diff --git a/LeanPool/ArnoldKAM.lean b/LeanPool/ArnoldKAM.lean
new file mode 100644
index 0000000000..1d8738ba53
--- /dev/null
+++ b/LeanPool/ArnoldKAM.lean
@@ -0,0 +1,23 @@
+/-
+Copyright (c) 2026 Bingqi Yu. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Bingqi Yu
+-/
+
+module
+
+public import LeanPool.ArnoldKAM.Arnold1963.Main.Theorem1
+public import LeanPool.ArnoldKAM.Arnold1963.Main.Theorem2
+public import LeanPool.ArnoldKAM.Arnold1963.Audit.W10Example
+public import LeanPool.ArnoldKAM.Arnold1963.Audit.W10Branches
+
+/-!
+# Analytic Hamiltonian KAM on compact action domains
+
+Source: doi:10.5281/zenodo.23232025
+Authors: Bingqi Yu
+Status: verified
+Main declarations: `KamProject.Arnold1963.theorem1`
+Tags: Hamiltonian dynamics, KAM theory, Fourier analysis, symplectic geometry
+MSC: 37J40, 37J35, 42A16
+-/
diff --git a/LeanPool/ArnoldKAM/Arnold1963/Analysis/AnalyticLift.lean b/LeanPool/ArnoldKAM/Arnold1963/Analysis/AnalyticLift.lean
new file mode 100644
index 0000000000..baf2b76256
--- /dev/null
+++ b/LeanPool/ArnoldKAM/Arnold1963/Analysis/AnalyticLift.lean
@@ -0,0 +1,118 @@
+/-
+Copyright (c) 2026 Bingqi Yu. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Bingqi Yu
+-/
+
+module
+
+public import LeanPool.ArnoldKAM.Arnold1963.Basic.Functions
+public import Mathlib.MeasureTheory.Integral.BoundedContinuousFunction
+public import Mathlib.MeasureTheory.Integral.Bochner.ContinuousLinearMap
+
+/-!
+Lift continuous multilinear maps and power series to bounded continuous function spaces.
+The norm bounds support analytic integration over compact parameter sets.
+-/
+
+@[expose] public section
+noncomputable section
+open MeasureTheory Set Filter
+open scoped Topology NNReal BoundedContinuousFunction
+namespace KamProject.Arnold1963
+
+variable {X E : Type*} [TopologicalSpace X] [NormedAddCommGroup E] [NormedSpace ℂ E]
+
+private theorem lift_bound {m : ℕ} (p : ContinuousMultilinearMap ℂ (fun _ : Fin m => E) ℂ)
+    (v : Fin m → X →ᵇ E) (x : X) :
+    ‖p (fun j => v j x)‖ ≤ ‖p‖ * ∏ j, ‖v j‖ := by
+  exact (p.le_opNorm _).trans (mul_le_mul_of_nonneg_left
+    (Finset.prod_le_prod₀ (fun _ _ => norm_nonneg _) (fun j _ => (v j).norm_coe_le_norm x))
+    (norm_nonneg _))
+
+omit [NormedSpace ℂ E] in
+private theorem eval_update {m : ℕ} [DecidableEq (Fin m)] (v : Fin m → X →ᵇ E) (i : Fin m)
+    (a : X →ᵇ E) (x : X) :
+    (fun j => Function.update v i a j x) = Function.update (fun j => v j x) i (a x) := by
+  ext j
+  by_cases h : j = i <;> simp [h]
+
+/-- Pointwise multilinear evaluation on bounded continuous functions, retaining an operator norm
+bound. -/
+def boundedMultilinearLift {m : ℕ}
+    (p : ContinuousMultilinearMap ℂ (fun _ : Fin m => E) ℂ) :
+    ContinuousMultilinearMap ℂ (fun _ : Fin m => X →ᵇ E) (X →ᵇ ℂ) :=
+  MultilinearMap.mkContinuous
+    { toFun := fun v => BoundedContinuousFunction.ofNormedAddCommGroup
+        (fun x => p (fun j => v j x))
+        (p.cont.comp (continuous_pi (fun j => (v j).continuous)))
+        (‖p‖ * ∏ j, ‖v j‖) (by exact lift_bound p v)
+      map_update_add' := by
+        intro _ v i a b
+        ext x
+        change p (fun j => Function.update v i (a + b) j x) =
+          p (fun j => Function.update v i a j x) + p (fun j => Function.update v i b j x)
+        simp only [eval_update, BoundedContinuousFunction.add_apply, p.map_update_add]
+      map_update_smul' := by
+        intro _ v i c a
+        ext x
+        change p (fun j => Function.update v i (c • a) j x) =
+          c • p (fun j => Function.update v i a j x)
+        simp only [eval_update, BoundedContinuousFunction.smul_apply, p.map_update_smul]
+        }
+    ‖p‖ (fun v => (BoundedContinuousFunction.norm_le (by positivity)).mpr
+      (by exact lift_bound p v))
+
+@[simp] theorem boundedMultilinearLift_apply {m : ℕ}
+    (p : ContinuousMultilinearMap ℂ (fun _ : Fin m => E) ℂ)
+    (v : Fin m → X →ᵇ E) (x : X) : boundedMultilinearLift p v x = p (fun j => v j x) := rfl
+
+theorem norm_boundedMultilinearLift_le {m : ℕ}
+    (p : ContinuousMultilinearMap ℂ (fun _ : Fin m => E) ℂ) :
+    ‖boundedMultilinearLift (X := X) p‖ ≤ ‖p‖ := by
+  apply ContinuousMultilinearMap.opNorm_le_bound (norm_nonneg _)
+  intro v
+  exact (BoundedContinuousFunction.norm_le (by positivity)).mpr (lift_bound p v)
+
+/-- A formal power series lifted coefficientwise to bounded continuous functions. -/
+def boundedSeriesLift (p : FormalMultilinearSeries ℂ E ℂ) :
+    FormalMultilinearSeries ℂ (X →ᵇ E) (X →ᵇ ℂ) := fun m => boundedMultilinearLift (p m)
+
+theorem radius_boundedSeriesLift_le (p : FormalMultilinearSeries ℂ E ℂ) :
+    p.radius ≤ (boundedSeriesLift (X := X) p).radius :=
+  FormalMultilinearSeries.radius_le_of_le (fun m => norm_boundedMultilinearLift_le (p m))
+
+theorem boundedSeriesLift_sum_apply (p : FormalMultilinearSeries ℂ E ℂ)
+    {v : X →ᵇ E} (hv : v ∈ Metric.eball 0 p.radius) (x : X) :
+    (boundedSeriesLift p).sum v x = p.sum (v x) := by
+  have hl : v ∈ Metric.eball 0 (boundedSeriesLift (X := X) p).radius :=
+    lt_of_lt_of_le hv (radius_boundedSeriesLift_le p)
+  have hs := (BoundedContinuousFunction.evalCLM ℂ x).hasSum
+    ((boundedSeriesLift p).summable hl).hasSum
+  have hx : v x ∈ Metric.eball 0 p.radius := by
+    have hv' : ENNReal.ofReal ‖v‖ < p.radius := by
+      simpa [Metric.mem_eball, edist_dist, dist_zero_right] using hv
+    simpa [Metric.mem_eball, edist_dist, dist_zero_right] using
+      (ENNReal.ofReal_le_ofReal (v.norm_coe_le_norm x)).trans_lt hv'
+  exact hs.unique (p.summable hx).hasSum
+
+/-- The continuous linear map sending a vector to its constant function. -/
+def boundedConstCLM : E →L[ℂ] (X →ᵇ E) :=
+  LinearMap.mkContinuous
+    { toFun := BoundedContinuousFunction.const X
+      map_add' := by intros; ext; rfl
+      map_smul' := by intros; ext; rfl }
+    1 (fun v => by simpa using BoundedContinuousFunction.norm_const_le (α := X) v)
+
+@[simp] theorem boundedConstCLM_apply (v : E) (x : X) : boundedConstCLM v x = v := rfl
+
+/-- Integration against a finite measure as a continuous complex linear functional. -/
+def boundedIntegralCLM [MeasurableSpace X] [OpensMeasurableSpace X]
+    (μ : Measure X) [IsFiniteMeasure μ] : (X →ᵇ ℂ) →L[ℂ] ℂ :=
+  LinearMap.mkContinuous
+    { toFun := fun f => ∫ x, f x ∂μ
+      map_add' := fun f g => integral_add (f.integrable μ) (g.integrable μ)
+      map_smul' := by intro c f; exact integral_smul c f }
+    (μ.real univ) (fun f => f.norm_integral_le_mul_norm μ)
+
+end KamProject.Arnold1963
diff --git a/LeanPool/ArnoldKAM/Arnold1963/Analysis/AnalyticUniformLimit.lean b/LeanPool/ArnoldKAM/Arnold1963/Analysis/AnalyticUniformLimit.lean
new file mode 100644
index 0000000000..b08404ca6a
--- /dev/null
+++ b/LeanPool/ArnoldKAM/Arnold1963/Analysis/AnalyticUniformLimit.lean
@@ -0,0 +1,157 @@
+/-
+Copyright (c) 2026 Bingqi Yu. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Bingqi Yu
+-/
+
+module
+
+public import LeanPool.ArnoldKAM.Arnold1963.Analysis.PolydiscCauchy
+public import Mathlib.Topology.UniformSpace.UniformConvergence
+public import Mathlib.Topology.Algebra.IsUniformGroup.Order
+public import Mathlib.MeasureTheory.Integral.DominatedConvergence
+
+/-!
+Analyticity of uniform limits on complex polydiscs, using the Cauchy integral formula and
+convergence of weighted integrals over compact sets.
+-/
+
+@[expose] public section
+noncomputable section
+open Set Metric MeasureTheory Complex Filter
+open scoped Topology ENNReal
+namespace KamProject.Arnold1963
+
+theorem analyticAt_cauchyIntegral {n : ℕ} {f : ComplexSpace n → ℂ}
+    {c w : ComplexSpace n} {r : RealSpace n} (hr : ∀ i, 0 ≤ r i)
+    (hf : ContinuousOn f (pi univ (fun i => closedBall (c i) (r i))))
+    (hw : ∀ i, w i ∈ ball (c i) (r i)) :
+    AnalyticAt ℂ (fun a => torusIntegral (fun z => cauchyKernel a z * f z) c r) w := by
+  let K : Set (RealSpace n) := Icc 0 (fun _ => 2 * Real.pi)
+  let μ : Measure (RealSpace n) := volume.restrict K
+  have : IsFiniteMeasure μ := ⟨by
+    change (volume.restrict K) univ < ⊤
+    rw [Measure.restrict_apply_univ]
+    exact isCompact_Icc.measure_lt_top⟩
+  let g : RealSpace n → ComplexSpace n × ℂ := fun t =>
+    (torusMap c r t, (∏ i, (r i : ℂ) * exp (t i * I) * I) * f (torusMap c r t))
+  let F : ComplexSpace n × (ComplexSpace n × ℂ) → ℂ :=
+    fun x => cauchyKernel x.1 x.2.1 * x.2.2
+  have hg : Continuous g := by
+    apply Continuous.prodMk (continuous_torusMap c r)
+    apply Continuous.mul
+    · fun_prop
+    · exact hf.comp_continuous (continuous_torusMap c r) (torusMap_mem_pi_closedBall c hr)
+  have hF : ∀ t ∈ K, AnalyticAt ℂ F (w, g t) := by
+    intro t _
+    apply AnalyticAt.mul
+    · apply Finset.analyticAt_fun_prod
+      intro i _
+      apply AnalyticAt.inv
+      · exact (((ContinuousLinearMap.proj (R := ℂ) (φ := fun _ : Fin n => ℂ) i).analyticAt _).comp
+          (analyticAt_fst.comp analyticAt_snd)).sub
+          (((ContinuousLinearMap.proj (R := ℂ) (φ := fun _ : Fin n => ℂ) i).analyticAt _).comp
+            analyticAt_fst)
+      · exact torusMap_sub_ne_zero hw t i
+    · exact analyticAt_snd.comp analyticAt_snd
+  have hA := analyticAt_integral_compact (μ := μ) hg (K := K) isCompact_Icc measurableSet_Icc hF
+  convert! hA using 1
+  funext a
+  simp only [F, g, cauchyKernel, torusIntegral, smul_eq_mul, μ,
+    Measure.restrict_restrict measurableSet_Icc, inter_self, K]
+  apply setIntegral_congr_fun measurableSet_Icc
+  intro t _
+  ring
+
+theorem tendsto_weightedIntegral_of_uniform_compact
+    {X : Type*} [TopologicalSpace X] [MeasurableSpace X] [OpensMeasurableSpace X]
+    {μ : Measure X} [IsFiniteMeasureOnCompacts μ] {K : Set X}
+    (hK : IsCompact K) (hKm : MeasurableSet K)
+    {F : ℕ → X → ℂ} {f a : X → ℂ} (hF : ∀ s, ContinuousOn (F s) K)
+    (ha : ContinuousOn a K) (hu : TendstoUniformlyOn F f atTop K) :
+    Tendsto (fun s => ∫ x in K, a x * F s x ∂μ) atTop
+      (𝓝 (∫ x in K, a x * f x ∂μ)) := by
+  have : IsFiniteMeasure (μ.restrict K) := ⟨by
+    rw [Measure.restrict_apply_univ]
+    exact hK.measure_lt_top⟩
+  obtain ⟨C, hC⟩ := hK.bddAbove_image
+    (hu.continuousOn (Eventually.of_forall hF).frequently).norm
+  obtain ⟨B, hB⟩ := hK.bddAbove_image ha.norm
+  apply tendsto_integral_filter_of_norm_le_const
+  · exact Eventually.of_forall fun s => (ha.mul (hF s)).aestronglyMeasurable hKm
+  · refine ⟨max B 0 * (C + 1), ?_⟩
+    have hb := (uniformContinuous_norm.comp_tendstoUniformlyOn hu).eventually_forall_le
+      (show C < C + 1 by linarith) (fun x hx => hC (mem_image_of_mem _ hx))
+    filter_upwards [hb] with s hs
+    filter_upwards [ae_restrict_mem hKm] with x hx
+    rw [norm_mul]
+    exact (mul_le_mul_of_nonneg_right
+      ((hB (mem_image_of_mem _ hx)).trans (le_max_left _ _)) (norm_nonneg _)).trans
+        (mul_le_mul_of_nonneg_left (hs x hx) (le_max_right _ _))
+  · filter_upwards [ae_restrict_mem hKm] with x hx
+    exact tendsto_const_nhds.mul (hu.tendsto_at hx)
+
+theorem analyticAt_uniform_limit_polydisc {n : ℕ} {F : ℕ → ComplexSpace n → ℂ}
+    {f : ComplexSpace n → ℂ} {c : ComplexSpace n} {R : ℝ} (hR : 0 < R)
+    (hF : ∀ s, AnalyticOnNhd ℂ (F s) (closedBall c R))
+    (hu : TendstoUniformlyOn F f atTop (closedBall c R)) : AnalyticAt ℂ f c := by
+  let r : RealSpace n := fun _ => R
+  have hp : closedBall c R = pi univ (fun i => closedBall (c i) (r i)) :=
+    closedBall_pi c hR.le
+  have hfc : ContinuousOn f (closedBall c R) :=
+    hu.continuousOn (Eventually.of_forall fun s => (hF s).continuousOn).frequently
+  have hm (t : RealSpace n) : torusMap c r t ∈ closedBall c R := by
+    rw [hp]
+    exact torusMap_mem_pi_closedBall c (fun _ => hR.le) t
+  have hc (w : ComplexSpace n) (hw : w ∈ ball c R) :
+      torusIntegral (fun z => cauchyKernel w z * f z) c r =
+        (2 * Real.pi * I : ℂ) ^ n * f w := by
+    have hw' : ∀ i, w i ∈ ball (c i) (r i) := by
+      simpa only [ball_pi c hR, mem_univ_pi] using hw
+    let a : RealSpace n → ℂ := fun t =>
+      (∏ i, (r i : ℂ) * exp (t i * I) * I) * cauchyKernel w (torusMap c r t)
+    have ha : Continuous a := by
+      apply Continuous.mul
+      · fun_prop
+      · apply continuous_finsetProd
+        intro i _
+        exact (((continuous_apply i).comp (continuous_torusMap c r)).sub
+          continuous_const).inv₀ (fun t => torusMap_sub_ne_zero hw' t i)
+    have ht := tendsto_weightedIntegral_of_uniform_compact
+      (μ := (volume : Measure (RealSpace n)))
+      (K := Icc (0 : RealSpace n) (fun _ => 2 * Real.pi)) isCompact_Icc measurableSet_Icc
+      (fun s => ((hF s).continuousOn.comp_continuous
+        (continuous_torusMap c r) hm).continuousOn) ha.continuousOn
+      ((hu.comp (torusMap c r)).mono (fun t _ => hm t))
+    have ht' : Tendsto (fun s => torusIntegral (fun z => cauchyKernel w z * F s z) c r)
+        atTop (𝓝 (torusIntegral (fun z => cauchyKernel w z * f z) c r)) := by
+      simpa only [torusIntegral, smul_eq_mul, a, mul_assoc, Function.comp_def] using! ht
+    have he (s : ℕ) := polydisc_cauchy (f := F s) (fun _ => hR) (hp ▸ hF s) hw'
+    have hs : Tendsto (fun s => torusIntegral (fun z => cauchyKernel w z * F s z) c r)
+        atTop (𝓝 ((2 * Real.pi * I : ℂ) ^ n * f w)) := by
+      exact (tendsto_const_nhds.mul (hu.tendsto_at (ball_subset_closedBall hw))).congr'
+        (Eventually.of_forall fun s => (he s).symm)
+    exact tendsto_nhds_unique ht' hs
+  have hA := analyticAt_cauchyIntegral (c := c) (w := c) (fun _ => hR.le)
+    (hp ▸ hfc) (fun i => mem_ball_self hR)
+  have hne : (2 * Real.pi * I : ℂ) ^ n ≠ 0 := by
+    apply pow_ne_zero
+    exact mul_ne_zero (mul_ne_zero (by norm_num) (by exact_mod_cast Real.pi_ne_zero)) I_ne_zero
+  apply (analyticAt_const.mul hA).congr
+    (g := f) (f := fun w => ((2 * Real.pi * I : ℂ) ^ n)⁻¹ *
+      torusIntegral (fun z => cauchyKernel w z * f z) c r)
+  filter_upwards [ball_mem_nhds c hR] with w hw
+  rw [hc w hw, ← mul_assoc, inv_mul_cancel₀ hne, one_mul]
+
+theorem analyticOnNhd_uniform_limit {n : ℕ} {U : Set (ComplexSpace n)}
+    (hU : IsOpen U) {F : ℕ → ComplexSpace n → ℂ} {f : ComplexSpace n → ℂ}
+    (hF : ∀ s, AnalyticOnNhd ℂ (F s) U) (hu : TendstoUniformlyOn F f atTop U) :
+    AnalyticOnNhd ℂ f U := by
+  intro c hc
+  obtain ⟨ε, hε, hsub⟩ := Metric.mem_nhds_iff.mp (hU.mem_nhds hc)
+  have hs : closedBall c (ε / 2) ⊆ U :=
+    (closedBall_subset_ball (half_lt_self hε)).trans hsub
+  exact analyticAt_uniform_limit_polydisc (half_pos hε)
+    (fun s => (hF s).mono hs) (hu.mono hs)
+
+end KamProject.Arnold1963
diff --git a/LeanPool/ArnoldKAM/Arnold1963/Analysis/BoxIntegral.lean b/LeanPool/ArnoldKAM/Arnold1963/Analysis/BoxIntegral.lean
new file mode 100644
index 0000000000..5dd9dde5cf
--- /dev/null
+++ b/LeanPool/ArnoldKAM/Arnold1963/Analysis/BoxIntegral.lean
@@ -0,0 +1,121 @@
+/-
+Copyright (c) 2026 Bingqi Yu. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Bingqi Yu
+-/
+
+module
+
+public import LeanPool.ArnoldKAM.Arnold1963.Basic.Spaces
+public import Mathlib.MeasureTheory.Integral.Pi
+public import Mathlib.MeasureTheory.Function.LocallyIntegrable
+public import Mathlib.MeasureTheory.Integral.IntervalIntegral.Basic
+
+/-!
+Unit-cube integration with product Lebesgue measure and coordinate-by-coordinate Fubini formulas.
+-/
+
+@[expose] public section
+noncomputable section
+open MeasureTheory Set
+namespace KamProject.Arnold1963
+
+/-- Lebesgue probability measure restricted to the closed unit interval. -/
+def unitIntervalMeasure : Measure ℝ := volume.restrict (Icc 0 1)
+
+instance : IsProbabilityMeasure unitIntervalMeasure := ⟨by
+  simp [unitIntervalMeasure, Real.volume_Icc]⟩
+
+/-- Product probability measure on the unit cube, used for normalized Fourier integration. -/
+def unitCubeMeasure (n : ℕ) : Measure (RealSpace n) :=
+  Measure.pi (fun _ : Fin n => unitIntervalMeasure)
+
+instance (n : ℕ) : IsProbabilityMeasure (unitCubeMeasure n) :=
+  inferInstanceAs (IsProbabilityMeasure (Measure.pi (fun _ : Fin n => unitIntervalMeasure)))
+
+/-- The closed unit cube in real coordinate space. -/
+def unitCube (n : ℕ) : Set (RealSpace n) := univ.pi (fun _ => Icc 0 1)
+
+/-- Integration over the unit cube with its product probability measure. -/
+def unitCubeIntegral {n : ℕ} (f : RealSpace n → ℂ) : ℂ := ∫ x, f x ∂unitCubeMeasure n
+
+theorem unitCubeMeasure_eq_restrict (n : ℕ) :
+    unitCubeMeasure n = volume.restrict (unitCube n) := by
+  change Measure.pi (fun _ : Fin n => volume.restrict (Icc (0 : ℝ) 1)) =
+    (Measure.pi (fun _ : Fin n => (volume : Measure ℝ))).restrict _
+  exact (Measure.restrict_pi_pi _ _).symm
+
+theorem ae_mem_unitCube (n : ℕ) : ∀ᵐ x ∂unitCubeMeasure n, x ∈ unitCube n := by
+  rw [unitCubeMeasure_eq_restrict]
+  exact ae_restrict_mem (MeasurableSet.univ_pi (fun _ => measurableSet_Icc))
+
+theorem integrable_unitCube {n : ℕ} {f : RealSpace n → ℂ}
+    (hf : ContinuousOn f (unitCube n)) : Integrable f (unitCubeMeasure n) := by
+  rw [unitCubeMeasure_eq_restrict]
+  exact hf.integrableOn_compact (isCompact_univ_pi (fun _ => isCompact_Icc))
+
+theorem unitCubeIntegral_congr {n : ℕ} {f g : RealSpace n → ℂ}
+    (h : ∀ x ∈ unitCube n, f x = g x) : unitCubeIntegral f = unitCubeIntegral g :=
+  integral_congr_ae ((ae_mem_unitCube n).mono fun x hx => h x hx)
+
+theorem norm_unitCubeIntegral_le {n : ℕ} {f : RealSpace n → ℂ} {M : ℝ}
+    (h : ∀ x ∈ unitCube n, ‖f x‖ ≤ M) : ‖unitCubeIntegral f‖ ≤ M := by
+  simpa only [unitCubeIntegral, probReal_univ, mul_one] using
+    norm_integral_le_of_norm_le_const ((ae_mem_unitCube n).mono fun x hx => h x hx)
+
+theorem integrable_cons_unitCube {n : ℕ} {f : RealSpace (n + 1) → ℂ}
+    (hf : Integrable f (unitCubeMeasure (n + 1))) :
+    Integrable (fun xy : ℝ × RealSpace n => f (Fin.cons xy.1 xy.2))
+      (unitIntervalMeasure.prod (unitCubeMeasure n)) := by
+  have hp := (measurePreserving_piFinSuccAbove
+    (fun _ : Fin (n + 1) => unitIntervalMeasure) 0).symm
+  have hi := (hp.integrable_comp_emb (MeasurableEquiv.measurableEmbedding _)).mpr hf
+  simpa only [MeasurableEquiv.piFinSuccAbove_symm_apply, Fin.insertNthEquiv,
+    Fin.insertNth_zero, Fin.zero_succAbove, Function.comp_def, Equiv.coe_fn_mk, cast_eq,
+    unitCubeMeasure] using hi
+
+theorem unitCubeIntegral_cons {n : ℕ} {f : RealSpace (n + 1) → ℂ}
+    (hf : Integrable f (unitCubeMeasure (n + 1))) :
+    unitCubeIntegral f = ∫ x, unitCubeIntegral (fun y => f (Fin.cons x y))
+      ∂unitIntervalMeasure := by
+  have hp := (measurePreserving_piFinSuccAbove
+    (fun _ : Fin (n + 1) => unitIntervalMeasure) 0).symm
+  unfold unitCubeIntegral unitCubeMeasure
+  rw [← hp.integral_comp']
+  simpa only [MeasurableEquiv.piFinSuccAbove_symm_apply, Fin.insertNthEquiv,
+    Fin.insertNth_zero, Fin.zero_succAbove, Function.comp_def, Equiv.coe_fn_mk, cast_eq,
+    unitCubeMeasure] using
+      integral_prod _ (integrable_cons_unitCube hf)
+
+theorem unitCubeIntegral_cons_symm {n : ℕ} {f : RealSpace (n + 1) → ℂ}
+    (hf : Integrable f (unitCubeMeasure (n + 1))) :
+    unitCubeIntegral f = ∫ y, (∫ x, f (Fin.cons x y) ∂unitIntervalMeasure)
+      ∂unitCubeMeasure n := by
+  have hp := (measurePreserving_piFinSuccAbove
+    (fun _ : Fin (n + 1) => unitIntervalMeasure) 0).symm
+  unfold unitCubeIntegral unitCubeMeasure
+  rw [← hp.integral_comp']
+  simpa only [MeasurableEquiv.piFinSuccAbove_symm_apply, Fin.insertNthEquiv,
+    Fin.insertNth_zero, Fin.zero_succAbove, Function.comp_def, Equiv.coe_fn_mk, cast_eq,
+    unitCubeMeasure] using
+      integral_prod_symm _ (integrable_cons_unitCube hf)
+
+theorem integral_unitInterval_eq_interval (f : ℝ → ℂ) :
+    (∫ x, f x ∂unitIntervalMeasure) = ∫ x in (0 : ℝ)..1, f x := by
+  rw [intervalIntegral.integral_of_le zero_le_one]
+  exact integral_Icc_eq_integral_Ioc
+
+theorem unitCubeMeasure_eq_restrict_Ioc (n : ℕ) :
+    unitCubeMeasure n = volume.restrict {x : RealSpace n | ∀ j, x j ∈ Ioc 0 1} := by
+  have he : {x : RealSpace n | ∀ j, x j ∈ Ioc 0 1} = univ.pi (fun _ => Ioc 0 1) := by
+    ext x
+    simp
+  rw [he]
+  change Measure.pi (fun _ : Fin n => volume.restrict (Icc (0 : ℝ) 1)) =
+    (Measure.pi (fun _ : Fin n => (volume : Measure ℝ))).restrict _
+  rw [Measure.restrict_pi_pi]
+  congr 1
+  funext j
+  exact (Measure.restrict_congr_set Ioc_ae_eq_Icc).symm
+
+end KamProject.Arnold1963
diff --git a/LeanPool/ArnoldKAM/Arnold1963/Analysis/Cauchy.lean b/LeanPool/ArnoldKAM/Arnold1963/Analysis/Cauchy.lean
new file mode 100644
index 0000000000..ec989c633e
--- /dev/null
+++ b/LeanPool/ArnoldKAM/Arnold1963/Analysis/Cauchy.lean
@@ -0,0 +1,99 @@
+/-
+Copyright (c) 2026 Bingqi Yu. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Bingqi Yu
+-/
+
+module
+
+public import LeanPool.ArnoldKAM.Arnold1963.Basic.Hamiltonian
+public import Mathlib.Analysis.Complex.Liouville
+public import Mathlib.Analysis.Calculus.Deriv.Mul
+
+/-!
+First derivative bounds from one-variable Cauchy estimates along complex lines. All ambient
+operator estimates use the specified maximum norm.
+-/
+
+@[expose] public section
+
+noncomputable section
+open scoped NNReal
+
+namespace KamProject.Arnold1963
+
+section Cauchy
+variable {E F : Type*} [NormedAddCommGroup E] [NormedSpace ℂ E]
+  [NormedAddCommGroup F] [NormedSpace ℂ F]
+
+theorem line_mem_of_mem_erosion {U : Set E} {r : ℝ≥0} {x v : E}
+    (hx : x ∈ erosion U r) (hv : ‖v‖ ≤ 1) {z : ℂ} (hz : ‖z‖ ≤ r) :
+    x + z • v ∈ U := by
+  apply hx
+  rw [Metric.mem_closedBall, dist_eq_norm, add_sub_cancel_left, norm_smul]
+  exact (mul_le_mul_of_nonneg_left hv (norm_nonneg z)).trans (by simpa using hz)
+
+theorem norm_fderiv_apply_le_div_of_mem_erosion {f : E → F} {U : Set E}
+    {r : ℝ≥0} {M : ℝ} {x v : E} (hr : 0 < r)
+    (hf : AnalyticOnNhd ℂ f U) (hM : NormBoundOn f U M)
+    (hx : x ∈ erosion U r) (hv : ‖v‖ ≤ 1) :
+    ‖fderiv ℂ f x v‖ ≤ M / r := by
+  let g : ℂ → F := fun z => f (x + z • v)
+  have hg : DifferentiableOn ℂ g (Metric.closedBall 0 (r : ℝ)) := by
+    intro z hz
+    have hz' : ‖z‖ ≤ (r : ℝ) := by simpa using hz
+    exact ((hf _ (line_mem_of_mem_erosion hx hv hz')).differentiableAt.comp z
+      ((differentiableAt_id.smul_const v).const_add x)).differentiableWithinAt
+  have hb : ∀ z ∈ Metric.sphere (0 : ℂ) (r : ℝ), ‖g z‖ ≤ M := by
+    intro z hz
+    exact hM.norm_le (line_mem_of_mem_erosion hx hv (by simpa using le_of_eq hz))
+  have hg0 : HasDerivAt g (fderiv ℂ f x v) 0 := by
+    have hline : HasDerivAt (fun z : ℂ => x + z • v) v 0 := by
+      simpa using ((hasDerivAt_id (0 : ℂ)).smul_const v).const_add x
+    have hf0 : HasFDerivAt f (fderiv ℂ f x) (x + (0 : ℂ) • v) := by
+      simpa using (hf x (erosion_subset U r hx)).differentiableAt.hasFDerivAt
+    simpa [g, Function.comp_def] using hf0.comp_hasDerivAt 0 hline
+  rw [← hg0.deriv]
+  exact Complex.norm_deriv_le_of_forall_mem_sphere_norm_le hr
+    (hg.diffContOnCl_ball (Set.Subset.refl _)) hb
+
+theorem norm_fderiv_le_div_of_mem_erosion {f : E → F} {U : Set E}
+    {r : ℝ≥0} {M : ℝ} {x : E} (hr : 0 < r)
+    (hf : AnalyticOnNhd ℂ f U) (hM : NormBoundOn f U M)
+    (hx : x ∈ erosion U r) : ‖fderiv ℂ f x‖ ≤ M / r := by
+  apply ContinuousLinearMap.opNorm_le_of_unit_norm (div_nonneg hM.nonneg r.coe_nonneg)
+  intro v hv
+  exact norm_fderiv_apply_le_div_of_mem_erosion hr hf hM hx hv.le
+
+end Cauchy
+
+theorem norm_pGradient_le_div {n : ℕ} {H : ComplexPhaseSpace n → ℂ}
+    {U : Set (ComplexPhaseSpace n)} {r : ℝ≥0} {M : ℝ} {x : ComplexPhaseSpace n}
+    (hr : 0 < r) (hH : AnalyticOnNhd ℂ H U) (hM : NormBoundOn H U M)
+    (hx : x ∈ erosion U r) : ‖pGradient H x‖ ≤ M / r := by
+  apply (complex_norm_le_iff _ (div_nonneg hM.nonneg r.coe_nonneg)).2
+  intro j
+  exact norm_fderiv_apply_le_div_of_mem_erosion hr hH hM hx (by simp)
+
+theorem norm_qGradient_le_div {n : ℕ} {H : ComplexPhaseSpace n → ℂ}
+    {U : Set (ComplexPhaseSpace n)} {r : ℝ≥0} {M : ℝ} {x : ComplexPhaseSpace n}
+    (hr : 0 < r) (hH : AnalyticOnNhd ℂ H U) (hM : NormBoundOn H U M)
+    (hx : x ∈ erosion U r) : ‖qGradient H x‖ ≤ M / r := by
+  apply (complex_norm_le_iff _ (div_nonneg hM.nonneg r.coe_nonneg)).2
+  intro j
+  exact norm_fderiv_apply_le_div_of_mem_erosion hr hH hM hx (by simp)
+
+theorem norm_hamiltonianVectorField_le_div {n : ℕ} {H : ComplexPhaseSpace n → ℂ}
+    {U : Set (ComplexPhaseSpace n)} {r : ℝ≥0} {M : ℝ} {x : ComplexPhaseSpace n}
+    (hr : 0 < r) (hH : AnalyticOnNhd ℂ H U) (hM : NormBoundOn H U M)
+    (hx : x ∈ erosion U r) : ‖hamiltonianVectorField H x‖ ≤ M / r :=
+  (norm_hamiltonianVectorField_le H x).trans
+    (norm_fderiv_le_div_of_mem_erosion hr hH hM hx)
+
+theorem AnalyticPhaseFunction.norm_vectorField_le_div {n : ℕ}
+    {G : Set (ComplexSpace n)} {ρ r : ℝ≥0} (f : AnalyticPhaseFunction n G ρ)
+    (hr : 0 < r) {x : ComplexPhaseSpace n} (hx : x ∈ erosion (phaseDomain G ρ) r) :
+    ‖hamiltonianVectorField f.toFun x‖ ≤ f.uniformNorm / r :=
+  norm_hamiltonianVectorField_le_div hr f.analytic (f.norm_le_iff.mp le_rfl) hx
+
+end KamProject.Arnold1963
diff --git a/LeanPool/ArnoldKAM/Arnold1963/Analysis/ContourShift.lean b/LeanPool/ArnoldKAM/Arnold1963/Analysis/ContourShift.lean
new file mode 100644
index 0000000000..6e9d17b4ff
--- /dev/null
+++ b/LeanPool/ArnoldKAM/Arnold1963/Analysis/ContourShift.lean
@@ -0,0 +1,112 @@
+/-
+Copyright (c) 2026 Bingqi Yu. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Bingqi Yu
+-/
+
+module
+
+public import Mathlib.Analysis.Complex.CauchyIntegral
+public import Mathlib.Analysis.SpecialFunctions.Trigonometric.Basic
+public import Mathlib.Tactic.Ring
+
+/-!
+One-variable contour shifts and exponential decay bounds for normalized Fourier integrals.
+-/
+
+@[expose] public section
+noncomputable section
+open Complex Set
+namespace KamProject.Arnold1963
+
+theorem integral_horizontal_shift {E : Type*}
+    [NormedAddCommGroup E] [NormedSpace ℂ E]
+    (f : ℂ → E) (T a b : ℝ)
+    (hf : DifferentiableOn ℂ f (uIcc 0 T ×ℂ uIcc a b))
+    (hperiod : ∀ y ∈ uIcc a b, f ((T : ℂ) + y * I) = f (y * I)) :
+    (∫ x : ℝ in 0..T, f (x + a * I)) =
+      ∫ x : ℝ in 0..T, f (x + b * I) := by
+  have h := integral_boundary_rect_eq_zero_of_differentiableOn f
+    ((a : ℂ) * I) ((T : ℂ) + b * I) (by simpa using hf)
+  have he : (∫ y : ℝ in a..b, f ((T : ℂ) + y * I)) =
+      ∫ y : ℝ in a..b, f (y * I) := intervalIntegral.integral_congr hperiod
+  simp only [add_re, mul_re, ofReal_re, I_re, mul_zero, ofReal_im, I_im,
+    mul_one, sub_self, zero_add, add_im, mul_im, add_zero] at h
+  rw [he] at h
+  have hz : (∫ x : ℝ in 0..T, f (x + a * I)) -
+      (∫ x : ℝ in 0..T, f (x + b * I)) = 0 := by
+    simpa only [ofReal_zero, zero_add, add_sub_cancel_right] using h
+  exact sub_eq_zero.mp hz
+
+theorem integral_fourier_horizontal_shift (f : ℂ → ℂ) (k : ℤ) (y : ℝ)
+    (hf : DifferentiableOn ℂ f (uIcc 0 (2 * Real.pi) ×ℂ uIcc 0 y))
+    (hperiod : ∀ t ∈ uIcc 0 y,
+      f ((2 * Real.pi : ℝ) + t * I) = f (t * I)) :
+    (∫ x : ℝ in 0..2 * Real.pi, f x * exp (-I * k * x)) =
+      ∫ x : ℝ in 0..2 * Real.pi,
+        f (x + y * I) * exp (-I * k * (x + y * I)) := by
+  have hg : Differentiable ℂ (fun z : ℂ => exp (-I * k * z)) := by fun_prop
+  have hs := integral_horizontal_shift (fun z => f z * exp (-I * k * z))
+    (2 * Real.pi) 0 y (hf.mul hg.differentiableOn) (by
+      intro t ht
+      rw [hperiod t ht]
+      have he : -I * (k : ℂ) * ((2 * Real.pi : ℝ) + t * I) =
+          -I * k * (t * I) + (-k : ℤ) * (2 * Real.pi * I) := by
+        push_cast
+        ring
+      rw [he, exp_add, exp_int_mul_two_pi_mul_I, mul_one])
+  simpa only [ofReal_zero, zero_mul, add_zero] using hs
+
+theorem norm_integral_fourier_le_on_shift (f : ℂ → ℂ) (k : ℤ) (y M : ℝ)
+    (hf : DifferentiableOn ℂ f (uIcc 0 (2 * Real.pi) ×ℂ uIcc 0 y))
+    (hperiod : ∀ t ∈ uIcc 0 y,
+      f ((2 * Real.pi : ℝ) + t * I) = f (t * I))
+    (hbound : ∀ x ∈ uIcc 0 (2 * Real.pi), ‖f (x + y * I)‖ ≤ M) :
+    ‖∫ x : ℝ in 0..2 * Real.pi, f x * exp (-I * k * x)‖ ≤
+      (M * Real.exp ((k : ℝ) * y)) * (2 * Real.pi) := by
+  rw [integral_fourier_horizontal_shift f k y hf hperiod]
+  have hb : ∀ x ∈ uIoc 0 (2 * Real.pi),
+      ‖f (x + y * I) * exp (-I * k * (x + y * I))‖ ≤ M * Real.exp ((k : ℝ) * y) := by
+    intro x hx
+    have he : (-I * (k : ℂ) * (x + y * I)).re = (k : ℝ) * y := by
+      simp [mul_re, mul_im]
+    rw [norm_mul, norm_exp, he]
+    exact mul_le_mul_of_nonneg_right (hbound x (uIoc_subset_uIcc hx)) (Real.exp_pos _).le
+  have h := intervalIntegral.norm_integral_le_of_norm_le_const hb
+  have hT : (0 : ℝ) < 2 * Real.pi := by positivity
+  simpa only [sub_zero, abs_of_pos hT] using h
+
+theorem norm_normalized_fourierIntegral_le (f : ℂ → ℂ) (k : ℤ) {ρ M : ℝ}
+    (hρ : 0 ≤ ρ)
+    (hf : DifferentiableOn ℂ f {z | |z.im| ≤ ρ})
+    (hperiod : ∀ z : ℂ, |z.im| ≤ ρ → f (z + (2 * Real.pi : ℝ)) = f z)
+    (hbound : ∀ z : ℂ, |z.im| ≤ ρ → ‖f z‖ ≤ M) :
+    ‖(∫ x : ℝ in 0..2 * Real.pi, f x * exp (-I * k * x)) /
+        (2 * Real.pi : ℝ)‖ ≤ M * Real.exp (-|(k : ℝ)| * ρ) := by
+  let y : ℝ := if 0 ≤ k then -ρ else ρ
+  have hy : |y| ≤ ρ := by dsimp [y]; split_ifs <;> simp [abs_of_nonneg hρ]
+  have ht : ∀ t ∈ uIcc 0 y, |t| ≤ ρ := by
+    intro t ht
+    exact abs_le.mpr (uIcc_subset_Icc ⟨by linarith, hρ⟩ (abs_le.mp hy) ht)
+  have hrect : DifferentiableOn ℂ f (uIcc 0 (2 * Real.pi) ×ℂ uIcc 0 y) :=
+    hf.mono (fun z hz => ht z.im hz.2)
+  have hp : ∀ t ∈ uIcc 0 y, f ((2 * Real.pi : ℝ) + t * I) = f (t * I) := by
+    intro t htt
+    simpa only [add_comm] using hperiod ((t : ℂ) * I) (by simpa using ht t htt)
+  have hb : ∀ x ∈ uIcc 0 (2 * Real.pi), ‖f (x + y * I)‖ ≤ M := by
+    intro x _
+    exact hbound _ (by simpa using hy)
+  have he : (k : ℝ) * y = -|(k : ℝ)| * ρ := by
+    dsimp [y]
+    split_ifs with hk
+    · rw [abs_of_nonneg (by exact_mod_cast hk)]
+      ring
+    · rw [abs_of_neg (by exact_mod_cast (lt_of_not_ge hk))]
+      ring
+  have h := norm_integral_fourier_le_on_shift f k y M hrect hp hb
+  rw [he] at h
+  have hT : (0 : ℝ) < 2 * Real.pi := by positivity
+  rw [norm_div, Complex.norm_real, Real.norm_eq_abs, abs_of_pos hT]
+  exact (div_le_iff₀ hT).mpr h
+
+end KamProject.Arnold1963
diff --git a/LeanPool/ArnoldKAM/Arnold1963/Analysis/DomainBuffer.lean b/LeanPool/ArnoldKAM/Arnold1963/Analysis/DomainBuffer.lean
new file mode 100644
index 0000000000..54d013b9fd
--- /dev/null
+++ b/LeanPool/ArnoldKAM/Arnold1963/Analysis/DomainBuffer.lean
@@ -0,0 +1,117 @@
+/-
+Copyright (c) 2026 Bingqi Yu. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Bingqi Yu
+-/
+
+module
+
+public import LeanPool.ArnoldKAM.Arnold1963.Analysis.Cauchy
+public import Mathlib.Tactic.Linarith
+
+/-!
+Rectangular action and angle buffers for Cauchy estimates on eroded phase domains.
+-/
+
+@[expose] public section
+
+noncomputable section
+open scoped NNReal
+namespace KamProject.Arnold1963
+
+theorem mem_angleStrip_of_dist_le {n : ℕ} {ρ δ : ℝ≥0} (hδρ : δ ≤ ρ)
+    {q q' : ComplexSpace n} (hq : q ∈ angleStrip n (ρ - δ))
+    (hd : dist q' q ≤ δ) : q' ∈ angleStrip n ρ := by
+  apply (mem_angleStrip_iff _ _).2
+  intro j
+  have hx := (mem_angleStrip_iff _ _).1 hq j
+  rw [NNReal.coe_sub hδρ] at hx
+  have hv : |(q' j - q j).im| ≤ (δ : ℝ) :=
+    (Complex.abs_im_le_norm _).trans ((norm_le_pi_norm (q' - q) j).trans
+      (by simpa [dist_eq_norm] using hd))
+  have heq : (q' j).im = (q' j - q j).im + (q j).im := by simp
+  rw [heq]
+  exact (abs_add_le _ _).trans (by linarith)
+
+theorem phaseDomain_rectangular_buffer {n : ℕ} {G : Set (ComplexSpace n)}
+    {ρ β δ : ℝ≥0} (hδρ : δ ≤ ρ) {p q : ComplexSpace n}
+    (hx : (p, q) ∈ phaseDomain (erosion G β) (ρ - δ)) :
+    Metric.closedBall p β ×ˢ Metric.closedBall q δ ⊆ phaseDomain G ρ := by
+  intro y hy
+  exact ⟨hx.1 hy.1, mem_angleStrip_of_dist_le hδρ hx.2 hy.2⟩
+
+theorem phaseDomain_shrink_subset_erosion {n : ℕ} (G : Set (ComplexSpace n))
+    {ρ r : ℝ≥0} (hrρ : r ≤ ρ) :
+    phaseDomain (erosion G r) (ρ - r) ⊆ erosion (phaseDomain G ρ) r := by
+  intro x hx y hy
+  have hnorm : max ‖y.1 - x.1‖ ‖y.2 - x.2‖ ≤ (r : ℝ) := by
+    simpa [Metric.mem_closedBall, dist_eq_norm, phase_norm_eq] using hy
+  have hp : ‖y.1 - x.1‖ ≤ (r : ℝ) := (le_max_left _ _).trans hnorm
+  have hq : ‖y.2 - x.2‖ ≤ (r : ℝ) := (le_max_right _ _).trans hnorm
+  refine ⟨hx.1 (by simpa [Metric.mem_closedBall, dist_eq_norm] using hp), ?_⟩
+  apply (mem_angleStrip_iff _ _).2
+  intro j
+  have hxq := (mem_angleStrip_iff _ _).1 hx.2 j
+  rw [NNReal.coe_sub hrρ] at hxq
+  have hd : |(y.2 j - x.2 j).im| ≤ (r : ℝ) :=
+    (Complex.abs_im_le_norm _).trans ((norm_le_pi_norm (y.2 - x.2) j).trans hq)
+  have heq : (y.2 j).im = (y.2 j - x.2 j).im + (x.2 j).im := by simp
+  rw [heq]
+  exact (abs_add_le _ _).trans (by linarith)
+
+theorem AnalyticPhaseFunction.norm_vectorField_le_on_shrink {n : ℕ}
+    {G : Set (ComplexSpace n)} {ρ r : ℝ≥0} (f : AnalyticPhaseFunction n G ρ)
+    (hr : 0 < r) (hrρ : r ≤ ρ) {x : ComplexPhaseSpace n}
+    (hx : x ∈ phaseDomain (erosion G r) (ρ - r)) :
+    ‖hamiltonianVectorField f.toFun x‖ ≤ f.uniformNorm / r :=
+  f.norm_vectorField_le_div hr (phaseDomain_shrink_subset_erosion G hrρ hx)
+
+theorem AnalyticPhaseFunction.norm_pGradient_le_rectangular {n : ℕ}
+    {G : Set (ComplexSpace n)} {ρ β : ℝ≥0} (f : AnalyticPhaseFunction n G ρ)
+    (hβ : 0 < β) {p q : ComplexSpace n}
+    (hp : p ∈ erosion G β) (hq : q ∈ angleStrip n ρ) :
+    ‖pGradient f.toFun (p, q)‖ ≤ f.uniformNorm / β := by
+  let g : ComplexSpace n → ℂ := fun p => f.toFun (p, q)
+  have hg : AnalyticOnNhd ℂ g G := by
+    intro p hp
+    exact (f.analytic (p, q) ⟨hp, hq⟩).comp (f := fun x : ComplexSpace n => (x, q))
+      (analyticAt_id.prod analyticAt_const)
+  have hb : NormBoundOn g G f.uniformNorm :=
+    ⟨(f.norm_le_iff.mp le_rfl).nonneg,
+      fun p hp => (f.norm_le_iff.mp le_rfl).norm_le ⟨hp, hq⟩⟩
+  have hd := (f.hasFDerivAt (x := (p, q)) ⟨erosion_subset G β hp, hq⟩).comp p
+    ((hasFDerivAt_id (𝕜 := ℂ) p).prodMk (hasFDerivAt_const q p))
+  apply (complex_norm_le_iff _ (div_nonneg hb.nonneg β.coe_nonneg)).2
+  intro j
+  have h := norm_fderiv_apply_le_div_of_mem_erosion (f := g) (x := p) hβ hg hb hp
+    (show ‖Pi.single j (1 : ℂ)‖ ≤ 1 by rw [Pi.norm_single]; norm_num)
+  change ‖fderiv ℂ g p (Pi.single j 1)‖ ≤ _ at h
+  rw [show fderiv ℂ g p = _ from hd.fderiv] at h
+  exact h
+
+theorem AnalyticPhaseFunction.norm_qGradient_le_rectangular {n : ℕ}
+    {G : Set (ComplexSpace n)} {ρ δ : ℝ≥0} (f : AnalyticPhaseFunction n G ρ)
+    (hδ : 0 < δ) (hδρ : δ ≤ ρ) {p q : ComplexSpace n}
+    (hp : p ∈ G) (hq : q ∈ angleStrip n (ρ - δ)) :
+    ‖qGradient f.toFun (p, q)‖ ≤ f.uniformNorm / δ := by
+  let g : ComplexSpace n → ℂ := fun q => f.toFun (p, q)
+  have hg : AnalyticOnNhd ℂ g (angleStrip n ρ) := by
+    intro q hq
+    exact (f.analytic (p, q) ⟨hp, hq⟩).comp (f := fun x : ComplexSpace n => (p, x))
+      (analyticAt_const.prod analyticAt_id)
+  have hb : NormBoundOn g (angleStrip n ρ) f.uniformNorm :=
+    ⟨(f.norm_le_iff.mp le_rfl).nonneg,
+      fun q hq => (f.norm_le_iff.mp le_rfl).norm_le ⟨hp, hq⟩⟩
+  have hq' : q ∈ erosion (angleStrip n ρ) δ :=
+    fun _ hx => mem_angleStrip_of_dist_le hδρ hq hx
+  have hd := (f.hasFDerivAt (x := (p, q)) ⟨hp, erosion_subset _ _ hq'⟩).comp q
+    ((hasFDerivAt_const p q).prodMk (hasFDerivAt_id (𝕜 := ℂ) q))
+  apply (complex_norm_le_iff _ (div_nonneg hb.nonneg δ.coe_nonneg)).2
+  intro j
+  have h := norm_fderiv_apply_le_div_of_mem_erosion (f := g) (x := q) hδ hg hb hq'
+    (show ‖Pi.single j (1 : ℂ)‖ ≤ 1 by rw [Pi.norm_single]; norm_num)
+  change ‖fderiv ℂ g q (Pi.single j 1)‖ ≤ _ at h
+  rw [show fderiv ℂ g q = _ from hd.fderiv] at h
+  exact h
+
+end KamProject.Arnold1963
diff --git a/LeanPool/ArnoldKAM/Arnold1963/Analysis/FourierCoefficients.lean b/LeanPool/ArnoldKAM/Arnold1963/Analysis/FourierCoefficients.lean
new file mode 100644
index 0000000000..50378774d9
--- /dev/null
+++ b/LeanPool/ArnoldKAM/Arnold1963/Analysis/FourierCoefficients.lean
@@ -0,0 +1,218 @@
+/-
+Copyright (c) 2026 Bingqi Yu. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Bingqi Yu
+-/
+
+module
+
+public import LeanPool.ArnoldKAM.Arnold1963.Basic.FunctionOperations
+public import LeanPool.ArnoldKAM.Arnold1963.Analysis.FourierPolynomial
+public import Mathlib.Analysis.Fourier.AddCircleMulti
+
+/-!
+Fourier coefficients and angle averages from Haar integration on the unit torus, linked to
+the physical angle period by scaling. The coefficients have uniform bounds and conjugation laws.
+-/
+
+@[expose] public section
+noncomputable section
+open MeasureTheory
+open scoped NNReal
+namespace KamProject.Arnold1963
+
+/-- Normalized Haar measure for the unit circle used in Fourier coefficient integrals. -/
+local instance fourierCoefficientMeasureSpace : MeasureSpace UnitAddCircle :=
+  ⟨AddCircle.haarAddCircle⟩
+local instance : IsProbabilityMeasure (volume : Measure UnitAddCircle) :=
+  inferInstanceAs (IsProbabilityMeasure AddCircle.haarAddCircle)
+
+/-- Representatives of unit torus coordinates in the interval `(0, 1]`. -/
+def unitTorusRepr {n : ℕ} (t : UnitAddTorus (Fin n)) : RealSpace n :=
+  fun j => (AddCircle.equivIoc 1 0 (t j)).1
+
+/-- Real unit-period coordinates embedded as complex angles with period `2π`. -/
+def scaledAngle {n : ℕ} (t : RealSpace n) : ComplexSpace n :=
+  complexify (fun j => 2 * Real.pi * t j)
+
+theorem continuous_scaledAngle (n : ℕ) : Continuous (scaledAngle (n := n)) := by
+  unfold scaledAngle
+  exact (continuous_complexify n).comp (by fun_prop)
+
+theorem scaledAngle_mem_strip {n : ℕ} (t : RealSpace n) (ρ : ℝ≥0) :
+    scaledAngle t ∈ angleStrip n ρ := complexify_mem_angleStrip _ _
+
+theorem mFourier_eq_fourierMonomial {n : ℕ} (k : FourierIndex n) (t : RealSpace n) :
+    UnitAddTorus.mFourier k (fun j => (t j : UnitAddCircle)) =
+      fourierMonomial k (scaledAngle t) := by
+  simp only [UnitAddTorus.mFourier, ContinuousMap.coe_mk, fourier_coe_apply,
+    Complex.ofReal_one, div_one]
+  rw [← Complex.exp_sum]
+  unfold fourierMonomial indexPairing
+  rw [Finset.mul_sum]
+  congr 1
+  apply Finset.sum_congr rfl
+  intro j _
+  simp only [scaledAngle, complexify, Complex.ofReal_mul, Complex.ofReal_ofNat]
+  ring
+
+namespace AnalyticPhaseFunction
+variable {n : ℕ} {G : Set (ComplexSpace n)} {ρ : ℝ≥0}
+
+/-- Evaluation of a periodic phase function on the unit torus at a fixed action. -/
+def torusValue (f : AnalyticPhaseFunction n G ρ) (p : ComplexSpace n)
+    (t : UnitAddTorus (Fin n)) : ℂ := f.toFun (p, scaledAngle (unitTorusRepr t))
+
+theorem torusValue_coe (f : AnalyticPhaseFunction n G ρ) {p : ComplexSpace n}
+    (hp : p ∈ G) (t : RealSpace n) :
+    f.torusValue p (fun j => (t j : UnitAddCircle)) = f.toFun (p, scaledAngle t) := by
+  classical
+  have hex : ∀ j : Fin n, ∃ k : ℤ,
+      (unitTorusRepr (fun j => (t j : UnitAddCircle)) j) = t j + k := by
+    intro j
+    have he : ((unitTorusRepr (fun j => (t j : UnitAddCircle)) j - t j : ℝ) :
+        UnitAddCircle) = 0 := by
+      simp [unitTorusRepr, AddCircle.coe_equivIoc]
+    obtain ⟨k, hk⟩ := (AddCircle.coe_eq_zero_iff (p := (1 : ℝ))).mp he
+    refine ⟨k, ?_⟩
+    simp only [zsmul_eq_mul, mul_one] at hk
+    linarith
+  choose k hk using hex
+  have heq : scaledAngle (unitTorusRepr (fun j => (t j : UnitAddCircle))) =
+      scaledAngle t + angleShift k := by
+    ext j
+    simp [scaledAngle, complexify, angleShift, hk, mul_add]
+  unfold torusValue
+  rw [heq]
+  exact f.periodic p hp _ (scaledAngle_mem_strip _ _) k
+
+theorem continuous_torusValue (f : AnalyticPhaseFunction n G ρ)
+    {p : ComplexSpace n} (hp : p ∈ G) : Continuous (f.torusValue p) := by
+  have hquot : IsOpenQuotientMap
+      (fun t : RealSpace n => (fun j => (t j : UnitAddCircle))) :=
+    IsOpenQuotientMap.piMap (fun _ : Fin n => QuotientAddGroup.isOpenQuotientMap_mk)
+  apply hquot.continuous_comp_iff.mp
+  have he : f.torusValue p ∘ (fun t : RealSpace n => fun j => (t j : UnitAddCircle)) =
+      fun t => f.toFun (p, scaledAngle t) := funext (f.torusValue_coe hp)
+  rw [he]
+  exact f.analytic.continuousOn.comp_continuous
+    (continuous_const.prodMk (continuous_scaledAngle n))
+    (fun t => ⟨hp, scaledAngle_mem_strip t ρ⟩)
+
+/-- The continuous unit-torus function obtained by fixing an action in the domain. -/
+def onUnitTorus (f : AnalyticPhaseFunction n G ρ) (p : G) :
+    C(UnitAddTorus (Fin n), ℂ) := ⟨f.torusValue p, f.continuous_torusValue p.property⟩
+
+/-- The normalized torus Fourier coefficient at a fixed complex action. -/
+def fourierCoeff (f : AnalyticPhaseFunction n G ρ) (p : ComplexSpace n)
+    (k : FourierIndex n) : ℂ := UnitAddTorus.mFourierCoeff (f.torusValue p) k
+
+/-- The zero Fourier coefficient, representing the angle average. -/
+def angleAverage (f : AnalyticPhaseFunction n G ρ) (p : ComplexSpace n) : ℂ :=
+  f.fourierCoeff p 0
+
+theorem fourierCoeff_eq_integral (f : AnalyticPhaseFunction n G ρ)
+    (p : ComplexSpace n) (k : FourierIndex n) :
+    f.fourierCoeff p k = UnitAddTorus.mFourierCoeff (f.torusValue p) k := rfl
+
+theorem norm_onUnitTorus_le (f : AnalyticPhaseFunction n G ρ) (p : G) :
+    ‖f.onUnitTorus p‖ ≤ f.uniformNorm := by
+  apply (ContinuousMap.norm_le _ ((f.norm_le_iff.mp le_rfl).nonneg)).mpr
+  intro t
+  exact (f.norm_le_iff.mp le_rfl).norm_le ⟨p.property, scaledAngle_mem_strip _ _⟩
+
+theorem norm_fourierCoeff_le (f : AnalyticPhaseFunction n G ρ)
+    {p : ComplexSpace n} (hp : p ∈ G) (k : FourierIndex n) :
+    ‖f.fourierCoeff p k‖ ≤ f.uniformNorm := by
+  unfold fourierCoeff UnitAddTorus.mFourierCoeff
+  have hb : ∀ᵐ t : UnitAddTorus (Fin n),
+      ‖UnitAddTorus.mFourier (-k) t • f.torusValue p t‖ ≤ f.uniformNorm := by
+    apply Filter.Eventually.of_forall
+    intro t
+    rw [norm_smul]
+    have he : ‖UnitAddTorus.mFourier (-k) t‖ ≤ 1 := by
+      simpa only [UnitAddTorus.mFourier_norm] using
+        (UnitAddTorus.mFourier (-k)).norm_coe_le_norm t
+    have hf : ‖f.torusValue p t‖ ≤ f.uniformNorm :=
+      (f.norm_le_iff.mp le_rfl).norm_le ⟨hp, scaledAngle_mem_strip _ _⟩
+    exact (mul_le_mul_of_nonneg_right he (norm_nonneg _)).trans (by simpa using hf)
+  simpa using norm_integral_le_of_norm_le_const hb
+
+theorem norm_angleAverage_le (f : AnalyticPhaseFunction n G ρ)
+    {p : ComplexSpace n} (hp : p ∈ G) : ‖f.angleAverage p‖ ≤ f.uniformNorm :=
+  f.norm_fourierCoeff_le hp 0
+
+theorem angleAverage_eq_integral (f : AnalyticPhaseFunction n G ρ)
+    (p : ComplexSpace n) :
+    f.angleAverage p = ∫ t : UnitAddTorus (Fin n), f.torusValue p t := by
+  simp [angleAverage, fourierCoeff, UnitAddTorus.mFourierCoeff, UnitAddTorus.mFourier_zero]
+
+theorem norm_sub_angleAverage_le (f : AnalyticPhaseFunction n G ρ)
+    {p q : ComplexSpace n} (hp : p ∈ G) (hq : q ∈ angleStrip n ρ) :
+    ‖f.toFun (p, q) - f.angleAverage p‖ ≤ 2 * f.uniformNorm := by
+  calc
+    _ ≤ ‖f.toFun (p, q)‖ + ‖f.angleAverage p‖ := norm_sub_le _ _
+    _ ≤ f.uniformNorm + f.uniformNorm :=
+      add_le_add ((f.norm_le_iff.mp le_rfl).norm_le ⟨hp, hq⟩) (f.norm_angleAverage_le hp)
+    _ = _ := by ring
+
+theorem fourierCoeff_eq_cubeIntegral (f : AnalyticPhaseFunction n G ρ)
+    {p : ComplexSpace n} (hp : p ∈ G) (k : FourierIndex n) :
+    f.fourierCoeff p k =
+      ∫ t : RealSpace n in {t | ∀ j, t j ∈ Set.Ioc 0 1},
+        UnitAddTorus.mFourier (-k) (fun j => (t j : UnitAddCircle)) *
+          f.toFun (p, scaledAngle t) := by
+  rw [fourierCoeff, UnitAddTorus.mFourierCoeff_eq_integral _ _ (0 : RealSpace n)]
+  simp only [Pi.zero_apply, zero_add, smul_eq_mul, f.torusValue_coe hp]
+
+theorem torusValue_conj (f : AnalyticPhaseFunction n G ρ)
+    {p : ComplexSpace n} (hp : p ∈ G) (t : UnitAddTorus (Fin n)) :
+    f.torusValue (conjVec p) t = star (f.torusValue p t) := by
+  simpa only [torusValue, conjPhase, scaledAngle, conjVec_complexify] using
+    f.conj_compatible (p, scaledAngle (unitTorusRepr t))
+      ⟨hp, scaledAngle_mem_strip _ _⟩
+
+theorem fourierCoeff_conj (f : AnalyticPhaseFunction n G ρ)
+    {p : ComplexSpace n} (hp : p ∈ G) (k : FourierIndex n) :
+    f.fourierCoeff (conjVec p) (-k) = star (f.fourierCoeff p k) := by
+  unfold fourierCoeff UnitAddTorus.mFourierCoeff
+  change _ = (starRingEnd ℂ) (∫ t : UnitAddTorus (Fin n),
+    UnitAddTorus.mFourier (-k) t • f.torusValue p t)
+  rw [← integral_conj]
+  apply integral_congr_ae
+  apply Filter.Eventually.of_forall
+  intro t
+  dsimp only
+  rw [f.torusValue_conj hp]
+  simp [smul_eq_mul, UnitAddTorus.mFourier_neg]
+
+theorem angleAverage_conj (f : AnalyticPhaseFunction n G ρ)
+    {p : ComplexSpace n} (hp : p ∈ G) :
+    f.angleAverage (conjVec p) = star (f.angleAverage p) := by
+  simpa only [angleAverage, neg_zero] using f.fourierCoeff_conj hp 0
+
+theorem angleAverage_real_value (f : AnalyticPhaseFunction n G ρ)
+    (p : RealSpace n) (hp : complexify p ∈ G) :
+    (f.angleAverage (complexify p)).im = 0 := by
+  apply Complex.conj_eq_iff_im.mp
+  simpa only [conjVec_complexify, starRingEnd_apply] using (f.angleAverage_conj hp).symm
+
+@[simp] theorem fourierCoeff_restrict (f : AnalyticPhaseFunction n G ρ)
+    {U : Set (ComplexSpace n)} {σ : ℝ≥0} (hUG : U ⊆ G)
+    (hσρ : σ ≤ ρ) (hU : ConjInvariant U) (p : ComplexSpace n) (k : FourierIndex n) :
+    (f.restrict hUG hσρ hU).fourierCoeff p k = f.fourierCoeff p k := rfl
+
+@[simp] theorem angleAverage_restrict (f : AnalyticPhaseFunction n G ρ)
+    {U : Set (ComplexSpace n)} {σ : ℝ≥0} (hUG : U ⊆ G)
+    (hσρ : σ ≤ ρ) (hU : ConjInvariant U) (p : ComplexSpace n) :
+    (f.restrict hUG hσρ hU).angleAverage p = f.angleAverage p := rfl
+
+theorem integral_centered_eq_zero (f : AnalyticPhaseFunction n G ρ)
+    {p : ComplexSpace n} (hp : p ∈ G) :
+    (∫ t : UnitAddTorus (Fin n), f.torusValue p t - f.angleAverage p) = 0 := by
+  rw [integral_sub ((f.continuous_torusValue hp).integrable_of_hasCompactSupport
+    (HasCompactSupport.of_compactSpace _)) (integrable_const _)]
+  simp [← f.angleAverage_eq_integral]
+
+end AnalyticPhaseFunction
+end KamProject.Arnold1963
diff --git a/LeanPool/ArnoldKAM/Arnold1963/Analysis/FourierDecay.lean b/LeanPool/ArnoldKAM/Arnold1963/Analysis/FourierDecay.lean
new file mode 100644
index 0000000000..ad84032ec8
--- /dev/null
+++ b/LeanPool/ArnoldKAM/Arnold1963/Analysis/FourierDecay.lean
@@ -0,0 +1,174 @@
+/-
+Copyright (c) 2026 Bingqi Yu. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Bingqi Yu
+-/
+
+module
+
+public import LeanPool.ArnoldKAM.Arnold1963.Analysis.MultiContourShift
+public import LeanPool.ArnoldKAM.Arnold1963.Analysis.FourierCoefficients
+public import Mathlib.Analysis.SpecialFunctions.ExpDeriv
+
+/-!
+Exponential decay of actual Fourier coefficients, using contour shifts in each coordinate.
+-/
+
+@[expose] public section
+noncomputable section
+open Complex MeasureTheory
+open scoped NNReal
+namespace KamProject.Arnold1963
+
+/-- Complex linear scaling from unit-period coordinates to angles with period `2π`. -/
+def angleScale (n : ℕ) : ComplexSpace n →L[ℂ] ComplexSpace n :=
+  (2 * (Real.pi : ℂ)) • ContinuousLinearMap.id ℂ _
+
+@[simp] theorem angleScale_apply {n : ℕ} (q : ComplexSpace n) (j : Fin n) :
+    angleScale n q j = 2 * (Real.pi : ℂ) * q j := rfl
+
+theorem scaledAngle_eq_angleScale {n : ℕ} (t : RealSpace n) :
+    scaledAngle t = angleScale n (complexify t) := by
+  ext j
+  simp [scaledAngle, complexify]
+
+/-- The strip width after converting angles to unit-period coordinates. -/
+def normalizedWidth (ρ : ℝ≥0) : ℝ≥0 := ⟨ρ / (2 * Real.pi), by positivity⟩
+
+theorem angleScale_mem_strip {n : ℕ} {ρ : ℝ≥0} {q : ComplexSpace n}
+    (hq : q ∈ angleStrip n (normalizedWidth ρ)) : angleScale n q ∈ angleStrip n ρ := by
+  apply (mem_angleStrip_iff _ _).mpr
+  intro j
+  have h := (mem_angleStrip_iff _ _).mp hq j
+  have hT : (0 : ℝ) < 2 * Real.pi := by positivity
+  change |(q j).im| ≤ (ρ : ℝ) / (2 * Real.pi) at h
+  have hb := (le_div_iff₀ hT).mp h
+  simpa [abs_mul, abs_of_pos hT, abs_of_pos Real.pi_pos, mul_comm] using hb
+
+/-- The negative-frequency exponential weight for normalized Fourier integration. -/
+def unitFourierWeight {n : ℕ} (k : FourierIndex n) (q : ComplexSpace n) : ℂ :=
+  exp (-I * (2 * (Real.pi : ℂ)) * indexPairing k q)
+
+theorem analyticAt_unitFourierWeight {n : ℕ} (k : FourierIndex n) (q : ComplexSpace n) :
+    AnalyticAt ℂ (unitFourierWeight k) q := by
+  apply AnalyticAt.cexp'
+  apply AnalyticAt.mul analyticAt_const
+  apply Finset.analyticAt_fun_sum
+  intro j hj
+  apply analyticAt_const.mul
+  convert (ContinuousLinearMap.proj (R := ℂ) (φ := fun _ : Fin n => ℂ) j).analyticAt q
+    using 1
+  rfl
+
+theorem indexPairing_update_one {n : ℕ} (k : FourierIndex n) (q : ComplexSpace n) (j : Fin n) :
+    indexPairing k (Function.update q j (q j + 1)) = indexPairing k q + k j := by
+  classical
+  have he : (fun l => (k l : ℂ) * Function.update q j (q j + 1) l) =
+      (fun l => (k l : ℂ) * q l + (Pi.single j (k j : ℂ) : ComplexSpace n) l) := by
+    ext l
+    by_cases h : l = j
+    · subst l; simp [mul_add]
+    · simp [Function.update_of_ne h, Pi.single_eq_of_ne h]
+  unfold indexPairing
+  rw [he, Finset.sum_add_distrib]
+  simp
+
+theorem unitFourierWeight_periodic {n : ℕ} (k : FourierIndex n) (q : ComplexSpace n)
+    (j : Fin n) : unitFourierWeight k (Function.update q j (q j + 1)) =
+      unitFourierWeight k q := by
+  unfold unitFourierWeight
+  rw [indexPairing_update_one, mul_add, exp_add]
+  have he : -I * (2 * (Real.pi : ℂ)) * k j = (-k j : ℤ) * (2 * Real.pi * I) := by
+    push_cast
+    ring
+  rw [he, exp_int_mul_two_pi_mul_I, mul_one]
+
+theorem unitFourierWeight_real {n : ℕ} (k : FourierIndex n) (x : RealSpace n) :
+    unitFourierWeight k (complexify x) = fourierMonomial (-k) (scaledAngle x) := by
+  unfold unitFourierWeight fourierMonomial indexPairing
+  rw [Finset.mul_sum, Finset.mul_sum]
+  congr 1
+  apply Finset.sum_congr rfl
+  intro j hj
+  simp only [Pi.neg_apply, Int.cast_neg, scaledAngle, complexify,
+    Complex.ofReal_mul, Complex.ofReal_ofNat]
+  ring
+
+theorem norm_unitFourierWeight_shift {n : ℕ} (k : FourierIndex n) (y x : RealSpace n) :
+    ‖unitFourierWeight k (complexShift y x)‖ =
+      Real.exp ((2 * Real.pi) * ∑ j, (k j : ℝ) * y j) := by
+  rw [unitFourierWeight, norm_exp]
+  congr 1
+  simp [indexPairing, complexShift, mul_re, mul_im]
+
+theorem angleScale_update_one {n : ℕ} (q : ComplexSpace n) (j : Fin n) :
+    angleScale n (Function.update q j (q j + 1)) =
+      angleScale n q + angleShift (Pi.single j (1 : ℤ)) := by
+  classical
+  ext l
+  by_cases h : l = j
+  · subst l; simp [angleShift, complexify, mul_add]
+  · simp [Function.update_of_ne h, Pi.single_eq_of_ne h, angleShift, complexify]
+
+namespace AnalyticPhaseFunction
+
+theorem fourierCoeff_eq_unitCubeIntegral {n : ℕ} {G : Set (ComplexSpace n)} {ρ : ℝ≥0}
+    (f : AnalyticPhaseFunction n G ρ) {p : ComplexSpace n} (hp : p ∈ G) (k : FourierIndex n) :
+    f.fourierCoeff p k = unitCubeIntegral
+      (fun x => f.toFun (p, angleScale n (complexify x)) * unitFourierWeight k (complexify x)) := by
+  rw [f.fourierCoeff_eq_cubeIntegral hp]
+  unfold unitCubeIntegral
+  rw [unitCubeMeasure_eq_restrict_Ioc]
+  apply integral_congr_ae
+  apply Filter.Eventually.of_forall
+  intro x
+  dsimp only
+  rw [mFourier_eq_fourierMonomial, ← scaledAngle_eq_angleScale, unitFourierWeight_real, mul_comm]
+
+theorem norm_fourierCoeff_le_exp {n : ℕ} {G : Set (ComplexSpace n)} {ρ : ℝ≥0}
+    (f : AnalyticPhaseFunction n G ρ) {p : ComplexSpace n} (hp : p ∈ G) (k : FourierIndex n) :
+    ‖f.fourierCoeff p k‖ ≤ f.uniformNorm * Real.exp (-(indexLength k * ρ)) := by
+  let r := normalizedWidth ρ
+  let F : ComplexSpace n → ℂ := fun q => f.toFun (p, angleScale n q) * unitFourierWeight k q
+  have hF : AnalyticOnNhd ℂ F (angleStrip n r) := by
+    intro q hq
+    have hpair : AnalyticAt ℂ (fun z : ComplexSpace n => (p, angleScale n z)) q :=
+      analyticAt_const.prod ((angleScale n).analyticAt q)
+    have hfq := f.analytic (p, angleScale n q) ⟨hp, angleScale_mem_strip (ρ := ρ) hq⟩
+    exact (hfq.comp (f := fun z : ComplexSpace n => (p, angleScale n z)) hpair).mul
+      (analyticAt_unitFourierWeight k q)
+  have hperiod : ∀ q ∈ angleStrip n r, ∀ j, F (Function.update q j (q j + 1)) = F q := by
+    intro q hq j
+    dsimp only [F]
+    rw [angleScale_update_one, f.periodic p hp _ (angleScale_mem_strip hq),
+      unitFourierWeight_periodic]
+  let y : RealSpace n := fun j => if 0 ≤ k j then -(r : ℝ) else r
+  have hy : ∀ j, |y j| ≤ r := by
+    intro j
+    dsimp [y]
+    split_ifs <;> simp
+  have hky (j : Fin n) : (k j : ℝ) * y j = -|(k j : ℝ)| * r := by
+    dsimp [y]
+    split_ifs with hk
+    · rw [abs_of_nonneg (by exact_mod_cast hk)]; ring
+    · rw [abs_of_neg (by exact_mod_cast (lt_of_not_ge hk))]; ring
+  have he : (2 * Real.pi) * ∑ j, (k j : ℝ) * y j = -(indexLength k * ρ) := by
+    simp_rw [hky]
+    rw [← Finset.sum_mul, Finset.sum_neg_distrib]
+    change (2 * Real.pi) * (-(∑ j, |(k j : ℝ)|) * ((ρ : ℝ) / (2 * Real.pi))) =
+      -((∑ j, |(k j : ℝ)|) * (ρ : ℝ))
+    have hT : (2 * Real.pi : ℝ) ≠ 0 := by positivity
+    field_simp
+  rw [f.fourierCoeff_eq_unitCubeIntegral hp]
+  change ‖unitCubeIntegral (fun x => F (complexify x))‖ ≤ _
+  rw [← unitCubeIntegral_shift_eq hF hperiod y hy]
+  apply norm_unitCubeIntegral_le
+  intro x hx
+  dsimp only [F]
+  rw [norm_mul, norm_unitFourierWeight_shift, he]
+  apply mul_le_mul_of_nonneg_right _ (Real.exp_pos _).le
+  exact (f.norm_le_iff.mp le_rfl).norm_le
+    ⟨hp, angleScale_mem_strip (complexShift_mem_strip _ _ hy)⟩
+
+end AnalyticPhaseFunction
+end KamProject.Arnold1963
diff --git a/LeanPool/ArnoldKAM/Arnold1963/Analysis/FourierKernel.lean b/LeanPool/ArnoldKAM/Arnold1963/Analysis/FourierKernel.lean
new file mode 100644
index 0000000000..c2c1b1a9e1
--- /dev/null
+++ b/LeanPool/ArnoldKAM/Arnold1963/Analysis/FourierKernel.lean
@@ -0,0 +1,93 @@
+/-
+Copyright (c) 2026 Bingqi Yu. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Bingqi Yu
+-/
+
+module
+
+public import LeanPool.ArnoldKAM.Arnold1963.Arithmetic.Estimates
+public import LeanPool.ArnoldKAM.Arnold1963.Basic.Spaces
+public import Mathlib.Analysis.Normed.Ring.InfiniteSum
+public import Mathlib.Topology.Algebra.InfiniteSum.NatInt
+
+/-!
+Summation of the exponential lattice kernel in the sum-of-absolute-coordinates norm.
+The product decomposition supplies normal convergence bounds for Fourier series.
+-/
+
+@[expose] public section
+noncomputable section
+namespace KamProject.Arnold1963
+
+/-- Splitting an integer Fourier index into its first coordinate and its tail. -/
+abbrev fourierIndexSuccEquiv (n : ℕ) : FourierIndex (n + 1) ≃ ℤ × FourierIndex n :=
+  (Fin.consEquiv (fun _ : Fin (n + 1) => ℤ)).symm
+
+theorem hasSum_exp_int_abs {δ : ℝ} (hδ : 0 < δ) :
+    HasSum (fun k : ℤ => Real.exp (-δ * |(k : ℝ)|))
+      ((1 + Real.exp (-δ)) / (1 - Real.exp (-δ))) := by
+  have hr : |Real.exp (-δ)| < 1 := by
+    rw [abs_of_pos (Real.exp_pos _), Real.exp_lt_one_iff]
+    linarith
+  have hn : HasSum (fun m : ℕ => Real.exp (-δ * |((m : ℤ) : ℝ)|))
+      (1 - Real.exp (-δ))⁻¹ := by
+    convert hasSum_geometric_of_abs_lt_one hr using 1
+    funext m
+    rw [← Real.exp_nat_mul]
+    congr 1
+    simp only [Int.cast_natCast, abs_of_nonneg (Nat.cast_nonneg m : (0 : ℝ) ≤ m)]
+    ring
+  have hm : HasSum (fun m : ℕ => Real.exp (-δ * |((-(m : ℤ)) : ℝ)|))
+      (1 - Real.exp (-δ))⁻¹ := by simpa using hn
+  have hs := HasSum.of_nat_of_neg
+    (f := fun k : ℤ => Real.exp (-δ * |(k : ℝ)|)) hn (by simpa only [Int.cast_neg] using hm)
+  have hd : 1 - Real.exp (-δ) ≠ 0 :=
+    ne_of_gt (sub_pos.mpr (lt_of_le_of_lt (le_abs_self _) hr))
+  have he : (1 + Real.exp (-δ)) / (1 - Real.exp (-δ)) =
+      (1 - Real.exp (-δ))⁻¹ + (1 - Real.exp (-δ))⁻¹ - 1 := by
+    field_simp [hd]
+    ring
+  rw [he]
+  simpa only [Int.cast_zero, abs_zero, mul_zero, Real.exp_zero] using hs
+
+theorem hasSum_exp_indexLength (n : ℕ) {δ : ℝ} (hδ : 0 < δ) :
+    HasSum (fun k : FourierIndex n => Real.exp (-δ * indexLength k))
+      (((1 + Real.exp (-δ)) / (1 - Real.exp (-δ))) ^ n) := by
+  induction n with
+  | zero => simp [indexLength]
+  | succ n ih =>
+    have hi := hasSum_exp_int_abs hδ
+    have hp := hi.mul ih (hi.summable.mul_of_nonneg ih.summable
+      (fun _ => (Real.exp_pos _).le) (fun _ => (Real.exp_pos _).le))
+    have he : (fun k : FourierIndex (n+1) => Real.exp (-δ * indexLength k)) =
+        (fun p : ℤ × FourierIndex n => Real.exp (-δ * |(p.1 : ℝ)|) *
+          Real.exp (-δ * indexLength p.2)) ∘ fourierIndexSuccEquiv n := by
+      funext k
+      change Real.exp (-δ * indexLength k) =
+        Real.exp (-δ * |(k 0 : ℝ)|) * Real.exp (-δ * indexLength (fun j => k j.succ))
+      simp only [indexLength, Fin.sum_univ_succ, mul_add, Real.exp_add]
+    rw [he]
+    simpa [pow_succ, mul_comm] using (fourierIndexSuccEquiv n).hasSum_iff.mpr hp
+
+theorem summable_exp_indexLength (n : ℕ) {δ : ℝ} (hδ : 0 < δ) :
+    Summable (fun k : FourierIndex n => Real.exp (-δ * indexLength k)) :=
+  (hasSum_exp_indexLength n hδ).summable
+
+theorem tsum_exp_indexLength_le (n : ℕ) {δ : ℝ} (hδ : 0 < δ) (hδ1 : δ ≤ 1) :
+    (∑' k : FourierIndex n, Real.exp (-δ * indexLength k)) ≤ (4 / δ) ^ n := by
+  rw [(hasSum_exp_indexLength n hδ).tsum_eq]
+  have he : Real.exp (-δ) ≤ 1 := (Real.exp_le_one_iff).mpr (by linarith)
+  have hd : 0 < 1 - Real.exp (-δ) := by
+    have := half_le_one_sub_exp_neg hδ.le hδ1
+    linarith
+  apply pow_le_pow_left₀ (by positivity)
+  apply (div_le_iff₀ hd).mpr
+  have := half_le_one_sub_exp_neg hδ.le hδ1
+  apply (mul_le_mul_iff_right₀ hδ).mp
+  have heq : δ * (4 / δ * (1 - Real.exp (-δ))) = 4 * (1 - Real.exp (-δ)) := by
+    field_simp
+  rw [heq]
+  nlinarith
+
+end KamProject.Arnold1963
diff --git a/LeanPool/ArnoldKAM/Arnold1963/Analysis/FourierParameter.lean b/LeanPool/ArnoldKAM/Arnold1963/Analysis/FourierParameter.lean
new file mode 100644
index 0000000000..42efa10978
--- /dev/null
+++ b/LeanPool/ArnoldKAM/Arnold1963/Analysis/FourierParameter.lean
@@ -0,0 +1,127 @@
+/-
+Copyright (c) 2026 Bingqi Yu. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Bingqi Yu
+-/
+
+module
+
+public import LeanPool.ArnoldKAM.Arnold1963.Analysis.ParameterIntegral
+public import LeanPool.ArnoldKAM.Arnold1963.Analysis.FourierDecay
+
+/-!
+Analytic dependence of Fourier coefficients and angle averages on action parameters, together
+with the centered perturbation and its uniform norm bound.
+-/
+
+@[expose] public section
+noncomputable section
+open MeasureTheory Set Complex
+open scoped NNReal
+namespace KamProject.Arnold1963
+
+/-- Normalized Haar measure for analytic dependence of Fourier coefficients on the action. -/
+local instance fourierParameterMeasureSpace : MeasureSpace UnitAddCircle :=
+  ⟨AddCircle.haarAddCircle⟩
+local instance fourierParameterProbability :
+    IsProbabilityMeasure (volume : Measure UnitAddCircle) :=
+  inferInstanceAs (IsProbabilityMeasure AddCircle.haarAddCircle)
+
+theorem analyticAt_fourierMonomial {n : ℕ} (k : FourierIndex n) (q : ComplexSpace n) :
+    AnalyticAt ℂ (fourierMonomial k) q := by
+  apply AnalyticAt.cexp'
+  apply AnalyticAt.mul analyticAt_const
+  apply Finset.analyticAt_fun_sum
+  intro j hj
+  apply analyticAt_const.mul
+  convert (ContinuousLinearMap.proj (R := ℂ) (φ := fun _ : Fin n => ℂ) j).analyticAt q
+    using 1
+  rfl
+
+namespace AnalyticPhaseFunction
+variable {n : ℕ} {G : Set (ComplexSpace n)} {ρ : ℝ≥0}
+
+theorem fourierCoeff_eq_cubeIntegral_all (f : AnalyticPhaseFunction n G ρ)
+    (p : ComplexSpace n) (k : FourierIndex n) :
+    f.fourierCoeff p k = unitCubeIntegral (fun t =>
+      f.toFun (p, scaledAngle t) * fourierMonomial (-k) (scaledAngle t)) := by
+  rw [fourierCoeff, UnitAddTorus.mFourierCoeff_eq_integral _ _ (0 : RealSpace n)]
+  simp only [Pi.zero_apply, zero_add, smul_eq_mul]
+  unfold unitCubeIntegral
+  rw [unitCubeMeasure_eq_restrict_Ioc]
+  apply setIntegral_congr_fun (show MeasurableSet {t : RealSpace n | ∀ j, t j ∈ Ioc 0 1} by
+    simp only [Set.ofPred_forall]
+    exact MeasurableSet.iInter (fun j => measurableSet_Ioc.preimage (measurable_pi_apply j)))
+  intro t ht
+  have he : unitTorusRepr (fun j => (t j : UnitAddCircle)) = t := by
+    ext j
+    exact AddCircle.equivIoc_coe_of_mem (by simpa using ht j)
+  simp only [torusValue, he, mFourier_eq_fourierMonomial, mul_comm]
+
+theorem analyticOnNhd_fourierCoeff (f : AnalyticPhaseFunction n G ρ) (k : FourierIndex n) :
+    AnalyticOnNhd ℂ (fun p => f.fourierCoeff p k) G := by
+  intro p hp
+  have hK : IsCompact (unitCube n) := isCompact_univ_pi (fun _ => isCompact_Icc)
+  have hKm : MeasurableSet (unitCube n) :=
+    MeasurableSet.univ_pi (fun _ => measurableSet_Icc)
+  have hA := analyticAt_integral_compact (μ := unitCubeMeasure n)
+    (f := fun z : ComplexPhaseSpace n => f.toFun z * fourierMonomial (-k) z.2)
+    (continuous_scaledAngle n) hK hKm (p := p) (by
+      intro t ht
+      exact (f.analytic _ ⟨hp, scaledAngle_mem_strip t ρ⟩).mul
+        ((analyticAt_fourierMonomial (-k) _).comp (f := Prod.snd) analyticAt_snd))
+  have hm : (unitCubeMeasure n).restrict (unitCube n) = unitCubeMeasure n := by
+    rw [unitCubeMeasure_eq_restrict, Measure.restrict_restrict hKm, inter_self]
+  simp only [hm] at hA
+  have heq : (fun a => f.fourierCoeff a k) = (fun a => unitCubeIntegral (fun t =>
+      f.toFun (a, scaledAngle t) * fourierMonomial (-k) (scaledAngle t))) :=
+    funext (fun a => f.fourierCoeff_eq_cubeIntegral_all a k)
+  rw [heq]
+  exact hA
+
+theorem analyticOnNhd_angleAverage (f : AnalyticPhaseFunction n G ρ) :
+    AnalyticOnNhd ℂ f.angleAverage G := f.analyticOnNhd_fourierCoeff 0
+
+theorem analyticOnNhd_fourierTruncation (f : AnalyticPhaseFunction n G ρ) (N : ℝ) :
+    AnalyticOnNhd ℂ (fun z : ComplexPhaseSpace n =>
+      fourierTruncation (f.fourierCoeff z.1) N z.2) (phaseDomain G ρ) := by
+  intro z hz
+  apply Finset.analyticAt_fun_sum
+  intro k hk
+  exact (((f.analyticOnNhd_fourierCoeff k) _ hz.1).comp (f := Prod.fst) analyticAt_fst).mul
+    ((analyticAt_fourierMonomial k _).comp (f := Prod.snd) analyticAt_snd)
+
+/-- The angle average packaged as an analytic phase function independent of the angles. -/
+def angleAverageFunction (f : AnalyticPhaseFunction n G ρ) : AnalyticPhaseFunction n G ρ where
+  toFun z := f.angleAverage z.1
+  domain_conj := f.domain_conj
+  analytic := fun z hz => (f.analyticOnNhd_angleAverage z.1 hz.1).comp
+    (f := Prod.fst) analyticAt_fst
+  periodic := by intro p hp q hq m; rfl
+  conj_compatible := by
+    intro z hz
+    exact f.angleAverage_conj hz.1
+  bounded := ⟨f.uniformNorm, (f.norm_le_iff.mp le_rfl).nonneg,
+    fun z hz => f.norm_angleAverage_le hz.1⟩
+
+theorem uniformNorm_angleAverageFunction_le (f : AnalyticPhaseFunction n G ρ) :
+    f.angleAverageFunction.uniformNorm ≤ f.uniformNorm :=
+  (norm_le_iff _).mpr ⟨(f.norm_le_iff.mp le_rfl).nonneg, fun _ hz => f.norm_angleAverage_le hz.1⟩
+
+/-- The phase function with its angle average removed. -/
+def centered (f : AnalyticPhaseFunction n G ρ) : AnalyticPhaseFunction n G ρ :=
+  f.sub f.angleAverageFunction
+
+theorem uniformNorm_centered_le (f : AnalyticPhaseFunction n G ρ) :
+    f.centered.uniformNorm ≤ 2 * f.uniformNorm := by
+  have h := (f.uniformNorm_sub_le f.angleAverageFunction).trans
+    (add_le_add_right f.uniformNorm_angleAverageFunction_le f.uniformNorm)
+  simpa only [centered, two_mul] using h
+
+theorem angleAverage_centered_eq_zero (f : AnalyticPhaseFunction n G ρ)
+    {p : ComplexSpace n} (hp : p ∈ G) : f.centered.angleAverage p = 0 := by
+  rw [angleAverage_eq_integral]
+  exact f.integral_centered_eq_zero hp
+
+end AnalyticPhaseFunction
+end KamProject.Arnold1963
diff --git a/LeanPool/ArnoldKAM/Arnold1963/Analysis/FourierPolynomial.lean b/LeanPool/ArnoldKAM/Arnold1963/Analysis/FourierPolynomial.lean
new file mode 100644
index 0000000000..fef722d8bc
--- /dev/null
+++ b/LeanPool/ArnoldKAM/Arnold1963/Analysis/FourierPolynomial.lean
@@ -0,0 +1,92 @@
+/-
+Copyright (c) 2026 Bingqi Yu. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Bingqi Yu
+-/
+
+module
+
+public import LeanPool.ArnoldKAM.Arnold1963.Arithmetic.Lattice
+public import LeanPool.ArnoldKAM.Arnold1963.Basic.Domains
+public import Mathlib.Analysis.Complex.Trigonometric
+
+/-!
+Finite Fourier polynomials and their bounds on complex angle strips.
+-/
+
+@[expose] public section
+
+noncomputable section
+namespace KamProject.Arnold1963
+
+/-- The complex Fourier character with integer frequency and angles of period `2π`. -/
+def fourierMonomial {n : ℕ} (k : FourierIndex n) (q : ComplexSpace n) : ℂ :=
+  Complex.exp (Complex.I * indexPairing k q)
+
+/-- The finite Fourier sum over modes below the specified strict cutoff. -/
+def fourierTruncation {n : ℕ} (a : FourierIndex n → ℂ) (N : ℝ)
+    (q : ComplexSpace n) : ℂ :=
+  ∑ k ∈ fourierModes n N, a k * fourierMonomial k q
+
+@[simp] theorem fourierMonomial_zero {n : ℕ} (q : ComplexSpace n) :
+    fourierMonomial 0 q = 1 := by
+  simp [fourierMonomial, indexPairing]
+
+theorem fourierTruncation_eq_zero_add {n : ℕ} (a : FourierIndex n → ℂ)
+    {N : ℝ} (hN : 0 < N) (q : ComplexSpace n) :
+    fourierTruncation a N q = a 0 + ∑ k ∈ lowModes n N, a k * fourierMonomial k q := by
+  classical
+  rw [fourierTruncation, fourierModes_eq_insert_lowModes n hN,
+    Finset.sum_insert (by simp [indexLength])]
+  simp
+
+theorem norm_fourierMonomial_le {n : ℕ} (k : FourierIndex n) (q : ComplexSpace n) :
+    ‖fourierMonomial k q‖ ≤ Real.exp (indexLength k * ‖imagPart q‖) := by
+  rw [fourierMonomial, Complex.norm_exp]
+  apply Real.exp_le_exp.mpr
+  have him : (Complex.I * indexPairing k q).re =
+      -(∑ j, (k j : ℝ) * (q j).im) := by
+    simp [indexPairing, Complex.mul_re, Complex.mul_im]
+  rw [him]
+  calc
+    _ ≤ |∑ j, (k j : ℝ) * (q j).im| := neg_le_abs _
+    _ ≤ ∑ j, |(k j : ℝ) * (q j).im| := Finset.abs_sum_le_sum_abs _ _
+    _ ≤ ∑ j, |(k j : ℝ)| * ‖imagPart q‖ := by
+      apply Finset.sum_le_sum
+      intro j _
+      rw [abs_mul]
+      apply mul_le_mul_of_nonneg_left _ (abs_nonneg _)
+      simpa [imagPart, Real.norm_eq_abs] using norm_le_pi_norm (imagPart q) j
+    _ = indexLength k * ‖imagPart q‖ := by rw [indexLength, Finset.sum_mul]
+
+theorem norm_fourierTerm_le {n : ℕ} {a : FourierIndex n → ℂ}
+    {M ρ δ : ℝ} (hM : 0 ≤ M)
+    (ha : ∀ k, ‖a k‖ ≤ M * Real.exp (-(indexLength k * ρ)))
+    {q : ComplexSpace n} (hq : ‖imagPart q‖ ≤ ρ - δ) (k : FourierIndex n) :
+    ‖a k * fourierMonomial k q‖ ≤ M * Real.exp (-(indexLength k * δ)) := by
+  rw [norm_mul]
+  calc
+    _ ≤ (M * Real.exp (-(indexLength k * ρ))) *
+        Real.exp (indexLength k * ‖imagPart q‖) :=
+      mul_le_mul (ha k) (norm_fourierMonomial_le k q) (norm_nonneg _)
+        (mul_nonneg hM (Real.exp_pos _).le)
+    _ = M * Real.exp (-(indexLength k * ρ) + indexLength k * ‖imagPart q‖) := by
+      rw [mul_assoc, ← Real.exp_add]
+    _ ≤ M * Real.exp (-(indexLength k * δ)) := by
+      apply mul_le_mul_of_nonneg_left _ hM
+      apply Real.exp_le_exp.mpr
+      nlinarith [mul_le_mul_of_nonneg_left hq (indexLength_nonneg k)]
+
+theorem norm_fourierTruncation_le {n : ℕ} {a : FourierIndex n → ℂ}
+    {M ρ δ : ℝ} (hM : 0 ≤ M)
+    (ha : ∀ k, ‖a k‖ ≤ M * Real.exp (-(indexLength k * ρ)))
+    {q : ComplexSpace n} (hq : ‖imagPart q‖ ≤ ρ - δ) (N : ℝ) :
+    ‖fourierTruncation a N q‖ ≤
+      M * ∑ k ∈ fourierModes n N, Real.exp (-(indexLength k * δ)) := by
+  calc
+    _ ≤ ∑ k ∈ fourierModes n N, ‖a k * fourierMonomial k q‖ := norm_sum_le _ _
+    _ ≤ ∑ k ∈ fourierModes n N, M * Real.exp (-(indexLength k * δ)) :=
+      Finset.sum_le_sum fun k _ => norm_fourierTerm_le hM ha hq k
+    _ = _ := (Finset.mul_sum _ _ _).symm
+
+end KamProject.Arnold1963
diff --git a/LeanPool/ArnoldKAM/Arnold1963/Analysis/FourierReconstruction.lean b/LeanPool/ArnoldKAM/Arnold1963/Analysis/FourierReconstruction.lean
new file mode 100644
index 0000000000..fb63021808
--- /dev/null
+++ b/LeanPool/ArnoldKAM/Arnold1963/Analysis/FourierReconstruction.lean
@@ -0,0 +1,106 @@
+/-
+Copyright (c) 2026 Bingqi Yu. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Bingqi Yu
+-/
+
+module
+
+public import LeanPool.ArnoldKAM.Arnold1963.Analysis.ShiftedFourier
+public import LeanPool.ArnoldKAM.Arnold1963.Analysis.TailConstant
+
+/-!
+Reconstruction of the original analytic phase function and bounds for its Fourier remainder.
+-/
+
+@[expose] public section
+noncomputable section
+open Complex
+open scoped NNReal
+namespace KamProject.Arnold1963
+
+theorem angleScale_normalize {n : ℕ} (q : ComplexSpace n) :
+    angleScale n (complexShift (fun j => (q j).im / (2 * Real.pi))
+      (fun j => (q j).re / (2 * Real.pi))) = q := by
+  have hT : (2 * Real.pi : ℝ) ≠ 0 := by positivity
+  ext j
+  simp [complexShift]
+  field_simp
+  exact re_add_im (q j)
+
+theorem imagPart_shift_zero {n : ℕ} (y t : RealSpace n) :
+    imagPart (angleScale n (complexShift y 0)) =
+      imagPart (angleScale n (complexShift y t)) := by
+  ext j
+  simp [imagPart, complexShift, mul_im]
+
+namespace AnalyticPhaseFunction
+variable {n : ℕ} {G : Set (ComplexSpace n)} {ρ : ℝ≥0}
+
+theorem hasSum_fourier_on_strip (f : AnalyticPhaseFunction n G ρ) {p : ComplexSpace n}
+    (hp : p ∈ G) {σ : ℝ≥0} (hσρ : σ < ρ) {q : ComplexSpace n}
+    (hq : q ∈ angleStrip n σ) :
+    HasSum (fun k => f.fourierCoeff p k * fourierMonomial k q) (f.toFun (p, q)) := by
+  let y : RealSpace n := fun j => (q j).im / (2 * Real.pi)
+  let t : RealSpace n := fun j => (q j).re / (2 * Real.pi)
+  have he : angleScale n (complexShift y t) = q := angleScale_normalize q
+  have hy : ∀ j, |y j| ≤ normalizedWidth ρ := by
+    intro j
+    dsimp [y, normalizedWidth]
+    rw [abs_div, abs_of_pos (by positivity : (0 : ℝ) < 2 * Real.pi)]
+    exact div_le_div_of_nonneg_right
+      (((mem_angleStrip_iff _ _).mp hq j).trans (show (σ : ℝ) ≤ ρ from hσρ.le))
+      (by positivity)
+  have hd : (0 : ℝ) < (ρ : ℝ) - σ := sub_pos.mpr (show (σ : ℝ) < ρ from hσρ)
+  have hw : ‖imagPart (angleScale n (complexShift y 0))‖ ≤
+      (ρ : ℝ) - ((ρ : ℝ) - σ) := by
+    rw [imagPart_shift_zero y t, he]
+    simpa [angleStrip] using hq
+  simpa only [he] using f.hasSum_fourier_shifted hp y hy hd hw t
+
+theorem tsum_fourierTerms_apply (f : AnalyticPhaseFunction n G ρ) {p : ComplexSpace n}
+    (hp : p ∈ G) {σ : ℝ≥0} (hσρ : σ < ρ) (q : angleStrip n σ) :
+    (∑' k, fourierTermOnStrip (f.fourierCoeff p) σ k) q = f.toFun (p, q) := by
+  have hsum := summable_fourierTerms_of_decay (f.norm_le_iff.mp le_rfl).nonneg
+    (sub_pos.mpr (show (σ : ℝ) < ρ from hσρ))
+    (show (σ : ℝ) ≤ (ρ : ℝ) - ((ρ : ℝ) - σ) by linarith)
+    (f.norm_fourierCoeff_le_exp hp)
+  have hs := (BoundedContinuousFunction.evalCLM ℂ q).hasSum hsum.hasSum
+  exact hs.unique (f.hasSum_fourier_on_strip hp hσρ q.property)
+
+theorem norm_sub_fourierTruncation_le (f : AnalyticPhaseFunction n G ρ)
+    {p : ComplexSpace n} (hp : p ∈ G) (hn : 0 < n)
+    {δ γ N : ℝ} {σ : ℝ≥0} (hδ : 0 < δ) (hsmall : δ ≤ 1 / 12)
+    (hγ : 0 ≤ γ) (hσ : (σ : ℝ) ≤ (ρ : ℝ) - (δ + γ))
+    {q : ComplexSpace n} (hq : q ∈ angleStrip n σ) :
+    ‖f.toFun (p, q) - fourierTruncation (f.fourierCoeff p) N q‖ ≤
+      (((2 * n : ℝ) / Real.exp 1) ^ n * f.uniformNorm / δ ^ (n + 1)) *
+        Real.exp (-N * γ) := by
+  have hσρ : σ < ρ := by exact_mod_cast (show (σ : ℝ) < ρ by linarith)
+  have hb := norm_fourierSeries_tail_le_arnoldConstant (N := N) hn
+    (f.norm_le_iff.mp le_rfl).nonneg hδ hsmall hγ hσ (f.norm_fourierCoeff_le_exp hp)
+  have he := BoundedContinuousFunction.norm_coe_le_norm
+    ((∑' k, fourierTermOnStrip (f.fourierCoeff p) σ k) -
+      ∑ k ∈ fourierModes n N, fourierTermOnStrip (f.fourierCoeff p) σ k) ⟨q, hq⟩
+  apply le_trans _ hb
+  rw [BoundedContinuousFunction.sub_apply, f.tsum_fourierTerms_apply hp hσρ,
+    BoundedContinuousFunction.sum_apply] at he
+  exact he
+
+/-- The difference between a phase function and its finite Fourier truncation. -/
+def fourierRemainder (f : AnalyticPhaseFunction n G ρ) (N : ℝ)
+    (z : ComplexPhaseSpace n) : ℂ :=
+  f.toFun z - fourierTruncation (f.fourierCoeff z.1) N z.2
+
+theorem normBoundOn_fourierRemainder (f : AnalyticPhaseFunction n G ρ) (hn : 0 < n)
+    {δ γ N : ℝ} {σ : ℝ≥0} (hδ : 0 < δ) (hsmall : δ ≤ 1 / 12)
+    (hγ : 0 ≤ γ) (hσ : (σ : ℝ) ≤ (ρ : ℝ) - (δ + γ)) :
+    NormBoundOn (f.fourierRemainder N) (phaseDomain G σ)
+      ((((2 * n : ℝ) / Real.exp 1) ^ n * f.uniformNorm / δ ^ (n + 1)) *
+        Real.exp (-N * γ)) := by
+  refine ⟨?_, fun z hz => f.norm_sub_fourierTruncation_le hz.1 hn hδ hsmall hγ hσ hz.2⟩
+  have hM := (f.norm_le_iff.mp le_rfl).nonneg
+  positivity
+
+end AnalyticPhaseFunction
+end KamProject.Arnold1963
diff --git a/LeanPool/ArnoldKAM/Arnold1963/Analysis/FourierSeries.lean b/LeanPool/ArnoldKAM/Arnold1963/Analysis/FourierSeries.lean
new file mode 100644
index 0000000000..0e81a0d9d6
--- /dev/null
+++ b/LeanPool/ArnoldKAM/Arnold1963/Analysis/FourierSeries.lean
@@ -0,0 +1,88 @@
+/-
+Copyright (c) 2026 Bingqi Yu. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Bingqi Yu
+-/
+
+module
+
+public import LeanPool.ArnoldKAM.Arnold1963.Analysis.FourierCoefficients
+public import LeanPool.ArnoldKAM.Arnold1963.Analysis.FourierKernel
+
+/-!
+Normally convergent Fourier series on narrower complex strips and reconstruction on real angles.
+-/
+
+@[expose] public section
+noncomputable section
+open scoped NNReal
+namespace KamProject.Arnold1963
+
+theorem continuous_fourierMonomial {n : ℕ} (k : FourierIndex n) :
+    Continuous (fourierMonomial k) := by
+  unfold fourierMonomial indexPairing
+  fun_prop
+
+/-- A bounded continuous Fourier summand on a closed complex angle strip. -/
+def fourierTermOnStrip {n : ℕ} (a : FourierIndex n → ℂ) (σ : ℝ≥0)
+    (k : FourierIndex n) : BoundedOnDomain (F := ℂ) (angleStrip n σ) :=
+  boundedRestriction (fun q => a k * fourierMonomial k q) (angleStrip n σ)
+    (continuous_const.mul (continuous_fourierMonomial k)).continuousOn
+    (‖a k‖ * Real.exp (indexLength k * σ))
+    ⟨by positivity, fun q hq => by
+      rw [norm_mul]
+      apply mul_le_mul_of_nonneg_left _ (norm_nonneg _)
+      exact (norm_fourierMonomial_le k q).trans
+        (Real.exp_le_exp.mpr (mul_le_mul_of_nonneg_left hq (indexLength_nonneg k)))⟩
+
+theorem norm_fourierTermOnStrip_le_of_decay {n : ℕ} {a : FourierIndex n → ℂ}
+    {M ρ δ : ℝ} {σ : ℝ≥0} (hM : 0 ≤ M) (hσ : (σ : ℝ) ≤ ρ - δ)
+    (ha : ∀ k, ‖a k‖ ≤ M * Real.exp (-(indexLength k * ρ))) (k : FourierIndex n) :
+    ‖fourierTermOnStrip a σ k‖ ≤ M * Real.exp (-δ * indexLength k) := by
+  apply (BoundedContinuousFunction.norm_le (by positivity)).mpr
+  intro q
+  change ‖a k * fourierMonomial k q‖ ≤ M * Real.exp (-δ * indexLength k)
+  simpa only [neg_mul, mul_comm] using
+    norm_fourierTerm_le hM ha (q.property.trans hσ) k
+
+theorem summable_fourierTerms_of_decay {n : ℕ} {a : FourierIndex n → ℂ}
+    {M ρ δ : ℝ} {σ : ℝ≥0} (hM : 0 ≤ M) (hδ : 0 < δ) (hσ : (σ : ℝ) ≤ ρ - δ)
+    (ha : ∀ k, ‖a k‖ ≤ M * Real.exp (-(indexLength k * ρ))) :
+    Summable (fourierTermOnStrip a σ) :=
+  ((summable_exp_indexLength n hδ).mul_left M).of_norm_bounded
+    (norm_fourierTermOnStrip_le_of_decay hM hσ ha)
+
+theorem norm_tsum_fourierTerms_le_of_decay {n : ℕ} {a : FourierIndex n → ℂ}
+    {M ρ δ : ℝ} {σ : ℝ≥0} (hM : 0 ≤ M) (hδ : 0 < δ) (hδ1 : δ ≤ 1)
+    (hσ : (σ : ℝ) ≤ ρ - δ)
+    (ha : ∀ k, ‖a k‖ ≤ M * Real.exp (-(indexLength k * ρ))) :
+    ‖∑' k, fourierTermOnStrip a σ k‖ ≤ M * (4 / δ) ^ n := by
+  have h := tsum_of_norm_bounded ((hasSum_exp_indexLength n hδ).mul_left M)
+    (norm_fourierTermOnStrip_le_of_decay hM hσ ha)
+  apply h.trans
+  apply mul_le_mul_of_nonneg_left _ hM
+  simpa only [(hasSum_exp_indexLength n hδ).tsum_eq] using
+    tsum_exp_indexLength_le n hδ hδ1
+
+namespace AnalyticPhaseFunction
+variable {n : ℕ} {G : Set (ComplexSpace n)} {ρ : ℝ≥0}
+
+theorem hasSum_fourier_real_of_summable (f : AnalyticPhaseFunction n G ρ)
+    {p : ComplexSpace n} (hp : p ∈ G) (h : Summable (f.fourierCoeff p)) (t : RealSpace n) :
+    HasSum (fun k => f.fourierCoeff p k * fourierMonomial k (scaledAngle t))
+      (f.toFun (p, scaledAngle t)) := by
+  have hs := UnitAddTorus.hasSum_mFourier_series_apply_of_summable
+    (f := f.onUnitTorus ⟨p, hp⟩) h (fun j => (t j : UnitAddCircle))
+  simpa only [onUnitTorus, ContinuousMap.coe_mk, smul_eq_mul, fourierCoeff,
+    mFourier_eq_fourierMonomial, f.torusValue_coe hp] using hs
+
+theorem summable_fourierCoeff_of_decay (f : AnalyticPhaseFunction n G ρ)
+    (p : ComplexSpace n) {M : ℝ} (hρ : 0 < ρ)
+    (h : ∀ k, ‖f.fourierCoeff p k‖ ≤ M * Real.exp (-(indexLength k * ρ))) :
+    Summable (f.fourierCoeff p) := by
+  apply ((summable_exp_indexLength n (show (0 : ℝ) < ρ from hρ)).mul_left M).of_norm_bounded
+  intro k
+  simpa only [neg_mul, mul_comm] using h k
+
+end AnalyticPhaseFunction
+end KamProject.Arnold1963
diff --git a/LeanPool/ArnoldKAM/Arnold1963/Analysis/FourierTail.lean b/LeanPool/ArnoldKAM/Arnold1963/Analysis/FourierTail.lean
new file mode 100644
index 0000000000..d028e88a9d
--- /dev/null
+++ b/LeanPool/ArnoldKAM/Arnold1963/Analysis/FourierTail.lean
@@ -0,0 +1,59 @@
+/-
+Copyright (c) 2026 Bingqi Yu. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Bingqi Yu
+-/
+
+module
+
+public import LeanPool.ArnoldKAM.Arnold1963.Analysis.FourierSeries
+
+/-!
+Bounds for the omitted Fourier modes, retaining the exponential cutoff factor.
+-/
+
+@[expose] public section
+noncomputable section
+open scoped NNReal
+namespace KamProject.Arnold1963
+
+theorem norm_fourierSeries_tail_le_of_decay {n : ℕ} {a : FourierIndex n → ℂ}
+    {M ρ δ γ N : ℝ} {σ : ℝ≥0} (hM : 0 ≤ M) (hδ : 0 < δ) (hδ1 : δ ≤ 1)
+    (hγ : 0 ≤ γ) (hσ : (σ : ℝ) ≤ ρ - (δ + γ))
+    (ha : ∀ k, ‖a k‖ ≤ M * Real.exp (-(indexLength k * ρ))) :
+    ‖(∑' k, fourierTermOnStrip a σ k) -
+        ∑ k ∈ fourierModes n N, fourierTermOnStrip a σ k‖ ≤
+      M * Real.exp (-N * γ) * (4 / δ) ^ n := by
+  classical
+  let C := M * Real.exp (-N * γ)
+  have hC : 0 ≤ C := by dsimp [C]; positivity
+  have hsum := summable_fourierTerms_of_decay hM (show 0 < δ + γ by linarith) hσ ha
+  have ht := (fourierModes n N).hasSum_iff_compl.mp hsum.hasSum
+  have hk := summable_exp_indexLength n hδ
+  have hk' := hk.subtype (fun k => k ∉ fourierModes n N)
+  have hb : ∀ k : {k // k ∉ fourierModes n N},
+      ‖fourierTermOnStrip a σ k.val‖ ≤ C * Real.exp (-δ * indexLength k.val) := by
+    intro k
+    have hN : N ≤ indexLength k.val := not_mem_fourierModes.mp k.property
+    calc
+      _ ≤ M * Real.exp (-(δ + γ) * indexLength k.val) :=
+        norm_fourierTermOnStrip_le_of_decay hM hσ ha k.val
+      _ = M * Real.exp (-γ * indexLength k.val) * Real.exp (-δ * indexLength k.val) := by
+        rw [mul_assoc, ← Real.exp_add]
+        congr 2
+        ring
+      _ ≤ C * Real.exp (-δ * indexLength k.val) := by
+        apply mul_le_mul_of_nonneg_right _ (Real.exp_pos _).le
+        apply mul_le_mul_of_nonneg_left _ hM
+        apply Real.exp_le_exp.mpr
+        nlinarith
+  have hbound := ht.norm_le_of_bounded (hk'.hasSum.mul_left C) hb
+  apply hbound.trans
+  apply mul_le_mul_of_nonneg_left _ hC
+  calc
+    _ ≤ ∑' k : FourierIndex n, Real.exp (-δ * indexLength k) :=
+      hk'.tsum_le_tsum_of_inj Subtype.val Subtype.val_injective
+        (fun _ _ => (Real.exp_pos _).le) (fun _ => le_rfl) hk
+    _ ≤ (4 / δ) ^ n := tsum_exp_indexLength_le n hδ hδ1
+
+end KamProject.Arnold1963
diff --git a/LeanPool/ArnoldKAM/Arnold1963/Analysis/MeanValue.lean b/LeanPool/ArnoldKAM/Arnold1963/Analysis/MeanValue.lean
new file mode 100644
index 0000000000..9410818e3d
--- /dev/null
+++ b/LeanPool/ArnoldKAM/Arnold1963/Analysis/MeanValue.lean
@@ -0,0 +1,73 @@
+/-
+Copyright (c) 2026 Bingqi Yu. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Bingqi Yu
+-/
+
+module
+
+public import LeanPool.ArnoldKAM.Arnold1963.Basic.Functions
+public import Mathlib.Analysis.Calculus.MeanValue
+public import Mathlib.Analysis.Calculus.FDeriv.Analytic
+
+/-!
+Mean-value estimates on contained segments. Coordinate bounds give operator bounds with the
+explicit dimension factor required by the maximum norm.
+-/
+
+@[expose] public section
+
+noncomputable section
+namespace KamProject.Arnold1963
+
+section Segment
+variable {E F : Type*} [NormedAddCommGroup E] [NormedSpace ℂ E]
+  [NormedSpace ℝ E]
+  [NormedAddCommGroup F] [NormedSpace ℂ F]
+
+theorem norm_sub_le_of_segment_bound {f : E → F} {U : Set E} {a b : E} {C : ℝ}
+    (hab : segment ℝ a b ⊆ U) (hf : ∀ x ∈ U, DifferentiableAt ℂ f x)
+    (hC : NormBoundOn (fderiv ℂ f) U C) :
+    ‖f b - f a‖ ≤ C * ‖b - a‖ := by
+  exact (convex_segment a b).norm_image_sub_le_of_norm_fderiv_le
+    (fun x hx => hf x (hab hx)) (fun x hx => hC.norm_le (hab hx))
+    (left_mem_segment ℝ a b) (right_mem_segment ℝ a b)
+
+theorem norm_sub_le_of_analytic_segment_bound {f : E → F} {U : Set E}
+    {a b : E} {C : ℝ} (hab : segment ℝ a b ⊆ U)
+    (hf : AnalyticOnNhd ℂ f U) (hC : NormBoundOn (fderiv ℂ f) U C) :
+    ‖f b - f a‖ ≤ C * ‖b - a‖ :=
+  norm_sub_le_of_segment_bound hab (fun x hx => (hf x hx).differentiableAt) hC
+
+end Segment
+
+theorem norm_linearMap_le_of_coordinate_bound {n : ℕ} {F : Type*}
+    [NormedAddCommGroup F] [NormedSpace ℂ F]
+    (A : ComplexSpace n →L[ℂ] F) {C : ℝ} (hC : 0 ≤ C)
+    (hA : ∀ j, ‖A (Pi.single j 1)‖ ≤ C) : ‖A‖ ≤ n * C := by
+  apply A.opNorm_le_bound (mul_nonneg (Nat.cast_nonneg _) hC)
+  intro v
+  have hv : A v = ∑ j, v j • A (Pi.single j 1) := by
+    conv_lhs => rw [pi_eq_sum_univ' v]
+    simp only [map_sum, map_smul]
+  rw [hv]
+  calc
+    _ ≤ ∑ j, ‖v j • A (Pi.single j 1)‖ := norm_sum_le _ _
+    _ ≤ ∑ _j : Fin n, ‖v‖ * C := by
+      apply Finset.sum_le_sum
+      intro j _
+      rw [norm_smul]
+      exact mul_le_mul (norm_le_pi_norm v j) (hA j) (norm_nonneg _) (norm_nonneg _)
+    _ = (n : ℝ) * C * ‖v‖ := by simp; ring
+
+theorem norm_sub_le_of_coordinate_bound {n : ℕ} {F : Type*}
+    [NormedAddCommGroup F] [NormedSpace ℂ F]
+    {f : ComplexSpace n → F} {U : Set (ComplexSpace n)} {a b : ComplexSpace n} {C : ℝ}
+    (hab : segment ℝ a b ⊆ U) (hf : AnalyticOnNhd ℂ f U) (hC : 0 ≤ C)
+    (hbound : ∀ x ∈ U, ∀ j, ‖fderiv ℂ f x (Pi.single j 1)‖ ≤ C) :
+    ‖f b - f a‖ ≤ (n : ℝ) * C * ‖b - a‖ := by
+  exact norm_sub_le_of_analytic_segment_bound hab hf
+    ⟨mul_nonneg (Nat.cast_nonneg _) hC, fun x hx =>
+      norm_linearMap_le_of_coordinate_bound _ hC (hbound x hx)⟩
+
+end KamProject.Arnold1963
diff --git a/LeanPool/ArnoldKAM/Arnold1963/Analysis/MultiContourShift.lean b/LeanPool/ArnoldKAM/Arnold1963/Analysis/MultiContourShift.lean
new file mode 100644
index 0000000000..6aa312c0f4
--- /dev/null
+++ b/LeanPool/ArnoldKAM/Arnold1963/Analysis/MultiContourShift.lean
@@ -0,0 +1,166 @@
+/-
+Copyright (c) 2026 Bingqi Yu. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Bingqi Yu
+-/
+
+module
+
+public import LeanPool.ArnoldKAM.Arnold1963.Analysis.BoxIntegral
+public import LeanPool.ArnoldKAM.Arnold1963.Analysis.ContourShift
+public import LeanPool.ArnoldKAM.Arnold1963.Basic.Functions
+
+/-!
+Coordinate induction extends the contour-shift identity to unit-cube integrals.
+-/
+
+@[expose] public section
+noncomputable section
+open MeasureTheory Set Complex
+open scoped NNReal
+namespace KamProject.Arnold1963
+
+/-- A real coordinate vector shifted in the imaginary direction by another real vector. -/
+def complexShift {n : ℕ} (y x : RealSpace n) : ComplexSpace n :=
+  fun j => (x j : ℂ) + (y j : ℂ) * I
+
+@[simp] theorem complexShift_zero {n : ℕ} (x : RealSpace n) :
+    complexShift 0 x = complexify x := by ext j; simp [complexShift, complexify]
+
+@[simp] theorem complexShift_cons {n : ℕ} (y : RealSpace (n + 1)) (x : ℝ)
+    (t : RealSpace n) : complexShift y (Fin.cons x t) =
+      Fin.cons ((x : ℂ) + y 0 * I) (complexShift (Fin.tail y) t) := by
+  ext j
+  exact Fin.cases rfl (fun _ => rfl) j
+
+theorem complexShift_mem_strip {n : ℕ} {r : ℝ≥0} (y x : RealSpace n)
+    (hy : ∀ j, |y j| ≤ r) : complexShift y x ∈ angleStrip n r := by
+  apply (mem_angleStrip_iff _ _).mpr
+  intro j
+  simpa [complexShift] using hy j
+
+theorem continuous_shift_slice {n : ℕ} {r : ℝ≥0} {f : ComplexSpace n → ℂ}
+    (hf : ContinuousOn f (angleStrip n r)) (y : RealSpace n) (hy : ∀ j, |y j| ≤ r) :
+    Continuous (fun x => f (complexShift y x)) :=
+  hf.comp_continuous (by unfold complexShift; fun_prop)
+    (fun x => complexShift_mem_strip y x hy)
+
+private theorem analyticAt_cons_head {n : ℕ} (q : ComplexSpace n) (z : ℂ) :
+    AnalyticAt ℂ (fun w : ℂ => (Fin.cons w q : ComplexSpace (n + 1))) z := by
+  apply AnalyticAt.pi
+  intro j
+  exact Fin.cases analyticAt_id (fun _ => analyticAt_const) j
+
+private theorem analyticAt_cons_tail {n : ℕ} (z : ℂ) (q : ComplexSpace n) :
+    AnalyticAt ℂ (fun w : ComplexSpace n => (Fin.cons z w : ComplexSpace (n + 1))) q := by
+  apply AnalyticAt.pi
+  intro j
+  refine Fin.cases analyticAt_const (fun i => ?_) j
+  change AnalyticAt ℂ (fun x : ComplexSpace n => x i) q
+  convert (ContinuousLinearMap.proj (R := ℂ) (φ := fun _ : Fin n => ℂ) i).analyticAt q using 1
+  rfl
+
+private theorem cons_mem_strip {n : ℕ} {r : ℝ≥0} {z : ℂ} {q : ComplexSpace n}
+    (hz : |z.im| ≤ r) (hq : q ∈ angleStrip n r) : Fin.cons z q ∈ angleStrip (n + 1) r := by
+  apply (mem_angleStrip_iff _ _).mpr
+  intro j
+  exact Fin.cases hz (fun i => (mem_angleStrip_iff _ _).mp hq i) j
+
+theorem integral_cons_horizontal_shift {n : ℕ} {r : ℝ≥0} {f : ComplexSpace (n + 1) → ℂ}
+    (hf : AnalyticOnNhd ℂ f (angleStrip (n + 1) r))
+    (hp : ∀ q ∈ angleStrip (n + 1) r, ∀ j,
+      f (Function.update q j (q j + 1)) = f q)
+    {q : ComplexSpace n} (hq : q ∈ angleStrip n r) {y : ℝ} (hy : |y| ≤ r) :
+    (∫ x, f (Fin.cons ((x : ℂ) + y * I) q) ∂unitIntervalMeasure) =
+      ∫ x, f (Fin.cons (x : ℂ) q) ∂unitIntervalMeasure := by
+  have ht : ∀ t ∈ uIcc 0 y, |t| ≤ r := by
+    intro t ht
+    exact abs_le.mpr (uIcc_subset_Icc ⟨neg_nonpos.mpr r.coe_nonneg, r.coe_nonneg⟩
+      (abs_le.mp hy) ht)
+  have hd : DifferentiableOn ℂ (fun z => f (Fin.cons z q)) (uIcc 0 1 ×ℂ uIcc 0 y) := by
+    intro z hz
+    exact ((hf _ (cons_mem_strip (ht _ hz.2) hq)).comp
+      (f := fun w : ℂ => (Fin.cons w q : ComplexSpace (n + 1)))
+      (analyticAt_cons_head q z)).differentiableAt.differentiableWithinAt
+  have hs := integral_horizontal_shift (fun z => f (Fin.cons z q)) 1 0 y hd (by
+    intro t htt
+    have hh := hp (Fin.cons ((t : ℂ) * I) q)
+      (cons_mem_strip (by simpa using ht t htt) hq) 0
+    have he : Function.update (Fin.cons ((t : ℂ) * I) q : ComplexSpace (n + 1)) 0
+        ((t : ℂ) * I + 1) = Fin.cons (1 + (t : ℂ) * I) q := by
+      ext j
+      refine Fin.cases ?_ (fun i => ?_) j <;> simp [add_comm]
+    simp only [Fin.cons_zero] at hh
+    rw [he] at hh
+    simpa only [ofReal_one] using hh)
+  simp only [ofReal_zero, zero_mul, add_zero] at hs
+  simpa only [integral_unitInterval_eq_interval] using hs.symm
+
+theorem unitCubeIntegral_shift_eq {n : ℕ} {r : ℝ≥0} {f : ComplexSpace n → ℂ}
+    (hf : AnalyticOnNhd ℂ f (angleStrip n r))
+    (hp : ∀ q ∈ angleStrip n r, ∀ j, f (Function.update q j (q j + 1)) = f q)
+    (y : RealSpace n) (hy : ∀ j, |y j| ≤ r) :
+    unitCubeIntegral (fun x => f (complexShift y x)) =
+      unitCubeIntegral (fun x => f (complexify x)) := by
+  induction n with
+  | zero =>
+    apply unitCubeIntegral_congr
+    intro x hx
+    congr 1
+    ext j
+    exact Fin.elim0 j
+  | succ n ih =>
+    let y' : RealSpace (n + 1) := Fin.cons 0 (Fin.tail y)
+    have hy' : ∀ j, |y' j| ≤ r := fun j =>
+      Fin.cases (by simp [y']) (fun i => hy i.succ) j
+    have hi (v : RealSpace (n + 1)) (hv : ∀ j, |v j| ≤ r) :
+        Integrable (fun x => f (complexShift v x)) (unitCubeMeasure (n + 1)) :=
+      integrable_unitCube (continuous_shift_slice hf.continuousOn v hv).continuousOn
+    have hi0 : Integrable (fun x => f (complexify x)) (unitCubeMeasure (n + 1)) := by
+      simpa using hi 0 (by intro j; simp)
+    calc
+      _ = ∫ t, (∫ x, f (Fin.cons ((x : ℂ) + y 0 * I)
+          (complexShift (Fin.tail y) t)) ∂unitIntervalMeasure) ∂unitCubeMeasure n := by
+        simpa only [complexShift_cons] using unitCubeIntegral_cons_symm (hi y hy)
+      _ = ∫ t, (∫ x, f (Fin.cons (x : ℂ) (complexShift (Fin.tail y) t))
+          ∂unitIntervalMeasure) ∂unitCubeMeasure n := by
+        apply integral_congr_ae
+        exact Filter.Eventually.of_forall fun t => integral_cons_horizontal_shift hf hp
+          (complexShift_mem_strip _ _ (fun j => hy j.succ)) (hy 0)
+      _ = unitCubeIntegral (fun x => f (complexShift y' x)) := by
+        simpa [y'] using (unitCubeIntegral_cons_symm (hi y' hy')).symm
+      _ = ∫ x, unitCubeIntegral (fun t => f (Fin.cons (x : ℂ)
+          (complexShift (Fin.tail y) t))) ∂unitIntervalMeasure := by
+        simpa [y'] using unitCubeIntegral_cons (hi y' hy')
+      _ = ∫ x, unitCubeIntegral (fun t => f (Fin.cons (x : ℂ) (complexify t)))
+          ∂unitIntervalMeasure := by
+        apply integral_congr_ae
+        apply Filter.Eventually.of_forall
+        intro x
+        apply ih (f := fun q => f (Fin.cons (x : ℂ) q))
+        · intro q hq
+          exact (hf _ (cons_mem_strip (by simp) hq)).comp
+            (f := fun w => (Fin.cons (x : ℂ) w : ComplexSpace (n + 1)))
+            (analyticAt_cons_tail _ q)
+        · intro q hq j
+          have hh := hp (Fin.cons (x : ℂ) q) (cons_mem_strip (by simp) hq) j.succ
+          have he : Function.update (Fin.cons (x : ℂ) q : ComplexSpace (n + 1)) j.succ
+              (q j + 1) =
+                Fin.cons (x : ℂ) (Function.update q j (q j + 1)) := by
+            ext i
+            refine Fin.cases ?_ (fun k => ?_) i
+            · rw [Function.update_of_ne (Ne.symm (Fin.succ_ne_zero j))]
+              rfl
+            · simp [Function.update_apply]
+          simp only [Fin.cons_succ] at hh
+          rw [he] at hh
+          exact hh
+        · exact fun j => hy j.succ
+      _ = _ := by
+        have he (x : ℝ) (t : RealSpace n) :
+            complexify (Fin.cons x t) = Fin.cons (x : ℂ) (complexify t) := by
+          ext j
+          exact Fin.cases rfl (fun _ => rfl) j
+        simpa only [he] using (unitCubeIntegral_cons hi0).symm
+
+end KamProject.Arnold1963
diff --git a/LeanPool/ArnoldKAM/Arnold1963/Analysis/ParameterIntegral.lean b/LeanPool/ArnoldKAM/Arnold1963/Analysis/ParameterIntegral.lean
new file mode 100644
index 0000000000..ed63916d4a
--- /dev/null
+++ b/LeanPool/ArnoldKAM/Arnold1963/Analysis/ParameterIntegral.lean
@@ -0,0 +1,139 @@
+/-
+Copyright (c) 2026 Bingqi Yu. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Bingqi Yu
+-/
+
+module
+
+public import LeanPool.ArnoldKAM.Arnold1963.Analysis.AnalyticLift
+public import Mathlib.MeasureTheory.Integral.Bochner.Set
+
+/-!
+Analyticity of integrals over compact parameter sets, obtained by lifting local power series
+and passing through a bounded integral linear map.
+-/
+
+@[expose] public section
+noncomputable section
+open MeasureTheory Set Filter
+open scoped Topology NNReal ENNReal BoundedContinuousFunction
+namespace KamProject.Arnold1963
+
+variable {X E F : Type*} [TopologicalSpace X] [MeasurableSpace X] [OpensMeasurableSpace X]
+  [NormedAddCommGroup E] [NormedSpace ℂ E] [NormedAddCommGroup F] [NormedSpace ℂ F]
+  {μ : Measure X} [IsFiniteMeasure μ] {f : E × F → ℂ} {g : X → F} {p : E}
+
+private theorem analytic_integral_local (hg : Continuous g) {x : X}
+    (hf : AnalyticAt ℂ f (p, g x)) :
+    ∃ U : Set X, IsOpen U ∧ x ∈ U ∧ ∀ s ⊆ U, MeasurableSet s →
+      AnalyticAt ℂ (fun a => ∫ t in s, f (a, g t) ∂μ) p ∧
+        ∀ᶠ a in 𝓝 p, IntegrableOn (fun t => f (a, g t)) s μ := by
+  obtain ⟨P, r, hP⟩ := hf
+  obtain ⟨R, hR, hRr⟩ := ENNReal.lt_iff_exists_nnreal_btwn.mp hP.r_pos
+  have hR0 : (0 : ℝ) < R := by exact_mod_cast hR
+  let U := {t : X | ‖g t - g x‖ < (R : ℝ) / 4}
+  refine ⟨U, isOpen_lt (hg.sub continuous_const).norm continuous_const, ?_, ?_⟩
+  · simp [U, hR0]
+  intro s hs hsm
+  let b : s →ᵇ (E × F) := BoundedContinuousFunction.ofNormedAddCommGroup
+    (fun t => (0, g t - g x))
+    (continuous_const.prodMk ((hg.comp continuous_subtype_val).sub continuous_const))
+    ((R : ℝ) / 4) (fun t => by simpa using (hs t.property).le)
+  have hb : ‖b‖ ≤ (R : ℝ) / 4 :=
+    (BoundedContinuousFunction.norm_le (by positivity)).mpr (fun t => by
+      simpa [b] using (hs t.property).le)
+  let L : E →L[ℂ] (s →ᵇ (E × F)) :=
+    boundedConstCLM.comp (ContinuousLinearMap.inl ℂ E F)
+  let v (a : E) : s →ᵇ (E × F) := L (a - p) + b
+  have hv_apply (a : E) (t : s) : v a t = (a - p, g t - g x) := by
+    simp [v, L, b, boundedConstCLM, Prod.add_def]
+  have hvp : v p = b := by simp [v]
+  have hv (a : E) (ha : a ∈ Metric.ball p ((R : ℝ) / 4)) :
+      v a ∈ Metric.eball 0 P.radius := by
+    have hn : ‖v a‖ < R := calc
+      ‖v a‖ ≤ ‖L (a - p)‖ + ‖b‖ := norm_add_le _ _
+      _ ≤ ‖a - p‖ + (R : ℝ) / 4 := add_le_add (by
+        simpa [L, boundedConstCLM] using
+          BoundedContinuousFunction.norm_const_le (α := s) (a - p, (0 : F))) hb
+      _ < R := by rw [Metric.mem_ball, dist_eq_norm] at ha; linarith
+    have he : ENNReal.ofReal ‖v a‖ < (R : ℝ≥0∞) := by
+      simpa using (ENNReal.ofReal_lt_ofReal_iff hR0).mpr hn
+    simpa [Metric.mem_eball, edist_dist, dist_zero_right] using he.trans (hRr.trans_le hP.r_le)
+  have hvb : b ∈ Metric.eball 0 (boundedSeriesLift (X := s) P).radius := by
+    rw [← hvp]
+    exact (hv p (Metric.mem_ball_self (by positivity))).trans_le (radius_boundedSeriesLift_le P)
+  let I := boundedIntegralCLM (μ.comap (Subtype.val : s → X))
+  have hsA : AnalyticAt ℂ (fun a : E => a - p) p := by
+    convert (analyticAt_id.sub (analyticAt_const (v := p) (x := p))) using 1; rfl
+  have hvA : AnalyticAt ℂ v p :=
+    ((L.analyticAt (p - p)).comp (f := fun a => a - p) hsA).add analyticAt_const
+  have hA : AnalyticAt ℂ (fun a => I ((boundedSeriesLift P).sum (v a))) p := by
+    have h := (boundedSeriesLift (X := s) P).analyticOnNhd b hvb
+    rw [← hvp] at h
+    exact (I.analyticAt _).comp (f := fun a => (boundedSeriesLift P).sum (v a))
+      (h.comp (f := v) hvA)
+  have he (a : E) (ha : a ∈ Metric.ball p ((R : ℝ) / 4)) (t : s) :
+      (boundedSeriesLift P).sum (v a) t = f (a, g t) := by
+    rw [boundedSeriesLift_sum_apply P (hv a ha)]
+    have hpt : v a t ∈ Metric.eball 0 r := by
+      have hn : ‖v a t‖ < R := by
+        rw [hv_apply]
+        rw [Prod.norm_def, max_lt_iff]
+        constructor
+        · have := Metric.mem_ball.mp ha; rw [dist_eq_norm] at this; linarith
+        · have := hs t.property; dsimp [U] at this; linarith
+      have he : ENNReal.ofReal ‖v a t‖ < (R : ℝ≥0∞) := by
+        simpa using (ENNReal.ofReal_lt_ofReal_iff hR0).mpr hn
+      simpa [Metric.mem_eball, edist_dist, dist_zero_right] using he.trans hRr
+    have hh := (hP.hasSum hpt).tsum_eq
+    simpa [FormalMultilinearSeries.sum, v, L, b, boundedConstCLM,
+      Prod.add_def] using hh
+  have hloc : ∀ᶠ a in 𝓝 p,
+      (I ((boundedSeriesLift P).sum (v a)) = ∫ t in s, f (a, g t) ∂μ) ∧
+        IntegrableOn (fun t => f (a, g t)) s μ := by
+    filter_upwards [Metric.ball_mem_nhds p (by positivity : (0 : ℝ) < (R : ℝ) / 4)] with a ha
+    constructor
+    · change (∫ t : s, (boundedSeriesLift P).sum (v a) t ∂μ.comap Subtype.val) = _
+      simp_rw [he a ha]
+      exact integral_subtype_comap (μ := μ) hsm (fun t => f (a, g t))
+    · rw [integrableOn_iff_comap_subtypeVal hsm]
+      have hi := ((boundedSeriesLift P).sum (v a)).integrable (μ.comap Subtype.val)
+      exact hi.congr (Filter.Eventually.of_forall (fun t => he a ha t))
+  exact ⟨hA.congr (hloc.mono fun _ h => h.1), hloc.mono fun _ h => h.2⟩
+
+theorem analyticAt_integral_compact (hg : Continuous g) {K : Set X} (hK : IsCompact K)
+    (hKm : MeasurableSet K) (hf : ∀ t ∈ K, AnalyticAt ℂ f (p, g t)) :
+    AnalyticAt ℂ (fun a => ∫ t in K, f (a, g t) ∂μ) p := by
+  let Good (s : Set X) := ∃ U : Set X, IsOpen U ∧ s ⊆ U ∧
+    ∀ t ⊆ U, MeasurableSet t →
+      AnalyticAt ℂ (fun a => ∫ x in t, f (a, g x) ∂μ) p ∧
+        ∀ᶠ a in 𝓝 p, IntegrableOn (fun x => f (a, g x)) t μ
+  have hgood : Good K := by
+    refine hK.induction_on (p := Good) ?_ ?_ ?_ ?_
+    · refine ⟨∅, isOpen_empty, Subset.rfl, ?_⟩
+      intro t ht htm
+      have he : t = ∅ := subset_empty_iff.mp ht
+      subst t
+      simp only [setIntegral_empty]
+      exact ⟨analyticAt_const, Filter.Eventually.of_forall (fun _ => integrableOn_empty)⟩
+    · rintro s t hst ⟨U, ho, ht, hu⟩
+      exact ⟨U, ho, hst.trans ht, hu⟩
+    · rintro s t ⟨U, hU, hs, hu⟩ ⟨V, hV, ht, hv⟩
+      refine ⟨U ∪ V, hU.union hV, union_subset_union hs ht, ?_⟩
+      intro A hA hm
+      obtain ⟨ha, hia⟩ := hu (A ∩ U) inter_subset_right (hm.inter hU.measurableSet)
+      obtain ⟨hb, hib⟩ := hv (A \ U) (by grind) (hm.diff hU.measurableSet)
+      have hi : ∀ᶠ a in 𝓝 p, IntegrableOn (fun x => f (a, g x)) A μ := by
+        filter_upwards [hia, hib] with a ha hb
+        simpa only [inter_union_sdiff] using ha.union hb
+      refine ⟨(ha.add hb).congr ?_, hi⟩
+      filter_upwards [hi] with a ha
+      exact integral_inter_add_sdiff hU.measurableSet ha
+    · intro x hx
+      obtain ⟨U, ho, hxU, hu⟩ := analytic_integral_local (μ := μ) hg (hf x hx)
+      exact ⟨U, mem_nhdsWithin_of_mem_nhds (ho.mem_nhds hxU), U, ho, Subset.rfl, hu⟩
+  obtain ⟨U, _, hKU, hU⟩ := hgood
+  exact (hU K hKU hKm).1
+
+end KamProject.Arnold1963
diff --git a/LeanPool/ArnoldKAM/Arnold1963/Analysis/PhaseCauchy.lean b/LeanPool/ArnoldKAM/Arnold1963/Analysis/PhaseCauchy.lean
new file mode 100644
index 0000000000..4ec9cdfb0b
--- /dev/null
+++ b/LeanPool/ArnoldKAM/Arnold1963/Analysis/PhaseCauchy.lean
@@ -0,0 +1,95 @@
+/-
+Copyright (c) 2026 Bingqi Yu. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Bingqi Yu
+-/
+
+module
+
+public import LeanPool.ArnoldKAM.Arnold1963.Analysis.SecondCauchy
+public import LeanPool.ArnoldKAM.Arnold1963.Analysis.DomainBuffer
+public import LeanPool.ArnoldKAM.Arnold1963.Basic.Symplectic
+
+/-!
+Coordinate second-derivative bounds and rectangular buffers in complex phase space.
+-/
+
+@[expose] public section
+noncomputable section
+open Set
+open scoped NNReal
+namespace KamProject.Arnold1963
+
+/-- The coordinate basis of phase space, with action coordinates preceding angle coordinates. -/
+abbrev phaseBasis {n : ℕ} : Fin n ⊕ Fin n → ComplexPhaseSpace n := phaseDirection
+
+theorem norm_phaseBasis {n : ℕ} (j : Fin n ⊕ Fin n) : ‖phaseBasis j‖ = 1 := by
+  cases j <;> simp [phaseBasis, phaseDirection]
+
+private theorem norm_single_add_le {n : ℕ} {i j : Fin n} (h : i ≠ j) :
+    ‖(Pi.single i 1 : ComplexSpace n) + Pi.single j 1‖ ≤ 1 := by
+  apply (complex_norm_le_iff _ zero_le_one).mpr
+  intro k
+  by_cases hi : k = i <;> by_cases hj : k = j <;> simp_all
+
+private theorem norm_single_sub_le {n : ℕ} {i j : Fin n} (h : i ≠ j) :
+    ‖(Pi.single i 1 : ComplexSpace n) - Pi.single j 1‖ ≤ 1 := by
+  apply (complex_norm_le_iff _ zero_le_one).mpr
+  intro k
+  by_cases hi : k = i <;> by_cases hj : k = j <;> simp_all
+
+theorem norm_phaseBasis_add_le {n : ℕ} {i j : Fin n ⊕ Fin n} (h : i ≠ j) :
+    ‖phaseBasis i + phaseBasis j‖ ≤ 1 := by
+  cases i with
+  | inl i =>
+    cases j with
+    | inl j =>
+      simpa [phaseBasis, phaseDirection, pDirection, phase_norm_eq] using
+        norm_single_add_le (by simpa using h)
+    | inr j => simp [phaseBasis, phaseDirection, pDirection, qDirection, Pi.norm_single]
+  | inr i =>
+    cases j with
+    | inl j => simp [phaseBasis, phaseDirection, pDirection, qDirection, Pi.norm_single]
+    | inr j =>
+      simpa [phaseBasis, phaseDirection, qDirection, phase_norm_eq] using
+        norm_single_add_le (by simpa using h)
+
+theorem norm_phaseBasis_sub_le {n : ℕ} {i j : Fin n ⊕ Fin n} (h : i ≠ j) :
+    ‖phaseBasis i - phaseBasis j‖ ≤ 1 := by
+  cases i with
+  | inl i =>
+    cases j with
+    | inl j =>
+      simpa [phaseBasis, phaseDirection, pDirection, phase_norm_eq] using
+        norm_single_sub_le (by simpa using h)
+    | inr j => simp [phaseBasis, phaseDirection, pDirection, qDirection, Pi.norm_single]
+  | inr i =>
+    cases j with
+    | inl j => simp [phaseBasis, phaseDirection, pDirection, qDirection, Pi.norm_single]
+    | inr j =>
+      simpa [phaseBasis, phaseDirection, qDirection, phase_norm_eq] using
+        norm_single_sub_le (by simpa using h)
+
+theorem norm_second_phaseCoordinate_le {n : ℕ} {f : ComplexPhaseSpace n → ℂ}
+    {U : Set (ComplexPhaseSpace n)} {r : ℝ≥0} {M : ℝ} {x : ComplexPhaseSpace n}
+    (hr : 0 < r) (hf : AnalyticOnNhd ℂ f U) (hM : NormBoundOn f U M)
+    (hx : x ∈ erosion U r) (i j : Fin n ⊕ Fin n) :
+    ‖fderiv ℂ (fderiv ℂ f) x (phaseBasis i) (phaseBasis j)‖ ≤ 2 * M / (r : ℝ) ^ 2 := by
+  by_cases hij : i = j
+  · subst j
+    exact norm_second_fderiv_diag_le hr hf hM hx (norm_phaseBasis i).le
+  · apply (norm_second_fderiv_mixed_le hr hf hM hx
+      (norm_phaseBasis_add_le hij) (norm_phaseBasis_sub_le hij)).trans
+    apply div_le_div_of_nonneg_right _ (sq_nonneg _)
+    linarith [hM.nonneg]
+
+theorem phaseDomain_buffer_of_neighborhood {n : ℕ} {S T : Set (ComplexSpace n)}
+    {r σ τ : ℝ≥0} (hrσ : r ≤ σ) (hτσ : τ ≤ σ - r)
+    (hST : closedBallNeighborhood S r ⊆ T) :
+    phaseDomain S τ ⊆ erosion (phaseDomain T σ) r := by
+  apply Subset.trans _ (phaseDomain_shrink_subset_erosion T hrσ)
+  apply Set.prod_mono _ (angleStrip_mono hτσ)
+  intro x hx y hy
+  exact hST ⟨x, hx, hy⟩
+
+end KamProject.Arnold1963
diff --git a/LeanPool/ArnoldKAM/Arnold1963/Analysis/PolydiscCauchy.lean b/LeanPool/ArnoldKAM/Arnold1963/Analysis/PolydiscCauchy.lean
new file mode 100644
index 0000000000..cd32ced98e
--- /dev/null
+++ b/LeanPool/ArnoldKAM/Arnold1963/Analysis/PolydiscCauchy.lean
@@ -0,0 +1,126 @@
+/-
+Copyright (c) 2026 Bingqi Yu. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Bingqi Yu
+-/
+
+module
+
+public import LeanPool.ArnoldKAM.Arnold1963.Analysis.ParameterIntegral
+public import Mathlib.Analysis.Complex.CauchyIntegral
+public import Mathlib.MeasureTheory.Integral.TorusIntegral
+
+/-!
+The multivariable Cauchy integral formula on polydiscs, proved by coordinate induction.
+-/
+
+@[expose] public section
+noncomputable section
+open Set Metric MeasureTheory Complex
+open scoped Topology
+namespace KamProject.Arnold1963
+
+/-- The product Cauchy kernel for integration on a polydisc boundary. -/
+def cauchyKernel {n : ℕ} (w z : ComplexSpace n) : ℂ := ∏ i, (z i - w i)⁻¹
+
+theorem continuous_torusMap {n : ℕ} (c : ComplexSpace n) (r : RealSpace n) :
+    Continuous (torusMap c r) := by
+  unfold torusMap
+  fun_prop
+
+theorem torusMap_mem_pi_closedBall {n : ℕ} (c : ComplexSpace n) {r : RealSpace n}
+    (hr : ∀ i, 0 ≤ r i) (t : RealSpace n) :
+    torusMap c r t ∈ pi univ (fun i => closedBall (c i) (r i)) := by
+  intro i _
+  simp [mem_closedBall, dist_eq_norm, torusMap, abs_of_nonneg (hr i)]
+
+theorem torusMap_sub_ne_zero {n : ℕ} {c w : ComplexSpace n} {r : RealSpace n}
+    (hw : ∀ i, w i ∈ ball (c i) (r i)) (t : RealSpace n) (i : Fin n) :
+    torusMap c r t i - w i ≠ 0 := by
+  intro he
+  have hh := hw i
+  rw [← sub_eq_zero.mp he] at hh
+  have hr : 0 ≤ r i := (dist_nonneg.trans (mem_ball.mp hh).le)
+  simp [mem_ball, dist_eq_norm, torusMap, abs_of_nonneg hr] at hh
+
+theorem continuous_cauchy_boundary {n : ℕ} {f : ComplexSpace n → ℂ}
+    {c w : ComplexSpace n} {r : RealSpace n} (hr : ∀ i, 0 ≤ r i)
+    (hf : ContinuousOn f (pi univ (fun i => closedBall (c i) (r i))))
+    (hw : ∀ i, w i ∈ ball (c i) (r i)) :
+    Continuous (fun t => cauchyKernel w (torusMap c r t) * f (torusMap c r t)) := by
+  apply Continuous.mul
+  · apply continuous_finsetProd
+    intro i _
+    exact (((continuous_apply i).comp (continuous_torusMap c r)).sub continuous_const).inv₀
+      (fun t => torusMap_sub_ne_zero hw t i)
+  · exact hf.comp_continuous (continuous_torusMap c r) (torusMap_mem_pi_closedBall c hr)
+
+theorem polydisc_cauchy {n : ℕ} {f : ComplexSpace n → ℂ}
+    {c w : ComplexSpace n} {r : RealSpace n} (hr : ∀ i, 0 < r i)
+    (hf : AnalyticOnNhd ℂ f (pi univ (fun i => closedBall (c i) (r i))))
+    (hw : ∀ i, w i ∈ ball (c i) (r i)) :
+    torusIntegral (fun z => cauchyKernel w z * f z) c r =
+      (2 * Real.pi * I : ℂ) ^ n * f w := by
+  induction n with
+  | zero => simp [cauchyKernel, torusIntegral_dim0, Subsingleton.elim c w]
+  | succ n ih =>
+    have hi : TorusIntegrable (fun z => cauchyKernel w z * f z) c r :=
+      (continuous_cauchy_boundary (fun i => (hr i).le)
+        hf.continuousOn hw).continuousOn.integrableOn_compact
+        isCompact_Icc
+    rw [torusIntegral_succ hi]
+    have he (z : ℂ) (hz : z ∈ sphere (c 0) (r 0)) :
+        torusIntegral (fun y => cauchyKernel w (Fin.cons z y) * f (Fin.cons z y))
+          (c ∘ Fin.succ) (r ∘ Fin.succ) =
+        (z - w 0)⁻¹ * ((2 * Real.pi * I : ℂ) ^ n * f (Fin.cons z (w ∘ Fin.succ))) := by
+      have hslice : AnalyticOnNhd ℂ (fun y : ComplexSpace n => f (Fin.cons z y))
+          (pi univ (fun i => closedBall (c i.succ) (r i.succ))) := by
+        intro y hy
+        have ha : AnalyticAt ℂ
+            (fun y : ComplexSpace n => (Fin.cons z y : ComplexSpace (n+1))) y := by
+          apply AnalyticAt.pi
+          intro i
+          refine Fin.cases ?_ (fun j => ?_) i
+          · exact analyticAt_const
+          · exact (ContinuousLinearMap.proj (R := ℂ) (φ := fun _ : Fin n => ℂ) j).analyticAt y
+        have hm : Fin.cons z y ∈ pi univ (fun i => closedBall (c i) (r i)) := by
+          intro i _
+          refine Fin.cases ?_ (fun j => ?_) i
+          · exact sphere_subset_closedBall hz
+          · exact hy j (mem_univ j)
+        exact (hf _ hm).comp (f := fun y : ComplexSpace n => (Fin.cons z y : ComplexSpace (n+1))) ha
+      have hk : (fun y : ComplexSpace n => cauchyKernel w (Fin.cons z y) * f (Fin.cons z y)) =
+          fun y => (z - w 0)⁻¹ * (cauchyKernel (w ∘ Fin.succ) y * f (Fin.cons z y)) := by
+        funext y
+        simp [cauchyKernel, Fin.prod_univ_succ, mul_assoc, mul_comm]
+      rw [hk, torusIntegral_const_mul]
+      exact congrArg (fun a : ℂ => (z - w 0)⁻¹ * a)
+        (ih (c := c ∘ Fin.succ) (w := w ∘ Fin.succ) (r := r ∘ Fin.succ)
+          (fun i => hr i.succ) hslice (fun i => hw i.succ))
+    rw [circleIntegral.integral_congr (hr 0).le he]
+    have hd : DifferentiableOn ℂ (fun z => f (Fin.cons z (w ∘ Fin.succ)))
+        (closedBall (c 0) (r 0)) := by
+      intro z hz
+      have hm : Fin.cons z (w ∘ Fin.succ) ∈ pi univ (fun i => closedBall (c i) (r i)) := by
+        intro i _
+        refine Fin.cases hz (fun j => ball_subset_closedBall (hw j.succ)) i
+      have ha : AnalyticAt ℂ (fun z : ℂ => (Fin.cons z (w ∘ Fin.succ) : ComplexSpace (n+1))) z := by
+        apply AnalyticAt.pi
+        intro i
+        exact Fin.cases analyticAt_id (fun _ => analyticAt_const) i
+      have hh := (hf _ hm).comp
+        (f := fun z : ℂ => (Fin.cons z (w ∘ Fin.succ) : ComplexSpace (n+1))) ha
+      exact hh.differentiableAt.differentiableWithinAt
+    have hc := hd.circleIntegral_sub_inv_smul (hw 0)
+    have hex : (fun z : ℂ => (z - w 0)⁻¹ * ((2 * Real.pi * I : ℂ) ^ n *
+        f (Fin.cons z (w ∘ Fin.succ)))) =
+        fun z => (2 * Real.pi * I : ℂ) ^ n *
+          ((z - w 0)⁻¹ * f (Fin.cons z (w ∘ Fin.succ))) := by funext z; ring
+    rw [hex, circleIntegral.integral_const_mul]
+    have hwcons : Fin.cons (w 0) (w ∘ Fin.succ) = w := by
+      ext i
+      exact Fin.cases rfl (fun _ => rfl) i
+    simpa [smul_eq_mul, ← mul_assoc, pow_succ, hwcons] using congrArg
+      (fun a : ℂ => (2 * Real.pi * I : ℂ) ^ n * a) hc
+
+end KamProject.Arnold1963
diff --git a/LeanPool/ArnoldKAM/Arnold1963/Analysis/SecondCauchy.lean b/LeanPool/ArnoldKAM/Arnold1963/Analysis/SecondCauchy.lean
new file mode 100644
index 0000000000..d7dc98f5a8
--- /dev/null
+++ b/LeanPool/ArnoldKAM/Arnold1963/Analysis/SecondCauchy.lean
@@ -0,0 +1,126 @@
+/-
+Copyright (c) 2026 Bingqi Yu. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Bingqi Yu
+-/
+
+module
+
+public import LeanPool.ArnoldKAM.Arnold1963.Analysis.Cauchy
+public import Mathlib.Analysis.Calculus.FDeriv.Symmetric
+
+/-!
+Second Frechet derivative bounds from one-variable Cauchy estimates. Symmetric bilinear
+polarization improves the mixed-coordinate constant when both sum and difference directions
+lie in the unit ball.
+-/
+
+@[expose] public section
+
+noncomputable section
+open scoped NNReal Topology
+namespace KamProject.Arnold1963
+
+section Lines
+variable {E F : Type*} [NormedAddCommGroup E] [NormedSpace ℂ E]
+  [NormedAddCommGroup F] [NormedSpace ℂ F]
+
+theorem deriv_line_eq_fderiv {f : E → F} {x v : E} {z : ℂ}
+    (hf : DifferentiableAt ℂ f (x + z • v)) :
+    deriv (fun w : ℂ => f (x + w • v)) z = fderiv ℂ f (x + z • v) v := by
+  have hline : HasDerivAt (fun w : ℂ => x + w • v) v z := by
+    simpa using ((hasDerivAt_id z).smul_const v).const_add x
+  simpa [Function.comp_def] using (hf.hasFDerivAt.comp_hasDerivAt z hline).deriv
+
+variable [CompleteSpace F]
+
+theorem iteratedDeriv_two_line_eq {f : E → F} {U : Set E} {r : ℝ≥0}
+    {x v : E} (hr : 0 < r) (hf : AnalyticOnNhd ℂ f U)
+    (hx : x ∈ erosion U r) (hv : ‖v‖ ≤ 1) :
+    iteratedDeriv 2 (fun z : ℂ => f (x + z • v)) 0 =
+      fderiv ℂ (fderiv ℂ f) x v v := by
+  have heq : (fun z => deriv (fun w : ℂ => f (x + w • v)) z) =ᶠ[𝓝 (0 : ℂ)]
+      (fun z => fderiv ℂ f (x + z • v) v) := by
+    filter_upwards [Metric.ball_mem_nhds (0 : ℂ) hr] with z hz
+    apply deriv_line_eq_fderiv
+    have hz' : ‖z‖ < (r : ℝ) := by simpa using hz
+    exact (hf _ (line_mem_of_mem_erosion hx hv hz'.le)).differentiableAt
+  have hline : HasDerivAt (fun z : ℂ => x + z • v) v 0 := by
+    simpa using ((hasDerivAt_id (0 : ℂ)).smul_const v).const_add x
+  have hdf : HasFDerivAt (fderiv ℂ f) (fderiv ℂ (fderiv ℂ f) x) (x + (0 : ℂ) • v) := by
+    simpa using (hf x (erosion_subset U r hx)).fderiv.differentiableAt.hasFDerivAt
+  have hdfLine : HasDerivAt (fun z : ℂ => fderiv ℂ f (x + z • v))
+      (fderiv ℂ (fderiv ℂ f) x v) 0 := hdf.comp_hasDerivAt 0 hline
+  have hd : HasDerivAt (fun z : ℂ => fderiv ℂ f (x + z • v) v)
+      (fderiv ℂ (fderiv ℂ f) x v v) 0 := by
+    simpa using hdfLine.clm_apply (hasDerivAt_const (0 : ℂ) v)
+  rw [show (2 : ℕ) = 1 + 1 from rfl, iteratedDeriv_succ, iteratedDeriv_one, heq.deriv_eq]
+  simpa [Function.comp_def] using hd.deriv
+
+theorem norm_second_fderiv_diag_le {f : E → F} {U : Set E} {r : ℝ≥0}
+    {M : ℝ} {x v : E} (hr : 0 < r) (hf : AnalyticOnNhd ℂ f U)
+    (hM : NormBoundOn f U M) (hx : x ∈ erosion U r) (hv : ‖v‖ ≤ 1) :
+    ‖fderiv ℂ (fderiv ℂ f) x v v‖ ≤ 2 * M / (r : ℝ) ^ 2 := by
+  have hg : DifferentiableOn ℂ (fun z : ℂ => f (x + z • v))
+      (Metric.closedBall 0 (r : ℝ)) := by
+    intro z hz
+    exact ((hf _ (line_mem_of_mem_erosion hx hv (by simpa using hz))).differentiableAt.comp z
+      ((differentiableAt_id.smul_const v).const_add x)).differentiableWithinAt
+  have h := Complex.norm_iteratedDeriv_le_of_forall_mem_sphere_norm_le 2 hr
+    (hg.diffContOnCl_ball (Set.Subset.refl _))
+    (fun z hz => hM.norm_le (line_mem_of_mem_erosion hx hv (by simpa using le_of_eq hz)))
+  simpa [iteratedDeriv_two_line_eq hr hf hx hv] using h
+
+end Lines
+
+theorem norm_second_fderiv_mixed_le {E : Type*} [NormedAddCommGroup E] [NormedSpace ℂ E]
+    {f : E → ℂ} {U : Set E} {r : ℝ≥0} {M : ℝ} {x v w : E}
+    (hr : 0 < r) (hf : AnalyticOnNhd ℂ f U) (hM : NormBoundOn f U M)
+    (hx : x ∈ erosion U r) (hplus : ‖v + w‖ ≤ 1) (hminus : ‖v - w‖ ≤ 1) :
+    ‖fderiv ℂ (fderiv ℂ f) x v w‖ ≤ M / (r : ℝ) ^ 2 := by
+  let B := fderiv ℂ (fderiv ℂ f) x
+  have hsym : B w v = B v w :=
+    (hf x (erosion_subset U r hx)).contDiffAt.isSymmSndFDerivAt_of_omega w v
+  have hid : (4 : ℂ) * B v w = B (v + w) (v + w) - B (v - w) (v - w) := by
+    simp only [map_add, map_sub, add_apply, sub_apply]
+    rw [hsym]
+    ring
+  have hp := norm_second_fderiv_diag_le hr hf hM hx hplus
+  have hm := norm_second_fderiv_diag_le hr hf hM hx hminus
+  have hb := (norm_sub_le (B (v + w) (v + w)) (B (v - w) (v - w))).trans (add_le_add hp hm)
+  rw [← hid, norm_mul] at hb
+  norm_num at hb
+  simp only [mul_div_assoc] at hb
+  dsimp [B] at hb
+  linarith only [hb]
+
+theorem norm_second_coordinate_le {n : ℕ} {f : ComplexSpace n → ℂ}
+    {U : Set (ComplexSpace n)} {r : ℝ≥0} {M : ℝ} {x : ComplexSpace n}
+    (hr : 0 < r) (hf : AnalyticOnNhd ℂ f U) (hM : NormBoundOn f U M)
+    (hx : x ∈ erosion U r) (i j : Fin n) :
+    ‖fderiv ℂ (fderiv ℂ f) x (Pi.single i 1) (Pi.single j 1)‖ ≤
+      2 * M / (r : ℝ) ^ 2 := by
+  by_cases hij : i = j
+  · subst j
+    exact norm_second_fderiv_diag_le hr hf hM hx (by simp [Pi.norm_single])
+  · have hp : ‖(Pi.single i 1 : ComplexSpace n) + Pi.single j 1‖ ≤ 1 := by
+      apply (complex_norm_le_iff _ zero_le_one).2
+      intro k
+      by_cases hi : k = i <;> by_cases hj : k = j
+      · exact False.elim (hij (hi.symm.trans hj))
+      · simp [hi, hij]
+      · simp [hj, Ne.symm hij]
+      · simp [hi, hj]
+    have hm : ‖(Pi.single i 1 : ComplexSpace n) - Pi.single j 1‖ ≤ 1 := by
+      apply (complex_norm_le_iff _ zero_le_one).2
+      intro k
+      by_cases hi : k = i <;> by_cases hj : k = j
+      · exact False.elim (hij (hi.symm.trans hj))
+      · simp [hi, hij]
+      · simp [hj, Ne.symm hij]
+      · simp [hi, hj]
+    refine (norm_second_fderiv_mixed_le hr hf hM hx hp hm).trans ?_
+    apply div_le_div_of_nonneg_right _ (sq_nonneg _)
+    linarith [hM.nonneg]
+
+end KamProject.Arnold1963
diff --git a/LeanPool/ArnoldKAM/Arnold1963/Analysis/ShiftedFourier.lean b/LeanPool/ArnoldKAM/Arnold1963/Analysis/ShiftedFourier.lean
new file mode 100644
index 0000000000..3b2f5777c3
--- /dev/null
+++ b/LeanPool/ArnoldKAM/Arnold1963/Analysis/ShiftedFourier.lean
@@ -0,0 +1,191 @@
+/-
+Copyright (c) 2026 Bingqi Yu. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Bingqi Yu
+-/
+
+module
+
+public import LeanPool.ArnoldKAM.Arnold1963.Analysis.FourierDecay
+public import LeanPool.ArnoldKAM.Arnold1963.Analysis.FourierSeries
+
+/-!
+Fourier reconstruction on shifted real tori inside the complex angle strip.
+-/
+
+@[expose] public section
+noncomputable section
+open Complex MeasureTheory
+open scoped NNReal
+namespace KamProject.Arnold1963
+
+/-- Normalized Haar measure for contour-shifted Fourier integration. -/
+local instance shiftedFourierMeasureSpace : MeasureSpace UnitAddCircle := ⟨AddCircle.haarAddCircle⟩
+local instance : IsProbabilityMeasure (volume : Measure UnitAddCircle) :=
+  inferInstanceAs (IsProbabilityMeasure AddCircle.haarAddCircle)
+
+theorem fourierMonomial_add {n : ℕ} (k : FourierIndex n) (q z : ComplexSpace n) :
+    fourierMonomial k (q + z) = fourierMonomial k q * fourierMonomial k z := by
+  simp [fourierMonomial, indexPairing, mul_add, Finset.sum_add_distrib, exp_add]
+
+theorem fourierMonomial_neg_mul {n : ℕ} (k : FourierIndex n) (q : ComplexSpace n) :
+    fourierMonomial (-k) q * fourierMonomial k q = 1 := by
+  simp only [fourierMonomial, indexPairing, Pi.neg_apply, Int.cast_neg, neg_mul,
+    Finset.sum_neg_distrib, mul_neg, ← exp_add, neg_add_cancel, exp_zero]
+
+theorem unitFourierWeight_eq_monomial {n : ℕ} (k : FourierIndex n) (q : ComplexSpace n) :
+    unitFourierWeight k q = fourierMonomial (-k) (angleScale n q) := by
+  unfold unitFourierWeight fourierMonomial indexPairing
+  rw [Finset.mul_sum, Finset.mul_sum]
+  congr 1
+  apply Finset.sum_congr rfl
+  intro j hj
+  simp only [Pi.neg_apply, Int.cast_neg, angleScale_apply]
+  ring
+
+theorem angleScale_shift_split {n : ℕ} (y x : RealSpace n) :
+    angleScale n (complexShift y x) = scaledAngle x + angleScale n (complexShift y 0) := by
+  ext j
+  simp [complexShift, scaledAngle, complexify, mul_add]
+
+theorem unitFourierWeight_shift_split {n : ℕ} (k : FourierIndex n) (y x : RealSpace n) :
+    unitFourierWeight k (complexShift y x) =
+      unitFourierWeight k (complexify x) *
+        fourierMonomial (-k) (angleScale n (complexShift y 0)) := by
+  rw [unitFourierWeight_eq_monomial, angleScale_shift_split, fourierMonomial_add,
+    unitFourierWeight_real]
+
+private theorem scaled_shift_repr_eq {n : ℕ} (y t : RealSpace n) :
+    ∃ k : FourierIndex n,
+      angleScale n (complexShift y (unitTorusRepr (fun j => (t j : UnitAddCircle)))) =
+        angleScale n (complexShift y t) + angleShift k := by
+  classical
+  have hex : ∀ j : Fin n, ∃ k : ℤ,
+      unitTorusRepr (fun j => (t j : UnitAddCircle)) j = t j + k := by
+    intro j
+    have he : ((unitTorusRepr (fun j => (t j : UnitAddCircle)) j - t j : ℝ) :
+        UnitAddCircle) = 0 := by
+      simp [unitTorusRepr, AddCircle.coe_equivIoc]
+    obtain ⟨k, hk⟩ := (AddCircle.coe_eq_zero_iff (p := (1 : ℝ))).mp he
+    refine ⟨k, ?_⟩
+    simp only [zsmul_eq_mul, mul_one] at hk
+    linarith
+  choose k hk using hex
+  refine ⟨k, ?_⟩
+  ext j
+  simp [complexShift, angleShift, complexify, hk, mul_add]
+  ring
+
+namespace AnalyticPhaseFunction
+variable {n : ℕ} {G : Set (ComplexSpace n)} {ρ : ℝ≥0}
+
+/-- Evaluation on a complex-shifted unit torus at a fixed action. -/
+def shiftedTorusValue (f : AnalyticPhaseFunction n G ρ) (p : ComplexSpace n)
+    (y : RealSpace n) (t : UnitAddTorus (Fin n)) : ℂ :=
+  f.toFun (p, angleScale n (complexShift y (unitTorusRepr t)))
+
+theorem shiftedTorusValue_coe (f : AnalyticPhaseFunction n G ρ) {p : ComplexSpace n}
+    (hp : p ∈ G) (y : RealSpace n) (hy : ∀ j, |y j| ≤ normalizedWidth ρ) (t : RealSpace n) :
+    f.shiftedTorusValue p y (fun j => (t j : UnitAddCircle)) =
+      f.toFun (p, angleScale n (complexShift y t)) := by
+  obtain ⟨k, hk⟩ := scaled_shift_repr_eq y t
+  unfold shiftedTorusValue
+  rw [hk]
+  exact f.periodic p hp _ (angleScale_mem_strip (complexShift_mem_strip _ _ hy)) k
+
+theorem continuous_shiftedTorusValue (f : AnalyticPhaseFunction n G ρ) {p : ComplexSpace n}
+    (hp : p ∈ G) (y : RealSpace n) (hy : ∀ j, |y j| ≤ normalizedWidth ρ) :
+    Continuous (f.shiftedTorusValue p y) := by
+  have hquot : IsOpenQuotientMap
+      (fun t : RealSpace n => (fun j => (t j : UnitAddCircle))) :=
+    IsOpenQuotientMap.piMap (fun _ : Fin n => QuotientAddGroup.isOpenQuotientMap_mk)
+  apply hquot.continuous_comp_iff.mp
+  have he : f.shiftedTorusValue p y ∘ (fun t : RealSpace n => fun j => (t j : UnitAddCircle)) =
+      fun t => f.toFun (p, angleScale n (complexShift y t)) :=
+    funext (f.shiftedTorusValue_coe hp y hy)
+  rw [he]
+  apply f.analytic.continuousOn.comp_continuous
+  · apply continuous_const.prodMk
+    exact (angleScale n).continuous.comp (by unfold complexShift; fun_prop)
+  · intro t
+    exact ⟨hp, angleScale_mem_strip (complexShift_mem_strip _ _ hy)⟩
+
+/-- The continuous shifted-torus function used to move the Fourier integration contour. -/
+def onShiftedTorus (f : AnalyticPhaseFunction n G ρ) {p : ComplexSpace n}
+    (hp : p ∈ G) (y : RealSpace n) (hy : ∀ j, |y j| ≤ normalizedWidth ρ) :
+    C(UnitAddTorus (Fin n), ℂ) :=
+  ⟨f.shiftedTorusValue p y, f.continuous_shiftedTorusValue hp y hy⟩
+
+theorem fourierCoeff_eq_shifted_unitCube (f : AnalyticPhaseFunction n G ρ)
+    {p : ComplexSpace n} (hp : p ∈ G) (k : FourierIndex n)
+    (y : RealSpace n) (hy : ∀ j, |y j| ≤ normalizedWidth ρ) :
+    f.fourierCoeff p k = unitCubeIntegral (fun x =>
+      f.toFun (p, angleScale n (complexShift y x)) * unitFourierWeight k (complexShift y x)) := by
+  rw [f.fourierCoeff_eq_unitCubeIntegral hp]
+  symm
+  apply unitCubeIntegral_shift_eq (r := normalizedWidth ρ)
+    (f := fun q => f.toFun (p, angleScale n q) * unitFourierWeight k q) (y := y)
+  · intro q hq
+    have hpair : AnalyticAt ℂ (fun z : ComplexSpace n => (p, angleScale n z)) q :=
+      analyticAt_const.prod ((angleScale n).analyticAt q)
+    have hfq := f.analytic (p, angleScale n q) ⟨hp, angleScale_mem_strip (ρ := ρ) hq⟩
+    exact (hfq.comp (f := fun z : ComplexSpace n => (p, angleScale n z)) hpair).mul
+      (analyticAt_unitFourierWeight k q)
+  · intro q hq j
+    rw [angleScale_update_one, f.periodic p hp _ (angleScale_mem_strip hq),
+      unitFourierWeight_periodic]
+  · exact hy
+
+theorem shiftedCoeff_eq_unitCube (f : AnalyticPhaseFunction n G ρ)
+    {p : ComplexSpace n} (hp : p ∈ G) (y : RealSpace n)
+    (hy : ∀ j, |y j| ≤ normalizedWidth ρ) (k : FourierIndex n) :
+    UnitAddTorus.mFourierCoeff (f.shiftedTorusValue p y) k = unitCubeIntegral (fun x =>
+      f.toFun (p, angleScale n (complexShift y x)) * unitFourierWeight k (complexify x)) := by
+  rw [UnitAddTorus.mFourierCoeff_eq_integral _ _ (0 : RealSpace n)]
+  unfold unitCubeIntegral
+  rw [unitCubeMeasure_eq_restrict_Ioc]
+  simp only [Pi.zero_apply, zero_add]
+  apply integral_congr_ae
+  apply Filter.Eventually.of_forall
+  intro x
+  dsimp only
+  rw [f.shiftedTorusValue_coe hp y hy, smul_eq_mul, mFourier_eq_fourierMonomial,
+    unitFourierWeight_real, mul_comm]
+
+theorem shiftedCoeff_eq (f : AnalyticPhaseFunction n G ρ) {p : ComplexSpace n}
+    (hp : p ∈ G) (y : RealSpace n) (hy : ∀ j, |y j| ≤ normalizedWidth ρ) (k : FourierIndex n) :
+    UnitAddTorus.mFourierCoeff (f.shiftedTorusValue p y) k =
+      f.fourierCoeff p k * fourierMonomial k (angleScale n (complexShift y 0)) := by
+  have he := f.fourierCoeff_eq_shifted_unitCube hp k y hy
+  simp_rw [unitFourierWeight_shift_split, ← mul_assoc] at he
+  unfold unitCubeIntegral at he
+  rw [integral_mul_const] at he
+  have hg := f.shiftedCoeff_eq_unitCube hp y hy k
+  unfold unitCubeIntegral at hg
+  rw [← hg] at he
+  rw [he, mul_assoc, fourierMonomial_neg_mul, mul_one]
+
+theorem hasSum_fourier_shifted (f : AnalyticPhaseFunction n G ρ) {p : ComplexSpace n}
+    (hp : p ∈ G) (y : RealSpace n) (hy : ∀ j, |y j| ≤ normalizedWidth ρ)
+    {δ : ℝ} (hδ : 0 < δ)
+    (hwidth : ‖imagPart (angleScale n (complexShift y 0))‖ ≤ (ρ : ℝ) - δ)
+    (t : RealSpace n) :
+    HasSum (fun k => f.fourierCoeff p k * fourierMonomial k (angleScale n (complexShift y t)))
+      (f.toFun (p, angleScale n (complexShift y t))) := by
+  have hsum : Summable (UnitAddTorus.mFourierCoeff (f.shiftedTorusValue p y)) := by
+    apply ((summable_exp_indexLength n hδ).mul_left f.uniformNorm).of_norm_bounded
+    intro k
+    rw [f.shiftedCoeff_eq hp y hy]
+    simpa only [neg_mul, mul_comm] using norm_fourierTerm_le
+      (f.norm_le_iff.mp le_rfl).nonneg (f.norm_fourierCoeff_le_exp hp) hwidth k
+  have hs := UnitAddTorus.hasSum_mFourier_series_apply_of_summable
+    (f := f.onShiftedTorus hp y hy) hsum (fun j => (t j : UnitAddCircle))
+  simp only [onShiftedTorus, ContinuousMap.coe_mk, f.shiftedCoeff_eq hp y hy,
+    smul_eq_mul, mFourier_eq_fourierMonomial, f.shiftedTorusValue_coe hp y hy] at hs
+  convert hs using 1
+  funext k
+  rw [angleScale_shift_split, fourierMonomial_add]
+  ring
+
+end AnalyticPhaseFunction
+end KamProject.Arnold1963
diff --git a/LeanPool/ArnoldKAM/Arnold1963/Analysis/TailConstant.lean b/LeanPool/ArnoldKAM/Arnold1963/Analysis/TailConstant.lean
new file mode 100644
index 0000000000..981b762709
--- /dev/null
+++ b/LeanPool/ArnoldKAM/Arnold1963/Analysis/TailConstant.lean
@@ -0,0 +1,57 @@
+/-
+Copyright (c) 2026 Bingqi Yu. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Bingqi Yu
+-/
+
+module
+
+public import LeanPool.ArnoldKAM.Arnold1963.Analysis.FourierTail
+public import Mathlib.Analysis.Complex.ExponentialBounds
+public import Mathlib.Tactic.IntervalCases
+
+/-!
+The Fourier tail estimate with the explicit constant used in the analytic KAM iteration.
+-/
+
+@[expose] public section
+noncomputable section
+open scoped NNReal
+namespace KamProject.Arnold1963
+
+theorem kernel_constant_le_arnold {n : ℕ} (hn : 0 < n) {δ : ℝ}
+    (hδ : 0 < δ) (hsmall : δ ≤ 1 / 12) :
+    (4 / δ) ^ n ≤ ((2 * n : ℝ) / Real.exp 1) ^ n / δ ^ (n + 1) := by
+  have hc : δ * (4 : ℝ) ^ n ≤ ((2 * n : ℝ) / 3) ^ n := by
+    by_cases hlarge : 6 ≤ n
+    · have hn' : (6 : ℝ) ≤ n := by exact_mod_cast hlarge
+      calc
+        _ ≤ (4 : ℝ) ^ n := by nlinarith [pow_nonneg (by norm_num : (0 : ℝ) ≤ 4) n]
+        _ ≤ ((2 * n : ℝ) / 3) ^ n := pow_le_pow_left₀ (by norm_num) (by linarith) n
+    · interval_cases n <;> norm_num at hn ⊢ <;> nlinarith
+  have hb : ((2 * n : ℝ) / 3) ^ n ≤ ((2 * n : ℝ) / Real.exp 1) ^ n := by
+    apply pow_le_pow_left₀ (by positivity)
+    exact div_le_div_of_nonneg_left (by positivity) (Real.exp_pos 1) Real.exp_one_lt_three.le
+  have h := hc.trans hb
+  apply (le_div_iff₀ (by positivity : (0 : ℝ) < δ ^ (n + 1))).mpr
+  have he : (4 / δ) ^ n * δ ^ (n + 1) = δ * 4 ^ n := by
+    rw [div_pow, pow_succ]
+    field_simp
+  rwa [he]
+
+theorem norm_fourierSeries_tail_le_arnoldConstant {n : ℕ} {a : FourierIndex n → ℂ}
+    {M ρ δ γ N : ℝ} {σ : ℝ≥0} (hn : 0 < n) (hM : 0 ≤ M)
+    (hδ : 0 < δ) (hsmall : δ ≤ 1 / 12) (hγ : 0 ≤ γ)
+    (hσ : (σ : ℝ) ≤ ρ - (δ + γ))
+    (ha : ∀ k, ‖a k‖ ≤ M * Real.exp (-(indexLength k * ρ))) :
+    ‖(∑' k, fourierTermOnStrip a σ k) -
+        ∑ k ∈ fourierModes n N, fourierTermOnStrip a σ k‖ ≤
+      (((2 * n : ℝ) / Real.exp 1) ^ n * M / δ ^ (n + 1)) * Real.exp (-N * γ) := by
+  have h := norm_fourierSeries_tail_le_of_decay (N := N) hM hδ (by linarith) hγ hσ ha
+  apply h.trans
+  have hb := mul_le_mul_of_nonneg_left (kernel_constant_le_arnold hn hδ hsmall)
+    (show 0 ≤ M * Real.exp (-N * γ) by positivity)
+  convert hb using 1
+  ring
+
+end KamProject.Arnold1963
diff --git a/LeanPool/ArnoldKAM/Arnold1963/Analysis/Taylor.lean b/LeanPool/ArnoldKAM/Arnold1963/Analysis/Taylor.lean
new file mode 100644
index 0000000000..3e52542c67
--- /dev/null
+++ b/LeanPool/ArnoldKAM/Arnold1963/Analysis/Taylor.lean
@@ -0,0 +1,95 @@
+/-
+Copyright (c) 2026 Bingqi Yu. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Bingqi Yu
+-/
+
+module
+
+public import LeanPool.ArnoldKAM.Arnold1963.Analysis.MeanValue
+public import Mathlib.Analysis.SpecialFunctions.Integrals.Basic
+public import Mathlib.MeasureTheory.Integral.IntervalIntegral.FundThmCalculus
+
+/-!
+Taylor remainder estimates obtained by integration along a contained segment, with explicit
+operator and coordinate Hessian bounds.
+-/
+
+@[expose] public section
+
+noncomputable section
+open MeasureTheory
+namespace KamProject.Arnold1963
+
+theorem norm_taylor_remainder_le {E F : Type*}
+    [NormedAddCommGroup E] [NormedSpace ℝ E] [NormedSpace ℂ E] [IsScalarTower ℝ ℂ E]
+    [NormedAddCommGroup F] [NormedSpace ℝ F] [NormedSpace ℂ F] [IsScalarTower ℝ ℂ F]
+    [CompleteSpace F] {f : E → F} {U : Set E} {a b : E} {C : ℝ}
+    (hab : segment ℝ a b ⊆ U) (hf : AnalyticOnNhd ℂ f U)
+    (hC : NormBoundOn (fderiv ℂ (fderiv ℂ f)) U C) :
+    ‖f b - f a - fderiv ℂ f a (b - a)‖ ≤ C / 2 * ‖b - a‖ ^ 2 := by
+  let l : ℝ → E := AffineMap.lineMap a b
+  let d : E := b - a
+  let g : ℝ → F := fun t => f (l t) - f a - t • (fderiv ℂ f a d)
+  let g' : ℝ → F := fun t => (fderiv ℂ f (l t) - fderiv ℂ f a) d
+  have hl : Set.MapsTo l (Set.Icc 0 1) (segment ℝ a b) :=
+    (convex_segment a b).mapsTo_lineMap (left_mem_segment ℝ a b) (right_mem_segment ℝ a b)
+  have hlU : Set.MapsTo l (Set.Icc 0 1) U := fun t ht => hab (hl ht)
+  have hd : ∀ t ∈ Set.Icc (0 : ℝ) 1, HasDerivAt g (g' t) t := by
+    intro t ht
+    have hpath : HasDerivAt l d t := AffineMap.hasDerivAt_lineMap
+    have hfR := (hf _ (hlU ht)).differentiableAt.hasFDerivAt.restrictScalars ℝ
+    have hcomp := hfR.comp_hasDerivAt t hpath
+    have hlin : HasDerivAt (fun s : ℝ => s • fderiv ℂ f a d) (fderiv ℂ f a d) t := by
+      simpa using (hasDerivAt_id t).smul_const (fderiv ℂ f a d)
+    simpa [g, g', Function.comp_def, sub_apply] using (hcomp.sub_const (f a)).fun_sub hlin
+  have hc : ContinuousOn g' (Set.Icc (0 : ℝ) 1) := by
+    have hdf : ContinuousOn (fun t => fderiv ℂ f (l t)) (Set.Icc (0 : ℝ) 1) :=
+      hf.fderiv.continuousOn.comp (by fun_prop) hlU
+    exact (hdf.sub continuousOn_const).clm_apply continuousOn_const
+  have hFTC : (∫ t in (0 : ℝ)..1, g' t) = f b - f a - fderiv ℂ f a d := by
+    have hc' : ContinuousOn g' (Set.uIcc (0 : ℝ) 1) := by simpa using hc
+    have h := intervalIntegral.integral_eq_sub_of_hasDerivAt (a := 0) (b := 1) (f := g)
+      (fun t ht => hd t (by simpa using ht)) hc'.intervalIntegrable
+    simpa [g, l] using h
+  have hb : ∀ t ∈ Set.Icc (0 : ℝ) 1, ‖g' t‖ ≤ C * t * ‖d‖ ^ 2 := by
+    intro t ht
+    have hseg : segment ℝ a (l t) ⊆ U :=
+      ((convex_segment a b).segment_subset (left_mem_segment ℝ a b) (hl ht)).trans hab
+    have hv := norm_sub_le_of_analytic_segment_bound hseg hf.fderiv hC
+    have hdist : ‖l t - a‖ = t * ‖d‖ := by
+      simp [l, d, AffineMap.lineMap_apply_module', norm_smul, abs_of_nonneg ht.1]
+    calc
+      ‖g' t‖ ≤ ‖fderiv ℂ f (l t) - fderiv ℂ f a‖ * ‖d‖ :=
+        (fderiv ℂ f (l t) - fderiv ℂ f a).le_opNorm d
+      _ ≤ (C * ‖l t - a‖) * ‖d‖ := mul_le_mul_of_nonneg_right hv (norm_nonneg _)
+      _ = C * t * ‖d‖ ^ 2 := by rw [hdist]; ring
+  rw [← hFTC]
+  calc
+    _ ≤ ∫ t in (0 : ℝ)..1, C * t * ‖d‖ ^ 2 :=
+      intervalIntegral.norm_integral_le_of_norm_le zero_le_one
+        (Filter.Eventually.of_forall fun t ht => hb t ⟨ht.1.le, ht.2⟩)
+        (by apply Continuous.intervalIntegrable; fun_prop)
+    _ = C / 2 * ‖b - a‖ ^ 2 := by
+      rw [intervalIntegral.integral_mul_const, intervalIntegral.integral_const_mul,
+        integral_id]
+      norm_num
+      dsimp [d]
+      ring
+
+theorem norm_taylor_remainder_le_of_coordinate_bound {n : ℕ}
+    {f : ComplexSpace n → ℂ} {U : Set (ComplexSpace n)} {a b : ComplexSpace n} {Θ : ℝ}
+    (hab : segment ℝ a b ⊆ U) (hf : AnalyticOnNhd ℂ f U) (hΘ : 0 ≤ Θ)
+    (hbound : ∀ x ∈ U, ∀ i j,
+      ‖fderiv ℂ (fderiv ℂ f) x (Pi.single i 1) (Pi.single j 1)‖ ≤ Θ) :
+    ‖f b - f a - fderiv ℂ f a (b - a)‖ ≤
+      (1 / 2 : ℝ) * n ^ 2 * Θ * ‖b - a‖ ^ 2 := by
+  have hC : NormBoundOn (fderiv ℂ (fderiv ℂ f)) U ((n : ℝ) * ((n : ℝ) * Θ)) := by
+    refine ⟨by positivity, fun x hx => ?_⟩
+    apply norm_linearMap_le_of_coordinate_bound _ (by positivity)
+    intro i
+    exact norm_linearMap_le_of_coordinate_bound _ hΘ (hbound x hx i)
+  convert norm_taylor_remainder_le hab hf hC using 1
+  ring
+
+end KamProject.Arnold1963
diff --git a/LeanPool/ArnoldKAM/Arnold1963/Arithmetic/Estimates.lean b/LeanPool/ArnoldKAM/Arnold1963/Arithmetic/Estimates.lean
new file mode 100644
index 0000000000..b77e374b9b
--- /dev/null
+++ b/LeanPool/ArnoldKAM/Arnold1963/Arithmetic/Estimates.lean
@@ -0,0 +1,84 @@
+/-
+Copyright (c) 2026 Bingqi Yu. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Bingqi Yu
+-/
+
+module
+
+public import Mathlib.Analysis.SpecialFunctions.Pow.Real
+public import Mathlib.Analysis.SpecialFunctions.Exp
+public import Mathlib.Tactic.FieldSimp
+public import Mathlib.Tactic.Linarith
+public import Mathlib.Tactic.Ring
+
+/-!
+Real exponential and logarithmic estimates used in the analytic KAM bounds.
+-/
+
+@[expose] public section
+
+namespace KamProject.Arnold1963
+
+theorem rpow_mul_exp_neg_le {x v : ℝ} (hx : 0 < x) (hv : 0 < v) :
+    x ^ v * Real.exp (-x) ≤ (v / Real.exp 1) ^ v := by
+  have hlog := Real.log_le_sub_one_of_pos (div_pos hx hv)
+  have h : v * Real.log (x / v) ≤ x - v := by
+    calc
+      _ ≤ v * (x / v - 1) := mul_le_mul_of_nonneg_left hlog hv.le
+      _ = x - v := by field_simp
+  rw [Real.log_div hx.ne' hv.ne'] at h
+  rw [Real.rpow_def_of_pos hx, Real.rpow_def_of_pos (div_pos hv (Real.exp_pos 1)),
+    ← Real.exp_add, Real.exp_le_exp, Real.log_div hv.ne' (Real.exp_ne_zero 1),
+    Real.log_exp]
+  nlinarith
+
+theorem rpow_le_scaled_exp {m v δ : ℝ} (hm : 0 < m) (hv : 0 < v) (hδ : 0 < δ) :
+    m ^ v ≤ (v / Real.exp 1) ^ v * δ ^ (-v) * Real.exp (m * δ) := by
+  have h := rpow_mul_exp_neg_le (mul_pos hm hδ) hv
+  rw [Real.rpow_def_of_pos (mul_pos hm hδ), ← Real.exp_add,
+    Real.rpow_def_of_pos (div_pos hv (Real.exp_pos 1)), Real.exp_le_exp,
+    Real.log_mul hm.ne' hδ.ne'] at h
+  rw [Real.rpow_def_of_pos hm, Real.rpow_def_of_pos (div_pos hv (Real.exp_pos 1)),
+    Real.rpow_def_of_pos hδ, ← Real.exp_add, ← Real.exp_add, Real.exp_le_exp]
+  nlinarith
+
+theorem log_le_rpow {x v : ℝ} (hx : 0 < x) (hv : 0 < v) :
+    Real.log x ≤ (v / Real.exp 1) * x ^ (1 / v) := by
+  have h := mul_le_mul_of_nonneg_right
+    (Real.mul_exp_neg_le_exp_neg_one (Real.log x / v))
+    (mul_pos hv (Real.exp_pos (Real.log x / v))).le
+  have hl : (Real.log x / v * Real.exp (-(Real.log x / v))) *
+      (v * Real.exp (Real.log x / v)) = Real.log x := by
+    rw [Real.exp_neg]
+    field_simp
+  rw [hl] at h
+  calc
+    Real.log x ≤ Real.exp (-1) * (v * Real.exp (Real.log x / v)) := h
+    _ = (v / Real.exp 1) * x ^ (1 / v) := by
+      rw [Real.rpow_def_of_pos hx, Real.exp_neg]
+      simp only [div_eq_mul_inv, one_mul]
+      ring
+
+theorem rpow_mul_exp_neg_mul_le {m v δ : ℝ} (hm : 0 < m) (hv : 0 < v) (hδ : 0 < δ) :
+    m ^ v * Real.exp (-(m * δ)) ≤ (v / Real.exp 1) ^ v * δ ^ (-v) := by
+  have h := mul_le_mul_of_nonneg_right (rpow_le_scaled_exp hm hv hδ)
+    (Real.exp_pos (-(m * δ))).le
+  simpa only [mul_assoc, ← Real.exp_add, add_neg_cancel, Real.exp_zero, mul_one] using h
+
+theorem log_inv_le_rpow {δ v : ℝ} (hδ : 0 < δ) (hv : 0 < v) :
+    Real.log (1 / δ) ≤ (v / Real.exp 1) * δ ^ (-(1 / v)) := by
+  simpa only [one_div, Real.inv_rpow hδ.le, Real.rpow_neg hδ.le] using
+    (log_le_rpow (inv_pos.mpr hδ) hv)
+
+theorem half_le_one_sub_exp_neg {δ : ℝ} (hδ : 0 ≤ δ) (hδ1 : δ ≤ 1) :
+    δ / 2 ≤ 1 - Real.exp (-δ) := by
+  have h := mul_le_mul_of_nonneg_right (Real.add_one_le_exp δ) (Real.exp_pos (-δ)).le
+  rw [← Real.exp_add, add_neg_cancel, Real.exp_zero] at h
+  have hprod : 1 ≤ (δ + 1) * (1 - δ / 2) := by
+    nlinarith [mul_nonneg hδ (sub_nonneg.mpr hδ1)]
+  have he : Real.exp (-δ) ≤ 1 - δ / 2 :=
+    le_of_mul_le_mul_left (h.trans hprod) (by linarith : 0 < δ + 1)
+  linarith
+
+end KamProject.Arnold1963
diff --git a/LeanPool/ArnoldKAM/Arnold1963/Arithmetic/Lattice.lean b/LeanPool/ArnoldKAM/Arnold1963/Arithmetic/Lattice.lean
new file mode 100644
index 0000000000..cbff008562
--- /dev/null
+++ b/LeanPool/ArnoldKAM/Arnold1963/Arithmetic/Lattice.lean
@@ -0,0 +1,261 @@
+/-
+Copyright (c) 2026 Bingqi Yu. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Bingqi Yu
+-/
+
+module
+
+public import LeanPool.ArnoldKAM.Arnold1963.Basic.Spaces
+public import Mathlib.Data.Int.Interval
+public import Mathlib.Data.Fintype.Pi
+public import Mathlib.Algebra.BigOperators.Group.Finset.Basic
+public import Mathlib.Algebra.Order.Floor.Ring
+public import Mathlib.Tactic.Linarith
+public import Mathlib.Tactic.NormNum
+public import Mathlib.Tactic.Positivity
+public import Mathlib.Tactic.Ring
+public import Lean.Elab.Tactic.Omega
+
+/-!
+Counting integer lattice shells in the sum-of-absolute-coordinates norm. Natural lengths are
+proved equal to the public real-valued indexLength. All mode cutoffs are strict.
+-/
+
+@[expose] public section
+
+noncomputable section
+
+namespace KamProject.Arnold1963
+
+/-- The integer-valued sum of absolute Fourier coordinates, used to enumerate shells. -/
+def latticeLength {n : ℕ} (k : FourierIndex n) : ℕ := ∑ j, (k j).natAbs
+
+theorem indexLength_eq_latticeLength {n : ℕ} (k : FourierIndex n) :
+    indexLength k = (latticeLength k : ℝ) := by
+  simp [indexLength, latticeLength, Nat.cast_sum]
+
+theorem natAbs_le_latticeLength {n : ℕ} (k : FourierIndex n) (j : Fin n) :
+    (k j).natAbs ≤ latticeLength k := by
+  exact Finset.single_le_sum (f := fun i => (k i).natAbs)
+    (fun _ _ => Nat.zero_le _) (Finset.mem_univ j)
+
+@[simp] theorem latticeLength_zero {n : ℕ} : latticeLength (0 : FourierIndex n) = 0 := by
+  simp [latticeLength]
+
+@[simp] theorem latticeLength_eq_zero {n : ℕ} (k : FourierIndex n) :
+    latticeLength k = 0 ↔ k = 0 := by
+  constructor
+  · intro h
+    funext j
+    have := natAbs_le_latticeLength k j
+    simp_all
+  · rintro rfl
+    simp
+
+theorem latticeLength_cons {n : ℕ} (a : ℤ) (k : FourierIndex n) :
+    latticeLength (Fin.cons a k) = a.natAbs + latticeLength k := by
+  simp [latticeLength, Fin.sum_univ_succ]
+
+/-- The finite integer coordinate box containing every shell of the given radius. -/
+def latticeBox (n m : ℕ) : Finset (FourierIndex n) :=
+  Fintype.piFinset (fun _ => Finset.Icc (-(m : ℤ)) (m : ℤ))
+
+/-- The finite shell of integer indices with the specified sum of absolute coordinates. -/
+def latticeShell (n m : ℕ) : Finset (FourierIndex n) :=
+  (latticeBox n m).filter (fun k => latticeLength k = m)
+
+@[simp] theorem mem_latticeShell {n m : ℕ} {k : FourierIndex n} :
+    k ∈ latticeShell n m ↔ latticeLength k = m := by
+  simp only [latticeShell, Finset.mem_filter, and_iff_right_iff_imp]
+  intro h
+  apply Fintype.mem_piFinset.2
+  intro j
+  have := natAbs_le_latticeLength k j
+  simp only [Finset.mem_Icc]
+  omega
+
+@[simp] theorem latticeShell_zero (n : ℕ) : latticeShell n 0 = {0} := by
+  ext k
+  simp
+
+theorem card_shell_fiber_le (n m : ℕ) (a : ℤ) :
+    ((latticeShell (n + 1) m).filter (fun k => k 0 = a)).card ≤
+      (latticeShell n (m - a.natAbs)).card := by
+  apply Finset.card_le_card_of_injOn Fin.tail
+  · intro k hk
+    obtain ⟨hk, ha⟩ := Finset.mem_filter.mp hk
+    have hlen := mem_latticeShell.mp hk
+    have heq : latticeLength k = (k 0).natAbs + latticeLength (Fin.tail k) := by
+      conv_lhs => rw [← Fin.cons_self_tail k]
+      exact latticeLength_cons _ _
+    apply mem_latticeShell.mpr
+    omega
+  · intro k hk l hl hkl
+    have hk0 := (Finset.mem_filter.mp hk).2
+    have hl0 := (Finset.mem_filter.mp hl).2
+    rw [← Fin.cons_self_tail k, ← Fin.cons_self_tail l, hk0, hl0, hkl]
+
+theorem card_latticeShell_one_le (m : ℕ) : (latticeShell 1 m).card ≤ 2 := by
+  have h : (latticeShell 1 m).card ≤ ({(m : ℤ), -(m : ℤ)} : Finset ℤ).card := by
+    apply Finset.card_le_card_of_injOn (fun k => k 0)
+    · intro k hk
+      have hlen : (k 0).natAbs = m := by simpa [latticeLength] using mem_latticeShell.mp hk
+      simp only [Finset.mem_coe, Finset.mem_insert, Finset.mem_singleton]
+      omega
+    · intro k hk l hl heq
+      funext j
+      have hj : j = 0 := Subsingleton.elim _ _
+      simpa [hj] using heq
+  exact h.trans ((Finset.card_insert_le _ _).trans_eq (by simp))
+
+theorem card_latticeShell_le (n m : ℕ) (hn : 0 < n) (hm : 0 < m) :
+    (latticeShell n m).card ≤ 2 ^ n * m ^ (n - 1) := by
+  induction n generalizing m with
+  | zero => omega
+  | succ n ih =>
+    by_cases hn0 : n = 0
+    · subst n
+      simpa using card_latticeShell_one_le m
+    have hn : 0 < n := Nat.pos_of_ne_zero hn0
+    let C := 2 ^ n * m ^ (n - 1)
+    let fiber := fun a : ℤ => ((latticeShell (n + 1) m).filter (fun k => k 0 = a)).card
+    have hC : 2 ≤ C := by
+      calc
+        2 = (2 : ℕ) ^ 1 * 1 := by norm_num
+        _ ≤ 2 ^ n * m ^ (n - 1) :=
+          Nat.mul_le_mul (pow_le_pow_right' (by omega) hn) (one_le_pow₀ (by omega))
+    have hend (a : ℤ) (ha : a.natAbs = m) : fiber a ≤ 1 := by
+      have := card_shell_fiber_le n m a
+      simpa [fiber, ha] using this
+    have hint (a : ℤ) (ha : a ∈ Finset.Ioo (-(m : ℤ)) (m : ℤ)) : fiber a ≤ C := by
+      have ha' : a.natAbs < m := by simp only [Finset.mem_Ioo] at ha; omega
+      exact (card_shell_fiber_le n m a).trans
+        ((ih (m - a.natAbs) hn (by omega)).trans
+          (Nat.mul_le_mul_left _ (Nat.pow_le_pow_left (Nat.sub_le m _) (n - 1))))
+    have hsum : (latticeShell (n + 1) m).card =
+        ∑ a ∈ Finset.Icc (-(m : ℤ)) (m : ℤ), fiber a := by
+      apply Finset.card_eq_sum_card_fiberwise
+      intro k hk
+      have hlen := mem_latticeShell.mp hk
+      have := natAbs_le_latticeLength k 0
+      simp only [Finset.mem_coe, Finset.mem_Icc]
+      omega
+    have hsplit : Finset.Icc (-(m : ℤ)) (m : ℤ) =
+        insert (-(m : ℤ)) (insert (m : ℤ) (Finset.Ioo (-(m : ℤ)) (m : ℤ))) := by
+      rw [Finset.Ioo_insert_right (by omega), Finset.Ioc_insert_left (by omega)]
+    have hcount : (Finset.Ioo (-(m : ℤ)) (m : ℤ)).card = 2 * m - 1 := by
+      rw [Int.card_Ioo]
+      omega
+    have hbound : (latticeShell (n + 1) m).card ≤ 2 + (2 * m - 1) * C := by
+      rw [hsum, hsplit, Finset.sum_insert (by simp; omega),
+        Finset.sum_insert (by simp)]
+      have hneg := hend (-(m : ℤ)) (by simp)
+      have hpos := hend (m : ℤ) (by simp)
+      have hmid : (∑ a ∈ Finset.Ioo (-(m : ℤ)) (m : ℤ), fiber a) ≤ (2 * m - 1) * C := by
+        calc
+          _ ≤ ∑ _a ∈ Finset.Ioo (-(m : ℤ)) (m : ℤ), C := Finset.sum_le_sum hint
+          _ = _ := by simp [hcount]
+      omega
+    calc
+      _ ≤ 2 + (2 * m - 1) * C := hbound
+      _ ≤ (2 * m) * C := by nlinarith [Nat.sub_add_cancel (show 1 ≤ 2 * m by omega)]
+      _ = 2 ^ (n + 1) * m ^ ((n + 1) - 1) := by
+        dsimp [C]
+        simp only [pow_succ]
+        have hp : m ^ (n - 1) * m = m ^ n := by
+          rw [← pow_succ, Nat.sub_add_cancel hn]
+        calc
+          _ = (2 ^ n * 2) * (m ^ (n - 1) * m) := by ring
+          _ = _ := by rw [hp]
+
+/-- The finite union of nonzero lattice shells through the specified radius. -/
+def nonzeroLatticeBall (n M : ℕ) : Finset (FourierIndex n) :=
+  (Finset.Icc 1 M).biUnion (latticeShell n)
+
+@[simp] theorem mem_nonzeroLatticeBall {n M : ℕ} {k : FourierIndex n} :
+    k ∈ nonzeroLatticeBall n M ↔ 0 < latticeLength k ∧ latticeLength k ≤ M := by
+  simp only [nonzeroLatticeBall, Finset.mem_biUnion, Finset.mem_Icc, mem_latticeShell]
+  constructor
+  · rintro ⟨i, hi, hlen⟩
+    omega
+  · intro h
+    exact ⟨latticeLength k, by omega, rfl⟩
+
+theorem card_nonzeroLatticeBall_le (n M : ℕ) (hn : 0 < n) :
+    (nonzeroLatticeBall n M).card ≤ 2 ^ n * M ^ n := by
+  by_cases hM : M = 0
+  · subst M
+    simp [nonzeroLatticeBall]
+  have hM : 0 < M := Nat.pos_of_ne_zero hM
+  calc
+    _ ≤ ∑ r ∈ Finset.Icc 1 M, (latticeShell n r).card := Finset.card_biUnion_le
+    _ ≤ ∑ _r ∈ Finset.Icc 1 M, 2 ^ n * M ^ (n - 1) := by
+      apply Finset.sum_le_sum
+      intro r hr
+      have hr := Finset.mem_Icc.mp hr
+      exact (card_latticeShell_le n r hn hr.1).trans
+        (Nat.mul_le_mul_left _ (Nat.pow_le_pow_left hr.2 (n - 1)))
+    _ = 2 ^ n * M ^ n := by
+      simp only [Finset.sum_const, Nat.card_Icc, Nat.add_sub_cancel, nsmul_eq_mul, Nat.cast_id]
+      have hp : M ^ (n - 1) * M = M ^ n := by rw [← pow_succ, Nat.sub_add_cancel hn]
+      calc
+        _ = 2 ^ n * (M ^ (n - 1) * M) := by ring
+        _ = _ := by rw [hp]
+
+/-- Nonzero Fourier indices with length strictly below the real cutoff. -/
+def lowModes (n : ℕ) (N : ℝ) : Finset (FourierIndex n) :=
+  nonzeroLatticeBall n (⌈N⌉₊ - 1)
+
+@[simp] theorem mem_lowModes {n : ℕ} {N : ℝ} {k : FourierIndex n} :
+    k ∈ lowModes n N ↔ 0 < indexLength k ∧ indexLength k < N := by
+  rw [lowModes, mem_nonzeroLatticeBall, indexLength_eq_latticeLength]
+  rw [Nat.cast_pos, ← Nat.lt_ceil]
+  omega
+
+/-- Fourier modes below the cutoff, including zero when the cutoff is positive. -/
+def fourierModes (n : ℕ) (N : ℝ) : Finset (FourierIndex n) :=
+  if 0 < N then insert 0 (lowModes n N) else ∅
+
+@[simp] theorem mem_fourierModes {n : ℕ} {N : ℝ} {k : FourierIndex n} :
+    k ∈ fourierModes n N ↔ indexLength k < N := by
+  classical
+  have hnonneg := indexLength_nonneg k
+  have hzero : indexLength k = 0 ↔ k = 0 := by
+    rw [indexLength_eq_latticeLength, Nat.cast_eq_zero, latticeLength_eq_zero]
+  by_cases hN : 0 < N
+  · simp only [fourierModes, ite_eq_left hN, Finset.mem_insert, mem_lowModes]
+    constructor
+    · rintro (rfl | h)
+      · simpa [indexLength] using hN
+      · exact h.2
+    · intro h
+      by_cases hk : k = 0
+      · exact Or.inl hk
+      · exact Or.inr ⟨lt_of_le_of_ne hnonneg (Ne.symm (mt hzero.mp hk)), h⟩
+  · simp only [fourierModes, ite_eq_right hN, Finset.notMem_empty, false_iff, not_lt]
+    exact (le_of_not_gt hN).trans hnonneg
+
+theorem not_mem_fourierModes {n : ℕ} {N : ℝ} {k : FourierIndex n} :
+    k ∉ fourierModes n N ↔ N ≤ indexLength k := by
+  simp
+
+theorem fourierModes_eq_insert_lowModes (n : ℕ) {N : ℝ} (hN : 0 < N) :
+    fourierModes n N = insert 0 (lowModes n N) := by
+  simp [fourierModes, hN]
+
+theorem card_lowModes_le {n : ℕ} {N : ℝ} (hn : 0 < n) (hN : 1 < N) :
+    ((lowModes n N).card : ℝ) ≤ (2 : ℝ) ^ n * N ^ n := by
+  have hceil : 1 ≤ ⌈N⌉₊ := Nat.one_le_ceil_iff.mpr (by linarith)
+  have hbound : ((⌈N⌉₊ - 1 : ℕ) : ℝ) ≤ N := by
+    rw [Nat.cast_sub hceil, Nat.cast_one]
+    have := Nat.ceil_lt_add_one (show 0 ≤ N by linarith)
+    linarith
+  calc
+    _ ≤ ((2 ^ n * (⌈N⌉₊ - 1) ^ n : ℕ) : ℝ) := by
+      exact_mod_cast card_nonzeroLatticeBall_le n (⌈N⌉₊ - 1) hn
+    _ = (2 : ℝ) ^ n * ((⌈N⌉₊ - 1 : ℕ) : ℝ) ^ n := by norm_cast
+    _ ≤ _ := mul_le_mul_of_nonneg_left
+      (pow_le_pow_left₀ (Nat.cast_nonneg _) hbound n) (by positivity)
+
+end KamProject.Arnold1963
diff --git a/LeanPool/ArnoldKAM/Arnold1963/Arithmetic/Parameters.lean b/LeanPool/ArnoldKAM/Arnold1963/Arithmetic/Parameters.lean
new file mode 100644
index 0000000000..fe2b18f780
--- /dev/null
+++ b/LeanPool/ArnoldKAM/Arnold1963/Arithmetic/Parameters.lean
@@ -0,0 +1,162 @@
+/-
+Copyright (c) 2026 Bingqi Yu. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Bingqi Yu
+-/
+
+module
+
+public import LeanPool.ArnoldKAM.Arnold1963.Arithmetic.Estimates
+public import Mathlib.Tactic.Positivity
+
+/-!
+Constants and positive thresholds for the corrected analytic iteration. The iteration exponent
+is 8 * n + 24. Explicit identities verify the exponent balance in the remainder recurrence.
+-/
+
+@[expose] public section
+noncomputable section
+namespace KamProject.Arnold1963
+
+/-- The small-divisor exponent used for arithmetic resonance bounds. -/
+def arithmeticExponent (n : ℕ) : ℕ := n + 1
+/-- The dimension-dependent exponent in the homological equation estimates. -/
+def homologicalExponent (n : ℕ) : ℕ := 2 * n + 1
+/-- The exponent governing the nonlinear remainder bound of one KAM step. -/
+def stepExponent (n : ℕ) : ℕ := 2 * n + 3
+/-- The initial perturbation exponent chosen to sustain the full iteration. -/
+def iterationExponent (n : ℕ) : ℕ := 8 * n + 24
+
+/-- The exponential coefficient used in dimension-dependent KAM estimates. -/
+def constantL0 (n : ℕ) : ℝ := ((n + 1 : ℝ) / Real.exp 1) ^ (n + 1)
+/-- The dimension-dependent coefficient used to bound the homological solution. -/
+def constantL5 (n : ℕ) : ℝ := 4 ^ n * constantL0 n
+/-- The numerical coefficient entering the first smallness threshold. -/
+def constantL2 (n : ℕ) : ℝ := 16 * n * constantL5 n
+/-- The numerical coefficient entering the quadratic remainder estimate. -/
+def constantL3 (n : ℕ) : ℝ := (1 / 2 : ℝ) * n ^ 2 * constantL5 n ^ 2
+/-- The exponential tail coefficient entering the Fourier remainder estimate. -/
+def constantL4 (n : ℕ) : ℝ := 2 * ((2 * n : ℝ) / Real.exp 1) ^ n
+
+/-- The common smallness bound for the fundamental step's numerical estimates. -/
+def threshold0 (n : ℕ) (Θ : ℝ) : ℝ :=
+  min (1 / 12) (min (constantL2 n)⁻¹ (min ((constantL3 n)⁻¹ * Θ⁻¹) (constantL4 n)⁻¹))
+/-- The fundamental smallness bound adjusted for frequency-chart derivative bounds. -/
+def threshold1 (n : ℕ) (θ Θ : ℝ) : ℝ := min (threshold0 n (2 * Θ)) (θ / (2 * n))
+/-- The smallness bound controlling strip widths and the requested measure tolerance. -/
+def threshold2 (n : ℕ) (κ ρ : ℝ) : ℝ :=
+  min (((10 : ℝ) ^ (4 * n))⁻¹ * ρ ^ (4 * n)) (min ((4 : ℝ) ^ (4 * n))⁻¹ κ)
+/-- The smallness bound controlling frequency-domain losses and their measure budget. -/
+def threshold3 (n : ℕ) (θ Θ κ D : ℝ) : ℝ :=
+  min (Real.exp (2 * n) / (32 * n ^ 2 + 100 * n) ^ (2 * n))
+    (min (1 / (6 + 14 * Θ)) (((4 : ℝ) ^ (n + 2))⁻¹ * κ * θ ^ n / (Θ ^ n * D * n)))
+/-- The smallness bound balancing the measure tolerance with the lower derivative bound. -/
+def threshold4 (κ θ : ℝ) : ℝ := κ / (2 + θ⁻¹)
+/-- The common initial smallness bound combining all iteration constraints. -/
+def threshold5 (n : ℕ) (θ Θ ρ κ D : ℝ) : ℝ :=
+  min (threshold1 n (θ / 2) (2 * Θ))
+    (min (threshold2 n κ ρ) (min (threshold3 n θ Θ κ D) (threshold4 κ θ)))
+
+theorem constants_pos {n : ℕ} (hn : 0 < n) :
+    0 < constantL0 n ∧ 0 < constantL5 n ∧ 0 < constantL2 n ∧
+      0 < constantL3 n ∧ 0 < constantL4 n := by
+  have hn' : (0 : ℝ) < n := by exact_mod_cast hn
+  dsimp [constantL0, constantL5, constantL2, constantL3, constantL4]
+  constructor
+  · positivity
+  constructor
+  · positivity
+  constructor
+  · positivity
+  constructor <;> positivity
+
+theorem threshold0_pos {n : ℕ} (hn : 0 < n) {Θ : ℝ} (hΘ : 0 < Θ) :
+    0 < threshold0 n Θ := by
+  obtain ⟨_, _, h2, h3, h4⟩ := constants_pos hn
+  unfold threshold0
+  positivity
+
+theorem threshold1_pos {n : ℕ} (hn : 0 < n) {θ Θ : ℝ}
+    (hθ : 0 < θ) (hΘ : 0 < Θ) : 0 < threshold1 n θ Θ := by
+  have hn' : (0 : ℝ) < n := by exact_mod_cast hn
+  exact lt_min (threshold0_pos hn (by positivity)) (by positivity)
+
+theorem threshold0_bounds {n : ℕ} {Θ δ : ℝ} (h : δ < threshold0 n Θ) :
+    δ < 1 / 12 ∧ δ < (constantL2 n)⁻¹ ∧
+      δ < (constantL3 n)⁻¹ * Θ⁻¹ ∧ δ < (constantL4 n)⁻¹ := by
+  simpa only [threshold0, lt_min_iff] using h
+
+theorem threshold0_budget_conditions {n : ℕ} (hn : 0 < n) {Θ δ : ℝ}
+    (hΘ : 0 < Θ) (hδ : δ < threshold0 n Θ) :
+    δ < 1 / 12 ∧ δ * constantL2 n < 1 ∧
+      δ * (constantL3 n * Θ) < 1 ∧ δ * constantL4 n < 1 := by
+  obtain ⟨hsmall, h2, h3, h4⟩ := threshold0_bounds hδ
+  obtain ⟨_, _, hL2, hL3, hL4⟩ := constants_pos hn
+  refine ⟨hsmall, ?_, ?_, ?_⟩
+  · exact (lt_div_iff₀ hL2).mp (by simpa only [one_div] using h2)
+  · exact (lt_div_iff₀ (mul_pos hL3 hΘ)).mp (by
+      simpa only [one_div, mul_inv] using h3)
+  · exact (lt_div_iff₀ hL4).mp (by simpa only [one_div] using h4)
+
+theorem threshold1_bounds {n : ℕ} {θ Θ δ : ℝ} (h : δ < threshold1 n θ Θ) :
+    δ < threshold0 n (2 * Θ) ∧ δ < θ / (2 * n) := lt_min_iff.mp h
+
+theorem threshold5_bounds {n : ℕ} {θ Θ ρ κ D δ : ℝ}
+    (h : δ < threshold5 n θ Θ ρ κ D) :
+    δ < threshold1 n (θ / 2) (2 * Θ) ∧ δ < threshold2 n κ ρ ∧
+      δ < threshold3 n θ Θ κ D ∧ δ < threshold4 κ θ := by
+  simpa only [threshold5, lt_min_iff] using h
+
+theorem threshold2_pos (n : ℕ) {κ ρ : ℝ} (hκ : 0 < κ) (hρ : 0 < ρ) :
+    0 < threshold2 n κ ρ := by
+  unfold threshold2
+  positivity
+
+theorem threshold3_pos {n : ℕ} (hn : 0 < n) {θ Θ κ D : ℝ}
+    (hθ : 0 < θ) (hΘ : 0 < Θ) (hκ : 0 < κ) (hD : 0 < D) :
+    0 < threshold3 n θ Θ κ D := by
+  have hn' : (0 : ℝ) < n := by exact_mod_cast hn
+  unfold threshold3
+  positivity
+
+theorem threshold4_pos {κ θ : ℝ} (hκ : 0 < κ) (hθ : 0 < θ) :
+    0 < threshold4 κ θ := by unfold threshold4; positivity
+
+theorem threshold5_pos {n : ℕ} (hn : 0 < n) {θ Θ ρ κ D : ℝ}
+    (hθ : 0 < θ) (hΘ : 0 < Θ) (hρ : 0 < ρ) (hκ : 0 < κ) (hD : 0 < D) :
+    0 < threshold5 n θ Θ ρ κ D := by
+  exact lt_min (threshold1_pos hn (by positivity) (by positivity))
+    (lt_min (threshold2_pos n hκ hρ)
+      (lt_min (threshold3_pos hn hθ hΘ hκ hD) (threshold4_pos hκ hθ)))
+
+/-- The perturbation threshold obtained from the initial smallness bound and iteration exponent. -/
+def initialPerturbationThreshold (n : ℕ) (θ Θ ρ κ D : ℝ) : ℝ :=
+  (threshold5 n θ Θ ρ κ D / 2) ^ iterationExponent n
+
+theorem initialPerturbationThreshold_pos {n : ℕ} (hn : 0 < n)
+    {θ Θ ρ κ D : ℝ} (hθ : 0 < θ) (hΘ : 0 < Θ)
+    (hρ : 0 < ρ) (hκ : 0 < κ) (hD : 0 < D) :
+    0 < initialPerturbationThreshold n θ Θ ρ κ D := by
+  have := threshold5_pos hn hθ hΘ hρ hκ hD
+  unfold initialPerturbationThreshold
+  positivity
+
+theorem strengthened_budget_two_mul (M δ β : ℝ) (n : ℕ) :
+    (1 / 4 : ℝ) * (2 * M) ^ 2 / (δ ^ (2 * stepExponent n) * β ^ 2) =
+      M ^ 2 / (δ ^ (2 * stepExponent n) * β ^ 2) := by ring
+
+theorem budget_exponent_identity (n : ℕ) :
+    2 * iterationExponent n = 2 * stepExponent n + 6 + (12 * n + 36) := by
+  unfold iterationExponent stepExponent
+  omega
+
+theorem budget_step_eq {δ : ℝ} (hδ : 0 < δ) (n : ℕ) :
+    (δ ^ iterationExponent n) ^ 2 / (δ ^ (2 * stepExponent n) * (δ ^ 3) ^ 2) =
+      δ ^ (12 * n + 36) := by
+  apply (div_eq_iff (by positivity : δ ^ (2 * stepExponent n) * (δ ^ 3) ^ 2 ≠ 0)).mpr
+  simp only [← pow_mul, ← pow_add]
+  congr 1
+  unfold iterationExponent stepExponent
+  omega
+
+end KamProject.Arnold1963
diff --git a/LeanPool/ArnoldKAM/Arnold1963/Arithmetic/ResonanceDomain.lean b/LeanPool/ArnoldKAM/Arnold1963/Arithmetic/ResonanceDomain.lean
new file mode 100644
index 0000000000..33e35d545d
--- /dev/null
+++ b/LeanPool/ArnoldKAM/Arnold1963/Arithmetic/ResonanceDomain.lean
@@ -0,0 +1,172 @@
+/-
+Copyright (c) 2026 Bingqi Yu. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Bingqi Yu
+-/
+
+module
+
+public import LeanPool.ArnoldKAM.Arnold1963.Geometry.FiniteTubes
+public import LeanPool.ArnoldKAM.Arnold1963.Arithmetic.ResonanceMeasure
+
+/-!
+Finite-tube representations of iterated frequency domains. Each integer direction retains one
+threshold, avoiding repeated tube counts as the cutoff grows and the domain is eroded.
+-/
+
+@[expose] public section
+noncomputable section
+open Set
+open scoped NNReal ENNReal
+namespace KamProject.Arnold1963
+
+/-- An integer Fourier covector regarded as a real coordinate vector. -/
+def integerCovector {n} (k : FourierIndex n) : RealSpace n := fun j => (k j : ℝ)
+
+@[simp] theorem integerCovector_length {n} (k : FourierIndex n) :
+    covectorLength (integerCovector k) = indexLength k := rfl
+
+@[simp] theorem integerCovector_pairing {n} (k : FourierIndex n) (z : ComplexSpace n) :
+    realCovectorPairing (integerCovector k) z = indexPairing k z := by
+  simp [integerCovector, realCovectorPairing, indexPairing]
+
+/-- Accumulated geometric erosion and resonance exclusions for a finite Fourier cutoff. -/
+structure ResonanceDomainState (n : ℕ) (K N : ℝ) where
+  /-- The accumulated erosion radius of the ambient frequency domain. -/
+  radius : ℝ≥0
+  /-- The exclusion width assigned to each Fourier index. -/
+  width : FourierIndex n → ℝ
+  width_pos : ∀ k ∈ lowModes n N, 0 < width k
+  width_lower : ∀ k ∈ lowModes n N, K / indexLength k ^ (n + 1) ≤ width k
+
+namespace ResonanceDomainState
+variable {n : ℕ} {K N : ℝ} (s : ResonanceDomainState n K N)
+
+/-- The frequency domain satisfying the state's erosion and finite resonance constraints. -/
+def domain (Ω : Set (ComplexSpace n)) : Set (ComplexSpace n) :=
+  finiteTubeDomain Ω (lowModes n N) integerCovector (fun _ => 0) s.width s.radius
+
+theorem mem_domain {Ω : Set (ComplexSpace n)} {z : ComplexSpace n} :
+    z ∈ s.domain Ω ↔ z ∈ erosion Ω s.radius ∧
+      ∀ k ∈ lowModes n N, s.width k ≤ ‖indexPairing k z‖ := by
+  simp only [domain, finiteTubeDomain, mem_ofPred_eq, integerCovector_pairing,
+    Complex.ofReal_zero, sub_zero]
+
+theorem subset (Ω : Set (ComplexSpace n)) : s.domain Ω ⊆ Ω :=
+  finiteTubeDomain_subset _ _ _ _ _ _
+
+theorem nonresonant {Ω : Set (ComplexSpace n)} {z} (hz : z ∈ s.domain Ω) :
+    FiniteNonresonant z K N := fun k hk =>
+  (s.width_lower k hk).trans ((s.mem_domain.mp hz).2 k hk)
+
+theorem compact {Ω : Set (ComplexSpace n)} (hc : IsCompact Ω) : IsCompact (s.domain Ω) := by
+  have he : s.domain Ω = erosion Ω s.radius ∩
+      ⋂ k ∈ lowModes n N, {z | s.width k ≤ ‖indexPairing k z‖} := by
+    ext z
+    simp only [s.mem_domain, mem_inter_iff, mem_iInter, mem_ofPred_eq]
+  rw [he]
+  apply (isCompact_erosion hc _).inter_right
+  exact isClosed_iInter fun k => isClosed_iInter fun _ =>
+    isClosed_le continuous_const ((continuous_iff_continuousAt.mpr
+      fun z => (analyticAt_indexPairing k z).continuousAt).norm)
+
+theorem conj {Ω : Set (ComplexSpace n)} (hj : ConjInvariant Ω) : ConjInvariant (s.domain Ω) := by
+  intro z hz
+  obtain ⟨hzΩ, hz⟩ := s.mem_domain.mp hz
+  apply s.mem_domain.mpr
+  refine ⟨star_mem_erosion hj hzΩ, ?_⟩
+  intro k hk
+  simpa only [indexPairing_conj, norm_star] using hz k hk
+
+/-- Increasing geometric erosion and widening each resonance exclusion accordingly. -/
+def erode (d : ℝ≥0) : ResonanceDomainState n K N where
+  radius := s.radius + d
+  width := fun k => s.width k + (d : ℝ) * indexLength k
+  width_pos := fun k hk => (s.width_pos k hk).trans_le (le_add_of_nonneg_right (by
+    positivity [indexLength_nonneg k]))
+  width_lower := fun k hk => (s.width_lower k hk).trans (le_add_of_nonneg_right (by
+    positivity [indexLength_nonneg k]))
+
+theorem erode_domain (Ω : Set (ComplexSpace n)) (d : ℝ≥0) :
+    (s.erode d).domain Ω = erosion (s.domain Ω) d := by
+  symm
+  exact erosion_finiteTubeDomain Ω (lowModes n N) integerCovector (fun _ => 0) s.width
+    s.radius d (fun k hk => (mem_lowModes.mp hk).1) s.width_pos
+
+/-- Extending the Fourier cutoff while preserving old exclusions and initializing new ones. -/
+def cut {N' : ℝ} (hK : 0 < K) (_hNN : N ≤ N') : ResonanceDomainState n K N' where
+  radius := s.radius
+  width := fun k => if k ∈ lowModes n N then s.width k else K / indexLength k ^ (n + 1)
+  width_pos := by
+    intro k hk
+    split_ifs with hkold
+    · exact s.width_pos k hkold
+    · exact div_pos hK (pow_pos (mem_lowModes.mp hk).1 _)
+  width_lower := by
+    intro k hk
+    split_ifs with hkold
+    · exact s.width_lower k hkold
+    · exact le_rfl
+
+theorem cut_domain {N' : ℝ} (hK : 0 < K) (hNN : N ≤ N') (Ω : Set (ComplexSpace n)) :
+    (s.cut hK hNN).domain Ω = nonresonantDomain (s.domain Ω) id K N' := by
+  classical
+  have hsub : lowModes n N ⊆ lowModes n N' := fun k hk => mem_lowModes.mpr
+    ⟨(mem_lowModes.mp hk).1, (mem_lowModes.mp hk).2.trans_le hNN⟩
+  ext z
+  rw [(s.cut hK hNN).mem_domain]
+  constructor
+  · rintro ⟨hzΩ, hz⟩
+    refine ⟨s.mem_domain.mpr ⟨hzΩ, ?_⟩, ?_⟩
+    · intro k hk
+      simpa only [cut, ite_eq_left hk] using hz k (hsub hk)
+    · intro k hk
+      by_cases hkold : k ∈ lowModes n N
+      · exact (s.width_lower k hkold).trans (by
+          simpa only [cut, ite_eq_left hkold, id_eq] using hz k hk)
+      · simpa only [cut, ite_eq_right hkold, id_eq] using hz k hk
+  · rintro ⟨hz, hnr⟩
+    obtain ⟨hzΩ, hz⟩ := s.mem_domain.mp hz
+    refine ⟨hzΩ, ?_⟩
+    intro k hk
+    dsimp only [cut]
+    split_ifs with hkold
+    · exact hz k hkold
+    · exact hnr k hk
+
+/-- The next resonance state after extending the cutoff and applying geometric erosion. -/
+def next {N' : ℝ} (hK : 0 < K) (hNN : N ≤ N') (d : ℝ≥0) : ResonanceDomainState n K N' :=
+  (s.cut hK hNN).erode d
+
+theorem next_domain {N' : ℝ} (hK : 0 < K) (hNN : N ≤ N') (d : ℝ≥0)
+    (Ω : Set (ComplexSpace n)) :
+    (s.next hK hNN d).domain Ω = erosion (nonresonantDomain (s.domain Ω) id K N') d := by
+  rw [next, erode_domain, cut_domain]
+
+/-- The initial resonance state at cutoff one, with no nonzero modes to exclude. -/
+def initial (n : ℕ) (K : ℝ) : ResonanceDomainState n K 1 where
+  radius := 0
+  width := fun _ => 1
+  width_pos := by intros; norm_num
+  width_lower := by
+    intro k hk
+    have hh := mem_lowModes.mp hk
+    rw [indexLength_eq_latticeLength] at hh
+    have hpos : 0 < latticeLength k := by exact_mod_cast hh.1
+    have hlt : latticeLength k < 1 := by exact_mod_cast hh.2
+    omega
+
+theorem initial_domain (n : ℕ) (K : ℝ) (Ω : Set (ComplexSpace n)) :
+    (initial n K).domain Ω = Ω := by
+  ext z
+  rw [mem_domain]
+  simp only [initial, erosion_zero, and_iff_left_iff_imp]
+  intro _ k hk
+  have hh := mem_lowModes.mp hk
+  rw [indexLength_eq_latticeLength] at hh
+  have hpos : 0 < latticeLength k := by exact_mod_cast hh.1
+  have hlt : latticeLength k < 1 := by exact_mod_cast hh.2
+  omega
+
+end ResonanceDomainState
+end KamProject.Arnold1963
diff --git a/LeanPool/ArnoldKAM/Arnold1963/Arithmetic/ResonanceLoss.lean b/LeanPool/ArnoldKAM/Arnold1963/Arithmetic/ResonanceLoss.lean
new file mode 100644
index 0000000000..ad39aab8de
--- /dev/null
+++ b/LeanPool/ArnoldKAM/Arnold1963/Arithmetic/ResonanceLoss.lean
@@ -0,0 +1,107 @@
+/-
+Copyright (c) 2026 Bingqi Yu. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Bingqi Yu
+-/
+
+module
+
+public import LeanPool.ArnoldKAM.Arnold1963.Arithmetic.ResonanceDomain
+
+/-!
+The single-step resonance loss combines new shells with erosion layers of existing tubes.
+-/
+
+@[expose] public section
+noncomputable section
+open Set MeasureTheory
+open scoped NNReal ENNReal
+namespace KamProject.Arnold1963
+
+/-- The dimension-dependent coefficient bounding the measure of resonant shells. -/
+def resonanceLossConstant (n : ℕ) : ℝ := n * 2 ^ (n + 2)
+
+theorem resonanceLossConstant_nonneg (n : ℕ) : 0 ≤ resonanceLossConstant n := by
+  unfold resonanceLossConstant; positivity
+
+theorem tube_count_budget {n : ℕ} {N : ℝ} (hn : 0 < n) (hN : 1 < N) :
+    1 + 2 * n * (lowModes n N).card ≤ resonanceLossConstant n * N ^ n := by
+  have hc := card_lowModes_le hn hN
+  have hnR : (1 : ℝ) ≤ n := by exact_mod_cast hn
+  have h2 : (1 : ℝ) ≤ 2 ^ n := one_le_pow₀ (by norm_num)
+  have hNp : 1 ≤ N ^ n := one_le_pow₀ hN.le
+  have hB : (1 : ℝ) ≤ n * 2 ^ n * N ^ n := by
+    simpa using mul_le_mul (mul_le_mul hnR h2 (by norm_num) (by positivity)) hNp
+      (by norm_num) (by positivity : (0 : ℝ) ≤ n * 2 ^ n)
+  have hh := mul_le_mul_of_nonneg_left hc (show (0 : ℝ) ≤ 2 * n by positivity)
+  have he : resonanceLossConstant n * N ^ n = 4 * (n * 2 ^ n * N ^ n) := by
+    unfold resonanceLossConstant
+    rw [pow_add]
+    norm_num
+    ring
+  rw [he]
+  nlinarith
+
+theorem ResonanceDomainState.erosion_loss {n : ℕ} {K N D : ℝ} {Ω : Set (ComplexSpace n)}
+    (s : ResonanceDomainState n K N) (h : TypeD Ω D) (hn : 0 < n) (hN : 1 < N) (d : ℝ≥0) :
+    realVolume (s.domain Ω \ erosion (s.domain Ω) d) ≤
+      ENNReal.ofReal (resonanceLossConstant n * D * (d : ℝ) * N ^ n) * realVolume Ω := by
+  have hh := h.finiteTube_erosion_layer (lowModes n N) integerCovector (fun _ => 0)
+    s.width s.radius 0 d (by positivity) (fun k hk => (mem_lowModes.mp hk).1) s.width_pos
+  simp only [erosion_zero, NNReal.coe_zero, sub_zero] at hh
+  apply hh.trans
+  apply mul_le_mul' (ENNReal.ofReal_le_ofReal _) le_rfl
+  have hc := mul_le_mul_of_nonneg_left (tube_count_budget hn hN)
+    (show 0 ≤ D * (d : ℝ) by positivity [h.constant_pos])
+  nlinarith [hc]
+
+theorem newShellBudget_nonneg (N₀ N₁ : ℝ) : 0 ≤ newShellBudget N₀ N₁ := by
+  exact Finset.sum_nonneg fun _ _ => by positivity
+
+theorem TypeD.ar_loss_le {n : ℕ} {K N₀ N₁ D : ℝ} {Ω : Set (ComplexSpace n)}
+    (h : TypeD Ω D) (s : ResonanceDomainState n K N₀)
+    (hn : 0 < n) (hK : 0 < K) (hN₀ : 1 ≤ N₀) (hN₁ : 1 < N₁) (hNN : N₀ ≤ N₁)
+    (d : ℝ≥0) :
+    realVolume (s.domain Ω \ erosion (nonresonantDomain (s.domain Ω) id K N₁) d) ≤
+      ENNReal.ofReal (resonanceLossConstant n * D *
+        (K * newShellBudget N₀ N₁ + (d : ℝ) * N₁ ^ n)) * realVolume Ω := by
+  let E := s.domain Ω
+  let F := nonresonantDomain E id K N₁
+  have hsub : E \ erosion F d ⊆ (E \ F) ∪ (F \ erosion F d) := by
+    intro x hx
+    by_cases hf : x ∈ F
+    · exact Or.inr ⟨hf, hx.2⟩
+    · exact Or.inl ⟨hx.1, hf⟩
+  have hnew := h.new_resonance_loss_le (N₁ := N₁) hn hK.le hN₀
+    (s.subset Ω) (fun _ hx => s.nonresonant hx)
+  have herode := (s.cut hK hNN).erosion_loss h hn hN₁ d
+  rw [s.cut_domain hK hNN Ω] at herode
+  have hc : (2 : ℝ) ^ (n + 1) * n ≤ resonanceLossConstant n := by
+    simp only [resonanceLossConstant, pow_add, pow_one]
+    norm_num
+    nlinarith [show (0 : ℝ) ≤ 2 ^ n * n by positivity]
+  have hnew' : realVolume (E \ F) ≤
+      ENNReal.ofReal (resonanceLossConstant n * D * (K * newShellBudget N₀ N₁)) * realVolume Ω := by
+    apply hnew.trans
+    apply mul_le_mul' (ENNReal.ofReal_le_ofReal _) le_rfl
+    have hh := mul_le_mul_of_nonneg_right hc
+      (show 0 ≤ D * K * newShellBudget N₀ N₁ by
+        positivity [h.constant_pos, newShellBudget_nonneg N₀ N₁])
+    nlinarith [hh]
+  calc
+    _ ≤ realVolume ((E \ F) ∪ (F \ erosion F d)) := realVolume_mono hsub
+    _ ≤ realVolume (E \ F) + realVolume (F \ erosion F d) := measure_union_le _ _
+    _ ≤ ENNReal.ofReal (resonanceLossConstant n * D * (K * newShellBudget N₀ N₁)) * realVolume Ω +
+        ENNReal.ofReal (resonanceLossConstant n * D * (d : ℝ) * N₁ ^ n) * realVolume Ω :=
+      add_le_add hnew' herode
+    _ = _ := by
+      rw [← add_mul, ← ENNReal.ofReal_add
+        (by positivity [resonanceLossConstant_nonneg n, h.constant_pos,
+          newShellBudget_nonneg N₀ N₁])
+        (by positivity [resonanceLossConstant_nonneg n, h.constant_pos, hN₁])]
+      have he : resonanceLossConstant n * D * (K * newShellBudget N₀ N₁) +
+          resonanceLossConstant n * D * (d : ℝ) * N₁ ^ n =
+          resonanceLossConstant n * D * (K * newShellBudget N₀ N₁ + (d : ℝ) * N₁ ^ n) := by ring
+      rw [he]
+
+end KamProject.Arnold1963
diff --git a/LeanPool/ArnoldKAM/Arnold1963/Arithmetic/ResonanceMeasure.lean b/LeanPool/ArnoldKAM/Arnold1963/Arithmetic/ResonanceMeasure.lean
new file mode 100644
index 0000000000..d99c725863
--- /dev/null
+++ b/LeanPool/ArnoldKAM/Arnold1963/Arithmetic/ResonanceMeasure.lean
@@ -0,0 +1,169 @@
+/-
+Copyright (c) 2026 Bingqi Yu. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Bingqi Yu
+-/
+
+module
+
+public import LeanPool.ArnoldKAM.Arnold1963.Geometry.TypeD
+public import LeanPool.ArnoldKAM.Arnold1963.Step.Nonresonance
+
+/-!
+Measure estimates for newly excluded lattice shells, using the strict mode cutoff. Previously
+excluded shells are charged once.
+-/
+
+@[expose] public section
+noncomputable section
+open Set MeasureTheory
+open scoped NNReal ENNReal
+namespace KamProject.Arnold1963
+
+/-- The frequencies where a given Fourier pairing violates the prescribed small-divisor bound. -/
+def resonanceSet {n : ℕ} (Ω : Set (ComplexSpace n)) (K : ℝ)
+    (k : FourierIndex n) : Set (ComplexSpace n) :=
+  Ω ∩ {ω | ‖indexPairing k ω‖ < K / indexLength k ^ (n + 1)}
+
+/-- The union of resonances associated with one lattice shell. -/
+def resonantShell {n : ℕ} (Ω : Set (ComplexSpace n)) (K : ℝ) (m : ℕ) :=
+  ⋃ k ∈ latticeShell n m, resonanceSet Ω K k
+
+/-- The integer shell radii introduced when the real Fourier cutoff increases. -/
+def newShells (N₀ N₁ : ℝ) : Finset ℕ := Finset.Ico ⌈N₀⌉₊ ⌈N₁⌉₊
+
+/-- The reciprocal-square sum budgeting the newly introduced resonance shells. -/
+def newShellBudget (N₀ N₁ : ℝ) : ℝ := ∑ m ∈ newShells N₀ N₁, 1 / (m : ℝ) ^ 2
+
+theorem FiniteNonresonant.mono_cutoff {n : ℕ} {ω : ComplexSpace n} {K N₀ N₁ : ℝ}
+    (h : FiniteNonresonant ω K N₁) (hN : N₀ ≤ N₁) : FiniteNonresonant ω K N₀ := by
+  intro k hk
+  exact h k (mem_lowModes.mpr ⟨(mem_lowModes.mp hk).1, (mem_lowModes.mp hk).2.trans_le hN⟩)
+
+theorem isClosed_finiteNonresonant {n : ℕ} (K N : ℝ) :
+    IsClosed {ω : ComplexSpace n | FiniteNonresonant ω K N} := by
+  simp only [FiniteNonresonant, ofPred_forall]
+  apply isClosed_iInter
+  intro k
+  apply isClosed_iInter
+  intro _
+  exact isClosed_le continuous_const ((continuous_iff_continuousAt.mpr
+    fun ω => (analyticAt_indexPairing k ω).continuousAt).norm)
+
+theorem isCompact_nonresonant_frequency_domain {n : ℕ} {Ω : Set (ComplexSpace n)}
+    (hΩ : IsCompact Ω) (K N : ℝ) : IsCompact (nonresonantDomain Ω id K N) :=
+  hΩ.inter_right (isClosed_finiteNonresonant K N)
+
+theorem nonresonant_on_erosion {n : ℕ} {Ω : Set (ComplexSpace n)} {K N : ℝ}
+    (d : ℝ≥0) {ω : ComplexSpace n} (hω : ω ∈ erosion (nonresonantDomain Ω id K N) d) :
+    FiniteNonresonant ω K N := (erosion_subset _ _ hω).2
+
+theorem mem_newShells {N₀ N₁ : ℝ} {m : ℕ} :
+    m ∈ newShells N₀ N₁ ↔ N₀ ≤ (m : ℝ) ∧ (m : ℝ) < N₁ := by
+  simp only [newShells, Finset.mem_Ico, Nat.ceil_le, Nat.lt_ceil]
+
+theorem nonresonant_removed_subset_new_shells {n : ℕ}
+    {Ω E : Set (ComplexSpace n)} {K N₀ N₁ : ℝ}
+    (hE : E ⊆ Ω) (hold : ∀ ω ∈ E, FiniteNonresonant ω K N₀) :
+    E \ nonresonantDomain E id K N₁ ⊆
+      ⋃ m ∈ newShells N₀ N₁, resonantShell Ω K m := by
+  classical
+  intro ω hω
+  have hbad : ¬ FiniteNonresonant ω K N₁ := fun h => hω.2 ⟨hω.1, h⟩
+  simp only [FiniteNonresonant, not_forall, not_le] at hbad
+  obtain ⟨k, hk, hres⟩ := hbad
+  have hlow : N₀ ≤ indexLength k := by
+    by_contra! h
+    exact (not_lt_of_ge (hold ω hω.1 k
+      (mem_lowModes.mpr ⟨(mem_lowModes.mp hk).1, h⟩))) hres
+  refine mem_iUnion.2 ⟨latticeLength k, mem_iUnion.2 ⟨?_, ?_⟩⟩
+  · exact mem_newShells.mpr (by
+      simpa only [← indexLength_eq_latticeLength] using ⟨hlow, (mem_lowModes.mp hk).2⟩)
+  · exact mem_iUnion.2 ⟨k, mem_iUnion.2 ⟨mem_latticeShell.mpr rfl, hE hω.1, hres⟩⟩
+
+theorem TypeD.resonance_le {n : ℕ} {Ω : Set (ComplexSpace n)} {D K : ℝ}
+    (d : TypeD Ω D) (hK : 0 ≤ K) {k : FourierIndex n} (hk : 0 < latticeLength k) :
+    realVolume (resonanceSet Ω K k) ≤
+      ENNReal.ofReal (2 * D * n * K / indexLength k ^ (n + 1)) * realVolume Ω := by
+  let ℓ : RealSpace n := fun j => (k j : ℝ)
+  have hlen : 1 ≤ indexLength k := by
+    rw [indexLength_eq_latticeLength]
+    exact_mod_cast hk
+  have hpair : realCovectorPairing ℓ = indexPairing k := by
+    funext z
+    simp [realCovectorPairing, indexPairing, ℓ]
+  have hl : covectorLength ℓ = indexLength k := rfl
+  have ha : 0 ≤ K / indexLength k ^ (n + 1) := by positivity
+  have hs := d.slab ℓ 0 (K / indexLength k ^ (n + 1)) (by rw [hl]; linarith) ha
+  simp only [complexSlab, hpair, Complex.ofReal_zero, sub_zero] at hs
+  apply hs.trans
+  apply mul_le_mul' _ le_rfl
+  apply ENNReal.ofReal_le_ofReal
+  rw [hl]
+  have hh : 2 * (K / indexLength k ^ (n + 1)) / indexLength k ≤
+      2 * (K / indexLength k ^ (n + 1)) := div_le_self (by positivity) hlen
+  calc
+    _ ≤ D * n * (2 * (K / indexLength k ^ (n + 1))) :=
+      mul_le_mul_of_nonneg_left hh (by positivity [d.constant_pos])
+    _ = _ := by ring
+
+theorem TypeD.resonantShell_le {n m : ℕ} {Ω : Set (ComplexSpace n)} {D K : ℝ}
+    (d : TypeD Ω D) (hn : 0 < n) (hm : 0 < m) (hK : 0 ≤ K) :
+    realVolume (resonantShell Ω K m) ≤
+      ENNReal.ofReal ((2 : ℝ) ^ (n + 1) * n * D * K / (m : ℝ) ^ 2) * realVolume Ω := by
+  have hmR : (0 : ℝ) < m := by exact_mod_cast hm
+  let C := 2 * D * n * K / (m : ℝ) ^ (n + 1)
+  have hC : 0 ≤ C := by dsimp [C]; positivity [d.constant_pos]
+  have hcount : ((latticeShell n m).card : ℝ) ≤ 2 ^ n * (m : ℝ) ^ (n - 1) := by
+    exact_mod_cast card_latticeShell_le n m hn hm
+  have hpow : (m : ℝ) ^ (n + 1) = (m : ℝ) ^ (n - 1) * (m : ℝ) ^ 2 := by
+    rw [← pow_add]
+    congr 1
+    omega
+  calc
+    _ ≤ ∑ k ∈ latticeShell n m, realVolume (resonanceSet Ω K k) :=
+      realVolume_biUnion_finset_le _ _
+    _ ≤ ∑ _k ∈ latticeShell n m, ENNReal.ofReal C * realVolume Ω := by
+      apply Finset.sum_le_sum
+      intro k hk
+      have he : indexLength k = (m : ℝ) := by
+        rw [indexLength_eq_latticeLength, mem_latticeShell.mp hk]
+      simpa only [he] using d.resonance_le (k := k) hK
+        (by rw [mem_latticeShell.mp hk]; exact hm)
+    _ = ENNReal.ofReal (((latticeShell n m).card : ℝ) * C) * realVolume Ω := by
+      rw [← Finset.sum_mul, ← ENNReal.ofReal_sum_of_nonneg (fun _ _ => hC)]
+      simp
+    _ ≤ ENNReal.ofReal ((2 : ℝ) ^ n * (m : ℝ) ^ (n - 1) * C) * realVolume Ω :=
+      mul_le_mul' (ENNReal.ofReal_le_ofReal (mul_le_mul_of_nonneg_right hcount hC)) le_rfl
+    _ = _ := by
+      have he : (2 : ℝ) ^ n * (m : ℝ) ^ (n - 1) * C =
+          (2 : ℝ) ^ (n + 1) * n * D * K / (m : ℝ) ^ 2 := by
+        dsimp [C]
+        rw [hpow, pow_succ]
+        field_simp [ne_of_gt hmR]
+        ring
+      rw [he]
+
+theorem TypeD.new_resonance_loss_le {n : ℕ} {Ω E : Set (ComplexSpace n)}
+    {D K N₀ N₁ : ℝ} (d : TypeD Ω D) (hn : 0 < n) (hK : 0 ≤ K)
+    (hN₀ : 1 ≤ N₀) (hE : E ⊆ Ω) (hold : ∀ ω ∈ E, FiniteNonresonant ω K N₀) :
+    realVolume (E \ nonresonantDomain E id K N₁) ≤
+      ENNReal.ofReal ((2 : ℝ) ^ (n + 1) * n * D * K * newShellBudget N₀ N₁) *
+        realVolume Ω := by
+  calc
+    _ ≤ realVolume (⋃ m ∈ newShells N₀ N₁, resonantShell Ω K m) :=
+      realVolume_mono (nonresonant_removed_subset_new_shells hE hold)
+    _ ≤ ∑ m ∈ newShells N₀ N₁, realVolume (resonantShell Ω K m) :=
+      realVolume_biUnion_finset_le _ _
+    _ ≤ ∑ m ∈ newShells N₀ N₁,
+        ENNReal.ofReal ((2 : ℝ) ^ (n + 1) * n * D * K / (m : ℝ) ^ 2) * realVolume Ω := by
+      apply Finset.sum_le_sum
+      intro m hm
+      have hmR := (mem_newShells.mp hm).1
+      exact d.resonantShell_le hn (by exact_mod_cast (show (0 : ℝ) < m by linarith)) hK
+    _ = _ := by
+      rw [← Finset.sum_mul, ← ENNReal.ofReal_sum_of_nonneg (fun _ _ => by
+        positivity [d.constant_pos])]
+      simp only [newShellBudget, Finset.mul_sum, div_eq_mul_inv, one_mul]
+
+end KamProject.Arnold1963
diff --git a/LeanPool/ArnoldKAM/Arnold1963/Audit/FundamentalExample.lean b/LeanPool/ArnoldKAM/Arnold1963/Audit/FundamentalExample.lean
new file mode 100644
index 0000000000..5e14553f4c
--- /dev/null
+++ b/LeanPool/ArnoldKAM/Arnold1963/Audit/FundamentalExample.lean
@@ -0,0 +1,218 @@
+/-
+Copyright (c) 2026 Bingqi Yu. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Bingqi Yu
+-/
+
+module
+
+public import LeanPool.ArnoldKAM.Arnold1963.Step.Fundamental
+public import LeanPool.ArnoldKAM.Arnold1963.Audit.Steps123
+
+/-!
+A nondegenerate quadratic integrable Hamiltonian and a nonzero angle perturbation
+exercise the analytic single-step construction.
+-/
+
+@[expose] public section
+noncomputable section
+open Set Metric
+open scoped NNReal
+namespace KamProject.Arnold1963.Audit
+
+/-- A quadratic one-action Hamiltonian used to exercise the local construction. -/
+def quadraticAction (p : ComplexSpace 1) : ℂ := p 0 * p 0 / 2
+
+theorem quadraticAction_analytic (p : ComplexSpace 1) : AnalyticAt ℂ quadraticAction p :=
+  (((ContinuousLinearMap.proj (R := ℂ) (φ := fun _ : Fin 1 => ℂ) 0).analyticAt p).mul
+    ((ContinuousLinearMap.proj (R := ℂ) (φ := fun _ : Fin 1 => ℂ) 0).analyticAt p)).div
+    analyticAt_const (by norm_num)
+
+theorem quadraticAction_fderiv (p : ComplexSpace 1) :
+    fderiv ℂ quadraticAction p = p 0 • (ContinuousLinearMap.proj 0) := by
+  let L : ComplexSpace 1 →L[ℂ] ℂ := ContinuousLinearMap.proj 0
+  have hd := ((L.hasFDerivAt (x := p)).mul L.hasFDerivAt).mul_const (2 : ℂ)⁻¹
+  change HasFDerivAt (𝕜 := ℂ) quadraticAction _ p at hd
+  rw [hd.fderiv]
+  ext v
+  simp [L]
+  ring
+
+theorem quadraticAction_frequency (p : ComplexSpace 1) : actionFrequency quadraticAction p = p := by
+  ext j
+  simp [actionFrequency, quadraticAction_fderiv, Fin.eq_zero j]
+
+theorem quadraticAction_nondegenerate (p : ComplexSpace 1) :
+    fderiv ℂ (actionFrequency quadraticAction) p = ContinuousLinearMap.id ℂ _ := by
+  have he : actionFrequency quadraticAction = id := funext quadraticAction_frequency
+  rw [he, fderiv_id]
+
+theorem quadraticAction_second (p v w : ComplexSpace 1) :
+    fderiv ℂ (fderiv ℂ quadraticAction) p v w = v 0 * w 0 := by
+  have he : fderiv ℂ quadraticAction = fun p => p 0 •
+      (ContinuousLinearMap.proj (R := ℂ) (φ := fun _ : Fin 1 => ℂ) 0) :=
+    funext quadraticAction_fderiv
+  rw [he]
+  let L : ComplexSpace 1 →L[ℂ] ℂ := ContinuousLinearMap.proj 0
+  have hd := (L.hasFDerivAt (x := p)).smul_const L
+  change ((fderiv ℂ (fun y => L y • L) p) v) w = v 0 * w 0
+  rw [hd.fderiv]
+  simp [L]
+
+theorem quadraticData : IntegrableData quadraticAction univ 1 where
+  analytic := fun p _ => quadraticAction_analytic p
+  conj_compatible := by intro p hp; simp [quadraticAction, conjVec]
+  frequency_conj := by intro p hp; rw [quadraticAction_frequency, quadraticAction_frequency]
+  hessian_bound := by
+    intro p hp j k
+    simp [quadraticAction_second, Fin.eq_zero j, Fin.eq_zero k]
+
+/-- A compact action ball centered at one for the quadratic example. -/
+def exampleActionDomain : Set (ComplexSpace 1) := closedBall (fun _ => 1) (1 / 4)
+
+theorem exampleActionDomain_conj : ConjInvariant exampleActionDomain := by
+  intro p hp
+  change dist (star p) (fun _ => (1 : ℂ)) ≤ (1 / 4 : ℝ)
+  have hd := dist_star_star p (fun _ : Fin 1 => (1 : ℂ))
+  simpa only [Pi.star_def, star_one] using hd.le.trans hp
+
+theorem example_frequency_lower {p : ComplexSpace 1} (hp : p ∈ exampleActionDomain) :
+    (3 / 4 : ℝ) ≤ ‖p 0‖ := by
+  have hh : ‖p 0 - 1‖ ≤ (1 / 4 : ℝ) :=
+    (norm_le_pi_norm (p - (fun _ => 1)) 0).trans (by
+      simpa only [exampleActionDomain, Metric.mem_closedBall, dist_eq_norm] using hp)
+  have ht := norm_sub_norm_le (1 : ℂ) (p 0)
+  rw [norm_sub_rev] at ht
+  norm_num at ht
+  linarith
+
+theorem example_nonresonance {p : ComplexSpace 1} (hp : p ∈ exampleActionDomain) (N : ℝ) :
+    FiniteNonresonant (actionFrequency quadraticAction p) (1 / 2) N := by
+  rw [quadraticAction_frequency]
+  intro k hk
+  have hlen : 1 ≤ indexLength k := by
+    have hh := (mem_lowModes.mp hk).1
+    rw [indexLength_eq_latticeLength] at hh ⊢
+    exact_mod_cast (show 1 ≤ latticeLength k by exact_mod_cast hh)
+  have he : ‖indexPairing k p‖ = indexLength k * ‖p 0‖ := by
+    simp [indexPairing, indexLength, Complex.norm_intCast]
+  rw [he]
+  have hl2 : 1 ≤ indexLength k ^ (1 + 1) := by
+    simpa using pow_le_pow_left₀ (by norm_num : (0 : ℝ) ≤ 1) hlen 2
+  have hquot : (1 / 2 : ℝ) / indexLength k ^ (1 + 1) ≤ 1 / 2 :=
+    div_le_self (by norm_num) hl2
+  have hprod := mul_le_mul hlen (example_frequency_lower hp) (by norm_num : (0 : ℝ) ≤ 3 / 4)
+    (by linarith : (0 : ℝ) ≤ indexLength k)
+  exact hquot.trans (by nlinarith)
+
+/-- A real scalar multiple of the analytic cosine perturbation. -/
+def scaledCosine (ρ : ℝ≥0) (ε : ℝ) : AnalyticPhaseFunction 1 univ ρ where
+  toFun z := (ε : ℂ) * (cosineExample ρ).toFun z
+  domain_conj := (cosineExample ρ).domain_conj
+  analytic := analyticOnNhd_const.mul (cosineExample ρ).analytic
+  periodic := by
+    intro p hp q hq k
+    dsimp only
+    rw [(cosineExample ρ).periodic p hp q hq k]
+  conj_compatible := by
+    intro z hz
+    dsimp only
+    rw [(cosineExample ρ).conj_compatible z hz]
+    simp
+  bounded := ⟨|ε| * (cosineExample ρ).uniformNorm,
+    mul_nonneg (abs_nonneg _) ((cosineExample ρ).norm_le_iff.mp le_rfl).nonneg,
+    fun z hz => by
+      rw [norm_mul, Complex.norm_real, Real.norm_eq_abs]
+      exact mul_le_mul_of_nonneg_left
+        (((cosineExample ρ).norm_le_iff.mp le_rfl).norm_le hz) (abs_nonneg _)⟩
+
+theorem scaledCosine_bound (ρ : ℝ≥0) {ε : ℝ} (hε : 0 ≤ ε) :
+    (scaledCosine ρ ε).uniformNorm ≤ ε * (cosineExample ρ).uniformNorm := by
+  apply ((scaledCosine ρ ε).norm_le_iff).mpr
+  refine ⟨mul_nonneg hε ((cosineExample ρ).norm_le_iff.mp le_rfl).nonneg, fun z hz => ?_⟩
+  change ‖(ε : ℂ) * (cosineExample ρ).toFun z‖ ≤ _
+  rw [norm_mul, Complex.norm_real, Real.norm_eq_abs, abs_of_nonneg hε]
+  exact mul_le_mul_of_nonneg_left (((cosineExample ρ).norm_le_iff.mp le_rfl).norm_le hz) hε
+
+/-- An amplitude chosen to place the example perturbation safely below a positive threshold. -/
+def exampleAmplitude (ρ : ℝ≥0) (M : ℝ) : ℝ :=
+  M / (4 * ((cosineExample ρ).uniformNorm + 1))
+
+theorem exampleAmplitude_pos (ρ : ℝ≥0) {M : ℝ} (hM : 0 < M) :
+    0 < exampleAmplitude ρ M := by
+  have := ((cosineExample ρ).norm_le_iff.mp le_rfl).nonneg
+  unfold exampleAmplitude
+  positivity
+
+/-- A nonconstant cosine perturbation with its angle average removed. -/
+def examplePerturbation (ρ : ℝ≥0) (M : ℝ) :=
+  (scaledCosine ρ (exampleAmplitude ρ M)).centered
+
+theorem examplePerturbation_bound (ρ : ℝ≥0) {M : ℝ} (hM : 0 < M) :
+    (examplePerturbation ρ M).uniformNorm ≤ M := by
+  have hC := ((cosineExample ρ).norm_le_iff.mp le_rfl).nonneg
+  have hε := (exampleAmplitude_pos ρ hM).le
+  have h1 := (scaledCosine ρ (exampleAmplitude ρ M)).uniformNorm_centered_le
+  have h2 := scaledCosine_bound ρ hε
+  apply h1.trans
+  apply (mul_le_mul_of_nonneg_left h2 (by norm_num : (0 : ℝ) ≤ 2)).trans
+  dsimp [exampleAmplitude]
+  apply (le_of_lt ?_)
+  have hc : 0 < 4 * ((cosineExample ρ).uniformNorm + 1) := by positivity
+  field_simp
+  nlinarith
+
+theorem examplePerturbation_nonconstant (ρ : ℝ≥0) {M : ℝ} (hM : 0 < M)
+    (p : ComplexSpace 1) :
+    (examplePerturbation ρ M).toFun (p, 0) ≠
+      (examplePerturbation ρ M).toFun (p, fun _ => (Real.pi : ℂ)) := by
+  have hε := ne_of_gt (exampleAmplitude_pos ρ hM)
+  simp only [examplePerturbation, AnalyticPhaseFunction.centered, AnalyticPhaseFunction.sub,
+    AnalyticPhaseFunction.angleAverageFunction, scaledCosine, cosineExample,
+    Pi.zero_apply, Complex.cos_zero, Complex.cos_pi, mul_one, mul_neg_one, ne_eq,
+    sub_left_inj]
+  intro he
+  have hz : (exampleAmplitude ρ M : ℂ) = 0 := by linear_combination (1 / 2 : ℂ) * he
+  exact hε (Complex.ofReal_eq_zero.mp hz)
+
+theorem example_has_nonzero_mode {ρ : ℝ≥0} (hρ : 0 < ρ) {M : ℝ} (hM : 0 < M)
+    (p : ComplexSpace 1) :
+    ∃ k : FourierIndex 1, k ≠ 0 ∧ (examplePerturbation ρ M).fourierCoeff p k ≠ 0 := by
+  by_contra! hall
+  have hz : ∀ k, (examplePerturbation ρ M).fourierCoeff p k = 0 := by
+    intro k
+    by_cases hk : k = 0
+    · subst k
+      exact (scaledCosine ρ (exampleAmplitude ρ M)).angleAverage_centered_eq_zero (mem_univ p)
+    · exact hall k hk
+  have h0 := (examplePerturbation ρ M).hasSum_fourier_on_strip (mem_univ p) hρ
+    (complexify_mem_angleStrip (0 : RealSpace 1) 0)
+  have hπ := (examplePerturbation ρ M).hasSum_fourier_on_strip (mem_univ p) hρ
+    (complexify_mem_angleStrip (fun _ => Real.pi) 0)
+  have h0' : HasSum (fun _ : FourierIndex 1 => (0 : ℂ))
+      ((examplePerturbation ρ M).toFun (p, complexify 0)) := by
+    simpa only [hz, zero_mul] using h0
+  have hπ' : HasSum (fun _ : FourierIndex 1 => (0 : ℂ))
+      ((examplePerturbation ρ M).toFun (p, complexify (fun _ => Real.pi))) := by
+    simpa only [hz, zero_mul] using hπ
+  exact examplePerturbation_nonconstant ρ hM p (h0'.unique hπ')
+
+theorem exampleInput {ρ β δ γ : ℝ≥0} {M : ℝ}
+    (b : FundamentalParameters 1 ρ β δ γ (1 / 2) M 1) :
+    FundamentalInput (E := exampleActionDomain) (β := β) (δ := δ) (γ := γ)
+      (K := 1 / 2) (M := M) (Θ := 1) quadraticAction (examplePerturbation ρ M) where
+  integrable := quadraticData
+  domain_subset := subset_univ _
+  domain_conj := exampleActionDomain_conj
+  perturbation_bound := examplePerturbation_bound ρ b.perturbation_pos
+  mean_zero := fun p _ => (scaledCosine ρ (exampleAmplitude ρ M)).angleAverage_centered_eq_zero
+    (mem_univ p)
+  nonresonant := fun _ hp => example_nonresonance hp _
+  budget := b
+
+example {ρ β δ γ : ℝ≥0} {M : ℝ}
+    (b : FundamentalParameters 1 ρ β δ γ (1 / 2) M 1) :
+    (exampleInput b).result.perturbation.uniformNorm < fundamentalRemainderBound 1 M δ β :=
+  (exampleInput b).result.bound
+
+end KamProject.Arnold1963.Audit
diff --git a/LeanPool/ArnoldKAM/Arnold1963/Audit/Steps123.lean b/LeanPool/ArnoldKAM/Arnold1963/Audit/Steps123.lean
new file mode 100644
index 0000000000..15c9b25a04
--- /dev/null
+++ b/LeanPool/ArnoldKAM/Arnold1963/Audit/Steps123.lean
@@ -0,0 +1,97 @@
+/-
+Copyright (c) 2026 Bingqi Yu. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Bingqi Yu
+-/
+
+module
+
+public import LeanPool.ArnoldKAM.Arnold1963.Analysis.FourierCoefficients
+public import LeanPool.ArnoldKAM.Arnold1963.Analysis.FourierKernel
+public import LeanPool.ArnoldKAM.Arnold1963.Arithmetic.Parameters
+public import Mathlib.Analysis.SpecialFunctions.Trigonometric.Deriv
+
+/-!
+Integration, Fourier normalization, threshold positivity, and a nonconstant cosine example.
+-/
+
+@[expose] public section
+noncomputable section
+open KamProject.Arnold1963 MeasureTheory
+open scoped NNReal
+namespace KamProject.Arnold1963.Audit
+
+/-- Normalized Haar measure for the explicit Fourier examples. -/
+local instance auditFourierMeasureSpace : MeasureSpace UnitAddCircle := ⟨AddCircle.haarAddCircle⟩
+local instance : IsProbabilityMeasure (volume : Measure UnitAddCircle) :=
+  inferInstanceAs (IsProbabilityMeasure AddCircle.haarAddCircle)
+
+example (k : FourierIndex 2) :
+    UnitAddTorus.mFourierCoeff (UnitAddTorus.mFourier k) k = (1 : ℂ) := by
+  have h := (orthonormal_iff_ite.mp UnitAddTorus.orthonormal_mFourier) k k
+  simpa only [ite_true, eq_self, ContinuousMap.inner_toLp, ← UnitAddTorus.mFourier_neg,
+    UnitAddTorus.mFourierCoeff, smul_eq_mul, mul_comm] using h
+
+example : indexLength (![1, 1] : FourierIndex 2) = 2 := by norm_num [indexLength]
+example : (![1, 1] : FourierIndex 2) ∉ fourierModes 2 2 := by norm_num [indexLength]
+example : (![1, 1] : FourierIndex 2) ∈ fourierModes 2 (5 / 2) := by
+  norm_num [indexLength]
+example : ‖(fun _ : Fin 2 => (1 : ℂ))‖ = 1 := by simp
+example (M : ℝ) : NormBoundOn (fun _ : ℝ => (0 : ℂ)) ∅ M ↔ 0 ≤ M := by simp
+
+private theorem norm_cos_le_exp_im (z : ℂ) : ‖Complex.cos z‖ ≤ Real.exp |z.im| := by
+  rw [Complex.cos, norm_div]
+  rw [show ‖(2 : ℂ)‖ = (2 : ℝ) by norm_num]
+  apply (div_le_iff₀ (by norm_num : (0 : ℝ) < 2)).mpr
+  have h := norm_add_le (Complex.exp (z * Complex.I)) (Complex.exp (-z * Complex.I))
+  rw [Complex.norm_exp, Complex.norm_exp] at h
+  have ha : (z * Complex.I).re ≤ |z.im| := by simpa using neg_le_abs z.im
+  have hb : (-z * Complex.I).re ≤ |z.im| := by simpa using le_abs_self z.im
+  exact h.trans (by nlinarith [Real.exp_le_exp.mpr ha, Real.exp_le_exp.mpr hb])
+
+/-- The cosine of the first angle, packaged with analyticity, periodicity and boundedness. -/
+def cosineExample (ρ : ℝ≥0) : AnalyticPhaseFunction 1 Set.univ ρ where
+  toFun z := Complex.cos (z.2 0)
+  domain_conj := by intro z hz; trivial
+  analytic := by
+    intro z hz
+    let L : ComplexPhaseSpace 1 →L[ℂ] ℂ :=
+      (ContinuousLinearMap.proj (0 : Fin 1)).comp (ContinuousLinearMap.snd ℂ _ _)
+    exact Complex.analyticAt_cos.comp (f := L) (L.analyticAt z)
+  periodic := by
+    intro p hp q hq k
+    simpa [angleShift, complexify, mul_comm, mul_assoc] using
+      Complex.cos_add_int_mul_two_pi (q 0) (k 0)
+  conj_compatible := by
+    intro z hz
+    simpa only [conjPhase, conjVec, starRingEnd_apply] using Complex.cos_conj (z.2 0)
+  bounded := by
+    refine ⟨Real.exp ρ, (Real.exp_pos _).le, fun z hz => ?_⟩
+    exact (norm_cos_le_exp_im _).trans
+      (Real.exp_le_exp.mpr ((mem_angleStrip_iff _ _).mp hz.2 0))
+
+example (ρ : ℝ≥0) : (cosineExample ρ).toFun (0, 0) = 1 := by
+  simp [cosineExample]
+example (ρ : ℝ≥0) :
+    (cosineExample ρ).toFun (0, fun _ => (Real.pi : ℂ)) = -1 := by
+  simp [cosineExample]
+
+example (ρ : ℝ≥0) (k : FourierIndex 1) :
+    ‖(cosineExample ρ).fourierCoeff 0 k‖ ≤ (cosineExample ρ).uniformNorm :=
+  (cosineExample ρ).norm_fourierCoeff_le (Set.mem_univ _) k
+example (ρ : ℝ≥0) :
+    ‖(cosineExample ρ).toFun (0, 0) - (cosineExample ρ).angleAverage 0‖ ≤
+      2 * (cosineExample ρ).uniformNorm :=
+  (cosineExample ρ).norm_sub_angleAverage_le (Set.mem_univ _)
+    (by simpa using complexify_mem_angleStrip (0 : RealSpace 1) ρ)
+
+example {δ : ℝ} (hδ : 0 < δ) :
+    HasSum (fun k : FourierIndex 0 => Real.exp (-δ * indexLength k)) 1 := by
+  simpa using hasSum_exp_indexLength 0 hδ
+
+example {n : ℕ} (hn : 0 < n) {θ Θ ρ κ D : ℝ}
+    (hθ : 0 < θ) (hΘ : 0 < Θ) (hρ : 0 < ρ) (hκ : 0 < κ) (hD : 0 < D) :
+    0 < initialPerturbationThreshold n θ Θ ρ κ D :=
+  initialPerturbationThreshold_pos hn hθ hΘ hρ hκ hD
+
+end KamProject.Arnold1963.Audit
diff --git a/LeanPool/ArnoldKAM/Arnold1963/Audit/W10Branches.lean b/LeanPool/ArnoldKAM/Arnold1963/Audit/W10Branches.lean
new file mode 100644
index 0000000000..6431602a4b
--- /dev/null
+++ b/LeanPool/ArnoldKAM/Arnold1963/Audit/W10Branches.lean
@@ -0,0 +1,138 @@
+/-
+Copyright (c) 2026 Bingqi Yu. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Bingqi Yu
+-/
+
+module
+
+public import LeanPool.ArnoldKAM.Arnold1963.Audit.W10Example
+
+/-!
+The good set meets both separated action branches and supplies distinct invariant tori
+in each branch. Strict measure bounds and torus continuity establish these witnesses.
+-/
+
+@[expose] public section
+noncomputable section
+open Set Metric MeasureTheory
+open scoped ENNReal
+namespace KamProject.Arnold1963.Audit.W10Example
+open W9Example
+local instance w10BranchesPeriodPositive : Fact (0 < 2 * Real.pi) :=
+  ⟨mul_pos (by norm_num) Real.pi_pos⟩
+
+/-- The real phase cylinder over the action ball centered at the specified branch. -/
+def branchPhase (a : ℝ) : Set (RealPhaseSpace 1) :=
+  closedBall (center a) (1 / 4) ×ˢ (univ : Set (RealTorus 1))
+
+theorem branchPhase_partition : realSlice ambient ×ˢ (univ : Set (RealTorus 1)) =
+    branchPhase 1 ∪ branchPhase (-1) := by
+  rw [realSlice_ambient, union_prod]
+  rfl
+
+theorem branchPhase_disjoint : Disjoint (branchPhase 1) (branchPhase (-1)) := by
+  have hd : Disjoint (closedBall (center 1) (1 / 4))
+      (closedBall (center (-1)) (1 / 4)) := closedBall_disjoint_closedBall (by
+    norm_num [dist_eq_norm, W9Example.center, Pi.sub_def, pi_norm_const])
+  exact disjoint_left.mpr (fun _ hx hy => disjoint_left.mp hd hx.1 hy.1)
+
+theorem branchPhase_volume_eq : volume (branchPhase 1) = volume (branchPhase (-1)) := by
+  change (volume.prod volume) _ = (volume.prod volume) _
+  simp only [branchPhase, Measure.prod_prod,
+    Measure.addHaar_closedBall_center]
+
+theorem branchPhase_half_volume :
+    ENNReal.ofReal (1 / 2 : ℝ) *
+      volume (realSlice ambient ×ˢ (univ : Set (RealTorus 1))) = volume (branchPhase 1) := by
+  rw [branchPhase_partition, measure_union branchPhase_disjoint
+    (measurableSet_closedBall.prod MeasurableSet.univ), ← branchPhase_volume_eq,
+    ← two_mul, ← mul_assoc]
+  norm_num only [ENNReal.ofReal_div_of_pos, ENNReal.ofReal_one,
+    ENNReal.ofReal_ofNat, one_div]
+  rw [ENNReal.inv_mul_cancel (by norm_num) (by norm_num), one_mul]
+
+theorem actual_good_meets_both_branches :
+    (result.goodSet ∩ branchPhase 1).Nonempty ∧
+      (result.goodSet ∩ branchPhase (-1)).Nonempty := by
+  have hsub : result.goodSet ⊆ branchPhase 1 ∪ branchPhase (-1) := by
+    rw [← branchPhase_partition, ← result.partition]
+    exact subset_union_left
+  have hlarge : volume (branchPhase 1) < volume result.goodSet := by
+    rw [← branchPhase_half_volume]
+    exact actual_large_measure
+  constructor
+  · by_contra hn
+    have hs : result.goodSet ⊆ branchPhase (-1) := by
+      intro z hz
+      exact (hsub hz).resolve_left (fun hp => hn ⟨z, hz, hp⟩)
+    exact (not_le_of_gt hlarge) (branchPhase_volume_eq ▸ measure_mono hs)
+  · by_contra hn
+    have hs : result.goodSet ⊆ branchPhase 1 := by
+      intro z hz
+      exact (hsub hz).resolve_right (fun hp => hn ⟨z, hz, hp⟩)
+    exact (not_le_of_gt hlarge) (measure_mono hs)
+
+private theorem branch_coordinate {a : ℝ} {z : RealPhaseSpace 1}
+    (hz : z ∈ branchPhase a) : |z.1 0 - a| ≤ (1 / 4 : ℝ) := by
+  have hd : ‖z.1 - center a‖ ≤ (1 / 4 : ℝ) := by
+    simpa only [mem_closedBall, dist_eq_norm] using hz.1
+  simpa only [Pi.sub_apply, W9Example.center, Real.norm_eq_abs] using
+    (norm_le_pi_norm (z.1 - center a) 0).trans hd
+
+theorem actual_torus_in_one_branch {T : Set (RealPhaseSpace 1)} (hT : T ∈ result.tori) :
+    T ⊆ branchPhase 1 ∨ T ⊆ branchPhase (-1) := by
+  obtain ⟨R⟩ := actual_torus_realization T hT
+  have hc : IsPreconnected T := R.embedding_range ▸
+    isPreconnected_range R.closedEmbedding.continuous
+  have hs : T ⊆ branchPhase 1 ∪ branchPhase (-1) := by
+    intro z hz
+    rw [← branchPhase_partition, ← result.partition]
+    exact Or.inl (result.union_eq ▸ mem_sUnion.mpr ⟨T, hT, hz⟩)
+  have hn : ∀ z ∈ T, z.1 0 ≠ 0 := by
+    intro z hz he
+    rcases hs hz with hp | hm
+    · have hh := branch_coordinate hp
+      norm_num [he] at hh
+    · have hh := branch_coordinate hm
+      norm_num [he] at hh
+  have hf : Continuous (fun z : RealPhaseSpace 1 => z.1 0) :=
+    (continuous_apply 0).comp continuous_fst
+  rcases hc.mapsTo_Ioi_or_Iio hf.continuousOn hn with hp | hm
+  · left
+    intro z hz
+    rcases hs hz with h | h
+    · exact h
+    · have hh := (abs_le.mp (branch_coordinate h)).2
+      have hpos := hp hz
+      change 0 < z.1 0 at hpos
+      linarith
+  · right
+    intro z hz
+    rcases hs hz with h | h
+    · have hh := (abs_le.mp (branch_coordinate h)).1
+      have hneg := hm hz
+      change z.1 0 < 0 at hneg
+      linarith
+    · exact h
+
+theorem actual_two_branch_tori :
+    ∃ Tpos ∈ result.tori, ∃ Tneg ∈ result.tori,
+      Tpos.Nonempty ∧ Tneg.Nonempty ∧ Tpos ⊆ branchPhase 1 ∧ Tneg ⊆ branchPhase (-1) ∧
+      Tpos ≠ Tneg ∧ Disjoint Tpos Tneg := by
+  obtain ⟨⟨z, hz, hzpos⟩, ⟨w, hw, hwneg⟩⟩ := actual_good_meets_both_branches
+  rw [result.union_eq] at hz hw
+  obtain ⟨Tpos, hTpos, hzT⟩ := mem_sUnion.mp hz
+  obtain ⟨Tneg, hTneg, hwT⟩ := mem_sUnion.mp hw
+  have hp : Tpos ⊆ branchPhase 1 := (actual_torus_in_one_branch hTpos).resolve_right (by
+    intro h
+    exact disjoint_left.mp branchPhase_disjoint hzpos (h hzT))
+  have hm : Tneg ⊆ branchPhase (-1) := (actual_torus_in_one_branch hTneg).resolve_left (by
+    intro h
+    exact disjoint_left.mp branchPhase_disjoint (h hwT) hwneg)
+  have hd : Disjoint Tpos Tneg := branchPhase_disjoint.mono hp hm
+  refine ⟨Tpos, hTpos, Tneg, hTneg, ⟨z, hzT⟩, ⟨w, hwT⟩, hp, hm, ?_, hd⟩
+  intro he
+  exact disjoint_left.mp hd hzT (he ▸ hzT)
+
+end KamProject.Arnold1963.Audit.W10Example
diff --git a/LeanPool/ArnoldKAM/Arnold1963/Audit/W10Example.lean b/LeanPool/ArnoldKAM/Arnold1963/Audit/W10Example.lean
new file mode 100644
index 0000000000..c4df7a7fb2
--- /dev/null
+++ b/LeanPool/ArnoldKAM/Arnold1963/Audit/W10Example.lean
@@ -0,0 +1,50 @@
+/-
+Copyright (c) 2026 Bingqi Yu. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Bingqi Yu
+-/
+
+module
+
+public import LeanPool.ArnoldKAM.Arnold1963.Main.Theorem1
+public import LeanPool.ArnoldKAM.Arnold1963.Audit.W9Example
+
+/-!
+The full KAM theorem applied to the cubic two-branch Hamiltonian and a nonconstant small
+perturbation, yielding actual disjoint tori and strict physical measure bounds.
+-/
+
+@[expose] public section
+noncomputable section
+open Set MeasureTheory
+open scoped NNReal ENNReal
+namespace KamProject.Arnold1963.Audit.W10Example
+open W9Example
+local instance w10ExamplePeriodPositive : Fact (0 < 2 * Real.pi) :=
+  ⟨mul_pos (by norm_num) Real.pi_pos⟩
+
+/-- The actual KAM result for the cubic Hamiltonian and its small nonconstant perturbation. -/
+def result : Theorem1Result 1 cubic ambient 1 (1 / 2) perturbation :=
+  localization.theorem1Result cubicOriginalData.compact perturbation perturbation_bound
+
+theorem original_data_threshold :
+    ∃ M : ℝ, 0 < M ∧ ∀ f : AnalyticPhaseFunction 1 ambient 1,
+      f.uniformNorm ≤ M → Nonempty (Theorem1Result 1 cubic ambient 1 (1 / 2) f) :=
+  theorem1 cubicOriginalData (by norm_num) (by norm_num)
+
+theorem actual_disjoint_tori : result.tori.Pairwise Disjoint := result.pairwise_disjoint
+
+theorem actual_torus_realization (T : Set (RealPhaseSpace 1)) (hT : T ∈ result.tori) :
+    Nonempty (KAMTorus 1 cubic perturbation.toFun ambient result.width (1 / 2) T) :=
+  result.realization T hT
+
+theorem actual_good_nonempty : result.goodSet.Nonempty := result.good_nonempty
+
+theorem actual_large_measure : ENNReal.ofReal (1 / 2 : ℝ) *
+    volume (realSlice ambient ×ˢ (univ : Set (RealTorus 1))) < volume result.goodSet := by
+  simpa only [show (1 : ℝ) - 1 / 2 = 1 / 2 by norm_num] using result.good_large
+
+theorem actual_bad_measure : volume result.badSet < ENNReal.ofReal (1 / 2 : ℝ) *
+    volume (realSlice ambient ×ˢ (univ : Set (RealTorus 1))) := result.bad_small
+
+end KamProject.Arnold1963.Audit.W10Example
diff --git a/LeanPool/ArnoldKAM/Arnold1963/Audit/W9Example.lean b/LeanPool/ArnoldKAM/Arnold1963/Audit/W9Example.lean
new file mode 100644
index 0000000000..d1c14e47b6
--- /dev/null
+++ b/LeanPool/ArnoldKAM/Arnold1963/Audit/W9Example.lean
@@ -0,0 +1,176 @@
+/-
+Copyright (c) 2026 Bingqi Yu. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Bingqi Yu
+-/
+
+module
+
+public import LeanPool.ArnoldKAM.Arnold1963.Main.GlobalCover
+public import LeanPool.ArnoldKAM.Arnold1963.Audit.FundamentalExample
+public import Mathlib.MeasureTheory.Measure.Lebesgue.EqHaar
+
+/-!
+A one-dimensional cubic Hamiltonian on two separated domains near +1 and -1. Its Hessian
+is nondegenerate on both branches, while their central frequencies agree. A nonconstant
+perturbation exercises the global construction without global frequency injectivity.
+-/
+
+@[expose] public section
+noncomputable section
+open Set Metric MeasureTheory
+open scoped NNReal ENNReal
+namespace KamProject.Arnold1963.Audit.W9Example
+local instance : Fact (0 < 2 * Real.pi) := ⟨mul_pos (by norm_num) Real.pi_pos⟩
+
+/-- The cubic Hamiltonian whose frequency map agrees at the two branch centers. -/
+def cubic (p : ComplexSpace 1) : ℂ := p 0 ^ 3 / 3
+
+theorem cubic_analytic (p : ComplexSpace 1) : AnalyticAt ℂ cubic p :=
+  ((ContinuousLinearMap.proj (R := ℂ) (φ := fun _ : Fin 1 => ℂ) 0).analyticAt p).pow 3
+    |>.div analyticAt_const (by norm_num)
+
+theorem cubic_fderiv (p : ComplexSpace 1) :
+    fderiv ℂ cubic p = p 0 ^ 2 • ContinuousLinearMap.proj 0 := by
+  let L : ComplexSpace 1 →L[ℂ] ℂ := ContinuousLinearMap.proj 0
+  have hd := ((L.hasFDerivAt (x := p)).pow 3).mul_const (3 : ℂ)⁻¹
+  change HasFDerivAt (𝕜 := ℂ) cubic _ p at hd
+  rw [hd.fderiv]
+  ext v
+  simp [L]
+  ring
+
+theorem cubic_frequency (p : ComplexSpace 1) :
+    actionFrequency cubic p = fun _ => p 0 ^ 2 := by
+  ext j
+  simp [actionFrequency, cubic_fderiv, Fin.eq_zero j]
+
+theorem cubic_second (p v w : ComplexSpace 1) :
+    fderiv ℂ (fderiv ℂ cubic) p v w = 2 * p 0 * v 0 * w 0 := by
+  let L : ComplexSpace 1 →L[ℂ] ℂ := ContinuousLinearMap.proj 0
+  have he : fderiv ℂ cubic = fun p => p 0 ^ 2 • L := funext cubic_fderiv
+  rw [he]
+  have hd := ((L.hasFDerivAt (x := p)).pow 2).smul_const L
+  change ((fderiv ℂ (fun p => L p ^ 2 • L) p) v) w = _
+  rw [hd.fderiv]
+  simp [L]
+
+theorem cubic_hessian (p : ComplexSpace 1) : hessianDet cubic p = 2 * p 0 := by
+  rw [hessianDet_eq_matrix (cubic_analytic p)]
+  erw [Matrix.det_fin_one]
+  simp [cubic_second]
+
+/-- The one-dimensional real action vector with the specified value. -/
+def center (a : ℝ) : RealSpace 1 := fun _ => a
+
+/-- Two disjoint compact complex action balls around the two branch centers. -/
+def ambient : Set (ComplexSpace 1) :=
+  closedBall (complexify (center 1)) (1 / 4) ∪ closedBall (complexify (center (-1))) (1 / 4)
+
+/-- The union of the corresponding open real action balls. -/
+def realOpen : Set (RealSpace 1) :=
+  ball (center 1) (1 / 4) ∪ ball (center (-1)) (1 / 4)
+
+theorem ambient_conj : ConjInvariant ambient := by
+  intro p hp
+  change star p ∈ ambient
+  rcases hp with hp | hp
+  · apply Or.inl
+    have hs : star (complexify (center 1)) = complexify (center 1) := conjVec_complexify _
+    rw [mem_closedBall, ← hs, dist_star_star]
+    exact hp
+  · apply Or.inr
+    have hs : star (complexify (center (-1))) = complexify (center (-1)) := conjVec_complexify _
+    rw [mem_closedBall, ← hs, dist_star_star]
+    exact hp
+
+theorem realSlice_ambient : realSlice ambient =
+    closedBall (center 1) (1 / 4) ∪ closedBall (center (-1)) (1 / 4) := by
+  ext x
+  simp only [realSlice, ambient, mem_preimage, mem_union, mem_closedBall,
+    (isometry_complexify 1).dist_eq]
+
+/-- The verified compact-domain and nondegeneracy hypotheses for the cubic example. -/
+def cubicOriginalData : GlobalHamiltonianData 1 cubic ambient where
+  dimension_pos := by norm_num
+  compact := (isCompact_closedBall _ _).union (isCompact_closedBall _ _)
+  domain_conj := ambient_conj
+  analytic := fun p _ => cubic_analytic p
+  conj := by intro p _; simp [cubic, conjVec]
+  realOpen := realOpen
+  isOpen_realOpen := isOpen_ball.union isOpen_ball
+  nonempty_realOpen := ⟨center 1, Or.inl (mem_ball_self (by norm_num))⟩
+  closure_realOpen := by
+    rw [realOpen, closure_union, closure_ball _ (by norm_num : (1 / 4 : ℝ) ≠ 0),
+      closure_ball _ (by norm_num : (1 / 4 : ℝ) ≠ 0), realSlice_ambient]
+  boundary_null := by
+    apply le_antisymm _ zero_le
+    calc
+      _ ≤ volume (frontier (ball (center 1) (1 / 4)) ∪
+          frontier (ball (center (-1)) (1 / 4))) := measure_mono
+        ((frontier_union_subset _ _).trans
+          (union_subset_union inter_subset_left inter_subset_right))
+      _ ≤ volume (frontier (ball (center 1) (1 / 4))) +
+          volume (frontier (ball (center (-1)) (1 / 4))) := measure_union_le _ _
+      _ = 0 := by rw [frontier_ball _ (by norm_num : (1 / 4 : ℝ) ≠ 0),
+        frontier_ball _ (by norm_num : (1 / 4 : ℝ) ≠ 0),
+        Measure.addHaar_sphere volume, Measure.addHaar_sphere volume, zero_add]
+  complex_interior := by
+    intro p hp
+    have hb : complexify p ∈
+        ball (complexify (center 1)) (1 / 4) ∪ ball (complexify (center (-1))) (1 / 4) := by
+      simpa only [realOpen, mem_union, mem_ball, (isometry_complexify 1).dist_eq] using hp
+    exact mem_interior.mpr ⟨_, union_subset_union ball_subset_closedBall ball_subset_closedBall,
+      isOpen_ball.union isOpen_ball, hb⟩
+  nondegenerate := by
+    intro p hp
+    rw [cubic_hessian]
+    apply mul_ne_zero (by norm_num)
+    intro he
+    have hp0 : p 0 = 0 := by simpa only [complexify, Complex.ofReal_eq_zero] using he
+    have hpzero : p = 0 := by ext j; simpa [Fin.eq_zero j] using hp0
+    rw [hpzero] at hp
+    change dist (0 : RealSpace 1) (fun _ => 1) < (1 / 4 : ℝ) ∨
+      dist (0 : RealSpace 1) (fun _ => -1) < (1 / 4 : ℝ) at hp
+    norm_num [dist_eq_norm, pi_norm_const] at hp
+
+theorem frequency_not_injective : ¬ InjOn (actionFrequency cubic) ambient := by
+  intro hi
+  have he := hi (Or.inl (mem_closedBall_self (by norm_num : (0 : ℝ) ≤ 1 / 4)))
+    (Or.inr (mem_closedBall_self (by norm_num : (0 : ℝ) ≤ 1 / 4)))
+    (show actionFrequency cubic (complexify (center 1)) =
+      actionFrequency cubic (complexify (center (-1))) by
+        simp [cubic_frequency, center, complexify])
+  have h0 := congrArg (fun p : ComplexSpace 1 => p 0) he
+  norm_num [complexify, center] at h0
+
+/-- A finite localization of the cubic example with width one and tolerance one half. -/
+def localization : FiniteLocalization 1 cubic ambient 1 (1 / 2) :=
+  Classical.choice (cubicOriginalData.exists_finiteLocalization (by norm_num) (by norm_num))
+
+/-- The centered cosine perturbation restricted to the cubic example's ambient domain. -/
+def perturbation : AnalyticPhaseFunction 1 ambient 1 :=
+  (examplePerturbation 1 localization.threshold).restrict (subset_univ _) le_rfl ambient_conj
+
+theorem perturbation_bound : perturbation.uniformNorm ≤ localization.threshold :=
+  ((examplePerturbation 1 localization.threshold).uniformNorm_restrict_le _ _ _).trans
+    (examplePerturbation_bound 1 localization.threshold_pos)
+
+theorem nonconstant_on_initial_phase :
+    ∃ z ∈ phaseDomain ambient 1, ∃ w ∈ phaseDomain ambient 1,
+      perturbation.toFun z ≠ perturbation.toFun w := by
+  refine ⟨(complexify (center 1), complexify (0 : RealSpace 1)),
+    ⟨Or.inl (mem_closedBall_self (by norm_num)), complexify_mem_angleStrip _ _⟩,
+    (complexify (center 1), complexify (fun _ : Fin 1 => Real.pi)),
+    ⟨Or.inl (mem_closedBall_self (by norm_num)), complexify_mem_angleStrip _ _⟩, ?_⟩
+  exact examplePerturbation_nonconstant 1 localization.threshold_pos (complexify (center 1))
+
+theorem actual_bad_volume : volume (localization.badSet perturbation perturbation_bound) <
+    ENNReal.ofReal (1 / 2 : ℝ) * volume localization.phase :=
+  localization.badSet_volume_lt cubicOriginalData.compact perturbation perturbation_bound
+
+theorem actual_good_volume_pos :
+    0 < volume (localization.goodSet perturbation perturbation_bound) :=
+  localization.goodSet_volume_pos perturbation perturbation_bound
+
+end KamProject.Arnold1963.Audit.W9Example
diff --git a/LeanPool/ArnoldKAM/Arnold1963/Basic/Domains.lean b/LeanPool/ArnoldKAM/Arnold1963/Basic/Domains.lean
new file mode 100644
index 0000000000..4ab6470abe
--- /dev/null
+++ b/LeanPool/ArnoldKAM/Arnold1963/Basic/Domains.lean
@@ -0,0 +1,150 @@
+/-
+Copyright (c) 2026 Bingqi Yu. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Bingqi Yu
+-/
+
+module
+
+public import LeanPool.ArnoldKAM.Arnold1963.Basic.Spaces
+public import Mathlib.Topology.MetricSpace.Basic
+public import Mathlib.Topology.MetricSpace.Thickening
+
+/-!
+Closed-ball neighborhoods, erosion, complex angle strips, and real slices. Radii are nonnegative.
+The neighborhood is a union of actual closed balls; its zero-radius value is the original set.
+Compactness hypotheses justify closedness when it is needed.
+-/
+
+@[expose] public section
+
+noncomputable section
+
+open scoped NNReal
+
+namespace KamProject.Arnold1963
+
+section MetricDomains
+
+variable {E : Type*} [MetricSpace E]
+
+/-- The union of closed balls of a fixed radius centered at points of the set. -/
+def closedBallNeighborhood (U : Set E) (r : ℝ≥0) : Set E :=
+  {x | ∃ y ∈ U, dist x y ≤ (r : ℝ)}
+
+/-- The points whose closed ball of the specified radius remains inside the set. -/
+def erosion (U : Set E) (r : ℝ≥0) : Set E :=
+  {x | Metric.closedBall x (r : ℝ) ⊆ U}
+
+@[simp] theorem erosion_zero (U : Set E) : erosion U 0 = U := by
+  ext x
+  simp [erosion]
+
+@[simp] theorem closedBallNeighborhood_zero (U : Set E) :
+    closedBallNeighborhood U 0 = U := by
+  ext x
+  simp [closedBallNeighborhood]
+
+theorem erosion_subset (U : Set E) (r : ℝ≥0) : erosion U r ⊆ U := by
+  intro x hx
+  exact hx (Metric.mem_closedBall_self r.coe_nonneg)
+
+theorem subset_closedBallNeighborhood (U : Set E) (r : ℝ≥0) :
+    U ⊆ closedBallNeighborhood U r := by
+  intro x hx
+  exact ⟨x, hx, by simp⟩
+
+theorem erosion_mono {U V : Set E} (hUV : U ⊆ V) (r : ℝ≥0) :
+    erosion U r ⊆ erosion V r := by
+  intro x hx y hy
+  exact hUV (hx hy)
+
+theorem erosion_antitone_radius (U : Set E) {r s : ℝ≥0} (hrs : r ≤ s) :
+    erosion U s ⊆ erosion U r := by
+  intro x hx y hy
+  apply hx
+  exact le_trans hy (show (r : ℝ) ≤ (s : ℝ) from hrs)
+
+theorem erosion_inter (U V : Set E) (r : ℝ≥0) :
+    erosion (U ∩ V) r = erosion U r ∩ erosion V r := by
+  ext x
+  simp only [erosion, Set.mem_ofPred_eq, Set.subset_inter_iff, Set.mem_inter_iff]
+
+theorem mem_of_mem_erosion {U : Set E} {r : ℝ≥0} {x y : E}
+    (hx : x ∈ erosion U r) (hxy : dist y x ≤ (r : ℝ)) : y ∈ U :=
+  hx hxy
+
+end MetricDomains
+
+section CompactDomains
+
+variable {E : Type*} [MetricSpace E] {U : Set E}
+
+theorem closedBallNeighborhood_eq_cthickening_of_isCompact (hU : IsCompact U)
+    (r : ℝ≥0) : closedBallNeighborhood U r = Metric.cthickening (r : ℝ) U := by
+  rw [hU.cthickening_eq_biUnion_closedBall r.coe_nonneg]
+  ext x
+  simp [closedBallNeighborhood, Metric.mem_closedBall]
+
+theorem isClosed_closedBallNeighborhood_of_isCompact (hU : IsCompact U) (r : ℝ≥0) :
+    IsClosed (closedBallNeighborhood U r) := by
+  rw [closedBallNeighborhood_eq_cthickening_of_isCompact hU]
+  exact Metric.isClosed_cthickening
+
+theorem isCompact_closedBallNeighborhood [ProperSpace E] (hU : IsCompact U)
+    (r : ℝ≥0) : IsCompact (closedBallNeighborhood U r) := by
+  rw [closedBallNeighborhood_eq_cthickening_of_isCompact hU]
+  exact hU.cthickening
+
+theorem isClosed_closedBallNeighborhood [ProperSpace E] (hU : IsClosed U) (r : ℝ≥0) :
+    IsClosed (closedBallNeighborhood U r) := by
+  have heq : closedBallNeighborhood U r = Metric.cthickening (r : ℝ) U := by
+    rw [hU.cthickening_eq_biUnion_closedBall r.coe_nonneg]
+    ext x
+    simp [closedBallNeighborhood, Metric.mem_closedBall]
+  rw [heq]
+  exact Metric.isClosed_cthickening
+
+end CompactDomains
+
+/-- The closed complex angle strip bounded in the supremum norm of imaginary coordinates. -/
+def angleStrip (n : ℕ) (ρ : ℝ≥0) : Set (ComplexSpace n) :=
+  {q | ‖imagPart q‖ ≤ (ρ : ℝ)}
+
+/-- The product of an action domain and a closed complex angle strip. -/
+def phaseDomain {n : ℕ} (G : Set (ComplexSpace n)) (ρ : ℝ≥0) :
+    Set (ComplexPhaseSpace n) := G ×ˢ angleStrip n ρ
+
+/-- The real actions whose complexifications belong to the complex domain. -/
+def realSlice {n : ℕ} (G : Set (ComplexSpace n)) : Set (RealSpace n) :=
+  complexify ⁻¹' G
+
+theorem isOpen_realSlice {n : ℕ} {G : Set (ComplexSpace n)} (hG : IsOpen G) :
+    IsOpen (realSlice G) := hG.preimage (continuous_complexify n)
+
+theorem isClosed_realSlice {n : ℕ} {G : Set (ComplexSpace n)} (hG : IsClosed G) :
+    IsClosed (realSlice G) := hG.preimage (continuous_complexify n)
+
+theorem isCompact_realSlice {n : ℕ} {G : Set (ComplexSpace n)} (hG : IsCompact G) :
+    IsCompact (realSlice G) :=
+  (isometry_complexify n).isClosedEmbedding.isCompact_preimage hG
+
+/-- Closure of a complex action domain under coordinatewise conjugation. -/
+def ConjInvariant {n : ℕ} (G : Set (ComplexSpace n)) : Prop :=
+  ∀ p ∈ G, conjVec p ∈ G
+
+theorem mem_angleStrip_iff {n : ℕ} (q : ComplexSpace n) (ρ : ℝ≥0) :
+    q ∈ angleStrip n ρ ↔ ∀ j, |(q j).im| ≤ (ρ : ℝ) := by
+  simp only [angleStrip, Set.mem_ofPred_eq, pi_norm_le_iff_of_nonneg ρ.coe_nonneg,
+    imagPart, Real.norm_eq_abs]
+
+theorem complexify_mem_angleStrip {n : ℕ} (q : RealSpace n) (ρ : ℝ≥0) :
+    complexify q ∈ angleStrip n ρ := by
+  simp [angleStrip]
+
+theorem angleStrip_mono {n : ℕ} {ρ σ : ℝ≥0} (h : ρ ≤ σ) :
+    angleStrip n ρ ⊆ angleStrip n σ := by
+  intro q hq
+  exact le_trans hq (show (ρ : ℝ) ≤ (σ : ℝ) from h)
+
+end KamProject.Arnold1963
diff --git a/LeanPool/ArnoldKAM/Arnold1963/Basic/FunctionOperations.lean b/LeanPool/ArnoldKAM/Arnold1963/Basic/FunctionOperations.lean
new file mode 100644
index 0000000000..c4d095544d
--- /dev/null
+++ b/LeanPool/ArnoldKAM/Arnold1963/Basic/FunctionOperations.lean
@@ -0,0 +1,129 @@
+/-
+Copyright (c) 2026 Bingqi Yu. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Bingqi Yu
+-/
+
+module
+
+public import LeanPool.ArnoldKAM.Arnold1963.Basic.Functions
+
+/-!
+Restrictions, sums, differences, and uniform norm bounds for analytic phase functions.
+-/
+
+@[expose] public section
+noncomputable section
+open scoped NNReal
+namespace KamProject.Arnold1963
+
+theorem NormBoundOn.mono {E F : Type*} [NormedAddCommGroup F]
+    {f : E → F} {S T : Set E} {M : ℝ} (h : NormBoundOn f S M) (hTS : T ⊆ S) :
+    NormBoundOn f T M := ⟨h.nonneg, fun _ hx => h.norm_le (hTS hx)⟩
+
+theorem NormBoundOn.add {E F : Type*} [NormedAddCommGroup F]
+    {f g : E → F} {S : Set E} {M N : ℝ}
+    (hf : NormBoundOn f S M) (hg : NormBoundOn g S N) :
+    NormBoundOn (fun x => f x + g x) S (M + N) :=
+  ⟨add_nonneg hf.nonneg hg.nonneg, fun _ hx =>
+    (norm_add_le _ _).trans (add_le_add (hf.norm_le hx) (hg.norm_le hx))⟩
+
+theorem NormBoundOn.sub {E F : Type*} [NormedAddCommGroup F]
+    {f g : E → F} {S : Set E} {M N : ℝ}
+    (hf : NormBoundOn f S M) (hg : NormBoundOn g S N) :
+    NormBoundOn (fun x => f x - g x) S (M + N) :=
+  ⟨add_nonneg hf.nonneg hg.nonneg, fun _ hx =>
+    (norm_sub_le _ _).trans (add_le_add (hf.norm_le hx) (hg.norm_le hx))⟩
+
+namespace AnalyticPhaseFunction
+variable {n : ℕ} {G U : Set (ComplexSpace n)} {ρ σ : ℝ≥0}
+
+/-- Restriction to a conjugation-invariant action subdomain and a narrower angle strip. -/
+def restrict (f : AnalyticPhaseFunction n G ρ) (hUG : U ⊆ G)
+    (hσρ : σ ≤ ρ) (hU : ConjInvariant U) : AnalyticPhaseFunction n U σ where
+  toFun := f.toFun
+  domain_conj := hU
+  analytic := f.analytic.mono (Set.prod_mono hUG (angleStrip_mono hσρ))
+  periodic := fun p hp q hq k => f.periodic p (hUG hp) q (angleStrip_mono hσρ hq) k
+  conj_compatible := fun z hz => f.conj_compatible z ⟨hUG hz.1, angleStrip_mono hσρ hz.2⟩
+  bounded := ⟨f.uniformNorm, ((f.norm_le_iff).mp le_rfl).mono
+    (Set.prod_mono hUG (angleStrip_mono hσρ))⟩
+
+theorem uniformNorm_restrict_le (f : AnalyticPhaseFunction n G ρ)
+    (hUG : U ⊆ G) (hσρ : σ ≤ ρ) (hU : ConjInvariant U) :
+    (f.restrict hUG hσρ hU).uniformNorm ≤ f.uniformNorm :=
+  (norm_le_iff _).mpr (((f.norm_le_iff).mp le_rfl).mono
+    (Set.prod_mono hUG (angleStrip_mono hσρ)))
+
+/-- Addition of analytic phase functions on the same domain and strip. -/
+def add (f g : AnalyticPhaseFunction n G ρ) : AnalyticPhaseFunction n G ρ where
+  toFun := fun z => f.toFun z + g.toFun z
+  domain_conj := f.domain_conj
+  analytic := f.analytic.add g.analytic
+  periodic := by intro p hp q hq k; dsimp only; rw [f.periodic p hp q hq k, g.periodic p hp q hq k]
+  conj_compatible := by
+    intro z hz
+    dsimp only
+    rw [f.conj_compatible z hz, g.conj_compatible z hz, star_add]
+  bounded := ⟨_, ((f.norm_le_iff).mp le_rfl).add ((g.norm_le_iff).mp le_rfl)⟩
+
+/-- Subtraction of analytic phase functions on the same domain and strip. -/
+def sub (f g : AnalyticPhaseFunction n G ρ) : AnalyticPhaseFunction n G ρ where
+  toFun := fun z => f.toFun z - g.toFun z
+  domain_conj := f.domain_conj
+  analytic := f.analytic.sub g.analytic
+  periodic := by intro p hp q hq k; dsimp only; rw [f.periodic p hp q hq k, g.periodic p hp q hq k]
+  conj_compatible := by
+    intro z hz
+    dsimp only
+    rw [f.conj_compatible z hz, g.conj_compatible z hz, star_sub]
+  bounded := ⟨_, ((f.norm_le_iff).mp le_rfl).sub ((g.norm_le_iff).mp le_rfl)⟩
+
+theorem uniformNorm_add_le (f g : AnalyticPhaseFunction n G ρ) :
+    (f.add g).uniformNorm ≤ f.uniformNorm + g.uniformNorm :=
+  (norm_le_iff _).mpr (((f.norm_le_iff).mp le_rfl).add ((g.norm_le_iff).mp le_rfl))
+
+theorem uniformNorm_sub_le (f g : AnalyticPhaseFunction n G ρ) :
+    (f.sub g).uniformNorm ≤ f.uniformNorm + g.uniformNorm :=
+  (norm_le_iff _).mpr (((f.norm_le_iff).mp le_rfl).sub ((g.norm_le_iff).mp le_rfl))
+
+/-- Addition after restricting both functions to their common phase domain. -/
+def addOnInter {H : Set (ComplexSpace n)} {τ : ℝ≥0}
+    (f : AnalyticPhaseFunction n G ρ) (g : AnalyticPhaseFunction n H τ) :
+    AnalyticPhaseFunction n (G ∩ H) (min ρ τ) :=
+  let hI : ConjInvariant (G ∩ H) := fun p hp =>
+    ⟨f.domain_conj p hp.1, g.domain_conj p hp.2⟩
+  (f.restrict Set.inter_subset_left (min_le_left _ _) hI).add
+    (g.restrict Set.inter_subset_right (min_le_right _ _) hI)
+
+/-- Subtraction after restricting both functions to their common phase domain. -/
+def subOnInter {H : Set (ComplexSpace n)} {τ : ℝ≥0}
+    (f : AnalyticPhaseFunction n G ρ) (g : AnalyticPhaseFunction n H τ) :
+    AnalyticPhaseFunction n (G ∩ H) (min ρ τ) :=
+  let hI : ConjInvariant (G ∩ H) := fun p hp =>
+    ⟨f.domain_conj p hp.1, g.domain_conj p hp.2⟩
+  (f.restrict Set.inter_subset_left (min_le_left _ _) hI).sub
+    (g.restrict Set.inter_subset_right (min_le_right _ _) hI)
+
+@[simp] theorem addOnInter_toFun {H : Set (ComplexSpace n)} {τ : ℝ≥0}
+    (f : AnalyticPhaseFunction n G ρ) (g : AnalyticPhaseFunction n H τ)
+    (z : ComplexPhaseSpace n) : (f.addOnInter g).toFun z = f.toFun z + g.toFun z := rfl
+
+@[simp] theorem subOnInter_toFun {H : Set (ComplexSpace n)} {τ : ℝ≥0}
+    (f : AnalyticPhaseFunction n G ρ) (g : AnalyticPhaseFunction n H τ)
+    (z : ComplexPhaseSpace n) : (f.subOnInter g).toFun z = f.toFun z - g.toFun z := rfl
+
+theorem uniformNorm_addOnInter_le {H : Set (ComplexSpace n)} {τ : ℝ≥0}
+    (f : AnalyticPhaseFunction n G ρ) (g : AnalyticPhaseFunction n H τ) :
+    (f.addOnInter g).uniformNorm ≤ f.uniformNorm + g.uniformNorm :=
+  (uniformNorm_add_le _ _).trans
+    (add_le_add (f.uniformNorm_restrict_le _ _ _) (g.uniformNorm_restrict_le _ _ _))
+
+theorem uniformNorm_subOnInter_le {H : Set (ComplexSpace n)} {τ : ℝ≥0}
+    (f : AnalyticPhaseFunction n G ρ) (g : AnalyticPhaseFunction n H τ) :
+    (f.subOnInter g).uniformNorm ≤ f.uniformNorm + g.uniformNorm :=
+  (uniformNorm_sub_le _ _).trans
+    (add_le_add (f.uniformNorm_restrict_le _ _ _) (g.uniformNorm_restrict_le _ _ _))
+
+end AnalyticPhaseFunction
+end KamProject.Arnold1963
diff --git a/LeanPool/ArnoldKAM/Arnold1963/Basic/Functions.lean b/LeanPool/ArnoldKAM/Arnold1963/Basic/Functions.lean
new file mode 100644
index 0000000000..85cf1a3cf1
--- /dev/null
+++ b/LeanPool/ArnoldKAM/Arnold1963/Basic/Functions.lean
@@ -0,0 +1,174 @@
+/-
+Copyright (c) 2026 Bingqi Yu. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Bingqi Yu
+-/
+
+module
+
+public import LeanPool.ArnoldKAM.Arnold1963.Basic.Periodic
+public import Mathlib.Analysis.Analytic.Basic
+public import Mathlib.Analysis.Analytic.Constructions
+public import Mathlib.Analysis.Analytic.ChangeOrigin
+public import Mathlib.Topology.ContinuousMap.Bounded.Normed
+
+/-!
+Analytic phase functions, conjugation compatibility, and the uniform norm. AnalyticOnNhd requires
+a convergent power series in an ambient neighborhood at each domain point. Bounded continuous
+restrictions supply the actual supremum norm, including on empty domains.
+-/
+
+@[expose] public section
+
+noncomputable section
+
+open scoped NNReal
+
+namespace KamProject.Arnold1963
+
+section UniformNorm
+
+variable {E F : Type*} [NormedAddCommGroup F]
+
+/-- A nonnegative uniform norm bound on the specified set. -/
+def NormBoundOn (f : E → F) (S : Set E) (M : ℝ) : Prop :=
+  0 ≤ M ∧ ∀ x ∈ S, ‖f x‖ ≤ M
+
+theorem NormBoundOn.nonneg {f : E → F} {S : Set E} {M : ℝ}
+    (h : NormBoundOn f S M) : 0 ≤ M := h.1
+
+theorem NormBoundOn.norm_le {f : E → F} {S : Set E} {M : ℝ}
+    (h : NormBoundOn f S M) {x : E} (hx : x ∈ S) : ‖f x‖ ≤ M := h.2 x hx
+
+@[simp] theorem normBoundOn_empty (f : E → F) (M : ℝ) :
+    NormBoundOn f ∅ M ↔ 0 ≤ M := by simp [NormBoundOn]
+
+variable [TopologicalSpace E]
+
+/-- Bounded continuous functions on a domain, with the domain's subspace topology. -/
+abbrev BoundedOnDomain (S : Set E) := BoundedContinuousFunction ↥S F
+
+/-- The supremum norm inherited from bounded continuous functions on the domain. -/
+def supNorm {S : Set E} (f : BoundedOnDomain (F := F) S) : ℝ := ‖f‖
+
+/-- Packaging a continuous function restricted to a set together with its uniform bound. -/
+def boundedRestriction (f : E → F) (S : Set E) (hf : ContinuousOn f S)
+    (M : ℝ) (hM : NormBoundOn f S M) : BoundedOnDomain (F := F) S :=
+  BoundedContinuousFunction.ofNormedAddCommGroup (fun x : S => f x)
+    hf.domRestrict M (fun x => hM.norm_le x.property)
+
+@[simp] theorem boundedRestriction_apply (f : E → F) (S : Set E)
+    (hf : ContinuousOn f S) (M : ℝ) (hM : NormBoundOn f S M) (x : S) :
+    boundedRestriction f S hf M hM x = f x := rfl
+
+theorem norm_apply_le_supNorm {S : Set E} (f : BoundedOnDomain (F := F) S) (x : S) :
+    ‖f x‖ ≤ supNorm f := f.norm_coe_le_norm x
+
+theorem supNorm_le_iff {S : Set E} (f : BoundedOnDomain (F := F) S)
+    {M : ℝ} (hM : 0 ≤ M) : supNorm f ≤ M ↔ ∀ x : S, ‖f x‖ ≤ M :=
+  BoundedContinuousFunction.norm_le hM
+
+theorem supNorm_lt_iff {S : Set E} (f : BoundedOnDomain (F := F) S) (M : ℝ) :
+    supNorm f < M ↔ ∃ C : ℝ, 0 ≤ C ∧ C < M ∧ ∀ x : S, ‖f x‖ ≤ C := by
+  constructor
+  · intro h
+    exact ⟨supNorm f, norm_nonneg f, h, fun x => norm_apply_le_supNorm f x⟩
+  · rintro ⟨C, hC, hCM, hf⟩
+    exact lt_of_le_of_lt ((supNorm_le_iff f hC).2 hf) hCM
+
+theorem supNorm_boundedRestriction_le (f : E → F) (S : Set E)
+    (hf : ContinuousOn f S) {M : ℝ} (hM : NormBoundOn f S M) :
+    supNorm (boundedRestriction f S hf M hM) ≤ M :=
+  (supNorm_le_iff _ hM.nonneg).2 fun x => hM.norm_le x.property
+
+end UniformNorm
+
+theorem analyticOnNhd_iff_forall_analyticAt {n : ℕ} (f : ComplexPhaseSpace n → ℂ)
+    (S : Set (ComplexPhaseSpace n)) :
+    AnalyticOnNhd ℂ f S ↔ ∀ x ∈ S, AnalyticAt ℂ f x := Iff.rfl
+
+theorem analyticOnNhd_iff_exists_open {n : ℕ} (f : ComplexPhaseSpace n → ℂ)
+    (S : Set (ComplexPhaseSpace n)) :
+    AnalyticOnNhd ℂ f S ↔
+      ∃ U : Set (ComplexPhaseSpace n), IsOpen U ∧ S ⊆ U ∧ AnalyticOnNhd ℂ f U := by
+  constructor
+  · intro h
+    exact ⟨{x | AnalyticAt ℂ f x}, isOpen_analyticAt ℂ f, h, fun _ hx => hx⟩
+  · rintro ⟨U, _, hSU, hU⟩
+    exact hU.mono hSU
+
+/-- Compatibility of a phase function with complex conjugation on the specified set. -/
+def ConjCompatibleOn {n : ℕ} (f : ComplexPhaseSpace n → ℂ)
+    (S : Set (ComplexPhaseSpace n)) : Prop :=
+  ∀ z ∈ S, f (conjPhase z) = star (f z)
+
+/-- A bounded analytic phase function with angle periodicity and real compatibility. -/
+structure AnalyticPhaseFunction (n : ℕ) (G : Set (ComplexSpace n)) (ρ : ℝ≥0) where
+  /-- The underlying complex-valued function on action-angle phase space. -/
+  toFun : ComplexPhaseSpace n → ℂ
+  domain_conj : ConjInvariant G
+  analytic : AnalyticOnNhd ℂ toFun (phaseDomain G ρ)
+  periodic : AnglePeriodicOn G ρ toFun
+  conj_compatible : ConjCompatibleOn toFun (phaseDomain G ρ)
+  bounded : ∃ M : ℝ, NormBoundOn toFun (phaseDomain G ρ) M
+
+/-- The bounded continuous restriction of an analytic phase function to its phase domain. -/
+def AnalyticPhaseFunction.toBounded {n : ℕ} {G : Set (ComplexSpace n)} {ρ : ℝ≥0}
+    (f : AnalyticPhaseFunction n G ρ) :
+    BoundedOnDomain (F := ℂ) (phaseDomain G ρ) :=
+  boundedRestriction f.toFun (phaseDomain G ρ) f.analytic.continuousOn
+    f.bounded.choose f.bounded.choose_spec
+
+/-- The uniform norm of the phase function on its prescribed action-angle domain. -/
+def AnalyticPhaseFunction.uniformNorm {n : ℕ} {G : Set (ComplexSpace n)} {ρ : ℝ≥0}
+    (f : AnalyticPhaseFunction n G ρ) : ℝ := supNorm f.toBounded
+
+theorem AnalyticPhaseFunction.norm_le_iff {n : ℕ} {G : Set (ComplexSpace n)}
+    {ρ : ℝ≥0} (f : AnalyticPhaseFunction n G ρ) {M : ℝ} :
+    f.uniformNorm ≤ M ↔ NormBoundOn f.toFun (phaseDomain G ρ) M := by
+  constructor
+  · intro h
+    refine ⟨(norm_nonneg f.toBounded).trans h, ?_⟩
+    intro x hx
+    exact (norm_apply_le_supNorm f.toBounded ⟨x, hx⟩).trans h
+  · intro h
+    exact (supNorm_le_iff _ h.nonneg).2 fun x => h.norm_le x.property
+
+theorem AnalyticPhaseFunction.real_value {n : ℕ} {G : Set (ComplexSpace n)}
+    {ρ : ℝ≥0} (f : AnalyticPhaseFunction n G ρ) (p q : RealSpace n)
+    (hp : complexify p ∈ G) : (f.toFun (complexify p, complexify q)).im = 0 := by
+  have h := f.conj_compatible (complexify p, complexify q)
+    (show (complexify p, complexify q) ∈ phaseDomain G ρ from
+      ⟨hp, complexify_mem_angleStrip q ρ⟩)
+  apply Complex.conj_eq_iff_im.mp
+  simpa [conjPhase] using h.symm
+
+/-- A real constant packaged as an analytic phase function on a conjugation-invariant domain. -/
+def AnalyticPhaseFunction.constReal {n : ℕ} (G : Set (ComplexSpace n)) (ρ : ℝ≥0)
+    (hG : ConjInvariant G) (c : ℝ) : AnalyticPhaseFunction n G ρ where
+  toFun := fun _ => (c : ℂ)
+  domain_conj := hG
+  analytic := analyticOnNhd_const
+  periodic := by intro p hp q hq k; rfl
+  conj_compatible := by intro z hz; simp
+  bounded := ⟨‖(c : ℂ)‖, norm_nonneg _, fun _ _ => le_rfl⟩
+
+theorem AnalyticPhaseFunction.uniformNorm_constReal {n : ℕ}
+    (G : Set (ComplexSpace n)) (ρ : ℝ≥0) (hG : ConjInvariant G)
+    (hne : G.Nonempty) (c : ℝ) :
+    (AnalyticPhaseFunction.constReal G ρ hG c).uniformNorm = |c| := by
+  apply le_antisymm
+  · apply (AnalyticPhaseFunction.norm_le_iff _).2
+    refine ⟨abs_nonneg c, ?_⟩
+    intro x hx
+    simp [AnalyticPhaseFunction.constReal, Complex.norm_real, Real.norm_eq_abs]
+  · obtain ⟨p, hp⟩ := hne
+    let x : phaseDomain G ρ := ⟨(p, complexify (0 : RealSpace n)),
+      hp, complexify_mem_angleStrip 0 ρ⟩
+    have h := norm_apply_le_supNorm
+      (AnalyticPhaseFunction.constReal G ρ hG c).toBounded x
+    simpa [AnalyticPhaseFunction.toBounded, boundedRestriction,
+      AnalyticPhaseFunction.constReal, AnalyticPhaseFunction.uniformNorm,
+      Complex.norm_real, Real.norm_eq_abs] using h
+
+end KamProject.Arnold1963
diff --git a/LeanPool/ArnoldKAM/Arnold1963/Basic/Hamiltonian.lean b/LeanPool/ArnoldKAM/Arnold1963/Basic/Hamiltonian.lean
new file mode 100644
index 0000000000..f4cf5e7a6d
--- /dev/null
+++ b/LeanPool/ArnoldKAM/Arnold1963/Basic/Hamiltonian.lean
@@ -0,0 +1,185 @@
+/-
+Copyright (c) 2026 Bingqi Yu. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Bingqi Yu
+-/
+
+module
+
+public import LeanPool.ArnoldKAM.Arnold1963.Basic.Functions
+public import LeanPool.ArnoldKAM.Arnold1963.Basic.SymplecticMatrix
+public import Mathlib.Analysis.Calculus.FDeriv.Analytic
+public import Mathlib.Analysis.Calculus.FDeriv.Comp
+public import Mathlib.Analysis.Calculus.FDeriv.Add
+public import Mathlib.Analysis.Calculus.FDeriv.Prod
+
+/-!
+Hamiltonian vector fields and canonical pullback, using complex Frechet derivatives and
+X_H = (-H_q, H_p). Derivative identities require differentiability or derive it from analyticity.
+Canonical maps preserve the specified symplectic form.
+-/
+
+@[expose] public section
+
+noncomputable section
+
+open scoped NNReal
+
+namespace KamProject.Arnold1963
+
+/-- The action-coordinate derivatives of a complex Hamiltonian. -/
+def pGradient {n : ℕ} (H : ComplexPhaseSpace n → ℂ) (x : ComplexPhaseSpace n) :
+    ComplexSpace n := fun j => fderiv ℂ H x (pDirection j)
+
+/-- The angle-coordinate derivatives of a complex Hamiltonian. -/
+def qGradient {n : ℕ} (H : ComplexPhaseSpace n → ℂ) (x : ComplexPhaseSpace n) :
+    ComplexSpace n := fun j => fderiv ℂ H x (qDirection j)
+
+theorem pGradient_eq_of_hasFDerivAt {n : ℕ} {H : ComplexPhaseSpace n → ℂ}
+    {x : ComplexPhaseSpace n} {L : ComplexPhaseSpace n →L[ℂ] ℂ}
+    (hH : HasFDerivAt H L x) : pGradient H x = fun j => L (pDirection j) := by
+  unfold pGradient
+  rw [hH.fderiv]
+
+theorem qGradient_eq_of_hasFDerivAt {n : ℕ} {H : ComplexPhaseSpace n → ℂ}
+    {x : ComplexPhaseSpace n} {L : ComplexPhaseSpace n →L[ℂ] ℂ}
+    (hH : HasFDerivAt H L x) : qGradient H x = fun j => L (qDirection j) := by
+  unfold qGradient
+  rw [hH.fderiv]
+
+theorem pGradient_eq_zero_of_not_differentiableAt {n : ℕ}
+    {H : ComplexPhaseSpace n → ℂ} {x : ComplexPhaseSpace n}
+    (hH : ¬ DifferentiableAt ℂ H x) : pGradient H x = 0 := by
+  ext j
+  simp [pGradient, fderiv_zero_of_not_differentiableAt hH]
+
+theorem qGradient_eq_zero_of_not_differentiableAt {n : ℕ}
+    {H : ComplexPhaseSpace n → ℂ} {x : ComplexPhaseSpace n}
+    (hH : ¬ DifferentiableAt ℂ H x) : qGradient H x = 0 := by
+  ext j
+  simp [qGradient, fderiv_zero_of_not_differentiableAt hH]
+
+/-- Hamilton's vector field with action component `-∂q H` and angle component `∂p H`. -/
+def hamiltonianVectorField {n : ℕ} (H : ComplexPhaseSpace n → ℂ)
+    (x : ComplexPhaseSpace n) : ComplexPhaseSpace n :=
+  (-qGradient H x, pGradient H x)
+
+theorem hamiltonianVectorField_mathlibJ {n : ℕ} (H : ComplexPhaseSpace n → ℂ)
+    (x : ComplexPhaseSpace n) :
+    phaseCoordinate (hamiltonianVectorField H x) =
+      (Matrix.J (Fin n) ℂ).mulVec (phaseCoordinate (pGradient H x, qGradient H x)) := by
+  ext i
+  cases i <;> simp [phaseCoordinate, hamiltonianVectorField, Matrix.J,
+    Matrix.mulVec, dotProduct, Matrix.one_apply]
+
+theorem hamiltonianVectorField_eq_sharp {n : ℕ} (H : ComplexPhaseSpace n → ℂ)
+    (x : ComplexPhaseSpace n) :
+    hamiltonianVectorField H x = symplecticSharp (fderiv ℂ H x).toLinearMap := rfl
+
+theorem norm_hamiltonianVectorField_le {n : ℕ} (H : ComplexPhaseSpace n → ℂ)
+    (x : ComplexPhaseSpace n) : ‖hamiltonianVectorField H x‖ ≤ ‖fderiv ℂ H x‖ := by
+  rw [hamiltonianVectorField, phase_norm_eq, norm_neg, max_le_iff]
+  constructor
+  · apply (complex_norm_le_iff _ (norm_nonneg _)).2
+    intro j
+    change ‖fderiv ℂ H x (qDirection j)‖ ≤ ‖fderiv ℂ H x‖
+    exact (fderiv ℂ H x).unit_le_opNorm (qDirection j) (by simp)
+  · apply (complex_norm_le_iff _ (norm_nonneg _)).2
+    intro j
+    change ‖fderiv ℂ H x (pDirection j)‖ ≤ ‖fderiv ℂ H x‖
+    exact (fderiv ℂ H x).unit_le_opNorm (pDirection j) (by simp)
+
+theorem hamiltonianVectorField_actionOnly {n : ℕ} {h : ComplexSpace n → ℂ}
+    (x : ComplexPhaseSpace n) (hh : DifferentiableAt ℂ h x.1) :
+    hamiltonianVectorField (h ∘ Prod.fst) x =
+      (0, fun j => fderiv ℂ h x.1 (Pi.single j 1)) := by
+  have hd := hh.hasFDerivAt.comp x (hasFDerivAt_fst (𝕜 := ℂ) (p := x))
+  ext j <;> simp [hamiltonianVectorField, pGradient, qGradient, hd.fderiv,
+    pDirection, qDirection]
+
+theorem hamiltonianVectorField_add {n : ℕ} {H K : ComplexPhaseSpace n → ℂ}
+    {x : ComplexPhaseSpace n} (hH : DifferentiableAt ℂ H x)
+    (hK : DifferentiableAt ℂ K x) :
+    hamiltonianVectorField (H + K) x =
+      hamiltonianVectorField H x + hamiltonianVectorField K x := by
+  ext j <;> simp [hamiltonianVectorField, pGradient, qGradient,
+    (hH.hasFDerivAt.add hK.hasFDerivAt).fderiv, add_comm]
+
+theorem HasFDerivAt.symplectic_identity {n : ℕ} {H : ComplexPhaseSpace n → ℂ}
+    {x : ComplexPhaseSpace n} {L : ComplexPhaseSpace n →L[ℂ] ℂ}
+    (hH : HasFDerivAt H L x) (v : ComplexPhaseSpace n) :
+    symplecticForm v (hamiltonianVectorField H x) = L v := by
+  rw [hamiltonianVectorField_eq_sharp, hH.fderiv]
+  exact symplecticForm_sharp L.toLinearMap v
+
+theorem AnalyticPhaseFunction.hasFDerivAt {n : ℕ} {G : Set (ComplexSpace n)}
+    {ρ : ℝ≥0} (H : AnalyticPhaseFunction n G ρ) {x : ComplexPhaseSpace n}
+    (hx : x ∈ phaseDomain G ρ) : HasFDerivAt H.toFun (fderiv ℂ H.toFun x) x :=
+  (H.analytic x hx).differentiableAt.hasFDerivAt
+
+theorem AnalyticPhaseFunction.symplectic_identity {n : ℕ} {G : Set (ComplexSpace n)}
+    {ρ : ℝ≥0} (H : AnalyticPhaseFunction n G ρ) {x : ComplexPhaseSpace n}
+    (hx : x ∈ phaseDomain G ρ) (v : ComplexPhaseSpace n) :
+    symplecticForm v (hamiltonianVectorField H.toFun x) = fderiv ℂ H.toFun x v :=
+  HasFDerivAt.symplectic_identity (H.hasFDerivAt hx) v
+
+/-- Differentiability and symplecticity of a transformation's derivative at one point. -/
+def CanonicalAt {n : ℕ} (B : ComplexPhaseSpace n → ComplexPhaseSpace n)
+    (x : ComplexPhaseSpace n) : Prop :=
+  DifferentiableAt ℂ B x ∧ IsSymplecticLinear (fderiv ℂ B x).toLinearMap
+
+/-- Pointwise canonicality of a phase transformation throughout a set. -/
+def CanonicalOn {n : ℕ} (B : ComplexPhaseSpace n → ComplexPhaseSpace n)
+    (S : Set (ComplexPhaseSpace n)) : Prop := ∀ x ∈ S, CanonicalAt B x
+
+theorem canonicalAt_id {n : ℕ} (x : ComplexPhaseSpace n) : CanonicalAt id x := by
+  refine ⟨differentiableAt_id, ?_⟩
+  intro v w
+  simp [fderiv_id]
+
+theorem CanonicalAt.derivative_bijective {n : ℕ}
+    {B : ComplexPhaseSpace n → ComplexPhaseSpace n} {x : ComplexPhaseSpace n}
+    (hB : CanonicalAt B x) : Function.Bijective (fderiv ℂ B x) :=
+  ⟨hB.2.injective, hB.2.surjective⟩
+
+theorem CanonicalAt.matrix_identity {n : ℕ}
+    {B : ComplexPhaseSpace n → ComplexPhaseSpace n} {x : ComplexPhaseSpace n}
+    (hB : CanonicalAt B x) :
+    (phaseLinearMatrix (fderiv ℂ B x).toLinearMap).transpose * symplecticMatrix n *
+        phaseLinearMatrix (fderiv ℂ B x).toLinearMap = symplecticMatrix n :=
+  hB.2.matrix_identity
+
+theorem CanonicalAt.comp {n : ℕ}
+    {B C : ComplexPhaseSpace n → ComplexPhaseSpace n} {x : ComplexPhaseSpace n}
+    (hB : CanonicalAt B (C x)) (hC : CanonicalAt C x) : CanonicalAt (B ∘ C) x := by
+  refine ⟨hB.1.comp x hC.1, ?_⟩
+  rw [fderiv_comp x hB.1 hC.1]
+  exact hB.2.comp hC.2
+
+theorem CanonicalOn.comp {n : ℕ}
+    {B C : ComplexPhaseSpace n → ComplexPhaseSpace n}
+    {S T : Set (ComplexPhaseSpace n)} (hB : CanonicalOn B T)
+    (hC : CanonicalOn C S) (hmap : Set.MapsTo C S T) : CanonicalOn (B ∘ C) S := by
+  intro x hx
+  exact (hB (C x) (hmap hx)).comp (hC x hx)
+
+theorem CanonicalAt.map_hamiltonianVectorField {n : ℕ}
+    {B : ComplexPhaseSpace n → ComplexPhaseSpace n} {x : ComplexPhaseSpace n}
+    (hB : CanonicalAt B x) {H : ComplexPhaseSpace n → ℂ}
+    (hH : DifferentiableAt ℂ H (B x)) :
+    fderiv ℂ B x (hamiltonianVectorField (H ∘ B) x) =
+      hamiltonianVectorField H (B x) := by
+  rw [hamiltonianVectorField_eq_sharp, hamiltonianVectorField_eq_sharp,
+    fderiv_comp x hH hB.1]
+  exact hB.2.map_sharp_comp (fderiv ℂ H (B x)).toLinearMap
+
+theorem AnalyticPhaseFunction.canonical_pullback {n : ℕ} {G : Set (ComplexSpace n)}
+    {ρ : ℝ≥0} (H : AnalyticPhaseFunction n G ρ)
+    {B : ComplexPhaseSpace n → ComplexPhaseSpace n} {S : Set (ComplexPhaseSpace n)}
+    (hB : CanonicalOn B S) (hmap : Set.MapsTo B S (phaseDomain G ρ))
+    {x : ComplexPhaseSpace n} (hx : x ∈ S) :
+    fderiv ℂ B x (hamiltonianVectorField (H.toFun ∘ B) x) =
+      hamiltonianVectorField H.toFun (B x) :=
+  (hB x hx).map_hamiltonianVectorField (H.analytic (B x) (hmap hx)).differentiableAt
+
+end KamProject.Arnold1963
diff --git a/LeanPool/ArnoldKAM/Arnold1963/Basic/Measure.lean b/LeanPool/ArnoldKAM/Arnold1963/Basic/Measure.lean
new file mode 100644
index 0000000000..9edeb51d8b
--- /dev/null
+++ b/LeanPool/ArnoldKAM/Arnold1963/Basic/Measure.lean
@@ -0,0 +1,75 @@
+/-
+Copyright (c) 2026 Bingqi Yu. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Bingqi Yu
+-/
+
+module
+
+public import LeanPool.ArnoldKAM.Arnold1963.Basic.Domains
+public import Mathlib.MeasureTheory.Measure.Lebesgue.Basic
+public import Mathlib.MeasureTheory.Constructions.Pi
+public import Mathlib.MeasureTheory.Measure.Prod
+public import Mathlib.Analysis.SpecialFunctions.Trigonometric.Basic
+
+/-!
+Real-slice volume is the product Lebesgue measure on Fin n -> R. It is distinct from complex
+ambient volume. The physical angle cell has side length 2 * pi; Fourier averaging uses unit cells.
+Measures retain their extended nonnegative values until finiteness has been proved.
+-/
+
+@[expose] public section
+
+noncomputable section
+
+open scoped ENNReal
+
+namespace KamProject.Arnold1963
+
+/-- Product Lebesgue measure on real action coordinates. -/
+def realLebesgue (n : ℕ) : MeasureTheory.Measure (RealSpace n) :=
+  MeasureTheory.Measure.pi (fun _ : Fin n => (MeasureTheory.volume : MeasureTheory.Measure ℝ))
+
+instance realLebesgue_sigmaFinite (n : ℕ) : MeasureTheory.SigmaFinite (realLebesgue n) :=
+  inferInstanceAs (MeasureTheory.SigmaFinite
+    (MeasureTheory.Measure.pi (fun _ : Fin n => (MeasureTheory.volume : MeasureTheory.Measure ℝ))))
+
+/-- The Lebesgue measure of a complex action domain's real slice. -/
+def realVolume {n : ℕ} (G : Set (ComplexSpace n)) : ℝ≥0∞ :=
+  realLebesgue n (realSlice G)
+
+theorem measurableSet_realSlice_of_isCompact {n : ℕ} {G : Set (ComplexSpace n)}
+    (hG : IsCompact G) : MeasurableSet (realSlice G) :=
+  (isCompact_realSlice hG).isClosed.measurableSet
+
+theorem realVolume_mono {n : ℕ} {G H : Set (ComplexSpace n)} (hGH : G ⊆ H) :
+    realVolume G ≤ realVolume H :=
+  MeasureTheory.measure_mono (Set.preimage_mono hGH)
+
+/-- A half-open fundamental angle cell of the specified period. -/
+def realAngleCell (n : ℕ) (L : ℝ) : Set (RealSpace n) :=
+  Set.pi Set.univ (fun _ => Set.Ioc 0 L)
+
+/-- Product Lebesgue measure on real action and unwrapped angle coordinates. -/
+def realPhaseLebesgue (n : ℕ) : MeasureTheory.Measure (RealSpace n × RealSpace n) :=
+  (realLebesgue n).prod (realLebesgue n)
+
+theorem realLebesgue_angleCell (n : ℕ) (L : ℝ) :
+    realLebesgue n (realAngleCell n L) = ENNReal.ofReal L ^ n := by
+  simp [realLebesgue, realAngleCell, MeasureTheory.Measure.pi_pi, Real.volume_Ioc]
+
+theorem realPhaseLebesgue_cell {n : ℕ} (G : Set (ComplexSpace n)) (L : ℝ) :
+    realPhaseLebesgue n (realSlice G ×ˢ realAngleCell n L) =
+      realVolume G * ENNReal.ofReal L ^ n := by
+  rw [realPhaseLebesgue, MeasureTheory.Measure.prod_prod, realLebesgue_angleCell]
+  rfl
+
+theorem realPhaseLebesgue_physicalCell {n : ℕ} (G : Set (ComplexSpace n)) :
+    realPhaseLebesgue n (realSlice G ×ˢ realAngleCell n (2 * Real.pi)) =
+      realVolume G * ENNReal.ofReal (2 * Real.pi) ^ n := realPhaseLebesgue_cell G _
+
+theorem realPhaseLebesgue_unitCell {n : ℕ} (G : Set (ComplexSpace n)) :
+    realPhaseLebesgue n (realSlice G ×ˢ realAngleCell n 1) = realVolume G := by
+  simpa using realPhaseLebesgue_cell G 1
+
+end KamProject.Arnold1963
diff --git a/LeanPool/ArnoldKAM/Arnold1963/Basic/Periodic.lean b/LeanPool/ArnoldKAM/Arnold1963/Basic/Periodic.lean
new file mode 100644
index 0000000000..11ba1bbb06
--- /dev/null
+++ b/LeanPool/ArnoldKAM/Arnold1963/Basic/Periodic.lean
@@ -0,0 +1,50 @@
+/-
+Copyright (c) 2026 Bingqi Yu. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Bingqi Yu
+-/
+
+module
+
+public import LeanPool.ArnoldKAM.Arnold1963.Basic.Domains
+public import Mathlib.Analysis.SpecialFunctions.Trigonometric.Basic
+public import Mathlib.Topology.Instances.AddCircle.Defs
+
+/-!
+Periodicity on the complex cover and the real torus with period 2 * pi. Periodicity constrains
+values on the specified phase domain; arbitrary extensions outside that domain are immaterial.
+-/
+
+@[expose] public section
+
+noncomputable section
+
+open scoped NNReal
+
+namespace KamProject.Arnold1963
+
+/-- The real angle torus with period `2π` in each coordinate. -/
+abbrev RealTorus (n : ℕ) := Fin n → AddCircle (2 * Real.pi)
+/-- Real action coordinates paired with angles modulo `2π`. -/
+abbrev RealPhaseSpace (n : ℕ) := RealSpace n × RealTorus n
+
+/-- The angle displacement associated with an integer multiple of each period. -/
+def angleShift {n : ℕ} (k : FourierIndex n) : ComplexSpace n :=
+  complexify (fun j => 2 * Real.pi * (k j : ℝ))
+
+/-- Invariance of a phase function under integer angle-period shifts on its domain. -/
+def AnglePeriodicOn {n : ℕ} (G : Set (ComplexSpace n)) (ρ : ℝ≥0)
+    (f : ComplexPhaseSpace n → ℂ) : Prop :=
+  ∀ p ∈ G, ∀ q ∈ angleStrip n ρ, ∀ k : FourierIndex n,
+    f (p, q + angleShift k) = f (p, q)
+
+@[simp] theorem imagPart_add_angleShift {n : ℕ} (q : ComplexSpace n)
+    (k : FourierIndex n) : imagPart (q + angleShift k) = imagPart q := by
+  funext j
+  simp [imagPart, angleShift, complexify]
+
+theorem add_angleShift_mem_iff {n : ℕ} (q : ComplexSpace n) (k : FourierIndex n)
+    (ρ : ℝ≥0) : q + angleShift k ∈ angleStrip n ρ ↔ q ∈ angleStrip n ρ := by
+  simp [angleStrip]
+
+end KamProject.Arnold1963
diff --git a/LeanPool/ArnoldKAM/Arnold1963/Basic/Spaces.lean b/LeanPool/ArnoldKAM/Arnold1963/Basic/Spaces.lean
new file mode 100644
index 0000000000..7830785de3
--- /dev/null
+++ b/LeanPool/ArnoldKAM/Arnold1963/Basic/Spaces.lean
@@ -0,0 +1,125 @@
+/-
+Copyright (c) 2026 Bingqi Yu. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Bingqi Yu
+-/
+
+module
+
+public import Mathlib.Analysis.Complex.Basic
+public import Mathlib.Analysis.Normed.Group.Constructions
+public import Mathlib.Analysis.Normed.Module.Basic
+public import Mathlib.Topology.MetricSpace.Isometry
+
+/-!
+The real and complex coordinate spaces use the maximum norm. Phase coordinates are ordered
+(p, q). Fourier indices use the sum of absolute coordinates, separately from the ambient norm.
+-/
+
+@[expose] public section
+
+noncomputable section
+
+namespace KamProject.Arnold1963
+
+/-- Real coordinate space with the supremum norm. -/
+abbrev RealSpace (n : ℕ) := Fin n → ℝ
+/-- Complex coordinate space with the supremum norm. -/
+abbrev ComplexSpace (n : ℕ) := Fin n → ℂ
+/-- Integer Fourier indices for the angle coordinates. -/
+abbrev FourierIndex (n : ℕ) := Fin n → ℤ
+/-- Complex action coordinates paired with complex angle coordinates. -/
+abbrev ComplexPhaseSpace (n : ℕ) := ComplexSpace n × ComplexSpace n
+
+/-- Coordinatewise embedding of real vectors into complex coordinate space. -/
+def complexify {n : ℕ} (x : RealSpace n) : ComplexSpace n := fun j => (x j : ℂ)
+
+@[simp] theorem complexify_zero {n : ℕ} : complexify (0 : RealSpace n) = 0 := by
+  ext j
+  simp [complexify]
+
+theorem isometry_complexify (n : ℕ) : Isometry (complexify (n := n)) :=
+  Isometry.piMap (fun _ : Fin n => ((↑) : ℝ → ℂ)) (fun _ => Complex.isometry_ofReal)
+
+theorem continuous_complexify (n : ℕ) : Continuous (complexify (n := n)) :=
+  (isometry_complexify n).continuous
+
+/-- Coordinatewise complex conjugation of an action or angle vector. -/
+def conjVec {n : ℕ} (z : ComplexSpace n) : ComplexSpace n := fun j => star (z j)
+
+/-- Coordinatewise real part of a complex vector. -/
+def realPart {n : ℕ} (z : ComplexSpace n) : RealSpace n := fun j => (z j).re
+/-- Coordinatewise imaginary part of a complex vector. -/
+def imagPart {n : ℕ} (z : ComplexSpace n) : RealSpace n := fun j => (z j).im
+
+/-- Coordinatewise conjugation of both action and angle components. -/
+def conjPhase {n : ℕ} (z : ComplexPhaseSpace n) : ComplexPhaseSpace n :=
+  (conjVec z.1, conjVec z.2)
+
+@[simp] theorem conjPhase_eq_star {n : ℕ} (x : ComplexPhaseSpace n) : conjPhase x = star x := rfl
+@[simp] theorem conjVec_eq_star {n : ℕ} (x : ComplexSpace n) : conjVec x = star x := rfl
+
+@[simp] theorem star_complexify {n : ℕ} (x : RealSpace n) :
+    star (complexify x) = complexify x := by
+  ext j
+  simp [complexify]
+
+/-- The real-valued sum of absolute Fourier coordinates. -/
+def indexLength {n : ℕ} (k : FourierIndex n) : ℝ := ∑ j, |(k j : ℝ)|
+
+/-- The bilinear pairing of an integer Fourier index with a complex vector. -/
+def indexPairing {n : ℕ} (k : FourierIndex n) (z : ComplexSpace n) : ℂ :=
+  ∑ j, (k j : ℂ) * z j
+
+theorem complex_norm_le_iff {n : ℕ} (z : ComplexSpace n) {r : ℝ} (hr : 0 ≤ r) :
+    ‖z‖ ≤ r ↔ ∀ j, ‖z j‖ ≤ r :=
+  pi_norm_le_iff_of_nonneg hr
+
+theorem real_norm_le_iff {n : ℕ} (x : RealSpace n) {r : ℝ} (hr : 0 ≤ r) :
+    ‖x‖ ≤ r ↔ ∀ j, |x j| ≤ r := by
+  simpa only [Real.norm_eq_abs] using (pi_norm_le_iff_of_nonneg hr (x := x))
+
+@[simp] theorem norm_complexify {n : ℕ} (x : RealSpace n) : ‖complexify x‖ = ‖x‖ := by
+  simpa only [complexify_zero, dist_zero_right] using (isometry_complexify n).dist_eq x 0
+
+theorem complex_coordinate_norm_le {n : ℕ} (z : ComplexSpace n) (j : Fin n) :
+    ‖z j‖ ≤ ‖z‖ := norm_le_pi_norm z j
+
+theorem phase_norm_eq {n : ℕ} (z : ComplexPhaseSpace n) :
+    ‖z‖ = max ‖z.1‖ ‖z.2‖ := rfl
+
+@[simp] theorem realPart_complexify {n : ℕ} (x : RealSpace n) :
+    realPart (complexify x) = x := by
+  funext j
+  simp [realPart, complexify]
+
+@[simp] theorem imagPart_complexify {n : ℕ} (x : RealSpace n) :
+    imagPart (complexify x) = 0 := by
+  funext j
+  simp [imagPart, complexify]
+
+theorem conjVec_complexify {n : ℕ} (x : RealSpace n) :
+    conjVec (complexify x) = complexify x := by
+  funext j
+  simp [conjVec, complexify]
+
+theorem conjVec_conjVec {n : ℕ} (z : ComplexSpace n) :
+    conjVec (conjVec z) = z := by
+  funext j
+  simp [conjVec]
+
+theorem indexLength_nonneg {n : ℕ} (k : FourierIndex n) : 0 ≤ indexLength k :=
+  Finset.sum_nonneg fun _ _ => abs_nonneg _
+
+theorem norm_indexPairing_le {n : ℕ} (k : FourierIndex n) (z : ComplexSpace n) :
+    ‖indexPairing k z‖ ≤ indexLength k * ‖z‖ := by
+  calc
+    ‖indexPairing k z‖ ≤ ∑ j, ‖(k j : ℂ) * z j‖ := norm_sum_le _ _
+    _ = ∑ j, |(k j : ℝ)| * ‖z j‖ := by simp [Complex.norm_intCast]
+    _ ≤ ∑ j, |(k j : ℝ)| * ‖z‖ := by
+      apply Finset.sum_le_sum
+      intro j _
+      exact mul_le_mul_of_nonneg_left (complex_coordinate_norm_le z j) (abs_nonneg _)
+    _ = indexLength k * ‖z‖ := by rw [indexLength, Finset.sum_mul]
+
+end KamProject.Arnold1963
diff --git a/LeanPool/ArnoldKAM/Arnold1963/Basic/Symplectic.lean b/LeanPool/ArnoldKAM/Arnold1963/Basic/Symplectic.lean
new file mode 100644
index 0000000000..36ea482c30
--- /dev/null
+++ b/LeanPool/ArnoldKAM/Arnold1963/Basic/Symplectic.lean
@@ -0,0 +1,168 @@
+/-
+Copyright (c) 2026 Bingqi Yu. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Bingqi Yu
+-/
+
+module
+
+public import LeanPool.ArnoldKAM.Arnold1963.Basic.Spaces
+public import Mathlib.Algebra.BigOperators.Pi
+public import Mathlib.LinearAlgebra.FiniteDimensional.Basic
+public import Mathlib.LinearAlgebra.SymplecticGroup
+public import Mathlib.Tactic.Ring
+
+/-!
+The standard symplectic form in (p, q) coordinates, its nondegeneracy, and covector duality.
+Symplecticity means preservation of this concrete bilinear form; it implies linear invertibility.
+-/
+
+@[expose] public section
+
+noncomputable section
+
+namespace KamProject.Arnold1963
+
+/-- The action-coordinate basis direction in phase space. -/
+def pDirection {n : ℕ} (j : Fin n) : ComplexPhaseSpace n := (Pi.single j 1, 0)
+/-- The angle-coordinate basis direction in phase space. -/
+def qDirection {n : ℕ} (j : Fin n) : ComplexPhaseSpace n := (0, Pi.single j 1)
+
+@[simp] theorem norm_pDirection {n : ℕ} (j : Fin n) : ‖pDirection j‖ = 1 := by
+  simp [pDirection, Pi.norm_single]
+
+@[simp] theorem norm_qDirection {n : ℕ} (j : Fin n) : ‖qDirection j‖ = 1 := by
+  simp [qDirection, Pi.norm_single]
+
+/-- The standard complex symplectic form in action-angle coordinates. -/
+def symplecticForm {n : ℕ} (v w : ComplexPhaseSpace n) : ℂ :=
+  ∑ j, (v.1 j * w.2 j - v.2 j * w.1 j)
+
+theorem phase_decomposition {n : ℕ} (v : ComplexPhaseSpace n) :
+    v = (∑ j, v.1 j • pDirection j) + ∑ j, v.2 j • qDirection j := by
+  simp only [pDirection, qDirection, Prod.smul_mk, smul_zero, ← prod_mk_sum]
+  simp only [Finset.sum_const_zero, Prod.mk_add_mk, add_zero, zero_add]
+  exact Prod.ext (pi_eq_sum_univ' v.1) (pi_eq_sum_univ' v.2)
+
+@[simp] theorem symplecticForm_pDirection {n : ℕ} (j : Fin n)
+    (w : ComplexPhaseSpace n) : symplecticForm (pDirection j) w = w.2 j := by
+  simp [symplecticForm, pDirection, Pi.single_apply]
+
+@[simp] theorem symplecticForm_qDirection {n : ℕ} (j : Fin n)
+    (w : ComplexPhaseSpace n) : symplecticForm (qDirection j) w = -w.1 j := by
+  simp [symplecticForm, qDirection, Pi.single_apply]
+
+theorem symplecticForm_skew {n : ℕ} (v w : ComplexPhaseSpace n) :
+    symplecticForm v w = -symplecticForm w v := by
+  rw [symplecticForm, symplecticForm, ← Finset.sum_neg_distrib]
+  apply Finset.sum_congr rfl
+  intro j _
+  ring
+
+@[simp] theorem symplecticForm_self {n : ℕ} (v : ComplexPhaseSpace n) :
+    symplecticForm v v = 0 := by simp [symplecticForm, mul_comm]
+
+theorem symplecticForm_add_left {n : ℕ} (u v w : ComplexPhaseSpace n) :
+    symplecticForm (u + v) w = symplecticForm u w + symplecticForm v w := by
+  simp only [symplecticForm, Prod.fst_add, Prod.snd_add, Pi.add_apply, add_mul]
+  rw [← Finset.sum_add_distrib]
+  apply Finset.sum_congr rfl
+  intro j _
+  ring
+
+theorem symplecticForm_smul_left {n : ℕ} (c : ℂ) (v w : ComplexPhaseSpace n) :
+    symplecticForm (c • v) w = c * symplecticForm v w := by
+  simp only [symplecticForm, Prod.smul_fst, Prod.smul_snd, Pi.smul_apply, smul_eq_mul]
+  rw [Finset.mul_sum]
+  apply Finset.sum_congr rfl
+  intro j _
+  ring
+
+theorem symplecticForm_ext_right {n : ℕ} {u w : ComplexPhaseSpace n}
+    (h : ∀ v, symplecticForm v u = symplecticForm v w) : u = w := by
+  apply Prod.ext
+  · funext j
+    have hj := h (qDirection j)
+    simpa using hj
+  · funext j
+    simpa using h (pDirection j)
+
+/-- The phase vector associated with a linear functional by the symplectic form. -/
+def symplecticSharp {n : ℕ} (L : ComplexPhaseSpace n →ₗ[ℂ] ℂ) :
+    ComplexPhaseSpace n := (fun j => -L (qDirection j), fun j => L (pDirection j))
+
+theorem linearForm_decomposition {n : ℕ} (L : ComplexPhaseSpace n →ₗ[ℂ] ℂ)
+    (v : ComplexPhaseSpace n) :
+    L v = (∑ j, v.1 j * L (pDirection j)) + ∑ j, v.2 j * L (qDirection j) := by
+  conv_lhs => rw [phase_decomposition v]
+  simp
+
+theorem symplecticForm_sharp {n : ℕ} (L : ComplexPhaseSpace n →ₗ[ℂ] ℂ)
+    (v : ComplexPhaseSpace n) : symplecticForm v (symplecticSharp L) = L v := by
+  rw [linearForm_decomposition L v]
+  simp [symplecticForm, symplecticSharp, Finset.sum_add_distrib]
+
+/-- Preservation of the standard symplectic form by a linear phase transformation. -/
+def IsSymplecticLinear {n : ℕ} (A : ComplexPhaseSpace n →ₗ[ℂ] ComplexPhaseSpace n) :
+    Prop := ∀ v w, symplecticForm (A v) (A w) = symplecticForm v w
+
+theorem IsSymplecticLinear.injective {n : ℕ}
+    {A : ComplexPhaseSpace n →ₗ[ℂ] ComplexPhaseSpace n} (hA : IsSymplecticLinear A) :
+    Function.Injective A := by
+  intro x y hxy
+  apply symplecticForm_ext_right
+  intro v
+  rw [← hA v x, ← hA v y, hxy]
+
+theorem IsSymplecticLinear.surjective {n : ℕ}
+    {A : ComplexPhaseSpace n →ₗ[ℂ] ComplexPhaseSpace n} (hA : IsSymplecticLinear A) :
+    Function.Surjective A := LinearMap.surjective_of_injective hA.injective
+
+theorem IsSymplecticLinear.comp {n : ℕ}
+    {A B : ComplexPhaseSpace n →ₗ[ℂ] ComplexPhaseSpace n}
+    (hA : IsSymplecticLinear A) (hB : IsSymplecticLinear B) :
+    IsSymplecticLinear (A.comp B) := by
+  intro v w
+  exact (hA (B v) (B w)).trans (hB v w)
+
+theorem IsSymplecticLinear.map_sharp_comp {n : ℕ}
+    {A : ComplexPhaseSpace n →ₗ[ℂ] ComplexPhaseSpace n} (hA : IsSymplecticLinear A)
+    (L : ComplexPhaseSpace n →ₗ[ℂ] ℂ) :
+    A (symplecticSharp (L.comp A)) = symplecticSharp L := by
+  apply symplecticForm_ext_right
+  intro v
+  obtain ⟨w, rfl⟩ := hA.surjective v
+  rw [hA, symplecticForm_sharp, symplecticForm_sharp]
+  rfl
+
+/-- A unified action-angle basis indexed by the disjoint union of coordinate indices. -/
+def phaseDirection {n : ℕ} : Fin n ⊕ Fin n → ComplexPhaseSpace n
+  | .inl j => pDirection j
+  | .inr j => qDirection j
+
+/-- The matrix of the chosen symplectic sign convention in the unified phase basis. -/
+def symplecticMatrix (n : ℕ) : Matrix (Fin n ⊕ Fin n) (Fin n ⊕ Fin n) ℂ :=
+  -Matrix.J (Fin n) ℂ
+
+@[simp] theorem symplecticMatrix_pp {n : ℕ} (i j : Fin n) :
+    symplecticMatrix n (.inl i) (.inl j) = 0 := by
+  simp [symplecticMatrix, Matrix.J]
+
+@[simp] theorem symplecticMatrix_pq {n : ℕ} (i j : Fin n) :
+    symplecticMatrix n (.inl i) (.inr j) = if i = j then 1 else 0 := by
+  simp [symplecticMatrix, Matrix.J, Matrix.one_apply]
+
+@[simp] theorem symplecticMatrix_qp {n : ℕ} (i j : Fin n) :
+    symplecticMatrix n (.inr i) (.inl j) = -(if i = j then 1 else 0) := by
+  simp [symplecticMatrix, Matrix.J, Matrix.one_apply]
+
+@[simp] theorem symplecticMatrix_qq {n : ℕ} (i j : Fin n) :
+    symplecticMatrix n (.inr i) (.inr j) = 0 := by
+  simp [symplecticMatrix, Matrix.J]
+
+theorem symplecticMatrix_apply {n : ℕ} (i j : Fin n ⊕ Fin n) :
+    symplecticMatrix n i j = symplecticForm (phaseDirection i) (phaseDirection j) := by
+  rcases i with i | i <;> rcases j with j | j <;>
+    simp [phaseDirection, pDirection, qDirection, symplecticForm, Pi.single_apply, eq_comm]
+
+end KamProject.Arnold1963
diff --git a/LeanPool/ArnoldKAM/Arnold1963/Basic/SymplecticMatrix.lean b/LeanPool/ArnoldKAM/Arnold1963/Basic/SymplecticMatrix.lean
new file mode 100644
index 0000000000..de5beae10c
--- /dev/null
+++ b/LeanPool/ArnoldKAM/Arnold1963/Basic/SymplecticMatrix.lean
@@ -0,0 +1,57 @@
+/-
+Copyright (c) 2026 Bingqi Yu. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Bingqi Yu
+-/
+
+module
+
+public import LeanPool.ArnoldKAM.Arnold1963.Basic.Symplectic
+public import Mathlib.Data.Matrix.Mul
+
+/-!
+Coordinate matrices for the symplectic form. The matrix identity uses ordinary transpose,
+rather than conjugate transpose, and the same (p, q) coordinate order.
+-/
+
+@[expose] public section
+
+noncomputable section
+
+namespace KamProject.Arnold1963
+
+theorem symplecticMatrix_eq_neg_mathlibJ (n : ℕ) :
+    symplecticMatrix n = -Matrix.J (Fin n) ℂ := rfl
+
+theorem symplectic_matrix_identity_iff_mathlib {n : ℕ}
+    (M : Matrix (Fin n ⊕ Fin n) (Fin n ⊕ Fin n) ℂ) :
+    M.transpose * symplecticMatrix n * M = symplecticMatrix n ↔
+      M.transpose * Matrix.J (Fin n) ℂ * M = Matrix.J (Fin n) ℂ := by
+  simp only [symplecticMatrix, Matrix.mul_neg, Matrix.neg_mul, neg_inj]
+
+/-- The unified coordinate function of a phase vector. -/
+def phaseCoordinate {n : ℕ} (v : ComplexPhaseSpace n) : Fin n ⊕ Fin n → ℂ :=
+  Sum.elim v.1 v.2
+
+/-- The matrix of a linear phase transformation in the unified coordinate basis. -/
+def phaseLinearMatrix {n : ℕ} (A : ComplexPhaseSpace n →ₗ[ℂ] ComplexPhaseSpace n) :
+    Matrix (Fin n ⊕ Fin n) (Fin n ⊕ Fin n) ℂ :=
+  fun i j => phaseCoordinate (A (phaseDirection j)) i
+
+theorem phaseLinearMatrix_symplectic_apply {n : ℕ}
+    (A : ComplexPhaseSpace n →ₗ[ℂ] ComplexPhaseSpace n) (i j : Fin n ⊕ Fin n) :
+    ((phaseLinearMatrix A).transpose * symplecticMatrix n * phaseLinearMatrix A) i j =
+      symplecticForm (A (phaseDirection i)) (A (phaseDirection j)) := by
+  simp [Matrix.mul_apply, Matrix.transpose_apply,
+    phaseLinearMatrix, phaseCoordinate, Finset.sum_add_distrib, symplecticForm,
+    neg_mul, sub_eq_add_neg, add_comm]
+
+theorem IsSymplecticLinear.matrix_identity {n : ℕ}
+    {A : ComplexPhaseSpace n →ₗ[ℂ] ComplexPhaseSpace n} (hA : IsSymplecticLinear A) :
+    (phaseLinearMatrix A).transpose * symplecticMatrix n * phaseLinearMatrix A =
+      symplecticMatrix n := by
+  ext i j
+  rw [phaseLinearMatrix_symplectic_apply, hA]
+  exact (symplecticMatrix_apply i j).symm
+
+end KamProject.Arnold1963
diff --git a/LeanPool/ArnoldKAM/Arnold1963/Convergence/Budgets.lean b/LeanPool/ArnoldKAM/Arnold1963/Convergence/Budgets.lean
new file mode 100644
index 0000000000..cb31899392
--- /dev/null
+++ b/LeanPool/ArnoldKAM/Arnold1963/Convergence/Budgets.lean
@@ -0,0 +1,95 @@
+/-
+Copyright (c) 2026 Bingqi Yu. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Bingqi Yu
+-/
+
+module
+
+public import LeanPool.ArnoldKAM.Arnold1963.Iteration.InitialParameters
+
+/-!
+Summable weighted transformation increments and separate unweighted frequency tails.
+-/
+
+@[expose] public section
+noncomputable section
+open Filter
+open scoped NNReal Topology
+namespace KamProject.Arnold1963.Iteration.InitialParameters
+variable {n : ℕ} {δ₁ θ₀ Θ₀ ρ₀ : ℝ≥0} {κ D : ℝ}
+  (b : InitialParameters n δ₁ θ₀ Θ₀ ρ₀ κ D)
+include b
+
+theorem beta_eighth (s : ℕ) : (beta δ₁ (s + 1) : ℝ) ≤ (beta δ₁ s : ℝ) / 8 := by
+  have hh := pow_le_pow_left₀ (delta δ₁ (s + 1)).coe_nonneg (decay_half b.delta_quarter.le s) 3
+  change (delta δ₁ (s + 1) : ℝ) ^ 3 ≤ (delta δ₁ s : ℝ) ^ 3 / 8
+  change (delta δ₁ (s + 1) : ℝ) ^ 3 ≤ ((delta δ₁ s : ℝ) / 2) ^ 3 at hh
+  nlinarith
+
+theorem beta_geometric (s j : ℕ) :
+    (beta δ₁ (j + s) : ℝ) ≤ (beta δ₁ s : ℝ) * (1 / 8 : ℝ) ^ j := by
+  induction j with
+  | zero => simp
+  | succ j ih =>
+    have hh := b.beta_eighth (j + s)
+    rw [show j + 1 + s = (j + s) + 1 by omega, pow_succ]
+    nlinarith
+
+theorem beta_summable : Summable (fun s => (beta δ₁ s : ℝ)) :=
+  Summable.of_nonneg_of_le (fun s => (beta δ₁ s).coe_nonneg)
+    (by simpa using b.beta_geometric 0)
+    ((summable_geometric_of_lt_one (by norm_num : (0 : ℝ) ≤ 1 / 8)
+      (by norm_num)).mul_left (beta δ₁ 0 : ℝ))
+
+theorem beta_tail_le (s : ℕ) : (∑' j, (beta δ₁ (j + s) : ℝ)) ≤ 8 / 7 * (beta δ₁ s : ℝ) := by
+  calc
+    _ ≤ ∑' j, (beta δ₁ s : ℝ) * (1 / 8 : ℝ) ^ j :=
+      ((summable_nat_add_iff s).mpr b.beta_summable).tsum_le_tsum (b.beta_geometric s)
+        ((summable_geometric_of_lt_one (by norm_num : (0 : ℝ) ≤ 1 / 8)
+          (by norm_num)).mul_left _)
+    _ = _ := by rw [tsum_mul_left, tsum_geometric_of_lt_one (by norm_num) (by norm_num)]; ring
+
+theorem weighted_beta_bound (s : ℕ) :
+    (2 : ℝ) ^ s * beta δ₁ s ≤ (beta δ₁ 0 : ℝ) * (1 / 4 : ℝ) ^ s := by
+  have hh := mul_le_mul_of_nonneg_left (b.beta_geometric 0 s) (by positivity : (0 : ℝ) ≤ 2 ^ s)
+  simpa only [Nat.add_zero, ← mul_assoc, mul_comm ((2 : ℝ) ^ s), mul_assoc, ← mul_pow,
+    show (1 / 8 : ℝ) * 2 = 1 / 4 by norm_num] using hh
+
+theorem weighted_beta_summable : Summable (fun s => (2 : ℝ) ^ s * beta δ₁ s) :=
+  Summable.of_nonneg_of_le (fun s => by positivity) b.weighted_beta_bound
+    ((summable_geometric_of_lt_one (by norm_num : (0 : ℝ) ≤ 1 / 4)
+      (by norm_num)).mul_left (beta δ₁ 0 : ℝ))
+
+theorem weighted_beta_tsum_lt : (∑' s, (2 : ℝ) ^ s * beta δ₁ s) < 2 * (beta δ₁ 0 : ℝ) := by
+  have hh := b.weighted_beta_summable.tsum_le_tsum b.weighted_beta_bound
+    ((summable_geometric_of_lt_one (by norm_num : (0 : ℝ) ≤ 1 / 4)
+      (by norm_num)).mul_left (beta δ₁ 0 : ℝ))
+  rw [tsum_mul_left, tsum_geometric_of_lt_one (by norm_num) (by norm_num)] at hh
+  have hp : (0 : ℝ) < beta δ₁ 0 := pow_pos (b.delta_step_pos 0) 3
+  norm_num at hh
+  nlinarith
+
+theorem weighted_beta_tendsto_zero :
+    Tendsto (fun s => (2 : ℝ) ^ s * beta δ₁ s) atTop (𝓝 0) :=
+  b.weighted_beta_summable.tendsto_atTop_zero
+
+theorem frequency_budget_summable :
+    Summable (fun s => (beta δ₁ s : ℝ) * delta δ₁ s) := by
+  apply Summable.of_nonneg_of_le (fun s => by positivity) _ b.beta_summable
+  intro s
+  exact mul_le_of_le_one_right (beta δ₁ s).coe_nonneg ((b.delta_step_le s).trans b.delta_one.le)
+
+theorem frequency_tail_lt (s : ℕ) :
+    (∑' j, (beta δ₁ (j + s) : ℝ) * delta δ₁ (j + s)) < (beta δ₁ s : ℝ) / 2 := by
+  have hh := ((summable_nat_add_iff s).mpr b.frequency_budget_summable).tsum_le_tsum
+    (fun j => mul_le_mul_of_nonneg_left
+      (show (delta δ₁ (j + s) : ℝ) ≤ 1 / 4 from
+        ((b.delta_step_le _).trans b.delta_quarter.le)) (beta δ₁ _).coe_nonneg)
+    (((summable_nat_add_iff s).mpr b.beta_summable).mul_right (1 / 4 : ℝ))
+  rw [tsum_mul_right] at hh
+  have ht := b.beta_tail_le s
+  have hp : (0 : ℝ) < beta δ₁ s := pow_pos (b.delta_step_pos s) 3
+  nlinarith
+
+end KamProject.Arnold1963.Iteration.InitialParameters
diff --git a/LeanPool/ArnoldKAM/Arnold1963/Convergence/ComplexLines.lean b/LeanPool/ArnoldKAM/Arnold1963/Convergence/ComplexLines.lean
new file mode 100644
index 0000000000..227b322f47
--- /dev/null
+++ b/LeanPool/ArnoldKAM/Arnold1963/Convergence/ComplexLines.lean
@@ -0,0 +1,82 @@
+/-
+Copyright (c) 2026 Bingqi Yu. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Bingqi Yu
+-/
+
+module
+
+public import LeanPool.ArnoldKAM.Arnold1963.Convergence.Limit
+public import Mathlib.Analysis.Complex.LocallyUniformLimit
+
+/-!
+Complex-line analyticity and convergence of angle derivatives for a fixed action label.
+-/
+
+@[expose] public section
+noncomputable section
+open Set Filter
+open scoped NNReal Topology
+namespace KamProject.Arnold1963.Iteration.InitialData
+variable {n : ℕ} {Ω₀ : Set (ComplexSpace n)} {δ₁ θ₀ Θ₀ ρ₀ : ℝ≥0} {κ D : ℝ}
+  (b : InitialParameters n δ₁ θ₀ Θ₀ ρ₀ κ D)
+  (h : InitialData n Ω₀ δ₁ θ₀ Θ₀ ρ₀ D)
+
+/-- Complex times for which the indicated affine angle line lies in the common open strip. -/
+def lineDomain (q v : ComplexSpace n) : Set ℂ :=
+  {t | ‖imagPart (q + t • v)‖ < (ρ₀ : ℝ) / 3}
+
+theorem lineDomain_open (q v : ComplexSpace n) : IsOpen (lineDomain (ρ₀ := ρ₀) q v) := by
+  apply isOpen_lt _ continuous_const
+  unfold imagPart
+  fun_prop
+
+theorem line_mem_limitPhase {p : ComplexSpace n} (hp : p ∈ h.limitDomain b)
+    {q v : ComplexSpace n} {t : ℂ} (ht : t ∈ lineDomain (ρ₀ := ρ₀) q v) :
+    (p, q + t • v) ∈ h.limitPhase b := by
+  apply h.commonPhase_subset b
+  refine ⟨hp, ?_⟩
+  exact (show ‖imagPart (q + t • v)‖ < (ρ₀ : ℝ) / 3 from ht).le
+
+theorem line_uniform {p : ComplexSpace n} (hp : p ∈ h.limitDomain b) (q v : ComplexSpace n) :
+    TendstoUniformlyOn (fun s t => h.cumulative b s (p, q + t • v))
+      (fun t => h.limitMap b (p, q + t • v)) atTop (lineDomain (ρ₀ := ρ₀) q v) :=
+  ((h.cumulative_uniform b).comp (fun t => (p, q + t • v))).mono
+    (fun _ ht => h.line_mem_limitPhase b hp ht)
+
+theorem line_differentiable {p : ComplexSpace n} (hp : p ∈ h.limitDomain b)
+    (q v : ComplexSpace n) (s : ℕ) :
+    DifferentiableOn ℂ (fun t => h.cumulative b s (p, q + t • v))
+      (lineDomain (ρ₀ := ρ₀) q v) := by
+  intro t ht
+  have ha : AnalyticAt ℂ (fun u : ℂ => (p, q + u • v)) t :=
+    analyticAt_const.prod (analyticAt_const.add (analyticAt_id.smul analyticAt_const))
+  exact ((h.cumulative_analytic b s _
+    (h.limitPhase_subset b s (h.line_mem_limitPhase b hp ht))).comp
+      (f := fun u : ℂ => (p, q + u • v)) ha).differentiableAt.differentiableWithinAt
+
+theorem limitMap_line_analytic {p : ComplexSpace n} (hp : p ∈ h.limitDomain b)
+    (q v : ComplexSpace n) :
+    AnalyticOnNhd ℂ (fun t => h.limitMap b (p, q + t • v)) (lineDomain (ρ₀ := ρ₀) q v) := by
+  have hd := (h.line_uniform b hp q v).tendstoLocallyUniformlyOn.differentiableOn
+    (Filter.Eventually.of_forall (h.line_differentiable b hp q v)) (lineDomain_open q v)
+  exact hd.analyticOnNhd (lineDomain_open q v)
+
+theorem line_derivative_uniform {p : ComplexSpace n} (hp : p ∈ h.limitDomain b)
+    (q v : ComplexSpace n) :
+    TendstoLocallyUniformlyOn (fun s => deriv (fun t => h.cumulative b s (p, q + t • v)))
+      (deriv (fun t => h.limitMap b (p, q + t • v))) atTop (lineDomain (ρ₀ := ρ₀) q v) :=
+  (h.line_uniform b hp q v).tendstoLocallyUniformlyOn.deriv
+    (Filter.Eventually.of_forall (h.line_differentiable b hp q v)) (lineDomain_open q v)
+
+theorem line_derivative_eq {p : ComplexSpace n} (hp : p ∈ h.limitDomain b)
+    {q v : ComplexSpace n} {t : ℂ} (ht : t ∈ lineDomain (ρ₀ := ρ₀) q v) (s : ℕ) :
+    deriv (fun t => h.cumulative b s (p, q + t • v)) t =
+      fderiv ℂ (h.cumulative b s) (p, q + t • v) (0, v) := by
+  have hd : HasDerivAt (fun t : ℂ => (p, q + t • v)) (0, v) t := by
+    simpa using (hasDerivAt_const t p).prodMk (((hasDerivAt_id t).smul_const v).const_add q)
+  have hf := (h.cumulative_analytic b s _
+    (h.limitPhase_subset b s (h.line_mem_limitPhase b hp ht))).differentiableAt.hasFDerivAt
+  exact (hf.comp_hasDerivAt t hd).deriv
+
+end KamProject.Arnold1963.Iteration.InitialData
diff --git a/LeanPool/ArnoldKAM/Arnold1963/Convergence/Composition.lean b/LeanPool/ArnoldKAM/Arnold1963/Convergence/Composition.lean
new file mode 100644
index 0000000000..c834efd33c
--- /dev/null
+++ b/LeanPool/ArnoldKAM/Arnold1963/Convergence/Composition.lean
@@ -0,0 +1,128 @@
+/-
+Copyright (c) 2026 Bingqi Yu. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Bingqi Yu
+-/
+
+module
+
+public import LeanPool.ArnoldKAM.Arnold1963.Iteration.Estimates
+public import LeanPool.ArnoldKAM.Arnold1963.Iteration.LimitDomain
+public import LeanPool.ArnoldKAM.Arnold1963.Convergence.Budgets
+
+/-!
+Cumulative transformation estimates. Mean-value arguments first establish segment containment
+in the relevant domain.
+-/
+
+@[expose] public section
+noncomputable section
+open Set Metric Filter
+open scoped NNReal Topology
+namespace KamProject.Arnold1963.Iteration.InitialData
+variable {n : ℕ} {Ω₀ : Set (ComplexSpace n)} {δ₁ θ₀ Θ₀ ρ₀ : ℝ≥0} {κ D : ℝ}
+  (b : InitialParameters n δ₁ θ₀ Θ₀ ρ₀ κ D)
+  (h : InitialData n Ω₀ δ₁ θ₀ Θ₀ ρ₀ D)
+
+theorem phase_antitone : Antitone (h.phase b) :=
+  antitone_nat_of_succ_le (fun s => (h.phase_buffer b s).trans (erosion_subset _ _))
+
+theorem phase_closed (s : ℕ) : IsClosed (h.phase b s) := by
+  have hc : Continuous (fun q : ComplexSpace n => ‖imagPart q‖) := by
+    unfold imagPart
+    fun_prop
+  exact (h.domain_compact b s).isClosed.prod (isClosed_le hc continuous_const)
+
+/-- The intersection of all phase domains in the iteration. -/
+def limitPhase : Set (ComplexPhaseSpace n) := ⋂ s, h.phase b s
+
+theorem limitPhase_subset (s : ℕ) : h.limitPhase b ⊆ h.phase b s := iInter_subset _ s
+
+theorem commonPhase_subset : phaseDomain (h.limitDomain b) (ρ₀ / 3) ⊆ h.limitPhase b := by
+  intro z hz
+  apply mem_iInter.mpr
+  intro s
+  refine ⟨h.limit_subset b s hz.1, ?_⟩
+  have hq : ‖imagPart z.2‖ ≤ (ρ₀ : ℝ) / 3 := hz.2
+  exact hq.trans (InitialData.width_gt_third b s).le
+
+theorem cumulative_analytic (s : ℕ) : AnalyticOnNhd ℂ (h.cumulative b s) (h.phase b s) := by
+  induction s with
+  | zero => exact fun _ _ => analyticAt_id
+  | succ s ih =>
+    intro z hz
+    exact (ih _ ((h.transformation b s).mapsTo hz)).comp ((h.transformation b s).analytic z hz)
+
+theorem cumulative_derivative (s : ℕ) :
+    ∀ z ∈ h.phase b s, ‖fderiv ℂ (h.cumulative b s) z‖ ≤ (2 : ℝ) ^ s := by
+  induction s with
+  | zero =>
+    intro z _
+    simpa only [cumulative, fderiv_id, pow_zero] using
+      (ContinuousLinearMap.norm_id_le (𝕜 := ℂ) (E := ComplexPhaseSpace n))
+  | succ s ih =>
+    intro z hz
+    change ‖fderiv ℂ (h.cumulative b s ∘ (h.transformation b s).toFun) z‖ ≤ _
+    rw [fderiv_comp z
+      ((h.cumulative_analytic b s) _ ((h.transformation b s).mapsTo hz)).differentiableAt
+      ((h.transformation b s).analytic z hz).differentiableAt, pow_succ]
+    exact (ContinuousLinearMap.opNorm_comp_le _ _).trans
+      (mul_le_mul (ih _ ((h.transformation b s).mapsTo hz))
+        ((h.transformation b s).derivative_bound z hz).le (norm_nonneg _) (by positivity))
+
+theorem cumulative_canonical (s : ℕ) : CanonicalOn (h.cumulative b s) (h.phase b s) := by
+  induction s with
+  | zero => exact fun z _ => canonicalAt_id z
+  | succ s ih => exact ih.comp (h.transformation b s).canonical (h.transformation b s).mapsTo
+
+theorem cumulative_injOn (s : ℕ) : InjOn (h.cumulative b s) (h.phase b s) := by
+  induction s with
+  | zero => exact fun _ _ _ _ hh => hh
+  | succ s ih => exact ih.comp (h.transformation b s).injOn (h.transformation b s).mapsTo
+
+theorem cumulative_increment (s : ℕ) {z : ComplexPhaseSpace n}
+    (hz : z ∈ h.phase b (s + 1)) :
+    ‖h.cumulative b (s + 1) z - h.cumulative b s z‖ ≤ (2 : ℝ) ^ s * beta δ₁ s := by
+  have hm : (h.transformation b s).toFun z ∈ closedBall z (beta δ₁ s : ℝ) := by
+    rw [mem_closedBall, dist_eq_norm]
+    exact (h.displacement_lt b s hz).le
+  have hseg : segment ℝ z ((h.transformation b s).toFun z) ⊆ h.phase b s :=
+    ((convex_closedBall z (beta δ₁ s : ℝ)).segment_subset
+      (mem_closedBall_self (beta δ₁ s).coe_nonneg) hm).trans (h.phase_buffer b s hz)
+  exact (norm_sub_le_of_analytic_segment_bound hseg (h.cumulative_analytic b s)
+    ⟨by positivity, h.cumulative_derivative b s⟩).trans
+    (mul_le_mul_of_nonneg_left (h.displacement_lt b s hz).le (by positivity))
+
+theorem cumulative_periodic (s : ℕ) : ∀ z ∈ h.phase b s, ∀ k : FourierIndex n,
+    h.cumulative b s (phaseShift k z) = phaseShift k (h.cumulative b s z) := by
+  induction s with
+  | zero => exact fun _ _ _ => rfl
+  | succ s ih =>
+    intro z hz k
+    change h.cumulative b s ((h.transformation b s).toFun (phaseShift k z)) = _
+    rw [h.transformation_periodic b s hz k]
+    exact ih _ ((h.transformation b s).mapsTo hz) k
+
+theorem cumulative_real (s : ℕ) : ∀ z ∈ h.phase b s,
+    h.cumulative b s (conjPhase z) = conjPhase (h.cumulative b s z) := by
+  induction s with
+  | zero => exact fun _ _ => rfl
+  | succ s ih =>
+    intro z hz
+    change h.cumulative b s ((h.transformation b s).toFun (conjPhase z)) = _
+    rw [h.transformation_real b s hz]
+    exact ih _ ((h.transformation b s).mapsTo hz)
+
+theorem limitPhase_shift {z : ComplexPhaseSpace n} (hz : z ∈ h.limitPhase b)
+    (k : FourierIndex n) : phaseShift k z ∈ h.limitPhase b := by
+  apply mem_iInter.mpr
+  intro s
+  exact (phaseShift_mem_phaseDomain k z).mpr (h.limitPhase_subset b s hz)
+
+theorem limitPhase_conj {z : ComplexPhaseSpace n} (hz : z ∈ h.limitPhase b) :
+    conjPhase z ∈ h.limitPhase b := by
+  apply mem_iInter.mpr
+  intro s
+  exact conj_mem_phaseDomain (h.state b s).input.chart.domain_conj (h.limitPhase_subset b s hz)
+
+end KamProject.Arnold1963.Iteration.InitialData
diff --git a/LeanPool/ArnoldKAM/Arnold1963/Convergence/Frequency.lean b/LeanPool/ArnoldKAM/Arnold1963/Convergence/Frequency.lean
new file mode 100644
index 0000000000..bf4ef42355
--- /dev/null
+++ b/LeanPool/ArnoldKAM/Arnold1963/Convergence/Frequency.lean
@@ -0,0 +1,68 @@
+/-
+Copyright (c) 2026 Bingqi Yu. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Bingqi Yu
+-/
+
+module
+
+public import LeanPool.ArnoldKAM.Arnold1963.Convergence.Limit
+
+/-!
+Uniform convergence of the actual frequencies on the common action domain, with strict
+tail bounds on the scale of the next action loss.
+-/
+
+@[expose] public section
+noncomputable section
+open Set Filter
+open scoped NNReal Topology
+namespace KamProject.Arnold1963.Iteration.InitialData
+variable {n : ℕ} {Ω₀ : Set (ComplexSpace n)} {δ₁ θ₀ Θ₀ ρ₀ : ℝ≥0} {κ D : ℝ}
+  (b : InitialParameters n δ₁ θ₀ Θ₀ ρ₀ κ D)
+  (h : InitialData n Ω₀ δ₁ θ₀ Θ₀ ρ₀ D)
+
+/-- The action-frequency map at the specified iteration stage. -/
+def frequency (s : ℕ) : ComplexSpace n → ComplexSpace n :=
+  actionFrequency (h.state b s).integrable
+
+/-- The telescoping limit of the iteration's action-frequency maps. -/
+def limitFrequency : ComplexSpace n → ComplexSpace n := Convergence.sequenceLimit (h.frequency b)
+
+theorem frequency_uniform : TendstoUniformlyOn (h.frequency b) (h.limitFrequency b) atTop
+    (h.limitDomain b) :=
+  Convergence.sequenceLimit_tendstoUniformlyOn b.frequency_budget_summable
+    (fun s _ hp => (h.frequency_displacement b s (h.limit_subset b (s + 1) hp)).le)
+
+theorem limitFrequency_tail {p : ComplexSpace n} (hp : p ∈ h.limitDomain b) (s : ℕ) :
+    ‖h.limitFrequency b p - h.frequency b s p‖ < (beta δ₁ s : ℝ) / 2 :=
+  (Convergence.sequenceLimit_tail_le b.frequency_budget_summable
+    (fun j => (h.frequency_displacement b j (h.limit_subset b (j + 1) hp)).le) s).trans_lt
+      (b.frequency_tail_lt s)
+
+theorem limitFrequency_continuous : ContinuousOn (h.limitFrequency b) (h.limitDomain b) :=
+  (h.frequency_uniform b).continuousOn (Filter.Eventually.frequently
+    (Filter.Eventually.of_forall fun s =>
+      (h.state b s).input.chart.analytic.continuousOn.mono (h.limit_subset b s)))
+
+theorem limitFrequency_real {p : ComplexSpace n} (hp : p ∈ h.limitDomain b) :
+    h.limitFrequency b (conjVec p) = conjVec (h.limitFrequency b p) := by
+  have hc : conjVec p ∈ h.limitDomain b := by
+    apply mem_iInter.mpr
+    intro s
+    exact (h.state b s).input.chart.domain_conj p (h.limit_subset b s hp)
+  have hs := (h.frequency_uniform b).tendsto_at hc
+  have ht := ((h.frequency_uniform b).tendsto_at hp).star
+  apply tendsto_nhds_unique hs
+  convert ht using 1
+  · funext s
+    exact (h.state b s).input.chart.map_conj p (h.limit_subset b s hp)
+  · rw [conjVec_eq_star]
+
+theorem limitFrequency_real_value {p : RealSpace n} (hp : p ∈ realSlice (h.limitDomain b)) :
+    complexify (realPart (h.limitFrequency b (complexify p))) =
+      h.limitFrequency b (complexify p) := by
+  apply complexify_realPart_of_conj
+  simpa only [conjVec_complexify] using (h.limitFrequency_real b hp).symm
+
+end KamProject.Arnold1963.Iteration.InitialData
diff --git a/LeanPool/ArnoldKAM/Arnold1963/Convergence/JointAnalyticity.lean b/LeanPool/ArnoldKAM/Arnold1963/Convergence/JointAnalyticity.lean
new file mode 100644
index 0000000000..c9b61e5f56
--- /dev/null
+++ b/LeanPool/ArnoldKAM/Arnold1963/Convergence/JointAnalyticity.lean
@@ -0,0 +1,77 @@
+/-
+Copyright (c) 2026 Bingqi Yu. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Bingqi Yu
+-/
+
+module
+
+public import LeanPool.ArnoldKAM.Arnold1963.Convergence.ComplexLines
+public import LeanPool.ArnoldKAM.Arnold1963.Analysis.AnalyticUniformLimit
+
+/-!
+Joint multivariable angle analyticity for each retained action label on a common complex
+strip. The result makes no ambient analyticity claim in the Cantor action-label variable.
+-/
+
+@[expose] public section
+noncomputable section
+open Set Filter
+open scoped NNReal Topology
+namespace KamProject.Arnold1963.Iteration.InitialData
+variable {n : ℕ} {Ω₀ : Set (ComplexSpace n)} {δ₁ θ₀ Θ₀ ρ₀ : ℝ≥0} {κ D : ℝ}
+  (b : InitialParameters n δ₁ θ₀ Θ₀ ρ₀ κ D)
+  (h : InitialData n Ω₀ δ₁ θ₀ Θ₀ ρ₀ D)
+
+/-- The open angle strip retained uniformly throughout the iteration. -/
+def commonAngleStrip (n : ℕ) (ρ : ℝ≥0) : Set (ComplexSpace n) :=
+  {q | ‖imagPart q‖ < (ρ : ℝ) / 3}
+
+theorem commonAngleStrip_open : IsOpen (commonAngleStrip n ρ₀) := by
+  apply isOpen_lt _ continuous_const
+  unfold imagPart
+  fun_prop
+
+theorem angle_mem_limitPhase {p : ComplexSpace n} (hp : p ∈ h.limitDomain b)
+    {q : ComplexSpace n} (hq : q ∈ commonAngleStrip n ρ₀) : (p, q) ∈ h.limitPhase b := by
+  apply h.commonPhase_subset b
+  exact ⟨hp, (show ‖imagPart q‖ < (ρ₀ : ℝ) / 3 from hq).le⟩
+
+theorem angle_uniform {p : ComplexSpace n} (hp : p ∈ h.limitDomain b) :
+    TendstoUniformlyOn (fun s q => h.cumulative b s (p, q))
+      (fun q => h.limitMap b (p, q)) atTop (commonAngleStrip n ρ₀) :=
+  ((h.cumulative_uniform b).comp (fun q => (p, q))).mono
+    (fun _ hq => h.angle_mem_limitPhase b hp hq)
+
+theorem cumulative_angle_analytic {p : ComplexSpace n} (hp : p ∈ h.limitDomain b)
+    (s : ℕ) : AnalyticOnNhd ℂ (fun q => h.cumulative b s (p, q)) (commonAngleStrip n ρ₀) := by
+  intro q hq
+  exact (h.cumulative_analytic b s _
+    (h.limitPhase_subset b s (h.angle_mem_limitPhase b hp hq))).comp
+      (f := fun q : ComplexSpace n => (p, q)) (analyticAt_const.prod analyticAt_id)
+
+theorem limitMap_angle_scalar_analytic {p : ComplexSpace n} (hp : p ∈ h.limitDomain b)
+    (L : ComplexPhaseSpace n →L[ℂ] ℂ) :
+    AnalyticOnNhd ℂ (fun q => L (h.limitMap b (p, q))) (commonAngleStrip n ρ₀) :=
+  analyticOnNhd_uniform_limit commonAngleStrip_open
+    (fun s q hq => (L.analyticAt _).comp (h.cumulative_angle_analytic b hp s q hq))
+    (L.uniformContinuous.comp_tendstoUniformlyOn (h.angle_uniform b hp))
+
+theorem limitMap_angle_analytic {p : ComplexSpace n} (hp : p ∈ h.limitDomain b) :
+    AnalyticOnNhd ℂ (fun q => h.limitMap b (p, q)) (commonAngleStrip n ρ₀) := by
+  intro q hq
+  have hpA : AnalyticAt ℂ (fun q => (h.limitMap b (p, q)).1) q := by
+    apply AnalyticAt.pi
+    intro j
+    exact h.limitMap_angle_scalar_analytic b hp
+      ((ContinuousLinearMap.proj (R := ℂ) (φ := fun _ : Fin n => ℂ) j).comp
+        (ContinuousLinearMap.fst ℂ (ComplexSpace n) (ComplexSpace n))) q hq
+  have hqA : AnalyticAt ℂ (fun q => (h.limitMap b (p, q)).2) q := by
+    apply AnalyticAt.pi
+    intro j
+    exact h.limitMap_angle_scalar_analytic b hp
+      ((ContinuousLinearMap.proj (R := ℂ) (φ := fun _ : Fin n => ℂ) j).comp
+        (ContinuousLinearMap.snd ℂ (ComplexSpace n) (ComplexSpace n))) q hq
+  exact hpA.prod hqA
+
+end KamProject.Arnold1963.Iteration.InitialData
diff --git a/LeanPool/ArnoldKAM/Arnold1963/Convergence/Limit.lean b/LeanPool/ArnoldKAM/Arnold1963/Convergence/Limit.lean
new file mode 100644
index 0000000000..224ac9966c
--- /dev/null
+++ b/LeanPool/ArnoldKAM/Arnold1963/Convergence/Limit.lean
@@ -0,0 +1,87 @@
+/-
+Copyright (c) 2026 Bingqi Yu. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Bingqi Yu
+-/
+
+module
+
+public import LeanPool.ArnoldKAM.Arnold1963.Convergence.Composition
+public import LeanPool.ArnoldKAM.Arnold1963.Convergence.SequenceLimit
+
+/-!
+Uniform convergence of actual cumulative transformations on their common domain, with
+periodicity, real compatibility, and displacement estimates.
+-/
+
+@[expose] public section
+noncomputable section
+open Set Filter Metric
+open scoped NNReal Topology
+namespace KamProject.Arnold1963.Iteration.InitialData
+variable {n : ℕ} {Ω₀ : Set (ComplexSpace n)} {δ₁ θ₀ Θ₀ ρ₀ : ℝ≥0} {κ D : ℝ}
+  (b : InitialParameters n δ₁ θ₀ Θ₀ ρ₀ κ D)
+  (h : InitialData n Ω₀ δ₁ θ₀ Θ₀ ρ₀ D)
+
+/-- The telescoping limit of the cumulative phase transformations. -/
+def limitMap : ComplexPhaseSpace n → ComplexPhaseSpace n :=
+  Convergence.sequenceLimit (h.cumulative b)
+
+theorem cumulative_uniform : TendstoUniformlyOn (h.cumulative b) (h.limitMap b) atTop
+    (h.limitPhase b) :=
+  Convergence.sequenceLimit_tendstoUniformlyOn b.weighted_beta_summable
+    (fun s _ hx => h.cumulative_increment b s (h.limitPhase_subset b (s + 1) hx))
+
+theorem limitMap_tail {z : ComplexPhaseSpace n} (hz : z ∈ h.limitPhase b) (s : ℕ) :
+    ‖h.limitMap b z - h.cumulative b s z‖ ≤
+      ∑' j, (2 : ℝ) ^ (j + s) * beta δ₁ (j + s) :=
+  Convergence.sequenceLimit_tail_le b.weighted_beta_summable
+    (fun j => h.cumulative_increment b j (h.limitPhase_subset b (j + 1) hz)) s
+
+theorem limitMap_displacement {z : ComplexPhaseSpace n} (hz : z ∈ h.limitPhase b) :
+    ‖h.limitMap b z - z‖ < 2 * (beta δ₁ 0 : ℝ) := by
+  have hh := h.limitMap_tail b hz 0
+  simp only [Nat.add_zero, cumulative] at hh
+  exact hh.trans_lt b.weighted_beta_tsum_lt
+
+theorem limitMap_continuous : ContinuousOn (h.limitMap b) (h.limitPhase b) :=
+  (h.cumulative_uniform b).continuousOn (Filter.Eventually.frequently
+    (Filter.Eventually.of_forall fun s =>
+      (h.cumulative_analytic b s).continuousOn.mono (h.limitPhase_subset b s)))
+
+theorem limitMap_maps : MapsTo (h.limitMap b) (h.limitPhase b) (h.phase b 0) := by
+  intro z hz
+  exact (h.phase_closed b 0).mem_of_tendsto ((h.cumulative_uniform b).tendsto_at hz)
+    (Filter.Eventually.of_forall fun s => h.cumulative_maps b s (h.limitPhase_subset b s hz))
+
+theorem limitMap_periodic {z : ComplexPhaseSpace n} (hz : z ∈ h.limitPhase b)
+    (k : FourierIndex n) : h.limitMap b (phaseShift k z) = phaseShift k (h.limitMap b z) := by
+  have hs := (h.cumulative_uniform b).tendsto_at (h.limitPhase_shift b hz k)
+  have ht := ((h.cumulative_uniform b).tendsto_at hz).add_const (0, angleShift k)
+  apply tendsto_nhds_unique hs
+  convert ht using 1
+  · funext s
+    exact (h.cumulative_periodic b s z (h.limitPhase_subset b s hz) k).trans
+      (phaseShift_eq_add k _)
+  · rw [phaseShift_eq_add]
+
+theorem limitMap_real {z : ComplexPhaseSpace n} (hz : z ∈ h.limitPhase b) :
+    h.limitMap b (conjPhase z) = conjPhase (h.limitMap b z) := by
+  have hs := (h.cumulative_uniform b).tendsto_at (h.limitPhase_conj b hz)
+  have ht := ((h.cumulative_uniform b).tendsto_at hz).star
+  apply tendsto_nhds_unique hs
+  convert ht using 1
+  · funext s
+    simpa only [conjPhase_eq_star] using h.cumulative_real b s z (h.limitPhase_subset b s hz)
+  · rw [conjPhase_eq_star]
+
+theorem limitMap_real_value {x : RealPhaseCover n}
+    (hx : x.1 ∈ realSlice (h.limitDomain b)) :
+    complexifyPhase (realPartPhase (h.limitMap b (complexifyPhase x))) =
+      h.limitMap b (complexifyPhase x) := by
+  apply complexifyPhase_realPartPhase_of_conj
+  have hz : complexifyPhase x ∈ h.limitPhase b :=
+    h.commonPhase_subset b ⟨hx, complexify_mem_angleStrip _ _⟩
+  simpa only [conjPhase_complexifyPhase] using (h.limitMap_real b hz).symm
+
+end KamProject.Arnold1963.Iteration.InitialData
diff --git a/LeanPool/ArnoldKAM/Arnold1963/Convergence/Nonresonance.lean b/LeanPool/ArnoldKAM/Arnold1963/Convergence/Nonresonance.lean
new file mode 100644
index 0000000000..c608140f37
--- /dev/null
+++ b/LeanPool/ArnoldKAM/Arnold1963/Convergence/Nonresonance.lean
@@ -0,0 +1,87 @@
+/-
+Copyright (c) 2026 Bingqi Yu. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Bingqi Yu
+-/
+
+module
+
+public import LeanPool.ArnoldKAM.Arnold1963.Convergence.Frequency
+
+/-!
+Increasing cutoffs give a common small-divisor bound for every nonzero integer mode
+of the limit frequency.
+-/
+
+@[expose] public section
+noncomputable section
+open Set Filter
+open scoped NNReal Topology
+namespace KamProject.Arnold1963.Iteration
+variable {n : ℕ} {Ω₀ : Set (ComplexSpace n)} {δ₁ θ₀ Θ₀ ρ₀ : ℝ≥0} {κ D : ℝ}
+  (b : InitialParameters n δ₁ θ₀ Θ₀ ρ₀ κ D)
+
+theorem indexLength_pos_of_ne_zero (k : FourierIndex n) (hk : k ≠ 0) :
+    0 < indexLength k := by
+  rw [indexLength_eq_latticeLength]
+  exact_mod_cast Nat.pos_of_ne_zero (mt (latticeLength_eq_zero k).mp hk)
+
+include b in
+theorem InitialParameters.cutoff_tendsto_atTop : Tendsto (cutoff n δ₁) atTop atTop := by
+  have hγ : Summable (fun s => (gamma n δ₁ s : ℝ)) := by
+    apply decay_summable
+    have hh := (gamma_initial_bounds b.dimension_pos (threshold5_bounds b.small).2.1).2.le
+    simp only [gamma, decay_zero] at hh
+    exact_mod_cast hh
+  apply tendsto_atTop.mpr
+  intro R
+  have hr : 0 < max R 1 := lt_of_lt_of_le zero_lt_one (le_max_right _ _)
+  have he : 0 < (1 / 2 : ℝ) / max R 1 := div_pos (by norm_num) hr
+  filter_upwards [hγ.tendsto_atTop_zero.eventually (gt_mem_nhds he)] with s hs
+  have hg : (0 : ℝ) < gamma n δ₁ s := b.gamma_step_pos s
+  have hh := (lt_div_iff₀ hr).mp hs
+  have hl := b.cutoff_numerator_gt_half s
+  apply le_of_lt
+  calc
+    R ≤ max R 1 := le_max_left _ _
+    _ < cutoff n δ₁ s := (lt_div_iff₀ hg).mpr (by nlinarith)
+
+namespace InitialData
+variable (h : InitialData n Ω₀ δ₁ θ₀ Θ₀ ρ₀ D)
+
+/-- The resonance-filtered frequency domain at the specified iteration stage. -/
+def frequencyDomain (s : ℕ) : Set (ComplexSpace n) := (h.state b s).ar.domain Ω₀
+
+theorem frequencyDomain_succ (s : ℕ) : h.frequencyDomain b (s + 1) =
+    erosion (nonresonantDomain (h.frequencyDomain b s) id (κ * (δ₁ : ℝ)) (cutoff n δ₁ s))
+      ((5 + 7 * Iteration.upper Θ₀ δ₁ s) * beta δ₁ s) :=
+  (h.state b s).ar.next_domain b.divisor_pos (b.cutoff_step_le s) _ Ω₀
+
+theorem frequencyDomain_antitone : Antitone (h.frequencyDomain b) := by
+  apply antitone_nat_of_succ_le
+  intro s
+  rw [h.frequencyDomain_succ b]
+  exact (erosion_subset _ _).trans (fun _ hx => hx.1)
+
+theorem limitFrequency_mem {p : ComplexSpace n} (hp : p ∈ h.limitDomain b) (s : ℕ) :
+    h.limitFrequency b p ∈ h.frequencyDomain b s := by
+  apply ((h.state b s).ar.compact h.typeD.compact).isClosed.mem_of_tendsto
+    ((h.frequency_uniform b).tendsto_at hp)
+  filter_upwards [eventually_ge_atTop s] with t ht
+  exact h.frequencyDomain_antitone b ht ((h.state b t).input.chart.maps (h.limit_subset b t hp))
+
+theorem limitFrequency_nonresonant {p : ComplexSpace n} (hp : p ∈ h.limitDomain b)
+    (k : FourierIndex n) (hk : k ≠ 0) :
+    κ * (δ₁ : ℝ) / indexLength k ^ (n + 1) ≤ ‖indexPairing k (h.limitFrequency b p)‖ := by
+  obtain ⟨s, hs⟩ := (b.cutoff_tendsto_atTop.eventually (eventually_gt_atTop (indexLength k))).exists
+  exact (h.state b (s + 1)).ar.nonresonant (h.limitFrequency_mem b hp (s + 1)) k
+    (mem_lowModes.mpr ⟨indexLength_pos_of_ne_zero k hk, hs⟩)
+
+theorem limitFrequency_no_integer_relation {p : ComplexSpace n} (hp : p ∈ h.limitDomain b)
+    (k : FourierIndex n) (hk : k ≠ 0) : indexPairing k (h.limitFrequency b p) ≠ 0 := by
+  apply norm_pos_iff.mp
+  exact (div_pos b.divisor_pos (pow_pos (indexLength_pos_of_ne_zero k hk) _)).trans_le
+    (h.limitFrequency_nonresonant b hp k hk)
+
+end InitialData
+end KamProject.Arnold1963.Iteration
diff --git a/LeanPool/ArnoldKAM/Arnold1963/Convergence/RealDerivative.lean b/LeanPool/ArnoldKAM/Arnold1963/Convergence/RealDerivative.lean
new file mode 100644
index 0000000000..a1466a7168
--- /dev/null
+++ b/LeanPool/ArnoldKAM/Arnold1963/Convergence/RealDerivative.lean
@@ -0,0 +1,92 @@
+/-
+Copyright (c) 2026 Bingqi Yu. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Bingqi Yu
+-/
+
+module
+
+public import LeanPool.ArnoldKAM.Arnold1963.Convergence.Composition
+public import LeanPool.ArnoldKAM.Arnold1963.Geometry.RealCover
+public import LeanPool.ArnoldKAM.Arnold1963.Geometry.RealJacobian
+
+/-!
+Derivative bounds for finite cumulative transformations on the real cover. Restricting
+to real coordinates and taking real parts does not increase the operator norm.
+-/
+
+@[expose] public section
+noncomputable section
+open Set
+open scoped NNReal
+namespace KamProject.Arnold1963
+
+/-- Complexification of action and angle coordinates as a real continuous linear map. -/
+def complexifyPhaseCLM (n : ℕ) : RealPhaseCover n →L[ℝ] ComplexPhaseSpace n :=
+  (complexifyCLM n).prodMap (complexifyCLM n)
+
+/-- Real-part projection of phase coordinates as a real continuous linear map. -/
+def realPartPhaseCLM (n : ℕ) : ComplexPhaseSpace n →L[ℝ] RealPhaseCover n :=
+  (realPartCLM n).prodMap (realPartCLM n)
+
+@[simp] theorem complexifyPhaseCLM_apply {n} (x : RealPhaseCover n) :
+    complexifyPhaseCLM n x = complexifyPhase x := rfl
+
+@[simp] theorem realPartPhaseCLM_apply {n} (z : ComplexPhaseSpace n) :
+    realPartPhaseCLM n z = realPartPhase z := rfl
+
+@[simp] theorem norm_complexifyPhase {n} (x : RealPhaseCover n) :
+    ‖complexifyPhase x‖ = ‖x‖ := by
+  simp [complexifyPhase, Prod.norm_def]
+
+theorem norm_realPartPhase_le {n} (z : ComplexPhaseSpace n) :
+    ‖realPartPhase z‖ ≤ ‖z‖ :=
+  max_le_max (norm_realPart_le z.1) (norm_realPart_le z.2)
+
+/-- Restriction of a complex phase map to real input and real output coordinates. -/
+def realPhaseRestriction {n} (f : ComplexPhaseSpace n → ComplexPhaseSpace n) :
+    RealPhaseCover n → RealPhaseCover n := realPartPhase ∘ f ∘ complexifyPhase
+
+/-- The real continuous linear derivative induced by a complex phase derivative. -/
+def realPhaseDerivative {n} (L : ComplexPhaseSpace n →L[ℂ] ComplexPhaseSpace n) :
+    RealPhaseCover n →L[ℝ] RealPhaseCover n :=
+  (realPartPhaseCLM n).comp ((L.restrictScalars ℝ).comp (complexifyPhaseCLM n))
+
+theorem hasFDerivAt_realPhaseRestriction {n}
+    {f : ComplexPhaseSpace n → ComplexPhaseSpace n} {x : RealPhaseCover n}
+    (hf : DifferentiableAt ℂ f (complexifyPhase x)) :
+    HasFDerivAt (realPhaseRestriction f)
+      (realPhaseDerivative (fderiv ℂ f (complexifyPhase x))) x :=
+  (realPartPhaseCLM n).hasFDerivAt.comp x
+    ((hf.hasFDerivAt.restrictScalars ℝ).comp x (complexifyPhaseCLM n).hasFDerivAt)
+
+theorem norm_realPhaseDerivative_le {n}
+    (L : ComplexPhaseSpace n →L[ℂ] ComplexPhaseSpace n) :
+    ‖realPhaseDerivative L‖ ≤ ‖L‖ := by
+  apply ContinuousLinearMap.opNorm_le_bound _ (norm_nonneg L)
+  intro x
+  exact (norm_realPartPhase_le _).trans (by simpa using L.le_opNorm (complexifyPhase x))
+
+namespace Iteration.InitialData
+variable {n : ℕ} {Ω₀ : Set (ComplexSpace n)} {δ₁ θ₀ Θ₀ ρ₀ : ℝ≥0} {κ D : ℝ}
+  (b : InitialParameters n δ₁ θ₀ Θ₀ ρ₀ κ D)
+  (h : InitialData n Ω₀ δ₁ θ₀ Θ₀ ρ₀ D)
+
+theorem cumulative_realPhase_value (s : ℕ) {x : RealPhaseCover n}
+    (hx : complexifyPhase x ∈ h.phase b s) :
+    complexifyPhase (realPhaseRestriction (h.cumulative b s) x) =
+      h.cumulative b s (complexifyPhase x) := by
+  apply complexifyPhase_realPartPhase_of_conj
+  have hr := h.cumulative_real b s _ hx
+  rw [conjPhase_complexifyPhase] at hr
+  exact hr.symm
+
+theorem cumulative_real_derivative (s : ℕ) {x : RealPhaseCover n}
+    (hx : complexifyPhase x ∈ h.phase b s) :
+    ‖fderiv ℝ (realPhaseRestriction (h.cumulative b s)) x‖ ≤ (2 : ℝ) ^ s := by
+  rw [(hasFDerivAt_realPhaseRestriction
+    (h.cumulative_analytic b s _ hx).differentiableAt).fderiv]
+  exact (norm_realPhaseDerivative_le _).trans (h.cumulative_derivative b s _ hx)
+
+end Iteration.InitialData
+end KamProject.Arnold1963
diff --git a/LeanPool/ArnoldKAM/Arnold1963/Convergence/SequenceLimit.lean b/LeanPool/ArnoldKAM/Arnold1963/Convergence/SequenceLimit.lean
new file mode 100644
index 0000000000..fab47ad85a
--- /dev/null
+++ b/LeanPool/ArnoldKAM/Arnold1963/Convergence/SequenceLimit.lean
@@ -0,0 +1,57 @@
+/-
+Copyright (c) 2026 Bingqi Yu. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Bingqi Yu
+-/
+
+module
+
+public import Mathlib.Analysis.Normed.Group.FunctionSeries
+public import Mathlib.Topology.Algebra.InfiniteSum.NatInt
+
+/-!
+Uniform limits from summable successive increments, with reusable tail estimates.
+-/
+
+@[expose] public section
+noncomputable section
+open Set Filter Metric
+open scoped Topology
+namespace KamProject.Arnold1963.Convergence
+
+variable {α E : Type*} [NormedAddCommGroup E] [CompleteSpace E]
+
+/-- The initial value plus the infinite sum of successive increments of a sequence. -/
+def sequenceLimit (f : ℕ → α → E) (x : α) : E :=
+  f 0 x + ∑' s, (f (s + 1) x - f s x)
+
+theorem sequenceLimit_tendstoUniformlyOn {f : ℕ → α → E} {U : Set α} {u : ℕ → ℝ}
+    (hu : Summable u) (hf : ∀ s x, x ∈ U → ‖f (s + 1) x - f s x‖ ≤ u s) :
+    TendstoUniformlyOn f (sequenceLimit f) atTop U := by
+  have hs := tendstoUniformlyOn_tsum_nat hu hf
+  apply Metric.tendstoUniformlyOn_iff.mpr
+  intro ε hε
+  filter_upwards [Metric.tendstoUniformlyOn_iff.mp hs ε hε] with s hs x hx
+  have he : f s x = f 0 x + ∑ j ∈ Finset.range s, (f (j + 1) x - f j x) := by
+    rw [Finset.sum_range_sub (fun j => f j x)]
+    abel
+  rw [sequenceLimit, he, dist_add_left]
+  exact hs x hx
+
+theorem sequenceLimit_sub_eq_tsum {f : ℕ → α → E} {x : α} {u : ℕ → ℝ}
+    (hu : Summable u) (hf : ∀ s, ‖f (s + 1) x - f s x‖ ≤ u s) (s : ℕ) :
+    sequenceLimit f x - f s x = ∑' j, (f (j + s + 1) x - f (j + s) x) := by
+  have hi := hu.of_norm_bounded hf
+  have he := hi.sum_add_tsum_nat_add s
+  rw [Finset.sum_range_sub (fun j => f j x)] at he
+  unfold sequenceLimit
+  rw [← he]
+  abel
+
+theorem sequenceLimit_tail_le {f : ℕ → α → E} {x : α} {u : ℕ → ℝ}
+    (hu : Summable u) (hf : ∀ s, ‖f (s + 1) x - f s x‖ ≤ u s) (s : ℕ) :
+    ‖sequenceLimit f x - f s x‖ ≤ ∑' j, u (j + s) := by
+  rw [sequenceLimit_sub_eq_tsum hu hf s]
+  exact tsum_of_norm_bounded ((summable_nat_add_iff s).mpr hu).hasSum (fun j => hf (j + s))
+
+end KamProject.Arnold1963.Convergence
diff --git a/LeanPool/ArnoldKAM/Arnold1963/Dynamics/LimitConjugacy.lean b/LeanPool/ArnoldKAM/Arnold1963/Dynamics/LimitConjugacy.lean
new file mode 100644
index 0000000000..1045bf42a6
--- /dev/null
+++ b/LeanPool/ArnoldKAM/Arnold1963/Dynamics/LimitConjugacy.lean
@@ -0,0 +1,87 @@
+/-
+Copyright (c) 2026 Bingqi Yu. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Bingqi Yu
+-/
+
+module
+
+public import LeanPool.ArnoldKAM.Arnold1963.Dynamics.VectorFields
+public import LeanPool.ArnoldKAM.Arnold1963.Convergence.ComplexLines
+public import Mathlib.Analysis.Complex.RealDeriv
+
+/-!
+Pass the conjugacy to the limit and construct solutions of the original Hamiltonian equation
+for every real time.
+-/
+
+@[expose] public section
+noncomputable section
+open Set Filter
+open scoped NNReal Topology
+namespace KamProject.Arnold1963.Iteration.InitialData
+variable {n : ℕ} {Ω₀ : Set (ComplexSpace n)} {δ₁ θ₀ Θ₀ ρ₀ : ℝ≥0} {κ D : ℝ}
+  (b : InitialParameters n δ₁ θ₀ Θ₀ ρ₀ κ D)
+  (h : InitialData n Ω₀ δ₁ θ₀ Θ₀ ρ₀ D)
+
+theorem limit_conjugacy_complex {p : ComplexSpace n} (hp : p ∈ h.limitDomain b)
+    {q : ComplexSpace n} {t : ℂ}
+    (ht : t ∈ lineDomain (ρ₀ := ρ₀) q (h.limitFrequency b p)) :
+    HasDerivAt (fun u : ℂ => h.limitMap b (p, q + u • h.limitFrequency b p))
+      (h.vectorField b 0 (h.limitMap b (p, q + t • h.limitFrequency b p))) t := by
+  let z : ComplexPhaseSpace n := (p, q + t • h.limitFrequency b p)
+  have hz : z ∈ h.limitPhase b := h.line_mem_limitPhase b hp ht
+  have hd := (h.line_derivative_uniform b hp q (h.limitFrequency b p)).tendsto_at ht
+  have hx := (h.vectorField_analytic b 0 _ (h.limitMap_maps b hz)).continuousAt.tendsto.comp
+    ((h.cumulative_uniform b).tendsto_at hz)
+  have hl := (hd.sub hx).norm.comp (tendsto_add_atTop_nat 1)
+  have hzero : Tendsto
+      (fun s => ‖deriv (fun u : ℂ => h.cumulative b (s + 1)
+        (p, q + u • h.limitFrequency b p)) t - h.vectorField b 0 (h.cumulative b (s + 1) z)‖)
+      atTop (𝓝 0) := by
+    apply squeeze_zero (fun _ => norm_nonneg _) _
+      (b.weighted_beta_tendsto_zero.comp (tendsto_add_atTop_nat 1))
+    intro s
+    rw [h.line_derivative_eq b hp ht (s + 1)]
+    exact h.approximate_conjugacy b s hz
+  have he := tendsto_nhds_unique hl hzero
+  have ha := h.limitMap_line_analytic b hp q (h.limitFrequency b p) t ht
+  have hderiv := ha.differentiableAt.hasDerivAt
+  rw [sub_eq_zero.mp (norm_eq_zero.mp he)] at hderiv
+  exact hderiv
+
+theorem real_time_mem_lineDomain {p : RealSpace n} (hp : p ∈ realSlice (h.limitDomain b))
+    (q : RealSpace n) (t : ℝ) :
+    (t : ℂ) ∈ lineDomain (ρ₀ := ρ₀) (complexify q) (h.limitFrequency b (complexify p)) := by
+  have he := h.limitFrequency_real_value b hp
+  change ‖imagPart (complexify q + (t : ℂ) • h.limitFrequency b (complexify p))‖ < _
+  rw [← he]
+  have hi : imagPart (complexify q + (t : ℂ) •
+      complexify (realPart (h.limitFrequency b (complexify p)))) = 0 := by
+    ext j
+    simp [imagPart, complexify]
+  rw [hi, norm_zero]
+  exact div_pos (show (0 : ℝ) < ρ₀ from b.width_pos) (by norm_num)
+
+/-- The limiting phase transformation applied to uniform rotation with the limiting frequency. -/
+def orbit (p q : RealSpace n) (t : ℝ) : ComplexPhaseSpace n :=
+  h.limitMap b (complexify p, complexify q + (t : ℂ) • h.limitFrequency b (complexify p))
+
+theorem orbit_hasDerivAt {p : RealSpace n} (hp : p ∈ realSlice (h.limitDomain b))
+    (q : RealSpace n) (t : ℝ) :
+    HasDerivAt (h.orbit b p q) (h.vectorField b 0 (h.orbit b p q t)) t := by
+  have hc := h.limit_conjugacy_complex b (p := complexify p) (q := complexify q)
+    hp (h.real_time_mem_lineDomain b hp q t)
+  change HasDerivAt (fun u : ℝ => h.limitMap b
+    (complexify p, complexify q + (u : ℂ) • h.limitFrequency b (complexify p))) _ t
+  simpa only [Function.comp_def, Complex.ofRealCLM_apply, Complex.ofReal_one, one_smul,
+    orbit] using! hc.scomp t Complex.ofRealCLM.hasDerivAt
+
+theorem orbit_mem_initial {p : RealSpace n} (hp : p ∈ realSlice (h.limitDomain b))
+    (q : RealSpace n) (t : ℝ) : h.orbit b p q t ∈ h.phase b 0 :=
+  h.limitMap_maps b (h.line_mem_limitPhase b hp (h.real_time_mem_lineDomain b hp q t))
+
+theorem orbit_initial (p q : RealSpace n) : h.orbit b p q 0 =
+    h.limitMap b (complexifyPhase (p, q)) := by simp [orbit, complexifyPhase]
+
+end KamProject.Arnold1963.Iteration.InitialData
diff --git a/LeanPool/ArnoldKAM/Arnold1963/Dynamics/OrbitUniqueness.lean b/LeanPool/ArnoldKAM/Arnold1963/Dynamics/OrbitUniqueness.lean
new file mode 100644
index 0000000000..aa03c78ab2
--- /dev/null
+++ b/LeanPool/ArnoldKAM/Arnold1963/Dynamics/OrbitUniqueness.lean
@@ -0,0 +1,62 @@
+/-
+Copyright (c) 2026 Bingqi Yu. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Bingqi Yu
+-/
+
+module
+
+public import LeanPool.ArnoldKAM.Arnold1963.Dynamics.RealOrbits
+public import Mathlib.Analysis.ODE.ExistUnique
+public import Mathlib.Analysis.Calculus.ContDiff.RCLike
+public import Mathlib.Topology.Connected.Clopen
+
+/-!
+Uniqueness of analytic autonomous trajectories, including trajectories from different labels.
+-/
+
+@[expose] public section
+noncomputable section
+open Set Filter
+open scoped Topology NNReal
+namespace KamProject.Arnold1963
+
+theorem eq_of_analytic_autonomous_orbits {E : Type*} [NormedAddCommGroup E]
+    [NormedSpace ℂ E] [NormedSpace ℝ E] [CompleteSpace E]
+    {X : E → E} {f g : ℝ → E}
+    (ha : ∀ t, AnalyticAt ℂ X (f t))
+    (hf : ∀ t, HasDerivAt f (X (f t)) t)
+    (hg : ∀ t, HasDerivAt g (X (g t)) t)
+    (he : f 0 = g 0) : f = g := by
+  have hc : IsClosed {t | f t = g t} :=
+    isClosed_eq (continuous_iff_continuousAt.mpr fun t => (hf t).continuousAt)
+      (continuous_iff_continuousAt.mpr fun t => (hg t).continuousAt)
+  have ho : IsOpen {t | f t = g t} := by
+    apply isOpen_iff_mem_nhds.mpr
+    intro t ht
+    change f t = g t at ht
+    obtain ⟨K, U, hU, hL⟩ := (ha t).contDiffAt.exists_lipschitzOnWith
+    have hfu : ∀ᶠ s in 𝓝 t, f s ∈ U := (hf t).continuousAt hU
+    have hgu : ∀ᶠ s in 𝓝 t, g s ∈ U := (hg t).continuousAt (by simpa only [← ht] using hU)
+    exact ODE_solution_unique_of_eventually (v := fun _ => X) (s := fun _ => U)
+      (Eventually.of_forall fun _ => hL)
+      (hfu.mono fun s hs => ⟨hf s, hs⟩) (hgu.mono fun s hs => ⟨hg s, hs⟩) ht
+  have hu := (show IsClopen {t | f t = g t} from ⟨hc, ho⟩).eq_univ ⟨0, he⟩
+  funext t
+  exact show t ∈ {t | f t = g t} from hu ▸ mem_univ t
+
+namespace Iteration.InitialData
+variable {n : ℕ} {Ω₀ : Set (ComplexSpace n)} {δ₁ θ₀ Θ₀ ρ₀ : ℝ≥0} {κ D : ℝ}
+  (b : InitialParameters n δ₁ θ₀ Θ₀ ρ₀ κ D)
+  (h : InitialData n Ω₀ δ₁ θ₀ Θ₀ ρ₀ D)
+
+theorem orbit_eq_of_initial_eq {p p' : RealSpace n}
+    (hp : p ∈ realSlice (h.limitDomain b)) (hp' : p' ∈ realSlice (h.limitDomain b))
+    (q q' : RealSpace n) (he : h.orbit b p q 0 = h.orbit b p' q' 0) :
+    h.orbit b p q = h.orbit b p' q' :=
+  eq_of_analytic_autonomous_orbits
+    (fun t => h.vectorField_analytic b 0 _ (h.orbit_mem_initial b hp q t))
+    (h.orbit_hasDerivAt b hp q) (h.orbit_hasDerivAt b hp' q') he
+
+end Iteration.InitialData
+end KamProject.Arnold1963
diff --git a/LeanPool/ArnoldKAM/Arnold1963/Dynamics/RealOrbits.lean b/LeanPool/ArnoldKAM/Arnold1963/Dynamics/RealOrbits.lean
new file mode 100644
index 0000000000..dfdd36afde
--- /dev/null
+++ b/LeanPool/ArnoldKAM/Arnold1963/Dynamics/RealOrbits.lean
@@ -0,0 +1,94 @@
+/-
+Copyright (c) 2026 Bingqi Yu. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Bingqi Yu
+-/
+
+module
+
+public import LeanPool.ArnoldKAM.Arnold1963.Dynamics.LimitConjugacy
+public import LeanPool.ArnoldKAM.Arnold1963.Geometry.GeneratingTorus
+
+/-!
+Real limit maps, quotient maps, and actual invariant trajectories on the angle torus.
+-/
+
+@[expose] public section
+noncomputable section
+open Set
+open scoped NNReal
+namespace KamProject.Arnold1963.Iteration.InitialData
+variable {n : ℕ} {Ω₀ : Set (ComplexSpace n)} {δ₁ θ₀ Θ₀ ρ₀ : ℝ≥0} {κ D : ℝ}
+  (b : InitialParameters n δ₁ θ₀ Θ₀ ρ₀ κ D)
+  (h : InitialData n Ω₀ δ₁ θ₀ Θ₀ ρ₀ D)
+
+/-- The real-coordinate restriction of the limiting phase transformation. -/
+def realLimitMap (x : RealPhaseCover n) : RealPhaseCover n :=
+  realPartPhase (h.limitMap b (complexifyPhase x))
+
+/-- The limiting phase transformation descended to real angles modulo `2π`. -/
+def torusLimitMap (x : RealPhaseSpace n) : RealPhaseSpace n :=
+  torusProjection (h.realLimitMap b (torusRepresentative x))
+
+theorem realLimitMap_shift {x : RealPhaseCover n}
+    (hx : x.1 ∈ realSlice (h.limitDomain b)) (k : FourierIndex n) :
+    h.realLimitMap b (realPhaseShift k x) = realPhaseShift k (h.realLimitMap b x) := by
+  have hz : complexifyPhase x ∈ h.limitPhase b :=
+    h.commonPhase_subset b ⟨hx, complexify_mem_angleStrip _ _⟩
+  unfold realLimitMap
+  rw [complexifyPhase_shift, h.limitMap_periodic b hz]
+  exact realPartPhase_shift k _
+
+theorem torusLimitMap_projection {x : RealPhaseCover n}
+    (hx : x.1 ∈ realSlice (h.limitDomain b)) :
+    h.torusLimitMap b (torusProjection x) = torusProjection (h.realLimitMap b x) := by
+  obtain ⟨k, hk⟩ := (torusProjection_eq_iff (torusRepresentative (torusProjection x)) x).mp
+    (torusProjection_representative _)
+  unfold torusLimitMap
+  rw [hk, h.realLimitMap_shift b hx, torusProjection_shift]
+
+theorem realLimitMap_maps {x : RealPhaseCover n}
+    (hx : x.1 ∈ realSlice (h.limitDomain b)) :
+    (h.realLimitMap b x).1 ∈ realSlice h.domain := by
+  have hz : complexifyPhase x ∈ h.limitPhase b :=
+    h.commonPhase_subset b ⟨hx, complexify_mem_angleStrip _ _⟩
+  have hm := (h.limitMap_maps b hz).1
+  have he := congrArg Prod.fst (h.limitMap_real_value b hx)
+  change (complexifyPhase (h.realLimitMap b x)).1 ∈ h.domain
+  rw [realLimitMap, he]
+  exact hm
+
+theorem torusLimitMap_maps : MapsTo (h.torusLimitMap b)
+    (realSlice (h.limitDomain b) ×ˢ (univ : Set (RealTorus n)))
+    (realSlice h.domain ×ˢ (univ : Set (RealTorus n))) := by
+  intro x hx
+  exact ⟨h.realLimitMap_maps b (x := torusRepresentative x) hx.1, mem_univ _⟩
+
+theorem orbit_eq_real_angle {p : RealSpace n} (hp : p ∈ realSlice (h.limitDomain b))
+    (q : RealSpace n) (t : ℝ) : h.orbit b p q t =
+      h.limitMap b (complexifyPhase (p, q + t • realPart (h.limitFrequency b (complexify p)))) := by
+  unfold orbit
+  congr 1
+  apply Prod.ext
+  · rfl
+  change complexify q + (t : ℂ) • h.limitFrequency b (complexify p) =
+    complexify (q + t • realPart (h.limitFrequency b (complexify p)))
+  rw [← h.limitFrequency_real_value b hp]
+  ext j
+  simp [complexify, smul_eq_mul]
+
+theorem orbit_real_value {p : RealSpace n} (hp : p ∈ realSlice (h.limitDomain b))
+    (q : RealSpace n) (t : ℝ) :
+    complexifyPhase (realPartPhase (h.orbit b p q t)) = h.orbit b p q t := by
+  rw [h.orbit_eq_real_angle b hp q t]
+  exact h.limitMap_real_value b (x := (p, q + t • realPart (h.limitFrequency b (complexify p)))) hp
+
+theorem orbit_mem_torus_image {p : RealSpace n} (hp : p ∈ realSlice (h.limitDomain b))
+    (q : RealSpace n) (t : ℝ) : torusProjection (realPartPhase (h.orbit b p q t)) ∈
+      h.torusLimitMap b '' ({p} ×ˢ (univ : Set (RealTorus n))) := by
+  let x : RealPhaseCover n := (p, q + t • realPart (h.limitFrequency b (complexify p)))
+  refine ⟨torusProjection x, ⟨rfl, mem_univ _⟩, ?_⟩
+  rw [h.torusLimitMap_projection b (x := x) hp, h.orbit_eq_real_angle b hp q t]
+  rfl
+
+end KamProject.Arnold1963.Iteration.InitialData
diff --git a/LeanPool/ArnoldKAM/Arnold1963/Dynamics/TorusDensity.lean b/LeanPool/ArnoldKAM/Arnold1963/Dynamics/TorusDensity.lean
new file mode 100644
index 0000000000..180f2be855
--- /dev/null
+++ b/LeanPool/ArnoldKAM/Arnold1963/Dynamics/TorusDensity.lean
@@ -0,0 +1,162 @@
+/-
+Copyright (c) 2026 Bingqi Yu. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Bingqi Yu
+-/
+
+module
+
+public import LeanPool.ArnoldKAM.Arnold1963.Geometry.RealCover
+public import Mathlib.Analysis.Fourier.AddCircleMulti
+public import Mathlib.MeasureTheory.Group.Integral
+public import Mathlib.Topology.MetricSpace.HausdorffDistance
+
+/-!
+Density of nonresonant linear torus flows, proved through Fourier coefficients and closure.
+-/
+
+@[expose] public section
+noncomputable section
+open Set MeasureTheory Metric
+namespace KamProject.Arnold1963
+
+/-- Normalized Haar measure used in the Fourier proof of orbit density. -/
+local instance densityUnitCircleMeasureSpace : MeasureSpace UnitAddCircle :=
+  ⟨AddCircle.haarAddCircle⟩
+local instance densityUnitCircleHaar :
+    Measure.IsAddHaarMeasure (volume : Measure UnitAddCircle) :=
+  inferInstanceAs (Measure.IsAddHaarMeasure AddCircle.haarAddCircle)
+local instance densityUnitCircleProbability :
+    IsProbabilityMeasure (volume : Measure UnitAddCircle) :=
+  inferInstanceAs (IsProbabilityMeasure AddCircle.haarAddCircle)
+
+/-- A uniform rotation on the unit-period real torus. -/
+def unitTorusLine {n : ℕ} (v : RealSpace n) (t : ℝ) : UnitAddTorus (Fin n) :=
+  fun j => (t * v j : ℝ)
+
+theorem unitTorusLine_add {n : ℕ} (v : RealSpace n) (s t : ℝ) :
+    unitTorusLine v (s + t) = unitTorusLine v s + unitTorusLine v t := by
+  ext j
+  simp [unitTorusLine, add_mul]
+
+theorem mFourier_translate {n : ℕ} (k : FourierIndex n)
+    (x y : UnitAddTorus (Fin n)) :
+    UnitAddTorus.mFourier k (x + y) =
+      UnitAddTorus.mFourier k x * UnitAddTorus.mFourier k y := by
+  simp only [UnitAddTorus.mFourier, ContinuousMap.coe_mk, Pi.add_apply, fourier_apply,
+    smul_add, AddCircle.toCircle_add, Circle.coe_mul, Finset.prod_mul_distrib]
+
+theorem mFourier_unitTorusLine {n : ℕ} (k : FourierIndex n) (v : RealSpace n) (t : ℝ) :
+    UnitAddTorus.mFourier k (unitTorusLine v t) =
+      Complex.exp (2 * Real.pi * Complex.I * (t : ℂ) *
+        ((∑ j, (k j : ℝ) * v j : ℝ) : ℂ)) := by
+  simp only [UnitAddTorus.mFourier, unitTorusLine, ContinuousMap.coe_mk, fourier_coe_apply,
+    Complex.ofReal_one, div_one, Complex.ofReal_mul, Complex.ofReal_sum,
+    Complex.ofReal_intCast]
+  rw [← Complex.exp_sum, Finset.mul_sum]
+  congr 1
+  apply Finset.sum_congr rfl
+  intro j _
+  ring
+
+theorem invariant_under_nonresonant_line_constant {n : ℕ} (v : RealSpace n)
+    (hnr : ∀ k : FourierIndex n, k ≠ 0 → ∑ j, (k j : ℝ) * v j ≠ 0)
+    (f : C(UnitAddTorus (Fin n), ℂ))
+    (hi : ∀ t x, f (unitTorusLine v t + x) = f x) :
+    ∀ x y, f x = f y := by
+  classical
+  have hc : ∀ k : FourierIndex n, k ≠ 0 → UnitAddTorus.mFourierCoeff f k = 0 := by
+    intro k hk
+    let a : ℝ := ∑ j, ((-k) j : ℝ) * v j
+    have ha : a ≠ 0 := hnr (-k) (neg_ne_zero.mpr hk)
+    have hm : UnitAddTorus.mFourier (-k) (unitTorusLine v (1 / (2 * a))) = -1 := by
+      rw [mFourier_unitTorusLine]
+      change Complex.exp (2 * Real.pi * Complex.I * ((1 / (2 * a) : ℝ) : ℂ) * (a : ℂ)) = -1
+      have haz : (a : ℂ) ≠ 0 := Complex.ofReal_ne_zero.mpr ha
+      convert Complex.exp_pi_mul_I using 1
+      push_cast
+      field_simp
+    apply integral_eq_zero_of_add_left_eq_neg (g := unitTorusLine v (1 / (2 * a)))
+    intro x
+    change UnitAddTorus.mFourier (-k) (unitTorusLine v (1 / (2 * a)) + x) *
+      f (unitTorusLine v (1 / (2 * a)) + x) = -(UnitAddTorus.mFourier (-k) x * f x)
+    rw [mFourier_translate, hi, hm]
+    ring
+  have hs : Summable (UnitAddTorus.mFourierCoeff f) :=
+    summable_of_ne_finset_zero (s := {0}) (by simpa using hc)
+  have he (x : UnitAddTorus (Fin n)) : f x = UnitAddTorus.mFourierCoeff f 0 := by
+    rw [← (UnitAddTorus.hasSum_mFourier_series_apply_of_summable hs x).tsum_eq,
+      tsum_eq_single 0]
+    · simp [UnitAddTorus.mFourier_zero]
+    · intro k hk
+      simp [hc k hk]
+  exact fun x y => (he x).trans (he y).symm
+
+theorem denseRange_unitTorusLine {n : ℕ} (v : RealSpace n)
+    (hnr : ∀ k : FourierIndex n, k ≠ 0 → ∑ j, (k j : ℝ) * v j ≠ 0) :
+    DenseRange (unitTorusLine v) := by
+  let S := range (unitTorusLine v)
+  have hS : S.Nonempty := ⟨_, ⟨0, rfl⟩⟩
+  let f : C(UnitAddTorus (Fin n), ℂ) :=
+    ⟨fun x => (infDist x S : ℂ), Complex.continuous_ofReal.comp (continuous_infDist_pt S)⟩
+  have hi (t : ℝ) (x : UnitAddTorus (Fin n)) : f (unitTorusLine v t + x) = f x := by
+    have he : (fun y => unitTorusLine v t + y) '' S = S := by
+      ext y
+      constructor
+      · rintro ⟨_, ⟨s, rfl⟩, rfl⟩
+        exact ⟨t + s, unitTorusLine_add v t s⟩
+      · rintro ⟨s, rfl⟩
+        refine ⟨unitTorusLine v (s - t), ⟨s - t, rfl⟩, ?_⟩
+        change unitTorusLine v t + unitTorusLine v (s - t) = unitTorusLine v s
+        rw [← unitTorusLine_add]
+        congr 1
+        ring
+    have hh := infDist_image (isometry_add_left (unitTorusLine v t)) (x := x) (t := S)
+    rw [he] at hh
+    exact congrArg Complex.ofReal hh
+  have he := invariant_under_nonresonant_line_constant v hnr f hi
+  intro x
+  apply (mem_closure_iff_infDist_zero hS).mpr
+  have hh := he x (unitTorusLine v 0)
+  change (infDist x S : ℂ) = (infDist (unitTorusLine v 0) S : ℂ) at hh
+  rw [infDist_zero_of_mem (show unitTorusLine v 0 ∈ S from ⟨0, rfl⟩)] at hh
+  exact Complex.ofReal_eq_zero.mp hh
+
+/-- A real-angle trajectory on the torus with period `2π`. -/
+def realTorusLine {n : ℕ} (v q : RealSpace n) (t : ℝ) : RealTorus n :=
+  fun j => (q j + t * v j : ℝ)
+
+theorem denseRange_realTorusLine {n : ℕ} (v q : RealSpace n)
+    (hnr : ∀ k : FourierIndex n, k ≠ 0 → ∑ j, (k j : ℝ) * v j ≠ 0) :
+    DenseRange (realTorusLine v q) := by
+  have hT : (2 * Real.pi : ℝ) ≠ 0 := by positivity
+  let w : RealSpace n := fun j => v j / (2 * Real.pi)
+  have hw : ∀ k : FourierIndex n, k ≠ 0 → ∑ j, (k j : ℝ) * w j ≠ 0 := by
+    intro k hk he
+    apply hnr k hk
+    have hh : (∑ j, (k j : ℝ) * v j) / (2 * Real.pi) = 0 := by
+      simpa only [w, ← mul_div_assoc, ← Finset.sum_div] using he
+    exact (div_eq_zero_iff.mp hh).resolve_right hT
+  let e : UnitAddTorus (Fin n) ≃ₜ RealTorus n := Homeomorph.piCongrRight
+    (fun _ => AddCircle.homeomorphAddCircle 1 (2 * Real.pi) one_ne_zero hT)
+  have hd := e.surjective.denseRange.comp (denseRange_unitTorusLine w hw) e.continuous
+  have he : e ∘ unitTorusLine w = realTorusLine v 0 := by
+    funext t
+    ext j
+    change ((t * (v j / (2 * Real.pi)) * (1⁻¹ * (2 * Real.pi)) : ℝ) :
+      AddCircle (2 * Real.pi)) = ((0 + t * v j : ℝ) : AddCircle (2 * Real.pi))
+    congr 1
+    field_simp
+    ring
+  rw [he] at hd
+  let a : RealTorus n := fun j => (q j : AddCircle (2 * Real.pi))
+  have ha : Function.Surjective (fun x : RealTorus n => a + x) := fun y => ⟨y - a, by abel_nf⟩
+  have hh := ha.denseRange.comp hd (by fun_prop)
+  have he' : (fun x : RealTorus n => a + x) ∘ realTorusLine v 0 = realTorusLine v q := by
+    funext t
+    ext j
+    simp [realTorusLine, a]
+  rw [he'] at hh
+  exact hh
+
+end KamProject.Arnold1963
diff --git a/LeanPool/ArnoldKAM/Arnold1963/Dynamics/VectorFields.lean b/LeanPool/ArnoldKAM/Arnold1963/Dynamics/VectorFields.lean
new file mode 100644
index 0000000000..e2ed5f5e16
--- /dev/null
+++ b/LeanPool/ArnoldKAM/Arnold1963/Dynamics/VectorFields.lean
@@ -0,0 +1,95 @@
+/-
+Copyright (c) 2026 Bingqi Yu. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Bingqi Yu
+-/
+
+module
+
+public import LeanPool.ArnoldKAM.Arnold1963.Convergence.Frequency
+
+/-!
+Actual Hamiltonian vector fields at each stage, their conjugacies, and vanishing error bounds.
+-/
+
+@[expose] public section
+noncomputable section
+open Set Filter
+open scoped NNReal Topology
+namespace KamProject.Arnold1963.Iteration.InitialData
+variable {n : ℕ} {Ω₀ : Set (ComplexSpace n)} {δ₁ θ₀ Θ₀ ρ₀ : ℝ≥0} {κ D : ℝ}
+  (b : InitialParameters n δ₁ θ₀ Θ₀ ρ₀ κ D)
+  (h : InitialData n Ω₀ δ₁ θ₀ Θ₀ ρ₀ D)
+
+/-- The Hamiltonian vector field at the specified iteration stage. -/
+def vectorField (s : ℕ) : ComplexPhaseSpace n → ComplexPhaseSpace n :=
+  hamiltonianVectorField (h.hamiltonian b s)
+
+theorem hamiltonian_analytic (s : ℕ) : AnalyticOnNhd ℂ (h.hamiltonian b s) (h.phase b s) := by
+  intro z hz
+  exact (((h.state b s).input.analytic z.1 hz.1).comp analyticAt_fst).add
+    ((h.state b s).perturbation.analytic z hz)
+
+theorem vectorField_analytic (s : ℕ) : AnalyticOnNhd ℂ (h.vectorField b s) (h.phase b s) := by
+  intro z hz
+  exact (analyticAt_qGradient (h.hamiltonian_analytic b s z hz)).neg.prod
+    (analyticAt_pGradient (h.hamiltonian_analytic b s z hz))
+
+theorem vectorField_split (s : ℕ) {z : ComplexPhaseSpace n} (hz : z ∈ h.phase b s) :
+    h.vectorField b s z = (0, h.frequency b s z.1) +
+      hamiltonianVectorField (h.state b s).perturbation.toFun z := by
+  have ha := (h.state b s).input.analytic z.1 hz.1
+  have hf := (h.state b s).perturbation.analytic z hz
+  change hamiltonianVectorField (((h.state b s).integrable ∘ Prod.fst) +
+    (h.state b s).perturbation.toFun) z = _
+  rw [hamiltonianVectorField_add (ha.comp analyticAt_fst).differentiableAt hf.differentiableAt,
+    hamiltonianVectorField_actionOnly z ha.differentiableAt]
+  rfl
+
+theorem vectorField_conjugacy (s : ℕ) {z : ComplexPhaseSpace n} (hz : z ∈ h.phase b s) :
+    fderiv ℂ (h.cumulative b s) z (h.vectorField b s z) =
+      h.vectorField b 0 (h.cumulative b s z) := by
+  have hh := (h.cumulative_canonical b s z hz).map_hamiltonianVectorField
+    (h.hamiltonian_analytic b 0 _ (h.cumulative_maps b s hz)).differentiableAt
+  have he : h.hamiltonian b 0 ∘ h.cumulative b s = h.hamiltonian b s :=
+    funext (h.cumulative_identity b s)
+  rw [he] at hh
+  exact hh
+
+theorem vectorField_limit_error (s : ℕ) {z : ComplexPhaseSpace n} (hz : z ∈ h.limitPhase b) :
+    ‖h.vectorField b (s + 1) z - (0, h.limitFrequency b z.1)‖ < (beta δ₁ (s + 1) : ℝ) := by
+  have hp : z.1 ∈ h.limitDomain b := mem_iInter.mpr fun j => (h.limitPhase_subset b j hz).1
+  have hr := (norm_hamiltonianVectorField_le (h.state b (s + 1)).perturbation.toFun z).trans_lt
+    (h.remainder_derivative b s (h.limitPhase_subset b (s + 1) hz))
+  have hf := h.limitFrequency_tail b hp (s + 1)
+  have hd : (delta δ₁ s : ℝ) < 1 / 4 := (b.delta_step_le s).trans_lt b.delta_quarter
+  have hβ : (0 : ℝ) < beta δ₁ (s + 1) := pow_pos (b.delta_step_pos _) 3
+  rw [h.vectorField_split b (s + 1) (h.limitPhase_subset b (s + 1) hz)]
+  have he : (0, h.frequency b (s + 1) z.1) +
+      hamiltonianVectorField (h.state b (s + 1)).perturbation.toFun z -
+      (0, h.limitFrequency b z.1) =
+    hamiltonianVectorField (h.state b (s + 1)).perturbation.toFun z +
+      (0, h.frequency b (s + 1) z.1 - h.limitFrequency b z.1) := by
+    ext j <;> simp only [Prod.fst_add, Prod.snd_add, Prod.fst_sub, Prod.snd_sub,
+      Pi.add_apply, Pi.sub_apply, Pi.zero_apply] <;> abel
+  rw [he]
+  have hnorm : ‖((0 : ComplexSpace n), h.frequency b (s + 1) z.1 - h.limitFrequency b z.1)‖ =
+      ‖h.limitFrequency b z.1 - h.frequency b (s + 1) z.1‖ := by
+    simp only [Prod.norm_def, norm_zero, max_eq_right (norm_nonneg _), norm_sub_rev]
+  have ht := norm_add_le (hamiltonianVectorField (h.state b (s + 1)).perturbation.toFun z)
+    (0, h.frequency b (s + 1) z.1 - h.limitFrequency b z.1)
+  rw [hnorm] at ht
+  nlinarith
+
+theorem approximate_conjugacy (s : ℕ) {z : ComplexPhaseSpace n} (hz : z ∈ h.limitPhase b) :
+    ‖fderiv ℂ (h.cumulative b (s + 1)) z (0, h.limitFrequency b z.1) -
+      h.vectorField b 0 (h.cumulative b (s + 1) z)‖ ≤
+      (2 : ℝ) ^ (s + 1) * beta δ₁ (s + 1) := by
+  rw [← h.vectorField_conjugacy b (s + 1) (h.limitPhase_subset b (s + 1) hz),
+    ← map_sub]
+  exact ((fderiv ℂ (h.cumulative b (s + 1)) z).le_opNorm _).trans
+    (mul_le_mul (h.cumulative_derivative b (s + 1) z (h.limitPhase_subset b (s + 1) hz))
+      (by simpa only [norm_sub_rev] using (h.vectorField_limit_error b s hz).le)
+      (norm_nonneg _) (by positivity))
+
+end KamProject.Arnold1963.Iteration.InitialData
diff --git a/LeanPool/ArnoldKAM/Arnold1963/Geometry/CorrectedChart.lean b/LeanPool/ArnoldKAM/Arnold1963/Geometry/CorrectedChart.lean
new file mode 100644
index 0000000000..0b43915f23
--- /dev/null
+++ b/LeanPool/ArnoldKAM/Arnold1963/Geometry/CorrectedChart.lean
@@ -0,0 +1,91 @@
+/-
+Copyright (c) 2026 Bingqi Yu. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Bingqi Yu
+-/
+
+module
+
+public import LeanPool.ArnoldKAM.Arnold1963.Geometry.FrequencyChart
+
+/-!
+Construct the corrected analytic chart from the original chart and a small frequency shift,
+including local two-sided inverse identities.
+-/
+
+@[expose] public section
+noncomputable section
+open Set Function Filter Metric
+open scoped NNReal Topology
+namespace KamProject.Arnold1963
+
+theorem correctedFrequency_chart {n : ℕ}
+    {A g Δ : ComplexSpace n → ComplexSpace n} {G Ω H V U : Set (ComplexSpace n)}
+    {β κ : ℝ≥0} (c : AnalyticFrequencyChart A g G Ω)
+    (d : FrequencyShiftData (Δ ∘ g) V β κ)
+    (hV : V ⊆ Ω) (hgV : MapsTo g V H) (hHG : H ⊆ G)
+    (hΔ : AnalyticOnNhd ℂ Δ H) (hVc : ConjInvariant V)
+    (hΔc : ∀ p ∈ H, Δ (conjVec p) = conjVec (Δ p))
+    (hU : IsCompact U) (hUc : ConjInvariant U) (hUt : U ⊆ frequencyInverseTarget V β) :
+    AnalyticFrequencyChart (fun p => A p + Δ p) (correctedFrequencyInverse g Δ V β)
+      (correctedFrequencyInverse g Δ V β '' U) U := by
+  let B := correctedFrequencyInverse g Δ V β
+  have hb : AnalyticOnNhd ℂ B U :=
+    fun y hy => correctedFrequencyInverse_analytic d (c.inverse_analytic.mono hV) y (hUt hy)
+  have hmap : ∀ y ∈ U, B y ∈ H := fun y hy =>
+    hgV (erosion_subset _ _ (d.inverse_spec (hUt hy)).1)
+  have hr : ∀ y ∈ U, A (B y) + Δ (B y) = y :=
+    fun y hy => correctedFrequencyInverse_right d (fun x hx => c.right (hV hx)) (hUt hy)
+  have ha : ∀ x ∈ V, (Δ ∘ g) (conjVec x) = conjVec ((Δ ∘ g) x) := by
+    intro x hx
+    dsimp only [Function.comp_apply]
+    rw [c.inverse_conj (hV hx), hΔc _ (hgV hx)]
+  have hbc : ∀ y ∈ U, B (conjVec y) = conjVec (B y) := by
+    intro y hy
+    change g (frequencyInverse (Δ ∘ g) V β (conjVec y)) =
+      conjVec (g (frequencyInverse (Δ ∘ g) V β y))
+    rw [d.inverse_conj hVc ha (hUt hy),
+      c.inverse_conj (hV (erosion_subset _ _ (d.inverse_spec (hUt hy)).1))]
+  refine ⟨hU.image_of_continuousOn hb.continuousOn, ?_, hb, ?_, ?_, ?_, ?_, ?_, ?_⟩
+  · rintro p ⟨y, hy, rfl⟩
+    exact (c.analytic _ (hHG (hmap y hy))).add (hΔ _ (hmap y hy))
+  · rintro p ⟨y, hy, rfl⟩
+    change A (B y) + Δ (B y) ∈ U
+    rwa [hr y hy]
+  · intro y hy
+    exact mem_image_of_mem B hy
+  · rintro p ⟨y, hy, rfl⟩
+    let x := frequencyInverse (Δ ∘ g) V β y
+    have hxV : x ∈ V := erosion_subset _ _ (d.inverse_spec (hUt hy)).1
+    have hp : B y ∈ G := hHG (hmap y hy)
+    have hAx : A (B y) = x := c.right (hV hxV)
+    have ht : Tendsto A (𝓝 (B y)) (𝓝 x) := by
+      rw [← hAx]
+      exact (c.analytic _ hp).continuousAt
+    have hs : ∀ᶠ q in 𝓝 (B y), A q ∈ frequencyInverseSource V β :=
+      ht (erosion_mem_nhds d.radius_pos (d.inverse_spec (hUt hy)).1)
+    filter_upwards [c.left_local _ hp, hs] with q hq hqs
+    change g (frequencyInverse (Δ ∘ g) V β (A q + Δ q)) = q
+    have he : A q + Δ q = frequencyShift (Δ ∘ g) (A q) := by
+      simp only [frequencyShift, Function.comp_apply, hq]
+    rw [he]
+    change g (invFunOn (frequencyShift (Δ ∘ g)) (frequencyInverseSource V β)
+      (frequencyShift (Δ ∘ g) (A q))) = q
+    rw [d.shift_injOn.leftInvOn_invFunOn hqs, hq]
+  · intro y hy
+    have hi := d.inverse_analytic_right (hUt hy)
+    have hxΩ := hV (erosion_subset _ _ (d.inverse_spec (hUt hy)).1)
+    have hh : ∀ᶠ z in 𝓝 y, A (g (frequencyInverse (Δ ∘ g) V β z)) =
+        frequencyInverse (Δ ∘ g) V β z := hi.1.continuousAt (c.right_local _ hxΩ)
+    filter_upwards [hh, hi.2] with z hz he
+    change A (g (frequencyInverse (Δ ∘ g) V β z)) +
+      Δ (g (frequencyInverse (Δ ∘ g) V β z)) = z
+    rw [hz]
+    exact he
+  · rintro p ⟨y, hy, rfl⟩
+    exact ⟨conjVec y, hUc _ hy, hbc y hy⟩
+  · rintro p ⟨y, hy, rfl⟩
+    rw [c.map_conj _ (hHG (hmap y hy)), hΔc _ (hmap y hy)]
+    simp only [conjVec_eq_star, star_add, B]
+
+end KamProject.Arnold1963
diff --git a/LeanPool/ArnoldKAM/Arnold1963/Geometry/CovectorTube.lean b/LeanPool/ArnoldKAM/Arnold1963/Geometry/CovectorTube.lean
new file mode 100644
index 0000000000..689de1eefb
--- /dev/null
+++ b/LeanPool/ArnoldKAM/Arnold1963/Geometry/CovectorTube.lean
@@ -0,0 +1,114 @@
+/-
+Copyright (c) 2026 Bingqi Yu. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Bingqi Yu
+-/
+
+module
+
+public import LeanPool.ArnoldKAM.Arnold1963.Geometry.TypeD
+public import LeanPool.ArnoldKAM.Arnold1963.Geometry.Erosion
+public import Mathlib.Tactic.FieldSimp
+public import Mathlib.Tactic.NormNum
+public import Mathlib.Tactic.Positivity
+public import Mathlib.Tactic.SplitIfs
+public import Mathlib.Tactic.Abel
+
+/-!
+Exact images of maximum-norm closed balls under linear forms, and erosion of complex tubes.
+-/
+
+@[expose] public section
+noncomputable section
+open Set Metric
+open scoped NNReal
+namespace KamProject.Arnold1963
+
+theorem covectorLength_nonneg {n} (ℓ : RealSpace n) : 0 ≤ covectorLength ℓ :=
+  Finset.sum_nonneg fun _ _ => abs_nonneg _
+
+theorem realCovectorPairing_add {n} (ℓ : RealSpace n) (x y : ComplexSpace n) :
+    realCovectorPairing ℓ (x + y) = realCovectorPairing ℓ x + realCovectorPairing ℓ y := by
+  simp [realCovectorPairing, mul_add, Finset.sum_add_distrib]
+
+theorem realCovectorPairing_sub {n} (ℓ : RealSpace n) (x y : ComplexSpace n) :
+    realCovectorPairing ℓ (x - y) = realCovectorPairing ℓ x - realCovectorPairing ℓ y := by
+  simp [realCovectorPairing, mul_sub, Finset.sum_sub_distrib]
+
+theorem norm_realCovectorPairing_le {n} (ℓ : RealSpace n) (z : ComplexSpace n) :
+    ‖realCovectorPairing ℓ z‖ ≤ covectorLength ℓ * ‖z‖ := by
+  calc
+    _ ≤ ∑ j, ‖(ℓ j : ℂ) * z j‖ := norm_sum_le _ _
+    _ = ∑ j, |ℓ j| * ‖z j‖ := by simp
+    _ ≤ ∑ j, |ℓ j| * ‖z‖ := Finset.sum_le_sum fun j _ =>
+      mul_le_mul_of_nonneg_left (norm_le_pi_norm z j) (abs_nonneg _)
+    _ = _ := by rw [covectorLength, Finset.sum_mul]
+
+theorem covector_has_lift {n} (ℓ : RealSpace n) (hℓ : 0 < covectorLength ℓ) (w : ℂ) :
+    ∃ v : ComplexSpace n, realCovectorPairing ℓ v = w ∧ ‖v‖ ≤ ‖w‖ / covectorLength ℓ := by
+  classical
+  let s : Fin n → ℝ := fun j => if 0 ≤ ℓ j then 1 else -1
+  have hs : ∀ j, ℓ j * s j = |ℓ j| := by
+    intro j
+    dsimp [s]
+    split_ifs with hj
+    · simp [abs_of_nonneg hj]
+    · simp [abs_of_neg (lt_of_not_ge hj)]
+  let v : ComplexSpace n := fun j => (s j : ℂ) * (w / (covectorLength ℓ : ℂ))
+  refine ⟨v, ?_, ?_⟩
+  · have he : realCovectorPairing ℓ v =
+        (covectorLength ℓ : ℂ) * (w / (covectorLength ℓ : ℂ)) := by
+      simp only [realCovectorPairing, v, ← mul_assoc, ← Complex.ofReal_mul, hs,
+        ← Finset.sum_mul, ← Complex.ofReal_sum, covectorLength]
+    rw [he]
+    field_simp [ne_of_gt hℓ]
+  · apply (complex_norm_le_iff _ (by positivity)).mpr
+    intro j
+    have hsn : |s j| ≤ 1 := by dsimp [s]; split_ifs <;> norm_num
+    calc
+      ‖v j‖ = |s j| * (‖w‖ / covectorLength ℓ) := by
+        simp only [v, norm_mul, Complex.norm_real, Real.norm_eq_abs, norm_div,
+          abs_of_pos hℓ]
+      _ ≤ _ := by
+        simpa using mul_le_mul_of_nonneg_right hsn
+          (by positivity : 0 ≤ ‖w‖ / covectorLength ℓ)
+
+theorem realCovectorPairing_image_closedBall {n} (ℓ : RealSpace n)
+    (hℓ : 0 < covectorLength ℓ) (x : ComplexSpace n) (d : ℝ≥0) :
+    realCovectorPairing ℓ '' closedBall x (d : ℝ) =
+      closedBall (realCovectorPairing ℓ x) ((d : ℝ) * covectorLength ℓ) := by
+  ext w
+  constructor
+  · rintro ⟨z, hz, rfl⟩
+    simp only [mem_closedBall, dist_eq_norm] at hz ⊢
+    rw [← realCovectorPairing_sub]
+    exact (norm_realCovectorPairing_le ℓ _).trans (by
+      simpa only [dist_eq_norm, mul_comm] using mul_le_mul_of_nonneg_left hz hℓ.le)
+  · intro hw
+    obtain ⟨v, hv, hn⟩ := covector_has_lift ℓ hℓ (w - realCovectorPairing ℓ x)
+    refine ⟨x + v, ?_, ?_⟩
+    · simp only [mem_closedBall, dist_eq_norm] at hw ⊢
+      rw [add_sub_cancel_left]
+      exact hn.trans ((div_le_iff₀ hℓ).mpr hw)
+    · rw [realCovectorPairing_add, hv]
+      abel
+
+theorem erosion_tube_complement {n} (ℓ : RealSpace n) (hℓ : 0 < covectorLength ℓ)
+    (c a : ℝ) (ha : 0 < a) (d : ℝ≥0) :
+    erosion {z | a ≤ ‖realCovectorPairing ℓ z - (c : ℂ)‖} d =
+      {z | a + (d : ℝ) * covectorLength ℓ ≤ ‖realCovectorPairing ℓ z - (c : ℂ)‖} := by
+  ext x
+  have he : x ∈ erosion {z | a ≤ ‖realCovectorPairing ℓ z - (c : ℂ)‖} d ↔
+      Disjoint (realCovectorPairing ℓ '' closedBall x (d : ℝ)) (ball (c : ℂ) a) := by
+    rw [disjoint_left]
+    constructor
+    · rintro hx _ ⟨z, hz, rfl⟩ hw
+      exact (not_lt_of_ge (hx hz)) (by simpa only [mem_ball, dist_eq_norm] using hw)
+    · intro hx z hz
+      exact le_of_not_gt (fun hw => hx ⟨z, hz, rfl⟩ (by
+        simpa only [mem_ball, dist_eq_norm] using hw))
+  rw [he, realCovectorPairing_image_closedBall ℓ hℓ,
+    disjoint_closedBall_ball_iff (mul_nonneg d.coe_nonneg hℓ.le) ha]
+  simp only [mem_ofPred_eq, dist_eq_norm, add_comm]
+
+end KamProject.Arnold1963
diff --git a/LeanPool/ArnoldKAM/Arnold1963/Geometry/DomainCover.lean b/LeanPool/ArnoldKAM/Arnold1963/Geometry/DomainCover.lean
new file mode 100644
index 0000000000..1820c40b6d
--- /dev/null
+++ b/LeanPool/ArnoldKAM/Arnold1963/Geometry/DomainCover.lean
@@ -0,0 +1,75 @@
+/-
+Copyright (c) 2026 Bingqi Yu. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Bingqi Yu
+-/
+
+module
+
+public import LeanPool.ArnoldKAM.Arnold1963.Geometry.Erosion
+public import LeanPool.ArnoldKAM.Arnold1963.Analysis.MeanValue
+public import Mathlib.Topology.Order.IntermediateValue
+public import Mathlib.Analysis.Normed.Affine.AddTorsor
+public import Mathlib.Tactic.Linarith
+
+/-!
+Coverage of eroded domains via continuous induction along a segment, allowing nonconvex
+compact domains and proving the required boundary behavior from local inverses.
+-/
+
+@[expose] public section
+noncomputable section
+open Set Filter Metric AffineMap
+open scoped Topology NNReal
+namespace KamProject.Arnold1963
+
+theorem mem_interior_of_local_inverse {n : ℕ}
+    {A g : ComplexSpace n → ComplexSpace n} {G Ω : Set (ComplexSpace n)}
+    {p : ComplexSpace n} (hA : ContinuousAt A p) (hg : MapsTo g Ω G)
+    (hl : ∀ᶠ x in 𝓝 p, g (A x) = x) (hp : A p ∈ interior Ω) : p ∈ interior G := by
+  apply mem_interior_iff_mem_nhds.mpr
+  have hm : ∀ᶠ x in 𝓝 p, A x ∈ Ω := hA (mem_interior_iff_mem_nhds.mp hp)
+  filter_upwards [hm, hl] with x hx he
+  simpa only [he] using hg hx
+
+theorem mem_erosion_of_image_buffer {n : ℕ}
+    {A : ComplexSpace n → ComplexSpace n} {G Ω : Set (ComplexSpace n)}
+    {C r : ℝ≥0} (hG : IsClosed G) (hC : 0 < C)
+    (hA : AnalyticOnNhd ℂ A G) (hd : ∀ p ∈ G, ‖fderiv ℂ A p‖ ≤ C)
+    (hback : ∀ p ∈ G, A p ∈ interior Ω → p ∈ interior G)
+    {p : ComplexSpace n} (hp : p ∈ G) (hy : A p ∈ erosion Ω (C * r)) :
+    p ∈ erosion G r := by
+  by_cases hr : r = 0
+  · simpa [hr] using hp
+  have hrpos : (0 : ℝ) < r := NNReal.coe_pos.mpr (pos_iff_ne_zero.mpr hr)
+  intro z hz
+  let l : ℝ →ᵃ[ℝ] ComplexSpace n := lineMap p z
+  have hl : Continuous l := lineMap_continuous
+  have hzero : (0 : ℝ) ∈ l ⁻¹' G := by simpa [l] using hp
+  have hall : Icc (0 : ℝ) 1 ⊆ l ⁻¹' G := by
+    apply ((hG.preimage hl).inter isClosed_Icc).Icc_subset_of_forall_mem_nhdsGT_of_Icc_subset hzero
+    intro t ht hprefix
+    have hpt : l t ∈ G := hprefix ⟨ht.1, le_rfl⟩
+    have hseg : segment ℝ p (l t) ⊆ G := by
+      have himage : l '' Icc 0 t = segment ℝ p (l t) := by
+        rw [← segment_eq_Icc ht.1, image_segment]
+        simp [l]
+      rw [← himage]
+      exact image_subset_iff.mpr hprefix
+    have hdist : dist (A (l t)) (A p) ≤ (C : ℝ) * dist (l t) p := by
+      simpa only [dist_eq_norm] using norm_sub_le_of_analytic_segment_bound hseg hA
+        (show NormBoundOn (fderiv ℂ A) G C from ⟨C.coe_nonneg, hd⟩)
+    have hsmall : dist (l t) p < (r : ℝ) := by
+      rw [show dist (l t) p = |t| * dist p z from dist_lineMap_left p z t,
+        abs_of_nonneg ht.1]
+      have hz' : dist p z ≤ (r : ℝ) := by simpa only [mem_closedBall, dist_comm] using hz
+      exact (mul_le_mul_of_nonneg_left hz' ht.1).trans_lt
+        (by nlinarith [ht.2])
+    have hi : A (l t) ∈ interior Ω :=
+      interior_mono hy (ball_subset_interior_closedBall
+        (hdist.trans_lt (mul_lt_mul_of_pos_left hsmall (show (0 : ℝ) < C from hC))))
+    exact nhdsWithin_le_nhds (hl.continuousAt
+      (mem_interior_iff_mem_nhds.mp (hback _ hpt hi)))
+  simpa [l] using hall (show (1 : ℝ) ∈ Icc (0 : ℝ) 1 by simp)
+
+end KamProject.Arnold1963
diff --git a/LeanPool/ArnoldKAM/Arnold1963/Geometry/Erosion.lean b/LeanPool/ArnoldKAM/Arnold1963/Geometry/Erosion.lean
new file mode 100644
index 0000000000..2147f52c4d
--- /dev/null
+++ b/LeanPool/ArnoldKAM/Arnold1963/Geometry/Erosion.lean
@@ -0,0 +1,62 @@
+/-
+Copyright (c) 2026 Bingqi Yu. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Bingqi Yu
+-/
+
+module
+
+public import LeanPool.ArnoldKAM.Arnold1963.Basic.Domains
+public import Mathlib.Analysis.Normed.Module.Ball.Pointwise
+
+/-!
+Closedness, compactness, and the exact radius identity for successive closed-ball erosions.
+-/
+
+@[expose] public section
+noncomputable section
+open Set Metric
+open scoped NNReal Pointwise
+namespace KamProject.Arnold1963
+
+variable {E : Type*} [NormedAddCommGroup E]
+
+theorem erosion_eq_iInter (U : Set E) (r : ℝ≥0) :
+    erosion U r = ⋂ v ∈ closedBall (0 : E) r, (fun x => x + v) ⁻¹' U := by
+  ext x
+  simp only [mem_iInter, mem_preimage]
+  constructor
+  · intro hx v hv
+    exact hx (by simpa [dist_eq_norm] using hv)
+  · intro hx y hy
+    have hv : y - x ∈ closedBall (0 : E) r := by simpa [dist_eq_norm] using hy
+    simpa using hx (y - x) hv
+
+theorem isClosed_erosion {U : Set E} (hU : IsClosed U) (r : ℝ≥0) :
+    IsClosed (erosion U r) := by
+  rw [erosion_eq_iInter]
+  exact isClosed_iInter fun _ => isClosed_iInter fun _ =>
+    hU.preimage (continuous_id.add continuous_const)
+
+theorem isCompact_erosion {U : Set E} (hU : IsCompact U) (r : ℝ≥0) :
+    IsCompact (erosion U r) :=
+  hU.of_isClosed_subset (isClosed_erosion hU.isClosed r) (erosion_subset U r)
+
+theorem erosion_add [NormedSpace ℝ E] [ProperSpace E] (U : Set E) (r s : ℝ≥0) :
+    erosion (erosion U r) s = erosion U (r + s) := by
+  ext x
+  constructor
+  · intro hx y hy
+    have hy' : y ∈ closedBall x (s : ℝ) + closedBall (0 : E) (r : ℝ) := by
+      rw [closedBall_add_closedBall s.coe_nonneg r.coe_nonneg, add_zero]
+      simpa [NNReal.coe_add, add_comm] using hy
+    obtain ⟨z, hz, v, hv, rfl⟩ := hy'
+    exact hx hz (by simpa [dist_eq_norm] using hv)
+  · intro hx y hy z hz
+    apply hx
+    exact (dist_triangle z y x).trans (by
+      change dist z y ≤ (r : ℝ) at hz
+      change dist y x ≤ (s : ℝ) at hy
+      exact add_le_add hz hy)
+
+end KamProject.Arnold1963
diff --git a/LeanPool/ArnoldKAM/Arnold1963/Geometry/FiniteTubes.lean b/LeanPool/ArnoldKAM/Arnold1963/Geometry/FiniteTubes.lean
new file mode 100644
index 0000000000..6ba3395061
--- /dev/null
+++ b/LeanPool/ArnoldKAM/Arnold1963/Geometry/FiniteTubes.lean
@@ -0,0 +1,123 @@
+/-
+Copyright (c) 2026 Bingqi Yu. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Bingqi Yu
+-/
+
+module
+
+public import LeanPool.ArnoldKAM.Arnold1963.Geometry.TubeLayer
+
+/-!
+Finite-tube domain representations and complete erosion loss bounds, relative to the
+original domain type constant.
+-/
+
+@[expose] public section
+noncomputable section
+open Set Metric MeasureTheory
+open scoped NNReal ENNReal
+namespace KamProject.Arnold1963
+
+/-- An eroded complex domain with finitely many covector-tube exclusions. -/
+def finiteTubeDomain {n : ℕ} {ι : Type*} (Ω : Set (ComplexSpace n)) (s : Finset ι)
+    (ℓ : ι → RealSpace n) (c a : ι → ℝ) (r : ℝ≥0) : Set (ComplexSpace n) :=
+  {z | z ∈ erosion Ω r ∧ ∀ i ∈ s, a i ≤ ‖realCovectorPairing (ℓ i) z - (c i : ℂ)‖}
+
+theorem finiteTubeDomain_subset {n : ℕ} {ι : Type*} (Ω : Set (ComplexSpace n)) (s : Finset ι)
+    (ℓ : ι → RealSpace n) (c a : ι → ℝ) (r : ℝ≥0) :
+    finiteTubeDomain Ω s ℓ c a r ⊆ Ω := fun _ hx => erosion_subset _ _ hx.1
+
+theorem erosion_finiteTubeDomain {n : ℕ} {ι : Type*} (Ω : Set (ComplexSpace n)) (s : Finset ι)
+    (ℓ : ι → RealSpace n) (c a : ι → ℝ) (r d : ℝ≥0)
+    (hℓ : ∀ i ∈ s, 0 < covectorLength (ℓ i)) (ha : ∀ i ∈ s, 0 < a i) :
+    erosion (finiteTubeDomain Ω s ℓ c a r) d =
+      finiteTubeDomain Ω s ℓ c (fun i => a i + (d : ℝ) * covectorLength (ℓ i)) (r + d) := by
+  ext x
+  constructor
+  · intro hx
+    constructor
+    · rw [← erosion_add]
+      exact fun z hz => (hx hz).1
+    · intro i hi
+      have hh : x ∈ erosion {z | a i ≤ ‖realCovectorPairing (ℓ i) z - (c i : ℂ)‖} d :=
+        fun z hz => (hx hz).2 i hi
+      rwa [erosion_tube_complement (ℓ i) (hℓ i hi) (c i) (a i) (ha i hi) d] at hh
+  · rintro ⟨hx, hs⟩ z hz
+    constructor
+    · rw [← erosion_add] at hx
+      exact hx hz
+    · intro i hi
+      have hh := hs i hi
+      change x ∈ {z | a i + (d : ℝ) * covectorLength (ℓ i) ≤
+        ‖realCovectorPairing (ℓ i) z - (c i : ℂ)‖} at hh
+      rw [← erosion_tube_complement (ℓ i) (hℓ i hi) (c i) (a i) (ha i hi) d] at hh
+      exact hh hz
+
+theorem finiteTube_layer_subset {n : ℕ} {ι : Type*} (Ω : Set (ComplexSpace n)) (s : Finset ι)
+    (ℓ : ι → RealSpace n) (c a : ι → ℝ) (r d₁ d₂ : ℝ≥0)
+    (hℓ : ∀ i ∈ s, 0 < covectorLength (ℓ i)) (ha : ∀ i ∈ s, 0 < a i) :
+    erosion (finiteTubeDomain Ω s ℓ c a r) d₁ \ erosion (finiteTubeDomain Ω s ℓ c a r) d₂ ⊆
+      (erosion Ω (r + d₁) \ erosion Ω (r + d₂)) ∪
+        ⋃ i ∈ s, Ω ∩ {z | a i + (d₁ : ℝ) * covectorLength (ℓ i) ≤
+          ‖realCovectorPairing (ℓ i) z - (c i : ℂ)‖ ∧
+          ‖realCovectorPairing (ℓ i) z - (c i : ℂ)‖ < a i + (d₂ : ℝ) * covectorLength (ℓ i)} := by
+  classical
+  rw [erosion_finiteTubeDomain Ω s ℓ c a r d₁ hℓ ha,
+    erosion_finiteTubeDomain Ω s ℓ c a r d₂ hℓ ha]
+  intro z ⟨hz, hn⟩
+  by_cases hz₂ : z ∈ erosion Ω (r + d₂)
+  · right
+    have hh : ¬ ∀ i ∈ s, a i + (d₂ : ℝ) * covectorLength (ℓ i) ≤
+        ‖realCovectorPairing (ℓ i) z - (c i : ℂ)‖ := fun hh => hn ⟨hz₂, hh⟩
+    push Not at hh
+    obtain ⟨i, hi, hbad⟩ := hh
+    exact mem_iUnion.mpr ⟨i, mem_iUnion.mpr ⟨hi, erosion_subset _ _ hz.1, hz.2 i hi, hbad⟩⟩
+  · exact Or.inl ⟨hz.1, hz₂⟩
+
+theorem TypeD.finiteTube_erosion_layer {n : ℕ} {ι : Type*} {Ω : Set (ComplexSpace n)}
+    {D : ℝ} (h : TypeD Ω D) (s : Finset ι) (ℓ : ι → RealSpace n) (c a : ι → ℝ)
+    (r d₁ d₂ : ℝ≥0) (hd : d₁ ≤ d₂)
+    (hℓ : ∀ i ∈ s, 0 < covectorLength (ℓ i)) (ha : ∀ i ∈ s, 0 < a i) :
+    realVolume (erosion (finiteTubeDomain Ω s ℓ c a r) d₁ \
+      erosion (finiteTubeDomain Ω s ℓ c a r) d₂) ≤
+      ENNReal.ofReal (D * (1 + 2 * n * s.card) * ((d₂ : ℝ) - d₁)) * realVolume Ω := by
+  let δ : ℝ := (d₂ : ℝ) - d₁
+  have hδ : 0 ≤ δ := sub_nonneg.mpr hd
+  let L i := Ω ∩ {z | a i + (d₁ : ℝ) * covectorLength (ℓ i) ≤
+      ‖realCovectorPairing (ℓ i) z - (c i : ℂ)‖ ∧
+      ‖realCovectorPairing (ℓ i) z - (c i : ℂ)‖ < a i + (d₂ : ℝ) * covectorLength (ℓ i)}
+  have hLi : ∀ i ∈ s, realVolume (L i) ≤ ENNReal.ofReal (2 * D * n * δ) * realVolume Ω := by
+    intro i hi
+    have hh := h.tube_layer (ℓ i) (c i) (a i + (d₁ : ℝ) * covectorLength (ℓ i))
+      (a i + (d₂ : ℝ) * covectorLength (ℓ i)) (hℓ i hi)
+      (by positivity [ha i hi, hℓ i hi])
+      (add_le_add le_rfl (mul_le_mul_of_nonneg_right
+        (show (d₁ : ℝ) ≤ d₂ from hd) (hℓ i hi).le))
+    have he : (a i + (d₂ : ℝ) * covectorLength (ℓ i) -
+        (a i + (d₁ : ℝ) * covectorLength (ℓ i))) / covectorLength (ℓ i) = δ := by
+      dsimp [δ]
+      field_simp [(hℓ i hi).ne']
+      ring
+    simpa only [he] using hh
+  have hb := h.boundary (r + d₁) (r + d₂) (add_le_add le_rfl hd)
+  have hsub := finiteTube_layer_subset Ω s ℓ c a r d₁ d₂ hℓ ha
+  calc
+    _ ≤ realVolume ((erosion Ω (r + d₁) \ erosion Ω (r + d₂)) ∪ ⋃ i ∈ s, L i) :=
+      realVolume_mono hsub
+    _ ≤ realVolume (erosion Ω (r + d₁) \ erosion Ω (r + d₂)) +
+        realVolume (⋃ i ∈ s, L i) := measure_union_le _ _
+    _ ≤ ENNReal.ofReal (D * δ) * realVolume Ω +
+        ∑ i ∈ s, ENNReal.ofReal (2 * D * n * δ) * realVolume Ω := by
+      apply add_le_add
+      · simpa only [NNReal.coe_add, add_sub_add_left_eq_sub] using hb
+      · exact (realVolume_biUnion_finset_le s L).trans (Finset.sum_le_sum hLi)
+    _ = _ := by
+      rw [← Finset.sum_mul, ← ENNReal.ofReal_sum_of_nonneg (fun _ _ => by
+        positivity [h.constant_pos]), ← add_mul,
+        ← ENNReal.ofReal_add (by positivity [h.constant_pos]) (by positivity [h.constant_pos])]
+      simp only [Finset.sum_const, nsmul_eq_mul]
+      have he : D * δ + (s.card : ℝ) * (2 * D * n * δ) = D * (1 + 2 * n * s.card) * δ := by ring
+      rw [he]
+
+end KamProject.Arnold1963
diff --git a/LeanPool/ArnoldKAM/Arnold1963/Geometry/FrequencyChange.lean b/LeanPool/ArnoldKAM/Arnold1963/Geometry/FrequencyChange.lean
new file mode 100644
index 0000000000..43a578634a
--- /dev/null
+++ b/LeanPool/ArnoldKAM/Arnold1963/Geometry/FrequencyChange.lean
@@ -0,0 +1,110 @@
+/-
+Copyright (c) 2026 Bingqi Yu. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Bingqi Yu
+-/
+
+module
+
+public import LeanPool.ArnoldKAM.Arnold1963.Geometry.FrequencyInverse
+
+/-!
+Compose the old frequency inverse with the inverse of the small shift. Domain buffers and
+measure bounds are assembled in FrequencyDomain to keep the dependencies acyclic.
+-/
+
+@[expose] public section
+noncomputable section
+open Set Function
+open scoped NNReal
+namespace KamProject.Arnold1963
+
+theorem frequencyChange_derivative_bounds {n : ℕ}
+    {A Δ : ComplexSpace n → ComplexSpace n} {p : ComplexSpace n}
+    {θ Θ : ℝ} {κ : ℝ≥0} (hA : DifferentiableAt ℂ A p) (hΔ : DifferentiableAt ℂ Δ p)
+    (hθΘ : θ ≤ Θ) (hlo : ∀ v, θ * ‖v‖ ≤ ‖fderiv ℂ A p v‖)
+    (hhi : ∀ v, ‖fderiv ℂ A p v‖ ≤ Θ * ‖v‖)
+    (hdΔ : ‖fderiv ℂ Δ p‖ ≤ (κ : ℝ) * θ) (v : ComplexSpace n) :
+    (θ * (1 - (κ : ℝ))) * ‖v‖ ≤ ‖fderiv ℂ (fun x => A x + Δ x) p v‖ ∧
+      ‖fderiv ℂ (fun x => A x + Δ x) p v‖ ≤ (Θ * (1 + (κ : ℝ))) * ‖v‖ := by
+  have hder : fderiv ℂ (fun x => A x + Δ x) p = fderiv ℂ A p + fderiv ℂ Δ p :=
+    (hA.hasFDerivAt.add hΔ.hasFDerivAt).fderiv
+  rw [hder]
+  change _ ≤ ‖fderiv ℂ A p v + fderiv ℂ Δ p v‖ ∧
+    ‖fderiv ℂ A p v + fderiv ℂ Δ p v‖ ≤ _
+  have hd := ((fderiv ℂ Δ p).le_opNorm v).trans
+    (mul_le_mul_of_nonneg_right hdΔ (norm_nonneg v))
+  have ht := mul_le_mul_of_nonneg_right (mul_le_mul_of_nonneg_left hθΘ κ.coe_nonneg)
+    (norm_nonneg v)
+  have hl : ‖fderiv ℂ A p v‖ ≤
+      ‖fderiv ℂ A p v + fderiv ℂ Δ p v‖ + ‖fderiv ℂ Δ p v‖ := by
+    simpa using norm_sub_le (fderiv ℂ A p v + fderiv ℂ Δ p v) (fderiv ℂ Δ p v)
+  constructor
+  · nlinarith [hlo v]
+  · nlinarith [hhi v, norm_add_le (fderiv ℂ A p v) (fderiv ℂ Δ p v)]
+
+theorem frequencyShiftData_of_old_inverse {n : ℕ}
+    {g Δ : ComplexSpace n → ComplexSpace n} {G V : Set (ComplexSpace n)}
+    {β κ : ℝ≥0} {θ : ℝ} (hβ : 0 < β) (hκ : κ < 1) (hθ : 0 < θ)
+    (hg : AnalyticOnNhd ℂ g V) (hmap : MapsTo g V G)
+    (hΔ : AnalyticOnNhd ℂ Δ G) (hb : NormBoundOn Δ G β)
+    (hdg : ∀ x ∈ V, ‖fderiv ℂ g x‖ ≤ θ⁻¹)
+    (hdΔ : ∀ p ∈ G, ‖fderiv ℂ Δ p‖ ≤ (κ : ℝ) * θ) :
+    FrequencyShiftData (Δ ∘ g) V β κ := by
+  refine ⟨hβ, hκ, ?_, ⟨β.coe_nonneg, fun x hx => hb.norm_le (hmap hx)⟩, ?_⟩
+  · intro x hx
+    exact (hΔ _ (hmap hx)).comp (hg x hx)
+  · intro x hx
+    rw [fderiv_comp x (hΔ _ (hmap hx)).differentiableAt (hg x hx).differentiableAt]
+    calc
+      _ ≤ ‖fderiv ℂ Δ (g x)‖ * ‖fderiv ℂ g x‖ := ContinuousLinearMap.opNorm_comp_le _ _
+      _ ≤ ((κ : ℝ) * θ) * θ⁻¹ :=
+        mul_le_mul (hdΔ _ (hmap hx)) (hdg x hx) (norm_nonneg _) (by positivity)
+      _ = κ := by field_simp
+
+/-- The inverse of a corrected frequency chart, composed with the original inverse chart. -/
+def correctedFrequencyInverse {n : ℕ} (g Δ : ComplexSpace n → ComplexSpace n)
+    (V : Set (ComplexSpace n)) (β : ℝ≥0) : ComplexSpace n → ComplexSpace n :=
+  g ∘ frequencyInverse (Δ ∘ g) V β
+
+theorem correctedFrequencyInverse_analytic {n : ℕ}
+    {g Δ : ComplexSpace n → ComplexSpace n} {V : Set (ComplexSpace n)} {β κ : ℝ≥0}
+    (d : FrequencyShiftData (Δ ∘ g) V β κ) (hg : AnalyticOnNhd ℂ g V) :
+    AnalyticOnNhd ℂ (correctedFrequencyInverse g Δ V β) (frequencyInverseTarget V β) := by
+  intro y hy
+  exact (hg _ (erosion_subset _ _ (d.inverse_spec hy).1)).comp (d.inverse_analytic_right hy).1
+
+theorem correctedFrequencyInverse_right {n : ℕ}
+    {A g Δ : ComplexSpace n → ComplexSpace n} {V : Set (ComplexSpace n)} {β κ : ℝ≥0}
+    (d : FrequencyShiftData (Δ ∘ g) V β κ) (hA : ∀ x ∈ V, A (g x) = x)
+    {y : ComplexSpace n} (hy : y ∈ frequencyInverseTarget V β) :
+    A (correctedFrequencyInverse g Δ V β y) +
+      Δ (correctedFrequencyInverse g Δ V β y) = y := by
+  dsimp [correctedFrequencyInverse]
+  rw [hA _ (erosion_subset _ _ (d.inverse_spec hy).1)]
+  exact (d.inverse_spec hy).2.1
+
+theorem correctedFrequencyInverse_injOn {n : ℕ}
+    {A g Δ : ComplexSpace n → ComplexSpace n} {V : Set (ComplexSpace n)} {β κ : ℝ≥0}
+    (d : FrequencyShiftData (Δ ∘ g) V β κ) (hA : ∀ x ∈ V, A (g x) = x) :
+    InjOn (correctedFrequencyInverse g Δ V β) (frequencyInverseTarget V β) := by
+  intro x hx y hy he
+  rw [← correctedFrequencyInverse_right d hA hx,
+    ← correctedFrequencyInverse_right d hA hy, he]
+
+theorem correctedFrequency_image_domain {n : ℕ}
+    {A g Δ : ComplexSpace n → ComplexSpace n} {V Ω₁ : Set (ComplexSpace n)} {β κ : ℝ≥0}
+    (d : FrequencyShiftData (Δ ∘ g) V β κ) (hA : ∀ x ∈ V, A (g x) = x)
+    (hΩ₁ : Ω₁ ⊆ frequencyInverseTarget V β) :
+    (fun p => A p + Δ p) '' (correctedFrequencyInverse g Δ V β '' Ω₁) = Ω₁ := by
+  rw [image_image]
+  ext y
+  constructor
+  · rintro ⟨x, hx, he⟩
+    have hr := correctedFrequencyInverse_right d hA (hΩ₁ hx)
+    have hxy : x = y := hr.symm.trans he
+    exact hxy ▸ hx
+  · intro hy
+    exact ⟨y, hy, correctedFrequencyInverse_right d hA (hΩ₁ hy)⟩
+
+end KamProject.Arnold1963
diff --git a/LeanPool/ArnoldKAM/Arnold1963/Geometry/FrequencyChart.lean b/LeanPool/ArnoldKAM/Arnold1963/Geometry/FrequencyChart.lean
new file mode 100644
index 0000000000..5d9df62e5a
--- /dev/null
+++ b/LeanPool/ArnoldKAM/Arnold1963/Geometry/FrequencyChart.lean
@@ -0,0 +1,136 @@
+/-
+Copyright (c) 2026 Bingqi Yu. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Bingqi Yu
+-/
+
+module
+
+public import LeanPool.ArnoldKAM.Arnold1963.Geometry.DomainCover
+public import LeanPool.ArnoldKAM.Arnold1963.Geometry.FrequencyChange
+
+/-!
+Analytic frequency charts on compact domains. Local inverse identities imply the required
+coverage and inverse derivative estimates.
+-/
+
+@[expose] public section
+noncomputable section
+open Set Function Filter Metric
+open scoped NNReal Topology
+namespace KamProject.Arnold1963
+
+/-- An analytic frequency chart with an analytic inverse and specified source and target sets. -/
+structure AnalyticFrequencyChart {n : ℕ} (A g : ComplexSpace n → ComplexSpace n)
+    (G Ω : Set (ComplexSpace n)) : Prop where
+  compact : IsCompact G
+  analytic : AnalyticOnNhd ℂ A G
+  inverse_analytic : AnalyticOnNhd ℂ g Ω
+  maps : MapsTo A G Ω
+  inverse_maps : MapsTo g Ω G
+  left_local : ∀ p ∈ G, ∀ᶠ x in 𝓝 p, g (A x) = x
+  right_local : ∀ y ∈ Ω, ∀ᶠ x in 𝓝 y, A (g x) = x
+  domain_conj : ConjInvariant G
+  map_conj : ∀ p ∈ G, A (conjVec p) = conjVec (A p)
+
+namespace AnalyticFrequencyChart
+variable {n : ℕ} {A g : ComplexSpace n → ComplexSpace n}
+  {G Ω : Set (ComplexSpace n)} (c : AnalyticFrequencyChart A g G Ω)
+include c
+
+theorem left {p} (hp : p ∈ G) : g (A p) = p := (c.left_local p hp).self_of_nhds
+theorem right {y} (hy : y ∈ Ω) : A (g y) = y := (c.right_local y hy).self_of_nhds
+
+theorem image_eq : A '' G = Ω := by
+  apply Subset.antisymm c.maps.image_subset
+  intro y hy
+  exact ⟨g y, c.inverse_maps hy, c.right hy⟩
+
+theorem inverse_image_eq : g '' Ω = G := by
+  apply Subset.antisymm c.inverse_maps.image_subset
+  intro p hp
+  exact ⟨A p, c.maps hp, c.left hp⟩
+
+theorem image_compact : IsCompact Ω := by
+  rw [← c.image_eq]
+  exact c.compact.image_of_continuousOn c.analytic.continuousOn
+
+theorem injOn : InjOn A G := by
+  intro p hp q hq he
+  rw [← c.left hp, ← c.left hq, he]
+
+theorem image_conj : ConjInvariant Ω := by
+  intro y hy
+  rw [← c.right hy, ← c.map_conj _ (c.inverse_maps hy)]
+  exact c.maps (c.domain_conj _ (c.inverse_maps hy))
+
+theorem inverse_conj {y} (hy : y ∈ Ω) : g (conjVec y) = conjVec (g y) := by
+  apply c.injOn (c.inverse_maps (c.image_conj _ hy)) (c.domain_conj _ (c.inverse_maps hy))
+  rw [c.right (c.image_conj _ hy), c.map_conj _ (c.inverse_maps hy), c.right hy]
+
+theorem symm : AnalyticFrequencyChart g A Ω G where
+  compact := c.image_compact
+  analytic := c.inverse_analytic
+  inverse_analytic := c.analytic
+  maps := c.inverse_maps
+  inverse_maps := c.maps
+  left_local := c.right_local
+  right_local := c.left_local
+  domain_conj := c.image_conj
+  map_conj := fun _ hy => c.inverse_conj hy
+
+theorem interior_back {p} (hp : p ∈ G) (hy : A p ∈ interior Ω) : p ∈ interior G :=
+  mem_interior_of_local_inverse (c.analytic _ hp).continuousAt c.inverse_maps
+    (c.left_local p hp) hy
+
+theorem inverse_maps_erosion {Θ β : ℝ≥0} (hΘ : 0 < Θ)
+    (hd : ∀ p ∈ G, ‖fderiv ℂ A p‖ ≤ Θ) :
+    MapsTo g (erosion Ω (Θ * β)) (erosion G β) := by
+  intro y hy
+  have hyΩ := erosion_subset _ _ hy
+  apply mem_erosion_of_image_buffer c.compact.isClosed hΘ c.analytic hd
+    (fun p hp => c.interior_back hp) (c.inverse_maps hyΩ)
+  simpa only [c.right hyΩ] using hy
+
+theorem erosion_subset_image {Θ β : ℝ≥0} (hΘ : 0 < Θ)
+    (hd : ∀ p ∈ G, ‖fderiv ℂ A p‖ ≤ Θ) :
+    erosion Ω (Θ * β) ⊆ A '' erosion G β := by
+  intro y hy
+  exact ⟨g y, c.inverse_maps_erosion hΘ hd hy, c.right (erosion_subset _ _ hy)⟩
+
+theorem inverse_derivative_le {θ : ℝ} (hθ : 0 < θ)
+    (hlo : ∀ p ∈ G, ∀ v, θ * ‖v‖ ≤ ‖fderiv ℂ A p v‖)
+    {y} (hy : y ∈ Ω) : ‖fderiv ℂ g y‖ ≤ θ⁻¹ := by
+  have hd := ((c.analytic _ (c.inverse_maps hy)).differentiableAt.hasFDerivAt.comp y
+    (c.inverse_analytic _ hy).differentiableAt.hasFDerivAt)
+  have hid : (fderiv ℂ A (g y)).comp (fderiv ℂ g y) = ContinuousLinearMap.id ℂ _ :=
+    (hd.congr_of_eventuallyEq (Filter.EventuallyEq.symm (c.right_local y hy))).unique
+      (hasFDerivAt_id y)
+  apply ContinuousLinearMap.opNorm_le_bound _ (inv_nonneg.mpr hθ.le)
+  intro v
+  have hh := hlo _ (c.inverse_maps hy) (fderiv ℂ g y v)
+  have hv := DFunLike.congr_fun hid v
+  change fderiv ℂ A (g y) (fderiv ℂ g y v) = v at hv
+  rw [hv] at hh
+  calc
+    ‖fderiv ℂ g y v‖ ≤ ‖v‖ / θ := (le_div_iff₀ hθ).mpr (by simpa [mul_comm] using hh)
+    _ = θ⁻¹ * ‖v‖ := by rw [div_eq_mul_inv, mul_comm]
+
+theorem restrict {S : Set (ComplexSpace n)} (hS : S ⊆ Ω) (hSc : IsCompact S)
+    (hSj : ConjInvariant S) : AnalyticFrequencyChart A g (g '' S) S := by
+  refine ⟨hSc.image_of_continuousOn (c.inverse_analytic.mono hS).continuousOn,
+    c.analytic.mono (image_subset_iff.mpr (fun _ hx => c.inverse_maps (hS hx))),
+    c.inverse_analytic.mono hS, ?_, fun _ hx => mem_image_of_mem g hx, ?_, ?_, ?_, ?_⟩
+  · rintro _ ⟨y, hy, rfl⟩
+    rwa [c.right (hS hy)]
+  · rintro _ ⟨y, hy, rfl⟩
+    exact c.left_local _ (c.inverse_maps (hS hy))
+  · intro y hy
+    exact c.right_local y (hS hy)
+  · rintro _ ⟨y, hy, rfl⟩
+    exact ⟨conjVec y, hSj _ hy, c.inverse_conj (hS hy)⟩
+  · rintro _ ⟨y, hy, rfl⟩
+    exact c.map_conj _ (c.inverse_maps (hS hy))
+
+end AnalyticFrequencyChart
+end KamProject.Arnold1963
diff --git a/LeanPool/ArnoldKAM/Arnold1963/Geometry/FrequencyChartCongr.lean b/LeanPool/ArnoldKAM/Arnold1963/Geometry/FrequencyChartCongr.lean
new file mode 100644
index 0000000000..c8653d0589
--- /dev/null
+++ b/LeanPool/ArnoldKAM/Arnold1963/Geometry/FrequencyChartCongr.lean
@@ -0,0 +1,43 @@
+/-
+Copyright (c) 2026 Bingqi Yu. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Bingqi Yu
+-/
+
+module
+
+public import LeanPool.ArnoldKAM.Arnold1963.Geometry.FrequencyChart
+
+/-!
+Frequency functions agreeing near every domain point give the same analytic chart.
+-/
+
+@[expose] public section
+noncomputable section
+open Set Filter
+open scoped Topology
+namespace KamProject.Arnold1963
+
+theorem AnalyticFrequencyChart.congr {n : ℕ} {A A' g : ComplexSpace n → ComplexSpace n}
+    {G Ω : Set (ComplexSpace n)} (c : AnalyticFrequencyChart A g G Ω)
+    (he : ∀ p ∈ G, A' =ᶠ[𝓝 p] A) : AnalyticFrequencyChart A' g G Ω where
+  compact := c.compact
+  analytic := fun p hp => (c.analytic p hp).congr (he p hp).symm
+  inverse_analytic := c.inverse_analytic
+  maps := fun p hp => (he p hp).self_of_nhds ▸ c.maps hp
+  inverse_maps := c.inverse_maps
+  left_local := by
+    intro p hp
+    filter_upwards [he p hp, c.left_local p hp] with x hx hi
+    rwa [hx]
+  right_local := by
+    intro y hy
+    have hh := (c.inverse_analytic y hy).continuousAt.eventually (he _ (c.inverse_maps hy))
+    filter_upwards [hh, c.right_local y hy] with x hx hi
+    exact hx.trans hi
+  domain_conj := c.domain_conj
+  map_conj := by
+    intro p hp
+    rw [(he _ (c.domain_conj _ hp)).self_of_nhds, (he _ hp).self_of_nhds, c.map_conj _ hp]
+
+end KamProject.Arnold1963
diff --git a/LeanPool/ArnoldKAM/Arnold1963/Geometry/FrequencyDomain.lean b/LeanPool/ArnoldKAM/Arnold1963/Geometry/FrequencyDomain.lean
new file mode 100644
index 0000000000..436ea67964
--- /dev/null
+++ b/LeanPool/ArnoldKAM/Arnold1963/Geometry/FrequencyDomain.lean
@@ -0,0 +1,215 @@
+/-
+Copyright (c) 2026 Bingqi Yu. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Bingqi Yu
+-/
+
+module
+
+public import LeanPool.ArnoldKAM.Arnold1963.Geometry.CorrectedChart
+public import LeanPool.ArnoldKAM.Arnold1963.Geometry.FrequencyMeasure
+
+/-!
+Construct new domains from the selected corrected inverse and prove all buffer inclusions.
+-/
+
+@[expose] public section
+noncomputable section
+open Set Function Filter Metric
+open scoped NNReal Topology ENNReal
+namespace KamProject.Arnold1963
+
+/-- The outer frequency erosion required for the corrected chart construction. -/
+def frequencyOuterRadius (Θ β : ℝ≥0) : ℝ≥0 := (5 + Θ) * β
+/-- The total frequency erosion budgeting a domain restriction and the corrected chart. -/
+def frequencyLossRadius (Θ β b : ℝ≥0) : ℝ≥0 := 2 * Θ * b + frequencyOuterRadius Θ β
+
+/-- The analytic chart, small correction and derivative bounds required for frequency change. -/
+structure FrequencyChangeInput {n : ℕ} (A g Δ : ComplexSpace n → ComplexSpace n)
+    (G Ω : Set (ComplexSpace n)) (β κ θ Θ : ℝ≥0) : Prop where
+  chart : AnalyticFrequencyChart A g G Ω
+  radius_pos : 0 < β
+  contraction : κ < 1
+  lower_pos : 0 < θ
+  lower_le_upper : θ ≤ Θ
+  lower : ∀ p ∈ G, ∀ v, (θ : ℝ) * ‖v‖ ≤ ‖fderiv ℂ A p v‖
+  upper : ∀ p ∈ G, ‖fderiv ℂ A p‖ ≤ Θ
+  analytic : AnalyticOnNhd ℂ Δ (erosion G β)
+  bounded : NormBoundOn Δ (erosion G β) β
+  derivative : ∀ p ∈ erosion G β, ‖fderiv ℂ Δ p‖ ≤ (κ : ℝ) * θ
+  conj : ∀ p ∈ erosion G β, Δ (conjVec p) = conjVec (Δ p)
+
+namespace FrequencyChangeInput
+variable {n : ℕ} {A g Δ : ComplexSpace n → ComplexSpace n}
+  {G Ω : Set (ComplexSpace n)} {β κ θ Θ : ℝ≥0}
+  (h : FrequencyChangeInput A g Δ G Ω β κ θ Θ)
+include h
+
+/-- The old frequency image of the once-eroded action domain. -/
+def oldImage (_ : FrequencyChangeInput A g Δ G Ω β κ θ Θ) : Set (ComplexSpace n) := A '' erosion G β
+/-- The corrected inverse chart on the old frequency image. -/
+def newInverse : ComplexSpace n → ComplexSpace n := correctedFrequencyInverse g Δ h.oldImage β
+/-- The outer eroded frequency domain retained by the corrected chart. -/
+def outerFrequency (_ : FrequencyChangeInput A g Δ G Ω β κ θ Θ) : Set (ComplexSpace n) :=
+  erosion Ω (frequencyOuterRadius Θ β)
+/-- The corrected action domain obtained from the outer frequency domain. -/
+def outerDomain : Set (ComplexSpace n) := h.newInverse '' h.outerFrequency
+/-- The inner frequency domain with the additional localization loss budget. -/
+def innerFrequency (_ : FrequencyChangeInput A g Δ G Ω β κ θ Θ)
+    (Ω₀ : Set (ComplexSpace n)) (b : ℝ≥0) := erosion Ω₀ (frequencyLossRadius Θ β b)
+/-- The corrected action domain obtained from the inner frequency domain. -/
+def innerDomain (Ω₀ : Set (ComplexSpace n)) (b : ℝ≥0) := h.newInverse '' h.innerFrequency Ω₀ b
+
+theorem oldImage_subset : h.oldImage ⊆ Ω := by
+  rintro y ⟨p, hp, rfl⟩
+  exact h.chart.maps (erosion_subset _ _ hp)
+
+theorem oldInverse_maps : MapsTo g h.oldImage (erosion G β) := by
+  rintro y ⟨p, hp, rfl⟩
+  rwa [h.chart.left (erosion_subset _ _ hp)]
+
+theorem oldImage_conj : ConjInvariant h.oldImage := by
+  rintro y ⟨p, hp, rfl⟩
+  exact ⟨conjVec p, star_mem_erosion h.chart.domain_conj hp,
+    h.chart.map_conj _ (erosion_subset _ _ hp)⟩
+
+theorem shiftData : FrequencyShiftData (Δ ∘ g) h.oldImage β κ :=
+  frequencyShiftData_of_old_inverse h.radius_pos h.contraction h.lower_pos
+    (h.chart.inverse_analytic.mono h.oldImage_subset) h.oldInverse_maps h.analytic h.bounded
+    (fun _ hx => h.chart.inverse_derivative_le h.lower_pos h.lower (h.oldImage_subset hx))
+    h.derivative
+
+theorem outer_subset_target : h.outerFrequency ⊆ frequencyInverseTarget h.oldImage β := by
+  have he : frequencyOuterRadius Θ β = Θ * β + (β + β + β + β + β) := by
+    unfold frequencyOuterRadius; ring
+  change erosion Ω _ ⊆ erosion h.oldImage _
+  rw [he, ← erosion_add]
+  exact erosion_mono
+    (h.chart.erosion_subset_image (h.lower_pos.trans_le h.lower_le_upper) h.upper) _
+
+theorem outer_subset : h.outerDomain ⊆ erosion G β := by
+  rintro p ⟨y, hy, rfl⟩
+  exact h.oldInverse_maps
+    (erosion_subset _ _ (h.shiftData.inverse_spec (h.outer_subset_target hy)).1)
+
+theorem outerChart : AnalyticFrequencyChart (fun p => A p + Δ p) h.newInverse
+    h.outerDomain h.outerFrequency :=
+  correctedFrequency_chart h.chart h.shiftData h.oldImage_subset h.oldInverse_maps
+    (erosion_subset G β) h.analytic h.oldImage_conj h.conj
+    (isCompact_erosion h.chart.image_compact _) (fun _ hx => star_mem_erosion h.chart.image_conj hx)
+    h.outer_subset_target
+
+theorem new_derivative_bounds {p} (hp : p ∈ h.outerDomain) (v : ComplexSpace n) :
+    ((θ : ℝ) * (1 - (κ : ℝ))) * ‖v‖ ≤ ‖fderiv ℂ (fun x => A x + Δ x) p v‖ ∧
+      ‖fderiv ℂ (fun x => A x + Δ x) p v‖ ≤ ((Θ : ℝ) * (1 + (κ : ℝ))) * ‖v‖ :=
+  frequencyChange_derivative_bounds
+    (h.chart.analytic _ (erosion_subset _ _ (h.outer_subset hp))).differentiableAt
+    (h.analytic _ (h.outer_subset hp)).differentiableAt h.lower_le_upper
+    (h.lower _ (erosion_subset _ _ (h.outer_subset hp)))
+    (fun v => ((fderiv ℂ A p).le_opNorm v).trans
+      (mul_le_mul_of_nonneg_right (h.upper _ (erosion_subset _ _ (h.outer_subset hp)))
+        (norm_nonneg v)))
+    (h.derivative _ (h.outer_subset hp)) v
+
+theorem new_upper {p} (hp : p ∈ h.outerDomain) :
+    ‖fderiv ℂ (fun x => A x + Δ x) p‖ ≤ (2 : ℝ) * Θ := by
+  apply ContinuousLinearMap.opNorm_le_bound _ (by positivity)
+  intro v
+  apply (h.new_derivative_bounds hp v).2.trans
+  apply mul_le_mul_of_nonneg_right _ (norm_nonneg v)
+  have hk : (κ : ℝ) < 1 := h.contraction
+  nlinarith [Θ.coe_nonneg]
+
+theorem new_upper_sharp {p} (hp : p ∈ h.outerDomain) :
+    ‖fderiv ℂ (fun x => A x + Δ x) p‖ ≤ (Θ : ℝ) * (1 + (κ : ℝ)) :=
+  ContinuousLinearMap.opNorm_le_bound _ (by positivity)
+    (fun v => (h.new_derivative_bounds hp v).2)
+
+theorem new_lower_pos : 0 < (θ : ℝ) * (1 - (κ : ℝ)) :=
+  mul_pos h.lower_pos (sub_pos.mpr h.contraction)
+
+theorem inner_subset_buffer {Ω₀ : Set (ComplexSpace n)} (hΩ₀ : Ω₀ ⊆ Ω) (b : ℝ≥0) :
+    h.innerFrequency Ω₀ b ⊆ erosion h.outerFrequency ((2 * Θ) * b) := by
+  change erosion Ω₀ _ ⊆ erosion (erosion Ω _) _
+  rw [erosion_add]
+  have he : frequencyLossRadius Θ β b = frequencyOuterRadius Θ β + (2 * Θ) * b := by
+    unfold frequencyLossRadius; ring
+  rw [← he]
+  exact erosion_mono hΩ₀ _
+
+theorem inner_subset_outerFrequency {Ω₀ : Set (ComplexSpace n)} (hΩ₀ : Ω₀ ⊆ Ω) (b : ℝ≥0) :
+    h.innerFrequency Ω₀ b ⊆ h.outerFrequency :=
+  (h.inner_subset_buffer hΩ₀ b).trans (erosion_subset _ _)
+
+theorem inner_subset_outerDomain {Ω₀ : Set (ComplexSpace n)} (hΩ₀ : Ω₀ ⊆ Ω) (b : ℝ≥0) :
+    h.innerDomain Ω₀ b ⊆ h.outerDomain := image_mono (h.inner_subset_outerFrequency hΩ₀ b)
+
+theorem innerChart {Ω₀ : Set (ComplexSpace n)} (hΩ₀ : Ω₀ ⊆ Ω) (hc : IsCompact Ω₀)
+    (hj : ConjInvariant Ω₀) (b : ℝ≥0) :
+    AnalyticFrequencyChart (fun p => A p + Δ p) h.newInverse
+      (h.innerDomain Ω₀ b) (h.innerFrequency Ω₀ b) :=
+  h.outerChart.restrict (h.inner_subset_outerFrequency hΩ₀ b) (isCompact_erosion hc _)
+    (fun _ hx => star_mem_erosion hj hx)
+
+theorem inner_subset_erosion {Ω₀ : Set (ComplexSpace n)} (hΩ₀ : Ω₀ ⊆ Ω) (b : ℝ≥0) :
+    h.innerDomain Ω₀ b ⊆ erosion h.outerDomain b := by
+  rintro p ⟨y, hy, rfl⟩
+  exact h.outerChart.inverse_maps_erosion (show (0 : ℝ≥0) < 2 * Θ by
+    exact mul_pos (by norm_num) (h.lower_pos.trans_le h.lower_le_upper))
+    (fun _ hp => h.new_upper hp) (h.inner_subset_buffer hΩ₀ b hy)
+
+theorem neighborhood_subset {Ω₀ : Set (ComplexSpace n)} (hΩ₀ : Ω₀ ⊆ Ω) (b : ℝ≥0) :
+    closedBallNeighborhood (h.innerDomain Ω₀ b) b ⊆ h.outerDomain := by
+  rintro p ⟨q, hq, hpq⟩
+  exact h.inner_subset_erosion hΩ₀ b hq hpq
+
+theorem neighborhood_maps {Ω₀ : Set (ComplexSpace n)} (hΩ₀ : Ω₀ ⊆ Ω) (b : ℝ≥0) :
+    MapsTo (fun p => A p + Δ p) (closedBallNeighborhood (h.innerDomain Ω₀ b) b) Ω₀ := by
+  rintro p ⟨q, ⟨y, hy, rfl⟩, hpq⟩
+  have hq : h.newInverse y ∈ h.innerDomain Ω₀ b := ⟨y, hy, rfl⟩
+  have hb : closedBall (h.newInverse y) (b : ℝ) ⊆ h.outerDomain := h.inner_subset_erosion hΩ₀ b hq
+  have hseg := (convex_closedBall (h.newInverse y) (b : ℝ)).segment_subset
+    (mem_closedBall_self b.coe_nonneg) hpq
+  have he : A (h.newInverse y) + Δ (h.newInverse y) = y :=
+    h.outerChart.right (h.inner_subset_outerFrequency hΩ₀ b hy)
+  apply hy
+  change dist (A p + Δ p) y ≤ (frequencyLossRadius Θ β b : ℝ)
+  have hn := norm_sub_le_of_analytic_segment_bound (hseg.trans hb) h.outerChart.analytic
+    (show NormBoundOn (fderiv ℂ (fun x => A x + Δ x)) h.outerDomain (2 * Θ) from
+      ⟨by positivity, fun _ hx => h.new_upper hx⟩)
+  rw [he] at hn
+  calc
+    _ ≤ (2 * (Θ : ℝ)) * dist p (h.newInverse y) := by simpa only [dist_eq_norm] using hn
+    _ ≤ (2 * (Θ : ℝ)) * b := mul_le_mul_of_nonneg_left hpq (by positivity)
+    _ ≤ _ := le_add_of_nonneg_right (frequencyOuterRadius Θ β).coe_nonneg
+
+theorem old_image_covers_inner_erosion {Ω₀ : Set (ComplexSpace n)} (hΩ₀ : Ω₀ ⊆ Ω) (b : ℝ≥0) :
+    erosion (h.innerFrequency Ω₀ b) β ⊆ A '' h.innerDomain Ω₀ b := by
+  intro y hy
+  have hyi := erosion_subset _ _ hy
+  have hyt := h.outer_subset_target (h.inner_subset_outerFrequency hΩ₀ b hyi)
+  have hyV : y ∈ h.oldImage := erosion_subset _ _ hyt
+  have hys : y ∈ frequencyInverseSource h.oldImage β :=
+    erosion_antitone_radius _ (by
+      exact (show β + β + β ≤ β + β + β + β from le_self_add).trans le_self_add) hyt
+  have hTy : frequencyShift (Δ ∘ g) y ∈ h.innerFrequency Ω₀ b := by
+    apply hy
+    simpa [frequencyShift, dist_eq_norm] using h.shiftData.bounded.norm_le hyV
+  refine ⟨g y, ?_, h.chart.right (h.oldImage_subset hyV)⟩
+  refine ⟨frequencyShift (Δ ∘ g) y, hTy, ?_⟩
+  change g (invFunOn (frequencyShift (Δ ∘ g)) (frequencyInverseSource h.oldImage β)
+    (frequencyShift (Δ ∘ g) y)) = g y
+  rw [h.shiftData.shift_injOn.leftInvOn_invFunOn hys]
+
+theorem measure_loss {Ω₀ : Set (ComplexSpace n)} (hΩ₀ : Ω₀ ⊆ Ω) (hc : IsCompact Ω₀) (b : ℝ≥0) :
+    realVolume (G \ h.innerDomain Ω₀ b) ≤ ENNReal.ofReal ((θ : ℝ)⁻¹ ^ n) *
+      realVolume (Ω \ erosion Ω₀ (frequencyLossRadius Θ β b + β)) := by
+  have hi : h.innerDomain Ω₀ b ⊆ G :=
+    (h.inner_subset_outerDomain hΩ₀ b).trans (h.outer_subset.trans (erosion_subset _ _))
+  apply h.chart.realVolume_loss_le hi (isCompact_erosion hc _).isClosed.measurableSet
+    _ h.lower_pos h.lower
+  rw [← erosion_add]
+  exact h.old_image_covers_inner_erosion hΩ₀ b
+
+end FrequencyChangeInput
+end KamProject.Arnold1963
diff --git a/LeanPool/ArnoldKAM/Arnold1963/Geometry/FrequencyInverse.lean b/LeanPool/ArnoldKAM/Arnold1963/Geometry/FrequencyInverse.lean
new file mode 100644
index 0000000000..6f9ce04677
--- /dev/null
+++ b/LeanPool/ArnoldKAM/Arnold1963/Geometry/FrequencyInverse.lean
@@ -0,0 +1,162 @@
+/-
+Copyright (c) 2026 Bingqi Yu. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Bingqi Yu
+-/
+
+module
+
+public import LeanPool.ArnoldKAM.Arnold1963.Geometry.GlobalInverse
+public import LeanPool.ArnoldKAM.Arnold1963.Geometry.GeneratingSymmetry
+public import LeanPool.ArnoldKAM.Arnold1963.Geometry.RealCover
+
+/-!
+Construct the inverse of a frequency shift from derivative smallness, including a consistent
+analytic branch on the target domain.
+-/
+
+@[expose] public section
+noncomputable section
+open Set Function Filter Metric
+open scoped NNReal Topology
+namespace KamProject.Arnold1963
+
+variable {n : ℕ}
+
+/-- The identity frequency map plus the specified correction. -/
+def frequencyShift (a : ComplexSpace n → ComplexSpace n) (x : ComplexSpace n) := x + a x
+
+/-- The thrice-eroded source on which the frequency shift is inverted. -/
+def frequencyInverseSource (V : Set (ComplexSpace n)) (β : ℝ≥0) :=
+  erosion V (β + β + β)
+
+/-- The five-times-eroded target used to control the frequency inverse. -/
+def frequencyInverseTarget (V : Set (ComplexSpace n)) (β : ℝ≥0) :=
+  erosion V (β + β + β + β + β)
+
+/-- A set-restricted inverse of the frequency shift on its eroded source. -/
+def frequencyInverse (a : ComplexSpace n → ComplexSpace n)
+    (V : Set (ComplexSpace n)) (β : ℝ≥0) :=
+  invFunOn (frequencyShift a) (frequencyInverseSource V β)
+
+/-- Analyticity, boundedness and contraction data for inverting a small frequency shift. -/
+structure FrequencyShiftData (a : ComplexSpace n → ComplexSpace n)
+    (V : Set (ComplexSpace n)) (β κ : ℝ≥0) : Prop where
+  radius_pos : 0 < β
+  contraction : κ < 1
+  analytic : AnalyticOnNhd ℂ a V
+  bounded : NormBoundOn a V β
+  derivative : ∀ x ∈ V, ‖fderiv ℂ a x‖ ≤ κ
+
+namespace FrequencyShiftData
+variable {a : ComplexSpace n → ComplexSpace n} {V : Set (ComplexSpace n)} {β κ : ℝ≥0}
+  (d : FrequencyShiftData a V β κ)
+include d
+
+theorem lipschitz_ball {x : ComplexSpace n} {r : ℝ≥0} (hx : x ∈ erosion V r) :
+    LipschitzOnWith κ a (closedBall x r) :=
+  (convex_closedBall x (r : ℝ)).lipschitzOnWith_of_nnnorm_fderiv_le
+    (fun y hy => (d.analytic y (hx hy)).differentiableAt) (fun y hy => d.derivative y (hx hy))
+
+theorem shift_injOn : InjOn (frequencyShift a) (frequencyInverseSource V β) := by
+  apply injOn_add_of_local_lipschitz (r := ((β + β : ℝ≥0) : ℝ))
+    (ε := (β : ℝ)) (κ := κ)
+  · intro x hx
+    exact d.bounded.norm_le (erosion_subset _ _ hx)
+  · simp only [NNReal.coe_add]; linarith
+  · exact d.contraction
+  · intro x hx
+    exact d.lipschitz_ball (erosion_antitone_radius V
+      (show β + β ≤ β + β + β from le_self_add) hx)
+
+theorem shift_analytic {x : ComplexSpace n} (hx : x ∈ V) :
+    AnalyticAt ℂ (frequencyShift a) x := analyticAt_id.add (d.analytic x hx)
+
+theorem shift_derivative {x : ComplexSpace n} (hx : x ∈ V) :
+    fderiv ℂ (frequencyShift a) x = ContinuousLinearMap.id ℂ _ + fderiv ℂ a x := by
+  exact ((hasFDerivAt_id (𝕜 := ℂ) x).add (d.analytic x hx).differentiableAt.hasFDerivAt).fderiv
+
+theorem inverse_spec {y : ComplexSpace n} (hy : y ∈ frequencyInverseTarget V β) :
+    frequencyInverse a V β y ∈ erosion V (β + β + β + β) ∧
+      frequencyShift a (frequencyInverse a V β y) = y ∧
+      ‖frequencyInverse a V β y - y‖ ≤ β := by
+  have hy' : y ∈ erosion V β := erosion_antitone_radius V (by
+    exact_mod_cast (show (β : ℝ) ≤ β + β + β + β + β by linarith [β.coe_nonneg])) hy
+  have hbound : NormBoundOn a (closedBall y β) β :=
+    ⟨β.coe_nonneg, fun x hx => d.bounded.norm_le (hy' hx)⟩
+  obtain ⟨x, ⟨hx, he⟩, _⟩ := existsUnique_add_eq_on_closedBall
+    hbound (le_refl (β : ℝ)) d.contraction (d.lipschitz_ball hy')
+  have hb : x ∈ erosion V (β + β + β + β) := mem_erosion_of_dist_le hy hx
+  have hsource : x ∈ frequencyInverseSource V β :=
+    erosion_antitone_radius V (show β + β + β ≤ β + β + β + β from le_self_add) hb
+  have hi : frequencyInverse a V β y = x := by
+    change invFunOn (frequencyShift a) (frequencyInverseSource V β) y = x
+    rw [← he]
+    exact d.shift_injOn.leftInvOn_invFunOn hsource
+  rw [hi]
+  exact ⟨hb, he, by simpa only [mem_closedBall, dist_eq_norm] using hx⟩
+
+theorem inverse_analytic_right {y : ComplexSpace n}
+    (hy : y ∈ frequencyInverseTarget V β) :
+    AnalyticAt ℂ (frequencyInverse a V β) y ∧
+      ∀ᶠ z in 𝓝 y, frequencyShift a (frequencyInverse a V β z) = z := by
+  have hs := d.inverse_spec hy
+  have hx : frequencyInverse a V β y ∈ V := erosion_subset _ _ hs.1
+  have hderiv : ‖fderiv ℂ (frequencyShift a) (frequencyInverse a V β y) -
+      ContinuousLinearMap.id ℂ _‖ < 1 := by
+    rw [d.shift_derivative hx, add_sub_cancel_left]
+    exact (d.derivative _ hx).trans_lt d.contraction
+  have hh := analytic_invFunOn d.shift_injOn (erosion_mem_nhds d.radius_pos hs.1)
+    (d.shift_analytic hx) hderiv
+  rw [hs.2.1] at hh
+  exact ⟨hh.1, hh.2.2⟩
+
+theorem target_subset_image :
+    frequencyInverseTarget V β ⊆ frequencyShift a '' frequencyInverseSource V β := by
+  intro y hy
+  have hs := d.inverse_spec hy
+  exact ⟨_, erosion_antitone_radius V
+    (show β + β + β ≤ β + β + β + β from le_self_add) hs.1, hs.2.1⟩
+
+theorem inverse_conj (hV : ConjInvariant V)
+    (ha : ∀ x ∈ V, a (conjVec x) = conjVec (a x))
+    {y : ComplexSpace n} (hy : y ∈ frequencyInverseTarget V β) :
+    frequencyInverse a V β (conjVec y) = conjVec (frequencyInverse a V β y) := by
+  have hyc : conjVec y ∈ frequencyInverseTarget V β := star_mem_erosion hV hy
+  have hs := d.inverse_spec hy
+  have hc := d.inverse_spec hyc
+  apply d.shift_injOn (erosion_antitone_radius V
+    (show β + β + β ≤ β + β + β + β from le_self_add) hc.1)
+    (star_mem_erosion hV (erosion_antitone_radius V
+      (show β + β + β ≤ β + β + β + β from le_self_add) hs.1))
+  rw [hc.2.1]
+  change conjVec y = conjVec (frequencyInverse a V β y) + a (conjVec _)
+  rw [ha _ (erosion_subset _ _ hs.1)]
+  simpa only [frequencyShift, conjVec_eq_star, star_add] using (congrArg conjVec hs.2.1).symm
+
+theorem inverse_real (hV : ConjInvariant V)
+    (ha : ∀ x ∈ V, a (conjVec x) = conjVec (a x)) {y : RealSpace n}
+    (hy : complexify y ∈ frequencyInverseTarget V β) :
+    complexify (realPart (frequencyInverse a V β (complexify y))) =
+      frequencyInverse a V β (complexify y) := by
+  apply complexify_realPart_of_conj
+  simpa only [conjVec_complexify] using (d.inverse_conj hV ha hy).symm
+
+theorem derivative_bounds {x : ComplexSpace n} (hx : x ∈ V) (v : ComplexSpace n) :
+    (1 - (κ : ℝ)) * ‖v‖ ≤ ‖fderiv ℂ (frequencyShift a) x v‖ ∧
+      ‖fderiv ℂ (frequencyShift a) x v‖ ≤ (1 + (κ : ℝ)) * ‖v‖ := by
+  rw [d.shift_derivative hx]
+  change (1 - (κ : ℝ)) * ‖v‖ ≤ ‖v + fderiv ℂ a x v‖ ∧
+    ‖v + fderiv ℂ a x v‖ ≤ (1 + (κ : ℝ)) * ‖v‖
+  have hd : ‖fderiv ℂ a x v‖ ≤ (κ : ℝ) * ‖v‖ :=
+    ((fderiv ℂ a x).le_opNorm v).trans
+      (mul_le_mul_of_nonneg_right (d.derivative x hx) (norm_nonneg _))
+  constructor
+  · have hh : ‖v‖ ≤ ‖v + fderiv ℂ a x v‖ + ‖fderiv ℂ a x v‖ := by
+      simpa using norm_sub_le (v + fderiv ℂ a x v) (fderiv ℂ a x v)
+    linarith
+  · have hh := norm_add_le v (fderiv ℂ a x v)
+    linarith
+
+end FrequencyShiftData
+end KamProject.Arnold1963
diff --git a/LeanPool/ArnoldKAM/Arnold1963/Geometry/FrequencyMeasure.lean b/LeanPool/ArnoldKAM/Arnold1963/Geometry/FrequencyMeasure.lean
new file mode 100644
index 0000000000..82596ff0a5
--- /dev/null
+++ b/LeanPool/ArnoldKAM/Arnold1963/Geometry/FrequencyMeasure.lean
@@ -0,0 +1,106 @@
+/-
+Copyright (c) 2026 Bingqi Yu. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Bingqi Yu
+-/
+
+module
+
+public import LeanPool.ArnoldKAM.Arnold1963.Geometry.FrequencyChart
+public import LeanPool.ArnoldKAM.Arnold1963.Geometry.RealJacobian
+
+/-!
+Pull back real-slice measure through the original frequency chart, using real Jacobians.
+-/
+
+@[expose] public section
+noncomputable section
+open Set Function MeasureTheory
+open scoped ENNReal
+namespace KamProject.Arnold1963
+namespace AnalyticFrequencyChart
+variable {n : ℕ} {A g : ComplexSpace n → ComplexSpace n}
+  {G Ω : Set (ComplexSpace n)} (c : AnalyticFrequencyChart A g G Ω)
+include c
+
+theorem inverse_real {x : RealSpace n} (hx : complexify x ∈ Ω) :
+    complexify (realPart (g (complexify x))) = g (complexify x) := by
+  apply complexify_realPart_of_conj
+  simpa only [conjVec_complexify] using (c.inverse_conj hx).symm
+
+theorem realSlice_inverse_image {S : Set (ComplexSpace n)} (hS : S ⊆ Ω) :
+    realSlice (g '' S) = realRestriction g '' realSlice S := by
+  ext p
+  constructor
+  · rintro ⟨y, hy, he⟩
+    have hyΩ := hS hy
+    have hgy := c.inverse_maps hyΩ
+    have heA : A (complexify p) = y := by rw [← he, c.right hyΩ]
+    have hyreal : complexify (realPart y) = y := by
+      apply complexify_realPart_of_conj
+      rw [← heA]
+      exact (c.map_conj _ (he ▸ hgy)).symm.trans (by rw [conjVec_complexify])
+    refine ⟨realPart y, ?_, ?_⟩
+    · change complexify (realPart y) ∈ S
+      rwa [hyreal]
+    · change realPart (g (complexify (realPart y))) = p
+      rw [hyreal, he, realPart_complexify]
+  · rintro ⟨x, hx, rfl⟩
+    exact ⟨complexify x, hx, (c.inverse_real (hS hx)).symm⟩
+
+theorem inverse_realVolume_le {S : Set (ComplexSpace n)} (hS : MeasurableSet S)
+    (hSΩ : S ⊆ Ω) {θ : ℝ} (hθ : 0 < θ)
+    (hlo : ∀ p ∈ G, ∀ v, θ * ‖v‖ ≤ ‖fderiv ℂ A p v‖) :
+    realVolume (g '' S) ≤ ENNReal.ofReal (θ⁻¹ ^ n) * realVolume S := by
+  unfold realVolume
+  rw [c.realSlice_inverse_image hSΩ]
+  change volume (realRestriction g '' realSlice S) ≤ _ * volume (realSlice S)
+  apply real_image_measure_le (hS.preimage (continuous_complexify n).measurable)
+    (inv_nonneg.mpr hθ.le)
+  · intro x hx
+    exact (hasFDerivAt_realRestriction
+      (c.inverse_analytic _ (hSΩ hx)).differentiableAt).differentiableAt
+  · intro x hx
+    rw [(hasFDerivAt_realRestriction (c.inverse_analytic _ (hSΩ hx)).differentiableAt).fderiv]
+    exact (norm_realDerivative_le _).trans (c.inverse_derivative_le hθ hlo (hSΩ hx))
+
+theorem inverse_image_complement {G₁ : Set (ComplexSpace n)} (hG₁ : G₁ ⊆ G) :
+    g '' (Ω \ A '' G₁) = G \ G₁ := by
+  ext p
+  constructor
+  · rintro ⟨y, ⟨hy, hny⟩, rfl⟩
+    refine ⟨c.inverse_maps hy, ?_⟩
+    intro hg
+    exact hny ⟨g y, hg, c.right hy⟩
+  · rintro ⟨hp, hnp⟩
+    refine ⟨A p, ⟨c.maps hp, ?_⟩, c.left hp⟩
+    rintro ⟨q, hq, he⟩
+    exact hnp ((c.injOn (hG₁ hq) hp he) ▸ hq)
+
+theorem realVolume_loss_le {G₁ S : Set (ComplexSpace n)} (hG₁ : G₁ ⊆ G)
+    (hS : MeasurableSet S) (hcover : S ⊆ A '' G₁) {θ : ℝ} (hθ : 0 < θ)
+    (hlo : ∀ p ∈ G, ∀ v, θ * ‖v‖ ≤ ‖fderiv ℂ A p v‖) :
+    realVolume (G \ G₁) ≤ ENNReal.ofReal (θ⁻¹ ^ n) * realVolume (Ω \ S) := by
+  calc
+    _ = realVolume (g '' (Ω \ A '' G₁)) := by rw [c.inverse_image_complement hG₁]
+    _ ≤ realVolume (g '' (Ω \ S)) := realVolume_mono (image_mono (sdiff_subset_sdiff_right hcover))
+    _ ≤ _ := c.inverse_realVolume_le (c.image_compact.isClosed.measurableSet.diff hS)
+      sdiff_subset hθ hlo
+
+theorem realVolume_image_le {Θ : ℝ} (hΘ : 0 ≤ Θ)
+    (hhi : ∀ p ∈ G, ‖fderiv ℂ A p‖ ≤ Θ) :
+    realVolume Ω ≤ ENNReal.ofReal (Θ ^ n) * realVolume G := by
+  rw [← c.image_eq]
+  unfold realVolume
+  rw [c.symm.realSlice_inverse_image (Subset.refl G)]
+  change volume (realRestriction A '' realSlice G) ≤ _ * volume (realSlice G)
+  apply real_image_measure_le
+    (c.compact.isClosed.measurableSet.preimage (continuous_complexify n).measurable) hΘ
+  · intro x hx
+    exact (hasFDerivAt_realRestriction (c.analytic _ hx).differentiableAt).differentiableAt
+  · intro x hx
+    rw [(hasFDerivAt_realRestriction (c.analytic _ hx).differentiableAt).fderiv]
+    exact (norm_realDerivative_le _).trans (hhi _ hx)
+
+end AnalyticFrequencyChart
+end KamProject.Arnold1963
diff --git a/LeanPool/ArnoldKAM/Arnold1963/Geometry/GeneratingEquivariance.lean b/LeanPool/ArnoldKAM/Arnold1963/Geometry/GeneratingEquivariance.lean
new file mode 100644
index 0000000000..c32af6b791
--- /dev/null
+++ b/LeanPool/ArnoldKAM/Arnold1963/Geometry/GeneratingEquivariance.lean
@@ -0,0 +1,137 @@
+/-
+Copyright (c) 2026 Bingqi Yu. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Bingqi Yu
+-/
+
+module
+
+public import LeanPool.ArnoldKAM.Arnold1963.Geometry.GeneratingSymmetry
+
+/-!
+Uniqueness on a fixed source yields conjugation compatibility and angle equivariance.
+-/
+
+@[expose] public section
+noncomputable section
+open Set Metric Filter
+open scoped NNReal Topology
+namespace KamProject.Arnold1963
+namespace AnalyticPhaseFunction
+variable {n : ℕ} {G : Set (ComplexSpace n)} {ρ r : ℝ≥0} {M : ℝ}
+  (S : AnalyticPhaseFunction n G ρ) (d : GeneratingData S.toFun G (angleStrip n ρ) r M)
+
+include S
+
+theorem conj_generatingTarget {y : ComplexPhaseSpace n}
+    (hy : y ∈ generatingTarget G (angleStrip n ρ) r) :
+    conjPhase y ∈ generatingTarget G (angleStrip n ρ) r := by
+  constructor
+  · exact star_mem_erosion S.domain_conj hy.1
+  · apply star_mem_erosion (fun q hq => ?_) hy.2
+    apply (mem_angleStrip_iff _ _).2
+    intro j
+    simpa using (mem_angleStrip_iff _ _).1 hq j
+
+omit S in
+theorem shift_generatingTarget {y : ComplexPhaseSpace n}
+    (hy : y ∈ generatingTarget G (angleStrip n ρ) r) (k : FourierIndex n) :
+    phaseShift k y ∈ generatingTarget G (angleStrip n ρ) r :=
+  ⟨hy.1, add_mem_erosion (fun q => add_angleShift_mem_iff q k ρ) hy.2⟩
+
+theorem conj_generatingSource {x : ComplexPhaseSpace n}
+    (hx : x ∈ generatingSource G (angleStrip n ρ) r) :
+    conjPhase x ∈ generatingSource G (angleStrip n ρ) r :=
+  star_mem_erosion (fun _ hz => conj_mem_phaseDomain S.domain_conj hz) hx
+
+omit S in
+theorem shift_generatingSource {x : ComplexPhaseSpace n}
+    (hx : x ∈ generatingSource G (angleStrip n ρ) r) (k : FourierIndex n) :
+    phaseShift k x ∈ generatingSource G (angleStrip n ρ) r := by
+  rw [phaseShift_eq_add]
+  exact add_mem_erosion (fun z => by
+    simpa only [phaseShift_eq_add, phaseDomain] using
+      phaseShift_mem_phaseDomain (G := G) (ρ := ρ) k z) hx
+
+include d
+
+theorem gradients_conj_on_source {x : ComplexPhaseSpace n}
+    (hx : x ∈ generatingSource G (angleStrip n ρ) r) :
+    pGradient S.toFun (conjPhase x) = conjVec (pGradient S.toFun x) ∧
+      qGradient S.toFun (conjPhase x) = conjVec (qGradient S.toFun x) := by
+  exact gradients_conj (S.analytic _ (erosion_subset _ _ hx)) S.conj_compatible
+    (mem_of_superset (closedBall_mem_nhds _ (show (0 : ℝ) < r from d.radius_pos))
+      (S.conj_generatingSource hx))
+
+theorem input_conj {x : ComplexPhaseSpace n}
+    (hx : x ∈ generatingSource G (angleStrip n ρ) r) :
+    generatingInput S.toFun (conjPhase x) = conjPhase (generatingInput S.toFun x) := by
+  have hg := (S.gradients_conj_on_source d hx).1
+  change ((conjPhase x).1, (conjPhase x).2 + pGradient S.toFun (conjPhase x)) =
+    conjPhase (x.1, x.2 + pGradient S.toFun x)
+  rw [hg]
+  ext j <;> simp [conjPhase]
+
+theorem output_conj {x : ComplexPhaseSpace n}
+    (hx : x ∈ generatingSource G (angleStrip n ρ) r) :
+    generatingOutput S.toFun (conjPhase x) = conjPhase (generatingOutput S.toFun x) := by
+  have hg := (S.gradients_conj_on_source d hx).2
+  change ((conjPhase x).1 + qGradient S.toFun (conjPhase x), (conjPhase x).2) =
+    conjPhase (x.1 + qGradient S.toFun x, x.2)
+  rw [hg]
+  ext j <;> simp [conjPhase]
+
+theorem input_shift {x : ComplexPhaseSpace n}
+    (hx : x ∈ generatingSource G (angleStrip n ρ) r) (k : FourierIndex n) :
+    generatingInput S.toFun (phaseShift k x) = phaseShift k (generatingInput S.toFun x) := by
+  have hg := (gradients_periodic S d.radius_pos hx k).1
+  change (x.1, x.2 + angleShift k + pGradient S.toFun (phaseShift k x)) =
+    (x.1, (x.2 + pGradient S.toFun x) + angleShift k)
+  rw [hg]
+  congr 1
+  abel
+
+theorem output_shift {x : ComplexPhaseSpace n}
+    (hx : x ∈ generatingSource G (angleStrip n ρ) r) (k : FourierIndex n) :
+    generatingOutput S.toFun (phaseShift k x) = phaseShift k (generatingOutput S.toFun x) := by
+  have hg := (gradients_periodic S d.radius_pos hx k).2
+  change (x.1 + qGradient S.toFun (phaseShift k x), x.2 + angleShift k) =
+    (x.1 + qGradient S.toFun x, x.2 + angleShift k)
+  rw [hg]
+
+theorem generatingInverse_conj {y : ComplexPhaseSpace n}
+    (hy : y ∈ generatingTarget G (angleStrip n ρ) r) :
+    generatingInverse S.toFun G (angleStrip n ρ) r (conjPhase y) =
+      conjPhase (generatingInverse S.toFun G (angleStrip n ρ) r y) := by
+  apply d.input_injOn (d.inverse_mem (S.conj_generatingTarget hy))
+    (S.conj_generatingSource (d.inverse_mem hy))
+  rw [(d.inverse_spec (S.conj_generatingTarget hy)).2.1,
+    S.input_conj d (d.inverse_mem hy), (d.inverse_spec hy).2.1]
+
+theorem generatingTransform_conj {y : ComplexPhaseSpace n}
+    (hy : y ∈ generatingTarget G (angleStrip n ρ) r) :
+    generatingTransform S.toFun G (angleStrip n ρ) r (conjPhase y) =
+      conjPhase (generatingTransform S.toFun G (angleStrip n ρ) r y) := by
+  unfold generatingTransform
+  simp only [Function.comp_apply, S.generatingInverse_conj d hy]
+  exact S.output_conj d (d.inverse_mem hy)
+
+theorem generatingInverse_shift {y : ComplexPhaseSpace n}
+    (hy : y ∈ generatingTarget G (angleStrip n ρ) r) (k : FourierIndex n) :
+    generatingInverse S.toFun G (angleStrip n ρ) r (phaseShift k y) =
+      phaseShift k (generatingInverse S.toFun G (angleStrip n ρ) r y) := by
+  apply d.input_injOn (d.inverse_mem (shift_generatingTarget hy k))
+    (shift_generatingSource (d.inverse_mem hy) k)
+  rw [(d.inverse_spec (shift_generatingTarget hy k)).2.1,
+    S.input_shift d (d.inverse_mem hy) k, (d.inverse_spec hy).2.1]
+
+theorem generatingTransform_shift {y : ComplexPhaseSpace n}
+    (hy : y ∈ generatingTarget G (angleStrip n ρ) r) (k : FourierIndex n) :
+    generatingTransform S.toFun G (angleStrip n ρ) r (phaseShift k y) =
+      phaseShift k (generatingTransform S.toFun G (angleStrip n ρ) r y) := by
+  unfold generatingTransform
+  simp only [Function.comp_apply, S.generatingInverse_shift d hy k]
+  exact S.output_shift d (d.inverse_mem hy) k
+
+end AnalyticPhaseFunction
+end KamProject.Arnold1963
diff --git a/LeanPool/ArnoldKAM/Arnold1963/Geometry/GeneratingGlobal.lean b/LeanPool/ArnoldKAM/Arnold1963/Geometry/GeneratingGlobal.lean
new file mode 100644
index 0000000000..7165d42a78
--- /dev/null
+++ b/LeanPool/ArnoldKAM/Arnold1963/Geometry/GeneratingGlobal.lean
@@ -0,0 +1,241 @@
+/-
+Copyright (c) 2026 Bingqi Yu. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Bingqi Yu
+-/
+
+module
+
+public import LeanPool.ArnoldKAM.Arnold1963.Geometry.GeneratingInjective
+
+/-!
+Global generating transformations on a fixed source, their analytic inverses, and estimates
+used by the next iteration step.
+-/
+
+@[expose] public section
+noncomputable section
+open Set Function Filter
+open scoped NNReal Topology
+namespace KamProject.Arnold1963
+
+theorem canonicalAt_inverse_generating_branch {n : ℕ} {S : ComplexPhaseSpace n → ℂ}
+    {g : ComplexPhaseSpace n → ComplexPhaseSpace n} {y : ComplexPhaseSpace n}
+    (hS : AnalyticAt ℂ S (g y)) (hg : AnalyticAt ℂ g y)
+    (he : ∀ᶠ z in 𝓝 y, generatingOutput S (g z) = z) :
+    CanonicalAt (generatingInput S ∘ g) y := by
+  have hF := analyticAt_generatingInput hS
+  have hH := analyticAt_generatingOutput hS
+  have hd : (fderiv ℂ (generatingOutput S) (g y)).comp (fderiv ℂ g y) =
+      ContinuousLinearMap.id ℂ _ := by
+    rw [← fderiv_comp y hH.differentiableAt hg.differentiableAt]
+    exact (Filter.EventuallyEq.fderiv_eq he).trans fderiv_id
+  refine ⟨hF.differentiableAt.comp y hg.differentiableAt, ?_⟩
+  intro v w
+  rw [fderiv_comp y hF.differentiableAt hg.differentiableAt]
+  change symplecticForm
+    (fderiv ℂ (generatingInput S) (g y) (fderiv ℂ g y v))
+    (fderiv ℂ (generatingInput S) (g y) (fderiv ℂ g y w)) = _
+  rw [← generating_symplectic_identity hS]
+  exact congrArg₂ symplecticForm
+    (congrArg (fun L : ComplexPhaseSpace n →L[ℂ] ComplexPhaseSpace n => L v) hd)
+    (congrArg (fun L : ComplexPhaseSpace n →L[ℂ] ComplexPhaseSpace n => L w) hd)
+
+/-- The eroded phase source used to invert the generating input map. -/
+def generatingSource {n : ℕ} (G U : Set (ComplexSpace n)) (r : ℝ≥0) := erosion (G ×ˢ U) r
+/-- The asymmetric action-angle erosion retained by the generating transformation. -/
+def generatingTarget {n : ℕ} (G U : Set (ComplexSpace n)) (r : ℝ≥0) :=
+  erosion G (r + r) ×ˢ erosion U (r + r + r)
+
+/-- A set-restricted inverse of the generating input map on its phase source. -/
+def generatingInverse {n : ℕ} (S : ComplexPhaseSpace n → ℂ)
+    (G U : Set (ComplexSpace n)) (r : ℝ≥0) :=
+  invFunOn (generatingInput S) (generatingSource G U r)
+
+/-- The generating output map composed with the inverse generating input map. -/
+def generatingTransform {n : ℕ} (S : ComplexPhaseSpace n → ℂ)
+    (G U : Set (ComplexSpace n)) (r : ℝ≥0) :=
+  generatingOutput S ∘ generatingInverse S G U r
+
+/-- The reverse generating transformation obtained by inverting the generating output map. -/
+def generatingTransformInv {n : ℕ} (S : ComplexPhaseSpace n → ℂ)
+    (G U : Set (ComplexSpace n)) (r : ℝ≥0) :=
+  generatingInput S ∘ invFunOn (generatingOutput S) (generatingSource G U r)
+
+/-- Analyticity and smallness data ensuring the generating transformation is well defined. -/
+structure GeneratingData {n : ℕ} (S : ComplexPhaseSpace n → ℂ)
+    (G U : Set (ComplexSpace n)) (r : ℝ≥0) (M : ℝ) : Prop where
+  radius_pos : 0 < r
+  analytic : AnalyticOnNhd ℂ S (G ×ˢ U)
+  bounded : NormBoundOn S (G ×ˢ U) M
+  small : M / r / r < 1 / 16
+
+namespace GeneratingData
+variable {n : ℕ} {S : ComplexPhaseSpace n → ℂ} {G U : Set (ComplexSpace n)}
+  {r : ℝ≥0} {M : ℝ} (d : GeneratingData S G U r M)
+
+include d
+
+theorem input_injOn : InjOn (generatingInput S) (generatingSource G U r) :=
+  (generating_injOn d.radius_pos d.analytic d.bounded d.small).1
+theorem output_injOn : InjOn (generatingOutput S) (generatingSource G U r) :=
+  (generating_injOn d.radius_pos d.analytic d.bounded d.small).2
+
+theorem inverse_eq_of_input {x y : ComplexPhaseSpace n}
+    (hx : x ∈ generatingSource G U r) (he : generatingInput S x = y) :
+    generatingInverse S G U r y = x := by
+  rw [← he]
+  exact d.input_injOn.leftInvOn_invFunOn hx
+
+theorem inverse_spec {y : ComplexPhaseSpace n} (hy : y ∈ generatingTarget G U r) :
+    generatingInverse S G U r y ∈ erosion (G ×ˢ U) (r + r) ∧
+      generatingInput S (generatingInverse S G U r y) = y ∧
+      (generatingInverse S G U r y).1 = y.1 ∧
+      (generatingInverse S G U r y).2 ∈ Metric.closedBall y.2 r := by
+  obtain ⟨q, ⟨hq, he⟩, _⟩ := existsUnique_generating_root d.radius_pos d.analytic d.bounded
+    (d.small.trans (by norm_num)) hy.1 hy.2
+  have hx := generating_ball_buffer hy.1 hy.2 hq
+  have hD : (y.1, q) ∈ generatingSource G U r :=
+    erosion_antitone_radius _ (show r ≤ r + r from le_add_self) hx
+  have hF : generatingInput S (y.1, q) = y := Prod.ext rfl he
+  have hi : generatingInverse S G U r y = (y.1, q) := by
+    rw [← hF]
+    exact d.input_injOn.leftInvOn_invFunOn hD
+  rw [hi]
+  exact ⟨hx, hF, rfl, hq⟩
+
+theorem inverse_mem {y : ComplexPhaseSpace n} (hy : y ∈ generatingTarget G U r) :
+    generatingInverse S G U r y ∈ generatingSource G U r :=
+  erosion_antitone_radius _ (show r ≤ r + r from le_add_self) (d.inverse_spec hy).1
+
+theorem inverse_analytic_right {y : ComplexPhaseSpace n} (hy : y ∈ generatingTarget G U r) :
+    AnalyticAt ℂ (generatingInverse S G U r) y ∧
+      ∀ᶠ z in 𝓝 y, generatingInput S (generatingInverse S G U r z) = z := by
+  have hs := d.inverse_spec hy
+  have ha := d.analytic _ (erosion_subset _ _ hs.1)
+  have hh := analytic_invFunOn d.input_injOn (erosion_mem_nhds d.radius_pos hs.1)
+    (analyticAt_generatingInput ha)
+    ((norm_fderiv_generatingInput_sub_id_le ha).trans_lt
+      ((norm_fderiv_pGradient_le d.radius_pos d.analytic d.bounded hs.1).trans_lt
+        (d.small.trans (by norm_num))))
+  rw [hs.2.1] at hh
+  exact ⟨hh.1, hh.2.2⟩
+
+theorem transform_analytic : AnalyticOnNhd ℂ (generatingTransform S G U r)
+    (generatingTarget G U r) := by
+  intro y hy
+  exact (analyticAt_generatingOutput (d.analytic _
+    (erosion_subset _ _ (d.inverse_spec hy).1))).comp (d.inverse_analytic_right hy).1
+
+theorem transform_canonical : CanonicalOn (generatingTransform S G U r)
+    (generatingTarget G U r) := by
+  intro y hy
+  exact canonicalAt_generating_branch (d.analytic _
+    (erosion_subset _ _ (d.inverse_spec hy).1))
+    (d.inverse_analytic_right hy).1 (d.inverse_analytic_right hy).2
+
+theorem transform_bounds {y : ComplexPhaseSpace n} (hy : y ∈ generatingTarget G U r) :
+    ‖generatingTransform S G U r y - y‖ ≤ M / r ∧
+      generatingTransform S G U r y ∈ G ×ˢ U := by
+  obtain ⟨hx, he, hp, hq⟩ := d.inverse_spec hy
+  have hpair : generatingInverse S G U r y = (y.1, (generatingInverse S G U r y).2) :=
+    Prod.ext hp rfl
+  rw [hpair] at he
+  have hh := generating_root_bounds d.radius_pos d.analytic d.bounded
+    (d.small.le.trans (by norm_num)) hy.1 hy.2 hq (congrArg Prod.snd he)
+  change ‖generatingOutput S (generatingInverse S G U r y) - y‖ ≤ _ ∧
+    generatingOutput S (generatingInverse S G U r y) ∈ G ×ˢ U
+  rw [hpair]
+  exact hh
+
+theorem displacement_bound : NormBoundOn (fun y => generatingTransform S G U r y - y)
+    (generatingTarget G U r) (M / r) :=
+  ⟨div_nonneg d.bounded.nonneg r.coe_nonneg, fun _ hy => (d.transform_bounds hy).1⟩
+
+theorem transform_mapsTo : MapsTo (generatingTransform S G U r)
+    (generatingTarget G U r) (G ×ˢ U) := fun _ hy => (d.transform_bounds hy).2
+
+theorem derivative_bound {y : ComplexPhaseSpace n} (hy : y ∈ generatingTarget G U r) :
+    ‖fderiv ℂ (generatingTransform S G U r) y‖ ≤ 5 / 3 := by
+  have hx := (d.inverse_spec hy).1
+  exact norm_fderiv_generating_branch_le (d.analytic _ (erosion_subset _ _ hx))
+    (d.inverse_analytic_right hy).1 (d.inverse_analytic_right hy).2
+    ((norm_fderiv_pGradient_le d.radius_pos d.analytic d.bounded hx).trans
+      (d.small.le.trans (by norm_num)))
+    ((norm_fderiv_qGradient_le d.radius_pos d.analytic d.bounded hx).trans
+      (d.small.le.trans (by norm_num)))
+
+theorem transform_injOn : InjOn (generatingTransform S G U r) (generatingTarget G U r) := by
+  intro y hy z hz he
+  have hh := d.output_injOn (d.inverse_mem hy) (d.inverse_mem hz) he
+  rw [← (d.inverse_spec hy).2.1, ← (d.inverse_spec hz).2.1, hh]
+
+theorem transform_left_inv {y : ComplexPhaseSpace n} (hy : y ∈ generatingTarget G U r) :
+    generatingTransformInv S G U r (generatingTransform S G U r y) = y := by
+  change generatingInput S (invFunOn (generatingOutput S) (generatingSource G U r)
+    (generatingOutput S (generatingInverse S G U r y))) = y
+  rw [d.output_injOn.leftInvOn_invFunOn (d.inverse_mem hy)]
+  exact (d.inverse_spec hy).2.1
+
+theorem transformInv_analytic : AnalyticOnNhd ℂ (generatingTransformInv S G U r)
+    (generatingTransform S G U r '' generatingTarget G U r) := by
+  rintro z ⟨y, hy, rfl⟩
+  have hx := (d.inverse_spec hy).1
+  have ha := d.analytic _ (erosion_subset _ _ hx)
+  have hh := analytic_invFunOn d.output_injOn (erosion_mem_nhds d.radius_pos hx)
+    (analyticAt_generatingOutput ha)
+    ((norm_fderiv_generatingOutput_sub_id_le ha).trans_lt
+      ((norm_fderiv_qGradient_le d.radius_pos d.analytic d.bounded hx).trans_lt
+        (d.small.trans (by norm_num))))
+  exact ((show AnalyticAt ℂ (generatingInput S)
+    (invFunOn (generatingOutput S) (generatingSource G U r)
+      (generatingTransform S G U r y)) by
+        change AnalyticAt ℂ (generatingInput S)
+          (invFunOn (generatingOutput S) (generatingSource G U r)
+            (generatingOutput S (generatingInverse S G U r y)))
+        rw [hh.2.1]
+        exact analyticAt_generatingInput ha)).comp hh.1
+
+theorem transform_right_inv {z : ComplexPhaseSpace n}
+    (hz : z ∈ generatingTransform S G U r '' generatingTarget G U r) :
+    generatingTransform S G U r (generatingTransformInv S G U r z) = z := by
+  obtain ⟨y, hy, rfl⟩ := hz
+  rw [d.transform_left_inv hy]
+
+theorem transformInv_canonical : CanonicalOn (generatingTransformInv S G U r)
+    (generatingTransform S G U r '' generatingTarget G U r) := by
+  rintro z ⟨y, hy, rfl⟩
+  have hx := (d.inverse_spec hy).1
+  have ha := d.analytic _ (erosion_subset _ _ hx)
+  have hh := analytic_invFunOn d.output_injOn (erosion_mem_nhds d.radius_pos hx)
+    (analyticAt_generatingOutput ha)
+    ((norm_fderiv_generatingOutput_sub_id_le ha).trans_lt
+      ((norm_fderiv_qGradient_le d.radius_pos d.analytic d.bounded hx).trans_lt
+        (d.small.trans (by norm_num))))
+  apply canonicalAt_inverse_generating_branch (g := invFunOn (generatingOutput S)
+    (generatingSource G U r)) (y := generatingOutput S (generatingInverse S G U r y))
+  · rw [hh.2.1]
+    exact ha
+  · exact hh.1
+  · exact hh.2.2
+
+theorem equations {y : ComplexPhaseSpace n} (hy : y ∈ generatingTarget G U r) :
+    (generatingTransform S G U r y).1 = y.1 +
+      qGradient S (y.1, (generatingTransform S G U r y).2) ∧
+    y.2 = (generatingTransform S G U r y).2 +
+      pGradient S (y.1, (generatingTransform S G U r y).2) := by
+  have he := (d.inverse_spec hy).2.1
+  have hp := (d.inverse_spec hy).2.2.1
+  have hpair : generatingInverse S G U r y = (y.1, (generatingInverse S G U r y).2) :=
+    Prod.ext hp rfl
+  constructor
+  · change (generatingInverse S G U r y).1 + qGradient S (generatingInverse S G U r y) = _
+    simp only [generatingTransform, Function.comp_apply, generatingOutput]
+    rw [hp, hpair]
+  · change y.2 = (generatingInverse S G U r y).2 +
+      pGradient S (y.1, (generatingInverse S G U r y).2)
+    rw [← hpair]
+    exact (congrArg Prod.snd he).symm
+
+end GeneratingData
+end KamProject.Arnold1963
diff --git a/LeanPool/ArnoldKAM/Arnold1963/Geometry/GeneratingImplicit.lean b/LeanPool/ArnoldKAM/Arnold1963/Geometry/GeneratingImplicit.lean
new file mode 100644
index 0000000000..2715dd6cbf
--- /dev/null
+++ b/LeanPool/ArnoldKAM/Arnold1963/Geometry/GeneratingImplicit.lean
@@ -0,0 +1,100 @@
+/-
+Copyright (c) 2026 Bingqi Yu. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Bingqi Yu
+-/
+
+module
+
+public import LeanPool.ArnoldKAM.Arnold1963.Geometry.NearIdentity
+public import LeanPool.ArnoldKAM.Arnold1963.Geometry.GeneratingMaps
+
+/-!
+Construct the unique small-displacement root of the generating equation from analyticity
+and uniform bounds.
+-/
+
+@[expose] public section
+noncomputable section
+open Set Metric
+open scoped NNReal Topology
+namespace KamProject.Arnold1963
+
+variable {n : ℕ} {S : ComplexPhaseSpace n → ℂ} {G U : Set (ComplexSpace n)}
+  {r : ℝ≥0} {M : ℝ} {P Q : ComplexSpace n}
+
+theorem generating_ball_buffer
+    (hP : P ∈ erosion G (r + r)) (hQ : Q ∈ erosion U ((r + r) + r))
+    {q : ComplexSpace n} (hq : q ∈ closedBall Q r) :
+    (P, q) ∈ erosion (G ×ˢ U) (r + r) :=
+  prod_mem_erosion hP (mem_erosion_of_dist_le hQ hq)
+
+theorem existsUnique_generating_root (hr : 0 < r)
+    (hS : AnalyticOnNhd ℂ S (G ×ˢ U)) (hM : NormBoundOn S (G ×ˢ U) M)
+    (hsmall : M / r / r < 1)
+    (hP : P ∈ erosion G (r + r)) (hQ : Q ∈ erosion U ((r + r) + r)) :
+    ∃! q, q ∈ closedBall Q r ∧ q + pGradient S (P, q) = Q := by
+  let a : ComplexSpace n → ComplexSpace n := fun q => pGradient S (P, q)
+  let κ : ℝ≥0 := ⟨M / r / r, div_nonneg (div_nonneg hM.nonneg r.coe_nonneg) r.coe_nonneg⟩
+  have hp (q : ComplexSpace n) (hq : q ∈ closedBall Q r) := generating_ball_buffer hP hQ hq
+  have hA (q : ComplexSpace n) (hq : q ∈ closedBall Q r) : AnalyticAt ℂ a q :=
+    (analyticAt_pGradient (hS _ (erosion_subset _ _ (hp q hq)))).comp
+      (f := fun t => (P, t)) (analyticAt_const.prod analyticAt_id)
+  have hd (q : ComplexSpace n) (hq : q ∈ closedBall Q r) :
+      ‖fderiv ℂ a q‖ ≤ M / r / r := by
+    have hc := ((analyticAt_pGradient
+      (hS _ (erosion_subset _ _ (hp q hq)))).differentiableAt.hasFDerivAt).comp q
+      ((hasFDerivAt_const P q).prodMk (hasFDerivAt_id (𝕜 := ℂ) q))
+    apply le_trans (b := ‖fderiv ℂ (pGradient S) (P, q)‖)
+    · refine (fderiv ℂ a q).opNorm_le_bound (norm_nonneg _) ?_
+      intro v
+      change ‖fderiv ℂ (pGradient S ∘ Prod.mk P) q v‖ ≤ _
+      rw [hc.fderiv]
+      simpa using (fderiv ℂ (pGradient S) (P, q)).le_opNorm (0, v)
+    · exact norm_fderiv_pGradient_le hr hS hM (hp q hq)
+  have hLip : LipschitzOnWith κ a (closedBall Q r) :=
+    (convex_closedBall Q (r : ℝ)).lipschitzOnWith_of_nnnorm_fderiv_le
+      (fun q hq => (hA q hq).differentiableAt) (fun q hq => hd q hq)
+  have hb : NormBoundOn a (closedBall Q r) (M / r) := by
+    refine ⟨div_nonneg hM.nonneg r.coe_nonneg, ?_⟩
+    intro q hq
+    exact norm_pGradient_le_div hr hS hM
+      (erosion_antitone_radius _ (le_add_self) (hp q hq))
+  exact existsUnique_add_eq_on_closedBall hb
+    (le_of_lt (by simpa using (div_lt_iff₀ (show (0 : ℝ) < r from hr)).mp hsmall))
+    hsmall hLip
+
+theorem generating_root_bounds (hr : 0 < r)
+    (hS : AnalyticOnNhd ℂ S (G ×ˢ U)) (hM : NormBoundOn S (G ×ˢ U) M)
+    (hsmall : M / r / r ≤ 1)
+    (hP : P ∈ erosion G (r + r)) (hQ : Q ∈ erosion U ((r + r) + r))
+    {q : ComplexSpace n} (hq : q ∈ closedBall Q r) (he : q + pGradient S (P, q) = Q) :
+    ‖generatingOutput S (P, q) - (P, Q)‖ ≤ M / r ∧
+      generatingOutput S (P, q) ∈ G ×ˢ U := by
+  have hx := generating_ball_buffer hP hQ hq
+  have hx' := erosion_antitone_radius (G ×ˢ U) (show r ≤ r + r from le_add_self) hx
+  have hbP := norm_pGradient_le_div hr hS hM hx'
+  have hbQ := norm_qGradient_le_div hr hS hM hx'
+  have hε : M / r ≤ (r : ℝ) := by
+    simpa using (div_le_iff₀ (show (0 : ℝ) < r from hr)).mp hsmall
+  constructor
+  · simpa [generatingOutput, Prod.sub_def, Prod.norm_def] using
+      max_le hbQ (norm_sub_le_of_add_eq (a := fun t => pGradient S (P, t)) he hbP)
+  · constructor
+    · apply (erosion_antitone_radius G (show r ≤ r + r from le_add_self) hP)
+      simpa [generatingOutput, Metric.mem_closedBall, dist_eq_norm] using hbQ.trans hε
+    · exact (erosion_subset _ _ hx).2
+
+theorem generating_action_displacement_le {δ : ℝ≥0} (hδ : 0 < δ)
+    (hS : AnalyticOnNhd ℂ S (G ×ˢ U)) (hM : NormBoundOn S (G ×ˢ U) M)
+    (hP : P ∈ G) (hQ : Q ∈ erosion U (((r + r) + r) + δ))
+    {q : ComplexSpace n} (hq : q ∈ closedBall Q r) :
+    ‖(generatingOutput S (P, q)).1 - P‖ ≤ M / δ := by
+  have hQr : Q ∈ erosion U (δ + r) :=
+    erosion_antitone_radius U (by
+      simpa only [add_assoc, add_comm, add_left_comm] using
+        (show δ + r ≤ (δ + r) + (r + r) from le_self_add)) hQ
+  have hqδ := mem_erosion_of_dist_le hQr hq
+  simpa [generatingOutput] using norm_qGradient_le_on_product hδ hS hM hP hqδ
+
+end KamProject.Arnold1963
diff --git a/LeanPool/ArnoldKAM/Arnold1963/Geometry/GeneratingInjective.lean b/LeanPool/ArnoldKAM/Arnold1963/Geometry/GeneratingInjective.lean
new file mode 100644
index 0000000000..721e84352f
--- /dev/null
+++ b/LeanPool/ArnoldKAM/Arnold1963/Geometry/GeneratingInjective.lean
@@ -0,0 +1,104 @@
+/-
+Copyright (c) 2026 Bingqi Yu. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Bingqi Yu
+-/
+
+module
+
+public import LeanPool.ArnoldKAM.Arnold1963.Geometry.GlobalInverse
+public import Mathlib.Analysis.Normed.Operator.Prod
+
+/-!
+The generating-function smallness bound gives injectivity of both mixed-coordinate maps
+on the same buffered source domain.
+-/
+
+@[expose] public section
+noncomputable section
+open Set Metric
+open scoped NNReal
+namespace KamProject.Arnold1963
+
+theorem generating_small_sixteenth {n : ℕ} (hn : 0 < n) {r : ℝ≥0} (hr : 0 < r)
+    {M : ℝ} (hM : M < (r : ℝ) ^ 2 / (16 * n)) : M / r / r < 1 / 16 := by
+  have hn1 : (1 : ℝ) ≤ n := by exact_mod_cast hn
+  have hd : (16 : ℝ) ≤ 16 * n := by linarith
+  have hb := hM.trans_le (div_le_div_of_nonneg_left (sq_nonneg (r : ℝ)) (by norm_num) hd)
+  apply (div_lt_iff₀ (show (0 : ℝ) < r from hr)).2
+  apply (div_lt_iff₀ (show (0 : ℝ) < r from hr)).2
+  nlinarith
+
+variable {n : ℕ} {S : ComplexPhaseSpace n → ℂ} {V : Set (ComplexPhaseSpace n)}
+  {r : ℝ≥0} {M : ℝ}
+
+theorem generating_injOn (hr : 0 < r) (hS : AnalyticOnNhd ℂ S V)
+    (hM : NormBoundOn S V M) (hsmall : M / r / r < 1 / 16) :
+    InjOn (generatingInput S) (erosion V r) ∧
+      InjOn (generatingOutput S) (erosion V r) := by
+  have hquarter : (0 : ℝ≥0) < r / 4 := by positivity
+  have hhalf : r / 4 + r / 4 = r / 2 := by ring
+  have hsum : r / 2 + r / 2 = r := by ring
+  have hR : (0 : ℝ) < r := hr
+  have hnum : M / (r / 4 : ℝ≥0) / (r / 4 : ℝ≥0) = 16 * (M / r / r) := by
+    simp only [NNReal.coe_div, NNReal.coe_ofNat]
+    field_simp
+    ring
+  let κ : ℝ≥0 := ⟨M / (r / 4 : ℝ≥0) / (r / 4 : ℝ≥0),
+    div_nonneg (div_nonneg hM.nonneg (by positivity)) (by positivity)⟩
+  have hk : κ < 1 := by change M / _ / _ < 1; rw [hnum]; linarith
+  have hε : 2 * (M / r) ≤ (r / 2 : ℝ≥0) := by
+    have hh := (div_lt_iff₀ hR).mp hsmall
+    norm_num only [NNReal.coe_div, NNReal.coe_ofNat]
+    linarith
+  have hbuffer {x z : ComplexPhaseSpace n} (hx : x ∈ erosion V r)
+      (hz : z ∈ closedBall x (r / 2 : ℝ≥0)) : z ∈ erosion V (r / 4 + r / 4) := by
+    rw [hhalf]
+    apply mem_erosion_of_dist_le (s := r / 2) (by simpa only [hsum] using hx) hz
+  have hproof (b : Bool) :
+      InjOn (fun x => x + if b then (0, pGradient S x) else (qGradient S x, 0))
+        (erosion V r) := by
+    apply injOn_add_of_local_lipschitz (ε := M / r) (κ := κ) (r := (r / 2 : ℝ≥0))
+    · intro x hx
+      cases b
+      · simpa using norm_qGradient_le_div hr hS hM hx
+      · simpa using norm_pGradient_le_div hr hS hM hx
+    · exact hε
+    · exact hk
+    · intro x hx
+      apply (convex_closedBall x (r / 2 : ℝ≥0)).lipschitzOnWith_of_nnnorm_fderiv_le (𝕜 := ℂ)
+      · intro z hz
+        have ha := hS z (erosion_subset _ _ (hbuffer hx hz))
+        cases b
+        · exact ((analyticAt_qGradient ha).prod analyticAt_const).differentiableAt
+        · exact (analyticAt_const.prod (analyticAt_pGradient ha)).differentiableAt
+      · intro z hz
+        have ha := hS z (erosion_subset _ _ (hbuffer hx hz))
+        change ‖fderiv ℂ (fun x => if b then (0, pGradient S x)
+          else (qGradient S x, 0)) z‖ ≤ (κ : ℝ)
+        cases b
+        · have hd := (analyticAt_qGradient ha).differentiableAt.hasFDerivAt.prodMk
+            (hasFDerivAt_const (0 : ComplexSpace n) z)
+          change ‖fderiv ℂ (fun x => (qGradient S x, 0)) z‖ ≤ _
+          rw [hd.fderiv, ContinuousLinearMap.opNorm_prod]
+          simp only [Prod.norm_def, norm_zero, max_eq_left (norm_nonneg _)]
+          convert norm_fderiv_qGradient_le hquarter hS hM (hbuffer hx hz) using 1
+          simp [κ]
+          rfl
+        · have hd := (hasFDerivAt_const (0 : ComplexSpace n) z).prodMk
+            (analyticAt_pGradient ha).differentiableAt.hasFDerivAt
+          change ‖fderiv ℂ (fun x => (0, pGradient S x)) z‖ ≤ _
+          rw [hd.fderiv, ContinuousLinearMap.opNorm_prod]
+          simp only [Prod.norm_def, norm_zero, max_eq_right (norm_nonneg _)]
+          convert norm_fderiv_pGradient_le hquarter hS hM (hbuffer hx hz) using 1
+          simp [κ]
+          rfl
+  constructor
+  · intro x hx y hy he
+    apply hproof true hx hy
+    simpa [Prod.add_def, generatingInput] using he
+  · intro x hx y hy he
+    apply hproof false hx hy
+    simpa [Prod.add_def, generatingOutput] using he
+
+end KamProject.Arnold1963
diff --git a/LeanPool/ArnoldKAM/Arnold1963/Geometry/GeneratingLocal.lean b/LeanPool/ArnoldKAM/Arnold1963/Geometry/GeneratingLocal.lean
new file mode 100644
index 0000000000..6f96829e6b
--- /dev/null
+++ b/LeanPool/ArnoldKAM/Arnold1963/Geometry/GeneratingLocal.lean
@@ -0,0 +1,175 @@
+/-
+Copyright (c) 2026 Bingqi Yu. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Bingqi Yu
+-/
+
+module
+
+public import LeanPool.ArnoldKAM.Arnold1963.Geometry.GeneratingImplicit
+
+/-!
+Local analytic canonical branches of the generating equation. The neighborhood is open in
+the ambient target space; the branch properties are conclusions of the construction.
+-/
+
+@[expose] public section
+noncomputable section
+open Set Metric Filter
+open scoped NNReal Topology
+namespace KamProject.Arnold1963
+
+theorem generating_small_of_arnold {n : ℕ} (hn : 0 < n) {r : ℝ≥0} (hr : 0 < r)
+    {M : ℝ} (hM : M < (r : ℝ) ^ 2 / (16 * n)) : M / r / r < 1 / 4 := by
+  have hn1 : (1 : ℝ) ≤ n := by exact_mod_cast hn
+  have hd : (4 : ℝ) ≤ 16 * n := by linarith
+  have hb : M < (r : ℝ) ^ 2 / 4 := hM.trans_le
+    (div_le_div_of_nonneg_left (sq_nonneg _) (by norm_num) hd)
+  apply (div_lt_iff₀ (show (0 : ℝ) < r from hr)).2
+  apply (div_lt_iff₀ (show (0 : ℝ) < r from hr)).2
+  nlinarith
+
+/-- A local analytic inverse branch of the generating input map around a target point. -/
+structure GeneratingLocalBranch {n : ℕ} (S : ComplexPhaseSpace n → ℂ)
+    (G U : Set (ComplexSpace n)) (r : ℝ≥0) (M : ℝ) (y : ComplexPhaseSpace n) where
+  /-- The local inverse function for the generating input map. -/
+  inverse : ComplexPhaseSpace n → ComplexPhaseSpace n
+  /-- The open target neighborhood on which the inverse branch is analytic. -/
+  neighborhood : Set (ComplexPhaseSpace n)
+  isOpen_neighborhood : IsOpen neighborhood
+  center_mem : y ∈ neighborhood
+  analytic_inverse : AnalyticOnNhd ℂ inverse neighborhood
+  implicit_eq : ∀ z ∈ neighborhood, generatingInput S (inverse z) = z
+  source_mem : MapsTo inverse neighborhood (G ×ˢ U)
+  analytic_transform : AnalyticOnNhd ℂ (generatingOutput S ∘ inverse) neighborhood
+  canonical : CanonicalOn (generatingOutput S ∘ inverse) neighborhood
+  mapsTo : MapsTo (generatingOutput S ∘ inverse) neighborhood (G ×ˢ U)
+  derivative_lt_two : ∀ z ∈ neighborhood, ‖fderiv ℂ (generatingOutput S ∘ inverse) z‖ < 2
+  displacement_center : ‖generatingOutput S (inverse y) - y‖ ≤ M / r
+  root_in_ball : (inverse y).2 ∈ closedBall y.2 r
+
+theorem exists_generatingLocalBranch {n : ℕ} {S : ComplexPhaseSpace n → ℂ}
+    {G U : Set (ComplexSpace n)} {r : ℝ≥0} {M : ℝ} {P Q : ComplexSpace n}
+    (hr : 0 < r) (hS : AnalyticOnNhd ℂ S (G ×ˢ U))
+    (hM : NormBoundOn S (G ×ˢ U) M) (hsmall : M / r / r < 1 / 4)
+    (hP : P ∈ erosion G (r + r)) (hQ : Q ∈ erosion U ((r + r) + r)) :
+    Nonempty (GeneratingLocalBranch S G U r M (P, Q)) := by
+  have hsmall1 : M / r / r < 1 := lt_trans hsmall (by norm_num)
+  obtain ⟨q, ⟨hq, he⟩, _⟩ := existsUnique_generating_root hr hS hM hsmall1 hP hQ
+  have hx := generating_ball_buffer hP hQ hq
+  have hAx := hS (P, q) (erosion_subset _ _ hx)
+  have hF : generatingInput S (P, q) = (P, Q) := Prod.ext rfl he
+  have hpB := norm_fderiv_pGradient_le hr hS hM hx
+  have hqB := norm_fderiv_qGradient_le hr hS hM hx
+  obtain ⟨g, hg, hgy, hright⟩ := exists_analytic_local_inverse
+    (analyticAt_generatingInput hAx)
+    ((norm_fderiv_generatingInput_sub_id_le hAx).trans_lt (hpB.trans_lt hsmall1))
+  rw [hF] at hg hgy hright
+  have hSg : AnalyticAt ℂ S (g (P, Q)) := by rw [hgy]; exact hAx
+  have hB : AnalyticAt ℂ (generatingOutput S ∘ g) (P, Q) :=
+    (analyticAt_generatingOutput hSg).comp hg
+  have hder : ‖fderiv ℂ (generatingOutput S ∘ g) (P, Q)‖ < 2 :=
+    (norm_fderiv_generating_branch_le hSg hg hright
+      (by rw [hgy]; exact hpB.trans hsmall.le)
+      (by rw [hgy]; exact hqB.trans hsmall.le)).trans_lt (by norm_num)
+  have hbounds := generating_root_bounds hr hS hM hsmall1.le hP hQ hq he
+  have hε : M / r ≤ (r : ℝ) := by
+    simpa using (div_le_iff₀ (show (0 : ℝ) < r from hr)).mp hsmall1.le
+  have hout : generatingOutput S (P, q) ∈ erosion (G ×ˢ U) r := by
+    apply prod_mem_erosion
+    · apply mem_erosion_of_dist_le hP
+      have hb := norm_qGradient_le_div hr hS hM
+        (erosion_antitone_radius _ (show r ≤ r + r from le_add_self) hx)
+      simpa [generatingOutput, dist_eq_norm] using hb.trans hε
+    · exact erosion_antitone_radius U (show r ≤ r + r from le_add_self)
+        (mem_erosion_of_dist_le hQ hq)
+  have hin_nhds : G ×ˢ U ∈ 𝓝 (g (P, Q)) := by
+    rw [hgy]
+    exact mem_of_superset (closedBall_mem_nhds _ (show (0 : ℝ) < r + r by positivity)) hx
+  have hout_nhds : G ×ˢ U ∈ 𝓝 ((generatingOutput S ∘ g) (P, Q)) := by
+    change G ×ˢ U ∈ 𝓝 (generatingOutput S (g (P, Q)))
+    rw [hgy]
+    exact mem_of_superset (closedBall_mem_nhds _ (show (0 : ℝ) < r from hr)) hout
+  have hlocal : ∀ᶠ z in 𝓝 (P, Q),
+      AnalyticAt ℂ g z ∧ generatingInput S (g z) = z ∧ g z ∈ G ×ˢ U ∧
+      AnalyticAt ℂ (generatingOutput S ∘ g) z ∧
+      CanonicalAt (generatingOutput S ∘ g) z ∧
+      (generatingOutput S ∘ g) z ∈ G ×ˢ U ∧
+      ‖fderiv ℂ (generatingOutput S ∘ g) z‖ < 2 := by
+    filter_upwards [hg.eventually_analyticAt, hright, hright.eventually_nhds,
+      hg.continuousAt hin_nhds, hB.eventually_analyticAt, hB.continuousAt hout_nhds,
+      hB.fderiv.continuousAt.norm (gt_mem_nhds hder)] with z hgz hz hzloc hzin hBz hzout hd
+    exact ⟨hgz, hz, hzin, hBz, canonicalAt_generating_branch (hS _ hzin) hgz hzloc, hzout, hd⟩
+  obtain ⟨V, hV, hVo, hyV⟩ := _root_.eventually_nhds_iff.mp hlocal
+  refine ⟨{
+    inverse := g
+    neighborhood := V
+    isOpen_neighborhood := hVo
+    center_mem := hyV
+    analytic_inverse := fun z hz => (hV z hz).1
+    implicit_eq := fun z hz => (hV z hz).2.1
+    source_mem := fun z hz => (hV z hz).2.2.1
+    analytic_transform := fun z hz => (hV z hz).2.2.2.1
+    canonical := fun z hz => (hV z hz).2.2.2.2.1
+    mapsTo := fun z hz => (hV z hz).2.2.2.2.2.1
+    derivative_lt_two := fun z hz => (hV z hz).2.2.2.2.2.2
+    displacement_center := ?_
+    root_in_ball := ?_ }⟩
+  · rw [hgy]; exact hbounds.1
+  · rw [hgy]; exact hq
+
+theorem AnalyticPhaseFunction.exists_generatingLocalBranch {n : ℕ}
+    {G : Set (ComplexSpace n)} {ρ r : ℝ≥0} (S : AnalyticPhaseFunction n G ρ)
+    (hr : 0 < r) (hsmall : S.uniformNorm / r / r < 1 / 4)
+    {P Q : ComplexSpace n} (hP : P ∈ erosion G (r + r))
+    (hQ : Q ∈ erosion (angleStrip n ρ) ((r + r) + r)) :
+    Nonempty (GeneratingLocalBranch S.toFun G (angleStrip n ρ) r S.uniformNorm (P, Q)) :=
+  KamProject.Arnold1963.exists_generatingLocalBranch hr S.analytic
+    (S.norm_le_iff.mp le_rfl) hsmall hP hQ
+
+theorem generatingLocalBranch_center_unique {n : ℕ} {S : ComplexPhaseSpace n → ℂ}
+    {G U : Set (ComplexSpace n)} {r : ℝ≥0} {M : ℝ} {P Q : ComplexSpace n}
+    (hr : 0 < r) (hS : AnalyticOnNhd ℂ S (G ×ˢ U))
+    (hM : NormBoundOn S (G ×ˢ U) M) (hsmall : M / r / r < 1)
+    (hP : P ∈ erosion G (r + r)) (hQ : Q ∈ erosion U ((r + r) + r))
+    (b c : GeneratingLocalBranch S G U r M (P, Q)) : b.inverse (P, Q) = c.inverse (P, Q) := by
+  have hb := b.implicit_eq _ b.center_mem
+  have hc := c.implicit_eq _ c.center_mem
+  have hbp : (b.inverse (P, Q)).1 = P := congrArg Prod.fst hb
+  have hcp : (c.inverse (P, Q)).1 = P := congrArg Prod.fst hc
+  obtain ⟨q, hq, hu⟩ := existsUnique_generating_root hr hS hM hsmall hP hQ
+  have heb : (b.inverse (P, Q)).2 + pGradient S (P, (b.inverse (P, Q)).2) = Q := by
+    rw [show (P, (b.inverse (P, Q)).2) = b.inverse (P, Q) from Prod.ext hbp.symm rfl]
+    exact congrArg Prod.snd hb
+  have hec : (c.inverse (P, Q)).2 + pGradient S (P, (c.inverse (P, Q)).2) = Q := by
+    rw [show (P, (c.inverse (P, Q)).2) = c.inverse (P, Q) from Prod.ext hcp.symm rfl]
+    exact congrArg Prod.snd hc
+  exact Prod.ext (hbp.trans hcp.symm)
+    ((hu _ ⟨b.root_in_ball, heb⟩).trans (hu _ ⟨c.root_in_ball, hec⟩).symm)
+
+namespace GeneratingLocalBranch
+variable {n : ℕ} {S : ComplexPhaseSpace n → ℂ} {G U : Set (ComplexSpace n)}
+  {r : ℝ≥0} {M : ℝ} {y : ComplexPhaseSpace n}
+
+/-- The generating output map evaluated through the local inverse branch. -/
+def transform (b : GeneratingLocalBranch S G U r M y) := generatingOutput S ∘ b.inverse
+
+theorem equations (b : GeneratingLocalBranch S G U r M y) {z : ComplexPhaseSpace n}
+    (hz : z ∈ b.neighborhood) :
+    (b.transform z).1 = z.1 + qGradient S (z.1, (b.transform z).2) ∧
+      z.2 = (b.transform z).2 + pGradient S (z.1, (b.transform z).2) := by
+  have he := b.implicit_eq z hz
+  have hp := congrArg (fun x : ComplexPhaseSpace n => x.1) he
+  change (b.inverse z).1 = z.1 at hp
+  have heq : b.inverse z = (z.1, (b.inverse z).2) := Prod.ext hp rfl
+  constructor
+  · change (b.inverse z).1 + qGradient S (b.inverse z) = _
+    simp only [transform, Function.comp_apply, generatingOutput]
+    rw [hp, heq]
+  · change z.2 = (b.inverse z).2 + pGradient S (z.1, (b.inverse z).2)
+    rw [← heq]
+    exact (congrArg Prod.snd he).symm
+
+end GeneratingLocalBranch
+
+end KamProject.Arnold1963
diff --git a/LeanPool/ArnoldKAM/Arnold1963/Geometry/GeneratingMaps.lean b/LeanPool/ArnoldKAM/Arnold1963/Geometry/GeneratingMaps.lean
new file mode 100644
index 0000000000..baf7b3d361
--- /dev/null
+++ b/LeanPool/ArnoldKAM/Arnold1963/Geometry/GeneratingMaps.lean
@@ -0,0 +1,156 @@
+/-
+Copyright (c) 2026 Bingqi Yu. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Bingqi Yu
+-/
+
+module
+
+public import LeanPool.ArnoldKAM.Arnold1963.Geometry.GradientBounds
+
+/-!
+Mixed-coordinate maps (P, q + S_P) and (P + S_q, q), and the Hessian symplectic identity.
+-/
+
+@[expose] public section
+noncomputable section
+open scoped Topology
+namespace KamProject.Arnold1963
+
+/-- The input coordinate map associated with a generating function. -/
+def generatingInput {n : ℕ} (S : ComplexPhaseSpace n → ℂ)
+    (x : ComplexPhaseSpace n) : ComplexPhaseSpace n := (x.1, x.2 + pGradient S x)
+
+/-- The output coordinate map associated with a generating function. -/
+def generatingOutput {n : ℕ} (S : ComplexPhaseSpace n → ℂ)
+    (x : ComplexPhaseSpace n) : ComplexPhaseSpace n := (x.1 + qGradient S x, x.2)
+
+theorem analyticAt_generatingInput {n : ℕ} {S : ComplexPhaseSpace n → ℂ}
+    {x : ComplexPhaseSpace n} (hS : AnalyticAt ℂ S x) : AnalyticAt ℂ (generatingInput S) x :=
+  analyticAt_fst.prod (analyticAt_snd.add (analyticAt_pGradient hS))
+
+theorem analyticAt_generatingOutput {n : ℕ} {S : ComplexPhaseSpace n → ℂ}
+    {x : ComplexPhaseSpace n} (hS : AnalyticAt ℂ S x) : AnalyticAt ℂ (generatingOutput S) x :=
+  (analyticAt_fst.add (analyticAt_qGradient hS)).prod analyticAt_snd
+
+theorem fderiv_generatingInput_apply {n : ℕ} {S : ComplexPhaseSpace n → ℂ}
+    {x : ComplexPhaseSpace n} (hS : AnalyticAt ℂ S x) (v : ComplexPhaseSpace n) :
+    fderiv ℂ (generatingInput S) x v = (v.1, v.2 + fderiv ℂ (pGradient S) x v) := by
+  have hd := (hasFDerivAt_fst (𝕜 := ℂ) (p := x)).prodMk
+    ((hasFDerivAt_snd (𝕜 := ℂ) (p := x)).add
+      (analyticAt_pGradient hS).differentiableAt.hasFDerivAt)
+  exact congrArg (fun L : ComplexPhaseSpace n →L[ℂ] ComplexPhaseSpace n => L v) hd.fderiv
+
+theorem fderiv_generatingOutput_apply {n : ℕ} {S : ComplexPhaseSpace n → ℂ}
+    {x : ComplexPhaseSpace n} (hS : AnalyticAt ℂ S x) (v : ComplexPhaseSpace n) :
+    fderiv ℂ (generatingOutput S) x v = (v.1 + fderiv ℂ (qGradient S) x v, v.2) := by
+  have hd := ((hasFDerivAt_fst (𝕜 := ℂ) (p := x)).add
+    (analyticAt_qGradient hS).differentiableAt.hasFDerivAt).prodMk
+      (hasFDerivAt_snd (𝕜 := ℂ) (p := x))
+  exact congrArg (fun L : ComplexPhaseSpace n →L[ℂ] ComplexPhaseSpace n => L v) hd.fderiv
+
+theorem norm_fderiv_generatingInput_sub_id_le {n : ℕ} {S : ComplexPhaseSpace n → ℂ}
+    {x : ComplexPhaseSpace n} (hS : AnalyticAt ℂ S x) :
+    ‖fderiv ℂ (generatingInput S) x - ContinuousLinearMap.id ℂ _‖ ≤
+      ‖fderiv ℂ (pGradient S) x‖ := by
+  refine (fderiv ℂ (generatingInput S) x -
+    ContinuousLinearMap.id ℂ (ComplexPhaseSpace n)).opNorm_le_bound
+    (norm_nonneg (fderiv ℂ (pGradient S) x)) ?_
+  intro v
+  change ‖fderiv ℂ (generatingInput S) x v - v‖ ≤ _
+  rw [fderiv_generatingInput_apply hS]
+  simpa [Prod.sub_def] using
+    (fderiv ℂ (pGradient S) x).le_opNorm v
+
+theorem norm_fderiv_generatingOutput_sub_id_le {n : ℕ} {S : ComplexPhaseSpace n → ℂ}
+    {x : ComplexPhaseSpace n} (hS : AnalyticAt ℂ S x) :
+    ‖fderiv ℂ (generatingOutput S) x - ContinuousLinearMap.id ℂ _‖ ≤
+      ‖fderiv ℂ (qGradient S) x‖ := by
+  refine (fderiv ℂ (generatingOutput S) x -
+    ContinuousLinearMap.id ℂ (ComplexPhaseSpace n)).opNorm_le_bound
+    (norm_nonneg (fderiv ℂ (qGradient S) x)) ?_
+  intro v
+  change ‖fderiv ℂ (generatingOutput S) x v - v‖ ≤ _
+  rw [fderiv_generatingOutput_apply hS]
+  simpa [Prod.sub_def] using
+    (fderiv ℂ (qGradient S) x).le_opNorm v
+
+theorem generating_symplectic_identity {n : ℕ} {S : ComplexPhaseSpace n → ℂ}
+    {x : ComplexPhaseSpace n} (hS : AnalyticAt ℂ S x) (v w : ComplexPhaseSpace n) :
+    symplecticForm (fderiv ℂ (generatingOutput S) x v) (fderiv ℂ (generatingOutput S) x w) =
+      symplecticForm (fderiv ℂ (generatingInput S) x v) (fderiv ℂ (generatingInput S) x w) := by
+  have hsym := hS.contDiffAt.isSymmSndFDerivAt_of_omega v w
+  change (fderiv ℂ (fderiv ℂ S) x v).toLinearMap w =
+    (fderiv ℂ (fderiv ℂ S) x w).toLinearMap v at hsym
+  rw [linearForm_decomposition (fderiv ℂ (fderiv ℂ S) x v).toLinearMap w,
+    linearForm_decomposition (fderiv ℂ (fderiv ℂ S) x w).toLinearMap v] at hsym
+  simp only [ContinuousLinearMap.coe_coe, ← fderiv_pGradient_apply hS,
+    ← fderiv_qGradient_apply hS] at hsym
+  rw [fderiv_generatingOutput_apply hS, fderiv_generatingOutput_apply hS,
+    fderiv_generatingInput_apply hS, fderiv_generatingInput_apply hS]
+  simp only [symplecticForm, Pi.add_apply, add_mul, mul_add,
+    Finset.sum_add_distrib, Finset.sum_sub_distrib]
+  simp_rw [mul_comm (fderiv ℂ (qGradient S) x v _),
+    mul_comm (fderiv ℂ (pGradient S) x v _)]
+  linear_combination hsym
+
+theorem canonicalAt_generating_branch {n : ℕ} {S : ComplexPhaseSpace n → ℂ}
+    {g : ComplexPhaseSpace n → ComplexPhaseSpace n} {y : ComplexPhaseSpace n}
+    (hS : AnalyticAt ℂ S (g y)) (hg : AnalyticAt ℂ g y)
+    (he : ∀ᶠ z in nhds y, generatingInput S (g z) = z) :
+    CanonicalAt (generatingOutput S ∘ g) y := by
+  have hF := analyticAt_generatingInput hS
+  have hH := analyticAt_generatingOutput hS
+  have hd : (fderiv ℂ (generatingInput S) (g y)).comp (fderiv ℂ g y) =
+      ContinuousLinearMap.id ℂ _ := by
+    rw [← fderiv_comp y hF.differentiableAt hg.differentiableAt]
+    exact (Filter.EventuallyEq.fderiv_eq he).trans fderiv_id
+  refine ⟨hH.differentiableAt.comp y hg.differentiableAt, ?_⟩
+  intro v w
+  rw [fderiv_comp y hH.differentiableAt hg.differentiableAt]
+  change symplecticForm
+    (fderiv ℂ (generatingOutput S) (g y) (fderiv ℂ g y v))
+    (fderiv ℂ (generatingOutput S) (g y) (fderiv ℂ g y w)) = _
+  rw [generating_symplectic_identity hS]
+  exact congrArg₂ symplecticForm
+    (congrArg (fun L : ComplexPhaseSpace n →L[ℂ] ComplexPhaseSpace n => L v) hd)
+    (congrArg (fun L : ComplexPhaseSpace n →L[ℂ] ComplexPhaseSpace n => L w) hd)
+
+theorem norm_fderiv_generating_branch_le {n : ℕ} {S : ComplexPhaseSpace n → ℂ}
+    {g : ComplexPhaseSpace n → ComplexPhaseSpace n} {y : ComplexPhaseSpace n}
+    (hS : AnalyticAt ℂ S (g y)) (hg : AnalyticAt ℂ g y)
+    (he : ∀ᶠ z in nhds y, generatingInput S (g z) = z)
+    (hp : ‖fderiv ℂ (pGradient S) (g y)‖ ≤ 1 / 4)
+    (hq : ‖fderiv ℂ (qGradient S) (g y)‖ ≤ 1 / 4) :
+    ‖fderiv ℂ (generatingOutput S ∘ g) y‖ ≤ 5 / 3 := by
+  let A := fderiv ℂ (generatingInput S) (g y)
+  let D := fderiv ℂ (generatingOutput S) (g y)
+  let C := fderiv ℂ g y
+  have hA : ‖A - ContinuousLinearMap.id ℂ _‖ ≤ 1 / 4 :=
+    (norm_fderiv_generatingInput_sub_id_le hS).trans hp
+  have hD : ‖D - ContinuousLinearMap.id ℂ _‖ ≤ 1 / 4 :=
+    (norm_fderiv_generatingOutput_sub_id_le hS).trans hq
+  have hAC : A.comp C = ContinuousLinearMap.id ℂ _ := by
+    rw [← fderiv_comp y (analyticAt_generatingInput hS).differentiableAt hg.differentiableAt]
+    exact (Filter.EventuallyEq.fderiv_eq he).trans fderiv_id
+  rw [fderiv_comp y (analyticAt_generatingOutput hS).differentiableAt hg.differentiableAt]
+  refine (D.comp C).opNorm_le_bound (by norm_num : (0 : ℝ) ≤ 5 / 3) ?_
+  intro v
+  have hav : A (C v) = v :=
+    congrArg (fun L : ComplexPhaseSpace n →L[ℂ] ComplexPhaseSpace n => L v) hAC
+  have h1 : ‖v - C v‖ ≤ 1 / 4 * ‖C v‖ := by
+    have hh := ((A - ContinuousLinearMap.id ℂ _).le_opNorm (C v)).trans
+      (mul_le_mul_of_nonneg_right hA (norm_nonneg _))
+    simpa only [sub_apply, ContinuousLinearMap.id_apply, hav] using hh
+  have h2 : ‖C v‖ ≤ ‖v‖ + ‖v - C v‖ := by
+    have := norm_sub_le v (v - C v)
+    simpa using this
+  have h3 : ‖D (C v) - C v‖ ≤ 1 / 4 * ‖C v‖ :=
+    ((D - ContinuousLinearMap.id ℂ _).le_opNorm (C v)).trans
+      (mul_le_mul_of_nonneg_right hD (norm_nonneg _))
+  have h4 : ‖D (C v)‖ ≤ ‖C v‖ + ‖D (C v) - C v‖ := by
+    simpa using norm_add_le (C v) (D (C v) - C v)
+  change ‖D (C v)‖ ≤ _
+  linarith
+
+end KamProject.Arnold1963
diff --git a/LeanPool/ArnoldKAM/Arnold1963/Geometry/GeneratingSymmetry.lean b/LeanPool/ArnoldKAM/Arnold1963/Geometry/GeneratingSymmetry.lean
new file mode 100644
index 0000000000..e19790905b
--- /dev/null
+++ b/LeanPool/ArnoldKAM/Arnold1963/Geometry/GeneratingSymmetry.lean
@@ -0,0 +1,105 @@
+/-
+Copyright (c) 2026 Bingqi Yu. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Bingqi Yu
+-/
+
+module
+
+public import LeanPool.ArnoldKAM.Arnold1963.Geometry.GeneratingGlobal
+public import Mathlib.Analysis.Calculus.FDeriv.Star
+
+/-!
+Conjugation and physical angle translation laws for the same selected inverse. No periodicity
+or real compatibility is required of arbitrary extensions outside the original domain.
+-/
+
+@[expose] public section
+noncomputable section
+open Set Metric Filter
+open scoped NNReal Topology
+namespace KamProject.Arnold1963
+
+
+/-- Translation of phase space by an integer angle-period shift. -/
+def phaseShift {n : ℕ} (k : FourierIndex n) (x : ComplexPhaseSpace n) :=
+  (x.1, x.2 + angleShift k)
+
+theorem phaseShift_eq_add {n : ℕ} (k : FourierIndex n) (x : ComplexPhaseSpace n) :
+    phaseShift k x = x + (0, angleShift k) := by simp [phaseShift, Prod.add_def]
+
+theorem phaseShift_mem_phaseDomain {n : ℕ} {G : Set (ComplexSpace n)} {ρ : ℝ≥0}
+    (k : FourierIndex n) (x : ComplexPhaseSpace n) :
+    phaseShift k x ∈ phaseDomain G ρ ↔ x ∈ phaseDomain G ρ := by
+  simp [phaseShift, phaseDomain, add_angleShift_mem_iff]
+
+theorem star_mem_erosion {E : Type*} [NormedAddCommGroup E] [StarAddMonoid E]
+    [NormedStarGroup E] {V : Set E} (hc : ∀ x ∈ V, star x ∈ V)
+    {r : ℝ≥0} {x : E} (hx : x ∈ erosion V r) : star x ∈ erosion V r := by
+  intro z hz
+  have hd : dist (star z) x = dist z (star x) := by
+    rw [← dist_star_star z (star x), star_star]
+  have hh := hc (star z) (hx (by simpa only [Metric.mem_closedBall, hd] using hz))
+  simpa only [star_star] using hh
+
+theorem add_mem_erosion {E : Type*} [NormedAddCommGroup E] {V : Set E} {c : E}
+    (hc : ∀ z, z + c ∈ V ↔ z ∈ V) {r : ℝ≥0} {x : E}
+    (hx : x ∈ erosion V r) : x + c ∈ erosion V r := by
+  intro z hz
+  have hd : dist (z - c) x = dist z (x + c) := by
+    simp only [dist_eq_norm]; congr 1; abel
+  have hh := (hc (z - c)).mpr (hx (by simpa only [Metric.mem_closedBall, hd] using hz))
+  simpa using hh
+
+theorem conj_mem_phaseDomain {n : ℕ} {G : Set (ComplexSpace n)} {ρ : ℝ≥0}
+    (hG : ConjInvariant G) {x : ComplexPhaseSpace n} (hx : x ∈ phaseDomain G ρ) :
+    conjPhase x ∈ phaseDomain G ρ := by
+  refine ⟨hG _ hx.1, ?_⟩
+  apply (mem_angleStrip_iff _ _).2
+  intro j
+  simpa [conjPhase, conjVec] using (mem_angleStrip_iff _ _).1 hx.2 j
+
+theorem fderiv_conjPhase {n : ℕ} {S : ComplexPhaseSpace n → ℂ}
+    {V : Set (ComplexPhaseSpace n)} {x : ComplexPhaseSpace n}
+    (ha : AnalyticAt ℂ S x) (hc : ConjCompatibleOn S V) (hx : V ∈ 𝓝 (conjPhase x))
+    (v : ComplexPhaseSpace n) :
+    fderiv ℂ S (conjPhase x) (conjPhase v) = star (fderiv ℂ S x v) := by
+  have he : S =ᶠ[𝓝 (star x)] (star ∘ S ∘ star) := by
+    filter_upwards [hx] with z hz
+    simpa [Function.comp_def, ← hc z hz] using (star_star (S z)).symm
+  have hd := ha.differentiableAt.hasFDerivAt.star_star
+  rw [conjPhase_eq_star, he.fderiv_eq, hd.fderiv]
+  simp [conjPhase_eq_star]
+
+theorem gradients_conj {n : ℕ} {S : ComplexPhaseSpace n → ℂ}
+    {V : Set (ComplexPhaseSpace n)} {x : ComplexPhaseSpace n}
+    (ha : AnalyticAt ℂ S x) (hc : ConjCompatibleOn S V) (hx : V ∈ 𝓝 (conjPhase x)) :
+    pGradient S (conjPhase x) = conjVec (pGradient S x) ∧
+      qGradient S (conjPhase x) = conjVec (qGradient S x) := by
+  constructor <;> ext j
+  · simpa [pGradient, pDirection, conjPhase, conjVec] using fderiv_conjPhase ha hc hx (pDirection j)
+  · simpa [qGradient, qDirection, conjPhase, conjVec] using fderiv_conjPhase ha hc hx (qDirection j)
+
+theorem gradients_periodic {n : ℕ} {G : Set (ComplexSpace n)} {ρ r : ℝ≥0}
+    (S : AnalyticPhaseFunction n G ρ) (hr : 0 < r) {x : ComplexPhaseSpace n}
+    (hx : x ∈ erosion (phaseDomain G ρ) r) (k : FourierIndex n) :
+    pGradient S.toFun (phaseShift k x) = pGradient S.toFun x ∧
+      qGradient S.toFun (phaseShift k x) = qGradient S.toFun x := by
+  have hn : phaseDomain G ρ ∈ 𝓝 x :=
+    mem_of_superset (closedBall_mem_nhds x (show (0 : ℝ) < r from hr)) hx
+  have he : (S.toFun ∘ phaseShift k) =ᶠ[𝓝 x] S.toFun := by
+    filter_upwards [hn] with z hz
+    exact S.periodic z.1 hz.1 z.2 hz.2 k
+  have hshift : HasFDerivAt (phaseShift k) (ContinuousLinearMap.id ℂ _) x := by
+    convert (hasFDerivAt_id (𝕜 := ℂ) x).add_const (0, angleShift k) using 1
+    funext z
+    exact phaseShift_eq_add k z
+  have ha := S.analytic _ ((phaseShift_mem_phaseDomain k x).2 (erosion_subset _ _ hx))
+  have hd := ha.differentiableAt.hasFDerivAt.comp x hshift
+  have heq : fderiv ℂ S.toFun (phaseShift k x) = fderiv ℂ S.toFun x := by
+    simpa using hd.fderiv.symm.trans he.fderiv_eq
+  constructor <;> ext j
+  · exact congrArg (fun L : ComplexPhaseSpace n →L[ℂ] ℂ => L (pDirection j)) heq
+  · exact congrArg (fun L : ComplexPhaseSpace n →L[ℂ] ℂ => L (qDirection j)) heq
+
+end KamProject.Arnold1963
diff --git a/LeanPool/ArnoldKAM/Arnold1963/Geometry/GeneratingTorus.lean b/LeanPool/ArnoldKAM/Arnold1963/Geometry/GeneratingTorus.lean
new file mode 100644
index 0000000000..ec2b118293
--- /dev/null
+++ b/LeanPool/ArnoldKAM/Arnold1963/Geometry/GeneratingTorus.lean
@@ -0,0 +1,125 @@
+/-
+Copyright (c) 2026 Bingqi Yu. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Bingqi Yu
+-/
+
+module
+
+public import LeanPool.ArnoldKAM.Arnold1963.Geometry.GeneratingTransformation
+public import LeanPool.ArnoldKAM.Arnold1963.Geometry.RealCover
+
+/-!
+Real restrictions and descent to the physical angle torus, including representative
+independence and injectivity on the quotient.
+-/
+
+@[expose] public section
+noncomputable section
+open Set
+open scoped NNReal
+namespace KamProject.Arnold1963
+
+theorem complexifyPhase_shift {n : ℕ} (k : FourierIndex n) (x : RealPhaseCover n) :
+    complexifyPhase (realPhaseShift k x) = phaseShift k (complexifyPhase x) := by
+  apply Prod.ext
+  · rfl
+  · funext j
+    simp [complexifyPhase, realPhaseShift, phaseShift, complexify, realAngleShift, angleShift]
+
+theorem realPartPhase_shift {n : ℕ} (k : FourierIndex n) (x : ComplexPhaseSpace n) :
+    realPartPhase (phaseShift k x) = realPhaseShift k (realPartPhase x) := by
+  apply Prod.ext
+  · rfl
+  · funext j
+    simp [realPartPhase, realPhaseShift, phaseShift, realPart,
+      realAngleShift, angleShift, complexify]
+
+/-- The generating transformation restricted to unwrapped real phase coordinates. -/
+def generatingRealTransform {n : ℕ} (S : ComplexPhaseSpace n → ℂ)
+    (G : Set (ComplexSpace n)) (ρ r : ℝ≥0) (x : RealPhaseCover n) : RealPhaseCover n :=
+  realPartPhase (generatingTransform S G (angleStrip n ρ) r (complexifyPhase x))
+
+/-- The generating transformation descended to real angles modulo `2π`. -/
+def generatingTorusTransform {n : ℕ} (S : ComplexPhaseSpace n → ℂ)
+    (G : Set (ComplexSpace n)) (ρ r : ℝ≥0) (x : RealPhaseSpace n) : RealPhaseSpace n :=
+  torusProjection (generatingRealTransform S G ρ r (torusRepresentative x))
+
+theorem complexifyPhase_mem_generatingTarget {n : ℕ} {G : Set (ComplexSpace n)}
+    {ρ r : ℝ≥0} (hρ : r + r + r ≤ ρ) {x : RealPhaseCover n}
+    (hx : x.1 ∈ realSlice (erosion G (r + r))) :
+    complexifyPhase x ∈ generatingTarget G (angleStrip n ρ) r :=
+  phaseDomain_subset_generatingTarget G hρ ⟨hx, complexify_mem_angleStrip _ _⟩
+
+namespace AnalyticPhaseFunction
+variable {n : ℕ} {G : Set (ComplexSpace n)} {ρ r : ℝ≥0} {M : ℝ}
+  (S : AnalyticPhaseFunction n G ρ) (d : GeneratingData S.toFun G (angleStrip n ρ) r M)
+  (hρ : r + r + r ≤ ρ)
+
+include S d hρ
+
+theorem generatingTransform_real {x : RealPhaseCover n}
+    (hx : x.1 ∈ realSlice (erosion G (r + r))) :
+    complexifyPhase (generatingRealTransform S.toFun G ρ r x) =
+      generatingTransform S.toFun G (angleStrip n ρ) r (complexifyPhase x) := by
+  apply complexifyPhase_realPartPhase_of_conj
+  have hh := S.generatingTransform_conj d (complexifyPhase_mem_generatingTarget hρ hx)
+  simpa only [conjPhase_complexifyPhase] using hh.symm
+
+theorem generatingRealTransform_mapsTo {x : RealPhaseCover n}
+    (hx : x.1 ∈ realSlice (erosion G (r + r))) :
+    (generatingRealTransform S.toFun G ρ r x).1 ∈ realSlice G := by
+  have hm := (d.transform_mapsTo (complexifyPhase_mem_generatingTarget hρ hx)).1
+  have he := congrArg Prod.fst (S.generatingTransform_real d hρ hx)
+  change (complexifyPhase (generatingRealTransform S.toFun G ρ r x)).1 ∈ G
+  rw [he]
+  exact hm
+
+theorem generatingRealTransform_shift {x : RealPhaseCover n}
+    (hx : x.1 ∈ realSlice (erosion G (r + r))) (k : FourierIndex n) :
+    generatingRealTransform S.toFun G ρ r (realPhaseShift k x) =
+      realPhaseShift k (generatingRealTransform S.toFun G ρ r x) := by
+  unfold generatingRealTransform
+  rw [complexifyPhase_shift,
+    S.generatingTransform_shift d (complexifyPhase_mem_generatingTarget hρ hx)]
+  exact realPartPhase_shift k _
+
+theorem generatingTorusTransform_projection {x : RealPhaseCover n}
+    (hx : x.1 ∈ realSlice (erosion G (r + r))) :
+    generatingTorusTransform S.toFun G ρ r (torusProjection x) =
+      torusProjection (generatingRealTransform S.toFun G ρ r x) := by
+  obtain ⟨k, hk⟩ := (torusProjection_eq_iff (torusRepresentative (torusProjection x)) x).1
+    (torusProjection_representative _)
+  unfold generatingTorusTransform
+  rw [hk, S.generatingRealTransform_shift d hρ hx, torusProjection_shift]
+
+theorem generatingTorusTransform_mapsTo : MapsTo (generatingTorusTransform S.toFun G ρ r)
+    (realSlice (erosion G (r + r)) ×ˢ (univ : Set (RealTorus n)))
+    (realSlice G ×ˢ (univ : Set (RealTorus n))) := by
+  intro x hx
+  exact ⟨S.generatingRealTransform_mapsTo d hρ (x := torusRepresentative x) hx.1, mem_univ _⟩
+
+theorem generatingTorusTransform_injOn : InjOn (generatingTorusTransform S.toFun G ρ r)
+    (realSlice (erosion G (r + r)) ×ˢ (univ : Set (RealTorus n))) := by
+  intro x hx y hy he
+  change torusProjection (generatingRealTransform S.toFun G ρ r (torusRepresentative x)) =
+    torusProjection (generatingRealTransform S.toFun G ρ r (torusRepresentative y)) at he
+  obtain ⟨k, hk⟩ := (torusProjection_eq_iff
+    (generatingRealTransform S.toFun G ρ r (torusRepresentative x))
+    (generatingRealTransform S.toFun G ρ r (torusRepresentative y))).1 he
+  have hB := congrArg complexifyPhase hk
+  rw [S.generatingTransform_real d hρ (x := torusRepresentative x) hx.1, complexifyPhase_shift,
+    S.generatingTransform_real d hρ (x := torusRepresentative y) hy.1] at hB
+  have hy' := complexifyPhase_mem_generatingTarget hρ (x := torusRepresentative y) hy.1
+  rw [← S.generatingTransform_shift d hy' k] at hB
+  have hi := d.transform_injOn
+    (complexifyPhase_mem_generatingTarget hρ (x := torusRepresentative x) hx.1)
+    (shift_generatingTarget hy' k) hB
+  rw [← complexifyPhase_shift] at hi
+  have hr := congrArg realPartPhase hi
+  simp only [realPartPhase_complexifyPhase] at hr
+  have ht := (torusProjection_eq_iff (torusRepresentative x) (torusRepresentative y)).2 ⟨k, hr⟩
+  simpa only [torusProjection_representative] using ht
+
+end AnalyticPhaseFunction
+end KamProject.Arnold1963
diff --git a/LeanPool/ArnoldKAM/Arnold1963/Geometry/GeneratingTransformation.lean b/LeanPool/ArnoldKAM/Arnold1963/Geometry/GeneratingTransformation.lean
new file mode 100644
index 0000000000..27010dcc55
--- /dev/null
+++ b/LeanPool/ArnoldKAM/Arnold1963/Geometry/GeneratingTransformation.lean
@@ -0,0 +1,173 @@
+/-
+Copyright (c) 2026 Bingqi Yu. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Bingqi Yu
+-/
+
+module
+
+public import LeanPool.ArnoldKAM.Arnold1963.Geometry.GeneratingEquivariance
+
+/-!
+Analytic canonical transformations on shrunken domains and analytic Hamiltonian pullbacks.
+-/
+
+@[expose] public section
+noncomputable section
+open Set
+open scoped NNReal Topology
+namespace KamProject.Arnold1963
+
+theorem phaseDomain_subset_generatingTarget {n : ℕ} (G : Set (ComplexSpace n))
+    {ρ r : ℝ≥0} (hρ : r + r + r ≤ ρ) :
+    phaseDomain (erosion G (r + r)) (ρ - (r + r + r)) ⊆
+      generatingTarget G (angleStrip n ρ) r := by
+  intro y hy
+  exact ⟨hy.1, fun _ hz => mem_angleStrip_of_dist_le hρ hy.2 hz⟩
+
+/-- An analytic canonical transformation with analytic inverse and displacement control. -/
+structure AnalyticCanonicalTransformation {n : ℕ}
+    (D V : Set (ComplexPhaseSpace n)) (ε : ℝ) where
+  /-- The forward complex phase transformation. -/
+  toFun : ComplexPhaseSpace n → ComplexPhaseSpace n
+  /-- The inverse function on the forward transformation's image. -/
+  invFun : ComplexPhaseSpace n → ComplexPhaseSpace n
+  analytic : AnalyticOnNhd ℂ toFun D
+  inverse_analytic : AnalyticOnNhd ℂ invFun (toFun '' D)
+  mapsTo : MapsTo toFun D V
+  left_inv : LeftInvOn invFun toFun D
+  right_inv : RightInvOn invFun toFun (toFun '' D)
+  inverse_mapsTo : MapsTo invFun (toFun '' D) D
+  canonical : CanonicalOn toFun D
+  inverse_canonical : CanonicalOn invFun (toFun '' D)
+  displacement : NormBoundOn (fun x => toFun x - x) D ε
+  derivative_bound : ∀ x ∈ D, ‖fderiv ℂ toFun x‖ < 2
+
+namespace AnalyticCanonicalTransformation
+variable {n : ℕ} {D V : Set (ComplexPhaseSpace n)} {ε : ℝ}
+
+theorem injOn (B : AnalyticCanonicalTransformation D V ε) : InjOn B.toFun D :=
+  B.left_inv.injOn
+
+theorem bijOn_image (B : AnalyticCanonicalTransformation D V ε) :
+    BijOn B.toFun D (B.toFun '' D) :=
+  ⟨mapsTo_image _ _, B.injOn, surjOn_image _ _⟩
+
+/-- The transformation as a homeomorphism between its source and its actual image. -/
+def homeomorph (B : AnalyticCanonicalTransformation D V ε) : D ≃ₜ (B.toFun '' D) where
+  toFun x := ⟨B.toFun x, mem_image_of_mem _ x.property⟩
+  invFun z := ⟨B.invFun z, B.inverse_mapsTo z.property⟩
+  left_inv x := Subtype.ext (B.left_inv x.property)
+  right_inv z := Subtype.ext (B.right_inv z.property)
+  continuous_toFun := (B.analytic.continuousOn.domRestrict).subtype_mk _
+  continuous_invFun := (B.inverse_analytic.continuousOn.domRestrict).subtype_mk _
+
+/-- Restriction of the canonical transformation to a smaller source domain. -/
+def restrict (B : AnalyticCanonicalTransformation D V ε)
+    {D' : Set (ComplexPhaseSpace n)} (hD : D' ⊆ D) : AnalyticCanonicalTransformation D' V ε where
+  toFun := B.toFun
+  invFun := B.invFun
+  analytic := B.analytic.mono hD
+  inverse_analytic := B.inverse_analytic.mono (image_mono hD)
+  mapsTo := fun _ hx => B.mapsTo (hD hx)
+  left_inv := fun _ hx => B.left_inv (hD hx)
+  right_inv := fun _ hx => B.right_inv (image_mono hD hx)
+  inverse_mapsTo := by
+    rintro z ⟨x, hx, rfl⟩
+    rw [B.left_inv (hD hx)]
+    exact hx
+  canonical := fun _ hx => B.canonical _ (hD hx)
+  inverse_canonical := fun _ hx => B.inverse_canonical _ (image_mono hD hx)
+  displacement := ⟨B.displacement.nonneg, fun _ hx => B.displacement.norm_le (hD hx)⟩
+  derivative_bound := fun _ hx => B.derivative_bound _ (hD hx)
+
+end AnalyticCanonicalTransformation
+
+namespace GeneratingData
+variable {n : ℕ} {S : ComplexPhaseSpace n → ℂ} {G U : Set (ComplexSpace n)}
+  {r : ℝ≥0} {M : ℝ} (d : GeneratingData S G U r M)
+
+theorem of_arnold (hn : 0 < n) (hr : 0 < r) (hS : AnalyticOnNhd ℂ S (G ×ˢ U))
+    (hb : NormBoundOn S (G ×ˢ U) M) (hM : M < (r : ℝ) ^ 2 / (16 * n)) :
+    GeneratingData S G U r M :=
+  ⟨hr, hS, hb, generating_small_sixteenth hn hr hM⟩
+
+include d
+
+/-- The canonical transformation constructed from analytic generating data. -/
+def transformation : AnalyticCanonicalTransformation (generatingTarget G U r) (G ×ˢ U) (M / r) where
+  toFun := generatingTransform S G U r
+  invFun := generatingTransformInv S G U r
+  analytic := d.transform_analytic
+  inverse_analytic := d.transformInv_analytic
+  mapsTo := d.transform_mapsTo
+  left_inv := fun _ hy => d.transform_left_inv hy
+  right_inv := fun _ hz => d.transform_right_inv hz
+  inverse_mapsTo := by
+    rintro z ⟨y, hy, rfl⟩
+    simpa only [d.transform_left_inv hy] using hy
+  canonical := d.transform_canonical
+  inverse_canonical := d.transformInv_canonical
+  displacement := d.displacement_bound
+  derivative_bound := fun _ hy => (d.derivative_bound hy).trans_lt (by norm_num)
+
+theorem action_displacement {δ : ℝ≥0} (hδ : 0 < δ) {y : ComplexPhaseSpace n}
+    (hP : y.1 ∈ erosion G (r + r)) (hQ : y.2 ∈ erosion U ((r + r + r) + δ)) :
+    ‖(generatingTransform S G U r y).1 - y.1‖ ≤ M / δ := by
+  have hy : y ∈ generatingTarget G U r :=
+    ⟨hP, erosion_antitone_radius U (show r + r + r ≤ (r + r + r) + δ from le_self_add) hQ⟩
+  have hp := (d.inverse_spec hy).2.2.1
+  have hpair : generatingInverse S G U r y = (y.1, (generatingInverse S G U r y).2) :=
+    Prod.ext hp rfl
+  change ‖(generatingOutput S (generatingInverse S G U r y)).1 - y.1‖ ≤ _
+  rw [hpair]
+  exact generating_action_displacement_le hδ d.analytic d.bounded
+    (erosion_subset _ _ hP) hQ (d.inverse_spec hy).2.2.2
+
+end GeneratingData
+
+namespace AnalyticPhaseFunction
+variable {n : ℕ} {G : Set (ComplexSpace n)} {ρ r : ℝ≥0} {M : ℝ}
+
+theorem generatingData (S : AnalyticPhaseFunction n G ρ) (hn : 0 < n) (hr : 0 < r)
+    (hM : S.uniformNorm < (r : ℝ) ^ 2 / (16 * n)) :
+    GeneratingData S.toFun G (angleStrip n ρ) r S.uniformNorm :=
+  ⟨hr, S.analytic, S.norm_le_iff.mp le_rfl, generating_small_sixteenth hn hr hM⟩
+
+/-- Pullback of an analytic Hamiltonian through a generating transformation on a smaller domain. -/
+def pullbackGenerating (H S : AnalyticPhaseFunction n G ρ)
+    (d : GeneratingData S.toFun G (angleStrip n ρ) r M)
+    (hρ : r + r + r ≤ ρ) :
+    AnalyticPhaseFunction n (erosion G (r + r)) (ρ - (r + r + r)) where
+  toFun z := H.toFun (generatingTransform S.toFun G (angleStrip n ρ) r z)
+  domain_conj := fun _ hp => star_mem_erosion S.domain_conj hp
+  analytic := fun z hz => (H.analytic _ (d.transform_mapsTo
+    (phaseDomain_subset_generatingTarget G hρ hz))).comp
+      (d.transform_analytic z (phaseDomain_subset_generatingTarget G hρ hz))
+  periodic := by
+    intro p hp q hq k
+    have hz := phaseDomain_subset_generatingTarget G hρ (show (p, q) ∈
+      phaseDomain (erosion G (r + r)) (ρ - (r + r + r)) from ⟨hp, hq⟩)
+    change H.toFun (generatingTransform S.toFun G (angleStrip n ρ) r (phaseShift k (p, q))) = _
+    rw [S.generatingTransform_shift d hz k]
+    exact H.periodic _ (d.transform_mapsTo hz).1 _ (d.transform_mapsTo hz).2 k
+  conj_compatible := by
+    intro z hz
+    have hy := phaseDomain_subset_generatingTarget G hρ hz
+    change H.toFun (generatingTransform S.toFun G (angleStrip n ρ) r (conjPhase z)) = _
+    rw [S.generatingTransform_conj d hy]
+    exact H.conj_compatible _ (d.transform_mapsTo hy)
+  bounded := ⟨H.uniformNorm, (H.norm_le_iff.mp le_rfl).nonneg,
+    fun z hz => (H.norm_le_iff.mp le_rfl).norm_le
+      (d.transform_mapsTo (phaseDomain_subset_generatingTarget G hρ hz))⟩
+
+theorem uniformNorm_pullbackGenerating_le (H S : AnalyticPhaseFunction n G ρ)
+    (d : GeneratingData S.toFun G (angleStrip n ρ) r M)
+    (hρ : r + r + r ≤ ρ) :
+    (H.pullbackGenerating S d hρ).uniformNorm ≤ H.uniformNorm :=
+  ((H.pullbackGenerating S d hρ).norm_le_iff).2
+    ⟨(H.norm_le_iff.mp le_rfl).nonneg, fun _ hz => (H.norm_le_iff.mp le_rfl).norm_le
+      (d.transform_mapsTo (phaseDomain_subset_generatingTarget G hρ hz))⟩
+
+end AnalyticPhaseFunction
+end KamProject.Arnold1963
diff --git a/LeanPool/ArnoldKAM/Arnold1963/Geometry/GlobalInverse.lean b/LeanPool/ArnoldKAM/Arnold1963/Geometry/GlobalInverse.lean
new file mode 100644
index 0000000000..babe01a669
--- /dev/null
+++ b/LeanPool/ArnoldKAM/Arnold1963/Geometry/GlobalInverse.lean
@@ -0,0 +1,70 @@
+/-
+Copyright (c) 2026 Bingqi Yu. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Bingqi Yu
+-/
+
+module
+
+public import LeanPool.ArnoldKAM.Arnold1963.Geometry.GeneratingLocal
+
+/-!
+Injectivity of maps close to identity on possibly nonconvex domains, and consistent analytic
+inverses selected on a fixed source domain.
+-/
+
+@[expose] public section
+noncomputable section
+open Set Filter Metric Function
+open scoped NNReal Topology
+namespace KamProject.Arnold1963
+
+variable {E : Type*} [NormedAddCommGroup E]
+
+theorem injOn_add_of_local_lipschitz {a : E → E} {D : Set E} {r ε : ℝ} {κ : ℝ≥0}
+    (hb : ∀ x ∈ D, ‖a x‖ ≤ ε) (hε : 2 * ε ≤ r) (hκ : κ < 1)
+    (hlip : ∀ x ∈ D, LipschitzOnWith κ a (closedBall x r)) :
+    InjOn (fun x => x + a x) D := by
+  intro x hx y hy he
+  change x + a x = y + a y at he
+  have hxy : x - y = a y - a x := by
+    calc
+      x - y = (x + a x) - (y + a y) + (a y - a x) := by abel
+      _ = a y - a x := by rw [he]; simp
+  have hd : dist y x ≤ r := by
+    rw [dist_comm, dist_eq_norm, hxy]
+    exact (norm_sub_le _ _).trans ((add_le_add (hb y hy) (hb x hx)).trans (by linarith))
+  have hr : 0 ≤ r := (dist_nonneg.trans hd)
+  have h := (hlip x hx).dist_le_mul y hd x (mem_closedBall_self hr)
+  have hh : dist (a y) (a x) = dist x y := by rw [dist_eq_norm, ← hxy, dist_eq_norm]
+  rw [hh, dist_comm y x] at h
+  have hk : (κ : ℝ) < 1 := hκ
+  apply dist_eq_zero.mp
+  nlinarith [dist_nonneg (x := x) (y := y)]
+
+theorem erosion_mem_nhds {D : Set E} {r s : ℝ≥0} (hs : 0 < s) {x : E}
+    (hx : x ∈ erosion D (r + s)) : erosion D r ∈ 𝓝 x :=
+  mem_of_superset (closedBall_mem_nhds x (show (0 : ℝ) < s from hs))
+    (fun _ hy => mem_erosion_of_dist_le hx hy)
+
+theorem invFunOn_eventually_eq {f g : E → E} {D : Set E} {x : E}
+    (hi : InjOn f D) (hD : D ∈ 𝓝 x) (hg : ContinuousAt g (f x))
+    (hgx : g (f x) = x) (he : ∀ᶠ y in 𝓝 (f x), f (g y) = y) :
+    ∀ᶠ y in 𝓝 (f x), invFunOn f D y = g y := by
+  have hm : ∀ᶠ y in 𝓝 (f x), g y ∈ D := hg (by simpa only [hgx] using hD)
+  filter_upwards [hm, he] with y hy hfy
+  have hh := invFunOn_pos ⟨g y, hy, hfy⟩
+  exact hi hh.1 hy (hh.2.trans hfy.symm)
+
+theorem analytic_invFunOn [NormedSpace ℂ E] [CompleteSpace E] {f : E → E} {D : Set E} {x : E}
+    (hi : InjOn f D) (hD : D ∈ 𝓝 x) (hf : AnalyticAt ℂ f x)
+    (hn : ‖fderiv ℂ f x - ContinuousLinearMap.id ℂ E‖ < 1) :
+    AnalyticAt ℂ (invFunOn f D) (f x) ∧ invFunOn f D (f x) = x ∧
+      ∀ᶠ y in 𝓝 (f x), f (invFunOn f D y) = y := by
+  obtain ⟨g, hg, hgx, he⟩ := exists_analytic_local_inverse hf hn
+  have heq := invFunOn_eventually_eq hi hD hg.continuousAt hgx he
+  refine ⟨hg.congr (heq.mono fun _ h => h.symm), heq.self_of_nhds.trans hgx, ?_⟩
+  filter_upwards [heq, he] with y hy hey
+  rw [hy]; exact hey
+
+end KamProject.Arnold1963
diff --git a/LeanPool/ArnoldKAM/Arnold1963/Geometry/GradientBounds.lean b/LeanPool/ArnoldKAM/Arnold1963/Geometry/GradientBounds.lean
new file mode 100644
index 0000000000..3ea02f3a48
--- /dev/null
+++ b/LeanPool/ArnoldKAM/Arnold1963/Geometry/GradientBounds.lean
@@ -0,0 +1,108 @@
+/-
+Copyright (c) 2026 Bingqi Yu. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Bingqi Yu
+-/
+
+module
+
+public import LeanPool.ArnoldKAM.Arnold1963.Analysis.DomainBuffer
+public import LeanPool.ArnoldKAM.Arnold1963.Analysis.SecondCauchy
+public import Mathlib.Analysis.Calculus.MeanValue
+
+/-!
+Joint analyticity and operator norm estimates for Hamiltonian gradients in the maximum norm.
+-/
+
+@[expose] public section
+noncomputable section
+open Set
+open scoped NNReal
+namespace KamProject.Arnold1963
+
+theorem mem_erosion_of_dist_le {E : Type*} [MetricSpace E] {U : Set E}
+    {r s : ℝ≥0} {x y : E} (hx : x ∈ erosion U (r + s)) (hy : dist y x ≤ s) :
+    y ∈ erosion U r := by
+  intro z hz
+  apply hx
+  exact (dist_triangle z y x).trans (by exact_mod_cast add_le_add hz hy)
+
+theorem prod_mem_erosion {E F : Type*} [MetricSpace E] [MetricSpace F]
+    {G : Set E} {U : Set F} {r : ℝ≥0} {p : E} {q : F}
+    (hp : p ∈ erosion G r) (hq : q ∈ erosion U r) : (p, q) ∈ erosion (G ×ˢ U) r := by
+  intro z hz
+  have h := max_le_iff.mp (show max (dist z.1 p) (dist z.2 q) ≤ (r : ℝ) from hz)
+  exact ⟨hp h.1, hq h.2⟩
+
+/-- Evaluation of a phase covector on all action-coordinate basis directions. -/
+def pGradientCLM (n : ℕ) :
+    (ComplexPhaseSpace n →L[ℂ] ℂ) →L[ℂ] ComplexSpace n :=
+  ContinuousLinearMap.pi (fun j => ContinuousLinearMap.apply ℂ ℂ (pDirection j))
+
+/-- Evaluation of a phase covector on all angle-coordinate basis directions. -/
+def qGradientCLM (n : ℕ) :
+    (ComplexPhaseSpace n →L[ℂ] ℂ) →L[ℂ] ComplexSpace n :=
+  ContinuousLinearMap.pi (fun j => ContinuousLinearMap.apply ℂ ℂ (qDirection j))
+
+theorem analyticAt_pGradient {n : ℕ} {S : ComplexPhaseSpace n → ℂ}
+    {x : ComplexPhaseSpace n} (hS : AnalyticAt ℂ S x) : AnalyticAt ℂ (pGradient S) x :=
+  ((pGradientCLM n).analyticAt _).comp hS.fderiv
+
+theorem analyticAt_qGradient {n : ℕ} {S : ComplexPhaseSpace n → ℂ}
+    {x : ComplexPhaseSpace n} (hS : AnalyticAt ℂ S x) : AnalyticAt ℂ (qGradient S) x :=
+  ((qGradientCLM n).analyticAt _).comp hS.fderiv
+
+theorem fderiv_pGradient_apply {n : ℕ} {S : ComplexPhaseSpace n → ℂ}
+    {x : ComplexPhaseSpace n} (hS : AnalyticAt ℂ S x) (v : ComplexPhaseSpace n) (j : Fin n) :
+    fderiv ℂ (pGradient S) x v j = fderiv ℂ (fderiv ℂ S) x v (pDirection j) := by
+  exact congrArg (fun L : ComplexPhaseSpace n →L[ℂ] ComplexSpace n => L v j)
+    (((pGradientCLM n).hasFDerivAt.comp x hS.fderiv.differentiableAt.hasFDerivAt).fderiv)
+
+theorem fderiv_qGradient_apply {n : ℕ} {S : ComplexPhaseSpace n → ℂ}
+    {x : ComplexPhaseSpace n} (hS : AnalyticAt ℂ S x) (v : ComplexPhaseSpace n) (j : Fin n) :
+    fderiv ℂ (qGradient S) x v j = fderiv ℂ (fderiv ℂ S) x v (qDirection j) := by
+  exact congrArg (fun L : ComplexPhaseSpace n →L[ℂ] ComplexSpace n => L v j)
+    (((qGradientCLM n).hasFDerivAt.comp x hS.fderiv.differentiableAt.hasFDerivAt).fderiv)
+
+theorem norm_fderiv_pGradient_le {n : ℕ} {S : ComplexPhaseSpace n → ℂ}
+    {U : Set (ComplexPhaseSpace n)} {r : ℝ≥0} {M : ℝ} {x : ComplexPhaseSpace n}
+    (hr : 0 < r) (hS : AnalyticOnNhd ℂ S U) (hM : NormBoundOn S U M)
+    (hx : x ∈ erosion U (r + r)) : ‖fderiv ℂ (pGradient S) x‖ ≤ M / r / r := by
+  apply norm_fderiv_le_div_of_mem_erosion hr
+    (fun y hy => analyticAt_pGradient (hS y (erosion_subset U r hy)))
+    (show NormBoundOn (pGradient S) (erosion U r) (M / r) from
+      ⟨div_nonneg hM.nonneg r.coe_nonneg, fun _ hy => norm_pGradient_le_div hr hS hM hy⟩)
+  intro y hy
+  exact mem_erosion_of_dist_le hx hy
+
+theorem norm_fderiv_qGradient_le {n : ℕ} {S : ComplexPhaseSpace n → ℂ}
+    {U : Set (ComplexPhaseSpace n)} {r : ℝ≥0} {M : ℝ} {x : ComplexPhaseSpace n}
+    (hr : 0 < r) (hS : AnalyticOnNhd ℂ S U) (hM : NormBoundOn S U M)
+    (hx : x ∈ erosion U (r + r)) : ‖fderiv ℂ (qGradient S) x‖ ≤ M / r / r := by
+  apply norm_fderiv_le_div_of_mem_erosion hr
+    (fun y hy => analyticAt_qGradient (hS y (erosion_subset U r hy)))
+    (show NormBoundOn (qGradient S) (erosion U r) (M / r) from
+      ⟨div_nonneg hM.nonneg r.coe_nonneg, fun _ hy => norm_qGradient_le_div hr hS hM hy⟩)
+  intro y hy
+  exact mem_erosion_of_dist_le hx hy
+
+theorem norm_qGradient_le_on_product {n : ℕ} {S : ComplexPhaseSpace n → ℂ}
+    {G U : Set (ComplexSpace n)} {δ : ℝ≥0} {M : ℝ} {P q : ComplexSpace n}
+    (hδ : 0 < δ) (hS : AnalyticOnNhd ℂ S (G ×ˢ U))
+    (hM : NormBoundOn S (G ×ˢ U) M) (hP : P ∈ G) (hq : q ∈ erosion U δ) :
+    ‖qGradient S (P, q)‖ ≤ M / δ := by
+  let f : ComplexSpace n → ℂ := fun t => S (P, t)
+  have hf : AnalyticOnNhd ℂ f U := fun t ht =>
+    (hS (P, t) ⟨hP, ht⟩).comp (f := fun t => (P, t)) (analyticAt_const.prod analyticAt_id)
+  have hb : NormBoundOn f U M := ⟨hM.nonneg, fun t ht => hM.norm_le ⟨hP, ht⟩⟩
+  have hd := ((hS (P, q) ⟨hP, erosion_subset _ _ hq⟩).differentiableAt.hasFDerivAt).comp q
+    ((hasFDerivAt_const P q).prodMk (hasFDerivAt_id (𝕜 := ℂ) q))
+  apply (complex_norm_le_iff _ (div_nonneg hM.nonneg δ.coe_nonneg)).2
+  intro j
+  have h := norm_fderiv_apply_le_div_of_mem_erosion (f := f) (x := q) hδ hf hb hq
+    (show ‖Pi.single j (1 : ℂ)‖ ≤ 1 by rw [Pi.norm_single]; norm_num)
+  change ‖fderiv ℂ (S ∘ Prod.mk P) q (Pi.single j 1)‖ ≤ _ at h
+  rw [hd.fderiv] at h
+  exact h
+
+end KamProject.Arnold1963
diff --git a/LeanPool/ArnoldKAM/Arnold1963/Geometry/HamiltonianLocalization.lean b/LeanPool/ArnoldKAM/Arnold1963/Geometry/HamiltonianLocalization.lean
new file mode 100644
index 0000000000..7f8455eb69
--- /dev/null
+++ b/LeanPool/ArnoldKAM/Arnold1963/Geometry/HamiltonianLocalization.lean
@@ -0,0 +1,161 @@
+/-
+Copyright (c) 2026 Bingqi Yu. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Bingqi Yu
+-/
+
+module
+
+public import LeanPool.ArnoldKAM.Arnold1963.Geometry.Localization
+public import LeanPool.ArnoldKAM.Arnold1963.Step.Integrable
+public import Mathlib.LinearAlgebra.Determinant
+public import Mathlib.Analysis.Normed.Operator.Banach
+
+/-!
+Nondegeneracy of the Hamiltonian Hessian supplies local frequency data. HamiltonianPatch
+is an output format whose existence is proved before the perturbation is chosen.
+-/
+
+@[expose] public section
+noncomputable section
+open Set Filter Function Metric
+open scoped Topology NNReal
+namespace KamProject.Arnold1963
+
+/-- The determinant of the derivative of the action-frequency map. -/
+def hessianDet {n : ℕ} (H₀ : ComplexSpace n → ℂ) (p : ComplexSpace n) : ℂ :=
+  LinearMap.det (fderiv ℂ (actionFrequency H₀) p).toLinearMap
+
+theorem frequency_derivative_apply {n : ℕ} {H₀ : ComplexSpace n → ℂ}
+    {p : ComplexSpace n} (ha : AnalyticAt ℂ H₀ p) (v : ComplexSpace n) (j : Fin n) :
+    fderiv ℂ (actionFrequency H₀) p v j =
+      fderiv ℂ (fderiv ℂ H₀) p v (Pi.single j 1) := by
+  exact fderiv_actionFrequency_apply ha v j
+
+theorem hessianDet_eq_matrix {n : ℕ} {H₀ : ComplexSpace n → ℂ}
+    {p : ComplexSpace n} (ha : AnalyticAt ℂ H₀ p) :
+    hessianDet H₀ p = Matrix.det (fun i j : Fin n =>
+      fderiv ℂ (fderiv ℂ H₀) p (Pi.single j 1) (Pi.single i 1)) := by
+  rw [hessianDet, ← LinearMap.det_toMatrix']
+  congr 1
+  ext i j
+  exact fderiv_actionFrequency_apply ha (Pi.single j 1) i
+
+theorem isUnit_frequency_derivative_iff {n : ℕ} (H₀ : ComplexSpace n → ℂ)
+    (p : ComplexSpace n) :
+    IsUnit (fderiv ℂ (actionFrequency H₀) p) ↔ hessianDet H₀ p ≠ 0 := by
+  rw [ContinuousLinearMap.isUnit_iff_isUnit_toLinearMap, LinearMap.isUnit_iff_isUnit_det,
+    isUnit_iff_ne_zero]
+  rfl
+
+/-- A compact Hamiltonian patch with an analytic frequency chart and uniform derivative bounds. -/
+structure HamiltonianPatch (n : ℕ) (H₀ : ComplexSpace n → ℂ)
+    (ambient : Set (ComplexSpace n)) where
+  /-- The patch's compact complex action domain. -/
+  domain : Set (ComplexSpace n)
+  subset : domain ⊆ ambient
+  /-- The real center of the patch's frequency polydisc. -/
+  center : RealSpace n
+  /-- The common coordinate radius of the patch's frequency polydisc. -/
+  radius : ℝ
+  radius_pos : 0 < radius
+  /-- The analytic inverse of the action-frequency chart on its frequency polydisc. -/
+  inverse : ComplexSpace n → ComplexSpace n
+  chart : AnalyticFrequencyChart (actionFrequency H₀) inverse domain
+    (realCenteredPolydisc center (fun _ => radius))
+  analytic : AnalyticOnNhd ℂ H₀ domain
+  conj : ∀ p ∈ domain, H₀ (conjVec p) = star (H₀ p)
+  /-- The positive lower bound on the frequency derivative, chosen below one. -/
+  lower : ℝ≥0
+  /-- The upper bound on the frequency derivative, chosen above one. -/
+  upper : ℝ≥0
+  lower_pos : 0 < lower
+  lower_lt_one : lower < 1
+  upper_gt_one : 1 < upper
+  derivative_lower : ∀ p ∈ domain, ∀ v,
+    (lower : ℝ) * ‖v‖ ≤ ‖fderiv ℂ (actionFrequency H₀) p v‖
+  derivative_upper : ∀ p ∈ domain, ‖fderiv ℂ (actionFrequency H₀) p‖ ≤ upper
+
+namespace HamiltonianPatch
+variable {n : ℕ} {H₀ : ComplexSpace n → ℂ} {ambient : Set (ComplexSpace n)}
+
+/-- The frequency polydisc associated with the Hamiltonian patch. -/
+def frequencyDomain (c : HamiltonianPatch n H₀ ambient) : Set (ComplexSpace n) :=
+  realCenteredPolydisc c.center (fun _ => c.radius)
+
+/-- The geometric type constant for the patch's frequency polydisc. -/
+def typeConstant (c : HamiltonianPatch n H₀ ambient) : ℝ :=
+  polydiscTypeConstant (fun _ : Fin n => c.radius)
+
+theorem typeD (c : HamiltonianPatch n H₀ ambient) (hn : 0 < n) :
+    TypeD c.frequencyDomain c.typeConstant :=
+  realCenteredPolydisc_typeD hn c.center _ (fun _ => c.radius_pos)
+
+theorem exists_at {x : RealSpace n} {V : Set (ComplexSpace n)}
+    (hV : V ∈ 𝓝 (complexify x)) (hVG : V ⊆ ambient)
+    (ha : AnalyticOnNhd ℂ H₀ ambient)
+    (hc : ∀ p ∈ ambient, H₀ (conjVec p) = star (H₀ p))
+    (hnd : hessianDet H₀ (complexify x) ≠ 0) :
+    ∃ c : HamiltonianPatch n H₀ ambient,
+      c.domain ⊆ V ∧ complexify x ∈ interior c.domain := by
+  obtain ⟨a, ha0, hab⟩ := Metric.mem_nhds_iff.mp hV
+  have hball : ball (complexify x) a ⊆ ambient := hab.trans hVG
+  have hfc : ∀ p ∈ ball (complexify x) a,
+      actionFrequency H₀ (conjVec p) = conjVec (actionFrequency H₀ p) := by
+    intro p hp
+    have hcp : conjVec p ∈ ball (complexify x) a := by
+      change dist (star p) (complexify x) < a
+      have hxstar : star (complexify x) = complexify x := conjVec_complexify x
+      rw [← hxstar, dist_star_star]
+      exact hp
+    exact actionFrequency_conj_of_mem_nhds (ha _ (hball hp)) hc
+      (mem_of_superset (isOpen_ball.mem_nhds hcp) hball)
+  obtain ⟨g, G, r, hr, hG, hxG, hchart⟩ := exists_polydisc_frequency_chart x
+    (ball_mem_nhds _ ha0) (analyticOnNhd_actionFrequency ha _ (hVG (mem_of_mem_nhds hV)))
+    ((isUnit_frequency_derivative_iff H₀ _).mpr hnd) hfc
+  obtain ⟨θ, Θ, hθ, hθ1, hΘ, hlo, hup⟩ := hchart.exists_derivative_bounds
+  exact ⟨{
+    domain := G
+    subset := hG.trans hball
+    center := realPart (actionFrequency H₀ (complexify x))
+    radius := r
+    radius_pos := hr
+    inverse := g
+    chart := hchart
+    analytic := ha.mono (hG.trans hball)
+    conj := fun p hp => hc p (hball (hG hp))
+    lower := θ
+    upper := Θ
+    lower_pos := hθ
+    lower_lt_one := hθ1
+    upper_gt_one := hΘ
+    derivative_lower := hlo
+    derivative_upper := hup }, hG.trans hab, hxG⟩
+
+theorem exists_finite_cover {K : Set (RealSpace n)} (hK : IsCompact K)
+    (hKG : ∀ x ∈ K, complexify x ∈ interior ambient)
+    (ha : AnalyticOnNhd ℂ H₀ ambient)
+    (hc : ∀ p ∈ ambient, H₀ (conjVec p) = star (H₀ p))
+    (hnd : ∀ x ∈ K, hessianDet H₀ (complexify x) ≠ 0) :
+    ∃ s : Finset (HamiltonianPatch n H₀ ambient),
+      K ⊆ ⋃ c ∈ s, realSlice (interior c.domain) := by
+  classical
+  have hex : ∀ x : K, ∃ c : HamiltonianPatch n H₀ ambient,
+      complexify x.val ∈ interior c.domain := by
+    intro x
+    obtain ⟨c, _, hx⟩ := exists_at (mem_interior_iff_mem_nhds.mp (hKG x x.property))
+      (Subset.refl ambient) ha hc (hnd x x.property)
+    exact ⟨c, hx⟩
+  choose c hcx using hex
+  obtain ⟨s, hs⟩ := hK.elim_finite_subcover
+    (fun x : K => realSlice (interior (c x).domain))
+    (fun _ => isOpen_realSlice isOpen_interior) (by
+      intro x hx
+      exact mem_iUnion.mpr ⟨⟨x, hx⟩, hcx ⟨x, hx⟩⟩)
+  refine ⟨s.image c, ?_⟩
+  intro x hx
+  obtain ⟨j, hj, hxj⟩ := mem_iUnion₂.mp (hs hx)
+  exact mem_iUnion₂.mpr ⟨c j, Finset.mem_image.mpr ⟨j, hj, rfl⟩, hxj⟩
+
+end HamiltonianPatch
+end KamProject.Arnold1963
diff --git a/LeanPool/ArnoldKAM/Arnold1963/Geometry/Localization.lean b/LeanPool/ArnoldKAM/Arnold1963/Geometry/Localization.lean
new file mode 100644
index 0000000000..e788b0fc3b
--- /dev/null
+++ b/LeanPool/ArnoldKAM/Arnold1963/Geometry/Localization.lean
@@ -0,0 +1,156 @@
+/-
+Copyright (c) 2026 Bingqi Yu. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Bingqi Yu
+-/
+
+module
+
+public import LeanPool.ArnoldKAM.Arnold1963.Geometry.FrequencyChart
+public import LeanPool.ArnoldKAM.Arnold1963.Geometry.RealCover
+public import LeanPool.ArnoldKAM.Arnold1963.Geometry.SlabMeasure
+
+/-!
+Construct a local frequency chart from nondegeneracy at a real point, before choosing a
+perturbation. The frequency domain is a real-centered closed polydisc; the action domain is
+its analytic inverse image and need not be convex.
+-/
+
+@[expose] public section
+noncomputable section
+open Set Function Filter Metric
+open scoped Topology NNReal
+namespace KamProject.Arnold1963
+
+theorem realCenteredPolydisc_const_eq_closedBall {n : ℕ} (c : RealSpace n)
+    {r : ℝ} (hr : 0 ≤ r) :
+    realCenteredPolydisc c (fun _ => r) = closedBall (complexify c) r := by
+  ext z
+  simp only [realCenteredPolydisc, mem_ofPred_eq, mem_closedBall, dist_eq_norm,
+    pi_norm_le_iff_of_nonneg hr, Pi.sub_apply, complexify]
+
+theorem exists_polydisc_frequency_chart {n : ℕ}
+    {A : ComplexSpace n → ComplexSpace n} {V : Set (ComplexSpace n)}
+    (x : RealSpace n) (hV : V ∈ 𝓝 (complexify x))
+    (ha : AnalyticAt ℂ A (complexify x))
+    (hu : IsUnit (fderiv ℂ A (complexify x)))
+    (hc : ∀ p ∈ V, A (conjVec p) = conjVec (A p)) :
+    ∃ (g : ComplexSpace n → ComplexSpace n) (G : Set (ComplexSpace n))
+      (r : ℝ), 0 < r ∧ G ⊆ V ∧ complexify x ∈ interior G ∧
+      AnalyticFrequencyChart A g G
+        (realCenteredPolydisc (realPart (A (complexify x))) (fun _ => r)) := by
+  obtain ⟨u, hu⟩ := hu
+  let i : ComplexSpace n ≃L[ℂ] ComplexSpace n := ContinuousLinearEquiv.ofUnit u
+  have hi : fderiv ℂ A (complexify x) = (i : ComplexSpace n →L[ℂ] ComplexSpace n) := hu.symm
+  have hd : HasStrictFDerivAt A (i : ComplexSpace n →L[ℂ] ComplexSpace n) (complexify x) := by
+    rw [← hi]
+    exact ha.hasStrictFDerivAt
+  let R := hd.toOpenPartialHomeomorph A
+  have hx : complexify x ∈ R.source := hd.mem_toOpenPartialHomeomorph_source
+  have hAx : A (complexify x) ∈ R.target := hd.image_mem_toOpenPartialHomeomorph_target
+  have hg : AnalyticAt ℂ R.symm (A (complexify x)) := R.analyticAt_symm' hx ha hi
+  have he : R.symm (A (complexify x)) = complexify x := R.left_inv hx
+  have hgood : ∀ᶠ p in 𝓝 (complexify x),
+      p ∈ R.source ∧ p ∈ V ∧ AnalyticAt ℂ A p := by
+    filter_upwards [R.open_source.mem_nhds hx, hV, ha.eventually_analyticAt] with p hp hpV hpA
+    exact ⟨hp, hpV, hpA⟩
+  obtain ⟨a, ha0, hab⟩ := Metric.mem_nhds_iff.mp hgood
+  have hga : ∀ᶠ y in 𝓝 (A (complexify x)), R.symm y ∈ ball (complexify x) a := by
+    apply hg.continuousAt.tendsto.eventually
+    rw [he]
+    exact ball_mem_nhds _ ha0
+  have ht : ∀ᶠ y in 𝓝 (A (complexify x)),
+      y ∈ R.target ∧ R.symm y ∈ ball (complexify x) a ∧ AnalyticAt ℂ R.symm y := by
+    filter_upwards [R.open_target.mem_nhds hAx, hga, hg.eventually_analyticAt] with y hy hyb hya
+    exact ⟨hy, hyb, hya⟩
+  obtain ⟨r, hr, hrt⟩ := Metric.nhds_basis_closedBall.mem_iff.mp ht
+  let Ω := closedBall (A (complexify x)) r
+  let G := R.symm '' Ω
+  have hΩ : ∀ y ∈ Ω, y ∈ R.target ∧ R.symm y ∈ ball (complexify x) a ∧
+      AnalyticAt ℂ R.symm y := fun _ hy => hrt hy
+  have hright : ∀ y ∈ Ω, A (R.symm y) = y := fun y hy => R.right_inv (hΩ y hy).1
+  have hG : ∀ p ∈ G, p ∈ R.source ∧ p ∈ V ∧ AnalyticAt ℂ A p := by
+    rintro p ⟨y, hy, rfl⟩
+    exact hab (hΩ y hy).2.1
+  have hcenter : conjVec (A (complexify x)) = A (complexify x) := by
+    simpa only [conjVec_complexify] using (hc _ (mem_of_mem_nhds hV)).symm
+  have hΩc : ConjInvariant Ω := by
+    intro y hy
+    change dist (star y) (A (complexify x)) ≤ r
+    change dist y (A (complexify x)) ≤ r at hy
+    rw [← hcenter, conjVec_eq_star, dist_star_star]
+    exact hy
+  have hGc : ConjInvariant G := by
+    rintro p ⟨y, hy, rfl⟩
+    have hp := (hΩ y hy).2.1
+    have hpc : conjVec (R.symm y) ∈ ball (complexify x) a := by
+      change dist (star (R.symm y)) (complexify x) < a
+      have hxstar : star (complexify x) = complexify x := conjVec_complexify x
+      rw [← hxstar, dist_star_star]
+      exact hp
+    have hmap : A (conjVec (R.symm y)) = conjVec y := by
+      rw [hc _ (hab hp).2.1, hright y hy]
+    refine ⟨conjVec y, hΩc _ hy, ?_⟩
+    rw [← hmap]
+    exact R.left_inv (hab hpc).1
+  have hchart : AnalyticFrequencyChart A R.symm G Ω := {
+    compact := (isCompact_closedBall _ _).image_of_continuousOn
+      (fun y hy => (hΩ y hy).2.2.continuousAt.continuousWithinAt)
+    analytic := fun p hp => (hG p hp).2.2
+    inverse_analytic := fun y hy => (hΩ y hy).2.2
+    maps := by
+      rintro p ⟨y, hy, rfl⟩
+      simpa only [hright y hy] using hy
+    inverse_maps := fun y hy => ⟨y, hy, rfl⟩
+    left_local := fun p hp => R.eventually_left_inverse (hG p hp).1
+    right_local := fun y hy => R.eventually_right_inverse (hΩ y hy).1
+    domain_conj := hGc
+    map_conj := fun p hp => hc p (hG p hp).2.1 }
+  have hxG : complexify x ∈ G := ⟨A (complexify x), mem_closedBall_self hr.le, he⟩
+  refine ⟨R.symm, G, r, hr, fun p hp => (hG p hp).2.1,
+    hchart.interior_back hxG ?_, ?_⟩
+  · exact mem_interior_iff_mem_nhds.mpr (closedBall_mem_nhds _ hr)
+  · rw [realCenteredPolydisc_const_eq_closedBall _ hr.le,
+      complexify_realPart_of_conj hcenter]
+    exact hchart
+
+theorem AnalyticFrequencyChart.exists_derivative_bounds {n : ℕ}
+    {A g : ComplexSpace n → ComplexSpace n} {G Ω : Set (ComplexSpace n)}
+    (c : AnalyticFrequencyChart A g G Ω) :
+    ∃ θ Θ : ℝ≥0, 0 < θ ∧ θ < 1 ∧ 1 < Θ ∧
+      (∀ p ∈ G, ∀ v, (θ : ℝ) * ‖v‖ ≤ ‖fderiv ℂ A p v‖) ∧
+      (∀ p ∈ G, ‖fderiv ℂ A p‖ ≤ Θ) := by
+  obtain ⟨B, hB⟩ := c.compact.exists_bound_of_continuousOn c.analytic.fderiv.continuousOn
+  obtain ⟨C, hC⟩ := c.image_compact.exists_bound_of_continuousOn
+    c.inverse_analytic.fderiv.continuousOn
+  let L := |C| + 2
+  have hL : 1 < L := by dsimp [L]; linarith [abs_nonneg C]
+  let θ : ℝ≥0 := ⟨L⁻¹, inv_nonneg.mpr (le_of_lt (zero_lt_one.trans hL))⟩
+  let Θ : ℝ≥0 := ⟨|B| + 2, by positivity⟩
+  refine ⟨θ, Θ, ?_, ?_, ?_, ?_, fun p hp => (hB p hp).trans ?_⟩
+  · exact inv_pos.mpr (zero_lt_one.trans hL)
+  · exact inv_lt_one_of_one_lt₀ hL
+  · change (1 : ℝ) < |B| + 2
+    linarith [abs_nonneg B]
+  · intro p hp v
+    have hd := (c.inverse_analytic _ (c.maps hp)).differentiableAt.hasFDerivAt.comp p
+      (c.analytic _ hp).differentiableAt.hasFDerivAt
+    have heq : (fun x => g (A x)) =ᶠ[𝓝 p] id := c.left_local p hp
+    have hid : (fderiv ℂ g (A p)).comp (fderiv ℂ A p) = ContinuousLinearMap.id ℂ _ :=
+      (hd.congr_of_eventuallyEq heq.symm).unique (hasFDerivAt_id p)
+    have hv : ‖v‖ ≤ L * ‖fderiv ℂ A p v‖ := by
+      calc
+        ‖v‖ = ‖fderiv ℂ g (A p) (fderiv ℂ A p v)‖ := by
+          rw [← ContinuousLinearMap.comp_apply, hid, ContinuousLinearMap.id_apply]
+        _ ≤ ‖fderiv ℂ g (A p)‖ * ‖fderiv ℂ A p v‖ := ContinuousLinearMap.le_opNorm _ _
+        _ ≤ L * ‖fderiv ℂ A p v‖ := mul_le_mul_of_nonneg_right
+          ((hC _ (c.maps hp)).trans (by dsimp [L]; linarith [le_abs_self C])) (norm_nonneg _)
+    change L⁻¹ * ‖v‖ ≤ _
+    calc
+      L⁻¹ * ‖v‖ ≤ L⁻¹ * (L * ‖fderiv ℂ A p v‖) :=
+        mul_le_mul_of_nonneg_left hv (inv_nonneg.mpr (le_of_lt (zero_lt_one.trans hL)))
+      _ = _ := by rw [← mul_assoc, inv_mul_cancel₀ (ne_of_gt (zero_lt_one.trans hL)), one_mul]
+  · change B ≤ |B| + 2
+    linarith [le_abs_self B]
+
+end KamProject.Arnold1963
diff --git a/LeanPool/ArnoldKAM/Arnold1963/Geometry/LocalizationCover.lean b/LeanPool/ArnoldKAM/Arnold1963/Geometry/LocalizationCover.lean
new file mode 100644
index 0000000000..3455004a0f
--- /dev/null
+++ b/LeanPool/ArnoldKAM/Arnold1963/Geometry/LocalizationCover.lean
@@ -0,0 +1,85 @@
+/-
+Copyright (c) 2026 Bingqi Yu. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Bingqi Yu
+-/
+
+module
+
+public import LeanPool.ArnoldKAM.Arnold1963.Geometry.HamiltonianLocalization
+public import Mathlib.MeasureTheory.Measure.Regular
+
+/-!
+Finite local coverage from the original nondegenerate Hamiltonian data. Loss is measured
+relative to the original action volume; the covering patches may overlap.
+-/
+
+@[expose] public section
+noncomputable section
+open Set MeasureTheory Filter
+open scoped Topology ENNReal
+namespace KamProject.Arnold1963
+
+/-- The unperturbed Hamiltonian and explicit compact-domain hypotheses for the global theorem. -/
+structure GlobalHamiltonianData (n : ℕ) (H₀ : ComplexSpace n → ℂ)
+    (ambient : Set (ComplexSpace n)) : Type where
+  dimension_pos : 0 < n
+  compact : IsCompact ambient
+  domain_conj : ConjInvariant ambient
+  analytic : AnalyticOnNhd ℂ H₀ ambient
+  conj : ∀ p ∈ ambient, H₀ (conjVec p) = star (H₀ p)
+  /-- The nonempty open real action set whose closure is the ambient domain's real slice. -/
+  realOpen : Set (RealSpace n)
+  isOpen_realOpen : IsOpen realOpen
+  nonempty_realOpen : realOpen.Nonempty
+  closure_realOpen : closure realOpen = realSlice ambient
+  boundary_null : volume (frontier realOpen) = 0
+  complex_interior : ∀ p ∈ realOpen, complexify p ∈ interior ambient
+  nondegenerate : ∀ p ∈ realOpen, hessianDet H₀ (complexify p) ≠ 0
+
+namespace GlobalHamiltonianData
+variable {n : ℕ} {H₀ : ComplexSpace n → ℂ} {ambient : Set (ComplexSpace n)}
+  (h : GlobalHamiltonianData n H₀ ambient)
+include h
+
+theorem realOpen_subset : h.realOpen ⊆ realSlice ambient :=
+  h.closure_realOpen ▸ subset_closure
+
+theorem volume_finite : volume (realSlice ambient) ≠ ⊤ :=
+  (isCompact_realSlice h.compact).measure_ne_top
+
+theorem volume_pos : 0 < volume (realSlice ambient) :=
+  (h.isOpen_realOpen.measure_pos volume h.nonempty_realOpen).trans_le
+    (measure_mono h.realOpen_subset)
+
+theorem real_boundary_null : volume (realSlice ambient \ h.realOpen) = 0 := by
+  simpa only [frontier, h.isOpen_realOpen.interior_eq, h.closure_realOpen] using h.boundary_null
+
+theorem exists_cover (ε : ℝ) (hε : 0 < ε) :
+    ∃ s : Finset (HamiltonianPatch n H₀ ambient),
+      volume (realSlice ambient \ ⋃ c ∈ s, realSlice c.domain) <
+        ENNReal.ofReal ε * volume (realSlice ambient) := by
+  have hεV : ENNReal.ofReal ε * volume (realSlice ambient) ≠ 0 :=
+    mul_ne_zero (ENNReal.ofReal_pos.mpr hε).ne' h.volume_pos.ne'
+  obtain ⟨K, hKU, hK, hVK⟩ := h.isOpen_realOpen.measurableSet.exists_isCompact_sdiff_lt
+    (ne_top_of_le_ne_top h.volume_finite (measure_mono h.realOpen_subset)) hεV
+  obtain ⟨s, hs⟩ := HamiltonianPatch.exists_finite_cover hK
+    (fun p hp => h.complex_interior p (hKU hp)) h.analytic h.conj
+    (fun p hp => h.nondegenerate p (hKU hp))
+  refine ⟨s, lt_of_le_of_lt ?_ hVK⟩
+  calc
+    volume (realSlice ambient \ ⋃ c ∈ s, realSlice c.domain) ≤
+        volume ((realSlice ambient \ h.realOpen) ∪ (h.realOpen \ K)) := measure_mono (by
+      intro p hp
+      by_cases hpU : p ∈ h.realOpen
+      · refine Or.inr ⟨hpU, ?_⟩
+        intro hpK
+        obtain ⟨c, hc, hpc⟩ := mem_iUnion₂.mp (hs hpK)
+        exact hp.2 (mem_iUnion₂.mpr ⟨c, hc,
+          (show complexify p ∈ c.domain from interior_subset hpc)⟩)
+      · exact Or.inl ⟨hp.1, hpU⟩)
+    _ ≤ volume (realSlice ambient \ h.realOpen) + volume (h.realOpen \ K) := measure_union_le _ _
+    _ = volume (h.realOpen \ K) := by rw [h.real_boundary_null, zero_add]
+
+end GlobalHamiltonianData
+end KamProject.Arnold1963
diff --git a/LeanPool/ArnoldKAM/Arnold1963/Geometry/NearIdentity.lean b/LeanPool/ArnoldKAM/Arnold1963/Geometry/NearIdentity.lean
new file mode 100644
index 0000000000..2694be4265
--- /dev/null
+++ b/LeanPool/ArnoldKAM/Arnold1963/Geometry/NearIdentity.lean
@@ -0,0 +1,87 @@
+/-
+Copyright (c) 2026 Bingqi Yu. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Bingqi Yu
+-/
+
+module
+
+public import LeanPool.ArnoldKAM.Arnold1963.Basic.Functions
+public import Mathlib.Topology.MetricSpace.Contracting
+public import Mathlib.Analysis.Calculus.InverseFunctionTheorem.FDeriv
+public import Mathlib.Analysis.Calculus.FDeriv.Analytic
+public import Mathlib.Analysis.SpecificLimits.Normed
+
+/-!
+Unique implicit roots on closed balls and analytic local inverses in Banach spaces.
+-/
+
+@[expose] public section
+noncomputable section
+open Set Filter Function Metric
+open scoped Topology NNReal
+namespace KamProject.Arnold1963
+
+variable {E : Type*} [NormedAddCommGroup E] [NormedSpace ℂ E] [CompleteSpace E]
+
+omit [NormedSpace ℂ E] in
+theorem existsUnique_add_eq_on_closedBall {a : E → E} {Q : E} {r κ : ℝ≥0} {ε : ℝ}
+    (hb : NormBoundOn a (Metric.closedBall Q r) ε) (hε : ε ≤ r)
+    (hκ : κ < 1) (hLip : LipschitzOnWith κ a (Metric.closedBall Q r)) :
+    ∃! q, q ∈ Metric.closedBall Q r ∧ q + a q = Q := by
+  let T : E → E := fun q => Q - a q
+  have hmap : MapsTo T (Metric.closedBall Q r) (Metric.closedBall Q r) := by
+    intro q hq
+    simpa [T, Metric.mem_closedBall, dist_eq_norm] using (hb.norm_le hq).trans hε
+  have hc : ContractingWith κ (hmap.restrict T _ _) := by
+    refine ⟨hκ, LipschitzWith.of_dist_le_mul (fun x y => ?_)⟩
+    change dist (Q - a x) (Q - a y) ≤ _
+    simpa only [dist_sub_left, Subtype.dist_eq] using hLip.dist_le_mul x x.property y y.property
+  obtain ⟨q, hq, he, _, _⟩ := ContractingWith.exists_fixedPoint'
+    isClosed_closedBall.isComplete hmap hc (Metric.mem_closedBall_self r.coe_nonneg)
+    (edist_ne_top Q (T Q))
+  have heq : q + a q = Q := (eq_sub_iff_add_eq).mp he.symm
+  refine ⟨q, ⟨hq, heq⟩, ?_⟩
+  intro z hz
+  have hzfix : IsFixedPt (hmap.restrict T _ _) (⟨z, hz.1⟩ : Metric.closedBall Q r) := by
+    apply Subtype.ext
+    exact (eq_sub_iff_add_eq.mpr hz.2).symm
+  have hqfix : IsFixedPt (hmap.restrict T _ _) (⟨q, hq⟩ : Metric.closedBall Q r) := by
+    apply Subtype.ext
+    exact he
+  exact congrArg Subtype.val (hc.fixedPoint_unique' hzfix hqfix)
+
+omit [NormedSpace ℂ E] [CompleteSpace E] in
+theorem norm_sub_le_of_add_eq {a : E → E} {q Q : E} {ε : ℝ}
+    (he : q + a q = Q) (hb : ‖a q‖ ≤ ε) : ‖q - Q‖ ≤ ε := by
+  rw [← he]
+  simpa using hb
+
+theorem exists_analytic_local_inverse_of_isUnit {f : E → E} {x : E}
+    (hf : AnalyticAt ℂ f x) (hu : IsUnit (fderiv ℂ f x)) :
+    ∃ g : E → E, AnalyticAt ℂ g (f x) ∧ g (f x) = x ∧
+      (∀ᶠ y in 𝓝 (f x), f (g y) = y) := by
+  obtain ⟨u, hu⟩ := hu
+  let i : E ≃L[ℂ] E := ContinuousLinearEquiv.ofUnit u
+  have hi : fderiv ℂ f x = (i : E →L[ℂ] E) := hu.symm
+  have hd : HasStrictFDerivAt f (i : E →L[ℂ] E) x := by
+    rw [← hi]
+    exact hf.hasStrictFDerivAt
+  let R := hd.toOpenPartialHomeomorph f
+  refine ⟨R.symm, ?_, R.left_inv hd.mem_toOpenPartialHomeomorph_source,
+    hd.eventually_right_inverse⟩
+  exact R.analyticAt_symm' hd.mem_toOpenPartialHomeomorph_source hf hi
+
+theorem exists_analytic_local_inverse {f : E → E} {x : E}
+    (hf : AnalyticAt ℂ f x)
+    (hn : ‖fderiv ℂ f x - ContinuousLinearMap.id ℂ E‖ < 1) :
+    ∃ g : E → E, AnalyticAt ℂ g (f x) ∧ g (f x) = x ∧
+      (∀ᶠ y in 𝓝 (f x), f (g y) = y) := by
+  apply exists_analytic_local_inverse_of_isUnit hf
+  have h := isUnit_one_sub_of_norm_lt_one
+    (show ‖-(fderiv ℂ f x - ContinuousLinearMap.id ℂ E)‖ < 1 by simpa only [norm_neg] using hn)
+  convert h using 1
+  change fderiv ℂ f x = 1 - -(fderiv ℂ f x - 1)
+  abel
+
+end KamProject.Arnold1963
diff --git a/LeanPool/ArnoldKAM/Arnold1963/Geometry/Polydisc.lean b/LeanPool/ArnoldKAM/Arnold1963/Geometry/Polydisc.lean
new file mode 100644
index 0000000000..e5c6fc2516
--- /dev/null
+++ b/LeanPool/ArnoldKAM/Arnold1963/Geometry/Polydisc.lean
@@ -0,0 +1,113 @@
+/-
+Copyright (c) 2026 Bingqi Yu. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Bingqi Yu
+-/
+
+module
+
+public import LeanPool.ArnoldKAM.Arnold1963.Geometry.Erosion
+public import LeanPool.ArnoldKAM.Arnold1963.Basic.Measure
+public import Mathlib.Tactic.Linarith.NNRealPreprocessor
+public import Mathlib.Tactic.Ring
+
+/-!
+Real-centered complex polydiscs and the volumes of their real slices after erosion.
+-/
+
+@[expose] public section
+noncomputable section
+open Set Metric MeasureTheory
+open scoped NNReal ENNReal
+namespace KamProject.Arnold1963
+
+/-- The closed coordinate polydisc centered at a real vector. -/
+def realCenteredPolydisc {n : ℕ} (c r : RealSpace n) : Set (ComplexSpace n) :=
+  {z | ∀ j, ‖z j - (c j : ℂ)‖ ≤ r j}
+
+theorem realSlice_realCenteredPolydisc {n : ℕ} (c r : RealSpace n) :
+    realSlice (realCenteredPolydisc c r) =
+      pi univ (fun j => Icc (c j - r j) (c j + r j)) := by
+  ext x
+  simp only [realSlice, mem_preimage, realCenteredPolydisc, mem_ofPred_eq,
+    complexify, ← Complex.ofReal_sub, Complex.norm_real, Real.norm_eq_abs,
+    mem_univ_pi, mem_Icc, abs_le]
+  exact forall_congr' fun j => by constructor <;> intro h <;> constructor <;> linarith [h.1, h.2]
+
+theorem isClosed_realCenteredPolydisc {n : ℕ} (c r : RealSpace n) :
+    IsClosed (realCenteredPolydisc c r) := by
+  have he : realCenteredPolydisc c r =
+      ⋂ j, {z : ComplexSpace n | ‖z j - (c j : ℂ)‖ ≤ r j} := by
+    ext z
+    simp [realCenteredPolydisc]
+  rw [he]
+  exact isClosed_iInter fun j => isClosed_le
+    (((continuous_apply j).sub continuous_const).norm) continuous_const
+
+theorem isCompact_realCenteredPolydisc {n : ℕ} (c r : RealSpace n) :
+    IsCompact (realCenteredPolydisc c r) := by
+  have he : realCenteredPolydisc c r = pi univ (fun j => closedBall (c j : ℂ) (r j)) := by
+    ext z
+    simp [realCenteredPolydisc, mem_closedBall, dist_eq_norm]
+  rw [he]
+  exact isCompact_univ_pi fun j => isCompact_closedBall _ _
+
+theorem realVolume_realCenteredPolydisc {n : ℕ} (c r : RealSpace n) :
+    realVolume (realCenteredPolydisc c r) = ∏ j, ENNReal.ofReal (2 * r j) := by
+  rw [realVolume, realSlice_realCenteredPolydisc]
+  simp only [realLebesgue, Measure.pi_pi, Real.volume_Icc]
+  congr 1
+  funext j
+  congr 1
+  ring
+
+theorem mem_realSlice_erosion_polydisc {n : ℕ} (c r : RealSpace n)
+    (t : ℝ≥0) (x : RealSpace n) :
+    x ∈ realSlice (erosion (realCenteredPolydisc c r) t) ↔
+      ∀ j, |x j - c j| + (t : ℝ) ≤ r j := by
+  change complexify x ∈ erosion (realCenteredPolydisc c r) t ↔ _
+  constructor
+  · intro hx j
+    have hp : complexify x + Pi.single j (t : ℂ) ∈
+        closedBall (complexify x) (t : ℝ) := by
+      simp [mem_closedBall, dist_eq_norm, Pi.norm_single]
+    have hm : complexify x - Pi.single j (t : ℂ) ∈
+        closedBall (complexify x) (t : ℝ) := by
+      simp [mem_closedBall, Pi.norm_single]
+    have hplus := hx hp j
+    have hminus := hx hm j
+    simp only [Pi.add_apply, Pi.sub_apply, Pi.single_eq_same, complexify,
+      ← Complex.ofReal_add, ← Complex.ofReal_sub, Complex.norm_real,
+      Real.norm_eq_abs] at hplus hminus
+    have hp' := (abs_le.mp hplus).2
+    have hm' := (abs_le.mp hminus).1
+    have habs : |x j - c j| ≤ r j - t := abs_le.mpr ⟨by linarith, by linarith⟩
+    linarith
+  · intro hx y hy j
+    have hd : ‖y j - (x j : ℂ)‖ ≤ (t : ℝ) :=
+      (norm_le_pi_norm (y - complexify x) j).trans
+        (by simpa only [mem_closedBall, dist_eq_norm] using hy)
+    calc
+      ‖y j - (c j : ℂ)‖ ≤ ‖y j - (x j : ℂ)‖ + ‖(x j : ℂ) - (c j : ℂ)‖ :=
+        norm_sub_le_norm_sub_add_norm_sub _ _ _
+      _ ≤ t + |x j - c j| := by
+        rw [← Complex.ofReal_sub, Complex.norm_real, Real.norm_eq_abs]
+        linarith
+      _ ≤ r j := by linarith [hx j]
+
+theorem realSlice_erosion_polydisc {n : ℕ} (c r : RealSpace n) (t : ℝ≥0) :
+    realSlice (erosion (realCenteredPolydisc c r) t) =
+      realSlice (realCenteredPolydisc c (fun j => r j - t)) := by
+  ext x
+  rw [mem_realSlice_erosion_polydisc]
+  change _ ↔ ∀ j, ‖(x j : ℂ) - (c j : ℂ)‖ ≤ r j - t
+  simp only [← Complex.ofReal_sub, Complex.norm_real, Real.norm_eq_abs]
+  exact forall_congr' fun j => by constructor <;> intro h <;> linarith
+
+theorem realVolume_erosion_polydisc {n : ℕ} (c r : RealSpace n) (t : ℝ≥0) :
+    realVolume (erosion (realCenteredPolydisc c r) t) =
+      ∏ j, ENNReal.ofReal (2 * (r j - t)) := by
+  rw [realVolume, realSlice_erosion_polydisc]
+  exact realVolume_realCenteredPolydisc c _
+
+end KamProject.Arnold1963
diff --git a/LeanPool/ArnoldKAM/Arnold1963/Geometry/PolydiscBoundary.lean b/LeanPool/ArnoldKAM/Arnold1963/Geometry/PolydiscBoundary.lean
new file mode 100644
index 0000000000..38c3583db5
--- /dev/null
+++ b/LeanPool/ArnoldKAM/Arnold1963/Geometry/PolydiscBoundary.lean
@@ -0,0 +1,138 @@
+/-
+Copyright (c) 2026 Bingqi Yu. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Bingqi Yu
+-/
+
+module
+
+public import LeanPool.ArnoldKAM.Arnold1963.Geometry.Polydisc
+
+/-!
+Boundary-layer estimates for polydiscs, with the sum of inverse radii as the type constant.
+The estimate also covers erosion beyond an individual coordinate radius.
+-/
+
+@[expose] public section
+noncomputable section
+open Set MeasureTheory
+open scoped NNReal ENNReal
+namespace KamProject.Arnold1963
+
+private theorem prod_sub_prod_le_sum_sub {ι : Type*} (s : Finset ι) (a b : ι → ℝ)
+    (hb : ∀ i ∈ s, 0 ≤ b i) (hba : ∀ i ∈ s, b i ≤ a i) (ha : ∀ i ∈ s, a i ≤ 1) :
+    (∏ i ∈ s, a i) - (∏ i ∈ s, b i) ≤ ∑ i ∈ s, (a i - b i) := by
+  classical
+  induction s using Finset.induction_on with
+  | empty => simp
+  | @insert j s hj ih =>
+    have hb' : ∀ i ∈ s, 0 ≤ b i := fun i hi => hb i (Finset.mem_insert_of_mem hi)
+    have hba' : ∀ i ∈ s, b i ≤ a i := fun i hi => hba i (Finset.mem_insert_of_mem hi)
+    have ha' : ∀ i ∈ s, a i ≤ 1 := fun i hi => ha i (Finset.mem_insert_of_mem hi)
+    have hpa := Finset.prod_le_one₀ (fun i hi => (hb' i hi).trans (hba' i hi)) ha'
+    have hdiff : 0 ≤ (∏ i ∈ s, a i) - (∏ i ∈ s, b i) :=
+      sub_nonneg.mpr (Finset.prod_le_prod₀ hb' hba')
+    have hjb := hb j (Finset.mem_insert_self j s)
+    have hjba := hba j (Finset.mem_insert_self j s)
+    have hja := ha j (Finset.mem_insert_self j s)
+    have h1 := mul_le_mul_of_nonneg_left hpa (sub_nonneg.mpr hjba)
+    have h2 := mul_le_mul_of_nonneg_right (hjba.trans hja) hdiff
+    rw [Finset.prod_insert hj, Finset.prod_insert hj, Finset.sum_insert hj]
+    nlinarith [ih hb' hba' ha']
+
+/-- The reciprocal-radius coefficient controlling boundary and slab losses in a polydisc. -/
+def polydiscTypeConstant {n : ℕ} (r : RealSpace n) : ℝ := ∑ j, (r j)⁻¹
+
+private def relativeRadius (r t : ℝ) : ℝ := max (r - t) 0 / r
+
+private theorem relativeRadius_bounds {r t : ℝ} (hr : 0 < r) (ht : 0 ≤ t) :
+    0 ≤ relativeRadius r t ∧ relativeRadius r t ≤ 1 := by
+  constructor
+  · exact div_nonneg (le_max_right _ _) hr.le
+  · apply (div_le_one hr).mpr
+    exact max_le (by linarith) hr.le
+
+private theorem relativeRadius_sub_le {r t₁ t₂ : ℝ} (hr : 0 < r) (ht : t₁ ≤ t₂) :
+    relativeRadius r t₂ ≤ relativeRadius r t₁ ∧
+      relativeRadius r t₁ - relativeRadius r t₂ ≤ (t₂ - t₁) / r := by
+  constructor
+  · exact div_le_div_of_nonneg_right (max_le_max (by linarith) le_rfl) hr.le
+  · unfold relativeRadius
+    rw [← sub_div]
+    apply div_le_div_of_nonneg_right _ hr.le
+    rcases le_total t₂ r with h₂ | h₂
+    · rw [max_eq_left (by linarith : 0 ≤ r - t₂), max_eq_left (by linarith : 0 ≤ r - t₁)]
+      linarith
+    · rw [max_eq_right (by linarith : r - t₂ ≤ 0)]
+      simp only [sub_zero]
+      exact max_le (by linarith) (by linarith)
+
+private theorem polydisc_volume_relative {n : ℕ} (c r : RealSpace n)
+    (hr : ∀ j, 0 < r j) (t : ℝ≥0) :
+    realVolume (erosion (realCenteredPolydisc c r) t) =
+      ENNReal.ofReal ((∏ j, 2 * r j) * ∏ j, relativeRadius (r j) t) := by
+  rw [realVolume_erosion_polydisc]
+  have he (j : Fin n) : ENNReal.ofReal (2 * (r j - t)) =
+      ENNReal.ofReal (2 * r j * relativeRadius (r j) t) := by
+    have he' : 2 * r j * relativeRadius (r j) t = 2 * max (r j - t) 0 := by
+      unfold relativeRadius
+      field_simp [ne_of_gt (hr j)]
+    rw [he', ENNReal.ofReal_mul (by norm_num : (0 : ℝ) ≤ 2),
+      ENNReal.ofReal_mul (by norm_num : (0 : ℝ) ≤ 2)]
+    simp
+  simp_rw [he]
+  rw [← ENNReal.ofReal_prod_of_nonneg (fun j _ =>
+    mul_nonneg (mul_nonneg (by norm_num) (hr j).le)
+      (relativeRadius_bounds (hr j) t.coe_nonneg).1),
+    Finset.prod_mul_distrib]
+
+theorem polydisc_boundary_le {n : ℕ} (c r : RealSpace n) (hr : ∀ j, 0 < r j)
+    (d₁ d₂ : ℝ≥0) (hd : d₁ ≤ d₂) :
+    realVolume (erosion (realCenteredPolydisc c r) d₁ \
+      erosion (realCenteredPolydisc c r) d₂) ≤
+      ENNReal.ofReal (polydiscTypeConstant r * ((d₂ : ℝ) - d₁)) *
+        realVolume (realCenteredPolydisc c r) := by
+  let V : ℝ := ∏ j, 2 * r j
+  have hV : 0 ≤ V := Finset.prod_nonneg fun j _ => mul_nonneg (by norm_num) (hr j).le
+  have hb (t : ℝ≥0) (j : Fin n) := relativeRadius_bounds (hr j) t.coe_nonneg
+  have hdiff (j : Fin n) := relativeRadius_sub_le (hr j) (show (d₁ : ℝ) ≤ d₂ from hd)
+  have hprod : (∏ j, relativeRadius (r j) d₁) - (∏ j, relativeRadius (r j) d₂) ≤
+      polydiscTypeConstant r * ((d₂ : ℝ) - d₁) := by
+    calc
+      _ ≤ ∑ j, (relativeRadius (r j) d₁ - relativeRadius (r j) d₂) :=
+        prod_sub_prod_le_sum_sub _ _ _ (fun j _ => (hb d₂ j).1)
+          (fun j _ => (hdiff j).1) (fun j _ => (hb d₁ j).2)
+      _ ≤ ∑ j, ((d₂ : ℝ) - d₁) / r j := Finset.sum_le_sum fun j _ => (hdiff j).2
+      _ = _ := by
+        simp only [polydiscTypeConstant, div_eq_mul_inv, Finset.sum_mul]
+        apply Finset.sum_congr rfl
+        intro j _
+        ring
+  have hsub : realSlice (erosion (realCenteredPolydisc c r) d₂) ⊆
+      realSlice (erosion (realCenteredPolydisc c r) d₁) :=
+    preimage_mono (erosion_antitone_radius _ hd)
+  have hm := (isClosed_realSlice
+    (isClosed_erosion (isClosed_realCenteredPolydisc c r) d₂)).measurableSet
+  have hfin : realVolume (erosion (realCenteredPolydisc c r) d₂) ≠ ∞ := by
+    rw [polydisc_volume_relative c r hr]
+    exact ENNReal.ofReal_ne_top
+  have he : realVolume (erosion (realCenteredPolydisc c r) d₁ \
+      erosion (realCenteredPolydisc c r) d₂) =
+      realVolume (erosion (realCenteredPolydisc c r) d₁) -
+        realVolume (erosion (realCenteredPolydisc c r) d₂) :=
+    measure_sdiff hsub hm.nullMeasurableSet hfin
+  rw [he, polydisc_volume_relative c r hr, polydisc_volume_relative c r hr,
+    ← ENNReal.ofReal_sub _ (mul_nonneg hV (Finset.prod_nonneg fun j _ => (hb d₂ j).1))]
+  have hVeq : realVolume (realCenteredPolydisc c r) = ENNReal.ofReal V := by
+    rw [realVolume_realCenteredPolydisc,
+      ← ENNReal.ofReal_prod_of_nonneg (fun j _ => mul_nonneg (by norm_num) (hr j).le)]
+  rw [hVeq, ← ENNReal.ofReal_mul (by
+    apply mul_nonneg
+    · exact Finset.sum_nonneg fun j _ => inv_nonneg.mpr (hr j).le
+    · exact sub_nonneg.mpr (show (d₁ : ℝ) ≤ d₂ from hd))]
+  apply ENNReal.ofReal_le_ofReal
+  have hh := mul_le_mul_of_nonneg_left hprod hV
+  dsimp [V] at *
+  nlinarith
+
+end KamProject.Arnold1963
diff --git a/LeanPool/ArnoldKAM/Arnold1963/Geometry/RealCover.lean b/LeanPool/ArnoldKAM/Arnold1963/Geometry/RealCover.lean
new file mode 100644
index 0000000000..b36579c355
--- /dev/null
+++ b/LeanPool/ArnoldKAM/Arnold1963/Geometry/RealCover.lean
@@ -0,0 +1,111 @@
+/-
+Copyright (c) 2026 Bingqi Yu. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Bingqi Yu
+-/
+
+module
+
+public import LeanPool.ArnoldKAM.Arnold1963.Basic.Functions
+
+/-!
+The real covering space and its quotient by the physical angle lattice.
+-/
+
+@[expose] public section
+noncomputable section
+open Set
+namespace KamProject.Arnold1963
+
+/-- Real action coordinates paired with unwrapped real angles. -/
+abbrev RealPhaseCover (n : ℕ) := RealSpace n × RealSpace n
+
+/-- Complexification of both real action and unwrapped angle coordinates. -/
+def complexifyPhase {n : ℕ} (x : RealPhaseCover n) : ComplexPhaseSpace n :=
+  (complexify x.1, complexify x.2)
+
+/-- Real-part projection of complex action and angle coordinates. -/
+def realPartPhase {n : ℕ} (x : ComplexPhaseSpace n) : RealPhaseCover n :=
+  (realPart x.1, realPart x.2)
+
+@[simp] theorem realPartPhase_complexifyPhase {n : ℕ} (x : RealPhaseCover n) :
+    realPartPhase (complexifyPhase x) = x := by simp [realPartPhase, complexifyPhase]
+
+theorem conjPhase_complexifyPhase {n : ℕ} (x : RealPhaseCover n) :
+    conjPhase (complexifyPhase x) = complexifyPhase x := by simp [conjPhase, complexifyPhase]
+
+theorem complexify_realPart_of_conj {n : ℕ} {z : ComplexSpace n} (h : conjVec z = z) :
+    complexify (realPart z) = z := by
+  funext j
+  apply Complex.ext
+  · rfl
+  · have hh := congrArg (fun v : ComplexSpace n => (v j).im) h
+    simp only [conjVec, Complex.star_def, Complex.conj_im] at hh
+    change 0 = (z j).im
+    linarith
+
+theorem complexifyPhase_realPartPhase_of_conj {n : ℕ} {z : ComplexPhaseSpace n}
+    (h : conjPhase z = z) : complexifyPhase (realPartPhase z) = z := by
+  exact Prod.ext (complexify_realPart_of_conj (congrArg Prod.fst h))
+    (complexify_realPart_of_conj (congrArg Prod.snd h))
+
+/-- The real angle shift corresponding to integer multiples of the period. -/
+def realAngleShift {n : ℕ} (k : FourierIndex n) : RealSpace n :=
+  fun j => 2 * Real.pi * (k j : ℝ)
+
+/-- Translation of unwrapped real phase space by an integer angle-period shift. -/
+def realPhaseShift {n : ℕ} (k : FourierIndex n) (x : RealPhaseCover n) : RealPhaseCover n :=
+  (x.1, x.2 + realAngleShift k)
+
+/-- Projection from unwrapped real angles to angles modulo `2π`. -/
+def torusProjection {n : ℕ} (x : RealPhaseCover n) : RealPhaseSpace n :=
+  (x.1, fun j => (x.2 j : AddCircle (2 * Real.pi)))
+
+@[simp] theorem torusProjection_shift {n : ℕ} (k : FourierIndex n) (x : RealPhaseCover n) :
+    torusProjection (realPhaseShift k x) = torusProjection x := by
+  apply Prod.ext
+  · rfl
+  funext j
+  change ((x.2 j + 2 * Real.pi * (k j : ℝ) : ℝ) : AddCircle (2 * Real.pi)) = _
+  rw [AddCircle.coe_add]
+  have hh : ((2 * Real.pi * (k j : ℝ) : ℝ) : AddCircle (2 * Real.pi)) = 0 := by
+    apply (AddCircle.coe_eq_zero_iff _).2
+    exact ⟨k j, by simp [zsmul_eq_mul, mul_comm]⟩
+  rw [hh, add_zero]
+  rfl
+
+theorem torusProjection_eq_iff {n : ℕ} (x y : RealPhaseCover n) :
+    torusProjection x = torusProjection y ↔ ∃ k : FourierIndex n, x = realPhaseShift k y := by
+  constructor
+  · intro he
+    have hp := congrArg Prod.fst he
+    change x.1 = y.1 at hp
+    have hq : ∀ j, ∃ m : ℤ, m • (2 * Real.pi) = x.2 j - y.2 j := by
+      intro j
+      apply (AddCircle.coe_eq_zero_iff _).1
+      rw [AddCircle.coe_sub, sub_eq_zero]
+      exact congrArg (fun z : RealPhaseSpace n => z.2 j) he
+    choose k hk using hq
+    refine ⟨k, Prod.ext hp ?_⟩
+    funext j
+    have hh := hk j
+    simp only [zsmul_eq_mul] at hh
+    change x.2 j = y.2 j + 2 * Real.pi * (k j : ℝ)
+    linarith
+  · rintro ⟨k, rfl⟩
+    exact torusProjection_shift k y
+
+local instance : Fact (0 < 2 * Real.pi) := ⟨mul_pos (by norm_num) Real.pi_pos⟩
+
+/-- Representatives of real torus angles in the fundamental interval `(0, 2π]`. -/
+def torusRepresentative {n : ℕ} (x : RealPhaseSpace n) : RealPhaseCover n :=
+  (x.1, fun j => (AddCircle.equivIoc (2 * Real.pi) 0 (x.2 j) : ℝ))
+
+@[simp] theorem torusProjection_representative {n : ℕ} (x : RealPhaseSpace n) :
+    torusProjection (torusRepresentative x) = x := by
+  apply Prod.ext
+  · rfl
+  funext j
+  exact AddCircle.coe_equivIoc
+
+end KamProject.Arnold1963
diff --git a/LeanPool/ArnoldKAM/Arnold1963/Geometry/RealJacobian.lean b/LeanPool/ArnoldKAM/Arnold1963/Geometry/RealJacobian.lean
new file mode 100644
index 0000000000..1dc1b12075
--- /dev/null
+++ b/LeanPool/ArnoldKAM/Arnold1963/Geometry/RealJacobian.lean
@@ -0,0 +1,99 @@
+/-
+Copyright (c) 2026 Bingqi Yu. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Bingqi Yu
+-/
+
+module
+
+public import LeanPool.ArnoldKAM.Arnold1963.Basic.Measure
+public import Mathlib.MeasureTheory.Function.Jacobian
+public import Mathlib.MeasureTheory.Measure.Lebesgue.EqHaar
+public import Mathlib.Analysis.Calculus.FDeriv.RestrictScalars
+public import Mathlib.Analysis.Calculus.FDeriv.Linear
+public import Mathlib.Analysis.Calculus.FDeriv.Comp
+public import Mathlib.Tactic.NormNum
+public import Mathlib.Tactic.Positivity
+
+/-!
+Real-slice Jacobian estimates. The maximum-norm unit cube gives the sharp C ^ n determinant
+bound without an additional dimension factor.
+-/
+
+@[expose] public section
+noncomputable section
+open Set MeasureTheory Metric
+open scoped ENNReal
+namespace KamProject.Arnold1963
+
+/-- Coordinatewise complexification as a real continuous linear map. -/
+def complexifyCLM (n : ℕ) : RealSpace n →L[ℝ] ComplexSpace n :=
+  ContinuousLinearMap.pi fun j => Complex.ofRealCLM.comp (ContinuousLinearMap.proj j)
+
+/-- Coordinatewise real-part projection as a real continuous linear map. -/
+def realPartCLM (n : ℕ) : ComplexSpace n →L[ℝ] RealSpace n :=
+  ContinuousLinearMap.pi fun j => Complex.reCLM.comp (ContinuousLinearMap.proj j)
+
+@[simp] theorem complexifyCLM_apply {n} (x : RealSpace n) : complexifyCLM n x = complexify x := rfl
+@[simp] theorem realPartCLM_apply {n} (z : ComplexSpace n) : realPartCLM n z = realPart z := rfl
+
+theorem norm_realPart_le {n} (z : ComplexSpace n) : ‖realPart z‖ ≤ ‖z‖ := by
+  apply (real_norm_le_iff _ (norm_nonneg _)).mpr
+  intro j
+  exact (Complex.abs_re_le_norm (z j)).trans (norm_le_pi_norm z j)
+
+/-- Restriction of a complex action map to real input and output coordinates. -/
+def realRestriction {n} (f : ComplexSpace n → ComplexSpace n) : RealSpace n → RealSpace n :=
+  realPart ∘ f ∘ complexify
+
+/-- The real continuous linear map induced by restricting a complex derivative. -/
+def realDerivative {n} (L : ComplexSpace n →L[ℂ] ComplexSpace n) :
+    RealSpace n →L[ℝ] RealSpace n :=
+  (realPartCLM n).comp ((L.restrictScalars ℝ).comp (complexifyCLM n))
+
+theorem hasFDerivAt_realRestriction {n} {f : ComplexSpace n → ComplexSpace n}
+    {x : RealSpace n} (hf : DifferentiableAt ℂ f (complexify x)) :
+    HasFDerivAt (realRestriction f) (realDerivative (fderiv ℂ f (complexify x))) x := by
+  exact (realPartCLM n).hasFDerivAt.comp x
+    ((hf.hasFDerivAt.restrictScalars ℝ).comp x (complexifyCLM n).hasFDerivAt)
+
+theorem norm_realDerivative_le {n} (L : ComplexSpace n →L[ℂ] ComplexSpace n) :
+    ‖realDerivative L‖ ≤ ‖L‖ := by
+  apply ContinuousLinearMap.opNorm_le_bound _ (norm_nonneg L)
+  intro x
+  exact (norm_realPart_le _).trans (by simpa using L.le_opNorm (complexify x))
+
+theorem abs_det_le_pow_of_opNorm_le {n : ℕ} (L : RealSpace n →L[ℝ] RealSpace n)
+    {C : ℝ} (hC : 0 ≤ C) (hL : ‖L‖ ≤ C) : |(L : RealSpace n →ₗ[ℝ] RealSpace n).det| ≤ C ^ n := by
+  have him : L '' closedBall (0 : RealSpace n) 1 ⊆ closedBall 0 C := by
+    rintro y ⟨x, hx, rfl⟩
+    simp only [mem_closedBall, dist_zero_right] at hx ⊢
+    exact (L.le_opNorm x).trans ((mul_le_mul_of_nonneg_right hL (norm_nonneg x)).trans
+      (by simpa using mul_le_mul_of_nonneg_left hx hC))
+  have hm := measure_mono (μ := (volume : Measure (RealSpace n))) him
+  rw [Measure.addHaar_image_continuousLinearMap,
+    Real.volume_pi_closedBall _ (by norm_num : (0 : ℝ) ≤ 1),
+    Real.volume_pi_closedBall _ hC] at hm
+  simp only [Fintype.card_fin, mul_one] at hm
+  have ht := ENNReal.toReal_mono ENNReal.ofReal_ne_top hm
+  rw [ENNReal.toReal_mul, ENNReal.toReal_ofReal (abs_nonneg _),
+    ENNReal.toReal_ofReal (by positivity : (0 : ℝ) ≤ 2 ^ n),
+    ENNReal.toReal_ofReal (by positivity : (0 : ℝ) ≤ (2 * C) ^ n), mul_pow] at ht
+  exact (mul_le_mul_iff_left₀ (by positivity : (0 : ℝ) < 2 ^ n)).mp (by
+    simpa only [mul_comm] using ht)
+
+theorem real_image_measure_le {n} {f : RealSpace n → RealSpace n}
+    {s : Set (RealSpace n)} {C : ℝ} (hs : MeasurableSet s) (hC : 0 ≤ C)
+    (hf : ∀ x ∈ s, DifferentiableAt ℝ f x) (hd : ∀ x ∈ s, ‖fderiv ℝ f x‖ ≤ C) :
+    volume (f '' s) ≤ ENNReal.ofReal (C ^ n) * volume s := by
+  calc
+    _ ≤ ∫⁻ x in s, ENNReal.ofReal |(fderiv ℝ f x).toLinearMap.det| ∂volume :=
+      addHaar_image_le_lintegral_abs_det_fderiv volume hs
+        (fun x hx => (hf x hx).hasFDerivAt.hasFDerivWithinAt)
+    _ ≤ ∫⁻ _ in s, ENNReal.ofReal (C ^ n) ∂volume := by
+      apply setLIntegral_mono' hs
+      intro x hx
+      exact ENNReal.ofReal_le_ofReal (abs_det_le_pow_of_opNorm_le _ hC (hd x hx))
+    _ = _ := by simp
+
+end KamProject.Arnold1963
diff --git a/LeanPool/ArnoldKAM/Arnold1963/Geometry/SlabMeasure.lean b/LeanPool/ArnoldKAM/Arnold1963/Geometry/SlabMeasure.lean
new file mode 100644
index 0000000000..869dfc618d
--- /dev/null
+++ b/LeanPool/ArnoldKAM/Arnold1963/Geometry/SlabMeasure.lean
@@ -0,0 +1,182 @@
+/-
+Copyright (c) 2026 Bingqi Yu. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Bingqi Yu
+-/
+
+module
+
+public import LeanPool.ArnoldKAM.Arnold1963.Geometry.TypeD
+public import LeanPool.ArnoldKAM.Arnold1963.Geometry.PolydiscBoundary
+
+/-!
+Fubini slab estimates using a coordinate with nonzero covector coefficient. The argument
+retains the maximum norm and introduces no Euclidean norm comparison.
+-/
+
+@[expose] public section
+noncomputable section
+open Set MeasureTheory Function
+open scoped ENNReal NNReal
+namespace KamProject.Arnold1963
+
+private theorem volume_affine_strip {A B a : ℝ} (hA : A ≠ 0) :
+    volume {y : ℝ | |A * y + B| < a} = ENNReal.ofReal (2 * a / |A|) := by
+  have he : {y : ℝ | |A * y + B| < a} = Metric.ball (-B / A) (a / |A|) := by
+    ext y
+    rw [Metric.mem_ball, Real.dist_eq]
+    change |A * y + B| < a ↔ |y - -B / A| < a / |A|
+    have heq : A * y + B = A * (y - -B / A) := by field_simp; ring
+    rw [heq, abs_mul, lt_div_iff₀ (abs_pos.mpr hA), mul_comm]
+  rw [he, Real.volume_ball]
+  congr 1
+  ring
+
+theorem realLebesgue_le_box_of_fiber {n : ℕ} (c r : RealSpace n)
+    (hr : ∀ i, 0 < r i) (j : Fin n) {s : Set (RealSpace n)} (hs : MeasurableSet s)
+    (hsub : s ⊆ realSlice (realCenteredPolydisc c r)) {L : ℝ} (hL : 0 ≤ L)
+    (hfib : ∀ x : RealSpace n,
+      volume {y : ℝ | update x j y ∈ s} ≤ ENNReal.ofReal L) :
+    realLebesgue n s ≤ ENNReal.ofReal (L / (2 * r j)) *
+      realVolume (realCenteredPolydisc c r) := by
+  classical
+  let B := realSlice (realCenteredPolydisc c r)
+  let C := ENNReal.ofReal (L / (2 * r j))
+  have hB : MeasurableSet B :=
+    (isClosed_realSlice (isClosed_realCenteredPolydisc c r)).measurableSet
+  have hC : C ≠ ∞ := ENNReal.ofReal_ne_top
+  have hupdate (x : RealSpace n) : Measurable (fun y : ℝ => update x j y) :=
+    (continuous_const.update j continuous_id).measurable
+  have hm : (∫⁻ x, s.indicator 1 x ∂realLebesgue n) ≤
+      ∫⁻ x, C * B.indicator 1 x ∂realLebesgue n := by
+    apply lintegral_le_of_lmarginal_le {j} (measurable_one.indicator hs)
+      (measurable_const.mul (measurable_one.indicator hB))
+    rw [lmarginal_singleton, lmarginal_singleton]
+    intro x
+    change (∫⁻ y : ℝ, s.indicator (1 : RealSpace n → ℝ≥0∞) (update x j y)) ≤
+      ∫⁻ y : ℝ, C * B.indicator (1 : RealSpace n → ℝ≥0∞) (update x j y)
+    by_cases hx : ∀ i, i ≠ j → x i ∈ Icc (c i - r i) (c i + r i)
+    · have hb : (fun y : ℝ => B.indicator (1 : RealSpace n → ℝ≥0∞) (update x j y)) =
+          (Icc (c j - r j) (c j + r j)).indicator (1 : ℝ → ℝ≥0∞) := by
+        funext y
+        have he : update x j y ∈ B ↔ y ∈ Icc (c j - r j) (c j + r j) := by
+          dsimp [B]
+          rw [realSlice_realCenteredPolydisc, mem_univ_pi]
+          constructor
+          · intro h
+            simpa using h j
+          · intro hy i
+            by_cases hi : i = j
+            · subst i; simpa using hy
+            · simpa [update_of_ne hi] using hx i hi
+        simp only [indicator, he, Pi.one_apply]
+      rw [lintegral_const_mul' _ _ hC, hb, lintegral_indicator_one measurableSet_Icc,
+        Real.volume_Icc]
+      have he : C * ENNReal.ofReal (c j + r j - (c j - r j)) = ENNReal.ofReal L := by
+        dsimp [C]
+        rw [← ENNReal.ofReal_mul (div_nonneg hL (mul_nonneg (by norm_num) (hr j).le))]
+        congr 1
+        field_simp [ne_of_gt (hr j)]
+        ring
+      rw [he]
+      calc
+        _ = volume {y : ℝ | update x j y ∈ s} := by
+          change (∫⁻ y, ((fun y : ℝ => update x j y) ⁻¹' s).indicator 1 y) =
+            volume ((fun y : ℝ => update x j y) ⁻¹' s)
+          exact lintegral_indicator_one (hs.preimage (hupdate x))
+        _ ≤ _ := hfib x
+    · have hnot (y : ℝ) : update x j y ∉ B := by
+        intro hy
+        apply hx
+        intro i hi
+        dsimp [B] at hy
+        rw [realSlice_realCenteredPolydisc] at hy
+        simpa [update_of_ne hi] using (mem_univ_pi.mp hy) i
+      have hsnot (y : ℝ) : update x j y ∉ s := fun hy => hnot y (hsub hy)
+      simp only [indicator_of_notMem (hsnot _), lintegral_zero]
+      exact zero_le
+  rw [lintegral_indicator_one hs, lintegral_const_mul' _ _ hC,
+    lintegral_indicator_one hB] at hm
+  exact hm
+
+theorem polydisc_slab_coordinate_le {n : ℕ} (c r ℓ : RealSpace n)
+    (hr : ∀ i, 0 < r i) (j : Fin n) (hj : ℓ j ≠ 0) (b a : ℝ) (ha : 0 ≤ a) :
+    realVolume (realCenteredPolydisc c r ∩ complexSlab ℓ b a) ≤
+      ENNReal.ofReal (a / (|ℓ j| * r j)) * realVolume (realCenteredPolydisc c r) := by
+  classical
+  have hcont : Continuous (fun x : RealSpace n => ∑ i, ℓ i * x i) :=
+    continuous_finsetSum _ fun i _ => continuous_const.mul (continuous_apply i)
+  have he : realSlice (realCenteredPolydisc c r ∩ complexSlab ℓ b a) =
+      realSlice (realCenteredPolydisc c r) ∩ {x | |(∑ i, ℓ i * x i) - b| < a} := by
+    ext x
+    simp [realSlice, complexSlab, realCovectorPairing, complexify,
+      ← Complex.ofReal_mul, ← Complex.ofReal_sum, ← Complex.ofReal_sub]
+  have hm : MeasurableSet (realSlice (realCenteredPolydisc c r) ∩
+      {x : RealSpace n | |(∑ i, ℓ i * x i) - b| < a}) :=
+    (isClosed_realSlice (isClosed_realCenteredPolydisc c r)).measurableSet.inter
+      (isOpen_lt ((hcont.sub continuous_const).abs) continuous_const).measurableSet
+  have hfib (x : RealSpace n) : volume {y : ℝ | update x j y ∈
+      realSlice (realCenteredPolydisc c r) ∩ {x | |(∑ i, ℓ i * x i) - b| < a}} ≤
+      ENNReal.ofReal (2 * a / |ℓ j|) := by
+    have heq (y : ℝ) : (∑ i, ℓ i * update x j y i) - b =
+        ℓ j * y + ((∑ i ∈ Finset.univ.erase j, ℓ i * x i) - b) := by
+      rw [← Finset.sum_erase_add _ _ (Finset.mem_univ j)]
+      simp only [update_self]
+      rw [show (∑ i ∈ Finset.univ.erase j, ℓ i * update x j y i) =
+          ∑ i ∈ Finset.univ.erase j, ℓ i * x i from
+        Finset.sum_congr rfl (fun i hi => by rw [update_of_ne (Finset.ne_of_mem_erase hi)])]
+      ring
+    calc
+      _ ≤ volume {y : ℝ | |ℓ j * y + ((∑ i ∈ Finset.univ.erase j, ℓ i * x i) - b)| < a} :=
+        measure_mono fun y hy => by
+          change |ℓ j * y + ((∑ i ∈ Finset.univ.erase j, ℓ i * x i) - b)| < a
+          rw [← heq y]
+          exact hy.2
+      _ = _ := volume_affine_strip hj
+  have hh := realLebesgue_le_box_of_fiber c r hr j hm inter_subset_left
+    (div_nonneg (by positivity) (abs_nonneg _)) hfib
+  rw [realVolume, he]
+  have hc : (2 * a / |ℓ j|) / (2 * r j) = a / (|ℓ j| * r j) := by ring
+  simpa only [hc] using hh
+
+theorem realCenteredPolydisc_typeD {n : ℕ} (hn : 0 < n) (c r : RealSpace n)
+    (hr : ∀ j, 0 < r j) : TypeD (realCenteredPolydisc c r) (polydiscTypeConstant r) := by
+  classical
+  have hnR : (0 : ℝ) < n := by exact_mod_cast hn
+  let j₀ : Fin n := ⟨0, hn⟩
+  have hD : 0 < polydiscTypeConstant r :=
+    (inv_pos.mpr (hr j₀)).trans_le (Finset.single_le_sum
+      (fun i _ => inv_nonneg.mpr (hr i).le) (Finset.mem_univ j₀))
+  refine ⟨hD, isCompact_realCenteredPolydisc c r, ?_, polydisc_boundary_le c r hr, ?_⟩
+  · rw [realVolume_realCenteredPolydisc]
+    exact pos_iff_ne_zero.mpr (Finset.prod_ne_zero_iff.mpr fun j _ =>
+      (ENNReal.ofReal_pos.mpr (by linarith [hr j])).ne')
+  · intro ℓ b a hℓ ha
+    obtain ⟨j, _, hj⟩ := Finset.exists_max_image Finset.univ (fun i : Fin n => |ℓ i|)
+      ⟨j₀, Finset.mem_univ _⟩
+    have hmax : covectorLength ℓ ≤ n * |ℓ j| := by
+      calc
+        _ ≤ ∑ _i : Fin n, |ℓ j| := Finset.sum_le_sum fun i hi => hj i hi
+        _ = _ := by simp
+    have hjpos : 0 < |ℓ j| := by nlinarith
+    have hjne : ℓ j ≠ 0 := abs_pos.mp hjpos
+    have hrecip : 1 / |ℓ j| ≤ (n : ℝ) / covectorLength ℓ :=
+      (div_le_div_iff₀ hjpos hℓ).mpr (by simpa only [one_mul] using hmax)
+    have hjD : (r j)⁻¹ ≤ polydiscTypeConstant r :=
+      Finset.single_le_sum (fun i _ => inv_nonneg.mpr (hr i).le) (Finset.mem_univ j)
+    apply (polydisc_slab_coordinate_le c r ℓ hr j hjne b a ha).trans
+    apply mul_le_mul' (ENNReal.ofReal_le_ofReal _) le_rfl
+    calc
+      a / (|ℓ j| * r j) = (a * (1 / |ℓ j|)) * (r j)⁻¹ := by ring
+      _ ≤ (a * ((n : ℝ) / covectorLength ℓ)) * polydiscTypeConstant r :=
+        mul_le_mul (mul_le_mul_of_nonneg_left hrecip ha) hjD
+          (inv_nonneg.mpr (hr j).le) (by positivity)
+      _ ≤ polydiscTypeConstant r * n * (2 * a / covectorLength ℓ) := by
+        have hh : 0 ≤ (a * ((n : ℝ) / covectorLength ℓ)) * polydiscTypeConstant r :=
+          mul_nonneg (by positivity) hD.le
+        have he : polydiscTypeConstant r * n * (2 * a / covectorLength ℓ) =
+            2 * ((a * ((n : ℝ) / covectorLength ℓ)) * polydiscTypeConstant r) := by ring
+        rw [he]
+        linarith
+
+end KamProject.Arnold1963
diff --git a/LeanPool/ArnoldKAM/Arnold1963/Geometry/TubeLayer.lean b/LeanPool/ArnoldKAM/Arnold1963/Geometry/TubeLayer.lean
new file mode 100644
index 0000000000..774a55f3fb
--- /dev/null
+++ b/LeanPool/ArnoldKAM/Arnold1963/Geometry/TubeLayer.lean
@@ -0,0 +1,87 @@
+/-
+Copyright (c) 2026 Bingqi Yu. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Bingqi Yu
+-/
+
+module
+
+public import LeanPool.ArnoldKAM.Arnold1963.Geometry.CovectorTube
+
+/-!
+Two-sided tube boundary layers. Right limits extend open-slab bounds to closed slabs.
+-/
+
+@[expose] public section
+noncomputable section
+open Set Metric MeasureTheory Filter
+open scoped NNReal ENNReal Topology
+namespace KamProject.Arnold1963
+
+theorem TypeD.realVolume_ne_top {n} {Ω : Set (ComplexSpace n)} {D : ℝ}
+    (h : TypeD Ω D) : realVolume Ω ≠ ∞ := by
+  change volume (realSlice Ω) ≠ ∞
+  exact (isCompact_realSlice h.compact).measure_lt_top.ne
+
+theorem TypeD.closed_slab {n} {Ω : Set (ComplexSpace n)} {D : ℝ} (h : TypeD Ω D)
+    (ℓ : RealSpace n) (c a : ℝ) (hℓ : 0 < covectorLength ℓ) (ha : 0 ≤ a) :
+    realVolume (Ω ∩ {z | ‖realCovectorPairing ℓ z - (c : ℂ)‖ ≤ a}) ≤
+      ENNReal.ofReal (D * n * (2 * a / covectorLength ℓ)) * realVolume Ω := by
+  have ht : Tendsto (fun t : ℝ => ENNReal.ofReal (D * n * (2 * t / covectorLength ℓ)) *
+      realVolume Ω) (𝓝[>] a)
+      (𝓝 (ENNReal.ofReal (D * n * (2 * a / covectorLength ℓ)) * realVolume Ω)) := by
+    apply ENNReal.Tendsto.mul_const _ (Or.inr h.realVolume_ne_top)
+    exact (ENNReal.continuous_ofReal.comp (by fun_prop)).continuousAt.tendsto.mono_left
+      nhdsWithin_le_nhds
+  apply ge_of_tendsto ht
+  filter_upwards [self_mem_nhdsWithin] with t ht
+  exact (realVolume_mono (inter_subset_inter_right Ω (fun z hx =>
+    (show ‖realCovectorPairing ℓ z - (c : ℂ)‖ ≤ a from hx).trans_lt ht))).trans
+    (h.slab ℓ c t hℓ (ha.trans ht.le))
+
+theorem realCovectorPairing_complexify {n} (ℓ x : RealSpace n) :
+    realCovectorPairing ℓ (complexify x) = ((∑ j, ℓ j * x j : ℝ) : ℂ) := by
+  simp [realCovectorPairing, complexify]
+
+theorem TypeD.tube_layer {n} {Ω : Set (ComplexSpace n)} {D : ℝ} (h : TypeD Ω D)
+    (ℓ : RealSpace n) (c a₁ a₂ : ℝ) (hℓ : 0 < covectorLength ℓ)
+    (_ha₁ : 0 ≤ a₁) (haa : a₁ ≤ a₂) :
+    realVolume (Ω ∩ {z | a₁ ≤ ‖realCovectorPairing ℓ z - (c : ℂ)‖ ∧
+      ‖realCovectorPairing ℓ z - (c : ℂ)‖ < a₂}) ≤
+      ENNReal.ofReal (2 * D * n * ((a₂ - a₁) / covectorLength ℓ)) * realVolume Ω := by
+  let Spos := Ω ∩ {z | ‖realCovectorPairing ℓ z - ((c + (a₁ + a₂) / 2 : ℝ) : ℂ)‖ ≤ (a₂ - a₁) / 2}
+  let Sneg := Ω ∩ {z | ‖realCovectorPairing ℓ z - ((c - (a₁ + a₂) / 2 : ℝ) : ℂ)‖ ≤ (a₂ - a₁) / 2}
+  have hsub : realSlice (Ω ∩ {z | a₁ ≤ ‖realCovectorPairing ℓ z - (c : ℂ)‖ ∧
+      ‖realCovectorPairing ℓ z - (c : ℂ)‖ < a₂}) ⊆ realSlice Spos ∪ realSlice Sneg := by
+    intro x ⟨hxΩ, hlo, hhi⟩
+    simp only [realCovectorPairing_complexify, ← Complex.ofReal_sub, Complex.norm_real,
+      Real.norm_eq_abs] at hlo hhi
+    by_cases hx : 0 ≤ (∑ j, ℓ j * x j) - c
+    · left
+      refine ⟨hxΩ, ?_⟩
+      change ‖realCovectorPairing ℓ (complexify x) - _‖ ≤ _
+      simp only [realCovectorPairing_complexify, ← Complex.ofReal_sub, Complex.norm_real,
+        Real.norm_eq_abs, abs_le]
+      rw [abs_of_nonneg hx] at hlo hhi
+      constructor <;> linarith
+    · right
+      refine ⟨hxΩ, ?_⟩
+      change ‖realCovectorPairing ℓ (complexify x) - _‖ ≤ _
+      simp only [realCovectorPairing_complexify, ← Complex.ofReal_sub, Complex.norm_real,
+        Real.norm_eq_abs, abs_le]
+      rw [abs_of_neg (lt_of_not_ge hx)] at hlo hhi
+      constructor <;> linarith
+  have hw : 0 ≤ (a₂ - a₁) / 2 := by linarith
+  let C := D * n * (2 * ((a₂ - a₁) / 2) / covectorLength ℓ)
+  have hC : 0 ≤ C := by dsimp [C]; positivity [h.constant_pos]
+  calc
+    _ ≤ realVolume Spos + realVolume Sneg :=
+      (measure_mono hsub).trans (measure_union_le _ _)
+    _ ≤ ENNReal.ofReal C * realVolume Ω + ENNReal.ofReal C * realVolume Ω :=
+      add_le_add (h.closed_slab ℓ _ _ hℓ hw) (h.closed_slab ℓ _ _ hℓ hw)
+    _ = _ := by
+      rw [← add_mul, ← ENNReal.ofReal_add hC hC]
+      have he : C + C = 2 * D * n * ((a₂ - a₁) / covectorLength ℓ) := by dsimp [C]; ring
+      rw [he]
+
+end KamProject.Arnold1963
diff --git a/LeanPool/ArnoldKAM/Arnold1963/Geometry/TypeD.lean b/LeanPool/ArnoldKAM/Arnold1963/Geometry/TypeD.lean
new file mode 100644
index 0000000000..31c3233809
--- /dev/null
+++ b/LeanPool/ArnoldKAM/Arnold1963/Geometry/TypeD.lean
@@ -0,0 +1,52 @@
+/-
+Copyright (c) 2026 Bingqi Yu. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Bingqi Yu
+-/
+
+module
+
+public import LeanPool.ArnoldKAM.Arnold1963.Geometry.Polydisc
+
+/-!
+Geometric domain conditions for boundary layers and slabs. These conditions concern the
+initial frequency domain and are proved for the polydiscs used in localization.
+-/
+
+@[expose] public section
+noncomputable section
+open Set MeasureTheory
+open scoped NNReal ENNReal
+namespace KamProject.Arnold1963
+
+/-- The complex-linear pairing with a real coordinate covector. -/
+def realCovectorPairing {n : ℕ} (ℓ : RealSpace n) (z : ComplexSpace n) : ℂ :=
+  ∑ j, (ℓ j : ℂ) * z j
+
+/-- The sum of absolute covector coordinates controlling its pairing norm. -/
+def covectorLength {n : ℕ} (ℓ : RealSpace n) : ℝ := ∑ j, |ℓ j|
+
+/-- The open complex slab cut out by a real covector and scalar center. -/
+def complexSlab {n : ℕ} (ℓ : RealSpace n) (c a : ℝ) : Set (ComplexSpace n) :=
+  {z | ‖realCovectorPairing ℓ z - (c : ℂ)‖ < a}
+
+/-- Compact positive-volume frequency domains with quantitative boundary and slab-loss bounds. -/
+structure TypeD {n : ℕ} (Ω : Set (ComplexSpace n)) (D : ℝ) : Prop where
+  constant_pos : 0 < D
+  compact : IsCompact Ω
+  volume_pos : 0 < realVolume Ω
+  boundary : ∀ d₁ d₂ : ℝ≥0, d₁ ≤ d₂ →
+    realVolume (erosion Ω d₁ \ erosion Ω d₂) ≤
+      ENNReal.ofReal (D * ((d₂ : ℝ) - d₁)) * realVolume Ω
+  slab : ∀ (ℓ : RealSpace n) (c a : ℝ), 0 < covectorLength ℓ → 0 ≤ a →
+    realVolume (Ω ∩ complexSlab ℓ c a) ≤
+      ENNReal.ofReal (D * n * (2 * a / covectorLength ℓ)) * realVolume Ω
+
+theorem realVolume_biUnion_finset_le {n : ℕ} {ι : Type*} (s : Finset ι)
+    (f : ι → Set (ComplexSpace n)) :
+    realVolume (⋃ i ∈ s, f i) ≤ ∑ i ∈ s, realVolume (f i) := by
+  unfold realVolume realSlice
+  simp only [preimage_iUnion]
+  exact measure_biUnion_finset_le s _
+
+end KamProject.Arnold1963
diff --git a/LeanPool/ArnoldKAM/Arnold1963/Iteration/Construction.lean b/LeanPool/ArnoldKAM/Arnold1963/Iteration/Construction.lean
new file mode 100644
index 0000000000..e0f2eefe20
--- /dev/null
+++ b/LeanPool/ArnoldKAM/Arnold1963/Iteration/Construction.lean
@@ -0,0 +1,137 @@
+/-
+Copyright (c) 2026 Bingqi Yu. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Bingqi Yu
+-/
+
+module
+
+public import LeanPool.ArnoldKAM.Arnold1963.Iteration.State
+
+/-!
+Construct the Hamiltonian states and cumulative transformations recursively from initial data.
+Stage existence and the Hamiltonian identities are proved by the construction.
+-/
+
+@[expose] public section
+noncomputable section
+open Set
+open scoped NNReal ENNReal
+namespace KamProject.Arnold1963.Iteration
+
+/-- Analytic Hamiltonian, perturbation and frequency-chart data initiating the KAM iteration. -/
+structure InitialData (n : ℕ) (Ω₀ : Set (ComplexSpace n)) (δ₁ θ₀ Θ₀ ρ₀ : ℝ≥0)
+    (D : ℝ) where
+  /-- The initial complex action domain. -/
+  domain : Set (ComplexSpace n)
+  /-- The initial integrable Hamiltonian depending only on action coordinates. -/
+  integrable : ComplexSpace n → ℂ
+  /-- The initial analytic perturbation on the prescribed phase domain. -/
+  perturbation : AnalyticPhaseFunction n domain ρ₀
+  /-- The inverse of the initial action-frequency chart. -/
+  inverseFrequency : ComplexSpace n → ComplexSpace n
+  chart : AnalyticFrequencyChart (actionFrequency integrable) inverseFrequency domain Ω₀
+  analytic : AnalyticOnNhd ℂ integrable domain
+  conj : ∀ p ∈ domain, integrable (conjVec p) = star (integrable p)
+  lower : ∀ p ∈ domain, ∀ v, (θ₀ : ℝ) * ‖v‖ ≤ ‖fderiv ℂ (actionFrequency integrable) p v‖
+  upper : ∀ p ∈ domain, ‖fderiv ℂ (actionFrequency integrable) p‖ ≤ Θ₀
+  bound : perturbation.uniformNorm ≤ Iteration.perturbation n δ₁ 0
+  typeD : TypeD Ω₀ D
+
+namespace InitialData
+variable {n : ℕ} {Ω₀ : Set (ComplexSpace n)} {δ₁ θ₀ Θ₀ ρ₀ : ℝ≥0} {κ D : ℝ}
+  (b : InitialParameters n δ₁ θ₀ Θ₀ ρ₀ κ D)
+  (h : InitialData n Ω₀ δ₁ θ₀ Θ₀ ρ₀ D)
+
+theorem volume_pos : 0 < realVolume h.domain := by
+  by_contra hn
+  have hz : realVolume h.domain = 0 := le_antisymm (le_of_not_gt hn) zero_le
+  have hh := h.chart.realVolume_image_le Θ₀.coe_nonneg h.upper
+  rw [hz, mul_zero] at hh
+  exact not_lt_of_ge hh h.typeD.volume_pos
+
+theorem volume_finite : realVolume h.domain ≠ ⊤ := by
+  change MeasureTheory.volume (realSlice h.domain) ≠ ⊤
+  exact (isCompact_realSlice h.chart.compact).measure_ne_top
+
+/-- The initial KAM state assembled from the Hamiltonian and parameter data. -/
+def initialState : State n Ω₀ δ₁ θ₀ Θ₀ ρ₀ κ 0 where
+  domain := h.domain
+  ar := ResonanceDomainState.initial n (κ * (δ₁ : ℝ))
+  integrable := h.integrable
+  perturbation := h.perturbation.restrict (Subset.refl _) (by simp) h.chart.domain_conj
+  inverseFrequency := h.inverseFrequency
+  input := {
+    chart := by
+      dsimp only [previousCutoff]
+      rw [ResonanceDomainState.initial_domain]
+      exact h.chart
+    analytic := h.analytic
+    conj := h.conj
+    lower := by simpa only [lower_zero] using h.lower
+    upper := by simpa only [upper_zero] using h.upper
+    perturbation := (h.perturbation.uniformNorm_restrict_le _ _ _).trans h.bound
+    budget := b.parameters 0 }
+
+/-- The recursively constructed KAM state at each iteration stage. -/
+def state : (s : ℕ) → State n Ω₀ δ₁ θ₀ Θ₀ ρ₀ κ s
+  | 0 => h.initialState b
+  | s + 1 => (state s).next b
+
+@[simp] theorem state_zero : h.state b 0 = h.initialState b := rfl
+theorem state_succ (s : ℕ) : h.state b (s + 1) = (h.state b s).next b := rfl
+
+/-- The action domain retained at a given iteration stage. -/
+def actionDomain (s : ℕ) : Set (ComplexSpace n) := (h.state b s).domain
+/-- The phase domain retained at a given iteration stage. -/
+def phase (s : ℕ) : Set (ComplexPhaseSpace n) := phaseDomain (h.actionDomain b s) (width n ρ₀ δ₁ s)
+/-- The sum of the integrable Hamiltonian and perturbation at a given stage. -/
+def hamiltonian (s : ℕ) (z : ComplexPhaseSpace n) : ℂ :=
+  (h.state b s).integrable z.1 + (h.state b s).perturbation.toFun z
+
+/-- The canonical transformation carrying the next phase domain into the current one. -/
+def transformation (s : ℕ) : AnalyticCanonicalTransformation
+    (h.phase b (s + 1)) (h.phase b s) (beta δ₁ s) :=
+  (h.state b s).step.transformation.restrict (by
+    simp only [phase, actionDomain, state_succ, State.next, width_succ]
+    exact Subset.refl _)
+
+theorem domain_zero : h.actionDomain b 0 = h.domain := rfl
+
+theorem domain_step_subset (s : ℕ) :
+    h.actionDomain b (s + 1) ⊆ erosion (h.actionDomain b s) (beta δ₁ s) :=
+  (h.state b s).next_domain_subset b
+
+theorem domain_antitone : Antitone (h.actionDomain b) :=
+  antitone_nat_of_succ_le (fun s => (h.domain_step_subset b s).trans (erosion_subset _ _))
+
+theorem domain_compact (s : ℕ) : IsCompact (h.actionDomain b s) := (h.state b s).input.chart.compact
+
+theorem perturbation_bound (s : ℕ) :
+    (h.state b (s + 1)).perturbation.uniformNorm < Iteration.perturbation n δ₁ (s + 1) :=
+  (h.state b s).nextPerturbation_bound b
+
+theorem step_identity (s : ℕ) (z : ComplexPhaseSpace n) :
+    h.hamiltonian b s ((h.transformation b s).toFun z) = h.hamiltonian b (s + 1) z := by
+  exact (h.state b s).next_identity b z
+
+/-- The cumulative composition carrying an iteration stage back to the original coordinates. -/
+def cumulative : ℕ → ComplexPhaseSpace n → ComplexPhaseSpace n
+  | 0 => id
+  | s + 1 => cumulative s ∘ (h.transformation b s).toFun
+
+theorem cumulative_maps (s : ℕ) : MapsTo (h.cumulative b s) (h.phase b s) (h.phase b 0) := by
+  induction s with
+  | zero => exact fun _ hx => hx
+  | succ s ih => exact ih.comp (h.transformation b s).mapsTo
+
+theorem cumulative_identity (s : ℕ) (z : ComplexPhaseSpace n) :
+    h.hamiltonian b 0 (h.cumulative b s z) = h.hamiltonian b s z := by
+  induction s generalizing z with
+  | zero => rfl
+  | succ s ih =>
+    change h.hamiltonian b 0 (h.cumulative b s ((h.transformation b s).toFun z)) = _
+    rw [ih, h.step_identity]
+
+end InitialData
+end KamProject.Arnold1963.Iteration
diff --git a/LeanPool/ArnoldKAM/Arnold1963/Iteration/Cutoff.lean b/LeanPool/ArnoldKAM/Arnold1963/Iteration/Cutoff.lean
new file mode 100644
index 0000000000..a7e63fea73
--- /dev/null
+++ b/LeanPool/ArnoldKAM/Arnold1963/Iteration/Cutoff.lean
@@ -0,0 +1,94 @@
+/-
+Copyright (c) 2026 Bingqi Yu. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Bingqi Yu
+-/
+
+module
+
+public import LeanPool.ArnoldKAM.Arnold1963.Iteration.InitialParameters
+
+/-!
+Strictly increasing Fourier cutoffs from the actual perturbation and angle-loss sequences.
+-/
+
+@[expose] public section
+noncomputable section
+open scoped NNReal
+namespace KamProject.Arnold1963.Iteration
+
+/-- The Fourier cutoff selected from the stage's strip loss and perturbation bound. -/
+def cutoff (n : ℕ) (δ₁ : ℝ≥0) (s : ℕ) : ℝ :=
+  fundamentalCutoff (gamma n δ₁ s) (2 * perturbation n δ₁ s)
+
+/-- The preceding Fourier cutoff, initialized to one before the first step. -/
+def previousCutoff (n : ℕ) (δ₁ : ℝ≥0) : ℕ → ℝ
+  | 0 => 1
+  | s + 1 => cutoff n δ₁ s
+
+namespace InitialParameters
+variable {n : ℕ} {δ₁ θ₀ Θ₀ ρ₀ : ℝ≥0} {κ D : ℝ}
+  (b : InitialParameters n δ₁ θ₀ Θ₀ ρ₀ κ D)
+include b
+
+theorem perturbation_step_pos (s : ℕ) : 0 < perturbation n δ₁ s :=
+  pow_pos (b.delta_step_pos s) _
+
+theorem perturbation_le_delta (s : ℕ) : perturbation n δ₁ s ≤ delta δ₁ s := by
+  have hd : (delta δ₁ s : ℝ) ≤ 1 := (b.delta_step_le s).trans b.delta_one.le
+  simpa only [perturbation, pow_one] using pow_le_pow_of_le_one
+    (delta δ₁ s).coe_nonneg hd (show 1 ≤ iterationExponent n by unfold iterationExponent; omega)
+
+theorem cutoff_numerator_gt_half (s : ℕ) :
+    1 / 2 < Real.log (1 / (2 * perturbation n δ₁ s)) := by
+  have hM := b.perturbation_step_pos s
+  have hM4 : perturbation n δ₁ s < 1 / 4 :=
+    (b.perturbation_le_delta s).trans_lt ((b.delta_step_le s).trans_lt b.delta_quarter)
+  have hi : (2 : ℝ) < 1 / (2 * perturbation n δ₁ s) :=
+    (lt_div_iff₀ (by positivity)).mpr (by linarith)
+  have hl : (1 / 2 : ℝ) ≤ Real.log 2 := by
+    have hh := Real.one_sub_inv_le_log_of_pos (by norm_num : (0 : ℝ) < 2)
+    norm_num at hh
+    linarith
+  exact hl.trans_lt (Real.log_lt_log (by norm_num) hi)
+
+theorem cutoff_gt_one (s : ℕ) : 1 < cutoff n δ₁ s := by
+  apply (lt_div_iff₀ (show (0 : ℝ) < gamma n δ₁ s from b.gamma_step_pos s)).mpr
+  have hg := b.gamma_step_quarter s
+  have hl := b.cutoff_numerator_gt_half s
+  linarith
+
+theorem cutoff_strictMono : StrictMono (cutoff n δ₁) := by
+  intro s t hst
+  have hd := b.delta_strictAnti hst
+  have hm : perturbation n δ₁ t < perturbation n δ₁ s :=
+    pow_lt_pow_left₀ (show (delta δ₁ t : ℝ) < delta δ₁ s from hd)
+      (delta δ₁ t).coe_nonneg (by unfold iterationExponent; omega)
+  have hMs := b.perturbation_step_pos s
+  have hMt := b.perturbation_step_pos t
+  have hl : Real.log (1 / (2 * perturbation n δ₁ s)) <
+      Real.log (1 / (2 * perturbation n δ₁ t)) := by
+    apply Real.log_lt_log (by positivity)
+    exact one_div_lt_one_div_of_lt (by positivity) (by linarith)
+  have hg : (gamma n δ₁ t : ℝ) ≤ gamma n δ₁ s := by
+    simp only [gamma_eq, NNReal.coe_rpow]
+    exact Real.rpow_le_rpow (delta δ₁ t).coe_nonneg hd.le (by positivity)
+  have hgp : (0 : ℝ) < gamma n δ₁ t := b.gamma_step_pos t
+  exact (div_lt_div_of_pos_right hl (b.gamma_step_pos s)).trans_le
+    (div_le_div_of_nonneg_left (by linarith [b.cutoff_numerator_gt_half t]) hgp hg)
+
+theorem previousCutoff_strictMono : StrictMono (previousCutoff n δ₁) := by
+  apply strictMono_nat_of_lt_succ
+  intro s
+  cases s with
+  | zero => exact b.cutoff_gt_one 0
+  | succ s => exact b.cutoff_strictMono (Nat.lt_succ_self s)
+
+theorem previousCutoff_ge_one (s : ℕ) : 1 ≤ previousCutoff n δ₁ s :=
+  b.previousCutoff_strictMono.monotone (Nat.zero_le s)
+
+theorem cutoff_step_le (s : ℕ) : previousCutoff n δ₁ s ≤ cutoff n δ₁ s :=
+  (b.previousCutoff_strictMono (Nat.lt_succ_self s)).le
+
+end InitialParameters
+end KamProject.Arnold1963.Iteration
diff --git a/LeanPool/ArnoldKAM/Arnold1963/Iteration/CutoffBudget.lean b/LeanPool/ArnoldKAM/Arnold1963/Iteration/CutoffBudget.lean
new file mode 100644
index 0000000000..5f4a83c172
--- /dev/null
+++ b/LeanPool/ArnoldKAM/Arnold1963/Iteration/CutoffBudget.lean
@@ -0,0 +1,105 @@
+/-
+Copyright (c) 2026 Bingqi Yu. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Bingqi Yu
+-/
+
+module
+
+public import LeanPool.ArnoldKAM.Arnold1963.Iteration.Cutoff
+
+/-!
+Uniform estimates for cutoff growth relative to decay of the small parameter.
+-/
+
+@[expose] public section
+noncomputable section
+open scoped NNReal
+namespace KamProject.Arnold1963.Iteration
+
+/-- The dimension-dependent coefficient used to bound the iteration's Fourier cutoffs. -/
+def cutoffConstant (n : ℕ) : ℝ := 4 * n * (iterationExponent n + 1) / Real.exp 1
+
+namespace InitialParameters
+variable {n : ℕ} {δ₁ θ₀ Θ₀ ρ₀ : ℝ≥0} {κ D : ℝ}
+  (b : InitialParameters n δ₁ θ₀ Θ₀ ρ₀ κ D)
+include b
+
+theorem cutoff_bound (s : ℕ) :
+    cutoff n δ₁ s < cutoffConstant n / (gamma n δ₁ s : ℝ) ^ 2 := by
+  have hd : (0 : ℝ) < delta δ₁ s := b.delta_step_pos s
+  have hd1 : (delta δ₁ s : ℝ) < 1 := (b.delta_step_le s).trans_lt b.delta_one
+  have hg : (0 : ℝ) < gamma n δ₁ s := b.gamma_step_pos s
+  have hn : (0 : ℝ) < n := by exact_mod_cast b.dimension_pos
+  have hL : 0 < Real.log (1 / (delta δ₁ s : ℝ)) :=
+    Real.log_pos ((one_lt_div hd).mpr hd1)
+  rw [one_div, Real.log_inv] at hL
+  have hnum : Real.log (1 / (2 * perturbation n δ₁ s)) <
+      (iterationExponent n + 1 : ℝ) * Real.log (1 / (delta δ₁ s : ℝ)) := by
+    have hlog2 := Real.log_pos (by norm_num : (1 : ℝ) < 2)
+    simp only [perturbation, one_div, Real.log_inv,
+      Real.log_mul (by norm_num : (2 : ℝ) ≠ 0) (pow_ne_zero _ hd.ne'), Real.log_pow]
+    nlinarith
+  have hlog : Real.log (1 / (delta δ₁ s : ℝ)) ≤ (4 * n / Real.exp 1) /
+      (gamma n δ₁ s : ℝ) := by
+    have hh := log_inv_le_rpow hd (show (0 : ℝ) < 4 * n by positivity)
+    simpa only [gamma_eq, NNReal.coe_rpow, Real.rpow_neg hd.le, div_eq_mul_inv] using hh
+  calc
+    cutoff n δ₁ s <
+        ((iterationExponent n + 1 : ℝ) * Real.log (1 / (delta δ₁ s : ℝ))) /
+          (gamma n δ₁ s : ℝ) := div_lt_div_of_pos_right hnum hg
+    _ ≤ ((iterationExponent n + 1 : ℝ) * ((4 * n / Real.exp 1) /
+          (gamma n δ₁ s : ℝ))) / (gamma n δ₁ s : ℝ) :=
+      div_le_div_of_nonneg_right (mul_le_mul_of_nonneg_left hlog (by positivity)) hg.le
+    _ = _ := by unfold cutoffConstant; ring
+
+theorem delta_cutoffConstant_small (s : ℕ) :
+    (delta δ₁ s : ℝ) * cutoffConstant n ^ (2 * n) < 1 := by
+  have hn : (0 : ℝ) < n := by exact_mod_cast b.dimension_pos
+  have hden : 0 < (32 * (n : ℝ) ^ 2 + 100 * n) ^ (2 * n) := by positivity
+  have hd := ((show (delta δ₁ s : ℝ) ≤ δ₁ from b.delta_step_le s).trans_lt
+    (threshold5_bounds b.small).2.2.1).trans_le (min_le_left _ _)
+  change (delta δ₁ s : ℝ) < Real.exp (2 * n) /
+    (32 * (n : ℝ) ^ 2 + 100 * n) ^ (2 * n) at hd
+  have he : Real.exp (2 * (n : ℝ)) = Real.exp 1 ^ (2 * n) := by
+    simpa only [Nat.cast_mul, Nat.cast_ofNat, mul_one] using Real.exp_nat_mul 1 (2 * n)
+  rw [he] at hd
+  have hh := (lt_div_iff₀ hden).mp hd
+  have hc : cutoffConstant n = (32 * (n : ℝ) ^ 2 + 100 * n) / Real.exp 1 := by
+    unfold cutoffConstant iterationExponent
+    push_cast
+    ring
+  rw [hc, div_pow, ← mul_div_assoc]
+  exact (div_lt_one (by positivity)).mpr hh
+
+theorem cutoff_budget (s : ℕ) : (delta δ₁ s : ℝ) * cutoff n δ₁ s ^ n < 1 := by
+  have hg : (0 : ℝ) < gamma n δ₁ s := b.gamma_step_pos s
+  have hd : (0 : ℝ) < delta δ₁ s := b.delta_step_pos s
+  have hn := b.dimension_pos
+  have hN : 0 < cutoff n δ₁ s := zero_lt_one.trans (b.cutoff_gt_one s)
+  have hc : 0 < cutoffConstant n := by
+    have hn' : (0 : ℝ) < n := by exact_mod_cast hn
+    unfold cutoffConstant
+    positivity
+  have hp : (gamma n δ₁ s : ℝ) ^ (4 * n) = delta δ₁ s := by
+    exact_mod_cast gamma_pow hn δ₁ s
+  have hbound := mul_lt_mul_of_pos_left
+    (pow_lt_pow_left₀ (b.cutoff_bound s) hN.le hn.ne') hd
+  have he : (delta δ₁ s : ℝ) *
+      (cutoffConstant n / (gamma n δ₁ s : ℝ) ^ 2) ^ n =
+        (gamma n δ₁ s : ℝ) ^ (2 * n) * cutoffConstant n ^ n := by
+    rw [← hp, div_pow, ← pow_mul, show 4 * n = 2 * n + 2 * n by omega, pow_add]
+    field_simp
+  rw [he] at hbound
+  have hsq : ((gamma n δ₁ s : ℝ) ^ (2 * n) * cutoffConstant n ^ n) ^ 2 < 1 := by
+    have heq : ((gamma n δ₁ s : ℝ) ^ (2 * n) * cutoffConstant n ^ n) ^ 2 =
+        (delta δ₁ s : ℝ) * cutoffConstant n ^ (2 * n) := by
+      rw [mul_pow, ← pow_mul, ← pow_mul]
+      rw [show 2 * n * 2 = 4 * n by omega, show n * 2 = 2 * n by omega, hp]
+    rw [heq]
+    exact b.delta_cutoffConstant_small s
+  have hh : (gamma n δ₁ s : ℝ) ^ (2 * n) * cutoffConstant n ^ n < 1 := by nlinarith
+  exact hbound.trans hh
+
+end InitialParameters
+end KamProject.Arnold1963.Iteration
diff --git a/LeanPool/ArnoldKAM/Arnold1963/Iteration/DerivativeBudget.lean b/LeanPool/ArnoldKAM/Arnold1963/Iteration/DerivativeBudget.lean
new file mode 100644
index 0000000000..62bc8b9404
--- /dev/null
+++ b/LeanPool/ArnoldKAM/Arnold1963/Iteration/DerivativeBudget.lean
@@ -0,0 +1,74 @@
+/-
+Copyright (c) 2026 Bingqi Yu. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Bingqi Yu
+-/
+
+module
+
+public import LeanPool.ArnoldKAM.Arnold1963.Iteration.NumericalConditions
+
+/-!
+First and second derivative budgets for the next perturbation.
+-/
+
+@[expose] public section
+noncomputable section
+open scoped NNReal
+namespace KamProject.Arnold1963.Iteration.InitialParameters
+variable {n : ℕ} {δ₁ θ₀ Θ₀ ρ₀ : ℝ≥0} {κ D : ℝ}
+  (b : InitialParameters n δ₁ θ₀ Θ₀ ρ₀ κ D)
+include b
+
+theorem next_perturbation_power (s : ℕ) :
+    perturbation n δ₁ (s + 1) = (delta δ₁ s : ℝ) ^ (12 * n + 36) := by
+  have hh := remainder_eq_next b.delta_pos n s
+  change ((delta δ₁ s : ℝ) ^ iterationExponent n) ^ 2 /
+    ((delta δ₁ s : ℝ) ^ (2 * stepExponent n) * ((delta δ₁ s : ℝ) ^ 3) ^ 2) = _ at hh
+  rw [budget_step_eq (δ := (delta δ₁ s : ℝ)) (b.delta_step_pos s) n] at hh
+  exact hh.symm
+
+theorem beta_next_lower (s : ℕ) : (delta δ₁ s : ℝ) ^ 6 ≤ (beta δ₁ (s + 1) : ℝ) := by
+  have hd := b.delta_step_pos s
+  have hd1 := (b.delta_step_le s).trans b.delta_one.le
+  have hh : delta δ₁ s ^ (2 : ℝ) ≤ delta δ₁ s ^ (3 / 2 : ℝ) :=
+    NNReal.rpow_le_rpow_of_exponent_ge hd hd1 (by norm_num)
+  rw [NNReal.rpow_two] at hh
+  have hnext : delta δ₁ s ^ 2 ≤ delta δ₁ (s + 1) := by
+    simpa only [delta, decay_succ] using hh
+  have hp := pow_le_pow_left₀ (zero_le : (0 : ℝ≥0) ≤ delta δ₁ s ^ 2) hnext 3
+  have hh' : delta δ₁ s ^ 6 ≤ beta δ₁ (s + 1) := by
+    simpa only [← pow_mul, beta] using hp
+  exact_mod_cast hh'
+
+theorem first_derivative_budget (s : ℕ) :
+    perturbation n δ₁ (s + 1) / (beta δ₁ s : ℝ) <
+      (delta δ₁ s : ℝ) * beta δ₁ (s + 1) := by
+  have hd : (0 : ℝ) < delta δ₁ s := b.delta_step_pos s
+  have hd1 : (delta δ₁ s : ℝ) < 1 := (b.delta_step_le s).trans_lt b.delta_one
+  apply (div_lt_iff₀ (show (0 : ℝ) < beta δ₁ s by
+    change 0 < (delta δ₁ s : ℝ) ^ 3; positivity)).mpr
+  rw [b.next_perturbation_power]
+  calc
+    (delta δ₁ s : ℝ) ^ (12 * n + 36) < (delta δ₁ s : ℝ) ^ 10 :=
+      pow_lt_pow_right_of_lt_one₀ hd hd1 (by omega)
+    _ = (delta δ₁ s : ℝ) * (delta δ₁ s : ℝ) ^ 6 * (delta δ₁ s : ℝ) ^ 3 := by ring
+    _ ≤ _ := mul_le_mul_of_nonneg_right
+      (mul_le_mul_of_nonneg_left (b.beta_next_lower s) hd.le) (by positivity)
+
+theorem second_derivative_budget (s : ℕ) :
+    2 * perturbation n δ₁ (s + 1) / (beta δ₁ s : ℝ) ^ 2 < (delta δ₁ s : ℝ) := by
+  have hd : (0 : ℝ) < delta δ₁ s := b.delta_step_pos s
+  have hd4 : (delta δ₁ s : ℝ) < 1 / 4 := (b.delta_step_le s).trans_lt b.delta_quarter
+  have hd1 : (delta δ₁ s : ℝ) ≤ 1 := by linarith
+  apply (div_lt_iff₀ (show (0 : ℝ) < (beta δ₁ s : ℝ) ^ 2 by
+    change 0 < ((delta δ₁ s : ℝ) ^ 3) ^ 2; positivity)).mpr
+  rw [b.next_perturbation_power]
+  have hp := pow_le_pow_of_le_one hd.le hd1 (show 8 ≤ 12 * n + 36 by omega)
+  have hh := mul_lt_mul_of_pos_right (show 2 * (delta δ₁ s : ℝ) < 1 by linarith)
+    (pow_pos hd 7)
+  change 2 * (delta δ₁ s : ℝ) ^ (12 * n + 36) < (delta δ₁ s : ℝ) *
+    ((delta δ₁ s : ℝ) ^ 3) ^ 2
+  nlinarith only [hp, hh]
+
+end KamProject.Arnold1963.Iteration.InitialParameters
diff --git a/LeanPool/ArnoldKAM/Arnold1963/Iteration/Estimates.lean b/LeanPool/ArnoldKAM/Arnold1963/Iteration/Estimates.lean
new file mode 100644
index 0000000000..c5f55d6906
--- /dev/null
+++ b/LeanPool/ArnoldKAM/Arnold1963/Iteration/Estimates.lean
@@ -0,0 +1,102 @@
+/-
+Copyright (c) 2026 Bingqi Yu. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Bingqi Yu
+-/
+
+module
+
+public import LeanPool.ArnoldKAM.Arnold1963.Iteration.Construction
+public import LeanPool.ArnoldKAM.Arnold1963.Iteration.DerivativeBudget
+
+/-!
+Uniform domain buffers, transformation estimates, and derivative bounds for the actual states.
+-/
+
+@[expose] public section
+noncomputable section
+open Set
+open scoped NNReal ENNReal
+namespace KamProject.Arnold1963.Iteration.InitialData
+variable {n : ℕ} {Ω₀ : Set (ComplexSpace n)} {δ₁ θ₀ Θ₀ ρ₀ : ℝ≥0} {κ D : ℝ}
+  (b : InitialParameters n δ₁ θ₀ Θ₀ ρ₀ κ D)
+  (h : InitialData n Ω₀ δ₁ θ₀ Θ₀ ρ₀ D)
+
+theorem phase_succ (s : ℕ) : h.phase b (s + 1) =
+    phaseDomain (h.state b s).step.domain (width n ρ₀ δ₁ s - 3 * gamma n δ₁ s) := by
+  simp only [phase, actionDomain, state_succ, State.next, width_succ]
+
+theorem phase_buffer (s : ℕ) : h.phase b (s + 1) ⊆ erosion (h.phase b s) (beta δ₁ s) := by
+  rw [h.phase_succ b]
+  exact (h.state b s).step.phase_buffer
+
+theorem displacement_lt (s : ℕ) {z : ComplexPhaseSpace n} (hz : z ∈ h.phase b (s + 1)) :
+    ‖(h.transformation b s).toFun z - z‖ < (beta δ₁ s : ℝ) := by
+  rw [h.phase_succ b] at hz
+  exact (h.state b s).step.displacement_lt z hz
+
+theorem transformation_periodic (s : ℕ) {z : ComplexPhaseSpace n}
+    (hz : z ∈ h.phase b (s + 1)) (k : FourierIndex n) :
+    (h.transformation b s).toFun (phaseShift k z) =
+      phaseShift k ((h.transformation b s).toFun z) := by
+  rw [h.phase_succ b] at hz
+  exact (h.state b s).step.periodic z hz k
+
+theorem transformation_real (s : ℕ) {z : ComplexPhaseSpace n}
+    (hz : z ∈ h.phase b (s + 1)) :
+    (h.transformation b s).toFun (conjPhase z) =
+      conjPhase ((h.transformation b s).toFun z) := by
+  rw [h.phase_succ b] at hz
+  exact (h.state b s).step.conj_compatible z hz
+
+include b in
+theorem width_gt_third (s : ℕ) : (ρ₀ : ℝ) / 3 < (width n ρ₀ δ₁ s : ℝ) := by
+  have hh := (uniform_bounds_of_threshold b.dimension_pos b.lower_pos
+    (zero_lt_one.trans b.upper_gt_one) b.small s).2.2.1
+  have hr : (0 : ℝ) < ρ₀ := b.width_pos
+  linarith
+
+theorem remainder_derivative (s : ℕ) {z : ComplexPhaseSpace n}
+    (hz : z ∈ h.phase b (s + 1)) :
+    ‖fderiv ℂ (h.state b (s + 1)).perturbation.toFun z‖ <
+      (delta δ₁ s : ℝ) * beta δ₁ (s + 1) := by
+  rw [h.phase_succ b] at hz
+  have hh := (h.state b s).step.derivative z hz
+  rw [remainder_eq_next_parameter b.delta_pos] at hh
+  exact hh.trans (b.first_derivative_budget s)
+
+theorem remainder_coordinate_derivative (s : ℕ) {z : ComplexPhaseSpace n}
+    (hz : z ∈ h.phase b (s + 1)) (j : Fin n ⊕ Fin n) :
+    ‖fderiv ℂ (h.state b (s + 1)).perturbation.toFun z (phaseBasis j)‖ <
+      (delta δ₁ s : ℝ) * beta δ₁ (s + 1) := by
+  have hh := (fderiv ℂ (h.state b (s + 1)).perturbation.toFun z).le_opNorm (phaseBasis j)
+  rw [norm_phaseBasis, mul_one] at hh
+  exact hh.trans_lt (h.remainder_derivative b s hz)
+
+theorem remainder_second_derivative (s : ℕ) {z : ComplexPhaseSpace n}
+    (hz : z ∈ h.phase b (s + 1)) (j k : Fin n ⊕ Fin n) :
+    ‖fderiv ℂ (fderiv ℂ (h.state b (s + 1)).perturbation.toFun) z
+      (phaseBasis j) (phaseBasis k)‖ < (delta δ₁ s : ℝ) := by
+  rw [h.phase_succ b] at hz
+  have hh := (h.state b s).step.second_derivative z hz j k
+  rw [remainder_eq_next_parameter b.delta_pos] at hh
+  exact hh.trans (b.second_derivative_budget s)
+
+theorem frequency_bounds (s : ℕ) {p : ComplexSpace n} (hp : p ∈ h.actionDomain b s)
+    (v : ComplexSpace n) :
+    (θ₀ : ℝ) / 2 * ‖v‖ ≤ ‖fderiv ℂ (actionFrequency (h.state b s).integrable) p v‖ ∧
+      ‖fderiv ℂ (actionFrequency (h.state b s).integrable) p v‖ ≤ 2 * (Θ₀ : ℝ) * ‖v‖ := by
+  constructor
+  · exact (mul_le_mul_of_nonneg_right (lower_gt_half b.lower_pos b.delta_quarter s).le
+      (norm_nonneg v)).trans ((h.state b s).input.lower p hp v)
+  · exact ((fderiv ℂ (actionFrequency (h.state b s).integrable) p).le_opNorm v).trans
+      (mul_le_mul_of_nonneg_right (((h.state b s).input.upper p hp).trans
+        (upper_lt_twice (zero_lt_one.trans b.upper_gt_one) b.delta_quarter s).le) (norm_nonneg v))
+
+theorem frequency_displacement (s : ℕ) {p : ComplexSpace n}
+    (hp : p ∈ h.actionDomain b (s + 1)) :
+    ‖actionFrequency (h.state b (s + 1)).integrable p -
+      actionFrequency (h.state b s).integrable p‖ < (beta δ₁ s : ℝ) * delta δ₁ s :=
+  (h.state b s).step.frequency_displacement p hp
+
+end KamProject.Arnold1963.Iteration.InitialData
diff --git a/LeanPool/ArnoldKAM/Arnold1963/Iteration/InitialParameters.lean b/LeanPool/ArnoldKAM/Arnold1963/Iteration/InitialParameters.lean
new file mode 100644
index 0000000000..832c849b40
--- /dev/null
+++ b/LeanPool/ArnoldKAM/Arnold1963/Iteration/InitialParameters.lean
@@ -0,0 +1,117 @@
+/-
+Copyright (c) 2026 Bingqi Yu. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Bingqi Yu
+-/
+
+module
+
+public import LeanPool.ArnoldKAM.Arnold1963.Iteration.UniformBounds
+public import LeanPool.ArnoldKAM.Arnold1963.Step.IterationParameters
+
+/-!
+Initial numerical hypotheses and their consequences at every iteration stage.
+-/
+
+@[expose] public section
+noncomputable section
+open scoped NNReal
+namespace KamProject.Arnold1963.Iteration
+
+/-- Positive initial parameters satisfying every smallness and measure-budget constraint. -/
+structure InitialParameters (n : ℕ) (δ₁ θ₀ Θ₀ ρ₀ : ℝ≥0) (κ D : ℝ) : Prop where
+  dimension_pos : 0 < n
+  delta_pos : 0 < δ₁
+  lower_pos : 0 < θ₀
+  lower_lt_one : θ₀ < 1
+  upper_gt_one : 1 < Θ₀
+  width_pos : 0 < ρ₀
+  width_le_one : ρ₀ ≤ 1
+  fraction_pos : 0 < κ
+  fraction_lt_one : κ < 1
+  type_constant_pos : 0 < D
+  small : (δ₁ : ℝ) < threshold5 n θ₀ Θ₀ ρ₀ κ D
+
+theorem threshold1_mono {n : ℕ} {θ θ' Θ Θ' : ℝ}
+    (hθ : θ ≤ θ') (hΘ : 0 < Θ') (hΘΘ : Θ' ≤ Θ) :
+    threshold1 n θ Θ ≤ threshold1 n θ' Θ' := by
+  have hi : (2 * Θ)⁻¹ ≤ (2 * Θ')⁻¹ :=
+    inv_anti₀ (by positivity) (by linarith)
+  have hL : 0 ≤ (constantL3 n)⁻¹ := by unfold constantL3 constantL5 constantL0; positivity
+  apply min_le_min _ (div_le_div_of_nonneg_right hθ (by positivity))
+  unfold threshold0
+  exact min_le_min le_rfl (min_le_min le_rfl
+    (min_le_min (mul_le_mul_of_nonneg_left hi hL) le_rfl))
+
+namespace InitialParameters
+variable {n : ℕ} {δ₁ θ₀ Θ₀ ρ₀ : ℝ≥0} {κ D : ℝ}
+  (b : InitialParameters n δ₁ θ₀ Θ₀ ρ₀ κ D)
+include b
+
+theorem delta_quarter : δ₁ < 1 / 4 := delta_initial_lt_quarter b.small
+
+theorem delta_one : δ₁ < 1 := by
+  have h : (δ₁ : ℝ) < 1 / 4 := b.delta_quarter
+  exact_mod_cast (show (δ₁ : ℝ) < 1 by linarith)
+
+theorem delta_step_pos (s : ℕ) : 0 < delta δ₁ s := decay_pos b.delta_pos s
+
+theorem delta_step_le (s : ℕ) : delta δ₁ s ≤ δ₁ := decay_le b.delta_one.le s
+
+theorem gamma_step_pos (s : ℕ) : 0 < gamma n δ₁ s := by
+  rw [gamma_eq]
+  exact NNReal.rpow_pos (b.delta_step_pos s)
+
+theorem gamma_step_le (s : ℕ) : gamma n δ₁ s ≤ gamma n δ₁ 0 := by
+  obtain ⟨_, hγ⟩ := gamma_initial_bounds b.dimension_pos (threshold5_bounds b.small).2.1
+  have h1 : δ₁ ^ (1 / (4 * (n : ℝ))) ≤ 1 := by
+    have : (gamma n δ₁ 0 : ℝ) ≤ 1 := by linarith
+    simp only [gamma, decay_zero] at this
+    exact_mod_cast this
+  simpa only [gamma, decay_zero] using decay_le h1 s
+
+theorem gamma_step_quarter (s : ℕ) : (gamma n δ₁ s : ℝ) < 1 / 4 :=
+  (show (gamma n δ₁ s : ℝ) ≤ gamma n δ₁ 0 from b.gamma_step_le s).trans_lt
+    (gamma_initial_bounds b.dimension_pos (threshold5_bounds b.small).2.1).2
+
+omit b in
+theorem lower_step_le (θ₀ δ₁ : ℝ≥0) (s : ℕ) : lower θ₀ δ₁ s ≤ θ₀ := by
+  induction s with
+  | zero => simp
+  | succ s ih =>
+    rw [lower_succ]
+    exact (mul_le_mul_of_nonneg_left (tsub_le_self : 1 - delta δ₁ s ≤ 1)
+      (zero_le : 0 ≤ lower θ₀ δ₁ s)).trans (by simpa using ih)
+
+omit b in
+theorem upper_step_ge (Θ₀ δ₁ : ℝ≥0) (s : ℕ) : Θ₀ ≤ upper Θ₀ δ₁ s := by
+  induction s with
+  | zero => simp
+  | succ s ih =>
+    rw [upper_succ]
+    apply ih.trans
+    simpa only [mul_one] using mul_le_mul_of_nonneg_left
+      (le_add_of_nonneg_right (zero_le : 0 ≤ delta δ₁ s) : 1 ≤ 1 + delta δ₁ s)
+      (zero_le : 0 ≤ upper Θ₀ δ₁ s)
+
+theorem delta_threshold (s : ℕ) :
+    (delta δ₁ s : ℝ) < threshold1 n (lower θ₀ δ₁ s) (upper Θ₀ δ₁ s) := by
+  obtain ⟨hl, hu, _, _⟩ := uniform_bounds_of_threshold b.dimension_pos b.lower_pos
+    (zero_lt_one.trans b.upper_gt_one) b.small s
+  exact ((show (delta δ₁ s : ℝ) ≤ δ₁ from b.delta_step_le s).trans_lt
+    (threshold5_bounds b.small).1).trans_le
+    (threshold1_mono hl.le (by
+      have hh := b.upper_gt_one.trans_le (upper_step_ge Θ₀ δ₁ s)
+      exact_mod_cast (zero_lt_one.trans hh)) hu.le)
+
+theorem delta_strictAnti : StrictAnti (delta δ₁) := by
+  apply strictAnti_nat_of_succ_lt
+  intro s
+  have hh := decay_half b.delta_quarter.le s
+  have hp : (0 : ℝ) < delta δ₁ s := b.delta_step_pos s
+  exact_mod_cast (show (delta δ₁ (s + 1) : ℝ) < delta δ₁ s by
+    change (delta δ₁ (s + 1) : ℝ) ≤ (delta δ₁ s : ℝ) / 2 at hh
+    linarith)
+
+end InitialParameters
+end KamProject.Arnold1963.Iteration
diff --git a/LeanPool/ArnoldKAM/Arnold1963/Iteration/LimitDomain.lean b/LeanPool/ArnoldKAM/Arnold1963/Iteration/LimitDomain.lean
new file mode 100644
index 0000000000..6743789733
--- /dev/null
+++ b/LeanPool/ArnoldKAM/Arnold1963/Iteration/LimitDomain.lean
@@ -0,0 +1,101 @@
+/-
+Copyright (c) 2026 Bingqi Yu. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Bingqi Yu
+-/
+
+module
+
+public import LeanPool.ArnoldKAM.Arnold1963.Iteration.Construction
+public import LeanPool.ArnoldKAM.Arnold1963.Iteration.TotalBudget
+public import LeanPool.ArnoldKAM.Arnold1963.Iteration.Measure
+
+/-!
+The compact intersection of actual iteration domains, with positive measure and strict loss
+bounds obtained from the summable budget.
+-/
+
+@[expose] public section
+noncomputable section
+open Set MeasureTheory
+open scoped NNReal ENNReal
+namespace KamProject.Arnold1963.Iteration.InitialData
+variable {n : ℕ} {Ω₀ : Set (ComplexSpace n)} {δ₁ θ₀ Θ₀ ρ₀ : ℝ≥0} {κ D : ℝ}
+  (b : InitialParameters n δ₁ θ₀ Θ₀ ρ₀ κ D)
+  (h : InitialData n Ω₀ δ₁ θ₀ Θ₀ ρ₀ D)
+
+theorem step_measure (s : ℕ) :
+    realVolume (h.actionDomain b s \ h.actionDomain b (s + 1)) ≤
+      lossBudget n δ₁ θ₀ Θ₀ κ D s * realVolume h.domain := by
+  have hh := Iteration.result_measure_uniform (h.state b s).ar (h.state b s).input
+    h.chart b.lower_pos b.delta_quarter h.upper h.typeD
+    (b.previousCutoff_ge_one s) (b.cutoff_step_le s)
+  apply hh.trans_eq
+  change ENNReal.ofReal ((2 * (Θ₀ : ℝ) / θ₀) ^ n) *
+    (ENNReal.ofReal (resonanceLossConstant n * D * rawLoss n δ₁ Θ₀ κ s) * realVolume h.domain) = _
+  unfold lossBudget actionLossFactor
+  rw [show (2 * (Θ₀ : ℝ) / θ₀) ^ n * resonanceLossConstant n * D * rawLoss n δ₁ Θ₀ κ s =
+    (2 * (Θ₀ : ℝ) / θ₀) ^ n * (resonanceLossConstant n * D * rawLoss n δ₁ Θ₀ κ s) by ring,
+    ENNReal.ofReal_mul (pow_nonneg
+      (div_nonneg (mul_nonneg (by norm_num) Θ₀.coe_nonneg) θ₀.coe_nonneg) n), mul_assoc]
+  ac_rfl
+
+/-- The intersection of all action domains retained during the iteration. -/
+def limitDomain : Set (ComplexSpace n) := ⋂ s, h.actionDomain b s
+
+theorem limit_subset (s : ℕ) : h.limitDomain b ⊆ h.actionDomain b s := iInter_subset _ s
+
+theorem limit_compact : IsCompact (h.limitDomain b) :=
+  h.chart.compact.of_isClosed_subset (isClosed_iInter fun s => (h.domain_compact b s).isClosed)
+    (h.limit_subset b 0)
+
+theorem limit_loss : realVolume (h.domain \ h.limitDomain b) <
+    ENNReal.ofReal κ * realVolume h.domain := by
+  exact (limit_positive_of_budget (h.actionDomain b) (lossBudget n δ₁ θ₀ Θ₀ κ D)
+    (h.step_measure b) b.lossBudget_tsum_lt (ENNReal.ofReal_lt_one.mpr b.fraction_lt_one)
+    h.volume_pos h.volume_finite).1
+
+theorem limit_volume_pos : 0 < realVolume (h.limitDomain b) :=
+  (limit_positive_of_budget (h.actionDomain b) (lossBudget n δ₁ θ₀ Θ₀ κ D)
+    (h.step_measure b) b.lossBudget_tsum_lt (ENNReal.ofReal_lt_one.mpr b.fraction_lt_one)
+    h.volume_pos h.volume_finite).2.1
+
+theorem limit_realSlice_nonempty : (realSlice (h.limitDomain b)).Nonempty :=
+  realSlice_nonempty_of_realVolume_pos (h.limit_volume_pos b)
+
+theorem finite_loss (s : ℕ) : realVolume (h.domain \ h.actionDomain b s) <
+    ENNReal.ofReal κ * realVolume h.domain :=
+  (realVolume_mono (sdiff_subset_sdiff_right (h.limit_subset b s))).trans_lt (h.limit_loss b)
+
+theorem domain_realSlice_nonempty (s : ℕ) : (realSlice (h.actionDomain b s)).Nonempty :=
+  (h.limit_realSlice_nonempty b).mono (preimage_mono (h.limit_subset b s))
+
+theorem phase_nonempty (s : ℕ) : (h.phase b s).Nonempty := by
+  obtain ⟨x, hx⟩ := h.domain_realSlice_nonempty b s
+  refine ⟨(complexify x, 0), hx, ?_⟩
+  apply (mem_angleStrip_iff _ _).mpr
+  intro j
+  simp only [Pi.zero_apply, Complex.zero_im, abs_zero]
+  exact (width n ρ₀ δ₁ s).coe_nonneg
+
+theorem limit_volume_gt : ENNReal.ofReal (1 - κ) * realVolume h.domain <
+    realVolume (h.limitDomain b) := by
+  have hsub : realSlice (h.limitDomain b) ⊆ realSlice h.domain :=
+    preimage_mono (h.limit_subset b 0)
+  have hfin : realVolume (h.limitDomain b) ≠ ⊤ :=
+    ne_top_of_le_ne_top h.volume_finite (realVolume_mono (h.limit_subset b 0))
+  have he : realVolume (h.domain \ h.limitDomain b) =
+      realVolume h.domain - realVolume (h.limitDomain b) := by
+    exact measure_sdiff hsub
+      (measurableSet_realSlice_of_isCompact (h.limit_compact b)).nullMeasurableSet hfin
+  have hl := h.limit_loss b
+  rw [he] at hl
+  have hk : ENNReal.ofReal κ * realVolume h.domain ≤ realVolume h.domain := by
+    simpa only [one_mul] using mul_le_mul_of_nonneg_right
+      (ENNReal.ofReal_lt_one.mpr b.fraction_lt_one).le (zero_le : 0 ≤ realVolume h.domain)
+  have hh := ENNReal.sub_lt_of_sub_lt hk (Or.inl h.volume_finite) hl
+  rw [ENNReal.ofReal_sub 1 b.fraction_pos.le, ENNReal.ofReal_one,
+    ENNReal.sub_mul (fun _ _ => h.volume_finite), one_mul]
+  exact hh
+
+end KamProject.Arnold1963.Iteration.InitialData
diff --git a/LeanPool/ArnoldKAM/Arnold1963/Iteration/Measure.lean b/LeanPool/ArnoldKAM/Arnold1963/Iteration/Measure.lean
new file mode 100644
index 0000000000..837c3e5549
--- /dev/null
+++ b/LeanPool/ArnoldKAM/Arnold1963/Iteration/Measure.lean
@@ -0,0 +1,73 @@
+/-
+Copyright (c) 2026 Bingqi Yu. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Bingqi Yu
+-/
+
+module
+
+public import LeanPool.ArnoldKAM.Arnold1963.Step.MeasureBudget
+
+/-!
+Finite and countable domain-loss estimates from the individual step budgets.
+-/
+
+@[expose] public section
+noncomputable section
+open Set MeasureTheory
+open scoped ENNReal
+namespace KamProject.Arnold1963.Iteration
+
+theorem finite_loss_le {n : ℕ} (G : ℕ → Set (ComplexSpace n)) (b : ℕ → ℝ≥0∞)
+    (hstep : ∀ s, realVolume (G s \ G (s + 1)) ≤ b s * realVolume (G 0)) (s : ℕ) :
+    realVolume (G 0 \ G s) ≤ (∑ j ∈ Finset.range s, b j) * realVolume (G 0) := by
+  induction s with
+  | zero => simp [realVolume, realSlice]
+  | succ s ih =>
+    have hc : realSlice (G 0 \ G (s + 1)) ⊆
+        realSlice (G 0 \ G s) ∪ realSlice (G s \ G (s + 1)) := by
+      intro x hx
+      by_cases hs : complexify x ∈ G s
+      · exact Or.inr ⟨hs, hx.2⟩
+      · exact Or.inl ⟨hx.1, hs⟩
+    have hh := (measure_mono (μ := realLebesgue n) hc).trans (measure_union_le _ _)
+    change realVolume (G 0 \ G (s + 1)) ≤
+      realVolume (G 0 \ G s) + realVolume (G s \ G (s + 1)) at hh
+    rw [Finset.sum_range_succ, add_mul]
+    exact hh.trans (add_le_add ih (hstep s))
+
+theorem limit_loss_le {n : ℕ} (G : ℕ → Set (ComplexSpace n)) (b : ℕ → ℝ≥0∞)
+    (hstep : ∀ s, realVolume (G s \ G (s + 1)) ≤ b s * realVolume (G 0)) :
+    realVolume (G 0 \ ⋂ s, G s) ≤ (∑' s, b s) * realVolume (G 0) := by
+  have hc : realSlice (G 0 \ ⋂ s, G s) ⊆ ⋃ s, realSlice (G s \ G (s + 1)) := by
+    intro x hx
+    by_contra h
+    have hs : ∀ s, complexify x ∈ G s := by
+      intro s
+      induction s with
+      | zero => exact hx.1
+      | succ s ih =>
+        by_contra hn
+        exact h (mem_iUnion_of_mem s ⟨ih, hn⟩)
+    exact hx.2 (mem_iInter.mpr hs)
+  calc
+    _ ≤ ∑' s, realVolume (G s \ G (s + 1)) :=
+      (measure_mono (μ := realLebesgue n) hc).trans (measure_iUnion_le _)
+    _ ≤ ∑' s, b s * realVolume (G 0) := ENNReal.tsum_le_tsum hstep
+    _ = _ := ENNReal.tsum_mul_right
+
+theorem limit_positive_of_budget {n : ℕ} (G : ℕ → Set (ComplexSpace n))
+    (b : ℕ → ℝ≥0∞) {κ : ℝ≥0∞}
+    (hstep : ∀ s, realVolume (G s \ G (s + 1)) ≤ b s * realVolume (G 0))
+    (hsum : (∑' s, b s) < κ) (hκ : κ < 1)
+    (hpos : 0 < realVolume (G 0)) (hfinite : realVolume (G 0) ≠ ⊤) :
+    realVolume (G 0 \ ⋂ s, G s) < κ * realVolume (G 0) ∧
+      0 < realVolume (⋂ s, G s) ∧ (realSlice (⋂ s, G s)).Nonempty := by
+  have hl := (limit_loss_le G b hstep).trans_lt
+    (ENNReal.mul_lt_mul_left hpos.ne' hfinite hsum)
+  have hκG : κ * realVolume (G 0) < realVolume (G 0) := by
+    simpa only [one_mul] using ENNReal.mul_lt_mul_left hpos.ne' hfinite hκ
+  have hp := realVolume_pos_of_loss_lt (hl.trans hκG)
+  exact ⟨hl, hp, realSlice_nonempty_of_realVolume_pos hp⟩
+
+end KamProject.Arnold1963.Iteration
diff --git a/LeanPool/ArnoldKAM/Arnold1963/Iteration/NumericalConditions.lean b/LeanPool/ArnoldKAM/Arnold1963/Iteration/NumericalConditions.lean
new file mode 100644
index 0000000000..7255545d9b
--- /dev/null
+++ b/LeanPool/ArnoldKAM/Arnold1963/Iteration/NumericalConditions.lean
@@ -0,0 +1,108 @@
+/-
+Copyright (c) 2026 Bingqi Yu. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Bingqi Yu
+-/
+
+module
+
+public import LeanPool.ArnoldKAM.Arnold1963.Iteration.Cutoff
+
+/-!
+Derive every single-step numerical condition from the initial threshold.
+-/
+
+@[expose] public section
+noncomputable section
+open scoped NNReal
+namespace KamProject.Arnold1963.Iteration.InitialParameters
+variable {n : ℕ} {δ₁ θ₀ Θ₀ ρ₀ : ℝ≥0} {κ D : ℝ}
+  (b : InitialParameters n δ₁ θ₀ Θ₀ ρ₀ κ D)
+include b
+
+theorem angle_loss (s : ℕ) : 10 * (delta δ₁ s : ℝ) < 2 * gamma n δ₁ s := by
+  have hg0 : (0 : ℝ) < gamma n δ₁ s := b.gamma_step_pos s
+  have hg := b.gamma_step_quarter s
+  have he : (gamma n δ₁ s : ℝ) ^ (4 * n) = delta δ₁ s := by
+    exact_mod_cast gamma_pow b.dimension_pos δ₁ s
+  have hn := b.dimension_pos
+  have hp : (delta δ₁ s : ℝ) ≤ (gamma n δ₁ s : ℝ) ^ 3 := by
+    rw [← he]
+    exact pow_le_pow_of_le_one hg0.le (by linarith) (by omega)
+  have hs := mul_le_mul_of_nonneg_left
+    (pow_le_pow_left₀ hg0.le hg.le (n := 2)) hg0.le
+  nlinarith
+
+theorem action_loss (s : ℕ) : 3 * (beta δ₁ s : ℝ) < 2 * delta δ₁ s := by
+  have hd0 : (0 : ℝ) < delta δ₁ s := b.delta_step_pos s
+  have hd : (delta δ₁ s : ℝ) < 1 / 4 := (b.delta_step_le s).trans_lt b.delta_quarter
+  have hs := mul_le_mul_of_nonneg_left
+    (pow_le_pow_left₀ hd0.le hd.le (n := 2)) hd0.le
+  change 3 * (delta δ₁ s : ℝ) ^ 3 < 2 * delta δ₁ s
+  nlinarith
+
+theorem delta_lt_fraction : (δ₁ : ℝ) < κ := by
+  have h := (threshold5_bounds b.small).2.1
+  exact (lt_min_iff.mp (lt_min_iff.mp h).2).2
+
+theorem divisor_pos : 0 < κ * (δ₁ : ℝ) := mul_pos b.fraction_pos b.delta_pos
+
+theorem divisor_le_one : κ * (δ₁ : ℝ) ≤ 1 := by
+  have hκ := b.fraction_lt_one
+  have hd : (δ₁ : ℝ) < 1 := b.delta_one
+  nlinarith [b.fraction_pos, δ₁.coe_nonneg]
+
+theorem delta_sq_lt_divisor (s : ℕ) : (delta δ₁ s : ℝ) ^ 2 < κ * (δ₁ : ℝ) := by
+  have hh := mul_lt_mul_of_pos_right b.delta_lt_fraction
+    (show (0 : ℝ) < δ₁ from b.delta_pos)
+  calc
+    (delta δ₁ s : ℝ) ^ 2 ≤ (δ₁ : ℝ) ^ 2 :=
+      pow_le_pow_left₀ (delta δ₁ s).coe_nonneg (show (delta δ₁ s : ℝ) ≤ δ₁ from
+        b.delta_step_le s) 2
+    _ < κ * (δ₁ : ℝ) := by nlinarith only [hh]
+
+theorem divisor_margin (s : ℕ) : 2 * (beta δ₁ s : ℝ) < κ * (δ₁ : ℝ) := by
+  have hd0 : (0 : ℝ) < delta δ₁ s := b.delta_step_pos s
+  have hd : (delta δ₁ s : ℝ) < 1 / 4 := (b.delta_step_le s).trans_lt b.delta_quarter
+  have hh := mul_lt_mul_of_pos_right (show 2 * (delta δ₁ s : ℝ) < 1 by linarith)
+    (sq_pos_of_pos hd0)
+  change 2 * (delta δ₁ s : ℝ) ^ 3 < κ * (δ₁ : ℝ)
+  exact (show 2 * (delta δ₁ s : ℝ) ^ 3 < (delta δ₁ s : ℝ) ^ 2 by nlinarith).trans
+    (b.delta_sq_lt_divisor s)
+
+theorem perturbation_small (s : ℕ) : perturbation n δ₁ s <
+    (delta δ₁ s : ℝ) ^ stepExponent n * (κ * (δ₁ : ℝ)) * (beta δ₁ s : ℝ) ^ 2 := by
+  have hd0 : (0 : ℝ) < delta δ₁ s := b.delta_step_pos s
+  have hd1 : (delta δ₁ s : ℝ) < 1 := (b.delta_step_le s).trans_lt b.delta_one
+  have hp : perturbation n δ₁ s < (delta δ₁ s : ℝ) ^ (stepExponent n + 8) :=
+    pow_lt_pow_right_of_lt_one₀ hd0 hd1 (by unfold iterationExponent stepExponent; omega)
+  apply hp.trans
+  have hh := mul_lt_mul_of_pos_left (b.delta_sq_lt_divisor s)
+    (show 0 < (delta δ₁ s : ℝ) ^ stepExponent n * (delta δ₁ s : ℝ) ^ 6 by positivity)
+  convert hh using 1 <;> simp only [beta, NNReal.coe_pow, pow_add] <;> ring
+
+theorem parameters (s : ℕ) :
+    IterationParameters n (width n ρ₀ δ₁ s) (beta δ₁ s) (delta δ₁ s) (gamma n δ₁ s)
+      (lower θ₀ δ₁ s) (upper Θ₀ δ₁ s) (κ * (δ₁ : ℝ)) (perturbation n δ₁ s) where
+  dimension_pos := b.dimension_pos
+  beta_pos := pow_pos (b.delta_step_pos s) 3
+  delta_pos := b.delta_step_pos s
+  lower_pos := by
+    have hh := lower_gt_half b.lower_pos b.delta_quarter s
+    have hθ : (0 : ℝ) < θ₀ := b.lower_pos
+    exact_mod_cast (show (0 : ℝ) < lower θ₀ δ₁ s by linarith)
+  lower_lt_one := (lower_step_le θ₀ δ₁ s).trans_lt b.lower_lt_one
+  upper_gt_one := b.upper_gt_one.trans_le (upper_step_ge Θ₀ δ₁ s)
+  delta_small := b.delta_threshold s
+  angle_loss := b.angle_loss s
+  angle_width := (uniform_bounds_of_threshold b.dimension_pos b.lower_pos
+    (zero_lt_one.trans b.upper_gt_one) b.small s).2.2.2
+  width_le_one := (tsub_le_self : width n ρ₀ δ₁ s ≤ ρ₀).trans b.width_le_one
+  action_loss := b.action_loss s
+  divisor_margin := b.divisor_margin s
+  divisor_le_one := b.divisor_le_one
+  perturbation_pos := b.perturbation_step_pos s
+  perturbation_small := b.perturbation_small s
+  cutoff_gt_one := b.cutoff_gt_one s
+
+end KamProject.Arnold1963.Iteration.InitialParameters
diff --git a/LeanPool/ArnoldKAM/Arnold1963/Iteration/Parameters.lean b/LeanPool/ArnoldKAM/Arnold1963/Iteration/Parameters.lean
new file mode 100644
index 0000000000..f8c7b86be9
--- /dev/null
+++ b/LeanPool/ArnoldKAM/Arnold1963/Iteration/Parameters.lean
@@ -0,0 +1,157 @@
+/-
+Copyright (c) 2026 Bingqi Yu. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Bingqi Yu
+-/
+
+module
+
+public import LeanPool.ArnoldKAM.Arnold1963.Arithmetic.Parameters
+public import Mathlib.Analysis.SpecialFunctions.Pow.NNReal
+public import Mathlib.Analysis.SpecificLimits.Normed
+
+/-!
+Explicit decay sequences for the corrected iteration. States are indexed from zero; their
+small parameters correspond to the next paper step. The recurrence uses the exponent 3 / 2.
+-/
+
+@[expose] public section
+noncomputable section
+open scoped NNReal
+namespace KamProject.Arnold1963
+namespace Iteration
+
+/-- Superexponential decay with exponent `(3/2)^s`. -/
+def decay (x : ℝ≥0) (s : ℕ) : ℝ≥0 := x ^ ((3 / 2 : ℝ) ^ s)
+
+@[simp] theorem decay_zero (x : ℝ≥0) : decay x 0 = x := by simp [decay]
+
+theorem decay_succ (x : ℝ≥0) (s : ℕ) :
+    decay x (s + 1) = decay x s ^ (3 / 2 : ℝ) := by
+  simp only [decay, pow_succ, NNReal.rpow_mul]
+
+theorem decay_pos {x : ℝ≥0} (hx : 0 < x) (s : ℕ) : 0 < decay x s :=
+  NNReal.rpow_pos hx
+
+theorem decay_add (x : ℝ≥0) (s t : ℕ) : decay x (s + t) = decay (decay x s) t := by
+  simp only [decay, pow_add, NNReal.rpow_mul]
+
+theorem coe_decay_succ (x : ℝ≥0) (s : ℕ) :
+    (decay x (s + 1) : ℝ) = (decay x s : ℝ) * Real.sqrt (decay x s) := by
+  rw [decay_succ, NNReal.coe_rpow, Real.sqrt_eq_rpow]
+  rw [show (3 / 2 : ℝ) = 1 + 1 / 2 by norm_num,
+    Real.rpow_add_of_nonneg (decay x s).coe_nonneg (by norm_num) (by norm_num), Real.rpow_one]
+
+theorem decay_le {x : ℝ≥0} (hx : x ≤ 1) (s : ℕ) : decay x s ≤ x := by
+  exact NNReal.rpow_le_self_of_le_one hx (one_le_pow₀ (by norm_num))
+
+theorem decay_half {x : ℝ≥0} (hx : x ≤ 1 / 4) (s : ℕ) :
+    (decay x (s + 1) : ℝ) ≤ (decay x s : ℝ) / 2 := by
+  have hd : (decay x s : ℝ) ≤ 1 / 4 :=
+    (decay_le (hx.trans (by
+      exact_mod_cast (show (1 / 4 : ℝ) ≤ 1 by norm_num))) s).trans hx
+  have hs : Real.sqrt (decay x s) ≤ 1 / 2 :=
+    (Real.sqrt_le_iff).2 ⟨by norm_num, by nlinarith⟩
+  rw [coe_decay_succ]
+  nlinarith [(decay x s).coe_nonneg]
+
+theorem decay_geometric {x : ℝ≥0} (hx : x ≤ 1 / 4) (s : ℕ) :
+    (decay x s : ℝ) ≤ (x : ℝ) * (1 / 2 : ℝ) ^ s := by
+  induction s with
+  | zero => simp
+  | succ s ih =>
+    have hh := decay_half hx s
+    rw [pow_succ]
+    nlinarith
+
+theorem decay_summable {x : ℝ≥0} (hx : x ≤ 1 / 4) :
+    Summable (fun s => (decay x s : ℝ)) :=
+  Summable.of_nonneg_of_le (fun s => (decay x s).coe_nonneg) (decay_geometric hx)
+    ((summable_geometric_of_lt_one (by norm_num : (0 : ℝ) ≤ 1 / 2)
+      (by norm_num)).mul_left (x : ℝ))
+
+theorem decay_tsum_le {x : ℝ≥0} (hx : x ≤ 1 / 4) :
+    (∑' s, (decay x s : ℝ)) ≤ 2 * (x : ℝ) := by
+  calc
+    _ ≤ ∑' s, (x : ℝ) * (1 / 2 : ℝ) ^ s :=
+      (decay_summable hx).tsum_le_tsum (decay_geometric hx)
+        ((summable_geometric_of_lt_one (by norm_num : (0 : ℝ) ≤ 1 / 2)
+          (by norm_num)).mul_left (x : ℝ))
+    _ = _ := by rw [tsum_mul_left, tsum_geometric_of_lt_one (by norm_num) (by norm_num)]; ring
+
+theorem decay_sum_le {x : ℝ≥0} (hx : x ≤ 1 / 4) (s : ℕ) :
+    (∑ j ∈ Finset.range s, (decay x j : ℝ)) ≤ 2 * (x : ℝ) :=
+  ((decay_summable hx).sum_le_tsum _ (fun _ _ => NNReal.coe_nonneg _)).trans
+    (decay_tsum_le hx)
+
+theorem decay_tail_le {x : ℝ≥0} (hx : x ≤ 1 / 4) (s : ℕ) :
+    (∑' j, (decay x (s + j) : ℝ)) ≤ 2 * (decay x s : ℝ) := by
+  simp only [decay_add]
+  apply decay_tsum_le
+  exact (decay_le (hx.trans (by
+    exact_mod_cast (show (1 / 4 : ℝ) ≤ 1 by norm_num))) s).trans hx
+
+/-- The stage's smallness parameter along the superexponential decay sequence. -/
+def delta (δ₁ : ℝ≥0) (s : ℕ) : ℝ≥0 := decay δ₁ s
+/-- The cubic smallness scale used for displacement and action-domain erosion. -/
+def beta (δ₁ : ℝ≥0) (s : ℕ) : ℝ≥0 := delta δ₁ s ^ 3
+/-- The stage's strip-loss scale derived from the initial smallness parameter. -/
+def gamma (n : ℕ) (δ₁ : ℝ≥0) (s : ℕ) : ℝ≥0 :=
+  decay (δ₁ ^ (1 / (4 * (n : ℝ)))) s
+/-- The stage's perturbation bound chosen with the iteration exponent. -/
+def perturbation (n : ℕ) (δ₁ : ℝ≥0) (s : ℕ) : ℝ :=
+  (delta δ₁ s : ℝ) ^ iterationExponent n
+
+theorem gamma_eq (n : ℕ) (δ₁ : ℝ≥0) (s : ℕ) :
+    gamma n δ₁ s = delta δ₁ s ^ (1 / (4 * (n : ℝ))) := by
+  simp only [gamma, delta, decay, ← NNReal.rpow_mul, mul_comm]
+
+theorem gamma_pow {n : ℕ} (hn : 0 < n) (δ₁ : ℝ≥0) (s : ℕ) :
+    gamma n δ₁ s ^ (4 * n) = delta δ₁ s := by
+  rw [gamma_eq, ← NNReal.rpow_natCast, ← NNReal.rpow_mul]
+  have hn' : (n : ℝ) ≠ 0 := by exact_mod_cast hn.ne'
+  have he : (1 / (4 * (n : ℝ))) * ((4 * n : ℕ) : ℝ) = 1 := by
+    push_cast
+    field_simp [hn']
+  rw [he, NNReal.rpow_one]
+
+theorem gamma_initial_bounds {n : ℕ} (hn : 0 < n) {δ₁ ρ₀ : ℝ≥0} {κ : ℝ}
+    (hδ : (δ₁ : ℝ) < threshold2 n κ ρ₀) :
+    (gamma n δ₁ 0 : ℝ) < (ρ₀ : ℝ) / 10 ∧ (gamma n δ₁ 0 : ℝ) < 1 / 4 := by
+  obtain ⟨hρ, h4, _⟩ := (show (δ₁ : ℝ) < ((10 : ℝ) ^ (4 * n))⁻¹ * (ρ₀ : ℝ) ^ (4 * n) ∧
+      (δ₁ : ℝ) < ((4 : ℝ) ^ (4 * n))⁻¹ ∧ (δ₁ : ℝ) < κ by
+    simpa only [threshold2, lt_min_iff] using hδ)
+  have hp : (gamma n δ₁ 0 : ℝ) ^ (4 * n) = (δ₁ : ℝ) := by
+    simp only [← NNReal.coe_pow, gamma_pow hn, delta, decay_zero]
+  constructor
+  · apply lt_of_pow_lt_pow_left₀ (4 * n) (by positivity : (0 : ℝ) ≤ (ρ₀ : ℝ) / 10)
+    rw [hp, div_pow]
+    simpa only [div_eq_mul_inv, mul_comm] using hρ
+  · apply lt_of_pow_lt_pow_left₀ (4 * n) (by norm_num : (0 : ℝ) ≤ 1 / 4)
+    rw [hp, div_pow, one_pow]
+    simpa only [one_div] using h4
+
+theorem delta_initial_lt_quarter {n : ℕ} {θ Θ ρ κ D : ℝ} {δ₁ : ℝ≥0}
+    (hδ : (δ₁ : ℝ) < threshold5 n θ Θ ρ κ D) : δ₁ < 1 / 4 := by
+  have hh := (threshold0_bounds (threshold1_bounds (threshold5_bounds hδ).1).1).1
+  have : (δ₁ : ℝ) < 1 / 4 := by linarith
+  exact_mod_cast this
+
+theorem remainder_eq_next {δ₁ : ℝ≥0} (hδ : 0 < δ₁) (n s : ℕ) :
+    (perturbation n δ₁ s) ^ 2 /
+      ((delta δ₁ s : ℝ) ^ (2 * stepExponent n) * (beta δ₁ s : ℝ) ^ 2) =
+      perturbation n δ₁ (s + 1) := by
+  have hd : (0 : ℝ) < delta δ₁ s := decay_pos hδ s
+  change ((delta δ₁ s : ℝ) ^ iterationExponent n) ^ 2 /
+    ((delta δ₁ s : ℝ) ^ (2 * stepExponent n) * ((delta δ₁ s : ℝ) ^ 3) ^ 2) = _
+  rw [budget_step_eq hd n]
+  unfold perturbation delta
+  rw [decay_succ, NNReal.coe_rpow]
+  conv_rhs => rw [← Real.rpow_natCast, ← Real.rpow_mul (decay δ₁ s).coe_nonneg]
+  have he : (3 / 2 : ℝ) * (iterationExponent n : ℝ) = ((12 * n + 36 : ℕ) : ℝ) := by
+    simp only [iterationExponent, Nat.cast_add, Nat.cast_mul, Nat.cast_ofNat]
+    ring
+  rw [he, Real.rpow_natCast]
+
+end Iteration
+end KamProject.Arnold1963
diff --git a/LeanPool/ArnoldKAM/Arnold1963/Iteration/ShellSum.lean b/LeanPool/ArnoldKAM/Arnold1963/Iteration/ShellSum.lean
new file mode 100644
index 0000000000..caefeb1b8e
--- /dev/null
+++ b/LeanPool/ArnoldKAM/Arnold1963/Iteration/ShellSum.lean
@@ -0,0 +1,56 @@
+/-
+Copyright (c) 2026 Bingqi Yu. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Bingqi Yu
+-/
+
+module
+
+public import LeanPool.ArnoldKAM.Arnold1963.Arithmetic.ResonanceLoss
+public import Mathlib.Analysis.PSeries
+public import Mathlib.Algebra.BigOperators.Intervals
+
+/-!
+Summation of new lattice shells along monotone real cutoffs, with the strict cutoff
+boundaries expressed through ceiling and half-open integer intervals.
+-/
+
+@[expose] public section
+noncomputable section
+open scoped NNReal ENNReal
+namespace KamProject.Arnold1963.Iteration
+
+theorem shell_sum_telescope (N : ℕ → ℝ) (hN : Monotone N) (s : ℕ) :
+    (∑ j ∈ Finset.range s, newShellBudget (N j) (N (j + 1))) =
+      newShellBudget (N 0) (N s) := by
+  induction s with
+  | zero => simp [newShellBudget, newShells]
+  | succ s ih =>
+    rw [Finset.sum_range_succ, ih]
+    exact Finset.sum_Ico_consecutive _ (Nat.ceil_mono (hN (Nat.zero_le s)))
+      (Nat.ceil_mono (hN (Nat.le_succ s)))
+
+theorem shell_budget_one_le_two (N : ℝ) : newShellBudget 1 N ≤ 2 := by
+  have he : newShells 1 N = Finset.Ioo 0 ⌈N⌉₊ := by
+    ext m
+    simp only [newShells, Nat.ceil_one, Finset.mem_Ico, Finset.mem_Ioo]
+    omega
+  rw [newShellBudget, he]
+  simpa only [one_div, Nat.cast_zero, zero_add, div_one] using
+    (sum_Ioo_inv_sq_le (α := ℝ) 0 ⌈N⌉₊)
+
+theorem shell_summable (N : ℕ → ℝ) (hN : Monotone N) (h0 : N 0 = 1) :
+    Summable (fun s => newShellBudget (N s) (N (s + 1))) := by
+  apply summable_of_sum_range_le (fun s => newShellBudget_nonneg _ _) (c := 2)
+  intro s
+  rw [shell_sum_telescope N hN s, h0]
+  exact shell_budget_one_le_two _
+
+theorem shell_tsum_le_two (N : ℕ → ℝ) (hN : Monotone N) (h0 : N 0 = 1) :
+    (∑' s, newShellBudget (N s) (N (s + 1))) ≤ 2 := by
+  apply Real.tsum_le_of_sum_range_le (fun s => newShellBudget_nonneg _ _)
+  intro s
+  rw [shell_sum_telescope N hN s, h0]
+  exact shell_budget_one_le_two _
+
+end KamProject.Arnold1963.Iteration
diff --git a/LeanPool/ArnoldKAM/Arnold1963/Iteration/State.lean b/LeanPool/ArnoldKAM/Arnold1963/Iteration/State.lean
new file mode 100644
index 0000000000..2f9ae3e178
--- /dev/null
+++ b/LeanPool/ArnoldKAM/Arnold1963/Iteration/State.lean
@@ -0,0 +1,104 @@
+/-
+Copyright (c) 2026 Bingqi Yu. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Bingqi Yu
+-/
+
+module
+
+public import LeanPool.ArnoldKAM.Arnold1963.Iteration.NumericalConditions
+public import LeanPool.ArnoldKAM.Arnold1963.Iteration.StepInterface
+
+/-!
+The actual recursive Hamiltonian state and its next-stage data.
+-/
+
+@[expose] public section
+noncomputable section
+open Set
+open scoped NNReal ENNReal
+namespace KamProject.Arnold1963.Iteration
+
+/-- The Hamiltonian, resonance exclusions and frequency chart at a given KAM stage. -/
+structure State (n : ℕ) (Ω₀ : Set (ComplexSpace n)) (δ₁ θ₀ Θ₀ ρ₀ : ℝ≥0)
+    (κ : ℝ) (s : ℕ) where
+  /-- The action domain retained by this KAM state. -/
+  domain : Set (ComplexSpace n)
+  /-- The accumulated resonance exclusions and geometric erosion at this stage. -/
+  ar : ResonanceDomainState n (κ * (δ₁ : ℝ)) (previousCutoff n δ₁ s)
+  /-- The current integrable Hamiltonian depending only on action coordinates. -/
+  integrable : ComplexSpace n → ℂ
+  /-- The current analytic perturbation on the retained phase domain. -/
+  perturbation : AnalyticPhaseFunction n domain (width n ρ₀ δ₁ s)
+  /-- The inverse of the current action-frequency chart. -/
+  inverseFrequency : ComplexSpace n → ComplexSpace n
+  input : IterationInput (Ω := ar.domain Ω₀) integrable perturbation inverseFrequency
+    (beta δ₁ s) (delta δ₁ s) (gamma n δ₁ s) (lower θ₀ δ₁ s) (upper Θ₀ δ₁ s)
+    (κ * (δ₁ : ℝ)) (Iteration.perturbation n δ₁ s)
+
+namespace State
+variable {n : ℕ} {Ω₀ : Set (ComplexSpace n)} {δ₁ θ₀ Θ₀ ρ₀ : ℝ≥0} {κ D : ℝ} {s : ℕ}
+  (b : InitialParameters n δ₁ θ₀ Θ₀ ρ₀ κ D)
+  (z : State n Ω₀ δ₁ θ₀ Θ₀ ρ₀ κ s)
+
+/-- The inductive KAM step constructed from the current state's verified input data. -/
+def step := z.input.result
+
+/-- The next perturbation restricted to the strip width prescribed by the iteration. -/
+def nextPerturbation : AnalyticPhaseFunction n z.step.domain (width n ρ₀ δ₁ (s + 1)) :=
+  z.step.perturbation.restrict (Subset.refl _) (by rw [width_succ]) z.step.chart.domain_conj
+
+include b in
+theorem nextPerturbation_bound : z.nextPerturbation.uniformNorm <
+    Iteration.perturbation n δ₁ (s + 1) := by
+  have hh := (z.step.perturbation.uniformNorm_restrict_le (Subset.refl _)
+    (show width n ρ₀ δ₁ (s + 1) ≤ width n ρ₀ δ₁ s - 3 * gamma n δ₁ s by rw [width_succ])
+    z.step.chart.domain_conj).trans_lt z.step.bound
+  exact hh.trans_eq (remainder_eq_next_parameter b.delta_pos n s)
+
+/-- The next resonance state after adding modes and the prescribed geometric loss. -/
+def nextAR : ResonanceDomainState n (κ * (δ₁ : ℝ)) (previousCutoff n δ₁ (s + 1)) :=
+  z.ar.next b.divisor_pos (b.cutoff_step_le s) ((5 + 7 * upper Θ₀ δ₁ s) * beta δ₁ s)
+
+theorem nextInput : IterationInput (Ω := (z.nextAR b).domain Ω₀)
+    (z.perturbation.averagedHamiltonian z.integrable) z.nextPerturbation z.step.inverseFrequency
+    (beta δ₁ (s + 1)) (delta δ₁ (s + 1)) (gamma n δ₁ (s + 1))
+    (lower θ₀ δ₁ (s + 1)) (upper Θ₀ δ₁ (s + 1))
+    (κ * (δ₁ : ℝ)) (Iteration.perturbation n δ₁ (s + 1)) where
+  chart := z.input.result_chart_next z.ar (b.cutoff_step_le s)
+  analytic := z.step.analytic
+  conj := z.step.conj
+  lower := by
+    intro p hp v
+    rw [lower_succ]
+    simpa only [NNReal.coe_mul, NNReal.coe_sub (b.parameters s).delta_lt_one.le,
+      NNReal.coe_one] using (z.step.derivative_bounds p hp v).1
+  upper := by
+    intro p hp
+    apply ContinuousLinearMap.opNorm_le_bound _ (by positivity)
+    intro v
+    rw [upper_succ]
+    simpa only [NNReal.coe_mul, NNReal.coe_add, NNReal.coe_one] using
+      (z.step.derivative_bounds p hp v).2
+  perturbation := (z.nextPerturbation_bound b).le
+  budget := b.parameters (s + 1)
+
+/-- The successor KAM state with updated Hamiltonian, perturbation and frequency chart. -/
+def next : State n Ω₀ δ₁ θ₀ Θ₀ ρ₀ κ (s + 1) where
+  domain := z.step.domain
+  ar := z.nextAR b
+  integrable := z.perturbation.averagedHamiltonian z.integrable
+  perturbation := z.nextPerturbation
+  inverseFrequency := z.step.inverseFrequency
+  input := z.nextInput b
+
+theorem next_domain_subset : (z.next b).domain ⊆ erosion z.domain (beta δ₁ s) :=
+  z.step.domain_subset
+
+theorem next_identity (x : ComplexPhaseSpace n) :
+    z.integrable (z.step.transformation.toFun x).1 +
+      z.perturbation.toFun (z.step.transformation.toFun x) =
+      (z.next b).integrable x.1 + (z.next b).perturbation.toFun x := z.step.identity x
+
+end State
+end KamProject.Arnold1963.Iteration
diff --git a/LeanPool/ArnoldKAM/Arnold1963/Iteration/StepInterface.lean b/LeanPool/ArnoldKAM/Arnold1963/Iteration/StepInterface.lean
new file mode 100644
index 0000000000..b205978856
--- /dev/null
+++ b/LeanPool/ArnoldKAM/Arnold1963/Iteration/StepInterface.lean
@@ -0,0 +1,46 @@
+/-
+Copyright (c) 2026 Bingqi Yu. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Bingqi Yu
+-/
+
+module
+
+public import LeanPool.ArnoldKAM.Arnold1963.Iteration.UniformBounds
+public import LeanPool.ArnoldKAM.Arnold1963.Step.InductiveIteration
+
+/-!
+Connect the analytic single-step result to the exact iteration parameter recurrence.
+-/
+
+@[expose] public section
+noncomputable section
+open Set
+open scoped NNReal ENNReal
+namespace KamProject.Arnold1963.Iteration
+
+theorem remainder_eq_next_parameter {δ₁ : ℝ≥0} (hδ : 0 < δ₁) (n s : ℕ) :
+    iterationRemainderBound n (perturbation n δ₁ s) (delta δ₁ s) (beta δ₁ s) =
+      perturbation n δ₁ (s + 1) := remainder_eq_next hδ n s
+
+theorem result_measure_uniform {n s : ℕ} {G Ωbase G₀ : Set (ComplexSpace n)}
+    {A₀ g₀ : ComplexSpace n → ComplexSpace n} {ρ δ₁ θ₀ Θ₀ : ℝ≥0}
+    {K N₀ D : ℝ} {a : ComplexSpace n → ℂ} {f : AnalyticPhaseFunction n G ρ}
+    {g : ComplexSpace n → ComplexSpace n} (r : ResonanceDomainState n K N₀)
+    (i : IterationInput (Ω := r.domain Ωbase) a f g
+      (beta δ₁ s) (delta δ₁ s) (gamma n δ₁ s) (lower θ₀ δ₁ s) (upper Θ₀ δ₁ s)
+      K (perturbation n δ₁ s))
+    (c₀ : AnalyticFrequencyChart A₀ g₀ G₀ Ωbase)
+    (hθ₀ : 0 < θ₀) (hδ₁ : δ₁ < 1 / 4)
+    (hupper : ∀ p ∈ G₀, ‖fderiv ℂ A₀ p‖ ≤ (Θ₀ : ℝ))
+    (hD : TypeD Ωbase D) (hN₀ : 1 ≤ N₀)
+    (hNN : N₀ ≤ fundamentalCutoff (gamma n δ₁ s) (2 * perturbation n δ₁ s)) :
+    realVolume (G \ i.result.domain) ≤ ENNReal.ofReal ((2 * (Θ₀ : ℝ) / θ₀) ^ n) *
+      (ENNReal.ofReal (resonanceLossConstant n * D *
+        (K * newShellBudget N₀ (fundamentalCutoff (gamma n δ₁ s) (2 * perturbation n δ₁ s)) +
+          (((6 + 7 * upper Θ₀ δ₁ s) * beta δ₁ s : ℝ≥0) : ℝ) *
+            (fundamentalCutoff (gamma n δ₁ s) (2 * perturbation n δ₁ s)) ^ n)) * realVolume G₀) :=
+  i.result_measure_uniform r c₀ hθ₀ (lower_gt_half hθ₀ hδ₁ s).le Θ₀.coe_nonneg
+    hupper hD hN₀ hNN
+
+end KamProject.Arnold1963.Iteration
diff --git a/LeanPool/ArnoldKAM/Arnold1963/Iteration/TotalBudget.lean b/LeanPool/ArnoldKAM/Arnold1963/Iteration/TotalBudget.lean
new file mode 100644
index 0000000000..2e89f944bd
--- /dev/null
+++ b/LeanPool/ArnoldKAM/Arnold1963/Iteration/TotalBudget.lean
@@ -0,0 +1,133 @@
+/-
+Copyright (c) 2026 Bingqi Yu. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Bingqi Yu
+-/
+
+module
+
+public import LeanPool.ArnoldKAM.Arnold1963.Iteration.CutoffBudget
+public import LeanPool.ArnoldKAM.Arnold1963.Iteration.NumericalConditions
+public import LeanPool.ArnoldKAM.Arnold1963.Iteration.ShellSum
+
+/-!
+Summable total action-domain loss, including resonance shells and boundary layers.
+-/
+
+@[expose] public section
+noncomputable section
+open scoped NNReal ENNReal
+namespace KamProject.Arnold1963.Iteration
+
+/-- The frequency-space loss budget combining new resonance shells and geometric erosion. -/
+def rawLoss (n : ℕ) (δ₁ Θ₀ : ℝ≥0) (κ : ℝ) (s : ℕ) : ℝ :=
+  (κ * (δ₁ : ℝ)) * newShellBudget (previousCutoff n δ₁ s) (cutoff n δ₁ s) +
+    (((6 + 7 * upper Θ₀ δ₁ s) * beta δ₁ s : ℝ≥0) : ℝ) * cutoff n δ₁ s ^ n
+
+/-- The coefficient transporting the frequency-space loss budget to real action volume. -/
+def actionLossFactor (n : ℕ) (θ₀ Θ₀ : ℝ≥0) (D : ℝ) : ℝ :=
+  (2 * (Θ₀ : ℝ) / θ₀) ^ n * resonanceLossConstant n * D
+
+/-- The extended nonnegative action-volume loss budget for one iteration stage. -/
+def lossBudget (n : ℕ) (δ₁ θ₀ Θ₀ : ℝ≥0) (κ D : ℝ) (s : ℕ) : ℝ≥0∞ :=
+  ENNReal.ofReal (actionLossFactor n θ₀ Θ₀ D * rawLoss n δ₁ Θ₀ κ s)
+
+namespace InitialParameters
+variable {n : ℕ} {δ₁ θ₀ Θ₀ ρ₀ : ℝ≥0} {κ D : ℝ}
+  (b : InitialParameters n δ₁ θ₀ Θ₀ ρ₀ κ D)
+include b
+
+theorem tube_budget (s : ℕ) :
+    (((6 + 7 * upper Θ₀ δ₁ s) * beta δ₁ s : ℝ≥0) : ℝ) * cutoff n δ₁ s ^ n <
+      (delta δ₁ s : ℝ) := by
+  have hd : (0 : ℝ) < delta δ₁ s := b.delta_step_pos s
+  have hD := (threshold5_bounds b.small).2.2.1
+  have hh : (δ₁ : ℝ) < 1 / (6 + 14 * (Θ₀ : ℝ)) := (lt_min_iff.mp (lt_min_iff.mp hD).2).1
+  have hbase := (lt_div_iff₀ (by positivity : (0 : ℝ) < 6 + 14 * (Θ₀ : ℝ))).mp hh
+  have hu := upper_lt_twice (zero_lt_one.trans b.upper_gt_one) b.delta_quarter s
+  have hA : (6 + 7 * (upper Θ₀ δ₁ s : ℝ)) * (delta δ₁ s : ℝ) < 1 := by
+    have hh' := mul_le_mul_of_nonneg_left
+      (show (delta δ₁ s : ℝ) ≤ δ₁ from b.delta_step_le s)
+      (show (0 : ℝ) ≤ 6 + 14 * (Θ₀ : ℝ) by positivity)
+    have hu' := mul_lt_mul_of_pos_right (show
+      6 + 7 * (upper Θ₀ δ₁ s : ℝ) < 6 + 14 * (Θ₀ : ℝ) by linarith) hd
+    nlinarith
+  have hN := mul_lt_mul_of_pos_left (b.cutoff_budget s) (sq_pos_of_pos hd)
+  have hNA := mul_lt_mul_of_pos_left hN
+    (show (0 : ℝ) < 6 + 7 * (upper Θ₀ δ₁ s : ℝ) by positivity)
+  have hAd := mul_lt_mul_of_pos_right hA hd
+  simp only [NNReal.coe_mul, NNReal.coe_add, NNReal.coe_ofNat, beta, NNReal.coe_pow]
+  nlinarith only [hNA, hAd]
+
+theorem rawLoss_nonneg (s : ℕ) : 0 ≤ rawLoss n δ₁ Θ₀ κ s := by
+  unfold rawLoss
+  exact add_nonneg (mul_nonneg b.divisor_pos.le (newShellBudget_nonneg _ _))
+    (mul_nonneg (NNReal.coe_nonneg _) (pow_nonneg (zero_le_one.trans (b.cutoff_gt_one s).le) n))
+
+theorem rawLoss_le (s : ℕ) : rawLoss n δ₁ Θ₀ κ s ≤
+    (κ * (δ₁ : ℝ)) * newShellBudget (previousCutoff n δ₁ s) (cutoff n δ₁ s) +
+      (delta δ₁ s : ℝ) := add_le_add le_rfl (b.tube_budget s).le
+
+theorem rawLoss_summable : Summable (rawLoss n δ₁ Θ₀ κ) := by
+  apply Summable.of_nonneg_of_le b.rawLoss_nonneg b.rawLoss_le
+  exact ((shell_summable (previousCutoff n δ₁) b.previousCutoff_strictMono.monotone rfl).mul_left
+    (κ * (δ₁ : ℝ))).add (decay_summable b.delta_quarter.le)
+
+theorem rawLoss_tsum_lt : (∑' s, rawLoss n δ₁ Θ₀ κ s) < 4 * (δ₁ : ℝ) := by
+  have hs : Summable (fun s => newShellBudget (previousCutoff n δ₁ s) (cutoff n δ₁ s)) :=
+    shell_summable (previousCutoff n δ₁) b.previousCutoff_strictMono.monotone rfl
+  have hd : Summable (fun s => (delta δ₁ s : ℝ)) := decay_summable b.delta_quarter.le
+  have hle := b.rawLoss_summable.tsum_le_tsum b.rawLoss_le
+    ((hs.mul_left (κ * (δ₁ : ℝ))).add hd)
+  rw [Summable.tsum_add (hs.mul_left _) hd, tsum_mul_left] at hle
+  have hshell := mul_le_mul_of_nonneg_left
+    (shell_tsum_le_two (previousCutoff n δ₁) b.previousCutoff_strictMono.monotone rfl)
+    b.divisor_pos.le
+  have hdelta := decay_tsum_le b.delta_quarter.le
+  have hstrict := mul_lt_mul_of_pos_right b.fraction_lt_one
+    (show (0 : ℝ) < δ₁ from b.delta_pos)
+  change (∑' s, (delta δ₁ s : ℝ)) ≤ 2 * (δ₁ : ℝ) at hdelta
+  change (κ * (δ₁ : ℝ)) *
+    (∑' s, newShellBudget (previousCutoff n δ₁ s) (cutoff n δ₁ s)) ≤ _ at hshell
+  nlinarith only [hle, hshell, hdelta, hstrict]
+
+theorem actionLossFactor_pos : 0 < actionLossFactor n θ₀ Θ₀ D := by
+  have hn : (0 : ℝ) < n := by exact_mod_cast b.dimension_pos
+  have hθ : (0 : ℝ) < θ₀ := b.lower_pos
+  have hΘ : (0 : ℝ) < Θ₀ := zero_lt_one.trans b.upper_gt_one
+  unfold actionLossFactor resonanceLossConstant
+  positivity [b.type_constant_pos]
+
+theorem initial_measure_budget : 4 * (δ₁ : ℝ) * actionLossFactor n θ₀ Θ₀ D < κ := by
+  have hθ : (θ₀ : ℝ) ≠ 0 := ne_of_gt b.lower_pos
+  have hΘ : (Θ₀ : ℝ) ≠ 0 := ne_of_gt (zero_lt_one.trans b.upper_gt_one)
+  have hD : D ≠ 0 := b.type_constant_pos.ne'
+  have hn : (n : ℝ) ≠ 0 := by exact_mod_cast b.dimension_pos.ne'
+  have hpow : (4 : ℝ) ^ (n + 2) = 4 * 2 ^ n * 2 ^ (n + 2) := by
+    rw [show (4 : ℝ) = 2 ^ 2 by norm_num]
+    simp only [← pow_mul, ← pow_add]
+    congr 1
+    omega
+  have he : ((4 : ℝ) ^ (n + 2))⁻¹ * κ * (θ₀ : ℝ) ^ n /
+      ((Θ₀ : ℝ) ^ n * D * n) = κ / (4 * actionLossFactor n θ₀ Θ₀ D) := by
+    unfold actionLossFactor resonanceLossConstant
+    rw [div_pow, mul_pow, hpow]
+    field_simp
+  have hs := (lt_min_iff.mp (lt_min_iff.mp (threshold5_bounds b.small).2.2.1).2).2
+  rw [he] at hs
+  have hh := (lt_div_iff₀ (mul_pos (by norm_num) b.actionLossFactor_pos)).mp hs
+  nlinarith only [hh]
+
+theorem total_budget : actionLossFactor n θ₀ Θ₀ D * (∑' s, rawLoss n δ₁ Θ₀ κ s) < κ := by
+  have hh := mul_lt_mul_of_pos_left b.rawLoss_tsum_lt b.actionLossFactor_pos
+  nlinarith only [hh, b.initial_measure_budget]
+
+theorem lossBudget_tsum_lt : (∑' s, lossBudget n δ₁ θ₀ Θ₀ κ D s) < ENNReal.ofReal κ := by
+  unfold lossBudget
+  rw [← ENNReal.ofReal_tsum_of_nonneg
+    (fun s => mul_nonneg b.actionLossFactor_pos.le (b.rawLoss_nonneg s))
+    (b.rawLoss_summable.mul_left _), tsum_mul_left]
+  exact (ENNReal.ofReal_lt_ofReal_iff b.fraction_pos).mpr b.total_budget
+
+end InitialParameters
+end KamProject.Arnold1963.Iteration
diff --git a/LeanPool/ArnoldKAM/Arnold1963/Iteration/UniformBounds.lean b/LeanPool/ArnoldKAM/Arnold1963/Iteration/UniformBounds.lean
new file mode 100644
index 0000000000..b65c8b0b66
--- /dev/null
+++ b/LeanPool/ArnoldKAM/Arnold1963/Iteration/UniformBounds.lean
@@ -0,0 +1,134 @@
+/-
+Copyright (c) 2026 Bingqi Yu. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Bingqi Yu
+-/
+
+module
+
+public import LeanPool.ArnoldKAM.Arnold1963.Iteration.Parameters
+
+/-!
+Uniform positive derivative and angle-width bounds for all stages of the iteration.
+-/
+
+@[expose] public section
+noncomputable section
+open scoped NNReal
+namespace KamProject.Arnold1963.Iteration
+
+/-- The lower frequency-derivative bound after the accumulated multiplicative losses. -/
+def lower (θ₀ δ₁ : ℝ≥0) (s : ℕ) : ℝ≥0 :=
+  θ₀ * ∏ j ∈ Finset.range s, (1 - delta δ₁ j)
+/-- The upper frequency-derivative bound after the accumulated multiplicative growth. -/
+def upper (Θ₀ δ₁ : ℝ≥0) (s : ℕ) : ℝ≥0 :=
+  Θ₀ * ∏ j ∈ Finset.range s, (1 + delta δ₁ j)
+/-- The remaining angle-strip width after all preceding strip losses. -/
+def width (n : ℕ) (ρ₀ δ₁ : ℝ≥0) (s : ℕ) : ℝ≥0 :=
+  ρ₀ - 3 * ∑ j ∈ Finset.range s, gamma n δ₁ j
+
+@[simp] theorem lower_zero (θ₀ δ₁ : ℝ≥0) : lower θ₀ δ₁ 0 = θ₀ := by simp [lower]
+@[simp] theorem upper_zero (Θ₀ δ₁ : ℝ≥0) : upper Θ₀ δ₁ 0 = Θ₀ := by simp [upper]
+@[simp] theorem width_zero (n : ℕ) (ρ₀ δ₁ : ℝ≥0) : width n ρ₀ δ₁ 0 = ρ₀ := by
+  simp [width]
+
+theorem lower_succ (θ₀ δ₁ : ℝ≥0) (s : ℕ) :
+    lower θ₀ δ₁ (s + 1) = lower θ₀ δ₁ s * (1 - delta δ₁ s) := by
+  simp [lower, Finset.prod_range_succ, mul_assoc]
+
+theorem upper_succ (Θ₀ δ₁ : ℝ≥0) (s : ℕ) :
+    upper Θ₀ δ₁ (s + 1) = upper Θ₀ δ₁ s * (1 + delta δ₁ s) := by
+  simp [upper, Finset.prod_range_succ, mul_assoc]
+
+theorem width_succ (n : ℕ) (ρ₀ δ₁ : ℝ≥0) (s : ℕ) :
+    width n ρ₀ δ₁ (s + 1) = width n ρ₀ δ₁ s - 3 * gamma n δ₁ s := by
+  simp [width, Finset.sum_range_succ, mul_add, tsub_add_eq_tsub_tsub]
+
+private theorem prod_one_sub_lower (u : ℕ → ℝ) (hu : ∀ j, 0 ≤ u j)
+    (hu1 : ∀ j, u j ≤ 1) (s : ℕ) :
+    1 - ∑ j ∈ Finset.range s, u j ≤ ∏ j ∈ Finset.range s, (1 - u j) := by
+  induction s with
+  | zero => simp
+  | succ s ih =>
+    rw [Finset.sum_range_succ, Finset.prod_range_succ]
+    have hm := mul_le_mul_of_nonneg_right ih (sub_nonneg.mpr (hu1 s))
+    have hp := mul_nonneg (Finset.sum_nonneg (fun j _ => hu j) :
+      0 ≤ ∑ j ∈ Finset.range s, u j) (hu s)
+    nlinarith
+
+theorem lower_gt_half {θ₀ δ₁ : ℝ≥0} (hθ : 0 < θ₀) (hδ : δ₁ < 1 / 4) (s : ℕ) :
+    (θ₀ : ℝ) / 2 < (lower θ₀ δ₁ s : ℝ) := by
+  have hδ1 : δ₁ ≤ 1 := hδ.le.trans (by
+    exact_mod_cast (show (1 / 4 : ℝ) ≤ 1 by norm_num))
+  have hd (j : ℕ) : delta δ₁ j ≤ 1 := (decay_le hδ1 j).trans hδ1
+  have he : (lower θ₀ δ₁ s : ℝ) =
+      (θ₀ : ℝ) * ∏ j ∈ Finset.range s, (1 - (delta δ₁ j : ℝ)) := by
+    simp only [lower, NNReal.coe_mul, NNReal.coe_prod]
+    congr 1
+    apply Finset.prod_congr rfl
+    intro j _
+    exact NNReal.coe_sub (hd j)
+  rw [he]
+  have hs := decay_sum_le hδ.le s
+  have hp := prod_one_sub_lower (fun j => (delta δ₁ j : ℝ))
+    (fun j => (delta δ₁ j).coe_nonneg) (fun j => hd j) s
+  have hδ' : (δ₁ : ℝ) < 1 / 4 := hδ
+  have hθ' : (0 : ℝ) < θ₀ := hθ
+  have : (1 / 2 : ℝ) < ∏ j ∈ Finset.range s, (1 - (delta δ₁ j : ℝ)) := by
+    change (∑ j ∈ Finset.range s, (delta δ₁ j : ℝ)) ≤ 2 * (δ₁ : ℝ) at hs
+    linarith
+  nlinarith
+
+theorem upper_lt_twice {Θ₀ δ₁ : ℝ≥0} (hΘ : 0 < Θ₀) (hδ : δ₁ < 1 / 4) (s : ℕ) :
+    (upper Θ₀ δ₁ s : ℝ) < 2 * (Θ₀ : ℝ) := by
+  have hs := decay_sum_le hδ.le s
+  have hδ' : (δ₁ : ℝ) < 1 / 4 := hδ
+  have hs' : (∑ j ∈ Finset.range s, (delta δ₁ j : ℝ)) < 1 / 2 := by
+    change (∑ j ∈ Finset.range s, (delta δ₁ j : ℝ)) ≤ 2 * (δ₁ : ℝ) at hs
+    linarith
+  have he : Real.exp (1 / 2) < 2 :=
+    (Real.exp_lt_two_add_div_two_sub (by norm_num : (0 : ℝ) < 1 / 2)
+      (by norm_num)).trans (by norm_num)
+  have hp := (Real.prod_one_add_le_exp_sum (Finset.range s)
+    (fun j => (delta δ₁ j).coe_nonneg)).trans_lt ((Real.exp_lt_exp.mpr hs').trans he)
+  simp only [upper, NNReal.coe_mul, NNReal.coe_prod, NNReal.coe_add, NNReal.coe_one]
+  have hΘ' : (0 : ℝ) < Θ₀ := hΘ
+  nlinarith
+
+theorem width_gt_two_fifths {n : ℕ} {ρ₀ δ₁ : ℝ≥0}
+    (hγ : gamma n δ₁ 0 ≤ 1 / 4) (hρ : (gamma n δ₁ 0 : ℝ) < (ρ₀ : ℝ) / 10) (s : ℕ) :
+    2 * (ρ₀ : ℝ) / 5 < (width n ρ₀ δ₁ s : ℝ) := by
+  have hs : (∑ j ∈ Finset.range s, (gamma n δ₁ j : ℝ)) ≤
+      2 * (gamma n δ₁ 0 : ℝ) := by
+    simpa only [gamma, decay_zero] using decay_sum_le (by
+      simpa only [gamma, decay_zero] using hγ) s
+  have hρ0 := ρ₀.coe_nonneg
+  have hb : 3 * (∑ j ∈ Finset.range s, gamma n δ₁ j) ≤ ρ₀ := by
+    have : 3 * (∑ j ∈ Finset.range s, (gamma n δ₁ j : ℝ)) ≤ (ρ₀ : ℝ) := by linarith
+    exact_mod_cast this
+  simp only [width, NNReal.coe_sub hb, NNReal.coe_mul, NNReal.coe_ofNat, NNReal.coe_sum]
+  linarith
+
+theorem uniform_bounds_of_threshold {n : ℕ} (hn : 0 < n)
+    {θ₀ Θ₀ ρ₀ δ₁ : ℝ≥0} {κ D : ℝ} (hθ : 0 < θ₀) (hΘ : 0 < Θ₀)
+    (hδ : (δ₁ : ℝ) < threshold5 n θ₀ Θ₀ ρ₀ κ D) (s : ℕ) :
+    (θ₀ : ℝ) / 2 < (lower θ₀ δ₁ s : ℝ) ∧
+      (upper Θ₀ δ₁ s : ℝ) < 2 * (Θ₀ : ℝ) ∧
+      2 * (ρ₀ : ℝ) / 5 < (width n ρ₀ δ₁ s : ℝ) ∧
+      3 * (gamma n δ₁ s : ℝ) < (width n ρ₀ δ₁ s : ℝ) := by
+  have hd := delta_initial_lt_quarter hδ
+  obtain ⟨hγρ, hγ4⟩ := gamma_initial_bounds hn (threshold5_bounds hδ).2.1
+  have hγ4' : gamma n δ₁ 0 ≤ 1 / 4 := by exact_mod_cast hγ4.le
+  have hw := width_gt_two_fifths hγ4' hγρ s
+  have hγ1 : δ₁ ^ (1 / (4 * (n : ℝ))) ≤ 1 := by
+    have : (gamma n δ₁ 0 : ℝ) ≤ 1 := by linarith
+    simp only [gamma, decay_zero] at this
+    exact_mod_cast this
+  have hg : (gamma n δ₁ s : ℝ) ≤ (gamma n δ₁ 0 : ℝ) := by
+    simp only [gamma, decay_zero]
+    exact_mod_cast decay_le hγ1 s
+  refine ⟨lower_gt_half hθ hd s, upper_lt_twice hΘ hd s, hw, ?_⟩
+  have := ρ₀.coe_nonneg
+  linarith
+
+end KamProject.Arnold1963.Iteration
diff --git a/LeanPool/ArnoldKAM/Arnold1963/Main/FiniteLocalization.lean b/LeanPool/ArnoldKAM/Arnold1963/Main/FiniteLocalization.lean
new file mode 100644
index 0000000000..f95befeba6
--- /dev/null
+++ b/LeanPool/ArnoldKAM/Arnold1963/Main/FiniteLocalization.lean
@@ -0,0 +1,128 @@
+/-
+Copyright (c) 2026 Bingqi Yu. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Bingqi Yu
+-/
+
+module
+
+public import LeanPool.ArnoldKAM.Arnold1963.Geometry.LocalizationCover
+public import LeanPool.ArnoldKAM.Arnold1963.Main.LocalThreshold
+
+/-!
+Finite localization and a perturbation-independent common threshold. Patches may have
+different numerical bounds. The loss budget accounts for the number of patches rather than
+adding overlapping patch volumes as though they were disjoint.
+-/
+
+@[expose] public section
+noncomputable section
+open Set MeasureTheory
+open scoped NNReal ENNReal
+namespace KamProject.Arnold1963
+
+/-- A finite collection of Hamiltonian patches with a common threshold and global measure budget. -/
+structure FiniteLocalization (n : ℕ) (H₀ : ComplexSpace n → ℂ)
+    (ambient : Set (ComplexSpace n)) (ρ : ℝ≥0) (κ : ℝ) where
+  dimension_pos : 0 < n
+  /-- The finite set of local Hamiltonian patches used for the global construction. -/
+  patches : Finset (HamiltonianPatch n H₀ ambient)
+  /-- The common positive angle width available in every patch. -/
+  width : ℝ≥0
+  width_pos : 0 < width
+  width_le_one : width ≤ 1
+  width_le : width ≤ ρ
+  /-- The per-patch relative measure-loss tolerance. -/
+  fraction : ℝ
+  fraction_pos : 0 < fraction
+  fraction_lt_one : fraction < 1
+  fraction_le : fraction ≤ κ
+  /-- The relative volume allowed to escape the finite patch cover. -/
+  coverError : ℝ
+  coverError_pos : 0 < coverError
+  coverError_lt_one : coverError < 1
+  cover : volume (realSlice ambient \ ⋃ c ∈ patches, realSlice c.domain) <
+    ENNReal.ofReal coverError * volume (realSlice ambient)
+  budget : coverError + (patches.card : ℝ) * fraction ≤ κ
+  /-- The positive perturbation threshold valid uniformly across the patch collection. -/
+  threshold : ℝ
+  threshold_pos : 0 < threshold
+  threshold_le : ∀ c ∈ patches, threshold ≤ c.threshold width fraction
+
+theorem GlobalHamiltonianData.exists_finiteLocalization {n : ℕ}
+    {H₀ : ComplexSpace n → ℂ} {ambient : Set (ComplexSpace n)}
+    (h : GlobalHamiltonianData n H₀ ambient) {ρ : ℝ≥0} {κ : ℝ}
+    (hρ : 0 < ρ) (hκ : 0 < κ) : Nonempty (FiniteLocalization n H₀ ambient ρ κ) := by
+  let τ := min κ 1
+  have hτ : 0 < τ := lt_min hκ zero_lt_one
+  have hτκ : τ ≤ κ := min_le_left _ _
+  have hτ1 : τ ≤ 1 := min_le_right _ _
+  obtain ⟨s, hs⟩ := h.exists_cover (τ / 4) (by positivity)
+  let η := τ / (4 * ((s.card : ℝ) + 1))
+  have hm : (0 : ℝ) ≤ s.card := Nat.cast_nonneg _
+  have hd : 0 < 4 * ((s.card : ℝ) + 1) := by positivity
+  have hη : 0 < η := div_pos hτ hd
+  have heq : η * (4 * ((s.card : ℝ) + 1)) = τ := div_mul_cancel₀ _ hd.ne'
+  have hη1 : η < 1 := by nlinarith
+  have hητ : η ≤ τ := by nlinarith
+  have hb : τ / 4 + (s.card : ℝ) * η ≤ κ := by nlinarith
+  have hw : (0 : ℝ≥0) < min ρ 1 := lt_min hρ zero_lt_one
+  obtain ⟨M, hM, hMs⟩ := HamiltonianPatch.exists_common_threshold s h.dimension_pos hw hη
+  exact ⟨{
+    dimension_pos := h.dimension_pos
+    patches := s
+    width := min ρ 1
+    width_pos := hw
+    width_le_one := min_le_right _ _
+    width_le := min_le_left _ _
+    fraction := η
+    fraction_pos := hη
+    fraction_lt_one := hη1
+    fraction_le := hητ.trans hτκ
+    coverError := τ / 4
+    coverError_pos := by positivity
+    coverError_lt_one := by linarith
+    cover := hs
+    budget := hb
+    threshold := M
+    threshold_pos := hM
+    threshold_le := hMs }⟩
+
+namespace FiniteLocalization
+variable {n : ℕ} {H₀ : ComplexSpace n → ℂ} {ambient : Set (ComplexSpace n)}
+  {ρ : ℝ≥0} {κ : ℝ} (L : FiniteLocalization n H₀ ambient ρ κ)
+
+theorem parameters (c : L.patches) :
+    Iteration.InitialParameters n (c.val.seed L.width L.fraction)
+      c.val.lower c.val.upper L.width L.fraction c.val.typeConstant :=
+  c.val.parameters L.dimension_pos L.width_pos L.width_le_one L.fraction_pos L.fraction_lt_one
+
+/-- The initial iteration data for a perturbation restricted to a selected patch. -/
+def data (f : AnalyticPhaseFunction n ambient ρ) (hf : f.uniformNorm ≤ L.threshold)
+    (c : L.patches) :=
+  c.val.initialData L.dimension_pos L.width_pos L.fraction_pos f L.width_le
+    (hf.trans (L.threshold_le c c.property))
+
+theorem local_result (f : AnalyticPhaseFunction n ambient ρ) (hf : f.uniformNorm ≤ L.threshold)
+    (c : L.patches) : LocalKAMResult (L.parameters c) (L.data f hf c) := localKAM _ _
+
+theorem hamiltonian_zero (f : AnalyticPhaseFunction n ambient ρ) (hf : f.uniformNorm ≤ L.threshold)
+    (c : L.patches) (z : ComplexPhaseSpace n) :
+    (L.data f hf c).hamiltonian (L.parameters c) 0 z = H₀ z.1 + f.toFun z := rfl
+
+theorem patches_nonempty : L.patches.Nonempty := by
+  classical
+  by_contra he
+  have hempty : L.patches = ∅ := Finset.not_nonempty_iff_eq_empty.mp he
+  have hh := L.cover
+  simp only [hempty, Finset.notMem_empty, iUnion_of_empty, iUnion_empty, sdiff_empty] at hh
+  have hle : ENNReal.ofReal L.coverError * volume (realSlice ambient) ≤
+      volume (realSlice ambient) := by
+    calc
+      _ ≤ 1 * volume (realSlice ambient) :=
+        mul_le_mul' (ENNReal.ofReal_le_one.mpr L.coverError_lt_one.le) le_rfl
+      _ = _ := one_mul _
+  exact (not_lt_of_ge hle) hh
+
+end FiniteLocalization
+end KamProject.Arnold1963
diff --git a/LeanPool/ArnoldKAM/Arnold1963/Main/GlobalCover.lean b/LeanPool/ArnoldKAM/Arnold1963/Main/GlobalCover.lean
new file mode 100644
index 0000000000..134a78cfb1
--- /dev/null
+++ b/LeanPool/ArnoldKAM/Arnold1963/Main/GlobalCover.lean
@@ -0,0 +1,186 @@
+/-
+Copyright (c) 2026 Bingqi Yu. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Bingqi Yu
+-/
+
+module
+
+public import LeanPool.ArnoldKAM.Arnold1963.Main.FiniteLocalization
+public import LeanPool.ArnoldKAM.Arnold1963.Measure.FiniteCover
+
+/-!
+The union of actual local KAM outputs and a strict global bad-set measure bound. Local
+frequency labels retain their chart branches; cross-chart disjointness is proved separately.
+-/
+
+@[expose] public section
+noncomputable section
+open Set MeasureTheory
+open scoped NNReal ENNReal
+namespace KamProject.Arnold1963
+local instance : Fact (0 < 2 * Real.pi) := ⟨mul_pos (by norm_num) Real.pi_pos⟩
+
+namespace FiniteLocalization
+variable {n : ℕ} {H₀ : ComplexSpace n → ℂ} {ambient : Set (ComplexSpace n)}
+  {ρ : ℝ≥0} {κ : ℝ} (L : FiniteLocalization n H₀ ambient ρ κ)
+
+/-- The initial real action-angle phase set over the ambient action domain. -/
+def phase (_L : FiniteLocalization n H₀ ambient ρ κ) : Set (RealPhaseSpace n) :=
+  realSlice ambient ×ˢ univ
+
+/-- The union of good sets constructed by the finitely many local iterations. -/
+def goodSet (f : AnalyticPhaseFunction n ambient ρ) (hf : f.uniformNorm ≤ L.threshold) :
+    Set (RealPhaseSpace n) := ⋃ c : L.patches, (L.data f hf c).localF1 (L.parameters c)
+
+/-- The complement of the global good set inside the initial real phase set. -/
+def badSet (f : AnalyticPhaseFunction n ambient ρ) (hf : f.uniformNorm ≤ L.threshold) :
+    Set (RealPhaseSpace n) := L.phase \ L.goodSet f hf
+
+theorem localPhase_subset (f : AnalyticPhaseFunction n ambient ρ)
+    (hf : f.uniformNorm ≤ L.threshold) (c : L.patches) :
+    (L.data f hf c).localPhase ⊆ L.phase := by
+  intro z hz
+  exact ⟨c.val.subset hz.1, hz.2⟩
+
+theorem goodSet_subset (f : AnalyticPhaseFunction n ambient ρ) (hf : f.uniformNorm ≤ L.threshold) :
+    L.goodSet f hf ⊆ L.phase := by
+  intro z hz
+  obtain ⟨c, hc⟩ := mem_iUnion.mp hz
+  exact L.localPhase_subset f hf c ((L.data f hf c).localF1_subset (L.parameters c) hc)
+
+theorem goodSet_compact (f : AnalyticPhaseFunction n ambient ρ)
+    (hf : f.uniformNorm ≤ L.threshold) : IsCompact (L.goodSet f hf) :=
+  isCompact_iUnion fun c => (L.data f hf c).localF1_compact (L.parameters c)
+
+theorem badSet_measurable (hG : IsCompact ambient) (f : AnalyticPhaseFunction n ambient ρ)
+    (hf : f.uniformNorm ≤ L.threshold) : MeasurableSet (L.badSet f hf) :=
+  ((isCompact_realSlice hG).isClosed.measurableSet.prod MeasurableSet.univ).diff
+    (L.goodSet_compact f hf).isClosed.measurableSet
+
+theorem partition (f : AnalyticPhaseFunction n ambient ρ) (hf : f.uniformNorm ≤ L.threshold) :
+    L.goodSet f hf ∪ L.badSet f hf = L.phase ∧ Disjoint (L.goodSet f hf) (L.badSet f hf) := by
+  refine ⟨union_sdiff_cancel (L.goodSet_subset f hf), disjoint_sdiff_right⟩
+
+theorem phase_volume_finite (hG : IsCompact ambient) : volume L.phase ≠ ⊤ := by
+  rw [phase, torus_phase_volume]
+  have hfin : realVolume ambient ≠ ⊤ := by
+    change volume (realSlice ambient) ≠ ⊤
+    exact (isCompact_realSlice hG).measure_ne_top
+  exact ENNReal.mul_ne_top hfin
+    (ENNReal.pow_ne_top ENNReal.ofReal_ne_top)
+
+theorem phase_cover (f : AnalyticPhaseFunction n ambient ρ) (hf : f.uniformNorm ≤ L.threshold) :
+    volume (L.phase \ ⋃ c : L.patches, (L.data f hf c).localPhase) <
+      ENNReal.ofReal L.coverError * volume L.phase := by
+  classical
+  let C : ℝ≥0∞ := ENNReal.ofReal (2 * Real.pi) ^ n
+  have hC : C ≠ 0 := pow_ne_zero _ (ENNReal.ofReal_pos.mpr (mul_pos (by norm_num) Real.pi_pos)).ne'
+  have hCt : C ≠ ⊤ := ENNReal.pow_ne_top ENNReal.ofReal_ne_top
+  have hprod (U : Set (RealSpace n)) :
+      volume (U ×ˢ (univ : Set (RealTorus n))) = volume U * C := by
+    change (volume.prod volume) _ = _
+    rw [Measure.prod_prod]
+    congr 1
+    change (Measure.pi fun _ : Fin n => (volume : Measure (AddCircle (2 * Real.pi)))) univ = _
+    simp [C, Measure.pi_univ, AddCircle.measure_univ]
+  have hs : L.phase \ ⋃ c : L.patches, (L.data f hf c).localPhase =
+      (realSlice ambient \ ⋃ c ∈ L.patches, realSlice c.domain) ×ˢ (univ : Set (RealTorus n)) := by
+    ext z
+    simp [phase, Iteration.InitialData.localPhase, data, HamiltonianPatch.initialData]
+  rw [hs, hprod, phase, hprod, ← mul_assoc]
+  simpa only [mul_comm C] using ENNReal.mul_lt_mul_right hC hCt L.cover
+
+theorem badSet_volume_lt (hG : IsCompact ambient) (f : AnalyticPhaseFunction n ambient ρ)
+    (hf : f.uniformNorm ≤ L.threshold) :
+    volume (L.badSet f hf) < ENNReal.ofReal κ * volume L.phase := by
+  apply measure_complement_finite_union_lt volume L.phase
+    (fun c : L.patches => (L.data f hf c).localPhase)
+    (fun c => (L.data f hf c).localF1 (L.parameters c))
+    L.coverError_pos.le L.fraction_pos.le (L.phase_volume_finite hG) (L.phase_cover f hf)
+  · intro c
+    exact ((L.data f hf c).localF2_volume_lt (L.parameters c)).le.trans
+      (mul_le_mul' le_rfl (measure_mono (L.localPhase_subset f hf c)))
+  · simpa using L.budget
+
+theorem goodSet_eq_tori (f : AnalyticPhaseFunction n ambient ρ)
+    (hf : f.uniformNorm ≤ L.threshold) :
+    L.goodSet f hf = ⋃ c : L.patches,
+      ⋃ ω ∈ (L.data f hf c).retainedRealFrequencies (L.parameters c),
+      (L.data f hf c).frequencyTorus (L.parameters c) ω := by
+  unfold goodSet
+  congr 1
+  funext c
+  exact (L.data f hf c).localF1_eq_frequency_union (L.parameters c)
+
+theorem goodSet_volume_pos (f : AnalyticPhaseFunction n ambient ρ)
+    (hf : f.uniformNorm ≤ L.threshold) : 0 < volume (L.goodSet f hf) := by
+  obtain ⟨c, hc⟩ := L.patches_nonempty
+  let j : L.patches := ⟨c, hc⟩
+  exact (lt_of_le_of_lt zero_le (L.local_result f hf j).large_measure).trans_le
+    (measure_mono (subset_iUnion (fun c => (L.data f hf c).localF1 (L.parameters c)) j))
+
+theorem corrections_small (f : AnalyticPhaseFunction n ambient ρ)
+    (hf : f.uniformNorm ≤ L.threshold) (c : L.patches) {p q : ComplexSpace n}
+    (hp : p ∈ (L.data f hf c).limitDomain (L.parameters c))
+    (hq : q ∈ Iteration.InitialData.commonAngleStrip n L.width) :
+    ‖(L.data f hf c).actionCorrection (L.parameters c) p q‖ < κ ∧
+      ‖(L.data f hf c).angleCorrection (L.parameters c) p q‖ < κ := by
+  have hh := (L.local_result f hf c).corrections_small p hp q hq
+  exact ⟨hh.1.trans_le L.fraction_le, hh.2.trans_le L.fraction_le⟩
+
+theorem orbit_original (f : AnalyticPhaseFunction n ambient ρ) (hf : f.uniformNorm ≤ L.threshold)
+    (c : L.patches) {p : RealSpace n}
+    (hp : p ∈ realSlice ((L.data f hf c).limitDomain (L.parameters c)))
+    (q : RealSpace n) (t : ℝ) :
+    HasDerivAt ((L.data f hf c).orbit (L.parameters c) p q)
+      (hamiltonianVectorField (fun z => H₀ z.1 + f.toFun z)
+        ((L.data f hf c).orbit (L.parameters c) p q t)) t :=
+  (L.data f hf c).orbit_hasDerivAt (L.parameters c) hp q t
+
+theorem orbit_mem_goodSet (f : AnalyticPhaseFunction n ambient ρ)
+    (hf : f.uniformNorm ≤ L.threshold) (c : L.patches) {p : RealSpace n}
+    (hp : p ∈ realSlice ((L.data f hf c).limitDomain (L.parameters c)))
+    (q : RealSpace n) (t : ℝ) :
+    torusProjection (realPartPhase ((L.data f hf c).orbit (L.parameters c) p q t)) ∈
+      L.goodSet f hf := by
+  apply mem_iUnion.mpr
+  refine ⟨c, ?_⟩
+  rw [(L.data f hf c).localF1_eq_union (L.parameters c)]
+  exact mem_iUnion₂.mpr ⟨p, hp, (L.data f hf c).orbit_mem_torus_image (L.parameters c) hp q t⟩
+
+theorem exists_global_orbit (f : AnalyticPhaseFunction n ambient ρ)
+    (hf : f.uniformNorm ≤ L.threshold) {z : RealPhaseSpace n} (hz : z ∈ L.goodSet f hf) :
+    ∃ γ : ℝ → ComplexPhaseSpace n,
+      torusProjection (realPartPhase (γ 0)) = z ∧
+      (∀ t, HasDerivAt γ (hamiltonianVectorField (fun w => H₀ w.1 + f.toFun w) (γ t)) t) ∧
+      (∀ t, complexifyPhase (realPartPhase (γ t)) = γ t) ∧
+      (∀ t, torusProjection (realPartPhase (γ t)) ∈ L.goodSet f hf) := by
+  obtain ⟨c, x, hx, rfl⟩ := mem_iUnion.mp hz
+  let q := (torusRepresentative x).2
+  refine ⟨(L.data f hf c).orbit (L.parameters c) x.1 q, ?_,
+    L.orbit_original f hf c hx.1 q,
+    (L.data f hf c).orbit_real_value (L.parameters c) hx.1 q,
+    L.orbit_mem_goodSet f hf c hx.1 q⟩
+  rw [(L.data f hf c).orbit_initial (L.parameters c)]
+  rfl
+
+end FiniteLocalization
+
+theorem global_kam_cover {n : ℕ} {H₀ : ComplexSpace n → ℂ}
+    {ambient : Set (ComplexSpace n)} (h : GlobalHamiltonianData n H₀ ambient)
+    {ρ : ℝ≥0} {κ : ℝ} (hρ : 0 < ρ) (hκ : 0 < κ) :
+    ∃ L : FiniteLocalization n H₀ ambient ρ κ,
+      ∀ f : AnalyticPhaseFunction n ambient ρ, ∀ hf : f.uniformNorm ≤ L.threshold,
+        IsCompact (L.goodSet f hf) ∧
+        L.goodSet f hf ∪ L.badSet f hf = L.phase ∧
+        Disjoint (L.goodSet f hf) (L.badSet f hf) ∧
+        volume (L.badSet f hf) < ENNReal.ofReal κ * volume L.phase ∧
+        0 < volume (L.goodSet f hf) ∧
+        ∀ c : L.patches, LocalKAMResult (L.parameters c) (L.data f hf c) := by
+  obtain ⟨L⟩ := h.exists_finiteLocalization hρ hκ
+  exact ⟨L, fun f hf => ⟨L.goodSet_compact f hf, (L.partition f hf).1,
+    (L.partition f hf).2, L.badSet_volume_lt h.compact f hf, L.goodSet_volume_pos f hf,
+    L.local_result f hf⟩⟩
+
+end KamProject.Arnold1963
diff --git a/LeanPool/ArnoldKAM/Arnold1963/Main/LocalKAM.lean b/LeanPool/ArnoldKAM/Arnold1963/Main/LocalKAM.lean
new file mode 100644
index 0000000000..ac93e911dc
--- /dev/null
+++ b/LeanPool/ArnoldKAM/Arnold1963/Main/LocalKAM.lean
@@ -0,0 +1,176 @@
+/-
+Copyright (c) 2026 Bingqi Yu. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Bingqi Yu
+-/
+
+module
+
+public import LeanPool.ArnoldKAM.Arnold1963.Tori.Embedding
+public import LeanPool.ArnoldKAM.Arnold1963.Tori.Parameterization
+
+/-!
+Local analytic invariant tori and the physical measure decomposition within one initial
+frequency chart, obtained from the actual infinite iteration.
+-/
+
+@[expose] public section
+noncomputable section
+open Set Function MeasureTheory Topology
+open scoped NNReal ENNReal
+namespace KamProject.Arnold1963
+open Iteration
+local instance : Fact (0 < 2 * Real.pi) := ⟨mul_pos (by norm_num) Real.pi_pos⟩
+
+namespace Iteration.InitialData
+variable {n : ℕ} {Ω₀ : Set (ComplexSpace n)} {δ₁ θ₀ Θ₀ ρ₀ : ℝ≥0} {κ D : ℝ}
+  (b : InitialParameters n δ₁ θ₀ Θ₀ ρ₀ κ D)
+  (h : InitialData n Ω₀ δ₁ θ₀ Θ₀ ρ₀ D)
+
+/-- The initial real action-angle phase set of a local iteration. -/
+def localPhase : Set (RealPhaseSpace n) := realSlice h.domain ×ˢ univ
+/-- The image of the limiting action domain and real torus under the limiting transformation. -/
+def localF1 : Set (RealPhaseSpace n) :=
+  h.torusLimitMap b '' (realSlice (h.limitDomain b) ×ˢ (univ : Set (RealTorus n)))
+/-- The complement of the local good set inside the initial local phase set. -/
+def localF2 : Set (RealPhaseSpace n) := h.localPhase \ h.localF1 b
+
+theorem localF1_subset : h.localF1 b ⊆ h.localPhase := (h.torusLimitMap_maps b).image_subset
+
+theorem localF1_eq_union : h.localF1 b =
+    ⋃ p ∈ realSlice (h.limitDomain b), h.invariantTorus b p := by
+  ext z
+  constructor
+  · rintro ⟨⟨p, q⟩, hpq, rfl⟩
+    exact mem_iUnion.mpr ⟨p, mem_iUnion.mpr ⟨hpq.1, ⟨(p, q), ⟨rfl, mem_univ _⟩, rfl⟩⟩⟩
+  · intro hz
+    rcases mem_iUnion.mp hz with ⟨p, hz⟩
+    rcases mem_iUnion.mp hz with ⟨hp, x, hx, rfl⟩
+    exact ⟨x, ⟨(show x.1 = p from hx.1) ▸ hp, mem_univ _⟩, rfl⟩
+
+theorem localF1_compact : IsCompact (h.localF1 b) := h.torusLimitMap_image_compact b
+
+theorem local_partition : h.localF1 b ∪ h.localF2 b = h.localPhase ∧
+    Disjoint (h.localF1 b) (h.localF2 b) := by
+  constructor
+  · ext z
+    have hs := h.localF1_subset b (a := z)
+    change (z ∈ h.localF1 b ∨ z ∈ h.localPhase ∧ z ∉ h.localF1 b) ↔ z ∈ h.localPhase
+    tauto
+  · exact disjoint_sdiff_right
+
+theorem localPhase_volume_finite : volume h.localPhase ≠ ⊤ := by
+  rw [localPhase, torus_phase_volume]
+  exact ENNReal.mul_ne_top h.volume_finite (ENNReal.pow_ne_top ENNReal.ofReal_ne_top)
+
+theorem localF2_volume_lt : volume (h.localF2 b) < ENNReal.ofReal κ * volume h.localPhase := by
+  have hfin := h.localPhase_volume_finite
+  have hF1fin := ne_top_of_le_ne_top hfin (measure_mono (h.localF1_subset b))
+  have hefin : ENNReal.ofReal κ * volume h.localPhase ≠ ⊤ :=
+    ENNReal.mul_ne_top ENNReal.ofReal_ne_top hfin
+  have hh := ENNReal.add_lt_add_right hefin (h.torusLimitMap_volume_gt b)
+  change ENNReal.ofReal (1 - κ) * volume h.localPhase +
+    ENNReal.ofReal κ * volume h.localPhase <
+    volume (h.localF1 b) + ENNReal.ofReal κ * volume h.localPhase at hh
+  rw [← add_mul, ← ENNReal.ofReal_add (sub_nonneg.mpr b.fraction_lt_one.le)
+    b.fraction_pos.le, sub_add_cancel, ENNReal.ofReal_one, one_mul] at hh
+  exact measure_sdiff_lt_of_lt_add (h.localF1_compact b).isClosed.measurableSet.nullMeasurableSet
+    (h.localF1_subset b) hF1fin hh
+
+/-- The invariant torus associated with a complex frequency via its real action label. -/
+def frequencyTorus (ω : ComplexSpace n) : Set (RealPhaseSpace n) :=
+  h.invariantTorus b (h.realFrequencyLabel b ω)
+
+theorem localF1_eq_frequency_union : h.localF1 b =
+    ⋃ ω ∈ h.retainedRealFrequencies b, h.frequencyTorus b ω := by
+  rw [h.localF1_eq_union b]
+  ext z
+  simp only [mem_iUnion]
+  constructor
+  · rintro ⟨p, hp, hz⟩
+    refine ⟨h.limitFrequency b (complexify p), ⟨complexify p, ⟨p, hp, rfl⟩, rfl⟩, ?_⟩
+    simpa only [frequencyTorus, realFrequencyLabel, h.frequencyLabel_left b hp,
+      realPart_complexify] using hz
+  · rintro ⟨ω, hω, hz⟩
+    exact ⟨h.realFrequencyLabel b ω, (h.realFrequencyLabel_spec b hω).1, hz⟩
+
+theorem frequencyTorus_disjoint {ω ω' : ComplexSpace n}
+    (hω : ω ∈ h.retainedRealFrequencies b) (hω' : ω' ∈ h.retainedRealFrequencies b)
+    (hne : ω ≠ ω') : Disjoint (h.frequencyTorus b ω) (h.frequencyTorus b ω') := by
+  have hs := h.realFrequencyLabel_spec b hω
+  have hs' := h.realFrequencyLabel_spec b hω'
+  apply h.invariantTorus_disjoint b hs.1 hs'.1
+  intro he
+  apply hne
+  rw [← hs.2.1, ← hs'.2.1, he]
+
+theorem frequency_orbit {ω : ComplexSpace n} (hω : ω ∈ h.retainedRealFrequencies b)
+    (q : RealSpace n) :
+    (∀ t : ℝ, h.orbit b (h.realFrequencyLabel b ω) q t =
+      h.frequencyParameterization b ω (complexify q + (t : ℂ) • ω)) ∧
+    (∀ t : ℝ, HasDerivAt (h.orbit b (h.realFrequencyLabel b ω) q)
+      (h.vectorField b 0 (h.orbit b (h.realFrequencyLabel b ω) q t)) t) ∧
+    (∀ t : ℝ, torusProjection (realPartPhase (h.orbit b (h.realFrequencyLabel b ω) q t)) ∈
+      h.frequencyTorus b ω) ∧
+    (∀ k : FourierIndex n, k ≠ 0 → indexPairing k ω ≠ 0) := by
+  have hs := h.realFrequencyLabel_spec b hω
+  refine ⟨?_, h.orbit_hasDerivAt b hs.1 q, h.orbit_mem_torus_image b hs.1 q, ?_⟩
+  · intro t
+    unfold orbit frequencyParameterization
+    rw [hs.2.1, hs.2.2]
+  · intro k hk
+    simpa only [hs.2.1] using h.limitFrequency_no_integer_relation b hs.1 k hk
+
+end Iteration.InitialData
+
+/-- The local KAM conclusion, including nonempty limiting domains and disjoint embedded tori. -/
+structure LocalKAMResult {n : ℕ} {Ω₀ : Set (ComplexSpace n)} {δ₁ θ₀ Θ₀ ρ₀ : ℝ≥0}
+    {κ D : ℝ} (b : InitialParameters n δ₁ θ₀ Θ₀ ρ₀ κ D)
+    (h : InitialData n Ω₀ δ₁ θ₀ Θ₀ ρ₀ D) : Prop where
+  nonempty : (realSlice (h.limitDomain b)).Nonempty
+  frequency_injective : InjOn (h.limitFrequency b) (h.limitDomain b)
+  embedding : ∀ p ∈ realSlice (h.limitDomain b), IsClosedEmbedding (h.torusEmbedding b p)
+  analytic_lift : ∀ p ∈ h.limitDomain b,
+    AnalyticOnNhd ℂ (fun q => h.limitMap b (p, q)) (InitialData.commonAngleStrip n ρ₀)
+  immersion : ∀ p ∈ h.limitDomain b, ∀ q ∈ angleStrip n (ρ₀ / 6),
+    Injective (fderiv ℂ (fun q => h.limitMap b (p, q)) q)
+  angle_bijective : ∀ p ∈ realSlice (h.limitDomain b), Bijective (h.torusAngleMap b p)
+  inverse_analytic : ∀ p ∈ realSlice (h.limitDomain b), ∀ Q : RealSpace n,
+    AnalyticAt ℂ (h.complexAngleInverse b (complexify p)) (complexify Q)
+  corrections_small : ∀ p ∈ h.limitDomain b, ∀ q ∈ InitialData.commonAngleStrip n ρ₀,
+    ‖h.actionCorrection b p q‖ < κ ∧ ‖h.angleCorrection b p q‖ < κ
+  disjoint : ∀ p ∈ realSlice (h.limitDomain b), ∀ p' ∈ realSlice (h.limitDomain b), p ≠ p' →
+    Disjoint (h.invariantTorus b p) (h.invariantTorus b p')
+  invariant_orbits : ∀ p ∈ realSlice (h.limitDomain b), ∀ q : RealSpace n, ∀ t : ℝ,
+    HasDerivAt (h.orbit b p q) (h.vectorField b 0 (h.orbit b p q t)) t ∧
+    torusProjection (realPartPhase (h.orbit b p q t)) ∈ h.invariantTorus b p
+  nonresonance : ∀ p ∈ h.limitDomain b, ∀ k : FourierIndex n, k ≠ 0 →
+    indexPairing k (h.limitFrequency b p) ≠ 0
+  union_eq : h.localF1 b = ⋃ ω ∈ h.retainedRealFrequencies b, h.frequencyTorus b ω
+  compact : IsCompact (h.localF1 b)
+  partition : h.localF1 b ∪ h.localF2 b = h.localPhase ∧ Disjoint (h.localF1 b) (h.localF2 b)
+  large_measure : ENNReal.ofReal (1 - κ) * volume h.localPhase < volume (h.localF1 b)
+  small_complement : volume (h.localF2 b) < ENNReal.ofReal κ * volume h.localPhase
+
+theorem localKAM {n : ℕ} {Ω₀ : Set (ComplexSpace n)} {δ₁ θ₀ Θ₀ ρ₀ : ℝ≥0} {κ D : ℝ}
+    (b : InitialParameters n δ₁ θ₀ Θ₀ ρ₀ κ D)
+    (h : InitialData n Ω₀ δ₁ θ₀ Θ₀ ρ₀ D) : LocalKAMResult b h where
+  nonempty := h.limit_realSlice_nonempty b
+  frequency_injective := h.limitFrequency_injOn b
+  embedding := fun _ hp => h.torusEmbedding_isClosedEmbedding b hp
+  analytic_lift := fun _ hp => h.limitMap_angle_analytic b hp
+  immersion := fun _ hp _ hq => h.torusLift_derivative_injective b hp hq
+  angle_bijective := fun _ hp => h.torusAngleMap_bijective b hp
+  inverse_analytic := fun _ hp Q => h.complexAngleInverse_analytic_at_real b hp Q
+  corrections_small := fun _ hp _ hq => h.torusCorrections_small b hp hq
+  disjoint := fun _ hp _ hp' he => h.invariantTorus_disjoint b hp hp' he
+  invariant_orbits := fun _ hp q t =>
+    ⟨h.orbit_hasDerivAt b hp q t, h.orbit_mem_torus_image b hp q t⟩
+  nonresonance := fun _ hp k hk => h.limitFrequency_no_integer_relation b hp k hk
+  union_eq := h.localF1_eq_frequency_union b
+  compact := h.localF1_compact b
+  partition := h.local_partition b
+  large_measure := h.torusLimitMap_volume_gt b
+  small_complement := h.localF2_volume_lt b
+
+end KamProject.Arnold1963
diff --git a/LeanPool/ArnoldKAM/Arnold1963/Main/LocalThreshold.lean b/LeanPool/ArnoldKAM/Arnold1963/Main/LocalThreshold.lean
new file mode 100644
index 0000000000..7ca52b2128
--- /dev/null
+++ b/LeanPool/ArnoldKAM/Arnold1963/Main/LocalThreshold.lean
@@ -0,0 +1,107 @@
+/-
+Copyright (c) 2026 Bingqi Yu. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Bingqi Yu
+-/
+
+module
+
+public import LeanPool.ArnoldKAM.Arnold1963.Geometry.HamiltonianLocalization
+public import LeanPool.ArnoldKAM.Arnold1963.Main.LocalKAM
+
+/-!
+Choose a positive perturbation threshold on each geometric patch before the perturbation
+is specified, using the existing numerical thresholds.
+-/
+
+@[expose] public section
+noncomputable section
+open Set
+open scoped NNReal
+namespace KamProject.Arnold1963
+open Iteration
+namespace HamiltonianPatch
+variable {n : ℕ} {H₀ : ComplexSpace n → ℂ} {ambient : Set (ComplexSpace n)}
+
+/-- The initial smallness seed selected from a Hamiltonian patch's numerical bounds. -/
+def seed (c : HamiltonianPatch n H₀ ambient) (ρ : ℝ≥0) (κ : ℝ) : ℝ≥0 :=
+  Real.toNNReal (threshold5 n c.lower c.upper ρ κ c.typeConstant / 2)
+
+/-- The positive perturbation threshold associated with a Hamiltonian patch. -/
+def threshold (c : HamiltonianPatch n H₀ ambient) (ρ : ℝ≥0) (κ : ℝ) : ℝ :=
+  initialPerturbationThreshold n c.lower c.upper ρ κ c.typeConstant
+
+theorem threshold_pos (c : HamiltonianPatch n H₀ ambient) (hn : 0 < n)
+    {ρ : ℝ≥0} {κ : ℝ} (hρ : 0 < ρ) (hκ : 0 < κ) : 0 < c.threshold ρ κ :=
+  initialPerturbationThreshold_pos hn c.lower_pos (zero_lt_one.trans c.upper_gt_one)
+    hρ hκ (c.typeD hn).constant_pos
+
+theorem seed_coe (c : HamiltonianPatch n H₀ ambient) (hn : 0 < n)
+    {ρ : ℝ≥0} {κ : ℝ} (hρ : 0 < ρ) (hκ : 0 < κ) :
+    (c.seed ρ κ : ℝ) = threshold5 n c.lower c.upper ρ κ c.typeConstant / 2 := by
+  apply Real.coe_toNNReal _ (le_of_lt (half_pos ?_))
+  exact threshold5_pos hn c.lower_pos (zero_lt_one.trans c.upper_gt_one)
+    hρ hκ (c.typeD hn).constant_pos
+
+theorem parameters (c : HamiltonianPatch n H₀ ambient) (hn : 0 < n)
+    {ρ : ℝ≥0} {κ : ℝ} (hρ : 0 < ρ) (hρ1 : ρ ≤ 1) (hκ : 0 < κ) (hκ1 : κ < 1) :
+    InitialParameters n (c.seed ρ κ) c.lower c.upper ρ κ c.typeConstant := by
+  have ht := threshold5_pos hn c.lower_pos (zero_lt_one.trans c.upper_gt_one)
+    hρ hκ (c.typeD hn).constant_pos
+  refine ⟨hn, ?_, c.lower_pos, c.lower_lt_one, c.upper_gt_one, hρ, hρ1,
+    hκ, hκ1, (c.typeD hn).constant_pos, ?_⟩
+  · change (0 : ℝ) < c.seed ρ κ
+    rw [c.seed_coe hn hρ hκ]
+    exact half_pos ht
+  · rw [c.seed_coe hn hρ hκ]
+    exact half_lt_self ht
+
+theorem threshold_eq_initial_bound (c : HamiltonianPatch n H₀ ambient) (hn : 0 < n)
+    {ρ : ℝ≥0} {κ : ℝ} (hρ : 0 < ρ) (hκ : 0 < κ) :
+    c.threshold ρ κ = Iteration.perturbation n (c.seed ρ κ) 0 := by
+  simp only [Iteration.perturbation, delta, decay_zero, c.seed_coe hn hρ hκ,
+    threshold, initialPerturbationThreshold]
+
+/-- Initial iteration data constructed by restricting a sufficiently small global perturbation. -/
+def initialData (c : HamiltonianPatch n H₀ ambient) (hn : 0 < n)
+    {ρ σ : ℝ≥0} {κ : ℝ} (hρ : 0 < ρ) (hκ : 0 < κ)
+    (f : AnalyticPhaseFunction n ambient σ) (hρσ : ρ ≤ σ)
+    (hf : f.uniformNorm ≤ c.threshold ρ κ) :
+    InitialData n c.frequencyDomain (c.seed ρ κ) c.lower c.upper ρ c.typeConstant where
+  domain := c.domain
+  integrable := H₀
+  perturbation := f.restrict c.subset hρσ c.chart.domain_conj
+  inverseFrequency := c.inverse
+  chart := c.chart
+  analytic := c.analytic
+  conj := c.conj
+  lower := c.derivative_lower
+  upper := c.derivative_upper
+  bound := by
+    rw [← c.threshold_eq_initial_bound hn hρ hκ]
+    exact (f.uniformNorm_restrict_le _ _ _).trans hf
+  typeD := c.typeD hn
+
+theorem local_result (c : HamiltonianPatch n H₀ ambient) (hn : 0 < n)
+    {ρ σ : ℝ≥0} {κ : ℝ} (hρ : 0 < ρ) (hρ1 : ρ ≤ 1) (hκ : 0 < κ) (hκ1 : κ < 1)
+    (f : AnalyticPhaseFunction n ambient σ) (hρσ : ρ ≤ σ)
+    (hf : f.uniformNorm ≤ c.threshold ρ κ) :
+    LocalKAMResult (c.parameters hn hρ hρ1 hκ hκ1) (c.initialData hn hρ hκ f hρσ hf) :=
+  localKAM _ _
+
+theorem exists_common_threshold (s : Finset (HamiltonianPatch n H₀ ambient))
+    (hn : 0 < n) {ρ : ℝ≥0} {κ : ℝ} (hρ : 0 < ρ) (hκ : 0 < κ) :
+    ∃ M : ℝ, 0 < M ∧ ∀ c ∈ s, M ≤ c.threshold ρ κ := by
+  classical
+  induction s using Finset.induction_on with
+  | empty => exact ⟨1, zero_lt_one, by simp⟩
+  | @insert c s _ ih =>
+    obtain ⟨M, hM, hs⟩ := ih
+    refine ⟨min M (c.threshold ρ κ), lt_min hM (c.threshold_pos hn hρ hκ), ?_⟩
+    intro d hd
+    rcases Finset.mem_insert.mp hd with rfl | hd
+    · exact min_le_right _ _
+    · exact (min_le_left _ _).trans (hs d hd)
+
+end HamiltonianPatch
+end KamProject.Arnold1963
diff --git a/LeanPool/ArnoldKAM/Arnold1963/Main/Theorem1.lean b/LeanPool/ArnoldKAM/Arnold1963/Main/Theorem1.lean
new file mode 100644
index 0000000000..04706ffeb3
--- /dev/null
+++ b/LeanPool/ArnoldKAM/Arnold1963/Main/Theorem1.lean
@@ -0,0 +1,134 @@
+/-
+Copyright (c) 2026 Bingqi Yu. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Bingqi Yu
+-/
+
+module
+
+public import LeanPool.ArnoldKAM.Arnold1963.Main.TorusResult
+public import LeanPool.ArnoldKAM.Arnold1963.Tori.CrossChart
+
+/-!
+Analytic Hamiltonian KAM on the compact domains specified by GlobalHamiltonianData. A common
+positive threshold precedes the perturbation. The actual local constructions and cross-chart
+orbit-closure argument produce a pairwise disjoint family with a strict measure-loss bound.
+-/
+
+@[expose] public section
+noncomputable section
+open Set MeasureTheory
+open scoped NNReal ENNReal
+namespace KamProject.Arnold1963
+local instance theorem1PeriodPositive : Fact (0 < 2 * Real.pi) :=
+  ⟨mul_pos (by norm_num) Real.pi_pos⟩
+
+/-- The global KAM partition, measure bounds, realized tori and all-time Hamiltonian
+trajectories. -/
+structure Theorem1Result (n : ℕ) (H₀ : ComplexSpace n → ℂ)
+    (G : Set (ComplexSpace n)) (ρ : ℝ≥0) (κ : ℝ)
+    (f : AnalyticPhaseFunction n G ρ) where
+  /-- The positive output width on which every realized torus lift is analytic. -/
+  width : ℝ≥0
+  width_pos : 0 < width
+  width_le : width ≤ ρ
+  /-- The compact positive-measure set covered by the realized invariant tori. -/
+  goodSet : Set (RealPhaseSpace n)
+  /-- The measurable exceptional set complementary to the good set in the initial phase domain. -/
+  badSet : Set (RealPhaseSpace n)
+  /-- The family of pairwise disjoint realized invariant tori. -/
+  tori : Set (Set (RealPhaseSpace n))
+  good_compact : IsCompact goodSet
+  good_measurable : MeasurableSet goodSet
+  bad_measurable : MeasurableSet badSet
+  partition : goodSet ∪ badSet = realSlice G ×ˢ (univ : Set (RealTorus n))
+  disjoint_partition : Disjoint goodSet badSet
+  good_volume_pos : 0 < volume goodSet
+  good_nonempty : goodSet.Nonempty
+  good_large : ENNReal.ofReal (1 - κ) *
+    volume (realSlice G ×ˢ (univ : Set (RealTorus n))) < volume goodSet
+  bad_small : volume badSet < ENNReal.ofReal κ *
+    volume (realSlice G ×ˢ (univ : Set (RealTorus n)))
+  union_eq : goodSet = ⋃₀ tori
+  pairwise_disjoint : tori.Pairwise Disjoint
+  realization : ∀ T ∈ tori, Nonempty (KAMTorus n H₀ f.toFun G width κ T)
+  global_orbits : ∀ z ∈ goodSet, ∃ γ : ℝ → ComplexPhaseSpace n,
+    torusProjection (realPartPhase (γ 0)) = z ∧
+    (∀ t, HasDerivAt γ (hamiltonianVectorField (fun w => H₀ w.1 + f.toFun w) (γ t)) t) ∧
+    (∀ t, complexifyPhase (realPartPhase (γ t)) = γ t) ∧
+    (∀ t, torusProjection (realPartPhase (γ t)) ∈ goodSet)
+
+namespace FiniteLocalization
+variable {n : ℕ} {H₀ : ComplexSpace n → ℂ} {G : Set (ComplexSpace n)}
+  {ρ : ℝ≥0} {κ : ℝ} (L : FiniteLocalization n H₀ G ρ κ)
+
+theorem goodSet_volume_gt (hG : IsCompact G) (f : AnalyticPhaseFunction n G ρ)
+    (hf : f.uniformNorm ≤ L.threshold) :
+    ENNReal.ofReal (1 - κ) * volume L.phase < volume (L.goodSet f hf) := by
+  by_cases hκ : κ < 1
+  · have hκ0 : 0 ≤ κ := (L.fraction_pos.trans_le L.fraction_le).le
+    have hV := L.phase_volume_finite hG
+    have hK := ne_top_of_le_ne_top hV (measure_mono (L.goodSet_subset f hf))
+    have hκV : ENNReal.ofReal κ * volume L.phase ≠ ⊤ :=
+      ENNReal.mul_ne_top ENNReal.ofReal_ne_top hV
+    have he : ENNReal.ofReal (1 - κ) * volume L.phase +
+        ENNReal.ofReal κ * volume L.phase = volume L.phase := by
+      rw [← add_mul, ← ENNReal.ofReal_add (sub_nonneg.mpr hκ.le) hκ0,
+        sub_add_cancel, ENNReal.ofReal_one, one_mul]
+    have hm := measure_union (μ := volume) (L.partition f hf).2 (L.badSet_measurable hG f hf)
+    rw [(L.partition f hf).1] at hm
+    apply (ENNReal.add_lt_add_iff_right hκV).mp
+    rw [he]
+    calc
+      volume L.phase = volume (L.goodSet f hf) + volume (L.badSet f hf) := hm
+      _ < volume (L.goodSet f hf) + ENNReal.ofReal κ * volume L.phase :=
+        ENNReal.add_lt_add_left hK (L.badSet_volume_lt hG f hf)
+  · rw [ENNReal.ofReal_of_nonpos (by linarith : 1 - κ ≤ 0), zero_mul]
+    exact L.goodSet_volume_pos f hf
+
+/-- The global KAM result assembled from a finite localization and a small perturbation. -/
+def theorem1Result (hG : IsCompact G) (f : AnalyticPhaseFunction n G ρ)
+    (hf : f.uniformNorm ≤ L.threshold) : Theorem1Result n H₀ G ρ κ f where
+  width := L.width / 6
+  width_pos := div_pos L.width_pos (by norm_num)
+  width_le := (div_le_self (zero_le : 0 ≤ L.width) (by norm_num : (1 : ℝ≥0) ≤ 6)).trans
+    L.width_le
+  goodSet := L.goodSet f hf
+  badSet := L.badSet f hf
+  tori := L.tori f hf
+  good_compact := L.goodSet_compact f hf
+  good_measurable := (L.goodSet_compact f hf).isClosed.measurableSet
+  bad_measurable := L.badSet_measurable hG f hf
+  partition := (L.partition f hf).1
+  disjoint_partition := (L.partition f hf).2
+  good_volume_pos := L.goodSet_volume_pos f hf
+  good_nonempty := nonempty_of_measure_ne_zero (L.goodSet_volume_pos f hf).ne'
+  good_large := L.goodSet_volume_gt hG f hf
+  bad_small := L.badSet_volume_lt hG f hf
+  union_eq := L.goodSet_eq_sUnion_tori f hf
+  pairwise_disjoint := L.tori_pairwise_disjoint f hf
+  realization := by
+    rintro T ⟨c, p, hp, rfl⟩
+    exact ⟨L.torusResult f hf c hp⟩
+  global_orbits := fun _ hz => L.exists_global_orbit f hf hz
+
+end FiniteLocalization
+
+theorem theorem1 {n : ℕ} {H₀ : ComplexSpace n → ℂ} {G : Set (ComplexSpace n)}
+    (h : GlobalHamiltonianData n H₀ G) {ρ : ℝ≥0} {κ : ℝ}
+    (hρ : 0 < ρ) (hκ : 0 < κ) :
+    ∃ M : ℝ, 0 < M ∧ ∀ f : AnalyticPhaseFunction n G ρ,
+      f.uniformNorm ≤ M → Nonempty (Theorem1Result n H₀ G ρ κ f) := by
+  obtain ⟨L⟩ := h.exists_finiteLocalization hρ hκ
+  exact ⟨L.threshold, L.threshold_pos, fun f hf => ⟨L.theorem1Result h.compact f hf⟩⟩
+
+theorem theorem1_of_pointwise {n : ℕ} {H₀ : ComplexSpace n → ℂ} {G : Set (ComplexSpace n)}
+    (h : GlobalHamiltonianData n H₀ G) {ρ : ℝ≥0} {κ : ℝ}
+    (hρ : 0 < ρ) (hκ : 0 < κ) :
+    ∃ M : ℝ, 0 < M ∧ ∀ f : AnalyticPhaseFunction n G ρ,
+      (∀ z ∈ phaseDomain G ρ, ‖f.toFun z‖ < M) → Nonempty (Theorem1Result n H₀ G ρ κ f) := by
+  obtain ⟨M, hM, hmain⟩ := theorem1 h hρ hκ
+  refine ⟨M, hM, fun f hf => hmain f ?_⟩
+  exact f.norm_le_iff.mpr ⟨hM.le, fun z hz => (hf z hz).le⟩
+
+end KamProject.Arnold1963
diff --git a/LeanPool/ArnoldKAM/Arnold1963/Main/Theorem2.lean b/LeanPool/ArnoldKAM/Arnold1963/Main/Theorem2.lean
new file mode 100644
index 0000000000..aa75061827
--- /dev/null
+++ b/LeanPool/ArnoldKAM/Arnold1963/Main/Theorem2.lean
@@ -0,0 +1,85 @@
+/-
+Copyright (c) 2026 Bingqi Yu. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Bingqi Yu
+-/
+
+module
+
+public import LeanPool.ArnoldKAM.Arnold1963.Iteration.Estimates
+public import LeanPool.ArnoldKAM.Arnold1963.Iteration.LimitDomain
+
+/-!
+The actual infinite Hamiltonian iteration and its positive-measure limiting action domain.
+Every stage is recursively constructed from initial data and its numerical threshold.
+-/
+
+@[expose] public section
+noncomputable section
+open Set
+open scoped NNReal ENNReal
+namespace KamProject.Arnold1963
+open Iteration
+
+/-- The constructed infinite iteration and its canonical maps, estimates and measure bounds. -/
+structure Theorem2Result {n : ℕ} {Ω₀ : Set (ComplexSpace n)} {δ₁ θ₀ Θ₀ ρ₀ : ℝ≥0}
+    {κ D : ℝ} (b : InitialParameters n δ₁ θ₀ Θ₀ ρ₀ κ D)
+    (h : InitialData n Ω₀ δ₁ θ₀ Θ₀ ρ₀ D) : Prop where
+  initial_domain : h.actionDomain b 0 = h.domain
+  initial_hamiltonian : ∀ z, h.hamiltonian b 0 z = h.integrable z.1 + h.perturbation.toFun z
+  phase_buffer : ∀ s, h.phase b (s + 1) ⊆ erosion (h.phase b s) (beta δ₁ s)
+  width : ∀ s, (ρ₀ : ℝ) / 3 < (Iteration.width n ρ₀ δ₁ s : ℝ)
+  phase_nonempty : ∀ s, (h.phase b s).Nonempty
+  displacement : ∀ s, ∀ z ∈ h.phase b (s + 1),
+    ‖(h.transformation b s).toFun z - z‖ < (beta δ₁ s : ℝ)
+  derivative : ∀ s, ∀ z ∈ h.phase b (s + 1), ‖fderiv ℂ (h.transformation b s).toFun z‖ < 2
+  identity : ∀ s z, h.integrable (h.cumulative b s z).1 +
+    h.perturbation.toFun (h.cumulative b s z) = h.hamiltonian b s z
+  perturbation : ∀ s, (h.state b (s + 1)).perturbation.uniformNorm <
+    Iteration.perturbation n δ₁ (s + 1)
+  first_derivative : ∀ s, ∀ z ∈ h.phase b (s + 1),
+    ‖fderiv ℂ (h.state b (s + 1)).perturbation.toFun z‖ <
+      (delta δ₁ s : ℝ) * beta δ₁ (s + 1)
+  second_derivative : ∀ s, ∀ z ∈ h.phase b (s + 1), ∀ j k : Fin n ⊕ Fin n,
+    ‖fderiv ℂ (fderiv ℂ (h.state b (s + 1)).perturbation.toFun) z
+      (phaseBasis j) (phaseBasis k)‖ < (delta δ₁ s : ℝ)
+  frequency_chart : ∀ s, AnalyticFrequencyChart
+    (actionFrequency (h.state b s).integrable) (h.state b s).inverseFrequency
+    (h.actionDomain b s) ((h.state b s).ar.domain Ω₀)
+  frequency_bounds : ∀ s, ∀ p ∈ h.actionDomain b s, ∀ v,
+    (θ₀ : ℝ) / 2 * ‖v‖ ≤ ‖fderiv ℂ (actionFrequency (h.state b s).integrable) p v‖ ∧
+      ‖fderiv ℂ (actionFrequency (h.state b s).integrable) p v‖ ≤ 2 * (Θ₀ : ℝ) * ‖v‖
+  frequency_displacement : ∀ s, ∀ p ∈ h.actionDomain b (s + 1),
+    ‖actionFrequency (h.state b (s + 1)).integrable p -
+      actionFrequency (h.state b s).integrable p‖ < (beta δ₁ s : ℝ) * delta δ₁ s
+  finite_loss : ∀ s, realVolume (h.domain \ h.actionDomain b s) <
+    ENNReal.ofReal κ * realVolume h.domain
+  limit_loss : realVolume (h.domain \ h.limitDomain b) < ENNReal.ofReal κ * realVolume h.domain
+  limit_volume : ENNReal.ofReal (1 - κ) * realVolume h.domain < realVolume (h.limitDomain b)
+  limit_positive : 0 < realVolume (h.limitDomain b)
+  limit_nonempty : (realSlice (h.limitDomain b)).Nonempty
+
+theorem theorem2 {n : ℕ} {Ω₀ : Set (ComplexSpace n)} {δ₁ θ₀ Θ₀ ρ₀ : ℝ≥0} {κ D : ℝ}
+    (b : InitialParameters n δ₁ θ₀ Θ₀ ρ₀ κ D)
+    (h : InitialData n Ω₀ δ₁ θ₀ Θ₀ ρ₀ D) : Theorem2Result b h where
+  initial_domain := h.domain_zero b
+  initial_hamiltonian := fun _ => rfl
+  phase_buffer := h.phase_buffer b
+  width := InitialData.width_gt_third b
+  phase_nonempty := h.phase_nonempty b
+  displacement := fun s _ hz => h.displacement_lt b s hz
+  derivative := fun s => (h.transformation b s).derivative_bound
+  identity := h.cumulative_identity b
+  perturbation := h.perturbation_bound b
+  first_derivative := fun s _ hz => h.remainder_derivative b s hz
+  second_derivative := fun s _ hz j k => h.remainder_second_derivative b s hz j k
+  frequency_chart := fun s => (h.state b s).input.chart
+  frequency_bounds := fun s _ hp v => h.frequency_bounds b s hp v
+  frequency_displacement := fun s _ hp => h.frequency_displacement b s hp
+  finite_loss := h.finite_loss b
+  limit_loss := h.limit_loss b
+  limit_volume := h.limit_volume_gt b
+  limit_positive := h.limit_volume_pos b
+  limit_nonempty := h.limit_realSlice_nonempty b
+
+end KamProject.Arnold1963
diff --git a/LeanPool/ArnoldKAM/Arnold1963/Main/TorusResult.lean b/LeanPool/ArnoldKAM/Arnold1963/Main/TorusResult.lean
new file mode 100644
index 0000000000..ade68ea862
--- /dev/null
+++ b/LeanPool/ArnoldKAM/Arnold1963/Main/TorusResult.lean
@@ -0,0 +1,137 @@
+/-
+Copyright (c) 2026 Bingqi Yu. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Bingqi Yu
+-/
+
+module
+
+public import LeanPool.ArnoldKAM.Arnold1963.Main.GlobalCover
+
+/-!
+The direct specification of one analytic invariant torus: center, frequency, lift, quotient
+embedding, inverse angle map, and all-time trajectories, realized by the same local limit.
+-/
+
+@[expose] public section
+noncomputable section
+open Set Function Topology
+open scoped NNReal
+namespace KamProject.Arnold1963
+
+/-- An analytic nonresonant torus with small displacement and original Hamiltonian trajectories. -/
+structure KAMTorus (n : ℕ) (H₀ : ComplexSpace n → ℂ)
+    (H₁ : ComplexPhaseSpace n → ℂ) (ambient : Set (ComplexSpace n))
+    (r : ℝ≥0) (κ : ℝ) (T : Set (RealPhaseSpace n)) where
+  /-- The real action center whose original frequency labels this torus. -/
+  center : RealSpace n
+  /-- The nonresonant real frequency of the torus's uniform rotation. -/
+  frequency : RealSpace n
+  /-- The analytic lift from complex angles to complex phase space. -/
+  lift : ComplexSpace n → ComplexPhaseSpace n
+  /-- The closed embedding of the real angle torus into real phase space. -/
+  embedding : RealTorus n → RealPhaseSpace n
+  /-- The analytic inverse for the angle component of the torus lift at real points. -/
+  angleInverse : ComplexSpace n → ComplexSpace n
+  center_mem : center ∈ realSlice ambient
+  frequency_eq : actionFrequency H₀ (complexify center) = complexify frequency
+  nonresonance : ∀ k : FourierIndex n, k ≠ 0 → indexPairing k (complexify frequency) ≠ 0
+  analytic : AnalyticOnNhd ℂ lift (angleStrip n r)
+  periodic : ∀ q ∈ angleStrip n r, ∀ k : FourierIndex n,
+    lift (q + angleShift k) = phaseShift k (lift q)
+  real_value : ∀ q : RealSpace n,
+    complexifyPhase (realPartPhase (lift (complexify q))) = lift (complexify q)
+  embedding_lift : ∀ q : RealSpace n,
+    embedding (fun j => (q j : AddCircle (2 * Real.pi))) =
+      torusProjection (realPartPhase (lift (complexify q)))
+  embedding_range : range embedding = T
+  closedEmbedding : IsClosedEmbedding embedding
+  immersion : ∀ q ∈ angleStrip n r, Injective (fderiv ℂ lift q)
+  angle_homeomorph : ∃ e : RealTorus n ≃ₜ RealTorus n, ∀ Q, e Q = (embedding Q).2
+  inverse_analytic : ∀ Q : RealSpace n, AnalyticAt ℂ angleInverse (complexify Q)
+  inverse_left : ∀ q : RealSpace n, angleInverse (lift (complexify q)).2 = complexify q
+  inverse_right : ∀ Q : RealSpace n, (lift (angleInverse (complexify Q))).2 = complexify Q
+  displacement : ∀ q ∈ angleStrip n r,
+    ‖(lift q).1 - complexify center‖ < κ ∧ ‖(lift q).2 - q‖ < κ
+  orbit_equation : ∀ q : RealSpace n, ∀ t : ℝ,
+    HasDerivAt (fun u : ℝ => lift (complexify (q + u • frequency)))
+      (hamiltonianVectorField (fun z => H₀ z.1 + H₁ z)
+        (lift (complexify (q + t • frequency)))) t
+  orbit_mem : ∀ q : RealSpace n, ∀ t : ℝ,
+    torusProjection (realPartPhase (lift (complexify (q + t • frequency)))) ∈ T
+
+namespace FiniteLocalization
+variable {n : ℕ} {H₀ : ComplexSpace n → ℂ} {ambient : Set (ComplexSpace n)}
+  {ρ : ℝ≥0} {κ : ℝ} (L : FiniteLocalization n H₀ ambient ρ κ)
+  (f : AnalyticPhaseFunction n ambient ρ) (hf : f.uniformNorm ≤ L.threshold)
+
+/-- A realized invariant torus extracted from one local patch's limiting construction. -/
+def torusResult (c : L.patches) {p : RealSpace n}
+    (hp : p ∈ realSlice ((L.data f hf c).limitDomain (L.parameters c))) :
+    KAMTorus n H₀ f.toFun ambient (L.width / 6) κ
+      ((L.data f hf c).invariantTorus (L.parameters c) p) := by
+  let h := L.data f hf c
+  let b := L.parameters c
+  let ω := h.limitFrequency b (complexify p)
+  let pc := h.unperturbedCenter ω
+  have hstrip : angleStrip n (L.width / 6) ⊆
+      Iteration.InitialData.commonAngleStrip n L.width :=
+    Iteration.InitialData.thinAngleStrip_subset b
+  have hpc : complexify (realPart pc) = pc := h.unperturbedCenter_real b hp
+  have hω : complexify (realPart ω) = ω := h.limitFrequency_real_value b hp
+  have ho (q : RealSpace n) : h.orbit b p q =
+      fun t : ℝ => h.limitMap b (complexify p, complexify (q + t • realPart ω)) :=
+    funext (h.orbit_eq_real_angle b hp q)
+  refine {
+    center := realPart pc
+    frequency := realPart ω
+    lift := fun q => h.limitMap b (complexify p, q)
+    embedding := h.torusEmbedding b p
+    angleInverse := h.complexAngleInverse b (complexify p)
+    center_mem := ?_
+    frequency_eq := ?_
+    nonresonance := ?_
+    analytic := (h.limitMap_angle_analytic b hp).mono hstrip
+    periodic := ?_
+    real_value := fun q => h.limitMap_real_value b (x := (p, q)) hp
+    embedding_lift := h.torusEmbedding_lift b hp
+    embedding_range := h.torusEmbedding_range b p
+    closedEmbedding := h.torusEmbedding_isClosedEmbedding b hp
+    immersion := fun _ hq => h.torusLift_derivative_injective b hp hq
+    angle_homeomorph := ⟨h.torusAngleHomeomorph b hp, fun _ => rfl⟩
+    inverse_analytic := h.complexAngleInverse_analytic_at_real b hp
+    inverse_left := fun q => (h.complexAngleInverse_analytic b hp q).2.1
+    inverse_right := ?_
+    displacement := ?_
+    orbit_equation := ?_
+    orbit_mem := ?_ }
+  · change complexify (realPart pc) ∈ ambient
+    rw [hpc]
+    have hlocal : pc ∈ c.val.domain := h.unperturbedCenter_mem b hp
+    exact c.val.subset hlocal
+  · rw [hpc, hω]
+    exact h.chart.right (by simpa using h.limitFrequency_mem b hp 0)
+  · intro k hk
+    rw [hω]
+    exact h.limitFrequency_no_integer_relation b hp k hk
+  · intro q hq k
+    exact h.limitMap_periodic b
+      (h.angle_mem_limitPhase b hp (hstrip hq)) k
+  · intro Q
+    rw [h.complexAngleInverse_real_value b hp]
+    change h.angleMap b (complexify p) (complexify (h.realAngleInverse b p Q)) = complexify Q
+    rw [← h.angleMap_real_value b hp, h.realAngleInverse_right b hp]
+  · intro q hq
+    rw [hpc]
+    exact L.corrections_small f hf c hp (hstrip hq)
+  · intro q t
+    have hh := L.orbit_original f hf c hp q t
+    change HasDerivAt (h.orbit b p q)
+      (hamiltonianVectorField (fun z => H₀ z.1 + f.toFun z) (h.orbit b p q t)) t at hh
+    simpa only [ho q] using hh
+  · intro q t
+    have hh := h.orbit_mem_torus_image b hp q t
+    simpa only [ho q, Iteration.InitialData.invariantTorus] using hh
+
+end FiniteLocalization
+end KamProject.Arnold1963
diff --git a/LeanPool/ArnoldKAM/Arnold1963/Measure/CumulativeVolume.lean b/LeanPool/ArnoldKAM/Arnold1963/Measure/CumulativeVolume.lean
new file mode 100644
index 0000000000..d6bc261719
--- /dev/null
+++ b/LeanPool/ArnoldKAM/Arnold1963/Measure/CumulativeVolume.lean
@@ -0,0 +1,91 @@
+/-
+Copyright (c) 2026 Bingqi Yu. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Bingqi Yu
+-/
+
+module
+
+public import LeanPool.ArnoldKAM.Arnold1963.Measure.RealSymplectic
+public import LeanPool.ArnoldKAM.Arnold1963.Measure.PeriodicProjection
+public import LeanPool.ArnoldKAM.Arnold1963.Geometry.GeneratingTorus
+
+/-!
+Physical quotient volume for finite cumulative transformations, using their injectivity.
+-/
+
+@[expose] public section
+noncomputable section
+open Set MeasureTheory
+open scoped NNReal ENNReal
+namespace KamProject.Arnold1963.Iteration.InitialData
+local instance : Fact (0 < 2 * Real.pi) := ⟨mul_pos (by norm_num) Real.pi_pos⟩
+variable {n : ℕ} {Ω₀ : Set (ComplexSpace n)} {δ₁ θ₀ Θ₀ ρ₀ : ℝ≥0} {κ D : ℝ}
+  (b : InitialParameters n δ₁ θ₀ Θ₀ ρ₀ κ D)
+  (h : InitialData n Ω₀ δ₁ θ₀ Θ₀ ρ₀ D)
+
+/-- The cumulative phase transformation restricted to unwrapped real coordinates. -/
+def realCumulative (s : ℕ) : RealPhaseCover n → RealPhaseCover n :=
+  realPhaseRestriction (h.cumulative b s)
+
+theorem real_mem_phase (s : ℕ) {x : RealPhaseCover n}
+    (hx : x.1 ∈ realSlice (h.limitDomain b)) : complexifyPhase x ∈ h.phase b s :=
+  h.limitPhase_subset b s (h.commonPhase_subset b ⟨hx, complexify_mem_angleStrip _ _⟩)
+
+theorem realCumulative_continuous (s : ℕ) : ContinuousOn (h.realCumulative b s)
+    (realSlice (h.limitDomain b) ×ˢ (univ : Set (RealSpace n))) := by
+  intro x hx
+  have hd := hasFDerivAt_realPhaseRestriction
+    (h.cumulative_analytic b s _ (h.real_mem_phase b s hx.1)).differentiableAt
+  exact hd.continuousAt.continuousWithinAt
+
+theorem realCumulative_injOn (s : ℕ) : InjOn (h.realCumulative b s)
+    (realSlice (h.limitDomain b) ×ˢ (univ : Set (RealSpace n))) := by
+  intro x hx y hy he
+  have hh := congrArg complexifyPhase he
+  change complexifyPhase (realPhaseRestriction (h.cumulative b s) x) =
+    complexifyPhase (realPhaseRestriction (h.cumulative b s) y) at hh
+  rw [h.cumulative_realPhase_value b s (h.real_mem_phase b s hx.1),
+    h.cumulative_realPhase_value b s (h.real_mem_phase b s hy.1)] at hh
+  simpa using congrArg realPartPhase
+    (h.cumulative_injOn b s (h.real_mem_phase b s hx.1) (h.real_mem_phase b s hy.1) hh)
+
+theorem realCumulative_shift (s : ℕ) {x : RealPhaseCover n}
+    (hx : x.1 ∈ realSlice (h.limitDomain b)) (k : FourierIndex n) :
+    h.realCumulative b s (realPhaseShift k x) = realPhaseShift k (h.realCumulative b s x) := by
+  change realPartPhase (h.cumulative b s (complexifyPhase (realPhaseShift k x))) = _
+  rw [complexifyPhase_shift, h.cumulative_periodic b s _ (h.real_mem_phase b s hx) k]
+  exact realPartPhase_shift k _
+
+/-- The limiting real action domain paired with a half-open fundamental angle cell. -/
+def retainedCell : Set (RealPhaseCover n) :=
+  realSlice (h.limitDomain b) ×ˢ realAngleCell n (2 * Real.pi)
+
+theorem retainedCell_measurable : MeasurableSet (h.retainedCell b) :=
+  (measurableSet_realSlice_of_isCompact (h.limit_compact b)).prod
+    (MeasurableSet.univ_pi fun _ => measurableSet_Ioc)
+
+theorem realCumulative_image_projection_injOn (s : ℕ) :
+    InjOn torusProjection (h.realCumulative b s '' h.retainedCell b) := by
+  rintro _ ⟨x, hx, rfl⟩ _ ⟨y, hy, rfl⟩ he
+  obtain ⟨k, hk⟩ := (torusProjection_eq_iff _ _).mp he
+  rw [← h.realCumulative_shift b s hy.1 k] at hk
+  have hxy : x = realPhaseShift k y := h.realCumulative_injOn b s ⟨hx.1, mem_univ _⟩
+    (show realPhaseShift k y ∈ realSlice (h.limitDomain b) ×ˢ univ from ⟨hy.1, mem_univ _⟩) hk
+  have hproj : torusProjection x = torusProjection y := by
+    rw [hxy, torusProjection_shift]
+  have heq := torusProjection_injOn_cell ⟨mem_univ _, hx.2⟩ ⟨mem_univ _, hy.2⟩ hproj
+  rw [heq]
+
+theorem cumulative_torus_volume (s : ℕ) :
+    volume ((torusProjection ∘ h.realCumulative b s) '' h.retainedCell b) =
+      volume (h.retainedCell b) := by
+  have hsub : h.retainedCell b ⊆ realSlice (h.limitDomain b) ×ˢ (univ : Set (RealSpace n)) :=
+    fun _ hx => ⟨hx.1, mem_univ _⟩
+  rw [image_comp, torusProjection_volume
+    ((h.retainedCell_measurable b).image_of_continuousOn_injOn
+      ((h.realCumulative_continuous b s).mono hsub) ((h.realCumulative_injOn b s).mono hsub))
+    (h.realCumulative_image_projection_injOn b s)]
+  exact h.cumulative_real_volume b s (h.retainedCell_measurable b) (fun _ hx => hx.1)
+
+end KamProject.Arnold1963.Iteration.InitialData
diff --git a/LeanPool/ArnoldKAM/Arnold1963/Measure/FiniteCover.lean b/LeanPool/ArnoldKAM/Arnold1963/Measure/FiniteCover.lean
new file mode 100644
index 0000000000..4d115bd069
--- /dev/null
+++ b/LeanPool/ArnoldKAM/Arnold1963/Measure/FiniteCover.lean
@@ -0,0 +1,57 @@
+/-
+Copyright (c) 2026 Bingqi Yu. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Bingqi Yu
+-/
+
+module
+
+public import Mathlib.MeasureTheory.Measure.Basic
+public import Mathlib.MeasureTheory.Measure.Continuity
+public import Mathlib.MeasureTheory.Measure.Typeclasses.Finite
+public import Mathlib.Basic.ENNReal.Real
+
+/-!
+Finite-cover loss estimates using subadditivity, allowing overlapping local patches.
+-/
+
+@[expose] public section
+noncomputable section
+open Set MeasureTheory
+open scoped ENNReal
+namespace KamProject.Arnold1963
+
+theorem measure_complement_finite_union_lt {E ι : Type*} [MeasurableSpace E] [Fintype ι]
+    (μ : Measure E) (F : Set E) (P K : ι → Set E) {ε η κ : ℝ}
+    (hε : 0 ≤ ε) (hη : 0 ≤ η) (hfin : μ F ≠ ⊤)
+    (hcover : μ (F \ ⋃ i, P i) < ENNReal.ofReal ε * μ F)
+    (hloss : ∀ i, μ (P i \ K i) ≤ ENNReal.ofReal η * μ F)
+    (hbudget : ε + (Fintype.card ι : ℝ) * η ≤ κ) :
+    μ (F \ ⋃ i, K i) < ENNReal.ofReal κ * μ F := by
+  classical
+  have hsub : F \ ⋃ i, K i ⊆ (F \ ⋃ i, P i) ∪ ⋃ i, P i \ K i := by
+    intro x hx
+    by_cases hp : x ∈ ⋃ i, P i
+    · obtain ⟨i, hi⟩ := mem_iUnion.mp hp
+      exact Or.inr (mem_iUnion.mpr ⟨i, hi, fun hk => hx.2 (mem_iUnion.mpr ⟨i, hk⟩)⟩)
+    · exact Or.inl ⟨hx.1, hp⟩
+  have hsum : μ (⋃ i, P i \ K i) ≤
+      ENNReal.ofReal ((Fintype.card ι : ℝ) * η) * μ F := by
+    calc
+      _ ≤ ∑ i, μ (P i \ K i) := measure_iUnion_fintype_le μ _
+      _ ≤ ∑ _i : ι, ENNReal.ofReal η * μ F := Finset.sum_le_sum fun i _ => hloss i
+      _ = _ := by simp [ENNReal.ofReal_mul, nsmul_eq_mul, mul_assoc]
+  have hbfin : ENNReal.ofReal ((Fintype.card ι : ℝ) * η) * μ F ≠ ⊤ :=
+    ENNReal.mul_ne_top ENNReal.ofReal_ne_top hfin
+  calc
+    μ (F \ ⋃ i, K i) ≤ μ (F \ ⋃ i, P i) + μ (⋃ i, P i \ K i) :=
+      (measure_mono hsub).trans (measure_union_le _ _)
+    _ ≤ μ (F \ ⋃ i, P i) + ENNReal.ofReal ((Fintype.card ι : ℝ) * η) * μ F :=
+      add_le_add le_rfl hsum
+    _ < ENNReal.ofReal ε * μ F + ENNReal.ofReal ((Fintype.card ι : ℝ) * η) * μ F :=
+      ENNReal.add_lt_add_right hbfin hcover
+    _ = ENNReal.ofReal (ε + (Fintype.card ι : ℝ) * η) * μ F := by
+      rw [← add_mul, ← ENNReal.ofReal_add hε (mul_nonneg (Nat.cast_nonneg _) hη)]
+    _ ≤ ENNReal.ofReal κ * μ F := mul_le_mul' (ENNReal.ofReal_le_ofReal hbudget) le_rfl
+
+end KamProject.Arnold1963
diff --git a/LeanPool/ArnoldKAM/Arnold1963/Measure/LimitImage.lean b/LeanPool/ArnoldKAM/Arnold1963/Measure/LimitImage.lean
new file mode 100644
index 0000000000..77767c0032
--- /dev/null
+++ b/LeanPool/ArnoldKAM/Arnold1963/Measure/LimitImage.lean
@@ -0,0 +1,64 @@
+/-
+Copyright (c) 2026 Bingqi Yu. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Bingqi Yu
+-/
+
+module
+
+public import Mathlib.MeasureTheory.Constructions.BorelSpace.Metric
+public import Mathlib.Topology.UniformSpace.UniformConvergence
+
+/-!
+Compact-image measure bounds under uniform convergence. Compactness controls image
+neighborhoods; injectivity of the limiting map is not assumed.
+-/
+
+@[expose] public section
+noncomputable section
+open Set Filter MeasureTheory Metric
+open scoped Topology ENNReal
+namespace KamProject.Arnold1963
+
+variable {α E : Type*} [TopologicalSpace α] [MetricSpace E] [ProperSpace E]
+  [MeasurableSpace E] [OpensMeasurableSpace E]
+  {μ : Measure E} [IsFiniteMeasureOnCompacts μ]
+
+theorem limsup_measure_image_le {K : Set α} (hK : IsCompact K)
+    {F : ℕ → α → E} {f : α → E} (hf : ContinuousOn f K)
+    (hF : TendstoUniformlyOn F f atTop K) :
+    limsup (fun s => μ (F s '' K)) atTop ≤ μ (f '' K) := by
+  have hb (r : ℝ) (hr : 0 < r) :
+      limsup (fun s => μ (F s '' K)) atTop ≤ μ (cthickening r (f '' K)) := by
+    apply limsup_le_of_le (by isBoundedDefault)
+    filter_upwards [Metric.tendstoUniformlyOn_iff.mp hF r hr] with s hs
+    apply measure_mono
+    rintro _ ⟨x, hx, rfl⟩
+    apply mem_cthickening_of_dist_le (F s x) (f x) r (f '' K) (mem_image_of_mem f hx)
+    simpa only [dist_comm] using (hs x hx).le
+  have ht : Tendsto (fun r => μ (cthickening r (f '' K))) (𝓝[>] (0 : ℝ))
+      (𝓝 (μ (f '' K))) :=
+    (tendsto_measure_cthickening_of_isCompact (μ := μ) (hK.image_of_continuousOn hf)).mono_left
+      inf_le_left
+  apply ge_of_tendsto ht
+  filter_upwards [self_mem_nhdsWithin] with r hr
+  exact hb r hr
+
+theorem measure_image_ge_of_uniform_limit {K : Set α} (hK : IsCompact K)
+    {F : ℕ → α → E} {f : α → E} (hf : ContinuousOn f K)
+    (hF : TendstoUniformlyOn F f atTop K) {a : ℝ≥0∞}
+    (ha : ∀ᶠ s in atTop, a ≤ μ (F s '' K)) : a ≤ μ (f '' K) := by
+  have hh : a ≤ limsup (fun s => μ (F s '' K)) atTop := by
+    apply le_limsup_of_le (by isBoundedDefault)
+    intro c hc
+    obtain ⟨s, hs, ht⟩ := (ha.and hc).exists
+    exact hs.trans ht
+  exact hh.trans (limsup_measure_image_le hK hf hF)
+
+theorem measure_image_gt_of_uniform_limit {K : Set α} (hK : IsCompact K)
+    {F : ℕ → α → E} {f : α → E} (hf : ContinuousOn f K)
+    (hF : TendstoUniformlyOn F f atTop K) {a c : ℝ≥0∞}
+    (hca : c < a) (ha : ∀ᶠ s in atTop, a ≤ μ (F s '' K)) : c < μ (f '' K) :=
+  hca.trans_le (measure_image_ge_of_uniform_limit hK hf hF ha)
+
+end KamProject.Arnold1963
diff --git a/LeanPool/ArnoldKAM/Arnold1963/Measure/LimitTorusVolume.lean b/LeanPool/ArnoldKAM/Arnold1963/Measure/LimitTorusVolume.lean
new file mode 100644
index 0000000000..dcd4a8b6a0
--- /dev/null
+++ b/LeanPool/ArnoldKAM/Arnold1963/Measure/LimitTorusVolume.lean
@@ -0,0 +1,115 @@
+/-
+Copyright (c) 2026 Bingqi Yu. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Bingqi Yu
+-/
+
+module
+
+public import LeanPool.ArnoldKAM.Arnold1963.Measure.CumulativeVolume
+public import LeanPool.ArnoldKAM.Arnold1963.Measure.LimitImage
+public import LeanPool.ArnoldKAM.Arnold1963.Measure.PhaseVolume
+public import LeanPool.ArnoldKAM.Arnold1963.Dynamics.RealOrbits
+
+/-!
+Apply compact-image bounds to the KAM limit on the periodic phase quotient. Half-open cells
+compute finite-stage volume, while closed cells supply compactness for the uniform limit.
+-/
+
+@[expose] public section
+noncomputable section
+open Set Filter MeasureTheory
+open scoped NNReal ENNReal Topology
+namespace KamProject.Arnold1963
+local instance : Fact (0 < 2 * Real.pi) := ⟨mul_pos (by norm_num) Real.pi_pos⟩
+
+theorem torus_phase_volume {n : ℕ} (G : Set (ComplexSpace n)) :
+    volume (realSlice G ×ˢ (univ : Set (RealTorus n))) =
+      realVolume G * ENNReal.ofReal (2 * Real.pi) ^ n := by
+  change (volume.prod volume) _ = _
+  rw [Measure.prod_prod]
+  congr 1
+  change (Measure.pi fun _ : Fin n => (volume : Measure (AddCircle (2 * Real.pi)))) univ = _
+  simp [Measure.pi_univ, AddCircle.measure_univ]
+
+namespace Iteration.InitialData
+variable {n : ℕ} {Ω₀ : Set (ComplexSpace n)} {δ₁ θ₀ Θ₀ ρ₀ : ℝ≥0} {κ D : ℝ}
+  (b : InitialParameters n δ₁ θ₀ Θ₀ ρ₀ κ D)
+  (h : InitialData n Ω₀ δ₁ θ₀ Θ₀ ρ₀ D)
+
+/-- The limiting real action domain paired with a closed fundamental angle cell. -/
+def retainedClosedCell : Set (RealPhaseCover n) :=
+  realSlice (h.limitDomain b) ×ˢ Icc 0 (fun _ => 2 * Real.pi)
+
+theorem retainedClosedCell_compact : IsCompact (h.retainedClosedCell b) :=
+  (isCompact_realSlice (h.limit_compact b)).prod isCompact_Icc
+
+theorem retainedCell_subset_closed : h.retainedCell b ⊆ h.retainedClosedCell b := by
+  intro x hx
+  exact ⟨hx.1, (fun j => (hx.2 j (mem_univ j)).1.le), fun j => (hx.2 j (mem_univ j)).2⟩
+
+theorem realLimitMap_continuous : ContinuousOn (h.realLimitMap b)
+    (realSlice (h.limitDomain b) ×ˢ (univ : Set (RealSpace n))) := by
+  change ContinuousOn ((realPartPhaseCLM n) ∘ h.limitMap b ∘ (complexifyPhaseCLM n)) _
+  apply (realPartPhaseCLM n).continuous.comp_continuousOn
+  exact (h.limitMap_continuous b).comp (complexifyPhaseCLM n).continuous.continuousOn
+    (fun _ hx => h.commonPhase_subset b ⟨hx.1, complexify_mem_angleStrip _ _⟩)
+
+theorem projected_cumulative_uniform :
+    TendstoUniformlyOn (fun s => torusProjection ∘ h.realCumulative b s)
+      (torusProjection ∘ h.realLimitMap b) atTop (h.retainedClosedCell b) := by
+  have hc := ((h.cumulative_uniform b).comp (@complexifyPhase n)).mono
+    (show h.retainedClosedCell b ⊆ complexifyPhase ⁻¹' h.limitPhase b from
+      fun _ hx => h.commonPhase_subset b ⟨hx.1, complexify_mem_angleStrip _ _⟩)
+  exact torusProjection_lipschitz.uniformContinuous.comp_tendstoUniformlyOn
+    ((realPartPhaseCLM n).uniformContinuous.comp_tendstoUniformlyOn hc)
+
+theorem projected_limit_continuous :
+    ContinuousOn (torusProjection ∘ h.realLimitMap b) (h.retainedClosedCell b) :=
+  continuous_torusProjection.comp_continuousOn ((h.realLimitMap_continuous b).mono
+    (fun _ hx => ⟨hx.1, mem_univ _⟩))
+
+theorem projected_limit_image :
+    (torusProjection ∘ h.realLimitMap b) '' h.retainedClosedCell b =
+      h.torusLimitMap b '' (realSlice (h.limitDomain b) ×ˢ (univ : Set (RealTorus n))) := by
+  ext z
+  constructor
+  · rintro ⟨x, hx, rfl⟩
+    exact ⟨torusProjection x, ⟨hx.1, mem_univ _⟩, h.torusLimitMap_projection b hx.1⟩
+  · rintro ⟨x, hx, rfl⟩
+    have hr := torusRepresentative_mem_cell x
+    refine ⟨torusRepresentative x, ?_, rfl⟩
+    exact h.retainedCell_subset_closed b ⟨hx.1, hr.2⟩
+
+theorem torusLimitMap_image_compact : IsCompact
+    (h.torusLimitMap b '' (realSlice (h.limitDomain b) ×ˢ (univ : Set (RealTorus n)))) := by
+  rw [← h.projected_limit_image b]
+  exact (h.retainedClosedCell_compact b).image_of_continuousOn (h.projected_limit_continuous b)
+
+theorem torusLimitMap_volume_ge :
+    realVolume (h.limitDomain b) * ENNReal.ofReal (2 * Real.pi) ^ n ≤
+      volume (h.torusLimitMap b ''
+        (realSlice (h.limitDomain b) ×ˢ (univ : Set (RealTorus n)))) := by
+  let : (volume : Measure (RealPhaseSpace n)).IsAddHaarMeasure :=
+    Measure.prod.instIsAddHaarMeasure _ _
+  rw [← h.projected_limit_image b]
+  have ha : realVolume (h.limitDomain b) * ENNReal.ofReal (2 * Real.pi) ^ n =
+      volume (h.retainedCell b) :=
+    (realPhaseLebesgue_physicalCell (h.limitDomain b)).symm
+  rw [ha]
+  apply measure_image_ge_of_uniform_limit (h.retainedClosedCell_compact b)
+    (h.projected_limit_continuous b) (h.projected_cumulative_uniform b)
+  exact Eventually.of_forall fun s => (h.cumulative_torus_volume b s).symm.le.trans
+    (measure_mono (image_mono (h.retainedCell_subset_closed b)))
+
+theorem torusLimitMap_volume_gt :
+    ENNReal.ofReal (1 - κ) * volume (realSlice h.domain ×ˢ (univ : Set (RealTorus n))) <
+      volume (h.torusLimitMap b ''
+        (realSlice (h.limitDomain b) ×ˢ (univ : Set (RealTorus n)))) := by
+  have ht := h.limit_physicalCell_volume_gt b
+  rw [realPhaseLebesgue_physicalCell, realPhaseLebesgue_physicalCell] at ht
+  rw [torus_phase_volume]
+  exact ht.trans_le (h.torusLimitMap_volume_ge b)
+
+end Iteration.InitialData
+end KamProject.Arnold1963
diff --git a/LeanPool/ArnoldKAM/Arnold1963/Measure/PeriodicProjection.lean b/LeanPool/ArnoldKAM/Arnold1963/Measure/PeriodicProjection.lean
new file mode 100644
index 0000000000..ee90175ecc
--- /dev/null
+++ b/LeanPool/ArnoldKAM/Arnold1963/Measure/PeriodicProjection.lean
@@ -0,0 +1,185 @@
+/-
+Copyright (c) 2026 Bingqi Yu. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Bingqi Yu
+-/
+
+module
+
+public import LeanPool.ArnoldKAM.Arnold1963.Geometry.RealCover
+public import LeanPool.ArnoldKAM.Arnold1963.Basic.Measure
+public import Mathlib.MeasureTheory.Integral.IntervalIntegral.Periodic
+public import Mathlib.MeasureTheory.Constructions.Polish.Basic
+public import Mathlib.Analysis.Normed.Group.AddCircle
+public import Mathlib.MeasureTheory.Measure.Lebesgue.EqHaar
+
+/-!
+Physical quotient volume with angle Haar mass 2 * pi. Countably many half-open cells
+transfer covering-space volume to the quotient for sets on which projection is injective.
+-/
+
+@[expose] public section
+noncomputable section
+open Set MeasureTheory Function
+open scoped ENNReal
+namespace KamProject.Arnold1963
+local instance : Fact (0 < 2 * Real.pi) := ⟨mul_pos (by norm_num) Real.pi_pos⟩
+
+/-- All real actions paired with one half-open fundamental angle cell. -/
+def phaseCell (n : ℕ) : Set (RealPhaseCover n) :=
+  univ ×ˢ realAngleCell n (2 * Real.pi)
+
+theorem measurableSet_phaseCell (n : ℕ) : MeasurableSet (phaseCell n) :=
+  MeasurableSet.univ.prod (MeasurableSet.univ_pi fun _ => measurableSet_Ioc)
+
+theorem continuous_torusProjection {n : ℕ} : Continuous (@torusProjection n) := by
+  unfold torusProjection
+  fun_prop
+
+theorem torusProjection_injOn_cell {n : ℕ} : InjOn (@torusProjection n) (phaseCell n) := by
+  intro x hx y hy he
+  apply Prod.ext (show x.1 = y.1 from congrArg (fun z : RealPhaseSpace n => z.1) he)
+  funext j
+  apply (AddCircle.coe_eq_coe_iff_of_mem_Ioc (p := 2 * Real.pi) (a := 0)
+    (by simpa using hx.2 j (mem_univ j))
+    (by simpa using hy.2 j (mem_univ j))).mp
+  exact congrArg (fun z : RealPhaseSpace n => z.2 j) he
+
+theorem torusRepresentative_mem_cell {n : ℕ} (x : RealPhaseSpace n) :
+    torusRepresentative x ∈ phaseCell n := by
+  refine ⟨mem_univ _, fun j _ => ?_⟩
+  simpa [torusRepresentative] using (AddCircle.equivIoc (2 * Real.pi) 0 (x.2 j)).property
+
+theorem torusProjection_measurePreserving (n : ℕ) :
+    MeasurePreserving (@torusProjection n) (volume.restrict (phaseCell n)) volume := by
+  have ha := measurePreserving_pi
+    (fun _ : Fin n => (volume : Measure ℝ).restrict (Ioc 0 (2 * Real.pi)))
+    (fun _ : Fin n => (volume : Measure (AddCircle (2 * Real.pi))))
+    (fun _ => by simpa using AddCircle.measurePreserving_mk (2 * Real.pi) 0)
+  rw [← Measure.restrict_pi_pi] at ha
+  have hi : MeasurePreserving (id : RealSpace n → RealSpace n)
+      (volume.restrict univ) volume := by simpa using MeasurePreserving.id volume
+  have hh := hi.prod ha
+  rw [Measure.prod_restrict] at hh
+  exact hh
+
+theorem realPhaseShift_eq_add {n : ℕ} (k : FourierIndex n) (x : RealPhaseCover n) :
+    realPhaseShift k x = x + (0, realAngleShift k) := by
+  ext <;> simp [realPhaseShift]
+
+/-- The measurable equivalence translating unwrapped phase space by an integer angle-period
+shift. -/
+def phaseShiftEquiv {n : ℕ} (k : FourierIndex n) : RealPhaseCover n ≃ᵐ RealPhaseCover n :=
+  MeasurableEquiv.addRight (0, realAngleShift k)
+
+@[simp] theorem phaseShiftEquiv_apply {n : ℕ} (k : FourierIndex n) (x : RealPhaseCover n) :
+    phaseShiftEquiv k x = realPhaseShift k x := (realPhaseShift_eq_add k x).symm
+
+theorem phaseShift_measurePreserving {n : ℕ} (k : FourierIndex n) :
+    MeasurePreserving (phaseShiftEquiv k) volume volume := by
+  let : (volume : Measure (RealPhaseCover n)).IsAddHaarMeasure :=
+    Measure.prod.instIsAddHaarMeasure _ _
+  exact measurePreserving_add_right volume _
+
+/-- The translated fundamental phase cell associated with an integer angle-period shift. -/
+def translatedPhaseCell {n : ℕ} (k : FourierIndex n) : Set (RealPhaseCover n) :=
+  phaseShiftEquiv k '' phaseCell n
+
+theorem measurableSet_translatedPhaseCell {n : ℕ} (k : FourierIndex n) :
+    MeasurableSet (translatedPhaseCell k) :=
+  (phaseShiftEquiv k).measurableEmbedding.measurableSet_image.mpr (measurableSet_phaseCell n)
+
+theorem translatedPhaseCell_cover (n : ℕ) :
+    ⋃ k : FourierIndex n, translatedPhaseCell k = univ := by
+  apply eq_univ_of_forall
+  intro x
+  obtain ⟨k, hk⟩ := (torusProjection_eq_iff x (torusRepresentative (torusProjection x))).mp
+    (torusProjection_representative _).symm
+  exact mem_iUnion.mpr ⟨k, torusRepresentative (torusProjection x),
+    torusRepresentative_mem_cell _, by simpa using hk.symm⟩
+
+theorem translatedPhaseCell_disjoint (n : ℕ) :
+    Pairwise (Disjoint on (translatedPhaseCell (n := n))) := by
+  intro k l hkl
+  apply disjoint_left.mpr
+  rintro z ⟨x, hx, rfl⟩ ⟨y, hy, he⟩
+  have hxy : y = x := torusProjection_injOn_cell hy hx (by
+    simpa using congrArg torusProjection he)
+  subst y
+  apply hkl
+  funext j
+  have hj := congrArg (fun v : RealPhaseCover n => v.2 j) he
+  simp only [phaseShiftEquiv_apply, realPhaseShift, Pi.add_apply, realAngleShift] at hj
+  have hc : (l j : ℝ) = (k j : ℝ) := (mul_left_cancel₀
+    (ne_of_gt (mul_pos (by norm_num) Real.pi_pos))) (add_left_cancel hj)
+  exact (Int.cast_injective hc).symm
+
+theorem torusProjection_translated_measurePreserving {n : ℕ} (k : FourierIndex n) :
+    MeasurePreserving (@torusProjection n) (volume.restrict (translatedPhaseCell k)) volume := by
+  have he := (phaseShift_measurePreserving k).restrict_image_emb
+    (phaseShiftEquiv k).measurableEmbedding (phaseCell n)
+  apply (he.comp_right_iff).mp
+  simpa only [Function.comp_def, phaseShiftEquiv_apply, torusProjection_shift] using
+    torusProjection_measurePreserving n
+
+theorem torusProjection_injOn_translated {n : ℕ} (k : FourierIndex n) :
+    InjOn (@torusProjection n) (translatedPhaseCell k) := by
+  rintro _ ⟨x, hx, rfl⟩ _ ⟨y, hy, rfl⟩ he
+  have hh := torusProjection_injOn_cell hx hy (by simpa using he)
+  rw [hh]
+
+theorem torusProjection_volume_piece {n : ℕ} {A : Set (RealPhaseCover n)}
+    (hA : MeasurableSet A) (k : FourierIndex n) (hsub : A ⊆ translatedPhaseCell k) :
+    volume (torusProjection '' A) = volume A := by
+  have hi := torusProjection_injOn_translated k
+  have hm := hA.image_of_continuousOn_injOn continuous_torusProjection.continuousOn (hi.mono hsub)
+  have he := (torusProjection_translated_measurePreserving k).measure_preimage hm.nullMeasurableSet
+  rw [Measure.restrict_apply (continuous_torusProjection.measurable hm)] at he
+  have hs : torusProjection ⁻¹' (torusProjection '' A) ∩ translatedPhaseCell k = A := by
+    ext x
+    constructor
+    · rintro ⟨⟨y, hy, he⟩, hx⟩
+      rwa [← hi (hsub hy) hx he]
+    · intro hx
+      exact ⟨mem_image_of_mem _ hx, hsub hx⟩
+  rw [hs] at he
+  exact he.symm
+
+theorem torusProjection_volume {n : ℕ} {A : Set (RealPhaseCover n)}
+    (hA : MeasurableSet A) (hi : InjOn torusProjection A) :
+    volume (torusProjection '' A) = volume A := by
+  let B := fun k : FourierIndex n => A ∩ translatedPhaseCell k
+  have hB k : MeasurableSet (B k) := hA.inter (measurableSet_translatedPhaseCell k)
+  have hu : ⋃ k, B k = A := by
+    simp only [B, ← inter_iUnion, translatedPhaseCell_cover, inter_univ]
+  have hd : Pairwise (Disjoint on B) := fun k l hkl =>
+    (translatedPhaseCell_disjoint n hkl).mono inter_subset_right inter_subset_right
+  have hdi : Pairwise (Disjoint on fun k => torusProjection '' B k) := by
+    intro k l hkl
+    apply disjoint_left.mpr
+    rintro z ⟨x, hx, rfl⟩ ⟨y, hy, he⟩
+    have hh := hi hy.1 hx.1 he
+    exact disjoint_left.mp (hd hkl) hx (hh ▸ hy)
+  rw [← hu, image_iUnion, measure_iUnion hdi]
+  · rw [measure_iUnion hd hB]
+    congr 1
+    funext k
+    exact torusProjection_volume_piece (hB k) k inter_subset_right
+  · intro k
+    exact (hB k).image_of_continuousOn_injOn continuous_torusProjection.continuousOn
+      (hi.mono inter_subset_left)
+
+theorem torusProjection_lipschitz {n : ℕ} : LipschitzWith 1 (@torusProjection n) := by
+  apply LipschitzWith.of_dist_le_mul
+  intro x y
+  simp only [NNReal.coe_one, one_mul, torusProjection, Prod.dist_eq]
+  apply max_le (le_max_left _ _)
+  apply (dist_pi_le_iff (le_trans dist_nonneg (le_max_right _ _))).mpr
+  intro j
+  have hh : dist (x.2 j : AddCircle (2 * Real.pi)) (y.2 j) ≤ dist (x.2 j) (y.2 j) := by
+    simpa only [dist_eq_norm, ← AddCircle.coe_sub] using
+      (QuotientAddGroup.norm_mk_le_norm (S := AddSubgroup.zmultiples (2 * Real.pi))
+        (m := x.2 j - y.2 j))
+  exact hh.trans ((dist_le_pi_dist x.2 y.2 j).trans (le_max_right _ _))
+
+end KamProject.Arnold1963
diff --git a/LeanPool/ArnoldKAM/Arnold1963/Measure/PhaseVolume.lean b/LeanPool/ArnoldKAM/Arnold1963/Measure/PhaseVolume.lean
new file mode 100644
index 0000000000..a2178c221b
--- /dev/null
+++ b/LeanPool/ArnoldKAM/Arnold1963/Measure/PhaseVolume.lean
@@ -0,0 +1,33 @@
+/-
+Copyright (c) 2026 Bingqi Yu. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Bingqi Yu
+-/
+
+module
+
+public import LeanPool.ArnoldKAM.Arnold1963.Iteration.LimitDomain
+
+/-!
+Physical phase volume of retained action domains. Angle cells have side length 2 * pi.
+This source-volume estimate is separate from volume preservation by transformations.
+-/
+
+@[expose] public section
+noncomputable section
+open Set
+open scoped NNReal ENNReal
+namespace KamProject.Arnold1963.Iteration.InitialData
+variable {n : ℕ} {Ω₀ : Set (ComplexSpace n)} {δ₁ θ₀ Θ₀ ρ₀ : ℝ≥0} {κ D : ℝ}
+  (b : InitialParameters n δ₁ θ₀ Θ₀ ρ₀ κ D)
+  (h : InitialData n Ω₀ δ₁ θ₀ Θ₀ ρ₀ D)
+
+theorem limit_physicalCell_volume_gt :
+    ENNReal.ofReal (1 - κ) *
+        realPhaseLebesgue n (realSlice h.domain ×ˢ realAngleCell n (2 * Real.pi)) <
+      realPhaseLebesgue n (realSlice (h.limitDomain b) ×ˢ
+        realAngleCell n (2 * Real.pi)) := by
+  rw [realPhaseLebesgue_physicalCell, realPhaseLebesgue_physicalCell, ← mul_assoc]
+  exact ENNReal.mul_lt_mul_left (by positivity) (by finiteness) (h.limit_volume_gt b)
+
+end KamProject.Arnold1963.Iteration.InitialData
diff --git a/LeanPool/ArnoldKAM/Arnold1963/Measure/RealSymplectic.lean b/LeanPool/ArnoldKAM/Arnold1963/Measure/RealSymplectic.lean
new file mode 100644
index 0000000000..bcfdb31ea3
--- /dev/null
+++ b/LeanPool/ArnoldKAM/Arnold1963/Measure/RealSymplectic.lean
@@ -0,0 +1,142 @@
+/-
+Copyright (c) 2026 Bingqi Yu. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Bingqi Yu
+-/
+
+module
+
+public import LeanPool.ArnoldKAM.Arnold1963.Convergence.RealDerivative
+public import Mathlib.LinearAlgebra.Basis.Prod
+public import Mathlib.MeasureTheory.Group.Prod
+
+/-!
+Real symplectic Jacobians. Real derivatives commute with complexification, and the symplectic
+matrix determinant theorem gives the real change-of-variables identity.
+-/
+
+@[expose] public section
+noncomputable section
+open Set Filter MeasureTheory Module
+open scoped NNReal Topology ENNReal
+namespace KamProject.Arnold1963
+
+/-- The coordinate basis of unwrapped real action-angle phase space. -/
+def realPhaseBasis (n : ℕ) : Basis (Fin n ⊕ Fin n) ℝ (RealPhaseCover n) :=
+  (Pi.basisFun ℝ (Fin n)).prod (Pi.basisFun ℝ (Fin n))
+
+theorem complexifyPhase_realPhaseBasis {n : ℕ} (j : Fin n ⊕ Fin n) :
+    complexifyPhase (realPhaseBasis n j) = phaseDirection j := by
+  cases j with
+  | inl j =>
+    ext i <;> by_cases hij : i = j <;>
+      simp [realPhaseBasis, complexifyPhase, complexify,
+        phaseDirection, pDirection, hij]
+  | inr j =>
+    ext i <;> by_cases hij : i = j <;>
+      simp [realPhaseBasis, complexifyPhase, complexify,
+        phaseDirection, qDirection, hij]
+
+theorem realPhase_det_eq_one {n : ℕ}
+    (L : ComplexPhaseSpace n →L[ℂ] ComplexPhaseSpace n)
+    (A : RealPhaseCover n →L[ℝ] RealPhaseCover n)
+    (hL : IsSymplecticLinear L.toLinearMap)
+    (hA : ∀ v, complexifyPhase (A v) = L (complexifyPhase v)) :
+    A.toLinearMap.det = 1 := by
+  let M := LinearMap.toMatrix (realPhaseBasis n) (realPhaseBasis n) A.toLinearMap
+  have hm : M.map Complex.ofRealHom = phaseLinearMatrix L.toLinearMap := by
+    ext i j
+    have hh := hA (realPhaseBasis n j)
+    rw [complexifyPhase_realPhaseBasis] at hh
+    cases i with
+    | inl i =>
+      simpa [M, Matrix.map_apply, LinearMap.toMatrix_apply, realPhaseBasis,
+        phaseLinearMatrix, phaseCoordinate, complexifyPhase, complexify] using
+        congrArg (fun z : ComplexPhaseSpace n => z.1 i) hh
+    | inr i =>
+      simpa [M, Matrix.map_apply, LinearMap.toMatrix_apply, realPhaseBasis,
+        phaseLinearMatrix, phaseCoordinate, complexifyPhase, complexify] using
+        congrArg (fun z : ComplexPhaseSpace n => z.2 i) hh
+  have hd : (phaseLinearMatrix L.toLinearMap).det = 1 :=
+    SymplecticGroup.det_eq_one (SymplecticGroup.mem_iff'.mpr
+      ((symplectic_matrix_identity_iff_mathlib _).mp hL.matrix_identity))
+  have he := congrArg Matrix.det hm
+  change (Complex.ofRealHom.mapMatrix M).det = _ at he
+  rw [← RingHom.map_det, hd] at he
+  apply Complex.ofReal_injective
+  simpa [M, LinearMap.det_toMatrix] using he
+
+theorem realPhaseDerivative_commutes {n : ℕ}
+    {f : ComplexPhaseSpace n → ComplexPhaseSpace n} {x : RealPhaseCover n}
+    (hf : DifferentiableAt ℂ f (complexifyPhase x))
+    (hr : ∀ᶠ y in 𝓝 x, complexifyPhase (realPhaseRestriction f y) =
+      f (complexifyPhase y)) (v : RealPhaseCover n) :
+    complexifyPhase (realPhaseDerivative (fderiv ℂ f (complexifyPhase x)) v) =
+      fderiv ℂ f (complexifyPhase x) (complexifyPhase v) := by
+  have ha := (complexifyPhaseCLM n).hasFDerivAt.comp x
+    (hasFDerivAt_realPhaseRestriction hf)
+  have hb := (hf.hasFDerivAt.restrictScalars ℝ).comp x (complexifyPhaseCLM n).hasFDerivAt
+  have he := (ha.congr_of_eventuallyEq (hr.mono fun y hy => hy.symm)).unique hb
+  exact congrArg (fun L : RealPhaseCover n →L[ℝ] ComplexPhaseSpace n => L v) he
+
+namespace Iteration.InitialData
+variable {n : ℕ} {Ω₀ : Set (ComplexSpace n)} {δ₁ θ₀ Θ₀ ρ₀ : ℝ≥0} {κ D : ℝ}
+  (b : InitialParameters n δ₁ θ₀ Θ₀ ρ₀ κ D)
+  (h : InitialData n Ω₀ δ₁ θ₀ Θ₀ ρ₀ D)
+
+theorem cumulative_real_near (s : ℕ) {x : RealPhaseCover n}
+    (hx : x.1 ∈ realSlice (h.limitDomain b)) :
+    ∀ᶠ y in 𝓝 x, complexifyPhase (realPhaseRestriction (h.cumulative b s) y) =
+      h.cumulative b s (complexifyPhase y) := by
+  have hz : complexifyPhase x ∈ h.limitPhase b :=
+    h.commonPhase_subset b ⟨hx, complexify_mem_angleStrip _ _⟩
+  have he := h.phase_buffer b s (h.limitPhase_subset b (s+1) hz)
+  have hp : (0 : ℝ≥0) < beta δ₁ s := pow_pos (b.delta_step_pos s) 3
+  have hne : h.phase b s ∈ 𝓝 (complexifyPhase x) :=
+    Filter.mem_of_superset (Metric.closedBall_mem_nhds (complexifyPhase x) hp) he
+  have hn := (complexifyPhaseCLM n).continuous.continuousAt hne
+  filter_upwards [hn] with y hy
+  exact h.cumulative_realPhase_value b s hy
+
+theorem cumulative_real_det (s : ℕ) {x : RealPhaseCover n}
+    (hx : x.1 ∈ realSlice (h.limitDomain b)) :
+    (fderiv ℝ (realPhaseRestriction (h.cumulative b s)) x).toLinearMap.det = 1 := by
+  have hz : complexifyPhase x ∈ h.limitPhase b :=
+    h.commonPhase_subset b ⟨hx, complexify_mem_angleStrip _ _⟩
+  have hs := h.limitPhase_subset b s hz
+  have hf := (h.cumulative_analytic b s _ hs).differentiableAt
+  rw [(hasFDerivAt_realPhaseRestriction hf).fderiv]
+  exact realPhase_det_eq_one _ _ (h.cumulative_canonical b s _ hs).2
+    (realPhaseDerivative_commutes hf (h.cumulative_real_near b s hx))
+
+theorem cumulative_real_volume (s : ℕ) {K : Set (RealPhaseCover n)}
+    (hK : MeasurableSet K)
+    (hsub : ∀ x ∈ K, x.1 ∈ realSlice (h.limitDomain b)) :
+    volume (realPhaseRestriction (h.cumulative b s) '' K) = volume K := by
+  let : (volume : Measure (RealPhaseCover n)).IsAddHaarMeasure :=
+    Measure.prod.instIsAddHaarMeasure _ _
+  have hz (x : RealPhaseCover n) (hx : x ∈ K) :
+      complexifyPhase x ∈ h.phase b s :=
+    h.limitPhase_subset b s (h.commonPhase_subset b
+      ⟨hsub x hx, complexify_mem_angleStrip _ _⟩)
+  have hd (x : RealPhaseCover n) (hx : x ∈ K) :=
+    hasFDerivAt_realPhaseRestriction (h.cumulative_analytic b s _ (hz x hx)).differentiableAt
+  have hi : InjOn (realPhaseRestriction (h.cumulative b s)) K := by
+    intro x hx y hy he
+    have hec := congrArg complexifyPhase he
+    rw [h.cumulative_realPhase_value b s (hz x hx),
+      h.cumulative_realPhase_value b s (hz y hy)] at hec
+    have hh := h.cumulative_injOn b s (hz x hx) (hz y hy) hec
+    simpa using congrArg realPartPhase hh
+  have he := lintegral_abs_det_fderiv_eq_addHaar_image volume hK
+    (fun x hx => (hd x hx).differentiableAt.hasFDerivAt.hasFDerivWithinAt) hi
+  rw [← he]
+  calc
+    _ = ∫⁻ _ in K, (1 : ℝ≥0∞) := by
+      apply setLIntegral_congr_fun hK
+      intro x hx
+      simp [h.cumulative_real_det b s (hsub x hx)]
+    _ = _ := by simp
+
+end Iteration.InitialData
+end KamProject.Arnold1963
diff --git a/LeanPool/ArnoldKAM/Arnold1963/Step/Averaging.lean b/LeanPool/ArnoldKAM/Arnold1963/Step/Averaging.lean
new file mode 100644
index 0000000000..c5e58d29cd
--- /dev/null
+++ b/LeanPool/ArnoldKAM/Arnold1963/Step/Averaging.lean
@@ -0,0 +1,96 @@
+/-
+Copyright (c) 2026 Bingqi Yu. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Bingqi Yu
+-/
+
+module
+
+public import LeanPool.ArnoldKAM.Arnold1963.Analysis.FourierParameter
+public import LeanPool.ArnoldKAM.Arnold1963.Analysis.SecondCauchy
+public import LeanPool.ArnoldKAM.Arnold1963.Analysis.MeanValue
+public import LeanPool.ArnoldKAM.Arnold1963.Step.IntegrableBounds
+public import LeanPool.ArnoldKAM.Arnold1963.Geometry.GlobalInverse
+
+/-!
+Supporting results for the analytic Hamiltonian KAM construction.
+-/
+
+@[expose] public section
+noncomputable section
+open Set Filter
+open scoped NNReal Topology
+namespace KamProject.Arnold1963
+
+theorem actionFrequency_add {n : ℕ} {a b : ComplexSpace n → ℂ} {p}
+    (ha : DifferentiableAt ℂ a p) (hb : DifferentiableAt ℂ b p) :
+    actionFrequency (fun x => a x + b x) p = actionFrequency a p + actionFrequency b p := by
+  ext j
+  have hd : fderiv ℂ (fun x => a x + b x) p = fderiv ℂ a p + fderiv ℂ b p :=
+    (ha.hasFDerivAt.add hb.hasFDerivAt).fderiv
+  change fderiv ℂ (fun x => a x + b x) p (Pi.single j 1) = _
+  rw [hd]
+  rfl
+
+theorem actionFrequency_add_eventually {n : ℕ} {a b : ComplexSpace n → ℂ} {p}
+    (ha : AnalyticAt ℂ a p) (hb : AnalyticAt ℂ b p) :
+    actionFrequency (fun x => a x + b x) =ᶠ[𝓝 p]
+      (fun x => actionFrequency a x + actionFrequency b x) := by
+  filter_upwards [ha.eventually_analyticAt, hb.eventually_analyticAt] with x hx hy
+  exact actionFrequency_add hx.differentiableAt hy.differentiableAt
+
+namespace AnalyticPhaseFunction
+variable {n : ℕ} {G : Set (ComplexSpace n)} {ρ : ℝ≥0}
+  (f : AnalyticPhaseFunction n G ρ)
+
+/-- The integrable Hamiltonian updated by adding the perturbation's angle average. -/
+def averagedHamiltonian (a : ComplexSpace n → ℂ) : ComplexSpace n → ℂ :=
+  fun p => a p + f.angleAverage p
+
+/-- The frequency correction produced by the perturbation's angle average. -/
+def frequencyShift : ComplexSpace n → ComplexSpace n := actionFrequency f.angleAverage
+
+theorem frequencyShift_analytic : AnalyticOnNhd ℂ f.frequencyShift G :=
+  analyticOnNhd_actionFrequency f.analyticOnNhd_angleAverage
+
+theorem frequencyShift_bound {β : ℝ≥0} (hβ : 0 < β) {M : ℝ}
+    (hf : f.uniformNorm ≤ M) : NormBoundOn f.frequencyShift (erosion G β) (M / β) := by
+  have hM := (f.norm_le_iff.mp hf).nonneg
+  refine ⟨div_nonneg hM β.coe_nonneg, fun p hp => ?_⟩
+  apply (complex_norm_le_iff _ (div_nonneg hM β.coe_nonneg)).mpr
+  intro j
+  exact norm_fderiv_apply_le_div_of_mem_erosion hβ f.analyticOnNhd_angleAverage
+    ⟨hM, fun p hp => (f.norm_angleAverage_le hp).trans hf⟩ hp (by simp [Pi.norm_single])
+
+theorem frequencyShift_derivative_bound {β : ℝ≥0} (hβ : 0 < β) {M : ℝ}
+    (hf : f.uniformNorm ≤ M) {p} (hp : p ∈ erosion G β) :
+    ‖fderiv ℂ f.frequencyShift p‖ ≤ 2 * n * M / (β : ℝ) ^ 2 := by
+  have hM := (f.norm_le_iff.mp hf).nonneg
+  have h := norm_linearMap_le_of_coordinate_bound (fderiv ℂ f.frequencyShift p)
+    (by positivity : 0 ≤ 2 * M / (β : ℝ) ^ 2) (fun i => ?_)
+  · convert h using 1; ring
+  · apply (complex_norm_le_iff _ (by positivity)).mpr
+    intro j
+    rw [frequencyShift, fderiv_actionFrequency_apply
+      (f.analyticOnNhd_angleAverage p (erosion_subset _ _ hp))]
+    exact norm_second_coordinate_le hβ f.analyticOnNhd_angleAverage
+      ⟨hM, fun p hp => (f.norm_angleAverage_le hp).trans hf⟩ hp i j
+
+theorem frequencyShift_conj {β : ℝ≥0} (hβ : 0 < β) {p}
+    (hp : p ∈ erosion G β) : f.frequencyShift (conjVec p) = conjVec (f.frequencyShift p) := by
+  apply actionFrequency_conj_of_mem_nhds
+    (f.analyticOnNhd_angleAverage p (erosion_subset _ _ hp))
+    (fun _ hx => f.angleAverage_conj hx)
+  have hh := erosion_mem_nhds (r := 0) hβ
+    (show conjVec p ∈ erosion G (0 + β) by
+      simpa using star_mem_erosion f.domain_conj hp)
+  simpa only [erosion_zero] using hh
+
+theorem averagedHamiltonian_frequency {a : ComplexSpace n → ℂ}
+    (ha : AnalyticOnNhd ℂ a G) {p} (hp : p ∈ G) :
+    actionFrequency (f.averagedHamiltonian a) p = actionFrequency a p + f.frequencyShift p :=
+  actionFrequency_add (ha p hp).differentiableAt
+    (f.analyticOnNhd_angleAverage p hp).differentiableAt
+
+end AnalyticPhaseFunction
+end KamProject.Arnold1963
diff --git a/LeanPool/ArnoldKAM/Arnold1963/Step/AveragingConstruction.lean b/LeanPool/ArnoldKAM/Arnold1963/Step/AveragingConstruction.lean
new file mode 100644
index 0000000000..057fecfd0e
--- /dev/null
+++ b/LeanPool/ArnoldKAM/Arnold1963/Step/AveragingConstruction.lean
@@ -0,0 +1,118 @@
+/-
+Copyright (c) 2026 Bingqi Yu. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Bingqi Yu
+-/
+
+module
+
+public import LeanPool.ArnoldKAM.Arnold1963.Step.Averaging
+public import LeanPool.ArnoldKAM.Arnold1963.Step.IterationParameters
+public import LeanPool.ArnoldKAM.Arnold1963.Step.FrequencyPreparation
+
+/-!
+Supporting results for the analytic Hamiltonian KAM construction.
+-/
+
+@[expose] public section
+noncomputable section
+open Set Filter
+open scoped NNReal Topology
+namespace KamProject.Arnold1963
+
+/-- The analytic chart and quantitative hypotheses required for one inductive KAM step. -/
+structure IterationInput {n : ℕ} {G Ω : Set (ComplexSpace n)}
+    {ρ : ℝ≥0} (a : ComplexSpace n → ℂ) (f : AnalyticPhaseFunction n G ρ)
+    (g : ComplexSpace n → ComplexSpace n) (β δ γ θ Θ : ℝ≥0) (K M : ℝ) : Prop where
+  chart : AnalyticFrequencyChart (actionFrequency a) g G Ω
+  analytic : AnalyticOnNhd ℂ a G
+  conj : ∀ p ∈ G, a (conjVec p) = star (a p)
+  lower : ∀ p ∈ G, ∀ v, (θ : ℝ) * ‖v‖ ≤ ‖fderiv ℂ (actionFrequency a) p v‖
+  upper : ∀ p ∈ G, ‖fderiv ℂ (actionFrequency a) p‖ ≤ Θ
+  perturbation : f.uniformNorm ≤ M
+  budget : IterationParameters n ρ β δ γ θ Θ K M
+
+namespace IterationInput
+variable {n : ℕ} {G Ω : Set (ComplexSpace n)} {ρ β δ γ θ Θ : ℝ≥0} {K M : ℝ}
+  {a : ComplexSpace n → ℂ} {f : AnalyticPhaseFunction n G ρ}
+  {g : ComplexSpace n → ComplexSpace n} (i : IterationInput (Ω := Ω) a f g β δ γ θ Θ K M)
+include i
+
+theorem frequencyChange : FrequencyChangeInput (actionFrequency a) g f.frequencyShift
+    G Ω β δ θ Θ where
+  chart := i.chart
+  radius_pos := i.budget.beta_pos
+  contraction := i.budget.delta_lt_one
+  lower_pos := i.budget.lower_pos
+  lower_le_upper := i.budget.lower_le_upper
+  lower := i.lower
+  upper := i.upper
+  analytic := f.frequencyShift_analytic.mono (erosion_subset _ _)
+  bounded := ⟨β.coe_nonneg, fun _ hp =>
+    ((f.frequencyShift_bound i.budget.beta_pos i.perturbation).norm_le hp).trans
+      (i.budget.mean_gradient_small.le.trans
+        (by
+          have hd : (δ : ℝ) ≤ 1 := i.budget.delta_lt_one.le
+          simpa using mul_le_mul_of_nonneg_left hd β.coe_nonneg))⟩
+  derivative := fun _ hp => (f.frequencyShift_derivative_bound i.budget.beta_pos
+    i.perturbation hp).trans i.budget.mean_hessian_small.le
+  conj := fun _ hp => f.frequencyShift_conj i.budget.beta_pos hp
+
+/-- The updated integrable Hamiltonian after absorbing the angle average. -/
+def newIntegrable (_ : IterationInput (Ω := Ω) a f g β δ γ θ Θ K M) :
+    ComplexSpace n → ℂ := f.averagedHamiltonian a
+
+/-- The centered perturbation restricted to the once-eroded action domain. -/
+def centeredPerturbation (_ : IterationInput (Ω := Ω) a f g β δ γ θ Θ K M) :
+    AnalyticPhaseFunction n (erosion G β) ρ :=
+  f.centered.restrict (erosion_subset _ _) le_rfl
+    (fun _ hp => star_mem_erosion f.domain_conj hp)
+
+theorem frequency_eventually {p} (hp : p ∈ G) :
+    actionFrequency i.newIntegrable =ᶠ[𝓝 p]
+      (fun p => actionFrequency a p + f.frequencyShift p) :=
+  actionFrequency_add_eventually (i.analytic p hp) (f.analyticOnNhd_angleAverage p hp)
+
+theorem newIntegrable_data : IntegrableData i.newIntegrable (erosion G β) (2 * Θ) := by
+  apply IntegrableData.of_frequency_bound (h := i.newIntegrable)
+    ((i.analytic.add f.analyticOnNhd_angleAverage).mono (erosion_subset _ _))
+  · intro p hp
+    change a (conjVec p) + f.angleAverage (conjVec p) = star (a p + f.angleAverage p)
+    rw [i.conj _ (erosion_subset _ _ hp), f.angleAverage_conj (erosion_subset _ _ hp), star_add]
+  · intro p hp
+    rw [(i.frequency_eventually (p := conjVec p)
+        (erosion_subset _ _ (star_mem_erosion f.domain_conj hp))).self_of_nhds,
+      (i.frequency_eventually (erosion_subset _ _ hp)).self_of_nhds]
+    dsimp only
+    rw [i.chart.map_conj _ (erosion_subset _ _ hp), f.frequencyShift_conj i.budget.beta_pos hp]
+    simp
+  · intro p hp
+    have hd : fderiv ℂ (fun p => actionFrequency a p + f.frequencyShift p) p =
+        fderiv ℂ (actionFrequency a) p + fderiv ℂ f.frequencyShift p :=
+      ((i.chart.analytic p (erosion_subset _ _ hp)).differentiableAt.hasFDerivAt.add
+        (f.frequencyShift_analytic p (erosion_subset _ _ hp)).differentiableAt.hasFDerivAt).fderiv
+    rw [(i.frequency_eventually (erosion_subset _ _ hp)).fderiv_eq, hd]
+    calc
+      _ ≤ ‖fderiv ℂ (actionFrequency a) p‖ + ‖fderiv ℂ f.frequencyShift p‖ := norm_add_le _ _
+      _ ≤ (Θ : ℝ) + (δ : ℝ) * θ := add_le_add (i.upper _ (erosion_subset _ _ hp))
+        (i.frequencyChange.derivative p hp)
+      _ ≤ 2 * Θ := by
+        have hle := mul_le_mul (show (δ : ℝ) ≤ 1 from i.budget.delta_lt_one.le)
+          (show (θ : ℝ) ≤ Θ from i.budget.lower_le_upper)
+          θ.coe_nonneg (show (0 : ℝ) ≤ 1 by norm_num)
+        nlinarith
+
+theorem fundamental : FundamentalInput
+    (E := i.frequencyChange.iterationE K (fundamentalCutoff γ (2 * M)))
+    (β := β) (δ := δ) (γ := γ) (K := K) (M := 2 * M) (Θ := 2 * Θ)
+    i.newIntegrable i.centeredPerturbation := by
+  apply i.frequencyChange.fundamentalInput i.newIntegrable_data
+    (fun p hp => (i.frequency_eventually (erosion_subset _ _ hp)).self_of_nhds)
+    i.budget.fundamental
+  · exact (f.centered.uniformNorm_restrict_le _ _ _).trans
+      (f.uniformNorm_centered_le.trans (mul_le_mul_of_nonneg_left i.perturbation (by norm_num)))
+  · intro p hp
+    exact f.angleAverage_centered_eq_zero (erosion_subset _ _ hp)
+
+end IterationInput
+end KamProject.Arnold1963
diff --git a/LeanPool/ArnoldKAM/Arnold1963/Step/Construction.lean b/LeanPool/ArnoldKAM/Arnold1963/Step/Construction.lean
new file mode 100644
index 0000000000..e2ff7381eb
--- /dev/null
+++ b/LeanPool/ArnoldKAM/Arnold1963/Step/Construction.lean
@@ -0,0 +1,106 @@
+/-
+Copyright (c) 2026 Bingqi Yu. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Bingqi Yu
+-/
+
+module
+
+public import LeanPool.ArnoldKAM.Arnold1963.Step.DomainGeometry
+public import LeanPool.ArnoldKAM.Arnold1963.Step.Integrable
+
+/-!
+Supporting results for the analytic Hamiltonian KAM construction.
+-/
+
+@[expose] public section
+noncomputable section
+open Set
+open scoped NNReal
+namespace KamProject.Arnold1963
+
+/-- The analytic, nonresonance and numerical hypotheses for the fundamental KAM construction. -/
+structure FundamentalInput {n : ℕ} {G E : Set (ComplexSpace n)}
+    {ρ β δ γ : ℝ≥0} {K M Θ : ℝ}
+    (h : ComplexSpace n → ℂ) (f : AnalyticPhaseFunction n G ρ) : Prop where
+  integrable : IntegrableData h G Θ
+  domain_subset : E ⊆ G
+  domain_conj : ConjInvariant E
+  perturbation_bound : f.uniformNorm ≤ M
+  mean_zero : ∀ p ∈ E, f.angleAverage p = 0
+  nonresonant : ∀ p ∈ E,
+    FiniteNonresonant (actionFrequency h p) K (fundamentalCutoff γ M)
+  budget : FundamentalParameters n ρ β δ γ K M Θ
+
+namespace FundamentalInput
+variable {n : ℕ} {G E : Set (ComplexSpace n)} {ρ β δ γ : ℝ≥0} {K M Θ : ℝ}
+  {h : ComplexSpace n → ℂ} {f : AnalyticPhaseFunction n G ρ}
+  (i : FundamentalInput (E := E) (β := β) (δ := δ) (γ := γ) (K := K) (M := M) (Θ := Θ) h f)
+
+/-- The bounded analytic generating function solving the finite homological equation. -/
+def generator : AnalyticPhaseFunction n E (ρ - (δ + δ)) :=
+  homologicalFunction f (actionFrequency h) i.domain_subset i.domain_conj
+    ((analyticOnNhd_actionFrequency i.integrable.analytic).mono i.domain_subset)
+    (fun p hp => i.integrable.frequency_conj p (i.domain_subset hp)) i.nonresonant
+    i.budget.K_pos i.perturbation_bound i.budget.delta_pos
+    (by exact_mod_cast (show (δ : ℝ) ≤ 1 by linarith [i.budget.delta_lt])) i.budget.double_delta_le
+
+theorem generator_bound : i.generator.uniformNorm ≤ homologicalBound n M K δ :=
+  norm_homologicalFunction_le f (actionFrequency h) _ _ _ _ _ _ _ _ _ _
+
+theorem generatingData : GeneratingData i.generator.toFun E
+    (angleStrip n (ρ - (δ + δ))) β (homologicalBound n M K δ) :=
+  GeneratingData.of_arnold i.budget.dimension_pos i.budget.beta_pos i.generator.analytic
+    (i.generator.norm_le_iff.mp i.generator_bound) i.budget.generating_small
+
+/-- The phase transformation obtained from the fundamental step's generating function. -/
+def transform : ComplexPhaseSpace n → ComplexPhaseSpace n :=
+  generatingTransform i.generator.toFun E (angleStrip n (ρ - (δ + δ))) β
+
+/-- The fundamental canonical transformation on its retained phase domain. -/
+def transformation : AnalyticCanonicalTransformation
+    (phaseDomain (erosion E (β + β)) (ρ - (γ + γ))) (phaseDomain G ρ)
+    (homologicalBound n M K δ / β) :=
+  let B := i.generatingData.transformation.restrict (i.budget.target_subset E)
+  { B with mapsTo := fun _ hz =>
+      ⟨i.domain_subset (B.mapsTo hz).1,
+        angleStrip_mono (tsub_le_self : ρ - (δ + δ) ≤ ρ) (B.mapsTo hz).2⟩ }
+
+include i
+
+theorem displacement {z : ComplexPhaseSpace n}
+    (hz : z ∈ phaseDomain (erosion E (β + β)) (ρ - (γ + γ))) :
+    ‖i.transform z - z‖ ≤ homologicalBound n M K δ / β :=
+  i.transformation.displacement.norm_le hz
+
+theorem action_displacement {z : ComplexPhaseSpace n}
+    (hz : z ∈ phaseDomain (erosion E (β + β)) (ρ - (γ + γ))) :
+    ‖(i.transform z).1 - z.1‖ ≤ homologicalBound n M K δ / δ :=
+  i.generatingData.action_displacement i.budget.delta_pos hz.1 (i.budget.target_angle_buffer hz.2)
+
+theorem action_displacement_beta {z : ComplexPhaseSpace n}
+    (hz : z ∈ phaseDomain (erosion E (β + β)) (ρ - (γ + γ))) :
+    ‖(i.transform z).1 - z.1‖ ≤ β :=
+  (norm_fst_le (i.transform z - z)).trans
+    ((i.displacement hz).trans i.budget.displacement_lt_beta.le)
+
+theorem angle_displacement_beta {z : ComplexPhaseSpace n}
+    (hz : z ∈ phaseDomain (erosion E (β + β)) (ρ - (γ + γ))) :
+    dist (i.transform z).2 z.2 ≤ β := by
+  rw [dist_eq_norm]
+  exact (norm_snd_le (i.transform z - z)).trans
+    ((i.displacement hz).trans i.budget.displacement_lt_beta.le)
+
+theorem action_segment {z : ComplexPhaseSpace n}
+    (hz : z ∈ phaseDomain (erosion E (β + β)) (ρ - (γ + γ))) :
+    segment ℝ z.1 (i.transform z).1 ⊆ erosion G β :=
+  (segment_subset_erosion_of_displacement hz.1 (i.action_displacement_beta hz)).trans
+    (erosion_mono i.domain_subset β)
+
+theorem transformed_angle {z : ComplexPhaseSpace n}
+    (hz : z ∈ phaseDomain (erosion E (β + β)) (ρ - (γ + γ))) :
+    (i.transform z).2 ∈ angleStrip n (ρ - (δ + γ)) :=
+  i.budget.shifted_angle_tail hz.2 (i.angle_displacement_beta hz)
+
+end FundamentalInput
+end KamProject.Arnold1963
diff --git a/LeanPool/ArnoldKAM/Arnold1963/Step/DomainGeometry.lean b/LeanPool/ArnoldKAM/Arnold1963/Step/DomainGeometry.lean
new file mode 100644
index 0000000000..839963e641
--- /dev/null
+++ b/LeanPool/ArnoldKAM/Arnold1963/Step/DomainGeometry.lean
@@ -0,0 +1,99 @@
+/-
+Copyright (c) 2026 Bingqi Yu. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Bingqi Yu
+-/
+
+module
+
+public import LeanPool.ArnoldKAM.Arnold1963.Step.NumericalBudget
+
+/-!
+Supporting results for the analytic Hamiltonian KAM construction.
+-/
+
+@[expose] public section
+noncomputable section
+open Set
+open scoped NNReal
+namespace KamProject.Arnold1963
+
+theorem mem_erosion_angleStrip {n : ℕ} {q : ComplexSpace n} {σ r : ℝ≥0}
+    (hq : ‖imagPart q‖ + (r : ℝ) ≤ σ) : q ∈ erosion (angleStrip n σ) r := by
+  intro q' hd
+  apply (mem_angleStrip_iff _ _).2
+  intro j
+  have hv : |(q' j - q j).im| ≤ (r : ℝ) :=
+    (Complex.abs_im_le_norm _).trans ((norm_le_pi_norm (q' - q) j).trans
+      (by simpa only [Metric.mem_closedBall, dist_eq_norm] using hd))
+  have hj : |(q j).im| ≤ ‖imagPart q‖ := norm_le_pi_norm (imagPart q) j
+  have he : (q' j).im = (q' j - q j).im + (q j).im := by simp
+  rw [he]
+  exact (abs_add_le _ _).trans (by linarith)
+
+namespace FundamentalParameters
+variable {n : ℕ} {ρ β δ γ : ℝ≥0} {K M Θ : ℝ}
+  (b : FundamentalParameters n ρ β δ γ K M Θ)
+include b
+
+theorem double_gamma_le : γ + γ ≤ ρ := by
+  exact_mod_cast (show (γ : ℝ) + γ ≤ ρ by linarith [b.angle_width])
+
+theorem beta_delta_le_gamma : β + δ ≤ γ := by
+  have hδ := δ.coe_nonneg
+  exact_mod_cast (show (β : ℝ) + δ ≤ γ by linarith [b.action_loss, b.angle_loss])
+
+theorem triple_beta_le : β + β + β ≤ ρ - (δ + δ) := by
+  rw [← NNReal.coe_le_coe, NNReal.coe_sub b.double_delta_le]
+  simp only [NNReal.coe_add]
+  linarith [b.action_loss, b.angle_loss, b.angle_width, δ.coe_nonneg]
+
+theorem action_buffer_loss_lt :
+    2 * (δ : ℝ) + (3 * β + δ) < 2 * γ := by
+  have hδ : (0 : ℝ) < δ := b.delta_pos
+  linarith [b.action_loss, b.angle_loss]
+
+theorem target_angle_buffer {q : ComplexSpace n}
+    (hq : q ∈ angleStrip n (ρ - (γ + γ))) :
+    q ∈ erosion (angleStrip n (ρ - (δ + δ))) ((β + β + β) + δ) := by
+  apply mem_erosion_angleStrip
+  change ‖imagPart q‖ ≤ (↑(ρ - (γ + γ)) : ℝ) at hq
+  rw [NNReal.coe_sub b.double_gamma_le, NNReal.coe_add] at hq
+  rw [NNReal.coe_sub b.double_delta_le]
+  simp only [NNReal.coe_add]
+  linarith [b.action_buffer_loss_lt]
+
+theorem target_subset (E : Set (ComplexSpace n)) :
+    phaseDomain (erosion E (β + β)) (ρ - (γ + γ)) ⊆
+      generatingTarget E (angleStrip n (ρ - (δ + δ))) β := by
+  intro z hz
+  exact ⟨hz.1, erosion_antitone_radius _ (show β + β + β ≤ (β + β + β) + δ
+    from le_self_add) (b.target_angle_buffer hz.2)⟩
+
+theorem shifted_angle_tail {q Q : ComplexSpace n}
+    (hQ : Q ∈ angleStrip n (ρ - (γ + γ))) (hd : dist q Q ≤ β) :
+    q ∈ angleStrip n (ρ - (δ + γ)) := by
+  have hδγ : δ + γ ≤ γ + γ := by
+    exact_mod_cast (show (δ : ℝ) + γ ≤ γ + γ by
+      linarith [b.angle_loss, δ.coe_nonneg])
+  have hδγρ := hδγ.trans b.double_gamma_le
+  have hb : ‖imagPart Q‖ + (β : ℝ) ≤ ↑(ρ - (δ + γ)) := by
+    change ‖imagPart Q‖ ≤ (↑(ρ - (γ + γ)) : ℝ) at hQ
+    rw [NNReal.coe_sub b.double_gamma_le, NNReal.coe_add] at hQ
+    rw [NNReal.coe_sub hδγρ, NNReal.coe_add]
+    have hh : (β : ℝ) + δ ≤ γ := b.beta_delta_le_gamma
+    linarith
+  exact mem_erosion_angleStrip hb hd
+
+end FundamentalParameters
+
+theorem segment_subset_erosion_of_displacement {n : ℕ} {E : Set (ComplexSpace n)}
+    {P p : ComplexSpace n} {β : ℝ≥0} (hP : P ∈ erosion E (β + β))
+    (hp : ‖p - P‖ ≤ β) : segment ℝ P p ⊆ erosion E β := by
+  have hs : segment ℝ P p ⊆ Metric.closedBall P (β : ℝ) :=
+    (convex_closedBall P (β : ℝ)).segment_subset
+      (Metric.mem_closedBall_self β.coe_nonneg)
+      (by simpa only [Metric.mem_closedBall, dist_eq_norm] using hp)
+  exact fun _ hx => mem_erosion_of_dist_le hP (hs hx)
+
+end KamProject.Arnold1963
diff --git a/LeanPool/ArnoldKAM/Arnold1963/Step/FourierDifferential.lean b/LeanPool/ArnoldKAM/Arnold1963/Step/FourierDifferential.lean
new file mode 100644
index 0000000000..ffef70f653
--- /dev/null
+++ b/LeanPool/ArnoldKAM/Arnold1963/Step/FourierDifferential.lean
@@ -0,0 +1,80 @@
+/-
+Copyright (c) 2026 Bingqi Yu. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Bingqi Yu
+-/
+
+module
+
+public import LeanPool.ArnoldKAM.Arnold1963.Step.Nonresonance
+public import LeanPool.ArnoldKAM.Arnold1963.Analysis.ShiftedFourier
+
+/-!
+Supporting results for the analytic Hamiltonian KAM construction.
+-/
+
+@[expose] public section
+noncomputable section
+open Set Complex
+namespace KamProject.Arnold1963
+
+/-- Pairing with an integer Fourier index as a continuous complex linear functional. -/
+def indexPairingCLM {n : ℕ} (k : FourierIndex n) : ComplexSpace n →L[ℂ] ℂ :=
+  ∑ j, (k j : ℂ) • ContinuousLinearMap.proj j
+
+@[simp] theorem indexPairingCLM_apply {n : ℕ} (k : FourierIndex n) (q : ComplexSpace n) :
+    indexPairingCLM k q = indexPairing k q := by
+  simp [indexPairingCLM, indexPairing]
+
+theorem fderiv_fourierMonomial {n : ℕ} (k : FourierIndex n) (q v : ComplexSpace n) :
+    fderiv ℂ (fourierMonomial k) q v =
+      (I * indexPairing k v) * fourierMonomial k q := by
+  have hd := ((indexPairingCLM k).hasFDerivAt (x := q)).const_mul I |>.cexp
+  simp only [indexPairingCLM_apply] at hd
+  change HasFDerivAt (𝕜 := ℂ) (fourierMonomial k) _ q at hd
+  rw [hd.fderiv]
+  simp [fourierMonomial, mul_comm, mul_left_comm]
+
+theorem fourierMonomial_periodic {n : ℕ} (k m : FourierIndex n) (q : ComplexSpace n) :
+    fourierMonomial k (q + angleShift m) = fourierMonomial k q := by
+  rw [fourierMonomial_add]
+  have he : I * indexPairing k (angleShift m) =
+      (∑ j, k j * m j : ℤ) * (2 * Real.pi * I) := by
+    simp only [indexPairing, angleShift, complexify, Int.cast_sum, Int.cast_mul,
+      ofReal_mul, ofReal_ofNat, ofReal_intCast, Finset.mul_sum, Finset.sum_mul]
+    apply Finset.sum_congr rfl
+    intro j _
+    ring
+  simp only [fourierMonomial]
+  rw [he, exp_int_mul_two_pi_mul_I, mul_one]
+
+theorem fourierMonomial_conj_neg {n : ℕ} (k : FourierIndex n) (q : ComplexSpace n) :
+    fourierMonomial (-k) (conjVec q) = star (fourierMonomial k q) := by
+  simp only [fourierMonomial, indexPairing_neg, indexPairing_conj]
+  simp [← Complex.exp_conj]
+
+theorem sum_lowModes_neg {n : ℕ} {A : Type*} [AddCommMonoid A]
+    (N : ℝ) (f : FourierIndex n → A) :
+    ∑ k ∈ lowModes n N, f (-k) = ∑ k ∈ lowModes n N, f k := by
+  apply Finset.sum_bij (fun k _ => -k)
+  · intro k hk; exact neg_mem_lowModes.mpr hk
+  · intro a _ b _ he; exact neg_injective he
+  · intro k hk; exact ⟨-k, neg_mem_lowModes.mpr hk, neg_neg k⟩
+  · intro k _; rfl
+
+theorem angle_fderiv_eq_sum_qGradient {n : ℕ} {S : ComplexPhaseSpace n → ℂ}
+    {p q : ComplexSpace n} (ha : AnalyticAt ℂ S (p, q)) (v : ComplexSpace n) :
+    fderiv ℂ (fun t => S (p, t)) q v = ∑ j, v j * qGradient S (p, q) j := by
+  have hd := ha.differentiableAt.hasFDerivAt.comp q
+    ((hasFDerivAt_const p q).prodMk (hasFDerivAt_id (𝕜 := ℂ) q))
+  change fderiv ℂ (S ∘ Prod.mk p) q v = _
+  rw [hd.fderiv]
+  change fderiv ℂ S (p, q) (0, v) = _
+  have he : (0, v) = ∑ j, v j • qDirection j := by
+    apply Prod.ext
+    · simp [qDirection, Prod.fst_sum]
+    · simpa [qDirection, Prod.snd_sum] using (pi_eq_sum_univ' v)
+  rw [he, map_sum]
+  simp [qGradient, map_smul]
+
+end KamProject.Arnold1963
diff --git a/LeanPool/ArnoldKAM/Arnold1963/Step/FrequencyPreparation.lean b/LeanPool/ArnoldKAM/Arnold1963/Step/FrequencyPreparation.lean
new file mode 100644
index 0000000000..95df4121ae
--- /dev/null
+++ b/LeanPool/ArnoldKAM/Arnold1963/Step/FrequencyPreparation.lean
@@ -0,0 +1,143 @@
+/-
+Copyright (c) 2026 Bingqi Yu. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Bingqi Yu
+-/
+
+module
+
+public import LeanPool.ArnoldKAM.Arnold1963.Geometry.FrequencyDomain
+public import LeanPool.ArnoldKAM.Arnold1963.Arithmetic.ResonanceLoss
+public import LeanPool.ArnoldKAM.Arnold1963.Step.Fundamental
+
+/-!
+Supporting results for the analytic Hamiltonian KAM construction.
+-/
+
+@[expose] public section
+noncomputable section
+open Set Metric
+open scoped NNReal ENNReal
+namespace KamProject.Arnold1963
+
+theorem frequencyLossRadius_three (Θ β : ℝ≥0) :
+    frequencyLossRadius Θ β (3 * β) = (5 + 7 * Θ) * β := by
+  unfold frequencyLossRadius frequencyOuterRadius
+  ring
+
+theorem frequencyMeasureRadius_three (Θ β : ℝ≥0) :
+    frequencyLossRadius Θ β (3 * β) + β = (6 + 7 * Θ) * β := by
+  rw [frequencyLossRadius_three]
+  ring
+
+theorem neighborhood_subset_erosion_neighborhood {n : ℕ} (S : Set (ComplexSpace n))
+    (r t : ℝ≥0) : closedBallNeighborhood S r ⊆ erosion (closedBallNeighborhood S (r + t)) t := by
+  rintro x ⟨p, hp, hxp⟩ y hy
+  exact ⟨p, hp, (dist_triangle y x p).trans (by
+    change dist y x ≤ (t : ℝ) at hy
+    change dist x p ≤ (r : ℝ) at hxp
+    simp only [NNReal.coe_add]
+    linarith)⟩
+
+theorem neighborhood_conj {n : ℕ} {S : Set (ComplexSpace n)}
+    (hS : ConjInvariant S) (r : ℝ≥0) : ConjInvariant (closedBallNeighborhood S r) := by
+  rintro x ⟨p, hp, hxp⟩
+  refine ⟨conjVec p, hS _ hp, ?_⟩
+  simpa only [conjVec_eq_star, dist_star_star] using hxp
+
+namespace FrequencyChangeInput
+variable {n : ℕ} {A g Δ : ComplexSpace n → ComplexSpace n}
+  {G Ω : Set (ComplexSpace n)} {β κ θ Θ : ℝ≥0}
+  (h : FrequencyChangeInput A g Δ G Ω β κ θ Θ)
+
+/-- The corrected action domain retained after finite resonance removal and erosion. -/
+def iterationDomain (K N : ℝ) : Set (ComplexSpace n) :=
+  h.innerDomain (nonresonantDomain Ω id K N) (3 * β)
+/-- A closed-ball neighborhood of the retained inductive action domain. -/
+def iterationE (K N : ℝ) : Set (ComplexSpace n) :=
+  closedBallNeighborhood (h.iterationDomain K N) (3 * β)
+
+theorem iterationChart (K N : ℝ) :
+    AnalyticFrequencyChart (fun p => A p + Δ p) h.newInverse (h.iterationDomain K N)
+      (erosion (nonresonantDomain Ω id K N) ((5 + 7 * Θ) * β)) := by
+  have hh := h.innerChart (fun _ hx => hx.1)
+    (isCompact_nonresonant_frequency_domain h.chart.image_compact K N)
+    (nonresonantDomain_conj h.chart.image_conj (fun _ _ => rfl)) (3 * β)
+  simpa only [iterationDomain, innerFrequency, frequencyLossRadius_three] using hh
+
+theorem iterationE_subset (K N : ℝ) : h.iterationE K N ⊆ erosion G β :=
+  (h.neighborhood_subset (fun _ hx => hx.1) (3 * β)).trans h.outer_subset
+
+theorem iteration_derivative_bounds (K N : ℝ) {p} (hp : p ∈ h.iterationDomain K N)
+    (v : ComplexSpace n) :
+    ((θ : ℝ) * (1 - (κ : ℝ))) * ‖v‖ ≤ ‖fderiv ℂ (fun x => A x + Δ x) p v‖ ∧
+      ‖fderiv ℂ (fun x => A x + Δ x) p v‖ ≤ ((Θ : ℝ) * (1 + (κ : ℝ))) * ‖v‖ :=
+  h.new_derivative_bounds (h.inner_subset_outerDomain (fun _ hx => hx.1) (3 * β) hp) v
+
+theorem iterationE_nonresonant (K N : ℝ) {p} (hp : p ∈ h.iterationE K N) :
+    FiniteNonresonant (A p + Δ p) K N :=
+  (h.neighborhood_maps (fun _ hx => hx.1) (3 * β) hp).2
+
+theorem iterationE_compact (K N : ℝ) : IsCompact (h.iterationE K N) :=
+  isCompact_closedBallNeighborhood (h.iterationChart K N).compact _
+
+theorem iterationE_conj (K N : ℝ) : ConjInvariant (h.iterationE K N) :=
+  neighborhood_conj (h.iterationChart K N).domain_conj _
+
+theorem iteration_target_buffer (K N : ℝ) :
+    closedBallNeighborhood (h.iterationDomain K N) β ⊆ erosion (h.iterationE K N) (β + β) := by
+  have hh := neighborhood_subset_erosion_neighborhood (h.iterationDomain K N) β (β + β)
+  have he : β + (β + β) = 3 * β := by ring
+  simpa only [he, iterationE] using hh
+
+theorem iteration_measure (K N : ℝ) :
+    realVolume (G \ h.iterationDomain K N) ≤ ENNReal.ofReal ((θ : ℝ)⁻¹ ^ n) *
+      realVolume (Ω \ erosion (nonresonantDomain Ω id K N) ((6 + 7 * Θ) * β)) := by
+  have hh := h.measure_loss (fun _ hx => hx.1)
+    (isCompact_nonresonant_frequency_domain h.chart.image_compact K N) (3 * β)
+  simpa only [iterationDomain, frequencyMeasureRadius_three] using hh
+
+theorem fundamentalInput {ρ δ γ : ℝ≥0} {K M T : ℝ}
+    {Hbar : ComplexSpace n → ℂ} {f : AnalyticPhaseFunction n (erosion G β) ρ}
+    (hi : IntegrableData Hbar (erosion G β) T)
+    (hfreq : ∀ p ∈ erosion G β, actionFrequency Hbar p = A p + Δ p)
+    (hb : FundamentalParameters n ρ β δ γ K (2 * M) T)
+    (hf : f.uniformNorm ≤ 2 * M) (hzero : ∀ p ∈ erosion G β, f.angleAverage p = 0) :
+    FundamentalInput (E := h.iterationE K (fundamentalCutoff γ (2 * M)))
+      (β := β) (δ := δ) (γ := γ) (K := K) (M := 2 * M) (Θ := T) Hbar f where
+  integrable := hi
+  domain_subset := h.iterationE_subset _ _
+  domain_conj := h.iterationE_conj _ _
+  perturbation_bound := hf
+  mean_zero := fun _ hp => hzero _ (h.iterationE_subset _ _ hp)
+  nonresonant := by
+    intro p hp
+    rw [hfreq _ (h.iterationE_subset _ _ hp)]
+    exact h.iterationE_nonresonant _ _ hp
+  budget := hb
+
+end FrequencyChangeInput
+
+theorem frequency_iteration_next_chart {n : ℕ} {K N₀ N : ℝ}
+    {A g Δ : ComplexSpace n → ComplexSpace n} {G Ωbase : Set (ComplexSpace n)}
+    {β κ θ Θ : ℝ≥0} (s : ResonanceDomainState n K N₀)
+    (h : FrequencyChangeInput A g Δ G (s.domain Ωbase) β κ θ Θ)
+    (hK : 0 < K) (hNN : N₀ ≤ N) :
+    AnalyticFrequencyChart (fun p => A p + Δ p) h.newInverse (h.iterationDomain K N)
+      ((s.next hK hNN ((5 + 7 * Θ) * β)).domain Ωbase) := by
+  rw [s.next_domain]
+  exact h.iterationChart K N
+
+theorem frequency_iteration_measure_budget {n : ℕ} {K N₀ N D : ℝ}
+    {A g Δ : ComplexSpace n → ComplexSpace n} {G Ωbase : Set (ComplexSpace n)}
+    {β κ θ Θ : ℝ≥0} (s : ResonanceDomainState n K N₀)
+    (h : FrequencyChangeInput A g Δ G (s.domain Ωbase) β κ θ Θ)
+    (hD : TypeD Ωbase D) (hn : 0 < n) (hK : 0 < K)
+    (hN₀ : 1 ≤ N₀) (hN : 1 < N) (hNN : N₀ ≤ N) :
+    realVolume (G \ h.iterationDomain K N) ≤ ENNReal.ofReal ((θ : ℝ)⁻¹ ^ n) *
+      (ENNReal.ofReal (resonanceLossConstant n * D *
+        (K * newShellBudget N₀ N + (((6 + 7 * Θ) * β : ℝ≥0) : ℝ) * N ^ n)) * realVolume Ωbase) :=
+  (h.iteration_measure K N).trans (mul_le_mul' le_rfl
+    (hD.ar_loss_le s hn hK hN₀ hN hNN ((6 + 7 * Θ) * β)))
+
+end KamProject.Arnold1963
diff --git a/LeanPool/ArnoldKAM/Arnold1963/Step/Fundamental.lean b/LeanPool/ArnoldKAM/Arnold1963/Step/Fundamental.lean
new file mode 100644
index 0000000000..f2bd8dfe6e
--- /dev/null
+++ b/LeanPool/ArnoldKAM/Arnold1963/Step/Fundamental.lean
@@ -0,0 +1,138 @@
+/-
+Copyright (c) 2026 Bingqi Yu. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Bingqi Yu
+-/
+
+module
+
+public import LeanPool.ArnoldKAM.Arnold1963.Step.Remainder
+
+/-!
+Supporting results for the analytic Hamiltonian KAM construction.
+-/
+
+@[expose] public section
+noncomputable section
+open Set
+open scoped NNReal
+namespace KamProject.Arnold1963
+
+namespace FundamentalInput
+variable {n : ℕ} {G E : Set (ComplexSpace n)} {ρ β δ γ : ℝ≥0} {K M Θ : ℝ}
+  {h : ComplexSpace n → ℂ} {f : AnalyticPhaseFunction n G ρ}
+  (i : FundamentalInput (E := E) (β := β) (δ := δ) (γ := γ) (K := K) (M := M) (Θ := Θ) h f)
+
+/-- The transformed Hamiltonian remainder packaged as an analytic perturbation. -/
+def newPerturbation : AnalyticPhaseFunction n (erosion E (β + β)) (ρ - (γ + γ)) where
+  toFun := i.remainder
+  domain_conj := fun _ hp => star_mem_erosion i.domain_conj hp
+  analytic := by
+    intro z hz
+    have hB : AnalyticAt ℂ i.transform z := i.transformation.analytic z hz
+    have hm : i.transform z ∈ phaseDomain G ρ := i.transformation.mapsTo hz
+    have hpB : AnalyticAt ℂ (fun x => (i.transform x).1) z :=
+      analyticAt_fst.comp (f := i.transform) hB
+    exact (((i.integrable.analytic _ hm.1).comp
+      (f := fun x => (i.transform x).1) hpB).add
+      ((f.analytic _ hm).comp (f := i.transform) hB)).sub
+      ((i.integrable.analytic _ (i.domain_subset (erosion_subset _ _ hz.1))).comp
+        (f := Prod.fst) analyticAt_fst)
+  periodic := by
+    intro p hp q hq k
+    have hz : (p, q) ∈ phaseDomain (erosion E (β + β)) (ρ - (γ + γ)) := ⟨hp, hq⟩
+    have he := i.generator.generatingTransform_shift i.generatingData
+      (i.budget.target_subset E hz) k
+    change i.transform (phaseShift k (p, q)) = phaseShift k (i.transform (p, q)) at he
+    change i.remainder (phaseShift k (p, q)) = i.remainder (p, q)
+    unfold remainder
+    rw [he]
+    have hm : i.transform (p, q) ∈ phaseDomain G ρ := i.transformation.mapsTo hz
+    change h (i.transform (p, q)).1 +
+      f.toFun ((i.transform (p, q)).1, (i.transform (p, q)).2 + angleShift k) - h p = _
+    rw [f.periodic _ hm.1 _ hm.2 k]
+  conj_compatible := by
+    intro z hz
+    have he := i.generator.generatingTransform_conj i.generatingData (i.budget.target_subset E hz)
+    change i.transform (conjPhase z) = conjPhase (i.transform z) at he
+    change i.remainder (conjPhase z) = star (i.remainder z)
+    unfold remainder
+    rw [he]
+    have hm : i.transform z ∈ phaseDomain G ρ := i.transformation.mapsTo hz
+    change h (conjVec (i.transform z).1) + f.toFun (conjPhase (i.transform z)) -
+      h (conjVec z.1) = _
+    rw [i.integrable.conj_compatible _ hm.1, f.conj_compatible _ hm,
+      i.integrable.conj_compatible _ (i.domain_subset (erosion_subset _ _ hz.1))]
+    simp only [star_sub, star_add]
+  bounded := ⟨fundamentalRawBound n M K Θ δ β, i.remainder_norm_bound⟩
+
+theorem newPerturbation_bound : i.newPerturbation.uniformNorm <
+    fundamentalRemainderBound n M δ β :=
+  ((i.newPerturbation.norm_le_iff).mpr i.remainder_norm_bound).trans_lt i.budget.remainder_budget
+
+theorem transformed_hamiltonian (z : ComplexPhaseSpace n) :
+    h (i.transform z).1 + f.toFun (i.transform z) = h z.1 + i.newPerturbation.toFun z := by
+  change _ = h z.1 + (h (i.transform z).1 + f.toFun (i.transform z) - h z.1)
+  ring
+
+end FundamentalInput
+
+/-- The fundamental canonical transformation and its quantitative perturbation remainder. -/
+structure FundamentalResult {n : ℕ} {G : Set (ComplexSpace n)}
+    (h : ComplexSpace n → ℂ) (f : AnalyticPhaseFunction n G ρ)
+    (E : Set (ComplexSpace n)) (β δ γ : ℝ≥0) (K M : ℝ) where
+  /-- The canonical transformation constructed by the fundamental step. -/
+  transformation : AnalyticCanonicalTransformation
+    (phaseDomain (erosion E (β + β)) (ρ - (γ + γ))) (phaseDomain G ρ)
+    (homologicalBound n M K δ / β)
+  /-- The analytic remainder of the transformed Hamiltonian on the retained phase domain. -/
+  perturbation : AnalyticPhaseFunction n (erosion E (β + β)) (ρ - (γ + γ))
+  identity : ∀ z, h (transformation.toFun z).1 + f.toFun (transformation.toFun z) =
+    h z.1 + perturbation.toFun z
+  bound : perturbation.uniformNorm < fundamentalRemainderBound n M δ β
+  displacement_lt : ∀ z ∈ phaseDomain (erosion E (β + β)) (ρ - (γ + γ)),
+    ‖transformation.toFun z - z‖ < β
+  action_bound : ∀ z ∈ phaseDomain (erosion E (β + β)) (ρ - (γ + γ)),
+    ‖(transformation.toFun z).1 - z.1‖ ≤ homologicalBound n M K δ / δ
+  periodic : ∀ z ∈ phaseDomain (erosion E (β + β)) (ρ - (γ + γ)), ∀ k,
+    transformation.toFun (phaseShift k z) = phaseShift k (transformation.toFun z)
+  conj_compatible : ∀ z ∈ phaseDomain (erosion E (β + β)) (ρ - (γ + γ)),
+    transformation.toFun (conjPhase z) = conjPhase (transformation.toFun z)
+
+/-- The fundamental-step result assembled from its verified analytic and numerical inputs. -/
+def FundamentalInput.result {n : ℕ} {G E : Set (ComplexSpace n)} {ρ β δ γ : ℝ≥0}
+    {K M Θ : ℝ} {h : ComplexSpace n → ℂ} {f : AnalyticPhaseFunction n G ρ}
+    (i : FundamentalInput (E := E) (β := β) (δ := δ) (γ := γ) (K := K) (M := M) (Θ := Θ) h f) :
+    FundamentalResult h f E β δ γ K M where
+  transformation := i.transformation
+  perturbation := i.newPerturbation
+  identity := i.transformed_hamiltonian
+  bound := i.newPerturbation_bound
+  displacement_lt := fun _ hz => (i.displacement hz).trans_lt i.budget.displacement_lt_beta
+  action_bound := fun _ hz => i.action_displacement hz
+  periodic := fun _ hz k => i.generator.generatingTransform_shift i.generatingData
+    (i.budget.target_subset E hz) k
+  conj_compatible := fun _ hz => i.generator.generatingTransform_conj i.generatingData
+    (i.budget.target_subset E hz)
+
+theorem fundamental_lemma {n : ℕ} {G E : Set (ComplexSpace n)} {ρ β δ γ : ℝ≥0}
+    {K M Θ : ℝ} {h : ComplexSpace n → ℂ} {f : AnalyticPhaseFunction n G ρ}
+    (i : FundamentalInput (E := E) (β := β) (δ := δ) (γ := γ) (K := K) (M := M) (Θ := Θ) h f) :
+    Nonempty (FundamentalResult h f E β δ γ K M) := ⟨i.result⟩
+
+theorem FundamentalInput.onNonresonantDomain {n : ℕ} {G : Set (ComplexSpace n)}
+    {ρ β δ γ : ℝ≥0} {K M Θ : ℝ} {h : ComplexSpace n → ℂ}
+    {f : AnalyticPhaseFunction n G ρ} (hi : IntegrableData h G Θ)
+    (hb : FundamentalParameters n ρ β δ γ K M Θ) (hf : f.uniformNorm ≤ M)
+    (hzero : ∀ p ∈ G, f.angleAverage p = 0) :
+    FundamentalInput (E := nonresonantDomain G (actionFrequency h) K (fundamentalCutoff γ M))
+      (β := β) (δ := δ) (γ := γ) (K := K) (M := M) (Θ := Θ) h f where
+  integrable := hi
+  domain_subset := fun _ hp => hp.1
+  domain_conj := nonresonantDomain_conj f.domain_conj hi.frequency_conj
+  perturbation_bound := hf
+  mean_zero := fun _ hp => hzero _ hp.1
+  nonresonant := fun _ hp => hp.2
+  budget := hb
+
+end KamProject.Arnold1963
diff --git a/LeanPool/ArnoldKAM/Arnold1963/Step/GeneratingFunction.lean b/LeanPool/ArnoldKAM/Arnold1963/Step/GeneratingFunction.lean
new file mode 100644
index 0000000000..991807157d
--- /dev/null
+++ b/LeanPool/ArnoldKAM/Arnold1963/Step/GeneratingFunction.lean
@@ -0,0 +1,70 @@
+/-
+Copyright (c) 2026 Bingqi Yu. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Bingqi Yu
+-/
+
+module
+
+public import LeanPool.ArnoldKAM.Arnold1963.Step.HomologicalBound
+
+/-!
+Supporting results for the analytic Hamiltonian KAM construction.
+-/
+
+@[expose] public section
+noncomputable section
+open Set
+open scoped NNReal
+namespace KamProject.Arnold1963
+
+/-- The finite homological generator packaged with analytic phase-function structure and bounds. -/
+def homologicalFunction {n : ℕ} {G E : Set (ComplexSpace n)} {ρ δ : ℝ≥0}
+    (f : AnalyticPhaseFunction n G ρ) (ω : ComplexSpace n → ComplexSpace n)
+    {K N M : ℝ} (hE : E ⊆ G) (hc : ConjInvariant E)
+    (hω : AnalyticOnNhd ℂ ω E) (hωc : ∀ p ∈ E, ω (conjVec p) = conjVec (ω p))
+    (hnr : ∀ p ∈ E, FiniteNonresonant (ω p) K N) (hK : 0 < K)
+    (hM : f.uniformNorm ≤ M) (hδ : 0 < δ) (hδ1 : δ ≤ 1) (hδρ : δ + δ ≤ ρ) :
+    AnalyticPhaseFunction n E (ρ - (δ + δ)) where
+  toFun := homologicalGenerator f ω N
+  domain_conj := hc
+  analytic := fun z hz => analyticAt_homologicalGenerator f (hE hz.1)
+    (hω z.1 hz.1) hK (hnr z.1 hz.1)
+  periodic := by intro p hp q hq m; exact homologicalGenerator_periodic f p q m
+  conj_compatible := fun z hz => homologicalGenerator_conj f (hE hz.1) (hωc z.1 hz.1)
+  bounded := by
+    refine ⟨homologicalBound n M K δ, ?_, fun z hz => ?_⟩
+    · have hm := (f.norm_le_iff.mp le_rfl).nonneg.trans hM
+      have hL := constantL5_pos n
+      unfold homologicalBound
+      positivity
+    · apply norm_homologicalGenerator_le f (hE hz.1) hM hK hδ
+        (show (δ : ℝ) ≤ 1 from hδ1) (hnr z.1 hz.1)
+      have hq := hz.2
+      change ‖imagPart z.2‖ ≤ (↑(ρ - (δ + δ)) : ℝ) at hq
+      rw [NNReal.coe_sub hδρ, NNReal.coe_add] at hq
+      convert hq using 1
+      rfl
+
+theorem norm_homologicalFunction_le {n : ℕ} {G E : Set (ComplexSpace n)} {ρ δ : ℝ≥0}
+    (f : AnalyticPhaseFunction n G ρ) (ω : ComplexSpace n → ComplexSpace n)
+    {K N M : ℝ} (hE : E ⊆ G) (hc : ConjInvariant E)
+    (hω : AnalyticOnNhd ℂ ω E) (hωc : ∀ p ∈ E, ω (conjVec p) = conjVec (ω p))
+    (hnr : ∀ p ∈ E, FiniteNonresonant (ω p) K N) (hK : 0 < K)
+    (hM : f.uniformNorm ≤ M) (hδ : 0 < δ) (hδ1 : δ ≤ 1) (hδρ : δ + δ ≤ ρ) :
+    (homologicalFunction f ω hE hc hω hωc hnr hK hM hδ hδ1 hδρ).uniformNorm ≤
+      homologicalBound n M K δ := by
+  apply (AnalyticPhaseFunction.norm_le_iff _).mpr
+  refine ⟨?_, fun z hz => ?_⟩
+  · have hm := (f.norm_le_iff.mp le_rfl).nonneg.trans hM
+    have hL := constantL5_pos n
+    unfold homologicalBound
+    positivity
+  · exact norm_homologicalGenerator_le f (hE hz.1) hM hK hδ (show (δ : ℝ) ≤ 1 from hδ1)
+      (hnr z.1 hz.1) (by
+        have hq := hz.2
+        change ‖imagPart z.2‖ ≤ (↑(ρ - (δ + δ)) : ℝ) at hq
+        rw [NNReal.coe_sub hδρ, NNReal.coe_add] at hq
+        convert hq using 1)
+
+end KamProject.Arnold1963
diff --git a/LeanPool/ArnoldKAM/Arnold1963/Step/Homological.lean b/LeanPool/ArnoldKAM/Arnold1963/Step/Homological.lean
new file mode 100644
index 0000000000..cabc193b76
--- /dev/null
+++ b/LeanPool/ArnoldKAM/Arnold1963/Step/Homological.lean
@@ -0,0 +1,104 @@
+/-
+Copyright (c) 2026 Bingqi Yu. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Bingqi Yu
+-/
+
+module
+
+public import LeanPool.ArnoldKAM.Arnold1963.Step.FourierDifferential
+
+/-!
+Supporting results for the analytic Hamiltonian KAM construction.
+-/
+
+@[expose] public section
+noncomputable section
+open Set Complex
+open scoped NNReal
+namespace KamProject.Arnold1963
+
+/-- The coefficient solving the homological equation for one nonzero Fourier mode. -/
+def homologicalCoeff {n : ℕ} {G : Set (ComplexSpace n)} {ρ : ℝ≥0}
+    (f : AnalyticPhaseFunction n G ρ) (ω : ComplexSpace n → ComplexSpace n)
+    (p : ComplexSpace n) (k : FourierIndex n) : ℂ :=
+  I * f.fourierCoeff p k / indexPairing k (ω p)
+
+/-- The finite Fourier generating function solving the truncated homological equation. -/
+def homologicalGenerator {n : ℕ} {G : Set (ComplexSpace n)} {ρ : ℝ≥0}
+    (f : AnalyticPhaseFunction n G ρ) (ω : ComplexSpace n → ComplexSpace n)
+    (N : ℝ) (z : ComplexPhaseSpace n) : ℂ :=
+  ∑ k ∈ lowModes n N, homologicalCoeff f ω z.1 k * fourierMonomial k z.2
+
+variable {n : ℕ} {G : Set (ComplexSpace n)} {ρ : ℝ≥0}
+  (f : AnalyticPhaseFunction n G ρ) {ω : ComplexSpace n → ComplexSpace n} {K N : ℝ}
+
+theorem analyticAt_homologicalCoeff {p : ComplexSpace n} (hp : p ∈ G)
+    (hω : AnalyticAt ℂ ω p) (hK : 0 < K) (hnr : FiniteNonresonant (ω p) K N)
+    {k : FourierIndex n} (hk : k ∈ lowModes n N) :
+    AnalyticAt ℂ (fun P => homologicalCoeff f ω P k) p :=
+  (analyticAt_const.mul (f.analyticOnNhd_fourierCoeff k p hp)).div
+    ((analyticAt_indexPairing k _).comp hω) (hnr.ne_zero hK hk)
+
+theorem analyticAt_homologicalGenerator {z : ComplexPhaseSpace n} (hz : z.1 ∈ G)
+    (hω : AnalyticAt ℂ ω z.1) (hK : 0 < K) (hnr : FiniteNonresonant (ω z.1) K N) :
+    AnalyticAt ℂ (homologicalGenerator f ω N) z := by
+  apply Finset.analyticAt_fun_sum
+  intro k hk
+  exact ((analyticAt_homologicalCoeff f hz hω hK hnr hk).comp
+    (f := Prod.fst) analyticAt_fst).mul
+    ((analyticAt_fourierMonomial k _).comp (f := Prod.snd) analyticAt_snd)
+
+theorem homologicalGenerator_periodic (p q : ComplexSpace n) (m : FourierIndex n) :
+    homologicalGenerator f ω N (p, q + angleShift m) = homologicalGenerator f ω N (p, q) := by
+  simp only [homologicalGenerator, fourierMonomial_periodic]
+
+theorem homologicalCoeff_conj {p : ComplexSpace n} (hp : p ∈ G)
+    (hω : ω (conjVec p) = conjVec (ω p)) (k : FourierIndex n) :
+    homologicalCoeff f ω (conjVec p) (-k) = star (homologicalCoeff f ω p k) := by
+  unfold homologicalCoeff
+  rw [f.fourierCoeff_conj hp k, hω, indexPairing_neg, indexPairing_conj]
+  simp [div_neg, neg_div]
+
+theorem homologicalGenerator_conj {z : ComplexPhaseSpace n} (hz : z.1 ∈ G)
+    (hω : ω (conjVec z.1) = conjVec (ω z.1)) :
+    homologicalGenerator f ω N (conjPhase z) = star (homologicalGenerator f ω N z) := by
+  change (∑ k ∈ lowModes n N, homologicalCoeff f ω (conjVec z.1) k *
+    fourierMonomial k (conjVec z.2)) = _
+  rw [← sum_lowModes_neg N (fun k => homologicalCoeff f ω (conjVec z.1) k *
+    fourierMonomial k (conjVec z.2))]
+  simp only [homologicalCoeff_conj f hz hω, fourierMonomial_conj_neg]
+  simp [homologicalGenerator, star_mul, mul_comm]
+
+theorem angle_fderiv_homologicalGenerator (p q v : ComplexSpace n) :
+    fderiv ℂ (fun t => homologicalGenerator f ω N (p, t)) q v =
+      ∑ k ∈ lowModes n N, homologicalCoeff f ω p k *
+        ((I * indexPairing k v) * fourierMonomial k q) := by
+  have hd : HasFDerivAt (fun t => homologicalGenerator f ω N (p, t))
+      (∑ k ∈ lowModes n N, homologicalCoeff f ω p k • fderiv ℂ (fourierMonomial k) q) q := by
+    apply HasFDerivAt.fun_sum
+    intro k _
+    exact (analyticAt_fourierMonomial k q).differentiableAt.hasFDerivAt.const_mul
+      (homologicalCoeff f ω p k)
+  rw [hd.fderiv]
+  simp only [sum_apply, smul_apply,
+    smul_eq_mul, fderiv_fourierMonomial]
+
+theorem homological_equation {z : ComplexPhaseSpace n} (hz : z.1 ∈ G)
+    (hω : AnalyticAt ℂ ω z.1) (hK : 0 < K) (hnr : FiniteNonresonant (ω z.1) K N)
+    (hN : 0 < N) (hmean : f.angleAverage z.1 = 0) :
+    (∑ j, ω z.1 j * qGradient (homologicalGenerator f ω N) z j) +
+      fourierTruncation (f.fourierCoeff z.1) N z.2 = 0 := by
+  have ha := analyticAt_homologicalGenerator f hz hω hK hnr
+  rw [← angle_fderiv_eq_sum_qGradient ha, angle_fderiv_homologicalGenerator,
+    fourierTruncation_eq_zero_add _ hN]
+  change _ + (f.angleAverage z.1 + _) = 0
+  rw [hmean, zero_add, ← Finset.sum_add_distrib]
+  apply Finset.sum_eq_zero
+  intro k hk
+  have hd := hnr.ne_zero hK hk
+  dsimp [homologicalCoeff]
+  field_simp [hd]
+  linear_combination (f.fourierCoeff z.1 k * fourierMonomial k z.2) * Complex.I_sq
+
+end KamProject.Arnold1963
diff --git a/LeanPool/ArnoldKAM/Arnold1963/Step/HomologicalBound.lean b/LeanPool/ArnoldKAM/Arnold1963/Step/HomologicalBound.lean
new file mode 100644
index 0000000000..331dc5f0da
--- /dev/null
+++ b/LeanPool/ArnoldKAM/Arnold1963/Step/HomologicalBound.lean
@@ -0,0 +1,119 @@
+/-
+Copyright (c) 2026 Bingqi Yu. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Bingqi Yu
+-/
+
+module
+
+public import LeanPool.ArnoldKAM.Arnold1963.Step.Homological
+public import LeanPool.ArnoldKAM.Arnold1963.Analysis.FourierKernel
+
+/-!
+Supporting results for the analytic Hamiltonian KAM construction.
+-/
+
+@[expose] public section
+noncomputable section
+open Set Complex
+open scoped NNReal
+namespace KamProject.Arnold1963
+
+/-- The uniform norm bound for the finite homological generating function. -/
+def homologicalBound (n : ℕ) (M K δ : ℝ) : ℝ :=
+  M * constantL5 n / (K * δ ^ homologicalExponent n)
+
+theorem constantL0_pos (n : ℕ) : 0 < constantL0 n := by
+  unfold constantL0
+  positivity
+
+theorem constantL5_pos (n : ℕ) : 0 < constantL5 n :=
+  mul_pos (by positivity) (constantL0_pos n)
+
+theorem nat_pow_exp_bound {x δ : ℝ} (hx : 0 < x) (hδ : 0 < δ) (n : ℕ) :
+    x ^ (n + 1) * Real.exp (-(x * δ)) ≤ constantL0 n / δ ^ (n + 1) := by
+  have h := rpow_mul_exp_neg_mul_le hx
+    (show (0 : ℝ) < (n + 1 : ℕ) by positivity) hδ
+  rw [Real.rpow_neg hδ.le, Real.rpow_natCast, Real.rpow_natCast,
+    Real.rpow_natCast] at h
+  simpa only [constantL0, Nat.cast_add, Nat.cast_one, div_eq_mul_inv] using h
+
+variable {n : ℕ} {G : Set (ComplexSpace n)} {ρ : ℝ≥0}
+  (f : AnalyticPhaseFunction n G ρ) {ω : ComplexSpace n → ComplexSpace n}
+  {M K N δ : ℝ}
+
+theorem norm_homologicalCoeff_le {p : ComplexSpace n} (hp : p ∈ G)
+    (hM : f.uniformNorm ≤ M) (hK : 0 < K) (hnr : FiniteNonresonant (ω p) K N)
+    {k : FourierIndex n} (hk : k ∈ lowModes n N) :
+    ‖homologicalCoeff f ω p k‖ ≤
+      M / K * indexLength k ^ (n + 1) * Real.exp (-(indexLength k * ρ)) := by
+  have hM0 := (f.norm_le_iff.mp le_rfl).nonneg.trans hM
+  have hpow : 0 < indexLength k ^ (n + 1) := pow_pos (mem_lowModes.mp hk).1 _
+  have hf := (f.norm_fourierCoeff_le_exp hp k).trans
+    (mul_le_mul_of_nonneg_right hM (Real.exp_pos _).le)
+  rw [homologicalCoeff, norm_div, norm_mul, norm_I, one_mul]
+  calc
+    _ ≤ (M * Real.exp (-(indexLength k * ρ))) / ‖indexPairing k (ω p)‖ :=
+      div_le_div_of_nonneg_right hf (norm_nonneg _)
+    _ ≤ (M * Real.exp (-(indexLength k * ρ))) / (K / indexLength k ^ (n + 1)) :=
+      div_le_div_of_nonneg_left (by positivity) (div_pos hK hpow) (hnr k hk)
+    _ = _ := by field_simp
+
+theorem norm_homologicalTerm_le {p q : ComplexSpace n} (hp : p ∈ G)
+    (hM : f.uniformNorm ≤ M) (hK : 0 < K) (hδ : 0 < δ)
+    (hnr : FiniteNonresonant (ω p) K N) (hq : ‖imagPart q‖ ≤ (ρ : ℝ) - (δ + δ))
+    {k : FourierIndex n} (hk : k ∈ lowModes n N) :
+    ‖homologicalCoeff f ω p k * fourierMonomial k q‖ ≤
+      (M / K * (constantL0 n / δ ^ (n + 1))) * Real.exp (-δ * indexLength k) := by
+  have hM0 := (f.norm_le_iff.mp le_rfl).nonneg.trans hM
+  have hlen := (mem_lowModes.mp hk).1
+  rw [norm_mul]
+  calc
+    _ ≤ (M / K * indexLength k ^ (n + 1) * Real.exp (-(indexLength k * ρ))) *
+        Real.exp (indexLength k * ‖imagPart q‖) :=
+      mul_le_mul (norm_homologicalCoeff_le f hp hM hK hnr hk)
+        (norm_fourierMonomial_le k q) (norm_nonneg _) (by positivity)
+    _ = M / K * indexLength k ^ (n + 1) *
+        Real.exp (-(indexLength k * ρ) + indexLength k * ‖imagPart q‖) := by
+      rw [mul_assoc, ← Real.exp_add]
+    _ ≤ M / K * indexLength k ^ (n + 1) * Real.exp (-(indexLength k * δ) - δ * indexLength k) := by
+      apply mul_le_mul_of_nonneg_left _ (by positivity)
+      apply Real.exp_le_exp.mpr
+      nlinarith [mul_le_mul_of_nonneg_left hq hlen.le]
+    _ = M / K * (indexLength k ^ (n + 1) * Real.exp (-(indexLength k * δ))) *
+        Real.exp (-δ * indexLength k) := by
+      rw [show -(indexLength k * δ) - δ * indexLength k =
+        -(indexLength k * δ) + (-δ * indexLength k) by ring, Real.exp_add]
+      ring
+    _ ≤ _ := mul_le_mul_of_nonneg_right
+      (mul_le_mul_of_nonneg_left (nat_pow_exp_bound hlen hδ n) (by positivity))
+      (Real.exp_pos _).le
+
+theorem norm_homologicalGenerator_le {p q : ComplexSpace n} (hp : p ∈ G)
+    (hM : f.uniformNorm ≤ M) (hK : 0 < K) (hδ : 0 < δ) (hδ1 : δ ≤ 1)
+    (hnr : FiniteNonresonant (ω p) K N) (hq : ‖imagPart q‖ ≤ (ρ : ℝ) - (δ + δ)) :
+    ‖homologicalGenerator f ω N (p, q)‖ ≤ homologicalBound n M K δ := by
+  have hM0 := (f.norm_le_iff.mp le_rfl).nonneg.trans hM
+  let C := M / K * (constantL0 n / δ ^ (n + 1))
+  have hC : 0 ≤ C := by
+    dsimp [C]
+    exact mul_nonneg (div_nonneg hM0 hK.le)
+      (div_nonneg (constantL0_pos n).le (pow_nonneg hδ.le _))
+  calc
+    _ ≤ ∑ k ∈ lowModes n N, ‖homologicalCoeff f ω p k * fourierMonomial k q‖ := norm_sum_le _ _
+    _ ≤ ∑ k ∈ lowModes n N, C * Real.exp (-δ * indexLength k) :=
+      Finset.sum_le_sum fun k hk => norm_homologicalTerm_le f hp hM hK hδ hnr hq hk
+    _ = C * ∑ k ∈ lowModes n N, Real.exp (-δ * indexLength k) := (Finset.mul_sum _ _ _).symm
+    _ ≤ C * (4 / δ) ^ n := by
+      apply mul_le_mul_of_nonneg_left _ hC
+      exact ((summable_exp_indexLength n hδ).sum_le_tsum (lowModes n N)
+        (fun _ _ => (Real.exp_pos _).le)).trans (tsum_exp_indexLength_le n hδ hδ1)
+    _ = _ := by
+      dsimp [C, homologicalBound, constantL5, homologicalExponent]
+      rw [div_pow]
+      have he : δ ^ (2 * n + 1) = δ ^ (n + 1) * δ ^ n := by
+        rw [← pow_add]; congr 1; omega
+      rw [he]
+      field_simp
+
+end KamProject.Arnold1963
diff --git a/LeanPool/ArnoldKAM/Arnold1963/Step/Inductive.lean b/LeanPool/ArnoldKAM/Arnold1963/Step/Inductive.lean
new file mode 100644
index 0000000000..1c883b3beb
--- /dev/null
+++ b/LeanPool/ArnoldKAM/Arnold1963/Step/Inductive.lean
@@ -0,0 +1,169 @@
+/-
+Copyright (c) 2026 Bingqi Yu. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Bingqi Yu
+-/
+
+module
+
+public import LeanPool.ArnoldKAM.Arnold1963.Step.InductiveDomains
+public import LeanPool.ArnoldKAM.Arnold1963.Step.MeasureBudget
+
+/-!
+Supporting results for the analytic Hamiltonian KAM construction.
+-/
+
+@[expose] public section
+noncomputable section
+open Set
+open scoped NNReal ENNReal
+namespace KamProject.Arnold1963
+
+/-- The quadratic perturbation bound supplied by one inductive KAM step. -/
+def iterationRemainderBound (n : ℕ) (M δ β : ℝ) : ℝ :=
+  M ^ 2 / (δ ^ (2 * stepExponent n) * β ^ 2)
+
+theorem fundamentalRemainderBound_eq_iterationRemainderBound (n : ℕ) (M δ β : ℝ) :
+    fundamentalRemainderBound n (2 * M) δ β = iterationRemainderBound n M δ β :=
+  fundamentalRemainderBound_twice n M δ β
+
+namespace IterationInput
+variable {n : ℕ} {G Ω : Set (ComplexSpace n)} {ρ β δ γ θ Θ : ℝ≥0} {K M : ℝ}
+  {a : ComplexSpace n → ℂ} {f : AnalyticPhaseFunction n G ρ}
+  {g : ComplexSpace n → ComplexSpace n} (i : IterationInput (Ω := Ω) a f g β δ γ θ Θ K M)
+
+/-- The fundamental result before restricting to the narrower inductive phase domain. -/
+def wideResult := i.fundamental.result
+
+theorem newDomain_subset_wide : i.newDomain ⊆ i.wideDomain :=
+  (subset_closedBallNeighborhood _ β).trans (i.frequencyChange.iteration_target_buffer _ _)
+
+/-- The next perturbation restricted to the inductive action domain and angle strip. -/
+def newPerturbation : AnalyticPhaseFunction n i.newDomain (ρ - 3 * γ) :=
+  i.wideResult.perturbation.restrict i.newDomain_subset_wide
+    (tsub_le_tsub_left (by nlinarith : γ + γ ≤ 3 * γ) ρ) i.newChart.domain_conj
+
+theorem newPerturbation_bound : i.newPerturbation.uniformNorm < iterationRemainderBound n M δ β :=
+  (i.wideResult.perturbation.uniformNorm_restrict_le _ _ _).trans_lt (by
+    simpa only [fundamentalRemainderBound_twice, iterationRemainderBound] using i.wideResult.bound)
+
+/-- The inductive canonical transformation restricted to its retained phase domain. -/
+def transformation : AnalyticCanonicalTransformation
+    (phaseDomain i.newDomain (ρ - 3 * γ)) (phaseDomain G ρ) β :=
+  let B := i.wideResult.transformation.restrict i.phase_subset_wide
+  { B with
+    mapsTo := fun _ hx =>
+      ⟨erosion_subset _ _ (B.mapsTo hx).1, (B.mapsTo hx).2⟩
+    displacement := ⟨β.coe_nonneg, fun z hz =>
+      (i.wideResult.displacement_lt z (i.phase_subset_wide hz)).le⟩ }
+
+theorem transformed_hamiltonian (z : ComplexPhaseSpace n) :
+    a (i.transformation.toFun z).1 + f.toFun (i.transformation.toFun z) =
+      i.newIntegrable z.1 + i.newPerturbation.toFun z := by
+  have hh := i.wideResult.identity z
+  change (a (i.transformation.toFun z).1 + f.angleAverage (i.transformation.toFun z).1) +
+    (f.toFun (i.transformation.toFun z) - f.angleAverage (i.transformation.toFun z).1) =
+      i.newIntegrable z.1 + i.newPerturbation.toFun z at hh
+  linear_combination hh
+
+theorem displacement_lt {z} (hz : z ∈ phaseDomain i.newDomain (ρ - 3 * γ)) :
+    ‖i.transformation.toFun z - z‖ < β :=
+  i.wideResult.displacement_lt z (i.phase_subset_wide hz)
+
+theorem remainder_derivative_bound {z} (hz : z ∈ phaseDomain i.newDomain (ρ - 3 * γ)) :
+    ‖fderiv ℂ i.newPerturbation.toFun z‖ < iterationRemainderBound n M δ β / β := by
+  apply (norm_fderiv_le_div_of_mem_erosion i.budget.beta_pos i.wideResult.perturbation.analytic
+    (i.wideResult.perturbation.norm_le_iff.mp le_rfl) (i.phase_buffer hz)).trans_lt
+  apply div_lt_div_of_pos_right _ (show (0 : ℝ) < β from i.budget.beta_pos)
+  simpa only [fundamentalRemainderBound_twice, iterationRemainderBound] using i.wideResult.bound
+
+theorem remainder_second_derivative_bound {z}
+    (hz : z ∈ phaseDomain i.newDomain (ρ - 3 * γ)) (j k : Fin n ⊕ Fin n) :
+    ‖fderiv ℂ (fderiv ℂ i.newPerturbation.toFun) z (phaseBasis j) (phaseBasis k)‖ <
+      2 * iterationRemainderBound n M δ β / (β : ℝ) ^ 2 := by
+  apply (norm_second_phaseCoordinate_le i.budget.beta_pos i.wideResult.perturbation.analytic
+    (i.wideResult.perturbation.norm_le_iff.mp le_rfl) (i.phase_buffer hz) j k).trans_lt
+  apply div_lt_div_of_pos_right _ (sq_pos_of_pos (show (0 : ℝ) < β from i.budget.beta_pos))
+  apply mul_lt_mul_of_pos_left _ (by norm_num)
+  simpa only [fundamentalRemainderBound_twice, iterationRemainderBound] using i.wideResult.bound
+
+end IterationInput
+
+/-- The updated frequency chart, canonical transformation and remainder of an inductive step. -/
+structure InductiveResult {n : ℕ} {G : Set (ComplexSpace n)} {ρ : ℝ≥0}
+    (a : ComplexSpace n → ℂ) (f : AnalyticPhaseFunction n G ρ)
+    (Ω : Set (ComplexSpace n)) (β δ γ θ Θ : ℝ≥0) (K M : ℝ) where
+  /-- The retained action domain of the inductive step. -/
+  domain : Set (ComplexSpace n)
+  /-- The inverse of the updated action-frequency chart. -/
+  inverseFrequency : ComplexSpace n → ComplexSpace n
+  chart : AnalyticFrequencyChart (actionFrequency (f.averagedHamiltonian a)) inverseFrequency domain
+    (erosion (nonresonantDomain Ω id K (fundamentalCutoff γ (2 * M))) ((5 + 7 * Θ) * β))
+  domain_subset : domain ⊆ erosion G β
+  width_pos : 0 < ρ - 3 * γ
+  analytic : AnalyticOnNhd ℂ (f.averagedHamiltonian a) domain
+  conj : ∀ p ∈ domain, f.averagedHamiltonian a (conjVec p) = star (f.averagedHamiltonian a p)
+  lower_pos : 0 < (θ : ℝ) * (1 - (δ : ℝ))
+  derivative_bounds : ∀ p ∈ domain, ∀ v,
+    ((θ : ℝ) * (1 - (δ : ℝ))) * ‖v‖ ≤
+      ‖fderiv ℂ (actionFrequency (f.averagedHamiltonian a)) p v‖ ∧
+    ‖fderiv ℂ (actionFrequency (f.averagedHamiltonian a)) p v‖ ≤
+      ((Θ : ℝ) * (1 + (δ : ℝ))) * ‖v‖
+  frequency_displacement : ∀ p ∈ domain,
+    ‖actionFrequency (f.averagedHamiltonian a) p - actionFrequency a p‖ < (β : ℝ) * δ
+  /-- The canonical transformation carrying the retained phase domain into the previous one. -/
+  transformation : AnalyticCanonicalTransformation
+    (phaseDomain domain (ρ - 3 * γ)) (phaseDomain G ρ) β
+  /-- The analytic perturbation remainder after updating the integrable Hamiltonian. -/
+  perturbation : AnalyticPhaseFunction n domain (ρ - 3 * γ)
+  identity : ∀ z, a (transformation.toFun z).1 + f.toFun (transformation.toFun z) =
+    f.averagedHamiltonian a z.1 + perturbation.toFun z
+  bound : perturbation.uniformNorm < iterationRemainderBound n M δ β
+  displacement_lt : ∀ z ∈ phaseDomain domain (ρ - 3 * γ), ‖transformation.toFun z - z‖ < β
+  periodic : ∀ z ∈ phaseDomain domain (ρ - 3 * γ), ∀ k,
+    transformation.toFun (phaseShift k z) = phaseShift k (transformation.toFun z)
+  conj_compatible : ∀ z ∈ phaseDomain domain (ρ - 3 * γ),
+    transformation.toFun (conjPhase z) = conjPhase (transformation.toFun z)
+  phase_buffer : phaseDomain domain (ρ - 3 * γ) ⊆ erosion (phaseDomain G ρ) β
+  derivative : ∀ z ∈ phaseDomain domain (ρ - 3 * γ),
+    ‖fderiv ℂ perturbation.toFun z‖ < iterationRemainderBound n M δ β / β
+  second_derivative : ∀ z ∈ phaseDomain domain (ρ - 3 * γ), ∀ j k : Fin n ⊕ Fin n,
+    ‖fderiv ℂ (fderiv ℂ perturbation.toFun) z (phaseBasis j) (phaseBasis k)‖ <
+      2 * iterationRemainderBound n M δ β / (β : ℝ) ^ 2
+  measure : realVolume (G \ domain) ≤ ENNReal.ofReal ((θ : ℝ)⁻¹ ^ n) *
+    realVolume (Ω \ erosion (nonresonantDomain Ω id K (fundamentalCutoff γ (2 * M)))
+      ((6 + 7 * Θ) * β))
+
+/-- The inductive-step result assembled from its verified input data. -/
+def IterationInput.result {n : ℕ} {G Ω : Set (ComplexSpace n)} {ρ β δ γ θ Θ : ℝ≥0}
+    {K M : ℝ} {a : ComplexSpace n → ℂ} {f : AnalyticPhaseFunction n G ρ}
+    {g : ComplexSpace n → ComplexSpace n} (i : IterationInput (Ω := Ω) a f g β δ γ θ Θ K M) :
+    InductiveResult a f Ω β δ γ θ Θ K M where
+  domain := i.newDomain
+  inverseFrequency := i.frequencyChange.newInverse
+  chart := i.newChart
+  domain_subset := i.newDomain_subset
+  width_pos := i.new_width_pos
+  analytic := i.newIntegrable_data.analytic.mono i.newDomain_subset
+  conj := fun _ hp => i.newIntegrable_data.conj_compatible _ (i.newDomain_subset hp)
+  lower_pos := mul_pos i.budget.lower_pos (sub_pos.mpr i.budget.delta_lt_one)
+  derivative_bounds := fun _ hp v => i.new_derivative_bounds hp v
+  frequency_displacement := fun _ hp => i.frequency_displacement hp
+  transformation := i.transformation
+  perturbation := i.newPerturbation
+  identity := i.transformed_hamiltonian
+  bound := i.newPerturbation_bound
+  displacement_lt := fun _ hz => i.displacement_lt hz
+  periodic := fun _ hz k => i.wideResult.periodic _ (i.phase_subset_wide hz) k
+  conj_compatible := fun _ hz => i.wideResult.conj_compatible _ (i.phase_subset_wide hz)
+  phase_buffer := i.phase_subset_old_erosion
+  derivative := fun _ hz => i.remainder_derivative_bound hz
+  second_derivative := fun _ hz j k => i.remainder_second_derivative_bound hz j k
+  measure := i.frequencyChange.iteration_measure _ _
+
+theorem inductive_lemma {n : ℕ} {G Ω : Set (ComplexSpace n)} {ρ β δ γ θ Θ : ℝ≥0}
+    {K M : ℝ} {a : ComplexSpace n → ℂ} {f : AnalyticPhaseFunction n G ρ}
+    {g : ComplexSpace n → ComplexSpace n} (i : IterationInput (Ω := Ω) a f g β δ γ θ Θ K M) :
+    Nonempty (InductiveResult a f Ω β δ γ θ Θ K M) := ⟨i.result⟩
+
+end KamProject.Arnold1963
diff --git a/LeanPool/ArnoldKAM/Arnold1963/Step/InductiveDomains.lean b/LeanPool/ArnoldKAM/Arnold1963/Step/InductiveDomains.lean
new file mode 100644
index 0000000000..2a5e86f3e4
--- /dev/null
+++ b/LeanPool/ArnoldKAM/Arnold1963/Step/InductiveDomains.lean
@@ -0,0 +1,87 @@
+/-
+Copyright (c) 2026 Bingqi Yu. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Bingqi Yu
+-/
+
+module
+
+public import LeanPool.ArnoldKAM.Arnold1963.Step.AveragingConstruction
+public import LeanPool.ArnoldKAM.Arnold1963.Geometry.FrequencyChartCongr
+public import LeanPool.ArnoldKAM.Arnold1963.Analysis.PhaseCauchy
+
+/-!
+Supporting results for the analytic Hamiltonian KAM construction.
+-/
+
+@[expose] public section
+noncomputable section
+open Set Filter
+open scoped NNReal Topology
+namespace KamProject.Arnold1963
+namespace IterationInput
+variable {n : ℕ} {G Ω : Set (ComplexSpace n)} {ρ β δ γ θ Θ : ℝ≥0} {K M : ℝ}
+  {a : ComplexSpace n → ℂ} {f : AnalyticPhaseFunction n G ρ}
+  {g : ComplexSpace n → ComplexSpace n} (i : IterationInput (Ω := Ω) a f g β δ γ θ Θ K M)
+include i
+
+/-- The action domain retained by corrected frequency inversion and finite resonance removal. -/
+def newDomain : Set (ComplexSpace n) :=
+  i.frequencyChange.iterationDomain K (fundamentalCutoff γ (2 * M))
+
+/-- The wider action domain used before the final inductive restriction. -/
+def wideDomain : Set (ComplexSpace n) :=
+  erosion (i.frequencyChange.iterationE K (fundamentalCutoff γ (2 * M))) (β + β)
+
+theorem newDomain_subset : i.newDomain ⊆ erosion G β :=
+  (subset_closedBallNeighborhood _ (3 * β)).trans (i.frequencyChange.iterationE_subset _ _)
+
+theorem newChart : AnalyticFrequencyChart (actionFrequency i.newIntegrable)
+    i.frequencyChange.newInverse i.newDomain
+      (erosion (nonresonantDomain Ω id K (fundamentalCutoff γ (2 * M))) ((5 + 7 * Θ) * β)) :=
+  (i.frequencyChange.iterationChart _ _).congr (fun _ hp =>
+    i.frequency_eventually (erosion_subset _ _ (i.newDomain_subset hp)))
+
+theorem new_derivative_bounds {p} (hp : p ∈ i.newDomain) (v : ComplexSpace n) :
+    ((θ : ℝ) * (1 - (δ : ℝ))) * ‖v‖ ≤ ‖fderiv ℂ (actionFrequency i.newIntegrable) p v‖ ∧
+    ‖fderiv ℂ (actionFrequency i.newIntegrable) p v‖ ≤ ((Θ : ℝ) * (1 + (δ : ℝ))) * ‖v‖ := by
+  rw [(i.frequency_eventually (erosion_subset _ _ (i.newDomain_subset hp))).fderiv_eq]
+  exact i.frequencyChange.iteration_derivative_bounds _ _ hp v
+
+theorem frequency_displacement {p} (hp : p ∈ i.newDomain) :
+    ‖actionFrequency i.newIntegrable p - actionFrequency a p‖ < (β : ℝ) * δ := by
+  rw [(i.frequency_eventually (erosion_subset _ _ (i.newDomain_subset hp))).self_of_nhds,
+    add_sub_cancel_left]
+  exact ((f.frequencyShift_bound i.budget.beta_pos i.perturbation).norm_le
+    (i.newDomain_subset hp)).trans_lt i.budget.mean_gradient_small
+
+theorem new_width_pos : 0 < ρ - 3 * γ := by
+  apply tsub_pos_of_lt
+  exact_mod_cast i.budget.angle_width
+
+theorem phase_buffer : phaseDomain i.newDomain (ρ - 3 * γ) ⊆
+    erosion (phaseDomain i.wideDomain (ρ - (γ + γ))) β := by
+  have hγ : 3 * γ ≤ ρ := by exact_mod_cast i.budget.angle_width.le
+  have hg2 : γ + γ ≤ ρ := by nlinarith
+  have hβ : β ≤ ρ - (γ + γ) := by
+    apply (le_tsub_iff_right hg2).mpr
+    nlinarith [i.budget.beta_lt_gamma]
+  apply phaseDomain_buffer_of_neighborhood hβ
+  · rw [tsub_tsub]
+    exact tsub_le_tsub_left (by nlinarith [i.budget.beta_lt_gamma]) ρ
+  · exact i.frequencyChange.iteration_target_buffer _ _
+
+theorem phase_subset_wide : phaseDomain i.newDomain (ρ - 3 * γ) ⊆
+    phaseDomain i.wideDomain (ρ - (γ + γ)) :=
+  i.phase_buffer.trans (erosion_subset _ _)
+
+theorem phase_subset_old_erosion : phaseDomain i.newDomain (ρ - 3 * γ) ⊆
+    erosion (phaseDomain G ρ) β := by
+  have hγ : 3 * γ ≤ ρ := by exact_mod_cast i.budget.angle_width.le
+  have hβγ : β ≤ 3 * γ := by nlinarith [i.budget.beta_lt_gamma]
+  apply Subset.trans (Set.prod_mono i.newDomain_subset
+    (angleStrip_mono (tsub_le_tsub_left hβγ ρ)))
+  exact phaseDomain_shrink_subset_erosion G (hβγ.trans hγ)
+
+end IterationInput
+end KamProject.Arnold1963
diff --git a/LeanPool/ArnoldKAM/Arnold1963/Step/InductiveIteration.lean b/LeanPool/ArnoldKAM/Arnold1963/Step/InductiveIteration.lean
new file mode 100644
index 0000000000..d178b16167
--- /dev/null
+++ b/LeanPool/ArnoldKAM/Arnold1963/Step/InductiveIteration.lean
@@ -0,0 +1,97 @@
+/-
+Copyright (c) 2026 Bingqi Yu. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Bingqi Yu
+-/
+
+module
+
+public import LeanPool.ArnoldKAM.Arnold1963.Step.Inductive
+
+/-!
+Supporting results for the analytic Hamiltonian KAM construction.
+-/
+
+@[expose] public section
+noncomputable section
+open Set
+open scoped NNReal ENNReal
+namespace KamProject.Arnold1963
+namespace InductiveResult
+variable {n : ℕ} {G Ω : Set (ComplexSpace n)} {ρ β δ γ θ Θ : ℝ≥0} {K M : ℝ}
+  {a : ComplexSpace n → ℂ} {f : AnalyticPhaseFunction n G ρ}
+  (r : InductiveResult a f Ω β δ γ θ Θ K M)
+include r
+
+theorem delta_lt_one : δ < 1 := by
+  have hh := r.lower_pos
+  have ht := θ.coe_nonneg
+  exact_mod_cast (show (δ : ℝ) < 1 by nlinarith)
+
+theorem realSlice_nonempty_of_budget {L : ℝ≥0∞}
+    (hloss : realVolume (G \ r.domain) ≤ L) (hL : L < realVolume G) :
+    (realSlice r.domain).Nonempty :=
+  realSlice_nonempty_of_realVolume_pos (realVolume_pos_of_loss_lt (hloss.trans_lt hL))
+
+theorem nextInput {β₁ δ₁ γ₁ : ℝ≥0}
+    (hb : IterationParameters n (ρ - 3 * γ) β₁ δ₁ γ₁ (θ * (1 - δ)) (Θ * (1 + δ))
+      K (iterationRemainderBound n M δ β)) :
+    IterationInput (Ω := erosion (nonresonantDomain Ω id K (fundamentalCutoff γ (2 * M)))
+      ((5 + 7 * Θ) * β)) (f.averagedHamiltonian a) r.perturbation r.inverseFrequency
+      β₁ δ₁ γ₁ (θ * (1 - δ)) (Θ * (1 + δ)) K (iterationRemainderBound n M δ β) where
+  chart := r.chart
+  analytic := r.analytic
+  conj := r.conj
+  lower := by
+    intro p hp v
+    simpa only [NNReal.coe_mul, NNReal.coe_sub r.delta_lt_one.le, NNReal.coe_one] using
+      (r.derivative_bounds p hp v).1
+  upper := by
+    intro p hp
+    apply ContinuousLinearMap.opNorm_le_bound _ (by positivity)
+    intro v
+    simpa only [NNReal.coe_mul, NNReal.coe_add, NNReal.coe_one] using
+      (r.derivative_bounds p hp v).2
+  perturbation := r.bound.le
+  budget := hb
+
+end InductiveResult
+
+namespace IterationInput
+variable {n : ℕ} {G Ωbase : Set (ComplexSpace n)} {ρ β δ γ θ Θ : ℝ≥0}
+  {K M N₀ D : ℝ} {a : ComplexSpace n → ℂ} {f : AnalyticPhaseFunction n G ρ}
+  {g : ComplexSpace n → ComplexSpace n} (s : ResonanceDomainState n K N₀)
+  (i : IterationInput (Ω := s.domain Ωbase) a f g β δ γ θ Θ K M)
+
+theorem result_chart_next (hNN : N₀ ≤ fundamentalCutoff γ (2 * M)) :
+    AnalyticFrequencyChart (actionFrequency (f.averagedHamiltonian a)) i.result.inverseFrequency
+      i.result.domain
+      ((s.next i.budget.fundamental.K_pos hNN ((5 + 7 * Θ) * β)).domain Ωbase) := by
+  rw [s.next_domain]
+  exact i.result.chart
+
+theorem result_measure_budget (hD : TypeD Ωbase D) (hN₀ : 1 ≤ N₀)
+    (hNN : N₀ ≤ fundamentalCutoff γ (2 * M)) :
+    realVolume (G \ i.result.domain) ≤ ENNReal.ofReal ((θ : ℝ)⁻¹ ^ n) *
+      (ENNReal.ofReal (resonanceLossConstant n * D *
+        (K * newShellBudget N₀ (fundamentalCutoff γ (2 * M)) +
+          (((6 + 7 * Θ) * β : ℝ≥0) : ℝ) * (fundamentalCutoff γ (2 * M)) ^ n)) *
+        realVolume Ωbase) :=
+  frequency_iteration_measure_budget s i.frequencyChange hD i.budget.dimension_pos
+    i.budget.fundamental.K_pos hN₀ i.budget.cutoff_gt_one hNN
+
+theorem result_measure_uniform {G₀ : Set (ComplexSpace n)}
+    {A₀ g₀ : ComplexSpace n → ComplexSpace n}
+    (c₀ : AnalyticFrequencyChart A₀ g₀ G₀ Ωbase) {θ₀ Θ₀ : ℝ}
+    (hθ₀ : 0 < θ₀) (hθ : θ₀ / 2 ≤ (θ : ℝ)) (hΘ₀ : 0 ≤ Θ₀)
+    (hupper : ∀ p ∈ G₀, ‖fderiv ℂ A₀ p‖ ≤ Θ₀)
+    (hD : TypeD Ωbase D) (hN₀ : 1 ≤ N₀) (hNN : N₀ ≤ fundamentalCutoff γ (2 * M)) :
+    realVolume (G \ i.result.domain) ≤ ENNReal.ofReal ((2 * Θ₀ / θ₀) ^ n) *
+      (ENNReal.ofReal (resonanceLossConstant n * D *
+        (K * newShellBudget N₀ (fundamentalCutoff γ (2 * M)) +
+          (((6 + 7 * Θ) * β : ℝ≥0) : ℝ) * (fundamentalCutoff γ (2 * M)) ^ n)) * realVolume G₀) :=
+  frequency_measure_to_uniform_action_budget c₀ hθ₀ hθ hΘ₀ hupper
+    (i.result_measure_budget s hD hN₀ hNN)
+
+end IterationInput
+end KamProject.Arnold1963
diff --git a/LeanPool/ArnoldKAM/Arnold1963/Step/Integrable.lean b/LeanPool/ArnoldKAM/Arnold1963/Step/Integrable.lean
new file mode 100644
index 0000000000..639d363382
--- /dev/null
+++ b/LeanPool/ArnoldKAM/Arnold1963/Step/Integrable.lean
@@ -0,0 +1,77 @@
+/-
+Copyright (c) 2026 Bingqi Yu. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Bingqi Yu
+-/
+
+module
+
+public import LeanPool.ArnoldKAM.Arnold1963.Step.GeneratingFunction
+public import LeanPool.ArnoldKAM.Arnold1963.Analysis.Taylor
+
+/-!
+Supporting results for the analytic Hamiltonian KAM construction.
+-/
+
+@[expose] public section
+noncomputable section
+open Set
+open Filter
+open scoped Topology
+namespace KamProject.Arnold1963
+
+/-- The coordinate gradient of an action-dependent Hamiltonian, giving its frequency map. -/
+def actionFrequency {n : ℕ} (h : ComplexSpace n → ℂ) (p : ComplexSpace n) :
+    ComplexSpace n := fun j => fderiv ℂ h p (Pi.single j 1)
+
+/-- Evaluation of an action covector on the coordinate basis as a continuous linear map. -/
+def actionFrequencyCLM (n : ℕ) :
+    (ComplexSpace n →L[ℂ] ℂ) →L[ℂ] ComplexSpace n :=
+  ContinuousLinearMap.pi (fun j => ContinuousLinearMap.apply ℂ ℂ (Pi.single j 1))
+
+theorem fderiv_actionFrequency_apply {n : ℕ} {h : ComplexSpace n → ℂ}
+    {p : ComplexSpace n} (ha : AnalyticAt ℂ h p) (v : ComplexSpace n) (j : Fin n) :
+    fderiv ℂ (actionFrequency h) p v j =
+      fderiv ℂ (fderiv ℂ h) p v (Pi.single j 1) := by
+  exact congrArg (fun L : ComplexSpace n →L[ℂ] ComplexSpace n => L v j)
+    (((actionFrequencyCLM n).hasFDerivAt.comp p ha.fderiv.differentiableAt.hasFDerivAt).fderiv)
+
+theorem fderiv_eq_actionFrequency {n : ℕ} (h : ComplexSpace n → ℂ)
+    (p v : ComplexSpace n) :
+    fderiv ℂ h p v = ∑ j, actionFrequency h p j * v j := by
+  conv_lhs => rw [pi_eq_sum_univ' v]
+  simp [actionFrequency, mul_comm]
+
+theorem analyticOnNhd_actionFrequency {n : ℕ} {G : Set (ComplexSpace n)}
+    {h : ComplexSpace n → ℂ} (hh : AnalyticOnNhd ℂ h G) :
+    AnalyticOnNhd ℂ (actionFrequency h) G := by
+  intro p hp
+  apply AnalyticAt.pi
+  intro j
+  exact ((ContinuousLinearMap.apply ℂ ℂ (Pi.single j 1)).analyticAt _).comp (hh.fderiv p hp)
+
+theorem actionFrequency_conj_of_mem_nhds {n : ℕ} {h : ComplexSpace n → ℂ}
+    {V : Set (ComplexSpace n)} {p : ComplexSpace n}
+    (ha : AnalyticAt ℂ h p) (hc : ∀ x ∈ V, h (conjVec x) = star (h x))
+    (hp : V ∈ 𝓝 (conjVec p)) :
+    actionFrequency h (conjVec p) = conjVec (actionFrequency h p) := by
+  have he : h =ᶠ[𝓝 (star p)] (star ∘ h ∘ star) := by
+    filter_upwards [hp] with z hz
+    simpa [Function.comp_def, ← hc z hz] using (star_star (h z)).symm
+  have hd := ha.differentiableAt.hasFDerivAt.star_star
+  ext j
+  dsimp [actionFrequency, conjVec]
+  rw [he.fderiv_eq, hd.fderiv]
+  simp
+
+/-- Analyticity, real compatibility and frequency bounds for an integrable Hamiltonian. -/
+structure IntegrableData {n : ℕ} (h : ComplexSpace n → ℂ)
+    (G : Set (ComplexSpace n)) (Θ : ℝ) : Prop where
+  analytic : AnalyticOnNhd ℂ h G
+  conj_compatible : ∀ p ∈ G, h (conjVec p) = star (h p)
+  frequency_conj : ∀ p ∈ G,
+    actionFrequency h (conjVec p) = conjVec (actionFrequency h p)
+  hessian_bound : ∀ p ∈ G, ∀ i j,
+    ‖fderiv ℂ (fderiv ℂ h) p (Pi.single i 1) (Pi.single j 1)‖ ≤ Θ
+
+end KamProject.Arnold1963
diff --git a/LeanPool/ArnoldKAM/Arnold1963/Step/IntegrableBounds.lean b/LeanPool/ArnoldKAM/Arnold1963/Step/IntegrableBounds.lean
new file mode 100644
index 0000000000..f0c6c1d9e7
--- /dev/null
+++ b/LeanPool/ArnoldKAM/Arnold1963/Step/IntegrableBounds.lean
@@ -0,0 +1,37 @@
+/-
+Copyright (c) 2026 Bingqi Yu. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Bingqi Yu
+-/
+
+module
+
+public import LeanPool.ArnoldKAM.Arnold1963.Step.Integrable
+
+/-!
+Supporting results for the analytic Hamiltonian KAM construction.
+-/
+
+@[expose] public section
+noncomputable section
+open Set
+namespace KamProject.Arnold1963
+
+theorem IntegrableData.of_frequency_bound {n : ℕ} {G : Set (ComplexSpace n)}
+    {h : ComplexSpace n → ℂ} {Θ : ℝ} (ha : AnalyticOnNhd ℂ h G)
+    (hc : ∀ p ∈ G, h (conjVec p) = star (h p))
+    (hωc : ∀ p ∈ G, actionFrequency h (conjVec p) = conjVec (actionFrequency h p))
+    (hbound : ∀ p ∈ G, ‖fderiv ℂ (actionFrequency h) p‖ ≤ Θ) : IntegrableData h G Θ where
+  analytic := ha
+  conj_compatible := hc
+  frequency_conj := hωc
+  hessian_bound := by
+    intro p hp i j
+    rw [← fderiv_actionFrequency_apply (ha p hp)]
+    calc
+      _ ≤ ‖fderiv ℂ (actionFrequency h) p (Pi.single i 1)‖ := norm_le_pi_norm _ j
+      _ ≤ ‖fderiv ℂ (actionFrequency h) p‖ * ‖(Pi.single i 1 : ComplexSpace n)‖ :=
+        (fderiv ℂ (actionFrequency h) p).le_opNorm (Pi.single i 1)
+      _ ≤ Θ := by simpa only [Pi.norm_single, norm_one, mul_one] using hbound p hp
+
+end KamProject.Arnold1963
diff --git a/LeanPool/ArnoldKAM/Arnold1963/Step/IterationParameters.lean b/LeanPool/ArnoldKAM/Arnold1963/Step/IterationParameters.lean
new file mode 100644
index 0000000000..9c2513c785
--- /dev/null
+++ b/LeanPool/ArnoldKAM/Arnold1963/Step/IterationParameters.lean
@@ -0,0 +1,100 @@
+/-
+Copyright (c) 2026 Bingqi Yu. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Bingqi Yu
+-/
+
+module
+
+public import LeanPool.ArnoldKAM.Arnold1963.Step.NumericalBudget
+
+/-!
+Supporting results for the analytic Hamiltonian KAM construction.
+-/
+
+@[expose] public section
+noncomputable section
+open scoped NNReal
+namespace KamProject.Arnold1963
+
+/-- The positive parameters and smallness inequalities required for an inductive KAM step. -/
+structure IterationParameters (n : ℕ) (ρ β δ γ θ Θ : ℝ≥0) (K M : ℝ) : Prop where
+  dimension_pos : 0 < n
+  beta_pos : 0 < β
+  delta_pos : 0 < δ
+  lower_pos : 0 < θ
+  lower_lt_one : θ < 1
+  upper_gt_one : 1 < Θ
+  delta_small : (δ : ℝ) < threshold1 n θ Θ
+  angle_loss : 10 * (δ : ℝ) < 2 * γ
+  angle_width : 3 * (γ : ℝ) < ρ
+  width_le_one : ρ ≤ 1
+  action_loss : 3 * (β : ℝ) < 2 * δ
+  divisor_margin : 2 * (β : ℝ) < K
+  divisor_le_one : K ≤ 1
+  perturbation_pos : 0 < M
+  perturbation_small : M < (δ : ℝ) ^ stepExponent n * K * (β : ℝ) ^ 2
+  cutoff_gt_one : 1 < fundamentalCutoff γ (2 * M)
+
+namespace IterationParameters
+variable {n : ℕ} {ρ β δ γ θ Θ : ℝ≥0} {K M : ℝ}
+  (b : IterationParameters n ρ β δ γ θ Θ K M)
+include b
+
+theorem fundamental : FundamentalParameters n ρ β δ γ K (2 * M) (2 * Θ) where
+  dimension_pos := b.dimension_pos
+  beta_pos := b.beta_pos
+  delta_pos := b.delta_pos
+  theta_pos := by have : (0 : ℝ) < Θ := lt_trans zero_lt_one b.upper_gt_one; positivity
+  delta_small := lt_of_lt_of_le b.delta_small (min_le_left _ _)
+  angle_loss := b.angle_loss
+  angle_width := by linarith [b.angle_width, γ.coe_nonneg]
+  width_le_one := b.width_le_one
+  action_loss := b.action_loss
+  divisor_margin := b.divisor_margin
+  perturbation_pos := by linarith [b.perturbation_pos]
+  perturbation_small := by linarith [b.perturbation_small]
+  cutoff_gt_one := b.cutoff_gt_one
+
+theorem delta_lt_one : δ < 1 := by
+  exact_mod_cast (show (δ : ℝ) < 1 by linarith [b.fundamental.delta_lt])
+
+theorem beta_lt_gamma : β < γ := by
+  exact_mod_cast (show (β : ℝ) < γ by linarith [b.action_loss, b.angle_loss, δ.coe_nonneg])
+
+theorem lower_le_upper : θ ≤ Θ := b.lower_lt_one.le.trans b.upper_gt_one.le
+
+theorem mean_gradient_small : M / (β : ℝ) < (β : ℝ) * δ := by
+  have hβ : (0 : ℝ) < β := b.beta_pos
+  have hd : (δ : ℝ) ≤ 1 := b.delta_lt_one.le
+  have hp : (δ : ℝ) ^ stepExponent n ≤ δ := by
+    simpa using pow_le_pow_of_le_one δ.coe_nonneg hd (show 1 ≤ stepExponent n by
+      unfold stepExponent; omega)
+  have hpk : (δ : ℝ) ^ stepExponent n * K ≤ δ :=
+    (mul_le_mul_of_nonneg_left b.divisor_le_one (by positivity)).trans (by simpa using hp)
+  apply (div_lt_iff₀ hβ).mpr
+  nlinarith [mul_le_mul_of_nonneg_right hpk (sq_nonneg (β : ℝ)), b.perturbation_small]
+
+theorem mean_hessian_small : 2 * n * M / (β : ℝ) ^ 2 < (δ : ℝ) * θ := by
+  have hβ : (0 : ℝ) < β := b.beta_pos
+  have hδ : (0 : ℝ) < δ := b.delta_pos
+  have hn : (0 : ℝ) < n := by exact_mod_cast b.dimension_pos
+  have hsmall : (δ : ℝ) < (θ : ℝ) / (2 * n) :=
+    lt_of_lt_of_le b.delta_small (min_le_right _ _)
+  have hdθ : 2 * n * (δ : ℝ) < θ := by
+    have hh := (lt_div_iff₀ (show (0 : ℝ) < 2 * n by positivity)).mp hsmall
+    nlinarith
+  have hp : (δ : ℝ) ^ stepExponent n ≤ (δ : ℝ) ^ 2 :=
+    pow_le_pow_of_le_one δ.coe_nonneg b.delta_lt_one.le (by unfold stepExponent; omega)
+  have hpk : (δ : ℝ) ^ stepExponent n * K ≤ (δ : ℝ) ^ 2 :=
+    (mul_le_mul_of_nonneg_left b.divisor_le_one (by positivity)).trans (by simpa using hp)
+  have hM : M / (β : ℝ) ^ 2 < (δ : ℝ) ^ 2 :=
+    (div_lt_iff₀ (sq_pos_of_pos hβ)).mpr
+      (b.perturbation_small.trans_le (mul_le_mul_of_nonneg_right hpk (sq_nonneg _)))
+  calc
+    _ = (2 * n : ℝ) * (M / (β : ℝ) ^ 2) := by ring
+    _ < (2 * n : ℝ) * (δ : ℝ) ^ 2 := mul_lt_mul_of_pos_left hM (by positivity)
+    _ < (δ : ℝ) * θ := by nlinarith [mul_lt_mul_of_pos_right hdθ hδ]
+
+end IterationParameters
+end KamProject.Arnold1963
diff --git a/LeanPool/ArnoldKAM/Arnold1963/Step/MeasureBudget.lean b/LeanPool/ArnoldKAM/Arnold1963/Step/MeasureBudget.lean
new file mode 100644
index 0000000000..a9a36f0959
--- /dev/null
+++ b/LeanPool/ArnoldKAM/Arnold1963/Step/MeasureBudget.lean
@@ -0,0 +1,97 @@
+/-
+Copyright (c) 2026 Bingqi Yu. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Bingqi Yu
+-/
+
+module
+
+public import LeanPool.ArnoldKAM.Arnold1963.Step.FrequencyPreparation
+
+/-!
+Supporting results for the analytic Hamiltonian KAM construction.
+-/
+
+@[expose] public section
+noncomputable section
+open Set MeasureTheory
+open scoped NNReal ENNReal
+namespace KamProject.Arnold1963
+
+theorem realVolume_pos_of_loss_lt {n : ℕ} {G S : Set (ComplexSpace n)}
+    (hloss : realVolume (G \ S) < realVolume G) : 0 < realVolume S := by
+  by_contra hn
+  have hz : realVolume S = 0 := le_antisymm (le_of_not_gt hn) zero_le
+  have hcover : realSlice G ⊆ realSlice (G \ S) ∪ realSlice S := by
+    intro x hx
+    by_cases hs : complexify x ∈ S
+    · exact Or.inr hs
+    · exact Or.inl ⟨hx, hs⟩
+  have hh := (measure_mono (μ := realLebesgue n) hcover).trans (measure_union_le _ _)
+  change realVolume G ≤ realVolume (G \ S) + realVolume S at hh
+  rw [hz, add_zero] at hh
+  exact (not_lt_of_ge hh) hloss
+
+theorem realSlice_nonempty_of_realVolume_pos {n : ℕ} {G : Set (ComplexSpace n)}
+    (hG : 0 < realVolume G) : (realSlice G).Nonempty :=
+  nonempty_of_measure_ne_zero (ne_of_gt hG)
+
+namespace FrequencyChangeInput
+variable {n : ℕ} {A g Δ : ComplexSpace n → ComplexSpace n}
+  {G Ω : Set (ComplexSpace n)} {β κ θ Θ : ℝ≥0}
+  (h : FrequencyChangeInput A g Δ G Ω β κ θ Θ)
+include h
+
+theorem iterationE_nonempty_iff (K N : ℝ) :
+    (h.iterationE K N).Nonempty ↔ (h.iterationDomain K N).Nonempty := by
+  constructor
+  · rintro ⟨_, p, hp, _⟩
+    exact ⟨p, hp⟩
+  · rintro ⟨p, hp⟩
+    exact ⟨p, p, hp, by simp⟩
+
+theorem iteration_nonempty_of_measure_budget {K N : ℝ} {L : ℝ≥0∞}
+    (hloss : realVolume (G \ h.iterationDomain K N) ≤ L) (hL : L < realVolume G) :
+    (realSlice (h.iterationDomain K N)).Nonempty ∧ (h.iterationE K N).Nonempty := by
+  have hp := realSlice_nonempty_of_realVolume_pos (realVolume_pos_of_loss_lt (hloss.trans_lt hL))
+  refine ⟨hp, ?_⟩
+  obtain ⟨x, hx⟩ := hp
+  exact ⟨complexify x, complexify x, hx, by simp⟩
+
+end FrequencyChangeInput
+
+theorem frequency_measure_to_action_budget {n : ℕ} {G S G₀ Ω₀ : Set (ComplexSpace n)}
+    {A₀ g₀ : ComplexSpace n → ComplexSpace n} (c₀ : AnalyticFrequencyChart A₀ g₀ G₀ Ω₀)
+    {θ Θ₀ B : ℝ} (_hθ : 0 < θ) (hΘ₀ : 0 ≤ Θ₀)
+    (hupper : ∀ p ∈ G₀, ‖fderiv ℂ A₀ p‖ ≤ Θ₀)
+    (hloss : realVolume (G \ S) ≤ ENNReal.ofReal (θ⁻¹ ^ n) *
+      (ENNReal.ofReal B * realVolume Ω₀)) :
+    realVolume (G \ S) ≤ ENNReal.ofReal ((Θ₀ / θ) ^ n) *
+      (ENNReal.ofReal B * realVolume G₀) := by
+  calc
+    _ ≤ ENNReal.ofReal (θ⁻¹ ^ n) *
+        (ENNReal.ofReal B * (ENNReal.ofReal (Θ₀ ^ n) * realVolume G₀)) :=
+      hloss.trans (mul_le_mul' le_rfl (mul_le_mul' le_rfl (c₀.realVolume_image_le hΘ₀ hupper)))
+    _ = _ := by
+      rw [div_pow, div_eq_mul_inv, inv_pow, ENNReal.ofReal_mul (pow_nonneg hΘ₀ n)]
+      ac_rfl
+
+theorem frequency_measure_to_uniform_action_budget {n : ℕ}
+    {G S G₀ Ω₀ : Set (ComplexSpace n)} {A₀ g₀ : ComplexSpace n → ComplexSpace n}
+    (c₀ : AnalyticFrequencyChart A₀ g₀ G₀ Ω₀) {θ θ₀ Θ₀ B : ℝ}
+    (hθ₀ : 0 < θ₀) (hθ : θ₀ / 2 ≤ θ) (hΘ₀ : 0 ≤ Θ₀)
+    (hupper : ∀ p ∈ G₀, ‖fderiv ℂ A₀ p‖ ≤ Θ₀)
+    (hloss : realVolume (G \ S) ≤ ENNReal.ofReal (θ⁻¹ ^ n) *
+      (ENNReal.ofReal B * realVolume Ω₀)) :
+    realVolume (G \ S) ≤ ENNReal.ofReal ((2 * Θ₀ / θ₀) ^ n) *
+      (ENNReal.ofReal B * realVolume G₀) := by
+  have hθp : 0 < θ := lt_of_lt_of_le (by positivity) hθ
+  apply (frequency_measure_to_action_budget c₀ hθp hΘ₀ hupper hloss).trans
+  apply mul_le_mul' _ le_rfl
+  apply ENNReal.ofReal_le_ofReal
+  apply pow_le_pow_left₀ (by positivity)
+  calc
+    Θ₀ / θ ≤ Θ₀ / (θ₀ / 2) := div_le_div_of_nonneg_left hΘ₀ (by positivity) hθ
+    _ = 2 * Θ₀ / θ₀ := by ring
+
+end KamProject.Arnold1963
diff --git a/LeanPool/ArnoldKAM/Arnold1963/Step/Nonresonance.lean b/LeanPool/ArnoldKAM/Arnold1963/Step/Nonresonance.lean
new file mode 100644
index 0000000000..806426133d
--- /dev/null
+++ b/LeanPool/ArnoldKAM/Arnold1963/Step/Nonresonance.lean
@@ -0,0 +1,72 @@
+/-
+Copyright (c) 2026 Bingqi Yu. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Bingqi Yu
+-/
+
+module
+
+public import LeanPool.ArnoldKAM.Arnold1963.Analysis.FourierParameter
+public import LeanPool.ArnoldKAM.Arnold1963.Arithmetic.Parameters
+public import LeanPool.ArnoldKAM.Arnold1963.Geometry.GeneratingTorus
+
+/-!
+Supporting results for the analytic Hamiltonian KAM construction.
+-/
+
+@[expose] public section
+noncomputable section
+open Set
+namespace KamProject.Arnold1963
+
+/-- Finite-cutoff lower bounds on all retained nonzero integer frequency pairings. -/
+def FiniteNonresonant {n : ℕ} (ω : ComplexSpace n) (K N : ℝ) : Prop :=
+  ∀ k ∈ lowModes n N, K / indexLength k ^ (n + 1) ≤ ‖indexPairing k ω‖
+
+/-- The action subdomain satisfying the finite-cutoff nonresonance condition. -/
+def nonresonantDomain {n : ℕ} (G : Set (ComplexSpace n))
+    (ω : ComplexSpace n → ComplexSpace n) (K N : ℝ) : Set (ComplexSpace n) :=
+  {p | p ∈ G ∧ FiniteNonresonant (ω p) K N}
+
+theorem FiniteNonresonant.ne_zero {n : ℕ} {ω : ComplexSpace n} {K N : ℝ}
+    (h : FiniteNonresonant ω K N) (hK : 0 < K) {k : FourierIndex n}
+    (hk : k ∈ lowModes n N) : indexPairing k ω ≠ 0 := by
+  have hk0 := (mem_lowModes.mp hk).1
+  exact norm_pos_iff.mp ((div_pos hK (pow_pos hk0 _)).trans_le (h k hk))
+
+@[simp] theorem indexLength_neg {n : ℕ} (k : FourierIndex n) :
+    indexLength (-k) = indexLength k := by simp [indexLength]
+
+theorem neg_mem_lowModes {n : ℕ} {k : FourierIndex n} {N : ℝ} :
+    -k ∈ lowModes n N ↔ k ∈ lowModes n N := by simp
+
+theorem indexPairing_conj {n : ℕ} (k : FourierIndex n) (z : ComplexSpace n) :
+    indexPairing k (conjVec z) = star (indexPairing k z) := by
+  simp [indexPairing, conjVec]
+
+@[simp] theorem indexPairing_neg {n : ℕ} (k : FourierIndex n) (z : ComplexSpace n) :
+    indexPairing (-k) z = -indexPairing k z := by simp [indexPairing, neg_mul]
+
+theorem FiniteNonresonant.conj {n : ℕ} {ω : ComplexSpace n} {K N : ℝ}
+    (h : FiniteNonresonant ω K N) : FiniteNonresonant (conjVec ω) K N := by
+  intro k hk
+  rw [indexPairing_conj, norm_star]
+  exact h k hk
+
+theorem nonresonantDomain_conj {n : ℕ} {G : Set (ComplexSpace n)}
+    {ω : ComplexSpace n → ComplexSpace n} {K N : ℝ} (hG : ConjInvariant G)
+    (hω : ∀ p ∈ G, ω (conjVec p) = conjVec (ω p)) :
+    ConjInvariant (nonresonantDomain G ω K N) := by
+  intro p hp
+  refine ⟨hG p hp.1, ?_⟩
+  rw [hω p hp.1]
+  exact hp.2.conj
+
+theorem analyticAt_indexPairing {n : ℕ} (k : FourierIndex n) (z : ComplexSpace n) :
+    AnalyticAt ℂ (indexPairing k) z := by
+  apply Finset.analyticAt_fun_sum
+  intro j _
+  exact analyticAt_const.mul ((ContinuousLinearMap.proj (R := ℂ)
+    (φ := fun _ : Fin n => ℂ) j).analyticAt z)
+
+end KamProject.Arnold1963
diff --git a/LeanPool/ArnoldKAM/Arnold1963/Step/NumericalBudget.lean b/LeanPool/ArnoldKAM/Arnold1963/Step/NumericalBudget.lean
new file mode 100644
index 0000000000..22e7ae0053
--- /dev/null
+++ b/LeanPool/ArnoldKAM/Arnold1963/Step/NumericalBudget.lean
@@ -0,0 +1,181 @@
+/-
+Copyright (c) 2026 Bingqi Yu. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Bingqi Yu
+-/
+
+module
+
+public import LeanPool.ArnoldKAM.Arnold1963.Step.HomologicalBound
+
+/-!
+Supporting results for the analytic Hamiltonian KAM construction.
+-/
+
+@[expose] public section
+noncomputable section
+open scoped NNReal
+namespace KamProject.Arnold1963
+
+/-- The logarithmic Fourier cutoff balancing strip loss and perturbation size. -/
+def fundamentalCutoff (γ M : ℝ) : ℝ := Real.log (1 / M) / γ
+
+/-- The strict quadratic remainder target used in the fundamental step. -/
+def fundamentalRemainderBound (n : ℕ) (M δ β : ℝ) : ℝ :=
+  (1 / 4 : ℝ) * M ^ 2 / (δ ^ (2 * stepExponent n) * β ^ 2)
+
+theorem fundamentalRemainderBound_twice (n : ℕ) (M δ β : ℝ) :
+    fundamentalRemainderBound n (2 * M) δ β =
+      M ^ 2 / (δ ^ (2 * stepExponent n) * β ^ 2) :=
+  strengthened_budget_two_mul M δ β n
+
+/-- The positive parameters and numerical constraints required by the fundamental step. -/
+structure FundamentalParameters (n : ℕ) (ρ β δ γ : ℝ≥0) (K M Θ : ℝ) : Prop where
+  dimension_pos : 0 < n
+  beta_pos : 0 < β
+  delta_pos : 0 < δ
+  theta_pos : 0 < Θ
+  delta_small : (δ : ℝ) < threshold0 n Θ
+  angle_loss : 10 * (δ : ℝ) < 2 * γ
+  angle_width : 2 * (γ : ℝ) < ρ
+  width_le_one : ρ ≤ 1
+  action_loss : 3 * (β : ℝ) < 2 * δ
+  divisor_margin : 2 * (β : ℝ) < K
+  perturbation_pos : 0 < M
+  perturbation_small : M < 2 * (δ : ℝ) ^ stepExponent n * K * (β : ℝ) ^ 2
+  cutoff_gt_one : 1 < fundamentalCutoff γ M
+
+namespace FundamentalParameters
+variable {n : ℕ} {ρ β δ γ : ℝ≥0} {K M Θ : ℝ}
+  (b : FundamentalParameters n ρ β δ γ K M Θ)
+include b
+
+theorem gamma_pos : 0 < γ := by
+  have hd : (0 : ℝ) < δ := b.delta_pos
+  exact_mod_cast (show (0 : ℝ) < γ by linarith [b.angle_loss])
+
+theorem K_pos : 0 < K := by
+  have hb : (0 : ℝ) < β := b.beta_pos
+  linarith [b.divisor_margin]
+
+theorem delta_lt : (δ : ℝ) < 1 / 12 := (threshold0_bounds b.delta_small).1
+
+theorem double_delta_le : δ + δ ≤ ρ := by
+  have hd := δ.coe_nonneg
+  have h1 := b.angle_loss
+  have h2 := b.angle_width
+  exact_mod_cast (show (δ : ℝ) + δ ≤ ρ by linarith)
+
+theorem exp_cutoff : Real.exp (-(fundamentalCutoff γ M) * γ) = M := by
+  have hγ : (γ : ℝ) ≠ 0 := ne_of_gt (show (0 : ℝ) < γ from b.gamma_pos)
+  rw [fundamentalCutoff, neg_mul, div_mul_cancel₀ _ hγ,
+    Real.exp_neg, Real.exp_log (div_pos zero_lt_one b.perturbation_pos)]
+  simp
+
+theorem generating_bound_lt : homologicalBound n M K δ <
+    2 * constantL5 n * (δ : ℝ) ^ 2 * (β : ℝ) ^ 2 := by
+  have hL := constantL5_pos n
+  apply (div_lt_iff₀ (mul_pos b.K_pos (pow_pos (show (0 : ℝ) < δ from b.delta_pos) _))).2
+  have hh := mul_lt_mul_of_pos_right b.perturbation_small hL
+  convert hh using 1
+  dsimp [stepExponent, homologicalExponent]
+  simp only [pow_add, pow_mul]
+  ring
+
+theorem generating_small : homologicalBound n M K δ < (β : ℝ) ^ 2 / (16 * n) := by
+  have hn : (0 : ℝ) < n := by exact_mod_cast b.dimension_pos
+  have hδ : (0 : ℝ) < δ := b.delta_pos
+  have hβ : (0 : ℝ) < β := b.beta_pos
+  have hb := (threshold0_budget_conditions b.dimension_pos b.theta_pos b.delta_small).2.1
+  apply (lt_div_iff₀ (show (0 : ℝ) < 16 * n by positivity)).2
+  calc
+    _ < (2 * constantL5 n * (δ : ℝ) ^ 2 * (β : ℝ) ^ 2) * (16 * n) :=
+      mul_lt_mul_of_pos_right b.generating_bound_lt (by positivity)
+    _ = ((δ : ℝ) * constantL2 n) * (2 * δ * (β : ℝ) ^ 2) := by unfold constantL2; ring
+    _ < 2 * δ * (β : ℝ) ^ 2 := by
+      simpa using mul_lt_mul_of_pos_right hb (show 0 < 2 * (δ : ℝ) * (β : ℝ) ^ 2 by positivity)
+    _ < (β : ℝ) ^ 2 := by nlinarith [b.delta_lt, sq_pos_of_pos hβ]
+
+theorem generating_lt_beta_sq : homologicalBound n M K δ < (β : ℝ) ^ 2 := by
+  have hn : (1 : ℝ) ≤ n := by exact_mod_cast b.dimension_pos
+  exact b.generating_small.trans_le (div_le_self (sq_nonneg _) (by nlinarith))
+
+theorem displacement_lt_beta : homologicalBound n M K δ / β < β := by
+  apply (div_lt_iff₀ (show (0 : ℝ) < β from b.beta_pos)).2
+  simpa only [pow_two] using b.generating_lt_beta_sq
+
+theorem remainder_budget :
+    (1 / 2 : ℝ) * n ^ 2 * Θ * (homologicalBound n M K δ / δ) ^ 2 +
+      (((2 * n : ℝ) / Real.exp 1) ^ n * M ^ 2 / (δ : ℝ) ^ (n + 1)) +
+      (n * M / β) * (homologicalBound n M K δ / δ) <
+        fundamentalRemainderBound n M δ β := by
+  have hδ : (0 : ℝ) < δ := b.delta_pos
+  have hβ : (0 : ℝ) < β := b.beta_pos
+  have hK := b.K_pos
+  have hM := b.perturbation_pos
+  have hΘ := b.theta_pos
+  have hn : (0 : ℝ) < n := by exact_mod_cast b.dimension_pos
+  have hδ1 : (δ : ℝ) ≤ 1 := by linarith [b.delta_lt]
+  have hβ1 : (β : ℝ) ≤ 1 := by linarith [b.action_loss, b.delta_lt]
+  have hr : (β : ℝ) / K ≤ 1 / 2 := (div_le_iff₀ hK).2 (by linarith [b.divisor_margin])
+  have hr0 : 0 ≤ (β : ℝ) / K := by positivity
+  have hr2 : ((β : ℝ) / K) ^ 2 ≤ 1 / 4 := by nlinarith
+  obtain ⟨_, hL2, hL3, hL4⟩ :=
+    threshold0_budget_conditions b.dimension_pos b.theta_pos b.delta_small
+  have hL5 : (δ : ℝ) * n * constantL5 n ≤ 1 := by
+    dsimp [constantL2] at hL2
+    linarith only [hL2]
+  have htail : (δ : ℝ) * (((2 * n : ℝ) / Real.exp 1) ^ n) ≤ 1 := by
+    dsimp [constantL4] at hL4
+    linarith only [hL4]
+  have hp3 : (δ : ℝ) ^ (3 * n + 4) ≤ (δ : ℝ) ^ 2 :=
+    pow_le_pow_of_le_one hδ.le hδ1 (by omega)
+  have hp4 : (δ : ℝ) ^ (2 * n + 3) ≤ (δ : ℝ) ^ 2 :=
+    pow_le_pow_of_le_one hδ.le hδ1 (by omega)
+  let R := M ^ 2 / ((δ : ℝ) ^ (2 * stepExponent n) * (β : ℝ) ^ 2)
+  have hR : 0 < R := by dsimp [R]; positivity
+  have h2 : (1 / 2 : ℝ) * n ^ 2 * Θ * (homologicalBound n M K δ / δ) ^ 2 =
+      R * (((δ : ℝ) * (constantL3 n * Θ)) * ((β : ℝ) / K) ^ 2 * δ) := by
+    dsimp [R, homologicalBound, homologicalExponent, stepExponent, constantL3]
+    simp only [pow_add, pow_mul']
+    field_simp
+  have h3 : (((2 * n : ℝ) / Real.exp 1) ^ n * M ^ 2 / (δ : ℝ) ^ (n + 1)) =
+      R * (((δ : ℝ) * (((2 * n : ℝ) / Real.exp 1) ^ n)) *
+        (β : ℝ) ^ 2 * (δ : ℝ) ^ (3 * n + 4)) := by
+    dsimp [R, stepExponent]
+    simp only [pow_add, pow_mul']
+    field_simp
+  have h4 : (n * M / β) * (homologicalBound n M K δ / δ) =
+      R * (((δ : ℝ) * n * constantL5 n) * ((β : ℝ) / K) * (δ : ℝ) ^ (2 * n + 3)) := by
+    dsimp [R, homologicalBound, homologicalExponent, stepExponent]
+    simp only [pow_add, pow_mul']
+    field_simp
+  have hb2 : ((δ : ℝ) * (constantL3 n * Θ)) * ((β : ℝ) / K) ^ 2 * δ ≤ (δ : ℝ) / 4 := by
+    have hh := mul_le_mul hL3.le hr2 (sq_nonneg _) zero_le_one
+    have := mul_le_mul_of_nonneg_right hh hδ.le
+    linarith only [this]
+  have hb3 : ((δ : ℝ) * (((2 * n : ℝ) / Real.exp 1) ^ n)) *
+      (β : ℝ) ^ 2 * (δ : ℝ) ^ (3 * n + 4) ≤ (δ : ℝ) ^ 2 := by
+    have hβ2 : (β : ℝ) ^ 2 ≤ 1 := by nlinarith only [hβ, hβ1]
+    have hprod := mul_le_mul htail hβ2 (sq_nonneg _) zero_le_one
+    have hh := mul_le_mul hprod hp3 (by positivity) (by norm_num : (0 : ℝ) ≤ 1 * 1)
+    simpa using hh
+  have hb4 : ((δ : ℝ) * n * constantL5 n) * ((β : ℝ) / K) *
+      (δ : ℝ) ^ (2 * n + 3) ≤ (1 / 2 : ℝ) * (δ : ℝ) ^ 2 := by
+    have hprod := mul_le_mul hL5 hr hr0 zero_le_one
+    have hh := mul_le_mul hprod hp4 (by positivity) (by norm_num : (0 : ℝ) ≤ 1 * (1 / 2))
+    simpa using hh
+  rw [h2, h3, h4]
+  calc
+    _ ≤ R * ((δ : ℝ) / 4 + (δ : ℝ) ^ 2 + 1 / 2 * (δ : ℝ) ^ 2) := by
+      have hA := mul_le_mul_of_nonneg_left hb2 hR.le
+      have hB := mul_le_mul_of_nonneg_left hb3 hR.le
+      have hC := mul_le_mul_of_nonneg_left hb4 hR.le
+      linarith only [hA, hB, hC]
+    _ < R * (1 / 4) := by
+      apply mul_lt_mul_of_pos_left _ hR
+      nlinarith only [b.delta_lt, hδ]
+    _ = fundamentalRemainderBound n M δ β := by dsimp [R, fundamentalRemainderBound]; ring
+
+end FundamentalParameters
+end KamProject.Arnold1963
diff --git a/LeanPool/ArnoldKAM/Arnold1963/Step/Remainder.lean b/LeanPool/ArnoldKAM/Arnold1963/Step/Remainder.lean
new file mode 100644
index 0000000000..fd1bfe2801
--- /dev/null
+++ b/LeanPool/ArnoldKAM/Arnold1963/Step/Remainder.lean
@@ -0,0 +1,143 @@
+/-
+Copyright (c) 2026 Bingqi Yu. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Bingqi Yu
+-/
+
+module
+
+public import LeanPool.ArnoldKAM.Arnold1963.Step.Construction
+public import LeanPool.ArnoldKAM.Arnold1963.Analysis.FourierReconstruction
+
+/-!
+Supporting results for the analytic Hamiltonian KAM construction.
+-/
+
+@[expose] public section
+noncomputable section
+open Set
+open scoped NNReal
+namespace KamProject.Arnold1963
+
+/-- The sum of separate error estimates before applying the final remainder budget. -/
+def fundamentalRawBound (n : ℕ) (M K Θ δ β : ℝ) : ℝ :=
+  (1 / 2 : ℝ) * n ^ 2 * Θ * (homologicalBound n M K δ / δ) ^ 2 +
+    (((2 * n : ℝ) / Real.exp 1) ^ n * M ^ 2 / δ ^ (n + 1)) +
+    (n * M / β) * (homologicalBound n M K δ / δ)
+
+namespace FundamentalInput
+variable {n : ℕ} {G E : Set (ComplexSpace n)} {ρ β δ γ : ℝ≥0} {K M Θ : ℝ}
+  {h : ComplexSpace n → ℂ} {f : AnalyticPhaseFunction n G ρ}
+  (i : FundamentalInput (E := E) (β := β) (δ := δ) (γ := γ) (K := K) (M := M) (Θ := Θ) h f)
+
+/-- The transformed total Hamiltonian minus the original integrable Hamiltonian. -/
+def remainder (z : ComplexPhaseSpace n) : ℂ :=
+  h (i.transform z).1 + f.toFun (i.transform z) - h z.1
+
+include i
+
+theorem first_variation_cancel {z : ComplexPhaseSpace n}
+    (hz : z ∈ phaseDomain (erosion E (β + β)) (ρ - (γ + γ))) :
+    fderiv ℂ h z.1 ((i.transform z).1 - z.1) +
+      fourierTruncation (f.fourierCoeff z.1) (fundamentalCutoff γ M) (i.transform z).2 = 0 := by
+  have hP := erosion_subset E (β + β) hz.1
+  have he := (i.generatingData.equations (i.budget.target_subset E hz)).1
+  have hd : (i.transform z).1 - z.1 = qGradient i.generator.toFun (z.1, (i.transform z).2) := by
+    change (i.transform z).1 = z.1 + qGradient i.generator.toFun (z.1, (i.transform z).2) at he
+    rw [he, add_sub_cancel_left]
+  rw [hd, fderiv_eq_actionFrequency h z.1]
+  exact homological_equation (z := (z.1, (i.transform z).2))
+    (ω := actionFrequency h) f (i.domain_subset hP)
+    (analyticOnNhd_actionFrequency i.integrable.analytic _ (i.domain_subset hP))
+    i.budget.K_pos (i.nonresonant z.1 hP) (zero_lt_one.trans i.budget.cutoff_gt_one)
+    (i.mean_zero z.1 hP)
+
+theorem taylor_bound {z : ComplexPhaseSpace n}
+    (hz : z ∈ phaseDomain (erosion E (β + β)) (ρ - (γ + γ))) :
+    ‖h (i.transform z).1 - h z.1 - fderiv ℂ h z.1 ((i.transform z).1 - z.1)‖ ≤
+      (1 / 2 : ℝ) * n ^ 2 * Θ * (homologicalBound n M K δ / δ) ^ 2 := by
+  have he := norm_taylor_remainder_le_of_coordinate_bound
+    ((i.action_segment hz).trans (erosion_subset G β)) i.integrable.analytic
+    i.budget.theta_pos.le i.integrable.hessian_bound
+  apply he.trans
+  apply mul_le_mul_of_nonneg_left _ (by have := i.budget.theta_pos; positivity)
+  exact pow_le_pow_left₀ (norm_nonneg _) (i.action_displacement hz) 2
+
+theorem tail_bound {z : ComplexPhaseSpace n}
+    (hz : z ∈ phaseDomain (erosion E (β + β)) (ρ - (γ + γ))) :
+    ‖f.toFun (z.1, (i.transform z).2) -
+      fourierTruncation (f.fourierCoeff z.1) (fundamentalCutoff γ M) (i.transform z).2‖ ≤
+      (((2 * n : ℝ) / Real.exp 1) ^ n * M ^ 2 / (δ : ℝ) ^ (n + 1)) := by
+  have hδγρ : δ + γ ≤ ρ := by
+    have hh := i.budget.angle_loss
+    have hh' := i.budget.angle_width
+    have hδ := δ.coe_nonneg
+    exact_mod_cast (show (δ : ℝ) + γ ≤ ρ by linarith)
+  have he := f.norm_sub_fourierTruncation_le (N := fundamentalCutoff γ M)
+    (i.domain_subset (erosion_subset E (β + β) hz.1)) i.budget.dimension_pos
+    (show (0 : ℝ) < δ from i.budget.delta_pos) i.budget.delta_lt.le
+    γ.coe_nonneg (show (↑(ρ - (δ + γ)) : ℝ) ≤ (ρ : ℝ) - ((δ : ℝ) + γ) by
+      rw [NNReal.coe_sub hδγρ, NNReal.coe_add]) (i.transformed_angle hz)
+  rw [i.budget.exp_cutoff] at he
+  apply he.trans
+  calc
+    _ ≤ ((((2 * n : ℝ) / Real.exp 1) ^ n * M / (δ : ℝ) ^ (n + 1))) * M := by
+      apply mul_le_mul_of_nonneg_right _ i.budget.perturbation_pos.le
+      apply div_le_div_of_nonneg_right _ (by positivity)
+      exact mul_le_mul_of_nonneg_left i.perturbation_bound (by positivity)
+    _ = _ := by ring
+
+theorem perturbation_composition_bound {z : ComplexPhaseSpace n}
+    (hz : z ∈ phaseDomain (erosion E (β + β)) (ρ - (γ + γ))) :
+    ‖f.toFun (i.transform z) - f.toFun (z.1, (i.transform z).2)‖ ≤
+      (n * M / β) * (homologicalBound n M K δ / δ) := by
+  let q := (i.transform z).2
+  have hq : q ∈ angleStrip n ρ :=
+    angleStrip_mono (tsub_le_self : ρ - (δ + γ) ≤ ρ) (i.transformed_angle hz)
+  have hf : AnalyticOnNhd ℂ (fun p => f.toFun (p, q)) G := fun p hp =>
+    (f.analytic (p, q) ⟨hp, hq⟩).comp (f := fun p => (p, q))
+      (analyticAt_id.prod analyticAt_const)
+  have hM : NormBoundOn (fun p => f.toFun (p, q)) G M :=
+    ⟨i.budget.perturbation_pos.le, fun p hp =>
+      (f.norm_le_iff.mp i.perturbation_bound).norm_le ⟨hp, hq⟩⟩
+  have hD : NormBoundOn (fderiv ℂ (fun p => f.toFun (p, q))) (erosion G β) (M / β) :=
+    ⟨div_nonneg i.budget.perturbation_pos.le β.coe_nonneg, fun p hp =>
+      norm_fderiv_le_div_of_mem_erosion i.budget.beta_pos hf hM hp⟩
+  have he := norm_sub_le_of_analytic_segment_bound (i.action_segment hz)
+    (hf.mono (erosion_subset G β)) hD
+  have hn : (1 : ℝ) ≤ n := by exact_mod_cast i.budget.dimension_pos
+  have hm : 0 ≤ M / (β : ℝ) := div_nonneg i.budget.perturbation_pos.le β.coe_nonneg
+  have hc : M / (β : ℝ) ≤ n * M / β := by
+    have hh := mul_le_mul_of_nonneg_right hn hm
+    simpa only [one_mul, mul_div_assoc] using hh
+  exact he.trans (mul_le_mul hc (i.action_displacement hz) (norm_nonneg _)
+    (by have := i.budget.perturbation_pos; positivity))
+
+theorem remainder_decomposition {z : ComplexPhaseSpace n}
+    (hz : z ∈ phaseDomain (erosion E (β + β)) (ρ - (γ + γ))) :
+    i.remainder z =
+      (h (i.transform z).1 - h z.1 - fderiv ℂ h z.1 ((i.transform z).1 - z.1)) +
+      (f.toFun (z.1, (i.transform z).2) -
+        fourierTruncation (f.fourierCoeff z.1) (fundamentalCutoff γ M) (i.transform z).2) +
+      (f.toFun (i.transform z) - f.toFun (z.1, (i.transform z).2)) := by
+  have he := i.first_variation_cancel hz
+  dsimp [remainder]
+  linear_combination he
+
+theorem remainder_norm_bound : NormBoundOn i.remainder
+    (phaseDomain (erosion E (β + β)) (ρ - (γ + γ)))
+    (fundamentalRawBound n M K Θ δ β) := by
+  refine ⟨?_, fun z hz => ?_⟩
+  · have := i.budget.theta_pos
+    have := i.budget.perturbation_pos
+    have := i.budget.K_pos
+    have := constantL5_pos n
+    dsimp [fundamentalRawBound, homologicalBound]
+    positivity
+  · rw [i.remainder_decomposition hz]
+    exact (norm_add_le _ _).trans (add_le_add
+      ((norm_add_le _ _).trans (add_le_add (i.taylor_bound hz) (i.tail_bound hz)))
+      (i.perturbation_composition_bound hz))
+
+end FundamentalInput
+end KamProject.Arnold1963
diff --git a/LeanPool/ArnoldKAM/Arnold1963/Tori/AngleBounds.lean b/LeanPool/ArnoldKAM/Arnold1963/Tori/AngleBounds.lean
new file mode 100644
index 0000000000..1f74a9b151
--- /dev/null
+++ b/LeanPool/ArnoldKAM/Arnold1963/Tori/AngleBounds.lean
@@ -0,0 +1,148 @@
+/-
+Copyright (c) 2026 Bingqi Yu. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Bingqi Yu
+-/
+
+module
+
+public import LeanPool.ArnoldKAM.Arnold1963.Convergence.JointAnalyticity
+public import LeanPool.ArnoldKAM.Arnold1963.Analysis.MeanValue
+public import LeanPool.ArnoldKAM.Arnold1963.Analysis.Cauchy
+public import LeanPool.ArnoldKAM.Arnold1963.Geometry.RealJacobian
+
+/-!
+Angle correction bounds, derivative smallness, and injectivity on a thinner complex strip.
+-/
+
+@[expose] public section
+noncomputable section
+open Set Metric
+open scoped NNReal
+namespace KamProject.Arnold1963
+
+theorem norm_imagPart_le {n} (z : ComplexSpace n) : ‖imagPart z‖ ≤ ‖z‖ := by
+  apply (real_norm_le_iff _ (norm_nonneg _)).mpr
+  intro j
+  exact (Complex.abs_im_le_norm (z j)).trans (norm_le_pi_norm z j)
+
+theorem convex_angleStrip (n : ℕ) (r : ℝ≥0) : Convex ℝ (angleStrip n r) := by
+  intro x hx y hy a b ha hb hab
+  have he : imagPart (a • x + b • y) = a • imagPart x + b • imagPart y := by
+    ext j
+    simp [imagPart, Complex.real_smul]
+  change ‖imagPart (a • x + b • y)‖ ≤ (r : ℝ)
+  rw [he]
+  calc
+    _ ≤ ‖a • imagPart x‖ + ‖b • imagPart y‖ := norm_add_le _ _
+    _ = a * ‖imagPart x‖ + b * ‖imagPart y‖ := by
+      simp [norm_smul, Real.norm_eq_abs, abs_of_nonneg ha, abs_of_nonneg hb]
+    _ ≤ a * r + b * r := add_le_add (mul_le_mul_of_nonneg_left hx ha)
+      (mul_le_mul_of_nonneg_left hy hb)
+    _ = r := by nlinarith
+
+namespace Iteration
+namespace InitialParameters
+variable {n : ℕ} {δ₁ θ₀ Θ₀ ρ₀ : ℝ≥0} {κ D : ℝ}
+  (b : InitialParameters n δ₁ θ₀ Θ₀ ρ₀ κ D)
+include b
+
+theorem beta_width_budget : 48 * (beta δ₁ 0 : ℝ) < ρ₀ := by
+  obtain ⟨hgρ, hg4⟩ := gamma_initial_bounds b.dimension_pos (threshold5_bounds b.small).2.1
+  have hdg : (δ₁ : ℝ) ≤ gamma n δ₁ 0 := by
+    have hh := pow_le_of_le_one (gamma n δ₁ 0).coe_nonneg
+      (show (gamma n δ₁ 0 : ℝ) ≤ 1 by linarith)
+      (show 4 * n ≠ 0 from Nat.mul_ne_zero (by norm_num) b.dimension_pos.ne')
+    simpa only [← NNReal.coe_pow, gamma_pow b.dimension_pos, delta, decay_zero] using hh
+  have hd : (0 : ℝ) < δ₁ := b.delta_pos
+  have hq : (δ₁ : ℝ) < 1 / 4 := b.delta_quarter
+  have hs : (δ₁ : ℝ) ^ 2 < 1 / 16 := by nlinarith
+  have ht := mul_lt_mul_of_pos_left hs hd
+  simp only [beta, delta, decay_zero, NNReal.coe_pow]
+  nlinarith
+
+theorem angle_derivative_budget :
+    2 * (beta δ₁ 0 : ℝ) / ((ρ₀ : ℝ) / 12) < 1 / 2 := by
+  apply (div_lt_iff₀ (div_pos (show (0 : ℝ) < ρ₀ from b.width_pos) (by norm_num))).mpr
+  linarith [b.beta_width_budget]
+
+end InitialParameters
+
+namespace InitialData
+variable {n : ℕ} {Ω₀ : Set (ComplexSpace n)} {δ₁ θ₀ Θ₀ ρ₀ : ℝ≥0} {κ D : ℝ}
+  (b : InitialParameters n δ₁ θ₀ Θ₀ ρ₀ κ D)
+  (h : InitialData n Ω₀ δ₁ θ₀ Θ₀ ρ₀ D)
+
+/-- The angle component of the limiting phase transformation at a fixed action label. -/
+def angleMap (p q : ComplexSpace n) : ComplexSpace n := (h.limitMap b (p, q)).2
+/-- The displacement of the limiting angle map from the identity. -/
+def angleCorrection (p q : ComplexSpace n) : ComplexSpace n := h.angleMap b p q - q
+
+theorem angleCorrection_analytic {p : ComplexSpace n} (hp : p ∈ h.limitDomain b) :
+    AnalyticOnNhd ℂ (h.angleCorrection b p) (commonAngleStrip n ρ₀) := by
+  intro q hq
+  exact (analyticAt_snd.comp (h.limitMap_angle_analytic b hp q hq)).sub analyticAt_id
+
+theorem angleCorrection_bound {p : ComplexSpace n} (hp : p ∈ h.limitDomain b)
+    {q : ComplexSpace n} (hq : q ∈ commonAngleStrip n ρ₀) :
+    ‖h.angleCorrection b p q‖ < 2 * (beta δ₁ 0 : ℝ) :=
+  (norm_snd_le (h.limitMap b (p, q) - (p, q))).trans_lt
+    (h.limitMap_displacement b (h.angle_mem_limitPhase b hp hq))
+
+include b in
+theorem thinAngleStrip_subset : angleStrip n (ρ₀ / 6) ⊆ commonAngleStrip n ρ₀ := by
+  intro q hq
+  change ‖imagPart q‖ ≤ ((ρ₀ / 6 : ℝ≥0) : ℝ) at hq
+  change ‖imagPart q‖ < (ρ₀ : ℝ) / 3
+  have hr : (0 : ℝ) < ρ₀ := b.width_pos
+  push_cast at hq
+  linarith
+
+include b in
+theorem thinAngleStrip_buffer {q : ComplexSpace n} (hq : q ∈ angleStrip n (ρ₀ / 6)) :
+    q ∈ erosion (commonAngleStrip n ρ₀) (ρ₀ / 12) := by
+  intro y hy
+  have he : imagPart y = imagPart (y - q) + imagPart q := by ext j; simp [imagPart]
+  have hh := (norm_add_le (imagPart (y - q)) (imagPart q)).trans
+    (add_le_add (norm_imagPart_le (y - q)) le_rfl)
+  rw [← he] at hh
+  change ‖imagPart q‖ ≤ ((ρ₀ / 6 : ℝ≥0) : ℝ) at hq
+  rw [mem_closedBall, dist_eq_norm] at hy
+  change ‖imagPart y‖ < (ρ₀ : ℝ) / 3
+  push_cast at hq hy
+  have hr : (0 : ℝ) < ρ₀ := b.width_pos
+  linarith
+
+theorem angleCorrection_derivative {p : ComplexSpace n} (hp : p ∈ h.limitDomain b)
+    {q : ComplexSpace n} (hq : q ∈ angleStrip n (ρ₀ / 6)) :
+    ‖fderiv ℂ (h.angleCorrection b p) q‖ < 1 / 2 := by
+  have hh := norm_fderiv_le_div_of_mem_erosion
+    (show 0 < ρ₀ / 12 from div_pos b.width_pos (by norm_num))
+    (h.angleCorrection_analytic b hp)
+    ⟨by positivity, fun z hz => (h.angleCorrection_bound b hp hz).le⟩
+    (thinAngleStrip_buffer b hq)
+  exact hh.trans_lt (by simpa using b.angle_derivative_budget)
+
+theorem angleCorrection_lipschitz {p : ComplexSpace n} (hp : p ∈ h.limitDomain b) :
+    LipschitzOnWith (1 / 2) (h.angleCorrection b p) (angleStrip n (ρ₀ / 6)) :=
+  (convex_angleStrip n (ρ₀ / 6)).lipschitzOnWith_of_nnnorm_fderiv_le
+    (fun q hq => (h.angleCorrection_analytic b hp q (thinAngleStrip_subset b hq)).differentiableAt)
+    (fun q hq => by exact_mod_cast (h.angleCorrection_derivative b hp hq).le)
+
+theorem angleMap_injOn {p : ComplexSpace n} (hp : p ∈ h.limitDomain b) :
+    InjOn (h.angleMap b p) (angleStrip n (ρ₀ / 6)) := by
+  intro q hq r hr he
+  have hh := (h.angleCorrection_lipschitz b hp).dist_le_mul q hq r hr
+  have hc : h.angleCorrection b p q - h.angleCorrection b p r = r - q := by
+    unfold angleCorrection
+    rw [he]
+    abel
+  rw [dist_eq_norm, hc, norm_sub_rev, ← dist_eq_norm] at hh
+  apply dist_eq_zero.mp
+  have hd := dist_nonneg (x := q) (y := r)
+  norm_num at hh
+  linarith
+
+end InitialData
+end Iteration
+end KamProject.Arnold1963
diff --git a/LeanPool/ArnoldKAM/Arnold1963/Tori/CrossChart.lean b/LeanPool/ArnoldKAM/Arnold1963/Tori/CrossChart.lean
new file mode 100644
index 0000000000..caa102fffa
--- /dev/null
+++ b/LeanPool/ArnoldKAM/Arnold1963/Tori/CrossChart.lean
@@ -0,0 +1,93 @@
+/-
+Copyright (c) 2026 Bingqi Yu. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Bingqi Yu
+-/
+
+module
+
+public import LeanPool.ArnoldKAM.Arnold1963.Main.GlobalCover
+public import LeanPool.ArnoldKAM.Arnold1963.Tori.OrbitClosure
+
+/-!
+Intersecting tori from different charts coincide by uniqueness of the original Hamiltonian
+trajectory and density of its orbit. The global family removes duplicate sets, retaining
+distinct branches that can have the same frequency.
+-/
+
+@[expose] public section
+noncomputable section
+open Set
+open scoped NNReal
+namespace KamProject.Arnold1963.FiniteLocalization
+variable {n : ℕ} {H₀ : ComplexSpace n → ℂ} {ambient : Set (ComplexSpace n)}
+  {ρ : ℝ≥0} {κ : ℝ} (L : FiniteLocalization n H₀ ambient ρ κ)
+  (f : AnalyticPhaseFunction n ambient ρ) (hf : f.uniformNorm ≤ L.threshold)
+
+theorem tori_eq_of_intersection (c d : L.patches) {p p' : RealSpace n}
+    (hp : p ∈ realSlice ((L.data f hf c).limitDomain (L.parameters c)))
+    (hp' : p' ∈ realSlice ((L.data f hf d).limitDomain (L.parameters d)))
+    {z : RealPhaseSpace n}
+    (hz : z ∈ (L.data f hf c).invariantTorus (L.parameters c) p)
+    (hz' : z ∈ (L.data f hf d).invariantTorus (L.parameters d) p') :
+    (L.data f hf c).invariantTorus (L.parameters c) p =
+      (L.data f hf d).invariantTorus (L.parameters d) p' := by
+  let h := L.data f hf c
+  let h' := L.data f hf d
+  let b := L.parameters c
+  let b' := L.parameters d
+  rw [← h.torusEmbedding_range b p] at hz
+  rw [← h'.torusEmbedding_range b' p'] at hz'
+  obtain ⟨Q, hQ⟩ := hz
+  obtain ⟨Q', hQ'⟩ := hz'
+  let x := torusRepresentative (p, Q)
+  let y := torusRepresentative (p', Q')
+  have he : torusProjection (h.realLimitMap b x) = torusProjection (h'.realLimitMap b' y) :=
+    hQ.trans hQ'.symm
+  obtain ⟨k, hk⟩ := (torusProjection_eq_iff _ _).mp he
+  have heR : h.realLimitMap b x = h'.realLimitMap b' (realPhaseShift k y) :=
+    hk.trans (h'.realLimitMap_shift b' (x := y) hp' k).symm
+  have he0 : h.orbit b p x.2 0 = h'.orbit b' p' (y.2 + realAngleShift k) 0 := by
+    rw [h.orbit_initial, h'.orbit_initial]
+    have hh := congrArg complexifyPhase heR
+    change complexifyPhase (realPartPhase (h.limitMap b (complexifyPhase x))) =
+      complexifyPhase (realPartPhase (h'.limitMap b' (complexifyPhase (realPhaseShift k y)))) at hh
+    rw [h.limitMap_real_value b hp, h'.limitMap_real_value b' hp'] at hh
+    exact hh
+  have heo : h.orbit b p x.2 = h'.orbit b' p' (y.2 + realAngleShift k) :=
+    eq_of_analytic_autonomous_orbits
+      (X := hamiltonianVectorField (fun w => H₀ w.1 + f.toFun w))
+      (fun t => h.vectorField_analytic b 0 _ (h.orbit_mem_initial b hp x.2 t))
+      (L.orbit_original f hf c hp x.2)
+      (L.orbit_original f hf d hp' (y.2 + realAngleShift k)) he0
+  rw [← h.projected_orbit_closure b hp x.2,
+    ← h'.projected_orbit_closure b' hp' (y.2 + realAngleShift k), heo]
+
+/-- The invariant torus sets realized by all retained labels in the finite patch collection. -/
+def tori : Set (Set (RealPhaseSpace n)) :=
+  {T | ∃ c : L.patches, ∃ p ∈ realSlice ((L.data f hf c).limitDomain (L.parameters c)),
+    T = (L.data f hf c).invariantTorus (L.parameters c) p}
+
+theorem tori_pairwise_disjoint : (L.tori f hf).Pairwise Disjoint := by
+  intro T hT U hU hne
+  obtain ⟨c, p, hp, rfl⟩ := hT
+  obtain ⟨d, p', hp', rfl⟩ := hU
+  apply disjoint_left.mpr
+  intro z hz hz'
+  exact hne (L.tori_eq_of_intersection f hf c d hp hp' hz hz')
+
+theorem goodSet_eq_sUnion_tori : L.goodSet f hf = ⋃₀ L.tori f hf := by
+  ext z
+  constructor
+  · intro hz
+    obtain ⟨c, hc⟩ := mem_iUnion.mp hz
+    rw [(L.data f hf c).localF1_eq_union (L.parameters c)] at hc
+    obtain ⟨p, hp, hzp⟩ := mem_iUnion₂.mp hc
+    exact mem_sUnion.mpr ⟨_, ⟨c, p, hp, rfl⟩, hzp⟩
+  · rintro ⟨T, ⟨c, p, hp, rfl⟩, hz⟩
+    apply mem_iUnion.mpr
+    refine ⟨c, ?_⟩
+    rw [(L.data f hf c).localF1_eq_union (L.parameters c)]
+    exact mem_iUnion₂.mpr ⟨p, hp, hz⟩
+
+end KamProject.Arnold1963.FiniteLocalization
diff --git a/LeanPool/ArnoldKAM/Arnold1963/Tori/Disjointness.lean b/LeanPool/ArnoldKAM/Arnold1963/Tori/Disjointness.lean
new file mode 100644
index 0000000000..a078bf9401
--- /dev/null
+++ b/LeanPool/ArnoldKAM/Arnold1963/Tori/Disjointness.lean
@@ -0,0 +1,140 @@
+/-
+Copyright (c) 2026 Bingqi Yu. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Bingqi Yu
+-/
+
+module
+
+public import LeanPool.ArnoldKAM.Arnold1963.Tori.FrequencyInjectivity
+public import LeanPool.ArnoldKAM.Arnold1963.Tori.AngleBounds
+public import LeanPool.ArnoldKAM.Arnold1963.Dynamics.OrbitUniqueness
+
+/-!
+Disjointness of invariant tori from ODE uniqueness, bounded angle corrections, and frequency
+injectivity within a single chart.
+-/
+
+@[expose] public section
+noncomputable section
+open Set
+open scoped NNReal
+namespace KamProject.Arnold1963
+
+theorem eq_zero_of_bounded_affine_line {E : Type*} [NormedAddCommGroup E]
+    [NormedSpace ℝ E] {u v : E} {C : ℝ}
+    (hb : ∀ t : ℝ, ‖u + t • v‖ ≤ C) : v = 0 := by
+  by_contra hv
+  have hn : 0 < ‖v‖ := norm_pos_iff.mpr hv
+  have hC : 0 ≤ C := (norm_nonneg _).trans (hb 0)
+  let t : ℝ := (C + ‖u‖ + 1) / ‖v‖
+  have ht : 0 ≤ t := by dsimp [t]; positivity
+  have hh := norm_sub_le (u + t • v) u
+  rw [add_sub_cancel_left, norm_smul, Real.norm_eq_abs, abs_of_nonneg ht] at hh
+  have he : t * ‖v‖ = C + ‖u‖ + 1 := div_mul_cancel₀ _ hn.ne'
+  rw [he] at hh
+  linarith [hb t]
+
+namespace Iteration.InitialData
+variable {n : ℕ} {Ω₀ : Set (ComplexSpace n)} {δ₁ θ₀ Θ₀ ρ₀ : ℝ≥0} {κ D : ℝ}
+  (b : InitialParameters n δ₁ θ₀ Θ₀ ρ₀ κ D)
+  (h : InitialData n Ω₀ δ₁ θ₀ Θ₀ ρ₀ D)
+
+theorem frequency_eq_of_orbit_eq {p p' : RealSpace n}
+    (hp : p ∈ realSlice (h.limitDomain b)) (hp' : p' ∈ realSlice (h.limitDomain b))
+    (q q' : RealSpace n) (he : h.orbit b p q = h.orbit b p' q') :
+    h.limitFrequency b (complexify p) = h.limitFrequency b (complexify p') := by
+  apply sub_eq_zero.mp
+  apply eq_zero_of_bounded_affine_line
+    (u := complexify q - complexify q') (C := 4 * (beta δ₁ 0 : ℝ))
+  intro t
+  let x : ComplexPhaseSpace n := (complexify p,
+    complexify q + (t : ℂ) • h.limitFrequency b (complexify p))
+  let y : ComplexPhaseSpace n := (complexify p',
+    complexify q' + (t : ℂ) • h.limitFrequency b (complexify p'))
+  have hx : x ∈ h.limitPhase b := by
+    rw [show x = complexifyPhase
+      (p, q + t • realPart (h.limitFrequency b (complexify p))) by
+        apply Prod.ext
+        · rfl
+        change complexify q + (t : ℂ) • h.limitFrequency b (complexify p) = _
+        rw [← h.limitFrequency_real_value b hp]
+        ext j
+        simp [complexifyPhase, complexify, smul_eq_mul]]
+    exact h.commonPhase_subset b ⟨hp, complexify_mem_angleStrip _ _⟩
+  have hy : y ∈ h.limitPhase b := by
+    rw [show y = complexifyPhase
+      (p', q' + t • realPart (h.limitFrequency b (complexify p'))) by
+        apply Prod.ext
+        · rfl
+        change complexify q' + (t : ℂ) • h.limitFrequency b (complexify p') = _
+        rw [← h.limitFrequency_real_value b hp']
+        ext j
+        simp [complexifyPhase, complexify, smul_eq_mul]]
+    exact h.commonPhase_subset b ⟨hp', complexify_mem_angleStrip _ _⟩
+  have hxy : h.limitMap b x = h.limitMap b y := congrFun he t
+  have ht := norm_sub_le_norm_sub_add_norm_sub x (h.limitMap b x) y
+  rw [norm_sub_rev x (h.limitMap b x), hxy] at ht
+  have hd : ‖x - y‖ < 4 * (beta δ₁ 0 : ℝ) := by
+    have hxB := h.limitMap_displacement b hx
+    have hyB := h.limitMap_displacement b hy
+    rw [hxy] at hxB
+    linarith
+  have ha := (norm_snd_le (x - y)).trans hd.le
+  have heq : complexify q - complexify q' +
+      t • (h.limitFrequency b (complexify p) - h.limitFrequency b (complexify p')) =
+      (x - y).2 := by
+    ext j
+    simp [x, y, Complex.real_smul]
+    ring
+  rw [heq]
+  exact ha
+
+theorem realLimitMap_injOn : InjOn (h.realLimitMap b)
+    (realSlice (h.limitDomain b) ×ˢ (univ : Set (RealSpace n))) := by
+  intro x hx y hy he
+  have hei : h.orbit b x.1 x.2 0 = h.orbit b y.1 y.2 0 := by
+    rw [h.orbit_initial, h.orbit_initial]
+    have hc := congrArg complexifyPhase he
+    change complexifyPhase (realPartPhase (h.limitMap b (complexifyPhase x))) =
+      complexifyPhase (realPartPhase (h.limitMap b (complexifyPhase y))) at hc
+    simpa only [h.limitMap_real_value b hx.1, h.limitMap_real_value b hy.1] using hc
+  have heo := h.orbit_eq_of_initial_eq b hx.1 hy.1 x.2 y.2 hei
+  have hep := h.limitFrequency_injOn b hx.1 hy.1
+    (h.frequency_eq_of_orbit_eq b hx.1 hy.1 x.2 y.2 heo)
+  have hp : x.1 = y.1 := (isometry_complexify n).injective hep
+  apply Prod.ext hp
+  apply (isometry_complexify n).injective
+  apply h.angleMap_injOn b hx.1 (complexify_mem_angleStrip _ _) (complexify_mem_angleStrip _ _)
+  have hh := congrArg Prod.snd hei
+  simpa only [h.orbit_initial, complexifyPhase, ← hp, angleMap] using hh
+
+theorem torusLimitMap_injOn : InjOn (h.torusLimitMap b)
+    (realSlice (h.limitDomain b) ×ˢ (univ : Set (RealTorus n))) := by
+  intro x hx y hy he
+  obtain ⟨k, hk⟩ := (torusProjection_eq_iff
+    (h.realLimitMap b (torusRepresentative x))
+    (h.realLimitMap b (torusRepresentative y))).mp he
+  rw [← h.realLimitMap_shift b (x := torusRepresentative y) hy.1 k] at hk
+  have hh := h.realLimitMap_injOn b ⟨hx.1, mem_univ _⟩ ⟨hy.1, mem_univ _⟩ hk
+  have hq := congrArg torusProjection hh
+  simpa only [torusProjection_shift, torusProjection_representative] using hq
+
+/-- The image of one retained action label and the full real angle torus. -/
+def invariantTorus (p : RealSpace n) : Set (RealPhaseSpace n) :=
+  h.torusLimitMap b '' ({p} ×ˢ (univ : Set (RealTorus n)))
+
+theorem invariantTorus_disjoint {p p' : RealSpace n}
+    (hp : p ∈ realSlice (h.limitDomain b)) (hp' : p' ∈ realSlice (h.limitDomain b))
+    (hne : p ≠ p') : Disjoint (h.invariantTorus b p) (h.invariantTorus b p') := by
+  apply disjoint_left.mpr
+  rintro z ⟨x, hx, hxz⟩ ⟨y, hy, hyz⟩
+  have hxp : x.1 = p := hx.1
+  have hyp : y.1 = p' := hy.1
+  have hh := h.torusLimitMap_injOn b
+    (x₁ := x) ⟨hxp ▸ hp, mem_univ _⟩ (x₂ := y) ⟨hyp ▸ hp', mem_univ _⟩
+    (hxz.trans hyz.symm)
+  exact hne (hxp.symm.trans ((congrArg Prod.fst hh).trans hyp))
+
+end Iteration.InitialData
+end KamProject.Arnold1963
diff --git a/LeanPool/ArnoldKAM/Arnold1963/Tori/Embedding.lean b/LeanPool/ArnoldKAM/Arnold1963/Tori/Embedding.lean
new file mode 100644
index 0000000000..78d742a62e
--- /dev/null
+++ b/LeanPool/ArnoldKAM/Arnold1963/Tori/Embedding.lean
@@ -0,0 +1,277 @@
+/-
+Copyright (c) 2026 Bingqi Yu. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Bingqi Yu
+-/
+
+module
+
+public import LeanPool.ArnoldKAM.Arnold1963.Tori.Disjointness
+public import LeanPool.ArnoldKAM.Arnold1963.Measure.LimitTorusVolume
+public import LeanPool.ArnoldKAM.Arnold1963.Geometry.GlobalInverse
+
+/-!
+Global real angle inverses, local complex analytic inverses, and closed torus embeddings.
+Analyticity concerns the complex angle lift for a fixed action label.
+-/
+
+@[expose] public section
+noncomputable section
+open Set Function Filter Metric Topology
+open scoped NNReal
+namespace KamProject.Arnold1963.Iteration.InitialData
+local instance : Fact (0 < 2 * Real.pi) := ⟨mul_pos (by norm_num) Real.pi_pos⟩
+variable {n : ℕ} {Ω₀ : Set (ComplexSpace n)} {δ₁ θ₀ Θ₀ ρ₀ : ℝ≥0} {κ D : ℝ}
+  (b : InitialParameters n δ₁ θ₀ Θ₀ ρ₀ κ D)
+  (h : InitialData n Ω₀ δ₁ θ₀ Θ₀ ρ₀ D)
+
+/-- The real angle component of the limiting phase transformation. -/
+def realAngleMap (p q : RealSpace n) : RealSpace n := (h.realLimitMap b (p, q)).2
+/-- The real-coordinate restriction of the limiting angle displacement. -/
+def realAngleCorrection (p : RealSpace n) : RealSpace n → RealSpace n :=
+  realRestriction (h.angleCorrection b (complexify p))
+
+theorem realAngleMap_eq (p q : RealSpace n) :
+    h.realAngleMap b p q = q + h.realAngleCorrection b p q := by
+  ext j
+  simp [realAngleMap, realAngleCorrection, realRestriction, angleCorrection, angleMap,
+    realLimitMap, realPartPhase, complexifyPhase, realPart, complexify]
+
+theorem realAngleCorrection_lipschitz {p : RealSpace n} (hp : p ∈ realSlice (h.limitDomain b)) :
+    LipschitzWith (1 / 2) (h.realAngleCorrection b p) := by
+  apply LipschitzWith.of_dist_le_mul
+  intro q r
+  have hh := (h.angleCorrection_lipschitz b hp).dist_le_mul
+    (complexify q) (complexify_mem_angleStrip _ _) (complexify r) (complexify_mem_angleStrip _ _)
+  rw [(isometry_complexify n).dist_eq] at hh
+  rw [dist_eq_norm] at hh ⊢
+  have he : h.realAngleCorrection b p q - h.realAngleCorrection b p r =
+      realPart (h.angleCorrection b (complexify p) (complexify q) -
+        h.angleCorrection b (complexify p) (complexify r)) := by
+    ext j; simp [realAngleCorrection, realRestriction, realPart]
+  rw [he]
+  exact (norm_realPart_le _).trans hh
+
+theorem realAngleCorrection_bound {p : RealSpace n} (hp : p ∈ realSlice (h.limitDomain b))
+    (q : RealSpace n) : ‖h.realAngleCorrection b p q‖ < 2 * (beta δ₁ 0 : ℝ) :=
+  (norm_realPart_le _).trans_lt (h.angleCorrection_bound b hp
+    (thinAngleStrip_subset b (complexify_mem_angleStrip _ _)))
+
+theorem realAngleMap_bijective {p : RealSpace n} (hp : p ∈ realSlice (h.limitDomain b)) :
+    Bijective (h.realAngleMap b p) := by
+  constructor
+  · intro q r he
+    have hh := (h.realAngleCorrection_lipschitz b hp).dist_le_mul q r
+    rw [h.realAngleMap_eq b, h.realAngleMap_eq b] at he
+    have hd : q - r = h.realAngleCorrection b p r - h.realAngleCorrection b p q := by
+      linear_combination he
+    rw [dist_eq_norm, norm_sub_rev (h.realAngleCorrection b p q)
+      (h.realAngleCorrection b p r), ← hd, ← dist_eq_norm] at hh
+    apply dist_eq_zero.mp
+    norm_num at hh
+    linarith [dist_nonneg (x := q) (y := r)]
+  · intro Q
+    obtain ⟨q, hq, _⟩ := existsUnique_add_eq_on_closedBall
+      (a := h.realAngleCorrection b p) (Q := Q) (r := 2 * beta δ₁ 0) (κ := 1 / 2)
+      ⟨by positivity, fun q _ => (h.realAngleCorrection_bound b hp q).le⟩
+      (by simp) (by norm_num) ((h.realAngleCorrection_lipschitz b hp).lipschitzOnWith)
+    exact ⟨q, (h.realAngleMap_eq b p q).trans hq.2⟩
+
+/-- A function inverse of the real limiting angle map at a fixed action label. -/
+def realAngleInverse (p : RealSpace n) : RealSpace n → RealSpace n :=
+  invFun (h.realAngleMap b p)
+
+theorem realAngleInverse_left {p : RealSpace n} (hp : p ∈ realSlice (h.limitDomain b))
+    (q : RealSpace n) : h.realAngleInverse b p (h.realAngleMap b p q) = q :=
+  Function.leftInverse_invFun (h.realAngleMap_bijective b hp).1 q
+
+theorem realAngleInverse_right {p : RealSpace n} (hp : p ∈ realSlice (h.limitDomain b))
+    (Q : RealSpace n) : h.realAngleMap b p (h.realAngleInverse b p Q) = Q :=
+  Function.rightInverse_invFun (h.realAngleMap_bijective b hp).2 Q
+
+/-- A set-restricted inverse of the limiting complex angle map on the narrower strip. -/
+def complexAngleInverse (p : ComplexSpace n) : ComplexSpace n → ComplexSpace n :=
+  invFunOn (h.angleMap b p) (angleStrip n (ρ₀ / 6))
+
+theorem angleMap_derivative_near_id {p : ComplexSpace n} (hp : p ∈ h.limitDomain b)
+    {q : ComplexSpace n} (hq : q ∈ angleStrip n (ρ₀ / 6)) :
+    ‖fderiv ℂ (h.angleMap b p) q - ContinuousLinearMap.id ℂ _‖ < 1 / 2 := by
+  have ha := analyticAt_snd.comp
+    (h.limitMap_angle_analytic b hp q (thinAngleStrip_subset b hq))
+  have he : fderiv ℂ (h.angleCorrection b p) q =
+      fderiv ℂ (h.angleMap b p) q - ContinuousLinearMap.id ℂ _ := by
+    exact (ha.differentiableAt.hasFDerivAt.sub (hasFDerivAt_id q)).fderiv
+  rw [← he]
+  exact h.angleCorrection_derivative b hp hq
+
+theorem complexAngleInverse_analytic {p : ComplexSpace n} (hp : p ∈ h.limitDomain b)
+    (q : RealSpace n) :
+    AnalyticAt ℂ (h.complexAngleInverse b p) (h.angleMap b p (complexify q)) ∧
+    h.complexAngleInverse b p (h.angleMap b p (complexify q)) = complexify q ∧
+    (∀ᶠ Q in 𝓝 (h.angleMap b p (complexify q)),
+      h.angleMap b p (h.complexAngleInverse b p Q) = Q) := by
+  have hD : angleStrip n (ρ₀ / 6) ∈ 𝓝 (complexify q) := by
+    have hc : Continuous (fun z : ComplexSpace n => ‖imagPart z‖) := by
+      unfold imagPart; fun_prop
+    have hh : ‖imagPart (complexify q)‖ < ((ρ₀ / 6 : ℝ≥0) : ℝ) := by
+      simp only [imagPart_complexify, norm_zero, NNReal.coe_div, NNReal.coe_ofNat]
+      exact div_pos b.width_pos (by norm_num)
+    exact mem_of_superset ((isOpen_lt hc continuous_const).mem_nhds hh)
+      (fun z (hz : ‖imagPart z‖ < ((ρ₀ / 6 : ℝ≥0) : ℝ)) => hz.le)
+  exact analytic_invFunOn (h.angleMap_injOn b hp) hD
+    (analyticAt_snd.comp (h.limitMap_angle_analytic b hp _
+      (thinAngleStrip_subset b (complexify_mem_angleStrip _ _))))
+    ((h.angleMap_derivative_near_id b hp (complexify_mem_angleStrip _ _)).trans (by norm_num))
+
+theorem angleMap_derivative_injective {p : ComplexSpace n} (hp : p ∈ h.limitDomain b)
+    {q : ComplexSpace n} (hq : q ∈ angleStrip n (ρ₀ / 6)) :
+    Injective (fderiv ℂ (h.angleMap b p) q) := by
+  have hn := h.angleMap_derivative_near_id b hp hq
+  have hu := isUnit_one_sub_of_norm_lt_one
+    (show ‖-(fderiv ℂ (h.angleMap b p) q - ContinuousLinearMap.id ℂ _)‖ < 1 by
+      simpa only [norm_neg] using hn.trans (by norm_num : (1 / 2 : ℝ) < 1))
+  have he : (1 : ComplexSpace n →L[ℂ] ComplexSpace n) -
+      -(fderiv ℂ (h.angleMap b p) q - 1) = fderiv ℂ (h.angleMap b p) q := by abel
+  change IsUnit (1 - -(fderiv ℂ (h.angleMap b p) q - 1)) at hu
+  rw [he] at hu
+  obtain ⟨u, hu⟩ := hu
+  rw [← hu]
+  exact (ContinuousLinearEquiv.ofUnit u).injective
+
+/-- The limiting phase map at a fixed real action label, regarded as a torus embedding. -/
+def torusEmbedding (p : RealSpace n) (Q : RealTorus n) : RealPhaseSpace n :=
+  h.torusLimitMap b (p, Q)
+
+theorem torusEmbedding_lift {p : RealSpace n} (hp : p ∈ realSlice (h.limitDomain b))
+    (q : RealSpace n) :
+    h.torusEmbedding b p (fun j => (q j : AddCircle (2 * Real.pi))) =
+      torusProjection (realPartPhase (h.limitMap b (complexify p, complexify q))) :=
+  h.torusLimitMap_projection b (x := (p, q)) hp
+
+theorem torusEmbedding_range (p : RealSpace n) :
+    range (h.torusEmbedding b p) = h.invariantTorus b p := by
+  ext z
+  constructor
+  · rintro ⟨q, rfl⟩
+    exact ⟨(p, q), ⟨rfl, mem_univ _⟩, rfl⟩
+  · rintro ⟨⟨p', q⟩, ⟨hp, _⟩, rfl⟩
+    change p' = p at hp
+    subst p'
+    exact ⟨q, rfl⟩
+
+theorem torusEmbedding_continuous {p : RealSpace n} (hp : p ∈ realSlice (h.limitDomain b)) :
+    Continuous (h.torusEmbedding b p) := by
+  let π : RealSpace n → RealTorus n := fun q j => (q j : AddCircle (2 * Real.pi))
+  have hπ : IsQuotientMap π :=
+    (IsOpenQuotientMap.piMap fun _ : Fin n =>
+      (QuotientAddGroup.isOpenQuotientMap_mk : IsOpenQuotientMap
+        (fun t : ℝ => (t : AddCircle (2 * Real.pi))))).isQuotientMap
+  apply hπ.continuous_iff.mpr
+  have he : h.torusEmbedding b p ∘ π =
+      fun q => torusProjection (h.realLimitMap b (p, q)) := by
+    funext q
+    exact h.torusLimitMap_projection b (x := (p, q)) hp
+  rw [he]
+  exact continuous_torusProjection.comp
+    ((h.realLimitMap_continuous b).comp_continuous (continuous_const.prodMk continuous_id)
+      (fun _ => ⟨hp, mem_univ _⟩))
+
+theorem torusEmbedding_isClosedEmbedding {p : RealSpace n}
+    (hp : p ∈ realSlice (h.limitDomain b)) : IsClosedEmbedding (h.torusEmbedding b p) := by
+  apply (h.torusEmbedding_continuous b hp).isClosedEmbedding
+  intro Q R he
+  exact congrArg Prod.snd (h.torusLimitMap_injOn b ⟨hp, mem_univ Q⟩ ⟨hp, mem_univ R⟩ he)
+
+theorem angleMap_real_value {p : RealSpace n} (hp : p ∈ realSlice (h.limitDomain b))
+    (q : RealSpace n) : complexify (h.realAngleMap b p q) =
+      h.angleMap b (complexify p) (complexify q) :=
+  congrArg Prod.snd (h.limitMap_real_value b (x := (p, q)) hp)
+
+theorem complexAngleInverse_real_value {p : RealSpace n}
+    (hp : p ∈ realSlice (h.limitDomain b)) (Q : RealSpace n) :
+    h.complexAngleInverse b (complexify p) (complexify Q) =
+      complexify (h.realAngleInverse b p Q) := by
+  have he := h.angleMap_real_value b hp (h.realAngleInverse b p Q)
+  rw [h.realAngleInverse_right b hp] at he
+  rw [he]
+  exact (h.complexAngleInverse_analytic b hp _).2.1
+
+theorem complexAngleInverse_analytic_at_real {p : RealSpace n}
+    (hp : p ∈ realSlice (h.limitDomain b)) (Q : RealSpace n) :
+    AnalyticAt ℂ (h.complexAngleInverse b (complexify p)) (complexify Q) := by
+  have he := h.angleMap_real_value b hp (h.realAngleInverse b p Q)
+  rw [h.realAngleInverse_right b hp] at he
+  rw [he]
+  exact (h.complexAngleInverse_analytic b hp _).1
+
+theorem torusLift_derivative_injective {p : ComplexSpace n} (hp : p ∈ h.limitDomain b)
+    {q : ComplexSpace n} (hq : q ∈ angleStrip n (ρ₀ / 6)) :
+    Injective (fderiv ℂ (fun q => h.limitMap b (p, q)) q) := by
+  have ha := (h.limitMap_angle_analytic b hp q (thinAngleStrip_subset b hq)).differentiableAt
+  have hd := ((ContinuousLinearMap.snd ℂ (ComplexSpace n) (ComplexSpace n)).hasFDerivAt.comp q
+    ha.hasFDerivAt).fderiv
+  intro v w he
+  apply h.angleMap_derivative_injective b hp hq
+  change fderiv ℂ (h.angleMap b p) q = _ at hd
+  rw [hd]
+  exact congrArg Prod.snd he
+
+/-- The angle component of the embedded torus, with angles reduced modulo `2π`. -/
+def torusAngleMap (p : RealSpace n) (Q : RealTorus n) : RealTorus n :=
+  (h.torusEmbedding b p Q).2
+
+theorem torusAngleMap_projection {p : RealSpace n} (hp : p ∈ realSlice (h.limitDomain b))
+    (q : RealSpace n) :
+    h.torusAngleMap b p (fun j => (q j : AddCircle (2 * Real.pi))) =
+      fun j => (h.realAngleMap b p q j : AddCircle (2 * Real.pi)) :=
+  congrArg Prod.snd (h.torusLimitMap_projection b (x := (p, q)) hp)
+
+theorem torusAngleMap_bijective {p : RealSpace n} (hp : p ∈ realSlice (h.limitDomain b)) :
+    Bijective (h.torusAngleMap b p) := by
+  constructor
+  · intro Q R he
+    let q := (torusRepresentative (p, Q)).2
+    let r := (torusRepresentative (p, R)).2
+    have hq : (fun j => (q j : AddCircle (2 * Real.pi))) = Q :=
+      congrArg Prod.snd (torusProjection_representative (p, Q))
+    have hr : (fun j => (r j : AddCircle (2 * Real.pi))) = R :=
+      congrArg Prod.snd (torusProjection_representative (p, R))
+    have ht : torusProjection ((0 : RealSpace n), h.realAngleMap b p q) =
+        torusProjection (0, h.realAngleMap b p r) := by
+      apply Prod.ext
+      · rfl
+      change (fun j => (h.realAngleMap b p q j : AddCircle (2 * Real.pi))) =
+        fun j => (h.realAngleMap b p r j : AddCircle (2 * Real.pi))
+      rw [← h.torusAngleMap_projection b hp q, ← h.torusAngleMap_projection b hp r, hq, hr]
+      exact he
+    obtain ⟨k, hk⟩ := (torusProjection_eq_iff _ _).mp ht
+    have hs := congrArg Prod.snd (h.realLimitMap_shift b (x := (p, r)) hp k)
+    have hqr : q = r + realAngleShift k := (h.realAngleMap_bijective b hp).1
+      ((congrArg Prod.snd hk).trans hs.symm)
+    rw [← hq, ← hr, hqr]
+    exact congrArg Prod.snd (torusProjection_shift k (p, r))
+  · intro Q
+    let q := (torusRepresentative (p, Q)).2
+    obtain ⟨r, hr⟩ := (h.realAngleMap_bijective b hp).2 q
+    refine ⟨fun j => (r j : AddCircle (2 * Real.pi)), ?_⟩
+    rw [h.torusAngleMap_projection b hp r, hr]
+    exact congrArg Prod.snd (torusProjection_representative (p, Q))
+
+/-- The homeomorphism of the real angle torus induced by a retained action label. -/
+def torusAngleHomeomorph {p : RealSpace n} (hp : p ∈ realSlice (h.limitDomain b)) :
+    RealTorus n ≃ₜ RealTorus n :=
+  (Equiv.ofBijective _ (h.torusAngleMap_bijective b hp)).toHomeomorphOfContinuousClosed
+    (h.torusEmbedding_continuous b hp).snd
+    (h.torusEmbedding_continuous b hp).snd.isClosedMap
+
+theorem torusAngleHomeomorph_inverse_lift {p : RealSpace n}
+    (hp : p ∈ realSlice (h.limitDomain b)) (Q : RealSpace n) :
+    (h.torusAngleHomeomorph b hp).symm (fun j => (Q j : AddCircle (2 * Real.pi))) =
+      fun j => (h.realAngleInverse b p Q j : AddCircle (2 * Real.pi)) := by
+  apply (h.torusAngleHomeomorph b hp).injective
+  rw [Homeomorph.apply_symm_apply]
+  change (fun j => (Q j : AddCircle (2 * Real.pi))) =
+    h.torusAngleMap b p (fun j => (h.realAngleInverse b p Q j : AddCircle (2 * Real.pi)))
+  rw [h.torusAngleMap_projection b hp, h.realAngleInverse_right b hp]
+
+end KamProject.Arnold1963.Iteration.InitialData
diff --git a/LeanPool/ArnoldKAM/Arnold1963/Tori/FrequencyInjectivity.lean b/LeanPool/ArnoldKAM/Arnold1963/Tori/FrequencyInjectivity.lean
new file mode 100644
index 0000000000..00bfd92902
--- /dev/null
+++ b/LeanPool/ArnoldKAM/Arnold1963/Tori/FrequencyInjectivity.lean
@@ -0,0 +1,129 @@
+/-
+Copyright (c) 2026 Bingqi Yu. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Bingqi Yu
+-/
+
+module
+
+public import LeanPool.ArnoldKAM.Arnold1963.Convergence.Nonresonance
+public import LeanPool.ArnoldKAM.Arnold1963.Analysis.MeanValue
+
+/-!
+Injectivity of limit frequency labels. Inverse mean-value estimates are taken on contained
+frequency balls, without assuming convexity of the limiting action domain.
+-/
+
+@[expose] public section
+noncomputable section
+open Set Filter Metric
+open scoped NNReal Topology
+namespace KamProject.Arnold1963.Iteration.InitialData
+variable {n : ℕ} {Ω₀ : Set (ComplexSpace n)} {δ₁ θ₀ Θ₀ ρ₀ : ℝ≥0} {κ D : ℝ}
+  (b : InitialParameters n δ₁ θ₀ Θ₀ ρ₀ κ D)
+  (h : InitialData n Ω₀ δ₁ θ₀ Θ₀ ρ₀ D)
+
+@[simp] theorem frequencyDomain_zero : h.frequencyDomain b 0 = Ω₀ := by
+  exact ResonanceDomainState.initial_domain n (κ * (δ₁ : ℝ)) Ω₀
+
+theorem limitFrequency_ball_subset {p : ComplexSpace n} (hp : p ∈ h.limitDomain b)
+    (s : ℕ) : closedBall (h.limitFrequency b p) (beta δ₁ s : ℝ) ⊆
+      h.frequencyDomain b s := by
+  have hm := h.limitFrequency_mem b hp (s + 1)
+  rw [h.frequencyDomain_succ b] at hm
+  intro y hy
+  apply (hm (show y ∈ closedBall (h.limitFrequency b p)
+      (((5 + 7 * Iteration.upper Θ₀ δ₁ s) * beta δ₁ s : ℝ≥0) : ℝ) from ?_)).1
+  rw [mem_closedBall] at hy ⊢
+  apply hy.trans
+  simp only [NNReal.coe_mul, NNReal.coe_add, NNReal.coe_ofNat]
+  have hu := (Iteration.upper Θ₀ δ₁ s).coe_nonneg
+  have hb := (beta δ₁ s).coe_nonneg
+  nlinarith
+
+private theorem inverse_frequency_ball_bound {p : ComplexSpace n}
+    (hp : p ∈ h.limitDomain b) (s : ℕ) {x y : ComplexSpace n}
+    (hx : x ∈ closedBall (h.limitFrequency b p) (beta δ₁ s : ℝ))
+    (hy : y ∈ closedBall (h.limitFrequency b p) (beta δ₁ s : ℝ)) :
+    ‖(h.state b s).inverseFrequency y - (h.state b s).inverseFrequency x‖ ≤
+      ((θ₀ : ℝ) / 2)⁻¹ * ‖y - x‖ := by
+  exact norm_sub_le_of_analytic_segment_bound
+    (((convex_closedBall _ _).segment_subset hx hy).trans (h.limitFrequency_ball_subset b hp s))
+    (h.state b s).input.chart.inverse_analytic
+    ⟨by positivity, fun z hz => (h.state b s).input.chart.inverse_derivative_le
+      (by exact div_pos b.lower_pos (by norm_num))
+      (fun q hq v => (h.frequency_bounds b s hq v).1) hz⟩
+
+theorem limitFrequency_injOn : InjOn (h.limitFrequency b) (h.limitDomain b) := by
+  intro p hp q hq he
+  have hb : ∀ s, ‖q - p‖ ≤ ((θ₀ : ℝ) / 2)⁻¹ * (beta δ₁ s : ℝ) := by
+    intro s
+    have hps := h.limitFrequency_tail b hp s
+    have hqs := h.limitFrequency_tail b hq s
+    have hpc : h.frequency b s p ∈ closedBall (h.limitFrequency b p) (beta δ₁ s : ℝ) := by
+      rw [mem_closedBall, dist_eq_norm, norm_sub_rev]
+      linarith [(beta δ₁ s).coe_nonneg]
+    have hqc : h.frequency b s q ∈ closedBall (h.limitFrequency b p) (beta δ₁ s : ℝ) := by
+      rw [he, mem_closedBall, dist_eq_norm, norm_sub_rev]
+      linarith [(beta δ₁ s).coe_nonneg]
+    have hi := h.inverse_frequency_ball_bound b hp s hpc hqc
+    have hleftp := (h.state b s).input.chart.left (h.limit_subset b s hp)
+    have hleftq := (h.state b s).input.chart.left (h.limit_subset b s hq)
+    change (h.state b s).inverseFrequency (h.frequency b s p) = p at hleftp
+    change (h.state b s).inverseFrequency (h.frequency b s q) = q at hleftq
+    rw [hleftp, hleftq] at hi
+    apply hi.trans (mul_le_mul_of_nonneg_left ?_ (by positivity))
+    have ht := norm_sub_le_norm_sub_add_norm_sub
+      (h.frequency b s q) (h.limitFrequency b p) (h.frequency b s p)
+    rw [he, norm_sub_rev (h.frequency b s q) (h.limitFrequency b q)] at ht
+    rw [he] at hps
+    linarith
+  have hz : ‖q - p‖ ≤ 0 := ge_of_tendsto
+    (by simpa using b.beta_summable.tendsto_atTop_zero.const_mul (((θ₀ : ℝ) / 2)⁻¹))
+    (Eventually.of_forall hb)
+  exact (sub_eq_zero.mp (norm_eq_zero.mp (le_antisymm hz (norm_nonneg _)))).symm
+
+/-- The image of the limiting action domain under the limiting frequency map. -/
+def retainedFrequencies : Set (ComplexSpace n) := h.limitFrequency b '' h.limitDomain b
+
+/-- A set-restricted inverse assigning action labels to retained limiting frequencies. -/
+def frequencyLabel : ComplexSpace n → ComplexSpace n :=
+  Function.invFunOn (h.limitFrequency b) (h.limitDomain b)
+
+theorem frequencyLabel_left {p : ComplexSpace n} (hp : p ∈ h.limitDomain b) :
+    h.frequencyLabel b (h.limitFrequency b p) = p :=
+  (h.limitFrequency_injOn b).leftInvOn_invFunOn hp
+
+theorem frequencyLabel_mem {ω : ComplexSpace n} (hω : ω ∈ h.retainedFrequencies b) :
+    h.frequencyLabel b ω ∈ h.limitDomain b := (Function.invFunOn_pos hω).1
+
+theorem frequencyLabel_right {ω : ComplexSpace n} (hω : ω ∈ h.retainedFrequencies b) :
+    h.limitFrequency b (h.frequencyLabel b ω) = ω := (Function.invFunOn_pos hω).2
+
+/-- The original action center corresponding to a frequency through the initial inverse chart. -/
+def unperturbedCenter (ω : ComplexSpace n) : ComplexSpace n := h.inverseFrequency ω
+
+theorem unperturbedCenter_mem {p : ComplexSpace n} (hp : p ∈ h.limitDomain b) :
+    h.unperturbedCenter (h.limitFrequency b p) ∈ h.domain :=
+  h.chart.inverse_maps (by simpa using h.limitFrequency_mem b hp 0)
+
+theorem unperturbedCenter_displacement {p : ComplexSpace n} (hp : p ∈ h.limitDomain b) :
+    ‖h.unperturbedCenter (h.limitFrequency b p) - p‖ <
+      (θ₀ : ℝ)⁻¹ * ((beta δ₁ 0 : ℝ) / 2) := by
+  have hp0 : p ∈ h.domain := h.limit_subset b 0 hp
+  have ht := h.limitFrequency_tail b hp 0
+  have hc : h.frequency b 0 p ∈ closedBall (h.limitFrequency b p) (beta δ₁ 0 : ℝ) := by
+    rw [mem_closedBall, dist_eq_norm, norm_sub_rev]
+    linarith [(beta δ₁ 0).coe_nonneg]
+  have hm := norm_sub_le_of_analytic_segment_bound
+    (((convex_closedBall _ _).segment_subset hc (mem_closedBall_self (beta δ₁ 0).coe_nonneg)).trans
+      (show closedBall (h.limitFrequency b p) (beta δ₁ 0 : ℝ) ⊆ Ω₀ by
+        simpa using h.limitFrequency_ball_subset b hp 0))
+    h.chart.inverse_analytic
+    ⟨inv_nonneg.mpr θ₀.coe_nonneg, fun z hz => h.chart.inverse_derivative_le b.lower_pos h.lower hz⟩
+  change ‖h.inverseFrequency (h.limitFrequency b p) -
+    h.inverseFrequency (actionFrequency h.integrable p)‖ ≤ _ at hm
+  rw [h.chart.left hp0] at hm
+  exact hm.trans_lt (mul_lt_mul_of_pos_left ht (inv_pos.mpr b.lower_pos))
+
+end KamProject.Arnold1963.Iteration.InitialData
diff --git a/LeanPool/ArnoldKAM/Arnold1963/Tori/OrbitClosure.lean b/LeanPool/ArnoldKAM/Arnold1963/Tori/OrbitClosure.lean
new file mode 100644
index 0000000000..ffe992eca6
--- /dev/null
+++ b/LeanPool/ArnoldKAM/Arnold1963/Tori/OrbitClosure.lean
@@ -0,0 +1,50 @@
+/-
+Copyright (c) 2026 Bingqi Yu. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Bingqi Yu
+-/
+
+module
+
+public import LeanPool.ArnoldKAM.Arnold1963.Tori.Embedding
+public import LeanPool.ArnoldKAM.Arnold1963.Dynamics.TorusDensity
+
+/-!
+The projected orbit closure equals the invariant torus, using nonresonant flow density.
+-/
+
+@[expose] public section
+noncomputable section
+open Set
+open scoped NNReal
+namespace KamProject.Arnold1963.Iteration.InitialData
+local instance : Fact (0 < 2 * Real.pi) := ⟨mul_pos (by norm_num) Real.pi_pos⟩
+variable {n : ℕ} {Ω₀ : Set (ComplexSpace n)} {δ₁ θ₀ Θ₀ ρ₀ : ℝ≥0} {κ D : ℝ}
+  (b : InitialParameters n δ₁ θ₀ Θ₀ ρ₀ κ D)
+  (h : InitialData n Ω₀ δ₁ θ₀ Θ₀ ρ₀ D)
+
+theorem projected_orbit_closure {p : RealSpace n}
+    (hp : p ∈ realSlice (h.limitDomain b)) (q : RealSpace n) :
+    closure (range (fun t : ℝ => torusProjection (realPartPhase (h.orbit b p q t)))) =
+      h.invariantTorus b p := by
+  let v := realPart (h.limitFrequency b (complexify p))
+  have hnr : ∀ k : FourierIndex n, k ≠ 0 → ∑ j, (k j : ℝ) * v j ≠ 0 := by
+    intro k hk he
+    apply h.limitFrequency_no_integer_relation b hp k hk
+    rw [← h.limitFrequency_real_value b hp]
+    change (∑ j, (k j : ℂ) * ((v j : ℝ) : ℂ)) = 0
+    exact_mod_cast he
+  have hd := denseRange_realTorusLine v q hnr
+  have hc := h.torusEmbedding_continuous b hp
+  have he : (fun t : ℝ => torusProjection (realPartPhase (h.orbit b p q t))) =
+      h.torusEmbedding b p ∘ realTorusLine v q := by
+    funext t
+    rw [h.orbit_eq_real_angle b hp q t]
+    exact (h.torusEmbedding_lift b hp (q + t • v)).symm
+  rw [he, ← h.torusEmbedding_range b p, range_comp]
+  apply Subset.antisymm
+  · exact closure_minimal (image_subset_range _ _) (isCompact_range hc).isClosed
+  · rintro z ⟨Q, rfl⟩
+    exact image_closure_subset_closure_image hc ⟨Q, hd Q, rfl⟩
+
+end KamProject.Arnold1963.Iteration.InitialData
diff --git a/LeanPool/ArnoldKAM/Arnold1963/Tori/Parameterization.lean b/LeanPool/ArnoldKAM/Arnold1963/Tori/Parameterization.lean
new file mode 100644
index 0000000000..b4b731c5c9
--- /dev/null
+++ b/LeanPool/ArnoldKAM/Arnold1963/Tori/Parameterization.lean
@@ -0,0 +1,142 @@
+/-
+Copyright (c) 2026 Bingqi Yu. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Bingqi Yu
+-/
+
+module
+
+public import LeanPool.ArnoldKAM.Arnold1963.Tori.FrequencyInjectivity
+public import LeanPool.ArnoldKAM.Arnold1963.Tori.AngleBounds
+public import LeanPool.ArnoldKAM.Arnold1963.Dynamics.RealOrbits
+
+/-!
+Frequency relabeling of the same limit transformation. The unperturbed center is selected
+through the original inverse frequency chart; action and angle corrections retain their bounds.
+-/
+
+@[expose] public section
+noncomputable section
+open Set
+open scoped NNReal
+namespace KamProject.Arnold1963.Iteration
+
+namespace InitialParameters
+variable {n : ℕ} {δ₁ θ₀ Θ₀ ρ₀ : ℝ≥0} {κ D : ℝ}
+  (b : InitialParameters n δ₁ θ₀ Θ₀ ρ₀ κ D)
+include b
+theorem torus_displacement_budget :
+    (beta δ₁ 0 : ℝ) * (2 + (θ₀ : ℝ)⁻¹) < κ := by
+  have ht := (threshold5_bounds b.small).2.2.2
+  change (δ₁ : ℝ) < κ / (2 + (θ₀ : ℝ)⁻¹) at ht
+  have hc : 0 < 2 + (θ₀ : ℝ)⁻¹ := by positivity
+  have hm := (lt_div_iff₀ hc).mp ht
+  have hb : (beta δ₁ 0 : ℝ) ≤ δ₁ := by
+    simp only [beta, delta, decay_zero, NNReal.coe_pow]
+    exact pow_le_of_le_one δ₁.coe_nonneg (show (δ₁ : ℝ) ≤ 1 from b.delta_one.le)
+      (by norm_num : 3 ≠ 0)
+  exact (mul_le_mul_of_nonneg_right hb hc.le).trans_lt hm
+end InitialParameters
+
+namespace InitialData
+variable {n : ℕ} {Ω₀ : Set (ComplexSpace n)} {δ₁ θ₀ Θ₀ ρ₀ : ℝ≥0} {κ D : ℝ}
+  (b : InitialParameters n δ₁ θ₀ Θ₀ ρ₀ κ D)
+  (h : InitialData n Ω₀ δ₁ θ₀ Θ₀ ρ₀ D)
+
+/-- The limiting action displacement from the corresponding original action center. -/
+def actionCorrection (p q : ComplexSpace n) : ComplexSpace n :=
+  (h.limitMap b (p, q)).1 - h.unperturbedCenter (h.limitFrequency b p)
+
+theorem parameterization_eq (p q : ComplexSpace n) :
+    h.limitMap b (p, q) =
+      (h.unperturbedCenter (h.limitFrequency b p) + h.actionCorrection b p q,
+        q + h.angleCorrection b p q) := by
+  simp [actionCorrection, angleCorrection, angleMap]
+
+theorem actionCorrection_analytic {p : ComplexSpace n} (hp : p ∈ h.limitDomain b) :
+    AnalyticOnNhd ℂ (h.actionCorrection b p) (commonAngleStrip n ρ₀) := by
+  intro q hq
+  exact (analyticAt_fst.comp (h.limitMap_angle_analytic b hp q hq)).sub analyticAt_const
+
+theorem torusCorrections_small {p : ComplexSpace n} (hp : p ∈ h.limitDomain b)
+    {q : ComplexSpace n} (hq : q ∈ commonAngleStrip n ρ₀) :
+    ‖h.actionCorrection b p q‖ < κ ∧ ‖h.angleCorrection b p q‖ < κ := by
+  have hd := h.limitMap_displacement b (h.angle_mem_limitPhase b hp hq)
+  have hf := (norm_fst_le (h.limitMap b (p, q) - (p, q))).trans_lt hd
+  change ‖(h.limitMap b (p, q)).1 - p‖ < 2 * (beta δ₁ 0 : ℝ) at hf
+  have hc := h.unperturbedCenter_displacement b hp
+  have ht := norm_sub_le_norm_sub_add_norm_sub (h.limitMap b (p, q)).1 p
+    (h.unperturbedCenter (h.limitFrequency b p))
+  rw [norm_sub_rev p (h.unperturbedCenter (h.limitFrequency b p))] at ht
+  have hi : 0 ≤ (θ₀ : ℝ)⁻¹ := inv_nonneg.mpr θ₀.coe_nonneg
+  have hb := (beta δ₁ 0).coe_nonneg
+  have hbudget := b.torus_displacement_budget
+  constructor
+  · change ‖(h.limitMap b (p, q)).1 - h.unperturbedCenter (h.limitFrequency b p)‖ < κ
+    nlinarith
+  · have hqB := h.angleCorrection_bound b hp hq
+    nlinarith
+
+theorem torusCorrections_periodic {p : ComplexSpace n} (hp : p ∈ h.limitDomain b)
+    {q : ComplexSpace n} (hq : q ∈ commonAngleStrip n ρ₀) (k : FourierIndex n) :
+    h.actionCorrection b p (q + angleShift k) = h.actionCorrection b p q ∧
+    h.angleCorrection b p (q + angleShift k) = h.angleCorrection b p q := by
+  have he := h.limitMap_periodic b (h.angle_mem_limitPhase b hp hq) k
+  change h.limitMap b (p, q + angleShift k) = phaseShift k (h.limitMap b (p, q)) at he
+  constructor
+  · simp only [actionCorrection, he, phaseShift]
+  · simp only [angleCorrection, angleMap, he, phaseShift]
+    abel
+
+/-- The limiting frequencies corresponding to retained real action labels. -/
+def retainedRealFrequencies : Set (ComplexSpace n) :=
+  h.limitFrequency b '' (complexify '' realSlice (h.limitDomain b))
+
+/-- The real action label associated with a retained limiting frequency. -/
+def realFrequencyLabel (ω : ComplexSpace n) : RealSpace n := realPart (h.frequencyLabel b ω)
+
+theorem realFrequencyLabel_spec {ω : ComplexSpace n} (hω : ω ∈ h.retainedRealFrequencies b) :
+    h.realFrequencyLabel b ω ∈ realSlice (h.limitDomain b) ∧
+      h.limitFrequency b (complexify (h.realFrequencyLabel b ω)) = ω ∧
+      complexify (h.realFrequencyLabel b ω) = h.frequencyLabel b ω := by
+  rcases hω with ⟨_, ⟨p, hp, rfl⟩, rfl⟩
+  have he : h.realFrequencyLabel b (h.limitFrequency b (complexify p)) = p := by
+    simp only [realFrequencyLabel, h.frequencyLabel_left b hp, realPart_complexify]
+  rw [he]
+  exact ⟨hp, rfl, (h.frequencyLabel_left b hp).symm⟩
+
+theorem retainedRealFrequency_real {ω : ComplexSpace n}
+    (hω : ω ∈ h.retainedRealFrequencies b) : complexify (realPart ω) = ω := by
+  have hs := h.realFrequencyLabel_spec b hω
+  simpa only [hs.2.1] using h.limitFrequency_real_value b hs.1
+
+theorem retainedRealFrequencies_nonempty : (h.retainedRealFrequencies b).Nonempty := by
+  obtain ⟨p, hp⟩ := h.limit_realSlice_nonempty b
+  exact ⟨h.limitFrequency b (complexify p), complexify p, ⟨p, hp, rfl⟩, rfl⟩
+
+theorem unperturbedCenter_real {p : RealSpace n} (hp : p ∈ realSlice (h.limitDomain b)) :
+    complexify (realPart (h.unperturbedCenter (h.limitFrequency b (complexify p)))) =
+      h.unperturbedCenter (h.limitFrequency b (complexify p)) := by
+  apply complexify_realPart_of_conj
+  have hc := h.chart.inverse_conj (by simpa using h.limitFrequency_mem b hp 0)
+  have hf : conjVec (h.limitFrequency b (complexify p)) =
+      h.limitFrequency b (complexify p) := by
+    simpa only [conjVec_complexify] using (h.limitFrequency_real b hp).symm
+  rw [hf] at hc
+  exact hc.symm
+
+/-- The limiting torus lift expressed in frequency coordinates rather than action labels. -/
+def frequencyParameterization (ω q : ComplexSpace n) : ComplexPhaseSpace n :=
+  h.limitMap b (h.frequencyLabel b ω, q)
+
+theorem frequencyParameterization_eq {ω : ComplexSpace n}
+    (hω : ω ∈ h.retainedRealFrequencies b) (q : ComplexSpace n) :
+    h.frequencyParameterization b ω q =
+      (h.unperturbedCenter ω + h.actionCorrection b (h.frequencyLabel b ω) q,
+        q + h.angleCorrection b (h.frequencyLabel b ω) q) := by
+  have hs := h.realFrequencyLabel_spec b hω
+  have hω' : h.limitFrequency b (h.frequencyLabel b ω) = ω := hs.2.2 ▸ hs.2.1
+  simpa only [frequencyParameterization, hω'] using h.parameterization_eq b (h.frequencyLabel b ω) q
+
+end InitialData
+end KamProject.Arnold1963.Iteration
diff --git a/LeanPool/ArnoldKAM/Imports.lean b/LeanPool/ArnoldKAM/Imports.lean
new file mode 100644
index 0000000000..526bc6fb0f
--- /dev/null
+++ b/LeanPool/ArnoldKAM/Imports.lean
@@ -0,0 +1,155 @@
+/-
+Copyright (c) 2026 Lean Pool contributors. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Lean Pool contributors
+-/
+module  -- shake: keep-all --deprecated_module: ignore
+
+-- Generated project imports; run `lake exe mk_all`.
+public import LeanPool.ArnoldKAM
+public import LeanPool.ArnoldKAM.Arnold1963.Analysis.AnalyticLift
+public import LeanPool.ArnoldKAM.Arnold1963.Analysis.AnalyticUniformLimit
+public import LeanPool.ArnoldKAM.Arnold1963.Analysis.BoxIntegral
+public import LeanPool.ArnoldKAM.Arnold1963.Analysis.Cauchy
+public import LeanPool.ArnoldKAM.Arnold1963.Analysis.ContourShift
+public import LeanPool.ArnoldKAM.Arnold1963.Analysis.DomainBuffer
+public import LeanPool.ArnoldKAM.Arnold1963.Analysis.FourierCoefficients
+public import LeanPool.ArnoldKAM.Arnold1963.Analysis.FourierDecay
+public import LeanPool.ArnoldKAM.Arnold1963.Analysis.FourierKernel
+public import LeanPool.ArnoldKAM.Arnold1963.Analysis.FourierParameter
+public import LeanPool.ArnoldKAM.Arnold1963.Analysis.FourierPolynomial
+public import LeanPool.ArnoldKAM.Arnold1963.Analysis.FourierReconstruction
+public import LeanPool.ArnoldKAM.Arnold1963.Analysis.FourierSeries
+public import LeanPool.ArnoldKAM.Arnold1963.Analysis.FourierTail
+public import LeanPool.ArnoldKAM.Arnold1963.Analysis.MeanValue
+public import LeanPool.ArnoldKAM.Arnold1963.Analysis.MultiContourShift
+public import LeanPool.ArnoldKAM.Arnold1963.Analysis.ParameterIntegral
+public import LeanPool.ArnoldKAM.Arnold1963.Analysis.PhaseCauchy
+public import LeanPool.ArnoldKAM.Arnold1963.Analysis.PolydiscCauchy
+public import LeanPool.ArnoldKAM.Arnold1963.Analysis.SecondCauchy
+public import LeanPool.ArnoldKAM.Arnold1963.Analysis.ShiftedFourier
+public import LeanPool.ArnoldKAM.Arnold1963.Analysis.TailConstant
+public import LeanPool.ArnoldKAM.Arnold1963.Analysis.Taylor
+public import LeanPool.ArnoldKAM.Arnold1963.Arithmetic.Estimates
+public import LeanPool.ArnoldKAM.Arnold1963.Arithmetic.Lattice
+public import LeanPool.ArnoldKAM.Arnold1963.Arithmetic.Parameters
+public import LeanPool.ArnoldKAM.Arnold1963.Arithmetic.ResonanceDomain
+public import LeanPool.ArnoldKAM.Arnold1963.Arithmetic.ResonanceLoss
+public import LeanPool.ArnoldKAM.Arnold1963.Arithmetic.ResonanceMeasure
+public import LeanPool.ArnoldKAM.Arnold1963.Audit.FundamentalExample
+public import LeanPool.ArnoldKAM.Arnold1963.Audit.Steps123
+public import LeanPool.ArnoldKAM.Arnold1963.Audit.W10Branches
+public import LeanPool.ArnoldKAM.Arnold1963.Audit.W10Example
+public import LeanPool.ArnoldKAM.Arnold1963.Audit.W9Example
+public import LeanPool.ArnoldKAM.Arnold1963.Basic.Domains
+public import LeanPool.ArnoldKAM.Arnold1963.Basic.FunctionOperations
+public import LeanPool.ArnoldKAM.Arnold1963.Basic.Functions
+public import LeanPool.ArnoldKAM.Arnold1963.Basic.Hamiltonian
+public import LeanPool.ArnoldKAM.Arnold1963.Basic.Measure
+public import LeanPool.ArnoldKAM.Arnold1963.Basic.Periodic
+public import LeanPool.ArnoldKAM.Arnold1963.Basic.Spaces
+public import LeanPool.ArnoldKAM.Arnold1963.Basic.Symplectic
+public import LeanPool.ArnoldKAM.Arnold1963.Basic.SymplecticMatrix
+public import LeanPool.ArnoldKAM.Arnold1963.Convergence.Budgets
+public import LeanPool.ArnoldKAM.Arnold1963.Convergence.ComplexLines
+public import LeanPool.ArnoldKAM.Arnold1963.Convergence.Composition
+public import LeanPool.ArnoldKAM.Arnold1963.Convergence.Frequency
+public import LeanPool.ArnoldKAM.Arnold1963.Convergence.JointAnalyticity
+public import LeanPool.ArnoldKAM.Arnold1963.Convergence.Limit
+public import LeanPool.ArnoldKAM.Arnold1963.Convergence.Nonresonance
+public import LeanPool.ArnoldKAM.Arnold1963.Convergence.RealDerivative
+public import LeanPool.ArnoldKAM.Arnold1963.Convergence.SequenceLimit
+public import LeanPool.ArnoldKAM.Arnold1963.Dynamics.LimitConjugacy
+public import LeanPool.ArnoldKAM.Arnold1963.Dynamics.OrbitUniqueness
+public import LeanPool.ArnoldKAM.Arnold1963.Dynamics.RealOrbits
+public import LeanPool.ArnoldKAM.Arnold1963.Dynamics.TorusDensity
+public import LeanPool.ArnoldKAM.Arnold1963.Dynamics.VectorFields
+public import LeanPool.ArnoldKAM.Arnold1963.Geometry.CorrectedChart
+public import LeanPool.ArnoldKAM.Arnold1963.Geometry.CovectorTube
+public import LeanPool.ArnoldKAM.Arnold1963.Geometry.DomainCover
+public import LeanPool.ArnoldKAM.Arnold1963.Geometry.Erosion
+public import LeanPool.ArnoldKAM.Arnold1963.Geometry.FiniteTubes
+public import LeanPool.ArnoldKAM.Arnold1963.Geometry.FrequencyChange
+public import LeanPool.ArnoldKAM.Arnold1963.Geometry.FrequencyChart
+public import LeanPool.ArnoldKAM.Arnold1963.Geometry.FrequencyChartCongr
+public import LeanPool.ArnoldKAM.Arnold1963.Geometry.FrequencyDomain
+public import LeanPool.ArnoldKAM.Arnold1963.Geometry.FrequencyInverse
+public import LeanPool.ArnoldKAM.Arnold1963.Geometry.FrequencyMeasure
+public import LeanPool.ArnoldKAM.Arnold1963.Geometry.GeneratingEquivariance
+public import LeanPool.ArnoldKAM.Arnold1963.Geometry.GeneratingGlobal
+public import LeanPool.ArnoldKAM.Arnold1963.Geometry.GeneratingImplicit
+public import LeanPool.ArnoldKAM.Arnold1963.Geometry.GeneratingInjective
+public import LeanPool.ArnoldKAM.Arnold1963.Geometry.GeneratingLocal
+public import LeanPool.ArnoldKAM.Arnold1963.Geometry.GeneratingMaps
+public import LeanPool.ArnoldKAM.Arnold1963.Geometry.GeneratingSymmetry
+public import LeanPool.ArnoldKAM.Arnold1963.Geometry.GeneratingTorus
+public import LeanPool.ArnoldKAM.Arnold1963.Geometry.GeneratingTransformation
+public import LeanPool.ArnoldKAM.Arnold1963.Geometry.GlobalInverse
+public import LeanPool.ArnoldKAM.Arnold1963.Geometry.GradientBounds
+public import LeanPool.ArnoldKAM.Arnold1963.Geometry.HamiltonianLocalization
+public import LeanPool.ArnoldKAM.Arnold1963.Geometry.Localization
+public import LeanPool.ArnoldKAM.Arnold1963.Geometry.LocalizationCover
+public import LeanPool.ArnoldKAM.Arnold1963.Geometry.NearIdentity
+public import LeanPool.ArnoldKAM.Arnold1963.Geometry.Polydisc
+public import LeanPool.ArnoldKAM.Arnold1963.Geometry.PolydiscBoundary
+public import LeanPool.ArnoldKAM.Arnold1963.Geometry.RealCover
+public import LeanPool.ArnoldKAM.Arnold1963.Geometry.RealJacobian
+public import LeanPool.ArnoldKAM.Arnold1963.Geometry.SlabMeasure
+public import LeanPool.ArnoldKAM.Arnold1963.Geometry.TubeLayer
+public import LeanPool.ArnoldKAM.Arnold1963.Geometry.TypeD
+public import LeanPool.ArnoldKAM.Arnold1963.Iteration.Construction
+public import LeanPool.ArnoldKAM.Arnold1963.Iteration.Cutoff
+public import LeanPool.ArnoldKAM.Arnold1963.Iteration.CutoffBudget
+public import LeanPool.ArnoldKAM.Arnold1963.Iteration.DerivativeBudget
+public import LeanPool.ArnoldKAM.Arnold1963.Iteration.Estimates
+public import LeanPool.ArnoldKAM.Arnold1963.Iteration.InitialParameters
+public import LeanPool.ArnoldKAM.Arnold1963.Iteration.LimitDomain
+public import LeanPool.ArnoldKAM.Arnold1963.Iteration.Measure
+public import LeanPool.ArnoldKAM.Arnold1963.Iteration.NumericalConditions
+public import LeanPool.ArnoldKAM.Arnold1963.Iteration.Parameters
+public import LeanPool.ArnoldKAM.Arnold1963.Iteration.ShellSum
+public import LeanPool.ArnoldKAM.Arnold1963.Iteration.State
+public import LeanPool.ArnoldKAM.Arnold1963.Iteration.StepInterface
+public import LeanPool.ArnoldKAM.Arnold1963.Iteration.TotalBudget
+public import LeanPool.ArnoldKAM.Arnold1963.Iteration.UniformBounds
+public import LeanPool.ArnoldKAM.Arnold1963.Main.FiniteLocalization
+public import LeanPool.ArnoldKAM.Arnold1963.Main.GlobalCover
+public import LeanPool.ArnoldKAM.Arnold1963.Main.LocalKAM
+public import LeanPool.ArnoldKAM.Arnold1963.Main.LocalThreshold
+public import LeanPool.ArnoldKAM.Arnold1963.Main.Theorem1
+public import LeanPool.ArnoldKAM.Arnold1963.Main.Theorem2
+public import LeanPool.ArnoldKAM.Arnold1963.Main.TorusResult
+public import LeanPool.ArnoldKAM.Arnold1963.Measure.CumulativeVolume
+public import LeanPool.ArnoldKAM.Arnold1963.Measure.FiniteCover
+public import LeanPool.ArnoldKAM.Arnold1963.Measure.LimitImage
+public import LeanPool.ArnoldKAM.Arnold1963.Measure.LimitTorusVolume
+public import LeanPool.ArnoldKAM.Arnold1963.Measure.PeriodicProjection
+public import LeanPool.ArnoldKAM.Arnold1963.Measure.PhaseVolume
+public import LeanPool.ArnoldKAM.Arnold1963.Measure.RealSymplectic
+public import LeanPool.ArnoldKAM.Arnold1963.Step.Averaging
+public import LeanPool.ArnoldKAM.Arnold1963.Step.AveragingConstruction
+public import LeanPool.ArnoldKAM.Arnold1963.Step.Construction
+public import LeanPool.ArnoldKAM.Arnold1963.Step.DomainGeometry
+public import LeanPool.ArnoldKAM.Arnold1963.Step.FourierDifferential
+public import LeanPool.ArnoldKAM.Arnold1963.Step.FrequencyPreparation
+public import LeanPool.ArnoldKAM.Arnold1963.Step.Fundamental
+public import LeanPool.ArnoldKAM.Arnold1963.Step.GeneratingFunction
+public import LeanPool.ArnoldKAM.Arnold1963.Step.Homological
+public import LeanPool.ArnoldKAM.Arnold1963.Step.HomologicalBound
+public import LeanPool.ArnoldKAM.Arnold1963.Step.Inductive
+public import LeanPool.ArnoldKAM.Arnold1963.Step.InductiveDomains
+public import LeanPool.ArnoldKAM.Arnold1963.Step.InductiveIteration
+public import LeanPool.ArnoldKAM.Arnold1963.Step.Integrable
+public import LeanPool.ArnoldKAM.Arnold1963.Step.IntegrableBounds
+public import LeanPool.ArnoldKAM.Arnold1963.Step.IterationParameters
+public import LeanPool.ArnoldKAM.Arnold1963.Step.MeasureBudget
+public import LeanPool.ArnoldKAM.Arnold1963.Step.Nonresonance
+public import LeanPool.ArnoldKAM.Arnold1963.Step.NumericalBudget
+public import LeanPool.ArnoldKAM.Arnold1963.Step.Remainder
+public import LeanPool.ArnoldKAM.Arnold1963.Tori.AngleBounds
+public import LeanPool.ArnoldKAM.Arnold1963.Tori.CrossChart
+public import LeanPool.ArnoldKAM.Arnold1963.Tori.Disjointness
+public import LeanPool.ArnoldKAM.Arnold1963.Tori.Embedding
+public import LeanPool.ArnoldKAM.Arnold1963.Tori.FrequencyInjectivity
+public import LeanPool.ArnoldKAM.Arnold1963.Tori.OrbitClosure
+public import LeanPool.ArnoldKAM.Arnold1963.Tori.Parameterization
diff --git a/LeanPool/projects/arnold-kam.yaml b/LeanPool/projects/arnold-kam.yaml
new file mode 100644
index 0000000000..9a408d68c6
--- /dev/null
+++ b/LeanPool/projects/arnold-kam.yaml
@@ -0,0 +1,55 @@
+slug: arnold-kam
+title: Analytic Hamiltonian KAM on compact action domains
+summary: >-
+  Proves a nondegenerate analytic Hamiltonian KAM theorem on compact complex action
+  domains whose real slice is the closure of a nonempty open set with null boundary.
+  A positive perturbation threshold, chosen independently of the perturbation,
+  yields a pairwise disjoint family of analytic invariant tori covering all but a
+  prescribed relative measure error. Includes Fourier estimates, generating
+  transformations, resonance measure bounds, infinite iteration, global Hamiltonian
+  trajectories, and examples with a noninjective frequency map. The final torus
+  interface asserts nonresonance but does not additionally assert a quantitative
+  Diophantine bound or the Lagrangian property.
+branch: Analysis
+entry_module: LeanPool.ArnoldKAM
+authors:
+  - Bingqi Yu
+source:
+  github_repo: ybq1415926-droid/arnold1963-kam
+  commit: 69c10c07bcd0a65f8965bc58c37eea2700bafafb
+  doi: 10.5281/zenodo.23232025
+license: Apache-2.0
+status: verified
+provenance: AI
+main_declarations:
+  - KamProject.Arnold1963.theorem1
+main_results:
+  - declaration: KamProject.Arnold1963.theorem1
+    informal: >-
+      For a positive-dimensional analytic, real-compatible unperturbed Hamiltonian
+      with nonzero Hessian determinant on the real interior of the specified compact
+      domain, and any positive angle width and tolerance, a positive uniform
+      perturbation threshold gives a compact positive-measure good set partitioned
+      into pairwise disjoint analytic nonresonant invariant tori. The complementary
+      bad set has measure less than the tolerance times the initial phase volume.
+      Each torus has a closed embedding, an injective derivative, small displacement,
+      and trajectories solving the original perturbed Hamiltonian equation for all
+      real time. The analytic width is a positive output bounded by the input width.
+  - declaration: KamProject.Arnold1963.theorem1_of_pointwise
+    informal: >-
+      The same KAM conclusion holds when the perturbation is pointwise strictly
+      below the chosen threshold throughout its prescribed phase domain.
+  - declaration: KamProject.Arnold1963.AnalyticPhaseFunction.canonical_pullback
+    informal: >-
+      A differentiable symplectic transformation mapping into the analytic
+      Hamiltonian's phase domain carries the vector field of the pulled-back
+      Hamiltonian to the original Hamiltonian vector field.
+tags:
+  - Hamiltonian dynamics
+  - KAM theory
+  - Fourier analysis
+  - symplectic geometry
+msc:
+  - 37J40
+  - 37J35
+  - 42A16