diff --git a/lean/ComparatorChallenges/TraceReconstruction.json b/lean/ComparatorChallenges/TraceReconstruction.json
new file mode 100644
index 0000000000000000000000000000000000000000..734fb3a2e226775e1f9145f0e6f37bb121a1ba32
--- /dev/null
+++ b/lean/ComparatorChallenges/TraceReconstruction.json
@@ -0,0 +1,16 @@
+{
+  "challenge_module": "ComparatorChallenges.TraceReconstruction",
+  "solution_module": "OAI.Probability.TraceReconstruction",
+  "theorem_names": [
+    "OAI.TraceReconstruction.quantitative_sample_lower_bound",
+    "OAI.TraceReconstruction.superpolynomial_one_trace",
+    "OAI.TraceReconstruction.superpolynomial_sample_complexity"
+  ],
+  "definition_names": [],
+  "permitted_axioms": [
+    "propext",
+    "Quot.sound",
+    "Classical.choice"
+  ],
+  "enable_nanoda": false
+}
diff --git a/lean/ComparatorChallenges/TraceReconstruction.lean b/lean/ComparatorChallenges/TraceReconstruction.lean
new file mode 100644
index 0000000000000000000000000000000000000000..10db783ba141d7754767bc00c211986979f0eecb
--- /dev/null
+++ b/lean/ComparatorChallenges/TraceReconstruction.lean
@@ -0,0 +1,91 @@
+import Mathlib
+
+namespace OAI
+
+open scoped ENNReal
+noncomputable section
+
+namespace TraceReconstruction
+
+abbrev Word (n : ℕ) := Fin n → Bool
+abbrev Mask (n : ℕ) := Fin n → Bool
+abbrev Trace := List Bool
+
+/-- `true` retains the bit. The observer gets only the resulting list. -/
+def traceOfMask {n : ℕ} (x : Word n) (a : Mask n) : Trace :=
+  ((List.finRange n).filter fun i => a i).map x
+
+/-- The deletion-mask probability, with deletion probability `q`. -/
+def maskWeight {n : ℕ} (q : ℝ) (a : Mask n) : ℝ :=
+  ∏ i, if a i then 1 - q else q
+
+/-- Law of a single complete trace. -/
+def traceMass {n : ℕ} (q : ℝ) (x : Word n) (w : Trace) : ℝ :=
+  ∑ a : Mask n, if traceOfMask x a = w then maskWeight q a else 0
+
+/-- All possible complete outputs from length-n inputs, with lengths included. -/
+def traceSpace (n : ℕ) : Finset Trace :=
+  Finset.univ.biUnion fun k : Fin (n + 1) =>
+    Finset.univ.image fun x : Word k.val => List.ofFn x
+
+/-- 1/2 sum of absolute differences, on the full finite output space. -/
+def traceTV {n : ℕ} (q : ℝ) (x y : Word n) : ℝ :=
+  (1 / 2 : ℝ) * ∑ w ∈ traceSpace n, |traceMass q x w - traceMass q y w|
+
+/-- The estimator may depend arbitrarily on n, q and every complete sample.
+    Its value is its conditional probability of reporting the given input. -/
+def IsEstimator {n m : ℕ} (A : (Fin m → Trace) → Word n → ℝ) : Prop :=
+  (∀ z x, 0 ≤ A z x) ∧ (∀ z, ∑ x : Word n, A z x = 1)
+
+/-- Independent masks generate independent complete traces; no retained
+    positions, boundaries or other latent variables are revealed to A. -/
+def reconstructionSuccess {n m : ℕ} (q : ℝ)
+    (A : (Fin m → Trace) → Word n → ℝ) (x : Word n) : ℝ :=
+  ∑ a : Fin m → Mask n,
+    (∏ j, maskWeight q (a j)) * A (fun j => traceOfMask x (a j)) x
+
+def SufficientBudget (n : ℕ) (q s : ℝ) (m : ℕ) : Prop :=
+  ∃ A : (Fin m → Trace) → Word n → ℝ,
+    IsEstimator A ∧ ∀ x, s ≤ reconstructionSuccess q A x
+
+/-- Natural fixed sample budget; infimum of the empty set is infinity. -/
+noncomputable def sampleComplexity (n : ℕ) (q s : ℝ) : ℝ≥0∞ :=
+  sInf {t | ∃ m : ℕ, SufficientBudget n q s m ∧ t = (m : ℝ≥0∞)}
+
+/-- The real infimum is a minimum for n>0 (a nonempty finite set). -/
+noncomputable def minTraceTV (n : ℕ) (q : ℝ) : ℝ :=
+  sInf {t | ∃ x y : Word n, x ≠ y ∧ t = traceTV q x y}
+
+open Filter
+open scoped Topology Classical ENNReal
+
+theorem quantitative_sample_lower_bound
+    (s c : ℝ) (hs : s ∈ Set.Ioc 0 1)
+    (hc : c ∈ Set.Ioo 0 (1 / (4 * Real.log 2)))
+    (n : ℕ → ℕ) (q : ℕ → ℝ)
+    (hn : Tendsto n atTop atTop)
+    (hq : ∀ k, q k ∈ Set.Ioo 0 1)
+    (hscale : Tendsto (fun k => (q k) ^ 3 * Real.log (n k)) atTop atTop) :
+    ∀ᶠ k in atTop,
+      ENNReal.ofReal ((n k : ℝ) ^ (c * Real.log ((q k) ^ 3 * Real.log (n k)))) ≤
+        sampleComplexity (n k) (q k) s := by
+  sorry
+
+theorem superpolynomial_one_trace
+    (q : ℝ) (hq : q ∈ Set.Ioo 0 1) (C : ℝ) (hC : 0 < C) :
+    Tendsto (fun n : ℕ => (n : ℝ) ^ C * minTraceTV n q) atTop (𝓝 0) := by
+  sorry
+
+theorem superpolynomial_sample_complexity
+    (q : ℝ) (hq : q ∈ Set.Ioo 0 1) (s : ℝ) (hs : s ∈ Set.Ioc 0 1)
+    (C : ℝ) (hC : 0 < C) :
+    Tendsto
+      (fun n : ℕ => sampleComplexity n q s / ENNReal.ofReal ((n : ℝ) ^ C))
+      atTop (𝓝 ⊤) := by
+  sorry
+
+end TraceReconstruction
+
+end
+
+end OAI
diff --git a/lean/ComparatorChallenges/TreeEdit.json b/lean/ComparatorChallenges/TreeEdit.json
new file mode 100644
index 0000000000000000000000000000000000000000..c2910a49767c92e1e161749affb32d61ce6e0487
--- /dev/null
+++ b/lean/ComparatorChallenges/TreeEdit.json
@@ -0,0 +1,14 @@
+{
+  "challenge_module": "ComparatorChallenges.TreeEdit",
+  "solution_module": "OAI.Combinatorics.TreeEdit.TorusLowerBound",
+  "theorem_names": [
+    "OAI.TreeEdit.binary_torus"
+  ],
+  "definition_names": [],
+  "permitted_axioms": [
+    "propext",
+    "Quot.sound",
+    "Classical.choice"
+  ],
+  "enable_nanoda": false
+}
diff --git a/lean/ComparatorChallenges/TreeEdit.lean b/lean/ComparatorChallenges/TreeEdit.lean
new file mode 100644
index 0000000000000000000000000000000000000000..e3abc7cc91aca049b7878a31c96037c6e2582ef1
--- /dev/null
+++ b/lean/ComparatorChallenges/TreeEdit.lean
@@ -0,0 +1,51 @@
+import Mathlib
+
+namespace OAI
+
+namespace TreeEdit
+
+universe u
+
+/-- A single unit-cost insertion, deletion or substitution, at any position. -/
+inductive EditStep {α : Type u} : List α → List α → Prop
+  | insert (p q : List α) (a : α) : EditStep (p ++ q) (p ++ a :: q)
+  | delete (p q : List α) (a : α) : EditStep (p ++ a :: q) (p ++ q)
+  | substitute (p q : List α) (a b : α) : EditStep (p ++ a :: q) (p ++ b :: q)
+
+/-- A script of precisely `n` edits. There is no restriction on its intermediate lengths. -/
+inductive EditScript {α : Type u} : List α → List α → ℕ → Prop
+  | nil (x : List α) : EditScript x x 0
+  | cons {x y z : List α} {n : ℕ} :
+      EditStep x y → EditScript y z n → EditScript x z (n + 1)
+
+/-- Ordinary unit-cost edit distance. The set is nonempty (delete then insert). -/
+noncomputable def ed {α : Type u} (x y : List α) : ℕ :=
+  sInf {n | EditScript x y n}
+
+/-- The full infinite-dimensional real ℓ₁ space. -/
+abbrev RealL1 := lp (fun _ : ℕ => ℝ) 1
+
+/-- Product of the two maximal pairwise distance ratios. -/
+noncomputable def distortion (W : Finset (List Bool)) (f : W → RealL1) : ℝ :=
+  sSup {r : ℝ | ∃ x y : W, x ≠ y ∧
+      r = dist (f x) (f y) / (ed x.val y.val : ℝ)} *
+  sSup {r : ℝ | ∃ x y : W, x ≠ y ∧
+      r = (ed x.val y.val : ℝ) / dist (f x) (f y)}
+
+/-- Infimum over all injective ℓ₁ maps, used on finite sets with at least two points. -/
+noncomputable def c1 (W : Finset (List Bool)) : ℝ :=
+  sInf {D : ℝ | ∃ f : W → RealL1, Function.Injective f ∧ distortion W f = D}
+
+/-- The binary main endpoint, for every sufficiently large cap (natural logarithms). -/
+def BinaryLowerBound : Prop :=
+  ∃ c : ℝ, 0 < c ∧ ∃ d₀ : ℕ, ∀ d : ℕ, d₀ ≤ d →
+    ∃ n : ℕ, n ≤ d ∧ ∃ W : Finset (List Bool),
+      2 ≤ W.card ∧ (∀ w ∈ W, w.length = n) ∧
+      Real.exp (c * Real.sqrt (Real.log (d : ℝ) * Real.log (Real.log (d : ℝ)))) ≤ c1 W
+
+theorem binary_torus : BinaryLowerBound := by
+  sorry
+
+end TreeEdit
+
+end OAI
diff --git a/lean/ComparatorChallenges/TriangleFace.json b/lean/ComparatorChallenges/TriangleFace.json
new file mode 100644
index 0000000000000000000000000000000000000000..f66bed20e54091e337b2815c686b9464eca1d5ae
--- /dev/null
+++ b/lean/ComparatorChallenges/TriangleFace.json
@@ -0,0 +1,14 @@
+{
+  "challenge_module": "ComparatorChallenges.TriangleFace",
+  "solution_module": "OAI.Combinatorics.TriangleFace.Main",
+  "theorem_names": [
+    "OAI.TriangleFace198.triangle_expansion_face"
+  ],
+  "definition_names": [],
+  "permitted_axioms": [
+    "propext",
+    "Quot.sound",
+    "Classical.choice"
+  ],
+  "enable_nanoda": false
+}
diff --git a/lean/ComparatorChallenges/TriangleFace.lean b/lean/ComparatorChallenges/TriangleFace.lean
new file mode 100644
index 0000000000000000000000000000000000000000..9a07cf5ac47447761244710f10bfebe6790c2dc2
--- /dev/null
+++ b/lean/ComparatorChallenges/TriangleFace.lean
@@ -0,0 +1,190 @@
+import Mathlib
+
+namespace OAI
+
+noncomputable section
+
+open scoped BigOperators Topology
+open Filter
+
+universe uV uE uIndex uι
+
+namespace MatchingEntropyBounds
+
+structure LooplessGraph (V : Type uV) (E : Type uE) where
+  left : E → V
+  right : E → V
+  loopless : ∀ e, left e ≠ right e
+
+variable {V : Type uV} {E : Type uE}
+  [Fintype V] [Fintype E] [DecidableEq V] [DecidableEq E]
+
+namespace LooplessGraph
+
+def Incident (G : LooplessGraph V E) (v : V) (e : E) : Prop :=
+  G.left e = v ∨ G.right e = v
+
+instance incidentDecidable (G : LooplessGraph V E) (v : V) (e : E) :
+    Decidable (G.Incident v e) := inferInstanceAs (Decidable (G.left e = v ∨ G.right e = v))
+
+def IsPerfectMatching (G : LooplessGraph V E) (M : Finset E) : Prop :=
+  ∀ v, ∃! e, e ∈ M ∧ G.Incident v e
+
+abbrev Matching (G : LooplessGraph V E) := {M : Finset E // G.IsPerfectMatching M}
+
+instance matchingFintype (G : LooplessGraph V E) : Fintype G.Matching :=
+  Fintype.ofFinite _
+
+def indicator (G : LooplessGraph V E) (M : G.Matching) (e : E) : ℝ :=
+  if e ∈ M.val then 1 else 0
+
+def polytope (G : LooplessGraph V E) : Set (E → ℝ) :=
+  convexHull ℝ (Set.range G.indicator)
+
+end LooplessGraph
+end MatchingEntropyBounds
+end
+
+noncomputable section
+
+open scoped BigOperators Topology
+open Filter
+
+universe uV uE uI uJ uA uB uC uW uF uD uι
+
+namespace MatchingEntropyBounds.LooplessGraph
+
+variable {V : Type uV} {E : Type uE} [Fintype V] [Fintype E] [DecidableEq V] [DecidableEq E]
+
+def Crosses (G : LooplessGraph V E) (S : Finset V) (e : E) : Prop :=
+  (G.left e ∈ S ∧ G.right e ∉ S) ∨ (G.left e ∉ S ∧ G.right e ∈ S)
+
+instance crossesDecidable (G : LooplessGraph V E) (S : Finset V) (e : E) :
+    Decidable (G.Crosses S e) := inferInstanceAs (Decidable
+      ((G.left e ∈ S ∧ G.right e ∉ S) ∨ (G.left e ∉ S ∧ G.right e ∈ S)))
+
+def cut (G : LooplessGraph V E) (S : Finset V) : Finset E :=
+  Finset.univ.filter (G.Crosses S)
+
+def degree (G : LooplessGraph V E) (x : E → ℝ) (v : V) : ℝ :=
+  ∑ e, if G.Incident v e then x e else 0
+
+def cutMass (G : LooplessGraph V E) (x : E → ℝ) (S : Finset V) : ℝ :=
+  ∑ e ∈ G.cut S, x e
+
+end MatchingEntropyBounds.LooplessGraph
+end
+
+noncomputable section
+
+open scoped BigOperators Topology
+open Filter
+
+universe uV uE uI uJ uA uB uC uW uF uD uι
+
+namespace MatchingEntropyBounds.Refined
+
+section TriangleExpansion
+variable {V : Type uV} {E : Type uE} [Fintype V] [Fintype E] [DecidableEq V] [DecidableEq E]
+
+def triangleTip (v : V) (i : Fin 3) : V ⊕ Fin 2 := ![Sum.inl v, Sum.inr 0, Sum.inr 1] i
+
+def triangleCollapse (v : V) : V ⊕ Fin 2 → V := Sum.elim id (fun _ => v)
+
+def reattach (v : V) (i : Fin 3) (w : V) : V ⊕ Fin 2 :=
+  if w = v then triangleTip v i else Sum.inl w
+
+omit [Fintype V] [Fintype E] [DecidableEq E] in
+theorem collapse_reattach (v : V) (i : Fin 3) (w : V) :
+    triangleCollapse v (reattach v i w) = w := by
+  by_cases h : w = v
+  · subst w
+    fin_cases i <;> simp [reattach,triangleTip,triangleCollapse]
+  · simp [reattach,h,triangleCollapse]
+
+def triangleExpansion (G : LooplessGraph V E) (c : E → Fin 3) (v : V) :
+    LooplessGraph (V ⊕ Fin 2) (E ⊕ Fin 3) where
+  left := Sum.elim (fun e => reattach v (c e) (G.left e)) (fun i => triangleTip v (i + 1))
+  right := Sum.elim (fun e => reattach v (c e) (G.right e)) (fun i => triangleTip v (i + 2))
+  loopless := by
+    intro e h
+    rcases e with e | i
+    · have hh := congrArg (triangleCollapse v) h
+      exact G.loopless e ((collapse_reattach v (c e) (G.left e)).symm.trans
+        (hh.trans (collapse_reattach v (c e) (G.right e))))
+    · fin_cases i <;> simp [triangleTip] at h
+
+def triangleVertices (v : V) : Finset (V ⊕ Fin 2) := Finset.univ.image (triangleTip v)
+
+end TriangleExpansion
+end MatchingEntropyBounds.Refined
+end
+
+namespace CanonicalFace198
+
+variable {A B : Type*} [AddCommGroup A] [Module ℝ A]
+  [AddCommGroup B] [Module ℝ B]
+
+def facesThrough (P : Set A) (x : A) : Set (Set A) :=
+  {F | Convex ℝ F ∧ IsExtreme ℝ P F ∧ x ∈ F}
+
+def minFace (P : Set A) (x : A) : Set A := ⋂₀ facesThrough P x
+
+end CanonicalFace198
+
+noncomputable section
+open scoped BigOperators
+open MatchingEntropyBounds MatchingEntropyBounds.Refined
+namespace TriangleFace198
+variable {V E : Type*} [Fintype V] [Fintype E] [DecidableEq V] [DecidableEq E]
+
+def LocalLabels (G : LooplessGraph V E) (v : V) (c : E → Fin 3) : Prop :=
+  ∀ i, ∃! e, G.Incident v e ∧ c e = i
+
+def localEdge (G : LooplessGraph V E) (c : E → Fin 3) (v : V)
+    (hc : LocalLabels G v c) (i : Fin 3) : E := Classical.choose (hc i)
+
+def localExtension (G : LooplessGraph V E) (c : E → Fin 3) (v : V)
+    (hc : LocalLabels G v c) : (E → ℝ) →ₗ[ℝ] (E ⊕ Fin 3 → ℝ) where
+  toFun x := Sum.elim x (fun i => x (localEdge G c v hc i))
+  map_add' x y := by ext e; cases e <;> rfl
+  map_smul' a x := by ext e; cases e <;> rfl
+
+def oldRestriction : (E ⊕ Fin 3 → ℝ) →ₗ[ℝ] (E → ℝ) where
+  toFun y e := y (Sum.inl e)
+  map_add' _ _ := rfl
+  map_smul' _ _ := rfl
+
+end TriangleFace198
+
+end
+
+noncomputable section
+open scoped BigOperators
+open MatchingEntropyBounds MatchingEntropyBounds.Refined
+namespace TriangleFace198
+universe uV uE
+variable {V : Type uV} {E : Type uE} [instFintypeV : Fintype V] [Fintype E] [DecidableEq V] [instDecidableEqE : DecidableEq E]
+
+theorem triangle_expansion_face {V : Type uV} {E : Type uE}
+    [Fintype V] [Fintype E] [DecidableEq V] [DecidableEq E] (G : LooplessGraph V E) (v : V)
+    (hdeg : Fintype.card {e : E // G.Incident v e} = 3)
+    (_hmatching : Nonempty G.Matching) :
+    ∃ (c : E → Fin 3) (hc : LocalLabels G v c),
+      let H := triangleExpansion G c v
+      let f := localExtension G c v hc
+      let Q := {y | y ∈ H.polytope ∧ H.cutMass y (triangleVertices v) = 1}
+      f '' G.polytope = Q ∧
+      Convex ℝ Q ∧ IsExtreme ℝ H.polytope Q ∧
+      (∀ x, oldRestriction (f x) = x) ∧
+      (∀ y ∈ Q, f (oldRestriction y) = y) ∧
+      (∀ x e, f x (Sum.inl e) = x e) ∧
+      (∀ x i, f x (Sum.inr i) = x (localEdge G c v hc i)) ∧
+      (∀ x, (∀ e, x e = (1/3 : ℝ)) → ∀ e, f x e = (1/3 : ℝ)) ∧
+      (∀ x ∈ G.polytope, CanonicalFace198.minFace H.polytope (f x) = f '' CanonicalFace198.minFace G.polytope x)  := by
+  sorry
+
+end TriangleFace198
+end
+
+end OAI
diff --git a/lean/ComparatorChallenges/TriangleRemoval.json b/lean/ComparatorChallenges/TriangleRemoval.json
new file mode 100644
index 0000000000000000000000000000000000000000..26c01db916dda8d1a2374e57b342d76d1ac253ad
--- /dev/null
+++ b/lean/ComparatorChallenges/TriangleRemoval.json
@@ -0,0 +1,14 @@
+{
+  "challenge_module": "ComparatorChallenges.TriangleRemoval",
+  "solution_module": "OAI.Combinatorics.TriangleRemoval.Main",
+  "theorem_names": [
+    "OAI.SharpTerminalLeave.sharp_terminal_leave"
+  ],
+  "definition_names": [],
+  "permitted_axioms": [
+    "propext",
+    "Classical.choice",
+    "Quot.sound"
+  ],
+  "enable_nanoda": false
+}
diff --git a/lean/ComparatorChallenges/TriangleRemoval.lean b/lean/ComparatorChallenges/TriangleRemoval.lean
new file mode 100644
index 0000000000000000000000000000000000000000..44f756332a829369d6b6547be9a5931629431aab
--- /dev/null
+++ b/lean/ComparatorChallenges/TriangleRemoval.lean
@@ -0,0 +1,67 @@
+import Mathlib
+
+namespace OAI
+
+section
+section
+
+open Filter
+open scoped BigOperators Topology
+
+namespace SharpTerminalLeave
+
+abbrev Graph (n : ℕ) := Finset (Finset (Fin n))
+
+def completeGraph (n : ℕ) : Graph n := Finset.univ.powersetCard 2
+
+def triangles {n : ℕ} (G : Graph n) : Finset (Finset (Fin n)) :=
+  (Finset.univ.powersetCard 3).filter (fun t => t.powersetCard 2 ⊆ G)
+
+noncomputable def step {n : ℕ} (G : Graph n) : PMF (Graph n) :=
+  if h : (triangles G).Nonempty then
+    (PMF.uniformOfFinset (triangles G) h).map (fun t => G \ t.powersetCard 2)
+  else PMF.pure G
+
+noncomputable def evolve {n : ℕ} (G : Graph n) : ℕ → PMF (Graph n)
+  | 0 => PMF.pure G
+  | k + 1 => (evolve G k).bind step
+
+noncomputable def terminalLaw (n : ℕ) : PMF (Graph n) :=
+  evolve (completeGraph n) (n.choose 2)
+
+noncomputable def expectation (n : ℕ) (f : Graph n → ℝ) : ℝ :=
+  ∑ G, (terminalLaw n G).toReal * f G
+
+noncomputable def probability (n : ℕ) (P : Graph n → Prop) : ℝ := by
+  classical
+  exact expectation n (fun G => if P G then 1 else 0)
+
+noncomputable def normalization (n : ℕ) : ℝ := (n : ℝ) ^ (3 / 2 : ℝ)
+
+noncomputable def normalizedLeave (n : ℕ) (G : Graph n) : ℝ :=
+  (G.card : ℝ) / normalization n
+
+noncomputable def sharpConstant : ℝ := 1 / (2 * Real.sqrt 2)
+
+end SharpTerminalLeave
+end
+end
+
+open Filter
+open scoped BigOperators Topology
+
+namespace SharpTerminalLeave
+
+theorem sharp_terminal_leave :
+    Tendsto (fun n => expectation n (fun G =>
+      (normalizedLeave n G - sharpConstant) ^ 2)) atTop (𝓝 0) ∧
+    (∀ ε : ℝ, 0 < ε →
+      Tendsto (fun n => probability n (fun G =>
+        ε < |normalizedLeave n G - sharpConstant|)) atTop (𝓝 0)) ∧
+    Tendsto (fun n => expectation n (fun G => (G.card : ℝ)) / normalization n)
+      atTop (𝓝 sharpConstant) := by
+  sorry
+
+end SharpTerminalLeave
+
+end OAI
diff --git a/lean/ComparatorChallenges/TriangularCovering.json b/lean/ComparatorChallenges/TriangularCovering.json
new file mode 100644
index 0000000000000000000000000000000000000000..a6513114a7cc77398841a4b0ffe53593b1c03eb8
--- /dev/null
+++ b/lean/ComparatorChallenges/TriangularCovering.json
@@ -0,0 +1,14 @@
+{
+  "challenge_module": "ComparatorChallenges.TriangularCovering",
+  "solution_module": "OAI.Geometry.TriangularCovering.Main",
+  "theorem_names": [
+    "OAI.TriangularCovering.main"
+  ],
+  "definition_names": [],
+  "permitted_axioms": [
+    "propext",
+    "Quot.sound",
+    "Classical.choice"
+  ],
+  "enable_nanoda": false
+}
diff --git a/lean/ComparatorChallenges/TriangularCovering.lean b/lean/ComparatorChallenges/TriangularCovering.lean
new file mode 100644
index 0000000000000000000000000000000000000000..1d77c559a02feed7ab6917ca3669fea6100a3b95
--- /dev/null
+++ b/lean/ComparatorChallenges/TriangularCovering.lean
@@ -0,0 +1,72 @@
+import Mathlib
+
+namespace OAI
+
+open Set MeasureTheory
+open scoped InnerProductSpace BigOperators Interval
+
+noncomputable section
+namespace TriangularCovering
+
+abbrev Space := EuclideanSpace ℝ (Fin 3)
+
+def H : ℝ := Real.sqrt 2
+
+def point (x y t : ℝ) : Space := !₂[x, y, H * t]
+
+def K : Set Space :=
+  {z | ∃ x y t : ℝ, 0 ≤ t ∧ t ≤ 1 ∧ |x| ≤ 1 - t ∧ |y| ≤ t ∧ z = point x y t}
+
+def projection (u z : Space) : Space := z - (inner ℝ u z) • u
+
+def area (B : Set Space) : ℝ := (Measure.euclideanHausdorffMeasure 2 B).toReal
+
+def shadowArea (u : Space) : ℝ := area (projection u '' K)
+
+def A_min : ℝ := sInf {a : ℝ | ∃ u : Space, ‖u‖ = 1 ∧ a = shadowArea u}
+
+structure TriCylinder where
+  axis : Space
+  base : Set Space
+  unit_axis : ‖axis‖ = 1
+  perpendicular : ∀ z ∈ base, inner ℝ axis z = 0
+  triangular : ∃ v : Fin 3 → Space, AffineIndependent ℝ v ∧
+    base = convexHull ℝ (Set.range v)
+  compact : IsCompact base
+  convex : Convex ℝ base
+  measurable : MeasurableSet base
+  finite_area : Measure.euclideanHausdorffMeasure 2 base ≠ ⊤
+
+def TriCylinder.carrier (c : TriCylinder) : Set Space :=
+  {z | ∃ b ∈ c.base, ∃ r : ℝ, z = b + r • c.axis}
+
+def Covers {m : ℕ} (c : Fin m → TriCylinder) : Prop :=
+  ∀ z ∈ K, ∃ i : Fin m, z ∈ (c i).carrier
+
+def totalArea {m : ℕ} (c : Fin m → TriCylinder) : ℝ :=
+  ∑ i : Fin m, area (c i).base
+
+def relativeCost {m : ℕ} (c : Fin m → TriCylinder) : ℝ :=
+  ∑ i : Fin m, area (c i).base / shadowArea (c i).axis
+
+def n (ε : ℝ) : ℕ := ⌈2 / ε ^ 2⌉₊
+
+def MainAsymptotic : Prop :=
+  ∃ δ C : ℝ, 0 < δ ∧ 0 < C ∧
+    ∀ ε : ℝ, 0 < ε → ε < δ →
+      ∃ c : Fin (2 * n ε) → TriCylinder,
+        Covers c ∧
+        |totalArea c / H - (1 / 2 - (13 / 6000 : ℝ) * ε ^ 2)| ≤ C * ε ^ 4 ∧
+        totalArea c < A_min / 2
+
+def NormalizedCounterexample : Prop :=
+  ∃ m : ℕ, ∃ c : Fin m → TriCylinder, Covers c ∧ relativeCost c < 1 / 2
+
+theorem main : A_min = H ∧ MainAsymptotic ∧ NormalizedCounterexample := by
+  sorry
+
+end TriangularCovering
+
+end
+
+end OAI
diff --git a/lean/ComparatorChallenges/TriangularEnergy.json b/lean/ComparatorChallenges/TriangularEnergy.json
new file mode 100644
index 0000000000000000000000000000000000000000..ade9cd84320b2effaa4cb9fd109d45ea6a5f0c26
--- /dev/null
+++ b/lean/ComparatorChallenges/TriangularEnergy.json
@@ -0,0 +1,14 @@
+{
+  "challenge_module": "ComparatorChallenges.TriangularEnergy",
+  "solution_module": "OAI.Analysis.Triangular.Energy.Universal",
+  "theorem_names": [
+    "OAI.AtomicTriangular.universal_energy_minimum"
+  ],
+  "definition_names": [],
+  "permitted_axioms": [
+    "propext",
+    "Quot.sound",
+    "Classical.choice"
+  ],
+  "enable_nanoda": false
+}
diff --git a/lean/ComparatorChallenges/TriangularEnergy.lean b/lean/ComparatorChallenges/TriangularEnergy.lean
new file mode 100644
index 0000000000000000000000000000000000000000..7dd73651627729ecaf8917377b52daec63828170
--- /dev/null
+++ b/lean/ComparatorChallenges/TriangularEnergy.lean
@@ -0,0 +1,74 @@
+import Mathlib
+
+namespace OAI
+
+noncomputable section
+open scoped BigOperators Topology ENNReal
+open Classical Filter
+
+namespace TriangularUniversal
+
+abbrev Plane := EuclideanSpace ℝ (Fin 2)
+
+def LocallyFinite (C : Set Plane) : Prop :=
+  ∀ R : ℝ, (C ∩ Metric.closedBall (0 : Plane) R).Finite
+
+def diskPoints (C : Set Plane) (R : ℝ) : Finset Plane :=
+  if h : (C ∩ Metric.closedBall (0 : Plane) R).Finite then h.toFinset else ∅
+
+def diskCount (C : Set Plane) (R : ℝ) : ℕ := (diskPoints C R).card
+
+def DensityOne (C : Set Plane) : Prop :=
+  Tendsto (fun R : ℝ => (diskCount C R : ℝ) / (Real.pi * R ^ 2))
+    atTop (𝓝 1)
+
+def AdmissiblePotential (g : ℝ → ℝ) : Prop :=
+  ContDiffOn ℝ (⊤ : ℕ∞) g (Set.Ioi 0) ∧
+  (∀ t : ℝ, 0 < t → 0 ≤ g t) ∧
+  ∀ (r : ℕ) (t : ℝ), 0 < t → 0 ≤ (-1 : ℝ) ^ r * iteratedDeriv r g t
+
+def diskEnergy (g : ℝ → ℝ) (C : Set Plane) (R : ℝ) : ℝ≥0∞ :=
+  (diskCount C R : ℝ≥0∞)⁻¹ *
+    ∑ x ∈ diskPoints C R, ∑ y ∈ (diskPoints C R).erase x,
+      ENNReal.ofReal (g (‖x - y‖ ^ 2))
+
+def energy (g : ℝ → ℝ) (C : Set Plane) : ℝ≥0∞ :=
+  Filter.liminf (diskEnergy g C) atTop
+
+end TriangularUniversal
+
+namespace AtomicTriangular
+
+abbrev Plane := EuclideanSpace ℝ (Fin 2)
+
+def b : ℝ := Real.sqrt 3 / 2
+
+def triangularPoint (jk : ℤ × ℤ) : Plane :=
+  (Real.sqrt b)⁻¹ •
+    (EuclideanSpace.single 0 ((jk.1 : ℝ) + (jk.2 : ℝ) / 2) +
+      EuclideanSpace.single 1 ((jk.2 : ℝ) * b))
+
+def A : Set Plane := Set.range triangularPoint
+
+abbrev LocallyFinite := TriangularUniversal.LocallyFinite
+abbrev diskPoints := TriangularUniversal.diskPoints
+abbrev diskCount := TriangularUniversal.diskCount
+abbrev DensityOne := TriangularUniversal.DensityOne
+abbrev AdmissiblePotential := TriangularUniversal.AdmissiblePotential
+abbrev diskEnergy := TriangularUniversal.diskEnergy
+abbrev energy := TriangularUniversal.energy
+
+/-- The full nonzero-lattice energy, allowing a divergent series. -/
+def latticeEnergy (g : ℝ → ℝ) : ℝ≥0∞ :=
+  ∑' a : {x : Plane // x ∈ A ∧ x ≠ 0}, ENNReal.ofReal (g (‖a.val‖ ^ 2))
+
+/-- Universal energy minimality for smooth completely monotone potentials, with attainment. -/
+theorem universal_energy_minimum (g : ℝ → ℝ) (C : Set Plane)
+    (hg : AdmissiblePotential g) (hC : LocallyFinite C) (hd : DensityOne C) :
+    latticeEnergy g ≤ energy g C ∧ latticeEnergy g = energy g A := by
+  sorry
+
+end AtomicTriangular
+end
+
+end OAI
diff --git a/lean/ComparatorChallenges/TriangularGaussian.json b/lean/ComparatorChallenges/TriangularGaussian.json
new file mode 100644
index 0000000000000000000000000000000000000000..6c88cf8f2127cc1606e9ac6063f4905809d55f69
--- /dev/null
+++ b/lean/ComparatorChallenges/TriangularGaussian.json
@@ -0,0 +1,14 @@
+{
+  "challenge_module": "ComparatorChallenges.TriangularGaussian",
+  "solution_module": "OAI.Analysis.Triangular.GaussianMinorants",
+  "theorem_names": [
+    "OAI.AtomicTriangular.sharp_gaussian_minorants_with_construction"
+  ],
+  "definition_names": [],
+  "permitted_axioms": [
+    "propext",
+    "Quot.sound",
+    "Classical.choice"
+  ],
+  "enable_nanoda": false
+}
diff --git a/lean/ComparatorChallenges/TriangularGaussian.lean b/lean/ComparatorChallenges/TriangularGaussian.lean
new file mode 100644
index 0000000000000000000000000000000000000000..43288229ab9dda9741e2984667aa851bd6b2b0ce
--- /dev/null
+++ b/lean/ComparatorChallenges/TriangularGaussian.lean
@@ -0,0 +1,275 @@
+import Mathlib
+
+namespace OAI
+
+/-!
+# Sharp Gaussian minorants with atomic interpolation
+
+The sharp Gaussian minorants of the atomic certificate for triangular-lattice
+universal optimality, including the construction for parameters at least one.
+-/
+
+noncomputable section
+open scoped BigOperators FourierTransform SchwartzMap
+open Complex Polynomial
+
+namespace AtomicTriangular
+
+abbrev Plane := EuclideanSpace ℝ (Fin 2)
+
+def b : ℝ := Real.sqrt 3 / 2
+
+def triangularPoint (jk : ℤ × ℤ) : Plane :=
+  (Real.sqrt b)⁻¹ •
+    (EuclideanSpace.single 0 ((jk.1 : ℝ) + (jk.2 : ℝ) / 2) +
+      EuclideanSpace.single 1 ((jk.2 : ℝ) * b))
+
+def A : Set Plane := Set.range triangularPoint
+
+def dualA : Set Plane := {w | ∀ a ∈ A, ∃ n : ℤ, inner ℝ a w = (n : ℝ)}
+
+def gaussian (α : ℝ) (x : Plane) : ℝ := Real.exp (-Real.pi * α * ‖x‖ ^ 2)
+
+def Radial (f : Plane → ℝ) : Prop := ∀ x y, ‖x‖ = ‖y‖ → f x = f y
+
+def realFourier (f : Plane → ℝ) (w : Plane) : ℂ := 𝓕 (fun x => (f x : ℂ)) w
+
+end AtomicTriangular
+
+namespace AtomicTriangular.Construction
+
+def b : ℝ := Real.sqrt 3 / 2
+
+def h : ℝ := 17 / 50
+
+def H : ℝ := 27 / 50
+
+def eta : ℝ := 1 / 5
+
+def kappa : ℝ := Real.pi / 36
+
+def residues : Finset ℤ := {0,1,3,4,7,9,12,13,16,19,21,25,27,28,31}
+
+def residue (a : Fin 15) : ℤ := ![0,1,3,4,7,9,12,13,16,19,21,25,27,28,31] a
+
+def Node : Type := {n : ℤ // 0 < n ∧ n % 36 ∈ residues}
+
+def FiniteNodes : Finset ℤ := {1,3,4,7,9,12,13,16,19,21}
+
+def sineFactor (a : Fin 15) (s : ℂ) : ℂ :=
+  2 * Complex.sin ((kappa : ℂ) * (s - (residue a : ℂ)))
+
+def P (s : ℂ) : ℂ := ∏ a : Fin 15, (sineFactor a s)^2
+
+def dBasis (n : Node) : ℂ → ℂ := dslope P (n.val : ℂ)
+
+def cBasis (n : Node) : ℂ → ℂ := dslope (dBasis n) (n.val : ℂ)
+
+def finiteC (a : Fin 15) (s : ℂ) : ℂ :=
+  4 * (kappa : ℂ)^2 * ∏ r ∈ Finset.univ.erase a, (sineFactor r s)^2
+
+def finiteD (a : Fin 15) (s : ℂ) : ℂ :=
+  2 * (kappa : ℂ) * sineFactor a s *
+    Complex.cos ((kappa : ℂ) * (s - (residue a : ℂ))) *
+      ∏ r ∈ Finset.univ.erase a, (sineFactor r s)^2
+
+def phase (s : ℂ) : ℂ := Complex.exp ((Real.pi : ℂ) * Complex.I * s / 18)
+
+def atomFactor (a : Fin 15) : Polynomial ℂ :=
+  -C (phase (residue a)) + C 2 * X - C (phase (-residue a)) * X^2
+
+def atomPolynomial : Polynomial ℂ := ∏ a : Fin 15, atomFactor a
+
+def cAtomPolynomial (a : Fin 15) : Polynomial ℂ :=
+  C (4 * (kappa : ℂ)^2) * ∏ r ∈ Finset.univ.erase a, atomFactor r
+
+def dAtomPolynomial (a : Fin 15) : Polynomial ℂ :=
+  C (Complex.I * (kappa : ℂ)) *
+    (C (phase (residue a)) - C (phase (-residue a)) * X^2) *
+      ∏ r ∈ Finset.univ.erase a, atomFactor r
+
+def fourierCoeff (j : Fin 31) : ℂ := atomPolynomial.coeff j.val
+
+def frequency (j : Fin 31) : ℝ := ((j.val : ℝ)-15)/18
+
+def waveDerivative (k : ℕ) (s : ℂ) : ℂ :=
+  ∑ j : Fin 31, fourierCoeff j * (I*Real.pi*frequency j)^k *
+    exp (I*Real.pi*frequency j*s)
+
+def Q (n : ℤ) : ℝ := (waveDerivative 2 n).re / 2
+
+def D (n : ℤ) : ℝ := (waveDerivative 3 n).re / (6 * Q n)
+
+end AtomicTriangular.Construction
+
+namespace AtomicTriangular.FiniteCertificate
+open Construction
+
+def cShiftPolynomial (a : Fin 15) : Polynomial ℂ := X * cAtomPolynomial a
+
+def cCoefficient (a : Fin 15) (j : Fin 31) : ℂ := (cShiftPolynomial a).coeff j.val
+
+def dCoefficient (a : Fin 15) (j : Fin 31) : ℂ := (dAtomPolynomial a).coeff j.val
+
+end AtomicTriangular.FiniteCertificate
+
+namespace AtomicTriangular.Construction
+
+abbrev Plane := EuclideanSpace ℝ (Fin 2)
+
+def radial (x : Plane) : ℝ := b*‖x‖^2
+
+def waveDen (k t : ℝ) : ℝ := k^2+t^2
+
+def Xwave (k t : ℝ) : ℝ := (4/3)/waveDen k t
+
+def lambda (k t : ℝ) : ℂ := ((k:ℂ)+I*t)/(b*waveDen k t : ℝ)
+
+def zeta (k v t : ℝ) : ℂ := -(t:ℂ)*(Xwave k t:ℂ)+I*(k*Xwave k t-v:ℝ)
+
+def transformedWave (k v t : ℝ) (s : ℂ) : ℂ := lambda k t*exp (I*Real.pi*zeta k v t*s)
+
+def finiteColumn (col : Fin 23) (j : Fin 31) : ℂ :=
+  if hc : col.val<22 then
+    if col.val%2=0 then FiniteCertificate.cCoefficient ⟨col.val/2,by omega⟩ j
+      else FiniteCertificate.dCoefficient ⟨col.val/2,by omega⟩ j
+  else fourierCoeff j
+
+def finiteNode (n : Fin 10) : ℤ := residue ⟨n.val+1,by omega⟩
+
+def jetMultiplier (k v : ℝ) (n : ℤ) (d : Fin 2) (t : ℝ) : ℂ :=
+  (Q n:ℂ)⁻¹*transformedWave k v t n *
+    (if d.val=0 then -1 else (D n:ℂ)-I*Real.pi*zeta k v t)
+
+def jet (k v : ℝ) (n : ℤ) (d : Fin 2) (S : Fin 31 → ℂ) : ℝ :=
+  (∑ j : Fin 31, jetMultiplier k v n d (frequency j)*S j).re
+
+def fullJetMatrix : Matrix (Fin 20) (Fin 23) ℝ := fun i col =>
+  jet (if col.val=22 then h else H) H
+    (finiteNode ⟨i.val/2,by omega⟩) ⟨i.val%2,by omega⟩ (finiteColumn col)
+
+def R : Matrix (Fin 20) (Fin 20) ℝ := fun i j => fullJetMatrix i ⟨j.val+2,by omega⟩
+
+def R0 : Matrix (Fin 20) (Fin 3) ℝ := fun i j =>
+  fullJetMatrix i (if j.val<2 then ⟨j.val,by omega⟩ else 22)
+
+abbrev TailNode := {n : Node // n.val ∉ FiniteNodes}
+
+structure InputCoefficients where
+  C : ℝ
+  finiteC : Fin 11 → ℝ
+  finiteD : Fin 11 → ℝ
+  tailC : TailNode → ℝ
+  tailD : TailNode → ℝ
+  summable : Summable (fun n => |tailC n|+|tailD n|)
+
+def tailInput (a : InputCoefficients) (s : ℂ) : ℂ :=
+  (a.C:ℂ)*P s + ∑' n : TailNode, ((a.tailC n:ℂ)*cBasis n.val s+(a.tailD n:ℂ)*dBasis n.val s)
+
+def finiteInput (a : InputCoefficients) (s : ℂ) : ℂ :=
+  ∑ j : Fin 11, ((a.finiteC j:ℂ)*finiteC ⟨j.val,by omega⟩ s +
+    (a.finiteD j:ℂ)*finiteD ⟨j.val,by omega⟩ s)
+
+def inputComplex (a : InputCoefficients) (x : Plane) : ℂ :=
+  exp (-(Real.pi:ℂ)*h*(radial x:ℂ))*tailInput a (radial x) +
+    exp (-(Real.pi:ℂ)*H*(radial x:ℂ))*finiteInput a (radial x)
+
+def targetCoefficient (n : Fin 10) : ℝ := Q 1 / Q (finiteNode n) * Real.exp (Real.pi*eta*(finiteNode n))
+
+def Yf : Matrix (Fin 20) (Fin 8) ℝ := fun i j =>
+  if i.val<8 then
+    targetCoefficient ⟨i.val/2,by omega⟩ *
+      (if i.val%2=0 then (if j.val=i.val then 1 else 0)
+       else (if j.val=i.val then -1 else if j.val=i.val-1 then Real.pi*eta-D (finiteNode ⟨i.val/2,by omega⟩) else 0))
+  else 0
+
+def gamma (side : Fin 2) : Matrix (Fin 3) (Fin 8) ℝ := fun i j =>
+  if j.val=1 then (if i.val=0 then 11/25 else if i.val=1 then 0 else if side.val=0 then -(3/500) else 3/500) else 0
+
+def Uplus : Matrix (Fin 20) (Fin 8) ℝ :=
+  (1-R)⁻¹*(Yf+R0*(gamma 1+gamma 0))
+
+def Uminus : Matrix (Fin 20) (Fin 8) ℝ :=
+  (1+R)⁻¹*(Yf+R0*(gamma 1-gamma 0))
+
+def finiteSolution (side : Fin 2) : Matrix (Fin 20) (Fin 8) ℝ :=
+  if side.val=0 then (1/2:ℝ) • (Uplus+Uminus) else (1/2:ℝ) • (Uplus-Uminus)
+
+def Acoefficient (side : Fin 2) : Matrix (Fin 23) (Fin 8) ℝ := fun i j =>
+  if hi : i.val<2 then gamma side ⟨i.val,by omega⟩ j
+  else if h22 : i.val=22 then gamma side 2 j
+  else finiteSolution side ⟨i.val-2,by omega⟩ j
+
+def gaussianZ (α : ℝ) : ℝ := 1/(Real.pi*(α/b-h))
+
+def actualParameter (z : ℝ) : Fin 8 → ℝ :=
+  ![z,1,z*Real.exp (-2/z),Real.exp (-2/z),z*Real.exp (-3/z),Real.exp (-3/z),
+    z*Real.exp (-6/z),Real.exp (-6/z)]
+
+def normalizingDen (z : ℝ) := Q 1*z*Real.exp (1/z)
+
+end AtomicTriangular.Construction
+
+end
+
+noncomputable section
+open scoped BigOperators FourierTransform
+
+namespace AtomicTriangular.Construction
+
+def correctedFinite (side : Fin 2) (z : ℝ) (δ : Fin 20 → ℝ) (j : Fin 22) : ℝ :=
+  (∑ r : Fin 8, Acoefficient side ⟨j.val, by omega⟩ r * actualParameter z r) +
+    if hj : j.val < 2 then 0 else δ ⟨j.val - 2, by omega⟩
+
+end AtomicTriangular.Construction
+
+namespace AtomicTriangular
+open Construction
+
+local instance finite_pair_neZero : NeZero (2 : ℕ) := inferInstance
+local instance three_atLeastTwo : Nat.AtLeastTwo 3 := inferInstance
+local instance ten_atLeastTwo : Nat.AtLeastTwo 10 := inferInstance
+local instance five_hundred_atLeastTwo : Nat.AtLeastTwo 500 := inferInstance
+local instance plane_borelSpace : BorelSpace Plane := inferInstance
+local instance plane_finite : Module.Finite ℝ Plane := inferInstance
+
+def AtomicConstruction (α : ℝ) (f : Plane → ℝ) : Prop :=
+  IsUnit (1 - R) ∧ IsUnit (1 + R) ∧
+  (1 - R) * Uplus = Yf + R0 * (gamma 1 + gamma 0) ∧
+  (1 + R) * Uminus = Yf + R0 * (gamma 1 - gamma 0) ∧
+  ∃ (δ : Fin 2 → Fin 20 → ℝ) (a : Fin 2 → InputCoefficients),
+    (∀ side, (∑ j : Fin 20, |δ side j|) < (1 / 10^5 : ℝ)) ∧
+    (∀ side, (a side).C = if side.val = 0 then -(3/500) else 3/500) ∧
+    (∀ side (j : Fin 11),
+      (a side).finiteC j =
+        correctedFinite side (gaussianZ α) (δ side) ⟨2*j.val, by omega⟩ ∧
+      (a side).finiteD j =
+        correctedFinite side (gaussianZ α) (δ side) ⟨2*j.val+1, by omega⟩) ∧
+    (∀ side, Summable (fun n => |(a side).tailC n| + |(a side).tailD n|) ∧
+      (∑' n, (|(a side).tailC n| + |(a side).tailD n|)) < (3 / 10^9 : ℝ)) ∧
+    (∀ x, (f x : ℂ) =
+      (inputComplex (a 0) x + 𝓕 (inputComplex (a 1)) x) /
+        (normalizingDen (gaussianZ α) : ℂ))
+
+end AtomicTriangular
+end
+
+noncomputable section
+open scoped BigOperators FourierTransform
+
+namespace AtomicTriangular
+open Construction
+
+theorem sharp_gaussian_minorants_with_construction (α : ℝ) (hα : 0 < α) :
+    ∃ f : SchwartzMap Plane ℝ,
+      Radial f ∧ (∀ x, f x ≤ gaussian α x) ∧
+      (∀ w, (realFourier f w).im = 0 ∧ 0 ≤ (realFourier f w).re) ∧
+      (∀ a ∈ A, a ≠ 0 → f a = gaussian α a) ∧
+      (∀ w ∈ dualA, w ≠ 0 → realFourier f w = 0) ∧
+      (1 ≤ α → AtomicConstruction α f) := by
+  sorry
+
+end AtomicTriangular
+end
+
+end OAI
diff --git a/lean/ComparatorChallenges/TriangularHilbert.json b/lean/ComparatorChallenges/TriangularHilbert.json
new file mode 100644
index 0000000000000000000000000000000000000000..203392a7d268d1e73c0ea0c0a8a3d25b14f02410
--- /dev/null
+++ b/lean/ComparatorChallenges/TriangularHilbert.json
@@ -0,0 +1,14 @@
+{
+  "challenge_module": "ComparatorChallenges.TriangularHilbert",
+  "solution_module": "OAI.Analysis.TriangularHilbert.Main",
+  "theorem_names": [
+    "OAI.TriangularHilbert.main_estimate"
+  ],
+  "definition_names": [],
+  "permitted_axioms": [
+    "propext",
+    "Quot.sound",
+    "Classical.choice"
+  ],
+  "enable_nanoda": false
+}
diff --git a/lean/ComparatorChallenges/TriangularHilbert.lean b/lean/ComparatorChallenges/TriangularHilbert.lean
new file mode 100644
index 0000000000000000000000000000000000000000..121c1dfb1f0d8c3642c43851ed559800b67c2c04
--- /dev/null
+++ b/lean/ComparatorChallenges/TriangularHilbert.lean
@@ -0,0 +1,57 @@
+import Mathlib
+
+namespace OAI
+
+noncomputable section
+
+open MeasureTheory
+open scoped ENNReal NNReal
+
+namespace TriangularHilbert
+
+abbrev Plane := ℝ × ℝ
+
+structure Endpoints where
+  lower : ℝ
+  upper : ℝ
+  lower_pos : 0 < lower
+  lower_lt_upper : lower < upper
+
+def annulus (ε R : ℝ) : Set ℝ := {t | ε < |t| ∧ |t| < R}
+
+def integrand (F G : Plane → ℂ) (z : Plane) (t : ℝ) : ℂ :=
+  F (z.1 + t, z.2) * G (z.1, z.2 + t) / (t : ℂ)
+
+def truncation (F G : Plane → ℂ) (E : Endpoints) (z : Plane) : ℂ :=
+  ∫ t in annulus E.lower E.upper, integrand F G z t
+
+def GoodPoint (F G : Plane → ℂ) (z : Plane) : Prop :=
+  ∀ n : ℕ, IntegrableOn (integrand F G z)
+    (annulus (1 / ((n : ℝ) + 2)) ((n : ℝ) + 2))
+
+def maximal (F G : Plane → ℂ) (z : Plane) : ℝ≥0∞ := by
+  classical
+  exact if GoodPoint F G z then
+    ⨆ E : Endpoints, ENNReal.ofReal ‖truncation F G E z‖ else 0
+
+def maximalNorm (F G : Plane → ℂ) : ℝ≥0∞ :=
+  (∫⁻ z : Plane, maximal F G z ^ ((3 : ℝ) / 2)) ^ ((2 : ℝ) / 3)
+
+def MainEstimate : Prop :=
+  ∃ C : ℝ≥0, ∀ F G : Plane → ℂ,
+    MemLp F 3 volume → MemLp G 3 volume →
+    (∀ᵐ z ∂volume, GoodPoint F G z) ∧
+    AEMeasurable (maximal F G) volume ∧
+    maximalNorm F G ≤ (C : ℝ≥0∞) * eLpNorm F 3 volume * eLpNorm G 3 volume
+
+open MeasureTheory Filter
+open scoped ENNReal
+
+theorem main_estimate : MainEstimate := by
+  sorry
+
+end TriangularHilbert
+
+end
+
+end OAI
diff --git a/lean/ComparatorChallenges/TruffetCounterexample.json b/lean/ComparatorChallenges/TruffetCounterexample.json
new file mode 100644
index 0000000000000000000000000000000000000000..e21e84c674b6ae3bd25a667caf8f13927eb2ec1a
--- /dev/null
+++ b/lean/ComparatorChallenges/TruffetCounterexample.json
@@ -0,0 +1,14 @@
+{
+  "challenge_module": "ComparatorChallenges.TruffetCounterexample",
+  "solution_module": "OAI.Optimization.Tropical.TruffetCounterexample",
+  "theorem_names": [
+    "OAI.TruffetV4Counterexample.finite_execution_not_optimal"
+  ],
+  "definition_names": [],
+  "permitted_axioms": [
+    "propext",
+    "Classical.choice",
+    "Quot.sound"
+  ],
+  "enable_nanoda": false
+}
diff --git a/lean/ComparatorChallenges/TruffetCounterexample.lean b/lean/ComparatorChallenges/TruffetCounterexample.lean
new file mode 100644
index 0000000000000000000000000000000000000000..3eb883a84951d236945dd5aa4c66b4d641619c38
--- /dev/null
+++ b/lean/ComparatorChallenges/TruffetCounterexample.lean
@@ -0,0 +1,134 @@
+import Mathlib
+
+namespace OAI
+
+noncomputable section
+namespace TruffetV4Counterexample
+
+abbrev Coeff := WithBot ℝ
+
+abbrev Form := Fin 3 → Coeff
+
+abbrev Var := Fin 2
+
+abbrev RowIndex := Fin 2
+
+def column (j : Var) : Fin 3 := ⟨j.val, Nat.lt_trans j.isLt (by decide)⟩
+
+def nullForm : Form := fun _ => ⊥
+
+structure Row where
+  lhs : Form
+  rhs : Form
+
+structure State where
+  rows : RowIndex → Row
+  cost : Form
+  remaining : Var → Prop
+
+def wellFormed (s : State) : Prop := ∀ j, ¬ s.remaining j →
+  s.cost (column j) = ⊥ ∧ ∀ i,
+    (s.rows i).lhs (column j) = ⊥ ∧ (s.rows i).rhs (column j) = ⊥
+
+def eval (f : Form) (w : Fin 3 → ℝ) : Coeff :=
+  max (f 0 + (w 0 : Coeff)) (max (f 1 + (w 1 : Coeff)) (f 2 + (w 2 : Coeff)))
+
+def feasible (s : State) (w : Fin 3 → ℝ) : Prop :=
+  ∀ i, eval (s.rows i).rhs w ≤ eval (s.rows i).lhs w
+
+def lower (s : State) (i : RowIndex) (j : Var) : Prop :=
+  (s.rows i).lhs (column j) ≠ ⊥ ∧
+    (s.rows i).rhs (column j) < (s.rows i).lhs (column j)
+
+def upper (s : State) (i : RowIndex) (j : Var) : Prop :=
+  (s.rows i).rhs (column j) ≠ ⊥ ∧
+    (s.rows i).lhs (column j) < (s.rows i).rhs (column j)
+
+def dominating (s : State) (j : Var) : Prop :=
+  s.remaining j ∧ (∃ i, lower s i j) ∧ ∃ i, upper s i j
+
+def eligible (s : State) (i : RowIndex) (j : Var) : Prop :=
+  s.remaining j ∧ lower s i j ∧ ((∃ k, dominating s k) → dominating s j)
+
+def bounded (s : State) : Prop :=
+  ∀ j, s.remaining j → (∃ i, lower s i j) ∨ ∃ i, upper s i j
+
+def stop (s : State) : Prop := ∀ i, (s.rows i).rhs 2 ≤ (s.rows i).lhs 2
+
+def switch (s : State) : Prop :=
+  (∀ j, s.remaining j → s.cost (column j) = ⊥) ∧ ¬ stop s ∧
+  (∃ j, s.remaining j) ∧
+  (¬ ∃ i j, s.remaining j ∧ lower s i j) ∧
+  ∃ i j, s.remaining j ∧ upper s i j
+
+def failure (s : State) : Prop := ¬ stop s ∧
+  ((¬ ∃ j, s.remaining j) ∨
+   ((¬ ∃ i j, s.remaining j ∧ lower s i j) ∧
+    (¬ ∃ i j, s.remaining j ∧ upper s i j)))
+
+def lowerForm (s : State) (i : RowIndex) (j : Var) : Form := fun k =>
+  if k = column j then ⊥ else
+    (s.rows i).rhs k + ((-WithBot.unbotD 0 ((s.rows i).lhs (column j)) : ℝ) : Coeff)
+
+def substitute (f : Form) (j : Var) (g : Form) : Form := fun k =>
+  if k = column j then ⊥ else max (f k) (f (column j) + g k)
+
+def cleanup (r : Row) : Row := by
+  classical
+  exact if ∀ k, r.rhs k ≤ r.lhs k then ⟨nullForm, nullForm⟩ else r
+
+def advance (s : State) (i : RowIndex) (j : Var) : State where
+  rows := fun r => cleanup ⟨substitute (s.rows r).lhs j (lowerForm s i j),
+    substitute (s.rows r).rhs j (lowerForm s i j)⟩
+  cost := substitute s.cost j (lowerForm s i j)
+  remaining := fun k => s.remaining k ∧ k ≠ j
+
+def ForcedSingletonStep (s s' : State) (i : RowIndex) (j : Var) : Prop :=
+  wellFormed s ∧ wellFormed s' ∧
+  bounded s ∧ ¬ stop s ∧ ¬ switch s ∧ ¬ failure s ∧
+  (∀ r k, eligible s r k ↔ r = i ∧ k = j) ∧
+  (∃ k, (substitute s.cost j (lowerForm s i j)) k ≠ ⊥) ∧
+  s' = advance s i j
+
+def initial : State where
+  rows := ![⟨![(0 : Coeff), 0, ⊥], ![⊥, ⊥, (0 : Coeff)]⟩,
+    ⟨![(0 : Coeff), ⊥, ⊥], ![⊥, (1 : Coeff), ((-2 : ℝ) : Coeff)]⟩]
+  cost := ![(0 : Coeff), ⊥, ⊥]
+  remaining := fun _ => True
+
+def middle : State where
+  rows := ![⟨nullForm, nullForm⟩,
+    ⟨![(0 : Coeff), ⊥, ⊥], ![⊥, ⊥, (1 : Coeff)]⟩]
+  cost := ![(0 : Coeff), ⊥, ⊥]
+  remaining := fun j => j = 0
+
+def finalState : State where
+  rows := fun _ => ⟨nullForm, nullForm⟩
+  cost := ![⊥, ⊥, (1 : Coeff)]
+  remaining := fun _ => False
+
+def crossRowRestriction (s : State) : Prop :=
+  ∀ i r : RowIndex, i ≠ r → ∀ α : ℝ, ∃ w : Fin 3 → ℝ,
+    eval (s.rows i).lhs w < (α : Coeff) + eval (s.rows r).rhs w
+
+def output : Fin 3 → ℝ := ![1, 0, 0]
+
+def better : Fin 3 → ℝ := ![0, -1, 0]
+
+theorem finite_execution_not_optimal :
+    crossRowRestriction initial ∧
+    ForcedSingletonStep initial middle 0 1 ∧
+    ForcedSingletonStep middle finalState 1 0 ∧
+    (¬ ∃ j, finalState.remaining j) ∧ stop finalState ∧
+    feasible initial output ∧ feasible initial better ∧
+    output 2 = 0 ∧ better 2 = 0 ∧
+    (output 1 : Coeff) = eval (lowerForm initial 0 1) output ∧
+    (output 0 : Coeff) = eval (lowerForm middle 1 0) output ∧
+    eval initial.cost output = eval finalState.cost output ∧
+    eval initial.cost better < eval finalState.cost output := by
+  sorry
+
+end TruffetV4Counterexample
+end
+
+end OAI
diff --git a/lean/ComparatorChallenges/TwoWayComplementation.json b/lean/ComparatorChallenges/TwoWayComplementation.json
new file mode 100644
index 0000000000000000000000000000000000000000..0c7fe26768a254f5e5e7828a18ecefb1fd718e0f
--- /dev/null
+++ b/lean/ComparatorChallenges/TwoWayComplementation.json
@@ -0,0 +1,14 @@
+{
+  "challenge_module": "ComparatorChallenges.TwoWayComplementation",
+  "solution_module": "OAI.Combinatorics.TwoWayAutomata.Main",
+  "theorem_names": [
+    "OAI.TwoWayComplementation.complementation_lower_bound_finite"
+  ],
+  "definition_names": [],
+  "permitted_axioms": [
+    "propext",
+    "Quot.sound",
+    "Classical.choice"
+  ],
+  "enable_nanoda": false
+}
diff --git a/lean/ComparatorChallenges/TwoWayComplementation.lean b/lean/ComparatorChallenges/TwoWayComplementation.lean
new file mode 100644
index 0000000000000000000000000000000000000000..ebe79e3b2e67e516225f5d498f92d1fcb8e7a73c
--- /dev/null
+++ b/lean/ComparatorChallenges/TwoWayComplementation.lean
@@ -0,0 +1,45 @@
+import Mathlib
+
+namespace OAI
+
+namespace TwoWayComplementation
+
+open scoped SetRel
+
+def relStar {α : Type*} (R : SetRel α α) : SetRel α α :=
+  {(x, y) | Relation.ReflTransGen (fun a b => (a, b) ∈ R) x y}
+
+structure TwoNFA (Sigma Q : Type*) where
+  initial : Q
+  accepting : Set Q
+  transition : Q → (Fin 2 ⊕ Sigma) → Set (Q × Fin 3)
+
+def tapeSymbol {Sigma : Type*} (w : List Sigma) (p : Fin (w.length + 2)) : Fin 2 ⊕ Sigma :=
+  if hleft : p.val = 0 then .inl 0
+  else if hright : p.val = w.length + 1 then .inl 1
+  else .inr (w[p.val - 1]'(by omega))
+
+namespace TwoNFA
+
+def step {Sigma Q : Type*} (A : TwoNFA Sigma Q) (w : List Sigma) :
+    SetRel (Q × Fin (w.length + 2)) (Q × Fin (w.length + 2)) :=
+  {(c, d) | ∃ move : Fin 3,
+    (d.1, move) ∈ A.transition c.1 (tapeSymbol w c.2) ∧
+    (d.2.val : ℤ) = (c.2.val : ℤ) + (move.val : ℤ) - 1}
+
+def language {Sigma Q : Type*} (A : TwoNFA Sigma Q) : Set (List Sigma) :=
+  {w | ∃ c, c.1 ∈ A.accepting ∧
+    ((A.initial, ⟨0, by omega⟩), c) ∈ relStar (A.step w)}
+
+end TwoNFA
+
+theorem complementation_lower_bound_finite (n : ℕ) (hn : 4 ≤ n) :
+    ∃ A : TwoNFA (SetRel (Fin (n - 2)) (Fin (n - 2))) (Fin n),
+      ∀ (Q : Type*) [Fintype Q], ∀ B : TwoNFA (SetRel (Fin (n - 2)) (Fin (n - 2))) Q,
+        B.language = A.languageᶜ →
+          (1 / 2 : ℝ) * 2 ^ ((n - 4) / 127) - 1 ≤ (Fintype.card Q : ℝ) := by
+  sorry
+
+end TwoWayComplementation
+
+end OAI
diff --git a/lean/ComparatorChallenges/TwoWayDeterminization.json b/lean/ComparatorChallenges/TwoWayDeterminization.json
new file mode 100644
index 0000000000000000000000000000000000000000..d46cc55595f3c3a741ed4a568a22992dabff831a
--- /dev/null
+++ b/lean/ComparatorChallenges/TwoWayDeterminization.json
@@ -0,0 +1,14 @@
+{
+  "challenge_module": "ComparatorChallenges.TwoWayDeterminization",
+  "solution_module": "OAI.Combinatorics.TwoWayAutomata.ExplicitFamily",
+  "theorem_names": [
+    "OAI.TwoWayComplementation.explicit_family_main"
+  ],
+  "definition_names": [],
+  "permitted_axioms": [
+    "propext",
+    "Classical.choice",
+    "Quot.sound"
+  ],
+  "enable_nanoda": false
+}
diff --git a/lean/ComparatorChallenges/TwoWayDeterminization.lean b/lean/ComparatorChallenges/TwoWayDeterminization.lean
new file mode 100644
index 0000000000000000000000000000000000000000..0c6f5f30cfa16122441e8a0ada4299aafddf972e
--- /dev/null
+++ b/lean/ComparatorChallenges/TwoWayDeterminization.lean
@@ -0,0 +1,73 @@
+import Mathlib
+
+namespace OAI
+
+namespace TwoWayComplementation
+
+open scoped SetRel
+
+/-- Reflexive transitive closure, including the empty path. -/
+def relStar {α : Type*} (R : SetRel α α) : SetRel α α :=
+  {(x, y) | Relation.ReflTransGen (fun a b => (a, b) ∈ R) x y}
+
+/-- A read-only 2NFA. The two endmarkers are `Sum.inl 0` and `Sum.inl 1`.
+    Move codes 0, 1, 2 mean left, stay, right. -/
+structure TwoNFA (Sigma Q : Type*) where
+  /-- The state in which the machine starts on the left endmarker. -/
+  initial : Q
+  /-- States whose occurrence on a finite run constitutes acceptance. -/
+  accepting : Set Q
+  /-- Allowed next-state and move pairs, determined by the state and scanned symbol. -/
+  transition : Q → (Fin 2 ⊕ Sigma) → Set (Q × Fin 3)
+
+/-- Tape lookup includes two distinct endmarkers, even on empty input. -/
+def tapeSymbol {Sigma : Type*} (w : List Sigma) (p : Fin (w.length + 2)) : Fin 2 ⊕ Sigma :=
+  if hleft : p.val = 0 then .inl 0
+  else if hright : p.val = w.length + 1 then .inl 1
+  else .inr (w[p.val - 1]'(by omega))
+
+namespace TwoNFA
+
+/-- One legal step: both head positions stay within the marked input. -/
+def step {Sigma Q : Type*} (A : TwoNFA Sigma Q) (w : List Sigma) :
+    SetRel (Q × Fin (w.length + 2)) (Q × Fin (w.length + 2)) :=
+  {(c, d) | ∃ move : Fin 3,
+    (d.1, move) ∈ A.transition c.1 (tapeSymbol w c.2) ∧
+    (d.2.val : ℤ) = (c.2.val : ℤ) + (move.val : ℤ) - 1}
+
+/-- Existential finite-run acceptance, allowing a run of length zero. -/
+def language {Sigma Q : Type*} (A : TwoNFA Sigma Q) : Set (List Sigma) :=
+  {w | ∃ c, c.1 ∈ A.accepting ∧
+    ((A.initial, ⟨0, by omega⟩), c) ∈ relStar (A.step w)}
+
+end TwoNFA
+
+/-- At most one next-state/move pair at every state and scanned symbol. -/
+def TwoNFA.Deterministic {Sigma Q : Type*} (A : TwoNFA Sigma Q) : Prop :=
+  ∀ q symbol, (A.transition q symbol).Subsingleton
+
+/-- Relation product for an input word; the empty product is the identity. -/
+def relationProduct {H : Type*} (w : List (SetRel H H)) : SetRel H H :=
+  w.foldr SetRel.comp SetRel.id
+
+/-- The source language consists of the words with nonempty relation product. -/
+def sourceLanguage (H : Type*) : Set (List (SetRel H H)) :=
+  {w | (relationProduct w).Nonempty}
+
+/-- Both lower bounds hold for the same n-state liveness witness. -/
+theorem explicit_family_main (n : ℕ) (hn : 4 ≤ n) :
+    ∃ A : TwoNFA (SetRel (Fin (n - 2)) (Fin (n - 2))) (Fin n),
+      A.language = sourceLanguage (Fin (n - 2)) ∧
+      (∀ (Q : Type*) [Fintype Q],
+        ∀ B : TwoNFA (SetRel (Fin (n - 2)) (Fin (n - 2))) Q,
+        B.language = A.languageᶜ →
+          (1 / 2 : ℝ) * 2 ^ ((n - 4) / 127) - 1 ≤ (Fintype.card Q : ℝ)) ∧
+      (131 ≤ n → ∀ (Q : Type*) [Fintype Q],
+        ∀ D : TwoNFA (SetRel (Fin (n - 2)) (Fin (n - 2))) Q,
+        D.Deterministic → D.language = A.language →
+          (1 / 2 : ℝ) * 2 ^ ((n - 4) / 127) ≤ (Fintype.card Q : ℝ)) := by
+  sorry
+
+end TwoWayComplementation
+
+end OAI
diff --git a/lean/ComparatorChallenges/TypeSystemNormalization.json b/lean/ComparatorChallenges/TypeSystemNormalization.json
new file mode 100644
index 0000000000000000000000000000000000000000..bf5560e0bac8bd34607aca29328e0e4db45d92bd
--- /dev/null
+++ b/lean/ComparatorChallenges/TypeSystemNormalization.json
@@ -0,0 +1,14 @@
+{
+  "challenge_module": "ComparatorChallenges.TypeSystemNormalization",
+  "solution_module": "OAI.Computability.TypeSystem.Normalization",
+  "theorem_names": [
+    "OAI.PureTypeSystem.weak_implies_strong"
+  ],
+  "definition_names": [],
+  "permitted_axioms": [
+    "propext",
+    "Quot.sound",
+    "Classical.choice"
+  ],
+  "enable_nanoda": false
+}
diff --git a/lean/ComparatorChallenges/TypeSystemNormalization.lean b/lean/ComparatorChallenges/TypeSystemNormalization.lean
new file mode 100644
index 0000000000000000000000000000000000000000..6a4260f96d16d6fb9821424b0d125de562d7e2b5
--- /dev/null
+++ b/lean/ComparatorChallenges/TypeSystemNormalization.lean
@@ -0,0 +1,122 @@
+import Mathlib
+
+namespace OAI
+
+/-!
+Full annotated PTS syntax, modulo alpha-renaming via de Bruijn indices.
+Contexts are stored newest-first, each declaration in its prefix context.
+No functionality assumptions on axioms or product rules.
+-/
+
+namespace PureTypeSystem
+
+universe u
+
+inductive Expr (Sorts : Type u) : Type u
+  | var : Nat → Expr Sorts
+  | sort : Sorts → Expr Sorts
+  | app : Expr Sorts → Expr Sorts → Expr Sorts
+  | lam : Expr Sorts → Expr Sorts → Expr Sorts
+  | pi : Expr Sorts → Expr Sorts → Expr Sorts
+  deriving DecidableEq
+
+namespace Expr
+
+variable {S : Type u}
+
+def liftRen (ρ : Nat → Nat) : Nat → Nat
+  | 0 => 0
+  | n + 1 => ρ n + 1
+
+def rename (ρ : Nat → Nat) : Expr S → Expr S
+  | var n => var (ρ n)
+  | sort s => sort s
+  | app f a => app (rename ρ f) (rename ρ a)
+  | lam A b => lam (rename ρ A) (rename (liftRen ρ) b)
+  | pi A B => pi (rename ρ A) (rename (liftRen ρ) B)
+
+def liftSub (σ : Nat → Expr S) : Nat → Expr S
+  | 0 => var 0
+  | n + 1 => rename Nat.succ (σ n)
+
+def subst (σ : Nat → Expr S) : Expr S → Expr S
+  | var n => σ n
+  | sort s => sort s
+  | app f a => app (subst σ f) (subst σ a)
+  | lam A b => lam (subst σ A) (subst (liftSub σ) b)
+  | pi A B => pi (subst σ A) (subst (liftSub σ) B)
+
+def single (a : Expr S) : Nat → Expr S
+  | 0 => a
+  | n + 1 => var n
+
+def instantiate (b a : Expr S) : Expr S := subst (single a) b
+
+end Expr
+
+structure Specification (S : Type u) where
+  axioms : S → S → Prop
+  rule : S → S → S → Prop
+
+inductive Beta {S : Type u} : Expr S → Expr S → Prop
+  | head (A b a) : Beta (.app (.lam A b) a) (b.instantiate a)
+  | app_left {f f' a} : Beta f f' → Beta (.app f a) (.app f' a)
+  | app_right {f a a'} : Beta a a' → Beta (.app f a) (.app f a')
+  | lam_domain {A A' b} : Beta A A' → Beta (.lam A b) (.lam A' b)
+  | lam_body {A b b'} : Beta b b' → Beta (.lam A b) (.lam A b')
+  | pi_domain {A A' B} : Beta A A' → Beta (.pi A B) (.pi A' B)
+  | pi_body {A B B'} : Beta B B' → Beta (.pi A B) (.pi A B')
+
+def Converts {S : Type u} : Expr S → Expr S → Prop := Relation.EqvGen Beta
+
+def Normal {S : Type u} (M : Expr S) : Prop := ∀ N, ¬ Beta M N
+
+def WeaklyNormalizing {S : Type u} (M : Expr S) : Prop :=
+  ∃ N, Relation.ReflTransGen Beta M N ∧ Normal N
+
+/-- Accessibility for the converse of reduction: strong normalization,
+including reductions in all type annotations. -/
+def StronglyNormalizing {S : Type u} (M : Expr S) : Prop :=
+  Acc (fun N M : Expr S => Beta M N) M
+
+inductive HasType {S : Type u} (P : Specification S) :
+    List (Expr S) → Expr S → Expr S → Prop
+  | ax {s t} : P.axioms s t → HasType P [] (.sort s) (.sort t)
+  | var {Γ A s} : HasType P Γ A (.sort s) →
+      HasType P (A :: Γ) (.var 0) (A.rename Nat.succ)
+  | weaken {Γ M B A s} : HasType P Γ M B → HasType P Γ A (.sort s) →
+      HasType P (A :: Γ) (M.rename Nat.succ) (B.rename Nat.succ)
+  | product {Γ A B s₁ s₂ s₃} : HasType P Γ A (.sort s₁) →
+      HasType P (A :: Γ) B (.sort s₂) → P.rule s₁ s₂ s₃ →
+      HasType P Γ (.pi A B) (.sort s₃)
+  | abstraction {Γ A b B s} : HasType P (A :: Γ) b B →
+      HasType P Γ (.pi A B) (.sort s) →
+      HasType P Γ (.lam A b) (.pi A B)
+  | application {Γ f a A B} : HasType P Γ f (.pi A B) →
+      HasType P Γ a A → HasType P Γ (.app f a) (B.instantiate a)
+  | conversion {Γ M A B s} : HasType P Γ M A → HasType P Γ B (.sort s) →
+      Converts A B → HasType P Γ M B
+
+inductive ValidContext {S : Type u} (P : Specification S) : List (Expr S) → Prop
+  | nil : ValidContext P []
+  | cons {Γ A s} : ValidContext P Γ → HasType P Γ A (.sort s) →
+      ValidContext P (A :: Γ)
+
+def Legal {S : Type u} (P : Specification S) (Γ : List (Expr S)) (M : Expr S) : Prop :=
+  ∃ A, HasType P Γ M A ∨ HasType P Γ A M
+
+def SystemWeaklyNormalizing {S : Type u} (P : Specification S) : Prop :=
+  ∀ Γ, ValidContext P Γ → ∀ M, Legal P Γ M → WeaklyNormalizing M
+
+def SystemStronglyNormalizing {S : Type u} (P : Specification S) : Prop :=
+  ∀ Γ, ValidContext P Γ → ∀ M, Legal P Γ M → StronglyNormalizing M
+
+/-- System-wide weak normalization implies strong normalization for every PTS,
+including arbitrary sort types, nonfunctional rules and annotated terms. -/
+theorem weak_implies_strong {S : Type u} (P : Specification S)
+    (h : SystemWeaklyNormalizing P) : SystemStronglyNormalizing P := by
+  sorry
+
+end PureTypeSystem
+
+end OAI
diff --git a/lean/ComparatorChallenges/UniformCommutator.json b/lean/ComparatorChallenges/UniformCommutator.json
new file mode 100644
index 0000000000000000000000000000000000000000..529a975903d43e2c277da537047d08d840ecd81a
--- /dev/null
+++ b/lean/ComparatorChallenges/UniformCommutator.json
@@ -0,0 +1,14 @@
+{
+  "challenge_module": "ComparatorChallenges.UniformCommutator",
+  "solution_module": "OAI.Analysis.Commutator.Main",
+  "theorem_names": [
+    "OAI.Kadison.uniform_commutator"
+  ],
+  "definition_names": [],
+  "permitted_axioms": [
+    "propext",
+    "Quot.sound",
+    "Classical.choice"
+  ],
+  "enable_nanoda": false
+}
diff --git a/lean/ComparatorChallenges/UniformCommutator.lean b/lean/ComparatorChallenges/UniformCommutator.lean
new file mode 100644
index 0000000000000000000000000000000000000000..f94d114e9d34bcd0def15bff6af942d8a40a0643
--- /dev/null
+++ b/lean/ComparatorChallenges/UniformCommutator.lean
@@ -0,0 +1,40 @@
+import Mathlib
+
+namespace OAI
+
+noncomputable section
+universe u v
+namespace Kadison
+
+variable {K : Type u} [NormedAddCommGroup K] [InnerProductSpace ℂ K]
+  [CompleteSpace K]
+
+def commutatorSeminorm (P : VonNeumannAlgebra K) (Y : K →L[ℂ] K) : ℝ :=
+  sSup {r : ℝ | ∃ a : K →L[ℂ] K, a ∈ P ∧ ‖a‖ ≤ 1 ∧ r = ‖Y * a - a * Y‖}
+
+def matrixOperator (h : ℕ) (X : Matrix (Fin h) (Fin h) (K →L[ℂ] K)) :
+    (PiLp 2 fun _ : Fin h => K) →L[ℂ] (PiLp 2 fun _ : Fin h => K) :=
+  (PiLp.continuousLinearEquiv 2 ℂ (fun _ : Fin h => K)).symm.toContinuousLinearMap.comp
+    (ContinuousLinearMap.pi (fun i => ∑ j : Fin h,
+      (X i j).comp (PiLp.proj 2 (fun _ : Fin h => K) j)))
+
+def diagonalAmplification (h : ℕ) (Y : K →L[ℂ] K) :
+    (PiLp 2 fun _ : Fin h => K) →L[ℂ] (PiLp 2 fun _ : Fin h => K) :=
+  (PiLp.continuousLinearEquiv 2 ℂ (fun _ : Fin h => K)).symm.toContinuousLinearMap.comp
+    (ContinuousLinearMap.pi (fun i => Y.comp (PiLp.proj 2 (fun _ : Fin h => K) i)))
+
+theorem uniform_commutator :
+    ∃ C : ℝ, 0 ≤ C ∧ ∀ (K : Type u) [NormedAddCommGroup K] [InnerProductSpace ℂ K]
+      [CompleteSpace K] (P : VonNeumannAlgebra K) (Y : K →L[ℂ] K)
+      (h : ℕ), 1 ≤ h → ∀ (X : Matrix (Fin h) (Fin h) (K →L[ℂ] K)),
+      (∀ i j, X i j ∈ P) →
+      ‖diagonalAmplification h Y * matrixOperator h X -
+        matrixOperator h X * diagonalAmplification h Y‖ ≤
+        C * commutatorSeminorm P Y * ‖matrixOperator h X‖ := by
+  sorry
+
+end Kadison
+
+end
+
+end OAI
diff --git a/lean/ComparatorChallenges/UniformGamma.json b/lean/ComparatorChallenges/UniformGamma.json
new file mode 100644
index 0000000000000000000000000000000000000000..edf4f8b90fb40afa1a72c5c5e309e36416bc0ecb
--- /dev/null
+++ b/lean/ComparatorChallenges/UniformGamma.json
@@ -0,0 +1,14 @@
+{
+  "challenge_module": "ComparatorChallenges.UniformGamma",
+  "solution_module": "OAI.Analysis.TracialSplitting.Challenge",
+  "theorem_names": [
+    "OAI.ComparatorModel.CurrentMain.main"
+  ],
+  "definition_names": [],
+  "permitted_axioms": [
+    "propext",
+    "Quot.sound",
+    "Classical.choice"
+  ],
+  "enable_nanoda": false
+}
diff --git a/lean/ComparatorChallenges/UniformGamma.lean b/lean/ComparatorChallenges/UniformGamma.lean
new file mode 100644
index 0000000000000000000000000000000000000000..7ca382715b35db791e19c4c7dccce01de8948a0d
--- /dev/null
+++ b/lean/ComparatorChallenges/UniformGamma.lean
@@ -0,0 +1,607 @@
+import Mathlib
+
+namespace OAI
+
+noncomputable section
+
+/-!
+The final claim constructs the tracial quotients and states the original gamma assertion.
+`Analysis.TracialSplitting.Challenge.main_iff_original` verifies statement preservation.
+-/
+
+universe uA uD uE uI uR uX u v
+
+namespace Pureness
+
+open scoped ComplexOrder
+
+structure CStarAlgebraNorm (R : Type uR) [Ring R] [StarRing R] [Algebra ℂ R]
+    extends AlgebraNorm ℂ R where
+  cstar : ∀ x, toAlgebraNorm (star x * x) = toAlgebraNorm x * toAlgebraNorm x
+
+structure TracialState (A : Type uA) [CStarAlgebra A] [PartialOrder A] where
+  functional : A →ₚ[ℂ] ℂ
+  normalized : functional 1 = 1
+  tracial : ∀ a b : A, functional (a * b) = functional (b * a)
+
+structure ClosedStarIdeal (D : Type uD) [CStarAlgebra D] where
+  ideal : TwoSidedIdeal D
+  star_mem : ∀ {u : D}, u ∈ ideal → star u ∈ ideal
+  isClosed : IsClosed (ideal : Set D)
+
+end Pureness
+
+universe uNuclear
+
+namespace ComparatorModel
+
+namespace Pureness
+
+open scoped TensorProduct ComplexOrder
+
+abbrev CStarAlgebraNorm := @_root_.OAI.Pureness.CStarAlgebraNorm
+
+def IsNuclear (A : Type u) [CStarAlgebra A] : Prop :=
+  ∀ (B : Type v) [CStarAlgebra B], Subsingleton (CStarAlgebraNorm (A ⊗[ℂ] B))
+
+abbrev TracialState := @_root_.OAI.Pureness.TracialState
+
+end Pureness
+
+namespace CurrentMain
+
+open _root_.OAI.ComparatorModel.Pureness
+
+open scoped ComplexOrder
+
+def RealRankZero (D : Type) [CStarAlgebra D] : Prop :=
+  ∀ a : D, IsSelfAdjoint a → ∀ ε : ℝ, 0 < ε →
+    ∃ b : D, IsSelfAdjoint b ∧ (spectrum ℂ b).Finite ∧ ‖a - b‖ < ε
+
+def traceTwoNorm {D : Type} [CStarAlgebra D] [PartialOrder D]
+    (τ : TracialState D) (a : D) : ℝ :=
+  Real.sqrt (τ.functional (star a * a)).re
+
+end CurrentMain
+
+section
+
+open Filter
+
+open scoped Topology NNReal ENNReal
+
+abbrev Pureness.ClosedStarIdeal := @_root_.OAI.Pureness.ClosedStarIdeal
+
+namespace Pureness.ClosedStarIdeal
+
+section
+
+variable {D : Type} [CStarAlgebra D] (J : ClosedStarIdeal D)
+
+abbrev Quotient := J.ideal.ringCon.Quotient
+
+def quotientMap : D →ₐ[ℂ] J.Quotient := J.ideal.ringCon.mkₐ ℂ
+
+instance quotientStar : Star (J.Quotient) where
+  star := Quotient.map' star (by
+    intro u v h
+    change J.ideal.ringCon u v at h
+    change J.ideal.ringCon (star u) (star v)
+    rw [TwoSidedIdeal.rel_iff] at h ⊢
+    simpa only [star_sub] using J.star_mem h)
+
+instance quotientStarRing : StarRing (J.Quotient) where
+  star_involutive x := Quotient.inductionOn' x (fun u => congrArg J.quotientMap (star_star u))
+  star_mul x y := Quotient.inductionOn₂' x y (fun u v => congrArg J.quotientMap (star_mul u v))
+  star_add x y := Quotient.inductionOn₂' x y (fun u v => congrArg J.quotientMap (star_add u v))
+
+instance quotientStarModule : StarModule ℂ (J.Quotient) where
+  star_smul c x := Quotient.inductionOn' x (fun u => congrArg J.quotientMap (star_smul c u))
+
+abbrev idealSubmodule : Submodule ℂ (D) :=
+  (J.quotientMap).toLinearMap.ker
+
+instance idealSubmodule_closed : IsClosed (J.idealSubmodule : Set D) := by
+  have he : (J.idealSubmodule : Set D) = (J.ideal : Set D) := by
+    ext u
+    change J.ideal.ringCon.mk' u = J.ideal.ringCon.mk' 0 ↔ u ∈ J.ideal
+    exact Quotient.eq
+  rw [he]
+  exact J.isClosed
+
+def quotientLinearEquiv :
+    (D ⧸ J.idealSubmodule) ≃ₗ[ℂ] J.Quotient :=
+  (J.quotientMap).toLinearMap.quotKerEquivOfSurjective ((J.ideal.ringCon.mkₐ_surjective (α := ℂ)))
+
+instance quotientNormedAddCommGroup : NormedAddCommGroup (J.Quotient) :=
+  NormedAddCommGroup.induced _ _ (J.quotientLinearEquiv).symm
+    (J.quotientLinearEquiv).symm.injective
+
+instance quotientNormedSpace : NormedSpace ℂ (J.Quotient) :=
+  NormedSpace.induced ℂ _ _ (J.quotientLinearEquiv).symm
+
+def quotientNormEquiv : J.Quotient ≃ₗᵢ[ℂ]
+    (D ⧸ J.idealSubmodule) where
+  __ := (J.quotientLinearEquiv).symm
+  norm_map' _ := rfl
+
+instance quotientCompleteSpace : CompleteSpace (J.Quotient) :=
+  (J.quotientNormEquiv).toIsometryEquiv.completeSpace_iff.mpr inferInstance
+
+class NormConstruction : Prop where
+  mul_le : ∀ {D : Type} [CStarAlgebra D] (J : ClosedStarIdeal D) (x y : J.Quotient),
+    ‖x*y‖ ≤ ‖x‖*‖y‖
+  star_eq : ∀ {D : Type} [CStarAlgebra D] (J : ClosedStarIdeal D) (x : J.Quotient),
+    ‖star x‖ = ‖x‖
+  square_le : ∀ {D : Type} [CStarAlgebra D] [PartialOrder D] [StarOrderedRing D]
+    (J : ClosedStarIdeal D) (x : J.Quotient), ‖x‖ * ‖x‖ ≤ ‖star x * x‖
+
+variable [ComparatorModel.Pureness.ClosedStarIdeal.NormConstruction]
+
+instance quotientNormedRing : NormedRing (J.Quotient) where
+  dist_eq := dist_eq_norm_neg_add
+  norm_mul_le := NormConstruction.mul_le J
+
+instance quotientNormedAlgebra : NormedAlgebra ℂ (J.Quotient) where
+  norm_smul_le := norm_smul_le
+
+instance quotientNormedStarGroup : NormedStarGroup (J.Quotient) where
+  norm_star_le x := (NormConstruction.star_eq J x).le
+
+end
+
+open Filter
+
+open scoped Topology NNReal ENNReal
+
+variable {D : Type} [CStarAlgebra D] [PartialOrder D] [StarOrderedRing D]
+
+variable (J : ClosedStarIdeal D)
+
+variable [ComparatorModel.Pureness.ClosedStarIdeal.NormConstruction]
+
+instance quotientCStarAlgebra : CStarAlgebra (J.Quotient) where
+  norm_mul_self_le := NormConstruction.square_le J
+
+end Pureness.ClosedStarIdeal
+
+end
+
+section
+
+open _root_.OAI.ComparatorModel.Pureness
+
+section UniformTraceNorm
+
+variable {D : Type} {I : Type} [CStarAlgebra D] [PartialOrder D] [StarOrderedRing D]
+
+variable (τ : I → TracialState D) [Nonempty I]
+
+variable [ComparatorModel.Pureness.ClosedStarIdeal.NormConstruction]
+
+def CurrentMain.familyTwoNorm (a : D) : ℝ := ⨆ i, traceTwoNorm (τ i) a
+
+end UniformTraceNorm
+
+open _root_.OAI.ComparatorModel.Pureness Filter
+
+open scoped Topology NNReal ENNReal
+
+variable [ComparatorModel.Pureness.ClosedStarIdeal.NormConstruction]
+
+instance CurrentMain.boundedFamilyProductCStar {X : Type} {D : Type} [CStarAlgebra D] [Nontrivial D] :
+    CStarAlgebra (lp (fun _ : X => D) ∞) where
+
+section UniformNull
+
+variable {D : Type} {I : Type} {X : Type} [CStarAlgebra D] [PartialOrder D] [StarOrderedRing D]
+
+variable (τ : I → TracialState D) [Nonempty I]
+
+def CurrentMain.IsFamilyNull (F : Filter X) (u : X → D) : Prop :=
+  Tendsto (fun n => familyTwoNorm τ (u n)) F (𝓝 0)
+
+class CurrentMain.NullConstruction : Prop where
+  zero : ∀ {D I X : Type} [CStarAlgebra D] [PartialOrder D] [StarOrderedRing D] (τ : I → Pureness.TracialState D) [Nonempty I]
+    (F : Filter X), IsFamilyNull τ F (fun _ => 0)
+  add : ∀ {D I X : Type} [CStarAlgebra D] [PartialOrder D] [StarOrderedRing D] (τ : I → Pureness.TracialState D) [Nonempty I]
+    {F : Filter X} {u v : X → D}, IsFamilyNull τ F u → IsFamilyNull τ F v →
+    IsFamilyNull τ F (fun n => u n + v n)
+  neg : ∀ {D I X : Type} [CStarAlgebra D] [PartialOrder D] [StarOrderedRing D] (τ : I → Pureness.TracialState D) [Nonempty I]
+    {F : Filter X} {u : X → D}, IsFamilyNull τ F u → IsFamilyNull τ F (fun n => -u n)
+  star : ∀ {D I X : Type} [CStarAlgebra D] [PartialOrder D] [StarOrderedRing D] (τ : I → Pureness.TracialState D) [Nonempty I]
+    {F : Filter X} {u : X → D}, IsFamilyNull τ F u → IsFamilyNull τ F (fun n => star (u n))
+  mul_left : ∀ {D I X : Type} [CStarAlgebra D] [PartialOrder D] [StarOrderedRing D] (τ : I → Pureness.TracialState D) [Nonempty I]
+    {F : Filter X} {u v : X → D}, IsFamilyNull τ F v → ∀ {M : ℝ},
+    (∀ n, ‖u n‖ ≤ M) → IsFamilyNull τ F (fun n => u n * v n)
+  mul_right : ∀ {D I X : Type} [CStarAlgebra D] [PartialOrder D] [StarOrderedRing D] (τ : I → Pureness.TracialState D) [Nonempty I]
+    {F : Filter X} {u v : X → D}, IsFamilyNull τ F u → ∀ {M : ℝ},
+    (∀ n, ‖v n‖ ≤ M) → IsFamilyNull τ F (fun n => u n * v n)
+  closed : ∀ {D I X : Type} [CStarAlgebra D] [PartialOrder D] [StarOrderedRing D] (τ : I → Pureness.TracialState D) [Nonempty I] (F : Filter X),
+    IsClosed {u : lp (fun _ : X => D) ∞ | IsFamilyNull τ F (fun n => u n)}
+
+variable [Nontrivial D]
+
+variable [ComparatorModel.CurrentMain.NullConstruction]
+
+def CurrentMain.familyNullTwoSided (F : Filter X) : TwoSidedIdeal (lp (fun _ : X => D) ∞) :=
+  TwoSidedIdeal.mk' {u | IsFamilyNull τ F (fun n => u n)}
+    (NullConstruction.zero τ F)
+    (fun hu hv => NullConstruction.add τ hu hv)
+    (fun hu => NullConstruction.neg τ hu)
+    (fun {u _} hv => NullConstruction.mul_left τ hv
+      (lp.norm_apply_le_norm ENNReal.top_ne_zero u))
+    (fun {_ v} hu => NullConstruction.mul_right τ hu
+      (lp.norm_apply_le_norm ENNReal.top_ne_zero v))
+
+def CurrentMain.familyNullIdeal (F : Filter X) : ClosedStarIdeal (lp (fun _ : X => D) ∞) where
+  ideal := familyNullTwoSided τ F
+  star_mem := by
+    intro u hu
+    apply (TwoSidedIdeal.mem_mk' _ _ _ _ _ _ (star u)).mpr
+    exact NullConstruction.star τ ((TwoSidedIdeal.mem_mk' _ _ _ _ _ _ u).mp hu)
+  isClosed := by
+    have he : (familyNullTwoSided τ F : Set (lp (fun _ : X => D) ∞)) =
+        {u | IsFamilyNull τ F (fun n => u n)} := by
+      ext u
+      exact TwoSidedIdeal.mem_mk' _ _ _ _ _ _ u
+    rw [he]
+    exact NullConstruction.closed τ F
+
+end UniformNull
+
+variable {D : Type} {I : Type} [CStarAlgebra D] [PartialOrder D] [StarOrderedRing D]
+
+variable (τ : I → TracialState D) [Nonempty I]
+
+variable [ComparatorModel.CurrentMain.NullConstruction]
+
+def CurrentMain.IsFamilyCauchy (u : ℕ → D) : Prop :=
+  IsFamilyNull τ (atTop : Filter (ℕ × ℕ)) (fun p => u p.1 - u p.2)
+
+class CurrentMain.CauchyConstruction : Prop where
+  const : ∀ {D I : Type} [CStarAlgebra D] [PartialOrder D] [StarOrderedRing D]
+    (τ : I → Pureness.TracialState D) [Nonempty I] (a : D), IsFamilyCauchy τ (fun _ => a)
+  add : ∀ {D I : Type} [CStarAlgebra D] [PartialOrder D] [StarOrderedRing D]
+    (τ : I → Pureness.TracialState D) [Nonempty I] {u v : ℕ → D},
+    IsFamilyCauchy τ u → IsFamilyCauchy τ v → IsFamilyCauchy τ (fun n => u n+v n)
+  star : ∀ {D I : Type} [CStarAlgebra D] [PartialOrder D] [StarOrderedRing D]
+    (τ : I → Pureness.TracialState D) [Nonempty I] {u : ℕ → D},
+    IsFamilyCauchy τ u → IsFamilyCauchy τ (fun n => star (u n))
+  mul : ∀ {D I : Type} [CStarAlgebra D] [PartialOrder D] [StarOrderedRing D]
+    (τ : I → Pureness.TracialState D) [Nonempty I] {u v : ℕ → D},
+    IsFamilyCauchy τ u → IsFamilyCauchy τ v → ∀ {M N : ℝ},
+    (∀ n, ‖u n‖ ≤ M) → (∀ n, ‖v n‖ ≤ N) → IsFamilyCauchy τ (fun n => u n*v n)
+  closed : ∀ {D I : Type} [CStarAlgebra D] [PartialOrder D] [StarOrderedRing D]
+    (τ : I → Pureness.TracialState D) [Nonempty I] [Nontrivial D],
+    IsClosed {u : lp (fun _ : ℕ => D) ∞ | IsFamilyCauchy τ (fun n => u n)}
+
+variable [Nontrivial D]
+
+variable [ComparatorModel.CurrentMain.CauchyConstruction]
+
+def CurrentMain.familyCauchyAlgebra : StarSubalgebra ℂ (lp (fun _ : ℕ => D) ∞) where
+  carrier := {u | IsFamilyCauchy τ (fun n => u n)}
+  zero_mem' := CauchyConstruction.const τ 0
+  one_mem' := CauchyConstruction.const τ 1
+  add_mem' hu hv := CauchyConstruction.add τ hu hv
+  mul_mem' {u v} hu hv := CauchyConstruction.mul τ hu hv
+    (lp.norm_apply_le_norm ENNReal.top_ne_zero u)
+    (lp.norm_apply_le_norm ENNReal.top_ne_zero v)
+  algebraMap_mem' z := CauchyConstruction.const τ (algebraMap ℂ D z)
+  star_mem' hu := CauchyConstruction.star τ hu
+
+instance CurrentMain.familyCauchy_complete : CompleteSpace (familyCauchyAlgebra τ) :=
+  (CauchyConstruction.closed τ).completeSpace_coe
+
+instance CurrentMain.familyCauchy_cstar : CStarAlgebra (familyCauchyAlgebra τ) where
+
+def CurrentMain.familyCauchyNullIdeal : ClosedStarIdeal (familyCauchyAlgebra τ) where
+  ideal := TwoSidedIdeal.comap (familyCauchyAlgebra τ).val.toRingHom
+    (familyNullIdeal τ atTop).ideal
+  star_mem := by
+    intro u hu
+    apply (familyNullIdeal τ atTop).star_mem hu
+  isClosed := by
+    exact (familyNullIdeal τ atTop).isClosed.preimage
+      (continuous_subtype_val : Continuous (fun u : familyCauchyAlgebra τ => u.1))
+
+abbrev CurrentMain.UniformTracialCompletion := (familyCauchyNullIdeal τ).Quotient
+
+end
+
+section
+
+open scoped ComplexOrder
+
+variable {D : Type} [CStarAlgebra D] [PartialOrder D] [StarOrderedRing D]
+
+variable [ComparatorModel.Pureness.ClosedStarIdeal.NormConstruction] [ComparatorModel.CurrentMain.NullConstruction] [ComparatorModel.CurrentMain.CauchyConstruction]
+
+instance Pureness.ClosedStarIdeal.quotientOrder (J : ClosedStarIdeal D) : PartialOrder J.Quotient :=
+  CStarAlgebra.spectralOrder _
+
+instance Pureness.ClosedStarIdeal.quotientStarOrdered (J : ClosedStarIdeal D) : StarOrderedRing J.Quotient :=
+  CStarAlgebra.spectralOrderedRing _
+
+variable (J : Pureness.ClosedStarIdeal D)
+
+variable (τ : Pureness.TracialState D) (hτ : ∀ a ∈ J.ideal, τ.functional a = 0)
+
+def Pureness.ClosedStarIdeal.descendedValue : J.Quotient → ℂ := Quotient.lift τ.functional (by
+  intro u v huv
+  change J.ideal.ringCon u v at huv
+  rw [TwoSidedIdeal.rel_iff] at huv
+  have h := hτ (u-v) huv
+  rw [map_sub, sub_eq_zero] at h
+  exact h)
+
+def Pureness.ClosedStarIdeal.descendedLinear : J.Quotient →ₗ[ℂ] ℂ where
+  toFun := J.descendedValue τ hτ
+  map_add' x y := Quotient.inductionOn₂' x y (fun u v => τ.functional.map_add u v)
+  map_smul' c x := Quotient.inductionOn' x (fun u => τ.functional.map_smul c u)
+
+def Pureness.ClosedStarIdeal.descendedTrace : TracialState J.Quotient where
+  functional := { J.descendedLinear τ hτ with
+    monotone' := by
+      intro x y hxy
+      apply sub_nonneg.mp
+      change 0 ≤ J.descendedLinear τ hτ y - J.descendedLinear τ hτ x
+      rw [← map_sub]
+      obtain ⟨z,hz⟩ := CStarAlgebra.nonneg_iff_eq_star_mul_self.mp (sub_nonneg.mpr hxy)
+      rw [hz]
+      induction z using Quotient.inductionOn' with
+      | h u => exact τ.functional.map_nonneg (star_mul_self_nonneg u) }
+  normalized := τ.normalized
+  tracial x y := Quotient.inductionOn₂' x y (fun u v => τ.tracial u v)
+
+end
+
+section
+
+open _root_.OAI.ComparatorModel.Pureness Filter
+
+open scoped Topology NNReal ENNReal ComplexOrder
+
+section UltraTrace
+
+variable {D : Type} {X : Type} [CStarAlgebra D] [PartialOrder D] [StarOrderedRing D] [Nontrivial D]
+
+variable (θ : X → TracialState D) (U : Ultrafilter X)
+
+variable [ComparatorModel.Pureness.ClosedStarIdeal.NormConstruction] [ComparatorModel.CurrentMain.NullConstruction] [ComparatorModel.CurrentMain.CauchyConstruction]
+
+instance CurrentMain.boundedFamilyProductOrder : PartialOrder (lp (fun _ : X => D) ∞) :=
+  CStarAlgebra.spectralOrder _
+
+instance CurrentMain.boundedFamilyProductStarOrdered : StarOrderedRing (lp (fun _ : X => D) ∞) :=
+  CStarAlgebra.spectralOrderedRing _
+
+def CurrentMain.ultraTraceValue (u : lp (fun _ : X => D) ∞) : ℂ :=
+  limUnder (U : Filter X) (fun n => (θ n).functional (u n))
+
+class CurrentMain.LimitConstruction : Prop where
+  tendsto : ∀ {D X : Type} [CStarAlgebra D] [PartialOrder D] [StarOrderedRing D]
+    (θ : X → Pureness.TracialState D) (U : Ultrafilter X) (u : lp (fun _ : X => D) ∞),
+    Tendsto (fun n => (θ n).functional (u n)) (U : Filter X) (𝓝 (ultraTraceValue θ U u))
+
+variable [ComparatorModel.CurrentMain.LimitConstruction]
+
+def CurrentMain.ultraTraceLinear : lp (fun _ : X => D) ∞ →ₗ[ℂ] ℂ where
+  toFun := ultraTraceValue θ U
+  map_add' u v := by
+    apply tendsto_nhds_unique (LimitConstruction.tendsto θ U (u+v))
+    simpa only [lp.coeFn_add, Pi.add_apply, map_add] using
+      (LimitConstruction.tendsto θ U u).add (LimitConstruction.tendsto θ U v)
+  map_smul' z u := by
+    apply tendsto_nhds_unique (LimitConstruction.tendsto θ U (z • u))
+    simpa only [lp.coeFn_smul, Pi.smul_apply, map_smul, RingHom.id_apply, smul_eq_mul] using
+      (LimitConstruction.tendsto θ U u).const_mul z
+
+def CurrentMain.boundedFamilyEval (n : X) : lp (fun _ : X => D) ∞ →⋆ₐ[ℂ] D where
+  toFun u := u n
+  map_zero' := rfl
+  map_one' := rfl
+  map_add' _ _ := rfl
+  map_mul' _ _ := rfl
+  commutes' _ := rfl
+  map_star' _ := rfl
+
+def CurrentMain.ultraTrace : TracialState (lp (fun _ : X => D) ∞) where
+  functional := { ultraTraceLinear θ U with
+    monotone' := by
+      intro u v huv
+      exact le_of_tendsto_of_tendsto (LimitConstruction.tendsto θ U u)
+        (LimitConstruction.tendsto θ U v) (Eventually.of_forall (fun n =>
+          (θ n).functional.monotone (map_rel (boundedFamilyEval n) huv))) }
+  normalized := by
+    apply tendsto_nhds_unique (LimitConstruction.tendsto θ U 1)
+    have he (n : X) : (θ n).functional ((1 : lp (fun _ : X => D) ∞) n) = 1 :=
+      (θ n).normalized
+    simp only [he]
+    exact tendsto_const_nhds
+  tracial u v := by
+    change ultraTraceValue θ U (u*v) = ultraTraceValue θ U (v*u)
+    apply tendsto_nhds_unique (LimitConstruction.tendsto θ U (u*v))
+    have he (n : X) : (θ n).functional ((u*v) n) = (θ n).functional ((v*u) n) :=
+      (θ n).tracial (u n) (v n)
+    simpa only [he] using LimitConstruction.tendsto θ U (v*u)
+
+end UltraTrace
+
+section UniformQuotient
+
+variable {D : Type} {I : Type} {X : Type} [CStarAlgebra D] [PartialOrder D] [StarOrderedRing D] [Nontrivial D]
+
+variable (τ : I → TracialState D) [Nonempty I] (U : Ultrafilter X)
+
+variable [ComparatorModel.Pureness.ClosedStarIdeal.NormConstruction] [ComparatorModel.CurrentMain.NullConstruction] [ComparatorModel.CurrentMain.CauchyConstruction] [ComparatorModel.CurrentMain.LimitConstruction]
+
+abbrev CurrentMain.FamilyUltrapower := (familyNullIdeal τ (U : Filter X)).Quotient
+
+class CurrentMain.TraceConstruction : Prop where
+  null : ∀ {D I X : Type} [CStarAlgebra D] [PartialOrder D] [StarOrderedRing D] [Nontrivial D] (τ : I → Pureness.TracialState D) [Nonempty I]
+    (U : Ultrafilter X) (s : X → I) (u : lp (fun _ : X => D) ∞),
+    IsFamilyNull τ (U : Filter X) (fun n => u n) →
+      (ultraTrace (fun n => τ (s n)) U).functional u = 0
+
+variable [ComparatorModel.CurrentMain.TraceConstruction]
+
+def CurrentMain.familyLimitTrace (s : X → I) : TracialState (FamilyUltrapower τ U) :=
+  (familyNullIdeal τ (U : Filter X)).descendedTrace
+    (ultraTrace (fun n => τ (s n)) U) (fun u hu => by
+      apply TraceConstruction.null τ U s u
+      have he : u ∈ familyNullTwoSided τ (U : Filter X) ↔
+          IsFamilyNull τ (U : Filter X) (fun n => u n) := by
+        unfold familyNullTwoSided
+        exact TwoSidedIdeal.mem_mk' _ _ _ _ _ _ u
+      exact he.mp hu)
+
+end UniformQuotient
+
+section PullbackTrace
+
+variable {D : Type} {E : Type} [CStarAlgebra D] [PartialOrder D] [StarOrderedRing D]
+
+variable [CStarAlgebra E] [PartialOrder E] [StarOrderedRing E]
+
+variable [ComparatorModel.Pureness.ClosedStarIdeal.NormConstruction] [ComparatorModel.CurrentMain.NullConstruction] [ComparatorModel.CurrentMain.CauchyConstruction] [ComparatorModel.CurrentMain.LimitConstruction] [ComparatorModel.CurrentMain.TraceConstruction]
+
+def CurrentMain.pullbackTrace (τ : TracialState E) (ι : D →⋆ₐ[ℂ] E) : TracialState D where
+  functional := { τ.functional.toLinearMap.comp ι.toLinearMap with
+    monotone' := fun _ _ h => τ.functional.monotone (map_rel ι h) }
+  normalized := by change τ.functional (ι 1) = 1; rw [map_one, τ.normalized]
+  tracial x y := by
+    change τ.functional (ι (x*y)) = τ.functional (ι (y*x))
+    rw [map_mul ι x y, map_mul ι y x]
+    exact τ.tracial _ _
+
+end PullbackTrace
+
+section CompletionTraces
+
+variable {D : Type} {I : Type} [CStarAlgebra D] [PartialOrder D] [StarOrderedRing D]
+
+variable [Nontrivial D] (τ : I → TracialState D) [Nonempty I]
+
+variable [ComparatorModel.Pureness.ClosedStarIdeal.NormConstruction] [ComparatorModel.CurrentMain.NullConstruction] [ComparatorModel.CurrentMain.CauchyConstruction] [ComparatorModel.CurrentMain.LimitConstruction] [ComparatorModel.CurrentMain.TraceConstruction]
+
+instance CurrentMain.familyCauchyOrder : PartialOrder (familyCauchyAlgebra τ) :=
+  CStarAlgebra.spectralOrder _
+
+instance CurrentMain.familyCauchyStarOrdered : StarOrderedRing (familyCauchyAlgebra τ) :=
+  CStarAlgebra.spectralOrderedRing _
+
+def CurrentMain.cauchyTrace (i : I) : TracialState (familyCauchyAlgebra τ) :=
+  pullbackTrace (ultraTrace (fun _ : ℕ => τ i) (Ultrafilter.of atTop))
+    (familyCauchyAlgebra τ).subtype
+
+def CurrentMain.completionTrace (i : I) : TracialState (UniformTracialCompletion τ) :=
+  (familyCauchyNullIdeal τ).descendedTrace (cauchyTrace τ i) (fun u hu => by
+    apply TraceConstruction.null τ (Ultrafilter.of atTop) (fun _ => i) u.1
+    have he : u.1 ∈ familyNullTwoSided τ atTop ↔
+        IsFamilyNull τ atTop (fun n => u.1 n) := by
+      unfold familyNullTwoSided
+      exact TwoSidedIdeal.mem_mk' _ _ _ _ _ _ u.1
+    have hn : IsFamilyNull τ atTop (fun n => u.1 n) := he.mp hu
+    exact hn.mono_left (Ultrafilter.of_le atTop))
+
+def CurrentMain.boundedFamilyConstant {X : Type} (a : D) : lp (fun _ : X => D) ∞ :=
+  ⟨fun _ => a, memℓp_infty_iff.mpr ⟨‖a‖,by rintro _ ⟨n,rfl⟩; exact le_rfl⟩⟩
+
+instance CurrentMain.completionNontrivial : Nontrivial (UniformTracialCompletion τ) := by
+  obtain ⟨i⟩ := ‹Nonempty I›
+  refine ⟨⟨1,0,?_⟩⟩
+  intro h
+  have he := congrArg (completionTrace τ i).functional h
+  rw [(completionTrace τ i).normalized, map_zero] at he
+  exact one_ne_zero he
+
+end CompletionTraces
+
+variable {D : Type} {I : Type} {X : Type} [CStarAlgebra D] [PartialOrder D] [StarOrderedRing D]
+
+variable [Nontrivial D] (τ : I → TracialState D) [Nonempty I] (U : Ultrafilter X)
+
+variable [ComparatorModel.Pureness.ClosedStarIdeal.NormConstruction] [ComparatorModel.CurrentMain.NullConstruction] [ComparatorModel.CurrentMain.CauchyConstruction] [ComparatorModel.CurrentMain.LimitConstruction] [ComparatorModel.CurrentMain.TraceConstruction]
+
+def CurrentMain.familyUltrapowerMap : D →⋆ₐ[ℂ] FamilyUltrapower τ U where
+  toFun a := (familyNullIdeal τ (U : Filter X)).quotientMap (boundedFamilyConstant a)
+  map_zero' := (familyNullIdeal τ (U : Filter X)).quotientMap.map_zero
+  map_one' := (familyNullIdeal τ (U : Filter X)).quotientMap.map_one
+  map_add' a b := (familyNullIdeal τ (U : Filter X)).quotientMap.map_add
+    (boundedFamilyConstant a) (boundedFamilyConstant b)
+  map_mul' a b := (familyNullIdeal τ (U : Filter X)).quotientMap.map_mul
+    (boundedFamilyConstant a) (boundedFamilyConstant b)
+  commutes' z := (familyNullIdeal τ (U : Filter X)).quotientMap.commutes z
+  map_star' _a := rfl
+
+end
+
+section
+
+open Filter Topology
+
+variable {A : Type uA} [NormedRing A]
+
+variable [ComparatorModel.Pureness.ClosedStarIdeal.NormConstruction] [ComparatorModel.CurrentMain.NullConstruction] [ComparatorModel.CurrentMain.CauchyConstruction] [ComparatorModel.CurrentMain.LimitConstruction] [ComparatorModel.CurrentMain.TraceConstruction]
+
+def Pureness.TopologicallySimple (A : Type uA) [NormedRing A] : Prop :=
+  ∀ I : TwoSidedIdeal A, IsClosed (I : Set A) → I = ⊥ ∨ I = ⊤
+
+end
+
+section
+
+open _root_.OAI.ComparatorModel.Pureness Filter
+
+variable [ComparatorModel.Pureness.ClosedStarIdeal.NormConstruction] [ComparatorModel.CurrentMain.NullConstruction] [ComparatorModel.CurrentMain.CauchyConstruction] [ComparatorModel.CurrentMain.LimitConstruction] [ComparatorModel.CurrentMain.TraceConstruction]
+
+def CurrentMain.StablyFinite (A : Type uA) [CStarAlgebra A] : Prop :=
+  ∀ n : ℕ, ∀ v : CStarMatrix (Fin n) (Fin n) A,
+    star v*v = 1 → v*star v = 1
+
+def CurrentMain.UniformPropertyGammaAt (A : Type) [CStarAlgebra A]
+    [PartialOrder A] [StarOrderedRing A] [Nontrivial A]
+    [Nonempty (TracialState A)] (U : Ultrafilter ℕ) : Prop :=
+  ∃ p : FamilyUltrapower (completionTrace (fun τ : TracialState A => τ)) U,
+    IsStarProjection p ∧ ∀ x : UniformTracialCompletion (fun τ : TracialState A => τ),
+      p * familyUltrapowerMap (completionTrace (fun τ : TracialState A => τ)) U x =
+        familyUltrapowerMap (completionTrace (fun τ : TracialState A => τ)) U x * p ∧
+      ∀ s : ℕ → TracialState A,
+        (familyLimitTrace (completionTrace (fun τ : TracialState A => τ)) U s).functional
+          (p * familyUltrapowerMap (completionTrace (fun τ : TracialState A => τ)) U x) =
+        (1/2 : ℂ) *
+        (familyLimitTrace (completionTrace (fun τ : TracialState A => τ)) U s).functional
+          (familyUltrapowerMap (completionTrace (fun τ : TracialState A => τ)) U x)
+
+open _root_.OAI.ComparatorModel.Pureness Filter
+
+def CurrentMain.Statement : Prop := ∀
+    {A : Type} [CStarAlgebra A] [PartialOrder A] [StarOrderedRing A]
+    [Nontrivial A] [TopologicalSpace.SeparableSpace A]
+    (_hsimple : TopologicallySimple A) (_hinf : ¬FiniteDimensional ℂ A)
+    (_hA : IsNuclear.{0, uNuclear} A) (_hfinite : StablyFinite A)
+    [Nonempty (TracialState A)] (U : Ultrafilter ℕ)
+    (_hfree : (U : Filter ℕ) ≤ atTop)
+    (_hRR : RealRankZero (FamilyUltrapower (completionTrace (fun τ : TracialState A => τ)) U)),
+    UniformPropertyGammaAt A U
+
+end
+
+def CurrentMain.MainClaim : Prop :=
+  ∃ h0 : ComparatorModel.Pureness.ClosedStarIdeal.NormConstruction, letI := h0;
+  ∃ h1 : ComparatorModel.CurrentMain.NullConstruction, letI := h1;
+  ∃ h2 : ComparatorModel.CurrentMain.CauchyConstruction, letI := h2;
+  ∃ h3 : ComparatorModel.CurrentMain.LimitConstruction, letI := h3;
+  ∃ h4 : ComparatorModel.CurrentMain.TraceConstruction, letI := h4;
+  Statement.{uNuclear}
+
+theorem CurrentMain.main : MainClaim.{uNuclear} := by
+  sorry
+
+end ComparatorModel
+
+end
+
+end OAI
diff --git a/lean/ComparatorChallenges/UniformKServer.json b/lean/ComparatorChallenges/UniformKServer.json
new file mode 100644
index 0000000000000000000000000000000000000000..665f0b45c117682ccb801ba18bec3b60779d2cfb
--- /dev/null
+++ b/lean/ComparatorChallenges/UniformKServer.json
@@ -0,0 +1,14 @@
+{
+  "challenge_module": "ComparatorChallenges.UniformKServer",
+  "solution_module": "OAI.Combinatorics.UniformKServer.Main",
+  "theorem_names": [
+    "OAI.UniformKServer.uniform_squared_logarithmic_main"
+  ],
+  "definition_names": [],
+  "permitted_axioms": [
+    "propext",
+    "Quot.sound",
+    "Classical.choice"
+  ],
+  "enable_nanoda": false
+}
diff --git a/lean/ComparatorChallenges/UniformKServer.lean b/lean/ComparatorChallenges/UniformKServer.lean
new file mode 100644
index 0000000000000000000000000000000000000000..254cfcd71efed615bde22b8f993d5591ab783857
--- /dev/null
+++ b/lean/ComparatorChallenges/UniformKServer.lean
@@ -0,0 +1,205 @@
+import Mathlib
+
+namespace OAI
+
+   
+
+                                                                               
+
+  
+namespace UniformKServer
+
+structure RationalMetric (n : ℕ) where
+  distance : Fin n → Fin n → ℚ
+  nonneg : ∀ x y, 0 ≤ distance x y
+  eq_zero : ∀ x y, distance x y = 0 ↔ x = y
+  symm : ∀ x y, distance x y = distance y x
+  triangle : ∀ x y z, distance x z ≤ distance x y + distance y z
+
+abbrev Configuration (n k : ℕ) := Fin k → Fin n
+abbrev History (n k : ℕ) := List (Fin n × Fin k)
+
+def serve {n k : ℕ} (s : Configuration n k) (r : Fin n) (j : Fin k) :
+    Configuration n k := Function.update s j r
+
+def costAlong {n k : ℕ} (d : RationalMetric n) :
+    Configuration n k → History n k → ℝ
+  | _, [] => 0
+  | s, (r, j) :: h => (d.distance (s j) r : ℝ) + costAlong d (serve s r j) h
+
+/-- All finite serving-label choices, knowing the entire request word. -/
+noncomputable def offlineCost {n k : ℕ} (d : RationalMetric n) (s : Configuration n k)
+    (w : List (Fin n)) : ℝ :=
+  sInf {c | ∃ h : History n k, h.map Prod.fst = w ∧ c = costAlong d s h}
+
+inductive HeadMove where
+  | left | stay | right
+  deriving DecidableEq
+
+structure BitTape where
+  left : List (Option Bool)
+  head : Option Bool
+  right : List (Option Bool)
+
+namespace BitTape
+
+def blank : BitTape := ⟨[], none, []⟩
+
+def ofWord (w : List Bool) : BitTape :=
+  match w with
+  | [] => blank
+  | b :: bs => ⟨[], some b, bs.map some⟩
+
+def shift (T : BitTape) : HeadMove → BitTape
+  | .stay => T
+  | .left => match T.left with
+    | [] => ⟨[], none, T.head :: T.right⟩
+    | a :: as => ⟨as, a, T.head :: T.right⟩
+  | .right => match T.right with
+    | [] => ⟨T.head :: T.left, none, []⟩
+    | a :: as => ⟨T.head :: T.left, a, as⟩
+
+end BitTape
+
+structure BitAction (q m : ℕ) where
+  control : Fin q
+  inputMove : HeadMove
+  write : Fin m → Option Bool
+  workMove : Fin m → HeadMove
+  emit : Option Bool
+  yield : Bool
+
+structure BitMachine where
+  controls : ℕ
+  tapes : ℕ
+  start : Fin controls
+  transition : Fin controls → Option Bool → (Fin tapes → Option Bool) →
+    Bool → BitAction controls tapes
+
+structure MachineState (M : BitMachine) where
+  control : Fin M.controls
+  input : BitTape
+  work : Fin M.tapes → BitTape
+  outputRev : List Bool
+  yielded : Bool
+
+namespace BitMachine
+
+def initial (M : BitMachine) (input : List Bool) : MachineState M :=
+  ⟨M.start, BitTape.ofWord input, fun _ => BitTape.blank, [], false⟩
+
+def step (M : BitMachine) (s : MachineState M) (coin : Bool) : MachineState M :=
+  if s.yielded then s else
+  let a := M.transition s.control s.input.head (fun i => (s.work i).head) coin
+  { control := a.control
+    input := s.input.shift a.inputMove
+    work := fun i => ({s.work i with head := a.write i}).shift (a.workMove i)
+    outputRev := match a.emit with
+      | none => s.outputRev
+      | some b => b :: s.outputRev
+    yielded := a.yield }
+
+def run (M : BitMachine) (s : MachineState M) (coins : List Bool) : MachineState M :=
+  coins.foldl M.step s
+
+/-- At a request boundary only the input/output interface is refreshed.
+    Work tapes and control retain the complete internal state. -/
+def install (M : BitMachine) (s : MachineState M) (input : List Bool) : MachineState M :=
+  {s with input := BitTape.ofWord input, outputRev := [], yielded := false}
+
+end BitMachine
+
+/-- Self-delimiting binary code: ℓ ones, a zero, then ℓ low-to-high bits.
+    This fixes one standard binary encoding rather than allowing a nonuniform
+    advice string to be included in the input. -/
+def natCode (a : ℕ) : List Bool :=
+  List.replicate a.bits.length true ++ [false] ++ a.bits
+
+def rationalCode (a : ℚ) : List Bool :=
+  (a.num < 0) :: (natCode a.num.natAbs ++ natCode a.den)
+
+def instanceCode {n k : ℕ} (d : RationalMetric n) (s : Configuration n k) : List Bool :=
+  natCode n ++ natCode k ++
+    (List.ofFn fun x : Fin n =>
+      (List.ofFn fun y : Fin n => rationalCode (d.distance x y)).flatten).flatten ++
+    (List.ofFn fun j : Fin k => natCode ((s j).val + 1)).flatten
+
+def bitValue : List Bool → ℕ
+  | [] => 0
+  | b :: bs => (if b then 1 else 0) + 2 * bitValue bs
+
+def outputValue {M : BitMachine} (s : MachineState M) : ℕ :=
+  bitValue s.outputRev.reverse
+
+/-- A dominating polynomial; every fixed polynomial nonnegative on natural
+    inputs is bounded by one of this form after increasing c and e. -/
+def polynomialBudget (c e x : ℕ) : ℕ := c * (x + 1)^e
+
+def requestBudget (c e L t : ℕ) : ℕ :=
+  polynomialBudget c e (L + Nat.clog 2 (t + 1))
+
+def boot {n k : ℕ} (M : BitMachine) (c e : ℕ)
+    (d : RationalMetric n) (s : Configuration n k) : MachineState M :=
+  M.run (M.initial (instanceCode d s))
+    (List.replicate (polynomialBudget c e (instanceCode d s).length) false)
+
+def requestStep {n : ℕ} (M : BitMachine) (c e L t : ℕ)
+    (s : MachineState M) (r : Fin n)
+    (coins : Fin (requestBudget c e L t) → Bool) : MachineState M :=
+  M.run (M.install s (natCode (r.val + 1))) (List.ofFn coins)
+
+/-- Reachability includes every binary choice, not merely an almost-sure set.
+    The index counts requests already served. -/
+inductive Reachable {n k : ℕ} (M : BitMachine) (c e : ℕ)
+    (d : RationalMetric n) (s : Configuration n k) : ℕ → MachineState M → Prop
+  | boot : Reachable M c e d s 0 (boot M c e d s)
+  | next {t z} : Reachable M c e d s t z → (r : Fin n) →
+      (bits : Fin (requestBudget c e (instanceCode d s).length (t+1)) → Bool) →
+      Reachable M c e d s (t+1)
+        (requestStep M c e (instanceCode d s).length (t+1) z r bits)
+
+/-- Modulo makes the semantic recursion total even for unsuccessful machines.
+    The main statement separately requires the output to be < k at *every*
+    reachable outcome, so no invalid output is accepted or silently repaired. -/
+def selectedLabel {M : BitMachine} {k : ℕ} (hk : 0 < k) (s : MachineState M) : Fin k :=
+  ⟨outputValue s % k, Nat.mod_lt _ hk⟩
+
+noncomputable def machineExpectedCost {n k : ℕ} (M : BitMachine) (c e L : ℕ)
+    (d : RationalMetric n) (hk : 0 < k) :
+    ℕ → MachineState M → Configuration n k → List (Fin n) → ℝ
+  | _, _, _, [] => 0
+  | t, z, s, r :: w =>
+      let B := requestBudget c e L (t+1)
+      (∑ bits : Fin B → Bool,
+        let z' := requestStep M c e L (t+1) z r bits
+        let j := selectedLabel hk z'
+        (d.distance (s j) r : ℝ) +
+          machineExpectedCost M c e L d hk (t+1) z' (serve s r j) w) / (2 : ℝ)^B
+
+/-- Full uniform main objective in the explicit bit model, not a theorem or
+    assumption. Machine transition steps are bit operations. Installing the
+    standard input and reading/erasing the output adds only O(L + budget)
+    charged bit operations, hence is absorbed by a single larger polynomial.
+    A single deterministic boot is sufficient for the source construction. -/
+def UniformAlgorithmClaim : Prop :=
+  ∃ (M : BitMachine) (c e : ℕ) (C : ℝ), 0 < c ∧ 0 < C ∧
+    ∀ (n k : ℕ) (hn : 3 ≤ n) (hk : 2 ≤ k) (hkn : k < n)
+      (d : RationalMetric n) (s : Configuration n k),
+      let L := (instanceCode d s).length
+      (boot M c e d s).yielded = true ∧
+      (∀ (t : ℕ) (z : MachineState M), Reachable M c e d s t z →
+        ∀ (r : Fin n) (bits : Fin (requestBudget c e L (t+1)) → Bool),
+          let z' := requestStep M c e L (t+1) z r bits
+          z'.yielded = true ∧ outputValue z' < k) ∧
+      (∃ B : ℝ, 0 ≤ B ∧ ∀ w : List (Fin n),
+        machineExpectedCost M c e L d (by omega) 0 (boot M c e d s) s w ≤
+          C * (Real.log (k + 1))^2 * offlineCost d s w + B)
+
+/-- A single uniform randomized bit machine has squared-logarithmic expected movement
+and a uniform polynomial bound on each request's bit operations. -/
+theorem uniform_squared_logarithmic_main : UniformAlgorithmClaim := by
+  sorry
+
+end UniformKServer
+
+end OAI
diff --git a/lean/ComparatorChallenges/UniformSparsestCut.json b/lean/ComparatorChallenges/UniformSparsestCut.json
new file mode 100644
index 0000000000000000000000000000000000000000..c84a168e2692c861687b5d83bc5f136a5c854b35
--- /dev/null
+++ b/lean/ComparatorChallenges/UniformSparsestCut.json
@@ -0,0 +1,14 @@
+{
+  "challenge_module": "ComparatorChallenges.UniformSparsestCut",
+  "solution_module": "OAI.Combinatorics.SparsestCut.Main",
+  "theorem_names": [
+    "OAI.UniformSparsestCut.mainGap"
+  ],
+  "definition_names": [],
+  "permitted_axioms": [
+    "propext",
+    "Quot.sound",
+    "Classical.choice"
+  ],
+  "enable_nanoda": false
+}
diff --git a/lean/ComparatorChallenges/UniformSparsestCut.lean b/lean/ComparatorChallenges/UniformSparsestCut.lean
new file mode 100644
index 0000000000000000000000000000000000000000..b6d86522ae638ac47d23f0b25b98159de703fd02
--- /dev/null
+++ b/lean/ComparatorChallenges/UniformSparsestCut.lean
@@ -0,0 +1,55 @@
+import Mathlib
+
+namespace OAI
+
+noncomputable section
+
+open scoped BigOperators
+
+namespace UniformSparsestCut
+
+structure Capacity (n : ℕ) where
+  cap : Fin n → Fin n → ℝ
+  nonneg : ∀ i j, 0 ≤ cap i j
+  symm : ∀ i j, cap i j = cap j i
+  diagonal : ∀ i, cap i i = 0
+
+def pairSum {n : ℕ} (f : Fin n → Fin n → ℝ) : ℝ :=
+  ∑ i, ∑ j, if i < j then f i j else 0
+
+noncomputable def cutRatio {n : ℕ} (C : Capacity n) (B : Finset (Fin n)) : ℝ :=
+  (∑ i ∈ B, ∑ j ∈ Bᶜ, C.cap i j) /
+    ((B.card : ℝ) * ((n : ℝ) - (B.card : ℝ)))
+
+noncomputable def OPT {n : ℕ} (C : Capacity n) : ℝ :=
+  sInf {r | ∃ B : Finset (Fin n), B.Nonempty ∧ B ≠ Finset.univ ∧ r = cutRatio C B}
+
+def NegativeType {n : ℕ} (d : Fin n → Fin n → ℝ) : Prop :=
+  (∃ x : Fin n → EuclideanSpace ℝ (Fin n), ∀ i j, d i j = ‖x i - x j‖ ^ 2) ∧
+  ∀ i j k, d i k ≤ d i j + d j k
+
+def Feasible {n : ℕ} (d : Fin n → Fin n → ℝ) : Prop :=
+  NegativeType d ∧ pairSum d = 1
+
+noncomputable def glValue {n : ℕ} (C : Capacity n) : ℝ :=
+  sInf {r | ∃ d : Fin n → Fin n → ℝ, Feasible d ∧
+    r = pairSum (fun i j => C.cap i j * d i j)}
+
+open Filter
+
+theorem mainGap :
+    ∃ c : ℝ, 0 < c ∧
+      ∃ n : ℕ → ℕ, ∃ C : (j : ℕ) → Capacity (n j),
+        (∀ j, 2 ≤ n j) ∧
+        Tendsto n atTop atTop ∧
+        (∀ j, 0 < glValue (C j)) ∧
+        ∀ᶠ j in atTop,
+          c * Real.sqrt (Real.log (n j : ℝ)) / (Real.log (Real.log (n j : ℝ))) ^ 3 ≤
+            OPT (C j) / glValue (C j) := by
+  sorry
+
+end UniformSparsestCut
+
+end
+
+end OAI
diff --git a/lean/ComparatorChallenges/UniqueGamesTheorem.json b/lean/ComparatorChallenges/UniqueGamesTheorem.json
new file mode 100644
index 0000000000000000000000000000000000000000..9eafa9cbbd76b1d3bbaa0ad85fe3a6af483cd78b
--- /dev/null
+++ b/lean/ComparatorChallenges/UniqueGamesTheorem.json
@@ -0,0 +1,14 @@
+{
+  "challenge_module": "ComparatorChallenges.UniqueGamesTheorem",
+  "solution_module": "OAI.Computability.UniqueGames.Main",
+  "theorem_names": [
+    "OAI.UniqueGamesTheorem.theorem11"
+  ],
+  "definition_names": [],
+  "permitted_axioms": [
+    "propext",
+    "Quot.sound",
+    "Classical.choice"
+  ],
+  "enable_nanoda": false
+}
diff --git a/lean/ComparatorChallenges/UniqueGamesTheorem.lean b/lean/ComparatorChallenges/UniqueGamesTheorem.lean
new file mode 100644
index 0000000000000000000000000000000000000000..5e0e18daac92b039a30dc500decc576b91fddb91
--- /dev/null
+++ b/lean/ComparatorChallenges/UniqueGamesTheorem.lean
@@ -0,0 +1,239 @@
+import Mathlib
+
+namespace OAI
+
+namespace UniqueGamesTheorem.Foundations.Target
+
+/-- Finite forward and inverse tables make totality and invertibility explicit.
+An eventual external encoding only needs to serialize the forward table. -/
+structure PermutationTable (alphabet : Nat) where
+  images : Vector (Fin alphabet) alphabet
+  inverseImages : Vector (Fin alphabet) alphabet
+  leftInverse : ∀ label : Fin alphabet, inverseImages[images[label]] = label
+  rightInverse : ∀ label : Fin alphabet, images[inverseImages[label]] = label
+
+structure Constraint (vertices alphabet : Nat) where
+  source : Fin vertices
+  target : Fin vertices
+  permutation : PermutationTable alphabet
+
+def Constraint.satisfied {n q : Nat} (constraint : Constraint n q)
+    (labeling : Fin n → Fin q) : Bool :=
+  decide (constraint.permutation.images[labeling constraint.source] = labeling constraint.target)
+
+/-- Constraint occurrences are list entries, so repeated parallel edges retain
+their multiplicity. No weights are hidden in this representation. -/
+structure Instance (alphabet : Nat) where
+  vertices : Nat
+  constraints : List (Constraint vertices alphabet)
+  nonempty : constraints ≠ []
+
+def countSatisfied {n q : Nat} (labeling : Fin n → Fin q) :
+    List (Constraint n q) → Nat
+  | [] => 0
+  | constraint :: rest =>
+      (if constraint.satisfied labeling then 1 else 0) + countSatisfied labeling rest
+
+end UniqueGamesTheorem.Foundations.Target
+
+namespace UniqueGamesTheorem.BinaryFormula
+
+open UniqueGamesTheorem.Foundations
+
+structure Literal where
+  name : Nat
+  positive : Bool
+  deriving DecidableEq
+
+def Literal.eval (literal : Literal) (assignment : Nat → Bool) : Bool :=
+  if literal.positive then assignment literal.name else !(assignment literal.name)
+
+abbrev Clause := Vector Literal 3
+
+def Clause.eval (clause : Clause) (assignment : Nat → Bool) : Bool :=
+  (clause[0].eval assignment || clause[1].eval assignment) || clause[2].eval assignment
+
+/-- An ordinary conjunction of three-slot clauses with sparse variable names.
+Repeated names and repeated literals are permitted in every clause. -/
+structure Formula where
+  clauses : List Clause
+
+def Formula.Satisfiable (F : Formula) : Prop :=
+  ∃ assignment : Nat → Bool, ∀ clause ∈ F.clauses, clause.eval assignment = true
+
+end UniqueGamesTheorem.BinaryFormula
+
+namespace UniqueGamesTheorem.BinaryEncoding
+
+open BinaryFormula
+
+def bitsValue : List Bool → Nat
+  | [] => 0
+  | b :: bits => Nat.bit b (bitsValue bits)
+
+def parseFrame : List Bool → Option (List Bool × List Bool)
+  | false :: rest => some ([], rest)
+  | true :: b :: rest => do
+      let (bits, trailing) ← parseFrame rest
+      return (b :: bits, trailing)
+  | _ => none
+
+/-- Equality with the canonical digits rejects alternate padded encodings. -/
+def parseName (input : List Bool) : Option (Nat × List Bool) := do
+  let (digits, rest) ← parseFrame input
+  let name := bitsValue digits
+  if digits = name.bits then some (name, rest) else none
+
+def parseLiteral : List Bool → Option (Literal × List Bool)
+  | sign :: input => do
+      let (name, rest) ← parseName input
+      return (⟨name, sign⟩, rest)
+  | [] => none
+
+def parseClause (input : List Bool) : Option (Clause × List Bool) := do
+  let (a, input) ← parseLiteral input
+  let (b, input) ← parseLiteral input
+  let (c, rest) ← parseLiteral input
+  return (#v[a, b, c], rest)
+
+/-- Fuel bounds the number of clause iterations, not the size of any name. -/
+def parseClauses : Nat → List Bool → Option (List Clause × List Bool)
+  | 0, _ => none
+  | _ + 1, false :: rest => some ([], rest)
+  | fuel + 1, true :: input => do
+      let (clause, input) ← parseClause input
+      let (clauses, rest) ← parseClauses fuel input
+      return (clause :: clauses, rest)
+  | _ + 1, [] => none
+
+def decodeFormula (input : List Bool) : Option Formula := do
+  let (clauses, rest) ← parseClauses (input.length + 1) input
+  if rest = [] then some ⟨clauses⟩ else none
+
+end UniqueGamesTheorem.BinaryEncoding
+
+namespace UniqueGamesTheorem.BinaryLanguage
+
+open UniqueGamesTheorem.Foundations
+
+def language (input : List Bool) : Prop :=
+  ∃ formula, BinaryEncoding.decodeFormula input = some formula ∧ formula.Satisfiable
+
+end UniqueGamesTheorem.BinaryLanguage
+
+namespace UniqueGamesTheorem.Integration.BinaryLinear
+
+abbrev F2 := ZMod 2
+
+abbrev Vector (n : Nat) := Fin n → F2
+
+end UniqueGamesTheorem.Integration.BinaryLinear
+
+namespace UniqueGamesTheorem.Integration.TranslationTarget
+
+open UniqueGamesTheorem.Foundations
+open Target
+
+def IsTranslationInstance {q s : Nat} (coordinates : Fin q ≃ BinaryLinear.Vector s)
+    (g : Instance q) : Prop :=
+  ∀ constraint ∈ g.constraints, ∃ shift : BinaryLinear.Vector s,
+    ∀ label : Fin q,
+      coordinates (constraint.permutation.images[label]) = coordinates label + shift
+
+end UniqueGamesTheorem.Integration.TranslationTarget
+
+namespace UniqueGamesTheorem.Foundations.Complexity
+
+def encodeWord (n : Nat) : List Bool := List.replicate n true ++ [false]
+
+def encodeWords : List Nat → List Bool
+  | [] => []
+  | n :: ns => encodeWord n ++ encodeWords ns
+
+end UniqueGamesTheorem.Foundations.Complexity
+
+namespace UniqueGamesTheorem.Foundations.Complexity
+
+open Target
+
+def tableWords {q : Nat} (table : PermutationTable q) : List Nat :=
+  table.images.toList.map Fin.val
+
+def constraintWords {n q : Nat} (constraint : Constraint n q) : List Nat :=
+  [constraint.source.val, constraint.target.val] ++ tableWords constraint.permutation
+
+def gameWords {q : Nat} (game : Instance q) : List Nat :=
+  [game.vertices, q, game.constraints.length] ++ game.constraints.flatMap constraintWords
+
+def gameBits {q : Nat} (game : Instance q) : List Bool := encodeWords (gameWords game)
+
+end UniqueGamesTheorem.Foundations.Complexity
+
+namespace UniqueGamesTheorem.Foundations.Complexity.MachineFiniteAlphabet
+
+open Turing
+
+/-- Every physical tape has a finite alphabet. Together with `M.kFin`, this
+also makes the disjoint union of all physical tape alphabets finite. -/
+def FiniteAlphabet (M : FinTM2) : Prop := ∀ k, Finite (M.Γ k)
+
+end UniqueGamesTheorem.Foundations.Complexity.MachineFiniteAlphabet
+
+namespace UniqueGamesTheorem.Explicit.MachineOutputContract
+
+open UniqueGamesTheorem.Foundations
+open Target
+open scoped BigOperators
+
+/-- A canonical orientation from the false side to the true side. Injectivity
+is on occurrence indices, so two distinct list entries cannot be parallel even
+when their constraint tables are different. -/
+structure SimpleBipartite {q : Nat} (game : Instance q) where
+  side : Fin game.vertices → Bool
+  sourceSide : ∀ i : Fin game.constraints.length,
+    side game.constraints[i].source = false
+  targetSide : ∀ i : Fin game.constraints.length,
+    side game.constraints[i].target = true
+  endpoints_injective : Function.Injective (fun i : Fin game.constraints.length =>
+    (game.constraints[i].source, game.constraints[i].target))
+
+/-- Every parameter, coordinate identification, program, and polynomial is
+fixed before the input quantifier. The identity input encoding measures runtime
+in the original raw bit length, including sparse binary variable names. -/
+structure BinaryGapReduction (ε δ : ℝ) where
+  alphabet : Nat
+  alphabetAtLeastTwo : 2 ≤ alphabet
+  dimension : Nat
+  dimensionPositive : 1 ≤ dimension
+  coordinates : Fin alphabet ≃ Integration.BinaryLinear.Vector dimension
+  construct : List Bool → Instance alphabet
+  simpleBipartite : ∀ input, SimpleBipartite (construct input)
+  translations : ∀ input,
+    Integration.TranslationTarget.IsTranslationInstance coordinates (construct input)
+  computation : Turing.TM2ComputableInPolyTime (id : List Bool → List Bool)
+    Complexity.gameBits construct
+  finiteAlphabet : Complexity.MachineFiniteAlphabet.FiniteAlphabet computation.tm
+  completeness : ∀ input, BinaryLanguage.language input →
+    ∃ labeling, 1 - ε ≤
+      (countSatisfied labeling (construct input).constraints : ℝ) /
+        (construct input).constraints.length
+  soundness : ∀ input, ¬BinaryLanguage.language input →
+    ∀ labeling, (countSatisfied labeling (construct input).constraints : ℝ) /
+      (construct input).constraints.length ≤ δ
+
+end UniqueGamesTheorem.Explicit.MachineOutputContract
+
+namespace UniqueGamesTheorem
+
+/-- For every fixed pair of errors in `(0, 1/2)`, binary 3SAT reduces in
+polynomial time to translation Unique Games with completeness at least `1 - ε`
+and soundness at most `δ`. The alphabet and machine depend only on the errors. -/
+theorem theorem11 (ε δ : ℝ)
+    (hε : 0 < ε) (hεhalf : ε < 1 / 2)
+    (hδ : 0 < δ) (hδhalf : δ < 1 / 2) :
+    Nonempty (Explicit.MachineOutputContract.BinaryGapReduction ε δ) := by
+  sorry
+
+end UniqueGamesTheorem
+
+end OAI
diff --git a/lean/ComparatorChallenges/UniversalFInfinity.json b/lean/ComparatorChallenges/UniversalFInfinity.json
new file mode 100644
index 0000000000000000000000000000000000000000..223eda13a0d5d57a11b3aedeecd4a3a0b7967836
--- /dev/null
+++ b/lean/ComparatorChallenges/UniversalFInfinity.json
@@ -0,0 +1,14 @@
+{
+  "challenge_module": "ComparatorChallenges.UniversalFInfinity",
+  "solution_module": "OAI.GroupTheory.UniversalGroup.Main",
+  "theorem_names": [
+    "OAI.UniversalFInfinity.universal_group_of_type_FInfinity"
+  ],
+  "definition_names": [],
+  "permitted_axioms": [
+    "propext",
+    "Quot.sound",
+    "Classical.choice"
+  ],
+  "enable_nanoda": false
+}
diff --git a/lean/ComparatorChallenges/UniversalFInfinity.lean b/lean/ComparatorChallenges/UniversalFInfinity.lean
new file mode 100644
index 0000000000000000000000000000000000000000..13b690fdf9629da241a85d1b602ddc6250c43dba
--- /dev/null
+++ b/lean/ComparatorChallenges/UniversalFInfinity.lean
@@ -0,0 +1,25 @@
+import Mathlib
+
+namespace OAI
+
+namespace UniversalFInfinity
+universe u
+
+def HasTypeFInfinity (G : Type u) [Group G] : Prop :=
+  ∃ (X : Type u) (_ : TopologicalSpace X) (_ : T2Space X)
+    (_ : ConnectedSpace X) (cw : Topology.CWComplex (Set.univ : Set X)),
+    (∀ n : ℕ, Finite (cw.cell n)) ∧
+    (∃ x : X, Nonempty (FundamentalGroup X x ≃* G)) ∧
+    ∃ (E : Type u) (_ : TopologicalSpace E) (_ : ContractibleSpace E)
+      (p : E → X), Function.Surjective p ∧ IsCoveringMap p
+
+theorem universal_group_of_type_FInfinity :
+    ∃ (H : Type u) (groupH : Group H),
+      @HasTypeFInfinity H groupH ∧
+      ∀ (G : Type u) [Group G] [Group.IsFinitelyPresented G],
+        ∃ φ : G →* H, Function.Injective φ := by
+  sorry
+
+end UniversalFInfinity
+
+end OAI
diff --git a/lean/ComparatorChallenges/UniversalTensorSquares.json b/lean/ComparatorChallenges/UniversalTensorSquares.json
new file mode 100644
index 0000000000000000000000000000000000000000..1f93d649664b38985359f1d12020c8f52fb2c426
--- /dev/null
+++ b/lean/ComparatorChallenges/UniversalTensorSquares.json
@@ -0,0 +1,13 @@
+{
+  "challenge_module": "ComparatorChallenges.UniversalTensorSquares",
+  "definition_names": [],
+  "permitted_axioms": [
+    "propext",
+    "Quot.sound",
+    "Classical.choice"
+  ],
+  "solution_module": "OAI.RepresentationTheory.UniversalSquare.Main",
+  "theorem_names": [
+    "OAI.UniversalTensorSquares.universal_tensor_square"
+  ]
+}
diff --git a/lean/ComparatorChallenges/UniversalTensorSquares.lean b/lean/ComparatorChallenges/UniversalTensorSquares.lean
new file mode 100644
index 0000000000000000000000000000000000000000..935b1ac8a650d05d05c1a313e0d831bd605a5706
--- /dev/null
+++ b/lean/ComparatorChallenges/UniversalTensorSquares.lean
@@ -0,0 +1,110 @@
+import Mathlib
+
+namespace OAI
+
+/-! Universal tensor squares of irreducible complex symmetric-group representations. -/
+
+noncomputable section
+
+open scoped TensorProduct
+
+universe uG uV
+
+namespace Saxl
+
+abbrev WordSpace (n d : ℕ) := (Fin n → Fin d) → ℂ
+
+def wordRep (n d : ℕ) : Representation ℂ (Equiv.Perm (Fin n)) (WordSpace n d) where
+  toFun g :=
+    { toFun := fun f a => f (a ∘ g)
+      map_add' := by intros; rfl
+      map_smul' := by intros; rfl }
+  map_one' := by ext f a; rfl
+  map_mul' g h := by ext f a; rfl
+
+def cyclic {G : Type uG} {V : Type uV} [Group G] [AddCommGroup V] [Module ℂ V]
+    (ρ : Representation ℂ G V) (v : V) : Subrepresentation ρ where
+  toSubmodule := Submodule.span ℂ (Set.range fun g : G => ρ g v)
+  apply_mem_toSubmodule g := by
+    intro x hx
+    induction hx using Submodule.span_induction with
+    | mem x hx =>
+      obtain ⟨h, rfl⟩ := hx
+      apply Submodule.subset_span
+      exact ⟨g * h, by simp only [map_mul, Module.End.mul_apply]⟩
+    | zero => simp
+    | add x y hx hy ihx ihy =>
+      simpa only [map_add] using Submodule.add_mem _ ihx ihy
+    | smul a x hx ih =>
+      simpa only [map_smul] using Submodule.smul_mem _ a ih
+
+abbrev Tableau (n : ℕ) (μ : YoungDiagram) := Fin n ≃ μ.cells
+
+def canonicalTableau {n : ℕ} (μ : YoungDiagram) (hn : μ.card = n) : Tableau n μ :=
+  (Fintype.equivFinOfCardEq (by simpa using hn)).symm
+
+def rowWord {n : ℕ} {μ : YoungDiagram} (t : Tableau n μ) : Fin n → Fin (μ.colLen 0) :=
+  fun i => ⟨(t i).val.1, YoungDiagram.mem_iff_lt_colLen.mp
+    (μ.up_left_mem le_rfl (Nat.zero_le _) (t i).property)⟩
+
+def columnGroup {n : ℕ} {μ : YoungDiagram} (t : Tableau n μ) :
+    Subgroup (Equiv.Perm (Fin n)) where
+  carrier := {g | ∀ i, (t (g i)).val.2 = (t i).val.2}
+  one_mem' := by intro i; rfl
+  mul_mem' := by
+    intro g h hg hh i
+    exact (hg (h i)).trans (hh i)
+  inv_mem' := by
+    intro g hg i
+    have h := hg (g⁻¹ i)
+    simpa using h.symm
+
+def polytabloid {n : ℕ} {μ : YoungDiagram} (t : Tableau n μ) :
+    WordSpace n (μ.colLen 0) := by
+  classical
+  letI := Fintype.ofFinite (columnGroup t)
+  exact ∑ g : columnGroup t,
+    (((Equiv.Perm.sign (g : Equiv.Perm (Fin n))) : ℤ) : ℂ) •
+      wordRep n (μ.colLen 0) (g : Equiv.Perm (Fin n)) (Pi.single (rowWord t) 1)
+
+def spechtSub {n : ℕ} {μ : YoungDiagram} (t : Tableau n μ) :=
+  cyclic (wordRep n (μ.colLen 0)) (polytabloid t)
+
+abbrev Specht {n : ℕ} {μ : YoungDiagram} (t : Tableau n μ) :=
+  (spechtSub t).toSubmodule
+
+def spechtRep {n : ℕ} {μ : YoungDiagram} (t : Tableau n μ) :
+    Representation ℂ (Equiv.Perm (Fin n)) (Specht t) :=
+  (spechtSub t).toRepresentation
+
+def kronecker {n : ℕ} {α β μ : YoungDiagram}
+    (a : Tableau n α) (b : Tableau n β) (t : Tableau n μ) : ℕ :=
+  Module.finrank ℂ (Representation.IntertwiningMap (spechtRep t)
+    ((spechtRep a).tprod (spechtRep b)))
+
+end Saxl
+
+namespace UniversalTensorSquares
+
+universe u
+
+theorem universal_tensor_square
+    (n : ℕ) (hn : 0 < n) (h2 : n ≠ 2) (h4 : n ≠ 4) (h9 : n ≠ 9) :
+    ∃ (lam : YoungDiagram) (hlam : lam.card = n),
+      (∀ (ν : YoungDiagram) (hν : ν.card = n),
+        0 < Saxl.kronecker (Saxl.canonicalTableau lam hlam)
+          (Saxl.canonicalTableau lam hlam) (Saxl.canonicalTableau ν hν)) ∧
+      Representation.IsIrreducible (Saxl.spechtRep (Saxl.canonicalTableau lam hlam)) ∧
+      ∀ (V : Type u) [AddCommGroup V] [Module ℂ V] [Module.Finite ℂ V]
+        (ρ : Representation ℂ (Equiv.Perm (Fin n)) V) [Representation.IsIrreducible ρ],
+        ∃ F : Representation.IntertwiningMap ρ
+          ((Saxl.spechtRep (Saxl.canonicalTableau lam hlam)).tprod
+            (Saxl.spechtRep (Saxl.canonicalTableau lam hlam))),
+          Function.Injective F := by
+  sorry
+
+end UniversalTensorSquares
+
+end
+
+end OAI
diff --git a/lean/ComparatorChallenges/VariableWL.json b/lean/ComparatorChallenges/VariableWL.json
new file mode 100644
index 0000000000000000000000000000000000000000..950e87ae11edcfbceb2d8cfcf4fa8e6c3e187b0b
--- /dev/null
+++ b/lean/ComparatorChallenges/VariableWL.json
@@ -0,0 +1,14 @@
+{
+  "challenge_module": "ComparatorChallenges.VariableWL",
+  "solution_module": "OAI.Combinatorics.VariableWL.Completeness",
+  "theorem_names": [
+    "OAI.VariableWL.main"
+  ],
+  "definition_names": [],
+  "permitted_axioms": [
+    "propext",
+    "Quot.sound",
+    "Classical.choice"
+  ],
+  "enable_nanoda": false
+}
diff --git a/lean/ComparatorChallenges/VariableWL.lean b/lean/ComparatorChallenges/VariableWL.lean
new file mode 100644
index 0000000000000000000000000000000000000000..92252e2a6d9961ddc619833f9ab0be9f2d57d696
--- /dev/null
+++ b/lean/ComparatorChallenges/VariableWL.lean
@@ -0,0 +1,130 @@
+import Mathlib
+
+namespace OAI
+
+namespace VariableWL
+
+abbrev Word := List Bool
+
+inductive Motion where
+  | left | stay | right
+  deriving DecidableEq
+
+def Motion.displacement : Motion → ℤ
+  | .left => -1
+  | .stay => 0
+  | .right => 1
+
+structure Machine where
+  states : ℕ
+  workSymbols : ℕ
+  extraTapes : ℕ
+  transition : Fin (states + 1) →
+    (Fin (extraTapes + 1) → Fin (workSymbols + 3)) →
+    Option (Fin (states + 1) ×
+      (Fin (extraTapes + 1) → Fin (workSymbols + 3) × Motion))
+
+structure Configuration (M : Machine) where
+  control : Fin (M.states + 1)
+  heads : Fin (M.extraTapes + 1) → ℤ
+  cells : Fin (M.extraTapes + 1) → ℤ → Fin (M.workSymbols + 3)
+
+def wordCells (a : ℕ) (w : Word) (i : ℤ) : Fin (a + 3) :=
+  if 0 ≤ i then
+    match w[i.toNat]? with
+    | none => 0
+    | some false => 1
+    | some true => 2
+  else 0
+
+def initial (M : Machine) (w : Word) : Configuration M where
+  control := 0
+  heads := fun _ => 0
+  cells := fun j => if j = 0 then wordCells M.workSymbols w else fun _ => 0
+
+def scanned {M : Machine} (c : Configuration M) :
+    Fin (M.extraTapes + 1) → Fin (M.workSymbols + 3) :=
+  fun j => c.cells j (c.heads j)
+
+def step (M : Machine) (c : Configuration M) : Option (Configuration M) :=
+  (M.transition c.control (scanned c)).map fun data =>
+    { control := data.1
+      heads := fun j => c.heads j + (data.2 j).2.displacement
+      cells := fun j i => if i = c.heads j then (data.2 j).1 else c.cells j i }
+
+def run (M : Machine) (w : Word) : ℕ → Configuration M
+  | 0 => initial M w
+  | n + 1 => (step M (run M w n)).getD (run M w n)
+
+def OutputsWithin (M : Machine) (w out : Word) (bound : ℕ) : Prop :=
+  ∃ t ≤ bound, step M (run M w t) = none ∧
+    (run M w t).cells 0 = wordCells M.workSymbols out
+
+abbrev Language := Set Word
+
+def InEXPTIME (L : Language) : Prop :=
+  ∃ M : Machine, ∃ c d : ℕ, ∀ w : Word,
+    ∃ b : Bool, (b = true ↔ w ∈ L) ∧
+      OutputsWithin M w [b] (2 ^ (c * (w.length + 1) ^ d))
+
+def PolytimeReduces (L R : Language) : Prop :=
+  ∃ M : Machine, ∃ c d : ℕ, ∀ w : Word,
+    ∃ out : Word, OutputsWithin M w out (c * (w.length + 1) ^ d) ∧
+      (w ∈ L ↔ out ∈ R)
+
+def EXPTIMEComplete (L : Language) : Prop :=
+  InEXPTIME L ∧ ∀ R : Language, InEXPTIME R → PolytimeReduces R L
+
+structure Graph where
+  order : ℕ
+  graph : SimpleGraph (Fin order)
+
+abbrev Tuple (G : Graph) (k : ℕ) := Fin k → Fin G.order
+
+def Color (k : ℕ) : ℕ → Type
+  | 0 => Fin k → Fin k → Bool × Bool
+  | s + 1 => Color k s × Multiset (Fin k → Color k s)
+
+noncomputable def color (G : Graph) (k : ℕ) : (s : ℕ) → Tuple G k → Color k s
+  | 0, v => by
+      classical
+      exact fun i j => (decide (v i = v j), decide (G.graph.Adj (v i) (v j)))
+  | s + 1, v => (color G k s v,
+      Finset.univ.val.map (fun z => fun i => color G k s (Function.update v i z)))
+
+noncomputable def histogram (G : Graph) (k s : ℕ) : Multiset (Color k s) :=
+  Finset.univ.val.map (color G k s)
+
+def Equivalent (G H : Graph) (k : ℕ) : Prop :=
+  ∀ s : ℕ, histogram G k s = histogram H k s
+
+def integerCode (n : ℕ) : Word :=
+  List.replicate (Nat.bits n).length true ++ [false] ++ Nat.bits n
+
+noncomputable def graphCode (G : Graph) : Word := by
+  classical
+  exact integerCode G.order ++
+    (List.ofFn fun i : Fin G.order =>
+      List.ofFn fun j : Fin G.order => decide (G.graph.Adj i j)).flatten
+
+noncomputable def pairCode (G H : Graph) (k : ℕ) : Word :=
+  graphCode G ++ graphCode H ++ integerCode k
+
+def WL : Language :=
+  { w | ∃ G H : Graph, ∃ k : ℕ, w = pairCode G H k ∧ 2 ≤ k ∧ Equivalent G H k }
+
+noncomputable def Subcubic (G : Graph) : Prop := by
+  classical
+  exact ∀ v : Fin G.order, G.graph.degree v ≤ 3
+
+def SubWL : Language :=
+  { w | ∃ G H : Graph, ∃ k : ℕ, w = pairCode G H k ∧ 2 ≤ k ∧
+    0 < G.order ∧ G.order = H.order ∧ G.graph.Connected ∧ H.graph.Connected ∧
+    Subcubic G ∧ Subcubic H ∧ Equivalent G H k }
+
+theorem main : EXPTIMEComplete WL ∧ EXPTIMEComplete SubWL := by
+  sorry
+
+end VariableWL
+
+end OAI
diff --git a/lean/ComparatorChallenges/VelocityHemisphere.json b/lean/ComparatorChallenges/VelocityHemisphere.json
new file mode 100644
index 0000000000000000000000000000000000000000..30af250684d97d7bc95597aad09a38c6035fcbb6
--- /dev/null
+++ b/lean/ComparatorChallenges/VelocityHemisphere.json
@@ -0,0 +1,14 @@
+{
+  "challenge_module": "ComparatorChallenges.VelocityHemisphere",
+  "solution_module": "OAI.Probability.Ballisticity.VelocityHemisphere",
+  "theorem_names": [
+    "OAI.DirectionalTransience.positive_probability_transience_velocity_hemisphere"
+  ],
+  "definition_names": [],
+  "permitted_axioms": [
+    "propext",
+    "Quot.sound",
+    "Classical.choice"
+  ],
+  "enable_nanoda": false
+}
diff --git a/lean/ComparatorChallenges/VelocityHemisphere.lean b/lean/ComparatorChallenges/VelocityHemisphere.lean
new file mode 100644
index 0000000000000000000000000000000000000000..125c0d315ad45595e6d278332286265231bfb0a8
--- /dev/null
+++ b/lean/ComparatorChallenges/VelocityHemisphere.lean
@@ -0,0 +1,102 @@
+import Mathlib
+
+namespace OAI
+
+open MeasureTheory ProbabilityTheory Filter
+open scoped ENNReal NNReal BigOperators Topology
+
+namespace DirectionalTransience
+
+abbrev Lattice (d : ℕ) := Fin d → ℤ
+abbrev Direction (d : ℕ) := Fin d × Bool
+abbrev Vector (d : ℕ) := Fin d → ℝ
+abbrev Row (d : ℕ) := {p : Direction d → ℝ≥0 // ∑ e, p e = 1}
+abbrev Environment (d : ℕ) := Lattice d → Row d
+abbrev State (d : ℕ) := Environment d × Lattice d
+abbrev Path (d : ℕ) := ℕ → Lattice d
+
+def step {d : ℕ} (e : Direction d) : Lattice d :=
+  fun i => if i = e.1 then (if e.2 then 1 else -1) else 0
+
+noncomputable def environmentLaw {d : ℕ} (ν : Measure (Row d)) :
+    Measure (Environment d) := Measure.infinitePi (fun _ => ν)
+
+def UniformElliptic {d : ℕ} (ν : Measure (Row d)) : Prop :=
+  ∃ κ : ℝ≥0, 0 < κ ∧ ∀ᵐ p ∂ν, ∀ e, κ ≤ p.1 e
+
+lemma measurable_current_row {d : ℕ} :
+    Measurable (fun z : State d => z.1 z.2) := by
+  apply measurable_from_prod_countable_left
+  intro x
+  exact measurable_pi_apply x
+
+noncomputable def transition {d : ℕ} : Kernel (State d) (State d) where
+  toFun z := ∑ e : Direction d,
+    ((z.1 z.2).1 e : ℝ≥0∞) • Measure.dirac (z.1, z.2 + step e)
+  measurable' := by
+    apply Measure.measurable_of_measurable_coe
+    intro s hs
+    simp only [Measure.finsetSum_apply, Measure.smul_apply, smul_eq_mul]
+    apply Finset.measurable_fun_sum
+    intro e _
+    apply Measurable.mul
+    · exact (measurable_pi_apply e |>.comp
+        (measurable_subtype_coe.comp measurable_current_row)).coe_nnreal_ennreal
+    · exact (Measure.measurable_coe hs).comp
+        (Measure.measurable_dirac.comp (measurable_fst.prodMk
+          (measurable_snd.add_const (step e))))
+
+instance transition_markov {d : ℕ} : IsMarkovKernel (transition (d := d)) where
+  isProbabilityMeasure z := by
+    constructor
+    change (∑ e : Direction d,
+      ((z.1 z.2).1 e : ℝ≥0∞) • Measure.dirac (z.1, z.2 + step e)) Set.univ = 1
+    simp only [Measure.finsetSum_apply, Measure.smul_apply, Measure.dirac_apply_of_mem
+      (Set.mem_univ _), smul_eq_mul, mul_one]
+    rw [← ENNReal.ofNNReal_finsetSum, (z.1 z.2).2]
+    rfl
+
+noncomputable def historyTransition {d : ℕ} (n : ℕ) :
+    Kernel ((i : Finset.Iic n) → State d) (State d) where
+  toFun z := transition (z ⟨n, Finset.mem_Iic.mpr le_rfl⟩)
+  measurable' := transition.measurable.comp (measurable_pi_apply _)
+
+instance historyTransition_markov {d : ℕ} (n : ℕ) :
+    IsMarkovKernel (historyTransition (d := d) n) where
+  isProbabilityMeasure _ := transition_markov.isProbabilityMeasure _
+
+noncomputable def initialLaw {d : ℕ} (ν : Measure (Row d)) : Measure (State d) :=
+  (environmentLaw ν).map (fun ω => (ω, (0 : Lattice d)))
+
+noncomputable def annealedLaw {d : ℕ} (ν : Measure (Row d)) : Measure (Path d) :=
+  (@Kernel.trajMeasure (fun _ => State d) _ (initialLaw ν) (historyTransition (d := d)) _).map
+    (fun z n => (z n).2)
+
+def dot {d : ℕ} (v ℓ : Vector d) : ℝ := ∑ i, v i * ℓ i
+
+def realPosition {d : ℕ} (x : Lattice d) : Vector d := fun i => (x i : ℝ)
+
+def TransientPaths {d : ℕ} (ℓ : Vector d) : Set (Path d) :=
+  {X | Tendsto (fun n => dot (realPosition (X n)) ℓ) atTop atTop}
+
+def VelocityPaths {d : ℕ} (v : Vector d) : Set (Path d) :=
+  {X | Tendsto (fun n : ℕ => fun i => (X n i:ℝ)/(n:ℝ)) atTop (𝓝 v)}
+
+theorem positive_probability_transience_velocity_hemisphere
+    {d : ℕ} (hd : 3 ≤ d) (ν : Measure (Row d)) [IsProbabilityMeasure ν]
+    (hue : UniformElliptic ν) (ℓ : Vector d) (hℓ : ℓ ≠ 0)
+    (hpos : 0 < annealedLaw ν (TransientPaths ℓ)) :
+    ∃ v : Vector d,
+      v ≠ 0 ∧ 0 < dot v ℓ ∧ annealedLaw ν (VelocityPaths v) = 1 ∧
+      (∀ w : Vector d, annealedLaw ν (VelocityPaths w) = 1 → w = v) ∧
+      {u : Vector d | dot u u = 1 ∧ annealedLaw ν (TransientPaths u) = 1} =
+        {u : Vector d | dot u u = 1 ∧ 0 < annealedLaw ν (TransientPaths u)} ∧
+      {u : Vector d | dot u u = 1 ∧ 0 < annealedLaw ν (TransientPaths u)} =
+        {u : Vector d | dot u u = 1 ∧ 0 < dot v u} ∧
+      (∀ u : Vector d, dot u u = 1 → dot v u ≤ 0 →
+        annealedLaw ν (TransientPaths u) = 0) := by
+  sorry
+
+end DirectionalTransience
+
+end OAI
diff --git a/lean/ComparatorChallenges/VertexAlgebraNet.json b/lean/ComparatorChallenges/VertexAlgebraNet.json
new file mode 100644
index 0000000000000000000000000000000000000000..8bc28ea62ec8aaa0c3dd3c50b8db4a1425d56cdc
--- /dev/null
+++ b/lean/ComparatorChallenges/VertexAlgebraNet.json
@@ -0,0 +1,14 @@
+{
+  "challenge_module": "ComparatorChallenges.VertexAlgebraNet",
+  "solution_module": "OAI.RepresentationTheory.VertexAlgebra.MinimalComparator",
+  "theorem_names": [
+    "OAI.MinimalVertex.main"
+  ],
+  "definition_names": [],
+  "permitted_axioms": [
+    "propext",
+    "Quot.sound",
+    "Classical.choice"
+  ],
+  "enable_nanoda": false
+}
diff --git a/lean/ComparatorChallenges/VertexAlgebraNet.lean b/lean/ComparatorChallenges/VertexAlgebraNet.lean
new file mode 100644
index 0000000000000000000000000000000000000000..06094cb4fd32fcf163a69989e6e93594347ee118
--- /dev/null
+++ b/lean/ComparatorChallenges/VertexAlgebraNet.lean
@@ -0,0 +1,830 @@
+import Mathlib
+
+/-! The strongly rational unitary vertex operator algebra main result, clause (1). -/
+
+noncomputable section
+universe u v w
+
+namespace OAI.StronglyRationalVOA
+variable {V : Type u} [AddCommGroup V] [Module ℂ V]
+
+noncomputable abbrev StateField (V : Type u) (W : Type v)
+    [AddCommGroup V] [Module ℂ V] [AddCommGroup W] [Module ℂ W] :=
+  V →ₗ[ℂ] VertexOperator ℂ W
+
+noncomputable def mode {W : Type v} [AddCommGroup W] [Module ℂ W]
+    (Y : OAI.StronglyRationalVOA.StateField V W) (a : V) (n : ℤ) : Module.End ℂ W :=
+  VertexOperator.ncoeff (Y a) n
+
+noncomputable def JacobiIdentity (Y : OAI.StronglyRationalVOA.StateField V V) : Prop :=
+  ∀ (a b c : V) (m n k : ℤ),
+    (∑ᶠ j : ℕ, Ring.choose (m : ℂ) j •
+      OAI.StronglyRationalVOA.mode Y (OAI.StronglyRationalVOA.mode Y a (n + j) b) (m + k - j) c) =
+    ∑ᶠ j : ℕ, ((-1 : ℂ) ^ j * Ring.choose (n : ℂ) j) •
+      (OAI.StronglyRationalVOA.mode Y a (m + n - j) (OAI.StronglyRationalVOA.mode Y b (k + j) c) -
+        (-1 : ℂ) ^ n • OAI.StronglyRationalVOA.mode Y b (n + k - j) (OAI.StronglyRationalVOA.mode Y a (m + j) c))
+
+structure VertexAlgebra (V : Type u) [AddCommGroup V] [Module ℂ V] where
+  vacuum : V
+  fields : OAI.StronglyRationalVOA.StateField V V
+  vacuum_mode : ∀ (n : ℤ), OAI.StronglyRationalVOA.mode fields vacuum n = if n = -1 then 1 else 0
+  creation : ∀ a : V, OAI.StronglyRationalVOA.mode fields a (-1) vacuum = a
+  creation_truncation : ∀ (a : V) (n : ℤ), 0 ≤ n → OAI.StronglyRationalVOA.mode fields a n vacuum = 0
+  jacobi : OAI.StronglyRationalVOA.JacobiIdentity fields
+
+end OAI.StronglyRationalVOA
+
+namespace OAI.StronglyRationalVOA.VertexAlgebra
+variable {V : Type u} [AddCommGroup V] [Module ℂ V]
+variable (A : VertexAlgebra V)
+
+noncomputable def translation : Module.End ℂ V where
+  toFun a := OAI.StronglyRationalVOA.mode A.fields a (-2) A.vacuum
+  map_add' a b := by simp [OAI.StronglyRationalVOA.mode]
+  map_smul' z a := by simp [OAI.StronglyRationalVOA.mode]
+
+noncomputable def c2 : Submodule ℂ V :=
+  Submodule.span ℂ {x | ∃ a b : V, x = OAI.StronglyRationalVOA.mode A.fields a (-2) b}
+
+noncomputable def C2Cofinite : Prop := FiniteDimensional ℂ (V ⧸ A.c2)
+
+noncomputable def IsIdeal (I : Submodule ℂ V) : Prop :=
+  (∀ a : V, ∀ n : ℤ, ∀ x ∈ I, OAI.StronglyRationalVOA.mode A.fields a n x ∈ I) ∧
+  ∀ x ∈ I, A.translation x ∈ I
+
+noncomputable def IsSimple : Prop :=
+  A.vacuum ≠ 0 ∧ ∀ I : Submodule ℂ V, A.IsIdeal I → I = ⊥ ∨ I = ⊤
+
+end OAI.StronglyRationalVOA.VertexAlgebra
+
+namespace OAI.StronglyRationalVOA
+variable {V : Type u} [AddCommGroup V] [Module ℂ V]
+
+noncomputable def ModuleJacobiIdentity {W : Type v} [AddCommGroup W] [Module ℂ W]
+    (A : OAI.StronglyRationalVOA.VertexAlgebra V) (Y : OAI.StronglyRationalVOA.StateField V W) : Prop :=
+  ∀ (a b : V) (c : W) (m n k : ℤ),
+    (∑ᶠ j : ℕ, Ring.choose (m : ℂ) j •
+      OAI.StronglyRationalVOA.mode Y (OAI.StronglyRationalVOA.mode A.fields a (n + j) b) (m + k - j) c) =
+    ∑ᶠ j : ℕ, ((-1 : ℂ) ^ j * Ring.choose (n : ℂ) j) •
+      (OAI.StronglyRationalVOA.mode Y a (m + n - j) (OAI.StronglyRationalVOA.mode Y b (k + j) c) -
+        (-1 : ℂ) ^ n • OAI.StronglyRationalVOA.mode Y b (n + k - j) (OAI.StronglyRationalVOA.mode Y a (m + j) c))
+
+structure WeakModule (A : OAI.StronglyRationalVOA.VertexAlgebra V) (W : Type v)
+    [AddCommGroup W] [Module ℂ W] where
+  fields : OAI.StronglyRationalVOA.StateField V W
+  vacuum_mode : ∀ n : ℤ, OAI.StronglyRationalVOA.mode fields A.vacuum n = if n = -1 then 1 else 0
+  jacobi : OAI.StronglyRationalVOA.ModuleJacobiIdentity A fields
+
+end OAI.StronglyRationalVOA
+
+namespace OAI.StronglyRationalVOA.WeakModule
+variable {V : Type u} [AddCommGroup V] [Module ℂ V]
+variable {W : Type v} [AddCommGroup W] [Module ℂ W]
+    {A : VertexAlgebra V} (M : WeakModule A W)
+
+noncomputable def IsInvariant (I : Submodule ℂ W) : Prop :=
+  ∀ a : V, ∀ n : ℤ, ∀ x ∈ I, OAI.StronglyRationalVOA.mode M.fields a n x ∈ I
+
+noncomputable def CompletelyReducible : Prop :=
+  ∀ I : Submodule ℂ W, M.IsInvariant I →
+    ∃ J : Submodule ℂ W, M.IsInvariant J ∧ IsCompl I J
+
+end OAI.StronglyRationalVOA.WeakModule
+
+namespace OAI.StronglyRationalVOA
+variable {V : Type u} [AddCommGroup V] [Module ℂ V]
+
+structure CFTTypeVOA (V : Type u) [AddCommGroup V] [Module ℂ V]
+    extends OAI.StronglyRationalVOA.VertexAlgebra V where
+  conformalVector : V
+  centralCharge : ℂ
+  grade : ℕ → Submodule ℂ V
+  grading_internal : DirectSum.IsInternal grade
+  grade_finite : ∀ d, FiniteDimensional ℂ (grade d)
+  vacuum_ne_zero : vacuum ≠ 0
+  grade_zero : grade 0 = ℂ ∙ vacuum
+  conformal_mem : conformalVector ∈ grade 2
+  conformal_energy : ∀ d, ∀ a ∈ grade d,
+    OAI.StronglyRationalVOA.mode fields conformalVector 1 a = (d : ℂ) • a
+  conformal_translation : OAI.StronglyRationalVOA.mode fields conformalVector 0 = toVertexAlgebra.translation
+  translation_covariance : ∀ a : V, ∀ n : ℤ,
+    OAI.StronglyRationalVOA.mode fields (toVertexAlgebra.translation a) n =
+      (-(n : ℂ)) • OAI.StronglyRationalVOA.mode fields a (n - 1)
+  virasoro : ∀ m n : ℤ,
+    (OAI.StronglyRationalVOA.mode fields conformalVector (m + 1)).comp (OAI.StronglyRationalVOA.mode fields conformalVector (n + 1)) -
+      (OAI.StronglyRationalVOA.mode fields conformalVector (n + 1)).comp (OAI.StronglyRationalVOA.mode fields conformalVector (m + 1)) =
+    ((m - n : ℤ) : ℂ) • OAI.StronglyRationalVOA.mode fields conformalVector (m + n + 1) +
+      (if m + n = 0 then (centralCharge / 12) * ((m : ℂ)^3 - m) else 0) •
+        (1 : Module.End ℂ V)
+
+end OAI.StronglyRationalVOA
+
+namespace OAI.StronglyRationalVOA.CFTTypeVOA
+variable {V : Type u} [AddCommGroup V] [Module ℂ V]
+variable (A : CFTTypeVOA V)
+
+noncomputable def virasoroMode (m : ℤ) : Module.End ℂ V :=
+  OAI.StronglyRationalVOA.mode A.fields A.conformalVector (m + 1)
+
+noncomputable def physicalMode (a : V) (d : ℕ) (m : ℤ) : Module.End ℂ V :=
+  OAI.StronglyRationalVOA.mode A.fields a (m + d - 1)
+
+noncomputable def energyShift : Module.End ℂ V := 1 + A.virasoroMode 0
+
+noncomputable def gradingEquiv : V ≃ₗ[ℂ] DirectSum ℕ (fun d => A.grade d) :=
+  (LinearEquiv.ofBijective (DirectSum.coeLinearMap A.grade) A.grading_internal).symm
+
+noncomputable def IsAdmissible {W : Type v} [AddCommGroup W] [Module ℂ W]
+    (M : OAI.StronglyRationalVOA.WeakModule A.toVertexAlgebra W) : Prop :=
+  ∃ G : ℤ → Submodule ℂ W,
+    DirectSum.IsInternal G ∧ (∀ k : ℤ, k < 0 → G k = ⊥) ∧
+      ∀ d : ℕ, ∀ a ∈ A.grade d, ∀ n k : ℤ, ∀ x ∈ G k,
+        OAI.StronglyRationalVOA.mode M.fields a n x ∈ G (k + d - n - 1)
+
+noncomputable def IsRational : Prop :=
+  ∀ (W : Type v) [AddCommGroup W] [Module ℂ W]
+    (M : OAI.StronglyRationalVOA.WeakModule A.toVertexAlgebra W),
+    A.IsAdmissible M → M.CompletelyReducible
+
+end OAI.StronglyRationalVOA.CFTTypeVOA
+
+namespace OAI.StronglyRationalVOA.CFTTypeVOA
+variable {V : Type u} [NormedAddCommGroup V] [InnerProductSpace ℂ V]
+    (A : CFTTypeVOA V)
+
+noncomputable def PolynomialEnergyBound (a : V) : Prop :=
+  ∃ C : ℝ, 0 < C ∧ ∃ p k : ℕ, ∀ (n : ℤ) (b : V),
+    ‖OAI.StronglyRationalVOA.mode A.fields a n b‖ ≤ C * (1 + |(n : ℝ)|) ^ p * ‖(A.energyShift ^ k) b‖
+
+noncomputable def PolynomialEnergyBounds : Prop := ∀ a : V, A.PolynomialEnergyBound a
+
+structure UnitaryStructure where
+  pct : V →ₛₗ[starRingEnd ℂ] V
+  pct_involutive : Function.Involutive pct
+  pct_vacuum : pct A.vacuum = A.vacuum
+  pct_conformal : pct A.conformalVector = A.conformalVector
+  pct_modes : ∀ (a b : V) (n : ℤ),
+    pct (OAI.StronglyRationalVOA.mode A.fields a n b) = OAI.StronglyRationalVOA.mode A.fields (pct a) n (pct b)
+  vacuum_norm : ‖A.vacuum‖ = 1
+  invariant : ∀ d : ℕ, ∀ a ∈ A.grade d, ∀ n : ℤ, ∀ b c : V,
+    inner ℂ (OAI.StronglyRationalVOA.mode A.fields a n b) c =
+      inner ℂ b (((-1 : ℂ) ^ d) •
+        ∑ j ∈ Finset.range (d + 1), ((j.factorial : ℂ)⁻¹) •
+          OAI.StronglyRationalVOA.mode A.fields ((A.virasoroMode 1 ^ j) (pct a))
+            (2 * (d : ℤ) - j - n - 2) c)
+
+end OAI.StronglyRationalVOA.CFTTypeVOA
+
+namespace OAI.StronglyRationalVOA.HilbertCore
+open Filter
+open UniformSpace
+variable {V : Type*} [NormedAddCommGroup V] [InnerProductSpace ℂ V]
+
+noncomputable def _root_.OAI.MinimalVertex.Code.StronglyRationalVOA.HilbertCore.space (V : Type*) [NormedAddCommGroup V] [InnerProductSpace ℂ V] :
+    Submodule ℂ (Completion V) :=
+  LinearMap.range (Completion.toComplₗᵢ : V →ₗᵢ[ℂ] Completion V).toLinearMap
+
+noncomputable def _root_.OAI.MinimalVertex.Code.StronglyRationalVOA.HilbertCore.equiv (V : Type*) [NormedAddCommGroup V] [InnerProductSpace ℂ V] :
+    V ≃ₗ[ℂ] (OAI.MinimalVertex.Code.StronglyRationalVOA.HilbertCore.space V) :=
+  LinearEquiv.ofInjective (Completion.toComplₗᵢ : V →ₗᵢ[ℂ] Completion V).toLinearMap
+    (Completion.toComplₗᵢ : V →ₗᵢ[ℂ] Completion V).injective
+
+noncomputable def _root_.OAI.MinimalVertex.Code.StronglyRationalVOA.HilbertCore.operator (T : V →ₗ[ℂ] Completion V) : Completion V →ₗ.[ℂ] Completion V where
+  domain := (OAI.MinimalVertex.Code.StronglyRationalVOA.HilbertCore.space V)
+  toFun := T.comp (OAI.MinimalVertex.Code.StronglyRationalVOA.HilbertCore.equiv V).symm.toLinearMap
+
+end OAI.StronglyRationalVOA.HilbertCore
+
+namespace OAI.StronglyRationalVOA
+open Filter
+
+noncomputable def RapidCoefficients (f : ℤ → ℂ) : Prop :=
+  ∀ p : ℕ, Summable (fun n : ℤ => ‖f n‖*(1+|(n : ℝ)|)^p)
+
+end OAI.StronglyRationalVOA
+
+namespace OAI.StronglyRationalVOA.SummableLinearFamily
+open Filter
+variable {ι V H : Type*} [NormedAddCommGroup V] [NormedSpace ℂ V]
+    [NormedAddCommGroup H] [NormedSpace ℂ H]
+
+noncomputable def tsumMap (T : ι → V →ₗ[ℂ] H) (hT : ∀ v, Summable (fun n => T n v)) : V →ₗ[ℂ] H where
+  toFun v := ∑' n, T n v
+  map_add' v w := by simpa only [map_add] using (hT v).tsum_add (hT w)
+  map_smul' z v := by
+    simpa only [map_smul, RingHom.id_apply] using (hT v).tsum_const_smul z
+
+end OAI.StronglyRationalVOA.SummableLinearFamily
+
+namespace OAI.StronglyRationalVOA
+open Filter
+open scoped ContDiff
+
+structure SmoothCircleFunction where
+  toFun : ℝ → ℂ
+  periodic : Function.Periodic toFun (2*Real.pi)
+  smooth : ContDiff ℝ ∞ toFun
+
+end OAI.StronglyRationalVOA
+
+namespace OAI.StronglyRationalVOA.SmoothCircleFunction
+open Filter
+open scoped ContDiff
+
+noncomputable instance : CoeFun OAI.StronglyRationalVOA.SmoothCircleFunction (fun _ => ℝ → ℂ) := ⟨OAI.StronglyRationalVOA.SmoothCircleFunction.toFun⟩
+
+noncomputable def _root_.OAI.MinimalVertex.Code.StronglyRationalVOA.SmoothCircleFunction.coefficient (f : OAI.StronglyRationalVOA.SmoothCircleFunction) (n : ℤ) : ℂ := by
+  classical
+  have h_OAI_StronglyRationalVOA_SmoothCircleFunction_period_pos  : 0 < 2*Real.pi := by positivity
+  exact
+    fourierCoeffOn h_OAI_StronglyRationalVOA_SmoothCircleFunction_period_pos f n
+
+end OAI.StronglyRationalVOA.SmoothCircleFunction
+
+namespace OAI.StronglyRationalVOA.ClosedGraphData
+open Filter
+open scoped ContDiff
+variable {H : Type u} [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H]
+
+noncomputable abbrev _root_.OAI.MinimalVertex.Code.StronglyRationalVOA.ClosedGraphData.Double (H : Type u) := WithLp 2 (H × H)
+
+noncomputable def _root_.OAI.MinimalVertex.Code.StronglyRationalVOA.ClosedGraphData.graph (T : H →ₗ.[ℂ] H) : Submodule ℂ (OAI.MinimalVertex.Code.StronglyRationalVOA.ClosedGraphData.Double H) :=
+  T.graph.comap (WithLp.prodContinuousLinearEquiv 2 ℂ H H).toLinearEquiv.toLinearMap
+
+noncomputable def _root_.OAI.MinimalVertex.Code.StronglyRationalVOA.ClosedGraphData.projection (T : H →ₗ.[ℂ] H) (hT : T.IsClosed) : (OAI.MinimalVertex.Code.StronglyRationalVOA.ClosedGraphData.Double H) →L[ℂ] (OAI.MinimalVertex.Code.StronglyRationalVOA.ClosedGraphData.Double H) := by
+  classical
+  have h_OAI_StronglyRationalVOA_ClosedGraphData_graph_closed {H : Type u} [instLocal1 : NormedAddCommGroup H] [instLocal2 : InnerProductSpace ℂ H]  {T : H →ₗ.[ℂ] H} (hT : T.IsClosed) :
+      IsClosed ((OAI.MinimalVertex.Code.StronglyRationalVOA.ClosedGraphData.graph T) : Set (OAI.MinimalVertex.Code.StronglyRationalVOA.ClosedGraphData.Double H)) :=
+    hT.preimage (WithLp.prodContinuousLinearEquiv 2 ℂ H H).continuous
+  letI : IsClosed ((OAI.MinimalVertex.Code.StronglyRationalVOA.ClosedGraphData.graph T) : Set (OAI.MinimalVertex.Code.StronglyRationalVOA.ClosedGraphData.Double H)) := (h_OAI_StronglyRationalVOA_ClosedGraphData_graph_closed hT)
+  exact (OAI.MinimalVertex.Code.StronglyRationalVOA.ClosedGraphData.graph T).starProjection
+
+noncomputable def _root_.OAI.MinimalVertex.Code.StronglyRationalVOA.ClosedGraphData.inclusion (i : Bool) : H →L[ℂ] (OAI.MinimalVertex.Code.StronglyRationalVOA.ClosedGraphData.Double H) :=
+  (WithLp.prodContinuousLinearEquiv 2 ℂ H H).symm.toContinuousLinearMap.comp
+    (if i then ContinuousLinearMap.inr ℂ H H else ContinuousLinearMap.inl ℂ H H)
+
+noncomputable def _root_.OAI.MinimalVertex.Code.StronglyRationalVOA.ClosedGraphData.coordinate (i : Bool) : (OAI.MinimalVertex.Code.StronglyRationalVOA.ClosedGraphData.Double H) →L[ℂ] H :=
+  (if i then ContinuousLinearMap.snd ℂ H H else ContinuousLinearMap.fst ℂ H H).comp
+    (WithLp.prodContinuousLinearEquiv 2 ℂ H H).toContinuousLinearMap
+
+noncomputable def _root_.OAI.MinimalVertex.Code.StronglyRationalVOA.ClosedGraphData.entry (T : H →ₗ.[ℂ] H) (hT : T.IsClosed) (i j : Bool) : H →L[ℂ] H :=
+  (OAI.MinimalVertex.Code.StronglyRationalVOA.ClosedGraphData.coordinate i).comp ((OAI.MinimalVertex.Code.StronglyRationalVOA.ClosedGraphData.projection T hT).comp (OAI.MinimalVertex.Code.StronglyRationalVOA.ClosedGraphData.inclusion j))
+
+end OAI.StronglyRationalVOA.ClosedGraphData
+
+namespace OAI.StronglyRationalVOA.LocalOperatorAlgebra
+open Filter
+open scoped ContDiff
+variable {H : Type u} [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H]
+open scoped Pointwise
+
+noncomputable def _root_.OAI.MinimalVertex.Code.StronglyRationalVOA.LocalOperatorAlgebra.generated (s : Set (H →L[ℂ] H)) : VonNeumannAlgebra H where
+  toStarSubalgebra := StarSubalgebra.centralizer ℂ (StarSubalgebra.centralizer ℂ s : Set (H →L[ℂ] H))
+  centralizer_centralizer' := by
+    change Set.centralizer (Set.centralizer
+      (StarSubalgebra.centralizer ℂ (StarSubalgebra.centralizer ℂ s : Set (H →L[ℂ] H)) : Set (H →L[ℂ] H))) =
+        (StarSubalgebra.centralizer ℂ (StarSubalgebra.centralizer ℂ s : Set (H →L[ℂ] H)) : Set (H →L[ℂ] H))
+    rw [StarSubalgebra.coe_centralizer_centralizer]
+    rw [Set.centralizer_centralizer_centralizer]
+
+end OAI.StronglyRationalVOA.LocalOperatorAlgebra
+
+namespace OAI.StronglyRationalVOA.SmoothCircleFunction
+open Filter
+open scoped ContDiff
+
+noncomputable def _root_.OAI.MinimalVertex.Code.StronglyRationalVOA.SmoothCircleFunction.onCircle (f : OAI.StronglyRationalVOA.SmoothCircleFunction) : AddCircle (2*Real.pi) → ℂ :=
+  f.periodic.lift
+
+end OAI.StronglyRationalVOA.SmoothCircleFunction
+
+namespace OAI.StronglyRationalVOA
+open Filter
+open scoped ContDiff
+
+structure ProperCircleArc where
+  left : ℝ
+  right : ℝ
+  nonempty' : left < right
+  nondense' : right < left + 2*Real.pi
+
+end OAI.StronglyRationalVOA
+
+namespace OAI.StronglyRationalVOA.ProperCircleArc
+open Filter
+open scoped ContDiff
+
+noncomputable def _root_.OAI.MinimalVertex.Code.StronglyRationalVOA.ProperCircleArc.carrier (I : OAI.StronglyRationalVOA.ProperCircleArc) : Set (AddCircle (2*Real.pi)) :=
+  (fun t : ℝ => (t : AddCircle (2*Real.pi))) '' Set.Ioo I.left I.right
+
+noncomputable def _root_.OAI.MinimalVertex.Code.StronglyRationalVOA.ProperCircleArc.complement (I : OAI.StronglyRationalVOA.ProperCircleArc) : OAI.StronglyRationalVOA.ProperCircleArc where
+  left := I.right
+  right := I.left + 2*Real.pi
+  nonempty' := I.nondense'
+  nondense' := by linarith [I.nonempty']
+
+end OAI.StronglyRationalVOA.ProperCircleArc
+
+namespace OAI.StronglyRationalVOA.BoundedFlow
+open scoped Topology
+open Filter
+open scoped Topology
+open Filter
+open scoped Topology
+variable {H : Type*} [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H]
+
+local instance _root_.OAI.MinimalVertex.Code.StronglyRationalVOA.BoundedFlow.boundedFlowRationalNormedAlgebra : NormedAlgebra ℚ (H →L[ℂ] H) :=
+  .restrictScalars ℚ ℂ (H →L[ℂ] H)
+
+noncomputable def _root_.OAI.MinimalVertex.Code.StronglyRationalVOA.BoundedFlow.flow (K : H →L[ℂ] H) (t : ℝ) : H →L[ℂ] H := NormedSpace.exp (t • K)
+
+end OAI.StronglyRationalVOA.BoundedFlow
+
+namespace OAI.StronglyRationalVOA
+open scoped ContDiff
+
+structure SmoothCircleLift where
+  toOrderIso : ℝ ≃o ℝ
+  smooth : ContDiff ℝ ∞ toOrderIso
+  inverse_smooth : ContDiff ℝ ∞ toOrderIso.symm
+  period : ∀ t, toOrderIso (t+2*Real.pi)=toOrderIso t+2*Real.pi
+
+end OAI.StronglyRationalVOA
+
+namespace OAI.StronglyRationalVOA.SmoothCircleLift
+open scoped ContDiff
+
+noncomputable instance : CoeFun OAI.StronglyRationalVOA.SmoothCircleLift (fun _ => ℝ → ℝ) := ⟨fun F => F.toOrderIso⟩
+
+noncomputable def _root_.OAI.MinimalVertex.Code.StronglyRationalVOA.SmoothCircleLift.identity : OAI.StronglyRationalVOA.SmoothCircleLift where
+  toOrderIso := OrderIso.refl ℝ
+  smooth := contDiff_id
+  inverse_smooth := contDiff_id
+  period := fun _ => rfl
+
+noncomputable def _root_.OAI.MinimalVertex.Code.StronglyRationalVOA.SmoothCircleLift.compose (F G : OAI.StronglyRationalVOA.SmoothCircleLift) : OAI.StronglyRationalVOA.SmoothCircleLift where
+  toOrderIso := G.toOrderIso.trans F.toOrderIso
+  smooth := F.smooth.comp G.smooth
+  inverse_smooth := G.inverse_smooth.comp F.inverse_smooth
+  period := by intro t; change F (G (t+2*Real.pi))=F (G t)+2*Real.pi; rw [G.period,F.period]
+
+noncomputable def _root_.OAI.MinimalVertex.Code.StronglyRationalVOA.SmoothCircleLift.inverse (F : OAI.StronglyRationalVOA.SmoothCircleLift) : OAI.StronglyRationalVOA.SmoothCircleLift where
+  toOrderIso := F.toOrderIso.symm
+  smooth := F.inverse_smooth
+  inverse_smooth := F.smooth
+  period := by
+    intro t
+    apply F.toOrderIso.injective
+    rw [F.toOrderIso.apply_symm_apply,F.period,F.toOrderIso.apply_symm_apply]
+
+noncomputable instance _root_.OAI.MinimalVertex.Code.StronglyRationalVOA.SmoothCircleLift.instGroup : Group OAI.StronglyRationalVOA.SmoothCircleLift := by
+  classical
+  have h_OAI_StronglyRationalVOA_SmoothCircleLift_ext  {F G : OAI.StronglyRationalVOA.SmoothCircleLift} (h : ∀ t, F t=G t) : F=G := by
+    cases F with
+    | mk f hf hfi hp =>
+      cases G with
+      | mk g hg hgi hgp =>
+        have he : f=g := DFunLike.ext _ _ h
+        subst g
+        rfl
+  exact {
+    mul := OAI.MinimalVertex.Code.StronglyRationalVOA.SmoothCircleLift.compose
+    one := OAI.MinimalVertex.Code.StronglyRationalVOA.SmoothCircleLift.identity
+    inv := OAI.MinimalVertex.Code.StronglyRationalVOA.SmoothCircleLift.inverse
+    npow := @npowRec OAI.StronglyRationalVOA.SmoothCircleLift
+      ⟨OAI.MinimalVertex.Code.StronglyRationalVOA.SmoothCircleLift.identity⟩
+      ⟨OAI.MinimalVertex.Code.StronglyRationalVOA.SmoothCircleLift.compose⟩
+    div := fun F G => OAI.MinimalVertex.Code.StronglyRationalVOA.SmoothCircleLift.compose F
+      (OAI.MinimalVertex.Code.StronglyRationalVOA.SmoothCircleLift.inverse G)
+    zpow := @zpowRec OAI.StronglyRationalVOA.SmoothCircleLift
+      ⟨OAI.MinimalVertex.Code.StronglyRationalVOA.SmoothCircleLift.identity⟩
+      ⟨OAI.MinimalVertex.Code.StronglyRationalVOA.SmoothCircleLift.compose⟩
+      ⟨OAI.MinimalVertex.Code.StronglyRationalVOA.SmoothCircleLift.inverse⟩
+      (@npowRec OAI.StronglyRationalVOA.SmoothCircleLift
+        ⟨OAI.MinimalVertex.Code.StronglyRationalVOA.SmoothCircleLift.identity⟩
+        ⟨OAI.MinimalVertex.Code.StronglyRationalVOA.SmoothCircleLift.compose⟩)
+    mul_assoc F G H := by apply h_OAI_StronglyRationalVOA_SmoothCircleLift_ext; intro t; rfl
+    one_mul F := by apply h_OAI_StronglyRationalVOA_SmoothCircleLift_ext; intro t; rfl
+    mul_one F := by apply h_OAI_StronglyRationalVOA_SmoothCircleLift_ext; intro t; rfl
+    inv_mul_cancel F := by apply h_OAI_StronglyRationalVOA_SmoothCircleLift_ext; intro t; exact F.toOrderIso.symm_apply_apply t
+  }
+
+noncomputable def _root_.OAI.MinimalVertex.Code.StronglyRationalVOA.SmoothCircleLift.onCircle (F : OAI.StronglyRationalVOA.SmoothCircleLift) : AddCircle (2*Real.pi) → AddCircle (2*Real.pi) := by
+  classical
+  have h_OAI_StronglyRationalVOA_SmoothCircleLift_one_apply  (t : ℝ) : (1 : OAI.StronglyRationalVOA.SmoothCircleLift) t=t := rfl
+  have h_OAI_StronglyRationalVOA_SmoothCircleLift_mul_apply  (F G : OAI.StronglyRationalVOA.SmoothCircleLift) (t : ℝ) : (F*G) t=F (G t) := rfl
+  have h_OAI_StronglyRationalVOA_SmoothCircleLift_circle_periodic  (F : OAI.StronglyRationalVOA.SmoothCircleLift) : Function.Periodic (fun t : ℝ => (F t : AddCircle (2*Real.pi))) (2*Real.pi) := by
+    intro t
+    change ((F.toOrderIso (t+2*Real.pi) : ℝ) : AddCircle (2*Real.pi)) =
+      (F.toOrderIso t : AddCircle (2*Real.pi))
+    rw [F.period,AddCircle.coe_add]
+    simp
+  exact
+    (h_OAI_StronglyRationalVOA_SmoothCircleLift_circle_periodic F).lift
+
+noncomputable def _root_.OAI.MinimalVertex.Code.StronglyRationalVOA.SmoothCircleLift.circleHomeomorph (F : OAI.StronglyRationalVOA.SmoothCircleLift) :
+    AddCircle (2*Real.pi) ≃ₜ AddCircle (2*Real.pi) := by
+  classical
+  have h_OAI_StronglyRationalVOA_SmoothCircleLift_one_apply  (t : ℝ) : (1 : OAI.StronglyRationalVOA.SmoothCircleLift) t=t := rfl
+  have h_OAI_StronglyRationalVOA_SmoothCircleLift_onCircle_one  (t : AddCircle (2*Real.pi)) : (OAI.MinimalVertex.Code.StronglyRationalVOA.SmoothCircleLift.onCircle 1 t)=t := by
+    induction t using QuotientAddGroup.induction_on with
+    | H t => rfl
+  have h_OAI_StronglyRationalVOA_SmoothCircleLift_onCircle_mul  (F G : OAI.StronglyRationalVOA.SmoothCircleLift) (t : AddCircle (2*Real.pi)) :
+      (OAI.MinimalVertex.Code.StronglyRationalVOA.SmoothCircleLift.onCircle (F * G) t)=(OAI.MinimalVertex.Code.StronglyRationalVOA.SmoothCircleLift.onCircle F (OAI.MinimalVertex.Code.StronglyRationalVOA.SmoothCircleLift.onCircle G t)) := by
+    induction t using QuotientAddGroup.induction_on with
+    | H t => rfl
+  have h_OAI_StronglyRationalVOA_SmoothCircleLift_onCircle_inverse  (F : OAI.StronglyRationalVOA.SmoothCircleLift) (t : AddCircle (2*Real.pi)) : (OAI.MinimalVertex.Code.StronglyRationalVOA.SmoothCircleLift.onCircle F⁻¹ (OAI.MinimalVertex.Code.StronglyRationalVOA.SmoothCircleLift.onCircle F t))=t := by
+    rw [← h_OAI_StronglyRationalVOA_SmoothCircleLift_onCircle_mul,inv_mul_cancel,h_OAI_StronglyRationalVOA_SmoothCircleLift_onCircle_one]
+  have h_OAI_StronglyRationalVOA_SmoothCircleLift_continuous_onCircle  (F : OAI.StronglyRationalVOA.SmoothCircleLift) : Continuous (OAI.MinimalVertex.Code.StronglyRationalVOA.SmoothCircleLift.onCircle F) := by
+    exact ((AddCircle.continuous_mk' (2*Real.pi)).comp F.smooth.continuous).quotient_liftOn' _
+  have h_OAI_StronglyRationalVOA_SmoothCircleLift_mul_apply  (F G : OAI.StronglyRationalVOA.SmoothCircleLift) (t : ℝ) : (F*G) t=F (G t) := rfl
+  exact {
+    toFun := (OAI.MinimalVertex.Code.StronglyRationalVOA.SmoothCircleLift.onCircle F)
+    invFun := (OAI.MinimalVertex.Code.StronglyRationalVOA.SmoothCircleLift.onCircle F⁻¹)
+    left_inv := (h_OAI_StronglyRationalVOA_SmoothCircleLift_onCircle_inverse F)
+    right_inv := by intro t; simpa [h_OAI_StronglyRationalVOA_SmoothCircleLift_one_apply, h_OAI_StronglyRationalVOA_SmoothCircleLift_mul_apply] using (h_OAI_StronglyRationalVOA_SmoothCircleLift_onCircle_inverse F⁻¹ t)
+    continuous_toFun := (h_OAI_StronglyRationalVOA_SmoothCircleLift_continuous_onCircle F)
+    continuous_invFun := (h_OAI_StronglyRationalVOA_SmoothCircleLift_continuous_onCircle F⁻¹)
+  }
+
+noncomputable def _root_.OAI.MinimalVertex.Code.StronglyRationalVOA.SmoothCircleLift.circleAction : OAI.StronglyRationalVOA.SmoothCircleLift →* Equiv.Perm (AddCircle (2*Real.pi)) := by
+  classical
+  have h_OAI_StronglyRationalVOA_SmoothCircleLift_onCircle_one  (t : AddCircle (2*Real.pi)) : (OAI.MinimalVertex.Code.StronglyRationalVOA.SmoothCircleLift.onCircle 1 t)=t := by
+    induction t using QuotientAddGroup.induction_on with
+    | H t => rfl
+  have h_OAI_StronglyRationalVOA_SmoothCircleLift_onCircle_mul  (F G : OAI.StronglyRationalVOA.SmoothCircleLift) (t : AddCircle (2*Real.pi)) :
+      (OAI.MinimalVertex.Code.StronglyRationalVOA.SmoothCircleLift.onCircle (F * G) t)=(OAI.MinimalVertex.Code.StronglyRationalVOA.SmoothCircleLift.onCircle F (OAI.MinimalVertex.Code.StronglyRationalVOA.SmoothCircleLift.onCircle G t)) := by
+    induction t using QuotientAddGroup.induction_on with
+    | H t => rfl
+  exact {
+    toFun F := (OAI.MinimalVertex.Code.StronglyRationalVOA.SmoothCircleLift.circleHomeomorph F).toEquiv
+    map_one' := by ext x; exact (h_OAI_StronglyRationalVOA_SmoothCircleLift_onCircle_one x)
+    map_mul' F G := by ext x; exact (h_OAI_StronglyRationalVOA_SmoothCircleLift_onCircle_mul F G x)
+  }
+
+end OAI.StronglyRationalVOA.SmoothCircleLift
+
+namespace OAI.StronglyRationalVOA
+open scoped ContDiff
+
+noncomputable def _root_.OAI.MinimalVertex.Code.StronglyRationalVOA.SmoothCircleDiffeomorphism := OAI.StronglyRationalVOA.SmoothCircleLift ⧸ (OAI.MinimalVertex.Code.StronglyRationalVOA.SmoothCircleLift.circleAction).ker
+
+noncomputable instance _root_.OAI.MinimalVertex.Code.StronglyRationalVOA.instGroupSmoothCircleDiffeomorphism : Group OAI.MinimalVertex.Code.StronglyRationalVOA.SmoothCircleDiffeomorphism := inferInstanceAs
+  (Group (OAI.StronglyRationalVOA.SmoothCircleLift ⧸ (OAI.MinimalVertex.Code.StronglyRationalVOA.SmoothCircleLift.circleAction).ker))
+
+end OAI.StronglyRationalVOA
+
+namespace OAI.StronglyRationalVOA
+open UniformSpace
+
+noncomputable def scalarPhaseSubgroup (H : Type*) [NormedAddCommGroup H] [InnerProductSpace ℂ H] :
+    Subgroup (H ≃ₗᵢ[ℂ] H) where
+  carrier := {E | ∃ c : ℂ, ‖c‖=1 ∧ ∀ x : H, E x=c • x}
+  one_mem' := ⟨1,by simp,fun x => (one_smul ℂ x).symm⟩
+  mul_mem' := by
+    rintro E F ⟨c,hc,he⟩ ⟨d,hd,hf⟩
+    refine ⟨c*d,by rw [norm_mul,hc,hd,one_mul],?_⟩
+    intro x
+    change E (F x)=(c*d) • x
+    rw [hf,he,mul_smul]
+  inv_mem' := by
+    rintro E ⟨c,hc,he⟩
+    have hn : c ≠ 0 := by intro h; rw [h,norm_zero] at hc; norm_num at hc
+    refine ⟨c⁻¹,by rw [norm_inv,hc,inv_one],?_⟩
+    intro x
+    apply E.injective
+    change E (E.symm x)=E (c⁻¹ • x)
+    rw [E.apply_symm_apply,map_smul,he,smul_smul,inv_mul_cancel₀ hn,one_smul]
+
+noncomputable instance scalarPhaseSubgroup_normal (H : Type*) [NormedAddCommGroup H] [InnerProductSpace ℂ H] :
+    (OAI.StronglyRationalVOA.scalarPhaseSubgroup H).Normal where
+  conj_mem := by
+    rintro E ⟨c,hc,he⟩ F
+    refine ⟨c,hc,?_⟩
+    intro x
+    change F (E (F.symm x))=c • x
+    rw [he,map_smul,F.apply_symm_apply]
+
+noncomputable abbrev ProjectiveUnitaryGroup (H : Type*) [NormedAddCommGroup H] [InnerProductSpace ℂ H] :=
+  (H ≃ₗᵢ[ℂ] H) ⧸ OAI.StronglyRationalVOA.scalarPhaseSubgroup H
+
+end OAI.StronglyRationalVOA
+
+namespace OAI.StronglyRationalVOA.SmoothCircleLift
+open Filter Set
+open scoped Topology ContDiff
+
+noncomputable def jet (F : OAI.StronglyRationalVOA.SmoothCircleLift) (k : ℕ) : C(ℝ,ℝ) :=
+  ⟨iteratedDeriv k F, F.smooth.continuous_iteratedDeriv k
+    (by exact_mod_cast (le_top : (k : ℕ∞) ≤ ⊤))⟩
+
+noncomputable instance : TopologicalSpace OAI.StronglyRationalVOA.SmoothCircleLift :=
+  TopologicalSpace.induced (fun F => OAI.StronglyRationalVOA.SmoothCircleLift.jet F) inferInstance
+
+end OAI.StronglyRationalVOA.SmoothCircleLift
+
+namespace OAI.StronglyRationalVOA
+open UniformSpace Filter Set
+open scoped Topology
+
+noncomputable instance unitaryStrongTopology (H : Type*) [NormedAddCommGroup H] [InnerProductSpace ℂ H] :
+    TopologicalSpace (H ≃ₗᵢ[ℂ] H) :=
+  TopologicalSpace.induced (fun E : H ≃ₗᵢ[ℂ] H => (E : H → H)) inferInstance
+
+noncomputable instance _root_.OAI.MinimalVertex.Code.StronglyRationalVOA.instTopologicalSpaceSmoothCircleDiffeomorphism : TopologicalSpace OAI.MinimalVertex.Code.StronglyRationalVOA.SmoothCircleDiffeomorphism := inferInstanceAs
+  (TopologicalSpace (OAI.StronglyRationalVOA.SmoothCircleLift ⧸ (OAI.MinimalVertex.Code.StronglyRationalVOA.SmoothCircleLift.circleAction).ker))
+
+end OAI.StronglyRationalVOA
+
+namespace OAI.StronglyRationalVOA.CircleMobiusGeometry
+open Set
+open scoped MatrixGroups
+
+noncomputable def _root_.OAI.MinimalVertex.Code.StronglyRationalVOA.CircleMobiusGeometry.Rel (M : SL(2,ℝ)) (x y : ℝ) : Prop :=
+  (M 0 0*Real.cos (x/2)+M 0 1*Real.sin (x/2))*Real.sin (y/2)=
+    (M 1 0*Real.cos (x/2)+M 1 1*Real.sin (x/2))*Real.cos (y/2)
+
+noncomputable def _root_.OAI.MinimalVertex.Code.StronglyRationalVOA.CircleMobiusGeometry.Implements (M : SL(2,ℝ)) (F : OAI.StronglyRationalVOA.SmoothCircleLift) : Prop := ∀ x, (OAI.MinimalVertex.Code.StronglyRationalVOA.CircleMobiusGeometry.Rel M x ((OAI.StronglyRationalVOA.SmoothCircleLift.toOrderIso F) x))
+
+noncomputable def _root_.OAI.MinimalVertex.Code.StronglyRationalVOA.CircleMobiusGeometry.lifts : Subgroup OAI.StronglyRationalVOA.SmoothCircleLift := by
+  classical
+  have h_OAI_StronglyRationalVOA_SmoothCircleLift_one_apply  (t : ℝ) : (1 : OAI.StronglyRationalVOA.SmoothCircleLift) t=t := rfl
+  have h_OAI_StronglyRationalVOA_SmoothCircleLift_mul_apply  (F G : OAI.StronglyRationalVOA.SmoothCircleLift) (t : ℝ) : (F*G) t=F (G t) := rfl
+  have h_OAI_StronglyRationalVOA_SmoothCircleLift_apply_inv_apply  (F : OAI.StronglyRationalVOA.SmoothCircleLift) (t : ℝ) : F (F⁻¹ t)=t := F.toOrderIso.apply_symm_apply t
+  have h_OAI_StronglyRationalVOA_CircleMobiusGeometry_implements_inv  {M : SL(2,ℝ)} {F : OAI.StronglyRationalVOA.SmoothCircleLift}
+      (hF : (OAI.MinimalVertex.Code.StronglyRationalVOA.CircleMobiusGeometry.Implements M F)) : (OAI.MinimalVertex.Code.StronglyRationalVOA.CircleMobiusGeometry.Implements M⁻¹ F⁻¹) := by
+    intro x
+    have h := hF (F⁻¹ x)
+    rw [OAI.MinimalVertex.Code.StronglyRationalVOA.CircleMobiusGeometry.Rel,(h_OAI_StronglyRationalVOA_SmoothCircleLift_apply_inv_apply F)] at h
+    simp only [OAI.MinimalVertex.Code.StronglyRationalVOA.CircleMobiusGeometry.Rel,Matrix.SpecialLinearGroup.SL2_inv_expl,Matrix.cons_val_zero,
+      Matrix.cons_val_one,Matrix.cons_val_fin_one]
+    linear_combination -h
+  have h_OAI_StronglyRationalVOA_CircleMobiusGeometry_implements_one  : (OAI.MinimalVertex.Code.StronglyRationalVOA.CircleMobiusGeometry.Implements 1 1) := by
+    intro x
+    simp [h_OAI_StronglyRationalVOA_SmoothCircleLift_one_apply, OAI.MinimalVertex.Code.StronglyRationalVOA.CircleMobiusGeometry.Rel,mul_comm]
+  have h_OAI_StronglyRationalVOA_CircleMobiusGeometry_collinear_unit  {p q c s : ℝ} (hu : c^2+s^2=1) (h : p*s=q*c) :
+      (p*c+q*s)*c=p ∧ (p*c+q*s)*s=q := by
+    constructor
+    · linear_combination p*hu-s*h
+    · linear_combination q*hu+c*h
+  have h_OAI_StronglyRationalVOA_CircleMobiusGeometry_cos_sq_add_sin_sq  (x : ℝ) : Real.cos x^2+Real.sin x^2=1 := by
+    nlinarith [Real.sin_sq_add_cos_sq x]
+  have h_OAI_StronglyRationalVOA_CircleMobiusGeometry_implements_mul  {M N : SL(2,ℝ)} {F G : OAI.StronglyRationalVOA.SmoothCircleLift}
+      (hF : (OAI.MinimalVertex.Code.StronglyRationalVOA.CircleMobiusGeometry.Implements M F)) (hG : (OAI.MinimalVertex.Code.StronglyRationalVOA.CircleMobiusGeometry.Implements N G)) : (OAI.MinimalVertex.Code.StronglyRationalVOA.CircleMobiusGeometry.Implements (M * N) (F * G)) := by
+    intro x
+    have hh := hF (G x)
+    have hg := hG x
+    obtain ⟨hr1,hr2⟩ := (h_OAI_StronglyRationalVOA_CircleMobiusGeometry_collinear_unit
+    (h_OAI_StronglyRationalVOA_CircleMobiusGeometry_cos_sq_add_sin_sq
+      ((OAI.StronglyRationalVOA.SmoothCircleLift.toOrderIso G) x / 2))
+    hg)
+    let r := (N 0 0*Real.cos (x/2)+N 0 1*Real.sin (x/2))*Real.cos (G x/2)+
+      (N 1 0*Real.cos (x/2)+N 1 1*Real.sin (x/2))*Real.sin (G x/2)
+    change r*Real.cos (G x/2)=N 0 0*Real.cos (x/2)+N 0 1*Real.sin (x/2) at hr1
+    change r*Real.sin (G x/2)=N 1 0*Real.cos (x/2)+N 1 1*Real.sin (x/2) at hr2
+    change (M 0 0*Real.cos (G x/2)+M 0 1*Real.sin (G x/2))*Real.sin (F (G x)/2)=
+      (M 1 0*Real.cos (G x/2)+M 1 1*Real.sin (G x/2))*Real.cos (F (G x)/2) at hh
+    simp only [OAI.MinimalVertex.Code.StronglyRationalVOA.CircleMobiusGeometry.Rel,(h_OAI_StronglyRationalVOA_SmoothCircleLift_mul_apply),Matrix.SpecialLinearGroup.coe_mul,
+      Matrix.mul_apply,Fin.sum_univ_two]
+    linear_combination r*hh+(M 1 0*Real.cos (F (G x)/2)-M 0 0*Real.sin (F (G x)/2))*hr1+
+      (M 1 1*Real.cos (F (G x)/2)-M 0 1*Real.sin (F (G x)/2))*hr2
+  exact {
+    carrier := {F | ∃ M : SL(2,ℝ), (OAI.MinimalVertex.Code.StronglyRationalVOA.CircleMobiusGeometry.Implements M F)}
+    one_mem' := ⟨1,h_OAI_StronglyRationalVOA_CircleMobiusGeometry_implements_one⟩
+    mul_mem' := by rintro F G ⟨M,hM⟩ ⟨N,hN⟩; exact ⟨M*N,(h_OAI_StronglyRationalVOA_CircleMobiusGeometry_implements_mul hM hN)⟩
+    inv_mem' := by rintro F ⟨M,hM⟩; exact ⟨M⁻¹,(h_OAI_StronglyRationalVOA_CircleMobiusGeometry_implements_inv hM)⟩
+  }
+
+noncomputable def _root_.OAI.MinimalVertex.Code.StronglyRationalVOA.CircleMobiusGeometry.rotationMatrix (s : ℝ) : SL(2,ℝ) := by
+  classical
+  have h_OAI_StronglyRationalVOA_CircleMobiusGeometry_cos_sq_add_sin_sq  (x : ℝ) : Real.cos x^2+Real.sin x^2=1 := by
+    nlinarith [Real.sin_sq_add_cos_sq x]
+  exact
+    ⟨!![Real.cos (s/2),-Real.sin (s/2);Real.sin (s/2),Real.cos (s/2)],by
+        simp only [Matrix.det_fin_two_of]
+        nlinarith [(h_OAI_StronglyRationalVOA_CircleMobiusGeometry_cos_sq_add_sin_sq (s / 2))]⟩
+
+noncomputable abbrev _root_.OAI.MinimalVertex.Code.StronglyRationalVOA.CircleMobiusGeometry.Group := OAI.MinimalVertex.Code.StronglyRationalVOA.CircleMobiusGeometry.lifts ⧸ ((OAI.MinimalVertex.Code.StronglyRationalVOA.SmoothCircleLift.circleAction).comp OAI.MinimalVertex.Code.StronglyRationalVOA.CircleMobiusGeometry.lifts.subtype).ker
+
+noncomputable def _root_.OAI.MinimalVertex.Code.StronglyRationalVOA.CircleMobiusGeometry.inclusion : OAI.MinimalVertex.Code.StronglyRationalVOA.CircleMobiusGeometry.Group →* OAI.MinimalVertex.Code.StronglyRationalVOA.SmoothCircleDiffeomorphism :=
+  QuotientGroup.lift ((OAI.MinimalVertex.Code.StronglyRationalVOA.SmoothCircleLift.circleAction).comp OAI.MinimalVertex.Code.StronglyRationalVOA.CircleMobiusGeometry.lifts.subtype).ker
+    ((QuotientGroup.mk' (OAI.MinimalVertex.Code.StronglyRationalVOA.SmoothCircleLift.circleAction).ker).comp OAI.MinimalVertex.Code.StronglyRationalVOA.CircleMobiusGeometry.lifts.subtype) (by
+      intro F hF
+      exact (QuotientGroup.eq_one_iff _).mpr hF)
+
+end OAI.StronglyRationalVOA.CircleMobiusGeometry
+
+namespace OAI.MinimalVertex.Code.StronglyRationalVOA.SmoothCircleDiffeomorphism
+open Set
+open scoped Topology MatrixGroups
+
+noncomputable def _root_.OAI.MinimalVertex.Code.StronglyRationalVOA.SmoothCircleDiffeomorphism.action : OAI.MinimalVertex.Code.StronglyRationalVOA.SmoothCircleDiffeomorphism →* Equiv.Perm (AddCircle (2*Real.pi)) :=
+  QuotientGroup.lift (OAI.MinimalVertex.Code.StronglyRationalVOA.SmoothCircleLift.circleAction).ker (OAI.MinimalVertex.Code.StronglyRationalVOA.SmoothCircleLift.circleAction)
+    (fun _ h => h)
+
+end OAI.MinimalVertex.Code.StronglyRationalVOA.SmoothCircleDiffeomorphism
+
+namespace OAI.StronglyRationalVOA
+open Set
+open scoped Topology MatrixGroups
+
+noncomputable def _root_.OAI.MinimalVertex.Code.StronglyRationalVOA.projectiveConjugation {H : Type*} [NormedAddCommGroup H] [InnerProductSpace ℂ H]
+    [CompleteSpace H] : OAI.StronglyRationalVOA.ProjectiveUnitaryGroup H → ((H →L[ℂ] H) ≃⋆ₐ[ℂ] (H →L[ℂ] H)) := by
+  classical
+  have h_OAI_StronglyRationalVOA_projective_equality_conjugation  {H : Type _} [NormedAddCommGroup H]
+      [InnerProductSpace ℂ H] [CompleteSpace H] (E F : H ≃ₗᵢ[ℂ] H)
+      (h : (QuotientGroup.mk E : OAI.StronglyRationalVOA.ProjectiveUnitaryGroup H)=QuotientGroup.mk F) :
+      E.conjStarAlgEquiv=F.conjStarAlgEquiv := by
+    obtain ⟨c,_,hc⟩ := QuotientGroup.eq.mp h
+    have he (x : H) : F x=c • E x := by
+      have H := congrArg E (hc x)
+      change E (E.symm (F x))=E (c • x) at H
+      simpa only [E.apply_symm_apply,map_smul] using H
+    ext B x
+    change E (B (E.symm x))=F (B (F.symm x))
+    have hi : E.symm x=c • F.symm x := by
+      apply E.injective
+      rw [E.apply_symm_apply,map_smul,← he,F.apply_symm_apply]
+    rw [hi,map_smul,map_smul,← he]
+  exact
+    Quotient.lift (fun E : H ≃ₗᵢ[ℂ] H => E.conjStarAlgEquiv) (by
+        intro E F h
+        exact (h_OAI_StronglyRationalVOA_projective_equality_conjugation E F (Quotient.sound h)))
+
+noncomputable def _root_.OAI.MinimalVertex.Code.StronglyRationalVOA.globalObservableAlgebra {H : Type*} [NormedAddCommGroup H] [InnerProductSpace ℂ H]
+    [CompleteSpace H] (N : OAI.StronglyRationalVOA.ProperCircleArc → VonNeumannAlgebra H) :
+    Subalgebra ℂ (H →L[ℂ] H) :=
+  Algebra.adjoin ℂ (⋃ I, (N I : Set (H →L[ℂ] H)))
+
+noncomputable def _root_.OAI.MinimalVertex.Code.StronglyRationalVOA.globalCyclicSpace {H : Type*} [NormedAddCommGroup H] [InnerProductSpace ℂ H]
+    [CompleteSpace H] (N : OAI.StronglyRationalVOA.ProperCircleArc → VonNeumannAlgebra H) (Ω : H) : Submodule ℂ H :=
+  (Submodule.span ℂ {x | ∃ B ∈ (OAI.MinimalVertex.Code.StronglyRationalVOA.globalObservableAlgebra N), x=B Ω}).topologicalClosure
+
+end OAI.StronglyRationalVOA
+
+namespace OAI.StronglyRationalVOA.CFTTypeVOA
+variable {V : Type u} [AddCommGroup V] [Module ℂ V] (A : CFTTypeVOA V)
+
+noncomputable abbrev GradedDual := DirectSum ℕ (fun d => Module.Dual ℂ (A.grade d))
+
+noncomputable def gradedDualPairing (φ : A.GradedDual) (b : V) : ℂ := by
+  classical
+  exact φ.sum (fun d f => f (A.gradingEquiv b d))
+
+noncomputable def IsSelfContragredient : Prop :=
+  ∃ e : V ≃ₗ[ℂ] A.GradedDual,
+    ∀ d : ℕ, ∀ a ∈ A.grade d, ∀ n : ℤ, ∀ b c : V,
+      A.gradedDualPairing (e (OAI.StronglyRationalVOA.mode A.fields a n b)) c =
+        ((-1 : ℂ)^d) * ∑ j ∈ Finset.range (d+1), ((j.factorial : ℂ)⁻¹) *
+          A.gradedDualPairing (e b)
+            (OAI.StronglyRationalVOA.mode A.fields ((A.virasoroMode 1 ^ j) a) (2*(d:ℤ)-j-n-2) c)
+
+noncomputable def IsStronglyRational : Prop :=
+  A.IsSelfContragredient ∧ A.IsRational.{u,v} ∧ A.toVertexAlgebra.C2Cofinite
+
+end OAI.StronglyRationalVOA.CFTTypeVOA
+
+namespace OAI.MinimalVertex
+open Filter Set UniformSpace
+open scoped Topology MatrixGroups
+open StronglyRationalVOA
+variable {V : Type u} [NormedAddCommGroup V] [InnerProductSpace ℂ V]
+  {A : CFTTypeVOA V}
+
+noncomputable def smearedMap (A : OAI.StronglyRationalVOA.CFTTypeVOA V) (a : V) (d : ℕ) (_ha : A.PolynomialEnergyBound a)
+    (f : ℤ → ℂ) (_hf : OAI.StronglyRationalVOA.RapidCoefficients f) : V →ₗ[ℂ] Completion V := by
+  classical
+  let family : ℤ → (V →ₗ[ℂ] Completion V) := fun m =>
+    f m • (Completion.toComplₗᵢ : V →ₗᵢ[ℂ] Completion V).toLinearMap.comp
+      (A.physicalMode a d m)
+  exact if h : ∀ v, Summable (fun m => family m v) then
+    SummableLinearFamily.tsumMap family h
+  else 0
+
+noncomputable def smoothSmearedField (_U : A.UnitaryStructure) (_hc : A.toVertexAlgebra.C2Cofinite)
+    (a : V) (d : ℕ) (f : OAI.StronglyRationalVOA.SmoothCircleFunction) : Completion V →ₗ.[ℂ] Completion V := by
+  classical
+  exact if h : A.PolynomialEnergyBounds ∧ OAI.StronglyRationalVOA.RapidCoefficients (OAI.MinimalVertex.Code.StronglyRationalVOA.SmoothCircleFunction.coefficient f) then
+    (OAI.MinimalVertex.Code.StronglyRationalVOA.HilbertCore.operator
+  (OAI.MinimalVertex.smearedMap A a d (And.left h a) (OAI.MinimalVertex.Code.StronglyRationalVOA.SmoothCircleFunction.coefficient f)
+    (And.right h)))
+  else 0
+
+noncomputable def closedSmoothField (U : A.UnitaryStructure) (hc : A.toVertexAlgebra.C2Cofinite)
+    (a : V) (d : ℕ) (f : OAI.StronglyRationalVOA.SmoothCircleFunction) : Completion V →ₗ.[ℂ] Completion V :=
+  (OAI.MinimalVertex.smoothSmearedField U hc a d f).closure
+
+noncomputable def localGraphData (U : A.UnitaryStructure) (hc : A.toVertexAlgebra.C2Cofinite)
+    (O : Set (AddCircle (2*Real.pi))) : Set (Completion V →L[ℂ] Completion V) :=
+  {x | ∃ (a : V) (d : ℕ), a ∈ A.grade d ∧ ∃ (f : OAI.StronglyRationalVOA.SmoothCircleFunction),
+      tsupport (OAI.MinimalVertex.Code.StronglyRationalVOA.SmoothCircleFunction.onCircle f) ⊆ O ∧ ∃ (h : (OAI.MinimalVertex.closedSmoothField U hc a d f).IsClosed),
+        ∃ i j : Bool, x = (OAI.MinimalVertex.Code.StronglyRationalVOA.ClosedGraphData.entry (OAI.MinimalVertex.closedSmoothField U hc a d f) h i j)}
+
+noncomputable def localAlgebra (U : A.UnitaryStructure) (hc : A.toVertexAlgebra.C2Cofinite)
+    (O : Set (AddCircle (2*Real.pi))) : VonNeumannAlgebra (Completion V) :=
+  (OAI.MinimalVertex.Code.StronglyRationalVOA.LocalOperatorAlgebra.generated (OAI.MinimalVertex.localGraphData U hc O))
+
+noncomputable def intervalAlgebra (U : A.UnitaryStructure) (hc : A.toVertexAlgebra.C2Cofinite)
+    (I : OAI.StronglyRationalVOA.ProperCircleArc) : VonNeumannAlgebra (Completion V) :=
+  OAI.MinimalVertex.localAlgebra U hc (OAI.MinimalVertex.Code.StronglyRationalVOA.ProperCircleArc.carrier I)
+
+noncomputable def CKLWStrongLocal (U : A.UnitaryStructure) (hc : A.toVertexAlgebra.C2Cofinite) : Prop :=
+  (∀ a : V, A.PolynomialEnergyBound a) ∧
+    ∀ I : OAI.StronglyRationalVOA.ProperCircleArc, OAI.MinimalVertex.intervalAlgebra U hc I ≤
+      (OAI.MinimalVertex.intervalAlgebra U hc (OAI.MinimalVertex.Code.StronglyRationalVOA.ProperCircleArc.complement I)).commutant
+
+end OAI.MinimalVertex
+
+namespace OAI.MinimalVertex
+open Filter Set UniformSpace
+open scoped Topology MatrixGroups
+open StronglyRationalVOA
+variable {H : Type*} [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H]
+
+noncomputable def resolvent (T : H →ₗ.[ℂ] H) (_hs : IsSelfAdjoint T) (z : ℂ) (_hz : 1 ≤ |z.im|) :
+    H →L[ℂ] H := by
+  classical
+  exact if h : ∃ R : H →L[ℂ] H, ∀ y, (R y, y + z • R y) ∈ T.graph then h.choose
+  else 0
+
+noncomputable def boundedGenerator (T : H →ₗ.[ℂ] H) (hs : IsSelfAdjoint T)
+    (r : ℝ) (hr : 1 ≤ r) : H →L[ℂ] H :=
+  ((r : ℂ)^2/2) •
+    (OAI.MinimalVertex.resolvent T hs ((r : ℂ)*Complex.I) (by simpa [abs_of_nonneg (by linarith : 0 ≤ r)] using hr) +
+     OAI.MinimalVertex.resolvent T hs (-((r : ℂ)*Complex.I)) (by simpa [abs_of_nonneg (by linarith : 0 ≤ r)] using hr))
+
+noncomputable def approximatingFlow (T : H →ₗ.[ℂ] H) (hs : IsSelfAdjoint T) (n : ℕ) (t : ℝ) : H →L[ℂ] H :=
+  (OAI.MinimalVertex.Code.StronglyRationalVOA.BoundedFlow.flow
+  (Complex.I • OAI.MinimalVertex.boundedGenerator T hs (↑n + 1) (le_add_of_nonneg_left (Nat.cast_nonneg n))) t)
+
+end OAI.MinimalVertex
+
+namespace OAI.MinimalVertex
+open Filter Set UniformSpace
+open scoped Topology MatrixGroups
+open StronglyRationalVOA
+
+noncomputable def flow {H : Type*} [NormedAddCommGroup H] [InnerProductSpace ℂ H] [CompleteSpace H]
+    (T : H →ₗ.[ℂ] H) (hs : IsSelfAdjoint T) (t : ℝ) : H →L[ℂ] H := by
+  classical
+  exact if h : ∃ L : H →L[ℂ] H, ∀ x,
+      Tendsto (fun n => OAI.MinimalVertex.approximatingFlow T hs n t x) atTop (𝓝 (L x)) then
+    h.choose
+  else 0
+
+noncomputable def projectiveStandardAction : PSL(2,ℝ) →* (OAI.MinimalVertex.Code.StronglyRationalVOA.CircleMobiusGeometry.Group) := by
+  classical
+  exact if h : ∃ L : PSL(2,ℝ) →* (OAI.MinimalVertex.Code.StronglyRationalVOA.CircleMobiusGeometry.Group),
+      ∀ M : SL(2,ℝ), ∃ F : OAI.StronglyRationalVOA.SmoothCircleLift, ∃ hF : (OAI.MinimalVertex.Code.StronglyRationalVOA.CircleMobiusGeometry.Implements M F),
+        L (QuotientGroup.mk M) =
+          QuotientGroup.mk (⟨F, M, hF⟩ : (OAI.MinimalVertex.Code.StronglyRationalVOA.CircleMobiusGeometry.lifts)) then h.choose
+  else 1
+
+structure IrreducibleConformalNetStructure {H : Type*} [NormedAddCommGroup H]
+    [InnerProductSpace ℂ H] [CompleteSpace H]
+    (N : OAI.StronglyRationalVOA.ProperCircleArc → VonNeumannAlgebra H) where
+  separable : TopologicalSpace.SeparableSpace H
+  carrier_congr : ∀ I J, (OAI.MinimalVertex.Code.StronglyRationalVOA.ProperCircleArc.carrier I)=(OAI.MinimalVertex.Code.StronglyRationalVOA.ProperCircleArc.carrier J) → N I=N J
+  isotony : ∀ I J, (OAI.MinimalVertex.Code.StronglyRationalVOA.ProperCircleArc.carrier I) ⊆ (OAI.MinimalVertex.Code.StronglyRationalVOA.ProperCircleArc.carrier J) → N I ≤ N J
+  locality : ∀ I J, Disjoint (OAI.MinimalVertex.Code.StronglyRationalVOA.ProperCircleArc.carrier I) (OAI.MinimalVertex.Code.StronglyRationalVOA.ProperCircleArc.carrier J) → N I ≤ (N J).commutant
+  mobius : PSL(2,ℝ) →* (H ≃ₗᵢ[ℂ] H)
+  mobius_continuous : Continuous mobius
+  diffeomorphism : OAI.MinimalVertex.Code.StronglyRationalVOA.SmoothCircleDiffeomorphism →* OAI.StronglyRationalVOA.ProjectiveUnitaryGroup H
+  diffeomorphism_continuous : Continuous diffeomorphism
+  extends_mobius : ∀ F, diffeomorphism ((OAI.MinimalVertex.Code.StronglyRationalVOA.CircleMobiusGeometry.inclusion) (OAI.MinimalVertex.projectiveStandardAction F))=QuotientGroup.mk (mobius F)
+  covariance : ∀ F I J, (OAI.MinimalVertex.Code.StronglyRationalVOA.ProperCircleArc.carrier J)=(OAI.MinimalVertex.Code.StronglyRationalVOA.SmoothCircleDiffeomorphism.action) F '' (OAI.MinimalVertex.Code.StronglyRationalVOA.ProperCircleArc.carrier I) →
+    ∀ B : H →L[ℂ] H, OAI.MinimalVertex.Code.StronglyRationalVOA.projectiveConjugation (diffeomorphism F) B ∈ N J ↔ B ∈ N I
+  local_action : ∀ F I, (∀ x ∈ (OAI.MinimalVertex.Code.StronglyRationalVOA.ProperCircleArc.carrier I), (OAI.MinimalVertex.Code.StronglyRationalVOA.SmoothCircleDiffeomorphism.action) F x=x) →
+    ∀ B ∈ N I, OAI.MinimalVertex.Code.StronglyRationalVOA.projectiveConjugation (diffeomorphism F) B=B
+  vacuum : H
+  vacuum_norm : ‖vacuum‖=1
+  vacuum_invariant : ∀ F, mobius F vacuum=vacuum
+  vacuum_unique : ∀ x : H, (∀ F, mobius F x=x) → ∃ c : ℂ, x=c • vacuum
+  vacuum_cyclic : (OAI.MinimalVertex.Code.StronglyRationalVOA.globalCyclicSpace N vacuum)=⊤
+  hamiltonian : H →ₗ.[ℂ] H
+  hamiltonian_selfAdjoint : IsSelfAdjoint hamiltonian
+  positive_energy : ∀ x y, (x,y) ∈ hamiltonian.graph → 0 ≤ (inner ℂ x y).re
+  rotation_flow : ∀ t : ℝ,
+    (mobius (QuotientGroup.mk (OAI.MinimalVertex.Code.StronglyRationalVOA.CircleMobiusGeometry.rotationMatrix t))).toLinearIsometry.toContinuousLinearMap=
+      OAI.MinimalVertex.flow hamiltonian hamiltonian_selfAdjoint t
+  irreducible : ∀ Q : H →L[ℂ] H, (∀ I, Q ∈ (N I).commutant) →
+    ∃ c : ℂ, Q=c • (1 : H →L[ℂ] H)
+
+end OAI.MinimalVertex
+
+namespace OAI.MinimalVertex
+open Filter Set UniformSpace
+open scoped Topology MatrixGroups
+open StronglyRationalVOA
+variable {V : Type u} [NormedAddCommGroup V] [InnerProductSpace ℂ V]
+  {A : CFTTypeVOA V} (U : A.UnitaryStructure)
+
+theorem main (_hSimple : A.toVertexAlgebra.IsSimple)
+    (hSR : A.IsStronglyRational.{u,v}) :
+    A.PolynomialEnergyBounds ∧ OAI.MinimalVertex.CKLWStrongLocal U hSR.2.2 ∧
+      Nonempty (OAI.MinimalVertex.IrreducibleConformalNetStructure (OAI.MinimalVertex.intervalAlgebra U hSR.2.2)) := by
+  sorry
+
+end OAI.MinimalVertex
+
+end
diff --git a/lean/ComparatorChallenges/VertexCover.json b/lean/ComparatorChallenges/VertexCover.json
new file mode 100644
index 0000000000000000000000000000000000000000..c53e8279ecb8e1952aa49294c5788d1b3be4f1bf
--- /dev/null
+++ b/lean/ComparatorChallenges/VertexCover.json
@@ -0,0 +1,15 @@
+{
+  "challenge_module": "ComparatorChallenges.VertexCover",
+  "solution_module": "OAI.Computability.VertexCover.Main",
+  "theorem_names": [
+    "OAI.VertexCover.explicit_cover_gap",
+    "OAI.VertexCover.every_fixed_factor_below_two"
+  ],
+  "definition_names": [],
+  "permitted_axioms": [
+    "propext",
+    "Quot.sound",
+    "Classical.choice"
+  ],
+  "enable_nanoda": false
+}
diff --git a/lean/ComparatorChallenges/VertexCover.lean b/lean/ComparatorChallenges/VertexCover.lean
new file mode 100644
index 0000000000000000000000000000000000000000..ffb0647a3284257c9db8b1872945c1ddc6d27c5e
--- /dev/null
+++ b/lean/ComparatorChallenges/VertexCover.lean
@@ -0,0 +1,154 @@
+import Mathlib
+
+namespace OAI
+
+namespace UniqueGames.BinaryFormula
+
+structure Literal where
+  name : Nat
+  positive : Bool
+  deriving DecidableEq
+
+def Literal.eval (literal : Literal) (assignment : Nat → Bool) : Bool :=
+  if literal.positive then assignment literal.name else !(assignment literal.name)
+
+abbrev Clause := Vector Literal 3
+
+def Clause.eval (clause : Clause) (assignment : Nat → Bool) : Bool :=
+  (clause[0].eval assignment || clause[1].eval assignment) || clause[2].eval assignment
+
+structure Formula where
+  clauses : List Clause
+
+def Formula.Satisfiable (F : Formula) : Prop :=
+  ∃ assignment : Nat → Bool, ∀ clause ∈ F.clauses, clause.eval assignment = true
+
+end UniqueGames.BinaryFormula
+
+namespace UniqueGames.BinaryEncoding
+
+open BinaryFormula
+
+def bitsValue : List Bool → Nat
+  | [] => 0
+  | b :: bits => Nat.bit b (bitsValue bits)
+
+def frame : List Bool → List Bool
+  | [] => [false]
+  | b :: bits => true :: b :: frame bits
+
+def parseFrame : List Bool → Option (List Bool × List Bool)
+  | false :: rest => some ([], rest)
+  | true :: b :: rest => do
+      let (bits, trailing) ← parseFrame rest
+      return (b :: bits, trailing)
+  | _ => none
+
+def nameBits (name : Nat) : List Bool := frame name.bits
+
+def parseName (input : List Bool) : Option (Nat × List Bool) := do
+  let (digits, rest) ← parseFrame input
+  let name := bitsValue digits
+  if digits = name.bits then some (name, rest) else none
+
+def parseLiteral : List Bool → Option (Literal × List Bool)
+  | sign :: input => do
+      let (name, rest) ← parseName input
+      return (⟨name, sign⟩, rest)
+  | [] => none
+
+def parseClause (input : List Bool) : Option (Clause × List Bool) := do
+  let (a, input) ← parseLiteral input
+  let (b, input) ← parseLiteral input
+  let (c, rest) ← parseLiteral input
+  return (#v[a, b, c], rest)
+
+def parseClauses : Nat → List Bool → Option (List Clause × List Bool)
+  | 0, _ => none
+  | _fuel + 1, false :: rest => some ([], rest)
+  | fuel + 1, true :: input => do
+      let (clause, input) ← parseClause input
+      let (clauses, rest) ← parseClauses fuel input
+      return (clause :: clauses, rest)
+  | _ + 1, [] => none
+
+def decodeFormula (input : List Bool) : Option Formula := do
+  let (clauses, rest) ← parseClauses (input.length + 1) input
+  if rest = [] then some ⟨clauses⟩ else none
+
+end UniqueGames.BinaryEncoding
+
+namespace VertexCover
+
+def ThreeSAT (input : List Bool) : Prop :=
+  ∃ formula, UniqueGames.BinaryEncoding.decodeFormula input = some formula ∧
+    formula.Satisfiable
+
+structure ExplicitGraph where
+  n : ℕ
+  edges : List (Fin n × Fin n)
+  increasing : ∀ e ∈ edges, e.1 < e.2
+  nodup : edges.Nodup
+
+namespace ExplicitGraph
+
+def Cover (G : ExplicitGraph) (S : Finset (Fin G.n)) : Prop :=
+  ∀ e ∈ G.edges, e.1 ∈ S ∨ e.2 ∈ S
+
+instance (G : ExplicitGraph) (S : Finset (Fin G.n)) : Decidable (G.Cover S) :=
+  inferInstanceAs (Decidable (∀ e ∈ G.edges, e.1 ∈ S ∨ e.2 ∈ S))
+
+noncomputable def coverNumber (G : ExplicitGraph) : ℕ :=
+  Nat.find (show ∃ k : ℕ, ∃ S : Finset (Fin G.n), G.Cover S ∧ S.card = k from
+    ⟨G.n, Finset.univ, by simp [Cover], by simp⟩)
+
+def bits (G : ExplicitGraph) : List Bool :=
+  let names := [G.n] ++ List.range G.n ++ [G.edges.length] ++
+    G.edges.flatMap (fun e => [e.1.val, e.2.val])
+  names.flatMap UniqueGames.BinaryEncoding.nameBits
+
+end ExplicitGraph
+
+def FiniteAlphabet (M : Turing.FinTM2) : Prop := ∀ k, Finite (M.Γ k)
+
+structure GapReduction (m : ℕ) where
+  construct : List Bool → ExplicitGraph
+  computation : Turing.TM2ComputableInPolyTime (id : List Bool → List Bool)
+    ExplicitGraph.bits construct
+  finiteAlphabet : FiniteAlphabet computation.tm
+  completeness : ∀ input, ThreeSAT input →
+    ((construct input).coverNumber : ℝ) <
+      (1 / 2 + 1 / (m : ℝ)) * (construct input).n
+  soundness : ∀ input, ¬ ThreeSAT input →
+    (1 - 1 / (m : ℝ)) * (construct input).n <
+      ((construct input).coverNumber : ℝ)
+
+def natListBits (L : List ℕ) : List Bool :=
+  (L.length :: L).flatMap UniqueGames.BinaryEncoding.nameBits
+
+structure Approximation (α : ℝ) where
+  run : ExplicitGraph → List ℕ
+  computation : Turing.TM2ComputableInPolyTime ExplicitGraph.bits natListBits run
+  finiteAlphabet : FiniteAlphabet computation.tm
+  nodup : ∀ G, (run G).Nodup
+  vertices : ∀ G, ∀ v ∈ run G, v < G.n
+  covers : ∀ G, ∀ e ∈ G.edges, e.1.val ∈ run G ∨ e.2.val ∈ run G
+  quality : ∀ G, ((run G).length : ℝ) ≤ α * (G.coverNumber : ℝ)
+
+structure ThreeSATDecision where
+  run : List Bool → Bool
+  computation : Turing.TM2ComputableInPolyTime (id : List Bool → List Bool)
+    (fun b : Bool => [b]) run
+  finiteAlphabet : FiniteAlphabet computation.tm
+  correct : ∀ input, run input = true ↔ ThreeSAT input
+
+theorem explicit_cover_gap (m : ℕ) (hm : 4 ≤ m) : Nonempty (GapReduction m) := by
+  sorry
+
+theorem every_fixed_factor_below_two (α : ℝ) (hα : 1 ≤ α) (hα2 : α < 2)
+    (algorithm : Approximation α) : Nonempty ThreeSATDecision := by
+  sorry
+
+end VertexCover
+
+end OAI
diff --git a/lean/ComparatorChallenges/VlasovMaxwell.json b/lean/ComparatorChallenges/VlasovMaxwell.json
new file mode 100644
index 0000000000000000000000000000000000000000..558493b4107fdcb3df27126603008c47ec4a2554
--- /dev/null
+++ b/lean/ComparatorChallenges/VlasovMaxwell.json
@@ -0,0 +1,14 @@
+{
+  "challenge_module": "ComparatorChallenges.VlasovMaxwell",
+  "solution_module": "OAI.Analysis.VlasovMaxwell.Main",
+  "theorem_names": [
+    "OAI.RVM.global_classical_solution"
+  ],
+  "definition_names": [],
+  "permitted_axioms": [
+    "propext",
+    "Quot.sound",
+    "Classical.choice"
+  ],
+  "enable_nanoda": false
+}
diff --git a/lean/ComparatorChallenges/VlasovMaxwell.lean b/lean/ComparatorChallenges/VlasovMaxwell.lean
new file mode 100644
index 0000000000000000000000000000000000000000..38b6c73916a07c182e16c50652c1a7e30b5412d0
--- /dev/null
+++ b/lean/ComparatorChallenges/VlasovMaxwell.lean
@@ -0,0 +1,112 @@
+import Mathlib
+
+namespace OAI
+
+noncomputable section
+open MeasureTheory Set
+open scoped ContDiff
+namespace RVM
+
+abbrev Vec := EuclideanSpace ℝ (Fin 3)
+abbrev Phase := Vec × Vec
+abbrev Particle := ℝ × Phase → ℝ
+abbrev Field := ℝ × Vec → Vec
+
+def q (v : Vec) : ℝ := Real.sqrt (1 + ‖v‖ ^ 2)
+def velocity (v : Vec) : Vec := (q v)⁻¹ • v
+
+def basis (i : Fin 3) : Vec := WithLp.toLp 2 (Pi.single i (1 : ℝ))
+def dot (a b : Vec) : ℝ := ∑ i : Fin 3, a i * b i
+def cross (a b : Vec) : Vec := WithLp.toLp 2
+  ![a 1 * b 2 - a 2 * b 1, a 2 * b 0 - a 0 * b 2,
+    a 0 * b 1 - a 1 * b 0]
+
+def spatialPartial (g : Vec → ℝ) (x : Vec) (i : Fin 3) : ℝ :=
+  fderiv ℝ g x (basis i)
+def divergence (F : Vec → Vec) (x : Vec) : ℝ :=
+  ∑ i : Fin 3, spatialPartial (fun y => F y i) x i
+
+def curl (F : Vec → Vec) (x : Vec) : Vec := WithLp.toLp 2
+  ![spatialPartial (fun y => F y 2) x 1 - spatialPartial (fun y => F y 1) x 2,
+    spatialPartial (fun y => F y 0) x 2 - spatialPartial (fun y => F y 2) x 0,
+    spatialPartial (fun y => F y 1) x 0 - spatialPartial (fun y => F y 0) x 1]
+
+def rho (g : Phase → ℝ) (x : Vec) : ℝ := ∫ v : Vec, g (x, v)
+def current (g : Phase → ℝ) (x : Vec) : Vec :=
+  ∫ v : Vec, g (x, v) • velocity v
+
+structure Datum where
+  f₀ : Phase → ℝ
+  E₀ : Vec → Vec
+  B₀ : Vec → Vec
+
+def BoundedSmooth (F : Vec → Vec) : Prop :=
+  ContDiff ℝ ∞ F ∧ ∀ n : ℕ, ∃ C : ℝ, ∀ x : Vec,
+    ‖iteratedFDeriv ℝ n F x‖ ≤ C
+
+def Admissible (d : Datum) : Prop :=
+  ContDiff ℝ ∞ d.f₀ ∧ HasCompactSupport d.f₀ ∧ (∀ z, 0 ≤ d.f₀ z) ∧
+  BoundedSmooth d.E₀ ∧ BoundedSmooth d.B₀ ∧
+  MemLp d.E₀ 2 volume ∧ MemLp d.B₀ 2 volume ∧
+  (∀ x, divergence d.E₀ x = rho d.f₀ x) ∧
+  (∀ x, divergence d.B₀ x = 0)
+
+structure Solution where
+  f : Particle
+  E : Field
+  B : Field
+
+def particleHalfSpace : Set (ℝ × Phase) := {z | 0 ≤ z.1}
+def fieldHalfSpace : Set (ℝ × Vec) := {z | 0 ≤ z.1}
+def particleSlab (T : ℝ) : Set (ℝ × Phase) := {z | z.1 ∈ Icc 0 T}
+def fieldSlab (T : ℝ) : Set (ℝ × Vec) := {z | z.1 ∈ Icc 0 T}
+
+def TimeContinuousL2 (F : Field) : Prop :=
+  ∃ F₂ : ℝ → Lp Vec 2 (volume : Measure Vec),
+    ContinuousOn F₂ (Ici 0) ∧
+    ∀ t, 0 ≤ t → (F₂ t : Vec → Vec) =ᵐ[volume] (fun x => F (t, x))
+
+def Equations (s : Solution) : Prop := ∀ t, 0 ≤ t →
+  (∀ x v,
+    derivWithin (fun t' => s.f (t', x, v)) (Ici 0) t +
+    (∑ i : Fin 3, velocity v i * spatialPartial (fun y => s.f (t, y, v)) x i) +
+    (∑ i : Fin 3, (s.E (t, x) + cross (velocity v) (s.B (t, x))) i *
+      spatialPartial (fun v' => s.f (t, x, v')) v i) = 0) ∧
+  (∀ x, derivWithin (fun t' => s.E (t', x)) (Ici 0) t -
+    curl (fun y => s.B (t, y)) x = -current (fun z => s.f (t, z)) x) ∧
+  (∀ x, derivWithin (fun t' => s.B (t', x)) (Ici 0) t +
+    curl (fun y => s.E (t, y)) x = 0) ∧
+  (∀ x, divergence (fun y => s.E (t, y)) x = rho (fun z => s.f (t, z)) x) ∧
+  (∀ x, divergence (fun y => s.B (t, y)) x = 0)
+
+def CompactOnFiniteHorizons (s : Solution) : Prop :=
+  ∀ T : ℝ, 0 ≤ T → ∃ K : Set Phase, IsCompact K ∧
+    ∀ t ∈ Icc 0 T, tsupport (fun z => s.f (t, z)) ⊆ K
+
+def Classical (d : Datum) (s : Solution) : Prop :=
+  ContDiffOn ℝ 1 s.f particleHalfSpace ∧
+  ContDiffOn ℝ 1 s.E fieldHalfSpace ∧ ContDiffOn ℝ 1 s.B fieldHalfSpace ∧
+  (∀ t, 0 ≤ t → ∀ z, 0 ≤ s.f (t, z)) ∧
+  TimeContinuousL2 s.E ∧ TimeContinuousL2 s.B ∧
+  CompactOnFiniteHorizons s ∧ Equations s ∧
+  (∀ z, s.f (0, z) = d.f₀ z) ∧
+  (∀ x, s.E (0, x) = d.E₀ x) ∧ (∀ x, s.B (0, x) = d.B₀ x)
+
+def SmoothOnFiniteHorizons (s : Solution) : Prop := ∀ T : ℝ, 0 ≤ T →
+  ContDiffOn ℝ ∞ s.f (particleSlab T) ∧
+  ContDiffOn ℝ ∞ s.E (fieldSlab T) ∧ ContDiffOn ℝ ∞ s.B (fieldSlab T)
+
+def SameNonnegativeTime (s s' : Solution) : Prop := ∀ t, 0 ≤ t →
+  (∀ z, s.f (t, z) = s'.f (t, z)) ∧
+  (∀ x, s.E (t, x) = s'.E (t, x)) ∧ (∀ x, s.B (t, x) = s'.B (t, x))
+
+theorem global_classical_solution (d : Datum) (hd : Admissible d) :
+    ∃ s : Solution, Classical d s ∧ SmoothOnFiniteHorizons s ∧
+      ∀ s' : Solution, Classical d s' → SameNonnegativeTime s s' := by
+  sorry
+
+end RVM
+
+end
+
+end OAI
diff --git a/lean/ComparatorChallenges/WLIdentification.json b/lean/ComparatorChallenges/WLIdentification.json
new file mode 100644
index 0000000000000000000000000000000000000000..c0008253f706cede39936f53b21a992a98ab80d5
--- /dev/null
+++ b/lean/ComparatorChallenges/WLIdentification.json
@@ -0,0 +1,14 @@
+{
+  "challenge_module": "ComparatorChallenges.WLIdentification",
+  "solution_module": "OAI.Computability.WLIdentification.Main",
+  "theorem_names": [
+    "OAI.WLIdentification.main"
+  ],
+  "definition_names": [],
+  "permitted_axioms": [
+    "propext",
+    "Quot.sound",
+    "Classical.choice"
+  ],
+  "enable_nanoda": false
+}
diff --git a/lean/ComparatorChallenges/WLIdentification.lean b/lean/ComparatorChallenges/WLIdentification.lean
new file mode 100644
index 0000000000000000000000000000000000000000..9e922ae71265a0cc363f3d24be42cc26fa8cd0aa
--- /dev/null
+++ b/lean/ComparatorChallenges/WLIdentification.lean
@@ -0,0 +1,146 @@
+import Mathlib
+
+namespace OAI
+
+namespace WLIdentification
+
+structure Graph where
+  order : ℕ
+  edge : Fin order → Fin order → Bool
+  symmetric : ∀ u v, edge u v = edge v u
+  loopless : ∀ u, edge u u = false
+
+def Isomorphic (G H : Graph) : Prop :=
+  ∃ e : Fin G.order ≃ Fin H.order, ∀ u v, G.edge u v = H.edge (e u) (e v)
+
+/-- Colors retain their full history, and hence are shared between graphs. -/
+def NeighborColor : ℕ → Type
+  | 0 => Unit
+  | s + 1 => NeighborColor s × Multiset (NeighborColor s)
+
+def neighborColor (G : Graph) : (s : ℕ) → Fin G.order → NeighborColor s
+  | 0, _ => ()
+  | s + 1, v => (neighborColor G s v,
+      (Finset.univ.filter (fun w => G.edge v w = true)).val.map (neighborColor G s))
+
+def neighborHistogram (G : Graph) (s : ℕ) : Multiset (NeighborColor s) :=
+  Finset.univ.val.map (neighborColor G s)
+
+def TupleColor (k : ℕ) : ℕ → Type
+  | 0 => (Fin k → Fin k → Bool) × (Fin k → Fin k → Bool)
+  | s + 1 => TupleColor k s × Multiset (Fin k → TupleColor k s)
+
+/-- Joint update: one multiset of whole replacement vectors, not independent marginals. -/
+def tupleColor (G : Graph) (k : ℕ) : (s : ℕ) → (Fin k → Fin G.order) → TupleColor k s
+  | 0, v => (fun i j => decide (v i = v j), fun i j => G.edge (v i) (v j))
+  | s + 1, v => (tupleColor G k s v,
+      Finset.univ.val.map (fun z => fun i => tupleColor G k s (Function.update v i z)))
+
+def tupleHistogram (G : Graph) (k s : ℕ) : Multiset (TupleColor k s) :=
+  Finset.univ.val.map (tupleColor G k s)
+
+def Equivalent (k : ℕ) (G H : Graph) : Prop :=
+  if k = 1 then ∀ s, neighborHistogram G s = neighborHistogram H s
+  else ∀ s, tupleHistogram G k s = tupleHistogram H k s
+
+/-- There is no restriction to mates from a graph construction or to a selected order. -/
+def Identifies (k : ℕ) (G : Graph) : Prop :=
+  ∀ H : Graph, Equivalent k G H → Isomorphic G H
+
+/-- The infimum of the positive identifying dimensions; this set is nonempty for finite G. -/
+noncomputable def WLdim (G : Graph) : ℕ :=
+  sInf {k : ℕ | 0 < k ∧ Identifies k G}
+
+abbrev Word := List Bool
+abbrev BinaryLanguage := Set Word
+
+def binaryValue (bits : Word) : ℕ :=
+  bits.foldl (fun z b => 2 * z + if b then 1 else 0) 0
+
+def matrixWord (G : Graph) : Word :=
+  (List.ofFn (fun i : Fin G.order => List.ofFn (G.edge i))).flatten
+
+/-- Unary order header, row-major binary matrix, then most-significant-first binary k. -/
+def inputWord (G : Graph) (bits : Word) : Word :=
+  List.replicate G.order true ++ [false] ++ matrixWord G ++ bits
+
+/-- A malformed word is rejected: membership requires a valid nonempty simple matrix and k>0. -/
+def dimensionLanguage : BinaryLanguage :=
+  {w | ∃ (G : Graph) (bits : Word),
+    0 < G.order ∧ (∃ tail, bits = true :: tail) ∧ 0 < binaryValue bits ∧
+    w = inputWord G bits ∧ WLdim G ≤ binaryValue bits}
+
+/- The deterministic local machine model is explicit; no oracle or arbitrary
+   state-transition on whole inputs is included. Both alphabets are fixed finite
+   types for each machine. Extra symbols and states allow arbitrary finite tables. -/
+inductive Move where
+  | left | stay | right
+  deriving DecidableEq
+
+def Move.displacement : Move → ℤ
+  | .left => -1
+  | .stay => 0
+  | .right => 1
+
+structure Machine where
+  extraSymbols : ℕ
+  extraStates : ℕ
+  transition : Fin (extraStates + 3) → Fin (extraSymbols + 3) →
+    Fin (extraStates + 3) × Fin (extraSymbols + 3) × Move
+
+structure Configuration (M : Machine) where
+  state : Fin (M.extraStates + 3)
+  head : ℤ
+  tape : ℤ → Fin (M.extraSymbols + 3)
+
+def inputSymbol (M : Machine) (b : Bool) : Fin (M.extraSymbols + 3) :=
+  if b then 2 else 1
+
+def initial (M : Machine) (w : Word) : Configuration M where
+  state := 0
+  head := 0
+  tape z := if 0 ≤ z then (w[z.toNat]?).elim 0 (inputSymbol M) else 0
+
+def Halted {M : Machine} (c : Configuration M) : Prop :=
+  c.state = 1 ∨ c.state = 2
+
+/-- One read/write/head-movement transition. A halted configuration is frozen. -/
+def step (M : Machine) (c : Configuration M) : Configuration M :=
+  if c.state = 1 ∨ c.state = 2 then c else
+    let t := M.transition c.state (c.tape c.head)
+    { state := t.1, head := c.head + t.2.2.displacement,
+      tape := Function.update c.tape c.head t.2.1 }
+
+def run (M : Machine) (w : Word) (t : ℕ) : Configuration M :=
+  (step M)^[t] (initial M w)
+
+/-- Output is the binary word beginning at origin and ending at its first blank. -/
+def Output {M : Machine} (c : Configuration M) (w : Word) : Prop :=
+  (∀ i : Fin w.length, c.tape (i.val : ℤ) = inputSymbol M w[i]) ∧
+    c.tape (w.length : ℤ) = 0
+
+/-- Uniform genuine executions on every bit word, including malformed graph words. -/
+def DecidesWithin (M : Machine) (L : BinaryLanguage) (bound : ℕ → ℕ) : Prop :=
+  ∀ w, ∃ t ≤ bound w.length, Halted (run M w t) ∧ ((run M w t).state = 1 ↔ w ∈ L)
+
+def InEXPTIME (L : BinaryLanguage) : Prop :=
+  ∃ (M : Machine) (C d : ℕ),
+    DecidesWithin M L (fun n => 2 ^ (C * (n + 1) ^ d))
+
+def ComputesWithin (M : Machine) (f : Word → Word) (bound : ℕ → ℕ) : Prop :=
+  ∀ w, ∃ t ≤ bound w.length, (run M w t).state = 1 ∧ Output (run M w t) (f w)
+
+def PolytimeManyOne (L S : BinaryLanguage) : Prop :=
+  ∃ (f : Word → Word) (M : Machine) (C d : ℕ),
+    ComputesWithin M f (fun n => C * (n + 1) ^ d) ∧ ∀ w, w ∈ L ↔ f w ∈ S
+
+def EXPTIMEComplete (S : BinaryLanguage) : Prop :=
+  InEXPTIME S ∧ ∀ L : BinaryLanguage, InEXPTIME L → PolytimeManyOne L S
+
+theorem main : EXPTIMEComplete dimensionLanguage :=
+  by
+    sorry
+
+end WLIdentification
+
+end OAI
diff --git a/lean/ComparatorChallenges/WeakHessian.json b/lean/ComparatorChallenges/WeakHessian.json
new file mode 100644
index 0000000000000000000000000000000000000000..942159005dddd1337ac8a1decb1a874755c03dfd
--- /dev/null
+++ b/lean/ComparatorChallenges/WeakHessian.json
@@ -0,0 +1,14 @@
+{
+  "challenge_module": "ComparatorChallenges.WeakHessian",
+  "solution_module": "OAI.Geometry.WeakHessian.Main",
+  "theorem_names": [
+    "OAI.WeakHessian.every_geodesic"
+  ],
+  "definition_names": [],
+  "permitted_axioms": [
+    "propext",
+    "Quot.sound",
+    "Classical.choice"
+  ],
+  "enable_nanoda": false
+}
diff --git a/lean/ComparatorChallenges/WeakHessian.lean b/lean/ComparatorChallenges/WeakHessian.lean
new file mode 100644
index 0000000000000000000000000000000000000000..1feec821ba1b56fcf272bcb034005aba75f13691
--- /dev/null
+++ b/lean/ComparatorChallenges/WeakHessian.lean
@@ -0,0 +1,233 @@
+import Mathlib
+
+namespace OAI
+
+open Set Filter MeasureTheory
+open scoped ENNReal NNReal Topology
+
+noncomputable section
+attribute [local instance] Classical.propDecidable
+namespace WeakHessian
+
+abbrev Time := Set.Icc (0 : ℝ) 1
+
+def timeZero : Time := ⟨0, le_rfl, zero_le_one⟩
+def timeOne : Time := ⟨1, zero_le_one, le_rfl⟩
+
+def clampTime (t : ℝ) : Time :=
+  ⟨max 0 (min 1 t), le_max_left _ _, max_le zero_le_one (min_le_left _ _)⟩
+
+variable {X : Type*} [MetricSpace X]
+
+abbrev Curve (X : Type*) [MetricSpace X] := C(Time, X)
+
+instance curveMeasurableSpace : MeasurableSpace (Curve X) := borel (Curve X)
+
+instance curveBorelSpace : BorelSpace (Curve X) := ⟨rfl⟩
+
+def evalReal (γ : Curve X) (t : ℝ) : X := γ (clampTime t)
+
+/-- The constant-speed minimizing parametrization, including constant curves. -/
+def IsGeodesic (γ : Curve X) : Prop :=
+  ∀ s t : Time,
+    dist (γ s) (γ t) = |(s : ℝ) - (t : ℝ)| * dist (γ timeZero) (γ timeOne)
+
+/-- Metric speed. Limsup agrees a.e. with the metric derivative on AC² curves. -/
+def metricSpeed (γ : Curve X) (t : ℝ) : ℝ≥0∞ :=
+  Filter.limsup (fun s : ℝ => ENNReal.ofReal
+    (dist (evalReal γ s) (evalReal γ t) / |s - t|)) (𝓝[≠] t)
+
+/-- Absolute continuity with a square-integrable metric control. -/
+def IsAC2 (γ : Curve X) : Prop :=
+  ∃ a : ℝ → ℝ≥0∞, Measurable a ∧
+    (∫⁻ t in Set.Icc (0 : ℝ) 1, (a t) ^ 2) < ∞ ∧
+    ∀ s t : Time, (s : ℝ) ≤ (t : ℝ) →
+      edist (γ s) (γ t) ≤ ∫⁻ r in Set.Icc (s : ℝ) (t : ℝ), a r
+
+variable [MeasurableSpace X] [BorelSpace X]
+
+/-- A 2-test plan: bounded compression and finite average kinetic energy. -/
+def IsTestPlan (m : Measure X) (π : Measure (Curve X)) : Prop :=
+  IsProbabilityMeasure π ∧
+  (∃ C : ℝ≥0, ∀ t : Time,
+    Measure.map (fun γ : Curve X => γ t) π ≤ (C : ℝ≥0∞) • m) ∧
+  (∀ᵐ γ ∂π, IsAC2 γ) ∧
+  (∫⁻ γ, ∫⁻ t in Set.Icc (0 : ℝ) 1, (metricSpeed γ t) ^ 2 ∂volume ∂π) < ∞
+
+/-- Uniform bounded spatial support; used only to define the local Sobolev class. -/
+def BoundedTracks (π : Measure (Curve X)) : Prop :=
+  ∃ o : X, ∃ R : ℝ, 0 < R ∧ ∀ᵐ γ ∂π, ∀ t : Time, dist (γ t) o ≤ R
+
+def LocallyL2 (m : Measure X) (f : X → ℝ) : Prop :=
+  ∀ o : X, ∀ R : ℝ, 0 < R → MemLp f 2 (m.restrict (Metric.ball o R))
+
+/-- Local weak upper gradients, in the integrated test-plan definition. -/
+def IsLocalWeakUpperGradient (m : Measure X) (f D : X → ℝ) : Prop :=
+  LocallyL2 m D ∧ (∀ᵐ x ∂m, 0 ≤ D x) ∧
+  ∀ π : Measure (Curve X), IsTestPlan m π → BoundedTracks π →
+    (∫⁻ γ, ENNReal.ofReal |f (γ timeOne) - f (γ timeZero)| ∂π) ≤
+      ∫⁻ γ, ∫⁻ t in Set.Icc (0 : ℝ) 1,
+        ENNReal.ofReal (D (evalReal γ t)) * metricSpeed γ t ∂volume ∂π
+
+def IsMinimalLocalWeakUpperGradient (m : Measure X) (f D : X → ℝ) : Prop :=
+  IsLocalWeakUpperGradient m f D ∧
+  ∀ D' : X → ℝ, IsLocalWeakUpperGradient m f D' → ∀ᵐ x ∂m, D x ≤ D' x
+
+/-- A representative of the minimal weak upper gradient (zero off its domain). -/
+def weakGradient (m : Measure X) (f : X → ℝ) : X → ℝ :=
+  if h : ∃ D, IsMinimalLocalWeakUpperGradient m f D then Classical.choose h
+  else 0
+
+def LocalSobolev (m : Measure X) (f : X → ℝ) : Prop :=
+  LocallyL2 m f ∧ ∃ D, IsMinimalLocalWeakUpperGradient m f D
+
+def Sobolev (m : Measure X) (f : X → ℝ) : Prop :=
+  MemLp f 2 m ∧ LocalSobolev m f ∧ MemLp (weakGradient m f) 2 m
+
+/-- Polarization of the minimal weak gradient on an infinitesimally Hilbertian space. -/
+def gamma (m : Measure X) (f g : X → ℝ) (x : X) : ℝ :=
+  ((weakGradient m (fun y => f y + g y) x) ^ 2 -
+    (weakGradient m (fun y => f y - g y) x) ^ 2) / 4
+
+/-- Weak nonpositive generator convention, without a global L² assumption on F. -/
+def IsLaplacian (m : Measure X) (u L : X → ℝ) : Prop :=
+  Sobolev m u ∧ MemLp L 2 m ∧
+    ∀ v : X → ℝ, Sobolev m v →
+      (∫ x, gamma m u v x ∂m) = -(∫ x, L x * v x ∂m)
+
+def InLaplacianDomain (m : Measure X) (u : X → ℝ) : Prop :=
+  ∃ L, IsLaplacian m u L
+
+def laplacian (m : Measure X) (u : X → ℝ) : X → ℝ :=
+  if h : ∃ L, IsLaplacian m u L then Classical.choose h else 0
+
+def BoundedFunction (f : X → ℝ) : Prop := ∃ B : ℝ, ∀ x, |f x| ≤ B
+
+def GloballyLipschitz (f : X → ℝ) : Prop := ∃ L : ℝ≥0, LipschitzWith L f
+
+/-- Bounded globally Lipschitz Laplacian-domain functions with Sobolev Laplacian. -/
+def IsTestFunction (m : Measure X) (g : X → ℝ) : Prop :=
+  InLaplacianDomain m g ∧ BoundedFunction g ∧ GloballyLipschitz g ∧
+    Sobolev m (laplacian m g)
+
+/-- The weak Hessian, with ∇_(∇g)∇g = ∇(Γ(g)/2). -/
+def weakHessian (m : Measure X) (F g h : X → ℝ) : ℝ :=
+  -(∫ x, (gamma m h g x + h x * laplacian m g x) * gamma m F g x ∂m) -
+    ∫ x, h x * gamma m F (fun y => gamma m g g y / 2) x ∂m
+
+def WeakHessianUpperBound (m : Measure X) (F G : X → ℝ) : Prop :=
+  ∀ g : X → ℝ, IsTestFunction m g → HasCompactSupport g →
+    ∀ h : X → ℝ, GloballyLipschitz h → HasCompactSupport h →
+      (∀ x, 0 ≤ h x) →
+      weakHessian m F g h ≤ ∫ x, h x * G x * gamma m g g x ∂m
+
+/-- Asymptotic Lipschitz slope; zero at an isolated point. -/
+def localSlope (f : X → ℝ) (x : X) : ℝ≥0∞ :=
+  Filter.limsup (fun y => ENNReal.ofReal (|f y - f x| / dist y x)) (𝓝[≠] x)
+
+/-- Cheeger energy is the L² relaxation of one half the squared local slope. -/
+def cheegerEnergy (m : Measure X) (f : X → ℝ) : ℝ≥0∞ :=
+  if MemLp f 2 m then
+    sInf {a | ∃ fs : ℕ → X → ℝ,
+      (∀ n, GloballyLipschitz (fs n) ∧ MemLp (fs n) 2 m) ∧
+      Tendsto (fun n => eLpNorm (fun x => fs n x - f x) 2 m) atTop (𝓝 0) ∧
+      a = Filter.liminf (fun n => (2 : ℝ≥0∞)⁻¹ *
+        ∫⁻ x, (localSlope (fs n) x) ^ 2 ∂m) atTop}
+  else ∞
+
+def QuadraticCheegerEnergy (m : Measure X) : Prop :=
+  ∀ f g : X → ℝ, cheegerEnergy m f < ∞ → cheegerEnergy m g < ∞ →
+    cheegerEnergy m (fun x => f x + g x) + cheegerEnergy m (fun x => f x - g x) =
+      2 * cheegerEnergy m f + 2 * cheegerEnergy m g
+
+/-- The unreduced Lott–Sturm–Villani distortion coefficient σ. -/
+def sigmaCoeff (K N t θ : ℝ) : ℝ≥0∞ :=
+  if t ≤ 0 then 0 else if 1 ≤ t then 1 else
+  if θ = 0 then ENNReal.ofReal t else
+  if 0 < K then
+    if K * θ ^ 2 < N * Real.pi ^ 2 then
+      ENNReal.ofReal (Real.sin (t * θ * Real.sqrt (K / N)) /
+        Real.sin (θ * Real.sqrt (K / N)))
+    else ∞
+  else if K = 0 then ENNReal.ofReal t else
+    ENNReal.ofReal (Real.sinh (t * θ * Real.sqrt (-K / N)) /
+      Real.sinh (θ * Real.sqrt (-K / N)))
+
+/-- The τ coefficient (not the reduced σ coefficient) in CD(K,N). -/
+def tauCoeff (K N t θ : ℝ) : ℝ≥0∞ :=
+  (ENNReal.ofReal t) ^ (1 / N) * (sigmaCoeff K (N - 1) t θ) ^ ((N - 1) / N)
+
+def HasSecondMoment (μ : Measure X) : Prop :=
+  ∃ o : X, (∫⁻ x, (edist x o) ^ 2 ∂μ) < ∞
+
+def IsCoupling (q : Measure (X × X)) (μ₀ μ₁ : Measure X) : Prop :=
+  Measure.map Prod.fst q = μ₀ ∧ Measure.map Prod.snd q = μ₁
+
+def QuadraticTransportCost (q : Measure (X × X)) : ℝ≥0∞ :=
+  ∫⁻ p, (edist p.1 p.2) ^ 2 ∂q
+
+def IsOptimalCoupling (q : Measure (X × X)) (μ₀ μ₁ : Measure X) : Prop :=
+  IsCoupling q μ₀ μ₁ ∧ ∀ q' : Measure (X × X), IsCoupling q' μ₀ μ₁ →
+    QuadraticTransportCost q ≤ QuadraticTransportCost q'
+
+def endpointCoupling (π : Measure (Curve X)) : Measure (X × X) :=
+  Measure.map (fun γ : Curve X => (γ timeZero, γ timeOne)) π
+
+def interpolation (π : Measure (Curve X)) (t : Time) : Measure X :=
+  Measure.map (fun γ : Curve X => γ t) π
+
+/-- The positive of minus the N-Rényi entropy; singular mass contributes zero. -/
+def renyiIntegral (m μ : Measure X) (N : ℝ) : ℝ≥0∞ :=
+  ∫⁻ x, (μ.rnDeriv m x) ^ (1 - 1 / N) ∂m
+
+/-- Unreduced CD(K,N), written with the standard dynamical optimal-plan formula. -/
+def CurvatureDimension (m : Measure X) (K N : ℝ) : Prop :=
+  ∀ μ₀ μ₁ : Measure X,
+    IsProbabilityMeasure μ₀ → IsProbabilityMeasure μ₁ →
+    HasSecondMoment μ₀ → HasSecondMoment μ₁ →
+    μ₀ ≪ m → μ₁ ≪ m →
+    ∃ π : Measure (Curve X), IsProbabilityMeasure π ∧
+      (∀ᵐ γ ∂π, IsGeodesic γ) ∧
+      IsOptimalCoupling (endpointCoupling π) μ₀ μ₁ ∧
+      ∀ N' : ℝ, N ≤ N' → ∀ t : Time,
+        (∫⁻ γ,
+          (tauCoeff K N' (1 - (t : ℝ)) (dist (γ timeZero) (γ timeOne)) *
+            (μ₀.rnDeriv m (γ timeZero)) ^ (-1 / N') +
+          tauCoeff K N' (t : ℝ) (dist (γ timeZero) (γ timeOne)) *
+            (μ₁.rnDeriv m (γ timeOne)) ^ (-1 / N')) ∂π) ≤
+        renyiIntegral m (interpolation π t) N'
+
+def RCD (m : Measure X) (K N : ℝ) : Prop :=
+  CurvatureDimension m K N ∧ QuadraticCheegerEnergy m
+
+def FullSupport (m : Measure X) : Prop :=
+  ∀ U : Set X, IsOpen U → U.Nonempty → 0 < m U
+
+def FiniteOnBoundedSets (m : Measure X) : Prop :=
+  ∀ B : Set X, Bornology.IsBounded B → m B < ∞
+
+/-- The literal second-distributional-derivative conclusion on (0,1). -/
+def CurveSecondDerivativeBound (F G : X → ℝ) (σ : Curve X) : Prop :=
+  ∀ φ : ℝ → ℝ, ContDiff ℝ ((⊤ : ℕ∞) : WithTop ℕ∞) φ → HasCompactSupport φ →
+    tsupport φ ⊆ Set.Ioo (0 : ℝ) 1 → (∀ t, 0 ≤ φ t) →
+    (∫ t in Set.Icc (0 : ℝ) 1,
+      F (evalReal σ t) * deriv (deriv φ) t) ≤
+    (dist (σ timeZero) (σ timeOne)) ^ 2 *
+      ∫ t in Set.Icc (0 : ℝ) 1, G (evalReal σ t) * φ t
+
+/-- A weak upper Hessian bound controls the second distributional derivative
+along every constant-speed minimizing geodesic. -/
+theorem every_geodesic [CompleteSpace X] [TopologicalSpace.SeparableSpace X]
+    (m : Measure X) (K N : ℝ) (hN : 1 < N)
+    (hfull : FullSupport m) (hfinite : FiniteOnBoundedSets m) (hrcd : RCD m K N)
+    (F G : X → ℝ) (hFbound : BoundedFunction F) (hFlip : GloballyLipschitz F)
+    (hGbound : BoundedFunction G) (hGcont : Continuous G)
+    (hHess : WeakHessianUpperBound m F G)
+    (σ : Curve X) (hσ : IsGeodesic σ) : CurveSecondDerivativeBound F G σ := by
+  sorry
+
+end WeakHessian
+
+end
+
+end OAI
diff --git a/lean/ComparatorChallenges/WeakMTWGlobalSupport.json b/lean/ComparatorChallenges/WeakMTWGlobalSupport.json
new file mode 100644
index 0000000000000000000000000000000000000000..f0a8b93d8fe8975109bcf8626807998f7e488d5c
--- /dev/null
+++ b/lean/ComparatorChallenges/WeakMTWGlobalSupport.json
@@ -0,0 +1,14 @@
+{
+  "challenge_module": "ComparatorChallenges.WeakMTWGlobalSupport",
+  "solution_module": "OAI.Geometry.WeakMTW.Main",
+  "theorem_names": [
+    "OAI.WeakMTWGlobalSupport.current_main_convexity"
+  ],
+  "definition_names": [],
+  "permitted_axioms": [
+    "propext",
+    "Quot.sound",
+    "Classical.choice"
+  ],
+  "enable_nanoda": false
+}
diff --git a/lean/ComparatorChallenges/WeakMTWGlobalSupport.lean b/lean/ComparatorChallenges/WeakMTWGlobalSupport.lean
new file mode 100644
index 0000000000000000000000000000000000000000..74d786cf47e5ef9ab6d23491aa47ef9c3132420a
--- /dev/null
+++ b/lean/ComparatorChallenges/WeakMTWGlobalSupport.lean
@@ -0,0 +1,79 @@
+import Mathlib
+
+namespace OAI
+
+namespace WeakMTWGlobalSupport
+
+open scoped Manifold ContDiff Topology
+open Set Filter Manifold Bundle
+
+namespace WeakMTW
+
+noncomputable section
+
+abbrev Model (n : ℕ) := EuclideanSpace ℝ (Fin n)
+abbrev model (n : ℕ) := 𝓘(ℝ, Model n)
+
+variable {n : ℕ} {M : Type*} [MetricSpace M] [ChartedSpace (Model n) M]
+  [IsManifold (model n) ∞ M]
+  [RiemannianBundle (fun x : M => TangentSpace (model n) x)]
+  [IsContMDiffRiemannianBundle (model n) ∞ (Model n)
+    (fun x : M => TangentSpace (model n) x)]
+  [IsRiemannianManifold (model n) M]
+
+def CompleteGeodesicWithInitialData (x : M) (v : TangentSpace (model n) x)
+    (γ : ℝ → M) : Prop :=
+  ContMDiff 𝓘(ℝ, ℝ) (model n) ∞ γ ∧
+  ∃ h : γ 0 = x,
+    (h ▸ mfderiv 𝓘(ℝ, ℝ) (model n) γ 0 (1 : ℝ)) = v ∧
+    ∀ t : ℝ, ∃ ε : ℝ, 0 < ε ∧
+      ∀ s ∈ Metric.ball t ε, ∀ r ∈ Metric.ball t ε,
+        dist (γ s) (γ r) = ‖v‖ * |s - r|
+
+def ExpEndpoint (x : M) (v : TangentSpace (model n) x) (y : M) : Prop :=
+  ∃ γ : ℝ → M, CompleteGeodesicWithInitialData x v γ ∧ γ 1 = y
+
+noncomputable def exp (x : M) (v : TangentSpace (model n) x) : M :=
+  by
+    classical
+    exact if h : ∃ y, ExpEndpoint x v y then Classical.choose h else x
+
+def injectivityDomain (x : M) : Set (TangentSpace (model n) x) :=
+  {v | ∃ a : ℝ, 1 < a ∧ dist x (exp x (a • v)) = a * ‖v‖}
+
+def cost (x y : M) : ℝ := dist x y ^ 2 / 2
+
+noncomputable def mtw (x : M) (v ξ η : TangentSpace (model n) x) : ℝ :=
+  -(3 / 2 : ℝ) * deriv (fun s : ℝ =>
+    deriv (fun s' : ℝ => deriv (fun t : ℝ =>
+      deriv (fun t' : ℝ => cost (exp x (t' • ξ)) (exp x (v + s' • η))) t) 0) s) 0
+
+def HasWeakMTW : Prop :=
+  ∀ (x : M) (v : TangentSpace (model n) x), v ∈ injectivityDomain x →
+    ∀ ξ η : TangentSpace (model n) x, inner ℝ ξ η = 0 → 0 ≤ mtw x v ξ η
+
+def MainConvexity : Prop :=
+  ∀ x : M, Convex ℝ (injectivityDomain (n := n) x)
+
+end
+
+end WeakMTW
+
+/-- Weak MTW implies linear convexity of every open tangent injectivity domain. -/
+theorem current_main_convexity
+    {n : ℕ} (hn : 2 ≤ n) {M : Type*}
+    [MetricSpace M] [ChartedSpace (WeakMTW.Model n) M]
+    [IsManifold (WeakMTW.model n) ∞ M]
+    [CompactSpace M] [ConnectedSpace M]
+    [RiemannianBundle (fun x : M => TangentSpace (WeakMTW.model n) x)]
+    [IsContMDiffRiemannianBundle (WeakMTW.model n) ∞ (WeakMTW.Model n)
+      (fun x : M => TangentSpace (WeakMTW.model n) x)]
+    [IsRiemannianManifold (WeakMTW.model n) M]
+    (hmtw : WeakMTW.HasWeakMTW (n := n) (M := M)) :
+    WeakMTW.MainConvexity (n := n) (M := M) :=
+  by
+    sorry
+
+end WeakMTWGlobalSupport
+
+end OAI
diff --git a/lean/ComparatorChallenges/WeightedSweepMoments.json b/lean/ComparatorChallenges/WeightedSweepMoments.json
new file mode 100644
index 0000000000000000000000000000000000000000..fa5ea14e3ca0e3f0c8f2364fa38e53e76129a8d2
--- /dev/null
+++ b/lean/ComparatorChallenges/WeightedSweepMoments.json
@@ -0,0 +1,14 @@
+{
+  "challenge_module": "ComparatorChallenges.WeightedSweepMoments",
+  "solution_module": "OAI.Probability.CubeShuffle.WeightedMoments",
+  "theorem_names": [
+    "OAI.CubeShuffle.WeightedSweep.weighted_sweep_moments"
+  ],
+  "definition_names": [],
+  "permitted_axioms": [
+    "propext",
+    "Quot.sound",
+    "Classical.choice"
+  ],
+  "enable_nanoda": false
+}
diff --git a/lean/ComparatorChallenges/WeightedSweepMoments.lean b/lean/ComparatorChallenges/WeightedSweepMoments.lean
new file mode 100644
index 0000000000000000000000000000000000000000..ca15ad3bd46a116f9e2bb777df62d50272fe03f5
--- /dev/null
+++ b/lean/ComparatorChallenges/WeightedSweepMoments.lean
@@ -0,0 +1,304 @@
+import Mathlib
+
+namespace OAI
+
+namespace CubeShuffle.Specht
+
+open scoped BigOperators Classical
+
+abbrev Cell (μ : YoungDiagram) := {x : ℕ × ℕ // x ∈ μ.cells}
+def row {μ : YoungDiagram} (x : Cell μ) : ℕ := x.1.1
+def col {μ : YoungDiagram} (x : Cell μ) : ℕ := x.1.2
+
+lemma row_lt_colLen {μ : YoungDiagram} (x : Cell μ) : row x < μ.colLen (col x) :=
+  YoungDiagram.mem_iff_lt_colLen.mp x.2
+noncomputable def rowIndex {μ : YoungDiagram} (x : Cell μ) : Fin (μ.colLen 0) :=
+  ⟨row x, (row_lt_colLen x).trans_le (μ.colLen_anti 0 (col x) (Nat.zero_le _))⟩
+
+abbrev Tabloid (μ : YoungDiagram) :=
+  {f : Cell μ → Fin (μ.colLen 0) // ∃ p : Equiv.Perm (Cell μ), f = rowIndex ∘ p}
+
+noncomputable instance (μ : YoungDiagram) : Fintype (Tabloid μ) := Fintype.ofFinite _
+
+noncomputable def baseTabloid (μ : YoungDiagram) : Tabloid μ := ⟨rowIndex, 1, rfl⟩
+
+noncomputable def tabloidAct {μ : YoungDiagram} (p : Equiv.Perm (Cell μ)) :
+    Equiv.Perm (Tabloid μ) where
+  toFun f := ⟨fun x => f.1 (p⁻¹ x), by
+    obtain ⟨q,hq⟩ := f.2
+    refine ⟨q*p⁻¹, ?_⟩
+    funext x
+    simp only [hq,Function.comp_apply,Equiv.Perm.mul_apply]⟩
+  invFun f := ⟨fun x => f.1 (p x), by
+    obtain ⟨q,hq⟩ := f.2
+    refine ⟨q*p, ?_⟩
+    funext x
+    simp only [hq,Function.comp_apply,Equiv.Perm.mul_apply]⟩
+  left_inv f := by apply Subtype.ext; funext x; simp
+  right_inv f := by apply Subtype.ext; funext x; simp
+
+@[simp] lemma tabloidAct_apply {μ : YoungDiagram} (p : Equiv.Perm (Cell μ))
+    (f : Tabloid μ) (x : Cell μ) : (tabloidAct p f).1 x = f.1 (p⁻¹ x) := rfl
+
+@[simp] lemma tabloidAct_one (μ : YoungDiagram) : tabloidAct (1 : Equiv.Perm (Cell μ)) = 1 := by
+  ext f x
+  rfl
+
+@[simp] lemma tabloidAct_mul {μ : YoungDiagram} (p q : Equiv.Perm (Cell μ)) :
+    tabloidAct (p*q) = tabloidAct p * tabloidAct q := by
+  ext f x
+  simp only [tabloidAct_apply, mul_inv_rev,Equiv.Perm.mul_apply]
+
+@[simp] lemma tabloidAct_inv {μ : YoungDiagram} (p : Equiv.Perm (Cell μ)) :
+    tabloidAct p⁻¹ = (tabloidAct p)⁻¹ := by
+  ext f x
+  simp [tabloidAct,Equiv.Perm.inv_def]
+
+noncomputable def tabloidRep (μ : YoungDiagram) :
+    Representation ℂ (Equiv.Perm (Cell μ)) (Tabloid μ → ℂ) where
+  toFun p :=
+    { toFun := fun v f => v (tabloidAct p⁻¹ f)
+      map_add' := by intros; rfl
+      map_smul' := by intros; rfl }
+  map_one' := by ext v f; simp
+  map_mul' p q := by
+    ext v f
+    simp only [mul_inv_rev,tabloidAct_mul,Equiv.Perm.mul_apply]
+    rfl
+
+@[simp] lemma tabloidRep_apply {μ : YoungDiagram} (p : Equiv.Perm (Cell μ))
+    (v : Tabloid μ → ℂ) (f : Tabloid μ) : tabloidRep μ p v f = v (tabloidAct p⁻¹ f) := rfl
+
+noncomputable def delta {μ : YoungDiagram} (f : Tabloid μ) : Tabloid μ → ℂ :=
+  fun g => if g=f then 1 else 0
+
+noncomputable def colGroup (μ : YoungDiagram) : Subgroup (Equiv.Perm (Cell μ)) where
+  carrier := {p | ∀ x, col (p x) = col x}
+  one_mem' := by intro x; rfl
+  mul_mem' := by intro p q hp hq x; exact (hp (q x)).trans (hq x)
+  inv_mem' := by intro p hp x; simpa using (hp (p⁻¹ x)).symm
+
+noncomputable def permSign {α : Type*} [Fintype α] [DecidableEq α] (p : Equiv.Perm α) : ℂ :=
+  ((Equiv.Perm.sign p : ℤ) : ℂ)
+section Alternator
+variable {α V : Type*} [Fintype α] [DecidableEq α] [AddCommGroup V] [Module ℂ V]
+
+noncomputable def alternator (C : Subgroup (Equiv.Perm α))
+    (ρ : Representation ℂ (Equiv.Perm α) V) : Module.End ℂ V := by
+  classical
+  exact ∑ c : C, permSign (c : Equiv.Perm α) • ρ c
+
+end Alternator
+
+noncomputable def polytabloid (μ : YoungDiagram) : Tabloid μ → ℂ :=
+  alternator (colGroup μ) (tabloidRep μ) (delta (baseTabloid μ))
+
+noncomputable def space (μ : YoungDiagram) : Submodule ℂ (Tabloid μ → ℂ) :=
+  Submodule.span ℂ (Set.range (fun p : Equiv.Perm (Cell μ) => tabloidRep μ p (polytabloid μ)))
+
+lemma orbit_mem_space (μ : YoungDiagram) (p : Equiv.Perm (Cell μ)) :
+    tabloidRep μ p (polytabloid μ) ∈ space μ := Submodule.subset_span ⟨p,rfl⟩
+
+lemma action_mem_space (μ : YoungDiagram) (p : Equiv.Perm (Cell μ))
+    (v : Tabloid μ → ℂ) (hv : v ∈ space μ) : tabloidRep μ p v ∈ space μ := by
+  induction hv using Submodule.span_induction with
+  | mem v hv =>
+    obtain ⟨q,rfl⟩ := hv
+    change ((tabloidRep μ p)*(tabloidRep μ q)) (polytabloid μ) ∈ space μ
+    rw [←map_mul]
+    exact orbit_mem_space μ (p*q)
+  | zero => simp
+  | add v w hv hw ihv ihw => simpa using (space μ).add_mem ihv ihw
+  | smul a v hv ih => simpa using (space μ).smul_mem a ih
+
+noncomputable def subrepresentation (μ : YoungDiagram) : Subrepresentation (tabloidRep μ) :=
+  ⟨space μ, fun p v hv => action_mem_space μ p v hv⟩
+
+noncomputable def representation (μ : YoungDiagram) :
+    Representation ℂ (Equiv.Perm (Cell μ)) (space μ) :=
+  (subrepresentation μ).toRepresentation
+
+end CubeShuffle.Specht
+
+namespace CubeShuffle.PermutationHilbert
+
+open scoped BigOperators ComplexConjugate Classical
+open Complex
+
+variable {X : Type*} [Fintype X]
+
+abbrev H (X : Type*) [Fintype X] := EuclideanSpace ℂ X
+
+end CubeShuffle.PermutationHilbert
+
+namespace CubeShuffle.Specht
+
+open scoped BigOperators Classical
+
+noncomputable def hilbertEquiv (μ : YoungDiagram) :
+    (Tabloid μ → ℂ) ≃ₗ[ℂ] PermutationHilbert.H (Tabloid μ) :=
+  (WithLp.linearEquiv 2 ℂ (Tabloid μ → ℂ)).symm
+
+noncomputable def hilbertSpace (μ : YoungDiagram) :
+    Submodule ℂ (PermutationHilbert.H (Tabloid μ)) := (space μ).map (hilbertEquiv μ).toLinearMap
+
+noncomputable def spaceHilbertEquiv (μ : YoungDiagram) : space μ ≃ₗ[ℂ] hilbertSpace μ :=
+  (hilbertEquiv μ).submoduleMap (space μ)
+
+noncomputable def unitaryRepresentation (μ : YoungDiagram) :
+    Representation ℂ (Equiv.Perm (Cell μ)) (hilbertSpace μ) :=
+  ((spaceHilbertEquiv μ).conjAlgEquiv ℂ).toMonoidHom.comp (representation μ)
+
+variable {α ι : Type*} [Fintype α] [Fintype ι]
+
+noncomputable def relabelledUnitary (μ : YoungDiagram) (e : α ≃ Cell μ) :
+    Representation ℂ (Equiv.Perm α) (hilbertSpace μ) :=
+  (unitaryRepresentation μ).comp e.permCongrHom.toMonoidHom
+
+end CubeShuffle.Specht
+
+namespace CubeShuffle
+
+open scoped BigOperators
+open Filter
+
+abbrev Card (d : ℕ) := Fin d → Bool
+
+def Coins : ℕ → Type
+  | 0 => Unit
+  | d + 1 => Card d → Bool
+
+instance (d : ℕ) : Fintype (Coins d) := by
+  cases d <;> dsimp [Coins] <;> infer_instance
+
+instance (d : ℕ) : Nonempty (Coins d) := by
+  cases d <;> dsimp [Coins] <;> infer_instance
+
+def switchFun {d : ℕ} (ξ : Card d → Bool) (x : Card (d + 1)) : Card (d + 1) :=
+  Fin.cons (Bool.xor (x 0) (ξ (Fin.tail x))) (Fin.tail x)
+
+theorem switchFun_involutive {d : ℕ} (ξ : Card d → Bool) :
+    Function.Involutive (switchFun ξ) := by
+  intro x
+  funext i
+  refine Fin.cases ?_ (fun j => ?_) i
+  · simp only [switchFun, Fin.cons_zero, Fin.tail_cons]
+    cases x 0 <;> cases ξ (Fin.tail x) <;> rfl
+  · simp [switchFun, Fin.tail]
+
+def pairSwitch {d : ℕ} (ξ : Card d → Bool) : Equiv.Perm (Card (d + 1)) :=
+  { toFun := switchFun ξ
+    invFun := switchFun ξ
+    left_inv := switchFun_involutive ξ
+    right_inv := switchFun_involutive ξ }
+
+def rotate (d : ℕ) : Equiv.Perm (Card d) where
+  toFun x i := x (finRotate d i)
+  invFun x i := x ((finRotate d).symm i)
+  left_inv x := by funext i; simp only [Equiv.apply_symm_apply]
+  right_inv x := by funext i; simp only [Equiv.symm_apply_apply]
+
+def step : (d : ℕ) → Coins d → Equiv.Perm (Card d)
+  | 0, _ => 1
+  | d + 1, ξ => rotate (d + 1) * pairSwitch ξ
+
+def run (d : ℕ) : (t : ℕ) → (Fin t → Coins d) → Equiv.Perm (Card d)
+  | 0, _ => 1
+  | t + 1, ω => step d (ω (Fin.last t)) * run d t (fun i => ω i.castSucc)
+
+lemma card_positions (d : ℕ) : Fintype.card (Card d) = 2 ^ d := by
+  simp [Card]
+
+end CubeShuffle
+
+namespace CubeShuffle.Specht
+open scoped BigOperators Classical
+
+@[simp] lemma card_cell (μ : YoungDiagram) : Fintype.card (Cell μ) = μ.card := by
+  simp [Cell, YoungDiagram.card]
+
+abbrev Shapes (N : ℕ) := {μ : YoungDiagram // μ.card = N}
+
+noncomputable def labels {N : ℕ} (μ : Shapes N) : Cell μ.1 ≃ Fin N :=
+  (Fintype.equivFin (Cell μ.1)).trans (finCongr ((card_cell μ.1).trans μ.2))
+
+noncomputable def cardLabels (d : ℕ) (μ : Shapes (2^d)) : Card d ≃ Cell μ.1 :=
+  ((Fintype.equivFin (Card d)).trans (finCongr (card_positions d))).trans (labels μ).symm
+
+noncomputable def cardRepresentation (d : ℕ) (μ : Shapes (2^d)) :
+    Representation ℂ (Equiv.Perm (Card d)) (hilbertSpace μ.1) :=
+  relabelledUnitary μ.1 (cardLabels d μ)
+
+end CubeShuffle.Specht
+
+namespace CubeShuffle.UnitaryFinite
+open scoped BigOperators ComplexConjugate Classical
+variable {G : Type*} [Group G] [Fintype G]
+variable {V : Type*} [NormedAddCommGroup V] [InnerProductSpace ℂ V] [FiniteDimensional ℂ V]
+
+noncomputable def continuousRepresentation (ρ : Representation ℂ G V) : G →* (V →L[ℂ] V) where
+  toFun g := (ρ g).toContinuousLinearMap
+  map_one' := by ext v; simp
+  map_mul' g h := by ext v; simp
+
+end CubeShuffle.UnitaryFinite
+
+run_cmd Lean.modifyEnv fun env => Lean.Meta.auxLemmasExt.setState env {}
+
+namespace CubeShuffle.UnitaryFinite
+open scoped BigOperators Classical
+variable {G : Type*} [Group G] [Fintype G]
+variable {V : Type*} [NormedAddCommGroup V] [InnerProductSpace ℂ V] [FiniteDimensional ℂ V]
+variable {Ω Ξ : Type*} [Fintype Ω] [Fintype Ξ]
+
+noncomputable def sampleOperator (ρ : Representation ℂ G V) (P : Ω → G) : V →L[ℂ] V :=
+  (Fintype.card Ω:ℂ)⁻¹ • ∑ ω,continuousRepresentation ρ (P ω)
+
+end CubeShuffle.UnitaryFinite
+
+noncomputable section
+open scoped BigOperators Classical
+
+namespace CubeShuffle.WeightedSweep
+open Specht UnitaryFinite
+
+def dimension (μ : YoungDiagram) : ℝ := Module.finrank ℂ (space μ)
+def fourierSweep (d : ℕ) (μ : Shapes (2^d)) :
+    hilbertSpace μ.1 →L[ℂ] hilbertSpace μ.1 :=
+  sampleOperator (V := hilbertSpace μ.1) (cardRepresentation d μ) (run d d)
+def schattenMoment {V : Type*} [NormedAddCommGroup V] [InnerProductSpace ℂ V]
+    [FiniteDimensional ℂ V] (A : V →L[ℂ] V) (p : ℝ) : ℝ :=
+  ∑ i : Fin (Module.finrank ℂ V), (A.toLinearMap.singularValues i) ^ p
+
+def schattenNorm {V : Type*} [NormedAddCommGroup V] [InnerProductSpace ℂ V]
+    [FiniteDimensional ℂ V] (A : V →L[ℂ] V) (p : ℝ) : ℝ :=
+  schattenMoment A p ^ (1 / p)
+
+end CubeShuffle.WeightedSweep
+
+end
+
+noncomputable section
+open scoped BigOperators Classical
+
+namespace CubeShuffle.WeightedSweep
+open Specht UnitaryFinite
+
+theorem weighted_sweep_moments :
+    ∃ (W : YoungDiagram → ℝ) (pStar : ℝ) (p : ℕ → ℝ),
+      (∀ μ : YoungDiagram, 0 < W μ) ∧
+      2 ≤ pStar ∧
+      (∀ d : ℕ, 1 ≤ d → 2 ≤ p d ∧ p d ≤ pStar) ∧
+      ∀ d : ℕ, 1 ≤ d → ∀ μ : Shapes (2 ^ d),
+        dimension μ.1 ^ (3 / 4 : ℝ) ≤ W μ.1 ∧
+        W μ.1 ≤ dimension μ.1 ∧
+        W μ.1 *
+          schattenNorm (V := hilbertSpace μ.1) (fourierSweep d μ) (p d) ^ (p d) ≤ 1 ∧
+        ‖fourierSweep d μ‖ ≤ dimension μ.1 ^ (-3 / (4 * pStar)) := by
+  sorry
+
+end CubeShuffle.WeightedSweep
+
+end
+
+end OAI
diff --git a/lean/ComparatorChallenges/WeisfeilerLeman.json b/lean/ComparatorChallenges/WeisfeilerLeman.json
new file mode 100644
index 0000000000000000000000000000000000000000..5e52feda9f499f0c3b3c462c845d4e8e1e897f7e
--- /dev/null
+++ b/lean/ComparatorChallenges/WeisfeilerLeman.json
@@ -0,0 +1,14 @@
+{
+  "challenge_module": "ComparatorChallenges.WeisfeilerLeman",
+  "solution_module": "OAI.Computability.WeisfeilerLeman.Main",
+  "theorem_names": [
+    "OAI.WLTime.unconditional_time_lower_bound"
+  ],
+  "definition_names": [],
+  "permitted_axioms": [
+    "propext",
+    "Quot.sound",
+    "Classical.choice"
+  ],
+  "enable_nanoda": false
+}
diff --git a/lean/ComparatorChallenges/WeisfeilerLeman.lean b/lean/ComparatorChallenges/WeisfeilerLeman.lean
new file mode 100644
index 0000000000000000000000000000000000000000..da205d7aff62b7573d0c34c4197b229af57ece6d
--- /dev/null
+++ b/lean/ComparatorChallenges/WeisfeilerLeman.lean
@@ -0,0 +1,270 @@
+import Mathlib
+
+namespace OAI
+
+namespace WLTime
+
+inductive Convention where
+  | joint | separate
+  deriving DecidableEq
+
+def Graph (n : ℕ) :=
+  { a : Fin n → Fin n → Bool //
+    (∀ x y, a x y = a y x) ∧ (∀ x, a x x = false) }
+
+namespace Graph
+
+def adj {n : ℕ} (G : Graph n) : Fin n → Fin n → Bool := G.val
+
+def diameterTwo {n : ℕ} (G : Graph n) : Prop :=
+  0 < n ∧ ∀ x y, x = y ∨ G.adj x y = true ∨
+    ∃ z, G.adj x z = true ∧ G.adj z y = true
+
+noncomputable instance (n : ℕ) : Fintype (Graph n) := by
+  classical
+  unfold Graph
+  infer_instance
+
+end Graph
+
+abbrev AtomicColor (k : ℕ) :=
+  (Fin k → Fin k → Bool) × (Fin k → Fin k → Bool)
+
+def Color (c : Convention) (k : ℕ) : ℕ → Type
+  | 0 => AtomicColor k
+  | t + 1 => match c with
+    | .joint => Color c k t × Multiset (Fin k → Color c k t)
+    | .separate => Color c k t × (Fin k → Multiset (Color c k t))
+
+noncomputable def tupleColor {n : ℕ} (c : Convention) (k : ℕ) (G : Graph n) :
+    (t : ℕ) → (Fin k → Fin n) → Color c k t
+  | 0, v => (fun i j => decide (v i = v j), fun i j => G.adj (v i) (v j))
+  | t + 1, v => match c with
+    | .joint => (tupleColor .joint k G t v,
+        Finset.univ.val.map (fun z => fun i =>
+          tupleColor .joint k G t (Function.update v i z)))
+    | .separate => (tupleColor .separate k G t v,
+        fun i => Finset.univ.val.map (fun z =>
+          tupleColor .separate k G t (Function.update v i z)))
+
+noncomputable def histogram {n : ℕ} (c : Convention) (k : ℕ) (G : Graph n)
+    (t : ℕ) : Multiset (Color c k t) :=
+  Finset.univ.val.map (tupleColor c k G t)
+
+def Equivalent {n : ℕ} (c : Convention) (k : ℕ) (G H : Graph n) : Prop :=
+  ∀ t, histogram c k G t = histogram c k H t
+
+def encodeNat (n : ℕ) : List Bool :=
+  let bits := (Nat.digits 2 n).map (fun b => decide (b = 1))
+  List.replicate bits.length true ++ [false] ++ bits
+
+def matrixBits {n : ℕ} (G : Graph n) : List Bool :=
+  (List.ofFn fun i : Fin n => List.ofFn fun j : Fin n => G.adj i j).flatten
+
+def encodePair {n : ℕ} (G H : Graph n) : List Bool :=
+  encodeNat n ++ matrixBits G ++ matrixBits H
+
+inductive Move where
+  | left | stay | right
+  deriving DecidableEq
+
+def Move.displacement : Move → ℤ
+  | .left => -1
+  | .stay => 0
+  | .right => 1
+
+structure TM where
+  tapes : ℕ
+  states : ℕ
+  symbols : ℕ
+  tapes_pos : 0 < tapes
+  states_ge : 3 ≤ states
+  symbols_ge : 3 ≤ symbols
+  transition : Fin states → (Fin tapes → Fin symbols) →
+    Fin states × (Fin tapes → Fin symbols) × (Fin tapes → Move)
+
+namespace TM
+
+structure Config (M : TM) where
+  state : Fin M.states
+  head : Fin M.tapes → ℤ
+  tape : Fin M.tapes → ℤ → Fin M.symbols
+
+def symbol (M : TM) (b : Bool) : Fin M.symbols :=
+  if b then ⟨2, by have := M.symbols_ge; omega⟩ else
+    ⟨1, by have := M.symbols_ge; omega⟩
+
+def initial (M : TM) (w : List Bool) : M.Config where
+  state := ⟨0, by have := M.states_ge; omega⟩
+  head := fun _ => 0
+  tape := fun a z => if a.val = 0 ∧ 0 ≤ z ∧ z.toNat < w.length then
+    M.symbol (w.getD z.toNat false) else ⟨0, by have := M.symbols_ge; omega⟩
+
+def halted (M : TM) (C : M.Config) : Prop := C.state.val = 1 ∨ C.state.val = 2
+
+instance (M : TM) (C : M.Config) : Decidable (M.halted C) := inferInstanceAs
+  (Decidable (C.state.val = 1 ∨ C.state.val = 2))
+
+def step (M : TM) (C : M.Config) : M.Config :=
+  if M.halted C then C else
+  let tr := M.transition C.state (fun a => C.tape a (C.head a))
+  { state := tr.1
+    head := fun a => C.head a + (tr.2.2 a).displacement
+    tape := fun a z => if z = C.head a then tr.2.1 a else C.tape a z }
+
+def run (M : TM) (w : List Bool) (t : ℕ) : M.Config := M.step^[t] (M.initial w)
+
+def halts (M : TM) (w : List Bool) : Prop := ∃ t, M.halted (M.run w t)
+
+noncomputable def time (M : TM) (w : List Bool) : ℕ := by
+  classical
+  exact if h : M.halts w then Nat.find h else 0
+
+def accepts (M : TM) (w : List Bool) : Prop :=
+  ∃ t, (M.run w t).state.val = 1
+
+def outputs (M : TM) (input output : List Bool) : Prop :=
+  M.halts input ∧ ∀ i : Fin output.length,
+    (M.run input (M.time input)).tape ⟨0, M.tapes_pos⟩ (i.val : ℤ) =
+      M.symbol (output.get i)
+
+end TM
+
+abbrev Word (w : ℕ) := Fin (2 ^ w)
+
+def wordBits {w : ℕ} (a : Word w) : List Bool :=
+  List.ofFn (fun i : Fin w => a.val.testBit i.val)
+
+def registerBits {R w : ℕ} (a : Fin R → Word w) : List Bool :=
+  (List.ofFn fun i : Fin R => wordBits (a i)).flatten
+
+structure WordOperation (R : ℕ) where
+  apply : (w : ℕ) → (Fin R → Word w) → (Fin R → Word w)
+  implementation : TM
+  exponent : ℕ
+  constant : ℕ
+  computes : ∀ w a, implementation.outputs
+    (encodeNat w ++ registerBits a) (registerBits (apply w a))
+  cost : ∀ w (a : Fin R → Word w), implementation.time (encodeNat w ++ registerBits a) ≤
+    constant * (w + 1) ^ exponent
+
+inductive RAMInstruction (R P : ℕ) where
+  | halt (answer : Bool)
+  | jump (pc : Fin P)
+  | compute (op : WordOperation R) (next : RAMInstruction R P)
+  | load (dest addr : Fin R) (next : RAMInstruction R P)
+  | store (addr src : Fin R) (next : RAMInstruction R P)
+  | branchZero (reg : Fin R) (yes no : RAMInstruction R P)
+
+structure WordWidth where
+  bits : ℕ → ℕ
+  positive : ∀ n, 0 < bits n
+  bound : ℕ
+  logarithmic : ∀ n, bits n ≤ bound * (Nat.log2 (n + 2) + 1)
+
+structure RAM where
+  registers : ℕ
+  locations : ℕ
+  locations_pos : 0 < locations
+  width : WordWidth
+  program : Fin locations → RAMInstruction registers locations
+  input_fits : ∀ n (G H : Graph n),
+    (encodePair G H).length ≤ width.bits n * 2 ^ width.bits n
+
+namespace RAM
+
+structure Config (A : RAM) (n : ℕ) where
+  pc : Fin A.locations
+  registers : Fin A.registers → Word (A.width.bits n)
+  memory : Word (A.width.bits n) → Word (A.width.bits n)
+  answer : Option Bool
+
+def packedWord (w : ℕ) (input : List Bool) (a : Word w) : Word w :=
+  ⟨(∑ i ∈ Finset.range w, if input.getD (w * a.val + i) false then 2 ^ i else 0)
+      % (2 ^ w), Nat.mod_lt _ (by positivity)⟩
+
+def initial (A : RAM) (n : ℕ) (w : List Bool) : A.Config n where
+  pc := ⟨0, A.locations_pos⟩
+  registers := fun _ => ⟨0, by positivity⟩
+  memory := packedWord (A.width.bits n) w
+  answer := none
+
+def execute (A : RAM) {n : ℕ} :
+    RAMInstruction A.registers A.locations → A.Config n → A.Config n
+  | .halt b, C => { C with answer := some b }
+  | .jump p, C => { C with pc := p }
+  | .compute op next, C => A.execute next { C with
+      registers := op.apply (A.width.bits n) C.registers }
+  | .load dest addr next, C => A.execute next { C with
+      registers := Function.update C.registers dest (C.memory (C.registers addr)) }
+  | .store addr src next, C => A.execute next { C with
+      memory := Function.update C.memory (C.registers addr) (C.registers src) }
+  | .branchZero reg yes no, C =>
+      if (C.registers reg).val = 0 then A.execute yes C else A.execute no C
+
+def step (A : RAM) {n : ℕ} (C : A.Config n) : A.Config n :=
+  match C.answer with
+  | some _ => C
+  | none => A.execute (A.program C.pc) C
+
+def run (A : RAM) (n : ℕ) (w : List Bool) (t : ℕ) : A.Config n :=
+  A.step^[t] (A.initial n w)
+
+def halts (A : RAM) (n : ℕ) (w : List Bool) : Prop :=
+  ∃ t, (A.run n w t).answer.isSome = true
+
+noncomputable def time (A : RAM) (n : ℕ) (w : List Bool) : ℕ := by
+  classical
+  exact if h : A.halts n w then Nat.find h else 0
+
+def accepts (A : RAM) (n : ℕ) (w : List Bool) : Prop :=
+  ∃ t, (A.run n w t).answer = some true
+
+end RAM
+
+inductive Model where
+  | turing (machine : TM)
+  | ram (machine : RAM)
+
+def Model.halts (A : Model) (n : ℕ) (w : List Bool) : Prop := match A with
+  | .turing M => M.halts w
+  | .ram M => M.halts n w
+
+def Model.accepts (A : Model) (n : ℕ) (w : List Bool) : Prop := match A with
+  | .turing M => M.accepts w
+  | .ram M => M.accepts n w
+
+noncomputable def Model.time (A : Model) (n : ℕ) (w : List Bool) : ℕ := match A with
+  | .turing M => M.time w
+  | .ram M => M.time n w
+
+inductive InputClass where
+  | unrestricted | diameterTwo
+  deriving DecidableEq
+
+def InputClass.contains (p : InputClass) {n : ℕ} (G H : Graph n) : Prop := match p with
+  | .unrestricted => True
+  | .diameterTwo => G.diameterTwo ∧ H.diameterTwo
+
+def Decides (A : Model) (c : Convention) (k : ℕ) (p : InputClass) : Prop :=
+  ∀ n (G H : Graph n), p.contains G H →
+    A.halts n (encodePair G H) ∧
+      (A.accepts n (encodePair G H) ↔ Equivalent c k G H)
+
+noncomputable def worstTime (A : Model) (p : InputClass) (n : ℕ) : ℕ := by
+  classical
+  exact Finset.univ.sup (fun pair : Graph n × Graph n =>
+    if p.contains pair.1 pair.2 then A.time n (encodePair pair.1 pair.2) else 0)
+
+def MainClaim : Prop :=
+  ∃ c : ℝ, 0 < c ∧ ∃ k₀ : ℕ, ∀ k : ℕ, k₀ ≤ k →
+    ∀ convention : Convention, ∀ p : InputClass, ∀ A : Model,
+      Decides A convention k p → ∃ n₀ : ℕ, ∀ n : ℕ, n₀ ≤ n →
+        (n : ℝ) ^ (c * (k : ℝ)) ≤ (worstTime A p n : ℝ)
+
+end WLTime
+
+theorem WLTime.unconditional_time_lower_bound : WLTime.MainClaim := by
+  sorry
+
+end OAI
diff --git a/lean/ComparatorChallenges/WitnessedChoice.json b/lean/ComparatorChallenges/WitnessedChoice.json
new file mode 100644
index 0000000000000000000000000000000000000000..1b08416ca1e343a3dad84e8415fe9225fd3ccd2f
--- /dev/null
+++ b/lean/ComparatorChallenges/WitnessedChoice.json
@@ -0,0 +1,14 @@
+{
+  "challenge_module": "ComparatorChallenges.WitnessedChoice",
+  "solution_module": "OAI.Computability.WitnessedChoice.Main",
+  "theorem_names": [
+    "OAI.WitnessedChoice.main"
+  ],
+  "definition_names": [],
+  "permitted_axioms": [
+    "propext",
+    "Quot.sound",
+    "Classical.choice"
+  ],
+  "enable_nanoda": false
+}
diff --git a/lean/ComparatorChallenges/WitnessedChoice.lean b/lean/ComparatorChallenges/WitnessedChoice.lean
new file mode 100644
index 0000000000000000000000000000000000000000..0f2828f516fb6d3e311b3742c6a013f01c69b45f
--- /dev/null
+++ b/lean/ComparatorChallenges/WitnessedChoice.lean
@@ -0,0 +1,474 @@
+import Mathlib
+
+namespace OAI
+
+noncomputable section
+
+universe u v w
+
+namespace WitnessedSeparation
+
+namespace Hereditary
+
+abbrev HF (A : Type u) := Quotient (@Lists.instSetoidLists A)
+
+variable {A : Type u} {B : Type v}
+
+section
+
+local instance {A : Type u} : DecidableEq (HF A) := Classical.decEq _
+
+def mk (l : Lists A) : HF A := Quotient.mk Lists.instSetoidLists l
+
+def atom (a : A) : HF A := mk (Lists.atom a)
+
+def isSet (x : HF A) : Bool := Quotient.liftOn x (fun l => l.1)
+  (by intro l r h; cases h <;> rfl)
+
+def rawElements (l : Lists A) : Finset (HF A) := by
+  classical
+  exact l.toList.toFinset.image mk
+
+def elements (x : HF A) : Finset (HF A) := Quotient.liftOn x rawElements (by
+  have mem_rawElements (a l : Lists A) : mk a ∈ rawElements l ↔ a ∈ l := by
+    classical
+    rcases l with ⟨(_ | _), l⟩
+    · cases l
+      change mk a ∈ (∅ : Finset (HF A)) ↔ False
+      simp
+    · change mk a ∈ (Lists'.toList l).toFinset.image mk ↔ a ∈ l
+      simp only [Finset.mem_image, List.mem_toFinset, Lists'.mem_def, mk, Quotient.eq]
+      constructor
+      · rintro ⟨a',ha',heq⟩
+        exact ⟨a',ha',heq.symm⟩
+      · rintro ⟨a',ha',heq⟩
+        exact ⟨a',ha',heq.symm⟩
+  have raw_mem_congr_right {l r : Lists A} (h : Lists.Equiv l r) (a : Lists A) :
+      a ∈ l ↔ a ∈ r := by
+    cases h with
+    | refl => rfl
+    | antisymm hl hr =>
+      exact ⟨Lists'.mem_of_subset hl, Lists'.mem_of_subset hr⟩
+  intro l r h
+  ext z
+  induction z using Quotient.inductionOn with
+  | _ a =>
+    change mk a ∈ rawElements l ↔ mk a ∈ rawElements r
+    rw [mem_rawElements, mem_rawElements]
+    exact raw_mem_congr_right h a)
+
+instance : Membership (HF A) (HF A) := ⟨fun y x => x ∈ elements y⟩
+
+def ofFinset (s : Finset (HF A)) : HF A :=
+  mk (Lists.ofList (s.toList.map Quotient.out))
+
+def rawRank' : {b : Bool} → Lists' A b → ℕ
+  | _, .atom _ => 0
+  | _, .nil => 0
+  | _, .cons' a l => max (rawRank' a + 1) (rawRank' l)
+
+def rawRank (l : Lists A) : ℕ := rawRank' l.2
+
+def rank (x : HF A) : ℕ := Quotient.liftOn x rawRank (by
+  have rawRank_lt_of_mem {b : Bool} (l : Lists' A b) (a : Lists A)
+      (ha : a ∈ l.toList) : rawRank a < rawRank' l := by
+    induction l with
+    | atom => simp at ha
+    | nil => simp at ha
+    | cons' c l ihc ihl =>
+      rcases List.mem_cons.mp ha with rfl | ha
+      · exact lt_of_lt_of_le (Nat.lt_succ_self _) (le_max_left _ _)
+      · exact lt_of_lt_of_le (ihl ha) (le_max_right _ _)
+  have rawRank_congr {l r : Lists A} (h : Lists.Equiv l r) : rawRank l = rawRank r := by
+    induction h using Lists.Equiv.rec
+        (motive_2 := fun l r _ => rawRank' l ≤ rawRank' r) with
+    | refl => rfl
+    | antisymm _ _ ihl ihr => exact Nat.le_antisymm ihl ihr
+    | nil => exact Nat.zero_le _
+    | @cons a a' l r _ hmem _ iheq ihsub =>
+      change max (rawRank a + 1) (rawRank' l) ≤ rawRank' r
+      refine max_le ?_ ihsub
+      rw [iheq]
+      exact rawRank_lt_of_mem r a' hmem
+  exact fun _ _ h => rawRank_congr h)
+
+def rawMap' (f : A → B) : {b : Bool} → Lists' A b → Lists' B b
+  | _, .atom a => .atom (f a)
+  | _, .nil => .nil
+  | _, .cons' a l => .cons' (rawMap' f a) (rawMap' f l)
+
+def rawMap (f : A → B) (l : Lists A) : Lists B := ⟨l.1, rawMap' f l.2⟩
+
+def map (f : A → B) (x : HF A) : HF B := by
+  have toList_rawMap' (f : A → B) {b : Bool} (l : Lists' A b) :
+      (rawMap' f l).toList = l.toList.map (rawMap f) := by
+    induction l with
+    | atom => rfl
+    | nil => rfl
+    | cons' a l iha ihl => simp only [rawMap', Lists'.toList, ihl]; rfl
+  have rawMap_congr (f : A → B) {l r : Lists A} (h : Lists.Equiv l r) :
+      Lists.Equiv (rawMap f l) (rawMap f r) := by
+    induction h using Lists.Equiv.rec
+        (motive_2 := fun l r _ => Lists'.Subset (rawMap' f l) (rawMap' f r)) with
+    | refl => exact Lists.Equiv.refl _
+    | antisymm hl hr ihl ihr => exact Lists.Equiv.antisymm ihl ihr
+    | nil => exact Lists'.Subset.nil
+    | @cons a a' l r _ hmem _ iheq ihsub =>
+      apply Lists'.Subset.cons iheq _ ihsub
+      rw [toList_rawMap']
+      exact List.mem_map.mpr ⟨a',hmem,rfl⟩
+  exact Quotient.liftOn x (fun l => mk (rawMap f l)) (fun _ _ h => Quotient.eq.mpr (rawMap_congr f h))
+
+instance {G : Type w} [Group G] [MulAction G A] : MulAction G (HF A)  := by
+  have map_mk {A B : Type u} (f : A → B) (l : Lists A) : map f (mk l) = mk (rawMap f l) := rfl
+  have rawMap_id {A : Type u} : ∀ l : Lists A, rawMap id l = l := by
+    rintro ⟨b,l⟩
+    have h : rawMap' id l = l := by
+      induction l with
+      | atom => rfl
+      | nil => rfl
+      | cons' a l iha ihl => simp only [rawMap', iha,ihl]
+    exact congrArg (Sigma.mk b) h
+  have map_id {A : Type u} (x : HF A) : map id x = x := by
+    induction x using Quotient.inductionOn with
+    | _ l =>
+      change map id (mk l) = mk l
+      rw [map_mk, rawMap_id]
+  have rawMap_comp {A B : Type u} {C : Type u} (g : B → C) (f : A → B) (l : Lists A) :
+      rawMap g (rawMap f l) = rawMap (g ∘ f) l := by
+    rcases l with ⟨b,l⟩
+    have h : rawMap' g (rawMap' f l) = rawMap' (g ∘ f) l := by
+      induction l with
+      | atom => rfl
+      | nil => rfl
+      | cons' a l iha ihl => simp only [rawMap', iha,ihl]
+    exact congrArg (Sigma.mk b) h
+  have map_comp {A B : Type u} {C : Type u} (g : B → C) (f : A → B) (x : HF A) :
+      map g (map f x) = map (g ∘ f) x := by
+    induction x using Quotient.inductionOn with
+    | _ l =>
+      change map g (map f (mk l)) = map (g ∘ f) (mk l)
+      simp only [map_mk,rawMap_comp]
+  exact {
+    smul g x := map (fun a => g • a) x
+    one_smul x := by
+      change map (fun a : A => (1 : G) • a) x = x
+      have h : (fun a : A => (1 : G) • a) = id := by funext a; simp
+      rw [h,map_id]
+    mul_smul g h x := by
+      change map (fun a : A => (g*h) • a) x = map (fun a => g • a) (map (fun a => h • a) x)
+      rw [map_comp]
+      congr 1
+      funext a
+      exact mul_smul g h a }
+
+end
+
+open Classical Finset
+
+def singleton (a : HF A) : HF A := ofFinset {a}
+
+def double (a b : HF A) : HF A := ofFinset {a,b}
+
+def pair (a b : HF A) : HF A := double (singleton a) (double a b)
+
+def ordinal : ℕ → HF A
+  | 0 => ofFinset ∅
+  | i+1 => ofFinset (insert (ordinal i) (elements (ordinal i)))
+
+local instance {C : Type w} : DecidableEq (HF C) := Classical.decEq _
+
+def closure (x : HF A) : Finset (HF A) :=
+  insert x ((elements x).attach.biUnion (fun y => closure y.val))
+termination_by rank x
+decreasing_by
+  have mem_rawElements (a l : Lists A) : mk a ∈ rawElements l ↔ a ∈ l := by
+    classical
+    rcases l with ⟨(_ | _), l⟩
+    · cases l
+      change mk a ∈ (∅ : Finset (HF A)) ↔ False
+      simp
+    · change mk a ∈ (Lists'.toList l).toFinset.image mk ↔ a ∈ l
+      simp only [Finset.mem_image, List.mem_toFinset, Lists'.mem_def, mk, Quotient.eq]
+      constructor
+      · rintro ⟨a',ha',heq⟩
+        exact ⟨a',ha',heq.symm⟩
+      · rintro ⟨a',ha',heq⟩
+        exact ⟨a',ha',heq.symm⟩
+  have rawRank_lt_of_mem {b : Bool} (l : Lists' A b) (a : Lists A)
+      (ha : a ∈ l.toList) : rawRank a < rawRank' l := by
+    induction l with
+    | atom => simp at ha
+    | nil => simp at ha
+    | cons' c l ihc ihl =>
+      rcases List.mem_cons.mp ha with rfl | ha
+      · exact lt_of_lt_of_le (Nat.lt_succ_self _) (le_max_left _ _)
+      · exact lt_of_lt_of_le (ihl ha) (le_max_right _ _)
+  have rawRank_congr {l r : Lists A} (h : Lists.Equiv l r) : rawRank l = rawRank r := by
+    induction h using Lists.Equiv.rec
+        (motive_2 := fun l r _ => rawRank' l ≤ rawRank' r) with
+    | refl => rfl
+    | antisymm _ _ ihl ihr => exact Nat.le_antisymm ihl ihr
+    | nil => exact Nat.zero_le _
+    | @cons a a' l r _ hmem _ iheq ihsub =>
+      change max (rawRank a + 1) (rawRank' l) ≤ rawRank' r
+      refine max_le ?_ ihsub
+      rw [iheq]
+      exact rawRank_lt_of_mem r a' hmem
+  have rank_lt_of_mem {x y : HF A} (h : x ∈ y) : rank x < rank y := by
+    induction y using Quotient.inductionOn with
+    | _ l =>
+      induction x using Quotient.inductionOn with
+      | _ a =>
+        have h' := (mem_rawElements a l).mp h
+        rcases l with ⟨(_ | _), l⟩
+        · exact False.elim h'
+        · obtain ⟨a',ha',heq⟩ := h'
+          change rawRank a < rawRank' l
+          rw [rawRank_congr heq]
+          exact rawRank_lt_of_mem l a' ha'
+  exact rank_lt_of_mem y.property
+
+end Hereditary
+
+abbrev Scalar := ZMod 3
+
+inductive Symbol
+  | Ed | Cf | EB | VB | I | Z (δ : Scalar)
+  deriving DecidableEq, Fintype
+
+structure Input (A : Type) where
+  rel : Symbol → A → A → Bool
+
+end WitnessedSeparation
+
+namespace WitnessedChoice
+
+namespace BGS
+
+open Classical WitnessedSeparation WitnessedSeparation.Hereditary
+
+mutual
+
+inductive Term : ℕ → Type
+    | var {n} (i : Fin n) : Term n
+    | empty {n} : Term n
+    | atoms {n} : Term n
+    | pair {n} (a b : Term n) : Term n
+    | union {n} (a : Term n) : Term n
+    | unique {n} (a : Term n) : Term n
+    | card {n} (a : Term n) : Term n
+    | comprehend {n} (body : Term (n+1)) (range : Term n)
+        (guard : Formula (n+1)) : Term n
+    | iterate {n} (step : Term (n+1)) : Term n
+  inductive Formula : ℕ → Type
+    | equal {n} (a b : Term n) : Formula n
+    | input {n} (r : Symbol) (a b : Term n) : Formula n
+    | neg {n} (a : Formula n) : Formula n
+    | and {n} (a b : Formula n) : Formula n
+    | or {n} (a b : Formula n) : Formula n
+    | wsc {n} (step : Term (n+2)) (choice : Term (n+1))
+        (witness : Term (n+2)) (output : Formula (n+1)) : Formula n
+
+end
+
+def dropFree {n} (f : Finset (Fin (n+1))) : Finset (Fin n) :=
+  Finset.univ.filter (fun i => i.succ ∈ f)
+
+mutual
+
+def Term.free : {n : ℕ} → Term n → Finset (Fin n)
+    | _, .var i => {i}
+    | _, .empty | _, .atoms => ∅
+    | _, .pair a b => a.free ∪ b.free
+    | _, .union a | _, .unique a | _, .card a => a.free
+    | _, .comprehend body range guard => range.free ∪ dropFree (body.free ∪ guard.free)
+    | _, .iterate step => dropFree step.free
+  def Formula.free : {n : ℕ} → Formula n → Finset (Fin n)
+    | _, .equal a b | _, .input _ a b => a.free ∪ b.free
+    | _, .neg a => a.free
+    | _, .and a b | _, .or a b => a.free ∪ b.free
+    | _, .wsc step choice witness output =>
+        dropFree (dropFree (step.free ∪ witness.free)) ∪ dropFree (choice.free ∪ output.free)
+
+end
+
+mutual
+
+def Term.wscCount : {n : ℕ} → Term n → ℕ
+    | _, .var _ | _, .empty | _, .atoms => 0
+    | _, .pair a b => a.wscCount + b.wscCount
+    | _, .union a | _, .unique a | _, .card a => a.wscCount
+    | _, .comprehend body range guard => body.wscCount + range.wscCount + guard.wscCount
+    | _, .iterate step => step.wscCount
+  def Formula.wscCount : {n : ℕ} → Formula n → ℕ
+    | _, .equal a b | _, .input _ a b => a.wscCount + b.wscCount
+    | _, .neg a => a.wscCount
+    | _, .and a b | _, .or a b => a.wscCount + b.wscCount
+    | _, .wsc step choice witness output =>
+        1 + step.wscCount + choice.wscCount + witness.wscCount + output.wscCount
+
+end
+
+variable {A : Type}
+
+abbrev Result (α : Type) := Option α
+
+def emptyHF : HF A := ofFinset ∅
+
+def TC (x : HF A) : Finset (HF A) := (elements x).biUnion closure
+
+def unionHF (x : HF A) : HF A := ofFinset ((elements x).biUnion elements)
+
+def uniqueHF (x : HF A) : HF A :=
+  if h : ∃ y, elements x = {y} then h.choose else emptyHF
+
+def cardHF (x : HF A) : HF A := ordinal (elements x).card
+
+def inputHF (S : Input A) (r : Symbol) (x y : HF A) : Bool :=
+  decide (∃ a b, x = atom a ∧ y = atom b ∧ S.rel r a b = true)
+
+def lift₂ {X Y Z : Type} (f : X → Y → Z) (a : Result X) (b : Result Y) : Result Z :=
+  a.bind (fun x => b.map (f x))
+
+def collect (r : HF A) (guard : HF A → Result Bool) (body : HF A → Result (HF A)) :
+    Result (HF A) :=
+  if (∀ x ∈ elements r, (guard x).isSome) ∧
+      (∀ x ∈ elements r, guard x = some true → (body x).isSome) then
+    some (ofFinset (((elements r).filter (fun x => guard x = some true)).image
+      (fun x => (body x).getD emptyHF)))
+  else none
+
+def iterationLoop (p : ℕ) (step : HF A → Result (HF A)) : ℕ → HF A → Result (HF A)
+  | 0, _ => some emptyHF
+  | fuel+1, x =>
+      if (TC x).card ≤ p then
+        (step x).bind (fun y =>
+          if x = y then some x else iterationLoop p step fuel y)
+      else some emptyHF
+
+def ordinaryIteration (p : ℕ) (step : HF A → Result (HF A)) : Result (HF A) :=
+  iterationLoop p step (p+1) emptyHF
+
+def resource (p : Polynomial ℝ) (n : ℕ) : ℕ := ⌊p.eval (n : ℝ)⌋₊
+
+variable [Fintype A]
+
+def permutationGraph (g : Equiv.Perm A) : HF A :=
+  ofFinset (Finset.univ.image (fun a => pair (atom a) (atom (g a))))
+
+def Automorphism (S : Input A) (g : Equiv.Perm A) : Prop :=
+  ∀ r a b, S.rel r (g a) (g b) = S.rel r a b
+
+def ChoicePrefix (step : HF A → HF A → Result (HF A))
+    (choice : HF A → Result (HF A)) (b c : ℕ → HF A) (k : ℕ) : Prop :=
+  b 0 = emptyHF ∧ ∀ i < k,
+    (∃ D, choice (b i) = some D ∧ c i ∈ elements D) ∧
+    step (b i) (c i) = some (b (i+1))
+
+def StrictPrefix (b : ℕ → HF A) (k : ℕ) : Prop := ∀ i < k, b i ≠ b (i+1)
+
+def FirstPath (step : HF A → HF A → Result (HF A))
+    (choice : HF A → Result (HF A)) (b c : ℕ → HF A) (t : ℕ) : Prop :=
+  ChoicePrefix step choice b c (t+1) ∧ StrictPrefix b t ∧ b t = b (t+1)
+
+def FixesParameters {n : ℕ} (free : Finset (Fin n)) (env : Fin n → HF A)
+    (g : Equiv.Perm A) : Prop := ∀ i ∈ free, g • env i = env i
+
+def WitnessesHistory {n : ℕ} (S : Input A) (free : Finset (Fin n))
+    (env : Fin n → HF A) (b : ℕ → HF A) (i : ℕ) (D M : HF A) : Prop :=
+  isSet M = true ∧
+  (∀ w ∈ elements M, ∃ g : Equiv.Perm A,
+    w = permutationGraph g ∧ Automorphism S g ∧ FixesParameters free env g ∧
+      ∀ j ≤ i, g • b j = b j) ∧
+  (∀ u ∈ elements D, ∀ v ∈ elements D, ∃ g : Equiv.Perm A,
+    permutationGraph g ∈ elements M ∧ g • u = v)
+
+def GoodWSC {n : ℕ} (S : Input A) (p : ℕ) (free : Finset (Fin n))
+    (env : Fin n → HF A) (step : HF A → HF A → Result (HF A))
+    (choice : HF A → Result (HF A)) (witness : HF A → HF A → Result (HF A))
+    (output : HF A → Result Bool) : Prop :=
+  (∀ b c k, ChoicePrefix step choice b c k → StrictPrefix b k →
+    k ≤ p ∧ (TC (b k)).card ≤ p ∧ ∃ D, choice (b k) = some D ∧
+      (elements D).Nonempty ∧ ∀ u ∈ elements D, (step (b k) u).isSome) ∧
+  (∀ b c t, FirstPath step choice b c t → t+2 ≤ p ∧
+    (∀ i ≤ t, ∃ D M, choice (b i) = some D ∧ witness (b t) (b i) = some M ∧
+      WitnessesHistory S free env b i D M) ∧ (output (b t)).isSome)
+
+def witnessedIteration {n : ℕ} (S : Input A) (p : ℕ) (free : Finset (Fin n))
+    (env : Fin n → HF A) (step : HF A → HF A → Result (HF A))
+    (choice : HF A → Result (HF A)) (witness : HF A → HF A → Result (HF A))
+    (output : HF A → Result Bool) : Result Bool :=
+  if GoodWSC S p free env step choice witness output then
+    some (decide (∀ b c t, FirstPath step choice b c t → output (b t) = some true))
+  else none
+
+mutual
+
+def Term.eval (S : Input A) (p : Polynomial ℝ) : {n : ℕ} → Term n →
+      (Fin n → HF A) → Result (HF A)
+    | _, .var i, env => some (env i)
+    | _, .empty, _ => some emptyHF
+    | _, .atoms, _ => some (ofFinset (Finset.univ.image atom))
+    | _, .pair a b, env => lift₂ double (a.eval S p env) (b.eval S p env)
+    | _, .union a, env => (a.eval S p env).map unionHF
+    | _, .unique a, env => (a.eval S p env).map uniqueHF
+    | _, .card a, env => (a.eval S p env).map cardHF
+    | _, .comprehend body range guard, env =>
+        (range.eval S p env).bind (fun r => collect r
+          (fun x => guard.eval S p (Fin.cons x env))
+          (fun x => body.eval S p (Fin.cons x env)))
+    | _, .iterate step, env => ordinaryIteration (resource p (Fintype.card A))
+        (fun x => step.eval S p (Fin.cons x env))
+  def Formula.eval (S : Input A) (p : Polynomial ℝ) : {n : ℕ} → Formula n →
+      (Fin n → HF A) → Result Bool
+    | _, .equal a b, env => lift₂ (fun x y => decide (x = y)) (a.eval S p env) (b.eval S p env)
+    | _, .input r a b, env => lift₂ (inputHF S r) (a.eval S p env) (b.eval S p env)
+    | _, .neg a, env => (a.eval S p env).map Bool.not
+    | _, .and a b, env => lift₂ Bool.and (a.eval S p env) (b.eval S p env)
+    | _, .or a b, env => lift₂ Bool.or (a.eval S p env) (b.eval S p env)
+    | _, .wsc step choice witness output, env =>
+        witnessedIteration S (resource p (Fintype.card A))
+          (Formula.wsc step choice witness output).free env
+          (fun x y => step.eval S p (Fin.cons y (Fin.cons x env)))
+          (fun x => choice.eval S p (Fin.cons x env))
+          (fun z x => witness.eval S p (Fin.cons x (Fin.cons z env)))
+          (fun x => output.eval S p (Fin.cons x env))
+
+end
+
+structure FiniteInput where
+  Carrier : Type
+  finite : Fintype Carrier
+  input : Input Carrier
+
+attribute [instance] FiniteInput.finite
+
+structure Sentence where
+  formula : Formula 0
+  polynomial : Polynomial ℝ
+
+def Sentence.eval (φ : Sentence) (S : FiniteInput) : Result Bool :=
+  φ.formula.eval S.input φ.polynomial Fin.elim0
+
+def Sentence.isCPT (φ : Sentence) : Prop := φ.formula.wscCount = 0
+
+def Sentence.BooleanOnAllInputs (φ : Sentence) : Prop :=
+  ∀ S, ∃ b : Bool, φ.eval S = some b
+
+def Sentence.TrueModels (φ : Sentence) : Set FiniteInput := {S | φ.eval S = some true}
+
+def MainStatement : Prop := ∃ φ : Sentence,
+  φ.formula.wscCount = 1 ∧ φ.BooleanOnAllInputs ∧
+    ∀ ψ : Sentence, ψ.isCPT → φ.TrueModels ≠ ψ.TrueModels
+
+end BGS
+
+end WitnessedChoice
+
+theorem WitnessedChoice.main : WitnessedChoice.BGS.MainStatement := by
+  sorry
+
+end
+
+end OAI
diff --git a/lean/ComparatorChallenges/YauCounterexample.json b/lean/ComparatorChallenges/YauCounterexample.json
new file mode 100644
index 0000000000000000000000000000000000000000..c89cfb9140585b3e9e07d44b5f2b22ec14878a88
--- /dev/null
+++ b/lean/ComparatorChallenges/YauCounterexample.json
@@ -0,0 +1,14 @@
+{
+  "challenge_module": "ComparatorChallenges.YauCounterexample",
+  "solution_module": "OAI.Geometry.NodalSets.Main",
+  "theorem_names": [
+    "OAI.Yau.Target.yau_nodal_set_upper_bound_counterexample"
+  ],
+  "definition_names": [],
+  "permitted_axioms": [
+    "propext",
+    "Quot.sound",
+    "Classical.choice"
+  ],
+  "enable_nanoda": false
+}
diff --git a/lean/ComparatorChallenges/YauCounterexample.lean b/lean/ComparatorChallenges/YauCounterexample.lean
new file mode 100644
index 0000000000000000000000000000000000000000..8b4a00979ffa7ff1ff76c34237e62b331b63073f
--- /dev/null
+++ b/lean/ComparatorChallenges/YauCounterexample.lean
@@ -0,0 +1,72 @@
+import Mathlib
+
+namespace OAI
+
+namespace Yau
+namespace Target
+open Bundle Manifold Matrix Filter
+open scoped ContDiff Topology ENNReal
+noncomputable section
+
+abbrev Base := Metric.sphere (0 : EuclideanSpace ℝ (Fin 5)) 1
+
+abbrev Manifold5 := Base × Circle
+
+abbrev Model := EuclideanSpace ℝ (Fin 4) × EuclideanSpace ℝ (Fin 1)
+
+abbrev modelWithCorners := (𝓡 4).prod (𝓡 1)
+
+abbrev SmoothMetric := ContMDiffRiemannianMetric modelWithCorners ∞ Model
+  (fun x : Manifold5 ↦ TangentSpace modelWithCorners x)
+
+abbrev Index := Fin (Module.finrank ℝ Model)
+
+def frame : Module.Basis Index ℝ Model := Module.finBasis ℝ Model
+
+def metricMatrix (g : SmoothMetric) (c : PartialEquiv Manifold5 Model)
+    (y : Model) : Matrix Index Index ℝ := fun i j ↦
+  g.inner (c.symm y)
+    (mfderiv 𝓘(ℝ, Model) modelWithCorners c.symm y (frame i))
+    (mfderiv 𝓘(ℝ, Model) modelWithCorners c.symm y (frame j))
+
+def volumeFactor (g : SmoothMetric) (c : PartialEquiv Manifold5 Model)
+    (y : Model) : ℝ := Real.sqrt (metricMatrix g c y).det
+
+def chartLaplacian (g : SmoothMetric) (c : PartialEquiv Manifold5 Model)
+    (u : Manifold5 → ℝ) (y : Model) : ℝ :=
+  (volumeFactor g c y)⁻¹ * ∑ i, fderiv ℝ
+    (fun z ↦ volumeFactor g c z * ∑ j,
+      (metricMatrix g c z)⁻¹ i j * fderiv ℝ (u ∘ c.symm) z (frame j)) y (frame i)
+
+def nodalMeasure (g : SmoothMetric) (u : Manifold5 → ℝ) : ℝ≥0∞ :=
+  letI : RiemannianBundle (fun x : Manifold5 ↦ TangentSpace modelWithCorners x) :=
+    ⟨g.toRiemannianMetric⟩
+  letI : IsContMDiffRiemannianBundle modelWithCorners ∞ Model
+      (fun x : Manifold5 ↦ TangentSpace modelWithCorners x) := inferInstance
+  letI : MeasurableSpace Manifold5 := borel Manifold5
+  letI : BorelSpace Manifold5 := ⟨rfl⟩
+  letI : IsContinuousRiemannianBundle Model
+      (fun x : Manifold5 ↦ TangentSpace modelWithCorners x) :=
+    ⟨g.inner, g.toContinuousRiemannianMetric.continuous, fun _ _ _ ↦ rfl⟩
+  letI : EMetricSpace Manifold5 := EMetricSpace.ofRiemannianMetric modelWithCorners Manifold5
+  MeasureTheory.Measure.hausdorffMeasure (4 : ℝ) {x | u x = 0}
+
+def MainTarget : Prop :=
+  ∃ (g : SmoothMetric) (lam : ℕ → ℝ) (u : ℕ → Manifold5 → ℝ),
+    (∀ k, 0 < lam k) ∧
+    (∀ k, u k ≠ 0) ∧
+    (∀ k, ContMDiff modelWithCorners 𝓘(ℝ, ℝ) ∞ (u k)) ∧
+    (∀ k x, -chartLaplacian g (extChartAt modelWithCorners x) (u k) ((extChartAt modelWithCorners x) x) =
+      lam k * u k x) ∧
+    Tendsto lam atTop atTop ∧
+    Tendsto (fun k ↦ nodalMeasure g (u k) / ENNReal.ofReal (Real.sqrt (lam k)))
+      atTop (𝓝 ⊤)
+
+theorem yau_nodal_set_upper_bound_counterexample : MainTarget := by
+  sorry
+
+end
+end Target
+end Yau
+
+end OAI
diff --git a/lean/LICENSE b/lean/LICENSE
new file mode 100644
index 0000000000000000000000000000000000000000..261eeb9e9f8b2b4b0d119366dda99c6fd7d35c64
--- /dev/null
+++ b/lean/LICENSE
@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
diff --git a/lean/OAI/Algebra/AffineCancellation/BezoutFrame.lean b/lean/OAI/Algebra/AffineCancellation/BezoutFrame.lean
new file mode 100644
index 0000000000000000000000000000000000000000..3e50ca65f9638fd532b6fff5054726b29bd17974
--- /dev/null
+++ b/lean/OAI/Algebra/AffineCancellation/BezoutFrame.lean
@@ -0,0 +1,50 @@
+import OAI.Algebra.AffineCancellation.Model
+
+namespace OAI
+
+noncomputable section
+
+namespace ComplexCancellation.BezoutFrame
+
+/-- Principalization of an SL₂/diagonal-torus point over a Euclidean domain.
+This supplies the invariant-localization frame over the slice polynomial ring. -/
+theorem exists_frame {R : Type*} [EuclideanDomain R] (x y z : R)
+    (h : x*y = z*(z+1)) :
+    ∃ a d b c : R, a*b = x ∧ d*c = y ∧ d*b = z ∧ a*c-d*b = 1 := by
+  classical
+  let g := EuclideanDomain.gcd x z
+  by_cases hg : g = 0
+  · have hxz : x = 0 ∧ z = 0 := EuclideanDomain.gcd_eq_zero_iff.mp hg
+    exact ⟨1, y, 0, 1, by simp [hxz.1], by simp, by simp [hxz.2], by simp⟩
+  · obtain ⟨a, ha⟩ := EuclideanDomain.gcd_dvd_left x z
+    obtain ⟨d, hd⟩ := EuclideanDomain.gcd_dvd_right x z
+    change x = g*a at ha
+    change z = g*d at hd
+    let r := EuclideanDomain.gcdA x z
+    let s := EuclideanDomain.gcdB x z
+    have hbez : a*r+d*s=1 := by
+      apply mul_left_cancel₀ hg
+      calc g * (a*r+d*s) = x*r+z*s := by rw [ha, hd]; ring
+        _ = g := (EuclideanDomain.gcd_eq_gcd_ab x z).symm
+        _ = g*1 := (mul_one g).symm
+    have hrel : a*y=d*(z+1) := by
+      apply mul_left_cancel₀ hg
+      calc g*(a*y) = x*y := by rw [ha]; ring
+        _ = z*(z+1) := h
+        _ = g*(d*(z+1)) := by rw [hd]; ring
+    refine ⟨a,d,g,r*(z+1)+s*y, ?_, ?_, ?_, ?_⟩
+    · rw [mul_comm, ← ha]
+    · calc d*(r*(z+1)+s*y) = r*(d*(z+1))+d*s*y := by ring
+        _ = r*(a*y)+d*s*y := by rw [hrel]
+        _ = (a*r+d*s)*y := by ring
+        _ = y := by rw [hbez, one_mul]
+    · rw [mul_comm, ← hd]
+    · calc a*(r*(z+1)+s*y)-d*g = a*r*(z+1)+s*(a*y)-z := by rw [hd]; ring
+        _ = (a*r+d*s)*(z+1)-z := by rw [hrel]; ring
+        _ = 1 := by rw [hbez]; ring
+
+end ComplexCancellation.BezoutFrame
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/AffineCancellation/Bundle.lean b/lean/OAI/Algebra/AffineCancellation/Bundle.lean
new file mode 100644
index 0000000000000000000000000000000000000000..9c7cdf0d84176917c0d86b2ba1ebab518195b44b
--- /dev/null
+++ b/lean/OAI/Algebra/AffineCancellation/Bundle.lean
@@ -0,0 +1,187 @@
+import OAI.Algebra.AffineCancellation.Degeneration
+import OAI.Algebra.AffineCancellation.Modification
+
+namespace OAI
+
+noncomputable section
+
+namespace ComplexCancellation.Bundle
+open MvPolynomial
+open Determinant
+
+def quadricEval : Quadric.Poly →ₐ[ℂ] T := aeval ![a*b,d*c,d*b,Determinant.u]
+lemma quadricEval_relation : quadricEval Quadric.relation=0 := by
+  simp only [Quadric.relation,quadricEval,aeval_X,map_sub,map_mul,map_add,map_one,
+    Matrix.cons_val,Matrix.cons_val_zero,Matrix.cons_val_one]
+  linear_combination b*d*determinant
+def inclusion : Quadric.R →ₐ[ℂ] T := Ideal.Quotient.liftₐ _ quadricEval (by
+  intro r hr
+  obtain ⟨t,rfl⟩ := Ideal.mem_span_singleton.mp hr
+  rw [map_mul,quadricEval_relation,zero_mul])
+@[simp] lemma inclusion_π (r : Quadric.Poly) : inclusion (Quadric.π r)=quadricEval r :=
+  Ideal.Quotient.lift_mk _ _ _
+@[simp] lemma inclusion_x : inclusion Quadric.x=a*b := by simp [Quadric.x,quadricEval]
+@[simp] lemma inclusion_y : inclusion Quadric.y=d*c := by simp [Quadric.y,quadricEval]
+@[simp] lemma inclusion_z : inclusion Quadric.z=d*b := by simp [Quadric.z,quadricEval,Matrix.cons_val]
+@[simp] lemma inclusion_u : inclusion Quadric.u=Determinant.u := by simp [Quadric.u,quadricEval,Matrix.cons_val]
+
+abbrev K := FractionRing Quadric.R
+def ι : Quadric.R →ₐ[ℂ] K := IsScalarTower.toAlgHom ℂ Quadric.R K
+lemma ι_injective : Function.Injective ι := IsFractionRing.injective Quadric.R K
+lemma x_ne_zero : ι Quadric.x ≠ 0 := by simpa using ι_injective.ne Quadric.x_ne_zero
+def chartEval : Poly →ₐ[ℂ] K := aeval ![1,ι Quadric.z/ι Quadric.x,ι Quadric.x,
+  ι Quadric.z+1,ι Quadric.u]
+lemma chartEval_relation : chartEval relation=0 := by
+  simp only [relation,chartEval,aeval_X,map_sub,map_mul,map_one,Matrix.cons_val,
+    Matrix.cons_val_zero,Matrix.cons_val_one]
+  field_simp [x_ne_zero]
+  ring
+def chart : T →ₐ[ℂ] K := Ideal.Quotient.liftₐ _ chartEval (by
+  intro r hr
+  obtain ⟨t,rfl⟩ := Ideal.mem_span_singleton.mp hr
+  rw [map_mul,chartEval_relation,zero_mul])
+@[simp] lemma chart_π (r : Poly) : chart (π r)=chartEval r := Ideal.Quotient.lift_mk _ _ _
+lemma chart_inclusion : chart.comp inclusion=ι := by
+  apply Ideal.Quotient.algHom_ext
+  apply MvPolynomial.algHom_ext
+  intro i
+  fin_cases i
+  · change chart (inclusion Quadric.x)=ι Quadric.x
+    rw [inclusion_x]
+    simp [a,b,chartEval,Matrix.cons_val]
+  · change chart (inclusion Quadric.y)=ι Quadric.y
+    rw [inclusion_y]
+    simp only [map_mul,d,c,chart_π,chartEval,aeval_X,Matrix.cons_val,
+      Matrix.cons_val_zero,Matrix.cons_val_one]
+    rw [div_mul_eq_mul_div]
+    apply (div_eq_iff x_ne_zero).mpr
+    have he := congrArg ι Quadric.equation
+    simp only [map_mul,map_add,map_one] at he
+    linear_combination -he
+  · change chart (inclusion Quadric.z)=ι Quadric.z
+    simp [inclusion_z,d,b,chartEval,Matrix.cons_val,x_ne_zero]
+  · change chart (inclusion Quadric.u)=ι Quadric.u
+    simp [Determinant.u,chartEval,Matrix.cons_val]
+lemma inclusion_injective : Function.Injective inclusion := by
+  apply Function.Injective.of_comp (f := chart)
+  rw [← AlgHom.coe_comp,chart_inclusion]
+  exact ι_injective
+
+def h : T := a*b-Determinant.u^3
+def C₁ : T := c^2-b^2*h
+def α : T := a^2*(1-2*b*d)
+def β : T := d^2*(3+2*b*d)+α*h
+lemma inclusion_s : inclusion Quadric.s=d*c-a*b*h := by
+  simp only [Quadric.s,map_sub,map_mul,map_pow,inclusion_x,inclusion_y,inclusion_u,h]
+lemma inclusion_f : inclusion Quadric.f=C₁*v := by
+  simp only [Quadric.f,map_sub,map_pow,inclusion_x,inclusion_s,inclusion_u,C₁,h,v]
+  linear_combination -(a*b-Determinant.u^3)*(a*c-b*d+1)*determinant
+lemma inclusion_g : inclusion Quadric.g=b^2*v := by
+  simp only [Quadric.g,map_sub,map_mul,inclusion_z,inclusion_s,inclusion_x,h,v]
+  linear_combination -b*d*determinant
+lemma certificate : α*C₁+β*b^2=1 := by
+  simp only [α,β,C₁]
+  linear_combination (1-2*b*d)*(a*c+b*d+1)*determinant
+lemma v_ne_zero : v ≠ 0 := by
+  intro hv
+  have he : baseMap (X 1^3*X 3-X 1^2*X 0^3-X 2^2)=0 := by
+    simpa [baseMap,baseValues,Matrix.cons_val,v] using hv
+  have hp := baseMap_injective (he.trans (map_zero baseMap).symm)
+  have hs := congrArg (MvPolynomial.eval (fun i : Fin 4 => if i=2 then (1:ℂ) else 0)) hp
+  norm_num [Fin.ext_iff] at hs
+abbrev B := AffineModification.T T v
+instance : IsDomain B := Function.Injective.isDomain (AffineModification.embedding T v)
+  (AffineModification.embedding_injective T v v_ne_zero)
+def j : T →ₐ[ℂ] B := IsScalarTower.toAlgHom ℂ T B
+def τ : B := AffineModification.τ T v
+def V : B := AffineModification.V T v
+lemma τ_ne_zero : τ ≠ 0 := by
+  intro hz
+  have he := congrArg (AffineModification.embedding T v) hz
+  have hx : (RatFunc.X : AffineModification.K T)=0 := by
+    simpa [τ,AffineModification.τ,AffineModification.eval,AffineModification.values] using he
+  exact RatFunc.X_ne_zero hx
+lemma equation : τ^2*V=j v := AffineModification.equation T v
+
+def values : Fin 5 → B := ![τ,j (inclusion Quadric.s),j Determinant.u,j C₁*V,j (b^2)*V]
+def eval : Degeneration.P →ₐ[ℂ] B := aeval values
+lemma eval_xp : eval Degeneration.xp=j (inclusion Quadric.x) := by
+  simp only [Degeneration.xp,eval,map_add,map_mul,map_pow,aeval_X,values,
+    Matrix.cons_val,Matrix.cons_val_zero,Matrix.cons_val_one]
+  have hf := congrArg j inclusion_f
+  simp only [Quadric.f,map_sub,map_pow,inclusion_u,map_mul] at hf
+  linear_combination -hf + j C₁*equation
+lemma eval_yp : eval Degeneration.yp=j (inclusion Quadric.y) := by
+  simp only [Degeneration.yp,map_add,map_mul,map_sub,map_pow,eval_xp]
+  simp only [eval,aeval_X,values,Matrix.cons_val,Matrix.cons_val_zero,Matrix.cons_val_one]
+  simp only [Quadric.s,map_sub,map_mul,map_pow,inclusion_u]
+  ring
+lemma eval_zp : eval Degeneration.zp=j (inclusion Quadric.z) := by
+  simp only [Degeneration.zp,map_add,map_mul,map_pow,eval_xp]
+  simp only [eval,aeval_X,values,Matrix.cons_val,Matrix.cons_val_zero,Matrix.cons_val_one]
+  have hg := congrArg j inclusion_g
+  simp only [Quadric.g,map_sub,map_mul] at hg
+  linear_combination -hg + j (b^2)*equation
+lemma eval_relation : eval Degeneration.relation=0 := by
+  have hi := congrArg eval Degeneration.identity
+  simp only [map_sub,map_mul,map_add,map_pow,map_one,eval_xp,eval_yp,eval_zp] at hi
+  have he := congrArg (j.comp inclusion) Quadric.equation
+  simp only [AlgHom.comp_apply,map_mul,map_add,map_one] at he
+  rw [sub_eq_zero.mpr he] at hi
+  have hp : eval (X 0)≠0 := by simpa [eval,values] using τ_ne_zero
+  exact (mul_eq_zero.mp hi.symm).resolve_left (pow_ne_zero 2 hp)
+def pullback : Degeneration.G →ₐ[ℂ] B := Ideal.Quotient.liftₐ _ eval (by
+  intro r hr
+  obtain ⟨t,rfl⟩ := Ideal.mem_span_singleton.mp hr
+  rw [map_mul,eval_relation,zero_mul])
+@[simp] lemma pullback_π (r : Degeneration.P) : pullback (Degeneration.π r)=eval r :=
+  Ideal.Quotient.lift_mk _ _ _
+lemma pullback_coefficientMap : pullback.comp Degeneration.coefficientMap=j.comp inclusion := by
+  apply Ideal.Quotient.algHom_ext
+  apply MvPolynomial.algHom_ext
+  intro i
+  fin_cases i
+  · change pullback (Degeneration.coefficientMap Quadric.x)=j (inclusion Quadric.x)
+    rw [Degeneration.coefficientMap_x,Degeneration.x,pullback_π,eval_xp]
+  · change pullback (Degeneration.coefficientMap Quadric.y)=j (inclusion Quadric.y)
+    rw [Degeneration.coefficientMap_y,Degeneration.y,pullback_π,eval_yp]
+  · change pullback (Degeneration.coefficientMap Quadric.z)=j (inclusion Quadric.z)
+    rw [Degeneration.coefficientMap_z,Degeneration.z,pullback_π,eval_zp]
+  · change pullback (Degeneration.coefficientMap Quadric.u)=j (inclusion Quadric.u)
+    rw [Degeneration.coefficientMap_u,inclusion_u,Degeneration.u,pullback_π]
+    simp [eval,values,Matrix.cons_val]
+def base : Polynomial T →ₐ[ℂ] B := (AffineModification.baseMap T v).restrictScalars ℂ
+lemma base_injective : Function.Injective base := by
+  apply Function.Injective.of_comp (f := AffineModification.embedding T v)
+  intro r s he
+  change AffineModification.embedding T v (AffineModification.baseMap T v r)=
+    AffineModification.embedding T v (AffineModification.baseMap T v s) at he
+  have ht := AffineModification.embedding_baseMap T v
+  simp only [← AlgHom.comp_apply,ht] at he
+  exact AffineModification.baseEmbedding_injective T he
+lemma pullback_baseMap : pullback.comp Degeneration.baseMap =
+    base.comp (Polynomial.mapAlgHom inclusion) := by
+  apply Polynomial.algHom_ext'
+  · ext r
+    simp only [AlgHom.comp_apply,Polynomial.CAlgHom_apply,Polynomial.coe_mapAlgHom,Polynomial.map_C]
+    rw [Degeneration.baseMap_C]
+    simp only [base,AlgHom.restrictScalars_apply,AffineModification.baseMap,Polynomial.aeval_C]
+    change pullback (Degeneration.coefficientMap r)=j (inclusion r)
+    exact DFunLike.congr_fun pullback_coefficientMap r
+  · simp only [AlgHom.comp_apply,Polynomial.coe_mapAlgHom,Polynomial.map_X]
+    rw [Degeneration.baseMap_X]
+    simp only [base,AlgHom.restrictScalars_apply,AffineModification.baseMap,Polynomial.aeval_X]
+    change pullback (Degeneration.π (X 0))=τ
+    rw [pullback_π]
+    simp [eval,values]
+lemma pullback_injective : Function.Injective pullback := by
+  apply Clearing.injective_of_clearing (S := Polynomial Quadric.R) pullback Degeneration.baseMap Polynomial.X
+  · rw [pullback_baseMap]
+    exact base_injective.comp (Polynomial.map_injective _ inclusion_injective)
+  · rw [Degeneration.baseMap_X]; exact Degeneration.p_regular
+  · exact Degeneration.clears
+end ComplexCancellation.Bundle
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/AffineCancellation/BundleGrading.lean b/lean/OAI/Algebra/AffineCancellation/BundleGrading.lean
new file mode 100644
index 0000000000000000000000000000000000000000..7017e9c02bfe264e7cd484f1b76ebbae65088768
--- /dev/null
+++ b/lean/OAI/Algebra/AffineCancellation/BundleGrading.lean
@@ -0,0 +1,57 @@
+import OAI.Algebra.AffineCancellation.ReplicaLift
+import OAI.Algebra.AffineCancellation.GradedCommutation
+
+namespace OAI
+
+noncomputable section
+
+namespace ComplexCancellation.Bundle
+open Determinant
+lemma fiberEuler_j (r : T) : fiberEuler (j r)=j (Euler r) := AffineModification.euler_coefficient _ _ _ r
+lemma fiberEuler_τ : fiberEuler τ=0 := AffineModification.euler_τ _ _ _
+lemma fiberEuler_V : fiberEuler V=2*V := AffineModification.euler_V _ _ _
+lemma j_mem (r : T) : j r ∈ valuationPieces 0 := AffineModification.coefficient_mem T v r
+lemma τ_mem : τ ∈ valuationPieces (-1) := AffineModification.τ_mem T v
+lemma V_mem : V ∈ valuationPieces 2 := AffineModification.V_mem T v
+lemma fiberEuler_homogeneous (i : ℤ) (r : B) (hr : r ∈ valuationPieces i) :
+    fiberEuler r ∈ valuationPieces i := by
+  have he : fiberEuler=GradedLND.component valuationPieces fiberEuler 0 := by
+    apply sub_eq_zero.mp
+    apply AffineModification.derivation_zero_of_generators v
+    · intro a
+      change fiberEuler (j a)-GradedLND.component valuationPieces fiberEuler 0 (j a)=0
+      rw [GradedLND.component_of_mem valuationPieces fiberEuler 0 (j_mem a),add_zero,
+        fiberEuler_j,GradedLND.proj_of_mem valuationPieces (j_mem _),sub_self]
+    · change fiberEuler τ-GradedLND.component valuationPieces fiberEuler 0 τ=0
+      rw [GradedLND.component_of_mem valuationPieces fiberEuler 0 τ_mem,fiberEuler_τ,map_zero,sub_self]
+    · change fiberEuler V-GradedLND.component valuationPieces fiberEuler 0 V=0
+      rw [GradedLND.component_of_mem valuationPieces fiberEuler 0 V_mem,add_zero,fiberEuler_V]
+      have hm : 2*V ∈ valuationPieces 2 := by simpa only [two_mul] using add_mem V_mem V_mem
+      rw [GradedLND.proj_of_mem valuationPieces hm,sub_self]
+  rw [he]
+  simpa only [add_zero] using GradedLND.component_homogeneous valuationPieces fiberEuler 0 hr
+lemma pullback_graded (i : ℤ) (r : Degeneration.G) (hr : r ∈ Degeneration.pieces i) :
+    pullback r ∈ valuationPieces i := by
+  obtain ⟨p,hp,rfl⟩ := hr
+  change pullback (Degeneration.π p) ∈ valuationPieces i
+  rw [pullback_π]
+  apply GradedMap.mvpolynomial valuationPieces Degeneration.weight eval _ hp
+  intro z
+  fin_cases z
+  · change eval (MvPolynomial.X 0) ∈ valuationPieces (-1)
+    simpa only [eval,MvPolynomial.aeval_X,values,Matrix.cons_val_zero] using τ_mem
+  · change eval (MvPolynomial.X 1) ∈ valuationPieces 0
+    simpa only [eval,MvPolynomial.aeval_X,values,Matrix.cons_val_one,Matrix.cons_val_zero] using j_mem (inclusion Quadric.s)
+  · change eval (MvPolynomial.X 2) ∈ valuationPieces 0
+    simpa only [eval,MvPolynomial.aeval_X,values,Matrix.cons_val] using j_mem Determinant.u
+  · change eval (MvPolynomial.X 3) ∈ valuationPieces 2
+    have h := SetLike.mul_mem_graded (j_mem C₁) V_mem
+    simpa only [zero_add,eval,MvPolynomial.aeval_X,values,Matrix.cons_val] using h
+  · change eval (MvPolynomial.X 4) ∈ valuationPieces 2
+    have h := SetLike.mul_mem_graded (j_mem (b^2)) V_mem
+    simpa only [zero_add,eval,MvPolynomial.aeval_X,values,Matrix.cons_val] using h
+end ComplexCancellation.Bundle
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/AffineCancellation/Clearing.lean b/lean/OAI/Algebra/AffineCancellation/Clearing.lean
new file mode 100644
index 0000000000000000000000000000000000000000..5b28c2c476471f5cfd47c19f0a67b02bf0e5150f
--- /dev/null
+++ b/lean/OAI/Algebra/AffineCancellation/Clearing.lean
@@ -0,0 +1,60 @@
+import OAI.Algebra.AffineCancellation.Model
+
+namespace OAI
+
+noncomputable section
+
+namespace ComplexCancellation.Clearing
+variable {k S R : Type*} [CommRing k] [CommRing S] [CommRing R] [Algebra k S] [Algebra k R]
+
+/-- Elements whose denominators can be cleared with a power of a fixed base element. -/
+def subalgebra (f : S →ₐ[k] R) (p : S) : Subalgebra k R where
+  carrier := {r | ∃ n : ℕ, ∃ s : S, f p ^ n * r = f s}
+  zero_mem' := ⟨0,0,by simp⟩
+  one_mem' := ⟨0,1,by simp⟩
+  add_mem' := by
+    rintro r s ⟨n,a,ha⟩ ⟨m,b,hb⟩
+    refine ⟨n+m,p^m*a+p^n*b,?_⟩
+    rw [map_add,map_mul,map_mul,map_pow,map_pow,← ha,← hb,pow_add]
+    ring
+  mul_mem' := by
+    rintro r s ⟨n,a,ha⟩ ⟨m,b,hb⟩
+    refine ⟨n+m,a*b,?_⟩
+    rw [map_mul,← ha,← hb,pow_add]
+    ring
+  algebraMap_mem' c := ⟨0,algebraMap k S c,by simp⟩
+
+lemma mem_base (f : S →ₐ[k] R) (p s : S) : f s ∈ subalgebra f p := ⟨0,s,by simp⟩
+
+lemma injective_of_clearing {K : Type*} [CommRing K] [Algebra k K]
+    (e : R →ₐ[k] K) (f : S →ₐ[k] R) (p : S)
+    (hef : Function.Injective (e.comp f)) (hp : IsLeftRegular (f p))
+    (h : subalgebra f p = ⊤) : Function.Injective e := by
+  apply (injective_iff_map_eq_zero e).mpr
+  intro r hr
+  have hm : r ∈ subalgebra f p := by rw [h]; trivial
+  obtain ⟨n,s,hs⟩ := hm
+  have hz : s = 0 := by
+    apply hef
+    change e (f s) = e (f 0)
+    rw [← hs,map_mul,hr,mul_zero,map_zero,map_zero]
+  rw [hz,map_zero] at hs
+  exact isLeftRegular_iff_right_eq_zero_of_mul.mp (hp.pow n) r hs
+
+lemma top_of_generators {ι : Type*} (q : MvPolynomial ι k →ₐ[k] R)
+    (hq : Function.Surjective q) (f : S →ₐ[k] R) (p : S)
+    (hX : ∀ i, q (MvPolynomial.X i) ∈ subalgebra f p) : subalgebra f p = ⊤ := by
+  apply top_unique
+  intro r hrTop
+  clear hrTop
+  obtain ⟨r,rfl⟩ := hq r
+  induction r using MvPolynomial.induction_on with
+  | C c => exact (q.commutes c) ▸ (subalgebra f p).algebraMap_mem c
+  | add r s hr hs => rw [map_add]; exact add_mem hr hs
+  | mul_X r i hr => rw [map_mul]; exact mul_mem hr (hX i)
+
+end ComplexCancellation.Clearing
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/AffineCancellation/Cylinder.lean b/lean/OAI/Algebra/AffineCancellation/Cylinder.lean
new file mode 100644
index 0000000000000000000000000000000000000000..ad796d16a4a0b71cb1ad9bd79c94f660740e4ed9
--- /dev/null
+++ b/lean/OAI/Algebra/AffineCancellation/Cylinder.lean
@@ -0,0 +1,189 @@
+import OAI.Algebra.AffineCancellation.CylinderMaps
+
+namespace OAI
+
+noncomputable section
+
+namespace ComplexCancellation.Cylinder
+
+/-- Saturation needed at p=0. It does not assume the hypersurface is integral. -/
+lemma regular_quotient_of_prime {R : Type*} [CommRing R] [IsDomain R]
+    {p h : R} (hp : Prime p) (hph : ¬p ∣ h) :
+    IsLeftRegular (Ideal.Quotient.mk (Ideal.span {h}) p) := by
+  apply isLeftRegular_iff_right_eq_zero_of_mul.mpr
+  intro q hq
+  obtain ⟨r, rfl⟩ := Ideal.Quotient.mk_surjective q
+  rw [← map_mul, Ideal.Quotient.eq_zero_iff_mem, Ideal.mem_span_singleton] at hq
+  obtain ⟨c, hc⟩ := hq
+  have hpc : p ∣ c := (hp.dvd_or_dvd (show p ∣ h * c by rw [← hc]; exact dvd_mul_right _ _)).resolve_left hph
+  obtain ⟨d, rfl⟩ := hpc
+  have hr : r = h * d := by
+    apply mul_left_cancel₀ hp.ne_zero
+    linear_combination hc
+  rw [Ideal.Quotient.eq_zero_iff_mem, Ideal.mem_span_singleton, hr]
+  exact dvd_mul_right _ _
+
+lemma polynomial_C_regular {R : Type*} [CommRing R] {r : R} (hr : IsLeftRegular r) :
+    IsLeftRegular (Polynomial.C r) := by
+  intro f g hfg
+  apply Polynomial.ext
+  intro n
+  apply hr
+  simpa using congrArg (fun f : Polynomial R => f.coeff n) hfg
+
+end ComplexCancellation.Cylinder
+
+namespace ComplexCancellation.Cylinder
+
+open MvPolynomial
+
+def universal : Point P := ⟨p, s, u, F, J⟩
+def parameters : Frame P := ⟨p, s, u, F⟩
+
+namespace Point
+variable {R S : Type*} [CommRing R] [Algebra ℂ R] [CommRing S] [Algebra ℂ S]
+
+def eval (q : Point R) : P →ₐ[ℂ] R := MvPolynomial.aeval ![q.p, q.s, q.u, q.f, q.j]
+
+@[simp] lemma universal_eval (q : Point R) : universal.map q.eval.toRingHom = q := by
+  ext <;> simp [universal, map, eval, ComplexCancellation.p, ComplexCancellation.s, ComplexCancellation.u, F, J]
+
+lemma eval_equation (q : Point R) : q.eval H = q.equation := by
+  have h := universal.map_equation q.eval.toRingHom
+  rw [universal_eval] at h
+  exact h.symm
+
+lemma map_eval (q : Point R) (g : R →ₐ[ℂ] S) :
+    g.comp q.eval = (q.map g.toRingHom).eval := by
+  apply MvPolynomial.algHom_ext
+  intro i
+  fin_cases i <;> simp [eval, map]
+
+@[simp] lemma universal_eval_id : universal.eval = AlgHom.id ℂ P := by
+  apply MvPolynomial.algHom_ext
+  intro i
+  fin_cases i <;> simp [eval, universal, ComplexCancellation.p, ComplexCancellation.s, ComplexCancellation.u, F, J]
+
+end Point
+
+def paramPoint {R : Type*} (t : Frame R) (z : R) : Point R := ⟨t.p, t.s, t.u, t.m, z⟩
+
+lemma paramPoint_map {R S : Type*} [CommRing R] [CommRing S]
+    (t : Frame R) (z : R) (g : R →+* S) :
+    (paramPoint t z).map g = paramPoint (t.map g) (g z) := rfl
+
+lemma parameters_eval {R : Type*} [CommRing R] [Algebra ℂ R] (t : Frame R) (z : R) :
+    parameters.map (paramPoint t z).eval.toRingHom = t ∧
+    (paramPoint t z).eval J = z := by
+  constructor
+  · ext <;> simp [parameters, Frame.map, paramPoint, Point.eval, p, s, u, F]
+  · simp [paramPoint, Point.eval, J]
+
+lemma p_not_dvd : ¬ p ∣ H := by
+  intro h
+  let q : Point ℂ := ⟨0, 0, 0, 0, 1⟩
+  have h' := map_dvd q.eval h
+  have hp : q.eval p = 0 := by simp [Point.eval, p, q]
+  have hh : q.eval H = -1 := by rw [q.eval_equation]; norm_num [Point.equation, Point.x, q]
+  rw [hp, hh, zero_dvd_iff] at h'
+  norm_num at h'
+
+lemma p_regular : IsLeftRegular (Ideal.Quotient.mk (Ideal.span {H}) p) :=
+  regular_quotient_of_prime (MvPolynomial.X_prime (i := 0)) p_not_dvd
+
+def sourcePoint : Point (Polynomial A) :=
+  universal.map ((Polynomial.CAlgHom : A →ₐ[ℂ] Polynomial A).comp
+    (Ideal.Quotient.mkₐ ℂ (Ideal.span {H}))).toRingHom
+
+lemma source_equation : sourcePoint.equation = 0 := by
+  rw [sourcePoint, Point.map_equation]
+  change Polynomial.C (Ideal.Quotient.mk (Ideal.span {H}) H) = 0
+  rw [Ideal.Quotient.eq_zero_iff_mem.mpr (Ideal.subset_span (Set.mem_singleton H)), Polynomial.C_0]
+
+lemma source_p_regular : IsLeftRegular sourcePoint.p := polynomial_C_regular p_regular
+
+lemma source_p_cube (r : Polynomial A) (h : sourcePoint.p ^ 3 * r = 0) : r = 0 :=
+  isLeftRegular_iff_right_eq_zero_of_mul.mp (source_p_regular.pow 3) r h
+
+def model : Point P × P := decode parameters J
+
+lemma model_equation : model.1.equation = 0 := decode_equation _ _
+
+def coefficientMap : A →ₐ[ℂ] P :=
+  Ideal.Quotient.liftₐ (Ideal.span {H}) model.1.eval (by
+    have hle : Ideal.span {H} ≤ RingHom.ker model.1.eval.toRingHom := by
+      apply Ideal.span_le.mpr
+      intro r hr
+      rw [Set.mem_singleton_iff] at hr
+      subst r
+      change model.1.eval H = 0
+      rw [Point.eval_equation, model_equation]
+    exact fun r hr => hle hr)
+
+def forward : Polynomial A →ₐ[ℂ] P :=
+  Polynomial.eval₂AlgHom coefficientMap model.2 (fun _ => Commute.all _ _)
+
+def backward : P →ₐ[ℂ] Polynomial A :=
+  (paramPoint (encode sourcePoint Polynomial.X).1 (encode sourcePoint Polynomial.X).2).eval
+
+@[simp] lemma forward_X : forward Polynomial.X = model.2 := by simp [forward]
+
+@[simp] lemma coefficientMap_mk (r : P) :
+    coefficientMap (Ideal.Quotient.mk (Ideal.span {H}) r) = model.1.eval r := by
+  exact Ideal.Quotient.lift_mk _ _ _
+
+@[simp] lemma forward_C (r : A) : forward (Polynomial.C r) = coefficientMap r := by
+  simp [forward]
+
+lemma forward_source : sourcePoint.map forward.toRingHom = model.1 := by
+  apply Point.ext <;>
+    simp [sourcePoint, Point.map, universal, Point.eval, p, s, u, F, J]
+
+lemma forward_backward : forward.comp backward = AlgHom.id ℂ P := by
+  have he := encode_map sourcePoint Polynomial.X forward.toRingHom
+  rw [forward_source] at he
+  change ((encode sourcePoint Polynomial.X).1.map forward.toRingHom,
+    forward (encode sourcePoint Polynomial.X).2) = encode model.1 (forward Polynomial.X) at he
+  rw [forward_X] at he
+  change _ = encode (decode parameters J).1 (decode parameters J).2 at he
+  rw [encode_decode] at he
+  unfold backward
+  rw [Point.map_eval (R := Polynomial A) (S := P) _ forward, paramPoint_map]
+  have he₁ : (encode sourcePoint Polynomial.X).1.map forward.toRingHom = parameters :=
+    congrArg Prod.fst he
+  have he₂ : forward.toRingHom (encode sourcePoint Polynomial.X).2 = J :=
+    congrArg Prod.snd he
+  rw [he₁, he₂]
+  exact Point.universal_eval_id
+
+lemma backward_model :
+    (model.1.map backward.toRingHom, backward model.2) = (sourcePoint, Polynomial.X) := by
+  have hp := parameters_eval (encode sourcePoint Polynomial.X).1 (encode sourcePoint Polynomial.X).2
+  have hd := decode_map (R := P) (S := Polynomial A) parameters J backward.toRingHom
+  have hp₁ : parameters.map backward.toRingHom = (encode sourcePoint Polynomial.X).1 := hp.1
+  have hp₂ : backward.toRingHom J = (encode sourcePoint Polynomial.X).2 := hp.2
+  rw [hp₁, hp₂] at hd
+  exact hd.trans (decode_encode sourcePoint Polynomial.X source_equation source_p_cube)
+
+lemma backward_forward : backward.comp forward = AlgHom.id ℂ (Polynomial A) := by
+  apply Polynomial.algHom_ext'
+  · apply Ideal.Quotient.algHom_ext ℂ
+    apply MvPolynomial.algHom_ext
+    intro i
+    have h := congrArg (fun q : Point (Polynomial A) =>
+      ![q.p, q.s, q.u, q.f, q.j] i) (congrArg Prod.fst backward_model)
+    simp only [AlgHom.comp_apply, Polynomial.CAlgHom_apply, Ideal.Quotient.mkₐ_eq_mk,
+      forward_C, coefficientMap_mk, AlgHom.id_apply]
+    fin_cases i <;>
+      simpa [Point.eval, sourcePoint, Point.map, universal, p, s, u, F, J] using h
+  · simpa using congrArg Prod.snd backward_model
+
+/-- The explicit scalar-preserving polynomial cylinder isomorphism. -/
+def equivalence : Polynomial A ≃ₐ[ℂ] P :=
+  AlgEquiv.ofAlgHom forward backward forward_backward backward_forward
+
+end ComplexCancellation.Cylinder
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/AffineCancellation/CylinderMaps.lean b/lean/OAI/Algebra/AffineCancellation/CylinderMaps.lean
new file mode 100644
index 0000000000000000000000000000000000000000..4209489912969f446564bcac8ad689bb653f627d
--- /dev/null
+++ b/lean/OAI/Algebra/AffineCancellation/CylinderMaps.lean
@@ -0,0 +1,110 @@
+import OAI.Algebra.AffineCancellation.CylinderShift
+
+namespace OAI
+
+noncomputable section
+
+namespace ComplexCancellation.Cylinder
+variable {R S : Type*} [CommRing R] [CommRing S]
+
+def encode (q : Point R) (w : R) : Frame R × R :=
+  let t := q.shift (-w)
+  (t.frame, t.frame.e t.linear w)
+
+def decode (t : Frame R) (z : R) : Point R × R :=
+  ((t.point (t.L z)).shift (t.W z), t.W z)
+
+lemma decode_equation (t : Frame R) (z : R) : (decode t z).1.equation = 0 := by
+  change ((t.point (t.L z)).shift (t.W z)).equation = 0
+  rw [Point.shift_equation]
+  exact t.coordinate_equation z
+
+lemma encode_decode (t : Frame R) (z : R) :
+    encode (decode t z).1 (decode t z).2 = (t, z) := by
+  simp only [decode, encode, Point.shift_neg_shift, Frame.frame_point,
+    Frame.linear_point, Frame.e_coordinates]
+
+lemma decode_encode (q : Point R) (w : R) (hq : q.equation = 0)
+    (hp : ∀ r : R, q.p ^ 3 * r = 0 → r = 0) :
+    decode (encode q w).1 (encode q w).2 = (q, w) := by
+  let r := q.shift (-w)
+  let t := r.frame
+  let l := r.linear
+  let z := t.e l w
+  have hpt : t.p = q.p := rfl
+  have htl : t.point l = r := r.point_frame
+  have heq : (t.point l).equation + t.p ^ 3 * w = 0 := by
+    rw [htl]
+    change (q.shift (-w)).equation + q.p ^ 3 * w = 0
+    rw [Point.shift_equation, hq]
+    ring
+  have hL : t.L z = l := by
+    have hc := t.e_certificate l w
+    rw [heq, mul_zero] at hc
+    change t.root + t.p ^ 3 * t.e l w = l
+    linear_combination hc
+  have hW : t.W z = w := by
+    have h := t.coordinate_equation z
+    rw [hL] at h
+    apply sub_eq_zero.mp
+    apply hp
+    rw [← hpt, mul_sub]
+    linear_combination h - heq
+  change (((t.point (t.L z)).shift (t.W z)), t.W z) = (q, w)
+  rw [hL, hW, htl]
+  congr 1
+  change (q.shift (-w)).shift w = q
+  rw [Point.shift_add, neg_add_cancel, Point.shift_zero]
+
+namespace Point
+
+def map (q : Point R) (g : R →+* S) : Point S :=
+  ⟨g q.p, g q.s, g q.u, g q.f, g q.j⟩
+
+@[simp] lemma map_x (q : Point R) (g : R →+* S) : (q.map g).x = g q.x := by
+  simp [map, x]
+
+@[simp] lemma map_equation (q : Point R) (g : R →+* S) :
+    (q.map g).equation = g q.equation := by
+  simp [equation, map, x, map_ofNat]
+
+@[simp] lemma map_shift (q : Point R) (w : R) (g : R →+* S) :
+    (q.shift w).map g = (q.map g).shift (g w) := by
+  ext <;> simp [map, shift, cubicDiff, x, map_ofNat]
+
+end Point
+namespace Frame
+
+def map (t : Frame R) (g : R →+* S) : Frame S := ⟨g t.p, g t.s, g t.u, g t.m⟩
+
+@[simp] lemma map_point (t : Frame R) (l : R) (g : R →+* S) :
+    (t.point l).map g = (t.map g).point (g l) := by
+  ext <;> simp [Point.map, map, point, f, j, f₁, f₀, j₁, j₀, x₀, map_ofNat]
+
+@[simp] lemma map_L (t : Frame R) (z : R) (g : R →+* S) :
+    g (t.L z) = (t.map g).L (g z) := by
+  simp [map, L, root, c, Q, f, j, f₁, f₀, j₁, j₀, x₀, map_ofNat]
+
+@[simp] lemma map_W (t : Frame R) (z : R) (g : R →+* S) :
+    g (t.W z) = (t.map g).W (g z) := by
+  simp [W, map_L, map, c, Q, Q₁, q₁, q₂, f, j, f₁, f₀, j₁, j₀, x₀, map_ofNat]
+
+end Frame
+
+lemma decode_map (t : Frame R) (z : R) (g : R →+* S) :
+    ((decode t z).1.map g, g (decode t z).2) = decode (t.map g) (g z) := by
+  simp [decode]
+
+lemma encode_map (q : Point R) (w : R) (g : R →+* S) :
+    ((encode q w).1.map g, g (encode q w).2) = encode (q.map g) (g w) := by
+  simp only [encode, ← Point.map_shift, ← map_neg]
+  apply Prod.ext
+  · ext <;> simp [Point.frame, Frame.map, Point.map, map_ofNat]
+  · simp [Frame.e, Frame.h, Frame.Q₁, Frame.q₁, Frame.q₂, Frame.Q, Frame.f, Frame.j,
+      Frame.f₀, Frame.f₁, Frame.j₀, Frame.j₁, Frame.x₀, Point.linear, Point.frame, Point.map, map_ofNat]
+
+end ComplexCancellation.Cylinder
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/AffineCancellation/CylinderShift.lean b/lean/OAI/Algebra/AffineCancellation/CylinderShift.lean
new file mode 100644
index 0000000000000000000000000000000000000000..5c7f6c0ef271d4bf85ed92dcbc15f8dda0bc6e35
--- /dev/null
+++ b/lean/OAI/Algebra/AffineCancellation/CylinderShift.lean
@@ -0,0 +1,236 @@
+import OAI.Algebra.AffineCancellation.Model
+
+namespace OAI
+
+noncomputable section
+
+/-! Polynomial stabilization without division by the distinguished coordinate. -/
+namespace ComplexCancellation.Cylinder
+
+variable {R : Type*} [CommRing R]
+
+@[ext] structure Point (R : Type*) where
+  p : R
+  s : R
+  u : R
+  f : R
+  j : R
+
+namespace Point
+
+def x (q : Point R) : R := q.s ^ 2 + q.u ^ 3 + q.p ^ 2 * q.f
+def equation (q : Point R) : R :=
+  q.x ^ 2 * q.f - (1 + 2 * q.s * q.x) * q.j - q.p ^ 2 * q.j ^ 2 - q.p * q.u
+
+def cubicDiff (p u w : R) : R := -3 * u ^ 2 * w + 3 * u * p ^ 2 * w ^ 2 - p ^ 4 * w ^ 3
+
+lemma cubicDiff_spec (p u w : R) :
+    (u - p ^ 2 * w) ^ 3 = u ^ 3 + p ^ 2 * cubicDiff p u w := by
+  unfold cubicDiff
+  ring
+
+lemma cubicDiff_add (p u w z : R) :
+    cubicDiff p u w + cubicDiff p (u - p ^ 2 * w) z = cubicDiff p u (w + z) := by
+  unfold cubicDiff
+  ring
+
+/-- A finite exponential shift fixing `p`, `x`, `y`, `z` and translating `u` by `-p²w`. -/
+def shift (q : Point R) (w : R) : Point R :=
+  let k := cubicDiff q.p q.u w
+  ⟨q.p, q.s + q.p ^ 2 * q.x * k, q.u - q.p ^ 2 * w,
+    q.f - (2 * q.s * q.x + 1) * k - q.p ^ 2 * q.x ^ 2 * k ^ 2,
+    q.j - q.x ^ 2 * k⟩
+
+@[simp] lemma shift_p (q : Point R) (w : R) : (q.shift w).p = q.p := rfl
+@[simp] lemma shift_u (q : Point R) (w : R) : (q.shift w).u = q.u - q.p ^ 2 * w := rfl
+
+@[simp] lemma shift_x (q : Point R) (w : R) : (q.shift w).x = q.x := by
+  change (q.s + q.p ^ 2 * q.x * cubicDiff q.p q.u w) ^ 2 +
+    (q.u - q.p ^ 2 * w) ^ 3 + q.p ^ 2 *
+    (q.f - (2 * q.s * q.x + 1) * cubicDiff q.p q.u w -
+      q.p ^ 2 * q.x ^ 2 * cubicDiff q.p q.u w ^ 2) = q.x
+  rw [cubicDiff_spec]
+  calc
+    _ = q.s ^ 2 + q.u ^ 3 + q.p ^ 2 * q.f := by ring
+    _ = q.x := rfl
+
+@[simp] lemma shift_zero (q : Point R) : q.shift 0 = q := by
+  cases q
+  simp [shift, cubicDiff]
+
+lemma shift_add (q : Point R) (w z : R) : (q.shift w).shift z = q.shift (w + z) := by
+  have hk := cubicDiff_add q.p q.u w z
+  have hx := shift_x q w
+  apply Point.ext
+  · rfl
+  · change (q.s + q.p ^ 2 * q.x * cubicDiff q.p q.u w) +
+      q.p ^ 2 * (q.shift w).x * cubicDiff q.p (q.u - q.p ^ 2 * w) z = _
+    rw [hx]
+    change _ = q.s + q.p ^ 2 * q.x * cubicDiff q.p q.u (w + z)
+    rw [← hk]
+    ring
+  · change q.u - q.p ^ 2 * w - q.p ^ 2 * z = q.u - q.p ^ 2 * (w + z)
+    ring
+  · change q.f - (2 * q.s * q.x + 1) * cubicDiff q.p q.u w -
+      q.p ^ 2 * q.x ^ 2 * cubicDiff q.p q.u w ^ 2 -
+      (2 * (q.s + q.p ^ 2 * q.x * cubicDiff q.p q.u w) * (q.shift w).x + 1) *
+        cubicDiff q.p (q.u - q.p ^ 2 * w) z -
+      q.p ^ 2 * (q.shift w).x ^ 2 * cubicDiff q.p (q.u - q.p ^ 2 * w) z ^ 2 = _
+    rw [hx]
+    change _ = q.f - (2 * q.s * q.x + 1) * cubicDiff q.p q.u (w + z) -
+      q.p ^ 2 * q.x ^ 2 * cubicDiff q.p q.u (w + z) ^ 2
+    rw [← hk]
+    ring
+  · change q.j - q.x ^ 2 * cubicDiff q.p q.u w -
+      (q.shift w).x ^ 2 * cubicDiff q.p (q.u - q.p ^ 2 * w) z = _
+    rw [hx]
+    change _ = q.j - q.x ^ 2 * cubicDiff q.p q.u (w + z)
+    rw [← hk]
+    ring
+
+lemma shift_equation (q : Point R) (w : R) :
+    (q.shift w).equation = q.equation + q.p ^ 3 * w := by
+  unfold equation
+  rw [shift_x]
+  change q.x ^ 2 * (q.f - (2 * q.s * q.x + 1) * cubicDiff q.p q.u w -
+      q.p ^ 2 * q.x ^ 2 * cubicDiff q.p q.u w ^ 2) -
+    (1 + 2 * (q.s + q.p ^ 2 * q.x * cubicDiff q.p q.u w) * q.x) *
+      (q.j - q.x ^ 2 * cubicDiff q.p q.u w) -
+    q.p ^ 2 * (q.j - q.x ^ 2 * cubicDiff q.p q.u w) ^ 2 -
+    q.p * (q.u - q.p ^ 2 * w) = _
+  ring
+
+@[simp] lemma shift_neg_shift (q : Point R) (w : R) : (q.shift w).shift (-w) = q := by
+  rw [shift_add, add_neg_cancel, shift_zero]
+
+end Point
+end ComplexCancellation.Cylinder
+
+namespace ComplexCancellation.Cylinder
+variable {R : Type*} [CommRing R]
+
+@[ext] structure Frame (R : Type*) where
+  p : R
+  s : R
+  u : R
+  m : R
+
+namespace Frame
+
+def x₀ (t : Frame R) : R := t.s ^ 2 + t.u ^ 3
+def f₁ (t : Frame R) : R := 4 * t.s ^ 2
+def f₀ (t : Frame R) : R := (1 + 2 * t.s * t.x₀) * t.m
+def j₁ (t : Frame R) : R := 2 * t.s * t.x₀ - 1
+def j₀ (t : Frame R) : R := t.x₀ ^ 2 * t.m
+def f (t : Frame R) (l : R) : R := t.f₁ * l + t.f₀
+def j (t : Frame R) (l : R) : R := t.j₁ * l + t.j₀
+def point (t : Frame R) (l : R) : Point R := ⟨t.p, t.s, t.u, t.f l, t.j l⟩
+def Q (t : Frame R) (l : R) : R :=
+  2 * t.x₀ * t.f l ^ 2 - 2 * t.s * t.f l * t.j l - t.j l ^ 2
+def c (t : Frame R) : R := t.Q 0
+def q₁ (t : Frame R) : R :=
+  4 * t.x₀ * t.f₁ * t.f₀ - 2 * t.s * (t.f₁ * t.j₀ + t.f₀ * t.j₁) - 2 * t.j₁ * t.j₀
+def q₂ (t : Frame R) : R :=
+  2 * t.x₀ * t.f₁ ^ 2 - 2 * t.s * t.f₁ * t.j₁ - t.j₁ ^ 2
+def Q₁ (t : Frame R) (l : R) : R := t.q₁ + t.q₂ * l
+
+lemma Q_expand (t : Frame R) (l : R) : t.Q l = t.c + l * t.Q₁ l := by
+  simp only [Q, c, Q₁, q₁, q₂, f, j]
+  ring
+
+lemma equation_point (t : Frame R) (l : R) :
+    (t.point l).equation = l - t.p * t.u + t.p ^ 2 * t.Q l + t.p ^ 4 * t.f l ^ 3 := by
+  have hl : t.x₀ ^ 2 * t.f l - (1 + 2 * t.s * t.x₀) * t.j l = l := by
+    unfold f j f₁ f₀ j₁ j₀
+    ring
+  change (t.s ^ 2 + t.u ^ 3 + t.p ^ 2 * t.f l) ^ 2 * t.f l -
+    (1 + 2 * t.s * (t.s ^ 2 + t.u ^ 3 + t.p ^ 2 * t.f l)) * t.j l -
+    t.p ^ 2 * t.j l ^ 2 - t.p * t.u = _
+  change (t.x₀ + t.p ^ 2 * t.f l) ^ 2 * t.f l -
+    (1 + 2 * t.s * (t.x₀ + t.p ^ 2 * t.f l)) * t.j l -
+    t.p ^ 2 * t.j l ^ 2 - t.p * t.u = _
+  unfold Q
+  linear_combination hl
+
+def root (t : Frame R) : R := t.p * t.u - t.p ^ 2 * t.c
+def h (t : Frame R) (l w : R) : R :=
+  t.u - t.p * t.Q l - t.p ^ 3 * t.f l ^ 3 - t.p ^ 2 * w
+def e (t : Frame R) (l w : R) : R := -w - t.p * t.f l ^ 3 - t.Q₁ l * t.h l w
+
+def L (t : Frame R) (z : R) : R := t.root + t.p ^ 3 * z
+def W (t : Frame R) (z : R) : R :=
+  -z - (t.u - t.p * t.c + t.p ^ 2 * z) * t.Q₁ (t.L z) - t.p * t.f (t.L z) ^ 3
+
+lemma e_certificate (t : Frame R) (l w : R) :
+    t.p ^ 3 * t.e l w - (l - t.root) =
+    (t.p ^ 2 * t.Q₁ l - 1) * ((t.point l).equation + t.p ^ 3 * w) := by
+  rw [equation_point]
+  unfold e h root
+  rw [Q_expand]
+  ring
+
+lemma coordinate_equation (t : Frame R) (z : R) :
+    (t.point (t.L z)).equation + t.p ^ 3 * t.W z = 0 := by
+  rw [equation_point, Q_expand]
+  unfold W L root
+  ring
+
+lemma h_coordinates (t : Frame R) (z : R) :
+    t.h (t.L z) (t.W z) = t.u - t.p * t.c + t.p ^ 2 * z := by
+  unfold h W
+  rw [Q_expand]
+  unfold L root
+  ring
+
+lemma e_coordinates (t : Frame R) (z : R) : t.e (t.L z) (t.W z) = z := by
+  unfold e
+  rw [h_coordinates]
+  unfold W
+  ring
+
+end Frame
+
+namespace Point
+
+def frame (q : Point R) : Frame R :=
+  ⟨q.p, q.s, q.u, (1 - 2 * q.s * (q.s ^ 2 + q.u ^ 3)) * q.f + 4 * q.s ^ 2 * q.j⟩
+def linear (q : Point R) : R :=
+  (q.s ^ 2 + q.u ^ 3) ^ 2 * q.f - (1 + 2 * q.s * (q.s ^ 2 + q.u ^ 3)) * q.j
+
+lemma point_frame (q : Point R) : q.frame.point q.linear = q := by
+  apply Point.ext
+  · rfl
+  · rfl
+  · rfl
+  · change 4 * q.s ^ 2 * q.linear +
+      (1 + 2 * q.s * (q.s ^ 2 + q.u ^ 3)) * q.frame.m = q.f
+    unfold linear frame
+    ring
+  · change (2 * q.s * (q.s ^ 2 + q.u ^ 3) - 1) * q.linear +
+      (q.s ^ 2 + q.u ^ 3) ^ 2 * q.frame.m = q.j
+    unfold linear frame
+    ring
+
+end Point
+namespace Frame
+
+@[simp] lemma frame_point (t : Frame R) (l : R) : (t.point l).frame = t := by
+  apply Frame.ext
+  · rfl
+  · rfl
+  · rfl
+  · change (1 - 2 * t.s * t.x₀) * t.f l + 4 * t.s ^ 2 * t.j l = t.m
+    unfold f j f₁ f₀ j₁ j₀
+    ring
+
+@[simp] lemma linear_point (t : Frame R) (l : R) : (t.point l).linear = l := by
+  change t.x₀ ^ 2 * t.f l - (1 + 2 * t.s * t.x₀) * t.j l = l
+  unfold f j f₁ f₀ j₁ j₀
+  ring
+
+end Frame
+end ComplexCancellation.Cylinder
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/AffineCancellation/Degeneration.lean b/lean/OAI/Algebra/AffineCancellation/Degeneration.lean
new file mode 100644
index 0000000000000000000000000000000000000000..1cd33e5703bd0fb8835834b3c7e34b0977b9c172
--- /dev/null
+++ b/lean/OAI/Algebra/AffineCancellation/Degeneration.lean
@@ -0,0 +1,166 @@
+import OAI.Algebra.AffineCancellation.Quadric
+
+namespace OAI
+
+noncomputable section
+
+namespace ComplexCancellation.Degeneration
+open MvPolynomial
+abbrev P := MvPolynomial (Fin 5) ℂ
+def xp : P := X 1^2+X 2^3+X 0^2*X 3
+def yp : P := X 1+xp*(xp-X 2^3)
+def zp : P := X 1*xp+X 0^2*X 4
+def relation : P := xp^2*X 3-(1+2*X 1*xp)*X 4-X 0^2*X 4^2
+lemma identity : xp*yp-zp*(zp+1)=X 0^2*relation := by
+  simp only [yp,zp,relation,xp]
+  ring
+abbrev G := P ⧸ Ideal.span {relation}
+def π : P →ₐ[ℂ] G := Ideal.Quotient.mkₐ ℂ _
+def p : G := π (X 0)
+def s : G := π (X 1)
+def u : G := π (X 2)
+def F : G := π (X 3)
+def J : G := π (X 4)
+def x : G := π xp
+def y : G := π yp
+def z : G := π zp
+lemma relation_zero : π relation = 0 := Ideal.Quotient.eq_zero_iff_mem.mpr (Ideal.subset_span (by simp))
+lemma equation : x*y=z*(z+1) := by
+  apply sub_eq_zero.mp
+  have h := congrArg π identity
+  simpa only [map_sub,map_mul,map_add,map_one,map_pow,relation_zero,mul_zero,x,y,z] using h
+
+def coeffEval : Quadric.Poly →ₐ[ℂ] G := aeval ![x,y,z,u]
+lemma coeffEval_relation : coeffEval Quadric.relation = 0 := by
+  simpa [coeffEval,Quadric.relation,Matrix.cons_val] using sub_eq_zero.mpr equation
+def coefficientMap : Quadric.R →ₐ[ℂ] G := Ideal.Quotient.liftₐ _ coeffEval (by
+  intro r hr
+  obtain ⟨q,rfl⟩ := Ideal.mem_span_singleton.mp hr
+  rw [map_mul,coeffEval_relation,zero_mul])
+@[simp] lemma coefficientMap_π (r : Quadric.Poly) : coefficientMap (Quadric.π r) = coeffEval r :=
+  Ideal.Quotient.lift_mk _ _ _
+@[simp] lemma coefficientMap_x : coefficientMap Quadric.x=x := by simp [Quadric.x,coeffEval]
+@[simp] lemma coefficientMap_y : coefficientMap Quadric.y=y := by simp [Quadric.y,coeffEval]
+@[simp] lemma coefficientMap_z : coefficientMap Quadric.z=z := by simp [Quadric.z,coeffEval,Matrix.cons_val]
+@[simp] lemma coefficientMap_u : coefficientMap Quadric.u=u := by simp [Quadric.u,coeffEval,Matrix.cons_val]
+@[simp] lemma coefficientMap_s : coefficientMap Quadric.s=s := by
+  simp only [Quadric.s,map_sub,map_mul,map_pow,coefficientMap_x,coefficientMap_y,coefficientMap_u]
+  simp only [x,y,s,u,yp,map_add,map_mul,map_sub,map_pow]
+  ring
+lemma coefficientMap_f : coefficientMap Quadric.f=p^2*F := by
+  simp only [Quadric.f,map_sub,map_pow,coefficientMap_x,coefficientMap_s,coefficientMap_u]
+  simp only [x,xp,map_add,map_mul,map_pow,s,u,p,F]
+  ring
+lemma coefficientMap_g : coefficientMap Quadric.g=p^2*J := by
+  simp only [Quadric.g,map_sub,map_mul,coefficientMap_z,coefficientMap_s,coefficientMap_x]
+  simp only [z,zp,map_add,map_mul,map_pow,s,p,J,x]
+  ring
+
+abbrev K₀ := FractionRing Quadric.R
+abbrev K := RatFunc K₀
+def ι : Quadric.R →ₐ[ℂ] K := IsScalarTower.toAlgHom ℂ Quadric.R K
+lemma ι_injective : Function.Injective ι :=
+  (RatFunc.C_injective).comp (IsFractionRing.injective Quadric.R K₀)
+lemma τ_ne_zero : (RatFunc.X : K) ≠ 0 := RatFunc.X_ne_zero
+def values : Fin 5 → K := ![RatFunc.X,ι Quadric.s,ι Quadric.u,
+  ι Quadric.f/RatFunc.X^2,ι Quadric.g/RatFunc.X^2]
+def eval : P →ₐ[ℂ] K := aeval values
+lemma eval_xp : eval xp=ι Quadric.x := by
+  simp only [xp,eval,map_add,map_mul,map_pow,aeval_X,values,
+    Matrix.cons_val_zero,Matrix.cons_val_one,Matrix.cons_val]
+  field_simp [τ_ne_zero]
+  simp only [Quadric.f,map_sub,map_pow]
+  ring
+lemma eval_yp : eval yp=ι Quadric.y := by
+  simp only [yp,map_add,map_mul,map_sub,map_pow,eval_xp]
+  simp only [eval,aeval_X,values,Matrix.cons_val_zero,Matrix.cons_val_one,Matrix.cons_val]
+  simp only [Quadric.s,map_sub,map_mul,map_pow]
+  ring
+lemma eval_zp : eval zp=ι Quadric.z := by
+  simp only [zp,map_add,map_mul,map_pow,eval_xp]
+  simp only [eval,aeval_X,values,Matrix.cons_val_zero,Matrix.cons_val_one,Matrix.cons_val]
+  field_simp [τ_ne_zero]
+  simp only [Quadric.g,map_sub,map_mul]
+  ring
+lemma eval_relation : eval relation=0 := by
+  have h := congrArg eval identity
+  simp only [map_sub,map_mul,map_add,map_one,map_pow,eval_xp,eval_yp,eval_zp] at h
+  have he : ι Quadric.x*ι Quadric.y-ι Quadric.z*(ι Quadric.z+1)=0 := by
+    simpa only [map_mul,map_add,map_one] using congrArg ι Quadric.equation |> sub_eq_zero.mpr
+  rw [he] at h
+  have hp : eval (X 0) ≠ 0 := by simpa [eval,values] using τ_ne_zero
+  exact (mul_eq_zero.mp h.symm).resolve_left (pow_ne_zero 2 hp)
+
+def embedding : G →ₐ[ℂ] K := Ideal.Quotient.liftₐ _ eval (by
+  intro r hr
+  obtain ⟨q,rfl⟩ := Ideal.mem_span_singleton.mp hr
+  rw [map_mul,eval_relation,zero_mul])
+@[simp] lemma embedding_π (r : P) : embedding (π r)=eval r := Ideal.Quotient.lift_mk _ _ _
+lemma embedding_coefficientMap : embedding.comp coefficientMap=ι := by
+  apply Ideal.Quotient.algHom_ext
+  apply MvPolynomial.algHom_ext
+  intro i
+  fin_cases i
+  · change embedding (coefficientMap Quadric.x)=ι Quadric.x
+    rw [coefficientMap_x,x,embedding_π,eval_xp]
+  · change embedding (coefficientMap Quadric.y)=ι Quadric.y
+    rw [coefficientMap_y,y,embedding_π,eval_yp]
+  · change embedding (coefficientMap Quadric.z)=ι Quadric.z
+    rw [coefficientMap_z,z,embedding_π,eval_zp]
+  · change embedding (coefficientMap Quadric.u)=ι Quadric.u
+    rw [coefficientMap_u,u,embedding_π]
+    simp [eval,values,Matrix.cons_val]
+lemma coefficientMap_injective : Function.Injective coefficientMap := by
+  apply Function.Injective.of_comp (f := embedding)
+  rw [← AlgHom.coe_comp,embedding_coefficientMap]
+  exact ι_injective
+lemma p_regular : IsLeftRegular p := by
+  apply Determinant.regular_quotient_of_prime (MvPolynomial.X_prime (i := 0))
+  intro h
+  have he := map_dvd (MvPolynomial.eval (fun i : Fin 5 => if i=4 then (1:ℂ) else 0)) h
+  norm_num [relation,xp,Fin.ext_iff] at he
+
+def baseMap : Polynomial Quadric.R →ₐ[ℂ] G :=
+  Polynomial.eval₂AlgHom coefficientMap p (fun _ => Commute.all _ _)
+lemma baseMap_X : baseMap Polynomial.X=p := by simp [baseMap]
+lemma baseMap_C (r : Quadric.R) : baseMap (Polynomial.C r)=coefficientMap r := by simp [baseMap]
+def baseEmbedding : Polynomial Quadric.R →ₐ[ℂ] K :=
+  (IsScalarTower.toAlgHom ℂ (Polynomial K₀) K).comp
+    (Polynomial.mapAlgHom (IsScalarTower.toAlgHom ℂ Quadric.R K₀))
+lemma baseEmbedding_injective : Function.Injective baseEmbedding :=
+  (RatFunc.algebraMap_injective K₀).comp
+    (Polynomial.map_injective _ (IsFractionRing.injective Quadric.R K₀))
+lemma embedding_baseMap : embedding.comp baseMap=baseEmbedding := by
+  apply Polynomial.algHom_ext'
+  · ext r
+    change embedding (baseMap (Polynomial.C r))=baseEmbedding (Polynomial.C r)
+    rw [baseMap_C]
+    have h := DFunLike.congr_fun embedding_coefficientMap r
+    simpa [baseEmbedding,ι,IsScalarTower.algebraMap_apply Quadric.R K₀ K,
+      RatFunc.algebraMap_eq_C] using h
+  · change embedding (baseMap Polynomial.X)=baseEmbedding Polynomial.X
+    rw [baseMap_X]
+    change eval (X 0)=algebraMap (Polynomial K₀) K (Polynomial.map (algebraMap Quadric.R K₀) Polynomial.X)
+    rw [Polynomial.map_X,RatFunc.algebraMap_X]
+    simp [eval,values]
+lemma clears : Clearing.subalgebra (S := Polynomial Quadric.R) baseMap Polynomial.X=⊤ := by
+  apply Clearing.top_of_generators π (Ideal.Quotient.mkₐ_surjective ℂ _) _ _
+  intro i
+  fin_cases i
+  · exact ⟨0,Polynomial.X,by simp [baseMap_X,p]⟩
+  · exact ⟨0,Polynomial.C Quadric.s,by simp [baseMap_C,s]⟩
+  · exact ⟨0,Polynomial.C Quadric.u,by simp [baseMap_C,u]⟩
+  · exact ⟨2,Polynomial.C Quadric.f,by rw [baseMap_X,baseMap_C,coefficientMap_f]; rfl⟩
+  · exact ⟨2,Polynomial.C Quadric.g,by rw [baseMap_X,baseMap_C,coefficientMap_g]; rfl⟩
+lemma embedding_injective : Function.Injective embedding := by
+  apply Clearing.injective_of_clearing (S := Polynomial Quadric.R) embedding baseMap Polynomial.X
+  · rw [embedding_baseMap]; exact baseEmbedding_injective
+  · rw [baseMap_X]; exact p_regular
+  · exact clears
+instance : IsDomain G := Function.Injective.isDomain embedding embedding_injective
+
+end ComplexCancellation.Degeneration
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/AffineCancellation/DegenerationGrading.lean b/lean/OAI/Algebra/AffineCancellation/DegenerationGrading.lean
new file mode 100644
index 0000000000000000000000000000000000000000..a915a81ebd5fe4ff9531b7f3d69440303c65f461
--- /dev/null
+++ b/lean/OAI/Algebra/AffineCancellation/DegenerationGrading.lean
@@ -0,0 +1,53 @@
+import OAI.Algebra.AffineCancellation.Degeneration
+
+namespace OAI
+
+noncomputable section
+
+namespace ComplexCancellation.Degeneration
+open MvPolynomial
+attribute [local instance] MvPolynomial.weightedGradedAlgebra
+def weight (i : Fin 5) : ℤ := if i=0 then -1 else if i=1 ∨ i=2 then 0 else 2
+def sourcePieces (e : ℤ) := weightedHomogeneousSubmodule ℂ weight e
+instance sourceGrading : GradedAlgebra sourcePieces := inferInstanceAs (GradedAlgebra (weightedHomogeneousSubmodule ℂ weight))
+lemma xp_homogeneous : IsWeightedHomogeneous weight xp 0 := by
+  have h₁ : IsWeightedHomogeneous weight ((X 1 : P)^2) 0 := by
+    convert (isWeightedHomogeneous_X ℂ weight 1).pow 2 using 1; try simp only [map_ofNat]
+    all_goals norm_num [weight,Fin.ext_iff]
+  have h₂ : IsWeightedHomogeneous weight ((X 2 : P)^3) 0 := by
+    convert (isWeightedHomogeneous_X ℂ weight 2).pow 3 using 1; try simp only [map_ofNat]
+    all_goals norm_num [weight,Fin.ext_iff]
+  have h₃ : IsWeightedHomogeneous weight ((X 0 : P)^2*X 3) 0 := by
+    convert ((isWeightedHomogeneous_X ℂ weight 0).pow 2).mul (isWeightedHomogeneous_X ℂ weight 3) using 1; try simp only [map_ofNat]
+    all_goals norm_num [weight,Fin.ext_iff]
+  exact (h₁.add h₂).add h₃
+lemma relation_homogeneous : relation ∈ sourcePieces 2 := by
+  have h₁ : IsWeightedHomogeneous weight (xp^2*X 3) 2 := by
+    convert (xp_homogeneous.pow 2).mul (isWeightedHomogeneous_X ℂ weight 3) using 1; try simp only [map_ofNat]
+    all_goals norm_num [weight,Fin.ext_iff]
+  have h₂ : IsWeightedHomogeneous weight (1+2*X 1*xp : P) 0 := by
+    apply (isWeightedHomogeneous_one ℂ weight).add
+    convert ((isWeightedHomogeneous_C weight (2:ℂ)).mul (isWeightedHomogeneous_X ℂ weight 1)).mul xp_homogeneous using 1 <;> try simp only [map_ofNat]
+    all_goals norm_num [weight,Fin.ext_iff]
+  have h₃ : IsWeightedHomogeneous weight ((1+2*X 1*xp)*X 4 : P) 2 := by
+    convert h₂.mul (isWeightedHomogeneous_X ℂ weight 4) using 1; try simp only [map_ofNat]
+    all_goals norm_num [weight,Fin.ext_iff]
+  have h₄ : IsWeightedHomogeneous weight (X 0^2*X 4^2 : P) 2 := by
+    convert ((isWeightedHomogeneous_X ℂ weight 0).pow 2).mul ((isWeightedHomogeneous_X ℂ weight 4).pow 2) using 1; try simp only [map_ofNat]
+    all_goals norm_num [weight,Fin.ext_iff]
+  exact (h₁.sub h₃).sub h₄
+lemma kernel_homogeneous : (RingHom.ker π).IsHomogeneous sourcePieces := by
+  change (RingHom.ker (Ideal.Quotient.mk (Ideal.span {relation}))).IsHomogeneous _
+  rw [Ideal.mk_ker]
+  apply Ideal.homogeneous_span
+  intro r hr
+  obtain rfl := Set.mem_singleton_iff.mp hr
+  exact ⟨2,relation_homogeneous⟩
+def pieces : ℤ → Submodule ℂ G := QuotientGrading.pieces sourcePieces π
+instance grading : GradedAlgebra pieces := QuotientGrading.grading _ _ (Ideal.Quotient.mkₐ_surjective ℂ _) kernel_homogeneous
+lemma X_mem (i : Fin 5) : π (X i) ∈ pieces (weight i) := ⟨X i,isWeightedHomogeneous_X ℂ weight i,rfl⟩
+end ComplexCancellation.Degeneration
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/AffineCancellation/Determinant.lean b/lean/OAI/Algebra/AffineCancellation/Determinant.lean
new file mode 100644
index 0000000000000000000000000000000000000000..67b2eabc658fa0248a86735b2238783910c2ec51
--- /dev/null
+++ b/lean/OAI/Algebra/AffineCancellation/Determinant.lean
@@ -0,0 +1,162 @@
+import OAI.Algebra.AffineCancellation.Model
+
+namespace OAI
+
+noncomputable section
+
+namespace ComplexCancellation.Determinant
+open MvPolynomial
+
+lemma regular_quotient_of_prime {R : Type*} [CommRing R] [IsDomain R]
+    {p h : R} (hp : Prime p) (hph : ¬p ∣ h) :
+    IsLeftRegular (Ideal.Quotient.mk (Ideal.span {h}) p) := by
+  apply isLeftRegular_iff_right_eq_zero_of_mul.mpr
+  intro q hq
+  obtain ⟨r, rfl⟩ := Ideal.Quotient.mk_surjective q
+  rw [← map_mul, Ideal.Quotient.eq_zero_iff_mem, Ideal.mem_span_singleton] at hq
+  obtain ⟨c, hc⟩ := hq
+  have hpc : p ∣ c := (hp.dvd_or_dvd (show p ∣ h * c by rw [← hc]; exact dvd_mul_right _ _)).resolve_left hph
+  obtain ⟨d, rfl⟩ := hpc
+  have hr : r = h * d := by
+    apply mul_left_cancel₀ hp.ne_zero
+    linear_combination hc
+  rw [Ideal.Quotient.eq_zero_iff_mem, Ideal.mem_span_singleton, hr]
+  exact dvd_mul_right _ _
+
+abbrev Poly := MvPolynomial (Fin 5) ℂ
+abbrev Base := MvPolynomial (Fin 4) ℂ
+abbrev Coeff := MvPolynomial (Fin 3) ℂ
+abbrev K₀ := FractionRing Coeff
+abbrev K := RatFunc K₀
+
+def relation : Poly := X 0 * X 3 - X 2 * X 1 - 1
+abbrev T := Poly ⧸ Ideal.span {relation}
+def π : Poly →ₐ[ℂ] T := Ideal.Quotient.mkₐ ℂ _
+def a : T := π (X 0)
+def d : T := π (X 1)
+def b : T := π (X 2)
+def c : T := π (X 3)
+def u : T := π (X 4)
+def v : T := a ^ 3 * b - a ^ 2 * u ^ 3 - d ^ 2
+
+def baseEmbedding : Base →ₐ[ℂ] K :=
+  (IsScalarTower.toAlgHom ℂ (Polynomial K₀) K).comp
+    ((Polynomial.mapAlgHom (IsScalarTower.toAlgHom ℂ Coeff K₀)).comp
+      (finSuccEquiv ℂ 3).toAlgHom)
+
+lemma baseEmbedding_injective : Function.Injective baseEmbedding :=
+  (RatFunc.algebraMap_injective K₀).comp
+    ((Polynomial.map_injective _ (IsFractionRing.injective Coeff K₀)).comp
+      (finSuccEquiv ℂ 3).injective)
+
+lemma baseEmbedding_X_zero : baseEmbedding (X 0) = RatFunc.X := by
+  change algebraMap (Polynomial K₀) K
+    (Polynomial.map (algebraMap Coeff K₀) ((finSuccEquiv ℂ 3) (X 0))) = _
+  rw [finSuccEquiv_X_zero, Polynomial.map_X, RatFunc.algebraMap_X]
+
+lemma baseEmbedding_X_succ (i : Fin 3) :
+    baseEmbedding (X i.succ) = RatFunc.C (algebraMap Coeff K₀ (X i)) := by
+  change algebraMap (Polynomial K₀) K
+    (Polynomial.map (algebraMap Coeff K₀) ((finSuccEquiv ℂ 3) (X i.succ))) = _
+  rw [finSuccEquiv_X_succ, Polynomial.map_C, RatFunc.algebraMap_C]
+
+def targetValues : Fin 5 → K := ![baseEmbedding (X 1), baseEmbedding (X 2),
+  baseEmbedding (X 3), (1 + baseEmbedding (X 3) * baseEmbedding (X 2)) /
+    baseEmbedding (X 1), baseEmbedding (X 0)]
+
+def eval : Poly →ₐ[ℂ] K := aeval targetValues
+
+lemma a_field_nonzero : baseEmbedding (X 1) ≠ 0 := by
+  intro h
+  have hz := baseEmbedding_injective (h.trans (map_zero _).symm)
+  exact X_ne_zero (1 : Fin 4) hz
+
+lemma eval_relation : eval relation = 0 := by
+  simp only [eval, relation, map_sub, map_mul, map_one, aeval_X]
+  simp only [targetValues, Matrix.cons_val_zero, Matrix.cons_val_one,
+    Matrix.cons_val]
+  field_simp [a_field_nonzero]
+  ring
+
+def embedding : T →ₐ[ℂ] K := Ideal.Quotient.liftₐ _ eval (by
+  intro r hr
+  obtain ⟨s, rfl⟩ := Ideal.mem_span_singleton.mp hr
+  rw [map_mul, eval_relation, zero_mul])
+
+@[simp] lemma embedding_π (r : Poly) : embedding (π r) = eval r :=
+  Ideal.Quotient.lift_mk _ _ _
+
+lemma determinant : a*c - b*d = 1 := by
+  have h : π relation = 0 := Ideal.Quotient.eq_zero_iff_mem.mpr (Ideal.subset_span (by simp))
+  simpa only [relation, map_sub, map_mul, map_one, a, b, c, d, sub_eq_zero] using h
+
+lemma a_regular : IsLeftRegular a := by
+  apply regular_quotient_of_prime (MvPolynomial.X_prime (i := 0))
+  intro h
+  have he := map_dvd (MvPolynomial.eval (fun _ : Fin 5 => (0 : ℂ))) h
+  simp [relation] at he
+
+def baseValues : Fin 4 → T := ![u,a,d,b]
+def baseMap : Base →ₐ[ℂ] T := aeval baseValues
+
+lemma embedding_baseMap (r : Base) : embedding (baseMap r) = baseEmbedding r := by
+  have he : embedding.comp baseMap = baseEmbedding := by
+    apply MvPolynomial.algHom_ext
+    intro i
+    fin_cases i <;> simp [baseMap, baseValues, u, a, d, b, embedding_π, eval, targetValues]
+  exact DFunLike.congr_fun he r
+
+lemma baseMap_injective : Function.Injective baseMap := by
+  intro r s hrs
+  apply baseEmbedding_injective
+  rw [← embedding_baseMap, ← embedding_baseMap, hrs]
+
+lemma clears_generator (i : Fin 5) :
+    ∃ n : ℕ, ∃ f : Base, a^n * π (X i) = baseMap f := by
+  fin_cases i
+  · exact ⟨0, X 1, by simp [baseMap, baseValues, a]⟩
+  · exact ⟨0, X 2, by simp [baseMap, baseValues, d]⟩
+  · exact ⟨0, X 3, by simp [baseMap, baseValues, b]⟩
+  · refine ⟨1, 1 + X 3 * X 2, ?_⟩
+    simp only [pow_one, map_add, map_one, map_mul, baseMap, aeval_X]
+    change a*c = 1+b*d
+    linear_combination determinant
+  · exact ⟨0, X 0, by simp [baseMap, baseValues, u]⟩
+
+lemma clears (r : T) : ∃ n : ℕ, ∃ f : Base, a^n * r = baseMap f := by
+  obtain ⟨r, rfl⟩ := Ideal.Quotient.mkₐ_surjective ℂ (Ideal.span {relation}) r
+  change ∃ n : ℕ, ∃ f : Base, a^n * π r = baseMap f
+  induction r using MvPolynomial.induction_on with
+  | C z => refine ⟨0, C z, ?_⟩; simp [baseMap, π]
+  | add r s hr hs =>
+    obtain ⟨n, f, hf⟩ := hr
+    obtain ⟨m, g, hg⟩ := hs
+    refine ⟨n+m, X 1 ^ m * f + X 1 ^ n * g, ?_⟩
+    simp only [map_add, map_mul, map_pow]
+    have hb : baseMap (X 1) = a := by simp [baseMap, baseValues]
+    rw [hb, ← hf, ← hg, pow_add]
+    ring
+  | mul_X r i hr =>
+    obtain ⟨n, f, hf⟩ := hr
+    obtain ⟨m, g, hg⟩ := clears_generator i
+    refine ⟨n+m, f*g, ?_⟩
+    rw [map_mul, map_mul, ← hf, ← hg, pow_add]
+    ring
+
+lemma embedding_injective : Function.Injective embedding := by
+  apply (injective_iff_map_eq_zero embedding).mpr
+  intro r hr
+  obtain ⟨n, f, hf⟩ := clears r
+  have h : baseEmbedding f = 0 := by
+    rw [← embedding_baseMap, ← hf, map_mul, hr, mul_zero]
+  have hfzero : f = 0 := baseEmbedding_injective (h.trans (map_zero _).symm)
+  rw [hfzero, map_zero] at hf
+  exact isLeftRegular_iff_right_eq_zero_of_mul.mp (a_regular.pow n) r hf
+
+instance : IsDomain T := Function.Injective.isDomain embedding embedding_injective
+
+end ComplexCancellation.Determinant
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/AffineCancellation/DeterminantRigidity.lean b/lean/OAI/Algebra/AffineCancellation/DeterminantRigidity.lean
new file mode 100644
index 0000000000000000000000000000000000000000..e8ea09af86404186a715d66fe6fc13bfe339ac4f
--- /dev/null
+++ b/lean/OAI/Algebra/AffineCancellation/DeterminantRigidity.lean
@@ -0,0 +1,277 @@
+import OAI.Algebra.AffineCancellation.Kernel
+import OAI.Algebra.AffineCancellation.GradedLND
+import OAI.Algebra.AffineCancellation.QuotientGrading
+import OAI.Algebra.AffineCancellation.QuotientDerivation
+import OAI.Algebra.AffineCancellation.HighestWeight
+import OAI.Algebra.AffineCancellation.Determinant
+
+namespace OAI
+
+noncomputable section
+
+namespace ComplexCancellation.Determinant
+open MvPolynomial
+
+def δP : Derivation ℂ Poly Poly := MvPolynomial.mkDerivation ℂ ![0,0,X 0,X 1,0]
+def ηP : Derivation ℂ Poly Poly := MvPolynomial.mkDerivation ℂ ![X 2,X 3,0,0,0]
+
+lemma δP_relation : δP relation = 0 := by
+  simp [δP, relation, Derivation.leibniz, smul_eq_mul]
+  ring
+lemma ηP_relation : ηP relation = 0 := by
+  simp [ηP, relation, Derivation.leibniz, smul_eq_mul]
+  ring
+
+def δ : Derivation ℂ T T := QuotientDerivation.derivation _ δP
+  (QuotientDerivation.span_singleton_stable δP (by rw [δP_relation]; exact Ideal.zero_mem _))
+def η : Derivation ℂ T T := QuotientDerivation.derivation _ ηP
+  (QuotientDerivation.span_singleton_stable ηP (by rw [ηP_relation]; exact Ideal.zero_mem _))
+def Euler : Derivation ℂ T T := ⁅δ,η⁆
+
+@[simp] lemma δ_π (r : Poly) : δ (π r) = π (δP r) := rfl
+@[simp] lemma η_π (r : Poly) : η (π r) = π (ηP r) := rfl
+@[simp] lemma δ_a : δ a = 0 := by simp [a, δP]
+@[simp] lemma δ_d : δ d = 0 := by simp [d, δP]
+@[simp] lemma δ_b : δ b = a := by simp [a, b, δP]
+@[simp] lemma δ_c : δ c = d := by simp [d, c, δP]
+@[simp] lemma δ_u : δ u = 0 := by simp [u, δP]
+@[simp] lemma η_a : η a = b := by simp [a, b, ηP]
+@[simp] lemma η_d : η d = c := by simp [d, c, ηP]
+@[simp] lemma η_b : η b = 0 := by simp [b, ηP]
+@[simp] lemma η_c : η c = 0 := by simp [c, ηP]
+@[simp] lemma η_u : η u = 0 := by simp [u, ηP]
+@[simp] lemma Euler_a : Euler a = a := by simp [Euler, Derivation.commutator_apply]
+@[simp] lemma Euler_d : Euler d = d := by simp [Euler, Derivation.commutator_apply]
+@[simp] lemma Euler_b : Euler b = -b := by simp [Euler, Derivation.commutator_apply]
+@[simp] lemma Euler_c : Euler c = -c := by simp [Euler, Derivation.commutator_apply]
+@[simp] lemma Euler_u : Euler u = 0 := by simp [Euler, Derivation.commutator_apply]
+
+lemma derivation_ext {D₁ D₂ : Derivation ℂ T T}
+    (hX : ∀ i : Fin 5, D₁ (π (X i)) = D₂ (π (X i))) : D₁ = D₂ := by
+  apply Derivation.ext
+  intro r
+  obtain ⟨r, rfl⟩ := Ideal.Quotient.mkₐ_surjective ℂ (Ideal.span {relation}) r
+  change D₁ (π r) = D₂ (π r)
+  induction r using MvPolynomial.induction_on with
+  | C z => simp [π]
+  | add r s hr hs => simp only [map_add, hr, hs]
+  | mul_X r i hr => simp only [map_mul, Derivation.leibniz, hr, hX]
+
+lemma η_locallyNilpotent : LND.LocallyNilpotent η := by
+  apply QuotientDerivation.locallyNilpotent
+  apply LND.mvPolynomial_locallyNilpotent
+  intro i
+  refine ⟨2, ?_⟩
+  fin_cases i <;> simp [Function.iterate_succ_apply', ηP]
+
+lemma Euler_η (r : T) : Euler (η r) = η (Euler r) - (2 : ℂ) • η r := by
+  have h : ⁅Euler,η⁆ = (-2 : ℂ) • η := by
+    apply derivation_ext
+    intro i
+    fin_cases i <;>
+      simp [Euler, Derivation.commutator_apply, δ_π, η_π, δP, ηP, Derivation.smul_apply] <;>
+      module
+  have hr := DFunLike.congr_fun h r
+  simp only [Derivation.commutator_apply, Derivation.smul_apply] at hr
+  rw [neg_smul] at hr
+  linear_combination hr
+
+/-- Exact infinitesimal formulation of a fixed fiber-weight shift. -/
+def FiberShift (E : Derivation ℂ T T) (e : ℤ) : Prop :=
+  ∀ r, Euler (E r) - E (Euler r) = (e : ℂ) • E r
+
+lemma fixed_coefficients_contradiction (E : Derivation ℂ T T)
+    (hE : E ≠ 0) (hln : LND.LocallyNilpotent E) (e : ℤ) (he : e ≤ 0)
+    (hshift : FiberShift E e) (ha : E a = 0) (hd : E d = 0) (hu : E u = 0) : False := by
+  let h := c * E b - b * E c
+  have hrel : a * E c = d * E b := by
+    have hh := congrArg E determinant
+    simp only [map_sub, Derivation.leibniz, ha, hd, smul_eq_mul, mul_zero,
+      add_zero, zero_add, Derivation.map_one_eq_zero] at hh
+    linear_combination hh
+  have hb : E b = h*a := by dsimp [h]; linear_combination -(E b) * determinant + b * hrel
+  have hc : E c = h*d := by dsimp [h]; linear_combination -(E c) * determinant + c * hrel
+  have hder : E = h • δ := by
+    apply derivation_ext
+    intro i
+    fin_cases i
+    · change E a = h * δ a; simp only [ha, δ_a, mul_zero]
+    · change E d = h * δ d; simp only [hd, δ_d, mul_zero]
+    · change E b = h * δ b; simpa only [δ_b] using hb
+    · change E c = h * δ c; simpa only [δ_c] using hc
+    · change E u = h * δ u; simp only [hu, δ_u, mul_zero]
+  have hn : h ≠ 0 := by
+    intro hh
+    apply hE
+    rw [hder, hh]
+    apply Derivation.ext
+    intro r
+    change (0:T) * δ r = 0
+    exact zero_mul _
+  have hfix : δ h = 0 := by
+    have hh : E h = 0 := LND.fixed_of_dvd E hln (by
+      rw [hder, Derivation.smul_apply, smul_eq_mul]
+      exact dvd_mul_right _ _)
+    rw [hder, Derivation.smul_apply, smul_eq_mul] at hh
+    exact (mul_eq_zero.mp hh).resolve_left hn
+  have hweight : Euler h = ((e-2 : ℤ) : ℂ) • h := by
+    have hb' := hshift b
+    have hc' := hshift c
+    simp only [Euler_b, Euler_c, map_neg] at hb' hc'
+    dsimp [h]
+    simp only [map_sub, Derivation.leibniz, Euler_b, Euler_c, smul_eq_mul]
+    simp only [Int.cast_smul_eq_zsmul, zsmul_eq_mul] at hb' hc' ⊢
+    push_cast
+    linear_combination c * hb' - b * hc'
+  exact hn (SL2.no_negative_highest δ.toLinearMap η.toLinearMap Euler.toLinearMap
+    (fun r => rfl) Euler_η h (e-2) (by omega) hfix hweight (η_locallyNilpotent h))
+
+end ComplexCancellation.Determinant
+
+namespace ComplexCancellation.Determinant
+open MvPolynomial
+attribute [local instance] MvPolynomial.weightedGradedAlgebra
+
+def auxWeight : Fin 5 → ℤ := ![0,3,-3,0,2]
+abbrev auxPoly : ℤ → Submodule ℂ Poly := weightedHomogeneousSubmodule ℂ auxWeight
+abbrev aux : ℤ → Submodule ℂ T := QuotientGrading.pieces auxPoly π
+
+lemma relation_aux : relation ∈ auxPoly 0 := by
+  have h1 := (isWeightedHomogeneous_X (R := ℂ) auxWeight 0).mul
+    (isWeightedHomogeneous_X (R := ℂ) auxWeight 3)
+  have h2 := (isWeightedHomogeneous_X (R := ℂ) auxWeight 2).mul
+    (isWeightedHomogeneous_X (R := ℂ) auxWeight 1)
+  have h1' : IsWeightedHomogeneous auxWeight (X 0 * X 3 : Poly) 0 := by
+    simpa [auxWeight] using h1
+  have h2' : IsWeightedHomogeneous auxWeight (X 2 * X 1 : Poly) 0 := by
+    simpa [auxWeight] using h2
+  exact (h1'.sub h2').sub (isWeightedHomogeneous_one ℂ auxWeight)
+
+lemma aux_ker : (RingHom.ker π).IsHomogeneous auxPoly := by
+  change (RingHom.ker (Ideal.Quotient.mk (Ideal.span {relation}))).IsHomogeneous _
+  rw [Ideal.mk_ker]
+  apply Ideal.homogeneous_span
+  intro r hr
+  have hr' : r = relation := Set.mem_singleton_iff.mp hr
+  subst r
+  exact ⟨0, relation_aux⟩
+
+instance auxGrading : GradedAlgebra aux :=
+  QuotientGrading.grading auxPoly π (Ideal.Quotient.mkₐ_surjective _ _) aux_ker
+
+lemma aux_X (i : Fin 5) : π (X i) ∈ aux (auxWeight i) :=
+  ⟨X i, isWeightedHomogeneous_X (R := ℂ) auxWeight i, rfl⟩
+lemma aux_a : a ∈ aux 0 := aux_X 0
+lemma aux_d : d ∈ aux 3 := aux_X 1
+lemma aux_b : b ∈ aux (-3) := aux_X 2
+lemma aux_c : c ∈ aux 0 := aux_X 3
+lemma aux_u : u ∈ aux 2 := aux_X 4
+lemma aux_N : d ^ 2 + a ^ 2 * u ^ 3 ∈ aux 6 := by
+  have hd := SetLike.pow_mem_graded 2 aux_d
+  have ha := SetLike.pow_mem_graded 2 aux_a
+  have hu := SetLike.pow_mem_graded 3 aux_u
+  have hi := SetLike.mul_mem_graded ha hu
+  norm_num at hd hi
+  exact Submodule.add_mem _ hd hi
+lemma aux_a3b : a ^ 3 * b ∈ aux (-3) := by
+  have ha := SetLike.pow_mem_graded 3 aux_a
+  have hi := SetLike.mul_mem_graded ha aux_b
+  norm_num at hi
+  exact hi
+
+lemma Euler_aux {r : T} {i : ℤ} (hr : r ∈ aux i) : Euler r ∈ aux i := by
+  have he : Euler = GradedLND.component aux Euler 0 := by
+    apply derivation_ext
+    intro j
+    rw [GradedLND.component_of_mem aux Euler 0 (aux_X j), add_zero]
+    apply (GradedLND.proj_of_mem aux _).symm
+    fin_cases j
+    · change Euler a ∈ aux 0
+      simpa only [Euler_a] using aux_a
+    · change Euler d ∈ aux 3
+      simpa only [Euler_d] using aux_d
+    · change Euler b ∈ aux (-3)
+      simpa only [Euler_b] using Submodule.neg_mem (aux (-3)) aux_b
+    · change Euler c ∈ aux 0
+      simpa only [Euler_c] using Submodule.neg_mem (aux 0) aux_c
+    · change Euler u ∈ aux 2
+      simpa only [Euler_u] using Submodule.zero_mem (aux 2)
+  rw [he]
+  simpa only [add_zero] using GradedLND.component_homogeneous aux Euler 0 hr
+
+lemma Euler_proj (r : T) (i : ℤ) :
+    Euler (GradedLND.proj aux i r) = GradedLND.proj aux i (Euler r) := by
+  induction r using DirectSum.Decomposition.inductionOn aux with
+  | zero => simp
+  | @homogeneous j r =>
+    by_cases hji : j = i
+    · subst j
+      rw [GradedLND.proj_of_mem aux r.2, GradedLND.proj_of_mem aux (Euler_aux r.2)]
+    · rw [GradedLND.proj_of_mem_ne aux r.2 hji,
+        GradedLND.proj_of_mem_ne aux (Euler_aux r.2) hji, map_zero]
+  | add r s hr hs => simp only [map_add, hr, hs]
+
+lemma component_fiberShift {E : Derivation ℂ T T} {e : ℤ} (hE : FiberShift E e)
+    (j : ℤ) : FiberShift (GradedLND.component aux E j) e := by
+  intro r
+  induction r using DirectSum.Decomposition.inductionOn aux with
+  | zero => simp
+  | @homogeneous i r =>
+    rw [GradedLND.component_of_mem aux E j r.2,
+      GradedLND.component_of_mem aux E j (Euler_aux r.2), Euler_proj,
+      ← map_sub, hE, map_smul]
+  | add r s hr hs => simp only [map_add, smul_add]; linear_combination hr + hs
+
+lemma nonzero_base_X (i : Fin 4) : baseMap (X i) ≠ 0 := by
+  intro h
+  exact X_ne_zero i (baseMap_injective (h.trans (map_zero _).symm))
+lemma a_ne_zero : a ≠ 0 := by simpa [baseMap, baseValues] using nonzero_base_X 1
+lemma d_ne_zero : d ≠ 0 := by simpa [baseMap, baseValues] using nonzero_base_X 2
+lemma u_ne_zero : u ≠ 0 := by simpa [baseMap, baseValues] using nonzero_base_X 0
+lemma N_ne_zero : d ^ 2 + a ^ 2 * u ^ 3 ≠ 0 := by
+  intro h
+  have he : baseMap (X 2 ^ 2 + X 1 ^ 2 * X 0 ^ 3) = 0 := by
+    simpa [baseMap, baseValues] using h
+  have hp : (X 2 ^ 2 + X 1 ^ 2 * X 0 ^ 3 : Base) = 0 :=
+    baseMap_injective (he.trans (map_zero _).symm)
+  have hz := congrArg (MvPolynomial.eval (fun i : Fin 4 => if i = 2 then (1 : ℂ) else 0)) hp
+  simp at hz
+
+lemma nonsquare_u (z : K) : z ^ 2 ≠ -(embedding u) ^ 3 := by
+  have he : embedding u = RatFunc.X := by
+    change embedding (π (X 4)) = _
+    rw [embedding_π]
+    simp only [eval, aeval_X]
+    change baseEmbedding (X 0) = _
+    exact baseEmbedding_X_zero
+  rw [he]
+  exact Rigidity.ratFunc_X_cube_nonsquare z
+
+/-- Rigidity for the determinant algebra with its fiber Euler operator. -/
+theorem rigidity (E : Derivation ℂ T T) (hln : LND.LocallyNilpotent E)
+    (e : ℤ) (he : e ≤ 0) (hshift : FiberShift E e) (hv : E (E v) = 0) : E = 0 := by
+  by_contra hE
+  obtain ⟨j, hj, hbound, htopln⟩ := GradedLND.highest aux E hE hln
+  let E' := GradedLND.component aux E j
+  have hN : E' (E' (d ^ 2 + a ^ 2 * u ^ 3)) = 0 := by
+    have ht := (GradedLND.iterate_top aux hbound aux_N 2).2
+    have hl := (GradedLND.iterate_top aux hbound aux_a3b 2).1
+    have hlow : GradedLND.proj aux (6+2*j) (E (E (a^3*b))) = 0 := by
+      apply GradedLND.proj_filtration aux hl
+      omega
+    have heq : E (E (d ^ 2 + a ^ 2 * u ^ 3)) = E (E (a^3*b)) := by
+      dsimp [v] at hv
+      simp only [map_sub, map_add] at hv ⊢
+      linear_combination -hv
+    change GradedLND.proj aux (6+2*j) (E (E (d^2+a^2*u^3))) = E' (E' _) at ht
+    rw [heq, hlow] at ht
+    exact ht.symm
+  obtain ⟨ha, hd, hu⟩ := LND.fixed_of_square_cube E' htopln embedding embedding_injective
+    a_ne_zero d_ne_zero u_ne_zero N_ne_zero hN nonsquare_u
+  exact fixed_coefficients_contradiction E' hj htopln e he (component_fiberShift hshift j) ha hd hu
+
+end ComplexCancellation.Determinant
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/AffineCancellation/DifferentialSlice.lean b/lean/OAI/Algebra/AffineCancellation/DifferentialSlice.lean
new file mode 100644
index 0000000000000000000000000000000000000000..8f42b0e5f50e960db0b22877abed6ec11ed38646
--- /dev/null
+++ b/lean/OAI/Algebra/AffineCancellation/DifferentialSlice.lean
@@ -0,0 +1,108 @@
+import OAI.Algebra.AffineCancellation.Model
+
+namespace OAI
+
+noncomputable section
+
+namespace ComplexCancellation.DifferentialSlice
+open Polynomial
+variable {k K : Type*} [CommRing k] [Field K] [CharZero K] [Algebra k K]
+
+/-- The field of constants of a derivation on a field. -/
+def constants (D : Derivation k K K) : Subfield K where
+  carrier := {r | D r = 0}
+  zero_mem' := map_zero D
+  one_mem' := D.map_one_eq_zero
+  add_mem' := by
+    intro r s hr hs
+    change D r = 0 at hr
+    change D s = 0 at hs
+    change D (r+s) = 0
+    rw [map_add, hr, hs, add_zero]
+  mul_mem' := by
+    intro r s hr hs
+    change D r = 0 at hr
+    change D s = 0 at hs
+    change D (r*s) = 0
+    rw [Derivation.leibniz, hr, hs, smul_zero, smul_zero, add_zero]
+  neg_mem' := by
+    intro r hr
+    change D r = 0 at hr
+    change D (-r) = 0
+    rw [map_neg, hr, neg_zero]
+  inv_mem' := by
+    intro r hr
+    change D r = 0 at hr
+    change D r⁻¹ = 0
+    rw [Derivation.leibniz_inv, hr, smul_zero]
+
+omit [CharZero K] in
+lemma derivative_eval (D : Derivation k K K) {t : K} (ht : D t = 1)
+    (p : Polynomial (constants D)) :
+    D (aeval t p) = aeval t p.derivative := by
+  induction p using Polynomial.induction_on' with
+  | add p q hp hq => simp only [map_add, hp, hq]
+  | monomial n c =>
+    simp only [aeval_monomial, derivative_monomial, map_mul, map_natCast,
+      aeval_monomial, Derivation.leibniz, Derivation.leibniz_pow, ht, smul_eq_mul, nsmul_eq_mul]
+    have hc : D (c : K) = 0 := c.property
+    change (c:K) * ((n:K) * (t^(n-1) * 1)) + t^n * D (c:K) =
+      (c:K) * (n:K) * t^(n-1)
+    rw [hc]
+    ring
+
+lemma eval_injective (D : Derivation k K K) {t : K} (ht : D t = 1) :
+    Function.Injective (aeval t : Polynomial (constants D) →ₐ[constants D] K) := by
+  apply (injective_iff_map_eq_zero _).mpr
+  intro p
+  induction hn : p.natDegree using Nat.strong_induction_on generalizing p with
+  | h n ih =>
+    intro hp
+    by_cases hdeg : p.natDegree = 0
+    · rw [eq_C_of_natDegree_eq_zero hdeg] at hp ⊢
+      simp only [aeval_C, map_eq_zero] at hp ⊢
+      exact hp
+    · have hder : p.derivative = 0 := ih p.derivative.natDegree (by rw [← hn]; exact natDegree_derivative_lt hdeg) p.derivative rfl (by
+        rw [← derivative_eval D ht, hp, map_zero])
+      have hc := eq_C_of_derivative_eq_zero hder
+      rw [hc] at hp ⊢
+      simp only [aeval_C, map_eq_zero] at hp ⊢
+      exact hp
+
+lemma exists_antiderivative {F : Type*} [Field F] [CharZero F] (p : Polynomial F) :
+    ∃ q : Polynomial F, q.derivative = p := by
+  induction p using Polynomial.induction_on' with
+  | add p q hp hq =>
+    obtain ⟨p', hp'⟩ := hp
+    obtain ⟨q', hq'⟩ := hq
+    exact ⟨p'+q', by rw [derivative_add, hp', hq']⟩
+  | monomial n c =>
+    refine ⟨monomial (n+1) (c / (n+1)), ?_⟩
+    rw [derivative_monomial]
+    have hn : (n:F)+1 ≠ 0 := by exact_mod_cast Nat.succ_ne_zero n
+    simp [hn]
+
+lemma nilpotent_is_polynomial (D : Derivation k K K) {t r : K} (ht : D t = 1)
+    (hr : ∃ n : ℕ, (D : K → K)^[n] r = 0) :
+    ∃ p : Polynomial (constants D), aeval t p = r := by
+  obtain ⟨n, hr⟩ := hr
+  induction n generalizing r with
+  | zero => exact ⟨0, by simpa using hr.symm⟩
+  | succ n ih =>
+    rw [Function.iterate_succ_apply] at hr
+    obtain ⟨p, hp⟩ := ih hr
+    obtain ⟨q, hqp⟩ := exists_antiderivative p
+    have hq : D (aeval t q) = D r := by
+      rw [derivative_eval D ht]
+      rw [hqp, hp]
+    let c : constants D := ⟨r - aeval t q, by change D (r-aeval t q) = 0; rw [map_sub, hq, sub_self]⟩
+    refine ⟨q + C c, ?_⟩
+    simp only [map_add, aeval_C]
+    change aeval t q + (r - aeval t q) = r
+    ring
+
+end ComplexCancellation.DifferentialSlice
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/AffineCancellation/Dimension.lean b/lean/OAI/Algebra/AffineCancellation/Dimension.lean
new file mode 100644
index 0000000000000000000000000000000000000000..6dd35f5941c2003ce56ffcef9fa947645f602596
--- /dev/null
+++ b/lean/OAI/Algebra/AffineCancellation/Dimension.lean
@@ -0,0 +1,49 @@
+import OAI.Algebra.AffineCancellation.Cylinder
+
+namespace OAI
+
+noncomputable section
+
+namespace ComplexCancellation
+
+theorem finiteType : Algebra.FiniteType ℂ A := inferInstance
+
+instance domain : IsDomain A :=
+  Function.Injective.isDomain Cylinder.coefficientMap (by
+    intro r s hrs
+    apply Polynomial.C_injective
+    apply Cylinder.equivalence.injective
+    simpa only [Cylinder.equivalence, AlgEquiv.ofAlgHom_apply,
+      Cylinder.forward_C] using hrs)
+
+instance noetherian : IsNoetherianRing A := Algebra.FiniteType.isNoetherianRing ℂ A
+
+theorem dimension : ringKrullDim A = 4 := by
+  have hd : ringKrullDim A + 1 = 5 := by
+    rw [← Polynomial.ringKrullDim_of_isNoetherianRing,
+      ringKrullDim_eq_of_ringEquiv Cylinder.equivalence.toRingEquiv,
+      MvPolynomial.ringKrullDim_of_isNoetherianRing,
+      ringKrullDim_eq_zero_of_field, zero_add]
+    simp
+  generalize ringKrullDim A = d at *
+  induction d using WithBot.recBotCoe with
+  | bot => simp at hd
+  | coe d =>
+    have hd' : d + 1 = 5 := WithBot.coe_inj.mp (by
+      simpa only [WithBot.coe_add, WithBot.coe_one, WithBot.coe_ofNat] using hd)
+    induction d using ENat.recTopCoe with
+    | top => simp at hd'
+    | coe n =>
+      have hd'' : n + 1 = 5 := by exact_mod_cast hd'
+      have hn : n = 4 := by omega
+      subst n
+      rfl
+
+theorem stabilization : Nonempty (Polynomial A ≃ₐ[ℂ] MvPolynomial (Fin 5) ℂ) :=
+  ⟨Cylinder.equivalence⟩
+
+end ComplexCancellation
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/AffineCancellation/EquivariantLift.lean b/lean/OAI/Algebra/AffineCancellation/EquivariantLift.lean
new file mode 100644
index 0000000000000000000000000000000000000000..e0d503c59b998093258f6e55578ac75861947e02
--- /dev/null
+++ b/lean/OAI/Algebra/AffineCancellation/EquivariantLift.lean
@@ -0,0 +1,54 @@
+import OAI.Algebra.AffineCancellation.TorsorEuler
+import OAI.Algebra.AffineCancellation.BundleGrading
+
+namespace OAI
+
+noncomputable section
+
+namespace ComplexCancellation.PolynomialTorsor
+open PolynomialModel
+lemma exists_equivariant_lift (D : Derivation ℂ Degeneration.G Degeneration.G)
+    (hD : LND.LocallyNilpotent D) (hDn : D ≠ 0) :
+    ∃ (c : Degeneration.G) (E : Derivation ℂ Bundle.B Bundle.B),
+      c ≠ 0 ∧ LND.LocallyNilpotent E ∧ E ≠ 0 ∧
+      (∀ r, E (Bundle.pullback r)=Bundle.pullback (c*D r)) ∧
+      ∀ b, Bundle.fiberEuler (E b)=E (Bundle.fiberEuler b) := by
+  obtain ⟨s,hs,hss⟩ := local_slice D hD hDn
+  let t : K := ι (k := ℂ) s/ι (k := ℂ) (D s)
+  have hi : Function.Injective (ι (k := ℂ) (R := Degeneration.G)) :=
+    IsFractionRing.injective Degeneration.G K
+  have hsn : ι (k := ℂ) (D s) ≠ 0 := by simpa only [map_zero] using hi.ne hs
+  have ht : FractionDerivation.extend D t=1 := by
+    change FractionDerivation.extend D (algebraMap Degeneration.G K s/algebraMap Degeneration.G K (D s))=1
+    rw [Derivation.leibniz_div_const _ _ _ (by rw [FractionDerivation.extend_algebraMap,hss,map_zero]),
+      FractionDerivation.extend_algebraMap,smul_eq_mul]
+    exact inv_mul_cancel₀ hsn
+  let φ := ρ D hD ht
+  have hφ : Function.Injective φ := ρ_injective D hD ht
+  obtain ⟨Q⟩ := exists_frame D hD ht
+  have hf : Function.Injective (Torsor.forward φ Q) := forward_injective D hD ht Q
+  let Dp : Derivation ℂ (P D) (P D) := SliceDerivative.derivation
+  have hDp : LND.LocallyNilpotent Dp := SliceDerivative.locallyNilpotent
+  have hder (r : Degeneration.G) : Dp (φ r)=φ (D r) := derivative_model D hD ht r
+  have hc (p : P D) : p ∈ InvariantClearing.subalgebra φ D :=
+    clear_polynomial D hD ht s hs hss rfl p
+  obtain ⟨c,E,hDc,hcn,hE,hsE⟩ := Torsor.invariant_replica φ Q D hφ hc Dp hDp hder hf
+  have hbase (r : Degeneration.G) : Torsor.forward φ Q (Bundle.pullback r)=Torsor.base φ r :=
+    DFunLike.congr_fun (Torsor.forward_pullback φ Q hφ) r
+  have he (r : Degeneration.G) : E (Bundle.pullback r)=Bundle.pullback (c*D r) := by
+    apply hf
+    rw [hsE,hbase,Torsor.extension_base φ D Dp hder,hbase,map_mul]
+  have hEn : E ≠ 0 := by
+    intro hz
+    apply hDn
+    ext r
+    have h := he r
+    rw [hz,Derivation.zero_apply] at h
+    have hz' : c*D r=0 := Bundle.pullback_injective (by simpa only [map_zero] using h.symm)
+    exact (mul_eq_zero.mp hz').resolve_left hcn
+  exact ⟨c,E,hcn,hE,hEn,he,Torsor.replica_commute φ Q hφ hf Dp E c hsE⟩
+end ComplexCancellation.PolynomialTorsor
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/AffineCancellation/Extraction.lean b/lean/OAI/Algebra/AffineCancellation/Extraction.lean
new file mode 100644
index 0000000000000000000000000000000000000000..6d85b3813ec4a157ff26c2bc17d9e3fd5cf4ab11
--- /dev/null
+++ b/lean/OAI/Algebra/AffineCancellation/Extraction.lean
@@ -0,0 +1,99 @@
+import OAI.Algebra.AffineCancellation.ModificationGrading
+import OAI.Algebra.AffineCancellation.PolynomialDerivation
+
+namespace OAI
+
+noncomputable section
+
+namespace ComplexCancellation.AffineModification
+open MvPolynomial
+variable {k R : Type*} [Field k] [CharZero k] [CommRing R] [IsDomain R] [Algebra k R]
+variable (v : R) (hv : v ≠ 0)
+lemma coefficient_injective : Function.Injective (algebraMap R (T R v)) := by
+  apply Function.Injective.of_comp (f := embedding R v)
+  intro r s he
+  change embedding R v (algebraMap R (T R v) r)=embedding R v (algebraMap R (T R v) s) at he
+  rw [AlgHom.commutes,AlgHom.commutes] at he
+  exact ((RatFunc.C_injective).comp (IsFractionRing.injective R (F R))) he
+lemma τ_nonzero : τ R v ≠ 0 := by
+  intro h
+  have he := congrArg (embedding R v) h
+  have he' : (RatFunc.X : K R)=0 := by
+    simpa [τ,eval,values] using he
+  exact RatFunc.X_ne_zero he'
+include hv in
+lemma V_nonzero : V R v ≠ 0 := by
+  intro h
+  have he := equation R v
+  rw [h,mul_zero] at he
+  exact hv ((coefficient_injective v) (he.symm.trans (map_zero _).symm))
+
+def coefficientHom : R →ₐ[k] T R v := IsScalarTower.toAlgHom k R (T R v)
+omit [CharZero k] in
+lemma coefficientHom_injective : Function.Injective (coefficientHom (k := k) v) :=
+  coefficient_injective v
+
+def eulerPoly (H : Derivation k R R) : Derivation k (P R) (P R) :=
+  PolynomialDerivation.mv H ![0,2*X 1]
+omit [CharZero k] [IsDomain R] in
+lemma eulerPoly_relation (H : Derivation k R R) (hH : H v=2*v) :
+    eulerPoly H (rel R v)=2*rel R v := by
+  simp only [rel,eulerPoly,map_sub,Derivation.leibniz,Derivation.leibniz_pow,
+    PolynomialDerivation.mv_X,PolynomialDerivation.mv_C,hH,map_mul,map_ofNat,
+    Matrix.cons_val_zero,Matrix.cons_val_one,smul_eq_mul]
+  ring
+
+def euler (H : Derivation k R R) (hH : H v=2*v) : Derivation k (T R v) (T R v) :=
+  QuotientDerivation.derivation _ (eulerPoly H)
+    (QuotientDerivation.span_singleton_stable _ (by
+      rw [eulerPoly_relation v H hH]
+      exact Ideal.mul_mem_left _ _ (Ideal.subset_span (by simp))))
+omit [CharZero k] [IsDomain R] in
+@[simp] lemma euler_π (H : Derivation k R R) (hH : H v=2*v) (p : P R) :
+    euler v H hH (π R v p)=π R v (eulerPoly H p) := rfl
+omit [CharZero k] [IsDomain R] in
+@[simp] lemma euler_coefficient (H : Derivation k R R) (hH : H v=2*v) (r : R) :
+    euler v H hH (coefficientHom (k := k) v r)=coefficientHom (k := k) v (H r) := by
+  change euler v H hH (π R v (C r))=π R v (C (H r))
+  rw [euler_π]
+  simp [eulerPoly]
+omit [CharZero k] [IsDomain R] in
+@[simp] lemma euler_τ (H : Derivation k R R) (hH : H v=2*v) : euler v H hH (τ R v)=0 := by
+  simp [τ,eulerPoly]
+omit [CharZero k] [IsDomain R] in
+@[simp] lemma euler_V (H : Derivation k R R) (hH : H v=2*v) : euler v H hH (V R v)=2*V R v := by
+  simp only [V,euler_π,eulerPoly,PolynomialDerivation.mv_X,Matrix.cons_val_one,Matrix.cons_val_zero,map_mul,map_ofNat]
+omit [CharZero k] [IsDomain R] in
+lemma euler_monomial (H : Derivation k R R) (hH : H v=2*v) (i h : ℕ) :
+    euler v H hH (τ R v^i*V R v^h)=(2*h:ℕ)*(τ R v^i*V R v^h) := by
+  simp only [Derivation.leibniz,Derivation.leibniz_pow,euler_τ,euler_V,
+    smul_eq_mul,mul_zero,add_zero,nsmul_eq_mul,Nat.cast_mul,Nat.cast_ofNat]
+  by_cases hh : h=0
+  · subst h; simp
+  · have he : V R v^(h-1)*V R v=V R v^h := by rw [← pow_succ]; congr 1; omega
+    calc
+      _ = (2*(h : T R v))*(τ R v^i*(V R v^(h-1)*V R v)) := by ring
+      _ = _ := by rw [he]
+
+omit [CharZero k] [IsDomain R] in
+lemma derivation_zero_of_generators (D : Derivation k (T R v) (T R v))
+    (hc : ∀ r, D (coefficientHom (k := k) v r)=0)
+    (hτ : D (τ R v)=0) (hV : D (V R v)=0) : D=0 := by
+  apply Derivation.ext
+  intro r
+  obtain ⟨r,rfl⟩ := Ideal.Quotient.mkₐ_surjective R (Ideal.span {rel R v}) r
+  change D (π R v r)=0
+  induction r using MvPolynomial.induction_on with
+  | C r => exact hc r
+  | add r s hr hs => simp only [map_add,hr,hs,add_zero]
+  | mul_X r i hr =>
+    have hi : D (π R v (X i))=0 := by
+      fin_cases i
+      · exact hτ
+      · exact hV
+    simp only [map_mul,Derivation.leibniz,hr,hi,smul_zero,add_zero]
+end ComplexCancellation.AffineModification
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/AffineCancellation/FactorDerivation.lean b/lean/OAI/Algebra/AffineCancellation/FactorDerivation.lean
new file mode 100644
index 0000000000000000000000000000000000000000..95c5cc3278974f1ea9028a946236ceb80f1ad0f1
--- /dev/null
+++ b/lean/OAI/Algebra/AffineCancellation/FactorDerivation.lean
@@ -0,0 +1,51 @@
+import OAI.Algebra.AffineCancellation.Model
+
+namespace OAI
+
+noncomputable section
+
+namespace ComplexCancellation.FactorDerivation
+variable {k S R : Type*} [CommRing k] [CommRing S] [CommRing R] [IsDomain R]
+  [Algebra k S] [Algebra k R]
+variable (f : S →ₐ[k] R) (hf : Function.Injective f)
+  (D : Derivation k R R) (c : R) (hc : c ≠ 0)
+  (h : ∀ s : S, ∃ t : S, D (f s)=c*f t)
+def value (s : S) : S := Classical.choose (h s)
+omit [IsDomain R] in
+lemma specification (s : S) : D (f s)=c*f (value f D c h s) := Classical.choose_spec (h s)
+include hf hc in
+lemma value_add (s t : S) : value f D c h (s+t)=value f D c h s+value f D c h t := by
+  apply hf
+  apply mul_left_cancel₀ hc
+  rw [← specification,map_add,map_add,map_add,mul_add,← specification,← specification]
+include hf hc in
+lemma value_smul (a : k) (s : S) : value f D c h (a • s)=a • value f D c h s := by
+  apply hf
+  apply mul_left_cancel₀ hc
+  rw [← specification,map_smul,Derivation.map_smul,map_smul,mul_smul_comm,← specification]
+include hf hc in
+lemma value_mul (s t : S) :
+    value f D c h (s*t)=s*value f D c h t+t*value f D c h s := by
+  apply hf
+  apply mul_left_cancel₀ hc
+  rw [← specification,map_mul,Derivation.leibniz,smul_eq_mul,smul_eq_mul,
+    specification f D c h s,specification f D c h t,map_add,map_mul,map_mul]
+  ring
+def derivation : Derivation k S S where
+  toLinearMap := {
+    toFun := value f D c h
+    map_add' := value_add f hf D c hc h
+    map_smul' := value_smul f hf D c hc h }
+  map_one_eq_zero' := by
+    apply hf
+    apply mul_left_cancel₀ hc
+    change c*f (value f D c h 1)=c*f 0
+    rw [← specification,map_one,Derivation.map_one_eq_zero,map_zero,mul_zero]
+  leibniz' s t := by
+    exact value_mul f hf D c hc h s t
+lemma apply_spec (s : S) : D (f s)=c*f (derivation f hf D c hc h s) := specification f D c h s
+end ComplexCancellation.FactorDerivation
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/AffineCancellation/FractionDerivation.lean b/lean/OAI/Algebra/AffineCancellation/FractionDerivation.lean
new file mode 100644
index 0000000000000000000000000000000000000000..96040856e73dfa5a66205f46ceb3c97a130ff55e
--- /dev/null
+++ b/lean/OAI/Algebra/AffineCancellation/FractionDerivation.lean
@@ -0,0 +1,91 @@
+import OAI.Algebra.AffineCancellation.Model
+
+namespace OAI
+
+noncomputable section
+
+namespace ComplexCancellation.FractionDerivation
+variable {k R K : Type*} [CommRing k] [CommRing R] [Field K]
+  [Algebra k R] [Algebra R K] [IsFractionRing R K] [Algebra k K] [IsScalarTower k R K]
+
+open TrivSqZeroExt
+
+def dualMap (D : Derivation k R R) : R →ₐ[k] TrivSqZeroExt K K where
+  toFun r := inl (algebraMap R K r) + inr (algebraMap R K (D r))
+  map_zero' := by apply TrivSqZeroExt.ext <;> simp
+  map_one' := by apply TrivSqZeroExt.ext <;> simp
+  map_add' := by
+    intro r s
+    apply TrivSqZeroExt.ext <;>
+      simp only [fst_add, fst_inl, fst_inr, snd_add, snd_inl, snd_inr,
+        map_add, add_zero, zero_add]
+  map_mul' := by
+    intro r s
+    apply TrivSqZeroExt.ext <;>
+      simp only [fst_add, fst_inl, fst_inr, snd_add, snd_inl, snd_inr,
+        fst_mul, snd_mul, add_zero, zero_add, Derivation.leibniz,
+        smul_eq_mul, map_add, map_mul, op_smul_eq_mul, mul_comm]
+  commutes' r := by
+    apply TrivSqZeroExt.ext <;>
+      simp only [fst_add, fst_inl, fst_inr, snd_add, snd_inl, snd_inr,
+        algebraMap_eq_inl', Derivation.map_algebraMap, map_zero, add_zero,
+        ← IsScalarTower.algebraMap_apply k R K]
+
+omit [IsFractionRing R K] in
+@[simp] lemma dualMap_fst (D : Derivation k R R) (r : R) :
+    fst (dualMap D r : TrivSqZeroExt K K) = algebraMap R K r := by
+  simp only [dualMap, AlgHom.coe_mk, RingHom.coe_mk, MonoidHom.coe_mk,
+    OneHom.coe_mk, fst_add, fst_inl, fst_inr, add_zero]
+
+omit [IsFractionRing R K] in
+@[simp] lemma dualMap_snd (D : Derivation k R R) (r : R) :
+    snd (dualMap D r : TrivSqZeroExt K K) = algebraMap R K (D r) := by
+  simp only [dualMap, AlgHom.coe_mk, RingHom.coe_mk, MonoidHom.coe_mk,
+    OneHom.coe_mk, snd_add, snd_inl, snd_inr, zero_add]
+
+def dualLift (D : Derivation k R R) : K →ₐ[k] TrivSqZeroExt K K :=
+  IsLocalization.liftAlgHom (M := nonZeroDivisors R) (S := K) (f := dualMap D) (by
+    intro y
+    apply isUnit_iff_isUnit_fst.mpr
+    rw [dualMap_fst]
+    exact IsLocalization.map_units K y)
+
+lemma dualLift_algebraMap (D : Derivation k R R) (r : R) :
+    dualLift D (algebraMap R K r) = dualMap D r :=
+  IsLocalization.lift_eq _ r
+
+lemma dualLift_fst (D : Derivation k R R) (z : K) : fst (dualLift D z) = z := by
+  have h : (fstHom k K K).comp (dualLift D) = AlgHom.id k K := by
+    apply AlgHom.coe_ringHom_injective
+    apply IsLocalization.ringHom_ext (nonZeroDivisors R)
+    ext r
+    simp only [RingHom.comp_apply, AlgHom.coe_toRingHom,
+      AlgHom.comp_apply, dualLift_algebraMap, AlgHom.id_apply]
+    exact dualMap_fst D r
+  exact DFunLike.congr_fun h z
+
+def extend (D : Derivation k R R) : Derivation k K K :=
+  Derivation.mk' (((sndHom K K).restrictScalars k).comp (dualLift D).toLinearMap) (by
+    intro x y
+    change snd (dualLift D (x*y)) = x * snd (dualLift D y) + y * snd (dualLift D x)
+    rw [map_mul, snd_mul, dualLift_fst, dualLift_fst]
+    simp only [smul_eq_mul, op_smul_eq_mul, mul_comm])
+
+@[simp] lemma extend_algebraMap (D : Derivation k R R) (r : R) :
+    extend D (algebraMap R K r) = algebraMap R K (D r) := by
+  change snd (dualLift D (algebraMap R K r)) = _
+  rw [dualLift_algebraMap]
+  exact dualMap_snd D r
+
+lemma iterate_algebraMap (D : Derivation k R R) (r : R) (n : ℕ) :
+    (extend D : K → K)^[n] (algebraMap R K r) = algebraMap R K ((D : R → R)^[n] r) := by
+  induction n with
+  | zero => rfl
+  | succ n ih => rw [Function.iterate_succ_apply', ih, extend_algebraMap,
+      Function.iterate_succ_apply']
+
+end ComplexCancellation.FractionDerivation
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/AffineCancellation/GradedCommutation.lean b/lean/OAI/Algebra/AffineCancellation/GradedCommutation.lean
new file mode 100644
index 0000000000000000000000000000000000000000..0e7be1dd4f22b1659523906da5d5b2ecb16e44e6
--- /dev/null
+++ b/lean/OAI/Algebra/AffineCancellation/GradedCommutation.lean
@@ -0,0 +1,33 @@
+import OAI.Algebra.AffineCancellation.GradedLND
+
+namespace OAI
+
+noncomputable section
+
+namespace ComplexCancellation.GradedLND
+variable {k R : Type*} [CommRing k] [CommRing R] [Algebra k R]
+variable (G : ℤ → Submodule k R) [GradedAlgebra G]
+lemma linear_projection (H : R →ₗ[k] R) (hH : ∀ i r, r ∈ G i → H r ∈ G i) (i : ℤ) (r : R) :
+    H (proj G i r)=proj G i (H r) := by
+  induction r using DirectSum.Decomposition.inductionOn G with
+  | zero => simp only [map_zero]
+  | @homogeneous j r =>
+    by_cases hj : j=i
+    · subst j
+      rw [proj_of_mem G r.2,proj_of_mem G (hH i r r.2)]
+    · rw [proj_of_mem_ne G r.2 hj,proj_of_mem_ne G (hH j r r.2) hj,map_zero]
+  | add r s hr hs => simp only [map_add,hr,hs]
+lemma component_commute (D H : Derivation k R R) (hH : ∀ i r, r ∈ G i → H r ∈ G i)
+    (hc : ∀ r, H (D r)=D (H r)) (j : ℤ) (r : R) :
+    H (component G D j r)=component G D j (H r) := by
+  induction r using DirectSum.Decomposition.inductionOn G with
+  | zero => simp only [map_zero]
+  | @homogeneous i r =>
+    rw [component_of_mem G D j r.2,component_of_mem G D j (hH i r r.2)]
+    exact (linear_projection G H.toLinearMap hH (i+j) (D r)).trans (congrArg (proj G (i+j)) (hc r))
+  | add r s hr hs => simp only [map_add,hr,hs]
+end ComplexCancellation.GradedLND
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/AffineCancellation/GradedLND.lean b/lean/OAI/Algebra/AffineCancellation/GradedLND.lean
new file mode 100644
index 0000000000000000000000000000000000000000..6e82591f9514c5b1138f498fae33d0ec42676db1
--- /dev/null
+++ b/lean/OAI/Algebra/AffineCancellation/GradedLND.lean
@@ -0,0 +1,290 @@
+import OAI.Algebra.AffineCancellation.Model
+
+namespace OAI
+
+noncomputable section
+
+namespace ComplexCancellation.GradedLND
+open DirectSum
+variable {k R : Type*} [CommRing k] [CommRing R] [Algebra k R]
+variable (G : ℤ → Submodule k R) [GradedAlgebra G]
+
+abbrev proj (i : ℤ) : R →ₗ[k] R := GradedAlgebra.proj G i
+
+lemma proj_mem (i : ℤ) (r : R) : proj G i r ∈ G i :=
+  (decompose G r i).property
+
+lemma proj_of_mem {r : R} {i : ℤ} (hr : r ∈ G i) : proj G i r = r :=
+  decompose_of_mem_same G hr
+
+lemma proj_of_mem_ne {r : R} {i j : ℤ} (hr : r ∈ G i) (hne : i ≠ j) :
+    proj G j r = 0 := decompose_of_mem_ne G hr hne
+
+lemma proj_mul_left {r : R} {i : ℤ} (hr : r ∈ G i) (s : R) (j : ℤ) :
+    proj G (i+j) (r*s) = r * proj G j s :=
+  coe_decompose_mul_add_of_left_mem G hr
+
+lemma proj_mul_right (r : R) {s : R} {j : ℤ} (hs : s ∈ G j) (i : ℤ) :
+    proj G (i+j) (r*s) = proj G i r * s :=
+  coe_decompose_mul_add_of_right_mem G hs
+
+/-- The shift-j component of a linear map, on an arbitrary ℤ-graded algebra. -/
+def componentLinear (D : R →ₗ[k] R) (j : ℤ) : R →ₗ[k] R :=
+  (DirectSum.toModule k ℤ R (fun i =>
+    ((proj G (i+j)).comp D).comp (G i).subtype)).comp
+    (DirectSum.decomposeAlgEquiv G).toLinearMap
+
+lemma componentLinear_of_mem (D : R →ₗ[k] R) (j : ℤ) {r : R} {i : ℤ}
+    (hr : r ∈ G i) : componentLinear G D j r = proj G (i+j) (D r) := by
+  change DirectSum.toModule k ℤ R _ (decompose G r) = _
+  rw [decompose_of_mem G hr]
+  change DirectSum.toModule k ℤ R (fun t =>
+    ((proj G (t+j)).comp D).comp (G t).subtype)
+      (DirectSum.lof k ℤ (fun t => G t) i ⟨r, hr⟩) = _
+  rw [DirectSum.toModule_lof]
+  rfl
+
+lemma componentLinear_leibniz (D : Derivation k R R) (j : ℤ) (r s : R) :
+    componentLinear G D.toLinearMap j (r*s) =
+      r * componentLinear G D.toLinearMap j s + s * componentLinear G D.toLinearMap j r := by
+  induction r using DirectSum.Decomposition.inductionOn G with
+  | zero => simp
+  | @homogeneous i r =>
+    induction s using DirectSum.Decomposition.inductionOn G with
+    | zero => simp
+    | @homogeneous h s =>
+      rw [componentLinear_of_mem G D.toLinearMap j (SetLike.GradedMul.mul_mem r.2 s.2),
+        componentLinear_of_mem G D.toLinearMap j s.2,
+        componentLinear_of_mem G D.toLinearMap j r.2]
+      simp only [Derivation.coeFn_coe, Derivation.leibniz, smul_eq_mul, map_add]
+      rw [show i+h+j = i+(h+j) by omega, proj_mul_left G r.2]
+      rw [show i+(h+j) = h+(i+j) by omega, proj_mul_left G s.2]
+    | add s t hs ht => simp only [mul_add, map_add, hs, ht, add_mul]; abel
+  | add r t hr ht => simp only [add_mul, map_add, hr, ht, mul_add]; abel
+
+def component (D : Derivation k R R) (j : ℤ) : Derivation k R R :=
+  Derivation.mk' (componentLinear G D.toLinearMap j) (by
+    intro r s
+    simpa only [smul_eq_mul] using componentLinear_leibniz G D j r s)
+
+lemma component_of_mem (D : Derivation k R R) (j : ℤ) {r : R} {i : ℤ}
+    (hr : r ∈ G i) : component G D j r = proj G (i+j) (D r) :=
+  componentLinear_of_mem G D.toLinearMap j hr
+
+lemma component_homogeneous (D : Derivation k R R) (j : ℤ) {r : R} {i : ℤ}
+    (hr : r ∈ G i) : component G D j r ∈ G (i+j) := by
+  rw [component_of_mem G D j hr]
+  exact proj_mem G _ _
+
+/-- The increasing filtration associated to an integer grading. -/
+def filtration (d : ℤ) : Submodule k R := ⨆ i : {i : ℤ // i ≤ d}, G i
+
+omit [GradedAlgebra G] in
+lemma mem_filtration {r : R} {i d : ℤ} (hr : r ∈ G i) (hid : i ≤ d) :
+    r ∈ filtration G d := Submodule.mem_iSup_of_mem ⟨i, hid⟩ hr
+
+omit [GradedAlgebra G] in
+lemma filtration_mono {d e : ℤ} (h : d ≤ e) : filtration G d ≤ filtration G e := by
+  apply iSup_le
+  intro i
+  exact fun r hr => mem_filtration G hr (i.2.trans h)
+
+lemma proj_filtration {r : R} {d i : ℤ} (hr : r ∈ filtration G d) (hdi : d < i) :
+    proj G i r = 0 := by
+  refine Submodule.iSup_induction (fun t : {i : ℤ // i ≤ d} => G t)
+    (motive := fun r => proj G i r = 0) hr ?_ ?_ ?_
+  · intro t r hr
+    exact proj_of_mem_ne G hr (by have ht := t.2; omega)
+  · exact map_zero _
+  · intro a b ha hb
+    rw [map_add, ha, hb, add_zero]
+
+lemma exists_filtration (r : R) : ∃ d, r ∈ filtration G d := by
+  induction r using DirectSum.Decomposition.inductionOn G with
+  | zero => exact ⟨0, Submodule.zero_mem _⟩
+  | @homogeneous i r => exact ⟨i, mem_filtration G r.2 le_rfl⟩
+  | add r s hr hs =>
+    obtain ⟨d, hd⟩ := hr
+    obtain ⟨e, he⟩ := hs
+    exact ⟨max d e, Submodule.add_mem _
+      (filtration_mono G (le_max_left d e) hd) (filtration_mono G (le_max_right d e) he)⟩
+
+def ShiftBound (D : Derivation k R R) (j : ℤ) : Prop :=
+  ∀ i r, r ∈ G i → D r ∈ filtration G (i+j)
+
+omit [GradedAlgebra G] in
+lemma map_filtration {D : Derivation k R R} {j : ℤ} (hD : ShiftBound G D j)
+    {r : R} {d : ℤ} (hr : r ∈ filtration G d) : D r ∈ filtration G (d+j) := by
+  refine Submodule.iSup_induction (fun t : {i : ℤ // i ≤ d} => G t)
+    (motive := fun r => D r ∈ filtration G (d+j)) hr ?_ ?_ ?_
+  · intro i r hr
+    exact filtration_mono G (by have ht := i.2; omega) (hD i r hr)
+  · rw [map_zero]; exact Submodule.zero_mem _
+  · intro a b ha hb
+    rw [map_add]; exact Submodule.add_mem _ ha hb
+
+lemma top_map {D : Derivation k R R} {j : ℤ} (hD : ShiftBound G D j)
+    {r : R} {d : ℤ} (hr : r ∈ filtration G d) :
+    proj G (d+j) (D r) = component G D j (proj G d r) := by
+  refine Submodule.iSup_induction (fun t : {i : ℤ // i ≤ d} => G t)
+    (motive := fun r => proj G (d+j) (D r) = component G D j (proj G d r))
+    hr ?_ ?_ ?_
+  · intro i r hr
+    by_cases hi : (i : ℤ) = d
+    · have hr' : r ∈ G d := hi ▸ hr
+      rw [proj_of_mem G hr', component_of_mem G D j hr']
+    · have hid : (i : ℤ) < d := lt_of_le_of_ne i.2 hi
+      rw [proj_of_mem_ne G hr hi, map_zero]
+      exact proj_filtration G (hD i r hr) (by omega)
+  · simp
+  · intro a b ha hb
+    simp only [map_add, ha, hb]
+
+lemma iterate_top {D : Derivation k R R} {j : ℤ} (hD : ShiftBound G D j)
+    {r : R} {i : ℤ} (hr : r ∈ G i) (n : ℕ) :
+    (D : R → R)^[n] r ∈ filtration G (i+n*j) ∧
+    proj G (i+n*j) ((D : R → R)^[n] r) = ((component G D j : R → R)^[n] r) := by
+  induction n with
+  | zero => simpa using And.intro (mem_filtration G hr le_rfl) (proj_of_mem G hr)
+  | succ n ih =>
+    rw [Function.iterate_succ_apply', Function.iterate_succ_apply']
+    have hn : i+(↑(n+1) : ℤ)*j = (i+n*j)+j := by push_cast; ring
+    rw [hn]
+    exact ⟨map_filtration G hD ih.1, (top_map G hD ih.1).trans (congrArg _ ih.2)⟩
+
+/-- Local nilpotence survives passage to the highest homogeneous component,
+including for gradings with negative degrees. -/
+lemma component_locallyNilpotent {D : Derivation k R R} {j : ℤ}
+    (hD : ShiftBound G D j) (hln : ∀ r : R, ∃ n : ℕ, (D : R → R)^[n] r = 0) :
+    ∀ r : R, ∃ n : ℕ, (component G D j : R → R)^[n] r = 0 := by
+  intro r
+  induction r using DirectSum.Decomposition.inductionOn G with
+  | zero => exact ⟨0, rfl⟩
+  | @homogeneous i r =>
+    obtain ⟨n, hn⟩ := hln r
+    refine ⟨n, ?_⟩
+    have h := (iterate_top G hD r.2 n).2
+    rw [hn, map_zero] at h
+    exact h.symm
+  | add r s hr hs =>
+    obtain ⟨n, hn⟩ := hr
+    obtain ⟨m, hm⟩ := hs
+    let E := (component G D j).toLinearMap
+    change (E : R → R)^[n] r = 0 at hn
+    change (E : R → R)^[m] s = 0 at hm
+    refine ⟨n+m, ?_⟩
+    change (E : R → R)^[n+m] (r+s) = 0
+    rw [← Module.End.pow_apply, map_add]
+    have hnr : (E ^ (n+m)) r = 0 := by
+      rw [Module.End.pow_apply, Nat.add_comm, Function.iterate_add_apply, hn]
+      simpa only [Module.End.pow_apply] using (E ^ m).map_zero
+    have hms : (E ^ (n+m)) s = 0 := by
+      rw [Module.End.pow_apply, Function.iterate_add_apply, hm]
+      simpa only [Module.End.pow_apply] using (E ^ n).map_zero
+    rw [hnr, hms, add_zero]
+
+lemma eq_zero_of_projections {r : R} (h : ∀ i, proj G i r = 0) : r = 0 := by
+  apply (DirectSum.decompose G).injective
+  ext i
+  simpa [proj] using h i
+
+lemma mem_filtration_iff {r : R} {d : ℤ} :
+    r ∈ filtration G d ↔ ∀ i, d < i → proj G i r = 0 := by
+  constructor
+  · exact fun hr i hi => proj_filtration G hr hi
+  · intro h
+    classical
+    rw [← DirectSum.sum_support_decompose G r]
+    apply Submodule.sum_mem
+    intro i hi
+    by_cases hid : i ≤ d
+    · exact mem_filtration G (proj_mem G i r) hid
+    · have hz := h i (lt_of_not_ge hid)
+      change proj G i r ∈ filtration G d
+      rw [hz]
+      exact Submodule.zero_mem _
+
+lemma shiftBound_of_components {D : Derivation k R R} {j : ℤ}
+    (hD : ∀ e, j < e → component G D e = 0) : ShiftBound G D j := by
+  intro i r hr
+  apply (mem_filtration_iff G).mpr
+  intro b hb
+  have h := DFunLike.congr_fun (hD (b-i) (by omega)) r
+  rw [component_of_mem G D (b-i) hr] at h
+  simpa only [add_sub_cancel, Derivation.zero_apply] using h
+
+lemma component_exists {D : Derivation k R R} (hD : D ≠ 0) :
+    ∃ j, component G D j ≠ 0 := by
+  by_contra h
+  push Not at h
+  apply hD
+  apply Derivation.ext
+  intro r
+  change D r = 0
+  induction r using DirectSum.Decomposition.inductionOn G with
+  | zero => exact map_zero D
+  | @homogeneous i r =>
+    apply eq_zero_of_projections G
+    intro j
+    have he := DFunLike.congr_fun (h (j-i)) (r : R)
+    rw [component_of_mem G D (j-i) r.2] at he
+    simpa only [add_sub_cancel, Derivation.zero_apply] using he
+  | add r s hr hs => rw [map_add, hr, hs, add_zero]
+
+lemma homogeneous_generators [Algebra.FiniteType k R] :
+    ∃ s : Finset R, Algebra.adjoin k (s : Set R) = ⊤ ∧
+      ∀ r ∈ s, ∃ i, r ∈ G i := by
+  classical
+  obtain ⟨F, hF⟩ := Algebra.FiniteType.out (R := k) (A := R)
+  let ι₀ := Σ (r : F), (DirectSum.decompose G r.1).support
+  let v (i : ι₀) : R := (DirectSum.decompose G i.1 i.2).1
+  refine ⟨Finset.univ.image v, ?_, ?_⟩
+  · rw [← top_le_iff, ← hF, Algebra.adjoin_le_iff]
+    intro r hr
+    rw [← DirectSum.sum_support_decompose G r]
+    apply sum_mem
+    intro i hi
+    exact Algebra.subset_adjoin (by
+      simp only [Finset.coe_image, Finset.coe_univ, Set.image_univ, Set.mem_range]
+      exact ⟨⟨⟨r, hr⟩, i, hi⟩, rfl⟩)
+  · intro r hr
+    obtain ⟨i, _, rfl⟩ := Finset.mem_image.mp hr
+    exact ⟨i.2, (DirectSum.decompose G i.1 i.2).property⟩
+
+lemma component_bounded [Algebra.FiniteType k R] (D : Derivation k R R) :
+    ∃ J : ℤ, ∀ j, component G D j ≠ 0 → j ≤ J := by
+  classical
+  obtain ⟨s, hs, hg⟩ := homogeneous_generators G
+  choose deg hdeg using fun r : s => hg r r.2
+  choose bound hbound using fun r : s => exists_filtration G (D r)
+  have hfinite : (Set.range (fun r : s => bound r - deg r)).Finite := Set.finite_range _
+  obtain ⟨J, hJ⟩ := hfinite.bddAbove
+  refine ⟨J, ?_⟩
+  intro j hj
+  by_contra h
+  apply hj
+  apply Derivation.ext_of_adjoin_eq_top (s : Set R) hs
+  intro r hr
+  have hbound' := hJ (Set.mem_range_self (⟨r, hr⟩ : s))
+  rw [component_of_mem G D j (hdeg ⟨r, hr⟩)]
+  exact proj_filtration G (hbound ⟨r, hr⟩) (by omega)
+
+/-- Every nonzero locally nilpotent derivation of a finite type graded algebra
+has a nonzero highest component, itself locally nilpotent. -/
+theorem highest [Algebra.FiniteType k R] (D : Derivation k R R) (hD : D ≠ 0)
+    (hln : ∀ r : R, ∃ n : ℕ, (D : R → R)^[n] r = 0) :
+    ∃ j, component G D j ≠ 0 ∧ ShiftBound G D j ∧
+      ∀ r : R, ∃ n : ℕ, (component G D j : R → R)^[n] r = 0 := by
+  obtain ⟨j, hj, hmax⟩ := Int.exists_greatest_of_bdd
+    (component_bounded G D) (component_exists G hD)
+  have hb : ShiftBound G D j := shiftBound_of_components G (by
+    intro e he
+    by_contra h
+    exact (not_le_of_gt he) (hmax e h))
+  exact ⟨j, hj, hb, component_locallyNilpotent G hb hln⟩
+
+end ComplexCancellation.GradedLND
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/AffineCancellation/GradedMap.lean b/lean/OAI/Algebra/AffineCancellation/GradedMap.lean
new file mode 100644
index 0000000000000000000000000000000000000000..097a0fe7695c2076b04398d4fc419891700afcee
--- /dev/null
+++ b/lean/OAI/Algebra/AffineCancellation/GradedMap.lean
@@ -0,0 +1,55 @@
+import OAI.Algebra.AffineCancellation.Model
+
+namespace OAI
+
+noncomputable section
+
+namespace ComplexCancellation.GradedMap
+open MvPolynomial
+variable {k R S : Type*} [CommRing k] [CommRing R] [CommRing S]
+  [Algebra k R] [Algebra k S]
+lemma mvpolynomial {ι : Type*} (G : ℤ → Submodule k R) [GradedAlgebra G]
+    (w : ι → ℤ) (f : MvPolynomial ι k →ₐ[k] R)
+    (hX : ∀ i, f (X i) ∈ G (w i)) {p : MvPolynomial ι k} {e : ℤ}
+    (hp : IsWeightedHomogeneous w p e) : f p ∈ G e := by
+  classical
+  induction hp using IsWeightedHomogeneous.induction_on with
+  | zero => rw [map_zero]; exact (G e).zero_mem
+  | add p q hp hq ihp ihq => rw [map_add]; exact add_mem ihp ihq
+  | monomial d a hd =>
+    rw [monomial_eq,map_mul,MvPolynomial.C_eq_algebraMap,AlgHom.commutes,← Algebra.smul_def]
+    apply (G e).smul_mem
+    rw [Finsupp.prod,map_prod]
+    simp only [map_pow]
+    have ht := SetLike.prod_pow_mem_graded G w (fun i => f (X i)) (F := d.support) (fun i => d i) (fun i _ => hX i)
+    convert ht using 1
+    rw [← hd,Finsupp.weight_apply,Finsupp.sum]
+
+lemma projection (G : ℤ → Submodule k R) (H : ℤ → Submodule k S)
+    [GradedAlgebra G] [GradedAlgebra H] (f : R →ₐ[k] S)
+    (hf : ∀ e r, r ∈ G e → f r ∈ H e) (e : ℤ) (r : R) :
+    f (GradedAlgebra.proj G e r)=GradedAlgebra.proj H e (f r) := by
+  induction r using DirectSum.Decomposition.inductionOn G with
+  | zero => simp only [map_zero]
+  | @homogeneous i r =>
+    by_cases hi : i=e
+    · subst i
+      rw [show GradedAlgebra.proj G e (r : R)=r from DirectSum.decompose_of_mem_same G r.2,
+        show GradedAlgebra.proj H e (f r)=f r from DirectSum.decompose_of_mem_same H (hf e r r.2)]
+    · rw [show GradedAlgebra.proj G e (r : R)=0 from DirectSum.decompose_of_mem_ne G r.2 hi,
+        show GradedAlgebra.proj H e (f r)=0 from DirectSum.decompose_of_mem_ne H (hf i r r.2) hi,map_zero]
+  | add r s hr hs => simp only [map_add,hr,hs]
+lemma reflect (G : ℤ → Submodule k R) (H : ℤ → Submodule k S)
+    [GradedAlgebra G] [GradedAlgebra H] (f : R →ₐ[k] S)
+    (hf : Function.Injective f) (hm : ∀ e r, r ∈ G e → f r ∈ H e)
+    {e : ℤ} {r : R} (hr : f r ∈ H e) : r ∈ G e := by
+  have he : GradedAlgebra.proj G e r=r := by
+    apply hf
+    rw [projection G H f hm,show GradedAlgebra.proj H e (f r)=f r from DirectSum.decompose_of_mem_same H hr]
+  rw [← he]
+  exact (DirectSum.decompose G r e).property
+end ComplexCancellation.GradedMap
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/AffineCancellation/HighestWeight.lean b/lean/OAI/Algebra/AffineCancellation/HighestWeight.lean
new file mode 100644
index 0000000000000000000000000000000000000000..714b1c647c8e5995d11f83627b2f3ca15638cfc8
--- /dev/null
+++ b/lean/OAI/Algebra/AffineCancellation/HighestWeight.lean
@@ -0,0 +1,66 @@
+import OAI.Algebra.AffineCancellation.Model
+
+namespace OAI
+
+noncomputable section
+
+namespace ComplexCancellation.SL2
+variable {R : Type*} [AddCommGroup R] [Module ℂ R]
+
+/-- A highest weight vector in a locally finite sl₂ representation has nonnegative
+weight. Only local nilpotence of the lowering operator on this vector is needed. -/
+lemma no_negative_highest (δ η H : R →ₗ[ℂ] R)
+    (hcomm : ∀ r, δ (η r) - η (δ r) = H r)
+    (hlower : ∀ r, H (η r) = η (H r) - (2 : ℂ) • η r)
+    (r : R) (w : ℤ) (hw : w < 0) (hδ : δ r = 0)
+    (hH : H r = (w : ℂ) • r) (hη : ∃ n : ℕ, (η : R → R)^[n] r = 0) : r = 0 := by
+  have hweight : ∀ n : ℕ, H ((η : R → R)^[n] r) =
+      ((w : ℂ) - 2 * n) • ((η : R → R)^[n] r) := by
+    intro n
+    induction n with
+    | zero => simpa using hH
+    | succ n ih =>
+      rw [Function.iterate_succ_apply', hlower, ih, map_smul]
+      rw [← sub_smul]
+      congr 1
+      push_cast
+      ring
+  have hraise : ∀ n : ℕ, δ ((η : R → R)^[n+1] r) =
+      (((n+1 : ℕ) : ℂ) * ((w : ℂ) - n)) • ((η : R → R)^[n] r) := by
+    intro n
+    induction n with
+    | zero =>
+      have hh := hcomm r
+      simpa [hδ, hH] using (sub_eq_iff_eq_add.mp hh)
+    | succ n ih =>
+      rw [Function.iterate_succ_apply', sub_eq_iff_eq_add.mp (hcomm _)]
+      rw [hweight, ih, map_smul]
+      rw [← Function.iterate_succ_apply' η n r, ← add_smul]
+      congr 1
+      push_cast
+      ring
+  by_contra hr
+  obtain ⟨n, hn⟩ := hη
+  have nz : ∀ n : ℕ, (η : R → R)^[n] r ≠ 0 := by
+    intro n
+    induction n with
+    | zero => simpa using hr
+    | succ n ih =>
+      intro hh
+      have he := hraise n
+      rw [hh, map_zero] at he
+      have hc : ((↑(n+1) : ℂ) * ((w : ℂ) - n)) ≠ 0 := by
+        apply mul_ne_zero
+        · exact_mod_cast Nat.succ_ne_zero n
+        · intro hh
+          have hw' : (w : ℂ) = (n : ℂ) := sub_eq_zero.mp hh
+          have heq : w = (n : ℤ) := by exact_mod_cast hw'
+          omega
+      exact ih ((smul_eq_zero.mp he.symm).resolve_left hc)
+  exact nz n hn
+
+end ComplexCancellation.SL2
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/AffineCancellation/HomogeneousExtraction.lean b/lean/OAI/Algebra/AffineCancellation/HomogeneousExtraction.lean
new file mode 100644
index 0000000000000000000000000000000000000000..a3f029978d0998c09dcfe05d54ab450d1cf44742
--- /dev/null
+++ b/lean/OAI/Algebra/AffineCancellation/HomogeneousExtraction.lean
@@ -0,0 +1,130 @@
+import OAI.Algebra.AffineCancellation.FactorDerivation
+import OAI.Algebra.AffineCancellation.Order
+import OAI.Algebra.AffineCancellation.Extraction
+
+namespace OAI
+
+noncomputable section
+
+namespace ComplexCancellation.AffineModification
+open MvPolynomial
+variable {k R : Type*} [Field k] [CharZero k] [CommRing R] [IsDomain R] [Algebra k R]
+variable (v : R) (hv : v ≠ 0)
+include hv
+
+omit [CharZero k] in
+lemma euler_factor (H : Derivation k R R) (hH : H v=2*v)
+    (D : Derivation k (T R v) (T R v))
+    (hcomm : ∀ z, euler v H hH (D z)=D (euler v H hH z))
+    (E : Derivation k R R) (c : T R v) (hc : c ≠ 0) (n : ℕ)
+    (hcn : euler v H hH c=n • c)
+    (hspec : ∀ r, D (coefficientHom (k := k) v r)=c*coefficientHom (k := k) v (E r)) :
+    ∀ r, H (E r)-E (H r)=-(n • E r) := by
+  let := isDomain R v hv
+  intro r
+  apply coefficientHom_injective (k := k) v
+  apply mul_left_cancel₀ hc
+  have he := hcomm (coefficientHom (k := k) v r)
+  rw [hspec,euler_coefficient,hspec,Derivation.leibniz,euler_coefficient,hcn] at he
+  simp only [map_sub,map_neg,smul_eq_mul,nsmul_eq_mul,map_mul,map_natCast] at he ⊢
+  linear_combination he
+
+lemma fixed_τ_of_fixed_v (D : Derivation k (T R v) (T R v))
+    (hD : LND.LocallyNilpotent D) (h : D (coefficientHom (k := k) v v)=0) : D (τ R v)=0 := by
+  let := isDomain R v hv
+  have hnτ := τ_nonzero v
+  have hnV := V_nonzero v hv
+  apply (LND.kernel_factorially_closed D hD hnτ (mul_ne_zero hnτ hnV) _).1
+  have he : τ R v*(τ R v*V R v)=coefficientHom (k := k) v v := by
+    change τ R v*(τ R v*V R v)=algebraMap R (T R v) v
+    simpa only [pow_two,mul_assoc] using equation R v
+  rwa [he]
+
+lemma coefficient_order (D : Derivation k (T R v) (T R v))
+    (hD : LND.LocallyNilpotent D) (hV : D (V R v)=0) :
+    LND.order D hD (coefficientHom (k := k) v v)=2*LND.order D hD (τ R v) := by
+  let := isDomain R v hv
+  have h₀ := (LND.order_zero_iff D hD (V R v)).mpr hV
+  change LND.order D hD (algebraMap R (T R v) v)=_
+  rw [← equation R v,pow_two,
+    LND.order_mul D hD (mul_ne_zero (τ_nonzero v) (τ_nonzero v)) (V_nonzero v hv),
+    LND.order_mul D hD (τ_nonzero v) (τ_nonzero v),h₀]
+  omega
+
+lemma order_monomial_fixed_V (D : Derivation k (T R v) (T R v))
+    (hD : LND.LocallyNilpotent D) (hV : D (V R v)=0) (n : ℕ) :
+    LND.order D hD (τ R v*V R v^n)=LND.order D hD (τ R v) := by
+  let := isDomain R v hv
+  rw [LND.order_mul D hD (τ_nonzero v) (pow_ne_zero _ (V_nonzero v hv))]
+  have he : D (V R v^n)=0 := by simp [Derivation.leibniz_pow,hV]
+  rw [(LND.order_zero_iff D hD _).mpr he,add_zero]
+
+/-- Extraction of a coefficient derivation without assuming invariance of the coefficient ring. -/
+theorem extract (H : Derivation k R R) (hH : H v=2*v)
+    (D : Derivation k (T R v) (T R v)) (hD : LND.LocallyNilpotent D) (hDn : D ≠ 0)
+    (j : ℤ) (hshift : ∀ e r, r ∈ pieces R v e → D r ∈ pieces R v (e+j))
+    (hcomm : ∀ z, euler v H hH (D z)=D (euler v H hH z))
+    (hV : D (V R v)=0) :
+    ∃ (E : Derivation k R R) (n : ℕ), E ≠ 0 ∧ LND.LocallyNilpotent E ∧
+      (∀ r, H (E r)-E (H r)=-(n • E r)) ∧ E (E v)=0 := by
+  let := isDomain R v hv
+  let f := coefficientHom (k := k) v
+  have hf : Function.Injective f := coefficientHom_injective v
+  have hcoeff (r : R) : D (f r) ∈ pieces R v j := by
+    simpa only [zero_add] using hshift 0 (f r) (coefficient_mem R v r)
+  by_cases ht : D (τ R v)=0
+  · obtain ⟨i,h,hpiece⟩ := piece_monomial R v j
+    let c := τ R v^i*V R v^h
+    have hc : c ≠ 0 := mul_ne_zero (pow_ne_zero _ (τ_nonzero v)) (pow_ne_zero _ (V_nonzero v hv))
+    have hspec : ∀ r : R, ∃ s : R, D (f r)=c*f s := fun r => hpiece _ (hcoeff r)
+    let E := FactorDerivation.derivation f hf D c hc hspec
+    have he (r : R) : D (f r)=c*f (E r) := FactorDerivation.apply_spec f hf D c hc hspec r
+    have hEv : E v=0 := by
+      apply hf
+      apply mul_left_cancel₀ hc
+      rw [map_zero,mul_zero,← he]
+      change D (algebraMap R (T R v) v)=0
+      rw [← equation R v]
+      simp [Derivation.leibniz,Derivation.leibniz_pow,ht,hV]
+    refine ⟨E,2*h,?_,LND.cancel_factor_locallyNilpotent f hf D hD E hc he,?_,?_⟩
+    · intro hE
+      apply hDn
+      apply derivation_zero_of_generators v D _ ht hV
+      intro r
+      rw [he,hE,Derivation.zero_apply,map_zero,mul_zero]
+    · apply euler_factor v hv H hH D hcomm E c hc (2*h) _ he
+      simpa only [nsmul_eq_mul] using euler_monomial v H hH i h
+    · rw [hEv,map_zero]
+  · have hnt : ¬τ R v ∣ D (τ R v) := fun he => ht (LND.fixed_of_dvd D hD he)
+    obtain ⟨l,hl⟩ := degree_even_of_not_τ_dvd R v (hshift (-1) _ (τ_mem R v)) hnt
+    have hj : j=2*(l:ℤ)+1 := by omega
+    have hspec : ∀ r : R, ∃ s : R, D (f r)=(τ R v*V R v^(l+1))*f s := by
+      intro r
+      exact piece_odd R v l (hj ▸ hcoeff r)
+    let c := τ R v*V R v^(l+1)
+    have hc : c ≠ 0 := mul_ne_zero (τ_nonzero v) (pow_ne_zero _ (V_nonzero v hv))
+    let E := FactorDerivation.derivation f hf D c hc hspec
+    have he (r : R) : D (f r)=c*f (E r) := FactorDerivation.apply_spec f hf D c hc hspec r
+    refine ⟨E,2*(l+1),?_,LND.cancel_factor_locallyNilpotent f hf D hD E hc he,?_,?_⟩
+    · intro hE
+      apply ht
+      apply fixed_τ_of_fixed_v v hv D hD
+      rw [he,hE,Derivation.zero_apply,map_zero,mul_zero]
+    · apply euler_factor v hv H hH D hcomm E c hc (2*(l+1)) _ he
+      simpa only [pow_one,nsmul_eq_mul] using euler_monomial v H hH 1 (l+1)
+    · apply LND.cancel_factor_square_zero f hf D hD E hc he v
+      rw [coefficient_order v hv D hD hV,order_monomial_fixed_V v hv D hD hV]
+lemma fixed_V_of_positive_invariant
+    (D : Derivation k (T R v) (T R v)) (hD : LND.LocallyNilpotent D)
+    (w : T R v) (hw : w ≠ 0) (e : ℤ) (he : 0 < e)
+    (hwg : w ∈ pieces R v e) (hDw : D w=0) : D (V R v)=0 := by
+  let := isDomain R v hv
+  obtain ⟨z,hz⟩ := V_dvd_of_positive R v he hwg
+  have hzn : z ≠ 0 := by intro he; rw [he,mul_zero] at hz; exact hw hz
+  apply (LND.kernel_factorially_closed D hD (V_nonzero v hv) hzn _).1
+  rwa [← hz]
+end ComplexCancellation.AffineModification
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/AffineCancellation/Intertwining.lean b/lean/OAI/Algebra/AffineCancellation/Intertwining.lean
new file mode 100644
index 0000000000000000000000000000000000000000..ee1cfb0d940a43f182c941856655459f6a2048c8
--- /dev/null
+++ b/lean/OAI/Algebra/AffineCancellation/Intertwining.lean
@@ -0,0 +1,38 @@
+import OAI.Algebra.AffineCancellation.Model
+
+namespace OAI
+
+noncomputable section
+
+namespace ComplexCancellation.DerivationIntertwining
+variable {k R S : Type*} [CommRing k] [CommRing R] [CommRing S] [Algebra k R] [Algebra k S]
+def subalgebra (f : R →ₐ[k] S) (D : Derivation k R R) (E : Derivation k S S) : Subalgebra k R where
+  carrier := {r | E (f r)=f (D r)}
+  algebraMap_mem' a := by
+    change E (f (algebraMap k R a))=f (D (algebraMap k R a))
+    rw [f.commutes,E.map_algebraMap,D.map_algebraMap,map_zero]
+  add_mem' := by
+    intro r s hr hs
+    change E (f r)=f (D r) at hr
+    change E (f s)=f (D s) at hs
+    change E (f (r+s))=f (D (r+s))
+    rw [map_add,map_add,hr,hs,map_add,map_add]
+  mul_mem' := by
+    intro r s hr hs
+    change E (f r)=f (D r) at hr
+    change E (f s)=f (D s) at hs
+    change E (f (r*s))=f (D (r*s))
+    rw [map_mul,Derivation.leibniz,Derivation.leibniz,hr,hs,smul_eq_mul,smul_eq_mul,smul_eq_mul,smul_eq_mul,map_add,map_mul,map_mul]
+lemma mvPolynomial (f : R →ₐ[k] S) (D : Derivation k R R) (E : Derivation k S S)
+    {ι : Type*} (q : MvPolynomial ι k →ₐ[k] R) (p : MvPolynomial ι k)
+    (hX : ∀ i, E (f (q (MvPolynomial.X i)))=f (D (q (MvPolynomial.X i)))) : E (f (q p))=f (D (q p)) := by
+  change q p ∈ subalgebra f D E
+  induction p using MvPolynomial.induction_on with
+  | C c => rw [MvPolynomial.C_eq_algebraMap,q.commutes]; exact (subalgebra f D E).algebraMap_mem c
+  | add r s hr hs => rw [map_add]; exact add_mem hr hs
+  | mul_X r i hr => rw [map_mul]; exact mul_mem hr (hX i)
+end ComplexCancellation.DerivationIntertwining
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/AffineCancellation/InvariantRestriction.lean b/lean/OAI/Algebra/AffineCancellation/InvariantRestriction.lean
new file mode 100644
index 0000000000000000000000000000000000000000..6b01958cbc82d0eb7f0499fff2bad4f114536b61
--- /dev/null
+++ b/lean/OAI/Algebra/AffineCancellation/InvariantRestriction.lean
@@ -0,0 +1,38 @@
+import OAI.Algebra.AffineCancellation.PositiveInvariant
+import OAI.Algebra.AffineCancellation.RelativeClearing
+
+namespace OAI
+
+noncomputable section
+
+namespace ComplexCancellation.InvariantRestriction
+variable {k A B R : Type*} [Field k] [CharZero k] [CommRing A] [IsDomain A]
+  [CommRing B] [CommRing R] [IsDomain R] [Algebra k A] [Algebra k B] [Algebra k R]
+lemma stable_restrict (f : B →ₐ[k] R) (hf : Function.Injective f) (E : Derivation k R R)
+    (hE : LND.LocallyNilpotent E) (hs : ∀ b, ∃ t, E (f b)=f t) :
+    ∃ D : Derivation k B B, LND.LocallyNilpotent D ∧ ∀ b, E (f b)=f (D b) := by
+  have he : ∀ b, ∃ t, E (f b)=1*f t := by simpa only [one_mul] using hs
+  let D := FactorDerivation.derivation f hf E 1 one_ne_zero he
+  have hspec (b : B) : E (f b)=f (D b) := by
+    simpa only [one_mul] using FactorDerivation.apply_spec f hf E 1 one_ne_zero he b
+  exact ⟨D,LND.cancel_factor_locallyNilpotent f hf E hE D one_ne_zero (by simpa only [one_mul] using hspec),hspec⟩
+lemma exists_restriction [Algebra.FiniteType k B]
+    (h : A →ₐ[k] B) (f : B →ₐ[k] R) (hf : Function.Injective f)
+    (D : Derivation k A A) (E : Derivation k R R) (hE : LND.LocallyNilpotent E)
+    (he : ∀ a, E (f (h a))=f (h (D a)))
+    (hc : ∀ r, r ∈ RelativeClearing.subalgebra h f D) :
+    ∃ c : A, ∃ E' : Derivation k B B, D c=0 ∧ c≠0 ∧ LND.LocallyNilpotent E' ∧
+      ∀ b, f (E' b)=f (h c)*E (f b) := by
+  obtain ⟨s,hs⟩ := Algebra.FiniteType.out (R := k) (A := B)
+  obtain ⟨c,hDc,hcn,hgen⟩ := RelativeClearing.uniform h f D s E (fun _ => hc _)
+  let E₀ := f (h c) • E
+  have hE₀ : LND.LocallyNilpotent E₀ := LND.replica E hE _ (by rw [he,hDc,map_zero,map_zero])
+  have hstable : ∀ b, ∃ t, E₀ (f b)=f t :=
+    DerivationRange.stable_of_generators f E₀ (s : Set B) hs hgen
+  obtain ⟨E',hE',hspec⟩ := stable_restrict f hf E₀ hE₀ hstable
+  exact ⟨c,E',hDc,hcn,hE',fun b => (hspec b).symm⟩
+end ComplexCancellation.InvariantRestriction
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/AffineCancellation/Kernel.lean b/lean/OAI/Algebra/AffineCancellation/Kernel.lean
new file mode 100644
index 0000000000000000000000000000000000000000..013e30f56dd6212d8f5e07238fd30ede1d4af126
--- /dev/null
+++ b/lean/OAI/Algebra/AffineCancellation/Kernel.lean
@@ -0,0 +1,125 @@
+import OAI.Algebra.AffineCancellation.OrbitRigidity
+
+namespace OAI
+
+noncomputable section
+
+namespace ComplexCancellation.LND
+open Polynomial
+variable {k R : Type*} [Field k] [CharZero k] [CommRing R] [Algebra k R]
+
+lemma inv_factorial_succ (n : ℕ) :
+    ((n + 1 : ℕ) : k) * ((n + 1).factorial : k)⁻¹ = (n.factorial : k)⁻¹ := by
+  rw [Nat.factorial_succ, Nat.cast_mul, mul_inv_rev]
+  have hn : ((n + 1 : ℕ) : k) ≠ 0 := Nat.cast_ne_zero.mpr (by omega)
+  field_simp
+
+lemma derivative_orbit (D : Derivation k R R) (hD : LocallyNilpotent D) (r : R) :
+    (orbit D hD r).derivative = orbit D hD (D r) := by
+  ext n
+  rw [Polynomial.coeff_derivative, orbit_coeff, orbit_coeff,
+    ← Function.iterate_succ_apply]
+  rw [mul_comm, ← Nat.cast_succ, ← nsmul_eq_mul, ← Nat.cast_smul_eq_nsmul k, smul_smul,
+    inv_factorial_succ]
+
+lemma kernel_factorially_closed [IsDomain R] (D : Derivation k R R)
+    (hD : LocallyNilpotent D) {r s : R} (hr : r ≠ 0) (hs : s ≠ 0)
+    (hrs : D (r * s) = 0) : D r = 0 ∧ D s = 0 := by
+  have hor : orbit D hD r ≠ 0 := by
+    intro h
+    have := congrArg (fun p : R[X] => p.coeff 0) h
+    simp at this
+    exact hr this
+  have hos : orbit D hD s ≠ 0 := by
+    intro h
+    have := congrArg (fun p : R[X] => p.coeff 0) h
+    simp at this
+    exact hs this
+  have hp := (orbit_constant_iff D hD (r*s)).mpr hrs
+  rw [orbit_mul] at hp
+  have hn := congrArg Polynomial.natDegree hp
+  rw [natDegree_mul hor hos, natDegree_C] at hn
+  have hnr : (orbit D hD r).natDegree = 0 := by omega
+  have hns : (orbit D hD s).natDegree = 0 := by omega
+  constructor
+  · apply (orbit_constant_iff D hD r).mp
+    simpa using eq_C_of_natDegree_eq_zero hnr
+  · apply (orbit_constant_iff D hD s).mp
+    simpa using eq_C_of_natDegree_eq_zero hns
+
+end ComplexCancellation.LND
+namespace ComplexCancellation.LND
+open Polynomial
+variable {k R : Type*} [Field k] [CharZero k] [CommRing R] [Algebra k R] [IsDomain R]
+
+lemma fixed_of_dvd (D : Derivation k R R) (hD : LocallyNilpotent D)
+    {r : R} (hr : r ∣ D r) : D r = 0 := by
+  obtain ⟨s, hs⟩ := hr
+  have hdvd : orbit D hD r ∣ (orbit D hD r).derivative := by
+    rw [derivative_orbit, hs, orbit_mul]
+    exact dvd_mul_right _ _
+  have hz := Polynomial.dvd_derivative_iff.mp hdvd
+  rw [derivative_orbit] at hz
+  apply orbit_injective D hD
+  change orbitHom D hD (D r) = orbitHom D hD 0
+  rw [map_zero]
+  exact hz
+
+lemma polynomial_dX_constant (D : Derivation k k[X] k[X]) (hD : LocallyNilpotent D) :
+    D X = C ((D X).coeff 0) := by
+  have hformula (f : k[X]) : D f = f.derivative * D X := by
+    have he : Polynomial.mkDerivation k (D X) = D := by ext; simp
+    calc D f = Polynomial.mkDerivation k (D X) f := congrArg (fun E : Derivation k k[X] k[X] => E f) he.symm
+      _ = _ := by simp [Polynomial.mkDerivation_apply, smul_eq_mul]
+  have hzero : D (D X) = 0 := fixed_of_dvd D hD (by
+    rw [hformula (D X)]; exact dvd_mul_left _ _)
+  by_cases hx : D X = 0
+  · simp [hx]
+  · have hp : (D X).derivative = 0 := by
+      rw [hformula, mul_eq_zero] at hzero
+      exact hzero.resolve_right hx
+    exact Polynomial.eq_C_of_natDegree_eq_zero (Polynomial.derivative_eq_zero.mp hp)
+
+end ComplexCancellation.LND
+
+namespace ComplexCancellation.LND
+variable {k R : Type*} [Field k] [CommRing R] [Algebra k R]
+
+lemma nilpotent_add (D : Derivation k R R) {r s : R}
+    (hr : ∃ n, (D : R → R)^[n] r = 0) (hs : ∃ n, (D : R → R)^[n] s = 0) :
+    ∃ n, (D : R → R)^[n] (r+s) = 0 := by
+  obtain ⟨n, hn⟩ := hr
+  obtain ⟨m, hm⟩ := hs
+  refine ⟨n+m, ?_⟩
+  rw [iterate_add, iterate_eq_zero_of_le D hn (Nat.le_add_right _ _),
+    iterate_eq_zero_of_le D hm (Nat.le_add_left _ _), add_zero]
+
+lemma nilpotent_mul (D : Derivation k R R) {r s : R}
+    (hr : ∃ n, (D : R → R)^[n] r = 0) (hs : ∃ n, (D : R → R)^[n] s = 0) :
+    ∃ n, (D : R → R)^[n] (r*s) = 0 := by
+  obtain ⟨n, hn⟩ := hr
+  obtain ⟨m, hm⟩ := hs
+  refine ⟨n+m, ?_⟩
+  rw [iterate_leibniz]
+  apply Finset.sum_eq_zero
+  rintro ⟨i,j⟩ hij
+  have hij' : i+j = n+m := Finset.HasAntidiagonal.mem_antidiagonal.mp hij
+  by_cases hi : n ≤ i
+  · rw [iterate_eq_zero_of_le D hn hi, zero_mul, nsmul_zero]
+  · rw [iterate_eq_zero_of_le D hm (by omega : m ≤ j), mul_zero, nsmul_zero]
+
+lemma mvPolynomial_locallyNilpotent {σ : Type*}
+    (D : Derivation k (MvPolynomial σ k) (MvPolynomial σ k))
+    (hX : ∀ i, ∃ n : ℕ, (D : _ → _)^[n] (MvPolynomial.X i) = 0) :
+    LocallyNilpotent D := by
+  intro r
+  induction r using MvPolynomial.induction_on with
+  | C c => exact ⟨1, by simp⟩
+  | add r s hr hs => exact nilpotent_add D hr hs
+  | mul_X r i hr => exact nilpotent_mul D hr (hX i)
+
+end ComplexCancellation.LND
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/AffineCancellation/LaurentDerivation.lean b/lean/OAI/Algebra/AffineCancellation/LaurentDerivation.lean
new file mode 100644
index 0000000000000000000000000000000000000000..5e750825e9dea4c6b3b0b56509d6be5a64519895
--- /dev/null
+++ b/lean/OAI/Algebra/AffineCancellation/LaurentDerivation.lean
@@ -0,0 +1,71 @@
+import OAI.Algebra.AffineCancellation.Model
+
+namespace OAI
+
+noncomputable section
+
+namespace ComplexCancellation.LaurentDerivation
+open LaurentPolynomial
+variable {k R : Type*} [CommRing k] [CommRing R] [Algebra k R]
+def linear (D : Derivation k R R) : LaurentPolynomial R →ₗ[k] LaurentPolynomial R :=
+  (AddMonoidAlgebra.coeffLinearEquiv k).symm.toLinearMap ∘ₗ
+    Finsupp.mapRange.linearMap D.toLinearMap ∘ₗ (AddMonoidAlgebra.coeffLinearEquiv k).toLinearMap
+@[simp] lemma linear_single (D : Derivation k R R) (n : ℤ) (r : R) :
+    linear D (C r*T n)=C (D r)*T n := by
+  rw [← single_eq_C_mul_T,← single_eq_C_mul_T]
+  apply AddMonoidAlgebra.coeff_injective
+  change Finsupp.mapRange D (map_zero D) (Finsupp.single n r)=Finsupp.single n (D r)
+  exact Finsupp.mapRange_single
+lemma linear_mul (D : Derivation k R R) (r s : LaurentPolynomial R) :
+    linear D (r*s)=r*linear D s+s*linear D r := by
+  induction r using LaurentPolynomial.induction_on' with
+  | add r s hr hs => simp only [add_mul,map_add,hr,hs]; ring
+  | C_mul_T n a =>
+    induction s using LaurentPolynomial.induction_on' with
+    | add r s hr hs => simp only [mul_add,map_add,hr,hs]; ring
+    | C_mul_T m b =>
+      have he : C a*T n*(C b*T m)=C (a*b)*T (n+m) := by rw [map_mul,T_add]; ring
+      rw [he,linear_single,linear_single,linear_single,Derivation.leibniz,
+        map_add,smul_eq_mul,smul_eq_mul,map_mul,map_mul,T_add]
+      ring
+
+def extension (D : Derivation k R R) : Derivation k (LaurentPolynomial R) (LaurentPolynomial R) :=
+  Derivation.mk' (linear D) (by intro r s; exact linear_mul D r s)
+@[simp] lemma extension_monomial (D : Derivation k R R) (n : ℤ) (r : R) :
+    extension D (C r*T n)=C (D r)*T n := linear_single D n r
+@[simp] lemma extension_C (D : Derivation k R R) (r : R) : extension D (C r)=C (D r) := by
+  simpa using extension_monomial D 0 r
+@[simp] lemma extension_T (D : Derivation k R R) (n : ℤ) : extension D (T n)=0 := by
+  simpa using extension_monomial D n 1
+lemma iterate_monomial (D : Derivation k R R) (n : ℤ) (r : R) (i : ℕ) :
+    (extension D : LaurentPolynomial R → LaurentPolynomial R)^[i] (C r*T n)=
+      C ((D : R → R)^[i] r)*T n := by
+  induction i with
+  | zero => rfl
+  | succ i ih => rw [Function.iterate_succ_apply',ih,extension_monomial,Function.iterate_succ_apply']
+lemma locallyNilpotent (D : Derivation k R R)
+    (hD : ∀ r : R, ∃ n, (D : R → R)^[n] r=0) :
+    ∀ p : LaurentPolynomial R, ∃ n,
+      (extension D : LaurentPolynomial R → LaurentPolynomial R)^[n] p=0 := by
+  intro p
+  induction p using LaurentPolynomial.induction_on' with
+  | add p q hp hq =>
+    obtain ⟨n,hn⟩ := hp
+    obtain ⟨m,hm⟩ := hq
+    refine ⟨n+m,?_⟩
+    have hp' : (extension D : LaurentPolynomial R → LaurentPolynomial R)^[n+m] p=0 := by
+      rw [Nat.add_comm,Function.iterate_add_apply,hn]
+      simpa only [Module.End.pow_apply, Derivation.coeFn_coe] using ((extension D).toLinearMap ^ m).map_zero
+    have hq' : (extension D : LaurentPolynomial R → LaurentPolynomial R)^[n+m] q=0 := by
+      rw [Function.iterate_add_apply,hm]
+      simpa only [Module.End.pow_apply, Derivation.coeFn_coe] using ((extension D).toLinearMap ^ n).map_zero
+    have he := ((extension D).toLinearMap ^ (n+m)).map_add p q
+    simpa only [Module.End.pow_apply, Derivation.coeFn_coe,hp',hq',add_zero] using he
+  | C_mul_T n r =>
+    obtain ⟨m,hm⟩ := hD r
+    exact ⟨m,by rw [iterate_monomial,hm,map_zero,zero_mul]⟩
+end ComplexCancellation.LaurentDerivation
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/AffineCancellation/LaurentEuler.lean b/lean/OAI/Algebra/AffineCancellation/LaurentEuler.lean
new file mode 100644
index 0000000000000000000000000000000000000000..e3feb122259f1bdc0ea77c2d08d15c059fdcd075
--- /dev/null
+++ b/lean/OAI/Algebra/AffineCancellation/LaurentEuler.lean
@@ -0,0 +1,52 @@
+import OAI.Algebra.AffineCancellation.LaurentDerivation
+
+namespace OAI
+
+noncomputable section
+
+namespace ComplexCancellation.LaurentEuler
+open LaurentPolynomial
+variable {k R : Type*} [CommRing k] [CommRing R] [Algebra k R]
+def linear : LaurentPolynomial R →ₗ[k] LaurentPolynomial R :=
+  (Finsupp.lsum k (fun n : ℤ => n • (AddMonoidAlgebra.lsingle n : R →ₗ[k] LaurentPolynomial R))) ∘ₗ
+    (AddMonoidAlgebra.coeffLinearEquiv k).toLinearMap
+lemma linear_single (n : ℤ) (r : R) : linear (k := k) (C r*T n)=n • (C r*T n) := by
+  rw [← single_eq_C_mul_T]
+  change Finsupp.lsum k _ (Finsupp.single n r)=_
+  rw [Finsupp.lsum_single]
+  rfl
+lemma linear_mul (r s : LaurentPolynomial R) :
+    linear (k := k) (r*s)=r*linear (k := k) s+s*linear (k := k) r := by
+  induction r using LaurentPolynomial.induction_on' with
+  | add r s hr hs => simp only [add_mul,map_add,hr,hs]; ring
+  | C_mul_T n a =>
+    induction s using LaurentPolynomial.induction_on' with
+    | add r s hr hs => simp only [mul_add,map_add,hr,hs]; ring
+    | C_mul_T m b =>
+      have he : C a*T n*(C b*T m)=C (a*b)*T (n+m) := by rw [map_mul,T_add]; ring
+      rw [he,linear_single,linear_single,linear_single,← he,add_zsmul]
+      simp only [mul_smul_comm]
+      rw [mul_comm (C b*T m),add_comm]
+def derivation : Derivation k (LaurentPolynomial R) (LaurentPolynomial R) :=
+  Derivation.mk' linear (by intro r s; exact linear_mul r s)
+@[simp] lemma monomial (n : ℤ) (r : R) : derivation (k := k) (C r*T n)=n • (C r*T n) := linear_single n r
+@[simp] lemma coefficient (r : R) : derivation (k := k) (C r)=0 := by simpa using monomial (k := k) 0 r
+@[simp] lemma T_apply (n : ℤ) : derivation (k := k) (T n : LaurentPolynomial R)=n • T n := by simpa using monomial (k := k) n (1 : R)
+end ComplexCancellation.LaurentEuler
+
+namespace ComplexCancellation.LaurentEuler
+open LaurentPolynomial
+variable {k R : Type*} [CommRing k] [CommRing R] [Algebra k R]
+lemma commute_extension (D : Derivation k R R) (r : LaurentPolynomial R) :
+    derivation (k := k) (LaurentDerivation.extension D r)=LaurentDerivation.extension D (derivation (k := k) r) := by
+  induction r using LaurentPolynomial.induction_on' with
+  | add r s hr hs => simp only [map_add,hr,hs]
+  | C_mul_T n a => rw [LaurentDerivation.extension_monomial (k := k),monomial (k := k),monomial (k := k),map_zsmul,LaurentDerivation.extension_monomial (k := k)]
+lemma commute_replica (D : Derivation k R R) (c : R) (r : LaurentPolynomial R) :
+    derivation (k := k) (C c*LaurentDerivation.extension D r)=C c*LaurentDerivation.extension D (derivation (k := k) r) := by
+  rw [Derivation.leibniz,coefficient,smul_zero,add_zero,smul_eq_mul,commute_extension]
+end ComplexCancellation.LaurentEuler
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/AffineCancellation/Main.lean b/lean/OAI/Algebra/AffineCancellation/Main.lean
new file mode 100644
index 0000000000000000000000000000000000000000..67e12506920cec027e64ff7118c513e3ac8455e0
--- /dev/null
+++ b/lean/OAI/Algebra/AffineCancellation/Main.lean
@@ -0,0 +1,38 @@
+import OAI.Algebra.AffineCancellation.Dimension
+import OAI.Algebra.AffineCancellation.EquivariantLift
+
+namespace OAI
+
+noncomputable section
+
+namespace ComplexCancellation
+/-- The hypersurface algebra is not a polynomial algebra over ℂ. -/
+theorem nonpolynomiality : ¬ Nonempty (A ≃ₐ[ℂ] MvPolynomial (Fin 4) ℂ) := by
+  rintro ⟨e⟩
+  obtain ⟨i,r,D,hi,hrn,hr,hD,hDn,hDr⟩ := Rees.positive_invariant_of_polynomial e
+  obtain ⟨c,E,hcn,hE,hEn,he,hcomm⟩ := PolynomialTorsor.exists_equivariant_lift D hD hDn
+  let w := Bundle.pullback r
+  have hw : w ≠ 0 := by
+    intro hz
+    apply hrn
+    exact Bundle.pullback_injective (by simpa only [map_zero] using hz)
+  have hwg : w ∈ Bundle.valuationPieces i := Bundle.pullback_graded i r hr
+  have hEw : E w=0 := by rw [he,hDr,mul_zero,map_zero]
+  obtain ⟨j,hjn,_hb,hjln⟩ := GradedLND.highest Bundle.valuationPieces E hEn hE
+  have hcw : GradedLND.component Bundle.valuationPieces E j w=0 := by
+    rw [GradedLND.component_of_mem Bundle.valuationPieces E j hwg,hEw,map_zero]
+  exact Bundle.no_positive_invariant (GradedLND.component Bundle.valuationPieces E j)
+    hjln hjn j
+    (fun _ _ hz => GradedLND.component_homogeneous Bundle.valuationPieces E j hz)
+    (GradedLND.component_commute Bundle.valuationPieces E Bundle.fiberEuler
+      Bundle.fiberEuler_homogeneous hcomm j)
+    w hw i hi hwg hcw
+
+/-- A four-dimensional complex domain with polynomial cylinder, but not itself polynomial. -/
+theorem main : MainStatement :=
+  ⟨finiteType,domain,dimension,stabilization,nonpolynomiality⟩
+end ComplexCancellation
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/AffineCancellation/Model.lean b/lean/OAI/Algebra/AffineCancellation/Model.lean
new file mode 100644
index 0000000000000000000000000000000000000000..2c633efa58fa934eeca8097d12f57b6f9c9fee11
--- /dev/null
+++ b/lean/OAI/Algebra/AffineCancellation/Model.lean
@@ -0,0 +1,29 @@
+import Mathlib
+
+namespace OAI
+
+noncomputable section
+
+namespace ComplexCancellation
+
+abbrev P := MvPolynomial (Fin 5) ℂ
+
+def p : P := MvPolynomial.X 0
+def s : P := MvPolynomial.X 1
+def u : P := MvPolynomial.X 2
+def F : P := MvPolynomial.X 3
+def J : P := MvPolynomial.X 4
+def x : P := s ^ 2 + u ^ 3 + p ^ 2 * F
+def H : P := x ^ 2 * F - (1 + 2 * s * x) * J - p ^ 2 * J ^ 2 - p * u
+abbrev A := P ⧸ Ideal.span {H}
+
+def MainStatement : Prop :=
+  Algebra.FiniteType ℂ A ∧ IsDomain A ∧ ringKrullDim A = 4 ∧
+  Nonempty (Polynomial A ≃ₐ[ℂ] MvPolynomial (Fin 5) ℂ) ∧
+  ¬ Nonempty (A ≃ₐ[ℂ] MvPolynomial (Fin 4) ℂ)
+
+end ComplexCancellation
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/AffineCancellation/Modification.lean b/lean/OAI/Algebra/AffineCancellation/Modification.lean
new file mode 100644
index 0000000000000000000000000000000000000000..7bdd69fef1b4152ee6fa312f1859de5625f7a4dd
--- /dev/null
+++ b/lean/OAI/Algebra/AffineCancellation/Modification.lean
@@ -0,0 +1,99 @@
+import OAI.Algebra.AffineCancellation.Clearing
+import OAI.Algebra.AffineCancellation.DeterminantRigidity
+
+namespace OAI
+
+noncomputable section
+
+namespace ComplexCancellation.AffineModification
+open MvPolynomial
+variable (R : Type*) [CommRing R] [IsDomain R] (v : R)
+
+abbrev P := MvPolynomial (Fin 2) R
+def rel : P R := X 0 ^ 2 * X 1 - C v
+abbrev T := P R ⧸ Ideal.span {rel R v}
+def π : P R →ₐ[R] T R v := Ideal.Quotient.mkₐ R _
+def τ : T R v := π R v (X 0)
+def V : T R v := π R v (X 1)
+
+omit [IsDomain R] in
+lemma equation : τ R v ^ 2 * V R v = algebraMap R (T R v) v := by
+  have h : π R v (rel R v) = 0 := Ideal.Quotient.eq_zero_iff_mem.mpr (Ideal.subset_span (by simp))
+  apply sub_eq_zero.mp
+  simpa only [rel,map_sub,map_mul,map_pow,τ,V,AlgHom.commutes, MvPolynomial.C_eq_algebraMap] using h
+
+abbrev F := FractionRing R
+abbrev K := RatFunc (F R)
+def baseEmbedding : Polynomial R →ₐ[R] K R :=
+  (IsScalarTower.toAlgHom R (Polynomial (F R)) (K R)).comp
+    (Polynomial.mapAlgHom (IsScalarTower.toAlgHom R R (F R)))
+
+lemma baseEmbedding_injective : Function.Injective (baseEmbedding R) :=
+  (RatFunc.algebraMap_injective (F R)).comp
+    (Polynomial.map_injective _ (IsFractionRing.injective R (F R)))
+
+lemma baseEmbedding_X : baseEmbedding R Polynomial.X = RatFunc.X := by
+  change algebraMap (Polynomial (F R)) (K R) (Polynomial.map (algebraMap R (F R)) Polynomial.X) = _
+  rw [Polynomial.map_X,RatFunc.algebraMap_X]
+
+lemma X_nonzero : (RatFunc.X : K R) ≠ 0 := RatFunc.X_ne_zero
+
+def values : Fin 2 → K R := ![RatFunc.X, algebraMap R (K R) v / RatFunc.X^2]
+def eval : P R →ₐ[R] K R := aeval (values R v)
+lemma eval_rel : eval R v (rel R v) = 0 := by
+  simp only [rel,eval,map_sub,map_mul,map_pow,aeval_X,aeval_C,values,
+    Matrix.cons_val_zero,Matrix.cons_val_one]
+  field_simp [X_nonzero R]
+  ring
+
+def embedding : T R v →ₐ[R] K R := Ideal.Quotient.liftₐ _ (eval R v) (by
+  intro r hr
+  obtain ⟨s,rfl⟩ := Ideal.mem_span_singleton.mp hr
+  rw [map_mul,eval_rel,zero_mul])
+
+@[simp] lemma embedding_π (r : P R) : embedding R v (π R v r) = eval R v r :=
+  Ideal.Quotient.lift_mk _ _ _
+
+def baseMap : Polynomial R →ₐ[R] T R v := Polynomial.aeval (τ R v)
+omit [IsDomain R] in
+lemma baseMap_X : baseMap R v Polynomial.X = τ R v := Polynomial.aeval_X _
+
+lemma embedding_baseMap : (embedding R v).comp (baseMap R v) = baseEmbedding R := by
+  apply Polynomial.algHom_ext
+  simp only [AlgHom.comp_apply,baseMap_X,baseEmbedding_X,τ,embedding_π,eval,aeval_X]
+  rfl
+
+lemma τ_regular (hv : v ≠ 0) : IsLeftRegular (τ R v) := by
+  apply Determinant.regular_quotient_of_prime (MvPolynomial.X_prime (i := 0))
+  intro h
+  have he := map_dvd (MvPolynomial.eval (fun _ : Fin 2 => (0 : R))) h
+  simp [rel,hv] at he
+
+omit [IsDomain R] in
+lemma clears (r : T R v) : r ∈ Clearing.subalgebra (baseMap R v) Polynomial.X := by
+  have ht : Clearing.subalgebra (baseMap R v) Polynomial.X = ⊤ := by
+    apply Clearing.top_of_generators (π R v) (Ideal.Quotient.mkₐ_surjective R _) _ _
+    intro i
+    fin_cases i
+    · exact ⟨0,Polynomial.X,by simp [baseMap_X,τ]⟩
+    · refine ⟨2,Polynomial.C v,?_⟩
+      rw [baseMap_X]
+      change τ R v^2 * V R v = _
+      simpa only [baseMap,Polynomial.aeval_C] using equation R v
+  rw [ht]
+  trivial
+
+lemma embedding_injective (hv : v ≠ 0) : Function.Injective (embedding R v) := by
+  apply Clearing.injective_of_clearing (embedding R v) (baseMap R v) Polynomial.X
+  · rw [embedding_baseMap]; exact baseEmbedding_injective R
+  · rw [baseMap_X]; exact τ_regular R v hv
+  · exact top_unique (fun r _ => clears R v r)
+
+lemma isDomain (hv : v ≠ 0) : IsDomain (T R v) :=
+  Function.Injective.isDomain (embedding R v) (embedding_injective R v hv)
+
+end ComplexCancellation.AffineModification
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/AffineCancellation/ModificationGrading.lean b/lean/OAI/Algebra/AffineCancellation/ModificationGrading.lean
new file mode 100644
index 0000000000000000000000000000000000000000..8f3f21f53b77ebb45c906d403512c1f731769a8c
--- /dev/null
+++ b/lean/OAI/Algebra/AffineCancellation/ModificationGrading.lean
@@ -0,0 +1,160 @@
+import OAI.Algebra.AffineCancellation.Modification
+
+namespace OAI
+
+noncomputable section
+
+namespace ComplexCancellation.AffineModification
+open MvPolynomial
+variable (R : Type*) [CommRing R] (v : R)
+attribute [local instance] MvPolynomial.weightedGradedAlgebra
+def weight : Fin 2 → ℤ := ![-1,2]
+def sourcePieces (e : ℤ) := weightedHomogeneousSubmodule R weight e
+instance sourceGrading : GradedAlgebra (sourcePieces R) :=
+  inferInstanceAs (GradedAlgebra (weightedHomogeneousSubmodule R weight))
+lemma rel_homogeneous : rel R v ∈ sourcePieces R 0 := by
+  apply IsWeightedHomogeneous.sub
+  · convert ((isWeightedHomogeneous_X R weight 0).pow 2).mul
+      (isWeightedHomogeneous_X R weight 1) using 1; norm_num [weight]
+  · exact isWeightedHomogeneous_C _ _
+lemma kernel_homogeneous : (RingHom.ker (π R v)).IsHomogeneous (sourcePieces R) := by
+  change (RingHom.ker (Ideal.Quotient.mk (Ideal.span {rel R v}))).IsHomogeneous _
+  rw [Ideal.mk_ker]
+  apply Ideal.homogeneous_span
+  intro r hr
+  have he : r=rel R v := Set.mem_singleton_iff.mp hr
+  subst r
+  exact ⟨0,rel_homogeneous R v⟩
+def pieces : ℤ → Submodule R (T R v) := QuotientGrading.pieces (sourcePieces R) (π R v)
+instance grading : GradedAlgebra (pieces R v) := QuotientGrading.grading _ _
+  (Ideal.Quotient.mkₐ_surjective R _) (kernel_homogeneous R v)
+lemma monomial_image (d : Fin 2 →₀ ℕ) (r : R) :
+    π R v (monomial d r)=τ R v^(d 0)*V R v^(d 1)*algebraMap R (T R v) r := by
+  rw [monomial_eq]
+  simp only [map_mul,AlgHom.commutes,MvPolynomial.C_eq_algebraMap]
+  rw [Finsupp.prod_fintype]
+  · simp only [Fin.prod_univ_two,map_mul,map_pow,τ,V]
+    ring
+  · intro i
+    simp
+lemma weight_eq (d : Fin 2 →₀ ℕ) :
+    Finsupp.weight weight d = 2*(d 1 : ℤ)-(d 0 : ℤ) := by
+  rw [Finsupp.weight_apply,Finsupp.sum_fintype]
+  · simp [Fin.sum_univ_two,weight]
+    ring
+  · intro i
+    simp
+lemma monomial_reduction (i h m : ℕ) :
+    τ R v^(i+2*m)*V R v^(h+m)=τ R v^i*V R v^h*algebraMap R (T R v) (v^m) := by
+  rw [map_pow,← equation R v,pow_add,pow_add,pow_mul,mul_pow]
+  ring
+lemma piece_negative (n : ℕ) {r : T R v} (hr : r ∈ pieces R v (-(n:ℤ))) :
+    ∃ s : R, r=τ R v^n*algebraMap R (T R v) s := by
+  obtain ⟨p,hp,rfl⟩ := hr
+  induction hp using IsWeightedHomogeneous.induction_on with
+  | zero => exact ⟨0,by simp⟩
+  | add p q hp hq ihp ihq =>
+    obtain ⟨a,ha⟩ := ihp
+    obtain ⟨b,hb⟩ := ihq
+    exact ⟨a+b,by rw [map_add,map_add,ha,hb,mul_add]⟩
+  | monomial d a hd =>
+    rw [weight_eq] at hd
+    have hi : d 0=n+2*d 1 := by omega
+    refine ⟨v^(d 1)*a,?_⟩
+    change π R v (monomial d a)=_
+    rw [monomial_image,hi]
+    have he := monomial_reduction R v n 0 (d 1)
+    simpa only [zero_add,pow_zero,mul_one,map_mul,mul_assoc] using congrArg (fun x => x*algebraMap R (T R v) a) he
+lemma piece_even (n : ℕ) {r : T R v} (hr : r ∈ pieces R v (2*(n:ℤ))) :
+    ∃ s : R, r=V R v^n*algebraMap R (T R v) s := by
+  obtain ⟨p,hp,rfl⟩ := hr
+  induction hp using IsWeightedHomogeneous.induction_on with
+  | zero => exact ⟨0,by simp⟩
+  | add p q hp hq ihp ihq =>
+    obtain ⟨a,ha⟩ := ihp
+    obtain ⟨b,hb⟩ := ihq
+    exact ⟨a+b,by rw [map_add,map_add,ha,hb,mul_add]⟩
+  | monomial d a hd =>
+    rw [weight_eq] at hd
+    have hi : d 0=2*(d 1-n) := by omega
+    have hh : d 1=n+(d 1-n) := by omega
+    refine ⟨v^(d 1-n)*a,?_⟩
+    change π R v (monomial d a)=_
+    rw [monomial_image,hi]
+    conv_lhs => arg 1; arg 2; rw [hh]
+    have he := monomial_reduction R v 0 n (d 1-n)
+    simpa only [zero_add,pow_zero,one_mul,map_mul,mul_assoc] using congrArg (fun x => x*algebraMap R (T R v) a) he
+lemma piece_odd (n : ℕ) {r : T R v} (hr : r ∈ pieces R v (2*(n:ℤ)+1)) :
+    ∃ s : R, r=τ R v*V R v^(n+1)*algebraMap R (T R v) s := by
+  obtain ⟨p,hp,rfl⟩ := hr
+  induction hp using IsWeightedHomogeneous.induction_on with
+  | zero => exact ⟨0,by simp⟩
+  | add p q hp hq ihp ihq =>
+    obtain ⟨a,ha⟩ := ihp
+    obtain ⟨b,hb⟩ := ihq
+    exact ⟨a+b,by rw [map_add,map_add,ha,hb,mul_add]⟩
+  | monomial d a hd =>
+    rw [weight_eq] at hd
+    have hi : d 0=1+2*(d 1-(n+1)) := by omega
+    have hh : d 1=(n+1)+(d 1-(n+1)) := by omega
+    refine ⟨v^(d 1-(n+1))*a,?_⟩
+    change π R v (monomial d a)=_
+    rw [monomial_image,hi]
+    conv_lhs => arg 1; arg 2; rw [hh]
+    have he := monomial_reduction R v 1 (n+1) (d 1-(n+1))
+    simpa only [pow_one,map_mul,mul_assoc] using congrArg (fun x => x*algebraMap R (T R v) a) he
+lemma degree_cases (e : ℤ) :
+    (∃ n : ℕ, e=-(n+1:ℤ)) ∨ (∃ n : ℕ, e=2*(n:ℤ)) ∨ (∃ n : ℕ, e=2*(n:ℤ)+1) := by
+  by_cases hn : e < 0
+  · exact Or.inl ⟨(-e-1).toNat,by omega⟩
+  · by_cases hm : e%2=0
+    · exact Or.inr (Or.inl ⟨(e/2).toNat,by omega⟩)
+    · exact Or.inr (Or.inr ⟨(e/2).toNat,by omega⟩)
+lemma piece_monomial (e : ℤ) : ∃ i h : ℕ, ∀ r ∈ pieces R v e,
+    ∃ s : R, r=τ R v^i*V R v^h*algebraMap R (T R v) s := by
+  rcases degree_cases e with ⟨n,rfl⟩ | ⟨n,rfl⟩ | ⟨n,rfl⟩
+  · refine ⟨n+1,0,?_⟩
+    intro r hr
+    have hr' : r ∈ pieces R v (-((n+1:ℕ):ℤ)) := by simpa using hr
+    simpa using piece_negative R v (n+1) hr'
+  · refine ⟨0,n,?_⟩
+    intro r hr
+    simpa using piece_even R v n hr
+  · refine ⟨1,n+1,?_⟩
+    intro r hr
+    simpa using piece_odd R v n hr
+lemma V_dvd_of_positive {r : T R v} {e : ℤ} (he : 0 < e) (hr : r ∈ pieces R v e) :
+    V R v ∣ r := by
+  rcases degree_cases e with ⟨n,hen⟩ | ⟨n,hen⟩ | ⟨n,hen⟩
+  · omega
+  · rw [hen] at hr
+    have hn : 1 ≤ n := by omega
+    obtain ⟨s,rfl⟩ := piece_even R v n hr
+    exact dvd_mul_of_dvd_left (dvd_pow_self _ (by omega : n ≠ 0)) _
+  · rw [hen] at hr
+    obtain ⟨s,rfl⟩ := piece_odd R v n hr
+    exact dvd_mul_of_dvd_left (dvd_mul_of_dvd_right (dvd_pow_self _ (by omega : n+1 ≠ 0)) _) _
+lemma degree_even_of_not_τ_dvd {r : T R v} {e : ℤ} (hr : r ∈ pieces R v e)
+    (h : ¬τ R v ∣ r) : ∃ n : ℕ, e=2*(n:ℤ) := by
+  rcases degree_cases e with ⟨n,hen⟩ | he | ⟨n,hen⟩
+  · exfalso
+    apply h
+    rw [hen] at hr
+    have hr' : r ∈ pieces R v (-((n+1:ℕ):ℤ)) := by simpa using hr
+    obtain ⟨s,rfl⟩ := piece_negative R v (n+1) hr'
+    exact dvd_mul_of_dvd_left (dvd_pow_self _ (by omega : n+1 ≠ 0)) _
+  · exact he
+  · exfalso
+    apply h
+    rw [hen] at hr
+    obtain ⟨s,rfl⟩ := piece_odd R v n hr
+    exact dvd_mul_of_dvd_left (dvd_mul_right _ _) _
+lemma coefficient_mem (r : R) : algebraMap R (T R v) r ∈ pieces R v 0 :=
+  ⟨C r,isWeightedHomogeneous_C _ _,(π R v).commutes r⟩
+lemma τ_mem : τ R v ∈ pieces R v (-1) := ⟨X 0,isWeightedHomogeneous_X R weight 0,rfl⟩
+lemma V_mem : V R v ∈ pieces R v 2 := ⟨X 1,isWeightedHomogeneous_X R weight 1,rfl⟩
+end ComplexCancellation.AffineModification
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/AffineCancellation/Orbit.lean b/lean/OAI/Algebra/AffineCancellation/Orbit.lean
new file mode 100644
index 0000000000000000000000000000000000000000..f9a8fba8eb795d5208e689c6b47079c250e4dc33
--- /dev/null
+++ b/lean/OAI/Algebra/AffineCancellation/Orbit.lean
@@ -0,0 +1,151 @@
+import OAI.Algebra.AffineCancellation.Model
+
+namespace OAI
+
+noncomputable section
+
+/-! Orbit polynomials and exponentiation of locally nilpotent derivations. -/
+namespace ComplexCancellation.LND
+open Polynomial
+
+variable {k R : Type*} [Field k] [CommRing R] [Algebra k R]
+
+/-- Local nilpotence, allowing the bound zero for the zero element. -/
+def LocallyNilpotent (D : Derivation k R R) : Prop :=
+  ∀ r : R, ∃ n : ℕ, (D : R → R)^[n] r = 0
+
+lemma iterate_zero (D : Derivation k R R) (n : ℕ) : (D : R → R)^[n] 0 = 0 := by
+  induction n with
+  | zero => rfl
+  | succ n ih => rw [Function.iterate_succ_apply', ih, map_zero]
+
+lemma iterate_eq_zero_of_le (D : Derivation k R R) {r : R} {n m : ℕ}
+    (h : (D : R → R)^[n] r = 0) (hnm : n ≤ m) : (D : R → R)^[m] r = 0 := by
+  obtain ⟨j, rfl⟩ := Nat.exists_eq_add_of_le hnm
+  rw [Nat.add_comm, Function.iterate_add_apply, h, iterate_zero]
+
+lemma iterate_add (D : Derivation k R R) (n : ℕ) (r s : R) :
+    (D : R → R)^[n] (r + s) = (D : R → R)^[n] r + (D : R → R)^[n] s := by
+  simpa only [Module.End.pow_apply, Derivation.coeFn_coe] using
+    (D.toLinearMap ^ n).map_add r s
+
+lemma iterate_smul (D : Derivation k R R) (n : ℕ) (c : k) (r : R) :
+    (D : R → R)^[n] (c • r) = c • (D : R → R)^[n] r := by
+  simpa only [Module.End.pow_apply, Derivation.coeFn_coe] using
+    (D.toLinearMap ^ n).map_smul c r
+
+lemma iterate_leibniz (D : Derivation k R R) (n : ℕ) (r s : R) :
+    (D : R → R)^[n] (r * s) =
+      ∑ ij ∈ Finset.HasAntidiagonal.antidiagonal n,
+        n.choose ij.1 • ((D : R → R)^[ij.1] r * (D : R → R)^[ij.2] s) := by
+  induction n with
+  | zero => simp
+  | succ n ih =>
+    rw [Function.iterate_succ_apply', ih, map_sum,
+      Finset.sum_antidiagonal_choose_succ_nsmul
+        (fun i j => (D : R → R)^[i] r * (D : R → R)^[j] s) n]
+    simp only [map_nsmul, Derivation.leibniz, smul_eq_mul, nsmul_add,
+      Finset.sum_add_distrib]
+    congr 1
+    · apply Finset.sum_congr rfl
+      intro ij hij
+      rw [Function.iterate_succ_apply']
+    · apply Finset.sum_congr rfl
+      rintro ⟨i,j⟩ hij
+      have hij' : i + j = n := Finset.HasAntidiagonal.mem_antidiagonal.mp hij
+      have hchoose : n.choose i = n.choose j := by
+        exact Nat.choose_symm_of_eq_add hij'.symm
+      rw [Function.iterate_succ_apply', hchoose, mul_comm]
+
+lemma orbit_support_finite (D : Derivation k R R) (hD : LocallyNilpotent D) (r : R) :
+    (Function.support (fun n : ℕ => ((n.factorial : k)⁻¹) • (D : R → R)^[n] r)).Finite := by
+  obtain ⟨m, hm⟩ := hD r
+  apply (Set.finite_Iio m).subset
+  intro n hn
+  change n < m
+  by_contra h
+  have he := iterate_eq_zero_of_le D hm (by omega : m ≤ n)
+  exact hn (by simp [he])
+
+noncomputable def orbit (D : Derivation k R R) (hD : LocallyNilpotent D) (r : R) : R[X] :=
+  Polynomial.ofFinsupp (AddMonoidAlgebra.ofCoeff
+    (Finsupp.ofSupportFinite (fun n : ℕ => ((n.factorial : k)⁻¹) • (D : R → R)^[n] r)
+      (orbit_support_finite D hD r)))
+
+@[simp] lemma orbit_coeff (D : Derivation k R R) (hD : LocallyNilpotent D) (r : R) (n : ℕ) :
+    (orbit D hD r).coeff n = ((n.factorial : k)⁻¹) • (D : R → R)^[n] r := by
+  rfl
+
+@[simp] lemma orbit_coeff_zero (D : Derivation k R R) (hD : LocallyNilpotent D) (r : R) :
+    (orbit D hD r).coeff 0 = r := by simp
+
+@[simp] lemma orbit_coeff_one (D : Derivation k R R) (hD : LocallyNilpotent D) (r : R) :
+    (orbit D hD r).coeff 1 = D r := by simp
+
+lemma inv_factorial_choose [CharZero k] {n i j : ℕ} (h : i + j = n) :
+    ((n.factorial : k)⁻¹) * (n.choose i : k) =
+      ((i.factorial : k)⁻¹) * ((j.factorial : k)⁻¹) := by
+  have hi : i ≤ n := by omega
+  rw [Nat.cast_choose k hi, show n - i = j by omega]
+  have hn : (n.factorial : k) ≠ 0 := Nat.cast_ne_zero.mpr n.factorial_ne_zero
+  field_simp
+
+lemma orbit_mul [CharZero k] (D : Derivation k R R) (hD : LocallyNilpotent D) (r s : R) :
+    orbit D hD (r * s) = orbit D hD r * orbit D hD s := by
+  ext n
+  rw [orbit_coeff, Polynomial.coeff_mul, iterate_leibniz, Finset.smul_sum]
+  apply Finset.sum_congr rfl
+  rintro ⟨i,j⟩ hij
+  rw [orbit_coeff, orbit_coeff]
+  have hij' : i + j = n := Finset.HasAntidiagonal.mem_antidiagonal.mp hij
+  rw [← Nat.cast_smul_eq_nsmul k, smul_smul, inv_factorial_choose hij',
+    smul_mul_smul_comm]
+
+lemma orbit_add (D : Derivation k R R) (hD : LocallyNilpotent D) (r s : R) :
+    orbit D hD (r + s) = orbit D hD r + orbit D hD s := by
+  ext n
+  simp [smul_add]
+
+lemma orbit_algebraMap (D : Derivation k R R) (hD : LocallyNilpotent D) (c : k) :
+    orbit D hD (algebraMap k R c) = C (algebraMap k R c) := by
+  ext n
+  cases n with
+  | zero => simp
+  | succ n =>
+    simp [Function.iterate_succ_apply, D.map_algebraMap]
+
+noncomputable def orbitHom [CharZero k] (D : Derivation k R R) (hD : LocallyNilpotent D) : R →ₐ[k] R[X] where
+  toFun := orbit D hD
+  map_zero' := by ext; simp
+  map_one' := by simpa using orbit_algebraMap D hD 1
+  map_add' := orbit_add D hD
+  map_mul' := orbit_mul D hD
+  commutes' := orbit_algebraMap D hD
+
+lemma orbit_injective (D : Derivation k R R) (hD : LocallyNilpotent D) :
+    Function.Injective (orbit D hD) := by
+  intro r s hes
+  simpa using congrArg (fun p : R[X] => p.coeff 0) hes
+
+lemma orbit_degree_le_one (D : Derivation k R R) (hD : LocallyNilpotent D) {r : R}
+    (hr : D (D r) = 0) : (orbit D hD r).natDegree ≤ 1 := by
+  apply Polynomial.natDegree_le_iff_coeff_eq_zero.mpr
+  intro n hn
+  rw [orbit_coeff, iterate_eq_zero_of_le D (n := 2) hr (by omega), smul_zero]
+
+lemma orbit_constant_iff (D : Derivation k R R) (hD : LocallyNilpotent D) (r : R) :
+    orbit D hD r = C r ↔ D r = 0 := by
+  constructor
+  · intro h
+    simpa using congrArg (fun p : R[X] => p.coeff 1) h
+  · intro h
+    ext n
+    cases n with
+    | zero => simp
+    | succ n => simp [Function.iterate_succ_apply, h]
+
+end ComplexCancellation.LND
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/AffineCancellation/OrbitRigidity.lean b/lean/OAI/Algebra/AffineCancellation/OrbitRigidity.lean
new file mode 100644
index 0000000000000000000000000000000000000000..cd9a65f7c9c094ce4626465fa9cfa94492993dfc
--- /dev/null
+++ b/lean/OAI/Algebra/AffineCancellation/OrbitRigidity.lean
@@ -0,0 +1,46 @@
+import OAI.Algebra.AffineCancellation.Rigidity
+import OAI.Algebra.AffineCancellation.Orbit
+
+namespace OAI
+
+noncomputable section
+
+namespace ComplexCancellation.LND
+open Polynomial
+variable {k R K : Type*} [Field k] [CharZero k] [CommRing R] [Algebra k R]
+  [Field K] [CharZero K] [Algebra k K]
+
+/-- Orbit rigidity for a locally nilpotent derivation, with the nonsquare condition
+in the original coefficient field. -/
+theorem fixed_of_square_cube (D : Derivation k R R) (hD : LocallyNilpotent D)
+    (f : R →ₐ[k] K) (hf : Function.Injective f) {a d u : R}
+    (ha : a ≠ 0) (hd : d ≠ 0) (hu : u ≠ 0) (hn : d ^ 2 + a ^ 2 * u ^ 3 ≠ 0)
+    (hlin : D (D (d ^ 2 + a ^ 2 * u ^ 3)) = 0)
+    (hns : ∀ z : K, z ^ 2 ≠ -(f u) ^ 3) : D a = 0 ∧ D d = 0 ∧ D u = 0 := by
+  let φ : R →ₐ[k] K[X] :=
+    (Polynomial.mapAlgHom f).comp (orbitHom D hD)
+  have hφ (r : R) : φ r = (orbit D hD r).map f.toRingHom := rfl
+  have hφinj : Function.Injective φ :=
+    (Polynomial.map_injective f.toRingHom hf).comp (orbit_injective D hD)
+  have hφ0 (r : R) : (φ r).coeff 0 = f r := by simp [hφ]
+  have hφ1 (r : R) : (φ r).coeff 1 = f (D r) := by simp [hφ]
+  have hdeg : (φ (d ^ 2 + a ^ 2 * u ^ 3)).natDegree ≤ 1 :=
+    (Polynomial.natDegree_map_le).trans (orbit_degree_le_one D hD hlin)
+  have h := Rigidity.orbit_constant
+    (a := φ a) (d := φ d) (u := φ u) (n := φ (d ^ 2 + a ^ 2 * u ^ 3))
+    (by intro he; apply ha; apply hφinj; simpa only [map_zero] using he)
+    (by intro he; apply hd; apply hφinj; simpa only [map_zero] using he)
+    (by intro he; apply hu; apply hφinj; simpa only [map_zero] using he)
+    (by intro he; apply hn; apply hφinj; simpa only [map_zero] using he)
+    hdeg (by simp) (by simpa only [hφ0] using hns)
+  have hc (r : R) (hr : φ r = C ((φ r).coeff 0)) : D r = 0 := by
+    apply hf
+    have hh := congrArg (fun p : K[X] => p.coeff 1) hr
+    simpa [hφ1] using hh
+  exact ⟨hc a h.1, hc d h.2.1, hc u h.2.2⟩
+
+end ComplexCancellation.LND
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/AffineCancellation/Order.lean b/lean/OAI/Algebra/AffineCancellation/Order.lean
new file mode 100644
index 0000000000000000000000000000000000000000..1915a96c1e0bf4d7666d4225b2e1ee7fcc55f971
--- /dev/null
+++ b/lean/OAI/Algebra/AffineCancellation/Order.lean
@@ -0,0 +1,90 @@
+import OAI.Algebra.AffineCancellation.Kernel
+
+namespace OAI
+
+noncomputable section
+
+namespace ComplexCancellation.LND
+open Polynomial
+variable {k R : Type*} [Field k] [CharZero k] [CommRing R] [IsDomain R] [Algebra k R]
+
+omit [CharZero k] [IsDomain R] in
+lemma orbit_ne_zero (D : Derivation k R R) (hD : LocallyNilpotent D) {r : R} (hr : r ≠ 0) :
+    orbit D hD r ≠ 0 := by
+  intro h
+  apply hr
+  simpa using congrArg (fun f : R[X] => f.coeff 0) h
+
+def order (D : Derivation k R R) (hD : LocallyNilpotent D) (r : R) : ℕ :=
+  (orbit D hD r).natDegree
+
+lemma order_mul (D : Derivation k R R) (hD : LocallyNilpotent D) {r s : R}
+    (hr : r ≠ 0) (hs : s ≠ 0) : order D hD (r*s) = order D hD r + order D hD s := by
+  exact (congrArg natDegree (orbit_mul D hD r s)).trans
+    (natDegree_mul (orbit_ne_zero D hD hr) (orbit_ne_zero D hD hs))
+
+omit [CharZero k] [IsDomain R] in
+lemma order_zero_iff (D : Derivation k R R) (hD : LocallyNilpotent D) (r : R) :
+    order D hD r = 0 ↔ D r = 0 := by
+  rw [← orbit_constant_iff D hD r]
+  constructor
+  · intro hr
+    simpa using eq_C_of_natDegree_eq_zero hr
+  · intro h
+    simp only [order, h, natDegree_C]
+
+lemma order_derivative (D : Derivation k R R) (hD : LocallyNilpotent D) {r : R}
+    (hr : D r ≠ 0) : order D hD (D r) + 1 = order D hD r := by
+  let : CharZero R := Algebra.charZero_of_charZero k R
+  have hpos : 0 < order D hD r := Nat.pos_of_ne_zero (mt (order_zero_iff D hD r).mp hr)
+  change (orbit D hD (D r)).natDegree+1 = _
+  rw [← derivative_orbit, natDegree_derivative]
+  change order D hD r - 1 + 1 = order D hD r
+  omega
+
+/-- Dividing a locally nilpotent derivation by a nonzero common factor still
+produces a locally nilpotent derivation, even if the factor is not invariant. -/
+lemma cancel_factor_locallyNilpotent {S : Type*} [CommRing S] [Algebra k S]
+    (f : S →ₐ[k] R) (hf : Function.Injective f)
+    (D : Derivation k R R) (hD : LocallyNilpotent D)
+    (E : Derivation k S S) {c : R} (hc : c ≠ 0)
+    (h : ∀ r : S, D (f r) = c * f (E r)) : LocallyNilpotent E := by
+  intro r
+  induction hn : order D hD (f r) using Nat.strong_induction_on generalizing r with
+  | h n ih =>
+    by_cases her : E r = 0
+    · exact ⟨1, her⟩
+    · have hfer : f (E r) ≠ 0 := by simpa only [map_zero] using hf.ne her
+      have hdr : D (f r) ≠ 0 := by rw [h]; exact mul_ne_zero hc hfer
+      have ho := order_derivative D hD hdr
+      rw [h, order_mul D hD hc hfer, hn] at ho
+      obtain ⟨m, hm⟩ := ih (order D hD (f (E r))) (by omega) (E r) rfl
+      exact ⟨m+1, by simpa only [Function.iterate_succ_apply] using hm⟩
+
+end ComplexCancellation.LND
+
+namespace ComplexCancellation.LND
+variable {k R S : Type*} [Field k] [CharZero k] [CommRing R] [IsDomain R]
+  [CommRing S] [Algebra k S] [Algebra k R]
+lemma cancel_factor_square_zero
+    (f : S →ₐ[k] R) (hf : Function.Injective f)
+    (D : Derivation k R R) (hD : LocallyNilpotent D)
+    (E : Derivation k S S) {c : R} (hc : c ≠ 0)
+    (h : ∀ r : S, D (f r)=c*f (E r)) (v : S)
+    (ho : order D hD (f v) ≤ 2*order D hD c) : E (E v)=0 := by
+  by_contra hEE
+  have hE : E v ≠ 0 := by intro he; apply hEE; rw [he,map_zero]
+  have hn (r : S) (hr : E r ≠ 0) :
+      order D hD c + order D hD (f (E r)) + 1 = order D hD (f r) := by
+    have hfr : f (E r) ≠ 0 := by simpa only [map_zero] using hf.ne hr
+    have hdr : D (f r) ≠ 0 := by rw [h]; exact mul_ne_zero hc hfr
+    have he := order_derivative D hD hdr
+    rwa [h,order_mul D hD hc hfr] at he
+  have h₁ := hn v hE
+  have h₂ := hn (E v) hEE
+  omega
+end ComplexCancellation.LND
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/AffineCancellation/PolynomialDerivation.lean b/lean/OAI/Algebra/AffineCancellation/PolynomialDerivation.lean
new file mode 100644
index 0000000000000000000000000000000000000000..4a29770f5663d5d64fb7bf540af6177d1baa17ad
--- /dev/null
+++ b/lean/OAI/Algebra/AffineCancellation/PolynomialDerivation.lean
@@ -0,0 +1,79 @@
+import OAI.Algebra.AffineCancellation.Model
+
+namespace OAI
+
+noncomputable section
+
+namespace ComplexCancellation.PolynomialDerivation
+open TrivSqZeroExt
+variable {k R : Type*} [CommRing k] [CommRing R] [Algebra k R]
+def dual (D : Derivation k R R) : R →ₐ[k] TrivSqZeroExt R R where
+  toFun r := inl r + inr (D r)
+  map_zero' := by apply TrivSqZeroExt.ext <;> simp
+  map_one' := by apply TrivSqZeroExt.ext <;> simp
+  map_add' r s := by apply TrivSqZeroExt.ext <;> simp
+  map_mul' r s := by
+    apply TrivSqZeroExt.ext <;>
+      simp [Derivation.leibniz,smul_eq_mul,mul_comm]
+  commutes' r := by apply TrivSqZeroExt.ext <;> simp [algebraMap_eq_inl']
+@[simp] lemma dual_fst (D : Derivation k R R) (r : R) : fst (dual D r)=r := by simp [dual]
+@[simp] lemma dual_snd (D : Derivation k R R) (r : R) : snd (dual D r)=D r := by simp [dual]
+def fromDual (g : R →ₐ[k] TrivSqZeroExt R R)
+    (hg : ∀ r, fst (g r)=r) : Derivation k R R :=
+  Derivation.mk' (((sndHom R R).restrictScalars k).comp g.toLinearMap) (by
+    intro r s
+    change snd (g (r*s)) = r * snd (g s)+s * snd (g r)
+    rw [map_mul,snd_mul,hg,hg]
+    simp only [smul_eq_mul,op_smul_eq_mul,mul_comm])
+variable {S : Type*} [CommRing S] [Algebra k S]
+def along (f : R →ₐ[k] S) (D : Derivation k R R) : R →ₐ[k] TrivSqZeroExt S S where
+  toFun r := inl (f r)+inr (f (D r))
+  map_zero' := by apply TrivSqZeroExt.ext <;> simp
+  map_one' := by apply TrivSqZeroExt.ext <;> simp
+  map_add' r s := by apply TrivSqZeroExt.ext <;> simp
+  map_mul' r s := by
+    apply TrivSqZeroExt.ext <;>
+      simp [Derivation.leibniz,smul_eq_mul,mul_comm]
+  commutes' r := by
+    apply TrivSqZeroExt.ext <;> simp [algebraMap_eq_inl']
+@[simp] lemma along_fst (f : R →ₐ[k] S) (D : Derivation k R R) (r : R) :
+    fst (along f D r)=f r := by simp [along]
+@[simp] lemma along_snd (f : R →ₐ[k] S) (D : Derivation k R R) (r : R) :
+    snd (along f D r)=f (D r) := by simp [along]
+
+variable {ι : Type*}
+def mvDual (D : Derivation k R R) (d : ι → MvPolynomial ι R) :
+    MvPolynomial ι R →ₐ[k] TrivSqZeroExt (MvPolynomial ι R) (MvPolynomial ι R) where
+  __ := MvPolynomial.eval₂Hom (along (IsScalarTower.toAlgHom k R (MvPolynomial ι R)) D).toRingHom
+    (fun i => inl (MvPolynomial.X i)+inr (d i))
+  commutes' a := by
+    change MvPolynomial.eval₂ _ _ (MvPolynomial.C (algebraMap k R a)) = _
+    rw [MvPolynomial.eval₂_C]
+    exact (along (IsScalarTower.toAlgHom k R (MvPolynomial ι R)) D).commutes a
+lemma mvDual_C (D : Derivation k R R) (d : ι → MvPolynomial ι R) (r : R) :
+    mvDual D d (MvPolynomial.C r)=inl (MvPolynomial.C r)+inr (MvPolynomial.C (D r)) :=
+  MvPolynomial.eval₂_C _ _ _
+lemma mvDual_X (D : Derivation k R R) (d : ι → MvPolynomial ι R) (i : ι) :
+    mvDual D d (MvPolynomial.X i)=inl (MvPolynomial.X i)+inr (d i) :=
+  MvPolynomial.eval₂_X _ _ _
+lemma mvDual_fst (D : Derivation k R R) (d : ι → MvPolynomial ι R) (p : MvPolynomial ι R) :
+    fst (mvDual D d p)=p := by
+  induction p using MvPolynomial.induction_on with
+  | C r => simp [mvDual_C]
+  | add p q hp hq => simp [hp,hq]
+  | mul_X p i hp => simp [mvDual_X,hp]
+def mv (D : Derivation k R R) (d : ι → MvPolynomial ι R) :
+    Derivation k (MvPolynomial ι R) (MvPolynomial ι R) := fromDual (mvDual D d) (mvDual_fst D d)
+@[simp] lemma mv_C (D : Derivation k R R) (d : ι → MvPolynomial ι R) (r : R) :
+    mv D d (MvPolynomial.C r)=MvPolynomial.C (D r) := by
+  change snd (mvDual D d (MvPolynomial.C r))=_
+  simp [mvDual_C]
+@[simp] lemma mv_X (D : Derivation k R R) (d : ι → MvPolynomial ι R) (i : ι) :
+    mv D d (MvPolynomial.X i)=d i := by
+  change snd (mvDual D d (MvPolynomial.X i))=_
+  simp [mvDual_X]
+end ComplexCancellation.PolynomialDerivation
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/AffineCancellation/PolynomialSlice.lean b/lean/OAI/Algebra/AffineCancellation/PolynomialSlice.lean
new file mode 100644
index 0000000000000000000000000000000000000000..537d1ffc5c51081716dd9428c13a6e5222548ab9
--- /dev/null
+++ b/lean/OAI/Algebra/AffineCancellation/PolynomialSlice.lean
@@ -0,0 +1,140 @@
+import OAI.Algebra.AffineCancellation.RationalSlice
+
+namespace OAI
+
+noncomputable section
+
+namespace ComplexCancellation.DifferentialSlice
+variable {k K : Type*} [CommRing k] [Field K] [CharZero K] [Algebra k K]
+def constantMap (D : Derivation k K K) : k →+* constants D where
+  toFun a := ⟨algebraMap k K a,Derivation.map_algebraMap D a⟩
+  map_zero' := by apply Subtype.ext; exact map_zero _
+  map_one' := by apply Subtype.ext; exact map_one _
+  map_add' a b := by apply Subtype.ext; exact map_add _ a b
+  map_mul' a b := by apply Subtype.ext; exact map_mul _ a b
+instance constantAlgebra (D : Derivation k K K) : Algebra k (constants D) := (constantMap D).toAlgebra
+instance constantTower (D : Derivation k K K) : IsScalarTower k (constants D) K :=
+  IsScalarTower.of_algebraMap_eq' rfl
+end ComplexCancellation.DifferentialSlice
+
+namespace ComplexCancellation.InvariantClearing
+variable {k R S : Type*} [CommRing k] [CommRing R] [IsDomain R] [CommRing S]
+  [Algebra k R] [Algebra k S]
+def subalgebra (f : R →ₐ[k] S) (D : Derivation k R R) : Subalgebra k S where
+  carrier := {s | ∃ c r : R, D c=0 ∧ c ≠ 0 ∧ f c*s=f r}
+  algebraMap_mem' a := ⟨1,algebraMap k R a,D.map_one_eq_zero,one_ne_zero,by rw [map_one,one_mul,f.commutes]⟩
+  add_mem' := by
+    rintro s t ⟨c,r,hc,hcn,hcr⟩ ⟨d,u,hd,hdn,hdu⟩
+    refine ⟨c*d,d*r+c*u,?_,mul_ne_zero hcn hdn,?_⟩
+    · rw [Derivation.leibniz,hc,hd,smul_zero,smul_zero,add_zero]
+    · rw [map_mul,mul_add,map_add,map_mul,map_mul]
+      calc f c*f d*s+f c*f d*t = f d*(f c*s)+f c*(f d*t) := by ring
+        _ = _ := by rw [hcr,hdu]
+  mul_mem' := by
+    rintro s t ⟨c,r,hc,hcn,hcr⟩ ⟨d,u,hd,hdn,hdu⟩
+    refine ⟨c*d,r*u,?_,mul_ne_zero hcn hdn,?_⟩
+    · rw [Derivation.leibniz,hc,hd,smul_zero,smul_zero,add_zero]
+    · rw [map_mul,map_mul,show f c*f d*(s*t)=(f c*s)*(f d*t) by ring,hcr,hdu]
+lemma image_mem (f : R →ₐ[k] S) (D : Derivation k R R) (r : R) : f r ∈ subalgebra f D :=
+  ⟨1,r,D.map_one_eq_zero,one_ne_zero,by rw [map_one,one_mul]⟩
+end ComplexCancellation.InvariantClearing
+
+namespace ComplexCancellation.PolynomialModel
+open Polynomial DifferentialSlice FractionDerivation
+variable {k R : Type*} [Field k] [CommRing R] [IsDomain R] [CharZero R] [Algebra k R]
+abbrev K := FractionRing R
+variable (D : Derivation k R R) (hD : LND.LocallyNilpotent D)
+abbrev F := constants (extend (K := K (R := R)) D)
+def ι : R →ₐ[k] K (R := R) := IsScalarTower.toAlgHom k R (K (R := R))
+include hD in
+omit [IsDomain R] [CharZero R] in
+lemma local_slice (hn : D ≠ 0) : ∃ s : R, D s ≠ 0 ∧ D (D s)=0 := by
+  obtain ⟨r,hr⟩ : ∃ r, D r ≠ 0 := by
+    by_contra h
+    push Not at h
+    apply hn
+    ext r
+    exact h r
+  obtain ⟨n,hn,hdn⟩ := RationalSlice.last_nonzero D hr (hD (D r))
+  refine ⟨(D : R → R)^[n] r,?_,?_⟩
+  · simpa only [← Function.iterate_succ_apply',Function.iterate_succ_apply] using hn
+  · simpa only [← Function.iterate_succ_apply',Function.iterate_succ_apply] using hdn
+variable {t : K (R := R)} (ht : extend D t=1)
+def evaluation : Polynomial (F D) →ₐ[k] K (R := R) := (aeval t).restrictScalars k
+include ht in
+lemma evaluation_injective : Function.Injective (evaluation (D := D) (t := t)) := eval_injective _ ht
+include hD ht in
+lemma exists_model (r : R) : ∃ p : Polynomial (F D), evaluation (D := D) (t := t) p=ι (k := k) r :=
+  RationalSlice.image_is_polynomial D hD ht r
+
+def model : R →ₐ[k] Polynomial (F D) where
+  toFun r := Classical.choose (exists_model D hD ht r)
+  map_zero' := by
+    apply evaluation_injective D ht
+    rw [Classical.choose_spec (exists_model D hD ht 0),map_zero,map_zero]
+  map_one' := by
+    apply evaluation_injective D ht
+    rw [Classical.choose_spec (exists_model D hD ht 1),map_one,map_one]
+  map_add' r s := by
+    apply evaluation_injective D ht
+    rw [Classical.choose_spec (exists_model D hD ht (r+s)),map_add,map_add,
+      Classical.choose_spec (exists_model D hD ht r),Classical.choose_spec (exists_model D hD ht s)]
+  map_mul' r s := by
+    apply evaluation_injective D ht
+    rw [Classical.choose_spec (exists_model D hD ht (r*s)),map_mul,map_mul,
+      Classical.choose_spec (exists_model D hD ht r),Classical.choose_spec (exists_model D hD ht s)]
+  commutes' a := by
+    apply evaluation_injective D ht
+    rw [Classical.choose_spec (exists_model D hD ht (algebraMap k R a)),AlgHom.commutes,AlgHom.commutes]
+lemma evaluation_model (r : R) : evaluation (D := D) (t := t) (model D hD ht r)=ι (k := k) r :=
+  Classical.choose_spec (exists_model D hD ht r)
+lemma model_injective : Function.Injective (model D hD ht) := by
+  intro r s he
+  have hi : Function.Injective (ι (k := k) (R := R)) := IsFractionRing.injective R (K (R := R))
+  apply hi
+  have h := congrArg (evaluation (D := D) (t := t)) he
+  simpa only [evaluation_model] using h
+lemma derivative_model (r : R) : (model D hD ht r).derivative=model D hD ht (D r) := by
+  apply evaluation_injective D ht
+  change aeval t (model D hD ht r).derivative = evaluation (D := D) (t := t) _
+  rw [← derivative_eval _ ht]
+  change extend D (evaluation (D := D) (t := t) (model D hD ht r)) = evaluation (D := D) (t := t) _
+  rw [evaluation_model,evaluation_model]
+  exact extend_algebraMap D r
+lemma clear_constant (c : F D) : C c ∈ InvariantClearing.subalgebra (model D hD ht) D := by
+  obtain ⟨a,b,ha,hb,hbn,hab⟩ := RationalSlice.constant_fraction D hD c.property
+  refine ⟨b,a,hb,hbn,?_⟩
+  apply evaluation_injective D ht
+  rw [map_mul,evaluation_model,evaluation_model]
+  simp only [evaluation,AlgHom.restrictScalars_apply,Polynomial.aeval_C]
+  change ι (k := k) b*(c : K (R := R))=ι (k := k) a
+  have hn : ι (k := k) b ≠ 0 := by
+    have hi : Function.Injective (ι (k := k) (R := R)) := IsFractionRing.injective R (K (R := R))
+    simpa only [map_zero] using hi.ne hbn
+  change ι (k := k) a/ι (k := k) b=(c : K (R := R)) at hab
+  rw [← hab,← mul_div_assoc,mul_div_cancel_left₀ _ hn]
+lemma clear_X (s : R) (hs : D s ≠ 0) (he : D (D s)=0)
+    (hsl : t=ι (k := k) s/ι (k := k) (D s)) :
+    X ∈ InvariantClearing.subalgebra (model D hD ht) D := by
+  refine ⟨D s,s,he,hs,?_⟩
+  apply evaluation_injective D ht
+  rw [map_mul,evaluation_model,evaluation_model]
+  simp only [evaluation,AlgHom.restrictScalars_apply,Polynomial.aeval_X]
+
+  rw [hsl,← mul_div_assoc]
+  apply mul_div_cancel_left₀
+  have hi : Function.Injective (ι (k := k) (R := R)) := IsFractionRing.injective R (K (R := R))
+  simpa only [map_zero] using hi.ne hs
+lemma clear_polynomial (s : R) (hs : D s ≠ 0) (he : D (D s)=0)
+    (hsl : t=ι (k := k) s/ι (k := k) (D s)) (p : Polynomial (F D)) :
+    p ∈ InvariantClearing.subalgebra (model D hD ht) D := by
+  induction p using Polynomial.induction_on' with
+  | add p q hp hq => exact add_mem hp hq
+  | monomial n c =>
+    rw [← Polynomial.C_mul_X_pow_eq_monomial]
+    exact mul_mem (clear_constant D hD ht c) (pow_mem (clear_X D hD ht s hs he hsl) n)
+end ComplexCancellation.PolynomialModel
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/AffineCancellation/PositiveInvariant.lean b/lean/OAI/Algebra/AffineCancellation/PositiveInvariant.lean
new file mode 100644
index 0000000000000000000000000000000000000000..88a0628c066a4fcf82fe28b4e503e8d4c44bedd9
--- /dev/null
+++ b/lean/OAI/Algebra/AffineCancellation/PositiveInvariant.lean
@@ -0,0 +1,123 @@
+import OAI.Algebra.AffineCancellation.ReesGrading
+
+namespace OAI
+
+noncomputable section
+
+namespace ComplexCancellation.LND
+variable {k R S : Type*} [Field k] [CommRing R] [CommRing S] [Algebra k R] [Algebra k S]
+def conjugate (e : R ≃ₐ[k] S) (D : Derivation k S S) : Derivation k R R :=
+  Derivation.mk' (e.symm.toLinearMap ∘ₗ D.toLinearMap ∘ₗ e.toLinearMap) (by
+    intro r s
+    change e.symm (D (e (r*s))) = r*e.symm (D (e s))+s*e.symm (D (e r))
+    simp only [map_mul,Derivation.leibniz,smul_eq_mul,map_add,AlgEquiv.symm_apply_apply])
+lemma conjugate_apply (e : R ≃ₐ[k] S) (D : Derivation k S S) (r : R) :
+    conjugate e D r=e.symm (D (e r)) := rfl
+lemma conjugate_iterate (e : R ≃ₐ[k] S) (D : Derivation k S S) (r : R) (n : ℕ) :
+    (conjugate e D : R → R)^[n] r=e.symm ((D : S → S)^[n] (e r)) := by
+  induction n with
+  | zero => simp
+  | succ n ih => rw [Function.iterate_succ_apply',ih,conjugate_apply,AlgEquiv.apply_symm_apply,Function.iterate_succ_apply']
+lemma conjugate_ln (e : R ≃ₐ[k] S) (D : Derivation k S S) (hD : LocallyNilpotent D) :
+    LocallyNilpotent (conjugate e D) := by
+  intro r
+  obtain ⟨n,hn⟩ := hD (e r)
+  exact ⟨n,by rw [conjugate_iterate,hn,map_zero]⟩
+lemma pderiv_ln {ι : Type*} (i : ι) : LocallyNilpotent (MvPolynomial.pderiv (R := k) i) := by
+  classical
+  apply mvPolynomial_locallyNilpotent
+  intro j
+  refine ⟨2,?_⟩
+  simp only [Function.iterate_succ_apply',Function.iterate_zero_apply,MvPolynomial.pderiv_X]
+  by_cases hij : j=i
+  · subst j; simp
+  · simp [hij]
+end ComplexCancellation.LND
+
+namespace ComplexCancellation.Rees
+open MvPolynomial LaurentPolynomial
+lemma F_ne_zero : Degeneration.F ≠ 0 := by
+  let f : Degeneration.P →ₐ[ℂ] ℂ := aeval (fun i => if i=3 then 1 else 0)
+  have hf : f Degeneration.relation=0 := by
+    norm_num [f,Degeneration.relation,Degeneration.xp,Fin.ext_iff]
+  let g : Degeneration.G →ₐ[ℂ] ℂ := Ideal.Quotient.liftₐ _ f (by
+    intro r hr
+    obtain ⟨t,rfl⟩ := Ideal.mem_span_singleton.mp hr
+    rw [map_mul,hf,zero_mul])
+  have hg : g Degeneration.F=1 := by
+    change f (X 3)=1
+    norm_num [f]
+  intro hz
+  rw [hz,map_zero] at hg
+  exact zero_ne_one hg
+
+lemma coefficient_not_mem : c (aπ (X 3)) ∉ embedding.range := by
+  rintro ⟨b,hb⟩
+  change embedding b=c (aπ (X 3)) at hb
+  have he : π (X 4)=q^2*b := by
+    apply embedding_injective
+    rw [map_mul,map_pow,embedding_q,T_pow,hb,embedding_π]
+    simp only [eval,aeval_X,values,Matrix.cons_val]
+    change c (aπ (X 3))*T 2=T 2*c (aπ (X 3))
+    exact mul_comm (c (aπ (X 3))) (T 2 : L)
+  have hr := congrArg red he
+  simp only [map_mul,map_pow,red_q,zero_pow (by decide : 2 ≠ 0),zero_mul] at hr
+  have hF : red (π (X 4))=Degeneration.F := by simp [redEval,redValues,Matrix.cons_val]
+  exact F_ne_zero (hF.symm.trans hr)
+lemma positive_clear (r : A) (hr : c r ∉ embedding.range) :
+    ∃ (i : ℤ) (s : B), 0 < i ∧ red s ≠ 0 ∧ embedding s=T i*c r := by
+  have hcr : c r ≠ 0 := by
+    intro hz
+    apply hr
+    rw [hz]
+    exact embedding.range.zero_mem
+  obtain ⟨i,s,hs,he⟩ := clear_order (c r) hcr
+  refine ⟨i,s,?_,hs,he⟩
+  by_contra hn
+  have hi : 0 ≤ -i := by omega
+  apply hr
+  use q^(-i).toNat*s
+  change embedding (q^(-i).toNat*s)=c r
+  rw [map_mul,map_pow,embedding_q,T_pow,Int.toNat_of_nonneg hi,mul_one,he,← mul_assoc,← T_add]
+  simp
+lemma polynomial_bad_coordinate (e : A ≃ₐ[ℂ] MvPolynomial (Fin 4) ℂ) :
+    ∃ i : Fin 4, c (e.symm (X i)) ∉ embedding.range := by
+  by_contra hn
+  push Not at hn
+  apply coefficient_not_mem
+  rw [← e.symm_apply_apply (aπ (X 3))]
+  generalize e (aπ (X 3))=r
+  induction r using MvPolynomial.induction_on with
+  | C z =>
+    have he : c (e.symm (MvPolynomial.C z))=algebraMap ℂ L z := by
+      rw [MvPolynomial.C_eq_algebraMap,AlgEquiv.commutes,c.commutes]
+    rw [he]
+    exact embedding.range.algebraMap_mem z
+  | add r s hr hs => rw [map_add,map_add]; exact add_mem hr hs
+  | mul_X r i hr => rw [map_mul,map_mul]; exact mul_mem hr (hn i)
+lemma bad_invariant (e : A ≃ₐ[ℂ] MvPolynomial (Fin 4) ℂ) :
+    ∃ (r : A) (D : Derivation ℂ A A), c r ∉ embedding.range ∧ LND.LocallyNilpotent D ∧ D ≠ 0 ∧ D r=0 := by
+  classical
+  obtain ⟨i,hi⟩ := polynomial_bad_coordinate e
+  obtain ⟨j,hj⟩ : ∃ j : Fin 4, j ≠ i := exists_ne i
+  let D := LND.conjugate e (MvPolynomial.pderiv j)
+  refine ⟨e.symm (X i),D,hi,LND.conjugate_ln e _ (LND.pderiv_ln j),?_,?_⟩
+  · intro hz
+    have he := DFunLike.congr_fun hz (e.symm (X j))
+    have ho : D (e.symm (X j))=1 := by simp [D,LND.conjugate_apply]
+    rw [ho,Derivation.zero_apply] at he
+    exact one_ne_zero he
+  · simp [D,LND.conjugate_apply,MvPolynomial.pderiv_X,hj]
+lemma positive_invariant_of_polynomial (e : A ≃ₐ[ℂ] MvPolynomial (Fin 4) ℂ) :
+    ∃ (i : ℤ) (r : Degeneration.G) (D : Derivation ℂ Degeneration.G Degeneration.G),
+      0 < i ∧ r ≠ 0 ∧ r ∈ Degeneration.pieces i ∧ LND.LocallyNilpotent D ∧ D ≠ 0 ∧ D r=0 := by
+  obtain ⟨r,D,hr,hD,hDn,hDr⟩ := bad_invariant e
+  obtain ⟨i,s,hi,hs,he⟩ := positive_clear r hr
+  obtain ⟨E,hE,hEn,hEq,hEs⟩ := scaled_restriction D hD hDn r hDr i s he
+  obtain ⟨D',hD',hDn',hDr'⟩ := primitive_reduction E hE hEn hEq s hEs
+  exact ⟨i,red s,D',hi,hs,red_monomial_mem s r i he,hD',hDn',hDr'⟩
+end ComplexCancellation.Rees
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/AffineCancellation/PositiveObstruction.lean b/lean/OAI/Algebra/AffineCancellation/PositiveObstruction.lean
new file mode 100644
index 0000000000000000000000000000000000000000..86081cce21274aa9988879c863080453c0fdeec3
--- /dev/null
+++ b/lean/OAI/Algebra/AffineCancellation/PositiveObstruction.lean
@@ -0,0 +1,40 @@
+import OAI.Algebra.AffineCancellation.Bundle
+import OAI.Algebra.AffineCancellation.HomogeneousExtraction
+
+namespace OAI
+
+noncomputable section
+
+namespace ComplexCancellation.Determinant
+lemma Euler_v : Euler v=2*v := by
+  simp only [v,map_sub,Derivation.leibniz,Derivation.leibniz_pow,
+    Euler_a,Euler_b,Euler_d,Euler_u,smul_eq_mul]
+  ring
+end ComplexCancellation.Determinant
+namespace ComplexCancellation.Bundle
+open Determinant
+abbrev valuationPieces (e : ℤ) : Submodule ℂ B :=
+  (AffineModification.pieces T v e).restrictScalars ℂ
+instance valuationGrading : GradedAlgebra valuationPieces :=
+  { (AffineModification.grading T v) with }
+def fiberEuler : Derivation ℂ B B := AffineModification.euler v Euler Euler_v
+/-- The positive-invariant obstruction on the pullback ring. -/
+theorem no_positive_invariant
+    (D : Derivation ℂ B B) (hD : LND.LocallyNilpotent D) (hDn : D ≠ 0)
+    (j : ℤ) (hshift : ∀ e r, r ∈ valuationPieces e → D r ∈ valuationPieces (e+j))
+    (hcomm : ∀ z, fiberEuler (D z)=D (fiberEuler z))
+    (w : B) (hw : w ≠ 0) (e : ℤ) (he : 0 < e)
+    (hwg : w ∈ valuationPieces e) (hDw : D w=0) : False := by
+  have hV := AffineModification.fixed_V_of_positive_invariant v v_ne_zero D hD w hw e he hwg hDw
+  obtain ⟨E,n,hEn,hEl,hshiftE,hEv⟩ :=
+    AffineModification.extract v v_ne_zero Euler Euler_v D hD hDn j hshift hcomm hV
+  apply hEn
+  apply rigidity E hEl (-(n : ℤ)) (by omega) _ hEv
+  intro r
+  rw [hshiftE]
+  simp only [Int.cast_neg,Int.cast_natCast,neg_smul,Nat.cast_smul_eq_nsmul]
+end ComplexCancellation.Bundle
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/AffineCancellation/Primitive.lean b/lean/OAI/Algebra/AffineCancellation/Primitive.lean
new file mode 100644
index 0000000000000000000000000000000000000000..3da691d1466a83b046288fc47cf8069a1cacd55d
--- /dev/null
+++ b/lean/OAI/Algebra/AffineCancellation/Primitive.lean
@@ -0,0 +1,59 @@
+import OAI.Algebra.AffineCancellation.FactorDerivation
+import OAI.Algebra.AffineCancellation.Order
+
+namespace OAI
+
+noncomputable section
+
+namespace ComplexCancellation.LND
+variable {k R : Type*} [Field k] [CharZero k] [CommRing R] [IsDomain R] [Algebra k R]
+omit [CharZero k] [IsDomain R] in
+lemma iterate_replica (D : Derivation k R R) (c : R) (hc : D c=0) (r : R) (n : ℕ) :
+    ((c • D : Derivation k R R) : R → R)^[n] r=c^n*(D : R → R)^[n] r := by
+  induction n with
+  | zero => simp
+  | succ n ih =>
+    rw [Function.iterate_succ_apply',ih,Derivation.smul_apply,Derivation.leibniz,
+      Derivation.leibniz_pow,hc]
+    simp only [smul_eq_mul]
+    rw [pow_succ,Function.iterate_succ_apply']
+    ring
+
+omit [CharZero k] [IsDomain R] in
+lemma replica (D : Derivation k R R) (hD : LocallyNilpotent D) (c : R) (hc : D c=0) :
+    LocallyNilpotent (c • D) := by
+  intro r
+  obtain ⟨n,hn⟩ := hD r
+  exact ⟨n,by rw [iterate_replica D c hc,hn,mul_zero]⟩
+
+/-- Remove all common powers of a regular parameter from an LND.
+The termination certificate is the exact finite order of a single nonzero image. -/
+lemma primitive_of_order (q : R) (hq : q ≠ 0) (w b s : R) (hs : ¬q ∣ s)
+    (n : ℕ) (D : Derivation k R R) (hD : LocallyNilpotent D)
+    (hDq : D q=0) (hDw : D w=0) (hb : D b=q^n*s) :
+    ∃ E : Derivation k R R, LocallyNilpotent E ∧ E q=0 ∧ E w=0 ∧ ∃ r, ¬q ∣ E r := by
+  induction n generalizing D with
+  | zero =>
+    refine ⟨D,hD,hDq,hDw,b,?_⟩
+    rw [hb,pow_zero,one_mul]
+    exact hs
+  | succ n ih =>
+    by_cases h : ∃ r, ¬q ∣ D r
+    · exact ⟨D,hD,hDq,hDw,h⟩
+    · push Not at h
+      let f := AlgHom.id k R
+      have hfac : ∀ r : R, ∃ s : R, D (f r)=q*f s := h
+      let E := FactorDerivation.derivation f Function.injective_id D q hq hfac
+      have he (r : R) : D r=q*E r := FactorDerivation.apply_spec f Function.injective_id D q hq hfac r
+      have hE : LocallyNilpotent E := cancel_factor_locallyNilpotent f Function.injective_id D hD E hq he
+      have hEq : E q=0 := (mul_eq_zero.mp (by rw [← he,hDq])).resolve_left hq
+      have hEw : E w=0 := (mul_eq_zero.mp (by rw [← he,hDw])).resolve_left hq
+      apply ih E hE hEq hEw
+      apply mul_left_cancel₀ hq
+      rw [← he,hb,pow_succ]
+      ring
+end ComplexCancellation.LND
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/AffineCancellation/Quadric.lean b/lean/OAI/Algebra/AffineCancellation/Quadric.lean
new file mode 100644
index 0000000000000000000000000000000000000000..7c63a463cad5a87008d5dbbcef731f4247aa1898
--- /dev/null
+++ b/lean/OAI/Algebra/AffineCancellation/Quadric.lean
@@ -0,0 +1,87 @@
+import OAI.Algebra.AffineCancellation.Clearing
+import OAI.Algebra.AffineCancellation.DeterminantRigidity
+
+namespace OAI
+
+noncomputable section
+
+namespace ComplexCancellation.Quadric
+open MvPolynomial
+abbrev Poly := MvPolynomial (Fin 4) ℂ
+abbrev Base := MvPolynomial (Fin 3) ℂ
+abbrev K := FractionRing Base
+def relation : Poly := X 0*X 1-X 2*(X 2+1)
+abbrev R := Poly ⧸ Ideal.span {relation}
+def π : Poly →ₐ[ℂ] R := Ideal.Quotient.mkₐ ℂ _
+def x : R := π (X 0)
+def y : R := π (X 1)
+def z : R := π (X 2)
+def u : R := π (X 3)
+def s : R := y-x*(x-u^3)
+def f : R := x-s^2-u^3
+def g : R := z-s*x
+
+def baseEmbedding : Base →ₐ[ℂ] K := IsScalarTower.toAlgHom ℂ Base K
+lemma baseEmbedding_injective : Function.Injective baseEmbedding := IsFractionRing.injective Base K
+lemma x_field_nonzero : baseEmbedding (X 0) ≠ 0 := by
+  simpa only [map_zero] using baseEmbedding_injective.ne (X_ne_zero (0 : Fin 3))
+def values : Fin 4 → K := ![baseEmbedding (X 0),
+  baseEmbedding (X 1)*(baseEmbedding (X 1)+1)/baseEmbedding (X 0),
+  baseEmbedding (X 1),baseEmbedding (X 2)]
+def eval : Poly →ₐ[ℂ] K := aeval values
+lemma eval_relation : eval relation = 0 := by
+  simp only [relation,eval,map_sub,map_mul,map_add,map_one,aeval_X,values,
+    Matrix.cons_val_zero,Matrix.cons_val_one,Matrix.cons_val]
+  field_simp [x_field_nonzero]
+  ring
+
+def embedding : R →ₐ[ℂ] K := Ideal.Quotient.liftₐ _ eval (by
+  intro r hr
+  obtain ⟨s,rfl⟩ := Ideal.mem_span_singleton.mp hr
+  rw [map_mul,eval_relation,zero_mul])
+@[simp] lemma embedding_π (r : Poly) : embedding (π r) = eval r := Ideal.Quotient.lift_mk _ _ _
+lemma equation : x*y=z*(z+1) := by
+  apply sub_eq_zero.mp
+  have h : π relation = 0 := Ideal.Quotient.eq_zero_iff_mem.mpr (Ideal.subset_span (by simp))
+  simpa only [relation,map_sub,map_mul,map_add,map_one,x,y,z] using h
+lemma x_regular : IsLeftRegular x := by
+  apply Determinant.regular_quotient_of_prime (MvPolynomial.X_prime (i := 0))
+  intro h
+  have he := map_dvd (MvPolynomial.eval (fun i : Fin 4 => if i=2 then (1:ℂ) else 0)) h
+  norm_num [relation,Fin.ext_iff] at he
+
+def baseMap : Base →ₐ[ℂ] R := aeval ![x,z,u]
+lemma baseMap_X_zero : baseMap (X 0) = x := by simp [baseMap]
+lemma embedding_baseMap : embedding.comp baseMap = baseEmbedding := by
+  apply MvPolynomial.algHom_ext
+  intro i
+  fin_cases i <;> simp [baseMap,x,z,u,eval,values]
+lemma clears : Clearing.subalgebra baseMap (X 0) = ⊤ := by
+  apply Clearing.top_of_generators π (Ideal.Quotient.mkₐ_surjective ℂ _) _ _
+  intro i
+  fin_cases i
+  · exact ⟨0,X 0,by simp [baseMap,x]⟩
+  · refine ⟨1,X 1*(X 1+1),?_⟩
+    simp only [pow_one,baseMap,map_mul,map_add,map_one,aeval_X]
+    exact equation
+  · exact ⟨0,X 1,by simp [baseMap,z]⟩
+  · exact ⟨0,X 2,by simp [baseMap,u]⟩
+lemma embedding_injective : Function.Injective embedding := by
+  apply Clearing.injective_of_clearing embedding baseMap (X 0)
+  · rw [embedding_baseMap]; exact baseEmbedding_injective
+  · rw [baseMap_X_zero]; exact x_regular
+  · exact clears
+instance : IsDomain R := Function.Injective.isDomain embedding embedding_injective
+lemma baseMap_injective : Function.Injective baseMap := by
+  apply Function.Injective.of_comp (f := embedding)
+  rw [← AlgHom.coe_comp,embedding_baseMap]
+  exact baseEmbedding_injective
+lemma x_ne_zero : x ≠ 0 := by
+  rw [← baseMap_X_zero]
+  simpa only [map_zero] using baseMap_injective.ne (X_ne_zero (0 : Fin 3))
+
+end ComplexCancellation.Quadric
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/AffineCancellation/QuotientDerivation.lean b/lean/OAI/Algebra/AffineCancellation/QuotientDerivation.lean
new file mode 100644
index 0000000000000000000000000000000000000000..b02d6d8a48379ffd5ad2f07091784d9e328c1893
--- /dev/null
+++ b/lean/OAI/Algebra/AffineCancellation/QuotientDerivation.lean
@@ -0,0 +1,57 @@
+import OAI.Algebra.AffineCancellation.Model
+
+namespace OAI
+
+noncomputable section
+
+namespace ComplexCancellation.QuotientDerivation
+variable {k R : Type*} [CommRing k] [CommRing R] [Algebra k R]
+variable (I : Ideal R) (D : Derivation k R R)
+  (hD : ∀ r ∈ I, D r ∈ I)
+
+def linear : (R ⧸ I) →ₗ[k] (R ⧸ I) :=
+  (I.restrictScalars k).liftQ ((Ideal.Quotient.mkₐ k I).toLinearMap.comp D.toLinearMap)
+    (by intro r hr; exact Ideal.Quotient.eq_zero_iff_mem.mpr (hD r hr))
+
+@[simp] lemma linear_mk (r : R) : linear I D hD (Ideal.Quotient.mk I r) =
+    Ideal.Quotient.mk I (D r) := rfl
+
+def derivation : Derivation k (R ⧸ I) (R ⧸ I) := Derivation.mk' (linear I D hD) (by
+  intro r s
+  obtain ⟨r, rfl⟩ := Ideal.Quotient.mk_surjective r
+  obtain ⟨s, rfl⟩ := Ideal.Quotient.mk_surjective s
+  change linear I D hD ((Ideal.Quotient.mk I) r * (Ideal.Quotient.mk I) s) = _
+  rw [← map_mul, linear_mk]
+  simp only [Derivation.leibniz, smul_eq_mul, map_add, map_mul, linear_mk])
+
+@[simp] lemma derivation_mk (r : R) : derivation I D hD (Ideal.Quotient.mk I r) =
+    Ideal.Quotient.mk I (D r) := rfl
+
+lemma iterate_mk (r : R) (n : ℕ) :
+    (derivation I D hD : (R ⧸ I) → (R ⧸ I))^[n] (Ideal.Quotient.mk I r) =
+      Ideal.Quotient.mk I ((D : R → R)^[n] r) := by
+  induction n with
+  | zero => rfl
+  | succ n ih => rw [Function.iterate_succ_apply', ih, derivation_mk,
+      Function.iterate_succ_apply']
+
+lemma locallyNilpotent (hn : ∀ r, ∃ n, (D : R → R)^[n] r = 0) :
+    ∀ r, ∃ n, (derivation I D hD : (R ⧸ I) → (R ⧸ I))^[n] r = 0 := by
+  intro r
+  obtain ⟨r, rfl⟩ := Ideal.Quotient.mk_surjective r
+  obtain ⟨n, hn⟩ := hn r
+  exact ⟨n, by rw [iterate_mk, hn, map_zero]⟩
+
+lemma span_singleton_stable {h : R} (hh : D h ∈ Ideal.span {h}) :
+    ∀ r ∈ Ideal.span {h}, D r ∈ Ideal.span {h} := by
+  intro r hr
+  obtain ⟨s, rfl⟩ := Ideal.mem_span_singleton.mp hr
+  rw [Derivation.leibniz, smul_eq_mul, smul_eq_mul]
+  exact Ideal.add_mem _ (Ideal.mul_mem_right _ _ (Ideal.subset_span (by simp)))
+    (Ideal.mul_mem_left _ _ hh)
+
+end ComplexCancellation.QuotientDerivation
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/AffineCancellation/QuotientGrading.lean b/lean/OAI/Algebra/AffineCancellation/QuotientGrading.lean
new file mode 100644
index 0000000000000000000000000000000000000000..4b9eab4c0d0db985e370d72fa72ed49f00599854
--- /dev/null
+++ b/lean/OAI/Algebra/AffineCancellation/QuotientGrading.lean
@@ -0,0 +1,126 @@
+import OAI.Algebra.AffineCancellation.Model
+
+namespace OAI
+
+noncomputable section
+
+namespace ComplexCancellation.QuotientGrading
+open DirectSum
+variable {k R Q ι : Type*} [CommRing k] [CommRing R] [CommRing Q]
+  [Algebra k R] [Algebra k Q] [AddCommMonoid ι] [DecidableEq ι]
+  (G : ι → Submodule k R) [GradedAlgebra G]
+  (q : R →ₐ[k] Q)
+
+def pieces (i : ι) : Submodule k Q := (G i).map q.toLinearMap
+
+def componentMap (i : ι) : G i →ₗ[k] pieces G q i :=
+  (q.toLinearMap.comp (G i).subtype).codRestrict _ (fun r => ⟨r, r.2, rfl⟩)
+
+def sourceDecompose : R →ₗ[k] ⨁ i, pieces G q i :=
+  (DirectSum.lmap (componentMap G q)).comp (decomposeLinearEquiv G).toLinearMap
+
+lemma sourceDecompose_apply (r : R) (i : ι) :
+    ((sourceDecompose G q r i : pieces G q i) : Q) = q (decompose G r i) := rfl
+
+lemma sourceDecompose_zero (hK : (RingHom.ker q).IsHomogeneous G) {r : R}
+    (hr : q r = 0) : sourceDecompose G q r = 0 := by
+  ext i
+  change q (decompose G r i) = 0
+  exact (hK.mem_iff.mp hr) i
+
+lemma sourceDecompose_eq (hK : (RingHom.ker q).IsHomogeneous G)
+    {a b : R} (hab : q a = q b) : sourceDecompose G q a = sourceDecompose G q b := by
+  ext i
+  have hz : q (a-b) = 0 := by rw [map_sub, hab, sub_self]
+  have hh := (hK.mem_iff.mp hz) i
+  change q (decompose G (a-b) i) = 0 at hh
+  rw [decompose_sub] at hh
+  change q (decompose G a i) = q (decompose G b i)
+  simpa only [DirectSum.sub_apply, Submodule.coe_sub, map_sub, sub_eq_zero] using hh
+
+def decomposeMap (hq : Function.Surjective q)
+    (hK : (RingHom.ker q).IsHomogeneous G) : Q →ₗ[k] ⨁ i, pieces G q i where
+  toFun r := sourceDecompose G q (Classical.choose (hq r))
+  map_add' r s := by
+    rw [← map_add]
+    apply sourceDecompose_eq G q hK
+    simp only [map_add, Classical.choose_spec (hq _)]
+  map_smul' a r := by
+    change sourceDecompose G q (Classical.choose (hq (a • r))) =
+      a • sourceDecompose G q (Classical.choose (hq r))
+    rw [← map_smul]
+    apply sourceDecompose_eq G q hK
+    simp only [map_smul, Classical.choose_spec (hq _)]
+
+@[simp] lemma decomposeMap_q (hq : Function.Surjective q)
+    (hK : (RingHom.ker q).IsHomogeneous G) (r : R) :
+    decomposeMap G q hq hK (q r) = sourceDecompose G q r :=
+  sourceDecompose_eq G q hK (Classical.choose_spec (hq (q r)))
+
+lemma coe_sourceDecompose (r : R) :
+    coeLinearMap (pieces G q) (sourceDecompose G q r) = q r := by
+  induction r using DirectSum.Decomposition.inductionOn G with
+  | zero => simp
+  | @homogeneous i r =>
+    change coeLinearMap (pieces G q) (DirectSum.lmap (componentMap G q)
+      (decompose G (r : R))) = _
+    rw [decompose_coe, DirectSum.lmap_of]
+    change coeLinearMap (pieces G q)
+      (DirectSum.lof k ι (fun i => pieces G q i) i (componentMap G q i r)) = _
+    rw [coeLinearMap_lof]
+    rfl
+  | add r s hr hs => simp [hr, hs]
+
+lemma decomposeMap_homogeneous (hq : Function.Surjective q)
+    (hK : (RingHom.ker q).IsHomogeneous G) (i : ι) (r : pieces G q i) :
+    decomposeMap G q hq hK r = DirectSum.lof k ι (fun i => pieces G q i) i r := by
+  obtain ⟨s, hs, hsr⟩ := r.2
+  have he : (r : Q) = q s := hsr.symm
+  rw [he, decomposeMap_q]
+  change DirectSum.lmap (componentMap G q) (decompose G s) = _
+  rw [decompose_of_mem G hs, DirectSum.lmap_of]
+  apply congrArg (DirectSum.of (fun i => pieces G q i) i)
+  exact Subtype.ext hsr
+
+@[instance_reducible] def decomposition (hq : Function.Surjective q)
+    (hK : (RingHom.ker q).IsHomogeneous G) : Decomposition (pieces G q) :=
+  Decomposition.ofLinearMap (pieces G q) (decomposeMap G q hq hK)
+    (by
+      ext r
+      obtain ⟨s, rfl⟩ := hq r
+      exact (congrArg (coeLinearMap (pieces G q)) (decomposeMap_q G q hq hK s)).trans
+        (coe_sourceDecompose G q s))
+    (by
+      apply DirectSum.linearMap_ext k
+      intro i
+      apply LinearMap.ext
+      intro r
+      change decomposeMap G q hq hK
+        (coeLinearMap (pieces G q) (DirectSum.lof k ι (fun i => pieces G q i) i r)) = _
+      rw [coeLinearMap_lof]
+      exact decomposeMap_homogeneous G q hq hK i r)
+
+@[instance_reducible] def grading (hq : Function.Surjective q)
+    (hK : (RingHom.ker q).IsHomogeneous G) : GradedAlgebra (pieces G q) where
+  toDecomposition := decomposition G q hq hK
+  one_mem := ⟨1, SetLike.one_mem_graded G, map_one q⟩
+  mul_mem := by
+    intro i j r s hr hs
+    obtain ⟨a, ha, rfl⟩ := hr
+    obtain ⟨b, hb, rfl⟩ := hs
+    exact ⟨a*b, SetLike.mul_mem_graded ha hb, map_mul q a b⟩
+
+lemma projection_q (hq : Function.Surjective q)
+    (hK : (RingHom.ker q).IsHomogeneous G) (r : R) (i : ι) :
+    letI : GradedAlgebra (pieces G q) := grading G q hq hK
+    GradedAlgebra.proj (pieces G q) i (q r) = q (GradedAlgebra.proj G i r) := by
+  let : GradedAlgebra (pieces G q) := grading G q hq hK
+  change ((decomposeMap G q hq hK (q r) i : pieces G q i) : Q) = _
+  rw [decomposeMap_q]
+  rfl
+
+end ComplexCancellation.QuotientGrading
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/AffineCancellation/RationalSlice.lean b/lean/OAI/Algebra/AffineCancellation/RationalSlice.lean
new file mode 100644
index 0000000000000000000000000000000000000000..4240f70e8d8dc4d15fac2103db823b38cfc05995
--- /dev/null
+++ b/lean/OAI/Algebra/AffineCancellation/RationalSlice.lean
@@ -0,0 +1,91 @@
+import OAI.Algebra.AffineCancellation.PositiveInvariant
+import OAI.Algebra.AffineCancellation.FractionDerivation
+import OAI.Algebra.AffineCancellation.DifferentialSlice
+
+namespace OAI
+
+noncomputable section
+
+namespace ComplexCancellation.RationalSlice
+open DifferentialSlice FractionDerivation
+variable {k R K : Type*} [Field k] [CharZero k] [CommRing R] [IsDomain R]
+  [Algebra k R] [Field K] [CharZero K] [Algebra R K] [IsFractionRing R K]
+  [Algebra k K] [IsScalarTower k R K]
+
+omit [IsDomain R] [Field K] [CharZero K] [Algebra R K] [IsFractionRing R K]
+  [Algebra k K] [IsScalarTower k R K] [CharZero k] in
+lemma last_nonzero (D : Derivation k R R) {r : R} (hr : r ≠ 0)
+    (h : ∃ m : ℕ, (D : R → R)^[m] r = 0) :
+    ∃ n : ℕ, (D : R → R)^[n] r ≠ 0 ∧ D ((D : R → R)^[n] r) = 0 := by
+  obtain ⟨m, hm⟩ := h
+  induction m generalizing r with
+  | zero => exact (hr hm).elim
+  | succ m ih =>
+    by_cases hdr : D r = 0
+    · exact ⟨0, hr, hdr⟩
+    · rw [Function.iterate_succ_apply] at hm
+      obtain ⟨n, hn, hdn⟩ := ih hdr hm
+      exact ⟨n+1, by simpa only [Function.iterate_succ_apply] using hn,
+        by simpa only [Function.iterate_succ_apply] using hdn⟩
+
+omit [CharZero k] [CharZero K] in
+lemma exists_slice (D : Derivation k R R) (hD : LND.LocallyNilpotent D) (hne : D ≠ 0) :
+    ∃ t : K, extend D t = 1 := by
+  obtain ⟨r, hr⟩ : ∃ r : R, D r ≠ 0 := by
+    by_contra h
+    push Not at h
+    apply hne
+    ext r
+    exact h r
+  obtain ⟨n, hn, hdn⟩ := last_nonzero D hr (hD (D r))
+  let s := (D : R → R)^[n] r
+  have hs : D s ≠ 0 := by simpa only [s, ← Function.iterate_succ_apply',
+    Function.iterate_succ_apply] using hn
+  have hss : D (D s) = 0 := by simpa only [s, ← Function.iterate_succ_apply',
+    Function.iterate_succ_apply] using hdn
+  refine ⟨algebraMap R K s / algebraMap R K (D s), ?_⟩
+  have hs' : algebraMap R K (D s) ≠ 0 := by simpa using (IsFractionRing.injective R K).ne hs
+  rw [Derivation.leibniz_div]
+  simp only [extend_algebraMap, hss, map_zero, smul_eq_mul]
+  field_simp
+  ring
+
+omit [CharZero k] [CharZero K] in
+lemma iterate_constant_mul (D : Derivation k K K) {c : K} (hc : D c = 0) (r : K) (n : ℕ) :
+    (D : K → K)^[n] (c * r) = c * (D : K → K)^[n] r := by
+  induction n with
+  | zero => rfl
+  | succ n ih =>
+    rw [Function.iterate_succ_apply', ih, Derivation.leibniz, hc,
+      smul_zero, add_zero, smul_eq_mul, Function.iterate_succ_apply']
+
+omit [CharZero k] [CharZero K] in
+lemma constant_fraction (D : Derivation k R R) (hD : LND.LocallyNilpotent D)
+    {c : K} (hc : extend D c = 0) :
+    ∃ a b : R, D a = 0 ∧ D b = 0 ∧ b ≠ 0 ∧ algebraMap R K a / algebraMap R K b = c := by
+  obtain ⟨a, b, hb, hab⟩ := IsFractionRing.div_surjective R c
+  have hb0 : b ≠ 0 := nonZeroDivisors.ne_zero hb
+  obtain ⟨n, hn, hdn⟩ := last_nonzero D hb0 (hD b)
+  have hbK : algebraMap R K b ≠ 0 := by simpa using (IsFractionRing.injective R K).ne hb0
+  have hz : c * algebraMap R K b = algebraMap R K a := by rw [← hab]; exact div_mul_cancel₀ _ hbK
+  have he := congrArg (fun z : K => (extend D : K → K)^[n] z) hz
+  rw [iterate_constant_mul _ hc, iterate_algebraMap, iterate_algebraMap] at he
+  refine ⟨(D : R → R)^[n] a, (D : R → R)^[n] b, ?_, hdn, hn, ?_⟩
+  · apply IsFractionRing.injective R K
+    rw [map_zero, ← extend_algebraMap, ← he, Derivation.leibniz, hc,
+      extend_algebraMap, hdn, map_zero, smul_zero, smul_zero, add_zero]
+  · rw [← he, mul_div_cancel_right₀ _ (by simpa using (IsFractionRing.injective R K).ne hn)]
+
+omit [CharZero k] [IsDomain R] in
+lemma image_is_polynomial (D : Derivation k R R) (hD : LND.LocallyNilpotent D)
+    {t : K} (ht : extend D t = 1) (r : R) :
+    ∃ p : Polynomial (constants (extend (K := K) D)), Polynomial.aeval t p = algebraMap R K r := by
+  apply nilpotent_is_polynomial _ ht
+  obtain ⟨n, hn⟩ := hD r
+  exact ⟨n, by rw [iterate_algebraMap, hn, map_zero]⟩
+
+end ComplexCancellation.RationalSlice
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/AffineCancellation/Rees.lean b/lean/OAI/Algebra/AffineCancellation/Rees.lean
new file mode 100644
index 0000000000000000000000000000000000000000..eebb3a67d6e76024d2ce7e3afe5c6e96aeceff86
--- /dev/null
+++ b/lean/OAI/Algebra/AffineCancellation/Rees.lean
@@ -0,0 +1,126 @@
+import OAI.Algebra.AffineCancellation.Cylinder
+import OAI.Algebra.AffineCancellation.Dimension
+
+namespace OAI
+
+noncomputable section
+
+namespace ComplexCancellation.Rees
+open MvPolynomial
+abbrev Poly := MvPolynomial (Fin 6) ℂ
+def xp : Poly := X 2^2+X 3^3+X 1^2*X 4
+def relation : Poly := xp^2*X 4-(1+2*X 2*xp)*X 5-X 1^2*X 5^2-X 0^3*X 1*X 3
+abbrev B := Poly ⧸ Ideal.span {relation}
+def π : Poly →ₐ[ℂ] B := Ideal.Quotient.mkₐ ℂ _
+def q : B := π (X 0)
+lemma relation_zero : π relation=0 := Ideal.Quotient.eq_zero_iff_mem.mpr (Ideal.subset_span (by simp))
+lemma q_regular : IsLeftRegular q := by
+  apply Cylinder.regular_quotient_of_prime (MvPolynomial.X_prime (i := 0))
+  intro h
+  have he := map_dvd (MvPolynomial.eval (fun i : Fin 6 => if i=5 then (1:ℂ) else 0)) h
+  norm_num [relation,xp,Fin.ext_iff] at he
+abbrev L := LaurentPolynomial A
+def c : A →ₐ[ℂ] L := IsScalarTower.toAlgHom ℂ A L
+def aπ : P →ₐ[ℂ] A := Ideal.Quotient.mkₐ ℂ _
+def a (i : Fin 5) : L := c (aπ (X i))
+def values : Fin 6 → L := ![LaurentPolynomial.T 1,a 0*LaurentPolynomial.T (-1),
+  a 1,a 2,a 3*LaurentPolynomial.T 2,a 4*LaurentPolynomial.T 2]
+def eval : Poly →ₐ[ℂ] L := aeval values
+lemma eval_xp : eval xp = c (aπ ComplexCancellation.x) := by
+  simp only [xp,eval,aeval_X,values,Matrix.cons_val,Matrix.cons_val_zero,Matrix.cons_val_one,
+    ComplexCancellation.x,ComplexCancellation.s,ComplexCancellation.p,ComplexCancellation.u,
+    ComplexCancellation.F,map_add,map_mul,map_pow,a]
+  have ht : (LaurentPolynomial.T (-1):L)^2*LaurentPolynomial.T 2=1 := by
+    rw [LaurentPolynomial.T_pow,← LaurentPolynomial.T_add]; norm_num
+  linear_combination c (aπ (X 0))^2*c (aπ (X 3))*ht
+lemma eval_relation : eval relation = 0 := by
+  have h : c (aπ H) = 0 := by
+    rw [show aπ H=0 from Ideal.Quotient.eq_zero_iff_mem.mpr (Ideal.subset_span (by simp)),map_zero]
+  have hh : eval relation = c (aπ H)*LaurentPolynomial.T 2 := by
+    simp only [relation,map_sub,map_mul,map_add,map_pow,map_one,map_ofNat,eval_xp]
+    simp only [eval,aeval_X,values,Matrix.cons_val,Matrix.cons_val_zero,Matrix.cons_val_one]
+    simp only [H,ComplexCancellation.F,ComplexCancellation.J,ComplexCancellation.p,
+      ComplexCancellation.s,ComplexCancellation.u,map_sub,map_mul,map_add,map_pow,map_one,map_ofNat,a]
+    have ht : (LaurentPolynomial.T (-1):L)^2*LaurentPolynomial.T 2=1 := by
+      rw [LaurentPolynomial.T_pow,← LaurentPolynomial.T_add]; norm_num
+    have ht' : (LaurentPolynomial.T 1:L)^3*LaurentPolynomial.T (-1)=LaurentPolynomial.T 2 := by
+      rw [LaurentPolynomial.T_pow,← LaurentPolynomial.T_add]; norm_num
+    linear_combination
+      -(c (aπ (X 0)))^2*c (aπ (X 4))^2*LaurentPolynomial.T 2*ht -
+      c (aπ (X 0))*c (aπ (X 2))*ht'
+
+  rw [hh,h,zero_mul]
+def embedding : B →ₐ[ℂ] L := Ideal.Quotient.liftₐ _ eval (by
+  intro r hr
+  obtain ⟨t,rfl⟩ := Ideal.mem_span_singleton.mp hr
+  rw [map_mul,eval_relation,zero_mul])
+@[simp] lemma embedding_π (r : Poly) : embedding (π r)=eval r := Ideal.Quotient.lift_mk _ _ _
+
+abbrev Bq := Localization.Away q
+def loc : B →ₐ[ℂ] Bq := IsScalarTower.toAlgHom ℂ B Bq
+def Q : Bqˣ := (IsLocalization.Away.algebraMap_isUnit q).unit
+lemma Q_val : (Q : Bq)=loc q := IsUnit.unit_spec _
+lemma loc_injective : Function.Injective loc := by
+  apply IsLocalization.injectiveₛ (M := Submonoid.powers q) Bq
+  rintro r ⟨n,rfl⟩
+  exact isLeftRegular_iff_isRegular.mp (q_regular.pow n)
+def backValues : Fin 5 → Bq := ![(Q:Bq)*loc (π (X 1)),loc (π (X 2)),
+  loc (π (X 3)),(↑(Q⁻¹):Bq)^2*loc (π (X 4)),(↑(Q⁻¹):Bq)^2*loc (π (X 5))]
+def backEval : P →ₐ[ℂ] Bq := aeval backValues
+lemma backEval_x : backEval ComplexCancellation.x = loc (π xp) := by
+  simp only [ComplexCancellation.x,ComplexCancellation.p,ComplexCancellation.s,
+    ComplexCancellation.u,ComplexCancellation.F,backEval,map_add,map_mul,map_pow,aeval_X,
+    backValues,Matrix.cons_val,Matrix.cons_val_zero,Matrix.cons_val_one,xp]
+  simp only [mul_pow]
+  have h : (Q:Bq)^2*(↑(Q⁻¹):Bq)^2=1 := by rw [← mul_pow,Units.mul_inv,one_pow]
+  linear_combination loc (π (X 1))^2*loc (π (X 4))*h
+lemma backEval_H : backEval H=0 := by
+  have h : loc (π relation)=0 := by rw [relation_zero,map_zero]
+  have he : (Q:Bq)^2*backEval H=loc (π relation) := by
+    simp only [H,map_sub,map_mul,map_add,map_pow,map_one,map_ofNat,backEval_x]
+    simp only [ComplexCancellation.p,ComplexCancellation.s,ComplexCancellation.u,
+      ComplexCancellation.F,ComplexCancellation.J,backEval,aeval_X,backValues,
+      Matrix.cons_val,Matrix.cons_val_zero,Matrix.cons_val_one]
+    simp only [relation,map_sub,map_mul,map_add,map_pow,map_one,map_ofNat]
+    rw [show loc (π (X 0))=(Q:Bq) from Q_val.symm]
+    have h2 : (Q:Bq)^2*(↑(Q⁻¹):Bq)^2=1 := by rw [← mul_pow,Units.mul_inv,one_pow]
+    have h4 : (Q:Bq)^4*(↑(Q⁻¹):Bq)^4=1 := by rw [← mul_pow,Units.mul_inv,one_pow]
+    linear_combination
+      (loc (π xp)^2*loc (π (X 4))-(1+2*loc (π (X 2))*loc (π xp))*loc (π (X 5)))*h2-
+      loc (π (X 1))^2*loc (π (X 5))^2*h4
+  apply (Q.isUnit.pow 2).mul_right_inj.mp
+  rw [mul_zero,he,h]
+def backCoefficients : A →ₐ[ℂ] Bq := Ideal.Quotient.liftₐ _ backEval (by
+  intro r hr
+  obtain ⟨t,rfl⟩ := Ideal.mem_span_singleton.mp hr
+  rw [map_mul,backEval_H,zero_mul])
+@[simp] lemma backCoefficients_aπ (r : P) : backCoefficients (aπ r)=backEval r :=
+  Ideal.Quotient.lift_mk _ _ _
+def backward : L →ₐ[ℂ] Bq where
+  __ := LaurentPolynomial.eval₂ backCoefficients.toRingHom Q
+  commutes' r := by
+    change LaurentPolynomial.eval₂ backCoefficients.toRingHom Q (LaurentPolynomial.C (algebraMap ℂ A r)) = _
+    rw [LaurentPolynomial.eval₂_C]
+    exact backCoefficients.commutes r
+lemma backward_embedding : backward.comp embedding=loc := by
+  apply Ideal.Quotient.algHom_ext
+  apply MvPolynomial.algHom_ext
+  intro i
+  change backward (eval (X i))=loc (π (X i))
+  fin_cases i <;> simp [eval,values,Matrix.cons_val,backward,a,c,backEval,backValues,
+    backCoefficients_aπ,IsScalarTower.toAlgHom]
+  · exact Q_val
+  · rw [mul_right_comm,Units.mul_inv,one_mul]
+  · rw [mul_right_comm,← mul_pow,Units.inv_mul,one_pow,one_mul]
+  · rw [mul_right_comm,← mul_pow,Units.inv_mul,one_pow,one_mul]
+lemma embedding_injective : Function.Injective embedding := by
+  apply Function.Injective.of_comp (f := backward)
+  rw [← AlgHom.coe_comp,backward_embedding]
+  exact loc_injective
+instance : IsDomain B := Function.Injective.isDomain embedding embedding_injective
+instance : IsNoetherianRing B := Algebra.FiniteType.isNoetherianRing ℂ B
+end ComplexCancellation.Rees
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/AffineCancellation/ReesClearing.lean b/lean/OAI/Algebra/AffineCancellation/ReesClearing.lean
new file mode 100644
index 0000000000000000000000000000000000000000..ba109e1c933c0de439662ea7a8b49e3569443ef0
--- /dev/null
+++ b/lean/OAI/Algebra/AffineCancellation/ReesClearing.lean
@@ -0,0 +1,82 @@
+import OAI.Algebra.AffineCancellation.ReesReduction
+
+namespace OAI
+
+noncomputable section
+
+namespace ComplexCancellation.Rees
+open MvPolynomial LaurentPolynomial
+lemma embedding_q : embedding q=T 1 := by simp [q,eval,values]
+lemma q_nonzero : q ≠ 0 := by
+  intro h
+  have := congrArg embedding h
+  rw [embedding_q,map_zero] at this
+  exact (isUnit_T (R := A) 1).ne_zero this
+lemma clear_coefficient (r : A) : c r ∈ Clearing.subalgebra embedding q := by
+  obtain ⟨r,rfl⟩ := Ideal.Quotient.mkₐ_surjective ℂ _ r
+  change c (aπ r) ∈ _
+  induction r using MvPolynomial.induction_on with
+  | C z =>
+    refine ⟨0,algebraMap ℂ B z,?_⟩
+    rw [pow_zero,one_mul]
+    have ha : aπ (MvPolynomial.C z)=algebraMap ℂ A z := aπ.commutes z
+    rw [ha,c.commutes,embedding.commutes]
+  | add r s hr hs => rw [map_add,map_add]; exact add_mem hr hs
+  | mul_X r i hr =>
+    rw [map_mul,map_mul]
+    apply mul_mem hr
+    fin_cases i
+    · refine ⟨0,q*π (X 1),?_⟩
+      simp only [pow_zero,one_mul,map_mul,embedding_q,embedding_π,eval,aeval_X,
+        values,Matrix.cons_val_zero,Matrix.cons_val_one,a]
+      change c (aπ (X 0))=T 1*(c (aπ (X 0))*T (-1))
+      rw [mul_left_comm (T 1 : L),← T_add]
+      norm_num
+    · refine ⟨0,π (X 2),?_⟩
+      simp only [pow_zero,one_mul,embedding_π,eval,aeval_X,values,Matrix.cons_val,a]
+      rfl
+    · refine ⟨0,π (X 3),?_⟩
+      simp only [pow_zero,one_mul,embedding_π,eval,aeval_X,values,Matrix.cons_val,a]
+      rfl
+    · refine ⟨2,π (X 4),?_⟩
+      simp only [embedding_q,T_pow,embedding_π,eval,aeval_X,values,Matrix.cons_val,a]
+      change T 2*c (aπ (X 3))=c (aπ (X 3))*T 2
+      exact mul_comm (T 2 : L) (c (aπ (X 3)))
+    · refine ⟨2,π (X 5),?_⟩
+      simp only [embedding_q,T_pow,embedding_π,eval,aeval_X,values,Matrix.cons_val,a]
+      change T 2*c (aπ (X 4))=c (aπ (X 4))*T 2
+      exact mul_comm (T 2 : L) (c (aπ (X 4)))
+
+lemma clear_T (n : ℤ) : (T n : L) ∈ Clearing.subalgebra embedding q := by
+  obtain ⟨m,hm⟩ : ∃ m : ℕ, 0 ≤ (m : ℤ)+n := ⟨n.natAbs,by omega⟩
+  refine ⟨m,q^((m : ℤ)+n).toNat,?_⟩
+  rw [map_pow,embedding_q,T_pow,T_pow,← T_add]
+  congr 1
+  simp only [mul_one,Int.toNat_of_nonneg hm]
+lemma clear_all (r : L) : ∃ n : ℕ, ∃ s : B, embedding q^n*r=embedding s := by
+  change r ∈ Clearing.subalgebra embedding q
+  induction r using LaurentPolynomial.induction_on' with
+  | add r s hr hs => exact add_mem hr hs
+  | C_mul_T n r => exact mul_mem (clear_coefficient r) (clear_T n)
+lemma clear_order (r : L) (hr : r ≠ 0) :
+    ∃ (i : ℤ) (s : B), red s ≠ 0 ∧ embedding s=T i*r := by
+  obtain ⟨n,b,hb⟩ := clear_all r
+  have hb0 : b ≠ 0 := by
+    intro hz
+    rw [hz,map_zero] at hb
+    exact mul_ne_zero (pow_ne_zero n (by rw [embedding_q]; exact (isUnit_T _).ne_zero)) hr hb
+  obtain ⟨m,s,hs,hbs⟩ := maximum_q_factor hb0
+  refine ⟨(n:ℤ)-m,s,hs,?_⟩
+  rw [hbs,map_mul,map_pow,embedding_q,T_pow,T_pow] at hb
+  have he := congrArg (fun t : L => T (-(m:ℤ))*t) hb
+  simp only [mul_one] at he
+  have h₀ : T (-(m:ℤ))*(T (m:ℤ):L)=1 := by rw [← T_add]; simp
+  rw [← mul_assoc (T (-(m:ℤ))) (T (m:ℤ)) (embedding s),h₀,one_mul] at he
+  rw [← mul_assoc,← T_add] at he
+  rw [show -(m:ℤ)+(n:ℤ)=(n:ℤ)-m by omega] at he
+  exact he.symm
+end ComplexCancellation.Rees
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/AffineCancellation/ReesDerivation.lean b/lean/OAI/Algebra/AffineCancellation/ReesDerivation.lean
new file mode 100644
index 0000000000000000000000000000000000000000..75c6203f276a7a522393cf0f0adf37d79eca0514
--- /dev/null
+++ b/lean/OAI/Algebra/AffineCancellation/ReesDerivation.lean
@@ -0,0 +1,145 @@
+import OAI.Algebra.AffineCancellation.Primitive
+import OAI.Algebra.AffineCancellation.LaurentDerivation
+import OAI.Algebra.AffineCancellation.ReesClearing
+
+namespace OAI
+
+noncomputable section
+
+namespace ComplexCancellation.Rees
+open MvPolynomial LaurentPolynomial
+lemma uniform_clear (f : Fin 6 → L) :
+    ∃ n : ℕ, ∀ i, ∃ b : B, embedding q^n*f i=embedding b := by
+  classical
+  choose n b hb using fun i => clear_all (f i)
+  refine ⟨∑ i, n i, fun i => ⟨q^((∑ j,n j)-n i)*b i,?_⟩⟩
+  have hi : n i ≤ ∑ j, n j := Finset.single_le_sum (fun j _ => Nat.zero_le (n j)) (Finset.mem_univ i)
+  rw [map_mul,map_pow,← hb,← mul_assoc,← pow_add,Nat.sub_add_cancel hi]
+lemma stable_of_generators (E : Derivation ℂ L L)
+    (h : ∀ i : Fin 6, ∃ t : B, E (embedding (π (X i)))=embedding t) :
+    ∀ b : B, ∃ t : B, E (embedding b)=embedding t := by
+  intro b
+  obtain ⟨r,rfl⟩ := Ideal.Quotient.mkₐ_surjective ℂ _ b
+  change ∃ t, E (embedding (π r))=embedding t
+  induction r using MvPolynomial.induction_on with
+  | C z => exact ⟨0,by simp only [MvPolynomial.C_eq_algebraMap,AlgHom.commutes,
+      Derivation.map_algebraMap,map_zero]⟩
+  | add r s hr hs =>
+    obtain ⟨r',hr'⟩ := hr
+    obtain ⟨s',hs'⟩ := hs
+    exact ⟨r'+s',by rw [map_add,map_add,map_add,hr',hs',map_add]⟩
+  | mul_X r i hr =>
+    obtain ⟨r',hr'⟩ := hr
+    obtain ⟨s',hs'⟩ := h i
+    refine ⟨π r*s'+π (X i)*r',?_⟩
+    rw [map_mul,map_mul,Derivation.leibniz,hr',hs',smul_eq_mul,smul_eq_mul,
+      map_add,map_mul,map_mul]
+lemma clear_annihilate (D : Derivation ℂ A A) (n : ℕ)
+    (h : ∀ b : B, embedding q^n * LaurentDerivation.extension D (embedding b)=0) : D=0 := by
+  let D' := LaurentDerivation.extension D
+  have hq : D' (embedding q)=0 := by rw [embedding_q]; exact LaurentDerivation.extension_T D 1
+  have hnon : embedding q^n ≠ 0 := pow_ne_zero n (by rw [embedding_q]; exact (isUnit_T _).ne_zero)
+  ext a
+  obtain ⟨m,b,hb⟩ := clear_all (c a)
+  have hd : D' (embedding b)=0 := (mul_eq_zero.mp (h b)).resolve_left hnon
+  have he := congrArg D' hb
+  rw [Derivation.leibniz,Derivation.leibniz_pow,hq,smul_zero,smul_zero,smul_zero,add_zero,hd] at he
+  have ha : D' (c a)=0 := (smul_eq_zero.mp he).resolve_left (pow_ne_zero m (by rw [embedding_q]; exact (isUnit_T _).ne_zero))
+  change LaurentDerivation.extension D (LaurentPolynomial.C a)=0 at ha
+  rw [LaurentDerivation.extension_C] at ha
+  have hz := congrArg (fun t : L => t.coeff 0) ha
+  simpa [LaurentPolynomial.C_apply] using hz
+lemma scaled_is_ln (D : Derivation ℂ A A) (hD : LND.LocallyNilpotent D) (n : ℕ) :
+    LND.LocallyNilpotent (k := ℂ) (R := L) (embedding q^n • LaurentDerivation.extension D) := by
+  apply LND.replica _ (LaurentDerivation.locallyNilpotent D hD)
+  rw [Derivation.leibniz_pow,embedding_q,LaurentDerivation.extension_T,smul_zero,smul_zero]
+lemma scaled_fixes (D : Derivation ℂ A A) (r : A) (hDr : D r=0) (i : ℤ) (s : B)
+    (hs : embedding s=T i*c r) (n : ℕ) :
+    (embedding q^n • LaurentDerivation.extension D) (embedding s)=0 := by
+  have he : LaurentDerivation.extension D (embedding s)=0 := by
+    rw [hs,Derivation.leibniz]
+    have hr : LaurentDerivation.extension D (c r)=0 := by
+      change LaurentDerivation.extension D (LaurentPolynomial.C r)=0
+      rw [LaurentDerivation.extension_C,hDr,map_zero]
+    rw [hr,LaurentDerivation.extension_T,smul_zero,smul_zero,add_zero]
+  exact (congrArg (fun z : L => embedding q^n*z) he).trans (mul_zero _)
+
+lemma restrict_stable (E' : Derivation ℂ L L) (hE' : LND.LocallyNilpotent (k := ℂ) (R := L) E')
+    (hstable : ∀ b : B, ∃ t : B, E' (embedding b)=embedding t) :
+    ∃ E : Derivation ℂ B B, LND.LocallyNilpotent E ∧ ∀ b, E' (embedding b)=embedding (E b) := by
+  have hfac : ∀ b : B, ∃ t : B, E' (embedding b)=1*embedding t := by simpa only [one_mul] using hstable
+  let E := FactorDerivation.derivation (k := ℂ) (R := L) embedding embedding_injective E' 1 one_ne_zero hfac
+  have hspec (b : B) : E' (embedding b)=embedding (E b) := by
+    simpa only [one_mul] using FactorDerivation.apply_spec (k := ℂ) (R := L) embedding embedding_injective E' 1 one_ne_zero hfac b
+  exact ⟨E,LND.cancel_factor_locallyNilpotent (k := ℂ) (R := L) embedding embedding_injective E' hE' E one_ne_zero (by simpa only [one_mul] using hspec),hspec⟩
+lemma scaled_restriction (D : Derivation ℂ A A) (hD : LND.LocallyNilpotent D)
+    (hDn : D ≠ 0) (r : A) (hDr : D r=0) (i : ℤ) (s : B)
+    (hs : embedding s=T i*c r) :
+    ∃ E : Derivation ℂ B B, LND.LocallyNilpotent E ∧ E ≠ 0 ∧ E q=0 ∧ E s=0 := by
+  obtain ⟨n,hn⟩ := uniform_clear (fun i => LaurentDerivation.extension D (embedding (π (X i))))
+  let E' := embedding q^n • LaurentDerivation.extension D
+  have hgen (i : Fin 6) : ∃ t : B, E' (embedding (π (X i)))=embedding t := hn i
+  obtain ⟨E,hE,hspec⟩ := restrict_stable E' (scaled_is_ln D hD n) (stable_of_generators E' hgen)
+  refine ⟨E,hE,?_,?_,?_⟩
+  · intro hz
+    apply hDn
+    apply clear_annihilate D n
+    intro b
+    change E' (embedding b)=0
+    rw [hspec,hz,Derivation.zero_apply,map_zero]
+  · apply embedding_injective
+    rw [map_zero,← hspec]
+    change embedding q^n*LaurentDerivation.extension D (embedding q)=0
+    rw [embedding_q,LaurentDerivation.extension_T,mul_zero]
+  · apply embedding_injective
+    rw [map_zero,← hspec]
+    exact scaled_fixes D r hDr i s hs n
+
+def up : Degeneration.P →ₐ[ℂ] B := aeval ![π (X 1),π (X 2),π (X 3),π (X 4),π (X 5)]
+lemma red_up : red.comp up=Degeneration.π := by
+  apply MvPolynomial.algHom_ext
+  intro i
+  fin_cases i <;> simp [up,redEval,redValues,Matrix.cons_val,
+    Degeneration.p,Degeneration.s,Degeneration.u,Degeneration.F,Degeneration.J]
+lemma red_surjective : Function.Surjective red := by
+  intro r
+  obtain ⟨p,rfl⟩ := Ideal.Quotient.mkₐ_surjective ℂ _ r
+  exact ⟨up p,DFunLike.congr_fun red_up p⟩
+lemma primitive_reduction (E : Derivation ℂ B B) (hE : LND.LocallyNilpotent E)
+    (hEn : E ≠ 0) (hEq : E q=0) (s : B) (hEs : E s=0) :
+    ∃ D : Derivation ℂ Degeneration.G Degeneration.G,
+      LND.LocallyNilpotent D ∧ D ≠ 0 ∧ D (red s)=0 := by
+  obtain ⟨b,hb⟩ : ∃ b, E b ≠ 0 := by
+    by_contra hn
+    push Not at hn
+    apply hEn
+    ext b
+    exact hn b
+  obtain ⟨n,t,ht,he⟩ := maximum_q_factor hb
+  obtain ⟨E',hE',hEq',hEs',r,hr⟩ := LND.primitive_of_order q q_nonzero s b t
+    (mt (red_zero_iff t).mpr ht) n E hE hEq hEs he
+  have hk (b : B) (hb : red b=0) : red (E' b)=0 := by
+    obtain ⟨t,rfl⟩ := (red_zero_iff b).mp hb
+    simp only [Derivation.leibniz,hEq',smul_eq_mul,mul_zero,add_zero,
+      map_mul,red_q,zero_mul]
+  let D := Derivation.liftOfSurjective red_surjective hk
+  have hspec (b : B) : D (red b)=red (E' b) := Derivation.liftOfSurjective_apply red_surjective hk b
+  have hiter (b : B) (n : ℕ) : (D : Degeneration.G → Degeneration.G)^[n] (red b)=red ((E' : B → B)^[n] b) := by
+    induction n with
+    | zero => rfl
+    | succ n ih => rw [Function.iterate_succ_apply',ih,hspec,Function.iterate_succ_apply']
+  refine ⟨D,?_,?_,?_⟩
+  · intro b
+    obtain ⟨b,rfl⟩ := red_surjective b
+    obtain ⟨n,hn⟩ := hE' b
+    exact ⟨n,by rw [hiter,hn,map_zero]⟩
+  · intro hz
+    apply hr
+    apply (red_zero_iff (E' r)).mp
+    rw [← hspec,hz,Derivation.zero_apply]
+  · rw [hspec,hEs',map_zero]
+end ComplexCancellation.Rees
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/AffineCancellation/ReesGrading.lean b/lean/OAI/Algebra/AffineCancellation/ReesGrading.lean
new file mode 100644
index 0000000000000000000000000000000000000000..bd5f4a8559f7854646f1a9fcae49260f48916d94
--- /dev/null
+++ b/lean/OAI/Algebra/AffineCancellation/ReesGrading.lean
@@ -0,0 +1,100 @@
+import OAI.Algebra.AffineCancellation.ReesDerivation
+import OAI.Algebra.AffineCancellation.GradedMap
+import OAI.Algebra.AffineCancellation.DegenerationGrading
+
+namespace OAI
+
+noncomputable section
+
+namespace ComplexCancellation.Rees
+open MvPolynomial LaurentPolynomial
+attribute [local instance] MvPolynomial.weightedGradedAlgebra
+def weight (i : Fin 6) : ℤ := if i=0 then 1 else if i=1 then -1 else if i=2 ∨ i=3 then 0 else 2
+def sourcePieces (e : ℤ) := weightedHomogeneousSubmodule ℂ weight e
+instance sourceGrading : GradedAlgebra sourcePieces := inferInstanceAs (GradedAlgebra (weightedHomogeneousSubmodule ℂ weight))
+lemma xp_homogeneous : IsWeightedHomogeneous weight xp 0 := by
+  have h₁ : IsWeightedHomogeneous weight ((X 2 : Poly)^2) 0 := by
+    convert (isWeightedHomogeneous_X ℂ weight 2).pow 2 using 1; try simp only [map_ofNat]
+    all_goals norm_num [weight,Fin.ext_iff]
+  have h₂ : IsWeightedHomogeneous weight ((X 3 : Poly)^3) 0 := by
+    convert (isWeightedHomogeneous_X ℂ weight 3).pow 3 using 1; try simp only [map_ofNat]
+    all_goals norm_num [weight,Fin.ext_iff]
+  have h₃ : IsWeightedHomogeneous weight ((X 1 : Poly)^2*X 4) 0 := by
+    convert ((isWeightedHomogeneous_X ℂ weight 1).pow 2).mul (isWeightedHomogeneous_X ℂ weight 4) using 1; try simp only [map_ofNat]
+    all_goals norm_num [weight,Fin.ext_iff]
+  exact (h₁.add h₂).add h₃
+lemma relation_homogeneous : relation ∈ sourcePieces 2 := by
+  have h₁ : IsWeightedHomogeneous weight (xp^2*X 4) 2 := by
+    convert (xp_homogeneous.pow 2).mul (isWeightedHomogeneous_X ℂ weight 4) using 1; try simp only [map_ofNat]
+    all_goals norm_num [weight,Fin.ext_iff]
+  have h₂ : IsWeightedHomogeneous weight (1+2*X 2*xp : Poly) 0 := by
+    apply (isWeightedHomogeneous_one ℂ weight).add
+    convert ((isWeightedHomogeneous_C weight (2:ℂ)).mul (isWeightedHomogeneous_X ℂ weight 2)).mul xp_homogeneous using 1 <;> try simp only [map_ofNat]
+    all_goals norm_num [weight,Fin.ext_iff]
+  have h₃ : IsWeightedHomogeneous weight ((1+2*X 2*xp)*X 5 : Poly) 2 := by
+    convert h₂.mul (isWeightedHomogeneous_X ℂ weight 5) using 1; try simp only [map_ofNat]
+    all_goals norm_num [weight,Fin.ext_iff]
+  have h₄ : IsWeightedHomogeneous weight (X 1^2*X 5^2 : Poly) 2 := by
+    convert ((isWeightedHomogeneous_X ℂ weight 1).pow 2).mul ((isWeightedHomogeneous_X ℂ weight 5).pow 2) using 1; try simp only [map_ofNat]
+    all_goals norm_num [weight,Fin.ext_iff]
+  have h₅ : IsWeightedHomogeneous weight (X 0^3*X 1*X 3 : Poly) 2 := by
+    convert (((isWeightedHomogeneous_X ℂ weight 0).pow 3).mul (isWeightedHomogeneous_X ℂ weight 1)).mul (isWeightedHomogeneous_X ℂ weight 3) using 1; try simp only [map_ofNat]
+    all_goals norm_num [weight,Fin.ext_iff]
+  exact ((h₁.sub h₃).sub h₄).sub h₅
+lemma kernel_homogeneous : (RingHom.ker π).IsHomogeneous sourcePieces := by
+  change (RingHom.ker (Ideal.Quotient.mk (Ideal.span {relation}))).IsHomogeneous _
+  rw [Ideal.mk_ker]
+  apply Ideal.homogeneous_span
+  intro r hr
+  obtain rfl := Set.mem_singleton_iff.mp hr
+  exact ⟨2,relation_homogeneous⟩
+def pieces : ℤ → Submodule ℂ B := QuotientGrading.pieces sourcePieces π
+instance grading : GradedAlgebra pieces := QuotientGrading.grading _ _ (Ideal.Quotient.mkₐ_surjective ℂ _) kernel_homogeneous
+abbrev laurentPieces (e : ℤ) : Submodule ℂ L := (AddMonoidAlgebra.grade A e).restrictScalars ℂ
+instance laurentGrading : GradedAlgebra laurentPieces := { (AddMonoidAlgebra.grade.gradedAlgebra (R := A) (ι := ℤ)) with }
+lemma laurentMonomial_mem (r : A) (e : ℤ) : LaurentPolynomial.C r*T e ∈ laurentPieces e := by
+  rw [← LaurentPolynomial.single_eq_C_mul_T]
+  exact AddMonoidAlgebra.single_mem_grade e r
+lemma embedding_graded (e : ℤ) (b : B) (hb : b ∈ pieces e) : embedding b ∈ laurentPieces e := by
+  obtain ⟨p,hp,rfl⟩ := hb
+  change embedding (π p) ∈ _
+  rw [embedding_π]
+  apply GradedMap.mvpolynomial (k := ℂ) (R := L) laurentPieces weight eval _ hp
+  intro i
+  fin_cases i <;> simp only [eval,aeval_X,values,weight]
+  · simpa using laurentMonomial_mem 1 1
+  · exact laurentMonomial_mem _ _
+  · change c (aπ (X 1)) ∈ laurentPieces 0
+    have h := laurentMonomial_mem (aπ (X 1)) 0
+    rw [T_zero,mul_one] at h
+    exact h
+  · change c (aπ (X 2)) ∈ laurentPieces 0
+    have h := laurentMonomial_mem (aπ (X 2)) 0
+    rw [T_zero,mul_one] at h
+    exact h
+  · exact laurentMonomial_mem _ _
+  · exact laurentMonomial_mem _ _
+lemma red_graded (e : ℤ) (b : B) (hb : b ∈ pieces e) : red b ∈ Degeneration.pieces e := by
+  obtain ⟨p,hp,rfl⟩ := hb
+  change red (π p) ∈ _
+  rw [red_π]
+  apply GradedMap.mvpolynomial Degeneration.pieces weight redEval _ hp
+  intro i
+  fin_cases i <;> simp only [redEval,aeval_X,redValues,weight]
+  · exact (Degeneration.pieces 1).zero_mem
+  · exact Degeneration.X_mem 0
+  · exact Degeneration.X_mem 1
+  · exact Degeneration.X_mem 2
+  · exact Degeneration.X_mem 3
+  · exact Degeneration.X_mem 4
+lemma red_monomial_mem (s : B) (r : A) (i : ℤ) (hs : embedding s=T i*c r) :
+    red s ∈ Degeneration.pieces i := by
+  apply red_graded
+  apply GradedMap.reflect (k := ℂ) (R := B) (S := L) pieces laurentPieces embedding embedding_injective embedding_graded
+  rw [hs,mul_comm (T i : L) (c r)]
+  exact laurentMonomial_mem _ _
+end ComplexCancellation.Rees
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/AffineCancellation/ReesReduction.lean b/lean/OAI/Algebra/AffineCancellation/ReesReduction.lean
new file mode 100644
index 0000000000000000000000000000000000000000..c5261e327d83d0326bd07a4e99f2f3a2e65a64eb
--- /dev/null
+++ b/lean/OAI/Algebra/AffineCancellation/ReesReduction.lean
@@ -0,0 +1,79 @@
+import OAI.Algebra.AffineCancellation.Degeneration
+import OAI.Algebra.AffineCancellation.Rees
+
+namespace OAI
+
+noncomputable section
+
+namespace ComplexCancellation.Rees
+open MvPolynomial
+def redValues : Fin 6 → Degeneration.G := ![0,Degeneration.p,Degeneration.s,
+  Degeneration.u,Degeneration.F,Degeneration.J]
+def redEval : Poly →ₐ[ℂ] Degeneration.G := aeval redValues
+lemma redEval_relation : redEval relation=0 := by
+  have h := Degeneration.relation_zero
+  simpa [relation,xp,redEval,redValues,Degeneration.relation,Degeneration.xp,
+    Degeneration.p,Degeneration.s,Degeneration.u,Degeneration.F,Degeneration.J,
+    Matrix.cons_val,map_ofNat] using h
+def red : B →ₐ[ℂ] Degeneration.G := Ideal.Quotient.liftₐ _ redEval (by
+  intro r hr
+  obtain ⟨t,rfl⟩ := Ideal.mem_span_singleton.mp hr
+  rw [map_mul,redEval_relation,zero_mul])
+@[simp] lemma red_π (r : Poly) : red (π r)=redEval r := Ideal.Quotient.lift_mk _ _ _
+@[simp] lemma red_q : red q=0 := by simp [q,redEval,redValues]
+abbrev Special := B ⧸ Ideal.span {q}
+def ρ : B →ₐ[ℂ] Special := Ideal.Quotient.mkₐ ℂ _
+def backRedValues : Fin 5 → Special := ![ρ (π (X 1)),ρ (π (X 2)),ρ (π (X 3)),
+  ρ (π (X 4)),ρ (π (X 5))]
+def backRedEval : Degeneration.P →ₐ[ℂ] Special := aeval backRedValues
+lemma ρ_q : ρ q=0 := Ideal.Quotient.eq_zero_iff_mem.mpr (Ideal.subset_span (by simp))
+lemma backRedEval_relation : backRedEval Degeneration.relation=0 := by
+  have h := congrArg ρ relation_zero
+  have hq := ρ_q
+  change ρ (π (X 0))=0 at hq
+  simp only [relation,xp,map_sub,map_mul,map_add,map_pow,map_one,map_ofNat,hq] at h
+  norm_num at h
+  simp only [backRedEval,backRedValues,Degeneration.relation,Degeneration.xp,aeval_X,map_sub,map_mul,map_add,map_pow,map_one,map_ofNat,Matrix.cons_val,Matrix.cons_val_zero,Matrix.cons_val_one]
+  linear_combination h
+def backRed : Degeneration.G →ₐ[ℂ] Special := Ideal.Quotient.liftₐ _ backRedEval (by
+  intro r hr
+  obtain ⟨t,rfl⟩ := Ideal.mem_span_singleton.mp hr
+  simp only [map_mul,backRedEval_relation]
+  ring)
+@[simp] lemma backRed_π (r : Degeneration.P) : backRed (Degeneration.π r)=backRedEval r :=
+  Ideal.Quotient.lift_mk _ _ _
+lemma backRed_red : backRed.comp red=ρ := by
+  apply Ideal.Quotient.algHom_ext
+  apply MvPolynomial.algHom_ext
+  intro i
+  change backRed (red (π (X i)))=ρ (π (X i))
+  fin_cases i <;>
+    simp [redEval,redValues,backRedEval,backRedValues,Matrix.cons_val,
+      Degeneration.p,Degeneration.s,Degeneration.u,Degeneration.F,Degeneration.J]
+  exact ρ_q.symm
+lemma red_zero_iff (r : B) : red r=0 ↔ q ∣ r := by
+  constructor
+  · intro hr
+    apply Ideal.mem_span_singleton.mp
+    apply Ideal.Quotient.eq_zero_iff_mem.mp
+    change ρ r=0
+    rw [← backRed_red]
+    simp [hr]
+  · rintro ⟨s,rfl⟩
+    simp
+lemma q_not_isUnit : ¬IsUnit q := by
+  intro h
+  have := h.map red.toMonoidHom
+  change IsUnit (red q) at this
+  rw [red_q] at this
+  exact not_isUnit_zero this
+lemma maximum_q_factor {r : B} (hr : r ≠ 0) :
+    ∃ (n : ℕ) (s : B), red s ≠ 0 ∧ r=q^n*s := by
+  let : WfDvdMonoid B := IsNoetherianRing.wfDvdMonoid
+  obtain ⟨n,s,hs,he⟩ := WfDvdMonoid.max_power_factor' hr q_not_isUnit
+  exact ⟨n,s,mt (red_zero_iff s).mp hs,he⟩
+end ComplexCancellation.Rees
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/AffineCancellation/RelativeClearing.lean b/lean/OAI/Algebra/AffineCancellation/RelativeClearing.lean
new file mode 100644
index 0000000000000000000000000000000000000000..fb88b2d23f3fb613655a465ea04282e6d2f811a2
--- /dev/null
+++ b/lean/OAI/Algebra/AffineCancellation/RelativeClearing.lean
@@ -0,0 +1,72 @@
+import OAI.Algebra.AffineCancellation.Model
+
+namespace OAI
+
+noncomputable section
+
+namespace ComplexCancellation.RelativeClearing
+variable {k A B R : Type*} [CommRing k] [CommRing A] [IsDomain A] [CommRing B] [CommRing R]
+  [Algebra k A] [Algebra k B] [Algebra k R]
+variable (h : A →ₐ[k] B) (f : B →ₐ[k] R) (D : Derivation k A A)
+def subalgebra : Subalgebra k R where
+  carrier := {r | ∃ c : A, ∃ b : B, D c=0 ∧ c≠0 ∧ f (h c)*r=f b}
+  algebraMap_mem' a := ⟨1,algebraMap k B a,D.map_one_eq_zero,one_ne_zero,by simp⟩
+  add_mem' := by
+    rintro r s ⟨c,b,hc,hcn,hcb⟩ ⟨d,e,hd,hdn,hde⟩
+    refine ⟨c*d,h d*b+h c*e,?_,mul_ne_zero hcn hdn,?_⟩
+    · rw [Derivation.leibniz,hc,hd,smul_zero,smul_zero,add_zero]
+    · simp only [map_mul,map_add]
+      calc f (h c)*f (h d)*(r+s)=f (h d)*(f (h c)*r)+f (h c)*(f (h d)*s) := by ring
+        _ = _ := by rw [hcb,hde]
+  mul_mem' := by
+    rintro r s ⟨c,b,hc,hcn,hcb⟩ ⟨d,e,hd,hdn,hde⟩
+    refine ⟨c*d,b*e,?_,mul_ne_zero hcn hdn,?_⟩
+    · rw [Derivation.leibniz,hc,hd,smul_zero,smul_zero,add_zero]
+    · simp only [map_mul]
+      calc f (h c)*f (h d)*(r*s)=(f (h c)*r)*(f (h d)*s) := by ring
+        _ = _ := by rw [hcb,hde]
+lemma image_mem (b : B) : f b ∈ subalgebra h f D := ⟨1,b,D.map_one_eq_zero,one_ne_zero,by simp⟩
+lemma uniform (s : Finset B) (E : Derivation k R R)
+    (hc : ∀ b, E (f b) ∈ subalgebra h f D) :
+    ∃ c : A, D c=0 ∧ c≠0 ∧ ∀ b∈s, ∃ t : B, f (h c)*E (f b)=f t := by
+  classical
+  induction s using Finset.induction_on with
+  | empty => exact ⟨1,D.map_one_eq_zero,one_ne_zero,by simp⟩
+  | @insert b s hbs ih =>
+    obtain ⟨c,t,hc,hcn,hct⟩ := hc b
+    obtain ⟨d,hd,hdn,hds⟩ := ih
+    refine ⟨c*d,?_,mul_ne_zero hcn hdn,?_⟩
+    · rw [Derivation.leibniz,hc,hd,smul_zero,smul_zero,add_zero]
+    · intro a ha
+      rcases Finset.mem_insert.mp ha with rfl|ha
+      · refine ⟨h d*t,?_⟩
+        simp only [map_mul]
+        calc f (h c)*f (h d)*E (f a)=f (h d)*(f (h c)*E (f a)) := by ring
+          _ = _ := by rw [hct]
+      · obtain ⟨u,hu⟩ := hds a ha
+        refine ⟨h c*u,?_⟩
+        simp only [map_mul]
+        rw [mul_assoc,hu]
+end ComplexCancellation.RelativeClearing
+
+namespace ComplexCancellation.DerivationRange
+variable {k B R : Type*} [CommRing k] [CommRing B] [CommRing R] [Algebra k B] [Algebra k R]
+def stable (f : B →ₐ[k] R) (E : Derivation k R R) : Subalgebra k B where
+  carrier := {b | ∃ t : B, E (f b)=f t}
+  algebraMap_mem' a := ⟨0,by rw [f.commutes,E.map_algebraMap,map_zero]⟩
+  add_mem' := by
+    rintro r s ⟨t,ht⟩ ⟨u,hu⟩
+    exact ⟨t+u,by rw [map_add,map_add,ht,hu,map_add]⟩
+  mul_mem' := by
+    rintro r s ⟨t,ht⟩ ⟨u,hu⟩
+    exact ⟨r*u+s*t,by rw [map_mul,Derivation.leibniz,ht,hu,smul_eq_mul,smul_eq_mul,map_add,map_mul,map_mul]⟩
+lemma stable_of_generators (f : B →ₐ[k] R) (E : Derivation k R R) (s : Set B)
+    (hs : Algebra.adjoin k s=⊤) (he : ∀ b∈s, ∃ t, E (f b)=f t) : ∀ b, ∃ t, E (f b)=f t := by
+  have h : Algebra.adjoin k s ≤ stable f E := Algebra.adjoin_le he
+  rw [hs] at h
+  exact fun b => h (show b∈(⊤ : Subalgebra k B) from trivial)
+end ComplexCancellation.DerivationRange
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/AffineCancellation/ReplicaLift.lean b/lean/OAI/Algebra/AffineCancellation/ReplicaLift.lean
new file mode 100644
index 0000000000000000000000000000000000000000..53c92a36889390b95becb8f610e7d12452bb2bcb
--- /dev/null
+++ b/lean/OAI/Algebra/AffineCancellation/ReplicaLift.lean
@@ -0,0 +1,83 @@
+import OAI.Algebra.AffineCancellation.InvariantRestriction
+import OAI.Algebra.AffineCancellation.BezoutFrame
+import OAI.Algebra.AffineCancellation.TorsorClearing
+
+namespace OAI
+
+noncomputable section
+
+namespace ComplexCancellation.SliceDerivative
+variable {k F : Type*} [Field k] [Field F] [Algebra k F]
+def derivation : Derivation k (Polynomial F) (Polynomial F) :=
+  Derivation.mk' ((Polynomial.derivative (R := F)).restrictScalars k) (by
+    intro p q
+    change (p*q).derivative=p*q.derivative+q*p.derivative
+    rw [Polynomial.derivative_mul,mul_comm p.derivative q,add_comm])
+lemma apply_eq (p : Polynomial F) : derivation (k := k) p=p.derivative := rfl
+lemma locallyNilpotent : LND.LocallyNilpotent (derivation (k := k) (F := F)) := by
+  intro p
+  exact ⟨p.natDegree+1,Polynomial.iterate_derivative_eq_zero (by omega)⟩
+end ComplexCancellation.SliceDerivative
+
+namespace ComplexCancellation.Bundle
+instance finiteType : Algebra.FiniteType ℂ B := by
+  let : Algebra.FiniteType ℂ Determinant.T := Algebra.FiniteType.quotient ℂ _
+  infer_instance
+end ComplexCancellation.Bundle
+
+namespace ComplexCancellation.Torsor
+open LaurentPolynomial
+variable {P : Type*} [CommRing P] [IsDomain P] [Algebra ℂ P]
+variable (ρ : Degeneration.G →ₐ[ℂ] P) (Q : Frame ρ) (D : Derivation ℂ Degeneration.G Degeneration.G)
+variable (hρ : Function.Injective ρ) (hc : ∀ p, p ∈ InvariantClearing.subalgebra ρ D)
+variable (Dp : Derivation ℂ P P) (hDp : LND.LocallyNilpotent Dp) (hder : ∀ r, Dp (ρ r)=ρ (D r))
+include hder in
+omit [IsDomain P] in
+lemma extension_base (r : Degeneration.G) : LaurentDerivation.extension Dp (base ρ r)=base ρ (D r) := by
+  change LaurentDerivation.extension Dp (C (ρ r))=C (ρ (D r))
+  rw [LaurentDerivation.extension_C,hder]
+include hρ hc hDp hder
+lemma invariant_replica (hf : Function.Injective (forward ρ Q)) :
+    ∃ c : Degeneration.G, ∃ E : Derivation ℂ Bundle.B Bundle.B,
+      D c=0 ∧ c≠0 ∧ LND.LocallyNilpotent E ∧
+      ∀ b, forward ρ Q (E b)=base ρ c*LaurentDerivation.extension Dp (forward ρ Q b) := by
+  have hbase (r : Degeneration.G) : forward ρ Q (Bundle.pullback r)=base ρ r :=
+    DFunLike.congr_fun (forward_pullback ρ Q hρ) r
+  obtain ⟨c,E,hDc,hcn,hE,hs⟩ := InvariantRestriction.exists_restriction Bundle.pullback (forward ρ Q) hf D
+    (LaurentDerivation.extension Dp) (LaurentDerivation.locallyNilpotent Dp hDp)
+    (fun r => by rw [hbase,hbase,extension_base ρ D Dp hder]) (clear_laurent ρ Q D hρ hc)
+  exact ⟨c,E,hDc,hcn,hE,fun b => by rw [hs,hbase]⟩
+end ComplexCancellation.Torsor
+
+namespace ComplexCancellation.PolynomialTorsor
+open PolynomialModel
+instance : CharZero Degeneration.G := Algebra.charZero_of_charZero ℂ Degeneration.G
+variable (D : Derivation ℂ Degeneration.G Degeneration.G) (hD : LND.LocallyNilpotent D)
+abbrev K := FractionRing Degeneration.G
+abbrev P := Polynomial (PolynomialModel.F D)
+variable {t : K} (ht : FractionDerivation.extend D t=1)
+noncomputable def ρ : Degeneration.G →ₐ[ℂ] P D := model D hD ht
+lemma ρ_injective : Function.Injective (ρ D hD ht) := model_injective D hD ht
+lemma exists_frame : Nonempty (Torsor.Frame (ρ D hD ht)) := by
+  have h := congrArg (ρ D hD ht) Degeneration.equation
+  simp only [map_mul,map_add,map_one] at h
+  obtain ⟨a,d,b,c,hab,hdc,hdb,hdet⟩ := BezoutFrame.exists_frame _ _ _ h
+  exact ⟨⟨a,d,b,c,hab,hdc,hdb,hdet⟩⟩
+def toField : K →ₐ[ℂ] Torsor.KB :=
+  IsFractionRing.liftAlgHom (g := Torsor.ib.comp Bundle.pullback)
+    ((IsFractionRing.injective Bundle.B Torsor.KB).comp Bundle.pullback_injective)
+def inverseCoefficient : P D →ₐ[ℂ] Torsor.KB := (toField).comp (PolynomialModel.evaluation (D := D) (t := t))
+lemma inverseCoefficient_comp : (inverseCoefficient (D := D) (t := t)).comp (ρ D hD ht)=Torsor.ib.comp Bundle.pullback := by
+  ext r
+  change toField (PolynomialModel.evaluation (D := D) (t := t) (model D hD ht r))=_
+  rw [evaluation_model]
+  exact IsFractionRing.lift_algebraMap
+    (g := (Torsor.ib.comp Bundle.pullback).toRingHom)
+    ((IsFractionRing.injective Bundle.B Torsor.KB).comp Bundle.pullback_injective) r
+lemma forward_injective (Q : Torsor.Frame (ρ D hD ht)) : Function.Injective (Torsor.forward (ρ D hD ht) Q) :=
+  Torsor.forward_injective _ Q (inverseCoefficient (D := D) (t := t)) (inverseCoefficient_comp D hD ht)
+end ComplexCancellation.PolynomialTorsor
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/AffineCancellation/Rigidity.lean b/lean/OAI/Algebra/AffineCancellation/Rigidity.lean
new file mode 100644
index 0000000000000000000000000000000000000000..6ac84dc10b87555684a961fd0959dd3ad94025e8
--- /dev/null
+++ b/lean/OAI/Algebra/AffineCancellation/Rigidity.lean
@@ -0,0 +1,154 @@
+import OAI.Algebra.AffineCancellation.Model
+
+namespace OAI
+
+noncomputable section
+
+/-! Polynomial orbit rigidity from the Mason–Stothers theorem. -/
+namespace ComplexCancellation.Rigidity
+open Polynomial UniqueFactorizationMonoid UniqueFactorizationDomain
+
+variable {k : Type*} [Field k]
+
+/-- A polynomial of degree at most one has no nonunit square divisor. -/
+lemma isUnit_of_square_dvd {n t : k[X]} (hn : n ≠ 0) (hdeg : n.natDegree ≤ 1)
+    (ht : t ^ 2 ∣ n) : IsUnit t := by
+  have ht0 : t ≠ 0 := by
+    intro h
+    simp only [h, ne_eq, OfNat.ofNat_ne_zero, not_false_eq_true, zero_pow,
+      zero_dvd_iff] at ht
+    exact hn ht
+  have hb := natDegree_le_of_dvd ht hn
+  rw [natDegree_pow] at hb
+  have htdeg : t.natDegree = 0 := by omega
+  rw [Polynomial.isUnit_iff_degree_eq_zero, degree_eq_natDegree ht0, htdeg]
+  rfl
+
+/-- Coprimality of the square and cube terms of an affine-linear orbit sum. -/
+lemma orbit_coprime {a d u n : k[X]} (hn : n ≠ 0) (hdeg : n.natDegree ≤ 1)
+    (heq : d ^ 2 + a ^ 2 * u ^ 3 = n) : IsCoprime (d ^ 2) (a ^ 2 * u ^ 3) := by
+  have hda : IsRelPrime d a := by
+    intro t htd hta
+    apply isUnit_of_square_dvd hn hdeg
+    rw [← heq]
+    exact dvd_add (pow_dvd_pow_of_dvd htd 2)
+      (dvd_mul_of_dvd_left (pow_dvd_pow_of_dvd hta 2) _)
+  have hdu : IsRelPrime d u := by
+    intro t htd htu
+    apply isUnit_of_square_dvd hn hdeg
+    rw [← heq]
+    apply dvd_add (pow_dvd_pow_of_dvd htd 2)
+    exact dvd_mul_of_dvd_right
+      ((pow_dvd_pow_of_dvd htu 2).trans (pow_dvd_pow u (by decide : 2 ≤ 3))) _
+  exact (hda.isCoprime.pow_left.pow_right).mul_right (hdu.isCoprime.pow_left.pow_right)
+
+/-- The polynomial degree bound expressed with radicals. -/
+lemma radical_orbit_bound [DecidableEq k] (a d u n : k[X]) :
+    (radical (d ^ 2 * (a ^ 2 * u ^ 3) * (-n))).natDegree ≤
+    d.natDegree + a.natDegree + u.natDegree + n.natDegree := by
+  classical
+  have hdvd : radical (d ^ 2 * (a ^ 2 * u ^ 3) * (-n)) ∣
+      radical d * (radical a * radical u) * radical n := by
+    apply radical_mul_dvd.trans
+    apply mul_dvd_mul
+    · apply radical_mul_dvd.trans
+      apply mul_dvd_mul
+      · rw [radical_pow d (by decide : 2 ≠ 0)]
+      · apply radical_mul_dvd.trans
+        rw [radical_pow a (by decide : 2 ≠ 0), radical_pow u (by decide : 3 ≠ 0)]
+    · rw [radical_neg]
+  have hb := natDegree_le_of_dvd hdvd
+    (mul_ne_zero (mul_ne_zero radical_ne_zero (mul_ne_zero radical_ne_zero radical_ne_zero))
+      radical_ne_zero)
+  rw [natDegree_mul (mul_ne_zero radical_ne_zero (mul_ne_zero radical_ne_zero radical_ne_zero))
+      radical_ne_zero,
+    natDegree_mul radical_ne_zero (mul_ne_zero radical_ne_zero radical_ne_zero),
+    natDegree_mul radical_ne_zero radical_ne_zero] at hb
+  have ha : (radical a).natDegree ≤ a.natDegree := natDegree_radical_le
+  have hd : (radical d).natDegree ≤ d.natDegree := natDegree_radical_le
+  have hu : (radical u).natDegree ≤ u.natDegree := natDegree_radical_le
+  have hn : (radical n).natDegree ≤ n.natDegree := natDegree_radical_le
+  omega
+
+/-- A nonsquare obstruction over the coefficient field forces constant polynomial orbits. -/
+theorem orbit_constant [CharZero k] {a d u n : k[X]}
+    (ha : a ≠ 0) (hd : d ≠ 0) (hu : u ≠ 0) (hn : n ≠ 0)
+    (hdeg : n.natDegree ≤ 1) (heq : d ^ 2 + a ^ 2 * u ^ 3 = n)
+    (hns : ∀ z : k, z ^ 2 ≠ -(u.coeff 0) ^ 3) :
+    a = C (a.coeff 0) ∧ d = C (d.coeff 0) ∧ u = C (u.coeff 0) := by
+  classical
+  have hdn : d ^ 2 ≠ 0 := pow_ne_zero _ hd
+  have haun : a ^ 2 * u ^ 3 ≠ 0 := mul_ne_zero (pow_ne_zero _ ha) (pow_ne_zero _ hu)
+  have hp := Polynomial.abc hdn haun (neg_ne_zero.mpr hn)
+    (orbit_coprime hn hdeg heq) (by rw [heq]; ring)
+  have hda : d.natDegree = a.natDegree ∧ u.natDegree = 0 := by
+    rcases hp with hp | hp
+    · have hb := radical_orbit_bound a d u n
+      have h1 := hp.1.trans hb
+      have h2 := hp.2.1.trans hb
+      rw [natDegree_pow] at h1
+      rw [natDegree_mul (pow_ne_zero _ ha) (pow_ne_zero _ hu),
+        natDegree_pow, natDegree_pow] at h2
+      omega
+    · have h1 := derivative_eq_zero.mp hp.1
+      have h2 := derivative_eq_zero.mp hp.2.1
+      rw [natDegree_pow] at h1
+      rw [natDegree_mul (pow_ne_zero _ ha) (pow_ne_zero _ hu),
+        natDegree_pow, natDegree_pow] at h2
+      omega
+  have hd0 : d.natDegree = 0 := by
+    by_contra hdpos
+    have hlt : n.natDegree < 2 * d.natDegree := by omega
+    have hc := congrArg (fun p : k[X] => p.coeff (2 * d.natDegree)) heq
+    rw [coeff_add, coeff_eq_zero_of_natDegree_lt hlt] at hc
+    have hcd : (d ^ 2).coeff (2 * d.natDegree) = d.leadingCoeff ^ 2 := by
+      rw [← natDegree_pow d 2, coeff_natDegree, leadingCoeff_pow]
+    have hcau : (a ^ 2 * u ^ 3).coeff (2 * d.natDegree) =
+        a.leadingCoeff ^ 2 * (u.coeff 0) ^ 3 := by
+      have hdegau : (a ^ 2 * u ^ 3).natDegree = 2 * d.natDegree := by
+        rw [natDegree_mul (pow_ne_zero _ ha) (pow_ne_zero _ hu),
+          natDegree_pow, natDegree_pow, hda.2, ← hda.1]
+        omega
+      rw [← hdegau, coeff_natDegree, leadingCoeff_mul, leadingCoeff_pow,
+        leadingCoeff_pow]
+      congr 2
+      exact congrArg (fun m : ℕ => u.coeff m) hda.2
+    rw [hcd, hcau] at hc
+    apply hns (d.leadingCoeff / a.leadingCoeff)
+    rw [div_pow, div_eq_iff (pow_ne_zero 2 (leadingCoeff_ne_zero.mpr ha))]
+    linear_combination hc
+  exact ⟨eq_C_of_natDegree_eq_zero (hda.1.symm.trans hd0),
+    eq_C_of_natDegree_eq_zero hd0, eq_C_of_natDegree_eq_zero hda.2⟩
+
+end ComplexCancellation.Rigidity
+
+namespace ComplexCancellation.Rigidity
+
+lemma ratFunc_intDegree_pow {K : Type*} [Field K] {z : RatFunc K}
+    (hz : z ≠ 0) (n : ℕ) : (z ^ n).intDegree = (n : ℤ) * z.intDegree := by
+  induction n with
+  | zero => simp
+  | succ n ih =>
+    rw [pow_succ, RatFunc.intDegree_mul (pow_ne_zero n hz) hz, ih]
+    push_cast
+    ring
+
+/-- The cube of the rational parameter is not the negative of a square. -/
+theorem ratFunc_X_cube_nonsquare {K : Type*} [Field K] (z : RatFunc K) :
+    z ^ 2 ≠ -(RatFunc.X : RatFunc K) ^ 3 := by
+  intro hz
+  have hz0 : z ≠ 0 := by
+    intro h
+    simp only [h, ne_eq, OfNat.ofNat_ne_zero, not_false_eq_true, zero_pow,
+      zero_eq_neg, pow_eq_zero_iff] at hz
+    exact RatFunc.X_ne_zero hz
+  have he := congrArg RatFunc.intDegree hz
+  rw [ratFunc_intDegree_pow hz0, RatFunc.intDegree_neg,
+    ratFunc_intDegree_pow RatFunc.X_ne_zero, RatFunc.intDegree_X] at he
+  omega
+
+end ComplexCancellation.Rigidity
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/AffineCancellation/TorsorClearing.lean b/lean/OAI/Algebra/AffineCancellation/TorsorClearing.lean
new file mode 100644
index 0000000000000000000000000000000000000000..b3b536c8c5cc77b18b295e4c66914830866ae3f2
--- /dev/null
+++ b/lean/OAI/Algebra/AffineCancellation/TorsorClearing.lean
@@ -0,0 +1,58 @@
+import OAI.Algebra.AffineCancellation.RelativeClearing
+import OAI.Algebra.AffineCancellation.PolynomialSlice
+import OAI.Algebra.AffineCancellation.TorsorInverse
+
+namespace OAI
+
+noncomputable section
+
+namespace ComplexCancellation.Torsor
+open LaurentPolynomial
+variable {P : Type*} [CommRing P] [IsDomain P] [Algebra ℂ P]
+variable (ρ : Degeneration.G →ₐ[ℂ] P) (Q : Frame ρ) (D : Derivation ℂ Degeneration.G Degeneration.G)
+variable (hρ : Function.Injective ρ)
+variable (hc : ∀ p, p ∈ InvariantClearing.subalgebra ρ D)
+include hρ hc
+lemma clear_C (p : P) : C p ∈ RelativeClearing.subalgebra Bundle.pullback (forward ρ Q) D := by
+  obtain ⟨c,r,hc,hcn,hcr⟩ := hc p
+  refine ⟨c,Bundle.pullback r,hc,hcn,?_⟩
+  have h := DFunLike.congr_fun (forward_pullback ρ Q hρ) c
+  have h' := DFunLike.congr_fun (forward_pullback ρ Q hρ) r
+  change forward ρ Q (Bundle.pullback c)=C (ρ c) at h
+  change forward ρ Q (Bundle.pullback r)=C (ρ r) at h'
+  rw [h,h',← map_mul,hcr]
+lemma clear_T_one : T 1 ∈ RelativeClearing.subalgebra Bundle.pullback (forward ρ Q) D := by
+  have he : T 1=C Q.c₀*forward ρ Q (Bundle.j Determinant.a)-C Q.b₀*forward ρ Q (Bundle.j Determinant.d) := by
+    rw [forward_j,forward_j,frameMap_a,frameMap_d]
+    calc _ = C (Q.a₀*Q.c₀-Q.d₀*Q.b₀)*T 1 := by rw [Q.det,map_one,one_mul]
+      _ = _ := by rw [map_sub,map_mul,map_mul]; ring
+  rw [he]
+  apply sub_mem
+  · exact mul_mem (clear_C ρ Q D hρ hc _) (RelativeClearing.image_mem _ _ _ _)
+  · exact mul_mem (clear_C ρ Q D hρ hc _) (RelativeClearing.image_mem _ _ _ _)
+lemma clear_T_neg_one : T (-1) ∈ RelativeClearing.subalgebra Bundle.pullback (forward ρ Q) D := by
+  have he : T (-1)=C Q.a₀*forward ρ Q (Bundle.j Determinant.c)-C Q.d₀*forward ρ Q (Bundle.j Determinant.b) := by
+    rw [forward_j,forward_j,frameMap_c,frameMap_b]
+    calc _ = C (Q.a₀*Q.c₀-Q.d₀*Q.b₀)*T (-1) := by rw [Q.det,map_one,one_mul]
+      _ = _ := by rw [map_sub,map_mul,map_mul]; ring
+  rw [he]
+  apply sub_mem
+  · exact mul_mem (clear_C ρ Q D hρ hc _) (RelativeClearing.image_mem _ _ _ _)
+  · exact mul_mem (clear_C ρ Q D hρ hc _) (RelativeClearing.image_mem _ _ _ _)
+lemma clear_T (n : ℤ) : T n ∈ RelativeClearing.subalgebra Bundle.pullback (forward ρ Q) D := by
+  by_cases hn : 0 ≤ n
+  · have he : T n=(T 1 : L (P := P))^n.toNat := by rw [T_pow,Int.toNat_of_nonneg hn,mul_one]
+    rw [he]
+    exact pow_mem (clear_T_one ρ Q D hρ hc) _
+  · have he : T n=(T (-1) : L (P := P))^(-n).toNat := by rw [T_pow,Int.toNat_of_nonneg (by omega : 0 ≤ -n)]; congr 1; omega
+    rw [he]
+    exact pow_mem (clear_T_neg_one ρ Q D hρ hc) _
+lemma clear_laurent (r : L (P := P)) : r ∈ RelativeClearing.subalgebra Bundle.pullback (forward ρ Q) D := by
+  induction r using LaurentPolynomial.induction_on' with
+  | add r s hr hs => exact add_mem hr hs
+  | C_mul_T n p => exact mul_mem (clear_C ρ Q D hρ hc p) (clear_T ρ Q D hρ hc n)
+end ComplexCancellation.Torsor
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/AffineCancellation/TorsorEuler.lean b/lean/OAI/Algebra/AffineCancellation/TorsorEuler.lean
new file mode 100644
index 0000000000000000000000000000000000000000..5b298cc82ed08d226c3e64676f251d9f7ac28ef6
--- /dev/null
+++ b/lean/OAI/Algebra/AffineCancellation/TorsorEuler.lean
@@ -0,0 +1,81 @@
+import OAI.Algebra.AffineCancellation.ReplicaLift
+import OAI.Algebra.AffineCancellation.LaurentEuler
+import OAI.Algebra.AffineCancellation.Intertwining
+
+namespace OAI
+
+noncomputable section
+
+namespace ComplexCancellation.Torsor
+open LaurentPolynomial
+variable {P : Type*} [CommRing P] [Algebra ℂ P]
+variable (ρ : Degeneration.G →ₐ[ℂ] P) (Q : Frame ρ)
+lemma frameMap_intertwining (r : Determinant.T) :
+    LaurentEuler.derivation (k := ℂ) (frameMap ρ Q r)=frameMap ρ Q (Determinant.Euler r) := by
+  obtain ⟨p,rfl⟩ := Ideal.Quotient.mkₐ_surjective ℂ (Ideal.span {Determinant.relation}) r
+  apply DerivationIntertwining.mvPolynomial (frameMap ρ Q) Determinant.Euler LaurentEuler.derivation Determinant.π p
+  intro i
+  fin_cases i
+  · change LaurentEuler.derivation (k := ℂ) (frameMap ρ Q Determinant.a)=frameMap ρ Q (Determinant.Euler Determinant.a)
+    rw [Determinant.Euler_a,frameMap_a,LaurentEuler.monomial,one_zsmul]
+  · change LaurentEuler.derivation (k := ℂ) (frameMap ρ Q Determinant.d)=frameMap ρ Q (Determinant.Euler Determinant.d)
+    rw [Determinant.Euler_d,frameMap_d,LaurentEuler.monomial,one_zsmul]
+  · change LaurentEuler.derivation (k := ℂ) (frameMap ρ Q Determinant.b)=frameMap ρ Q (Determinant.Euler Determinant.b)
+    rw [Determinant.Euler_b,map_neg,frameMap_b,LaurentEuler.monomial,neg_one_zsmul]
+  · change LaurentEuler.derivation (k := ℂ) (frameMap ρ Q Determinant.c)=frameMap ρ Q (Determinant.Euler Determinant.c)
+    rw [Determinant.Euler_c,map_neg,frameMap_c,LaurentEuler.monomial,neg_one_zsmul]
+  · change LaurentEuler.derivation (k := ℂ) (frameMap ρ Q Determinant.u)=frameMap ρ Q (Determinant.Euler Determinant.u)
+    rw [Determinant.Euler_u,map_zero,frameMap_u,LaurentEuler.coefficient]
+lemma forwardEuler_τ : LaurentEuler.derivation (k := ℂ) (forward ρ Q Bundle.τ)=0 := by
+  rw [forward_τ]
+  exact LaurentEuler.coefficient _
+lemma forwardEuler_j (r : Determinant.T) :
+    LaurentEuler.derivation (k := ℂ) (forward ρ Q (Bundle.j r))=forward ρ Q (Bundle.fiberEuler (Bundle.j r)) := by
+  change _=forward ρ Q (AffineModification.euler _ _ _ (AffineModification.coefficientHom (k := ℂ) _ r))
+  rw [AffineModification.euler_coefficient,forward_j,frameMap_intertwining]
+  exact (forward_j ρ Q (Determinant.Euler r)).symm
+variable [IsDomain P]
+lemma forwardEuler_V (hρ : Function.Injective ρ) :
+    LaurentEuler.derivation (k := ℂ) (forward ρ Q Bundle.V)=2*forward ρ Q Bundle.V := by
+  have hτ : forward ρ Q Bundle.τ≠0 := by rw [forward_τ]; exact base_p_ne_zero ρ hρ
+  apply mul_left_cancel₀ (pow_ne_zero 2 hτ)
+  have he := congrArg (LaurentEuler.derivation (k := ℂ) : L (P := P) → L (P := P))
+    (congrArg (forward ρ Q) Bundle.equation)
+  rw [map_mul,map_pow,Derivation.leibniz,Derivation.leibniz_pow,forwardEuler_τ,
+    smul_zero,smul_zero,smul_zero,add_zero,smul_eq_mul,forward_j,frameMap_intertwining,
+    Determinant.Euler_v,map_mul,map_ofNat] at he
+  rw [he,← forward_j,← Bundle.equation,map_mul,map_pow]
+  ring
+lemma forward_intertwining (hρ : Function.Injective ρ) (r : Bundle.B) :
+    LaurentEuler.derivation (k := ℂ) (forward ρ Q r)=forward ρ Q (Bundle.fiberEuler r) := by
+  change r ∈ DerivationIntertwining.subalgebra (forward ρ Q) Bundle.fiberEuler LaurentEuler.derivation
+  obtain ⟨p,rfl⟩ := Ideal.Quotient.mkₐ_surjective Determinant.T (Ideal.span {AffineModification.rel Determinant.T Determinant.v}) r
+  change AffineModification.π Determinant.T Determinant.v p ∈ _
+  induction p using MvPolynomial.induction_on with
+  | C a => exact forwardEuler_j ρ Q a
+  | add p q hp hq => rw [map_add]; exact add_mem hp hq
+  | mul_X p i hp =>
+    rw [map_mul]
+    apply mul_mem hp
+    fin_cases i
+    · change LaurentEuler.derivation (k := ℂ) (forward ρ Q Bundle.τ)=forward ρ Q (Bundle.fiberEuler Bundle.τ)
+      rw [forwardEuler_τ]
+      change 0=forward ρ Q (AffineModification.euler _ _ _ (AffineModification.τ _ _))
+      rw [AffineModification.euler_τ,map_zero]
+    · change LaurentEuler.derivation (k := ℂ) (forward ρ Q Bundle.V)=forward ρ Q (Bundle.fiberEuler Bundle.V)
+      rw [forwardEuler_V ρ Q hρ]
+      change _=forward ρ Q (AffineModification.euler _ _ _ (AffineModification.V _ _))
+      rw [AffineModification.euler_V,map_mul,map_ofNat]
+      rfl
+lemma replica_commute (hρ : Function.Injective ρ) (hf : Function.Injective (forward ρ Q))
+    (Dp : Derivation ℂ P P) (E : Derivation ℂ Bundle.B Bundle.B) (c : Degeneration.G)
+    (hs : ∀ b, forward ρ Q (E b)=base ρ c*LaurentDerivation.extension Dp (forward ρ Q b))
+    (b : Bundle.B) : Bundle.fiberEuler (E b)=E (Bundle.fiberEuler b) := by
+  apply hf
+  rw [← forward_intertwining ρ Q hρ,hs,hs,← forward_intertwining ρ Q hρ]
+  exact LaurentEuler.commute_replica Dp (ρ c) (forward ρ Q b)
+end ComplexCancellation.Torsor
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/AffineCancellation/TorsorFrame.lean b/lean/OAI/Algebra/AffineCancellation/TorsorFrame.lean
new file mode 100644
index 0000000000000000000000000000000000000000..5cc23433f33488b88ad208d93868ec06acc5e268
--- /dev/null
+++ b/lean/OAI/Algebra/AffineCancellation/TorsorFrame.lean
@@ -0,0 +1,151 @@
+import OAI.Algebra.AffineCancellation.PositiveObstruction
+import OAI.Algebra.AffineCancellation.DegenerationGrading
+
+namespace OAI
+
+noncomputable section
+
+namespace ComplexCancellation.Torsor
+open LaurentPolynomial
+open MvPolynomial (X aeval aeval_X eval₂Hom_C eval₂Hom_X)
+variable {P : Type*} [CommRing P] [Algebra ℂ P]
+variable (ρ : Degeneration.G →ₐ[ℂ] P)
+structure Frame where
+  a₀ : P
+  d₀ : P
+  b₀ : P
+  c₀ : P
+  ab : a₀*b₀=ρ Degeneration.x
+  dc : d₀*c₀=ρ Degeneration.y
+  db : d₀*b₀=ρ Degeneration.z
+  det : a₀*c₀-d₀*b₀=1
+variable (Q : Frame ρ)
+abbrev L := LaurentPolynomial P
+def cc : P →ₐ[ℂ] L (P := P) := IsScalarTower.toAlgHom ℂ P (L (P := P))
+def base : Degeneration.G →ₐ[ℂ] L (P := P) := (cc (P := P)).comp ρ
+omit [Algebra ℂ P] in
+lemma mono_pair (r s : P) : C r*T (1:ℤ)*(C s*T (-1))=C (r*s) := by
+  calc C r*T (1:ℤ)*(C s*T (-1)) = C (r*s)*(T (1:ℤ)*T (-1)) := by rw [map_mul]; ring
+    _ = _ := by rw [← T_add]; norm_num
+
+def frameEval : Determinant.Poly →ₐ[ℂ] L (P := P) :=
+  aeval ![C Q.a₀*T 1,C Q.d₀*T 1,C Q.b₀*T (-1),C Q.c₀*T (-1),C (ρ Degeneration.u)]
+lemma frameEval_relation : frameEval ρ Q Determinant.relation=0 := by
+  simp only [frameEval,Determinant.relation,map_sub,map_mul,map_one,aeval_X,
+    Matrix.cons_val,Matrix.cons_val_zero,Matrix.cons_val_one]
+  rw [mono_pair,mul_comm (C Q.b₀*T (-1)),mono_pair,← map_sub,Q.det,map_one,sub_self]
+def frameMap : Determinant.T →ₐ[ℂ] L (P := P) :=
+  Ideal.Quotient.liftₐ _ (frameEval ρ Q) (by
+    intro r hr
+    obtain ⟨t,rfl⟩ := Ideal.mem_span_singleton.mp hr
+    rw [map_mul,frameEval_relation,zero_mul])
+@[simp] lemma frameMap_π (r : Determinant.Poly) : frameMap ρ Q (Determinant.π r)=frameEval ρ Q r :=
+  Ideal.Quotient.lift_mk _ _ _
+@[simp] lemma frameMap_a : frameMap ρ Q Determinant.a=C Q.a₀*T 1 := by simp [Determinant.a,frameEval]
+@[simp] lemma frameMap_d : frameMap ρ Q Determinant.d=C Q.d₀*T 1 := by simp [Determinant.d,frameEval]
+@[simp] lemma frameMap_b : frameMap ρ Q Determinant.b=C Q.b₀*T (-1) := by simp [Determinant.b,frameEval,Matrix.cons_val]
+@[simp] lemma frameMap_c : frameMap ρ Q Determinant.c=C Q.c₀*T (-1) := by simp [Determinant.c,frameEval,Matrix.cons_val]
+@[simp] lemma frameMap_u : frameMap ρ Q Determinant.u=C (ρ Degeneration.u) := by simp [Determinant.u,frameEval,Matrix.cons_val]
+lemma frameMap_inclusion : (frameMap ρ Q).comp Bundle.inclusion = (base ρ).comp Degeneration.coefficientMap := by
+  apply Ideal.Quotient.algHom_ext
+  apply MvPolynomial.algHom_ext
+  intro i
+  fin_cases i
+  · change frameMap ρ Q (Bundle.inclusion Quadric.x)=base ρ (Degeneration.coefficientMap Quadric.x)
+    rw [Bundle.inclusion_x,map_mul,frameMap_a,frameMap_b,mono_pair,Q.ab,Degeneration.coefficientMap_x]
+    rfl
+  · change frameMap ρ Q (Bundle.inclusion Quadric.y)=base ρ (Degeneration.coefficientMap Quadric.y)
+    rw [Bundle.inclusion_y,map_mul,frameMap_d,frameMap_c,mono_pair,Q.dc,Degeneration.coefficientMap_y]
+    rfl
+  · change frameMap ρ Q (Bundle.inclusion Quadric.z)=base ρ (Degeneration.coefficientMap Quadric.z)
+    rw [Bundle.inclusion_z,map_mul,frameMap_d,frameMap_b,mono_pair,Q.db,Degeneration.coefficientMap_z]
+    rfl
+  · change frameMap ρ Q (Bundle.inclusion Quadric.u)=base ρ (Degeneration.coefficientMap Quadric.u)
+    rw [Bundle.inclusion_u,frameMap_u,Degeneration.coefficientMap_u]
+    rfl
+lemma frame_f : base ρ Degeneration.p^2*base ρ Degeneration.F =
+    frameMap ρ Q Bundle.C₁*frameMap ρ Q Determinant.v := by
+  have h := DFunLike.congr_fun (frameMap_inclusion ρ Q) Quadric.f
+  simpa only [AlgHom.comp_apply,Bundle.inclusion_f,map_mul,Degeneration.coefficientMap_f,map_pow] using h.symm
+lemma frame_g : base ρ Degeneration.p^2*base ρ Degeneration.J =
+    frameMap ρ Q (Determinant.b^2)*frameMap ρ Q Determinant.v := by
+  have h := DFunLike.congr_fun (frameMap_inclusion ρ Q) Quadric.g
+  simpa only [AlgHom.comp_apply,Bundle.inclusion_g,map_mul,Degeneration.coefficientMap_g,map_pow] using h.symm
+
+def vb : L (P := P) := frameMap ρ Q Bundle.α*base ρ Degeneration.F+frameMap ρ Q Bundle.β*base ρ Degeneration.J
+lemma vb_equation : base ρ Degeneration.p^2*vb ρ Q=frameMap ρ Q Determinant.v := by
+  have h := congrArg (frameMap ρ Q) Bundle.certificate
+  simp only [map_add,map_mul,map_one] at h
+  calc _ = frameMap ρ Q Bundle.α*(base ρ Degeneration.p^2*base ρ Degeneration.F)+
+      frameMap ρ Q Bundle.β*(base ρ Degeneration.p^2*base ρ Degeneration.J) := by dsimp [vb]; ring
+    _ = _ := by rw [frame_f,frame_g]; linear_combination frameMap ρ Q Determinant.v*h
+
+def forwardEval : AffineModification.P Determinant.T →ₐ[ℂ] L (P := P) where
+  __ := MvPolynomial.eval₂Hom (frameMap ρ Q).toRingHom ![base ρ Degeneration.p,vb ρ Q]
+  commutes' r := by
+    change MvPolynomial.eval₂Hom _ _ (MvPolynomial.C (algebraMap ℂ Determinant.T r))=_
+    rw [eval₂Hom_C]
+    exact (frameMap ρ Q).commutes r
+@[simp] lemma forwardEval_C (r : Determinant.T) : forwardEval ρ Q (MvPolynomial.C r)=frameMap ρ Q r := eval₂Hom_C _ _ _
+@[simp] lemma forwardEval_X (i : Fin 2) : forwardEval ρ Q (X i)=![base ρ Degeneration.p,vb ρ Q] i := by
+  change MvPolynomial.eval₂ _ _ (X i)=_
+  exact MvPolynomial.eval₂_X _ _ _
+lemma forwardEval_rel : forwardEval ρ Q (AffineModification.rel Determinant.T Determinant.v)=0 := by
+  simp only [AffineModification.rel,map_sub,map_mul,map_pow,forwardEval_C,forwardEval_X,
+    Matrix.cons_val_zero,Matrix.cons_val_one,vb_equation,sub_self]
+def forward : Bundle.B →ₐ[ℂ] L (P := P) :=
+  Ideal.Quotient.liftₐ _ (forwardEval ρ Q) (by
+    intro r hr
+    obtain ⟨t,rfl⟩ := Ideal.mem_span_singleton.mp hr
+    rw [map_mul,forwardEval_rel,zero_mul])
+@[simp] lemma forward_π (r : AffineModification.P Determinant.T) :
+    forward ρ Q (AffineModification.π Determinant.T Determinant.v r)=forwardEval ρ Q r :=
+  Ideal.Quotient.lift_mk _ _ _
+@[simp] lemma forward_j (r : Determinant.T) : forward ρ Q (Bundle.j r)=frameMap ρ Q r :=
+by
+  change forward ρ Q (AffineModification.π Determinant.T Determinant.v (MvPolynomial.C r))=_
+  rw [forward_π,forwardEval_C]
+@[simp] lemma forward_τ : forward ρ Q Bundle.τ=base ρ Degeneration.p := by
+  simp [Bundle.τ,AffineModification.τ]
+@[simp] lemma forward_V : forward ρ Q Bundle.V=vb ρ Q := by
+  simp [Bundle.V,AffineModification.V]
+lemma base_p_ne_zero (hρ : Function.Injective ρ) : base ρ Degeneration.p ≠ 0 := by
+  have hp : Degeneration.p ≠ 0 := Degeneration.p_regular.ne_zero
+  change C (ρ Degeneration.p) ≠ 0
+  intro hz
+  have hn : ρ Degeneration.p ≠ 0 := by simpa only [map_zero] using hρ.ne hp
+  apply hn
+  have he := congrArg (fun z : L (P := P) => z.coeff 0) hz
+  simpa [LaurentPolynomial.C_apply] using he
+variable [IsDomain P]
+lemma forward_pullback (hρ : Function.Injective ρ) : (forward ρ Q).comp Bundle.pullback=base ρ := by
+  apply Ideal.Quotient.algHom_ext
+  apply MvPolynomial.algHom_ext
+  intro i
+  change forward ρ Q (Bundle.pullback (Degeneration.π (X i)))=base ρ (Degeneration.π (X i))
+  rw [Bundle.pullback_π]
+  simp only [Bundle.eval,MvPolynomial.aeval_X,Bundle.values]
+  fin_cases i
+  · change forward ρ Q Bundle.τ=base ρ Degeneration.p
+    exact forward_τ ρ Q
+  · change forward ρ Q (Bundle.j (Bundle.inclusion Quadric.s))=base ρ Degeneration.s
+    rw [forward_j]
+    simpa only [AlgHom.comp_apply,Degeneration.coefficientMap_s] using DFunLike.congr_fun (frameMap_inclusion ρ Q) Quadric.s
+  · change forward ρ Q (Bundle.j Determinant.u)=base ρ Degeneration.u
+    rw [forward_j,frameMap_u]
+    rfl
+  · change forward ρ Q (Bundle.j Bundle.C₁*Bundle.V)=base ρ Degeneration.F
+    rw [map_mul,forward_j,forward_V]
+    apply mul_left_cancel₀ (pow_ne_zero 2 (base_p_ne_zero ρ hρ))
+    calc _ = frameMap ρ Q Bundle.C₁*(base ρ Degeneration.p^2*vb ρ Q) := by ring
+      _ = _ := by rw [vb_equation,← frame_f]
+  · change forward ρ Q (Bundle.j (Determinant.b^2)*Bundle.V)=base ρ Degeneration.J
+    rw [map_mul,forward_j,forward_V]
+    apply mul_left_cancel₀ (pow_ne_zero 2 (base_p_ne_zero ρ hρ))
+    calc _ = frameMap ρ Q (Determinant.b^2)*(base ρ Degeneration.p^2*vb ρ Q) := by ring
+      _ = _ := by rw [vb_equation,← frame_g]
+end ComplexCancellation.Torsor
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/AffineCancellation/TorsorInverse.lean b/lean/OAI/Algebra/AffineCancellation/TorsorInverse.lean
new file mode 100644
index 0000000000000000000000000000000000000000..e5a33a0dd749a35209d3296739501a939e461e26
--- /dev/null
+++ b/lean/OAI/Algebra/AffineCancellation/TorsorInverse.lean
@@ -0,0 +1,130 @@
+import OAI.Algebra.AffineCancellation.TorsorFrame
+
+namespace OAI
+
+noncomputable section
+
+namespace ComplexCancellation.Torsor
+open LaurentPolynomial
+variable {P : Type*} [CommRing P] [Algebra ℂ P]
+variable (ρ : Degeneration.G →ₐ[ℂ] P) (Q : Frame ρ)
+abbrev KB := FractionRing Bundle.B
+def ib : Bundle.B →ₐ[ℂ] KB := IsScalarTower.toAlgHom ℂ Bundle.B KB
+def bc : Determinant.T →ₐ[ℂ] KB := ib.comp Bundle.j
+variable (f : P →ₐ[ℂ] KB) (hf : f.comp ρ=ib.comp Bundle.pullback)
+include hf
+lemma compatibility (r : Quadric.R) : f (ρ (Degeneration.coefficientMap r))=bc (Bundle.inclusion r) := by
+  rw [← AlgHom.comp_apply,hf]
+  change ib (Bundle.pullback (Degeneration.coefficientMap r))=_
+  change ib ((Bundle.pullback.comp Degeneration.coefficientMap) r)=_
+  rw [Bundle.pullback_coefficientMap]
+  rfl
+lemma back_ab : f Q.a₀*f Q.b₀=bc Determinant.a*bc Determinant.b := by
+  rw [← map_mul,Q.ab]
+  simpa only [Degeneration.coefficientMap_x,Bundle.inclusion_x,map_mul] using compatibility ρ f hf Quadric.x
+lemma back_dc : f Q.d₀*f Q.c₀=bc Determinant.d*bc Determinant.c := by
+  rw [← map_mul,Q.dc]
+  simpa only [Degeneration.coefficientMap_y,Bundle.inclusion_y,map_mul] using compatibility ρ f hf Quadric.y
+lemma back_db : f Q.d₀*f Q.b₀=bc Determinant.d*bc Determinant.b := by
+  rw [← map_mul,Q.db]
+  simpa only [Degeneration.coefficientMap_z,Bundle.inclusion_z,map_mul] using compatibility ρ f hf Quadric.z
+omit hf in
+lemma bc_det : bc Determinant.a*bc Determinant.c-bc Determinant.b*bc Determinant.d=1 := by
+  simpa only [map_mul,map_sub,map_one] using congrArg bc Determinant.determinant
+lemma back_ac : f Q.a₀*f Q.c₀=bc Determinant.a*bc Determinant.c := by
+  have he := congrArg f Q.det
+  simp only [map_mul,map_sub,map_one] at he
+  rw [back_db ρ Q f hf] at he
+  linear_combination he-bc_det
+
+def w : KB := f Q.c₀*bc Determinant.a-f Q.b₀*bc Determinant.d
+def wi : KB := f Q.a₀*bc Determinant.c-f Q.d₀*bc Determinant.b
+lemma back_a : f Q.a₀*w ρ Q f=bc Determinant.a := by
+  dsimp [w]
+  calc _ = (f Q.a₀*f Q.c₀)*bc Determinant.a-(f Q.a₀*f Q.b₀)*bc Determinant.d := by ring
+    _ = _ := by rw [back_ac ρ Q f hf,back_ab ρ Q f hf]; linear_combination bc Determinant.a*bc_det
+lemma back_d : f Q.d₀*w ρ Q f=bc Determinant.d := by
+  dsimp [w]
+  calc _ = (f Q.d₀*f Q.c₀)*bc Determinant.a-(f Q.d₀*f Q.b₀)*bc Determinant.d := by ring
+    _ = _ := by rw [back_dc ρ Q f hf,back_db ρ Q f hf]; linear_combination bc Determinant.d*bc_det
+lemma back_b : f Q.b₀*wi ρ Q f=bc Determinant.b := by
+  dsimp [wi]
+  calc _ = (f Q.a₀*f Q.b₀)*bc Determinant.c-(f Q.d₀*f Q.b₀)*bc Determinant.b := by ring
+    _ = _ := by rw [back_ab ρ Q f hf,back_db ρ Q f hf]; linear_combination bc Determinant.b*bc_det
+lemma back_c : f Q.c₀*wi ρ Q f=bc Determinant.c := by
+  dsimp [wi]
+  calc _ = (f Q.a₀*f Q.c₀)*bc Determinant.c-(f Q.d₀*f Q.c₀)*bc Determinant.b := by ring
+    _ = _ := by rw [back_ac ρ Q f hf,back_dc ρ Q f hf]; linear_combination bc Determinant.c*bc_det
+lemma w_wi : w ρ Q f*wi ρ Q f=1 := by
+  calc _ = bc Determinant.a*(f Q.c₀*wi ρ Q f)-bc Determinant.d*(f Q.b₀*wi ρ Q f) := by dsimp [w]; ring
+    _ = _ := by rw [back_c ρ Q f hf,back_b ρ Q f hf]; linear_combination bc_det
+def W : KBˣ := ⟨w ρ Q f,wi ρ Q f,w_wi ρ Q f hf,by rw [mul_comm]; exact w_wi ρ Q f hf⟩
+def backward : L (P := P) →ₐ[ℂ] KB where
+  __ := LaurentPolynomial.eval₂ f.toRingHom (W ρ Q f hf)
+  commutes' r := by
+    change LaurentPolynomial.eval₂ f.toRingHom (W ρ Q f hf) (C (algebraMap ℂ P r))=_
+    rw [LaurentPolynomial.eval₂_C]
+    exact f.commutes r
+@[simp] lemma backward_C (r : P) : backward ρ Q f hf (C r)=f r := LaurentPolynomial.eval₂_C _ _ _
+@[simp] lemma backward_T_one : backward ρ Q f hf (T 1)=w ρ Q f := by
+  change LaurentPolynomial.eval₂ f.toRingHom (W ρ Q f hf) (T 1)=_
+  rw [LaurentPolynomial.eval₂_T]
+  simp only [zpow_one,W,Units.val_mk]
+@[simp] lemma backward_T_neg_one : backward ρ Q f hf (T (-1))=wi ρ Q f := by
+  change LaurentPolynomial.eval₂ f.toRingHom (W ρ Q f hf) (T (-1))=_
+  rw [LaurentPolynomial.eval₂_T]
+  simp only [zpow_neg_one]
+  rfl
+lemma backward_frameMap : (backward ρ Q f hf).comp (frameMap ρ Q)=bc := by
+  apply Ideal.Quotient.algHom_ext
+  apply MvPolynomial.algHom_ext
+  intro i
+  fin_cases i
+  · change backward ρ Q f hf (frameMap ρ Q Determinant.a)=bc Determinant.a
+    rw [frameMap_a,map_mul,backward_C,backward_T_one,back_a ρ Q f hf]
+  · change backward ρ Q f hf (frameMap ρ Q Determinant.d)=bc Determinant.d
+    rw [frameMap_d,map_mul,backward_C,backward_T_one,back_d ρ Q f hf]
+  · change backward ρ Q f hf (frameMap ρ Q Determinant.b)=bc Determinant.b
+    rw [frameMap_b,map_mul,backward_C,backward_T_neg_one,back_b ρ Q f hf]
+  · change backward ρ Q f hf (frameMap ρ Q Determinant.c)=bc Determinant.c
+    rw [frameMap_c,map_mul,backward_C,backward_T_neg_one,back_c ρ Q f hf]
+  · change backward ρ Q f hf (frameMap ρ Q Determinant.u)=bc Determinant.u
+    rw [frameMap_u,backward_C]
+    simpa only [Degeneration.coefficientMap_u,Bundle.inclusion_u] using compatibility ρ f hf Quadric.u
+lemma backward_forward_j (r : Determinant.T) : backward ρ Q f hf (forward ρ Q (Bundle.j r))=ib (Bundle.j r) := by
+  rw [forward_j]
+  exact DFunLike.congr_fun (backward_frameMap ρ Q f hf) r
+lemma backward_forward_τ : backward ρ Q f hf (forward ρ Q Bundle.τ)=ib Bundle.τ := by
+  rw [forward_τ]
+  change backward ρ Q f hf (C (ρ Degeneration.p))=_
+  rw [backward_C,← AlgHom.comp_apply,hf]
+  change ib (Bundle.pullback (Degeneration.π (MvPolynomial.X 0)))=_
+  rw [Bundle.pullback_π]
+  congr 1
+  exact MvPolynomial.aeval_X _ 0
+lemma backward_forward_V : backward ρ Q f hf (forward ρ Q Bundle.V)=ib Bundle.V := by
+  have hp : ib Bundle.τ ≠ 0 := by
+    have hi : Function.Injective ib := IsFractionRing.injective Bundle.B KB
+    simpa only [map_zero] using hi.ne Bundle.τ_ne_zero
+  apply mul_left_cancel₀ (pow_ne_zero 2 hp)
+  have he := congrArg (fun z => backward ρ Q f hf (forward ρ Q z)) Bundle.equation
+  rw [map_mul,map_pow,map_mul,map_pow,backward_forward_τ,backward_forward_j] at he
+  rw [he,← Bundle.equation,map_mul,map_pow]
+lemma backward_forward : (backward ρ Q f hf).comp (forward ρ Q)=ib := by
+  apply Ideal.Quotient.algHom_ext
+  apply MvPolynomial.algHom_ext'
+  · ext r
+    exact backward_forward_j ρ Q f hf r
+  · intro i
+    fin_cases i
+    · exact backward_forward_τ ρ Q f hf
+    · exact backward_forward_V ρ Q f hf
+lemma forward_injective : Function.Injective (forward ρ Q) := by
+  apply Function.Injective.of_comp (f := backward ρ Q f hf)
+  rw [← AlgHom.coe_comp,backward_forward]
+  exact IsFractionRing.injective Bundle.B KB
+end ComplexCancellation.Torsor
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/AlgebraicObstruction/AdicFunctor.lean b/lean/OAI/Algebra/AlgebraicObstruction/AdicFunctor.lean
new file mode 100644
index 0000000000000000000000000000000000000000..c9ddc03864e5df66e343b003b4ba19465d058273
--- /dev/null
+++ b/lean/OAI/Algebra/AlgebraicObstruction/AdicFunctor.lean
@@ -0,0 +1,142 @@
+import Mathlib
+import OAI.Algebra.FrobeniusObstruction.Obstruction
+
+namespace OAI
+
+noncomputable section
+open scoped BigOperators
+
+namespace BoundaryOnly.FormalObstruction.AlgebraicReplacement
+namespace AdicCofinal
+variable {R : Type*} [CommRing R]
+
+lemma factor_eval (I : Ideal R) {m n : ℕ} (h : m ≤ n)
+    (x : AdicCompletion I R) :
+    Ideal.Quotient.factorPow I h (AdicCompletion.evalₐ I n x) =
+      AdicCompletion.evalₐ I m x := by
+  have hn : (I ^ n • ⊤ : Ideal R) = I ^ n := by simp
+  have hm : (I ^ m • ⊤ : Ideal R) = I ^ m := by simp
+  rw [← AdicCompletion.factor_eval_eq_evalₐ I x hn.le,
+    ← AdicCompletion.factor_eval_eq_evalₐ I x hm.le]
+  have hx := congrArg (Ideal.Quotient.factor hm.le) (x.property h)
+  simpa only [AdicCompletion.eval_apply, AdicCompletion.transitionMap,
+    Submodule.factorPow, Submodule.mapQ_eq_factor, Submodule.factor_eq_factor,
+    Ideal.Quotient.factorPow, Ideal.Quotient.factor_comp_apply] using hx
+
+def family (I J : Ideal R) (c : ℕ)
+    (hc : ∀ n, I ^ (n + c) ≤ J ^ n) (n : ℕ) :
+    AdicCompletion I R →+* R ⧸ J ^ n :=
+  (Ideal.Quotient.factor (hc n)).comp (AdicCompletion.evalₐ I (n+c)).toRingHom
+
+lemma family_compatible (I J : Ideal R) (c : ℕ)
+    (hc : ∀ n, I ^ (n + c) ≤ J ^ n) {m n : ℕ} (h : m ≤ n) :
+    (Ideal.Quotient.factorPow J h).comp (family I J c hc n) =
+      family I J c hc m := by
+  ext x
+  have hx := factor_eval I (Nat.add_le_add_right h c) x
+  have hy := congrArg (Ideal.Quotient.factor (hc m)) hx
+  simpa only [family, RingHom.comp_apply, AlgHom.toRingHom_eq_coe, RingHom.coe_coe,
+    Ideal.Quotient.factorPow, Ideal.Quotient.factor_comp_apply] using hy
+
+noncomputable def map (I J : Ideal R) (c : ℕ)
+    (hc : ∀ n, I ^ (n + c) ≤ J ^ n) :
+    AdicCompletion I R →+* AdicCompletion J R :=
+  AdicCompletion.liftRingHom J (family I J c hc) (family_compatible I J c hc)
+
+@[simp] lemma eval_map (I J : Ideal R) (c : ℕ)
+    (hc : ∀ n, I ^ (n + c) ≤ J ^ n) (n : ℕ) (x : AdicCompletion I R) :
+    AdicCompletion.evalₐ J n (map I J c hc x) =
+      Ideal.Quotient.factor (hc n) (AdicCompletion.evalₐ I (n+c) x) := by
+  exact AdicCompletion.evalₐ_liftRingHom J (family I J c hc)
+    (family_compatible I J c hc) n x
+
+lemma map_map (I J : Ideal R) (c d : ℕ)
+    (hc : ∀ n, I ^ (n + c) ≤ J ^ n)
+    (hd : ∀ n, J ^ (n + d) ≤ I ^ n) (x : AdicCompletion I R) :
+    map J I d hd (map I J c hc x) = x := by
+  apply AdicCompletion.ext_evalₐ
+  intro n
+  simp only [eval_map]
+  have he := factor_eval I (show n ≤ (n+d)+c by omega) x
+  simpa only [Ideal.Quotient.factorPow, Ideal.Quotient.factor_comp_apply] using he
+
+noncomputable def equiv (I J : Ideal R) (c d : ℕ)
+    (hc : ∀ n, I ^ (n + c) ≤ J ^ n)
+    (hd : ∀ n, J ^ (n + d) ≤ I ^ n) :
+    AdicCompletion I R ≃+* AdicCompletion J R :=
+  { map I J c hc with
+    invFun := map J I d hd
+    left_inv := map_map I J c d hc hd
+    right_inv := map_map J I d c hd hc }
+
+@[simp] lemma equiv_of (I J : Ideal R) (c d : ℕ)
+    (hc : ∀ n, I ^ (n + c) ≤ J ^ n)
+    (hd : ∀ n, J ^ (n + d) ≤ I ^ n) (r : R) :
+    equiv I J c d hc hd (AdicCompletion.of I R r) = AdicCompletion.of J R r := by
+  apply AdicCompletion.ext_evalₐ
+  intro n
+  change AdicCompletion.evalₐ J n (map I J c hc _) = _
+  simp
+
+end AdicCofinal
+end BoundaryOnly.FormalObstruction.AlgebraicReplacement
+
+namespace BoundaryOnly.FormalObstruction.AlgebraicReplacement
+namespace AdicFunctor
+variable {R S : Type*} [CommRing R] [CommRing S]
+
+lemma map_pow_le (I : Ideal R) (J : Ideal S) (f : R →+* S)
+    (hf : I ≤ J.comap f) (n : ℕ) : I ^ n ≤ (J ^ n).comap f := by
+  apply Ideal.map_le_iff_le_comap.mp
+  rw [Ideal.map_pow]
+  exact pow_le_pow_left' (Ideal.map_le_iff_le_comap.mpr hf) n
+
+def quotient (I : Ideal R) (J : Ideal S) (f : R →+* S)
+    (hf : I ≤ J.comap f) (n : ℕ) : R ⧸ I ^ n →+* S ⧸ J ^ n :=
+  Ideal.quotientMap _ f (map_pow_le I J f hf n)
+
+lemma quotient_compatible (I : Ideal R) (J : Ideal S) (f : R →+* S)
+    (hf : I ≤ J.comap f) {m n : ℕ} (h : m ≤ n) :
+    (Ideal.Quotient.factorPow J h).comp (quotient I J f hf n) =
+    (quotient I J f hf m).comp (Ideal.Quotient.factorPow I h) := by
+  ext x
+  rfl
+
+def family (I : Ideal R) (J : Ideal S) (f : R →+* S)
+    (hf : I ≤ J.comap f) (n : ℕ) : AdicCompletion I R →+* S ⧸ J ^ n :=
+  (quotient I J f hf n).comp (AdicCompletion.evalₐ I n).toRingHom
+
+lemma family_compatible (I : Ideal R) (J : Ideal S) (f : R →+* S)
+    (hf : I ≤ J.comap f) {m n : ℕ} (h : m ≤ n) :
+    (Ideal.Quotient.factorPow J h).comp (family I J f hf n) =
+      family I J f hf m := by
+  ext x
+  have he := congrArg (fun g : R ⧸ I ^ n →+* S ⧸ J ^ m ↦
+    g (AdicCompletion.evalₐ I n x)) (quotient_compatible I J f hf h)
+  simpa only [RingHom.comp_apply,AdicCofinal.factor_eval,family,
+    AlgHom.toRingHom_eq_coe,RingHom.coe_coe] using he
+
+noncomputable def map (I : Ideal R) (J : Ideal S) (f : R →+* S)
+    (hf : I ≤ J.comap f) : AdicCompletion I R →+* AdicCompletion J S :=
+  AdicCompletion.liftRingHom J (family I J f hf) (family_compatible I J f hf)
+
+@[simp] lemma eval_map (I : Ideal R) (J : Ideal S) (f : R →+* S)
+    (hf : I ≤ J.comap f) (n : ℕ) (x : AdicCompletion I R) :
+    AdicCompletion.evalₐ J n (map I J f hf x) =
+      quotient I J f hf n (AdicCompletion.evalₐ I n x) :=
+  AdicCompletion.evalₐ_liftRingHom J (family I J f hf)
+    (family_compatible I J f hf) n x
+
+@[simp] lemma map_of (I : Ideal R) (J : Ideal S) (f : R →+* S)
+    (hf : I ≤ J.comap f) (r : R) :
+    map I J f hf (AdicCompletion.of I R r) = AdicCompletion.of J S (f r) := by
+  apply AdicCompletion.ext_evalₐ
+  intro n
+  simp [quotient]
+
+end AdicFunctor
+end BoundaryOnly.FormalObstruction.AlgebraicReplacement
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/AlgebraicObstruction/AlgebraicData.lean b/lean/OAI/Algebra/AlgebraicObstruction/AlgebraicData.lean
new file mode 100644
index 0000000000000000000000000000000000000000..ba827b1ffba4b6a9c94ad9164c439a86f8bf3bf3
--- /dev/null
+++ b/lean/OAI/Algebra/AlgebraicObstruction/AlgebraicData.lean
@@ -0,0 +1,122 @@
+import Mathlib
+import OAI.Algebra.FrobeniusObstruction.Obstruction
+import OAI.Algebra.AlgebraicObstruction.AlgebraicGerms
+
+namespace OAI
+
+noncomputable section
+open scoped BigOperators
+
+namespace BoundaryOnly.FormalObstruction.CoefficientRing
+open MvPowerSeries FormalCorrection
+open scoped Classical
+variable {K : Type} [Field K] {d : ℕ} {n : Fin d → ℕ}
+
+lemma potential_germ (P : (i : Fin d) → MvPowerSeries (WallVar n i) K)
+    (hP : ∀ i, Nonempty (LocalEtaleExpansion (P i))) :
+    Nonempty (LocalEtaleExpansion (potential n P)) := by
+  apply germ_sum
+  intro i _
+  apply germ_sub
+  · apply germ_subst _ (hP i)
+    · intro j; cases j <;> exact germ_X _
+    · intro j; cases j <;> simp [plusCoordinates]
+  · apply germ_subst _ (hP i)
+    · intro j; cases j
+      · exact germ_zero
+      · exact germ_X _
+    · intro j; cases j <;> simp [minusCoordinates]
+
+lemma graphCoordinates_germ (Y : InternalVar n → MvPowerSeries (GraphVar n) K)
+    (hY : ∀ c, Nonempty (LocalEtaleExpansion (Y c))) :
+    ∀ i, Nonempty (LocalEtaleExpansion (graphCoordinates n Y i)) := by
+  rintro (a | c)
+  · exact germ_X _
+  · exact hY c
+
+lemma graphCoordinates_constant (Q : QuadraticData (R := K) (n := n)) :
+    ∀ i, constantCoeff (graphCoordinates n Q.Y i) = 0 := by
+  rintro (a | c)
+  · exact constantCoeff_X _
+  · exact origin_constant (Q.centered c)
+
+lemma restrictedGradient_germ (Q : QuadraticData (R := K) (n := n))
+    (hP : ∀ i, Nonempty (LocalEtaleExpansion (Q.P i)))
+    (hY : ∀ c, Nonempty (LocalEtaleExpansion (Q.Y c))) (c : InternalVar n) :
+    Nonempty (LocalEtaleExpansion (restrictedGradient n Q.P Q.Y c)) :=
+  germ_subst _ (germ_pderiv (potential_germ Q.P hP) _) (graphCoordinates_germ Q.Y hY)
+    (graphCoordinates_constant Q)
+
+lemma negativeSlopeValue_germ (Q : QuadraticData (R := K) (n := n))
+    (hP : ∀ i, Nonempty (LocalEtaleExpansion (Q.P i)))
+    (hY : ∀ c, Nonempty (LocalEtaleExpansion (Q.Y c))) (i : Fin d) :
+    Nonempty (LocalEtaleExpansion (negativeSlopeValue n Q.P Q.Y i)) := by
+  apply germ_subst _ _ (fun j ↦ hY (false,⟨i,j⟩))
+    (fun j ↦ origin_constant (Q.centered (false,⟨i,j⟩)))
+  apply germ_subst _ (germ_pderiv (hP i) _)
+  · intro j; cases j
+    · exact germ_zero
+    · exact germ_X _
+  · intro j; cases j <;> simp [zeroSlopes]
+
+theorem QuadraticData.etale_witnesses (Q : QuadraticData (R := K) (n := n))
+    (hP : ∀ i, Nonempty (LocalEtaleExpansion (Q.P i)))
+    (hY : ∀ c, Nonempty (LocalEtaleExpansion (Q.Y c))) :
+    ∃ W : QuadraticWitnesses Q,
+      (∀ c e, Nonempty (LocalEtaleExpansion (W.b c e))) ∧
+      (∀ t c, Nonempty (LocalEtaleExpansion (W.pos t c))) ∧
+      (∀ t c, Nonempty (LocalEtaleExpansion (W.neg t c))) := by
+  have hgrad := restrictedGradient_germ Q hP hY
+  have hvalue := germ_subst (graphCoordinates n Q.Y) (potential_germ Q.P hP)
+    (graphCoordinates_germ Q.Y hY) (graphCoordinates_constant Q)
+  obtain ⟨b,hb,hbg⟩ := germ_square_witness _ _ hgrad hvalue Q.graph_square
+  have hp : ∀ t : Fin d × Fin d × Fin d,
+      ∃ c : InternalVar n → MvPowerSeries (GraphVar n) K,
+        slope n t.1 * slope n t.2.1 * slope n t.2.2 =
+          ∑ e, c e * restrictedGradient n Q.P Q.Y e ∧
+        ∀ e, Nonempty (LocalEtaleExpansion (c e)) := by
+    intro t
+    apply germ_span_witness _ _ hgrad
+    · exact germ_mul (germ_mul (germ_X _) (germ_X _)) (germ_X _)
+    · exact Q.positive_cubic t.1 t.2.1 t.2.2
+  have hn : ∀ t : Fin d × Fin d × Fin d,
+      ∃ c : InternalVar n → MvPowerSeries (GraphVar n) K,
+        negativeSlopeValue n Q.P Q.Y t.1 * negativeSlopeValue n Q.P Q.Y t.2.1 *
+          negativeSlopeValue n Q.P Q.Y t.2.2 =
+          ∑ e, c e * restrictedGradient n Q.P Q.Y e ∧
+        ∀ e, Nonempty (LocalEtaleExpansion (c e)) := by
+    intro t
+    apply germ_span_witness _ _ hgrad
+    · exact germ_mul (germ_mul (negativeSlopeValue_germ Q hP hY _)
+        (negativeSlopeValue_germ Q hP hY _)) (negativeSlopeValue_germ Q hP hY _)
+    · exact Q.negative_cubic t.1 t.2.1 t.2.2
+  choose p hp hpg using hp
+  choose r hr hrg using hn
+  exact ⟨⟨b,p,r,hb,hp,hr⟩,hbg,hpg,hrg⟩
+
+end BoundaryOnly.FormalObstruction.CoefficientRing
+
+namespace BoundaryOnly.FormalObstruction.CoefficientRing
+open MvPowerSeries FormalCorrection
+open scoped Classical
+variable {K : Type} [Field K] [CharZero K] {d : ℕ} {n : Fin d → ℕ}
+
+theorem no_algebraic_quadratic_data (hd : 5 ≤ d)
+    (Q : QuadraticData (R := K) (n := n))
+    (hP : ∀ i, Nonempty (LocalEtaleExpansion (Q.P i)))
+    (hY : ∀ c, Nonempty (LocalEtaleExpansion (Q.Y c))) : False := by
+  obtain ⟨W,hb,hpos,hneg⟩ := Q.etale_witnesses hP hY
+  apply no_etale_quadratic_data hd Q W
+  intro e
+  cases e with
+  | wall i => exact (hP i).some
+  | graph c => exact (hY c).some
+  | quadratic c e => exact (hb c e).some
+  | positive t c => exact (hpos t c).some
+  | negative t c => exact (hneg t c).some
+
+end BoundaryOnly.FormalObstruction.CoefficientRing
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/AlgebraicObstruction/AlgebraicGerms.lean b/lean/OAI/Algebra/AlgebraicObstruction/AlgebraicGerms.lean
new file mode 100644
index 0000000000000000000000000000000000000000..40d0b16558f28443af3ee08081e654524038f3fc
--- /dev/null
+++ b/lean/OAI/Algebra/AlgebraicObstruction/AlgebraicGerms.lean
@@ -0,0 +1,328 @@
+import Mathlib
+import OAI.Algebra.FrobeniusObstruction.Obstruction
+import OAI.Algebra.AlgebraicObstruction.EtaleCharts
+
+namespace OAI
+
+noncomputable section
+open scoped BigOperators
+
+namespace BoundaryOnly.FormalObstruction.FormalCorrection
+open MvPowerSeries
+open scoped Classical
+variable {K α ι : Type} [Field K] [Finite α] [Fintype ι]
+
+theorem common_chart_finite (v : ι → MvPowerSeries α K)
+    (hv : ∀ i, Nonempty (LocalEtaleExpansion (v i))) :
+    ∃ E : AffineEtaleChart K α, ∀ i, v i ∈ E.localExpansion.range := by
+  obtain ⟨E,hE⟩ := common_affine_chart (Finset.univ.image v) (by
+    intro φ hφ
+    obtain ⟨i,_,rfl⟩ := Finset.mem_image.mp hφ
+    exact hv i)
+  exact ⟨E,fun i ↦ E.localRange (hE _ (Finset.mem_image.mpr ⟨i,Finset.mem_univ _,rfl⟩))⟩
+
+theorem germ_span_witness (v : ι → MvPowerSeries α K) (x : MvPowerSeries α K)
+    (hv : ∀ i, Nonempty (LocalEtaleExpansion (v i)))
+    (hx : Nonempty (LocalEtaleExpansion x))
+    (hm : x ∈ Ideal.span (Set.range v)) :
+    ∃ c : ι → MvPowerSeries α K, x = ∑ i, c i * v i ∧
+      ∀ i, Nonempty (LocalEtaleExpansion (c i)) := by
+  let w : Option ι → MvPowerSeries α K := fun e ↦ e.elim x v
+  have hw : ∀ e, Nonempty (LocalEtaleExpansion (w e)) := by
+    rintro (_ | i)
+    · exact hx
+    · exact hv i
+  obtain ⟨E,hE⟩ := common_chart_finite w hw
+  obtain ⟨xE,hxE⟩ := hE none
+  change E.localExpansion xE = x at hxE
+  have hvs : ∀ i, ∃ vi : E.LocalRing, E.localExpansion vi = v i := fun i ↦ hE (some i)
+  choose vE hvE using hvs
+  let I : Ideal E.LocalRing := Ideal.span (Set.range vE)
+  let := E.localFaithfullyFlat
+  have hI : I.map (algebraMap E.LocalRing (MvPowerSeries α K)) =
+      Ideal.span (Set.range v) := by
+    change (Ideal.span (Set.range vE)).map _ = _
+    rw [Ideal.map_span, ← Set.range_comp]
+    congr 1
+    exact congrArg Set.range (funext hvE)
+  have hmE : xE ∈ I := by
+    apply (BoundaryOnly.FormalObstruction.AlgebraicReplacement.etale_expansion_mem_iff (K := K) (α := α) I xE).mp
+    rw [hI]
+    change E.localExpansion xE ∈ _
+    rw [hxE]
+    exact hm
+  obtain ⟨c,hc⟩ := Ideal.mem_span_range_iff_exists_fun.mp hmE
+  refine ⟨fun i ↦ E.localExpansion (c i), ?_, fun i ↦ ⟨E.localGerm (c i)⟩⟩
+  have hc' := congrArg E.localExpansion hc
+  simp only [map_sum,map_mul,hvE] at hc'
+  exact hxE.symm.trans hc'.symm
+
+theorem germ_mul {x y : MvPowerSeries α K}
+    (hx : Nonempty (LocalEtaleExpansion x)) (hy : Nonempty (LocalEtaleExpansion y)) :
+    Nonempty (LocalEtaleExpansion (x*y)) := by
+  let v : Bool → MvPowerSeries α K := fun b ↦ if b then x else y
+  have hv : ∀ b, Nonempty (LocalEtaleExpansion (v b)) := by
+    rintro (_ | _) <;> assumption
+  obtain ⟨E,hE⟩ := common_chart_finite v hv
+  obtain ⟨a,ha⟩ := hE true
+  obtain ⟨b,hb⟩ := hE false
+  change E.localExpansion a = x at ha
+  change E.localExpansion b = y at hb
+  have he : E.localExpansion (a*b) = x*y := by rw [map_mul,ha,hb]
+  rw [← he]
+  exact ⟨E.localGerm (a*b)⟩
+
+theorem germ_square_witness (v : ι → MvPowerSeries α K) (x : MvPowerSeries α K)
+    (hv : ∀ i, Nonempty (LocalEtaleExpansion (v i)))
+    (hx : Nonempty (LocalEtaleExpansion x))
+    (hm : x ∈ (Ideal.span (Set.range v))^2) :
+    ∃ b : ι → ι → MvPowerSeries α K, x = ∑ i, ∑ j, b i j * v i * v j ∧
+      ∀ i j, Nonempty (LocalEtaleExpansion (b i j)) := by
+  have hI : (Ideal.span (Set.range v))^2 =
+      Ideal.span (Set.range (fun ij : ι × ι ↦ v ij.1 * v ij.2)) := by
+    rw [pow_two, Ideal.span_mul_span]
+    congr 1
+    ext z
+    constructor
+    · rintro ⟨a,⟨i,rfl⟩,b,⟨j,rfl⟩,rfl⟩
+      exact ⟨(i,j),rfl⟩
+    · rintro ⟨⟨i,j⟩,rfl⟩
+      exact ⟨v i,⟨i,rfl⟩,v j,⟨j,rfl⟩,rfl⟩
+  rw [hI] at hm
+  obtain ⟨b,hb,hg⟩ := germ_span_witness (fun ij : ι × ι ↦ v ij.1 * v ij.2) x
+    (fun ij ↦ germ_mul (hv ij.1) (hv ij.2)) hx hm
+  refine ⟨fun i j ↦ b (i,j),?_,fun i j ↦ hg (i,j)⟩
+  simpa only [Fintype.sum_prod_type,mul_assoc] using hb
+
+end BoundaryOnly.FormalObstruction.FormalCorrection
+
+namespace BoundaryOnly.FormalObstruction.AlgebraicReplacement
+open TensorProduct
+variable {R S T M : Type*} [CommRing R] [CommRing S] [CommRing T]
+  [Algebra R S] [Algebra R T] [Algebra S T] [IsScalarTower R S T]
+  [Algebra.FormallyEtale S T]
+
+def extendDerivation (d : Derivation R S S) : Derivation R T T :=
+  (((Algebra.linearMap S T).compDer d).liftKaehlerDifferential.liftBaseChange T ∘ₗ
+    (KaehlerDifferential.tensorKaehlerEquivOfFormallyEtale R S T).symm.toLinearMap).compDer
+      (KaehlerDifferential.D R T)
+
+@[simp] theorem extendDerivation_algebraMap (d : Derivation R S S) (s : S) :
+    extendDerivation (T := T) d (algebraMap S T s) = algebraMap S T (d s) := by
+  change ((Algebra.linearMap S T).compDer d).liftKaehlerDifferential.liftBaseChange T
+    ((KaehlerDifferential.tensorKaehlerEquivOfFormallyEtale R S T).symm
+      (KaehlerDifferential.D R T (algebraMap S T s))) = _
+  rw [KaehlerDifferential.tensorKaehlerEquivOfFormallyEtale_symm_D_algebraMap]
+  simp
+
+theorem etale_derivation_ext [AddCommGroup M] [Module R M] [Module S M] [Module T M]
+    [IsScalarTower R T M] [IsScalarTower S T M] [IsScalarTower R S M]
+    (d e : Derivation R T M)
+    (h : ∀ s : S, d (algebraMap S T s) = e (algebraMap S T s)) : d = e := by
+  let k := KaehlerDifferential.tensorKaehlerEquivOfFormallyEtale R S T
+  have hl : d.liftKaehlerDifferential ∘ₗ k.toLinearMap =
+      e.liftKaehlerDifferential ∘ₗ k.toLinearMap := by
+    ext s
+    simp [k,KaehlerDifferential.mapBaseChange_tmul,KaehlerDifferential.map_D,h]
+  ext t
+  obtain ⟨z,hz⟩ := k.surjective (KaehlerDifferential.D R T t)
+  have hh := congrArg (fun f : T ⊗[S] KaehlerDifferential R S →ₗ[T] M ↦ f z) hl
+  simpa only [LinearMap.comp_apply,LinearEquiv.coe_coe,hz,
+    Derivation.liftKaehlerDifferential_comp_D] using hh
+
+end BoundaryOnly.FormalObstruction.AlgebraicReplacement
+
+namespace BoundaryOnly.FormalObstruction.FormalCorrection
+open MvPowerSeries
+variable {K α : Type} [Field K] [Finite α]
+
+omit [Finite α] in
+lemma polynomial_pderiv_expansion [Finite α] (p : MvPolynomial α K) (i : α) :
+    pderiv i p.toMvPowerSeries = (MvPolynomial.pderiv i p).toMvPowerSeries := by
+  classical
+  induction p using MvPolynomial.induction_on with
+  | C k => simp
+  | add p q hp hq => simpa only [MvPolynomial.coe_add,map_add] using congrArg₂ (· + ·) hp hq
+  | mul_X p j hp =>
+      simp only [MvPolynomial.coe_mul,MvPolynomial.coe_add,Derivation.leibniz,smul_eq_mul,
+        MvPolynomial.pderiv_X,MvPolynomial.coe_X,pderiv_X,hp,Pi.single_apply]
+      split_ifs <;> simp_all
+
+noncomputable instance AffineEtaleChart.localCoeffAlgebra (E : AffineEtaleChart K α) :
+    Algebra K E.LocalRing := Algebra.compHom E.LocalRing (algebraMap K (MvPolynomial α K))
+
+instance AffineEtaleChart.localCoeffTower (E : AffineEtaleChart K α) :
+    IsScalarTower K (MvPolynomial α K) E.LocalRing :=
+  IsScalarTower.of_algebraMap_eq' rfl
+
+instance AffineEtaleChart.localCompletionCoeffTower (E : AffineEtaleChart K α) :
+    IsScalarTower K E.LocalRing (MvPowerSeries α K) := by
+  apply IsScalarTower.of_algebraMap_eq
+  intro k
+  rw [IsScalarTower.algebraMap_apply K (MvPolynomial α K) E.LocalRing,
+    ← IsScalarTower.algebraMap_apply (MvPolynomial α K) E.LocalRing (MvPowerSeries α K),
+    ← IsScalarTower.algebraMap_apply K (MvPolynomial α K) (MvPowerSeries α K)]
+
+noncomputable def AffineEtaleChart.deriv (E : AffineEtaleChart K α) (i : α) :
+    Derivation K E.LocalRing E.LocalRing :=
+  BoundaryOnly.FormalObstruction.AlgebraicReplacement.extendDerivation (MvPolynomial.pderiv i)
+
+lemma AffineEtaleChart.expansion_deriv (E : AffineEtaleChart K α) (i : α) (x : E.LocalRing) :
+    E.localExpansion (E.deriv i x) = pderiv i (E.localExpansion x) := by
+  let d := (Algebra.linearMap E.LocalRing (MvPowerSeries α K)).compDer (E.deriv i)
+  let e := (pderiv (R := K) i).compAlgebraMap E.LocalRing
+  have hd : d = e := by
+    apply BoundaryOnly.FormalObstruction.AlgebraicReplacement.etale_derivation_ext
+      (S := MvPolynomial α K)
+    intro p
+    change algebraMap E.LocalRing (MvPowerSeries α K)
+      (BoundaryOnly.FormalObstruction.AlgebraicReplacement.extendDerivation (MvPolynomial.pderiv i)
+        (algebraMap (MvPolynomial α K) E.LocalRing p)) =
+      pderiv i (algebraMap E.LocalRing (MvPowerSeries α K)
+        (algebraMap (MvPolynomial α K) E.LocalRing p))
+    rw [BoundaryOnly.FormalObstruction.AlgebraicReplacement.extendDerivation_algebraMap,
+      ← IsScalarTower.algebraMap_apply, ← IsScalarTower.algebraMap_apply]
+    exact (polynomial_pderiv_expansion p i).symm
+  exact Derivation.congr_fun hd x
+
+theorem germ_pderiv {φ : MvPowerSeries α K}
+    (hφ : Nonempty (LocalEtaleExpansion φ)) (i : α) :
+    Nonempty (LocalEtaleExpansion (pderiv i φ)) := by
+  obtain ⟨E,hE⟩ := hφ.some.affine
+  obtain ⟨x,hx⟩ := E.localRange hE
+  change E.localExpansion x = φ at hx
+  rw [← hx, ← E.expansion_deriv]
+  exact ⟨E.localGerm (E.deriv i x)⟩
+
+end BoundaryOnly.FormalObstruction.FormalCorrection
+
+namespace BoundaryOnly.FormalObstruction.FormalCorrection
+open MvPowerSeries
+open scoped TensorProduct
+variable {K α β : Type} [Field K] [Finite α] [Finite β]
+
+lemma AffineEtaleChart.germ (E : AffineEtaleChart K α) {φ : MvPowerSeries α K}
+    (h : φ ∈ E.expansion.range) : Nonempty (LocalEtaleExpansion φ) := by
+  obtain ⟨x,hx⟩ := E.localRange h
+  change E.localExpansion x = φ at hx
+  rw [← hx]
+  exact ⟨E.localGerm x⟩
+
+lemma germ_polynomial (p : MvPolynomial α K) :
+    Nonempty (LocalEtaleExpansion p.toMvPowerSeries) :=
+  (AffineEtaleChart.base : AffineEtaleChart K α).germ ⟨p,rfl⟩
+
+lemma germ_X (i : α) : Nonempty (LocalEtaleExpansion (X i : MvPowerSeries α K)) := by
+  simpa using germ_polynomial (MvPolynomial.X i : MvPolynomial α K)
+
+lemma germ_zero : Nonempty (LocalEtaleExpansion (0 : MvPowerSeries α K)) := by
+  simpa using germ_polynomial (0 : MvPolynomial α K)
+
+lemma germ_add {x y : MvPowerSeries α K}
+    (hx : Nonempty (LocalEtaleExpansion x)) (hy : Nonempty (LocalEtaleExpansion y)) :
+    Nonempty (LocalEtaleExpansion (x+y)) := by
+  let v : Bool → MvPowerSeries α K := fun b ↦ if b then x else y
+  have hv : ∀ b, Nonempty (LocalEtaleExpansion (v b)) := by
+    rintro (_ | _) <;> assumption
+  obtain ⟨E,hE⟩ := common_chart_finite v hv
+  obtain ⟨a,ha⟩ := hE true
+  obtain ⟨b,hb⟩ := hE false
+  change E.localExpansion a = x at ha
+  change E.localExpansion b = y at hb
+  have he : E.localExpansion (a+b) = x+y := by rw [map_add,ha,hb]
+  rw [← he]
+  exact ⟨E.localGerm (a+b)⟩
+
+lemma germ_neg {x : MvPowerSeries α K}
+    (hx : Nonempty (LocalEtaleExpansion x)) :
+    Nonempty (LocalEtaleExpansion (-x)) := by
+  obtain ⟨E,⟨a,ha⟩⟩ := hx.some.affine
+  apply E.germ
+  exact ⟨-a,by simpa only [map_neg] using congrArg Neg.neg ha⟩
+
+lemma germ_sub {x y : MvPowerSeries α K}
+    (hx : Nonempty (LocalEtaleExpansion x)) (hy : Nonempty (LocalEtaleExpansion y)) :
+    Nonempty (LocalEtaleExpansion (x-y)) := by
+  rw [sub_eq_add_neg]
+  exact germ_add hx (germ_neg hy)
+
+lemma germ_sum {ι : Type*} (s : Finset ι) (v : ι → MvPowerSeries α K)
+    (hv : ∀ i ∈ s, Nonempty (LocalEtaleExpansion (v i))) :
+    Nonempty (LocalEtaleExpansion (∑ i ∈ s, v i)) := by
+  classical
+  induction s using Finset.induction_on with
+  | empty => simpa using (germ_zero (K := K) (α := α))
+  | @insert i s hi ih =>
+      rw [Finset.sum_insert hi]
+      exact germ_add (hv i (Finset.mem_insert_self _ _))
+        (ih (fun j hj ↦ hv j (Finset.mem_insert_of_mem hj)))
+
+theorem germ_subst {φ : MvPowerSeries α K} (u : α → MvPowerSeries β K)
+    (hφ : Nonempty (LocalEtaleExpansion φ))
+    (hu : ∀ i, Nonempty (LocalEtaleExpansion (u i)))
+    (hc : ∀ i, constantCoeff (u i) = 0) :
+    Nonempty (LocalEtaleExpansion (subst u φ)) := by
+  classical
+  let := Fintype.ofFinite α
+  obtain ⟨E,x,hx⟩ := hφ.some.affine
+  obtain ⟨F,hF⟩ := common_affine_chart (Finset.univ.image u) (by
+    intro ψ hψ
+    obtain ⟨i,_,rfl⟩ := Finset.mem_image.mp hψ
+    exact hu i)
+  have hv : ∀ i, ∃ v : F.S, F.expansion v = u i := fun i ↦
+    hF _ (Finset.mem_image.mpr ⟨i,Finset.mem_univ _,rfl⟩)
+  choose v hv using hv
+  let f : MvPolynomial α K →+* F.S := MvPolynomial.eval₂Hom
+    ((algebraMap (MvPolynomial β K) F.S).comp MvPolynomial.C) v
+  let g : MvPolynomial α K →+* MvPowerSeries β K := MvPolynomial.eval₂Hom C u
+  let : Algebra (MvPolynomial α K) F.S := f.toAlgebra
+  let : Algebra (MvPolynomial α K) (MvPowerSeries β K) := g.toAlgebra
+  let fF : F.S →ₐ[MvPolynomial α K] MvPowerSeries β K :=
+    ⟨F.expansion.toRingHom, by
+      intro p
+      change F.expansion (f p) = g p
+      induction p using MvPolynomial.induction_on with
+      | C k =>
+          simp only [f,g,MvPolynomial.eval₂Hom_C,RingHom.comp_apply]
+          have hk := F.expansion.commutes (MvPolynomial.C k)
+          change _ = (MvPolynomial.C k).toMvPowerSeries at hk
+          simpa using hk
+      | add p q hp hq => simp only [map_add,hp,hq]
+      | mul_X p i hp => simp only [map_mul,f,g,MvPolynomial.eval₂Hom_X',hv,hp]⟩
+  let su := substAlgHom (R := K) (hasSubst_of_constantCoeff_zero hc)
+  let fE : E.S →ₐ[MvPolynomial α K] MvPowerSeries β K :=
+    ⟨su.toRingHom.comp E.expansion.toRingHom, by
+      intro p
+      change su (E.expansion (algebraMap (MvPolynomial α K) E.S p)) = g p
+      rw [E.expansion.commutes]
+      change substAlgHom (R := K) (hasSubst_of_constantCoeff_zero hc) p.toMvPowerSeries = g p
+      rw [substAlgHom_coe]
+      rfl⟩
+  let : SMulCommClass (MvPolynomial α K) (MvPolynomial β K) F.S :=
+    ⟨fun scalarLeft scalarRight element ↦ by simp only [Algebra.smul_def, mul_left_comm]⟩
+  let T := F.S ⊗[MvPolynomial α K] E.S
+  let : Algebra (MvPolynomial β K) T := Algebra.TensorProduct.leftAlgebra
+  let t : T →ₐ[MvPolynomial α K] MvPowerSeries β K :=
+    Algebra.TensorProduct.lift fF fE (fun _ _ ↦ Commute.all _ _)
+  let : Algebra.Etale (MvPolynomial β K) T := Algebra.Etale.comp (MvPolynomial β K) F.S T
+  let H : AffineEtaleChart K β :=
+    ⟨T,inferInstance,inferInstance,inferInstance,
+     ⟨t.toRingHom,by
+       intro p
+       rw [IsScalarTower.algebraMap_apply (MvPolynomial β K) F.S T]
+       change fF (algebraMap (MvPolynomial β K) F.S p) * fE 1 = _
+       rw [map_one,mul_one]
+       exact F.expansion.commutes p⟩⟩
+  apply H.germ
+  refine ⟨Algebra.TensorProduct.includeRight x,?_⟩
+  change fF 1 * fE x = subst u φ
+  rw [map_one,one_mul]
+  change su (E.expansion x) = subst u φ
+  rw [show E.expansion x = φ from hx]
+  exact congrFun (coe_substAlgHom (R := K) (hasSubst_of_constantCoeff_zero hc)) φ
+
+end BoundaryOnly.FormalObstruction.FormalCorrection
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/AlgebraicObstruction/AlgebraicInput.lean b/lean/OAI/Algebra/AlgebraicObstruction/AlgebraicInput.lean
new file mode 100644
index 0000000000000000000000000000000000000000..d804c5d161315dd5fdc233e28fe8467b3c7ab917
--- /dev/null
+++ b/lean/OAI/Algebra/AlgebraicObstruction/AlgebraicInput.lean
@@ -0,0 +1,122 @@
+import Mathlib
+import OAI.Algebra.FrobeniusObstruction.Obstruction
+import OAI.Algebra.AlgebraicObstruction.AlgebraicData
+import OAI.Algebra.AlgebraicObstruction.RadicalPrimitives
+import OAI.Algebra.AlgebraicObstruction.PotentialReplacement
+
+namespace OAI
+
+noncomputable section
+open scoped BigOperators
+
+namespace BoundaryOnly.FormalObstruction.FormalCorrection.AffineEtaleChart
+open MvPowerSeries
+variable {K α : Type} [Field K] [CharZero K] [IsAlgClosed K] [Finite α]
+
+omit [CharZero K] [IsAlgClosed K] in
+lemma completion_map_ideal [CharZero K] [IsAlgClosed K]
+    (E : AffineEtaleChart K α) (L : Ideal E.LocalRing) :
+    (L.map (algebraMap E.LocalRing
+      (AdicCompletion (IsLocalRing.maximalIdeal E.LocalRing) E.LocalRing))).map
+      E.completionEquiv.toRingHom = L.map E.localExpansion.toRingHom := by
+  rw [Ideal.map_map]
+  congr 1
+  apply RingHom.ext
+  intro a
+  exact E.completionEquiv_of a
+
+lemma completion_mem_iff (E : AffineEtaleChart K α) (L : Ideal E.LocalRing)
+    (b : AdicCompletion (IsLocalRing.maximalIdeal E.LocalRing) E.LocalRing) :
+    E.completionEquiv b ∈ L.map E.localExpansion.toRingHom ↔
+    b ∈ L.map (algebraMap E.LocalRing
+      (AdicCompletion (IsLocalRing.maximalIdeal E.LocalRing) E.LocalRing)) := by
+  rw [← E.completion_map_ideal L]
+  exact Ideal.apply_mem_of_equiv_iff
+
+theorem primitive_series_approximation (E : AffineEtaleChart K α) (L : Ideal E.LocalRing)
+    (P : MvPowerSeries α K)
+    (hgrad : ∀ j : α, pderiv (R := K) j P ∈ L.map E.localExpansion.toRingHom)
+    (hjets : ∀ j : α, ∀ q : ℕ, 1 ≤ q → ∃ a : E.LocalRing,
+      pderiv (R := K) j P - E.localExpansion a ∈ (L.map E.localExpansion.toRingHom)^q)
+    (m : ℕ) (hm : 1 ≤ m) :
+    ∃ a : E.LocalRing, P - E.localExpansion a ∈ (L.map E.localExpansion.toRingHom)^m := by
+  let b := E.completionEquiv.symm P
+  have hb : E.completionEquiv b = P := E.completionEquiv.apply_symm_apply P
+  have hd (j : α) : E.completionEquiv (E.completionDeriv j b) = pderiv (R := K) j P := by
+    change E.completionEquiv (E.completionEquiv.symm (pderiv (R := K) j (E.completionEquiv b))) = _
+    rw [E.completionEquiv.apply_symm_apply,hb]
+  obtain ⟨a,ha⟩ := E.primitive_approximation L b (fun j ↦
+    (E.completion_mem_iff L _).mp (by rw [hd]; exact hgrad j)) (by
+      intro j q hq
+      obtain ⟨a,ha⟩ := hjets j q hq
+      refine ⟨a,?_⟩
+      rw [← Ideal.map_pow]
+      apply (E.completion_mem_iff (L^q) _).mp
+      rw [map_sub,hd,E.completionEquiv_of,Ideal.map_pow]
+      exact ha) m hm
+  refine ⟨a,?_⟩
+  have h := (E.completion_mem_iff (L^m) _).mpr ha
+  rwa [map_sub,hb,E.completionEquiv_of,Ideal.map_pow] at h
+
+end BoundaryOnly.FormalObstruction.FormalCorrection.AffineEtaleChart
+
+namespace BoundaryOnly.FormalObstruction.FormalCorrection.AffineEtaleChart
+open MvPowerSeries
+variable {K α : Type} [Field K] [CharZero K] [IsAlgClosed K] [Finite α]
+
+omit [CharZero K] [IsAlgClosed K] in
+lemma ideal_map_origin [CharZero K] [IsAlgClosed K]
+    (E : AffineEtaleChart K α) (L : Ideal E.LocalRing)
+    (hL : L ≤ IsLocalRing.maximalIdeal E.LocalRing) :
+    L.map E.localExpansion.toRingHom ≤ originIdeal K α := by
+  classical
+  let := Fintype.ofFinite α
+  apply Ideal.map_le_iff_le_comap.mpr
+  intro a ha
+  apply mem_origin_iff.mpr
+  by_contra hn
+  have hu : IsUnit (E.localExpansion a) := MvPowerSeries.isUnit_iff_constantCoeff.mpr
+    (isUnit_iff_ne_zero.mpr hn)
+  exact (hL ha) (isUnit_of_map_unit E.localExpansion a hu)
+
+end BoundaryOnly.FormalObstruction.FormalCorrection.AffineEtaleChart
+
+namespace BoundaryOnly.FormalObstruction.CoefficientRing
+open MvPowerSeries FormalCorrection AlgebraicReplacement
+open scoped Classical
+variable {K : Type} [Field K] [CharZero K] [IsAlgClosed K] {d : ℕ} {n : Fin d → ℕ}
+
+theorem no_algebraic_input (hd : 5 ≤ d)
+    (Q : QuadraticData (R := K) (n := n))
+    (E : (i : Fin d) → AffineEtaleChart K (WallVar n i))
+    (L : (i : Fin d) → Ideal (E i).LocalRing)
+    (hL : ∀ i, L i ≤ IsLocalRing.maximalIdeal (E i).LocalRing)
+    (hgradient : ∀ i w, pderiv (R := K) w (Q.P i) ∈ (L i).map (E i).localExpansion.toRingHom)
+    (hjets : ∀ i w, ∀ q : ℕ, 1 ≤ q → ∃ a : (E i).LocalRing,
+      pderiv (R := K) w (Q.P i) - (E i).localExpansion a ∈
+        ((L i).map (E i).localExpansion.toRingHom)^q)
+    (hpulled : ∀ b i, Ideal.map (wallEval Q.Y Q.centered b i)
+      ((L i).map (E i).localExpansion.toRingHom) ≤ originIdeal K (GraphVar n))
+    (hcube : ∀ b i, (Ideal.map (wallEval Q.Y Q.centered b i)
+      ((L i).map (E i).localExpansion.toRingHom))^3 ≤ gradientIdeal n Q.P Q.Y)
+    (hY : ∀ c, Nonempty (LocalEtaleExpansion (Q.Y c))) : False := by
+  have happ (i : Fin d) := (E i).primitive_series_approximation (L i) (Q.P i)
+    (hgradient i) (hjets i) 9 (by omega)
+  choose a ha using happ
+  let P := fun i ↦ (E i).localExpansion (a i)
+  let W := fun i ↦ (L i).map (E i).localExpansion.toRingHom
+  have hW (i : Fin d) : W i ≤ originIdeal K (WallVar n i) :=
+    (E i).ideal_map_origin (L i) (hL i)
+  have hP (i : Fin d) : P i - Q.P i ∈ (W i)^9 := by
+    simpa only [neg_sub] using ((W i)^9).neg_mem (ha i)
+  let T : QuadraticData (R := K) (n := n) := Q.replace W hW hpulled hcube P hP
+  apply no_algebraic_quadratic_data hd T
+  · intro i
+    exact ⟨(E i).localGerm (a i)⟩
+  · exact hY
+
+end BoundaryOnly.FormalObstruction.CoefficientRing
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/AlgebraicObstruction/AnalyticReducedness.lean b/lean/OAI/Algebra/AlgebraicObstruction/AnalyticReducedness.lean
new file mode 100644
index 0000000000000000000000000000000000000000..91b7da16daa70427ecffbce6f35da7ecac2ea029
--- /dev/null
+++ b/lean/OAI/Algebra/AlgebraicObstruction/AnalyticReducedness.lean
@@ -0,0 +1,360 @@
+import Mathlib
+import OAI.Algebra.FrobeniusObstruction.Obstruction
+import OAI.Algebra.AlgebraicObstruction.SemilocalCompletion
+
+namespace OAI
+
+noncomputable section
+open scoped BigOperators
+
+open scoped TensorProduct nonZeroDivisors
+
+namespace BoundaryOnly.FormalObstruction.AlgebraicReplacement.AnalyticReducedness
+
+variable {R A S F KA KS : Type*}
+variable [CommRing R] [IsDomain R] [CommRing A] [CommRing S]
+variable [Algebra R A] [Algebra R S]
+variable [Field F] [Algebra R F] [IsFractionRing R F]
+variable [Field KA] [Field KS] [Algebra R KA] [Algebra R KS]
+variable [Algebra F KA] [Algebra F KS]
+variable [IsScalarTower R F KA] [IsScalarTower R F KS]
+
+omit [IsDomain R] in
+theorem reduced_tensor_of_field_embeddings [IsDomain R] [CharZero F]
+    [FiniteDimensional F KS] [Module.Flat R A]
+    (i : A →ₐ[R] KA) (hi : Function.Injective i)
+    (j : S →ₐ[R] KS) (hj : Function.Injective j) : IsReduced (A ⊗[R] S) := by
+  have : Module.Flat R F := IsLocalization.flat F R⁰
+  have : Module.Flat R KS := Module.Flat.trans R F KS
+  let f : A ⊗[R] S →ₐ[R] A ⊗[R] KS := Algebra.TensorProduct.map (AlgHom.id R A) j
+  have hf : Function.Injective f :=
+    Module.Flat.lTensor_preserves_injective_linearMap j.toLinearMap hj
+  let g : A ⊗[R] KS →ₐ[R] KA ⊗[R] KS := Algebra.TensorProduct.map i (AlgHom.id R KS)
+  have hg : Function.Injective g :=
+    Module.Flat.rTensor_preserves_injective_linearMap i.toLinearMap hi
+  let e : KA ⊗[F] KS ≃ₐ[F] KA ⊗[R] KS :=
+    IsLocalization.algebraTensorEquiv R⁰ F KA KS
+  have : Algebra.FormallyUnramified F KS := Algebra.FormallyUnramified.of_isSeparable F KS
+  have : Algebra.EssFiniteType F KS := inferInstance
+  have : IsReduced (KA ⊗[F] KS) :=
+    Algebra.FormallyUnramified.isReduced_of_field KA (KA ⊗[F] KS)
+  have : IsReduced (KA ⊗[R] KS) := isReduced_of_injective e.symm e.symm.injective
+  exact isReduced_of_injective (g.comp f) (hg.comp hf)
+
+section Domains
+attribute [local instance] FractionRing.liftAlgebra FractionRing.isScalarTower_liftAlgebra
+
+theorem reduced_flat_domain_tensor [IsDomain A] [IsDomain S] [CharZero R]
+    [FaithfulSMul R A] [FaithfulSMul R S] [Module.Finite R S] [Module.Flat R A] :
+    IsReduced (A ⊗[R] S) := by
+  apply reduced_tensor_of_field_embeddings (F := FractionRing R)
+    (IsScalarTower.toAlgHom R A (FractionRing A))
+    (IsFractionRing.injective A (FractionRing A))
+    (IsScalarTower.toAlgHom R S (FractionRing S))
+    (IsFractionRing.injective S (FractionRing S))
+
+end Domains
+end BoundaryOnly.FormalObstruction.AlgebraicReplacement.AnalyticReducedness
+
+namespace BoundaryOnly.FormalObstruction.AlgebraicReplacement.AnalyticReducedness
+open scoped TensorProduct
+universe u
+variable {R S : Type u} [CommRing R] [IsDomain R] [CharZero R]
+  [IsNoetherianRing R] [CommRing S] [IsDomain S] [Algebra R S]
+  [FaithfulSMul R S] [Module.Finite R S]
+
+theorem reduced_finite_domain_completion (p : Ideal R) [p.IsMaximal]
+    [IsDomain (AdicCompletion p R)] (q : Ideal S) [q.IsMaximal]
+    (hpq : p.map (algebraMap R S) ≤ q) : IsReduced (AdicCompletion q S) := by
+  let J := p.map (algebraMap R S)
+  have : IsNoetherianRing S := IsNoetherianRing.of_finite R S
+  have : FaithfulSMul R (AdicCompletion p R) :=
+    inferInstance
+  have : IsReduced (AdicCompletion p R ⊗[R] S) := reduced_flat_domain_tensor
+  have : IsReduced (AdicCompletion J S) :=
+    isReduced_of_injective (CompletionScalar.tensorAlgEquiv (S := S) p).symm
+      (CompletionScalar.tensorAlgEquiv (S := S) p).symm.injective
+  let : Field (R ⧸ p) := Ideal.Quotient.field p
+  have : Module.Finite (R ⧸ p) (S ⧸ J) :=
+    Module.Finite.of_restrictScalars_finite R (R ⧸ p) (S ⧸ J)
+  have : IsArtinianRing (S ⧸ J) := IsArtinianRing.of_finite (R ⧸ p) (S ⧸ J)
+  exact SemilocalCompletion.reduced_at_maximal J q hpq
+
+end BoundaryOnly.FormalObstruction.AlgebraicReplacement.AnalyticReducedness
+
+namespace BoundaryOnly.FormalObstruction.AlgebraicReplacement.AnalyticReducedness
+universe u
+variable {K S : Type u} [Field K] [CharZero K] [CommRing S] [IsDomain S]
+  [Algebra K S] [Algebra.FiniteType K S]
+
+theorem reduced_domain_point_completion (e : S →ₐ[K] K) :
+    IsReduced (AdicCompletion (RingHom.ker e.toRingHom) S) := by
+  obtain ⟨n,f,hf,hfin⟩ := exists_finite_inj_algHom_of_fg K S
+  let R := MvPolynomial (Fin n) K
+  let : Algebra R S := f.toRingHom.toAlgebra
+  have : Module.Finite R S := hfin
+  have : FaithfulSMul R S := (faithfulSMul_iff_algebraMap_injective R S).mpr hf
+  let a : Fin n → K := fun i ↦ e (f (MvPolynomial.X i))
+  let p : Ideal R := RingHom.ker (MvPolynomial.aeval a : R →ₐ[K] K).toRingHom
+  have : p.IsMaximal := RingHom.ker_isMaximal_of_surjective
+    (MvPolynomial.aeval a : R →ₐ[K] K).toRingHom
+    (fun k ↦ ⟨MvPolynomial.C k,by simp⟩)
+  have : IsDomain (AdicCompletion p R) := PolynomialPointCompletion.isDomain_completion a
+  have : (RingHom.ker e.toRingHom).IsMaximal := RingHom.ker_isMaximal_of_surjective e.toRingHom
+    (fun k ↦ ⟨algebraMap K S k,e.commutes k⟩)
+  apply reduced_finite_domain_completion p (RingHom.ker e.toRingHom)
+  rw [Ideal.map_le_iff_le_comap]
+  intro r hr
+  change e (f r) = 0
+  have he : e.comp f = MvPolynomial.aeval a := MvPolynomial.aeval_unique (e.comp f)
+  exact (AlgHom.congr_fun he r).trans hr
+
+end BoundaryOnly.FormalObstruction.AlgebraicReplacement.AnalyticReducedness
+
+namespace BoundaryOnly.FormalObstruction.AlgebraicReplacement.AnalyticReducedness
+open scoped TensorProduct
+universe u
+variable {R : Type u} [CommRing R] [IsNoetherianRing R]
+
+theorem reduced_completion_of_quotients {ι : Type u} [Fintype ι] (J : ι → Ideal R)
+    (hJ : (⨅ i,J i) = ⊥) (I : Ideal R)
+    (hred : ∀ i, IsReduced (AdicCompletion (I.map (Ideal.Quotient.mk (J i))) (R ⧸ J i))) :
+    IsReduced (AdicCompletion I R) := by
+  classical
+  let A := AdicCompletion I R
+  let Q := fun i ↦ R ⧸ J i
+  let f : R →ₐ[R] ∀ i,Q i := AlgHom.pi fun i ↦ Ideal.Quotient.mkₐ R (J i)
+  have hf : Function.Injective f := by
+    intro x y h
+    apply sub_eq_zero.mp
+    have hz : x-y ∈ (⨅ i,J i) := by
+      rw [Ideal.mem_iInf]
+      intro i
+      rw [← Ideal.Quotient.eq_zero_iff_mem,map_sub]
+      exact sub_eq_zero.mpr (congrFun h i)
+    rwa [hJ,Ideal.mem_bot] at hz
+  let g : A ⊗[R] R →ₐ[R] A ⊗[R] (∀ i,Q i) :=
+    Algebra.TensorProduct.map (AlgHom.id R A) f
+  have hg : Function.Injective g := Module.Flat.lTensor_preserves_injective_linearMap f.toLinearMap hf
+  have (i : ι) : IsReduced (A ⊗[R] Q i) := by
+    have := hred i
+    exact isReduced_of_injective (CompletionScalar.tensorAlgEquiv (S := Q i) I)
+      (CompletionScalar.tensorAlgEquiv (S := Q i) I).injective
+  let e := Algebra.TensorProduct.piRight R R A Q
+  have : IsReduced (A ⊗[R] (∀ i,Q i)) := isReduced_of_injective e e.injective
+  have : IsReduced (A ⊗[R] R) := isReduced_of_injective g hg
+  let e' := Algebra.TensorProduct.rid R R A
+  exact isReduced_of_injective e'.symm e'.symm.injective
+
+omit [IsNoetherianRing R] in
+theorem reduced_top_completion [IsNoetherianRing R] : IsReduced (AdicCompletion (⊤ : Ideal R) R) := by
+  have : Subsingleton (AdicCompletion (⊤ : Ideal R) R) :=
+    IsHausdorff.subsingleton (inferInstance : IsHausdorff (⊤ : Ideal R) _)
+  constructor
+  intro x hx
+  exact Subsingleton.elim x 0
+
+end BoundaryOnly.FormalObstruction.AlgebraicReplacement.AnalyticReducedness
+
+namespace BoundaryOnly.FormalObstruction.AlgebraicReplacement.AnalyticReducedness
+universe u
+variable {K S : Type u} [Field K] [CharZero K] [CommRing S] [IsReduced S]
+  [Algebra K S] [Algebra.FiniteType K S]
+
+theorem reduced_point_completion (e : S →ₐ[K] K) :
+    IsReduced (AdicCompletion (RingHom.ker e.toRingHom) S) := by
+  classical
+  have : IsNoetherianRing S := Algebra.FiniteType.isNoetherianRing K S
+  let ι := minimalPrimes S
+  let : Fintype ι := (minimalPrimes.finite_of_isNoetherianRing (R := S)).fintype
+  let J : ι → Ideal S := Subtype.val
+  have hJ : (⨅ i,J i) = ⊥ := by
+    rw [show (⨅ i,J i) = sInf (minimalPrimes S) from
+      le_antisymm (le_sInf fun Q hQ ↦ iInf_le (fun i : ι ↦ J i) ⟨Q,hQ⟩)
+        (le_iInf fun i ↦ sInf_le i.property)]
+    rw [Ideal.sInf_minimalPrimes]
+    exact (nilradical_eq_bot_iff).mpr inferInstance
+  let p := RingHom.ker e.toRingHom
+  have : p.IsMaximal := RingHom.ker_isMaximal_of_surjective e.toRingHom
+    (fun k ↦ ⟨algebraMap K S k,e.commutes k⟩)
+  apply reduced_completion_of_quotients J hJ p
+  intro q
+  have : (J q).IsPrime := q.property.isPrime
+  by_cases hq : J q ≤ p
+  · let e' : (S ⧸ J q) →ₐ[K] K := Ideal.Quotient.liftₐ (J q) e hq
+    have he' : p.map (Ideal.Quotient.mk (J q)) = RingHom.ker e'.toRingHom := by
+      apply Ideal.comap_injective_of_surjective (Ideal.Quotient.mk (J q)) Ideal.Quotient.mk_surjective
+      rw [Ideal.comap_map_of_surjective _ Ideal.Quotient.mk_surjective,
+        ← RingHom.ker_eq_comap_bot,Ideal.mk_ker,sup_eq_left.mpr hq,RingHom.comap_ker]
+      rfl
+    rw [he']
+    exact reduced_domain_point_completion e'
+  · have htop : p.map (Ideal.Quotient.mk (J q)) = ⊤ := by
+      apply Ideal.comap_injective_of_surjective (Ideal.Quotient.mk (J q)) Ideal.Quotient.mk_surjective
+      rw [Ideal.comap_map_of_surjective _ Ideal.Quotient.mk_surjective,
+        ← RingHom.ker_eq_comap_bot,Ideal.mk_ker,Ideal.comap_top]
+      by_contra hne
+      have he : p = p ⊔ J q := Ideal.IsMaximal.eq_of_le inferInstance hne le_sup_left
+      exact hq (he ▸ le_sup_right)
+    rw [htop]
+    exact reduced_top_completion
+
+end BoundaryOnly.FormalObstruction.AlgebraicReplacement.AnalyticReducedness
+
+namespace BoundaryOnly.FormalObstruction.AlgebraicReplacement.CompletionLocalization
+variable {R S : Type*} [CommRing R] [CommRing S] [Algebra R S]
+variable (p : Ideal R) [p.IsMaximal] [IsLocalRing S] [IsLocalization.AtPrime S p]
+
+noncomputable def level (n : ℕ) : R ⧸ p^n ≃+* S ⧸ (IsLocalRing.maximalIdeal S)^n :=
+  (IsLocalization.AtPrime.equivQuotMaximalIdealPow p S n).toRingEquiv
+
+lemma level_factor {m n : ℕ} (h : m ≤ n) (x : R ⧸ p^n) :
+    level (S := S) p m (Ideal.Quotient.factorPow p h x) =
+      Ideal.Quotient.factorPow (IsLocalRing.maximalIdeal S) h (level p n x) := by
+  induction x using Quotient.inductionOn' with
+  | _ r => rfl
+
+noncomputable def family (n : ℕ) :
+    AdicCompletion p R →+* S ⧸ (IsLocalRing.maximalIdeal S)^n :=
+  (level p n).toRingHom.comp (AdicCompletion.evalₐ p n).toRingHom
+
+lemma compatible {m n : ℕ} (h : m ≤ n) :
+    (Ideal.Quotient.factorPow (IsLocalRing.maximalIdeal S) h).comp (family p n) =
+      family p m := by
+  ext x
+  change Ideal.Quotient.factorPow _ h (level p n (AdicCompletion.evalₐ p n x)) =
+    level p m (AdicCompletion.evalₐ p m x)
+  rw [← level_factor,AdicCofinal.factor_eval]
+
+noncomputable def forward : AdicCompletion p R →+* AdicCompletion (IsLocalRing.maximalIdeal S) S :=
+  AdicCompletion.liftRingHom _ (family p) (compatible p)
+
+lemma eval_forward (n : ℕ) (x : AdicCompletion p R) :
+    AdicCompletion.evalₐ (IsLocalRing.maximalIdeal S) n (forward p x) =
+      level p n (AdicCompletion.evalₐ p n x) :=
+  AdicCompletion.evalₐ_liftRingHom _ _ (compatible p) n x
+
+noncomputable def inverseFamily (n : ℕ) :
+    AdicCompletion (IsLocalRing.maximalIdeal S) S →+* R ⧸ p^n :=
+  (level p n).symm.toRingHom.comp (AdicCompletion.evalₐ (IsLocalRing.maximalIdeal S) n).toRingHom
+
+lemma inverse_compatible {m n : ℕ} (h : m ≤ n) :
+    (Ideal.Quotient.factorPow p h).comp (inverseFamily (S := S) p n) =
+      inverseFamily p m := by
+  ext x
+  apply (level (S := S) p m).injective
+  change level p m (Ideal.Quotient.factorPow p h
+    ((level p n).symm (AdicCompletion.evalₐ _ n x))) =
+    level p m ((level p m).symm (AdicCompletion.evalₐ _ m x))
+  rw [level_factor,RingEquiv.apply_symm_apply,RingEquiv.apply_symm_apply]
+  exact AdicCofinal.factor_eval _ h x
+
+noncomputable def inverse : AdicCompletion (IsLocalRing.maximalIdeal S) S →+* AdicCompletion p R :=
+  AdicCompletion.liftRingHom p (inverseFamily p) (inverse_compatible p)
+
+lemma eval_inverse (n : ℕ) (x : AdicCompletion (IsLocalRing.maximalIdeal S) S) :
+    AdicCompletion.evalₐ p n (inverse p x) =
+      (level p n).symm (AdicCompletion.evalₐ _ n x) :=
+  AdicCompletion.evalₐ_liftRingHom _ _ (inverse_compatible p) n x
+
+noncomputable def equiv :
+    AdicCompletion p R ≃+* AdicCompletion (IsLocalRing.maximalIdeal S) S :=
+  { forward p with
+    invFun := inverse p
+    left_inv := fun x ↦ by
+      apply AdicCompletion.ext_evalₐ
+      intro n
+      change AdicCompletion.evalₐ p n (inverse p (forward p x)) = _
+      rw [eval_inverse,eval_forward,RingEquiv.symm_apply_apply]
+    right_inv := fun x ↦ by
+      apply AdicCompletion.ext_evalₐ
+      intro n
+      change AdicCompletion.evalₐ _ n (forward p (inverse p x)) = _
+      rw [eval_forward,eval_inverse,RingEquiv.apply_symm_apply] }
+
+end BoundaryOnly.FormalObstruction.AlgebraicReplacement.CompletionLocalization
+
+namespace BoundaryOnly.FormalObstruction.AlgebraicReplacement.CompletionLocalization
+variable {R S : Type*} [CommRing R] [CommRing S] [Algebra R S]
+variable (p : Ideal R) [p.IsMaximal] [IsLocalRing S] [IsLocalization.AtPrime S p]
+@[simp] lemma equiv_of (r : R) :
+    equiv (S := S) p (AdicCompletion.of p R r) =
+      AdicCompletion.of (IsLocalRing.maximalIdeal S) S (algebraMap R S r) := by
+  apply AdicCompletion.ext_evalₐ
+  intro n
+  change AdicCompletion.evalₐ _ n (forward p _) = _
+  rw [eval_forward, AdicCompletion.evalₐ_of, AdicCompletion.evalₐ_of]
+  rfl
+end BoundaryOnly.FormalObstruction.AlgebraicReplacement.CompletionLocalization
+
+namespace BoundaryOnly.FormalObstruction.AlgebraicReplacement.AnalyticReducedness
+universe u
+variable {K R : Type u} [Field K] [CharZero K] [CommRing R]
+  [Algebra K R] [Algebra.FiniteType K R]
+
+theorem radical_map_completion (e : R →ₐ[K] K) (I : Ideal R)
+    (hI : I.IsRadical) (hIp : I ≤ RingHom.ker e.toRingHom) :
+    (I.map (algebraMap R (AdicCompletion (RingHom.ker e.toRingHom) R))).IsRadical := by
+  have : IsNoetherianRing R := Algebra.FiniteType.isNoetherianRing K R
+  have : IsReduced (R ⧸ I) := (Ideal.isRadical_iff_quotient_reduced I).mp hI
+  let p := RingHom.ker e.toRingHom
+  let e' : (R ⧸ I) →ₐ[K] K := Ideal.Quotient.liftₐ I e hIp
+  have he' : p.map (Ideal.Quotient.mk I) = RingHom.ker e'.toRingHom := by
+    apply Ideal.comap_injective_of_surjective (Ideal.Quotient.mk I) Ideal.Quotient.mk_surjective
+    rw [Ideal.comap_map_of_surjective _ Ideal.Quotient.mk_surjective,
+      ← RingHom.ker_eq_comap_bot,Ideal.mk_ker,sup_eq_left.mpr hIp,RingHom.comap_ker]
+    rfl
+  have : IsReduced (AdicCompletion (p.map (Ideal.Quotient.mk I)) (R ⧸ I)) := by
+    rw [he']
+    exact reduced_point_completion e'
+  have : IsReduced (TensorProduct R (AdicCompletion p R) (R ⧸ I)) :=
+    isReduced_of_injective (CompletionScalar.tensorAlgEquiv (S := R ⧸ I) p)
+      (CompletionScalar.tensorAlgEquiv (S := R ⧸ I) p).injective
+  let q := Algebra.TensorProduct.quotIdealMapEquivTensorQuot (AdicCompletion p R) I
+  exact (Ideal.isRadical_iff_quotient_reduced _).mpr (isReduced_of_injective q q.injective)
+
+instance rationalPointPrime (e : R →ₐ[K] K) : (RingHom.ker e.toRingHom).IsPrime :=
+  RingHom.ker_isPrime _
+
+lemma radical_local_completion_transfer (e : R →ₐ[K] K)
+    (A : Type u) [CommRing A] [Algebra R A] [IsLocalRing A]
+    [IsLocalization.AtPrime A (RingHom.ker e.toRingHom)]
+    (I : Ideal A) (hI : I.IsRadical) (hIne : I ≠ ⊤)
+    (q : AdicCompletion (RingHom.ker e.toRingHom) R ≃+*
+      AdicCompletion (IsLocalRing.maximalIdeal A) A)
+    (hq : q.toRingHom.comp (algebraMap R (AdicCompletion (RingHom.ker e.toRingHom) R)) =
+      (algebraMap A (AdicCompletion (IsLocalRing.maximalIdeal A) A)).comp (algebraMap R A)) :
+    (I.map (algebraMap A (AdicCompletion (IsLocalRing.maximalIdeal A) A))).IsRadical := by
+  let p := RingHom.ker e.toRingHom
+  let J := I.comap (algebraMap R A)
+  have hJ : J.IsRadical := hI.comap _
+  have hJp : J ≤ p := by
+    rw [← IsLocalization.AtPrime.under_maximalIdeal A p]
+    exact Ideal.comap_mono (IsLocalRing.le_maximalIdeal hIne)
+  have hJmap : J.map (algebraMap R A) = I := IsLocalization.map_under p.primeCompl A I
+  have heq : (J.map (algebraMap R (AdicCompletion p R))).map q.toRingHom =
+      I.map (algebraMap A (AdicCompletion (IsLocalRing.maximalIdeal A) A)) := by
+    rw [Ideal.map_map,hq,← Ideal.map_map,hJmap]
+  rw [← heq]
+  have he := Ideal.map_comap_of_equiv (I := J.map (algebraMap R (AdicCompletion p R))) q
+  change (J.map (algebraMap R (AdicCompletion p R))).map q.toRingHom = _ at he
+  rw [he]
+  exact (radical_map_completion e J hJ hJp).comap _
+
+theorem radical_local_completion (e : R →ₐ[K] K)
+    (A : Type u) [CommRing A] [Algebra R A] [IsLocalRing A]
+    [IsLocalization.AtPrime A (RingHom.ker e.toRingHom)]
+    (I : Ideal A) (hI : I.IsRadical) (hIne : I ≠ ⊤) :
+    (I.map (algebraMap A (AdicCompletion (IsLocalRing.maximalIdeal A) A))).IsRadical := by
+  let p := RingHom.ker e.toRingHom
+  have : p.IsMaximal := RingHom.ker_isMaximal_of_surjective e.toRingHom
+    (fun k ↦ ⟨algebraMap K R k,e.commutes k⟩)
+  apply radical_local_completion_transfer e A I hI hIne (CompletionLocalization.equiv (S := A) p)
+  apply RingHom.ext
+  intro r
+  exact CompletionLocalization.equiv_of (S := A) p r
+end BoundaryOnly.FormalObstruction.AlgebraicReplacement.AnalyticReducedness
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/AlgebraicObstruction/ArcDetection.lean b/lean/OAI/Algebra/AlgebraicObstruction/ArcDetection.lean
new file mode 100644
index 0000000000000000000000000000000000000000..04744d23cdfd535ae128ab80c62045dddc7407a1
--- /dev/null
+++ b/lean/OAI/Algebra/AlgebraicObstruction/ArcDetection.lean
@@ -0,0 +1,374 @@
+import Mathlib
+import OAI.Algebra.FrobeniusObstruction.Obstruction
+import OAI.Algebra.AlgebraicObstruction.FormalArcs
+
+namespace OAI
+
+noncomputable section
+open scoped BigOperators
+
+namespace BoundaryOnly.FormalObstruction.AlgebraicReplacement.FormalArc
+open IsLocalRing
+open scoped nonZeroDivisors
+
+private theorem radical_eq_maximal_of_minimal {S : Type*} [CommRing S]
+    [IsLocalRing S] (I : Ideal S)
+    (h : maximalIdeal S ∈ I.minimalPrimes) : I.radical = maximalIdeal S := by
+  apply le_antisymm
+  · exact (Ideal.IsPrime.radical_le_iff (inferInstance : (maximalIdeal S).IsPrime)).mpr h.1.2
+  · rw [← Ideal.sInf_minimalPrimes]
+    apply le_sInf
+    intro p hp
+    exact h.2 hp.1 (le_maximalIdeal hp.1.1.ne_top)
+
+variable {S : Type*} [CommRing S] [IsDomain S] [IsLocalRing S] [IsNoetherianRing S]
+
+theorem exists_primary_curve_quotient (b : S) (hb : b ≠ 0)
+    (hbm : b ∈ maximalIdeal S) :
+    ∃ p : Ideal S, p.IsPrime ∧ b ∉ p ∧
+      (Ideal.span {b} ⊔ p).radical = maximalIdeal S := by
+  classical
+  let B : Ideal S := Ideal.span {b}
+  have hB : B ≤ maximalIdeal S := (Ideal.span_singleton_le_iff_mem _).mpr hbm
+  have hBne : B ≠ ⊤ := ne_top_of_le_ne_top (maximalIdeal.isMaximal S).ne_top hB
+  let Q := S ⧸ B
+  have : Nontrivial Q := Ideal.Quotient.nontrivial_iff.mpr hBne
+  let q : S →+* Q := Ideal.Quotient.mk B
+  have hsurj : Function.Surjective q := Ideal.Quotient.mk_surjective
+  have : IsLocalRing Q := IsLocalRing.of_surjective' q hsurj
+  have : IsLocalHom q := IsLocalHom.of_surjective q hsurj
+  obtain ⟨s,hs,hcard⟩ :=
+    Ideal.exists_finset_card_eq_height_of_isNoetherianRing (maximalIdeal Q)
+  have hrad : (Ideal.span (s : Set Q)).radical = maximalIdeal Q :=
+    radical_eq_maximal_of_minimal _ hs
+  let lift : Q → S := Function.surjInv hsurj
+  have hlift (x : Q) : q (lift x) = x := Function.surjInv_eq hsurj x
+  let t : Finset S := s.image lift
+  let J : Ideal S := Ideal.span (t : Set S)
+  have hmap : J.map q = Ideal.span (s : Set Q) := by
+    rw [Ideal.map_span]
+    congr 1
+    ext x
+    simp only [t,Finset.coe_image,Set.mem_image]
+    constructor
+    · rintro ⟨y,⟨z,hz,rfl⟩,rfl⟩
+      simpa only [hlift] using hz
+    · intro hx
+      exact ⟨lift x,⟨x,hx,rfl⟩,hlift x⟩
+  have hJB : (J ⊔ B).radical = maximalIdeal S := by
+    have heq := congrArg (Ideal.comap q) hrad
+    rw [← hmap,Ideal.comap_radical,Ideal.comap_map_of_surjective q hsurj] at heq
+    have hker : RingHom.ker q = B := Ideal.mk_ker
+    rw [RingHom.ker_eq_comap_bot] at hker
+    rw [hker,maximalIdeal_comap q] at heq
+    exact heq
+  have hJm : J ≤ maximalIdeal S :=
+    (le_sup_left : J ≤ J ⊔ B).trans (Ideal.le_radical.trans hJB.le)
+  obtain ⟨p,hp,hpm⟩ := Ideal.exists_minimalPrimes_le hJm
+  have : p.IsPrime := hp.1.1
+  have hheight : p.height < (maximalIdeal S).height := by
+    have hd := ringKrullDim_quotient_succ_le_of_nonZeroDivisor
+      ((mem_nonZeroDivisors_iff_ne_zero).mpr hb)
+    rw [← maximalIdeal_height_eq_ringKrullDim (R := Q),
+      ← maximalIdeal_height_eq_ringKrullDim (R := S)] at hd
+    have hd' : (maximalIdeal Q).height + 1 ≤ (maximalIdeal S).height := by
+      exact_mod_cast hd
+    have hc : (s.card : ℕ∞) + 1 ≤ (maximalIdeal S).height := by rwa [hcard]
+    have hcs : (s.card : ℕ∞) < (s.card : ℕ∞) + 1 := by
+      exact_mod_cast Nat.lt_succ_self s.card
+    exact lt_of_le_of_lt (Ideal.height_le_card_of_mem_minimalPrimes_span_finset hp)
+      (lt_of_le_of_lt (by exact_mod_cast Finset.card_image_le (s := s) (f := lift))
+        (hcs.trans_le hc))
+  have hbp : b ∉ p := by
+    intro h
+    have hBp : B ≤ p := (Ideal.span_singleton_le_iff_mem _).mpr h
+    have hmp : maximalIdeal S ≤ p := by
+      rw [← hJB]
+      exact (Ideal.IsPrime.radical_le_iff (inferInstance : p.IsPrime)).mpr
+        (sup_le hp.1.2 hBp)
+    have heq := le_antisymm hpm hmp
+    exact (ne_of_lt hheight) (congrArg Ideal.height heq)
+  refine ⟨p,inferInstance,hbp,?_⟩
+  apply le_antisymm
+  · exact (Ideal.IsPrime.radical_le_iff (inferInstance : (maximalIdeal S).IsPrime)).mpr (sup_le hB hpm)
+  · rw [← hJB]
+    exact Ideal.radical_mono (sup_le (hp.1.2.trans le_sup_right) le_sup_left)
+
+end BoundaryOnly.FormalObstruction.AlgebraicReplacement.FormalArc
+
+namespace BoundaryOnly.FormalObstruction.AlgebraicReplacement.FormalArc
+open IsLocalRing
+
+private instance quotient_localRing {R : Type*} [CommRing R] [IsLocalRing R]
+    (J : Ideal R) [Nontrivial (R ⧸ J)] : IsLocalRing (R ⧸ J) :=
+  IsLocalRing.of_surjective' (Ideal.Quotient.mk J) Ideal.Quotient.mk_surjective
+
+variable {S : Type*} [CommRing S] [IsLocalRing S] [IsNoetherianRing S]
+  [IsAdicComplete (maximalIdeal S) S]
+
+theorem local_quotient_complete (J : Ideal S) [Nontrivial (S ⧸ J)] :
+    IsAdicComplete (maximalIdeal (S ⧸ J)) (S ⧸ J) := by
+  let m := maximalIdeal S
+  let Q := S ⧸ J
+  let f : S →ₗ[S] Q := J.mkQ
+  have hf : Function.Surjective f := J.mkQ_surjective
+  have : IsPrecomplete m Q := by
+    apply (AdicCompletion.of_surjective_iff (I := m) (M := Q)).mp
+    intro z
+    obtain ⟨x,hx⟩ := AdicCompletion.map_surjective_of_mkQ_comp_surjective
+      (I := m) (f := f) ((Submodule.mkQ_surjective (m • ⊤)).comp hf) z
+    obtain ⟨y,hy⟩ := AdicCompletion.of_surjective m S x
+    refine ⟨f y,?_⟩
+    rw [← AdicCompletion.map_of,hy,hx]
+  have : IsAdicComplete m Q := { }
+  have hm : m.map (algebraMap S Q) = maximalIdeal Q :=
+    map_maximalIdeal_of_surjective (Ideal.Quotient.mk J) Ideal.Quotient.mk_surjective
+  rw [← hm]
+  exact (IsAdicComplete.map_algebraMap_iff m Q).mpr inferInstance
+
+omit [IsNoetherianRing S] [IsAdicComplete (maximalIdeal S) S] in
+
+theorem quotient_residue_surjective {K : Type*} [Field K] [Algebra K S]
+    (J : Ideal S) [Nontrivial (S ⧸ J)]
+    (hres : Function.Surjective
+      ((Ideal.Quotient.mk (maximalIdeal S)).comp (algebraMap K S))) :
+    Function.Surjective
+      ((Ideal.Quotient.mk (maximalIdeal (S ⧸ J))).comp (algebraMap K (S ⧸ J))) := by
+  let Q := S ⧸ J
+  let q : S →+* Q := Ideal.Quotient.mk J
+  have : IsLocalHom q := IsLocalHom.of_surjective q Ideal.Quotient.mk_surjective
+  intro z
+  obtain ⟨y,hy⟩ := Ideal.Quotient.mk_surjective z
+  obtain ⟨x,hx⟩ := Ideal.Quotient.mk_surjective y
+  obtain ⟨c,hc⟩ := hres (residue S x)
+  refine ⟨c,?_⟩
+  have hc' := congrArg (ResidueField.map q) hc
+  change ResidueField.map q (residue S (algebraMap K S c)) =
+    ResidueField.map q (residue S x) at hc'
+  rw [ResidueField.map_residue,ResidueField.map_residue] at hc'
+  change residue Q (algebraMap K Q c) = z
+  change q x = y at hx
+  change residue Q y = z at hy
+  rw [hx,hy] at hc'
+  exact hc'
+
+end BoundaryOnly.FormalObstruction.AlgebraicReplacement.FormalArc
+
+namespace BoundaryOnly.FormalObstruction.AlgebraicReplacement.FormalArc
+open IsLocalRing
+variable {K S : Type*} [Field K] [IsAlgClosed K] [CharZero K]
+  [CommRing S] [IsLocalRing S] [IsNoetherianRing S]
+  [Algebra K S] [IsAdicComplete (maximalIdeal S) S]
+
+theorem domain_detecting_arc [IsDomain S] (b : S) (hb : b ≠ 0)
+    (hbm : b ∈ maximalIdeal S)
+    (hres : Function.Surjective
+      ((Ideal.Quotient.mk (maximalIdeal S)).comp (algebraMap K S))) :
+    ∃ f : S →ₐ[K] PowerSeries K, IsLocalHom f.toRingHom ∧ f b ≠ 0 := by
+  obtain ⟨p,hp,hbp,hprimary⟩ := exists_primary_curve_quotient b hb hbm
+  have : Ideal.IsPrime p := hp
+  let Q := S ⧸ p
+  let q : S →ₐ[K] Q := Ideal.Quotient.mkₐ K p
+  have hsurj : Function.Surjective q := Ideal.Quotient.mk_surjective
+  have : IsLocalHom q.toRingHom := IsLocalHom.of_surjective _ hsurj
+  have : IsAdicComplete (maximalIdeal Q) Q := local_quotient_complete p
+  have hqb : q b ≠ 0 := fun h ↦ hbp (Ideal.Quotient.eq_zero_iff_mem.mp h)
+  have hprimaryQ : (Ideal.span {q b}).radical = maximalIdeal Q := by
+    have h := congrArg (Ideal.map q.toRingHom) hprimary
+    have hker : RingHom.ker q.toRingHom ≤ Ideal.span {b} ⊔ p := by
+      change RingHom.ker (Ideal.Quotient.mk p) ≤ _
+      rw [Ideal.mk_ker]
+      exact le_sup_right
+    rw [Ideal.map_radical_of_surjective hsurj hker,Ideal.map_sup,
+      Ideal.map_span,Set.image_singleton] at h
+    have hpmap : p.map q.toRingHom = ⊥ := Ideal.map_quotient_self p
+    rw [hpmap,sup_bot_eq,
+      map_maximalIdeal_of_surjective q.toRingHom hsurj] at h
+    exact h
+  obtain ⟨g,hginj,hglocal⟩ := primary_parameter_arc (q b) hqb hprimaryQ
+    (quotient_residue_surjective p hres)
+  have : IsLocalHom g.toRingHom := hglocal
+  refine ⟨g.comp q,?_,?_⟩
+  · change IsLocalHom (g.toRingHom.comp q.toRingHom)
+    infer_instance
+  · change g (q b) ≠ 0
+    exact fun h ↦ hqb (hginj (h.trans (map_zero g).symm))
+
+theorem reduced_detecting_arc [IsReduced S] (b : S) (hb : b ≠ 0)
+    (hbm : b ∈ maximalIdeal S)
+    (hres : Function.Surjective
+      ((Ideal.Quotient.mk (maximalIdeal S)).comp (algebraMap K S))) :
+    ∃ f : S →ₐ[K] PowerSeries K, IsLocalHom f.toRingHom ∧ f b ≠ 0 := by
+  have hnil : b ∉ nilradical S := by
+    intro h
+    exact hb (IsReduced.eq_zero b (mem_nilradical.mp h))
+  rw [nilradical_eq_sInf,Submodule.mem_sInf] at hnil
+  push Not at hnil
+  obtain ⟨p,hp,hbp⟩ := hnil
+  have : Ideal.IsPrime p := hp
+  let Q := S ⧸ p
+  let q : S →ₐ[K] Q := Ideal.Quotient.mkₐ K p
+  have hsurj : Function.Surjective q := Ideal.Quotient.mk_surjective
+  have : IsLocalHom q.toRingHom := IsLocalHom.of_surjective _ hsurj
+  have : IsAdicComplete (maximalIdeal Q) Q := local_quotient_complete p
+  have hqb : q b ≠ 0 := fun h ↦ hbp (Ideal.Quotient.eq_zero_iff_mem.mp h)
+  have hqbm : q b ∈ maximalIdeal Q := map_nonunit q.toRingHom b hbm
+  obtain ⟨g,hglocal,hgb⟩ := domain_detecting_arc (q b) hqb hqbm
+    (quotient_residue_surjective p hres)
+  have : IsLocalHom g.toRingHom := hglocal
+  refine ⟨g.comp q,?_,hgb⟩
+  change IsLocalHom (g.toRingHom.comp q.toRingHom)
+  infer_instance
+
+end BoundaryOnly.FormalObstruction.AlgebraicReplacement.FormalArc
+
+namespace BoundaryOnly.FormalObstruction.AlgebraicReplacement.FormalArc
+open IsLocalRing
+variable {K S : Type*} [Field K] [IsAlgClosed K] [CharZero K]
+  [CommRing S] [IsLocalRing S] [IsNoetherianRing S] [IsReduced S]
+  [Algebra K S] [IsAdicComplete (maximalIdeal S) S]
+
+theorem reduced_detecting_continuous_arc (b : S) (hb : b ≠ 0)
+    (hbm : b ∈ maximalIdeal S)
+    (hres : Function.Surjective
+      ((Ideal.Quotient.mk (maximalIdeal S)).comp (algebraMap K S))) :
+    letI : WithIdeal S := ⟨maximalIdeal S⟩
+    letI : WithIdeal (PowerSeries K) := ⟨maximalIdeal (PowerSeries K)⟩
+    ∃ f : S →ₐ[K] PowerSeries K, IsLocalHom f.toRingHom ∧
+      Continuous f ∧ f b ≠ 0 := by
+  let : WithIdeal S := ⟨maximalIdeal S⟩
+  let : WithIdeal (PowerSeries K) := ⟨maximalIdeal (PowerSeries K)⟩
+  obtain ⟨f,hf,hfb⟩ := reduced_detecting_arc b hb hbm hres
+  have : IsLocalHom f.toRingHom := hf
+  refine ⟨f,hf,?_,hfb⟩
+  exact (WithIdeal.uniformContinuous_of_map_le (f := f.toRingHom)
+    (map_maximalIdeal_le f.toRingHom)).continuous
+end BoundaryOnly.FormalObstruction.AlgebraicReplacement.FormalArc
+
+namespace BoundaryOnly.FormalObstruction.AlgebraicReplacement.FormalArc
+open MvPowerSeries IsLocalRing
+variable {σ K : Type*} [Finite σ] [Field K]
+
+lemma polynomial_approximate (f : MvPowerSeries σ K) (n : ℕ) :
+    ∃ p : MvPolynomial σ K, f - (p : MvPowerSeries σ K) ∈
+      (Ideal.span (Set.range (X : σ → MvPowerSeries σ K))) ^ n := by
+  let J := MvPolynomial.idealOfVars σ K
+  let e := toAdicCompletionAlgEquiv σ K
+  have hmap : Ideal.map e.toRingHom (Ideal.span (Set.range X)) =
+      J.map (algebraMap (MvPolynomial σ K) (AdicCompletion J (MvPolynomial σ K))) := by
+    change Ideal.map e.toRingHom (Ideal.span (Set.range X)) =
+      (MvPolynomial.idealOfVars σ K).map _
+    simp_rw [MvPolynomial.idealOfVars,Ideal.map_span, ← Set.range_comp]
+    congr 2; ext1
+    simp [e,J,AdicCompletion.algebraMap_apply, ← MvPolynomial.coe_X, toAdicCompletion_coe]
+  obtain ⟨p,hp⟩ := Submodule.Quotient.mk_surjective (J^n • (⊤ : Ideal (MvPolynomial σ K)))
+    ((e f).val n)
+  refine ⟨p,?_⟩
+  have he : e (f - (p : MvPowerSeries σ K)) ∈
+      (Ideal.span (Set.range X) ^ n).map e.toRingHom := by
+    rw [Ideal.map_pow,hmap,← Ideal.map_pow,← Submodule.restrictScalars_mem (MvPolynomial σ K),
+      ← Ideal.smul_top_eq_map,AdicCompletion.pow_smul_top_eq_ker_eval J.fg_of_isNoetherianRing]
+    change AdicCompletion.eval J (MvPolynomial σ K) n (e (f - (p : MvPowerSeries σ K))) = 0
+    rw [map_sub]
+    have hecoe : e (p : MvPowerSeries σ K) = AdicCompletion.of J (MvPolynomial σ K) p :=
+      toAdicCompletion_coe p
+    rw [hecoe]
+    rw [map_sub,AdicCompletion.eval_of]
+    exact sub_eq_zero.mpr hp.symm
+  obtain ⟨z,hz,hze⟩ := (Ideal.mem_map_iff_of_surjective e.toRingHom e.surjective).mp he
+  exact e.injective hze ▸ hz
+
+lemma span_variables_eq_constant_kernel :
+    Ideal.span (Set.range (X : σ → MvPowerSeries σ K)) =
+      RingHom.ker (constantCoeff (σ := σ) (R := K)) := by
+  have hle : Ideal.span (Set.range (X : σ → MvPowerSeries σ K)) ≤
+      RingHom.ker (constantCoeff (σ := σ) (R := K)) := by
+    rw [Ideal.span_le]
+    rintro _ ⟨i,rfl⟩
+    simp
+  apply le_antisymm hle
+  intro f hf
+  obtain ⟨p,hp⟩ := polynomial_approximate f 1
+  rw [pow_one] at hp
+  have hpc : MvPolynomial.constantCoeff p = 0 := by
+    have hh := hle hp
+    change constantCoeff (f - (p : MvPowerSeries σ K)) = 0 at hh
+    change constantCoeff f = 0 at hf
+    rw [map_sub,hf,zero_sub,neg_eq_zero] at hh
+    exact hh
+  have hpvar : p ∈ MvPolynomial.idealOfVars σ K := by
+    rw [← pow_one (MvPolynomial.idealOfVars σ K),MvPolynomial.mem_pow_idealOfVars_iff']
+    intro d hd
+    have hd0 : d = 0 := (Finsupp.degree_eq_zero_iff d).mp (by omega)
+    subst d
+    exact hpc
+  have hpcoe : (p : MvPowerSeries σ K) ∈ Ideal.span (Set.range X) := by
+    have hh := Ideal.mem_map_of_mem (MvPolynomial.coeToMvPowerSeries.ringHom :
+      MvPolynomial σ K →+* MvPowerSeries σ K) hpvar
+    have hm : Ideal.map (MvPolynomial.coeToMvPowerSeries.ringHom :
+        MvPolynomial σ K →+* MvPowerSeries σ K) (MvPolynomial.idealOfVars σ K) =
+        Ideal.span (Set.range X) := by
+      rw [MvPolynomial.idealOfVars,Ideal.map_span,← Set.range_comp]
+      simp only [Function.comp_def,MvPolynomial.coeToMvPowerSeries.ringHom_apply,MvPolynomial.coe_X]
+    rw [hm] at hh
+    exact hh
+  simpa only [sub_add_cancel] using Ideal.add_mem _ hp hpcoe
+
+lemma maximalIdeal_eq_variables :
+    maximalIdeal (MvPowerSeries σ K) = Ideal.span (Set.range X) := by
+  rw [span_variables_eq_constant_kernel]
+  ext f
+  change ¬IsUnit f ↔ constantCoeff f = 0
+  rw [MvPowerSeries.isUnit_iff_constantCoeff]
+  simp only [isUnit_iff_ne_zero,not_not]
+
+instance complete_mps_maximal :
+    IsAdicComplete (maximalIdeal (MvPowerSeries σ K)) (MvPowerSeries σ K) := by
+  rw [maximalIdeal_eq_variables]
+  infer_instance
+
+lemma residue_mps_surjective : Function.Surjective
+    ((Ideal.Quotient.mk (maximalIdeal (MvPowerSeries σ K))).comp
+      (algebraMap K (MvPowerSeries σ K))) := by
+  intro z
+  obtain ⟨f,rfl⟩ := Ideal.Quotient.mk_surjective z
+  refine ⟨constantCoeff f,?_⟩
+  change Ideal.Quotient.mk _ (C (constantCoeff f)) = Ideal.Quotient.mk _ f
+  rw [Ideal.Quotient.eq,maximalIdeal_eq_variables,span_variables_eq_constant_kernel]
+  simp
+
+theorem local_mps_hom_ext {T : Type*} [CommRing T] [IsLocalRing T]
+    [Algebra K T] [IsHausdorff (maximalIdeal T) T]
+    (f g : MvPowerSeries σ K →ₐ[K] T)
+    [IsLocalHom f.toRingHom] [IsLocalHom g.toRingHom]
+    (hX : ∀ i, f (X i) = g (X i)) : f = g := by
+  have hpoly : f.comp (MvPolynomial.coeToMvPowerSeries.algHom K) =
+      g.comp (MvPolynomial.coeToMvPowerSeries.algHom K) := by
+    apply MvPolynomial.algHom_ext
+    intro i
+    simpa using hX i
+  apply AlgHom.ext
+  intro x
+  rw [IsHausdorff.eq_iff_smodEq (I := maximalIdeal T)]
+  intro n
+  obtain ⟨p,hp⟩ := polynomial_approximate x n
+  rw [← maximalIdeal_eq_variables] at hp
+  have hf := Ideal.mem_map_of_mem f.toRingHom hp
+  have hg := Ideal.mem_map_of_mem g.toRingHom hp
+  rw [Ideal.map_pow] at hf hg
+  have hf' := (pow_le_pow_left' (map_maximalIdeal_le f.toRingHom) n) hf
+  have hg' := (pow_le_pow_left' (map_maximalIdeal_le g.toRingHom) n) hg
+  have hph : f (p : MvPowerSeries σ K) = g (p : MvPowerSeries σ K) :=
+    by simpa using AlgHom.congr_fun hpoly p
+  rw [SModEq.sub_mem,smul_eq_mul,Ideal.mul_top]
+  have hh := Ideal.sub_mem _ hf' hg'
+  simp only [map_sub] at hh
+  change (f x - f (p : MvPowerSeries σ K)) -
+    (g x - g (p : MvPowerSeries σ K)) ∈ maximalIdeal T ^ n at hh
+  simpa only [hph,sub_sub_sub_cancel_right] using hh
+
+end BoundaryOnly.FormalObstruction.AlgebraicReplacement.FormalArc
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/AlgebraicObstruction/ChartCompletion.lean b/lean/OAI/Algebra/AlgebraicObstruction/ChartCompletion.lean
new file mode 100644
index 0000000000000000000000000000000000000000..e7fcbb8d8c9b973f679ad8324366a80bf724aac2
--- /dev/null
+++ b/lean/OAI/Algebra/AlgebraicObstruction/ChartCompletion.lean
@@ -0,0 +1,136 @@
+import Mathlib
+import OAI.Algebra.FrobeniusObstruction.Obstruction
+import OAI.Algebra.AlgebraicObstruction.ChartTruncation
+import OAI.Algebra.AlgebraicObstruction.AdicFunctor
+
+namespace OAI
+
+noncomputable section
+open scoped BigOperators
+
+namespace BoundaryOnly.FormalObstruction.FormalCorrection.AffineEtaleChart
+open MvPowerSeries
+open BoundaryOnly.FormalObstruction.AlgebraicReplacement
+variable {K α : Type} [Field K] [Finite α]
+
+lemma truncatedEquiv_compatible (E : AffineEtaleChart K α) {m n : ℕ} (h : m ≤ n)
+    (x : E.LocalRing ⧸ (IsLocalRing.maximalIdeal E.LocalRing)^n) :
+    Ideal.Quotient.factorPow (MvPolynomial.idealOfVars α K) h (E.truncatedEquiv n x) =
+      E.truncatedEquiv m (Ideal.Quotient.factorPow (IsLocalRing.maximalIdeal E.LocalRing) h x) := by
+  obtain ⟨a,rfl⟩ := Ideal.Quotient.mk_surjective x
+  change Ideal.Quotient.mk (MvPolynomial.idealOfVars α K ^ m)
+      (truncTotal n (E.localExpansion a)) =
+    Ideal.Quotient.mk (MvPolynomial.idealOfVars α K ^ m)
+      (truncTotal m (E.localExpansion a))
+  rw [Ideal.Quotient.eq]
+  exact truncTotal_sub_truncTotal_mem_pow_idealOfVars h le_rfl _
+
+def completionFamily (E : AffineEtaleChart K α) (n : ℕ) :
+    AdicCompletion (IsLocalRing.maximalIdeal E.LocalRing) E.LocalRing →+*
+      FormalTruncation (K := K) (α := α) n :=
+  (E.truncatedEquiv n).toRingHom.comp
+    (AdicCompletion.evalₐ (IsLocalRing.maximalIdeal E.LocalRing) n).toRingHom
+
+lemma completionFamily_compatible (E : AffineEtaleChart K α) {m n : ℕ} (h : m ≤ n) :
+    (Ideal.Quotient.factorPow (MvPolynomial.idealOfVars α K) h).comp (E.completionFamily n) =
+      E.completionFamily m := by
+  apply RingHom.ext
+  intro x
+  change Ideal.Quotient.factorPow _ h (E.truncatedEquiv n (AdicCompletion.evalₐ _ n x)) = _
+  rw [E.truncatedEquiv_compatible h,AdicCofinal.factor_eval]
+  rfl
+
+noncomputable def completionToPolynomial (E : AffineEtaleChart K α) :
+    AdicCompletion (IsLocalRing.maximalIdeal E.LocalRing) E.LocalRing →+*
+      AdicCompletion (MvPolynomial.idealOfVars α K) (MvPolynomial α K) :=
+  AdicCompletion.liftRingHom _ E.completionFamily E.completionFamily_compatible
+
+@[simp] lemma eval_completionToPolynomial (E : AffineEtaleChart K α) (n : ℕ)
+    (x : AdicCompletion (IsLocalRing.maximalIdeal E.LocalRing) E.LocalRing) :
+    AdicCompletion.evalₐ _ n (E.completionToPolynomial x) =
+      E.truncatedEquiv n (AdicCompletion.evalₐ _ n x) :=
+  AdicCompletion.evalₐ_liftRingHom _ E.completionFamily E.completionFamily_compatible n x
+
+omit [Finite α] in
+lemma variables_le_comap_maximal (E : AffineEtaleChart K α) :
+    MvPolynomial.idealOfVars α K ≤ (IsLocalRing.maximalIdeal E.LocalRing).comap
+      (algebraMap (MvPolynomial α K) E.LocalRing) := by
+  rw [E.maximalIdeal_eq_map_variables]
+  exact Ideal.le_comap_map
+
+noncomputable def polynomialToCompletion (E : AffineEtaleChart K α) :
+    AdicCompletion (MvPolynomial.idealOfVars α K) (MvPolynomial α K) →+*
+      AdicCompletion (IsLocalRing.maximalIdeal E.LocalRing) E.LocalRing :=
+  AdicFunctor.map _ _ (algebraMap (MvPolynomial α K) E.LocalRing) E.variables_le_comap_maximal
+
+omit [Finite α] in
+lemma quotient_polynomial (E : AffineEtaleChart K α) (n : ℕ)
+    (x : FormalTruncation (K := K) (α := α) n) :
+    AdicFunctor.quotient _ _ (algebraMap (MvPolynomial α K) E.LocalRing)
+      E.variables_le_comap_maximal n x = E.polynomialQuotient n x := by
+  obtain ⟨p,rfl⟩ := Ideal.Quotient.mk_surjective x
+  rfl
+
+omit [Finite α] in
+@[simp] lemma eval_polynomialToCompletion (E : AffineEtaleChart K α) (n : ℕ)
+    (x : AdicCompletion (MvPolynomial.idealOfVars α K) (MvPolynomial α K)) :
+    AdicCompletion.evalₐ _ n (E.polynomialToCompletion x) =
+      E.polynomialQuotient n (AdicCompletion.evalₐ _ n x) := by
+  rw [polynomialToCompletion,AdicFunctor.eval_map,quotient_polynomial]
+
+lemma completionToPolynomial_polynomialToCompletion (E : AffineEtaleChart K α)
+    (x : AdicCompletion (MvPolynomial.idealOfVars α K) (MvPolynomial α K)) :
+    E.completionToPolynomial (E.polynomialToCompletion x) = x := by
+  apply AdicCompletion.ext_evalₐ
+  intro n
+  rw [eval_completionToPolynomial,eval_polynomialToCompletion]
+  exact (E.truncatedEquiv n).apply_symm_apply _
+
+lemma polynomialToCompletion_completionToPolynomial (E : AffineEtaleChart K α)
+    (x : AdicCompletion (IsLocalRing.maximalIdeal E.LocalRing) E.LocalRing) :
+    E.polynomialToCompletion (E.completionToPolynomial x) = x := by
+  apply AdicCompletion.ext_evalₐ
+  intro n
+  rw [eval_polynomialToCompletion,eval_completionToPolynomial]
+  exact (E.truncatedEquiv n).symm_apply_apply _
+
+noncomputable def polynomialCompletionEquiv (E : AffineEtaleChart K α) :
+    AdicCompletion (IsLocalRing.maximalIdeal E.LocalRing) E.LocalRing ≃+*
+      AdicCompletion (MvPolynomial.idealOfVars α K) (MvPolynomial α K) :=
+  { E.completionToPolynomial with
+    invFun := E.polynomialToCompletion
+    left_inv := E.polynomialToCompletion_completionToPolynomial
+    right_inv := E.completionToPolynomial_polynomialToCompletion }
+
+noncomputable def completionEquiv (E : AffineEtaleChart K α) :
+    AdicCompletion (IsLocalRing.maximalIdeal E.LocalRing) E.LocalRing ≃+*
+      MvPowerSeries α K :=
+  E.polynomialCompletionEquiv.trans (MvPowerSeries.toAdicCompletionAlgEquiv α K).symm.toRingEquiv
+
+@[simp] theorem completionEquiv_of (E : AffineEtaleChart K α) (a : E.LocalRing) :
+    E.completionEquiv (AdicCompletion.of _ _ a) = E.localExpansion a := by
+  apply (MvPowerSeries.toAdicCompletionAlgEquiv α K).injective
+  change (MvPowerSeries.toAdicCompletionAlgEquiv α K)
+    ((MvPowerSeries.toAdicCompletionAlgEquiv α K).symm
+      (E.completionToPolynomial (AdicCompletion.of _ _ a))) = _
+  rw [AlgEquiv.apply_symm_apply]
+  apply AdicCompletion.ext_evalₐ
+  intro n
+  rw [eval_completionToPolynomial,AdicCompletion.evalₐ_of,truncatedEquiv_mk]
+  rfl
+
+noncomputable def completionAlgEquiv (E : AffineEtaleChart K α) :
+    AdicCompletion (IsLocalRing.maximalIdeal E.LocalRing) E.LocalRing ≃ₐ[E.LocalRing]
+      MvPowerSeries α K :=
+  { E.completionEquiv with commutes' := E.completionEquiv_of }
+
+instance localNoetherian (E : AffineEtaleChart K α) : IsNoetherianRing E.LocalRing := by
+  have : IsNoetherianRing E.S :=
+    Algebra.FiniteType.isNoetherianRing (MvPolynomial α K) E.S
+  infer_instance
+
+end BoundaryOnly.FormalObstruction.FormalCorrection.AffineEtaleChart
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/AlgebraicObstruction/ChartTruncation.lean b/lean/OAI/Algebra/AlgebraicObstruction/ChartTruncation.lean
new file mode 100644
index 0000000000000000000000000000000000000000..51944bcc7c5a1924593bafa557d7104800576ee0
--- /dev/null
+++ b/lean/OAI/Algebra/AlgebraicObstruction/ChartTruncation.lean
@@ -0,0 +1,172 @@
+import Mathlib
+import OAI.Algebra.FrobeniusObstruction.Obstruction
+import OAI.Algebra.AlgebraicObstruction.LocalOrigin
+import OAI.Algebra.AlgebraicObstruction.TaylorTarget
+
+namespace OAI
+
+noncomputable section
+open scoped BigOperators
+
+namespace BoundaryOnly.FormalObstruction.FormalCorrection.AffineEtaleChart
+open MvPowerSeries
+open BoundaryOnly.FormalObstruction.AlgebraicReplacement
+variable {K α : Type} [Field K] [Finite α]
+
+omit [Finite α] in
+lemma origin_eq_variables : origin (K := K) (α := α) = MvPolynomial.idealOfVars α K :=
+  (TaylorTarget.variables_ker K α).symm
+
+omit [Finite α] in
+lemma maximalIdeal_eq_map_variables (E : AffineEtaleChart K α) :
+    IsLocalRing.maximalIdeal E.LocalRing =
+      (MvPolynomial.idealOfVars α K).map (algebraMap (MvPolynomial α K) E.LocalRing) := by
+  rw [maximalIdeal_eq_map_origin,origin_eq_variables]
+
+def augmentation (E : AffineEtaleChart K α) : E.LocalRing →+* K :=
+  constantCoeff.comp E.localExpansion.toRingHom
+
+@[simp] lemma augmentation_polynomial (E : AffineEtaleChart K α) (p : MvPolynomial α K) :
+    E.augmentation (algebraMap (MvPolynomial α K) E.LocalRing p) =
+      MvPolynomial.constantCoeff p := by
+  change constantCoeff (E.localExpansion (algebraMap (MvPolynomial α K) E.LocalRing p)) = _
+  rw [E.localExpansion.commutes]
+  rfl
+
+lemma augmentation_ker (E : AffineEtaleChart K α) :
+    RingHom.ker E.augmentation = IsLocalRing.maximalIdeal E.LocalRing := by
+  ext a
+  change E.augmentation a = 0 ↔ _
+  rw [IsLocalRing.mem_maximalIdeal]
+  constructor
+  · intro h hu
+    have hh := hu.map E.augmentation
+    rw [h] at hh
+    exact not_isUnit_zero hh
+  · intro h
+    by_contra hn
+    apply h
+    apply isUnit_of_map_unit E.localExpansion
+    rw [MvPowerSeries.isUnit_iff_constantCoeff,isUnit_iff_ne_zero]
+    exact hn
+
+abbrev FormalTruncation (q : ℕ) := TaylorTarget.Ring K α q
+
+noncomputable def formalTruncate (q : ℕ) :
+    MvPowerSeries α K →ₐ[MvPolynomial α K] FormalTruncation (K := K) (α := α) q :=
+  MvPowerSeries.truncTotalAlgHom α K q
+
+lemma reduction_formalTruncate (q : ℕ) (hq : 1 ≤ q) (f : MvPowerSeries α K) :
+    TaylorTarget.reduction K α q hq (formalTruncate q f) = constantCoeff f := by
+  change MvPolynomial.constantCoeff (MvPowerSeries.truncTotal q f) = constantCoeff f
+  exact MvPowerSeries.coeff_truncTotal _ (by simp only [map_zero]; omega)
+
+noncomputable def truncate (E : AffineEtaleChart K α) (q : ℕ) :
+    E.LocalRing →ₐ[MvPolynomial α K] FormalTruncation (K := K) (α := α) q :=
+  (formalTruncate q).comp E.localExpansion
+
+@[simp] lemma truncate_polynomial (E : AffineEtaleChart K α) (q : ℕ) (p : MvPolynomial α K) :
+    E.truncate q (algebraMap (MvPolynomial α K) E.LocalRing p) =
+      Ideal.Quotient.mk (MvPolynomial.idealOfVars α K ^ q) p :=
+  (E.truncate q).commutes p
+
+lemma reduction_truncate (E : AffineEtaleChart K α) (q : ℕ) (hq : 1 ≤ q) (a : E.LocalRing) :
+    TaylorTarget.reduction K α q hq (E.truncate q a) = E.augmentation a :=
+  reduction_formalTruncate q hq _
+
+lemma truncate_maximal_pow (E : AffineEtaleChart K α) (q : ℕ) :
+    (IsLocalRing.maximalIdeal E.LocalRing) ^ q ≤ RingHom.ker (E.truncate q) := by
+  rw [E.maximalIdeal_eq_map_variables,← Ideal.map_pow,Ideal.map_le_iff_le_comap]
+  intro p hp
+  change E.truncate q (algebraMap (MvPolynomial α K) E.LocalRing p) = 0
+  rw [truncate_polynomial,Ideal.Quotient.eq_zero_iff_mem]
+  exact hp
+
+noncomputable def truncateQuotient (E : AffineEtaleChart K α) (q : ℕ) :
+    E.LocalRing ⧸ (IsLocalRing.maximalIdeal E.LocalRing) ^ q →+*
+       FormalTruncation (K := K) (α := α) q :=
+  Ideal.Quotient.lift _ (E.truncate q).toRingHom (E.truncate_maximal_pow q)
+
+noncomputable def polynomialQuotient (E : AffineEtaleChart K α) (q : ℕ) :
+    FormalTruncation (K := K) (α := α) q →ₐ[MvPolynomial α K]
+      E.LocalRing ⧸ (IsLocalRing.maximalIdeal E.LocalRing) ^ q :=
+  Ideal.Quotient.liftₐ _ (Algebra.ofId (MvPolynomial α K) (E.LocalRing ⧸ (IsLocalRing.maximalIdeal E.LocalRing) ^ q)) (by
+    intro p hp
+    change Ideal.Quotient.mk _ (algebraMap (MvPolynomial α K) E.LocalRing p) = 0
+    rw [Ideal.Quotient.eq_zero_iff_mem,E.maximalIdeal_eq_map_variables,← Ideal.map_pow]
+    exact Ideal.mem_map_of_mem _ hp)
+
+lemma truncate_polynomialQuotient (E : AffineEtaleChart K α) (q : ℕ)
+    (x : FormalTruncation (K := K) (α := α) q) :
+    E.truncateQuotient q (E.polynomialQuotient q x) = x := by
+  obtain ⟨p,rfl⟩ := Ideal.Quotient.mk_surjective x
+  change E.truncate q (algebraMap (MvPolynomial α K) E.LocalRing p) = _
+  exact E.truncate_polynomial q p
+
+lemma factor_polynomial_truncate (E : AffineEtaleChart K α) (q : ℕ) (hq : 1 ≤ q)
+    (a : E.LocalRing) :
+    Ideal.Quotient.factor (Ideal.pow_le_self (show q ≠ 0 by omega))
+      (E.polynomialQuotient q (E.truncate q a)) =
+      Ideal.Quotient.mk (IsLocalRing.maximalIdeal E.LocalRing) a := by
+  obtain ⟨p,hp⟩ := Ideal.Quotient.mk_surjective (E.truncate q a)
+  have hc : MvPolynomial.constantCoeff p = E.augmentation a := by
+    have hh := congrArg (TaylorTarget.reduction K α q hq) hp
+    exact (TaylorTarget.reduction_mk K α q hq p).symm.trans
+      (hh.trans (E.reduction_truncate q hq a))
+  rw [← hp]
+  change Ideal.Quotient.mk (IsLocalRing.maximalIdeal E.LocalRing)
+      (algebraMap (MvPolynomial α K) E.LocalRing p) =
+    Ideal.Quotient.mk (IsLocalRing.maximalIdeal E.LocalRing) a
+  rw [Ideal.Quotient.eq,← E.augmentation_ker]
+  change E.augmentation (algebraMap (MvPolynomial α K) E.LocalRing p - a) = 0
+  rw [map_sub,augmentation_polynomial,hc,sub_self]
+
+lemma polynomial_truncate (E : AffineEtaleChart K α) (q : ℕ) (a : E.LocalRing) :
+    E.polynomialQuotient q (E.truncate q a) =
+      Ideal.Quotient.mk ((IsLocalRing.maximalIdeal E.LocalRing)^q) a := by
+  by_cases hq : q = 0
+  · subst q
+    have : Subsingleton (E.LocalRing ⧸ (IsLocalRing.maximalIdeal E.LocalRing)^0) :=
+      Ideal.Quotient.subsingleton_iff.mpr (by simp)
+    exact Subsingleton.elim _ _
+  · let r := Ideal.Quotient.factor
+      (Ideal.pow_le_self (I := IsLocalRing.maximalIdeal E.LocalRing) hq)
+    have hr : IsNilpotent (RingHom.ker r) := by
+      refine ⟨q,?_⟩
+      have hk : RingHom.ker r = (IsLocalRing.maximalIdeal E.LocalRing).map
+          (Ideal.Quotient.mk ((IsLocalRing.maximalIdeal E.LocalRing)^q)) := by
+        apply Ideal.comap_injective_of_surjective
+          (Ideal.Quotient.mk ((IsLocalRing.maximalIdeal E.LocalRing)^q)) Ideal.Quotient.mk_surjective
+        rw [RingHom.comap_ker]
+        change RingHom.ker (Ideal.Quotient.mk (IsLocalRing.maximalIdeal E.LocalRing)) = _
+        rw [Ideal.mk_ker,Ideal.comap_map_of_surjective _ Ideal.Quotient.mk_surjective]
+        change _ = IsLocalRing.maximalIdeal E.LocalRing ⊔ _
+        rw [← RingHom.ker_eq_comap_bot,Ideal.mk_ker]
+        exact (sup_eq_left.mpr (Ideal.pow_le_self hq)).symm
+      rw [hk,← Ideal.map_pow,Ideal.map_quotient_self]
+      rfl
+    have hh := Algebra.FormallyUnramified.ext' r hr
+      ((E.polynomialQuotient q).comp (E.truncate q))
+      (Ideal.Quotient.mkₐ (MvPolynomial α K) ((IsLocalRing.maximalIdeal E.LocalRing)^q))
+      (fun a ↦ E.factor_polynomial_truncate q (by omega) a)
+    exact AlgHom.congr_fun hh a
+
+noncomputable def truncatedEquiv (E : AffineEtaleChart K α) (q : ℕ) :
+    E.LocalRing ⧸ (IsLocalRing.maximalIdeal E.LocalRing)^q ≃+*
+      FormalTruncation (K := K) (α := α) q :=
+  { E.truncateQuotient q with
+    invFun := E.polynomialQuotient q
+    left_inv := by
+      intro x
+      obtain ⟨a,rfl⟩ := Ideal.Quotient.mk_surjective x
+      exact E.polynomial_truncate q a
+    right_inv := E.truncate_polynomialQuotient q }
+
+@[simp] lemma truncatedEquiv_mk (E : AffineEtaleChart K α) (q : ℕ) (a : E.LocalRing) :
+    E.truncatedEquiv q (Ideal.Quotient.mk _ a) = E.truncate q a := rfl
+
+end BoundaryOnly.FormalObstruction.FormalCorrection.AffineEtaleChart
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/AlgebraicObstruction/CoefficientData.lean b/lean/OAI/Algebra/AlgebraicObstruction/CoefficientData.lean
new file mode 100644
index 0000000000000000000000000000000000000000..85ddf74591018cdc2012305a0ad3f6291ee1e73d
--- /dev/null
+++ b/lean/OAI/Algebra/AlgebraicObstruction/CoefficientData.lean
@@ -0,0 +1,283 @@
+import Mathlib
+import OAI.Algebra.FrobeniusObstruction.Obstruction
+
+namespace OAI
+
+noncomputable section
+open scoped BigOperators
+
+namespace BoundaryOnly.FormalObstruction.CoefficientRing
+
+abbrev SlopeVar (d : ℕ) := Fin d × Fin 3
+abbrev TangentVar {d : ℕ} (n : Fin d → ℕ) := (i : Fin d) × Fin (n i)
+abbrev WallVar {d : ℕ} (n : Fin d → ℕ) (i : Fin d) := Fin 3 ⊕ Fin (n i)
+abbrev InternalVar {d : ℕ} (n : Fin d → ℕ) := Bool × TangentVar n
+abbrev GraphVar {d : ℕ} (n : Fin d → ℕ) := SlopeVar d ⊕ TangentVar n
+abbrev AmbientVar {d : ℕ} (n : Fin d → ℕ) := SlopeVar d ⊕ InternalVar n
+
+def originIdeal (k : Type*) [CommRing k] (ι : Type*) : Ideal (MvPowerSeries ι k) :=
+  Ideal.span (Set.range (MvPowerSeries.X : ι → MvPowerSeries ι k))
+
+variable {k : Type*} [CommRing k] {d : ℕ} (n : Fin d → ℕ)
+
+def plusCoordinates (i : Fin d) : WallVar n i → MvPowerSeries (AmbientVar n) k
+  | .inl j => MvPowerSeries.X (.inl (i, j))
+  | .inr y => MvPowerSeries.X (.inr (true, ⟨i, y⟩))
+
+def minusCoordinates (i : Fin d) : WallVar n i → MvPowerSeries (AmbientVar n) k
+  | .inl _ => 0
+  | .inr y => MvPowerSeries.X (.inr (false, ⟨i, y⟩))
+
+def zeroSlopes (i : Fin d) : WallVar n i → MvPowerSeries (Fin (n i)) k
+  | .inl _ => 0
+  | .inr y => MvPowerSeries.X y
+
+def potential (P : (i : Fin d) → MvPowerSeries (WallVar n i) k) :
+    MvPowerSeries (AmbientVar n) k :=
+  ∑ i, (MvPowerSeries.subst (plusCoordinates n i) (P i) -
+    MvPowerSeries.subst (minusCoordinates n i) (P i))
+
+def slopeDerivative (P : (i : Fin d) → MvPowerSeries (WallVar n i) k)
+    (i : Fin d) : MvPowerSeries (Fin (n i)) k :=
+  MvPowerSeries.subst (zeroSlopes n i) (MvPowerSeries.pderiv (.inl 0) (P i))
+
+def graphCoordinates (Y : InternalVar n → MvPowerSeries (GraphVar n) k) :
+    AmbientVar n → MvPowerSeries (GraphVar n) k
+  | .inl a => MvPowerSeries.X (.inl a)
+  | .inr c => Y c
+
+def restrictedGradient (P : (i : Fin d) → MvPowerSeries (WallVar n i) k)
+    (Y : InternalVar n → MvPowerSeries (GraphVar n) k) (c : InternalVar n) :
+    MvPowerSeries (GraphVar n) k :=
+  MvPowerSeries.subst (graphCoordinates n Y)
+    (MvPowerSeries.pderiv (.inr c) (potential n P))
+
+def gradientIdeal (P : (i : Fin d) → MvPowerSeries (WallVar n i) k)
+    (Y : InternalVar n → MvPowerSeries (GraphVar n) k) :
+    Ideal (MvPowerSeries (GraphVar n) k) :=
+  Ideal.span (Set.range (restrictedGradient n P Y))
+
+def negativeSlopeValue (P : (i : Fin d) → MvPowerSeries (WallVar n i) k)
+    (Y : InternalVar n → MvPowerSeries (GraphVar n) k) (i : Fin d) :
+    MvPowerSeries (GraphVar n) k :=
+  MvPowerSeries.subst (fun j => Y (false, ⟨i, j⟩)) (slopeDerivative n P i)
+
+def slope (i : Fin d) : MvPowerSeries (GraphVar n) k :=
+  MvPowerSeries.X (.inl (i, 0))
+
+def swapBlocks (c : InternalVar n) : InternalVar n := (!c.1, c.2)
+
+def tangentMatrix (Y : InternalVar n → MvPowerSeries (GraphVar n) k) :
+    Matrix (InternalVar n) (TangentVar n) k :=
+  fun c t => MvPowerSeries.constantCoeff (MvPowerSeries.pderiv (.inr t) (Y c))
+
+def complementaryMatrix (Y : InternalVar n → MvPowerSeries (GraphVar n) k) :
+    Matrix (InternalVar n) (InternalVar n) k :=
+  fun c bt => if bt.1 then tangentMatrix n Y (swapBlocks n c) bt.2
+    else tangentMatrix n Y c bt.2
+
+structure FormalData where
+  P : (i : Fin d) → MvPowerSeries (WallVar n i) k
+  Y : InternalVar n → MvPowerSeries (GraphVar n) k
+  order_three : ∀ i, P i ∈ (originIdeal k (WallVar n i)) ^ 3
+  centered : ∀ c, Y c ∈ originIdeal k (GraphVar n)
+  complementary : IsUnit (complementaryMatrix n Y).det
+  graph_zero : MvPowerSeries.subst (graphCoordinates n Y) (potential n P) = 0
+  positive_cubic : ∀ i j l : Fin d,
+    slope n i * slope n j * slope n l ∈ gradientIdeal n P Y
+  negative_cubic : ∀ i j l : Fin d,
+    negativeSlopeValue n P Y i * negativeSlopeValue n P Y j *
+      negativeSlopeValue n P Y l ∈ gradientIdeal n P Y
+
+end BoundaryOnly.FormalObstruction.CoefficientRing
+
+namespace BoundaryOnly.FormalObstruction.CoefficientRing
+open MvPowerSeries
+variable {R S ι κ : Type*} [CommRing R] [CommRing S]
+
+ theorem map_partial (f : R →+* S) (i : ι) (P : MvPowerSeries ι R) :
+    MvPowerSeries.map f (pderiv i P) = pderiv i (MvPowerSeries.map f P) := by
+  classical
+  ext e
+  simp only [coeff_map, coeff_pderiv, map_mul, map_add, map_natCast, map_one]
+
+ theorem map_origin (f : R →+* S) :
+    Ideal.map (MvPowerSeries.map f) (originIdeal R ι) ≤ originIdeal S ι := by
+  rw [originIdeal, Ideal.map_span]
+  apply Ideal.span_le.mpr
+  rintro _ ⟨_, ⟨i,rfl⟩, rfl⟩
+  change MvPowerSeries.map f (X i) ∈ Ideal.span (Set.range (X : ι → MvPowerSeries ι S))
+  rw [map_X]
+  exact Ideal.subset_span ⟨i,rfl⟩
+
+ theorem map_mem_origin (f : R →+* S) {P : MvPowerSeries ι R}
+    (h : P ∈ originIdeal R ι) : MvPowerSeries.map f P ∈ originIdeal S ι :=
+  map_origin f (Ideal.mem_map_of_mem (MvPowerSeries.map f) h)
+
+ theorem map_mem_origin_pow (f : R →+* S) (q : ℕ) {P : MvPowerSeries ι R}
+    (h : P ∈ (originIdeal R ι)^q) : MvPowerSeries.map f P ∈ (originIdeal S ι)^q := by
+  have hp := Ideal.mem_map_of_mem (MvPowerSeries.map f) h
+  rw [Ideal.map_pow] at hp
+  exact Ideal.pow_right_mono (map_origin f) q hp
+
+ theorem origin_constant {P : MvPowerSeries ι R} (h : P ∈ originIdeal R ι) :
+    constantCoeff P = 0 := by
+  have hi : originIdeal R ι ≤ RingHom.ker (constantCoeff : MvPowerSeries ι R →+* R) := by
+    apply Ideal.span_le.mpr
+    rintro _ ⟨i,rfl⟩
+    change constantCoeff (X i : MvPowerSeries ι R) = 0
+    exact constantCoeff_X i
+  exact hi h
+
+ theorem hasSubst_origin [Finite ι] (v : ι → MvPowerSeries κ R)
+    (hv : ∀ i, v i ∈ originIdeal R κ) : HasSubst v :=
+  hasSubst_of_constantCoeff_zero (fun i => origin_constant (hv i))
+
+end BoundaryOnly.FormalObstruction.CoefficientRing
+
+namespace BoundaryOnly.FormalObstruction.CoefficientRing
+open MvPowerSeries
+variable {R S : Type*} [CommRing R] [CommRing S] {d : ℕ} (n : Fin d → ℕ)
+
+ theorem plus_hasSubst (i : Fin d) : HasSubst (plusCoordinates (k := R) n i) := by
+  apply hasSubst_of_constantCoeff_zero
+  rintro (j | y) <;> simp only [plusCoordinates, constantCoeff_X]
+
+ theorem minus_hasSubst (i : Fin d) : HasSubst (minusCoordinates (k := R) n i) := by
+  apply hasSubst_of_constantCoeff_zero
+  rintro (j | y) <;> simp only [minusCoordinates, map_zero, constantCoeff_X]
+
+ theorem zeroSlopes_hasSubst (i : Fin d) : HasSubst (zeroSlopes (k := R) n i) := by
+  apply hasSubst_of_constantCoeff_zero
+  rintro (j | y) <;> simp only [zeroSlopes, map_zero, constantCoeff_X]
+
+ theorem map_plus (f : R →+* S) (i : Fin d) :
+    (fun j => MvPowerSeries.map f (plusCoordinates n i j)) = plusCoordinates n i := by
+  funext j
+  cases j <;> simp only [plusCoordinates, map_X]
+
+ theorem map_minus (f : R →+* S) (i : Fin d) :
+    (fun j => MvPowerSeries.map f (minusCoordinates n i j)) = minusCoordinates n i := by
+  funext j
+  cases j <;> simp only [minusCoordinates, map_X, map_zero]
+
+ theorem map_zeroSlopes (f : R →+* S) (i : Fin d) :
+    (fun j => MvPowerSeries.map f (zeroSlopes n i j)) = zeroSlopes n i := by
+  funext j
+  cases j <;> simp only [zeroSlopes, map_X, map_zero]
+
+ theorem map_potential (f : R →+* S) (P : (i : Fin d) → MvPowerSeries (WallVar n i) R) :
+    MvPowerSeries.map f (potential n P) =
+      potential n (fun i => MvPowerSeries.map f (P i)) := by
+  simp only [potential, map_sum, map_sub, map_subst (plus_hasSubst n _),
+    map_subst (minus_hasSubst n _), map_plus, map_minus]
+
+ theorem map_slopeDerivative (f : R →+* S) (P : (i : Fin d) → MvPowerSeries (WallVar n i) R)
+    (i : Fin d) :
+    MvPowerSeries.map f (slopeDerivative n P i) =
+      slopeDerivative n (fun i => MvPowerSeries.map f (P i)) i := by
+  simp only [slopeDerivative, map_subst (zeroSlopes_hasSubst n i), map_zeroSlopes, map_partial]
+
+ theorem graph_hasSubst (Y : InternalVar n → MvPowerSeries (GraphVar n) R)
+    (hY : ∀ c, Y c ∈ originIdeal R (GraphVar n)) : HasSubst (graphCoordinates n Y) := by
+  apply hasSubst_of_constantCoeff_zero
+  rintro (a | c)
+  · exact constantCoeff_X _
+  · exact origin_constant (hY c)
+
+ theorem map_graph (f : R →+* S) (Y : InternalVar n → MvPowerSeries (GraphVar n) R) :
+    (fun j => MvPowerSeries.map f (graphCoordinates n Y j)) =
+      graphCoordinates n (fun c => MvPowerSeries.map f (Y c)) := by
+  funext j
+  cases j <;> simp only [graphCoordinates, map_X]
+
+ theorem map_restrictedGradient (f : R →+* S)
+    (P : (i : Fin d) → MvPowerSeries (WallVar n i) R)
+    (Y : InternalVar n → MvPowerSeries (GraphVar n) R)
+    (hY : ∀ c, Y c ∈ originIdeal R (GraphVar n)) (c : InternalVar n) :
+    MvPowerSeries.map f (restrictedGradient n P Y c) =
+      restrictedGradient n (fun i => MvPowerSeries.map f (P i))
+        (fun c => MvPowerSeries.map f (Y c)) c := by
+  simp only [restrictedGradient, map_subst (graph_hasSubst n Y hY), map_graph,
+    map_partial, map_potential]
+
+ theorem map_gradientIdeal (f : R →+* S)
+    (P : (i : Fin d) → MvPowerSeries (WallVar n i) R)
+    (Y : InternalVar n → MvPowerSeries (GraphVar n) R)
+    (hY : ∀ c, Y c ∈ originIdeal R (GraphVar n)) :
+    Ideal.map (MvPowerSeries.map f) (gradientIdeal n P Y) =
+      gradientIdeal n (fun i => MvPowerSeries.map f (P i))
+        (fun c => MvPowerSeries.map f (Y c)) := by
+  simp only [gradientIdeal, Ideal.map_span, ← Set.range_comp]
+  apply congrArg Ideal.span
+  apply congrArg Set.range
+  funext c
+  exact map_restrictedGradient n f P Y hY c
+
+ theorem map_negativeSlopeValue (f : R →+* S)
+    (P : (i : Fin d) → MvPowerSeries (WallVar n i) R)
+    (Y : InternalVar n → MvPowerSeries (GraphVar n) R)
+    (hY : ∀ c, Y c ∈ originIdeal R (GraphVar n)) (i : Fin d) :
+    MvPowerSeries.map f (negativeSlopeValue n P Y i) =
+      negativeSlopeValue n (fun i => MvPowerSeries.map f (P i))
+        (fun c => MvPowerSeries.map f (Y c)) i := by
+  rw [negativeSlopeValue, map_subst (hasSubst_origin _ (fun y => hY (false,⟨i,y⟩))),
+    map_slopeDerivative]
+  rfl
+
+ theorem map_complementary (f : R →+* S)
+    (Y : InternalVar n → MvPowerSeries (GraphVar n) R) :
+    (complementaryMatrix n Y).map f =
+      complementaryMatrix n (fun c => MvPowerSeries.map f (Y c)) := by
+  ext c bt
+  simp only [Matrix.map_apply, complementaryMatrix]
+  split_ifs <;> simp only [tangentMatrix, ← map_partial, constantCoeff_map]
+
+end BoundaryOnly.FormalObstruction.CoefficientRing
+
+namespace BoundaryOnly.FormalObstruction.CoefficientRing
+open MvPowerSeries
+variable {R S : Type*} [CommRing R] [CommRing S] {d : ℕ} {n : Fin d → ℕ}
+
+def FormalData.map (D : FormalData (k := R) n) (f : R →+* S) : FormalData (k := S) n where
+  P := fun i => MvPowerSeries.map f (D.P i)
+  Y := fun c => MvPowerSeries.map f (D.Y c)
+  order_three := fun i => map_mem_origin_pow f 3 (D.order_three i)
+  centered := fun c => map_mem_origin f (D.centered c)
+  complementary := by
+    rw [← map_complementary]
+    change IsUnit (f.mapMatrix (complementaryMatrix n D.Y)).det
+    rw [← RingHom.map_det]
+    exact D.complementary.map f
+  graph_zero := by
+    have h := congrArg (MvPowerSeries.map f) D.graph_zero
+    simpa only [MvPowerSeries.map_subst (graph_hasSubst n D.Y D.centered), map_potential,
+      map_graph, map_zero] using h
+  positive_cubic := by
+    intro i j l
+    have h := Ideal.mem_map_of_mem (MvPowerSeries.map f) (D.positive_cubic i j l)
+    rw [map_gradientIdeal n f D.P D.Y D.centered] at h
+    simpa only [map_mul, slope, map_X] using h
+  negative_cubic := by
+    intro i j l
+    have h := Ideal.mem_map_of_mem (MvPowerSeries.map f) (D.negative_cubic i j l)
+    rw [map_gradientIdeal n f D.P D.Y D.centered] at h
+    simpa only [map_mul, map_negativeSlopeValue n f D.P D.Y D.centered] using h
+
+variable {k : Type*} [Field k]
+
+def FormalData.toField (D : FormalData (k := k) n) : BoundaryOnly.FormalObstruction.FormalData (k := k) n where
+  P := D.P
+  Y := D.Y
+  order_three := D.order_three
+  centered := D.centered
+  complementary := D.complementary.ne_zero
+  graph_zero := D.graph_zero
+  positive_cubic := D.positive_cubic
+  negative_cubic := D.negative_cubic
+
+end BoundaryOnly.FormalObstruction.CoefficientRing
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/AlgebraicObstruction/CorrectionOperator.lean b/lean/OAI/Algebra/AlgebraicObstruction/CorrectionOperator.lean
new file mode 100644
index 0000000000000000000000000000000000000000..84e298d85d5d1677b1f0b902faca34b49ec89db8
--- /dev/null
+++ b/lean/OAI/Algebra/AlgebraicObstruction/CorrectionOperator.lean
@@ -0,0 +1,141 @@
+import Mathlib
+import OAI.Algebra.FrobeniusObstruction.Obstruction
+import OAI.Algebra.AlgebraicObstruction.SeriesJets
+
+namespace OAI
+
+noncomputable section
+open scoped BigOperators
+
+namespace BoundaryOnly.FormalObstruction.FormalCorrection
+open MvPowerSeries
+variable {R σ τ ι : Type*} [CommRing R]
+
+ theorem Jet.sum {n : ℕ} (s : Finset ι) {f g : ι → MvPowerSeries σ R}
+    (h : ∀ i ∈ s, Jet n (f i) (g i)) : Jet n (∑ i ∈ s, f i) (∑ i ∈ s, g i) := by
+  apply Jet.iff_coeff.mpr
+  intro e he
+  simp only [map_sum]
+  exact Finset.sum_congr rfl fun i hi => Jet.iff_coeff.mp (h i hi) e he
+
+ theorem positively_weighted_triple {n : ℕ} {f f' h h' g g' : MvPowerSeries σ R}
+    (hf : Jet n f f') (hg : Jet n g g') (h0 : Vanishes 1 h) (h0' : Vanishes 1 h')
+    (hh : Jet (n+1) h h') : Jet (n+1) (f*h*g) (f'*h'*g') := by
+  change Vanishes (n+1) (f*h*g - f'*h'*g')
+  have heq : f*h*g - f'*h'*g' =
+      (f-f')*h*g + f'*(h-h')*g + f'*h'*(g-g') := by ring
+  rw [heq]
+  apply Vanishes.add
+  · exact ((Vanishes.mul hf h0).mul_right g).add
+      ((Vanishes.mul_left hh f').mul_right g)
+  · simpa only [Nat.add_comm, mul_assoc] using (h0'.mul hg).mul_left f'
+
+variable [Fintype ι]
+
+def correctionArguments (x : τ → MvPowerSeries σ R) (v : ι → MvPowerSeries σ R)
+    (B : Matrix ι ι (MvPowerSeries σ R)) : τ ⊕ ι → MvPowerSeries σ R
+  | .inl t => x t
+  | .inr i => ∑ j, B i j * v j
+
+def remainderValue (H : Matrix ι ι (MvPowerSeries (τ ⊕ ι) R))
+    (x : τ → MvPowerSeries σ R) (v : ι → MvPowerSeries σ R)
+    (B : Matrix ι ι (MvPowerSeries σ R)) : Matrix ι ι (MvPowerSeries σ R) :=
+  fun i j => subst (correctionArguments x v B) (H i j)
+
+def correctionOperator (b : Matrix ι ι (MvPowerSeries σ R))
+    (H : Matrix ι ι (MvPowerSeries (τ ⊕ ι) R))
+    (x : τ → MvPowerSeries σ R) (v : ι → MvPowerSeries σ R)
+    (B : Matrix ι ι (MvPowerSeries σ R)) : Matrix ι ι (MvPowerSeries σ R) :=
+  -b - B.transpose * remainderValue H x v B * B
+
+ theorem correctionArguments_centered (x : τ → MvPowerSeries σ R)
+    (v : ι → MvPowerSeries σ R) (hx : ∀ t, constantCoeff (x t) = 0)
+    (hv : ∀ i, Vanishes 2 (v i)) (B : Matrix ι ι (MvPowerSeries σ R)) :
+    ∀ z, constantCoeff (correctionArguments x v B z) = 0 := by
+  intro z
+  cases z with
+  | inl t => exact hx t
+  | inr i =>
+    apply Vanishes.one_iff.mp
+    exact (Vanishes.sum Finset.univ (fun j => B i j * v j)
+      (fun j _ => (hv j).mul_left (B i j))).mono (by omega)
+
+ theorem correctionArguments_jet (x : τ → MvPowerSeries σ R)
+    (v : ι → MvPowerSeries σ R) (hv : ∀ i, Vanishes 2 (v i))
+    {n : ℕ} {B B' : Matrix ι ι (MvPowerSeries σ R)}
+    (hB : ∀ i j, Jet n (B i j) (B' i j)) :
+    ∀ z, Jet (n+2) (correctionArguments x v B z) (correctionArguments x v B' z) := by
+  intro z
+  cases z with
+  | inl t => exact Jet.refl _ _
+  | inr i =>
+    apply Jet.sum
+    intro j _
+    change Vanishes (n+2) (B i j * v j - B' i j * v j)
+    rw [← sub_mul]
+    exact (hB i j).mul (hv j)
+
+variable [Finite σ] [Finite τ]
+
+omit [Finite σ] in
+ theorem remainderValue_positive (H : Matrix ι ι (MvPowerSeries (τ ⊕ ι) R))
+    (x : τ → MvPowerSeries σ R) (v : ι → MvPowerSeries σ R)
+    (hH : ∀ i j, Vanishes 1 (H i j)) (hx : ∀ t, constantCoeff (x t) = 0)
+    (hv : ∀ i, Vanishes 2 (v i)) (B : Matrix ι ι (MvPowerSeries σ R)) (i j : ι) :
+    Vanishes 1 (remainderValue H x v B i j) := by
+  apply Vanishes.one_iff.mpr
+  have ha := correctionArguments_centered x v hx hv B
+  exact constantCoeff_subst_eq_zero (hasSubst_of_constantCoeff_zero ha) ha
+    (Vanishes.one_iff.mp (hH i j))
+
+ theorem remainderValue_jet (H : Matrix ι ι (MvPowerSeries (τ ⊕ ι) R))
+    (x : τ → MvPowerSeries σ R) (v : ι → MvPowerSeries σ R)
+    (hx : ∀ t, constantCoeff (x t) = 0) (hv : ∀ i, Vanishes 2 (v i))
+    {n : ℕ} {B B' : Matrix ι ι (MvPowerSeries σ R)}
+    (hB : ∀ i j, Jet n (B i j) (B' i j)) (i j : ι) :
+    Jet (n+2) (remainderValue H x v B i j) (remainderValue H x v B' i j) := by
+  exact Jet.subst (correctionArguments_centered x v hx hv B)
+    (correctionArguments_centered x v hx hv B') (correctionArguments_jet x v hv hB) (H i j)
+
+ theorem correctionOperator_contracts (b : Matrix ι ι (MvPowerSeries σ R))
+    (H : Matrix ι ι (MvPowerSeries (τ ⊕ ι) R))
+    (x : τ → MvPowerSeries σ R) (v : ι → MvPowerSeries σ R)
+    (hH : ∀ i j, Vanishes 1 (H i j)) (hx : ∀ t, constantCoeff (x t) = 0)
+    (hv : ∀ i, Vanishes 2 (v i))
+    {n : ℕ} {B B' : Matrix ι ι (MvPowerSeries σ R)}
+    (hB : ∀ i j, Jet n (B i j) (B' i j)) (i j : ι) :
+    Jet (n+1) (correctionOperator b H x v B i j) (correctionOperator b H x v B' i j) := by
+  classical
+  simp only [correctionOperator, Matrix.sub_apply, Matrix.neg_apply, Matrix.mul_apply,
+    Matrix.transpose_apply, Finset.sum_mul]
+  apply Jet.sub (Jet.refl _ _)
+  apply Jet.sum
+  intro l _
+  apply Jet.sum
+  intro k _
+  exact positively_weighted_triple (hB k i) (hB l j)
+    (remainderValue_positive H x v hH hx hv B k l)
+    (remainderValue_positive H x v hH hx hv B' k l)
+    ((remainderValue_jet H x v hx hv hB k l).mono (by omega))
+
+theorem exists_correction_matrix (b : Matrix ι ι (MvPowerSeries σ R))
+    (H : Matrix ι ι (MvPowerSeries (τ ⊕ ι) R))
+    (x : τ → MvPowerSeries σ R) (v : ι → MvPowerSeries σ R)
+    (hH : ∀ i j, Vanishes 1 (H i j)) (hx : ∀ t, constantCoeff (x t) = 0)
+    (hv : ∀ i, Vanishes 2 (v i)) :
+    ∃ B : Matrix ι ι (MvPowerSeries σ R), B = -b - B.transpose * remainderValue H x v B * B := by
+  let T : ((ι × ι) → MvPowerSeries σ R) → ((ι × ι) → MvPowerSeries σ R) :=
+    fun B ij => correctionOperator b H x v (fun i j => B (i,j)) ij.1 ij.2
+  have hT : ∀ n f g, Close n f g → Close (n+1) (T f) (T g) := by
+    intro n f g hfg ij e he
+    exact Jet.iff_coeff.mp (correctionOperator_contracts b H x v hH hx hv
+      (fun i j => Jet.iff_coeff.mpr (hfg (i,j))) ij.1 ij.2) e he
+  refine ⟨fun i j => fixedPoint T (i,j), ?_⟩
+  funext i j
+  exact (congrFun (fixedPoint_eq T hT) (i,j)).symm
+
+end BoundaryOnly.FormalObstruction.FormalCorrection
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/AlgebraicObstruction/Differentiation.lean b/lean/OAI/Algebra/AlgebraicObstruction/Differentiation.lean
new file mode 100644
index 0000000000000000000000000000000000000000..9fb498d6c91b6af53ed99658bd56ed3368f8a922
--- /dev/null
+++ b/lean/OAI/Algebra/AlgebraicObstruction/Differentiation.lean
@@ -0,0 +1,107 @@
+import Mathlib
+import OAI.Algebra.FrobeniusObstruction.Obstruction
+import OAI.Algebra.AlgebraicObstruction.SeriesJets
+
+namespace OAI
+
+noncomputable section
+open scoped BigOperators
+
+namespace BoundaryOnly.FormalObstruction.FormalCorrection
+open MvPowerSeries
+variable {R σ τ ι S : Type*} [CommRing R]
+
+ theorem Jet.mul {n : ℕ} {f f' g g' : MvPowerSeries σ R}
+    (hf : Jet n f f') (hg : Jet n g g') : Jet n (f*g) (f'*g') := by
+  change Vanishes n (f*g-f'*g')
+  have heq : f*g-f'*g' = (f-f')*g + f'*(g-g') := by ring
+  rw [heq]
+  exact (Vanishes.mul_right hf g).add (Vanishes.mul_left hg f')
+
+ theorem Jet.pderiv {n : ℕ} {f g : MvPowerSeries σ R}
+    (h : Jet (n+1) f g) (i : σ) : Jet n (MvPowerSeries.pderiv (R := R) i f) (MvPowerSeries.pderiv (R := R) i g) := by
+  classical
+  apply Jet.iff_coeff.mpr
+  intro e he
+  simp only [MvPowerSeries.coeff_pderiv]
+  rw [Jet.iff_coeff.mp h (e + Finsupp.single i 1) (by
+    simp only [map_add, Finsupp.degree_single]; omega)]
+
+ theorem Vanishes.pderiv {n : ℕ} {f : MvPowerSeries σ R}
+    (h : Vanishes (n+1) f) (i : σ) : Vanishes n (MvPowerSeries.pderiv (R := R) i f) := by
+  have hf : Jet (n+1) f 0 := by simpa only [Jet, sub_zero] using h
+  simpa only [Jet, map_zero, sub_zero] using hf.pderiv i
+
+ theorem jet_trunc [Finite σ] (n : ℕ) (f : MvPowerSeries σ R) :
+    Jet n f (truncTotal n f).toMvPowerSeries := by
+  apply Jet.iff_coeff.mpr
+  intro e he
+  simp only [MvPolynomial.coeff_coe, coeff_truncTotal _ he]
+
+ theorem Jet.subst_series [Finite σ] [Finite τ] {n : ℕ} {f g : MvPowerSeries σ R}
+    (a : σ → MvPowerSeries τ R) (ha : ∀ i, constantCoeff (a i) = 0) (h : Jet n f g) :
+    Jet n (MvPowerSeries.subst a f) (MvPowerSeries.subst a g) := by
+  apply jet_iff_truncTotal.mpr
+  have hh := jet_iff_truncTotal.mp h
+  calc
+    truncTotal n (MvPowerSeries.subst a f) = truncTotal n (MvPowerSeries.subst a (truncTotal n f).toMvPowerSeries) :=
+      truncTotal_subst_eq_truncTotal_truncTotal_subst ha
+    _ = truncTotal n (MvPowerSeries.subst a (truncTotal n g).toMvPowerSeries) := by rw [hh]
+    _ = truncTotal n (MvPowerSeries.subst a g) := (truncTotal_subst_eq_truncTotal_truncTotal_subst ha).symm
+
+ theorem Vanishes.subst [Finite σ] [Finite τ] {n : ℕ} {f : MvPowerSeries σ R}
+    (hf : Vanishes n f) (a : σ → MvPowerSeries τ R) (ha : ∀ i, constantCoeff (a i) = 0) :
+    Vanishes n (MvPowerSeries.subst a f) := by
+  have h : Jet n f 0 := by simpa only [Jet,sub_zero] using hf
+  have hh := Jet.subst_series a ha h
+  simpa only [Jet, ← MvPowerSeries.substAlgHom_apply (hasSubst_of_constantCoeff_zero ha), map_zero, sub_zero] using hh
+
+theorem derivation_aeval [Fintype σ] [CommRing S] [Algebra R S]
+    (D : Derivation R S S) (a : σ → S) (p : MvPolynomial σ R) :
+    D (MvPolynomial.aeval a p) =
+      ∑ i, MvPolynomial.aeval a (MvPolynomial.pderiv i p) * D (a i) := by
+  classical
+  induction p using MvPolynomial.induction_on with
+  | C r => simp
+  | add p q hp hq => simp only [map_add, hp, hq, add_mul, Finset.sum_add_distrib]
+  | mul_X p t hp =>
+    simp only [map_mul, Derivation.leibniz, smul_eq_mul, MvPolynomial.aeval_X,
+      MvPolynomial.pderiv_X, map_add, add_mul, Finset.sum_add_distrib, hp]
+    simp [Pi.single_apply, Finset.mul_sum, mul_assoc]
+
+ theorem pderiv_subst_polynomial [Fintype σ] (a : σ → MvPowerSeries τ R)
+    (p : MvPolynomial σ R) (j : τ) :
+    MvPowerSeries.pderiv (R := R) j (MvPowerSeries.subst a p.toMvPowerSeries) =
+      ∑ i, subst a (MvPowerSeries.pderiv (R := R) i p.toMvPowerSeries) * MvPowerSeries.pderiv (R := R) j (a i) := by
+  simp only [subst_coe, MvPowerSeries.pderiv_coe]
+  exact derivation_aeval (MvPowerSeries.pderiv (R := R) j) a p
+
+theorem pderiv_subst [Fintype σ] [Finite τ] (a : σ → MvPowerSeries τ R)
+    (ha : ∀ i, constantCoeff (a i) = 0) (f : MvPowerSeries σ R) (j : τ) :
+    MvPowerSeries.pderiv (R := R) j (MvPowerSeries.subst a f) =
+      ∑ i, subst a (MvPowerSeries.pderiv (R := R) i f) * MvPowerSeries.pderiv (R := R) j (a i) := by
+  classical
+  ext e
+  let p := truncTotal (e.degree+2) f
+  have hfp : Jet (e.degree+2) f p.toMvPowerSeries := jet_trunc _ _
+  have hleft : Jet (e.degree+1) (MvPowerSeries.pderiv (R := R) j (MvPowerSeries.subst a f))
+      (MvPowerSeries.pderiv (R := R) j (MvPowerSeries.subst a p.toMvPowerSeries)) :=
+    (Jet.subst_series a ha hfp).pderiv j
+  have hright : Jet (e.degree+1)
+      (∑ i, subst a (MvPowerSeries.pderiv (R := R) i f) * MvPowerSeries.pderiv (R := R) j (a i))
+      (∑ i, subst a (MvPowerSeries.pderiv (R := R) i p.toMvPowerSeries) * MvPowerSeries.pderiv (R := R) j (a i)) := by
+    apply Jet.iff_coeff.mpr
+    intro exponent degree_lt
+    simp only [map_sum]
+    apply Finset.sum_congr rfl
+    intro index _
+    exact Jet.iff_coeff.mp
+      ((Jet.subst_series a ha (hfp.pderiv index)).mul (Jet.refl _ _)) exponent degree_lt
+  rw [Jet.iff_coeff.mp hleft e (Nat.lt_succ_self _), pderiv_subst_polynomial]
+  exact (Jet.iff_coeff.mp hright e (Nat.lt_succ_self _)).symm
+
+end BoundaryOnly.FormalObstruction.FormalCorrection
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/AlgebraicObstruction/EtaleCharts.lean b/lean/OAI/Algebra/AlgebraicObstruction/EtaleCharts.lean
new file mode 100644
index 0000000000000000000000000000000000000000..b930d1c8b32166532c49bce3215cd841743c681d
--- /dev/null
+++ b/lean/OAI/Algebra/AlgebraicObstruction/EtaleCharts.lean
@@ -0,0 +1,230 @@
+import Mathlib
+import OAI.Algebra.FrobeniusObstruction.Obstruction
+import OAI.Algebra.AlgebraicObstruction.EtaleCoefficients
+
+namespace OAI
+
+noncomputable section
+open scoped BigOperators
+
+namespace BoundaryOnly.FormalObstruction.FormalCorrection
+open MvPowerSeries
+open scoped TensorProduct
+
+structure AffineEtaleChart (K α : Type) [CommRing K] where
+  S : Type
+  ringS : CommRing S
+  baseS : Algebra (MvPolynomial α K) S
+  etale : Algebra.Etale (MvPolynomial α K) S
+  expansion : S →ₐ[MvPolynomial α K] MvPowerSeries α K
+
+attribute [instance] AffineEtaleChart.ringS AffineEtaleChart.baseS AffineEtaleChart.etale
+
+variable {K α : Type} [CommRing K]
+
+noncomputable def AffineEtaleChart.base : AffineEtaleChart K α where
+  S := MvPolynomial α K
+  ringS := inferInstance
+  baseS := inferInstance
+  etale := inferInstance
+  expansion := Algebra.ofId _ _
+
+noncomputable def AffineEtaleChart.prod (E F : AffineEtaleChart K α) :
+    AffineEtaleChart K α where
+  S := E.S ⊗[MvPolynomial α K] F.S
+  ringS := inferInstance
+  baseS := inferInstance
+  etale := Algebra.Etale.comp (MvPolynomial α K) E.S _
+  expansion := Algebra.TensorProduct.lift E.expansion F.expansion
+    (fun _ _ ↦ Commute.all _ _)
+
+lemma AffineEtaleChart.range_left (E F : AffineEtaleChart K α) (x : E.S) :
+    E.expansion x ∈ (E.prod F).expansion.range := by
+  refine ⟨(Algebra.TensorProduct.includeLeft : E.S →ₐ[MvPolynomial α K] E.S ⊗[MvPolynomial α K] F.S) x, ?_⟩
+  change E.expansion x * F.expansion 1 = E.expansion x
+  simp
+
+lemma AffineEtaleChart.range_right (E F : AffineEtaleChart K α) (x : F.S) :
+    F.expansion x ∈ (E.prod F).expansion.range := by
+  refine ⟨Algebra.TensorProduct.includeRight x, ?_⟩
+  change E.expansion 1 * F.expansion x = F.expansion x
+  simp
+
+theorem LocalEtaleExpansion.affine {φ : MvPowerSeries α K} (E : LocalEtaleExpansion φ) :
+    ∃ F : AffineEtaleChart K α, φ ∈ F.expansion.range := by
+  obtain ⟨x,y,hy⟩ := IsLocalization.exists_mk'_eq E.denominators E.germ
+  let T := Localization.Away (y : E.S)
+  let g := E.expansion.comp (algebraMap E.S E.L)
+  have hu : IsUnit (g y) := (IsLocalization.map_units E.L y).map E.expansion
+  let H : T →+* MvPowerSeries α K := IsLocalization.Away.lift (y : E.S) hu
+  let y' : Submonoid.powers (y : E.S) := ⟨y,⟨1,by simp⟩⟩
+  let s' : T := IsLocalization.mk' T x y'
+  let : Algebra.Etale (MvPolynomial α K) T := Algebra.Etale.comp _ E.S _
+  have hH (p : MvPolynomial α K) : H (algebraMap _ T p) = algebraMap _ _ p := by
+    rw [IsScalarTower.algebraMap_apply (MvPolynomial α K) E.S T,
+      IsLocalization.Away.lift_eq]
+    change E.expansion (algebraMap E.S E.L (algebraMap (MvPolynomial α K) E.S p)) = _
+    rw [← IsScalarTower.algebraMap_apply]
+    exact E.coordinates p
+  let F : AffineEtaleChart K α :=
+    ⟨T, inferInstance, inferInstance, inferInstance, ⟨H,hH⟩⟩
+  refine ⟨F, s', ?_⟩
+  change H s' = φ
+  apply Eq.trans _ E.represents
+  rw [← hy]
+  apply hu.mul_right_cancel
+  have h₁ := congrArg H (IsLocalization.mk'_spec T x y')
+  have h₂ := congrArg E.expansion (IsLocalization.mk'_spec E.L x y)
+  simp only [map_mul,IsLocalization.Away.lift_eq,H,y'] at h₁
+  simpa only [map_mul,g,RingHom.comp_apply] using h₁.trans h₂.symm
+
+theorem common_affine_chart (s : Finset (MvPowerSeries α K))
+    (hs : ∀ φ ∈ s, Nonempty (LocalEtaleExpansion φ)) :
+    ∃ E : AffineEtaleChart K α, ∀ φ ∈ s, φ ∈ E.expansion.range := by
+  classical
+  induction s using Finset.induction_on with
+  | empty => exact ⟨AffineEtaleChart.base, by simp⟩
+  | @insert φ s hφ ih =>
+      obtain ⟨E,hE⟩ := ih (fun ψ hψ ↦ hs ψ (Finset.mem_insert_of_mem hψ))
+      obtain ⟨F,hF⟩ := (hs φ (Finset.mem_insert_self _ _)).some.affine
+      refine ⟨E.prod F, ?_⟩
+      intro ψ hψ
+      rcases Finset.mem_insert.mp hψ with rfl | hψ
+      · obtain ⟨x,hx⟩ := hF
+        rw [← hx]
+        exact E.range_right F x
+      · obtain ⟨x,hx⟩ := hE ψ hψ
+        rw [← hx]
+        exact E.range_left F x
+
+end BoundaryOnly.FormalObstruction.FormalCorrection
+
+namespace BoundaryOnly.FormalObstruction.AlgebraicReplacement
+
+theorem coordinate_series_flat {K α : Type*} [Field K] [Finite α] :
+    Module.Flat (MvPolynomial α K) (MvPowerSeries α K) := by
+  exact Module.Flat.of_linearEquiv
+    (MvPowerSeries.toAdicCompletionAlgEquiv α K).toLinearEquiv
+
+theorem etale_expansion_faithfullyFlat
+    {K α E : Type*} [Field K] [Finite α] [CommRing E]
+    [Algebra (MvPolynomial α K) E]
+    [Algebra.FormallyUnramified (MvPolynomial α K) E]
+    [Algebra.EssFiniteType (MvPolynomial α K) E]
+    [Algebra E (MvPowerSeries α K)]
+    [IsScalarTower (MvPolynomial α K) E (MvPowerSeries α K)]
+    [IsLocalRing E] [IsLocalHom (algebraMap E (MvPowerSeries α K))] :
+    Module.FaithfullyFlat E (MvPowerSeries α K) := by
+  let := coordinate_series_flat (K := K) (α := α)
+  let : Module.Flat E (MvPowerSeries α K) :=
+    Algebra.FormallyUnramified.flat_of_restrictScalars
+      (MvPolynomial α K) E (MvPowerSeries α K)
+  exact Module.FaithfullyFlat.of_flat_of_isLocalHom
+
+theorem etale_expansion_mem_iff
+    {K α E : Type*} [Field K] [Finite α] [CommRing E]
+    [Algebra (MvPolynomial α K) E]
+    [Algebra.FormallyUnramified (MvPolynomial α K) E]
+    [Algebra.EssFiniteType (MvPolynomial α K) E]
+    [Algebra E (MvPowerSeries α K)]
+    [IsScalarTower (MvPolynomial α K) E (MvPowerSeries α K)]
+    [IsLocalRing E] [IsLocalHom (algebraMap E (MvPowerSeries α K))]
+    (I : Ideal E) (x : E) :
+    algebraMap E (MvPowerSeries α K) x ∈ I.map (algebraMap E (MvPowerSeries α K)) ↔
+      x ∈ I := by
+  let := etale_expansion_faithfullyFlat (K := K) (α := α) (E := E)
+  change x ∈ (I.map (algebraMap E (MvPowerSeries α K))).comap
+    (algebraMap E (MvPowerSeries α K)) ↔ _
+  rw [Ideal.comap_map_eq_self_of_faithfullyFlat]
+
+end BoundaryOnly.FormalObstruction.AlgebraicReplacement
+
+namespace BoundaryOnly.FormalObstruction.FormalCorrection
+open MvPowerSeries
+variable {K α : Type} [Field K] [Finite α]
+
+namespace AffineEtaleChart
+
+def point (E : AffineEtaleChart K α) : Ideal E.S :=
+  RingHom.ker ((constantCoeff : MvPowerSeries α K →+* K).comp E.expansion.toRingHom)
+
+instance (E : AffineEtaleChart K α) : (point E).IsPrime := RingHom.ker_isPrime _
+
+abbrev LocalRing (E : AffineEtaleChart K α) := Localization.AtPrime E.point
+
+omit [Finite α] in
+lemma outside_point_unit [Finite α] (E : AffineEtaleChart K α) (y : E.point.primeCompl) :
+    IsUnit (E.expansion y) := by
+  rw [MvPowerSeries.isUnit_iff_constantCoeff, isUnit_iff_ne_zero]
+  exact y.property
+
+noncomputable def localExpansion (E : AffineEtaleChart K α) :
+    E.LocalRing →ₐ[MvPolynomial α K] MvPowerSeries α K :=
+  IsLocalization.liftAlgHom E.outside_point_unit
+
+@[simp] lemma localExpansion_map (E : AffineEtaleChart K α) (x : E.S) :
+    E.localExpansion (algebraMap E.S E.LocalRing x) = E.expansion x :=
+  IsLocalization.lift_eq E.outside_point_unit x
+
+instance localExpansion_isLocalHom (E : AffineEtaleChart K α) :
+    IsLocalHom E.localExpansion := by
+  constructor
+  intro z hz
+  obtain ⟨x,y,rfl⟩ := IsLocalization.exists_mk'_eq E.point.primeCompl z
+  apply (IsLocalization.AtPrime.isUnit_mk'_iff E.LocalRing E.point x y).mpr
+  have hxy := congrArg E.localExpansion (IsLocalization.mk'_spec E.LocalRing x y)
+  simp only [map_mul, localExpansion_map] at hxy
+  have hu : IsUnit (E.expansion x) := hxy ▸ (hz.mul (E.outside_point_unit y))
+  exact (MvPowerSeries.isUnit_iff_constantCoeff.mp hu).ne_zero
+
+noncomputable instance localAlgebra (E : AffineEtaleChart K α) :
+    Algebra E.LocalRing (MvPowerSeries α K) := E.localExpansion.toRingHom.toAlgebra
+
+instance localTower (E : AffineEtaleChart K α) :
+    IsScalarTower (MvPolynomial α K) E.LocalRing (MvPowerSeries α K) :=
+  IsScalarTower.of_algebraMap_eq (fun p ↦ (E.localExpansion.commutes p).symm)
+
+instance localAlgebra_isLocalHom (E : AffineEtaleChart K α) :
+    IsLocalHom (algebraMap E.LocalRing (MvPowerSeries α K)) :=
+  ⟨fun x hx ↦ isUnit_of_map_unit E.localExpansion x hx⟩
+
+instance localEssFiniteType (E : AffineEtaleChart K α) :
+    Algebra.EssFiniteType (MvPolynomial α K) E.LocalRing :=
+  Algebra.EssFiniteType.comp (MvPolynomial α K) E.S E.LocalRing
+
+instance localFormallyEtale (E : AffineEtaleChart K α) :
+    Algebra.FormallyEtale (MvPolynomial α K) E.LocalRing := inferInstance
+
+theorem localFaithfullyFlat (E : AffineEtaleChart K α) :
+    Module.FaithfullyFlat E.LocalRing (MvPowerSeries α K) :=
+  BoundaryOnly.FormalObstruction.AlgebraicReplacement.etale_expansion_faithfullyFlat
+
+lemma localRange (E : AffineEtaleChart K α) {φ : MvPowerSeries α K}
+    (h : φ ∈ E.expansion.range) : φ ∈ E.localExpansion.range := by
+  obtain ⟨x,rfl⟩ := h
+  exact ⟨algebraMap E.S E.LocalRing x,E.localExpansion_map x⟩
+
+noncomputable def localGerm (E : AffineEtaleChart K α) (x : E.LocalRing) :
+    LocalEtaleExpansion (E.localExpansion x) where
+  S := E.S
+  L := E.LocalRing
+  ringS := inferInstance
+  baseS := inferInstance
+  etale := inferInstance
+  ringL := inferInstance
+  fromS := inferInstance
+  baseL := inferInstance
+  tower := inferInstance
+  denominators := E.point.primeCompl
+  localization := inferInstance
+  expansion := E.localExpansion.toRingHom
+  coordinates p := E.localExpansion.commutes p
+  germ := x
+  represents := rfl
+
+end AffineEtaleChart
+end BoundaryOnly.FormalObstruction.FormalCorrection
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/AlgebraicObstruction/EtaleCoefficients.lean b/lean/OAI/Algebra/AlgebraicObstruction/EtaleCoefficients.lean
new file mode 100644
index 0000000000000000000000000000000000000000..2356b3fe9d88a07cb195590250ba11ffdeacac1c
--- /dev/null
+++ b/lean/OAI/Algebra/AlgebraicObstruction/EtaleCoefficients.lean
@@ -0,0 +1,359 @@
+import Mathlib
+import OAI.Algebra.FrobeniusObstruction.Obstruction
+import OAI.Algebra.AlgebraicObstruction.WitnessDescent
+
+namespace OAI
+
+noncomputable section
+open scoped BigOperators
+
+namespace BoundaryOnly.FormalObstruction.FormalCorrection
+open MvPowerSeries
+open scoped Classical
+variable {K α ι σ : Type*} [CommRing K]
+
+def centerPolynomial (e : σ ≃ ι) (c : ι → K) :
+    MvPolynomial ι (MvPolynomial α K) →+* MvPolynomial (α ⊕ σ) K :=
+  MvPolynomial.eval₂Hom (MvPolynomial.rename Sum.inl).toRingHom
+    (fun i => MvPolynomial.C (c i) + MvPolynomial.X (Sum.inr (e.symm i)))
+
+def pointEval (c : ι → K) : MvPolynomial ι (MvPolynomial α K) →+* K :=
+  MvPolynomial.eval₂Hom MvPolynomial.constantCoeff c
+
+theorem pderiv_rename_inl (j : σ) (p : MvPolynomial α K) :
+    MvPolynomial.pderiv (Sum.inr j) (MvPolynomial.rename Sum.inl p) = 0 := by
+  induction p using MvPolynomial.induction_on with
+  | C a => simp
+  | add p q hp hq => simp [hp,hq]
+  | mul_X p a h => simp [Derivation.leibniz,h,MvPolynomial.pderiv_X]
+
+theorem centerPolynomial_derivative (e : σ ≃ ι) (c : ι → K)
+    (p : MvPolynomial ι (MvPolynomial α K)) (j : σ) :
+    MvPolynomial.pderiv (Sum.inr j) (centerPolynomial e c p) =
+      centerPolynomial e c (MvPolynomial.pderiv (e j) p) := by
+  induction p using MvPolynomial.induction_on with
+  | C a => simp [centerPolynomial,MvPolynomial.eval₂Hom,pderiv_rename_inl]
+  | add p q hp hq => simp only [map_add,hp,hq]
+  | mul_X p a h =>
+      simp only [map_mul,Derivation.leibniz,smul_eq_mul,map_add,h]
+      simp only [centerPolynomial,MvPolynomial.pderiv_X]
+      have he : e.symm a = j ↔ a = e j := by
+        constructor
+        · intro h; simpa using congrArg e h
+        · intro h; simp [h]
+      simp [Pi.single_apply,he,apply_ite]
+
+theorem centerPolynomial_constant (e : σ ≃ ι) (c : ι → K)
+    (p : MvPolynomial ι (MvPolynomial α K)) :
+    (centerPolynomial e c p).coeff 0 = pointEval c p := by
+  change MvPolynomial.constantCoeff (centerPolynomial e c p) = pointEval c p
+  have hh : MvPolynomial.constantCoeff.comp (centerPolynomial (α := α) e c) = pointEval c := by
+    apply MvPolynomial.ringHom_ext
+    · intro a
+      simp [centerPolynomial,pointEval,MvPolynomial.eval₂Hom]
+    · intro i
+      simp [centerPolynomial,pointEval,MvPolynomial.eval₂Hom]
+  exact congrArg (fun h => h p) hh
+
+theorem centerPolynomial_linear (e : σ ≃ ι) (c : ι → K)
+    (p : MvPolynomial ι (MvPolynomial α K)) (j : σ) :
+    (centerPolynomial e c p).coeff (Finsupp.single (Sum.inr j) 1) =
+      pointEval c (MvPolynomial.pderiv (e j) p) := by
+  rw [← centerPolynomial_constant e c,← centerPolynomial_derivative e c]
+  simp [MvPolynomial.coeff_pderiv]
+
+theorem centerPolynomial_solution [Finite α] [Finite σ] (e : σ ≃ ι) (c : ι → K)
+    (z : ι → MvPowerSeries α K) (hz : ∀ i, constantCoeff (z i) = c i)
+    (p : MvPolynomial ι (MvPolynomial α K)) :
+    subst (Sum.elim X (fun j => z (e j) - C (c (e j))))
+      (centerPolynomial e c p).toMvPowerSeries =
+    MvPolynomial.eval₂ MvPolynomial.coeToMvPowerSeries.ringHom z p := by
+  have hc : ∀ j, constantCoeff
+      (Sum.elim X (fun j => z (e j) - C (c (e j))) j) = 0 := by
+    intro j; cases j <;> simp [hz]
+  let hs := hasSubst_of_constantCoeff_zero hc
+  rw [← substAlgHom_apply hs,substAlgHom_coe]
+  have hh : (MvPolynomial.aeval (Sum.elim X
+      (fun j => z (e j) - C (c (e j))))).toRingHom.comp (centerPolynomial e c) =
+      MvPolynomial.eval₂Hom MvPolynomial.coeToMvPowerSeries.ringHom z := by
+    apply MvPolynomial.ringHom_ext
+    · intro a
+      induction a using MvPolynomial.induction_on with
+      | C r => simp [centerPolynomial,MvPolynomial.eval₂Hom,MvPowerSeries.algebraMap_apply]
+      | add p q hp hq => simpa only [map_add] using congrArg₂ (· + ·) hp hq
+      | mul_X p j hp =>
+          simpa [centerPolynomial,MvPolynomial.eval₂Hom] using (congrArg (· * X j) hp)
+    · intro i
+      simp [centerPolynomial,MvPolynomial.eval₂Hom,MvPowerSeries.algebraMap_apply]
+  exact congrArg (fun h => h p) hh
+
+end BoundaryOnly.FormalObstruction.FormalCorrection
+
+namespace BoundaryOnly.FormalObstruction.FormalCorrection
+open MvPowerSeries
+open scoped Classical
+variable {K α ι σ S : Type*} [CommRing K] [Fintype α]
+  [CommRing S] [Algebra (MvPolynomial α K) S] [Fintype ι] [Fintype σ]
+
+theorem finite_ring_submersive
+    (P : Algebra.SubmersivePresentation (MvPolynomial α K) S ι σ)
+    (hdim : P.dimension = 0) (f : S →+* MvPowerSeries α K)
+    (hf : ∀ p : MvPolynomial α K, f (algebraMap _ S p) = p.toMvPowerSeries)
+    (constants : Finset K) :
+    ∃ R : Subalgebra ℤ K, Algebra.FiniteType ℤ R ∧
+      (∀ c ∈ constants, c ∈ R) ∧ ∀ i, coefficientsIn R (f (P.val i)) := by
+  have hcard : Nat.card ι ≤ Nat.card σ := by
+    exact Nat.sub_eq_zero_iff_le.mp hdim
+  let e : σ ≃ ι := Equiv.ofBijective P.map (P.map_inj.bijective_of_nat_card_le hcard)
+  let z : ι → MvPowerSeries α K := fun i => f (P.val i)
+  let c : ι → K := fun i => constantCoeff (z i)
+  let w : σ → MvPowerSeries α K := fun j => z (e j) - C (c (e j))
+  let F : σ → MvPolynomial (α ⊕ σ) K := fun j => centerPolynomial e c (P.relation j)
+  let ev : MvPolynomial ι (MvPolynomial α K) →+* MvPowerSeries α K :=
+    f.comp (MvPolynomial.aeval P.val).toRingHom
+  have hev : ev = MvPolynomial.eval₂Hom MvPolynomial.coeToMvPowerSeries.ringHom z := by
+    apply MvPolynomial.ringHom_ext
+    · intro p
+      simpa [ev] using hf p
+    · intro i; simp [ev,z]
+  have hpoint : pointEval c = constantCoeff.comp ev := by
+    apply MvPolynomial.ringHom_ext
+    · intro p
+      simp only [pointEval,MvPolynomial.eval₂Hom_C,RingHom.comp_apply,hev,
+        MvPolynomial.eval₂Hom_C]
+      rfl
+    · intro i; simp [pointEval,ev,c,z]
+  have hF0 : ∀ j, (F j).coeff 0 = 0 := by
+    intro j
+    rw [show F j = centerPolynomial e c (P.relation j) from rfl,
+      centerPolynomial_constant,hpoint]
+    simp [ev,P.aeval_val_relation]
+  have hw : ∀ j, constantCoeff (w j) = 0 := by intro j; simp [w,c]
+  have hF : ∀ j, subst (Sum.elim X w) (F j).toMvPowerSeries = 0 := by
+    intro j
+    rw [show F j = centerPolynomial e c (P.relation j) from rfl,
+      centerPolynomial_solution e c z (fun _ => rfl)]
+    change MvPolynomial.eval₂Hom MvPolynomial.coeToMvPowerSeries.ringHom z (P.relation j) = 0
+    rw [← hev]
+    simp [ev,P.aeval_val_relation]
+  have hJ : internalJacobian F =
+      ((constantCoeff.comp ev).mapMatrix P.jacobiMatrix).transpose := by
+    ext i j
+    change (F i).coeff (Finsupp.single (Sum.inr j) 1) = _
+    rw [show F i = centerPolynomial e c (P.relation i) from rfl,centerPolynomial_linear,hpoint]
+    simp [Matrix.transpose_apply,RingHom.mapMatrix_apply,P.jacobiMatrix_apply,e]
+  have hdet : IsUnit (internalJacobian F).det := by
+    rw [hJ,Matrix.det_transpose,← RingHom.map_det]
+    have hunit := P.jacobian_isUnit.map (constantCoeff.comp f)
+    simpa only [P.jacobian_eq_jacobiMatrix_det,P.algebraMap_eq,RingHom.comp_apply,ev,
+      AlgHom.toRingHom_eq_coe] using hunit
+  obtain ⟨R,hR,hconst,hwR⟩ := finite_ring_nonsingular F hF0 hdet
+    (constants ∪ Finset.univ.image c) w hw hF
+  refine ⟨R,hR,fun x hx => hconst x (Finset.mem_union_left _ hx),?_⟩
+  intro i d
+  have hc : c i ∈ R := hconst (c i) (Finset.mem_union_right _ (Finset.mem_image.mpr ⟨i,by simp,rfl⟩))
+  have hh : f (P.val i) = w (e.symm i) + C (c i) := by simp [w,z]
+  rw [hh,map_add]
+  apply R.add_mem (hwR _ d)
+  by_cases hd : d = 0
+  · simpa [hd] using hc
+  · simp [coeff_C,hd,R.zero_mem]
+
+end BoundaryOnly.FormalObstruction.FormalCorrection
+
+namespace BoundaryOnly.FormalObstruction.FormalCorrection
+open MvPowerSeries
+open scoped Classical
+variable {K α ι : Type*} [CommRing K]
+
+def seriesCoefficientRing (R : Subalgebra ℤ K) : Subring (MvPowerSeries α K) where
+  carrier := {f | coefficientsIn R f}
+  zero_mem' := by intro e; simp [R.zero_mem]
+  one_mem' := by
+    intro e
+    by_cases he : e = 0 <;> simp [coeff_one,he,R.zero_mem,R.one_mem]
+  add_mem' := by intro f g hf hg e; simpa using R.add_mem (hf e) (hg e)
+  mul_mem' := by
+    intro f g hf hg e
+    rw [coeff_mul]
+    exact R.sum_mem (fun x hx => R.mul_mem (hf x.1) (hg x.2))
+  neg_mem' := by intro f hf e; simpa using R.neg_mem (hf e)
+
+theorem nested_polynomial_finite_coefficients
+    (p : MvPolynomial ι (MvPolynomial α K)) :
+    ∃ s : Finset K, ∀ d e, (p.coeff d).coeff e = 0 ∨ (p.coeff d).coeff e ∈ s := by
+  refine ⟨p.support.biUnion (fun d => (p.coeff d).coeffs),?_⟩
+  intro d e
+  by_cases hz : (p.coeff d).coeff e = 0
+  · exact Or.inl hz
+  · right
+    apply Finset.mem_biUnion.mpr
+    refine ⟨d,?_,MvPolynomial.coeff_mem_coeffs e hz⟩
+    apply MvPolynomial.mem_support_iff.mpr
+    intro h
+    simp [h] at hz
+
+theorem coefficientsIn_polynomial_eval (R : Subalgebra ℤ K)
+    (p : MvPolynomial ι (MvPolynomial α K))
+    (hp : ∀ d e, (p.coeff d).coeff e ∈ R)
+    (z : ι → MvPowerSeries α K) (hz : ∀ i, coefficientsIn R (z i)) :
+    coefficientsIn R (MvPolynomial.eval₂ MvPolynomial.coeToMvPowerSeries.ringHom z p) := by
+  change MvPolynomial.eval₂ _ z p ∈ seriesCoefficientRing R
+  rw [MvPolynomial.eval₂_eq]
+  apply (seriesCoefficientRing R).sum_mem
+  intro d hd
+  apply (seriesCoefficientRing R).mul_mem
+  · change ∀ e, coeff e (p.coeff d).toMvPowerSeries ∈ R
+    exact hp d
+  · apply (seriesCoefficientRing R).prod_mem
+    intro i hi
+    exact (seriesCoefficientRing R).pow_mem (hz i) _
+
+end BoundaryOnly.FormalObstruction.FormalCorrection
+
+namespace BoundaryOnly.FormalObstruction.FormalCorrection
+open MvPowerSeries
+open scoped Classical
+variable {K α S : Type*} [CommRing K] [Fintype α]
+  [CommRing S] [Algebra (MvPolynomial α K) S]
+
+theorem finite_ring_etale_image [Algebra.Etale (MvPolynomial α K) S]
+    (f : S →+* MvPowerSeries α K)
+    (hf : ∀ p : MvPolynomial α K, f (algebraMap _ S p) = p.toMvPowerSeries)
+    (s : S) (constants : Finset K) :
+    ∃ R : Subalgebra ℤ K, Algebra.FiniteType ℤ R ∧
+      (∀ c ∈ constants, c ∈ R) ∧ coefficientsIn R (f s) := by
+  have hh : Algebra.IsStandardSmoothOfRelativeDimension 0 (MvPolynomial α K) S :=
+    Algebra.Etale.iff_isStandardSmoothOfRelativeDimension_zero.mp inferInstance
+  obtain ⟨ι,σ,hσ,hι,P,hdim⟩ := hh.out
+  let : Fintype ι := Fintype.ofFinite ι
+  let : Fintype σ := Fintype.ofFinite σ
+  obtain ⟨c,hc⟩ := nested_polynomial_finite_coefficients (P.σ s)
+  obtain ⟨R,hR,hconst,hval⟩ := finite_ring_submersive P hdim f hf (constants ∪ c)
+  refine ⟨R,hR,fun x hx => hconst x (Finset.mem_union_left _ hx),?_⟩
+  have hev : f.comp (MvPolynomial.aeval P.val).toRingHom =
+      MvPolynomial.eval₂Hom MvPolynomial.coeToMvPowerSeries.ringHom (fun i => f (P.val i)) := by
+    apply MvPolynomial.ringHom_ext
+    · intro p; simpa using hf p
+    · intro i; simp
+  have heq := congrArg (fun h => h (P.σ s)) hev
+  change f ((MvPolynomial.aeval P.val) (P.σ s)) = _ at heq
+  rw [P.aeval_val_σ] at heq
+  rw [heq]
+  apply coefficientsIn_polynomial_eval R (P.σ s) _ _ hval
+  intro d e
+  rcases hc d e with hz | hm
+  · rw [hz]; exact R.zero_mem
+  · exact hconst _ (Finset.mem_union_right _ hm)
+
+end BoundaryOnly.FormalObstruction.FormalCorrection
+
+namespace BoundaryOnly.FormalObstruction.FormalCorrection
+open MvPowerSeries
+open scoped Classical
+variable {K α S L : Type*} [CommRing K] [Fintype α]
+  [CommRing S] [Algebra (MvPolynomial α K) S]
+  [CommRing L] [Algebra S L] [Algebra (MvPolynomial α K) L]
+  [IsScalarTower (MvPolynomial α K) S L]
+
+theorem finite_ring_etale_localization [Algebra.Etale (MvPolynomial α K) S]
+    (M : Submonoid S) [IsLocalization M L]
+    (f : L →+* MvPowerSeries α K)
+    (hf : ∀ p : MvPolynomial α K, f (algebraMap _ L p) = p.toMvPowerSeries)
+    (s : L) (constants : Finset K) :
+    ∃ R : Subalgebra ℤ K, Algebra.FiniteType ℤ R ∧
+      (∀ c ∈ constants, c ∈ R) ∧ coefficientsIn R (f s) := by
+  obtain ⟨x,y,rfl⟩ := IsLocalization.exists_mk'_eq M s
+  let T := Localization.Away (y : S)
+  let g := f.comp (algebraMap S L)
+  have hu : IsUnit (g y) := (IsLocalization.map_units L y).map f
+  let H : T →+* MvPowerSeries α K := IsLocalization.Away.lift (y : S) hu
+  let y' : Submonoid.powers (y : S) := ⟨y,⟨1,by simp⟩⟩
+  let s' : T := IsLocalization.mk' T x y'
+  let : Algebra.Etale (MvPolynomial α K) T := Algebra.Etale.comp (MvPolynomial α K) S T
+  have hH (p : MvPolynomial α K) : H (algebraMap _ T p) = p.toMvPowerSeries := by
+    rw [IsScalarTower.algebraMap_apply (MvPolynomial α K) S T,
+      IsLocalization.Away.lift_eq]
+    change f (algebraMap S L (algebraMap (MvPolynomial α K) S p)) = _
+    rw [← IsScalarTower.algebraMap_apply]
+    exact hf p
+  have hs : H s' = f (IsLocalization.mk' L x y) := by
+    apply hu.mul_right_cancel
+    have h₁ := congrArg H (IsLocalization.mk'_spec T x y')
+    have h₂ := congrArg f (IsLocalization.mk'_spec L x y)
+    simp only [map_mul,IsLocalization.Away.lift_eq,H,y'] at h₁
+    simpa only [map_mul,g,RingHom.comp_apply] using h₁.trans h₂.symm
+  rw [← hs]
+  exact finite_ring_etale_image H hH s' constants
+
+end BoundaryOnly.FormalObstruction.FormalCorrection
+
+namespace BoundaryOnly.FormalObstruction.FormalCorrection
+open MvPowerSeries
+
+structure LocalEtaleExpansion {K α : Type*} [CommRing K]
+    (φ : MvPowerSeries α K) where
+  S : Type
+  L : Type
+  ringS : CommRing S
+  baseS : Algebra (MvPolynomial α K) S
+  etale : Algebra.Etale (MvPolynomial α K) S
+  ringL : CommRing L
+  fromS : Algebra S L
+  baseL : Algebra (MvPolynomial α K) L
+  tower : IsScalarTower (MvPolynomial α K) S L
+  denominators : Submonoid S
+  localization : IsLocalization denominators L
+  expansion : L →+* MvPowerSeries α K
+  coordinates : ∀ p : MvPolynomial α K,
+    expansion (algebraMap _ L p) = p.toMvPowerSeries
+  germ : L
+  represents : expansion germ = φ
+
+attribute [instance] LocalEtaleExpansion.ringS LocalEtaleExpansion.baseS
+  LocalEtaleExpansion.etale LocalEtaleExpansion.ringL LocalEtaleExpansion.fromS
+  LocalEtaleExpansion.baseL LocalEtaleExpansion.tower LocalEtaleExpansion.localization
+
+theorem LocalEtaleExpansion.finite_coefficients {K α : Type*} [CommRing K]
+    [Fintype α] {φ : MvPowerSeries α K} (E : LocalEtaleExpansion φ)
+    (constants : Finset K) :
+    ∃ R : Subalgebra ℤ K, Algebra.FiniteType ℤ R ∧
+      (∀ c ∈ constants, c ∈ R) ∧ coefficientsIn R φ := by
+  rw [← E.represents]
+  exact finite_ring_etale_localization E.denominators E.expansion E.coordinates E.germ constants
+
+end BoundaryOnly.FormalObstruction.FormalCorrection
+
+namespace BoundaryOnly.FormalObstruction.CoefficientRing
+open MvPowerSeries FormalCorrection
+open scoped Classical
+variable {K : Type*} [CommRing K] {d : ℕ} {n : Fin d → ℕ}
+
+theorem QuadraticWitnesses.finite_ring_etale (Q : QuadraticData (R := K) (n := n))
+    (W : QuadraticWitnesses Q)
+    (h : ∀ e, LocalEtaleExpansion (W.entry Q e)) :
+    ∃ R : Subalgebra ℤ K, Algebra.FiniteType ℤ R ∧
+      Nonempty (QuadraticData (R := R) (n := n)) := by
+  obtain ⟨inv,hi⟩ := isUnit_iff_exists_inv.mp Q.complementary
+  have hf : ∀ e, ∃ R : Subalgebra ℤ K, Algebra.FiniteType ℤ R ∧
+      coefficientsIn R (W.entry Q e) := by
+    intro e
+    obtain ⟨R,hR,_,he⟩ := (h e).finite_coefficients ∅
+    exact ⟨R,hR,he⟩
+  obtain ⟨R,hR,hc,he⟩ := finite_coefficient_family (W.entry Q) hf {inv}
+  refine ⟨R,hR,W.descend Q R (fun i => he (.wall i)) (fun c => he (.graph c))
+    (fun c e => he (.quadratic c e)) (fun t c => he (.positive t c))
+    (fun t c => he (.negative t c)) inv (hc inv (Finset.mem_singleton_self inv)) hi⟩
+
+theorem no_etale_quadratic_data [IsDomain K] [CharZero K] (hd : 5 ≤ d)
+    (Q : QuadraticData (R := K) (n := n)) (W : QuadraticWitnesses Q)
+    (h : ∀ e, LocalEtaleExpansion (W.entry Q e)) : False := by
+  obtain ⟨R,hR,hQ⟩ := W.finite_ring_etale Q h
+  let : Algebra.FiniteType ℤ R := hR
+  exact no_integral_quadratic_data R d hd n hQ
+
+end BoundaryOnly.FormalObstruction.CoefficientRing
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/AlgebraicObstruction/FiniteCoefficients.lean b/lean/OAI/Algebra/AlgebraicObstruction/FiniteCoefficients.lean
new file mode 100644
index 0000000000000000000000000000000000000000..3b445ef1402d18fc43bff3dafbb698325558f772
--- /dev/null
+++ b/lean/OAI/Algebra/AlgebraicObstruction/FiniteCoefficients.lean
@@ -0,0 +1,309 @@
+import Mathlib
+import OAI.Algebra.FrobeniusObstruction.Obstruction
+import OAI.Algebra.AlgebraicObstruction.ImplicitFunction
+
+namespace OAI
+
+noncomputable section
+open scoped BigOperators
+
+namespace BoundaryOnly.FormalObstruction.FormalCorrection
+open MvPowerSeries
+open scoped Classical
+variable {K σ α ι : Type*} [CommRing K] [Fintype α] [Fintype ι]
+
+def coefficientsIn (R : Subalgebra ℤ K) (f : MvPowerSeries σ K) : Prop :=
+  ∀ e, coeff e f ∈ R
+
+def restrictCoefficients (R : Subalgebra ℤ K) (f : MvPowerSeries σ K)
+    (h : coefficientsIn R f) : MvPowerSeries σ R := fun e => ⟨coeff e f,h e⟩
+
+theorem map_restrictCoefficients (R : Subalgebra ℤ K) (f : MvPowerSeries σ K)
+    (h : coefficientsIn R f) : map R.val.toRingHom (restrictCoefficients R f h) = f := by
+  ext e; rfl
+
+theorem restrictCoefficients_centered (R : Subalgebra ℤ K) (f : MvPowerSeries σ K)
+    (h : coefficientsIn R f) (hf : constantCoeff f = 0) :
+    constantCoeff (restrictCoefficients R f h) = 0 := by
+  apply Subtype.ext
+  exact hf
+
+theorem restrictCoefficients_vanishes (R : Subalgebra ℤ K) (f : MvPowerSeries σ K)
+    (h : coefficientsIn R f) {n : ℕ} (hf : Vanishes n f) :
+    Vanishes n (restrictCoefficients R f h) := by
+  intro e he; apply Subtype.ext; exact hf e he
+
+theorem coefficientsIn_map (R : Subalgebra ℤ K) (f : MvPowerSeries σ R) :
+    coefficientsIn R (map R.val.toRingHom f) := fun e => (coeff e f).property
+
+theorem implicit_coefficientsIn (R : Subalgebra ℤ K)
+    (L : ι → MvPowerSeries α K) (H : ι → MvPowerSeries (α ⊕ ι) K)
+    (hL : ∀ i, constantCoeff (L i) = 0) (hH : ∀ i, Vanishes 2 (H i))
+    (hLR : ∀ i, coefficientsIn R (L i)) (hHR : ∀ i, coefficientsIn R (H i))
+    (w : ι → MvPowerSeries α K) (hw : ∀ i, constantCoeff (w i) = 0)
+    (heq : ∀ i, w i = L i + subst (Sum.elim X w) (H i)) :
+    ∀ i, coefficientsIn R (w i) := by
+  let LR := fun i => restrictCoefficients R (L i) (hLR i)
+  let HR := fun i => restrictCoefficients R (H i) (hHR i)
+  obtain ⟨v,⟨hvc,hve⟩,_⟩ := centered_implicit_solution LR HR
+    (fun i => restrictCoefficients_centered R _ _ (hL i))
+    (fun i => restrictCoefficients_vanishes R _ _ (hH i))
+  let vm := fun i => map R.val.toRingHom (v i)
+  have hvm : ∀ i, constantCoeff (vm i) = 0 := by
+    intro i; simp [vm,constantCoeff_map,hvc]
+  have hvarg : ∀ j, constantCoeff (Sum.elim X v j) = 0 := by
+    intro j; cases j <;> simp [hvc]
+  have hmargument : (fun j => map R.val.toRingHom (Sum.elim X v j)) = Sum.elim X vm := by
+    funext j; cases j <;> simp [vm]
+  have hvme : ∀ i, vm i = L i + subst (Sum.elim X vm) (H i) := by
+    intro i
+    have h := congrArg (map R.val.toRingHom) (hve i)
+    simpa only [map_add,map_subst (hasSubst_of_constantCoeff_zero hvarg),hmargument,
+      LR,HR,map_restrictCoefficients] using h
+  obtain ⟨u,_,hu⟩ := centered_implicit_solution L H hL hH
+  have hsame : w = vm := (hu w ⟨hw,heq⟩).trans (hu vm ⟨hvm,hvme⟩).symm
+  rw [hsame]
+  exact fun i => coefficientsIn_map R (v i)
+
+theorem finite_ring_normalized (L : ι → MvPolynomial α K)
+    (H : ι → MvPolynomial (α ⊕ ι) K) (constants : Finset K)
+    (hL : ∀ i, constantCoeff (L i).toMvPowerSeries = 0)
+    (hH : ∀ i, Vanishes 2 (H i).toMvPowerSeries)
+    (w : ι → MvPowerSeries α K) (hw : ∀ i, constantCoeff (w i) = 0)
+    (heq : ∀ i, w i = (L i).toMvPowerSeries +
+      subst (Sum.elim X w) (H i).toMvPowerSeries) :
+    ∃ R : Subalgebra ℤ K, Algebra.FiniteType ℤ R ∧
+      (∀ c ∈ constants, c ∈ R) ∧ ∀ i, coefficientsIn R (w i) := by
+  let s := constants ∪ (Finset.univ.biUnion fun i => (L i).coeffs) ∪
+    (Finset.univ.biUnion fun i => (H i).coeffs)
+  let R := Algebra.adjoin ℤ (s : Set K)
+  have hmem : ∀ c ∈ s, c ∈ R := fun c hc => Algebra.subset_adjoin hc
+  refine ⟨R,(Subalgebra.fg_iff_finiteType R).mp (Subalgebra.fg_adjoin_finset s),?_,?_⟩
+  · intro c hc; apply hmem; simp [s,hc]
+  · apply implicit_coefficientsIn R (fun i => (L i).toMvPowerSeries)
+      (fun i => (H i).toMvPowerSeries) hL hH _ _ w hw heq
+    · intro i e
+      change (L i).coeff e ∈ R
+      by_cases hz : (L i).coeff e = 0
+      · rw [hz]; exact R.zero_mem
+      · apply hmem
+        have hc := MvPolynomial.coeff_mem_coeffs e hz
+        simp only [s,Finset.mem_union,Finset.mem_biUnion,Finset.mem_univ,true_and]
+        exact Or.inl (Or.inr ⟨i,hc⟩)
+    · intro i e
+      change (H i).coeff e ∈ R
+      by_cases hz : (H i).coeff e = 0
+      · rw [hz]; exact R.zero_mem
+      · apply hmem
+        have hc := MvPolynomial.coeff_mem_coeffs e hz
+        simp only [s,Finset.mem_union,Finset.mem_biUnion,Finset.mem_univ,true_and]
+        exact Or.inr ⟨i,hc⟩
+
+end BoundaryOnly.FormalObstruction.FormalCorrection
+
+namespace BoundaryOnly.FormalObstruction.FormalCorrection
+open MvPowerSeries
+open scoped Classical
+variable {K σ α ι : Type*} [CommRing K] [Fintype α] [Fintype ι]
+
+theorem vanishes_two_of_coeff (f : MvPowerSeries σ K)
+    (h0 : coeff 0 f = 0) (h1 : ∀ j, coeff (Finsupp.single j 1) f = 0) :
+    Vanishes 2 f := by
+  intro e he
+  by_cases hz : e.degree = 0
+  · have : e = 0 := (Finsupp.degree_eq_zero_iff e).mp hz
+    simpa only [this] using h0
+  · have hd : e.sum (fun _ n => n) = 1 := by
+      change e.degree = 1
+      omega
+    obtain ⟨j,rfl⟩ := (Finsupp.sum_eq_one_iff e).mp hd
+    exact h1 j
+
+def internalJacobian (F : ι → MvPolynomial (α ⊕ ι) K) : Matrix ι ι K :=
+  fun i j => (F i).coeff (Finsupp.single (Sum.inr j) 1)
+
+def implicitG (F : ι → MvPolynomial (α ⊕ ι) K) (A : Matrix ι ι K) (i : ι) :
+    MvPolynomial (α ⊕ ι) K :=
+  MvPolynomial.X (Sum.inr i) - ∑ j, MvPolynomial.C (A i j) * F j
+
+def implicitL (G : ι → MvPolynomial (α ⊕ ι) K) (i : ι) : MvPolynomial α K :=
+  ∑ a, MvPolynomial.C ((G i).coeff (Finsupp.single (Sum.inl a) 1)) * MvPolynomial.X a
+
+def implicitH (G : ι → MvPolynomial (α ⊕ ι) K) (i : ι) :
+    MvPolynomial (α ⊕ ι) K :=
+  G i - ∑ a, MvPolynomial.C ((G i).coeff (Finsupp.single (Sum.inl a) 1)) *
+    MvPolynomial.X (Sum.inl a)
+
+omit [Fintype α] in
+theorem implicitG_constant [Fintype α] (F : ι → MvPolynomial (α ⊕ ι) K) (A : Matrix ι ι K)
+    (hF : ∀ i, (F i).coeff 0 = 0) (i : ι) : (implicitG F A i).coeff 0 = 0 := by
+  simp [implicitG,MvPolynomial.coeff_C_mul,hF]
+
+omit [Fintype α] in
+theorem implicitG_internal_linear [Fintype α] (F : ι → MvPolynomial (α ⊕ ι) K) (A : Matrix ι ι K)
+    (hA : A * internalJacobian F = 1) (i j : ι) :
+    (implicitG F A i).coeff (Finsupp.single (Sum.inr j) 1) = 0 := by
+  have h := congrArg (fun M : Matrix ι ι K => M i j) hA
+  simp only [Matrix.mul_apply,Matrix.one_apply,internalJacobian] at h
+  simp only [implicitG,MvPolynomial.coeff_sub,MvPolynomial.coeff_sum,
+    MvPolynomial.coeff_sum,MvPolynomial.coeff_C_mul,MvPolynomial.coeff_X,Finsupp.single_left_inj (by decide : (1:ℕ) ≠ 0),
+    Sum.inr.injEq,h,sub_self]
+
+omit [Fintype ι] in
+theorem implicitL_centered [Fintype ι] (G : ι → MvPolynomial (α ⊕ ι) K) (i : ι) :
+    constantCoeff (implicitL G i).toMvPowerSeries = 0 := by
+  change (implicitL G i).coeff 0 = 0
+  simp [implicitL,MvPolynomial.coeff_C_mul]
+
+omit [Fintype ι] in
+theorem implicitH_quadratic [Fintype ι] (G : ι → MvPolynomial (α ⊕ ι) K)
+    (h0 : ∀ i, (G i).coeff 0 = 0)
+    (h1 : ∀ i j, (G i).coeff (Finsupp.single (Sum.inr j) 1) = 0) (i : ι) :
+    Vanishes 2 (implicitH G i).toMvPowerSeries := by
+  apply vanishes_two_of_coeff
+  · change (implicitH G i).coeff 0 = 0
+    simp [implicitH,MvPolynomial.coeff_C_mul,h0]
+  · intro j
+    change (implicitH G i).coeff (Finsupp.single j 1) = 0
+    cases j with
+    | inl a =>
+      simp [implicitH,MvPolynomial.coeff_C_mul,MvPolynomial.coeff_X,
+        Finsupp.single_left_inj (by decide : (1:ℕ) ≠ 0)]
+    | inr j =>
+      simp [implicitH,MvPolynomial.coeff_C_mul,MvPolynomial.coeff_X,
+        Finsupp.single_left_inj (by decide : (1:ℕ) ≠ 0),h1]
+
+theorem polynomial_series_sub (f g : MvPolynomial σ K) :
+    (f-g).toMvPowerSeries = f.toMvPowerSeries-g.toMvPowerSeries :=
+  map_sub MvPolynomial.coeToMvPowerSeries.ringHom f g
+
+theorem polynomial_series_sum {β : Type*} (s : Finset β) (f : β → MvPolynomial σ K) :
+    (∑ b ∈ s, f b).toMvPowerSeries = ∑ b ∈ s, (f b).toMvPowerSeries :=
+  map_sum MvPolynomial.coeToMvPowerSeries.ringHom f s
+
+theorem implicitGH_equation (F : ι → MvPolynomial (α ⊕ ι) K) (A : Matrix ι ι K)
+    (w : ι → MvPowerSeries α K) (hw : ∀ i, constantCoeff (w i) = 0)
+    (hF : ∀ i, subst (Sum.elim X w) (F i).toMvPowerSeries = 0) (i : ι) :
+    w i = (implicitL (implicitG F A) i).toMvPowerSeries +
+      subst (Sum.elim X w) (implicitH (implicitG F A) i).toMvPowerSeries := by
+  have hc : ∀ j, constantCoeff (Sum.elim X w j) = 0 := by
+    intro j; cases j <;> simp [hw]
+  let hs := hasSubst_of_constantCoeff_zero hc
+  have hG : subst (Sum.elim X w) (implicitG F A i).toMvPowerSeries = w i := by
+    rw [← substAlgHom_apply hs]
+    simp only [implicitG,polynomial_series_sub,polynomial_series_sum,MvPolynomial.coe_mul,
+      MvPolynomial.coe_C,MvPolynomial.coe_X,map_sub,map_sum,map_mul,
+      substAlgHom_apply,subst_X hs,subst_C,hF,Sum.elim_inr,mul_zero,Finset.sum_const_zero,sub_zero]
+  have hlinear : subst (Sum.elim X w)
+      (∑ a, MvPolynomial.C ((implicitG F A i).coeff (Finsupp.single (Sum.inl a) 1)) *
+        MvPolynomial.X (Sum.inl a)).toMvPowerSeries =
+      (implicitL (implicitG F A) i).toMvPowerSeries := by
+    rw [← substAlgHom_apply hs]
+    simp only [implicitL,polynomial_series_sum,MvPolynomial.coe_mul,MvPolynomial.coe_C,
+      MvPolynomial.coe_X,map_sum,map_mul,substAlgHom_apply,subst_X hs,subst_C,Sum.elim_inl]
+  rw [implicitH,polynomial_series_sub,subst_sub hs,hG,hlinear]
+  abel
+
+theorem finite_ring_nonsingular (F : ι → MvPolynomial (α ⊕ ι) K)
+    (hF0 : ∀ i, (F i).coeff 0 = 0)
+    (hdet : IsUnit (internalJacobian F).det)
+    (constants : Finset K) (w : ι → MvPowerSeries α K)
+    (hw : ∀ i, constantCoeff (w i) = 0)
+    (hF : ∀ i, subst (Sum.elim X w) (F i).toMvPowerSeries = 0) :
+    ∃ R : Subalgebra ℤ K, Algebra.FiniteType ℤ R ∧
+      (∀ c ∈ constants, c ∈ R) ∧ ∀ i, coefficientsIn R (w i) := by
+  let A := (internalJacobian F)⁻¹
+  let G := implicitG F A
+  have hA : A * internalJacobian F = 1 := Matrix.nonsing_inv_mul _ hdet
+  exact finite_ring_normalized (implicitL G) (implicitH G) constants
+    (implicitL_centered G) (implicitH_quadratic G (implicitG_constant F A hF0)
+      (implicitG_internal_linear F A hA)) w hw (implicitGH_equation F A w hw hF)
+
+end BoundaryOnly.FormalObstruction.FormalCorrection
+
+namespace BoundaryOnly.FormalObstruction.FormalCorrection
+open MvPowerSeries
+open scoped Classical
+variable {K : Type*} [CommRing K]
+
+structure NonsingularPresentation {σ : Type*} (f : MvPowerSeries σ K) where
+  m : ℕ
+  F : Fin m → MvPolynomial (σ ⊕ Fin m) K
+  w : Fin m → MvPowerSeries σ K
+  offset : K
+  output : Fin m
+  equation : ∀ i, subst (Sum.elim X w) (F i).toMvPowerSeries = 0
+  zero : ∀ i, (F i).coeff 0 = 0
+  centered : ∀ i, constantCoeff (w i) = 0
+  nonsingular : IsUnit (internalJacobian F).det
+  represents : f = C offset + w output
+
+theorem NonsingularPresentation.finite_coefficients {σ : Type*} [Fintype σ]
+    {f : MvPowerSeries σ K} (D : NonsingularPresentation f) (constants : Finset K) :
+    ∃ R : Subalgebra ℤ K, Algebra.FiniteType ℤ R ∧
+      (∀ c ∈ constants, c ∈ R) ∧ coefficientsIn R f := by
+  let A : Matrix (Fin D.m) (Fin D.m) K := (internalJacobian D.F)⁻¹
+  let G := implicitG D.F A
+  have hA' := Matrix.nonsing_inv_mul (internalJacobian D.F) D.nonsingular
+  have hA : A * internalJacobian D.F = 1 := by
+    ext i j
+    simpa only [Matrix.one_apply] using congrArg (fun M : Matrix (Fin D.m) (Fin D.m) K => M i j) hA'
+  have hH : ∀ i, Vanishes 2 (implicitH G i).toMvPowerSeries :=
+    implicitH_quadratic G (implicitG_constant D.F A D.zero) (implicitG_internal_linear D.F A (by
+      ext i j
+      have h := congrArg (fun M : Matrix (Fin D.m) (Fin D.m) K => M i j) hA
+      by_cases hij : i = j
+      · simpa only [Matrix.one_apply, ite_eq_left hij] using h
+      · simpa only [Matrix.one_apply, ite_eq_right hij] using h))
+  obtain ⟨R,hR,hconst,hw⟩ := finite_ring_normalized (implicitL G) (implicitH G)
+    (insert D.offset constants) (implicitL_centered G) hH D.w D.centered
+      (implicitGH_equation D.F A D.w D.centered D.equation)
+  refine ⟨R,hR,fun c hc => hconst c (Finset.mem_insert_of_mem hc),?_⟩
+  intro e
+  rw [D.represents,map_add]
+  apply R.add_mem _ (hw _ e)
+  by_cases he : e = 0
+  · simpa [he] using hconst D.offset (Finset.mem_insert_self _ _)
+  · simp [coeff_C,he]
+
+theorem finite_coefficient_family {κ : Type*} [Fintype κ] {σ : κ → Type*}
+    (f : (i : κ) → MvPowerSeries (σ i) K)
+    (hf : ∀ i, ∃ R : Subalgebra ℤ K, Algebra.FiniteType ℤ R ∧ coefficientsIn R (f i))
+    (constants : Finset K) :
+    ∃ R : Subalgebra ℤ K, Algebra.FiniteType ℤ R ∧
+      (∀ c ∈ constants, c ∈ R) ∧ ∀ i, coefficientsIn R (f i) := by
+  choose R hfg hcoef using hf
+  have hgens : ∀ i, ∃ s : Finset K, Algebra.adjoin ℤ (s : Set K) = R i := by
+    intro i
+    exact (Subalgebra.fg_iff_finiteType (R i)).mpr (hfg i)
+  choose s hs using hgens
+  let S := constants ∪ Finset.univ.biUnion s
+  let A := Algebra.adjoin ℤ (S : Set K)
+  have hRA : ∀ i, R i ≤ A := by
+    intro i
+    rw [← hs i]
+    apply Algebra.adjoin_mono
+    intro x hx
+    change x ∈ S
+    simp only [S,Finset.mem_union,Finset.mem_biUnion,Finset.mem_univ,true_and]
+    exact Or.inr ⟨i,hx⟩
+  refine ⟨A,(Subalgebra.fg_iff_finiteType A).mp (Subalgebra.fg_adjoin_finset S),?_,?_⟩
+  · intro c hc
+    exact Algebra.subset_adjoin (show c ∈ S by simp [S,hc])
+  · exact fun i e => hRA i (hcoef i e)
+
+theorem finite_ring_presentations {κ : Type*} [Fintype κ] {σ : κ → Type*}
+    [∀ i, Fintype (σ i)] (f : (i : κ) → MvPowerSeries (σ i) K)
+    (D : ∀ i, NonsingularPresentation (f i)) (constants : Finset K) :
+    ∃ R : Subalgebra ℤ K, Algebra.FiniteType ℤ R ∧
+      (∀ c ∈ constants, c ∈ R) ∧ ∀ i, coefficientsIn R (f i) := by
+  apply finite_coefficient_family f _ constants
+  intro i
+  obtain ⟨R,hR,_,hf⟩ := (D i).finite_coefficients ∅
+  exact ⟨R,hR,hf⟩
+
+end BoundaryOnly.FormalObstruction.FormalCorrection
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/AlgebraicObstruction/FlatDescent.lean b/lean/OAI/Algebra/AlgebraicObstruction/FlatDescent.lean
new file mode 100644
index 0000000000000000000000000000000000000000..3029456eafed134423e17068d8f351ca4e3aa6cf
--- /dev/null
+++ b/lean/OAI/Algebra/AlgebraicObstruction/FlatDescent.lean
@@ -0,0 +1,78 @@
+import Mathlib
+import OAI.Algebra.FrobeniusObstruction.Obstruction
+
+namespace OAI
+
+noncomputable section
+open scoped BigOperators
+
+namespace BoundaryOnly.FormalObstruction.AlgebraicReplacement
+open TensorProduct
+variable {A B M N : Type*} [CommRing A] [CommRing B] [Algebra A B]
+    [Module.FaithfullyFlat A B] [AddCommGroup M] [Module A M]
+    [AddCommGroup N] [Module A N]
+
+theorem mem_of_tmul_mem_baseChange (U : Submodule A N) (x : N)
+    (hx : (1 : B) ⊗ₜ[A] x ∈ U.baseChange B) : x ∈ U := by
+  apply (Submodule.Quotient.mk_eq_zero U).mp
+  apply Module.FaithfullyFlat.tensorProduct_mk_injective (A := A) (B := B) (N ⧸ U)
+  change (1 : B) ⊗ₜ[A] (U.mkQ x) = (1 : B) ⊗ₜ[A] (0 : N ⧸ U)
+  obtain ⟨y,hy⟩ := hx
+  have he : U.mkQ.baseChange B ∘ₗ U.subtype.baseChange B = 0 := by
+    ext scalar
+    simp
+  calc
+    (1 : B) ⊗ₜ[A] (U.mkQ x) = U.mkQ.baseChange B ((1 : B) ⊗ₜ[A] x) := rfl
+    _ = U.mkQ.baseChange B (U.subtype.baseChange B y) := by rw [hy]
+    _ = 0 := LinearMap.congr_fun he y
+    _ = (1 : B) ⊗ₜ[A] (0 : N ⧸ U) := by simp
+
+theorem whole_tuple_descends (f : M →ₗ[A] N) (x : N)
+    (hx : (1 : B) ⊗ₜ[A] x ∈ (LinearMap.range f).baseChange B) :
+    ∃ y : M, f y = x :=
+  mem_of_tmul_mem_baseChange (LinearMap.range f) x hx
+
+theorem kernel_baseChange (f : M →ₗ[A] N) :
+    (LinearMap.ker f).baseChange B = LinearMap.ker (f.baseChange B) := by
+  have h : Function.Exact (LinearMap.ker f).subtype f := by
+    rw [LinearMap.exact_iff]
+    simp
+  have hb := Module.Flat.lTensor_exact B h
+  ext x
+  exact (hb x).symm
+
+end BoundaryOnly.FormalObstruction.AlgebraicReplacement
+
+namespace BoundaryOnly.FormalObstruction.AlgebraicReplacement
+open TensorProduct
+variable {A B : Type*} [CommRing A] [CommRing B] [Algebra A B]
+
+lemma ideal_baseChange_rid (I : Ideal A) :
+    (I.baseChange B).map (AlgebraTensorModule.rid A B B).toLinearMap =
+      I.map (algebraMap A B) := by
+  rw [Submodule.baseChange_eq_span, Submodule.map_span]
+  change Submodule.span B
+    ((AlgebraTensorModule.rid A B B) ''
+      (TensorProduct.mk A B A 1 '' (I : Set A))) = _
+  rw [Set.image_image]
+  change Submodule.span B ((fun a : A ↦ a • (1 : B)) '' (I : Set A)) = _
+  simp only [Algebra.smul_def, mul_one]
+  rfl
+
+lemma tmul_one_mem_ideal_baseChange_iff (I : Ideal A) (b : B) :
+    b ⊗ₜ[A] (1 : A) ∈ I.baseChange B ↔ b ∈ I.map (algebraMap A B) := by
+  rw [← ideal_baseChange_rid]
+  constructor
+  · intro h
+    exact ⟨b ⊗ₜ[A] (1 : A), h, by simp⟩
+  · rintro ⟨x,hx,h⟩
+    have he : x = b ⊗ₜ[A] (1 : A) := by
+      apply (AlgebraTensorModule.rid A B B).injective
+      simpa using h
+    rwa [he] at hx
+
+end BoundaryOnly.FormalObstruction.AlgebraicReplacement
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/AlgebraicObstruction/FormalArcs.lean b/lean/OAI/Algebra/AlgebraicObstruction/FormalArcs.lean
new file mode 100644
index 0000000000000000000000000000000000000000..fe08958dfca38d8ca3f86d1acd12e82fca2cafae
--- /dev/null
+++ b/lean/OAI/Algebra/AlgebraicObstruction/FormalArcs.lean
@@ -0,0 +1,409 @@
+import Mathlib
+import OAI.Algebra.FrobeniusObstruction.Obstruction
+import OAI.Algebra.AlgebraicObstruction.AnalyticReducedness
+
+namespace OAI
+
+noncomputable section
+open scoped BigOperators
+
+namespace BoundaryOnly.FormalObstruction.AlgebraicReplacement.FormalArc
+
+open IsLocalRing
+
+variable {K R : Type*} [Field K] [CommRing R] [Algebra K R]
+
+section Principal
+variable [IsLocalRing R] [IsAdicComplete (maximalIdeal R) R]
+
+theorem complete_principal_powerSeries (π : R)
+    (hπpow : ∀ n : ℕ, π^n ≠ 0)
+    (hmπ : maximalIdeal R = Ideal.span {π})
+    (hres : Function.Surjective
+      ((Ideal.Quotient.mk (maximalIdeal R)).comp (algebraMap K R))) :
+    ∃ e : PowerSeries K ≃ₐ[K] R, e PowerSeries.X = π := by
+  classical
+  let : WithIdeal K := ⟨⊥⟩
+  let : WithIdeal R := ⟨maximalIdeal R⟩
+  have hadic : IsAdic (maximalIdeal R) := rfl
+  have hcomplete := hadic.isAdicComplete_iff.mp
+    (inferInstance : IsAdicComplete (maximalIdeal R) R)
+  let : CompleteSpace R := hcomplete.1
+  let : T2Space R := hcomplete.2
+  have hmap : Continuous (algebraMap K R) :=
+    (WithIdeal.uniformContinuous_of_map_le (f := algebraMap K R) (by
+      change (⊥ : Ideal K).map (algebraMap K R) ≤ maximalIdeal R
+      rw [Ideal.map_bot]
+      exact bot_le)).continuous
+  have hπeval : PowerSeries.HasEval π :=
+    WithIdeal.isTopologicallyNilpotent_of_mem (by
+      change π ∈ maximalIdeal R
+      rw [hmπ]
+      exact Ideal.subset_span (by simp))
+  let f : PowerSeries K →+* R := PowerSeries.eval₂Hom hmap hπeval
+  have hfX : f PowerSeries.X = π := by
+    simp only [f,PowerSeries.coe_eval₂Hom,PowerSeries.eval₂_X]
+  have hfC (c : K) : f (PowerSeries.C c) = algebraMap K R c := by
+    simp only [f,PowerSeries.coe_eval₂Hom,PowerSeries.eval₂_C]
+  have hfI : (Ideal.span {PowerSeries.X}).map f = maximalIdeal R := by
+    rw [Ideal.map_span,Set.image_singleton,hfX,hmπ]
+  have : IsHausdorff ((Ideal.span {PowerSeries.X}).map f) R := by
+    rw [hfI]
+    infer_instance
+  have hsurj : Function.Surjective f := by
+    apply surjective_of_mk_map_comp_surjective (I := Ideal.span {PowerSeries.X}) f
+    rw [hfI]
+    intro z
+    obtain ⟨c,hc⟩ := hres z
+    refine ⟨PowerSeries.C c,?_⟩
+    simpa only [RingHom.comp_apply,hfC] using hc
+  have hinj : Function.Injective f := by
+    apply (injective_iff_map_eq_zero f).mpr
+    intro g hg
+    by_contra hg0
+    have hfactor := PowerSeries.X_pow_order_mul_divXPowOrder (f := g)
+    have hunit := (PowerSeries.isUnit_divided_by_X_pow_order hg0).map f
+    have heq := congrArg f hfactor
+    rw [map_mul,map_pow,hfX,hg] at heq
+    apply hπpow g.order.toNat
+    exact hunit.mul_left_cancel (by simpa only [mul_comm,mul_zero,zero_mul] using heq)
+  let e : PowerSeries K ≃+* R := RingEquiv.ofBijective f ⟨hinj,hsurj⟩
+  exact ⟨{ e with commutes' := fun c ↦ hfC c },hfX⟩
+
+end Principal
+
+variable [IsDomain R] [IsDiscreteValuationRing R]
+
+theorem completeDVR_powerSeries [IsAdicComplete (maximalIdeal R) R]
+    (hres : Function.Surjective
+      ((Ideal.Quotient.mk (maximalIdeal R)).comp (algebraMap K R))) :
+    Nonempty (PowerSeries K ≃ₐ[K] R) := by
+  obtain ⟨π,hπ⟩ := IsDiscreteValuationRing.exists_irreducible R
+  obtain ⟨e,he⟩ := complete_principal_powerSeries π
+    (fun n ↦ pow_ne_zero n hπ.ne_zero) hπ.maximalIdeal_eq hres
+  exact ⟨e⟩
+
+theorem DVR_completion_powerSeries
+    (hres : Function.Surjective
+      ((Ideal.Quotient.mk (maximalIdeal R)).comp (algebraMap K R))) :
+    Nonempty (PowerSeries K ≃ₐ[K] AdicCompletion (maximalIdeal R) R) := by
+  classical
+  let B := AdicCompletion (maximalIdeal R) R
+  obtain ⟨π,hπ⟩ := IsDiscreteValuationRing.exists_irreducible R
+  have hinj : Function.Injective (algebraMap R B) :=
+    AdicCompletion.of_injective (maximalIdeal R) R
+  have hm : maximalIdeal B = Ideal.span {algebraMap R B π} := by
+    exact (AdicCompletion.maximalIdeal_eq_map).trans
+      ((congrArg (Ideal.map (algebraMap R B)) hπ.maximalIdeal_eq).trans
+        (by rw [Ideal.map_span,Set.image_singleton]))
+  have hp (n : ℕ) : (algebraMap R B π)^n ≠ 0 := by
+    rw [← map_pow]
+    exact fun h ↦ pow_ne_zero n hπ.ne_zero (hinj (h.trans (map_zero _).symm))
+  have hr : Function.Surjective
+      ((Ideal.Quotient.mk (maximalIdeal B)).comp (algebraMap K B)) := by
+    intro z
+    obtain ⟨w,hw⟩ := (AdicCompletion.residueField_map_bijective R).2 z
+    obtain ⟨c,hc⟩ := hres w
+    refine ⟨c,?_⟩
+    change residue R (algebraMap K R c) = w at hc
+    change residue B (algebraMap K B c) = z
+    have hx := IsLocalRing.ResidueField.map_residue (algebraMap R B)
+      (algebraMap K R c)
+    rw [hc] at hx
+    rw [hw] at hx
+    rw [← IsScalarTower.algebraMap_apply K R B c] at hx
+    exact hx.symm
+  obtain ⟨e,he⟩ := complete_principal_powerSeries (algebraMap R B π) hp hm hr
+  exact ⟨e⟩
+
+end BoundaryOnly.FormalObstruction.AlgebraicReplacement.FormalArc
+
+namespace BoundaryOnly.FormalObstruction.AlgebraicReplacement.FormalArc
+open IsLocalRing
+variable {K S C : Type*} [Field K] [IsAlgClosed K]
+  [CommRing S] [IsDomain S] [IsLocalRing S] [Algebra K S]
+  [CommRing C] [IsDedekindDomain C]
+  [Algebra S C] [Algebra K C] [IsScalarTower K S C]
+  [Module.Finite S C] [Module.IsTorsionFree S C]
+
+include C in
+
+theorem finite_normalization_arc
+    (hres : Function.Surjective
+      ((Ideal.Quotient.mk (maximalIdeal S)).comp (algebraMap K S)))
+    (b : S) (hb : b ≠ 0) (hbm : b ∈ maximalIdeal S) :
+    ∃ f : S →ₐ[K] PowerSeries K,
+      Function.Injective f ∧ IsLocalHom f.toRingHom := by
+  classical
+  obtain ⟨p,hp,hpm⟩ := Ideal.exists_ideal_over_maximal_of_isIntegral
+    (S := C) (maximalIdeal S) (by
+      rw [(RingHom.injective_iff_ker_eq_bot _).mp (FaithfulSMul.algebraMap_injective S C)]
+      exact bot_le)
+  change p.comap (algebraMap S C) = maximalIdeal S at hpm
+  let : p.IsMaximal := hp
+  have hp0 : p ≠ ⊥ := by
+    intro hz
+    have hx : algebraMap S C b ∈ p := by rw [← Ideal.mem_comap,hpm]; exact hbm
+    rw [hz,Ideal.mem_bot] at hx
+    exact hb ((FaithfulSMul.algebraMap_injective S C) (hx.trans (map_zero _).symm))
+  let D := Localization.AtPrime p
+  let : IsDiscreteValuationRing D :=
+    IsLocalization.AtPrime.isDiscreteValuationRing_of_dedekind_domain C hp0 D
+  have : IsLocalHom (algebraMap S D) := by
+    apply ((IsLocalRing.local_hom_TFAE (algebraMap S D)).out 1 5).mpr
+    change (maximalIdeal D).comap (algebraMap S D) = maximalIdeal S
+    have hd : (maximalIdeal D).comap (algebraMap C D) = p :=
+      IsLocalization.AtPrime.under_maximalIdeal D p
+    rw [IsScalarTower.algebraMap_eq S C D,← Ideal.comap_comap,hd,hpm]
+  have : Module.Finite S p.ResidueField := Module.Finite.trans C p.ResidueField
+  have : Module.Finite K (ResidueField S) :=
+    Module.Finite.of_surjective (Algebra.linearMap K (ResidueField S)) hres
+  have : IsScalarTower K (ResidueField S) p.ResidueField :=
+    IsScalarTower.of_algebraMap_eq fun x ↦ by
+      change algebraMap K p.ResidueField x =
+        algebraMap S p.ResidueField (algebraMap K S x)
+      exact IsScalarTower.algebraMap_apply K S p.ResidueField x
+  have : Module.Finite (ResidueField S) p.ResidueField :=
+    Module.Finite.of_restrictScalars_finite S (ResidueField S) p.ResidueField
+  have : Module.Finite K p.ResidueField :=
+    Module.Finite.trans (ResidueField S) p.ResidueField
+  have hr : Function.Surjective
+      ((Ideal.Quotient.mk (maximalIdeal D)).comp (algebraMap K D)) := by
+    exact (IsAlgClosed.algebraMap_bijective_of_isIntegral (k := K)
+      (K := p.ResidueField)).2
+  obtain ⟨e⟩ := DVR_completion_powerSeries (R := D) hr
+  let g : S →ₐ[K] AdicCompletion (maximalIdeal D) D :=
+    (IsScalarTower.toAlgHom K D _).comp (IsScalarTower.toAlgHom K S D)
+  let f : S →ₐ[K] PowerSeries K := e.symm.toAlgHom.comp g
+  have hdinj : Function.Injective (algebraMap C D) :=
+    IsLocalization.injective D p.primeCompl_le_nonZeroDivisors
+  have hsinj : Function.Injective (algebraMap S D) := by
+    rw [IsScalarTower.algebraMap_eq S C D]
+    exact hdinj.comp (FaithfulSMul.algebraMap_injective S C)
+  have hbinj : Function.Injective (algebraMap D (AdicCompletion (maximalIdeal D) D)) :=
+    AdicCompletion.of_injective (maximalIdeal D) D
+  refine ⟨f,e.symm.injective.comp (hbinj.comp hsinj),?_⟩
+  change IsLocalHom (e.symm.toRingHom.comp
+    ((algebraMap D (AdicCompletion (maximalIdeal D) D)).comp (algebraMap S D)))
+  have : IsLocalHom e.symm.toRingHom := isLocalHom_toRingHom e.symm
+  exact RingHom.isLocalHom_comp _ _
+
+end BoundaryOnly.FormalObstruction.AlgebraicReplacement.FormalArc
+
+namespace BoundaryOnly.FormalObstruction.AlgebraicReplacement.FormalArc
+open IsLocalRing
+variable {K S : Type*} [Field K] [IsAlgClosed K] [CharZero K]
+  [CommRing S] [IsDomain S] [IsLocalRing S] [Algebra K S]
+  [Algebra (PowerSeries K) S] [IsScalarTower K (PowerSeries K) S]
+  [Module.Finite (PowerSeries K) S] [Module.IsTorsionFree (PowerSeries K) S]
+
+attribute [local instance] FractionRing.liftAlgebra FractionRing.isScalarTower_liftAlgebra
+
+theorem finite_powerSeries_curve_arc
+    (hres : Function.Surjective
+      ((Ideal.Quotient.mk (maximalIdeal S)).comp (algebraMap K S)))
+    (b : S) (hb : b ≠ 0) (hbm : b ∈ maximalIdeal S) :
+    ∃ f : S →ₐ[K] PowerSeries K,
+      Function.Injective f ∧ IsLocalHom f.toRingHom := by
+  classical
+  let A := PowerSeries K
+  let L := FractionRing S
+  let C := integralClosure A L
+  have : Module.Finite (FractionRing A) L := inferInstance
+  have : CharZero A := charZero_of_injective_ringHom (PowerSeries.C_injective (R := K))
+  have : CharZero (FractionRing A) := inferInstance
+  have : Algebra.IsSeparable (FractionRing A) L := inferInstance
+  have : IsDedekindDomain C := inferInstance
+  have : Module.Finite A C := IsIntegralClosure.finite A (FractionRing A) L C
+  let j : S →ₐ[A] C := IsIntegralClosure.lift A C L
+  let : Algebra S C := j.toRingHom.toAlgebra
+  have : IsScalarTower A S C := IsScalarTower.of_algebraMap_eq fun a ↦ (j.commutes a).symm
+  have : IsScalarTower S C L := IsScalarTower.of_algebraMap_eq fun s ↦
+    (IsIntegralClosure.algebraMap_lift A C L s).symm
+  let : Algebra K C := ((algebraMap A C).comp (algebraMap K A)).toAlgebra
+  have : IsScalarTower K A C := IsScalarTower.of_algebraMap_eq' rfl
+  have : IsScalarTower K S C := IsScalarTower.of_algebraMap_eq fun k ↦ by
+    change algebraMap A C (algebraMap K A k) = j (algebraMap K S k)
+    rw [IsScalarTower.algebraMap_apply K A S,j.commutes]
+  have : Module.Finite S C := Module.Finite.of_restrictScalars_finite A S C
+  have hinj : Function.Injective (algebraMap S C) := by
+    intro x y h
+    apply IsFractionRing.injective S L
+    rw [IsScalarTower.algebraMap_apply S C L x,
+      IsScalarTower.algebraMap_apply S C L y,h]
+  have : Module.IsTorsionFree S C :=
+    Module.isTorsionFree_iff_algebraMap_injective.mpr hinj
+  exact finite_normalization_arc (C := C) hres b hb hbm
+
+end BoundaryOnly.FormalObstruction.AlgebraicReplacement.FormalArc
+
+namespace BoundaryOnly.FormalObstruction.AlgebraicReplacement.FormalArc
+open IsLocalRing
+open scoped Pointwise
+
+private theorem mem_principal_smul_pi {A ι : Type*} [CommRing A]
+    (a : A) (x : ι → A) :
+    x ∈ (Ideal.span {a} : Ideal A) • (⊤ : Submodule A (ι → A)) ↔
+      ∀ i, x i ∈ Ideal.span {a} := by
+  simp only [Submodule.ideal_span_singleton_smul,
+    Submodule.mem_smul_pointwise_iff_exists,Submodule.mem_top,true_and,
+    Ideal.mem_span_singleton]
+  constructor
+  · rintro ⟨y,rfl⟩ i
+    exact ⟨y i,rfl⟩
+  · intro h
+    choose y hy using h
+    exact ⟨y,funext fun i ↦ (hy i).symm⟩
+
+private theorem principal_pi_precomplete {A ι : Type*} [CommRing A]
+    (a : A) [IsPrecomplete (Ideal.span {a}) A] :
+    IsPrecomplete (Ideal.span {a}) (ι → A) := by
+  classical
+  constructor
+  intro f hf
+  have hc (i : ι) : ∃ z : A, ∀ n,
+      f n i ≡ z [SMOD ((Ideal.span {a})^n • (⊤ : Submodule A A))] := by
+    apply IsPrecomplete.prec'
+    intro m n hmn
+    have h := hf hmn
+    rw [SModEq.sub_mem,Ideal.span_singleton_pow] at h
+    have hi := (mem_principal_smul_pi (a^m) _).mp h i
+    simpa only [SModEq.sub_mem,Ideal.span_singleton_pow,smul_eq_mul,Ideal.mul_top,
+      Pi.sub_apply] using hi
+  choose z hz using hc
+  refine ⟨z,fun n ↦ ?_⟩
+  rw [SModEq.sub_mem,Ideal.span_singleton_pow,mem_principal_smul_pi]
+  intro i
+  simpa only [SModEq.sub_mem,Ideal.span_singleton_pow,smul_eq_mul,Ideal.mul_top,
+    Pi.sub_apply] using hz i n
+
+variable {K S : Type*} [Field K] [CommRing S] [IsLocalRing S]
+  [IsNoetherianRing S] [Algebra K S]
+
+theorem finite_primary_quotient (I : Ideal S)
+    (hI : I.radical = maximalIdeal S)
+    (hres : Function.Surjective
+      ((Ideal.Quotient.mk (maximalIdeal S)).comp (algebraMap K S))) :
+    Module.Finite K (S ⧸ I) := by
+  have him : I ≤ maximalIdeal S := hI ▸ Ideal.le_radical
+  let f : (S ⧸ I) →ₐ[K] ResidueField S := Ideal.Quotient.factorₐ K him
+  have : Module.Finite K (ResidueField S) :=
+    Module.Finite.of_surjective (Algebra.linearMap K (ResidueField S)) hres
+  apply Module.finite_of_surjective_of_ker_le_nilradical f
+    (Ideal.Quotient.factor_surjective him) ?_ (IsNoetherian.noetherian _)
+  intro x
+  induction x using Quotient.inductionOn' with
+  | h x =>
+    intro hx
+    have hxm : x ∈ maximalIdeal S := Ideal.Quotient.eq_zero_iff_mem.mp hx
+    rw [← hI] at hxm
+    obtain ⟨n,hn⟩ := hxm
+    apply mem_nilradical.mpr
+    exact ⟨n,by
+      change (Ideal.Quotient.mk I x)^n = 0
+      rw [← map_pow]
+      exact Ideal.Quotient.eq_zero_iff_mem.mpr hn⟩
+
+theorem finite_over_parameter [Algebra (PowerSeries K) S]
+    [IsScalarTower K (PowerSeries K) S]
+    (b : S) (hb : b ∈ maximalIdeal S)
+    (hfX : algebraMap (PowerSeries K) S PowerSeries.X = b)
+    [Module.Finite K (S ⧸ Ideal.span {b})] :
+    Module.Finite (PowerSeries K) S := by
+  classical
+  let A := PowerSeries K
+  let I : Ideal A := Ideal.span {PowerSeries.X}
+  let J : Ideal S := Ideal.span {b}
+  have hm : I.map (algebraMap A S) = J := by
+    rw [Ideal.map_span,Set.image_singleton,hfX]
+  have hjm : J ≤ maximalIdeal S := (Ideal.span_singleton_le_iff_mem (maximalIdeal S)).mpr hb
+  have : IsHausdorff J S := IsHausdorff.of_isLocalRing J S
+    (fun h ↦ (maximalIdeal.isMaximal S).ne_top (top_le_iff.mp (h ▸ hjm)))
+  have : IsHausdorff I S := IsHausdorff.map_algebraMap_iff.mp (hm ▸ ‹IsHausdorff J S›)
+  let B := Module.finBasis K (S ⧸ J)
+  obtain ⟨v,hv⟩ := Classical.axiom_of_choice
+    (fun i ↦ Ideal.Quotient.mk_surjective (B i))
+  let l : (Fin (Module.finrank K (S ⧸ J)) → A) →ₗ[A] S :=
+    Fintype.linearCombination A v
+  have : IsPrecomplete I (Fin (Module.finrank K (S ⧸ J)) → A) :=
+    principal_pi_precomplete PowerSeries.X
+  have hl : Function.Surjective l := by
+    apply surjective_of_mkQ_comp_surjective (I := I)
+    have heq : I • (⊤ : Submodule A S) = J.restrictScalars A := by
+      rw [Ideal.smul_top_eq_map,hm]
+    rw [heq]
+    change Function.Surjective (fun c ↦ Ideal.Quotient.mk J (l c))
+    intro z
+    refine ⟨fun i ↦ algebraMap K A (B.repr z i),?_⟩
+    change Ideal.Quotient.mk J (∑ i, algebraMap K A (B.repr z i) • v i) = z
+    rw [map_sum]
+    simp_rw [IsScalarTower.algebraMap_smul A]
+    change (∑ i, (Ideal.Quotient.mkₐ K J) (B.repr z i • v i)) = z
+    simp_rw [map_smul]
+    change (∑ i, B.repr z i • Ideal.Quotient.mk J (v i)) = z
+    simp_rw [hv]
+    exact B.sum_repr z
+  exact Module.Finite.of_surjective l hl
+
+end BoundaryOnly.FormalObstruction.AlgebraicReplacement.FormalArc
+
+namespace BoundaryOnly.FormalObstruction.AlgebraicReplacement.FormalArc
+open IsLocalRing
+variable {K S : Type*} [Field K] [IsAlgClosed K] [CharZero K]
+  [CommRing S] [IsDomain S] [IsLocalRing S] [IsNoetherianRing S]
+  [Algebra K S] [IsAdicComplete (maximalIdeal S) S]
+
+theorem primary_parameter_arc (b : S) (hb : b ≠ 0)
+    (hprimary : (Ideal.span {b}).radical = maximalIdeal S)
+    (hres : Function.Surjective
+      ((Ideal.Quotient.mk (maximalIdeal S)).comp (algebraMap K S))) :
+    ∃ f : S →ₐ[K] PowerSeries K,
+      Function.Injective f ∧ IsLocalHom f.toRingHom := by
+  classical
+  have hbm : b ∈ maximalIdeal S := by
+    rw [← hprimary]
+    exact Ideal.le_radical (Ideal.mem_span_singleton_self b)
+  let : WithIdeal K := ⟨⊥⟩
+  let : WithIdeal S := ⟨maximalIdeal S⟩
+  have hadic : IsAdic (maximalIdeal S) := rfl
+  have hc := hadic.isAdicComplete_iff.mp
+    (inferInstance : IsAdicComplete (maximalIdeal S) S)
+  let : CompleteSpace S := hc.1
+  let : T2Space S := hc.2
+  have hmap : Continuous (algebraMap K S) :=
+    (WithIdeal.uniformContinuous_of_map_le (f := algebraMap K S) (by
+      change (⊥ : Ideal K).map (algebraMap K S) ≤ maximalIdeal S
+      rw [Ideal.map_bot]
+      exact bot_le)).continuous
+  have hbeval : PowerSeries.HasEval b :=
+    WithIdeal.isTopologicallyNilpotent_of_mem hbm
+  let g : PowerSeries K →+* S := PowerSeries.eval₂Hom hmap hbeval
+  have hgX : g PowerSeries.X = b := by
+    simp only [g,PowerSeries.coe_eval₂Hom,PowerSeries.eval₂_X]
+  have hgC (c : K) : g (PowerSeries.C c) = algebraMap K S c := by
+    simp only [g,PowerSeries.coe_eval₂Hom,PowerSeries.eval₂_C]
+  have hinj : Function.Injective g := by
+    apply (injective_iff_map_eq_zero g).mpr
+    intro a ha
+    by_contra ha0
+    have hfactor := PowerSeries.X_pow_order_mul_divXPowOrder (f := a)
+    have hunit := (PowerSeries.isUnit_divided_by_X_pow_order ha0).map g
+    have heq := congrArg g hfactor
+    rw [map_mul,map_pow,hgX,ha] at heq
+    exact pow_ne_zero a.order.toNat hb
+      (hunit.mul_left_cancel (by simpa only [mul_comm,mul_zero,zero_mul] using heq))
+  let : Algebra (PowerSeries K) S := g.toAlgebra
+  have : IsScalarTower K (PowerSeries K) S :=
+    IsScalarTower.of_algebraMap_eq fun c ↦ (hgC c).symm
+  have : Module.IsTorsionFree (PowerSeries K) S :=
+    Module.isTorsionFree_iff_algebraMap_injective.mpr hinj
+  have : Module.Finite K (S ⧸ Ideal.span {b}) :=
+    finite_primary_quotient (Ideal.span {b}) hprimary hres
+  have : Module.Finite (PowerSeries K) S := finite_over_parameter b hbm hgX
+  exact finite_powerSeries_curve_arc hres b hb hbm
+
+end BoundaryOnly.FormalObstruction.AlgebraicReplacement.FormalArc
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/AlgebraicObstruction/GraphCorrection.lean b/lean/OAI/Algebra/AlgebraicObstruction/GraphCorrection.lean
new file mode 100644
index 0000000000000000000000000000000000000000..acc1b6c115ced7bc5bfc06dc423388262afd757c
--- /dev/null
+++ b/lean/OAI/Algebra/AlgebraicObstruction/GraphCorrection.lean
@@ -0,0 +1,275 @@
+import Mathlib
+import OAI.Algebra.FrobeniusObstruction.Obstruction
+import OAI.Algebra.AlgebraicObstruction.CorrectionOperator
+import OAI.Algebra.AlgebraicObstruction.TaylorRemainder
+
+namespace OAI
+
+noncomputable section
+open scoped BigOperators
+
+namespace BoundaryOnly.FormalObstruction.FormalCorrection
+open MvPowerSeries Matrix
+open scoped Classical
+variable {R α ι σ : Type*} [CommRing R] [Fintype α] [Fintype ι] [Finite σ]
+
+def shiftedGraph (x : (α ⊕ ι) → MvPowerSeries σ R) (δ : ι → MvPowerSeries σ R) :
+    (α ⊕ ι) → MvPowerSeries σ R :=
+  Sum.elim (fun a => x (.inl a)) (fun i => x (.inr i) + δ i)
+
+omit [Fintype α] [Fintype ι] [Finite σ] in
+theorem extended_centered [Fintype α] [Fintype ι] [Finite σ]
+    (x : (α ⊕ ι) → MvPowerSeries σ R) (δ : ι → MvPowerSeries σ R)
+    (hx : ∀ i, constantCoeff (x i) = 0) (hδ : ∀ i, constantCoeff (δ i) = 0) :
+    ∀ j, constantCoeff (Sum.elim x δ j) = 0 := by
+  intro j; cases j with
+  | inl j => exact hx j
+  | inr j => exact hδ j
+
+omit [Fintype α] [Fintype ι] [Finite σ] in
+theorem shiftedGraph_centered [Fintype α] [Fintype ι] [Finite σ]
+    (x : (α ⊕ ι) → MvPowerSeries σ R) (δ : ι → MvPowerSeries σ R)
+    (hx : ∀ i, constantCoeff (x i) = 0) (hδ : ∀ i, constantCoeff (δ i) = 0) :
+    ∀ j, constantCoeff (shiftedGraph x δ j) = 0 := by
+  intro j; cases j <;> simp [shiftedGraph, hx, hδ]
+
+theorem subst_extended_base (x : (α ⊕ ι) → MvPowerSeries σ R) (δ : ι → MvPowerSeries σ R)
+    (hx : ∀ i, constantCoeff (x i) = 0) (hδ : ∀ i, constantCoeff (δ i) = 0)
+    (f : MvPowerSeries (α ⊕ ι) R) :
+    subst (Sum.elim x δ) (subst (baseArguments (R := R)) f) = subst x f := by
+  let hs := hasSubst_of_constantCoeff_zero (extended_centered x δ hx hδ)
+  rw [subst_comp_subst_apply (R := R) (hasSubst_of_constantCoeff_zero (baseArguments_centered (R := R) (α := α) (ι := ι))) hs]
+  simp only [baseArguments, subst_X hs, Sum.elim_inl]
+
+theorem subst_extended_shifted (x : (α ⊕ ι) → MvPowerSeries σ R) (δ : ι → MvPowerSeries σ R)
+    (hx : ∀ i, constantCoeff (x i) = 0) (hδ : ∀ i, constantCoeff (δ i) = 0)
+    (f : MvPowerSeries (α ⊕ ι) R) :
+    subst (Sum.elim x δ) (subst (shiftedArguments (R := R)) f) = subst (shiftedGraph x δ) f := by
+  let hs := hasSubst_of_constantCoeff_zero (extended_centered x δ hx hδ)
+  rw [subst_comp_subst_apply (R := R) (hasSubst_of_constantCoeff_zero (shiftedArguments_centered (R := R) (α := α) (ι := ι))) hs]
+  congr 1
+  funext i
+  cases i <;> simp only [shiftedArguments, shiftedGraph, Sum.elim_inl, Sum.elim_inr,
+    subst_add hs, subst_X hs]
+
+def gradientValue (f : MvPowerSeries (α ⊕ ι) R) (x : (α ⊕ ι) → MvPowerSeries σ R) :
+    ι → MvPowerSeries σ R := fun i => subst x (MvPowerSeries.pderiv (R := R) (Sum.inr i) f)
+
+theorem gradientValue_vanishes (f : MvPowerSeries (α ⊕ ι) R) (hf : Vanishes 3 f)
+    (x : (α ⊕ ι) → MvPowerSeries σ R) (hx : ∀ i, constantCoeff (x i) = 0) :
+    ∀ i, Vanishes 2 (gradientValue f x i) := by
+  intro i
+  exact (hf.pderiv _).subst x hx
+
+theorem evaluated_remainder (f : MvPowerSeries (α ⊕ ι) R)
+    (H : Matrix ι ι (MvPowerSeries (Extended (α := α)) R))
+    (hH : subst shiftedArguments f = subst baseArguments f +
+        (∑ i, X (Sum.inr i) * subst baseArguments (MvPowerSeries.pderiv (R := R) (Sum.inr i) f)) +
+        ∑ i, ∑ j, X (Sum.inr i) * H i j * X (Sum.inr j))
+    (x : (α ⊕ ι) → MvPowerSeries σ R) (δ : ι → MvPowerSeries σ R)
+    (hx : ∀ i, constantCoeff (x i) = 0) (hδ : ∀ i, constantCoeff (δ i) = 0) :
+    subst (shiftedGraph x δ) f = subst x f + dotProduct (gradientValue f x) δ +
+      dotProduct δ ((fun i j => subst (Sum.elim x δ) (H i j)) *ᵥ δ) := by
+  let hs := hasSubst_of_constantCoeff_zero (extended_centered x δ hx hδ)
+  have hh := congrArg (substAlgHom hs) hH
+  simp only [map_add, map_sum, map_mul, substAlgHom_apply, subst_X hs,
+    Sum.elim_inr, subst_extended_shifted x δ hx hδ, subst_extended_base x δ hx hδ] at hh
+  rw [hh]
+  congr 2
+  · exact Finset.sum_congr rfl fun i _ => mul_comm _ _
+  · simp only [dotProduct, mulVec, Finset.mul_sum, mul_assoc]
+
+theorem evaluated_first_remainder (f : MvPowerSeries (α ⊕ ι) R)
+    (x : (α ⊕ ι) → MvPowerSeries σ R) (δ : ι → MvPowerSeries σ R)
+    (hx : ∀ i, constantCoeff (x i) = 0) (hδ : ∀ i, constantCoeff (δ i) = 0) :
+    ∃ q : ι → MvPowerSeries σ R,
+      subst (shiftedGraph x δ) f - subst x f = dotProduct q δ := by
+  obtain ⟨q,_,hq⟩ := exists_first_remainder f
+  let hs := hasSubst_of_constantCoeff_zero (extended_centered x δ hx hδ)
+  refine ⟨fun i => subst (Sum.elim x δ) (q i), ?_⟩
+  have hh := congrArg (substAlgHom hs) hq
+  simpa only [map_sub, map_sum, map_mul, substAlgHom_apply, subst_X hs,
+    Sum.elim_inr, subst_extended_shifted x δ hx hδ, subst_extended_base x δ hx hδ,
+    dotProduct] using hh
+
+end BoundaryOnly.FormalObstruction.FormalCorrection
+
+namespace BoundaryOnly.FormalObstruction.FormalCorrection
+open MvPowerSeries Matrix
+open scoped Classical
+variable {R α ι σ : Type*} [CommRing R] [Fintype α] [Fintype ι] [Finite σ]
+
+omit [Finite σ] in
+theorem mulVec_vanishes [Finite σ] {n : ℕ} (B : Matrix ι ι (MvPowerSeries σ R))
+    (v : ι → MvPowerSeries σ R) (hv : ∀ i, Vanishes n (v i)) :
+    ∀ i, Vanishes n ((B *ᵥ v) i) := by
+  intro i
+  exact Vanishes.sum Finset.univ _ (fun j _ => (hv j).mul_left (B i j))
+
+omit [Finite σ] in
+theorem quadratic_transpose [Finite σ] (B H : Matrix ι ι (MvPowerSeries σ R))
+    (v : ι → MvPowerSeries σ R) :
+    dotProduct (B *ᵥ v) (H *ᵥ (B *ᵥ v)) =
+      dotProduct v ((B.transpose * H * B) *ᵥ v) := by
+  rw [← mulVec_mulVec, ← mulVec_mulVec, dotProduct_transpose_mulVec, dotProduct_comm]
+
+omit [Fintype α] [Fintype ι] [Finite σ] in
+theorem shiftedGraph_jet [Fintype α] [Fintype ι] [Finite σ]
+    {n : ℕ} (x : (α ⊕ ι) → MvPowerSeries σ R)
+    (δ : ι → MvPowerSeries σ R) (hδ : ∀ i, Vanishes n (δ i)) :
+    ∀ i, Jet n (shiftedGraph x δ i) (x i) := by
+  intro i
+  cases i with
+  | inl a => exact Jet.refl _ _
+  | inr i =>
+    change Vanishes n ((x (.inr i) + δ i) - x (.inr i))
+    simpa only [add_sub_cancel_left] using hδ i
+
+theorem exists_zero_correction (f : MvPowerSeries (α ⊕ ι) R) (hf : Vanishes 3 f)
+    (x : (α ⊕ ι) → MvPowerSeries σ R) (hx : ∀ i, constantCoeff (x i) = 0)
+    (b : Matrix ι ι (MvPowerSeries σ R))
+    (hg : subst x f = dotProduct (gradientValue f x) (b *ᵥ gradientValue f x)) :
+    ∃ B : Matrix ι ι (MvPowerSeries σ R),
+      subst (shiftedGraph x (B *ᵥ gradientValue f x)) f = 0 ∧
+      (∀ i, Jet 2 (shiftedGraph x (B *ᵥ gradientValue f x) i) (x i)) := by
+  obtain ⟨H,hH,hTaylor⟩ := exists_taylor_remainder f hf
+  let v := gradientValue f x
+  have hv : ∀ i, Vanishes 2 (v i) := gradientValue_vanishes f hf x hx
+  obtain ⟨B,hB⟩ := exists_correction_matrix b H x v hH hx hv
+  have hδ := mulVec_vanishes B v hv
+  have hδ0 : ∀ i, constantCoeff ((B *ᵥ v) i) = 0 :=
+    fun i => Vanishes.one_iff.mp ((hδ i).mono (by omega))
+  refine ⟨B, ?_, shiftedGraph_jet x _ hδ⟩
+  have ht := evaluated_remainder f H hTaylor x (B *ᵥ v) hx hδ0
+  change subst (shiftedGraph x (B *ᵥ v)) f = _ at ht ⊢
+  have heval : (fun i j => subst (Sum.elim x (B *ᵥ v)) (H i j)) = remainderValue H x v B := by
+    funext i j
+    unfold remainderValue
+    congr 1
+    funext k
+    cases k <;> rfl
+  rw [heval, quadratic_transpose B, hg] at ht
+  have hz : b + B + B.transpose * remainderValue H x v B * B = 0 := by
+    change B = -b - B.transpose * remainderValue H x v B * B at hB
+    calc
+      _ = b + (-b - B.transpose * remainderValue H x v B * B) +
+        B.transpose * remainderValue H x v B * B := congrArg (fun A => b+A+B.transpose * remainderValue H x v B * B) hB
+      _ = 0 := by abel
+  rw [ht]
+  change dotProduct v (b *ᵥ v) + dotProduct v (B *ᵥ v) +
+    dotProduct v ((B.transpose * remainderValue H x v B * B) *ᵥ v) = 0
+  rw [← dotProduct_add, ← add_mulVec, ← dotProduct_add, ← add_mulVec, hz]
+  simp
+
+end BoundaryOnly.FormalObstruction.FormalCorrection
+
+namespace BoundaryOnly.FormalObstruction.FormalCorrection
+open MvPowerSeries Matrix
+open scoped Classical
+variable {R α ι σ : Type*} [CommRing R] [Fintype α] [Fintype ι] [Finite σ]
+
+theorem evaluated_gradient_remainder (f : MvPowerSeries (α ⊕ ι) R) (hf : Vanishes 3 f)
+    (x : (α ⊕ ι) → MvPowerSeries σ R) (δ : ι → MvPowerSeries σ R)
+    (hx : ∀ i, constantCoeff (x i) = 0) (hδ : ∀ i, constantCoeff (δ i) = 0) :
+    ∃ G : Matrix ι ι (MvPowerSeries σ R), (∀ i j, Vanishes 1 (G i j)) ∧
+      gradientValue f (shiftedGraph x δ) = gradientValue f x + G *ᵥ δ := by
+  obtain ⟨G,hG,hgrad⟩ := exists_gradient_remainder f hf
+  let hs := hasSubst_of_constantCoeff_zero (extended_centered x δ hx hδ)
+  refine ⟨fun i j => subst (Sum.elim x δ) (G i j), ?_, ?_⟩
+  · intro i j
+    exact (hG i j).subst _ (extended_centered x δ hx hδ)
+  · funext i
+    have hh := congrArg (substAlgHom hs) (hgrad i)
+    simp only [map_sub, map_sum, map_mul, substAlgHom_apply, subst_X hs,
+      Sum.elim_inr, subst_extended_shifted x δ hx hδ, subst_extended_base x δ hx hδ] at hh
+    change gradientValue f (shiftedGraph x δ) i = gradientValue f x i + _
+    change gradientValue f (shiftedGraph x δ) i - gradientValue f x i = _ at hh
+    exact sub_eq_iff_eq_add.mp hh |>.trans (add_comm _ _)
+
+omit [Finite σ] in
+theorem matrix_one_add_isUnit [Finite σ] (M : Matrix ι ι (MvPowerSeries σ R))
+    (hM : ∀ i j, Vanishes 1 (M i j)) : IsUnit (1 + M) := by
+  have hc : (1 + M).map (constantCoeff (σ := σ) (R := R)) = 1 := by
+    ext i j
+    simp only [Matrix.map_apply, Matrix.add_apply, map_add, Vanishes.one_iff.mp (hM i j), add_zero]
+    simp only [Matrix.one_apply, apply_ite, map_one, map_zero]
+    split_ifs <;> rfl
+  apply ((1+M).isUnit_iff_isUnit_det).mpr
+  apply MvPowerSeries.isUnit_iff_constantCoeff.mpr
+  rw [RingHom.map_det]
+  change IsUnit (((1+M).map (constantCoeff (σ := σ) (R := R))).det)
+  rw [hc, Matrix.det_one]
+  exact isUnit_one
+
+theorem gradient_transport (f : MvPowerSeries (α ⊕ ι) R) (hf : Vanishes 3 f)
+    (x : (α ⊕ ι) → MvPowerSeries σ R) (hx : ∀ i, constantCoeff (x i) = 0)
+    (B : Matrix ι ι (MvPowerSeries σ R)) :
+    ∃ A : Matrix ι ι (MvPowerSeries σ R), IsUnit A ∧
+      gradientValue f (shiftedGraph x (B *ᵥ gradientValue f x)) = A *ᵥ gradientValue f x := by
+  let v := gradientValue f x
+  have hv : ∀ i, Vanishes 2 (v i) := gradientValue_vanishes f hf x hx
+  have hδ := mulVec_vanishes B v hv
+  have hδ0 : ∀ i, constantCoeff ((B *ᵥ v) i) = 0 :=
+    fun i => Vanishes.one_iff.mp ((hδ i).mono (by omega))
+  obtain ⟨G,hG,hgrad⟩ := evaluated_gradient_remainder f hf x (B *ᵥ v) hx hδ0
+  have hM : ∀ i j, Vanishes 1 ((G*B) i j) := by
+    intro i j
+    exact Vanishes.sum Finset.univ _ (fun k _ => (hG i k).mul_right (B k j))
+  refine ⟨1+G*B, matrix_one_add_isUnit _ hM, ?_⟩
+  rw [hgrad, Matrix.add_mulVec, Matrix.one_mulVec, ← Matrix.mulVec_mulVec]
+
+def vectorIdeal (v : ι → MvPowerSeries σ R) : Ideal (MvPowerSeries σ R) :=
+  Ideal.span (Set.range v)
+
+omit [Fintype ι] [Finite σ] in
+theorem vector_mem_vectorIdeal [Fintype ι] [Finite σ]
+    (v : ι → MvPowerSeries σ R) (i : ι) :
+    v i ∈ vectorIdeal v := Ideal.subset_span ⟨i,rfl⟩
+
+theorem mulVec_mem_vectorIdeal (A : Matrix ι ι (MvPowerSeries σ R))
+    (v : ι → MvPowerSeries σ R) (i : ι) : (A *ᵥ v) i ∈ vectorIdeal v := by
+  apply Ideal.sum_mem
+  intro j _
+  exact Ideal.mul_mem_left _ _ (vector_mem_vectorIdeal v j)
+
+theorem vectorIdeal_mulVec_le (A : Matrix ι ι (MvPowerSeries σ R))
+    (v : ι → MvPowerSeries σ R) : vectorIdeal (A *ᵥ v) ≤ vectorIdeal v := by
+  apply Ideal.span_le.mpr
+  rintro _ ⟨i,rfl⟩
+  exact mulVec_mem_vectorIdeal A v i
+
+theorem vectorIdeal_unit_mulVec (A : Matrix ι ι (MvPowerSeries σ R))
+    (hA : IsUnit A) (v : ι → MvPowerSeries σ R) : vectorIdeal (A *ᵥ v) = vectorIdeal v := by
+  obtain ⟨u,rfl⟩ := hA
+  apply le_antisymm (vectorIdeal_mulVec_le _ v)
+  have h := vectorIdeal_mulVec_le (↑(u⁻¹) : Matrix ι ι (MvPowerSeries σ R)) ((↑u) *ᵥ v)
+  simpa only [mulVec_mulVec, Units.inv_mul, one_mulVec] using h
+
+theorem gradient_ideal_transport (f : MvPowerSeries (α ⊕ ι) R) (hf : Vanishes 3 f)
+    (x : (α ⊕ ι) → MvPowerSeries σ R) (hx : ∀ i, constantCoeff (x i) = 0)
+    (B : Matrix ι ι (MvPowerSeries σ R)) :
+    vectorIdeal (gradientValue f (shiftedGraph x (B *ᵥ gradientValue f x))) =
+      vectorIdeal (gradientValue f x) := by
+  obtain ⟨A,hA,h⟩ := gradient_transport f hf x hx B
+  rw [h]
+  exact vectorIdeal_unit_mulVec A hA _
+
+theorem scalar_transport_mem (g : MvPowerSeries (α ⊕ ι) R)
+    (x : (α ⊕ ι) → MvPowerSeries σ R) (hx : ∀ i, constantCoeff (x i) = 0)
+    (v : ι → MvPowerSeries σ R) (hv : ∀ i, Vanishes 2 (v i))
+    (B : Matrix ι ι (MvPowerSeries σ R)) :
+    subst (shiftedGraph x (B *ᵥ v)) g - subst x g ∈ vectorIdeal v := by
+  have hδ := mulVec_vanishes B v hv
+  have hδ0 : ∀ i, constantCoeff ((B *ᵥ v) i) = 0 :=
+    fun i => Vanishes.one_iff.mp ((hδ i).mono (by omega))
+  obtain ⟨q,hq⟩ := evaluated_first_remainder g x (B *ᵥ v) hx hδ0
+  rw [hq]
+  apply Ideal.sum_mem
+  intro i _
+  exact Ideal.mul_mem_left _ _ (mulVec_mem_vectorIdeal B v i)
+
+end BoundaryOnly.FormalObstruction.FormalCorrection
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/AlgebraicObstruction/Holonomy.lean b/lean/OAI/Algebra/AlgebraicObstruction/Holonomy.lean
new file mode 100644
index 0000000000000000000000000000000000000000..bc9103ad8ff38ad729fcd35e3d8ba841f6799a28
--- /dev/null
+++ b/lean/OAI/Algebra/AlgebraicObstruction/Holonomy.lean
@@ -0,0 +1,130 @@
+import Mathlib
+import OAI.Algebra.AlgebraicObstruction.AlgebraicInput
+import OAI.Algebra.MarkedTensor.Holonomy
+
+namespace OAI
+
+noncomputable section
+open scoped BigOperators
+
+namespace BoundaryOnly.Holonomy
+
+variable {R : Type*} [CommRing R]
+
+lemma triple_mem_cube (I : Ideal R) {x y z : R}
+    (hx : x ∈ I) (hy : y ∈ I) (hz : z ∈ I) : x * y * z ∈ I ^ 3 := by
+  have h : x * y * z ∈ (I * I) * I := Ideal.mul_mem_mul (Ideal.mul_mem_mul hx hy) hz
+  simpa only [pow_succ, pow_zero, one_mul] using h
+
+lemma cube_iSup_le_of_le_deviation {T E : Type*}
+    (z : E → Matrix.SpecialLinearGroup (Fin 2) R)
+    (W : T → Ideal R) (hW : ∀ t, W t ≤ deviationIdeal z)
+    (r : Ideal R) (hc : deviationIdeal z ^ 3 ≤ r) : (⨆ t, W t) ^ 3 ≤ r := by
+  exact (pow_le_pow_left' (iSup_le hW) 3).trans hc
+
+lemma pow_sup_defect_le (I r : Ideal R) (q : ℕ) (h : I ^ q ≤ r) :
+    (I ⊔ r) ^ q ≤ r := by
+  let f : R →+* R ⧸ r := Ideal.Quotient.mk r
+  have hf : RingHom.ker f = r := Ideal.mk_ker
+  have hr : r.map f = ⊥ := (Ideal.map_eq_bot_iff_le_ker f).mpr (by rw [hf])
+  have hI : (I ^ q).map f = ⊥ := (Ideal.map_eq_bot_iff_le_ker f).mpr (by rwa [hf])
+  have hmap : ((I ⊔ r) ^ q).map f = ⊥ := by
+    rw [Ideal.map_pow, Ideal.map_sup, hr, sup_bot_eq, ← Ideal.map_pow, hI]
+  simpa only [hf] using ((Ideal.map_eq_bot_iff_le_ker f).mp hmap)
+
+end BoundaryOnly.Holonomy
+
+namespace BoundaryOnly.FormalObstruction.CoefficientRing
+
+open MvPowerSeries FormalCorrection AlgebraicReplacement BoundaryOnly.Holonomy
+open scoped Classical commutatorElement
+
+variable {K : Type} [Field K]
+variable {d : ℕ} {n : Fin d → ℕ}
+
+lemma origin_eq_maximal {σ : Type} [Fintype σ] :
+    originIdeal K σ = IsLocalRing.maximalIdeal (MvPowerSeries σ K) := by
+  ext f
+  rw [show originIdeal K σ = BoundaryOnly.FormalObstruction.originIdeal K σ from rfl, mem_origin_iff]
+  change constantCoeff f = 0 ↔ ¬ IsUnit f
+  rw [MvPowerSeries.isUnit_iff_constantCoeff, isUnit_iff_ne_zero, not_not]
+
+lemma gradientIdeal_le_origin
+    (P : (i : Fin d) → MvPowerSeries (WallVar n i) K)
+    (Y : InternalVar n → MvPowerSeries (GraphVar n) K)
+    (hP : ∀ i, P i ∈ (originIdeal K (WallVar n i)) ^ 3)
+    (hY : ∀ c, Y c ∈ originIdeal K (GraphVar n)) :
+    gradientIdeal n P Y ≤ originIdeal K (GraphVar n) := by
+  apply Ideal.span_le.mpr
+  rintro _ ⟨c, rfl⟩
+  apply mem_origin_iff.mpr
+  have h := gradientValue_vanishes (potential n P) (potential_vanishes P hP)
+    (graphCoordinates n Y) (graphCoordinates_centered Y hY) c
+  exact Vanishes.one_iff.mp (h.mono (by decide : 1 ≤ 2))
+
+variable [CharZero K] [IsAlgClosed K]
+
+theorem no_holonomy_algebraic_input (hd : 5 ≤ d)
+    (P : (i : Fin d) → MvPowerSeries (WallVar n i) K)
+    (Y : InternalVar n → MvPowerSeries (GraphVar n) K)
+    (hP : ∀ i, P i ∈ (originIdeal K (WallVar n i)) ^ 3)
+    (hY : ∀ c, Y c ∈ originIdeal K (GraphVar n))
+    (hcomp : IsUnit (complementaryMatrix n Y).det)
+    (hsquare : subst (graphCoordinates n Y) (potential n P) ∈ (gradientIdeal n P Y) ^ 2)
+    (A : (i : Fin d) → AffineEtaleChart K (WallVar n i))
+    (L : (i : Fin d) → Ideal (A i).LocalRing)
+    (hL : ∀ i, L i ≤ IsLocalRing.maximalIdeal (A i).LocalRing)
+    (hgradient : ∀ i w, pderiv (R := K) w (P i) ∈ (L i).map (A i).localExpansion.toRingHom)
+    (hjets : ∀ i w, ∀ q : ℕ, 1 ≤ q → ∃ a : (A i).LocalRing,
+      pderiv (R := K) w (P i) - (A i).localExpansion a ∈
+        ((L i).map (A i).localExpansion.toRingHom) ^ q)
+    (hYalg : ∀ c, Nonempty (LocalEtaleExpansion (Y c)))
+    (z : Bool × Fin d → Matrix.SpecialLinearGroup (Fin 2) (MvPowerSeries (GraphVar n) K))
+    (u : shortWords → Matrix.SpecialLinearGroup (Fin 2) (MvPowerSeries (GraphVar n) K))
+    (hz : ∀ e, mat (z e) - 1 ∈
+      (IsLocalRing.maximalIdeal (MvPowerSeries (GraphVar n) K)).matrix (Fin 2))
+    (hu : ∀ c, mat (u c) - mat (referenceOver (MvPowerSeries (GraphVar n) K) c) ∈
+      (IsLocalRing.maximalIdeal (MvPowerSeries (GraphVar n) K)).matrix (Fin 2))
+    (hrel : ∀ e f g a b c,
+      mat ⁅u a * z e * (u a)⁻¹, ⁅u b * z f * (u b)⁻¹, u c * z g * (u c)⁻¹⁆⁆ - 1 ∈
+        (gradientIdeal n P Y).matrix (Fin 2))
+    (hwall : ∀ b i, Ideal.map (wallEval Y hY b i)
+      ((L i).map (A i).localExpansion.toRingHom) ≤ deviationIdeal z ⊔ gradientIdeal n P Y)
+    (hpositive : ∀ i, slope n i ∈ deviationIdeal z ⊔ gradientIdeal n P Y)
+    (hnegative : ∀ i, negativeSlopeValue n P Y i ∈
+      deviationIdeal z ⊔ gradientIdeal n P Y) : False := by
+  have hr : gradientIdeal n P Y ≤
+      IsLocalRing.maximalIdeal (MvPowerSeries (GraphVar n) K) := by
+    rw [← origin_eq_maximal]
+    exact gradientIdeal_le_origin P Y hP hY
+  have hc₀ : deviationIdeal z ^ 3 ≤ gradientIdeal n P Y :=
+    cubic_nilpotence_mod_ideal _ hr z u hz hu hrel
+  have hc : (deviationIdeal z ⊔ gradientIdeal n P Y) ^ 3 ≤ gradientIdeal n P Y :=
+    pow_sup_defect_le _ _ 3 hc₀
+  have hn : deviationIdeal z ≤ originIdeal K (GraphVar n) := by
+    rw [origin_eq_maximal]
+    apply Ideal.span_le.mpr
+    rintro x ⟨⟨e, i, j⟩, rfl⟩
+    exact hz e i j
+  have hnr : deviationIdeal z ⊔ gradientIdeal n P Y ≤ originIdeal K (GraphVar n) :=
+    sup_le hn (gradientIdeal_le_origin P Y hP hY)
+  let Q : QuadraticData (R := K) (n := n) := {
+    P := P
+    Y := Y
+    order_three := hP
+    centered := hY
+    complementary := hcomp
+    graph_square := hsquare
+    positive_cubic := fun i j l => hc
+      (triple_mem_cube _ (hpositive i) (hpositive j) (hpositive l))
+    negative_cubic := fun i j l => hc
+      (triple_mem_cube _ (hnegative i) (hnegative j) (hnegative l)) }
+  exact no_algebraic_input hd Q A L hL hgradient hjets
+    (fun b i => (hwall b i).trans hnr)
+    (fun b i => (pow_le_pow_left' (hwall b i) 3).trans hc) hYalg
+
+end BoundaryOnly.FormalObstruction.CoefficientRing
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/AlgebraicObstruction/IdealBounds.lean b/lean/OAI/Algebra/AlgebraicObstruction/IdealBounds.lean
new file mode 100644
index 0000000000000000000000000000000000000000..11d62365593e284e49c77d9b66891e29afc640ba
--- /dev/null
+++ b/lean/OAI/Algebra/AlgebraicObstruction/IdealBounds.lean
@@ -0,0 +1,114 @@
+import Mathlib
+import OAI.Algebra.FrobeniusObstruction.Obstruction
+import OAI.Algebra.AlgebraicObstruction.TaylorDescent
+
+namespace OAI
+
+noncomputable section
+open scoped BigOperators
+
+namespace BoundaryOnly.FormalObstruction.AlgebraicReplacement.TaylorShift
+universe u
+variable {K A α : Type u} [CommRing K] [CommRing A]
+  [Algebra K A] [Algebra (MvPolynomial α K) A]
+  [IsScalarTower K (MvPolynomial α K) A]
+  [IsNoetherianRing A] [Finite α]
+  [Algebra.FormallySmooth (MvPolynomial α K) A]
+
+lemma fullTaylor_comp_of (I J : Ideal A) (q : ℕ) (hq : 1 ≤ q) :
+    (fullTaylor (K := K) (α := α) I J q hq).comp
+        (algebraMap A (AdicCompletion J A)) =
+      (TaylorTarget.map (TaylorTarget.quotientCoefficient (S := AdicCompletion J A) I) q).comp
+        (taylor (K := K) (α := α) I q hq) := by
+  ext a
+  exact fullTaylor_of I J q hq a
+
+omit [IsNoetherianRing A] [Finite α] in
+lemma coefficient_comp_of (I J : Ideal A) (q : ℕ) :
+    (algebraMap (AdicCompletion J A)
+        (TaylorTarget.Ring ((AdicCompletion J A) ⧸ I.map (algebraMap A (AdicCompletion J A))) α q)).comp
+        (algebraMap A (AdicCompletion J A)) =
+      (TaylorTarget.map (TaylorTarget.quotientCoefficient (S := AdicCompletion J A) I) q).comp
+        (coefficient (α := α) I q) := by
+  ext a
+  change TaylorTarget.mk _ α q (MvPolynomial.C _) =
+    TaylorTarget.map _ q (TaylorTarget.mk _ α q (MvPolynomial.C _))
+  rw [TaylorTarget.map_mk,MvPolynomial.map_C]
+  rfl
+
+theorem fullTaylor_mem_pow (I J : Ideal A) (q : ℕ) (hq : 1 ≤ q) (N : ℕ)
+    (b : AdicCompletion J A)
+    (hb : b ∈ (J.map (algebraMap A (AdicCompletion J A))) ^ (N+q-1)) :
+    fullTaylor (K := K) (α := α) I J q hq b ∈
+      ((J.map (algebraMap A (AdicCompletion J A))).map
+        (algebraMap (AdicCompletion J A)
+          (TaylorTarget.Ring ((AdicCompletion J A) ⧸ I.map (algebraMap A (AdicCompletion J A))) α q))) ^ N := by
+  have hh := Ideal.mem_map_of_mem (fullTaylor (K := K) (α := α) I J q hq) hb
+  rw [Ideal.map_pow,Ideal.map_map,fullTaylor_comp_of,← Ideal.map_map,← Ideal.map_pow] at hh
+  have hle := Ideal.map_mono (f := TaylorTarget.map
+    (TaylorTarget.quotientCoefficient (S := AdicCompletion J A) I) q)
+      (actions_cofinal (K := K) (α := α) I J q hq N).1
+  have ht := hle hh
+  rwa [Ideal.map_pow,Ideal.map_map,← coefficient_comp_of,← Ideal.map_map] at ht
+
+end BoundaryOnly.FormalObstruction.AlgebraicReplacement.TaylorShift
+
+namespace BoundaryOnly.FormalObstruction.AlgebraicReplacement
+variable {k A : Type*} [CommRing k] [CommRing A] [Algebra k A]
+
+theorem derivation_mem_pow (D : Derivation k A A) (I : Ideal A) (q : ℕ)
+    {f : A} (hf : f ∈ I^(q+1)) : D f ∈ I^q := by
+  induction q generalizing f with
+  | zero => simp
+  | succ q ih =>
+    rw [pow_succ] at hf
+    refine Submodule.mul_induction_on hf ?_ ?_
+    · intro a ha b hb
+      rw [D.leibniz, smul_eq_mul, smul_eq_mul]
+      apply (I^(q+1)).add_mem
+      · exact Ideal.mul_mem_right _ _ ha
+      · rw [pow_succ]
+        simpa only [mul_comm] using Ideal.mul_mem_mul (ih ha) hb
+    · intro a b ha hb
+      simpa only [map_add] using (I^(q+1)).add_mem ha hb
+
+theorem ninth_order_bounds (L r m : Ideal A) (hL : L ≤ m) (hcube : L^3 ≤ r) :
+    L^9 ≤ r^3 ∧ L^8 ≤ r^2 * m^2 := by
+  constructor
+  · calc
+      L^9 = (L^3)^3 := by rw [← pow_mul]
+      _ ≤ r^3 := pow_le_pow_left' hcube 3
+  · calc
+      L^8 = (L^3)^2 * L^2 := by rw [← pow_mul, ← pow_add]
+      _ ≤ r^2 * m^2 := mul_le_mul' (pow_le_pow_left' hcube 2) (pow_le_pow_left' hL 2)
+
+theorem eighth_le_mul (r m : Ideal A) : r^2 * m^2 ≤ m * r := by
+  calc
+    r^2 * m^2 ≤ r * m := mul_le_mul' (Ideal.pow_le_self (by omega)) (Ideal.pow_le_self (by omega))
+    _ = m * r := mul_comm _ _
+
+theorem span_eq_of_generator_congruence {ι : Type*} [Fintype ι]
+    (m : Ideal A) (hm : m ≤ Ideal.jacobson ⊥) (v w : ι → A)
+    (h : ∀ i, w i - v i ∈ m * Ideal.span (Set.range v)) :
+    Ideal.span (Set.range w) = Ideal.span (Set.range v) := by
+  let r := Ideal.span (Set.range v)
+  let s := Ideal.span (Set.range w)
+  have hmr : m * r ≤ r := Ideal.mul_le_right
+  have hs : s ≤ r := Ideal.span_le.mpr (by
+    rintro _ ⟨i,rfl⟩
+    have he : w i = (w i - v i) + v i := by ring
+    rw [he]
+    exact r.add_mem (hmr (h i)) (Ideal.subset_span ⟨i,rfl⟩))
+  have hr : r ≤ s ⊔ m • r := Ideal.span_le.mpr (by
+    rintro _ ⟨i,rfl⟩
+    have hw : w i ∈ s ⊔ m • r := (show s ≤ s ⊔ m • r from le_sup_left) (Ideal.subset_span ⟨i,rfl⟩)
+    have hd : w i - v i ∈ s ⊔ m • r := (show m * r ≤ s ⊔ m • r from le_sup_right) (h i)
+    exact sub_sub_cancel (w i) (v i) ▸ (s ⊔ m • r).sub_mem hw hd)
+  exact le_antisymm hs (Submodule.le_of_le_smul_of_le_jacobson_bot
+    (Submodule.fg_span (Set.finite_range v)) hm hr)
+
+end BoundaryOnly.FormalObstruction.AlgebraicReplacement
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/AlgebraicObstruction/IdealVanishing.lean b/lean/OAI/Algebra/AlgebraicObstruction/IdealVanishing.lean
new file mode 100644
index 0000000000000000000000000000000000000000..22d9d1aa30fe8a26a7ada6bf7d39cd8c9699466c
--- /dev/null
+++ b/lean/OAI/Algebra/AlgebraicObstruction/IdealVanishing.lean
@@ -0,0 +1,122 @@
+import Mathlib
+import OAI.Algebra.FrobeniusObstruction.Obstruction
+import OAI.Algebra.AlgebraicObstruction.CoefficientData
+import OAI.Algebra.AlgebraicObstruction.GraphCorrection
+
+namespace OAI
+
+noncomputable section
+open scoped BigOperators
+
+namespace BoundaryOnly.FormalObstruction.FormalCorrection
+open MvPowerSeries
+open scoped Classical
+variable {R σ : Type*} [CommRing R]
+
+def vanishingIdeal (n : ℕ) : Ideal (MvPowerSeries σ R) where
+  carrier := {f | Vanishes n f}
+  zero_mem' := Vanishes.zero n
+  add_mem' := fun hf hg => hf.add hg
+  smul_mem' := fun c _ hf => hf.mul_left c
+
+ theorem origin_le_vanishingIdeal : originIdeal R σ ≤ vanishingIdeal 1 := by
+  apply Ideal.span_le.mpr
+  rintro _ ⟨i,rfl⟩
+  exact Vanishes.one_iff.mpr (constantCoeff_X i)
+
+ theorem vanishingIdeal_mul (a b : ℕ) :
+    (vanishingIdeal a : Ideal (MvPowerSeries σ R)) * vanishingIdeal b ≤ vanishingIdeal (a+b) := by
+  apply Ideal.mul_le.mpr
+  intro f hf g hg
+  exact Vanishes.mul hf hg
+
+ theorem origin_pow_vanishes {f : MvPowerSeries σ R} {n : ℕ}
+    (hf : f ∈ (originIdeal R σ)^n) : Vanishes n f := by
+  suffices (originIdeal R σ)^n ≤ vanishingIdeal n from this hf
+  clear hf
+  induction n with
+  | zero => exact fun f _ => Vanishes.all f
+  | succ n ih =>
+    rw [pow_succ]
+    exact (mul_le_mul' ih origin_le_vanishingIdeal).trans (vanishingIdeal_mul n 1)
+
+ theorem mem_origin_iff [Fintype σ] {f : MvPowerSeries σ R} :
+    f ∈ originIdeal R σ ↔ constantCoeff f = 0 := by
+  constructor
+  · intro hf
+    exact Vanishes.one_iff.mp (origin_le_vanishingIdeal hf)
+  · intro hf
+    let m : σ → σ →₀ ℕ := fun i => Finsupp.single i 1
+    have hh : ∀ e : σ →₀ ℕ, (¬ ∃ i, m i ≤ e) → coeff e f = 0 := by
+      intro e he
+      have he0 : e = 0 := by
+        ext i
+        by_contra hi
+        apply he
+        refine ⟨i, Finsupp.single_le_iff.mpr ?_⟩
+        change 1 ≤ e i
+        have : e i ≠ 0 := by simpa using hi
+        omega
+      simpa only [he0, coeff_zero_eq_constantCoeff] using hf
+    rw [monomial_factorization m f hh]
+    apply Ideal.sum_mem
+    intro i _
+    apply Ideal.mul_mem_right
+    change monomial (Finsupp.single i 1) 1 ∈ originIdeal R σ
+    exact Ideal.subset_span ⟨i,rfl⟩
+
+ theorem triple_transport_mem {S : Type*} [CommRing S] (I : Ideal S)
+    {a b c a' b' c' : S} (ha : a'-a ∈ I) (hb : b'-b ∈ I) (hc : c'-c ∈ I)
+    (h : a*b*c ∈ I) : a'*b'*c' ∈ I := by
+  have hd : a'*b'*c' - a*b*c ∈ I := by
+    have hh := I.add_mem (I.add_mem
+      (I.mul_mem_right (b'*c') ha) (I.mul_mem_left (a*c') hb))
+      (I.mul_mem_left (a*b) hc)
+    convert hh using 1
+    ring
+  convert I.add_mem hd h using 1
+  ring
+
+ theorem Jet.pderiv_constant {f g : MvPowerSeries σ R} (h : Jet 2 f g) (i : σ) :
+    constantCoeff (MvPowerSeries.pderiv i f) = constantCoeff (MvPowerSeries.pderiv i g) := by
+  have hh := Vanishes.one_iff.mp (h.pderiv i)
+  simpa only [Jet, map_sub, sub_eq_zero] using hh
+
+end BoundaryOnly.FormalObstruction.FormalCorrection
+
+namespace BoundaryOnly.FormalObstruction.FormalCorrection
+open Matrix
+open scoped Classical
+variable {R ι σ : Type*} [CommRing R] [Fintype ι]
+
+omit [Fintype ι] in
+theorem vectorIdeal_square [Fintype ι] (v : ι → MvPowerSeries σ R) :
+    (vectorIdeal v)^2 = Ideal.span (Set.range fun ij : ι × ι => v ij.1 * v ij.2) := by
+  rw [pow_two, vectorIdeal, Ideal.span_mul_span]
+  congr 1
+  ext z
+  constructor
+  · rintro ⟨a,⟨i,rfl⟩,b,⟨j,rfl⟩,rfl⟩
+    exact ⟨(i,j),rfl⟩
+  · rintro ⟨⟨i,j⟩,rfl⟩
+    exact ⟨v i,⟨i,rfl⟩, v j,⟨j,rfl⟩,rfl⟩
+
+ theorem quadratic_witness (v : ι → MvPowerSeries σ R) (f : MvPowerSeries σ R)
+    (hf : f ∈ (vectorIdeal v)^2) :
+    ∃ b : Matrix ι ι (MvPowerSeries σ R), f = dotProduct v (b *ᵥ v) := by
+  rw [vectorIdeal_square] at hf
+  obtain ⟨c,hc⟩ := Ideal.mem_span_range_iff_exists_fun.mp hf
+  refine ⟨fun i j => c (i,j), ?_⟩
+  rw [← hc, Fintype.sum_prod_type]
+  simp only [dotProduct, mulVec, Finset.mul_sum]
+  apply Finset.sum_congr rfl
+  intro i _
+  apply Finset.sum_congr rfl
+  intro j _
+  ring
+
+end BoundaryOnly.FormalObstruction.FormalCorrection
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/AlgebraicObstruction/ImplicitFunction.lean b/lean/OAI/Algebra/AlgebraicObstruction/ImplicitFunction.lean
new file mode 100644
index 0000000000000000000000000000000000000000..c7602feb2f886e69759d8857f6722b020965a0ac
--- /dev/null
+++ b/lean/OAI/Algebra/AlgebraicObstruction/ImplicitFunction.lean
@@ -0,0 +1,112 @@
+import Mathlib
+import OAI.Algebra.FrobeniusObstruction.Obstruction
+import OAI.Algebra.AlgebraicObstruction.GraphCorrection
+
+namespace OAI
+
+noncomputable section
+open scoped BigOperators
+
+namespace BoundaryOnly.FormalObstruction.FormalCorrection
+open MvPowerSeries Matrix
+open scoped Classical
+variable {R α ι : Type*} [CommRing R] [Fintype ι]
+
+def centeredPart (f : MvPowerSeries α R) : MvPowerSeries α R := f - C (constantCoeff f)
+
+theorem centeredPart_centered [Fintype α] (f : MvPowerSeries α R) :
+    constantCoeff (centeredPart f) = 0 := by
+  simp [centeredPart]
+
+theorem centeredPart_eq [Fintype α] {f : MvPowerSeries α R} (hf : constantCoeff f = 0) :
+    centeredPart f = f := by simp [centeredPart,hf]
+
+theorem centeredPart_jet [Fintype α] {n : ℕ} {f g : MvPowerSeries α R} (h : Jet n f g) :
+    Jet n (centeredPart f) (centeredPart g) := by
+  by_cases hn : n = 0
+  · subst n; exact Vanishes.all _
+  · have hc : constantCoeff f = constantCoeff g :=
+      Jet.iff_coeff.mp h 0 (by simpa using Nat.pos_of_ne_zero hn)
+    rw [centeredPart,centeredPart,hc]
+    exact h.sub (Jet.refl _ _)
+
+variable [Fintype α]
+
+theorem quadratic_subst_contracts (H : MvPowerSeries (α ⊕ ι) R) (hH : Vanishes 2 H)
+    (f g : ι → MvPowerSeries α R) {n : ℕ}
+    (hfg : ∀ i, Jet n (f i) (g i)) :
+    Jet (n+1) (subst (Sum.elim X (fun i => centeredPart (f i))) H)
+      (subst (Sum.elim X (fun i => centeredPart (g i))) H) := by
+  let x : (α ⊕ ι) → MvPowerSeries α R := Sum.elim X (fun i => centeredPart (g i))
+  let δ : ι → MvPowerSeries α R := fun i => centeredPart (f i)-centeredPart (g i)
+  have hx : ∀ j, constantCoeff (x j) = 0 := by
+    intro j; cases j <;> simp [x,centeredPart_centered]
+  have hδ : ∀ j, constantCoeff (δ j) = 0 := by
+    intro j; simp [δ,centeredPart_centered]
+  have hext := extended_centered x δ hx hδ
+  let hs := hasSubst_of_constantCoeff_zero hext
+  obtain ⟨q,hq,hfact⟩ := exists_first_remainder H
+  have hq' : ∀ i, Vanishes 1 (subst (Sum.elim x δ) (q i)) :=
+    fun i => (hq 1 hH i).subst _ hext
+  have hfact' := congrArg (substAlgHom hs) hfact
+  simp only [map_sub,map_sum,map_mul,substAlgHom_apply,subst_X hs,Sum.elim_inr,
+    subst_extended_shifted x δ hx hδ,subst_extended_base x δ hx hδ] at hfact'
+  have harg : shiftedGraph x δ = Sum.elim X (fun i => centeredPart (f i)) := by
+    funext j
+    cases j <;> simp [shiftedGraph,x,δ]
+  change Vanishes (n+1) _
+  rw [← harg]
+  change Vanishes (n+1) (subst (shiftedGraph x δ) H-subst x H)
+  rw [hfact']
+  exact Vanishes.sum _ _ fun i _ => by
+    simpa only [Nat.add_comm 1 n] using (hq' i).mul (centeredPart_jet (hfg i))
+
+def implicitOperator (L : ι → MvPowerSeries α R)
+    (H : ι → MvPowerSeries (α ⊕ ι) R) (w : ι → MvPowerSeries α R) :
+    ι → MvPowerSeries α R := fun i =>
+  L i + subst (Sum.elim X (fun j => centeredPart (w j))) (H i)
+
+theorem implicitOperator_contracts (L : ι → MvPowerSeries α R)
+    (H : ι → MvPowerSeries (α ⊕ ι) R) (hH : ∀ i, Vanishes 2 (H i)) :
+    ∀ n f g, Close n f g → Close (n+1) (implicitOperator L H f) (implicitOperator L H g) := by
+  intro n f g h i e he
+  have hj := quadratic_subst_contracts (H i) (hH i) f g
+    (fun j => Jet.iff_coeff.mpr (h j))
+  simpa only [implicitOperator,map_add] using congrArg (fun z => coeff e (L i)+z)
+    (Jet.iff_coeff.mp hj e he)
+
+theorem implicitOperator_centered (L : ι → MvPowerSeries α R)
+    (H : ι → MvPowerSeries (α ⊕ ι) R)
+    (hL : ∀ i, constantCoeff (L i) = 0) (hH : ∀ i, Vanishes 2 (H i))
+    (w : ι → MvPowerSeries α R) : ∀ i, constantCoeff (implicitOperator L H w i) = 0 := by
+  intro i
+  have hargs : ∀ j, constantCoeff (Sum.elim X (fun j => centeredPart (w j)) j) = 0 := by
+    intro j; cases j <;> simp [centeredPart_centered]
+  have hz := Vanishes.one_iff.mp (((hH i).subst _ hargs).mono (by omega : 1 ≤ 2))
+  simpa only [implicitOperator,map_add,hL,zero_add] using hz
+
+theorem centered_implicit_solution (L : ι → MvPowerSeries α R)
+    (H : ι → MvPowerSeries (α ⊕ ι) R)
+    (hL : ∀ i, constantCoeff (L i) = 0) (hH : ∀ i, Vanishes 2 (H i)) :
+    ∃! w : ι → MvPowerSeries α R,
+      (∀ i, constantCoeff (w i) = 0) ∧
+      (∀ i, w i = L i + subst (Sum.elim X w) (H i)) := by
+  let T := implicitOperator L H
+  have hT := implicitOperator_contracts L H hH
+  have hw : T (fixedPoint T) = fixedPoint T := fixedPoint_eq T hT
+  have hcenter : ∀ i, constantCoeff (fixedPoint T i) = 0 := by
+    rw [← hw]; exact implicitOperator_centered L H hL hH _
+  refine ⟨fixedPoint T,⟨hcenter,?_⟩,?_⟩
+  · intro i
+    have he := congrFun hw i
+    simpa only [T,implicitOperator,centeredPart_eq (hcenter _)] using he.symm
+  · intro w ⟨hc,hw⟩
+    apply fixedPoint_unique T hT
+    funext i
+    simpa only [T,implicitOperator,centeredPart_eq (hc _)] using (hw i).symm
+
+end BoundaryOnly.FormalObstruction.FormalCorrection
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/AlgebraicObstruction/LocalOrigin.lean b/lean/OAI/Algebra/AlgebraicObstruction/LocalOrigin.lean
new file mode 100644
index 0000000000000000000000000000000000000000..d81eb8de9017b4677355159c797f09c8598ceb8d
--- /dev/null
+++ b/lean/OAI/Algebra/AlgebraicObstruction/LocalOrigin.lean
@@ -0,0 +1,57 @@
+import Mathlib
+import OAI.Algebra.FrobeniusObstruction.Obstruction
+import OAI.Algebra.AlgebraicObstruction.EtaleCharts
+
+namespace OAI
+
+noncomputable section
+open scoped BigOperators
+
+namespace BoundaryOnly.FormalObstruction.FormalCorrection.AffineEtaleChart
+open MvPowerSeries
+variable {K α : Type} [Field K] [Finite α]
+
+def origin : Ideal (MvPolynomial α K) := RingHom.ker MvPolynomial.constantCoeff
+instance : (origin (K := K) (α := α)).IsPrime := RingHom.ker_isPrime _
+
+instance point_liesOver (E : AffineEtaleChart K α) :
+    E.point.LiesOver (origin (K := K) (α := α)) := by
+  constructor
+  ext p
+  change MvPolynomial.constantCoeff p = 0 ↔
+    constantCoeff (E.expansion (algebraMap (MvPolynomial α K) E.S p)) = 0
+  rw [E.expansion.commutes]
+  rfl
+
+noncomputable instance originAlgebra (E : AffineEtaleChart K α) :
+    Algebra (Localization.AtPrime (origin (K := K) (α := α))) E.LocalRing :=
+  Localization.AtPrime.algebraOfLiesOver _ _
+
+instance originLiesOverAlgebra (E : AffineEtaleChart K α) :
+    IsScalarTower (MvPolynomial α K)
+      (Localization.AtPrime (origin (K := K) (α := α))) E.LocalRing :=
+  inferInstance
+
+instance origin_isLocalHom (E : AffineEtaleChart K α) :
+    IsLocalHom (algebraMap (Localization.AtPrime (origin (K := K) (α := α))) E.LocalRing) := by
+  change IsLocalHom (Localization.localRingHom _ _ (algebraMap (MvPolynomial α K) E.S) _)
+  infer_instance
+
+omit [Finite α] in
+lemma maximalIdeal_eq_map_origin (E : AffineEtaleChart K α) :
+    IsLocalRing.maximalIdeal E.LocalRing =
+      (origin (K := K) (α := α)).map (algebraMap (MvPolynomial α K) E.LocalRing) := by
+  let R := Localization.AtPrime (origin (K := K) (α := α))
+  have : Algebra.EssFiniteType R E.LocalRing :=
+    Algebra.EssFiniteType.of_comp (MvPolynomial α K) R E.LocalRing
+  have : Algebra.FormallyUnramified R E.LocalRing :=
+    Algebra.FormallyUnramified.of_restrictScalars (MvPolynomial α K) R E.LocalRing
+  rw [← Algebra.FormallyUnramified.map_maximalIdeal (R := R)]
+  rw [← Localization.AtPrime.map_eq_maximalIdeal (I := origin (K := K) (α := α))]
+  rw [Ideal.map_map,← IsScalarTower.algebraMap_eq (MvPolynomial α K) R E.LocalRing]
+
+end BoundaryOnly.FormalObstruction.FormalCorrection.AffineEtaleChart
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/AlgebraicObstruction/PositiveCoefficients.lean b/lean/OAI/Algebra/AlgebraicObstruction/PositiveCoefficients.lean
new file mode 100644
index 0000000000000000000000000000000000000000..508d9c3c17aa0db60890a5d36683a751bb6c667d
--- /dev/null
+++ b/lean/OAI/Algebra/AlgebraicObstruction/PositiveCoefficients.lean
@@ -0,0 +1,240 @@
+import Mathlib
+import OAI.Algebra.FrobeniusObstruction.Obstruction
+import OAI.Algebra.AlgebraicObstruction.TaylorDifferential
+
+namespace OAI
+
+noncomputable section
+open scoped BigOperators
+
+namespace BoundaryOnly.FormalObstruction.AlgebraicReplacement.TaylorTarget
+variable {A B α : Type*} [CommRing A] [CommRing B]
+
+lemma reduction_map (f : A →+* B) (q : ℕ) (hq : 1 ≤ q) (x : Ring A α q) :
+    reduction B α q hq (map f q x) = f (reduction A α q hq x) := by
+  obtain ⟨p,rfl⟩ := mk_surjective q x
+  rw [map_mk,reduction_mk,reduction_mk]
+  exact MvPolynomial.constantCoeff_map f p
+
+end BoundaryOnly.FormalObstruction.AlgebraicReplacement.TaylorTarget
+
+namespace BoundaryOnly.FormalObstruction.AlgebraicReplacement.TaylorShift
+universe u
+variable {K A α : Type u} [CommRing K] [CommRing A]
+  [Algebra K A] [Algebra (MvPolynomial α K) A]
+  [IsScalarTower K (MvPolynomial α K) A]
+  [IsNoetherianRing A] [Finite α]
+  [Algebra.FormallySmooth (MvPolynomial α K) A]
+
+lemma fullTaylor_map_le_nil (I J : Ideal A) (q : ℕ) (hq : 1 ≤ q) :
+    (I.map (algebraMap A (AdicCompletion J A))).map
+      (fullTaylor (K := K) (α := α) I J q hq) ≤
+      TaylorTarget.nilIdeal
+        ((AdicCompletion J A) ⧸ I.map (algebraMap A (AdicCompletion J A))) α q := by
+  rw [← TaylorTarget.reduction_ker _ _ q hq,
+    Ideal.map_le_iff_le_comap,Ideal.map_le_iff_le_comap]
+  intro a ha
+  change TaylorTarget.reduction _ α q hq
+    (fullTaylor (K := K) (α := α) I J q hq (AdicCompletion.of J A a)) = 0
+  rw [fullTaylor_of,TaylorTarget.reduction_map,reduction_taylor,
+    Ideal.Quotient.eq_zero_iff_mem.mpr ha,map_zero]
+
+theorem fullTaylor_pow_zero (I J : Ideal A) (q : ℕ) (hq : 1 ≤ q)
+    (b : AdicCompletion J A) (hb : b ∈ (I.map (algebraMap A (AdicCompletion J A)))^q) :
+    fullTaylor (K := K) (α := α) I J q hq b = 0 := by
+  have hh := Ideal.mem_map_of_mem (fullTaylor (K := K) (α := α) I J q hq) hb
+  rw [Ideal.map_pow] at hh
+  have ht := (pow_le_pow_left' (fullTaylor_map_le_nil (K := K) (α := α) I J q hq) q) hh
+  rw [TaylorTarget.variables_pow,Ideal.mem_bot] at ht
+  exact ht
+
+end BoundaryOnly.FormalObstruction.AlgebraicReplacement.TaylorShift
+
+namespace BoundaryOnly.FormalObstruction.AlgebraicReplacement.TaylorTarget
+variable {K R S α : Type*} [Field K] [CharZero K] [CommRing R] [CommRing S]
+  [Algebra K R]
+
+include K in
+
+theorem positive_coefficient_descends (f : R →+* S) (q : ℕ) (x : Ring S α (q+1))
+    (h : ∀ i : α, ∃ y : Ring R α q, shiftDeriv i q x = map f q y)
+    (e : α →₀ ℕ) (he : e.degree < q+1) (he0 : e ≠ 0) :
+    ∃ r : R, f r = coefficient (q+1) e x := by
+  classical
+  obtain ⟨i,hi⟩ : ∃ i, e i ≠ 0 := by
+    by_contra hh
+    apply he0
+    ext j
+    exact not_not.mp (fun hn ↦ hh ⟨j,hn⟩)
+  let d := e - Finsupp.single i 1
+  have hd : d + Finsupp.single i 1 = e :=
+    tsub_add_cancel_of_le (Finsupp.single_le_iff.mpr (Nat.one_le_iff_ne_zero.mpr hi))
+  have hdeg : d.degree < q := by
+    have hh := congrArg Finsupp.degree hd
+    simp only [map_add,Finsupp.degree_single] at hh
+    omega
+  obtain ⟨y,hy⟩ := h i
+  have hc := coefficient_shiftDeriv i q d hdeg x
+  rw [hy,coefficient_map _ q d hdeg,hd] at hc
+  have hu : IsUnit ((d i + 1 : ℕ) : R) := by
+    have hk : IsUnit ((d i + 1 : ℕ) : K) :=
+      isUnit_iff_ne_zero.mpr (Nat.cast_ne_zero.mpr (by omega))
+    simpa only [map_natCast] using hk.map (algebraMap K R)
+  obtain ⟨u,hu⟩ := hu
+  have hfu : f (u : R) = (d i : S)+1 := by
+    rw [hu,map_natCast,Nat.cast_add,Nat.cast_one]
+  refine ⟨coefficient q d y * (↑(u⁻¹) : R),?_⟩
+  rw [map_mul,hc,← hfu,mul_assoc,← map_mul]
+  simp
+
+end BoundaryOnly.FormalObstruction.AlgebraicReplacement.TaylorTarget
+
+namespace BoundaryOnly.FormalObstruction.AlgebraicReplacement.TaylorShift
+universe u
+variable {K A α : Type u} [CommRing K] [CommRing A]
+  [Algebra K A] [Algebra (MvPolynomial α K) A]
+  [IsScalarTower K (MvPolynomial α K) A]
+  [IsNoetherianRing A] [Finite α]
+  [Algebra.FormallySmooth (MvPolynomial α K) A]
+
+lemma fullTaylor_eq_of_sub_mem (I J : Ideal A) (q : ℕ) (hq : 1 ≤ q)
+    (b c : AdicCompletion J A)
+    (h : b-c ∈ (I.map (algebraMap A (AdicCompletion J A)))^q) :
+    fullTaylor (K := K) (α := α) I J q hq b = fullTaylor (K := K) (α := α) I J q hq c := by
+  apply sub_eq_zero.mp
+  exact ((fullTaylor (K := K) (α := α) I J q hq).map_sub b c).symm.trans
+    (fullTaylor_pow_zero I J q hq (b-c) h)
+
+end BoundaryOnly.FormalObstruction.AlgebraicReplacement.TaylorShift
+
+namespace BoundaryOnly.FormalObstruction.FormalCorrection.AffineEtaleChart
+open BoundaryOnly.FormalObstruction.AlgebraicReplacement
+variable {K α : Type} [Field K] [Finite α]
+
+theorem fullTaylor_gradient_descends (E : AffineEtaleChart K α)
+    (I L : Ideal E.LocalRing) (hLI : L ≤ I) (q : ℕ) (hq : 1 ≤ q)
+    (b : AdicCompletion (IsLocalRing.maximalIdeal E.LocalRing) E.LocalRing)
+    (h : ∀ i : α, ∃ a : E.LocalRing,
+      E.completionDeriv i b - AdicCompletion.of _ _ a ∈
+        (L.map (algebraMap E.LocalRing
+          (AdicCompletion (IsLocalRing.maximalIdeal E.LocalRing) E.LocalRing)))^q) :
+    ∀ i : α, ∃ y : TaylorShift.Target (α := α) I q,
+      TaylorTarget.shiftDeriv i q
+        (TaylorShift.fullTaylor (K := K) (α := α) I (IsLocalRing.maximalIdeal E.LocalRing)
+          (q+1) (by omega) b) =
+      TaylorTarget.map (TaylorTarget.quotientCoefficient
+        (S := AdicCompletion (IsLocalRing.maximalIdeal E.LocalRing) E.LocalRing) I) q y := by
+  intro i
+  obtain ⟨a,ha⟩ := h i
+  refine ⟨TaylorShift.taylor (K := K) (α := α) I q hq a,?_⟩
+  rw [E.fullTaylor_deriv I i q hq]
+  calc
+    _ = TaylorShift.fullTaylor (K := K) (α := α) I (IsLocalRing.maximalIdeal E.LocalRing)
+        q hq (AdicCompletion.of _ _ a) := by
+      apply TaylorShift.fullTaylor_eq_of_sub_mem
+      exact (pow_le_pow_left' (Ideal.map_mono hLI) q) ha
+    _ = _ := TaylorShift.fullTaylor_of I (IsLocalRing.maximalIdeal E.LocalRing) q hq a
+
+theorem fullTaylor_positive_coefficients [CharZero K] (E : AffineEtaleChart K α)
+    (I L : Ideal E.LocalRing) (hLI : L ≤ I) (q : ℕ) (hq : 1 ≤ q)
+    (b : AdicCompletion (IsLocalRing.maximalIdeal E.LocalRing) E.LocalRing)
+    (h : ∀ i : α, ∃ a : E.LocalRing,
+      E.completionDeriv i b - AdicCompletion.of _ _ a ∈
+        (L.map (algebraMap E.LocalRing
+          (AdicCompletion (IsLocalRing.maximalIdeal E.LocalRing) E.LocalRing)))^q)
+    (e : α →₀ ℕ) (he : e.degree < q+1) (he0 : e ≠ 0) :
+    ∃ a : E.LocalRing ⧸ I,
+      TaylorTarget.quotientCoefficient
+        (S := AdicCompletion (IsLocalRing.maximalIdeal E.LocalRing) E.LocalRing) I a =
+      TaylorTarget.coefficient (q+1) e
+        (TaylorShift.fullTaylor (K := K) (α := α) I (IsLocalRing.maximalIdeal E.LocalRing)
+          (q+1) (by omega) b) := by
+  exact TaylorTarget.positive_coefficient_descends (K := K) _ q _
+    (E.fullTaylor_gradient_descends I L hLI q hq b h) e he he0
+
+end BoundaryOnly.FormalObstruction.FormalCorrection.AffineEtaleChart
+
+namespace BoundaryOnly.FormalObstruction.AlgebraicReplacement.TaylorTarget
+variable {A R α : Type*} [CommRing A] [CommRing R] [Algebra A R]
+
+lemma reduction_comp_coefficient (q : ℕ) (hq : 1 ≤ q) :
+    (reduction R α q hq).comp (algebraMap A (Ring R α q)) = algebraMap A R := by
+  ext a
+  change reduction R α q hq (mk R α q (MvPolynomial.C (algebraMap A R a))) = _
+  rw [reduction_mk,MvPolynomial.constantCoeff_C]
+
+lemma reduction_mem_coeff_pow (J : Ideal A) (q : ℕ) (hq : 1 ≤ q) (N : ℕ)
+    (x : Ring R α q) (hx : x ∈ (J.map (algebraMap A (Ring R α q)))^N) :
+    reduction R α q hq x ∈ (J.map (algebraMap A R))^N := by
+  have h := Ideal.mem_map_of_mem (reduction R α q hq) hx
+  rwa [Ideal.map_pow,Ideal.map_map,reduction_comp_coefficient] at h
+
+end BoundaryOnly.FormalObstruction.AlgebraicReplacement.TaylorTarget
+
+namespace BoundaryOnly.FormalObstruction.AlgebraicReplacement
+variable {A R : Type} [CommRing A] [IsLocalRing A] [IsNoetherianRing A]
+    [CommRing R] [Algebra A R] [Module.Finite A R]
+
+lemma finite_algebra_adic_separated (x y : R)
+    (h : ∀ N, x-y ∈ ((IsLocalRing.maximalIdeal A).map (algebraMap A R))^N) : x=y := by
+  apply (IsHausdorff.eq_iff_smodEq (I := IsLocalRing.maximalIdeal A)).mpr
+  intro N
+  rw [SModEq.sub_mem,Ideal.smul_top_eq_map,Submodule.restrictScalars_mem,Ideal.map_pow]
+  exact h N
+
+end BoundaryOnly.FormalObstruction.AlgebraicReplacement
+
+namespace BoundaryOnly.FormalObstruction.FormalCorrection.AffineEtaleChart
+open BoundaryOnly.FormalObstruction.AlgebraicReplacement
+variable {K α : Type} [Field K] [Finite α]
+
+theorem reduction_fullTaylor (E : AffineEtaleChart K α) (I : Ideal E.LocalRing)
+    (q : ℕ) (hq : 1 ≤ q)
+    (b : AdicCompletion (IsLocalRing.maximalIdeal E.LocalRing) E.LocalRing) :
+    TaylorTarget.reduction _ α q hq
+      (TaylorShift.fullTaylor (K := K) (α := α) I (IsLocalRing.maximalIdeal E.LocalRing) q hq b) =
+    Ideal.Quotient.mk (I.map (algebraMap E.LocalRing
+      (AdicCompletion (IsLocalRing.maximalIdeal E.LocalRing) E.LocalRing))) b := by
+  let J := IsLocalRing.maximalIdeal E.LocalRing
+  let B := AdicCompletion J E.LocalRing
+  let I' := I.map (algebraMap E.LocalRing B)
+  let R := B ⧸ I'
+  let m := IsLocalRing.maximalIdeal B
+  let F := (TaylorTarget.reduction R α q hq).toAddMonoidHom.comp
+    (TaylorShift.fullTaylor (K := K) (α := α) I J q hq).toAddMonoidHom
+  let G := (Ideal.Quotient.mk I').toAddMonoidHom
+  have hm : m = J.map (algebraMap E.LocalRing B) := AdicCompletion.maximalIdeal_eq_map
+  apply additive_eq_of_approximation (AdicCompletion.of J E.LocalRing).toAddMonoidHom
+    F G m (m.map (algebraMap B R)) q
+  · intro b N
+    rw [hm]
+    exact completion_approximate J b N
+  · exact fun x y h ↦ finite_algebra_adic_separated (A := B) x y h
+  · intro N x hx
+    change TaylorTarget.reduction R α q hq
+      (TaylorShift.fullTaylor (K := K) (α := α) I J q hq x) ∈ _
+    apply TaylorTarget.reduction_mem_coeff_pow
+    rw [hm] at hx ⊢
+    apply TaylorShift.fullTaylor_mem_pow (K := K) (α := α) I J q hq N x
+    exact (Ideal.pow_le_pow_right (by omega)) hx
+  · intro N x hx
+    change Ideal.Quotient.mk I' x ∈ _
+    have hx' : x ∈ m^N := (Ideal.pow_le_pow_right (by omega)) hx
+    have h := Ideal.mem_map_of_mem (Ideal.Quotient.mk I') hx'
+    have hmap : algebraMap B R = Ideal.Quotient.mk I' := rfl
+    rw [hmap]
+    simpa only [Ideal.map_pow] using h
+  · intro a
+    dsimp only [F,G,AddMonoidHom.comp_apply, RingHom.toAddMonoidHom_eq_coe,
+      AddMonoidHom.coe_coe]
+    change TaylorTarget.reduction R α q hq
+      (TaylorShift.fullTaylor (K := K) (α := α) I J q hq (AdicCompletion.of J E.LocalRing a)) =
+      Ideal.Quotient.mk I' (AdicCompletion.of J E.LocalRing a)
+    rw [TaylorShift.fullTaylor_of,TaylorTarget.reduction_map,TaylorShift.reduction_taylor]
+    rfl
+
+end BoundaryOnly.FormalObstruction.FormalCorrection.AffineEtaleChart
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/AlgebraicObstruction/PotentialReplacement.lean b/lean/OAI/Algebra/AlgebraicObstruction/PotentialReplacement.lean
new file mode 100644
index 0000000000000000000000000000000000000000..8b30702969cff8083329c6087d1f49cedb9f5639
--- /dev/null
+++ b/lean/OAI/Algebra/AlgebraicObstruction/PotentialReplacement.lean
@@ -0,0 +1,214 @@
+import Mathlib
+import OAI.Algebra.FrobeniusObstruction.Obstruction
+import OAI.Algebra.AlgebraicObstruction.IdealBounds
+
+namespace OAI
+
+noncomputable section
+open scoped BigOperators
+
+namespace BoundaryOnly.FormalObstruction.CoefficientRing
+open MvPowerSeries FormalCorrection AlgebraicReplacement
+open scoped Classical
+variable {R : Type*} [CommRing R] {d : ℕ} {n : Fin d → ℕ}
+
+def wallCoordinates (b : Bool) (i : Fin d) : WallVar n i → MvPowerSeries (AmbientVar n) R :=
+  if b then plusCoordinates n i else minusCoordinates n i
+
+theorem wallCoordinates_centered (b : Bool) (i : Fin d) :
+    ∀ w, constantCoeff (wallCoordinates (R := R) (n := n) b i w) = 0 := by
+  cases b
+  · exact minusCoordinates_centered i
+  · exact plusCoordinates_centered i
+
+def wallEval (Y : InternalVar n → MvPowerSeries (GraphVar n) R)
+    (hY : ∀ c, Y c ∈ originIdeal R (GraphVar n)) (b : Bool) (i : Fin d) :
+    MvPowerSeries (WallVar n i) R →ₐ[R] MvPowerSeries (GraphVar n) R :=
+  (substAlgHom (hasSubst_of_constantCoeff_zero (graphCoordinates_centered Y hY))).comp
+    (substAlgHom (hasSubst_of_constantCoeff_zero (wallCoordinates_centered b i)))
+
+theorem subst_potential_eq_sum (P : (i : Fin d) → MvPowerSeries (WallVar n i) R)
+    (Y : InternalVar n → MvPowerSeries (GraphVar n) R)
+    (hY : ∀ c, Y c ∈ originIdeal R (GraphVar n)) :
+    subst (graphCoordinates n Y) (potential n P) =
+      ∑ i, (wallEval Y hY true i (P i) - wallEval Y hY false i (P i)) := by
+  rw [← substAlgHom_apply (hasSubst_of_constantCoeff_zero (graphCoordinates_centered Y hY))]
+  simp only [potential, map_sum, map_sub]
+  apply Finset.sum_congr rfl
+  intro i _
+  simp [wallEval, wallCoordinates, AlgHom.comp_apply, substAlgHom_apply]
+
+theorem wallEval_negativeSlope (P : (i : Fin d) → MvPowerSeries (WallVar n i) R)
+    (Y : InternalVar n → MvPowerSeries (GraphVar n) R)
+    (hY : ∀ c, Y c ∈ originIdeal R (GraphVar n)) (i : Fin d) :
+    negativeSlopeValue n P Y i = wallEval Y hY false i (pderiv (.inl 0) (P i)) := by
+  have hz : ∀ w : WallVar n i, constantCoeff (zeroSlopes (k := R) n i w) = 0 := by
+    intro w; cases w <;> simp [zeroSlopes]
+  have hminus : ∀ j : Fin (n i), constantCoeff (Y (false,⟨i,j⟩)) = 0 :=
+    fun j => mem_origin_iff.mp (hY _)
+  simp only [wallEval, AlgHom.comp_apply, substAlgHom_apply, wallCoordinates, Bool.false_eq_true, ite_false]
+  change subst (fun j => Y (false,⟨i,j⟩))
+      (subst (zeroSlopes (k := R) n i) (pderiv (.inl 0) (P i))) =
+    subst (graphCoordinates n Y)
+      (subst (minusCoordinates (k := R) n i) (pderiv (.inl 0) (P i)))
+  rw [subst_comp_subst_apply (hasSubst_of_constantCoeff_zero hz)
+      (hasSubst_of_constantCoeff_zero hminus),
+    subst_comp_subst_apply (hasSubst_of_constantCoeff_zero (minusCoordinates_centered i))
+      (hasSubst_of_constantCoeff_zero (graphCoordinates_centered Y hY))]
+  congr 1
+  funext w
+  cases w with
+  | inl a =>
+    simp only [zeroSlopes, minusCoordinates,
+      ← substAlgHom_apply (hasSubst_of_constantCoeff_zero hminus),
+      ← substAlgHom_apply (hasSubst_of_constantCoeff_zero (graphCoordinates_centered Y hY)), map_zero]
+  | inr j =>
+    simp only [zeroSlopes, minusCoordinates,
+      subst_X (hasSubst_of_constantCoeff_zero hminus),
+      subst_X (hasSubst_of_constantCoeff_zero (graphCoordinates_centered Y hY)), graphCoordinates]
+
+theorem origin_le_jacobson {σ : Type*} [Fintype σ] :
+    originIdeal R σ ≤ Ideal.jacobson ⊥ := by
+  intro f hf
+  apply Ideal.mem_jacobson_bot.mpr
+  intro g
+  apply MvPowerSeries.isUnit_iff_constantCoeff.mpr
+  simp [mem_origin_iff.mp hf]
+
+theorem wall_error_bounds
+    (Y : InternalVar n → MvPowerSeries (GraphVar n) R)
+    (hY : ∀ c, Y c ∈ originIdeal R (GraphVar n))
+    (K : (i : Fin d) → Ideal (MvPowerSeries (WallVar n i) R))
+    (r : Ideal (MvPowerSeries (GraphVar n) R))
+    (hL : ∀ b i, Ideal.map (wallEval Y hY b i) (K i) ≤ originIdeal R (GraphVar n))
+    (hcube : ∀ b i, (Ideal.map (wallEval Y hY b i) (K i))^3 ≤ r)
+    (E : (i : Fin d) → MvPowerSeries (WallVar n i) R)
+    (hE : ∀ i, E i ∈ (K i)^9) :
+    (∀ b i, wallEval Y hY b i (E i) ∈ r^3) ∧
+    (∀ b i w, wallEval Y hY b i (pderiv w (E i)) ∈ originIdeal R (GraphVar n) * r) := by
+  constructor
+  · intro b i
+    have h := Ideal.mem_map_of_mem (wallEval Y hY b i) (hE i)
+    rw [Ideal.map_pow] at h
+    exact (ninth_order_bounds _ _ _ (hL b i) (hcube b i)).1 h
+  · intro b i w
+    have hd := derivation_mem_pow (pderiv w) (K i) 8 (hE i)
+    have h := Ideal.mem_map_of_mem (wallEval Y hY b i) hd
+    rw [Ideal.map_pow] at h
+    exact eighth_le_mul _ _ ((ninth_order_bounds _ _ _ (hL b i) (hcube b i)).2 h)
+
+theorem wall_ambient_derivative_mem
+    (Y : InternalVar n → MvPowerSeries (GraphVar n) R)
+    (hY : ∀ c, Y c ∈ originIdeal R (GraphVar n))
+    (I : Ideal (MvPowerSeries (GraphVar n) R)) (b : Bool) (i : Fin d)
+    (E : MvPowerSeries (WallVar n i) R)
+    (hE : ∀ w, wallEval Y hY b i (pderiv w E) ∈ I) (c : AmbientVar n) :
+    subst (graphCoordinates n Y) (pderiv (R := R) c (subst (wallCoordinates b i) E)) ∈ I := by
+  rw [pderiv_subst _ (wallCoordinates_centered b i)]
+  rw [← substAlgHom_apply (hasSubst_of_constantCoeff_zero (graphCoordinates_centered Y hY))]
+  rw [map_sum]
+  apply Ideal.sum_mem
+  intro w _
+  rw [map_mul]
+  have hw := hE w
+  simp only [wallEval, AlgHom.comp_apply, substAlgHom_apply] at hw
+  simp only [substAlgHom_apply]
+  exact I.mul_mem_right _ hw
+
+end BoundaryOnly.FormalObstruction.CoefficientRing
+
+namespace BoundaryOnly.FormalObstruction.CoefficientRing
+open MvPowerSeries FormalCorrection AlgebraicReplacement
+open scoped Classical
+variable {R : Type*} [CommRing R] {d : ℕ} {n : Fin d → ℕ}
+
+theorem potential_sub (P Q : (i : Fin d) → MvPowerSeries (WallVar n i) R) :
+    potential n (fun i => P i - Q i) = potential n P - potential n Q := by
+  unfold potential
+  rw [← Finset.sum_sub_distrib]
+  apply Finset.sum_congr rfl
+  intro i _
+  simp only [← substAlgHom_apply (hasSubst_of_constantCoeff_zero (plusCoordinates_centered i)),
+    ← substAlgHom_apply (hasSubst_of_constantCoeff_zero (minusCoordinates_centered i)), map_sub]
+  ring
+
+theorem gradient_sub (P Q : (i : Fin d) → MvPowerSeries (WallVar n i) R)
+    (Y : InternalVar n → MvPowerSeries (GraphVar n) R)
+    (hY : ∀ c, Y c ∈ originIdeal R (GraphVar n)) (c : InternalVar n) :
+    restrictedGradient n (fun i => P i - Q i) Y c =
+      restrictedGradient n P Y c - restrictedGradient n Q Y c := by
+  unfold restrictedGradient
+  rw [potential_sub, map_sub]
+  exact (substAlgHom_apply (hasSubst_of_constantCoeff_zero (graphCoordinates_centered Y hY)) _).symm.trans
+    ((map_sub (substAlgHom (R := R) (S := R) (hasSubst_of_constantCoeff_zero (graphCoordinates_centered Y hY))) _ _).trans (by simp only [substAlgHom_apply]))
+
+theorem gradient_mem_of_wall_derivatives
+    (E : (i : Fin d) → MvPowerSeries (WallVar n i) R)
+    (Y : InternalVar n → MvPowerSeries (GraphVar n) R)
+    (hY : ∀ c, Y c ∈ originIdeal R (GraphVar n))
+    (I : Ideal (MvPowerSeries (GraphVar n) R))
+    (hE : ∀ b i w, wallEval Y hY b i (pderiv w (E i)) ∈ I)
+    (c : InternalVar n) : restrictedGradient n E Y c ∈ I := by
+  unfold restrictedGradient potential
+  rw [map_sum]
+  rw [← substAlgHom_apply (hasSubst_of_constantCoeff_zero (graphCoordinates_centered Y hY))]
+  rw [map_sum]
+  apply Ideal.sum_mem
+  intro i _
+  rw [map_sub, map_sub]
+  simp only [substAlgHom_apply]
+  exact I.sub_mem (wall_ambient_derivative_mem Y hY I true i (E i) (hE true i) _)
+    (wall_ambient_derivative_mem Y hY I false i (E i) (hE false i) _)
+
+def QuadraticData.replace (Q : QuadraticData (R := R) (n := n))
+    (K : (i : Fin d) → Ideal (MvPowerSeries (WallVar n i) R))
+    (hK : ∀ i, K i ≤ originIdeal R (WallVar n i))
+    (hL : ∀ b i, Ideal.map (wallEval Q.Y Q.centered b i) (K i) ≤ originIdeal R (GraphVar n))
+    (hcube : ∀ b i, (Ideal.map (wallEval Q.Y Q.centered b i) (K i))^3 ≤ gradientIdeal n Q.P Q.Y)
+    (P : (i : Fin d) → MvPowerSeries (WallVar n i) R)
+    (hP : ∀ i, P i - Q.P i ∈ (K i)^9) : QuadraticData (R := R) (n := n) := by
+  let E := fun i => P i - Q.P i
+  let r := gradientIdeal n Q.P Q.Y
+  let m := originIdeal R (GraphVar n)
+  have hbounds := wall_error_bounds Q.Y Q.centered K r hL hcube E hP
+  have hvalue := hbounds.1
+  have hderiv := hbounds.2
+  have hgrad : gradientIdeal n P Q.Y = r := by
+    apply span_eq_of_generator_congruence m origin_le_jacobson
+    intro c
+    rw [← gradient_sub P Q.P Q.Y Q.centered c]
+    exact gradient_mem_of_wall_derivatives E Q.Y Q.centered (m*r) hderiv c
+  have hval : subst (graphCoordinates n Q.Y) (potential n P) -
+      subst (graphCoordinates n Q.Y) (potential n Q.P) ∈ r^3 := by
+    simp only [← substAlgHom_apply (hasSubst_of_constantCoeff_zero
+      (graphCoordinates_centered Q.Y Q.centered)), ← map_sub]
+    rw [substAlgHom_apply, ← potential_sub,
+      subst_potential_eq_sum _ _ Q.centered]
+    apply Ideal.sum_mem
+    intro i _
+    exact (r^3).sub_mem (hvalue true i) (hvalue false i)
+  have hneg : ∀ i, negativeSlopeValue n P Q.Y i - negativeSlopeValue n Q.P Q.Y i ∈ r := by
+    intro i
+    rw [wallEval_negativeSlope _ _ Q.centered, wallEval_negativeSlope _ _ Q.centered,
+      ← map_sub, ← map_sub]
+    exact (show m * r ≤ r from Ideal.mul_le_right) (hderiv false i (.inl 0))
+  refine ⟨P, Q.Y, ?_, Q.centered, Q.complementary, ?_, ?_, ?_⟩
+  · intro i
+    have he : E i ∈ (originIdeal R (WallVar n i))^3 :=
+      Ideal.pow_le_pow_right (by omega : 3 ≤ 9) ((pow_le_pow_left' (hK i) 9) (hP i))
+    simpa only [E, sub_add_cancel] using (originIdeal R (WallVar n i)^3).add_mem he (Q.order_three i)
+  · rw [hgrad]
+    have hh := (r^2).add_mem (Ideal.pow_le_pow_right (by omega : 2 ≤ 3) hval) Q.graph_square
+    simpa only [sub_add_cancel] using hh
+  · intro i j l
+    rw [hgrad]
+    exact Q.positive_cubic i j l
+  · intro i j l
+    rw [hgrad]
+    exact triple_transport_mem r (hneg i) (hneg j) (hneg l) (Q.negative_cubic i j l)
+
+end BoundaryOnly.FormalObstruction.CoefficientRing
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/AlgebraicObstruction/QuadraticData.lean b/lean/OAI/Algebra/AlgebraicObstruction/QuadraticData.lean
new file mode 100644
index 0000000000000000000000000000000000000000..dc49b377a4205db4e763b7640ad9798616d84b03
--- /dev/null
+++ b/lean/OAI/Algebra/AlgebraicObstruction/QuadraticData.lean
@@ -0,0 +1,136 @@
+import Mathlib
+import OAI.Algebra.FrobeniusObstruction.Obstruction
+import OAI.Algebra.AlgebraicObstruction.Specialization
+import OAI.Algebra.AlgebraicObstruction.IdealVanishing
+
+namespace OAI
+
+noncomputable section
+open scoped BigOperators
+
+namespace BoundaryOnly.FormalObstruction.CoefficientRing
+open MvPowerSeries Matrix FormalCorrection
+open scoped Classical
+variable {R : Type*} [CommRing R] {d : ℕ} {n : Fin d → ℕ}
+
+ theorem plusCoordinates_centered (i : Fin d) :
+    ∀ j, constantCoeff (plusCoordinates (k := R) n i j) = 0 := by
+  intro j; cases j <;> simp [plusCoordinates]
+ theorem minusCoordinates_centered (i : Fin d) :
+    ∀ j, constantCoeff (minusCoordinates (k := R) n i j) = 0 := by
+  intro j; cases j <;> simp [minusCoordinates]
+
+ theorem potential_vanishes (P : (i : Fin d) → MvPowerSeries (WallVar n i) R)
+    (hP : ∀ i, P i ∈ (originIdeal R (WallVar n i))^3) : Vanishes 3 (potential n P) := by
+  apply Vanishes.sum
+  intro i _
+  simpa only [sub_eq_add_neg] using ((origin_pow_vanishes (hP i)).subst _ (plusCoordinates_centered i)).add
+    (((origin_pow_vanishes (hP i)).subst _ (minusCoordinates_centered i)).neg)
+
+ theorem graphCoordinates_centered (Y : InternalVar n → MvPowerSeries (GraphVar n) R)
+    (hY : ∀ c, Y c ∈ originIdeal R (GraphVar n)) :
+    ∀ i, constantCoeff (graphCoordinates n Y i) = 0 := by
+  intro i
+  cases i with
+  | inl a => exact constantCoeff_X _
+  | inr c => exact mem_origin_iff.mp (hY c)
+
+ def correctedGraph (Y : InternalVar n → MvPowerSeries (GraphVar n) R)
+    (δ : InternalVar n → MvPowerSeries (GraphVar n) R) := fun c => Y c + δ c
+
+ theorem graph_corrected (Y : InternalVar n → MvPowerSeries (GraphVar n) R)
+    (δ : InternalVar n → MvPowerSeries (GraphVar n) R) :
+    graphCoordinates n (correctedGraph Y δ) = shiftedGraph (graphCoordinates n Y) δ := by
+  funext i
+  cases i <;> rfl
+
+ def negativeAmbient (P : (i : Fin d) → MvPowerSeries (WallVar n i) R) (i : Fin d) :
+    MvPowerSeries (AmbientVar n) R :=
+  subst (fun j => (X (.inr (false,⟨i,j⟩)) : MvPowerSeries (AmbientVar n) R)) (slopeDerivative n P i)
+
+ theorem subst_negativeAmbient (P : (i : Fin d) → MvPowerSeries (WallVar n i) R)
+    (Y : InternalVar n → MvPowerSeries (GraphVar n) R)
+    (hY : ∀ c, Y c ∈ originIdeal R (GraphVar n)) (i : Fin d) :
+    subst (graphCoordinates n Y) (negativeAmbient P i) = negativeSlopeValue n P Y i := by
+  let hx := hasSubst_of_constantCoeff_zero (graphCoordinates_centered Y hY)
+  let hi := hasSubst_of_constantCoeff_zero (fun j : Fin (n i) =>
+    constantCoeff_X (R := R) (Sum.inr (false,⟨i,j⟩) : AmbientVar n))
+  rw [negativeAmbient, subst_comp_subst_apply hi hx]
+  simp only [subst_X hx, graphCoordinates, negativeSlopeValue]
+
+ theorem complementaryMatrix_jet
+    (Y Z : InternalVar n → MvPowerSeries (GraphVar n) R)
+    (h : ∀ c, Jet 2 (Z c) (Y c)) : complementaryMatrix n Z = complementaryMatrix n Y := by
+  ext c bt
+  unfold complementaryMatrix tangentMatrix
+  split_ifs <;> exact Jet.pderiv_constant (h _) _
+
+structure QuadraticData where
+  P : (i : Fin d) → MvPowerSeries (WallVar n i) R
+  Y : InternalVar n → MvPowerSeries (GraphVar n) R
+  order_three : ∀ i, P i ∈ (originIdeal R (WallVar n i))^3
+  centered : ∀ c, Y c ∈ originIdeal R (GraphVar n)
+  complementary : IsUnit (complementaryMatrix n Y).det
+  graph_square : subst (graphCoordinates n Y) (potential n P) ∈ (gradientIdeal n P Y)^2
+  positive_cubic : ∀ i j l : Fin d,
+    slope n i * slope n j * slope n l ∈ gradientIdeal n P Y
+  negative_cubic : ∀ i j l : Fin d,
+    negativeSlopeValue n P Y i * negativeSlopeValue n P Y j *
+      negativeSlopeValue n P Y l ∈ gradientIdeal n P Y
+
+ theorem QuadraticData.correct (Q : QuadraticData (R := R) (n := n)) :
+    ∃ D : FormalData (k := R) n, D.P = Q.P ∧
+      (∀ c, Jet 2 (D.Y c) (Q.Y c)) := by
+  let f := potential n Q.P
+  let x := graphCoordinates n Q.Y
+  let v := gradientValue f x
+  have hf : Vanishes 3 f := potential_vanishes Q.P Q.order_three
+  have hx : ∀ i, constantCoeff (x i) = 0 := graphCoordinates_centered Q.Y Q.centered
+  have hv : ∀ c, Vanishes 2 (v c) := gradientValue_vanishes f hf x hx
+  have hid : vectorIdeal v = gradientIdeal n Q.P Q.Y := rfl
+  obtain ⟨b,hb⟩ := quadratic_witness v (subst x f) (hid ▸ Q.graph_square)
+  obtain ⟨B,hzero,hjet⟩ := exists_zero_correction f hf x hx b hb
+  let Z := correctedGraph Q.Y (B *ᵥ v)
+  have hZjet : ∀ c, Jet 2 (Z c) (Q.Y c) := fun c => hjet (.inr c)
+  have hZ : ∀ c, Z c ∈ originIdeal R (GraphVar n) := by
+    intro c
+    apply mem_origin_iff.mpr
+    have hh := (hZjet c).mono (by omega : 1 ≤ 2)
+    have hh' := Vanishes.one_iff.mp hh
+    simp only [map_sub, mem_origin_iff.mp (Q.centered c), sub_zero] at hh'
+    exact hh'
+  have hgrad : gradientIdeal n Q.P Z = gradientIdeal n Q.P Q.Y := by
+    change vectorIdeal (gradientValue f (graphCoordinates n Z)) = vectorIdeal v
+    rw [graph_corrected]
+    exact gradient_ideal_transport f hf x hx B
+  have hdiff : ∀ i, negativeSlopeValue n Q.P Z i - negativeSlopeValue n Q.P Q.Y i ∈
+      gradientIdeal n Q.P Q.Y := by
+    intro i
+    rw [← subst_negativeAmbient Q.P Z hZ, ← subst_negativeAmbient Q.P Q.Y Q.centered, graph_corrected]
+    exact scalar_transport_mem (negativeAmbient Q.P i) x hx v hv B
+  refine ⟨⟨Q.P, Z, Q.order_three, hZ, ?_, ?_, ?_, ?_⟩, rfl, hZjet⟩
+  · rw [complementaryMatrix_jet Q.Y Z hZjet]
+    exact Q.complementary
+  · rw [graph_corrected]
+    exact hzero
+  · intro i j l
+    rw [hgrad]
+    exact Q.positive_cubic i j l
+  · intro i j l
+    rw [hgrad]
+    exact triple_transport_mem _ (hdiff i) (hdiff j) (hdiff l) (Q.negative_cubic i j l)
+
+end BoundaryOnly.FormalObstruction.CoefficientRing
+namespace BoundaryOnly.FormalObstruction.CoefficientRing
+
+theorem no_integral_quadratic_data (R : Type*) [CommRing R] [IsDomain R] [CharZero R]
+    [Algebra.FiniteType ℤ R] (d : ℕ) (hd : 5 ≤ d) (n : Fin d → ℕ) :
+    ¬ Nonempty (QuadraticData (R := R) (n := n)) := by
+  rintro ⟨Q⟩
+  obtain ⟨D,_,_⟩ := Q.correct
+  exact no_integral_formal_data R d hd n ⟨D⟩
+end BoundaryOnly.FormalObstruction.CoefficientRing
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/AlgebraicObstruction/RadicalPrimitives.lean b/lean/OAI/Algebra/AlgebraicObstruction/RadicalPrimitives.lean
new file mode 100644
index 0000000000000000000000000000000000000000..fe86df39538318dabe7d31e2bdb196d4f631941c
--- /dev/null
+++ b/lean/OAI/Algebra/AlgebraicObstruction/RadicalPrimitives.lean
@@ -0,0 +1,260 @@
+import Mathlib
+import OAI.Algebra.FrobeniusObstruction.Obstruction
+import OAI.Algebra.AlgebraicObstruction.SymbolicPowers
+import OAI.Algebra.AlgebraicObstruction.ArcDetection
+
+namespace OAI
+
+noncomputable section
+open scoped BigOperators
+
+namespace BoundaryOnly.FormalObstruction.AlgebraicReplacement.FormalArc
+open MvPowerSeries
+open scoped MvPowerSeries.WithPiTopology
+open MvPowerSeries.WithPiTopology
+variable {R σ τ : Type*} [CommRing R] [Fintype σ]
+
+lemma substitution_pderiv_polynomial (a : σ → MvPowerSeries τ R) (ha : HasSubst a)
+    (j : τ) (p : MvPolynomial σ R) :
+    pderiv (R := R) j (subst a (p : MvPowerSeries σ R)) =
+      ∑ i, subst a (pderiv (R := R) i (p : MvPowerSeries σ R)) * pderiv (R := R) j (a i) := by
+  classical
+  have hz : subst a (0 : MvPowerSeries σ R) = 0 := by rw [← substAlgHom_apply (R := R) ha, map_zero]
+  have ho : subst a (1 : MvPowerSeries σ R) = 1 := by rw [← substAlgHom_apply (R := R) ha, map_one]
+  induction p using MvPolynomial.induction_on with
+  | C c => simp only [MvPolynomial.coe_C, pderiv_C, subst_C, hz, zero_mul,
+      Finset.sum_const_zero]
+  | add p q hp hq =>
+    simp only [MvPolynomial.coe_add, map_add, subst_add ha, add_mul, Finset.sum_add_distrib, hp, hq]
+  | mul_X p k hp =>
+    simp only [MvPolynomial.coe_mul, MvPolynomial.coe_X, subst_mul ha, subst_X ha,
+      Derivation.leibniz, smul_eq_mul, subst_add ha, hp, add_mul,
+      Finset.sum_add_distrib]
+    rw [Finset.mul_sum]
+    congr 1
+    · simp [pderiv_X, Pi.single_apply, apply_ite, hz, ho]
+    · simp only [mul_assoc]
+
+omit [Fintype σ] in
+lemma continuous_pderiv [TopologicalSpace R] [IsTopologicalRing R] (i : σ) :
+    Continuous (pderiv (R := R) i : MvPowerSeries σ R → MvPowerSeries σ R) := by
+  apply continuous_pi
+  intro n
+  change Continuous (fun f : MvPowerSeries σ R ↦ coeff n (pderiv (R := R) i f))
+  simp only [coeff_pderiv]
+  exact (continuous_coeff R _).mul continuous_const
+
+lemma substitution_pderiv (a : σ → MvPowerSeries τ R) (ha : HasSubst a)
+    (j : τ) (f : MvPowerSeries σ R) :
+    pderiv (R := R) j (subst a f) =
+      ∑ i, subst a (pderiv (R := R) i f) * pderiv (R := R) j (a i) := by
+  let : UniformSpace R := ⊥
+  have h := denseRange_toMvPowerSeries (σ := σ) (R := R)
+  have h1 : Continuous (fun f : MvPowerSeries σ R ↦ pderiv (R := R) j (subst a f)) :=
+    (continuous_pderiv j).comp (continuous_subst ha)
+  have h2 : Continuous (fun f : MvPowerSeries σ R ↦
+      ∑ i, subst a (pderiv (R := R) i f) * pderiv (R := R) j (a i)) := by
+    apply continuous_finsetSum
+    intro i hi
+    exact ((continuous_subst ha).comp (continuous_pderiv i)).mul continuous_const
+  exact congrFun (h.equalizer h1 h2 (funext (substitution_pderiv_polynomial a ha j))) f
+
+omit [Fintype σ] in
+lemma constantCoeff_subst_centered [Fintype σ] (a : σ → MvPowerSeries τ R) (ha : HasSubst a)
+    (ha0 : ∀ i, constantCoeff (a i) = 0) (f : MvPowerSeries σ R) :
+    constantCoeff (subst a f) = constantCoeff f := by
+  have h := constantCoeff_subst_eq_zero ha ha0
+    (f := f - C (constantCoeff f)) (by simp)
+  rw [subst_sub ha, subst_C, map_sub, constantCoeff_C, sub_eq_zero] at h
+  exact h
+
+theorem primitive_constant_on_arc [IsAddTorsionFree R]
+    (a : σ → MvPowerSeries τ R) (ha : HasSubst a)
+    (ha0 : ∀ i, constantCoeff (a i) = 0)
+    (I : Ideal (MvPowerSeries σ R))
+    (hI : I ≤ RingHom.ker (substAlgHom (R := R) ha).toRingHom)
+    (f : MvPowerSeries σ R) (hgrad : ∀ i, pderiv (R := R) i f ∈ I) :
+    subst a (f - C (constantCoeff f)) = 0 := by
+  have hg (i : σ) : subst a (pderiv (R := R) i f) = 0 := by
+    have h := hI (hgrad i)
+    change substAlgHom (R := R) ha (pderiv (R := R) i f) = 0 at h
+    simpa only [substAlgHom_apply] using h
+  have he : subst a f = C (constantCoeff f) := by
+    apply pderiv.ext
+    · intro j
+      rw [substitution_pderiv a ha j]
+      simp only [hg, zero_mul, Finset.sum_const_zero, pderiv_C]
+    · rw [constantCoeff_subst_centered a ha ha0, constantCoeff_C]
+  rw [subst_sub ha, subst_C, he, sub_self]
+
+end BoundaryOnly.FormalObstruction.AlgebraicReplacement.FormalArc
+
+namespace BoundaryOnly.FormalObstruction.AlgebraicReplacement.FormalArc
+open MvPowerSeries IsLocalRing
+variable {K σ : Type*} [Field K] [IsAlgClosed K] [CharZero K] [Fintype σ]
+
+theorem radical_primitive_constant (I : Ideal (MvPowerSeries σ K))
+    (hI : I.IsRadical) (P : MvPowerSeries σ K)
+    (hgrad : ∀ i, pderiv (R := K) i P ∈ I) : P - C (constantCoeff P) ∈ I := by
+  classical
+  by_contra hnot
+  have hIne : I ≠ ⊤ := by
+    intro h
+    apply hnot
+    simp [h]
+  let B := MvPowerSeries σ K
+  let Q := B ⧸ I
+  have : Nontrivial Q := Ideal.Quotient.nontrivial_iff.mpr hIne
+  have : IsReduced Q := (Ideal.isRadical_iff_quotient_reduced I).mp hI
+  have : IsAdicComplete (maximalIdeal Q) Q := local_quotient_complete I
+  let q : B →ₐ[K] Q := Ideal.Quotient.mkₐ K I
+  have hsurj : Function.Surjective q := Ideal.Quotient.mk_surjective
+  have : IsLocalHom q.toRingHom := IsLocalHom.of_surjective _ hsurj
+  let b := P - C (constantCoeff P)
+  have hqb : q b ≠ 0 := fun h ↦ hnot (Ideal.Quotient.eq_zero_iff_mem.mp h)
+  have hbm : b ∈ maximalIdeal B := by
+    rw [maximalIdeal_eq_variables,span_variables_eq_constant_kernel]
+    change constantCoeff b = 0
+    simp [b]
+  obtain ⟨g,hglocal,hgb⟩ := reduced_detecting_arc (q b) hqb
+    (map_nonunit q.toRingHom b hbm) (quotient_residue_surjective I residue_mps_surjective)
+  have : IsLocalHom g.toRingHom := hglocal
+  let f : B →ₐ[K] PowerSeries K := g.comp q
+  have : IsLocalHom f.toRingHom := by
+    change IsLocalHom (g.toRingHom.comp q.toRingHom)
+    infer_instance
+  let a : σ → MvPowerSeries Unit K := fun i ↦ f (X i)
+  have ha0 (i : σ) : constantCoeff (a i) = 0 := by
+    have hx : (X i : B) ∈ maximalIdeal B := by
+      rw [maximalIdeal_eq_variables]
+      exact Ideal.subset_span (Set.mem_range_self i)
+    have hh := map_nonunit f.toRingHom (X i) hx
+    rw [maximalIdeal_eq_variables,span_variables_eq_constant_kernel] at hh
+    exact hh
+  have ha : HasSubst a := ⟨fun i ↦ ha0 i ▸ IsNilpotent.zero,fun _ ↦ Set.toFinite _⟩
+  let s : B →ₐ[K] PowerSeries K := substAlgHom (R := K) ha
+  have : IsLocalHom s.toRingHom := ⟨by
+    intro x hx
+    apply MvPowerSeries.isUnit_iff_constantCoeff.mpr
+    have hh := MvPowerSeries.isUnit_iff_constantCoeff.mp hx
+    change IsUnit (constantCoeff (substAlgHom (R := K) ha x)) at hh
+    rw [substAlgHom_apply] at hh
+    rw [constantCoeff_subst_centered a ha ha0] at hh
+    exact hh⟩
+  have hfs : f = s := local_mps_hom_ext f s (fun i ↦ by
+    change a i = substAlgHom (R := K) ha (X i)
+    rw [substAlgHom_apply,subst_X ha])
+  have hkill : I ≤ RingHom.ker s.toRingHom := by
+    intro x hx
+    change s x = 0
+    rw [← hfs]
+    change g (q x) = 0
+    rw [show q x = 0 from Ideal.Quotient.eq_zero_iff_mem.mpr hx,map_zero]
+  have hconst := primitive_constant_on_arc a ha ha0 I hkill P hgrad
+  apply hgb
+  change f b = 0
+  rw [hfs]
+  change substAlgHom (R := K) ha b = 0
+  rw [substAlgHom_apply]
+  exact hconst
+
+end BoundaryOnly.FormalObstruction.AlgebraicReplacement.FormalArc
+
+namespace BoundaryOnly.FormalObstruction.FormalCorrection.AffineEtaleChart
+open BoundaryOnly.FormalObstruction.AlgebraicReplacement MvPowerSeries
+variable {K α : Type} [Field K] [CharZero K] [IsAlgClosed K] [Finite α]
+
+noncomputable instance chartCoeffAlgebra (E : AffineEtaleChart K α) : Algebra K E.S :=
+  Algebra.compHom E.S (algebraMap K (MvPolynomial α K))
+instance chartCoeffTower (E : AffineEtaleChart K α) : IsScalarTower K (MvPolynomial α K) E.S :=
+  IsScalarTower.of_algebraMap_eq' rfl
+
+noncomputable def pointAlgHom (E : AffineEtaleChart K α) : E.S →ₐ[K] K :=
+  { ((constantCoeff : MvPowerSeries α K →+* K).comp E.expansion.toRingHom) with
+    commutes' := fun k ↦ by
+      change constantCoeff (E.expansion (algebraMap (MvPolynomial α K) E.S (MvPolynomial.C k))) = k
+      rw [E.expansion.commutes]
+      simp [MvPowerSeries.algebraMap_apply'] }
+
+theorem radical_extended (E : AffineEtaleChart K α) (I : Ideal E.LocalRing)
+    (hI : I.IsRadical) (hIne : I ≠ ⊤) :
+    (I.map (algebraMap E.LocalRing
+      (AdicCompletion (IsLocalRing.maximalIdeal E.LocalRing) E.LocalRing))).IsRadical := by
+  have : Algebra.FiniteType K E.S := Algebra.FiniteType.trans
+    (inferInstance : Algebra.FiniteType K (MvPolynomial α K)) inferInstance
+  have : IsLocalization.AtPrime E.LocalRing (RingHom.ker E.pointAlgHom.toRingHom) := by
+    change IsLocalization.AtPrime E.LocalRing E.point
+    infer_instance
+  exact AnalyticReducedness.radical_local_completion E.pointAlgHom E.LocalRing I hI hIne
+
+theorem primitive_constant_reduction (E : AffineEtaleChart K α) (L : Ideal E.LocalRing)
+    (b : AdicCompletion (IsLocalRing.maximalIdeal E.LocalRing) E.LocalRing)
+    (hgrad : ∀ i : α, E.completionDeriv i b ∈ L.map (algebraMap E.LocalRing
+      (AdicCompletion (IsLocalRing.maximalIdeal E.LocalRing) E.LocalRing))) :
+    ∃ a₀ : E.LocalRing ⧸ L.radical,
+      TaylorTarget.quotientCoefficient
+        (S := AdicCompletion (IsLocalRing.maximalIdeal E.LocalRing) E.LocalRing) L.radical a₀ =
+      Ideal.Quotient.mk (L.radical.map (algebraMap E.LocalRing
+        (AdicCompletion (IsLocalRing.maximalIdeal E.LocalRing) E.LocalRing))) b := by
+  classical
+  let := Fintype.ofFinite α
+  let B := AdicCompletion (IsLocalRing.maximalIdeal E.LocalRing) E.LocalRing
+  let I := L.radical
+  let J := I.map (algebraMap E.LocalRing B)
+  by_cases hI : I = ⊤
+  · refine ⟨0,?_⟩
+    have hJ : J = ⊤ := by
+      change I.map (algebraMap E.LocalRing B) = ⊤
+      rw [hI,Ideal.map_top]
+    change TaylorTarget.quotientCoefficient (S := B) I 0 = Ideal.Quotient.mk J b
+    rw [map_zero]
+    exact (Ideal.Quotient.eq_zero_iff_mem.mpr (show b ∈ J by rw [hJ]; trivial)).symm
+  have hJ : J.IsRadical := E.radical_extended I L.radical_isRadical hI
+  let H := J.map E.completionEquiv.toRingHom
+  have hH : H.IsRadical := by
+    change (J.map (E.completionEquiv : B →+* MvPowerSeries α K)).IsRadical
+    rw [Ideal.map_comap_of_equiv]
+    exact hJ.comap _
+  have hg : ∀ i, pderiv (R := K) i (E.completionEquiv b) ∈ H := by
+    intro i
+    have hi := Ideal.mem_map_of_mem E.completionEquiv.toRingHom
+      ((Ideal.map_mono (show L ≤ I from Ideal.le_radical)) (hgrad i))
+    change E.completionEquiv (E.completionEquiv.symm (pderiv (R := K) i (E.completionEquiv b))) ∈ H at hi
+    rwa [RingEquiv.apply_symm_apply] at hi
+  have hc := FormalArc.radical_primitive_constant H hH (E.completionEquiv b) hg
+  let k := constantCoeff (E.completionEquiv b)
+  let a : E.LocalRing := algebraMap K E.LocalRing k
+  have ha : E.completionEquiv (AdicCompletion.of _ _ a) = C k := by
+    rw [E.completionEquiv_of]
+    change E.localExpansion (algebraMap (MvPolynomial α K) E.LocalRing (MvPolynomial.C k)) = _
+    rw [E.localExpansion.commutes]
+    simp [MvPowerSeries.algebraMap_apply']
+  have hb : b - AdicCompletion.of _ _ a ∈ J := by
+    apply (Ideal.apply_mem_of_equiv_iff (f := E.completionEquiv) (I := J)).mp
+    change E.completionEquiv (b - AdicCompletion.of _ _ a) ∈ H
+    rw [map_sub,ha]
+    exact hc
+  refine ⟨Ideal.Quotient.mk I a,?_⟩
+  change Ideal.Quotient.mk J (AdicCompletion.of _ _ a) = Ideal.Quotient.mk J b
+  exact (Ideal.Quotient.eq.mpr hb).symm
+
+theorem primitive_approximation (E : AffineEtaleChart K α) (L : Ideal E.LocalRing)
+    (b : AdicCompletion (IsLocalRing.maximalIdeal E.LocalRing) E.LocalRing)
+    (hgrad : ∀ i : α, E.completionDeriv i b ∈ L.map (algebraMap E.LocalRing
+      (AdicCompletion (IsLocalRing.maximalIdeal E.LocalRing) E.LocalRing)))
+    (hjets : ∀ i : α, ∀ q : ℕ, 1 ≤ q → ∃ a : E.LocalRing,
+      E.completionDeriv i b - AdicCompletion.of _ _ a ∈
+        (L.map (algebraMap E.LocalRing
+          (AdicCompletion (IsLocalRing.maximalIdeal E.LocalRing) E.LocalRing)))^q)
+    (m : ℕ) (hm : 1 ≤ m) :
+    ∃ a : E.LocalRing, b - AdicCompletion.of _ _ a ∈
+      (L^m).map (algebraMap E.LocalRing
+        (AdicCompletion (IsLocalRing.maximalIdeal E.LocalRing) E.LocalRing)) :=
+  E.primitive_approximation_from_constant_reduction L b
+    (E.primitive_constant_reduction L b hgrad) hjets m hm
+
+end BoundaryOnly.FormalObstruction.FormalCorrection.AffineEtaleChart
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/AlgebraicObstruction/ScalarCompletion.lean b/lean/OAI/Algebra/AlgebraicObstruction/ScalarCompletion.lean
new file mode 100644
index 0000000000000000000000000000000000000000..7f4f05251bbe021dabc49fcd0cd3d99e9d371ba8
--- /dev/null
+++ b/lean/OAI/Algebra/AlgebraicObstruction/ScalarCompletion.lean
@@ -0,0 +1,97 @@
+import Mathlib
+import OAI.Algebra.FrobeniusObstruction.Obstruction
+import OAI.Algebra.AlgebraicObstruction.SeriesJets
+import OAI.Algebra.AlgebraicObstruction.AdicFunctor
+
+namespace OAI
+
+noncomputable section
+open scoped BigOperators
+
+namespace BoundaryOnly.FormalObstruction.AlgebraicReplacement.CompletionScalar
+universe u
+variable {R S : Type u} [CommRing R] [CommRing S] [Algebra R S]
+
+def quotientEquiv (I : Ideal R) (n : ℕ) :
+    (S ⧸ (I ^ n • ⊤ : Submodule R S)) ≃ₗ[R]
+      (S ⧸ ((I.map (algebraMap R S)) ^ n • ⊤ : Ideal S)) :=
+  (Submodule.quotEquivOfEq _ _ (by
+    rw [Ideal.smul_top_eq_map, Ideal.map_pow]
+    simp)).trans (Submodule.Quotient.restrictScalarsEquiv R _)
+
+@[simp] lemma quotientEquiv_mk (I : Ideal R) (n : ℕ) (s : S) :
+    quotientEquiv I n (Submodule.Quotient.mk s) = Submodule.Quotient.mk s := by
+  simp only [quotientEquiv, LinearEquiv.trans_apply, Submodule.quotEquivOfEq_mk,
+    Submodule.Quotient.restrictScalarsEquiv_mk]
+
+@[simp] lemma quotientEquiv_symm_mk (I : Ideal R) (n : ℕ) (s : S) :
+    (quotientEquiv I n).symm (Submodule.Quotient.mk s) = Submodule.Quotient.mk s := by
+  apply (quotientEquiv I n).injective
+  rw [LinearEquiv.apply_symm_apply, quotientEquiv_mk]
+
+lemma quotientEquiv_transition (I : Ideal R) {m n : ℕ} (h : m ≤ n)
+    (x : S ⧸ (I ^ n • ⊤ : Submodule R S)) :
+    AdicCompletion.transitionMap (I.map (algebraMap R S)) S h
+      (quotientEquiv I n x) =
+    quotientEquiv I m (AdicCompletion.transitionMap I S h x) := by
+  induction x using Submodule.Quotient.induction_on with
+  | _ s =>
+      rw [quotientEquiv_mk]
+      exact (quotientEquiv_mk I m s).symm
+
+lemma quotientEquiv_symm_transition (I : Ideal R) {m n : ℕ} (h : m ≤ n)
+    (x : S ⧸ ((I.map (algebraMap R S)) ^ n • ⊤ : Ideal S)) :
+    AdicCompletion.transitionMap I S h ((quotientEquiv I n).symm x) =
+    (quotientEquiv I m).symm
+      (AdicCompletion.transitionMap (I.map (algebraMap R S)) S h x) := by
+  apply (quotientEquiv I m).injective
+  rw [← quotientEquiv_transition, LinearEquiv.apply_symm_apply,
+    LinearEquiv.apply_symm_apply]
+
+def equiv (I : Ideal R) :
+    AdicCompletion I S ≃ₗ[R] AdicCompletion (I.map (algebraMap R S)) S where
+  toFun x := ⟨fun n ↦ quotientEquiv I n (x.val n), fun h ↦ by
+    rw [quotientEquiv_transition, x.property h]⟩
+  invFun x := ⟨fun n ↦ (quotientEquiv I n).symm (x.val n), fun h ↦ by
+    rw [quotientEquiv_symm_transition, x.property h]⟩
+  left_inv x := by
+    apply AdicCompletion.ext
+    intro n
+    exact (quotientEquiv I n).symm_apply_apply _
+  right_inv x := by
+    apply AdicCompletion.ext
+    intro n
+    exact (quotientEquiv I n).apply_symm_apply _
+  map_add' x y := by
+    apply AdicCompletion.ext
+    intro n
+    exact map_add (quotientEquiv I n) _ _
+  map_smul' r x := by
+    apply AdicCompletion.ext
+    intro n
+    exact (quotientEquiv I n).map_smul r _
+
+@[simp] theorem equiv_of (I : Ideal R) (s : S) :
+    equiv I (AdicCompletion.of I S s) =
+      AdicCompletion.of (I.map (algebraMap R S)) S s := by
+  apply AdicCompletion.ext
+  intro n
+  exact quotientEquiv_mk I n s
+
+def tensorEquiv [IsNoetherianRing R] [Module.Finite R S] (I : Ideal R) :
+    TensorProduct R (AdicCompletion I R) S ≃ₗ[R]
+      AdicCompletion (I.map (algebraMap R S)) S :=
+  ((AdicCompletion.ofTensorProductEquivOfFiniteNoetherian I S).restrictScalars R).trans
+    (equiv I)
+
+@[simp] theorem tensorEquiv_one_tmul [IsNoetherianRing R] [Module.Finite R S]
+    (I : Ideal R) (s : S) :
+    tensorEquiv I (1 ⊗ₜ[R] s) = AdicCompletion.of (I.map (algebraMap R S)) S s := by
+  change equiv I (AdicCompletion.ofTensorProduct I S (1 ⊗ₜ[R] s)) = _
+  rw [AdicCompletion.ofTensorProduct_tmul, one_smul, equiv_of]
+
+end BoundaryOnly.FormalObstruction.AlgebraicReplacement.CompletionScalar
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/AlgebraicObstruction/SemilocalCompletion.lean b/lean/OAI/Algebra/AlgebraicObstruction/SemilocalCompletion.lean
new file mode 100644
index 0000000000000000000000000000000000000000..dd4049a11d38330119b5c2340f0f3c88eda77da4
--- /dev/null
+++ b/lean/OAI/Algebra/AlgebraicObstruction/SemilocalCompletion.lean
@@ -0,0 +1,350 @@
+import Mathlib
+import OAI.Algebra.FrobeniusObstruction.Obstruction
+import OAI.Algebra.AlgebraicObstruction.TaylorCoefficients
+
+namespace OAI
+
+noncomputable section
+open scoped BigOperators
+
+namespace BoundaryOnly.FormalObstruction.AlgebraicReplacement.AdicFunctor
+variable {R S : Type*} [CommRing R] [CommRing S]
+
+lemma map_map_equiv (I : Ideal R) (J : Ideal S) (e : R ≃+* S)
+    (h : I ≤ J.comap e.toRingHom) (h' : J ≤ I.comap e.symm.toRingHom) (x : AdicCompletion I R) :
+    map J I e.symm.toRingHom h' (map I J e.toRingHom h x) = x := by
+  apply AdicCompletion.ext_evalₐ
+  intro n
+  rw [eval_map,eval_map]
+  generalize AdicCompletion.evalₐ I n x = y
+  induction y using Quotient.inductionOn' with
+  | _ r => change Ideal.Quotient.mk _ (e.symm (e r)) = _; rw [e.symm_apply_apply]; rfl
+
+noncomputable def equiv (I : Ideal R) (J : Ideal S) (e : R ≃+* S)
+    (h : I ≤ J.comap e.toRingHom) (h' : J ≤ I.comap e.symm.toRingHom) :
+    AdicCompletion I R ≃+* AdicCompletion J S :=
+  { map I J e.toRingHom h with
+    invFun := map J I e.symm.toRingHom h'
+    left_inv := map_map_equiv I J e h h'
+    right_inv := map_map_equiv J I e.symm h' h }
+
+end BoundaryOnly.FormalObstruction.AlgebraicReplacement.AdicFunctor
+
+namespace BoundaryOnly.FormalObstruction.AlgebraicReplacement.PolynomialPointCompletion
+variable {K α : Type*} [Field K] [Finite α]
+open MvPolynomial
+
+noncomputable def shift (a : α → K) : MvPolynomial α K ≃ₐ[K] MvPolynomial α K :=
+  AlgEquiv.ofAlgHom (aeval fun i ↦ X i + C (a i)) (aeval fun i ↦ X i - C (a i))
+    (by ext i; simp) (by ext i; simp)
+
+omit [Finite α] in
+lemma vars_ker [Finite α] : idealOfVars α K = RingHom.ker (constantCoeff : MvPolynomial α K →+* K) := by
+  apply le_antisymm
+  · rw [idealOfVars,Ideal.span_le]
+    rintro _ ⟨i,rfl⟩
+    simp
+  · intro p hp
+    rw [← pow_one (idealOfVars α K),mem_pow_idealOfVars_iff]
+    intro e he
+    have he0 : e ≠ 0 := by
+      intro h; subst e
+      exact (mem_support_iff.mp he) hp
+    exact Nat.one_le_iff_ne_zero.mpr (by simpa [Finsupp.degree_eq_zero_iff] using he0)
+
+omit [Finite α] in
+lemma constant_shift [Finite α] (a : α → K) (p : MvPolynomial α K) :
+    constantCoeff (shift a p) = aeval a p := by
+  have h : (constantCoeff : MvPolynomial α K →+* K).comp (shift a).toRingHom =
+      (aeval a).toRingHom := by
+    apply MvPolynomial.ringHom_ext
+    · intro k; simp [shift]
+    · intro i; simp [shift]
+  exact RingHom.congr_fun h p
+
+noncomputable def completionEquiv (a : α → K) :
+    AdicCompletion (RingHom.ker (aeval a : MvPolynomial α K →ₐ[K] K).toRingHom) (MvPolynomial α K) ≃+*
+      AdicCompletion (idealOfVars α K) (MvPolynomial α K) :=
+  AdicFunctor.equiv _ _ (shift a).toRingEquiv
+    (by intro p hp; rw [vars_ker]; exact (constant_shift a p).trans hp)
+    (by
+      intro p hp
+      change aeval a ((shift a).symm p) = 0
+      rw [← constant_shift,AlgEquiv.apply_symm_apply]
+      rw [vars_ker] at hp
+      exact hp)
+
+theorem isDomain_completion (a : α → K) :
+    IsDomain (AdicCompletion (RingHom.ker (aeval a : MvPolynomial α K →ₐ[K] K).toRingHom) (MvPolynomial α K)) := by
+  have : IsDomain (MvPowerSeries α K) := NoZeroDivisors.to_isDomain _
+  let e := (completionEquiv a).trans (MvPowerSeries.toAdicCompletionAlgEquiv α K).symm.toRingEquiv
+  exact Function.Injective.isDomain e e.injective
+
+end BoundaryOnly.FormalObstruction.AlgebraicReplacement.PolynomialPointCompletion
+
+namespace BoundaryOnly.FormalObstruction.AlgebraicReplacement.CompletionScalar
+open scoped TensorProduct
+variable {R S : Type*} [CommRing R] [CommRing S] [Algebra R S]
+
+noncomputable def algebraMapCompletion (I : Ideal R) :
+    AdicCompletion I R →ₐ[R] AdicCompletion (I.map (algebraMap R S)) S :=
+  { AdicFunctor.map I (I.map (algebraMap R S)) (algebraMap R S) Ideal.le_comap_map with
+    commutes' := fun r ↦ AdicFunctor.map_of I (I.map (algebraMap R S))
+      (algebraMap R S) Ideal.le_comap_map r }
+
+noncomputable def tensorHom (I : Ideal R) :
+    AdicCompletion I R ⊗[R] S →ₐ[R] AdicCompletion (I.map (algebraMap R S)) S :=
+  Algebra.TensorProduct.lift (algebraMapCompletion I)
+    (IsScalarTower.toAlgHom R S _) (fun _ _ ↦ Commute.all _ _)
+
+universe u
+variable {R S : Type u} [CommRing R] [CommRing S] [Algebra R S]
+
+lemma tensorHom_eq [IsNoetherianRing R] [Module.Finite R S] (I : Ideal R) :
+    (tensorHom (S := S) I).toLinearMap = (tensorEquiv I).toLinearMap := by
+  apply TensorProduct.ext'
+  intro r s
+  change AdicFunctor.map I (I.map (algebraMap R S)) (algebraMap R S)
+      Ideal.le_comap_map r * AdicCompletion.of (I.map (algebraMap R S)) S s =
+    tensorEquiv I (r ⊗ₜ[R] s)
+  exact (tensorEquiv_tmul I r s).symm
+
+noncomputable def tensorAlgEquiv [IsNoetherianRing R] [Module.Finite R S] (I : Ideal R) :
+    AdicCompletion I R ⊗[R] S ≃ₐ[R] AdicCompletion (I.map (algebraMap R S)) S :=
+  AlgEquiv.ofBijective (tensorHom I) (by
+    change Function.Bijective (tensorHom I).toLinearMap
+    rw [tensorHom_eq]
+    exact (tensorEquiv I).bijective)
+
+end BoundaryOnly.FormalObstruction.AlgebraicReplacement.CompletionScalar
+
+namespace BoundaryOnly.FormalObstruction.AlgebraicReplacement.CompletionCRT
+open Function
+variable {R ι : Type*} [CommRing R] [Fintype ι]
+
+lemma pow_iInf (I : ι → Ideal R) (hI : Pairwise (IsCoprime on I)) (n : ℕ) :
+    (⨅ i, I i)^n = ⨅ i, I i ^ n := by
+  classical
+  have h (J : ι → Ideal R) (hJ : Pairwise (IsCoprime on J)) :
+      ∏ i, J i = ⨅ i, J i := by
+    simpa using Ideal.prod_eq_iInf_of_pairwise_isCoprime
+      (s := Finset.univ) (J := J) (fun i _ j _ hij ↦ hJ hij)
+  rw [← h I hI,← h (fun i ↦ I i^n) (fun i j hij ↦ (hI hij).pow)]
+  exact (Finset.prod_pow _ _ _).symm
+
+noncomputable def level (I : ι → Ideal R) (hI : Pairwise (IsCoprime on I)) (n : ℕ) :
+    R ⧸ (⨅ i, I i)^n ≃+* ∀ i, R ⧸ I i^n :=
+  (Ideal.quotEquivOfEq (pow_iInf I hI n)).trans
+    (Ideal.quotientInfRingEquivPiQuotient (fun i ↦ I i^n)
+      (fun _ _ hij ↦ (hI hij).pow))
+
+@[simp] lemma level_mk (I : ι → Ideal R) (hI : Pairwise (IsCoprime on I))
+    (n : ℕ) (r : R) (i : ι) :
+    level I hI n (Ideal.Quotient.mk _ r) i = Ideal.Quotient.mk (I i^n) r := rfl
+
+lemma level_factor (I : ι → Ideal R) (hI : Pairwise (IsCoprime on I))
+    {m n : ℕ} (h : m ≤ n) (x : R ⧸ (⨅ i, I i)^n) (i : ι) :
+    level I hI m (Ideal.Quotient.factorPow (⨅ i, I i) h x) i =
+      Ideal.Quotient.factorPow (I i) h (level I hI n x i) := by
+  induction x using Quotient.inductionOn' with
+  | _ r => rfl
+
+noncomputable def forward (I : ι → Ideal R) :
+    AdicCompletion (⨅ i, I i) R →+* ∀ i, AdicCompletion (I i) R :=
+  RingHom.pi (fun i ↦ AdicFunctor.map (⨅ i, I i) (I i) (RingHom.id R)
+    (by simpa using (iInf_le I i)))
+
+lemma eval_to (I : ι → Ideal R) (hI : Pairwise (IsCoprime on I))
+    (n : ℕ) (x : AdicCompletion (⨅ i, I i) R) (i : ι) :
+    AdicCompletion.evalₐ (I i) n (forward I x i) =
+      level I hI n (AdicCompletion.evalₐ (⨅ i, I i) n x) i := by
+  change AdicCompletion.evalₐ (I i) n (AdicFunctor.map _ _ _ _ x) = _
+  rw [AdicFunctor.eval_map]
+  generalize AdicCompletion.evalₐ (⨅ i, I i) n x = y
+  induction y using Quotient.inductionOn' with
+  | _ r => rfl
+
+noncomputable def inverseFamily (I : ι → Ideal R)
+    (hI : Pairwise (IsCoprime on I)) (n : ℕ) :
+    (∀ i, AdicCompletion (I i) R) →+* R ⧸ (⨅ i, I i)^n :=
+  (level I hI n).symm.toRingHom.comp
+    (RingHom.pi fun i ↦ (AdicCompletion.evalₐ (I i) n).toRingHom.comp (Pi.evalRingHom _ i))
+
+lemma inverseFamily_compatible (I : ι → Ideal R) (hI : Pairwise (IsCoprime on I))
+    {m n : ℕ} (h : m ≤ n) :
+    (Ideal.Quotient.factorPow (⨅ i, I i) h).comp (inverseFamily I hI n) =
+      inverseFamily I hI m := by
+  ext x
+  apply (level I hI m).injective
+  funext i
+  change level I hI m (Ideal.Quotient.factorPow (⨅ i, I i) h
+    ((level I hI n).symm (fun j ↦ AdicCompletion.evalₐ (I j) n (x j)))) i =
+    level I hI m ((level I hI m).symm (fun j ↦ AdicCompletion.evalₐ (I j) m (x j))) i
+  rw [level_factor,RingEquiv.apply_symm_apply,RingEquiv.apply_symm_apply]
+  exact AdicCofinal.factor_eval (I i) h (x i)
+
+noncomputable def inverse (I : ι → Ideal R) (hI : Pairwise (IsCoprime on I)) :
+    (∀ i, AdicCompletion (I i) R) →+* AdicCompletion (⨅ i, I i) R :=
+  AdicCompletion.liftRingHom _ (inverseFamily I hI) (inverseFamily_compatible I hI)
+
+lemma eval_inverse (I : ι → Ideal R) (hI : Pairwise (IsCoprime on I))
+    (n : ℕ) (x : ∀ i, AdicCompletion (I i) R) :
+    AdicCompletion.evalₐ (⨅ i, I i) n (inverse I hI x) =
+      (level I hI n).symm (fun i ↦ AdicCompletion.evalₐ (I i) n (x i)) :=
+  AdicCompletion.evalₐ_liftRingHom _ _ (inverseFamily_compatible I hI) n x
+
+noncomputable def equiv (I : ι → Ideal R) (hI : Pairwise (IsCoprime on I)) :
+    AdicCompletion (⨅ i, I i) R ≃+* ∀ i, AdicCompletion (I i) R :=
+  { forward I with
+    invFun := inverse I hI
+    left_inv := fun x ↦ by
+      apply AdicCompletion.ext_evalₐ
+      intro n
+      rw [eval_inverse]
+      apply (level I hI n).injective
+      rw [RingEquiv.apply_symm_apply]
+      funext i
+      exact eval_to I hI n x i
+    right_inv := fun x ↦ by
+      funext i
+      apply AdicCompletion.ext_evalₐ
+      intro n
+      change AdicCompletion.evalₐ (I i) n (forward I (inverse I hI x) i) = _
+      rw [eval_to I hI,eval_inverse,RingEquiv.apply_symm_apply] }
+
+theorem reduced_factor (I : ι → Ideal R) (hI : Pairwise (IsCoprime on I))
+    [IsReduced (AdicCompletion (⨅ i, I i) R)] (i : ι) :
+    IsReduced (AdicCompletion (I i) R) := by
+  classical
+  have : IsReduced (∀ i, AdicCompletion (I i) R) :=
+    isReduced_of_injective (equiv I hI).symm (equiv I hI).symm.injective
+  constructor
+  intro x hx
+  obtain ⟨n,hn⟩ := hx
+  have hn1 : x^(n+1) = 0 := by rw [pow_succ,hn,zero_mul]
+  let y : ∀ j, AdicCompletion (I j) R := fun j ↦ if h : j = i then h ▸ x else 0
+  have hy : IsNilpotent y := ⟨n+1,by
+    funext j
+    by_cases h : j = i
+    · subst j
+      simpa [y] using hn1
+    · simp [y,h]⟩
+  have hz := congrFun hy.eq_zero i
+  simpa [y] using hz
+
+end BoundaryOnly.FormalObstruction.AlgebraicReplacement.CompletionCRT
+
+namespace BoundaryOnly.FormalObstruction.AlgebraicReplacement.PowerCofinal
+variable {R : Type*} [CommRing R]
+
+def family (I J : Ideal R) (c : ℕ)
+    (hc : ∀ n, I ^ (c*n) ≤ J ^ n) (n : ℕ) :
+    AdicCompletion I R →+* R ⧸ J ^ n :=
+  (Ideal.Quotient.factor (hc n)).comp (AdicCompletion.evalₐ I (c*n)).toRingHom
+
+lemma compatible (I J : Ideal R) (c : ℕ)
+    (hc : ∀ n, I ^ (c*n) ≤ J ^ n) {m n : ℕ} (h : m ≤ n) :
+    (Ideal.Quotient.factorPow J h).comp (family I J c hc n) = family I J c hc m := by
+  ext x
+  have hx := AdicCofinal.factor_eval I (Nat.mul_le_mul_left c h) x
+  have hy := congrArg (Ideal.Quotient.factor (hc m)) hx
+  simpa only [family,RingHom.comp_apply,AlgHom.toRingHom_eq_coe,RingHom.coe_coe,
+    Ideal.Quotient.factorPow,Ideal.Quotient.factor_comp_apply] using hy
+
+noncomputable def map (I J : Ideal R) (c : ℕ)
+    (hc : ∀ n, I ^ (c*n) ≤ J ^ n) : AdicCompletion I R →+* AdicCompletion J R :=
+  AdicCompletion.liftRingHom J (family I J c hc) (compatible I J c hc)
+
+@[simp] lemma eval_map (I J : Ideal R) (c : ℕ)
+    (hc : ∀ n, I ^ (c*n) ≤ J ^ n) (n : ℕ) (x : AdicCompletion I R) :
+    AdicCompletion.evalₐ J n (map I J c hc x) =
+      Ideal.Quotient.factor (hc n) (AdicCompletion.evalₐ I (c*n) x) :=
+  AdicCompletion.evalₐ_liftRingHom J _ (compatible I J c hc) n x
+
+lemma map_map (I J : Ideal R) (c d : ℕ) (hc0 : 0 < c) (hd0 : 0 < d)
+    (hc : ∀ n, I ^ (c*n) ≤ J ^ n) (hd : ∀ n, J ^ (d*n) ≤ I ^ n)
+    (x : AdicCompletion I R) : map J I d hd (map I J c hc x) = x := by
+  apply AdicCompletion.ext_evalₐ
+  intro n
+  simp only [eval_map]
+  have hn : n ≤ c*(d*n) := (Nat.le_mul_of_pos_left n hd0).trans
+    (Nat.le_mul_of_pos_left (d*n) hc0)
+  have he := AdicCofinal.factor_eval I hn x
+  simpa only [Ideal.Quotient.factorPow,Ideal.Quotient.factor_comp_apply] using he
+
+noncomputable def equiv (I J : Ideal R) (c d : ℕ) (hc0 : 0 < c) (hd0 : 0 < d)
+    (hc : ∀ n, I ^ (c*n) ≤ J ^ n) (hd : ∀ n, J ^ (d*n) ≤ I ^ n) :
+    AdicCompletion I R ≃+* AdicCompletion J R :=
+  { map I J c hc with
+    invFun := map J I d hd
+    left_inv := map_map I J c d hc0 hd0 hc hd
+    right_inv := map_map J I d c hd0 hc0 hd hc }
+
+noncomputable def radicalEquiv [IsNoetherianRing R] (I : Ideal R) :
+    AdicCompletion I R ≃+* AdicCompletion I.radical R := by
+  let hc0 := Ideal.exists_pow_le_of_le_radical_of_fg (le_refl I.radical)
+    (IsNoetherian.noetherian I.radical)
+  let c := hc0.choose
+  have hc := hc0.choose_spec
+  refine equiv I I.radical 1 (c+1) (by omega) (by omega)
+    (fun n ↦ by simpa using (pow_le_pow_left' Ideal.le_radical n)) ?_
+  intro n
+  rw [pow_mul]
+  exact pow_le_pow_left' ((Ideal.pow_le_pow_right (by omega : c ≤ c+1)).trans hc) n
+
+end BoundaryOnly.FormalObstruction.AlgebraicReplacement.PowerCofinal
+
+namespace BoundaryOnly.FormalObstruction.AlgebraicReplacement.SemilocalCompletion
+variable {R : Type*} [CommRing R] [IsNoetherianRing R]
+variable (I : Ideal R) [IsArtinianRing (R ⧸ I)]
+
+noncomputable def primes (p : PrimeSpectrum (R ⧸ I)) : Ideal R :=
+  p.asIdeal.comap (Ideal.Quotient.mk I)
+
+instance primesMaximal (p : PrimeSpectrum (R ⧸ I)) : (primes I p).IsMaximal :=
+  Ideal.comap_isMaximal_of_surjective _ (Ideal.Quotient.mk_surjective)
+
+omit [IsNoetherianRing R] in
+lemma primes_pairwise [IsNoetherianRing R] :
+    Pairwise (fun p q ↦ IsCoprime (primes I p) (primes I q)) := by
+  intro p q hpq
+  apply Ideal.isCoprime_of_isMaximal
+  intro h
+  apply hpq
+  apply PrimeSpectrum.ext
+  exact Ideal.comap_injective_of_surjective (Ideal.Quotient.mk I)
+    Ideal.Quotient.mk_surjective h
+
+omit [IsNoetherianRing R] [IsArtinianRing (R ⧸ I)] in
+lemma iInf_primes [IsNoetherianRing R] [IsArtinianRing (R ⧸ I)] :
+    (⨅ p, primes I p) = I.radical := by
+  unfold primes
+  rw [← Ideal.comap_iInf,← PrimeSpectrum.nilradical_eq_iInf]
+  change (Ideal.radical (⊥ : Ideal (R ⧸ I))).comap _ = _
+  rw [Ideal.comap_radical,← RingHom.ker_eq_comap_bot,Ideal.mk_ker]
+
+theorem reduced_at_maximal [IsReduced (AdicCompletion I R)]
+    (p : Ideal R) [p.IsMaximal] (hIp : I ≤ p) : IsReduced (AdicCompletion p R) := by
+  classical
+  let : Fintype (PrimeSpectrum (R ⧸ I)) := Fintype.ofFinite _
+  have : IsReduced (AdicCompletion I.radical R) :=
+    isReduced_of_injective (PowerCofinal.radicalEquiv I).symm
+      (PowerCofinal.radicalEquiv I).symm.injective
+  have : IsReduced (AdicCompletion (⨅ q,primes I q) R) := by
+    rw [iInf_primes]
+    infer_instance
+  have hp : (p.map (Ideal.Quotient.mk I)).IsPrime :=
+    Ideal.map_isPrime_of_surjective Ideal.Quotient.mk_surjective (by simpa using hIp)
+  let q : PrimeSpectrum (R ⧸ I) := ⟨p.map (Ideal.Quotient.mk I),hp⟩
+  have hq : primes I q = p := by
+    change (p.map (Ideal.Quotient.mk I)).comap (Ideal.Quotient.mk I) = p
+    rw [Ideal.comap_map_of_surjective _ Ideal.Quotient.mk_surjective]
+    rw [← RingHom.ker_eq_comap_bot,Ideal.mk_ker,sup_eq_left.mpr hIp]
+  rw [← hq]
+  exact CompletionCRT.reduced_factor (primes I) (primes_pairwise I) q
+
+end BoundaryOnly.FormalObstruction.AlgebraicReplacement.SemilocalCompletion
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/AlgebraicObstruction/SeriesJets.lean b/lean/OAI/Algebra/AlgebraicObstruction/SeriesJets.lean
new file mode 100644
index 0000000000000000000000000000000000000000..d6b26f57a597c9e8c05a594949ac315a5524a220
--- /dev/null
+++ b/lean/OAI/Algebra/AlgebraicObstruction/SeriesJets.lean
@@ -0,0 +1,188 @@
+import Mathlib
+import OAI.Algebra.FrobeniusObstruction.Obstruction
+
+namespace OAI
+
+noncomputable section
+open scoped BigOperators
+
+namespace BoundaryOnly.FormalObstruction.FormalCorrection
+open MvPowerSeries
+variable {R σ ι : Type*} [CommRing R]
+
+def Close (n : ℕ) (f g : ι → MvPowerSeries σ R) : Prop :=
+  ∀ i e, e.degree < n → coeff e (f i) = coeff e (g i)
+
+ theorem Close.refl (n : ℕ) (f : ι → MvPowerSeries σ R) : Close n f f :=
+  fun _ _ _ => rfl
+ theorem Close.symm {n : ℕ} {f g : ι → MvPowerSeries σ R} (h : Close n f g) :
+    Close n g f := fun i e he => (h i e he).symm
+ theorem Close.trans {n : ℕ} {f g h : ι → MvPowerSeries σ R}
+    (hfg : Close n f g) (hgh : Close n g h) : Close n f h :=
+  fun i e he => (hfg i e he).trans (hgh i e he)
+ theorem Close.mono {n m : ℕ} {f g : ι → MvPowerSeries σ R}
+    (h : Close n f g) (hm : m ≤ n) : Close m f g :=
+  fun i e he => h i e (lt_of_lt_of_le he hm)
+ theorem Close.zero (f g : ι → MvPowerSeries σ R) : Close 0 f g :=
+  fun _ _ he => (Nat.not_lt_zero _ he).elim
+ theorem Close.ext {f g : ι → MvPowerSeries σ R} (h : ∀ n, Close n f g) : f = g := by
+  funext i
+  ext e
+  exact h (e.degree + 1) i e (Nat.lt_succ_self _)
+
+variable (T : (ι → MvPowerSeries σ R) → (ι → MvPowerSeries σ R))
+variable (hT : ∀ n f g, Close n f g → Close (n + 1) (T f) (T g))
+include hT
+
+ theorem iterate_step_close (n : ℕ) : Close n (T^[n] 0) (T^[n+1] 0) := by
+  induction n with
+  | zero => exact Close.zero _ _
+  | succ n ih =>
+    simpa only [Function.iterate_succ_apply'] using hT n _ _ ih
+
+ theorem iterate_later_close {n m : ℕ} (hnm : n ≤ m) :
+    Close n (T^[n] 0) (T^[m] 0) := by
+  induction m, hnm using Nat.le_induction with
+  | base => exact Close.refl _ _
+  | succ m hnm ih =>
+    exact ih.trans ((iterate_step_close T hT m).mono hnm)
+
+omit hT in
+
+def fixedPoint : ι → MvPowerSeries σ R :=
+  fun i e => coeff e ((T^[e.degree + 1] 0) i)
+
+ theorem fixedPoint_close (n : ℕ) : Close n (fixedPoint T) (T^[n] 0) := by
+  intro i e he
+  exact iterate_later_close T hT (Nat.add_one_le_iff.mpr he) i e (Nat.lt_succ_self _)
+
+ theorem fixedPoint_eq : T (fixedPoint T) = fixedPoint T := by
+  apply Close.ext
+  intro n
+  apply (hT n _ _ (fixedPoint_close T hT n)).mono (Nat.le_succ n) |>.trans
+  simpa only [Function.iterate_succ_apply'] using
+    ((fixedPoint_close T hT (n+1)).symm.mono (Nat.le_succ n))
+
+ theorem fixedPoint_unique {f : ι → MvPowerSeries σ R} (hf : T f = f) :
+    f = fixedPoint T := by
+  apply Close.ext
+  intro n
+  induction n with
+  | zero => exact Close.zero _ _
+  | succ n ih => simpa only [hf, fixedPoint_eq T hT] using hT n _ _ ih
+
+ theorem exists_unique_fixedPoint : ∃! f, T f = f :=
+  ⟨fixedPoint T, fixedPoint_eq T hT, fun _ h => fixedPoint_unique T hT h⟩
+
+end BoundaryOnly.FormalObstruction.FormalCorrection
+
+namespace BoundaryOnly.FormalObstruction.FormalCorrection
+open MvPowerSeries
+variable {R σ τ ι : Type*} [CommRing R]
+
+def Vanishes (n : ℕ) (f : MvPowerSeries σ R) : Prop :=
+  ∀ e, e.degree < n → coeff e f = 0
+
+def Jet (n : ℕ) (f g : MvPowerSeries σ R) : Prop := Vanishes n (f-g)
+
+ theorem Vanishes.iff_order {n : ℕ} {f : MvPowerSeries σ R} :
+    Vanishes n f ↔ (n : ℕ∞) ≤ f.order := by
+  constructor
+  · exact nat_le_order
+  · intro h e he
+    exact coeff_of_lt_order (lt_of_lt_of_le (by exact_mod_cast he) h)
+ theorem Vanishes.zero (n : ℕ) : Vanishes n (0 : MvPowerSeries σ R) := by
+  intro e he; exact map_zero _
+ theorem Vanishes.mono {n m : ℕ} {f : MvPowerSeries σ R} (h : Vanishes n f)
+    (hm : m ≤ n) : Vanishes m f := fun e he => h e (lt_of_lt_of_le he hm)
+ theorem Vanishes.add {n : ℕ} {f g : MvPowerSeries σ R}
+    (hf : Vanishes n f) (hg : Vanishes n g) : Vanishes n (f+g) := by
+  intro e he; simp only [map_add, hf e he, hg e he, add_zero]
+ theorem Vanishes.neg {n : ℕ} {f : MvPowerSeries σ R}
+    (hf : Vanishes n f) : Vanishes n (-f) := by
+  intro e he; simp only [map_neg, hf e he, neg_zero]
+ theorem Vanishes.mul {n m : ℕ} {f g : MvPowerSeries σ R}
+    (hf : Vanishes n f) (hg : Vanishes m g) : Vanishes (n+m) (f*g) := by
+  apply Vanishes.iff_order.mpr
+  calc
+    ((n+m : ℕ) : ℕ∞) = (n : ℕ∞) + m := by simp only [Nat.cast_add]
+    _ ≤ f.order + g.order := add_le_add (Vanishes.iff_order.mp hf) (Vanishes.iff_order.mp hg)
+    _ ≤ (f*g).order := le_order_mul
+ theorem Vanishes.all (f : MvPowerSeries σ R) : Vanishes 0 f :=
+  fun _ h => (Nat.not_lt_zero _ h).elim
+ theorem Vanishes.mul_right {n : ℕ} {f : MvPowerSeries σ R}
+    (hf : Vanishes n f) (g : MvPowerSeries σ R) : Vanishes n (f*g) := by
+  simpa only [Nat.add_zero] using hf.mul (Vanishes.all g)
+ theorem Vanishes.mul_left {n : ℕ} {f : MvPowerSeries σ R}
+    (hf : Vanishes n f) (g : MvPowerSeries σ R) : Vanishes n (g*f) := by
+  simpa only [Nat.zero_add] using (Vanishes.all g).mul hf
+ theorem Vanishes.sum {n : ℕ} (s : Finset ι) (f : ι → MvPowerSeries σ R)
+    (hf : ∀ i ∈ s, Vanishes n (f i)) : Vanishes n (∑ i ∈ s, f i) := by
+  classical
+  intro e he
+  simp only [map_sum]
+  exact Finset.sum_eq_zero fun i hi => hf i hi e he
+ theorem Vanishes.one_iff {f : MvPowerSeries σ R} :
+    Vanishes 1 f ↔ constantCoeff f = 0 := by
+  rw [Vanishes.iff_order]
+  exact one_le_order_iff_constCoeff_eq_zero
+
+ theorem Jet.iff_coeff {n : ℕ} {f g : MvPowerSeries σ R} :
+    Jet n f g ↔ ∀ e, e.degree < n → coeff e f = coeff e g := by
+  simp only [Jet, Vanishes, map_sub, sub_eq_zero]
+ theorem Jet.refl (n : ℕ) (f : MvPowerSeries σ R) : Jet n f f :=
+  Jet.iff_coeff.mpr fun _ _ => rfl
+ theorem Jet.symm {n : ℕ} {f g : MvPowerSeries σ R} (h : Jet n f g) : Jet n g f :=
+  Jet.iff_coeff.mpr fun e he => (Jet.iff_coeff.mp h e he).symm
+ theorem Jet.trans {n : ℕ} {f g h : MvPowerSeries σ R}
+    (hfg : Jet n f g) (hgh : Jet n g h) : Jet n f h :=
+  Jet.iff_coeff.mpr fun e he => (Jet.iff_coeff.mp hfg e he).trans (Jet.iff_coeff.mp hgh e he)
+ theorem Jet.mono {n m : ℕ} {f g : MvPowerSeries σ R} (h : Jet n f g)
+    (hm : m ≤ n) : Jet m f g := Vanishes.mono h hm
+ theorem Jet.neg {n : ℕ} {f g : MvPowerSeries σ R} (h : Jet n f g) : Jet n (-f) (-g) := by
+  apply Jet.iff_coeff.mpr
+  intro e he
+  simp only [map_neg, Jet.iff_coeff.mp h e he]
+ theorem Jet.sub {n : ℕ} {f g f' g' : MvPowerSeries σ R}
+    (hf : Jet n f f') (hg : Jet n g g') : Jet n (f-g) (f'-g') := by
+  apply Jet.iff_coeff.mpr
+  intro e he
+  simp only [map_sub, Jet.iff_coeff.mp hf e he, Jet.iff_coeff.mp hg e he]
+ theorem jet_iff_truncTotal [Finite σ] {n : ℕ} {f g : MvPowerSeries σ R} :
+    Jet n f g ↔ truncTotal n f = truncTotal n g := by
+  rw [Jet.iff_coeff]
+  constructor
+  · intro h
+    ext e
+    by_cases he : e.degree < n
+    · simpa only [coeff_truncTotal _ he] using h e he
+    · simp only [coeff_truncTotal_eq_zero _ (not_lt.mp he)]
+  · intro h e he
+    simpa only [coeff_truncTotal _ he] using
+      congrArg (fun polynomial : MvPolynomial σ R => polynomial.coeff e) h
+
+ theorem Jet.subst [Finite σ] [Finite τ] {n : ℕ} {a b : σ → MvPowerSeries τ R}
+    (ha : ∀ i, constantCoeff (a i) = 0) (hb : ∀ i, constantCoeff (b i) = 0)
+    (hab : ∀ i, Jet n (a i) (b i)) (f : MvPowerSeries σ R) :
+    Jet n (MvPowerSeries.subst a f) (MvPowerSeries.subst b f) := by
+  apply jet_iff_truncTotal.mpr
+  have ha' := hasSubst_of_constantCoeff_zero ha
+  have hb' := hasSubst_of_constantCoeff_zero hb
+  have harg : (fun i => (truncTotal n (a i)).toMvPowerSeries) =
+      (fun i => (truncTotal n (b i)).toMvPowerSeries) := by
+    funext i
+    exact congrArg MvPolynomial.toMvPowerSeries (jet_iff_truncTotal.mp (hab i))
+  calc
+    truncTotal n (MvPowerSeries.subst a f) = truncTotal n
+      (MvPowerSeries.subst (fun i => (truncTotal n (a i)).toMvPowerSeries) f) :=
+        truncTotal_subst_eq_truncTotal_subst_truncTotal_of_le ha' (fun _ => le_refl n)
+    _ = truncTotal n (MvPowerSeries.subst (fun i => (truncTotal n (b i)).toMvPowerSeries) f) :=
+        congrArg (fun z => truncTotal n (MvPowerSeries.subst z f)) harg
+    _ = truncTotal n (MvPowerSeries.subst b f) :=
+        (truncTotal_subst_eq_truncTotal_subst_truncTotal_of_le hb' (fun _ => le_refl n)).symm
+
+end BoundaryOnly.FormalObstruction.FormalCorrection
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/AlgebraicObstruction/Specialization.lean b/lean/OAI/Algebra/AlgebraicObstruction/Specialization.lean
new file mode 100644
index 0000000000000000000000000000000000000000..fc7e276b87111896f33147237c52cde198f801e9
--- /dev/null
+++ b/lean/OAI/Algebra/AlgebraicObstruction/Specialization.lean
@@ -0,0 +1,119 @@
+import Mathlib
+import OAI.Algebra.FrobeniusObstruction.Obstruction
+import OAI.Algebra.AlgebraicObstruction.CoefficientData
+
+namespace OAI
+
+noncomputable section
+open scoped BigOperators
+
+namespace BoundaryOnly.FormalObstruction.Specialization
+open PrimeSpectrum
+
+variable (R : Type*) [CommRing R] [IsDomain R] [CharZero R]
+  [Algebra.FiniteType ℤ R]
+
+theorem spectrum_contains_basic_open :
+    ∃ N : ℤ, N ≠ 0 ∧ (basicOpen N : Set (PrimeSpectrum ℤ)) ⊆
+      Set.range (comap (algebraMap ℤ R)) := by
+  have : Algebra.FinitePresentation ℤ R := Algebra.FinitePresentation.of_finiteType.mp inferInstance
+  have : Module.Flat ℤ R := inferInstance
+  have hopen : IsOpen (Set.range (comap (algebraMap ℤ R))) := by
+    simpa only [Set.image_univ] using
+      (isOpenMap_comap_of_hasGoingDown_of_finitePresentation (R := ℤ) (S := R))
+        Set.univ isOpen_univ
+  let z : PrimeSpectrum ℤ := ⟨⊥, Ideal.isPrime_bot⟩
+  have hz : z ∈ Set.range (comap (algebraMap ℤ R)) := by
+    refine ⟨⟨⊥, Ideal.isPrime_bot⟩, ?_⟩
+    apply PrimeSpectrum.ext
+    ext a
+    simp only [comap_asIdeal, Ideal.mem_comap, Ideal.mem_bot]
+    exact Int.cast_eq_zero
+  obtain ⟨U, hU, hzU, hUsub⟩ := isBasis_basic_opens.exists_subset_of_mem_open hz hopen
+  obtain ⟨U', ⟨N, rfl⟩, rfl⟩ := hU
+  refine ⟨N, ?_, hUsub⟩
+  change N ≠ 0 at hzU
+  exact hzU
+
+theorem finite_residue_fields_away :
+    ∃ N : ℤ, N ≠ 0 ∧ ∀ p : ℕ, p.Prime → ¬ (p : ℤ) ∣ N →
+      ∃ I : Ideal R, I.IsMaximal ∧ (p : R) ∈ I ∧ Finite (R ⧸ I) := by
+  obtain ⟨N,hN,hopen⟩ := spectrum_contains_basic_open R
+  refine ⟨N,hN,?_⟩
+  intro p hp hpN
+  let : Fact p.Prime := ⟨hp⟩
+  let z : PrimeSpectrum ℤ := comap (Int.castRingHom (ZMod p)) ⟨⊥, Ideal.isPrime_bot⟩
+  have hz : z ∈ (basicOpen N : Set (PrimeSpectrum ℤ)) := by
+    change ¬ (N : ZMod p) ∈ (⊥ : Ideal (ZMod p))
+    simpa only [Ideal.mem_bot, ZMod.intCast_zmod_eq_zero_iff_dvd] using hpN
+  obtain ⟨P,hP⟩ := hopen hz
+  have hpP : (p : R) ∈ P.asIdeal := by
+    have h := congrArg PrimeSpectrum.asIdeal hP
+    have hzmem : (p : ℤ) ∈ z.asIdeal := by
+      change ((p : ℤ) : ZMod p) ∈ (⊥ : Ideal (ZMod p))
+      simp only [Ideal.mem_bot, Int.cast_natCast, CharP.cast_eq_zero]
+    rw [← h] at hzmem
+    change algebraMap ℤ R (p : ℤ) ∈ P.asIdeal at hzmem
+    simpa only [map_natCast, Int.cast_natCast] using hzmem
+  obtain ⟨I,hI,hPI⟩ := Ideal.exists_le_maximal P.asIdeal P.isPrime.ne_top
+  have : I.IsMaximal := hI
+  let : Field (R ⧸ I) := Ideal.Quotient.field I
+  have hpI : (p : R) ∈ I := hPI hpP
+  have : CharP (R ⧸ I) p := (CharP.charP_iff_prime_eq_zero hp).2 (by
+    rw [← map_natCast (Ideal.Quotient.mk I), Ideal.Quotient.eq_zero_iff_mem]
+    exact hpI)
+  let : Algebra (ZMod p) (R ⧸ I) := ZMod.algebra (R ⧸ I) p
+  have : Algebra.FiniteType (ZMod p) (R ⧸ I) :=
+    Algebra.FiniteType.of_restrictScalars_finiteType ℤ (ZMod p) (R ⧸ I)
+  have : Module.Finite (ZMod p) (R ⧸ I) :=
+    finite_of_finite_type_of_isJacobsonRing (ZMod p) (R ⧸ I)
+  exact ⟨I,hI,hpI, Module.finite_of_finite (ZMod p)⟩
+
+universe u
+
+structure Reduction (R : Type u) [CommRing R] (p : ℕ) where
+  K : Type u
+  [field : Field K]
+  [finite : Finite K]
+  [characteristic : CharP K p]
+  hom : R →+* K
+
+theorem finite_field_reduction :
+    ∃ B : ℕ, ∀ p : ℕ, p.Prime → B < p → Nonempty (Reduction R p) := by
+  obtain ⟨N,hN,h⟩ := finite_residue_fields_away R
+  refine ⟨N.natAbs,?_⟩
+  intro p hp hpB
+  have hpN : ¬ (p : ℤ) ∣ N := by
+    intro hd
+    have hh := Int.natAbs_le_of_dvd_ne_zero hd hN
+    simp only [Int.natAbs_natCast] at hh
+    omega
+  obtain ⟨I,hI,hpI,hfin⟩ := h p hp hpN
+  let : I.IsMaximal := hI
+  let : Field (R ⧸ I) := Ideal.Quotient.field I
+  let : Finite (R ⧸ I) := hfin
+  let : CharP (R ⧸ I) p := (CharP.charP_iff_prime_eq_zero hp).2 (by
+    rw [← map_natCast (Ideal.Quotient.mk I), Ideal.Quotient.eq_zero_iff_mem]
+    exact hpI)
+  exact ⟨{ K := R ⧸ I, hom := Ideal.Quotient.mk I }⟩
+
+end BoundaryOnly.FormalObstruction.Specialization
+
+namespace BoundaryOnly.FormalObstruction.CoefficientRing
+
+theorem no_integral_formal_data (R : Type*) [CommRing R] [IsDomain R] [CharZero R]
+    [Algebra.FiniteType ℤ R] (d : ℕ) (hd : 5 ≤ d) (n : Fin d → ℕ) :
+    ¬ Nonempty (FormalData (k := R) n) := by
+  rintro ⟨D⟩
+  obtain ⟨B,hB⟩ := Specialization.finite_field_reduction R
+  obtain ⟨p,hpB,hp⟩ := Nat.exists_infinite_primes (max B 2 + 1)
+  obtain ⟨r⟩ := hB p hp (by omega)
+  let : Field r.K := r.field
+  let : CharP r.K p := r.characteristic
+  exact BoundaryOnly.FormalObstruction.no_formal_data r.K p hp (by omega) d hd n
+    ⟨(D.map r.hom).toField⟩
+end BoundaryOnly.FormalObstruction.CoefficientRing
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/AlgebraicObstruction/SymbolicPowers.lean b/lean/OAI/Algebra/AlgebraicObstruction/SymbolicPowers.lean
new file mode 100644
index 0000000000000000000000000000000000000000..f25898d2f13900711033576e00e8d711ce55bd3b
--- /dev/null
+++ b/lean/OAI/Algebra/AlgebraicObstruction/SymbolicPowers.lean
@@ -0,0 +1,176 @@
+import Mathlib
+import OAI.Algebra.FrobeniusObstruction.Obstruction
+import OAI.Algebra.AlgebraicObstruction.PositiveCoefficients
+import OAI.Algebra.AlgebraicObstruction.TaylorEvaluation
+
+namespace OAI
+
+noncomputable section
+open scoped BigOperators
+
+namespace BoundaryOnly.FormalObstruction.AlgebraicReplacement
+variable {A : Type*} [CommRing A] [IsNoetherianRing A]
+
+theorem primary_symbolic_cofinal (I : Ideal A) :
+    ∃ N : ℕ, 1 ≤ N ∧ ∀ x : A,
+      (∀ (p : Ideal A), p.IsPrime → I ≤ p →
+        ∃ s : A, s ∉ p ∧ s*x ∈ p^N) → x ∈ I := by
+  classical
+  obtain ⟨S,hS,hprimary⟩ := Submodule.isLasker (R := A) (M := A) I
+  have hb : ∀ Q : Ideal A, ∃ n : ℕ, Q.radical^n ≤ Q :=
+    fun Q ↦ Q.exists_radical_pow_le_of_fg Q.radical.fg_of_isNoetherianRing
+  choose n hn using hb
+  refine ⟨S.sup n + 1, by omega, ?_⟩
+  intro x hx
+  rw [← hS]
+  apply Submodule.mem_finsetInf.mpr
+  intro Q hQ
+  have hp : (Ideal.radical Q).IsPrime := Ideal.isPrime_radical (hprimary hQ)
+  have hIQ : I ≤ Q := by
+    rw [← hS]
+    exact Finset.inf_le hQ
+  obtain ⟨s,hs,hsx⟩ := hx (Ideal.radical Q) hp (hIQ.trans Ideal.le_radical)
+  have hN : n Q ≤ S.sup n + 1 := (Finset.le_sup hQ).trans (Nat.le_succ _)
+  have hmem : s*x ∈ Q := hn Q ((Ideal.pow_le_pow_right hN) hsx)
+  exact ((Ideal.isPrimary_iff.mp (hprimary hQ)).2 (by simpa [mul_comm] using hmem)).resolve_right hs
+
+theorem primary_symbolic_cofinal_power (K : Ideal A) (m : ℕ) (_hm : 1 ≤ m) :
+    ∃ N : ℕ, 1 ≤ N ∧ ∀ x : A,
+      (∀ (p : Ideal A), p.IsPrime → K ≤ p →
+        ∃ s : A, s ∉ p ∧ s*x ∈ p^N) → x ∈ K^m := by
+  obtain ⟨N,hN,h⟩ := primary_symbolic_cofinal (K^m)
+  refine ⟨N,hN,?_⟩
+  intro x hx
+  apply h x
+  intro p hp hK
+  have hKp : K ≤ p := by
+    intro a ha
+    have ham : a^m ∈ p := hK (Ideal.pow_mem_pow ha m)
+    exact hp.mem_of_pow_mem m ham
+  exact hx p hp hKp
+
+omit [IsNoetherianRing A] in
+theorem symbolic_denominator_iff (p : Ideal A) [p.IsPrime] (N : ℕ) (x : A) :
+    algebraMap A (Localization.AtPrime p) x ∈
+        (p.map (algebraMap A (Localization.AtPrime p)))^N ↔
+      ∃ s : A, s ∉ p ∧ s*x ∈ p^N := by
+  rw [← Ideal.map_pow,
+    IsLocalization.algebraMap_mem_map_algebraMap_iff p.primeCompl]
+  rfl
+
+end BoundaryOnly.FormalObstruction.AlgebraicReplacement
+
+namespace BoundaryOnly.FormalObstruction.AlgebraicReplacement
+variable {K A α : Type*} [Field K] [PerfectField K] [CommRing A] [IsNoetherianRing A]
+  [Algebra K A] [Algebra (MvPolynomial α K) A] [IsScalarTower K (MvPolynomial α K) A]
+  [Algebra.EssFiniteType K A] [Algebra.FormallyEtale (MvPolynomial α K) A]
+
+theorem taylor_kernel_cofinal (J : Ideal A) (m : ℕ) (hm : 1 ≤ m) :
+    ∃ q : ℕ, ∃ hq : 1 ≤ q,
+      RingHom.ker (TaylorShift.taylor (K := K) (α := α) J.radical q hq) ≤ J^m := by
+  obtain ⟨q,hq,h⟩ := primary_symbolic_cofinal_power J m hm
+  refine ⟨q,hq,?_⟩
+  intro a ha
+  apply h a
+  intro p hp hJp
+  let := hp
+  have hIp : J.radical ≤ p := hp.radical_le_iff.mpr hJp
+  exact SymbolicTaylor.kernel_le_symbolic J.radical p hIp q hq a ha
+
+end BoundaryOnly.FormalObstruction.AlgebraicReplacement
+
+namespace BoundaryOnly.FormalObstruction.AlgebraicReplacement.TaylorTarget
+variable {A B α : Type*} [CommRing A] [CommRing B]
+
+theorem lift_of_coefficients (f : A →+* B) (q : ℕ) (x : Ring B α q)
+    (h : ∀ e, e.degree < q → ∃ a : A, f a = coefficient q e x) :
+    ∃ y : Ring A α q, map f q y = x := by
+  classical
+  let p := representative q x
+  let c : (α →₀ ℕ) → A := fun e ↦ if he : e.degree < q then (h e he).choose else 0
+  have hc (e : α →₀ ℕ) (he : e.degree < q) : f (c e) = coefficient q e x := by
+    dsimp only [c]
+    rw [dite_eq_left he]
+    exact (h e he).choose_spec
+  let r : MvPolynomial α A := ∑ e ∈ p.support, MvPolynomial.monomial e (c e)
+  refine ⟨mk A α q r,?_⟩
+  apply coefficient_ext
+  intro e he
+  rw [coefficient_map f q e he,coefficient_mk q e he]
+  have hr : r.coeff e = if e ∈ p.support then c e else 0 := by
+    simp only [r,MvPolynomial.coeff_sum,MvPolynomial.coeff_monomial]
+    simp
+  rw [hr]
+  split_ifs with hm
+  · exact hc e he
+  · rw [map_zero]
+    have hp : p.coeff e = 0 := not_not.mp (fun hn ↦ hm (MvPolynomial.mem_support_iff.mpr hn))
+    have hx := coefficient_mk q e he p
+    rw [mk_representative] at hx
+    exact (hx.trans hp).symm
+
+lemma coefficient_zero_eq_reduction (q : ℕ) (hq : 1 ≤ q) (x : Ring A α q) :
+    coefficient q 0 x = reduction A α q hq x := by
+  obtain ⟨p,rfl⟩ := mk_surjective q x
+  rw [coefficient_mk q 0 (by simp only [map_zero]; omega),reduction_mk]
+  rfl
+
+end BoundaryOnly.FormalObstruction.AlgebraicReplacement.TaylorTarget
+
+namespace BoundaryOnly.FormalObstruction.FormalCorrection.AffineEtaleChart
+open BoundaryOnly.FormalObstruction.AlgebraicReplacement
+variable {K α : Type} [Field K] [CharZero K] [Finite α]
+
+theorem primitive_approximation_from_constant_reduction (E : AffineEtaleChart K α)
+    (L : Ideal E.LocalRing)
+    (b : AdicCompletion (IsLocalRing.maximalIdeal E.LocalRing) E.LocalRing)
+    (hconstant : ∃ a₀ : E.LocalRing ⧸ L.radical,
+      TaylorTarget.quotientCoefficient
+        (S := AdicCompletion (IsLocalRing.maximalIdeal E.LocalRing) E.LocalRing) L.radical a₀ =
+      Ideal.Quotient.mk (L.radical.map (algebraMap E.LocalRing
+        (AdicCompletion (IsLocalRing.maximalIdeal E.LocalRing) E.LocalRing))) b)
+    (hjets : ∀ i : α, ∀ q : ℕ, 1 ≤ q → ∃ a : E.LocalRing,
+      E.completionDeriv i b - AdicCompletion.of _ _ a ∈
+        (L.map (algebraMap E.LocalRing
+          (AdicCompletion (IsLocalRing.maximalIdeal E.LocalRing) E.LocalRing)))^q)
+    (m : ℕ) (hm : 1 ≤ m) :
+    ∃ a : E.LocalRing, b - AdicCompletion.of _ _ a ∈
+      (L^m).map (algebraMap E.LocalRing
+        (AdicCompletion (IsLocalRing.maximalIdeal E.LocalRing) E.LocalRing)) := by
+  have : Algebra.EssFiniteType K E.LocalRing :=
+    Algebra.EssFiniteType.comp K (MvPolynomial α K) E.LocalRing
+  obtain ⟨q,hq,hcofinal⟩ := taylor_kernel_cofinal (K := K) (α := α) L m hm
+  let I := L.radical
+  let J := IsLocalRing.maximalIdeal E.LocalRing
+  let B := AdicCompletion J E.LocalRing
+  let F := TaylorShift.fullTaylor (K := K) (α := α) I J (q+1) (by omega) b
+  have hcoeff : ∀ e, e.degree < q+1 → ∃ a : E.LocalRing ⧸ I,
+      TaylorTarget.quotientCoefficient (S := B) I a =
+        TaylorTarget.coefficient (q+1) e F := by
+    intro e he
+    by_cases he0 : e = 0
+    · subst e
+      obtain ⟨a₀,ha₀⟩ := hconstant
+      refine ⟨a₀,?_⟩
+      rw [TaylorTarget.coefficient_zero_eq_reduction (q+1) (by omega)]
+      exact ha₀.trans (E.reduction_fullTaylor I (q+1) (by omega) b).symm
+    · exact E.fullTaylor_positive_coefficients I L Ideal.le_radical q hq b
+        (fun i ↦ hjets i q hq) e he he0
+  obtain ⟨x,hx⟩ := TaylorTarget.lift_of_coefficients
+    (TaylorTarget.quotientCoefficient (S := B) I) (q+1) F hcoeff
+  obtain ⟨a,ha,hba⟩ := E.taylor_primitive_tuple I (q+1) (by omega) b x hx.symm
+  refine ⟨a,?_⟩
+  apply Ideal.map_mono (show RingHom.ker
+    (TaylorShift.taylor (K := K) (α := α) I (q+1) (by omega)) ≤ L^m from ?_) hba
+  intro c hc
+  apply hcofinal
+  change TaylorShift.taylor (K := K) (α := α) I q hq c = 0
+  rw [← TaylorShift.lower_taylor (K := K) (α := α) I q hq c]
+  change TaylorTarget.lower q (TaylorShift.taylor (K := K) (α := α) I (q+1) _ c) = 0
+  rw [hc,map_zero]
+
+end BoundaryOnly.FormalObstruction.FormalCorrection.AffineEtaleChart
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/AlgebraicObstruction/TaylorCoefficients.lean b/lean/OAI/Algebra/AlgebraicObstruction/TaylorCoefficients.lean
new file mode 100644
index 0000000000000000000000000000000000000000..ebb7187f6c59ebf3bfad3d7ed651a93c24d0dd19
--- /dev/null
+++ b/lean/OAI/Algebra/AlgebraicObstruction/TaylorCoefficients.lean
@@ -0,0 +1,286 @@
+import Mathlib
+import OAI.Algebra.FrobeniusObstruction.Obstruction
+import OAI.Algebra.AlgebraicObstruction.IdealBounds
+
+namespace OAI
+
+noncomputable section
+open scoped BigOperators
+
+namespace BoundaryOnly.FormalObstruction.AlgebraicReplacement.TaylorTarget
+variable {A α : Type*} [CommRing A]
+
+theorem mk_surjective (q : ℕ) : Function.Surjective (mk A α q) :=
+  Ideal.Quotient.mk_surjective
+
+noncomputable def representative (q : ℕ) (x : Ring A α q) : MvPolynomial α A :=
+  (mk_surjective q x).choose
+
+@[simp] theorem mk_representative (q : ℕ) (x : Ring A α q) :
+    mk A α q (representative q x) = x :=
+  (mk_surjective q x).choose_spec
+
+def lower (q : ℕ) : Ring A α (q+1) →+* Ring A α q :=
+  Ideal.Quotient.factor (Ideal.pow_le_pow_right (Nat.le_succ q))
+
+@[simp] theorem lower_mk (q : ℕ) (p : MvPolynomial α A) :
+    lower q (mk A α (q+1) p) = mk A α q p := rfl
+
+noncomputable def shiftDeriv (i : α) (q : ℕ) (x : Ring A α (q+1)) : Ring A α q :=
+  mk A α q (MvPolynomial.pderiv i (representative (q+1) x))
+
+@[simp] theorem shiftDeriv_mk (i : α) (q : ℕ) (p : MvPolynomial α A) :
+    shiftDeriv i q (mk A α (q+1) p) = mk A α q (MvPolynomial.pderiv i p) := by
+  unfold shiftDeriv
+  apply Ideal.Quotient.eq.mpr
+  rw [← map_sub]
+  apply derivation_mem_pow (MvPolynomial.pderiv i) (variablesIdeal A α) q
+  apply Ideal.Quotient.eq.mp
+  exact mk_representative (q+1) (mk A α (q+1) p)
+
+@[simp] theorem shiftDeriv_add (i : α) (q : ℕ) (x y : Ring A α (q+1)) :
+    shiftDeriv i q (x+y) = shiftDeriv i q x + shiftDeriv i q y := by
+  obtain ⟨x,rfl⟩ := mk_surjective (q+1) x
+  obtain ⟨y,rfl⟩ := mk_surjective (q+1) y
+  change shiftDeriv i q (mk A α (q+1) (x+y)) = _
+  rw [shiftDeriv_mk,shiftDeriv_mk,shiftDeriv_mk]
+  simp only [map_add]
+
+@[simp] theorem shiftDeriv_one (i : α) (q : ℕ) :
+    shiftDeriv (A := A) i q 1 = 0 := by
+  simpa only [map_one,MvPolynomial.pderiv_one,map_zero] using
+    shiftDeriv_mk i q (1 : MvPolynomial α A)
+
+@[simp] theorem shiftDeriv_zero (i : α) (q : ℕ) :
+    shiftDeriv (A := A) i q 0 = 0 := by
+  simpa only [map_zero] using shiftDeriv_mk i q (0 : MvPolynomial α A)
+
+ theorem shiftDeriv_mul (i : α) (q : ℕ) (x y : Ring A α (q+1)) :
+    shiftDeriv i q (x*y) = lower q x * shiftDeriv i q y + lower q y * shiftDeriv i q x := by
+  obtain ⟨x,rfl⟩ := mk_surjective (q+1) x
+  obtain ⟨y,rfl⟩ := mk_surjective (q+1) y
+  change shiftDeriv i q (mk A α (q+1) (x*y)) = _
+  rw [shiftDeriv_mk,shiftDeriv_mk,shiftDeriv_mk,lower_mk,lower_mk]
+  simp only [Derivation.leibniz,smul_eq_mul,map_add,map_mul]
+
+ theorem shiftDeriv_C_mul (i : α) (q : ℕ) (a : A) (x : Ring A α (q+1)) :
+    shiftDeriv i q (mk A α (q+1) (MvPolynomial.C a) * x) =
+      mk A α q (MvPolynomial.C a) * shiftDeriv i q x := by
+  rw [shiftDeriv_mul,shiftDeriv_mk,MvPolynomial.pderiv_C,map_zero,mul_zero,add_zero,lower_mk]
+
+noncomputable def coefficient (q : ℕ) (e : α →₀ ℕ) (x : Ring A α q) : A :=
+  (representative q x).coeff e
+
+@[simp] theorem coefficient_mk (q : ℕ) (e : α →₀ ℕ) (he : e.degree < q)
+    (p : MvPolynomial α A) :
+    coefficient q e (mk A α q p) = p.coeff e := by
+  have hh : representative q (mk A α q p) - p ∈ variablesIdeal A α ^ q :=
+    Ideal.Quotient.eq.mp (mk_representative q (mk A α q p))
+  have hc : (representative q (mk A α q p) - p).coeff e = 0 := by
+    by_contra hn
+    exact (not_le_of_gt he) ((MvPolynomial.mem_pow_idealOfVars_iff _ _).mp hh e
+      (MvPolynomial.mem_support_iff.mpr hn))
+  simpa only [MvPolynomial.coeff_sub,sub_eq_zero,coefficient] using hc
+
+ theorem coefficient_shiftDeriv (i : α) (q : ℕ) (e : α →₀ ℕ) (he : e.degree < q)
+    (x : Ring A α (q+1)) :
+    coefficient q e (shiftDeriv i q x) =
+      coefficient (q+1) (e + Finsupp.single i 1) x * (e i + 1) := by
+  obtain ⟨p,rfl⟩ := mk_surjective (q+1) x
+  rw [shiftDeriv_mk,coefficient_mk q e he,MvPolynomial.coeff_pderiv,
+    coefficient_mk (q+1) (e + Finsupp.single i 1) (by
+      simpa only [map_add,Finsupp.degree_single] using Nat.add_lt_add_right he 1)]
+
+ theorem coefficient_ext (q : ℕ) {x y : Ring A α q}
+    (h : ∀ e, e.degree < q → coefficient q e x = coefficient q e y) : x = y := by
+  obtain ⟨p,rfl⟩ := mk_surjective q x
+  obtain ⟨r,rfl⟩ := mk_surjective q y
+  apply Ideal.Quotient.eq.mpr
+  rw [MvPolynomial.mem_pow_idealOfVars_iff]
+  intro e he
+  by_contra hn
+  have ht : e.degree < q := by omega
+  have hc := h e ht
+  rw [coefficient_mk q e ht,coefficient_mk q e ht] at hc
+  apply MvPolynomial.mem_support_iff.mp he
+  simpa only [MvPolynomial.coeff_sub,sub_eq_zero] using hc
+
+end BoundaryOnly.FormalObstruction.AlgebraicReplacement.TaylorTarget
+
+namespace BoundaryOnly.FormalObstruction.AlgebraicReplacement.TaylorTarget
+variable {A B α : Type*} [CommRing A] [CommRing B]
+
+lemma coefficient_map (f : A →+* B) (q : ℕ) (e : α →₀ ℕ) (he : e.degree < q)
+    (x : Ring A α q) : coefficient q e (map f q x) = f (coefficient q e x) := by
+  obtain ⟨p,rfl⟩ := mk_surjective q x
+  rw [map_mk,coefficient_mk q e he,coefficient_mk q e he,MvPolynomial.coeff_map]
+
+lemma coefficient_add (q : ℕ) (e : α →₀ ℕ) (he : e.degree < q)
+    (x y : Ring A α q) : coefficient q e (x+y) = coefficient q e x + coefficient q e y := by
+  obtain ⟨p,rfl⟩ := mk_surjective q x
+  obtain ⟨r,rfl⟩ := mk_surjective q y
+  rw [← map_add,coefficient_mk q e he,coefficient_mk q e he,coefficient_mk q e he,
+    AddMonoidAlgebra.coeff_add,Finsupp.add_apply]
+
+lemma coefficient_sub (q : ℕ) (e : α →₀ ℕ) (he : e.degree < q)
+    (x y : Ring A α q) : coefficient q e (x-y) = coefficient q e x - coefficient q e y := by
+  obtain ⟨p,rfl⟩ := mk_surjective q x
+  obtain ⟨r,rfl⟩ := mk_surjective q y
+  rw [← map_sub,coefficient_mk q e he,coefficient_mk q e he,coefficient_mk q e he,
+    MvPolynomial.coeff_sub]
+
+lemma coefficient_mem_map (J : Ideal A) (q : ℕ) (e : α →₀ ℕ) (he : e.degree < q)
+    (x : Ring A α q) (hx : x ∈ J.map (algebraMap A (Ring A α q))) :
+    coefficient q e x ∈ J := by
+  have hle : J.map (algebraMap A (Ring A α q)) ≤
+      RingHom.ker (map (Ideal.Quotient.mk J) q) := by
+    rw [Ideal.map_le_iff_le_comap]
+    intro a ha
+    change map (Ideal.Quotient.mk J) q
+      (mk A α q (MvPolynomial.C a)) = 0
+    rw [map_mk,MvPolynomial.map_C,Ideal.Quotient.eq_zero_iff_mem.mpr ha,
+      MvPolynomial.C_0,map_zero]
+  have hz := congrArg (coefficient q e) (hle hx)
+  rw [coefficient_map _ q e he] at hz
+  have h0 : coefficient q e (0 : Ring (A ⧸ J) α q) = 0 := by
+    simpa only [map_zero,AddMonoidAlgebra.coeff_zero,Finsupp.zero_apply] using
+      coefficient_mk q e he (0 : MvPolynomial α (A ⧸ J))
+  rw [h0] at hz
+  exact Ideal.Quotient.eq_zero_iff_mem.mp hz
+
+lemma coefficient_mem_pow (J : Ideal A) (q N : ℕ) (e : α →₀ ℕ) (he : e.degree < q)
+    (x : Ring A α q) (hx : x ∈ (J.map (algebraMap A (Ring A α q))) ^ N) :
+    coefficient q e x ∈ J ^ N := by
+  apply coefficient_mem_map (J^N) q e he x
+  simpa only [Ideal.map_pow] using hx
+
+end BoundaryOnly.FormalObstruction.AlgebraicReplacement.TaylorTarget
+
+namespace BoundaryOnly.FormalObstruction.AlgebraicReplacement
+namespace TaylorShift
+variable {K A α : Type*} [CommRing K] [CommRing A]
+  [Algebra K A] [Algebra (MvPolynomial α K) A]
+  [IsScalarTower K (MvPolynomial α K) A]
+
+omit [IsScalarTower K (MvPolynomial α K) A] in
+lemma lower_shift (I : Ideal A) (q : ℕ) (p : MvPolynomial α K) :
+    TaylorTarget.lower q (shift (K := K) (α := α) I (q+1) p) = shift (K := K) (α := α) I q p := by
+  have hh : (TaylorTarget.lower q).comp (shift (K := K) (α := α) I (q+1)) = shift (K := K) (α := α) I q := by
+    apply MvPolynomial.ringHom_ext
+    · intro k
+      simp [shift]
+    · intro i
+      simp [shift]
+  exact RingHom.congr_fun hh p
+
+lemma reduction_lower (I : Ideal A) (q : ℕ) (hq : 1 ≤ q)
+    (x : Target (α := α) I (q+1)) :
+    TaylorTarget.reduction (A ⧸ I) α q hq (TaylorTarget.lower q x) =
+      TaylorTarget.reduction (A ⧸ I) α (q+1) (by omega) x := by
+  obtain ⟨p,rfl⟩ := TaylorTarget.mk_surjective (q+1) x
+  simp
+
+lemma lower_taylor [Algebra.FormallyEtale (MvPolynomial α K) A]
+    (I : Ideal A) (q : ℕ) (hq : 1 ≤ q) (a : A) :
+    TaylorTarget.lower q (taylor (K := K) (α := α) I (q+1) (by omega) a) =
+      taylor (K := K) (α := α) I q hq a := by
+  have hh := taylor_unique (K := K) (α := α) I q hq
+    ((TaylorTarget.lower q).comp (taylor (K := K) (α := α) I (q+1) (by omega)))
+    (fun p ↦ by simp only [RingHom.comp_apply,taylor_coordinates,lower_shift])
+    (fun a ↦ by simp only [RingHom.comp_apply,reduction_lower,reduction_taylor])
+  exact RingHom.congr_fun hh a
+
+lemma taylor_scalar [Algebra.FormallySmooth (MvPolynomial α K) A]
+    (I : Ideal A) (q : ℕ) (hq : 1 ≤ q) (k : K) :
+    taylor (K := K) (α := α) I q hq (algebraMap K A k) =
+      algebraMap K (Target (α := α) I q) k := by
+  have hh := taylor_coordinates (K := K) (α := α) I q hq (MvPolynomial.C k)
+  have hc : algebraMap (MvPolynomial α K) A (MvPolynomial.C k) =
+      algebraMap K A k := IsScalarTower.algebraMap_apply K (MvPolynomial α K) A k |>.symm
+  rw [hc] at hh
+  change _ = TaylorTarget.mk (A ⧸ I) α q
+    (MvPolynomial.C (Ideal.Quotient.mk I (algebraMap K A k)))
+  simpa only [shift, MvPolynomial.eval₂Hom_C, RingHom.comp_apply] using hh
+
+noncomputable def taylorAlgHom [Algebra.FormallySmooth (MvPolynomial α K) A]
+    (I : Ideal A) (q : ℕ) (hq : 1 ≤ q) : A →ₐ[K] Target (α := α) I q :=
+  { taylor (K := K) (α := α) I q hq with commutes' := taylor_scalar (K := K) (α := α) I q hq }
+
+end TaylorShift
+namespace TaylorTarget
+variable {K A α : Type*} [CommRing K] [CommRing A] [Algebra K A]
+
+noncomputable def shiftDerivLinear (i : α) (q : ℕ) :
+    Ring A α (q+1) →ₗ[K] Ring A α q where
+  toFun := shiftDeriv i q
+  map_add' := shiftDeriv_add i q
+  map_smul' k x := by
+    simp only [RingHom.id_apply]
+    rw [Algebra.smul_def (A := Ring A α (q+1)) k x,
+      Algebra.smul_def (A := Ring A α q) k (shiftDeriv i q x)]
+    change shiftDeriv i q (mk A α (q+1) (MvPolynomial.C (algebraMap K A k)) * x) =
+      mk A α q (MvPolynomial.C (algebraMap K A k)) * shiftDeriv i q x
+    exact shiftDeriv_C_mul i q _ x
+
+end TaylorTarget
+end BoundaryOnly.FormalObstruction.AlgebraicReplacement
+
+namespace BoundaryOnly.FormalObstruction.AlgebraicReplacement
+variable {A : Type*} [CommRing A] [IsNoetherianRing A]
+
+theorem completion_approximate (J : Ideal A) (b : AdicCompletion J A) (N : ℕ) :
+    ∃ a : A, b - AdicCompletion.of J A a ∈
+      (J.map (algebraMap A (AdicCompletion J A))) ^ N := by
+  obtain ⟨a,ha⟩ := Submodule.Quotient.mk_surjective (J^N • (⊤ : Ideal A)) (b.val N)
+  refine ⟨a,?_⟩
+  rw [← Ideal.map_pow,← Submodule.restrictScalars_mem A,← Ideal.smul_top_eq_map,
+    AdicCompletion.pow_smul_top_eq_ker_eval J.fg_of_isNoetherianRing]
+  change AdicCompletion.eval J A N (b - AdicCompletion.of J A a) = 0
+  rw [map_sub, AdicCompletion.eval_of]
+  exact sub_eq_zero.mpr ha.symm
+
+namespace TaylorTarget
+variable {R α : Type*} [CommRing R]
+
+lemma shiftDeriv_mem_map (J : Ideal R) (i : α) (q : ℕ)
+    (x : Ring R α (q+1)) (hx : x ∈ J.map (algebraMap R (Ring R α (q+1)))) :
+    shiftDeriv i q x ∈ J.map (algebraMap R (Ring R α q)) := by
+  have hm : x ∈ J • (⊤ : Submodule R (Ring R α (q+1))) := by
+    rwa [Ideal.smul_top_eq_map,Submodule.restrictScalars_mem]
+  have ht := Submodule.mem_map_of_mem (f := shiftDerivLinear (K := R) i q) hm
+  rw [Submodule.map_smul''] at ht
+  have hle : J • (⊤ : Submodule R (Ring R α (q+1))).map (shiftDerivLinear (K := R) i q) ≤
+      J • (⊤ : Submodule R (Ring R α q)) := smul_le_smul_left J le_top
+  have hh := hle ht
+  rwa [Ideal.smul_top_eq_map,Submodule.restrictScalars_mem] at hh
+
+lemma shiftDeriv_mem_pow (J : Ideal R) (i : α) (q N : ℕ)
+    (x : Ring R α (q+1)) (hx : x ∈ (J.map (algebraMap R (Ring R α (q+1))))^N) :
+    shiftDeriv i q x ∈ (J.map (algebraMap R (Ring R α q)))^N := by
+  rw [← Ideal.map_pow] at hx ⊢
+  exact shiftDeriv_mem_map (J^N) i q x hx
+
+lemma shiftDeriv_sub (i : α) (q : ℕ) (x y : Ring R α (q+1)) :
+    shiftDeriv i q (x-y) = shiftDeriv i q x - shiftDeriv i q y :=
+  map_sub (shiftDerivLinear (K := R) i q) x y
+
+variable [Algebra A R]
+
+omit [IsNoetherianRing A] in
+lemma shiftDeriv_mem_coeff_pow (J : Ideal A) (i : α) (q N : ℕ)
+    (x : Ring R α (q+1)) (hx : x ∈ (J.map (algebraMap A (Ring R α (q+1))))^N) :
+    shiftDeriv i q x ∈ (J.map (algebraMap A (Ring R α q)))^N := by
+  have hbig : (algebraMap R (Ring R α (q+1))).comp (algebraMap A R) =
+      algebraMap A (Ring R α (q+1)) := (IsScalarTower.algebraMap_eq A R _).symm
+  have hsmall : (algebraMap R (Ring R α q)).comp (algebraMap A R) =
+      algebraMap A (Ring R α q) := (IsScalarTower.algebraMap_eq A R _).symm
+  rw [← hbig, ← Ideal.map_map] at hx
+  rw [← hsmall, ← Ideal.map_map]
+  exact shiftDeriv_mem_pow (J.map (algebraMap A R)) i q N x hx
+
+end TaylorTarget
+end BoundaryOnly.FormalObstruction.AlgebraicReplacement
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/AlgebraicObstruction/TaylorCompletion.lean b/lean/OAI/Algebra/AlgebraicObstruction/TaylorCompletion.lean
new file mode 100644
index 0000000000000000000000000000000000000000..c18ea587323e0984791d36ad87eefbb6dd18aa39
--- /dev/null
+++ b/lean/OAI/Algebra/AlgebraicObstruction/TaylorCompletion.lean
@@ -0,0 +1,349 @@
+import Mathlib
+import OAI.Algebra.FrobeniusObstruction.Obstruction
+import OAI.Algebra.AlgebraicObstruction.TaylorShift
+import OAI.Algebra.AlgebraicObstruction.ScalarCompletion
+
+namespace OAI
+
+noncomputable section
+open scoped BigOperators
+
+namespace BoundaryOnly.FormalObstruction.AlgebraicReplacement
+namespace TaylorShift
+universe u
+variable {K A α : Type u} [CommRing K] [CommRing A]
+  [Algebra K A] [Algebra (MvPolynomial α K) A]
+  [IsScalarTower K (MvPolynomial α K) A]
+  [Algebra.FormallySmooth (MvPolynomial α K) A]
+
+noncomputable def completionAlgEquiv (I J : Ideal A) (q : ℕ) (hq : 1 ≤ q) :
+    letI := (taylor (K := K) (α := α) I q hq).toAlgebra
+    letI : Module A (Target (α := α) I q) :=
+      (taylor (K := K) (α := α) I q hq).toAlgebra.toModule
+    AdicCompletion (J.map (taylor (K := K) (α := α) I q hq)) (Target (α := α) I q) ≃ₐ[A]
+      AdicCompletion (J.map (coefficient (α := α) I q)) (Target (α := α) I q) := by
+  letI := (taylor (K := K) (α := α) I q hq).toAlgebra
+  letI : Module A (Target (α := α) I q) :=
+    (taylor (K := K) (α := α) I q hq).toAlgebra.toModule
+  exact { completionEquiv (K := K) I J q hq with
+    commutes' := fun a ↦ completionEquiv_of I J q hq
+      (taylor (K := K) (α := α) I q hq a) }
+
+noncomputable def tensorCompletionEquiv [IsNoetherianRing A] [Finite α]
+    (I J : Ideal A) (q : ℕ) (hq : 1 ≤ q) :
+    letI := (taylor (K := K) (α := α) I q hq).toAlgebra
+    letI : Module A (Target (α := α) I q) :=
+      (taylor (K := K) (α := α) I q hq).toAlgebra.toModule
+    TensorProduct A (AdicCompletion J A) (Target (α := α) I q) ≃ₗ[A]
+      AdicCompletion (J.map (coefficient (α := α) I q)) (Target (α := α) I q) := by
+  letI := (taylor (K := K) (α := α) I q hq).toAlgebra
+  letI : Module A (Target (α := α) I q) :=
+    (taylor (K := K) (α := α) I q hq).toAlgebra.toModule
+  have : Module.Finite A (Target (α := α) I q) := taylor_finite (K := K) (α := α) I q hq
+  exact (CompletionScalar.tensorEquiv J).trans
+    (completionAlgEquiv (K := K) I J q hq).toLinearEquiv
+
+@[simp] theorem tensorCompletionEquiv_one_tmul [IsNoetherianRing A] [Finite α]
+    (I J : Ideal A) (q : ℕ) (hq : 1 ≤ q) (t : Target (α := α) I q) :
+    letI := (taylor (K := K) (α := α) I q hq).toAlgebra
+    letI : Module A (Target (α := α) I q) :=
+      (taylor (K := K) (α := α) I q hq).toAlgebra.toModule
+    tensorCompletionEquiv (K := K) I J q hq (1 ⊗ₜ[A] t) =
+      AdicCompletion.of (J.map (coefficient (α := α) I q)) _ t := by
+  let := (taylor (K := K) (α := α) I q hq).toAlgebra
+  let : Module A (Target (α := α) I q) :=
+    (taylor (K := K) (α := α) I q hq).toAlgebra.toModule
+  have : Module.Finite A (Target (α := α) I q) := taylor_finite (K := K) (α := α) I q hq
+  simp only [tensorCompletionEquiv, LinearEquiv.trans_apply,
+    CompletionScalar.tensorEquiv_one_tmul]
+  exact completionEquiv_of I J q hq t
+
+end TaylorShift
+end BoundaryOnly.FormalObstruction.AlgebraicReplacement
+
+namespace BoundaryOnly.FormalObstruction.AlgebraicReplacement.TaylorTarget
+open TensorProduct
+variable {R S C α : Type*} [CommRing R] [CommRing S] [CommRing C]
+  [Algebra R S] [Algebra R C]
+
+lemma polynomialTensor_X (i : α) :
+    (MvPolynomial.rTensorAlgEquiv (R := R) (S := S))
+      (1 ⊗ₜ[R] (MvPolynomial.X i : MvPolynomial α C)) = MvPolynomial.X i := by
+  classical
+  ext e
+  rw [MvPolynomial.coeff_rTensorAlgEquiv_tmul]
+  simp only [MvPolynomial.coeff_X]
+  split_ifs
+  · rfl
+  · exact TensorProduct.tmul_zero _ _
+
+lemma polynomialTensor_ideal (q : ℕ) :
+    ((variablesIdeal C α ^ q).map
+      (Algebra.TensorProduct.includeRight : MvPolynomial α C →ₐ[R]
+        S ⊗[R] MvPolynomial α C)).map
+      (MvPolynomial.rTensorAlgEquiv (R := R) (S := S)).toRingHom =
+      variablesIdeal (S ⊗[R] C) α ^ q := by
+  rw [Ideal.map_pow, Ideal.map_pow]
+  congr 1
+  change ((variablesIdeal C α).map
+    (Algebra.TensorProduct.includeRight : MvPolynomial α C →ₐ[R]
+      S ⊗[R] MvPolynomial α C).toRingHom).map _ = _
+  rw [Ideal.map_map]
+  change (Ideal.span (Set.range (MvPolynomial.X : α → MvPolynomial α C))).map _ = _
+  rw [Ideal.map_span, ← Set.range_comp]
+  have hh : (MvPolynomial.rTensorAlgEquiv (R := R) (S := S)).toRingHom.comp
+      (Algebra.TensorProduct.includeRight : MvPolynomial α C →ₐ[R]
+        S ⊗[R] MvPolynomial α C).toRingHom ∘ MvPolynomial.X =
+      (MvPolynomial.X : α → MvPolynomial α (S ⊗[R] C)) := by
+    funext i
+    exact polynomialTensor_X i
+  rw [hh]
+
+noncomputable def tensorTruncateEquiv (q : ℕ) :
+    S ⊗[R] Ring C α q ≃ₐ[S] Ring (S ⊗[R] C) α q :=
+  (Algebra.TensorProduct.tensorQuotientEquiv (R := R) S (MvPolynomial α C) S
+    (variablesIdeal C α ^ q)).trans
+    (Ideal.quotientEquivAlg _ _ (MvPolynomial.rTensorAlgEquiv (R := R) (S := S))
+      (polynomialTensor_ideal q).symm)
+
+variable {D : Type*} [CommRing D]
+
+lemma map_variables (f : C →+* D) :
+    (variablesIdeal C α).map (MvPolynomial.map f) = variablesIdeal D α := by
+  change (Ideal.span (Set.range (MvPolynomial.X : α → MvPolynomial α C))).map _ = _
+  rw [Ideal.map_span, ← Set.range_comp]
+  congr 1
+  ext i
+  simp
+
+noncomputable def mapEquiv (f : C ≃+* D) (q : ℕ) :
+    Ring C α q ≃+* Ring D α q :=
+  Ideal.quotientEquiv _ _ (MvPolynomial.mapEquiv α f)
+    (by rw [Ideal.map_pow]; exact congrArg (· ^ q) (map_variables f.toRingHom).symm)
+
+noncomputable def quotientTensorTruncateEquiv (I : Ideal R) (q : ℕ) :
+    S ⊗[R] Ring (R ⧸ I) α q ≃+*
+      Ring (S ⧸ I.map (algebraMap R S)) α q :=
+  (tensorTruncateEquiv (R := R) (C := R ⧸ I) (S := S) (α := α) q).toRingEquiv.trans
+    (mapEquiv (Algebra.TensorProduct.quotIdealMapEquivTensorQuot S I).symm.toRingEquiv q)
+
+end BoundaryOnly.FormalObstruction.AlgebraicReplacement.TaylorTarget
+
+namespace BoundaryOnly.FormalObstruction.AlgebraicReplacement.TaylorTarget
+variable {R C D α : Type*} [CommRing R] [CommRing C] [CommRing D]
+  [Algebra R C] [Algebra R D]
+
+noncomputable def mapAlgEquiv (f : C ≃ₐ[R] D) (q : ℕ) :
+    Ring C α q ≃ₐ[R] Ring D α q :=
+  Ideal.quotientEquivAlg _ _ (MvPolynomial.mapAlgEquiv α f)
+    (by rw [Ideal.map_pow]; exact congrArg (· ^ q) (map_variables f.toRingHom).symm)
+
+variable {S : Type*} [CommRing S] [Algebra R S]
+noncomputable def quotientTensorTruncateAlgEquiv (I : Ideal R) (q : ℕ) :
+    TensorProduct R S (Ring (R ⧸ I) α q) ≃ₐ[S]
+      Ring (S ⧸ I.map (algebraMap R S)) α q :=
+  (tensorTruncateEquiv (R := R) (C := R ⧸ I) (S := S) (α := α) q).trans
+    (mapAlgEquiv (Algebra.TensorProduct.quotIdealMapEquivTensorQuot S I).symm q)
+
+end BoundaryOnly.FormalObstruction.AlgebraicReplacement.TaylorTarget
+
+namespace BoundaryOnly.FormalObstruction.AlgebraicReplacement
+namespace TaylorShift
+open TensorProduct
+universe u
+variable {K A α : Type u} [CommRing K] [CommRing A]
+  [Algebra K A] [Algebra (MvPolynomial α K) A]
+  [IsScalarTower K (MvPolynomial α K) A]
+
+lemma coefficient_eq_algebraMap (I : Ideal A) (q : ℕ) :
+    coefficient (α := α) I q = algebraMap A (Target (α := α) I q) := rfl
+
+lemma coefficient_finite [Finite α] (I : Ideal A) (q : ℕ) (hq : 1 ≤ q) :
+    Module.Finite A (Target (α := α) I q) := by
+  apply TaylorTarget.finite_shifted (A ⧸ I) α A q hq
+  intro a
+  exact reduction_coefficient I q hq a
+
+noncomputable def coefficientCompletionEquiv [IsNoetherianRing A] [Finite α]
+    (I J : Ideal A) (q : ℕ) (hq : 1 ≤ q) :
+    AdicCompletion (J.map (coefficient (α := α) I q)) (Target (α := α) I q) ≃+
+      TaylorTarget.Ring ((AdicCompletion J A) ⧸ I.map (algebraMap A (AdicCompletion J A))) α q := by
+  have : Module.Finite A (Target (α := α) I q) := coefficient_finite I q hq
+  exact (CompletionScalar.tensorEquiv J).symm.toAddEquiv.trans
+    (TaylorTarget.quotientTensorTruncateAlgEquiv
+      (S := AdicCompletion J A) (α := α) I q).toRingEquiv.toAddEquiv
+
+variable [Algebra.FormallySmooth (MvPolynomial α K) A]
+
+noncomputable def shiftedTargetEquiv [IsNoetherianRing A] [Finite α]
+    (I J : Ideal A) (q : ℕ) (hq : 1 ≤ q) :
+    letI := (taylor (K := K) (α := α) I q hq).toAlgebra
+    letI : Module A (Target (α := α) I q) :=
+      (taylor (K := K) (α := α) I q hq).toAlgebra.toModule
+    TensorProduct A (AdicCompletion J A) (Target (α := α) I q) ≃+
+      TaylorTarget.Ring ((AdicCompletion J A) ⧸ I.map (algebraMap A (AdicCompletion J A))) α q := by
+  letI := (taylor (K := K) (α := α) I q hq).toAlgebra
+  letI : Module A (Target (α := α) I q) :=
+    (taylor (K := K) (α := α) I q hq).toAlgebra.toModule
+  have : Module.Finite A (Target (α := α) I q) := taylor_finite (K := K) (α := α) I q hq
+  exact (CompletionScalar.tensorEquiv J).toAddEquiv.trans
+    ((completionEquiv (K := K) I J q hq).toAddEquiv.trans
+      (coefficientCompletionEquiv I J q hq))
+
+end TaylorShift
+end BoundaryOnly.FormalObstruction.AlgebraicReplacement
+
+namespace BoundaryOnly.FormalObstruction.AlgebraicReplacement.TaylorTarget
+open TensorProduct
+variable {R S C D α : Type*} [CommRing R] [CommRing S] [CommRing C] [CommRing D]
+  [Algebra R S]
+
+noncomputable def map (f : C →+* D) (q : ℕ) : Ring C α q →+* Ring D α q :=
+  Ideal.quotientMap _ (MvPolynomial.map f) (by
+    rw [← Ideal.map_le_iff_le_comap, Ideal.map_pow, map_variables])
+
+@[simp] lemma map_mk (f : C →+* D) (q : ℕ) (p : MvPolynomial α C) :
+    map f q (mk C α q p) = mk D α q (MvPolynomial.map f p) := rfl
+
+noncomputable def quotientCoefficient (I : Ideal R) :
+    R ⧸ I →+* S ⧸ I.map (algebraMap R S) :=
+  Ideal.quotientMap _ (algebraMap R S) Ideal.le_comap_map
+
+lemma tensorQuotient_coefficient (I : Ideal R) (a : R ⧸ I) :
+    (Algebra.TensorProduct.quotIdealMapEquivTensorQuot S I).symm (1 ⊗ₜ[R] a) =
+      quotientCoefficient (S := S) I a := by
+  obtain ⟨a,rfl⟩ := Ideal.Quotient.mk_surjective a
+  rw [Algebra.TensorProduct.quotIdealMapEquivTensorQuot_symm_tmul]
+  change Ideal.Quotient.mk _ (a • (1 : S)) = Ideal.Quotient.mk _ (algebraMap R S a)
+  rw [Algebra.smul_def, mul_one]
+
+@[simp] lemma quotientTensorTruncateAlgEquiv_one_tmul (I : Ideal R) (q : ℕ)
+    (t : Ring (R ⧸ I) α q) :
+    quotientTensorTruncateAlgEquiv (S := S) I q (1 ⊗ₜ[R] t) =
+      map (quotientCoefficient (S := S) I) q t := by
+  obtain ⟨p,rfl⟩ := Ideal.Quotient.mk_surjective t
+  change Ideal.Quotient.mk _
+    (MvPolynomial.map (Algebra.TensorProduct.quotIdealMapEquivTensorQuot S I).symm.toRingHom
+      (MvPolynomial.rTensorAlgEquiv (1 ⊗ₜ[R] p))) =
+    Ideal.Quotient.mk _ (MvPolynomial.map (quotientCoefficient (S := S) I) p)
+  congr 1
+  ext e
+  simp only [MvPolynomial.coeff_map, MvPolynomial.coeff_rTensorAlgEquiv_tmul]
+  exact tensorQuotient_coefficient I _
+
+end BoundaryOnly.FormalObstruction.AlgebraicReplacement.TaylorTarget
+
+namespace BoundaryOnly.FormalObstruction.AlgebraicReplacement.TaylorShift
+open TensorProduct
+universe u
+variable {K A α : Type u} [CommRing K] [CommRing A]
+  [Algebra K A] [Algebra (MvPolynomial α K) A]
+  [IsScalarTower K (MvPolynomial α K) A]
+
+@[simp] lemma coefficientCompletionEquiv_of [IsNoetherianRing A] [Finite α]
+    (I J : Ideal A) (q : ℕ) (hq : 1 ≤ q) (t : Target (α := α) I q) :
+    coefficientCompletionEquiv I J q hq
+      (AdicCompletion.of (J.map (coefficient (α := α) I q)) _ t) =
+      TaylorTarget.map (TaylorTarget.quotientCoefficient (S := AdicCompletion J A) I) q t := by
+  have : Module.Finite A (Target (α := α) I q) := coefficient_finite I q hq
+  have ht : (CompletionScalar.tensorEquiv J).symm
+      (AdicCompletion.of (J.map (coefficient (α := α) I q)) _ t) = 1 ⊗ₜ[A] t := by
+    change (CompletionScalar.tensorEquiv J).symm
+      (AdicCompletion.of (J.map (algebraMap A (Target (α := α) I q))) _ t) = _
+    apply (CompletionScalar.tensorEquiv J).injective
+    rw [LinearEquiv.apply_symm_apply, CompletionScalar.tensorEquiv_one_tmul]
+  change TaylorTarget.quotientTensorTruncateAlgEquiv (S := AdicCompletion J A) I q
+    ((CompletionScalar.tensorEquiv J).symm _) = _
+  rw [ht,TaylorTarget.quotientTensorTruncateAlgEquiv_one_tmul]
+
+variable [Algebra.FormallySmooth (MvPolynomial α K) A]
+
+@[simp] lemma shiftedTargetEquiv_one_tmul [IsNoetherianRing A] [Finite α]
+    (I J : Ideal A) (q : ℕ) (hq : 1 ≤ q) (t : Target (α := α) I q) :
+    letI := (taylor (K := K) (α := α) I q hq).toAlgebra
+    letI : Module A (Target (α := α) I q) :=
+      (taylor (K := K) (α := α) I q hq).toAlgebra.toModule
+    shiftedTargetEquiv (K := K) I J q hq (1 ⊗ₜ[A] t) =
+      TaylorTarget.map (TaylorTarget.quotientCoefficient (S := AdicCompletion J A) I) q t := by
+  let := (taylor (K := K) (α := α) I q hq).toAlgebra
+  let : Module A (Target (α := α) I q) :=
+    (taylor (K := K) (α := α) I q hq).toAlgebra.toModule
+  have : Module.Finite A (Target (α := α) I q) := taylor_finite (K := K) (α := α) I q hq
+  have ht := tensorCompletionEquiv_one_tmul (K := K) I J q hq t
+  exact (congrArg (coefficientCompletionEquiv I J q hq) ht).trans
+    (coefficientCompletionEquiv_of I J q hq t)
+
+end BoundaryOnly.FormalObstruction.AlgebraicReplacement.TaylorShift
+
+namespace BoundaryOnly.FormalObstruction.AlgebraicReplacement.CompletionScalar
+open TensorProduct
+universe u
+variable {R S : Type u} [CommRing R] [CommRing S] [Algebra R S]
+
+lemma equiv_smul_of (I : Ideal R) (r : AdicCompletion I R) (s : S) :
+    equiv I (r • AdicCompletion.of I S s) =
+      AdicFunctor.map I (I.map (algebraMap R S)) (algebraMap R S)
+        Ideal.le_comap_map r * AdicCompletion.of (I.map (algebraMap R S)) S s := by
+  apply AdicCompletion.ext_evalₐ
+  intro n
+  rw [map_mul, AdicFunctor.eval_map, AdicCompletion.evalₐ_of]
+  induction r using AdicCompletion.induction_on I R with
+  | _ r =>
+    have hv : (equiv I (AdicCompletion.mk I R r • AdicCompletion.of I S s)).val n =
+        Submodule.Quotient.mk (p := ((I.map (algebraMap R S)) ^ n • ⊤ : Ideal S))
+          (algebraMap R S (r.val n) * s) := by
+      change quotientEquiv I n ((AdicCompletion.mk I R r •
+        AdicCompletion.of I S s).val n) = _
+      rw [AdicCompletion.smul_eval]
+      change quotientEquiv I n (r.val n • Submodule.Quotient.mk s) = _
+      rw [map_smul, quotientEquiv_mk, ← Submodule.Quotient.mk_smul]
+      simp only [Algebra.smul_def]
+    rw [← AdicCompletion.factor_eval_eq_evalₐ (I.map (algebraMap R S)) _
+      (by rw [smul_eq_mul, Ideal.mul_top])]
+    change Ideal.Quotient.factor
+      (show (I.map (algebraMap R S)) ^ n • ⊤ ≤ (I.map (algebraMap R S)) ^ n from
+        by rw [smul_eq_mul, Ideal.mul_top]) ((equiv I
+      (AdicCompletion.mk I R r • AdicCompletion.of I S s)).val n) = _
+    rw [hv, AdicCompletion.evalₐ_mk]
+    simp only [AdicFunctor.quotient, Ideal.quotientMap_mk, Ideal.Quotient.mk_eq_mk]
+    rfl
+
+lemma tensorEquiv_tmul [IsNoetherianRing R] [Module.Finite R S]
+    (I : Ideal R) (r : AdicCompletion I R) (s : S) :
+    tensorEquiv I (r ⊗ₜ[R] s) =
+      AdicFunctor.map I (I.map (algebraMap R S)) (algebraMap R S)
+        Ideal.le_comap_map r * AdicCompletion.of (I.map (algebraMap R S)) S s := by
+  change equiv I (AdicCompletion.ofTensorProduct I S (r ⊗ₜ[R] s)) = _
+  rw [AdicCompletion.ofTensorProduct_tmul, equiv_smul_of]
+
+end BoundaryOnly.FormalObstruction.AlgebraicReplacement.CompletionScalar
+
+namespace BoundaryOnly.FormalObstruction.AlgebraicReplacement
+namespace TaylorShift
+variable {K A α : Type*} [CommRing K] [CommRing A]
+  [Algebra K A] [Algebra (MvPolynomial α K) A]
+  [IsScalarTower K (MvPolynomial α K) A]
+  [Algebra.FormallySmooth (MvPolynomial α K) A]
+
+noncomputable def completedTaylor (I J : Ideal A) (q : ℕ) (hq : 1 ≤ q) :
+    AdicCompletion J A →+*
+      AdicCompletion (J.map (coefficient (α := α) I q)) (Target (α := α) I q) :=
+  (completionEquiv (K := K) I J q hq).toRingHom.comp
+    (AdicFunctor.map J (J.map (taylor (K := K) (α := α) I q hq))
+      (taylor (K := K) (α := α) I q hq) Ideal.le_comap_map)
+
+@[simp] theorem completedTaylor_of (I J : Ideal A) (q : ℕ) (hq : 1 ≤ q)
+    (a : A) :
+    completedTaylor (K := K) I J q hq (AdicCompletion.of J A a) =
+      AdicCompletion.of (J.map (coefficient (α := α) I q)) _
+        (taylor (K := K) (α := α) I q hq a) := by
+  change completionEquiv (K := K) I J q hq
+    (AdicFunctor.map _ _ _ _ _) = _
+  rw [AdicFunctor.map_of,completionEquiv_of]
+
+end TaylorShift
+end BoundaryOnly.FormalObstruction.AlgebraicReplacement
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/AlgebraicObstruction/TaylorDescent.lean b/lean/OAI/Algebra/AlgebraicObstruction/TaylorDescent.lean
new file mode 100644
index 0000000000000000000000000000000000000000..3617495febaa38484c09ef7fb7b213fa3d0817f9
--- /dev/null
+++ b/lean/OAI/Algebra/AlgebraicObstruction/TaylorDescent.lean
@@ -0,0 +1,232 @@
+import Mathlib
+import OAI.Algebra.FrobeniusObstruction.Obstruction
+import OAI.Algebra.AlgebraicObstruction.TaylorCompletion
+import OAI.Algebra.AlgebraicObstruction.FlatDescent
+import OAI.Algebra.AlgebraicObstruction.AlgebraicGerms
+
+namespace OAI
+
+noncomputable section
+open scoped BigOperators
+
+namespace BoundaryOnly.FormalObstruction.AlgebraicReplacement.TaylorShift
+open TensorProduct
+universe u
+variable {K A α : Type u} [CommRing K] [CommRing A]
+  [Algebra K A] [Algebra (MvPolynomial α K) A]
+  [IsScalarTower K (MvPolynomial α K) A]
+  [Algebra.FormallySmooth (MvPolynomial α K) A]
+  [IsNoetherianRing A] [Finite α]
+
+@[simp] theorem tensorCompletionEquiv_tmul_one
+    (I J : Ideal A) (q : ℕ) (hq : 1 ≤ q) (b : AdicCompletion J A) :
+    letI := (taylor (K := K) (α := α) I q hq).toAlgebra
+    letI : Module A (Target (α := α) I q) :=
+      (taylor (K := K) (α := α) I q hq).toAlgebra.toModule
+    tensorCompletionEquiv (K := K) (α := α) I J q hq (b ⊗ₜ[A] 1) =
+      completedTaylor (K := K) (α := α) I J q hq b := by
+  let := (taylor (K := K) (α := α) I q hq).toAlgebra
+  let : Module A (Target (α := α) I q) :=
+    (taylor (K := K) (α := α) I q hq).toAlgebra.toModule
+  have : Module.Finite A (Target (α := α) I q) := taylor_finite (K := K) (α := α) I q hq
+  have ht := CompletionScalar.tensorEquiv_tmul J b (1 : Target (α := α) I q)
+  change CompletionScalar.tensorEquiv J (b ⊗ₜ[A] (1 : Target (α := α) I q)) =
+    AdicFunctor.map J (J.map (taylor (K := K) (α := α) I q hq))
+      (taylor (K := K) (α := α) I q hq) Ideal.le_comap_map b * 1 at ht
+  rw [mul_one] at ht
+  exact congrArg (completionEquiv (K := K) (α := α) I J q hq) ht
+
+@[simp] theorem shiftedTargetEquiv_tmul_one
+    (I J : Ideal A) (q : ℕ) (hq : 1 ≤ q) (b : AdicCompletion J A) :
+    letI := (taylor (K := K) (α := α) I q hq).toAlgebra
+    letI : Module A (Target (α := α) I q) :=
+      (taylor (K := K) (α := α) I q hq).toAlgebra.toModule
+    shiftedTargetEquiv (K := K) (α := α) I J q hq (b ⊗ₜ[A] 1) =
+      coefficientCompletionEquiv (α := α) I J q hq (completedTaylor (K := K) (α := α) I J q hq b) := by
+  let := (taylor (K := K) (α := α) I q hq).toAlgebra
+  let : Module A (Target (α := α) I q) :=
+    (taylor (K := K) (α := α) I q hq).toAlgebra.toModule
+  have : Module.Finite A (Target (α := α) I q) := taylor_finite (K := K) (α := α) I q hq
+  exact congrArg (coefficientCompletionEquiv (α := α) I J q hq)
+    (tensorCompletionEquiv_tmul_one (K := K) (α := α) I J q hq b)
+
+theorem actual_whole_tuple_descends (I J : Ideal A) (q : ℕ) (hq : 1 ≤ q)
+    [Module.FaithfullyFlat A (AdicCompletion J A)]
+    (b : AdicCompletion J A) (x : Target (α := α) I q)
+    (hx : coefficientCompletionEquiv (α := α) I J q hq
+        (completedTaylor (K := K) (α := α) I J q hq b) =
+      TaylorTarget.map (TaylorTarget.quotientCoefficient (S := AdicCompletion J A) I) q x) :
+    ∃ a : A, taylor (K := K) (α := α) I q hq a = x := by
+  let := (taylor (K := K) (α := α) I q hq).toAlgebra
+  let : Module A (Target (α := α) I q) :=
+    (taylor (K := K) (α := α) I q hq).toAlgebra.toModule
+  have htx : b ⊗ₜ[A] (1 : Target (α := α) I q) = 1 ⊗ₜ[A] x := by
+    apply (shiftedTargetEquiv (K := K) (α := α) I J q hq).injective
+    rw [shiftedTargetEquiv_tmul_one, shiftedTargetEquiv_one_tmul]
+    exact hx
+  let f := Algebra.linearMap A (Target (α := α) I q)
+  apply whole_tuple_descends (B := AdicCompletion J A) f x
+  rw [← htx]
+  refine ⟨b ⊗ₜ[A] (⟨1, ?_⟩ : LinearMap.range f), ?_⟩
+  · exact ⟨1, map_one (taylor (K := K) (α := α) I q hq)⟩
+  · rfl
+
+end BoundaryOnly.FormalObstruction.AlgebraicReplacement.TaylorShift
+
+namespace BoundaryOnly.FormalObstruction.AlgebraicReplacement.TaylorShift
+open TensorProduct
+universe u
+variable {K A α : Type u} [CommRing K] [CommRing A]
+  [Algebra K A] [Algebra (MvPolynomial α K) A]
+  [IsScalarTower K (MvPolynomial α K) A]
+  [Algebra.FormallySmooth (MvPolynomial α K) A]
+  [IsNoetherianRing A] [Finite α]
+
+theorem completedTaylor_eq_zero_iff (I J : Ideal A) (q : ℕ) (hq : 1 ≤ q)
+    [Module.FaithfullyFlat A (AdicCompletion J A)] (b : AdicCompletion J A) :
+    completedTaylor (K := K) (α := α) I J q hq b = 0 ↔
+      b ∈ (RingHom.ker (taylor (K := K) (α := α) I q hq)).map
+        (algebraMap A (AdicCompletion J A)) := by
+  let := (taylor (K := K) (α := α) I q hq).toAlgebra
+  let : Module A (Target (α := α) I q) :=
+    (taylor (K := K) (α := α) I q hq).toAlgebra.toModule
+  let f := Algebra.linearMap A (Target (α := α) I q)
+  have hker : LinearMap.ker f = RingHom.ker (taylor (K := K) (α := α) I q hq) := rfl
+  rw [← tmul_one_mem_ideal_baseChange_iff, ← hker, kernel_baseChange]
+  change _ ↔ f.baseChange (AdicCompletion J A) (b ⊗ₜ[A] (1 : A)) = 0
+  have hf : f (1 : A) = (1 : Target (α := α) I q) :=
+    map_one (taylor (K := K) (α := α) I q hq)
+  rw [LinearMap.baseChange_tmul, hf]
+  rw [← tensorCompletionEquiv_tmul_one (K := K) (α := α) I J q hq]
+  exact (tensorCompletionEquiv (K := K) (α := α) I J q hq).map_eq_zero_iff
+
+theorem actual_primitive_tuple (I J : Ideal A) (q : ℕ) (hq : 1 ≤ q)
+    [Module.FaithfullyFlat A (AdicCompletion J A)]
+    (b : AdicCompletion J A) (x : Target (α := α) I q)
+    (hx : coefficientCompletionEquiv (α := α) I J q hq
+        (completedTaylor (K := K) (α := α) I J q hq b) =
+      TaylorTarget.map (TaylorTarget.quotientCoefficient (S := AdicCompletion J A) I) q x) :
+    ∃ a : A, taylor (K := K) (α := α) I q hq a = x ∧
+      b - AdicCompletion.of J A a ∈
+        (RingHom.ker (taylor (K := K) (α := α) I q hq)).map
+          (algebraMap A (AdicCompletion J A)) := by
+  obtain ⟨a,ha⟩ := actual_whole_tuple_descends (K := K) (α := α) I J q hq b x hx
+  refine ⟨a,ha, (completedTaylor_eq_zero_iff (K := K) (α := α) I J q hq _).mp ?_⟩
+  rw [map_sub, sub_eq_zero, completedTaylor_of, ha]
+  apply (coefficientCompletionEquiv (α := α) I J q hq).injective
+  rw [coefficientCompletionEquiv_of]
+  exact hx
+
+end BoundaryOnly.FormalObstruction.AlgebraicReplacement.TaylorShift
+
+namespace BoundaryOnly.FormalObstruction.FormalCorrection.AffineEtaleChart
+open MvPowerSeries
+variable {K α : Type} [Field K] [Finite α]
+
+theorem completionFaithfullyFlat (E : AffineEtaleChart K α) :
+    Module.FaithfullyFlat E.LocalRing
+      (AdicCompletion (IsLocalRing.maximalIdeal E.LocalRing) E.LocalRing) := by
+  have := E.localFaithfullyFlat
+  exact Module.FaithfullyFlat.of_linearEquiv _ _ E.completionAlgEquiv.toLinearEquiv
+
+theorem taylor_primitive_tuple (E : AffineEtaleChart K α) (I : Ideal E.LocalRing)
+    (q : ℕ) (hq : 1 ≤ q)
+    (b : AdicCompletion (IsLocalRing.maximalIdeal E.LocalRing) E.LocalRing)
+    (x : BoundaryOnly.FormalObstruction.AlgebraicReplacement.TaylorShift.Target (α := α) I q)
+    (hx : BoundaryOnly.FormalObstruction.AlgebraicReplacement.TaylorShift.coefficientCompletionEquiv
+        (α := α) I (IsLocalRing.maximalIdeal E.LocalRing) q hq
+        (BoundaryOnly.FormalObstruction.AlgebraicReplacement.TaylorShift.completedTaylor
+          (K := K) (α := α) I (IsLocalRing.maximalIdeal E.LocalRing) q hq b) =
+      BoundaryOnly.FormalObstruction.AlgebraicReplacement.TaylorTarget.map
+        (BoundaryOnly.FormalObstruction.AlgebraicReplacement.TaylorTarget.quotientCoefficient
+          (S := AdicCompletion (IsLocalRing.maximalIdeal E.LocalRing) E.LocalRing) I) q x) :
+    ∃ a : E.LocalRing,
+      BoundaryOnly.FormalObstruction.AlgebraicReplacement.TaylorShift.taylor (K := K) (α := α) I q hq a = x ∧
+      b - AdicCompletion.of _ _ a ∈
+        (RingHom.ker (BoundaryOnly.FormalObstruction.AlgebraicReplacement.TaylorShift.taylor
+          (K := K) (α := α) I q hq)).map
+          (algebraMap E.LocalRing
+            (AdicCompletion (IsLocalRing.maximalIdeal E.LocalRing) E.LocalRing)) := by
+  have := E.completionFaithfullyFlat
+  exact BoundaryOnly.FormalObstruction.AlgebraicReplacement.TaylorShift.actual_primitive_tuple
+    I (IsLocalRing.maximalIdeal E.LocalRing) q hq b x hx
+
+end BoundaryOnly.FormalObstruction.FormalCorrection.AffineEtaleChart
+
+namespace BoundaryOnly.FormalObstruction.AlgebraicReplacement.CompletionScalar
+open TensorProduct
+universe u
+variable {R S : Type u} [CommRing R] [CommRing S] [Algebra R S]
+  [IsNoetherianRing R] [Module.Finite R S]
+
+lemma tensorEquiv_one (I : Ideal R) :
+    tensorEquiv I (1 : TensorProduct R (AdicCompletion I R) S) = 1 := by
+  change tensorEquiv I (1 ⊗ₜ[R] (1 : S)) = 1
+  rw [tensorEquiv_one_tmul]
+  exact map_one (algebraMap S (AdicCompletion (I.map (algebraMap R S)) S))
+
+lemma tensorEquiv_mul (I : Ideal R)
+    (x y : TensorProduct R (AdicCompletion I R) S) :
+    tensorEquiv I (x*y) = tensorEquiv I x * tensorEquiv I y := by
+  induction x using TensorProduct.inductionOn with
+  | add x z hx hz => simp only [add_mul,map_add,hx,hz]
+  | tmul r s =>
+    induction y using TensorProduct.inductionOn with
+    | add y z hy hz => simp only [mul_add,map_add,hy,hz]
+    | tmul t u =>
+        rw [Algebra.TensorProduct.tmul_mul_tmul]
+        simp only [tensorEquiv_tmul,map_mul]
+        have hm : AdicCompletion.of (I.map (algebraMap R S)) S (s*u) =
+            AdicCompletion.of (I.map (algebraMap R S)) S s *
+              AdicCompletion.of (I.map (algebraMap R S)) S u :=
+          map_mul (algebraMap S (AdicCompletion (I.map (algebraMap R S)) S)) s u
+        rw [hm]
+        ring
+
+noncomputable def tensorRingEquiv (I : Ideal R) :
+    TensorProduct R (AdicCompletion I R) S ≃+*
+      AdicCompletion (I.map (algebraMap R S)) S :=
+  { (tensorEquiv I).toAddEquiv with
+    map_mul' := tensorEquiv_mul I }
+
+end BoundaryOnly.FormalObstruction.AlgebraicReplacement.CompletionScalar
+
+namespace BoundaryOnly.FormalObstruction.AlgebraicReplacement.TaylorShift
+universe u
+variable {K A α : Type u} [CommRing K] [CommRing A]
+  [Algebra K A] [Algebra (MvPolynomial α K) A]
+  [IsScalarTower K (MvPolynomial α K) A]
+  [IsNoetherianRing A] [Finite α]
+
+noncomputable def coefficientCompletionRingEquiv (I J : Ideal A) (q : ℕ) (hq : 1 ≤ q) :
+    AdicCompletion (J.map (coefficient (α := α) I q)) (Target (α := α) I q) ≃+*
+      TaylorTarget.Ring ((AdicCompletion J A) ⧸ I.map (algebraMap A (AdicCompletion J A))) α q := by
+  haveI : Module.Finite A (Target (α := α) I q) := coefficient_finite I q hq
+  exact (CompletionScalar.tensorRingEquiv J).symm.trans
+    (TaylorTarget.quotientTensorTruncateAlgEquiv
+      (S := AdicCompletion J A) (α := α) I q).toRingEquiv
+
+lemma coefficientCompletionRingEquiv_apply (I J : Ideal A) (q : ℕ) (hq : 1 ≤ q)
+    (t : AdicCompletion (J.map (coefficient (α := α) I q)) (Target (α := α) I q)) :
+    coefficientCompletionRingEquiv I J q hq t = coefficientCompletionEquiv I J q hq t := rfl
+
+variable [Algebra.FormallySmooth (MvPolynomial α K) A]
+
+noncomputable def fullTaylor (I J : Ideal A) (q : ℕ) (hq : 1 ≤ q) :
+    AdicCompletion J A →+*
+      TaylorTarget.Ring ((AdicCompletion J A) ⧸ I.map (algebraMap A (AdicCompletion J A))) α q :=
+  (coefficientCompletionRingEquiv I J q hq).toRingHom.comp
+    (completedTaylor (K := K) (α := α) I J q hq)
+
+@[simp] theorem fullTaylor_of (I J : Ideal A) (q : ℕ) (hq : 1 ≤ q) (a : A) :
+    fullTaylor (K := K) (α := α) I J q hq (AdicCompletion.of J A a) =
+      TaylorTarget.map (TaylorTarget.quotientCoefficient (S := AdicCompletion J A) I) q
+        (taylor (K := K) (α := α) I q hq a) := by
+  change coefficientCompletionRingEquiv I J q hq (completedTaylor (K := K) I J q hq _) = _
+  rw [coefficientCompletionRingEquiv_apply,completedTaylor_of,coefficientCompletionEquiv_of]
+
+end BoundaryOnly.FormalObstruction.AlgebraicReplacement.TaylorShift
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/AlgebraicObstruction/TaylorDifferential.lean b/lean/OAI/Algebra/AlgebraicObstruction/TaylorDifferential.lean
new file mode 100644
index 0000000000000000000000000000000000000000..b3b1f78c3708f57dec1d874072593a7253dae15c
--- /dev/null
+++ b/lean/OAI/Algebra/AlgebraicObstruction/TaylorDifferential.lean
@@ -0,0 +1,241 @@
+import Mathlib
+import OAI.Algebra.FrobeniusObstruction.Obstruction
+import OAI.Algebra.AlgebraicObstruction.AlgebraicGerms
+import OAI.Algebra.AlgebraicObstruction.TaylorCoefficients
+
+namespace OAI
+
+noncomputable section
+open scoped BigOperators
+
+namespace BoundaryOnly.FormalObstruction.AlgebraicReplacement.TaylorShift
+variable {K A α : Type*} [CommRing K] [CommRing A]
+  [Algebra K A] [Algebra (MvPolynomial α K) A]
+  [IsScalarTower K (MvPolynomial α K) A]
+  [Algebra.FormallyEtale (MvPolynomial α K) A]
+
+theorem shiftDeriv_taylor (I : Ideal A) (i : α) (q : ℕ) (hq : 1 ≤ q) (a : A) :
+    TaylorTarget.shiftDeriv i q (taylor (K := K) (α := α) I (q+1) (by omega) a) =
+      taylor (K := K) (α := α) I q hq
+        (extendDerivation (T := A) (MvPolynomial.pderiv (R := K) i) a) := by
+  classical
+  let T := Target (α := α) I q
+  let : Algebra A T := (taylor (K := K) (α := α) I q hq).toAlgebra
+  let : SMul A T := (inferInstance : Algebra A T).toSMul
+  let : Module A T := (inferInstance : Algebra A T).toModule
+  let : SMul K T := (inferInstance : Algebra K T).toSMul
+  let : Module K T := (inferInstance : Algebra K T).toModule
+  let : IsScalarTower K A T := IsScalarTower.of_algebraMap_eq' (by
+    ext k
+    exact (taylor_scalar (K := K) (α := α) I q hq k).symm)
+  let : Algebra (MvPolynomial α K) T := (shift (K := K) (α := α) I q).toAlgebra
+  let : SMul (MvPolynomial α K) T := (inferInstance : Algebra (MvPolynomial α K) T).toSMul
+  let : Module (MvPolynomial α K) T := (inferInstance : Algebra (MvPolynomial α K) T).toModule
+  let : IsScalarTower (MvPolynomial α K) A T := IsScalarTower.of_algebraMap_eq' (by
+    apply RingHom.ext
+    intro p
+    exact (taylor_coordinates (K := K) (α := α) I q hq p).symm)
+  let : IsScalarTower K (MvPolynomial α K) T := IsScalarTower.of_algebraMap_eq' (by
+    apply RingHom.ext
+    intro k
+    change TaylorTarget.mk (A ⧸ I) α q
+      (MvPolynomial.C (Ideal.Quotient.mk I (algebraMap K A k))) =
+        shift (K := K) (α := α) I q (MvPolynomial.C k)
+    simp [shift])
+  let d : Derivation K A T :=
+    { toLinearMap := (TaylorTarget.shiftDerivLinear (K := K) i q).comp
+        (taylorAlgHom (K := K) (α := α) I (q+1) (by omega)).toLinearMap
+      map_one_eq_zero' := by
+        change TaylorTarget.shiftDeriv i q (taylor (K := K) (α := α) I (q+1) (by omega) 1) = 0
+        rw [map_one,TaylorTarget.shiftDeriv_one]
+      leibniz' := by
+        intro x y
+        change TaylorTarget.shiftDeriv i q (taylor (K := K) (α := α) I (q+1) (by omega) (x*y)) =
+          taylor (K := K) (α := α) I q hq x *
+            TaylorTarget.shiftDeriv i q (taylor (K := K) (α := α) I (q+1) (by omega) y) +
+          taylor (K := K) (α := α) I q hq y *
+            TaylorTarget.shiftDeriv i q (taylor (K := K) (α := α) I (q+1) (by omega) x)
+        rw [map_mul,TaylorTarget.shiftDeriv_mul,lower_taylor I q hq,lower_taylor I q hq] }
+  let e : Derivation K A T := (Algebra.linearMap A T).compDer
+    (extendDerivation (T := A) (MvPolynomial.pderiv (R := K) i))
+  have he : d.compAlgebraMap (MvPolynomial α K) = e.compAlgebraMap (MvPolynomial α K) := by
+    apply MvPolynomial.derivation_ext
+    intro j
+    change TaylorTarget.shiftDeriv i q
+      (taylor (K := K) (α := α) I (q+1) (by omega)
+        (algebraMap (MvPolynomial α K) A (MvPolynomial.X j))) =
+      taylor (K := K) (α := α) I q hq
+        (extendDerivation (T := A) (MvPolynomial.pderiv (R := K) i)
+          (algebraMap (MvPolynomial α K) A (MvPolynomial.X j)))
+    rw [taylor_coordinates,extendDerivation_algebraMap,taylor_coordinates]
+    simp only [shift,MvPolynomial.eval₂Hom_X']
+    rw [TaylorTarget.shiftDeriv_mk]
+    by_cases hij : j = i
+    · subst j
+      simp
+    · simp [MvPolynomial.pderiv_X_of_ne hij]
+  have hde : d = e := etale_derivation_ext d e (fun p ↦ Derivation.congr_fun he p)
+  exact Derivation.congr_fun hde a
+
+end BoundaryOnly.FormalObstruction.AlgebraicReplacement.TaylorShift
+
+namespace BoundaryOnly.FormalObstruction.FormalCorrection.AffineEtaleChart
+open MvPowerSeries BoundaryOnly.FormalObstruction.AlgebraicReplacement
+variable {K α : Type} [Field K] [Finite α]
+
+noncomputable def completionDeriv (E : AffineEtaleChart K α) (i : α) :
+    AdicCompletion (IsLocalRing.maximalIdeal E.LocalRing) E.LocalRing →+
+      AdicCompletion (IsLocalRing.maximalIdeal E.LocalRing) E.LocalRing :=
+  E.completionEquiv.symm.toAddMonoidHom.comp
+    ((pderiv (R := K) i).toAddMonoidHom.comp E.completionEquiv.toAddMonoidHom)
+
+@[simp] theorem completionDeriv_of (E : AffineEtaleChart K α) (i : α) (a : E.LocalRing) :
+    E.completionDeriv i (AdicCompletion.of _ _ a) = AdicCompletion.of _ _ (E.deriv i a) := by
+  apply E.completionEquiv.injective
+  change E.completionEquiv (E.completionEquiv.symm (pderiv (R := K) i
+    (E.completionEquiv (AdicCompletion.of _ _ a)))) = _
+  rw [E.completionEquiv.apply_symm_apply,E.completionEquiv_of,E.completionEquiv_of,
+    E.expansion_deriv]
+
+theorem completionDeriv_mem_pow (E : AffineEtaleChart K α) (i : α) (N : ℕ)
+    (b : AdicCompletion (IsLocalRing.maximalIdeal E.LocalRing) E.LocalRing)
+    (hb : b ∈ (IsLocalRing.maximalIdeal _ : Ideal
+      (AdicCompletion (IsLocalRing.maximalIdeal E.LocalRing) E.LocalRing))^(N+1)) :
+    E.completionDeriv i b ∈ (IsLocalRing.maximalIdeal _)^N := by
+  have hh := Ideal.mem_map_of_mem E.completionEquiv.toRingHom hb
+  rw [Ideal.map_pow] at hh
+  have he : (IsLocalRing.maximalIdeal _).map E.completionEquiv.toRingHom =
+      IsLocalRing.maximalIdeal _ := IsLocalRing.map_ringEquiv_maximalIdeal E.completionEquiv
+  rw [he] at hh
+  have hd := derivation_mem_pow (pderiv (R := K) i) (IsLocalRing.maximalIdeal _) N hh
+  have ht := Ideal.mem_map_of_mem E.completionEquiv.symm.toRingHom hd
+  rw [Ideal.map_pow] at ht
+  have he' : (IsLocalRing.maximalIdeal _).map E.completionEquiv.symm.toRingHom =
+      IsLocalRing.maximalIdeal _ := IsLocalRing.map_ringEquiv_maximalIdeal E.completionEquiv.symm
+  rw [he'] at ht
+  exact ht
+
+end BoundaryOnly.FormalObstruction.FormalCorrection.AffineEtaleChart
+
+namespace BoundaryOnly.FormalObstruction.AlgebraicReplacement.TaylorTarget
+variable {R S α : Type*} [CommRing R] [CommRing S]
+
+lemma shiftDeriv_map (f : R →+* S) (q : ℕ) (i : α) (x : Ring R α (q+1)) :
+    shiftDeriv i q (map f (q+1) x) = map f q (shiftDeriv i q x) := by
+  obtain ⟨p,rfl⟩ := mk_surjective (q+1) x
+  rw [map_mk,shiftDeriv_mk,shiftDeriv_mk,map_mk,MvPolynomial.pderiv_map]
+
+end BoundaryOnly.FormalObstruction.AlgebraicReplacement.TaylorTarget
+
+namespace BoundaryOnly.FormalObstruction.AlgebraicReplacement.TaylorShift
+variable {A α : Type} [CommRing A] [IsNoetherianRing A] [IsLocalRing A] [Finite α]
+
+lemma coefficient_adic_separated (I : Ideal A) (q : ℕ) (hq : 1 ≤ q)
+    (x y : Target (α := α) I q)
+    (h : ∀ N, x-y ∈ ((IsLocalRing.maximalIdeal A).map
+      (algebraMap A (Target (α := α) I q)))^N) : x = y := by
+  have : Module.Finite A (Target (α := α) I q) := coefficient_finite I q hq
+  apply (IsHausdorff.eq_iff_smodEq (I := IsLocalRing.maximalIdeal A)).mpr
+  intro N
+  rw [SModEq.sub_mem,Ideal.smul_top_eq_map,Submodule.restrictScalars_mem,Ideal.map_pow]
+  exact h N
+
+end BoundaryOnly.FormalObstruction.AlgebraicReplacement.TaylorShift
+
+namespace BoundaryOnly.FormalObstruction.FormalCorrection.AffineEtaleChart
+open MvPowerSeries BoundaryOnly.FormalObstruction.AlgebraicReplacement
+variable {K α : Type} [Field K] [Finite α]
+
+instance completionNoetherian (E : AffineEtaleChart K α) :
+    IsNoetherianRing (AdicCompletion (IsLocalRing.maximalIdeal E.LocalRing) E.LocalRing) :=
+  isNoetherianRing_of_ringEquiv (MvPowerSeries α K) E.completionEquiv.symm
+
+end BoundaryOnly.FormalObstruction.FormalCorrection.AffineEtaleChart
+
+namespace BoundaryOnly.FormalObstruction.AlgebraicReplacement
+variable {A B T : Type*} [AddCommGroup A] [CommRing B] [CommRing T]
+
+lemma additive_eq_of_approximation (f : A →+ B) (F G : B →+ T)
+    (J : Ideal B) (H : Ideal T) (q : ℕ)
+    (hdense : ∀ b N, ∃ a, b-f a ∈ J^N)
+    (hsep : ∀ x y, (∀ N, x-y ∈ H^N) → x=y)
+    (hF : ∀ N b, b ∈ J^(N+q) → F b ∈ H^N)
+    (hG : ∀ N b, b ∈ J^(N+q) → G b ∈ H^N)
+    (hag : ∀ a, F (f a) = G (f a)) (b : B) : F b = G b := by
+  apply hsep
+  intro N
+  obtain ⟨a,ha⟩ := hdense b (N+q)
+  have h := (H^N).sub_mem (hF N _ ha) (hG N _ ha)
+  rw [map_sub,map_sub,hag] at h
+  convert h using 1
+  abel
+
+end BoundaryOnly.FormalObstruction.AlgebraicReplacement
+
+namespace BoundaryOnly.FormalObstruction.FormalCorrection.AffineEtaleChart
+open MvPowerSeries BoundaryOnly.FormalObstruction.AlgebraicReplacement
+variable {K α : Type} [Field K] [Finite α]
+
+theorem fullTaylor_deriv_of (E : AffineEtaleChart K α) (I : Ideal E.LocalRing)
+    (i : α) (q : ℕ) (hq : 1 ≤ q) (a : E.LocalRing) :
+    TaylorTarget.shiftDeriv i q
+      (TaylorShift.fullTaylor (K := K) (α := α) I (IsLocalRing.maximalIdeal E.LocalRing)
+        (q+1) (by omega) (AdicCompletion.of _ _ a)) =
+      TaylorShift.fullTaylor (K := K) (α := α) I (IsLocalRing.maximalIdeal E.LocalRing)
+        q hq (AdicCompletion.of _ _ (E.deriv i a)) := by
+  rw [TaylorShift.fullTaylor_of,TaylorTarget.shiftDeriv_map,
+    TaylorShift.shiftDeriv_taylor I i q hq,TaylorShift.fullTaylor_of]
+  rfl
+
+theorem fullTaylor_deriv (E : AffineEtaleChart K α) (I : Ideal E.LocalRing)
+    (i : α) (q : ℕ) (hq : 1 ≤ q)
+    (b : AdicCompletion (IsLocalRing.maximalIdeal E.LocalRing) E.LocalRing) :
+    TaylorTarget.shiftDeriv i q
+      (TaylorShift.fullTaylor (K := K) (α := α) I (IsLocalRing.maximalIdeal E.LocalRing)
+        (q+1) (by omega) b) =
+    TaylorShift.fullTaylor (K := K) (α := α) I (IsLocalRing.maximalIdeal E.LocalRing)
+        q hq (E.completionDeriv i b) := by
+  let J := IsLocalRing.maximalIdeal E.LocalRing
+  let B := AdicCompletion J E.LocalRing
+  let R := I.map (algebraMap E.LocalRing B)
+  let m := IsLocalRing.maximalIdeal B
+  let T := TaylorTarget.Ring (B ⧸ R) α q
+  let F := (TaylorTarget.shiftDerivLinear (K := B ⧸ R) i q).toAddMonoidHom.comp
+    (TaylorShift.fullTaylor (K := K) (α := α) I J (q+1) (by omega)).toAddMonoidHom
+  let G := (TaylorShift.fullTaylor (K := K) (α := α) I J q hq).toAddMonoidHom.comp
+    (E.completionDeriv i)
+  have hm : m = J.map (algebraMap E.LocalRing B) :=
+    AdicCompletion.maximalIdeal_eq_map
+  apply additive_eq_of_approximation (AdicCompletion.of J E.LocalRing).toAddMonoidHom
+    F G m (m.map (algebraMap B T)) q
+  · intro b N
+    rw [hm]
+    exact completion_approximate J b N
+  · exact fun x y h ↦ TaylorShift.coefficient_adic_separated R q hq x y h
+  · intro N x hx
+    change TaylorTarget.shiftDeriv i q
+      (TaylorShift.fullTaylor (K := K) (α := α) I J (q+1) (by omega) x) ∈ _
+    rw [hm] at hx ⊢
+    apply TaylorTarget.shiftDeriv_mem_coeff_pow
+    apply TaylorShift.fullTaylor_mem_pow (K := K) (α := α) I J (q+1) (by omega) N x
+    rwa [show N+(q+1)-1 = N+q by omega]
+  · intro N x hx
+    change TaylorShift.fullTaylor (K := K) (α := α) I J q hq (E.completionDeriv i x) ∈ _
+    have hD := E.completionDeriv_mem_pow i (N+q-1) x (by
+      rw [show N+q-1+1 = N+q by omega]
+      exact hx)
+    change E.completionDeriv i x ∈ m^(N+q-1) at hD
+    rw [hm] at hD ⊢
+    exact TaylorShift.fullTaylor_mem_pow (K := K) (α := α) I J q hq N _ hD
+  · intro a
+    dsimp only [F,G,AddMonoidHom.comp_apply, RingHom.toAddMonoidHom_eq_coe,
+      AddMonoidHom.coe_coe]
+    exact (E.fullTaylor_deriv_of I i q hq a).trans
+      (congrArg (TaylorShift.fullTaylor (K := K) (α := α) I J q hq)
+        (E.completionDeriv_of i a).symm)
+
+end BoundaryOnly.FormalObstruction.FormalCorrection.AffineEtaleChart
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/AlgebraicObstruction/TaylorEvaluation.lean b/lean/OAI/Algebra/AlgebraicObstruction/TaylorEvaluation.lean
new file mode 100644
index 0000000000000000000000000000000000000000..0d17d700a59e7b8829bf00baaee3cd3e19b0366a
--- /dev/null
+++ b/lean/OAI/Algebra/AlgebraicObstruction/TaylorEvaluation.lean
@@ -0,0 +1,207 @@
+import Mathlib
+import OAI.Algebra.FrobeniusObstruction.Obstruction
+import OAI.Algebra.AlgebraicObstruction.TaylorCoefficients
+
+namespace OAI
+
+noncomputable section
+open scoped BigOperators
+
+namespace BoundaryOnly.FormalObstruction.AlgebraicReplacement
+namespace ResidueSection
+variable (K R : Type*) [Field K] [PerfectField K] [CommRing R] [IsLocalRing R]
+  [Algebra K R] [Algebra.EssFiniteType K R]
+
+abbrev Trunc (q : ℕ) := R ⧸ (IsLocalRing.maximalIdeal R)^q
+
+def reduction (q : ℕ) (hq : 1 ≤ q) : Trunc R q →ₐ[K] IsLocalRing.ResidueField R :=
+  Ideal.Quotient.factorₐ K (Ideal.pow_le_self (by omega : q ≠ 0))
+
+omit [PerfectField K] [Algebra.EssFiniteType K R] in
+lemma reduction_surjective (q : ℕ) (hq : 1 ≤ q) :
+    Function.Surjective (reduction K R q hq) :=
+  Ideal.Quotient.factor_surjective (Ideal.pow_le_self (by omega : q ≠ 0))
+
+omit [PerfectField K] [Algebra.EssFiniteType K R] in
+lemma reduction_ker_pow (q : ℕ) (hq : 1 ≤ q) :
+    RingHom.ker (reduction K R q hq : Trunc R q →+* IsLocalRing.ResidueField R) ^ q = ⊥ := by
+  change RingHom.ker (Ideal.Quotient.factor (Ideal.pow_le_self (by omega : q ≠ 0))) ^ q = ⊥
+  rw [Ideal.Quotient.factor_ker, ← Ideal.map_pow]
+  exact Ideal.map_quotient_self _
+
+noncomputable def sectionMap (q : ℕ) (hq : 1 ≤ q) :
+    IsLocalRing.ResidueField R →ₐ[K] Trunc R q :=
+  by
+  letI : Algebra.EssFiniteType K (IsLocalRing.ResidueField R) :=
+    Algebra.EssFiniteType.comp K R (IsLocalRing.ResidueField R)
+  exact Algebra.FormallySmooth.liftOfSurjective (AlgHom.id K _)
+    (reduction K R q hq) (reduction_surjective K R q hq)
+    ⟨q,reduction_ker_pow K R q hq⟩
+
+@[simp] lemma reduction_sectionMap (q : ℕ) (hq : 1 ≤ q) (a : IsLocalRing.ResidueField R) :
+    reduction K R q hq (sectionMap K R q hq a) = a :=
+  by
+  let : Algebra.EssFiniteType K (IsLocalRing.ResidueField R) :=
+    Algebra.EssFiniteType.comp K R (IsLocalRing.ResidueField R)
+  exact Algebra.FormallySmooth.liftOfSurjective_apply _ _ _ _ a
+
+omit [PerfectField K] [Algebra.EssFiniteType K R] in
+@[simp] lemma reduction_mk (q : ℕ) (hq : 1 ≤ q) (a : R) :
+    reduction K R q hq (Ideal.Quotient.mk _ a) = IsLocalRing.residue R a := rfl
+
+end ResidueSection
+end BoundaryOnly.FormalObstruction.AlgebraicReplacement
+
+namespace BoundaryOnly.FormalObstruction.AlgebraicReplacement
+namespace TaylorEvaluate
+variable {K A α D F : Type*} [CommRing K] [CommRing A] [CommRing D] [CommRing F]
+  [Algebra K A] [Algebra (MvPolynomial α K) A] [IsScalarTower K (MvPolynomial α K) A]
+
+noncomputable def poly (I : Ideal A) (f : A →+* D) (c : A ⧸ I →+* D) :
+    MvPolynomial α (A ⧸ I) →+* D :=
+  MvPolynomial.eval₂Hom c (fun i ↦ f (algebraMap (MvPolynomial α K) A (MvPolynomial.X i)) -
+    c (Ideal.Quotient.mk I (algebraMap (MvPolynomial α K) A (MvPolynomial.X i))))
+
+omit [Algebra K A] [IsScalarTower K (MvPolynomial α K) A] in
+lemma variables_map_le (I : Ideal A) (f : A →+* D) (c : A ⧸ I →+* D)
+    (g : D →+* F) (hc : ∀ a : A, g (c (Ideal.Quotient.mk I a)) = g (f a)) :
+    (TaylorTarget.variablesIdeal (A ⧸ I) α).map (poly (K := K) (α := α) I f c) ≤ RingHom.ker g := by
+  rw [Ideal.map_le_iff_le_comap,Ideal.span_le]
+  rintro _ ⟨i,rfl⟩
+  change g (poly (K := K) (α := α) I f c (MvPolynomial.X i)) = 0
+  simp only [poly,MvPolynomial.eval₂Hom_X',map_sub,hc,sub_self]
+
+noncomputable def evaluate (I : Ideal A) (f : A →+* D) (c : A ⧸ I →+* D)
+    (g : D →+* F) (hc : ∀ a : A, g (c (Ideal.Quotient.mk I a)) = g (f a))
+    (q : ℕ) (hg : RingHom.ker g ^ q = ⊥) : TaylorShift.Target (α := α) I q →+* D :=
+  Ideal.Quotient.lift _ (poly (K := K) (α := α) I f c) (by
+    change TaylorTarget.variablesIdeal (A ⧸ I) α ^ q ≤ RingHom.ker (poly (K := K) (α := α) I f c)
+    rw [RingHom.ker_eq_comap_bot,← Ideal.map_le_iff_le_comap,Ideal.map_pow]
+    exact (pow_le_pow_left' (variables_map_le I f c g hc) q).trans (le_of_eq hg))
+
+omit [Algebra K A] [IsScalarTower K (MvPolynomial α K) A] in
+@[simp] lemma evaluate_mk (I : Ideal A) (f : A →+* D) (c : A ⧸ I →+* D)
+    (g : D →+* F) (hc : ∀ a : A, g (c (Ideal.Quotient.mk I a)) = g (f a))
+    (q : ℕ) (hg : RingHom.ker g ^ q = ⊥) (p : MvPolynomial α (A ⧸ I)) :
+    evaluate (K := K) I f c g hc q hg (TaylorTarget.mk (A ⧸ I) α q p) =
+      poly (K := K) (α := α) I f c p := rfl
+
+lemma evaluate_shift (I : Ideal A) (f : A →+* D) (c : A ⧸ I →+* D)
+    (g : D →+* F) (hc : ∀ a : A, g (c (Ideal.Quotient.mk I a)) = g (f a))
+    (q : ℕ) (hg : RingHom.ker g ^ q = ⊥)
+    (hcK : ∀ k : K, c (Ideal.Quotient.mk I (algebraMap K A k)) = f (algebraMap K A k))
+    (p : MvPolynomial α K) :
+    evaluate (K := K) I f c g hc q hg (TaylorShift.shift I q p) =
+      f (algebraMap (MvPolynomial α K) A p) := by
+  have h : (evaluate (K := K) I f c g hc q hg).comp (TaylorShift.shift I q) =
+      f.comp (algebraMap (MvPolynomial α K) A) := by
+    apply MvPolynomial.ringHom_ext
+    · intro k
+      simp only [RingHom.comp_apply,TaylorShift.shift,MvPolynomial.eval₂Hom_C]
+      rw [evaluate_mk]
+      simp only [poly,MvPolynomial.eval₂Hom_C]
+      rw [hcK]
+      exact congrArg f (IsScalarTower.algebraMap_apply K (MvPolynomial α K) A k)
+    · intro i
+      simp [TaylorShift.shift,poly]
+  exact RingHom.congr_fun h p
+
+omit [Algebra K A] [IsScalarTower K (MvPolynomial α K) A] in
+lemma reduction_evaluate (I : Ideal A) (f : A →+* D) (c : A ⧸ I →+* D)
+    (g : D →+* F) (hc : ∀ a : A, g (c (Ideal.Quotient.mk I a)) = g (f a))
+    (q : ℕ) (hq : 1 ≤ q) (hg : RingHom.ker g ^ q = ⊥)
+    (x : TaylorShift.Target (α := α) I q) :
+    g (evaluate (K := K) I f c g hc q hg x) =
+      g (c (TaylorTarget.reduction (A ⧸ I) α q hq x)) := by
+  have hh : g.comp (poly (K := K) (α := α) I f c) =
+      (g.comp c).comp MvPolynomial.constantCoeff := by
+    apply MvPolynomial.ringHom_ext
+    · intro a; simp [poly]
+    · intro i
+      simp only [RingHom.comp_apply,poly,MvPolynomial.eval₂Hom_X',map_sub,hc,
+        sub_self,MvPolynomial.constantCoeff_X,map_zero]
+  obtain ⟨p,rfl⟩ := Ideal.Quotient.mk_surjective x
+  exact RingHom.congr_fun hh p
+
+theorem evaluate_taylor [Algebra.FormallyEtale (MvPolynomial α K) A]
+    (I : Ideal A) (f : A →+* D) (c : A ⧸ I →+* D)
+    (g : D →+* F) (hc : ∀ a : A, g (c (Ideal.Quotient.mk I a)) = g (f a))
+    (q : ℕ) (hq : 1 ≤ q) (hg : RingHom.ker g ^ q = ⊥)
+    (hcK : ∀ k : K, c (Ideal.Quotient.mk I (algebraMap K A k)) = f (algebraMap K A k))
+    (a : A) :
+    evaluate (K := K) I f c g hc q hg (TaylorShift.taylor (K := K) (α := α) I q hq a) = f a := by
+  let : Algebra (MvPolynomial α K) D := (f.comp (algebraMap (MvPolynomial α K) A)).toAlgebra
+  let u : A →ₐ[MvPolynomial α K] D :=
+    { (evaluate (K := K) I f c g hc q hg).comp (TaylorShift.taylor (K := K) (α := α) I q hq) with
+      commutes' := by
+        intro p
+        change evaluate (K := K) I f c g hc q hg
+          (TaylorShift.taylor (K := K) (α := α) I q hq (algebraMap (MvPolynomial α K) A p)) = _
+        rw [TaylorShift.taylor_coordinates]
+        exact evaluate_shift I f c g hc q hg hcK p }
+  let v : A →ₐ[MvPolynomial α K] D := ⟨f, fun _ ↦ rfl⟩
+  have huv : u = v := Algebra.FormallyUnramified.ext' g ⟨q,hg⟩ u v (by
+    intro b
+    change g (evaluate (K := K) I f c g hc q hg
+      (TaylorShift.taylor (K := K) (α := α) I q hq b)) = g (f b)
+    rw [reduction_evaluate I f c g hc q hq hg,TaylorShift.reduction_taylor]
+    exact hc b)
+  exact AlgHom.congr_fun huv a
+
+end TaylorEvaluate
+end BoundaryOnly.FormalObstruction.AlgebraicReplacement
+
+namespace BoundaryOnly.FormalObstruction.AlgebraicReplacement
+namespace SymbolicTaylor
+variable {K A α : Type*} [Field K] [PerfectField K] [CommRing A]
+  [Algebra K A] [Algebra (MvPolynomial α K) A] [IsScalarTower K (MvPolynomial α K) A]
+  [Algebra.EssFiniteType K A] [Algebra.FormallyEtale (MvPolynomial α K) A]
+
+theorem kernel_le_symbolic (I p : Ideal A) [p.IsPrime] (hIp : I ≤ p)
+    (q : ℕ) (hq : 1 ≤ q) (a : A)
+    (ha : TaylorShift.taylor (K := K) (α := α) I q hq a = 0) :
+    ∃ s : A, s ∉ p ∧ s*a ∈ p^q := by
+  let R := Localization.AtPrime p
+  let : Algebra.EssFiniteType A R :=
+    Algebra.EssFiniteType.of_isLocalization R p.primeCompl
+  let : Algebra.EssFiniteType K R := Algebra.EssFiniteType.comp K A R
+  let m := IsLocalRing.maximalIdeal R
+  let D := R ⧸ m^q
+  let F := IsLocalRing.ResidueField R
+  let f : A →ₐ[K] D := (Ideal.Quotient.mkₐ K (m^q)).comp (IsScalarTower.toAlgHom K A R)
+  let rho : A →ₐ[K] F :=
+    (IsScalarTower.toAlgHom K R F).comp (IsScalarTower.toAlgHom K A R)
+  have hI : I ≤ RingHom.ker (rho : A →+* F) := by
+    intro b hb
+    change IsLocalRing.residue R (algebraMap A R b) = 0
+    rw [IsLocalRing.residue_eq_zero_iff,← Localization.AtPrime.map_eq_maximalIdeal]
+    exact Ideal.mem_map_of_mem _ (hIp hb)
+  let rhoQ : A ⧸ I →ₐ[K] F := Ideal.Quotient.liftₐ I rho hI
+  let c : A ⧸ I →ₐ[K] D := (ResidueSection.sectionMap K R q hq).comp rhoQ
+  let g : D →ₐ[K] F := ResidueSection.reduction K R q hq
+  have hc : ∀ b : A, g (c (Ideal.Quotient.mk I b)) = g (f b) := by
+    intro b
+    dsimp [c,g,f,rhoQ]
+    rw [ResidueSection.reduction_sectionMap]
+    rfl
+  have hcK : ∀ k : K, c (Ideal.Quotient.mk I (algebraMap K A k)) = f (algebraMap K A k) := by
+    intro k
+    change c (algebraMap K (A ⧸ I) k) = f (algebraMap K A k)
+    rw [c.commutes,f.commutes]
+  have hg : RingHom.ker (g : D →+* F) ^ q = ⊥ := ResidueSection.reduction_ker_pow K R q hq
+  have hf : f a = 0 := by
+    have he := TaylorEvaluate.evaluate_taylor (α := α) I f.toRingHom c.toRingHom
+      g.toRingHom hc q hq hg hcK a
+    rw [ha,map_zero] at he
+    exact he.symm
+  have ham : algebraMap A R a ∈ m^q := (Ideal.Quotient.eq_zero_iff_mem).mp hf
+  have hmp : m = p.map (algebraMap A R) := Localization.AtPrime.map_eq_maximalIdeal.symm
+  rw [hmp,← Ideal.map_pow,IsLocalization.algebraMap_mem_map_algebraMap_iff p.primeCompl] at ham
+  exact ham
+
+end SymbolicTaylor
+end BoundaryOnly.FormalObstruction.AlgebraicReplacement
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/AlgebraicObstruction/TaylorRemainder.lean b/lean/OAI/Algebra/AlgebraicObstruction/TaylorRemainder.lean
new file mode 100644
index 0000000000000000000000000000000000000000..90152adb177cce65b9d907c462eaba36a9bb771d
--- /dev/null
+++ b/lean/OAI/Algebra/AlgebraicObstruction/TaylorRemainder.lean
@@ -0,0 +1,320 @@
+import Mathlib
+import OAI.Algebra.FrobeniusObstruction.Obstruction
+import OAI.Algebra.AlgebraicObstruction.Differentiation
+
+namespace OAI
+
+noncomputable section
+open scoped BigOperators
+
+namespace BoundaryOnly.FormalObstruction.FormalCorrection
+open MvPowerSeries
+open scoped Classical
+variable {R σ κ : Type*} [CommRing R] [Fintype κ]
+
+noncomputable def monomialFactor (m : κ → σ →₀ ℕ) (f : MvPowerSeries σ R)
+    (j : κ) : MvPowerSeries σ R := fun e => by
+  classical
+  exact if h : ∃ k, m k ≤ e + m j then
+    if j = h.choose then coeff (e + m j) f else 0 else 0
+
+ theorem coeff_monomialFactor (m : κ → σ →₀ ℕ) (f : MvPowerSeries σ R)
+    (j : κ) (e : σ →₀ ℕ) :
+    coeff e (monomial (m j) 1 * monomialFactor m f j) =
+      if h : ∃ k, m k ≤ e then if j = h.choose then coeff e f else 0 else 0 := by
+  classical
+  rw [coeff_monomial_mul]
+  by_cases hj : m j ≤ e
+  · rw [ite_eq_left hj]
+    simp only [one_mul, monomialFactor, coeff_apply, tsub_add_cancel_of_le hj]
+  · rw [ite_eq_right hj]
+    split_ifs with h heq
+    · exact (hj (heq ▸ h.choose_spec)).elim
+    all_goals rfl
+
+ theorem monomial_factorization (m : κ → σ →₀ ℕ) (f : MvPowerSeries σ R)
+    (hzero : ∀ e, (¬ ∃ k, m k ≤ e) → coeff e f = 0) :
+    f = ∑ j, monomial (m j) 1 * monomialFactor m f j := by
+  classical
+  ext e
+  simp only [map_sum, coeff_monomialFactor]
+  by_cases h : ∃ k, m k ≤ e
+  · simp only [dite_eq_left h, Finset.sum_ite_eq', Finset.mem_univ, ite_true]
+  · simp only [dite_eq_right h, Finset.sum_const_zero, hzero e h]
+
+ theorem monomialFactor_vanishes (m : κ → σ →₀ ℕ) (f : MvPowerSeries σ R)
+    {a b : ℕ} (hf : Vanishes (a+b) f) (hm : ∀ j, (m j).degree = b) (j : κ) :
+    Vanishes a (monomialFactor m f j) := by
+  classical
+  intro e he
+  change (if h : ∃ k, m k ≤ e + m j then
+    if j = h.choose then coeff (e + m j) f else 0 else 0) = 0
+  split_ifs
+  · apply hf
+    simp only [map_add, hm]
+    omega
+  all_goals rfl
+
+end BoundaryOnly.FormalObstruction.FormalCorrection
+
+namespace BoundaryOnly.FormalObstruction.FormalCorrection
+open MvPowerSeries
+variable {R σ τ ι : Type*} [CommRing R]
+
+theorem constantCoeff_killCompl (e : σ ↪ τ) (f : MvPowerSeries τ R) :
+    constantCoeff (killCompl e f) = constantCoeff f := by
+  change coeff 0 (killCompl e f) = coeff 0 f
+  rw [coeff_killCompl, Finsupp.embDomain_zero]
+
+theorem Jet.killCompl {n : ℕ} {f g : MvPowerSeries τ R}
+    (e : σ ↪ τ) (h : Jet n f g) : Jet n (killCompl e f) (killCompl e g) := by
+  apply Jet.iff_coeff.mpr
+  intro d hd
+  simp only [coeff_killCompl]
+  apply Jet.iff_coeff.mp h
+  simpa only [Finsupp.embDomain_eq_mapDomain, Finsupp.degree_mapDomain] using hd
+
+theorem killCompl_subst [Finite σ] [Finite τ] [Finite ι]
+    (e : σ ↪ τ) (a : ι → MvPowerSeries τ R)
+    (ha : ∀ i, constantCoeff (a i) = 0) (f : MvPowerSeries ι R) :
+    killCompl e (subst a f) = subst (fun i => killCompl e (a i)) f := by
+  classical
+  ext d
+  have hb : ∀ i, constantCoeff (killCompl e (a i)) = 0 := by
+    intro i; rw [constantCoeff_killCompl, ha]
+  let p := truncTotal (d.degree+1) f
+  have hp : Jet (d.degree+1) f p.toMvPowerSeries := jet_trunc _ _
+  have hl := (Jet.subst_series a ha hp).killCompl e
+  have hr := Jet.subst_series (fun i => killCompl e (a i)) hb hp
+  rw [Jet.iff_coeff.mp hl d (Nat.lt_succ_self _),
+      Jet.iff_coeff.mp hr d (Nat.lt_succ_self _)]
+  simp only [subst_coe, MvPolynomial.comp_aeval_apply]
+
+def dropExponent (e : (σ ⊕ τ) →₀ ℕ) : σ →₀ ℕ :=
+  e.comapDomain Sum.inl Sum.inl_injective.injOn
+
+theorem embed_dropExponent (e : (σ ⊕ τ) →₀ ℕ) (h : ∀ i, e (Sum.inr i) = 0) :
+    Finsupp.embDomain (Function.Embedding.inl : σ ↪ σ ⊕ τ) (dropExponent e) = e := by
+  classical
+  ext i
+  cases i with
+  | inl i => exact Finsupp.embDomain_apply_self _ _ i
+  | inr i => simp [h]
+
+theorem coeff_eq_zero_of_killCompl (f : MvPowerSeries (σ ⊕ τ) R)
+    (hf : killCompl (Function.Embedding.inl : σ ↪ σ ⊕ τ) f = 0)
+    (e : (σ ⊕ τ) →₀ ℕ) (he : ∀ i, e (Sum.inr i) = 0) : coeff e f = 0 := by
+  have h := congrArg (coeff (dropExponent e)) hf
+  simpa only [coeff_killCompl, embed_dropExponent e he, map_zero] using h
+
+theorem single_le_exponent (i : σ) (e : σ →₀ ℕ) (h : 1 ≤ e i) :
+    Finsupp.single i 1 ≤ e := (Finsupp.single_le_iff).mpr h
+
+theorem no_delta_coeff (f : MvPowerSeries (σ ⊕ τ) R)
+    (hf : killCompl (Function.Embedding.inl : σ ↪ σ ⊕ τ) f = 0)
+    (e : (σ ⊕ τ) →₀ ℕ)
+    (he : ¬ ∃ i : τ, Finsupp.single (Sum.inr i) 1 ≤ e) : coeff e f = 0 := by
+  apply coeff_eq_zero_of_killCompl f hf e
+  intro i
+  have hi : ¬ 1 ≤ e (Sum.inr i) := fun hi => he ⟨i, single_le_exponent _ _ hi⟩
+  omega
+
+theorem no_two_delta_coeff (f : MvPowerSeries (σ ⊕ τ) R)
+    (hf : killCompl (Function.Embedding.inl : σ ↪ σ ⊕ τ) f = 0)
+    (hd : ∀ i, killCompl (Function.Embedding.inl : σ ↪ σ ⊕ τ) (MvPowerSeries.pderiv (R := R) (Sum.inr i) f) = 0)
+    (e : (σ ⊕ τ) →₀ ℕ)
+    (he : ¬ ∃ ij : τ × τ, Finsupp.single (Sum.inr ij.1) 1 + Finsupp.single (Sum.inr ij.2) 1 ≤ e) :
+    coeff e f = 0 := by
+  classical
+  by_cases hone : ∃ i : τ, Finsupp.single (Sum.inr i) 1 ≤ e
+  · obtain ⟨i, hi⟩ := hone
+    let e' := e - Finsupp.single (Sum.inr i) 1
+    have heq : e' + Finsupp.single (Sum.inr i) 1 = e := tsub_add_cancel_of_le hi
+    have hz : ∀ j, e' (Sum.inr j) = 0 := by
+      intro j
+      by_contra hj
+      have hj' : Finsupp.single (Sum.inr j) 1 ≤ e' := single_le_exponent _ _ (by omega)
+      apply he
+      refine ⟨(j,i), ?_⟩
+      rw [← heq]
+      exact add_le_add hj' le_rfl
+    have hcoeff := coeff_eq_zero_of_killCompl _ (hd i) e' hz
+    simpa only [coeff_pderiv, hz, Nat.cast_zero, zero_add, mul_one, heq] using hcoeff
+  · exact no_delta_coeff f hf e hone
+
+end BoundaryOnly.FormalObstruction.FormalCorrection
+
+namespace BoundaryOnly.FormalObstruction.FormalCorrection
+open MvPowerSeries
+open scoped Classical
+variable {R α ι : Type*} [CommRing R]
+
+abbrev Extended := (α ⊕ ι) ⊕ ι
+
+def baseArguments : (α ⊕ ι) → MvPowerSeries (Extended (α := α) (ι := ι)) R :=
+  fun i => X (Sum.inl i)
+
+def shiftedArguments : (α ⊕ ι) → MvPowerSeries (Extended (α := α) (ι := ι)) R :=
+  Sum.elim (fun a => X (Sum.inl (Sum.inl a)))
+    (fun i => X (Sum.inl (Sum.inr i)) + X (Sum.inr i))
+
+theorem baseArguments_centered [Fintype α] [Fintype ι] (i : α ⊕ ι) :
+    constantCoeff (baseArguments (R := R) i) = 0 := by simp [baseArguments]
+
+theorem shiftedArguments_centered [Fintype α] [Fintype ι] (i : α ⊕ ι) :
+    constantCoeff (shiftedArguments (R := R) i) = 0 := by
+  cases i <;> simp [shiftedArguments]
+
+abbrev dropDelta : MvPowerSeries (Extended (α := α) (ι := ι)) R →ₐ[R] MvPowerSeries (α ⊕ ι) R :=
+  killCompl (Function.Embedding.inl : (α ⊕ ι) ↪ (α ⊕ ι) ⊕ ι)
+
+theorem dropDelta_baseArguments [Fintype α] [Fintype ι] (i : α ⊕ ι) :
+    dropDelta (baseArguments (R := R) i) = X i := by
+  exact killCompl_X i
+
+theorem dropDelta_X [Fintype α] [Fintype ι] (i : ι) :
+    dropDelta (X (Sum.inr i) : MvPowerSeries (Extended (α := α)) R) = 0 := by
+  apply killCompl_X_eq_zero
+  simp
+
+variable [Fintype α] [Fintype ι]
+
+theorem dropDelta_shiftedArguments (i : α ⊕ ι) :
+    dropDelta (shiftedArguments (R := R) i) = X i := by
+  cases i with
+  | inl i => exact dropDelta_baseArguments (Sum.inl i)
+  | inr i =>
+    change dropDelta (baseArguments (Sum.inr i) + X (Sum.inr i)) = _
+    rw [map_add, dropDelta_baseArguments, dropDelta_X, add_zero]
+
+theorem dropDelta_subst_base (f : MvPowerSeries (α ⊕ ι) R) :
+    dropDelta (subst baseArguments f) = f := by
+  rw [killCompl_subst _ _ baseArguments_centered]
+  simp only [dropDelta_baseArguments, subst_self, id_eq]
+
+theorem dropDelta_subst_shifted (f : MvPowerSeries (α ⊕ ι) R) :
+    dropDelta (subst shiftedArguments f) = f := by
+  rw [killCompl_subst _ _ shiftedArguments_centered]
+  simp only [dropDelta_shiftedArguments, subst_self, id_eq]
+
+theorem pderiv_delta_subst_base (f : MvPowerSeries (α ⊕ ι) R) (i : ι) :
+    MvPowerSeries.pderiv (R := R) (Sum.inr i) (subst baseArguments f) = 0 := by
+  rw [pderiv_subst _ baseArguments_centered]
+  simp [baseArguments]
+
+theorem pderiv_delta_subst_shifted (f : MvPowerSeries (α ⊕ ι) R) (i : ι) :
+    MvPowerSeries.pderiv (R := R) (Sum.inr i) (subst shiftedArguments f) =
+      subst shiftedArguments (MvPowerSeries.pderiv (R := R) (Sum.inr i) f) := by
+  rw [pderiv_subst _ shiftedArguments_centered, Fintype.sum_sum_type]
+  simp [shiftedArguments, MvPowerSeries.pderiv_X, Pi.single_apply]
+
+noncomputable def universalDifference (f : MvPowerSeries (α ⊕ ι) R) : MvPowerSeries (Extended (α := α) (ι := ι)) R :=
+  subst shiftedArguments f - subst baseArguments f
+
+noncomputable def universalRemainder (f : MvPowerSeries (α ⊕ ι) R) : MvPowerSeries (Extended (α := α) (ι := ι)) R :=
+  universalDifference f - ∑ i : ι, X (Sum.inr i) * subst baseArguments (MvPowerSeries.pderiv (R := R) (Sum.inr i) f)
+
+theorem dropDelta_difference (f : MvPowerSeries (α ⊕ ι) R) :
+    dropDelta (universalDifference f) = 0 := by
+  simp only [universalDifference, map_sub, dropDelta_subst_base, dropDelta_subst_shifted, sub_self]
+
+theorem dropDelta_remainder (f : MvPowerSeries (α ⊕ ι) R) :
+    dropDelta (universalRemainder f) = 0 := by
+  simp only [universalRemainder, map_sub, dropDelta_difference, map_sum, map_mul,
+    dropDelta_X, zero_mul, Finset.sum_const_zero, sub_zero]
+
+theorem dropDelta_pderiv_remainder (f : MvPowerSeries (α ⊕ ι) R) (i : ι) :
+    dropDelta (MvPowerSeries.pderiv (R := R) (Sum.inr i) (universalRemainder f)) = 0 := by
+  simp [universalRemainder, universalDifference, map_sub, map_sum,
+    Derivation.leibniz, smul_eq_mul, pderiv_delta_subst_base, pderiv_delta_subst_shifted,
+    dropDelta_subst_shifted, dropDelta_subst_base, MvPowerSeries.pderiv_X, Pi.single_apply]
+
+theorem universalDifference_vanishes {n : ℕ} (f : MvPowerSeries (α ⊕ ι) R) (hf : Vanishes n f) :
+    Vanishes n (universalDifference f) := by
+  simpa only [universalDifference, sub_eq_add_neg] using
+    (hf.subst _ shiftedArguments_centered).add (hf.subst _ baseArguments_centered).neg
+
+theorem universalRemainder_vanishes (f : MvPowerSeries (α ⊕ ι) R) (hf : Vanishes 3 f) :
+    Vanishes 3 (universalRemainder f) := by
+  unfold universalRemainder
+  rw [sub_eq_add_neg]
+  apply (universalDifference_vanishes f hf).add
+  apply Vanishes.neg
+  apply Vanishes.sum
+  intro i _
+  have hx : Vanishes 1 (X (Sum.inr i) : MvPowerSeries (Extended (α := α)) R) :=
+    Vanishes.one_iff.mpr (by simp)
+  exact hx.mul ((hf.pderiv (Sum.inr i)).subst _ baseArguments_centered)
+
+theorem exists_taylor_remainder (f : MvPowerSeries (α ⊕ ι) R) (hf : Vanishes 3 f) :
+    ∃ H : Matrix ι ι (MvPowerSeries (Extended (α := α)) R),
+      (∀ i j, Vanishes 1 (H i j)) ∧
+      subst shiftedArguments f = subst baseArguments f +
+        (∑ i, X (Sum.inr i) * subst baseArguments (MvPowerSeries.pderiv (R := R) (Sum.inr i) f)) +
+        ∑ i, ∑ j, X (Sum.inr i) * H i j * X (Sum.inr j) := by
+  let m : (ι × ι) → (Extended (α := α)) →₀ ℕ :=
+    fun ij => Finsupp.single (Sum.inr ij.1) 1 + Finsupp.single (Sum.inr ij.2) 1
+  let H : Matrix ι ι (MvPowerSeries (Extended (α := α)) R) :=
+    fun i j => monomialFactor m (universalRemainder f) (i,j)
+  have hH : ∀ i j, Vanishes 1 (H i j) := by
+    intro i j
+    apply monomialFactor_vanishes m _ (a := 1) (b := 2) (universalRemainder_vanishes f hf)
+    intro ij
+    simp [m]
+  have hfac := monomial_factorization m (universalRemainder f)
+    (no_two_delta_coeff _ (dropDelta_remainder f) (dropDelta_pderiv_remainder f))
+  have hm (i j : ι) : monomial (m (i,j)) (1 : R) = X (Sum.inr i) * X (Sum.inr j) := by
+    simp only [m, X, monomial_mul_monomial, one_mul]
+  refine ⟨H,hH,?_⟩
+  have heq : universalRemainder f = ∑ i, ∑ j, X (Sum.inr i) * H i j * X (Sum.inr j) := by
+    rw [hfac, Fintype.sum_prod_type]
+    apply Finset.sum_congr rfl
+    intro i _
+    apply Finset.sum_congr rfl
+    intro j _
+    rw [hm]
+    dsimp [H]
+    ring
+  dsimp [universalRemainder, universalDifference] at heq
+  linear_combination heq
+
+end BoundaryOnly.FormalObstruction.FormalCorrection
+
+namespace BoundaryOnly.FormalObstruction.FormalCorrection
+open MvPowerSeries
+open scoped Classical
+variable {R α ι : Type*} [CommRing R] [Fintype α] [Fintype ι]
+
+theorem exists_first_remainder (f : MvPowerSeries (α ⊕ ι) R) :
+    ∃ q : ι → MvPowerSeries (Extended (α := α) (ι := ι)) R,
+      (∀ n, Vanishes (n+1) f → ∀ i, Vanishes n (q i)) ∧
+      subst shiftedArguments f - subst baseArguments f = ∑ i, q i * X (Sum.inr i) := by
+  let m : ι → (Extended (α := α) (ι := ι)) →₀ ℕ := fun i => Finsupp.single (Sum.inr i) 1
+  let q := monomialFactor m (universalDifference f)
+  refine ⟨q, ?_, ?_⟩
+  · intro n hf i
+    exact monomialFactor_vanishes m _ (universalDifference_vanishes f hf)
+      (fun j => Finsupp.degree_single _ _) i
+  · have hfac := monomial_factorization m (universalDifference f)
+      (no_delta_coeff _ (dropDelta_difference f))
+    change universalDifference f = _
+    rw [hfac]
+    apply Finset.sum_congr rfl
+    intro i _
+    change X (Sum.inr i) * q i = q i * X (Sum.inr i)
+    exact mul_comm _ _
+
+theorem exists_gradient_remainder (f : MvPowerSeries (α ⊕ ι) R) (hf : Vanishes 3 f) :
+    ∃ G : Matrix ι ι (MvPowerSeries (Extended (α := α)) R),
+      (∀ i j, Vanishes 1 (G i j)) ∧
+      (∀ i, subst shiftedArguments (MvPowerSeries.pderiv (R := R) (Sum.inr i) f) -
+          subst baseArguments (MvPowerSeries.pderiv (R := R) (Sum.inr i) f) =
+        ∑ j, G i j * X (Sum.inr j)) := by
+  choose G hG hdiff using fun i : ι => exists_first_remainder (MvPowerSeries.pderiv (R := R) (Sum.inr i) f)
+  exact ⟨G, fun i j => hG i 1 (hf.pderiv _) j, hdiff⟩
+
+end BoundaryOnly.FormalObstruction.FormalCorrection
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/AlgebraicObstruction/TaylorShift.lean b/lean/OAI/Algebra/AlgebraicObstruction/TaylorShift.lean
new file mode 100644
index 0000000000000000000000000000000000000000..95a9383014d34e83285cad4570dc40e03164196a
--- /dev/null
+++ b/lean/OAI/Algebra/AlgebraicObstruction/TaylorShift.lean
@@ -0,0 +1,163 @@
+import Mathlib
+import OAI.Algebra.FrobeniusObstruction.Obstruction
+import OAI.Algebra.AlgebraicObstruction.ChartCompletion
+
+namespace OAI
+
+noncomputable section
+open scoped BigOperators
+
+namespace BoundaryOnly.FormalObstruction.AlgebraicReplacement
+namespace TaylorShift
+variable {K A α : Type*} [CommRing K] [CommRing A]
+  [Algebra K A] [Algebra (MvPolynomial α K) A]
+  [IsScalarTower K (MvPolynomial α K) A]
+
+abbrev Target (I : Ideal A) (q : ℕ) := TaylorTarget.Ring (A ⧸ I) α q
+
+def shift (I : Ideal A) (q : ℕ) : MvPolynomial α K →+* Target (α := α) I q :=
+  MvPolynomial.eval₂Hom
+    ((TaylorTarget.mk (A ⧸ I) α q).comp (MvPolynomial.C.comp
+      ((Ideal.Quotient.mk I).comp (algebraMap K A))))
+    (fun i ↦ TaylorTarget.mk (A ⧸ I) α q
+      (MvPolynomial.C (Ideal.Quotient.mk I (algebraMap (MvPolynomial α K) A
+        (MvPolynomial.X i))) + MvPolynomial.X i))
+
+lemma reduction_shift (I : Ideal A) (q : ℕ) (hq : 1 ≤ q) (p : MvPolynomial α K) :
+    TaylorTarget.reduction (A ⧸ I) α q hq (shift I q p) =
+      Ideal.Quotient.mk I (algebraMap (MvPolynomial α K) A p) := by
+  have hh : (TaylorTarget.reduction (A ⧸ I) α q hq).comp (shift I q) =
+      (Ideal.Quotient.mk I).comp (algebraMap (MvPolynomial α K) A) := by
+    apply MvPolynomial.ringHom_ext
+    · intro k
+      simp only [shift,RingHom.comp_apply,MvPolynomial.eval₂Hom_C,
+        TaylorTarget.reduction_mk,MvPolynomial.constantCoeff_C]
+      exact congrArg (Ideal.Quotient.mk I)
+        (IsScalarTower.algebraMap_apply K (MvPolynomial α K) A k)
+    · intro i
+      simp [shift]
+  exact RingHom.congr_fun hh p
+
+noncomputable def taylor [Algebra.FormallySmooth (MvPolynomial α K) A]
+    (I : Ideal A) (q : ℕ) (hq : 1 ≤ q) : A →+* Target (α := α) I q := by
+  letI : Algebra (MvPolynomial α K) (Target (α := α) I q) := (shift I q).toAlgebra
+  let f : Target (α := α) I q →ₐ[MvPolynomial α K] (A ⧸ I) :=
+    { TaylorTarget.reduction (A ⧸ I) α q hq with
+      commutes' := reduction_shift I q hq }
+  exact (Algebra.FormallySmooth.liftOfSurjective
+    (Ideal.Quotient.mkₐ (MvPolynomial α K) I) f
+    (TaylorTarget.reduction_surjective (A ⧸ I) α q hq)
+    (by change IsNilpotent (RingHom.ker (TaylorTarget.reduction (A ⧸ I) α q hq))
+        rw [TaylorTarget.reduction_ker]
+        exact ⟨q,TaylorTarget.variables_pow (A ⧸ I) α q⟩)).toRingHom
+
+lemma reduction_taylor [Algebra.FormallySmooth (MvPolynomial α K) A]
+    (I : Ideal A) (q : ℕ) (hq : 1 ≤ q) (a : A) :
+    TaylorTarget.reduction (A ⧸ I) α q hq (taylor (K := K) (α := α) I q hq a) =
+      Ideal.Quotient.mk I a := by
+  let : Algebra (MvPolynomial α K) (Target (α := α) I q) := (shift I q).toAlgebra
+  let f : Target (α := α) I q →ₐ[MvPolynomial α K] (A ⧸ I) :=
+    { TaylorTarget.reduction (A ⧸ I) α q hq with
+      commutes' := reduction_shift I q hq }
+  exact Algebra.FormallySmooth.liftOfSurjective_apply
+    (Ideal.Quotient.mkₐ (MvPolynomial α K) I) f
+    (TaylorTarget.reduction_surjective (A ⧸ I) α q hq)
+    (by change IsNilpotent (RingHom.ker (TaylorTarget.reduction (A ⧸ I) α q hq))
+        rw [TaylorTarget.reduction_ker]
+        exact ⟨q,TaylorTarget.variables_pow (A ⧸ I) α q⟩) a
+
+lemma taylor_coordinates [Algebra.FormallySmooth (MvPolynomial α K) A]
+    (I : Ideal A) (q : ℕ) (hq : 1 ≤ q) (p : MvPolynomial α K) :
+    taylor (K := K) (α := α) I q hq (algebraMap (MvPolynomial α K) A p) = shift I q p := by
+  let : Algebra (MvPolynomial α K) (Target (α := α) I q) := (shift I q).toAlgebra
+  unfold taylor
+  exact AlgHom.commutes _ p
+
+theorem taylor_finite [Algebra.FormallySmooth (MvPolynomial α K) A] [Finite α]
+    (I : Ideal A) (q : ℕ) (hq : 1 ≤ q) :
+    @Module.Finite A (Target (α := α) I q) _ _ (taylor (K := K) (α := α) I q hq).toAlgebra.toModule := by
+  let : Algebra A (Target (α := α) I q) := (taylor (K := K) (α := α) I q hq).toAlgebra
+  exact TaylorTarget.finite_shifted (A ⧸ I) α A q hq (reduction_taylor (K := K) (α := α) I q hq)
+
+lemma taylor_unique [Algebra.FormallyEtale (MvPolynomial α K) A]
+    (I : Ideal A) (q : ℕ) (hq : 1 ≤ q)
+    (g : A →+* Target (α := α) I q)
+    (hg : ∀ p : MvPolynomial α K,
+      g (algebraMap (MvPolynomial α K) A p) = shift I q p)
+    (hr : ∀ a, TaylorTarget.reduction (A ⧸ I) α q hq (g a) = Ideal.Quotient.mk I a) :
+    g = taylor (K := K) (α := α) I q hq := by
+  let : Algebra (MvPolynomial α K) (Target (α := α) I q) := (shift I q).toAlgebra
+  let g' : A →ₐ[MvPolynomial α K] Target (α := α) I q := ⟨g,hg⟩
+  let t' : A →ₐ[MvPolynomial α K] Target (α := α) I q :=
+    ⟨taylor (K := K) (α := α) I q hq, taylor_coordinates I q hq⟩
+  have hh : g' = t' := Algebra.FormallyUnramified.ext'
+    (TaylorTarget.reduction (A ⧸ I) α q hq)
+    (by rw [TaylorTarget.reduction_ker]
+        exact ⟨q,TaylorTarget.variables_pow (A ⧸ I) α q⟩) g' t'
+    (fun a ↦ (hr a).trans (reduction_taylor (K := K) (α := α) I q hq a).symm)
+  exact congrArg AlgHom.toRingHom hh
+
+def coefficient (I : Ideal A) (q : ℕ) : A →+* Target (α := α) I q :=
+  (TaylorTarget.mk (A ⧸ I) α q).comp (MvPolynomial.C.comp (Ideal.Quotient.mk I))
+
+lemma reduction_coefficient (I : Ideal A) (q : ℕ) (hq : 1 ≤ q) (a : A) :
+    TaylorTarget.reduction (A ⧸ I) α q hq (coefficient I q a) = Ideal.Quotient.mk I a := by
+  simp [coefficient]
+
+lemma actions_sup_nil [Algebra.FormallySmooth (MvPolynomial α K) A]
+    (I J : Ideal A) (q : ℕ) (hq : 1 ≤ q) :
+    J.map (taylor (K := K) (α := α) I q hq) ⊔ TaylorTarget.nilIdeal (A ⧸ I) α q =
+    J.map (coefficient (α := α) I q) ⊔ TaylorTarget.nilIdeal (A ⧸ I) α q := by
+  let r := TaylorTarget.reduction (A ⧸ I) α q hq
+  have he : r.comp (taylor (K := K) (α := α) I q hq) =
+      r.comp (coefficient (α := α) I q) := by
+    ext a
+    exact (reduction_taylor (K := K) (α := α) I q hq a).trans
+      (reduction_coefficient I q hq a).symm
+  have hi : (J.map (taylor (K := K) (α := α) I q hq)).map r =
+      (J.map (coefficient (α := α) I q)).map r := by
+    rw [Ideal.map_map,Ideal.map_map,he]
+  have hc := congrArg (Ideal.comap r) hi
+  simpa only [Ideal.comap_map_of_surjective r
+    (TaylorTarget.reduction_surjective (A ⧸ I) α q hq),
+    ← RingHom.ker_eq_comap_bot,TaylorTarget.reduction_ker,r] using hc
+
+theorem actions_cofinal [Algebra.FormallySmooth (MvPolynomial α K) A]
+    (I J : Ideal A) (q : ℕ) (hq : 1 ≤ q) (N : ℕ) :
+    (J.map (taylor (K := K) (α := α) I q hq)) ^ (N + q - 1) ≤
+      (J.map (coefficient (α := α) I q)) ^ N ∧
+    (J.map (coefficient (α := α) I q)) ^ (N + q - 1) ≤
+      (J.map (taylor (K := K) (α := α) I q hq)) ^ N :=
+  shifted_ideal_cofinal _ _ (TaylorTarget.nilIdeal (A ⧸ I) α q) q hq
+    (TaylorTarget.variables_pow (A ⧸ I) α q) (actions_sup_nil I J q hq) N
+
+end TaylorShift
+end BoundaryOnly.FormalObstruction.AlgebraicReplacement
+
+namespace BoundaryOnly.FormalObstruction.AlgebraicReplacement
+namespace TaylorShift
+variable {K A α : Type*} [CommRing K] [CommRing A]
+  [Algebra K A] [Algebra (MvPolynomial α K) A]
+  [IsScalarTower K (MvPolynomial α K) A]
+
+noncomputable def completionEquiv [Algebra.FormallySmooth (MvPolynomial α K) A]
+    (I J : Ideal A) (q : ℕ) (hq : 1 ≤ q) :
+    AdicCompletion (J.map (taylor (K := K) (α := α) I q hq)) (Target (α := α) I q) ≃+*
+    AdicCompletion (J.map (coefficient (α := α) I q)) (Target (α := α) I q) :=
+  AdicCofinal.equiv _ _ (q-1) (q-1)
+    (fun N ↦ by simpa [Nat.add_sub_assoc hq] using (actions_cofinal I J q hq N).1)
+    (fun N ↦ by simpa [Nat.add_sub_assoc hq] using (actions_cofinal I J q hq N).2)
+
+@[simp] lemma completionEquiv_of [Algebra.FormallySmooth (MvPolynomial α K) A]
+    (I J : Ideal A) (q : ℕ) (hq : 1 ≤ q) (x : Target (α := α) I q) :
+    completionEquiv (K := K) I J q hq
+      (AdicCompletion.of (J.map (taylor (K := K) (α := α) I q hq)) _ x) =
+    AdicCompletion.of (J.map (coefficient (α := α) I q)) _ x :=
+  AdicCofinal.equiv_of _ _ _ _ _ _ x
+
+end TaylorShift
+end BoundaryOnly.FormalObstruction.AlgebraicReplacement
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/AlgebraicObstruction/TaylorTarget.lean b/lean/OAI/Algebra/AlgebraicObstruction/TaylorTarget.lean
new file mode 100644
index 0000000000000000000000000000000000000000..6bf33adf88022c21e56e058a7bd1f23c0179c121
--- /dev/null
+++ b/lean/OAI/Algebra/AlgebraicObstruction/TaylorTarget.lean
@@ -0,0 +1,118 @@
+import Mathlib
+import OAI.Algebra.FrobeniusObstruction.Obstruction
+import OAI.Algebra.AlgebraicObstruction.Differentiation
+
+namespace OAI
+
+noncomputable section
+open scoped BigOperators
+
+namespace BoundaryOnly.FormalObstruction.AlgebraicReplacement
+
+theorem sup_pow_pred_le {R : Type*} [CommRing R] (I J : Ideal R)
+    (n q : ℕ) (hq : 1 ≤ q) : (I ⊔ J) ^ (n + q - 1) ≤ I ^ n ⊔ J ^ q := by
+  rw [← Ideal.add_eq_sup, ← Ideal.add_eq_sup, add_pow, Ideal.sum_eq_sup]
+  apply Finset.sup_le
+  intro i hi
+  by_cases hn : n ≤ i
+  · exact (Ideal.mul_le_left.trans (Ideal.mul_le_left.trans
+      ((Ideal.pow_le_pow_right hn).trans le_sup_left)))
+  · refine (Ideal.mul_le_left.trans (Ideal.mul_le_right.trans
+      ((Ideal.pow_le_pow_right ?_).trans le_sup_right)))
+    omega
+
+theorem shifted_ideal_cofinal {R : Type*} [CommRing R]
+    (J H S : Ideal R) (q : ℕ) (hq : 1 ≤ q) (hS : S ^ q = ⊥)
+    (hs : J ⊔ S = H ⊔ S) (N : ℕ) :
+    J ^ (N + q - 1) ≤ H ^ N ∧ H ^ (N + q - 1) ≤ J ^ N := by
+  constructor
+  · calc
+      J ^ (N + q - 1) ≤ (J ⊔ S) ^ (N + q - 1) := pow_le_pow_left' le_sup_left _
+      _ = (H ⊔ S) ^ (N + q - 1) := by rw [hs]
+      _ ≤ H ^ N ⊔ S ^ q := sup_pow_pred_le H S N q hq
+      _ = H ^ N := by rw [hS,sup_bot_eq]
+  · calc
+      H ^ (N + q - 1) ≤ (H ⊔ S) ^ (N + q - 1) := pow_le_pow_left' le_sup_left _
+      _ = (J ⊔ S) ^ (N + q - 1) := by rw [hs]
+      _ ≤ J ^ N ⊔ S ^ q := sup_pow_pred_le J S N q hq
+      _ = J ^ N := by rw [hS,sup_bot_eq]
+
+namespace TaylorTarget
+variable (A α : Type*) [CommRing A]
+
+abbrev variablesIdeal : Ideal (MvPolynomial α A) := MvPolynomial.idealOfVars α A
+abbrev Ring (q : ℕ) := MvPolynomial α A ⧸ variablesIdeal A α ^ q
+
+def mk (q : ℕ) : MvPolynomial α A →+* Ring A α q := Ideal.Quotient.mk _
+
+def nilIdeal (q : ℕ) : Ideal (Ring A α q) := (variablesIdeal A α).map (mk A α q)
+
+lemma variables_pow (q : ℕ) : nilIdeal A α q ^ q = ⊥ := by
+  rw [nilIdeal,← Ideal.map_pow]
+  exact Ideal.map_quotient_self _
+
+lemma variables_fg [Finite α] (q : ℕ) : (nilIdeal A α q).FG :=
+  (MvPolynomial.idealOfVars_fg α A).map _
+
+lemma variables_ker : variablesIdeal A α = RingHom.ker MvPolynomial.constantCoeff := by
+  apply le_antisymm
+  · rw [Ideal.span_le]
+    rintro _ ⟨i,rfl⟩
+    simp
+  · intro p hp
+    rw [← pow_one (variablesIdeal A α),MvPolynomial.mem_pow_idealOfVars_iff]
+    intro e he
+    have he0 : e ≠ 0 := by
+      intro h
+      subst e
+      exact (MvPolynomial.mem_support_iff.mp he) hp
+    exact Nat.one_le_iff_ne_zero.mpr (by simpa [Finsupp.degree_eq_zero_iff] using he0)
+
+def reduction (q : ℕ) (hq : 1 ≤ q) : Ring A α q →+* A :=
+  Ideal.Quotient.lift _ MvPolynomial.constantCoeff (by
+    change variablesIdeal A α ^ q ≤ RingHom.ker MvPolynomial.constantCoeff
+    rw [← variables_ker]
+    exact Ideal.pow_le_self (by omega))
+
+@[simp] lemma reduction_mk (q : ℕ) (hq : 1 ≤ q) (p : MvPolynomial α A) :
+    reduction A α q hq (mk A α q p) = MvPolynomial.constantCoeff p := rfl
+
+lemma reduction_surjective (q : ℕ) (hq : 1 ≤ q) :
+    Function.Surjective (reduction A α q hq) := fun a ↦
+  ⟨mk A α q (MvPolynomial.C a),by simp⟩
+
+lemma reduction_ker (q : ℕ) (hq : 1 ≤ q) :
+    RingHom.ker (reduction A α q hq) = nilIdeal A α q := by
+  apply Ideal.comap_injective_of_surjective (mk A α q) (Ideal.Quotient.mk_surjective)
+  rw [RingHom.comap_ker]
+  change RingHom.ker MvPolynomial.constantCoeff = _
+  rw [← variables_ker,nilIdeal]
+  unfold mk
+  rw [Ideal.comap_map_of_surjective _ (Ideal.Quotient.mk_surjective)]
+  change _ = variablesIdeal A α ⊔ _
+  rw [← RingHom.ker_eq_comap_bot,Ideal.mk_ker]
+  exact (sup_eq_left.mpr (Ideal.pow_le_self (by omega))).symm
+
+theorem finite_shifted (R : Type*) [CommRing R] [Algebra R A]
+    [Module.Finite R A] [Finite α] (q : ℕ) (hq : 1 ≤ q)
+    [halg : Algebra R (Ring A α q)]
+    (hred : ∀ r : R, reduction A α q hq (algebraMap R (Ring A α q) r) =
+      algebraMap R A r) :
+    @Module.Finite R (Ring A α q) _ _ halg.toModule := by
+  let f : Ring A α q →ₐ[R] A :=
+    { reduction A α q hq with commutes' := hred }
+  apply Module.finite_of_surjective_of_ker_le_nilradical f
+    (reduction_surjective A α q hq)
+  · change RingHom.ker (reduction A α q hq) ≤ _
+    rw [reduction_ker]
+    exact (variables_fg A α q).isNilpotent_iff_le_nilradical.mp ⟨q,variables_pow A α q⟩
+  · change (RingHom.ker (reduction A α q hq)).FG
+    rw [reduction_ker]
+    exact variables_fg A α q
+
+end TaylorTarget
+end BoundaryOnly.FormalObstruction.AlgebraicReplacement
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/AlgebraicObstruction/WitnessDescent.lean b/lean/OAI/Algebra/AlgebraicObstruction/WitnessDescent.lean
new file mode 100644
index 0000000000000000000000000000000000000000..859e0a47f6c9c6e9f91dbb21162d6f73d1c0c7f3
--- /dev/null
+++ b/lean/OAI/Algebra/AlgebraicObstruction/WitnessDescent.lean
@@ -0,0 +1,226 @@
+import Mathlib
+import OAI.Algebra.FrobeniusObstruction.Obstruction
+import OAI.Algebra.AlgebraicObstruction.QuadraticData
+import OAI.Algebra.AlgebraicObstruction.FiniteCoefficients
+
+namespace OAI
+
+noncomputable section
+open scoped BigOperators
+
+namespace BoundaryOnly.FormalObstruction.FormalCorrection
+open MvPowerSeries
+open scoped Classical
+variable {R σ : Type*} [CommRing R] [Fintype σ]
+
+theorem vanishes_mem_origin_pow {f : MvPowerSeries σ R} {n : ℕ}
+    (hf : Vanishes n f) : f ∈ (originIdeal R σ)^n := by
+  induction n generalizing f with
+  | zero => simp
+  | succ n ih =>
+    let m : σ → σ →₀ ℕ := fun i => Finsupp.single i 1
+    have hzero : ∀ e : σ →₀ ℕ, (¬ ∃ i, m i ≤ e) → coeff e f = 0 := by
+      intro e he
+      have hz : e = 0 := by
+        ext i
+        by_contra hi
+        apply he
+        refine ⟨i,Finsupp.single_le_iff.mpr ?_⟩
+        change 1 ≤ e i
+        have : e i ≠ 0 := by simpa using hi
+        omega
+      subst e
+      apply hf
+      simp
+    rw [monomial_factorization m f hzero,pow_succ']
+    apply Ideal.sum_mem
+    intro i _
+    apply Ideal.mul_mem_mul
+    · exact Ideal.subset_span ⟨i,rfl⟩
+    · apply ih
+      apply monomialFactor_vanishes m f hf
+      intro j
+      simp [m]
+
+theorem origin_pow_iff_vanishes {f : MvPowerSeries σ R} {n : ℕ} :
+    f ∈ (originIdeal R σ)^n ↔ Vanishes n f :=
+  ⟨origin_pow_vanishes,vanishes_mem_origin_pow⟩
+
+end BoundaryOnly.FormalObstruction.FormalCorrection
+
+namespace BoundaryOnly.FormalObstruction.CoefficientRing
+open MvPowerSeries FormalCorrection Matrix
+open scoped Classical
+variable {K : Type*} [CommRing K] {d : ℕ} {n : Fin d → ℕ}
+
+structure QuadraticWitnesses (Q : QuadraticData (R := K) (n := n)) where
+  b : InternalVar n → InternalVar n → MvPowerSeries (GraphVar n) K
+  pos : (Fin d × Fin d × Fin d) → InternalVar n → MvPowerSeries (GraphVar n) K
+  neg : (Fin d × Fin d × Fin d) → InternalVar n → MvPowerSeries (GraphVar n) K
+  graph : subst (graphCoordinates n Q.Y) (potential n Q.P) =
+    ∑ c, ∑ e, b c e * restrictedGradient n Q.P Q.Y c * restrictedGradient n Q.P Q.Y e
+  positive : ∀ t, slope n t.1 * slope n t.2.1 * slope n t.2.2 =
+    ∑ c, pos t c * restrictedGradient n Q.P Q.Y c
+  negative : ∀ t, negativeSlopeValue n Q.P Q.Y t.1 * negativeSlopeValue n Q.P Q.Y t.2.1 *
+    negativeSlopeValue n Q.P Q.Y t.2.2 = ∑ c, neg t c * restrictedGradient n Q.P Q.Y c
+
+theorem QuadraticWitnesses.exists (Q : QuadraticData (R := K) (n := n)) :
+    Nonempty (QuadraticWitnesses Q) := by
+  obtain ⟨b,hb⟩ := quadratic_witness (restrictedGradient n Q.P Q.Y) _ Q.graph_square
+  have hp : ∀ t : Fin d × Fin d × Fin d, ∃ c : InternalVar n → MvPowerSeries (GraphVar n) K,
+      ∑ e, c e * restrictedGradient n Q.P Q.Y e = slope n t.1 * slope n t.2.1 * slope n t.2.2 :=
+    fun t => Ideal.mem_span_range_iff_exists_fun.mp (Q.positive_cubic t.1 t.2.1 t.2.2)
+  have hn : ∀ t : Fin d × Fin d × Fin d, ∃ c : InternalVar n → MvPowerSeries (GraphVar n) K,
+      ∑ e, c e * restrictedGradient n Q.P Q.Y e =
+        negativeSlopeValue n Q.P Q.Y t.1 * negativeSlopeValue n Q.P Q.Y t.2.1 *
+          negativeSlopeValue n Q.P Q.Y t.2.2 :=
+    fun t => Ideal.mem_span_range_iff_exists_fun.mp (Q.negative_cubic t.1 t.2.1 t.2.2)
+  choose p hp using hp
+  choose r hr using hn
+  refine ⟨⟨b,p,r,?_,fun t => (hp t).symm,fun t => (hr t).symm⟩⟩
+  rw [hb]
+  simp only [dotProduct,mulVec,Finset.mul_sum]
+  apply Finset.sum_congr rfl
+  intro c _
+  apply Finset.sum_congr rfl
+  intro e _
+  ring
+
+theorem subtype_series_map_injective (R : Subalgebra ℤ K) {σ : Type*} :
+    Function.Injective (MvPowerSeries.map R.val.toRingHom : MvPowerSeries σ R → MvPowerSeries σ K) := by
+  intro f g h
+  ext e
+  exact congrArg (coeff e) h
+
+theorem QuadraticWitnesses.descend (Q : QuadraticData (R := K) (n := n)) (W : QuadraticWitnesses Q)
+    (R : Subalgebra ℤ K)
+    (hP : ∀ i, coefficientsIn R (Q.P i)) (hY : ∀ c, coefficientsIn R (Q.Y c))
+    (hb : ∀ c e, coefficientsIn R (W.b c e))
+    (hp : ∀ t c, coefficientsIn R (W.pos t c))
+    (hn : ∀ t c, coefficientsIn R (W.neg t c))
+    (inv : K) (hi : inv ∈ R) (hunit : (complementaryMatrix n Q.Y).det * inv = 1) :
+    Nonempty (QuadraticData (R := R) (n := n)) := by
+  let PR := fun i => restrictCoefficients R (Q.P i) (hP i)
+  let YR := fun c => restrictCoefficients R (Q.Y c) (hY c)
+  let bR := fun c e => restrictCoefficients R (W.b c e) (hb c e)
+  let pR := fun t c => restrictCoefficients R (W.pos t c) (hp t c)
+  let nR := fun t c => restrictCoefficients R (W.neg t c) (hn t c)
+  have hPR : (fun i => map R.val.toRingHom (PR i)) = Q.P :=
+    funext fun i => map_restrictCoefficients R _ _
+  have hYR : (fun c => map R.val.toRingHom (YR c)) = Q.Y :=
+    funext fun c => map_restrictCoefficients R _ _
+  have hcenter : ∀ c, YR c ∈ originIdeal R (GraphVar n) := by
+    intro c
+    apply mem_origin_iff.mpr
+    exact restrictCoefficients_centered R _ _ (mem_origin_iff.mp (Q.centered c))
+  have hgrad : ∀ c, map R.val.toRingHom (restrictedGradient n PR YR c) =
+      restrictedGradient n Q.P Q.Y c := by
+    intro c
+    rw [map_restrictedGradient n _ PR YR hcenter,hPR,hYR]
+  have hnegative : ∀ i, map R.val.toRingHom (negativeSlopeValue n PR YR i) =
+      negativeSlopeValue n Q.P Q.Y i := by
+    intro i
+    rw [map_negativeSlopeValue n _ PR YR hcenter,hPR,hYR]
+  have hgraph : subst (graphCoordinates n YR) (potential n PR) =
+      ∑ c, ∑ e, bR c e * restrictedGradient n PR YR c * restrictedGradient n PR YR e := by
+    apply subtype_series_map_injective R
+    rw [map_subst (graph_hasSubst n YR hcenter),map_graph,map_potential,hPR,hYR]
+    simp only [map_sum,map_mul,bR,map_restrictCoefficients,hgrad,W.graph]
+  refine ⟨{ P := PR
+            Y := YR
+            order_three := ?_
+            centered := hcenter
+            complementary := ?_
+            graph_square := ?_
+            positive_cubic := ?_
+            negative_cubic := ?_ }⟩
+  · intro i
+    apply vanishes_mem_origin_pow
+    exact restrictCoefficients_vanishes R _ _ (origin_pow_vanishes (Q.order_three i))
+  · apply isUnit_iff_exists_inv.mpr
+    refine ⟨⟨inv,hi⟩,?_⟩
+    apply Subtype.ext
+    change R.val.toRingHom (complementaryMatrix n YR).det * inv = 1
+    rw [RingHom.map_det]
+    change ((complementaryMatrix n YR).map R.val.toRingHom).det * inv = 1
+    rw [map_complementary,hYR]
+    exact hunit
+  · rw [hgraph,pow_two]
+    apply Ideal.sum_mem
+    intro c _
+    apply Ideal.sum_mem
+    intro e _
+    apply Ideal.mul_mem_mul
+    · exact Ideal.mul_mem_left _ _ (Ideal.subset_span ⟨c,rfl⟩)
+    · exact Ideal.subset_span ⟨e,rfl⟩
+  · intro i j l
+    apply Ideal.mem_span_range_iff_exists_fun.mpr
+    refine ⟨pR (i,j,l),?_⟩
+    apply subtype_series_map_injective R
+    simpa only [map_sum,map_mul,pR,map_restrictCoefficients,hgrad,slope,map_X] using
+      (W.positive (i,j,l)).symm
+  · intro i j l
+    apply Ideal.mem_span_range_iff_exists_fun.mpr
+    refine ⟨nR (i,j,l),?_⟩
+    apply subtype_series_map_injective R
+    simpa only [map_sum,map_mul,nR,map_restrictCoefficients,hgrad,hnegative] using
+      (W.negative (i,j,l)).symm
+
+end BoundaryOnly.FormalObstruction.CoefficientRing
+
+namespace BoundaryOnly.FormalObstruction.CoefficientRing
+open MvPowerSeries FormalCorrection
+open scoped Classical
+variable {K : Type*} [CommRing K] {d : ℕ} {n : Fin d → ℕ}
+
+inductive QuadraticEntry (n : Fin d → ℕ)
+  | wall : Fin d → QuadraticEntry n
+  | graph : InternalVar n → QuadraticEntry n
+  | quadratic : InternalVar n → InternalVar n → QuadraticEntry n
+  | positive : (Fin d × Fin d × Fin d) → InternalVar n → QuadraticEntry n
+  | negative : (Fin d × Fin d × Fin d) → InternalVar n → QuadraticEntry n
+  deriving Fintype
+
+def QuadraticEntry.variables : QuadraticEntry n → Type
+  | .wall i => WallVar n i
+  | _ => GraphVar n
+
+instance (e : QuadraticEntry n) : Fintype e.variables := by
+  cases e <;> dsimp [QuadraticEntry.variables] <;> infer_instance
+
+def QuadraticWitnesses.entry (Q : QuadraticData (R := K) (n := n)) (W : QuadraticWitnesses Q) :
+    (e : QuadraticEntry n) → MvPowerSeries e.variables K
+  | .wall i => Q.P i
+  | .graph c => Q.Y c
+  | .quadratic c e => W.b c e
+  | .positive t c => W.pos t c
+  | .negative t c => W.neg t c
+
+theorem QuadraticWitnesses.finite_ring (Q : QuadraticData (R := K) (n := n))
+    (W : QuadraticWitnesses Q)
+    (h : ∀ e, NonsingularPresentation (W.entry Q e)) :
+    ∃ R : Subalgebra ℤ K, Algebra.FiniteType ℤ R ∧
+      Nonempty (QuadraticData (R := R) (n := n)) := by
+  obtain ⟨inv,hi⟩ := isUnit_iff_exists_inv.mp Q.complementary
+  obtain ⟨R,hR,hc,he⟩ := finite_ring_presentations (W.entry Q) h {inv}
+  refine ⟨R,hR,W.descend Q R (fun i => he (.wall i)) (fun c => he (.graph c))
+    (fun c e => he (.quadratic c e)) (fun t c => he (.positive t c))
+    (fun t c => he (.negative t c)) inv (hc inv (Finset.mem_singleton_self inv)) hi⟩
+
+end BoundaryOnly.FormalObstruction.CoefficientRing
+
+namespace BoundaryOnly.FormalObstruction.CoefficientRing
+open FormalCorrection
+
+theorem no_presented_quadratic_data {K : Type*} [CommRing K] [IsDomain K] [CharZero K]
+    {d : ℕ} (hd : 5 ≤ d) {n : Fin d → ℕ}
+    (Q : QuadraticData (R := K) (n := n)) (W : QuadraticWitnesses Q)
+    (h : ∀ e, NonsingularPresentation (W.entry Q e)) : False := by
+  obtain ⟨R,hR,hQ⟩ := W.finite_ring Q h
+  let : Algebra.FiniteType ℤ R := hR
+  exact no_integral_quadratic_data R d hd n hQ
+end BoundaryOnly.FormalObstruction.CoefficientRing
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/AuslanderReiten/Algebras/BaseAlgebra.lean b/lean/OAI/Algebra/AuslanderReiten/Algebras/BaseAlgebra.lean
new file mode 100644
index 0000000000000000000000000000000000000000..fbbb3643d6ee0af816bab2a9d9c8933454efc137
--- /dev/null
+++ b/lean/OAI/Algebra/AuslanderReiten/Algebras/BaseAlgebra.lean
@@ -0,0 +1,262 @@
+import Mathlib.Algebra.Algebra.Defs
+import Mathlib.Algebra.Group.TransferInstance
+import Mathlib.Algebra.Module.TransferInstance
+import Mathlib.LinearAlgebra.FiniteDimensional.Defs
+import Mathlib.LinearAlgebra.Dimension.Constructions
+import Mathlib.LinearAlgebra.FreeModule.StrongRankCondition
+import Mathlib.Tactic.Ring
+
+namespace OAI
+
+namespace ArExplicit
+
+inductive Letter
+  | e | x | y | z | u | v | t | j | f | n
+  deriving DecidableEq
+
+instance : Fintype Letter where
+  elems := {.e, .x, .y, .z, .u, .v, .t, .j, .f, .n}
+  complete i := by cases i <;> simp
+
+@[simp] theorem Letter.card : Fintype.card Letter = 10 := by decide
+
+@[ext]
+structure BaseAlgebra (k : Type*) (q : k) where
+  coeff : Letter → k
+
+namespace BaseAlgebra
+
+variable {k : Type*} (q : k)
+
+def coordinates : BaseAlgebra k q ≃ (Letter → k) where
+  toFun := coeff
+  invFun := mk
+  left_inv _ := rfl
+  right_inv _ := rfl
+
+instance [AddCommGroup k] : AddCommGroup (BaseAlgebra k q) :=
+  (coordinates q).addCommGroup
+
+variable [CommRing k]
+
+def coordinateAddEquiv : BaseAlgebra k q ≃+ (Letter → k) where
+  __ := coordinates q
+  map_add' _ _ := rfl
+
+instance : Module k (BaseAlgebra k q) := (coordinateAddEquiv q).module k
+
+@[simp] theorem coeff_zero (i : Letter) : (0 : BaseAlgebra k q).coeff i = 0 := rfl
+@[simp] theorem coeff_add (a b : BaseAlgebra k q) (i : Letter) :
+    (a + b).coeff i = a.coeff i + b.coeff i := rfl
+@[simp] theorem coeff_neg (a : BaseAlgebra k q) (i : Letter) :
+    (-a).coeff i = -a.coeff i := rfl
+@[simp] theorem coeff_smul (r : k) (a : BaseAlgebra k q) (i : Letter) :
+    (r • a).coeff i = r * a.coeff i := rfl
+
+open Letter
+
+def product (a b : BaseAlgebra k q) : BaseAlgebra k q := ⟨fun
+  | e => a.coeff e * b.coeff e
+  | x => a.coeff e * b.coeff x + a.coeff x * b.coeff e + q * a.coeff u * b.coeff t
+  | y => a.coeff e * b.coeff y + a.coeff y * b.coeff e + a.coeff u * b.coeff t
+  | z => a.coeff e * b.coeff z + a.coeff z * b.coeff e + q * a.coeff x * b.coeff y +
+      a.coeff y * b.coeff x + q * a.coeff v * b.coeff t + a.coeff u * b.coeff j
+  | u => a.coeff e * b.coeff u + a.coeff u * b.coeff f
+  | v => a.coeff e * b.coeff v + a.coeff v * b.coeff f + a.coeff x * b.coeff u +
+      a.coeff y * b.coeff u + a.coeff u * b.coeff n
+  | t => a.coeff f * b.coeff t + a.coeff t * b.coeff e
+  | j => a.coeff f * b.coeff j + a.coeff j * b.coeff e + a.coeff t * b.coeff x +
+      q ^ 2 * a.coeff t * b.coeff y + q * a.coeff n * b.coeff t
+  | f => a.coeff f * b.coeff f
+  | n => a.coeff f * b.coeff n + a.coeff n * b.coeff f +
+      (1 + q) * a.coeff t * b.coeff u⟩
+
+instance : Mul (BaseAlgebra k q) := ⟨product q⟩
+instance : One (BaseAlgebra k q) := ⟨⟨fun i => if i = e ∨ i = f then 1 else 0⟩⟩
+
+@[simp] theorem coeff_mul (a b : BaseAlgebra k q) :
+    (a * b).coeff = (product q a b).coeff := rfl
+@[simp] theorem coeff_one (i : Letter) :
+    (1 : BaseAlgebra k q).coeff i = if i = e ∨ i = f then 1 else 0 := rfl
+
+private theorem product_assoc (a b c : BaseAlgebra k q) : (a * b) * c = a * (b * c) := by
+  ext i
+  cases i <;> simp only [coeff_mul, product] <;> ring
+
+instance : Ring (BaseAlgebra k q) where
+  __ := (inferInstance : AddCommGroup (BaseAlgebra k q))
+  mul_assoc := product_assoc q
+  one_mul a := by ext i; cases i <;> simp [product]
+  mul_one a := by ext i; cases i <;> simp [product]
+  left_distrib a b c := by
+    ext i
+    cases i <;> simp only [coeff_mul, product, coeff_add] <;> ring
+  right_distrib a b c := by
+    ext i
+    cases i <;> simp only [coeff_mul, product, coeff_add] <;> ring
+  zero_mul a := by ext i; cases i <;> simp [product]
+  mul_zero a := by ext i; cases i <;> simp [product]
+
+instance : Algebra k (BaseAlgebra k q) :=
+  Algebra.ofModule
+    (by intro r a b; ext i; cases i <;> simp only [coeff_smul, coeff_mul, product] <;> ring)
+    (by intro r a b; ext i; cases i <;> simp only [coeff_smul, coeff_mul, product] <;> ring)
+
+def basisVector (i : Letter) : BaseAlgebra k q := ⟨Pi.single i 1⟩
+
+@[simp] theorem coeff_basisVector (i l : Letter) :
+    (basisVector q i).coeff l = if l = i then 1 else 0 := by
+  simp [basisVector, Pi.single_apply, eq_comm]
+
+theorem one_eq_vertices : (1 : BaseAlgebra k q) = basisVector q e + basisVector q f := by
+  ext i
+  cases i <;> simp
+
+def multiplicationTable (left right : Letter) : BaseAlgebra k q :=
+  let b := basisVector q
+  match left, right with
+  | e, e => b e
+  | e, x => b x
+  | e, y => b y
+  | e, z => b z
+  | e, u => b u
+  | e, v => b v
+  | x, e => b x
+  | x, y => q • b z
+  | x, u => b v
+  | y, e => b y
+  | y, x => b z
+  | y, u => b v
+  | z, e => b z
+  | u, f => b u
+  | u, t => b y + q • b x
+  | u, j => b z
+  | u, n => b v
+  | v, f => b v
+  | v, t => q • b z
+  | t, e => b t
+  | t, x => b j
+  | t, y => q ^ 2 • b j
+  | t, u => (1 + q) • b n
+  | j, e => b j
+  | f, t => b t
+  | f, j => b j
+  | f, f => b f
+  | f, n => b n
+  | n, f => b n
+  | n, t => q • b j
+  | _, _ => 0
+
+private theorem basis_e_mul (right : Letter) :
+    basisVector q e * basisVector q right = multiplicationTable q e right := by
+  cases right <;> ext coordinate <;> cases coordinate <;>
+    simp [product, multiplicationTable]
+
+private theorem basis_x_mul (right : Letter) :
+    basisVector q x * basisVector q right = multiplicationTable q x right := by
+  cases right <;> ext coordinate <;> cases coordinate <;>
+    simp [product, multiplicationTable]
+
+private theorem basis_y_mul (right : Letter) :
+    basisVector q y * basisVector q right = multiplicationTable q y right := by
+  cases right <;> ext coordinate <;> cases coordinate <;>
+    simp [product, multiplicationTable]
+
+private theorem basis_z_mul (right : Letter) :
+    basisVector q z * basisVector q right = multiplicationTable q z right := by
+  cases right <;> ext coordinate <;> cases coordinate <;>
+    simp [product, multiplicationTable]
+
+private theorem basis_u_mul (right : Letter) :
+    basisVector q u * basisVector q right = multiplicationTable q u right := by
+  cases right <;> ext coordinate <;> cases coordinate <;>
+    simp [product, multiplicationTable]
+
+private theorem basis_v_mul (right : Letter) :
+    basisVector q v * basisVector q right = multiplicationTable q v right := by
+  cases right <;> ext coordinate <;> cases coordinate <;>
+    simp [product, multiplicationTable]
+
+private theorem basis_t_mul (right : Letter) :
+    basisVector q t * basisVector q right = multiplicationTable q t right := by
+  cases right <;> ext coordinate <;> cases coordinate <;>
+    simp [product, multiplicationTable]
+
+private theorem basis_j_mul (right : Letter) :
+    basisVector q j * basisVector q right = multiplicationTable q j right := by
+  cases right <;> ext coordinate <;> cases coordinate <;>
+    simp [product, multiplicationTable]
+
+private theorem basis_f_mul (right : Letter) :
+    basisVector q f * basisVector q right = multiplicationTable q f right := by
+  cases right <;> ext coordinate <;> cases coordinate <;>
+    simp [product, multiplicationTable]
+
+private theorem basis_n_mul (right : Letter) :
+    basisVector q n * basisVector q right = multiplicationTable q n right := by
+  cases right <;> ext coordinate <;> cases coordinate <;>
+    simp [product, multiplicationTable]
+
+theorem basis_mul (left right : Letter) :
+    basisVector q left * basisVector q right = multiplicationTable q left right := by
+  cases left
+  · exact basis_e_mul q right
+  · exact basis_x_mul q right
+  · exact basis_y_mul q right
+  · exact basis_z_mul q right
+  · exact basis_u_mul q right
+  · exact basis_v_mul q right
+  · exact basis_t_mul q right
+  · exact basis_j_mul q right
+  · exact basis_f_mul q right
+  · exact basis_n_mul q right
+
+theorem fourfold_product :
+    ((basisVector q u * basisVector q t) * basisVector q u) * basisVector q t =
+      (q * (1 + q)) • basisVector q z := by
+  ext coordinate
+  cases coordinate <;> simp [product]
+  ring
+
+def mapScalars {K : Type*} [CommRing K] (f : k →+* K) :
+    BaseAlgebra k q →+* BaseAlgebra K (f q) where
+  toFun a := ⟨fun i => f (a.coeff i)⟩
+  map_one' := by ext i; cases i <;> simp
+  map_mul' a b := by
+    ext i
+    cases i <;> simp [product, map_add, map_mul, map_pow]
+  map_zero' := by ext i; simp
+  map_add' a b := by ext i; simp
+
+@[simp] theorem coeff_mapScalars {K : Type*} [CommRing K] (f : k →+* K)
+    (a : BaseAlgebra k q) (i : Letter) :
+    (mapScalars q f a).coeff i = f (a.coeff i) := rfl
+
+theorem mapScalars_injective {K : Type*} [CommRing K] (f : k →+* K)
+    (hf : Function.Injective f) : Function.Injective (mapScalars q f) := by
+  intro a b h
+  ext i
+  apply hf
+  exact congrArg (fun c : BaseAlgebra K (f q) => c.coeff i) h
+
+def coordinateLinearEquiv : BaseAlgebra k q ≃ₗ[k] (Letter → k) :=
+  (coordinateAddEquiv q).linearEquiv k
+
+instance : Module.Finite k (BaseAlgebra k q) :=
+  Module.Finite.equiv (coordinateLinearEquiv q).symm
+
+theorem finrank_eq_ten [Nontrivial k] : Module.finrank k (BaseAlgebra k q) = 10 := by
+  rw [(coordinateLinearEquiv q).finrank_eq]
+  simp only [Module.finrank_fintype_fun_eq_card, Letter.card]
+
+theorem fourfold_product_ne_zero [IsDomain k] (hq : q ≠ 0) (hq1 : 1 + q ≠ 0) :
+    ((basisVector q u * basisVector q t) * basisVector q u) * basisVector q t ≠ 0 := by
+  rw [fourfold_product]
+  intro h
+  have hz := congrArg (fun a : BaseAlgebra k q => a.coeff z) h
+  simpa using (mul_ne_zero hq hq1) (by simpa using hz)
+
+end BaseAlgebra
+end ArExplicit
+
+end OAI
diff --git a/lean/OAI/Algebra/AuslanderReiten/Algebras/BaseRadical.lean b/lean/OAI/Algebra/AuslanderReiten/Algebras/BaseRadical.lean
new file mode 100644
index 0000000000000000000000000000000000000000..0f37cda7970cd77b054b0bb9eb7d34593c0aef3e
--- /dev/null
+++ b/lean/OAI/Algebra/AuslanderReiten/Algebras/BaseRadical.lean
@@ -0,0 +1,119 @@
+import OAI.Algebra.AuslanderReiten.Algebras.BaseAlgebra
+import OAI.Algebra.AuslanderReiten.Algebras.Radical
+import Mathlib.RingTheory.Ideal.Quotient.Operations
+
+namespace OAI
+
+namespace ArExplicit.BaseAlgebra
+
+open ArExplicit.Letter
+
+variable {k : Type*} [Field k] (q : k)
+
+def eCharacter : BaseAlgebra k q →+* k where
+  toFun a := a.coeff e
+  map_one' := by simp
+  map_mul' _ _ := rfl
+  map_zero' := rfl
+  map_add' _ _ := rfl
+
+def fCharacter : BaseAlgebra k q →+* k where
+  toFun a := a.coeff f
+  map_one' := by simp
+  map_mul' _ _ := rfl
+  map_zero' := rfl
+  map_add' _ _ := rfl
+
+theorem eCharacter_surjective : Function.Surjective (eCharacter q) := by
+  intro a
+  refine ⟨a • basisVector q e, ?_⟩
+  change (a • basisVector q e).coeff e = a
+  simp
+
+theorem fCharacter_surjective : Function.Surjective (fCharacter q) := by
+  intro a
+  refine ⟨a • basisVector q f, ?_⟩
+  change (a • basisVector q f).coeff f = a
+  simp
+
+def diagonal : BaseAlgebra k q →+* k × k := (eCharacter q).prod (fCharacter q)
+
+theorem fifth_power_eq_zero (a : BaseAlgebra k q) (he : a.coeff e = 0)
+    (hf : a.coeff f = 0) : a ^ 5 = 0 := by
+  ext i
+  cases i <;> simp [pow_succ, product, he, hf]
+
+private theorem field_jacobson : Ring.jacobson k = ⊥ := by
+  let : (⊥ : Ideal k).IsMaximal := Ideal.bot_isMaximal
+  exact le_antisymm (Ring.jacobson_le_of_isMaximal ⊥) bot_le
+
+theorem mem_jacobson_iff (a : BaseAlgebra k q) :
+    a ∈ Ring.jacobson (BaseAlgebra k q) ↔ a.coeff e = 0 ∧ a.coeff f = 0 := by
+  constructor
+  · intro ha
+    have : RingHomSurjective (eCharacter q) := ⟨eCharacter_surjective q⟩
+    have : RingHomSurjective (fCharacter q) := ⟨fCharacter_surjective q⟩
+    have he := Ring.le_comap_jacobson (eCharacter q) ha
+    have hf := Ring.le_comap_jacobson (fCharacter q) ha
+    rw [field_jacobson] at he hf
+    exact ⟨he, hf⟩
+  · rintro ⟨he, hf⟩
+    have hn : RingHom.ker (diagonal q) ≤ Ring.jacobson (BaseAlgebra k q) := by
+      apply ArExplicit.nilIdeal_le_jacobson
+      intro b hb
+      change (b.coeff e, b.coeff f) = (0, 0) at hb
+      exact ⟨5, fifth_power_eq_zero q b (congrArg Prod.fst hb) (congrArg Prod.snd hb)⟩
+    apply hn
+    change (a.coeff e, a.coeff f) = (0, 0)
+    exact Prod.ext he hf
+
+def diagonalAlg : BaseAlgebra k q →ₐ[k] k × k where
+  __ := diagonal q
+  commutes' c := by
+    apply Prod.ext
+    · change (algebraMap k (BaseAlgebra k q) c).coeff e = c
+      rw [Algebra.algebraMap_eq_smul_one]
+      simp
+    · change (algebraMap k (BaseAlgebra k q) c).coeff f = c
+      rw [Algebra.algebraMap_eq_smul_one]
+      simp
+
+theorem diagonalAlg_surjective : Function.Surjective (diagonalAlg q) := by
+  rintro ⟨a, b⟩
+  refine ⟨a • basisVector q e + b • basisVector q f, ?_⟩
+  apply Prod.ext
+  · change (a • basisVector q e + b • basisVector q f).coeff e = a
+    simp
+  · change (a • basisVector q e + b • basisVector q f).coeff f = b
+    simp
+
+theorem radical_eq_ker_diagonal :
+    Ring.jacobson (BaseAlgebra k q) = RingHom.ker (diagonalAlg q) := by
+  ext a
+  rw [mem_jacobson_iff]
+  change (a.coeff e = 0 ∧ a.coeff f = 0) ↔ (a.coeff e, a.coeff f) = (0, 0)
+  simp only [Prod.mk.injEq]
+
+noncomputable def semisimpleQuotientEquiv :
+    (BaseAlgebra k q ⧸ Ring.jacobson (BaseAlgebra k q)) ≃ₐ[k] k × k :=
+  (Ideal.quotientEquivAlgOfEq k (radical_eq_ker_diagonal q)).trans
+    (Ideal.quotientKerAlgEquivOfSurjective (diagonalAlg_surjective q))
+
+theorem jacobson_fourth_ne_bot (hq : q ≠ 0) (hq1 : 1 + q ≠ 0) :
+    (Ring.jacobson (BaseAlgebra k q)) ^ 4 ≠ ⊥ := by
+  let J := Ring.jacobson (BaseAlgebra k q)
+  have hu : basisVector q u ∈ J := (mem_jacobson_iff q _).mpr (by simp)
+  have ht : basisVector q t ∈ J := (mem_jacobson_iff q _).mpr (by simp)
+  have hprod : ((basisVector q u * basisVector q t) * basisVector q u) *
+      basisVector q t ∈ J ^ 4 := by
+    have h2 := Ideal.mul_mem_mul hu ht
+    have h3 := Ideal.mul_mem_mul h2 hu
+    have h4 := Ideal.mul_mem_mul h3 ht
+    simpa only [Submodule.pow_succ, Submodule.pow_zero, Submodule.one_mul] using h4
+  intro h
+  rw [h] at hprod
+  exact fourfold_product_ne_zero q hq hq1 hprod
+
+end ArExplicit.BaseAlgebra
+
+end OAI
diff --git a/lean/OAI/Algebra/AuslanderReiten/Algebras/FrobeniusOpposite.lean b/lean/OAI/Algebra/AuslanderReiten/Algebras/FrobeniusOpposite.lean
new file mode 100644
index 0000000000000000000000000000000000000000..4369c894602932770fe4213f2228e6378e60ee91
--- /dev/null
+++ b/lean/OAI/Algebra/AuslanderReiten/Algebras/FrobeniusOpposite.lean
@@ -0,0 +1,58 @@
+import OAI.Algebra.AuslanderReiten.Algebras.TensorFrobenius
+
+namespace OAI
+
+noncomputable section
+
+namespace ArExplicit.FrobeniusTrace
+
+variable {k R : Type*} [Field k] [Ring R] [Algebra k R]
+variable (τ : FrobeniusTrace k R)
+variable (hsym : ∀ a b, τ.trace (a * b) = τ.trace (b * a))
+
+def opposite : FrobeniusTrace k Rᵐᵒᵖ where
+  trace :=
+    { toFun := fun a => τ.trace a.unop
+      map_add' a b := τ.trace.map_add a.unop b.unop
+      map_smul' a b := τ.trace.map_smul a b.unop }
+  separates a ha := by
+    apply MulOpposite.unop_injective
+    change a.unop = 0
+    apply τ.separates
+    intro b
+    rw [hsym]
+    exact ha (MulOpposite.op b)
+
+@[simp] theorem opposite_trace (a : Rᵐᵒᵖ) : (opposite τ hsym).trace a = τ.trace a.unop := rfl
+
+theorem opposite_symmetric (a b : Rᵐᵒᵖ) :
+    (opposite τ hsym).trace (a * b) = (opposite τ hsym).trace (b * a) :=
+  hsym b.unop a.unop
+
+end ArExplicit.FrobeniusTrace
+
+namespace ArExplicit
+
+variable (k : Type*) [Field k] (q : k)
+
+def AOppositeFrobeniusTrace : FrobeniusTrace k (A k q)ᵐᵒᵖ :=
+  (AFrobeniusTrace k q).opposite (A_trace_symmetric k q)
+
+instance : Module.Injective (A k q)ᵐᵒᵖ (A k q)ᵐᵒᵖ :=
+  (AOppositeFrobeniusTrace k q).regular_injective
+
+open scoped TensorProduct
+
+def AEnvelopingFrobeniusTrace : FrobeniusTrace k (A k q ⊗[k] (A k q)ᵐᵒᵖ) :=
+  (AFrobeniusTrace k q).tensor (AOppositeFrobeniusTrace k q)
+
+theorem AEnveloping_trace_symmetric (a b : A k q ⊗[k] (A k q)ᵐᵒᵖ) :
+    (AEnvelopingFrobeniusTrace k q).trace (a * b) = (AEnvelopingFrobeniusTrace k q).trace (b * a) :=
+  FrobeniusTrace.tensorTrace_mul_comm _ _ (A_trace_symmetric k q)
+    ((AFrobeniusTrace k q).opposite_symmetric (A_trace_symmetric k q)) a b
+
+end ArExplicit
+
+end
+
+end OAI
diff --git a/lean/docs/003.md b/lean/docs/003.md
new file mode 100644
index 0000000000000000000000000000000000000000..cf794e93da2e1a494434153f5b91f2990fe9fd60
--- /dev/null
+++ b/lean/docs/003.md
@@ -0,0 +1,25 @@
+# The quasi-Riemann hypothesis
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [The Quasi-Riemann Hypothesis: A Zero-Free Half-Plane $\Re(s)>7/8$](../../preprints/The-Quasi-Riemann-Hypothesis-September-30-2026/paper.pdf)
+- [Uniform exclusion of Landau–Siegel zeros](../../preprints/Uniform-exclusion-of-Landau-Siegel-zeros-October-1-2026/paper.pdf)
+
+## Scope
+
+The quasi-Riemann hypothesis asks for a fixed zero-free half-plane $\Re s>\theta$ with $\theta<1$. The formalization gives $\theta=7/8$ for the Riemann zeta function and every Dirichlet $L$-function, uniformly over all positive moduli and all characters. It also establishes the same bound for finite-order Hecke $L$-functions over $\mathbb Q(\sqrt{-3})$.
+
+The principal-character poles at $s=1$ are excluded in the Dirichlet and Hecke statements. The paper's later applications are not included.
+
+The formalized result gives a uniform logarithmic exclusion region for Landau–Siegel zeros. There is one constant $c>0$ such that every primitive nonprincipal real Dirichlet character of conductor $q\ge3$ and every real zero $0<\beta<1$ of its $L$-function satisfy $1-\beta\ge c/\log q$.
+
+Both character parities are included. No explicit value of $c$ is given. This excludes real zeros in $1-c/\log q<\beta<1$, but does not rule out real zeros elsewhere in $(0,1)$.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Riemann zeta $7/8$ bound | [QuasiRiemannHypothesis.lean](../ComparatorChallenges/QuasiRiemannHypothesis.lean) |
+| Dirichlet $L$-function $7/8$ bound | [DirichletSevenEighths.lean](../ComparatorChallenges/DirichletSevenEighths.lean) |
+| Finite-order Hecke $L$-function $7/8$ bound | [HeckeSevenEighths.lean](../ComparatorChallenges/HeckeSevenEighths.lean) |
+| Uniform real-zero gap | [SiegelZeros.lean](../ComparatorChallenges/SiegelZeros.lean) |
diff --git a/lean/docs/005.md b/lean/docs/005.md
new file mode 100644
index 0000000000000000000000000000000000000000..b8d3af65448c39017827ba4e7441b44a45f355a1
--- /dev/null
+++ b/lean/docs/005.md
@@ -0,0 +1,15 @@
+# Irrationality of Catalan’s constant
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [Catalan's constant is irrational](../../preprints/Catalans-constant-is-irrational-September-24-2026/paper.pdf)
+
+## Scope
+
+The formalization proves that Catalan's constant $G=\sum_{j=0}^{\infty}(-1)^j/(2j+1)^2$ is irrational. This is the mathematical assertion in the paper's title.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Irrationality of Catalan's constant | [Catalan.lean](../ComparatorChallenges/Catalan.lean) |
diff --git a/lean/docs/007.md b/lean/docs/007.md
new file mode 100644
index 0000000000000000000000000000000000000000..dad638d19609ebbddc93a5594dfc2ecd2a26a7a6
--- /dev/null
+++ b/lean/docs/007.md
@@ -0,0 +1,18 @@
+# Ordinary two-point correlations and the corrected Elliott conjecture
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [Ordinary two-point correlations of multiplicative functions](../../preprints/Ordinary-two-point-correlations-of-multiplicative-functions-September-24-2026/final.pdf)
+
+## Scope
+
+The formalization proves ordinary two-point cancellation for multiplicative functions. For the Liouville function on every fixed pair of nonproportional affine forms, the correlation sum up to $X$ is $O(X/(\log X)^c)$ for an absolute $c>0$, with the implied constant depending on the forms.
+
+For two one-bounded multiplicative functions, if at least one is uniformly nonpretentious against all Dirichlet-character twists with frequency $|t|\le N$, then their shifted and nonproportional affine correlation sums divided by $N$ tend to zero. These are ordinary averages, with no logarithmic averaging.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Ordinary Elliott cancellation under uniform nonpretentiousness | [OrdinaryElliott.lean](../ComparatorChallenges/OrdinaryElliott.lean) |
+| Ordinary Liouville and multiplicative two-point correlations | [OrdinaryTwoPointCorrelations.lean](../ComparatorChallenges/OrdinaryTwoPointCorrelations.lean) |
diff --git a/lean/docs/008.md b/lean/docs/008.md
new file mode 100644
index 0000000000000000000000000000000000000000..f227db94ecd5f03a621ea359e3733946e7dab3d1
--- /dev/null
+++ b/lean/docs/008.md
@@ -0,0 +1,17 @@
+# The Deligne–Drinfeld conjecture
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [The Deligne-Drinfeld conjecture](../../preprints/The-Deligne-Drinfeld-conjecture-September-23-2026/paper.pdf)
+
+## Scope
+
+The Deligne–Drinfeld conjecture predicts that the rational Grothendieck–Teichmüller Lie algebra is freely generated by one element in each odd weight $3,5,7,\ldots$. The formalization establishes this for the rational solution space of antisymmetry, the three-term equation, and the four-strand pentagon with the Ihara bracket. It also gives the corresponding continuous isomorphism after completion by weight.
+
+The regularized-transport proposition and graph-complex consequences are not included.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Deligne–Drinfeld main statement | [DeligneDrinfeld.lean](../ComparatorChallenges/DeligneDrinfeld.lean) |
diff --git a/lean/docs/009.md b/lean/docs/009.md
new file mode 100644
index 0000000000000000000000000000000000000000..f5cb872d28dab31ab4cdccea8956676ffd2e37c1
--- /dev/null
+++ b/lean/docs/009.md
@@ -0,0 +1,17 @@
+# Function-field reconstruction from Milnor K-theory and Galois data
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [The Bogomolov-Pop reconstruction theorem](../../preprints/The-Bogomolov-Pop-reconstruction-theorem-September-23-2026/paper.pdf)
+
+## Scope
+
+The Bogomolov–Pop reconstruction conjecture concerns recovering a function field and its constants from pro-$\ell$ abelian-by-central Galois data. The linked formalization proves injectivity of the reconstruction correspondence for function fields of transcendence degree at least two over algebraically closed fields of characteristic different from the prime $\ell$.
+
+If two isomorphisms of perfect closures preserving the constant fields induce the same Galois-data isomorphism modulo $\ell$-adic unit scaling, then they agree modulo Frobenius. The selected statement proves this uniqueness; existence of a field isomorphism for every admissible Galois-data isomorphism is outside it.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Injectivity of Bogomolov–Pop reconstruction modulo the stated ambiguities | [BogomolovPopInjectivity.lean](../ComparatorChallenges/BogomolovPopInjectivity.lean) |
diff --git a/lean/docs/012.md b/lean/docs/012.md
new file mode 100644
index 0000000000000000000000000000000000000000..a92487d8cc5e8fa243fc0af64b8be34a06d165f0
--- /dev/null
+++ b/lean/docs/012.md
@@ -0,0 +1,17 @@
+# Independent largest prime factors of consecutive integers
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [The joint Dickman law for consecutive integers](../../preprints/The-joint-Dickman-law-for-consecutive-integers-September-24-2026/paper.pdf)
+
+## Scope
+
+Let $P^+(n)$ be the largest prime factor of $n$. The formalization proves the joint Dickman law in ordinary natural density: for every $0<a,b<1$, the density of integers satisfying $P^+(n)\le n^a$ and $P^+(n+1)\le n^b$ tends to $\rho(1/a)\rho(1/b)$, where $\rho$ is the Dickman function.
+
+It also proves that each of the orderings $P^+(n)<P^+(n+1)$ and $P^+(n+1)<P^+(n)$ has natural density $1/2$.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Joint Dickman law and equal ordering densities for consecutive integers | [JointDickman.lean](../ComparatorChallenges/JointDickman.lean) |
diff --git a/lean/docs/013.md b/lean/docs/013.md
new file mode 100644
index 0000000000000000000000000000000000000000..8eeb95c35a98a41433342ee053a9cf5154581e70
--- /dev/null
+++ b/lean/docs/013.md
@@ -0,0 +1,16 @@
+# Ostmann’s inverse Goldbach conjecture
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [The additive indecomposability of the primes](../../preprints/the-additive-indecomposability-of-the-primes-September-24-2026/paper.pdf)
+
+## Scope
+
+The formalization proves Ostmann's inverse Goldbach conjecture. For any two sets $A,B$ of nonnegative integers, each containing at least two elements, the symmetric difference between their sumset $A+B$ and the set of primes is infinite. Thus no set differing from the primes by only finitely many elements can be decomposed as such a sumset. The linked statements include the full result and its two-infinite-summands case.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Ostmann's inverse Goldbach theorem and the infinite-summands case | [OstmannComplete.lean](../ComparatorChallenges/OstmannComplete.lean) |
+| Additive indecomposability of the primes up to finite changes | [OstmannPrimes.lean](../ComparatorChallenges/OstmannPrimes.lean) |
diff --git a/lean/docs/015.md b/lean/docs/015.md
new file mode 100644
index 0000000000000000000000000000000000000000..41cb082d16a4e16fada3cca0229ef8b0fa2d467f
--- /dev/null
+++ b/lean/docs/015.md
@@ -0,0 +1,15 @@
+# Torus-packet equidistribution in prime, quartic, and sextic degrees
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [Equidistribution of Prime-Degree Torus Packets with Arbitrary Local Type](../../preprints/Equidistribution-of-Prime-Degree-Torus-Packets-with-Arbitrary-Local-Type-September-24-2026/paper.pdf)
+
+## Scope
+
+The formalization proves equidistribution of volume-weighted torus packets for totally real number fields of every fixed prime degree at least five. For any sequence of full lattices whose multiplier-order discriminants tend to infinity, the packet measures converge weakly to Haar probability measure and form a tight family, so no mass escapes. Arbitrary local homothety types are allowed, and the fields may vary along the sequence.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Equidistribution of prime-degree torus packets | [DukePrimeDegree.lean](../ComparatorChallenges/DukePrimeDegree.lean) |
diff --git a/lean/docs/017.md b/lean/docs/017.md
new file mode 100644
index 0000000000000000000000000000000000000000..08ebac405fcc7fd8c8e7cda9bfe8e83d2bbfba0f
--- /dev/null
+++ b/lean/docs/017.md
@@ -0,0 +1,17 @@
+# The irrationality exponent of <i>π</i> is 2
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [The irrationality exponent of $\pi$ is 2](../../preprints/The-irrationality-exponent-of-pi-is-2-September-24-2026/paper.pdf)
+
+## Scope
+
+The formalization proves that the irrationality exponent of $\pi$ is exactly two. For every $\nu>2$, all sufficiently large positive denominators $q$ satisfy $|\pi-p/q|\ge q^{-\nu}$ for every integer numerator $p$. It also states the exact supremum characterization using infinitely many rational approximations.
+
+The paper's convergence consequence for the Flint–Hills series is outside this selected statement.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| The irrationality exponent of $\pi$ equals two | [PiExponent.lean](../ComparatorChallenges/PiExponent.lean) |
diff --git a/lean/docs/020.md b/lean/docs/020.md
new file mode 100644
index 0000000000000000000000000000000000000000..a7375a7bfb57399b2ae594429ab921269f1f2405
--- /dev/null
+++ b/lean/docs/020.md
@@ -0,0 +1,15 @@
+# Squarefree quartics and power-free polynomial values
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [Squarefree values of quartics and power-free values of polynomials](../../preprints/Squarefree-values-of-quartics-and-power-free-values-of-polynomials-September-24-2026/manuscript.pdf)
+
+## Scope
+
+The formalized result proves positive-density power-free values for every integer polynomial $f$ irreducible over $\mathbb Q$ of degree $d\ge4$. Put $k=d-2$ and assume no prime $k$th power divides every value of $f$. Then the number of positive integers $n\le X$ for which $f(n)$ is $k$-free is $c_fX+o_f(X)$, where $c_f>0$ is the convergent product of local factors. Negative values are allowed and zero is excluded. No monicity, primitivity, or coefficient-height restriction is imposed.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Positive density of power-free polynomial values | [PowerFreeValues.lean](../ComparatorChallenges/PowerFreeValues.lean) |
diff --git a/lean/docs/021.md b/lean/docs/021.md
new file mode 100644
index 0000000000000000000000000000000000000000..7d6cd6364d752006f3b7605780f892d9282c231a
--- /dev/null
+++ b/lean/docs/021.md
@@ -0,0 +1,16 @@
+# A quadratic bound for Jacobsthal’s function
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [A quadratic bound for Jacobsthal's function](../../preprints/A-quadratic-bound-for-Jacobsthals-function-September-25-2026/paper.pdf)
+
+## Scope
+
+Let $h(k)$ be the least interval length that guarantees an integer coprime to any prescribed positive modulus with at most $k$ distinct prime factors. The formalization proves the paper's strengthened Jacobsthal bound $h(k)\le Ck^2/(\log\log(3k))^2$ for one absolute $C>0$ and every $k\ge1$. Intervals may begin at any signed integer. The earlier quadratic bound is also retained as a separate statement; the optimal order of growth is not determined.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Quadratic Jacobsthal bound | [Jacobsthal.lean](../ComparatorChallenges/Jacobsthal.lean) |
+| Jacobsthal bound with an iterated-logarithm saving | [JacobsthalImproved.lean](../ComparatorChallenges/JacobsthalImproved.lean) |
diff --git a/lean/docs/023.md b/lean/docs/023.md
new file mode 100644
index 0000000000000000000000000000000000000000..4a1fc7738b4915758da296feb987d9638018aa5b
--- /dev/null
+++ b/lean/docs/023.md
@@ -0,0 +1,15 @@
+# Patterson's first moment for cubic Gauss sums
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [An unconditional first moment for cubic Gauss sums](../../preprints/An-unconditional-first-moment-for-cubic-Gauss-sums-September-25-2026/paper.pdf)
+
+## Scope
+
+Patterson's first-moment conjecture concerns the average of normalized cubic Gauss sums over primary Eisenstein primes. The formalization proves the sharp-cutoff asymptotic with main term $\frac65c_*X^{5/6}/\log X$, where $c_*=(2\pi)^{2/3}/(3\Gamma(2/3))$. It also proves the corresponding angular comparison for every integer Fourier mode and cancellation of order $o(X^{5/6}/\log X)$ for each fixed nonzero mode. All primary Eisenstein primes are included, without an extra conjectural premise.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Patterson first moment and angular cancellation | [PattersonFirstMoment.lean](../ComparatorChallenges/PattersonFirstMoment.lean) |
diff --git a/lean/docs/024.md b/lean/docs/024.md
new file mode 100644
index 0000000000000000000000000000000000000000..e313b808b590070606dfe934ccae8f1797a52f88
--- /dev/null
+++ b/lean/docs/024.md
@@ -0,0 +1,18 @@
+# An asymptotic formula for the number of totients
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [An asymptotic formula for the number of totients](../../preprints/An-asymptotic-formula-for-the-number-of-totients-September-25-2026/An-asymptotic-formula-for-the-number-of-totients-September-25-2026.pdf)
+
+## Scope
+
+Let $V(x)$ count the distinct values of Euler's totient function up to $x$. The formalization constructs the paper's explicit positive main term from finite arithmetic approximants and proves that their ratio tends to one. In particular, $V(cx)/V(x)\to c$ for every fixed $c>0$, answering the Erdős–Hall regular-variation question.
+
+The formalization also gives asymptotics for totients $v\le x$ whose least preimage $\ell(v)=\min\{n\ge1:\varphi(n)=v\}$ lies between $kx$ and $(k+1)x$. The associated coefficient is positive under the stated existence condition; when no totient $d$ satisfies $kd<\ell(d)$, the count and coefficient are identically zero. The cases $k=1,2$ have positive coefficients.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Totient-count asymptotics and regular variation | [TotientAsymptotic.lean](../ComparatorChallenges/TotientAsymptotic.lean) |
+| Exact zero case for the companion totient counts | [TotientCompanionZero.lean](../ComparatorChallenges/TotientCompanionZero.lean) |
diff --git a/lean/docs/025.md b/lean/docs/025.md
new file mode 100644
index 0000000000000000000000000000000000000000..dd8d775e3fdb48649809770086e4ff22c9b751ff
--- /dev/null
+++ b/lean/docs/025.md
@@ -0,0 +1,18 @@
+# Short Egyptian fractions
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [Short Egyptian fractions](../../preprints/Short-Egyptian-fractions-September-25-2026/Short-Egyptian-fractions-September-25-2026.pdf)
+
+## Scope
+
+An Egyptian-fraction expansion writes a rational number as a sum of distinct unit fractions. The formalization proves that every $a/b$ with $1\le a<b$ has such an expansion and that the largest minimum length at denominator $b$ is $\Theta(\log\log b)$. If $F(k)$ counts exact $k$-term expansions of $1$, it also proves $\log\log F(k)=\Theta(k)$ and bounds every denominator in such an expansion.
+
+Every integer $m\ge2$ occurs as a denominator in an expansion of $1$, with length eventually at most $(257/\log2+\varepsilon)\log\log m$ for every $\varepsilon>0$; padding can preserve that denominator. If $v(k)$ is the least integer at least $2$ absent from all exact $k$-term expansions of $1$, then eventually $e^{e^{k/600}}\le v(k)\le1+k^{2^{k-1}}$, and $\liminf_{k\to\infty}\log\log v(k)/k\ge\log2/257$.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Short expansions, counting, and prescribed denominators | [EgyptianFractions.lean](../ComparatorChallenges/EgyptianFractions.lean) |
+| Optimal order of the shortest Egyptian-fraction expansions | [ShortEgyptianFractions.lean](../ComparatorChallenges/ShortEgyptianFractions.lean) |
diff --git a/lean/docs/026.md b/lean/docs/026.md
new file mode 100644
index 0000000000000000000000000000000000000000..f1d0ec6813807ab053eb34d610f1a370d7c033e8
--- /dev/null
+++ b/lean/docs/026.md
@@ -0,0 +1,15 @@
+# Positive lower density of large prime gaps
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [Positive lower density of large prime gaps](../../preprints/Positive-lower-density-of-large-prime-gaps-September-25-2026/main.pdf)
+
+## Scope
+
+The formalized supplement proves that the indices $n$ for which $p_n/n<p_{n+1}/(n+1)$ have positive lower asymptotic density, where $p_n$ is the $n$th prime. Thus the normalized prime sequence has a positive-density set of increases. This is the prime-ratio corollary associated with the paper's theorem on a positive lower density of large prime gaps.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Positive lower density of prime-ratio increases | [PrimeGaps.lean](../ComparatorChallenges/PrimeGaps.lean) |
diff --git a/lean/docs/028.md b/lean/docs/028.md
new file mode 100644
index 0000000000000000000000000000000000000000..d127bda379395e1136f7fe276272b75ea210009c
--- /dev/null
+++ b/lean/docs/028.md
@@ -0,0 +1,15 @@
+# Uniformly bounded components of Gaussian-prime graphs
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [Bounded-Step Walks on Gaussian Primes](../../preprints/Bounded-Step-Walks-on-Gaussian-Primes-September-26-2026/paper.pdf)
+
+## Scope
+
+The Gaussian moat problem asks whether an infinite walk through distinct Gaussian primes can have bounded step lengths. The formalized result gives a negative answer for every real step bound $D$. More strongly, one finite bound depending only on $D$ limits the size of every connected component of the bounded-step graph and the length of every injective bounded-step walk. Axis primes and all associates are included. No explicit function of $D$ is supplied.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Uniform bounds for bounded-step Gaussian-prime walks | [GaussianMoat.lean](../ComparatorChallenges/GaussianMoat.lean) |
diff --git a/lean/docs/033.md b/lean/docs/033.md
new file mode 100644
index 0000000000000000000000000000000000000000..f3524758d7b3ab1688df48551dc2bce8d817d5d0
--- /dev/null
+++ b/lean/docs/033.md
@@ -0,0 +1,17 @@
+# Iitaka subadditivity, variation, and logarithmic additivity
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [The reverse logarithmic Kodaira inequality and additivity](../../preprints/The-reverse-logarithmic-Kodaira-inequality-and-additivity-September-26-2026/paper.pdf)
+
+## Scope
+
+The paper studies logarithmic Kodaira additivity for connected-fiber morphisms of smooth projective reduced simple-normal-crossing pairs that are smooth on all boundary strata away from the base boundary. The linked formalization proves the negative-fiber branch: for a very general base point, if the logarithmic Kodaira dimension of the fiber is $-\infty$, then the total logarithmic Kodaira dimension equals the sum of the base and fiber dimensions and is $-\infty$. Every positive-degree logarithmic pluriform section on the total space then vanishes.
+
+The finite-dimension and negative-base branches of the paper's additivity theorem are outside this selected statement.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Logarithmic Kodaira additivity in the negative-fiber branch | [LogKodairaFiberNegative.lean](../ComparatorChallenges/LogKodairaFiberNegative.lean) |
diff --git a/lean/docs/039.md b/lean/docs/039.md
new file mode 100644
index 0000000000000000000000000000000000000000..a0287fe5262399b08105a47be6ece7aec89f0212
--- /dev/null
+++ b/lean/docs/039.md
@@ -0,0 +1,23 @@
+# Nagata’s conjecture and maximal Seshadri constants
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [Nagata's conjecture for plane curves](../../preprints/Nagatas-Conjecture-for-Plane-Curves-September-23-2026/main.pdf)
+- [Maximal Seshadri constants on arbitrary polarized surfaces](../../preprints/Maximal-Seshadri-Constants-on-Arbitrary-Polarized-Surfaces-September-23-2026/main.pdf)
+
+## Scope
+
+Nagata's conjecture asserts that a nonzero effective plane curve of degree $d$, with multiplicities at least $m_i$ at $r\ge10$ very general points, satisfies $\sum_i m_i<d\sqrt r$.
+
+The formalization establishes this inequality simultaneously for all curves and multiplicity vectors outside one countable union of proper Zariski-closed exceptional sets with nonempty complement. Reducible curves, repeated components, and unequal multiplicities are included, in both effective-curve and homogeneous-polynomial formulations. The formalization also includes the passage from homogeneous effective cycles to equations.
+
+The maximality question asks whether the multipoint Seshadri constant reaches the upper bound $\sqrt{L^2/r}$ at very general points once $r$ is sufficiently large. The formalized result establishes this for every smooth integral complex projective surface $S$ and ample line bundle $L$.
+
+For every $r$ above a threshold depending on $(S,L)$, it gives a countable union of proper closed exceptional sets with nonempty complement. Outside it, the constant is $\sqrt{L^2/r}$ and the boundary class defining this Seshadri constant on the point blowup is nef. The threshold is not explicit or uniform over all surfaces.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Nagata's conjecture | [Nagata.lean](../ComparatorChallenges/Nagata.lean) |
+| Eventual maximal Seshadri constants | [MaximalSeshadriConstants.lean](../ComparatorChallenges/MaximalSeshadriConstants.lean) |
diff --git a/lean/docs/047.md b/lean/docs/047.md
new file mode 100644
index 0000000000000000000000000000000000000000..24ea9a2140a18a7611605ae5b5f046fbb63c49c9
--- /dev/null
+++ b/lean/docs/047.md
@@ -0,0 +1,17 @@
+# Zariski cancellation and affine fibrations over the complex numbers
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [An explicit failure of complex affine-space cancellation](../../preprints/An-explicit-failure-of-complex-affine-space-cancellation-September-23-2026/paper.pdf)
+
+## Scope
+
+Affine-space cancellation asks whether $X\times\mathbb A^1\cong\mathbb A^{n+1}$ forces $X\cong\mathbb A^n$. The formalized result gives an explicit finite-type complex domain $A$ of Krull dimension four with $A[w]\cong\mathbb C[x_1,\ldots,x_5]$ but $A\not\cong\mathbb C[x_1,\ldots,x_4]$. Thus adjoining one variable erases a genuine algebraic distinction.
+
+The separate stable-coordinate and general line-bundle lifting consequences are not included.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Complex affine-space cancellation counterexample | [ComplexCancellation.lean](../ComparatorChallenges/ComplexCancellation.lean) |
diff --git a/lean/docs/049.md b/lean/docs/049.md
new file mode 100644
index 0000000000000000000000000000000000000000..678b0faa7847d2b05d2e43f826dfb7853c496deb
--- /dev/null
+++ b/lean/docs/049.md
@@ -0,0 +1,18 @@
+# A stable-coordinate counterexample in four variables
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [An explicit noncoordinate polynomial with affine three-space zero fibre](../../preprints/An-explicit-noncoordinate-polynomial-with-affine-three-space-zero-fibre-September-24-2026/paper.pdf)
+
+## Scope
+
+The Abhyankar–Sathaye conjecture predicts that a polynomial defining an affine-space quotient must be an ambient coordinate. For every $n\ge4$, the formalized counterexample gives $F\in\mathbb C[x_1,\ldots,x_n]$ with quotient $\mathbb C[x_1,\ldots,x_n]/(F)\cong\mathbb C[y_1,\ldots,y_{n-1}]$, although $F$ is not a coordinate.
+
+A companion gives $n-1$ commuting, locally nilpotent derivations, linearly independent over the polynomial ring, whose common kernel is generated by the construction's explicit polynomial and contains no ambient coordinate. The extra $n-4$ derivations are ordinary partial derivatives in the added variables. The three-variable case is not covered.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Noncoordinate polynomial in every dimension at least four | [AbhyankarSathaye.lean](../ComparatorChallenges/AbhyankarSathaye.lean) |
+| Commuting locally nilpotent derivations | [CommutingDerivations.lean](../ComparatorChallenges/CommutingDerivations.lean) |
diff --git a/lean/docs/050.md b/lean/docs/050.md
new file mode 100644
index 0000000000000000000000000000000000000000..63672c73023df96c9b9b40b968b390e7e6c00723
--- /dev/null
+++ b/lean/docs/050.md
@@ -0,0 +1,17 @@
+# A counterexample to Griffiths’ positivity conjecture
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [Ample rank-two bundles on the quadric surface without Griffiths-positive metrics](../../preprints/ample-rank-two-bundles-on-the-quadric-surface-without-griffiths-positive-metrics-September-24-2026/paper.pdf)
+
+## Scope
+
+Griffiths' positivity conjecture predicts that every ample holomorphic vector bundle on a smooth complex projective variety admits a smooth Hermitian metric with strictly Griffiths-positive curvature. The formalized counterexample starts with a rank-two algebraic bundle $G$ on $\mathbb P^1\times\mathbb P^1$. Its coordinatewise power pullbacks, tensored with $\mathcal O(1,1)$, are ample for every positive power but admit no such metric for all sufficiently large powers.
+
+The separate very-ampleness result for all admissible even exponents is not included.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Ample bundles without Griffiths-positive metrics | [QuadricBundles.lean](../ComparatorChallenges/QuadricBundles.lean) |
diff --git a/lean/docs/052.md b/lean/docs/052.md
new file mode 100644
index 0000000000000000000000000000000000000000..510edec7a3f990c7f8ab25bd214c19f4f1030a0f
--- /dev/null
+++ b/lean/docs/052.md
@@ -0,0 +1,21 @@
+# Tangent splittings and product decompositions
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [Universal-cover splitting for compact Kähler manifolds](../../preprints/Universal-cover-splitting-for-compact-Kahler-manifolds-September-23-2026/paper.pdf)
+- [Integrability of split tangent bundles on rationally connected manifolds](../../preprints/Integrability-of-split-tangent-bundles-on-rationally-connected-manifolds-September-23-2026/main.pdf)
+
+## Scope
+
+The splitting question asks whether a holomorphic decomposition of the tangent bundle comes from a product decomposition of the universal cover. The formalized result gives an affirmative answer for a compact connected Kähler manifold whose tangent bundle splits into two positive-rank, integrable holomorphic subbundles. The universal cover is a product of connected simply connected complex manifolds of the prescribed dimensions, and the differential identifies the two tangent factors with the original summands.
+
+Both integrability assumptions are required. Automatic integrability and the paper's additional corollaries are not included.
+
+The formalization proves integrability of both summands in a holomorphic splitting of the tangent bundle of a rationally connected projective manifold. More precisely, for a compact connected complex manifold of dimension at least two with a projective embedding witnessing rational connectedness, each positive-rank summand of a holomorphic tangent-bundle splitting is integrable. The paper's compatible product decomposition is a separate consequence, outside this selected statement.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Universal-cover product splitting | [KahlerSplitting.lean](../ComparatorChallenges/KahlerSplitting.lean) |
+| Integrability of both holomorphic tangent summands | [SplitTangentIntegrability.lean](../ComparatorChallenges/SplitTangentIntegrability.lean) |
diff --git a/lean/docs/058.md b/lean/docs/058.md
new file mode 100644
index 0000000000000000000000000000000000000000..a831050aa960a134206921105e911c5614d4e2f1
--- /dev/null
+++ b/lean/docs/058.md
@@ -0,0 +1,17 @@
+# Semialgebraic universal covers and bounded domains
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [Symmetry of semialgebraic bounded domains with compact quotient](../../preprints/Symmetry-of-semialgebraic-bounded-domains-with-compact-quotient-September-24-2026/paper.pdf)
+
+## Scope
+
+The formalized result answers the paper's symmetry question affirmatively. A nonempty connected bounded semialgebraic subset, relatively open in a complex affine algebraic set, is smooth and biholomorphic to a bounded symmetric domain whenever a discrete group acts properly and holomorphically with compact quotient.
+
+The action need not be free, and the ambient algebraic set may be singular.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Symmetry of semialgebraic bounded domains | [SymmetricDomains.lean](../ComparatorChallenges/SymmetricDomains.lean) |
diff --git a/lean/docs/071.md b/lean/docs/071.md
new file mode 100644
index 0000000000000000000000000000000000000000..8b70ae0527122dc10c3ce867a90e5ddea7f712e0
--- /dev/null
+++ b/lean/docs/071.md
@@ -0,0 +1,21 @@
+# Koebe’s circle-domain conjecture
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [Removable Boundaries and Rigidity of Circle Domains](../../preprints/Removable-Boundaries-and-Rigidity-of-Circle-Domains-September-23-2026/paper.pdf)
+- [Koebe's Circle-Domain Conjecture](../../preprints/Koebes-Circle-Domain-Conjecture-September-23-2026/paper.pdf)
+
+## Scope
+
+The formalization proves the removability-to-rigidity direction of the He–Schramm conjecture. If a circle domain has conformally removable boundary, then every conformal equivalence from it to another circle domain agrees on the source with a Möbius transformation. There is no bound on the number of complementary components.
+
+The same Comparator file also states Koebe's circle-domain theorem, which gives a circle-domain representative for every domain in the Riemann sphere.
+
+Koebe's circle-domain conjecture asks whether every domain in the Riemann sphere is conformally equivalent to a circle domain, whose complementary components are round disks or points. The formalization proves this for every domain. It also proves rigidity under a separate hypothesis: a conformal equivalence between circle domains is a Möbius transformation when the source boundary is conformally removable.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Removable-boundary rigidity and the circle-domain theorem | [KoebeCircleDomains.lean](../ComparatorChallenges/KoebeCircleDomains.lean) |
+| Koebe's circle-domain theorem and removable-boundary rigidity | [KoebeCircleDomains.lean](../ComparatorChallenges/KoebeCircleDomains.lean) |
diff --git a/lean/docs/072.md b/lean/docs/072.md
new file mode 100644
index 0000000000000000000000000000000000000000..ea7cfbd667959c481df6e64d6d7120f1fd36eec8
--- /dev/null
+++ b/lean/docs/072.md
@@ -0,0 +1,24 @@
+# Brennan's conjecture and the integral-means spectrum
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [Brennan's conjecture and sharp inverse-square integral means](../../preprints/Brennans-conjecture-and-sharp-inverse-square-integral-means-September-24-2026/paper.pdf)
+- [A strict inverse-first-power bound for univalent functions](../../preprints/A-strict-inverse-first-power-bound-for-univalent-functions-September-24-2026/paper.pdf)
+
+## Scope
+
+Brennan's conjecture asserts that $|\phi'|^s$ is area-integrable for $4/3<s<4$ when $\phi$ conformally maps a simply connected plane domain with nontrivial spherical boundary onto the disk. The formalization establishes this interval, along with area integrability of $|f'|^t$ for univalent disk maps when $-2<t<2/3$.
+
+It also gives the uniform inverse-square radial-mean bound with exponent $-1-\varepsilon$ for every $\varepsilon>0$ and the spectrum value $B_{\mathcal S}(-2)=1$. The Koebe map and its inverse give divergence at all four boundary exponents.
+
+Kraetzer's proposed integral-means spectrum predicts $B_b(-1)=1/4$ for bounded univalent maps. The formalized result proves $B_b(-1)<1/4$, contradicting that prediction.
+
+The underlying estimate gives constants $0<\varepsilon<1/4$ and $C<\infty$ such that the normalized circular mean of $|f'|^{-1}$ is at most $C(1-r)^{-1/4+\varepsilon}$ for every normalized univalent disk map and $1/2\le r<1$. The bound requires neither bounded image nor boundary regularity, and no numerical value of $\varepsilon$ is specified.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Brennan and inverse-square integral-means bounds | [Brennan.lean](../ComparatorChallenges/Brennan.lean) |
+| Sharp endpoint divergence | [BrennanSharp.lean](../ComparatorChallenges/BrennanSharp.lean) |
+| Strict inverse-first-power bound and consequences | [StrictMeans.lean](../ComparatorChallenges/StrictMeans.lean) |
diff --git a/lean/docs/073.md b/lean/docs/073.md
new file mode 100644
index 0000000000000000000000000000000000000000..a359f023f2ab698358d8c0061b0405bdef41bc84
--- /dev/null
+++ b/lean/docs/073.md
@@ -0,0 +1,16 @@
+# The Falconer distance conjecture
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [The Falconer distance conjecture in all dimensions](../../preprints/The-Falconer-distance-conjecture-in-all-dimensions-September-23-2026/paper.pdf)
+
+## Scope
+
+The formalization proves the Falconer distance conjecture in every dimension. For every integer $d\ge2$ and compact set $E\subset\mathbb R^d$ with Hausdorff dimension greater than $d/2$, the set $\{\lVert x-y\rVert:x,y\in E\}$ has positive Lebesgue measure. The linked statements include both this all-dimensional result and the earlier planar case.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Planar Falconer distance theorem | [PlanarFalconer.lean](../ComparatorChallenges/PlanarFalconer.lean) |
+| Falconer distance theorem in every dimension | [FalconerAllDimensions.lean](../ComparatorChallenges/FalconerAllDimensions.lean) |
diff --git a/lean/docs/076.md b/lean/docs/076.md
new file mode 100644
index 0000000000000000000000000000000000000000..dcd69b52ed11c3e254e47d2f8f784a76b42344fd
--- /dev/null
+++ b/lean/docs/076.md
@@ -0,0 +1,18 @@
+# Real ultraflat Littlewood polynomials and unbounded binary merit factors
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [Asymptotically minimal maxima of real Littlewood polynomials](../../preprints/Asymptotically-minimal-maxima-of-real-Littlewood-polynomials-September-23-2026/paper.pdf)
+
+## Scope
+
+The formalization gives real Littlewood polynomials of every sufficiently large length whose maximum modulus on the unit circle is at most $(1+\eta)\sqrt N$ for any fixed $\eta>0$. Thus the smallest possible maximum is asymptotically minimal through all integer lengths.
+
+A further statement chooses one family of real sign polynomials for all lengths such that, for every fixed finite $p>0$, the $L^p$ mean of $\bigl||P_N(z)|/\sqrt N-1\bigr|$ on the unit circle tends to zero. The results are existential and do not give an effective convergence rate or a signing algorithm.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Asymptotically minimal Littlewood maximum | [AsymptoticallyMinimalLittlewood.lean](../ComparatorChallenges/AsymptoticallyMinimalLittlewood.lean) |
+| Finite-exponent flatness of one all-length Littlewood family | [LittlewoodFiniteFlatness.lean](../ComparatorChallenges/LittlewoodFiniteFlatness.lean) |
diff --git a/lean/docs/081.md b/lean/docs/081.md
new file mode 100644
index 0000000000000000000000000000000000000000..4e0a23593b42d69c2ce0000ea8f772947ebd277e
--- /dev/null
+++ b/lean/docs/081.md
@@ -0,0 +1,15 @@
+# Riesz transforms and rectifiability in higher codimension
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [Riesz transforms and uniform rectifiability in higher codimension](../../preprints/Riesz-transforms-and-uniform-rectifiability-in-higher-codimension-September-24-2026/paper.pdf)
+
+## Scope
+
+The formalized result proves that bounded Riesz transforms force quantitative uniform rectifiability in higher codimension. For $d\ge4$ and $2\le n\le d-2$, an $n$-Ahlfors–David regular measure whose positive hard truncations have one uniform $L^2$ operator bound has big pieces of Lipschitz images. The mass fraction and Lipschitz constant depend only on the dimensions and the stated regularity and operator bounds, and work at every support point and admissible radius, including unbounded support. The variation and principal-value corollary is not included.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Quantitative higher-codimension Riesz rectifiability | [RieszQuantitative.lean](../ComparatorChallenges/RieszQuantitative.lean) |
diff --git a/lean/docs/082.md b/lean/docs/082.md
new file mode 100644
index 0000000000000000000000000000000000000000..da0c4bca87e82b2e2e1fdb80cb01618d54dcfffe
--- /dev/null
+++ b/lean/docs/082.md
@@ -0,0 +1,15 @@
+# Annular variation and dyadic absolute bounds for the triangular Hilbert transform
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [The maximal triangular Hilbert transform at the symmetric point](../../preprints/The-maximal-triangular-Hilbert-transform-at-the-symmetric-point-September-24-2026/paper.pdf)
+
+## Scope
+
+The formalized result proves the symmetric maximal estimate for the triangular Hilbert transform: for arbitrary complex $F,G\in L^3(\mathbb R^2)$, the $L^{3/2}$ norm of the supremum over all finite hard-truncation intervals is at most $C\|F\|_3\|G\|_3$ for one absolute constant $C$. It also establishes a common full-measure set on which the truncated integrals are defined and almost-everywhere measurability of the maximal output.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Maximal triangular Hilbert transform bound | [TriangularHilbert.lean](../ComparatorChallenges/TriangularHilbert.lean) |
diff --git a/lean/docs/083.md b/lean/docs/083.md
new file mode 100644
index 0000000000000000000000000000000000000000..5641260100e527b9c7ee9b97d7c1040d7c157011
--- /dev/null
+++ b/lean/docs/083.md
@@ -0,0 +1,17 @@
+# Hilbert transforms along Lipschitz directions
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [A uniform Hilbert transform estimate for Lipschitz directions](../../preprints/A-uniform-Hilbert-transform-estimate-for-Lipschitz-directions-September-25-2026/main.pdf)
+
+## Scope
+
+The formalization proves uniform $L^2$ bounds for short Hilbert transforms along Lipschitz unit vector fields in the plane, including fields depending on both coordinates. For Lipschitz constant $K>0$, every hard truncation with $0<\varepsilon\le R\le1/(10^6K)$ has one universal $L^2$ bound on Schwartz functions, independent of the inner cutoff.
+
+At a fixed short scale for $1$-Lipschitz fields, the formalization also gives principal-value and weak-$(2,2)$ estimates and bounded extensions to all of $L^2$. These results establish the stated short-scale form of Stein's question.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Uniform short Hilbert-transform bounds for Lipschitz directions | [LipschitzHilbert.lean](../ComparatorChallenges/LipschitzHilbert.lean) |
diff --git a/lean/docs/084.md b/lean/docs/084.md
new file mode 100644
index 0000000000000000000000000000000000000000..007836d73009740dd7dc474c451e40014a2f5b7b
--- /dev/null
+++ b/lean/docs/084.md
@@ -0,0 +1,15 @@
+# The geometric case of the Erdős similarity conjecture
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [The dyadic case of the Erdős similarity conjecture](../../preprints/The-dyadic-case-of-the-Erdos-similarity-conjecture-September-25-2026/paper.pdf)
+
+## Scope
+
+The formalization proves the dyadic case of the Erdős similarity conjecture. For every $0<\eta<1$, it constructs a compact set $E\subset[0,1]$ of measure greater than $1-\eta$ that contains no affine copy of $\{2^{-n}:n\ge1\}$. Explicitly, for every translation $x$ and every nonzero real dilation $s$, some point $x+s2^{-n}$ lies outside $E$. Both signs of $s$ are included.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Positive-measure avoidance of every affine dyadic sequence | [DyadicAvoidance.lean](../ComparatorChallenges/DyadicAvoidance.lean) |
diff --git a/lean/docs/085.md b/lean/docs/085.md
new file mode 100644
index 0000000000000000000000000000000000000000..35bcafd8efebe1e753fc05b01f14865ba32eba2f
--- /dev/null
+++ b/lean/docs/085.md
@@ -0,0 +1,18 @@
+# Endpoint Sobolev regularity of centered disk averages
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [An Endpoint Gradient Bound for the Centered Disk Maximal Operator](../../preprints/An-Endpoint-Gradient-Bound-for-the-Centered-Disk-Maximal-Operator-September-26-2026/article.pdf)
+
+## Scope
+
+The centered disk maximal operator takes the supremum of averages of $|f|$ over disks centered at each point. The formalization proves that every real $f\in W^{1,1}(\mathbb R^2)$ has a maximal function that is finite almost everywhere, belongs to $W^{1,1}_{\mathrm{loc}}$, and has a globally integrable weak gradient satisfying $\|\nabla Mf\|_1\le C\|\nabla f\|_1$ for one absolute constant $C$.
+
+The earlier signed finite-band estimate for smooth compactly supported functions is also retained. The general endpoint statement covers the Sobolev setting of the paper; a BV extension is outside these statements.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Signed finite-band disk-maximal gradient bound | [SignedFiniteBand.lean](../ComparatorChallenges/SignedFiniteBand.lean) |
+| Endpoint gradient bound for the centered disk maximal operator | [DiskMaximal.lean](../ComparatorChallenges/DiskMaximal.lean) |
diff --git a/lean/docs/087.md b/lean/docs/087.md
new file mode 100644
index 0000000000000000000000000000000000000000..52459dc8c7e37b2395a25c903c4edac14b08e032
--- /dev/null
+++ b/lean/docs/087.md
@@ -0,0 +1,30 @@
+# The Mahler conjectures, functional inequalities and polar-product symplectic width
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [The symmetric Mahler conjecture and its equality cases](../../preprints/The-symmetric-Mahler-conjecture-and-its-equality-cases-September-22-2026/paper.pdf)
+- [The Mahler Conjecture for General Convex Bodies](../../preprints/The-Mahler-Conjecture-for-General-Convex-Bodies-September-22-2026/paper.pdf)
+- [Symplectic Balls in Symmetric Polar Products](../../preprints/Symplectic-Balls-in-Symmetric-Polar-Products-September-22-2026/paper.pdf)
+
+## Scope
+
+The symmetric Mahler conjecture predicts $|K||K^\circ|\ge4^n/n!$ for every origin-symmetric convex body $K\subset\mathbb R^n$. The formalization establishes this for every $n\ge1$ and characterizes equality exactly by invertible linear images of Hanner bodies, built from intervals using Cartesian products and convex-hull joins.
+
+The nonsymmetric Mahler conjecture and the functional inequalities are not included.
+
+The general Mahler conjecture gives a sharp lower bound for the volume product of a convex body and its polar. For every $n\ge1$ and compact convex body $K\subset\mathbb R^n$ with nonempty interior, the formalization proves
+$\inf_{z\in\mathrm{int}\,K}|K|\,|(K-z)^\circ|\ge (n+1)^{n+1}/(n!)^2$.
+Equality holds exactly when $K$ is a simplex. The paper's functional inequality is outside this selected statement.
+
+For an origin-symmetric convex body $K\subset\mathbb R^n$, $n\ge2$, the formalized result determines the symplectic ball capacity of $\mathrm{int}\,K\times\mathrm{int}\,K^\circ$: its Gromov width is $4$, and every ball of capacity $0<c<4$ embeds symplectically into it. The normalization assigns capacity $\pi r^2$ to a ball of radius $r$.
+
+No boundary smoothness or strict convexity is assumed. An embedding at capacity exactly $4$ is not asserted.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Symmetric Mahler inequality | [MahlerConjecture.lean](../ComparatorChallenges/MahlerConjecture.lean) |
+| Symmetric Mahler equality characterization | [SymmetricMahlerEquality.lean](../ComparatorChallenges/SymmetricMahlerEquality.lean) |
+| General Mahler inequality and simplex equality cases | [GeneralMahler.lean](../ComparatorChallenges/GeneralMahler.lean) |
+| Gromov width of symmetric polar products | [SymmetricPolar.lean](../ComparatorChallenges/SymmetricPolar.lean) |
diff --git a/lean/docs/088.md b/lean/docs/088.md
new file mode 100644
index 0000000000000000000000000000000000000000..2fd4efffae46c7cd2eb18bce019b87be74959872
--- /dev/null
+++ b/lean/docs/088.md
@@ -0,0 +1,30 @@
+# Sharp projection-body inequalities and a counterexample to simplex maximization
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [Petty’s projection-volume conjecture in dimensions at least four](../../preprints/Pettys-projection-volume-conjecture-in-dimensions-at-least-four-September-24-2026/paper.pdf)
+- [A product counterexample to the simplex maximum for projection-body volume](../../preprints/A-product-counterexample-to-the-simplex-maximum-for-projection-body-volume-September-24-2026/paper.pdf)
+
+## Scope
+
+Petty's projection-volume conjecture predicts
+
+$\displaystyle \frac{|\Pi K|}{|K|^{n-1}}\ge \kappa_{n-1}^{n}\kappa_n^{2-n},$
+
+with equality exactly for ellipsoids; here $\kappa_j$ is the volume of the Euclidean unit ball in dimension $j$. The formalization establishes this for every convex body $K\subset\mathbb R^n$ and every $n\ge4$.
+
+Other inequalities in the projection-body family are not included.
+
+Brannen's simplex-maximization conjecture predicts that a simplex maximizes normalized projection-body volume $|\Pi K|/|K|^{n-1}$ in dimension $n$. The formalized counterexample is the product of two ten-dimensional simplices. Its normalized projection volume, divided by that of a twenty-dimensional simplex, is
+
+$\displaystyle \frac{22{,}355{,}476}{22{,}020{,}096}>1.$
+
+Thus the proposed maximum fails in dimension $20$. The paper's exponential-factor result for every sufficiently large dimension is not included.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Petty's projection-volume inequality | [PettyProjectionVolume.lean](../ComparatorChallenges/PettyProjectionVolume.lean) |
+| Failure of the simplex upper bound in dimension 20 | [ProjectionCounterexample.lean](../ComparatorChallenges/ProjectionCounterexample.lean) |
+| Explicit product-of-simplices counterexample | [ProjectionVolume.lean](../ComparatorChallenges/ProjectionVolume.lean) |
diff --git a/lean/docs/089.md b/lean/docs/089.md
new file mode 100644
index 0000000000000000000000000000000000000000..0b56be5126ed5904bbb288f4d020948648bf118d
--- /dev/null
+++ b/lean/docs/089.md
@@ -0,0 +1,19 @@
+# Bounded-distortion <i>L</i><sub>1</sub> embeddings of planar and bounded-treewidth graphs
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [Planar Graph Metrics Embed into $L_1$ with Constant Distortion](../../preprints/Planar-Graph-Metrics-Embed-into-L1-with-Constant-Distortion-September-23-2026/paper.pdf)
+- [$L_1$ Embeddings of Graphs of Bounded Treewidth](../../preprints/L1-Embeddings-of-Graphs-of-Bounded-Treewidth-September-23-2026/paper.pdf)
+
+## Scope
+
+The planar case of the Gupta–Newman–Rabinovich–Sinclair embedding problem asks for a universal distortion bound in $L_1$. The formalized result gives one constant $C$ for every finite connected planar graph with arbitrary positive real edge lengths: its weighted shortest-path metric embeds into real $L_1$ with distortion at most $C$. The constant is independent of the number of vertices and the ratios between edge lengths; singleton graphs are included.
+
+The formalized result gives a uniform $L_1$ embedding bound for each bounded-treewidth class. For every bag-size bound $k\ge2$, there is a constant $C(k)$ such that the weighted shortest-path metric of every nonempty finite connected graph with a tree decomposition of bag size at most $k$ embeds into finite-dimensional real $L_1$ with distortion at most $C(k)$. Edge lengths may be arbitrary positive real numbers, and the constant is independent of the graph and decomposition size.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Planar graph metrics in $L_1$ | [PlanarL1.lean](../ComparatorChallenges/PlanarL1.lean) |
+| Bounded-treewidth graph metrics in $L_1$ | [BoundedTreewidthL1.lean](../ComparatorChallenges/BoundedTreewidthL1.lean) |
diff --git a/lean/docs/090.md b/lean/docs/090.md
new file mode 100644
index 0000000000000000000000000000000000000000..6ef2b6dbb33cd23f6a6a82a509003b3707427b71
--- /dev/null
+++ b/lean/docs/090.md
@@ -0,0 +1,23 @@
+# Triangular-lattice optimality, long-range Riesz and Coulomb energies, and spherical logarithmic energy
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [An atomic certificate for triangular-lattice universal optimality](../../preprints/An-atomic-certificate-for-triangular-lattice-universal-optimality-September-26-2026/paper.pdf)
+- [A sharp Fourier certificate for planar circle packing](../../preprints/A-sharp-Fourier-certificate-for-planar-circle-packing-September-23-2026/paper.pdf)
+
+## Scope
+
+The formalization proves that the density-one triangular lattice minimizes lower energy per particle among all locally finite planar configurations of centered-disk density one, for every nonnegative completely monotone function of squared distance. Infinite energies are allowed in the comparison.
+
+It also constructs sharp radial Schwartz minorants for every Gaussian potential: each minorant lies below the Gaussian, has nonnegative real Fourier transform, agrees with the Gaussian at nonzero triangular-lattice points, and vanishes on nonzero dual-lattice points after Fourier transformation. For the stated parameter range, the formalization includes the explicit atomic interpolation construction.
+
+The planar Cohn–Elkies sharpness conjecture asks whether the two-point Fourier method attains the optimal circle-packing density. The formalization constructs a radial Schwartz function $f$ on $\mathbb R^2$ with $\widehat f(0)=1$, $f(0)=2/\sqrt3$, $\widehat f$ real and nonnegative everywhere, and $f(x)\le0$ whenever $\|x\|\ge1$. These are the sharp Fourier certificate conditions yielding density $\pi/(2\sqrt3)$. The separate uniqueness statement for periodic equality cases is outside this selected theorem.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Sharp Gaussian minorants from an atomic certificate | [AtomicGaussian.lean](../ComparatorChallenges/AtomicGaussian.lean) |
+| Universal energy minimality of the triangular lattice | [TriangularEnergy.lean](../ComparatorChallenges/TriangularEnergy.lean) |
+| Gaussian Fourier minorants with their construction | [TriangularGaussian.lean](../ComparatorChallenges/TriangularGaussian.lean) |
+| Sharp Fourier certificate for planar circle packing | [PlanarPacking.lean](../ComparatorChallenges/PlanarPacking.lean) |
diff --git a/lean/docs/091.md b/lean/docs/091.md
new file mode 100644
index 0000000000000000000000000000000000000000..2f52add9f8c3c4b61db550dd7e62b6fca0538857
--- /dev/null
+++ b/lean/docs/091.md
@@ -0,0 +1,15 @@
+# Logarithmic and <i>L</i><sub><i>p</i></sub> Brunn–Minkowski inequalities and the B-conjecture
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [The logarithmic Brunn–Minkowski conjecture](../../preprints/The-logarithmic-Brunn-Minkowski-conjecture-September-23-2026/paper.pdf)
+
+## Scope
+
+The logarithmic Brunn–Minkowski conjecture asserts that logarithmic interpolation of origin-symmetric convex bodies preserves the geometric-mean lower bound for volume. The formalized result proves, for every dimension $n\ge1$, such bodies $K,L\subset\mathbb R^n$, and $0\le t\le1$, that their logarithmic Wulff combination has volume at least $|K|^{1-t}|L|^t$. It assumes neither boundary smoothness nor coordinatewise unconditionality.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Logarithmic Brunn–Minkowski inequality | [LogBrunnMinkowski.lean](../ComparatorChallenges/LogBrunnMinkowski.lean) |
diff --git a/lean/docs/092.md b/lean/docs/092.md
new file mode 100644
index 0000000000000000000000000000000000000000..e833ff29be0caf6a7f2adfab1186eb1556a714f9
--- /dev/null
+++ b/lean/docs/092.md
@@ -0,0 +1,19 @@
+# The optimal order of convex-body covering density
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [A single-lattice covering bound of order $n\log n$](../../preprints/A-single-lattice-covering-bound-of-order-n-log-n-September-23-2026/paper.pdf)
+- [Translative covering densities of order $n\log n$](../../preprints/Translative-covering-densities-of-order-n-log-n-September-23-2026/paper.pdf)
+
+## Scope
+
+The formalized result gives an absolute constant $C>0$ such that every convex body $K\subset\mathbb R^n$, $n\ge2$, admits a covering by translates along one full-rank lattice $L$ with density $|K|/\mathrm{covol}(L)\le Cn\log n$. The covering is exact, and no symmetry, boundary regularity, or volume normalization is assumed.
+
+The formalization determines the order of the largest covering density in dimension $n$. For all sufficiently large $n$, the suprema of translative covering density and lattice covering density are each bounded above and below by absolute positive multiples of $n\log n$, both over all convex bodies and over centrally symmetric convex bodies.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Single-lattice covering bound | [SingleLatticeCovering.lean](../ComparatorChallenges/SingleLatticeCovering.lean) |
+| Optimal order for translative and lattice covering-density suprema | [CoveringDensity.lean](../ComparatorChallenges/CoveringDensity.lean) |
diff --git a/lean/docs/094.md b/lean/docs/094.md
new file mode 100644
index 0000000000000000000000000000000000000000..ea8bdfa7b5dd2f9ec5312fc1ff1a409d869a7ad9
--- /dev/null
+++ b/lean/docs/094.md
@@ -0,0 +1,15 @@
+# Subpolynomial dimension reduction in <i>L</i><sub><i>p</i></sub>
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [Subpolynomial dimension reduction in $L_p$](../../preprints/Subpolynomial-dimension-reduction-in-Lp-September-23-2026/paper.pdf)
+
+## Scope
+
+For $p>1$, $p\ne2$, the formalization bounds the least dimension needed to embed every $n$-point subset of real $L_p$ with distortion $D$. For each fixed $D>1$, there is a constant $C=C(p,D)$ such that this dimension lies between $\log n/\log(1+2D)$ and $\exp(C(\log n)^{\gamma(p)})$ for every $n\ge2$, where $\gamma(p)=2-p$ for $p<2$ and $1-2/p$ for $p>2$. At distortion $1$ and $n\ge9$, it lies between $\lfloor(n-1)/4\rfloor^2$ and $\binom n2$. The least dimension is attained, and its logarithm divided by $\log n$ tends to $0$ for $D>1$ and to $2$ for $D=1$.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Dimension reduction in $L_p$ | [SubpolynomialLp.lean](../ComparatorChallenges/SubpolynomialLp.lean) |
diff --git a/lean/docs/095.md b/lean/docs/095.md
new file mode 100644
index 0000000000000000000000000000000000000000..5bdd2ca365901e548b714deb52539263845a75b4
--- /dev/null
+++ b/lean/docs/095.md
@@ -0,0 +1,15 @@
+# Hyperbolicity cones without semidefinite lifts
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [A nonspectrahedral hyperbolicity cone](../../preprints/A-Nonspectrahedral-Hyperbolicity-Cone-September-24-2026/nonspectrahedral-hyperbolicity-cone.pdf)
+
+## Scope
+
+The generalized Lax conjecture predicts that every hyperbolicity cone is spectrahedral. The formalized counterexample is an explicit homogeneous polynomial of degree $20$ in $23$ real variables. It is hyperbolic, but its closed hyperbolicity cone cannot be represented as the positive-semidefinite region of any finite real symmetric linear matrix pencil, in any positive matrix size.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Nonspectrahedral hyperbolicity cone | [HyperbolicCones.lean](../ComparatorChallenges/HyperbolicCones.lean) |
diff --git a/lean/docs/096.md b/lean/docs/096.md
new file mode 100644
index 0000000000000000000000000000000000000000..9a77fb948cc25fc62000457de1a357c3ebe1940d
--- /dev/null
+++ b/lean/docs/096.md
@@ -0,0 +1,15 @@
+# The Gaussian propeller conjecture in every dimension
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [The Gaussian propeller bound in every dimension](../../preprints/The-Gaussian-Propeller-Bound-in-Every-Dimension-September-24-2026/main.pdf)
+
+## Scope
+
+The Gaussian propeller problem asks how large the sum of squared Gaussian first moments can be over a partition. The formalized result proves the sharp bound $9/(8\pi)$ for every positive dimension and every positive number of labelled cells, allowing empty cells and arbitrary masses. In dimension at least two with at least three cells, three planar sectors of angle $120^\circ$, extended in orthogonal directions, attain equality. The separate Gaussian-maxima and kernel-clustering consequences are not included.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Gaussian propeller bound and attainment | [GaussianPropeller.lean](../ComparatorChallenges/GaussianPropeller.lean) |
diff --git a/lean/docs/097.md b/lean/docs/097.md
new file mode 100644
index 0000000000000000000000000000000000000000..62d935ed4e92b450bc3c4b172256dc1fe4e0b3a3
--- /dev/null
+++ b/lean/docs/097.md
@@ -0,0 +1,15 @@
+# The Euclidean Steinitz–Bergström bound
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [The Euclidean Steinitz–Bergström theorem](../../preprints/The-Euclidean-Steinitz-Bergstrom-theorem-September-24-2026/The-Euclidean-Steinitz-Bergstrom-theorem-September-24-2026.pdf)
+
+## Scope
+
+The formalized result gives the Euclidean Steinitz–Bergström bound with one absolute constant $C$. For every finite family of vectors in the unit ball of $\mathbb R^d$, signs can be chosen so that every prefix in the prescribed order has norm at most $C\sqrt d$. When the vector sum is zero, a permutation makes every unsigned prefix satisfy the same bound. Repeated and zero vectors are included. The result is existential and does not supply an online algorithm.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Euclidean signed and reordered prefix bounds | [SteinitzBergstrom.lean](../ComparatorChallenges/SteinitzBergstrom.lean) |
diff --git a/lean/docs/098.md b/lean/docs/098.md
new file mode 100644
index 0000000000000000000000000000000000000000..64b6902640aa3552c46b77e2a2d9d75c6e66b3e9
--- /dev/null
+++ b/lean/docs/098.md
@@ -0,0 +1,16 @@
+# Compact counterexamples to bi-Lipschitz dimension reduction
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [A doubling Hilbert subset with no finite-dimensional bi-Lipschitz embedding](../../preprints/A-doubling-Hilbert-subset-with-no-finite-dimensional-bi-Lipschitz-embedding-September-25-2026/main.pdf)
+
+## Scope
+
+The formalized result gives a doubling subset of real $\ell_2$, with doubling constant at most $76800$, that admits no bi-Lipschitz embedding into any finite-dimensional Euclidean space at any finite distortion. A companion gives one universal doubling constant such that every infinite-dimensional real Banach space contains a compact doubling subset with no bi-Lipschitz embedding into any finite-dimensional normed space.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Doubling Hilbert subset without finite-dimensional embedding | [DoublingHilbert.lean](../ComparatorChallenges/DoublingHilbert.lean) |
+| Compact counterexamples in infinite-dimensional Banach spaces | [CompactBanach.lean](../ComparatorChallenges/CompactBanach.lean) |
diff --git a/lean/docs/099.md b/lean/docs/099.md
new file mode 100644
index 0000000000000000000000000000000000000000..037b6f9666df52f97fe0e42a2e3e4d457e588363
--- /dev/null
+++ b/lean/docs/099.md
@@ -0,0 +1,28 @@
+# The sharp exponential scale of edit-distance distortion
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [Edit Distance in $\ell_1$: Matching Bounds up to Constants in the Exponent](../../preprints/Edit-Distance-in-l1-Matching-Bounds-up-to-Constants-in-the-Exponent-September-27-2026/paper.pdf)
+- [Finite-Circle Obstructions, Binary Codes, and Histogram Embeddings for Edit Distance](../../preprints/Finite-Circle-Obstructions-Binary-Codes-and-Histogram-Embeddings-for-Edit-Distance-September-27-2026/paper.pdf)
+- [Tree Constructions for the $\ell_1$ Distortion of Binary Edit Distance](../../preprints/Tree-Constructions-for-the-l1-Distortion-of-Binary-Edit-Distance-September-27-2026/paper.pdf)
+
+## Scope
+
+The formalization determines the exponential scale of the least $\ell_1$ distortion of unit-cost edit distance on strings of length at most $d$. For every sufficiently large $d$, uniformly over finite alphabets with at least two symbols, the distortion lies between $\exp(c\sqrt{\log d\,\log\log d})$ and $\exp(C\sqrt{\log d\,\log\log d})$ for absolute constants $c,C>0$. The lower bound has a witness consisting of binary strings of one common length, and the same scale controls the supremum over finite alphabets.
+
+The formalization gives two finite-circle constructions of binary strings whose least $\ell_1$ distortion is at least $\exp(c\sqrt{\log d\,\log\log d})$ for all sufficiently large length caps $d$. The witnesses use strings of one common length and include the binary coding transfers with their stated uniform bounds.
+
+It also gives a finite histogram embedding with distortion at most $\exp(C\sqrt{\log d\,\log\log d})$ for all strings of length at most $d$, uniformly over finite alphabets, including the empty string. Thus the lower and upper exponential scales agree up to absolute constants.
+
+The formalization gives two lower-bound constructions for the $\ell_1$ distortion of ordinary edit distance on binary words. For every sufficiently large length cap $d$, each construction supplies a finite set of at least two binary words of one common length at most $d$ whose least $\ell_1$ distortion is at least $\exp(c\sqrt{\log d\,\log\log d})$ for an absolute $c>0$.
+
+The selected statements are the binary lower bounds. The paper's constant-distortion binary conversion and the companion upper embedding theorem are outside them.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Matching exponential-scale bounds for edit-distance distortion | [EditDistance.lean](../ComparatorChallenges/EditDistance.lean) |
+| Finite-circle obstructions and histogram embeddings for edit distance | [FiniteCircle.lean](../ComparatorChallenges/FiniteCircle.lean) |
+| Binary edit-distance distortion lower bound | [BinaryEditLower.lean](../ComparatorChallenges/BinaryEditLower.lean) |
+| Tree-based binary edit-distance distortion lower bound | [TreeEdit.lean](../ComparatorChallenges/TreeEdit.lean) |
diff --git a/lean/docs/100.md b/lean/docs/100.md
new file mode 100644
index 0000000000000000000000000000000000000000..15ce0d568caa0538de2a8aab35bf3822260424d6
--- /dev/null
+++ b/lean/docs/100.md
@@ -0,0 +1,37 @@
+# Cylinder coverings below the half-area bound
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [Finite angular cylinder covers below the half-area bound](../../preprints/Finite-angular-cylinder-covers-below-the-half-area-bound-September-27-2026/main.pdf)
+- [Finite cylinder approximation of ruled sets](../../preprints/Finite-cylinder-approximation-of-ruled-sets-September-27-2026/main.pdf)
+- [Slope-field perturbations of the two-cylinder covering](../../preprints/Slope-field-perturbations-of-the-two-cylinder-covering-September-27-2026/main.pdf)
+- [Finite triangular approximation of radial sweeps](../../preprints/Finite-triangular-approximation-of-radial-sweeps-September-27-2026/main.pdf)
+
+## Scope
+
+The half-area cylinder-covering conjecture predicts that a cylinder cover of a convex body has total perpendicular-base area at least half its smallest projection area. The formalization constructs finite covers of a regular tetrahedron by cylinders with compact triangular bases whose total area is strictly below that bound. For the explicit small parameter $\varepsilon$, the normalized area is $1/2-(13/6000)\varepsilon^2+O(\varepsilon^4)$, giving the strict saving.
+
+It also gives a counterexample to the directionwise normalized half-bound. The broader Comparator file includes the companion ruled-set and radial-sweep approximation results.
+
+The formalization approximates compact ruled families of line segments by finite cylinder covers with perpendicular-base area at most the integral projection cost plus any prescribed positive error. The selected results cover the stated $C^1$ hyperbolic differential condition, square-zero and nilpotent cases, physical rescalings, logarithmic and product-cell estimates, and singular cases. Compact label sets need not have regular boundary.
+
+The differential and segment-length hypotheses remain part of each result. The aggregate Comparator file also contains the companion tetrahedron counterexamples and radial-sweep estimates.
+
+The formalization proves that every regular tetrahedron has a finite cylinder cover whose total perpendicular-base area is strictly less than half its minimum projection area. It supplies covers with parallelogram bases and also proves the directionwise normalized cost is below one half. These are counterexamples to the two cylinder-covering bounds studied in the paper.
+
+The linked aggregate includes the accompanying explicit angular covers and finite approximation theorems for ruled sets and radial sweeps. The affine extension of the directionwise conclusion to every nondegenerate tetrahedron is outside the selected regular-tetrahedron statements.
+
+The formalization proves finite triangular-cylinder approximation for radially aligned segment sweeps. For every tagged partition of the parameter interval, it constructs one cylinder per interval with the prescribed radial direction, and the total perpendicular-base area converges to the weighted parameter area as the mesh tends to zero. It also covers the corresponding actual swept set under the stated geometric hypotheses.
+
+The same aggregate includes finite cylinder covers of regular tetrahedra below half the minimum projection area. These are the radial approximation and covering consequences relevant to the paper.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Cylinder-covering counterexamples and companion approximations | [CylinderCovering.lean](../ComparatorChallenges/CylinderCovering.lean) |
+| Explicit triangular-cylinder cover below half area | [TriangularCovering.lean](../ComparatorChallenges/TriangularCovering.lean) |
+| Ruled-set approximation within the cylinder-covering aggregate | [CylinderCovering.lean](../ComparatorChallenges/CylinderCovering.lean) |
+| Finite cylinder approximation for the selected ruled families | [RuledCovering.lean](../ComparatorChallenges/RuledCovering.lean) |
+| Cylinder-covering counterexamples and approximation results | [CylinderCovering.lean](../ComparatorChallenges/CylinderCovering.lean) |
+| Finite triangular approximation of radial sweeps | [CylinderCovering.lean](../ComparatorChallenges/CylinderCovering.lean) |
diff --git a/lean/docs/102.md b/lean/docs/102.md
new file mode 100644
index 0000000000000000000000000000000000000000..6d70843b135770e41906c99f37f2fe3859067089
--- /dev/null
+++ b/lean/docs/102.md
@@ -0,0 +1,31 @@
+# The Unique Games Conjecture and optimal approximation thresholds
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [The Unique Games Theorem](../../preprints/The-Unique-Games-Theorem-September-23-2026/paper.pdf)
+- [A Direct Proof of Optimal Max-Cut Hardness](../../preprints/A-Direct-Proof-of-Optimal-Max-Cut-Hardness-September-23-2026/paper.pdf)
+- [The Factor-Two Hardness Threshold for Vertex Cover](../../preprints/The-Factor-Two-Hardness-Threshold-for-Vertex-Cover-September-23-2026/paper.pdf)
+- [Constant-factor hardness of Min-UnCut](../../preprints/Constant-factor-hardness-of-Min-UnCut-September-23-2026/paper.pdf)
+- [Constant-factor hardness of directed feedback vertex set](../../preprints/Constant-factor-hardness-of-directed-feedback-vertex-set-September-23-2026/paper.pdf)
+
+## Scope
+
+The Unique Games conjecture asks for hardness of distinguishing nearly satisfiable unique games from games of very small value. The formalized result gives, for every fixed $0<\varepsilon,\delta<1/2$, a deterministic polynomial-time reduction from binary 3SAT to nonempty unweighted simple bipartite unique games. Satisfiable inputs have value at least $1-\varepsilon$ and unsatisfiable inputs have value at most $\delta$. The alphabet is a fixed $\mathbb F_2^s$ depending only on the errors, and every constraint is a translation.
+
+The formalized result establishes hardness of approximating Max-Cut beyond the Goemans–Williamson constant $\alpha_{\mathrm{GW}}$. For every fixed $\alpha_{\mathrm{GW}}<\alpha\le1$, it gives a deterministic polynomial-time reduction from binary 3SAT to a strictly separated Max-Cut gap on finite simple unweighted graphs. The reduction includes the explicit positive integer scaling used in the gap statement.
+
+The formalized result gives the factor-two hardness threshold for Vertex Cover. For each integer $m\ge4$, a polynomial-time reduction from binary 3SAT produces simple unweighted graphs with cover density below $1/2+1/m$ on satisfiable inputs and above $1-1/m$ on unsatisfiable inputs. Consequently, any polynomial-time approximation with a fixed factor $1\le\alpha<2$ would give a polynomial-time decision algorithm for 3SAT. No assumption that $P\ne NP$ is built into the statement.
+
+Min-UnCut minimizes the number of edges left uncut by a bipartition. The formalization constructs a deterministic reduction from encoded $3$-SAT formulas to finite simple unweighted Min-UnCut instances with arbitrarily large fixed multiplicative gaps. For every integer $K\ge2$, satisfiable formulas give optimum at most the output threshold, while unsatisfiable formulas give optimum strictly greater than $K$ times that threshold. Runtime and output length are polynomial for each fixed $K$, establishing hardness for every fixed approximation factor greater than one.
+
+A directed feedback vertex set meets every directed cycle. The formalization proves hardness of approximating the minimum such set within any fixed constant factor. For every real factor $A\ge1$ and every language in NP, it constructs a polynomial-time gap reduction to unweighted directed graphs with the stated completeness and soundness separation. Thus a fixed-factor polynomial-time approximation would imply a polynomial-time algorithm for every NP language.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Unique Games gap reduction | [UniqueGamesTheorem.lean](../ComparatorChallenges/UniqueGamesTheorem.lean) |
+| Optimal Max-Cut hardness gap | [OptimalMaxCut.lean](../ComparatorChallenges/OptimalMaxCut.lean) |
+| Vertex Cover gap and factor-two hardness | [VertexCover.lean](../ComparatorChallenges/VertexCover.lean) |
+| Arbitrary constant-factor hardness of Min-UnCut | [MinUncut.lean](../ComparatorChallenges/MinUncut.lean) |
+| Constant-factor hardness of directed feedback vertex set | [DirectedFeedback.lean](../ComparatorChallenges/DirectedFeedback.lean) |
diff --git a/lean/docs/104.md b/lean/docs/104.md
new file mode 100644
index 0000000000000000000000000000000000000000..65cebab021a088b1f33434be79a1316be6a4b512
--- /dev/null
+++ b/lean/docs/104.md
@@ -0,0 +1,19 @@
+# Quasipolynomial algorithms for mean-payoff, stochastic and parity games
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [Deterministic quasipolynomial-time mean-payoff games](../../preprints/Deterministic-quasipolynomial-time-mean-payoff-games-September-25-2026/paper.pdf)
+- [Randomized quasipolynomial-time mean-payoff games](../../preprints/Randomized-quasipolynomial-time-mean-payoff-games-September-25-2026/paper.pdf)
+
+## Scope
+
+The formalization checks that a specified two-step execution of Truffet's elimination procedure terminates with a feasible but nonoptimal output. It is a finite counterexample to that proposed optimization step.
+
+The formalized result gives one randomized algorithm for the complete zero-threshold winning set of every finite mean-payoff game with signed binary weights. It succeeds with probability at least $7/8$ and runs in quasipolynomial bit time on every random tape. Self-loops, parallel edges, and history-dependent strategies are allowed, and winning means a nonnegative liminf average payoff.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Finite counterexample to Truffet's optimization procedure | [TruffetCounterexample.lean](../ComparatorChallenges/TruffetCounterexample.lean) |
+| Randomized quasipolynomial mean-payoff algorithm | [RandomizedMeanPayoff.lean](../ComparatorChallenges/RandomizedMeanPayoff.lean) |
diff --git a/lean/docs/105.md b/lean/docs/105.md
new file mode 100644
index 0000000000000000000000000000000000000000..5e5ad9f40c122221221db48ea819001697f58c48
--- /dev/null
+++ b/lean/docs/105.md
@@ -0,0 +1,15 @@
+# Perfect completeness for 2-to-1 games
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [Perfect completeness for 2-to-1 games](../../preprints/Perfect-completeness-for-2-to-1-games-September-23-2026/paper.pdf)
+
+## Scope
+
+The formalized result establishes perfect-completeness hardness for 2-to-1 games. For every fixed rational $0<\delta<1$, a deterministic polynomial-time reduction from binary 3SAT produces a nonempty unweighted game of value exactly $1$ on satisfiable inputs and at most $\delta$ on unsatisfiable inputs. Each constraint projection has exactly two preimages for each output label. The alphabet depends only on $\delta$, and the runtime is measured in the original input bit length.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Perfect-completeness reduction for 2-to-1 games | [PerfectCompleteness.lean](../ComparatorChallenges/PerfectCompleteness.lean) |
diff --git a/lean/docs/106.md b/lean/docs/106.md
new file mode 100644
index 0000000000000000000000000000000000000000..ddb80b724c6de2a363503eef9cd77272db5cc900
--- /dev/null
+++ b/lean/docs/106.md
@@ -0,0 +1,15 @@
+# Hardness of coloring three-colorable graphs
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [Hardness of finding large independent sets in three-colorable graphs](../../preprints/Hardness-of-finding-large-independent-sets-in-three-colorable-graphs-September-24-2026/Hardness-of-finding-large-independent-sets-in-three-colorable-graphs-September-24-2026.pdf)
+
+## Scope
+
+The formalized result shows hardness of finding large independent sets even under a three-colorability promise. For every fixed $0<\delta<1/3$, a deterministic polynomial-time reduction maps binary 3SAT formulas to nonempty finite simple graphs. Satisfiable formulas produce three-colorable graphs; unsatisfiable formulas produce graphs whose largest independent set has fewer than $\delta$ times the number of vertices. The complete adjacency-matrix output is included in the runtime bound.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Independent-set hardness in three-colorable graphs | [IndependentSets.lean](../ComparatorChallenges/IndependentSets.lean) |
diff --git a/lean/docs/107.md b/lean/docs/107.md
new file mode 100644
index 0000000000000000000000000000000000000000..b80de2d2cbef9b933a637978c6ea79a394a89b72
--- /dev/null
+++ b/lean/docs/107.md
@@ -0,0 +1,19 @@
+# Matrix multiplication with exponent at most 9/4
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [Complex Matrix Multiplication Below 2.258 and Rectangular Bounds](../../preprints/Complex-Matrix-Multiplication-Below-2.258-and-Rectangular-Bounds-September-24-2026/Complex-Matrix-Multiplication-Below-2.258-and-Rectangular-Bounds-September-24-2026.pdf)
+- [Staggered extraction for exact matrix multiplication over every field](../../preprints/Staggered-extraction-for-exact-matrix-multiplication-over-every-field-September-24-2026/Staggered-extraction-for-exact-matrix-multiplication-over-every-field-September-24-2026.pdf)
+
+## Scope
+
+The formalized results bound the complex matrix-multiplication exponent by $\omega(\mathbb C)\le9/4$, the dual exponent by $\alpha>0.465$, and the rectangular exponent at aspect ratio $0.709$ by $\omega(\mathbb C;1,0.709,1)<2.092$. The dual exponent is the supremum of rectangular aspect ratios attainable with exponent $2$. The arithmetic model counts additions, subtractions, and multiplications in finite division-free programs, with arbitrary positive exponent slack. The square bound implies the paper's weaker $2.258$ headline bound.
+
+The formalized result gives the unconditional bound $\omega(F)<2.371054886006746$ for every field $F$, including finite fields and fields of positive characteristic. The exponent counts additions, subtractions, and multiplications in finite division-free arithmetic programs, with arbitrary positive exponent slack. No numerical inequalities remain as hypotheses. The result concerns arithmetic complexity, rather than bit complexity or practical crossover sizes.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Complex square, dual, and rectangular exponent bounds | [MatrixMultiplication.lean](../ComparatorChallenges/MatrixMultiplication.lean) |
+| Matrix-multiplication exponent over every field | [MatrixFields.lean](../ComparatorChallenges/MatrixFields.lean) |
diff --git a/lean/docs/108.md b/lean/docs/108.md
new file mode 100644
index 0000000000000000000000000000000000000000..9ea4bb8cd7da73885affaaf8686565b6ed872013
--- /dev/null
+++ b/lean/docs/108.md
@@ -0,0 +1,18 @@
+# A cubic permanent–determinant lower bound
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [A cubic lower bound for border determinantal complexity of the permanent](../../preprints/A-cubic-lower-bound-for-border-determinantal-complexity-of-the-permanent-September-24-2026/A-cubic-lower-bound-for-border-determinantal-complexity-of-the-permanent-September-24-2026.pdf)
+
+## Scope
+
+The formalization proves a cubic lower bound for both exact and border determinantal representations of the complex $m\times m$ permanent. For $m\ge1408$, every affine-linear determinant representation of size $n$, including coefficientwise limits, satisfies $n\ge m^3/(5529600e)$.
+
+A general supporting theorem applies to a polynomial in $d\ge2$ variables whose first nonzero homogeneous Taylor term has degree $r\ge2$ and no nonzero singular zero. Its exact and border determinantal sizes are at least $(r-1)(d-1)/(4e)$. The paper's algebraic-branching-program consequences are outside these statements.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Cubic lower bounds for permanent determinantal complexity | [PermanentCubic.lean](../ComparatorChallenges/PermanentCubic.lean) |
+| Determinantal lower bound from a smooth initial form | [SmoothInitialForm.lean](../ComparatorChallenges/SmoothInitialForm.lean) |
diff --git a/lean/docs/110.md b/lean/docs/110.md
new file mode 100644
index 0000000000000000000000000000000000000000..d9bebba8e2785d6ccab8d11a2fd98f25e3b8731c
--- /dev/null
+++ b/lean/docs/110.md
@@ -0,0 +1,23 @@
+# Optimal-order randomized <i>k</i>-server on arbitrary metrics
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [Squared-logarithmic randomized $k$-server on arbitrary metrics](../../preprints/Squared-logarithmic-randomized-k-server-on-arbitrary-metrics-September-24-2026/Squared-logarithmic-randomized-k-server-on-arbitrary-metrics-September-24-2026.pdf)
+- [Uniform computation of the squared-logarithmic $k$-server bound](../../preprints/Uniform-computation-of-the-squared-logarithmic-k-server-bound-September-24-2026/Uniform-computation-of-the-squared-logarithmic-k-server-bound-September-24-2026.pdf)
+
+## Scope
+
+The formalization proves an $O((\log(k+1))^2)$ competitive ratio for randomized $k$-server against oblivious finite request sequences. For every $k\ge2$, every metric space containing at least $k+1$ points, and every initial configuration, one policy works for all request sequences, including in infinite and unbounded spaces.
+
+The bound permits a configuration-dependent additive constant, which is zero when the initial server positions are distinct. The universal multiplicative constant is independent of the metric and $k$.
+
+The formalization constructs one uniform randomized bit algorithm for $k$-server on finite rational metrics, for $2\le k<n$. Its expected movement on every oblivious finite request sequence is at most an absolute multiple of $(\log(k+1))^2$ times the offline optimum, plus a finite instance-dependent additive constant.
+
+Preprocessing is polynomial in the encoded input length, and each request is processed in time polynomial in that length and the binary length of the request counter. Every processed request returns a legal server index. The additive movement constant is not claimed to be polynomially bounded.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Squared-logarithmic randomized $k$-server on arbitrary metrics | [KServer.lean](../ComparatorChallenges/KServer.lean) |
+| Uniform bit algorithm for the squared-logarithmic $k$-server bound | [UniformKServer.lean](../ComparatorChallenges/UniformKServer.lean) |
diff --git a/lean/docs/111.md b/lean/docs/111.md
new file mode 100644
index 0000000000000000000000000000000000000000..3234d56da1715866f94b352d84f3a55cf0d5bd19
--- /dev/null
+++ b/lean/docs/111.md
@@ -0,0 +1,18 @@
+# One-sample matroid prophet inequalities against an almighty adversary
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [One Sample Suffices for Matroid Prophet Inequalities against an Almighty Adversary](../../preprints/One-Sample-Suffices-for-Matroid-Prophet-Inequalities-against-an-Almighty-Adversary-September-23-2026/final.pdf)
+
+## Scope
+
+The formalization proves a one-sample matroid prophet inequality with expected reward at least $2^{-310}$ times the expected offline optimum. Each element has one independent sample paired with an identically distributed nonnegative online value, and all coordinates are independent. The rule and finite seed law depend only on the labeled matroid; choices are irrevocable and feasible after every prefix. The arrival order may depend measurably on all samples, values, and the seed, and only the offline optimum must be integrable.
+
+A supporting hidden-vector selection result for fixed nonnegative matroid weights gives expected worst-order reward at least $2^{-293}$ times the optimum, again with a finite seed law and prefix feasibility.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| One-sample matroid prophet inequality against an almighty adversary | [MatroidProphet.lean](../ComparatorChallenges/MatroidProphet.lean) |
+| Hidden-vector matroid selection with worst-order guarantee | [MatroidSecretary.lean](../ComparatorChallenges/MatroidSecretary.lean) |
diff --git a/lean/docs/112.md b/lean/docs/112.md
new file mode 100644
index 0000000000000000000000000000000000000000..eb90f86e8ac4797c1e15fc5df0346106779f9888
--- /dev/null
+++ b/lean/docs/112.md
@@ -0,0 +1,15 @@
+# Beyond the square-root exponent for depth-three circuits
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [Beyond the Square-Root Exponent for Depth-Three Boolean Circuits](../../preprints/Beyond-the-Square-Root-Exponent-for-Depth-Three-Boolean-Circuits-September-23-2026/main.pdf)
+
+## Scope
+
+The formalized result gives one polynomial-time Boolean language whose exact depth-three OR–AND–OR circuit size eventually exceeds $2^{A\sqrt n}$ for every fixed $A>0$. The language and its polynomial-time algorithm are fixed before $A$ is chosen, while circuits may vary with the input length. Gates have unrestricted finite fan-in and sharing, with free input negations and constants. The result does not assert a fixed exponent $n^{1/2+\varepsilon}$ or a lower bound for unrestricted depth.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Depth-three circuit lower bound beyond every square-root constant | [DepthThree.lean](../ComparatorChallenges/DepthThree.lean) |
diff --git a/lean/docs/113.md b/lean/docs/113.md
new file mode 100644
index 0000000000000000000000000000000000000000..1d8966739519f3b75c8aaa44b4570492137999ce
--- /dev/null
+++ b/lean/docs/113.md
@@ -0,0 +1,27 @@
+# Approximate counting and entropy of perfect matchings
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [A Fully Polynomial Randomized Approximation Scheme for Perfect Matchings in General Graphs](../../preprints/A-Fully-Polynomial-Randomized-Approximation-Scheme-for-Perfect-Matchings-in-General-Graphs-September-23-2026/main.pdf)
+- [Entropy and Face Dimension of the Perfect-Matching Polytope](../../preprints/Entropy-and-Face-Dimension-of-the-Perfect-Matching-Polytope-September-23-2026/main.pdf)
+
+## Scope
+
+The formalization gives a fully polynomial randomized approximation scheme for counting perfect matchings in every finite simple undirected graph. For rational $0<\varepsilon<1$ and $0<\delta<1/2$, it returns a nonnegative rational estimate with relative error at most $\varepsilon$ with probability at least $1-\delta$. If the graph has no perfect matching, every execution returns zero.
+
+The algorithm is a fixed finite-alphabet randomized machine. Its worst-case running time is polynomial in the binary input length, $\varepsilon^{-1}$, and $\log(\delta^{-1})$, including on unsuccessful random tapes.
+
+For feasible edge marginals $x$ of perfect matchings in a loopless multigraph on $2m$ vertices, let $F(x)=-\sum_e x_e\log x_e$, $B(x)=-\sum_e(1-x_e)\log(1-x_e)$, and let $H(x)$ be the maximum entropy of a matching law with those marginals. The formalization proves $F(x)-(2-2/m)B(x)\le H(x)\le F(x)$ for $m\ge1$, including boundary points of the polytope. It retains the earlier coefficient-eight entropy bound and the deterministic counting approximations with factors $512^n$ for loopless graphs and $2^{18n}$ with singleton loops.
+
+A further statement identifies the exact face obtained by expanding a degree-three vertex into a triangle and shows that minimal faces are carried to minimal faces by the expansion. The paper's sharp global face-dimension bound is not part of that selected statement.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Randomized approximation of the perfect-matching count | [MatchingFPRAS.lean](../ComparatorChallenges/MatchingFPRAS.lean) |
+| Perfect-matching entropy bound | [MatchingEntropy.lean](../ComparatorChallenges/MatchingEntropy.lean) |
+| Deterministic approximate matching count | [BinaryMatching.lean](../ComparatorChallenges/BinaryMatching.lean) |
+| Approximate counting with singleton loops | [SingletonLoopMatching.lean](../ComparatorChallenges/SingletonLoopMatching.lean) |
+| Refined pointwise perfect-matching entropy bounds | [MatchingEntropyBounds.lean](../ComparatorChallenges/MatchingEntropyBounds.lean) |
+| Face correspondence under triangle expansion | [TriangleFace.lean](../ComparatorChallenges/TriangleFace.lean) |
diff --git a/lean/docs/114.md b/lean/docs/114.md
new file mode 100644
index 0000000000000000000000000000000000000000..b8e106e9c6c21ef6709291eb1a7af477f505b73a
--- /dev/null
+++ b/lean/docs/114.md
@@ -0,0 +1,15 @@
+# Approximate counting of common integer polymatroid bases
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [Approximate counting of common bases of two matroids](../../preprints/Approximate-counting-of-common-bases-of-two-matroids-September-23-2026/main.pdf)
+
+## Scope
+
+The formalized result gives a fully polynomial randomized approximation scheme for the number of common bases of two equal-rank matroids on an enumerated finite ground set, using independence oracles. For rational $0<\varepsilon,\delta<1$, the nonnegative rational output has relative error at most $\varepsilon$ with probability at least $1-\delta$. A zero count produces zero on every execution. Oracle calls and bit operations have polynomial bounds on every random tape in the input size, $\varepsilon^{-1}$, and $\log(\delta^{-1})$.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| FPRAS for common matroid bases | [CommonBasesFPRAS.lean](../ComparatorChallenges/CommonBasesFPRAS.lean) |
diff --git a/lean/docs/115.md b/lean/docs/115.md
new file mode 100644
index 0000000000000000000000000000000000000000..1aa44edde15aa918b1f0773087ebfb3e98df810c
--- /dev/null
+++ b/lean/docs/115.md
@@ -0,0 +1,23 @@
+# Sampling and counting contingency tables with arbitrary margins
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [Exact Uniform Sampling of Contingency Tables with Arbitrary Margins](../../preprints/Exact-Uniform-Sampling-of-Contingency-Tables-with-Arbitrary-Margins-September-24-2026/main.pdf)
+- [An FPRAS for Cell-Bounded Contingency Tables](../../preprints/An-FPRAS-for-Cell-Bounded-Contingency-Tables-September-24-2026/main.pdf)
+
+## Scope
+
+The formalization gives an exact uniform sampler for nonnegative integer contingency tables with arbitrary prescribed row and column sums having equal totals. It terminates almost surely, every halted output is feasible, and each table has exactly the uniform limiting probability. Expected bit complexity is polynomial in the dimensions and the binary length of the margins.
+
+It also gives a sampler with a fixed polynomial time bound on every execution whose total-variation error is at most $2^{-k}$ for requested precision $k\ge1$. The same Comparator file includes the companion approximation scheme for counting tables with individual cell bounds.
+
+The formalization gives a fully polynomial randomized approximation scheme for counting nonnegative integer matrices with prescribed row sums, column sums, and individual entry bounds. Both dimensions may vary, the margins and bounds are binary encoded, and zero entry bounds are allowed. For rational $0<\varepsilon,\delta<1$, the algorithm returns a nonnegative estimate with relative error at most $\varepsilon$ with probability at least $1-\delta$, and returns zero on every execution when no table exists.
+
+The running time is polynomial in the encoded input size, $\varepsilon^{-1}$, and $\log(\delta^{-1})$ on every random tape. The same Comparator file also contains the companion sampling results for tables without cell bounds.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Exact and bounded-time sampling of contingency tables | [ContingencyTables.lean](../ComparatorChallenges/ContingencyTables.lean) |
+| Randomized approximate counting of cell-bounded contingency tables | [ContingencyTables.lean](../ComparatorChallenges/ContingencyTables.lean) |
diff --git a/lean/docs/116.md b/lean/docs/116.md
new file mode 100644
index 0000000000000000000000000000000000000000..1adf3a79084ab4062a5556e0c9bbc7fec5d04897
--- /dev/null
+++ b/lean/docs/116.md
@@ -0,0 +1,21 @@
+# Uniform black-box noncommutative identity testing across characteristics
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [One Rational Matrix Hitting Point for Noncommutative Formulas](../../preprints/One-Rational-Matrix-Hitting-Point-for-Noncommutative-Formulas-September-24-2026/One-Rational-Matrix-Hitting-Point-for-Noncommutative-Formulas-September-24-2026.pdf)
+- [Polynomial Hitting Lists for Noncommutative Rational Formulas](../../preprints/Polynomial-Hitting-Lists-for-Noncommutative-Rational-Formulas-September-24-2026/Polynomial-Hitting-Lists-for-Noncommutative-Rational-Formulas-September-24-2026.pdf)
+
+## Scope
+
+The formalization gives one explicit tuple of rational matrices that simultaneously detects every nonzero division-free noncommutative formula with at most $s$ gates in $n$ variables, for $n,s\ge1$. Evaluation at that tuple is a nonzero matrix over every characteristic-zero field.
+
+The selected theorem states this universal hitting property. The paper's deterministic polynomial bit-construction bound and matrix-dimension bound $O(ns^2)$ are not separately asserted in it.
+
+The formalized result constructs polynomial-size hitting lists for noncommutative rational formulas with rational constants, addition, multiplication, and inverse gates. Given the number of variables and a formula-size bound, one deterministic polynomial-time machine outputs rational matrix tuples of a common positive dimension. Every admissible nonzero formula within the size bound evaluates to an invertible matrix on some listed tuple. The matrix dimension, complete binary output length, and running time are all polynomially bounded.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| One rational matrix tuple hitting all bounded-size noncommutative formulas | [FormulaHitting.lean](../ComparatorChallenges/FormulaHitting.lean) |
+| Polynomial hitting lists for rational formulas | [RationalHitting.lean](../ComparatorChallenges/RationalHitting.lean) |
diff --git a/lean/docs/117.md b/lean/docs/117.md
new file mode 100644
index 0000000000000000000000000000000000000000..c0a5aa25ad26baf580e0e95920348166b460e7a3
--- /dev/null
+++ b/lean/docs/117.md
@@ -0,0 +1,15 @@
+# Uniform sparsest cut: hardness and semidefinite gaps
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [Near-square-root logarithmic integrality gaps for uniform sparsest cut](../../preprints/Near-square-root-logarithmic-integrality-gaps-for-uniform-sparsest-cut-September-24-2026/Near-square-root-logarithmic-integrality-gaps-for-uniform-sparsest-cut-September-24-2026.pdf)
+
+## Scope
+
+The formalized result gives integrality gaps for the Goemans–Linial relaxation of uniform sparsest cut. Along a sequence of instance sizes $n\to\infty$, the ratio of the integral optimum to the positive relaxation optimum is at least $c\sqrt{\log n}/(\log\log n)^3$ for one absolute $c>0$. Every unordered pair has unit demand, and the relaxation uses squared Euclidean distances satisfying the triangle inequalities. The result is an existential sequence, not a bound for every size or a computational hardness theorem.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Uniform sparsest-cut integrality gaps | [UniformSparsestCut.lean](../ComparatorChallenges/UniformSparsestCut.lean) |
diff --git a/lean/docs/118.md b/lean/docs/118.md
new file mode 100644
index 0000000000000000000000000000000000000000..ca04c56f833ae938c1025c65f081cf17d8a48079
--- /dev/null
+++ b/lean/docs/118.md
@@ -0,0 +1,15 @@
+# Bin packing and unbounded configuration-LP gaps
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [Additive hardness and unbounded configuration gaps in bin packing](../../preprints/Additive-hardness-and-unbounded-configuration-gaps-in-bin-packing-September-24-2026/Additive-hardness-and-unbounded-configuration-gaps-in-bin-packing-September-24-2026.pdf)
+
+## Scope
+
+The formalized results rule out a universal additive bound for the configuration linear program in bin packing. For every integer $c\ge0$, there are an integer $B$ and a rational instance with $5B$ items whose individual-copy and size-type configuration-LP values both equal $B$, but whose integral optimum is greater than $B+c$. Distinguishing a packing in $B$ bins from the absence of one in $B+c$ bins is NP-hard for each fixed $c$. A deterministic polynomial-time algorithm with a fixed absolute additive allowance exists exactly when $P=NP$; under that equality, an optimal algorithm is constructed.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Unbounded configuration gaps and additive hardness | [BinPackingGap.lean](../ComparatorChallenges/BinPackingGap.lean) |
diff --git a/lean/docs/119.md b/lean/docs/119.md
new file mode 100644
index 0000000000000000000000000000000000000000..e8de61a6f182c52430a35f4792c84eba2b14e08d
--- /dev/null
+++ b/lean/docs/119.md
@@ -0,0 +1,18 @@
+# The Courtade–Kumar and Hellinger conjectures
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [Sharp binary-information contraction on the discrete cube](../../preprints/Sharp-binary-information-contraction-on-the-discrete-cube-September-24-2026/main.pdf)
+
+## Scope
+
+The formalization proves sharp contraction of the information carried by a binary channel under independent symmetric noise on a uniform discrete cube. At each fixed initial information level, a noisy coordinate channel attains the maximum retained information. It also proves the refined Boolean bound that accounts for output bias, with strict improvement for nonconstant biased outputs at nonzero noise correlation, and the selected mean-dependent entropy-production inequality.
+
+For Boolean functions this includes the Courtade–Kumar inequality $I(f(X);Y)\le1-h_2(\varepsilon)$ in bits at crossover probability $0\le\varepsilon\le1/2$, where $h_2$ is binary entropy. A coordinate and its complement attain equality.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Courtade–Kumar inequality and attainment | [CourtadeKumar.lean](../ComparatorChallenges/CourtadeKumar.lean) |
+| Sharp binary-channel contraction and entropy production | [SoftChannel204.lean](../ComparatorChallenges/SoftChannel204.lean) |
diff --git a/lean/docs/121.md b/lean/docs/121.md
new file mode 100644
index 0000000000000000000000000000000000000000..586807cfc4ed6b35cb580c651ca4ce81369e6b73
--- /dev/null
+++ b/lean/docs/121.md
@@ -0,0 +1,17 @@
+# Almost-linear approximation of edit distance
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [An Almost-Linear Approximation Scheme for Edit Distance](../../preprints/An-Almost-Linear-Approximation-Scheme-for-Edit-Distance-September-24-2026/paper.pdf)
+
+## Scope
+
+The formalization gives a randomized $(1+\varepsilon)$-approximation for unit-cost edit distance between explicitly stored integer strings, for every fixed rational $0<\varepsilon<1$. Its estimate is at least the true distance and at most $(1+\varepsilon)$ times it with probability at least $2/3$; equal strings return zero on every execution.
+
+For total length at most $N$ and integer symbols bounded by a fixed polynomial in $N$, expected work is at most $(N+2)^{1+\eta}$ for every fixed $\eta>0$ and all sufficiently large $N$. Space is polynomially bounded on every execution.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Almost-linear randomized approximation of edit distance | [EditApproximation.lean](../ComparatorChallenges/EditApproximation.lean) |
diff --git a/lean/docs/122.md b/lean/docs/122.md
new file mode 100644
index 0000000000000000000000000000000000000000..75fee8107664cb88751893f163388ce2b05c5cfb
--- /dev/null
+++ b/lean/docs/122.md
@@ -0,0 +1,17 @@
+# Quantitative trace-reconstruction bounds with a uniform decoder
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [Quantitative lower bounds for trace reconstruction](../../preprints/quantitative-lower-bounds-for-trace-reconstruction-September-24-2026/paper.pdf)
+
+## Scope
+
+The formalization proves superpolynomial sample lower bounds for exact worst-case reconstruction of binary words from independent deletion traces, with unrestricted computation and any fixed positive success probability. For every fixed deletion probability $q\in(0,1)$, sample complexity grows faster than every fixed power of the word length; the minimum total-variation distance between two one-trace laws decays faster than every inverse power.
+
+More quantitatively, along sequences with $q^3\log n\to\infty$, the required number of samples is at least $n^{c\log(q^3\log n)}$ eventually for every fixed $0<c<1/(4\log2)$. All logarithms are natural.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Quantitative and superpolynomial sample lower bounds for trace reconstruction | [TraceReconstruction.lean](../ComparatorChallenges/TraceReconstruction.lean) |
diff --git a/lean/docs/124.md b/lean/docs/124.md
new file mode 100644
index 0000000000000000000000000000000000000000..2ce83844d1d36d6d87e5d85c9a9d1e82633bafe3
--- /dev/null
+++ b/lean/docs/124.md
@@ -0,0 +1,15 @@
+# Polynomial-time scheduling on three identical machines
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [A Polynomial-Time Algorithm for Three-Machine Unit-Job Scheduling](../../preprints/A-polynomial-time-algorithm-for-three-machine-unit-job-scheduling-September-24-2026/paper.pdf)
+
+## Scope
+
+The formalization gives a deterministic polynomial-time algorithm for scheduling nonempty collections of unit-length jobs with arbitrary acyclic precedence constraints on three identical parallel machines. It constructs a schedule of minimum makespan and decides exactly whether a valid specified deadline can be met. The algorithm is one fixed finite machine, and its running time is bounded by a polynomial in the binary input length.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Optimal three-machine unit-job scheduling | [ThreeMachine.lean](../ComparatorChallenges/ThreeMachine.lean) |
diff --git a/lean/docs/125.md b/lean/docs/125.md
new file mode 100644
index 0000000000000000000000000000000000000000..99d7bf4022eb7ea7102baf42a199bee7a75e021b
--- /dev/null
+++ b/lean/docs/125.md
@@ -0,0 +1,25 @@
+# The metric <i>k</i>-median approximation threshold and recovery
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [Single-exponential recovery and bounded-price strictness for metric $k$-median](../../preprints/Single-Exponential-Recovery-and-Bounded-Price-Strictness-for-Metric-k-Median-September-24-2026/paper.pdf)
+- [The approximation threshold for metric $k$-median](../../preprints/The-Approximation-Threshold-for-Metric-k-Median-September-24-2026/main.pdf)
+
+## Scope
+
+The formalization gives an exact-budget recovery algorithm for metric $k$-median on the stated polynomially bounded integral metrics. Suppose a supplied anchor represents all but logarithmically many comparison clusters by distinct proxies, with total proxy cost at most the comparison cost plus a sufficiently small relative error. The algorithm always opens at most $k$ facilities and, with any requested confidence, attains a $(1+2/e+\varepsilon)$ factor relative to those comparison centers in polynomial time.
+
+The linked final approximation result applies to arbitrary finite rational metrics. For one absolute $\sigma>0$, a polynomial-time fair-bit algorithm always returns a feasible solution, has expected cost at most $(2-\sigma)\mathrm{OPT}$, and attains the same factor with arbitrarily high polynomial confidence.
+
+The formalization gives, for every fixed $\varepsilon>0$, a deterministic polynomial-time $(1+2/e+\varepsilon)$-approximation for metric $k$-median on finite rational metrics with specified candidate facilities. Every output is a nonempty subset of the candidate facilities and opens at most $k$ of them.
+
+Assuming $P\ne NP$, it also proves that the infimum of all polynomial-time approximation factors in this model is exactly $1+2/e$.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Randomized metric $k$-median approximation below two | [KMedianRecovery.lean](../ComparatorChallenges/KMedianRecovery.lean) |
+| Exact-budget recovery from accurate distinct cluster proxies | [KMedianRefinedRecovery.lean](../ComparatorChallenges/KMedianRefinedRecovery.lean) |
+| Exact approximation threshold under $P\ne NP$ | [KMedianThreshold.lean](../ComparatorChallenges/KMedianThreshold.lean) |
+| Deterministic metric $k$-median approximation at the threshold | [MetricKMedian.lean](../ComparatorChallenges/MetricKMedian.lean) |
diff --git a/lean/docs/126.md b/lean/docs/126.md
new file mode 100644
index 0000000000000000000000000000000000000000..e64c42eb6358254a54f8c3e869f3b2a1995db75c
--- /dev/null
+++ b/lean/docs/126.md
@@ -0,0 +1,18 @@
+# Exponential semidefinite complexity of perfect matching
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [Exponential PSD rank of positively shifted matching matrices](../../preprints/Exponential-PSD-rank-of-positively-shifted-matching-matrices-October-5-2026/shifted-matching-psd.pdf)
+
+## Scope
+
+The paper proves exponential PSD-rank lower bounds for positively shifted matching matrices. The linked formalization records the related superpolynomial lower bounds: for every fixed $C>0$, the PSD rank of the selected perfect-matching slack matrix exceeds $n^C$ for all sufficiently large even $n$. Every exact affine semidefinite lift of the perfect-matching polytope likewise requires matrix size greater than $n^C$.
+
+These selected statements give superpolynomial growth. They do not state the paper's exponential bound for every fixed positive shift.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Superpolynomial lower bound for affine semidefinite lifts | [MatchingAffineLift.lean](../ComparatorChallenges/MatchingAffineLift.lean) |
+| Superpolynomial PSD rank for the perfect-matching slack matrix | [MatchingPSD.lean](../ComparatorChallenges/MatchingPSD.lean) |
diff --git a/lean/docs/127.md b/lean/docs/127.md
new file mode 100644
index 0000000000000000000000000000000000000000..7ed32b1d857ef786dde308593b470c9d53b78427
--- /dev/null
+++ b/lean/docs/127.md
@@ -0,0 +1,15 @@
+# Average sensitivity of polynomial threshold functions
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [Average sensitivity of polynomial threshold functions](../../preprints/Average-Sensitivity-of-Polynomial-Threshold-Functions-September-25-2026/main.pdf)
+
+## Scope
+
+The formalized result proves the average-sensitivity bound $8d\sqrt n$ for every Boolean threshold function defined by a real multilinear polynomial of degree at most $d$ on the $n$-dimensional cube. The sign convention assigns value $1$ at zero. This establishes the stated asymptotic bound, rather than the separate conjecture identifying exact extremizers.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Average sensitivity of polynomial threshold functions | [GotsmanLinial.lean](../ComparatorChallenges/GotsmanLinial.lean) |
diff --git a/lean/docs/128.md b/lean/docs/128.md
new file mode 100644
index 0000000000000000000000000000000000000000..ed5a4adce48a5ce86caac0b9858d784fae132b35
--- /dev/null
+++ b/lean/docs/128.md
@@ -0,0 +1,15 @@
+# A factor-two approximation for shortest common superstring
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [A Polynomial-Time 2-Approximation for Shortest Common Superstring](../../preprints/A-Polynomial-Time-2-Approximation-for-Shortest-Common-Superstring-September-24-2026/paper.pdf)
+
+## Scope
+
+The shortest common superstring problem asks for the shortest string containing each input string as a contiguous substring. The formalized result gives one deterministic polynomial-time algorithm whose output is a common superstring of length at most twice the unrestricted optimum. It applies to every finite list of explicitly encoded strings, with running time measured in input bits and the approximation ratio measured in symbol length.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Polynomial-time 2-approximation for shortest common superstring | [Superstring.lean](../ComparatorChallenges/Superstring.lean) |
diff --git a/lean/docs/129.md b/lean/docs/129.md
new file mode 100644
index 0000000000000000000000000000000000000000..dc34a9572574ac4fab4027a5a18a103e71e4021e
--- /dev/null
+++ b/lean/docs/129.md
@@ -0,0 +1,22 @@
+# Exponential state costs for two-way automata
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [An exponential state lower bound for two-way nondeterministic complementation](../../preprints/An-exponential-state-lower-bound-for-two-way-nondeterministic-complementation-September-25-2026/paper.pdf)
+- [An exponential two-way deterministic state lower bound for one-way liveness](../../preprints/An-exponential-two-way-deterministic-state-lower-bound-for-one-way-liveness-September-25-2026/main.pdf)
+
+## Scope
+
+The paper asks how many states are needed to complement or determinize two-way nondeterministic finite automata. The formalization gives, for every $n\ge4$, an explicit $n$-state automaton whose complement requires at least $\tfrac12 2^{\lfloor(n-4)/127\rfloor}-1$ states. For the same family of relational languages and every $n\ge131$, every equivalent deterministic two-way automaton requires at least $\tfrac12 2^{\lfloor(n-4)/127\rfloor}$ states.
+
+The alphabet grows with $n$, so neither complementation nor determinization has a polynomial state bound uniform over alphabets. The model has two endmarkers, left, right, and stay moves, and acceptance by a finite run. The separate results about one-way liveness and the Sakoda–Sipser problem are outside this scope.
+
+The formalization gives a family of one-way nondeterministic automata with $h+3$ states whose languages require exponentially many states for two-way deterministic recognition. For every $h\ge2$, a deterministic recognizer with $s$ states satisfies $2^{\lfloor(h-2)/31\rfloor}\le4(s+2)^2$ under both acceptance conventions considered in the paper; one convention has the sharper factor $4(s+1)^2$. The alphabet may grow with $h$, so no alphabet-independent polynomial simulation bound holds.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Two-way nondeterministic complementation lower bound | [TwoWayComplementation.lean](../ComparatorChallenges/TwoWayComplementation.lean) |
+| Same-family determinization lower bound | [TwoWayDeterminization.lean](../ComparatorChallenges/TwoWayDeterminization.lean) |
+| Exponential deterministic state lower bound for liveness | [OneWayLiveness.lean](../ComparatorChallenges/OneWayLiveness.lean) |
diff --git a/lean/docs/130.md b/lean/docs/130.md
new file mode 100644
index 0000000000000000000000000000000000000000..4a105acf75c96e0e2e8b69c9b5d654b2ddfefe54
--- /dev/null
+++ b/lean/docs/130.md
@@ -0,0 +1,15 @@
+# Exact Fourier transforms below $`n\log n`$
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [Finite tensor savings and exact Fourier circuits](../../preprints/Finite-tensor-savings-and-exact-Fourier-circuits-September-25-2026/main.pdf)
+
+## Scope
+
+The formalized result gives exact discrete Fourier transforms with arbitrarily small normalized circuit cost along an unbounded sequence of lengths. For every $c>0$ and every cutoff $N_0\ge2$, some $n\ge N_0$ has a circuit computing the unnormalized DFT with fewer than $cn\log_2 n$ gates. Addition, subtraction, and multiplication by a predetermined complex scalar each cost one gate; diagonal scalings are charged. The result is subsequential, with no all-length, bounded-coefficient, conditioning, or bit-complexity claim.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Subsequential savings for exact Fourier circuits | [ExactFourier.lean](../ComparatorChallenges/ExactFourier.lean) |
diff --git a/lean/docs/131.md b/lean/docs/131.md
new file mode 100644
index 0000000000000000000000000000000000000000..c8f733a08e4536d0184873086ee4fbaa9e077690
--- /dev/null
+++ b/lean/docs/131.md
@@ -0,0 +1,17 @@
+# Rapid mixing of graph switches for every degree sequence
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [Polynomial mixing of the switch chain for every graphical degree sequence](../../preprints/Polynomial-Mixing-of-the-Switch-Chain-for-Every-Graphical-Degree-Sequence-September-25-2026/main.pdf)
+
+## Scope
+
+The Kannan–Tetali–Vempala conjecture asks for polynomial mixing of the switch chain for every graphical degree sequence. The formalization proves the simple undirected case: for $n\ge4$, the lazy chain that proposes switches on four vertices has total-variation mixing time at distance $1/4$ at most $2n^8$. It also proves switch connectivity, the stated exponential total-variation bound, and a spectral gap of at least $1/(24n^2\binom n4)$ when more than one graph realizes the degree sequence.
+
+The paper's exactly uniform sampling algorithm is outside these selected chain estimates.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Polynomial mixing and connectivity for every graphical degree sequence | [SwitchChain.lean](../ComparatorChallenges/SwitchChain.lean) |
diff --git a/lean/docs/132.md b/lean/docs/132.md
new file mode 100644
index 0000000000000000000000000000000000000000..45471071153edd829e9fb4755e640ee6bf9b5943
--- /dev/null
+++ b/lean/docs/132.md
@@ -0,0 +1,15 @@
+# A superquadratic separation of sensitivity and block sensitivity
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [A superquadratic separation between sensitivity and block sensitivity](../../preprints/A-superquadratic-separation-between-sensitivity-and-block-sensitivity-September-25-2026/paper.pdf)
+
+## Scope
+
+The formalized result disproves a universal quadratic bound of block sensitivity by sensitivity for total Boolean functions. For every integer $d\ge1$, it constructs a nonconstant function with $\mathrm{bs}(f)/s(f)^2\ge2^d/(4(d+2)^2)$, making the ratio unbounded. The formalization also gives a fixed exponent $\alpha>2$ and a sequence with $s(f)^\alpha\le\mathrm{bs}(f,0)$ while the latter tends to infinity; here $\mathrm{bs}(f,0)$ is block sensitivity at the all-zero input.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Superquadratic sensitivity separation | [SensitivitySeparation.lean](../ComparatorChallenges/SensitivitySeparation.lean) |
diff --git a/lean/docs/133.md b/lean/docs/133.md
new file mode 100644
index 0000000000000000000000000000000000000000..bd1d08cc0f4623af1276fbe4588de00ddff81156
--- /dev/null
+++ b/lean/docs/133.md
@@ -0,0 +1,31 @@
+# The computational complexity of Weisfeiler–Leman refinement
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [Parity lifts and bounded-treewidth witnesses for Weisfeiler–Leman equivalence](../../preprints/Parity-lifts-and-bounded-treewidth-witnesses-for-Weisfeiler-Leman-equivalence-September-25-2026/paper.pdf)
+- [The complexity of identifying a graph by Weisfeiler–Leman refinement](../../preprints/The-complexity-of-identifying-a-graph-by-Weisfeiler-Leman-refinement-September-25-2026/paper.pdf)
+- [Unconditional time lower bounds for Weisfeiler–Leman equivalence](../../preprints/Unconditional-time-lower-bounds-for-Weisfeiler-Leman-equivalence-September-25-2026/paper.pdf)
+- [Variable-dimension Weisfeiler–Leman equivalence on general and subcubic graphs](../../preprints/Variable-dimension-Weisfeiler-Leman-equivalence-on-general-and-subcubic-graphs-September-25-2026/paper.pdf)
+
+## Scope
+
+The formalization gives the paper's parity-lift graph construction for every Weisfeiler–Leman dimension $k\ge4$, under both joint and separate conventions. From a finite choice system it constructs two equal-size uncolored graphs that are Weisfeiler–Leman equivalent exactly when the system has no successful compatible choice. The same equivalence holds for the pure variant.
+
+A successful choice is detected by the specified early round: round two in the joint convention and round one in the separate convention. The graph-size bound is linear in the choice-system size with a factor depending on $k$. The paper's conditional running-time exclusions are outside these selected construction statements.
+
+The formalization proves that deciding whether Weisfeiler–Leman refinement of a supplied dimension identifies a graph is EXPTIME-complete under polynomial-time many-one reductions. The input is a nonempty finite simple uncolored graph encoded by its adjacency matrix together with a positive binary-encoded dimension. Identification quantifies over every comparison graph, and the statement includes both the exponential-time upper bound and hardness.
+
+The formalization proves an unconditional deterministic time lower bound for deciding $k$-dimensional Weisfeiler–Leman equivalence. For every sufficiently large fixed $k$, every deciding algorithm in the stated multitape Turing-machine or sequential logarithmic-word RAM model requires at least $n^{ck}$ worst-case time for all sufficiently large graph orders $n$, for one absolute $c>0$.
+
+The bound covers both joint and separate replacement conventions and remains valid for explicit adjacency-matrix inputs restricted to simple connected uncolored graphs of diameter at most two.
+
+The formalization proves EXPTIME-completeness of deciding joint-update $k$-dimensional Weisfeiler–Leman equivalence when $k\ge2$ is part of the input in binary and the graphs are encoded by explicit adjacency matrices. It proves both the general result and the restriction to connected simple uncolored graphs of equal positive order and maximum degree at most three. Completeness uses polynomial-time many-one reductions.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Parity-lift characterization of Weisfeiler–Leman equivalence | [ParityLifts.lean](../ComparatorChallenges/ParityLifts.lean) |
+| EXPTIME-completeness of Weisfeiler–Leman graph identification | [WLIdentification.lean](../ComparatorChallenges/WLIdentification.lean) |
+| Unconditional sequential time lower bounds for Weisfeiler–Leman equivalence | [WeisfeilerLeman.lean](../ComparatorChallenges/WeisfeilerLeman.lean) |
+| EXPTIME-completeness of variable-dimension Weisfeiler–Leman equivalence | [VariableWL.lean](../ComparatorChallenges/VariableWL.lean) |
diff --git a/lean/docs/134.md b/lean/docs/134.md
new file mode 100644
index 0000000000000000000000000000000000000000..2a8a786d09dd61ebc2700b0c974d551ca911aea9
--- /dev/null
+++ b/lean/docs/134.md
@@ -0,0 +1,22 @@
+# Generalized star height at most three
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [Finite Monoid Computations and a Uniform Generalized Star-Height Bound](../../preprints/Finite-Monoid-Computations-and-a-Uniform-Generalized-Star-Height-Bound-September-25-2026/Finite-Monoid-Computations-and-a-Uniform-Generalized-Star-Height-Bound-September-25-2026.pdf)
+- [Generalized Star Height at Most Four](../../preprints/Generalized-Star-Height-at-Most-Four-September-25-2026/Generalized-Star-Height-at-Most-Four-September-25-2026.pdf)
+- [Generalized Star Height at Most Three](../../preprints/Generalized-Star-Height-at-Most-Three-September-25-2026/article.pdf)
+
+## Scope
+
+Generalized star height measures the nesting of Kleene stars in regular expressions that also allow Boolean operations. The formalization proves that every regular language over a finite alphabet has a generalized expression over the same alphabet of star height at most three. This is stronger than the bound of thirteen in the accompanying finite-monoid paper. The selected statement asserts the uniform expression bound, without separately encoding every construction step of that paper.
+
+The formalization proves that every regular language over a finite alphabet has a generalized regular expression over that same alphabet with star height at most three. Generalized expressions allow Boolean operations as well as concatenation and Kleene star. The bound of three implies the accompanying paper's bound of four; the selected statement concerns the expression bound itself.
+
+Generalized star height measures the nesting of Kleene stars in regular expressions that also allow Boolean operations. The formalization proves that every regular language over a finite alphabet has a generalized regular expression over that same alphabet of star height at most three. Complements are taken in the same free monoid. This is the paper's uniform bound.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Uniform generalized star-height bound of three | [GeneralizedStarHeight.lean](../ComparatorChallenges/GeneralizedStarHeight.lean) |
+| Generalized star height at most three | [GeneralizedStarHeight.lean](../ComparatorChallenges/GeneralizedStarHeight.lean) |
diff --git a/lean/docs/135.md b/lean/docs/135.md
new file mode 100644
index 0000000000000000000000000000000000000000..1657acd351d3597af491bfbbaf83b1e9571da761
--- /dev/null
+++ b/lean/docs/135.md
@@ -0,0 +1,17 @@
+# Homogeneous depth-five lower bounds for iterated matrix multiplication
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [Homogeneous depth-five lower bounds for iterated matrix multiplication](../../preprints/Homogeneous-depth-five-lower-bounds-for-iterated-matrix-multiplication-September-25-2026/Homogeneous-depth-five-lower-bounds-for-iterated-matrix-multiplication-September-25-2026.pdf)
+
+## Scope
+
+Let $\mathrm{IMM}_{n,n}$ be the $(1,1)$ entry of the product of $n$ independent $n\times n$ variable matrices. The formalization proves that, over every characteristic-zero field, syntactically homogeneous depth-five $\Sigma\Pi\Sigma\Pi\Sigma$ circuits computing this polynomial require at least $n^{\sqrt n/400}$ gates for all sufficiently large $n$, with a threshold independent of the field. Arbitrary bottom support, finite fan-in and fan-out, and sharing are allowed.
+
+It also gives, over every field and for $n\ge2$, circuits with at most $n^{\sqrt n+4}$ gates. These are the lower and upper bounds selected from the paper.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Homogeneous depth-five bounds for iterated matrix multiplication | [DepthFive.lean](../ComparatorChallenges/DepthFive.lean) |
diff --git a/lean/docs/139.md b/lean/docs/139.md
new file mode 100644
index 0000000000000000000000000000000000000000..323bb69fdd61aaa00418330c794a19f6b2efc368
--- /dev/null
+++ b/lean/docs/139.md
@@ -0,0 +1,15 @@
+# Subpolynomial query complexity for log-concave sampling
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [Subpolynomial query complexity for well-conditioned log-concave sampling](../../preprints/Subpolynomial-query-complexity-for-well-conditioned-log-concave-sampling-September-26-2026/article.pdf)
+
+## Scope
+
+The formalized result determines the dimension exponent of exact value-and-gradient query complexity for well-conditioned log-concave sampling. For potentials with $V(0)=0$, $\nabla V(0)=0$, and $I\le\nabla^2V\le2I$, the least worst-case query budget achieving total-variation error at most $1/10$ is at most $C_\varepsilon d^\varepsilon$ for every $\varepsilon>0$, and at least $c\log d$ eventually. Hence the infimal polynomial exponent is zero. Algorithms may be measurable, randomized, and adaptive; arithmetic and bit costs are not bounded.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Subpolynomial query complexity for log-concave sampling | [LogConcaveQuery.lean](../ComparatorChallenges/LogConcaveQuery.lean) |
diff --git a/lean/docs/140.md b/lean/docs/140.md
new file mode 100644
index 0000000000000000000000000000000000000000..dbabe31e00bf52ef24a4633980ff3794fb1e8127
--- /dev/null
+++ b/lean/docs/140.md
@@ -0,0 +1,49 @@
+# Memory–sample lower bounds for noiseless Gaussian regression
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [Memory and precision in noiseless Gaussian regression](../../preprints/Memory-and-precision-in-noiseless-Gaussian-regression-September-27-2026/paper.pdf)
+- [Posterior replicas and conditional information in Gaussian regression](../../preprints/Posterior-replicas-and-conditional-information-in-Gaussian-regression-September-27-2026/paper.pdf)
+- [Localization costs and information growth for exact Gaussian observations](../../preprints/Localization-costs-and-information-growth-for-exact-Gaussian-observations-September-27-2026/paper.pdf)
+- [Projection moments, positive cap domination, and Riesz estimates on the sphere](../../preprints/Projection-moments-positive-cap-domination-and-Riesz-estimates-on-the-sphere-September-27-2026/paper.pdf)
+- [Replacing Gaussian observations in memory-constrained inference](../../preprints/Replacing-Gaussian-observations-in-memory-constrained-inference-September-27-2026/paper.pdf)
+- [Subsphere methods for memory–sample lower bounds in noiseless Gaussian regression](../../preprints/Subsphere-methods-for-memory-sample-lower-bounds-in-noiseless-Gaussian-regression-September-27-2026/paper.pdf)
+
+## Scope
+
+In noiseless Gaussian regression, a learner observes inner products of an unknown unit vector in $\mathbb R^d$ with independent standard Gaussian vectors. The formalization proves that, for every fixed $A>0$, there is $c_A>0$ such that, in sufficiently large dimension, a learner retaining at most $Ad^2$ bits between observations needs at least $c_A d\log(1/\varepsilon)$ observations to attain angular error at most $\varepsilon$ with probability at least $2/3$ for a uniformly random unit signal, for $0<\varepsilon\le1/10$.
+
+For memory $o(d^2)$, the constant can be universal, and the selected statement also permits success at least $2/3$ separately for every signal. The linked supporting results include inverse Gram-matrix moments, exact-projection densities, regularization bounds, and sphere- and cube-prior block estimates.
+
+The paper studies how posterior replicas—independent signals drawn conditionally on the same observed data—control information in noiseless Gaussian regression. The formalization establishes the equal-label identity for finite measures, its density and measurable forms, and information bounds for Gaussian, distance, Haar, synthetic, and incidence comparisons. These statements retain exact observation labels, independent side randomness, and randomized transition rules.
+
+For a learner using $M(d)=o(d^2)$ bits of memory, the resulting bound says that, for sufficiently large $d$ and $0<\varepsilon\le1/10$, success probability at least $2/3$ under the uniform unit-sphere prior requires $T\ge c d\log(1/\varepsilon)$ observations, where $c>0$ is universal. The formalized streaming result uses the $2/3$ threshold; the stronger $3/5$ variant is outside this scope.
+
+The formalization controls information gained from exact Gaussian observations of a spherical image of the uniform cube. Under the stated entropy and size conditions, repeated localization over $t$ observation blocks produces nested disclosures with mutual information at most $C(n+1)t$ and expected final localization level at most $Ct$. The selected estimates include inverse-volume control, kernel coercivity, and drift for the actual observation rows.
+
+For a law of finite relative entropy with respect to a uniform cell law in sufficiently large dimension, the regularization procedure terminates almost surely in regular cells. Its expected depth and number of attempts are finite, with at most twice one plus the expected depth in expectation; the remaining relative entropy plus $(\log 2)n/4$ times the expected depth is at most the initial relative entropy plus $2/e$.
+
+The paper uses projection moments and domination by positive spherical caps to bound the information carried by exact Gaussian observations of an unknown unit vector. The formalization covers integrated frame and sphere moments, cap domination, Riesz-density estimates with fixed offsets, and bounds valid at every radius. It also covers probability bounds for finite-memory learners at a fixed stopping time and after summing over stopping times.
+
+For $M(d)=o(d^2)$ bits of memory, sufficiently large $d$, and $0<\varepsilon\le1/10$, success probability at least $2/3$ under the uniform sphere prior requires $T\ge c d\log(1/\varepsilon)$ observations for a universal $c>0$. A corresponding bound holds when $M\le A d^2$ for each fixed $A>0$, with the constant allowed to depend on $A$. The randomized learner model allows independent shared seeds; its reduction to a finite-state model is proved for dimensions at least three, with the auxiliary dimension-two case outside this scope.
+
+The paper compares fresh Gaussian observations with observations coupled to information already held in memory. The formalization covers mixed-moment and actual-row estimates, critical-radius, one-level, and two-label comparisons, and conditional-information bounds across a block of observations. For sufficiently large dimension $d$, the relevant entropy bounds of order $d^2$ bound the information in the fresh experiment by that in the coupled experiment plus a term of order $d$; the associated block information increase also has order $d$.
+
+It also covers two-point identities on observation fibers and the fiber-block bound, including the boundary case of $d-2$ observed rows. The uniform unit-sphere prior, Gaussian rows, finite memory states, and randomized transition rules remain part of these statements. The separate streaming consequences and several intermediate comparison constructions are outside this selection.
+
+The paper uses subspheres to bound the number of exact Gaussian observations needed to estimate a unit vector with limited memory. The formalization proves that, for $M(d)=o(d^2)$ bits of memory, sufficiently large $d$, and $0<\varepsilon\le1/10$, success probability at least $2/3$ under the uniform sphere prior, or for every unit signal, requires at least $2^{-16}d\log_2(1/\varepsilon)$ observations. Under the uniform prior, a lower bound of the same order with a universal positive constant holds at success probability $1/2$.
+
+The formalization also covers radius-weighted block and terminal estimates, affine and dimension estimates, and a vector-valued beta-mixture comparison with its boundary cases. These statements retain their dimension, width, radius, and suffix hypotheses, as well as the finite-state learner's independent randomness and restrictions on stopping and output.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Projection estimates and memory–precision bounds | [MemoryPrecision.lean](../ComparatorChallenges/MemoryPrecision.lean) |
+| Subquadratic and fixed-quadratic memory–precision lower bounds | [NoiselessRegression.lean](../ComparatorChallenges/NoiselessRegression.lean) |
+| Posterior-replica comparisons and sample lower bound | [PosteriorReplicas.lean](../ComparatorChallenges/PosteriorReplicas.lean) |
+| Finite-entropy localization and regularization bounds | [GaussianFiniteEntropy.lean](../ComparatorChallenges/GaussianFiniteEntropy.lean) |
+| Information growth under repeated exact Gaussian observations | [GaussianInformation.lean](../ComparatorChallenges/GaussianInformation.lean) |
+| Projection, cap, and Riesz estimates with regression bounds | [ProjectionMoments.lean](../ComparatorChallenges/ProjectionMoments.lean) |
+| Gaussian replacement and information bounds | [GaussianReplacement.lean](../ComparatorChallenges/GaussianReplacement.lean) |
+| Subsphere estimates and memory–sample lower bounds | [SubsphereCurrent.lean](../ComparatorChallenges/SubsphereCurrent.lean) |
diff --git a/lean/docs/143.md b/lean/docs/143.md
new file mode 100644
index 0000000000000000000000000000000000000000..c5bd183a050b32edf8c9c59f585de18e73a352bd
--- /dev/null
+++ b/lean/docs/143.md
@@ -0,0 +1,15 @@
+# Hilbert's sixteenth problem: uniform bounds for limit cycles
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [Two limit cycles for quintic Liénard systems](../../preprints/two-limit-cycles-for-quintic-lienard-systems-September-24-2026/two-limit-cycles-for-quintic-lienard-systems-September-24-2026.pdf)
+
+## Scope
+
+For the quintic Liénard system $x'=y-F(x)$, $y'=-x$, the formalized result proves that every real polynomial $F$ of degree at most five yields at most two limit cycles, and that some such $F$ yields exactly two. Limit cycles are isolated images of nonconstant periodic solutions. No sign, parity, hyperbolicity, or amplitude restriction is imposed.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Exact two-cycle bound for quintic Liénard systems | [QuinticLienard.lean](../ComparatorChallenges/QuinticLienard.lean) |
diff --git a/lean/docs/144.md b/lean/docs/144.md
new file mode 100644
index 0000000000000000000000000000000000000000..bb24489bd6e237a26bf2e93e6f5c82113585be8f
--- /dev/null
+++ b/lean/docs/144.md
@@ -0,0 +1,15 @@
+# Banach’s simple Lebesgue-spectrum problem
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [A smooth three-torus diffeomorphism with simple Lebesgue spectrum](../../preprints/A-smooth-three-torus-diffeomorphism-with-simple-Lebesgue-spectrum-September-23-2026/paper.pdf)
+
+## Scope
+
+Banach's simple Lebesgue-spectrum problem asks for a probability-preserving transformation with simple Lebesgue spectrum on its mean-zero $L^2$ space. The formalization constructs a smooth volume-preserving diffeomorphism of the three-torus with this property. It gives a real-valued cyclic vector whose integer iterates form an orthonormal basis of the entire mean-zero space, and an isometric identification under which the Koopman operator becomes multiplication by the coordinate function on the circle. The transformation is also ergodic.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Smooth simple Lebesgue spectrum on the three-torus | [ThreeTorus.lean](../ComparatorChallenges/ThreeTorus.lean) |
diff --git a/lean/docs/145.md b/lean/docs/145.md
new file mode 100644
index 0000000000000000000000000000000000000000..0efa05919ab9774c50264fef71e4cc3077c069db
--- /dev/null
+++ b/lean/docs/145.md
@@ -0,0 +1,15 @@
+# Rokhlin’s multiple-mixing problem
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [Rokhlin's multiple-mixing problem for one transformation](../../preprints/Rokhlins-multiple-mixing-problem-for-one-transformation-September-23-2026/paper.pdf)
+
+## Scope
+
+Rokhlin's multiple-mixing problem asks whether ordinary mixing of one invertible probability-preserving transformation implies mixing of every finite order. The formalization proves this implication. For each $k\ge3$ and every $k$ measurable sets, the measure of their translated intersection tends to the product of their measures as all successive time gaps tend to infinity.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Mixing of every finite order for one mixing transformation | [Rokhlin.lean](../ComparatorChallenges/Rokhlin.lean) |
diff --git a/lean/docs/146.md b/lean/docs/146.md
new file mode 100644
index 0000000000000000000000000000000000000000..74693583afa73b347a47901d07d840a820dfd13d
--- /dev/null
+++ b/lean/docs/146.md
@@ -0,0 +1,19 @@
+# Positive metric entropy for the standard map
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [Positive Metric Entropy for the Standard Map at Large Parameters](../../preprints/Positive-Metric-Entropy-for-the-Standard-Map-at-Large-Parameters-September-23-2026/paper.pdf)
+
+## Scope
+
+The formalization proves Sinai's positive-entropy conjecture for the standard sine map on the two-dimensional torus in the stronger form of a full positive parameter tail. For every sufficiently large parameter, normalized area has positive metric entropy, and a positive-area set has positive largest Lyapunov exponent with the stated derivative-growth limit.
+
+It also constructs a positive-area invariant ergodic hyperbolic component. That component splits into finitely many cyclic pieces on each of which the corresponding iterate is Bernoulli. No genericity assumption on the parameter is used.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Positive-area hyperbolic Bernoulli component | [StandardMapComponents.lean](../ComparatorChallenges/StandardMapComponents.lean) |
+| Positive metric entropy for all sufficiently large parameters | [StandardMapEntropy.lean](../ComparatorChallenges/StandardMapEntropy.lean) |
+| Positive Lyapunov exponents and entropy | [StandardMapLyapunov.lean](../ComparatorChallenges/StandardMapLyapunov.lean) |
diff --git a/lean/docs/148.md b/lean/docs/148.md
new file mode 100644
index 0000000000000000000000000000000000000000..f40e1f2a9ee44fda0b9e2725c5f57703d81471e0
--- /dev/null
+++ b/lean/docs/148.md
@@ -0,0 +1,18 @@
+# The entropy-rate dimension formula for self-similar measures
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [The entropy-rate dimension formula for self-similar measures on the line](../../preprints/The-entropy-rate-dimension-formula-for-self-similar-measures-on-the-line-September-24-2026/main.pdf)
+
+## Scope
+
+The formalization proves $\dim_H\mu=\min\{1,h_{\mathrm{RW}}/\chi\}$ for the lower Hausdorff dimension of every finite real self-similar probability measure with positive weights and nonzero contraction ratios of absolute value below one. Here $h_{\mathrm{RW}}$ is the entropy rate of random affine compositions and $\chi$ is the corresponding Lyapunov exponent in the same logarithmic base. Ratios may be signed and unequal, and exact overlaps are allowed.
+
+It also gives two consequences without exact overlaps: the usual entropy-over-Lyapunov formula for a common positive contraction ratio, and the attractor formula $\dim_H K=\min\{1,s\}$, where $s\ge0$ is the unique solution of $\sum_i|r_i|^s=1$. Absolute continuity is outside these statements.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Entropy-rate dimension formula | [SelfSimilar.lean](../ComparatorChallenges/SelfSimilar.lean) |
+| Homogeneous-measure and self-similar-attractor dimension formulas | [SelfSimilarCorollaries.lean](../ComparatorChallenges/SelfSimilarCorollaries.lean) |
diff --git a/lean/docs/149.md b/lean/docs/149.md
new file mode 100644
index 0000000000000000000000000000000000000000..0434973c5a6e5458ffefb3478d83cf810fe25f38
--- /dev/null
+++ b/lean/docs/149.md
@@ -0,0 +1,15 @@
+# Classwise permanence for weakly reversible mass-action systems
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [Boundedness and persistence of weakly reversible mass-action systems](../../preprints/Boundedness-and-persistence-of-weakly-reversible-mass-action-systems-September-25-2026/paper.pdf)
+
+## Scope
+
+The boundedness and persistence conjectures for mass-action systems ask whether positive concentrations remain finite and separated from zero. The formalization proves this for every finite weakly reversible reaction network with positive constant reaction rates and every strictly positive initial state. A global forward solution exists, and one $\varepsilon\in(0,1)$ bounds every concentration of every global forward solution between $\varepsilon$ and $\varepsilon^{-1}$ for all nonnegative times. The bound may depend on the network, rates, and initial state.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Global boundedness and persistence for weakly reversible mass-action systems | [MassAction.lean](../ComparatorChallenges/MassAction.lean) |
diff --git a/lean/docs/150.md b/lean/docs/150.md
new file mode 100644
index 0000000000000000000000000000000000000000..80d46b5297711506dbbaf9de57f75daafe689614
--- /dev/null
+++ b/lean/docs/150.md
@@ -0,0 +1,15 @@
+# Weak mixing of triangular billiards with an irrational angle
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [Ergodicity of triangular billiards with an irrational angle](../../preprints/Ergodicity-of-triangular-billiards-with-an-irrational-angle-September-25-2026/Ergodicity-of-triangular-billiards-with-an-irrational-angle-September-25-2026.pdf)
+
+## Scope
+
+The formalization proves that the unit-speed billiard flow in every nondegenerate Euclidean triangle with at least one angle irrational relative to $\pi$ is ergodic for normalized area times uniform angular measure. It constructs the flow outside the null set of exceptional trajectories, proves uniqueness of the flight chain there, and establishes measure preservation and the flow law almost everywhere. No genericity or Diophantine condition on the irrational angle is assumed.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Ergodicity of triangular billiards with an irrational angle | [IrrationalTriangleBilliard.lean](../ComparatorChallenges/IrrationalTriangleBilliard.lean) |
diff --git a/lean/docs/151.md b/lean/docs/151.md
new file mode 100644
index 0000000000000000000000000000000000000000..832f79ce8dabe2b8f40cf8274af58793daac214a
--- /dev/null
+++ b/lean/docs/151.md
@@ -0,0 +1,15 @@
+# A <i>C</i><sup>1</sup> counterexample to the entropy conjecture
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [A $C^1$ Counterexample to the Entropy Conjecture](../../preprints/A-C1-Counterexample-to-the-Entropy-Conjecture-September-25-2026/article.pdf)
+
+## Scope
+
+Shub's entropy conjecture predicts that a smooth self-map's topological entropy is at least the logarithm of the spectral radius of its action on real homology. The formalization gives a counterexample to the general $C^1$ self-map version: a noninvertible $C^1$ map on a compact smooth manifold without boundary has topological entropy zero, while its action on second real homology has a nonzero eigenvector with eigenvalue $2$. Thus the homological lower bound is strictly positive and fails for this map.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| A $C^1$ counterexample to the entropy conjecture | [C1EntropyCounterexample.lean](../ComparatorChallenges/C1EntropyCounterexample.lean) |
diff --git a/lean/docs/152.md b/lean/docs/152.md
new file mode 100644
index 0000000000000000000000000000000000000000..cc8cac12b24cf70964acbb152167b22427caa4bd
--- /dev/null
+++ b/lean/docs/152.md
@@ -0,0 +1,17 @@
+# Zero entropy does not guarantee a smooth positive-volume model
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [A zero-entropy system without a smooth positive-volume model](../../preprints/A-finite-entropy-system-without-a-smooth-positive-volume-model-September-25-2026/paper.pdf)
+
+## Scope
+
+The paper asks whether a measure-preserving system can be represented by a smooth diffeomorphism preserving positive smooth volume. The formalized supporting result constructs an ergodic invertible transformation of a standard nonatomic probability space with finite Kolmogorov–Sinai entropy that has no such model on any compact finite-dimensional manifold, including manifolds with smooth boundary. The comparison is measurable conjugacy after discarding null sets.
+
+The linked statement gives finite entropy; the paper's stronger zero-entropy conclusion is outside this statement.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Finite-entropy system without a smooth positive-volume model | [SmoothObstruction.lean](../ComparatorChallenges/SmoothObstruction.lean) |
diff --git a/lean/docs/155.md b/lean/docs/155.md
new file mode 100644
index 0000000000000000000000000000000000000000..be4d349f4ed5041e1834b3be875160e53fb9e80a
--- /dev/null
+++ b/lean/docs/155.md
@@ -0,0 +1,15 @@
+# A counterexample to periodic tiling in dimension three
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [A translational tile with no fully periodic tiling in dimension three](../../preprints/A-translational-tile-with-no-fully-periodic-tiling-in-dimension-three-September-23-2026/paper.pdf)
+
+## Scope
+
+The periodic-tiling question asks whether a finite tile that tiles a lattice must admit a periodic tiling. The formalized counterexample is a finite tile in $\mathbb Z^3$ that tiles but has no complement invariant under a finite-index subgroup. Its unit-cube thickening also tiles $\mathbb R^3$ almost everywhere but admits no fully periodic tiling, even with arbitrary real translation vectors. The result also establishes that dimension three is the least lattice dimension where this failure occurs.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Aperiodic translational tile in dimension three | [PeriodicTilingThree.lean](../ComparatorChallenges/PeriodicTilingThree.lean) |
diff --git a/lean/docs/156.md b/lean/docs/156.md
new file mode 100644
index 0000000000000000000000000000000000000000..b7d70bab39125aeab20098c1dc035bb5861f1762
--- /dev/null
+++ b/lean/docs/156.md
@@ -0,0 +1,15 @@
+# Borsuk's conjecture fails in dimension nine
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [A nine-dimensional counterexample to Borsuk's covering assertion](../../preprints/A-nine-dimensional-counterexample-to-Borsuks-covering-assertion-September-23-2026/paper.pdf)
+
+## Scope
+
+Borsuk's conjecture predicts that every bounded subset of $\mathbb R^d$ can be covered by $d+1$ sets of strictly smaller diameter. The formalized counterexample is the compact set of rank-one orthogonal projectors onto lines in $\mathbb R^4$, with the Frobenius metric. It lies in the nine-dimensional affine space of trace-one symmetric matrices, has diameter $\sqrt2$, and cannot be covered by ten arbitrary sets of smaller diameter.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Nine-dimensional Borsuk counterexample | [BorsukNine.lean](../ComparatorChallenges/BorsukNine.lean) |
diff --git a/lean/docs/157.md b/lean/docs/157.md
new file mode 100644
index 0000000000000000000000000000000000000000..fd634db0d6debd47fae0370eb56030d1951bf679
--- /dev/null
+++ b/lean/docs/157.md
@@ -0,0 +1,15 @@
+# Graph coloring, clique minors, and Colin de Verdière invariants
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [A linear list-coloring bound in terms of the Hadwiger number](../../preprints/A-linear-list-coloring-bound-in-terms-of-the-Hadwiger-number-September-23-2026/paper.pdf)
+
+## Scope
+
+The Linear List Hadwiger conjecture asks for a universal linear bound on list chromatic number in terms of clique-minor size. The formalization proves that there is one integer $C\ge1$ such that every finite nonempty simple graph $G$ satisfies $\chi_{\mathrm{list}}(G)\le C h(G)$, where $h(G)$ is the largest order of a clique minor. The constant is independent of the graph.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Linear list-coloring bound in the Hadwiger number | [ListHadwiger.lean](../ComparatorChallenges/ListHadwiger.lean) |
diff --git a/lean/docs/158.md b/lean/docs/158.md
new file mode 100644
index 0000000000000000000000000000000000000000..e0156ec60c494a10c66915ffcd3274b2902df433
--- /dev/null
+++ b/lean/docs/158.md
@@ -0,0 +1,16 @@
+# The Euclidean plane cannot be colored with five colors
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [The Euclidean plane is not five-colorable](../../preprints/The-Euclidean-plane-is-not-five-colorable-September-23-2026/paper.pdf)
+
+## Scope
+
+The Hadwiger–Nelson problem asks for the fewest colors needed to color the plane so that points at distance one have different colors. The formalized results prove that five colors do not suffice and that seven colors do suffice. The lower bound applies to arbitrary colorings, with no measurability or continuity assumption; the upper bound includes every boundary point of the coloring regions.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| No proper five-coloring | [EuclideanFiveColor.lean](../ComparatorChallenges/EuclideanFiveColor.lean) |
+| Proper seven-coloring | [PlaneColoring.lean](../ComparatorChallenges/PlaneColoring.lean) |
diff --git a/lean/docs/159.md b/lean/docs/159.md
new file mode 100644
index 0000000000000000000000000000000000000000..66ef29e1f3a887a47889812669e9b736c4294b94
--- /dev/null
+++ b/lean/docs/159.md
@@ -0,0 +1,17 @@
+# Erdős’s reciprocal-sum conjecture and quasipolynomial Szemerédi bounds
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [Quasipolynomial Bounds for Arithmetic Progressions](../../preprints/Quasipolynomial-Bounds-for-Arithmetic-Progressions-September-23-2026/paper.pdf)
+
+## Scope
+
+Erdős's reciprocal-sum conjecture asks whether every set of positive integers with divergent reciprocal sum contains arithmetic progressions of every finite length. The formalization proves this statement: for every requested length, such a set contains a progression with positive common difference.
+
+The selected theorem is the reciprocal-sum consequence. The paper's quantitative upper bound for the largest progression-free subset of $\{1,\ldots,N\}$ is outside this statement.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Erdős's reciprocal-sum arithmetic-progression conjecture | [ErdosReciprocal.lean](../ComparatorChallenges/ErdosReciprocal.lean) |
diff --git a/lean/docs/160.md b/lean/docs/160.md
new file mode 100644
index 0000000000000000000000000000000000000000..9790b3a2e07815023f04a08d51885fef3098caf3
--- /dev/null
+++ b/lean/docs/160.md
@@ -0,0 +1,15 @@
+# Superexponential van der Waerden numbers
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [Quantitative Superexponential Bounds for van der Waerden Numbers](../../preprints/Quantitative-Superexponential-Bounds-for-van-der-Waerden-Numbers-September-23-2026/paper.pdf)
+
+## Scope
+
+Let $W(r,k)$ be the least interval length forcing a monochromatic $k$-term arithmetic progression in every coloring with at most $r$ colors. The formalized result gives an absolute threshold $K$ such that $W(r,k)>k^{k\lfloor\log_2 r\rfloor/100000}$ for all $k\ge K$ and $r\ge2$. It also establishes the associated growth limits, finiteness, and boundary values. The sharper intermediate estimates used in the paper are not part of the described formalization.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Uniform van der Waerden lower bound | [QuantitativeVanDerWaerden.lean](../ComparatorChallenges/QuantitativeVanDerWaerden.lean) |
diff --git a/lean/docs/161.md b/lean/docs/161.md
new file mode 100644
index 0000000000000000000000000000000000000000..b395e0eaa2462cf72aeea576d6c614cd544da2ec
--- /dev/null
+++ b/lean/docs/161.md
@@ -0,0 +1,15 @@
+# Counterexamples to Sidorenko’s conjecture and the forcing conjecture
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [A counterexample to Sidorenko's conjecture](../../preprints/A-counterexample-to-Sidorenkos-conjecture-September-23-2026/paper.pdf)
+
+## Scope
+
+Sidorenko's conjecture predicts that every bipartite graph $H$ has homomorphism density at least the host graph's edge density raised to $|E(H)|$. The formalization disproves this for the paper's fixed bipartite graph with $35$ vertices and $66$ edges: it constructs a nonempty finite simple host graph with $t(H,G)<t(K_2,G)^{66}$. The separate forcing-conjecture consequence in the paper is outside this statement.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Counterexample to Sidorenko's conjecture | [SidorenkoCounterexample.lean](../ComparatorChallenges/SidorenkoCounterexample.lean) |
diff --git a/lean/docs/162.md b/lean/docs/162.md
new file mode 100644
index 0000000000000000000000000000000000000000..598ccda6d875af9faf2e568589d074a00960b683
--- /dev/null
+++ b/lean/docs/162.md
@@ -0,0 +1,20 @@
+# Counterexamples to Ryser’s covering conjecture
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [Balanced counterexamples to Ryser's conjecture at prime orders](../../preprints/Balanced-Counterexamples-to-Rysers-Conjecture-at-Prime-Orders-September-27-2026/paper.pdf)
+- [A counterexample to Ryser's covering conjecture](../../preprints/A-Counterexample-to-Rysers-Covering-Conjecture-September-23-2026/paper.pdf)
+
+## Scope
+
+Ryser's covering conjecture predicts that an intersecting $r$-partite hypergraph has a vertex cover of size at most $r-1$. The formalization proves that every sufficiently large prime $q$ has a finite intersecting $(q+1)$-partite, $(q+1)$-uniform hypergraph with covering number $q+1$ and exactly $q+1$ nonisolated vertices in each part. Thus the conjecture fails even with equal part sizes. The prime threshold is existential.
+
+Ryser's covering conjecture predicts $\tau\le(r-1)\nu$ for an $r$-partite hypergraph, where $\tau$ and $\nu$ are its covering and matching numbers. The formalized constructions give finite intersecting $r$-partite $r$-uniform hypergraphs with $\nu=1$ and $\tau=r$, contradicting the bound. The ranks have the form $r=p^n+1$: one fixed prime $p\equiv2\pmod3$ works for all sufficiently large prime degrees $n$, and a second result covers every sufficiently large such prime $p$ and every sufficiently large odd $n$, with the degree threshold allowed to depend on $p$. Infinitely many ranks occur. Equal part sizes and numerical thresholds are not asserted.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Balanced Ryser counterexamples at prime orders | [BalancedRyser.lean](../ComparatorChallenges/BalancedRyser.lean) |
+| Fixed-prime Ryser counterexamples | [RyserCovering.lean](../ComparatorChallenges/RyserCovering.lean) |
+| Counterexamples in odd extension degrees | [RyserOddExtensions.lean](../ComparatorChallenges/RyserOddExtensions.lean) |
diff --git a/lean/docs/165.md b/lean/docs/165.md
new file mode 100644
index 0000000000000000000000000000000000000000..d1c66893a3231ff441debc59f677bc027e6eea99
--- /dev/null
+++ b/lean/docs/165.md
@@ -0,0 +1,19 @@
+# The Harary–Hill and Zarankiewicz crossing-number formulas
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [The crossing number of complete graphs](../../preprints/The-crossing-number-of-complete-graphs-September-23-2026/paper.pdf)
+- [The crossing number of complete bipartite graphs](../../preprints/The-crossing-number-of-complete-bipartite-graphs-September-23-2026/paper.pdf)
+
+## Scope
+
+The formalized result proves Hill's proposed formula for the crossing number of the complete graph: for every $n\ge3$, $\mathrm{cr}(K_n)=\frac14\lfloor n/2\rfloor\lfloor(n-1)/2\rfloor\lfloor(n-2)/2\rfloor\lfloor(n-3)/2\rfloor$. It proves the lower bound and constructs a matching two-page drawing. Crossings are spatial points, so repeated crossings of one edge pair count separately.
+
+Zarankiewicz's crossing-number conjecture predicts $\mathrm{cr}(K_{m,n})=\lfloor m/2\rfloor\lfloor(m-1)/2\rfloor\lfloor n/2\rfloor\lfloor(n-1)/2\rfloor$. The formalized result proves this equality for every positive $m,n$ and constructs a drawing attaining it. Crossings are counted as spatial points for continuous simple edge paths, including repeated crossings between the same pair of edges.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Crossing number of complete graphs | [CompleteCrossing.lean](../ComparatorChallenges/CompleteCrossing.lean) |
+| Crossing number of complete bipartite graphs | [BipartiteCrossing.lean](../ComparatorChallenges/BipartiteCrossing.lean) |
diff --git a/lean/docs/167.md b/lean/docs/167.md
new file mode 100644
index 0000000000000000000000000000000000000000..80d4f1e938e4e1f6dd01ca0a4aaa5c52548967f1
--- /dev/null
+++ b/lean/docs/167.md
@@ -0,0 +1,19 @@
+# Planar distinct distances and unit-distance bounds
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [The weak pinned planar distance theorem](../../preprints/The-weak-pinned-planar-distance-theorem-September-23-2026/paper.pdf)
+- [A power saving for planar unit distances](../../preprints/A-power-saving-for-planar-unit-distances-September-23-2026/paper.pdf)
+
+## Scope
+
+The formalized result shows that large repeated distance fibers are rare in arbitrary finite planar point sets. For each fixed $s>0$, the largest possible fraction of ordered distinct pairs $(x,y)$ whose distance from the pin $x$ occurs at least $n^s$ times tends to zero as the set size $n$ grows. Consequently, for every $\varepsilon>0$, the fraction of pins determining fewer than $n^{1-\varepsilon}$ distances tends uniformly to zero. The separate unit-distance power-saving theorem is not included.
+
+The planar unit-distance problem asks how many pairs at distance one can occur among $n$ points. The formalization proves that there are absolute constants $C>0$ and $1\le\beta<4/3$ such that every finite planar point set of size $n$ determines at most $Cn^\beta$ unordered unit-distance pairs. The same constants work for every $n$, giving a fixed power improvement over the classical exponent $4/3$.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Weak pinned planar distance theorem | [PinnedDistances.lean](../ComparatorChallenges/PinnedDistances.lean) |
+| Power saving for planar unit distances | [PlanarUnitDistances.lean](../ComparatorChallenges/PlanarUnitDistances.lean) |
diff --git a/lean/docs/168.md b/lean/docs/168.md
new file mode 100644
index 0000000000000000000000000000000000000000..d6bf4f12eaf16fc2349404e3968ff377349f7a38
--- /dev/null
+++ b/lean/docs/168.md
@@ -0,0 +1,15 @@
+# Combinatorial invariance of Kazhdan–Lusztig polynomials
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [Combinatorial invariance of Kazhdan–Lusztig polynomials](../../preprints/Combinatorial-Invariance-of-Kazhdan-Lusztig-Polynomials-September-24-2026/paper.pdf)
+
+## Scope
+
+The combinatorial invariance conjecture asks whether a Kazhdan–Lusztig polynomial depends only on its Bruhat interval as an ordered set. The formalization proves that every order isomorphism between Bruhat intervals in arbitrary Coxeter systems preserves the corresponding equal-parameter Kazhdan–Lusztig polynomial. The two intervals may come from different Coxeter systems.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Combinatorial invariance of Kazhdan–Lusztig polynomials | [KLInvariance.lean](../ComparatorChallenges/KLInvariance.lean) |
diff --git a/lean/docs/169.md b/lean/docs/169.md
new file mode 100644
index 0000000000000000000000000000000000000000..037ec3c66c790afa2cc0605a0797409e2f5c3679
--- /dev/null
+++ b/lean/docs/169.md
@@ -0,0 +1,15 @@
+# Shareshian–Wachs elementary positivity
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [Elementary positivity of chromatic quasisymmetric functions](../../preprints/Elementary-Positivity-of-Chromatic-Quasisymmetric-Functions-September-24-2026/paper.pdf)
+
+## Scope
+
+The elementary-positivity part of the Shareshian–Wachs conjecture asks whether the chromatic quasisymmetric function of every natural unit interval graph has nonnegative coefficients in the elementary basis. The formalization proves this over $\mathbb N[q]$. It constructs an explicit elementary-basis expansion indexed by the graph's permitted nondescent permutations, with each term weighted by a nonnegative power of $q$ determined by its graph inversions. The expansion holds for every finite number of color variables.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Elementary positivity for natural unit interval graphs | [ElementaryPositivity.lean](../ComparatorChallenges/ElementaryPositivity.lean) |
diff --git a/lean/docs/170.md b/lean/docs/170.md
new file mode 100644
index 0000000000000000000000000000000000000000..70efd2165a2a8641719db2d532ec88a72e5eb56e
--- /dev/null
+++ b/lean/docs/170.md
@@ -0,0 +1,23 @@
+# Sharp logarithmic exponents for off-diagonal Ramsey numbers
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [The sharp logarithmic exponent of $r(5,t)$](../../preprints/The-Sharp-Logarithmic-Exponent-of-r-5-t-September-24-2026/paper.pdf)
+- [Sharp Logarithmic Exponents for Fixed Off-Diagonal Ramsey Numbers](../../preprints/Sharp-Logarithmic-Exponents-for-Fixed-Off-Diagonal-Ramsey-Numbers-September-24-2026/paper.pdf)
+
+## Scope
+
+The formalization determines the sharp logarithmic exponent of the off-diagonal Ramsey number $r(5,t)$. It proves
+$r(5,t)=t^4/(\log t)^{3+o(1)}$ as $t\to\infty$.
+For every $\varepsilon>0$, the lower bound $t^4/(\log t)^{3+\varepsilon}$ holds eventually, while the upper bound is $Ct^4/(\log t)^3$ for an absolute $C>0$. The corresponding logarithmic exponent converges to three along all natural values of $t$.
+
+The formalization determines the sharp logarithmic exponent of the off-diagonal Ramsey number for every fixed integer $s\ge6$. It proves
+$r(s,t)=t^{s-1}/(\log t)^{s-2+o(1)}$ as $t\to\infty$.
+More explicitly, for each $\varepsilon>0$ the lower bound $t^{s-1}/(\log t)^{s-2+\varepsilon}$ holds eventually, while the upper bound is $C_s t^{s-1}/(\log t)^{s-2}$. The logarithmic exponent limit is taken along all natural values of $t$.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Sharp logarithmic exponent of $r(5,t)$ | [RamseyFive.lean](../ComparatorChallenges/RamseyFive.lean) |
+| Sharp logarithmic exponent for fixed off-diagonal Ramsey numbers | [SharpLogRamsey.lean](../ComparatorChallenges/SharpLogRamsey.lean) |
diff --git a/lean/docs/172.md b/lean/docs/172.md
new file mode 100644
index 0000000000000000000000000000000000000000..66a70def5fdc63c39958196e5bfd3902f7f19dd0
--- /dev/null
+++ b/lean/docs/172.md
@@ -0,0 +1,23 @@
+# Classification of finite Euclidean Ramsey configurations
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [A classification of finite Euclidean Ramsey configurations](../../preprints/A-classification-of-finite-Euclidean-Ramsey-configurations-September-23-2026/paper.pdf)
+
+## Scope
+
+A finite configuration is Euclidean Ramsey if every finite coloring of some sufficiently high-dimensional Euclidean space contains a monochromatic congruent copy at the original scale. The formalization gives the tensor-field classification for full-affine-span configurations, covers singleton and affine-span reductions, and proves that every Ramsey configuration is cospherical. It also proves that every nonempty subset of a finite transitive configuration and every nonempty set of at most five points on a circle is Ramsey. A further sufficient condition uses linear independence of the quadratic evaluation rows of a spherical configuration.
+
+The formalization also gives spherical non-Ramsey examples: the specified twelve-point set on the unit circle has a fifty-color obstruction in every positive dimension, and a nine-point circle configuration built from algebraically independent parameters is non-Ramsey.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Tensor-field classification of Ramsey configurations | [EuclideanRamsey.lean](../ComparatorChallenges/EuclideanRamsey.lean) |
+| Twelve-point spherical non-Ramsey example | [GrahamSpherical.lean](../ComparatorChallenges/GrahamSpherical.lean) |
+| Ramsey property for at most five circle points | [EuclideanRamseyCircle.lean](../ComparatorChallenges/EuclideanRamseyCircle.lean) |
+| Nine-point non-Ramsey circle configuration | [EuclideanRamseyNine.lean](../ComparatorChallenges/EuclideanRamseyNine.lean) |
+| Quadratic-independence criterion for spherical configurations | [EuclideanRamseyQuadratic.lean](../ComparatorChallenges/EuclideanRamseyQuadratic.lean) |
+| Cosphericity of Ramsey configurations | [EuclideanRamseySpherical.lean](../ComparatorChallenges/EuclideanRamseySpherical.lean) |
+| Ramsey property for subsets of finite transitive configurations | [EuclideanRamseyTransitive.lean](../ComparatorChallenges/EuclideanRamseyTransitive.lean) |
diff --git a/lean/docs/173.md b/lean/docs/173.md
new file mode 100644
index 0000000000000000000000000000000000000000..38e8d827cd569edeb886d9676ff1233fbf0954b7
--- /dev/null
+++ b/lean/docs/173.md
@@ -0,0 +1,15 @@
+# Seymour’s second-neighborhood conjecture
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [A proof of Seymour’s second-neighborhood conjecture](../../preprints/A-proof-of-Seymours-second-neighborhood-conjecture-September-23-2026/paper.pdf)
+
+## Scope
+
+Seymour's second-neighborhood conjecture asserts that every nonempty finite oriented graph has a vertex with at least as many second out-neighbors as first out-neighbors. The formalized result proves this assertion, where the second neighborhood consists of vertices at directed distance exactly two. The initial vertex and first neighbors are excluded from that count, and sinks are included.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Seymour's second-neighborhood conjecture | [SeymourSecondNeighborhood.lean](../ComparatorChallenges/SeymourSecondNeighborhood.lean) |
diff --git a/lean/docs/174.md b/lean/docs/174.md
new file mode 100644
index 0000000000000000000000000000000000000000..dc0a54c1b723e552d9a14074959e8cecb67bd4cb
--- /dev/null
+++ b/lean/docs/174.md
@@ -0,0 +1,19 @@
+# Deterministic construction of strong thin spanning trees
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [The strong thin tree conjecture](../../preprints/The-strong-thin-tree-conjecture-September-23-2026/paper.pdf)
+- [A polynomial-time construction of strong thin trees](../../preprints/A-polynomial-time-construction-of-strong-thin-trees-September-23-2026/paper.pdf)
+
+## Scope
+
+The strong thin-tree conjecture asks for spanning trees that cross every cut sparsely relative to the original graph. The formalized result gives one absolute constant $C>0$ such that every finite loopless $k$-edge-connected multigraph with at least two vertices has a spanning tree crossing each nontrivial cut at most $(C/k)$ times the original cut size. Parallel edges remain distinct. No numerical value of $C$ or construction algorithm is asserted.
+
+The strong thin-tree problem asks for a spanning tree that crosses every cut sparsely relative to the original graph. The formalization gives one deterministic polynomial-time algorithm and an absolute constant $C>0$ such that a finite $k$-edge-connected loopless multigraph yields a spanning tree using at most a $C/k$ fraction of the edges of every cut. The input may encode parallel-edge multiplicities in binary, and the running time is polynomial in that binary input length.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Strong thin-tree bound | [StrongThinTree.lean](../ComparatorChallenges/StrongThinTree.lean) |
+| Polynomial-time construction of strong thin trees | [AlgorithmicThinTrees.lean](../ComparatorChallenges/AlgorithmicThinTrees.lean) |
diff --git a/lean/docs/175.md b/lean/docs/175.md
new file mode 100644
index 0000000000000000000000000000000000000000..2581424d3537de485e06c66c7b61061dda32f245
--- /dev/null
+++ b/lean/docs/175.md
@@ -0,0 +1,19 @@
+# Talagrand’s expectation thresholds, discrete convexity, and graph decompositions
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [Integral and fractional expectation thresholds are equivalent](../../preprints/Integral-and-fractional-expectation-thresholds-are-equivalent-September-23-2026/paper.pdf)
+- [Talagrand's discrete-convexity conjecture](../../preprints/Talagrands-discrete-convexity-conjecture-September-23-2026/paper.pdf)
+
+## Scope
+
+Talagrand's expectation-threshold conjecture asks whether the fractional and integral expectation thresholds are comparable by an absolute constant. The formalized result proves $q_f(\mathcal F)\le25\cdot512^4 q(\mathcal F)$ for every nonempty proper increasing family on a finite nonempty ground set. Both thresholds use cover budget $1/2$, and fractional covers may assign weights to every subset, including the empty set.
+
+The formalized result proves Talagrand's discrete-convexity assertion with $k=2^{75}$. If a family of subsets of a finite nonempty ground set has Bernoulli-$p$ measure at least $1-1/k$, then the sets not contained in a union of $k$ members form a $p$-small family: they have a containment cover of total $p$-cost at most $1/2$. This holds for every $0<p<1$, with repeated members allowed in the union and no monotonicity assumption.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Integral–fractional expectation-threshold comparison | [TalagrandExpectationThreshold.lean](../ComparatorChallenges/TalagrandExpectationThreshold.lean) |
+| Talagrand discrete convexity | [TalagrandDiscreteConvexity.lean](../ComparatorChallenges/TalagrandDiscreteConvexity.lean) |
diff --git a/lean/docs/176.md b/lean/docs/176.md
new file mode 100644
index 0000000000000000000000000000000000000000..34826829a666fbf5a4bfb42b37a62f99b0d9879b
--- /dev/null
+++ b/lean/docs/176.md
@@ -0,0 +1,15 @@
+# The second Kahn–Kalai conjecture with an edge-count bound
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [The second Kahn–Kalai conjecture](../../preprints/The-second-Kahn-Kalai-conjecture-September-24-2026/paper.pdf)
+
+## Scope
+
+The second Kahn–Kalai conjecture compares the threshold for a random graph to contain a fixed graph with its expectation threshold. The formalized result proves the comparison up to a universal factor times $1+\log_2|E(H)|$, and hence up to a universal factor times $\log_2 n$, for every graph $H$ with at least one edge and at most $n$ vertices, $n\ge2$. The bounds use the actual containment and expectation thresholds.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Second Kahn–Kalai threshold bounds | [SecondKahnKalai.lean](../ComparatorChallenges/SecondKahnKalai.lean) |
diff --git a/lean/docs/177.md b/lean/docs/177.md
new file mode 100644
index 0000000000000000000000000000000000000000..efef27c9fdf619c09aa3531d446b816157e6f343
--- /dev/null
+++ b/lean/docs/177.md
@@ -0,0 +1,15 @@
+# Bounded-degree coboundary expanders
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [Bounded-degree coboundary expanders in every dimension](../../preprints/Bounded-degree-coboundary-expanders-in-every-dimension-September-24-2026/paper.pdf)
+
+## Scope
+
+The formalization constructs bounded-degree $\mathbb F_2$ coboundary expanders in every dimension $d\ge3$. For each such $d$, it gives finite pure connected $d$-dimensional simplicial complexes with vertex counts tending to infinity, one uniform bound on top-dimensional degree at each vertex, and one positive coboundary-expansion constant in every degree below $d$. The constants may depend on $d$. The graph and two-dimensional cases used for the paper's all-positive-dimensions conclusion are separate.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Bounded-degree coboundary expanders in dimensions at least three | [CoboundaryExpanders.lean](../ComparatorChallenges/CoboundaryExpanders.lean) |
diff --git a/lean/docs/179.md b/lean/docs/179.md
new file mode 100644
index 0000000000000000000000000000000000000000..cad4e960f7f27bbe5296d34ced66b8e4d38fdf00
--- /dev/null
+++ b/lean/docs/179.md
@@ -0,0 +1,18 @@
+# The circulant Hadamard and Barker-sequence conjectures
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [The circulant Hadamard conjecture](../../preprints/The-circulant-Hadamard-conjecture-September-23-2026/paper.pdf)
+
+## Scope
+
+The formalization proves the circulant Hadamard conjecture in exact form: a real circulant Hadamard matrix of positive order $n$ exists exactly when $n=1$ or $n=4$. Explicit witnesses are supplied for both orders, with no restriction on prime factors.
+
+It also proves the even-length part of the Barker-sequence consequence. A positive even-length sign sequence whose nonzero aperiodic autocorrelations have absolute value at most one must have length $2$ or $4$. The paper's classification of odd Barker lengths is outside this selected additional statement.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Classification of circulant Hadamard orders | [CirculantHadamard.lean](../ComparatorChallenges/CirculantHadamard.lean) |
+| Classification of positive even Barker lengths | [EvenBarker.lean](../ComparatorChallenges/EvenBarker.lean) |
diff --git a/lean/docs/180.md b/lean/docs/180.md
new file mode 100644
index 0000000000000000000000000000000000000000..363c429fd9073e01ef1c9f8380a22520ca2293d8
--- /dev/null
+++ b/lean/docs/180.md
@@ -0,0 +1,15 @@
+# Barnette’s Hamiltonian-cycle conjecture
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [Paired states and Hamiltonian cycles in cubic bipartite planar graphs](../../preprints/Paired-states-and-Hamiltonian-cycles-in-cubic-bipartite-planar-graphs-September-24-2026/paper.pdf)
+
+## Scope
+
+Barnette's conjecture states that every finite simple cubic bipartite planar graph that is 3-vertex-connected has a Hamiltonian cycle. The formalization proves this statement for every such graph. The selected result is the existence of a cycle visiting every vertex exactly once.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Barnette's Hamiltonian-cycle conjecture | [BarnetteHamiltonian.lean](../ComparatorChallenges/BarnetteHamiltonian.lean) |
diff --git a/lean/docs/181.md b/lean/docs/181.md
new file mode 100644
index 0000000000000000000000000000000000000000..fe08fad8c7a44fba560968f504f41f8efb8a52da
--- /dev/null
+++ b/lean/docs/181.md
@@ -0,0 +1,15 @@
+# The Erdős–Gallai cycle-decomposition conjecture
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [A linear cycle-and-edge decomposition of every graph](../../preprints/A-linear-cycle-and-edge-decomposition-of-every-graph-September-24-2026/main.pdf)
+
+## Scope
+
+The Erdős–Gallai cycle-decomposition conjecture asks for a linear bound on the number of cycles and single edges needed to partition a graph's edges. The formalized result gives one absolute constant $C>0$ such that every finite simple graph on $n$ vertices has an edge-disjoint decomposition into at most $Cn$ cycles or singleton edges. Edgeless and small graphs are included. The optimal value of $C$ is not determined.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Linear cycle-and-edge decomposition | [CycleDecomposition.lean](../ComparatorChallenges/CycleDecomposition.lean) |
diff --git a/lean/docs/182.md b/lean/docs/182.md
new file mode 100644
index 0000000000000000000000000000000000000000..a45c46f701d1428a9006f9082fa583f7093af5db
--- /dev/null
+++ b/lean/docs/182.md
@@ -0,0 +1,15 @@
+# Power savings for intersective polynomial differences and prime arguments
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [A power saving for square-difference-free sets](../../preprints/A-power-saving-for-square-difference-free-sets-September-24-2026/paper.pdf)
+
+## Scope
+
+The formalization proves a fixed power saving for sets with no nonzero square difference. There are absolute constants $c>0$ and $C$ such that every $A\subseteq\{1,\ldots,N\}$ satisfying $a-b\ne m^2$ for all $a,b\in A$ and integers $m\ge1$ has $|A|\le C N^{1-c}$. The bound is uniform for every integer $N\ge1$.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Power saving for square-difference-free sets | [SquareDifference.lean](../ComparatorChallenges/SquareDifference.lean) |
diff --git a/lean/docs/183.md b/lean/docs/183.md
new file mode 100644
index 0000000000000000000000000000000000000000..077bcb09f6324eb726c7b9846488743423e9ca48
--- /dev/null
+++ b/lean/docs/183.md
@@ -0,0 +1,15 @@
+# Power savings for planar halving lines and <i>k</i>-sets
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [A power saving for planar halving lines](../../preprints/A-power-saving-for-planar-halving-lines-September-25-2026/main.pdf)
+
+## Scope
+
+A halving pair in an even planar point set is a pair whose line leaves equally many remaining points on each side. The formalization proves that some absolute $\varepsilon>0$ and $C$ bound the number of halving pairs by $Cn^{4/3-\varepsilon}$ for every sufficiently large even $n$ and every $n$-point set with no three collinear. It also proves a bound of the same form for all level-switch counts under the additional generic-position assumptions in the statement. The constants are existential.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Power-saving bounds for halving pairs and level switches | [HalvingLines.lean](../ComparatorChallenges/HalvingLines.lean) |
diff --git a/lean/docs/184.md b/lean/docs/184.md
new file mode 100644
index 0000000000000000000000000000000000000000..59862f0ef15197701c8fe6c3d7ce806999fbdf63
--- /dev/null
+++ b/lean/docs/184.md
@@ -0,0 +1,15 @@
+# Correspondence coloring with a fixed forbidden subgraph
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [A logarithmic independence bound for clique-free graphs](../../preprints/A-Logarithmic-Independence-Bound-for-Clique-Free-Graphs-September-25-2026/paper.pdf)
+
+## Scope
+
+The formalized result gives a logarithmic improvement in the independence number of clique-free graphs. For every fixed integer $r\ge4$, there is $c_r>0$ such that every finite $K_r$-free simple graph on $n$ vertices with average degree $d\ge2$ has an independent set of size at least $c_r n\log d/d$. The constant depends only on $r$.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Logarithmic independence bound for clique-free graphs | [CliqueFreeLog.lean](../ComparatorChallenges/CliqueFreeLog.lean) |
diff --git a/lean/docs/185.md b/lean/docs/185.md
new file mode 100644
index 0000000000000000000000000000000000000000..6ffdda41e9b510aa3e774924146227fc853fce77
--- /dev/null
+++ b/lean/docs/185.md
@@ -0,0 +1,18 @@
+# Counterexamples to infinite matroid intersection and packing/covering
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [A Counterexample to the Infinite Matroid Packing/Covering Conjecture](../../preprints/A-Counterexample-to-the-Infinite-Matroid-Packing-Covering-Conjecture-September-24-2026/paper.pdf)
+
+## Scope
+
+The infinite matroid packing/covering conjecture predicts a partition of a common ground set into parts admitting the corresponding packing and covering. The formalization constructs two self-dual partitional matroids on one countably infinite ground set that admit neither an independent covering nor a packing/covering partition. The same pair has no intersection witness, so it also refutes the unrestricted infinite matroid intersection conjecture.
+
+Separate formalized consequences give counterexamples to the individual covering and packing conjectures. The construction is in ordinary set theory with Choice and assumes no finitary restriction on the matroids.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Infinite matroid packing/covering counterexample | [InfiniteMatroid.lean](../ComparatorChallenges/InfiniteMatroid.lean) |
+| Partitional intersection, covering, and packing counterexamples | [InfiniteMatroidCorollaries.lean](../ComparatorChallenges/InfiniteMatroidCorollaries.lean) |
diff --git a/lean/docs/186.md b/lean/docs/186.md
new file mode 100644
index 0000000000000000000000000000000000000000..d3a23b263256b152d43fe6db36b04a2b390b323b
--- /dev/null
+++ b/lean/docs/186.md
@@ -0,0 +1,15 @@
+# Uniform influence and sharp thresholds for graph and hypergraph properties
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [A Sharp Threshold Bound for Monotone Graph Properties](../../preprints/A-Sharp-Threshold-Bound-for-Monotone-Graph-Properties-September-25-2026/paper.pdf)
+
+## Scope
+
+The Friedgut–Kalai sharp-threshold conjecture concerns how quickly a nontrivial increasing graph property appears in the independent-edge random graph. For every $n\ge2$, every such property invariant under vertex relabeling, and $0<\varepsilon<1/2$, the formalization proves that the edge-probability interval between probabilities $\varepsilon$ and $1-\varepsilon$ has width at most $2^{19}\log(1/(2\varepsilon))/(\log n)^2$. The constant is uniform over the graph property, $n$, and $\varepsilon$.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Sharp threshold width for monotone graph properties | [SharpThreshold.lean](../ComparatorChallenges/SharpThreshold.lean) |
diff --git a/lean/docs/187.md b/lean/docs/187.md
new file mode 100644
index 0000000000000000000000000000000000000000..b377da7e6be6705d5a7c8863b42d389f1eeecc58
--- /dev/null
+++ b/lean/docs/187.md
@@ -0,0 +1,19 @@
+# Snaky in 21 Maker moves
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [Snaky in 21 Maker moves](../../preprints/Snaky-in-21-Maker-moves-September-25-2026/article.pdf)
+
+## Scope
+
+In the Snaky Maker–Breaker game, the players alternately claim cells of $\mathbb Z^2$, and Maker seeks a translated, rotated, or reflected copy of the six-cell Snaky shape. The formalization gives a legal strategy that wins within $21$ actual Maker moves against every legal Breaker play from the empty infinite board. The selected theorem checks disjointness and the move counts throughout play; it does not impose the paper's smaller finite-board restriction.
+
+The linked supplements reconstruct the older $35$-move appendix's finite recursive certificate and prove four conditional winning templates from partial positions, assuming the required Maker cells are present and Breaker avoids the corresponding finite envelope.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Reconstruction of the 35-move Snaky certificate | [SnakyCertificate.lean](../ComparatorChallenges/SnakyCertificate.lean) |
+| Conditional winning templates from finite partial positions | [SnakyConditional.lean](../ComparatorChallenges/SnakyConditional.lean) |
+| Legal Snaky winning strategy within 21 Maker moves | [SnakyTwentyOne.lean](../ComparatorChallenges/SnakyTwentyOne.lean) |
diff --git a/lean/docs/188.md b/lean/docs/188.md
new file mode 100644
index 0000000000000000000000000000000000000000..6248f894d584d7acb2c07fd8e6856fef5663fa33
--- /dev/null
+++ b/lean/docs/188.md
@@ -0,0 +1,15 @@
+# The sharp terminal leave in random triangle removal
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [The sharp terminal leave in random triangle removal](../../preprints/The-Sharp-Terminal-Leave-in-Random-Triangle-Removal-September-25-2026/The-Sharp-Terminal-Leave-in-Random-Triangle-Removal-September-25-2026.pdf)
+
+## Scope
+
+Start with the complete graph on $n$ vertices and repeatedly delete the three edges of a uniformly chosen remaining triangle. The formalization proves that the number of edges at termination, divided by $n^{3/2}$, converges in $L^2$ to $1/(2\sqrt2)$. It also states convergence in probability and convergence of the normalized expectation to the same constant. This is the triangle case of the sharp terminal-leave conjecture of Joos and Kühn.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Sharp terminal edge count in random triangle removal | [TriangleRemoval.lean](../ComparatorChallenges/TriangleRemoval.lean) |
diff --git a/lean/docs/189.md b/lean/docs/189.md
new file mode 100644
index 0000000000000000000000000000000000000000..5207b2ad41a9539b6725aff03cb19cf454fa3c31
--- /dev/null
+++ b/lean/docs/189.md
@@ -0,0 +1,15 @@
+# Cycle–clique Ramsey numbers
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [Cycle–clique Ramsey numbers](../../preprints/Cycle-clique-Ramsey-numbers-September-25-2026/Cycle-clique-Ramsey-numbers-September-25-2026.pdf)
+
+## Scope
+
+The cycle–clique Ramsey conjecture predicts the exact number of vertices forcing either a cycle $C_m$ or a clique $K_n$ in complementary colors. The formalization proves $R(C_m,K_n)=(m-1)(n-1)+1$ for all integers $m\ge n\ge3$ except $(m,n)=(3,3)$, where it proves $R(C_3,K_3)=6$. This is the complete parameter range of the paper's main theorem.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Exact cycle–clique Ramsey numbers | [CycleCliqueRamsey.lean](../ComparatorChallenges/CycleCliqueRamsey.lean) |
diff --git a/lean/docs/190.md b/lean/docs/190.md
new file mode 100644
index 0000000000000000000000000000000000000000..9d0213bb8054aaa90a0c7fbd0b5265be4e04252a
--- /dev/null
+++ b/lean/docs/190.md
@@ -0,0 +1,15 @@
+# Polynomial removal fails for ordered binary matrices
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [Polynomial removal fails for ordered binary matrices](../../preprints/Polynomial-removal-fails-for-ordered-binary-matrices-September-25-2026/paper.pdf)
+
+## Scope
+
+The formalized result disproves a polynomial removal bound for one explicit $66\times66$ binary pattern. For every $c,C>0$, there is an $n\times n$ binary matrix at normalized edit distance at least $\varepsilon>0$ from being pattern-free but with fewer than $c\varepsilon^C n^{132}$ induced ordered copies. Row and column indices are independently increasing, and every zero and one entry must match. The construction gives an explicit sequence of such matrices, allowing edits in both directions.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Failure of polynomial removal for ordered binary matrices | [MatrixRemoval.lean](../ComparatorChallenges/MatrixRemoval.lean) |
diff --git a/lean/docs/191.md b/lean/docs/191.md
new file mode 100644
index 0000000000000000000000000000000000000000..a5283c33fc583d652323a427f75c7b6594de0076
--- /dev/null
+++ b/lean/docs/191.md
@@ -0,0 +1,15 @@
+# A power improvement in the Heilbronn triangle lower bound
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [A power improvement in the Heilbronn triangle lower bound](../../preprints/A-power-improvement-in-the-Heilbronn-triangle-lower-bound-September-25-2026/main.pdf)
+
+## Scope
+
+Heilbronn's triangle problem asks how large the smallest triangle determined by $n$ points in the unit square can be. The formalization constructs an unbounded sequence of sizes $n$ and point sets for which every triangle has area at least $n^{-2+\eta}$, for one fixed $\eta>0$. It consequently refutes the proposed upper bound of order $n^{-2+\varepsilon}$ for every $\varepsilon>0$. The linked construction is for an unbounded sequence of sizes; the paper's statement for every sufficiently large $n$ is broader.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Power improvement for the smallest Heilbronn triangle | [HeilbronnTriangle.lean](../ComparatorChallenges/HeilbronnTriangle.lean) |
diff --git a/lean/docs/192.md b/lean/docs/192.md
new file mode 100644
index 0000000000000000000000000000000000000000..718b9748bb6f6e69b7e6d1690d890ad681a238c2
--- /dev/null
+++ b/lean/docs/192.md
@@ -0,0 +1,17 @@
+# Boolean functions violate the square-root degree bound by arbitrary factors
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [Unbounded Violations of the Square-Root Degree Bound](../../preprints/Unbounded-Violations-of-the-Square-Root-Degree-Bound-September-26-2026/Unbounded-Violations-of-the-Square-Root-Degree-Bound-September-26-2026.pdf)
+
+## Scope
+
+The formalization disproves the Gopalan–Servedio square-root degree conjecture by an unbounded factor. For every $C>0$, it gives a nonconstant Boolean function on a finite sign cube for which the sum of its linear Fourier coefficients exceeds $C\sqrt{\deg f}$, where $\deg f$ is its real multilinear degree.
+
+It also proves that the ratio of the sum of the absolute values of those coefficients to $\sqrt{\deg f}$ is unbounded among positive-degree Boolean functions.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Unbounded violations of the square-root Fourier-degree bound | [SquareRootDegree.lean](../ComparatorChallenges/SquareRootDegree.lean) |
diff --git a/lean/docs/194.md b/lean/docs/194.md
new file mode 100644
index 0000000000000000000000000000000000000000..f5bf94172539d9dee7d9534e8d256ad8d65383b6
--- /dev/null
+++ b/lean/docs/194.md
@@ -0,0 +1,17 @@
+# Lech’s multiplicity conjecture
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [Lech's multiplicity conjecture](../../preprints/Lechs-multiplicity-conjecture-September-23-2026/paper.pdf)
+
+## Scope
+
+Lech's multiplicity conjecture compares Hilbert–Samuel multiplicities across flat local maps. The linked formalization covers a supporting characteristic-$p$ comparison over a complete Noetherian local domain $D$: for a complex satisfying the stated short-complex and finite-length homology conditions, its Frobenius multiplicity sequence converges to its Dutta multiplicity, and the Hilbert–Samuel multiplicity of $D$ is at most that Dutta multiplicity.
+
+This selected statement is the complete-domain Dutta comparison. The paper's full flat-local result in arbitrary characteristic is outside it.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Complete-domain Dutta multiplicity comparison | [DuttaDomain.lean](../ComparatorChallenges/DuttaDomain.lean) |
diff --git a/lean/docs/196.md b/lean/docs/196.md
new file mode 100644
index 0000000000000000000000000000000000000000..4f6c9f8a5104ab8169901fb99a56fd12d2de169f
--- /dev/null
+++ b/lean/docs/196.md
@@ -0,0 +1,17 @@
+# A counterexample to Kaplansky’s zero-divisor conjecture
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [A Torsion-Free Group Algebra with Zero Divisors](../../preprints/A-Torsion-Free-Group-Algebra-with-Zero-Divisors-September-23-2026/paper.pdf)
+
+## Scope
+
+Kaplansky's zero-divisor conjecture asserts that the group algebra of a torsion-free group over a field has no zero divisors. The formalized result constructs a finitely presented torsion-free group $G$ and nonzero elements $\alpha,\beta\in\mathbb F_2[G]$ with $\alpha\beta=0$, giving a counterexample.
+
+The same group admits a finite two-dimensional classifying space $K(G,1)$.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Torsion-free group-algebra counterexample | [TorsionFreeZeroDivisors.lean](../ComparatorChallenges/TorsionFreeZeroDivisors.lean) |
diff --git a/lean/docs/197.md b/lean/docs/197.md
new file mode 100644
index 0000000000000000000000000000000000000000..4fea1727a756f9d11ae5470f840000ce1bf70cf2
--- /dev/null
+++ b/lean/docs/197.md
@@ -0,0 +1,36 @@
+# A torsion-free group algebra that is not directly finite
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [A Counterexample to Kaplansky's Direct-Finiteness Conjecture in Characteristic Two](../../preprints/A-Counterexample-to-Kaplanskys-Direct-Finiteness-Conjecture-in-Characteristic-Two-September-23-2026/paper.pdf)
+- [A Counterexample to the Group-Ring Determinant Conjecture](../../preprints/A-Counterexample-to-the-Group-Ring-Determinant-Conjecture-September-23-2026/paper.pdf)
+- [A Counterexample to Kaplansky's Direct-Finiteness Conjecture in Odd Characteristic](../../preprints/A-Counterexample-to-Kaplanskys-Direct-Finiteness-Conjecture-in-Odd-Characteristic-September-26-2026/paper.pdf)
+
+## Scope
+
+Kaplansky's direct-finiteness conjecture asserts that $ab=1$ implies $ba=1$ for $a,b\in K[G]$, for every field $K$ and group $G$. The formalized results construct a finite field of characteristic two and a group algebra violating this implication. One statement records the counterexample for a finitely generated group; the more detailed construction gives a finitely presented group with an element of odd prime order.
+
+The detailed construction also gives a precise recipe for choosing the data and proves that the required search terminates. The further conclusion that the group is nonsofic is outside these statements.
+
+A nonsingular integer matrix has absolute determinant at least $1$. The group-ring Determinant Conjecture extends this bound to matrices over $\mathbb Z[G]$ for every discrete group $G$. If $T_A$ is the operator induced by such a matrix $A$ on finite direct sums of $\ell^2(G)$, and $\mu_A$ is the spectral measure of $T_A^*T_A$ with respect to the group trace, the conjecture asserts
+
+$\displaystyle \int_{(0,\infty)}\log t\,d\mu_A(t)\ge0,$
+
+with the zero spectral atom omitted. For an invertible square matrix, this is equivalent to its Fuglede–Kadison determinant being at least $1$.
+
+The formalized result contradicts that bound. It gives a finitely generated group $G$ and an $n\times n$ matrix over $\mathbb Z[G]$, with $n\ge1$, that is invertible over $\mathbb Q[G]$. Its bounded left-regular operator is invertible and has determinant strictly between $0$ and $1$.
+
+The formalization uses the trace of $\log(T^*T)$ to define the determinant for the invertible operator $T$. The paper's additional spectral-measure integral conclusion is not included.
+
+Kaplansky's direct-finiteness conjecture asserts that $ab=1$ implies $ba=1$ in every group algebra over a field. Let $p$ be the smallest prime divisor of $\bigl(\binom{1200}{600}!\bigr)^2+1$; this prime is odd. The formalized result constructs a field $K$ of order $p^4$, a finitely generated group $G$ with torsion, and elements $a,b$ violating this implication. The associated cellular automaton on all configurations $K^G$ is injective but not surjective.
+
+The formalization also contains fixed-field transfer results, separate from the statement linked below.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Finitely presented characteristic-two counterexample | [KaplanskyFinitelyPresented.lean](../ComparatorChallenges/KaplanskyFinitelyPresented.lean) |
+| Characteristic-two direct-finiteness counterexample | [KaplanskyDirectFiniteness.lean](../ComparatorChallenges/KaplanskyDirectFiniteness.lean) |
+| Group-ring determinant counterexample | [GroupRingDeterminant.lean](../ComparatorChallenges/GroupRingDeterminant.lean) |
+| Prescribed odd-characteristic counterexample | [OddKaplansky.lean](../ComparatorChallenges/OddKaplansky.lean) |
diff --git a/lean/docs/198.md b/lean/docs/198.md
new file mode 100644
index 0000000000000000000000000000000000000000..1541ec451e506dccf14e7f1514fa8cbecdc50408
--- /dev/null
+++ b/lean/docs/198.md
@@ -0,0 +1,18 @@
+# A counterexample to finitistic-dimension finiteness
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [An algebra of infinite little finitistic dimension](../../preprints/An-algebra-of-infinite-little-finitistic-dimension-September-23-2026/paper.pdf)
+
+## Scope
+
+The little finitistic-dimension conjecture predicts that finitely generated modules of finite projective dimension over a fixed finite-dimensional algebra have bounded projective dimensions. The formalized counterexample is a finite-dimensional complex algebra with a finitely generated module of projective dimension at least $2m-2$ and still finite for every $m\ge1$.
+
+A separate formalized result gives a finite-dimensional complex algebra whose little and big finitistic dimensions are infinite on the left and zero on the right. Injectives fail to generate its unbounded derived category on the left and generate it on the right.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Infinite little finitistic dimension | [LittleFinitistic.lean](../ComparatorChallenges/LittleFinitistic.lean) |
+| Left/right finitistic-dimension asymmetry | [FinitisticAsymmetry.lean](../ComparatorChallenges/FinitisticAsymmetry.lean) |
diff --git a/lean/docs/199.md b/lean/docs/199.md
new file mode 100644
index 0000000000000000000000000000000000000000..3f57aa2cfe69c168ccc85b0503ef02f2051a5f79
--- /dev/null
+++ b/lean/docs/199.md
@@ -0,0 +1,23 @@
+# Counterexamples to Auslander–Reiten, Tachikawa and related homological conjectures
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [An explicit counterexample to the Auslander-Reiten conjecture](../../preprints/An-explicit-counterexample-to-the-Auslander-Reiten-conjecture-September-23-2026/paper.pdf)
+- [A counterexample to Tachikawa's second conjecture](../../preprints/A-counterexample-to-Tachikawas-second-conjecture-September-23-2026/paper.pdf)
+
+## Scope
+
+The Auslander–Reiten conjecture predicts that a finitely generated module $M$ over an Artin algebra $A$ is projective if $\mathrm{Ext}^i_A(M,M\oplus A)=0$ for every $i>0$. The formalized counterexample is a finite-dimensional algebra over $k=\mathbb F_2(q,H_1,H_2)$ and a finite-dimensional nonprojective Gorenstein-projective module with this vanishing.
+
+It also establishes $A/\mathrm{rad}\,A\cong k^8$, $(\mathrm{rad}\,A)^4\ne0$, and preservation of the listed properties after every field extension. The Tachikawa companion is separate.
+
+Tachikawa's second conjecture predicts that a finite-dimensional module over a finite-dimensional self-injective algebra is projective if all its positive-degree self-Ext groups vanish. The formalized counterexample gives a finite-dimensional symmetric algebra over $\mathbb F_2(q,H_1,H_2)$ and a finite-dimensional nonprojective module $M$ with $\mathrm{Ext}^i(M,M)=0$ for every $i>0$. Symmetric algebras are self-injective, so this contradicts the conjecture.
+
+The later field-extension, endomorphism-algebra, and related homological consequences are not included.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Auslander–Reiten counterexample | [AuslanderReiten.lean](../ComparatorChallenges/AuslanderReiten.lean) |
+| Tachikawa counterexample | [Tachikawa.lean](../ComparatorChallenges/Tachikawa.lean) |
diff --git a/lean/docs/205.md b/lean/docs/205.md
new file mode 100644
index 0000000000000000000000000000000000000000..22ab925cac1695f0b4a3b06d5b95163cc3ee97c1
--- /dev/null
+++ b/lean/docs/205.md
@@ -0,0 +1,21 @@
+# Saxl’s conjecture and universal tensor squares
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [Universal Tensor Squares for Symmetric Groups](../../preprints/Universal-Tensor-Squares-for-Symmetric-Groups-September-24-2026/main.pdf)
+- [A Cyclic Polytabloid Proof of Saxl's Conjecture](../../preprints/A-Cyclic-Polytabloid-Proof-of-Saxls-Conjecture-September-24-2026/paper.pdf)
+
+## Scope
+
+The formalization proves the universal tensor-square conjecture for symmetric groups in the stated range. For every positive integer $n\notin\{2,4,9\}$, it constructs an irreducible complex representation of $S_n$ whose tensor square contains every irreducible complex representation of $S_n$. Equivalently, all corresponding Kronecker coefficients are positive. The statement also supplies injective intertwining maps for arbitrary finite-dimensional irreducible representations.
+
+Saxl's conjecture asserts that the tensor square of each staircase Specht module contains every irreducible representation of the corresponding symmetric group. The formalization establishes this for every $m\ge1$: if $\rho_m=(m,m-1,\ldots,1)$, then $g(\rho_m,\rho_m,\mu)>0$ for every partition $\mu$ of $m(m+1)/2$.
+
+The stronger claim that every constituent appears in the orbit span of one prescribed tensor is not included.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Universal irreducible tensor squares for symmetric groups | [UniversalTensorSquares.lean](../ComparatorChallenges/UniversalTensorSquares.lean) |
+| Saxl's conjecture | [Saxl.lean](../ComparatorChallenges/Saxl.lean) |
diff --git a/lean/docs/206.md b/lean/docs/206.md
new file mode 100644
index 0000000000000000000000000000000000000000..92f5bd40d2852719dea28d044acd61ee21db4c03
--- /dev/null
+++ b/lean/docs/206.md
@@ -0,0 +1,15 @@
+# Finite lattice representation and undecidability
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [Finite congruence lattices: characterization and undecidability](../../preprints/Finite-Congruence-Lattices-Characterization-and-Undecidability-September-24-2026/paper.pdf)
+
+## Scope
+
+The finite lattice representation problem asks which finite lattices occur as the full congruence lattice of a finite algebra. The formalization proves the paper's colored-graph characterization: a finite nonempty lattice is representable exactly when it admits the specified finite nonempty graph witness, whose edge colors encode the required congruence relations. This selected theorem is the equivalence with the graph criterion; the paper's undecidability and subgroup-interval conclusions are outside it.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Colored-graph criterion for finite congruence lattices | [FiniteCongruenceGraph.lean](../ComparatorChallenges/FiniteCongruenceGraph.lean) |
diff --git a/lean/docs/207.md b/lean/docs/207.md
new file mode 100644
index 0000000000000000000000000000000000000000..e5783e5f14b11a7ea6a5eb0729e2812dfd3e4924
--- /dev/null
+++ b/lean/docs/207.md
@@ -0,0 +1,18 @@
+# The ℓ¹-Bass conjecture for all discrete groups
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [The Bass trace conjecture and the characteristic-zero Kaplansky idempotent conjecture](../../preprints/The-Bass-trace-conjecture-for-complex-group-rings-September-24-2026/The-Bass-trace-conjecture-for-complex-group-rings-September-24-2026.pdf)
+
+## Scope
+
+The formalization proves the complex Bass trace conjecture for every group: the Hattori–Stallings trace of each virtual class of finitely generated projective right $\mathbb C[G]$-modules vanishes on conjugacy classes of infinite-order elements. No finiteness, countability, or geometric hypothesis on $G$ is imposed.
+
+For torsion-free $G$, it identifies the trace on $K_0(\mathbb C[G])$ with the integral augmentation rank and proves the characteristic-zero Kaplansky idempotent conjecture: for every commutative unital domain $R$ of characteristic zero, an idempotent in $R[G]$ is $0$ or $1$.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Complex Bass trace vanishing and support | [BassTrace.lean](../ComparatorChallenges/BassTrace.lean) |
+| Trace rank and characteristic-zero Kaplansky idempotents for torsion-free groups | [BassTorsionFree.lean](../ComparatorChallenges/BassTorsionFree.lean) |
diff --git a/lean/docs/210.md b/lean/docs/210.md
new file mode 100644
index 0000000000000000000000000000000000000000..eab6acd16032a6fcd2273dc431928680975d3cb9
--- /dev/null
+++ b/lean/docs/210.md
@@ -0,0 +1,15 @@
+# Foulkes' conjecture for sixth powers and quadratic stabilization
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [Quadratic stabilization of the canonical Foulkes–Howe map](../../preprints/Quadratic-Stabilization-of-the-Canonical-Foulkes-Howe-Map-September-25-2026/paper.pdf)
+
+## Scope
+
+The formalized result proves surjectivity of the canonical averaged Foulkes–Howe map $\mathrm{Sym}^b(\mathrm{Sym}^a\,V)\to\mathrm{Sym}^a(\mathrm{Sym}^b\,V)$ for every finite-dimensional complex vector space, $a\ge2$, and $b\ge a(a-1)$. It also covers the bijective $a=1$ case, the vanishing-on-products consequence, and the corresponding equivariant embedding in the reverse direction. The sixth-power specialization is covered for $b\ge30$; the companion's full range $b\ge6$ is not included.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Quadratic stabilization of the canonical Foulkes–Howe map | [FoulkesHowe.lean](../ComparatorChallenges/FoulkesHowe.lean) |
diff --git a/lean/docs/211.md b/lean/docs/211.md
new file mode 100644
index 0000000000000000000000000000000000000000..b6a3cc8d15093310ffde4c611750d809d866e9cb
--- /dev/null
+++ b/lean/docs/211.md
@@ -0,0 +1,15 @@
+# The geometric phase diagram, diffusion, and spectra of random planar maps
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [Brownian continuum random tree limits of finite Fortuin–Kasteleyn maps above four](../../preprints/Brownian-continuum-random-tree-limits-of-finite-Fortuin-Kasteleyn-maps-above-four-September-24-2026/main.pdf)
+
+## Scope
+
+For every fixed $q>4$, the formalization proves the Brownian continuum-random-tree limit for critical finite Fortuin–Kasteleyn planar maps. After rescaling graph distances in an $n$-edge map by a constant depending on $q$ times $n^{-1/2}$ and using normalized degree measure, the metric-measure space converges in distribution to the Brownian continuum random tree in the Gromov–Hausdorff–Prokhorov topology. The convergence holds through all positive integer sizes.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Brownian continuum-random-tree limit for finite FK maps | [FKCRT.lean](../ComparatorChallenges/FKCRT.lean) |
diff --git a/lean/docs/212.md b/lean/docs/212.md
new file mode 100644
index 0000000000000000000000000000000000000000..f5a9f6b38dca98f93f03f010a879fb6129fcbce0
--- /dev/null
+++ b/lean/docs/212.md
@@ -0,0 +1,18 @@
+# Planar first-passage geometry and the absence of bigeodesics
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [Strict convexity and differentiability of the planar exponential first-passage limit shape](../../preprints/Strict-convexity-and-differentiability-of-the-planar-exponential-first-passage-limit-shape-September-24-2026/main.pdf)
+
+## Scope
+
+The formalization proves differentiability of the planar first-passage time-constant norm for independent Gamma edge weights of every positive shape and rate. The norm is differentiable away from the origin, and its unit sphere has a $C^1$ boundary. This includes the exponential model, for which the linked statement also gives a unique supporting line at every boundary point.
+
+The paper also claims strict convexity for the exponential limit shape. Strict convexity is outside these selected differentiability statements.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Differentiability of the exponential first-passage limit shape | [PlanarFirstPassage.lean](../ComparatorChallenges/PlanarFirstPassage.lean) |
+| Differentiability for every positive Gamma edge-weight law | [GammaPassage.lean](../ComparatorChallenges/GammaPassage.lean) |
diff --git a/lean/docs/213.md b/lean/docs/213.md
new file mode 100644
index 0000000000000000000000000000000000000000..9eb68659945d33920576e9193f6e3395fe156213
--- /dev/null
+++ b/lean/docs/213.md
@@ -0,0 +1,19 @@
+# Critical percolation on every quasi-transitive graph
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [Critical bond and site percolation on the cubic lattice](../../preprints/Critical-bond-and-site-percolation-on-the-cubic-lattice-September-24-2026/paper.pdf)
+- [No percolation at criticality on quasi-transitive graphs](../../preprints/No-percolation-at-criticality-on-quasi-transitive-graphs-September-24-2026/paper.pdf)
+
+## Scope
+
+The critical-percolation question asks whether an infinite cluster can remain at the threshold. The formalized result proves that, at their respective critical probabilities, nearest-neighbor bond and site percolation on $\mathbb Z^3$ almost surely have no infinite cluster. Equivalently, almost surely every vertex belongs to a finite cluster in each model.
+
+The formalization proves absence of an infinite cluster at criticality for Bernoulli bond percolation on every infinite connected locally finite quasi-transitive graph with critical probability $p_c<1$. At $p=p_c$, the probability that any infinite cluster exists is zero. The graph model permits bond multiplicities.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| No infinite critical clusters on $\mathbb Z^3$ | [CriticalZ3.lean](../ComparatorChallenges/CriticalZ3.lean) |
+| No infinite cluster at the critical probability | [CriticalPercolation.lean](../ComparatorChallenges/CriticalPercolation.lean) |
diff --git a/lean/docs/214.md b/lean/docs/214.md
new file mode 100644
index 0000000000000000000000000000000000000000..e854fc6ca5cac140a538cae03a3a632ceb5717c3
--- /dev/null
+++ b/lean/docs/214.md
@@ -0,0 +1,18 @@
+# The Benjamini–Schramm nonuniqueness conjecture
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [Nonuniqueness of percolation on nonamenable quasi-transitive graphs](../../preprints/Nonuniqueness-of-percolation-on-nonamenable-quasi-transitive-graphs-September-24-2026/paper.pdf)
+
+## Scope
+
+The formalization proves the nonuniqueness phase conjecture for Bernoulli bond percolation on infinite connected locally finite nonamenable quasi-transitive graphs. It establishes $p_c<p_{2\to2}\le p_u$ and a common nonempty coupled interval with infinitely many infinite clusters almost surely. For Cayley graphs, the result holds for every finite symmetric generating set of a nonamenable finitely generated group and every $p\in(p_c,p_u)$.
+
+The selected critical estimates include a finite triangle diagram, susceptibility of order $(p_c-p)^{-1}$, percolation probability of order $p-p_c$, cluster-volume tail of order $n^{-1/2}$, and intrinsic and extrinsic radius tails of order $n^{-1}$. Connection probabilities decay exponentially below $p_{2\to2}$.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Nonuniqueness phase and critical laws on quasi-transitive graphs | [BenjaminiSchramm.lean](../ComparatorChallenges/BenjaminiSchramm.lean) |
+| Nonuniqueness for every nonamenable Cayley graph | [CayleyPercolation.lean](../ComparatorChallenges/CayleyPercolation.lean) |
diff --git a/lean/docs/215.md b/lean/docs/215.md
new file mode 100644
index 0000000000000000000000000000000000000000..3ced0c5a2d64b6d104d0de14aaa55757c62327c8
--- /dev/null
+++ b/lean/docs/215.md
@@ -0,0 +1,15 @@
+# Canonical $`O(3)`$ continuum limit and exact $`O(4)`$ mass asymptotics
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [Exponential decay in two-dimensional classical $O(n)$ models](../../preprints/Exponential-decay-in-two-dimensional-classical-On-models-September-23-2026/paper.pdf)
+
+## Scope
+
+The formalized result proves exponential decay of spin correlations for the two-dimensional classical $O(n)$ model at every temperature when $n\ge3$. For each interaction bound $\beta>0$, constants $A$ and $m>0$ work for every finite square-lattice subgraph with free boundary and nonnegative edge strengths at most $\beta$: the correlation between sites $x,y$ is at most $Ae^{-m|x-y|}$. The infinite-volume limit and the separate $O(4)$ spectral-gap claim are not included.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Exponential correlation decay for classical $O(n)$ models | [ClassicalON.lean](../ComparatorChallenges/ClassicalON.lean) |
diff --git a/lean/docs/218.md b/lean/docs/218.md
new file mode 100644
index 0000000000000000000000000000000000000000..6feb544826f55a49569828ffe41cbbcc197b97f1
--- /dev/null
+++ b/lean/docs/218.md
@@ -0,0 +1,15 @@
+# Conformal universality for weakly interacting and random-bond Ising models
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [Buffered comparison and stopping-band resolution in critical Ising](../../preprints/Buffered-comparison-and-stopping-band-resolution-in-critical-Ising-September-23-2026/paper.pdf)
+
+## Scope
+
+The formalized result compares conditional Ising probabilities on finite graphs when two boundary mixtures differ but a common set of spins is pinned. If $q_0$ is the associated zero-field Fortuin–Kasteleyn connection probability after deleting the pinned vertices, the likelihood ratio lies between $\exp(-4\mathrm{artanh}\,q_0)$ and $\exp(4\mathrm{artanh}\,q_0)$. The statement allows arbitrary external fields and arbitrary probability mixtures satisfying the stated disjointness conditions. The paper's finite stopping-band approximation theorem is outside this selected statement.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Finite-graph buffered Ising likelihood comparison | [BufferedIsing.lean](../ComparatorChallenges/BufferedIsing.lean) |
diff --git a/lean/docs/220.md b/lean/docs/220.md
new file mode 100644
index 0000000000000000000000000000000000000000..359e44da63d12d4fb53d6d1dc0b9605dc79ad48b
--- /dev/null
+++ b/lean/docs/220.md
@@ -0,0 +1,22 @@
+# Directional zero–one laws beyond iid environments and iid ballisticity
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [A directional zero–one law under strict ellipticity](../../preprints/A-directional-zero-one-law-under-strict-ellipticity-September-23-2026/paper.pdf)
+- [Directional transience implies ballisticity](../../preprints/Directional-transience-implies-ballisticity-September-23-2026/paper.pdf)
+
+## Scope
+
+The directional zero–one conjecture asks whether a random walk's probability of escape in a fixed direction must be zero or one. The formalization proves this for nearest-neighbor walks in independent identically distributed strictly elliptic environments on $\mathbb Z^d$, for every $d\ge3$ and every nonzero real direction. Strict ellipticity means that every allowed transition probability is positive almost surely; no uniform positive lower bound or moment condition is assumed. The probability is the annealed law from the origin.
+
+For an i.i.d. uniformly elliptic nearest-neighbor random environment on $\mathbb Z^d$, the formalization proves that almost-sure directional transience implies convergence of $X_n/n$ to a deterministic velocity with positive projection in that direction for every $d\ge2$.
+
+For $d\ge3$, positive probability of transience in any nonzero direction already suffices. The limiting velocity is unique, and the unit directions with positive transience probability are exactly the open hemisphere having positive inner product with that velocity; transience has probability one on that hemisphere and zero on its complement. The environment is sampled once and retained along the walk, and the probabilities use the annealed law from the origin.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Directional zero–one law under strict ellipticity | [DirectionalWalk.lean](../ComparatorChallenges/DirectionalWalk.lean) |
+| Directional transience implies ballisticity | [DirectionalBallisticity.lean](../ComparatorChallenges/DirectionalBallisticity.lean) |
+| Positive-probability transience and the velocity hemisphere | [VelocityHemisphere.lean](../ComparatorChallenges/VelocityHemisphere.lean) |
diff --git a/lean/docs/221.md b/lean/docs/221.md
new file mode 100644
index 0000000000000000000000000000000000000000..860fb28fe29f84d0f802c55fc979d9c92732c8a1
--- /dev/null
+++ b/lean/docs/221.md
@@ -0,0 +1,15 @@
+# The Mézard–Parisi formula for diluted spin glasses
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [The Mézard–Parisi formula for diluted spin glasses](../../preprints/The-Mezard-Parisi-formula-for-diluted-spin-glasses-September-23-2026/paper.pdf)
+
+## Scope
+
+The formalization proves the Mézard–Parisi hierarchical cavity formula for diluted even-arity Ising models in the Panchenko–Talagrand class. Under the class's factorization, independence, integrability, and positivity assumptions, the finite-system pressure converges to the infimum of the trial functional over all finite hierarchy depths and trial laws. The arity is any even integer at least two and the interaction density is positive.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Mézard–Parisi variational equality for diluted even-arity spin glasses | [DilutedSpin.lean](../ComparatorChallenges/DilutedSpin.lean) |
diff --git a/lean/docs/222.md b/lean/docs/222.md
new file mode 100644
index 0000000000000000000000000000000000000000..e5e3b913b789e243430257f54d9e9c5f6378e1b8
--- /dev/null
+++ b/lean/docs/222.md
@@ -0,0 +1,24 @@
+# Perceptron free energies and microscopic jamming exponents
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [The free energy of the Ising random perceptron](../../preprints/The-free-energy-of-the-Ising-random-perceptron-September-24-2026/The-free-energy-of-the-Ising-random-perceptron-September-24-2026.pdf)
+- [The free energy of the spherical random perceptron](../../preprints/The-free-energy-of-the-spherical-random-perceptron-September-24-2026/The-free-energy-of-the-spherical-random-perceptron-September-24-2026.pdf)
+
+## Scope
+
+The linked formalization proves finiteness of the variational value used for the Ising random perceptron. For every nonnegative pattern density and every bounded continuous log-potential, the infimum over admissible overlap paths is a finite real number.
+
+This is a supporting well-definedness result. It does not assert convergence of the finite-system pressure or the paper's extension to all bounded Borel log-potentials.
+
+The formalization proves the variational formula for the spherical random perceptron's limiting pressure for every positive pattern density and inverse temperature and every bounded continuous single-pattern potential. It shows that the variational value is finite and that the pressure converges to it both in expectation and in probability.
+
+The linked spherical-field result supplies a supporting dual formula: finite hierarchy field values converge uniformly on compact parameter sets to an attained dual minimum, and the corresponding bounded stationary-field approximation holds for monotone overlap quantiles bounded away from one.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Finiteness of the Ising-perceptron variational value | [IsingFiniteness.lean](../ComparatorChallenges/IsingFiniteness.lean) |
+| Variational formula for spherical-perceptron pressure | [PerceptronFreeEnergy.lean](../ComparatorChallenges/PerceptronFreeEnergy.lean) |
+| Spherical linear-field dual formula and approximation | [SphericalField.lean](../ComparatorChallenges/SphericalField.lean) |
diff --git a/lean/docs/227.md b/lean/docs/227.md
new file mode 100644
index 0000000000000000000000000000000000000000..ae25f2a4382f1fbc1f0807faa6dc0604ff25f0a1
--- /dev/null
+++ b/lean/docs/227.md
@@ -0,0 +1,34 @@
+# Critical SK autocorrelation processes and dynamics across the temperature transition
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [A spectral gap throughout the high-temperature Sherrington–Kirkpatrick phase](../../preprints/A-spectral-gap-throughout-the-high-temperature-Sherrington-Kirkpatrick-phase-September-24-2026/main.pdf)
+- [Cutoff throughout the high-temperature Sherrington–Kirkpatrick phase](../../preprints/Cutoff-throughout-the-high-temperature-Sherrington-Kirkpatrick-phase-September-24-2026/paper.pdf)
+- [Critical slowing down in the Sherrington–Kirkpatrick model](../../preprints/Critical-slowing-down-in-the-Sherrington-Kirkpatrick-model-September-24-2026/paper.pdf)
+- [Stretched-exponential barriers for typical SK initial states](../../preprints/Stretched-exponential-barriers-for-typical-SK-initial-states-September-24-2026/paper.pdf)
+
+## Scope
+
+For every fixed inverse temperature $0<\beta<1$, the formalization proves a dimension-independent Poincaré inequality for the zero-field Gaussian Sherrington–Kirkpatrick model with probability tending to one over the disorder. Equivalently, the unscaled single-site heat-bath spectral gap stays bounded away from zero. For dynamics that choose one site uniformly at each discrete step, the spectral gap is at least $1/(Cn)$ with probability tending to one, for a constant $C$ depending on $\beta$.
+
+The formalized supporting result proves ratio cutoff for discrete single-site heat-bath dynamics in the zero-field Gaussian Sherrington–Kirkpatrick model for $0\le\beta<1/2$. For every $0<\varepsilon<1/2$ and $\eta>0$, the probability over the disorder that $t_{\mathrm{mix}}(\varepsilon)/t_{\mathrm{mix}}(1-\varepsilon)>1+\eta$ tends to zero as $n\to\infty$. The denominator is positive for all sufficiently large sizes.
+
+The paper's full range $\beta<1$, explicit cutoff location, and continuous-time conclusion are outside this selected statement.
+
+At criticality in the zero-field Sherrington–Kirkpatrick model, the formalization proves that for every fixed $\varepsilon>0$, the continuous-time mixing time lies between $n^{2/3-\varepsilon}$ and $e^{\varepsilon n}$, and the discrete-time mixing count lies between $n^{5/3-\varepsilon}$ and $e^{\varepsilon n}$, with probability tending to one over the Gaussian disorder. The disorder has independent off-diagonal entries of variance $1/n$. Continuous updates have rate one per site; discrete time counts uniformly chosen single-site update attempts. Mixing is worst-start total variation at threshold $1/4$, with holding allowed.
+
+For deterministic times $t_n=o(n^{2/3})$ or update counts $k_n=o(n^{5/3})$, the Gibbs mass of realized starting states still farther than $1/4$ from equilibrium tends to one in probability. For every deterministic positive sequence $M_n\to\infty$, the covariance operator norm and the linear Rayleigh supremum, using the unscaled heat-bath Dirichlet form, both lie between $n^{2/3}/M_n$ and $M_n n^{2/3}$ with probability tending to one. The covariance result does not give an upper bound for the full inverse spectral gap.
+
+The formalization proves a stretched-exponential mixing obstruction for the zero-field Sherrington–Kirkpatrick model at every fixed inverse temperature $\beta>1$. At time $\exp(n^{1/10000})$, the expected Gibbs mass of initial configurations whose total-variation distance from equilibrium exceeds $1/4$ tends to one. Since this mass lies in $[0,1]$, it also tends to one in probability over the disorder.
+
+The result covers both rate-one-per-site continuous-time heat-bath dynamics and the same stated number of discrete update attempts.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Spectral-gap bound throughout the high-temperature SK phase | [SKHighTemperature.lean](../ComparatorChallenges/SKHighTemperature.lean) |
+| Discrete mixing-time ratio cutoff for $\beta<1/2$ | [SKRatio.lean](../ComparatorChallenges/SKRatio.lean) |
+| Critical SK mixing bounds | [CriticalSKMixing.lean](../ComparatorChallenges/CriticalSKMixing.lean) |
+| Equilibrium starts, covariance, and mixing lower bounds | [CriticalSK.lean](../ComparatorChallenges/CriticalSK.lean) |
+| Stretched-exponential barriers from typical equilibrium initial states | [SKBarriers.lean](../ComparatorChallenges/SKBarriers.lean) |
diff --git a/lean/docs/228.md b/lean/docs/228.md
new file mode 100644
index 0000000000000000000000000000000000000000..ade8af3e30f843e21526921ceac88f08e0b9a70c
--- /dev/null
+++ b/lean/docs/228.md
@@ -0,0 +1,22 @@
+# Continuum phase transitions for radial pair potentials
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [A continuum temperature singularity for a radial pair potential](../../preprints/A-continuum-temperature-singularity-for-a-radial-pair-potential-September-24-2026/paper.pdf)
+- [A radial continuum phase transition with algebraic decay](../../preprints/A-radial-continuum-phase-transition-with-algebraic-decay-September-24-2026/paper.pdf)
+
+## Scope
+
+The formalization constructs one stable radial pair potential in three-dimensional continuum space with a divergent repulsive core and an integrable tail that is $o(r^{-3})$. Its canonical free energy exists for every positive inverse temperature and density. At one inverse temperature $\beta_c\in(1/2,3/2)$, the free energy has a strict finite jump between its one-sided derivatives with respect to inverse temperature, for every density in one nonempty open interval.
+
+The formalization constructs a bounded continuous stable radial pair potential in $\mathbb R^3$ satisfying $|\phi(r)|\le Cr^{-3-1/32}$ for $r\ge1$. There is a nonempty open interval of positive densities around $5p/3$, where $p$ is the unit-separated packing-density limit, on which the canonical free energy exists at every positive inverse temperature and has a strict downward derivative jump at one common $\beta_c\in[7/8,9/8]$.
+
+The earlier fixed-density statement at $5p/3$ is also retained. Both statements concern the derivative with respect to inverse temperature.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Temperature singularity over a density interval | [ContinuumTransition.lean](../ComparatorChallenges/ContinuumTransition.lean) |
+| Fixed-density radial continuum phase transition | [RadialTransition.lean](../ComparatorChallenges/RadialTransition.lean) |
+| A common radial phase transition over a density interval | [RadialDensityInterval.lean](../ComparatorChallenges/RadialDensityInterval.lean) |
diff --git a/lean/docs/229.md b/lean/docs/229.md
new file mode 100644
index 0000000000000000000000000000000000000000..627566210a40bd915908ff5fbb4d9923fd226415
--- /dev/null
+++ b/lean/docs/229.md
@@ -0,0 +1,18 @@
+# Exact three- and four-state reconstruction thresholds and four-state tree capacity
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [The exact reconstruction threshold for the three-state symmetric channel](../../preprints/The-exact-reconstruction-threshold-for-the-three-state-symmetric-channel-September-25-2026/paper.pdf)
+
+## Scope
+
+The formalization proves the supercritical direction of reconstruction for the symmetric three-state broadcast channel, whose parameter satisfies $-1/2\le\lambda\le1$. On a regular $b$-ary tree, reconstruction holds when $b\lambda^2>1$; on an observed Poisson Galton–Watson tree of mean $d$, it holds when $d\lambda^2>1$. In each case the root-estimation advantage converges to a positive limit, with the Poisson advantage averaged over trees and spins.
+
+The selected statements cover reconstruction above the Kesten–Stigum threshold. Non-reconstruction at or below the threshold and the stochastic-block-model consequences in the paper are outside them.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Supercritical reconstruction on regular and Poisson trees | [ThreeStateSupercritical.lean](../ComparatorChallenges/ThreeStateSupercritical.lean) |
+| Three-state reconstruction above the Kesten–Stigum threshold | [ThreeStateTreeClauses.lean](../ComparatorChallenges/ThreeStateTreeClauses.lean) |
diff --git a/lean/docs/230.md b/lean/docs/230.md
new file mode 100644
index 0000000000000000000000000000000000000000..4a365b3f912f57f59ddbd8ddb8de07cd904b9768
--- /dev/null
+++ b/lean/docs/230.md
@@ -0,0 +1,16 @@
+# Exact Hausdorff gauges for SLE
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [An exact Hausdorff gauge for SLE: A moment-integral and finite-batch construction](../../preprints/An-exact-Hausdorff-gauge-for-SLE-September-25-2026/An-exact-Hausdorff-gauge-for-SLE-September-25-2026.pdf)
+- [An explicit exact Hausdorff gauge for SLE: A regular formula from quantitative tails and dense visits](../../preprints/An-explicit-exact-Hausdorff-gauge-for-SLE-September-26-2026/An-explicit-exact-Hausdorff-gauge-for-SLE-September-26-2026.pdf)
+
+## Scope
+
+For $0<\kappa<8$, put $d=1+\kappa/8$. The formalization proves that every continuous nondecreasing Hausdorff gauge agreeing with $h(r)=r^d(\log\log(1/r))^{(2-d)/2}$ at sufficiently small positive radii almost surely assigns positive measure to every nontrivial compact positive-time segment of ordinary chordal $\mathrm{SLE}_\kappa$.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Positivity of the explicit gauge on every positive-time segment | [SLELowerPositivity.lean](../ComparatorChallenges/SLELowerPositivity.lean) |
diff --git a/lean/docs/231.md b/lean/docs/231.md
new file mode 100644
index 0000000000000000000000000000000000000000..5b54db53d629492e0735e554240053be59a50380
--- /dev/null
+++ b/lean/docs/231.md
@@ -0,0 +1,18 @@
+# The free uniform spanning forest is a factor of IID
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [The free uniform spanning forest is a factor of IID](../../preprints/The-free-uniform-spanning-forest-is-a-factor-of-IID-September-25-2026/The-free-uniform-spanning-forest-is-a-factor-of-IID-September-25-2026.pdf)
+
+## Scope
+
+The formalization proves that the free uniform spanning forest is a factor of independent identically distributed vertex labels on every infinite connected locally finite simple unweighted graph. One Borel equivariant rule works for all such graphs and uses no distinguished root.
+
+The linked supplements also give equivariant IID sampling for invariant strongly Rayleigh laws on countable groups and existence, uniqueness, and IID-factor results for determinantal laws with Hermitian positive-contraction kernels on countable index sets. These group results require neither amenability nor finite generation, and the kernels need not be trace class.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Strongly Rayleigh and determinantal-process IID factors | [StronglyRayleighDPP.lean](../ComparatorChallenges/StronglyRayleighDPP.lean) |
+| A universal IID factor for the free uniform spanning forest | [FreeUniformSpanningForest.lean](../ComparatorChallenges/FreeUniformSpanningForest.lean) |
diff --git a/lean/docs/234.md b/lean/docs/234.md
new file mode 100644
index 0000000000000000000000000000000000000000..2c80bbb0991833ad4235580f9adb56676ad7a05d
--- /dev/null
+++ b/lean/docs/234.md
@@ -0,0 +1,17 @@
+# All-temperature pressure of orthogonally invariant Ising spin glasses
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [All-temperature pressure for orthogonally invariant Ising spin glasses](../../preprints/All-temperature-pressure-for-orthogonally-invariant-Ising-spin-glasses-September-25-2026/paper.pdf)
+
+## Scope
+
+The formalization gives variational limits for orthogonally invariant Ising spin glasses whose eigenvectors have Haar law and whose empirical eigenvalue distributions converge to a compactly supported law with the stated control of extreme eigenvalues. The pressure converges both in expectation and almost surely to an explicit functional of the limiting spectral law. A version with external fields assumes convergence of their empirical laws in Wasserstein distance and gives the corresponding magnetic-field functional.
+
+The formalization also covers every positive temperature, a ground-state limit, random spectral data with the stated conditional Haar law, and Gaussian-pattern specializations. These hypotheses identify the invariant models to which the limits apply.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Pressure and ground-state limits for invariant Ising models | [InvariantIsing.lean](../ComparatorChallenges/InvariantIsing.lean) |
diff --git a/lean/docs/235.md b/lean/docs/235.md
new file mode 100644
index 0000000000000000000000000000000000000000..5974e018344467e649fc50dc4f46e06703b2c6b3
--- /dev/null
+++ b/lean/docs/235.md
@@ -0,0 +1,26 @@
+# Limiting random SAT thresholds, sharp variance and computability
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [A Limiting Satisfiability Threshold for Every Fixed Clause Size](../../preprints/A-Limiting-Satisfiability-Threshold-for-Every-Fixed-Clause-Size-September-25-2026/article.pdf)
+- [Variance of the Random $k$-SAT Hitting Time](../../preprints/Variance-of-the-Random-k-SAT-Hitting-Time-September-27-2026/article.pdf)
+- [Computing the Random 3-SAT Threshold](../../preprints/Computing-the-Random-3-SAT-Threshold-September-27-2026/article.pdf)
+
+## Scope
+
+The random $k$-SAT threshold problem asks whether satisfiability changes at one limiting clause density. The formalization proves that every fixed integer $k\ge3$ has a finite positive threshold $\alpha_k$: for every fixed density $c<\alpha_k$, the satisfiability probability tends to one as the number of variables grows, while for every $c>\alpha_k$ it tends to zero. Clauses use distinct variables with independent uniform signs and are sampled independently with replacement. The statement makes no assertion at the threshold itself.
+
+Let $H_n$ be the first unsatisfiable prefix length in random $k$-SAT with independent uniformly signed clauses on $k$ distinct variables, sampled with replacement. The formalization proves $\mathrm{Var}(H_n)=\Theta_k(n)$ for every fixed $k\ge4$. For $k=3$, it proves a positive linear lower bound and an $O(n\log n)$ upper bound. The same upper bounds hold after clipping at any fixed positive multiple of $n$, and linear lower bounds hold for sufficiently high clipping levels.
+
+The linked supplements prove sharpness of the separate survival-lifetime and clause-replacement estimates used in the argument. They do not show that the logarithmic factor in the $k=3$ variance bound is necessary.
+
+The formalization proves that the limiting threshold $\alpha$ for uniform random $3$-SAT is a computable positive real. Satisfiability tends to one at every fixed density below $\alpha$ and to zero at every fixed density above it. One deterministic machine produces a rational number $q_r$ for every requested precision $r$ with $|q_r-\alpha|\le2^{-r}$. No computable rate of finite-size convergence is assumed in the statement.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Limiting satisfiability threshold for every fixed $k\ge3$ | [FixedClauseThreshold.lean](../ComparatorChallenges/FixedClauseThreshold.lean) |
+| Sharpness of random $k$-SAT lifetime and replacement bounds | [SATSharpness.lean](../ComparatorChallenges/SATSharpness.lean) |
+| Variance bounds for the random $k$-SAT hitting time | [SATVariance.lean](../ComparatorChallenges/SATVariance.lean) |
+| Computability of the random $3$-SAT threshold | [SATComputability.lean](../ComparatorChallenges/SATComputability.lean) |
diff --git a/lean/docs/236.md b/lean/docs/236.md
new file mode 100644
index 0000000000000000000000000000000000000000..5e821f15ff1a7fcfa2ef2e0ceb59c1bbb284e27d
--- /dev/null
+++ b/lean/docs/236.md
@@ -0,0 +1,15 @@
+# The exact factor-of-IID threshold for free Ising spins on trees
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [The sharp factor-of-IID threshold for the free Ising model on regular trees](../../preprints/The-sharp-factor-of-IID-threshold-for-the-free-Ising-model-on-regular-trees-September-26-2026/article.pdf)
+
+## Scope
+
+The formalized result determines the factor-of-IID threshold for the free zero-field Ising law on the infinite $d$-regular tree. For every $d\ge3$ and $\beta\ge0$, the law is a factor of IID exactly when $\tanh\beta\le1/\sqrt{d-1}$, including equality. The factor uses independent uniform vertex labels and is almost surely equivariant for each fixed tree automorphism. Finitary coding and coding-radius bounds are not included.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Factor-of-IID threshold for the free Ising model | [FreeIsing.lean](../ComparatorChallenges/FreeIsing.lean) |
diff --git a/lean/docs/237.md b/lean/docs/237.md
new file mode 100644
index 0000000000000000000000000000000000000000..ea303e8a380fd703faaa9480a0cffac84bd86da4
--- /dev/null
+++ b/lean/docs/237.md
@@ -0,0 +1,27 @@
+# The three-quarter exponent for honeycomb self-avoiding walk
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [Polynomial vacuum representations and bridge mass for honeycomb walks](../../preprints/Polynomial-vacuum-representations-and-bridge-mass-for-honeycomb-walks-September-26-2026/main.pdf)
+- [Renewal and changes of law for critical honeycomb walks](../../preprints/Renewal-and-changes-of-law-for-critical-honeycomb-walks-September-26-2026/main.pdf)
+- [Critical strip-crossing mass on the honeycomb lattice](../../preprints/Critical-strip-crossing-mass-on-the-honeycomb-lattice-September-26-2026/main.pdf)
+
+## Scope
+
+The linked formalization establishes finiteness of the critical bridge measures used in the paper. For every strip height $h\ge1$, the total weight and first length moment of self-avoiding honeycomb bridges from a fixed initial port to a free terminal port are finite. The corresponding sums are also finite when the bridge is confined to the corridor of horizontal width $h(\log h)^2$, including the normalized first-moment sums.
+
+These are supporting summability statements. The paper's $h^{4/3+o(1)}$ mean-length law and its central-visit and hexagonal-chord exponents are outside them.
+
+The linked formalization proves existence of the infinite-length free energy for the critical honeycomb self-avoiding-walk partition function. For every starting vertex, force direction, and real force parameter, the logarithm of the length-$n$ partition function divided by $n$ converges to its stated free-energy limit.
+
+This selected result supplies the limiting free energy. It does not state the paper's small-force exponent, near-critical correlation scale, or the $3/4$ spatial and moment laws.
+
+For critical self-avoiding walks on the honeycomb lattice, the formalization proves that the total weight of paths crossing a strip of height $N$ is comparable to $N^{-1/4}$, while the first horizontal-displacement moment of return paths is comparable to $N^{3/4}$. It also proves finiteness of the strip sums, the exact arch–bridge balance identity, comparison of successive moment increments with bridge mass, and monotonicity of bridge mass. The comparison constants are uniform in the strip height.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Finiteness of critical bridge mass and first length moments | [HoneycombBridgeFiniteness.lean](../ComparatorChallenges/HoneycombBridgeFiniteness.lean) |
+| Existence of the honeycomb free-energy limit | [HoneycombFreeEnergy.lean](../ComparatorChallenges/HoneycombFreeEnergy.lean) |
+| Critical honeycomb strip mass and displacement moment | [CriticalStripMass.lean](../ComparatorChallenges/CriticalStripMass.lean) |
diff --git a/lean/docs/238.md b/lean/docs/238.md
new file mode 100644
index 0000000000000000000000000000000000000000..56610ae008acfdcdee2e0e144ff84a8bbace2402
--- /dev/null
+++ b/lean/docs/238.md
@@ -0,0 +1,64 @@
+# Optimal logarithmic mixing of the Thorp shuffle
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [Optimal-order mixing of the Thorp shuffle](../../preprints/Optimal-order-mixing-of-the-Thorp-shuffle-September-26-2026/paper.pdf)
+- [From partial permutation information to Fourier bounds](../../preprints/From-partial-permutation-information-to-Fourier-bounds-September-26-2026/main.pdf)
+- [Conditional permutations in a revealed switching environment](../../preprints/Conditional-permutations-in-a-revealed-switching-environment-September-26-2026/paper.pdf)
+- [Routing densities and representation contraction for Thorp sweeps](../../preprints/Routing-densities-and-representation-contraction-for-Thorp-sweeps-September-26-2026/paper.pdf)
+- [Row–column symmetry and contraction of coordinate sweeps](../../preprints/Row-column-symmetry-and-contraction-of-coordinate-sweeps-September-26-2026/paper.pdf)
+- [Random-subspace tests and trace smoothing for coordinate sweeps](../../preprints/Random-subspace-tests-and-trace-smoothing-for-coordinate-sweeps-September-26-2026/paper.pdf)
+- [Compatibility entropy and the spectrum of a Thorp sweep](../../preprints/Compatibility-entropy-and-the-spectrum-of-a-Thorp-sweep-September-26-2026/paper.pdf)
+- [Signed tensor densities and diagram budgets for the Thorp shuffle](../../preprints/Signed-tensor-densities-and-diagram-budgets-for-coordinate-sweeps-September-26-2026/paper.pdf)
+- [Conditional coordinate sweeps and analytic transfer](../../preprints/Conditional-coordinate-sweeps-and-analytic-transfer-September-26-2026/main.pdf)
+- [A strict four-row permanent inequality and permutation moments](../../preprints/A-strict-four-row-permanent-inequality-and-permutation-moments-September-26-2026/main.pdf)
+
+## Scope
+
+The formalization proves optimal-order mixing of the Thorp shuffle on $2^d$ cards. After $1600d$ complete shuffles, the full permutation law converges in total variation to uniform as $d\to\infty$, uniformly over initial decks. Together with the support lower bound of $2d-O(1)$, this gives mixing time $\Theta(d)=\Theta(\log(2^d))$.
+
+The linked supporting results include frame and conditional-list estimates, regular trace and spectral bounds, signed moments, and full-density $L^2$ control. They also bound reciprocal Specht-dimension sums and give the eight-block Fourier estimate used in the mixing argument.
+
+The formalized supporting result turns bounds on partial-permutation cosets into Fourier bounds. Partition a finite set into $b\ge1$ nonempty blocks, and let $f\ge0$ be a subprobability weight on its symmetric group whose left-coset masses for each block subgroup are at most $B$. For every irreducible unitary representation of dimension $D$ and every $u>0$, both the squared Hilbert–Schmidt norm and squared operator norm of its Fourier transform are at most $bB\,C(u)D^{-1+(u+2)/b}$, where $C(u)$ is the stated symmetric-group degree constant.
+
+The paper's asymptotic conclusion about the product of two random permutations is outside this selected finite estimate.
+
+The formalized results give averaged conditional mixing for half-permutations in the revealed-path model and full-deck mixing for the Thorp shuffle. In particular, the full-deck total-variation distance tends to zero after $16040400d$ steps on $2^d$ cards, uniformly over deterministic initial decks. The conditional estimate is averaged over the actual outside-path law, rather than asserted for each individual environment. The formalization also includes the associated overlay, reset minorization, and two-color conditional constructions.
+
+The formalization covers nine routing and representation estimates for Thorp sweeps: adaptive operator and fourth-trace bounds, Casimir moments, dense truncation, sparse contact, harmonic-cycle contraction, smoothing, and three tail or sparse-saving estimates. They bound routing-density deviations and Fourier operators in dense and sparse regimes, including exponential savings in the level scale and representation dimension.
+
+The conditional high-height estimate requires a sufficiently large cutoff height $J$ that exceeds twice the number $s$ of coordinates in the fixed low block, so $J>2s$. These are the earlier nine statements associated with the paper; its changed later statements and six other result blocks are outside this scope.
+
+The formalization proves uniform representation bounds for one coordinate sweep of the Thorp shuffle. For each irreducible representation of dimension $D$, it chooses a weight between $D^{3/4}$ and $D$ and a Schatten exponent bounded by one absolute constant so that the weighted Schatten moment is at most one. The sweep's operator norm is consequently at most $D^{-c}$ for one absolute $c>0$.
+
+The supporting row–column estimate bounds the total squared overlap over all multiplicity copies on an occupied board, with explicit dependence on the row and column representation dimensions, the global dimension, the number of missing cells, and the number of rows or columns containing the global Young diagram. The paper's full physical-mixing conclusion is outside these selected representation estimates.
+
+The formalization proves a uniform trace-smoothing estimate for coordinate sweeps of the Thorp shuffle on $2^d$ cards. One absolute sweep parameter works for every $d\ge1$: the regular trace is at most $1+(2^d)^{-10}$, and the full permutation law after the corresponding fixed number of sweeps is within $\tfrac12(2^d)^{-5}$ of uniform in total variation, for every initial deck. Thus the selected upper bound uses $O(d)$ physical shuffles.
+
+The formalized result is the weighted compatibility theorem for balanced $A\times D$ rectangles, with $n=AD$ and $\sqrt n/2\le A,D\le2\sqrt n$. For arbitrary nonnegative weights on the row and column permutation groups, the normalized compatibility average is bounded by $\exp(C_0n^{54/100})$ times the product of the marginal $L^{1/\theta}$ factors, where $\theta=1-L/\log\sqrt n>0$ and the constants are absolute. Compatibility means injectivity in every original column. The bounded regular-moment and other moment/rank conclusions are not included.
+
+The formalization gives signed representation estimates for coordinate sweeps of the Thorp shuffle. For every signed occurrence of a Young diagram of size $2^d$, it bounds the logarithm of a fixed-order weighted sweep moment by a small multiple of the signed partition entropy plus an explicit remainder-size budget. The moment order is uniform over the diagrams and decompositions after the two small coefficients are fixed.
+
+The linked supporting angle bound controls the overlap of row, column, and global signed-type projections on an occupied rectangle, with explicit entropy, dimension, and missing-cell factors. These selected estimates support the paper's full-density argument; the full $L^2$ and total-variation mixing conclusion is outside them.
+
+The formalized binary-sweep theorem gives a universal power contraction in every irreducible representation: for sufficiently large $d$, the averaged sweep on $2^d$ slots has operator norm at most $D^{-g}$ in representation dimension $D$, for some $g>0$. The sign expectation is zero, and a fixed number of independent sweeps approaches uniform in total variation from every initial deck. A separate conditional moment estimate covers allowed power-of-two grids and disjoint coordinate-respecting trajectories, with its stated feasibility premise. Physical-shuffle law identification is not included.
+
+The formalization proves the paper's strict four-row permanent inequality. There are constants $4/3<p<2$ and $\varepsilon>0$ such that every probability law on $S_4$ within total-variation distance $\varepsilon$ of uniform, and with exactly uniform coordinate marginals, satisfies the permanent bound by the product of the four $L^p$ row norms for every nonnegative matrix. The exponent and neighborhood are uniform over those laws. The Thorp mixing consequence is outside this selected statement.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Reciprocal Specht degrees and eight-block Fourier bound | [ThorpFirstReciprocal.lean](../ComparatorChallenges/ThorpFirstReciprocal.lean) |
+| Frame, spectral, and density estimates for Thorp mixing | [ThorpRemaining.lean](../ComparatorChallenges/ThorpRemaining.lean) |
+| Fourier bounds from complementary coset caps | [PartialPermutation.lean](../ComparatorChallenges/PartialPermutation.lean) |
+| Nine routing-density and representation estimates | [ThorpRouting.lean](../ComparatorChallenges/ThorpRouting.lean) |
+| Row–column overlap on occupied boards | [OccupiedOverlap.lean](../ComparatorChallenges/OccupiedOverlap.lean) |
+| Weighted Schatten moments and operator contraction for coordinate sweeps | [WeightedSweepMoments.lean](../ComparatorChallenges/WeightedSweepMoments.lean) |
+| Regular trace smoothing and full-permutation mixing | [CoordinateTrace.lean](../ComparatorChallenges/CoordinateTrace.lean) |
+| Weighted row–column compatibility bound | [ThorpWeightedCompatibility.lean](../ComparatorChallenges/ThorpWeightedCompatibility.lean) |
+| One-sided angle bound for signed spin types | [SpinAngle.lean](../ComparatorChallenges/SpinAngle.lean) |
+| Uniform signed-occurrence moment bound for coordinate sweeps | [SignedSweepMoment.lean](../ComparatorChallenges/SignedSweepMoment.lean) |
+| Binary sweep contraction and mixing | [BinarySweep.lean](../ComparatorChallenges/BinarySweep.lean) |
+| Conditional coordinate-sweep moment estimate | [CoordinateSweeps.lean](../ComparatorChallenges/CoordinateSweeps.lean) |
+| Strict four-row permanent inequality near the uniform law | [FourRowPermanent.lean](../ComparatorChallenges/FourRowPermanent.lean) |
diff --git a/lean/docs/240.md b/lean/docs/240.md
new file mode 100644
index 0000000000000000000000000000000000000000..d616594fc18948fdd4cc26c7f8ca993fdb526f76
--- /dev/null
+++ b/lean/docs/240.md
@@ -0,0 +1,17 @@
+# Shelah's eventual categoricity and the prescribed-threshold obstruction
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [A CH obstruction to a prescribed categoricity threshold](../../preprints/A-CH-Obstruction-to-a-Prescribed-Categoricity-Threshold-September-24-2026/paper.pdf)
+
+## Scope
+
+Under the continuum hypothesis, the formalized result refutes the proposed transfer of categoricity down to the Hanf threshold. It gives an abstract elementary class in a countable relational language, with Löwenheim–Skolem number $\aleph_0$, that has two nonisomorphic models at $\beth_{\omega_2}=h(\aleph_0)$ but is categorical in every cardinal at least $\beth_{(2^{\aleph_1})^+}$.
+
+No amalgamation, joint embedding, tameness, or absence-of-maximal-models assumption is imposed. The later canonical-point obstruction and the separate eventual-categoricity theorem are not included.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| CH categoricity-threshold obstruction | [CHObstruction.lean](../ComparatorChallenges/CHObstruction.lean) |
diff --git a/lean/docs/241.md b/lean/docs/241.md
new file mode 100644
index 0000000000000000000000000000000000000000..a3f7a6cfde613509d0a953c92601ae93d36225f3
--- /dev/null
+++ b/lean/docs/241.md
@@ -0,0 +1,15 @@
+# Rigidity of the Turing degrees
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [Rigidity of the Turing degrees](../../preprints/Rigidity-of-the-Turing-degrees-September-24-2026/paper.pdf)
+
+## Scope
+
+The rigidity problem asks whether the ordering of Turing degrees by relative computability has any nontrivial automorphism. The formalized result gives a negative answer: every order automorphism of the full Turing degrees of subsets of $\mathbb N$ fixes every degree, with no definability or genericity assumption. The additional representation corollaries are not included.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Rigidity of the Turing degrees | [DegreeRigidity.lean](../ComparatorChallenges/DegreeRigidity.lean) |
diff --git a/lean/docs/242.md b/lean/docs/242.md
new file mode 100644
index 0000000000000000000000000000000000000000..bd25e975fa489a857799fe63e10890a3de33e9a7
--- /dev/null
+++ b/lean/docs/242.md
@@ -0,0 +1,17 @@
+# Single-fold Diophantine representations and undecidability under an at-most-one-solution promise
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [Single-fold Diophantine representations](../../preprints/Single-fold-Diophantine-representations-September-24-2026/paper.pdf)
+
+## Scope
+
+The single-fold Diophantine conjecture asks whether every recursively enumerable set has a polynomial representation with a unique auxiliary witness for each member. The formalization establishes this for every recursively enumerable subset of $\mathbb N^n$, $n\ge1$: an integer polynomial has exactly one complete natural-number witness tuple for members and none for nonmembers.
+
+The consequence that solvability remains undecidable under an at-most-one-solution promise is not separately formalized.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Single-fold Diophantine representations | [SingleFold.lean](../ComparatorChallenges/SingleFold.lean) |
diff --git a/lean/docs/243.md b/lean/docs/243.md
new file mode 100644
index 0000000000000000000000000000000000000000..107bc77eda4fa98af2252539cd189a621188001b
--- /dev/null
+++ b/lean/docs/243.md
@@ -0,0 +1,19 @@
+# Separating choiceless counting from polynomial time and witnessed choice
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [Choiceless polynomial time with counting does not capture polynomial time](../../preprints/Choiceless-polynomial-time-with-counting-does-not-capture-polynomial-time-September-23-2026/paper.pdf)
+- [Witnessed symmetric choice is strictly stronger than choiceless polynomial time with counting](../../preprints/Witnessed-symmetric-choice-is-strictly-stronger-than-choiceless-polynomial-time-with-counting-September-24-2026/paper.pdf)
+
+## Scope
+
+The formalized result separates polynomial time from choiceless polynomial time with counting. It gives an explicit query on finite structures with eight relations that is invariant under isomorphism and decidable in polynomial time, but is not definable in the stated hereditarily finite-set language with cardinality and polynomial bounds on stages and intermediate objects. The query applies to all finite inputs without a promise. The separate witnessed-symmetric-choice result is not included.
+
+The formalization proves that witnessed symmetric choice strictly increases the expressive power of choiceless polynomial time with counting. It constructs one fixed sentence with exactly one witnessed-choice occurrence that gives a Boolean answer on every finite input, while no sentence of the original counting formalism defines the same class of inputs.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Polynomial-time query outside choiceless polynomial time | [ChoicelessPolynomialTime.lean](../ComparatorChallenges/ChoicelessPolynomialTime.lean) |
+| Strict expressive gain from one witnessed symmetric choice | [WitnessedChoice.lean](../ComparatorChallenges/WitnessedChoice.lean) |
diff --git a/lean/docs/244.md b/lean/docs/244.md
new file mode 100644
index 0000000000000000000000000000000000000000..5756099ffd08f45da45dc7d97d2f6b95b61e1988
--- /dev/null
+++ b/lean/docs/244.md
@@ -0,0 +1,18 @@
+# The Partition Principle does not imply Choice
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [The Partition Principle does not imply Choice](../../preprints/The-Partition-Principle-does-not-imply-Choice-September-24-2026/partition-principle-without-choice.pdf)
+
+## Scope
+
+The Partition Principle says that every surjection admits an injection in the reverse direction. The formalization proves the relative-consistency implication: if ZF is consistent, then so is ZF with the Partition Principle, Choice for ordinal-indexed families, and failure of the Axiom of Choice.
+
+The linked model-construction result also constructs a transitive model of the Partition Principle without Choice from an externally countable transitive ground model satisfying the stated axioms, including Choice, and containing an internal strongly inaccessible cardinal. The paper's stronger transitive-model preservation assertions are outside that selected construction.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Partition Principle without Choice from a ground model | [PartitionPrinciple.lean](../ComparatorChallenges/PartitionPrinciple.lean) |
+| Relative consistency of the Partition Principle with ordinal Choice and failure of Choice | [PartitionConsistency.lean](../ComparatorChallenges/PartitionConsistency.lean) |
diff --git a/lean/docs/245.md b/lean/docs/245.md
new file mode 100644
index 0000000000000000000000000000000000000000..aa178b65d140bba1898a8c462b18bbe0ce1e4fa4
--- /dev/null
+++ b/lean/docs/245.md
@@ -0,0 +1,15 @@
+# Weak normalization implies strong normalization in pure type systems
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [Weak and strong normalization in pure type systems](../../preprints/Weak-and-strong-normalization-in-pure-type-systems-September-25-2026/paper.pdf)
+
+## Scope
+
+The formalization proves the $\beta$-Barendregt–Geuvers–Klop conjecture for pure type systems: if every legal expression in every valid context has some terminating $\beta$-reduction sequence, then every $\beta$-reduction sequence from every such expression terminates. Reduction is allowed inside type annotations, and the specification may have arbitrary sorts and nonfunctional axioms or rules.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Weak normalization implies strong normalization in every pure type system | [TypeSystemNormalization.lean](../ComparatorChallenges/TypeSystemNormalization.lean) |
diff --git a/lean/docs/246.md b/lean/docs/246.md
new file mode 100644
index 0000000000000000000000000000000000000000..bef79858e71e71da41bed7429271edd013567224
--- /dev/null
+++ b/lean/docs/246.md
@@ -0,0 +1,15 @@
+# Cannon's conjecture
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [A Modulus Proof of Cannon’s Conjecture](../../preprints/A-Modulus-Proof-of-Cannons-Conjecture-September-23-2026/paper.pdf)
+
+## Scope
+
+Cannon's conjecture asks whether a hyperbolic group with boundary homeomorphic to the two-sphere acts geometrically on hyperbolic three-space. The formalization proves that such a group admits an isometric action on $\mathbb H^3$ that is proper and cocompact and has finite kernel. Hyperbolicity is expressed through uniformly thin geodesic triangles in a Cayley graph, and the boundary hypothesis is a homeomorphism with $S^2$.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Cannon's geometric-action conclusion | [CannonGeometricAction.lean](../ComparatorChallenges/CannonGeometricAction.lean) |
diff --git a/lean/docs/247.md b/lean/docs/247.md
new file mode 100644
index 0000000000000000000000000000000000000000..48b7524fc27a628da6dcad6b41798ce7eaafd3b2
--- /dev/null
+++ b/lean/docs/247.md
@@ -0,0 +1,15 @@
+# An infinite finitely presented residually finite 2-group and a finitely presented nil algebra
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [An infinite finitely presented periodic group](../../preprints/An-infinite-finitely-presented-periodic-group-September-23-2026/paper.pdf)
+
+## Scope
+
+The finitely presented Burnside question asks whether a finitely presented group in which every element has finite order must be finite. The formalization gives a negative answer by constructing an infinite finitely presented periodic group, including a witness realized as a Steinberg group over an algebra of characteristic two. Periodicity means that each element has some finite order; no common exponent is asserted. The paper's separate nil-algebra and radical-algebra conclusions are outside these selected statements.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Infinite finitely presented periodic group | [PeriodicGroup.lean](../ComparatorChallenges/PeriodicGroup.lean) |
diff --git a/lean/docs/248.md b/lean/docs/248.md
new file mode 100644
index 0000000000000000000000000000000000000000..6f26d2c9e0b9574f778412c41e66467fa04d6965
--- /dev/null
+++ b/lean/docs/248.md
@@ -0,0 +1,15 @@
+# Thompson's group <i>F</i> is nonamenable
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [Thompson's group $F$ is nonamenable](../../preprints/Thompsons-group-F-is-nonamenable-September-23-2026/paper.pdf)
+
+## Scope
+
+The amenability problem for Thompson's group $F$ asks whether it admits a positive normalized left-invariant mean on bounded real functions. The formalized result rules out such a mean for the standard group of dyadic piecewise-linear homeomorphisms of the interval, proving nonamenability. No explicit boundary constant or prescribed generating set is given.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Nonamenability of Thompson's group $F$ | [ThompsonNonamenability.lean](../ComparatorChallenges/ThompsonNonamenability.lean) |
diff --git a/lean/docs/249.md b/lean/docs/249.md
new file mode 100644
index 0000000000000000000000000000000000000000..dff8a4c12de8dee1a3e9ded98a1fd820f4262493
--- /dev/null
+++ b/lean/docs/249.md
@@ -0,0 +1,15 @@
+# A finitely generated Eilenberg–Ganea counterexample
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [A finitely generated counterexample to the Eilenberg–Ganea conjecture](../../preprints/A-finitely-generated-counterexample-to-the-Eilenberg-Ganea-conjecture-September-23-2026/paper.pdf)
+
+## Scope
+
+The Eilenberg–Ganea conjecture predicts that a group of integral cohomological dimension two has a two-dimensional classifying space. The formalization constructs a finitely generated residually finite group of cohomological dimension two that has a three-dimensional classifying space but no two-dimensional one. Thus its geometric dimension is three, contradicting the conjecture.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Counterexample to the Eilenberg–Ganea conjecture | [EilenbergGanea.lean](../ComparatorChallenges/EilenbergGanea.lean) |
diff --git a/lean/docs/250.md b/lean/docs/250.md
new file mode 100644
index 0000000000000000000000000000000000000000..c82fa71607d70509c56908ae7384392dca7bebe2
--- /dev/null
+++ b/lean/docs/250.md
@@ -0,0 +1,25 @@
+# Boone–Higman embeddings with higher finiteness
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [Finite algebraic envelopes and the Boone–Higman conjecture](../../preprints/Finite-algebraic-envelopes-and-the-Boone-Higman-conjecture-September-23-2026/paper.pdf)
+- [Simple $F_\infty$ overgroups of groups with decidable word problem](../../preprints/Simple-F-infinity-overgroups-of-groups-with-decidable-word-problem-September-23-2026/paper.pdf)
+- [A universal group of type $F_\infty$](../../preprints/A-universal-group-of-type-F-infinity-September-23-2026/paper.pdf)
+
+## Scope
+
+The Boone–Higman conjecture characterizes finitely generated groups with decidable word problem by embeddings into finitely presented simple groups. The formalization proves the equivalence in full: a finitely generated group has a computable word problem for a finite generating set exactly when it embeds by an injective homomorphism into a finitely presented simple group.
+
+The formalization proves the higher-finiteness strengthening of the Boone–Higman conjecture: every finitely generated group with decidable word problem embeds by an injective homomorphism into a nontrivial simple group of type $F_\infty$. Here type $F_\infty$ means that the group has a classifying CW complex with finitely many cells in each dimension. No additional finiteness property of the original group is assumed.
+
+The formalized result constructs one group $H$ of type $F_\infty$ containing every finitely presented group. Here type $F_\infty$ means that $H$ has a classifying space with finitely many cells in each dimension.
+
+The group $H$ is fixed before the groups embedded into it are chosen. No word-problem assumption is imposed, and the classifying space need not be finite-dimensional or have finitely many cells in total. The paper's converse about recursively presented subgroups is not included.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Boone–Higman equivalence | [BooneHigman.lean](../ComparatorChallenges/BooneHigman.lean) |
+| Simple type $F_\infty$ overgroups of groups with decidable word problem | [SimpleOvergroups.lean](../ComparatorChallenges/SimpleOvergroups.lean) |
+| Universal group of type $F_\infty$ | [UniversalFInfinity.lean](../ComparatorChallenges/UniversalFInfinity.lean) |
diff --git a/lean/docs/251.md b/lean/docs/251.md
new file mode 100644
index 0000000000000000000000000000000000000000..977c418c3c311854bfe782781ad322c205b37668
--- /dev/null
+++ b/lean/docs/251.md
@@ -0,0 +1,18 @@
+# Amenability, unitarizability, and strong Ulam stability
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [Unitarizability implies amenability for discrete groups](../../preprints/Unitarizability-Implies-Amenability-for-Countable-Groups-September-23-2026/paper.pdf)
+
+## Scope
+
+Dixmier's unitarizability problem asks whether a discrete group is amenable exactly when every uniformly bounded Hilbert-space representation is similar to a unitary one. The formalization establishes this equivalence for every discrete group.
+
+For every nonamenable group and every $\varepsilon>0$, it also gives a nonunitarizable representation with uniform operator bound at most $1+\varepsilon$. The Hilbert space can be chosen separable for countable groups; a separate linked statement records a separable witness with uniform bound $101$ in that case.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Unitarizability for all discrete groups | [DixmierAllDiscrete.lean](../ComparatorChallenges/DixmierAllDiscrete.lean) |
+| Separable nonunitarizable witnesses for countable nonamenable groups | [Dixmier.lean](../ComparatorChallenges/Dixmier.lean) |
diff --git a/lean/docs/252.md b/lean/docs/252.md
new file mode 100644
index 0000000000000000000000000000000000000000..d93c36a2aa10b21aaecfdc0adf4b50c05ecf8c15
--- /dev/null
+++ b/lean/docs/252.md
@@ -0,0 +1,17 @@
+# A torsion-free hyperbolic group that is neither residually finite nor linear over any field
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [A torsion-free hyperbolic group that is not residually finite](../../preprints/a-torsion-free-hyperbolic-group-that-is-not-residually-finite-September-23-2026/paper.pdf)
+
+## Scope
+
+The residual-finiteness question for hyperbolic groups asks whether every nonidentity element survives in some finite quotient. The formalized result gives a negative answer by constructing a torsion-free word-hyperbolic group that is not residually finite.
+
+Nonlinearity over every field is not a separate conclusion of the statement linked below.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Torsion-free hyperbolic group that is not residually finite | [TorsionFreeHyperbolic.lean](../ComparatorChallenges/TorsionFreeHyperbolic.lean) |
diff --git a/lean/docs/253.md b/lean/docs/253.md
new file mode 100644
index 0000000000000000000000000000000000000000..2e9033ed75b008259409a3aec96a19aec5d14143
--- /dev/null
+++ b/lean/docs/253.md
@@ -0,0 +1,17 @@
+# An infinite finitely presented simple amenable group
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [An infinite finitely presented simple amenable group](../../preprints/An-Infinite-Finitely-Presented-Simple-Amenable-Group-September-23-2026/paper.pdf)
+
+## Scope
+
+The formalized result answers the existence question affirmatively: there is one group that is infinite, finitely presented, simple, and amenable. Amenability is expressed by the Følner condition.
+
+The later general claims about central kernels and enlargements across families are not included.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Infinite finitely presented simple amenable group | [SimpleAmenable.lean](../ComparatorChallenges/SimpleAmenable.lean) |
diff --git a/lean/docs/254.md b/lean/docs/254.md
new file mode 100644
index 0000000000000000000000000000000000000000..3daef005137f48059e9a4c37aa2c2ef43b6bdd98
--- /dev/null
+++ b/lean/docs/254.md
@@ -0,0 +1,29 @@
+# Classifying spaces and geometric obstructions for Artin groups
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [Harmonic heights and the Artin $K(\pi,1)$ conjecture](../../preprints/Harmonic-heights-and-the-Artin-K-pi-1-conjecture-September-23-2026/paper.pdf)
+- [An Artin group with no geometric $\mathrm{CAT}(0)$ action](../../preprints/An-Artin-group-with-no-geometric-CAT-0-action-September-23-2026/paper.pdf)
+- [Parabolic Intersections in Artin Groups](../../preprints/Parabolic-intersections-in-Artin-groups-September-23-2026/paper.pdf)
+
+## Scope
+
+The Artin $K(\pi,1)$ conjecture asserts that the standard Salvetti complex of every finite-rank Artin group is aspherical. The formalized result proves the equivalent statement that its universal cover is contractible.
+
+It applies to every Coxeter matrix on a finite generating set, including empty and disconnected diagrams and infinite edge labels. The associated Coxeter and Artin groups may be infinite. Later corollaries in the manuscript are not included.
+
+The geometric-action question asks whether every Artin group acts properly and cocompactly by isometries on a proper CAT(0) space. The formalized result gives a counterexample: an Artin group defined by a symmetric matrix on $116$ generators, with diagonal entries $1$ and off-diagonal entries in $\{2,3,\infty\}$.
+
+It admits no such action on any nonempty proper CAT(0) space, in any dimension.
+
+The formalization proves that the intersection of any family of parabolic subgroups of a finite-rank Artin group is parabolic. Every such intersection is already the intersection of at most the rank many members, and every subset has a unique parabolic closure. Both finite and infinite Coxeter labels are allowed.
+
+For irreducible Artin groups with an infinite Coxeter label, it also proves acylindrical hyperbolicity and weak malnormality of every proper parabolic subgroup. These are the intersection and structural consequences selected from the paper.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Contractibility of the Salvetti cover | [HarmonicArtin.lean](../ComparatorChallenges/HarmonicArtin.lean) |
+| Artin group with no geometric $\mathrm{CAT}(0)$ action | [ArtinCAT0.lean](../ComparatorChallenges/ArtinCAT0.lean) |
+| Parabolic intersections, closures, and structural consequences | [ArtinParabolicIntersections.lean](../ComparatorChallenges/ArtinParabolicIntersections.lean) |
diff --git a/lean/docs/255.md b/lean/docs/255.md
new file mode 100644
index 0000000000000000000000000000000000000000..0805f2aa9a0cf941ee415229a36bf6a0746a9fdb
--- /dev/null
+++ b/lean/docs/255.md
@@ -0,0 +1,17 @@
+# Quasi-isometric recognition of virtually polycyclic groups
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [Quasi-isometric Recognition of Virtually Polycyclic Groups](../../preprints/quasi-isometric-recognition-of-virtually-polycyclic-groups-September-24-2026/paper.pdf)
+
+## Scope
+
+The formalization proves quasi-isometric recognition of virtually polycyclic groups: every finitely generated group quasi-isometric to a finitely generated virtually polycyclic group is itself virtually polycyclic. It also realizes a finite-index subgroup of the recognized group as a uniform lattice in a simply connected solvable Lie group, which may differ from the original ambient group.
+
+The linked structural estimate controls the height-coordinate behavior of self quasi-isometries of the stated unimodular solvable Lie models, up to bounded error and one of finitely many linear height symmetries.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Quasi-isometric recognition of virtually polycyclic groups and solvable lattices | [PolycyclicRecognition.lean](../ComparatorChallenges/PolycyclicRecognition.lean) |
diff --git a/lean/docs/256.md b/lean/docs/256.md
new file mode 100644
index 0000000000000000000000000000000000000000..d84092b79c3b5384daf059e00f0d18fb25453dcf
--- /dev/null
+++ b/lean/docs/256.md
@@ -0,0 +1,15 @@
+# Nonsingular systems of equations over arbitrary groups
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [The Kervaire theorem for groups](../../preprints/The-Kervaire-Theorem-for-Groups-September-24-2026/The-Kervaire-Theorem-for-Groups-September-24-2026.pdf)
+
+## Scope
+
+Kervaire's conjecture states that the free product of a nontrivial group with an infinite cyclic group cannot be normally generated by one element. The linked formalization proves the stronger coefficient-injectivity statement used in the paper: for any group $A$ and any relator in $A*\mathbb Z$ whose exponent sum in the cyclic generator is $1$ or $-1$, the natural map from $A$ into the quotient by that relator is injective. This is the selected unimodular-relator result underlying the conjecture.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Coefficient-group injectivity for unimodular one-relator quotients | [Kervaire.lean](../ComparatorChallenges/Kervaire.lean) |
diff --git a/lean/docs/257.md b/lean/docs/257.md
new file mode 100644
index 0000000000000000000000000000000000000000..48a4e713c3a1f0fecdb4b66ff545de6406e8e3c7
--- /dev/null
+++ b/lean/docs/257.md
@@ -0,0 +1,15 @@
+# A hyperbolic group without a geometric CAT(0) action
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [A hyperbolic group with no geometric $\mathrm{CAT}(0)$ action](../../preprints/A-hyperbolic-group-with-no-geometric-CAT0-action-September-25-2026/paper.pdf)
+
+## Scope
+
+The formalized result constructs a finite connected aspherical complex with a linear disk-filling bound whose fundamental group is word-hyperbolic but admits no geometric action on a nonempty proper complete $\mathrm{CAT}(0)$ space. It also excludes locally $\mathrm{CAT}(-1)$ geodesic metrics on every finite complex homotopy equivalent to the witness. The stronger claims that the witness is two-dimensional and that those models admit no locally $\mathrm{CAT}(0)$ metric are not included.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Hyperbolic group with no geometric CAT(0) action | [HyperbolicObstruction.lean](../ComparatorChallenges/HyperbolicObstruction.lean) |
diff --git a/lean/docs/260.md b/lean/docs/260.md
new file mode 100644
index 0000000000000000000000000000000000000000..10b828bcc4a7bbfa89e30b209fd8d83fb8890dc8
--- /dev/null
+++ b/lean/docs/260.md
@@ -0,0 +1,19 @@
+# Spacetime Penrose inequalities: enclosing area, charge, rotation, and anti-de Sitter extensions
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [Area-controlled end replacement and the Bondi–Penrose inequality in the CKS class](../../preprints/Area-controlled-end-replacement-and-the-Bondi-Penrose-inequality-in-the-CKS-class-September-27-2026/paper.pdf)
+
+## Scope
+
+The formalization replaces a three-dimensional Cha–Khuri–Sakovich hyperboloidal end by asymptotically flat ends while preserving each fixed compact interior, completeness, and the dominant energy condition. For strictly future-timelike initial-data charge, the ADM masses approach the invariant Bondi mass and the loss of enclosing area tends to zero.
+
+The Comparator also includes canonical Schwarzschild equality examples at every positive mass, with $m_{\mathrm{Bondi}}=m$ and enclosing area $16\pi m^2$. The paper's general Bondi–Penrose inequality for possibly disconnected weakly trapped boundaries remains unformalized.
+
+The implementation retains a conditional inequality for the connected marginal-boundary case, assuming the asymptotically flat exterior Penrose inequality. This supporting result is not selected as a substitute for the paper's main inequality.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Area-controlled end replacement and Schwarzschild equality examples | [CKSBondiPenrose.lean](../ComparatorChallenges/CKSBondiPenrose.lean) |
diff --git a/lean/docs/261.md b/lean/docs/261.md
new file mode 100644
index 0000000000000000000000000000000000000000..cd3caead32a1843ae8254752c3619a4944363a2f
--- /dev/null
+++ b/lean/docs/261.md
@@ -0,0 +1,17 @@
+# Localization and delocalization in the Anderson model
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [Pure-Point Spectrum for the Two-Dimensional Anderson Model at Every Positive Disorder](../../preprints/Pure-Point-Spectrum-for-the-Two-Dimensional-Anderson-Model-at-Every-Positive-Disorder-September-23-2026/paper.pdf)
+
+## Scope
+
+The linked formalization proves a supporting spectral statement for the nearest-neighbor Anderson operator on $\mathbb Z^2$. For every disorder strength $h>0$ with independent site potentials uniform on $[-h,h]$, it constructs the bounded self-adjoint operator almost surely and identifies its spectrum as the real interval $[-4-h,4+h]$.
+
+This selected statement identifies the spectral set. It does not assert the pure-point spectral type claimed in the accompanying paper.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Almost-sure spectrum of the planar Anderson operator | [PlanarAndersonSpectrum.lean](../ComparatorChallenges/PlanarAndersonSpectrum.lean) |
diff --git a/lean/docs/262.md b/lean/docs/262.md
new file mode 100644
index 0000000000000000000000000000000000000000..760f71a5932e6898ce90c6ffce78cad8c288034d
--- /dev/null
+++ b/lean/docs/262.md
@@ -0,0 +1,15 @@
+# Sharp finite-matrix Lieb–Thirring inequalities and all equality cases
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [Sharp one-dimensional Lieb–Thirring constants](../../preprints/Sharp-One-Dimensional-Lieb-Thirring-Constants-September-23-2026/paper.pdf)
+
+## Scope
+
+The formalized result determines the sharp one-dimensional Lieb–Thirring constant for $1/2<\gamma<3/2$. For every nonnegative $W\in L^{\gamma+1/2}(\mathbb R)$, it bounds the full negative-eigenvalue moment of $-d^2/dx^2-W$ by the one-bound-state constant times the potential integral. This constant is optimal and is attained by $(r+1)\mathrm{sech}^2(rx)$, where $r=(\gamma-1/2)^{-1}$. No finite spectral cutoff is imposed.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Sharp one-dimensional Lieb–Thirring inequality | [LiebThirring.lean](../ComparatorChallenges/LiebThirring.lean) |
diff --git a/lean/docs/263.md b/lean/docs/263.md
new file mode 100644
index 0000000000000000000000000000000000000000..ed123c227c15aa12e1c7baa8f1adcb486d6fbbc0
--- /dev/null
+++ b/lean/docs/263.md
@@ -0,0 +1,20 @@
+# The ionization and generalized ionization conjectures
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [Generalized ionization energies for full Coulomb atoms](../../preprints/Generalized-ionization-energies-for-full-Coulomb-atoms-September-24-2026/paper.pdf)
+- [Generalized outer-electron radii of neutral Coulomb atoms](../../preprints/Generalized-outer-electron-radii-of-neutral-Coulomb-atoms-September-24-2026/paper.pdf)
+
+## Scope
+
+The formalization gives the large-ionization asymptotics for the full nonrelativistic two-spin Coulomb atom. Let $I_m(Z)$ be the energy needed to remove $m$ electrons from a neutral atom of nuclear charge $Z$. There is a positive coefficient $a_{\mathrm{TF}}$ with the Thomas–Fermi variational characterization such that $I_m(Z)/m^{7/3}\to a_{\mathrm{TF}}$ whenever $m\to\infty$ and $Z/m\to\infty$, with integers $Z>m\ge1$. The corresponding iterated limsup and liminf limits hold with $Z\to\infty$ first. The energy uses the full antisymmetric Sobolev form domain; fixed-$m$ convergence and ground-state attainment are outside this statement.
+
+For neutral Coulomb atoms with two electron spin states, the formalization proves the asymptotic law for generalized outer-electron radii defined by an expected exterior electron mass $m$. For every choice of normalized ground states, both the upper and lower large-nuclear-charge radius limits satisfy
+$m^{1/3}R_m\longrightarrow (81\pi^2/2)^{1/3}$ as $m\to\infty$. The large-nuclear-charge limit is taken first. Ground states are inputs to the statement; their existence is not asserted separately.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Generalized Coulomb ionization-energy asymptotics | [CoulombIonization.lean](../ComparatorChallenges/CoulombIonization.lean) |
+| Asymptotic outer-electron radii of neutral atoms | [CoulombRadii.lean](../ComparatorChallenges/CoulombRadii.lean) |
diff --git a/lean/docs/266.md b/lean/docs/266.md
new file mode 100644
index 0000000000000000000000000000000000000000..7c20d45303024a7e0ac7db1e65e95b24eec0f81d
--- /dev/null
+++ b/lean/docs/266.md
@@ -0,0 +1,23 @@
+# Exactly three mutually unbiased bases in dimension six
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [The maximum number of mutually unbiased bases in dimension six](../../preprints/The-maximum-number-of-mutually-unbiased-bases-in-dimension-six-September-24-2026/The-maximum-number-of-mutually-unbiased-bases-in-dimension-six-September-24-2026.pdf)
+- [Exact Fourier certificates for complex Hadamard matrices of order six](../../preprints/Exact-Fourier-certificates-for-complex-Hadamard-matrices-of-order-six-September-24-2026/Exact-Fourier-certificates-for-complex-Hadamard-matrices-of-order-six-September-24-2026.pdf)
+
+## Scope
+
+The paper claims that at most three mutually unbiased orthonormal bases exist in $\mathbb C^6$. The linked formalization proves a weaker family bound: every family in its mutually unbiased bases model has at most five members. It also proves a Fourier character-sum vanishing statement for order-six complex Hadamard matrices not equivalent to the Tao matrix, uniformly over coordinate permutations.
+
+The selected statement does not establish the paper's upper bound of three or its computer-assisted exclusion of four arbitrary bases.
+
+The linked formalization proves a cancellation lemma used in the order-six complex Hadamard analysis. Let $H$ and its entrywise square both be complex Hadamard matrices, and fix two distinct rows. If the cubes of their six entrywise ratios take only two distinct values, then the sum of the row-ratio terms over either specified cube fiber is zero.
+
+This is a supporting Fourier cancellation statement. The paper's full character-sum vanishing theorem and its mutually unbiased bases bound are outside this selected statement.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Order-six Hadamard Fourier vanishing and a five-basis upper bound | [MUBSix.lean](../ComparatorChallenges/MUBSix.lean) |
+| Cube-fiber cancellation for order-six Hadamard row ratios | [HadamardCubeFiber.lean](../ComparatorChallenges/HadamardCubeFiber.lean) |
diff --git a/lean/docs/267.md b/lean/docs/267.md
new file mode 100644
index 0000000000000000000000000000000000000000..c1cbf6be21bfb41bf18c72eb2174280879f3b38f
--- /dev/null
+++ b/lean/docs/267.md
@@ -0,0 +1,17 @@
+# Positive-temperature Bose–Einstein condensation and exact quantum depletion
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [Ground-state condensation in the dilute hard-sphere gas](../../preprints/Ground-state-condensation-in-the-dilute-hard-sphere-gas-September-24-2026/paper.pdf)
+
+## Scope
+
+The formalization proves ground-state Bose–Einstein condensation in the dilute hard-sphere gas. There are absolute constants $\varepsilon_0,c_0>0$ such that, whenever the density $\rho$ and hard-sphere radius $a$ satisfy $\rho a^3<\varepsilon_0$, the condensate occupation fraction has limit inferior at least $c_0$ along every thermodynamic sequence with $N/L^3\to\rho$.
+
+The bound covers every pure ground state, every mixed state supported on the ground space, and the normalized ground-space projection. It is uniform in the gas parameter within this range and concerns ground states, without a positive-temperature assertion.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Uniform ground-state condensation in the dilute hard-sphere gas | [HardSphere.lean](../ComparatorChallenges/HardSphere.lean) |
diff --git a/lean/docs/269.md b/lean/docs/269.md
new file mode 100644
index 0000000000000000000000000000000000000000..7ae324d902f282192afe1e6c4ebdbcba6a16944a
--- /dev/null
+++ b/lean/docs/269.md
@@ -0,0 +1,25 @@
+# Uniform Laughlin gap and stability under bounded scalar disorder
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [Uniform Stability of the Spherical Laughlin Gap](../../preprints/Uniform-Stability-of-the-Spherical-Laughlin-Gap-October-5-2026/uniform-stability-spherical-laughlin-gap.pdf)
+- [A Fock-space inequality and the Laughlin spectral gap](../../preprints/A-Fock-space-inequality-and-the-Laughlin-spectral-gap-September-24-2026/A-Fock-space-inequality-and-the-Laughlin-spectral-gap-September-24-2026.pdf)
+
+## Scope
+
+The linked formalization proves the uniform unperturbed gap estimate used in the paper's stability argument for the fermionic Laughlin state at filling $1/3$ on the sphere. At flux $q=3(N-1)$ and all sufficiently large particle numbers $N$, every antisymmetric state has $V_1$ energy at least $1/25$ times its squared distance from the Laughlin ground-state line.
+
+This selected statement is the unperturbed Fock-space inequality. Stability under projected one-body potentials and uniqueness of the perturbed ground state are outside it.
+
+The Laughlin spectral-gap problem asks for a positive gap that remains uniform as the system grows. The formalization includes the finite spherical $V_1$ bound of $1/100$ above the Laughlin state at flux $3(N-1)$ for all sufficiently large particle numbers $N$. It also proves the stronger Fock-space inequality $H_Q^2\ge\gamma H_Q$ for every fixed $0<\gamma<\gamma_*$ and all sufficiently large fluxes $Q$, independently of particle number, where $\gamma_*=4616733319001/10^{14}>1/25$.
+
+For the untruncated planar model, the formalization proves the corresponding inequality at the endpoint $\gamma_*$ on every homogeneous particle sector. These statements use coefficient one for each pair projector.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Uniform unperturbed spherical Laughlin gap inequality | [LaughlinGap.lean](../ComparatorChallenges/LaughlinGap.lean) |
+| Uniform Laughlin $V_1$ spectral gap | [Laughlin.lean](../ComparatorChallenges/Laughlin.lean) |
+| Uniform Fock-space spectral-gap inequality | [LaughlinFock.lean](../ComparatorChallenges/LaughlinFock.lean) |
+| Planar spectral-gap inequality | [LaughlinPlanar.lean](../ComparatorChallenges/LaughlinPlanar.lean) |
diff --git a/lean/docs/271.md b/lean/docs/271.md
new file mode 100644
index 0000000000000000000000000000000000000000..962cc2b8d52fa2cc986aa493ad03cab241fe7f68
--- /dev/null
+++ b/lean/docs/271.md
@@ -0,0 +1,17 @@
+# Bloch's law, its lattice correction, and the spherical magnetization law
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [Spontaneous magnetization in the quantum Heisenberg ferromagnet](../../preprints/Spontaneous-magnetization-in-the-quantum-Heisenberg-ferromagnet-September-24-2026/paper.pdf)
+
+## Scope
+
+The formalization proves spontaneous magnetization for the nearest-neighbor isotropic quantum Heisenberg ferromagnet on $\mathbb Z^d$ for every $d\ge3$ and every spin $S\in\{\tfrac12,1,\tfrac32,\ldots\}$. At every sufficiently low positive temperature, it constructs a translation-invariant equilibrium state satisfying the KMS condition for the zero-field dynamics and having magnetization at least $S/4$.
+
+It also proves convergence of the finite-volume dynamics to the infinite-volume dynamics used in the KMS statement.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Low-temperature spontaneous magnetization for every positive spin | [Heisenberg.lean](../ComparatorChallenges/Heisenberg.lean) |
diff --git a/lean/docs/272.md b/lean/docs/272.md
new file mode 100644
index 0000000000000000000000000000000000000000..959f2b1015727cd054c8786a340c3abaa284c78c
--- /dev/null
+++ b/lean/docs/272.md
@@ -0,0 +1,18 @@
+# Entanglement without distillable secret key
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [Entanglement with zero distillable secret key in local dimension ten](../../preprints/Entanglement-with-zero-distillable-secret-key-in-local-dimension-ten-September-27-2026/paper.pdf)
+
+## Scope
+
+The paper's entanglement construction yields counterexamples to PPT-composition claims. The linked formalization covers these consequences: two explicitly specified PPT maps on $10\times10$ complex matrices have a composition that is not entanglement breaking, and the nonzero Choi matrix of that composition has no nonzero product vector in its range. A separate trace-preserving PPT channel on $21\times21$ matrices has a square that is not entanglement breaking.
+
+The paper's zero-distillable-secret-key statement is outside these two selected Comparator statements.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| PPT channel on dimension 21 whose square is not entanglement breaking | [DimensionTenChannel.lean](../ComparatorChallenges/DimensionTenChannel.lean) |
+| Dimension-ten PPT pair with non-entanglement-breaking composition | [DimensionTenPair.lean](../ComparatorChallenges/DimensionTenPair.lean) |
diff --git a/lean/docs/273.md b/lean/docs/273.md
new file mode 100644
index 0000000000000000000000000000000000000000..d46c3d65b74c8831e63194b5c174e4f4b863f0fd
--- /dev/null
+++ b/lean/docs/273.md
@@ -0,0 +1,17 @@
+# The entropy photon-number inequality
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [The entropy photon-number inequality](../../preprints/The-entropy-photon-number-inequality-September-24-2026/paper.pdf)
+
+## Scope
+
+The formalization proves the entropy photon-number inequality for two independent bosonic inputs with finite mean energy and any finite positive number $n$ of modes. Write $N(\rho)=g^{-1}(S(\rho)/n)$, where $S$ is von Neumann entropy and $g(x)=(x+1)\log(x+1)-x\log x$ is the thermal entropy per mode. For a beam splitter of transmissivity $0\le\eta\le1$, its output satisfies $N(\rho_C)\ge\eta N(\rho_A)+(1-\eta)N(\rho_B)$.
+
+Entanglement among modes within either input is allowed. The thermal-attenuator minimum-output-entropy and broadcast-capacity consequences in the paper are outside this selected inequality.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Entropy photon-number inequality for finite-energy bosonic inputs | [EntropyPhotonNumber.lean](../ComparatorChallenges/EntropyPhotonNumber.lean) |
diff --git a/lean/docs/274.md b/lean/docs/274.md
new file mode 100644
index 0000000000000000000000000000000000000000..ce7dfdfdd23adbf658a561b00bf5281fd1f8dd54
--- /dev/null
+++ b/lean/docs/274.md
@@ -0,0 +1,21 @@
+# Parity is not in QAC<sup>0</sup>
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [Product-projection localization and the $\mathrm{QAC}^0$ parity lower bound](../../preprints/Product-projection-localization-and-the-QAC0-parity-lower-bound-September-24-2026/paper.pdf)
+- [Regular trajectories, pruning and quantum parity](../../preprints/Regular-trajectories-pruning-and-quantum-parity-September-24-2026/paper.pdf)
+
+## Scope
+
+The formalization rules out bounded-error parity computation by constant-depth quantum circuits with polynomially many zero-initialized ancillary qubits. For every fixed depth, polynomial bound on the total number of qubits, and $0<\varepsilon\le1/2$, every sufficiently large input length has an input on which the measured-output parity success probability is less than $1/2+\varepsilon$. A companion specialization gives success strictly below $2/3$. The formalization also includes the product-projection localization estimate supporting this bound.
+
+The formalized result supplies the polynomial-size parity consequence of the paper. For every fixed circuit depth and polynomial bound on the number of qubits, all sufficiently large input lengths have an input on which any such circuit computes measured-output parity with probability strictly below $2/3$. Ancillary qubits start at zero. The formalization also contains the general positive-advantage parity bound and its product-projection localization estimate; regular-trajectory propagation and pruning are not separate formalized statements here.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Constant-depth quantum parity lower bound | [QACParity.lean](../ComparatorChallenges/QACParity.lean) |
+| Polynomial-size parity specialization | [RegularParity.lean](../ComparatorChallenges/RegularParity.lean) |
+| Polynomial-size quantum parity lower bound | [RegularParity.lean](../ComparatorChallenges/RegularParity.lean) |
+| General positive-advantage parity lower bound | [QACParity.lean](../ComparatorChallenges/QACParity.lean) |
diff --git a/lean/docs/275.md b/lean/docs/275.md
new file mode 100644
index 0000000000000000000000000000000000000000..85c1f1f8df0a30bb4a69c87d689eefe0e5e6c3e4
--- /dev/null
+++ b/lean/docs/275.md
@@ -0,0 +1,21 @@
+# QMA-hardness of continuum Coulomb energy
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [Continuum Coulomb hardness with binary nuclear charges](../../preprints/Continuum-Coulomb-hardness-with-binary-nuclear-charges-September-24-2026/Continuum-Coulomb-hardness-with-binary-nuclear-charges-September-24-2026.pdf)
+- [QMA-hardness of continuum Coulomb energy with unit nuclear charges](../../preprints/QMA-hardness-of-continuum-Coulomb-energy-with-unit-nuclear-charges-September-24-2026/QMA-hardness-of-continuum-Coulomb-energy-with-unit-nuclear-charges-September-24-2026.pdf)
+
+## Scope
+
+The formalization proves QMA-hardness of approximating the electronic Coulomb spectral infimum in three-dimensional continuum space when positive integer nuclear charges are encoded in binary. The instances have distinct rational nuclear positions and a unary electron count, and the energy ranges over antisymmetric continuum states and all spin sectors. A deterministic polynomial-time many-one reduction produces the promise gap with threshold separation at least one, while keeping the complete output length polynomial. The same Comparator file also contains the companion unit-charge result.
+
+The formalization proves QMA-hardness of approximating the electronic ground-energy infimum for clamped unit-charge nuclei in the full spinful fermionic continuum. The reduction is deterministic and polynomial time, with rational nuclear positions and separated rational energy thresholds. No orbital basis, magnetic field, additional external potential, or binding premise is part of the input.
+
+The same Comparator file also includes the companion hardness result when positive integer nuclear charges are encoded in binary.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| QMA-hardness of continuum Coulomb energy with binary charges | [ContinuumCoulombHardness.lean](../ComparatorChallenges/ContinuumCoulombHardness.lean) |
+| QMA-hardness of continuum Coulomb ground-energy approximation | [ContinuumCoulombHardness.lean](../ComparatorChallenges/ContinuumCoulombHardness.lean) |
diff --git a/lean/docs/276.md b/lean/docs/276.md
new file mode 100644
index 0000000000000000000000000000000000000000..657963d5d9ffa8dae2294ad608fa6ac1d9e77087
--- /dev/null
+++ b/lean/docs/276.md
@@ -0,0 +1,15 @@
+# Classical capacity of generalized amplitude damping
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [Classical capacity and entropy inequalities for generalized amplitude damping](../../preprints/Classical-capacity-and-entropy-inequalities-for-generalized-amplitude-damping-September-24-2026/paper.pdf)
+
+## Scope
+
+The formalized result determines the unassisted classical capacity of every generalized amplitude-damping channel with parameters in $[0,1]^2$. Its unrestricted Holevo information is additive across every number of repeated uses, equals an attained scalar maximum, and agrees with the operational capacity per use. Every maximizing equiprobable phase-pair product ensemble attains the corresponding block value. Additivity with an arbitrary different partner channel and decoding by separate measurements are not included.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Additivity and capacity for generalized amplitude damping | [AmplitudeDamping.lean](../ComparatorChallenges/AmplitudeDamping.lean) |
diff --git a/lean/docs/277.md b/lean/docs/277.md
new file mode 100644
index 0000000000000000000000000000000000000000..52633f47e9a6ee9357751b19a548d4fb0c850af6
--- /dev/null
+++ b/lean/docs/277.md
@@ -0,0 +1,15 @@
+# Threshold repetition for entangled games
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [Threshold parallel repetition for finite-dimensional entangled games](../../preprints/Threshold-parallel-repetition-for-finite-dimensional-entangled-games-September-25-2026/paper.pdf)
+
+## Scope
+
+The formalization gives exponential threshold parallel repetition for every finite two-player game with arbitrary correlated questions. If its finite-dimensional entangled value is $v<1$, its answer sets are $A,B$, and $0<\delta<1-v$, then the probability of winning at least the fraction $v+\delta$ of $k$ repetitions is at most $\exp(-\kappa\delta^{13}k/(1+\log(|A||B|)))$ for one universal $\kappa>0$. The bound applies to every joint finite-dimensional strategy and to their supremum, without assuming attainment. The separate distribution-dependent cubic bound is outside this scope.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Threshold parallel repetition for entangled games | [EntangledGames.lean](../ComparatorChallenges/EntangledGames.lean) |
diff --git a/lean/docs/279.md b/lean/docs/279.md
new file mode 100644
index 0000000000000000000000000000000000000000..2217dfc3bb1e3cd8455177e3c0fbdf1e9446a20f
--- /dev/null
+++ b/lean/docs/279.md
@@ -0,0 +1,15 @@
+# Exact quantum factoring over a fixed finite gate set
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [Exact quantum factoring over a fixed finite gate set](../../preprints/Exact-quantum-factoring-over-a-fixed-finite-gate-set-September-25-2026/main.pdf)
+
+## Scope
+
+The formalization constructs a polynomial-time uniform quantum circuit family that outputs the complete prime factorization of every integer $N\ge2$ with probability exactly one. The circuits use one fixed finite set of bounded-arity gates, and both the gate count and number of qubits have polynomial worst-case bounds in the bit length of $N$. The probability-one conclusion is exact, rather than an asymptotic or bounded-error guarantee.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Exact quantum factoring over a fixed finite gate set | [ExactQuantumFactoring.lean](../ComparatorChallenges/ExactQuantumFactoring.lean) |
diff --git a/lean/docs/280.md b/lean/docs/280.md
new file mode 100644
index 0000000000000000000000000000000000000000..8d018ccad0b0dc0505b15112d49b8d84d19d2bec
--- /dev/null
+++ b/lean/docs/280.md
@@ -0,0 +1,17 @@
+# Unitary vertex operator algebras and conformal nets
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [Strongly rational unitary vertex operator algebras and conformal nets](../../preprints/Strongly-rational-unitary-vertex-operator-algebras-and-conformal-nets-September-25-2026/paper.pdf)
+
+## Scope
+
+The linked formalization proves the first construction step relating strongly rational unitary vertex operator algebras to conformal nets. For a simple unitary strongly rational vertex operator algebra, it establishes polynomial energy bounds and strong locality and constructs an irreducible conformal net with the stated covariance, vacuum, and positive-energy properties.
+
+The selected statement does not include complete rationality of the net, unitarizability of all simple modules, the braided tensor equivalence, or the classification of local extensions described in the paper.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Energy bounds, strong locality, and an irreducible conformal net | [VertexAlgebraNet.lean](../ComparatorChallenges/VertexAlgebraNet.lean) |
diff --git a/lean/docs/281.md b/lean/docs/281.md
new file mode 100644
index 0000000000000000000000000000000000000000..485fb111fff726999fa12dc47c2ce4431f9d2299
--- /dev/null
+++ b/lean/docs/281.md
@@ -0,0 +1,23 @@
+# QAOA attains the SK optimum in the thermodynamic-first limit
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [QAOA attains the SK ground-state energy in the thermodynamic-first limit](../../preprints/QAOA-attains-the-SK-ground-state-energy-in-the-thermodynamic-first-limit-September-25-2026/QAOA-attains-the-SK-ground-state-energy-in-the-thermodynamic-first-limit-September-25-2026.pdf)
+- [Full support of the zero-temperature Sherrington–Kirkpatrick order parameter](../../preprints/Full-support-of-the-zero-temperature-Sherrington-Kirkpatrick-order-parameter-September-27-2026/main.pdf)
+
+## Scope
+
+The linked formalization supplies variational identities for the Gaussian zero-field Sherrington–Kirkpatrick ground-state energy used in the paper's QAOA argument. Conditional on an admissible Parisi minimizer and its associated diffusion, it proves convergence of the finite-system ground-state energy, identifies its limit with the Parisi value, and gives equivalent terminal-martingale and integrated-curvature formulas.
+
+It also proves convergence of finite Gaussian coefficient sums to the curvature integral, which approaches the ground-state value as the terminal time tends to one. The selected statement covers these value and approximation results; it does not itself assert convergence of QAOA circuit energies.
+
+The formalization proves that every admissible integrable minimizer of the zero-temperature Parisi functional for the pure zero-field Sherrington–Kirkpatrick model has full relative Stieltjes support on $[0,1)$. Equivalently, the order parameter increases strictly between every two overlap values below one, so its support has no gap. The covariance normalization is $\xi(t)=t^2/2$.
+
+The statement also constructs the associated diffusion and proves its selected self-consistency moment identities. It is conditional on the order parameter being a minimizer and does not separately assert existence of a minimizer.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Parisi ground-state value identities and finite Gaussian approximation | [SKValue.lean](../ComparatorChallenges/SKValue.lean) |
+| Full support of zero-temperature SK minimizers | [SKFullSupport.lean](../ComparatorChallenges/SKFullSupport.lean) |
diff --git a/lean/docs/287.md b/lean/docs/287.md
new file mode 100644
index 0000000000000000000000000000000000000000..f88043225c5eafde7df79a32c5272f5cb14c44dc
--- /dev/null
+++ b/lean/docs/287.md
@@ -0,0 +1,15 @@
+# Isomorphism of the free group factors
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [An isomorphism of the free group factors](../../preprints/An-isomorphism-of-the-free-group-factors-September-23-2026/An-isomorphism-of-the-free-group-factors-September-23-2026.pdf)
+
+## Scope
+
+The free group factor problem asks whether the von Neumann algebras of free groups of different ranks are isomorphic. The formalization proves that interpolated free group factors with any parameters $r,s>1$, including the infinite parameter, are normally trace-preservingly isomorphic. The paper's fundamental-group conclusion is a further consequence rather than a separate selected statement here.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Isomorphism of all interpolated free group factors | [InterpolatedFactors.lean](../ComparatorChallenges/InterpolatedFactors.lean) |
diff --git a/lean/docs/288.md b/lean/docs/288.md
new file mode 100644
index 0000000000000000000000000000000000000000..4f53f8d88aee49fb6220f300b09a9754df5f5045
--- /dev/null
+++ b/lean/docs/288.md
@@ -0,0 +1,18 @@
+# Kadison's similarity conjecture
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [Kadison's similarity theorem through uniform derivation estimates](../../preprints/Kadisons-similarity-theorem-through-uniform-derivation-estimates-September-23-2026/paper.pdf)
+
+## Scope
+
+Kadison's similarity problem asks whether every bounded unital homomorphism from a unital complex $C^*$-algebra into operators on a Hilbert space is similar to a $*$-homomorphism. The formalization proves this for arbitrary Hilbert spaces. It also gives one universal hyperreflexivity constant for all unital von Neumann algebras.
+
+The linked commutator estimate is uniform over all finite matrix amplifications: its constant is independent of the algebra, Hilbert space, and amplification size. This is the quantitative derivation estimate supporting the similarity result.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Kadison's similarity theorem and uniform hyperreflexivity | [KadisonSimilarity.lean](../ComparatorChallenges/KadisonSimilarity.lean) |
+| Uniform amplified commutator estimate | [UniformCommutator.lean](../ComparatorChallenges/UniformCommutator.lean) |
diff --git a/lean/docs/289.md b/lean/docs/289.md
new file mode 100644
index 0000000000000000000000000000000000000000..5626f7421f04cffbbe214cc3b8ece7a90aa3db37
--- /dev/null
+++ b/lean/docs/289.md
@@ -0,0 +1,15 @@
+# Strong Kadison–Kastler stability and its spatial boundaries
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [Universal strong Kadison–Kastler stability](../../preprints/Universal-strong-Kadison-Kastler-stability-September-23-2026/paper.pdf)
+
+## Scope
+
+The formalization proves the strong Kadison–Kastler conjecture uniformly. For every $\varepsilon>0$, there is a $\delta>0$ such that any two unital von Neumann algebras on the same complex Hilbert space at Kadison–Kastler distance below $\delta$ are conjugate by a unitary $u$ with $\lVert u-1\rVert<\varepsilon$. The tolerance depends only on $\varepsilon$, uniformly over the algebras, their representations, and the Hilbert space.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Universal near-identity unitary conjugacy for close von Neumann algebras | [StrongKadisonKastler.lean](../ComparatorChallenges/StrongKadisonKastler.lean) |
diff --git a/lean/docs/290.md b/lean/docs/290.md
new file mode 100644
index 0000000000000000000000000000000000000000..3cccb68ec70fcd48b307dea633126cb0884ef96d
--- /dev/null
+++ b/lean/docs/290.md
@@ -0,0 +1,15 @@
+# Relative bicentralizers and modular spectral recovery
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [Bounded recovery for modular spectral averages](../../preprints/Bounded-recovery-for-modular-spectral-averages-September-23-2026/Bounded-recovery-for-modular-spectral-averages-September-23-2026.pdf)
+
+## Scope
+
+For a faithful normal state with scalar centralizer in the stated standard-space representation, the formalized result converts positive modular spectral averages into uniformly bounded algebra elements. Given unit vectors in shrinking spectral bands around a real number $s$ and a positive limiting symmetric average for a bounded operator $T$, it finds a subsequence of bounded algebra elements whose images under $T$ stay uniformly nonzero and whose spectral bands have four times the original widths. The absolute bicentralizer conjecture is not included.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Bounded recovery from modular spectral averages | [BoundedRecovery.lean](../ComparatorChallenges/BoundedRecovery.lean) |
diff --git a/lean/docs/291.md b/lean/docs/291.md
new file mode 100644
index 0000000000000000000000000000000000000000..b0918b0dc20ad3fcd50e73b0555aabeb00aa0044
--- /dev/null
+++ b/lean/docs/291.md
@@ -0,0 +1,17 @@
+# Cuntz comparison, nuclear dimension, and equivariant Jiang–Su stability
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [Tracial projection methods and uniform property $\Gamma$](../../preprints/Tracial-projection-methods-and-uniform-property-Gamma-September-23-2026/paper.pdf)
+
+## Scope
+
+The formalization proves that real rank zero of the uniform tracial ultrapower of the uniform tracial completion implies uniform property $\Gamma$ for a simple separable unital infinite-dimensional nuclear stably finite $C^*$-algebra with traces. The conclusion holds at every specified free ultrafilter under the corresponding real-rank-zero hypothesis.
+
+The linked comparison results also prove Jiang–Su absorption and uniform property $\Gamma$ for simple separable unital infinite-dimensional nuclear algebras with strict comparison, and for the stated stably projectionless nuclear algebras with bounded densely finite traces, a nonempty compact normalized trace base, and the prescribed finite-target-rank comparison condition.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Uniform property $\Gamma$ from tracial real rank zero | [UniformGamma.lean](../ComparatorChallenges/UniformGamma.lean) |
diff --git a/lean/docs/292.md b/lean/docs/292.md
new file mode 100644
index 0000000000000000000000000000000000000000..a6f876b86751a164d581b0841c5be2078260f99c
--- /dev/null
+++ b/lean/docs/292.md
@@ -0,0 +1,15 @@
+# Kirchberg's $`\mathcal O_2`$ norm-ultrapower embedding problem
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [An explicit obstruction to nuclear norm-ultrapower embeddings](../../preprints/An-explicit-obstruction-to-nuclear-norm-ultrapower-embeddings-September-23-2026/paper.pdf)
+
+## Scope
+
+Kirchberg's norm-ultrapower embedding problem asks whether separable $C^*$-algebras embed into norm ultrapowers of nuclear algebras. The formalization constructs an explicit separable unital full group $C^*$-algebra that has no unital embedding into $B^\omega$ for any nonzero unital nuclear $C^*$-algebra $B$ and any free ultrafilter $\omega$ on $\mathbb N$. In particular, it does not embed unitally into an ultrapower of the Cuntz algebra $\mathcal O_2$.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Obstruction to nuclear norm-ultrapower embeddings | [NuclearUltrapower.lean](../ComparatorChallenges/NuclearUltrapower.lean) |
diff --git a/lean/docs/293.md b/lean/docs/293.md
new file mode 100644
index 0000000000000000000000000000000000000000..1249174d1aa65d93fee7ee8f2530a6aa85c02eb6
--- /dev/null
+++ b/lean/docs/293.md
@@ -0,0 +1,26 @@
+# Invariant projections, hyperinvariant subspaces, and transitive algebras
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [Invariant-projection counterexamples for every irrational rotation](../../preprints/Invariant-projection-counterexamples-for-every-irrational-rotation-September-27-2026/paper.pdf)
+- [Backward intertwiners and a transitive commutant](../../preprints/Backward-intertwiners-and-a-transitive-commutant-September-27-2026/paper.pdf)
+
+## Scope
+
+For every irrational rotation angle $\theta\in(0,1)$, the formalization constructs a continuous nonnegative circle weight with a single zero and logarithmic integral $-\infty$ whose weighted rotation is nonzero and quasinilpotent. In its associated hyperfinite type $\mathrm{II}_1$ factor, the operator has no nontrivial invariant projection: $(1-p)Tp=0$ forces $p=0$ or $p=1$. The linked statements also include an earlier existence construction, a product realization, and the selected product model's Brown measure $\delta_0$.
+
+The formalization for the companion paper [Backward intertwiners and a transitive commutant](../../preprints/Backward-intertwiners-and-a-transitive-commutant-September-27-2026/paper.pdf) gives, on every separable infinite-dimensional complex Hilbert space, a nonzero quasinilpotent operator whose commutant is transitive, proper, and closed in the strong operator topology. Thus no nontrivial closed subspace is invariant under every operator in the commutant.
+
+The hyperinvariant-subspace problem asks whether every bounded operator on a complex Hilbert space has a nontrivial closed subspace invariant under every operator that commutes with it. The formalization gives a negative answer on every separable infinite-dimensional complex Hilbert space: there is a nonzero quasinilpotent operator with a transitive commutant. Its commutant is a proper unital operator algebra closed in the strong operator topology. The construction therefore has no nonzero proper closed hyperinvariant subspace.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Finite-factor invariant-projection counterexample | [FiniteFactor.lean](../ComparatorChallenges/FiniteFactor.lean) |
+| Quasinilpotent operator with transitive commutant | [BackwardIntertwiners.lean](../ComparatorChallenges/BackwardIntertwiners.lean) |
+| Continuous-weight invariant-projection counterexample | [ContinuousCircleWeight.lean](../ComparatorChallenges/ContinuousCircleWeight.lean) |
+| Quasinilpotent operator with a transitive commutant | [HyperinvariantSubspaces.lean](../ComparatorChallenges/HyperinvariantSubspaces.lean) |
+| Invariant-projection counterexamples for every irrational rotation | [IrrationalRotation.lean](../ComparatorChallenges/IrrationalRotation.lean) |
+| Brown measure of the selected product weighted shift | [ProductBrown.lean](../ComparatorChallenges/ProductBrown.lean) |
+| Quasinilpotent operator without a hyperinvariant subspace | [HyperinvariantSubspaces.lean](../ComparatorChallenges/HyperinvariantSubspaces.lean) |
diff --git a/lean/docs/294.md b/lean/docs/294.md
new file mode 100644
index 0000000000000000000000000000000000000000..5f4d7a3457804ea21fc8d404b883b3f517e93884
--- /dev/null
+++ b/lean/docs/294.md
@@ -0,0 +1,18 @@
+# Kaplansky's quasitrace conjecture and failure of tensor-product stable finiteness
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [A counterexample to Kaplansky's quasitrace conjecture and failure of tensor-product stable finiteness](../../preprints/A-counterexample-to-Kaplanskys-quasitrace-conjecture-September-23-2026/paper.pdf)
+
+## Scope
+
+Kaplansky's quasitrace conjecture predicts that every $2$-quasitrace on a $C^*$-algebra is a trace. The formalization constructs a separable $C^*$-algebra with normalized $2$-quasitraces and fixed positive contractions $a,b$ for which every such quasitrace satisfies $\mathrm{Re}(\tau(a+b)-\tau(a)-\tau(b))\ge1/144$. Thus none is additive on this pair.
+
+The formalization also gives simple stably finite $C^*$-algebras whose spatial tensor product is properly infinite, a separable stably finite algebra with no tracial state, and a tensor-product example in which normalized $2$-quasitraces are lost. These are the stable-finiteness consequences named in the paper's title.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Nonadditive normalized $2$-quasitraces | [KaplanskyQuasitrace.lean](../ComparatorChallenges/KaplanskyQuasitrace.lean) |
+| Tensor-product failure of stable finiteness and quasitrace consequences | [KaplanskyStableFiniteness.lean](../ComparatorChallenges/KaplanskyStableFiniteness.lean) |
diff --git a/lean/docs/295.md b/lean/docs/295.md
new file mode 100644
index 0000000000000000000000000000000000000000..d16c3ee0110ecbf28cf66f4f55d2a2aee898c747
--- /dev/null
+++ b/lean/docs/295.md
@@ -0,0 +1,15 @@
+# The Kadison–Ringrose cohomology conjecture
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [Vanishing of higher bounded Hochschild cohomology](../../preprints/Vanishing-of-higher-bounded-Hochschild-cohomology-September-23-2026/paper.pdf)
+
+## Scope
+
+The formalization proves vanishing of bounded Hochschild cohomology in every degree at least two for a complex von Neumann algebra with coefficients in itself. Every bounded multilinear cocycle of such a degree is the Hochschild differential of a bounded multilinear cochain one degree lower. No separability or type restriction is imposed. The degree-one inner-derivation theorem is outside this selected statement.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Bounded primitives for all Hochschild cocycles of degree at least two | [KadisonRingrose.lean](../ComparatorChallenges/KadisonRingrose.lean) |
diff --git a/lean/docs/296.md b/lean/docs/296.md
new file mode 100644
index 0000000000000000000000000000000000000000..7880f066737ca81ff0a7b0c174175eae0b4d6d61
--- /dev/null
+++ b/lean/docs/296.md
@@ -0,0 +1,18 @@
+# The generator problem for finite factors
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [Relative generation and the generator problem for finite factors](../../preprints/Relative-generation-and-the-generator-problem-for-finite-factors-September-23-2026/paper.pdf)
+
+## Scope
+
+The formalization answers the generator problem affirmatively for type $\mathrm{II}_1$ factors with separable predual: one bounded operator generates the factor under adjoints and weak-operator closure. It imposes no separability assumption on the representing Hilbert space or on the operator-norm topology.
+
+It also proves the paper's relative-generation result. For an irreducible inclusion of type $\mathrm{II}_1$ factors with separable predual for the larger factor, the unitaries that generate the larger factor together with the smaller one form a dense $G_\delta$ set in the normalized trace two-norm topology. The normalized faithful normal trace is included in the assertion.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Single generation of separable-predual $\mathrm{II}_1$ factors | [FactorGeneration.lean](../ComparatorChallenges/FactorGeneration.lean) |
+| Dense relative generators for irreducible inclusions of finite factors | [RelativeGeneration.lean](../ComparatorChallenges/RelativeGeneration.lean) |
diff --git a/lean/docs/297.md b/lean/docs/297.md
new file mode 100644
index 0000000000000000000000000000000000000000..c7330efc3100050dd191c1cfe24d6807aafab8b4
--- /dev/null
+++ b/lean/docs/297.md
@@ -0,0 +1,15 @@
+# A ZFC counterexample to Naimark's problem
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [A counterexample to Naimark's problem in ZFC](../../preprints/A-counterexample-to-Naimarks-problem-in-ZFC-September-24-2026/naimark-counterexample-zfc.pdf)
+
+## Scope
+
+Naimark's problem asks whether a $C^*$-algebra whose nonzero irreducible representations are all unitarily equivalent must be an algebra of compact operators. The formalization gives a counterexample in ZFC: a unital infinite-dimensional simple complex $C^*$-algebra with a faithful tracial state has that uniqueness property for irreducible representations but is not isomorphic to the compact operators on any Hilbert space. No additional set-theoretic assumption is used.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Counterexample to Naimark's problem in ZFC | [Naimark.lean](../ComparatorChallenges/Naimark.lean) |
diff --git a/lean/docs/298.md b/lean/docs/298.md
new file mode 100644
index 0000000000000000000000000000000000000000..aebc04d1615efaa41f701aa58e625e0616e14c8d
--- /dev/null
+++ b/lean/docs/298.md
@@ -0,0 +1,15 @@
+# Two notions of free entropy differ even when both are finite
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [A finite-entropy separation of microstates and nonmicrostates free entropy](../../preprints/A-finite-entropy-separation-of-microstates-and-nonmicrostates-free-entropy-September-25-2026/paper.pdf)
+
+## Scope
+
+The formalization disproves equality of microstates and nonmicrostates free entropy even when both quantities are finite. It constructs a bounded self-adjoint tuple $X$ in a von Neumann algebra with a faithful normal tracial state such that $-\infty<\chi(X)\le\chi^*(X)-1/2<\infty$. Here $\chi$ is the microstates entropy with an operator-norm cutoff and a limsup over matrix sizes, and $\chi^*$ is the nonmicrostates entropy defined using free semicircular noise. The example has a fixed finite number of variables.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Finite separation of microstates and nonmicrostates free entropy | [FiniteEntropySeparation.lean](../ComparatorChallenges/FiniteEntropySeparation.lean) |
diff --git a/lean/docs/299.md b/lean/docs/299.md
new file mode 100644
index 0000000000000000000000000000000000000000..1994ca1d2247cbb868cb7f454c718fd9d2e7553e
--- /dev/null
+++ b/lean/docs/299.md
@@ -0,0 +1,15 @@
+# The Kirchberg–Rørdam character criterion and infinite tensor-power Jiang–Su stability
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [The Kirchberg–Rørdam character criterion](../../preprints/The-Kirchberg-Rordam-character-criterion-September-25-2026/paper.pdf)
+
+## Scope
+
+The Kirchberg–Rørdam criterion relates Jiang–Su absorption to characters of the central-sequence algebra. The formalized result proves that, for every nonzero unital separable complex $C^*$-algebra $A$ and every free ultrafilter on $\mathbb N$, the norm central-sequence algebra has no nonzero character exactly when $A\cong A\otimes_{\min}\mathcal Z$. No nuclearity, simplicity, trace, or comparison hypothesis is imposed.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Kirchberg–Rørdam character criterion | [CharacterCriterion.lean](../ComparatorChallenges/CharacterCriterion.lean) |
diff --git a/lean/docs/303.md b/lean/docs/303.md
new file mode 100644
index 0000000000000000000000000000000000000000..7049784005b725f96532c0c0c471a270ec519b06
--- /dev/null
+++ b/lean/docs/303.md
@@ -0,0 +1,18 @@
+# Weak pure infiniteness and Cuntz-algebra absorption
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [Weak pure infiniteness and $\mathcal O_\infty$ absorption](../../preprints/Weak-pure-infiniteness-and-O-infinity-absorption-September-25-2026/paper.pdf)
+
+## Scope
+
+The formalization proves that a complex $C^*$-algebra in which every positive element is properly infinite is strongly purely infinite, with the full positive-element diagonalization property. No exactness, nuclearity, unitality, or simplicity assumption is needed for this implication.
+
+For exact algebras, proper infiniteness of one fixed finite amplification of every positive element already implies individual proper infiniteness and strong pure infiniteness.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Fixed-amplification pure infiniteness for exact algebras | [ExactInfiniteness.lean](../ComparatorChallenges/ExactInfiniteness.lean) |
+| Individual proper infiniteness implies strong pure infiniteness | [IndividualStrongInfiniteness.lean](../ComparatorChallenges/IndividualStrongInfiniteness.lean) |
diff --git a/lean/docs/307.md b/lean/docs/307.md
new file mode 100644
index 0000000000000000000000000000000000000000..c8e04530f3808bd9a4073e9731db397e4b5e396a
--- /dev/null
+++ b/lean/docs/307.md
@@ -0,0 +1,15 @@
+# Failure of rational injectivity for maximal coarse assembly
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [A counterexample to the coarse Novikov conjecture](../../preprints/A-counterexample-to-the-coarse-Novikov-conjecture-September-23-2026/paper.pdf)
+
+## Scope
+
+The coarse Novikov conjecture predicts rational injectivity of the ordinary coarse assembly map for uniformly discrete spaces of bounded geometry. The formalization constructs a counterexample from a coarse disjoint union of finite connected graphs with uniformly bounded degree. Its degree-one coarse $K$-homology contains an infinite-order class whose image under ordinary coarse assembly into the reduced locally compact Roe algebra vanishes. The class remains nonzero after tensoring with $\mathbb Q$, so rational injectivity fails.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Failure of rational injectivity for ordinary coarse assembly | [CoarseAssembly.lean](../ComparatorChallenges/CoarseAssembly.lean) |
diff --git a/lean/docs/312.md b/lean/docs/312.md
new file mode 100644
index 0000000000000000000000000000000000000000..8809125a2f4e2152d42ff19606abd00cdc00fbed
--- /dev/null
+++ b/lean/docs/312.md
@@ -0,0 +1,17 @@
+# The Grothendieck homotopy hypothesis
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [The Grothendieck homotopy hypothesis via elementary expansions](../../preprints/The-Grothendieck-homotopy-hypothesis-via-elementary-expansions-September-24-2026/paper.pdf)
+
+## Scope
+
+The Grothendieck homotopy hypothesis asks whether algebraic $\infty$-groupoids recover the homotopy theory of spaces. The formalized result is the elementary-expansion theorem used in this approach: for every Grothendieck coherator in the Ara–Henry convention and every boundary-cellular model, attaching an $(n+1)$-disk along its source $n$-face induces a weak equivalence.
+
+The later semi-model structure and full comparison with the homotopy theory of spaces are not included.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Elementary-expansion weak equivalence | [GrothendieckElementaryExpansion.lean](../ComparatorChallenges/GrothendieckElementaryExpansion.lean) |
diff --git a/lean/docs/317.md b/lean/docs/317.md
new file mode 100644
index 0000000000000000000000000000000000000000..4b60778639253c6f9e0e02712dffc489db4698cc
--- /dev/null
+++ b/lean/docs/317.md
@@ -0,0 +1,17 @@
+# Thomason model structures in all strict higher dimensions
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [Thomason Model Structures in Every Strict Higher Dimension](../../preprints/Thomason-Model-Structures-in-Every-Strict-Higher-Dimension-September-25-2026/paper.pdf)
+
+## Scope
+
+The formalization proves the higher-dimensional Thomason model-structure theorem for small strict globular $n$-categories in every positive finite dimension and in dimension $\omega$. Each category has the stated proper combinatorial model structure, Quillen equivalent to simplicial sets through the twice-subdivided categorification and twice-extended Street nerve adjunction.
+
+The selected statements also identify weak equivalences by the Street nerve in all these dimensions. Thus the constructions model the homotopy theory of spaces throughout the stated range.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Thomason model structures and nerve detection in all positive strict dimensions | [ThomasonModelStructures.lean](../ComparatorChallenges/ThomasonModelStructures.lean) |
diff --git a/lean/docs/322.md b/lean/docs/322.md
new file mode 100644
index 0000000000000000000000000000000000000000..2192f77c0186237291fc0d25898a2eb0bf58a5c0
--- /dev/null
+++ b/lean/docs/322.md
@@ -0,0 +1,15 @@
+# Tingley’s sphere-isometry problem
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [A positive solution to Tingley's problem](../../preprints/A-positive-solution-to-Tingleys-problem-September-23-2026/paper.pdf)
+
+## Scope
+
+Tingley's problem asks whether a surjective isometry between the unit spheres of Banach spaces extends to a linear isometry of the spaces. The formalized result gives a unique surjective real-linear isometric extension for arbitrary nonzero real Banach spaces, with no finite-dimensionality, separability, reflexivity, or convexity assumptions. For complex spaces viewed as real spaces, the conclusion is real linearity rather than complex linearity.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Tingley's sphere-isometry extension | [TingleySphereIsometry.lean](../ComparatorChallenges/TingleySphereIsometry.lean) |
diff --git a/lean/docs/323.md b/lean/docs/323.md
new file mode 100644
index 0000000000000000000000000000000000000000..06f548683b6ca3b1865b4618e3abbb517c25d007
--- /dev/null
+++ b/lean/docs/323.md
@@ -0,0 +1,17 @@
+# Independence of the separable quotient problem
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [Relative independence of the separable quotient problem](../../preprints/Relative-independence-of-the-separable-quotient-problem-September-23-2026/paper.pdf)
+
+## Scope
+
+The separable quotient problem asks whether every infinite-dimensional Banach space has an infinite-dimensional separable quotient. The linked formalization proves the negative direction under the continuum hypothesis: over both the real and complex fields, there is an infinite-dimensional Banach space admitting no bounded linear surjection onto an infinite-dimensional separable Banach space.
+
+This is the conditional counterexample direction. The positive consistency direction and the paper's full relative-independence conclusions are outside the selected statement.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Failure of the separable quotient assertion under the continuum hypothesis | [SeparableQuotientNegative.lean](../ComparatorChallenges/SeparableQuotientNegative.lean) |
diff --git a/lean/docs/324.md b/lean/docs/324.md
new file mode 100644
index 0000000000000000000000000000000000000000..199db22d10c26cc6ed9d160856a69f40ccfd1cf4
--- /dev/null
+++ b/lean/docs/324.md
@@ -0,0 +1,19 @@
+# Lipschitz equivalent Banach spaces need not be linearly isomorphic
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [Lipschitz Equivalent Separable Banach Spaces Need Not Be Linearly Isomorphic](../../preprints/Lipschitz-Equivalent-Separable-Banach-Spaces-Need-Not-Be-Linearly-Isomorphic-September-24-2026/paper.pdf)
+- [Bi-Lipschitz Absorption of $c_0$ Without a Linear Copy of $c_0$](../../preprints/Bi-Lipschitz-Absorption-of-c0-Without-a-Linear-Copy-of-c0-September-26-2026/paper.pdf)
+
+## Scope
+
+The formalized counterexample gives separable real Banach spaces $X,Y$ that are bi-Lipschitz equivalent but not linearly isomorphic. The bijection has lower Lipschitz bound $4/21$ and upper bound $76/25$. The linear obstruction is explicit: $X$ contains a linear isometric copy of $c_0(\ell_2)$, whereas $Y$ contains no bounded linear copy of that space.
+
+The formalized result constructs one separable real Banach space $X$ that is bi-Lipschitz equivalent to $X\times c_0$ but contains no closed linear subspace isomorphic to $c_0$. The same space contains a bi-Lipschitz copy of $c_0$, is bi-Lipschitz universal for separable metric spaces, and is not linearly isomorphic to $X\times c_0$. Thus nonlinear absorption of $c_0$ does not force a linear copy of it.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Bi-Lipschitz equivalent nonisomorphic Banach spaces | [LipschitzEquivalence.lean](../ComparatorChallenges/LipschitzEquivalence.lean) |
+| Bi-Lipschitz absorption of $c_0$ | [C0Absorption.lean](../ComparatorChallenges/C0Absorption.lean) |
diff --git a/lean/docs/325.md b/lean/docs/325.md
new file mode 100644
index 0000000000000000000000000000000000000000..cd4d083eceaf63a4ababffa7a7b43a993c21be54
--- /dev/null
+++ b/lean/docs/325.md
@@ -0,0 +1,24 @@
+# The complete Crouzeix conjecture
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [A direct proof of the complete Crouzeix inequality](../../preprints/A-direct-proof-of-the-complete-Crouzeix-inequality-September-26-2026/paper.pdf)
+- [The complete Crouzeix theorem: optimal similarity and a common positive boundary representation](../../preprints/The-complete-Crouzeix-theorem-September-23-2026/paper.pdf)
+
+## Scope
+
+The complete Crouzeix inequality bounds a matrix-valued polynomial evaluated at a matrix by its maximum norm on the numerical range. The formalized result proves the bound with constant $2$ for every positive matrix and coefficient size, every polynomial degree, and arbitrary complex coefficients. It also proves that no smaller universal constant works. Normality of the matrix and nonempty interior of its numerical range are not assumed.
+
+The formalization proves the complete Crouzeix inequality with sharp constant two for every bounded operator on an arbitrary complex Hilbert space. For every matrix-valued polynomial, its operator evaluation has norm at most twice its supremum norm on the numerical range. The same bound holds for finite matrix-valued functions holomorphic near the closure of the numerical range and for rational functions with poles outside that closure. No separability assumption is required.
+
+For finite matrices in a bounded convex domain with regular real-analytic Jordan boundary, the structural result gives an attained optimal similarity with condition number at most two and one continuous positive boundary density of mass the identity representing every matrix-valued analytic test. The linked supporting statements include numerical-range geometry and finite-compression identities.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Complete Crouzeix inequality and sharpness | [DirectCrouzeix.lean](../ComparatorChallenges/DirectCrouzeix.lean) |
+| Complete polynomial inequality and sharpness | [CompleteCrouzeix.lean](../ComparatorChallenges/CompleteCrouzeix.lean) |
+| Optimal similarity and boundary representation | [StructuralCrouzeix.lean](../ComparatorChallenges/StructuralCrouzeix.lean) |
+| Complete sharp Crouzeix theorem on arbitrary Hilbert spaces | [CrouzeixHilbert.lean](../ComparatorChallenges/CrouzeixHilbert.lean) |
+| Numerical-range geometry and finite-compression support | [HilbertCrouzeix.lean](../ComparatorChallenges/HilbertCrouzeix.lean) |
diff --git a/lean/docs/326.md b/lean/docs/326.md
new file mode 100644
index 0000000000000000000000000000000000000000..178bcf2e1441413c9b325c765a2a35e337ebc758
--- /dev/null
+++ b/lean/docs/326.md
@@ -0,0 +1,15 @@
+# The cotype–cotype conjecture under the approximation property
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [The cotype–cotype conjecture under the approximation property](../../preprints/The-cotype-cotype-conjecture-under-the-approximation-property-September-23-2026/paper.pdf)
+
+## Scope
+
+The cotype–cotype problem asks whether finite cotype of a Banach space and its dual characterizes $K$-convexity. The formalized result establishes this equivalence for every nonzero real Banach space with the approximation property: $X$ is $K$-convex exactly when both $X$ and $X^*$ have finite cotype.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Cotype–cotype equivalence with approximation property | [Cotype.lean](../ComparatorChallenges/Cotype.lean) |
diff --git a/lean/docs/327.md b/lean/docs/327.md
new file mode 100644
index 0000000000000000000000000000000000000000..033c3ae17bbdf9b25bceb39924bc3fc9497d8cec
--- /dev/null
+++ b/lean/docs/327.md
@@ -0,0 +1,15 @@
+# Markov type characterizes superreflexivity
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [Nontrivial Markov Type Forces Superreflexivity](../../preprints/Nontrivial-Markov-Type-Forces-Superreflexivity-September-23-2026/paper.pdf)
+
+## Scope
+
+The formalized result proves that a real Banach space has nontrivial Markov type exactly when it admits an equivalent uniformly convex norm, hence exactly when it is superreflexive. Nontrivial Markov type means a uniform Markov-type bound for some exponent $p>1$ over all finite stationary reversible chains and all positive times. The exponent and equivalent norm may depend on the space, and the zero space is included. Additional formalized consequences concern uniformly smooth renormings and reflexivity of finitely representable spaces.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Nontrivial Markov type and superreflexivity | [MarkovType.lean](../ComparatorChallenges/MarkovType.lean) |
diff --git a/lean/docs/328.md b/lean/docs/328.md
new file mode 100644
index 0000000000000000000000000000000000000000..c29144b3feb6e9fe48844568236d5bf4dd3a186d
--- /dev/null
+++ b/lean/docs/328.md
@@ -0,0 +1,15 @@
+# Nonexpansive fixed points in reflexive Banach spaces
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [Fixed Points of Nonexpansive Maps in Reflexive Banach Spaces](../../preprints/Fixed-Points-of-Nonexpansive-Maps-in-Reflexive-Banach-Spaces-September-24-2026/paper.pdf)
+
+## Scope
+
+The fixed-point question asks whether reflexivity suffices for nonexpansive maps on bounded convex sets. The formalized result gives an affirmative answer: every nonexpansive self-map of a nonempty closed bounded convex subset of a real reflexive Banach space has a fixed point in the original norm. Zero and nonseparable spaces are included, with no uniform convexity, normal structure, or weak-continuity assumption.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Nonexpansive fixed points in reflexive spaces | [ReflexiveFixedPoints.lean](../ComparatorChallenges/ReflexiveFixedPoints.lean) |
diff --git a/lean/docs/329.md b/lean/docs/329.md
new file mode 100644
index 0000000000000000000000000000000000000000..23c894215506c1187febc5dc4385bf0304d5c78b
--- /dev/null
+++ b/lean/docs/329.md
@@ -0,0 +1,15 @@
+# A counterexample to metric-entropy duality
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [Counterexamples to the duality conjecture for metric entropy](../../preprints/Counterexamples-to-the-duality-conjecture-for-metric-entropy-September-24-2026/main.pdf)
+
+## Scope
+
+Metric-entropy duality predicts a universal comparison between covering numbers of convex bodies and their polars. The formalized result disproves such a comparison: for every $a,b\ge1$, there is an origin-symmetric convex body $K$ in a positive finite dimension with $\log N(K,B_\infty)>b\log N(B_\infty^\circ,a^{-1}K^\circ)$, where $N$ is the least number of translates in a finite cover. A further construction makes the dual-to-primal logarithmic entropy ratio tend to zero as the dimension grows.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Counterexample to metric-entropy duality | [MetricEntropyDuality.lean](../ComparatorChallenges/MetricEntropyDuality.lean) |
diff --git a/lean/docs/330.md b/lean/docs/330.md
new file mode 100644
index 0000000000000000000000000000000000000000..0793e4e8a54582407e42022924db916f5149db98
--- /dev/null
+++ b/lean/docs/330.md
@@ -0,0 +1,18 @@
+# A uniformly discrete counterexample to bounded approximation in Lipschitz-free spaces
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [A uniformly discrete counterexample to bounded approximation in Lipschitz-free spaces](../../preprints/Failure-of-Bounded-Approximation-in-a-Lipschitz-Free-Space-over-a-Uniformly-Discrete-Metric-Space-September-26-2026/main.pdf)
+
+## Scope
+
+Kalton's question asks whether uniform discreteness of a metric space forces its Lipschitz-free space to have the bounded approximation property. The formalization constructs a countable metric space with all distinct points at distance at least one whose real Lipschitz-free space has the approximation property but fails every bounded approximation bound. The metric space is unbounded and not proper.
+
+The earlier quantitative renorming result for real $\ell_1$ is retained: for each integer $p\ge1$, an equivalent complete norm has the $2B_p$-bounded approximation property but fails the $p$-bounded approximation property, where $B_p=300p^2+150p+5$.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Quantitative renorming of real $\ell_1$ | [RealL1Renorming.lean](../ComparatorChallenges/RealL1Renorming.lean) |
+| Uniformly discrete Lipschitz-free space with AP but no BAP | [DiscreteLipschitzFree.lean](../ComparatorChallenges/DiscreteLipschitzFree.lean) |
diff --git a/lean/docs/331.md b/lean/docs/331.md
new file mode 100644
index 0000000000000000000000000000000000000000..eaf81dd51cc733e19b8419a96ad254d430bcd40f
--- /dev/null
+++ b/lean/docs/331.md
@@ -0,0 +1,53 @@
+# Reflexive midpoint convexity and diamond distortion
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [Asymptotic midpoint uniform convexity and unbounded diamond distortion in a reflexive tree space](../../preprints/Asymptotic-midpoint-uniform-convexity-and-unbounded-diamond-distortion-in-a-reflexive-tree-space-September-27-2026/manuscript.pdf)
+- [Midpoint lenses in segment spaces](../../preprints/Midpoint-lenses-in-segment-spaces-September-27-2026/manuscript.pdf)
+- [Distortion of countably branching diamonds from midpoint and tree energies](../../preprints/Diamond-distortion-from-midpoint-and-tree-energies-September-27-2026/manuscript.pdf)
+- [Exact asymptotic moduli in a Daugavet subspace of $L_1$](../../preprints/Exact-asymptotic-moduli-in-a-Daugavet-subspace-of-L1-September-27-2026/manuscript.pdf)
+- [Midpoint convexity from bounded tree potentials and path costs](../../preprints/Midpoint-convexity-from-bounded-tree-potentials-and-path-costs-September-27-2026/manuscript.pdf)
+- [Independent products in real $L_1$: asymptotic midpoint convexity without AUC renormings](../../preprints/Independent-products-in-real-L1-asymptotic-midpoint-convexity-without-AUC-renormings-September-27-2026/manuscript.pdf)
+- [Midpoint convexity from two recursive potentials](../../preprints/Midpoint-convexity-from-two-recursive-potentials-September-27-2026/manuscript.pdf)
+
+## Scope
+
+The paper constructs a Banach space whose midpoint geometry is asymptotically uniformly convex even though no equivalent norm is asymptotically uniformly convex in the usual one-sided sense. The formalization proves that the full dual of the specified segment-norm completion is infinite-dimensional, separable, and reflexive; its averaged midpoint modulus is at least $\sqrt{1+t^2/12}-1$ for every $t>0$, while every equivalent norm fails asymptotic uniform convexity. It also proves that an embedding of a depth-$k$ countably branching diamond has distortion at least $\sqrt{1+k/12}$.
+
+The general-forest and word-forest results use the closed span of the coordinate functionals. Their conclusions retain the finite-ancestor and equivalent-norm hypotheses, including the scale $\alpha/(2\beta)$ when $0<\alpha\le\beta$ and the new norm lies between $\alpha$ and $\beta$ times the original norm; they do not identify that span with the full dual or assert reflexivity for every forest.
+
+The paper controls midpoint lenses in Banach spaces defined by tree-segment norms. The formalization proves the following estimate in both the full dual of the finite-height forest space and the coordinate predual of the infinite-tree space. If $x$ is supported on a finite ancestral set $H$, $R\ge0$, and $\|x+y\|,\|x-y\|\le R$, then the part of $y$ outside $H$ has norm at most $2\sqrt{R^2-\|x\|^2}$.
+
+The formalization also covers selected consequences for averaged midpoint moduli and separated families of vectors, together with reflexivity and renorming obstructions. This scope concerns the segment-space results; the companion results on diamond energies remain separate.
+
+The paper studies embeddings of countably branching diamond graphs into Banach spaces built from tree segments. The formalization proves that every embedding of the depth-$k$ diamond with distortion $D$, at any positive scale, satisfies $1+k/4\le D^2$ in either of two spaces: the full dual of the completed finite-height forest space and the closed coordinate span in the dual of the infinite-tree space. The bound applies to all pairs of vertices and is unconditional.
+
+The formalization also contains selected graph deductions under explicit companion assumptions. Twenty-two of those companion inputs are assumed in these deductions; the diamond distortion bound above does not require them.
+
+The paper exhibits a real $L_1$ subspace with positive averaged midpoint convexity but no equivalent asymptotically uniformly convex norm. For every closed infinite-dimensional subspace whose unit ball is precompact in measure and which has the Daugavet property, the formalization computes the moduli at every unit vector: the averaged midpoint modulus is $\max(t/2,t-1)$ and the usual one-sided asymptotic modulus is $\max(0,t-2)$ for every $t>0$. The same formulas hold after taking the infimum over unit vectors, and every equivalent norm fails asymptotic uniform convexity.
+
+The formalization also constructs such a subspace on a countable product of unit intervals and proves that it has the stated measure-precompactness and Daugavet properties, so the modulus formulas apply to an actual example.
+
+The paper constructs Banach spaces from bounded tree potentials and path costs to separate averaged midpoint convexity from asymptotic uniform convexity. For the specified tree-potential completions, the formalization proves completeness, separability, infinite dimension, and an averaged midpoint modulus of at least $\sqrt{1+t^2/4}-1$ for $0<t<1$. No space linearly isomorphic to one of these completions is asymptotically uniformly convex.
+
+The formalization also covers selected path-cost duality and comparison results, clipping and energy estimates, and further renorming obstructions. These retain their stated support, head, and tail hypotheses; the remaining auxiliary assertions of the paper are outside this scope.
+
+The paper forms a real $L_1$ space from the closed span of products of independent multipliers along tree paths. For a positive, nonconstant multiplier of mean one and finite second moment, the formalization proves that this space is infinite-dimensional and has no equivalent asymptotically uniformly convex norm.
+
+For every $t>0$, the averaged midpoint modulus nevertheless has explicit positive lower bounds. If $G$ is a standard real Gaussian, the exponential-multiplier bound is $\frac{7t}{480}\mathbb E[(|G|-20/t)_+]$, where $u_+=\max(u,0)$. For squared-Gaussian multipliers, the bounds are $\frac18\Pr(|G|\ge4\sqrt2(2+\sqrt2)/t)$ and $\frac14\Pr(|G|\ge8\sqrt6/t)$.
+
+The paper constructs three Banach spaces from recursive tree potentials: a root-sum space, a zero-root space, and a joined space. The formalization proves that all three are infinite-dimensional and have no equivalent asymptotically uniformly convex norm. The root-sum and joined spaces have averaged midpoint modulus at least $t^3/128$ for $0<t<1$, and the root-sum modulus is positive for every $t>0$. The zero-root estimate retains its finite ancestral support and tail hypotheses, and the zero-root and joined spaces are reflexive.
+
+The formalization also covers a separated-midpoint result for the joined space and a variable-exponent model with its recursive norm, duality, projections, renorming obstruction, and sixth- and third-order stability estimates. The separation, sequence, support, and head assumptions in these results are essential parts of their statements.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Reflexive tree space, midpoint modulus, and diamond distortion | [ForestSpace.lean](../ComparatorChallenges/ForestSpace.lean) |
+| Midpoint-lens tail estimate | [MidpointLenses.lean](../ComparatorChallenges/MidpointLenses.lean) |
+| All-pairs diamond distortion bound | [DiamondDistortion.lean](../ComparatorChallenges/DiamondDistortion.lean) |
+| Exact asymptotic moduli and a Daugavet example | [DaugavetModuli.lean](../ComparatorChallenges/DaugavetModuli.lean) |
+| Tree-potential midpoint convexity and renorming obstruction | [BoundedTreePotentials.lean](../ComparatorChallenges/BoundedTreePotentials.lean) |
+| Independent-product spaces and positive midpoint moduli | [IndependentProducts.lean](../ComparatorChallenges/IndependentProducts.lean) |
+| Recursive-potential spaces and midpoint convexity | [RecursivePotentials.lean](../ComparatorChallenges/RecursivePotentials.lean) |
diff --git a/lean/docs/333.md b/lean/docs/333.md
new file mode 100644
index 0000000000000000000000000000000000000000..5f2c3e53837b4695d4753e8fb097450e2c9b50ab
--- /dev/null
+++ b/lean/docs/333.md
@@ -0,0 +1,15 @@
+# Smooth isometric immersions of surfaces into ℝ<sup>4</sup>
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [Smooth isometric immersions of closed surfaces into Euclidean four-space](../../preprints/Smooth-isometric-immersions-of-closed-surfaces-into-Euclidean-four-space-September-23-2026/paper.pdf)
+
+## Scope
+
+The formalization proves that every closed smooth Riemannian surface admits a smooth isometric immersion into $\mathbb R^4$. The differential preserves the Riemannian inner product on every tangent space. No orientability assumption is imposed, and the statement asks for an immersion rather than an embedding.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Smooth isometric immersion of every closed surface into four-space | [SurfaceImmersion.lean](../ComparatorChallenges/SurfaceImmersion.lean) |
diff --git a/lean/docs/334.md b/lean/docs/334.md
new file mode 100644
index 0000000000000000000000000000000000000000..31005e3616cc7ba130591ed989aca8b0f9c43107
--- /dev/null
+++ b/lean/docs/334.md
@@ -0,0 +1,15 @@
+# A smooth surface metric with no local isometric immersion in ℝ<sup>3</sup>
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [A Smooth Metric with No Local Isometric Immersion into Three-Space](../../preprints/A-Smooth-Metric-with-No-Local-Isometric-Immersion-into-Three-Space-September-24-2026/paper.pdf)
+
+## Scope
+
+The local isometric-immersion problem asks whether every smooth surface metric can be realized locally in Euclidean three-space. The formalized counterexample is a smooth positive-definite metric on $(-1,1)^2$ for which no neighborhood of the origin admits a smooth isometric immersion into $\mathbb R^3$. The obstruction applies to every smooth candidate map on every such neighborhood.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Smooth local isometric-immersion obstruction | [IsometricImmersion.lean](../ComparatorChallenges/IsometricImmersion.lean) |
diff --git a/lean/docs/337.md b/lean/docs/337.md
new file mode 100644
index 0000000000000000000000000000000000000000..3b520f51b57819294274727bc05c8fb425021e3e
--- /dev/null
+++ b/lean/docs/337.md
@@ -0,0 +1,18 @@
+# Sharp Cartan–Hadamard isoperimetry and rigidity
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [Sharp integral fillings in $\mathrm{CAT}(0)$ spaces](../../preprints/Sharp-integral-fillings-in-CAT(0)-spaces-September-23-2026/paper.pdf)
+
+## Scope
+
+The formalization proves the sharp Euclidean filling inequality for every compactly supported integral $n$-cycle in a proper $\mathrm{CAT}(0)$ space, for $n\ge2$. It constructs a compactly supported integral filling whose mass is at most $C_n$ times the boundary mass to the power $(n+1)/n$, where $C_n$ is the Euclidean isoperimetric coefficient. Integer multiplicities and the ambient dimension are unrestricted.
+
+A second statement proves that this coefficient is optimal by giving, in Euclidean space, a cycle for which every compactly supported integral filling has at least that mass. This yields the selected integral-current form of the Cartan–Hadamard isoperimetric conjecture.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Optimality of the Euclidean filling coefficient | [FillingCoefficient.lean](../ComparatorChallenges/FillingCoefficient.lean) |
+| Sharp integral fillings in proper $\mathrm{CAT}(0)$ spaces | [SharpCAT0Filling.lean](../ComparatorChallenges/SharpCAT0Filling.lean) |
diff --git a/lean/docs/342.md b/lean/docs/342.md
new file mode 100644
index 0000000000000000000000000000000000000000..890c10b573d2d383741d727fba384d4e52c0942e
--- /dev/null
+++ b/lean/docs/342.md
@@ -0,0 +1,15 @@
+# Donaldson's tamed-to-compatible conjecture
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [Taming implies compatibility on four-manifolds](../../preprints/Taming-implies-compatibility-on-four-manifolds-September-23-2026/paper.pdf)
+
+## Scope
+
+Donaldson's tamed-to-compatible conjecture asks whether an almost-complex structure tamed by a symplectic form also admits a compatible symplectic form. The formalized result establishes this for every closed connected smooth four-manifold, keeping the almost-complex structure fixed. No integrability assumption or prescribed cohomology class for the compatible form is required.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Taming implies compatibility | [TamingCompatibility.lean](../ComparatorChallenges/TamingCompatibility.lean) |
diff --git a/lean/docs/343.md b/lean/docs/343.md
new file mode 100644
index 0000000000000000000000000000000000000000..738242c0bdf28e2d5e00163585d58290f4cf1653
--- /dev/null
+++ b/lean/docs/343.md
@@ -0,0 +1,18 @@
+# Symplectic ball packing in higher dimensions
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [Symplectic Ball Packings in Higher Dimensions](../../preprints/Symplectic-Ball-Packings-in-Higher-Dimensions-September-23-2026/paper.pdf)
+
+## Scope
+
+The formalization proves Siegel and Yao's ball-packing criterion in every symplectic dimension $2n$ with $n\ge3$. For $k\ge1$ closed standard balls of positive capacities $R_1,\ldots,R_k$, disjoint symplectic embeddings into the interior of a ball of capacity $R$ exist exactly when
+$\sum_i R_i^n<R^n$ and $R_i+R_j<R$ for all $i\ne j$.
+Capacity is $\pi$ times squared Euclidean radius, and each embedding is defined on a neighborhood of its closed source ball. The linked statements include both the full equivalence and the necessity direction.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Exact criterion for higher-dimensional symplectic ball packings | [BallPacking.lean](../ComparatorChallenges/BallPacking.lean) |
+| Necessity of the volume and pairwise capacity inequalities | [BallPackingNecessity.lean](../ComparatorChallenges/BallPackingNecessity.lean) |
diff --git a/lean/docs/347.md b/lean/docs/347.md
new file mode 100644
index 0000000000000000000000000000000000000000..befa6c4a0dc6d33d0fa048b42caee2f6c972e777
--- /dev/null
+++ b/lean/docs/347.md
@@ -0,0 +1,15 @@
+# Counterexamples to stable-Morse and strong Arnold fixed-point bounds
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [Three fixed points on the symplectic quadric threefold](../../preprints/A-degenerate-counterexample-to-the-critical-number-Arnold-bound-September-23-2026/paper.pdf)
+
+## Scope
+
+The critical-number form of Arnold's fixed-point conjecture predicts at least as many fixed points as the minimum number of critical points of a smooth function. The formalized counterexample is a Hamiltonian diffeomorphism of the complex quadric threefold with exactly three fixed points, while every smooth function on that manifold has at least four critical points. At least one fixed point is degenerate. The separate nondegenerate Morse-number construction is not included.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Three-fixed-point Arnold counterexample | [ArnoldCounterexample.lean](../ComparatorChallenges/ArnoldCounterexample.lean) |
diff --git a/lean/docs/348.md b/lean/docs/348.md
new file mode 100644
index 0000000000000000000000000000000000000000..0a0517abbc25c2fd102ee574c7b159858785e6a6
--- /dev/null
+++ b/lean/docs/348.md
@@ -0,0 +1,15 @@
+# Nonnegative-curvature Einstein classification and an <i>L</i><sup>2</sup> topological gap
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [Positively curved Einstein four-manifolds](../../preprints/Positively-curved-Einstein-four-manifolds-September-23-2026/paper.pdf)
+
+## Scope
+
+The formalization classifies connected smooth closed Einstein four-manifolds with strictly positive sectional curvature. Up to positive scaling and isometry, every such manifold is the round four-sphere, the complex projective plane with its Fubini–Study metric, or round real projective four-space. No orientability hypothesis is required. In the oriented case, only the sphere and complex projective plane occur.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Classification of positively curved Einstein four-manifolds | [EinsteinFour.lean](../ComparatorChallenges/EinsteinFour.lean) |
diff --git a/lean/docs/350.md b/lean/docs/350.md
new file mode 100644
index 0000000000000000000000000000000000000000..0dcd752770fb992be6b73d02268d34e6bd2189cd
--- /dev/null
+++ b/lean/docs/350.md
@@ -0,0 +1,23 @@
+# Yau’s nodal bounds: surfaces and higher dimensions
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [Sharp nodal length on smooth surfaces](../../preprints/Sharp-nodal-length-on-smooth-surfaces-September-23-2026/paper.pdf)
+- [Smooth counterexamples to Yau's nodal upper bound in dimensions three and four](../../preprints/Smooth-counterexamples-to-Yaus-nodal-upper-bound-in-dimensions-three-and-four-September-23-2026/paper.pdf)
+- [Power-law violations of Yau's nodal upper bound](../../preprints/Power-law-violations-of-Yaus-nodal-upper-bound-September-23-2026/paper.pdf)
+
+## Scope
+
+Yau's nodal-set conjecture predicts nodal size of order $\sqrt\lambda$ for Laplace eigenfunctions of eigenvalue $\lambda$. The formalization proves the upper bound on every fixed smooth closed connected Riemannian surface: there is a surface-dependent constant $C$ such that the one-dimensional Hausdorff measure of the zero set of every nonzero real eigenfunction with $\lambda>0$ is at most $C\sqrt\lambda$. The known lower bound is not part of this selected statement.
+
+The formalized results contradict Yau's proposed $O(\sqrt\lambda)$ upper bound for nodal measure in dimensions three and four. On $S^3$, every prescribed smooth neighborhood of the round metric contains one fixed smooth metric with an eigenfunction sequence of unbounded nodal-measure ratio. A second fixed metric on $S^2\times T^2$ has the same property. In both cases the eigenvalues tend to infinity and the intrinsic nodal measures are finite.
+
+Yau's nodal upper-bound conjecture predicts that the nodal measure of an eigenfunction is bounded by a constant times the square root of its eigenvalue. The formalized counterexample fixes one smooth metric on $S^4\times S^1$ and a sequence of nonzero smooth eigenfunctions whose positive eigenvalues tend to infinity, while the intrinsic four-dimensional nodal measures divided by the square roots of the eigenvalues tend to infinity. The metric is fixed throughout the sequence.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Sharp upper bound for nodal length on smooth surfaces | [NodalLength.lean](../ComparatorChallenges/NodalLength.lean) |
+| Nodal counterexamples in dimensions three and four | [SmoothYau.lean](../ComparatorChallenges/SmoothYau.lean) |
+| Unbounded nodal ratio on $S^4\times S^1$ | [YauCounterexample.lean](../ComparatorChallenges/YauCounterexample.lean) |
diff --git a/lean/docs/353.md b/lean/docs/353.md
new file mode 100644
index 0000000000000000000000000000000000000000..f397f0b8b6417831c6e91065a04ea172fbf8c307
--- /dev/null
+++ b/lean/docs/353.md
@@ -0,0 +1,17 @@
+# Affine Bernstein rigidity through dimension nine and a smooth dimension-ten counterexample
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [The affine Bernstein theorem in dimensions three through nine](../../preprints/The-affine-Bernstein-theorem-in-dimensions-three-through-nine-September-24-2026/main.pdf)
+
+## Scope
+
+The formalization proves the Euclidean-complete affine Bernstein theorem for graph dimensions $3\le n\le9$. If a smooth function on a nonempty open convex domain has positive-definite Hessian, satisfies the affine maximal equation, and its graph is complete in the induced Euclidean metric, then the domain is all of $\mathbb R^n$ and the function is a positive-definite quadratic polynomial plus an affine term. Its graph is therefore an elliptic paraboloid.
+
+The paper's extension to immersed hypersurfaces without an initial graph assumption is outside this selected statement.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Affine Bernstein classification for complete graphs in dimensions three through nine | [AffineBernstein.lean](../ComparatorChallenges/AffineBernstein.lean) |
diff --git a/lean/docs/354.md b/lean/docs/354.md
new file mode 100644
index 0000000000000000000000000000000000000000..2d94146d57e85e9ec8c0cb3ffe261ec12b7c47f1
--- /dev/null
+++ b/lean/docs/354.md
@@ -0,0 +1,17 @@
+# The isoperimetric profile of the cubic three-torus
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [The Isoperimetric Conjecture for the Cubic Flat Three-Torus](../../preprints/The-Isoperimetric-Conjecture-for-the-Cubic-Flat-Three-Torus-September-24-2026/article.pdf)
+
+## Scope
+
+The formalization determines the isoperimetric profile and all minimizers in the unit cubic flat three-torus. At every volume $0<V<1$, a minimizer exists, and the minimizers, up to null-set changes, are exactly balls, circular tubes about shortest closed geodesics, coordinate slabs, and their complements in the appropriate volume ranges.
+
+The classification includes all equality cases at the transition volumes $4\pi/81$ and $1/\pi$, and every minimizer has the stated candidate-profile perimeter.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Isoperimetric profile and all minimizers in the cubic flat three-torus | [CubicTorus.lean](../ComparatorChallenges/CubicTorus.lean) |
diff --git a/lean/docs/356.md b/lean/docs/356.md
new file mode 100644
index 0000000000000000000000000000000000000000..189cc39d4efb65e2c3ffcda5937338a650e75a27
--- /dev/null
+++ b/lean/docs/356.md
@@ -0,0 +1,15 @@
+# Gigli’s characterization of Alexandrov curvature
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [Weak Hessian bounds along every geodesic in RCD spaces](../../preprints/Weak-Hessian-bounds-along-every-geodesic-in-RCD-spaces-September-24-2026/weak-hessian-geodesics.pdf)
+
+## Scope
+
+The formalization transfers a weak Hessian upper bound to every prescribed minimizing geodesic in an $\mathrm{RCD}(K,N)$ space with finite $N>1$. If a bounded globally Lipschitz function $F$ has weak Hessian bounded above by $G$ times the metric, where $G$ is bounded and continuous, then every constant-speed geodesic $\gamma:[0,1]\to X$ satisfies $(F\circ\gamma)''\le G(\gamma)\,d(\gamma(0),\gamma(1))^2$ in the distributional sense. Constant geodesics are included. The space is complete and separable with full support and measure finite on bounded sets; compactness and metric nonbranching are not assumed.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Weak Hessian bounds along every geodesic | [WeakHessian.lean](../ComparatorChallenges/WeakHessian.lean) |
diff --git a/lean/docs/358.md b/lean/docs/358.md
new file mode 100644
index 0000000000000000000000000000000000000000..7a7172d57e9f1ff8083351f3661daa0eb3c49755
--- /dev/null
+++ b/lean/docs/358.md
@@ -0,0 +1,15 @@
+# A three-manifold without conjugate points or nonpositive curvature
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [A Three-Manifold Without Conjugate Points and Without a Nonpositively Curved Metric](../../preprints/A-Three-Manifold-Without-Conjugate-Points-and-Without-a-Nonpositively-Curved-Metric-September-24-2026/paper.pdf)
+
+## Scope
+
+The formalized result separates absence of conjugate points from nonpositive sectional curvature. It constructs a closed connected orientable smooth three-manifold with a smooth Riemannian metric having no conjugate points, while the same manifold admits no smooth metric of everywhere nonpositive sectional curvature. The no-conjugate-points assertion ranges over all geodesics and tangent-bundle Jacobi fields, including constant geodesics and unbounded time intervals. The separate no-focal-points and CAT(0) consequences are not included.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| No conjugate points without a nonpositively curved metric | [ConjugatePoints.lean](../ComparatorChallenges/ConjugatePoints.lean) |
diff --git a/lean/docs/359.md b/lean/docs/359.md
new file mode 100644
index 0000000000000000000000000000000000000000..ebed924d774c4d64ccb369a701f1e9adf176947d
--- /dev/null
+++ b/lean/docs/359.md
@@ -0,0 +1,15 @@
+# Negative Kähler curvature without bounded holomorphic coordinates
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [A negatively pinched Kähler threefold without bounded holomorphic coordinates](../../preprints/A-negatively-pinched-Kahler-threefold-without-bounded-holomorphic-coordinates-September-25-2026/paper.pdf)
+
+## Scope
+
+The formalized result constructs a nonempty contractible complex threefold with a complete Kähler metric whose real sectional curvatures lie between two fixed negative constants. Nevertheless, it has no system of bounded holomorphic coordinates and is not biholomorphic to a bounded domain. The metric is obtained from an explicitly controlled potential. This is the negatively pinched construction; the different companion with only one-sided curvature control is separate.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Negatively pinched Kähler threefold without bounded coordinates | [PinchedKahler.lean](../ComparatorChallenges/PinchedKahler.lean) |
diff --git a/lean/docs/360.md b/lean/docs/360.md
new file mode 100644
index 0000000000000000000000000000000000000000..df390e9b0413040cf5c95de9adb559e1d21f5a43
--- /dev/null
+++ b/lean/docs/360.md
@@ -0,0 +1,19 @@
+# Weak MTW curvature gives convexity and regular optimal transport
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [Global Support and Convex Injectivity Domains under Weak MTW](../../preprints/Global-Support-and-Convex-Injectivity-Domains-under-Weak-MTW-September-25-2026/paper.pdf)
+- [Uniform Bi-Hölder Transport from Weak MTW](../../preprints/Uniform-Bi-Holder-Transport-from-Weak-MTW-September-25-2026/paper.pdf)
+
+## Scope
+
+On a compact connected smooth Riemannian manifold of dimension at least two, the formalized result proves that weak MTW curvature implies convexity of every open tangent injectivity domain. Prior convexity or nonfocality is not assumed. Additional formalized results give global support at ordinary subgradients, compact convex lifted gap sections with the stated diameter bound, and scale and local-injectivity estimates for finite target families. The latter finite-family result does not cover the paper's arbitrary-potential local-injectivity assertion.
+
+The formalized result gives uniform bi-Hölder optimal transport for squared-distance cost on each fixed compact connected smooth Riemannian manifold of dimension at least two satisfying weak MTW. For probability densities between fixed positive lower and finite upper bounds, one exponent and constant work for every pair of densities. The optimal map is a homeomorphism, is unique almost everywhere, and both it and its inverse satisfy the global Hölder bound. The constants are uniform over the density class on the fixed manifold, not over varying metrics.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Convex injectivity domains under weak MTW | [WeakMTWGlobalSupport.lean](../ComparatorChallenges/WeakMTWGlobalSupport.lean) |
+| Uniform bi-Hölder optimal transport | [BiholderTransport.lean](../ComparatorChallenges/BiholderTransport.lean) |
diff --git a/lean/docs/361.md b/lean/docs/361.md
new file mode 100644
index 0000000000000000000000000000000000000000..0a31036129229c61a5892dfacec6ed0a4300351e
--- /dev/null
+++ b/lean/docs/361.md
@@ -0,0 +1,15 @@
+# Failure of integer-degree harmonic dimension comparison
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [A counterexample to integer-degree harmonic dimension comparison](../../preprints/A-counterexample-to-integer-degree-harmonic-dimension-comparison-September-25-2026/paper.pdf)
+
+## Scope
+
+The formalized result disproves the proposed Euclidean upper comparison for dimensions of harmonic functions with integer polynomial growth. It constructs one complete smooth metric with nonnegative Ricci curvature on an even-dimensional Euclidean space, Euclidean near the origin and with asymptotic volume ratio strictly between zero and one, admitting more independent harmonic functions of the prescribed growth degree than the Euclidean count. The construction uses dimension $16$ and degree $50000$. Separate tangent-cone and cone-spectrum conclusions are not included.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Counterexample to harmonic dimension comparison | [HarmonicGrowth.lean](../ComparatorChallenges/HarmonicGrowth.lean) |
diff --git a/lean/docs/362.md b/lean/docs/362.md
new file mode 100644
index 0000000000000000000000000000000000000000..94f617ef2ae2126220f1e251ebe3c4688cdcb715
--- /dev/null
+++ b/lean/docs/362.md
@@ -0,0 +1,15 @@
+# Global smoothness for relativistic Vlasov–Maxwell
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [Global classical solutions of the three-dimensional relativistic Vlasov–Maxwell system](../../preprints/Global-classical-solutions-of-the-three-dimensional-relativistic-Vlasov-Maxwell-system-September-23-2026/paper.pdf)
+
+## Scope
+
+The formalized result gives global existence and uniqueness for the three-dimensional one-species relativistic Vlasov–Maxwell system. The initial particle density is nonnegative, smooth, and compactly supported; the initial fields have bounded derivatives of all orders, finite energy, and satisfy both Gauss constraints. The solution is smooth on every finite time interval, has compact particle phase support there, and is unique among classical solutions. No smallness, symmetry, or neutrality assumption is imposed.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Global classical Vlasov–Maxwell solutions | [VlasovMaxwell.lean](../ComparatorChallenges/VlasovMaxwell.lean) |
diff --git a/lean/docs/363.md b/lean/docs/363.md
new file mode 100644
index 0000000000000000000000000000000000000000..d37205c709984e0e43c77af9070a5342cb763d31
--- /dev/null
+++ b/lean/docs/363.md
@@ -0,0 +1,17 @@
+# Nonuniqueness with local conservation for the hard-sphere Boltzmann equation
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [Nonuniqueness for the periodic hard-sphere Boltzmann equation](../../preprints/Nonuniqueness-for-the-periodic-hard-sphere-Boltzmann-equation-September-23-2026/paper.pdf)
+
+## Scope
+
+The formalization proves nonuniqueness for the periodic hard-sphere Boltzmann equation by constructing two distinct global renormalized solutions on $\mathbb T^3\times\mathbb R^3$ with the same nonnegative initial density. The data have bounded velocity support and finite mass, energy, and absolute entropy. Both solutions conserve local mass and total momentum and satisfy the global energy and entropy-dissipation inequalities.
+
+On a common initial interval they are strongly continuous in $L^1$, with integrable collision gains and losses. These are the conditions of the selected periodic result; later local-conservation refinements are outside it.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Two periodic hard-sphere Boltzmann solutions with the same data | [BoltzmannNonuniqueness.lean](../ComparatorChallenges/BoltzmannNonuniqueness.lean) |
diff --git a/lean/docs/365.md b/lean/docs/365.md
new file mode 100644
index 0000000000000000000000000000000000000000..d84860a9139731d3ffc3a481b79851d022170440
--- /dev/null
+++ b/lean/docs/365.md
@@ -0,0 +1,15 @@
+# Joint metric and connection recovery from one boundary patch
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [Nonuniqueness for Bounded Measurable Scalar Conductivities in Three Dimensions](../../preprints/Nonuniqueness-for-Bounded-Measurable-Scalar-Conductivities-in-Three-Dimensions-September-23-2026/paper.pdf)
+
+## Scope
+
+The Calderón inverse problem asks whether boundary measurements determine an interior conductivity. The formalized result gives nonuniqueness for bounded measurable scalar conductivities on the ball $B(0,3)\subset\mathbb R^3$: two uniformly positive conductivities differ on a set of positive volume, equal $1$ near the boundary, and have the same full weak Dirichlet-to-Neumann operator. Weak solutions exist uniquely for every boundary trace.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Scalar conductivity nonuniqueness | [Conductivity.lean](../ComparatorChallenges/Conductivity.lean) |
diff --git a/lean/docs/367.md b/lean/docs/367.md
new file mode 100644
index 0000000000000000000000000000000000000000..2649fd75b650bbfae7dfdcd1737231c40dfa42d3
--- /dev/null
+++ b/lean/docs/367.md
@@ -0,0 +1,17 @@
+# The critical dimension for the one-phase Bernoulli problem
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [The critical dimension for one-phase Bernoulli minimizers](../../preprints/The-critical-dimension-for-one-phase-Bernoulli-minimizers-September-24-2026/The-critical-dimension-for-one-phase-Bernoulli-minimizers-September-24-2026.pdf)
+
+## Scope
+
+The paper identifies seven as the critical dimension for nonflat one-homogeneous global minimizers of the one-phase Bernoulli problem. The linked formalization proves the existence side: in dimension seven there is a nonzero one-homogeneous global minimizer that is not a half-space solution.
+
+The flatness classification in dimensions at most six and the resulting regularity and singular-set bounds are outside this selected statement.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| A nonflat one-homogeneous Bernoulli minimizer in dimension seven | [BernoulliNonflatInSeven.lean](../ComparatorChallenges/BernoulliNonflatInSeven.lean) |
diff --git a/lean/docs/369.md b/lean/docs/369.md
new file mode 100644
index 0000000000000000000000000000000000000000..303e026dc76b6d793b2b441e8bbc2ad3d88f0af7
--- /dev/null
+++ b/lean/docs/369.md
@@ -0,0 +1,15 @@
+# The hot spots conjecture for simply connected planar domains
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [Strict hot spots and absence of interior critical points on smooth simply connected planar domains](../../preprints/Strict-hot-spots-and-absence-of-interior-critical-points-on-smooth-simply-connected-planar-domains-September-24-2026/main.pdf)
+
+## Scope
+
+The strict hot-spots conjecture asks whether extrema of a first nonconstant Neumann eigenfunction occur only on the boundary. The formalization proves the stronger interior statement on every nonempty smooth bounded simply connected planar domain: every nonzero eigenfunction in the first positive Neumann eigenspace has nonvanishing gradient throughout the interior. Consequently all global maxima and minima lie on the boundary. The conclusion applies to every eigenfunction even when the eigenvalue is multiple.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Strict hot spots and absence of interior critical points | [HotSpots.lean](../ComparatorChallenges/HotSpots.lean) |
diff --git a/lean/docs/370.md b/lean/docs/370.md
new file mode 100644
index 0000000000000000000000000000000000000000..2dd51dd91a2dafde844edadf0710cc545e9171b4
--- /dev/null
+++ b/lean/docs/370.md
@@ -0,0 +1,15 @@
+# The Lane–Emden and Hénon–Lane–Emden conjectures
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [The Subcritical Hénon–Lane–Emden Conjecture](../../preprints/The-Subcritical-Henon-Lane-Emden-Conjecture-September-24-2026/paper.pdf)
+
+## Scope
+
+The formalized result proves nonexistence of positive entire solutions to the subcritical Hénon–Lane–Emden system. For $n\ge2$, $p,q>0$, and real $A,B$ with $(n+A)/(p+1)+(n+B)/(q+1)>n-2$, there are no positive functions, continuous everywhere and $C^2$ off the origin, satisfying $-\Delta u=|x|^A v^p$ and $-\Delta v=|x|^B u^q$ away from the origin. It includes the globally $C^2$ unweighted case for $n\ge3$. The critical equality case is not included.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Subcritical Hénon–Lane–Emden nonexistence | [HenonEmden.lean](../ComparatorChallenges/HenonEmden.lean) |
diff --git a/lean/docs/371.md b/lean/docs/371.md
new file mode 100644
index 0000000000000000000000000000000000000000..c39f2a5798bbc7752b972fc577e7b6bfa0aa1986
--- /dev/null
+++ b/lean/docs/371.md
@@ -0,0 +1,17 @@
+# Stable blowup for the defocusing Schrödinger equation
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [Stable self-similar blowup for a supercritical defocusing Schrödinger equation on the torus](../../preprints/Stable-Self-Similar-Blowup-for-a-Supercritical-Defocusing-Schrodinger-Equation-on-the-Torus-September-24-2026/paper.pdf)
+
+## Scope
+
+The formalization constructs stable self-similar finite-time blowup for defocusing nonlinear Schrödinger equations on the twelve-dimensional torus. For every prescribed lower bound on the power, it selects an odd power at least that large and a Sobolev index $k>8$ for which a nonempty open set of $H^k$ initial data has the stated classical blowup behavior. The selected quantifier gives arbitrarily large odd powers, rather than every sufficiently large odd power.
+
+For each such construction, Gaussian Fourier data with decay exponent $\alpha>k+6$ assign positive probability to the blowup set, and almost-sure global existence fails. The exponent $\alpha$ may be arbitrarily large.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Stable self-similar blowup and positive-probability Gaussian blowup | [DefocusingNLS.lean](../ComparatorChallenges/DefocusingNLS.lean) |
diff --git a/lean/docs/372.md b/lean/docs/372.md
new file mode 100644
index 0000000000000000000000000000000000000000..2d818b463d3b4c98c181639b1b56d300eb3fa445
--- /dev/null
+++ b/lean/docs/372.md
@@ -0,0 +1,15 @@
+# Global uniqueness in smooth isotropic elasticity
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [Global Uniqueness for the Smooth Isotropic Elasticity Inverse Problem](../../preprints/Global-Uniqueness-for-the-Smooth-Isotropic-Elasticity-Inverse-Problem-September-24-2026/article.pdf)
+
+## Scope
+
+The formalization proves global uniqueness in the three-dimensional static isotropic elasticity inverse problem. On a bounded connected smooth domain, let two pairs of smooth real Lamé moduli satisfy $\mu>0$ and $3\lambda+2\mu>0$ on the closure. If their full displacement-to-traction maps agree, then both Lamé moduli agree throughout the domain. The selected statement is uniqueness; it does not supply a reconstruction algorithm.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Global uniqueness of smooth isotropic Lamé moduli | [ElasticityUniqueness.lean](../ComparatorChallenges/ElasticityUniqueness.lean) |
diff --git a/lean/docs/373.md b/lean/docs/373.md
new file mode 100644
index 0000000000000000000000000000000000000000..a79d3c0bfb68fbcca661836b18d03a9744670e99
--- /dev/null
+++ b/lean/docs/373.md
@@ -0,0 +1,17 @@
+# Nonattainment of the three-marginal Coulomb Monge problem
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [A counterexample to the Monge ansatz for the three-marginal Coulomb cost](../../preprints/A-counterexample-to-the-Monge-ansatz-for-the-three-marginal-Coulomb-cost-September-25-2026/paper.pdf)
+
+## Scope
+
+The Monge ansatz asks whether an optimal multi-marginal transport plan can be induced by maps from one marginal. For the three-marginal Coulomb cost in $\mathbb R^3$, the formalization constructs a smooth compactly supported probability density, with smooth compactly supported square root, for which no pair of measure-preserving Borel maps attains the Kantorovich minimum.
+
+Nevertheless, the Monge and Kantorovich infima are equal: preserving maps with finite costs approach the minimum. This is the three-dimensional Coulomb result; the paper's inverse-power extensions in every dimension are outside this statement.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Coulomb Monge nonattainment with equality of infima | [CoulombCounterexample.lean](../ComparatorChallenges/CoulombCounterexample.lean) |
diff --git a/lean/docs/374.md b/lean/docs/374.md
new file mode 100644
index 0000000000000000000000000000000000000000..b7babfc1abbf1b258182e7eab91fbdbe469cdb2f
--- /dev/null
+++ b/lean/docs/374.md
@@ -0,0 +1,17 @@
+# Sharp one-third stability of Brenier maps
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [Sharp One-Third Stability of Brenier Maps](../../preprints/Sharp-One-Third-Stability-of-Brenier-Maps-September-25-2026/article.pdf)
+
+## Scope
+
+The formalization proves one-third Hölder stability of Brenier maps from the uniform measure on a compact convex body with nonempty interior in $\mathbb R^d$, for every $d\ge2$. For targets supported in one fixed nonempty compact set, the $L^2$ distance between the unique quadratic optimal maps is at most a constant times the one-third power of the targets' $2$-Wasserstein distance. The constant is uniform over those targets.
+
+It also proves optimality of the exponent: on a fixed cube, pairs of three-atom target measures violate every analogous bound with exponent greater than $1/3$. In particular, the conjectured uniform square-root estimate fails.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| One-third stability of Brenier maps and sharpness | [Brenier.lean](../ComparatorChallenges/Brenier.lean) |
diff --git a/lean/docs/376.md b/lean/docs/376.md
new file mode 100644
index 0000000000000000000000000000000000000000..b43f10df2d8fb85337f2b74abe299de009d0ad38
--- /dev/null
+++ b/lean/docs/376.md
@@ -0,0 +1,37 @@
+# Universal computation in forced Navier–Stokes flows
+
+The following describes the scope of the Lean formalization related to the following accompanying paper(s):
+
+- [Geometric Programs for Solenoidal Forcing](../../preprints/Geometric-Programs-for-Solenoidal-Forcing-September-27-2026/manuscript.pdf)
+- [Computation under Rapidly Vanishing Navier–Stokes Forcing](../../preprints/Computation-under-Rapidly-Vanishing-Navier-Stokes-Forcing-September-27-2026/manuscript.pdf)
+- [Velocity-Field Detection of Computation in Forced Navier–Stokes Flows](../../preprints/Velocity-Field-Detection-of-Computation-in-Forced-Navier-Stokes-Flows-September-27-2026/manuscript.pdf)
+- [Incompressible Box Transport and Finite Computation](../../preprints/Incompressible-Box-Transport-and-Finite-Computation-September-27-2026/manuscript.pdf)
+
+## Scope
+
+The formalization realizes finite families of prescribed positive diagonal maps on coding sheets by smooth incompressible flows on a flat three-torus. At every positive computable viscosity, it supplies a solution starting from rest with zero pressure and a force that is divergence free, has spatial mean zero, and is one-periodic from time zero. Each map acts on every point of its source sheet, and the construction provides effective bounds for all mixed derivatives.
+
+This selected statement covers the sheet programs. The paper's fixed-particle halting detector and its reciprocal maps on solid boxes are outside its scope.
+
+The formalization proves that a fluid particle can detect arbitrary finite-machine halting using alternating-coordinate memory in smooth incompressible Navier–Stokes flows whose velocity and force decay faster than every inverse power of time, including every mixed derivative. For each fixed positive computable viscosity, the construction starts from rest and provides effective forces, unique material trajectories, and an exact equivalence between entering a fixed open detector and halting.
+
+The velocity and force share one compact support for every machine and input. The solution-uniqueness assertion uses the stated energy comparison class.
+
+The formalization constructs smooth forced three-dimensional Navier–Stokes flows from rest whose velocity fields detect whether a prescribed machine halts, at any positive computable viscosity. On the unit flat torus, halting is equivalent to the vertical velocity exceeding $1/2$ somewhere in a fixed observation strip. On $\mathbb R^2\times\mathbb T$, it is equivalent to the integral of the nonnegative vertical velocity over the observation half-plane times the circle exceeding $1/2$.
+
+The torus force is confined to a fixed horizontal region. The cylindrical force has globally bounded mixed derivatives and compact horizontal support on every finite time interval. Both constructions have effective descriptions and uniqueness within their respective smooth solution-comparison classes.
+
+The formalization realizes finitely many positive diagonal affine maps of determinant one between rational solid boxes by a smooth compactly supported divergence-free flow. Source boxes are pairwise disjoint and target boxes are pairwise disjoint, while overlap between the two families is allowed. Each map holds on a neighborhood of the entire source box, and the velocity is supported in the middle half of the time interval.
+
+It also encodes every finite machine and input in a smooth, compactly supported incompressible Navier–Stokes flow on $\mathbb R^3$ starting from rest: the particle initially at $(4,0,0)$ enters the fixed open box $(-1,2)^3$ exactly when the machine halts. One velocity works for every viscosity $\nu>0$, with zero pressure and force $f_0+\nu f_1$. Velocity and force have bounded mixed derivatives and are one-periodic after time one; the repeated velocity depends only on the machine. The force is computable for computable $\nu$. Velocity is unique among smooth zero-data solutions with $u\in C_tH_x^2\cap C_t^1L_x^2$, bounded $u$ and $\nabla u$ on finite time intervals, and pressure modulo a function of time in $C_tH_x^1$.
+
+## Comparator links
+
+| Result | Comparator statement |
+| --- | --- |
+| Positive diagonal programs on incompressible coding sheets | [SolenoidalSheetPrograms.lean](../ComparatorChallenges/SolenoidalSheetPrograms.lean) |
+| Rapidly decaying alternating-coordinate memory | [NavierStokesAlternating.lean](../ComparatorChallenges/NavierStokesAlternating.lean) |
+| Pointwise and integral velocity-field detection of halting | [NavierStokesVelocity.lean](../ComparatorChallenges/NavierStokesVelocity.lean) |
+| Incompressible transport of solid boxes | [BalancedBoxRouting.lean](../ComparatorChallenges/BalancedBoxRouting.lean) |
+| Finite computation in a balanced zero-data fluid flow | [BalancedThreeStack.lean](../ComparatorChallenges/BalancedThreeStack.lean) |
+| Effective finite computation detected by a fixed particle | [ForcedNavierStokesComputation.lean](../ComparatorChallenges/ForcedNavierStokesComputation.lean) |
diff --git a/lean/formalization.yaml b/lean/formalization.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..e0584d4993df01ec08233ab344ebc1b1039bf7f7
--- /dev/null
+++ b/lean/formalization.yaml
@@ -0,0 +1,1668 @@
+# yaml-language-server: $schema=https://raw.githubusercontent.com/mathlib-initiative/formalization.yaml/main/schema/formalization.schema.json
+# Catalog of papers with a formalized main result. Paths are relative to lean/.
+version: "v0.4"
+
+project:
+  name: "OpenAI math repository"
+  description: "Lean formalizations accompanying a mathematics manuscript collection."
+  authors: ["OpenAI"]
+  license: "Apache-2.0"
+
+sources:
+  - title: "$L_1$ Embeddings of Graphs of Bounded Treewidth"
+    authors: ["OpenAI"]
+    id: ../preprints/L1-Embeddings-of-Graphs-of-Bounded-Treewidth-September-23-2026/paper.pdf
+    type: article
+
+  - title: "A CH obstruction to a prescribed categoricity threshold"
+    authors: ["OpenAI"]
+    id: ../preprints/A-CH-Obstruction-to-a-Prescribed-Categoricity-Threshold-September-24-2026/paper.pdf
+    type: article
+
+  - title: "A classification of finite Euclidean Ramsey configurations"
+    authors: ["OpenAI"]
+    id: ../preprints/A-classification-of-finite-Euclidean-Ramsey-configurations-September-23-2026/paper.pdf
+    type: article
+
+  - title: "A continuum temperature singularity for a radial pair potential"
+    authors: ["OpenAI"]
+    id: ../preprints/A-continuum-temperature-singularity-for-a-radial-pair-potential-September-24-2026/paper.pdf
+    type: article
+
+  - title: "A counterexample to integer-degree harmonic dimension comparison"
+    authors: ["OpenAI"]
+    id: ../preprints/A-counterexample-to-integer-degree-harmonic-dimension-comparison-September-25-2026/paper.pdf
+    type: article
+
+  - title: "A Counterexample to Kaplansky's Direct-Finiteness Conjecture in Characteristic Two"
+    authors: ["OpenAI"]
+    id: ../preprints/A-Counterexample-to-Kaplanskys-Direct-Finiteness-Conjecture-in-Characteristic-Two-September-23-2026/paper.pdf
+    type: article
+
+  - title: "A Counterexample to Kaplansky's Direct-Finiteness Conjecture in Odd Characteristic"
+    authors: ["OpenAI"]
+    id: ../preprints/A-Counterexample-to-Kaplanskys-Direct-Finiteness-Conjecture-in-Odd-Characteristic-September-26-2026/paper.pdf
+    type: article
+
+  - title: "A counterexample to Kaplansky's quasitrace conjecture and failure of tensor-product stable finiteness"
+    authors: ["OpenAI"]
+    id: ../preprints/A-counterexample-to-Kaplanskys-quasitrace-conjecture-September-23-2026/paper.pdf
+    type: article
+
+  - title: "A counterexample to Ryser's covering conjecture"
+    authors: ["OpenAI"]
+    id: ../preprints/A-Counterexample-to-Rysers-Covering-Conjecture-September-23-2026/paper.pdf
+    type: article
+
+  - title: "A counterexample to Tachikawa's second conjecture"
+    authors: ["OpenAI"]
+    id: ../preprints/A-counterexample-to-Tachikawas-second-conjecture-September-23-2026/paper.pdf
+    type: article
+
+  - title: "A Counterexample to the Group-Ring Determinant Conjecture"
+    authors: ["OpenAI"]
+    id: ../preprints/A-Counterexample-to-the-Group-Ring-Determinant-Conjecture-September-23-2026/paper.pdf
+    type: article
+
+  - title: "A Counterexample to the Infinite Matroid Packing/Covering Conjecture"
+    authors: ["OpenAI"]
+    id: ../preprints/A-Counterexample-to-the-Infinite-Matroid-Packing-Covering-Conjecture-September-24-2026/paper.pdf
+    type: article
+
+  - title: "A Cyclic Polytabloid Proof of Saxl's Conjecture"
+    authors: ["OpenAI"]
+    id: ../preprints/A-Cyclic-Polytabloid-Proof-of-Saxls-Conjecture-September-24-2026/paper.pdf
+    type: article
+
+  - title: "A Direct Proof of Optimal Max-Cut Hardness"
+    authors: ["OpenAI"]
+    id: ../preprints/A-Direct-Proof-of-Optimal-Max-Cut-Hardness-September-23-2026/paper.pdf
+    type: article
+
+  - title: "A direct proof of the complete Crouzeix inequality"
+    authors: ["OpenAI"]
+    id: ../preprints/A-direct-proof-of-the-complete-Crouzeix-inequality-September-26-2026/paper.pdf
+    type: article
+
+  - title: "A doubling Hilbert subset with no finite-dimensional bi-Lipschitz embedding"
+    authors: ["OpenAI"]
+    id: ../preprints/A-doubling-Hilbert-subset-with-no-finite-dimensional-bi-Lipschitz-embedding-September-25-2026/main.pdf
+    type: article
+
+  - title: "A Fock-space inequality and the Laughlin spectral gap"
+    authors: ["OpenAI"]
+    id: ../preprints/A-Fock-space-inequality-and-the-Laughlin-spectral-gap-September-24-2026/A-Fock-space-inequality-and-the-Laughlin-spectral-gap-September-24-2026.pdf
+    type: article
+
+  - title: "A hyperbolic group with no geometric CAT(0) action"
+    authors: ["OpenAI"]
+    id: ../preprints/A-hyperbolic-group-with-no-geometric-CAT0-action-September-25-2026/paper.pdf
+    type: article
+
+  - title: "A linear cycle-and-edge decomposition of every graph"
+    authors: ["OpenAI"]
+    id: ../preprints/A-linear-cycle-and-edge-decomposition-of-every-graph-September-24-2026/main.pdf
+    type: article
+
+  - title: "A logarithmic independence bound for clique-free graphs"
+    authors: ["OpenAI"]
+    id: ../preprints/A-Logarithmic-Independence-Bound-for-Clique-Free-Graphs-September-25-2026/paper.pdf
+    type: article
+
+  - title: "A negatively pinched Kähler threefold without bounded holomorphic coordinates"
+    authors: ["OpenAI"]
+    id: ../preprints/A-negatively-pinched-Kahler-threefold-without-bounded-holomorphic-coordinates-September-25-2026/paper.pdf
+    type: article
+
+  - title: "A nine-dimensional counterexample to Borsuk's covering assertion"
+    authors: ["OpenAI"]
+    id: ../preprints/A-nine-dimensional-counterexample-to-Borsuks-covering-assertion-September-23-2026/paper.pdf
+    type: article
+
+  - title: "A nonspectrahedral hyperbolicity cone"
+    authors: ["OpenAI"]
+    id: ../preprints/A-Nonspectrahedral-Hyperbolicity-Cone-September-24-2026/nonspectrahedral-hyperbolicity-cone.pdf
+    type: article
+
+  - title: "A Polynomial-Time 2-Approximation for Shortest Common Superstring"
+    authors: ["OpenAI"]
+    id: ../preprints/A-Polynomial-Time-2-Approximation-for-Shortest-Common-Superstring-September-24-2026/paper.pdf
+    type: article
+
+  - title: "A positive solution to Tingley's problem"
+    authors: ["OpenAI"]
+    id: ../preprints/A-positive-solution-to-Tingleys-problem-September-23-2026/paper.pdf
+    type: article
+
+  - title: "A product counterexample to the simplex maximum for projection-body volume"
+    authors: ["OpenAI"]
+    id: ../preprints/A-product-counterexample-to-the-simplex-maximum-for-projection-body-volume-September-24-2026/paper.pdf
+    type: article
+
+  - title: "A proof of Seymour’s second-neighborhood conjecture"
+    authors: ["OpenAI"]
+    id: ../preprints/A-proof-of-Seymours-second-neighborhood-conjecture-September-23-2026/paper.pdf
+    type: article
+
+  - title: "A quadratic bound for Jacobsthal's function"
+    authors: ["OpenAI"]
+    id: ../preprints/A-quadratic-bound-for-Jacobsthals-function-September-25-2026/paper.pdf
+    type: article
+
+  - title: "A radial continuum phase transition with algebraic decay"
+    authors: ["OpenAI"]
+    id: ../preprints/A-radial-continuum-phase-transition-with-algebraic-decay-September-24-2026/paper.pdf
+    type: article
+
+  - title: "A single-lattice covering bound of order n log n"
+    authors: ["OpenAI"]
+    id: ../preprints/A-single-lattice-covering-bound-of-order-n-log-n-September-23-2026/paper.pdf
+    type: article
+
+  - title: "A Smooth Metric with No Local Isometric Immersion into Three-Space"
+    authors: ["OpenAI"]
+    id: ../preprints/A-Smooth-Metric-with-No-Local-Isometric-Immersion-into-Three-Space-September-24-2026/paper.pdf
+    type: article
+
+  - title: "A strict inverse-first-power bound for univalent functions"
+    authors: ["OpenAI"]
+    id: ../preprints/A-strict-inverse-first-power-bound-for-univalent-functions-September-24-2026/paper.pdf
+    type: article
+
+  - title: "A superquadratic separation between sensitivity and block sensitivity"
+    authors: ["OpenAI"]
+    id: ../preprints/A-superquadratic-separation-between-sensitivity-and-block-sensitivity-September-25-2026/paper.pdf
+    type: article
+
+  - title: "A Three-Manifold Without Conjugate Points and Without a Nonpositively Curved Metric"
+    authors: ["OpenAI"]
+    id: ../preprints/A-Three-Manifold-Without-Conjugate-Points-and-Without-a-Nonpositively-Curved-Metric-September-24-2026/paper.pdf
+    type: article
+
+  - title: "A Torsion-Free Group Algebra with Zero Divisors"
+    authors: ["OpenAI"]
+    id: ../preprints/A-Torsion-Free-Group-Algebra-with-Zero-Divisors-September-23-2026/paper.pdf
+    type: article
+
+  - title: "A torsion-free hyperbolic group that is not residually finite"
+    authors: ["OpenAI"]
+    id: ../preprints/a-torsion-free-hyperbolic-group-that-is-not-residually-finite-September-23-2026/paper.pdf
+    type: article
+
+  - title: "A translational tile with no fully periodic tiling in dimension three"
+    authors: ["OpenAI"]
+    id: ../preprints/A-translational-tile-with-no-fully-periodic-tiling-in-dimension-three-September-23-2026/paper.pdf
+    type: article
+
+  - title: "A universal group of type F∞"
+    authors: ["OpenAI"]
+    id: ../preprints/A-universal-group-of-type-F-infinity-September-23-2026/paper.pdf
+    type: article
+
+  - title: "Additive hardness and unbounded configuration gaps in bin packing"
+    authors: ["OpenAI"]
+    id: ../preprints/Additive-hardness-and-unbounded-configuration-gaps-in-bin-packing-September-24-2026/Additive-hardness-and-unbounded-configuration-gaps-in-bin-packing-September-24-2026.pdf
+    type: article
+
+  - title: "Ample rank-two bundles on the quadric surface without Griffiths-positive metrics"
+    authors: ["OpenAI"]
+    id: ../preprints/ample-rank-two-bundles-on-the-quadric-surface-without-griffiths-positive-metrics-September-24-2026/paper.pdf
+    type: article
+
+  - title: "An algebra of infinite little finitistic dimension"
+    authors: ["OpenAI"]
+    id: ../preprints/An-algebra-of-infinite-little-finitistic-dimension-September-23-2026/paper.pdf
+    type: article
+
+  - title: "An Artin group with no geometric CAT(0) action"
+    authors: ["OpenAI"]
+    id: ../preprints/An-Artin-group-with-no-geometric-CAT-0-action-September-23-2026/paper.pdf
+    type: article
+
+  - title: "An Endpoint Gradient Bound for the Centered Disk Maximal Operator"
+    authors: ["OpenAI"]
+    id: ../preprints/An-Endpoint-Gradient-Bound-for-the-Centered-Disk-Maximal-Operator-September-26-2026/article.pdf
+    type: article
+
+  - title: "An explicit counterexample to the Auslander-Reiten conjecture"
+    authors: ["OpenAI"]
+    id: ../preprints/An-explicit-counterexample-to-the-Auslander-Reiten-conjecture-September-23-2026/paper.pdf
+    type: article
+
+  - title: "An explicit failure of complex affine-space cancellation"
+    authors: ["OpenAI"]
+    id: ../preprints/An-explicit-failure-of-complex-affine-space-cancellation-September-23-2026/paper.pdf
+    type: article
+
+  - title: "An explicit noncoordinate polynomial with affine three-space zero fibre"
+    authors: ["OpenAI"]
+    id: ../preprints/An-explicit-noncoordinate-polynomial-with-affine-three-space-zero-fibre-September-24-2026/paper.pdf
+    type: article
+
+  - title: "An exponential state lower bound for two-way nondeterministic complementation"
+    authors: ["OpenAI"]
+    id: ../preprints/An-exponential-state-lower-bound-for-two-way-nondeterministic-complementation-September-25-2026/paper.pdf
+    type: article
+
+  - title: "An exponential two-way deterministic state lower bound for one-way liveness"
+    authors: ["OpenAI"]
+    id: ../preprints/An-exponential-two-way-deterministic-state-lower-bound-for-one-way-liveness-September-25-2026/main.pdf
+    type: article
+
+  - title: "An infinite finitely presented simple amenable group"
+    authors: ["OpenAI"]
+    id: ../preprints/An-Infinite-Finitely-Presented-Simple-Amenable-Group-September-23-2026/paper.pdf
+    type: article
+
+  - title: "An Upper Bound of 9/4 for the Matrix Multiplication Exponent"
+    authors: ["OpenAI"]
+    id: ../preprints/Matrix-Multiplication-Nine-Fourths-October-2-2026/paper.pdf
+    type: article
+
+  - title: "Approximate counting of common bases of two matroids"
+    authors: ["OpenAI"]
+    id: ../preprints/Approximate-counting-of-common-bases-of-two-matroids-September-23-2026/main.pdf
+    type: article
+
+  - title: "Asymptotic midpoint uniform convexity and unbounded diamond distortion in a reflexive tree space"
+    authors: ["OpenAI"]
+    id: ../preprints/Asymptotic-midpoint-uniform-convexity-and-unbounded-diamond-distortion-in-a-reflexive-tree-space-September-27-2026/manuscript.pdf
+    type: article
+
+  - title: "Asymptotically minimal maxima of real Littlewood polynomials"
+    authors: ["OpenAI"]
+    id: ../preprints/Asymptotically-minimal-maxima-of-real-Littlewood-polynomials-September-23-2026/paper.pdf
+    type: article
+
+  - title: "Average sensitivity of polynomial threshold functions"
+    authors: ["OpenAI"]
+    id: ../preprints/Average-Sensitivity-of-Polynomial-Threshold-Functions-September-25-2026/main.pdf
+    type: article
+
+  - title: "Backward intertwiners and a transitive commutant"
+    authors: ["OpenAI"]
+    id: ../preprints/Backward-intertwiners-and-a-transitive-commutant-September-27-2026/paper.pdf
+    type: article
+
+  - title: "Beyond the Square-Root Exponent for Depth-Three Boolean Circuits"
+    authors: ["OpenAI"]
+    id: ../preprints/Beyond-the-Square-Root-Exponent-for-Depth-Three-Boolean-Circuits-September-23-2026/main.pdf
+    type: article
+
+  - title: "Bi-Lipschitz Absorption of $c_0$ Without a Linear Copy of $c_0$"
+    authors: ["OpenAI"]
+    id: ../preprints/Bi-Lipschitz-Absorption-of-c0-Without-a-Linear-Copy-of-c0-September-26-2026/paper.pdf
+    type: article
+
+  - title: "Bounded recovery for modular spectral averages"
+    authors: ["OpenAI"]
+    id: ../preprints/Bounded-recovery-for-modular-spectral-averages-September-23-2026/Bounded-recovery-for-modular-spectral-averages-September-23-2026.pdf
+    type: article
+
+  - title: "Bounded-Step Walks on Gaussian Primes"
+    authors: ["OpenAI"]
+    id: ../preprints/Bounded-Step-Walks-on-Gaussian-Primes-September-26-2026/paper.pdf
+    type: article
+
+  - title: "Brennan's conjecture and sharp inverse-square integral means"
+    authors: ["OpenAI"]
+    id: ../preprints/Brennans-conjecture-and-sharp-inverse-square-integral-means-September-24-2026/paper.pdf
+    type: article
+
+  - title: "Choiceless polynomial time with counting does not capture polynomial time"
+    authors: ["OpenAI"]
+    id: ../preprints/Choiceless-polynomial-time-with-counting-does-not-capture-polynomial-time-September-23-2026/paper.pdf
+    type: article
+
+  - title: "Classical capacity and entropy inequalities for generalized amplitude damping"
+    authors: ["OpenAI"]
+    id: ../preprints/Classical-capacity-and-entropy-inequalities-for-generalized-amplitude-damping-September-24-2026/paper.pdf
+    type: article
+
+  - title: "Compatibility entropy and the spectrum of a Thorp sweep"
+    authors: ["OpenAI"]
+    id: ../preprints/Compatibility-entropy-and-the-spectrum-of-a-Thorp-sweep-September-26-2026/paper.pdf
+    type: article
+
+  - title: "Complex Matrix Multiplication Below 2.258 and Rectangular Bounds"
+    authors: ["OpenAI"]
+    id: ../preprints/Complex-Matrix-Multiplication-Below-2.258-and-Rectangular-Bounds-September-24-2026/Complex-Matrix-Multiplication-Below-2.258-and-Rectangular-Bounds-September-24-2026.pdf
+    type: article
+
+  - title: "Conditional coordinate sweeps and analytic transfer"
+    authors: ["OpenAI"]
+    id: ../preprints/Conditional-coordinate-sweeps-and-analytic-transfer-September-26-2026/main.pdf
+    type: article
+
+  - title: "Counterexamples to the duality conjecture for metric entropy"
+    authors: ["OpenAI"]
+    id: ../preprints/Counterexamples-to-the-duality-conjecture-for-metric-entropy-September-24-2026/main.pdf
+    type: article
+
+  - title: "Critical bond and site percolation on the cubic lattice"
+    authors: ["OpenAI"]
+    id: ../preprints/Critical-bond-and-site-percolation-on-the-cubic-lattice-September-24-2026/paper.pdf
+    type: article
+
+  - title: "Critical slowing down in the Sherrington–Kirkpatrick model"
+    authors: ["OpenAI"]
+    id: ../preprints/Critical-slowing-down-in-the-Sherrington-Kirkpatrick-model-September-24-2026/paper.pdf
+    type: article
+
+  - title: "Directional transience implies ballisticity"
+    authors: ["OpenAI"]
+    id: ../preprints/Directional-transience-implies-ballisticity-September-23-2026/paper.pdf
+    type: article
+
+  - title: "Distortion of countably branching diamonds from midpoint and tree energies"
+    authors: ["OpenAI"]
+    id: ../preprints/Diamond-distortion-from-midpoint-and-tree-energies-September-27-2026/manuscript.pdf
+    type: article
+
+  - title: "Entropy and Face Dimension of the Perfect-Matching Polytope"
+    authors: ["OpenAI"]
+    id: ../preprints/Entropy-and-Face-Dimension-of-the-Perfect-Matching-Polytope-September-23-2026/main.pdf
+    type: article
+
+  - title: "Exact asymptotic moduli in a Daugavet subspace of L1"
+    authors: ["OpenAI"]
+    id: ../preprints/Exact-asymptotic-moduli-in-a-Daugavet-subspace-of-L1-September-27-2026/manuscript.pdf
+    type: article
+
+  - title: "Exponential decay in two-dimensional classical O(n) models"
+    authors: ["OpenAI"]
+    id: ../preprints/Exponential-decay-in-two-dimensional-classical-On-models-September-23-2026/paper.pdf
+    type: article
+
+  - title: "Finite tensor savings and exact Fourier circuits"
+    authors: ["OpenAI"]
+    id: ../preprints/Finite-tensor-savings-and-exact-Fourier-circuits-September-25-2026/main.pdf
+    type: article
+
+  - title: "Fixed Points of Nonexpansive Maps in Reflexive Banach Spaces"
+    authors: ["OpenAI"]
+    id: ../preprints/Fixed-Points-of-Nonexpansive-Maps-in-Reflexive-Banach-Spaces-September-24-2026/paper.pdf
+    type: article
+
+  - title: "Generalized ionization energies for full Coulomb atoms"
+    authors: ["OpenAI"]
+    id: ../preprints/Generalized-ionization-energies-for-full-Coulomb-atoms-September-24-2026/paper.pdf
+    type: article
+
+  - title: "Global classical solutions of the three-dimensional relativistic Vlasov–Maxwell system"
+    authors: ["OpenAI"]
+    id: ../preprints/Global-classical-solutions-of-the-three-dimensional-relativistic-Vlasov-Maxwell-system-September-23-2026/paper.pdf
+    type: article
+
+  - title: "Global Support and Convex Injectivity Domains under Weak MTW"
+    authors: ["OpenAI"]
+    id: ../preprints/Global-Support-and-Convex-Injectivity-Domains-under-Weak-MTW-September-25-2026/paper.pdf
+    type: article
+
+  - title: "Hardness of finding large independent sets in three-colorable graphs"
+    authors: ["OpenAI"]
+    id: ../preprints/Hardness-of-finding-large-independent-sets-in-three-colorable-graphs-September-24-2026/Hardness-of-finding-large-independent-sets-in-three-colorable-graphs-September-24-2026.pdf
+    type: article
+
+  - title: "Harmonic heights and the Artin K(π,1) conjecture"
+    authors: ["OpenAI"]
+    id: ../preprints/Harmonic-heights-and-the-Artin-K-pi-1-conjecture-September-23-2026/paper.pdf
+    type: article
+
+  - title: "Independent products in real L1: asymptotic midpoint convexity without AUC renormings"
+    authors: ["OpenAI"]
+    id: ../preprints/Independent-products-in-real-L1-asymptotic-midpoint-convexity-without-AUC-renormings-September-27-2026/manuscript.pdf
+    type: article
+
+  - title: "Integral and fractional expectation thresholds are equivalent"
+    authors: ["OpenAI"]
+    id: ../preprints/Integral-and-fractional-expectation-thresholds-are-equivalent-September-23-2026/paper.pdf
+    type: article
+
+  - title: "Lipschitz Equivalent Separable Banach Spaces Need Not Be Linearly Isomorphic"
+    authors: ["OpenAI"]
+    id: ../preprints/Lipschitz-Equivalent-Separable-Banach-Spaces-Need-Not-Be-Linearly-Isomorphic-September-24-2026/paper.pdf
+    type: article
+
+  - title: "Maximal Seshadri constants on arbitrary polarized surfaces"
+    authors: ["OpenAI"]
+    id: ../preprints/Maximal-Seshadri-Constants-on-Arbitrary-Polarized-Surfaces-September-23-2026/main.pdf
+    type: article
+
+  - title: "Memory and precision in noiseless Gaussian regression"
+    authors: ["OpenAI"]
+    id: ../preprints/Memory-and-precision-in-noiseless-Gaussian-regression-September-27-2026/paper.pdf
+    type: article
+
+  - title: "Midpoint convexity from bounded tree potentials and path costs"
+    authors: ["OpenAI"]
+    id: ../preprints/Midpoint-convexity-from-bounded-tree-potentials-and-path-costs-September-27-2026/manuscript.pdf
+    type: article
+
+  - title: "Midpoint convexity from two recursive potentials"
+    authors: ["OpenAI"]
+    id: ../preprints/Midpoint-convexity-from-two-recursive-potentials-September-27-2026/manuscript.pdf
+    type: article
+
+  - title: "Midpoint lenses in segment spaces"
+    authors: ["OpenAI"]
+    id: ../preprints/Midpoint-lenses-in-segment-spaces-September-27-2026/manuscript.pdf
+    type: article
+
+  - title: "Nagata's conjecture for plane curves"
+    authors: ["OpenAI"]
+    id: ../preprints/Nagatas-Conjecture-for-Plane-Curves-September-23-2026/main.pdf
+    type: article
+
+  - title: "Near-square-root logarithmic integrality gaps for uniform sparsest cut"
+    authors: ["OpenAI"]
+    id: ../preprints/Near-square-root-logarithmic-integrality-gaps-for-uniform-sparsest-cut-September-24-2026/Near-square-root-logarithmic-integrality-gaps-for-uniform-sparsest-cut-September-24-2026.pdf
+    type: article
+
+  - title: "Nontrivial Markov Type Forces Superreflexivity"
+    authors: ["OpenAI"]
+    id: ../preprints/Nontrivial-Markov-Type-Forces-Superreflexivity-September-23-2026/paper.pdf
+    type: article
+
+  - title: "Nonuniqueness for Bounded Measurable Scalar Conductivities in Three Dimensions"
+    authors: ["OpenAI"]
+    id: ../preprints/Nonuniqueness-for-Bounded-Measurable-Scalar-Conductivities-in-Three-Dimensions-September-23-2026/paper.pdf
+    type: article
+
+  - title: "Perfect completeness for 2-to-1 games"
+    authors: ["OpenAI"]
+    id: ../preprints/Perfect-completeness-for-2-to-1-games-September-23-2026/paper.pdf
+    type: article
+
+  - title: "Petty’s projection-volume conjecture in dimensions at least four"
+    authors: ["OpenAI"]
+    id: ../preprints/Pettys-projection-volume-conjecture-in-dimensions-at-least-four-September-24-2026/paper.pdf
+    type: article
+
+  - title: "Planar Graph Metrics Embed into $L_1$ with Constant Distortion"
+    authors: ["OpenAI"]
+    id: ../preprints/Planar-Graph-Metrics-Embed-into-L1-with-Constant-Distortion-September-23-2026/paper.pdf
+    type: article
+
+  - title: "Polynomial Hitting Lists for Noncommutative Rational Formulas"
+    authors: ["OpenAI"]
+    id: ../preprints/Polynomial-Hitting-Lists-for-Noncommutative-Rational-Formulas-September-24-2026/Polynomial-Hitting-Lists-for-Noncommutative-Rational-Formulas-September-24-2026.pdf
+    type: article
+
+  - title: "Polynomial removal fails for ordered binary matrices"
+    authors: ["OpenAI"]
+    id: ../preprints/Polynomial-removal-fails-for-ordered-binary-matrices-September-25-2026/paper.pdf
+    type: article
+
+  - title: "Posterior replicas and conditional information in Gaussian regression"
+    authors: ["OpenAI"]
+    id: ../preprints/Posterior-replicas-and-conditional-information-in-Gaussian-regression-September-27-2026/paper.pdf
+    type: article
+
+  - title: "Power-law violations of Yau's nodal upper bound"
+    authors: ["OpenAI"]
+    id: ../preprints/Power-law-violations-of-Yaus-nodal-upper-bound-September-23-2026/paper.pdf
+    type: article
+
+  - title: "Product-projection localization and the QAC⁰ parity lower bound"
+    authors: ["OpenAI"]
+    id: ../preprints/Product-projection-localization-and-the-QAC0-parity-lower-bound-September-24-2026/paper.pdf
+    type: article
+
+  - title: "Projection moments, positive cap domination, and Riesz estimates on the sphere"
+    authors: ["OpenAI"]
+    id: ../preprints/Projection-moments-positive-cap-domination-and-Riesz-estimates-on-the-sphere-September-27-2026/paper.pdf
+    type: article
+
+  - title: "Quadratic stabilization of the canonical Foulkes–Howe map"
+    authors: ["OpenAI"]
+    id: ../preprints/Quadratic-Stabilization-of-the-Canonical-Foulkes-Howe-Map-September-25-2026/paper.pdf
+    type: article
+
+  - title: "Quantitative Superexponential Bounds for van der Waerden Numbers"
+    authors: ["OpenAI"]
+    id: ../preprints/Quantitative-Superexponential-Bounds-for-van-der-Waerden-Numbers-September-23-2026/paper.pdf
+    type: article
+
+  - title: "Randomized quasipolynomial-time mean-payoff games"
+    authors: ["OpenAI"]
+    id: ../preprints/Randomized-quasipolynomial-time-mean-payoff-games-September-25-2026/paper.pdf
+    type: article
+
+  - title: "Regular trajectories, pruning and quantum parity"
+    authors: ["OpenAI"]
+    id: ../preprints/Regular-trajectories-pruning-and-quantum-parity-September-24-2026/paper.pdf
+    type: article
+
+  - title: "Relative generation and the generator problem for finite factors"
+    authors: ["OpenAI"]
+    id: ../preprints/Relative-generation-and-the-generator-problem-for-finite-factors-September-23-2026/paper.pdf
+    type: article
+
+  - title: "Replacing Gaussian observations in memory-constrained inference"
+    authors: ["OpenAI"]
+    id: ../preprints/Replacing-Gaussian-observations-in-memory-constrained-inference-September-27-2026/paper.pdf
+    type: article
+
+  - title: "Riesz transforms and uniform rectifiability in higher codimension"
+    authors: ["OpenAI"]
+    id: ../preprints/Riesz-transforms-and-uniform-rectifiability-in-higher-codimension-September-24-2026/paper.pdf
+    type: article
+
+  - title: "Rigidity of the Turing degrees"
+    authors: ["OpenAI"]
+    id: ../preprints/Rigidity-of-the-Turing-degrees-September-24-2026/paper.pdf
+    type: article
+
+  - title: "Routing densities and representation contraction for Thorp sweeps"
+    authors: ["OpenAI"]
+    id: ../preprints/Routing-densities-and-representation-contraction-for-Thorp-sweeps-September-26-2026/paper.pdf
+    type: article
+
+  - title: "Sharp binary-information contraction on the discrete cube"
+    authors: ["OpenAI"]
+    id: ../preprints/Sharp-binary-information-contraction-on-the-discrete-cube-September-24-2026/main.pdf
+    type: article
+
+  - title: "Sharp one-dimensional Lieb–Thirring constants"
+    authors: ["OpenAI"]
+    id: ../preprints/Sharp-One-Dimensional-Lieb-Thirring-Constants-September-23-2026/paper.pdf
+    type: article
+
+  - title: "Short Egyptian fractions"
+    authors: ["OpenAI"]
+    id: ../preprints/Short-Egyptian-fractions-September-25-2026/Short-Egyptian-fractions-September-25-2026.pdf
+    type: article
+
+  - title: "Single-exponential recovery and bounded-price strictness for metric k-median"
+    authors: ["OpenAI"]
+    id: ../preprints/Single-Exponential-Recovery-and-Bounded-Price-Strictness-for-Metric-k-Median-September-24-2026/paper.pdf
+    type: article
+
+  - title: "Single-fold Diophantine representations"
+    authors: ["OpenAI"]
+    id: ../preprints/Single-fold-Diophantine-representations-September-24-2026/paper.pdf
+    type: article
+
+  - title: "Smooth counterexamples to Yau's nodal upper bound in dimensions three and four"
+    authors: ["OpenAI"]
+    id: ../preprints/Smooth-counterexamples-to-Yaus-nodal-upper-bound-in-dimensions-three-and-four-September-23-2026/paper.pdf
+    type: article
+
+  - title: "Squarefree values of quartics and power-free values of polynomials"
+    authors: ["OpenAI"]
+    id: ../preprints/Squarefree-values-of-quartics-and-power-free-values-of-polynomials-September-24-2026/manuscript.pdf
+    type: article
+
+  - title: "Staggered extraction for exact matrix multiplication over every field"
+    authors: ["OpenAI"]
+    id: ../preprints/Staggered-extraction-for-exact-matrix-multiplication-over-every-field-September-24-2026/Staggered-extraction-for-exact-matrix-multiplication-over-every-field-September-24-2026.pdf
+    type: article
+
+  - title: "Strict convexity and differentiability of the planar exponential first-passage limit shape"
+    authors: ["OpenAI"]
+    id: ../preprints/Strict-convexity-and-differentiability-of-the-planar-exponential-first-passage-limit-shape-September-24-2026/main.pdf
+    type: article
+
+  - title: "Subpolynomial dimension reduction in $L_p$"
+    authors: ["OpenAI"]
+    id: ../preprints/Subpolynomial-dimension-reduction-in-Lp-September-23-2026/paper.pdf
+    type: article
+
+  - title: "Subpolynomial query complexity for well-conditioned log-concave sampling"
+    authors: ["OpenAI"]
+    id: ../preprints/Subpolynomial-query-complexity-for-well-conditioned-log-concave-sampling-September-26-2026/article.pdf
+    type: article
+
+  - title: "Subsphere methods for memory–sample lower bounds in noiseless Gaussian regression"
+    authors: ["OpenAI"]
+    id: ../preprints/Subsphere-methods-for-memory-sample-lower-bounds-in-noiseless-Gaussian-regression-September-27-2026/paper.pdf
+    type: article
+
+  - title: "Symmetry of semialgebraic bounded domains with compact quotient"
+    authors: ["OpenAI"]
+    id: ../preprints/Symmetry-of-semialgebraic-bounded-domains-with-compact-quotient-September-24-2026/paper.pdf
+    type: article
+
+  - title: "Symplectic Balls in Symmetric Polar Products"
+    authors: ["OpenAI"]
+    id: ../preprints/Symplectic-Balls-in-Symmetric-Polar-Products-September-22-2026/paper.pdf
+    type: article
+
+  - title: "Talagrand's discrete-convexity conjecture"
+    authors: ["OpenAI"]
+    id: ../preprints/Talagrands-discrete-convexity-conjecture-September-23-2026/paper.pdf
+    type: article
+
+  - title: "Taming implies compatibility on four-manifolds"
+    authors: ["OpenAI"]
+    id: ../preprints/Taming-implies-compatibility-on-four-manifolds-September-23-2026/paper.pdf
+    type: article
+
+  - title: "The Bass trace conjecture and the characteristic-zero Kaplansky idempotent conjecture"
+    authors: ["OpenAI"]
+    id: ../preprints/The-Bass-trace-conjecture-for-complex-group-rings-September-24-2026/The-Bass-trace-conjecture-for-complex-group-rings-September-24-2026.pdf
+    type: article
+
+  - title: "The circulant Hadamard conjecture"
+    authors: ["OpenAI"]
+    id: ../preprints/The-circulant-Hadamard-conjecture-September-23-2026/paper.pdf
+    type: article
+
+  - title: "The complete Crouzeix theorem: optimal similarity and a common positive boundary representation"
+    authors: ["OpenAI"]
+    id: ../preprints/The-complete-Crouzeix-theorem-September-23-2026/paper.pdf
+    type: article
+
+  - title: "The cotype–cotype conjecture under the approximation property"
+    authors: ["OpenAI"]
+    id: ../preprints/The-cotype-cotype-conjecture-under-the-approximation-property-September-23-2026/paper.pdf
+    type: article
+
+  - title: "The crossing number of complete bipartite graphs"
+    authors: ["OpenAI"]
+    id: ../preprints/The-crossing-number-of-complete-bipartite-graphs-September-23-2026/paper.pdf
+    type: article
+
+  - title: "The crossing number of complete graphs"
+    authors: ["OpenAI"]
+    id: ../preprints/The-crossing-number-of-complete-graphs-September-23-2026/paper.pdf
+    type: article
+
+  - title: "The Deligne-Drinfeld conjecture"
+    authors: ["OpenAI"]
+    id: ../preprints/The-Deligne-Drinfeld-conjecture-September-23-2026/paper.pdf
+    type: article
+
+  - title: "The entropy-rate dimension formula for self-similar measures on the line"
+    authors: ["OpenAI"]
+    id: ../preprints/The-entropy-rate-dimension-formula-for-self-similar-measures-on-the-line-September-24-2026/main.pdf
+    type: article
+
+  - title: "The Euclidean plane is not five-colorable"
+    authors: ["OpenAI"]
+    id: ../preprints/The-Euclidean-plane-is-not-five-colorable-September-23-2026/paper.pdf
+    type: article
+
+  - title: "The Euclidean Steinitz–Bergström theorem"
+    authors: ["OpenAI"]
+    id: ../preprints/The-Euclidean-Steinitz-Bergstrom-theorem-September-24-2026/The-Euclidean-Steinitz-Bergstrom-theorem-September-24-2026.pdf
+    type: article
+
+  - title: "The Factor-Two Hardness Threshold for Vertex Cover"
+    authors: ["OpenAI"]
+    id: ../preprints/The-Factor-Two-Hardness-Threshold-for-Vertex-Cover-September-23-2026/paper.pdf
+    type: article
+
+  - title: "The Falconer distance conjecture in all dimensions"
+    authors: ["OpenAI"]
+    id: ../preprints/The-Falconer-distance-conjecture-in-all-dimensions-September-23-2026/paper.pdf
+    type: article
+
+  - title: "The Gaussian propeller bound in every dimension"
+    authors: ["OpenAI"]
+    id: ../preprints/The-Gaussian-Propeller-Bound-in-Every-Dimension-September-24-2026/main.pdf
+    type: article
+
+  - title: "The Grothendieck homotopy hypothesis via elementary expansions"
+    authors: ["OpenAI"]
+    id: ../preprints/The-Grothendieck-homotopy-hypothesis-via-elementary-expansions-September-24-2026/paper.pdf
+    type: article
+
+  - title: "The Kirchberg–Rørdam character criterion"
+    authors: ["OpenAI"]
+    id: ../preprints/The-Kirchberg-Rordam-character-criterion-September-25-2026/paper.pdf
+    type: article
+
+  - title: "The logarithmic Brunn–Minkowski conjecture"
+    authors: ["OpenAI"]
+    id: ../preprints/The-logarithmic-Brunn-Minkowski-conjecture-September-23-2026/paper.pdf
+    type: article
+
+  - title: "The maximal triangular Hilbert transform at the symmetric point"
+    authors: ["OpenAI"]
+    id: ../preprints/The-maximal-triangular-Hilbert-transform-at-the-symmetric-point-September-24-2026/paper.pdf
+    type: article
+
+  - title: "The Partition Principle does not imply Choice"
+    authors: ["OpenAI"]
+    id: ../preprints/The-Partition-Principle-does-not-imply-Choice-September-24-2026/partition-principle-without-choice.pdf
+    type: article
+
+  - title: "The Quasi-Riemann Hypothesis: A Zero-Free Half-Plane Re(s)>7/8"
+    authors: ["OpenAI"]
+    id: ../preprints/The-Quasi-Riemann-Hypothesis-September-30-2026/paper.pdf
+    type: article
+
+  - title: "The second Kahn–Kalai conjecture"
+    authors: ["OpenAI"]
+    id: ../preprints/The-second-Kahn-Kalai-conjecture-September-24-2026/paper.pdf
+    type: article
+
+  - title: "The sharp factor-of-IID threshold for the free Ising model on regular trees"
+    authors: ["OpenAI"]
+    id: ../preprints/The-sharp-factor-of-IID-threshold-for-the-free-Ising-model-on-regular-trees-September-26-2026/article.pdf
+    type: article
+
+  - title: "The strong thin tree conjecture"
+    authors: ["OpenAI"]
+    id: ../preprints/The-strong-thin-tree-conjecture-September-23-2026/paper.pdf
+    type: article
+
+  - title: "The Subcritical Hénon–Lane–Emden Conjecture"
+    authors: ["OpenAI"]
+    id: ../preprints/The-Subcritical-Henon-Lane-Emden-Conjecture-September-24-2026/paper.pdf
+    type: article
+
+  - title: "The symmetric Mahler conjecture and its equality cases"
+    authors: ["OpenAI"]
+    id: ../preprints/The-symmetric-Mahler-conjecture-and-its-equality-cases-September-22-2026/paper.pdf
+    type: article
+
+  - title: "The Unique Games Theorem"
+    authors: ["OpenAI"]
+    id: ../preprints/The-Unique-Games-Theorem-September-23-2026/paper.pdf
+    type: article
+
+  - title: "The weak pinned planar distance theorem"
+    authors: ["OpenAI"]
+    id: ../preprints/The-weak-pinned-planar-distance-theorem-September-23-2026/paper.pdf
+    type: article
+
+  - title: "Thompson's group F is nonamenable"
+    authors: ["OpenAI"]
+    id: ../preprints/Thompsons-group-F-is-nonamenable-September-23-2026/paper.pdf
+    type: article
+
+  - title: "Three fixed points on the symplectic quadric threefold"
+    authors: ["OpenAI"]
+    id: ../preprints/A-degenerate-counterexample-to-the-critical-number-Arnold-bound-September-23-2026/paper.pdf
+    type: article
+
+  - title: "Threshold parallel repetition for finite-dimensional entangled games"
+    authors: ["OpenAI"]
+    id: ../preprints/Threshold-parallel-repetition-for-finite-dimensional-entangled-games-September-25-2026/paper.pdf
+    type: article
+
+  - title: "Tracial projection methods and uniform property Γ"
+    authors: ["OpenAI"]
+    id: ../preprints/Tracial-projection-methods-and-uniform-property-Gamma-September-23-2026/paper.pdf
+    type: article
+
+  - title: "Two limit cycles for quintic Liénard systems"
+    authors: ["OpenAI"]
+    id: ../preprints/two-limit-cycles-for-quintic-lienard-systems-September-24-2026/two-limit-cycles-for-quintic-lienard-systems-September-24-2026.pdf
+    type: article
+
+  - title: "Uniform Bi-Hölder Transport from Weak MTW"
+    authors: ["OpenAI"]
+    id: ../preprints/Uniform-Bi-Holder-Transport-from-Weak-MTW-September-25-2026/paper.pdf
+    type: article
+
+  - title: "Uniform exclusion of Landau–Siegel zeros"
+    authors: ["OpenAI"]
+    id: ../preprints/Uniform-exclusion-of-Landau-Siegel-zeros-October-1-2026/paper.pdf
+    type: article
+
+  - title: "Unitarizability implies amenability for discrete groups"
+    authors: ["OpenAI"]
+    id: ../preprints/Unitarizability-Implies-Amenability-for-Countable-Groups-September-23-2026/paper.pdf
+    type: article
+
+  - title: "Universal-cover splitting for compact Kähler manifolds"
+    authors: ["OpenAI"]
+    id: ../preprints/Universal-cover-splitting-for-compact-Kahler-manifolds-September-23-2026/paper.pdf
+    type: article
+
+  - title: "Weak Hessian bounds along every geodesic in RCD spaces"
+    authors: ["OpenAI"]
+    id: ../preprints/Weak-Hessian-bounds-along-every-geodesic-in-RCD-spaces-September-24-2026/weak-hessian-geodesics.pdf
+    type: article
+
+related_formalizations:
+  # Imported libraries, ordered by direct import count in project Lean sources.
+  - id: https://github.com/leanprover-community/mathlib4
+    relationship: builds-on
+
+  - id: https://github.com/AlexKontorovich/PrimeNumberTheoremAnd
+    relationship: builds-on
+
+  - id: https://github.com/n-yamaguchi-0729/ClassFieldTheory
+    relationship: builds-on
+
+  - id: https://github.com/CBirkbeck/AINTLIB
+    relationship: builds-on
+
+  - id: https://github.com/math-inc/strongpnt
+    relationship: builds-on
+
+  - id: https://github.com/abenenson/rellich-kondrachov
+    relationship: builds-on
+
+  - id: https://github.com/harfe/fixed-point-theorems-lean4
+    relationship: builds-on
+
+  - id: https://github.com/TauCetiProject/TauCeti
+    relationship: builds-on
+
+  - id: https://github.com/fpvandoorn/carleson
+    relationship: builds-on
+
+  - id: https://github.com/lana-agents/heights
+    relationship: builds-on
+
+  - id: https://github.com/Aaron1011/gromov
+    relationship: builds-on
+
+  - id: https://github.com/lana-agents/iut
+    relationship: builds-on
+
+  - id: https://github.com/alonamaloh/schoenflies-lean
+    relationship: builds-on
+
+  - id: https://github.com/leanprover-community/sphere-eversion
+    relationship: builds-on
+
+  - id: https://github.com/ahhwuhu/zeta_3_irrational
+    relationship: builds-on
+
+  - id: https://github.com/BennyAvelin/AbsorptionCutoff
+    relationship: builds-on
+
+  - id: https://github.com/lana-agents/belyi
+    relationship: builds-on
+
+  - id: https://github.com/PatrickMassot/checkdecls
+    relationship: builds-on
+
+  - id: https://github.com/leanprover/doc-gen4
+    relationship: builds-on
+
+  - id: https://github.com/lana-agents/elliptic-curves
+    relationship: builds-on
+
+  - id: https://github.com/lana-agents/formal-schemes
+    relationship: builds-on
+
+  - id: https://github.com/lana-agents/genl
+    relationship: builds-on
+
+  - id: https://github.com/hanwenzhu/LeanArchitect
+    relationship: builds-on
+
+  - id: https://github.com/alerad/leancert
+    relationship: builds-on
+
+  - id: https://github.com/lana-agents/oka
+    relationship: builds-on
+
+  - id: https://github.com/lana-agents/orbicurve-cores
+    relationship: builds-on
+
+  - id: https://github.com/lana-agents/pi1
+    relationship: builds-on
+
+  - id: https://github.com/b-mehta/PrimeCert
+    relationship: builds-on
+
+  - id: https://github.com/lana-agents/tate-curves-theta
+    relationship: builds-on
+
+  - id: https://github.com/lana-agents/tempered-fundamental-groups
+    relationship: builds-on
+
+status:
+  scope: "Partial progress."
+  # Entries use source-qualified declaration names and the files containing them.
+  main_results:
+    - comparator_config: ComparatorChallenges/AbhyankarSathaye.json
+      declaration: OAI.AbhyankarSathaye.exists_noncoordinate_polynomial
+      file: OAI/AlgebraicGeometry/AbhyankarSathaye/Counterexample.lean
+
+    - comparator_config: ComparatorChallenges/AmplitudeDamping.json
+      declaration: OAI.GAD.main
+      file: OAI/InformationTheory/AmplitudeDamping/Main.lean
+
+    - comparator_config: ComparatorChallenges/ArnoldCounterexample.json
+      declaration: OAI.ArnoldCounterexample.main
+      file: OAI/Geometry/Arnold/Main.lean
+
+    - comparator_config: ComparatorChallenges/ArtinCAT0.json
+      declaration: OAI.ArtinCAT0.main
+      file: OAI/GroupTheory/ArtinCAT0/Main.lean
+
+    - comparator_config: ComparatorChallenges/AsymptoticallyMinimalLittlewood.json
+      declaration: OAI.AsymptoticallyMinimalLittlewood.main
+      file: OAI/Analysis/Littlewood/Main.lean
+
+    - comparator_config: ComparatorChallenges/AuslanderReiten.json
+      declaration: OAI.ArExplicit.Statement.main
+      file: OAI/Algebra/AuslanderReiten/All.lean
+
+    - comparator_config: ComparatorChallenges/BackwardIntertwiners.json
+      declaration: OAI.BackwardIntertwiners.direct_algebra_corollary
+      file: OAI/Analysis/BackwardIntertwiners/AlgebraCorollary.lean
+
+    - comparator_config: ComparatorChallenges/BassTrace.json
+      declaration: OAI.BassTrace.RightProjective.bassTraceModules_vanishing_and_support
+      file: OAI/RingTheory/BassTrace/Main.lean
+
+    - comparator_config: ComparatorChallenges/BiholderTransport.json
+      declaration: OAI.WeakMTWTransport.uniform_biHolder_transport
+      file: OAI/Analysis/BiholderTransport/Main.lean
+
+    - comparator_config: ComparatorChallenges/BinPackingGap.json
+      declaration: OAI.BinPackingGap.main_results
+      file: OAI/Computability/BinPacking/Main.lean
+
+    - comparator_config: ComparatorChallenges/BinaryMatching.json
+      declaration: OAI.BinaryMatching.deterministic_approximate_counting
+      file: OAI/Computability/MatchingCount/BinarySolve.lean
+
+    - comparator_config: ComparatorChallenges/BinarySweep.json
+      declaration: OAI.binary_sweep_contraction_and_mixing
+      file: OAI/Probability/BinarySweep/Main.lean
+
+    - comparator_config: ComparatorChallenges/BipartiteCrossing.json
+      declaration: OAI.Zarankiewicz.mainTarget_proof
+      file: OAI/Combinatorics/Crossing/Main.lean
+
+    - comparator_config: ComparatorChallenges/BorsukNine.json
+      declaration: OAI.BorsukNine.main_theorem
+      file: OAI/Geometry/Borsuk/Counterexample.lean
+
+    - comparator_config: ComparatorChallenges/BoundedRecovery.json
+      declaration: OAI.BoundedRecovery.bounded_recovery
+      file: OAI/Analysis/ModularRecovery/Recovery.lean
+
+    - comparator_config: ComparatorChallenges/BoundedTreePotentials.json
+      declaration: OAI.BoundedTreePotentials.TreeCalculus.main_counterexample
+      file: OAI/Analysis/TreePotential/Main.lean
+
+    - comparator_config: ComparatorChallenges/BoundedTreewidthL1.json
+      declaration: OAI.BoundedTreewidthL1.main_theorem
+      file: OAI/Combinatorics/TreewidthL1/Main.lean
+
+    - comparator_config: ComparatorChallenges/Brennan.json
+      declaration: OAI.Brennan.main_theorem
+      file: OAI/Analysis/IntegralMeans/Main.lean
+
+    - comparator_config: ComparatorChallenges/BrennanSharp.json
+      declaration: OAI.Brennan.Sharp.sharp_endpoints
+      file: OAI/Analysis/IntegralMeans/SharpEndpoints.lean
+
+    - comparator_config: ComparatorChallenges/C0Absorption.json
+      declaration: OAI.C0Absorption.main_result
+      file: OAI/Analysis/C0Absorption/Main.lean
+
+    - comparator_config: ComparatorChallenges/CHObstruction.json
+      declaration: OAI.CHObstruction.main
+      file: OAI/ModelTheory/Categoricity/Main.lean
+
+    - comparator_config: ComparatorChallenges/CharacterCriterion.json
+      declaration: OAI.KirchbergRordam.character_criterion
+      file: OAI/Analysis/CharacterCriterion/Main.lean
+
+    - comparator_config: ComparatorChallenges/ChoicelessPolynomialTime.json
+      declaration: OAI.CPTSeparation.main
+      file: OAI/ModelTheory/Choiceless/Separation.lean
+
+    - comparator_config: ComparatorChallenges/CirculantHadamard.json
+      declaration: OAI.CirculantHadamard.exists_iff_order_one_or_four
+      file: OAI/LinearAlgebra/CirculantHadamard/Main.lean
+
+    - comparator_config: ComparatorChallenges/ClassicalON.json
+      declaration: OAI.ClassicalON.main
+      file: OAI/Probability/ClassicalON/Main.lean
+
+    - comparator_config: ComparatorChallenges/CliqueFreeLog.json
+      declaration: OAI.CliqueFreeLog.logarithmic_independence_bound
+      file: OAI/Combinatorics/CliqueFree/Main.lean
+
+    - comparator_config: ComparatorChallenges/CommonBasesFPRAS.json
+      declaration: OAI.common_bases_fpras
+      file: OAI/Combinatorics/MatroidCounting/CommonBases.lean
+
+    - comparator_config: ComparatorChallenges/CommutingDerivations.json
+      declaration: OAI.AbhyankarSathaye.CommutingDerivations.commuting_derivations_with_ordinary_extras
+      file: OAI/AlgebraicGeometry/CommutingDerivations/OrdinaryExtraMain.lean
+
+    - comparator_config: ComparatorChallenges/CompactBanach.json
+      declaration: OAI.CompactBanach.main
+      file: OAI/Geometry/DoublingHilbert/CompactBanach.lean
+
+    - comparator_config: ComparatorChallenges/CompleteCrossing.json
+      declaration: OAI.Paper170.complete_graph_crossing_number
+      file: OAI/Combinatorics/CompleteCrossing/Main.lean
+
+    - comparator_config: ComparatorChallenges/CompleteCrouzeix.json
+      declaration: OAI.CompleteCrouzeix.main
+      file: OAI/Analysis/NumericalRange/Main.lean
+
+    - comparator_config: ComparatorChallenges/ComplexCancellation.json
+      declaration: OAI.ComplexCancellation.main
+      file: OAI/Algebra/AffineCancellation/Main.lean
+
+    - comparator_config: ComparatorChallenges/Conductivity.json
+      declaration: OAI.ScalarConductivity.main_nonuniqueness
+      file: OAI/Analysis/Conductivity/Main.lean
+
+    - comparator_config: ComparatorChallenges/ConjugatePoints.json
+      declaration: OAI.ThreeManifold.main_theorem
+      file: OAI/Geometry/ConjugatePoints/ThreeManifold.lean
+
+    - comparator_config: ComparatorChallenges/ContinuumTransition.json
+      declaration: OAI.ContinuumTemperature.main_theorem
+      file: OAI/Probability/ContinuumTransition/Main.lean
+
+    - comparator_config: ComparatorChallenges/CoordinateSweeps.json
+      declaration: OAI.CoordinateSweeps.conditional_main
+      file: OAI/Probability/CoordinateSweeps/Main.lean
+
+    - comparator_config: ComparatorChallenges/Cotype.json
+      declaration: OAI.Cotype.mainTarget_proved
+      file: OAI/Analysis/Cotype/Main.lean
+
+    - comparator_config: ComparatorChallenges/CoulombIonization.json
+      declaration: OAI.CoulombAtom.generalized_ionization
+      file: OAI/Analysis/CoulombIonization/Main.lean
+
+    - comparator_config: ComparatorChallenges/CourtadeKumar.json
+      declaration: OAI.LeanBlast.CourtadeKumar.courtadeKumarAndAttainment
+      file: OAI/InformationTheory/BooleanNoise/Main.lean
+
+    - comparator_config: ComparatorChallenges/CriticalSK.json
+      declaration: OAI.CriticalSK.covariance_and_linear_tests
+      file: OAI/MathematicalPhysics/CriticalSK/Rayleigh.lean
+
+    - comparator_config: ComparatorChallenges/CriticalSKMixing.json
+      declaration: OAI.CriticalSK.critical_mixing_bounds
+      file: OAI/MathematicalPhysics/CriticalMixing/Main.lean
+
+    - comparator_config: ComparatorChallenges/CriticalZ3.json
+      declaration: OAI.CriticalZ3.critical_no_infinite
+      file: OAI/Probability/CriticalZ3/Main.lean
+
+    - comparator_config: ComparatorChallenges/CycleDecomposition.json
+      declaration: OAI.ErdosGallai.erdos_gallai
+      file: OAI/Combinatorics/CycleDecomposition/Main.lean
+
+    - comparator_config: ComparatorChallenges/DaugavetModuli.json
+      declaration: OAI.ExactModuli.exact_example
+      file: OAI/Analysis/Daugavet/Main.lean
+
+    - comparator_config: ComparatorChallenges/DegreeRigidity.json
+      declaration: OAI.TuringRigidity.ManuscriptMain.rigidity
+      file: OAI/Computability/DegreeRigidity/Main.lean
+
+    - comparator_config: ComparatorChallenges/DeligneDrinfeld.json
+      declaration: OAI.DeligneDrinfeld.main
+      file: OAI/Algebra/Drinfeld/Completion.lean
+
+    - comparator_config: ComparatorChallenges/DepthThree.json
+      declaration: OAI.DepthThreeLowerBound.exists_polynomial_time_language_depth_three_lower_bound
+      file: OAI/Computability/DepthThree/Main.lean
+
+    - comparator_config: ComparatorChallenges/DiamondDistortion.json
+      declaration: OAI.DiamondDistortion.headline_all_pairs
+      file: OAI/Analysis/DiamondDistortion/Descent.lean
+
+    - comparator_config: ComparatorChallenges/DirectCrouzeix.json
+      declaration: OAI.DirectCrouzeix.complete_crouzeix
+      file: OAI/Analysis/DirectCrouzeix/CompleteBound.lean
+
+    - comparator_config: ComparatorChallenges/DirectionalBallisticity.json
+      declaration: OAI.DirectionalTransience.directional_transience_implies_ballisticity
+      file: OAI/Probability/Ballisticity/Main.lean
+
+    - comparator_config: ComparatorChallenges/DirichletSevenEighths.json
+      declaration: OAI.DirichletCharacter.LFunction_ne_zero_of_seven_eighths_lt_re
+      file: OAI/NumberTheory/DirichletL/Nonvanishing.lean
+
+    - comparator_config: ComparatorChallenges/DixmierAllDiscrete.json
+      declaration: OAI.Dixmier.current_main_theorem
+      file: OAI/Analysis/Unitarizability/AllDiscrete.lean
+
+    - comparator_config: ComparatorChallenges/DoublingHilbert.json
+      declaration: OAI.DoublingHilbert.main
+      file: OAI/Geometry/DoublingHilbert/Main.lean
+
+    - comparator_config: ComparatorChallenges/EgyptianFractions.json
+      declaration: OAI.Problem337.main_double_log_order
+      file: OAI/NumberTheory/EgyptianFractions/Main.lean
+
+    - comparator_config: ComparatorChallenges/EgyptianFractions.json
+      declaration: OAI.Problem337.counting_double_log_order
+      file: OAI/NumberTheory/EgyptianFractions/Main.lean
+
+    - comparator_config: ComparatorChallenges/EgyptianFractions.json
+      declaration: OAI.Problem337.prescribed_denominator_corollary
+      file: OAI/NumberTheory/EgyptianFractions/Main.lean
+
+    - comparator_config: ComparatorChallenges/EntangledGames.json
+      declaration: OAI.ThresholdParallelRepetition.threshold_parallel_repetition
+      file: OAI/Probability/EntangledGames/Main.lean
+
+    - comparator_config: ComparatorChallenges/EuclideanFiveColor.json
+      declaration: OAI.EuclideanFiveColor.no_proper_five_coloring
+      file: OAI/Geometry/PlaneColoring/Five.lean
+
+    - comparator_config: ComparatorChallenges/EuclideanRamsey.json
+      declaration: OAI.EuclideanRamsey.classification
+      file: OAI/Combinatorics/EuclideanRamsey/Main.lean
+
+    - comparator_config: ComparatorChallenges/ExactFourier.json
+      declaration: OAI.ExactFourier.main_theorem
+      file: OAI/Computability/FourierCircuit/Main.lean
+
+    - comparator_config: ComparatorChallenges/FactorGeneration.json
+      declaration: OAI.Generator.single_generation_of_II1_separable_predual
+      file: OAI/Analysis/FactorGeneration/Main.lean
+
+    - comparator_config: ComparatorChallenges/FinitisticAsymmetry.json
+      declaration: OAI.LittleFinitistic.extreme_left_right_asymmetry
+      file: OAI/Algebra/FinitisticAsymmetry/Main.lean
+
+    - comparator_config: ComparatorChallenges/ForestSpace.json
+      declaration: OAI.ForestSpace.main_theorem
+      file: OAI/Analysis/ForestSpace/Main.lean
+
+    - comparator_config: ComparatorChallenges/FoulkesHowe.json
+      declaration: OAI.Problem346.canonical_foulkes_howe_surjective
+      file: OAI/RepresentationTheory/FoulkesHowe/Stabilization.lean
+
+    - comparator_config: ComparatorChallenges/FreeIsing.json
+      declaration: OAI.Problem367.free_ising_factor_iff_threshold
+      file: OAI/Probability/FreeIsing/Main.lean
+
+    - comparator_config: ComparatorChallenges/GaussianMoat.json
+      declaration: OAI.GaussianMoat.fullMain
+      file: OAI/NumberTheory/GaussianMoat/Main.lean
+
+    - comparator_config: ComparatorChallenges/GaussianPropeller.json
+      declaration: OAI.GaussianPropeller.all_partitions
+      file: OAI/Probability/GaussianPropeller/Main.lean
+
+    - comparator_config: ComparatorChallenges/GaussianReplacement.json
+      declaration: OAI.CurrentProjection.hybridBlockMain
+      file: OAI/Probability/GaussianReplacement/Hybrid.lean
+
+    - comparator_config: ComparatorChallenges/GaussianReplacement.json
+      declaration: OAI.CurrentProjection.fiberBlockMain
+      file: OAI/Probability/GaussianReplacement/FiberBlock.lean
+
+    - comparator_config: ComparatorChallenges/GotsmanLinial.json
+      declaration: OAI.LeanBlast.GotsmanLinial.gotsmanLinialStatement
+      file: OAI/Combinatorics/GotsmanLinial/Main.lean
+
+    - comparator_config: ComparatorChallenges/GrahamSpherical.json
+      declaration: OAI.GrahamSpherical.full_main
+      file: OAI/Combinatorics/SphericalRamsey/Main.lean
+
+    - comparator_config: ComparatorChallenges/GrothendieckElementaryExpansion.json
+      declaration: OAI.Grothendieck.elementary_expansion
+      file: OAI/CategoryTheory/Globular/ElementaryExpansion.lean
+
+    - comparator_config: ComparatorChallenges/GroupRingDeterminant.json
+      declaration: OAI.GroupRingDeterminant.main
+      file: OAI/Analysis/GroupDeterminants/Main.lean
+
+    - comparator_config: ComparatorChallenges/HarmonicArtin.json
+      declaration: OAI.HarmonicArtin.salvetti_cover_contractible
+      file: OAI/Topology/ArtinGroups/Realizations/SalvettiCoverContractible.lean
+
+    - comparator_config: ComparatorChallenges/HarmonicGrowth.json
+      declaration: OAI.HarmonicCounterexample.main
+      file: OAI/Geometry/HarmonicGrowth/Main.lean
+
+    - comparator_config: ComparatorChallenges/HeckeSevenEighths.json
+      declaration: OAI.SevenEighths.HeckeFamily.LFunction_ne_zero_of_seven_eighths_lt_re
+      file: OAI/NumberTheory/DirichletL/Hecke/Nonvanishing.lean
+
+    - comparator_config: ComparatorChallenges/HenonEmden.json
+      declaration: OAI.HenonLaneEmden.main_nonexistence
+      file: OAI/Analysis/HenonEmden/Main.lean
+
+    - comparator_config: ComparatorChallenges/HyperbolicCones.json
+      declaration: OAI.Paper256.main_result
+      file: OAI/Analysis/HyperbolicCones/Main.lean
+
+    - comparator_config: ComparatorChallenges/HyperbolicObstruction.json
+      declaration: OAI.HyperbolicObstruction.main
+      file: OAI/Geometry/HyperbolicGroups/Main.lean
+
+    - comparator_config: ComparatorChallenges/IndependentProducts.json
+      declaration: OAI.IndependentProducts.main_general
+      file: OAI/Analysis/ProductSpaces/WeakNullity.lean
+
+    - comparator_config: ComparatorChallenges/IndependentProducts.json
+      declaration: OAI.IndependentProducts.main_exponential
+      file: OAI/Analysis/ProductSpaces/Main.lean
+
+    - comparator_config: ComparatorChallenges/IndependentSets.json
+      declaration: OAI.LargeIndependentSets.mainTheoremReal
+      file: OAI/Combinatorics/IndependentSets/Main.lean
+
+    - comparator_config: ComparatorChallenges/InfiniteMatroid.json
+      declaration: OAI.InfiniteMatroidCounterexample.main
+      file: OAI/Combinatorics/InfiniteMatroid/Main.lean
+
+    - comparator_config: ComparatorChallenges/IsometricImmersion.json
+      declaration: OAI.SmoothLocal.Geometry.exists_local_metric_without_local_immersion
+      file: OAI/Geometry/IsometricImmersion/Main.lean
+
+    - comparator_config: ComparatorChallenges/Jacobsthal.json
+      declaration: OAI.Erdos970.Erdos970Final.erdos_970_quadratic
+      file: OAI/NumberTheory/Jacobsthal/Conclusions/QuadraticBound.lean
+
+    - comparator_config: ComparatorChallenges/KMedianRecovery.json
+      declaration: OAI.MetricKMedianRecovery.global_application
+      file: OAI/Combinatorics/KMedianRecovery/Main.lean
+
+    - comparator_config: ComparatorChallenges/KahlerSplitting.json
+      declaration: OAI.UniversalCoverSplitting.main
+      file: OAI/Geometry/KahlerSplitting/Main.lean
+
+    - comparator_config: ComparatorChallenges/KaplanskyFinitelyPresented.json
+      declaration: OAI.KaplanskyCounterexample.finitelyPresented_counterexample
+      file: OAI/RingTheory/DirectFiniteness/FinitelyPresented.lean
+
+    - comparator_config: ComparatorChallenges/KaplanskyQuasitrace.json
+      declaration: OAI.Kaplansky.kaplansky_quasitrace_counterexample
+      file: OAI/Analysis/Kaplansky/Main.lean
+
+    - comparator_config: ComparatorChallenges/Laughlin.json
+      declaration: OAI.Laughlin.mainTarget_proved
+      file: OAI/Analysis/Laughlin/Main.lean
+
+    - comparator_config: ComparatorChallenges/LiebThirring.json
+      declaration: OAI.SharpLiebThirring.sharp_lieb_thirring
+      file: OAI/Analysis/LiebThirring/Main.lean
+
+    - comparator_config: ComparatorChallenges/LipschitzEquivalence.json
+      declaration: OAI.LipschitzCounterexample.main
+      file: OAI/Analysis/LipschitzEquivalence/Main.lean
+
+    - comparator_config: ComparatorChallenges/LittleFinitistic.json
+      declaration: OAI.LittleFinitistic.Main.exists_counterexample
+      file: OAI/Algebra/Finitistic/Main.lean
+
+    - comparator_config: ComparatorChallenges/LogBrunnMinkowski.json
+      declaration: OAI.LogBrunnMinkowski.main
+      file: OAI/Geometry/LogVolume/BrunnMinkowski.lean
+
+    - comparator_config: ComparatorChallenges/LogConcaveQuery.json
+      declaration: OAI.LogConcaveSampling.exact_source_main
+      file: OAI/Probability/LogConcave/Main.lean
+
+    - comparator_config: ComparatorChallenges/MahlerConjecture.json
+      declaration: OAI.SymmetricMahler.symmetric_mahler
+      file: OAI/Analysis/Mahler/MainTheorem.lean
+
+    - comparator_config: ComparatorChallenges/MarkovType.json
+      declaration: OAI.MarkovSuperreflexivity.hasNontrivialMarkovType_iff_hasEquivalentUCNorm
+      file: OAI/Analysis/MarkovType/Main.lean
+
+    - comparator_config: ComparatorChallenges/MatchingEntropy.json
+      declaration: OAI.MatchingEntropy.entropy_main
+      file: OAI/Combinatorics/PerfectMatching/Main.lean
+
+    - comparator_config: ComparatorChallenges/MatrixFields.json
+      declaration: OAI.MatrixAllFields.MatrixMultiplication.AllFieldMain.omega_lt_source_constant
+      file: OAI/LinearAlgebra/MatrixFields/Conclusions/AllFieldsBound.lean
+
+    - comparator_config: ComparatorChallenges/MatrixMultiplication.json
+      declaration: OAI.MatrixMultiplication.complex_omega_le_nine_quarters
+      file: OAI/LinearAlgebra/MatrixMultiplication/Main.lean
+
+    - comparator_config: ComparatorChallenges/MatrixMultiplication.json
+      declaration: OAI.MatrixMultiplication.complex_alpha_gt_93_div_200
+      file: OAI/LinearAlgebra/MatrixMultiplication/Main.lean
+
+    - comparator_config: ComparatorChallenges/MatrixMultiplication.json
+      declaration: OAI.MatrixMultiplication.complex_rectangular_omega_lt_523_div_250
+      file: OAI/LinearAlgebra/MatrixMultiplication/Main.lean
+
+    - comparator_config: ComparatorChallenges/MatrixRemoval.json
+      declaration: OAI.Problem348.no_polynomial_removal_bound
+      file: OAI/Combinatorics/MatrixRemoval/Main.lean
+
+    - comparator_config: ComparatorChallenges/MaximalSeshadriConstants.json
+      declaration: OAI.MaximalSeshadri.Geometry.maximalSeshadriConstants
+      file: OAI/AlgebraicGeometry/Seshadri/Main.lean
+
+    - comparator_config: ComparatorChallenges/MemoryPrecision.json
+      declaration: OAI.MemoryPrecision.main
+      file: OAI/Probability/MemoryPrecision/Main.lean
+
+    - comparator_config: ComparatorChallenges/MetricEntropyDuality.json
+      declaration: OAI.MetricEntropyDuality.exists_entropy_duality_counterexample_with_covers
+      file: OAI/Analysis/MetricEntropy/Main.lean
+
+    - comparator_config: ComparatorChallenges/MidpointLenses.json
+      declaration: OAI.SegmentLenses.midpoint_lens_main
+      file: OAI/Analysis/SegmentLenses/Main.lean
+
+    - comparator_config: ComparatorChallenges/Nagata.json
+      declaration: OAI.Nagata.nagata_conjecture
+      file: OAI/AlgebraicGeometry/PlaneCurves/Nagata.lean
+
+    - comparator_config: ComparatorChallenges/OddKaplansky.json
+      declaration: OAI.OddKaplansky.main_theorem
+      file: OAI/Algebra/OddKaplansky/Main.lean
+
+    - comparator_config: ComparatorChallenges/OneWayLiveness.json
+      declaration: OAI.OneWayLiveness.main_theorem
+      file: OAI/Combinatorics/Automata/Main.lean
+
+    - comparator_config: ComparatorChallenges/OptimalMaxCut.json
+      declaration: OAI.OptimalMaxCut.main
+      file: OAI/Computability/MaxCut/Main.lean
+
+    - comparator_config: ComparatorChallenges/PartitionPrinciple.json
+      declaration: OAI.PartitionPilot.Forcing.TransitiveGround.exists_model_partitionPrinciple_without_choice
+      file: OAI/SetTheory/PartitionPrinciple/Models/Separation.lean
+
+    - comparator_config: ComparatorChallenges/PerfectCompleteness.json
+      declaration: OAI.PerfectCompleteness.Theorem11.exists_reduction
+      file: OAI/Computability/PerfectCompleteness/Theorem11.lean
+
+    - comparator_config: ComparatorChallenges/PeriodicTilingThree.json
+      declaration: OAI.PeriodicTilingThree.periodic_tiling_counterexample_and_minimality
+      file: OAI/Geometry/PeriodicTiling/Counterexample.lean
+
+    - comparator_config: ComparatorChallenges/PettyProjectionVolume.json
+      declaration: OAI.PettyProjection.petty_projection_volume
+      file: OAI/Geometry/ProjectionBodies/Main.lean
+
+    - comparator_config: ComparatorChallenges/PinchedKahler.json
+      declaration: OAI.PinchedHartogs.main_theorem
+      file: OAI/Geometry/Kahler/Main.lean
+
+    - comparator_config: ComparatorChallenges/PinnedDistances.json
+      declaration: OAI.WeakPinned.main
+      file: OAI/Geometry/PinnedDistances/Main.lean
+
+    - comparator_config: ComparatorChallenges/PlanarFalconer.json
+      declaration: OAI.PlanarFalconer.mainTarget_proved
+      file: OAI/MeasureTheory/Falconer/Main.lean
+
+    - comparator_config: ComparatorChallenges/PlanarFirstPassage.json
+      declaration: OAI.PlanarFPP.manuscriptMain
+      file: OAI/Probability/FirstPassage/BoundaryCurve.lean
+
+    - comparator_config: ComparatorChallenges/PlanarL1.json
+      declaration: OAI.PlanarL1.planar_graph_metrics_embed_L1
+      file: OAI/Combinatorics/PlanarL1/Embedding.lean
+
+    - comparator_config: ComparatorChallenges/PlaneColoring.json
+      declaration: OAI.Problem160.properColoring_seven
+      file: OAI/Geometry/PlaneColoring/Seven.lean
+
+    - comparator_config: ComparatorChallenges/PosteriorReplicas.json
+      declaration: OAI.PosteriorReplicas.source_main
+      file: OAI/Probability/PosteriorReplicas/Main.lean
+
+    - comparator_config: ComparatorChallenges/PowerFreeValues.json
+      declaration: OAI.QuarticPowerFree.allDegrees
+      file: OAI/NumberTheory/PowerFree/Main.lean
+
+    - comparator_config: ComparatorChallenges/ProjectionCounterexample.json
+      declaration: OAI.ProjectionCounterexample.universal_simplex_upper_bound_false
+      file: OAI/Geometry/ProjectionBody/Counterexample.lean
+
+    - comparator_config: ComparatorChallenges/ProjectionMoments.json
+      declaration: OAI.ProjectionMoments.main
+      file: OAI/Probability/ProjectionMoments/Main.lean
+
+    - comparator_config: ComparatorChallenges/ProjectionVolume.json
+      declaration: OAI.Paper092.product_counterexample
+      file: OAI/Geometry/ProjectionVolume/ProductCounterexample.lean
+
+    - comparator_config: ComparatorChallenges/QACParity.json
+      declaration: OAI.QAC.parity_lower_bound
+      file: OAI/InformationTheory/QuantumCircuit/Parity.lean
+
+    - comparator_config: ComparatorChallenges/QuadricBundles.json
+      declaration: OAI.QuadricCounterexample.main_theorem
+      file: OAI/Geometry/QuadricBundles/Main.lean
+
+    - comparator_config: ComparatorChallenges/QuantitativeVanDerWaerden.json
+      declaration: OAI.QuantitativeVanDerWaerden.uniform_lower_bound
+      file: OAI/Combinatorics/ProgressionColoring/Main.lean
+
+    - comparator_config: ComparatorChallenges/QuasiRiemannHypothesis.json
+      declaration: OAI.riemannZeta_ne_zero_of_seven_eighths_lt_re
+      file: OAI/NumberTheory/DirichletL/Nonvanishing.lean
+
+    - comparator_config: ComparatorChallenges/QuinticLienard.json
+      declaration: OAI.QuinticLienard.main
+      file: OAI/Analysis/LienardCycles/Main.lean
+
+    - comparator_config: ComparatorChallenges/RadialTransition.json
+      declaration: OAI.RadialTransition.main
+      file: OAI/Probability/RadialTransition/Main.lean
+
+    - comparator_config: ComparatorChallenges/RandomizedMeanPayoff.json
+      declaration: OAI.randomized_quasipolynomial_mean_payoff
+      file: OAI/Computability/RandomMean/Main.lean
+
+    - comparator_config: ComparatorChallenges/RationalHitting.json
+      declaration: OAI.RationalHitting.main
+      file: OAI/Computability/RationalHitting/Main.lean
+
+    - comparator_config: ComparatorChallenges/RecursivePotentials.json
+      declaration: OAI.ComparatorModel.RecursivePotentials.main
+      file: OAI/Analysis/RecursivePotentials/Challenge.lean
+
+    - comparator_config: ComparatorChallenges/ReflexiveFixedPoints.json
+      declaration: OAI.ReflexiveFixedPoints.exists_fixedPoint_of_canonicallyReflexive
+      file: OAI/Analysis/Nonexpansive/Main.lean
+
+    - comparator_config: ComparatorChallenges/RegularParity.json
+      declaration: OAI.QAC.parity_lower_bound_polynomial_size
+      file: OAI/InformationTheory/QuantumCircuit/Main.lean
+
+    - comparator_config: ComparatorChallenges/RieszQuantitative.json
+      declaration: OAI.RieszRectifiability.quantitative_higher_codimension_riesz_rectifiability
+      file: OAI/Analysis/RieszRectifiability/Uniformity/Rectifiability.lean
+
+    - comparator_config: ComparatorChallenges/RyserCovering.json
+      declaration: OAI.RyserCoveringCounterexample.exists_prime_eventually_counterexampleRank
+      file: OAI/Combinatorics/Ryser/Construction/Main.lean
+
+    - comparator_config: ComparatorChallenges/RyserOddExtensions.json
+      declaration: OAI.RyserOdd.eventualOddFailures_and_infinite
+      file: OAI/Combinatorics/Ryser/OddExtensions.lean
+
+    - comparator_config: ComparatorChallenges/Saxl.json
+      declaration: OAI.Saxl.saxl_conjecture
+      file: OAI/RepresentationTheory/Saxl/Main.lean
+
+    - comparator_config: ComparatorChallenges/SecondKahnKalai.json
+      declaration: OAI.LeanBlast.SecondKahnKalai.secondKahnKalaiBounds
+      file: OAI/Combinatorics/GraphThreshold/Main.lean
+
+    - comparator_config: ComparatorChallenges/SelfSimilar.json
+      declaration: OAI.EntropyRateDimension.entropy_rate_dimension
+      file: OAI/MeasureTheory/SelfSimilar/Main.lean
+
+    - comparator_config: ComparatorChallenges/SensitivitySeparation.json
+      declaration: OAI.Paper320.quantitative_separation
+      file: OAI/Combinatorics/Sensitivity/Separation.lean
+
+    - comparator_config: ComparatorChallenges/SeymourSecondNeighborhood.json
+      declaration: OAI.SeymourSecondNeighborhood.exists_goodVertex
+      file: OAI/Combinatorics/SecondNeighborhood/Main.lean
+
+    - comparator_config: ComparatorChallenges/SiegelZeros.json
+      declaration: OAI.SiegelZeros.WeightedTorusJets.exists_absolute_real_zero_gap
+      file: OAI/NumberTheory/SiegelZeros/Conclusions/Theorem.lean
+
+    - comparator_config: ComparatorChallenges/SignedFiniteBand.json
+      declaration: OAI.SignedDisk.CenteredDiskEndpoint.main_signed_finite_band
+      file: OAI/Analysis/SignedDisk/Main.lean
+
+    - comparator_config: ComparatorChallenges/SimpleAmenable.json
+      declaration: OAI.SimpleAmenable.main
+      file: OAI/GroupTheory/SimpleAmenable/Main.lean
+
+    - comparator_config: ComparatorChallenges/SingleFold.json
+      declaration: OAI.SingleFold.main
+      file: OAI/NumberTheory/SingleFold/Main.lean
+
+    - comparator_config: ComparatorChallenges/SingleLatticeCovering.json
+      declaration: OAI.SingleLatticeCovering.single_lattice_covering
+      file: OAI/Geometry/LatticeCovering/Main.lean
+
+    - comparator_config: ComparatorChallenges/SingletonLoopMatching.json
+      declaration: OAI.LoopMatching.fullEndpoint
+      file: OAI/Computability/LoopMatching/Main.lean
+
+    - comparator_config: ComparatorChallenges/SmoothYau.json
+      declaration: OAI.YauCounterexamples.sphere_three
+      file: OAI/Geometry/SmoothYau/SphereMetric/ThreeSphere.lean
+
+    - comparator_config: ComparatorChallenges/SmoothYau.json
+      declaration: OAI.YauCounterexamples.sphere_two_torus_two
+      file: OAI/Geometry/SmoothYau/ProductMetric/SphereProduct.lean
+
+    - comparator_config: ComparatorChallenges/SteinitzBergstrom.json
+      declaration: OAI.EuclideanSteinitzBergstrom.main
+      file: OAI/Analysis/Steinitz/Main.lean
+
+    - comparator_config: ComparatorChallenges/StrictMeans.json
+      declaration: OAI.StrictInverseFirstPower.main
+      file: OAI/Analysis/StrictMeans/Main.lean
+
+    - comparator_config: ComparatorChallenges/StrongThinTree.json
+      declaration: OAI.StrongThinTree.strongThinTree
+      file: OAI/Combinatorics/ThinTrees/Main.lean
+
+    - comparator_config: ComparatorChallenges/StructuralCrouzeix.json
+      declaration: OAI.StructuralCrouzeixReference.challenge
+      file: OAI/Analysis/StructuralCrouzeix/Endpoint.lean
+
+    - comparator_config: ComparatorChallenges/SubpolynomialLp.json
+      declaration: OAI.SubpolynomialLp.source_main
+      file: OAI/Analysis/LpDimension/Main.lean
+
+    - comparator_config: ComparatorChallenges/SubsphereCurrent.json
+      declaration: OAI.SubsphereCurrent.full_current_main_scope
+      file: OAI/Probability/Subsphere/Main.lean
+
+    - comparator_config: ComparatorChallenges/Superstring.json
+      declaration: OAI.Superstring.main
+      file: OAI/Computability/Superstring/Main.lean
+
+    - comparator_config: ComparatorChallenges/SymmetricDomains.json
+      declaration: OAI.Release061.main
+      file: OAI/Analysis/SymmetricDomains/Main.lean
+
+    - comparator_config: ComparatorChallenges/SymmetricMahlerEquality.json
+      declaration: OAI.SymmetricMahler.symmetric_mahler_equality
+      file: OAI/Analysis/Mahler/Classification.lean
+
+    - comparator_config: ComparatorChallenges/SymmetricPolar.json
+      declaration: OAI.SymmetricPolar.symmetric_polar_main
+      file: OAI/Geometry/PolarProducts/Main.lean
+
+    - comparator_config: ComparatorChallenges/Tachikawa.json
+      declaration: OAI.Tachikawa.main_theorem
+      file: OAI/RingTheory/Tachikawa/Counterexample.lean
+
+    - comparator_config: ComparatorChallenges/TalagrandDiscreteConvexity.json
+      declaration: OAI.TalagrandDiscreteConvexity.talagrand_discrete_convexity
+      file: OAI/Combinatorics/DiscreteConvexity/Main.lean
+
+    - comparator_config: ComparatorChallenges/TalagrandExpectationThreshold.json
+      declaration: OAI.TalagrandThreshold.talagrand_expectation_threshold_equivalence
+      file: OAI/Combinatorics/ExpectationThreshold/Main.lean
+
+    - comparator_config: ComparatorChallenges/TamingCompatibility.json
+      declaration: OAI.TamingCompatibility.taming_implies_compatibility
+      file: OAI/Geometry/TamingCompatibility/Main.lean
+
+    - comparator_config: ComparatorChallenges/ThompsonNonamenability.json
+      declaration: OAI.ThompsonNonamenability.thompson_F_nonamenable_composition
+      file: OAI/GroupTheory/Thompson/Main.lean
+
+    - comparator_config: ComparatorChallenges/ThorpRouting.json
+      declaration: OAI.ThorpNine.main
+      file: OAI/Probability/ThorpRouting/Main.lean
+
+    - comparator_config: ComparatorChallenges/ThorpWeightedCompatibility.json
+      declaration: OAI.ThorpCompatibility.weightedCompatibility_main
+      file: OAI/Probability/ThorpCompatibility/Main.lean
+
+    - comparator_config: ComparatorChallenges/TingleySphereIsometry.json
+      declaration: OAI.Tingley.tingley_sphere_isometry_full
+      file: OAI/Analysis/SphereIsometry/Extension.lean
+
+    - comparator_config: ComparatorChallenges/TorsionFreeHyperbolic.json
+      declaration: OAI.Release075.main
+      file: OAI/GroupTheory/Hyperbolic/Main.lean
+
+    - comparator_config: ComparatorChallenges/TorsionFreeZeroDivisors.json
+      declaration: OAI.TorsionFreeZeroDivisors.main
+      file: OAI/Algebra/GroupRing/Main.lean
+
+    - comparator_config: ComparatorChallenges/TriangularHilbert.json
+      declaration: OAI.TriangularHilbert.main_estimate
+      file: OAI/Analysis/TriangularHilbert/Main.lean
+
+    - comparator_config: ComparatorChallenges/TwoWayComplementation.json
+      declaration: OAI.TwoWayComplementation.complementation_lower_bound_finite
+      file: OAI/Combinatorics/TwoWayAutomata/Main.lean
+
+    - comparator_config: ComparatorChallenges/TwoWayDeterminization.json
+      declaration: OAI.TwoWayComplementation.explicit_family_main
+      file: OAI/Combinatorics/TwoWayAutomata/ExplicitFamily.lean
+
+    - comparator_config: ComparatorChallenges/UniformGamma.json
+      declaration: OAI.ComparatorModel.CurrentMain.main
+      file: OAI/Analysis/TracialSplitting/Challenge.lean
+
+    - comparator_config: ComparatorChallenges/UniformSparsestCut.json
+      declaration: OAI.UniformSparsestCut.mainGap
+      file: OAI/Combinatorics/SparsestCut/Main.lean
+
+    - comparator_config: ComparatorChallenges/UniqueGamesTheorem.json
+      declaration: OAI.UniqueGamesTheorem.theorem11
+      file: OAI/Computability/UniqueGames/Theorem.lean
+
+    - comparator_config: ComparatorChallenges/UniversalFInfinity.json
+      declaration: OAI.UniversalFInfinity.universal_group_of_type_FInfinity
+      file: OAI/GroupTheory/UniversalGroup/Main.lean
+
+    - comparator_config: ComparatorChallenges/VertexCover.json
+      declaration: OAI.VertexCover.every_fixed_factor_below_two
+      file: OAI/Computability/VertexCover/Main.lean
+
+    - comparator_config: ComparatorChallenges/VlasovMaxwell.json
+      declaration: OAI.RVM.global_classical_solution
+      file: OAI/Analysis/VlasovMaxwell/Main.lean
+
+    - comparator_config: ComparatorChallenges/WeakHessian.json
+      declaration: OAI.WeakHessian.every_geodesic
+      file: OAI/Geometry/WeakHessian/Main.lean
+
+    - comparator_config: ComparatorChallenges/WeakMTWGlobalSupport.json
+      declaration: OAI.WeakMTWGlobalSupport.current_main_convexity
+      file: OAI/Geometry/WeakMTW/Convexity.lean
+
+    - comparator_config: ComparatorChallenges/YauCounterexample.json
+      declaration: OAI.Yau.Target.yau_nodal_set_upper_bound_counterexample
+      file: OAI/Geometry/NodalSets/Main.lean
+
+automation:
+  methods:
+    - method: agent
+
+review:
+  status: unchecked
+
+acknowledgements: >-
+  Thank you very much to the authors of Lean 4, mathlib, and the other imported
+  libraries listed above, as well as to the authors of Lake, Comparator,
+  lean4export, and related tools.
diff --git a/lean/lake-manifest.json b/lean/lake-manifest.json
new file mode 100644
index 0000000000000000000000000000000000000000..67d01d2717d0aaff59fb8814bb53581b961f42b4
--- /dev/null
+++ b/lean/lake-manifest.json
@@ -0,0 +1,426 @@
+{"version": "1.2.0",
+ "packagesDir": ".lake/packages",
+ "packages":
+ [{"url": "https://github.com/leanprover-community/mathlib4.git",
+   "type": "git",
+   "subDir": null,
+   "scope": "",
+   "rev": "d13f23b723b8a846827a245b89c10fc7d3f11612",
+   "name": "mathlib",
+   "manifestFile": "lake-manifest.json",
+   "inputRev": "d13f23b723b8a846827a245b89c10fc7d3f11612",
+   "inherited": false,
+   "configFile": "lakefile.lean"},
+  {"url": "https://github.com/PatrickMassot/checkdecls.git",
+   "type": "git",
+   "subDir": null,
+   "scope": "",
+   "rev": "3d425859e73fcfbef85b9638c2a91708ef4a22d4",
+   "name": "checkdecls",
+   "manifestFile": "lake-manifest.json",
+   "inputRev": "3d425859e73fcfbef85b9638c2a91708ef4a22d4",
+   "inherited": false,
+   "configFile": "lakefile.lean"},
+  {"url": "https://github.com/leanprover/doc-gen4.git",
+   "type": "git",
+   "subDir": null,
+   "scope": "",
+   "rev": "953c8992d174b4e56955e01e101d46668c68f2bb",
+   "name": "«doc-gen4»",
+   "manifestFile": "lake-manifest.json",
+   "inputRev": "953c8992d174b4e56955e01e101d46668c68f2bb",
+   "inherited": false,
+   "configFile": "lakefile.lean"},
+  {"url": "https://github.com/b-mehta/PrimeCert.git",
+   "type": "git",
+   "subDir": null,
+   "scope": "",
+   "rev": "0803c2f6bd289c09704c7d352bb8fcf770cbb9b2",
+   "name": "PrimeCert",
+   "manifestFile": "lake-manifest.json",
+   "inputRev": "0803c2f6bd289c09704c7d352bb8fcf770cbb9b2",
+   "inherited": false,
+   "configFile": "lakefile.toml"},
+  {"url": "https://github.com/hanwenzhu/LeanArchitect.git",
+   "type": "git",
+   "subDir": null,
+   "scope": "",
+   "rev": "468e8f58fb4ad6e6ad672a08da6d0d0531e95a97",
+   "name": "LeanArchitect",
+   "manifestFile": "lake-manifest.json",
+   "inputRev": "468e8f58fb4ad6e6ad672a08da6d0d0531e95a97",
+   "inherited": false,
+   "configFile": "lakefile.lean"},
+  {"url": "https://github.com/alerad/leancert.git",
+   "type": "git",
+   "subDir": null,
+   "scope": "",
+   "rev": "7f91b6eb3567437f6cfac03ed279706603ee22f4",
+   "name": "leancert",
+   "manifestFile": "lake-manifest.json",
+   "inputRev": "7f91b6eb3567437f6cfac03ed279706603ee22f4",
+   "inherited": false,
+   "configFile": "lakefile.toml"},
+  {"url": "https://github.com/AlexKontorovich/PrimeNumberTheoremAnd.git",
+   "type": "git",
+   "subDir": null,
+   "scope": "",
+   "rev": "c39a751132c88b6e8080b74c74023fd95b3d8be0",
+   "name": "PrimeNumberTheoremAnd",
+   "manifestFile": "lake-manifest.json",
+   "inputRev": "c39a751132c88b6e8080b74c74023fd95b3d8be0",
+   "inherited": false,
+   "configFile": "lakefile.toml"},
+  {"url": "https://github.com/lana-agents/belyi.git",
+   "type": "git",
+   "subDir": null,
+   "scope": "",
+   "rev": "9ce4d3f793d3bc831f2fc7214b7dbad90ea012d8",
+   "name": "belyi",
+   "manifestFile": "lake-manifest.json",
+   "inputRev": "9ce4d3f793d3bc831f2fc7214b7dbad90ea012d8",
+   "inherited": false,
+   "configFile": "lakefile.toml"},
+  {"url": "https://github.com/lana-agents/formal-schemes.git",
+   "type": "git",
+   "subDir": null,
+   "scope": "",
+   "rev": "51aa935079537bf4dc580751a6e70727fb23ca93",
+   "name": "«formal-schemes»",
+   "manifestFile": "lake-manifest.json",
+   "inputRev": "51aa935079537bf4dc580751a6e70727fb23ca93",
+   "inherited": false,
+   "configFile": "lakefile.toml"},
+  {"url": "https://github.com/lana-agents/elliptic-curves.git",
+   "type": "git",
+   "subDir": null,
+   "scope": "",
+   "rev": "bebec3fc9f2602e81c83e5236789572a541c85fb",
+   "name": "«elliptic-curves»",
+   "manifestFile": "lake-manifest.json",
+   "inputRev": "bebec3fc9f2602e81c83e5236789572a541c85fb",
+   "inherited": false,
+   "configFile": "lakefile.toml"},
+  {"url": "https://github.com/lana-agents/tempered-fundamental-groups.git",
+   "type": "git",
+   "subDir": null,
+   "scope": "",
+   "rev": "2006651f52b70ea2fe3388238c7d9db14d21748f",
+   "name": "«tempered-fundamental-groups»",
+   "manifestFile": "lake-manifest.json",
+   "inputRev": "2006651f52b70ea2fe3388238c7d9db14d21748f",
+   "inherited": false,
+   "configFile": "lakefile.toml"},
+  {"url": "https://github.com/lana-agents/oka.git",
+   "type": "git",
+   "subDir": null,
+   "scope": "",
+   "rev": "75dcdc3faadd10b986afb9283e89902bcdddecd4",
+   "name": "oka",
+   "manifestFile": "lake-manifest.json",
+   "inputRev": "75dcdc3faadd10b986afb9283e89902bcdddecd4",
+   "inherited": false,
+   "configFile": "lakefile.toml"},
+  {"url": "https://github.com/lana-agents/orbicurve-cores.git",
+   "type": "git",
+   "subDir": null,
+   "scope": "",
+   "rev": "61616dcd77fbe45c083a8ebfa7cc80728f86e841",
+   "name": "«orbicurve-cores»",
+   "manifestFile": "lake-manifest.json",
+   "inputRev": "61616dcd77fbe45c083a8ebfa7cc80728f86e841",
+   "inherited": false,
+   "configFile": "lakefile.toml"},
+  {"url": "https://github.com/lana-agents/pi1.git",
+   "type": "git",
+   "subDir": null,
+   "scope": "",
+   "rev": "ca7def953193f861a462aa0831eec8f0a31ff69f",
+   "name": "pi1",
+   "manifestFile": "lake-manifest.json",
+   "inputRev": "ca7def953193f861a462aa0831eec8f0a31ff69f",
+   "inherited": false,
+   "configFile": "lakefile.toml"},
+  {"url": "https://github.com/lana-agents/heights.git",
+   "type": "git",
+   "subDir": null,
+   "scope": "",
+   "rev": "721496ca4c158e511d25d8ccf6bfe8503eda73c1",
+   "name": "heights",
+   "manifestFile": "lake-manifest.json",
+   "inputRev": "721496ca4c158e511d25d8ccf6bfe8503eda73c1",
+   "inherited": false,
+   "configFile": "lakefile.toml"},
+  {"url": "https://github.com/lana-agents/genl.git",
+   "type": "git",
+   "subDir": null,
+   "scope": "",
+   "rev": "ea2846c877d1e16d8f0b911a5fed07f5ee69eaaf",
+   "name": "genl",
+   "manifestFile": "lake-manifest.json",
+   "inputRev": "ea2846c877d1e16d8f0b911a5fed07f5ee69eaaf",
+   "inherited": false,
+   "configFile": "lakefile.toml"},
+  {"url": "https://github.com/lana-agents/tate-curves-theta.git",
+   "type": "git",
+   "subDir": null,
+   "scope": "",
+   "rev": "ca6c2279d3cea0690cdb01328e727118d5485d68",
+   "name": "«tate-curves-theta»",
+   "manifestFile": "lake-manifest.json",
+   "inputRev": "ca6c2279d3cea0690cdb01328e727118d5485d68",
+   "inherited": false,
+   "configFile": "lakefile.toml"},
+  {"url": "https://github.com/lana-agents/iut.git",
+   "type": "git",
+   "subDir": null,
+   "scope": "",
+   "rev": "d9465c111ec4073709f67e9fccec7e3eb374a816",
+   "name": "iut",
+   "manifestFile": "lake-manifest.json",
+   "inputRev": "d9465c111ec4073709f67e9fccec7e3eb374a816",
+   "inherited": false,
+   "configFile": "lakefile.toml"},
+  {"url": "https://github.com/Aaron1011/gromov.git",
+   "type": "git",
+   "subDir": null,
+   "scope": "",
+   "rev": "8db79f13cf211b570e3116301d91379fbc01cf3e",
+   "name": "gromov",
+   "manifestFile": "lake-manifest.json",
+   "inputRev": "8db79f13cf211b570e3116301d91379fbc01cf3e",
+   "inherited": false,
+   "configFile": "lakefile.toml"},
+  {"url": "https://github.com/TauCetiProject/TauCeti.git",
+   "type": "git",
+   "subDir": null,
+   "scope": "",
+   "rev": "3bed7e37f3c504a99e8c07e9f309540812a7aa90",
+   "name": "TauCeti",
+   "manifestFile": "lake-manifest.json",
+   "inputRev": "3bed7e37f3c504a99e8c07e9f309540812a7aa90",
+   "inherited": false,
+   "configFile": "lakefile.toml"},
+  {"url": "https://github.com/leanprover-community/sphere-eversion.git",
+   "type": "git",
+   "subDir": null,
+   "scope": "",
+   "rev": "9c53f91e2a281199163ecea04dc4976cb79e2076",
+   "name": "SphereEversion",
+   "manifestFile": "lake-manifest.json",
+   "inputRev": "9c53f91e2a281199163ecea04dc4976cb79e2076",
+   "inherited": false,
+   "configFile": "lakefile.toml"},
+  {"url": "https://github.com/alonamaloh/schoenflies-lean",
+   "type": "git",
+   "subDir": null,
+   "scope": "",
+   "rev": "05a43d29cde026618777db3d4e4316204ccca237",
+   "name": "«schoenflies-lean»",
+   "manifestFile": "lake-manifest.json",
+   "inputRev": "05a43d29cde026618777db3d4e4316204ccca237",
+   "inherited": false,
+   "configFile": "lakefile.toml"},
+  {"url": "https://github.com/n-yamaguchi-0729/ClassFieldTheory.git",
+   "type": "git",
+   "subDir": null,
+   "scope": "",
+   "rev": "2eb22d6485af45f29c5219de6c49f196a61c4f49",
+   "name": "ClassFieldTheory",
+   "manifestFile": "lake-manifest.json",
+   "inputRev": "2eb22d6485af45f29c5219de6c49f196a61c4f49",
+   "inherited": false,
+   "configFile": "lakefile.toml"},
+  {"url": "https://github.com/CBirkbeck/AINTLIB.git",
+   "type": "git",
+   "subDir": null,
+   "scope": "",
+   "rev": "160e446617a2168c34c95bbe7a76c4105b392434",
+   "name": "AINTLIB",
+   "manifestFile": "lake-manifest.json",
+   "inputRev": "160e446617a2168c34c95bbe7a76c4105b392434",
+   "inherited": false,
+   "configFile": "lakefile.toml"},
+  {"url": "https://github.com/BennyAvelin/AbsorptionCutoff.git",
+   "type": "git",
+   "subDir": null,
+   "scope": "",
+   "rev": "41c45c6d72e979419e46224bb7b4be5cee31f2b5",
+   "name": "AbsorptionCutoff",
+   "manifestFile": "lake-manifest.json",
+   "inputRev": "41c45c6d72e979419e46224bb7b4be5cee31f2b5",
+   "inherited": false,
+   "configFile": "lakefile.toml"},
+  {"url": "https://github.com/math-inc/strongpnt.git",
+   "type": "git",
+   "subDir": null,
+   "scope": "",
+   "rev": "2f5835c322314f55f1026ec2f139d704b7c45c69",
+   "name": "StrongPNT",
+   "manifestFile": "lake-manifest.json",
+   "inputRev": "2f5835c322314f55f1026ec2f139d704b7c45c69",
+   "inherited": false,
+   "configFile": "lakefile.toml"},
+  {"url": "https://github.com/fpvandoorn/carleson.git",
+   "type": "git",
+   "subDir": null,
+   "scope": "",
+   "rev": "306ae5b29300771aece1aa39f0a939183cc59486",
+   "name": "carleson",
+   "manifestFile": "lake-manifest.json",
+   "inputRev": "306ae5b29300771aece1aa39f0a939183cc59486",
+   "inherited": false,
+   "configFile": "lakefile.toml"},
+  {"url": "https://github.com/abenenson/rellich-kondrachov.git",
+   "type": "git",
+   "subDir": null,
+   "scope": "",
+   "rev": "70f85d4c1bf99c6e7d61e8be4daa6f3664d08d23",
+   "name": "«rellich-kondrachov»",
+   "manifestFile": "lake-manifest.json",
+   "inputRev": "70f85d4c1bf99c6e7d61e8be4daa6f3664d08d23",
+   "inherited": false,
+   "configFile": "lakefile.lean"},
+  {"url": "https://github.com/ahhwuhu/zeta_3_irrational.git",
+   "type": "git",
+   "subDir": null,
+   "scope": "",
+   "rev": "e8785315a01c8fbcddaa0fc03b3c8b29a61bc1f1",
+   "name": "Zeta3Irrational",
+   "manifestFile": "lake-manifest.json",
+   "inputRev": "e8785315a01c8fbcddaa0fc03b3c8b29a61bc1f1",
+   "inherited": false,
+   "configFile": "lakefile.lean"},
+  {"url": "https://github.com/harfe/fixed-point-theorems-lean4.git",
+   "type": "git",
+   "subDir": null,
+   "scope": "",
+   "rev": "770940ddf9878cf61952ed53d910b92bca841838",
+   "name": "«fixed-point-theorems»",
+   "manifestFile": "lake-manifest.json",
+   "inputRev": "770940ddf9878cf61952ed53d910b92bca841838",
+   "inherited": false,
+   "configFile": "lakefile.toml"},
+  {"url": "https://github.com/leanprover-community/plausible",
+   "type": "git",
+   "subDir": null,
+   "scope": "leanprover-community",
+   "rev": "118aa17ee84656b8bd727fef7c458ee8c833385c",
+   "name": "plausible",
+   "manifestFile": "lake-manifest.json",
+   "inputRev": "main",
+   "inherited": true,
+   "configFile": "lakefile.toml"},
+  {"url": "https://github.com/leanprover-community/LeanSearchClient",
+   "type": "git",
+   "subDir": null,
+   "scope": "leanprover-community",
+   "rev": "ddf04cf3949fa556442341e87d47f9f6e6074707",
+   "name": "LeanSearchClient",
+   "manifestFile": "lake-manifest.json",
+   "inputRev": "main",
+   "inherited": true,
+   "configFile": "lakefile.toml"},
+  {"url": "https://github.com/leanprover-community/import-graph",
+   "type": "git",
+   "subDir": null,
+   "scope": "leanprover-community",
+   "rev": "e928b72544873815af278d38681b31c0293588e3",
+   "name": "importGraph",
+   "manifestFile": "lake-manifest.json",
+   "inputRev": "main",
+   "inherited": true,
+   "configFile": "lakefile.toml"},
+  {"url": "https://github.com/leanprover-community/ProofWidgets4",
+   "type": "git",
+   "subDir": null,
+   "scope": "leanprover-community",
+   "rev": "106ff4fafc74ef4ac99d81dbf3ab399118f497a5",
+   "name": "proofwidgets",
+   "manifestFile": "lake-manifest.json",
+   "inputRev": "main",
+   "inherited": true,
+   "configFile": "lakefile.lean"},
+  {"url": "https://github.com/leanprover-community/aesop",
+   "type": "git",
+   "subDir": null,
+   "scope": "leanprover-community",
+   "rev": "355695d523e41d0554926416cba2a2b3544fbbc9",
+   "name": "aesop",
+   "manifestFile": "lake-manifest.json",
+   "inputRev": "master",
+   "inherited": true,
+   "configFile": "lakefile.toml"},
+  {"url": "https://github.com/leanprover-community/quote4",
+   "type": "git",
+   "subDir": null,
+   "scope": "leanprover-community",
+   "rev": "6a489d9af5d0c47e5b259e2e8bcdfc1811b5a259",
+   "name": "Qq",
+   "manifestFile": "lake-manifest.json",
+   "inputRev": "master",
+   "inherited": true,
+   "configFile": "lakefile.toml"},
+  {"url": "https://github.com/leanprover-community/batteries",
+   "type": "git",
+   "subDir": null,
+   "scope": "leanprover-community",
+   "rev": "f2effa3d803fda822b1f97b806c47cf2adfbcbc2",
+   "name": "batteries",
+   "manifestFile": "lake-manifest.json",
+   "inputRev": "main",
+   "inherited": true,
+   "configFile": "lakefile.toml"},
+  {"url": "https://github.com/leanprover/leansqlite",
+   "type": "git",
+   "subDir": null,
+   "scope": "",
+   "rev": "f9cdb9eacb5c8b8ecc02ee9fd9e568d7d28c1416",
+   "name": "leansqlite",
+   "manifestFile": "lake-manifest.json",
+   "inputRev": "main",
+   "inherited": true,
+   "configFile": "lakefile.lean"},
+  {"url": "https://github.com/leanprover/lean4-cli",
+   "type": "git",
+   "subDir": null,
+   "scope": "leanprover",
+   "rev": "e92c9f15fdfacc8536f31cfb3b7ad26c3c8cd204",
+   "name": "Cli",
+   "manifestFile": "lake-manifest.json",
+   "inputRev": "v4.34.0",
+   "inherited": true,
+   "configFile": "lakefile.toml"},
+  {"url": "https://github.com/fgdorais/lean4-unicode-basic",
+   "type": "git",
+   "subDir": null,
+   "scope": "",
+   "rev": "0e569d08b6443ce0908d356884c765397253e2f0",
+   "name": "UnicodeBasic",
+   "manifestFile": "lake-manifest.json",
+   "inputRev": "main",
+   "inherited": true,
+   "configFile": "lakefile.lean"},
+  {"url": "https://github.com/dupuisf/BibtexQuery",
+   "type": "git",
+   "subDir": null,
+   "scope": "",
+   "rev": "4d8616fd4870d0a3453d845770833eac7951fe1c",
+   "name": "BibtexQuery",
+   "manifestFile": "lake-manifest.json",
+   "inputRev": "master",
+   "inherited": true,
+   "configFile": "lakefile.toml"},
+  {"url": "https://github.com/acmepjz/md4lean",
+   "type": "git",
+   "subDir": null,
+   "scope": "",
+   "rev": "31907cc18f48a95384f99cee5582c00fb39e0f67",
+   "name": "MD4Lean",
+   "manifestFile": "lake-manifest.json",
+   "inputRev": "main",
+   "inherited": true,
+   "configFile": "lakefile.lean"}],
+ "name": "OAI",
+ "lakeDir": ".lake",
+ "fixedToolchain": true}
diff --git a/lean/lakefile.lean b/lean/lakefile.lean
new file mode 100644
index 0000000000000000000000000000000000000000..66c3867331c7c607ffc0e60955cc86cccf046e12
--- /dev/null
+++ b/lean/lakefile.lean
@@ -0,0 +1,335 @@
+import Lake
+
+open System Lake DSL
+
+package OAI where
+  version := v!"0.1.0"
+  fixedToolchain := true
+  leanOptions := #[⟨`autoImplicit, false⟩]
+
+require «fixed-point-theorems» from git
+  "https://github.com/harfe/fixed-point-theorems-lean4.git" @ "770940ddf9878cf61952ed53d910b92bca841838"
+require Zeta3Irrational from git
+  "https://github.com/ahhwuhu/zeta_3_irrational.git" @ "e8785315a01c8fbcddaa0fc03b3c8b29a61bc1f1"
+require «rellich-kondrachov» from git
+  "https://github.com/abenenson/rellich-kondrachov.git" @ "70f85d4c1bf99c6e7d61e8be4daa6f3664d08d23"
+require carleson from git
+  "https://github.com/fpvandoorn/carleson.git" @ "306ae5b29300771aece1aa39f0a939183cc59486"
+require StrongPNT from git
+  "https://github.com/math-inc/strongpnt.git" @ "2f5835c322314f55f1026ec2f139d704b7c45c69"
+require AbsorptionCutoff from git
+  "https://github.com/BennyAvelin/AbsorptionCutoff.git" @ "41c45c6d72e979419e46224bb7b4be5cee31f2b5"
+require AINTLIB from git
+  "https://github.com/CBirkbeck/AINTLIB.git" @ "160e446617a2168c34c95bbe7a76c4105b392434"
+require ClassFieldTheory from git
+  "https://github.com/n-yamaguchi-0729/ClassFieldTheory.git" @ "2eb22d6485af45f29c5219de6c49f196a61c4f49"
+require «schoenflies-lean» from git
+  "https://github.com/alonamaloh/schoenflies-lean" @ "05a43d29cde026618777db3d4e4316204ccca237"
+
+require SphereEversion from git
+  "https://github.com/leanprover-community/sphere-eversion.git" @ "9c53f91e2a281199163ecea04dc4976cb79e2076"
+
+require TauCeti from git
+  "https://github.com/TauCetiProject/TauCeti.git" @ "3bed7e37f3c504a99e8c07e9f309540812a7aa90"
+
+require gromov from git
+  "https://github.com/Aaron1011/gromov.git" @ "8db79f13cf211b570e3116301d91379fbc01cf3e"
+
+require «iut» from git
+  "https://github.com/lana-agents/iut.git" @ "d9465c111ec4073709f67e9fccec7e3eb374a816"
+
+require «tate-curves-theta» from git
+  "https://github.com/lana-agents/tate-curves-theta.git" @ "ca6c2279d3cea0690cdb01328e727118d5485d68"
+
+require «genl» from git
+  "https://github.com/lana-agents/genl.git" @ "ea2846c877d1e16d8f0b911a5fed07f5ee69eaaf"
+
+require «heights» from git
+  "https://github.com/lana-agents/heights.git" @ "721496ca4c158e511d25d8ccf6bfe8503eda73c1"
+
+require «pi1» from git
+  "https://github.com/lana-agents/pi1.git" @ "ca7def953193f861a462aa0831eec8f0a31ff69f"
+
+require «orbicurve-cores» from git
+  "https://github.com/lana-agents/orbicurve-cores.git" @ "61616dcd77fbe45c083a8ebfa7cc80728f86e841"
+
+require «oka» from git
+  "https://github.com/lana-agents/oka.git" @ "75dcdc3faadd10b986afb9283e89902bcdddecd4"
+
+require «tempered-fundamental-groups» from git
+  "https://github.com/lana-agents/tempered-fundamental-groups.git" @ "2006651f52b70ea2fe3388238c7d9db14d21748f"
+
+require «elliptic-curves» from git
+  "https://github.com/lana-agents/elliptic-curves.git" @ "bebec3fc9f2602e81c83e5236789572a541c85fb"
+
+require «formal-schemes» from git
+  "https://github.com/lana-agents/formal-schemes.git" @ "51aa935079537bf4dc580751a6e70727fb23ca93"
+
+require «belyi» from git
+  "https://github.com/lana-agents/belyi.git" @ "9ce4d3f793d3bc831f2fc7214b7dbad90ea012d8"
+
+-- Declare shared dependencies last: Lake resolves later requirements first.
+-- These pins override the older versions in the upstream packages' manifests.
+require PrimeNumberTheoremAnd from git
+  "https://github.com/AlexKontorovich/PrimeNumberTheoremAnd.git" @ "c39a751132c88b6e8080b74c74023fd95b3d8be0"
+require leancert from git
+  "https://github.com/alerad/leancert.git" @ "7f91b6eb3567437f6cfac03ed279706603ee22f4"
+require LeanArchitect from git
+  "https://github.com/hanwenzhu/LeanArchitect.git" @ "468e8f58fb4ad6e6ad672a08da6d0d0531e95a97"
+require PrimeCert from git
+  "https://github.com/b-mehta/PrimeCert.git" @ "0803c2f6bd289c09704c7d352bb8fcf770cbb9b2"
+require «doc-gen4» from git
+  "https://github.com/leanprover/doc-gen4.git" @ "953c8992d174b4e56955e01e101d46668c68f2bb"
+require checkdecls from git
+  "https://github.com/PatrickMassot/checkdecls.git" @ "3d425859e73fcfbef85b9638c2a91708ef4a22d4"
+require mathlib from git
+  "https://github.com/leanprover-community/mathlib4.git" @ "d13f23b723b8a846827a245b89c10fc7d3f11612"
+
+@[default_target] lean_lib OAI
+
+lean_lib OAI.Analysis where
+  roots := #[`OAI.Analysis]
+  globs := #[`OAI.Analysis.+]
+lean_lib OAI.Algebra where
+  roots := #[`OAI.Algebra]
+  globs := #[`OAI.Algebra.+]
+lean_lib OAI.AlgebraicGeometry where
+  roots := #[`OAI.AlgebraicGeometry]
+  globs := #[`OAI.AlgebraicGeometry.+]
+lean_lib OAI.AlgebraicTopology where
+  roots := #[`OAI.AlgebraicTopology]
+  globs := #[`OAI.AlgebraicTopology.+]
+lean_lib OAI.Geometry where
+  roots := #[`OAI.Geometry]
+  globs := #[`OAI.Geometry.+]
+lean_lib OAI.Probability where
+  roots := #[`OAI.Probability]
+  globs := #[`OAI.Probability.+]
+lean_lib OAI.Combinatorics where
+  roots := #[`OAI.Combinatorics]
+  globs := #[`OAI.Combinatorics.+]
+lean_lib ComparatorChallenges where globs := #[`ComparatorChallenges.+]
+lean_lib OAI.InformationTheory where
+  roots := #[`OAI.InformationTheory]
+  globs := #[`OAI.InformationTheory.+]
+lean_lib OAI.ModelTheory where
+  roots := #[`OAI.ModelTheory]
+  globs := #[`OAI.ModelTheory.+]
+lean_lib OAI.RepresentationTheory where
+  roots := #[`OAI.RepresentationTheory]
+  globs := #[`OAI.RepresentationTheory.+]
+lean_lib OAI.NumberTheory where
+  roots := #[`OAI.NumberTheory]
+  globs := #[`OAI.NumberTheory.+]
+lean_lib OAI.MeasureTheory where
+  roots := #[`OAI.MeasureTheory]
+  globs := #[`OAI.MeasureTheory.+]
+lean_lib OAI.GroupTheory where
+  roots := #[`OAI.GroupTheory]
+  globs := #[`OAI.GroupTheory.+]
+lean_lib OAI.LinearAlgebra where
+  roots := #[`OAI.LinearAlgebra]
+  globs := #[`OAI.LinearAlgebra.+]
+lean_lib OAI.RingTheory where
+  roots := #[`OAI.RingTheory]
+  globs := #[`OAI.RingTheory.+]
+lean_lib OAI.Computability where
+  roots := #[`OAI.Computability]
+  globs := #[`OAI.Computability.+]
+lean_lib OAI.Dynamics where
+  roots := #[`OAI.Dynamics]
+  globs := #[`OAI.Dynamics.+]
+lean_lib OAI.CategoryTheory where
+  roots := #[`OAI.CategoryTheory]
+  globs := #[`OAI.CategoryTheory.+]
+lean_lib OAI.MathematicalPhysics where
+  roots := #[`OAI.MathematicalPhysics]
+  globs := #[`OAI.MathematicalPhysics.+]
+lean_lib OAI.Topology where
+  roots := #[`OAI.Topology]
+  globs := #[`OAI.Topology.+]
+lean_lib OAI.Optimization where
+  roots := #[`OAI.Optimization]
+  globs := #[`OAI.Optimization.+]
+lean_lib OAI.GameTheory where
+  roots := #[`OAI.GameTheory]
+  globs := #[`OAI.GameTheory.+]
+lean_lib OAI.SetTheory where
+  roots := #[`OAI.SetTheory]
+  globs := #[`OAI.SetTheory.+]
+
+private def preResolutionPatchNames : Array Lean.Name := #[
+  `iut, `«tate-curves-theta», `genl, `heights, `pi1, `«orbicurve-cores», `oka,
+  `«tempered-fundamental-groups», `«elliptic-curves», `«formal-schemes», `belyi
+]
+
+private def patchGit (directory : FilePath) (args : Array String) : IO IO.Process.Output :=
+  IO.Process.output { cmd := "git", args := #["-C", directory.toString] ++ args }
+
+private def checkPatch (directory patch : FilePath) (args : Array String := #[]) :
+    IO IO.Process.Output :=
+  patchGit directory (#["apply", "--check"] ++ args ++ #[patch.toString])
+
+private inductive PatchState where
+  | absent
+  | applied
+  | needsApply
+
+private structure PatchPlan where
+  label : String
+  directory : FilePath
+  patch : FilePath
+  url : String
+  revision : String
+  state : PatchState
+
+private def planDependencyPatch (root : FilePath) (dependency : Dependency) : IO PatchPlan := do
+  let label := dependency.dirName
+  let some (.git url (some revision) none) := dependency.src?
+    | throw <| IO.userError s!"{label}: compatibility patches require a Git dependency pinned to a commit."
+  unless revision.length == 40 && revision.toList.all (fun c =>
+      c.isDigit || ('a' <= c && c <= 'f')) do
+    throw <| IO.userError s!"{label}: expected a full lowercase Git commit, got {revision}."
+  let patch := root / "patches" / s!"{label}-lean4341.patch"
+  unless ← patch.pathExists do
+    throw <| IO.userError s!"Missing compatibility patch: {patch}"
+  let directory := root / ".lake" / "packages" / label
+  let plan := { label, directory, patch, url, revision, state := .absent : PatchPlan }
+  unless ← directory.pathExists do
+    return plan
+  let head ← patchGit directory #["rev-parse", "HEAD"]
+  unless head.exitCode == 0 && head.stdout.trimAscii.toString == revision do
+    throw <| IO.userError s!"{label}: expected commit {revision}, got {head.stdout}\n{head.stderr}"
+  let origin ← patchGit directory #["remote", "get-url", "origin"]
+  unless origin.exitCode == 0 && origin.stdout.trimAscii.toString == url do
+    throw <| IO.userError s!"{label}: expected origin {url}, got {origin.stdout}\n{origin.stderr}"
+  let reverse ← checkPatch directory patch #["--reverse"]
+  if reverse.exitCode == 0 then
+    return {plan with state := .applied}
+  let forward ← checkPatch directory patch
+  if forward.exitCode == 0 then
+    return {plan with state := .needsApply}
+  throw <| IO.userError s!"{label}: compatibility patch conflicts with local changes.\n\
+    Forward check:\n{forward.stderr}\nReverse check:\n{reverse.stderr}"
+
+private def applyDependencyPatch (plan : PatchPlan) (directory : FilePath) : IO Unit := do
+  let applied ← patchGit directory #["apply", plan.patch.toString]
+  unless applied.exitCode == 0 do
+    throw <| IO.userError s!"{plan.label}: failed to apply compatibility patch:\n{applied.stderr}"
+  let verified ← checkPatch directory plan.patch #["--reverse"]
+  unless verified.exitCode == 0 do
+    throw <| IO.userError s!"{plan.label}: patch verification failed:\n{verified.stderr}"
+
+/-- Prepare patched package configurations before Lake resolves their dependencies. -/
+private def preparePatchedDependencies (root : FilePath) (dependencies : Array Dependency) :
+    IO (Array String) := do
+  -- Check all existing checkouts before changing any of them.
+  let plans ← dependencies.mapM (planDependencyPatch root)
+  let mut changed := #[]
+  for plan in plans do
+    match plan.state with
+    | .applied => pure ()
+    | .needsApply =>
+      applyDependencyPatch plan plan.directory
+      changed := changed.push plan.label
+    | .absent =>
+      let packages := root / ".lake" / "packages"
+      IO.FS.createDirAll packages
+      let pid ← IO.Process.getPID
+      let stamp ← IO.monoNanosNow
+      let staging := packages / s!".{plan.label}-bootstrap-{pid}-{stamp}"
+      IO.FS.createDir staging
+      try
+        let cloned ← IO.Process.output {
+          cmd := "git", args := #["clone", "--no-checkout", plan.url, staging.toString]
+        }
+        unless cloned.exitCode == 0 do
+          throw <| IO.userError s!"{plan.label}: clone failed:\n{cloned.stderr}"
+        let checkedOut ← patchGit staging #["checkout", "--detach", plan.revision]
+        unless checkedOut.exitCode == 0 do
+          throw <| IO.userError s!"{plan.label}: checkout failed:\n{checkedOut.stderr}"
+        let head ← patchGit staging #["rev-parse", "HEAD"]
+        unless head.exitCode == 0 && head.stdout.trimAscii.toString == plan.revision do
+          throw <| IO.userError s!"{plan.label}: cloned checkout has the wrong commit."
+        applyDependencyPatch plan staging
+        IO.FS.rename staging plan.directory
+        changed := changed.push plan.label
+      finally
+        if ← staging.pathExists then
+          IO.FS.removeDirAll staging
+  return changed
+
+-- Configuration elaboration precedes dependency resolution, unlike `post_update`.
+run_cmd do
+  let env ← Lean.getEnv
+  if let some root := Lake.dirExt.getState env then
+    let options ← Lean.getOptions
+    let changed ← Lean.Elab.Command.liftIO do
+      let declarations ← IO.ofExcept <| Lake.packageDepAttr.getAllEntries env |>.mapM fun name =>
+        unsafe env.evalConstCheck Dependency options ``Dependency name
+      let mut dependencies := #[]
+      for name in preResolutionPatchNames do
+        let some dependency := declarations.find? (·.name == name)
+          | throw <| IO.userError s!"Missing direct dependency declaration for {name}."
+        dependencies := dependencies.push dependency
+      preparePatchedDependencies root dependencies
+    for label in changed do
+      Lean.logInfo s!"{label}: applied compatibility patch before dependency resolution"
+
+post_update pkg do
+  for name in preResolutionPatchNames do
+    let label := name.toString (escape := false)
+    let some dependency ← findPackageByName? name
+      | error s!"Missing dependency {label} after Lake update."
+    let some declaration := pkg.depConfigs.find? (·.name == name)
+      | error s!"Missing direct dependency declaration for {label}."
+    let plan ← planDependencyPatch pkg.dir declaration
+    unless plan.directory == dependency.dir do
+      error s!"{label}: Lake resolved an unexpected checkout at {dependency.dir}."
+    match plan.state with
+    | .applied => logInfo s!"{label}: compatibility patch verified after dependency resolution"
+    | _ => error s!"{label}: compatibility patch was lost during dependency resolution."
+
+  -- Preflight every dependency before changing any of them.
+  let mut plans := #[]
+  for name in #[`«fixed-point-theorems», `PrimeNumberTheoremAnd, `Zeta3Irrational,
+      `«rellich-kondrachov», `carleson, `StrongPNT, `AbsorptionCutoff, `AINTLIB,
+      `ClassFieldTheory, `«schoenflies-lean», `SphereEversion, `gromov] do
+    let label := name.toString (escape := false)
+    let some dep ← findPackageByName? name
+      | error s!"Missing dependency {label}; run lake update from the project root."
+    let some declaration := pkg.depConfigs.find? (·.name == name)
+      | error s!"Missing direct dependency declaration for {label}."
+    let some (.git _ (some revision) _) := declaration.src?
+      | error s!"{label} must be pinned to a Git commit."
+    let patchDirectory := dep.dir
+    let head ← patchGit patchDirectory #["rev-parse", "HEAD"]
+    unless head.exitCode == 0 && head.stdout.trimAscii.toString == revision do
+      error s!"{label}: expected commit {revision}, got {head.stdout}\n{head.stderr}"
+    let patchNames := #[s!"{label}-lean4341.patch"]
+    for patchName in patchNames do
+      let patch := pkg.dir / "patches" / FilePath.mk patchName
+      unless ← patch.pathExists do
+        error s!"Missing compatibility patch: {patch}"
+      let reverse ← checkPatch patchDirectory patch #["--reverse"]
+      if reverse.exitCode == 0 then
+        plans := plans.push (label, patchDirectory, patch, none)
+        continue
+      let forward ← checkPatch patchDirectory patch
+      if forward.exitCode == 0 then
+        plans := plans.push (label, patchDirectory, patch, some patch)
+        continue
+      error s!"{label}: compatibility patch {patch} conflicts with local changes.\n\
+        Forward check:\n{forward.stderr}\nReverse check:\n{reverse.stderr}"
+  for (label, directory, patch, action) in plans do
+    let patchName := patch.fileName.getD patch.toString
+    if let some toApply := action then
+      let result ← patchGit directory #["apply", toApply.toString]
+      unless result.exitCode == 0 do
+        error s!"{label}: failed to apply {toApply}:\n{result.stderr}"
+      let verified ← checkPatch directory patch #["--reverse"]
+      unless verified.exitCode == 0 do
+        error s!"{label}: patch verification failed:\n{verified.stderr}"
+      logInfo s!"{label}: applied compatibility patch {patchName}"
+    else
+      logInfo s!"{label}: compatibility patch already applied: {patchName}"
diff --git a/lean/lean-toolchain b/lean/lean-toolchain
new file mode 100644
index 0000000000000000000000000000000000000000..ba8ebf2dbaf6a668cd2a0e086186d6d569b69ff5
--- /dev/null
+++ b/lean/lean-toolchain
@@ -0,0 +1 @@
+leanprover/lean4:v4.34.1