diff --git a/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryFirstDerivedRetraction.lean b/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryFirstDerivedRetraction.lean
new file mode 100644
index 0000000000000000000000000000000000000000..9917b2e1c67a586215de8247005b2c506693da5d
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryFirstDerivedRetraction.lean
@@ -0,0 +1,66 @@
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryFirstDerivedCompatibility
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryFirstComponentExact
+
+namespace OAI
+noncomputable section
+open CategoryTheory CategoryTheory.Limits
+namespace LittleFinitistic.BlockModule
+universe u
+variable (L R : Type u) [Ring L] [Ring R]
+variable [HasDerivedCategory.{u+1} (ModuleCat.{u} L)]
+variable [HasDerivedCategory.{u+1} (ModuleCat.{u} (L × R))]
+
+/-- The exact derived first-component functor on the whole product-ring derived category. -/
+abbrev derivedFirstComponent := (ProductModules.firstFunctor.{u,u} L R).mapDerivedCategory
+
+def firstComplexComponentIso : firstComplexFunctor L R ⋙
+    (ProductModules.firstFunctor L R).mapHomologicalComplex (.up ℤ) ≅
+      𝟭 (CochainComplex (ModuleCat.{u} L) ℤ) :=
+  Functor.mapHomologicalComplexCompIso (ProductModules.firstInflationComponentIso L R) (.up ℤ) ≪≫
+    Functor.mapHomologicalComplexIdIso (ModuleCat.{u} L) (.up ℤ)
+
+/-- On chain representatives, the composite is the identity localization. -/
+def derivedFirstComponentFactors : DerivedCategory.Q ⋙ derivedFirst L R ⋙
+    derivedFirstComponent L R ≅ (DerivedCategory.Q : CochainComplex (ModuleCat.{u} L) ℤ ⥤ _) :=
+  (Functor.associator ..).symm ≪≫
+    Functor.isoWhiskerRight (derivedFirstComparison L R) _ ≪≫
+    Functor.associator .. ≪≫
+    Functor.isoWhiskerLeft _ (ProductModules.firstFunctor L R).mapDerivedCategoryFactors ≪≫
+    (Functor.associator ..).symm ≪≫
+    Functor.isoWhiskerRight (firstComplexComponentIso L R) _ ≪≫ Functor.leftUnitor _
+
+/-- Taking the first component recovers every derived object, naturally. -/
+def derivedFirstRetraction : derivedFirst L R ⋙ derivedFirstComponent L R ≅
+    𝟭 (DerivedCategory (ModuleCat.{u} L)) := by
+  letI : Localization.Lifting DerivedCategory.Q
+      (HomologicalComplex.quasiIso (ModuleCat.{u} L) (.up ℤ)) DerivedCategory.Q
+      (derivedFirst L R ⋙ derivedFirstComponent L R) := ⟨derivedFirstComponentFactors L R⟩
+  exact Localization.liftNatIso DerivedCategory.Q
+    (HomologicalComplex.quasiIso (ModuleCat.{u} L) (.up ℤ))
+    DerivedCategory.Q DerivedCategory.Q _ _ (Iso.refl _)
+
+/-- The same retraction for mathlib's exact derived inflation. -/
+def exactFirstRetraction : (ProductModules.firstInflation L R).mapDerivedCategory ⋙
+    derivedFirstComponent L R ≅ 𝟭 (DerivedCategory (ModuleCat.{u} L)) :=
+  Functor.isoWhiskerRight (derivedFirstIso L R).symm _ ≪≫ derivedFirstRetraction L R
+
+instance derivedFirst_additive : (derivedFirst L R).Additive :=
+  Functor.additive_of_iso (derivedFirstIso L R).symm
+
+/-- No derived object becomes zero merely by putting it in the first block. -/
+theorem derivedFirst_isZero_iff (Y : DerivedCategory (ModuleCat.{u} L)) :
+    IsZero ((derivedFirst L R).obj Y) ↔ IsZero Y := by
+  constructor
+  · intro h
+    exact ((derivedFirstRetraction L R).app Y).isZero_iff.mp
+      ((derivedFirstComponent L R).map_isZero h)
+  · exact (derivedFirst L R).map_isZero
+
+theorem exactFirst_isZero_iff (Y : DerivedCategory (ModuleCat.{u} L)) :
+    IsZero ((ProductModules.firstInflation L R).mapDerivedCategory.obj Y) ↔ IsZero Y :=
+  ((derivedFirstIso L R).app Y).isZero_iff.symm.trans (derivedFirst_isZero_iff L R Y)
+end LittleFinitistic.BlockModule
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryFixedTensorFunctor.lean b/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryFixedTensorFunctor.lean
new file mode 100644
index 0000000000000000000000000000000000000000..517db7837d075923e0059e5402cf0b8e831d7e87
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryFixedTensorFunctor.lean
@@ -0,0 +1,86 @@
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryTensorExactness
+import Mathlib.Algebra.Category.ModuleCat.ChangeOfRings
+import Mathlib.Algebra.Homology.ShortComplex.ModuleCat
+import Mathlib.CategoryTheory.Abelian.Exact
+import Mathlib.Algebra.Homology.QuasiIso
+
+namespace OAI
+noncomputable section
+open CategoryTheory
+namespace LittleFinitistic.BalancedTensor
+universe u
+variable (k A : Type u) [Field k] [Ring A] [Algebra k A]
+
+abbrev ScalarLeftModule (N : ModuleCat.{u} A) :=
+  (ModuleCat.restrictScalars (algebraMap k A)).obj N
+
+instance scalarLeftTower (N : ModuleCat.{u} A) : IsScalarTower k A (ScalarLeftModule k A N) where
+  smul_assoc r a n := by
+    change (r • a) • (n : N) = algebraMap k A r • (a • (n : N))
+    rw [Algebra.smul_def,mul_smul]
+
+variable (M : Type u) [AddCommGroup M] [Module k M] [Module Aᵐᵒᵖ M]
+
+/-- Tensor by a fixed actual right module on every left module. -/
+def fixedTensorFunctor : ModuleCat.{u} A ⥤ ModuleCat.{u} k where
+  obj N := ModuleCat.of k (Tensor k A M (ScalarLeftModule k A N))
+  map {N N'} f := ModuleCat.ofHom
+    (mapRightTo (k := k) (M := M) (N := ScalarLeftModule k A N) (N' := ScalarLeftModule k A N') f.hom)
+  map_id N := by
+    apply ModuleCat.hom_ext
+    apply BalancedTensor.ext
+    intro m n
+    rfl
+  map_comp f g := by
+    apply ModuleCat.hom_ext
+    apply BalancedTensor.ext
+    intro m n
+    rfl
+
+instance fixedTensorFunctor_additive : (fixedTensorFunctor k A M).Additive where
+  map_add {N N'} {f g} := by
+    apply ModuleCat.hom_ext
+    apply BalancedTensor.ext
+    intro m n
+    exact (mk k A M (ScalarLeftModule k A N') m).map_add (f.hom n) (g.hom n)
+
+variable (e : A) (he : e*e=e)
+
+include he in
+theorem idempotentTensor_mapsExact (S : ShortComplex (ModuleCat.{u} A)) (hS : S.Exact) :
+    (S.map (fixedTensorFunctor k A (IdempotentTensor.rightIdeal e))).Exact := by
+  rw [ShortComplex.moduleCat_exact_iff]
+  have h : Function.Exact
+      (S.f.hom : ScalarLeftModule k A S.X₁ →ₗ[A] ScalarLeftModule k A S.X₂)
+      (S.g.hom : ScalarLeftModule k A S.X₂ →ₗ[A] ScalarLeftModule k A S.X₃) := by
+    intro n
+    constructor
+    · exact (ShortComplex.moduleCat_exact_iff S).mp hS n
+    · rintro ⟨m,rfl⟩
+      exact congrArg (fun f => f.hom m) S.zero
+  have ht := @IdempotentTensor.tensor_exact k A
+    (ScalarLeftModule k A S.X₁) (ScalarLeftModule k A S.X₂) (ScalarLeftModule k A S.X₃)
+    _ _ _ _ _ _ (scalarLeftTower k A S.X₁)
+    _ _ _ (scalarLeftTower k A S.X₂) _ _ _ (scalarLeftTower k A S.X₃)
+    e he S.f.hom S.g.hom h
+  intro z hz
+  exact (ht z).mp hz
+
+include he in
+/-- Derived input complexes remain arbitrary: this functor preserves homology. -/
+theorem idempotentTensor_preservesHomology :
+    (fixedTensorFunctor k A (IdempotentTensor.rightIdeal e)).PreservesHomology :=
+  Functor.preservesHomology_of_map_exact _ (idempotentTensor_mapsExact k A e he)
+
+include he in
+/-- No boundedness, dimension, projectivity, or flatness hypothesis on either input complex. -/
+theorem idempotentTensor_quasiIso
+    {Z Z' : CochainComplex (ModuleCat.{u} A) ℤ} (f : Z ⟶ Z') [QuasiIso f] :
+    QuasiIso (((fixedTensorFunctor k A (IdempotentTensor.rightIdeal e)).mapHomologicalComplex (.up ℤ)).map f) := by
+  let := idempotentTensor_preservesHomology k A e he
+  infer_instance
+end LittleFinitistic.BalancedTensor
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryFreeTensor.lean b/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryFreeTensor.lean
new file mode 100644
index 0000000000000000000000000000000000000000..c1bbbdaefdf0e20079868acdbedcb8fd09f11cc8
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryFreeTensor.lean
@@ -0,0 +1,80 @@
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryTensorExactness
+import Mathlib.LinearAlgebra.Finsupp.LSum
+import Mathlib.Algebra.Algebra.Opposite
+
+namespace OAI
+noncomputable section
+namespace LittleFinitistic.BalancedTensor.Free
+universe u
+variable {k A : Type u} [Field k] [Ring A] [Algebra k A]
+variable (I N : Type u) [AddCommGroup N] [Module k N] [Module A N] [IsScalarTower k A N]
+
+/-- A right-regular coefficient acts on the left tensor factor by its unop. -/
+def coefficientAction : Aᵐᵒᵖ →ₗ[k] N →ₗ[k] N :=
+  (Algebra.lsmul k k N).toLinearMap.comp (MulOpposite.opLinearEquiv k).symm.toLinearMap
+
+/-- Coordinate evaluation of a free right module tensor N. -/
+def evaluateBilinear : (I →₀ Aᵐᵒᵖ) →ₗ[k] N →ₗ[k] (I →₀ N) :=
+  Finsupp.lsum k (fun i => (coefficientAction (k := k) (A := A) N).compr₂ (Finsupp.lsingle i))
+
+@[simp] theorem evaluateBilinear_single (i : I) (x : Aᵐᵒᵖ) (n : N) :
+    evaluateBilinear (k := k) I N (Finsupp.single i x) n = Finsupp.single i (x.unop • n) := by
+  simp only [evaluateBilinear,Finsupp.lsum_single]
+  rfl
+
+def evaluation : Tensor k A (I →₀ Aᵐᵒᵖ) N →ₗ[k] (I →₀ N) :=
+  lift (evaluateBilinear (k := k) I N) (by
+    intro a m n
+    induction m using Finsupp.induction_linear with
+    | zero => simp only [smul_zero,map_zero,LinearMap.zero_apply]
+    | add x y hx hy => simp only [smul_add,map_add,LinearMap.add_apply,hx,hy]
+    | single i x =>
+      rw [Finsupp.smul_single,evaluateBilinear_single,evaluateBilinear_single]
+      change Finsupp.single i ((x.unop*a) • n) = Finsupp.single i (x.unop • (a • n))
+      rw [mul_smul])
+
+@[simp] theorem evaluation_single (i : I) (x : Aᵐᵒᵖ) (n : N) :
+    evaluation (k := k) I N (mk k A (I →₀ Aᵐᵒᵖ) N (Finsupp.single i x) n) =
+      Finsupp.single i (x.unop • n) := evaluateBilinear_single I N i x n
+
+def insertion : (I →₀ N) →ₗ[k] Tensor k A (I →₀ Aᵐᵒᵖ) N :=
+  Finsupp.lsum k (fun i => mk k A (I →₀ Aᵐᵒᵖ) N (Finsupp.single i 1))
+
+omit [IsScalarTower k A N] in
+@[simp] theorem insertion_single (i : I) (n : N) :
+    insertion (k := k) (A := A) I N (Finsupp.single i n) =
+      mk k A (I →₀ Aᵐᵒᵖ) N (Finsupp.single i 1) n := by
+  simp only [insertion,Finsupp.lsum_single]
+
+theorem evaluation_insertion (z : I →₀ N) :
+    evaluation (k := k) (A := A) I N (insertion I N z) = z := by
+  induction z using Finsupp.induction_linear with
+  | zero => simp only [map_zero]
+  | add x y hx hy => simp only [map_add,hx,hy]
+  | single i n => rw [insertion_single,evaluation_single,MulOpposite.unop_one,one_smul]
+
+theorem insertion_evaluation (z : Tensor k A (I →₀ Aᵐᵒᵖ) N) :
+    insertion I N (evaluation (k := k) I N z) = z := by
+  induction z using BalancedTensor.induction_on with
+  | hz => simp only [map_zero]
+  | ht m n =>
+    induction m using Finsupp.induction_linear with
+    | zero => simp only [map_zero,LinearMap.zero_apply]
+    | add x y hx hy => simp only [map_add,LinearMap.add_apply,hx,hy]
+    | single i x =>
+      rw [evaluation_single,insertion_single,← balance]
+      congr 1
+      rw [MulOpposite.op_unop,Finsupp.smul_single,smul_eq_mul,mul_one]
+  | ha x y hx hy => simp only [map_add,hx,hy]
+
+/-- The actual free balanced tensor, for arbitrary index sets and arbitrary modules N. -/
+def equivalence : Tensor k A (I →₀ Aᵐᵒᵖ) N ≃ₗ[k] (I →₀ N) where
+  __ := evaluation (k := k) I N
+  invFun := insertion I N
+  left_inv := insertion_evaluation I N
+  right_inv := evaluation_insertion I N
+end LittleFinitistic.BalancedTensor.Free
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryFreeTensorExactness.lean b/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryFreeTensorExactness.lean
new file mode 100644
index 0000000000000000000000000000000000000000..b4427d77da83ddcf41e04f5a5e71bf348f0c6bb1
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryFreeTensorExactness.lean
@@ -0,0 +1,83 @@
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryFreeTensor
+import Mathlib.LinearAlgebra.Finsupp.Defs
+
+namespace OAI
+noncomputable section
+namespace LittleFinitistic.BalancedTensor.Free
+universe u
+variable {k A : Type u} [Field k] [Ring A] [Algebra k A]
+variable (I : Type u)
+variable {N N' N'' : Type u}
+variable [AddCommGroup N] [Module k N] [Module A N] [IsScalarTower k A N]
+variable [AddCommGroup N'] [Module k N'] [Module A N'] [IsScalarTower k A N']
+variable [AddCommGroup N''] [Module k N''] [Module A N''] [IsScalarTower k A N'']
+
+theorem evaluation_naturality (f : N →ₗ[A] N') (z : Tensor k A (I →₀ Aᵐᵒᵖ) N) :
+    evaluation (k := k) I N' (mapRightTo f z) =
+      Finsupp.mapRange.linearMap (f.restrictScalars k) (evaluation (k := k) I N z) := by
+  induction z using BalancedTensor.induction_on with
+  | hz => simp only [map_zero]
+  | ht m n =>
+    induction m using Finsupp.induction_linear with
+    | zero => simp only [map_zero,LinearMap.zero_apply]
+    | add x y hx hy => simp only [map_add,LinearMap.add_apply,hx,hy]
+    | single i x =>
+      simp only [mapRightTo_mk,evaluation_single]
+      change Finsupp.single i (MulOpposite.unop x • f n) =
+        Finsupp.mapRange f f.map_zero (Finsupp.single i (MulOpposite.unop x • n))
+      rw [Finsupp.mapRange_single, f.map_smul]
+  | ha x y hx hy => simp only [map_add,hx,hy]
+
+/-- Direct sums preserve exactness, with a preimage supported on the given finite support. -/
+theorem finsupp_exact (f : N →ₗ[A] N') (g : N' →ₗ[A] N'') (h : Function.Exact f g) :
+    Function.Exact (Finsupp.mapRange.linearMap (f.restrictScalars k) : (I →₀ N) →ₗ[k] (I →₀ N'))
+      (Finsupp.mapRange.linearMap (g.restrictScalars k)) := by
+  classical
+  intro z
+  constructor
+  · intro hz
+    have hg (i : I) : g (z i) = 0 := congrArg (fun x : I →₀ N'' => x i) hz
+    let y : I →₀ N := Finsupp.onFinset z.support
+      (fun i => if hi : z i = 0 then 0 else Classical.choose ((h (z i)).mp (hg i))) (by
+        intro i hi
+        by_contra hn
+        have hz0 : z i = 0 := by simpa only [Finsupp.mem_support_iff,not_not] using hn
+        exact hi (by simp [hz0]))
+    refine ⟨y, ?_⟩
+    ext i
+    change f (if hi : z i = 0 then 0 else Classical.choose ((h (z i)).mp (hg i))) = z i
+    split_ifs with hi
+    · rw [map_zero,hi]
+    · exact Classical.choose_spec ((h (z i)).mp (hg i))
+  · rintro ⟨y,rfl⟩
+    ext i
+    exact (h (f (y i))).mpr ⟨y i,rfl⟩
+
+/-- Tensor by an arbitrary free right module preserves every exact module sequence. -/
+theorem tensor_exact (f : N →ₗ[A] N') (g : N' →ₗ[A] N'') (h : Function.Exact f g) :
+    Function.Exact (mapRightTo (k := k) (M := I →₀ Aᵐᵒᵖ) f)
+      (mapRightTo (k := k) (M := I →₀ Aᵐᵒᵖ) g) := by
+  intro z
+  constructor
+  · intro hz
+    have hz' : Finsupp.mapRange.linearMap (g.restrictScalars k) (evaluation (k := k) I N' z) = 0 := by
+      rw [← evaluation_naturality,hz,map_zero]
+    obtain ⟨y,hy⟩ := (finsupp_exact (k := k) I f g h _).mp hz'
+    refine ⟨(equivalence (k := k) (A := A) I N).symm y, ?_⟩
+    apply (equivalence (k := k) (A := A) I N').injective
+    change evaluation (k := k) I N' (mapRightTo f ((equivalence (k := k) (A := A) I N).symm y)) = _
+    rw [evaluation_naturality]
+    change Finsupp.mapRange.linearMap (f.restrictScalars k)
+      ((equivalence (k := k) (A := A) I N) ((equivalence (k := k) (A := A) I N).symm y)) = _
+    rw [LinearEquiv.apply_symm_apply]
+    exact hy
+  · rintro ⟨y,rfl⟩
+    induction y using BalancedTensor.induction_on with
+    | hz => simp only [map_zero]
+    | ht m n => rw [mapRightTo_mk,mapRightTo_mk,(h (f n)).mpr ⟨n,rfl⟩,map_zero]
+    | ha x y hx hy => simp only [map_add,hx,hy,add_zero]
+end LittleFinitistic.BalancedTensor.Free
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryFullTensorComplex.lean b/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryFullTensorComplex.lean
new file mode 100644
index 0000000000000000000000000000000000000000..ce73fc5435c7d4cdd2754c199931996f0939868f
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryFullTensorComplex.lean
@@ -0,0 +1,89 @@
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryFullTensorTerms
+import Mathlib.Algebra.Homology.Embedding.Restriction
+
+namespace OAI
+noncomputable section
+open CategoryTheory Limits
+open scoped TensorProduct
+namespace LittleFinitistic.OrdinarySimulation.FullTensorTerm
+universe u
+variable {k B : Type u} [Field k] [Ring B] [Algebra k B]
+variable (P : CochainComplex (ModuleCat.{u} (Enveloping k B)) ℤ) (a : ℤ) (l : ℕ)
+attribute [local instance] VertexTensor.termScalar VertexTensor.termTower
+
+def differential (n : ℕ) : FullTensorTerm P a l n →ₗ[Enveloping k B] FullTensorTerm P a l (n+1) :=
+  TwoSidedTensor.map (T := Bᵐᵒᵖ) (N := BimoduleO P a l)
+    (TensorResolution.differential k B l n) (TensorResolution.differential_left k B l n)
+
+theorem differential_square (n : ℕ) : (differential P a l (n+1)).comp (differential P a l n) = 0 := by
+  apply LinearMap.restrictScalars_injective k
+  apply BalancedTensor.ext
+  intro m v
+  change BalancedTensor.mk k (B ⊗[k] ChainAlgebra k l) (TensorResolution.term k B l (n+2))
+    (BimoduleO P a l) (TensorResolution.differential k B l (n+1)
+      (TensorResolution.differential k B l n m)) v = 0
+  have h := congrArg (fun f => f m) (TensorResolution.differential_square k B l n)
+  change TensorResolution.differential k B l (n+1) (TensorResolution.differential k B l n m) = 0 at h
+  rw [h,map_zero,LinearMap.zero_apply]
+
+/-- Actual tensor complex, with both B-actions and the actual extended arrow maps. -/
+def complex : CochainComplex (ModuleCat.{u} (Enveloping k B)) ℕ :=
+  CochainComplex.of (fun n => ModuleCat.of _ (FullTensorTerm P a l n))
+    (fun n => ModuleCat.ofHom (differential P a l n))
+    (fun n => ModuleCat.hom_ext (differential_square P a l n))
+
+/-- Supported evaluation is the product action followed by the source coordinate projection. -/
+theorem supportedEquiv_mk (n : ℕ) (hn : n ≤ l) (m : TensorResolution.term k B l n) (v : BimoduleO P a l) :
+    supportedEquiv P a l n hn
+      (TwoSidedTensor.mk k (B ⊗[k] ChainAlgebra k l) B Bᵐᵒᵖ (TensorResolution.term k B l n) (BimoduleO P a l) m v) =
+        (m.val • v : BimoduleO P a l) ⟨n,by omega⟩ := rfl
+
+theorem supported_differential (n : ℕ) (hn : n+1 ≤ l) (z : FullTensorTerm P a l n) :
+    supportedEquiv P a l (n+1) hn (differential P a l n z) =
+      (P.d (a+(n:ℤ)) (a+((n+1:ℕ):ℤ))).hom (supportedEquiv P a l n (by omega) z) := by
+  have h : (supportedEquiv P a l (n+1) hn).toLinearMap.comp (differential P a l n) =
+      (P.d (a+(n:ℤ)) (a+((n+1:ℕ):ℤ))).hom.comp
+        (supportedEquiv P a l n (by omega)).toLinearMap := by
+    apply LinearMap.restrictScalars_injective k
+    apply BalancedTensor.ext
+    intro m v
+    change ((((1:B) ⊗ₜ[k] ChainAlgebra.extendedArrow k l n) * m.val) • v : BimoduleO P a l) ⟨n+1,by omega⟩ =
+      (P.d (a+(n:ℤ)) (a+((n+1:ℕ):ℤ))).hom ((m.val • v : BimoduleO P a l) ⟨n,by omega⟩)
+    have hv : (((1:B) ⊗ₜ[k] ChainAlgebra.extendedArrow k l n) * m.val) • v =
+        ChainAlgebra.arrow k l ⟨n,by omega⟩ • (m.val • v) := by
+      rw [mul_smul,BimoduleO.tensor_smul,one_smul,ChainAlgebra.extendedArrow,dite_eq_left (by omega)]
+    exact (congrArg (fun w : BimoduleO P a l => w ⟨n+1,by omega⟩) hv).trans
+      (VertexTensor.arrow_coordinate P a l ⟨n,by omega⟩ (m.val • v))
+  exact congrArg (fun f => f z) h
+
+variable (hP : ∀ n : ℕ, l < n → IsZero (P.X (a+(n:ℤ))))
+
+theorem termEquiv_differential (n : ℕ) (z : FullTensorTerm P a l n) :
+    termEquiv P a l hP (n+1) (differential P a l n z) =
+      (P.d (a+(n:ℤ)) (a+((n+1:ℕ):ℤ))).hom (termEquiv P a l hP n z) := by
+  by_cases hn : n+1 ≤ l
+  · simp only [termEquiv,dite_eq_left hn,dite_eq_left (show n ≤ l by omega)]
+    exact supported_differential P a l n hn z
+  · let : Subsingleton (P.X (a+((n+1:ℕ):ℤ))) :=
+      ModuleCat.isZero_iff_subsingleton.mp (hP (n+1) (by omega))
+    exact Subsingleton.elim _ _
+
+/-- The entire actual tensor complex identifies with P on degrees a,a+1,... . -/
+def complexIso : complex P a l ≅ P.restriction (ComplexShape.embeddingUpIntGE a) :=
+  HomologicalComplex.Hom.isoOfComponents (fun n => (termEquiv P a l hP n).toModuleIso) (by
+    intro n m hnm
+    change n+1=m at hnm
+    subst m
+    change (termEquiv P a l hP n).toModuleIso.hom ≫ P.d (a+(n:ℤ)) (a+((n+1:ℕ):ℤ)) =
+      CochainComplex.of.d (fun j => ModuleCat.of (Enveloping k B) (FullTensorTerm P a l j))
+        (fun j => ModuleCat.ofHom (differential P a l j)) n (n+1) ≫ (termEquiv P a l hP (n+1)).toModuleIso.hom
+    rw [CochainComplex.of_d]
+    apply ModuleCat.hom_ext
+    apply LinearMap.ext
+    intro z
+    exact (termEquiv_differential P a l hP n z).symm)
+end LittleFinitistic.OrdinarySimulation.FullTensorTerm
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryFullTensorTerms.lean b/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryFullTensorTerms.lean
new file mode 100644
index 0000000000000000000000000000000000000000..b4c251a3622f5a099b46c62a925c58a495ced211
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryFullTensorTerms.lean
@@ -0,0 +1,86 @@
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryTwoSidedTensor
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryTensorDifferential
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryIntegerResolution
+
+namespace OAI
+noncomputable section
+open CategoryTheory Limits
+open scoped TensorProduct
+namespace LittleFinitistic.OrdinarySimulation
+universe u
+variable {k B : Type u} [Field k] [Ring B] [Algebra k B]
+variable (P : CochainComplex (ModuleCat.{u} (Enveloping k B)) ℤ) (a : ℤ) (l : ℕ)
+
+instance BimoduleO.commuteRightTensor : SMulCommClass Bᵐᵒᵖ (B ⊗[k] ChainAlgebra k l) (BimoduleO P a l) :=
+  ⟨fun r x v => (smul_comm x r v).symm⟩
+
+/-- Every degree of Q_T tensor_BC O, carrying the actual outside B-actions. -/
+abbrev FullTensorTerm (n : ℕ) := TwoSidedTensor k (B ⊗[k] ChainAlgebra k l) B Bᵐᵒᵖ
+  (TensorResolution.term k B l n) (BimoduleO P a l)
+
+namespace FullTensorTerm
+open ChainAlgebra
+
+/-- Supported extended ideals are the same right ideals as the finite vertex terms. -/
+def supportedIdealEquiv (n : ℕ) (hn : n ≤ l) :
+    TensorResolution.term k B l n ≃ₗ[(B ⊗[k] ChainAlgebra k l)ᵐᵒᵖ]
+      IdempotentTensor.rightIdeal (TensorIdeal.vertex (k := k) (B := B) (vertex k l ⟨n,by omega⟩)) where
+  toFun x := ⟨x.val, by
+    have hx := x.property
+    change TensorIdeal.vertex (k := k) (B := B) (extendedVertex k l n) * x.val = x.val at hx
+    rw [extendedVertex,dite_eq_left hn] at hx
+    exact hx⟩
+  invFun x := ⟨x.val, by
+    change TensorIdeal.vertex (k := k) (B := B) (extendedVertex k l n) * x.val = x.val
+    rw [extendedVertex,dite_eq_left hn]
+    exact x.property⟩
+  left_inv _ := rfl
+  right_inv _ := rfl
+  map_add' _ _ := rfl
+  map_smul' _ _ := rfl
+
+def finiteModel (i : Fin (l+1)) :
+    TwoSidedTensor k (B ⊗[k] ChainAlgebra k l) B Bᵐᵒᵖ
+      (IdempotentTensor.rightIdeal (TensorIdeal.vertex (k := k) (B := B) (vertex k l i)))
+      (BimoduleO P a l) ≃ₗ[Enveloping k B] VertexTensor P a l i where
+  toFun z := z
+  invFun z := z
+  left_inv _ := rfl
+  right_inv _ := rfl
+  map_add' _ _ := rfl
+  map_smul' _ _ := rfl
+
+/-- Actual degreewise B-bimodule comparison throughout the supported range. -/
+def supportedEquiv (n : ℕ) (hn : n ≤ l) : FullTensorTerm P a l n ≃ₗ[Enveloping k B] P.X (a+(n:ℤ)) :=
+  (TwoSidedTensor.congrLeft (k := k) (S := B) (T := Bᵐᵒᵖ) (N := BimoduleO P a l)
+    (supportedIdealEquiv (k := k) (B := B) l n hn) (fun _ _ => rfl)).trans
+      ((finiteModel P a l ⟨n,by omega⟩).trans (VertexTensor.bimoduleEquiv P a l ⟨n,by omega⟩))
+
+theorem subsingleton_above (n : ℕ) (hn : l < n) : Subsingleton (FullTensorTerm P a l n) := by
+  let : Subsingleton (TensorResolution.term k B l n) :=
+    (ModuleCat.isZero_iff_subsingleton).mp (TensorResolution.term_vanishes k B l n hn)
+  exact inferInstanceAs (Subsingleton (BalancedTensor.Tensor k (B ⊗[k] ChainAlgebra k l)
+    (TensorResolution.term k B l n) (BimoduleO P a l)))
+
+/-- Use precisely the source's upper support bound for all remaining degrees. -/
+def outsideEquiv (n : ℕ) (hn : l < n) (hP : IsZero (P.X (a+(n:ℤ)))) :
+    FullTensorTerm P a l n ≃ₗ[Enveloping k B] P.X (a+(n:ℤ)) := by
+  letI := subsingleton_above P a l n hn
+  letI : Subsingleton (P.X (a+(n:ℤ))) := ModuleCat.isZero_iff_subsingleton.mp hP
+  exact { toFun := fun _ => 0
+          invFun := fun _ => 0
+          left_inv := fun _ => Subsingleton.elim _ _
+          right_inv := fun _ => Subsingleton.elim _ _
+          map_add' := fun _ _ => Subsingleton.elim _ _
+          map_smul' := fun _ _ => Subsingleton.elim _ _ }
+
+/-- No extra support assumptions: P is required to vanish only above a+l here. -/
+def termEquiv (hP : ∀ n : ℕ, l < n → IsZero (P.X (a+(n:ℤ)))) (n : ℕ) :
+    FullTensorTerm P a l n ≃ₗ[Enveloping k B] P.X (a+(n:ℤ)) :=
+  if hn : n ≤ l then supportedEquiv P a l n hn else outsideEquiv P a l n (by omega) (hP n (by omega))
+end FullTensorTerm
+end LittleFinitistic.OrdinarySimulation
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryFunctorExtension.lean b/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryFunctorExtension.lean
new file mode 100644
index 0000000000000000000000000000000000000000..d836a2745ed3785d0cbad095e6d1109d3689dd2d
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryFunctorExtension.lean
@@ -0,0 +1,42 @@
+import OAI.Algebra.Finitistic.Ordinary.OrdinarySupportedExtension
+import Mathlib.Algebra.Homology.Additive
+
+namespace OAI
+noncomputable section
+open CategoryTheory Limits
+namespace LittleFinitistic.FunctorExtension
+universe u v u' v' w w'
+variable {C : Type u} [Category.{v} C] [HasZeroMorphisms C] [HasZeroObject C]
+variable {D : Type u'} [Category.{v'} D] [HasZeroMorphisms D] [HasZeroObject D]
+variable (F : C ⥤ D) [F.PreservesZeroMorphisms]
+variable {I : Type w} {J : Type w'} {c : ComplexShape I} {c' : ComplexShape J}
+variable (K : HomologicalComplex C c) (e : c.Embedding c') [e.IsRelIff]
+
+omit [HasZeroObject D] [e.IsRelIff] in
+/-- Mapping an extended complex retains its proved zero terms outside the embedded degrees. -/
+theorem mappedSupport : ((F.mapHomologicalComplex c').obj (K.extend e)).IsStrictlySupported e where
+  isZero j hj := F.map_isZero (K.isZero_extend_X e j hj)
+
+/-- On the actual supported degrees, mapping and extension have the same original terms. -/
+def restrictionIso : ((F.mapHomologicalComplex c').obj (K.extend e)).restriction e ≅
+    (F.mapHomologicalComplex c).obj K :=
+  HomologicalComplex.Hom.isoOfComponents (fun i => F.mapIso (K.extendXIso e (i := i) rfl)) (by
+    intro i j _
+    change F.map (K.extendXIso e (i := i) rfl).hom ≫ F.map (K.d i j) =
+      F.map ((K.extend e).d (e.f i) (e.f j)) ≫ F.map (K.extendXIso e (i := j) rfl).hom
+    rw [← F.map_comp,← F.map_comp]
+    congr 1
+    rw [HomologicalComplex.extend_d_eq _ _ rfl rfl]
+    simp only [Category.assoc,Iso.inv_hom_id,Category.comp_id])
+
+/-- An actual chain isomorphism commuting a zero-preserving functor with extension by zero. -/
+def iso : (F.mapHomologicalComplex c').obj (K.extend e) ≅
+    ((F.mapHomologicalComplex c).obj K).extend e := by
+  letI := mappedSupport F K e
+  exact (OrdinarySimulation.SupportedExtension.iso ((F.mapHomologicalComplex c').obj (K.extend e)) e).symm ≪≫
+    (e.extendFunctor D).mapIso (restrictionIso F K e)
+end LittleFinitistic.FunctorExtension
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryGenuineBimoduleComparison.lean b/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryGenuineBimoduleComparison.lean
new file mode 100644
index 0000000000000000000000000000000000000000..2ce1ffc0b6a5219c0e8658dc0b5a0e120b958efa
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryGenuineBimoduleComparison.lean
@@ -0,0 +1,78 @@
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryBimoduleTensorFunctor
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryTensorBimoduleResolution
+import OAI.Algebra.Finitistic.Ordinary.OrdinarySimulationComparison
+
+namespace OAI
+noncomputable section
+open CategoryTheory Limits
+open scoped TensorProduct
+namespace LittleFinitistic.OrdinarySimulation
+universe u
+variable {k B : Type u} [Field k] [Ring B] [Algebra k B]
+variable (P : CochainComplex (ModuleCat.{u} (Enveloping k B)) ℤ) (a : ℤ) (l : ℕ)
+
+abbrev genuineTensorFunctor :=
+  bimoduleTensorFunctor k B (B ⊗[k] ChainAlgebra k l) Bᵐᵒᵖ (BimoduleO P a l)
+
+def genuineFiniteTermIso (n : ℕ) :
+    (genuineTensorFunctor P a l).obj ((TensorResolution.bimoduleComplex k B l).X n) ≅
+      (FullTensorTerm.complex P a l).X n := by
+  let e : BimoduleCoefficients k B (B ⊗[k] ChainAlgebra k l)
+      ((TensorResolution.bimoduleComplex k B l).X n) ≃ₗ[(B ⊗[k] ChainAlgebra k l)ᵐᵒᵖ]
+        TensorResolution.term k B l n := (TensorResolution.forgetBimoduleTerm k B l n).toLinearEquiv
+  have he (b : B) (x : BimoduleCoefficients k B (B ⊗[k] ChainAlgebra k l)
+      ((TensorResolution.bimoduleComplex k B l).X n)) : e (b • x) = b • e x := by
+    apply Subtype.ext
+    change TensorIdeal.coefficient b * (x.val * 1) = TensorIdeal.coefficient b * x.val
+    rw [mul_one]
+  exact (TwoSidedTensor.congrLeft (k := k) (S := B) (T := Bᵐᵒᵖ) (N := BimoduleO P a l) e he).toModuleIso
+
+/-- The actual finite bimodule tensor agrees with the existing full computation, preserving both B-actions. -/
+def genuineFiniteComplexIso :
+    ((genuineTensorFunctor P a l).mapHomologicalComplex (.up ℕ)).obj
+      (TensorResolution.bimoduleComplex k B l) ≅ FullTensorTerm.complex P a l :=
+  HomologicalComplex.Hom.isoOfComponents (genuineFiniteTermIso P a l) (by
+    intro n m h
+    change n+1=m at h
+    subst m
+    change (genuineFiniteTermIso P a l n).hom ≫ (FullTensorTerm.complex P a l).d n (n+1) =
+      (genuineTensorFunctor P a l).map ((TensorResolution.bimoduleComplex k B l).d n (n+1)) ≫
+        (genuineFiniteTermIso P a l (n+1)).hom
+    have h₁ : (FullTensorTerm.complex P a l).d n (n+1) = ModuleCat.ofHom (FullTensorTerm.differential P a l n) :=
+      CochainComplex.of_d (fun n => ModuleCat.of (Enveloping k B) (FullTensorTerm P a l n))
+        (fun n => ModuleCat.ofHom (FullTensorTerm.differential P a l n)) n
+    have h₂ : (TensorResolution.bimoduleComplex k B l).d n (n+1) =
+        ModuleCat.ofHom (TensorResolution.bimoduleDifferential k B l n) :=
+      CochainComplex.of_d (fun n => ModuleCat.of (B ⊗[k] (B ⊗[k] ChainAlgebra k l)ᵐᵒᵖ)
+        (TensorResolution.bimoduleTerm k B l n))
+        (fun n => ModuleCat.ofHom (TensorResolution.bimoduleDifferential k B l n)) n
+    rw [h₁,h₂]
+    apply ModuleCat.hom_ext
+    dsimp only [genuineTensorFunctor, bimoduleTensorFunctor, FullTensorTerm.complex]
+    apply LinearMap.restrictScalars_injective k
+    apply BalancedTensor.ext
+    intro q o
+    rfl)
+
+/-- The actual all-integer tensor of genuine Q_T with O, retaining both outside B-actions. -/
+def genuineComputedTensor : CochainComplex (ModuleCat.{u} (Enveloping k B)) ℤ :=
+  ((genuineTensorFunctor P a l).mapHomologicalComplex (.up ℤ)).obj
+    (TensorResolution.integerBimoduleComplex k B l)
+
+/-- Agreement with the preserved full signed-comparison input in every integer degree. -/
+def genuineComputedTensorIso : genuineComputedTensor P a l ≅ computedTensorComplex P a l :=
+  FunctorExtension.iso (genuineTensorFunctor P a l) (TensorResolution.bimoduleComplex k B l)
+      (TensorResolution.degreeEmbedding l) ≪≫
+    ((TensorResolution.degreeEmbedding l).extendFunctor _).mapIso (genuineFiniteComplexIso P a l)
+
+/-- The actual ordinary tensor Q_T tensor O is isomorphic to P[b] as B-bimodule complexes.
+Only the manuscript support and indexing hypotheses are used. -/
+def genuineSourceShiftComparison (b : ℤ) (hb : a+(l:ℤ)=b)
+    (hP : ∀ n : ℤ, n < a ∨ b < n → IsZero (P.X n)) :
+    genuineComputedTensor P a l ≅ P⟦b⟧ :=
+  genuineComputedTensorIso P a l ≪≫ sourceShiftComparison P a l b hb hP
+end LittleFinitistic.OrdinarySimulation
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryGlobalDimension.lean b/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryGlobalDimension.lean
new file mode 100644
index 0000000000000000000000000000000000000000..6dd71dcff3cd645820c6de6a5c6d3ab47669eb72
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryGlobalDimension.lean
@@ -0,0 +1,41 @@
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryProductOpposite
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryTensorGlobalDimension
+
+namespace OAI
+noncomputable section
+open CategoryTheory
+open scoped TensorProduct
+namespace LittleFinitistic.OrdinarySimulation
+universe u v
+variable {k B : Type u} [Field k] [Ring B] [Algebra k B]
+
+/-- The manuscript's exact bound for D, on both sides and for arbitrary modules. -/
+theorem ordinary_globalDimension_bound (DB : DirectedBound.DirectedSystem k B 3) (l : ℕ) :
+    (⨆ M : ModuleCat.{max u v} (AlgebraD k l B), projectiveDimension M) ≤ (3*l+2 : ℕ) ∧
+    (⨆ M : ModuleCat.{max u v} (AlgebraD k l B)ᵐᵒᵖ, projectiveDimension M) ≤ (3*l+2 : ℕ) := by
+  have hB := DirectedBound.DirectedSystem.both_sides_projectiveDimension_le.{u,v} DB
+  have hBC := tensor_projectiveDimension_bound.{u,v} DB l
+  have hL (M : ModuleCat.{max u v} B) : projectiveDimension M ≤ (3*l+2 : ℕ) := by
+    apply (hB.1 M).trans
+    exact_mod_cast (show 3-1 ≤ 3*l+2 by omega)
+  have hR (M : ModuleCat.{max u v} Bᵐᵒᵖ) : projectiveDimension M ≤ (3*l+2 : ℕ) := by
+    apply (hB.2 M).trans
+    exact_mod_cast (show 3-1 ≤ 3*l+2 by omega)
+  exact ⟨iSup_le (fun M => ProductModules.product_module_bound B (B ⊗[k] ChainAlgebra k l)
+      (3*l+2) hL hBC.1 M),
+    iSup_le (fun M => ProductModules.opposite_product_module_bound B (B ⊗[k] ChainAlgebra k l)
+      (3*l+2) hR hBC.2 M)⟩
+
+variable {V W U : Type u} [AddCommGroup V] [Module k V] [AddCommGroup W] [Module k W]
+  [AddCommGroup U] [Module k U]
+
+/-- The bound for the actual three-vertex coefficient algebra and the actual Section 5 product D. -/
+theorem source_ordinary_globalDimension_bound (μ : W →ₗ[k] V →ₗ[k] U) (l : ℕ) :
+    (⨆ M : ModuleCat.{max u v} (AlgebraD k l (ThreeVertexAlgebra μ)), projectiveDimension M) ≤ (3*l+2 : ℕ) ∧
+    (⨆ M : ModuleCat.{max u v} (AlgebraD k l (ThreeVertexAlgebra μ))ᵐᵒᵖ, projectiveDimension M) ≤ (3*l+2 : ℕ) :=
+  ordinary_globalDimension_bound (ThreeVertexAlgebra.directedSystem μ) l
+end LittleFinitistic.OrdinarySimulation
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryIntegerResolution.lean b/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryIntegerResolution.lean
new file mode 100644
index 0000000000000000000000000000000000000000..beb66de87daa04ffe39ddb2c775b9b2d996a849b
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryIntegerResolution.lean
@@ -0,0 +1,74 @@
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryTensorResolutionComplex
+import Mathlib.Algebra.Homology.Embedding.ExtendHomology
+
+namespace OAI
+noncomputable section
+open CategoryTheory Limits
+open scoped TensorProduct
+namespace LittleFinitistic.OrdinarySimulation.TensorResolution
+universe u
+variable (k B : Type u) [Field k] [Ring B] [Algebra k B] (l : ℕ)
+
+def degreeEmbedding : (ComplexShape.up ℕ).Embedding (ComplexShape.up ℤ) :=
+  ComplexShape.embeddingUpIntGE (-(l:ℤ))
+
+instance degreeEmbedding_rel : (degreeEmbedding l).IsRelIff :=
+  inferInstanceAs ((ComplexShape.embeddingUpIntGE (-(l:ℤ))).IsRelIff)
+
+@[simp] theorem degreeEmbedding_apply (n : ℕ) : (degreeEmbedding l).f n = -(l:ℤ)+n := rfl
+
+/-- Q_T in the manuscript's cohomological degrees -l,...,0. -/
+def integerComplex : CochainComplex (ModuleCat.{u} (B ⊗[k] ChainAlgebra k l)ᵐᵒᵖ) ℤ :=
+  (complex k B l).extend (degreeEmbedding l)
+
+def integerTermIso (n : ℕ) : (integerComplex k B l).X (-(l:ℤ)+n) ≅ termObject k B l n :=
+  (complex k B l).extendXIso (degreeEmbedding l) rfl
+
+/-- The terminal simple is in degree zero after the actual reindexing. -/
+def integerAugmentation : integerComplex k B l ⟶
+    (HomologicalComplex.single _ (.up ℤ) 0).obj
+      (ModuleCat.of (B ⊗[k] ChainAlgebra k l)ᵐᵒᵖ (TerminalTensor B)) :=
+  HomologicalComplex.extendMap (augmentationMap k B l) (degreeEmbedding l) ≫
+    (HomologicalComplex.extendSingleIso (e := degreeEmbedding l)
+      (X := ModuleCat.of (B ⊗[k] ChainAlgebra k l)ᵐᵒᵖ (TerminalTensor B)) l 0 (by simp)).hom
+
+theorem integerAugmentation_quasiIso : QuasiIso (integerAugmentation k B l) := by
+  have := augmentationMap_quasiIso k B l
+  exact inferInstanceAs (QuasiIso
+    (HomologicalComplex.extendMap (augmentationMap k B l) (degreeEmbedding l) ≫
+      (HomologicalComplex.extendSingleIso (e := degreeEmbedding l)
+        (X := ModuleCat.of (B ⊗[k] ChainAlgebra k l)ᵐᵒᵖ (TerminalTensor B)) l 0 (by simp)).hom))
+
+theorem integerTerm_lower (n : ℤ) (h : n < -(l:ℤ)) : IsZero ((integerComplex k B l).X n) := by
+  apply (complex k B l).isZero_extend_X (degreeEmbedding l) n
+  intro j hj
+  simp only [degreeEmbedding_apply] at hj
+  omega
+
+theorem integerTerm_upper (n : ℤ) (h : 0 < n) : IsZero ((integerComplex k B l).X n) := by
+  let j := (n+(l:ℤ)).toNat
+  have hj : (degreeEmbedding l).f j = n := by
+    simp only [degreeEmbedding_apply]
+    dsimp [j]
+    rw [Int.toNat_of_nonneg (by omega)]
+    omega
+  have hjl : l < j := by
+    have hc : (j:ℤ) = n+(l:ℤ) := Int.toNat_of_nonneg (by omega)
+    omega
+  exact (term_vanishes k B l j hjl).of_iso ((complex k B l).extendXIso (degreeEmbedding l) hj)
+
+theorem integerTerm_projective (n : ℤ) : Projective ((integerComplex k B l).X n) := by
+  by_cases h : n < -(l:ℤ)
+  · exact (integerTerm_lower k B l n h).projective
+  let j := (n+(l:ℤ)).toNat
+  have hj : (degreeEmbedding l).f j = n := by
+    simp only [degreeEmbedding_apply]
+    dsimp [j]
+    rw [Int.toNat_of_nonneg (by omega)]
+    omega
+  exact Projective.of_iso ((complex k B l).extendXIso (degreeEmbedding l) hj).symm (projectiveTerm k B l j)
+end LittleFinitistic.OrdinarySimulation.TensorResolution
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryLeftTensorCongruence.lean b/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryLeftTensorCongruence.lean
new file mode 100644
index 0000000000000000000000000000000000000000..d24a14ba01ac4e11ca6efd2014056654ab6c6b2d
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryLeftTensorCongruence.lean
@@ -0,0 +1,27 @@
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryLeftTensorMaps
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryBalancedCongruence
+
+namespace OAI
+noncomputable section
+namespace LittleFinitistic.LeftTensor
+universe u
+variable {k A S M M' N N' : Type u} [Field k] [Ring A] [Ring S] [Algebra k A] [Algebra k S]
+variable [AddCommGroup M] [Module k M] [Module Aᵐᵒᵖ M] [IsScalarTower k Aᵐᵒᵖ M]
+  [Module S M] [IsScalarTower k S M] [SMulCommClass S Aᵐᵒᵖ M]
+variable [AddCommGroup M'] [Module k M'] [Module Aᵐᵒᵖ M'] [IsScalarTower k Aᵐᵒᵖ M']
+  [Module S M'] [IsScalarTower k S M'] [SMulCommClass S Aᵐᵒᵖ M']
+variable [AddCommGroup N] [Module k N] [Module A N] [IsScalarTower k A N]
+variable [AddCommGroup N'] [Module k N'] [Module A N'] [IsScalarTower k A N']
+
+/-- Actual balanced tensor congruence retaining the outside left action. -/
+def congr (f : M ≃ₗ[Aᵐᵒᵖ] M') (hf : ∀ (s : S) m, f (s • m) = s • f m)
+    (g : N ≃ₗ[A] N') : LeftTensor k A S M N ≃ₗ[S] LeftTensor k A S M' N' where
+  __ := bimap f.toLinearMap hf g.toLinearMap
+  invFun := (BalancedTensor.congr (k := k) f g).symm
+  left_inv := (BalancedTensor.congr (k := k) f g).left_inv
+  right_inv := (BalancedTensor.congr (k := k) f g).right_inv
+end LittleFinitistic.LeftTensor
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryLeftTensorMaps.lean b/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryLeftTensorMaps.lean
new file mode 100644
index 0000000000000000000000000000000000000000..d393c7afc5023fe9e7a711cfd70725bd2870fea6
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryLeftTensorMaps.lean
@@ -0,0 +1,43 @@
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryAssociativeTensorModules
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryTensorBimap
+
+namespace OAI
+noncomputable section
+namespace LittleFinitistic.LeftTensor
+universe u
+variable {k A S M M' N N' : Type u} [Field k] [Ring A] [Ring S] [Algebra k A] [Algebra k S]
+variable [AddCommGroup M] [Module k M] [Module Aᵐᵒᵖ M] [IsScalarTower k Aᵐᵒᵖ M]
+  [Module S M] [IsScalarTower k S M] [SMulCommClass S Aᵐᵒᵖ M]
+variable [AddCommGroup M'] [Module k M'] [Module Aᵐᵒᵖ M'] [IsScalarTower k Aᵐᵒᵖ M']
+  [Module S M'] [IsScalarTower k S M'] [SMulCommClass S Aᵐᵒᵖ M']
+variable [AddCommGroup N] [Module k N] [Module A N] [IsScalarTower k A N]
+variable [AddCommGroup N'] [Module k N'] [Module A N'] [IsScalarTower k A N']
+
+/-- The actual balanced bimap retains the outside left action. -/
+def bimap (f : M →ₗ[Aᵐᵒᵖ] M') (hf : ∀ (s : S) m, f (s • m) = s • f m)
+    (g : N →ₗ[A] N') : LeftTensor k A S M N →ₗ[S] LeftTensor k A S M' N' where
+  __ := (BalancedTensor.bimap (k := k) f g).toAddHom
+  map_smul' s z := by
+    change BalancedTensor.bimap (k := k) f g (action k S A M N s z) =
+      action k S A M' N' s (BalancedTensor.bimap (k := k) f g z)
+    induction z using BalancedTensor.induction_on with
+    | hz =>
+      exact ((BalancedTensor.bimap (k := k) f g).comp (action k S A M N s)).map_zero.trans
+        (((action k S A M' N' s).comp (BalancedTensor.bimap (k := k) f g)).map_zero).symm
+    | ht m n =>
+      change BalancedTensor.mk k A M' N' (f (s • m)) (g n) =
+        BalancedTensor.mk k A M' N' (s • f m) (g n)
+      rw [hf]
+    | ha x y hx hy =>
+      exact (((BalancedTensor.bimap (k := k) f g).comp (action k S A M N s)).map_add x y).trans
+        ((congrArg₂ (· + ·) hx hy).trans
+          (((action k S A M' N' s).comp (BalancedTensor.bimap (k := k) f g)).map_add x y).symm)
+
+@[simp] theorem bimap_mk (f : M →ₗ[Aᵐᵒᵖ] M') (hf : ∀ (s : S) m, f (s • m) = s • f m)
+    (g : N →ₗ[A] N') (m : M) (n : N) :
+    bimap f hf g (mk k S A M N m n) = mk k S A M' N' (f m) (g n) := rfl
+end LittleFinitistic.LeftTensor
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryMiddleTensorFunctors.lean b/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryMiddleTensorFunctors.lean
new file mode 100644
index 0000000000000000000000000000000000000000..9458f64d817983b655eb33d81c4e05ac3e67b289
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryMiddleTensorFunctors.lean
@@ -0,0 +1,83 @@
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryAssociativityNaturality
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryFixedTensorFunctor
+
+namespace OAI
+noncomputable section
+open CategoryTheory
+namespace LittleFinitistic
+universe u
+variable (k A B N : Type u) [Field k] [Ring A] [Ring B] [Algebra k A] [Algebra k B]
+variable [AddCommGroup N] [Module k N] [Module A N] [Module Bᵐᵒᵖ N]
+  [IsScalarTower k A N] [IsScalarTower k Bᵐᵒᵖ N] [SMulCommClass A Bᵐᵒᵖ N]
+
+/-- Tensor by the fixed middle bimodule, retaining its actual left action. -/
+def middleLeftFunctor : ModuleCat.{u} B ⥤ ModuleCat.{u} A where
+  obj Z := ModuleCat.of A (LeftTensor k B A N (BalancedTensor.ScalarLeftModule k B Z))
+  map {Z Z'} g := ModuleCat.ofHom
+    (LeftTensor.mapLast (k := k) (A := A) (N := N)
+      (Z := BalancedTensor.ScalarLeftModule k B Z) (Z' := BalancedTensor.ScalarLeftModule k B Z') g.hom)
+  map_id Z := by
+    apply ModuleCat.hom_ext
+    apply LinearMap.restrictScalars_injective k
+    apply BalancedTensor.ext
+    intro n z
+    rfl
+  map_comp f g := by
+    apply ModuleCat.hom_ext
+    apply LinearMap.restrictScalars_injective k
+    apply BalancedTensor.ext
+    intro n z
+    rfl
+
+instance middleLeftFunctor_additive : (middleLeftFunctor k A B N).Additive where
+  map_add {Z Z'} {f g} := by
+    dsimp only [middleLeftFunctor]
+    apply ModuleCat.hom_ext
+    apply LinearMap.restrictScalars_injective k
+    apply BalancedTensor.ext
+    intro n z
+    exact (BalancedTensor.mk k B N (BalancedTensor.ScalarLeftModule k B Z') n).map_add (f.hom z) (g.hom z)
+
+/-- Tensor a right module by the middle bimodule, retaining its actual right action. -/
+def middleRightFunctor : ModuleCat.{u} Aᵐᵒᵖ ⥤ ModuleCat.{u} Bᵐᵒᵖ where
+  obj M := ModuleCat.of Bᵐᵒᵖ (RightTensor k A B (BalancedTensor.ScalarLeftModule k Aᵐᵒᵖ M) N)
+  map {M M'} f := ModuleCat.ofHom
+    (RightTensor.mapFirst (k := k) (B := B) (N := N)
+      (M := BalancedTensor.ScalarLeftModule k Aᵐᵒᵖ M) (M' := BalancedTensor.ScalarLeftModule k Aᵐᵒᵖ M') f.hom)
+  map_id M := by
+    apply ModuleCat.hom_ext
+    apply LinearMap.restrictScalars_injective k
+    apply BalancedTensor.ext
+    intro m n
+    rfl
+  map_comp f g := by
+    apply ModuleCat.hom_ext
+    apply LinearMap.restrictScalars_injective k
+    apply BalancedTensor.ext
+    intro m n
+    rfl
+
+instance middleRightFunctor_additive : (middleRightFunctor k A B N).Additive where
+  map_add {M M'} {f g} := by
+    dsimp only [middleRightFunctor]
+    apply ModuleCat.hom_ext
+    apply LinearMap.restrictScalars_injective k
+    apply BalancedTensor.ext
+    intro m n
+    exact congrArg (fun h => h n)
+      ((BalancedTensor.mk k A (BalancedTensor.ScalarLeftModule k Aᵐᵒᵖ M') N).map_add (f.hom m) (g.hom m))
+
+/-- The genuine right tensor complex, with its right B-action. -/
+def middleRightComplex (Q : CochainComplex (ModuleCat.{u} Aᵐᵒᵖ) ℤ) :
+    CochainComplex (ModuleCat.{u} Bᵐᵒᵖ) ℤ :=
+  ((middleRightFunctor k A B N).mapHomologicalComplex (.up ℤ)).obj Q
+
+/-- The genuine left tensor complex, with its left A-action. -/
+def middleLeftComplex (Z : CochainComplex (ModuleCat.{u} B) ℤ) :
+    CochainComplex (ModuleCat.{u} A) ℤ :=
+  ((middleLeftFunctor k A B N).mapHomologicalComplex (.up ℤ)).obj Z
+end LittleFinitistic
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryOffDiagonalComplex.lean b/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryOffDiagonalComplex.lean
new file mode 100644
index 0000000000000000000000000000000000000000..1ec5f107c65e8d42edd79b3ec9759568e03708ee
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryOffDiagonalComplex.lean
@@ -0,0 +1,44 @@
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryOffDiagonalMaps
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryBimoduleCoefficients
+import Mathlib.Algebra.Homology.Additive
+
+namespace OAI
+noncomputable section
+open CategoryTheory
+open scoped TensorProduct
+namespace LittleFinitistic.OrdinarySimulation.OffDiagonal
+universe u
+variable (k L R : Type u) [Field k] [Ring L] [Ring R] [Algebra k L] [Algebra k R]
+variable (O : CochainComplex (ModuleCat.{u} (R ⊗[k] Lᵐᵒᵖ)) ℤ)
+variable (T : CochainComplex (ModuleCat.{u} (L ⊗[k] Rᵐᵒᵖ)) ℤ)
+
+abbrev complexTerm (n : ℤ) := RetainedBimodule k (L × R) (L × R)
+  (OffDiagonal (BimoduleCoefficients k R L (O.X n)) (BimoduleCoefficients k L R (T.X n)))
+
+def complexDifferential (n : ℤ) :=
+  RetainedBimodule.map (k := k) (S := L × R) (A := L × R)
+    (map (BimoduleCoefficients.map k R L (O.d n (n+1)))
+      (BimoduleCoefficients.map k L R (T.d n (n+1))))
+    (map_left (BimoduleCoefficients.map k R L (O.d n (n+1)))
+      (BimoduleCoefficients.map_left k R L (O.d n (n+1)))
+      (BimoduleCoefficients.map k L R (T.d n (n+1)))
+      (BimoduleCoefficients.map_left k L R (T.d n (n+1))))
+
+theorem complexDifferential_square (n : ℤ) :
+    (complexDifferential k L R O T (n+1)).comp (complexDifferential k L R O T n) = 0 := by
+  apply LinearMap.ext
+  intro x
+  apply Prod.ext
+  · exact congrArg (fun f => f.hom x.1) (O.d_comp_d n (n+1) ((n+1)+1))
+  · exact congrArg (fun f => f.hom x.2) (T.d_comp_d n (n+1) ((n+1)+1))
+
+/-- Actual off-diagonal complex with both actions of the product algebra retained. -/
+def complex : CochainComplex (ModuleCat.{u} ((L × R) ⊗[k] (L × R)ᵐᵒᵖ)) ℤ :=
+  CochainComplex.of (fun n => ModuleCat.of _ (complexTerm k L R O T n))
+    (fun n => ModuleCat.ofHom (complexDifferential k L R O T n))
+    (fun n => ModuleCat.hom_ext (complexDifferential_square k L R O T n))
+end LittleFinitistic.OrdinarySimulation.OffDiagonal
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryOffDiagonalComplexMaps.lean b/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryOffDiagonalComplexMaps.lean
new file mode 100644
index 0000000000000000000000000000000000000000..47299e0dfb4d7f9c7e7130924b0351ca5d90fa0d
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryOffDiagonalComplexMaps.lean
@@ -0,0 +1,43 @@
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryOffDiagonalComplex
+
+namespace OAI
+noncomputable section
+open CategoryTheory
+open scoped TensorProduct
+namespace LittleFinitistic.OrdinarySimulation.OffDiagonal
+universe u
+variable (k L R : Type u) [Field k] [Ring L] [Ring R] [Algebra k L] [Algebra k R]
+variable {O O' : CochainComplex (ModuleCat.{u} (R ⊗[k] Lᵐᵒᵖ)) ℤ}
+variable {T T' : CochainComplex (ModuleCat.{u} (L ⊗[k] Rᵐᵒᵖ)) ℤ}
+
+def complexTermMap (f : O ⟶ O') (g : T ⟶ T') (n : ℤ) :=
+  RetainedBimodule.map (k := k) (S := L × R) (A := L × R)
+    (map (BimoduleCoefficients.map k R L (f.f n)) (BimoduleCoefficients.map k L R (g.f n)))
+    (map_left (BimoduleCoefficients.map k R L (f.f n))
+      (BimoduleCoefficients.map_left k R L (f.f n))
+      (BimoduleCoefficients.map k L R (g.f n))
+      (BimoduleCoefficients.map_left k L R (g.f n)))
+
+theorem complex_d (n : ℤ) : (complex k L R O T).d n (n+1) =
+    ModuleCat.ofHom (complexDifferential k L R O T n) :=
+  CochainComplex.of_d (fun n => ModuleCat.of _ (complexTerm k L R O T n))
+    (fun n => ModuleCat.ofHom (complexDifferential k L R O T n)) n
+
+/-- An actual map of off-diagonal complexes retaining both product-ring actions. -/
+def complexMap (f : O ⟶ O') (g : T ⟶ T') : complex k L R O T ⟶ complex k L R O' T' where
+  f n := ModuleCat.ofHom (complexTermMap k L R f g n)
+  comm' n m h := by
+    change n+1=m at h
+    subst m
+    rw [complex_d,complex_d]
+    apply ModuleCat.hom_ext
+    apply LinearMap.ext
+    intro x
+    apply Prod.ext
+    · exact congrArg (fun h => h.hom x.1) (f.comm n (n+1))
+    · exact congrArg (fun h => h.hom x.2) (g.comm n (n+1))
+end LittleFinitistic.OrdinarySimulation.OffDiagonal
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryOffDiagonalForget.lean b/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryOffDiagonalForget.lean
new file mode 100644
index 0000000000000000000000000000000000000000..84ca1a34e6fd1b039ce05bccf0f56b8a5b841ecc
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryOffDiagonalForget.lean
@@ -0,0 +1,66 @@
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryOffDiagonalComplexMaps
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryRetainedRestriction
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryPairQuasiIso
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryRestrictionHomology
+
+namespace OAI
+noncomputable section
+open CategoryTheory
+open scoped TensorProduct
+namespace LittleFinitistic.OrdinarySimulation.OffDiagonal
+universe u
+variable (k L R : Type u) [Field k] [Ring L] [Ring R] [Algebra k L] [Algebra k R]
+variable (O : CochainComplex (ModuleCat.{u} (R ⊗[k] Lᵐᵒᵖ)) ℤ)
+variable (T : CochainComplex (ModuleCat.{u} (L ⊗[k] Rᵐᵒᵖ)) ℤ)
+
+def forgetTermIso (n : ℤ) : (underlyingComplex (k := k) (complex k L R O T)).X n ≅
+    (PairComplex.complex (underlyingComplex (k := k) O) (underlyingComplex (k := k) T)).X n :=
+  (RetainedBimodule.scalarEquiv k (L × R) (L × R)
+    (OffDiagonal (BimoduleCoefficients k R L (O.X n)) (BimoduleCoefficients k L R (T.X n)))).toModuleIso
+
+/-- Forgetting the two outside actions gives the actual coordinate direct-sum complex. -/
+def forgetIso : underlyingComplex (k := k) (complex k L R O T) ≅
+    PairComplex.complex (underlyingComplex (k := k) O) (underlyingComplex (k := k) T) :=
+  HomologicalComplex.Hom.isoOfComponents (forgetTermIso k L R O T) (by
+    intro n m h
+    change n+1=m at h
+    subst m
+    change (forgetTermIso k L R O T n).hom ≫ _ =
+      (ModuleCat.restrictScalars (algebraMap k ((L × R) ⊗[k] (L × R)ᵐᵒᵖ))).map
+        ((complex k L R O T).d n (n+1)) ≫ (forgetTermIso k L R O T (n+1)).hom
+    rw [complex_d,PairComplex.complex_d]
+    rfl)
+
+variable {O T} {O' : CochainComplex (ModuleCat.{u} (R ⊗[k] Lᵐᵒᵖ)) ℤ}
+variable {T' : CochainComplex (ModuleCat.{u} (L ⊗[k] Rᵐᵒᵖ)) ℤ}
+
+theorem forgetIso_natural (f : O ⟶ O') (g : T ⟶ T') :
+    ((ModuleCat.restrictScalars (algebraMap k ((L × R) ⊗[k] (L × R)ᵐᵒᵖ))).mapHomologicalComplex (.up ℤ)).map
+      (complexMap k L R f g) ≫ (forgetIso k L R O' T').hom =
+    (forgetIso k L R O T).hom ≫ PairComplex.map
+      (((ModuleCat.restrictScalars (algebraMap k (R ⊗[k] Lᵐᵒᵖ))).mapHomologicalComplex (.up ℤ)).map f)
+      (((ModuleCat.restrictScalars (algebraMap k (L ⊗[k] Rᵐᵒᵖ))).mapHomologicalComplex (.up ℤ)).map g) := by
+  ext n x
+  rfl
+
+/-- The actual off-diagonal map is a quasi-isomorphism when its two components are. -/
+theorem complexMap_quasiIso (f : O ⟶ O') (g : T ⟶ T') [QuasiIso f] [QuasiIso g] :
+    QuasiIso (complexMap k L R f g) := by
+  apply (RestrictionHomology.quasiIso_iff (algebraMap k ((L × R) ⊗[k] (L × R)ᵐᵒᵖ)) _).mp
+  let f' := ((ModuleCat.restrictScalars (algebraMap k (R ⊗[k] Lᵐᵒᵖ))).mapHomologicalComplex (.up ℤ)).map f
+  let g' := ((ModuleCat.restrictScalars (algebraMap k (L ⊗[k] Rᵐᵒᵖ))).mapHomologicalComplex (.up ℤ)).map g
+  have : QuasiIso f' := (RestrictionHomology.quasiIso_iff (algebraMap k (R ⊗[k] Lᵐᵒᵖ)) f).mpr inferInstance
+  have : QuasiIso g' := (RestrictionHomology.quasiIso_iff (algebraMap k (L ⊗[k] Rᵐᵒᵖ)) g).mpr inferInstance
+  have := PairComplex.map_quasiIso f' g'
+  let h := ((ModuleCat.restrictScalars (algebraMap k ((L × R) ⊗[k] (L × R)ᵐᵒᵖ))).mapHomologicalComplex (.up ℤ)).map
+    (complexMap k L R f g)
+  have hh : QuasiIso (h ≫ (forgetIso k L R O' T').hom) := by
+    dsimp only [h]
+    rw [forgetIso_natural]
+    exact inferInstanceAs (QuasiIso ((forgetIso k L R O T).hom ≫ PairComplex.map f' g'))
+  exact (quasiIso_iff_comp_right h (forgetIso k L R O' T').hom).mp hh
+end LittleFinitistic.OrdinarySimulation.OffDiagonal
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryOffDiagonalMaps.lean b/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryOffDiagonalMaps.lean
new file mode 100644
index 0000000000000000000000000000000000000000..e6e61f023c4aff47034e39e18d6d708797696575
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryOffDiagonalMaps.lean
@@ -0,0 +1,31 @@
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryBlockBimodule
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryRetainedBimodule
+
+namespace OAI
+noncomputable section
+namespace LittleFinitistic.OrdinarySimulation.OffDiagonal
+universe u
+variable {L R O O' T T' : Type u} [Ring L] [Ring R]
+variable [AddCommGroup O] [AddCommGroup O'] [AddCommGroup T] [AddCommGroup T']
+variable [Module R O] [Module R O'] [Module L T] [Module L T']
+variable [Module Lᵐᵒᵖ O] [Module Lᵐᵒᵖ O'] [Module Rᵐᵒᵖ T] [Module Rᵐᵒᵖ T']
+
+/-- Actual component maps of the off-diagonal right product-ring module. -/
+def map (f : O →ₗ[Lᵐᵒᵖ] O') (g : T →ₗ[Rᵐᵒᵖ] T') :
+    OffDiagonal O T →ₗ[(L × R)ᵐᵒᵖ] OffDiagonal O' T' where
+  toFun x := (f x.1,g x.2)
+  map_add' left right := Prod.ext (f.map_add left.1 right.1) (g.map_add left.2 right.2)
+  map_smul' d x := Prod.ext (f.map_smul (MulOpposite.op d.unop.1) x.1)
+    (g.map_smul (MulOpposite.op d.unop.2) x.2)
+
+/-- The same map retains the two prescribed left product-ring actions. -/
+theorem map_left (f : O →ₗ[Lᵐᵒᵖ] O') (hf : ∀ (r : R) x, f (r • x) = r • f x)
+    (g : T →ₗ[Rᵐᵒᵖ] T') (hg : ∀ (s : L) x, g (s • x) = s • g x)
+    (d : L × R) (x : OffDiagonal O T) :
+    map f g (d • x) = d • map f g x :=
+  Prod.ext (hf d.2 x.1) (hg d.1 x.2)
+end LittleFinitistic.OrdinarySimulation.OffDiagonal
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryOffDiagonalObjects.lean b/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryOffDiagonalObjects.lean
new file mode 100644
index 0000000000000000000000000000000000000000..9ee5f6738e15258f6b67fd8b43393f3a534aa05c
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryOffDiagonalObjects.lean
@@ -0,0 +1,50 @@
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryOffDiagonalComplexMaps
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryRetainedRestriction
+
+namespace OAI
+noncomputable section
+open CategoryTheory Limits
+open scoped TensorProduct
+namespace LittleFinitistic.OrdinarySimulation.OffDiagonal
+universe u
+variable (k L R : Type u) [Field k] [Ring L] [Ring R] [Algebra k L] [Algebra k R]
+variable (O : ModuleCat.{u} (R ⊗[k] Lᵐᵒᵖ)) (T : ModuleCat.{u} (L ⊗[k] Rᵐᵒᵖ))
+
+abbrev object : ModuleCat.{u} ((L × R) ⊗[k] (L × R)ᵐᵒᵖ) :=
+  RetainedBimodule.object k (L × R) (L × R)
+    (OffDiagonal (BimoduleCoefficients k R L O) (BimoduleCoefficients k L R T))
+
+variable {O T} {O' : ModuleCat.{u} (R ⊗[k] Lᵐᵒᵖ)} {T' : ModuleCat.{u} (L ⊗[k] Rᵐᵒᵖ)}
+
+def objectMap (f : O ⟶ O') (g : T ⟶ T') : object k L R O T ⟶ object k L R O' T' :=
+  ModuleCat.ofHom (RetainedBimodule.map (k := k) (S := L × R) (A := L × R)
+    (map (BimoduleCoefficients.map k R L f) (BimoduleCoefficients.map k L R g))
+    (map_left (BimoduleCoefficients.map k R L f) (BimoduleCoefficients.map_left k R L f)
+      (BimoduleCoefficients.map k L R g) (BimoduleCoefficients.map_left k L R g)))
+
+def objectIso (f : O ≅ O') (g : T ≅ T') : object k L R O T ≅ object k L R O' T' where
+  hom := objectMap k L R f.hom g.hom
+  inv := objectMap k L R f.inv g.inv
+  hom_inv_id := by
+    apply ModuleCat.hom_ext
+    apply LinearMap.ext
+    intro x
+    exact Prod.ext (congrArg (fun h => h.hom x.1) f.hom_inv_id)
+      (congrArg (fun h => h.hom x.2) g.hom_inv_id)
+  inv_hom_id := by
+    apply ModuleCat.hom_ext
+    apply LinearMap.ext
+    intro x
+    exact Prod.ext (congrArg (fun h => h.hom x.1) f.inv_hom_id)
+      (congrArg (fun h => h.hom x.2) g.inv_hom_id)
+
+theorem object_isZero (hO : IsZero O) (hT : IsZero T) : IsZero (object k L R O T) := by
+  have := ModuleCat.isZero_iff_subsingleton.mp hO
+  have := ModuleCat.isZero_iff_subsingleton.mp hT
+  apply ModuleCat.isZero_iff_subsingleton.mpr
+  exact inferInstanceAs (Subsingleton (O × T))
+end LittleFinitistic.OrdinarySimulation.OffDiagonal
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryOffDiagonalProjective.lean b/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryOffDiagonalProjective.lean
new file mode 100644
index 0000000000000000000000000000000000000000..89aab37d05d9faba0be8bf898e07f773e2067a46
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryOffDiagonalProjective.lean
@@ -0,0 +1,52 @@
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryOffDiagonalMaps
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryProductOpposite
+
+namespace OAI
+noncomputable section
+open CategoryTheory
+namespace LittleFinitistic.OrdinarySimulation.OffDiagonal
+universe u
+variable (L R O T : Type u) [Ring L] [Ring R]
+variable [AddCommGroup O] [AddCommGroup T] [Module Lᵐᵒᵖ O] [Module Rᵐᵒᵖ T]
+open ProductModules
+
+abbrev inflatedPair : ModuleCat.{u} (Lᵐᵒᵖ × Rᵐᵒᵖ) := ModuleCat.of _
+  (((firstInflation Lᵐᵒᵖ Rᵐᵒᵖ).obj (ModuleCat.of Lᵐᵒᵖ O)) ×
+    ((secondInflation Lᵐᵒᵖ Rᵐᵒᵖ).obj (ModuleCat.of Rᵐᵒᵖ T)))
+
+attribute [local instance] RingHomInvPair.of_ringEquiv
+
+def rightPairEquiv : OffDiagonal O T ≃ₛₗ[RingHomClass.toRingHom (oppositeEquiv L R)]
+    inflatedPair L R O T where
+  toFun x := x
+  invFun x := x
+  left_inv _ := rfl
+  right_inv _ := rfl
+  map_add' _ _ := rfl
+  map_smul' _ _ := rfl
+
+/-- Off-diagonal right projectivity follows from the actual two product-factor modules. -/
+theorem right_projective [Module.Projective Lᵐᵒᵖ O] [Module.Projective Rᵐᵒᵖ T] :
+    Module.Projective (L × R)ᵐᵒᵖ (OffDiagonal O T) := by
+  let P := ModuleCat.of Lᵐᵒᵖ O
+  let Q := ModuleCat.of Rᵐᵒᵖ T
+  have : Projective P := ModuleCat.projective_of_categoryTheory_projective P
+  have : Projective Q := ModuleCat.projective_of_categoryTheory_projective Q
+  have : HasProjectiveDimensionLE P 0 := (projective_iff_hasProjectiveDimensionLT_one (X := P)).mp inferInstance
+  have : HasProjectiveDimensionLE Q 0 := (projective_iff_hasProjectiveDimensionLT_one (X := Q)).mp inferInstance
+  have := firstInflation_dimensionLE Lᵐᵒᵖ Rᵐᵒᵖ 0 P
+  have := secondInflation_dimensionLE Lᵐᵒᵖ Rᵐᵒᵖ 0 Q
+  let e := ModuleCat.biprodIsoProd ((firstInflation Lᵐᵒᵖ Rᵐᵒᵖ).obj P)
+    ((secondInflation Lᵐᵒᵖ Rᵐᵒᵖ).obj Q)
+  have : HasProjectiveDimensionLT (inflatedPair L R O T) 1 := hasProjectiveDimensionLT_of_iso e 1
+  have : HasProjectiveDimensionLE (ModuleCat.of (L × R)ᵐᵒᵖ (OffDiagonal O T)) 0 :=
+    ModuleCat.hasProjectiveDimensionLE_of_semiLinearEquiv (oppositeEquiv L R).symm
+      (rightPairEquiv L R O T).symm 0
+  have : Projective (ModuleCat.of (L × R)ᵐᵒᵖ (OffDiagonal O T)) :=
+    (projective_iff_hasProjectiveDimensionLT_one (X := ModuleCat.of (L × R)ᵐᵒᵖ (OffDiagonal O T))).mpr inferInstance
+  exact ModuleCat.projective_of_module_projective (ModuleCat.of (L × R)ᵐᵒᵖ (OffDiagonal O T))
+end LittleFinitistic.OrdinarySimulation.OffDiagonal
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryOffDiagonalSingle.lean b/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryOffDiagonalSingle.lean
new file mode 100644
index 0000000000000000000000000000000000000000..8e85cfd45ffc167d0446636ea8da60e4aec328f0
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryOffDiagonalSingle.lean
@@ -0,0 +1,45 @@
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryOffDiagonalObjects
+import Mathlib.Algebra.Homology.Single
+
+namespace OAI
+noncomputable section
+open CategoryTheory Limits
+open scoped TensorProduct
+namespace LittleFinitistic.OrdinarySimulation.OffDiagonal
+universe u
+variable (k L R : Type u) [Field k] [Ring L] [Ring R] [Algebra k L] [Algebra k R]
+variable (O : ModuleCat.{u} (R ⊗[k] Lᵐᵒᵖ)) (T : ModuleCat.{u} (L ⊗[k] Rᵐᵒᵖ))
+
+abbrev singles : CochainComplex (ModuleCat.{u} ((L × R) ⊗[k] (L × R)ᵐᵒᵖ)) ℤ :=
+  complex k L R ((HomologicalComplex.single _ (.up ℤ) 0).obj O)
+    ((HomologicalComplex.single _ (.up ℤ) 0).obj T)
+
+theorem singles_isZero (n : ℤ) (hn : n ≠ 0) : IsZero ((singles k L R O T).X n) :=
+  object_isZero k L R (HomologicalComplex.isZero_single_obj_X (.up ℤ) 0 O n hn)
+    (HomologicalComplex.isZero_single_obj_X (.up ℤ) 0 T n hn)
+
+def singleTermIso (n : ℤ) : (singles k L R O T).X n ≅
+    ((HomologicalComplex.single _ (.up ℤ) 0).obj (object k L R O T)).X n := by
+  by_cases hn : n = 0
+  · subst n
+    exact objectIso k L R (HomologicalComplex.singleObjXSelf (.up ℤ) 0 O)
+      (HomologicalComplex.singleObjXSelf (.up ℤ) 0 T) ≪≫
+      (HomologicalComplex.singleObjXSelf (.up ℤ) 0 (object k L R O T)).symm
+  · exact (singles_isZero k L R O T n hn).iso
+      (HomologicalComplex.isZero_single_obj_X (.up ℤ) 0 (object k L R O T) n hn)
+
+/-- The off-diagonal direct sum of two ordinary modules is their ordinary bimodule in degree zero. -/
+def singleIso : singles k L R O T ≅
+    (HomologicalComplex.single _ (.up ℤ) 0).obj (object k L R O T) :=
+  HomologicalComplex.Hom.isoOfComponents (singleTermIso k L R O T) (by
+    intro n m h
+    change n+1=m at h
+    by_cases hn : n = 0
+    · have hm : m ≠ 0 := by omega
+      exact (HomologicalComplex.isZero_single_obj_X (.up ℤ) 0 (object k L R O T) m hm).eq_of_tgt _ _
+    · exact (singles_isZero k L R O T n hn).eq_of_src _ _)
+end LittleFinitistic.OrdinarySimulation.OffDiagonal
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryPairComplex.lean b/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryPairComplex.lean
new file mode 100644
index 0000000000000000000000000000000000000000..f93a0558835aa023cb381c3327e6ff1a9c713605
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryPairComplex.lean
@@ -0,0 +1,86 @@
+import Mathlib.Algebra.Homology.Additive
+import Mathlib.Algebra.Homology.QuasiIso
+import Mathlib.Algebra.Homology.HomologicalComplexBiprod
+import Mathlib.Algebra.Category.ModuleCat.Biproducts
+
+namespace OAI
+noncomputable section
+open CategoryTheory Limits
+namespace LittleFinitistic.PairComplex
+universe u
+variable {k : Type u} [Ring k]
+variable (O T : CochainComplex (ModuleCat.{u} k) ℤ)
+
+def complex : CochainComplex (ModuleCat.{u} k) ℤ :=
+  CochainComplex.of (fun n => ModuleCat.of k (O.X n × T.X n))
+    (fun n => ModuleCat.ofHom ((O.d n (n+1)).hom.prodMap (T.d n (n+1)).hom)) (by
+      intro n
+      apply ModuleCat.hom_ext
+      apply LinearMap.ext
+      intro x
+      exact Prod.ext (congrArg (fun h => h.hom x.1) (O.d_comp_d n (n+1) ((n+1)+1)))
+        (congrArg (fun h => h.hom x.2) (T.d_comp_d n (n+1) ((n+1)+1))))
+
+theorem complex_d (n : ℤ) : (complex O T).d n (n+1) =
+    ModuleCat.ofHom ((O.d n (n+1)).hom.prodMap (T.d n (n+1)).hom) :=
+  CochainComplex.of_d (fun n => ModuleCat.of k (O.X n × T.X n))
+    (fun n => ModuleCat.ofHom ((O.d n (n+1)).hom.prodMap (T.d n (n+1)).hom)) n
+
+def fst : complex O T ⟶ O where
+  f n := ModuleCat.ofHom (LinearMap.fst k (O.X n) (T.X n))
+  comm' n m h := by
+    change n+1=m at h
+    subst m
+    rw [complex_d]
+    rfl
+
+def snd : complex O T ⟶ T where
+  f n := ModuleCat.ofHom (LinearMap.snd k (O.X n) (T.X n))
+  comm' n m h := by
+    change n+1=m at h
+    subst m
+    rw [complex_d]
+    rfl
+
+def inl : O ⟶ complex O T where
+  f n := ModuleCat.ofHom (LinearMap.inl k (O.X n) (T.X n))
+  comm' n m h := by
+    change n+1=m at h
+    subst m
+    rw [complex_d]
+    apply ModuleCat.hom_ext
+    apply LinearMap.ext
+    intro x
+    exact Prod.ext rfl ((T.d n (n+1)).hom.map_zero)
+
+def inr : T ⟶ complex O T where
+  f n := ModuleCat.ofHom (LinearMap.inr k (O.X n) (T.X n))
+  comm' n m h := by
+    change n+1=m at h
+    subst m
+    rw [complex_d]
+    apply ModuleCat.hom_ext
+    apply LinearMap.ext
+    intro x
+    exact Prod.ext ((O.d n (n+1)).hom.map_zero) rfl
+
+@[simp] theorem inl_fst : inl O T ≫ fst O T = 𝟙 O := by ext degree element; rfl
+@[simp] theorem inl_snd : inl O T ≫ snd O T = 0 := by ext degree element; rfl
+@[simp] theorem inr_fst : inr O T ≫ fst O T = 0 := by ext degree element; rfl
+@[simp] theorem inr_snd : inr O T ≫ snd O T = 𝟙 T := by ext degree element; rfl
+
+/-- The actual coordinate complex is the native binary biproduct. -/
+def biprodIso : complex O T ≅ O ⊞ T where
+  hom := biprod.lift (fst O T) (snd O T)
+  inv := biprod.desc (inl O T) (inr O T)
+  hom_inv_id := by
+    rw [biprod.lift_desc]
+    ext n x
+    exact Prod.ext (add_zero _) (zero_add _)
+  inv_hom_id := by
+    apply biprod.hom_ext <;> apply biprod.hom_ext' <;> simp [Category.assoc]
+end LittleFinitistic.PairComplex
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryPairQuasiIso.lean b/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryPairQuasiIso.lean
new file mode 100644
index 0000000000000000000000000000000000000000..49fd8029749aada90f92d17f29e4243352f5b1f7
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryPairQuasiIso.lean
@@ -0,0 +1,74 @@
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryPairComplex
+import Mathlib.Algebra.Homology.HomologicalComplexAbelian
+import Mathlib.CategoryTheory.Preadditive.AdditiveFunctor
+
+namespace OAI
+noncomputable section
+open CategoryTheory Limits
+namespace LittleFinitistic.PairComplex
+universe u
+variable {k : Type u} [Ring k]
+variable {O O' T T' : CochainComplex (ModuleCat.{u} k) ℤ}
+
+def map (f : O ⟶ O') (g : T ⟶ T') : complex O T ⟶ complex O' T' where
+  f n := ModuleCat.ofHom ((f.f n).hom.prodMap (g.f n).hom)
+  comm' n m h := by
+    change n+1=m at h
+    subst m
+    rw [complex_d,complex_d]
+    apply ModuleCat.hom_ext
+    apply LinearMap.ext
+    intro x
+    exact Prod.ext (congrArg (fun h => h.hom x.1) (f.comm n (n+1)))
+      (congrArg (fun h => h.hom x.2) (g.comm n (n+1)))
+
+theorem biprodIso_natural (f : O ⟶ O') (g : T ⟶ T') :
+    map f g ≫ (biprodIso O' T').hom = (biprodIso O T).hom ≫ biprod.map f g := by
+  apply biprod.hom_ext
+  · simp only [biprodIso,Category.assoc,biprod.lift_fst,biprod.map_fst,biprod.lift_fst_assoc]
+    ext n x
+    rfl
+  · simp only [biprodIso,Category.assoc,biprod.lift_snd,biprod.map_snd,biprod.lift_snd_assoc]
+    ext n x
+    rfl
+
+/-- Native binary biproducts preserve actual quasi-isomorphisms. -/
+theorem biprodMap_quasiIso (f : O ⟶ O') (g : T ⟶ T') [QuasiIso f] [QuasiIso g] :
+    QuasiIso (biprod.map f g) := by
+  constructor
+  intro i
+  apply (quasiIsoAt_iff_isIso_homologyMap _ i).mpr
+  let H := HomologicalComplex.homologyFunctor (ModuleCat.{u} k) (.up ℤ) i
+  let : H.Additive := inferInstanceAs ((HomologicalComplex.homologyFunctor (ModuleCat.{u} k) (.up ℤ) i).Additive)
+  let : PreservesFiniteBiproducts H := Functor.preservesFiniteBiproductsOfAdditive H
+  let : PreservesBinaryBiproducts H := preservesBinaryBiproducts_of_preservesBiproducts H
+  have : IsIso (H.map f) := (quasiIsoAt_iff_isIso_homologyMap f i).mp inferInstance
+  have : IsIso (H.map g) := (quasiIsoAt_iff_isIso_homologyMap g i).mp inferInstance
+  change IsIso (H.map (biprod.map f g))
+  have he : H.map (biprod.map f g) ≫ (H.mapBiprod O' T').hom =
+      (H.mapBiprod O T).hom ≫ biprod.map (H.map f) (H.map g) := by
+    apply biprod.hom_ext
+    · simp only [Functor.mapBiprod_hom,Category.assoc,biprod.lift_fst,biprod.map_fst,biprod.lift_fst_assoc,← H.map_comp]
+    · simp only [Functor.mapBiprod_hom,Category.assoc,biprod.lift_snd,biprod.map_snd,biprod.lift_snd_assoc,← H.map_comp]
+  have : IsIso (biprod.map (H.map f) (H.map g)) := by
+    refine ⟨⟨biprod.map (inv (H.map f)) (inv (H.map g)), ?_, ?_⟩⟩
+    · apply biprod.hom_ext <;> simp [Category.assoc]
+    · apply biprod.hom_ext <;> simp [Category.assoc]
+  have h : IsIso (H.map (biprod.map f g) ≫ (H.mapBiprod O' T').hom) := by
+    rw [he]
+    infer_instance
+  exact (isIso_comp_right_iff _ (H.mapBiprod O' T').hom).mp h
+
+/-- Coordinatewise quasi-isomorphisms give a quasi-isomorphism of the actual direct sum. -/
+theorem map_quasiIso (f : O ⟶ O') (g : T ⟶ T') [QuasiIso f] [QuasiIso g] :
+    QuasiIso (map f g) := by
+  have := biprodMap_quasiIso f g
+  have h : QuasiIso (map f g ≫ (biprodIso O' T').hom) := by
+    rw [biprodIso_natural]
+    infer_instance
+  exact (quasiIso_iff_comp_right (map f g) (biprodIso O' T').hom).mp h
+end LittleFinitistic.PairComplex
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryProductComponent.lean b/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryProductComponent.lean
new file mode 100644
index 0000000000000000000000000000000000000000..f61b64550642e26f04b55d8afe328cb1b7f78bcb
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryProductComponent.lean
@@ -0,0 +1,101 @@
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryRestrictionHomology
+import Mathlib.Algebra.Category.ModuleCat.Projective
+
+namespace OAI
+noncomputable section
+open CategoryTheory
+namespace LittleFinitistic.ProductModules
+universe u v
+variable (L R : Type u) [Ring L] [Ring R]
+variable (M : ModuleCat.{v} (L × R))
+
+/-- The actual first central-idempotent summand of an arbitrary product-ring module. -/
+def firstSpace : Submodule (L × R) M where
+  carrier := {m | ((1,0) : L × R) • m = m}
+  zero_mem' := smul_zero _
+  add_mem' {x y} hx hy := by
+    change ((1,0) : L × R) • (x+y) = x+y
+    rw [smul_add,hx,hy]
+  smul_mem' d x hx := by
+    change ((1,0) : L × R) • (d • x) = d • x
+    have he : ((1,0) : L × R) * d = d * (1,0) := by ext <;> simp
+    rw [← mul_smul,he,mul_smul,hx]
+
+def firstScalar (r : L) : firstSpace L R M →ₗ[ℤ] firstSpace L R M where
+  toFun x := ⟨(r,(0:R)) • x.val, by
+    change ((1,0) : L × R) • ((r,(0:R)) • x.val) = (r,(0:R)) • x.val
+    rw [← mul_smul]
+    have h : ((1,0) : L × R) * (r,(0:R)) = (r,(0:R)) := by ext <;> simp
+    rw [h]⟩
+  map_add' x y := Subtype.ext (smul_add _ _ _)
+  map_smul' n x := by
+    apply Subtype.ext
+    exact smul_comm ((r,(0:R)) : L × R) n x.val
+
+def firstAction : L →+* Module.End ℤ (firstSpace L R M) where
+  toFun := firstScalar L R M
+  map_one' := by
+    apply LinearMap.ext
+    intro x
+    apply Subtype.ext
+    change ((1,0) : L × R) • x.val = x.val
+    exact x.property
+  map_zero' := by
+    apply LinearMap.ext
+    intro x
+    apply Subtype.ext
+    change (0 : L × R) • x.val = 0
+    exact zero_smul (L × R) x.val
+  map_add' r s := by
+    apply LinearMap.ext
+    intro x
+    apply Subtype.ext
+    change ((r+s,(0:R)) : L × R) • x.val = (r,(0:R)) • x.val + (s,(0:R)) • x.val
+    simpa only [Prod.mk_add_mk,add_zero] using add_smul ((r,(0:R)) : L × R) (s,(0:R)) x.val
+  map_mul' r s := by
+    apply LinearMap.ext
+    intro x
+    apply Subtype.ext
+    change ((r*s,(0:R)) : L × R) • x.val = (r,(0:R)) • ((s,(0:R)) • x.val)
+    rw [← mul_smul]
+    have h : ((r,(0:R)) : L × R) * (s,0) = (r*s,0) := by ext <;> simp
+    rw [h]
+
+instance firstModule : Module L (firstSpace L R M) := Module.compHom _ (firstAction L R M)
+
+abbrev firstObject : ModuleCat.{v} L := ModuleCat.of L (firstSpace L R M)
+
+variable {M} {N : ModuleCat.{v} (L × R)}
+
+def firstMap (f : M ⟶ N) : firstSpace L R M →ₗ[L] firstSpace L R N where
+  toFun x := ⟨f.hom x.val, by
+    change ((1,0) : L × R) • f.hom x.val = f.hom x.val
+    rw [← f.hom.map_smul,x.property]⟩
+  map_add' x y := Subtype.ext (f.hom.map_add _ _)
+  map_smul' r x := Subtype.ext (f.hom.map_smul ((r,(0:R)) : L × R) x.val)
+
+/-- The actual component functor, constructed on every module and map. -/
+def firstFunctor : ModuleCat.{v} (L × R) ⥤ ModuleCat.{v} L where
+  obj M := firstObject L R M
+  map f := ModuleCat.ofHom (firstMap L R f)
+  map_id M := by rfl
+  map_comp f g := by rfl
+
+/-- Surjections remain surjections on the selected component, by projecting a preimage. -/
+theorem firstMap_surjective (f : M ⟶ N) (hf : Function.Surjective f.hom) :
+    Function.Surjective (firstMap L R f) := by
+  intro y
+  obtain ⟨x,hx⟩ := hf y.val
+  refine ⟨⟨((1,0) : L × R) • x,?_⟩,?_⟩
+  · change ((1,0) : L × R) • (((1,0) : L × R) • x) = ((1,0) : L × R) • x
+    rw [← mul_smul]
+    have h : ((1,0) : L × R) * (1,0) = (1,0) := by ext <;> simp
+    rw [h]
+  · apply Subtype.ext
+    change f.hom (((1,0) : L × R) • x) = y.val
+    rw [f.hom.map_smul,hx,y.property]
+end LittleFinitistic.ProductModules
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryProductDimension.lean b/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryProductDimension.lean
new file mode 100644
index 0000000000000000000000000000000000000000..fcf18953204e01ea764a0c1b22b5fe8450db5d76
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryProductDimension.lean
@@ -0,0 +1,46 @@
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryProductProjective
+import Mathlib.Algebra.Category.ModuleCat.ProjectiveDimension
+
+namespace OAI
+noncomputable section
+open CategoryTheory
+namespace LittleFinitistic.ProductModules
+universe u v
+variable (L R : Type u) [Ring L] [Ring R] [Small.{v} L] [Small.{v} R]
+
+omit [Small.{v} L] [Small.{v} R] in
+/-- Exactness of actual inflation, with the module universe independent of the ring universe. -/
+theorem firstInflation_preservesHomology :
+    (firstInflation.{u,v} L R).PreservesHomology :=
+  CategoryTheory.Functor.preservesHomology_of_map_exact _ (fun K hK => by
+    rw [ShortComplex.moduleCat_exact_iff] at hK ⊢
+    exact hK)
+
+omit [Small.{v} R] in
+/-- Inflation from a factor preserves finite projective-dimension bounds, via actual projective covers. -/
+theorem firstInflation_dimensionLE (n : ℕ) (M : ModuleCat.{v} L) [HasProjectiveDimensionLE M n] :
+    HasProjectiveDimensionLE ((firstInflation L R).obj M) n := by
+  induction n generalizing M with
+  | zero =>
+    have : Projective M := (projective_iff_hasProjectiveDimensionLT_one (X := M)).mpr inferInstance
+    have := firstInflation_projective L R M
+    infer_instance
+  | succ n ih =>
+    let S := M.projectiveShortComplex
+    have hS := M.shortExact_projectiveShortComplex
+    have : HasProjectiveDimensionLT S.X₁ (n+1) :=
+      (hS.hasProjectiveDimensionLT_X₃_iff n inferInstance).mp inferInstance
+    have hk := ih S.X₁
+    have hp := firstInflation_projective L R S.X₂
+    have := firstInflation_preservesHomology.{u,v} L R
+    have : Mono ((firstInflation L R).map S.f) :=
+      (ModuleCat.mono_iff_injective _).mpr ((ModuleCat.mono_iff_injective S.f).mp hS.mono_f)
+    have : Epi ((firstInflation L R).map S.g) :=
+      (ModuleCat.epi_iff_surjective _).mpr ((ModuleCat.epi_iff_surjective S.g).mp hS.epi_g)
+    have hs : (S.map (firstInflation L R)).ShortExact := hS.map (firstInflation L R)
+    exact (hs.hasProjectiveDimensionLT_X₃_iff n hp).mpr hk
+end LittleFinitistic.ProductModules
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryProductOpposite.lean b/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryProductOpposite.lean
new file mode 100644
index 0000000000000000000000000000000000000000..3a0dc4e7a1a5737f52bf6de1431d9c9cfa030929
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryProductOpposite.lean
@@ -0,0 +1,49 @@
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryProductSecondDimension
+import Mathlib.Algebra.Algebra.Opposite
+
+namespace OAI
+noncomputable section
+open CategoryTheory
+namespace LittleFinitistic.ProductModules
+universe u v
+variable (L R : Type u) [Ring L] [Ring R]
+
+/-- The opposite of the actual product ring is the product of the two opposite rings. -/
+def oppositeEquiv : (L × R)ᵐᵒᵖ ≃+* Lᵐᵒᵖ × Rᵐᵒᵖ where
+  toFun x := (MulOpposite.op x.unop.1,MulOpposite.op x.unop.2)
+  invFun x := MulOpposite.op (x.1.unop,x.2.unop)
+  left_inv _ := rfl
+  right_inv _ := rfl
+  map_add' _ _ := rfl
+  map_mul' _ _ := rfl
+
+abbrev oppositeModule (M : ModuleCat.{v} (L × R)ᵐᵒᵖ) : ModuleCat.{v} (Lᵐᵒᵖ × Rᵐᵒᵖ) :=
+  (ModuleCat.restrictScalars (oppositeEquiv L R).symm.toRingHom).obj M
+
+attribute [local instance] RingHomInvPair.of_ringEquiv
+
+def oppositeModuleEquiv (M : ModuleCat.{v} (L × R)ᵐᵒᵖ) :
+    M ≃ₛₗ[RingHomClass.toRingHom (oppositeEquiv L R)] oppositeModule L R M where
+  toFun x := x
+  invFun x := x
+  left_inv _ := rfl
+  right_inv _ := rfl
+  map_add' _ _ := rfl
+  map_smul' _ _ := rfl
+
+variable [Small.{v} L] [Small.{v} R]
+
+theorem opposite_product_module_bound (n : ℕ)
+    (hL : ∀ M : ModuleCat.{v} Lᵐᵒᵖ, projectiveDimension M ≤ (n : ℕ))
+    (hR : ∀ M : ModuleCat.{v} Rᵐᵒᵖ, projectiveDimension M ≤ (n : ℕ))
+    (M : ModuleCat.{v} (L × R)ᵐᵒᵖ) : projectiveDimension M ≤ (n : ℕ) := by
+  let : Small.{v} Lᵐᵒᵖ := small_of_injective (@MulOpposite.unop_injective L)
+  let : Small.{v} Rᵐᵒᵖ := small_of_injective (@MulOpposite.unop_injective R)
+  let : Small.{v} (L × R)ᵐᵒᵖ := small_of_injective (@MulOpposite.unop_injective (L × R))
+  rw [ModuleCat.projectiveDimension_eq_of_semiLinearEquiv (oppositeEquiv L R) (oppositeModuleEquiv L R M)]
+  exact product_module_bound Lᵐᵒᵖ Rᵐᵒᵖ n hL hR (oppositeModule L R M)
+end LittleFinitistic.ProductModules
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryProductProjective.lean b/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryProductProjective.lean
new file mode 100644
index 0000000000000000000000000000000000000000..b2d90e9d5fe78cda06ae93c63c21b86b0e2afcaf
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryProductProjective.lean
@@ -0,0 +1,61 @@
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryProductComponent
+
+namespace OAI
+noncomputable section
+open CategoryTheory
+namespace LittleFinitistic.ProductModules
+universe u v
+variable (L R : Type u) [Ring L] [Ring R]
+
+abbrev firstInflation : ModuleCat.{v} L ⥤ ModuleCat.{v} (L × R) :=
+  ModuleCat.restrictScalars (RingHom.fst L R)
+
+variable {P : ModuleCat.{v} L} {M : ModuleCat.{v} (L × R)}
+
+def intoFirst (g : (firstInflation L R).obj P ⟶ M) : P ⟶ firstObject L R M :=
+  ModuleCat.ofHom
+    { toFun := fun x => ⟨g.hom x, by
+        have h := g.hom.map_smul ((1,0) : L × R) x
+        change g.hom ((1:L) • x) = ((1,0) : L × R) • g.hom x at h
+        rw [one_smul] at h
+        exact h.symm⟩
+      map_add' := fun x y => Subtype.ext (g.hom.map_add x y)
+      map_smul' := fun r x => Subtype.ext (g.hom.map_smul ((r,0) : L × R) x) }
+
+theorem firstSpace_product_smul (d : L × R) (x : firstSpace L R M) :
+    d • x.val = ((d.1,0) : L × R) • x.val := by
+  have he : d * ((1,0) : L × R) = (d.1,0) := by ext <;> simp
+  calc
+    d • x.val = d • (((1,0) : L × R) • x.val) := by rw [x.property]
+    _ = (d * ((1,0) : L × R)) • x.val := (mul_smul _ _ _).symm
+    _ = _ := by rw [he]
+
+def outOfFirst (g : P ⟶ firstObject L R M) : (firstInflation L R).obj P ⟶ M := by
+  letI : Module (L × R) P := Module.compHom P (RingHom.fst L R)
+  exact ModuleCat.ofHom (show (firstInflation L R).obj P →ₗ[L × R] M from
+    { toFun := fun x => (g.hom x).val
+      map_add' := fun x y => congrArg Subtype.val (g.hom.map_add x y)
+      map_smul' := fun d x => by
+        have h := congrArg Subtype.val (g.hom.map_smul d.1 x)
+        exact h.trans (firstSpace_product_smul L R d (g.hom x)).symm })
+
+/-- Inflation from one factor preserves actual projective objects. -/
+theorem firstInflation_projective (P : ModuleCat.{v} L) [Projective P] :
+    Projective ((firstInflation L R).obj P) := by
+  refine ⟨fun g E he => ?_⟩
+  let e : firstObject L R _ ⟶ firstObject L R _ := (firstFunctor L R).map E
+  let g' := intoFirst L R g
+  let : Epi e := (ModuleCat.epi_iff_surjective e).mpr
+    (firstMap_surjective L R E ((ModuleCat.epi_iff_surjective E).mp he))
+  let h := Projective.factorThru g' e
+  refine ⟨outOfFirst L R h,?_⟩
+  apply ModuleCat.hom_ext
+  apply LinearMap.ext
+  intro x
+  have hh := congrArg (fun f => f.hom x) (Projective.factorThru_comp g' e)
+  exact congrArg Subtype.val hh
+end LittleFinitistic.ProductModules
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryProductSecondDimension.lean b/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryProductSecondDimension.lean
new file mode 100644
index 0000000000000000000000000000000000000000..5417ee7150cf7974f6b4a416d9024feedf8fa3d8
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryProductSecondDimension.lean
@@ -0,0 +1,52 @@
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryProductDimension
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryProductSplitting
+import Mathlib.Algebra.Category.ModuleCat.Biproducts
+
+namespace OAI
+noncomputable section
+open CategoryTheory
+namespace LittleFinitistic.ProductModules
+universe u v
+variable (L R : Type u) [Ring L] [Ring R]
+
+attribute [local instance] RingHomInvPair.of_ringEquiv
+
+/-- Swapping product factors identifies the two actual inflation constructions. -/
+def swapInflationEquiv (P : ModuleCat.{v} R) :
+    (firstInflation R L).obj P ≃ₛₗ[RingHomClass.toRingHom (RingEquiv.prodComm : R × L ≃+* L × R)]
+      (secondInflation L R).obj P where
+  toFun x := x
+  invFun x := x
+  left_inv _ := rfl
+  right_inv _ := rfl
+  map_add' _ _ := rfl
+  map_smul' _ _ := rfl
+
+variable [Small.{v} L] [Small.{v} R]
+
+theorem secondInflation_dimensionLE (n : ℕ) (P : ModuleCat.{v} R) [HasProjectiveDimensionLE P n] :
+    HasProjectiveDimensionLE ((secondInflation L R).obj P) n := by
+  have := firstInflation_dimensionLE R L n P
+  exact ModuleCat.hasProjectiveDimensionLE_of_semiLinearEquiv
+    (RingEquiv.prodComm : R × L ≃+* L × R) (swapInflationEquiv L R P) n
+
+/-- Each module over the product has the same finite bound as its two factors. -/
+theorem product_module_bound (n : ℕ)
+    (hL : ∀ M : ModuleCat.{v} L, projectiveDimension M ≤ (n : ℕ))
+    (hR : ∀ M : ModuleCat.{v} R, projectiveDimension M ≤ (n : ℕ))
+    (M : ModuleCat.{v} (L × R)) : projectiveDimension M ≤ (n : ℕ) := by
+  have : HasProjectiveDimensionLE (firstObject L R M) n := (projectiveDimension_le_iff _ n).mp (hL _)
+  have : HasProjectiveDimensionLE (secondObject L R M) n := (projectiveDimension_le_iff _ n).mp (hR _)
+  have := firstInflation_dimensionLE L R n (firstObject L R M)
+  have := secondInflation_dimensionLE L R n (secondObject L R M)
+  let e := ModuleCat.biprodIsoProd ((firstInflation L R).obj (firstObject L R M))
+    ((secondInflation L R).obj (secondObject L R M))
+  have : HasProjectiveDimensionLT (pairObject L R M) (n+1) := hasProjectiveDimensionLT_of_iso e (n+1)
+  have : HasProjectiveDimensionLT M (n+1) :=
+    hasProjectiveDimensionLT_of_iso (splitting L R M).toModuleIso.symm (n+1)
+  exact (projectiveDimension_le_iff _ n).mpr inferInstance
+end LittleFinitistic.ProductModules
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryProductSplitting.lean b/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryProductSplitting.lean
new file mode 100644
index 0000000000000000000000000000000000000000..f8b6cd1e19180fd0ed2c53775521f561543865df
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryProductSplitting.lean
@@ -0,0 +1,101 @@
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryProductProjective
+import Mathlib.Algebra.Ring.Prod
+import Mathlib.Algebra.Category.ModuleCat.Limits
+import Mathlib.Tactic.Abel
+
+namespace OAI
+noncomputable section
+open CategoryTheory
+namespace LittleFinitistic.ProductModules
+universe u v
+variable (L R : Type u) [Ring L] [Ring R]
+
+abbrev secondInflation : ModuleCat.{v} R ⥤ ModuleCat.{v} (L × R) :=
+  ModuleCat.restrictScalars (RingHom.snd L R)
+
+abbrev swapModule (M : ModuleCat.{v} (L × R)) : ModuleCat.{v} (R × L) :=
+  (ModuleCat.restrictScalars (RingEquiv.prodComm : R × L ≃+* L × R).toRingHom).obj M
+
+abbrev secondObject (M : ModuleCat.{v} (L × R)) : ModuleCat.{v} R :=
+  firstObject R L (swapModule L R M)
+
+abbrev pairObject (M : ModuleCat.{v} (L × R)) : ModuleCat.{v} (L × R) := ModuleCat.of (L × R)
+  (((firstInflation L R).obj (firstObject L R M)) × ((secondInflation L R).obj (secondObject L R M)))
+
+variable (M : ModuleCat.{v} (L × R))
+
+def splitTo : M →ₗ[L × R] pairObject L R M where
+  toFun m := (⟨((1,0) : L × R) • m, by
+    change ((1,0) : L × R) • (((1,0) : L × R) • m) = ((1,0) : L × R) • m
+    rw [← mul_smul]
+    have h : ((1,0) : L × R) * (1,0) = (1,0) := by ext <;> simp
+    rw [h]⟩, ⟨((0,1) : L × R) • m, by
+    change ((0,1) : L × R) • (((0,1) : L × R) • m) = ((0,1) : L × R) • m
+    rw [← mul_smul]
+    have h : ((0,1) : L × R) * (0,1) = (0,1) := by ext <;> simp
+    rw [h]⟩)
+  map_add' x y := Prod.ext (Subtype.ext (smul_add _ _ _)) (Subtype.ext (smul_add _ _ _))
+  map_smul' d m := by
+    apply Prod.ext
+    · apply Subtype.ext
+      change ((1,0) : L × R) • (d • m) = ((d.1,0) : L × R) • (((1,0) : L × R) • m)
+      rw [← mul_smul,← mul_smul]
+      congr 1
+      ext <;> simp
+    · apply Subtype.ext
+      change ((0,1) : L × R) • (d • m) = ((0,d.2) : L × R) • (((0,1) : L × R) • m)
+      rw [← mul_smul,← mul_smul]
+      congr 1
+      ext <;> simp
+
+def joinTo : pairObject L R M →ₗ[L × R] M where
+  toFun x := x.1.val + (show M from x.2.val)
+  map_add' x y := by
+    change (x.1.val+y.1.val) + ((show M from x.2.val)+(show M from y.2.val)) =
+      (x.1.val+(show M from x.2.val)) + (y.1.val+(show M from y.2.val))
+    abel
+  map_smul' d x := by
+    have h₁ := firstSpace_product_smul L R d x.1
+    have h₂ := firstSpace_product_smul R L (M := swapModule L R M) (d.2,d.1) x.2
+    change ((d.1,0) : L × R) • x.1.val + ((0,d.2) : L × R) • (show M from x.2.val) = d • (x.1.val + (show M from x.2.val))
+    rw [smul_add,← h₁]
+    exact congrArg (fun y : swapModule L R M => d • x.1.val + (show M from y)) h₂.symm
+
+/-- Every module over a product ring splits into its two actual central-idempotent components. -/
+def splitting : M ≃ₗ[L × R] pairObject L R M where
+  __ := splitTo L R M
+  invFun := joinTo L R M
+  left_inv m := by
+    change ((1,0) : L × R) • m + ((0,1) : L × R) • m = m
+    rw [← add_smul]
+    have h : ((1,0) : L × R) + (0,1) = 1 := by ext <;> simp
+    rw [h,one_smul]
+  right_inv x := by
+    have h₁ : ((1,0) : L × R) • x.1.val = x.1.val := x.1.property
+    have h₂ : ((0,1) : L × R) • (show M from x.2.val) = (show M from x.2.val) := x.2.property
+    have hz₁ : ((0,1) : L × R) • x.1.val = 0 := by
+      calc
+        _ = ((0,1) : L × R) • (((1,0) : L × R) • x.1.val) := by rw [h₁]
+        _ = 0 := by
+          rw [← mul_smul]
+          have h : ((0,1) : L × R) * (1,0) = 0 := by ext <;> simp
+          rw [h,zero_smul]
+    have hz₂ : ((1,0) : L × R) • (show M from x.2.val) = 0 := by
+      calc
+        _ = ((1,0) : L × R) • (((0,1) : L × R) • (show M from x.2.val)) := by rw [h₂]
+        _ = 0 := by
+          rw [← mul_smul]
+          have h : ((1,0) : L × R) * (0,1) = 0 := by ext <;> simp
+          rw [h,zero_smul]
+    apply Prod.ext
+    · apply Subtype.ext
+      change ((1,0) : L × R) • (x.1.val + (show M from x.2.val)) = x.1.val
+      rw [smul_add,h₁,hz₂,add_zero]
+    · apply Subtype.ext
+      change ((0,1) : L × R) • (x.1.val + (show M from x.2.val)) = (show M from x.2.val)
+      rw [smul_add,hz₁,h₂,zero_add]
+end LittleFinitistic.ProductModules
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryProjectiveTensor.lean b/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryProjectiveTensor.lean
new file mode 100644
index 0000000000000000000000000000000000000000..fd25757e78343caff41f7a8a5d89cf61752a741f
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryProjectiveTensor.lean
@@ -0,0 +1,98 @@
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryFreeTensorExactness
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryFixedTensorFunctor
+import OAI.Algebra.Finitistic.Tensor.BalancedTensorMaps
+import Mathlib.Algebra.Module.Projective
+
+namespace OAI
+noncomputable section
+open CategoryTheory
+namespace LittleFinitistic.BalancedTensor
+universe u
+variable {k A M M' : Type u} [Field k] [Ring A] [Algebra k A]
+variable [AddCommGroup M] [Module k M] [Module Aᵐᵒᵖ M] [IsScalarTower k Aᵐᵒᵖ M]
+variable [AddCommGroup M'] [Module k M'] [Module Aᵐᵒᵖ M'] [IsScalarTower k Aᵐᵒᵖ M']
+variable {N N' N'' : Type u}
+variable [AddCommGroup N] [Module k N] [Module A N] [IsScalarTower k A N]
+variable [AddCommGroup N'] [Module k N'] [Module A N'] [IsScalarTower k A N']
+variable [AddCommGroup N''] [Module k N''] [Module A N''] [IsScalarTower k A N'']
+
+theorem mapLeft_mapRightTo (i : M →ₗ[Aᵐᵒᵖ] M') (f : N →ₗ[A] N') (z : Tensor k A M N) :
+    mapLeft N' i (mapRightTo f z) = mapRightTo f (mapLeft N i z) := by
+  induction z using BalancedTensor.induction_on with
+  | hz => simp only [map_zero]
+  | ht m n => rfl
+  | ha x y hx hy => simp only [map_add,hx,hy]
+
+omit [IsScalarTower k A N] in
+theorem mapLeft_split (i : M →ₗ[Aᵐᵒᵖ] M') (p : M' →ₗ[Aᵐᵒᵖ] M)
+    (hp : p.comp i = LinearMap.id) (z : Tensor k A M N) :
+    mapLeft N p (mapLeft N i z) = z := by
+  have hm := congrArg (fun f : Tensor k A M N →ₗ[k] Tensor k A M N => f z)
+    (mapLeft_comp (k := k) N i p).symm
+  simpa only [hp,mapLeft_id,LinearMap.id_apply,LinearMap.comp_apply] using hm
+
+/-- Exactness descends through an actual split right-module retract. -/
+theorem tensor_exact_of_split (i : M →ₗ[Aᵐᵒᵖ] M') (p : M' →ₗ[Aᵐᵒᵖ] M)
+    (hp : p.comp i = LinearMap.id) (f : N →ₗ[A] N') (g : N' →ₗ[A] N'')
+    (h : Function.Exact f g)
+    (h' : Function.Exact (mapRightTo (k := k) (M := M') f) (mapRightTo (k := k) (M := M') g)) :
+    Function.Exact (mapRightTo (k := k) (M := M) f) (mapRightTo (k := k) (M := M) g) := by
+  intro z
+  constructor
+  · intro hz
+    have hi : mapRightTo g (mapLeft N' i z) = 0 := by
+      rw [← mapLeft_mapRightTo,hz,map_zero]
+    obtain ⟨y,hy⟩ := (h' _).mp hi
+    refine ⟨mapLeft N p y, ?_⟩
+    rw [← mapLeft_mapRightTo,hy,mapLeft_split i p hp]
+  · rintro ⟨y,rfl⟩
+    induction y using BalancedTensor.induction_on with
+    | hz => simp only [map_zero]
+    | ht m n => rw [mapRightTo_mk,mapRightTo_mk,(h (f n)).mpr ⟨n,rfl⟩,map_zero]
+    | ha x y hx hy => simp only [map_add,hx,hy,add_zero]
+
+/-- Projectivity of the actual right module suffices, with no hypothesis on the left modules. -/
+theorem projectiveTensor_exact [Module.Projective Aᵐᵒᵖ M]
+    (f : N →ₗ[A] N') (g : N' →ₗ[A] N'') (h : Function.Exact f g) :
+    Function.Exact (mapRightTo (k := k) (M := M) f) (mapRightTo (k := k) (M := M) g) := by
+  obtain ⟨i,hi⟩ := (Module.projective_def' (R := Aᵐᵒᵖ) (P := M)).mp inferInstance
+  exact tensor_exact_of_split i (Finsupp.linearCombination Aᵐᵒᵖ id) hi f g h
+    (Free.tensor_exact (k := k) M f g h)
+
+variable (k A M)
+
+theorem projectiveTensor_mapsExact [Module.Projective Aᵐᵒᵖ M]
+    (S : ShortComplex (ModuleCat.{u} A)) (hS : S.Exact) :
+    (S.map (fixedTensorFunctor k A M)).Exact := by
+  rw [ShortComplex.moduleCat_exact_iff]
+  have h : Function.Exact
+      (S.f.hom : ScalarLeftModule k A S.X₁ →ₗ[A] ScalarLeftModule k A S.X₂)
+      (S.g.hom : ScalarLeftModule k A S.X₂ →ₗ[A] ScalarLeftModule k A S.X₃) := by
+    intro n
+    constructor
+    · exact (ShortComplex.moduleCat_exact_iff S).mp hS n
+    · rintro ⟨m,rfl⟩
+      exact congrArg (fun f => f.hom m) S.zero
+  have ht := @projectiveTensor_exact k A M _ _ _ _ _ _ _
+    (ScalarLeftModule k A S.X₁) (ScalarLeftModule k A S.X₂) (ScalarLeftModule k A S.X₃)
+    _ _ _ (scalarLeftTower k A S.X₁)
+    _ _ _ (scalarLeftTower k A S.X₂) _ _ _ (scalarLeftTower k A S.X₃)
+    _ S.f.hom S.g.hom h
+  intro z hz
+  exact (ht z).mp hz
+
+theorem projectiveTensor_preservesHomology [Module.Projective Aᵐᵒᵖ M] :
+    (fixedTensorFunctor k A M).PreservesHomology :=
+  Functor.preservesHomology_of_map_exact _ (projectiveTensor_mapsExact k A M)
+
+/-- Degree-zero projective tensor preserves quasi-isomorphisms of arbitrary complexes. -/
+theorem projectiveTensor_quasiIso [Module.Projective Aᵐᵒᵖ M]
+    {Z Z' : CochainComplex (ModuleCat.{u} A) ℤ} (f : Z ⟶ Z') [QuasiIso f] :
+    QuasiIso (((fixedTensorFunctor k A M).mapHomologicalComplex (.up ℤ)).map f) := by
+  let := projectiveTensor_preservesHomology k A M
+  infer_instance
+end LittleFinitistic.BalancedTensor
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryResolutionComplex.lean b/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryResolutionComplex.lean
new file mode 100644
index 0000000000000000000000000000000000000000..f6ecae24959b46b9236aad564f0faedd5d1eecfc
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryResolutionComplex.lean
@@ -0,0 +1,85 @@
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryTerminalResolution
+import Mathlib.Algebra.Homology.HomologicalComplex
+import Mathlib.Algebra.Category.ModuleCat.Projective
+import Mathlib.Algebra.Category.ModuleCat.Abelian
+
+namespace OAI
+noncomputable section
+open CategoryTheory Limits
+namespace LittleFinitistic.OrdinarySimulation.ChainAlgebra
+universe u
+variable (k : Type u) [Field k] (l : ℕ)
+
+/-- Extending the source idempotents by zero keeps all right ideals in the same C. -/
+def extendedVertex (n : ℕ) : ChainAlgebra k l :=
+  if h : n ≤ l then vertex k l ⟨n,by omega⟩ else 0
+
+def extendedArrow (n : ℕ) : ChainAlgebra k l :=
+  if h : n < l then arrow k l ⟨n,h⟩ else 0
+
+theorem extendedVertex_idempotent (n : ℕ) :
+    extendedVertex k l n * extendedVertex k l n = extendedVertex k l n := by
+  unfold extendedVertex
+  split
+  · exact vertex_idempotent k l _
+  · exact zero_mul _
+
+theorem extendedArrow_target (n : ℕ) :
+    extendedVertex k l (n+1) * extendedArrow k l n = extendedArrow k l n := by
+  by_cases h : n < l
+  · have h1 : n+1 ≤ l := by omega
+    simp only [extendedVertex, extendedArrow, dite_eq_left h, dite_eq_left h1]
+    exact vertex_target_arrow k l ⟨n,h⟩
+  · rw [extendedArrow, dite_eq_right h, mul_zero]
+
+theorem extendedArrow_square (n : ℕ) : extendedArrow k l (n+1) * extendedArrow k l n = 0 := by
+  by_cases h1 : n+1 < l
+  · have h0 : n < l := by omega
+    simp only [extendedArrow, dite_eq_left h1, dite_eq_left h0, arrow_mul_arrow]
+  · rw [extendedArrow, dite_eq_right h1, zero_mul]
+
+abbrev resolutionIdeal (n : ℕ) := IdempotentTensor.rightIdeal (extendedVertex k l n)
+abbrev resolutionTerm (n : ℕ) : ModuleCat.{u} (ChainAlgebra k l)ᵐᵒᵖ :=
+  ModuleCat.of _ (resolutionIdeal k l n)
+
+/-- Actual left-arrow differentials, with no transport of module types. -/
+def resolutionDifferential (n : ℕ) : resolutionTerm k l n ⟶ resolutionTerm k l (n+1) :=
+  ModuleCat.ofHom (((leftMultiply (extendedArrow k l n)).comp (resolutionIdeal k l n).subtype).codRestrict _
+    (fun x => by
+      change extendedVertex k l (n+1) * (extendedArrow k l n * x.val) = extendedArrow k l n * x.val
+      rw [← mul_assoc, extendedArrow_target]))
+
+theorem resolutionDifferential_square (n : ℕ) :
+    resolutionDifferential k l n ≫ resolutionDifferential k l (n+1) = 0 := by
+  ext x
+  change extendedArrow k l (n+1) * (extendedArrow k l n * x.val) = 0
+  rw [← mul_assoc, extendedArrow_square, zero_mul]
+
+/-- The source's projective complex, extended by zero after degree l. -/
+def terminalProjectiveComplex : CochainComplex (ModuleCat.{u} (ChainAlgebra k l)ᵐᵒᵖ) ℕ :=
+  CochainComplex.of (resolutionTerm k l) (resolutionDifferential k l) (resolutionDifferential_square k l)
+
+theorem resolutionTerm_projective (n : ℕ) : Projective (resolutionTerm k l n) := by
+  let : Module.Projective (ChainAlgebra k l)ᵐᵒᵖ (ChainAlgebra k l) := Module.Projective.of_equiv rightRegularEquiv
+  let r : ChainAlgebra k l →ₗ[(ChainAlgebra k l)ᵐᵒᵖ] resolutionIdeal k l n :=
+    (leftMultiply (extendedVertex k l n)).codRestrict _ (fun x => by
+      change extendedVertex k l n * (extendedVertex k l n * x) = extendedVertex k l n * x
+      rw [← mul_assoc, extendedVertex_idempotent])
+  have : Module.Projective (ChainAlgebra k l)ᵐᵒᵖ (resolutionIdeal k l n) :=
+    Module.Projective.of_split (resolutionIdeal k l n).subtype r (by ext x; exact x.property)
+  infer_instance
+
+theorem resolutionTerm_vanishes (n : ℕ) (h : l < n) : IsZero (resolutionTerm k l n) := by
+  apply ModuleCat.isZero_iff_subsingleton.mpr
+  have hz (x : resolutionIdeal k l n) : x = 0 := by
+    apply Subtype.ext
+    have hp := x.property
+    change extendedVertex k l n * x.val = x.val at hp
+    rw [extendedVertex, dite_eq_right (Nat.not_le.mpr h), zero_mul] at hp
+    exact hp.symm
+  exact ⟨fun x y => (hz x).trans (hz y).symm⟩
+end LittleFinitistic.OrdinarySimulation.ChainAlgebra
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryResolutionExact.lean b/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryResolutionExact.lean
new file mode 100644
index 0000000000000000000000000000000000000000..e4eeb7958c958c44e2c948e03b5e9c6b786936af
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryResolutionExact.lean
@@ -0,0 +1,69 @@
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryResolutionComplex
+import Mathlib.Algebra.Homology.ShortComplex.ModuleCat
+import Mathlib.Algebra.Homology.Single
+
+namespace OAI
+noncomputable section
+open CategoryTheory Limits
+namespace LittleFinitistic.OrdinarySimulation.ChainAlgebra
+universe u
+variable (k : Type u) [Field k] (l : ℕ)
+
+/-- In the supported range, the extended ideal is the source's actual right projective. -/
+def supportedIdealEquiv (n : ℕ) (h : n ≤ l) :
+    resolutionIdeal k l n ≃ₗ[(ChainAlgebra k l)ᵐᵒᵖ] rightTerm (k := k) (⟨n,by omega⟩ : Fin (l+1)) where
+  toFun x := ⟨x.val, by
+    have hp := x.property
+    change extendedVertex k l n * x.val = x.val at hp
+    change vertex k l ⟨n,by omega⟩ * x.val = x.val
+    simpa only [extendedVertex, dite_eq_left h] using hp⟩
+  invFun x := ⟨x.val, by
+    change extendedVertex k l n * x.val = x.val
+    rw [extendedVertex, dite_eq_left h]
+    exact x.property⟩
+  left_inv _ := rfl
+  right_inv _ := rfl
+  map_add' _ _ := rfl
+  map_smul' _ _ := rfl
+
+@[simp] theorem supportedIdealEquiv_d (n : ℕ) (h : n < l) (x : resolutionIdeal k l n) :
+    supportedIdealEquiv k l (n+1) (by omega) ((resolutionDifferential k l n).hom x) =
+      resolutionMap (k := k) ⟨n,h⟩ (supportedIdealEquiv k l n (by omega) x) := by
+  apply Subtype.ext
+  change extendedArrow k l n * x.val = arrow k l ⟨n,h⟩ * x.val
+  rw [extendedArrow, dite_eq_left h]
+
+/-- The actual bundled complex is exact at every interior degree. -/
+theorem supported_complex_exact (n : ℕ) (h : n+1 < l) :
+    (ShortComplex.mk (resolutionDifferential k l n) (resolutionDifferential k l (n+1))
+      (resolutionDifferential_square k l n)).Exact := by
+  rw [ShortComplex.moduleCat_exact_iff]
+  intro x hx
+  have hx' := congrArg (supportedIdealEquiv k l (n+2) (by omega)) hx
+  rw [supportedIdealEquiv_d k l (n+1) h, map_zero] at hx'
+  obtain ⟨y,hy⟩ := (resolution_exact (k := k) n h (supportedIdealEquiv k l (n+1) (by omega) x)).mp hx'
+  refine ⟨(supportedIdealEquiv k l n (by omega)).symm y, ?_⟩
+  apply (supportedIdealEquiv k l (n+1) (by omega)).injective
+  rw [supportedIdealEquiv_d k l n (by omega), LinearEquiv.apply_symm_apply, hy]
+
+/-- The actual augmentation of the bundled complex in its last degree. -/
+def resolutionAugmentation : resolutionTerm k l l ⟶ ModuleCat.of (ChainAlgebra k l)ᵐᵒᵖ (TerminalSimple k) :=
+  ModuleCat.ofHom ((augmentation k l).comp (supportedIdealEquiv k l l le_rfl).toLinearMap)
+
+/-- A genuine chain map to the terminal simple placed in degree l. -/
+def terminalAugmentationMap : terminalProjectiveComplex k l ⟶
+    (HomologicalComplex.single _ (.up ℕ) l).obj (ModuleCat.of (ChainAlgebra k l)ᵐᵒᵖ (TerminalSimple k)) :=
+  HomologicalComplex.mkHomToSingle (resolutionAugmentation k l) (by
+    intro i hi
+    change i+1=l at hi
+    subst l
+    change CochainComplex.of.d _ _ i (i+1) ≫ resolutionAugmentation k (i+1) = 0
+    rw [CochainComplex.of_d]
+    ext x
+    change (extendedArrow k (i+1) i * x.val).1 (Fin.last (i+1)) = (0:k)
+    rw [extendedArrow, dite_eq_left (by omega), mul_diagonal, arrow_diagonal, zero_mul])
+end LittleFinitistic.OrdinarySimulation.ChainAlgebra
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryResolutionModels.lean b/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryResolutionModels.lean
new file mode 100644
index 0000000000000000000000000000000000000000..8039a3bfaad4bc152a22219dbdfb5eab10b63dfc
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryResolutionModels.lean
@@ -0,0 +1,68 @@
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryBimoduleDerivedTensor
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryBimoduleTensorFunctor
+
+namespace OAI
+noncomputable section
+open CategoryTheory Limits
+open scoped TensorProduct
+namespace LittleFinitistic
+universe u
+
+/-- A finite model for tensoring a genuine bimodule complex, with its support and right projectivity proved. -/
+structure FiniteProjectiveBimoduleComplex (k S A : Type u) [Field k] [Ring S] [Ring A]
+    [Algebra k S] [Algebra k A] where
+  complex : CochainComplex (ModuleCat.{u} (S ⊗[k] Aᵐᵒᵖ)) ℤ
+  size : ℕ
+  degrees : Fin size → ℤ
+  strictMono : StrictMono degrees
+  support : ∀ n, n ∉ Set.range degrees → IsZero (complex.X n)
+  rightProjective : ∀ n, Module.Projective Aᵐᵒᵖ (BimoduleCoefficients k S A (complex.X n))
+
+namespace FiniteProjectiveBimoduleComplex
+variable {k S A : Type u} [Field k] [Ring S] [Ring A] [Algebra k S] [Algebra k A]
+variable (Q : FiniteProjectiveBimoduleComplex k S A)
+
+instance rightTerm_projective (n : ℤ) : Module.Projective Aᵐᵒᵖ
+    (ComplexTensor.rightTerm k A (BimoduleComplexTensor.rightComplex k S A Q.complex) n) := Q.rightProjective n
+
+abbrev tensorFunctor := BimoduleComplexTensor.totalFunctor k S A Q.complex Q.degrees Q.strictMono
+
+/-- The certified model inverts every input quasi-isomorphism; no condition is placed on the input complex. -/
+theorem tensorFunctor_quasiIso {Z Z' : CochainComplex (ModuleCat.{u} A) ℤ} (f : Z ⟶ Z') [QuasiIso f] :
+    QuasiIso (Q.tensorFunctor.map f) :=
+  BimoduleComplexTensor.totalFunctor_quasiIso k S A Q.complex Q.degrees Q.strictMono f
+
+variable [HasDerivedCategory.{u+1} (ModuleCat.{u} A)] [HasDerivedCategory.{u+1} (ModuleCat.{u} S)]
+
+def derivedTensor : DerivedCategory (ModuleCat.{u} A) ⥤ DerivedCategory (ModuleCat.{u} S) :=
+  BimoduleComplexTensor.derivedTotal k S A Q.complex Q.degrees Q.strictMono
+
+def comparison : DerivedCategory.Q ⋙ Q.derivedTensor ≅ Q.tensorFunctor ⋙ DerivedCategory.Q :=
+  BimoduleComplexTensor.derivedTotalComparison k S A Q.complex Q.degrees Q.strictMono
+end FiniteProjectiveBimoduleComplex
+
+/-- A genuine ordinary bimodule supplied with an actual bounded right-projective resolution. -/
+structure BoundedBimoduleResolution (k S A : Type u) [Field k] [Ring S] [Ring A]
+    [Algebra k S] [Algebra k A] (M : ModuleCat.{u} (S ⊗[k] Aᵐᵒᵖ)) extends FiniteProjectiveBimoduleComplex k S A where
+  augmentation : complex ⟶ (HomologicalComplex.single _ (.up ℤ) 0).obj M
+  augmentation_quasiIso : QuasiIso augmentation
+
+namespace BoundedBimoduleResolution
+variable {k S A : Type u} [Field k] [Ring S] [Ring A] [Algebra k S] [Algebra k A]
+variable {M : ModuleCat.{u} (S ⊗[k] Aᵐᵒᵖ)} (Q : BoundedBimoduleResolution k S A M)
+variable (B N : Type u) [Ring B] [Algebra k B]
+variable [AddCommGroup N] [Module k N] [Module A N] [Module Bᵐᵒᵖ N]
+  [IsScalarTower k A N] [IsScalarTower k Bᵐᵒᵖ N] [SMulCommClass A Bᵐᵒᵖ N]
+local instance : SMulCommClass Bᵐᵒᵖ A N := ⟨fun b a n => (smul_comm a b n).symm⟩
+variable [HasDerivedCategory.{u+1} (ModuleCat.{u} (S ⊗[k] Bᵐᵒᵖ))]
+
+/-- The resolved ordinary tensor object, in the native derived category retaining both outside actions.
+The resolution, its quasi-isomorphism, finite support and right projectivity are fields of Q. -/
+def tensorOrdinary : DerivedCategory (ModuleCat.{u} (S ⊗[k] Bᵐᵒᵖ)) :=
+  DerivedCategory.Q.obj (((bimoduleTensorFunctor k S A Bᵐᵒᵖ N).mapHomologicalComplex (.up ℤ)).obj Q.complex)
+end BoundedBimoduleResolution
+end LittleFinitistic
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryResolutionQuasiIso.lean b/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryResolutionQuasiIso.lean
new file mode 100644
index 0000000000000000000000000000000000000000..f3fe2fb33319532b76fa2df1da4771b2f820b0f1
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryResolutionQuasiIso.lean
@@ -0,0 +1,155 @@
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryResolutionExact
+import Mathlib.Algebra.Homology.QuasiIso
+
+namespace OAI
+noncomputable section
+open CategoryTheory Limits
+namespace LittleFinitistic.OrdinarySimulation.ChainAlgebra
+universe u
+variable (k : Type u) [Field k] (l : ℕ)
+
+theorem resolutionInitial_injective (h : 0 < l) :
+    Function.Injective (resolutionDifferential k l 0).hom := by
+  intro x y hxy
+  apply (supportedIdealEquiv k l 0 (by omega)).injective
+  apply resolution_first_injective (k := k) h
+  rw [← supportedIdealEquiv_d k l 0 h, ← supportedIdealEquiv_d k l 0 h, hxy]
+
+/-- Exactness in every degree except the terminal homology degree. -/
+theorem terminalProjectiveComplex_exactAt (n : ℕ) (hn : n ≠ l) :
+    (terminalProjectiveComplex k l).ExactAt n := by
+  by_cases h : l < n
+  · exact HomologicalComplex.ExactAt.of_isZero (resolutionTerm_vanishes k l n h)
+  have hnl : n < l := by omega
+  cases n with
+  | zero =>
+    rw [HomologicalComplex.exactAt_iff, ShortComplex.moduleCat_exact_iff]
+    intro x hx
+    have hx' : (resolutionDifferential k l 0).hom x = 0 := by
+      change ((terminalProjectiveComplex k l).d 0 ((ComplexShape.up ℕ).next 0)).hom x = 0 at hx
+      rw [show (ComplexShape.up ℕ).next 0 = 1 by simp] at hx
+      change (CochainComplex.of.d (resolutionTerm k l) (resolutionDifferential k l) 0 (0+1)).hom x = 0 at hx
+      rw [CochainComplex.of_d] at hx
+      exact hx
+    have hx0 : x = 0 := resolutionInitial_injective k l hnl (hx'.trans (map_zero _).symm)
+    refine ⟨0, ?_⟩
+    simp only [hx0, map_zero]
+  | succ n =>
+    apply (HomologicalComplex.exactAt_iff' _ n (n+1) (n+2) (by simp) (by simp)).2
+    change (ShortComplex.mk (CochainComplex.of.d _ _ n (n+1)) (CochainComplex.of.d _ _ (n+1) ((n+1)+1)) _).Exact
+    simpa only [CochainComplex.of_d] using supported_complex_exact k l n hnl
+
+theorem resolutionAugmentation_surjective : Function.Surjective (resolutionAugmentation k l).hom :=
+  (augmentation_surjective k l).comp (supportedIdealEquiv k l l le_rfl).surjective
+
+instance resolutionAugmentation_epi : Epi (resolutionAugmentation k l) :=
+  (ModuleCat.epi_iff_surjective _).mpr (resolutionAugmentation_surjective k l)
+
+theorem resolutionAugmentation_comp (n : ℕ) :
+    resolutionDifferential k (n+1) n ≫ resolutionAugmentation k (n+1) = 0 := by
+  ext x
+  change (extendedArrow k (n+1) n * x.val).1 (Fin.last (n+1)) = (0:k)
+  rw [extendedArrow, dite_eq_left (by omega), mul_diagonal, arrow_diagonal, zero_mul]
+
+theorem resolutionAugmentation_exact (n : ℕ) :
+    (ShortComplex.mk (resolutionDifferential k (n+1) n) (resolutionAugmentation k (n+1))
+      (resolutionAugmentation_comp k n)).Exact := by
+  rw [ShortComplex.moduleCat_exact_iff]
+  intro x hx
+  have hx' : augmentation k (n+1) (supportedIdealEquiv k (n+1) (n+1) le_rfl x) = 0 := hx
+  obtain ⟨y,hy⟩ := (augmentation_exact k n _).mp hx'
+  refine ⟨(supportedIdealEquiv k (n+1) n (by omega)).symm y, ?_⟩
+  apply (supportedIdealEquiv k (n+1) (n+1) le_rfl).injective
+  rw [supportedIdealEquiv_d k (n+1) n (by omega), LinearEquiv.apply_symm_apply]
+  exact hy
+
+theorem resolutionAugmentation_zero_injective :
+    Function.Injective (resolutionAugmentation k 0).hom :=
+  (augmentation_zero_injective k).comp (supportedIdealEquiv k 0 0 le_rfl).injective
+
+theorem resolutionDifferential_last_zero : resolutionDifferential k l l = 0 := by
+  ext x
+  change extendedArrow k l l * x.val = 0
+  rw [extendedArrow, dite_eq_right (lt_irrefl l), zero_mul]
+
+/-- Postcomposing a short complex's second map by an isomorphism preserves exactness. -/
+theorem exact_post_iso {R : Type u} [Ring R] {X Y Z Z' : ModuleCat.{u} R}
+    (f : X ⟶ Y) (g : Y ⟶ Z) (hfg : f ≫ g = 0) (e : Z ≅ Z')
+    (h : (ShortComplex.mk f g hfg).Exact) :
+    (ShortComplex.mk f (g ≫ e.hom) (by rw [← Category.assoc, hfg, zero_comp])).Exact := by
+  rw [ShortComplex.moduleCat_exact_iff] at h ⊢
+  intro x hx
+  apply h x
+  apply (ModuleCat.mono_iff_injective e.hom).mp inferInstance
+  exact hx.trans (map_zero _).symm
+
+/-- The augmentation is a quasi-isomorphism at the terminal degree. -/
+theorem terminalAugmentationMap_quasiIsoAt_last :
+    QuasiIsoAt (terminalAugmentationMap k l) l := by
+  rw [quasiIsoAt_iff]
+  refine (ShortComplex.quasiIso_iff_of_zeros' _ ?_ ?_ ?_).2 ?_
+  · change (terminalProjectiveComplex k l).d l ((ComplexShape.up ℕ).next l) = 0
+    rw [show (ComplexShape.up ℕ).next l = l+1 by simp]
+    change CochainComplex.of.d (resolutionTerm k l) (resolutionDifferential k l) l (l+1) = 0
+    rw [CochainComplex.of_d]
+    exact resolutionDifferential_last_zero k l
+  · exact HomologicalComplex.single_obj_d (.up ℕ) l (ModuleCat.of (ChainAlgebra k l)ᵐᵒᵖ (TerminalSimple k)) ((ComplexShape.up ℕ).prev l) l
+  · exact HomologicalComplex.single_obj_d (.up ℕ) l (ModuleCat.of (ChainAlgebra k l)ᵐᵒᵖ (TerminalSimple k)) l ((ComplexShape.up ℕ).next l)
+  · change (ShortComplex.mk ((terminalProjectiveComplex k l).d ((ComplexShape.up ℕ).prev l) l)
+        ((terminalAugmentationMap k l).f l) _).Exact ∧ Epi ((terminalAugmentationMap k l).f l)
+    have hf : (terminalAugmentationMap k l).f l = resolutionAugmentation k l ≫
+        (HomologicalComplex.singleObjXSelf (.up ℕ) l
+          (ModuleCat.of (ChainAlgebra k l)ᵐᵒᵖ (TerminalSimple k))).inv := by
+      unfold terminalAugmentationMap
+      apply HomologicalComplex.mkHomToSingle_f
+    simp only [hf]
+    constructor
+    · refine exact_post_iso _ _ ?_
+        (HomologicalComplex.singleObjXSelf (.up ℕ) l
+          (ModuleCat.of (ChainAlgebra k l)ᵐᵒᵖ (TerminalSimple k))).symm ?_
+      · cases l with
+        | zero =>
+          have hz := (terminalProjectiveComplex k 0).shape ((ComplexShape.up ℕ).prev 0) 0 (by simp)
+          erw [hz, zero_comp]
+        | succ n =>
+          rw [show (ComplexShape.up ℕ).prev (n+1) = n by simp]
+          simp only [terminalProjectiveComplex, CochainComplex.of_d]
+          convert resolutionAugmentation_comp k n using 1
+          rfl
+      cases l with
+      | zero =>
+        rw [ShortComplex.moduleCat_exact_iff]
+        intro x hx
+        have hx' : (resolutionAugmentation k 0).hom x = 0 := hx
+        have hx0 : x = 0 := resolutionAugmentation_zero_injective k (hx'.trans (map_zero _).symm)
+        refine ⟨0, ?_⟩
+        simp only [hx0, map_zero]
+      | succ n =>
+        rw [ShortComplex.moduleCat_exact_iff]
+        intro x hx
+        obtain ⟨y, hy⟩ := (ShortComplex.moduleCat_exact_iff _).mp
+          (resolutionAugmentation_exact k n) x hx
+        change ∃ z : resolutionTerm k (n+1) ((ComplexShape.up ℕ).prev (n+1)),
+          (CochainComplex.of.d (resolutionTerm k (n+1)) (resolutionDifferential k (n+1))
+            ((ComplexShape.up ℕ).prev (n+1)) (n+1)).hom z = x
+        rw [show (ComplexShape.up ℕ).prev (n+1) = n by simp]
+        exact ⟨y, by simpa only [CochainComplex.of_d] using hy⟩
+    · erw [ModuleCat.epi_iff_surjective]
+      exact ((ModuleCat.epi_iff_surjective _).mp (inferInstance : Epi
+        (HomologicalComplex.singleObjXSelf (.up ℕ) l
+          (ModuleCat.of (ChainAlgebra k l)ᵐᵒᵖ (TerminalSimple k))).inv)).comp
+        (resolutionAugmentation_surjective k l)
+
+/-- The source's finite projective resolution now has its actual augmentation quasi-isomorphism. -/
+theorem terminalAugmentationMap_quasiIso : QuasiIso (terminalAugmentationMap k l) := by
+  constructor
+  intro n
+  by_cases hn : n = l
+  · subst n; exact terminalAugmentationMap_quasiIsoAt_last k l
+  · apply (quasiIsoAt_iff_exactAt' _ n ?_).2 (terminalProjectiveComplex_exactAt k l n hn)
+    exact HomologicalComplex.ExactAt.of_isZero (HomologicalComplex.isZero_single_obj_X _ _ _ _ hn)
+end LittleFinitistic.OrdinarySimulation.ChainAlgebra
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryRestrictionHomology.lean b/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryRestrictionHomology.lean
new file mode 100644
index 0000000000000000000000000000000000000000..6eb5a8d2c74de5e1bd0dfda79fe2046c122a2451
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryRestrictionHomology.lean
@@ -0,0 +1,30 @@
+import Mathlib.Algebra.Category.ModuleCat.ChangeOfRings
+import Mathlib.Algebra.Homology.ShortComplex.ModuleCat
+import Mathlib.Algebra.Homology.ShortComplex.PreservesHomology
+import Mathlib.Algebra.Homology.QuasiIso
+
+namespace OAI
+noncomputable section
+open CategoryTheory
+namespace LittleFinitistic.RestrictionHomology
+universe u v
+variable {R S : Type u} [Ring R] [Ring S] (f : R →+* S)
+
+theorem mapsExact (K : ShortComplex (ModuleCat.{u} S)) (hK : K.Exact) :
+    (K.map (ModuleCat.restrictScalars f)).Exact := by
+  rw [ShortComplex.moduleCat_exact_iff] at hK ⊢
+  exact hK
+
+theorem preservesHomology : (ModuleCat.restrictScalars.{u} f).PreservesHomology :=
+  CategoryTheory.Functor.preservesHomology_of_map_exact _ (mapsExact f)
+
+theorem quasiIso_iff {I : Type v} {c : ComplexShape I}
+    {K L : HomologicalComplex (ModuleCat.{u} S) c} (g : K ⟶ L) :
+    QuasiIso (((ModuleCat.restrictScalars f).mapHomologicalComplex c).map g) ↔ QuasiIso g := by
+  let := preservesHomology f
+  exact HomologicalComplex.quasiIso_map_iff_of_preservesHomology g (ModuleCat.restrictScalars f)
+end LittleFinitistic.RestrictionHomology
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryRetainedBimodule.lean b/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryRetainedBimodule.lean
new file mode 100644
index 0000000000000000000000000000000000000000..ec4d9ab7a105dc54a6eece0f062e7c90b26cf132
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryRetainedBimodule.lean
@@ -0,0 +1,57 @@
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryBimoduleCoefficients
+
+namespace OAI
+noncomputable section
+open scoped TensorProduct
+namespace LittleFinitistic
+universe u
+/-- An ordinary bimodule packaged as a module over its actual tensor algebra. -/
+def RetainedBimodule (_k _S _A M : Type u) := M
+namespace RetainedBimodule
+variable (k S A M : Type u) [Field k] [Ring S] [Ring A] [Algebra k S] [Algebra k A]
+variable [AddCommGroup M] [Module k M] [Module S M] [Module Aᵐᵒᵖ M]
+  [IsScalarTower k S M] [IsScalarTower k Aᵐᵒᵖ M] [SMulCommClass S Aᵐᵒᵖ M]
+instance : AddCommGroup (RetainedBimodule k S A M) := inferInstanceAs (AddCommGroup M)
+instance : Module k (RetainedBimodule k S A M) := inferInstanceAs (Module k M)
+instance : Module S (RetainedBimodule k S A M) := inferInstanceAs (Module S M)
+instance : Module Aᵐᵒᵖ (RetainedBimodule k S A M) := inferInstanceAs (Module Aᵐᵒᵖ M)
+instance : IsScalarTower k S (RetainedBimodule k S A M) := inferInstanceAs (IsScalarTower k S M)
+instance : IsScalarTower k Aᵐᵒᵖ (RetainedBimodule k S A M) := inferInstanceAs (IsScalarTower k Aᵐᵒᵖ M)
+instance : SMulCommClass S Aᵐᵒᵖ (RetainedBimodule k S A M) := inferInstanceAs (SMulCommClass S Aᵐᵒᵖ M)
+
+
+def action : (S ⊗[k] Aᵐᵒᵖ) →ₐ[k] Module.End k (RetainedBimodule k S A M) :=
+  show (S ⊗[k] Aᵐᵒᵖ) →ₐ[k] Module.End k M from
+  Algebra.TensorProduct.lift (Algebra.lsmul k k M) (Algebra.lsmul k k M) (by
+    intro s a
+    ext m
+    exact smul_comm s a (m : M))
+instance : Module (S ⊗[k] Aᵐᵒᵖ) (RetainedBimodule k S A M) := Module.compHom _ (action k S A M).toRingHom
+instance tower : IsScalarTower k (S ⊗[k] Aᵐᵒᵖ) (RetainedBimodule k S A M) where
+  smul_assoc r x m := by
+    change action k S A M (r • x) m = r • action k S A M x m
+    rw [map_smul]
+    rfl
+
+variable {k S A M} {M' : Type u}
+variable [AddCommGroup M'] [Module k M'] [Module S M'] [Module Aᵐᵒᵖ M']
+  [IsScalarTower k S M'] [IsScalarTower k Aᵐᵒᵖ M'] [SMulCommClass S Aᵐᵒᵖ M']
+
+def map (f : M →ₗ[Aᵐᵒᵖ] M') (hf : ∀ (s : S) m, f (s • m) = s • f m) :
+    RetainedBimodule k S A M →ₗ[S ⊗[k] Aᵐᵒᵖ] RetainedBimodule k S A M' where
+  __ := f.toAddHom
+  map_smul' x m := by
+    change f (action k S A M x m) = action k S A M' x (f m)
+    induction x using TensorProduct.inductionOn with
+    | tmul s a =>
+      change f (s • (a • (m : M))) = s • (a • f (m : M))
+      exact (hf s (a • (m : M))).trans (congrArg (s • ·) (f.map_smul a (m : M)))
+    | add x y hx hy =>
+      rw [map_add, map_add]
+      exact (f.map_add _ _).trans (congrArg₂ (· + ·) hx hy)
+end RetainedBimodule
+end LittleFinitistic
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryRetainedCongruence.lean b/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryRetainedCongruence.lean
new file mode 100644
index 0000000000000000000000000000000000000000..6d3af8c5227242580e9d8a1ff7eb001fadac7bdb
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryRetainedCongruence.lean
@@ -0,0 +1,42 @@
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryRetainedRestriction
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryOffDiagonalMaps
+
+namespace OAI
+noncomputable section
+open scoped TensorProduct
+namespace LittleFinitistic.RetainedBimodule
+universe u
+variable {k S A M N : Type u} [Field k] [Ring S] [Ring A] [Algebra k S] [Algebra k A]
+variable [AddCommGroup M] [Module k M] [Module S M] [Module Aᵐᵒᵖ M]
+  [IsScalarTower k S M] [IsScalarTower k Aᵐᵒᵖ M] [SMulCommClass S Aᵐᵒᵖ M]
+variable [AddCommGroup N] [Module k N] [Module S N] [Module Aᵐᵒᵖ N]
+  [IsScalarTower k S N] [IsScalarTower k Aᵐᵒᵖ N] [SMulCommClass S Aᵐᵒᵖ N]
+
+/-- An actual right-linear, left-equivariant equivalence retains both actions. -/
+def congr (f : M ≃ₗ[Aᵐᵒᵖ] N) (hf : ∀ (s : S) x, f (s • x) = s • f x) :
+    RetainedBimodule k S A M ≃ₗ[S ⊗[k] Aᵐᵒᵖ] RetainedBimodule k S A N where
+  __ := map (k := k) f.toLinearMap hf
+  invFun := f.symm
+  left_inv := f.left_inv
+  right_inv := f.right_inv
+end LittleFinitistic.RetainedBimodule
+namespace LittleFinitistic.OrdinarySimulation.OffDiagonal
+universe u
+variable {L R O O' T T' : Type u} [Ring L] [Ring R]
+variable [AddCommGroup O] [AddCommGroup O'] [AddCommGroup T] [AddCommGroup T']
+variable [Module Lᵐᵒᵖ O] [Module Lᵐᵒᵖ O'] [Module Rᵐᵒᵖ T] [Module Rᵐᵒᵖ T']
+
+def congr (f : O ≃ₗ[Lᵐᵒᵖ] O') (g : T ≃ₗ[Rᵐᵒᵖ] T') :
+    OffDiagonal O T ≃ₗ[(L × R)ᵐᵒᵖ] OffDiagonal O' T' where
+  toFun x := (f x.1,g x.2)
+  invFun x := (f.symm x.1,g.symm x.2)
+  left_inv x := Prod.ext (f.left_inv x.1) (g.left_inv x.2)
+  right_inv x := Prod.ext (f.right_inv x.1) (g.right_inv x.2)
+  map_add' left right := Prod.ext (f.map_add left.1 right.1) (g.map_add left.2 right.2)
+  map_smul' d x := Prod.ext (f.map_smul (MulOpposite.op d.unop.1) x.1)
+    (g.map_smul (MulOpposite.op d.unop.2) x.2)
+end LittleFinitistic.OrdinarySimulation.OffDiagonal
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryRetainedRestriction.lean b/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryRetainedRestriction.lean
new file mode 100644
index 0000000000000000000000000000000000000000..3c9d4639c683d4e0e919d968e7836e0a683612f1
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryRetainedRestriction.lean
@@ -0,0 +1,54 @@
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryRetainedBimodule
+import Mathlib.Algebra.Category.ModuleCat.ChangeOfRings
+
+namespace OAI
+noncomputable section
+open CategoryTheory
+open scoped TensorProduct
+namespace LittleFinitistic.RetainedBimodule
+universe u
+variable (k S A M : Type u) [Field k] [Ring S] [Ring A] [Algebra k S] [Algebra k A]
+variable [AddCommGroup M] [Module k M] [Module S M] [Module Aᵐᵒᵖ M]
+  [IsScalarTower k S M] [IsScalarTower k Aᵐᵒᵖ M] [SMulCommClass S Aᵐᵒᵖ M]
+
+abbrev object : ModuleCat.{u} (S ⊗[k] Aᵐᵒᵖ) := ModuleCat.of _ (RetainedBimodule k S A M)
+
+/-- Recover the exact original right action after packaging the ordinary bimodule. -/
+def rightEquiv : BimoduleCoefficients k S A (object k S A M) ≃ₗ[Aᵐᵒᵖ] M where
+  toFun x := x
+  invFun x := x
+  left_inv _ := rfl
+  right_inv _ := rfl
+  map_add' _ _ := rfl
+  map_smul' r x := by
+    change action k S A M ((1:S) ⊗ₜ[k] r) x = _
+    unfold action
+    erw [Algebra.TensorProduct.lift_tmul]
+    change (1:S) • (r • (show M from x)) = r • (show M from x)
+    exact one_smul _ _
+
+theorem rightEquiv_left (s : S) (x : BimoduleCoefficients k S A (object k S A M)) :
+    rightEquiv k S A M (s • x) = s • rightEquiv k S A M x := by
+  change action k S A M (s ⊗ₜ[k] (1:Aᵐᵒᵖ)) x = _
+  unfold action
+  erw [Algebra.TensorProduct.lift_tmul]
+  change s • ((1:Aᵐᵒᵖ) • (show M from x)) = s • (show M from x)
+  rw [one_smul]
+
+/-- Recover the exact original scalar module after retaining both actions. -/
+def scalarEquiv : (ModuleCat.restrictScalars (algebraMap k (S ⊗[k] Aᵐᵒᵖ))).obj
+    (object k S A M) ≃ₗ[k] M where
+  toFun x := x
+  invFun x := x
+  left_inv _ := rfl
+  right_inv _ := rfl
+  map_add' _ _ := rfl
+  map_smul' r x := by
+    have h (y : RetainedBimodule k S A M) :
+        (algebraMap k (S ⊗[k] Aᵐᵒᵖ) r) • y = r • y := algebraMap_smul _ r y
+    exact h x
+end LittleFinitistic.RetainedBimodule
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryRightProjective.lean b/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryRightProjective.lean
new file mode 100644
index 0000000000000000000000000000000000000000..88da1bb04e7a12a8aa0e6f308b46714d452e4821
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryRightProjective.lean
@@ -0,0 +1,36 @@
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryBimodule
+import Mathlib.Algebra.Module.Projective
+import Mathlib.LinearAlgebra.DFinsupp
+
+namespace OAI
+noncomputable section
+namespace LittleFinitistic.OrdinarySimulation
+universe u v w
+
+/-- The finite direct sum of actual projective terms is projective. -/
+theorem finitePi_projective {R : Type u} [Ring R] {ι : Type v} [Fintype ι]
+    (V : ι → Type w) [∀ i, AddCommGroup (V i)] [∀ i, Module R (V i)]
+    [∀ i, Module.Projective R (V i)] : Module.Projective R (∀ i, V i) :=
+  Module.Projective.of_equiv (DFinsupp.linearEquivFunOnFintype (R := R) (M := V))
+
+open CategoryTheory
+variable {k B : Type u} [Field k] [Ring B] [Algebra k B]
+
+/-- The actual underlying right-B complex of the genuine dg bimodule. -/
+abbrev underlyingRightComplex (P : CochainComplex (ModuleCat.{u} (Enveloping k B)) ℤ) :
+    CochainComplex (ModuleCat.{u} Bᵐᵒᵖ) ℤ :=
+  ((ModuleCat.restrictScalars
+    (Algebra.TensorProduct.includeRight (R := k) (A := B) (B := Bᵐᵒᵖ)).toRingHom).mapHomologicalComplex (.up ℤ)).obj P
+
+theorem ordinaryO_right_projective (P : CochainComplex (ModuleCat.{u} (Enveloping k B)) ℤ)
+    (a : ℤ) (l : ℕ)
+    [∀ n, Module.Projective Bᵐᵒᵖ ((underlyingRightComplex P).X n)] :
+    Module.Projective Bᵐᵒᵖ (BimoduleO P a l) := by
+  let V : Fin (l+1) → Type u := fun i => (underlyingRightComplex P).X (a+(i.val:ℤ))
+  have : Module.Projective Bᵐᵒᵖ (∀ i, V i) := finitePi_projective V
+  exact Module.Projective.of_equiv (show (∀ i, V i) ≃ₗ[Bᵐᵒᵖ] BimoduleO P a l from LinearEquiv.refl _ _)
+end LittleFinitistic.OrdinarySimulation
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Ordinary/OrdinarySecondBlockTensor.lean b/lean/OAI/Algebra/Finitistic/Ordinary/OrdinarySecondBlockTensor.lean
new file mode 100644
index 0000000000000000000000000000000000000000..2a24c5ffa6e1cd9a189b20a7e5936033d793c94e
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Ordinary/OrdinarySecondBlockTensor.lean
@@ -0,0 +1,102 @@
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryBlockModules
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryBalancedCongruence
+
+namespace OAI
+noncomputable section
+namespace LittleFinitistic.OrdinarySimulation.SecondBlockTensor
+universe u
+variable (k L R O T Z : Type u) [Field k] [Ring L] [Ring R] [Algebra k L] [Algebra k R]
+variable [AddCommGroup O] [Module k O] [Module R O] [Module Lᵐᵒᵖ O]
+  [IsScalarTower k R O] [IsScalarTower k Lᵐᵒᵖ O] [SMulCommClass R Lᵐᵒᵖ O]
+variable [AddCommGroup T] [Module k T] [Module L T] [Module Rᵐᵒᵖ T]
+  [IsScalarTower k L T] [IsScalarTower k Rᵐᵒᵖ T] [SMulCommClass L Rᵐᵒᵖ T]
+variable [AddCommGroup Z] [Module k Z] [Module R Z] [IsScalarTower k R Z]
+
+abbrev source := LeftTensor k (L × R) (L × R) (OffDiagonal O T) (BlockModule.Second k L R Z)
+abbrev target := BlockModule.First k L R (LeftTensor k R L T Z)
+
+def forward : source k L R O T Z →ₗ[k] target k L R T Z :=
+  BalancedTensor.lift ((BalancedTensor.mk k R T Z).compl₁₂
+    (show OffDiagonal O T →ₗ[k] T from LinearMap.snd k O T)
+    (show BlockModule.Second k L R Z →ₗ[k] Z from LinearMap.id)) (by
+      intro d x z
+      exact BalancedTensor.balance (k := k) (A := R) (M := T) (N := Z) d.2 x.2 (show Z from z))
+
+def inverse : target k L R T Z →ₗ[k] source k L R O T Z :=
+  BalancedTensor.lift ((BalancedTensor.mk k (L × R) (OffDiagonal O T) (BlockModule.Second k L R Z)).compl₁₂
+    (show T →ₗ[k] OffDiagonal O T from LinearMap.inr k O T)
+    (show Z →ₗ[k] BlockModule.Second k L R Z from LinearMap.id)) (by
+      intro a t z
+      have h := BalancedTensor.balance (k := k) (A := L × R) (M := OffDiagonal O T)
+        (N := BlockModule.Second k L R Z) (0,a) (0,t) z
+      change BalancedTensor.mk k (L × R) (OffDiagonal O T) (BlockModule.Second k L R Z)
+          ((0:Lᵐᵒᵖ) • (0:O),MulOpposite.op a • t) (show BlockModule.Second k L R Z from z) =
+        BalancedTensor.mk k (L × R) (OffDiagonal O T) (BlockModule.Second k L R Z) (0,t)
+          (show BlockModule.Second k L R Z from a • z) at h
+      rw [smul_zero] at h
+      exact h)
+
+omit [Algebra k L] [Algebra k R] [Module R O] [IsScalarTower k R O]
+  [IsScalarTower k Lᵐᵒᵖ O] [SMulCommClass R Lᵐᵒᵖ O] [Module L T]
+  [IsScalarTower k L T] [IsScalarTower k Rᵐᵒᵖ T] [SMulCommClass L Rᵐᵒᵖ T]
+  [IsScalarTower k R Z] in
+theorem other_block_zero (o : O) (z : BlockModule.Second k L R Z) :
+    BalancedTensor.mk k (L × R) (OffDiagonal O T) (BlockModule.Second k L R Z) (o,0) z = 0 := by
+  have h := BalancedTensor.balance (k := k) (A := L × R) (M := OffDiagonal O T)
+    (N := BlockModule.Second k L R Z) (1,0) (o,0) z
+  change BalancedTensor.mk k (L × R) (OffDiagonal O T) (BlockModule.Second k L R Z)
+      ((1:Lᵐᵒᵖ) • o,(0:Rᵐᵒᵖ) • (0:T)) z =
+    BalancedTensor.mk k (L × R) (OffDiagonal O T) (BlockModule.Second k L R Z) (o,0) ((0:R) • (show Z from z)) at h
+  erw [one_smul, zero_smul, zero_smul, map_zero] at h
+  exact h
+
+omit [Module R O] [IsScalarTower k R O] [IsScalarTower k Lᵐᵒᵖ O]
+  [SMulCommClass R Lᵐᵒᵖ O] [Module L T] [IsScalarTower k L T]
+  [IsScalarTower k Rᵐᵒᵖ T] [SMulCommClass L Rᵐᵒᵖ T] [IsScalarTower k R Z] in
+theorem inverse_forward (x : source k L R O T Z) :
+    inverse k L R O T Z (forward k L R O T Z x) = x := by
+  let F := (inverse k L R O T Z).comp (forward k L R O T Z)
+  have h : F = LinearMap.id := by
+    apply BalancedTensor.ext
+    intro x z
+    change BalancedTensor.mk k (L × R) (OffDiagonal O T) (BlockModule.Second k L R Z) (0,x.2) z =
+      BalancedTensor.mk k (L × R) (OffDiagonal O T) (BlockModule.Second k L R Z) x z
+    let q := (BalancedTensor.mk k (L × R) (OffDiagonal O T) (BlockModule.Second k L R Z)).flip z
+    have hx : x = (x.1,0) + (0,x.2) := Prod.ext (add_zero _).symm (zero_add _).symm
+    exact ((congrArg q hx).trans ((q.map_add _ _).trans
+      ((congrArg (· + q (0,x.2)) (other_block_zero k L R O T Z x.1 z)).trans (zero_add _)))).symm
+  exact congrArg (fun f => f x) h
+
+omit [Module R O] [IsScalarTower k R O] [IsScalarTower k Lᵐᵒᵖ O]
+  [SMulCommClass R Lᵐᵒᵖ O] [Module L T] [IsScalarTower k L T]
+  [IsScalarTower k Rᵐᵒᵖ T] [SMulCommClass L Rᵐᵒᵖ T] [IsScalarTower k R Z] in
+theorem forward_inverse (x : target k L R T Z) :
+    forward k L R O T Z (inverse k L R O T Z x) = x := by
+  have h : (forward k L R O T Z).comp (inverse k L R O T Z) = LinearMap.id := by
+    apply BalancedTensor.ext
+    intro t z
+    rfl
+  exact congrArg (fun f => f x) h
+
+/-- Tensor on the second block selects T and has its actual output on the first block. -/
+def equivalence : source k L R O T Z ≃ₗ[L × R] target k L R T Z where
+  toFun := forward k L R O T Z
+  invFun := inverse k L R O T Z
+  left_inv := inverse_forward k L R O T Z
+  right_inv := forward_inverse k L R O T Z
+  map_add' := (forward k L R O T Z).map_add
+  map_smul' d x := by
+    let F := forward k L R O T Z
+    have h : F.comp (LeftTensor.action k (L × R) (L × R) (OffDiagonal O T)
+        (BlockModule.Second k L R Z) d) =
+        (Algebra.lsmul k k (target k L R T Z) d).comp F := by
+      apply BalancedTensor.ext
+      intro x z
+      rfl
+    exact congrArg (fun f => f x) h
+
+end LittleFinitistic.OrdinarySimulation.SecondBlockTensor
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Ordinary/OrdinarySecondBlockTotal.lean b/lean/OAI/Algebra/Finitistic/Ordinary/OrdinarySecondBlockTotal.lean
new file mode 100644
index 0000000000000000000000000000000000000000..05b052a6e3f098d7ed4185e9fbe75a9de28f4292
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Ordinary/OrdinarySecondBlockTotal.lean
@@ -0,0 +1,113 @@
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryBlockTensorTerms
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryBimoduleTensorTotal
+
+namespace OAI
+noncomputable section
+open CategoryTheory
+open scoped TensorProduct
+namespace LittleFinitistic.OrdinarySimulation.BlockTensor
+universe u
+variable (k L R : Type u) [Field k] [Ring L] [Ring R] [Algebra k L] [Algebra k R]
+variable (O : CochainComplex (ModuleCat.{u} (R ⊗[k] Lᵐᵒᵖ)) ℤ)
+variable (T : CochainComplex (ModuleCat.{u} (L ⊗[k] Rᵐᵒᵖ)) ℤ)
+variable (Z : CochainComplex (ModuleCat.{u} R) ℤ)
+variable {l : ℕ} (p : Fin l → ℤ) (hp : StrictMono p)
+open BimoduleComplexTensor
+
+def secondTotalEquiv (n : ℤ) :
+    totalTerm k (L × R) (L × R) (OffDiagonal.complex k L R O T) (BlockModule.secondComplex L R Z) p n ≃ₗ[L × R]
+      BlockModule.First k L R (totalTerm k L R T Z p n) :=
+  (LinearEquiv.piCongrRight (fun i => secondTermEquiv k L R O T Z (p i) (n + -(p i)))).trans
+    (show (∀ i : Fin l, BlockModule.First k L R (term k L R T Z (p i) (n + -(p i)))) ≃ₗ[L × R]
+      BlockModule.First k L R (totalTerm k L R T Z p n) from LinearEquiv.refl _ _)
+
+@[simp] theorem secondTotalEquiv_apply (n : ℤ)
+    (z : totalTerm k (L × R) (L × R) (OffDiagonal.complex k L R O T) (BlockModule.secondComplex L R Z) p n)
+    (i : Fin l) : secondTotalEquiv k L R O T Z p n z i =
+      secondTermEquiv k L R O T Z (p i) (n + -(p i)) (z i) := rfl
+
+theorem second_entry (n : ℤ) (i j : Fin l) :
+    (secondTermEquiv k L R O T Z (p j) ((n+1) + -(p j))).toLinearMap.comp
+      (entry k (L × R) (L × R) (OffDiagonal.complex k L R O T) (BlockModule.secondComplex L R Z) p n i j) =
+    (BlockModule.firstMap k L R (entry k L R T Z p n i j)).comp
+      (secondTermEquiv k L R O T Z (p i) (n + -(p i))).toLinearMap := by
+  unfold entry
+  split_ifs with h
+  · have he : n + -(p i) = (n+1) + -(p j) := by omega
+    have ht : (ProductModules.secondInflation L R).map (eqToHom (congrArg Z.X he)) =
+        eqToHom (congrArg (BlockModule.secondComplex L R Z).X he) := by
+      generalize n + -(p i) = q at he ⊢
+      generalize (n+1) + -(p j) = q' at he ⊢
+      subst q'
+      simp only [eqToHom_refl,CategoryTheory.Functor.map_id]
+      rfl
+    have hh := secondTermEquiv_map k L R O T Z (O.d (p i) (p j)) (T.d (p i) (p j)) (eqToHom (congrArg Z.X he))
+    rw [ht,← OffDiagonal.complex_d_all] at hh
+    exact hh
+  · apply LinearMap.ext
+    intro x
+    change secondTermEquiv k L R O T Z (p j) ((n+1) + -(p j)) 0 = 0
+    exact (secondTermEquiv k L R O T Z (p j) ((n+1) + -(p j))).map_zero
+
+theorem second_vertical (n : ℤ) (i : Fin l) :
+    (secondTermEquiv k L R O T Z (p i) ((n+1) + -(p i))).toLinearMap.comp
+      (map k (L × R) (L × R) (OffDiagonal.complex k L R O T) (BlockModule.secondComplex L R Z) (𝟙 _)
+        ((BlockModule.secondComplex L R Z).d (n + -(p i)) ((n+1) + -(p i)))) =
+    (BlockModule.firstMap k L R (map k L R T Z (𝟙 _) (Z.d (n + -(p i)) ((n+1) + -(p i))))).comp
+      (secondTermEquiv k L R O T Z (p i) (n + -(p i))).toLinearMap := by
+  exact secondTermEquiv_map k L R O T Z (𝟙 (O.X (p i))) (𝟙 (T.X (p i))) (Z.d _ _)
+
+theorem second_differential (n : ℤ)
+    (z : totalTerm k (L × R) (L × R) (OffDiagonal.complex k L R O T) (BlockModule.secondComplex L R Z) p n) :
+    secondTotalEquiv k L R O T Z p (n+1)
+      (differential k (L × R) (L × R) (OffDiagonal.complex k L R O T) (BlockModule.secondComplex L R Z) p n z) =
+    differential k L R T Z p n (secondTotalEquiv k L R O T Z p n z) := by
+  funext j
+  change secondTermEquiv k L R O T Z (p j) ((n+1) + -(p j))
+      (differential k (L × R) (L × R) (OffDiagonal.complex k L R O T) (BlockModule.secondComplex L R Z) p n z j) =
+    differential k L R T Z p n (secondTotalEquiv k L R O T Z p n z) j
+  simp only [differential,
+    LinearMap.pi_apply,LinearMap.add_apply,LinearMap.comp_apply,LinearMap.proj_apply,
+    LinearMap.sum_apply,map_add,map_sum]
+  apply congrArg₂ (· + ·)
+  · change secondTermEquiv k L R O T Z (p j) ((n+1) + -(p j))
+        ((((-(p j)).negOnePow : ℤ)) •
+          (map k (L × R) (L × R) (OffDiagonal.complex k L R O T) (BlockModule.secondComplex L R Z) (𝟙 _)
+            ((BlockModule.secondComplex L R Z).d (n + -(p j)) ((n+1) + -(p j))) (z j))) =
+      (((-(p j)).negOnePow : ℤ)) •
+        (map k L R T Z (𝟙 _) (Z.d (n + -(p j)) ((n+1) + -(p j))))
+          (secondTermEquiv k L R O T Z (p j) (n + -(p j)) (z j))
+    rw [map_zsmul]
+    congr 1
+    exact congrArg (fun f => f (z j)) (second_vertical k L R O T Z p n j)
+  · erw [LinearMap.sum_apply]
+    apply Finset.sum_congr rfl
+    intro i _
+    exact congrArg (fun f => f (z i)) (second_entry k L R O T Z p n i j)
+
+/-- Actual tensor with the off-diagonal complex on a second-block input is the first-block T-total. -/
+def secondTotalIso :
+    total k (L × R) (L × R) (OffDiagonal.complex k L R O T) (BlockModule.secondComplex L R Z) p hp ≅
+      BlockModule.firstComplex L R (total k L R T Z p hp) :=
+  HomologicalComplex.Hom.isoOfComponents (fun n => (secondTotalEquiv k L R O T Z p n).toModuleIso) (by
+    intro n m h
+    change n+1=m at h
+    subst m
+    have h₁ : (total k (L × R) (L × R) (OffDiagonal.complex k L R O T) (BlockModule.secondComplex L R Z) p hp).d n (n+1) =
+        ModuleCat.ofHom (differential k (L × R) (L × R) (OffDiagonal.complex k L R O T) (BlockModule.secondComplex L R Z) p n) :=
+      CochainComplex.of_d (fun n => ModuleCat.of (L × R) (totalTerm k (L × R) (L × R) (OffDiagonal.complex k L R O T) (BlockModule.secondComplex L R Z) p n))
+        (fun n => ModuleCat.ofHom (differential k (L × R) (L × R) (OffDiagonal.complex k L R O T) (BlockModule.secondComplex L R Z) p n)) n
+    have h₂ : (total k L R T Z p hp).d n (n+1) = ModuleCat.ofHom (differential k L R T Z p n) :=
+      CochainComplex.of_d (fun n => ModuleCat.of L (totalTerm k L R T Z p n))
+        (fun n => ModuleCat.ofHom (differential k L R T Z p n)) n
+    change _ ≫ (ProductModules.firstInflation L R).map ((total k L R T Z p hp).d n (n+1)) = _
+    rw [h₁,h₂]
+    apply ModuleCat.hom_ext
+    apply LinearMap.ext
+    intro z
+    exact (second_differential k L R O T Z p n z).symm)
+end LittleFinitistic.OrdinarySimulation.BlockTensor
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryShiftDerivedTensor.lean b/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryShiftDerivedTensor.lean
new file mode 100644
index 0000000000000000000000000000000000000000..d30cd2ada11f799b275965cb0f964db514b4dad3
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryShiftDerivedTensor.lean
@@ -0,0 +1,44 @@
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryBimoduleDerivedTensor
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryRightProjective
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryShiftSign
+
+namespace OAI
+noncomputable section
+open CategoryTheory Limits
+open scoped TensorProduct
+namespace LittleFinitistic.OrdinarySimulation
+universe u
+variable {k B : Type u} [Field k] [Ring B] [Algebra k B]
+variable (P : CochainComplex (ModuleCat.{u} (Enveloping k B)) ℤ) (b : ℤ) (l : ℕ)
+variable [∀ n, Module.Projective Bᵐᵒᵖ ((underlyingRightComplex P).X n)]
+
+instance shifted_right_projective (n : ℤ) : Module.Projective Bᵐᵒᵖ
+    (ComplexTensor.rightTerm k B (BimoduleComplexTensor.rightComplex k B B (P⟦b⟧)) n) :=
+  inferInstanceAs (Module.Projective Bᵐᵒᵖ ((underlyingRightComplex P).X (n+b)))
+
+variable [HasDerivedCategory.{u+1} (ModuleCat.{u} B)]
+
+/-- The native derived tensor functor computed by the source's actual bounded P[b]. -/
+def shiftedDerivedTensor : DerivedCategory (ModuleCat.{u} B) ⥤ DerivedCategory (ModuleCat.{u} B) :=
+  BimoduleComplexTensor.derivedTotal k B B (P⟦b⟧)
+    (TensorResolution.finiteDegrees l) (TensorResolution.finiteDegrees_strictMono l)
+
+def shiftedDerivedTensorComparison : DerivedCategory.Q ⋙ shiftedDerivedTensor P b l ≅
+    BimoduleComplexTensor.totalFunctor k B B (P⟦b⟧)
+      (TensorResolution.finiteDegrees l) (TensorResolution.finiteDegrees_strictMono l) ⋙ DerivedCategory.Q :=
+  BimoduleComplexTensor.derivedTotalComparison k B B (P⟦b⟧)
+    (TensorResolution.finiteDegrees l) (TensorResolution.finiteDegrees_strictMono l)
+
+omit [∀ n, Module.Projective Bᵐᵒᵖ ((underlyingRightComplex P).X n)]
+  [HasDerivedCategory.{u+1} (ModuleCat.{u} B)] in
+theorem shifted_support (a : ℤ) (hb : a+(l:ℤ)=b)
+    (hP : ∀ n : ℤ, n < a ∨ b < n → IsZero (P.X n)) (n : ℤ) (hn : n < -(l:ℤ) ∨ 0 < n) :
+    IsZero ((P⟦b⟧).X n) := by
+  change IsZero (P.X (n+b))
+  apply hP
+  omega
+end LittleFinitistic.OrdinarySimulation
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryShiftSign.lean b/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryShiftSign.lean
new file mode 100644
index 0000000000000000000000000000000000000000..291955567b6df37085c8e37a99061febf4667534
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryShiftSign.lean
@@ -0,0 +1,49 @@
+import Mathlib.Algebra.Homology.HomotopyCategory.Shift
+
+namespace OAI
+noncomputable section
+open CategoryTheory
+namespace LittleFinitistic.OrdinarySimulation
+universe u v
+variable {C : Type u} [Category.{v} C] [Preadditive C]
+
+/-- Reindex P by b, retaining the original differential. This is what the resolution computes. -/
+def unsignedShift (P : CochainComplex C ℤ) (b : ℤ) : CochainComplex C ℤ where
+  X n := P.X (n+b)
+  d n m := P.d (n+b) (m+b)
+  shape n m h := P.shape _ _ (by
+    change ¬ (n+b)+1 = m+b
+    change ¬ n+1=m at h
+    omega)
+  d_comp_d' n m q _ _ := P.d_comp_d _ _ _
+
+/-- Multiplication by an integer unit is an actual isomorphism in any additive category. -/
+def integerUnitIso (X : C) (u : ℤˣ) : X ≅ X where
+  hom := u • 𝟙 X
+  inv := u⁻¹ • 𝟙 X
+  hom_inv_id := by
+    simp only [Linear.units_smul_comp, Linear.comp_units_smul, Category.id_comp,
+      smul_smul, inv_mul_cancel, one_smul]
+  inv_hom_id := by
+    simp only [Linear.units_smul_comp, Linear.comp_units_smul, Category.id_comp,
+      smul_smul, mul_inv_cancel, one_smul]
+
+/-- The source's degree-n sign (-1)^(b*n), for all integers b and n. -/
+def shiftSignIso (P : CochainComplex C ℤ) (b : ℤ) : unsignedShift P b ≅ P⟦b⟧ :=
+  HomologicalComplex.Hom.isoOfComponents
+    (fun n => integerUnitIso (P.X (n+b)) (b*n).negOnePow) (by
+      intro n m h
+      change n+1=m at h
+      subst m
+      change ((b*n).negOnePow • 𝟙 _) ≫ (b.negOnePow • P.d (n+b) (n+1+b)) =
+        P.d (n+b) (n+1+b) ≫ ((b*(n+1)).negOnePow • 𝟙 _)
+      simp only [Linear.units_smul_comp, Linear.comp_units_smul, Category.id_comp,
+        Category.comp_id, smul_smul]
+      rw [← Int.negOnePow_add]
+      congr 2
+      simp [mul_add, add_comm])
+end LittleFinitistic.OrdinarySimulation
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Ordinary/OrdinarySignedExactness.lean b/lean/OAI/Algebra/Finitistic/Ordinary/OrdinarySignedExactness.lean
new file mode 100644
index 0000000000000000000000000000000000000000..a16c095575086061a1b36d37d96c3a63d1013a6e
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Ordinary/OrdinarySignedExactness.lean
@@ -0,0 +1,35 @@
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryTensorExactness
+
+namespace OAI
+noncomputable section
+namespace LittleFinitistic
+universe u
+variable {R E F G : Type u} [Ring R]
+variable [AddCommGroup E] [Module R E]
+variable [AddCommGroup F] [Module R F]
+variable [AddCommGroup G] [Module R G]
+
+/-- Multiplying both differentials by an integer unit preserves exactness. -/
+theorem exact_units_smul (u : ℤˣ) (f : E →ₗ[R] F) (g : F →ₗ[R] G)
+    (h : Function.Exact f g) : Function.Exact (u • f) (u • g) := by
+  intro z
+  constructor
+  · intro hz
+    have hg : g z = 0 := by
+      have hh := congrArg (fun x : G => u⁻¹ • x) hz
+      simpa only [LinearMap.smul_apply,smul_smul,inv_mul_cancel,one_smul,smul_zero] using hh
+    obtain ⟨y,hy⟩ := (h z).mp hg
+    refine ⟨u⁻¹ • y, ?_⟩
+    change u • f ((↑(u⁻¹) : ℤ) • y) = z
+    rw [map_zsmul]
+    change u • (u⁻¹ • f y) = z
+    rw [smul_smul,mul_inv_cancel,one_smul,hy]
+  · rintro ⟨y,rfl⟩
+    have hg : g (f y) = 0 := (h (f y)).mpr ⟨y,rfl⟩
+    change u • g ((↑u : ℤ) • f y) = 0
+    rw [map_zsmul,hg,smul_zero,smul_zero]
+end LittleFinitistic
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Ordinary/OrdinarySimulationComparison.lean b/lean/OAI/Algebra/Finitistic/Ordinary/OrdinarySimulationComparison.lean
new file mode 100644
index 0000000000000000000000000000000000000000..b46d2629ecc1ee1c4ff0b2a517bdf5d5a706cf51
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Ordinary/OrdinarySimulationComparison.lean
@@ -0,0 +1,75 @@
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryFullTensorComplex
+import OAI.Algebra.Finitistic.Ordinary.OrdinarySupportedExtension
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryShiftSign
+
+namespace OAI
+noncomputable section
+open CategoryTheory Limits
+open scoped TensorProduct
+namespace LittleFinitistic.OrdinarySimulation
+universe u
+variable {k B : Type u} [Field k] [Ring B] [Algebra k B]
+variable (P : CochainComplex (ModuleCat.{u} (Enveloping k B)) ℤ) (a : ℤ) (l : ℕ)
+
+theorem differential_transport {n n' m m' : ℤ} (hn : n = n') (hm : m = m') :
+    eqToHom (congrArg P.X hn) ≫ P.d n' m' = P.d n m ≫ eqToHom (congrArg P.X hm) := by
+  subst n'
+  subst m'
+  simp only [eqToHom_refl,Category.id_comp,Category.comp_id]
+
+/-- Align the finite resolution's degree n with the source's degree a+n. -/
+def restrictedShiftIso : P.restriction (ComplexShape.embeddingUpIntGE a) ≅
+    (unsignedShift P (a+(l:ℤ))).restriction (TensorResolution.degreeEmbedding l) :=
+  HomologicalComplex.Hom.isoOfComponents (fun n => eqToIso (by
+    change P.X (a+(n:ℤ)) = P.X ((-(l:ℤ)+n)+(a+l))
+    congr 1
+    omega)) (by
+      intro n m _
+      have hn : (-(l:ℤ)+(n:ℤ))+(a+l) = a+n := by omega
+      have hm : (-(l:ℤ)+(m:ℤ))+(a+l) = a+m := by omega
+      change eqToHom (congrArg P.X hn.symm) ≫ P.d ((-(l:ℤ)+n)+(a+l)) ((-(l:ℤ)+m)+(a+l)) =
+        P.d (a+n) (a+m) ≫ eqToHom (congrArg P.X hm.symm)
+      exact differential_transport P hn.symm hm.symm)
+
+/-- The lower support condition of the manuscript supplies strict support after reindexing. -/
+theorem unsignedSupport (hP : ∀ n : ℤ, n < a → IsZero (P.X n)) :
+    (unsignedShift P (a+(l:ℤ))).IsStrictlySupported (TensorResolution.degreeEmbedding l) :=
+  ⟨fun n hn => by
+    have hlt : n < -(l:ℤ) := by
+      by_contra h
+      let j := (n+(l:ℤ)).toNat
+      have hj : (TensorResolution.degreeEmbedding l).f j = n := by
+        simp only [TensorResolution.degreeEmbedding_apply]
+        dsimp [j]
+        rw [Int.toNat_of_nonneg (by omega)]
+        omega
+      exact hn j hj
+    exact hP (n+(a+l)) (by omega)⟩
+
+/-- The computed BC-balanced tensor complex in degrees -l,...,0 with both B-actions. -/
+def computedTensorComplex : CochainComplex (ModuleCat.{u} (Enveloping k B)) ℤ :=
+  (FullTensorTerm.complex P a l).extend (TensorResolution.degreeEmbedding l)
+
+/-- Full bimodule chain comparison, including all zero terms and the genuine integer shift sign. -/
+def computedTensorIso
+    (hLower : ∀ n : ℤ, n < a → IsZero (P.X n))
+    (hUpper : ∀ n : ℕ, l < n → IsZero (P.X (a+(n:ℤ)))) :
+    computedTensorComplex P a l ≅ P⟦a+(l:ℤ)⟧ := by
+  letI := unsignedSupport P a l hLower
+  exact ((TensorResolution.degreeEmbedding l).extendFunctor (ModuleCat.{u} (Enveloping k B))).mapIso
+      (FullTensorTerm.complexIso P a l hUpper ≪≫ restrictedShiftIso P a l) ≪≫
+    SupportedExtension.iso (unsignedShift P (a+(l:ℤ))) (TensorResolution.degreeEmbedding l) ≪≫
+    shiftSignIso P (a+(l:ℤ))
+
+/-- Exact source indexing: b=a+l, with only the manuscript's support hypothesis. -/
+def sourceShiftComparison (b : ℤ) (hb : a+(l:ℤ)=b)
+    (hP : ∀ n : ℤ, n < a ∨ b < n → IsZero (P.X n)) :
+    computedTensorComplex P a l ≅ P⟦b⟧ := by
+  subst b
+  exact computedTensorIso P a l (fun n hn => hP n (Or.inl hn))
+    (fun n hn => hP (a+(n:ℤ)) (Or.inr (by omega)))
+end LittleFinitistic.OrdinarySimulation
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Ordinary/OrdinarySingleTensorTerms.lean b/lean/OAI/Algebra/Finitistic/Ordinary/OrdinarySingleTensorTerms.lean
new file mode 100644
index 0000000000000000000000000000000000000000..d3061a5841dab0c29a6ebba004b7131d526406ea
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Ordinary/OrdinarySingleTensorTerms.lean
@@ -0,0 +1,99 @@
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryBimoduleCoefficientEquiv
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryBimoduleTensorTotal
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryRetainedRestriction
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryFinitePiSupport
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryMiddleTensorFunctors
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryShiftSign
+
+namespace OAI
+noncomputable section
+open CategoryTheory Limits
+open scoped TensorProduct
+namespace LittleFinitistic.SingleBimoduleTensor
+universe u
+variable (k S A N : Type u) [Field k] [Ring S] [Ring A] [Algebra k S] [Algebra k A]
+variable [AddCommGroup N] [Module k N] [Module S N] [Module Aᵐᵒᵖ N]
+  [IsScalarTower k S N] [IsScalarTower k Aᵐᵒᵖ N] [SMulCommClass S Aᵐᵒᵖ N]
+
+abbrev complex : CochainComplex (ModuleCat.{u} (S ⊗[k] Aᵐᵒᵖ)) ℤ :=
+  (HomologicalComplex.single _ (.up ℤ) 0).obj (RetainedBimodule.object k S A N)
+
+variable (Z : CochainComplex (ModuleCat.{u} A) ℤ)
+open BimoduleComplexTensor
+
+def zeroCoefficientEquiv : BimoduleCoefficients k S A ((complex k S A N).X 0) ≃ₗ[Aᵐᵒᵖ] N :=
+  (BimoduleCoefficients.equiv k S A (HomologicalComplex.singleObjXSelf (.up ℤ) 0 (RetainedBimodule.object k S A N))).trans
+    (RetainedBimodule.rightEquiv k S A N)
+
+theorem zeroCoefficientEquiv_left (s : S) (x : BimoduleCoefficients k S A ((complex k S A N).X 0)) :
+    zeroCoefficientEquiv k S A N (s • x) = s • zeroCoefficientEquiv k S A N x := by
+  simp only [zeroCoefficientEquiv,LinearEquiv.trans_apply,BimoduleCoefficients.equiv_left,RetainedBimodule.rightEquiv_left]
+
+def zeroTermEquiv (n : ℤ) : term k S A (complex k S A N) Z 0 n ≃ₗ[S] (middleLeftComplex k S A N Z).X n :=
+  LeftTensor.congr (zeroCoefficientEquiv k S A N) (zeroCoefficientEquiv_left k S A N)
+    (LinearEquiv.refl A (ComplexTensor.leftTerm k A Z n))
+
+theorem zeroTermEquiv_map {n m : ℤ} (g : Z.X n ⟶ Z.X m) :
+    (zeroTermEquiv k S A N Z m).toLinearMap.comp (map k S A (complex k S A N) Z (𝟙 _) g) =
+    ((middleLeftFunctor k S A N).map g).hom.comp (zeroTermEquiv k S A N Z n).toLinearMap := by
+  let : Module k ((middleLeftComplex k S A N Z).X m) := inferInstanceAs (Module k (LeftTensor k A S N (ComplexTensor.leftTerm k A Z m)))
+  let : IsScalarTower k S ((middleLeftComplex k S A N Z).X m) := inferInstanceAs (IsScalarTower k S (LeftTensor k A S N (ComplexTensor.leftTerm k A Z m)))
+  apply LinearMap.restrictScalars_injective k
+  apply BalancedTensor.ext
+  intro x z
+  rfl
+
+variable {l : ℕ} (p : Fin l → ℤ) (hp : StrictMono p) (i₀ : Fin l) (h₀ : p i₀ = 0)
+
+include hp h₀ in
+theorem otherTerm_subsingleton (n : ℤ) (i : Fin l) (hi : i ≠ i₀) :
+    Subsingleton (term k S A (complex k S A N) Z (p i) (n + -(p i))) := by
+  have hz : p i ≠ 0 := by
+    intro h
+    exact hi (hp.injective (h.trans h₀.symm))
+  have : Subsingleton (BimoduleCoefficients k S A ((complex k S A N).X (p i))) :=
+    ModuleCat.isZero_iff_subsingleton.mp
+      (HomologicalComplex.isZero_single_obj_X (.up ℤ) 0 (RetainedBimodule.object k S A N) (p i) hz)
+  exact inferInstanceAs (Subsingleton (BalancedTensor.Tensor k A
+    (BimoduleCoefficients k S A ((complex k S A N).X (p i))) (ComplexTensor.leftTerm k A Z (n + -(p i)))))
+
+def coefficientEquivAt (q : ℤ) (hq : q = 0) :
+    BimoduleCoefficients k S A ((complex k S A N).X q) ≃ₗ[Aᵐᵒᵖ] N := by
+  subst q
+  exact zeroCoefficientEquiv k S A N
+
+theorem coefficientEquivAt_left (q : ℤ) (hq : q = 0) (s : S)
+    (x : BimoduleCoefficients k S A ((complex k S A N).X q)) :
+    coefficientEquivAt k S A N q hq (s • x) = s • coefficientEquivAt k S A N q hq x := by
+  subst q
+  exact zeroCoefficientEquiv_left k S A N s x
+
+def termEquivAt (q : ℤ) (hq : q = 0) (n : ℤ) :
+    term k S A (complex k S A N) Z q (n + -q) ≃ₗ[S] ((middleLeftComplex k S A N Z)⟦-q⟧).X n :=
+  LeftTensor.congr (coefficientEquivAt k S A N q hq) (coefficientEquivAt_left k S A N q hq)
+    (LinearEquiv.refl A (ComplexTensor.leftTerm k A Z (n + -q)))
+
+theorem termEquivAt_map (q : ℤ) (hq : q = 0) (n m : ℤ) (g : Z.X (n + -q) ⟶ Z.X (m + -q)) :
+    (termEquivAt k S A N Z q hq m).toLinearMap.comp (map k S A (complex k S A N) Z (𝟙 _) g) =
+    ((middleLeftFunctor k S A N).map g).hom.comp (termEquivAt k S A N Z q hq n).toLinearMap := by
+  let : Module k (((middleLeftComplex k S A N Z)⟦-q⟧).X m) :=
+    inferInstanceAs (Module k (LeftTensor k A S N (ComplexTensor.leftTerm k A Z (m + -q))))
+  let : IsScalarTower k S (((middleLeftComplex k S A N Z)⟦-q⟧).X m) :=
+    inferInstanceAs (IsScalarTower k S (LeftTensor k A S N (ComplexTensor.leftTerm k A Z (m + -q))))
+  apply LinearMap.restrictScalars_injective k
+  apply BalancedTensor.ext
+  intro x z
+  rfl
+
+abbrev selectedTermEquiv (n : ℤ) := termEquivAt k S A N Z (p i₀) h₀ n
+
+def totalTermEquiv (n : ℤ) : totalTerm k S A (complex k S A N) Z p n ≃ₗ[S]
+    ((middleLeftComplex k S A N Z)⟦-(p i₀)⟧).X n :=
+  (FinitePiSupport.equivalence (fun i => term k S A (complex k S A N) Z (p i) (n + -(p i)))
+    i₀ (otherTerm_subsingleton k S A N Z p hp i₀ h₀ n)).trans
+    (selectedTermEquiv k S A N Z p i₀ h₀ n)
+end LittleFinitistic.SingleBimoduleTensor
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Ordinary/OrdinarySingleTensorTotal.lean b/lean/OAI/Algebra/Finitistic/Ordinary/OrdinarySingleTensorTotal.lean
new file mode 100644
index 0000000000000000000000000000000000000000..367886aad0e420e33a213c2664b4b0fc35c2a883
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Ordinary/OrdinarySingleTensorTotal.lean
@@ -0,0 +1,84 @@
+import OAI.Algebra.Finitistic.Ordinary.OrdinarySingleTensorTerms
+
+namespace OAI
+noncomputable section
+open CategoryTheory Limits
+open scoped TensorProduct
+namespace LittleFinitistic.SingleBimoduleTensor
+universe u
+variable (k S A N : Type u) [Field k] [Ring S] [Ring A] [Algebra k S] [Algebra k A]
+variable [AddCommGroup N] [Module k N] [Module S N] [Module Aᵐᵒᵖ N]
+  [IsScalarTower k S N] [IsScalarTower k Aᵐᵒᵖ N] [SMulCommClass S Aᵐᵒᵖ N]
+variable (Z : CochainComplex (ModuleCat.{u} A) ℤ)
+variable {l : ℕ} (p : Fin l → ℤ) (hp : StrictMono p) (i₀ : Fin l) (h₀ : p i₀ = 0)
+open BimoduleComplexTensor
+
+include hp h₀ in
+theorem entry_selected_zero (n : ℤ) (z : totalTerm k S A (complex k S A N) Z p n) (i : Fin l) :
+    entry k S A (complex k S A N) Z p n i i₀ (z i) = 0 := by
+  by_cases hi : i = i₀
+  · subst i
+    unfold entry
+    rw [dite_eq_right (show ¬ p i₀ + 1 = p i₀ by omega)]
+    rfl
+  · have hs := otherTerm_subsingleton k S A N Z p hp i₀ h₀ n i hi
+    rw [hs.elim (z i) 0,map_zero]
+
+include hp h₀ in
+theorem differential_selected (n : ℤ) (z : totalTerm k S A (complex k S A N) Z p n) :
+    differential k S A (complex k S A N) Z p n z i₀ =
+      ((-(p i₀)).negOnePow • map k S A (complex k S A N) Z (𝟙 _)
+        (Z.d (n + -(p i₀)) ((n+1) + -(p i₀)))) (z i₀) := by
+  simp only [differential,LinearMap.pi_apply,LinearMap.add_apply,LinearMap.comp_apply,LinearMap.proj_apply,
+    LinearMap.sum_apply]
+  rw [Finset.sum_eq_zero (fun i _ => entry_selected_zero k S A N Z p hp i₀ h₀ n z i),add_zero]
+
+theorem termEquivAt_vertical (q : ℤ) (hq : q = 0) (n : ℤ)
+    (y : term k S A (complex k S A N) Z q (n + -q)) :
+    termEquivAt k S A N Z q hq (n+1)
+      (((-q).negOnePow • map k S A (complex k S A N) Z (𝟙 _)
+        (Z.d (n + -q) ((n+1) + -q))) y) =
+    (((middleLeftComplex k S A N Z)⟦-q⟧).d n (n+1)).hom (termEquivAt k S A N Z q hq n y) := by
+  change termEquivAt k S A N Z q hq (n+1)
+      ((((-q).negOnePow : ℤ)) • (map k S A (complex k S A N) Z (𝟙 _)
+        (Z.d (n + -q) ((n+1) + -q))) y) =
+    (((-q).negOnePow : ℤ)) • (((middleLeftFunctor k S A N).map (Z.d (n + -q) ((n+1) + -q))).hom
+      (termEquivAt k S A N Z q hq n y))
+  rw [map_zsmul]
+  congr 1
+  exact congrArg (fun f => f y) (termEquivAt_map k S A N Z q hq n (n+1) (Z.d _ _))
+
+theorem totalTermEquiv_differential (n : ℤ) (z : totalTerm k S A (complex k S A N) Z p n) :
+    totalTermEquiv k S A N Z p hp i₀ h₀ (n+1) (differential k S A (complex k S A N) Z p n z) =
+    (((middleLeftComplex k S A N Z)⟦-(p i₀)⟧).d n (n+1)).hom (totalTermEquiv k S A N Z p hp i₀ h₀ n z) := by
+  change termEquivAt k S A N Z (p i₀) h₀ (n+1)
+      (differential k S A (complex k S A N) Z p n z i₀) =
+    (((middleLeftComplex k S A N Z)⟦-(p i₀)⟧).d n (n+1)).hom (termEquivAt k S A N Z (p i₀) h₀ n (z i₀))
+  rw [differential_selected k S A N Z p hp i₀ h₀]
+  exact termEquivAt_vertical k S A N Z (p i₀) h₀ n (z i₀)
+
+/-- A genuine ordinary bimodule in degree zero has exactly its ordinary tensor complex as total. -/
+def shiftedTotalIso : total k S A (complex k S A N) Z p hp ≅ (middleLeftComplex k S A N Z)⟦-(p i₀)⟧ :=
+  HomologicalComplex.Hom.isoOfComponents (fun n => (totalTermEquiv k S A N Z p hp i₀ h₀ n).toModuleIso) (by
+    intro n m h
+    change n+1=m at h
+    subst m
+    have hd : (total k S A (complex k S A N) Z p hp).d n (n+1) = ModuleCat.ofHom (differential k S A (complex k S A N) Z p n) :=
+      CochainComplex.of_d (fun n => ModuleCat.of S (totalTerm k S A (complex k S A N) Z p n))
+        (fun n => ModuleCat.ofHom (differential k S A (complex k S A N) Z p n)) n
+    rw [hd]
+    apply ModuleCat.hom_ext
+    apply LinearMap.ext
+    intro z
+    exact (totalTermEquiv_differential k S A N Z p hp i₀ h₀ n z).symm)
+
+/-- Removing the proved zero shift identifies the ordinary tensor complex exactly. -/
+def totalIso : total k S A (complex k S A N) Z p hp ≅ middleLeftComplex k S A N Z :=
+  shiftedTotalIso k S A N Z p hp i₀ h₀ ≪≫
+    (eqToIso (congrArg (fun q : ℤ => (middleLeftComplex k S A N Z)⟦q⟧) (show -(p i₀) = 0 by omega))) ≪≫
+    (shiftFunctorZero (CochainComplex (ModuleCat.{u} S) ℤ) ℤ).app (middleLeftComplex k S A N Z)
+end LittleFinitistic.SingleBimoduleTensor
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Ordinary/OrdinarySourceBimoduleTotal.lean b/lean/OAI/Algebra/Finitistic/Ordinary/OrdinarySourceBimoduleTotal.lean
new file mode 100644
index 0000000000000000000000000000000000000000..d9f31b8c839c0a06e03b3da238270031aa37ef43
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Ordinary/OrdinarySourceBimoduleTotal.lean
@@ -0,0 +1,35 @@
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryGenuineBimoduleComparison
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryBimoduleTotalAssociativity
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryBimoduleTotalCongruence
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryTensorTotalAcyclic
+
+namespace OAI
+noncomputable section
+open CategoryTheory Limits
+open scoped TensorProduct
+namespace LittleFinitistic.OrdinarySimulation
+universe u
+variable {k B : Type u} [Field k] [Ring B] [Algebra k B]
+variable (P : CochainComplex (ModuleCat.{u} (Enveloping k B)) ℤ) (a : ℤ) (l : ℕ)
+variable (b : ℤ) (hb : a+(l:ℤ)=b)
+variable (hP : ∀ n : ℤ, n < a ∨ b < n → IsZero (P.X n))
+variable (Z : CochainComplex (ModuleCat.{u} B) ℤ)
+
+/-- The source signed total comparison for every Z, with the actual outside B-action retained. -/
+def sourceBimoduleTotalComparison :
+    BimoduleComplexTensor.total k B (B ⊗[k] ChainAlgebra k l)
+      (TensorResolution.integerBimoduleComplex k B l)
+      (middleLeftComplex k (B ⊗[k] ChainAlgebra k l) B (BimoduleO P a l) Z)
+      (TensorResolution.finiteDegrees l) (TensorResolution.finiteDegrees_strictMono l) ≅
+    BimoduleComplexTensor.total k B B (P⟦b⟧) Z
+      (TensorResolution.finiteDegrees l) (TensorResolution.finiteDegrees_strictMono l) :=
+  (BimoduleComplexTensor.totalAssociativityIso k B (B ⊗[k] ChainAlgebra k l) B (BimoduleO P a l)
+    (TensorResolution.integerBimoduleComplex k B l) Z
+    (TensorResolution.finiteDegrees l) (TensorResolution.finiteDegrees_strictMono l)).symm ≪≫
+  BimoduleComplexTensor.totalRightIso k B B (genuineSourceShiftComparison P a l b hb hP) Z
+    (TensorResolution.finiteDegrees l) (TensorResolution.finiteDegrees_strictMono l)
+end LittleFinitistic.OrdinarySimulation
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Ordinary/OrdinarySourceDerivedComparison.lean b/lean/OAI/Algebra/Finitistic/Ordinary/OrdinarySourceDerivedComparison.lean
new file mode 100644
index 0000000000000000000000000000000000000000..04fb44336d9d4f5b755396100c2562ad77e7fa96
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Ordinary/OrdinarySourceDerivedComparison.lean
@@ -0,0 +1,42 @@
+import OAI.Algebra.Finitistic.Ordinary.OrdinarySourceResolutionModels
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryDerivedSquareComparison
+
+namespace OAI
+noncomputable section
+open CategoryTheory Limits
+open scoped TensorProduct
+namespace LittleFinitistic.OrdinarySimulation
+universe u
+variable {k B : Type u} [Field k] [Ring B] [Algebra k B]
+variable (P : CochainComplex (ModuleCat.{u} (Enveloping k B)) ℤ) (a : ℤ) (l : ℕ)
+variable (b : ℤ) (hb : a+(l:ℤ)=b)
+variable (hP : ∀ n : ℤ, n < a ∨ b < n → IsZero (P.X n))
+
+section Bimodule
+variable [HasDerivedCategory.{u+1} (ModuleCat.{u} (Enveloping k B))]
+
+/-- The source's resolved T tensor O comparison in the native derived category of genuine B-bimodules.
+Its left operand includes the actual bounded right-BC-projective resolution and augmentation to T. -/
+def resolvedBimoduleComparison :
+    (TensorResolution.resolutionModel k B l).tensorOrdinary B (BimoduleO P a l) ≅
+      DerivedCategory.Q.obj (P⟦b⟧) :=
+  DerivedCategory.Q.mapIso (genuineSourceShiftComparison P a l b hb hP)
+end Bimodule
+
+variable [∀ n, Module.Projective Bᵐᵒᵖ ((underlyingRightComplex P).X n)]
+variable [HasDerivedCategory.{u+1} (ModuleCat.{u} B)]
+variable [HasDerivedCategory.{u+1} (ModuleCat.{u} (AlgebraD k l B))]
+
+/-- The source's native derived square with both tensor functors tied to their certified full-support models. -/
+def resolvedSquareComparison (Z : CochainComplex (ModuleCat.{u} B) ℤ) :
+    (XResolution.resolutionModel P a l).toFiniteProjectiveBimoduleComplex.derivedTensor.obj
+      ((XResolution.resolutionModel P a l).toFiniteProjectiveBimoduleComplex.derivedTensor.obj
+        ((BlockModule.derivedFirst B (B ⊗[k] ChainAlgebra k l)).obj (DerivedCategory.Q.obj Z))) ≅
+    (BlockModule.derivedFirst B (B ⊗[k] ChainAlgebra k l)).obj
+      ((shiftedResolutionModel P a l b hb hP).derivedTensor.obj (DerivedCategory.Q.obj Z)) :=
+  XResolution.derivedSquareComparison P a l b hb hP Z
+end LittleFinitistic.OrdinarySimulation
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Ordinary/OrdinarySourceResolutionModels.lean b/lean/OAI/Algebra/Finitistic/Ordinary/OrdinarySourceResolutionModels.lean
new file mode 100644
index 0000000000000000000000000000000000000000..69522e229ae5f3347bfe4fd1f62056ef12454948
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Ordinary/OrdinarySourceResolutionModels.lean
@@ -0,0 +1,80 @@
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryResolutionModels
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryXAugmentation
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryShiftDerivedTensor
+
+namespace OAI
+noncomputable section
+open CategoryTheory Limits
+open scoped TensorProduct
+namespace LittleFinitistic.OrdinarySimulation
+universe u
+variable {k B : Type u} [Field k] [Ring B] [Algebra k B]
+
+namespace TensorResolution
+
+theorem finiteDegrees_range (l : ℕ) (n : ℤ) : n ∈ Set.range (finiteDegrees l) ↔ -(l:ℤ) ≤ n ∧ n ≤ 0 := by
+  constructor
+  · rintro ⟨i,rfl⟩
+    dsimp [finiteDegrees]
+    have hi := i.isLt
+    omega
+  · rintro ⟨hlo,hhi⟩
+    let j := (n+(l:ℤ)).toNat
+    have hj : (j:ℤ) = n+(l:ℤ) := Int.toNat_of_nonneg (by omega)
+    refine ⟨⟨j,by omega⟩,?_⟩
+    dsimp [finiteDegrees]
+    omega
+
+/-- The actual Q_T augmentation with all source resolution obligations proved. -/
+def resolutionModel (k B : Type u) [Field k] [Ring B] [Algebra k B] (l : ℕ) :
+    BoundedBimoduleResolution k B (B ⊗[k] ChainAlgebra k l) (bimoduleTerminalObject k B l) where
+  complex := integerBimoduleComplex k B l
+  size := l+1
+  degrees := finiteDegrees l
+  strictMono := finiteDegrees_strictMono l
+  support n hn := by
+    have h : n < -(l:ℤ) ∨ 0 < n := by
+      have := (finiteDegrees_range l n).not.mp hn
+      omega
+    exact h.elim (integerBimodule_lower k B l n) (integerBimodule_upper k B l n)
+  rightProjective n := integerBimoduleRight_projective k B l n
+  augmentation := integerBimoduleAugmentation k B l
+  augmentation_quasiIso := integerBimoduleAugmentation_quasiIso k B l
+end TensorResolution
+
+variable (P : CochainComplex (ModuleCat.{u} (Enveloping k B)) ℤ) (a : ℤ) (l : ℕ)
+variable [∀ n, Module.Projective Bᵐᵒᵖ ((underlyingRightComplex P).X n)]
+
+/-- The actual Q_X resolution with no assumed augmentation, projectivity, or support theorem. -/
+def XResolution.resolutionModel :
+    BoundedBimoduleResolution k (AlgebraD k l B) (AlgebraD k l B) (XResolution.ordinaryXObject P a l) where
+  complex := XResolution.complex P a l
+  size := l+1
+  degrees := TensorResolution.finiteDegrees l
+  strictMono := TensorResolution.finiteDegrees_strictMono l
+  support n hn := by
+    apply XResolution.vanishes P a l n
+    have := (TensorResolution.finiteDegrees_range l n).not.mp hn
+    omega
+  rightProjective n := XResolution.right_projective P a l n
+  augmentation := XResolution.augmentationToX P a l
+  augmentation_quasiIso := XResolution.augmentationToX_quasiIso P a l
+
+/-- The actual P[b] itself is a finite right-projective tensor model with exactly the source support. -/
+def shiftedResolutionModel (b : ℤ) (hb : a+(l:ℤ)=b)
+    (hP : ∀ n : ℤ, n < a ∨ b < n → IsZero (P.X n)) : FiniteProjectiveBimoduleComplex k B B where
+  complex := P⟦b⟧
+  size := l+1
+  degrees := TensorResolution.finiteDegrees l
+  strictMono := TensorResolution.finiteDegrees_strictMono l
+  support n hn := by
+    change IsZero (P.X (n+b))
+    apply hP
+    have := (TensorResolution.finiteDegrees_range l n).not.mp hn
+    omega
+  rightProjective n := shifted_right_projective P b n
+end LittleFinitistic.OrdinarySimulation
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Ordinary/OrdinarySupportedExtension.lean b/lean/OAI/Algebra/Finitistic/Ordinary/OrdinarySupportedExtension.lean
new file mode 100644
index 0000000000000000000000000000000000000000..b5ce362be0adb76599e68c19977eea48fe1f0515
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Ordinary/OrdinarySupportedExtension.lean
@@ -0,0 +1,53 @@
+import Mathlib.Algebra.Homology.Embedding.StupidTrunc
+
+namespace OAI
+noncomputable section
+attribute [local instance] Classical.propDecidable
+open CategoryTheory Limits
+namespace LittleFinitistic.OrdinarySimulation.SupportedExtension
+universe u v w w'
+variable {C : Type u} [Category.{v} C] [HasZeroMorphisms C] [HasZeroObject C]
+variable {I : Type w} {J : Type w'} {c : ComplexShape I} {c' : ComplexShape J}
+variable (K : HomologicalComplex C c') (e : c.Embedding c') [e.IsRelIff] [K.IsStrictlySupported e]
+
+/-- The supported complex's restriction and extension have its actual components. -/
+def component (j : J) : (K.stupidTrunc e).X j ≅ K.X j :=
+  if hj : ∃ i, e.f i = j then K.stupidTruncXIso e hj.choose_spec
+  else (K.isZero_stupidTrunc_X e j (by simpa using hj)).iso
+    (K.isZero_X_of_isStrictlySupported e j (by simpa using hj))
+
+omit [K.IsStrictlySupported e] in
+theorem component_iso_unique {i j : I} {n : J} (hi : e.f i = n) (hj : e.f j = n) :
+    K.stupidTruncXIso e hi = K.stupidTruncXIso e hj := by
+  have h : i = j := e.injective_f (hi.trans hj.symm)
+  subst j
+  rfl
+
+theorem component_at (i : I) : component K e (e.f i) = K.stupidTruncXIso e rfl := by
+  unfold component
+  rw [dite_eq_left (show ∃ j, e.f j = e.f i from ⟨i,rfl⟩)]
+  exact component_iso_unique K e _ _
+
+/-- An actual chain isomorphism, with support supplied by proved zero objects. -/
+def iso : K.stupidTrunc e ≅ K :=
+  HomologicalComplex.Hom.isoOfComponents (component K e) (by
+    intro i' j' _
+    by_cases hi : ∃ i, e.f i = i'
+    · obtain ⟨i,rfl⟩ := hi
+      by_cases hj : ∃ j, e.f j = j'
+      · obtain ⟨j,rfl⟩ := hj
+        rw [component_at,component_at]
+        change (((K.restriction e).extendXIso e rfl).hom ≫ 𝟙 _) ≫ K.d (e.f i) (e.f j) =
+          ((K.restriction e).extend e).d (e.f i) (e.f j) ≫
+            (((K.restriction e).extendXIso e rfl).hom ≫ 𝟙 _)
+        rw [Category.comp_id, Category.comp_id]
+        rw [HomologicalComplex.extend_d_eq _ _ rfl rfl]
+        simp only [Category.assoc,Iso.inv_hom_id,Category.comp_id]
+        rfl
+      · exact IsZero.eq_of_tgt (K.isZero_X_of_isStrictlySupported e j' (by simpa using hj)) _ _
+    · exact IsZero.eq_of_src (K.isZero_stupidTrunc_X e i' (by simpa using hi)) _ _)
+end LittleFinitistic.OrdinarySimulation.SupportedExtension
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryTensorAugmentation.lean b/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryTensorAugmentation.lean
new file mode 100644
index 0000000000000000000000000000000000000000..a08f88a0e32b58d497c04306dbca4fd28539e9c7
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryTensorAugmentation.lean
@@ -0,0 +1,127 @@
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryTensorResolution
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryTerminal
+
+namespace OAI
+noncomputable section
+open CategoryTheory
+open scoped TensorProduct
+namespace LittleFinitistic.OrdinarySimulation
+universe u
+variable (k B : Type u) [Field k] [Ring B] [Algebra k B] (l : ℕ)
+
+instance TerminalSimple.tower : IsScalarTower k (ChainAlgebra k l)ᵐᵒᵖ (TerminalSimple k) where
+  smul_assoc r x w := by
+    change (show k from w) * (r * (ChainAlgebra.terminalCharacter k l x.unop)) =
+      r * ((show k from w) * ChainAlgebra.terminalCharacter k l x.unop)
+    ring
+
+namespace TensorResolution
+open ChainAlgebra
+
+def simpleCoordinates : TerminalSimple k ≃ₗ[k] k where
+  toFun w := w
+  invFun w := w
+  left_inv _ := rfl
+  right_inv _ := rfl
+  map_add' _ _ := rfl
+  map_smul' _ _ := rfl
+
+def terminalEquiv : B ⊗[k] TerminalSimple k ≃ₗ[k] TerminalTensor B :=
+  (TensorProduct.congr (LinearEquiv.refl k B) (simpleCoordinates k)).trans (TerminalTensor.tensorModel k B)
+
+/-- The augmentation retains the actual right BC-action. -/
+def augmentation : term k B l l →ₗ[(B ⊗[k] ChainAlgebra k l)ᵐᵒᵖ] TerminalTensor B where
+  toFun x := terminalAugmentation k B l x.val
+  map_add' x y := map_add _ x.val y.val
+  map_smul' r x := map_mul (terminalAugmentation k B l) x.val r.unop
+
+/-- The ordinary augmentation is exactly B tensor the terminal C-augmentation. -/
+theorem augmentation_tensor (z : B ⊗[k] resolutionIdeal k l l) :
+    augmentation k B l (termEquiv k B l l z) =
+      terminalEquiv k B (((resolutionAugmentation k l).hom.restrictScalars k).lTensor B z) := by
+  induction z using TensorProduct.inductionOn with
+  | tmul b c =>
+    change b * algebraMap k B (c.val.1 (Fin.last l)) = (c.val.1 (Fin.last l)) • b
+    rw [Algebra.smul_def,Algebra.commutes]
+  | add x y hx hy => simp only [map_add,hx,hy]
+
+/-- The augmentation preserves the regular left B-action as well. -/
+theorem augmentation_left (b : B) (x : term k B l l) :
+    augmentation k B l (b • x) = b • augmentation k B l x := by
+  change terminalAugmentation k B l (TensorIdeal.coefficient b * x.val) =
+    b * terminalAugmentation k B l x.val
+  rw [map_mul]
+  congr 1
+  change b * algebraMap k B (ChainAlgebra.terminalCharacter k l 1) = b
+  rw [map_one,map_one,mul_one]
+
+theorem augmentation_comp (n : ℕ) :
+    (augmentation k B (n+1)).comp (differential k B (n+1) n) = 0 := by
+  ext x
+  change terminalAugmentation k B (n+1) (((1:B) ⊗ₜ[k] extendedArrow k (n+1) n) * x.val) = 0
+  rw [map_mul]
+  have hz : terminalAugmentation k B (n+1) ((1:B) ⊗ₜ[k] extendedArrow k (n+1) n) = 0 := by
+    rw [extendedArrow,dite_eq_left (by omega)]
+    change 1 * algebraMap k B ((arrow k (n+1) ⟨n,by omega⟩).1 (Fin.last (n+1))) = 0
+    rw [arrow_diagonal,map_zero,mul_zero]
+  rw [hz,zero_mul]
+
+theorem augmentation_exact (n : ℕ) :
+    Function.Exact (differential k B (n+1) n) (augmentation k B (n+1)) := by
+  have hc : Function.Exact ((resolutionDifferential k (n+1) n).hom.restrictScalars k)
+      ((resolutionAugmentation k (n+1)).hom.restrictScalars k) := by
+    intro x
+    constructor
+    · intro hx
+      exact (ShortComplex.moduleCat_exact_iff _).mp (resolutionAugmentation_exact k n) x hx
+    · rintro ⟨y,rfl⟩
+      exact congrArg (fun f => f.hom y) (resolutionAugmentation_comp k n)
+  have ht := Module.Flat.lTensor_exact B hc
+  intro x
+  constructor
+  · intro hx
+    have hz : (((resolutionAugmentation k (n+1)).hom.restrictScalars k).lTensor B)
+        ((termEquiv k B (n+1) (n+1)).symm x) = 0 := by
+      apply (terminalEquiv k B).injective
+      rw [← augmentation_tensor,LinearEquiv.apply_symm_apply,hx,map_zero]
+    obtain ⟨y,hy⟩ := (ht _).mp hz
+    refine ⟨termEquiv k B (n+1) n y, ?_⟩
+    rw [← termEquiv_d,hy,LinearEquiv.apply_symm_apply]
+  · rintro ⟨y,rfl⟩
+    exact congrArg (fun f => f y) (augmentation_comp k B n)
+
+/-- Surjectivity is explicit: the terminal vertex lifts every coefficient b. -/
+theorem augmentation_surjective : Function.Surjective (augmentation k B l) := by
+  intro b
+  let x : term k B l l := ⟨(show B from b) ⊗ₜ[k] vertex k l (Fin.last l), by
+    change ((1:B) ⊗ₜ[k] extendedVertex k l l) * _ = _
+    rw [extendedVertex,dite_eq_left le_rfl]
+    have hi : (⟨l,by omega⟩ : Fin (l+1)) = Fin.last l := rfl
+    rw [hi,Algebra.TensorProduct.tmul_mul_tmul,one_mul,vertex_idempotent]⟩
+  refine ⟨x, ?_⟩
+  change (show B from b) * algebraMap k B ((vertex k l (Fin.last l)).1 (Fin.last l)) = (show B from b)
+  rw [vertex_diagonal,Pi.single_eq_same,map_one,mul_one]
+
+theorem initial_injective (h : 0 < l) : Function.Injective (differential k B l 0) := by
+  have hi := Module.Flat.lTensor_preserves_injective_linearMap
+    ((resolutionDifferential k l 0).hom.restrictScalars k) (resolutionInitial_injective k l h) (M := B)
+  intro x y hxy
+  apply (termEquiv k B l 0).symm.injective
+  apply hi
+  apply (termEquiv k B l 1).injective
+  rw [termEquiv_d,termEquiv_d,LinearEquiv.apply_symm_apply,LinearEquiv.apply_symm_apply,hxy]
+
+theorem augmentation_zero_injective : Function.Injective (augmentation k B 0) := by
+  have hi := Module.Flat.lTensor_preserves_injective_linearMap
+    ((resolutionAugmentation k 0).hom.restrictScalars k) (resolutionAugmentation_zero_injective k) (M := B)
+  intro x y hxy
+  apply (termEquiv k B 0 0).symm.injective
+  apply hi
+  apply (terminalEquiv k B).injective
+  rw [← augmentation_tensor,← augmentation_tensor,LinearEquiv.apply_symm_apply,LinearEquiv.apply_symm_apply,hxy]
+end TensorResolution
+end LittleFinitistic.OrdinarySimulation
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryTensorBimap.lean b/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryTensorBimap.lean
new file mode 100644
index 0000000000000000000000000000000000000000..a1dcde68dfd9937a38572ee7058f3aa6470f7a09
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryTensorBimap.lean
@@ -0,0 +1,44 @@
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryProjectiveTensor
+
+namespace OAI
+noncomputable section
+namespace LittleFinitistic.BalancedTensor
+universe u
+variable {k A M M' M'' N N' N'' : Type u} [Field k] [Ring A] [Algebra k A]
+variable [AddCommGroup M] [Module k M] [Module Aᵐᵒᵖ M] [IsScalarTower k Aᵐᵒᵖ M]
+variable [AddCommGroup M'] [Module k M'] [Module Aᵐᵒᵖ M'] [IsScalarTower k Aᵐᵒᵖ M']
+variable [AddCommGroup M''] [Module k M''] [Module Aᵐᵒᵖ M''] [IsScalarTower k Aᵐᵒᵖ M'']
+variable [AddCommGroup N] [Module k N] [Module A N] [IsScalarTower k A N]
+variable [AddCommGroup N'] [Module k N'] [Module A N'] [IsScalarTower k A N']
+variable [AddCommGroup N''] [Module k N''] [Module A N''] [IsScalarTower k A N'']
+
+/-- The actual balanced tensor map in both variables. -/
+def bimap (f : M →ₗ[Aᵐᵒᵖ] M') (g : N →ₗ[A] N') : Tensor k A M N →ₗ[k] Tensor k A M' N' :=
+  (mapRightTo g).comp (mapLeft N f)
+
+@[simp] theorem bimap_mk (f : M →ₗ[Aᵐᵒᵖ] M') (g : N →ₗ[A] N') (m : M) (n : N) :
+    bimap (k := k) f g (mk k A M N m n) = mk k A M' N' (f m) (g n) := rfl
+
+@[simp] theorem bimap_comp (f : M →ₗ[Aᵐᵒᵖ] M') (f' : M' →ₗ[Aᵐᵒᵖ] M'')
+    (g : N →ₗ[A] N') (g' : N' →ₗ[A] N'') :
+    (bimap (k := k) f' g').comp (bimap f g) = bimap (f'.comp f) (g'.comp g) := by
+  apply ext
+  intro m n
+  rfl
+
+@[simp] theorem bimap_zero_left (g : N →ₗ[A] N') :
+    bimap (k := k) (0 : M →ₗ[Aᵐᵒᵖ] M') g = 0 := by
+  apply ext
+  intro m n
+  simp only [bimap_mk,LinearMap.zero_apply,map_zero,LinearMap.zero_apply]
+
+@[simp] theorem bimap_zero_right (f : M →ₗ[Aᵐᵒᵖ] M') :
+    bimap (k := k) f (0 : N →ₗ[A] N') = 0 := by
+  apply ext
+  intro m n
+  simp only [bimap_mk,LinearMap.zero_apply,map_zero]
+end LittleFinitistic.BalancedTensor
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryTensorBimoduleComparison.lean b/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryTensorBimoduleComparison.lean
new file mode 100644
index 0000000000000000000000000000000000000000..2d6db78101247127cf3dd84cde45a29c95b1105e
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryTensorBimoduleComparison.lean
@@ -0,0 +1,102 @@
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryTensorVertex
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryBalancedActions
+
+namespace OAI
+noncomputable section
+open CategoryTheory
+open scoped TensorProduct
+namespace LittleFinitistic.OrdinarySimulation
+universe u
+variable {k B : Type u} [Field k] [Ring B] [Algebra k B]
+variable (P : CochainComplex (ModuleCat.{u} (Enveloping k B)) ℤ) (a : ℤ) (l : ℕ)
+
+def VertexTensor (i : Fin (l+1)) :=
+  BalancedTensor.Tensor k (B ⊗[k] ChainAlgebra k l)
+    (IdempotentTensor.rightIdeal (TensorIdeal.vertex (k := k) (B := B) (ChainAlgebra.vertex k l i)))
+    (BimoduleO P a l)
+
+namespace VertexTensor
+variable (i : Fin (l+1))
+instance : AddCommGroup (VertexTensor P a l i) := inferInstanceAs (AddCommGroup (BalancedTensor.Tensor k (B ⊗[k] ChainAlgebra k l) _ (BimoduleO P a l)))
+instance : Module k (VertexTensor P a l i) := inferInstanceAs (Module k (BalancedTensor.Tensor k (B ⊗[k] ChainAlgebra k l) _ (BimoduleO P a l)))
+
+def action : Enveloping k B →ₐ[k] Module.End k (VertexTensor P a l i) :=
+  by
+    have : SMulCommClass Bᵐᵒᵖ (B ⊗[k] ChainAlgebra k l) (BimoduleO P a l) :=
+      ⟨fun r x v => (smul_comm x r v).symm⟩
+    exact BalancedTensor.bimoduleAction
+
+instance : Module (Enveloping k B) (VertexTensor P a l i) := Module.compHom _ (action P a l i).toRingHom
+instance : IsScalarTower k (Enveloping k B) (VertexTensor P a l i) where
+  smul_assoc r x z := by
+    change action P a l i (r • x) z = r • action P a l i x z
+    rw [map_smul]
+    rfl
+
+def mk : IdempotentTensor.rightIdeal (TensorIdeal.vertex (k := k) (B := B) (ChainAlgebra.vertex k l i)) →ₗ[k]
+    BimoduleO P a l →ₗ[k] VertexTensor P a l i := BalancedTensor.mk k (B ⊗[k] ChainAlgebra k l)
+    (IdempotentTensor.rightIdeal (TensorIdeal.vertex (k := k) (B := B) (ChainAlgebra.vertex k l i)))
+    (BimoduleO P a l)
+
+@[simp] theorem action_tmul_mk (b : B) (r : Bᵐᵒᵖ)
+    (m : IdempotentTensor.rightIdeal (TensorIdeal.vertex (k := k) (B := B) (ChainAlgebra.vertex k l i)))
+    (v : BimoduleO P a l) :
+    (b ⊗ₜ[k] r) • mk P a l i m v = mk P a l i (b • m) (r • v) := rfl
+
+local instance termScalar (n : ℤ) : Module k (P.X n) := Module.compHom _ (algebraMap k (Enveloping k B))
+local instance termTower (n : ℤ) : IsScalarTower k (Enveloping k B) (P.X n) :=
+  IsScalarTower.of_compHom k (Enveloping k B) (P.X n)
+
+/-- Evaluation of the actual BC-balanced tensor. -/
+def evaluation : VertexTensor P a l i ≃ₗ[k] P.X (a+(i.val:ℤ)) :=
+  BimoduleO.tensorVertexEquiv P a l i
+
+@[simp] theorem evaluation_mk
+    (m : IdempotentTensor.rightIdeal (TensorIdeal.vertex (k := k) (B := B) (ChainAlgebra.vertex k l i)))
+    (v : BimoduleO P a l) :
+    evaluation P a l i (mk P a l i m v) = (m.val • v : BimoduleO P a l) i := rfl
+
+/-- The original enveloping-algebra action is the two original B-actions. -/
+theorem enveloping_smul (b : B) (r : Bᵐᵒᵖ) (v : BimoduleO P a l) :
+    (b ⊗ₜ[k] r : Enveloping k B) • v = b • (r • v) := by
+  change (b ⊗ₜ[k] r : Enveloping k B) • (v : Compression P a l) =
+    (b ⊗ₜ[k] (1:Bᵐᵒᵖ)) • (((1:B) ⊗ₜ[k] r) • (v : Compression P a l))
+  rw [← mul_smul]
+  simp only [Algebra.TensorProduct.tmul_mul_tmul,mul_one,one_mul]
+
+theorem evaluation_tmul_smul (b : B) (r : Bᵐᵒᵖ) (z : VertexTensor P a l i) :
+    evaluation P a l i ((b ⊗ₜ[k] r) • z) =
+      (b ⊗ₜ[k] r : Enveloping k B) • (evaluation P a l i z : P.X (a+(i.val:ℤ))) := by
+  have h : (evaluation P a l i).toLinearMap.comp (action P a l i (b ⊗ₜ[k] r)) =
+      (Algebra.lsmul k k (P.X (a+(i.val:ℤ))) (b ⊗ₜ[k] r : Enveloping k B)).comp
+        (evaluation P a l i).toLinearMap := by
+    apply BalancedTensor.ext
+    intro m v
+    change evaluation P a l i ((b ⊗ₜ[k] r) • mk P a l i m v) =
+      (b ⊗ₜ[k] r : Enveloping k B) • evaluation P a l i (mk P a l i m v)
+    rw [action_tmul_mk, evaluation_mk, evaluation_mk]
+    change (((TensorIdeal.coefficient b * m.val) • (r • v)) : BimoduleO P a l) i = _
+    have hv : (TensorIdeal.coefficient b * m.val) • (r • v) =
+        (b ⊗ₜ[k] r : Enveloping k B) • (m.val • v) := by
+      rw [mul_smul, smul_comm m.val r]
+      change (b ⊗ₜ[k] (1:ChainAlgebra k l)) • (r • (m.val • v)) = _
+      rw [BimoduleO.tensor_smul, one_smul, ← enveloping_smul]
+    exact congrArg (fun w : BimoduleO P a l => w i) hv
+  exact congrArg (fun f => f z) h
+
+theorem evaluation_smul (x : Enveloping k B) (z : VertexTensor P a l i) :
+    evaluation P a l i (x • z) = x • (evaluation P a l i z : P.X (a+(i.val:ℤ))) := by
+  induction x using TensorProduct.inductionOn with
+  | tmul b r => exact evaluation_tmul_smul P a l i b r z
+  | add x y hx hy => simp only [add_smul,map_add,hx,hy]
+
+/-- Degreewise comparison as a genuine B-bimodule equivalence. -/
+def bimoduleEquiv : VertexTensor P a l i ≃ₗ[Enveloping k B] P.X (a+(i.val:ℤ)) where
+  __ := (evaluation P a l i).toAddEquiv
+  map_smul' x z := evaluation_smul P a l i x z
+end VertexTensor
+end LittleFinitistic.OrdinarySimulation
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryTensorBimoduleResolution.lean b/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryTensorBimoduleResolution.lean
new file mode 100644
index 0000000000000000000000000000000000000000..eb8d279ece8e4aa0cdec5411a455ce2920ed3da0
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryTensorBimoduleResolution.lean
@@ -0,0 +1,81 @@
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryRetainedBimodule
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryIntegerResolution
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryFunctorExtension
+
+namespace OAI
+noncomputable section
+open CategoryTheory
+open scoped TensorProduct
+namespace LittleFinitistic.OrdinarySimulation.TensorResolution
+universe u
+variable (k B : Type u) [Field k] [Ring B] [Algebra k B] (l : ℕ)
+
+abbrev bimoduleTerm (n : ℕ) := RetainedBimodule k B (B ⊗[k] ChainAlgebra k l) (term k B l n)
+
+def bimoduleDifferential (n : ℕ) :=
+  RetainedBimodule.map (k := k) (S := B) (A := B ⊗[k] ChainAlgebra k l) (differential k B l n) (differential_left k B l n)
+
+theorem bimoduleDifferential_square (n : ℕ) :
+    (bimoduleDifferential k B l (n+1)).comp (bimoduleDifferential k B l n) = 0 := by
+  apply LinearMap.ext
+  intro x
+  exact congrArg (fun f => f x) (differential_square k B l n)
+
+/-- The actual finite resolution retains the left B-action as a genuine tensor-algebra complex. -/
+def bimoduleComplex : CochainComplex (ModuleCat.{u} (B ⊗[k] (B ⊗[k] ChainAlgebra k l)ᵐᵒᵖ)) ℕ :=
+  CochainComplex.of (fun n => ModuleCat.of _ (bimoduleTerm k B l n))
+    (fun n => ModuleCat.ofHom (bimoduleDifferential k B l n))
+    (fun n => ModuleCat.hom_ext (bimoduleDifferential_square k B l n))
+
+/-- The genuine bimodule resolution in exactly the source interval [-l,0]. -/
+def integerBimoduleComplex : CochainComplex (ModuleCat.{u} (B ⊗[k] (B ⊗[k] ChainAlgebra k l)ᵐᵒᵖ)) ℤ :=
+  (bimoduleComplex k B l).extend (degreeEmbedding l)
+
+abbrev forgetBimodule : ModuleCat.{u} (B ⊗[k] (B ⊗[k] ChainAlgebra k l)ᵐᵒᵖ) ⥤
+    ModuleCat.{u} (B ⊗[k] ChainAlgebra k l)ᵐᵒᵖ :=
+  ModuleCat.restrictScalars
+    (Algebra.TensorProduct.includeRight (R := k) (A := B) (B := (B ⊗[k] ChainAlgebra k l)ᵐᵒᵖ)).toRingHom
+
+def forgetBimoduleTerm (n : ℕ) :
+    (forgetBimodule k B l).obj (ModuleCat.of _ (bimoduleTerm k B l n)) ≅ termObject k B l n := by
+  let e : (forgetBimodule k B l).obj (ModuleCat.of _ (bimoduleTerm k B l n)) ≃ₗ[(B ⊗[k] ChainAlgebra k l)ᵐᵒᵖ]
+      term k B l n :=
+    { toFun := fun x => x
+      invFun := fun x => x
+      left_inv := fun _ => rfl
+      right_inv := fun _ => rfl
+      map_add' := fun _ _ => rfl
+      map_smul' := fun r x => by
+        apply Subtype.ext
+        change TensorIdeal.coefficient (1:B) * (x.val * r.unop) = x.val * r.unop
+        rw [map_one,one_mul] }
+  exact e.toModuleIso
+
+/-- Forgetting the retained left action recovers the verified ordinary finite resolution. -/
+def forgetBimoduleComplex :
+    ((forgetBimodule k B l).mapHomologicalComplex (.up ℕ)).obj (bimoduleComplex k B l) ≅ complex k B l :=
+  HomologicalComplex.Hom.isoOfComponents (forgetBimoduleTerm k B l) (by
+    intro n m h
+    change n+1=m at h
+    subst m
+    change (forgetBimoduleTerm k B l n).hom ≫ (complex k B l).d n (n+1) =
+      (forgetBimodule k B l).map ((bimoduleComplex k B l).d n (n+1)) ≫ (forgetBimoduleTerm k B l (n+1)).hom
+    have h₁ : (complex k B l).d n (n+1) = ModuleCat.ofHom (differential k B l n) :=
+      CochainComplex.of_d (termObject k B l) (fun n => ModuleCat.ofHom (differential k B l n)) n
+    have h₂ : (bimoduleComplex k B l).d n (n+1) = ModuleCat.ofHom (bimoduleDifferential k B l n) :=
+      CochainComplex.of_d (fun n => ModuleCat.of (B ⊗[k] (B ⊗[k] ChainAlgebra k l)ᵐᵒᵖ) (bimoduleTerm k B l n))
+        (fun n => ModuleCat.ofHom (bimoduleDifferential k B l n)) n
+    rw [h₁,h₂]
+    rfl)
+
+/-- Every integer term and differential agrees after forgetting the left action. -/
+def forgetIntegerBimoduleComplex :
+    ((forgetBimodule k B l).mapHomologicalComplex (.up ℤ)).obj (integerBimoduleComplex k B l) ≅
+      integerComplex k B l :=
+  FunctorExtension.iso (forgetBimodule k B l) (bimoduleComplex k B l) (degreeEmbedding l) ≪≫
+    ((degreeEmbedding l).extendFunctor _).mapIso (forgetBimoduleComplex k B l)
+end LittleFinitistic.OrdinarySimulation.TensorResolution
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryTensorColumnAcyclic.lean b/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryTensorColumnAcyclic.lean
new file mode 100644
index 0000000000000000000000000000000000000000..00313d54a2413114f91cc04d2ec3a271efbcc8d1
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryTensorColumnAcyclic.lean
@@ -0,0 +1,52 @@
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryComplexTensorMaps
+import OAI.Algebra.Finitistic.Ordinary.OrdinarySignedExactness
+
+namespace OAI
+noncomputable section
+open CategoryTheory
+namespace LittleFinitistic.ComplexTensor
+open BalancedTensor
+universe u
+variable (k A : Type u) [Field k] [Ring A] [Algebra k A]
+variable (Q : CochainComplex (ModuleCat.{u} Aᵐᵒᵖ) ℤ)
+variable (Z : CochainComplex (ModuleCat.{u} A) ℤ)
+
+@[simp] theorem map_id_left {p q q' : ℤ} (g : Z.X q ⟶ Z.X q') :
+    map k A Q Z (𝟙 (Q.X p)) g =
+      @mapRightTo k A (rightTerm k A Q p) (leftTerm k A Z q) (leftTerm k A Z q')
+        _ _ _ _ _ _ _ _ _ (scalarLeftTower k A (Z.X q))
+        _ _ _ (scalarLeftTower k A (Z.X q')) g.hom := by
+  apply BalancedTensor.ext
+  intro x y
+  rfl
+
+/-- A signed tensor column for an actual projective right term preserves acyclicity. -/
+theorem column_acyclic (p : ℤ) [Module.Projective Aᵐᵒᵖ (rightTerm k A Q p)]
+    (hZ : Z.Acyclic) : (column k A Q Z p).Acyclic := by
+  intro n
+  have hh := (HomologicalComplex.exactAt_iff' Z ((n-1) + -p) (n + -p) ((n+1) + -p)
+    (by simp; omega)
+    (by simp; omega)).mp (hZ (n + -p))
+  have hex : Function.Exact
+      ((Z.d ((n-1) + -p) (n + -p)).hom : leftTerm k A Z ((n-1) + -p) →ₗ[A] leftTerm k A Z (n + -p))
+      ((Z.d (n + -p) ((n+1) + -p)).hom : leftTerm k A Z (n + -p) →ₗ[A] leftTerm k A Z ((n+1) + -p)) :=
+    (ShortComplex.ShortExact.moduleCat_exact_iff_function_exact _).mp hh
+  have ht := @projectiveTensor_exact k A (rightTerm k A Q p) _ _ _ _ _ _ _
+    (leftTerm k A Z ((n-1) + -p)) (leftTerm k A Z (n + -p)) (leftTerm k A Z ((n+1) + -p))
+    _ _ _ (scalarLeftTower k A (Z.X ((n-1) + -p)))
+    _ _ _ (scalarLeftTower k A (Z.X (n + -p)))
+    _ _ _ (scalarLeftTower k A (Z.X ((n+1) + -p))) _
+    (Z.d ((n-1) + -p) (n + -p)).hom (Z.d (n + -p) ((n+1) + -p)).hom hex
+  have hs := exact_units_smul (-p).negOnePow _ _ ht
+  apply (HomologicalComplex.exactAt_iff' _ (n-1) n (n+1) (by simp) (by simp)).2
+  rw [ShortComplex.moduleCat_exact_iff]
+  change ∀ (z : term k A Q Z p (n + -p)),
+    ((column k A Q Z p).d n (n+1)).hom z = 0 →
+    ∃ w : term k A Q Z p ((n-1) + -p), ((column k A Q Z p).d (n-1) n).hom w = z
+  simp only [column_d,map_id_left]
+  exact fun z hz => (hs z).mp hz
+end LittleFinitistic.ComplexTensor
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryTensorDerivedFunctor.lean b/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryTensorDerivedFunctor.lean
new file mode 100644
index 0000000000000000000000000000000000000000..9d2045d863d4a044487aa30570302c602ccb7984
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryTensorDerivedFunctor.lean
@@ -0,0 +1,39 @@
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryTensorTotalQuasiIso
+import Mathlib.Algebra.Homology.DerivedCategory.Basic
+
+namespace OAI
+noncomputable section
+open CategoryTheory
+namespace LittleFinitistic.ComplexTensor
+universe u
+variable (k A : Type u) [Field k] [Ring A] [Algebra k A]
+variable (Q : CochainComplex (ModuleCat.{u} Aᵐᵒᵖ) ℤ)
+variable {l : ℕ} (p : Fin l → ℤ) (hp : StrictMono p)
+variable [HasDerivedCategory.{u+1} (ModuleCat.{u} A)]
+variable [HasDerivedCategory.{u+1} (ModuleCat.{u} k)]
+variable [∀ i, Module.Projective Aᵐᵒᵖ (rightTerm k A Q (p i))]
+
+omit [HasDerivedCategory.{u+1} (ModuleCat.{u} A)] in
+/-- The proved actual total functor sends every quasi-isomorphism to an isomorphism after localization. -/
+theorem finiteTotal_inverts : (HomologicalComplex.quasiIso (ModuleCat.{u} A) (.up ℤ)).IsInvertedBy
+    (finiteTotalFunctor k A Q p hp ⋙ DerivedCategory.Q) := by
+  intro Z Z' f hf
+  let : QuasiIso f := hf
+  let := finiteTotalMap_quasiIso k A Q f p hp
+  exact (inferInstance : IsIso (DerivedCategory.Q.map (finiteTotalMap k A Q p hp f)))
+
+/-- Localization of the actual signed total tensor functor, justified by the proved preservation theorem. -/
+def derivedFiniteTotal : DerivedCategory (ModuleCat.{u} A) ⥤ DerivedCategory (ModuleCat.{u} k) :=
+  Localization.lift (finiteTotalFunctor k A Q p hp ⋙ DerivedCategory.Q)
+    (finiteTotal_inverts k A Q p hp) DerivedCategory.Q
+
+/-- The explicit natural comparison with the actual chain-level total on every input complex. -/
+def derivedFiniteTotalComparison :
+    DerivedCategory.Q ⋙ derivedFiniteTotal k A Q p hp ≅ finiteTotalFunctor k A Q p hp ⋙ DerivedCategory.Q :=
+  Localization.fac (finiteTotalFunctor k A Q p hp ⋙ DerivedCategory.Q)
+    (finiteTotal_inverts k A Q p hp) DerivedCategory.Q
+end LittleFinitistic.ComplexTensor
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryTensorDifferential.lean b/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryTensorDifferential.lean
new file mode 100644
index 0000000000000000000000000000000000000000..8754fb127ef09ea1e516e004dd6550de0ce4b576
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryTensorDifferential.lean
@@ -0,0 +1,82 @@
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryTensorBimoduleComparison
+
+namespace OAI
+noncomputable section
+open CategoryTheory
+open scoped TensorProduct
+namespace LittleFinitistic.OrdinarySimulation
+universe u
+variable {k B : Type u} [Field k] [Ring B] [Algebra k B]
+variable (P : CochainComplex (ModuleCat.{u} (Enveloping k B)) ℤ) (a : ℤ) (l : ℕ)
+namespace VertexTensor
+
+attribute [local instance] termScalar termTower
+
+/-- The actual arrow between BC vertex projectives. -/
+def arrowMap (i : Fin l) :
+    IdempotentTensor.rightIdeal (TensorIdeal.vertex (k := k) (B := B) (ChainAlgebra.vertex k l i.castSucc)) →ₗ[(B ⊗[k] ChainAlgebra k l)ᵐᵒᵖ]
+    IdempotentTensor.rightIdeal (TensorIdeal.vertex (k := k) (B := B) (ChainAlgebra.vertex k l i.succ)) where
+  toFun x := ⟨((1:B) ⊗ₜ[k] ChainAlgebra.arrow k l i) * x.val, by
+    change ((1:B) ⊗ₜ[k] ChainAlgebra.vertex k l i.succ) *
+      (((1:B) ⊗ₜ[k] ChainAlgebra.arrow k l i) * x.val) = _
+    rw [← mul_assoc,Algebra.TensorProduct.tmul_mul_tmul,one_mul,ChainAlgebra.vertex_target_arrow]⟩
+  map_add' x y := Subtype.ext (mul_add _ _ _)
+  map_smul' r x := Subtype.ext (mul_assoc _ _ r.unop).symm
+
+/-- Tensor the actual arrow with O; no differential is assumed. -/
+def rawDifferential (i : Fin l) : VertexTensor P a l i.castSucc →ₗ[k] VertexTensor P a l i.succ :=
+  BalancedTensor.mapLeft (BimoduleO P a l) (arrowMap (k := k) (B := B) l i)
+
+theorem arrow_coordinate (i : Fin l) (v : BimoduleO P a l) :
+    (ChainAlgebra.arrow k l i • v : BimoduleO P a l) i.succ =
+      (P.d (a+(i.castSucc.val:ℤ)) (a+(i.succ.val:ℤ))).hom (v i.castSucc) := by
+  have h := OrdinaryTerms.action_arrow
+    (intervalTerms (underlyingComplex (k := k) P) a l)
+    (intervalDifferential (underlyingComplex (k := k) P) a l) i v
+  have h' := congrArg (fun w => w i.succ) h
+  change OrdinaryTerms.action (intervalTerms (underlyingComplex (k := k) P) a l)
+    (intervalDifferential (underlyingComplex (k := k) P) a l) (ChainAlgebra.arrow k l i) v i.succ =
+      intervalDifferential (underlyingComplex (k := k) P) a l i.castSucc i.succ (v i.castSucc)
+  simpa only [Pi.single_eq_same] using h' 
+
+/-- Evaluation identifies the computed arrow differential with the genuine d_P. -/
+theorem evaluation_differential (i : Fin l) (z : VertexTensor P a l i.castSucc) :
+    evaluation P a l i.succ (rawDifferential P a l i z) =
+      (P.d (a+(i.castSucc.val:ℤ)) (a+(i.succ.val:ℤ))).hom (evaluation P a l i.castSucc z) := by
+  have h : (evaluation P a l i.succ).toLinearMap.comp (rawDifferential P a l i) =
+      ((P.d (a+(i.castSucc.val:ℤ)) (a+(i.succ.val:ℤ))).hom.restrictScalars k).comp
+        (evaluation P a l i.castSucc).toLinearMap := by
+    apply BalancedTensor.ext
+    intro m v
+    change ((((1:B) ⊗ₜ[k] ChainAlgebra.arrow k l i) * m.val) • v : BimoduleO P a l) i.succ =
+      (P.d (a+(i.castSucc.val:ℤ)) (a+(i.succ.val:ℤ))).hom ((m.val • v : BimoduleO P a l) i.castSucc)
+    have h : (((1:B) ⊗ₜ[k] ChainAlgebra.arrow k l i) * m.val) • v =
+        ChainAlgebra.arrow k l i • (m.val • v) := by
+      rw [mul_smul, BimoduleO.tensor_smul, one_smul]
+    exact (congrArg (fun w : BimoduleO P a l => w i.succ) h).trans
+      (arrow_coordinate P a l i (m.val • v))
+  exact congrArg (fun f => f z) h
+
+/-- The actual tensor differential retains both B-actions. -/
+def differential (i : Fin l) : VertexTensor P a l i.castSucc →ₗ[Enveloping k B] VertexTensor P a l i.succ where
+  __ := (rawDifferential P a l i).toAddHom
+  map_smul' r z := by
+    apply (evaluation P a l i.succ).injective
+    change evaluation P a l i.succ (rawDifferential P a l i (r • z)) =
+      evaluation P a l i.succ (r • rawDifferential P a l i z)
+    rw [evaluation_differential, evaluation_smul, evaluation_smul, evaluation_differential]
+    exact (P.d _ _).hom.map_smul r _
+
+/-- Equality of bimodule maps, with the source's actual differential. -/
+theorem bimodule_differential_comparison (i : Fin l) :
+    (bimoduleEquiv P a l i.succ).toLinearMap.comp (differential P a l i) =
+      (P.d (a+(i.castSucc.val:ℤ)) (a+(i.succ.val:ℤ))).hom.comp
+        (bimoduleEquiv P a l i.castSucc).toLinearMap := by
+  ext z
+  exact evaluation_differential P a l i z
+end VertexTensor
+end LittleFinitistic.OrdinarySimulation
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryTensorDirected.lean b/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryTensorDirected.lean
new file mode 100644
index 0000000000000000000000000000000000000000..456f5625300d550289c136035320d70d53c9ab7d
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryTensorDirected.lean
@@ -0,0 +1,94 @@
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryChainDirected
+import Mathlib.Logic.Equiv.Fin.Basic
+
+namespace OAI
+noncomputable section
+open scoped TensorProduct
+namespace LittleFinitistic.OrdinarySimulation.TensorDirected
+universe u
+variable {k B C : Type u} [Field k] [Ring B] [Ring C] [Algebra k B] [Algebra k C]
+variable {n : ℕ} (DB : DirectedBound.DirectedSystem k B 3) (DC : DirectedBound.DirectedSystem k C n)
+
+def bIndex (i : Fin (n*3)) : Fin 3 := (finProdFinEquiv.symm i).2
+def cIndex (i : Fin (n*3)) : Fin n := (finProdFinEquiv.symm i).1
+
+theorem index_value (i : Fin (n*3)) : (bIndex i).val + 3 * (cIndex i).val = i.val :=
+  congrArg Fin.val (finProdFinEquiv.apply_symm_apply i)
+
+def vertex (i : Fin (n*3)) : B ⊗[k] C := DB.e (bIndex i) ⊗ₜ[k] DC.e (cIndex i)
+
+theorem vertex_idempotent (i : Fin (n*3)) : vertex DB DC i * vertex DB DC i = vertex DB DC i := by
+  simp only [vertex,Algebra.TensorProduct.tmul_mul_tmul,DB.idem,DC.idem]
+
+theorem vertex_orthogonal (i j : Fin (n*3)) (hij : i ≠ j) : vertex DB DC i * vertex DB DC j = 0 := by
+  simp only [vertex,Algebra.TensorProduct.tmul_mul_tmul]
+  by_cases hb : bIndex i = bIndex j
+  · have hc : cIndex i ≠ cIndex j := by
+      intro h
+      apply hij
+      apply Fin.ext
+      have hi := index_value i
+      have hj := index_value j
+      rw [hb,h] at hi
+      omega
+    rw [DC.orthogonal _ _ hc,TensorProduct.tmul_zero]
+  · rw [DB.orthogonal _ _ hb,TensorProduct.zero_tmul]
+
+theorem vertex_complete : ∑ i : Fin (n*3), vertex DB DC i = 1 := by
+  have h := Equiv.sum_comp (finProdFinEquiv : Fin n × Fin 3 ≃ Fin (n*3)) (vertex DB DC)
+  rw [← h]
+  simp only [vertex,bIndex,cIndex,Equiv.symm_apply_apply,Fintype.sum_prod_type]
+  have ht (x : Fin n) : (∑ j : Fin 3, DB.e j ⊗ₜ[k] DC.e x) = (1:B) ⊗ₜ[k] DC.e x := by
+    rw [← TensorProduct.sum_tmul,DB.complete]
+  simp_rw [ht]
+  rw [← TensorProduct.tmul_sum,DC.complete]
+  rfl
+
+theorem vertex_diagonal (i : Fin (n*3)) (x : B ⊗[k] C) :
+    ∃ r : k, vertex DB DC i * x * vertex DB DC i = r • vertex DB DC i := by
+  induction x using TensorProduct.inductionOn with
+  | tmul b c =>
+    obtain ⟨r,hr⟩ := DB.diagonal (bIndex i) b
+    obtain ⟨s,hs⟩ := DC.diagonal (cIndex i) c
+    refine ⟨r*s,?_⟩
+    simp only [vertex,Algebra.TensorProduct.tmul_mul_tmul,hr,hs,
+      TensorProduct.smul_tmul,TensorProduct.tmul_smul,smul_smul,mul_comm s r]
+  | add x y hx hy =>
+    obtain ⟨r,hr⟩ := hx
+    obtain ⟨s,hs⟩ := hy
+    exact ⟨r+s,by rw [mul_add,add_mul,hr,hs,add_smul]⟩
+
+theorem vertex_directed (i j : Fin (n*3)) (hij : j < i) (x : B ⊗[k] C) :
+    vertex DB DC j * x * vertex DB DC i = 0 := by
+  have hi := index_value i
+  have hj := index_value j
+  have hbi := (bIndex i).isLt
+  have hbj := (bIndex j).isLt
+  change j.val < i.val at hij
+  have hc : cIndex j < cIndex i ∨ (cIndex j = cIndex i ∧ bIndex j < bIndex i) := by
+    by_cases h : cIndex j < cIndex i
+    · exact Or.inl h
+    · right
+      have he : cIndex j = cIndex i := Fin.ext (by change ¬(cIndex j).val < (cIndex i).val at h; omega)
+      exact ⟨he,by change (bIndex j).val < (bIndex i).val; rw [he] at hj; omega⟩
+  induction x using TensorProduct.inductionOn with
+  | tmul b c =>
+    simp only [vertex,Algebra.TensorProduct.tmul_mul_tmul]
+    rcases hc with h | ⟨h,hb⟩
+    · rw [DC.directed _ _ h,TensorProduct.tmul_zero]
+    · rw [DB.directed _ _ hb,TensorProduct.zero_tmul]
+  | add x y hx hy => rw [mul_add,add_mul,hx,hy,add_zero]
+
+/-- A concrete linear extension of the source's product order, with exactly 3n vertices. -/
+def directedSystem : DirectedBound.DirectedSystem k (B ⊗[k] C) (n*3) where
+  e := vertex DB DC
+  idem := vertex_idempotent DB DC
+  orthogonal := vertex_orthogonal DB DC
+  complete := vertex_complete DB DC
+  diagonal := vertex_diagonal DB DC
+  directed := vertex_directed DB DC
+end LittleFinitistic.OrdinarySimulation.TensorDirected
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryTensorExactness.lean b/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryTensorExactness.lean
new file mode 100644
index 0000000000000000000000000000000000000000..728dee06a1bd1d4f4bae12ae97cda744b79702de
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryTensorExactness.lean
@@ -0,0 +1,98 @@
+import OAI.Algebra.Finitistic.Tensor.IdempotentTensor
+import Mathlib.Algebra.Exact.Basic
+
+namespace OAI
+noncomputable section
+namespace LittleFinitistic
+namespace BalancedTensor
+universe u
+variable {k A M N N' N'' : Type u} [Field k] [Ring A] [Algebra k A]
+variable [AddCommGroup M] [Module k M] [Module Aᵐᵒᵖ M]
+variable [AddCommGroup N] [Module k N] [Module A N] [IsScalarTower k A N]
+variable [AddCommGroup N'] [Module k N'] [Module A N'] [IsScalarTower k A N']
+variable [AddCommGroup N''] [Module k N''] [Module A N''] [IsScalarTower k A N'']
+
+/-- The actual covariant map in the left-module factor of a balanced tensor. -/
+def mapRightTo (f : N →ₗ[A] N') : Tensor k A M N →ₗ[k] Tensor k A M N' :=
+  lift ((mk k A M N').compl₁₂ LinearMap.id (f.restrictScalars k)) (by
+    intro a m n
+    change mk k A M N' (MulOpposite.op a • m) (f n) = mk k A M N' m (f (a • n))
+    rw [f.map_smul,balance])
+
+@[simp] theorem mapRightTo_mk (f : N →ₗ[A] N') (m : M) (n : N) :
+    mapRightTo (k := k) (M := M) f (mk k A M N m n) = mk k A M N' m (f n) := rfl
+
+end BalancedTensor
+
+namespace IdempotentTensor
+universe u
+variable {k A N N' N'' : Type u} [Field k] [Ring A] [Algebra k A]
+variable [AddCommGroup N] [Module k N] [Module A N] [IsScalarTower k A N]
+variable [AddCommGroup N'] [Module k N'] [Module A N'] [IsScalarTower k A N']
+variable [AddCommGroup N''] [Module k N''] [Module A N''] [IsScalarTower k A N'']
+variable (e : A)
+
+def spaceMap (f : N →ₗ[A] N') : leftSpace (k := k) e N →ₗ[k] leftSpace (k := k) e N' where
+  toFun x := ⟨f x.val, by
+    change e • f x.val = f x.val
+    rw [← f.map_smul,x.property]⟩
+  map_add' x y := Subtype.ext (f.map_add x.val y.val)
+  map_smul' r x := Subtype.ext ((f.restrictScalars k).map_smul r x.val)
+
+theorem tensorEval_naturality (f : N →ₗ[A] N') (z : BalancedTensor.Tensor k A (rightIdeal e) N) :
+    tensorEval (k := k) e N' (BalancedTensor.mapRightTo f z) =
+      spaceMap (k := k) e f (tensorEval (k := k) e N z) := by
+  induction z using BalancedTensor.induction_on with
+  | hz => simp only [map_zero]
+  | ht m n =>
+    apply Subtype.ext
+    exact (f.map_smul m.val n).symm
+  | ha x y hx hy => simp only [map_add,hx,hy]
+
+/-- Taking an idempotent part preserves exactness, with an explicit projected preimage. -/
+theorem spaceMap_exact (he : e*e=e) (f : N →ₗ[A] N') (g : N' →ₗ[A] N'')
+    (h : Function.Exact f g) : Function.Exact (spaceMap (k := k) e f) (spaceMap (k := k) e g) := by
+  intro x
+  constructor
+  · intro hx
+    have hx' : g x.val = 0 := congrArg Subtype.val hx
+    obtain ⟨y,hy⟩ := (h x.val).mp hx'
+    refine ⟨⟨e • y, by change e • (e • y) = e • y; rw [← mul_smul,he]⟩, ?_⟩
+    apply Subtype.ext
+    change f (e • y) = x.val
+    rw [f.map_smul,hy,x.property]
+  · rintro ⟨y,rfl⟩
+    apply Subtype.ext
+    exact (h (f y.val)).mpr ⟨y.val,rfl⟩
+
+/-- Tensor with the actual projective eA preserves every exact module sequence. -/
+theorem tensor_exact (he : e*e=e) (f : N →ₗ[A] N') (g : N' →ₗ[A] N'')
+    (h : Function.Exact f g) :
+    Function.Exact (BalancedTensor.mapRightTo (k := k) (M := rightIdeal e) f)
+      (BalancedTensor.mapRightTo (k := k) (M := rightIdeal e) g) := by
+  intro z
+  constructor
+  · intro hz
+    have hx : spaceMap (k := k) e g (tensorEquiv (k := k) e N' he z) = 0 := by
+      change spaceMap (k := k) e g (tensorEval (k := k) e N' z) = 0
+      rw [← tensorEval_naturality,hz,map_zero]
+    obtain ⟨y,hy⟩ := (spaceMap_exact (k := k) e he f g h _).mp hx
+    refine ⟨(tensorEquiv (k := k) e N he).symm y, ?_⟩
+    apply (tensorEquiv (k := k) e N' he).injective
+    change tensorEval (k := k) e N' (BalancedTensor.mapRightTo f ((tensorEquiv (k := k) e N he).symm y)) =
+      tensorEquiv (k := k) e N' he z
+    rw [tensorEval_naturality]
+    change spaceMap (k := k) e f ((tensorEquiv (k := k) e N he) ((tensorEquiv (k := k) e N he).symm y)) = _
+    rw [LinearEquiv.apply_symm_apply,hy]
+  · rintro ⟨y,rfl⟩
+    induction y using BalancedTensor.induction_on with
+    | hz => simp only [map_zero]
+    | ht m n =>
+      rw [BalancedTensor.mapRightTo_mk,BalancedTensor.mapRightTo_mk,(h (f n)).mpr ⟨n,rfl⟩,map_zero]
+    | ha x y hx hy => simp only [map_add,hx,hy,add_zero]
+end IdempotentTensor
+end LittleFinitistic
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryTensorFiniteMatrix.lean b/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryTensorFiniteMatrix.lean
new file mode 100644
index 0000000000000000000000000000000000000000..8decea0fc4f1ed2e7aaad012daed2448adc9d3b7
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryTensorFiniteMatrix.lean
@@ -0,0 +1,108 @@
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryTensorMixedSign
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryFiniteTotal
+
+namespace OAI
+noncomputable section
+open CategoryTheory
+namespace LittleFinitistic.ComplexTensor
+universe u
+variable (k A : Type u) [Field k] [Ring A] [Algebra k A]
+variable (Q : CochainComplex (ModuleCat.{u} Aᵐᵒᵖ) ℤ)
+variable (Z : CochainComplex (ModuleCat.{u} A) ℤ)
+variable {l : ℕ} (p : Fin l → ℤ)
+
+abbrev columns := fun i : Fin l => column k A Q Z (p i)
+
+/-- The actual horizontal matrix entry, zero unless the right degrees are consecutive. -/
+def entry (n : ℤ) (i j : Fin l) :
+    term k A Q Z (p i) (n + -(p i)) →ₗ[k] term k A Q Z (p j) ((n+1) + -(p j)) :=
+  if h : p i + 1 = p j then horizontal k A Q Z n (p i) (p j) h else 0
+
+theorem entry_square (n : ℤ) (i j t : Fin l) :
+    (entry k A Q Z p (n+1) j t).comp (entry k A Q Z p n i j) = 0 := by
+  unfold entry
+  split_ifs with h₁ h₂ h₂
+  · exact horizontal_square k A Q Z n (p i) (p j) (p t) h₂ h₁
+  · simp only [LinearMap.comp_zero]
+  · simp only [LinearMap.zero_comp]
+  · simp only [LinearMap.zero_comp]
+
+theorem entry_mixed (n : ℤ) (i j : Fin l) :
+    (vertical k A Q Z (n+1) (p j)).comp (entry k A Q Z p n i j) +
+      (entry k A Q Z p (n+1) i j).comp (vertical k A Q Z n (p i)) = 0 := by
+  unfold entry
+  split_ifs with h
+  · exact horizontal_mixed k A Q Z n (p i) (p j) h
+  · simp only [LinearMap.comp_zero,LinearMap.zero_comp,add_zero]
+
+/-- The actual finite horizontal tensor differential, on the sum of all selected columns. -/
+def matrix (n : ℤ) : FiniteColumnComplex.term (columns k A Q Z p) n →ₗ[k]
+    FiniteColumnComplex.term (columns k A Q Z p) (n+1) :=
+  LinearMap.pi (fun j => ∑ i : Fin l, (entry k A Q Z p n i j).comp (LinearMap.proj i))
+
+@[simp] theorem matrix_apply (n : ℤ)
+    (z : FiniteColumnComplex.term (columns k A Q Z p) n) (j : Fin l) :
+    matrix k A Q Z p n z j = ∑ i : Fin l, entry k A Q Z p n i j (z i) := by
+  change ((∑ i : Fin l, (entry k A Q Z p n i j).comp
+    (LinearMap.proj i) : (∀ t : Fin l, term k A Q Z (p t) (n + -(p t))) →ₗ[k]
+      term k A Q Z (p j) ((n+1) + -(p j))) z) = _
+  exact LinearMap.sum_apply _ _ _
+
+theorem matrix_square (n : ℤ) :
+    (matrix k A Q Z p (n+1)).comp (matrix k A Q Z p n) = 0 := by
+  apply LinearMap.ext
+  intro z
+  funext j
+  change matrix k A Q Z p (n+1) (matrix k A Q Z p n z) j = 0
+  simp only [matrix_apply,map_sum]
+  apply Finset.sum_eq_zero
+  intro i _
+  apply Finset.sum_eq_zero
+  intro t _
+  exact congrArg (fun f => f (z t)) (entry_square k A Q Z p n t i j)
+
+theorem matrix_mixed (n : ℤ) :
+    (FiniteColumnComplex.diagonal (columns k A Q Z p) (n+1)).comp (matrix k A Q Z p n) +
+    (matrix k A Q Z p (n+1)).comp (FiniteColumnComplex.diagonal (columns k A Q Z p) n) = 0 := by
+  apply LinearMap.ext
+  intro z
+  funext j
+  change ((column k A Q Z (p j)).d (n+1) ((n+1)+1)).hom (matrix k A Q Z p n z j) +
+    matrix k A Q Z p (n+1) (FiniteColumnComplex.diagonal (columns k A Q Z p) n z) j = 0
+  simp only [matrix_apply,FiniteColumnComplex.diagonal_apply]
+  erw [map_sum, ← Finset.sum_add_distrib]
+  apply Finset.sum_eq_zero
+  intro i _
+  have h := congrArg (fun f => f (z i)) (entry_mixed k A Q Z p n i j)
+  simp only [vertical] at h
+  simp only [column_d]
+  exact h
+
+theorem matrix_upper (hp : StrictMono p) (n : ℤ) (j : Fin l)
+    (z : FiniteColumnComplex.term (columns k A Q Z p) n)
+    (hz : ∀ i : Fin l, i.val < j.val → z i = 0) : matrix k A Q Z p n z j = 0 := by
+  rw [matrix_apply]
+  apply Finset.sum_eq_zero
+  intro i _
+  unfold entry
+  split_ifs with h
+  · have hij : i < j := hp.lt_iff_lt.mp (by omega)
+    erw [hz i hij,map_zero]
+    rfl
+  · rfl
+
+/-- Actual tensor horizontal maps satisfy every requirement of the finite total construction. -/
+def tensorHorizontal (hp : StrictMono p) : FiniteColumnComplex.Horizontal (columns k A Q Z p) where
+  d := matrix k A Q Z p
+  square := matrix_square k A Q Z p
+  mixed := matrix_mixed k A Q Z p
+  strictUpper := matrix_upper k A Q Z p hp
+
+/-- The signed total tensor complex on a finite interval of the right complex. -/
+def finiteTotal (hp : StrictMono p) : CochainComplex (ModuleCat.{u} k) ℤ :=
+  FiniteColumnComplex.total (columns k A Q Z p) (tensorHorizontal k A Q Z p hp)
+end LittleFinitistic.ComplexTensor
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryTensorGlobalDimension.lean b/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryTensorGlobalDimension.lean
new file mode 100644
index 0000000000000000000000000000000000000000..0621fb78f7bf57f6d9f41cfcf63352ea63875ec1
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryTensorGlobalDimension.lean
@@ -0,0 +1,42 @@
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryTensorDirected
+import OAI.Algebra.Finitistic.Encoding.ThreeVertexAlgebra
+
+namespace OAI
+noncomputable section
+open CategoryTheory
+open scoped TensorProduct
+namespace LittleFinitistic.OrdinarySimulation
+universe u v
+variable {k B : Type u} [Field k] [Ring B] [Algebra k B]
+
+/-- The source tensor algebra bound uses exactly 3(l+1) directed vertices, on both sides. -/
+theorem tensor_globalDimension_bound (DB : DirectedBound.DirectedSystem k B 3) (l : ℕ) :
+    (⨆ M : ModuleCat.{max u v} (B ⊗[k] ChainAlgebra k l), projectiveDimension M) ≤ (3*l+2 : ℕ) ∧
+    (⨆ M : ModuleCat.{max u v} (B ⊗[k] ChainAlgebra k l)ᵐᵒᵖ, projectiveDimension M) ≤ (3*l+2 : ℕ) := by
+  have h := DirectedBound.DirectedSystem.both_sides_globalDimension_le.{u,v}
+    (TensorDirected.directedSystem DB (ChainAlgebra.directedSystem k l))
+  have hn : (l+1)*3-1 = 3*l+2 := by omega
+  simpa only [hn] using h
+
+/-- The corresponding bound holds for each arbitrary left or right module. -/
+theorem tensor_projectiveDimension_bound (DB : DirectedBound.DirectedSystem k B 3) (l : ℕ) :
+    (∀ M : ModuleCat.{max u v} (B ⊗[k] ChainAlgebra k l), projectiveDimension M ≤ (3*l+2 : ℕ)) ∧
+    (∀ M : ModuleCat.{max u v} (B ⊗[k] ChainAlgebra k l)ᵐᵒᵖ, projectiveDimension M ≤ (3*l+2 : ℕ)) := by
+  have h := DirectedBound.DirectedSystem.both_sides_projectiveDimension_le.{u,v}
+    (TensorDirected.directedSystem DB (ChainAlgebra.directedSystem k l))
+  have hn : (l+1)*3-1 = 3*l+2 := by omega
+  simpa only [hn] using h
+
+variable {V W U : Type u} [AddCommGroup V] [Module k V] [AddCommGroup W] [Module k W]
+  [AddCommGroup U] [Module k U]
+
+/-- The bound for the actual three-vertex coefficient algebra used by the manuscript. -/
+theorem source_tensor_globalDimension_bound (μ : W →ₗ[k] V →ₗ[k] U) (l : ℕ) :
+    (⨆ M : ModuleCat.{max u v} (ThreeVertexAlgebra μ ⊗[k] ChainAlgebra k l), projectiveDimension M) ≤ (3*l+2 : ℕ) ∧
+    (⨆ M : ModuleCat.{max u v} (ThreeVertexAlgebra μ ⊗[k] ChainAlgebra k l)ᵐᵒᵖ, projectiveDimension M) ≤ (3*l+2 : ℕ) :=
+  tensor_globalDimension_bound (ThreeVertexAlgebra.directedSystem μ) l
+end LittleFinitistic.OrdinarySimulation
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryTensorIdeal.lean b/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryTensorIdeal.lean
new file mode 100644
index 0000000000000000000000000000000000000000..c9c36003bab9a9a2c2b164e381ee6a8569831421
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryTensorIdeal.lean
@@ -0,0 +1,68 @@
+import OAI.Algebra.Finitistic.Tensor.IdempotentTensor
+import Mathlib.RingTheory.TensorProduct.Maps
+
+namespace OAI
+noncomputable section
+open scoped TensorProduct
+namespace LittleFinitistic.OrdinarySimulation.TensorIdeal
+universe u
+variable {k B C : Type u} [Field k] [Ring B] [Ring C] [Algebra k B] [Algebra k C]
+variable (e : C) (he : e*e=e)
+
+def vertex : B ⊗[k] C := (1:B) ⊗ₜ[k] e
+
+include he in
+theorem vertex_idempotent : vertex (k := k) (B := B) e * vertex e = vertex e := by
+  simp only [vertex, Algebra.TensorProduct.tmul_mul_tmul, one_mul, he]
+
+def project : C →ₗ[k] IdempotentTensor.rightIdeal e where
+  toFun c := ⟨e*c, by change e*(e*c)=e*c; rw [← mul_assoc,he]⟩
+  map_add' x y := Subtype.ext (mul_add e x y)
+  map_smul' r x := Subtype.ext (mul_smul_comm r e x)
+
+def inclusion : B ⊗[k] IdempotentTensor.rightIdeal e →ₗ[k] B ⊗[k] C :=
+  TensorProduct.map (LinearMap.id) ((IdempotentTensor.rightIdeal e).subtype.restrictScalars k)
+
+def retraction : B ⊗[k] C →ₗ[k] B ⊗[k] IdempotentTensor.rightIdeal e :=
+  TensorProduct.map (LinearMap.id) (project e he)
+
+theorem inclusion_retraction (z : B ⊗[k] C) :
+    inclusion e (retraction e he z) = vertex e * z := by
+  induction z using TensorProduct.inductionOn with
+  | tmul b c =>
+    simp only [inclusion,retraction,TensorProduct.map_tmul,LinearMap.id_apply,
+      LinearMap.restrictScalars_apply,Submodule.subtype_apply,project,LinearMap.coe_mk,
+      AddHom.coe_mk,vertex,Algebra.TensorProduct.tmul_mul_tmul,one_mul]
+  | add x y hx hy => simp only [map_add,mul_add,hx,hy]
+
+theorem retraction_inclusion (z : B ⊗[k] IdempotentTensor.rightIdeal e) :
+    retraction e he (inclusion e z) = z := by
+  induction z using TensorProduct.inductionOn with
+  | tmul b c =>
+    change b ⊗ₜ[k] (⟨e*c.val, _⟩ : IdempotentTensor.rightIdeal e) = b ⊗ₜ[k] c
+    congr 1
+    exact Subtype.ext c.property
+  | add x y hx hy => simp only [map_add,hx,hy]
+
+include he in
+theorem inclusion_fixed (z : B ⊗[k] IdempotentTensor.rightIdeal e) :
+    vertex e * inclusion e z = inclusion e z := by
+  rw [← inclusion_retraction e he, retraction_inclusion e he]
+
+/-- The source term B tensor eC is the actual right ideal (1 tensor e)(B tensor C). -/
+def equivalence : B ⊗[k] IdempotentTensor.rightIdeal e ≃ₗ[k]
+    IdempotentTensor.rightIdeal (vertex (k := k) (B := B) e) where
+  toFun z := ⟨inclusion e z, inclusion_fixed e he z⟩
+  invFun z := retraction e he z.val
+  left_inv := retraction_inclusion e he
+  right_inv z := Subtype.ext ((inclusion_retraction e he z.val).trans z.property)
+  map_add' x y := Subtype.ext (map_add _ x y)
+  map_smul' r x := Subtype.ext (map_smul _ r x)
+
+@[simp] theorem equivalence_tmul (b : B) (c : IdempotentTensor.rightIdeal e) :
+    (equivalence (B := B) e he (b ⊗ₜ[k] c)).val = b ⊗ₜ[k] c.val := rfl
+end LittleFinitistic.OrdinarySimulation.TensorIdeal
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryTensorIdealActions.lean b/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryTensorIdealActions.lean
new file mode 100644
index 0000000000000000000000000000000000000000..e84e81a2c4e7744db518b8356f85826a120cd3c6
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryTensorIdealActions.lean
@@ -0,0 +1,67 @@
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryTensorIdeal
+
+namespace OAI
+noncomputable section
+open scoped TensorProduct
+namespace LittleFinitistic.OrdinarySimulation.TensorIdeal
+universe u
+variable {k B C : Type u} [Field k] [Ring B] [Ring C] [Algebra k B] [Algebra k C]
+variable (e : C)
+
+abbrev coefficient : B →ₐ[k] B ⊗[k] C := Algebra.TensorProduct.includeLeft
+
+theorem coefficient_commute (b : B) :
+    vertex (k := k) e * coefficient b = coefficient b * vertex e := by
+  simp only [vertex,coefficient,Algebra.TensorProduct.includeLeft_apply,
+    Algebra.TensorProduct.tmul_mul_tmul,one_mul,mul_one]
+
+def leftMultiply (b : B) : IdempotentTensor.rightIdeal (vertex (k := k) (B := B) e) →ₗ[(B ⊗[k] C)ᵐᵒᵖ]
+    IdempotentTensor.rightIdeal (vertex (k := k) (B := B) e) where
+  toFun x := ⟨coefficient b * x.val, by
+    change vertex e * (coefficient b * x.val) = coefficient b * x.val
+    rw [← mul_assoc, coefficient_commute, mul_assoc, x.property]⟩
+  map_add' x y := Subtype.ext (mul_add _ _ _)
+  map_smul' r x := Subtype.ext (mul_assoc _ _ r.unop).symm
+
+def leftAction : B →ₐ[k] Module.End (B ⊗[k] C)ᵐᵒᵖ
+    (IdempotentTensor.rightIdeal (vertex (k := k) (B := B) e)) where
+  toFun := leftMultiply e
+  map_one' := by ext x; exact one_mul x.val
+  map_mul' b c := by
+    ext x
+    change coefficient (b*c) * x.val = coefficient b * (coefficient c * x.val)
+    rw [map_mul,mul_assoc]
+  map_zero' := by
+    ext x
+    change coefficient (0:B) * x.val = 0
+    rw [map_zero,zero_mul]
+  map_add' b c := by
+    ext x
+    change coefficient (b+c) * x.val = coefficient b * x.val + coefficient c * x.val
+    rw [map_add,add_mul]
+  commutes' r := by
+    ext x
+    change coefficient (algebraMap k B r) * x.val = r • x.val
+    rw [AlgHom.commutes, Algebra.smul_def]
+
+instance leftModule : Module B (IdempotentTensor.rightIdeal (vertex (k := k) (B := B) e)) :=
+  Module.compHom _ (leftAction (k := k) (B := B) e).toRingHom
+
+instance towerLeft : IsScalarTower k B (IdempotentTensor.rightIdeal (vertex (k := k) (B := B) e)) where
+  smul_assoc r b x := by
+    change leftAction e (r • b) x = r • leftAction e b x
+    rw [map_smul]
+    rfl
+
+instance commute : SMulCommClass B (B ⊗[k] C)ᵐᵒᵖ
+    (IdempotentTensor.rightIdeal (vertex (k := k) (B := B) e)) where
+  smul_comm b r x := (leftAction e b).map_smul r x
+
+@[simp] theorem left_smul_value (b : B)
+    (x : IdempotentTensor.rightIdeal (vertex (k := k) (B := B) e)) :
+    (b • x).val = coefficient b * x.val := rfl
+end LittleFinitistic.OrdinarySimulation.TensorIdeal
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryTensorInputMaps.lean b/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryTensorInputMaps.lean
new file mode 100644
index 0000000000000000000000000000000000000000..4bd9f4ce71737ed383014fab0fd0baab9016c293
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryTensorInputMaps.lean
@@ -0,0 +1,78 @@
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryTensorFiniteMatrix
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryFiniteTotalMaps
+
+namespace OAI
+noncomputable section
+open CategoryTheory
+namespace LittleFinitistic.ComplexTensor
+open BalancedTensor
+universe u
+variable (k A : Type u) [Field k] [Ring A] [Algebra k A]
+variable (Q : CochainComplex (ModuleCat.{u} Aᵐᵒᵖ) ℤ)
+variable {Z Z' : CochainComplex (ModuleCat.{u} A) ℤ} (f : Z ⟶ Z')
+
+/-- The actual map induced by an input chain map in a single balanced tensor term. -/
+def inputMap (p q : ℤ) : term k A Q Z p q →ₗ[k] term k A Q Z' p q :=
+  bimap (k := k) (M := rightTerm k A Q p) (M' := rightTerm k A Q p)
+    (N := leftTerm k A Z q) (N' := leftTerm k A Z' q) LinearMap.id (f.f q).hom
+
+/-- Input chain maps act on the signed columns by the actual shifted tensor functor. -/
+def columnMap (p : ℤ) : column k A Q Z p ⟶ column k A Q Z' p :=
+  (shiftFunctor _ (-p)).map
+    (((fixedTensorFunctor k A (rightTerm k A Q p)).mapHomologicalComplex (.up ℤ)).map f)
+
+@[simp] theorem columnMap_f (p n : ℤ) :
+    ((columnMap k A Q f p).f n).hom = inputMap k A Q f p (n + -p) := by
+  apply BalancedTensor.ext
+  intro x y
+  rfl
+
+theorem inputMap_transport {q q' : ℤ} (h : q=q') :
+    eqToHom (congrArg Z.X h) ≫ f.f q' = f.f q ≫ eqToHom (congrArg Z'.X h) := by
+  subst q'
+  simp only [eqToHom_refl,Category.id_comp,Category.comp_id]
+
+/-- The horizontal tensor differential is natural in the arbitrary input complex. -/
+theorem horizontal_inputMap (n p p' : ℤ) (h : p+1=p') :
+    (horizontal k A Q Z' n p p' h).comp (inputMap k A Q f p (n + -p)) =
+      (inputMap k A Q f p' ((n+1) + -p')).comp (horizontal k A Q Z n p p' h) := by
+  unfold horizontal inputMap map
+  erw [bimap_comp,bimap_comp,LinearMap.comp_id]
+  congr 1
+  have hn := inputMap_transport A f (show n + -p = (n+1) + -p' by omega)
+  exact congrArg ModuleCat.Hom.hom hn.symm
+
+variable {l : ℕ} (p : Fin l → ℤ) (hp : StrictMono p)
+
+theorem entry_inputMap (n : ℤ) (i j : Fin l) :
+    (entry k A Q Z' p n i j).comp (inputMap k A Q f (p i) (n + -(p i))) =
+      (inputMap k A Q f (p j) ((n+1) + -(p j))).comp (entry k A Q Z p n i j) := by
+  unfold entry
+  split_ifs with h
+  · exact horizontal_inputMap k A Q f n (p i) (p j) h
+  · simp only [LinearMap.zero_comp,LinearMap.comp_zero]
+
+/-- The full horizontal matrix commutes with the actual input map. -/
+theorem matrix_inputMap (n : ℤ) :
+    (matrix k A Q Z' p n).comp
+      (FiniteColumnComplex.componentMap (columns k A Q Z p) (columns k A Q Z' p)
+        (fun i => columnMap k A Q f (p i)) n) =
+    (FiniteColumnComplex.componentMap (columns k A Q Z p) (columns k A Q Z' p)
+      (fun i => columnMap k A Q f (p i)) (n+1)).comp (matrix k A Q Z p n) := by
+  apply LinearMap.ext
+  intro z
+  funext j
+  change matrix k A Q Z' p n
+    (FiniteColumnComplex.componentMap (columns k A Q Z p) (columns k A Q Z' p)
+      (fun i => columnMap k A Q f (p i)) n z) j =
+      ((columnMap k A Q f (p j)).f (n+1)).hom (matrix k A Q Z p n z j)
+  simp only [matrix_apply,FiniteColumnComplex.componentMap_apply,columnMap_f]
+  erw [map_sum]
+  apply Finset.sum_congr rfl
+  intro i _
+  exact congrArg (fun g => g (z i)) (entry_inputMap k A Q f p n i j)
+end LittleFinitistic.ComplexTensor
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryTensorMixedSign.lean b/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryTensorMixedSign.lean
new file mode 100644
index 0000000000000000000000000000000000000000..9498ffa9ba9fa50a15de835797abf37ccc7c8284
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryTensorMixedSign.lean
@@ -0,0 +1,42 @@
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryComplexTensorMaps
+
+namespace OAI
+noncomputable section
+open CategoryTheory
+namespace LittleFinitistic.ComplexTensor
+universe u
+variable (k A : Type u) [Field k] [Ring A] [Algebra k A]
+variable (Q : CochainComplex (ModuleCat.{u} Aᵐᵒᵖ) ℤ)
+variable (Z : CochainComplex (ModuleCat.{u} A) ℤ)
+
+theorem transport_d {q q' r r' : ℤ} (hq : q=q') (hr : r=r') :
+    eqToHom (congrArg Z.X hq) ≫ Z.d q' r' = Z.d q r ≫ eqToHom (congrArg Z.X hr) := by
+  subst q'
+  subst r'
+  simp only [eqToHom_refl,Category.id_comp,Category.comp_id]
+
+/-- Signed vertical tensor differential on the concrete balanced tensor term. -/
+def vertical (n p : ℤ) : term k A Q Z p (n + -p) →ₗ[k] term k A Q Z p ((n+1) + -p) :=
+  (-p).negOnePow • map k A Q Z (𝟙 (Q.X p)) (Z.d (n + -p) ((n+1) + -p))
+
+/-- The two mixed terms cancel with the actual integer total-complex signs. -/
+theorem horizontal_mixed (n p p' : ℤ) (h : p+1=p') :
+    (vertical k A Q Z (n+1) p').comp (horizontal k A Q Z n p p' h) +
+      (horizontal k A Q Z (n+1) p p' h).comp (vertical k A Q Z n p) = 0 := by
+  unfold vertical horizontal
+  rw [LinearMap.smul_comp,LinearMap.comp_smul,map_comp,map_comp,Category.comp_id,Category.id_comp]
+  have hd := transport_d A Z
+    (show n + -p = (n+1) + -p' by omega)
+    (show (n+1) + -p = ((n+1)+1) + -p' by omega)
+  rw [hd]
+  have hs : (-p').negOnePow = -(-p).negOnePow := by
+    subst p'
+    simp only [Int.negOnePow_neg,Int.negOnePow_succ]
+  rw [hs]
+  change (-(↑((-p).negOnePow) : ℤ)) • _ + (↑((-p).negOnePow) : ℤ) • _ = (0 : term k A Q Z p (n + -p) →ₗ[k] term k A Q Z p' (((n+1)+1) + -p'))
+  rw [neg_smul,neg_add_cancel]
+end LittleFinitistic.ComplexTensor
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryTensorResolution.lean b/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryTensorResolution.lean
new file mode 100644
index 0000000000000000000000000000000000000000..82d5fd135da9420c78195b000b8732d494a6bc9e
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryTensorResolution.lean
@@ -0,0 +1,103 @@
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryResolutionQuasiIso
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryTensorIdealActions
+import Mathlib.RingTheory.Flat.Basic
+
+namespace OAI
+noncomputable section
+open CategoryTheory
+open scoped TensorProduct
+namespace LittleFinitistic.OrdinarySimulation
+universe u
+variable (k B : Type u) [Field k] [Ring B] [Algebra k B] (l : ℕ)
+namespace TensorResolution
+open ChainAlgebra
+
+abbrev term (n : ℕ) := IdempotentTensor.rightIdeal
+  (TensorIdeal.vertex (k := k) (B := B) (extendedVertex k l n))
+
+def termEquiv (n : ℕ) : B ⊗[k] resolutionIdeal k l n ≃ₗ[k] term k B l n :=
+  TensorIdeal.equivalence _ (extendedVertex_idempotent k l n)
+
+def regularEquiv : (B ⊗[k] ChainAlgebra k l)ᵐᵒᵖ ≃ₗ[(B ⊗[k] ChainAlgebra k l)ᵐᵒᵖ]
+    B ⊗[k] ChainAlgebra k l where
+  toFun := MulOpposite.unop
+  invFun := MulOpposite.op
+  left_inv _ := rfl
+  right_inv _ := rfl
+  map_add' _ _ := rfl
+  map_smul' _ _ := rfl
+
+def leftMultiply (x : B ⊗[k] ChainAlgebra k l) :
+    B ⊗[k] ChainAlgebra k l →ₗ[(B ⊗[k] ChainAlgebra k l)ᵐᵒᵖ] B ⊗[k] ChainAlgebra k l where
+  toFun y := x*y
+  map_add' := mul_add x
+  map_smul' r y := (mul_assoc x y r.unop).symm
+
+def retract (n : ℕ) : B ⊗[k] ChainAlgebra k l →ₗ[(B ⊗[k] ChainAlgebra k l)ᵐᵒᵖ] term k B l n :=
+  (leftMultiply k B l (TensorIdeal.vertex (k := k) (B := B) (extendedVertex k l n))).codRestrict _ (fun x => by
+    change _ * (_ * x) = _ * x
+    rw [← mul_assoc, TensorIdeal.vertex_idempotent _ (extendedVertex_idempotent k l n)])
+
+instance term_projective (n : ℕ) : Module.Projective (B ⊗[k] ChainAlgebra k l)ᵐᵒᵖ (term k B l n) := by
+  let : Module.Projective (B ⊗[k] ChainAlgebra k l)ᵐᵒᵖ (B ⊗[k] ChainAlgebra k l) :=
+    Module.Projective.of_equiv (regularEquiv k B l)
+  apply Module.Projective.of_split (term k B l n).subtype (retract k B l n)
+  ext x
+  exact x.property
+
+/-- The B-extended resolution differential is left multiplication by 1 tensor c. -/
+def differential (n : ℕ) : term k B l n →ₗ[(B ⊗[k] ChainAlgebra k l)ᵐᵒᵖ] term k B l (n+1) :=
+  ((leftMultiply k B l ((1:B) ⊗ₜ[k] extendedArrow k l n)).comp (term k B l n).subtype).codRestrict _ (fun x => by
+    change TensorIdeal.vertex (k := k) (B := B) (extendedVertex k l (n+1)) *
+      (((1:B) ⊗ₜ[k] extendedArrow k l n) * x.val) = ((1:B) ⊗ₜ[k] extendedArrow k l n) * x.val
+    rw [← mul_assoc]
+    congr 1
+    simp only [TensorIdeal.vertex,Algebra.TensorProduct.tmul_mul_tmul,one_mul,extendedArrow_target])
+
+theorem differential_square (n : ℕ) : (differential k B l (n+1)).comp (differential k B l n) = 0 := by
+  ext x
+  change ((1:B) ⊗ₜ[k] extendedArrow k l (n+1)) * (((1:B) ⊗ₜ[k] extendedArrow k l n) * x.val) = 0
+  rw [← mul_assoc,Algebra.TensorProduct.tmul_mul_tmul,extendedArrow_square,TensorProduct.tmul_zero,zero_mul]
+
+theorem termEquiv_d (n : ℕ) (z : B ⊗[k] resolutionIdeal k l n) :
+    termEquiv k B l (n+1) (((resolutionDifferential k l n).hom.restrictScalars k).lTensor B z) =
+      differential k B l n (termEquiv k B l n z) := by
+  induction z using TensorProduct.inductionOn with
+  | tmul b c =>
+    apply Subtype.ext
+    change b ⊗ₜ[k] (extendedArrow k l n * c.val) =
+      ((1:B) ⊗ₜ[k] extendedArrow k l n) * (b ⊗ₜ[k] c.val)
+    rw [Algebra.TensorProduct.tmul_mul_tmul,one_mul]
+  | add x y hx hy => simp only [map_add,hx,hy]
+
+/-- Every interior exact sequence stays exact after the actual B-extension over k. -/
+theorem differential_exact (n : ℕ) (hn : n+1 < l) :
+    Function.Exact (differential k B l n) (differential k B l (n+1)) := by
+  have hc : Function.Exact ((resolutionDifferential k l n).hom.restrictScalars k)
+      ((resolutionDifferential k l (n+1)).hom.restrictScalars k) := by
+    intro x
+    constructor
+    · intro hx
+      exact (ShortComplex.moduleCat_exact_iff _).mp (supported_complex_exact k l n hn) x hx
+    · rintro ⟨y,rfl⟩
+      have h := congrArg (fun f => f.hom y) (resolutionDifferential_square k l n)
+      exact h
+  have ht := Module.Flat.lTensor_exact B hc
+  intro x
+  constructor
+  · intro hx
+    have hzero : (((resolutionDifferential k l (n+1)).hom.restrictScalars k).lTensor B)
+        ((termEquiv k B l (n+1)).symm x) = 0 := by
+      apply (termEquiv k B l (n+2)).injective
+      rw [termEquiv_d,LinearEquiv.apply_symm_apply,hx,map_zero]
+    obtain ⟨y,hy⟩ := (ht _).mp hzero
+    refine ⟨termEquiv k B l n y, ?_⟩
+    rw [← termEquiv_d,hy,LinearEquiv.apply_symm_apply]
+  · rintro ⟨y,rfl⟩
+    exact congrArg (fun f => f y) (differential_square k B l n)
+end TensorResolution
+end LittleFinitistic.OrdinarySimulation
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryTensorResolutionComplex.lean b/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryTensorResolutionComplex.lean
new file mode 100644
index 0000000000000000000000000000000000000000..7e9f1d842be923cd43a7bb343c67bdb9ec11d477
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryTensorResolutionComplex.lean
@@ -0,0 +1,161 @@
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryTensorAugmentation
+
+namespace OAI
+noncomputable section
+open CategoryTheory Limits
+open scoped TensorProduct
+namespace LittleFinitistic.OrdinarySimulation.TensorResolution
+universe u
+variable (k B : Type u) [Field k] [Ring B] [Algebra k B] (l : ℕ)
+
+abbrev termObject (n : ℕ) : ModuleCat.{u} (B ⊗[k] ChainAlgebra k l)ᵐᵒᵖ := ModuleCat.of _ (term k B l n)
+
+def complex : CochainComplex (ModuleCat.{u} (B ⊗[k] ChainAlgebra k l)ᵐᵒᵖ) ℕ :=
+  CochainComplex.of (termObject k B l) (fun n => ModuleCat.ofHom (differential k B l n))
+    (fun n => by apply ModuleCat.hom_ext; exact differential_square k B l n)
+
+instance projectiveTerm (n : ℕ) : Projective (termObject k B l n) := inferInstance
+
+theorem term_vanishes (n : ℕ) (h : l < n) : IsZero (termObject k B l n) := by
+  apply ModuleCat.isZero_iff_subsingleton.mpr
+  have hz (x : term k B l n) : x = 0 := by
+    apply Subtype.ext
+    have hp := x.property
+    change ((1:B) ⊗ₜ[k] ChainAlgebra.extendedVertex k l n) * x.val = x.val at hp
+    rw [ChainAlgebra.extendedVertex,dite_eq_right (Nat.not_le.mpr h),TensorProduct.tmul_zero,zero_mul] at hp
+    exact hp.symm
+  exact ⟨fun x y => (hz x).trans (hz y).symm⟩
+
+/-- Every differential preserves the regular left B-action. -/
+theorem differential_left (n : ℕ) (b : B) (x : term k B l n) :
+    differential k B l n (b • x) = b • differential k B l n x := by
+  apply Subtype.ext
+  change ((1:B) ⊗ₜ[k] ChainAlgebra.extendedArrow k l n) * (TensorIdeal.coefficient b * x.val) =
+    TensorIdeal.coefficient b * (((1:B) ⊗ₜ[k] ChainAlgebra.extendedArrow k l n) * x.val)
+  rw [← mul_assoc,← mul_assoc]
+  congr 1
+  simp only [TensorIdeal.coefficient,Algebra.TensorProduct.includeLeft_apply,
+    Algebra.TensorProduct.tmul_mul_tmul,one_mul,mul_one]
+
+theorem complex_exactAt (n : ℕ) (hn : n ≠ l) : (complex k B l).ExactAt n := by
+  by_cases h : l < n
+  · exact HomologicalComplex.ExactAt.of_isZero (term_vanishes k B l n h)
+  have hnl : n < l := by omega
+  cases n with
+  | zero =>
+    rw [HomologicalComplex.exactAt_iff, ShortComplex.moduleCat_exact_iff]
+    intro x hx
+    have hx' : differential k B l 0 x = 0 := by
+      change ((complex k B l).d 0 ((ComplexShape.up ℕ).next 0)).hom x = 0 at hx
+      rw [show (ComplexShape.up ℕ).next 0 = 1 by simp] at hx
+      change (CochainComplex.of.d (termObject k B l) (fun n => ModuleCat.ofHom (differential k B l n)) 0 (0+1)).hom x = 0 at hx
+      rw [CochainComplex.of_d] at hx
+      exact hx
+    have hx0 : x = 0 := initial_injective k B l hnl (hx'.trans (map_zero _).symm)
+    exact ⟨0, by simp only [hx0,map_zero]⟩
+  | succ n =>
+    apply (HomologicalComplex.exactAt_iff' _ n (n+1) (n+2) (by simp) (by simp)).2
+    rw [ShortComplex.moduleCat_exact_iff]
+    intro x hx
+    have hx' : differential k B l (n+1) x = 0 := by
+      change (CochainComplex.of.d (termObject k B l) (fun n => ModuleCat.ofHom (differential k B l n)) (n+1) ((n+1)+1)).hom x = 0 at hx
+      rw [CochainComplex.of_d] at hx
+      exact hx
+    obtain ⟨y,hy⟩ := (differential_exact k B l n hnl x).mp hx'
+    refine ⟨y, ?_⟩
+    change (CochainComplex.of.d (termObject k B l)
+      (fun j => ModuleCat.ofHom (differential k B l j)) n (n+1)).hom y = x
+    rw [CochainComplex.of_d]
+    exact hy
+
+abbrev augmentationHom : termObject k B l l ⟶ ModuleCat.of (B ⊗[k] ChainAlgebra k l)ᵐᵒᵖ (TerminalTensor B) :=
+  ModuleCat.ofHom (augmentation k B l)
+
+instance augmentation_epi : Epi (augmentationHom k B l) :=
+  (ModuleCat.epi_iff_surjective _).mpr (augmentation_surjective k B l)
+
+/-- The actual B-extended resolution augmentation as a chain map. -/
+def augmentationMap : complex k B l ⟶
+    (HomologicalComplex.single _ (.up ℕ) l).obj (ModuleCat.of (B ⊗[k] ChainAlgebra k l)ᵐᵒᵖ (TerminalTensor B)) :=
+  HomologicalComplex.mkHomToSingle (augmentationHom k B l) (by
+    intro i hi
+    change i+1=l at hi
+    subst l
+    change CochainComplex.of.d _ _ i (i+1) ≫ augmentationHom k B (i+1) = 0
+    rw [CochainComplex.of_d]
+    ext x
+    exact congrArg (fun f => f x) (augmentation_comp k B i))
+
+theorem differential_last_zero : differential k B l l = 0 := by
+  ext x
+  change ((1:B) ⊗ₜ[k] ChainAlgebra.extendedArrow k l l) * x.val = 0
+  rw [ChainAlgebra.extendedArrow,dite_eq_right (lt_irrefl l),TensorProduct.tmul_zero,zero_mul]
+
+theorem augmentationMap_quasiIsoAt_last : QuasiIsoAt (augmentationMap k B l) l := by
+  rw [quasiIsoAt_iff]
+  refine (ShortComplex.quasiIso_iff_of_zeros' _ ?_ ?_ ?_).2 ?_
+  · change (complex k B l).d l ((ComplexShape.up ℕ).next l) = 0
+    rw [show (ComplexShape.up ℕ).next l = l+1 by simp]
+    change CochainComplex.of.d (termObject k B l) (fun n => ModuleCat.ofHom (differential k B l n)) l (l+1) = 0
+    rw [CochainComplex.of_d]
+    apply ModuleCat.hom_ext
+    exact differential_last_zero k B l
+  · exact HomologicalComplex.single_obj_d (.up ℕ) l (ModuleCat.of (B ⊗[k] ChainAlgebra k l)ᵐᵒᵖ (TerminalTensor B)) ((ComplexShape.up ℕ).prev l) l
+  · exact HomologicalComplex.single_obj_d (.up ℕ) l (ModuleCat.of (B ⊗[k] ChainAlgebra k l)ᵐᵒᵖ (TerminalTensor B)) l ((ComplexShape.up ℕ).next l)
+  · change (ShortComplex.mk ((complex k B l).d ((ComplexShape.up ℕ).prev l) l)
+      ((augmentationMap k B l).f l) _).Exact ∧ Epi ((augmentationMap k B l).f l)
+    have hf : (augmentationMap k B l).f l = augmentationHom k B l ≫
+        (HomologicalComplex.singleObjXSelf (.up ℕ) l
+          (ModuleCat.of (B ⊗[k] ChainAlgebra k l)ᵐᵒᵖ (TerminalTensor B))).inv := by
+      unfold augmentationMap
+      apply HomologicalComplex.mkHomToSingle_f
+    simp only [hf]
+    constructor
+    · refine ChainAlgebra.exact_post_iso _ _ ?_
+        (HomologicalComplex.singleObjXSelf (.up ℕ) l
+          (ModuleCat.of (B ⊗[k] ChainAlgebra k l)ᵐᵒᵖ (TerminalTensor B))).symm ?_
+      · cases l with
+        | zero =>
+          have hz := (complex k B 0).shape ((ComplexShape.up ℕ).prev 0) 0 (by simp)
+          erw [hz,zero_comp]
+        | succ n =>
+          rw [show (ComplexShape.up ℕ).prev (n+1) = n by simp]
+          change CochainComplex.of.d _ _ n (n+1) ≫ augmentationHom k B (n+1) = 0
+          rw [CochainComplex.of_d]
+          ext x
+          exact congrArg (fun f => f x) (augmentation_comp k B n)
+      cases l with
+      | zero =>
+        rw [ShortComplex.moduleCat_exact_iff]
+        intro x hx
+        have hx0 : x = 0 := augmentation_zero_injective k B (hx.trans (map_zero _).symm)
+        exact ⟨0, by simp only [hx0,map_zero]⟩
+      | succ n =>
+        rw [ShortComplex.moduleCat_exact_iff]
+        intro x hx
+        obtain ⟨y,hy⟩ := (augmentation_exact k B n x).mp hx
+        change ∃ z : termObject k B (n+1) ((ComplexShape.up ℕ).prev (n+1)),
+          (CochainComplex.of.d (termObject k B (n+1))
+            (fun j => ModuleCat.ofHom (differential k B (n+1) j))
+            ((ComplexShape.up ℕ).prev (n+1)) (n+1)).hom z = x
+        rw [show (ComplexShape.up ℕ).prev (n+1) = n by simp]
+        exact ⟨y, by rw [CochainComplex.of_d]; exact hy⟩
+    · erw [ModuleCat.epi_iff_surjective]
+      exact ((ModuleCat.epi_iff_surjective _).mp (inferInstance : Epi
+        (HomologicalComplex.singleObjXSelf (.up ℕ) l
+          (ModuleCat.of (B ⊗[k] ChainAlgebra k l)ᵐᵒᵖ (TerminalTensor B))).inv)).comp
+        (augmentation_surjective k B l)
+
+/-- Actual augmentation quasi-isomorphism for the finite right-BC-projective resolution. -/
+theorem augmentationMap_quasiIso : QuasiIso (augmentationMap k B l) := by
+  constructor
+  intro n
+  by_cases hn : n = l
+  · subst n; exact augmentationMap_quasiIsoAt_last k B l
+  · apply (quasiIsoAt_iff_exactAt' _ n ?_).2 (complex_exactAt k B l n hn)
+    exact HomologicalComplex.ExactAt.of_isZero (HomologicalComplex.isZero_single_obj_X _ _ _ _ hn)
+end LittleFinitistic.OrdinarySimulation.TensorResolution
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryTensorRightRestriction.lean b/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryTensorRightRestriction.lean
new file mode 100644
index 0000000000000000000000000000000000000000..7b9eaa541aa07f0805b15ba05bf9495d24f2ab18
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryTensorRightRestriction.lean
@@ -0,0 +1,48 @@
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryTwoSidedTensor
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryAssociativeTensorModules
+import Mathlib.Algebra.Category.ModuleCat.ChangeOfRings
+
+namespace OAI
+noncomputable section
+open CategoryTheory
+open scoped TensorProduct
+namespace LittleFinitistic.TwoSidedTensor
+universe u
+variable (k A B S M N : Type u) [Field k] [Ring A] [Ring B] [Ring S]
+  [Algebra k A] [Algebra k B] [Algebra k S]
+variable [AddCommGroup M] [Module k M] [Module Aᵐᵒᵖ M] [IsScalarTower k Aᵐᵒᵖ M]
+  [Module S M] [IsScalarTower k S M] [SMulCommClass S Aᵐᵒᵖ M]
+variable [AddCommGroup N] [Module k N] [Module A N] [Module Bᵐᵒᵖ N]
+  [IsScalarTower k A N] [IsScalarTower k Bᵐᵒᵖ N] [SMulCommClass A Bᵐᵒᵖ N]
+
+local instance : SMulCommClass Bᵐᵒᵖ A N := ⟨fun b a n => (smul_comm a b n).symm⟩
+
+/-- The actual outside right action obtained by restricting the enveloping action. -/
+abbrev rightRestriction : ModuleCat.{u} Bᵐᵒᵖ :=
+  (ModuleCat.restrictScalars (Algebra.TensorProduct.includeRight (R := k) (A := S) (B := Bᵐᵒᵖ)).toRingHom).obj
+    (ModuleCat.of (S ⊗[k] Bᵐᵒᵖ) (TwoSidedTensor k A S Bᵐᵒᵖ M N))
+
+/-- The one-sided right tensor action equals the restriction of the genuine two-sided action. -/
+def rightActionEquiv : RightTensor k A B M N ≃ₗ[Bᵐᵒᵖ] rightRestriction k A B S M N where
+  toFun x := x
+  invFun x := x
+  left_inv x := rfl
+  right_inv x := rfl
+  map_add' x y := rfl
+  map_smul' r x := by
+    let F : BalancedTensor.Tensor k A M N →ₗ[k] BalancedTensor.Tensor k A M N :=
+      RightTensor.action k A B M N r
+    let G : BalancedTensor.Tensor k A M N →ₗ[k] BalancedTensor.Tensor k A M N :=
+      TwoSidedTensor.action k A S Bᵐᵒᵖ M N ((1:S) ⊗ₜ[k] r)
+    have h : F = G := by
+      apply BalancedTensor.ext
+      intro m n
+      change BalancedTensor.mk k A M N m (r • n) = BalancedTensor.mk k A M N ((1:S) • m) (r • n)
+      rw [one_smul]
+    exact congrArg (fun f => f x) h
+
+end LittleFinitistic.TwoSidedTensor
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryTensorTotalAcyclic.lean b/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryTensorTotalAcyclic.lean
new file mode 100644
index 0000000000000000000000000000000000000000..93c5e827c38f9b115cf9bbd5c441733b9cac2d10
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryTensorTotalAcyclic.lean
@@ -0,0 +1,60 @@
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryTensorFiniteMatrix
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryTensorColumnAcyclic
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryIntegerResolution
+
+namespace OAI
+noncomputable section
+open CategoryTheory
+open scoped TensorProduct
+namespace LittleFinitistic
+namespace ComplexTensor
+universe u
+variable (k A : Type u) [Field k] [Ring A] [Algebra k A]
+variable (Q : CochainComplex (ModuleCat.{u} Aᵐᵒᵖ) ℤ)
+variable (Z : CochainComplex (ModuleCat.{u} A) ℤ)
+variable {l : ℕ} (p : Fin l → ℤ) (hp : StrictMono p)
+
+/-- The actual signed finite tensor total of projective right terms preserves acyclicity.
+No bound, finiteness, dimension or projectivity condition is imposed on Z. -/
+theorem finiteTotal_acyclic [∀ i, Module.Projective Aᵐᵒᵖ (rightTerm k A Q (p i))]
+    (hZ : Z.Acyclic) : (finiteTotal k A Q Z p hp).Acyclic :=
+  FiniteColumnComplex.total_acyclic (columns k A Q Z p) (tensorHorizontal k A Q Z p hp)
+    (fun i => column_acyclic k A Q Z (p i) hZ)
+
+end ComplexTensor
+namespace OrdinarySimulation.TensorResolution
+universe u
+variable (k B : Type u) [Field k] [Ring B] [Algebra k B] (l : ℕ)
+
+/-- Exactly the manuscript's finite interval [-l,0] of Q_T. -/
+def finiteDegrees (i : Fin (l+1)) : ℤ := -(l:ℤ) + i.val
+
+theorem finiteDegrees_strictMono : StrictMono (finiteDegrees l) := by
+  intro i j hij
+  change -(l:ℤ) + (i.val:ℤ) < -(l:ℤ) + (j.val:ℤ)
+  change i.val < j.val at hij
+  omega
+
+instance integerTerm_moduleProjective (n : ℤ) :
+    Module.Projective (B ⊗[k] ChainAlgebra k l)ᵐᵒᵖ
+      (ComplexTensor.rightTerm k (B ⊗[k] ChainAlgebra k l) (integerComplex k B l) n) := by
+  let := integerTerm_projective k B l n
+  exact (inferInstance : Module.Projective (B ⊗[k] ChainAlgebra k l)ᵐᵒᵖ ((integerComplex k B l).X n))
+
+/-- Actual signed tensor with the manuscript's Q_T on an arbitrary complex of BC-modules. -/
+def tensorTotal (Z : CochainComplex (ModuleCat.{u} (B ⊗[k] ChainAlgebra k l)) ℤ) :
+    CochainComplex (ModuleCat.{u} k) ℤ :=
+  ComplexTensor.finiteTotal k (B ⊗[k] ChainAlgebra k l) (integerComplex k B l) Z
+    (finiteDegrees l) (finiteDegrees_strictMono l)
+
+/-- Q_T is K-flat in the acyclic-input characterization, for its actual signed tensor total. -/
+theorem tensorTotal_acyclic (Z : CochainComplex (ModuleCat.{u} (B ⊗[k] ChainAlgebra k l)) ℤ)
+    (hZ : Z.Acyclic) : (tensorTotal k B l Z).Acyclic :=
+  ComplexTensor.finiteTotal_acyclic k (B ⊗[k] ChainAlgebra k l) (integerComplex k B l) Z
+    (finiteDegrees l) (finiteDegrees_strictMono l) hZ
+end OrdinarySimulation.TensorResolution
+end LittleFinitistic
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryTensorTotalFunctor.lean b/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryTensorTotalFunctor.lean
new file mode 100644
index 0000000000000000000000000000000000000000..75aa776839e9dc69116ca475c9ed526200372ffd
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryTensorTotalFunctor.lean
@@ -0,0 +1,88 @@
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryTensorInputMaps
+
+namespace OAI
+noncomputable section
+open CategoryTheory
+namespace LittleFinitistic
+namespace FiniteColumnComplex
+universe u
+variable {R : Type u} [Ring R] {l : ℕ}
+variable (K L : Fin l → CochainComplex (ModuleCat.{u} R) ℤ) (f : ∀ i, K i ⟶ L i)
+
+theorem diagonal_componentMap (n : ℤ) :
+    (diagonal L n).comp (componentMap K L f n) = (componentMap K L f (n+1)).comp (diagonal K n) := by
+  apply LinearMap.ext
+  intro z
+  funext i
+  exact congrArg (fun g => g.hom (z i)) ((f i).comm n (n+1))
+
+end FiniteColumnComplex
+namespace ComplexTensor
+open BalancedTensor
+universe u
+variable (k A : Type u) [Field k] [Ring A] [Algebra k A]
+variable (Q : CochainComplex (ModuleCat.{u} Aᵐᵒᵖ) ℤ)
+variable {Z Z' Z'' : CochainComplex (ModuleCat.{u} A) ℤ}
+variable {l : ℕ} (p : Fin l → ℤ) (hp : StrictMono p)
+
+/-- Actual tensor total applied to an arbitrary chain map of input complexes. -/
+def finiteTotalMap (f : Z ⟶ Z') : finiteTotal k A Q Z p hp ⟶ finiteTotal k A Q Z' p hp :=
+  FiniteColumnComplex.complexMap (columns k A Q Z p) (columns k A Q Z' p)
+    (FiniteColumnComplex.totalDifferential _ (tensorHorizontal k A Q Z p hp))
+    (FiniteColumnComplex.totalDifferential _ (tensorHorizontal k A Q Z' p hp))
+    (fun i => columnMap k A Q f (p i)) (by
+      intro n
+      change (FiniteColumnComplex.diagonal (columns k A Q Z' p) n + matrix k A Q Z' p n).comp _ =
+        (FiniteColumnComplex.componentMap _ _ (fun i => columnMap k A Q f (p i)) (n+1)).comp
+          (FiniteColumnComplex.diagonal (columns k A Q Z p) n + matrix k A Q Z p n)
+      rw [LinearMap.add_comp,LinearMap.comp_add,
+        FiniteColumnComplex.diagonal_componentMap,matrix_inputMap])
+
+@[simp] theorem finiteTotalMap_apply (f : Z ⟶ Z') (n : ℤ)
+    (z : FiniteColumnComplex.term (columns k A Q Z p) n) (i : Fin l) :
+    ((finiteTotalMap k A Q p hp f).f n).hom z i = inputMap k A Q f (p i) (n + -(p i)) (z i) := by
+  change ((columnMap k A Q f (p i)).f n).hom (z i) = _
+  rw [columnMap_f]
+  rfl
+
+@[simp] theorem inputMap_id (p q : ℤ) : inputMap k A Q (𝟙 Z) p q = LinearMap.id := by
+  apply BalancedTensor.ext
+  intro x y
+  rfl
+
+@[simp] theorem inputMap_comp (f : Z ⟶ Z') (g : Z' ⟶ Z'') (p q : ℤ) :
+    (inputMap k A Q g p q).comp (inputMap k A Q f p q) = inputMap k A Q (f ≫ g) p q := by
+  apply BalancedTensor.ext
+  intro x y
+  rfl
+
+/-- The actual signed finite tensor total is a functor on all input complexes. -/
+def finiteTotalFunctor : CochainComplex (ModuleCat.{u} A) ℤ ⥤ CochainComplex (ModuleCat.{u} k) ℤ where
+  obj Z := finiteTotal k A Q Z p hp
+  map f := finiteTotalMap k A Q p hp f
+  map_id Z := by
+    apply HomologicalComplex.Hom.ext
+    funext n
+    apply ModuleCat.hom_ext
+    apply LinearMap.ext
+    intro z
+    funext i
+    change ((finiteTotalMap k A Q p hp (𝟙 Z)).f n).hom z i = z i
+    erw [finiteTotalMap_apply,inputMap_id,LinearMap.id_apply]
+  map_comp f g := by
+    apply HomologicalComplex.Hom.ext
+    funext n
+    apply ModuleCat.hom_ext
+    apply LinearMap.ext
+    intro z
+    funext i
+    change ((finiteTotalMap k A Q p hp (f ≫ g)).f n).hom z i =
+      ((finiteTotalMap k A Q p hp g).f n).hom (((finiteTotalMap k A Q p hp f).f n).hom z) i
+    erw [finiteTotalMap_apply,finiteTotalMap_apply,finiteTotalMap_apply]
+    exact (congrArg (fun h => h (z i)) (inputMap_comp k A Q f g (p i) (n + -(p i)))).symm
+end ComplexTensor
+end LittleFinitistic
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryTensorTotalQuasiIso.lean b/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryTensorTotalQuasiIso.lean
new file mode 100644
index 0000000000000000000000000000000000000000..d5cc64f17b6d4d3ef67db9f81bb97512de3d92f3
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryTensorTotalQuasiIso.lean
@@ -0,0 +1,56 @@
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryTensorTotalFunctor
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryFiniteConeTriangular
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryTensorTotalAcyclic
+import Mathlib.Algebra.Homology.HomotopyCategory.ShiftSequence
+
+namespace OAI
+noncomputable section
+open CategoryTheory
+namespace LittleFinitistic
+namespace ComplexTensor
+universe u
+variable (k A : Type u) [Field k] [Ring A] [Algebra k A]
+variable (Q : CochainComplex (ModuleCat.{u} Aᵐᵒᵖ) ℤ)
+variable {Z Z' : CochainComplex (ModuleCat.{u} A) ℤ} (f : Z ⟶ Z')
+
+/-- Every shifted projective tensor column preserves arbitrary quasi-isomorphisms. -/
+theorem columnMap_quasiIso (p : ℤ) [Module.Projective Aᵐᵒᵖ (rightTerm k A Q p)] [QuasiIso f] :
+    QuasiIso (columnMap k A Q f p) := by
+  have ht := BalancedTensor.projectiveTensor_quasiIso k A (rightTerm k A Q p) f
+  let := ht
+  exact inferInstanceAs (QuasiIso ((shiftFunctor _ (-p)).map
+    (((BalancedTensor.fixedTensorFunctor k A (rightTerm k A Q p)).mapHomologicalComplex
+      (.up ℤ)).map f)))
+
+variable {l : ℕ} (p : Fin l → ℤ) (hp : StrictMono p)
+
+/-- The actual signed finite tensor functor preserves quasi-isomorphisms of arbitrary complexes. -/
+theorem finiteTotalMap_quasiIso [∀ i, Module.Projective Aᵐᵒᵖ (rightTerm k A Q (p i))] [QuasiIso f] :
+    QuasiIso (finiteTotalMap k A Q p hp f) := by
+  let (i : Fin l) := columnMap_quasiIso k A Q f (p i)
+  unfold finiteTotalMap
+  exact FiniteColumnComplex.complexMap_quasiIso _ _ _ _ _ _
+
+end ComplexTensor
+namespace OrdinarySimulation.TensorResolution
+open scoped TensorProduct
+universe u
+variable (k B : Type u) [Field k] [Ring B] [Algebra k B] (l : ℕ)
+
+def tensorTotalFunctor : CochainComplex (ModuleCat.{u} (B ⊗[k] ChainAlgebra k l)) ℤ ⥤
+    CochainComplex (ModuleCat.{u} k) ℤ :=
+  ComplexTensor.finiteTotalFunctor k (B ⊗[k] ChainAlgebra k l) (integerComplex k B l)
+    (finiteDegrees l) (finiteDegrees_strictMono l)
+
+/-- The actual bounded projective Q_T computes a homotopy-invariant tensor on every input complex. -/
+theorem tensorTotalFunctor_quasiIso
+    {Z Z' : CochainComplex (ModuleCat.{u} (B ⊗[k] ChainAlgebra k l)) ℤ} (f : Z ⟶ Z') [QuasiIso f] :
+    QuasiIso ((tensorTotalFunctor k B l).map f) :=
+  ComplexTensor.finiteTotalMap_quasiIso k (B ⊗[k] ChainAlgebra k l) (integerComplex k B l) f
+    (finiteDegrees l) (finiteDegrees_strictMono l)
+end OrdinarySimulation.TensorResolution
+end LittleFinitistic
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryTensorVertex.lean b/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryTensorVertex.lean
new file mode 100644
index 0000000000000000000000000000000000000000..067e66cdacf9e6727f676a1759501106e7eea0d8
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryTensorVertex.lean
@@ -0,0 +1,55 @@
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryBimodule
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryVertexCompression
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryTensorIdealActions
+
+namespace OAI
+noncomputable section
+open CategoryTheory
+open scoped TensorProduct
+namespace LittleFinitistic.OrdinarySimulation.BimoduleO
+universe u
+variable {k B : Type u} [Field k] [Ring B] [Algebra k B]
+variable (P : CochainComplex (ModuleCat.{u} (Enveloping k B)) ℤ) (a : ℤ) (l : ℕ)
+
+@[simp] theorem tensor_smul (b : B) (c : ChainAlgebra k l) (v : BimoduleO P a l) :
+    (b ⊗ₜ[k] c) • v = b • (c • v) := rfl
+
+@[simp] theorem tensor_vertex_smul (i : Fin (l+1)) (v : BimoduleO P a l) :
+    TensorIdeal.vertex (k := k) (B := B) (ChainAlgebra.vertex k l i) • v =
+      ChainAlgebra.vertex k l i • v := by
+  change (1:B) • (ChainAlgebra.vertex k l i • v) = _
+  exact one_smul _ _
+
+/-- The BC vertex space is the same actual subspace of O as the C vertex space. -/
+def tensorVertexSpaceEquiv (i : Fin (l+1)) :
+    IdempotentTensor.leftSpace (k := k) (TensorIdeal.vertex (k := k) (B := B) (ChainAlgebra.vertex k l i))
+      (BimoduleO P a l) ≃ₗ[k] Compression.vertexSpace (k := k) P a l i where
+  toFun x := ⟨x.val, by
+    have h := x.property
+    change TensorIdeal.vertex (k := k) (B := B) (ChainAlgebra.vertex k l i) • x.val = x.val at h
+    rw [tensor_vertex_smul] at h
+    exact h⟩
+  invFun x := ⟨x.val, by
+    exact (tensor_vertex_smul P a l i (show BimoduleO P a l from x.val)).trans x.property⟩
+  left_inv _ := rfl
+  right_inv _ := rfl
+  map_add' _ _ := rfl
+  map_smul' _ _ := rfl
+
+/-- Evaluation uses the actual balanced tensor over BC, not only over C. -/
+def tensorVertexEquiv (i : Fin (l+1)) :
+    BalancedTensor.Tensor k (B ⊗[k] ChainAlgebra k l)
+      (IdempotentTensor.rightIdeal (TensorIdeal.vertex (k := k) (B := B) (ChainAlgebra.vertex k l i)))
+      (BimoduleO P a l) ≃ₗ[k] (underlyingComplex (k := k) P).X (a+(i.val:ℤ)) := by
+  letI (n : ℤ) : Module k (P.X n) := Module.compHom _ (algebraMap k (Enveloping k B))
+  have (n : ℤ) : IsScalarTower k (Enveloping k B) (P.X n) := IsScalarTower.of_compHom k (Enveloping k B) (P.X n)
+  exact (IdempotentTensor.tensorEquiv (k := k)
+    (TensorIdeal.vertex (k := k) (B := B) (ChainAlgebra.vertex k l i)) (BimoduleO P a l)
+    (TensorIdeal.vertex_idempotent _ (ChainAlgebra.vertex_idempotent k l i))).trans
+      ((tensorVertexSpaceEquiv P a l i).trans
+        ((Compression.vertexEquiv (k := k) P a l i).restrictScalars k))
+end LittleFinitistic.OrdinarySimulation.BimoduleO
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryTerminal.lean b/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryTerminal.lean
new file mode 100644
index 0000000000000000000000000000000000000000..7f29e3b0e451633c9e8911c9c910000cd51f0846
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryTerminal.lean
@@ -0,0 +1,72 @@
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryBimodule
+
+namespace OAI
+noncomputable section
+open CategoryTheory
+open scoped TensorProduct
+namespace LittleFinitistic.OrdinarySimulation
+universe u
+variable (k B : Type u) [Field k] [Ring B] [Algebra k B] (l : ℕ)
+
+/-- The terminal character extended along the B-factor. -/
+def terminalAugmentation : (B ⊗[k] ChainAlgebra k l) →ₐ[k] B :=
+  Algebra.TensorProduct.lift (AlgHom.id k B)
+    ((Algebra.ofId k B).comp (ChainAlgebra.terminalCharacter k l)) (by
+      intro b c
+      change b * algebraMap k B (ChainAlgebra.terminalCharacter k l c) =
+        algebraMap k B (ChainAlgebra.terminalCharacter k l c) * b
+      exact (Algebra.commutes _ _).symm)
+
+/-- Coordinate model for B tensor_k W, with its specified terminal right action. -/
+def TerminalTensor := B
+namespace TerminalTensor
+instance : AddCommGroup (TerminalTensor B) := inferInstanceAs (AddCommGroup B)
+instance : Module k (TerminalTensor B) := inferInstanceAs (Module k B)
+instance : Module B (TerminalTensor B) := inferInstanceAs (Module B B)
+instance : Module (B ⊗[k] ChainAlgebra k l)ᵐᵒᵖ (TerminalTensor B) :=
+  Module.compHom B (terminalAugmentation k B l).toRingHom.op
+
+def value (t : TerminalTensor B) : B := t
+
+@[simp] theorem right_action (x : (B ⊗[k] ChainAlgebra k l)ᵐᵒᵖ) (t : TerminalTensor B) :
+    value B (x • t) = value B t * terminalAugmentation k B l x.unop := rfl
+
+instance towerLeft : IsScalarTower k B (TerminalTensor B) := inferInstanceAs (IsScalarTower k B B)
+
+instance towerRight : IsScalarTower k (B ⊗[k] ChainAlgebra k l)ᵐᵒᵖ (TerminalTensor B) where
+  smul_assoc c x v := by
+    change value B v * terminalAugmentation k B l (c • x.unop) = c • (value B v * terminalAugmentation k B l x.unop)
+    rw [map_smul, mul_smul_comm]
+
+instance commuteActions : SMulCommClass B (B ⊗[k] ChainAlgebra k l)ᵐᵒᵖ (TerminalTensor B) where
+  smul_comm b x t := by
+    change b * (value B t * terminalAugmentation k B l x.unop) =
+      (b*value B t) * terminalAugmentation k B l x.unop
+    exact (mul_assoc _ _ _).symm
+
+/-- Explicit identification of this coordinate model with the source tensor product. -/
+def tensorModel : (B ⊗[k] k) ≃ₗ[k] TerminalTensor B := TensorProduct.rid k B
+
+@[simp] theorem tensorModel_tmul (b : B) (c : k) :
+    tensorModel k B (b ⊗ₜ[k] c) = c • b := rfl
+
+/-- The coordinate right action has exactly the regular-B/terminal-W tensor formula. -/
+theorem tensor_right_formula (b b' : B) (w : k) (c : ChainAlgebra k l) :
+    MulOpposite.op (b' ⊗ₜ[k] c) • tensorModel k B (b ⊗ₜ[k] w) =
+      tensorModel k B ((b*b') ⊗ₜ[k] (w * ChainAlgebra.terminalCharacter k l c)) := by
+  change (w • b) * (b' * algebraMap k B (ChainAlgebra.terminalCharacter k l c)) =
+    (w * ChainAlgebra.terminalCharacter k l c) • (b*b')
+  rw [Algebra.smul_def, Algebra.smul_def, map_mul]
+  have hc := Algebra.commutes (R := k) (A := B) (ChainAlgebra.terminalCharacter k l c) (b*b')
+  calc
+    _ = algebraMap k B w * ((b*b') * algebraMap k B (ChainAlgebra.terminalCharacter k l c)) := by simp only [mul_assoc]
+    _ = _ := by rw [← hc]; simp only [mul_assoc]
+
+instance finiteDimensional [FiniteDimensional k B] : FiniteDimensional k (TerminalTensor B) :=
+  inferInstanceAs (FiniteDimensional k B)
+end TerminalTensor
+end LittleFinitistic.OrdinarySimulation
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryTerminalResolution.lean b/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryTerminalResolution.lean
new file mode 100644
index 0000000000000000000000000000000000000000..ced43cc70913fd03911e47ba5c34cdadc4c0819b
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryTerminalResolution.lean
@@ -0,0 +1,65 @@
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryChainResolution
+
+namespace OAI
+noncomputable section
+namespace LittleFinitistic.OrdinarySimulation
+universe u
+variable (k : Type u) [Field k] (l : ℕ)
+
+/-- W is the genuine terminal right simple, via the terminal character. -/
+def TerminalSimple := k
+namespace TerminalSimple
+instance : AddCommGroup (TerminalSimple k) := inferInstanceAs (AddCommGroup k)
+instance : Module k (TerminalSimple k) := inferInstanceAs (Module k k)
+instance : Module (ChainAlgebra k l)ᵐᵒᵖ (TerminalSimple k) :=
+  Module.compHom k (ChainAlgebra.terminalCharacter k l).toRingHom.op
+end TerminalSimple
+
+namespace ChainAlgebra
+/-- The augmentation of the terminal right projective. -/
+def augmentation : rightTerm (k := k) (Fin.last l) →ₗ[(ChainAlgebra k l)ᵐᵒᵖ] TerminalSimple k where
+  toFun x := x.val.1 (Fin.last l)
+  map_add' _ _ := rfl
+  map_smul' _ _ := rfl
+
+@[simp] theorem augmentation_zero_iff (x : rightTerm (k := k) (Fin.last l)) :
+    augmentation k l x = 0 ↔ x.val.1 (Fin.last l) = 0 := Iff.rfl
+
+theorem augmentation_surjective : Function.Surjective (augmentation k l) := by
+  intro w
+  let x : rightTerm (k := k) (Fin.last l) := ⟨(show k from w) • vertex k l (Fin.last l), by
+    change vertex k l (Fin.last l) * ((show k from w) • vertex k l (Fin.last l)) =
+      (show k from w) • vertex k l (Fin.last l)
+    rw [mul_smul_comm, vertex_idempotent]⟩
+  refine ⟨x, ?_⟩
+  change ((show k from w) • vertex k l (Fin.last l)).1 (Fin.last l) = (show k from w)
+  rw [smul_diagonal, vertex_diagonal]
+  simp only [Pi.single_eq_same]
+  exact @mul_one k _ w
+
+/-- Exactness at the augmentation for every positive chain length. -/
+theorem augmentation_exact (x : rightTerm (k := k) (Fin.last (l+1))) :
+    augmentation k (l+1) x = 0 ↔
+      ∃ y, resolutionMap (k := k) (Fin.last l) y = x := by
+  rw [augmentation_zero_iff, resolutionMap_range]
+  rfl
+
+theorem augmentation_zero_injective : Function.Injective (augmentation k 0) := by
+  intro x y hxy
+  have hz : (x-y).val.1 0 = 0 := by
+    have hz : augmentation k 0 (x-y) = 0 := by rw [map_sub, hxy, sub_self]
+    exact (augmentation_zero_iff k 0 _).mp hz
+  have he := vertex_zero_mul (x-y).val
+  have hp : vertex k 0 0 * (x-y).val = (x-y).val := (x-y).property
+  rw [hp, hz, zero_smul] at he
+  exact sub_eq_zero.mp (show x-y = 0 from Subtype.ext he)
+
+/-- For l=0, the source resolution is the actual isomorphism e₀C ≅ W. -/
+def zeroLengthResolution : rightTerm (k := k) (Fin.last 0) ≃ₗ[(ChainAlgebra k 0)ᵐᵒᵖ] TerminalSimple k :=
+  LinearEquiv.ofBijective (augmentation k 0) ⟨augmentation_zero_injective k, augmentation_surjective k 0⟩
+end ChainAlgebra
+end LittleFinitistic.OrdinarySimulation
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryTriangularExactness.lean b/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryTriangularExactness.lean
new file mode 100644
index 0000000000000000000000000000000000000000..58a7103264d291c1784da5ddbd087908de9f9c34
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryTriangularExactness.lean
@@ -0,0 +1,68 @@
+import Mathlib.Algebra.Exact.Basic
+import Mathlib.LinearAlgebra.Pi
+import Mathlib.Tactic.Abel
+
+namespace OAI
+noncomputable section
+namespace LittleFinitistic.TriangularExactness
+universe u v
+variable {R : Type u} [Ring R] {l : ℕ}
+variable (E F G : Fin l → Type v)
+variable [∀ i, AddCommGroup (E i)] [∀ i, Module R (E i)]
+variable [∀ i, AddCommGroup (F i)] [∀ i, Module R (F i)]
+variable [∀ i, AddCommGroup (G i)] [∀ i, Module R (G i)]
+
+/-- A finite upper triangular differential with exact diagonal complexes is exact.
+The argument eliminates one coordinate at a time; the modules may be arbitrary. -/
+theorem exact_of_diagonal
+    (d : (∀ i, E i) →ₗ[R] (∀ i, F i)) (e : (∀ i, F i) →ₗ[R] (∀ i, G i))
+    (d₀ : ∀ i, E i →ₗ[R] F i) (e₀ : ∀ i, F i →ₗ[R] G i)
+    (hzero : e.comp d = 0)
+    (hd : ∀ (i : Fin l) (x : E i) (j : Fin l), j.val < i.val → d (Pi.single i x) j = 0)
+    (hdi : ∀ (i : Fin l) (x : E i), d (Pi.single i x) i = d₀ i x)
+    (he : ∀ (i : Fin l) (z : ∀ j, F j), (∀ j : Fin l, j.val < i.val → z j = 0) →
+      e z i = e₀ i (z i))
+    (hex : ∀ i, Function.Exact (d₀ i) (e₀ i)) : Function.Exact d e := by
+  classical
+  intro z
+  constructor
+  · intro hz
+    have step (n : ℕ) (hn : n ≤ l) :
+        ∃ w : ∀ i, E i, ∀ j : Fin l, j.val < n → (z-d w) j = 0 := by
+      induction n with
+      | zero => exact ⟨0,fun j hj => by omega⟩
+      | succ n ih =>
+        obtain ⟨w,hw⟩ := ih (by omega)
+        let i : Fin l := ⟨n,by omega⟩
+        have hclosed : e (z-d w) = 0 := by
+          rw [map_sub,hz]
+          have hed : e (d w) = 0 := congrArg (fun f : (∀ i, E i) →ₗ[R] (∀ i, G i) => f w) hzero
+          rw [hed,sub_self]
+        have hei : e₀ i ((z-d w) i) = 0 := by
+          rw [← he i (z-d w) (fun j hj => hw j hj)]
+          exact congrArg (fun x => x i) hclosed
+        obtain ⟨y,hy⟩ := (hex i _).mp hei
+        refine ⟨w + Pi.single i y, ?_⟩
+        intro j hj
+        by_cases hji : j.val < n
+        · have hj0 := hd i y j hji
+          change z j - d (w + Pi.single i y) j = 0
+          rw [map_add,Pi.add_apply,hj0,add_zero]
+          exact hw j hji
+        · have hij : j = i := Fin.ext (by dsimp [i]; omega)
+          subst j
+          change z i - d (w + Pi.single i y) i = 0
+          rw [map_add,Pi.add_apply,hdi,hy]
+          change z i - (d w i + (z i - d w i)) = 0
+          abel
+    obtain ⟨w,hw⟩ := step l (by rfl)
+    refine ⟨w, ?_⟩
+    ext i
+    exact (sub_eq_zero.mp (hw i i.isLt)).symm
+  · rintro ⟨w,rfl⟩
+    exact congrArg (fun f : (∀ i, E i) →ₗ[R] (∀ i, G i) => f w) hzero
+end LittleFinitistic.TriangularExactness
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryTwoSidedTensor.lean b/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryTwoSidedTensor.lean
new file mode 100644
index 0000000000000000000000000000000000000000..25beda4245d88ef4b92e4c7e1729551acada5510
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryTwoSidedTensor.lean
@@ -0,0 +1,95 @@
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryBalancedActions
+
+namespace OAI
+noncomputable section
+open scoped TensorProduct
+namespace LittleFinitistic
+universe u
+/-- Balanced tensor with its two outside coefficient algebras recorded in the type. -/
+def TwoSidedTensor (k A _S _T M N : Type u) [Field k] [Ring A] [Algebra k A]
+    [AddCommGroup M] [Module k M] [Module Aᵐᵒᵖ M]
+    [AddCommGroup N] [Module k N] [Module A N] := BalancedTensor.Tensor k A M N
+
+variable (k A S T M N : Type u) [Field k] [Ring A] [Algebra k A] [Ring S] [Algebra k S]
+  [Ring T] [Algebra k T]
+  [AddCommGroup M] [Module k M] [Module Aᵐᵒᵖ M] [IsScalarTower k Aᵐᵒᵖ M]
+  [Module S M] [IsScalarTower k S M] [SMulCommClass S Aᵐᵒᵖ M]
+  [AddCommGroup N] [Module k N] [Module A N] [IsScalarTower k A N]
+  [Module T N] [IsScalarTower k T N] [SMulCommClass T A N]
+
+namespace TwoSidedTensor
+instance : AddCommGroup (TwoSidedTensor k A S T M N) := inferInstanceAs (AddCommGroup (BalancedTensor.Tensor k A M N))
+instance : Module k (TwoSidedTensor k A S T M N) := inferInstanceAs (Module k (BalancedTensor.Tensor k A M N))
+
+def action : (S ⊗[k] T) →ₐ[k] Module.End k (TwoSidedTensor k A S T M N) :=
+  BalancedTensor.bimoduleAction
+instance : Module (S ⊗[k] T) (TwoSidedTensor k A S T M N) := Module.compHom _ (action k A S T M N).toRingHom
+instance : IsScalarTower k (S ⊗[k] T) (TwoSidedTensor k A S T M N) where
+  smul_assoc r x z := by
+    change action k A S T M N (r • x) z = r • action k A S T M N x z
+    rw [map_smul]
+    rfl
+
+def mk : M →ₗ[k] N →ₗ[k] TwoSidedTensor k A S T M N := BalancedTensor.mk k A M N
+
+@[simp] theorem tmul_smul_mk (s : S) (t : T) (m : M) (n : N) :
+    (s ⊗ₜ[k] t) • mk k A S T M N m n = mk k A S T M N (s • m) (t • n) := rfl
+
+variable {k A S T M N}
+variable {M' : Type u} [AddCommGroup M'] [Module k M'] [Module Aᵐᵒᵖ M'] [IsScalarTower k Aᵐᵒᵖ M']
+  [Module S M'] [IsScalarTower k S M'] [SMulCommClass S Aᵐᵒᵖ M']
+
+/-- Functoriality of the actual tensor with both outside actions retained. -/
+def map (f : M →ₗ[Aᵐᵒᵖ] M') (hf : ∀ (s : S) m, f (s • m) = s • f m) :
+    TwoSidedTensor k A S T M N →ₗ[S ⊗[k] T] TwoSidedTensor k A S T M' N where
+  __ := (BalancedTensor.mapLeft (k := k) N f).toAddHom
+  map_smul' x z := by
+    let F : TwoSidedTensor k A S T M N →ₗ[k] TwoSidedTensor k A S T M' N :=
+      BalancedTensor.mapLeft (k := k) N f
+    have h : F.comp (action k A S T M N x) = (action k A S T M' N x).comp F := by
+      induction x using TensorProduct.inductionOn with
+      | tmul s t =>
+        apply BalancedTensor.ext
+        intro m n
+        change BalancedTensor.mk k A M' N (f (s • m)) (t • n) =
+          BalancedTensor.mk k A M' N (s • f m) (t • n)
+        rw [hf]
+      | add x y hx hy =>
+        simp only [map_add, LinearMap.comp_add, LinearMap.add_comp, hx, hy]
+    exact congrArg (fun g => g z) h
+
+@[simp] theorem map_mk (f : M →ₗ[Aᵐᵒᵖ] M') (hf : ∀ (s : S) m, f (s • m) = s • f m) (m : M) (n : N) :
+    map (T := T) (N := N) f hf (mk k A S T M N m n) = mk k A S T M' N (f m) n := rfl
+
+/-- Actual equivalences of the right factor on the left preserve the outside bimodule. -/
+def congrLeft (e : M ≃ₗ[Aᵐᵒᵖ] M') (he : ∀ (s : S) m, e (s • m) = s • e m) :
+    TwoSidedTensor k A S T M N ≃ₗ[S ⊗[k] T] TwoSidedTensor k A S T M' N where
+  __ := map (T := T) (N := N) e.toLinearMap he
+  invFun := map (T := T) (N := N) e.symm.toLinearMap (fun s m => by
+    apply e.injective
+    change e (e.symm (s • m)) = e (s • e.symm m)
+    rw [LinearEquiv.apply_symm_apply,he,LinearEquiv.apply_symm_apply])
+  left_inv z := by
+    change BalancedTensor.mapLeft (k := k) N e.symm.toLinearMap
+      (BalancedTensor.mapLeft (k := k) N e.toLinearMap z) = z
+    induction z using BalancedTensor.induction_on with
+    | hz => simp only [map_zero]
+    | ht m n =>
+      change mk k A S T M N (e.symm (e m)) n = mk k A S T M N m n
+      rw [LinearEquiv.symm_apply_apply]
+    | ha x y hx hy => simp only [map_add,hx,hy]
+  right_inv z := by
+    change BalancedTensor.mapLeft (k := k) N e.toLinearMap
+      (BalancedTensor.mapLeft (k := k) N e.symm.toLinearMap z) = z
+    induction z using BalancedTensor.induction_on with
+    | hz => simp only [map_zero]
+    | ht m n =>
+      change mk k A S T M' N (e (e.symm m)) n = mk k A S T M' N m n
+      rw [LinearEquiv.apply_symm_apply]
+    | ha x y hx hy => simp only [map_add,hx,hy]
+end TwoSidedTensor
+end LittleFinitistic
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryVertexCompression.lean b/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryVertexCompression.lean
new file mode 100644
index 0000000000000000000000000000000000000000..1abdb213c0ac914b24f0c1ca17ad52c068d5e5da
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryVertexCompression.lean
@@ -0,0 +1,80 @@
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryCompression
+import OAI.Algebra.Finitistic.Tensor.IdempotentTensor
+
+namespace OAI
+noncomputable section
+open CategoryTheory
+namespace LittleFinitistic.OrdinarySimulation.Compression
+universe u
+variable {k A : Type u} [Field k] [Ring A] [Algebra k A]
+variable (P : CochainComplex (ModuleCat.{u} A) ℤ) (a : ℤ) (l : ℕ)
+
+/-- Coordinate insertion is linear over the full coefficient algebra A. -/
+def insert (i : Fin (l+1)) : P.X (a+(i.val:ℤ)) →ₗ[A] Compression P a l :=
+  LinearMap.single A (fun i : Fin (l+1) => P.X (a+(i.val:ℤ))) i
+
+def project (i : Fin (l+1)) : Compression P a l →ₗ[A] P.X (a+(i.val:ℤ)) := LinearMap.proj i
+
+theorem vertex_action (i : Fin (l+1)) (v : Compression P a l) :
+    ChainAlgebra.vertex k l i • v = insert P a l i (project P a l i v) := by
+  exact OrdinaryTerms.action_vertex (intervalTerms (underlyingComplex (k := k) P) a l)
+    (intervalDifferential (underlyingComplex (k := k) P) a l) i v
+
+/-- The vertex part is a submodule over A, hence retains both B-actions when A=B tensor B-op. -/
+def vertexSpace (i : Fin (l+1)) : Submodule A (Compression P a l) where
+  carrier := {v | ChainAlgebra.vertex k l i • v = v}
+  zero_mem' := smul_zero _
+  add_mem' := by
+    intro x y hx hy
+    change ChainAlgebra.vertex k l i • (x+y) = x+y
+    rw [smul_add, hx, hy]
+  smul_mem' r v hv := by
+    change ChainAlgebra.vertex k l i • (r • v) = r • v
+    rw [smul_comm, hv]
+
+def vertexInsert (i : Fin (l+1)) : P.X (a+(i.val:ℤ)) →ₗ[A] vertexSpace (k := k) P a l i :=
+  (insert P a l i).codRestrict _ (fun v => by
+    change ChainAlgebra.vertex k l i • insert P a l i v = insert P a l i v
+    rw [vertex_action]
+    congr 1
+    change (Pi.single i v : ∀ j : Fin (l+1), P.X (a+(j.val:ℤ))) i = v
+    simp)
+
+/-- Actual A-linear identification of the compressed vertex with its original term. -/
+def vertexEquiv (i : Fin (l+1)) : vertexSpace (k := k) P a l i ≃ₗ[A] P.X (a+(i.val:ℤ)) where
+  __ := (project P a l i).comp (vertexSpace (k := k) P a l i).subtype
+  invFun := vertexInsert (k := k) P a l i
+  left_inv x := by
+    apply Subtype.ext
+    exact (vertex_action (k := k) P a l i x.val).symm.trans x.property
+  right_inv v := by
+    change (Pi.single i v : ∀ j : Fin (l+1), P.X (a+(j.val:ℤ))) i = v
+    simp
+
+/-- Change only the scalar description of the same actual vertex subspace. -/
+def vertexSpaceScalarEquiv (i : Fin (l+1)) :
+    IdempotentTensor.leftSpace (k := k) (ChainAlgebra.vertex k l i) (Compression P a l) ≃ₗ[k]
+      vertexSpace (k := k) P a l i where
+  toFun x := ⟨x.val,x.property⟩
+  invFun x := ⟨x.val,x.property⟩
+  left_inv _ := rfl
+  right_inv _ := rfl
+  map_add' _ _ := rfl
+  map_smul' _ _ := rfl
+
+/-- The genuine balanced tensor on a vertex projective evaluates to the original term. -/
+def vertexTensorEquiv (i : Fin (l+1)) :
+    BalancedTensor.Tensor k (ChainAlgebra k l)
+      (IdempotentTensor.rightIdeal (ChainAlgebra.vertex k l i)) (Compression P a l) ≃ₗ[k]
+      (underlyingComplex (k := k) P).X (a+(i.val:ℤ)) := by
+  letI (n : ℤ) : Module k (P.X n) := Module.compHom _ (algebraMap k A)
+  letI (n : ℤ) : IsScalarTower k A (P.X n) := IsScalarTower.of_compHom k A (P.X n)
+  exact (IdempotentTensor.tensorEquiv (k := k) (ChainAlgebra.vertex k l i) (Compression P a l)
+    (ChainAlgebra.vertex_idempotent k l i)).trans
+      ((vertexSpaceScalarEquiv (k := k) P a l i).trans
+        ((vertexEquiv (k := k) P a l i).restrictScalars k))
+end LittleFinitistic.OrdinarySimulation.Compression
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryXAugmentation.lean b/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryXAugmentation.lean
new file mode 100644
index 0000000000000000000000000000000000000000..bbb7cdc982d9dd6cd326edb0aabeeadb42cead37
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryXAugmentation.lean
@@ -0,0 +1,51 @@
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryXResolution
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryOffDiagonalForget
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryOffDiagonalSingle
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryRetainedCongruence
+
+namespace OAI
+noncomputable section
+open CategoryTheory
+open scoped TensorProduct
+namespace LittleFinitistic.OrdinarySimulation.XResolution
+universe u
+variable {k B : Type u} [Field k] [Ring B] [Algebra k B]
+variable (P : CochainComplex (ModuleCat.{u} (Enveloping k B)) ℤ) (a : ℤ) (l : ℕ)
+
+/-- The actual ordinary X, represented as a genuine D-bimodule. -/
+abbrev ordinaryXObject : ModuleCat.{u} ((AlgebraD k l B) ⊗[k] (AlgebraD k l B)ᵐᵒᵖ) :=
+  RetainedBimodule.object k (AlgebraD k l B) (AlgebraD k l B) (BimoduleX P a l)
+
+def recoveredObjectIso : OffDiagonal.object k B (B ⊗[k] ChainAlgebra k l)
+    (ordinaryOObject P a l) (TensorResolution.bimoduleTerminalObject k B l) ≅ ordinaryXObject P a l := by
+  let eO := RetainedBimodule.rightEquiv k (B ⊗[k] ChainAlgebra k l) B (BimoduleO P a l)
+  let eT := RetainedBimodule.rightEquiv k B (B ⊗[k] ChainAlgebra k l) (TerminalTensor B)
+  let e := OffDiagonal.congr eO eT
+  have he (d : AlgebraD k l B) x : e (d • x) = d • e x := by
+    apply Prod.ext
+    · exact RetainedBimodule.rightEquiv_left k (B ⊗[k] ChainAlgebra k l) B (BimoduleO P a l) d.2 x.1
+    · exact RetainedBimodule.rightEquiv_left k B (B ⊗[k] ChainAlgebra k l) (TerminalTensor B) d.1 x.2
+  exact (RetainedBimodule.congr (k := k) e he).toModuleIso
+
+/-- The previous component target is exactly X in degree zero, with both D-actions. -/
+def targetIso : target P a l ≅ (HomologicalComplex.single _ (.up ℤ) 0).obj (ordinaryXObject P a l) :=
+  OffDiagonal.singleIso k B (B ⊗[k] ChainAlgebra k l) (ordinaryOObject P a l)
+    (TensorResolution.bimoduleTerminalObject k B l) ≪≫
+    (HomologicalComplex.single _ (.up ℤ) 0).mapIso (recoveredObjectIso P a l)
+
+def augmentationToX : complex P a l ⟶
+    (HomologicalComplex.single _ (.up ℤ) 0).obj (ordinaryXObject P a l) :=
+  augmentation P a l ≫ (targetIso P a l).hom
+
+/-- The actual bounded right-projective complex augments quasi-isomorphically to X. -/
+theorem augmentationToX_quasiIso : QuasiIso (augmentationToX P a l) := by
+  have := TensorResolution.integerBimoduleAugmentation_quasiIso k B l
+  have : QuasiIso (augmentation P a l) := OffDiagonal.complexMap_quasiIso k B (B ⊗[k] ChainAlgebra k l)
+    (𝟙 (ordinaryOComplex P a l)) (TensorResolution.integerBimoduleAugmentation k B l)
+  unfold augmentationToX
+  infer_instance
+end LittleFinitistic.OrdinarySimulation.XResolution
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryXBlockComparison.lean b/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryXBlockComparison.lean
new file mode 100644
index 0000000000000000000000000000000000000000..7b0376f8b7a4facf44f1a7ddbe658897cc9b0363
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryXBlockComparison.lean
@@ -0,0 +1,55 @@
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryXDerivedTensor
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryFirstBlockTotal
+import OAI.Algebra.Finitistic.Ordinary.OrdinarySecondBlockTotal
+import OAI.Algebra.Finitistic.Ordinary.OrdinarySingleTensorTotal
+import OAI.Algebra.Finitistic.Ordinary.OrdinarySourceBimoduleTotal
+
+namespace OAI
+noncomputable section
+open CategoryTheory Limits
+open scoped TensorProduct
+namespace LittleFinitistic.OrdinarySimulation.XResolution
+universe u
+variable {k B : Type u} [Field k] [Ring B] [Algebra k B]
+variable (P : CochainComplex (ModuleCat.{u} (Enveloping k B)) ℤ) (a : ℤ) (l : ℕ)
+
+/-- The first actual tensor application is exactly ordinary O tensor Z on the second block. -/
+def firstBlockComparison (Z : CochainComplex (ModuleCat.{u} B) ℤ) :
+    (tensorFunctor P a l).obj (BlockModule.firstComplex B (B ⊗[k] ChainAlgebra k l) Z) ≅
+    BlockModule.secondComplex B (B ⊗[k] ChainAlgebra k l)
+      (middleLeftComplex k (B ⊗[k] ChainAlgebra k l) B (BimoduleO P a l) Z) :=
+  BlockTensor.firstTotalIso k B (B ⊗[k] ChainAlgebra k l) (ordinaryOComplex P a l)
+    (TensorResolution.integerBimoduleComplex k B l) Z
+    (TensorResolution.finiteDegrees l) (TensorResolution.finiteDegrees_strictMono l) ≪≫
+  ((ProductModules.secondInflation B (B ⊗[k] ChainAlgebra k l)).mapHomologicalComplex (.up ℤ)).mapIso
+    (SingleBimoduleTensor.totalIso k (B ⊗[k] ChainAlgebra k l) B (BimoduleO P a l) Z
+      (TensorResolution.finiteDegrees l) (TensorResolution.finiteDegrees_strictMono l) (Fin.last l)
+      (by simp [TensorResolution.finiteDegrees]))
+
+/-- The second actual tensor application selects Q_T and retains first-block support. -/
+def secondBlockComparison (Y : CochainComplex (ModuleCat.{u} (B ⊗[k] ChainAlgebra k l)) ℤ) :
+    (tensorFunctor P a l).obj (BlockModule.secondComplex B (B ⊗[k] ChainAlgebra k l) Y) ≅
+    BlockModule.firstComplex B (B ⊗[k] ChainAlgebra k l)
+      (BimoduleComplexTensor.total k B (B ⊗[k] ChainAlgebra k l) (TensorResolution.integerBimoduleComplex k B l) Y
+        (TensorResolution.finiteDegrees l) (TensorResolution.finiteDegrees_strictMono l)) :=
+  BlockTensor.secondTotalIso k B (B ⊗[k] ChainAlgebra k l) (ordinaryOComplex P a l)
+    (TensorResolution.integerBimoduleComplex k B l) Y
+    (TensorResolution.finiteDegrees l) (TensorResolution.finiteDegrees_strictMono l)
+
+/-- The complete actual chain-level square calculation, with the source support and outside action. -/
+def squareComparison (b : ℤ) (hb : a+(l:ℤ)=b)
+    (hP : ∀ n : ℤ, n < a ∨ b < n → IsZero (P.X n))
+    (Z : CochainComplex (ModuleCat.{u} B) ℤ) :
+    (tensorFunctor P a l).obj ((tensorFunctor P a l).obj (BlockModule.firstComplex B (B ⊗[k] ChainAlgebra k l) Z)) ≅
+    BlockModule.firstComplex B (B ⊗[k] ChainAlgebra k l)
+      (BimoduleComplexTensor.total k B B (P⟦b⟧) Z
+        (TensorResolution.finiteDegrees l) (TensorResolution.finiteDegrees_strictMono l)) :=
+  (tensorFunctor P a l).mapIso (firstBlockComparison P a l Z) ≪≫
+  secondBlockComparison P a l (middleLeftComplex k (B ⊗[k] ChainAlgebra k l) B (BimoduleO P a l) Z) ≪≫
+  ((ProductModules.firstInflation B (B ⊗[k] ChainAlgebra k l)).mapHomologicalComplex (.up ℤ)).mapIso
+    (sourceBimoduleTotalComparison P a l b hb hP Z)
+end LittleFinitistic.OrdinarySimulation.XResolution
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryXDerivedTensor.lean b/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryXDerivedTensor.lean
new file mode 100644
index 0000000000000000000000000000000000000000..e868ab7d7a8295ff90b27bcb2fc166b5fd4212c0
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryXDerivedTensor.lean
@@ -0,0 +1,43 @@
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryXAugmentation
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryBimoduleDerivedTensor
+
+namespace OAI
+noncomputable section
+open CategoryTheory
+namespace LittleFinitistic.OrdinarySimulation.XResolution
+universe u
+variable {k B : Type u} [Field k] [Ring B] [Algebra k B]
+variable (P : CochainComplex (ModuleCat.{u} (Enveloping k B)) ℤ) (a : ℤ) (l : ℕ)
+variable [∀ n, Module.Projective Bᵐᵒᵖ ((underlyingRightComplex P).X n)]
+
+instance rightTerm_projective (n : ℤ) : Module.Projective (AlgebraD k l B)ᵐᵒᵖ
+    (ComplexTensor.rightTerm k (AlgebraD k l B)
+      (BimoduleComplexTensor.rightComplex k (AlgebraD k l B) (AlgebraD k l B) (complex P a l)) n) :=
+  right_projective P a l n
+
+/-- Tensor with the actual right-projective Q_X on arbitrary input complexes of D-modules. -/
+abbrev tensorFunctor := BimoduleComplexTensor.totalFunctor k (AlgebraD k l B) (AlgebraD k l B)
+  (complex P a l) (TensorResolution.finiteDegrees l) (TensorResolution.finiteDegrees_strictMono l)
+
+theorem tensorFunctor_quasiIso {Z Z' : CochainComplex (ModuleCat.{u} (AlgebraD k l B)) ℤ}
+    (f : Z ⟶ Z') [QuasiIso f] : QuasiIso ((tensorFunctor P a l).map f) :=
+  BimoduleComplexTensor.totalFunctor_quasiIso k (AlgebraD k l B) (AlgebraD k l B)
+    (complex P a l) (TensorResolution.finiteDegrees l) (TensorResolution.finiteDegrees_strictMono l) f
+
+variable [HasDerivedCategory.{u+1} (ModuleCat.{u} (AlgebraD k l B))]
+
+/-- The derived endofunctor obtained from the actual bounded resolution of X. -/
+def derivedTensor : DerivedCategory (ModuleCat.{u} (AlgebraD k l B)) ⥤
+    DerivedCategory (ModuleCat.{u} (AlgebraD k l B)) :=
+  BimoduleComplexTensor.derivedTotal k (AlgebraD k l B) (AlgebraD k l B) (complex P a l)
+    (TensorResolution.finiteDegrees l) (TensorResolution.finiteDegrees_strictMono l)
+
+def derivedTensorComparison : DerivedCategory.Q ⋙ derivedTensor P a l ≅
+    tensorFunctor P a l ⋙ DerivedCategory.Q :=
+  BimoduleComplexTensor.derivedTotalComparison k (AlgebraD k l B) (AlgebraD k l B) (complex P a l)
+    (TensorResolution.finiteDegrees l) (TensorResolution.finiteDegrees_strictMono l)
+end LittleFinitistic.OrdinarySimulation.XResolution
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryXResolution.lean b/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryXResolution.lean
new file mode 100644
index 0000000000000000000000000000000000000000..528fb81633e48143292de0e4181377c863042c8d
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryXResolution.lean
@@ -0,0 +1,85 @@
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryOffDiagonalComplexMaps
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryOffDiagonalProjective
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryRetainedRestriction
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryBimoduleAugmentationQuasiIso
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryBimoduleResolutionProjective
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryRightProjective
+
+namespace OAI
+noncomputable section
+open CategoryTheory Limits
+open scoped TensorProduct
+namespace LittleFinitistic.OrdinarySimulation.XResolution
+universe u
+variable {k B : Type u} [Field k] [Ring B] [Algebra k B]
+variable (P : CochainComplex (ModuleCat.{u} (Enveloping k B)) ℤ) (a : ℤ) (l : ℕ)
+
+abbrev ordinaryOObject : ModuleCat.{u} ((B ⊗[k] ChainAlgebra k l) ⊗[k] Bᵐᵒᵖ) :=
+  RetainedBimodule.object k (B ⊗[k] ChainAlgebra k l) B (BimoduleO P a l)
+
+abbrev ordinaryOComplex : CochainComplex (ModuleCat.{u} ((B ⊗[k] ChainAlgebra k l) ⊗[k] Bᵐᵒᵖ)) ℤ :=
+  (HomologicalComplex.single _ (.up ℤ) 0).obj (ordinaryOObject P a l)
+
+/-- The manuscript's actual Q_X = O[0] ⊕ Q_T, with both D-actions retained. -/
+def complex := OffDiagonal.complex k B (B ⊗[k] ChainAlgebra k l)
+  (ordinaryOComplex P a l) (TensorResolution.integerBimoduleComplex k B l)
+
+abbrev target := OffDiagonal.complex k B (B ⊗[k] ChainAlgebra k l)
+  (ordinaryOComplex P a l)
+  ((HomologicalComplex.single _ (.up ℤ) 0).obj (TensorResolution.bimoduleTerminalObject k B l))
+
+/-- The identity on O and the genuine terminal augmentation give a D-bimodule chain map. -/
+def augmentation : complex P a l ⟶ target P a l :=
+  OffDiagonal.complexMap k B (B ⊗[k] ChainAlgebra k l) (𝟙 _)
+    (TensorResolution.integerBimoduleAugmentation k B l)
+
+theorem ordinaryOComplex_right_projective
+    [∀ n, Module.Projective Bᵐᵒᵖ ((underlyingRightComplex P).X n)] (n : ℤ) :
+    Module.Projective Bᵐᵒᵖ (BimoduleCoefficients k (B ⊗[k] ChainAlgebra k l) B
+      ((ordinaryOComplex P a l).X n)) := by
+  let F : ModuleCat.{u} ((B ⊗[k] ChainAlgebra k l) ⊗[k] Bᵐᵒᵖ) ⥤ ModuleCat.{u} Bᵐᵒᵖ := ModuleCat.restrictScalars
+    (Algebra.TensorProduct.includeRight (R := k) (A := B ⊗[k] ChainAlgebra k l) (B := Bᵐᵒᵖ)).toRingHom
+  by_cases hn : n = 0
+  · subst n
+    have := ordinaryO_right_projective P a l
+    have : Module.Projective Bᵐᵒᵖ (F.obj (ordinaryOObject P a l)) :=
+      Module.Projective.of_equiv (RetainedBimodule.rightEquiv k (B ⊗[k] ChainAlgebra k l) B (BimoduleO P a l)).symm
+    have : Projective (F.obj (ordinaryOObject P a l)) := ModuleCat.projective_of_categoryTheory_projective _
+    have : Projective (F.obj ((ordinaryOComplex P a l).X 0)) := Projective.of_iso
+      (F.mapIso (HomologicalComplex.singleObjXSelf (.up ℤ) 0 (ordinaryOObject P a l))).symm inferInstance
+    exact ModuleCat.projective_of_module_projective (F.obj ((ordinaryOComplex P a l).X 0))
+  · have hz := HomologicalComplex.isZero_single_obj_X (.up ℤ) 0 (ordinaryOObject P a l) n hn
+    have : Projective (F.obj ((ordinaryOComplex P a l).X n)) := (F.map_isZero hz).projective
+    exact ModuleCat.projective_of_module_projective (F.obj ((ordinaryOComplex P a l).X n))
+
+/-- Every actual term of Q_X is right-D-projective; no left projectivity is assumed. -/
+theorem right_projective
+    [∀ n, Module.Projective Bᵐᵒᵖ ((underlyingRightComplex P).X n)] (n : ℤ) :
+    Module.Projective (AlgebraD k l B)ᵐᵒᵖ
+      (BimoduleCoefficients k (AlgebraD k l B) (AlgebraD k l B) ((complex P a l).X n)) := by
+  have := ordinaryOComplex_right_projective P a l n
+  have : Module.Projective (B ⊗[k] ChainAlgebra k l)ᵐᵒᵖ
+      (BimoduleCoefficients k B (B ⊗[k] ChainAlgebra k l)
+        ((TensorResolution.integerBimoduleComplex k B l).X n)) :=
+    TensorResolution.integerBimoduleRight_projective k B l n
+  have := OffDiagonal.right_projective B (B ⊗[k] ChainAlgebra k l)
+    (BimoduleCoefficients k (B ⊗[k] ChainAlgebra k l) B ((ordinaryOComplex P a l).X n))
+    (BimoduleCoefficients k B (B ⊗[k] ChainAlgebra k l) ((TensorResolution.integerBimoduleComplex k B l).X n))
+  exact Module.Projective.of_equiv (RetainedBimodule.rightEquiv k (AlgebraD k l B) (AlgebraD k l B) _).symm
+
+/-- The support of the genuine resolution is exactly bounded by [-l,0]. -/
+theorem vanishes (n : ℤ) (hn : n < -(l:ℤ) ∨ 0 < n) : IsZero ((complex P a l).X n) := by
+  have hn0 : n ≠ 0 := by omega
+  have hO := HomologicalComplex.isZero_single_obj_X (.up ℤ) 0 (ordinaryOObject P a l) n hn0
+  have hT : IsZero ((TensorResolution.integerBimoduleComplex k B l).X n) := hn.elim
+    (TensorResolution.integerBimodule_lower k B l n) (TensorResolution.integerBimodule_upper k B l n)
+  have := ModuleCat.isZero_iff_subsingleton.mp hO
+  have := ModuleCat.isZero_iff_subsingleton.mp hT
+  apply ModuleCat.isZero_iff_subsingleton.mpr
+  exact inferInstanceAs (Subsingleton (((ordinaryOComplex P a l).X n) ×
+    ((TensorResolution.integerBimoduleComplex k B l).X n)))
+end LittleFinitistic.OrdinarySimulation.XResolution
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Rectification/AdjacentArrowSum.lean b/lean/OAI/Algebra/Finitistic/Rectification/AdjacentArrowSum.lean
new file mode 100644
index 0000000000000000000000000000000000000000..7022742a79592af83de83461e215d543cbfd96cb
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Rectification/AdjacentArrowSum.lean
@@ -0,0 +1,86 @@
+import OAI.Algebra.Finitistic.Rectification.CornerArrowCoordinates
+import OAI.Algebra.Finitistic.Rectification.TensorArrowSum
+
+namespace OAI
+noncomputable section
+open CategoryTheory CategoryTheory.Limits
+open scoped TensorProduct ModuleCat.Algebra
+namespace LittleFinitistic.AdjacentArrowSum
+universe u
+variable {k V W U : Type u} [Field k] [AddCommGroup V] [Module k V]
+  [AddCommGroup W] [Module k W] [AddCommGroup U] [Module k U]
+variable (μ : W →ₗ[k] V →ₗ[k] U)
+variable (D : CochainComplex (ModuleCat.{u} (ThreeVertexAlgebra μ)ᵐᵒᵖ) ℤ)
+local notation "T" => ThreeVertexAlgebra μ
+local instance : HasFiniteBiproducts (CochainComplex (ModuleCat.{u} Tᵐᵒᵖ) ℤ) :=
+  HasFiniteBiproducts.of_hasFiniteProducts
+abbrev vertexComplex (v : Fin 3) :=
+  (BimoduleVertex.functor k T (ThreeVertexAlgebra.vertex μ v)).mapHomologicalComplex (.up ℤ)
+
+def sourceIso (v : Fin 3) :
+    (vertexComplex μ v).obj ((ExternalTensor.Section4.columnComplex k T
+      (ThreeVertexAlgebra.vertex μ v)).obj D) ≅
+      (TensorComplex.tensorFunctor (k := k) D).obj (ModuleCat.of k k) :=
+  (CornerColumnComplex.complexIso μ v v D).symm ≪≫
+    (TensorComplex.tensorFunctor (k := k) D).mapIso (CornerSpaces.diagonalEquiv μ v).toModuleIso
+
+def targetIso (v i : Fin 3) (d : ℕ)
+    (ξ : CornerSpaces.corner μ v i ≃ₗ[k] QuadraticEncoding.Arrows k d) :
+    (vertexComplex μ v).obj ((ExternalTensor.Section4.columnComplex k T
+      (ThreeVertexAlgebra.vertex μ i)).obj D) ≅
+      (TensorComplex.tensorFunctor (k := k) D).obj (ModuleCat.of k (QuadraticEncoding.Arrows k d)) :=
+  (CornerColumnComplex.complexIso μ v i D).symm ≪≫
+    (TensorComplex.tensorFunctor (k := k) D).mapIso ξ.toModuleIso
+
+/-- An actual adjacent path family becomes the full arrow basis under corner coordinates. -/
+theorem desc_isIso (v i : Fin 3) (d : ℕ)
+    (ξ : CornerSpaces.corner μ v i ≃ₗ[k] QuadraticEncoding.Arrows k d)
+    (a : Fin (d+1) → ThreeVertexAlgebra μ)
+    (ha : ∀ j, a j * ThreeVertexAlgebra.vertex μ i = a j)
+    (hc : ∀ j c, ξ (CornerColumnPaths.cornerMap μ v i v (a j) (ha j)
+      ((CornerSpaces.diagonalEquiv μ v).symm c)) = c • QuadraticEncoding.basis j) :
+    IsIso (biproduct.desc (fun j => (vertexComplex μ v).map
+      (ExternalTensor.Section4.path k T (ThreeVertexAlgebra.vertex μ i)
+        (ThreeVertexAlgebra.vertex μ v) (a j) (ha j) D))) := by
+  let F := TensorComplex.tensorFunctor (k := k) D
+  apply TensorArrowSum.desc_isIso_of_coordinates k d F _ _
+    (fun _ => sourceIso μ D v) (targetIso μ D v i d ξ)
+  intro j
+  have hm : ModuleCat.ofHom (CornerSpaces.diagonalEquiv μ v).toLinearMap ≫
+      TensorArrowSum.insertion k d j =
+      ModuleCat.ofHom (CornerColumnPaths.cornerMap μ v i v (a j) (ha j)) ≫
+        ModuleCat.ofHom ξ.toLinearMap := by
+    apply ModuleCat.hom_ext
+    apply LinearMap.ext
+    intro x
+    change (TensorArrowSum.insertion k d j).hom ((CornerSpaces.diagonalEquiv μ v) x) =
+      ξ (CornerColumnPaths.cornerMap μ v i v (a j) (ha j) x)
+    rw [TensorArrowSum.insertion_apply]
+    simpa only [LinearEquiv.symm_apply_apply]
+      using (hc j ((CornerSpaces.diagonalEquiv μ v) x)).symm
+  have hF := congrArg F.map hm
+  simp only [Functor.map_comp] at hF
+  apply (cancel_epi (CornerColumnComplex.complexIso μ v v D).hom).1
+  calc
+    _ = F.map (ModuleCat.ofHom (CornerSpaces.diagonalEquiv μ v).toLinearMap) ≫
+        F.map (TensorArrowSum.insertion k d j) := by
+      change (CornerColumnComplex.complexIso μ v v D).hom ≫
+        ((CornerColumnComplex.complexIso μ v v D).inv ≫
+          F.map (ModuleCat.ofHom (CornerSpaces.diagonalEquiv μ v).toLinearMap)) ≫
+        F.map (TensorArrowSum.insertion k d j) = _
+      erw [Category.assoc]
+      exact (CornerColumnComplex.complexIso μ v v D).hom_inv_id_assoc _
+    _ = F.map (ModuleCat.ofHom (CornerColumnPaths.cornerMap μ v i v (a j) (ha j))) ≫
+        F.map (ModuleCat.ofHom ξ.toLinearMap) := hF
+    _ = (F.map (ModuleCat.ofHom
+          (CornerColumnPaths.cornerMap μ v i v (a j) (ha j))) ≫
+        (CornerColumnComplex.complexIso μ v i D).hom) ≫
+          (targetIso μ D v i d ξ).hom := by simp [targetIso,F,TensorComplex.tensorFunctor]
+    _ = _ := by
+      erw [CornerColumnPaths.path_naturality]
+      exact Category.assoc _ _ _
+end LittleFinitistic.AdjacentArrowSum
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Rectification/ArrowCompatibility.lean b/lean/OAI/Algebra/Finitistic/Rectification/ArrowCompatibility.lean
new file mode 100644
index 0000000000000000000000000000000000000000..7a4aeceae5a60831f3b46c815e23e1d37c7b4a37
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Rectification/ArrowCompatibility.lean
@@ -0,0 +1,112 @@
+import OAI.Algebra.Finitistic.Rectification.ArrowVertex
+import OAI.Algebra.Finitistic.Rectification.RectificationTotal
+import Mathlib.Algebra.Category.ModuleCat.Biproducts
+
+namespace OAI
+open CategoryTheory CategoryTheory.Limits HomologicalComplex
+open scoped TensorProduct ModuleCat.Algebra
+noncomputable section
+namespace ExternalTensor.Section4.ArrowVertex
+universe u
+variable {k B : Type u} [Field k] [Ring B] [Algebra k B]
+
+/-- Original insertion through the zero-column inclusion of the actual total. -/
+def iota {L₀ L₁ L₂ : BiComplex k B} (p : L₁ ⟶ L₀) (q : L₂ ⟶ L₁)
+    (h : Homotopy (q ≫ p) 0) (e : B) (he : e * e = e)
+    (D : RightComplex B) (t : (columnComplex k B e).obj D ⟶ L₀) :
+    D ⟶ (vertexComplex k B e).obj (LittleFinitistic.RectificationTotal.total p q h) :=
+  diagonalComplex k B e he D ≫ (vertexComplex k B e).map
+    (t ≫ LittleFinitistic.RectificationTotal.inclusion p q h)
+
+/-- The insertion has exactly the manuscript's diagonal tensor, before any coordinates. -/
+@[simp] theorem iota_original {L₀ L₁ L₂ : BiComplex k B}
+    (p : L₁ ⟶ L₀) (q : L₂ ⟶ L₁) (h : Homotopy (q ≫ p) 0)
+    (e : B) (he : e * e = e) (D : RightComplex B)
+    (t : (columnComplex k B e).obj D ⟶ L₀) (n : ℤ) (x : D.X n) :
+    (((iota p q h e he D t).f n) x).val =
+      ((t ≫ LittleFinitistic.RectificationTotal.inclusion p q h).f n)
+        (generator B e ⊗ₜ[k] x) := rfl
+
+/-- The original p-boundary produces compatibility in the actual target vertex. -/
+def compatibility {L₀ L₁ L₂ : BiComplex k B} (p : L₁ ⟶ L₀) (q : L₂ ⟶ L₁)
+    (h : Homotopy (q ≫ p) 0) (ei ej a : B) (hei : ei * ei = ei)
+    (hej : ej * ej = ej) (hai : a * ei = a) (hja : ej * a = a)
+    {D E : RightComplex B} (f : D ⟶ E)
+    (t : (columnComplex k B ei).obj D ⟶ L₀)
+    (u : (columnComplex k B ej).obj E ⟶ L₀)
+    (w : (columnComplex k B ej).obj D ⟶ L₁)
+    (hw : w ≫ p = path k B ei ej a hai D ≫ t - (columnComplex k B ej).map f ≫ u) :
+    Homotopy
+      (iota p q h ei hei D t ≫ arrowComplex k B ei ej a hja
+        (LittleFinitistic.RectificationTotal.total p q h))
+      (f ≫ iota p q h ej hej E u) := by
+  let inc := LittleFinitistic.RectificationTotal.inclusion p q h
+  let F := vertexComplex k B ej
+  have hb := (LittleFinitistic.RectificationTotal.boundaryHomotopy p q h).compLeft w
+  have hh := ((vertex k B ej).mapHomotopy hb).compLeft (diagonalComplex k B ej hej D)
+  have heq : diagonalComplex k B ej hej D ≫ F.map (w ≫ p ≫ inc) =
+      iota p q h ei hei D t ≫ arrowComplex k B ei ej a hja
+        (LittleFinitistic.RectificationTotal.total p q h) -
+        f ≫ iota p q h ej hej E u := by
+    rw [← Category.assoc w p inc, hw, Preadditive.sub_comp, Functor.map_sub,
+      Preadditive.comp_sub]
+    apply congrArg₂ (fun x y => x - y)
+    · change diagonalComplex k B ej hej D ≫
+          (vertexComplex k B ej).map ((path k B ei ej a hai D ≫ t) ≫ inc) = _
+      rw [Category.assoc, Functor.map_comp, ← Category.assoc,
+        diagonal_path k B ei ej a hei hej hai hja D, Category.assoc,
+        ← arrow_naturality]
+      rfl
+    · change diagonalComplex k B ej hej D ≫
+          (vertexComplex k B ej).map (((columnComplex k B ej).map f ≫ u) ≫ inc) = _
+      rw [Category.assoc, Functor.map_comp, ← Category.assoc, ← diagonal_naturality]
+      rfl
+  refine Homotopy.equivSubZero.symm ?_
+  change Homotopy (diagonalComplex k B ej hej D ≫ F.map (w ≫ p ≫ inc))
+    (diagonalComplex k B ej hej D ≫ F.map (w ≫ 0)) at hh
+  rw [comp_zero, Functor.map_zero, comp_zero, heq] at hh
+  exact hh
+
+variable {A J R : Type} [Fintype A] [Fintype J] [Fintype R]
+variable (s : Quadratic k B (A := A) (J := J) (R := R))
+variable (D₀ D₁ D₂ : RightComplex B)
+variable (f : A → (D₀ ⟶ D₁)) (g : J → (D₁ ⟶ D₂))
+variable (H : ∀ r, Homotopy (relationMap s D₀ D₁ D₂ f g r) 0)
+
+abbrev actualP : BiComplex k B := LittleFinitistic.RectificationTotal.total
+  (p s D₀ D₁ D₂ f g) (q s D₀ D₁ D₂ f g) (nullHomotopy s D₀ D₁ D₂ f g H)
+
+abbrev iota0 (he : s.e₀ * s.e₀ = s.e₀) :=
+  iota (p s D₀ D₁ D₂ f g) (q s D₀ D₁ D₂ f g) (nullHomotopy s D₀ D₁ D₂ f g H)
+    s.e₀ he D₀ (inducedData s D₀ D₁ D₂ f g).in₀
+abbrev iota1 (he : s.e₁ * s.e₁ = s.e₁) :=
+  iota (p s D₀ D₁ D₂ f g) (q s D₀ D₁ D₂ f g) (nullHomotopy s D₀ D₁ D₂ f g H)
+    s.e₁ he D₁ (inducedData s D₀ D₁ D₂ f g).in₁
+abbrev iota2 (he : s.e₂ * s.e₂ = s.e₂) :=
+  iota (p s D₀ D₁ D₂ f g) (q s D₀ D₁ D₂ f g) (nullHomotopy s D₀ D₁ D₂ f g H)
+    s.e₂ he D₂ (inducedData s D₀ D₁ D₂ f g).in₂
+
+/-- Compatibility of the actual original vertex-zero insertion with every 0-to-1 arrow. -/
+def compatibility01 (h₀ : s.e₀ * s.e₀ = s.e₀) (h₁ : s.e₁ * s.e₁ = s.e₁)
+    (a : A) (ha : s.e₁ * s.a a = s.a a) :
+    Homotopy (iota0 s D₀ D₁ D₂ f g H h₀ ≫
+      arrowComplex k B s.e₀ s.e₁ (s.a a) ha (actualP s D₀ D₁ D₂ f g H))
+      (f a ≫ iota1 s D₀ D₁ D₂ f g H h₁) :=
+  compatibility _ _ _ _ _ _ h₀ h₁ (s.ha a) ha (f a) _ _
+    (biproduct.ι (inducedData s D₀ D₁ D₂ f g).U a ≫ biprod.inl)
+    (p_arrow01 s D₀ D₁ D₂ f g a)
+
+/-- Compatibility of the actual original vertex-one insertion with every 1-to-2 arrow. -/
+def compatibility12 (h₁ : s.e₁ * s.e₁ = s.e₁) (h₂ : s.e₂ * s.e₂ = s.e₂)
+    (b : J) (hb : s.e₂ * s.b b = s.b b) :
+    Homotopy (iota1 s D₀ D₁ D₂ f g H h₁ ≫
+      arrowComplex k B s.e₁ s.e₂ (s.b b) hb (actualP s D₀ D₁ D₂ f g H))
+      (g b ≫ iota2 s D₀ D₁ D₂ f g H h₂) :=
+  compatibility _ _ _ _ _ _ h₁ h₂ (s.hb b) hb (g b) _ _
+    (biproduct.ι (inducedData s D₀ D₁ D₂ f g).V b ≫ biprod.inr)
+    (p_arrow12 s D₀ D₁ D₂ f g b)
+end ExternalTensor.Section4.ArrowVertex
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Rectification/ArrowVertex.lean b/lean/OAI/Algebra/Finitistic/Rectification/ArrowVertex.lean
new file mode 100644
index 0000000000000000000000000000000000000000..48a4987391518d37b66d007a0271c0447c6083b8
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Rectification/ArrowVertex.lean
@@ -0,0 +1,162 @@
+import OAI.Algebra.Finitistic.Rectification.ColumnProperties
+
+namespace OAI
+open CategoryTheory CategoryTheory.Limits HomologicalComplex
+open scoped TensorProduct ModuleCat.Algebra
+noncomputable section
+namespace ExternalTensor.Section4.ArrowVertex
+attribute [local instance] ExternalTensor.bimodule ExternalTensor.rightModule
+universe u
+variable (k B : Type u) [Field k] [Ring B] [Algebra k B]
+
+/-- Left multiplication on a bimodule, regarded as a right-linear map. -/
+def left (a : B) (N : ModuleCat.{u} (Enveloping k B)) :
+    (forgetRight k B).obj N →ₗ[Bᵐᵒᵖ] (forgetRight k B).obj N where
+  toFun x := (a ⊗ₜ[k] (1 : Bᵐᵒᵖ)) • (show N from x)
+  map_add' x y := smul_add (a ⊗ₜ[k] (1 : Bᵐᵒᵖ)) (show N from x) (show N from y)
+  map_smul' c x := by
+    change (a ⊗ₜ[k] (1 : Bᵐᵒᵖ)) • ((1 ⊗ₜ[k] c : Enveloping k B) • (show N from x)) =
+      (1 ⊗ₜ[k] c : Enveloping k B) • ((a ⊗ₜ[k] (1 : Bᵐᵒᵖ)) • (show N from x))
+    erw [← mul_smul, ← mul_smul]
+    simp only [Algebra.TensorProduct.tmul_mul_tmul, mul_one, one_mul]
+
+@[simp] theorem left_mul (a b : B) (N : ModuleCat.{u} (Enveloping k B))
+    (x : (forgetRight k B).obj N) : left k B (a * b) N x = left k B a N (left k B b N x) := by
+  change ((a * b) ⊗ₜ[k] (1 : Bᵐᵒᵖ)) • (show N from x) =
+    (a ⊗ₜ[k] (1 : Bᵐᵒᵖ)) • ((b ⊗ₜ[k] (1 : Bᵐᵒᵖ)) • (show N from x))
+  erw [← mul_smul]
+  simp only [Algebra.TensorProduct.tmul_mul_tmul, mul_one]
+
+@[simp] theorem map_left {N N' : ModuleCat.{u} (Enveloping k B)}
+    (f : N ⟶ N') (a : B) (x : (forgetRight k B).obj N) :
+    (forgetRight k B).map f (left k B a N x) =
+      left k B a N' ((forgetRight k B).map f x) := f.hom.map_smul _ _
+
+/-- The actual fixed submodule eN, for an idempotent e. -/
+def space (e : B) (N : ModuleCat.{u} (Enveloping k B)) :
+    Submodule Bᵐᵒᵖ ((forgetRight k B).obj N) :=
+  LinearMap.ker (left k B e N - LinearMap.id)
+
+@[simp] theorem mem_space (e : B) (N : ModuleCat.{u} (Enveloping k B))
+    (x : (forgetRight k B).obj N) : x ∈ space k B e N ↔ left k B e N x = x := by
+  simp [space, LinearMap.mem_ker, sub_eq_zero]
+
+/-- For idempotents the fixed submodule is exactly the image eN. -/
+theorem space_eq_range (e : B) (he : e * e = e)
+    (N : ModuleCat.{u} (Enveloping k B)) :
+    space k B e N = (left k B e N).range := by
+  ext x
+  rw [mem_space, LinearMap.mem_range]
+  constructor
+  · intro hx
+    exact ⟨x, hx⟩
+  · rintro ⟨y, rfl⟩
+    rw [← left_mul, he]
+
+/-- Vertex restriction retains the original elements, rather than chosen coordinates. -/
+def vertex (e : B) : ModuleCat.{u} (Enveloping k B) ⥤ ModuleCat.{u} Bᵐᵒᵖ where
+  obj N := ModuleCat.of _ (space k B e N)
+  map f := ModuleCat.ofHom
+    { toFun x := ⟨(forgetRight k B).map f x.val, by
+        rw [mem_space, ← map_left, (mem_space k B e _ _).1 x.property]⟩
+      map_add' x y := Subtype.ext (map_add _ _ _)
+      map_smul' c x := Subtype.ext (map_smul _ _ _) }
+  map_id N := by ext x; rfl
+  map_comp f g := by ext x; rfl
+instance vertex_additive (e : B) : (vertex k B e).Additive where
+  map_add := by intros; ext x; rfl
+
+abbrev vertexComplex (e : B) : BiComplex k B ⥤ RightComplex B :=
+  (vertex k B e).mapHomologicalComplex (ComplexShape.up ℤ)
+
+/-- The intervertex map is precisely left multiplication by a. -/
+def arrow (ei ej a : B) (hja : ej * a = a) : vertex k B ei ⟶ vertex k B ej where
+  app N := ModuleCat.ofHom
+    { toFun x := ⟨left k B a N x.val, by
+        rw [mem_space, ← left_mul, hja]⟩
+      map_add' x y := Subtype.ext (map_add _ _ _)
+      map_smul' c x := Subtype.ext (map_smul _ _ _) }
+  naturality {N N'} f := by ext x; apply Subtype.ext; exact (map_left k B f a x.val).symm
+
+abbrev arrowComplex (ei ej a : B) (hja : ej * a = a) (P : BiComplex k B) :
+    (vertexComplex k B ei).obj P ⟶ (vertexComplex k B ej).obj P :=
+  ((arrow k B ei ej a hja).mapHomologicalComplex (ComplexShape.up ℤ)).app P
+
+@[simp] theorem arrow_original (ei ej a : B) (hja : ej * a = a)
+    (P : BiComplex k B) (n : ℤ) (x : ((vertexComplex k B ei).obj P).X n) :
+    (((arrowComplex k B ei ej a hja P).f n) x).val =
+      (a ⊗ₜ[k] (1 : Bᵐᵒᵖ)) • (show P.X n from x.val) := rfl
+
+/-- Composition uses multiplication in B in the original arrow order. -/
+@[reassoc] theorem arrow_comp (ei ej el a b : B) (hja : ej * a = a)
+    (hlb : el * b = b) (hlba : el * (b * a) = b * a) (P : BiComplex k B) :
+    arrowComplex k B ei ej a hja P ≫ arrowComplex k B ej el b hlb P =
+      arrowComplex k B ei el (b * a) hlba P := by
+  ext n x
+  apply Subtype.ext
+  exact (left_mul k B b a (P.X n) x.val).symm
+
+/-- The trivial path acts as the identity on its vertex. -/
+@[simp] theorem arrow_id (e : B) (he : e * e = e) (P : BiComplex k B) :
+    arrowComplex k B e e e he P = 𝟙 ((vertexComplex k B e).obj P) := by
+  ext n x
+  apply Subtype.ext
+  exact (mem_space k B e (P.X n) x.val).1 x.property
+
+/-- The original diagonal tensor e tensor n in its actual fixed submodule. -/
+def diagonal (e : B) (he : e * e = e) :
+    𝟭 (ModuleCat.{u} Bᵐᵒᵖ) ⟶ columnFunctor k B e ⋙ vertex k B e where
+  app N := ModuleCat.ofHom
+    { toFun n := ⟨generator B e ⊗ₜ[k] n, by
+        erw [mem_space]
+        change (e • generator B e) ⊗ₜ[k] ((1 : Bᵐᵒᵖ) • n) = generator B e ⊗ₜ[k] n
+        rw [one_smul]
+        congr 1
+        exact Subtype.ext he⟩
+      map_add' x y := Subtype.ext (TensorProduct.tmul_add _ _ _)
+      map_smul' c x := by
+        apply Subtype.ext
+        change generator B e ⊗ₜ[k] (c • x) =
+          (1 ⊗ₜ[k] c : Enveloping k B) • (generator B e ⊗ₜ[k] x)
+        rw [ExternalTensor.smul_tmul, one_smul] }
+  naturality {N N'} f := by ext x; rfl
+
+/-- Original insertion into a single induced column, degree by degree. -/
+def diagonalComplex (e : B) (he : e * e = e) (D : RightComplex B) :
+    D ⟶ (vertexComplex k B e).obj ((columnComplex k B e).obj D) where
+  f n := (diagonal k B e he).app (D.X n)
+  comm' i j _hij := (diagonal k B e he).naturality (D.d i j)
+
+@[reassoc] theorem diagonal_naturality (e : B) (he : e * e = e)
+    {D E : RightComplex B} (f : D ⟶ E) :
+    f ≫ diagonalComplex k B e he E = diagonalComplex k B e he D ≫
+      (vertexComplex k B e).map ((columnComplex k B e).map f) := by
+  ext n x
+  rfl
+
+/-- Right multiplication in p at e_j agrees with left arrow action at e_i. -/
+@[reassoc] theorem diagonal_path (ei ej a : B) (hei : ei * ei = ei)
+    (hej : ej * ej = ej) (hai : a * ei = a) (hja : ej * a = a)
+    (D : RightComplex B) :
+    diagonalComplex k B ej hej D ≫ (vertexComplex k B ej).map (path k B ei ej a hai D) =
+      diagonalComplex k B ei hei D ≫
+        arrowComplex k B ei ej a hja ((columnComplex k B ei).obj D) := by
+  ext n x
+  apply Subtype.ext
+  change (pathMap ei ej a hai (generator B ej)) ⊗ₜ[k] x =
+    (a • generator B ei) ⊗ₜ[k] ((1 : Bᵐᵒᵖ) • x)
+  rw [one_smul]
+  congr 1
+  apply Subtype.ext
+  exact hja.trans hai.symm
+
+@[reassoc] theorem arrow_naturality (ei ej a : B) (hja : ej * a = a)
+    {P Q : BiComplex k B} (f : P ⟶ Q) :
+    (vertexComplex k B ei).map f ≫ arrowComplex k B ei ej a hja Q =
+      arrowComplex k B ei ej a hja P ≫ (vertexComplex k B ej).map f :=
+  ((arrow k B ei ej a hja).mapHomologicalComplex (ComplexShape.up ℤ)).naturality f
+end ExternalTensor.Section4.ArrowVertex
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Rectification/BiprodEvaluationSquare.lean b/lean/OAI/Algebra/Finitistic/Rectification/BiprodEvaluationSquare.lean
new file mode 100644
index 0000000000000000000000000000000000000000..7b7548b9489b1b729e38ccb2dcf4dda0977bb4ef
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Rectification/BiprodEvaluationSquare.lean
@@ -0,0 +1,45 @@
+import OAI.Algebra.Finitistic.Localization.FormalSummandAction
+import Mathlib.CategoryTheory.Limits.Preserves.Shapes.Biproducts
+
+namespace OAI
+noncomputable section
+open CategoryTheory CategoryTheory.Limits CategoryTheory.Idempotents
+namespace LittleFinitistic.BiprodEvaluationSquare
+universe u v w z
+variable {C : Type u} [Category.{v} C] [Preadditive C] [HasBinaryBiproducts C]
+variable {D : Type w} [Category.{z} D] [Preadditive D] [HasBinaryBiproducts D]
+variable (F : C ⥤ D) [F.Additive] [PreservesBinaryBiproducts F]
+
+/-- Transport both diagonal actions through additive evaluation and given summand isomorphisms. -/
+theorem square {A B : C} {A' B' : D} (f : A ⟶ A) (g : B ⟶ B)
+    (i : F.obj A ≅ A') (j : F.obj B ≅ B') (f' : A' ⟶ A') (g' : B' ⟶ B')
+    (hf : F.map f ≫ i.hom = i.hom ≫ f') (hg : F.map g ≫ j.hom = j.hom ≫ g') :
+    F.map (biprod.map f g) ≫ (F.mapBiprod A B ≪≫ biprod.mapIso i j).hom =
+      (F.mapBiprod A B ≪≫ biprod.mapIso i j).hom ≫ biprod.map f' g' := by
+  apply biprod.hom_ext
+  · simp only [Iso.trans_hom,Functor.mapBiprod_hom,biprod.mapIso_hom,
+      Category.assoc,biprod.map_fst,biprod.map_fst_assoc,biprod.lift_fst_assoc]
+    rw [← Category.assoc,← Functor.map_comp,biprod.map_fst,Functor.map_comp,Category.assoc,hf]
+  · simp only [Iso.trans_hom,Functor.mapBiprod_hom,biprod.mapIso_hom,
+      Category.assoc,biprod.map_snd,biprod.map_snd_assoc,biprod.lift_snd_assoc]
+    rw [← Category.assoc,← Functor.map_comp,biprod.map_snd,Functor.map_comp,Category.assoc,hg]
+
+variable {k R : Type*} [CommRing k] [Ring R] [Algebra k R]
+variable [Linear k C] [HasShift C ℤ] [HasZeroObject C]
+  [∀ n : ℤ,(shiftFunctor C n).Additive] [Pretriangulated C]
+  [∀ n : ℤ,(shiftFunctor C n).Linear k]
+variable {L : C} (theta : R →ₐ[k] End L) (e : R) (he : e*e=e)
+  (hc : ∀ r : R,e*r=r*e) (alpha : R →ₐ[k] R)
+local instance : HasFiniteBiproducts (Karoubi C) := Karoubi.karoubi_hasFiniteBiproducts
+local instance : HasBinaryBiproducts (Karoubi C) := hasBinaryBiproducts_of_finite_biproducts _
+
+omit [HasBinaryBiproducts C] in
+theorem action_formula (r : R) :
+    FormalSummandAction.oddDoubleAction theta e he hc alpha r =
+      biprod.map (FormalSummandAction.action theta e he hc alpha r)
+        ((OddDouble.formalShiftFunctor 3).map (FormalSummandAction.action theta e he hc alpha r)) := rfl
+end LittleFinitistic.BiprodEvaluationSquare
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Rectification/CanonicalArrowCompatibility.lean b/lean/OAI/Algebra/Finitistic/Rectification/CanonicalArrowCompatibility.lean
new file mode 100644
index 0000000000000000000000000000000000000000..b6b87a74cd00ea00e9955126267cf01b487d313d
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Rectification/CanonicalArrowCompatibility.lean
@@ -0,0 +1,71 @@
+import OAI.Algebra.Finitistic.Localization.NativeArrowBridge
+import OAI.Algebra.Finitistic.Rectification.VertexHomotopyEquivalence
+
+namespace OAI
+noncomputable section
+open CategoryTheory HomologicalComplex
+open scoped TensorProduct
+namespace LittleFinitistic.CanonicalArrowCompatibility
+open ExternalTensor.Section4 ExternalTensor.Section4.ArrowVertex
+open QuadraticEncoding
+universe u
+variable {k : Type u} [Field k] {d t : ℕ} (P : Relations k d t)
+
+lemma diagonal_original (i : Fin 3) (D : RightComplex (B P)) :
+    (VertexColumnComplex.diagonalComplexIso (composition P) i D).hom =
+      diagonalComplex k (B P) (ThreeVertexAlgebra.vertex (composition P) i)
+        ((ThreeVertexAlgebra.directedSystem (composition P)).idem i) D := by
+  apply NativeBridge.diagonal_eq_of_original
+  intro n x
+  exact VertexColumnModels.diagonal_symm_val (composition P) (D.X n) i x
+
+variable (D₀ D₁ D₂ : RightComplex (B P))
+variable (f : Fin (d+1) → (D₀ ⟶ D₁)) (g : Fin (d+1) → (D₁ ⟶ D₂))
+variable (H : ∀ r, Homotopy (relationMap (ConcreteQuadraticDiagram.quadratic P) D₀ D₁ D₂ f g r) 0)
+
+lemma arrow01_target (a : Fin (d+1)) :
+    ThreeVertexAlgebra.vertex (composition P) 1 * arrow01 P a = arrow01 P a := by
+  change ThreeVertexAlgebra.mul (composition P) (0,1,0,0,0,0) (0,0,0,basis a,0,0) = _
+  simp [ThreeVertexAlgebra.mul, arrow01]
+
+lemma arrow12_target (b : Fin (d+1)) :
+    ThreeVertexAlgebra.vertex (composition P) 2 * arrow12 P b = arrow12 P b := by
+  change ThreeVertexAlgebra.mul (composition P) (0,0,1,0,0,0) (0,0,0,0,basis b,0) = _
+  simp [ThreeVertexAlgebra.mul, arrow12]
+
+/-- Left multiplication by the original first arrow on the actual vertex complexes. -/
+def arrow01Map (a : Fin (d+1)) :=
+  arrowComplex k (B P) (ThreeVertexAlgebra.vertex (composition P) 0)
+    (ThreeVertexAlgebra.vertex (composition P) 1) (arrow01 P a) (arrow01_target P a)
+    (InducedRectification.total (ConcreteQuadraticDiagram.quadratic P) D₀ D₁ D₂ f g H)
+
+/-- Left multiplication by the original second arrow on the actual vertex complexes. -/
+def arrow12Map (b : Fin (d+1)) :=
+  arrowComplex k (B P) (ThreeVertexAlgebra.vertex (composition P) 1)
+    (ThreeVertexAlgebra.vertex (composition P) 2) (arrow12 P b) (arrow12_target P b)
+    (InducedRectification.total (ConcreteQuadraticDiagram.quadratic P) D₀ D₁ D₂ f g H)
+
+/-- The homotopy uses exactly the original first and second vertex equivalences. -/
+def compatibility01 (a : Fin (d+1)) : Homotopy
+    (FirstVertex.iota P D₀ D₁ D₂ f g H ≫ arrow01Map P D₀ D₁ D₂ f g H a)
+    (f a ≫ SecondVertex.iota P D₀ D₁ D₂ f g H) := by
+  rw [FirstVertex.iota, SecondVertex.iota_original,
+    diagonal_original, diagonal_original]
+  exact NativeBridge.nativeCompatibility01 (ConcreteQuadraticDiagram.quadratic P)
+    D₀ D₁ D₂ f g H ((ThreeVertexAlgebra.directedSystem (composition P)).idem 0)
+    ((ThreeVertexAlgebra.directedSystem (composition P)).idem 1) a (arrow01_target P a)
+
+/-- The homotopy uses exactly the original second and third vertex equivalences. -/
+def compatibility12 (b : Fin (d+1)) : Homotopy
+    (SecondVertex.iota P D₀ D₁ D₂ f g H ≫ arrow12Map P D₀ D₁ D₂ f g H b)
+    (g b ≫ ThirdVertex.iota P D₀ D₁ D₂ f g H) := by
+  rw [SecondVertex.iota_original, ThirdVertex.iota_original,
+    diagonal_original, diagonal_original]
+  exact NativeBridge.nativeCompatibility12 (ConcreteQuadraticDiagram.quadratic P)
+    D₀ D₁ D₂ f g H ((ThreeVertexAlgebra.directedSystem (composition P)).idem 1)
+    ((ThreeVertexAlgebra.directedSystem (composition P)).idem 2) b (arrow12_target P b)
+end LittleFinitistic.CanonicalArrowCompatibility
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Rectification/ColumnComplex.lean b/lean/OAI/Algebra/Finitistic/Rectification/ColumnComplex.lean
new file mode 100644
index 0000000000000000000000000000000000000000..ea5780b27ce3255ac41f3a5928842f788ba65e44
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Rectification/ColumnComplex.lean
@@ -0,0 +1,132 @@
+import OAI.Algebra.Finitistic.Rectification.InducedColumns
+import Mathlib.Algebra.Category.ModuleCat.Limits
+import Mathlib.Algebra.Homology.Homotopy
+import Mathlib.Algebra.Homology.HomologicalComplexLimits
+
+namespace OAI
+open CategoryTheory CategoryTheory.Limits HomologicalComplex
+open scoped TensorProduct ModuleCat.Algebra
+noncomputable section
+namespace ExternalTensor.Section4
+universe u
+variable (k B : Type u) [Field k] [Ring B] [Algebra k B]
+
+instance rightModuleK (N : ModuleCat.{u} Bᵐᵒᵖ) : Module k N :=
+  Module.compHom N (algebraMap k Bᵐᵒᵖ)
+instance rightModuleTower (N : ModuleCat.{u} Bᵐᵒᵖ) : IsScalarTower k Bᵐᵒᵖ N where
+  smul_assoc r b n := by
+    change (r • b) • n = (algebraMap k Bᵐᵒᵖ r) • (b • n)
+    rw [Algebra.smul_def, mul_smul]
+attribute [local instance] ExternalTensor.bimodule ExternalTensor.rightModule
+
+abbrev Enveloping := B ⊗[k] Bᵐᵒᵖ
+abbrev RightComplex := CochainComplex (ModuleCat.{u} Bᵐᵒᵖ) ℤ
+abbrev BiComplex := CochainComplex (ModuleCat.{u} (Enveloping k B)) ℤ
+
+/-- Induction by the actual left ideal Be, on right modules and maps. -/
+def columnFunctor (e : B) : ModuleCat.{u} Bᵐᵒᵖ ⥤ ModuleCat.{u} (Enveloping k B) where
+  obj N := ModuleCat.of _ (Column k B N e)
+  map f := ModuleCat.ofHom (columnMap k e f.hom)
+  map_id N := by apply ModuleCat.hom_ext; exact map_id
+  map_comp f g := by
+    apply ModuleCat.hom_ext
+    simpa [columnMap] using (map_comp (k := k) (LinearMap.id) (LinearMap.id) f.hom g.hom)
+instance columnFunctor_additive (e : B) : (columnFunctor k B e).Additive where
+  map_add := by intros; apply ModuleCat.hom_ext; exact map_add_right _ _ _
+
+instance columnFunctor_linear (e : B) : (columnFunctor k B e).Linear k where
+  map_smul f r := by
+    apply ModuleCat.hom_ext
+    apply LinearMap.ext
+    intro x
+    change ExternalTensor.map (k := k) LinearMap.id (r • f.hom) x =
+      (algebraMap k (Enveloping k B) r) • (columnMap k e f.hom x)
+    rw [map_smul_right]
+    exact (IsScalarTower.algebraMap_smul (Enveloping k B) r _).symm
+
+abbrev columnComplex (e : B) : RightComplex B ⥤ BiComplex k B :=
+  (columnFunctor k B e).mapHomologicalComplex (ComplexShape.up ℤ)
+
+/-- Right multiplication on the left tensor factor, natural in the right module. -/
+def pathNat (ei ej a : B) (ha : a * ei = a) :
+    columnFunctor k B ej ⟶ columnFunctor k B ei where
+  app N := ModuleCat.ofHom (columnPath k ei ej a ha)
+  naturality {N N'} f := by
+    apply ModuleCat.hom_ext
+    ext x
+    induction x using TensorProduct.inductionOn with
+    | tmul c n => rfl
+    | add x y hx hy =>
+      exact (map_add _ _ _).trans ((congrArg₂ (· + ·) hx hy).trans (map_add _ _ _).symm)
+
+abbrev path (ei ej a : B) (ha : a * ei = a) (D : RightComplex B) :
+    (columnComplex k B ej).obj D ⟶ (columnComplex k B ei).obj D :=
+  ((pathNat k B ei ej a ha).mapHomologicalComplex (ComplexShape.up ℤ)).app D
+
+@[reassoc] theorem path_naturality (ei ej a : B) (ha : a * ei = a)
+    {D E : RightComplex B} (f : D ⟶ E) :
+    (columnComplex k B ej).map f ≫ path k B ei ej a ha E =
+      path k B ei ej a ha D ≫ (columnComplex k B ei).map f :=
+  ((pathNat k B ei ej a ha).mapHomologicalComplex (ComplexShape.up ℤ)).naturality f
+
+@[simp] theorem sum_f {C D : BiComplex k B} {I : Type} (s : Finset I)
+    (f : I → (C ⟶ D)) (n : ℤ) : (∑ i ∈ s, f i).f n = ∑ i ∈ s, (f i).f n :=
+  map_sum (Hom.fAddMonoidHom n) f s
+
+@[simp] theorem sum_hom {S : Type*} [Ring S] {X Y : ModuleCat S}
+    {I : Type} (s : Finset I) (f : I → (X ⟶ Y)) :
+    (∑ i ∈ s, f i).hom = ∑ i ∈ s, (f i).hom :=
+  map_sum ModuleCat.homAddEquiv f s
+
+private theorem sum_smul_component_apply {R : Type u} [Ring R] [Algebra k R]
+    {K L : CochainComplex (ModuleCat.{u} R) ℤ} {I J : Type} [Fintype I] [Fintype J]
+    (r : I → J → k) (f : I → J → (K ⟶ L)) (n : ℤ) (x : K.X n) :
+    ((∑ i, ∑ j, r i j • f i j).f n).hom x =
+      ∑ i, ∑ j, algebraMap k R (r i j) • ((f i j).f n).hom x := by
+  have eval_sum {I : Type} (s : Finset I) (g : I → (K ⟶ L)) :
+      (∑ i ∈ s, g i).f n = ∑ i ∈ s, (g i).f n :=
+    map_sum (Hom.fAddMonoidHom n) g s
+  simp only [eval_sum, smul_f_apply, ModuleCat.hom_sum,
+    ModuleCat.hom_smul, LinearMap.sum_apply, LinearMap.smul_apply]
+  rfl
+
+/-- The vertex-zero component vanishes by the actual quadratic relation in B. -/
+theorem paths_relation {A J : Type} [Fintype A] [Fintype J]
+    (e₀ e₁ e₂ : B) (a : A → B) (b : J → B)
+    (ha : ∀ i, a i * e₀ = a i) (hb : ∀ j, b j * e₁ = b j)
+    (r : A → J → k) (hr : ∑ i, ∑ j, r i j • (b j * a i) = 0)
+    (D : RightComplex B) :
+    ∑ i, ∑ j, r i j • (path k B e₁ e₂ (b j) (hb j) D ≫
+      path k B e₀ e₁ (a i) (ha i) D) = 0 := by
+  apply Hom.ext
+  funext n
+  apply ModuleCat.hom_ext
+  apply LinearMap.ext
+  intro x
+  induction x using TensorProduct.inductionOn with
+  | add x y hx hy =>
+    exact (map_add _ _ _).trans ((congrArg₂ (· + ·) hx hy).trans (map_add _ _ _).symm)
+  | tmul c v =>
+    erw [sum_smul_component_apply]
+    change (∑ i, ∑ j, (algebraMap k (Enveloping k B) (r i j)) •
+      ((pathMap e₀ e₁ (a i) (ha i) (pathMap e₁ e₂ (b j) (hb j) c)) ⊗ₜ[k] v)) = 0
+    simp only [IsScalarTower.algebraMap_smul, TensorProduct.smul_tmul',
+      ← TensorProduct.sum_tmul]
+    have hz : (∑ i, ∑ j, r i j •
+        pathMap e₀ e₁ (a i) (ha i) (pathMap e₁ e₂ (b j) (hb j) c)) = 0 := by
+      apply Subtype.ext
+      change ((leftIdeal B e₀).subtype.restrictScalars k)
+        (∑ i, ∑ j, r i j • pathMap e₀ e₁ (a i) (ha i)
+          (pathMap e₁ e₂ (b j) (hb j) c)) = 0
+      simp only [map_sum, map_smul, LinearMap.restrictScalars_apply,
+        Submodule.subtype_apply, pathMap_apply]
+      calc
+        _ = (c : B) * (∑ i, ∑ j, r i j • (b j * a i)) := by
+          simp only [Finset.mul_sum, Algebra.mul_smul_comm, mul_assoc]
+        _ = 0 := by rw [hr, mul_zero]
+    rw [hz, TensorProduct.zero_tmul]
+end ExternalTensor.Section4
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Rectification/ColumnFinite.lean b/lean/OAI/Algebra/Finitistic/Rectification/ColumnFinite.lean
new file mode 100644
index 0000000000000000000000000000000000000000..79cd5c8bb94831bf3b71cc0f356e02b1615ff38e
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Rectification/ColumnFinite.lean
@@ -0,0 +1,109 @@
+import OAI.Algebra.Finitistic.Rectification.ColumnProperties
+import Mathlib.Algebra.Category.ModuleCat.Biproducts
+
+namespace OAI
+open CategoryTheory CategoryTheory.Limits HomologicalComplex
+open scoped TensorProduct ModuleCat.Algebra
+noncomputable section
+namespace ExternalTensor.Section4
+universe u
+variable (k B : Type u) [Field k] [Ring B] [Algebra k B]
+attribute [local instance] ExternalTensor.bimodule ExternalTensor.rightModule
+
+def forgetK : ModuleCat.{u} (Enveloping k B) ⥤ ModuleCat.{u} k :=
+  ModuleCat.restrictScalars (algebraMap k (Enveloping k B))
+instance forgetK_additive : (forgetK k B).Additive := by
+  dsimp [forgetK]
+  infer_instance
+
+def columnKIso (e : B) (N : ModuleCat.{u} Bᵐᵒᵖ) :
+    (forgetK k B).obj ((columnFunctor k B e).obj N) ≅
+      ModuleCat.of k (Column k B N e) :=
+  (show ((forgetK k B).obj ((columnFunctor k B e).obj N)) ≃ₗ[k]
+      (ModuleCat.of k (Column k B N e)) from
+    { toFun := id
+      invFun := id
+      left_inv := fun _ => rfl
+      right_inv := fun _ => rfl
+      map_add' := fun _ _ => rfl
+      map_smul' := fun c x => by
+        change (algebraMap k (Enveloping k B) c) •
+          (show Column k B N e from x) = c • (show Column k B N e from x)
+        exact IsScalarTower.algebraMap_smul (Enveloping k B) c (show Column k B N e from x) }).toModuleIso
+
+theorem finite_of_iso {X Y : ModuleCat.{u} k} (e : X ≅ Y)
+    (hY : FiniteDimensional k Y) : FiniteDimensional k X := by
+  let := hY
+  exact FiniteDimensional.of_injective e.hom.hom e.toLinearEquiv.injective
+
+theorem column_finite [FiniteDimensional k B] (e : B)
+    (N : ModuleCat.{u} Bᵐᵒᵖ) [Module.Finite Bᵐᵒᵖ N] :
+    FiniteDimensional k ((forgetK k B).obj ((columnFunctor k B e).obj N)) :=
+  finite_of_iso k (columnKIso k B e N) (column_finiteDimensional k B N e)
+
+abbrev termK (n : ℤ) : BiComplex k B ⥤ ModuleCat.{u} k :=
+  eval _ _ n ⋙ forgetK k B
+
+theorem sum_finite {I : Type} [Fintype I] (K : I → BiComplex k B)
+    (n : ℤ) (hK : ∀ i, FiniteDimensional k ((termK k B n).obj (K i))) :
+    FiniteDimensional k ((termK k B n).obj (⨁ K)) := by
+  let (i : I) : FiniteDimensional k ((termK k B n).obj (K i)) := hK i
+  apply finite_of_iso k ((termK k B n).mapBiproduct K ≪≫ ModuleCat.biproductIsoPi _)
+  change Module.Finite k (∀ i, ((termK k B n).obj (K i)))
+  infer_instance
+
+theorem biprod_finite {X Y : ModuleCat.{u} k}
+    (hX : FiniteDimensional k X) (hY : FiniteDimensional k Y) :
+    FiniteDimensional k (X ⊞ Y : ModuleCat.{u} k) := by
+  let := hX
+  let := hY
+  apply finite_of_iso k (ModuleCat.biprodIsoProd X Y)
+  change Module.Finite k (X × Y)
+  infer_instance
+
+theorem biprod_term_finite (K L : BiComplex k B) (n : ℤ)
+    (hK : FiniteDimensional k ((termK k B n).obj K))
+    (hL : FiniteDimensional k ((termK k B n).obj L)) :
+    FiniteDimensional k ((termK k B n).obj (K ⊞ L)) := by
+  let := preservesBinaryBiproducts_of_preservesBiproducts (termK k B n)
+  exact finite_of_iso k ((termK k B n).mapBiprod K L) (biprod_finite k hK hL)
+
+variable {k B}
+variable {A J R : Type} [Fintype A] [Fintype J] [Fintype R]
+variable (s : Quadratic k B (A := A) (J := J) (R := R))
+variable (D₀ D₁ D₂ : RightComplex B)
+variable (f : A → (D₀ ⟶ D₁)) (g : J → (D₁ ⟶ D₂))
+
+/-- Finite-dimensionality of the actual three induced columns, from exactly
+finite-dimensional B and finite generation of the right-module input terms. -/
+theorem columns_finite [FiniteDimensional k B]
+    (h₀ : ∀ n, Module.Finite Bᵐᵒᵖ (D₀.X n))
+    (h₁ : ∀ n, Module.Finite Bᵐᵒᵖ (D₁.X n))
+    (h₂ : ∀ n, Module.Finite Bᵐᵒᵖ (D₂.X n)) (n : ℤ) :
+    FiniteDimensional k ((forgetK k B).obj ((L0Prime s D₀ D₁ D₂ f g).X n)) ∧
+    FiniteDimensional k ((forgetK k B).obj ((L1Prime s D₀ D₁ D₂ f g).X n)) ∧
+    FiniteDimensional k ((forgetK k B).obj ((L2Prime s D₀ D₁ D₂ f g).X n)) := by
+  let := h₀ n
+  let := h₁ n
+  let := h₂ n
+  refine ⟨?_, ?_, ?_⟩
+  · apply biprod_term_finite
+    · exact column_finite k B s.e₀ (D₀.X n)
+    · apply biprod_term_finite
+      · exact column_finite k B s.e₁ (D₁.X n)
+      · exact column_finite k B s.e₂ (D₂.X n)
+  · apply biprod_term_finite
+    · apply sum_finite
+      intro a
+      exact column_finite k B s.e₁ (D₀.X n)
+    · apply sum_finite
+      intro b
+      exact column_finite k B s.e₂ (D₁.X n)
+  · apply sum_finite
+    intro r
+    exact column_finite k B s.e₂ (D₀.X n)
+end ExternalTensor.Section4
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Rectification/ColumnProperties.lean b/lean/OAI/Algebra/Finitistic/Rectification/ColumnProperties.lean
new file mode 100644
index 0000000000000000000000000000000000000000..44a9c167a1825ea07609830bf18fbe3736e5022e
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Rectification/ColumnProperties.lean
@@ -0,0 +1,171 @@
+import OAI.Algebra.Finitistic.Rectification.InducedDiagram
+import Mathlib.Algebra.Category.ModuleCat.Projective
+import Mathlib.Algebra.Category.ModuleCat.ChangeOfRings
+import Mathlib.Algebra.Homology.HomologicalComplexBiprod
+
+namespace OAI
+open CategoryTheory CategoryTheory.Limits HomologicalComplex
+open scoped TensorProduct ModuleCat.Algebra
+noncomputable section
+namespace ExternalTensor.Section4
+universe u
+variable (k B : Type u) [Field k] [Ring B] [Algebra k B]
+attribute [local instance] ExternalTensor.bimodule ExternalTensor.rightModule
+
+/-- Restrict genuine bimodules to right B-modules. -/
+def forgetRight : ModuleCat.{u} (Enveloping k B) ⥤ ModuleCat.{u} Bᵐᵒᵖ :=
+  ModuleCat.restrictScalars (Algebra.TensorProduct.includeRight :
+    Bᵐᵒᵖ →ₐ[k] Enveloping k B).toRingHom
+
+instance forgetRight_additive : (forgetRight k B).Additive := by
+  dsimp [forgetRight]
+  infer_instance
+
+/-- The restricted action is the right action already verified for the actual tensor. -/
+def columnRightIso (e : B) (N : ModuleCat.{u} Bᵐᵒᵖ) :
+    (forgetRight k B).obj ((columnFunctor k B e).obj N) ≅
+      ModuleCat.of Bᵐᵒᵖ (Column k B N e) :=
+  (show ((forgetRight k B).obj ((columnFunctor k B e).obj N)) ≃ₗ[Bᵐᵒᵖ]
+      (ModuleCat.of Bᵐᵒᵖ (Column k B N e)) from
+    { toFun := id
+      invFun := id
+      left_inv := fun _ => rfl
+      right_inv := fun _ => rfl
+      map_add' := fun _ _ => rfl
+      map_smul' := fun c x => by
+        change ((1 ⊗ₜ[k] c : Enveloping k B) • (show Column k B N e from x)) =
+          c • (show Column k B N e from x)
+        exact (right_eq_enveloping k B (leftIdeal B e) N c x).symm }).toModuleIso
+
+theorem column_right_projective (e : B) (N : ModuleCat.{u} Bᵐᵒᵖ)
+    [Module.Projective Bᵐᵒᵖ N] :
+    Projective ((forgetRight k B).obj ((columnFunctor k B e).obj N)) := by
+  let := column_projective k B N e
+  exact Projective.of_iso (columnRightIso k B e N).symm (by infer_instance)
+
+/-- Exact boundedness transfer for each induced column. -/
+theorem column_isZero (e : B) (D : RightComplex B) (i : ℤ)
+    (hi : IsZero (D.X i)) : IsZero (((columnComplex k B e).obj D).X i) :=
+  (columnFunctor k B e).map_isZero hi
+
+instance rightFiniteBiproducts : HasFiniteBiproducts (ModuleCat.{u} Bᵐᵒᵖ) :=
+  HasFiniteBiproducts.of_hasFiniteProducts
+instance rightBinaryBiproducts : HasBinaryBiproducts (ModuleCat.{u} Bᵐᵒᵖ) :=
+  HasBinaryBiproducts.of_hasBinaryProducts
+
+abbrev termRight (n : ℤ) : BiComplex k B ⥤ ModuleCat.{u} Bᵐᵒᵖ :=
+  eval _ _ n ⋙ forgetRight k B
+
+theorem sum_right_projective {I : Type} [Fintype I] (K : I → BiComplex k B)
+    (n : ℤ) (hK : ∀ i, Projective ((termRight k B n).obj (K i))) :
+    Projective ((termRight k B n).obj (⨁ K)) := by
+  let (i : I) : Projective ((termRight k B n).obj (K i)) := hK i
+  apply Projective.of_iso ((termRight k B n).mapBiproduct K).symm
+  refine ⟨fun f e _ => ⟨biproduct.desc (fun i => by
+    letI : Projective (((termRight k B n).obj ∘ K) i) := hK i
+    exact Projective.factorThru (biproduct.ι ((termRight k B n).obj ∘ K) i ≫ f) e), ?_⟩⟩
+  apply biproduct.hom_ext'
+  intro i
+  let : Projective (((termRight k B n).obj ∘ K) i) := hK i
+  simp only [biproduct.ι_desc_assoc, Projective.factorThru_comp]
+
+theorem biprod_right_projective (K L : BiComplex k B) (n : ℤ)
+    (hK : Projective ((termRight k B n).obj K))
+    (hL : Projective ((termRight k B n).obj L)) :
+    Projective ((termRight k B n).obj (K ⊞ L)) := by
+  let := hK
+  let := hL
+  let := preservesBinaryBiproducts_of_preservesBiproducts (termRight k B n)
+  exact Projective.of_iso ((termRight k B n).mapBiprod K L).symm (by infer_instance)
+
+theorem sum_isZero {C : Type*} [Category C] [HasZeroMorphisms C]
+    {I : Type} (K : I → C) [HasBiproduct K] (hK : ∀ i, IsZero (K i)) :
+    IsZero (⨁ K) := by
+  apply (IsZero.iff_id_eq_zero _).2
+  apply biproduct.hom_ext
+  intro i
+  simp only [Category.id_comp, zero_comp]
+  exact (hK i).eq_zero_of_tgt _
+
+theorem sum_term_isZero {I : Type} [Fintype I] (K : I → BiComplex k B)
+    (n : ℤ) (hK : ∀ i, IsZero ((K i).X n)) : IsZero ((⨁ K).X n) := by
+  apply ((eval _ _ n).mapBiproduct K).isZero_iff.mpr
+  exact sum_isZero _ hK
+
+theorem biprod_term_isZero (K L : BiComplex k B) (n : ℤ)
+    (hK : IsZero (K.X n)) (hL : IsZero (L.X n)) : IsZero ((K ⊞ L).X n) := by
+  let := preservesBinaryBiproducts_of_preservesBiproducts (eval (ModuleCat (Enveloping k B)) (ComplexShape.up ℤ) n)
+  apply ((eval _ _ n).mapBiprod K L).isZero_iff.mpr
+  exact (biprod_isZero_iff _ _).mpr ⟨hK, hL⟩
+
+variable {k B}
+variable {A J R : Type} [Fintype A] [Fintype J] [Fintype R]
+variable (s : Quadratic k B (A := A) (J := J) (R := R))
+variable (D₀ D₁ D₂ : RightComplex B)
+variable (f : A → (D₀ ⟶ D₁)) (g : J → (D₁ ⟶ D₂))
+
+/-- Exactly the three right-projectivity inputs to RectificationTotal.total_projective_after. -/
+theorem columns_right_projective
+    (h₀ : ∀ n, Module.Projective Bᵐᵒᵖ (D₀.X n))
+    (h₁ : ∀ n, Module.Projective Bᵐᵒᵖ (D₁.X n))
+    (h₂ : ∀ n, Module.Projective Bᵐᵒᵖ (D₂.X n)) (n : ℤ) :
+    Projective ((forgetRight k B).obj ((L0Prime s D₀ D₁ D₂ f g).X n)) ∧
+    Projective ((forgetRight k B).obj ((L1Prime s D₀ D₁ D₂ f g).X n)) ∧
+    Projective ((forgetRight k B).obj ((L2Prime s D₀ D₁ D₂ f g).X n)) := by
+  let := h₀ n
+  let := h₁ n
+  let := h₂ n
+  refine ⟨?_, ?_, ?_⟩
+  · apply biprod_right_projective
+    · exact column_right_projective k B s.e₀ (D₀.X n)
+    · apply biprod_right_projective
+      · exact column_right_projective k B s.e₁ (D₁.X n)
+      · exact column_right_projective k B s.e₂ (D₂.X n)
+  · apply biprod_right_projective
+    · apply sum_right_projective
+      intro a
+      exact column_right_projective k B s.e₁ (D₀.X n)
+    · apply sum_right_projective
+      intro b
+      exact column_right_projective k B s.e₂ (D₁.X n)
+  · apply sum_right_projective
+    intro r
+    exact column_right_projective k B s.e₂ (D₀.X n)
+
+theorem columns_isZero (n : ℤ) (h₀ : IsZero (D₀.X n))
+    (h₁ : IsZero (D₁.X n)) (h₂ : IsZero (D₂.X n)) :
+    IsZero ((L0Prime s D₀ D₁ D₂ f g).X n) ∧
+    IsZero ((L1Prime s D₀ D₁ D₂ f g).X n) ∧
+    IsZero ((L2Prime s D₀ D₁ D₂ f g).X n) := by
+  refine ⟨?_, ?_, ?_⟩
+  · apply biprod_term_isZero
+    · exact column_isZero k B s.e₀ D₀ n h₀
+    · apply biprod_term_isZero
+      · exact column_isZero k B s.e₁ D₁ n h₁
+      · exact column_isZero k B s.e₂ D₂ n h₂
+  · apply biprod_term_isZero
+    · apply sum_term_isZero
+      intro a
+      exact column_isZero k B s.e₁ D₀ n h₀
+    · apply sum_term_isZero
+      intro b
+      exact column_isZero k B s.e₂ D₁ n h₁
+  · apply sum_term_isZero
+    intro r
+    exact column_isZero k B s.e₂ D₀ n h₀
+
+/-- Uniform bounds on the input complexes give the same bounds on all three columns. -/
+theorem columns_bounded (lo hi : ℤ)
+    (h₀ : ∀ n, n < lo ∨ hi < n → IsZero (D₀.X n))
+    (h₁ : ∀ n, n < lo ∨ hi < n → IsZero (D₁.X n))
+    (h₂ : ∀ n, n < lo ∨ hi < n → IsZero (D₂.X n)) :
+    ∀ n, n < lo ∨ hi < n →
+      IsZero ((L0Prime s D₀ D₁ D₂ f g).X n) ∧
+      IsZero ((L1Prime s D₀ D₁ D₂ f g).X n) ∧
+      IsZero ((L2Prime s D₀ D₁ D₂ f g).X n) :=
+  fun n hn => columns_isZero s D₀ D₁ D₂ f g n (h₀ n hn) (h₁ n hn) (h₂ n hn)
+end ExternalTensor.Section4
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Rectification/ConcreteAdjacentGraded.lean b/lean/OAI/Algebra/Finitistic/Rectification/ConcreteAdjacentGraded.lean
new file mode 100644
index 0000000000000000000000000000000000000000..a6ada6c1f258483e2027fbbb477f32169b463b01
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Rectification/ConcreteAdjacentGraded.lean
@@ -0,0 +1,64 @@
+import OAI.Algebra.Finitistic.Rectification.AdjacentArrowSum
+import OAI.Algebra.Finitistic.Rectification.RectificationAcyclic
+
+namespace OAI
+noncomputable section
+open CategoryTheory CategoryTheory.Limits
+namespace LittleFinitistic.ConcreteAdjacentGraded
+open ExternalTensor.Section4 QuadraticEncoding
+universe u
+variable {k : Type u} [Field k] {d t : ℕ} (P : Relations k d t)
+variable (D : RightComplex (QuadraticEncoding.B P))
+local notation "T" => QuadraticEncoding.B P
+local notation "s" => ConcreteQuadraticDiagram.quadratic P
+
+def arrow01Sum : (⨁ fun _ : Fin (d+1) => (columnComplex k T (s).e₁).obj D) ⟶
+    (columnComplex k T (s).e₀).obj D :=
+  biproduct.desc (fun a => path k T (s).e₀ (s).e₁ (arrow01 P a) ((s).ha a) D)
+
+def arrow12Sum : (⨁ fun _ : Fin (d+1) => (columnComplex k T (s).e₂).obj D) ⟶
+    (columnComplex k T (s).e₁).obj D :=
+  biproduct.desc (fun b => path k T (s).e₁ (s).e₂ (arrow12 P b) ((s).hb b) D)
+
+theorem vertex1_arrow01_isIso :
+    IsIso ((AdjacentArrowSum.vertexComplex (composition P) 1).map (arrow01Sum P D)) := by
+  let F := AdjacentArrowSum.vertexComplex (composition P) 1
+  have hdesc := AdjacentArrowSum.desc_isIso (composition P) D 1 0 d
+    (CornerSpaces.corner10Equiv (composition P)) (arrow01 P) ((s).ha)
+    (CornerArrowCoordinates.arrow01_coordinate P)
+  let : IsIso (biproduct.desc (fun a => F.map
+    (path k T (s).e₀ (s).e₁ (arrow01 P a) ((s).ha a) D))) := hdesc
+  change IsIso (F.map (biproduct.desc _))
+  rw [← biproduct.mapBiproduct_hom_desc,isIso_comp_left_iff]
+  exact hdesc
+
+theorem vertex2_arrow12_isIso :
+    IsIso ((AdjacentArrowSum.vertexComplex (composition P) 2).map (arrow12Sum P D)) := by
+  let F := AdjacentArrowSum.vertexComplex (composition P) 2
+  have hdesc := AdjacentArrowSum.desc_isIso (composition P) D 2 1 d
+    (CornerSpaces.corner21Equiv (composition P)) (arrow12 P) ((s).hb)
+    (CornerArrowCoordinates.arrow12_coordinate P)
+  let : IsIso (biproduct.desc (fun b => F.map
+    (path k T (s).e₁ (s).e₂ (arrow12 P b) ((s).hb b) D))) := hdesc
+  change IsIso (F.map (biproduct.desc _))
+  rw [← biproduct.mapBiproduct_hom_desc,isIso_comp_left_iff]
+  exact hdesc
+
+/-- The first adjacent graded cone is acyclic for the actual arrow map. -/
+theorem vertex1_cone_acyclic :
+    (CochainComplex.mappingCone
+      ((AdjacentArrowSum.vertexComplex (composition P) 1).map (arrow01Sum P D))).Acyclic := by
+  let := vertex1_arrow01_isIso P D
+  exact RectificationAcyclic.cone_acyclic _
+
+/-- The second adjacent graded cone is acyclic for the actual arrow map. -/
+theorem vertex2_cone_acyclic :
+    (CochainComplex.mappingCone
+      ((AdjacentArrowSum.vertexComplex (composition P) 2).map (arrow12Sum P D))).Acyclic := by
+  let := vertex2_arrow12_isIso P D
+  exact RectificationAcyclic.cone_acyclic _
+end LittleFinitistic.ConcreteAdjacentGraded
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Rectification/CornerArrowCoordinates.lean b/lean/OAI/Algebra/Finitistic/Rectification/CornerArrowCoordinates.lean
new file mode 100644
index 0000000000000000000000000000000000000000..8b54ef419f9a84cbca6fc3823ff2be04006ae29a
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Rectification/CornerArrowCoordinates.lean
@@ -0,0 +1,45 @@
+import OAI.Algebra.Finitistic.Rectification.CornerColumnPaths
+import OAI.Algebra.Finitistic.Localization.ConcreteQuadraticDiagram
+
+namespace OAI
+noncomputable section
+open scoped TensorProduct
+namespace LittleFinitistic.CornerArrowCoordinates
+open QuadraticEncoding CornerColumnPaths
+universe u
+variable {k : Type u} [Field k] {d t : ℕ} (P : Relations k d t)
+
+/-- On the adjacent 1,0 corner, the original a-arrow inserts its actual basis vector. -/
+theorem arrow01_coordinate (a : Fin (d+1)) (c : k) :
+    CornerSpaces.corner10Equiv (composition P)
+      (cornerMap (composition P) 1 0 1 (arrow01 P a)
+        ((ConcreteQuadraticDiagram.quadratic P).ha a)
+        ((CornerSpaces.diagonalEquiv (composition P) 1).symm c)) = c • basis a := by
+  simp [CornerSpaces.corner10Equiv,cornerMap,CornerSpaces.diagonalEquiv,
+    arrow01,ThreeVertexAlgebra.mul,ThreeVertexAlgebra.vertex]
+
+/-- On the adjacent 2,1 corner, the original b-arrow inserts its actual basis vector. -/
+theorem arrow12_coordinate (b : Fin (d+1)) (c : k) :
+    CornerSpaces.corner21Equiv (composition P)
+      (cornerMap (composition P) 2 1 2 (arrow12 P b)
+        ((ConcreteQuadraticDiagram.quadratic P).hb b)
+        ((CornerSpaces.diagonalEquiv (composition P) 2).symm c)) = c • basis b := by
+  simp [CornerSpaces.corner21Equiv,cornerMap,CornerSpaces.diagonalEquiv,
+    arrow12,ThreeVertexAlgebra.mul,ThreeVertexAlgebra.vertex]
+
+/-- Length-two multiplication is exactly the quotient of the original tensor path. -/
+theorem lengthTwo_coordinate (a : Fin (d+1)) (w : Arrows k d) :
+    CornerSpaces.corner20Equiv (composition P)
+      (cornerMap (composition P) 2 0 1 (arrow01 P a)
+        ((ConcreteQuadraticDiagram.quadratic P).ha a)
+        ((CornerSpaces.corner21Equiv (composition P)).symm w)) =
+      (relationSpace P).mkQ (w ⊗ₜ[k] basis a) := by
+  change (0 : k) • (0 : Paths k d ⧸ relationSpace P) +
+    (relationSpace P).mkQ (w ⊗ₜ[k] basis a) + (0 : k) • 0 = _
+  simp only [zero_smul, zero_add, add_zero]
+
+end LittleFinitistic.CornerArrowCoordinates
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Rectification/CornerColumnComplex.lean b/lean/OAI/Algebra/Finitistic/Rectification/CornerColumnComplex.lean
new file mode 100644
index 0000000000000000000000000000000000000000..f229d50c49ca274be639fd8bedbcb9e7320a3756
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Rectification/CornerColumnComplex.lean
@@ -0,0 +1,50 @@
+import OAI.Algebra.Finitistic.Rectification.VertexColumnComplex
+import OAI.Algebra.Finitistic.Rectification.TensorComplex
+
+namespace OAI
+noncomputable section
+open CategoryTheory CategoryTheory.Limits
+open scoped TensorProduct ModuleCat.Algebra
+namespace LittleFinitistic.CornerColumnComplex
+universe u
+variable {k V W U : Type u} [Field k] [AddCommGroup V] [Module k V]
+  [AddCommGroup W] [Module k W] [AddCommGroup U] [Module k U]
+variable (μ : W →ₗ[k] V →ₗ[k] U)
+local notation "T" => ThreeVertexAlgebra μ
+attribute [local instance] ExternalTensor.rightModule ExternalTensor.bimodule
+
+/-- Embed an actual corner into the principal left ideal of its source vertex. -/
+def cornerToIdeal (i j : Fin 3) : CornerSpaces.corner μ i j →ₗ[k]
+    ExternalTensor.leftIdeal T (ThreeVertexAlgebra.vertex μ j) where
+  toFun x := ⟨x.val,⟨x.val,CornerProjection.corner_right_fixed μ i j x⟩⟩
+  map_add' _ _ := rfl
+  map_smul' _ _ := rfl
+
+/-- The corner equivalence retains the actual tensor insertion on pure tensors. -/
+theorem corner_symm_tmul_val (N : ModuleCat.{u} (ThreeVertexAlgebra μ)ᵐᵒᵖ)
+    (i j : Fin 3) (x : CornerSpaces.corner μ i j) (n : N) :
+    ((VertexColumnModels.cornerEquiv μ N i j).symm (x ⊗ₜ[k] n)).val =
+      cornerToIdeal μ i j x ⊗ₜ[k] n := by
+  rfl
+
+/-- Every actual vertex column is its concrete corner-tensor complex. -/
+def complexIso (i j : Fin 3)
+    (D : CochainComplex (ModuleCat.{u} (ThreeVertexAlgebra μ)ᵐᵒᵖ) ℤ) :
+    TensorComplex.complex D (ModuleCat.of k (CornerSpaces.corner μ i j)) ≅
+      ((VertexColumnComplex.vertexColumn μ i j).mapHomologicalComplex (.up ℤ)).obj D :=
+  HomologicalComplex.Hom.isoOfComponents
+    (fun n => (VertexColumnModels.cornerEquiv μ (D.X n) i j).symm.toModuleIso) (by
+      intro n m hnm
+      apply ModuleCat.hom_ext
+      apply LinearMap.ext
+      intro x
+      induction x using TensorProduct.inductionOn with
+      | tmul c v => rfl
+      | add x y hx hy =>
+        exact (map_add _ _ _).trans
+          ((congrArg₂ (· + ·) hx hy).trans (map_add _ _ _).symm))
+end LittleFinitistic.CornerColumnComplex
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Rectification/CornerColumnPaths.lean b/lean/OAI/Algebra/Finitistic/Rectification/CornerColumnPaths.lean
new file mode 100644
index 0000000000000000000000000000000000000000..acd44d4a0a1c69724e904846fb3f32198dde669f
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Rectification/CornerColumnPaths.lean
@@ -0,0 +1,53 @@
+import OAI.Algebra.Finitistic.Rectification.CornerColumnComplex
+
+namespace OAI
+noncomputable section
+open CategoryTheory CategoryTheory.Limits
+open scoped TensorProduct ModuleCat.Algebra
+namespace LittleFinitistic.CornerColumnPaths
+universe u
+variable {k V W U : Type u} [Field k] [AddCommGroup V] [Module k V]
+  [AddCommGroup W] [Module k W] [AddCommGroup U] [Module k U]
+variable (μ : W →ₗ[k] V →ₗ[k] U)
+local notation "T" => ThreeVertexAlgebra μ
+attribute [local instance] ExternalTensor.rightModule ExternalTensor.bimodule
+
+/-- Right multiplication by the original path on the actual vertex corner. -/
+def cornerMap (v i j : Fin 3) (a : ThreeVertexAlgebra μ)
+    (ha : a * ThreeVertexAlgebra.vertex μ i = a) :
+    CornerSpaces.corner μ v j →ₗ[k] CornerSpaces.corner μ v i where
+  toFun x := ⟨x.val*a,by
+    change ThreeVertexAlgebra.vertex μ v * (x.val*a) * ThreeVertexAlgebra.vertex μ i = x.val*a
+    calc
+      _ = (ThreeVertexAlgebra.vertex μ v * x.val) *
+        (a * ThreeVertexAlgebra.vertex μ i) := by simp only [mul_assoc]
+      _ = x.val*a := by rw [CornerProjection.corner_left_fixed,ha]⟩
+  map_add' x y := Subtype.ext (add_mul _ _ _)
+  map_smul' c x := Subtype.ext (smul_mul_assoc _ _ _)
+
+/-- The corner-tensor identification carries the actual induced path map to right multiplication. -/
+theorem path_naturality (v i j : Fin 3) (a : ThreeVertexAlgebra μ)
+    (ha : a * ThreeVertexAlgebra.vertex μ i = a)
+    (D : CochainComplex (ModuleCat.{u} (ThreeVertexAlgebra μ)ᵐᵒᵖ) ℤ) :
+    TensorComplex.complexMap D (ModuleCat.ofHom (cornerMap μ v i j a ha)) ≫
+        (CornerColumnComplex.complexIso μ v i D).hom =
+      (CornerColumnComplex.complexIso μ v j D).hom ≫
+        ((BimoduleVertex.functor k T (ThreeVertexAlgebra.vertex μ v)).mapHomologicalComplex (.up ℤ)).map
+          (ExternalTensor.Section4.path k T (ThreeVertexAlgebra.vertex μ i)
+            (ThreeVertexAlgebra.vertex μ j) a ha D) := by
+  apply HomologicalComplex.Hom.ext
+  funext n
+  apply ModuleCat.hom_ext
+  apply LinearMap.ext
+  intro x
+  induction x using TensorProduct.inductionOn with
+  | tmul c z => rfl
+  | add x y hx hy =>
+    exact (map_add _ _ _).trans
+      ((congrArg₂ (· + ·) hx hy).trans (map_add _ _ _).symm)
+
+end LittleFinitistic.CornerColumnPaths
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Rectification/CornerPathTransport.lean b/lean/OAI/Algebra/Finitistic/Rectification/CornerPathTransport.lean
new file mode 100644
index 0000000000000000000000000000000000000000..f9893eddf8512b344c184ef2d5b53db4806ee1f4
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Rectification/CornerPathTransport.lean
@@ -0,0 +1,65 @@
+import OAI.Algebra.Finitistic.Rectification.AdjacentArrowSum
+import OAI.Algebra.Finitistic.Encoding.RelationMatrixSequence
+
+namespace OAI
+noncomputable section
+open CategoryTheory CategoryTheory.Limits
+namespace LittleFinitistic.CornerPathTransport
+universe u
+variable {k V W U : Type u} [Field k] [AddCommGroup V] [Module k V]
+  [AddCommGroup W] [Module k W] [AddCommGroup U] [Module k U]
+variable (μ : W →ₗ[k] V →ₗ[k] U)
+variable (D : CochainComplex (ModuleCat.{u} (ThreeVertexAlgebra μ)ᵐᵒᵖ) ℤ)
+local notation "T" => ThreeVertexAlgebra μ
+
+def coordinateIso (v i : Fin 3) {M : Type u} [AddCommGroup M] [Module k M]
+    (ξ : CornerSpaces.corner μ v i ≃ₗ[k] M) :
+    (AdjacentArrowSum.vertexComplex μ v).obj ((ExternalTensor.Section4.columnComplex k T
+      (ThreeVertexAlgebra.vertex μ i)).obj D) ≅
+      (TensorComplex.tensorFunctor (k := k) D).obj (ModuleCat.of k M) :=
+  (CornerColumnComplex.complexIso μ v i D).symm ≪≫
+    (TensorComplex.tensorFunctor (k := k) D).mapIso ξ.toModuleIso
+
+/-- Coordinate transport preserves each actual path map, before taking any finite sum. -/
+theorem path_square (v i j : Fin 3) {M N : Type u}
+    [AddCommGroup M] [Module k M] [AddCommGroup N] [Module k N]
+    (ξ : CornerSpaces.corner μ v j ≃ₗ[k] M)
+    (η : CornerSpaces.corner μ v i ≃ₗ[k] N)
+    (a : T) (ha : a * ThreeVertexAlgebra.vertex μ i = a)
+    (f : M →ₗ[k] N)
+    (hc : ∀ x, η (CornerColumnPaths.cornerMap μ v i j a ha x) = f (ξ x)) :
+    (coordinateIso μ D v j ξ).hom ≫ (TensorComplex.tensorFunctor (k := k) D).map
+      (ModuleCat.ofHom f) =
+    (AdjacentArrowSum.vertexComplex μ v).map
+      (ExternalTensor.Section4.path k T (ThreeVertexAlgebra.vertex μ i)
+        (ThreeVertexAlgebra.vertex μ j) a ha D) ≫ (coordinateIso μ D v i η).hom := by
+  let F := TensorComplex.tensorFunctor (k := k) D
+  have hm : ModuleCat.ofHom ξ.toLinearMap ≫ ModuleCat.ofHom f =
+      ModuleCat.ofHom (CornerColumnPaths.cornerMap μ v i j a ha) ≫
+        ModuleCat.ofHom η.toLinearMap := by
+    apply ModuleCat.hom_ext
+    exact LinearMap.ext (fun x => (hc x).symm)
+  have hF := congrArg F.map hm
+  simp only [Functor.map_comp] at hF
+  apply (cancel_epi (CornerColumnComplex.complexIso μ v j D).hom).1
+  calc
+    _ = F.map (ModuleCat.ofHom ξ.toLinearMap) ≫ F.map (ModuleCat.ofHom f) := by
+      change (CornerColumnComplex.complexIso μ v j D).hom ≫
+        ((CornerColumnComplex.complexIso μ v j D).inv ≫
+          F.map (ModuleCat.ofHom ξ.toLinearMap)) ≫ F.map (ModuleCat.ofHom f) = _
+      erw [Category.assoc]
+      exact (CornerColumnComplex.complexIso μ v j D).hom_inv_id_assoc _
+    _ = F.map (ModuleCat.ofHom (CornerColumnPaths.cornerMap μ v i j a ha)) ≫
+        F.map (ModuleCat.ofHom η.toLinearMap) := hF
+    _ = (F.map (ModuleCat.ofHom
+          (CornerColumnPaths.cornerMap μ v i j a ha)) ≫
+        (CornerColumnComplex.complexIso μ v i D).hom) ≫
+          (coordinateIso μ D v i η).hom := by simp [coordinateIso,F,TensorComplex.tensorFunctor]
+    _ = _ := by
+      erw [CornerColumnPaths.path_naturality]
+      exact Category.assoc _ _ _
+end LittleFinitistic.CornerPathTransport
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Rectification/CornerProjection.lean b/lean/OAI/Algebra/Finitistic/Rectification/CornerProjection.lean
new file mode 100644
index 0000000000000000000000000000000000000000..0bc665f0619d38053c02d5442b379484da0fd708
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Rectification/CornerProjection.lean
@@ -0,0 +1,82 @@
+import OAI.Algebra.Finitistic.Rectification.CornerSpaces
+import OAI.Algebra.Finitistic.Rectification.InducedColumns
+
+namespace OAI
+noncomputable section
+
+namespace LittleFinitistic.CornerProjection
+open ThreeVertexAlgebra CornerSpaces
+universe u
+variable {k V W U : Type u} [Field k]
+  [AddCommGroup V] [Module k V] [AddCommGroup W] [Module k W]
+  [AddCommGroup U] [Module k U]
+variable (μ : W →ₗ[k] V →ₗ[k] U)
+
+private theorem videm (i : Fin 3) : vertex μ i * vertex μ i = vertex μ i :=
+  (directedSystem μ).idem i
+
+theorem corner_left_fixed (i j : Fin 3) (x : corner μ i j) : vertex μ i * x.val = x.val := by
+  have hx := x.property
+  change vertex μ i * x.val * vertex μ j = x.val at hx
+  calc
+    vertex μ i * x.val = vertex μ i * (vertex μ i * x.val * vertex μ j) := congrArg (fun a : ThreeVertexAlgebra μ => vertex μ i * a) hx.symm
+    _ = vertex μ i * x.val * vertex μ j := by simp only [← mul_assoc,videm]
+    _ = x.val := hx
+
+theorem corner_right_fixed (i j : Fin 3) (x : corner μ i j) : x.val * vertex μ j = x.val := by
+  have hx := x.property
+  change vertex μ i * x.val * vertex μ j = x.val at hx
+  calc
+    x.val * vertex μ j = (vertex μ i * x.val * vertex μ j) * vertex μ j := congrArg (fun a : ThreeVertexAlgebra μ => a * vertex μ j) hx.symm
+    _ = vertex μ i * x.val * vertex μ j := by rw [mul_assoc,videm]
+    _ = x.val := hx
+
+theorem ideal_right_fixed (j : Fin 3)
+    (x : ExternalTensor.leftIdeal (ThreeVertexAlgebra μ) (vertex μ j)) :
+    x.val * vertex μ j = x.val := by
+  obtain ⟨b,hb⟩ := x.property
+  change b * vertex μ j = x.val at hb
+  rw [← hb,mul_assoc,videm]
+
+/-- Left multiplication by e_i on the actual induced-column first factor B e_j. -/
+def projection (i j : Fin 3) :
+    ExternalTensor.leftIdeal (ThreeVertexAlgebra μ) (vertex μ j) →ₗ[k]
+    ExternalTensor.leftIdeal (ThreeVertexAlgebra μ) (vertex μ j) where
+  toFun x := ⟨vertex μ i * x.val,⟨vertex μ i * x.val,by
+    change (vertex μ i * x.val) * vertex μ j = vertex μ i * x.val
+    rw [mul_assoc,ideal_right_fixed]⟩⟩
+  map_add' x y := Subtype.ext (mul_add _ _ _)
+  map_smul' c x := Subtype.ext (mul_smul_comm _ _ _)
+
+@[simp] theorem projection_apply (i j : Fin 3) (x) :
+    ((projection μ i j) x).val = vertex μ i * x.val := rfl
+
+theorem projection_idempotent (i j : Fin 3) :
+    (projection μ i j).comp (projection μ i j) = projection μ i j := by
+  apply LinearMap.ext
+  intro x
+  apply Subtype.ext
+  change vertex μ i * (vertex μ i * x.val) = vertex μ i * x.val
+  rw [← mul_assoc,videm]
+
+/-- The image of the actual column projector is the concrete two-sided path corner. -/
+def rangeEquiv (i j : Fin 3) : (projection μ i j).range ≃ₗ[k] corner μ i j where
+  toFun x := ⟨x.val.val,by
+    obtain ⟨y,hy⟩ := x.property
+    have h := congrArg Subtype.val hy
+    change vertex μ i * y.val = x.val.val at h
+    change vertex μ i * x.val.val * vertex μ j = x.val.val
+    rw [← h,← mul_assoc,videm,mul_assoc,ideal_right_fixed]⟩
+  invFun x := ⟨⟨x.val,⟨x.val,corner_right_fixed μ i j x⟩⟩,by
+    refine ⟨⟨x.val,⟨x.val,corner_right_fixed μ i j x⟩⟩,?_⟩
+    apply Subtype.ext
+    exact corner_left_fixed μ i j x⟩
+  left_inv x := by apply Subtype.ext; apply Subtype.ext; rfl
+  right_inv x := rfl
+  map_add' x y := rfl
+  map_smul' c x := rfl
+end LittleFinitistic.CornerProjection
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Rectification/CornerSpaces.lean b/lean/OAI/Algebra/Finitistic/Rectification/CornerSpaces.lean
new file mode 100644
index 0000000000000000000000000000000000000000..bb78b884b80c823784e0c35bc7a8912574c7c047
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Rectification/CornerSpaces.lean
@@ -0,0 +1,103 @@
+import Mathlib.LinearAlgebra.Prod
+import Mathlib.Tactic.FinCases
+import OAI.Algebra.Finitistic.Encoding.QuadraticEncoding
+
+namespace OAI
+
+namespace LittleFinitistic.CornerSpaces
+open ThreeVertexAlgebra
+
+universe u
+variable {k V W U : Type u} [Field k]
+  [AddCommGroup V] [Module k V] [AddCommGroup W] [Module k W]
+  [AddCommGroup U] [Module k U]
+variable (μ : W →ₗ[k] V →ₗ[k] U)
+
+/-- The actual two-sided corner e_i B e_j as a vector subspace. -/
+def corner (i j : Fin 3) : Submodule k (ThreeVertexAlgebra μ) where
+  carrier := {x | vertex μ i * x * vertex μ j = x}
+  zero_mem' := by
+    change vertex μ i * (0 : ThreeVertexAlgebra μ) * vertex μ j = 0
+    rw [mul_zero,zero_mul]
+  add_mem' := by
+    intro x y hx hy
+    change vertex μ i * x * vertex μ j = x at hx
+    change vertex μ i * y * vertex μ j = y at hy
+    change vertex μ i * (x+y) * vertex μ j = x+y
+    rw [mul_add,add_mul,hx,hy]
+  smul_mem' := by
+    intro r x hx
+    change vertex μ i * x * vertex μ j = x at hx
+    change vertex μ i * (r • x) * vertex μ j = r • x
+    rw [mul_smul_comm,smul_mul_assoc,hx]
+
+noncomputable def corner10Equiv : corner μ 1 0 ≃ₗ[k] V where
+  toFun x := x.val.2.2.2.1
+  invFun v := ⟨(0,0,0,v,0,0),by
+    change mul μ (mul μ (vertex μ 1) (0,0,0,v,0,0)) (vertex μ 0) = _
+    simp [vertex,mul]⟩
+  left_inv x := by
+    apply Subtype.ext
+    have hx := x.property
+    change mul μ (mul μ (vertex μ 1) x.val) (vertex μ 0) = x.val at hx
+    simpa [vertex,mul] using hx
+  right_inv _ := rfl
+  map_add' _ _ := rfl
+  map_smul' _ _ := rfl
+
+noncomputable def corner21Equiv : corner μ 2 1 ≃ₗ[k] W where
+  toFun x := x.val.2.2.2.2.1
+  invFun w := ⟨(0,0,0,0,w,0),by
+    change mul μ (mul μ (vertex μ 2) (0,0,0,0,w,0)) (vertex μ 1) = _
+    simp [vertex,mul]⟩
+  left_inv x := by
+    apply Subtype.ext
+    have hx := x.property
+    change mul μ (mul μ (vertex μ 2) x.val) (vertex μ 1) = x.val at hx
+    simpa [vertex,mul] using hx
+  right_inv _ := rfl
+  map_add' _ _ := rfl
+  map_smul' _ _ := rfl
+
+noncomputable def corner20Equiv : corner μ 2 0 ≃ₗ[k] U where
+  toFun x := x.val.2.2.2.2.2
+  invFun u := ⟨(0,0,0,0,0,u),by
+    change mul μ (mul μ (vertex μ 2) (0,0,0,0,0,u)) (vertex μ 0) = _
+    simp [vertex,mul]⟩
+  left_inv x := by
+    apply Subtype.ext
+    have hx := x.property
+    change mul μ (mul μ (vertex μ 2) x.val) (vertex μ 0) = x.val at hx
+    simpa [vertex,mul] using hx
+  right_inv _ := rfl
+  map_add' _ _ := rfl
+  map_smul' _ _ := rfl
+
+/-- A diagonal corner has only its scalar trivial path. -/
+noncomputable def diagonalEquiv (i : Fin 3) : corner μ i i ≃ₗ[k] k where
+  toFun x := if i = 0 then x.val.1 else if i = 1 then x.val.2.1 else x.val.2.2.1
+  invFun c := ⟨c • vertex μ i,by
+    change vertex μ i * (c • vertex μ i) * vertex μ i = c • vertex μ i
+    rw [mul_smul_comm,smul_mul_assoc]
+    have hi := (directedSystem μ).idem i
+    change vertex μ i * vertex μ i = vertex μ i at hi
+    rw [hi,hi]⟩
+  left_inv x := by
+    apply Subtype.ext
+    have hx := x.property
+    change mul μ (mul μ (vertex μ i) x.val) (vertex μ i) = x.val at hx
+    fin_cases i <;> simpa [vertex,mul,smul_eq μ] using hx
+  right_inv c := by fin_cases i <;> simp [vertex,smul_eq μ]
+  map_add' x y := by fin_cases i <;> rfl
+  map_smul' c x := by fin_cases i <;> rfl
+
+/-- No path points backwards in the actual algebra. -/
+theorem corner_zero_of_lt (i j : Fin 3) (hij : i < j) (x : corner μ i j) : x = 0 := by
+  apply Subtype.ext
+  have hx := x.property
+  change (directedSystem μ).e i * x.val * (directedSystem μ).e j = x.val at hx
+  rw [(directedSystem μ).directed j i hij x.val] at hx
+  exact hx.symm
+end LittleFinitistic.CornerSpaces
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Rectification/CornerTensor.lean b/lean/OAI/Algebra/Finitistic/Rectification/CornerTensor.lean
new file mode 100644
index 0000000000000000000000000000000000000000..7e825ce12954d7ceb4536336454654e0201907ca
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Rectification/CornerTensor.lean
@@ -0,0 +1,60 @@
+import OAI.Algebra.Finitistic.Rectification.CornerProjection
+import OAI.Algebra.Finitistic.Rectification.TensorProjection
+
+namespace OAI
+noncomputable section
+open scoped TensorProduct
+
+namespace LittleFinitistic.CornerTensor
+open ThreeVertexAlgebra CornerSpaces CornerProjection TensorProjection
+attribute [local instance] ExternalTensor.rightModule ExternalTensor.bimodule
+universe u v
+variable {k V W U : Type u} [Field k]
+  [AddCommGroup V] [Module k V] [AddCommGroup W] [Module k W]
+  [AddCommGroup U] [Module k U]
+variable (μ : W →ₗ[k] V →ₗ[k] U)
+variable (N : Type v) [AddCommGroup N] [Module k N]
+  [Module (ThreeVertexAlgebra μ)ᵐᵒᵖ N] [IsScalarTower k (ThreeVertexAlgebra μ)ᵐᵒᵖ N]
+
+/-- The concrete corner tensor is the fixed submodule of the induced column. -/
+def cornerTensorEquiv (i j : Fin 3) :
+    (corner μ i j ⊗[k] N) ≃ₗ[(ThreeVertexAlgebra μ)ᵐᵒᵖ]
+    TensorProjection.fixed (B := ThreeVertexAlgebra μ) (N := N) (projection μ i j) :=
+  (rightCongr (B := ThreeVertexAlgebra μ) (N := N) (rangeEquiv μ i j).symm).trans
+    (imageTensorEquiv (B := ThreeVertexAlgebra μ) (N := N)
+      (projection μ i j) (projection_idempotent μ i j))
+
+/-- This fixed-space definition uses the original left vertex action on the column. -/
+theorem fixed_iff_left_action (i j : Fin 3)
+    (x : ExternalTensor.Column k (ThreeVertexAlgebra μ) N (vertex μ j)) :
+    x ∈ TensorProjection.fixed (B := ThreeVertexAlgebra μ) (projection μ i j) ↔
+      vertex μ i • x = x := by
+  rw [TensorProjection.mem_fixed]
+  have h : rightMap (B := ThreeVertexAlgebra μ) (projection μ i j) x = vertex μ i • x := by
+    induction x using TensorProduct.inductionOn with
+    | tmul m n => rfl
+    | add x y hx hy => simp_all [smul_add]
+  rw [h]
+
+/-- Scalar tensor multiplication is right B-linear with the actual external action. -/
+def scalarTensorEquiv : (k ⊗[k] N) ≃ₗ[(ThreeVertexAlgebra μ)ᵐᵒᵖ] N where
+  __ := (TensorProduct.lid k N).toAddEquiv
+  map_smul' c x := by
+    induction x using TensorProduct.inductionOn with
+    | tmul r n =>
+      change r • (c • n) = c • (r • n)
+      exact smul_comm r c n
+    | add x y hx hy => simp_all [smul_add]
+
+/-- The diagonal vertex component of its own induced column is exactly N. -/
+def diagonalColumnEquiv (i : Fin 3) :
+    TensorProjection.fixed (B := ThreeVertexAlgebra μ) (N := N) (projection μ i i)
+      ≃ₗ[(ThreeVertexAlgebra μ)ᵐᵒᵖ] N :=
+  (cornerTensorEquiv μ N i i).symm.trans
+    ((rightCongr (B := ThreeVertexAlgebra μ) (N := N) (diagonalEquiv μ i)).trans
+      (scalarTensorEquiv μ N))
+end LittleFinitistic.CornerTensor
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Rectification/DiagramAssembly.lean b/lean/OAI/Algebra/Finitistic/Rectification/DiagramAssembly.lean
new file mode 100644
index 0000000000000000000000000000000000000000..efc9f593e045315cef24e9742caeac1ffdbac280
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Rectification/DiagramAssembly.lean
@@ -0,0 +1,97 @@
+import OAI.Algebra.Finitistic.Rectification.ColumnComplex
+
+namespace OAI
+open CategoryTheory CategoryTheory.Limits HomologicalComplex
+noncomputable section
+namespace ExternalTensor.Section4
+universe u
+variable {k : Type u} [Field k]
+variable {C : Type u} [Category C] [Preadditive C] [Linear k C] [HasFiniteBiproducts C] [HasBinaryBiproducts C]
+variable {A J R : Type} [Fintype A] [Fintype J] [Fintype R]
+
+/-- The concrete column/map interface. No composite or null-homotopy is assumed.
+The three equations are path naturality, the algebra relations, and the chosen
+relation homotopies after column induction. -/
+structure AssemblyData where
+  V₀ : C
+  V₁ : C
+  V₂ : C
+  U : A → C
+  V : J → C
+  W : R → C
+  pa₀ : ∀ a, U a ⟶ V₀
+  pa₁ : ∀ a, U a ⟶ V₁
+  pb₁ : ∀ b, V b ⟶ V₁
+  pb₂ : ∀ b, V b ⟶ V₂
+  qa : ∀ relation arrow, J → (W relation ⟶ U arrow)
+  qb : ∀ relation, A → ∀ arrow, W relation ⟶ V arrow
+  rel : ∀ r, W r ⟶ V₂
+  middle : ∀ r a b, qa r a b ≫ pa₁ a = qb r a b ≫ pb₁ b
+  first : ∀ r, ∑ a, ∑ b, qa r a b ≫ pa₀ a = 0
+  last : ∀ r, ∑ a, ∑ b, qb r a b ≫ pb₂ b = rel r
+
+namespace AssemblyData
+variable (s : AssemblyData (C := C) (A := A) (J := J) (R := R))
+abbrev L₀ := s.V₀ ⊞ (s.V₁ ⊞ s.V₂)
+abbrev L₁ := (⨁ s.U) ⊞ (⨁ s.V)
+abbrev L₂ := ⨁ s.W
+abbrev in₀ : s.V₀ ⟶ s.L₀ := biprod.inl
+abbrev in₁ : s.V₁ ⟶ s.L₀ := biprod.inl ≫ biprod.inr
+abbrev in₂ : s.V₂ ⟶ s.L₀ := biprod.inr ≫ biprod.inr
+
+def p : s.L₁ ⟶ s.L₀ :=
+  biprod.desc
+    (biproduct.desc fun a => s.pa₀ a ≫ s.in₀ - s.pa₁ a ≫ s.in₁)
+    (biproduct.desc fun b => s.pb₁ b ≫ s.in₁ - s.pb₂ b ≫ s.in₂)
+
+def q : s.L₂ ⟶ s.L₁ :=
+  biproduct.desc fun r => ∑ a, ∑ b,
+    (s.qa r a b ≫ biproduct.ι s.U a ≫ biprod.inl +
+     s.qb r a b ≫ biproduct.ι s.V b ≫ biprod.inr)
+
+/-- The complete cancellation in Section 4, including the minus sign. -/
+theorem composite : s.q ≫ s.p =
+    -(biproduct.desc fun r => s.rel r ≫ s.in₂) := by
+  apply biproduct.hom_ext'
+  intro r
+  simp only [q, biproduct.ι_desc_assoc, Preadditive.comp_neg,
+    biproduct.ι_desc]
+  simp only [Preadditive.sum_comp, Preadditive.add_comp, Category.assoc, p,
+    biprod.inl_desc, biprod.inr_desc, biproduct.ι_desc, Preadditive.comp_sub,
+    ]
+  simp only [← Category.assoc, s.middle]
+  simp only [Category.assoc]
+  have cancel (a : A) (b : J) :
+      s.qa r a b ≫ s.pa₀ a ≫ s.in₀ - s.qb r a b ≫ s.pb₁ b ≫ s.in₁ +
+      (s.qb r a b ≫ s.pb₁ b ≫ s.in₁ - s.qb r a b ≫ s.pb₂ b ≫ s.in₂) =
+      s.qa r a b ≫ s.pa₀ a ≫ s.in₀ - s.qb r a b ≫ s.pb₂ b ≫ s.in₂ := by abel
+  simp_rw [cancel, Finset.sum_sub_distrib]
+  have hf := congrArg (fun z => z ≫ s.in₀) (s.first r)
+  have hl := congrArg (fun z => z ≫ s.in₂) (s.last r)
+  simp only [Preadditive.sum_comp, Category.assoc, zero_comp] at hf hl
+  rw [hf, hl]
+  simp
+
+/-- A componentwise specified finite sum of homotopies. -/
+def sumHomotopy {E : Type*} [Category E] [Preadditive E]
+    {X Y : CochainComplex E ℤ} {I : Type} [Fintype I]
+    (f : I → (X ⟶ Y)) (H : ∀ i, Homotopy (f i) 0) :
+    Homotopy (∑ i, f i) 0 where
+  hom n m := ∑ i, (H i).hom n m
+  zero n m h := by simp [fun i => (H i).zero n m h]
+  comm n := by
+    change Hom.fAddMonoidHom n (∑ i, f i) = _
+    rw [map_sum]
+    change (∑ i, (f i).f n) = _
+    calc
+      _ = ∑ i, (dNext n (H i).hom + prevD n (H i).hom + (0 : X ⟶ Y).f n) :=
+        Finset.sum_congr rfl (fun i _ => (H i).comm n)
+      _ = _ := by
+        simp [dNext, prevD, Preadditive.comp_sum, Preadditive.sum_comp,
+          Finset.sum_add_distrib]
+end AssemblyData
+end ExternalTensor.Section4
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Rectification/ExactProducts.lean b/lean/OAI/Algebra/Finitistic/Rectification/ExactProducts.lean
new file mode 100644
index 0000000000000000000000000000000000000000..2e14b986c1b705fe7e4f72b4912d84cd13e7aade
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Rectification/ExactProducts.lean
@@ -0,0 +1,72 @@
+import Mathlib.Algebra.Exact.Basic
+
+namespace OAI
+noncomputable section
+namespace LittleFinitistic.RectificationTotal
+variable {A B C A' B' C' : Type*} [Zero C] [Zero C']
+variable {f : A → B} {g : B → C} {f' : A' → B'} {g' : B' → C'}
+
+/-- Exact pairs remain exact under the concrete binary product of maps. -/
+theorem exact_prod (h : Function.Exact f g) (h' : Function.Exact f' g') :
+    Function.Exact (Prod.map f f') (Prod.map g g') := by
+  rintro ⟨x, x'⟩
+  constructor
+  · intro hx
+    obtain ⟨y, hy⟩ := (h x).mp (congrArg Prod.fst hx)
+    obtain ⟨y', hy'⟩ := (h' x').mp (congrArg Prod.snd hx)
+    exact ⟨(y,y'), Prod.ext hy hy'⟩
+  · rintro ⟨⟨y,y'⟩, hy⟩
+    rw [← hy]
+    exact Prod.ext (h.apply_apply_eq_zero y) (h'.apply_apply_eq_zero y')
+
+/-- Short exactness is also preserved by the concrete binary product. -/
+theorem shortExact_prod (h : Function.Exact f g) (h' : Function.Exact f' g')
+    (hf : Function.Injective f) (hf' : Function.Injective f')
+    (hg : Function.Surjective g) (hg' : Function.Surjective g') :
+    Function.Injective (Prod.map f f') ∧
+      Function.Exact (Prod.map f f') (Prod.map g g') ∧
+      Function.Surjective (Prod.map g g') := by
+  refine ⟨?_, exact_prod h h', ?_⟩
+  · intro x y hxy
+    exact Prod.ext (hf (congrArg Prod.fst hxy)) (hf' (congrArg Prod.snd hxy))
+  · rintro ⟨z,z'⟩
+    obtain ⟨x,hx⟩ := hg z
+    obtain ⟨x',hx'⟩ := hg' z'
+    exact ⟨(x,x'),Prod.ext hx hx'⟩
+
+variable {X Y Z X' Y' Z' : Type*} [Zero Z] [Zero Z']
+variable (eX : X ≃ X') (eY : Y ≃ Y') (eZ : Z ≃ Z') (eZzero : eZ 0 = 0)
+variable {f : X → Y} {g : Y → Z} {f' : X' → Y'} {g' : Y' → Z'}
+variable (commF : ∀ x, eY (f x) = f' (eX x))
+variable (commG : ∀ y, eZ (g y) = g' (eY y))
+
+include eX eY eZ eZzero commF commG
+
+theorem exact_transport (h : Function.Exact f' g') : Function.Exact f g := by
+  intro y
+  constructor
+  · intro hy
+    obtain ⟨x',hx'⟩ := (h (eY y)).mp (by rw [← commG, hy, eZzero])
+    refine ⟨eX.symm x', eY.injective ?_⟩
+    rw [commF, eX.apply_symm_apply, hx']
+  · rintro ⟨x,rfl⟩
+    apply eZ.injective
+    rw [commG, commF, h.apply_apply_eq_zero, eZzero]
+
+theorem shortExact_transport (hf : Function.Injective f') (h : Function.Exact f' g')
+    (hg : Function.Surjective g') :
+    Function.Injective f ∧ Function.Exact f g ∧ Function.Surjective g := by
+  refine ⟨?_, exact_transport eX eY eZ eZzero commF commG h, ?_⟩
+  · intro x y hxy
+    apply eX.injective
+    apply hf
+    rw [← commF, ← commF, hxy]
+  · intro z
+    obtain ⟨y',hy'⟩ := hg (eZ z)
+    refine ⟨eY.symm y',eZ.injective ?_⟩
+    rw [commG, eY.apply_symm_apply, hy']
+end LittleFinitistic.RectificationTotal
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Rectification/ExternalTensor.lean b/lean/OAI/Algebra/Finitistic/Rectification/ExternalTensor.lean
new file mode 100644
index 0000000000000000000000000000000000000000..b98e79060652074d1496e2d1b170e8d63ebe8179
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Rectification/ExternalTensor.lean
@@ -0,0 +1,221 @@
+import Mathlib.RingTheory.TensorProduct.Maps
+import Mathlib.LinearAlgebra.TensorProduct.Basis
+import Mathlib.Algebra.Module.Projective
+import Mathlib.LinearAlgebra.FiniteDimensional.Basic
+
+namespace OAI
+open scoped TensorProduct
+
+
+noncomputable section
+namespace ExternalTensor
+
+variable (k B M N : Type*) [Field k] [Ring B] [Algebra k B]
+  [AddCommGroup M] [Module k M] [Module B M] [IsScalarTower k B M]
+  [AddCommGroup N] [Module k N] [Module Bᵐᵒᵖ N] [IsScalarTower k Bᵐᵒᵖ N]
+
+def leftAction : B →ₐ[k] Module.End k (M ⊗[k] N) :=
+  (Module.End.rTensorAlgHom k M N).comp (Algebra.lsmul k k M)
+
+def rightAction : Bᵐᵒᵖ →ₐ[k] Module.End k (M ⊗[k] N) :=
+  (Module.End.lTensorAlgHom k N M).comp (Algebra.lsmul k k N)
+
+omit [Module Bᵐᵒᵖ N] [IsScalarTower k Bᵐᵒᵖ N] in
+@[simp] theorem leftAction_tmul (b : B) (m : M) (n : N) :
+    leftAction k B M N b (m ⊗ₜ[k] n) = (b • m) ⊗ₜ[k] n := rfl
+
+omit [Module B M] [IsScalarTower k B M] in
+@[simp] theorem rightAction_tmul (b : Bᵐᵒᵖ) (m : M) (n : N) :
+    rightAction k B M N b (m ⊗ₜ[k] n) = m ⊗ₜ[k] (b • n) := rfl
+
+theorem actions_commute (b : B) (c : Bᵐᵒᵖ) :
+    Commute (leftAction k B M N b) (rightAction k B M N c) := by
+  apply TensorProduct.ext
+  ext m n
+  rfl
+
+/-- The genuine enveloping algebra representation; the right action is encoded by Bᵐᵒᵖ. -/
+def action : (B ⊗[k] Bᵐᵒᵖ) →ₐ[k] Module.End k (M ⊗[k] N) :=
+  Algebra.TensorProduct.lift (leftAction k B M N) (rightAction k B M N)
+    (actions_commute k B M N)
+
+@[instance_reducible] def bimodule : Module (B ⊗[k] Bᵐᵒᵖ) (M ⊗[k] N) :=
+  Module.compHom (M ⊗[k] N) (action k B M N).toRingHom
+
+@[instance_reducible] def rightModule : Module Bᵐᵒᵖ (M ⊗[k] N) :=
+  Module.compHom (M ⊗[k] N) (rightAction k B M N).toRingHom
+
+attribute [local instance] bimodule rightModule
+
+@[simp] theorem smul_tmul (b : B) (c : Bᵐᵒᵖ) (m : M) (n : N) :
+    (b ⊗ₜ[k] c) • (m ⊗ₜ[k] n) = (b • m) ⊗ₜ[k] (c • n) := rfl
+
+omit [Module B M] [IsScalarTower k B M] in
+@[simp] theorem right_smul_tmul (c : Bᵐᵒᵖ) (m : M) (n : N) :
+    c • (m ⊗ₜ[k] n) = m ⊗ₜ[k] (c • n) := rfl
+
+
+/-- Factor swap, with the external right action on the source. -/
+def rightSwap : (M ⊗[k] N) ≃ₗ[Bᵐᵒᵖ] (N ⊗[k] M) where
+  __ := (TensorProduct.comm k M N).toAddEquiv
+  map_smul' c x := by
+    induction x using TensorProduct.inductionOn with
+    | tmul m n => simp [right_smul_tmul, TensorProduct.smul_tmul']
+    | add x y hx hy => simp_all [smul_add]
+
+omit [Module B M] [IsScalarTower k B M] in
+/-- In fact no dimension restriction on M is needed for right projectivity. -/
+theorem projective_right [Module.Projective Bᵐᵒᵖ N] :
+    Module.Projective Bᵐᵒᵖ (M ⊗[k] N) :=
+  Module.Projective.of_equiv (rightSwap k B M N).symm
+
+theorem finiteDimensional [FiniteDimensional k M] [FiniteDimensional k N] :
+    FiniteDimensional k (M ⊗[k] N) :=
+  Module.Finite.equiv
+    (TensorProduct.equivFinsuppOfBasisLeft (Module.finBasis k M)).symm
+
+
+/-- A k-basis of the left factor gives an actual right-module direct-sum decomposition. -/
+def rightBasisEquiv {ι : Type*} [DecidableEq ι] (v : Module.Basis ι k M) :
+    (M ⊗[k] N) ≃ₗ[Bᵐᵒᵖ] (ι →₀ N) where
+  __ := (TensorProduct.equivFinsuppOfBasisLeft v).toAddEquiv
+  map_smul' c x := by
+    induction x using TensorProduct.inductionOn with
+    | tmul m n =>
+      ext i
+      change (TensorProduct.equivFinsuppOfBasisLeft v)
+        (c • (m ⊗ₜ[k] n)) i = c • (TensorProduct.equivFinsuppOfBasisLeft v) (m ⊗ₜ[k] n) i
+      rw [right_smul_tmul, TensorProduct.equivFinsuppOfBasisLeft_apply_tmul_apply,
+        TensorProduct.equivFinsuppOfBasisLeft_apply_tmul_apply]
+      exact smul_comm (v.repr m i) c n
+    | add x y hx hy => simp_all [smul_add]
+
+omit [Module B M] [IsScalarTower k B M] in
+@[simp] theorem rightBasisEquiv_tmul {ι : Type*} [DecidableEq ι]
+    (v : Module.Basis ι k M) (m : M) (n : N) (i : ι) :
+    rightBasisEquiv k B M N v (m ⊗ₜ[k] n) i = v.repr m i • n :=
+  TensorProduct.equivFinsuppOfBasisLeft_apply_tmul_apply v m n i
+
+omit [Module B M] [IsScalarTower k B M] in
+theorem finite_right [FiniteDimensional k M] [Module.Finite Bᵐᵒᵖ N] :
+    Module.Finite Bᵐᵒᵖ (M ⊗[k] N) :=
+  Module.Finite.equiv (rightBasisEquiv k B M N (Module.finBasis k M)).symm
+
+
+/-- The chosen right action is the restriction of the enveloping action. -/
+theorem right_eq_enveloping (c : Bᵐᵒᵖ) (x : M ⊗[k] N) :
+    c • x = (1 ⊗ₜ[k] c : B ⊗[k] Bᵐᵒᵖ) • x := by
+  induction x using TensorProduct.inductionOn with
+  | tmul m n => simp
+  | add x y hx hy => simp_all [smul_add]
+
+/-- The usual left action on the first tensor factor is the other restriction. -/
+theorem left_eq_enveloping (b : B) (x : M ⊗[k] N) :
+    b • x = (b ⊗ₜ[k] (1 : Bᵐᵒᵖ)) • x := by
+  induction x using TensorProduct.inductionOn with
+  | tmul m n => simp [TensorProduct.smul_tmul']
+  | add x y hx hy => simp_all [smul_add]
+
+instance commutingActions : SMulCommClass B Bᵐᵒᵖ (M ⊗[k] N) where
+  smul_comm b c x := by
+    induction x using TensorProduct.inductionOn with
+    | tmul m n => simp [TensorProduct.smul_tmul']
+    | add x y hx hy => simp_all [smul_add]
+
+instance rightScalarTower : IsScalarTower k Bᵐᵒᵖ (M ⊗[k] N) where
+  smul_assoc r c x := by
+    change rightAction k B M N (r • c) x = r • rightAction k B M N c x
+    rw [map_smul]
+    rfl
+
+instance envelopingScalarTower : IsScalarTower k (B ⊗[k] Bᵐᵒᵖ) (M ⊗[k] N) where
+  smul_assoc r a x := by
+    change action k B M N (r • a) x = r • action k B M N a x
+    rw [map_smul]
+    rfl
+
+variable {k B M N}
+variable {M' N' : Type*}
+  [AddCommGroup M'] [Module k M'] [Module B M'] [IsScalarTower k B M']
+  [AddCommGroup N'] [Module k N'] [Module Bᵐᵒᵖ N'] [IsScalarTower k Bᵐᵒᵖ N']
+
+/-- Tensor of a left-module map and a right-module map is enveloping-linear. -/
+def map (f : M →ₗ[B] M') (g : N →ₗ[Bᵐᵒᵖ] N') :
+    (M ⊗[k] N) →ₗ[B ⊗[k] Bᵐᵒᵖ] (M' ⊗[k] N') where
+  __ := (TensorProduct.map (f.restrictScalars k) (g.restrictScalars k)).toAddMonoidHom
+  map_smul' a x := by
+    induction a using TensorProduct.inductionOn with
+    | tmul b c =>
+      induction x using TensorProduct.inductionOn with
+      | tmul m n => simp [smul_tmul]
+      | add x y hx hy => simp_all [smul_add]
+    | add a b ha hb => simp_all [add_smul]
+
+@[simp] theorem map_tmul (f : M →ₗ[B] M') (g : N →ₗ[Bᵐᵒᵖ] N') (m : M) (n : N) :
+    map (k := k) f g (m ⊗ₜ[k] n) = f m ⊗ₜ[k] g n := rfl
+
+@[simp] theorem map_id :
+    map (k := k) (LinearMap.id : M →ₗ[B] M) (LinearMap.id : N →ₗ[Bᵐᵒᵖ] N) =
+      LinearMap.id := by
+  ext x
+  induction x using TensorProduct.inductionOn with
+  | tmul m n => rfl
+  | add x y hx hy => simp_all
+
+variable {M'' N'' : Type*}
+  [AddCommGroup M''] [Module k M''] [Module B M''] [IsScalarTower k B M'']
+  [AddCommGroup N''] [Module k N''] [Module Bᵐᵒᵖ N''] [IsScalarTower k Bᵐᵒᵖ N'']
+
+theorem map_comp (f : M →ₗ[B] M') (f' : M' →ₗ[B] M'')
+    (g : N →ₗ[Bᵐᵒᵖ] N') (g' : N' →ₗ[Bᵐᵒᵖ] N'') :
+    map (k := k) (f'.comp f) (g'.comp g) = (map (k := k) f' g').comp (map (k := k) f g) := by
+  ext x
+  induction x using TensorProduct.inductionOn with
+  | tmul m n => rfl
+  | add x y hx hy => simp_all
+
+
+theorem map_add_left (f f' : M →ₗ[B] M') (g : N →ₗ[Bᵐᵒᵖ] N') :
+    map (k := k) (f + f') g = map (k := k) f g + map (k := k) f' g := by
+  ext x
+  induction x using TensorProduct.inductionOn with
+  | tmul m n => simp [TensorProduct.add_tmul]
+  | add x y hx hy => simp_all [add_add_add_comm]
+
+theorem map_add_right (f : M →ₗ[B] M') (g g' : N →ₗ[Bᵐᵒᵖ] N') :
+    map (k := k) f (g + g') = map (k := k) f g + map (k := k) f g' := by
+  ext x
+  induction x using TensorProduct.inductionOn with
+  | tmul m n => simp [TensorProduct.tmul_add]
+  | add x y hx hy => simp_all [add_add_add_comm]
+
+
+theorem map_smul_left (r : k) (f : M →ₗ[B] M') (g : N →ₗ[Bᵐᵒᵖ] N') :
+    map (k := k) (r • f) g = r • map (k := k) f g := by
+  ext x
+  induction x using TensorProduct.inductionOn with
+  | tmul m n => simp [TensorProduct.smul_tmul']
+  | add x y hx hy => simp_all [smul_add]
+
+theorem map_smul_right (r : k) (f : M →ₗ[B] M') (g : N →ₗ[Bᵐᵒᵖ] N') :
+    map (k := k) f (r • g) = r • map (k := k) f g := by
+  ext x
+  induction x using TensorProduct.inductionOn with
+  | tmul m n => simp [TensorProduct.tmul_smul]
+  | add x y hx hy => simp_all [smul_add]
+
+/-- The same tensor map as a map of right B-modules. -/
+def rightMap (f : M →ₗ[B] M') (g : N →ₗ[Bᵐᵒᵖ] N') :
+    (M ⊗[k] N) →ₗ[Bᵐᵒᵖ] (M' ⊗[k] N') where
+  __ := (map (k := k) f g).toAddMonoidHom
+  map_smul' c x := by
+    change map (k := k) f g (c • x) = c • map (k := k) f g x
+    rw [right_eq_enveloping, right_eq_enveloping, LinearMap.map_smul]
+
+@[simp] theorem rightMap_tmul (f : M →ₗ[B] M') (g : N →ₗ[Bᵐᵒᵖ] N') (m : M) (n : N) :
+    rightMap (k := k) f g (m ⊗ₜ[k] n) = f m ⊗ₜ[k] g n := rfl
+end ExternalTensor
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Rectification/FiltrationExactness.lean b/lean/OAI/Algebra/Finitistic/Rectification/FiltrationExactness.lean
new file mode 100644
index 0000000000000000000000000000000000000000..c6283255791c0c56d9175731828f24ee15a683be
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Rectification/FiltrationExactness.lean
@@ -0,0 +1,70 @@
+import OAI.Algebra.Finitistic.Rectification.SourceFiltrationCone
+
+namespace OAI
+open CategoryTheory CategoryTheory.Limits HomologicalComplex CochainComplex
+open LittleFinitistic.RectificationTotal
+open scoped TensorProduct ModuleCat.Algebra
+noncomputable section
+namespace ExternalTensor.Section4.SourceFiltration.Exactness
+universe u
+variable {k B : Type u} [Field k] [Ring B] [Algebra k B]
+variable {A J R : Type} [Fintype A] [Fintype J] [Fintype R]
+variable (s : Quadratic k B (A := A) (J := J) (R := R))
+variable (D₀ D₁ D₂ : RightComplex B)
+variable (f : A → (D₀ ⟶ D₁)) (g : J → (D₁ ⟶ D₂))
+variable (H : ∀ r, Homotopy (relationMap s D₀ D₁ D₂ f g r) 0)
+
+abbrev data := inducedData s D₀ D₁ D₂ f g
+abbrev P := total (p s D₀ D₁ D₂ f g) (q s D₀ D₁ D₂ f g)
+  (nullHomotopy s D₀ D₁ D₂ f g H)
+abbrev F1 := total (p1 (data s D₀ D₁ D₂ f g)) 0 (h1 (data s D₀ D₁ D₂ f g))
+abbrev G0 := total (p0 (data s D₀ D₁ D₂ f g)) (q0 (data s D₀ D₁ D₂ f g))
+  (h0 (data s D₀ D₁ D₂ f g))
+abbrev G1 := total (pGrade1 (data s D₀ D₁ D₂ f g)) 0
+  (hGrade1 (data s D₀ D₁ D₂ f g))
+
+abbrev i1 : F1 s D₀ D₁ D₂ f g ⟶ P s D₀ D₁ D₂ f g H :=
+  (inducedInclude1 s D₀ D₁ D₂ f g H).totalMap
+abbrev pi0 : P s D₀ D₁ D₂ f g H ⟶ G0 s D₀ D₁ D₂ f g :=
+  (inducedQuotient0 s D₀ D₁ D₂ f g H).totalMap
+abbrev i2 : (columnComplex k B s.e₂).obj D₂ ⟶ F1 s D₀ D₁ D₂ f g :=
+  v2Inclusion (data s D₀ D₁ D₂ f g)
+abbrev pi1 : F1 s D₀ D₁ D₂ f g ⟶ G1 s D₀ D₁ D₂ f g :=
+  (quotient1 (data s D₀ D₁ D₂ f g)).totalMap
+
+/-- Section 4's actual two nontrivial source-filtration steps. No decomposition,
+exactness, extra coherence, vertex equivalence, or main theorem is an input. -/
+theorem exact_source_filtration (n : ℤ) :
+    (Function.Injective ((i1 s D₀ D₁ D₂ f g H).f n) ∧
+     Function.Exact ((i1 s D₀ D₁ D₂ f g H).f n) ((pi0 s D₀ D₁ D₂ f g H).f n) ∧
+     Function.Surjective ((pi0 s D₀ D₁ D₂ f g H).f n)) ∧
+    (Function.Injective ((i2 s D₀ D₁ D₂ f g).f n) ∧
+     Function.Exact ((i2 s D₀ D₁ D₂ f g).f n) ((pi1 s D₀ D₁ D₂ f g).f n) ∧
+     Function.Surjective ((pi1 s D₀ D₁ D₂ f g).f n)) ∧
+    i2 s D₀ D₁ D₂ f g ≫ i1 s D₀ D₁ D₂ f g H =
+      (data s D₀ D₁ D₂ f g).in₂ ≫
+        inclusion (p s D₀ D₁ D₂ f g) (q s D₀ D₁ D₂ f g)
+          (nullHomotopy s D₀ D₁ D₂ f g H) :=
+  ⟨induced_source0_shortExact s D₀ D₁ D₂ f g H n,
+   v2_shortExact (data s D₀ D₁ D₂ f g) n,
+   v2_nested (data s D₀ D₁ D₂ f g) (nullHomotopy s D₀ D₁ D₂ f g H)⟩
+
+theorem categorical_source0 (n : ℤ) :
+    let E := (exact_source_filtration s D₀ D₁ D₂ f g H n).1
+    (ModuleCat.shortComplexOfCompEqZero ((i1 s D₀ D₁ D₂ f g H).f n).hom
+      ((pi0 s D₀ D₁ D₂ f g H).f n).hom E.2.1.linearMap_comp_eq_zero).ShortExact := by
+  let E := (exact_source_filtration s D₀ D₁ D₂ f g H n).1
+  exact ModuleCat.shortComplex_shortExact _ E.2.1 E.1 E.2.2
+
+omit [Fintype R] in
+theorem categorical_source1 (n : ℤ) :
+    let E := v2_shortExact (data s D₀ D₁ D₂ f g) n
+    (ModuleCat.shortComplexOfCompEqZero ((i2 s D₀ D₁ D₂ f g).f n).hom
+      ((pi1 s D₀ D₁ D₂ f g).f n).hom E.2.1.linearMap_comp_eq_zero).ShortExact := by
+  let E := v2_shortExact (data s D₀ D₁ D₂ f g) n
+  exact ModuleCat.shortComplex_shortExact _ E.2.1 E.1 E.2.2
+end ExternalTensor.Section4.SourceFiltration.Exactness
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Rectification/FinalGradedAcyclic.lean b/lean/OAI/Algebra/Finitistic/Rectification/FinalGradedAcyclic.lean
new file mode 100644
index 0000000000000000000000000000000000000000..d09ae96606275a22987534aae87034927e42027e
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Rectification/FinalGradedAcyclic.lean
@@ -0,0 +1,38 @@
+import OAI.Algebra.Finitistic.Encoding.RelationVertexSequence
+import OAI.Algebra.Finitistic.Rectification.TotalInterchange
+import OAI.Algebra.Finitistic.Rectification.GradedVertexAcyclic
+
+namespace OAI
+noncomputable section
+open CategoryTheory CategoryTheory.Limits HomologicalComplex CochainComplex
+namespace LittleFinitistic.FinalGradedAcyclic
+open QuadraticEncoding ExternalTensor.Section4 ExternalTensor.Section4.SourceFiltration
+open RectificationTotal
+universe u
+variable {k : Type u} [Field k] {d t : ℕ} (P : Relations k d t)
+variable (D₀ D₁ D₂ : RightComplex (QuadraticEncoding.B P))
+variable (f : Fin (d+1) → (D₀ ⟶ D₁)) (g : Fin (d+1) → (D₁ ⟶ D₂))
+local notation "T" => QuadraticEncoding.B P
+local notation "s" => ConcreteQuadraticDiagram.quadratic P
+local notation "data" => Exactness.data s D₀ D₁ D₂ f g
+
+/-- The original source-zero quotient at vertex two is acyclic, with every relation column retained. -/
+theorem grade0_vertex2_acyclic :
+    ((RelationVertexCoordinates.vertex P).obj (Exactness.G0 s D₀ D₁ D₂ f g)).Acyclic := by
+  let F := BimoduleVertex.functor k T (ThreeVertexAlgebra.vertex (composition P) 2)
+  let S := (RelationVertexSequence.originalSequence P D₀ D₁ D₂ f g).map
+    (RelationVertexCoordinates.vertex P)
+  have he : mapNullHomotopy F (p0 data) (q0 data) (h0 data) = Homotopy.ofEq S.zero := by
+    ext i j
+    simp [mapNullHomotopy_hom,h0,Homotopy.ofEq]
+    rfl
+  apply GradedVertexAcyclic.acyclic_of_iso
+    (totalInterchange F (p0 data) (q0 data) (h0 data))
+  rw [he]
+  exact RectificationAcyclic.short_exact_total_acyclic S
+    (RelationVertexSequence.shortExact P D₀ D₁ D₂ f g)
+end LittleFinitistic.FinalGradedAcyclic
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Rectification/FirstVertex.lean b/lean/OAI/Algebra/Finitistic/Rectification/FirstVertex.lean
new file mode 100644
index 0000000000000000000000000000000000000000..4773638edaff2ab8eb1f719f887f0a5a92cff814
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Rectification/FirstVertex.lean
@@ -0,0 +1,75 @@
+import OAI.Algebra.Finitistic.Rectification.VertexZeroTotal
+
+namespace OAI
+noncomputable section
+open CategoryTheory CategoryTheory.Limits HomologicalComplex
+open scoped TensorProduct ModuleCat.Algebra
+namespace LittleFinitistic.FirstVertex
+open ExternalTensor.Section4
+section General
+variable {C D : Type*} [Category C] [Category D] [Preadditive C] [Preadditive D]
+  [HasBinaryBiproducts C] [HasBinaryBiproducts D]
+def biprodInlIso {X Y : D} (hY : IsZero Y) : X ≅ X ⊞ Y where
+  hom := biprod.inl
+  inv := biprod.fst
+  hom_inv_id := by simp
+  inv_hom_id := by
+    apply biprod.hom_ext
+    · simp
+    · exact hY.eq_of_tgt _ _
+
+theorem mapped_inl_isIso (F : C ⥤ D) [F.Additive] (X Y : C) (hY : IsZero (F.obj Y)) :
+    IsIso (F.map (biprod.inl : X ⟶ X ⊞ Y)) := by
+  have := preservesBinaryBiproducts_of_preservesBiproducts F
+  rw [← isIso_comp_right_iff _ (F.mapBiprod X Y).hom]
+  have he : F.map (biprod.inl : X ⟶ X ⊞ Y) ≫ (F.mapBiprod X Y).hom = biprod.inl := by
+    apply biprod.hom_ext
+    · erw [Functor.mapBiprod_hom, Category.assoc, biprod.lift_fst,
+        ← Functor.map_comp, biprod.inl_fst, F.map_id, biprod.inl_fst]
+    · erw [Functor.mapBiprod_hom, Category.assoc, biprod.lift_snd,
+        ← Functor.map_comp, biprod.inl_snd, F.map_zero, biprod.inl_snd]
+  rw [he]
+  exact (biprodInlIso hY).isIso_hom
+end General
+
+universe u
+variable {k : Type u} [Field k] {d t : ℕ} (P : QuadraticEncoding.Relations k d t)
+local notation "B" => QuadraticEncoding.B P
+local notation "s" => ConcreteQuadraticDiagram.quadratic P
+abbrev vertexComplex := (VertexZeroTotal.vertexFunctor P).mapHomologicalComplex (.up ℤ)
+variable (D₀ D₁ D₂ : RightComplex (QuadraticEncoding.B P))
+variable (f : Fin (d+1) → (D₀ ⟶ D₁)) (g : Fin (d+1) → (D₁ ⟶ D₂))
+variable (H : ∀ r, Homotopy (relationMap (ConcreteQuadraticDiagram.quadratic P) D₀ D₁ D₂ f g r) 0)
+
+/-- The original first induced column includes into the actual zero column. -/
+def columnInclusion : (columnComplex k B (s).e₀).obj D₀ ⟶ L0Prime s D₀ D₁ D₂ f g := biprod.inl
+
+theorem columnInclusion_isIso :
+    IsIso ((vertexComplex P).map (columnInclusion P D₀ D₁ D₂ f g)) := by
+  have := preservesBinaryBiproducts_of_preservesBiproducts (vertexComplex P)
+  apply mapped_inl_isIso
+  apply ((vertexComplex P).mapBiprod _ _).isZero_iff.mpr
+  rw [biprod_isZero_iff]
+  exact ⟨VertexColumnComplex.reverse_isZero (QuadraticEncoding.composition P) 0 1 (by decide) D₁,
+    VertexColumnComplex.reverse_isZero (QuadraticEncoding.composition P) 0 2 (by decide) D₂⟩
+
+/-- The manuscript's original first-vertex insertion into the constructed total. -/
+def iota : D₀ ⟶ (vertexComplex P).obj (InducedRectification.total s D₀ D₁ D₂ f g H) :=
+  (VertexColumnComplex.diagonalComplexIso (QuadraticEncoding.composition P) 0 D₀).hom ≫
+    (vertexComplex P).map (columnInclusion P D₀ D₁ D₂ f g) ≫
+    (vertexComplex P).map (InducedRectification.inclusion s D₀ D₁ D₂ f g H)
+
+/-- At the first vertex the original insertion is already a chain isomorphism. -/
+theorem iota_isIso : IsIso (iota P D₀ D₁ D₂ f g H) := by
+  have := columnInclusion_isIso P D₀ D₁ D₂ f g
+  have := VertexZeroTotal.inclusion_isIso P D₀ D₁ D₂ f g H
+  let e : D₀ ≅ (vertexComplex P).obj ((columnComplex k B (s).e₀).obj D₀) :=
+    VertexColumnComplex.diagonalComplexIso (QuadraticEncoding.composition P) 0 D₀
+  change IsIso (e.hom ≫ (vertexComplex P).map (columnInclusion P D₀ D₁ D₂ f g) ≫
+    (vertexComplex P).map (InducedRectification.inclusion s D₀ D₁ D₂ f g H))
+  infer_instance
+end LittleFinitistic.FirstVertex
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Rectification/FullTensorProperties.lean b/lean/OAI/Algebra/Finitistic/Rectification/FullTensorProperties.lean
new file mode 100644
index 0000000000000000000000000000000000000000..511896df128174ec027895cd5dacab26076dc8be
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Rectification/FullTensorProperties.lean
@@ -0,0 +1,53 @@
+import OAI.Algebra.Finitistic.Bimodule.BimoduleTensorUnderlying
+import OAI.Algebra.Finitistic.Rectification.TotalFinite
+import OAI.Algebra.Finitistic.Rectification.InducedRectification
+
+namespace OAI
+noncomputable section
+open CategoryTheory CategoryTheory.Limits
+open scoped TensorProduct ModuleCat.Algebra
+namespace LittleFinitistic.FullTensorProperties
+open ExternalTensor.Section4
+universe u
+variable (k B : Type u) [Field k] [Ring B] [Algebra k B]
+
+/-- The tensor input's scalar structure agrees with the original bimodule's
+scalar restriction through the two algebra homomorphisms. -/
+def inputEquiv (M : ModuleCat.{u} (Enveloping k B)) :
+    (forgetK k B).obj M ≃ₗ[k] BimoduleBalancedTensor.Input k B M where
+  toFun := id
+  invFun := id
+  left_inv _ := rfl
+  right_inv _ := rfl
+  map_add' _ _ := rfl
+  map_smul' c x := by
+    change (algebraMap k (Enveloping k B) c) • (show M from x) =
+      (BimoduleVertex.restriction k B (algebraMap k Bᵐᵒᵖ c)) • (show M from x)
+    have h : BimoduleVertex.restriction k B (algebraMap k Bᵐᵒᵖ c) =
+        algebraMap k (Enveloping k B) c := Algebra.TensorProduct.includeRight.commutes c
+    rw [h]
+
+variable (N : Type u) [AddCommGroup N] [Module k N] [Module B N]
+
+theorem finite (M : ModuleCat.{u} (Enveloping k B))
+    [FiniteDimensional k ((forgetK k B).obj M)] [FiniteDimensional k N] :
+    FiniteDimensional k ((ModuleCat.restrictScalars (algebraMap k B)).obj
+      ((BimoduleBalancedTensor.functor k B N).obj M)) := by
+  have : FiniteDimensional k (BimoduleBalancedTensor.Input k B M) :=
+    Module.Finite.of_surjective (inputEquiv k B M).toLinearMap (inputEquiv k B M).surjective
+  have : FiniteDimensional k ((BalancedTensor.tensorFunctor k B N).obj ((forgetRight k B).obj M)) :=
+    inferInstanceAs (FiniteDimensional k (BimoduleBalancedTensor.Tensor k B M N))
+  apply Module.Finite.of_surjective (BimoduleBalancedTensor.underlyingEquiv k B N M).symm.toLinearMap
+    (BimoduleBalancedTensor.underlyingEquiv k B N M).symm.surjective
+
+theorem bounded (P : BiComplex k B) (lo hi : ℤ)
+    (h : ∀ n, n < lo ∨ hi < n → IsZero (P.X n)) :
+    ∀ n, n < lo ∨ hi < n → IsZero
+      ((((BimoduleBalancedTensor.functor k B N).mapHomologicalComplex (.up ℤ)).obj P).X n) := by
+  intro n hn
+  exact (BimoduleBalancedTensor.functor k B N).map_isZero (h n hn)
+end LittleFinitistic.FullTensorProperties
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Rectification/FullTensorRectification.lean b/lean/OAI/Algebra/Finitistic/Rectification/FullTensorRectification.lean
new file mode 100644
index 0000000000000000000000000000000000000000..7cfc1e10f9477ae1e17cdabbd8b4e0ad00056a38
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Rectification/FullTensorRectification.lean
@@ -0,0 +1,125 @@
+import OAI.Algebra.Finitistic.Rectification.TensorArrowComparison
+import OAI.Algebra.Finitistic.Rectification.CanonicalArrowCompatibility
+
+namespace OAI
+noncomputable section
+open CategoryTheory CategoryTheory.Limits HomologicalComplex
+namespace LittleFinitistic.FullTensorRectification
+open ExternalTensor.Section4 QuadraticEncoding
+universe u
+variable {k : Type u} [Field k] {d t : ℕ} (P : Relations k d t)
+variable (D₀ D₁ D₂ : RightComplex (B P))
+variable (f : Fin (d+1) → (D₀ ⟶ D₁)) (g : Fin (d+1) → (D₁ ⟶ D₂))
+variable (H : ∀ r, Homotopy (relationMap (ConcreteQuadraticDiagram.quadratic P) D₀ D₁ D₂ f g r) 0)
+variable (N : Type u) [AddCommGroup N] [Module k N] [Module (B P) N]
+
+/-- The actual left B-module complex P tensor_B N. -/
+abbrev tensor := ((BimoduleBalancedTensor.functor k (B P) N).mapHomologicalComplex (.up ℤ)).obj
+  (InducedRectification.total (ConcreteQuadraticDiagram.quadratic P) D₀ D₁ D₂ f g H)
+
+abbrev source (v : Fin 3) :=
+  ((BalancedTensor.tensorFunctor k (B P) N).mapHomologicalComplex (.up ℤ)).obj
+    (VertexHomotopyEquivalence.source P D₀ D₁ D₂ v)
+abbrev target (v : Fin 3) :=
+  ((LeftVertexHomology.vertex k (B P) (ThreeVertexAlgebra.vertex (composition P) v)).mapHomologicalComplex
+    (.up ℤ)).obj (tensor P D₀ D₁ D₂ f g H N)
+
+/-- The original vertex insertion after balanced tensoring and the canonical comparison. -/
+def iota (v : Fin 3) : source P D₀ D₁ D₂ N v ⟶ target P D₀ D₁ D₂ f g H N v :=
+  ((BalancedTensor.tensorFunctor k (B P) N).mapHomologicalComplex (.up ℤ)).map
+    (VertexHomotopyEquivalence.iota P D₀ D₁ D₂ f g H v) ≫
+  (TensorArrowComparison.complexIso k (B P) N (ThreeVertexAlgebra.vertex (composition P) v)
+    ((ThreeVertexAlgebra.directedSystem (composition P)).idem v)
+    (InducedRectification.total (ConcreteQuadraticDiagram.quadratic P) D₀ D₁ D₂ f g H)).hom
+
+/-- The equivalences retain the full left B-valued tensor target and the exact original maps. -/
+theorem equivalence (v : Fin 3) (lo hi : ℤ)
+    (b₀ : ∀ n, n < lo ∨ hi < n → IsZero (D₀.X n))
+    (b₁ : ∀ n, n < lo ∨ hi < n → IsZero (D₁.X n))
+    (b₂ : ∀ n, n < lo ∨ hi < n → IsZero (D₂.X n))
+    (p₀ : ∀ n, Module.Projective (B P)ᵐᵒᵖ (D₀.X n))
+    (p₁ : ∀ n, Module.Projective (B P)ᵐᵒᵖ (D₁.X n))
+    (p₂ : ∀ n, Module.Projective (B P)ᵐᵒᵖ (D₂.X n)) :
+    ∃ E : HomotopyEquiv (source P D₀ D₁ D₂ N v) (target P D₀ D₁ D₂ f g H N v),
+      E.hom = iota P D₀ D₁ D₂ f g H N v := by
+  obtain ⟨j,⟨h₁⟩,⟨h₂⟩⟩ := VertexHomotopyEquivalence.homotopy_inverse P D₀ D₁ D₂ f g H
+    v lo hi b₀ b₁ b₂ p₀ p₁ p₂
+  let E : HomotopyEquiv (VertexHomotopyEquivalence.source P D₀ D₁ D₂ v)
+      (VertexHomotopyEquivalence.target P D₀ D₁ D₂ f g H v) :=
+    ⟨VertexHomotopyEquivalence.iota P D₀ D₁ D₂ f g H v,j,h₁,h₂⟩
+  exact ⟨((BalancedTensor.tensorFunctor k (B P) N).mapHomotopyEquiv E).trans
+    (HomotopyEquiv.ofIso (TensorArrowComparison.complexIso k (B P) N
+      (ThreeVertexAlgebra.vertex (composition P) v)
+      ((ThreeVertexAlgebra.directedSystem (composition P)).idem v)
+      (InducedRectification.total (ConcreteQuadraticDiagram.quadratic P) D₀ D₁ D₂ f g H))),rfl⟩
+
+abbrev arrow01Map (a : Fin (d+1)) :=
+  ((LeftVertexHomology.arrow k (B P) (ThreeVertexAlgebra.vertex (composition P) 0)
+    (ThreeVertexAlgebra.vertex (composition P) 1) (arrow01 P a)
+    (CanonicalArrowCompatibility.arrow01_target P a)).mapHomologicalComplex (.up ℤ)).app
+      (tensor P D₀ D₁ D₂ f g H N)
+abbrev arrow12Map (b : Fin (d+1)) :=
+  ((LeftVertexHomology.arrow k (B P) (ThreeVertexAlgebra.vertex (composition P) 1)
+    (ThreeVertexAlgebra.vertex (composition P) 2) (arrow12 P b)
+    (CanonicalArrowCompatibility.arrow12_target P b)).mapHomologicalComplex (.up ℤ)).app
+      (tensor P D₀ D₁ D₂ f g H N)
+
+lemma original_iota0 : VertexHomotopyEquivalence.iota P D₀ D₁ D₂ f g H 0 =
+    FirstVertex.iota P D₀ D₁ D₂ f g H := by rfl
+lemma original_iota1 : VertexHomotopyEquivalence.iota P D₀ D₁ D₂ f g H 1 =
+    SecondVertex.iota P D₀ D₁ D₂ f g H := by rfl
+lemma original_iota2 : VertexHomotopyEquivalence.iota P D₀ D₁ D₂ f g H 2 =
+    ThirdVertex.iota P D₀ D₁ D₂ f g H := by rfl
+
+/-- Actual arrow compatibility on the vertex diagram of the full B-valued tensor. -/
+def compatibility01 (a : Fin (d+1)) : Homotopy
+    (iota P D₀ D₁ D₂ f g H N 0 ≫ arrow01Map P D₀ D₁ D₂ f g H N a)
+    (((BalancedTensor.tensorFunctor k (B P) N).mapHomologicalComplex (.up ℤ)).map (f a) ≫
+      iota P D₀ D₁ D₂ f g H N 1) := by
+  have h := ((BalancedTensor.tensorFunctor k (B P) N).mapHomotopy
+    (CanonicalArrowCompatibility.compatibility01 P D₀ D₁ D₂ f g H a)).compRight
+      (TensorArrowComparison.complexIso k (B P) N (ThreeVertexAlgebra.vertex (composition P) 1)
+        ((ThreeVertexAlgebra.directedSystem (composition P)).idem 1)
+        (InducedRectification.total (ConcreteQuadraticDiagram.quadratic P) D₀ D₁ D₂ f g H)).hom
+  erw [Functor.map_comp_assoc _ (FirstVertex.iota P D₀ D₁ D₂ f g H)
+      (CanonicalArrowCompatibility.arrow01Map P D₀ D₁ D₂ f g H a),
+    Functor.map_comp_assoc _ (f a) (SecondVertex.iota P D₀ D₁ D₂ f g H)] at h
+  have hs := TensorArrowComparison.complex_arrow_square k (B P) N
+    (ThreeVertexAlgebra.vertex (composition P) 0) (ThreeVertexAlgebra.vertex (composition P) 1)
+    (arrow01 P a) ((ThreeVertexAlgebra.directedSystem (composition P)).idem 0)
+    ((ThreeVertexAlgebra.directedSystem (composition P)).idem 1)
+    (CanonicalArrowCompatibility.arrow01_target P a)
+    (InducedRectification.total (ConcreteQuadraticDiagram.quadratic P) D₀ D₁ D₂ f g H)
+  erw [hs] at h
+  dsimp only [iota]
+  erw [original_iota0, original_iota1, Category.assoc]
+  exact h
+
+/-- The second arrow family retains its original maps as well. -/
+def compatibility12 (b : Fin (d+1)) : Homotopy
+    (iota P D₀ D₁ D₂ f g H N 1 ≫ arrow12Map P D₀ D₁ D₂ f g H N b)
+    (((BalancedTensor.tensorFunctor k (B P) N).mapHomologicalComplex (.up ℤ)).map (g b) ≫
+      iota P D₀ D₁ D₂ f g H N 2) := by
+  have h := ((BalancedTensor.tensorFunctor k (B P) N).mapHomotopy
+    (CanonicalArrowCompatibility.compatibility12 P D₀ D₁ D₂ f g H b)).compRight
+      (TensorArrowComparison.complexIso k (B P) N (ThreeVertexAlgebra.vertex (composition P) 2)
+        ((ThreeVertexAlgebra.directedSystem (composition P)).idem 2)
+        (InducedRectification.total (ConcreteQuadraticDiagram.quadratic P) D₀ D₁ D₂ f g H)).hom
+  erw [Functor.map_comp_assoc _ (SecondVertex.iota P D₀ D₁ D₂ f g H)
+      (CanonicalArrowCompatibility.arrow12Map P D₀ D₁ D₂ f g H b),
+    Functor.map_comp_assoc _ (g b) (ThirdVertex.iota P D₀ D₁ D₂ f g H)] at h
+  have hs := TensorArrowComparison.complex_arrow_square k (B P) N
+    (ThreeVertexAlgebra.vertex (composition P) 1) (ThreeVertexAlgebra.vertex (composition P) 2)
+    (arrow12 P b) ((ThreeVertexAlgebra.directedSystem (composition P)).idem 1)
+    ((ThreeVertexAlgebra.directedSystem (composition P)).idem 2)
+    (CanonicalArrowCompatibility.arrow12_target P b)
+    (InducedRectification.total (ConcreteQuadraticDiagram.quadratic P) D₀ D₁ D₂ f g H)
+  erw [hs] at h
+  dsimp only [iota]
+  erw [original_iota1, original_iota2, Category.assoc]
+  exact h
+end LittleFinitistic.FullTensorRectification
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Rectification/GradedVertexAcyclic.lean b/lean/OAI/Algebra/Finitistic/Rectification/GradedVertexAcyclic.lean
new file mode 100644
index 0000000000000000000000000000000000000000..b615dea8100180eb87e1d4f163ad6c1dff9406dc
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Rectification/GradedVertexAcyclic.lean
@@ -0,0 +1,73 @@
+import OAI.Algebra.Finitistic.Rectification.SourceFiltrationComplex
+import OAI.Algebra.Finitistic.Rectification.ConcreteAdjacentGraded
+import OAI.Algebra.Finitistic.Rectification.ZeroLastColumn
+import OAI.Algebra.Finitistic.Rectification.ColumnProperties
+
+namespace OAI
+noncomputable section
+open CategoryTheory CategoryTheory.Limits HomologicalComplex CochainComplex
+namespace LittleFinitistic.GradedVertexAcyclic
+
+theorem acyclic_of_iso {C : Type*} [Category C] [Abelian C]
+    {X Y : CochainComplex C ℤ} (e : X ≅ Y) (hY : Y.Acyclic) : X.Acyclic := by
+  intro n
+  rw [exactAt_iff_isZero_homology]
+  exact ((homologyFunctor C (.up ℤ) n).mapIso e).isZero_iff.mpr (hY n).isZero_homology
+
+open ExternalTensor.Section4 ExternalTensor.Section4.SourceFiltration
+universe u
+variable {k : Type u} [Field k] {d t : ℕ} (P : QuadraticEncoding.Relations k d t)
+variable (D₀ D₁ D₂ : RightComplex (QuadraticEncoding.B P))
+variable (f : Fin (d+1) → (D₀ ⟶ D₁)) (g : Fin (d+1) → (D₁ ⟶ D₂))
+local notation "T" => QuadraticEncoding.B P
+local notation "s" => ConcreteQuadraticDiagram.quadratic P
+
+/-- The actual source-one quotient is the adjacent-arrow cone after taking vertex two. -/
+def grade1VertexIso :
+    (AdjacentArrowSum.vertexComplex (QuadraticEncoding.composition P) 2).obj
+      (Exactness.G1 s D₀ D₁ D₂ f g) ≅
+    mappingCone ((AdjacentArrowSum.vertexComplex (QuadraticEncoding.composition P) 2).map
+      (ConcreteAdjacentGraded.arrow12Sum P D₁)) :=
+  (AdjacentArrowSum.vertexComplex (QuadraticEncoding.composition P) 2).mapIso
+    (grade1ConeIso (Exactness.data s D₀ D₁ D₂ f g)).symm ≪≫
+  mappingCone.mapHomologicalComplexIso (pGrade1 (Exactness.data s D₀ D₁ D₂ f g))
+    (BimoduleVertex.functor k T (ThreeVertexAlgebra.vertex (QuadraticEncoding.composition P) 2))
+
+theorem grade1_vertex2_acyclic :
+    ((AdjacentArrowSum.vertexComplex (QuadraticEncoding.composition P) 2).obj
+      (Exactness.G1 s D₀ D₁ D₂ f g)).Acyclic :=
+  acyclic_of_iso (grade1VertexIso P D₀ D₁ D₂ f g)
+    (ConcreteAdjacentGraded.vertex2_cone_acyclic P D₁)
+
+/-- The relation column of the actual source-zero quotient vanishes at vertex one. -/
+theorem relationColumn_vertex1_zero :
+    IsZero ((AdjacentArrowSum.vertexComplex (QuadraticEncoding.composition P) 1).obj
+      (Exactness.data s D₀ D₁ D₂ f g).L₂) := by
+  let F := AdjacentArrowSum.vertexComplex (QuadraticEncoding.composition P) 1
+  change IsZero (F.obj (⨁ fun _ : RelationBasisCoefficients.RelationIndex P =>
+    (columnComplex k T (s).e₂).obj D₀))
+  apply (F.mapBiproduct _).isZero_iff.mpr
+  exact sum_isZero _ (fun _ =>
+    VertexColumnComplex.reverse_isZero (QuadraticEncoding.composition P) 1 2 (by decide) D₀)
+
+/-- The actual source-zero quotient at vertex one is the first adjacent-arrow cone. -/
+def grade0Vertex1Iso :
+    (AdjacentArrowSum.vertexComplex (QuadraticEncoding.composition P) 1).obj
+      (Exactness.G0 s D₀ D₁ D₂ f g) ≅
+    mappingCone ((AdjacentArrowSum.vertexComplex (QuadraticEncoding.composition P) 1).map
+      (ConcreteAdjacentGraded.arrow01Sum P D₀)) :=
+  ZeroLastColumn.mappedTotalIso (p0 (Exactness.data s D₀ D₁ D₂ f g))
+    (q0 (Exactness.data s D₀ D₁ D₂ f g)) (h0 (Exactness.data s D₀ D₁ D₂ f g))
+    (BimoduleVertex.functor k T (ThreeVertexAlgebra.vertex (QuadraticEncoding.composition P) 1))
+    (relationColumn_vertex1_zero P D₀ D₁ D₂ f g)
+
+theorem grade0_vertex1_acyclic :
+    ((AdjacentArrowSum.vertexComplex (QuadraticEncoding.composition P) 1).obj
+      (Exactness.G0 s D₀ D₁ D₂ f g)).Acyclic :=
+  acyclic_of_iso (grade0Vertex1Iso P D₀ D₁ D₂ f g)
+    (ConcreteAdjacentGraded.vertex1_cone_acyclic P D₀)
+end LittleFinitistic.GradedVertexAcyclic
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Rectification/InducedColumns.lean b/lean/OAI/Algebra/Finitistic/Rectification/InducedColumns.lean
new file mode 100644
index 0000000000000000000000000000000000000000..e61159fb3ea43dfb462d1364f239f35460e44ac5
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Rectification/InducedColumns.lean
@@ -0,0 +1,104 @@
+import OAI.Algebra.Finitistic.Rectification.ExternalTensor
+
+namespace OAI
+open scoped TensorProduct
+noncomputable section
+
+namespace ExternalTensor
+
+attribute [local instance] bimodule rightModule
+
+variable (k B : Type*) [Field k] [Ring B] [Algebra k B]
+
+/-- The actual principal left ideal B e, the image of right multiplication by e. -/
+def leftIdeal (e : B) : Submodule B B := (LinearMap.mulRight B e).range
+
+@[simp] theorem mem_leftIdeal (e x : B) : x ∈ leftIdeal B e ↔ ∃ b : B, b * e = x :=
+  Iff.rfl
+
+theorem leftIdeal_finiteDimensional [FiniteDimensional k B] (e : B) :
+    FiniteDimensional k (leftIdeal B e) :=
+  FiniteDimensional.of_injective ((leftIdeal B e).subtype.restrictScalars k)
+    Subtype.val_injective
+
+attribute [local instance] leftIdeal_finiteDimensional
+
+variable (N : Type*) [AddCommGroup N] [Module k N]
+  [Module Bᵐᵒᵖ N] [IsScalarTower k Bᵐᵒᵖ N]
+
+/-- The induced column in Section 4, with its external actions. -/
+abbrev Column (e : B) := (leftIdeal B e) ⊗[k] N
+
+theorem column_projective (e : B) [Module.Projective Bᵐᵒᵖ N] :
+    Module.Projective Bᵐᵒᵖ (Column k B N e) :=
+  projective_right k B (leftIdeal B e) N
+
+theorem column_finite_right [FiniteDimensional k B] (e : B)
+    [Module.Finite Bᵐᵒᵖ N] : Module.Finite Bᵐᵒᵖ (Column k B N e) :=
+  finite_right k B (leftIdeal B e) N
+
+theorem column_finiteDimensional [FiniteDimensional k B] (e : B)
+    [Module.Finite Bᵐᵒᵖ N] : FiniteDimensional k (Column k B N e) := by
+  let : Module.Finite k N := Module.Finite.trans Bᵐᵒᵖ N
+  exact finiteDimensional k (leftIdeal B e) N
+
+/-- The full induced-column assertion required for each summand of L'_0,L'_1,L'_2. -/
+theorem induced_column [FiniteDimensional k B] (e : B)
+    [Module.Finite Bᵐᵒᵖ N] [Module.Projective Bᵐᵒᵖ N] :
+    FiniteDimensional k (Column k B N e) ∧
+      Module.Finite Bᵐᵒᵖ (Column k B N e) ∧
+      Module.Projective Bᵐᵒᵖ (Column k B N e) :=
+  ⟨column_finiteDimensional k B N e, column_finite_right k B N e,
+    column_projective k B N e⟩
+
+
+/-- The distinguished generator e of the principal left ideal. -/
+def generator (e : B) : leftIdeal B e := ⟨e, ⟨1, one_mul e⟩⟩
+
+/-- The right-linear insertion used in the vertex maps iota_i. -/
+def columnInclusion (e : B) : N →ₗ[Bᵐᵒᵖ] Column k B N e where
+  toFun n := generator B e ⊗ₜ[k] n
+  map_add' first second := TensorProduct.tmul_add _ first second
+  map_smul' c n := (right_smul_tmul k B (leftIdeal B e) N c (generator B e) n).symm
+
+@[simp] theorem columnInclusion_apply (e : B) (n : N) :
+    columnInclusion k B N e n = generator B e ⊗ₜ[k] n := rfl
+
+variable {B}
+/-- Right multiplication by a path a: i→j maps B e_j to B e_i.
+Only the relation a e_i = a is needed for membership in the target ideal. -/
+def pathMap (ei ej a : B) (ha : a * ei = a) :
+    leftIdeal B ej →ₗ[B] leftIdeal B ei where
+  toFun c := ⟨c.val * a, ⟨c.val * a, by simp [LinearMap.mulRight_apply, mul_assoc, ha]⟩⟩
+  map_add' c d := Subtype.ext (add_mul c.val d.val a)
+  map_smul' b c := Subtype.ext (mul_assoc b c.val a)
+
+@[simp] theorem pathMap_apply (ei ej a : B) (ha : a * ei = a) (c : leftIdeal B ej) :
+    (pathMap ei ej a ha c : B) = (c : B) * a := rfl
+
+variable {N}
+/-- The path-multiplication component c tensor n ↦ ca tensor n of the rectification maps. -/
+def columnPath (ei ej a : B) (ha : a * ei = a) :
+    Column k B N ej →ₗ[B ⊗[k] Bᵐᵒᵖ] Column k B N ei :=
+  map (k := k) (pathMap ei ej a ha) LinearMap.id
+
+@[simp] theorem columnPath_tmul (ei ej a : B) (ha : a * ei = a)
+    (c : leftIdeal B ej) (n : N) :
+    columnPath k ei ej a ha (c ⊗ₜ[k] n) = (pathMap ei ej a ha c) ⊗ₜ[k] n := rfl
+
+variable {N' : Type*} [AddCommGroup N'] [Module k N']
+  [Module Bᵐᵒᵖ N'] [IsScalarTower k Bᵐᵒᵖ N']
+
+/-- The differential or relation-homotopy component c tensor n ↦ c tensor f(n). -/
+def columnMap (e : B) (f : N →ₗ[Bᵐᵒᵖ] N') :
+    Column k B N e →ₗ[B ⊗[k] Bᵐᵒᵖ] Column k B N' e :=
+  map (k := k) LinearMap.id f
+
+@[simp] theorem columnMap_tmul (e : B) (f : N →ₗ[Bᵐᵒᵖ] N')
+    (c : leftIdeal B e) (n : N) :
+    columnMap k e f (c ⊗ₜ[k] n) = c ⊗ₜ[k] f n := rfl
+end ExternalTensor
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Rectification/InducedDerivedFunctor.lean b/lean/OAI/Algebra/Finitistic/Rectification/InducedDerivedFunctor.lean
new file mode 100644
index 0000000000000000000000000000000000000000..eb8d119d770f8311d71dc9c3f78b8970960012f0
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Rectification/InducedDerivedFunctor.lean
@@ -0,0 +1,52 @@
+import OAI.Algebra.Finitistic.Bimodule.BimoduleDerivedInterval
+
+namespace OAI
+noncomputable section
+open CategoryTheory CategoryTheory.Limits
+namespace LittleFinitistic.BimoduleTotal
+open ExternalTensor.Section4
+universe u
+variable {k B : Type u} [Field k] [Ring B] [Algebra k B]
+variable {A J R : Type} [Fintype A] [Fintype J] [Fintype R]
+variable (s : Quadratic k B (A := A) (J := J) (R := R))
+variable (D₀ D₁ D₂ : RightComplex B)
+variable (f : A → (D₀ ⟶ D₁)) (g : J → (D₁ ⟶ D₂))
+variable (H : ∀ r, Homotopy (relationMap s D₀ D₁ D₂ f g r) 0)
+variable (h₀ : ∀ n, Module.Projective Bᵐᵒᵖ (D₀.X n))
+variable (h₁ : ∀ n, Module.Projective Bᵐᵒᵖ (D₁.X n))
+variable (h₂ : ∀ n, Module.Projective Bᵐᵒᵖ (D₂.X n))
+
+include h₀ h₁ h₂ in
+/-- The fixed native rectification supplies the precise projectivity required by the frozen total theorem. -/
+theorem induced_term_projective (n : ℤ) : Module.Projective Bᵐᵒᵖ
+    (ComplexTensor.rightTerm k B (right k B
+      (InducedRectification.total s D₀ D₁ D₂ f g H)) n) := by
+  let := InducedRectification.rightTotal_projective s D₀ D₁ D₂ f g H h₀ h₁ h₂ n
+  exact inferInstanceAs (Module.Projective Bᵐᵒᵖ
+    ((InducedRectification.rightTotal s D₀ D₁ D₂ f g H).X n))
+
+variable [HasDerivedCategory.{u+1} (ModuleCat.{u} B)]
+
+/-- Native P is fixed before the arbitrary derived input is supplied. -/
+def inducedDerived (lo hi : ℤ) :
+    DerivedCategory (ModuleCat.{u} B) ⥤ DerivedCategory (ModuleCat.{u} B) := by
+  letI : ∀ n, Module.Projective Bᵐᵒᵖ
+      (ComplexTensor.rightTerm k B (right k B (InducedRectification.total s D₀ D₁ D₂ f g H)) n) :=
+    fun n => induced_term_projective s D₀ D₁ D₂ f g H h₀ h₁ h₂ n
+  exact derivedInterval k B (InducedRectification.total s D₀ D₁ D₂ f g H) (lo-2) hi
+
+omit [HasDerivedCategory.{u+1} (ModuleCat.{u} B)] in
+/-- The selected interval contains the complete actual native P whenever the source complexes have these bounds. -/
+theorem induced_complete (lo hi : ℤ)
+    (b₀ : ∀ n, n < lo ∨ hi < n → IsZero (D₀.X n))
+    (b₁ : ∀ n, n < lo ∨ hi < n → IsZero (D₁.X n))
+    (b₂ : ∀ n, n < lo ∨ hi < n → IsZero (D₂.X n))
+    (n : ℤ) (hn : ∀ i, intervalDegrees (lo-2) hi i ≠ n) :
+    IsZero ((InducedRectification.total s D₀ D₁ D₂ f g H).X n) :=
+  outside_interval_isZero k B _ (lo-2) hi
+    (InducedRectification.total_bounded s D₀ D₁ D₂ f g H lo hi b₀ b₁ b₂) n hn
+end LittleFinitistic.BimoduleTotal
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Rectification/InducedDiagram.lean b/lean/OAI/Algebra/Finitistic/Rectification/InducedDiagram.lean
new file mode 100644
index 0000000000000000000000000000000000000000..c73c54f88f8c6efe5eb261b63d535785687a43d1
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Rectification/InducedDiagram.lean
@@ -0,0 +1,185 @@
+import OAI.Algebra.Finitistic.Rectification.DiagramAssembly
+import Mathlib.CategoryTheory.Preadditive.Biproducts
+
+namespace OAI
+open CategoryTheory CategoryTheory.Limits HomologicalComplex
+open scoped TensorProduct ModuleCat.Algebra
+noncomputable section
+namespace ExternalTensor.Section4
+universe u
+variable (k B : Type u) [Field k] [Ring B] [Algebra k B]
+instance biFiniteBiproducts : HasFiniteBiproducts (BiComplex k B) :=
+  HasFiniteBiproducts.of_hasFiniteProducts
+instance biBinaryBiproducts : HasBinaryBiproducts (BiComplex k B) :=
+  HasBinaryBiproducts.of_hasBinaryProducts
+
+private theorem smul_comp_add {C : Type*} [Category C] [Preadditive C] [Linear k C]
+    {X Y₁ Y₂ Z : C} (c : k) (f₁ : X ⟶ Y₁) (f₂ : Y₁ ⟶ Z)
+    (g₁ : X ⟶ Y₂) (g₂ : Y₂ ⟶ Z) :
+    (c • f₁) ≫ f₂ + (c • g₁) ≫ g₂ = c • (f₁ ≫ f₂ + g₁ ≫ g₂) := by
+  simp only [Linear.smul_comp, smul_add]
+
+private def framedMapHomotopy {C E : Type*} [Category C] [Preadditive C]
+    [Category E] [Preadditive E] (G : C ⥤ E) [G.Additive]
+    {X Y : CochainComplex C ℤ} {P Q : CochainComplex E ℤ}
+    (f : X ⟶ Y) (H : Homotopy f 0)
+    (a : P ⟶ (G.mapHomologicalComplex (.up ℤ)).obj X)
+    (b : (G.mapHomologicalComplex (.up ℤ)).obj Y ⟶ Q) :
+    Homotopy (a ≫ (G.mapHomologicalComplex (.up ℤ)).map f ≫ b) 0 where
+  hom i j := a.f i ≫ G.map (H.hom i j) ≫ b.f j
+  zero i j hij := by rw [H.zero i j hij, G.map_zero, zero_comp, comp_zero]
+  comm i := by
+    let h := ((G.mapHomotopy H).compLeft a).compRight b
+    simpa [h, Category.assoc, dNext, prevD] using h.comm i
+
+variable {A J R : Type} [Fintype A] [Fintype J] [Fintype R]
+
+/-- Only the finite quadratic diagram data used in the column calculation.
+These equations hold for Section 3's arrows in e_j B e_i and relation basis.
+No independence of relations is needed for the stronger assembly statement. -/
+structure Quadratic where
+  e₀ : B
+  e₁ : B
+  e₂ : B
+  a : A → B
+  b : J → B
+  ha : ∀ i, a i * e₀ = a i
+  hb : ∀ j, b j * e₁ = b j
+  coeff : R → A → J → k
+  relation : ∀ r, ∑ i, ∑ j, coeff r i j • (b j * a i) = 0
+
+variable {k B}
+variable (s : Quadratic k B (A := A) (J := J) (R := R))
+variable (D₀ D₁ D₂ : RightComplex B)
+variable (f : A → (D₀ ⟶ D₁)) (g : J → (D₁ ⟶ D₂))
+
+/-- The actual finite relation evaluated on the chosen chain maps. -/
+def relationMap (r : R) : D₀ ⟶ D₂ := ∑ a, ∑ b, s.coeff r a b • (f a ≫ g b)
+
+/-- All columns and components are induced from actual modules, paths and maps. -/
+def inducedData : AssemblyData (C := BiComplex k B) (A := A) (J := J) (R := R) where
+  V₀ := (columnComplex k B s.e₀).obj D₀
+  V₁ := (columnComplex k B s.e₁).obj D₁
+  V₂ := (columnComplex k B s.e₂).obj D₂
+  U _ := (columnComplex k B s.e₁).obj D₀
+  V _ := (columnComplex k B s.e₂).obj D₁
+  W _ := (columnComplex k B s.e₂).obj D₀
+  pa₀ a := path k B s.e₀ s.e₁ (s.a a) (s.ha a) D₀
+  pa₁ a := (columnComplex k B s.e₁).map (f a)
+  pb₁ b := path k B s.e₁ s.e₂ (s.b b) (s.hb b) D₁
+  pb₂ b := (columnComplex k B s.e₂).map (g b)
+  qa r a b := s.coeff r a b • path k B s.e₁ s.e₂ (s.b b) (s.hb b) D₀
+  qb r a b := s.coeff r a b • (columnComplex k B s.e₂).map (f a)
+  rel r := (columnComplex k B s.e₂).map (relationMap s D₀ D₁ D₂ f g r)
+  middle r a b := by simp [Linear.smul_comp]
+  first r := by
+    simpa only [Linear.smul_comp] using
+      paths_relation k B s.e₀ s.e₁ s.e₂ s.a s.b s.ha s.hb (s.coeff r) (s.relation r) D₀
+  last r := by
+    simp only [Linear.smul_comp, relationMap, Functor.map_sum, Functor.map_smul,
+      Functor.map_comp]
+
+abbrev L0Prime := (inducedData s D₀ D₁ D₂ f g).L₀
+abbrev L1Prime := (inducedData s D₀ D₁ D₂ f g).L₁
+abbrev L2Prime := (inducedData s D₀ D₁ D₂ f g).L₂
+abbrev p := (inducedData s D₀ D₁ D₂ f g).p
+abbrev q := (inducedData s D₀ D₁ D₂ f g).q
+
+omit [Fintype R] in
+@[reassoc] theorem p_arrow01 (a : A) :
+    biproduct.ι (inducedData s D₀ D₁ D₂ f g).U a ≫ biprod.inl ≫
+      p s D₀ D₁ D₂ f g =
+    path k B s.e₀ s.e₁ (s.a a) (s.ha a) D₀ ≫ (inducedData s D₀ D₁ D₂ f g).in₀ -
+      (columnComplex k B s.e₁).map (f a) ≫ (inducedData s D₀ D₁ D₂ f g).in₁ := by
+  simp only [p, AssemblyData.p, biprod.inl_desc, biproduct.ι_desc]
+  rfl
+
+omit [Fintype R] in
+@[reassoc] theorem p_arrow12 (b : J) :
+    biproduct.ι (inducedData s D₀ D₁ D₂ f g).V b ≫ biprod.inr ≫
+      p s D₀ D₁ D₂ f g =
+    path k B s.e₁ s.e₂ (s.b b) (s.hb b) D₁ ≫ (inducedData s D₀ D₁ D₂ f g).in₁ -
+      (columnComplex k B s.e₂).map (g b) ≫ (inducedData s D₀ D₁ D₂ f g).in₂ := by
+  simp only [p, AssemblyData.p, biprod.inr_desc, biproduct.ι_desc]
+  rfl
+
+theorem q_relation (r : R) :
+    biproduct.ι (inducedData s D₀ D₁ D₂ f g).W r ≫ q s D₀ D₁ D₂ f g =
+    ∑ a, ∑ b, s.coeff r a b •
+      (path k B s.e₁ s.e₂ (s.b b) (s.hb b) D₀ ≫
+        biproduct.ι (inducedData s D₀ D₁ D₂ f g).U a ≫ biprod.inl +
+       (columnComplex k B s.e₂).map (f a) ≫
+        biproduct.ι (inducedData s D₀ D₁ D₂ f g).V b ≫ biprod.inr) := by
+  simp only [q, AssemblyData.q, biproduct.ι_desc]
+  apply Finset.sum_congr rfl
+  intro a _
+  apply Finset.sum_congr rfl
+  intro b _
+  exact smul_comp_add k (s.coeff r a b) _ _ _ _
+
+variable (H : ∀ r, Homotopy (relationMap s D₀ D₁ D₂ f g r) 0)
+
+/-- Positive degree-minus-one h of the manuscript, packaged with its equation. -/
+def positiveHomotopy :
+    Homotopy (biproduct.desc fun r =>
+      (inducedData s D₀ D₁ D₂ f g).rel r ≫ (inducedData s D₀ D₁ D₂ f g).in₂) 0 := by
+  classical
+  let t := inducedData s D₀ D₁ D₂ f g
+  let F (r : R) := biproduct.π t.W r ≫ t.rel r ≫ t.in₂
+  let hh (r : R) : Homotopy (F r) 0 :=
+    framedMapHomotopy (columnFunctor k B s.e₂) (relationMap s D₀ D₁ D₂ f g r)
+      (H r) (biproduct.π t.W r) t.in₂
+  have hs := AssemblyData.sumHomotopy F hh
+  have heq : (∑ r, F r) = biproduct.desc (fun r => t.rel r ≫ t.in₂) := by
+    exact biproduct.desc_eq.symm
+  refine { hom := hs.hom, zero := hs.zero, comm := ?_ }
+  intro i
+  rw [← heq]
+  exact hs.comm i
+
+/-- The sign-correct null-homotopy required by RectificationTotal.total. -/
+def nullHomotopy : Homotopy (q s D₀ D₁ D₂ f g ≫ p s D₀ D₁ D₂ f g) 0 := by
+  rw [AssemblyData.composite]
+  simpa using (positiveHomotopy s D₀ D₁ D₂ f g H).smul (-1 : k)
+
+/-- The manuscript h, with zero components away from degree minus one. -/
+def h (i j : ℤ) := (positiveHomotopy s D₀ D₁ D₂ f g H).hom i j
+
+theorem h_formula (i j : ℤ) : h s D₀ D₁ D₂ f g H i j =
+    ∑ r, (biproduct.π (inducedData s D₀ D₁ D₂ f g).W r).f i ≫
+      (columnFunctor k B s.e₂).map ((H r).hom i j) ≫
+      (inducedData s D₀ D₁ D₂ f g).in₂.f j := rfl
+
+theorem h_relation (r : R) (i j : ℤ) :
+    (biproduct.ι (inducedData s D₀ D₁ D₂ f g).W r).f i ≫ h s D₀ D₁ D₂ f g H i j =
+    (columnFunctor k B s.e₂).map ((H r).hom i j) ≫
+      (inducedData s D₀ D₁ D₂ f g).in₂.f j := by
+  classical
+  simp only [h_formula, Preadditive.comp_sum, ← Category.assoc, ← comp_f]
+  simp only [biproduct.ι_π]
+  rw [Finset.sum_eq_single r]
+  · simp
+    rfl
+  · intro x _ hxr
+    simp [Ne.symm hxr]
+  · simp
+
+theorem h_shape (i j : ℤ) (hij : j + 1 ≠ i) : h s D₀ D₁ D₂ f g H i j = 0 :=
+  (positiveHomotopy s D₀ D₁ D₂ f g H).zero i j hij
+
+/-- Precisely the remaining off-diagonal entry in the manuscript's d_P squared. -/
+theorem square (n : ℤ) :
+    h s D₀ D₁ D₂ f g H n (n-1) ≫ (L0Prime s D₀ D₁ D₂ f g).d (n-1) n +
+    (q s D₀ D₁ D₂ f g ≫ p s D₀ D₁ D₂ f g).f n +
+    (L2Prime s D₀ D₁ D₂ f g).d n (n+1) ≫ h s D₀ D₁ D₂ f g H (n+1) n = 0 := by
+  have hh := (positiveHomotopy s D₀ D₁ D₂ f g H).comm n
+  rw [dNext_eq _ (show (ComplexShape.up ℤ).Rel n (n+1) by simp),
+    prevD_eq _ (show (ComplexShape.up ℤ).Rel (n-1) n by simp)] at hh
+  rw [AssemblyData.composite, neg_f_apply, hh]
+  dsimp [h, L0Prime, L2Prime]
+  abel
+end ExternalTensor.Section4
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Rectification/InducedRectification.lean b/lean/OAI/Algebra/Finitistic/Rectification/InducedRectification.lean
new file mode 100644
index 0000000000000000000000000000000000000000..2653a25d1ebc7e16e18d5dcf28e1917ce429336f
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Rectification/InducedRectification.lean
@@ -0,0 +1,60 @@
+import Mathlib.Algebra.Category.ModuleCat.Biproducts
+import OAI.Algebra.Finitistic.Rectification.InducedDiagram
+import OAI.Algebra.Finitistic.Rectification.ColumnProperties
+import OAI.Algebra.Finitistic.Rectification.RectificationTotal
+
+namespace OAI
+noncomputable section
+open CategoryTheory CategoryTheory.Limits
+namespace LittleFinitistic.InducedRectification
+open ExternalTensor.Section4
+universe u
+variable {k B : Type u} [Field k] [Ring B] [Algebra k B]
+variable {A J R : Type} [Fintype A] [Fintype J] [Fintype R]
+variable (s : Quadratic k B (A := A) (J := J) (R := R))
+variable (D₀ D₁ D₂ : RightComplex B)
+variable (f : A → (D₀ ⟶ D₁)) (g : J → (D₁ ⟶ D₂))
+variable (H : ∀ r, Homotopy (relationMap s D₀ D₁ D₂ f g r) 0)
+
+/-- The actual three-column induced bimodule complex of Section 4. -/
+def total : BiComplex k B :=
+  RectificationTotal.total (p s D₀ D₁ D₂ f g) (q s D₀ D₁ D₂ f g)
+    (nullHomotopy s D₀ D₁ D₂ f g H)
+
+/-- Its right-module restriction, retaining the original bimodule construction. -/
+def rightTotal : RightComplex B :=
+  ((forgetRight k B).mapHomologicalComplex (.up ℤ)).obj (total s D₀ D₁ D₂ f g H)
+
+theorem total_bounded (lo hi : ℤ)
+    (h₀ : ∀ n, n < lo ∨ hi < n → IsZero (D₀.X n))
+    (h₁ : ∀ n, n < lo ∨ hi < n → IsZero (D₁.X n))
+    (h₂ : ∀ n, n < lo ∨ hi < n → IsZero (D₂.X n)) :
+    ∀ n, n < lo-2 ∨ hi < n → IsZero ((total s D₀ D₁ D₂ f g H).X n) := by
+  have hc := columns_bounded s D₀ D₁ D₂ f g lo hi h₀ h₁ h₂
+  exact RectificationTotal.total_bounded _ _ _ lo hi
+    (fun n hn => (hc n hn).1) (fun n hn => (hc n hn).2.1)
+    (fun n hn => (hc n hn).2.2)
+
+/-- Termwise projectivity holds for the actual right restriction of the total. -/
+theorem rightTotal_projective
+    (h₀ : ∀ n, Module.Projective Bᵐᵒᵖ (D₀.X n))
+    (h₁ : ∀ n, Module.Projective Bᵐᵒᵖ (D₁.X n))
+    (h₂ : ∀ n, Module.Projective Bᵐᵒᵖ (D₂.X n)) :
+    ∀ n, Projective ((rightTotal s D₀ D₁ D₂ f g H).X n) := by
+  have hc := columns_right_projective s D₀ D₁ D₂ f g h₀ h₁ h₂
+  exact RectificationTotal.total_projective_after _ _ _ (forgetRight k B)
+    (fun n => (hc n).1) (fun n => (hc n).2.1) (fun n => (hc n).2.2)
+
+/-- The entire zero column has its original chain inclusion. -/
+def inclusion : L0Prime s D₀ D₁ D₂ f g ⟶ total s D₀ D₁ D₂ f g H :=
+  RectificationTotal.inclusion _ _ _
+
+/-- The prescribed first boundary becomes null-homotopic in the actual total. -/
+def boundaryHomotopy : Homotopy
+    (p s D₀ D₁ D₂ f g ≫ inclusion s D₀ D₁ D₂ f g H) 0 :=
+  RectificationTotal.boundaryHomotopy _ _ _
+end LittleFinitistic.InducedRectification
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Rectification/LeftVertexHomology.lean b/lean/OAI/Algebra/Finitistic/Rectification/LeftVertexHomology.lean
new file mode 100644
index 0000000000000000000000000000000000000000..baa129b63ef135ab0698e581603110d76cd8d1d2
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Rectification/LeftVertexHomology.lean
@@ -0,0 +1,74 @@
+import OAI.Algebra.Finitistic.Rectification.VertexHomology
+import OAI.Algebra.Finitistic.Rectification.VertexDecomposition
+
+namespace OAI
+noncomputable section
+open CategoryTheory HomologicalComplex
+namespace LittleFinitistic.LeftVertexHomology
+universe u
+variable (k B : Type u) [Field k] [Ring B] [Algebra k B]
+
+lemma scalar_commute (e : B) (c : k) : e * algebraMap k B c = algebraMap k B c * e :=
+  (Algebra.commutes c e).symm
+
+/-- The actual left vertex functor from B-modules to k-vector spaces. -/
+abbrev vertex (e : B) : ModuleCat.{u} B ⥤ ModuleCat.{u} k :=
+  VertexFunctor.functor (algebraMap k B) e (scalar_commute k B e)
+
+/-- Arrow action is a natural transformation between the actual vertex functors. -/
+def arrow (ei ej a : B) (ha : ej*a=a) : vertex k B ei ⟶ vertex k B ej where
+  app M := ModuleCat.ofHom {
+    toFun := fun x => ⟨a • (x.val : M), by
+      rw [VertexFunctor.mem_fixed]
+      rw [← mul_smul, ha]⟩
+    map_add' := fun x y => Subtype.ext (smul_add _ _ _)
+    map_smul' := fun c x => by
+      apply Subtype.ext
+      change a • (algebraMap k B c • (x.val : M)) =
+        algebraMap k B c • (a • (x.val : M))
+      rw [← mul_smul, ← mul_smul, scalar_commute] }
+  naturality M M' f := by
+    apply ModuleCat.hom_ext
+    apply LinearMap.ext
+    intro x
+    apply Subtype.ext
+    exact (f.hom.map_smul a x.val).symm
+
+instance scalarTower (M : ModuleCat.{u} B) :
+    IsScalarTower k B ((ModuleCat.restrictScalars (algebraMap k B)).obj M) :=
+  IsScalarTower.of_algebraMap_smul (fun _ _ => rfl)
+
+/-- Identify the vertex functor with the actual fixed subspace of scalar restriction. -/
+def spaceEquiv (e : B) (M : ModuleCat.{u} B) :
+    (vertex k B e).obj M ≃ₗ[k]
+      IdempotentTensor.leftSpace (k := k) e ((ModuleCat.restrictScalars (algebraMap k B)).obj M) where
+  toFun x := ⟨x.val, (VertexFunctor.mem_fixed _ _ _ M x.val).1 x.property⟩
+  invFun x := ⟨x.val, (VertexFunctor.mem_fixed _ _ _ M x.val).2 x.property⟩
+  left_inv _ := rfl
+  right_inv _ := rfl
+  map_add' _ _ := rfl
+  map_smul' _ _ := rfl
+
+/-- Actual vertex homology, identified with the actual subspace of module homology. -/
+def homologyEquiv (e : B) (he : e*e=e)
+    (X : CochainComplex (ModuleCat.{u} B) ℤ) (n : ℤ) :
+    (((vertex k B e).mapHomologicalComplex (.up ℤ)).obj X).homology n ≃ₗ[k]
+      IdempotentTensor.leftSpace (k := k) e
+        ((ModuleCat.restrictScalars (algebraMap k B)).obj (X.homology n)) :=
+  (VertexHomology.iso (algebraMap k B) e he (scalar_commute k B e) X n).toLinearEquiv.trans
+    (spaceEquiv k B e (X.homology n))
+
+/-- Cohomology comparison retains the original arrow action, not only dimensions. -/
+theorem arrow_homology (ei ej a : B) (hi : ei*ei=ei) (hj : ej*ej=ej) (ha : ej*a=a)
+    (X : CochainComplex (ModuleCat.{u} B) ℤ) (n : ℤ) :
+    homologyMap ((NatTrans.mapHomologicalComplex (arrow k B ei ej a ha) (.up ℤ)).app X) n ≫
+      (VertexHomology.iso (algebraMap k B) ej hj (scalar_commute k B ej) X n).hom =
+    (VertexHomology.iso (algebraMap k B) ei hi (scalar_commute k B ei) X n).hom ≫
+      (arrow k B ei ej a ha).app (X.homology n) :=
+  VertexHomology.natural (algebraMap k B) ei hi (scalar_commute k B ei)
+    ej hj (scalar_commute k B ej) _ X n
+end LittleFinitistic.LeftVertexHomology
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Rectification/RectificationAcyclic.lean b/lean/OAI/Algebra/Finitistic/Rectification/RectificationAcyclic.lean
new file mode 100644
index 0000000000000000000000000000000000000000..9e8ba35ddd387e79ffb0b0d2564fa0f2b5d7e4e0
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Rectification/RectificationAcyclic.lean
@@ -0,0 +1,115 @@
+import Mathlib.Algebra.Homology.DerivedCategory.KProjective
+import Mathlib.Algebra.Homology.HomotopyCategory.ShortExact
+import OAI.Algebra.Finitistic.Rectification.RectificationTotal
+
+namespace OAI
+
+namespace LittleFinitistic.RectificationAcyclic
+open CategoryTheory CategoryTheory.Limits HomologicalComplex CochainComplex
+
+variable {C : Type*} [Category C] [Abelian C]
+
+/-- The ordinary cone of a quasi-isomorphism is acyclic. -/
+theorem cone_acyclic {K L : CochainComplex C ℤ} (f : K ⟶ L) [QuasiIso f] :
+    (mappingCone f).Acyclic := by
+  let P := HomotopyCategory.subcategoryAcyclic C
+  have hf : P.trW ((HomotopyCategory.quotient C (.up ℤ)).map f) := by
+    rw [← HomotopyCategory.quasiIso_eq_trW_subcategoryAcyclic,
+      HomotopyCategory.quotient_map_mem_quasiIso_iff,HomologicalComplex.mem_quasiIso_iff]
+    infer_instance
+  have hT := HomotopyCategory.mappingCone_triangleh_distinguished f
+  have hz := (P.trW_iff_of_distinguished (mappingCone.triangleh f) hT).1 hf
+  exact (HomotopyCategory.quotient_obj_mem_subcategoryAcyclic_iff_acyclic _).1 hz
+
+/-- The total of a strict short exact sequence of complexes is acyclic. This is
+applied to the associated graded source-index pieces in rectification. -/
+theorem short_exact_total_acyclic (S : ShortComplex (CochainComplex C ℤ))
+    (hS : S.ShortExact) :
+    (RectificationTotal.total S.g S.f (Homotopy.ofEq S.zero)).Acyclic := by
+  have he : RectificationTotal.rectifyingMap S.g S.f (Homotopy.ofEq S.zero) =
+      mappingCone.descShortComplex S := by
+    simp only [RectificationTotal.rectifyingMap,CochainComplex.HomComplex.Cochain.ofHomotopy_ofEq,
+      mappingCone.descShortComplex]
+  change (mappingCone (RectificationTotal.rectifyingMap S.g S.f (Homotopy.ofEq S.zero))).Acyclic
+  rw [he]
+  let := mappingCone.quasiIso_descShortComplex hS
+  exact cone_acyclic _
+
+/-- Bounded-above acyclic complexes of projectives admit an actual contraction. -/
+noncomputable def contractBoundedProjective (K : CochainComplex C ℤ) (hi : ℤ)
+    [K.IsStrictlyLE hi] [∀ i, Projective (K.X i)] (hK : K.Acyclic) :
+    Homotopy (𝟙 K) 0 := by
+  letI := CochainComplex.isKProjective_of_projective K hi
+  exact CochainComplex.IsKProjective.homotopyZero (𝟙 K) hK
+
+/-- A quasi-isomorphism between bounded-above projective complexes has an actual
+chain-map inverse up to specified homotopies, retaining the given forward map. -/
+theorem bounded_projective_homotopy_inverse {K L : CochainComplex C ℤ}
+    (f : K ⟶ L) [QuasiIso f] (hi : ℤ) [K.IsStrictlyLE hi] [L.IsStrictlyLE hi]
+    [∀ i, Projective (K.X i)] [∀ i, Projective (L.X i)] :
+    ∃ g : L ⟶ K, Nonempty (Homotopy (f ≫ g) (𝟙 K)) ∧
+      Nonempty (Homotopy (g ≫ f) (𝟙 L)) := by
+  classical
+  have : (mappingCone f).IsStrictlyLE hi := by
+    rw [isStrictlyLE_iff]
+    intro i hi'
+    rw [mappingCone.isZero_X_iff]
+    exact ⟨K.isZero_of_isStrictlyLE hi _ (by omega),L.isZero_of_isStrictlyLE hi _ hi'⟩
+  have (degree : ℤ) : Projective ((mappingCone f).X degree) := by
+    apply Projective.of_iso (homotopyCofiber.XIsoBiprod f degree (degree+1) (by simp)).symm
+    infer_instance
+  let q := HomotopyCategory.quotient C (.up ℤ)
+  have hzero : IsZero (q.obj (mappingCone f)) :=
+    (HomotopyCategory.isZero_quotient_obj_iff _).2
+      ⟨contractBoundedProjective _ hi (cone_acyclic f)⟩
+  have : IsIso (q.map f) :=
+    ((mappingCone.triangleh f).isZero₃_iff_isIso₁
+      (HomotopyCategory.mappingCone_triangleh_distinguished f)).1 hzero
+  let g := q.preimage (inv (q.map f))
+  have hg : q.map g = inv (q.map f) := q.map_preimage _
+  refine ⟨g,⟨HomotopyCategory.homotopyOfEq _ _ ?_⟩,
+    ⟨HomotopyCategory.homotopyOfEq _ _ ?_⟩⟩
+  · change q.map (f ≫ g) = q.map (𝟙 K)
+    rw [Functor.map_comp,hg,IsIso.hom_inv_id,q.map_id]
+  · change q.map (g ≫ f) = q.map (𝟙 L)
+    rw [Functor.map_comp,hg,IsIso.inv_hom_id,q.map_id]
+
+/-- A finite decreasing filtration with acyclic successive quotients is acyclic.
+The hypotheses are actual short exact sequences of complexes. -/
+theorem finite_exact_filtration_acyclic (n : ℕ)
+    (F G : ℕ → CochainComplex C ℤ)
+    (u : ∀ i, F (i+1) ⟶ F i) (v : ∀ i, F i ⟶ G i)
+    (huv : ∀ i, u i ≫ v i = 0)
+    (hseq : ∀ i, i < n → (ShortComplex.mk (u i) (v i) (huv i)).ShortExact)
+    (hG : ∀ i, i < n → (G i).Acyclic) (hn : (F n).Acyclic) :
+    (F 0).Acyclic := by
+  apply Nat.decreasingInduction (motive := fun i _ => (F i).Acyclic) ?_ hn (Nat.zero_le n)
+  intro i hi hnext
+  exact (hseq i hi).acyclic_X₂ hnext (hG i hi)
+
+/-- A short exact inclusion with acyclic quotient is a quasi-isomorphism. -/
+theorem quasiIso_of_acyclic_quotient (S : ShortComplex (CochainComplex C ℤ))
+    (hS : S.ShortExact) (hQ : S.X₃.Acyclic) : QuasiIso S.f := by
+  rw [quasiIso_iff]
+  intro i
+  rw [quasiIsoAt_iff_isIso_homologyMap]
+  have : Mono (HomologicalComplex.homologyMap S.f i) :=
+    (hS.homology_exact₁ (i-1) i (by change i-1+1=i; omega)).mono_g
+      ((hQ (i-1)).isZero_homology.eq_of_src _ _)
+  have : Epi (HomologicalComplex.homologyMap S.f i) :=
+    (hS.homology_exact₂ i).epi_f ((hQ i).isZero_homology.eq_of_tgt _ _)
+  exact isIso_of_mono_of_epi _
+
+/-- The given inclusion, rather than an unspecified replacement, has an actual
+homotopy inverse once its quotient is proved acyclic by the finite filtration. -/
+theorem inclusion_homotopy_inverse (S : ShortComplex (CochainComplex C ℤ))
+    (hS : S.ShortExact) (hQ : S.X₃.Acyclic) (hi : ℤ)
+    [S.X₁.IsStrictlyLE hi] [S.X₂.IsStrictlyLE hi]
+    [∀ i, Projective (S.X₁.X i)] [∀ i, Projective (S.X₂.X i)] :
+    ∃ g : S.X₂ ⟶ S.X₁, Nonempty (Homotopy (S.f ≫ g) (𝟙 S.X₁)) ∧
+      Nonempty (Homotopy (g ≫ S.f) (𝟙 S.X₂)) := by
+  let := quasiIso_of_acyclic_quotient S hS hQ
+  exact bounded_projective_homotopy_inverse S.f hi
+end LittleFinitistic.RectificationAcyclic
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Rectification/RectificationLemma.lean b/lean/OAI/Algebra/Finitistic/Rectification/RectificationLemma.lean
new file mode 100644
index 0000000000000000000000000000000000000000..0596b82d89780d6ad9d8a565006605f5511648d0
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Rectification/RectificationLemma.lean
@@ -0,0 +1,63 @@
+import OAI.Algebra.Finitistic.Rectification.CanonicalArrowCompatibility
+import OAI.Algebra.Finitistic.Rectification.TotalFinite
+
+namespace OAI
+noncomputable section
+open CategoryTheory CategoryTheory.Limits HomologicalComplex
+namespace LittleFinitistic.RectificationLemma
+open ExternalTensor.Section4 QuadraticEncoding CanonicalArrowCompatibility
+universe u
+variable {k : Type u} [Field k] {d t : ℕ} (P : Relations k d t)
+variable (D₀ D₁ D₂ : RightComplex (B P))
+variable (f : Fin (d+1) → (D₀ ⟶ D₁)) (g : Fin (d+1) → (D₁ ⟶ D₂))
+variable (H : ∀ r, Homotopy (relationMap (ConcreteQuadraticDiagram.quadratic P) D₀ D₁ D₂ f g r) 0)
+
+/-- The conclusions of the paper's rectification lemma for the explicitly constructed
+bimodule complex and original vertex insertion maps. -/
+structure Verified (lo hi : ℤ) : Prop where
+  bounded : ∀ n, n < lo-2 ∨ hi < n → IsZero
+    ((InducedRectification.total (ConcreteQuadraticDiagram.quadratic P) D₀ D₁ D₂ f g H).X n)
+  projective : ∀ n, Projective
+    ((InducedRectification.rightTotal (ConcreteQuadraticDiagram.quadratic P) D₀ D₁ D₂ f g H).X n)
+  finite : ∀ n, FiniteDimensional k ((forgetK k (B P)).obj
+    ((InducedRectification.total (ConcreteQuadraticDiagram.quadratic P) D₀ D₁ D₂ f g H).X n))
+  vertices : ∀ v : Fin 3, ∃ j :
+    VertexHomotopyEquivalence.target P D₀ D₁ D₂ f g H v ⟶
+    VertexHomotopyEquivalence.source P D₀ D₁ D₂ v,
+    Nonempty (Homotopy (VertexHomotopyEquivalence.iota P D₀ D₁ D₂ f g H v ≫ j) (𝟙 _)) ∧
+    Nonempty (Homotopy (j ≫ VertexHomotopyEquivalence.iota P D₀ D₁ D₂ f g H v) (𝟙 _))
+  arrows01 : ∀ a, Nonempty (Homotopy
+    (FirstVertex.iota P D₀ D₁ D₂ f g H ≫ arrow01Map P D₀ D₁ D₂ f g H a)
+    (f a ≫ SecondVertex.iota P D₀ D₁ D₂ f g H))
+  arrows12 : ∀ b, Nonempty (Homotopy
+    (SecondVertex.iota P D₀ D₁ D₂ f g H ≫ arrow12Map P D₀ D₁ D₂ f g H b)
+    (g b ≫ ThirdVertex.iota P D₀ D₁ D₂ f g H))
+
+/-- Full rectification for arbitrary bounded finite projective input complexes,
+using only the assigned relation homotopies. No conclusion about the constructed
+P, its vertices, or its arrow homotopies is assumed. -/
+theorem rectification (lo hi : ℤ)
+    (b₀ : ∀ n, n < lo ∨ hi < n → IsZero (D₀.X n))
+    (b₁ : ∀ n, n < lo ∨ hi < n → IsZero (D₁.X n))
+    (b₂ : ∀ n, n < lo ∨ hi < n → IsZero (D₂.X n))
+    (p₀ : ∀ n, Module.Projective (B P)ᵐᵒᵖ (D₀.X n))
+    (p₁ : ∀ n, Module.Projective (B P)ᵐᵒᵖ (D₁.X n))
+    (p₂ : ∀ n, Module.Projective (B P)ᵐᵒᵖ (D₂.X n))
+    (f₀ : ∀ n, Module.Finite (B P)ᵐᵒᵖ (D₀.X n))
+    (f₁ : ∀ n, Module.Finite (B P)ᵐᵒᵖ (D₁.X n))
+    (f₂ : ∀ n, Module.Finite (B P)ᵐᵒᵖ (D₂.X n)) :
+    Verified P D₀ D₁ D₂ f g H lo hi := by
+  have := QuadraticEncoding.finiteDimensional P
+  exact {
+    bounded := InducedRectification.total_bounded _ _ _ _ _ _ _ lo hi b₀ b₁ b₂
+    projective := InducedRectification.rightTotal_projective _ _ _ _ _ _ _ p₀ p₁ p₂
+    finite := induced_total_finite _ _ _ _ _ _ _ f₀ f₁ f₂
+    vertices := fun v => VertexHomotopyEquivalence.homotopy_inverse P D₀ D₁ D₂ f g H
+      v lo hi b₀ b₁ b₂ p₀ p₁ p₂
+    arrows01 := fun a => ⟨CanonicalArrowCompatibility.compatibility01 P D₀ D₁ D₂ f g H a⟩
+    arrows12 := fun b => ⟨CanonicalArrowCompatibility.compatibility12 P D₀ D₁ D₂ f g H b⟩ }
+end LittleFinitistic.RectificationLemma
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Rectification/RectificationTotal.lean b/lean/OAI/Algebra/Finitistic/Rectification/RectificationTotal.lean
new file mode 100644
index 0000000000000000000000000000000000000000..d0b38eef027a3c09983178d91a5e4aeef067a1cc
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Rectification/RectificationTotal.lean
@@ -0,0 +1,87 @@
+import OAI.Algebra.Finitistic.Localization.ChainRepresentatives
+
+namespace OAI
+
+namespace LittleFinitistic.RectificationTotal
+open CategoryTheory CategoryTheory.Limits HomologicalComplex CochainComplex HomComplex
+
+variable {C : Type*} [Category C] [Preadditive C] [HasBinaryBiproducts C]
+variable {L₀ L₁ L₂ : CochainComplex C ℤ} (p : L₁ ⟶ L₀) (q : L₂ ⟶ L₁)
+  (h : Homotopy (q ≫ p) 0)
+
+/-- The relation null-homotopy extends p over the first cone. -/
+noncomputable def rectifyingMap : mappingCone q ⟶ L₀ :=
+  mappingCone.desc q (Cochain.ofHomotopy h) p (by simp [δ_ofHomotopy])
+
+/-- A genuine cochain complex rectifying a three-column homotopy diagram.
+The cone convention fixes all differential signs; the three-column term
+isomorphism is given below. -/
+noncomputable def total : CochainComplex C ℤ := mappingCone (rectifyingMap p q h)
+
+/-- The total complex has exactly the three finite columns. -/
+noncomputable def termIso (i : ℤ) :
+    (total p q h).X i ≅ (L₂.X (i+2) ⊞ L₁.X (i+1)) ⊞ L₀.X i :=
+  homotopyCofiber.XIsoBiprod (rectifyingMap p q h) i (i+1) (by simp) ≪≫
+    biprod.mapIso (homotopyCofiber.XIsoBiprod q (i+1) (i+2) (by simp; omega)) (Iso.refl _)
+
+@[simp] theorem total_isZero (i : ℤ) :
+    IsZero ((total p q h).X i) ↔
+      (IsZero (L₂.X (i+2)) ∧ IsZero (L₁.X (i+1))) ∧ IsZero (L₀.X i) := by
+  rw [(termIso p q h i).isZero_iff,biprod_isZero_iff,biprod_isZero_iff]
+
+/-- Bounded columns give a bounded actual total complex. -/
+theorem total_bounded (lo hi : ℤ)
+    (h₀ : ∀ i, i < lo ∨ hi < i → IsZero (L₀.X i))
+    (h₁ : ∀ i, i < lo ∨ hi < i → IsZero (L₁.X i))
+    (h₂ : ∀ i, i < lo ∨ hi < i → IsZero (L₂.X i)) :
+    ∀ i, i < lo-2 ∨ hi < i → IsZero ((total p q h).X i) := by
+  intro i hi'
+  rw [total_isZero]
+  exact ⟨⟨h₂ _ (by omega),h₁ _ (by omega)⟩,h₀ _ (by omega)⟩
+
+/-- Termwise projectivity is preserved by the concrete three-column construction. -/
+theorem total_projective (h₀ : ∀ i, Projective (L₀.X i))
+    (h₁ : ∀ i, Projective (L₁.X i)) (h₂ : ∀ i, Projective (L₂.X i)) :
+    ∀ i, Projective ((total p q h).X i) := by
+  intro i
+  let := h₀ i
+  let := h₁ (i+1)
+  let := h₂ (i+2)
+  apply Projective.of_iso (termIso p q h i).symm
+  infer_instance
+
+/-- The original zero column includes by an actual chain map. -/
+noncomputable def inclusion : L₀ ⟶ total p q h := mappingCone.inr (rectifyingMap p q h)
+
+/-- The first-column boundary vanishes by a specified chain homotopy in the total.
+For the induced B-arrow columns this is exactly the arrow compatibility homotopy. -/
+noncomputable def boundaryHomotopy : Homotopy (p ≫ inclusion p q h) 0 := by
+  let f := rectifyingMap p q h
+  let H : Homotopy (f ≫ mappingCone.inr f) 0 :=
+    (Cochain.equivHomotopy _ _).symm ⟨mappingCone.inl f,by simp⟩
+  have H' := H.compLeft (mappingCone.inr q)
+  have heq : mappingCone.inr q ≫ f = p := mappingCone.inr_desc _ _ _ _
+  rw [← Category.assoc,heq,CategoryTheory.Limits.comp_zero] at H'
+  exact H'
+
+variable {D : Type*} [Category D] [Preadditive D] [HasBinaryBiproducts D]
+
+/-- Projectivity after an additive forgetful functor, needed for right projectivity
+of a total built in the category of bimodules. -/
+theorem total_projective_after (F : C ⥤ D) [F.Additive]
+    (h₀ : ∀ i, Projective (F.obj (L₀.X i)))
+    (h₁ : ∀ i, Projective (F.obj (L₁.X i)))
+    (h₂ : ∀ i, Projective (F.obj (L₂.X i))) :
+    ∀ i, Projective (F.obj ((total p q h).X i)) := by
+  intro i
+  let := h₀ i
+  let := h₁ (i+1)
+  let := h₂ (i+2)
+  let := preservesBinaryBiproducts_of_preservesBiproducts F
+  let e := F.mapIso (termIso p q h i) ≪≫ F.mapBiprod _ _ ≪≫
+    biprod.mapIso (F.mapBiprod _ _) (Iso.refl _)
+  apply Projective.of_iso e.symm
+  infer_instance
+end LittleFinitistic.RectificationTotal
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Rectification/SecondVertex.lean b/lean/OAI/Algebra/Finitistic/Rectification/SecondVertex.lean
new file mode 100644
index 0000000000000000000000000000000000000000..613e359d8d3a3a8fcdbf3a7dc0f0dc5da3c4ae19
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Rectification/SecondVertex.lean
@@ -0,0 +1,101 @@
+import OAI.Algebra.Finitistic.Rectification.GradedVertexAcyclic
+import OAI.Algebra.Finitistic.Rectification.FirstVertex
+
+namespace OAI
+noncomputable section
+open CategoryTheory CategoryTheory.Limits HomologicalComplex
+namespace LittleFinitistic.SecondVertex
+open ExternalTensor.Section4 ExternalTensor.Section4.SourceFiltration
+universe u
+variable {k : Type u} [Field k] {d t : ℕ} (P : QuadraticEncoding.Relations k d t)
+variable (D₀ D₁ D₂ : RightComplex (QuadraticEncoding.B P))
+variable (f : Fin (d+1) → (D₀ ⟶ D₁)) (g : Fin (d+1) → (D₁ ⟶ D₂))
+local notation "T" => QuadraticEncoding.B P
+local notation "s" => ConcreteQuadraticDiagram.quadratic P
+abbrev vertex := BimoduleVertex.functor k (QuadraticEncoding.B P)
+  (ThreeVertexAlgebra.vertex (QuadraticEncoding.composition P) 1)
+abbrev vertexComplex := (vertex P).mapHomologicalComplex (.up ℤ)
+
+def intoF1 : (columnComplex k T (s).e₁).obj D₁ ⟶ Exactness.F1 s D₀ D₁ D₂ f g :=
+  biprod.inl ≫ RectificationTotal.inclusion (p1 (Exactness.data s D₀ D₁ D₂ f g)) 0
+    (h1 (Exactness.data s D₀ D₁ D₂ f g))
+
+theorem intoF1_isIso : IsIso ((vertexComplex P).map (intoF1 P D₀ D₁ D₂ f g)) := by
+  let F := vertex P
+  let G := vertexComplex P
+  have hz : IsZero (G.obj (Z (k := k) (B := T))) := by
+    apply G.map_isZero
+    apply ZeroColumnTotal.complex_zero
+    intro n
+    exact ModuleCat.isZero_iff_subsingleton.mpr inferInstance
+  have hv : IsZero (G.obj ((columnComplex k T (s).e₂).obj D₂)) :=
+    VertexColumnComplex.reverse_isZero (QuadraticEncoding.composition P) 1 2 (by decide) D₂
+  have hs : IsZero (G.obj (F1₁ (Exactness.data s D₀ D₁ D₂ f g))) := by
+    apply (G.mapBiproduct _).isZero_iff.mpr
+    exact sum_isZero _ (fun _ =>
+      VertexColumnComplex.reverse_isZero (QuadraticEncoding.composition P) 1 2 (by decide) D₁)
+  have hi := ZeroColumnTotal.mapped_inclusion_isIso
+    (p1 (Exactness.data s D₀ D₁ D₂ f g)) 0 (h1 (Exactness.data s D₀ D₁ D₂ f g)) F
+    (fun n => (HomologicalComplex.eval _ _ n).map_isZero hs)
+    (fun n => (HomologicalComplex.eval _ _ n).map_isZero hz)
+  have hj := FirstVertex.mapped_inl_isIso G
+    ((columnComplex k T (s).e₁).obj D₁) ((columnComplex k T (s).e₂).obj D₂) hv
+  let := hi
+  let := hj
+  dsimp [intoF1]
+  erw [Functor.map_comp]
+  exact (show IsIso (G.map (biprod.inl :
+    (columnComplex k T (s).e₁).obj D₁ ⟶ F1₀ (Exactness.data s D₀ D₁ D₂ f g)) ≫
+      G.map (RectificationTotal.inclusion (p1 (Exactness.data s D₀ D₁ D₂ f g)) 0
+        (h1 (Exactness.data s D₀ D₁ D₂ f g)))) from by
+    have : IsIso (G.map (biprod.inl :
+      (columnComplex k T (s).e₁).obj D₁ ⟶ F1₀ (Exactness.data s D₀ D₁ D₂ f g))) := hj
+    rw [isIso_comp_left_iff]
+    exact hi)
+
+variable (H : ∀ r, Homotopy (relationMap (ConcreteQuadraticDiagram.quadratic P) D₀ D₁ D₂ f g r) 0)
+
+theorem filtration_inclusion_quasiIso :
+    QuasiIso ((vertexComplex P).map (Exactness.i1 s D₀ D₁ D₂ f g H)) := by
+  let S := Complex.source0 s D₀ D₁ D₂ f g H
+  exact RectificationAcyclic.quasiIso_of_acyclic_quotient (S.map (vertexComplex P))
+    (Complex.vertex_shortExact ((s).e₁) ((ThreeVertexAlgebra.directedSystem (QuadraticEncoding.composition P)).idem 1) S
+      (Complex.source0_shortExact s D₀ D₁ D₂ f g H))
+    (GradedVertexAcyclic.grade0_vertex1_acyclic P D₀ D₁ D₂ f g)
+
+def iota : D₁ ⟶ (vertexComplex P).obj (Exactness.P s D₀ D₁ D₂ f g H) :=
+  (VertexColumnComplex.diagonalComplexIso (QuadraticEncoding.composition P) 1 D₁).hom ≫
+    (vertexComplex P).map (intoF1 P D₀ D₁ D₂ f g) ≫
+    (vertexComplex P).map (Exactness.i1 s D₀ D₁ D₂ f g H)
+
+theorem iota_quasiIso : QuasiIso (iota P D₀ D₁ D₂ f g H) := by
+  let := intoF1_isIso P D₀ D₁ D₂ f g
+  let := filtration_inclusion_quasiIso P D₀ D₁ D₂ f g H
+  let e : D₁ ≅ (vertexComplex P).obj ((columnComplex k T (s).e₁).obj D₁) :=
+    VertexColumnComplex.diagonalComplexIso (QuadraticEncoding.composition P) 1 D₁
+  change QuasiIso (e.hom ≫ (vertexComplex P).map (intoF1 P D₀ D₁ D₂ f g) ≫
+    (vertexComplex P).map (Exactness.i1 s D₀ D₁ D₂ f g H))
+  infer_instance
+
+/-- The filtration route retains the original vertex-one summand insertion. -/
+theorem intoF1_nested : intoF1 P D₀ D₁ D₂ f g ≫ Exactness.i1 s D₀ D₁ D₂ f g H =
+    (Exactness.data s D₀ D₁ D₂ f g).in₁ ≫
+      InducedRectification.inclusion s D₀ D₁ D₂ f g H := by
+  exact (Category.assoc _ _ _).trans (congrArg
+    (fun h => (biprod.inl : (columnComplex k T (s).e₁).obj D₁ ⟶
+      F1₀ (Exactness.data s D₀ D₁ D₂ f g)) ≫ h)
+    ((include1 (inducedData s D₀ D₁ D₂ f g) (nullHomotopy s D₀ D₁ D₂ f g H)).inclusion_totalMap))
+
+theorem iota_original : iota P D₀ D₁ D₂ f g H =
+    (VertexColumnComplex.diagonalComplexIso (QuadraticEncoding.composition P) 1 D₁).hom ≫
+      (vertexComplex P).map ((Exactness.data s D₀ D₁ D₂ f g).in₁) ≫
+      (vertexComplex P).map (InducedRectification.inclusion s D₀ D₁ D₂ f g H) := by
+  dsimp only [iota]
+  erw [← (vertexComplex P).map_comp (intoF1 P D₀ D₁ D₂ f g)
+    (Exactness.i1 s D₀ D₁ D₂ f g H), intoF1_nested, Functor.map_comp]
+  rfl
+end LittleFinitistic.SecondVertex
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Rectification/SourceFiltration.lean b/lean/OAI/Algebra/Finitistic/Rectification/SourceFiltration.lean
new file mode 100644
index 0000000000000000000000000000000000000000..fa466275938c6051f1d5e8fb703ab601f3ad9a53
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Rectification/SourceFiltration.lean
@@ -0,0 +1,171 @@
+import OAI.Algebra.Finitistic.Rectification.InducedDiagram
+import OAI.Algebra.Finitistic.Rectification.TotalFunctorial
+
+namespace OAI
+open CategoryTheory CategoryTheory.Limits HomologicalComplex CochainComplex
+open LittleFinitistic.RectificationTotal
+open scoped TensorProduct ModuleCat.Algebra
+noncomputable section
+namespace ExternalTensor.Section4.SourceFiltration
+universe u
+variable {k B : Type u} [Field k] [Ring B] [Algebra k B]
+variable {A J R : Type} [Fintype A] [Fintype J] [Fintype R]
+variable (t : AssemblyData (C := BiComplex k B) (A := A) (J := J) (R := R))
+
+/-- Source at least one: the actual D1 and D2 vertex terms and D1 arrow terms. -/
+abbrev F1₀ := t.V₁ ⊞ t.V₂
+abbrev F1₁ := ⨁ t.V
+def Z : BiComplex k B where
+  X _ := ModuleCat.of _ PUnit
+  d _ _ := 0
+  shape _ _ _ := rfl
+  d_comp_d' _ _ _ _ _ := by simp
+
+def p1 : F1₁ t ⟶ F1₀ t :=
+  biproduct.desc fun b => t.pb₁ b ≫ biprod.inl - t.pb₂ b ≫ biprod.inr
+
+def h1 : Homotopy ((0 : Z ⟶ F1₁ t) ≫ p1 t) 0 where
+  hom _ _ := 0
+  zero _ _ _ := rfl
+  comm _ := by simp [dNext, prevD]
+
+/-- Source zero quotient: retain precisely the path-multiplication terms. -/
+def p0 : (⨁ t.U) ⟶ t.V₀ := biproduct.desc t.pa₀
+
+def q0 : t.L₂ ⟶ (⨁ t.U) :=
+  biproduct.desc fun r => ∑ a, ∑ b, t.qa r a b ≫ biproduct.ι t.U a
+
+theorem q0_p0 : q0 t ≫ p0 t = 0 := by
+  apply biproduct.hom_ext'
+  intro r
+  simpa [q0, p0, Preadditive.sum_comp] using t.first r
+
+def h0 : Homotopy (q0 t ≫ p0 t) 0 where
+  hom _ _ := 0
+  zero _ _ _ := rfl
+  comm n := by rw [q0_p0]; simp [dNext, prevD]
+
+omit [Fintype R] in
+@[reassoc] theorem in_p : (biprod.inr : F1₁ t ⟶ t.L₁) ≫ t.p =
+    p1 t ≫ (biprod.inr : F1₀ t ⟶ t.L₀) := by
+  apply biproduct.hom_ext'
+  intro b
+  simp [AssemblyData.p, p1, AssemblyData.in₁, AssemblyData.in₂,
+    Preadditive.sub_comp]
+
+omit [Fintype R] in
+@[reassoc] theorem p_out : t.p ≫ (biprod.fst : t.L₀ ⟶ t.V₀) =
+    (biprod.fst : t.L₁ ⟶ ⨁ t.U) ≫ p0 t := by
+  apply biprod.hom_ext' <;> apply biproduct.hom_ext' <;> intro a <;>
+    simp [AssemblyData.p, p0, AssemblyData.in₀, AssemblyData.in₁,
+      AssemblyData.in₂, Preadditive.sub_comp]
+
+@[reassoc] theorem q_out : t.q ≫ (biprod.fst : t.L₁ ⟶ ⨁ t.U) = q0 t := by
+  apply biproduct.hom_ext'
+  intro r
+  simp [AssemblyData.q, q0, Preadditive.sum_comp, Preadditive.add_comp]
+
+variable (h : Homotopy (t.q ≫ t.p) 0)
+/-- The original summand inclusion, as a triple preserving the specified homotopy. -/
+def include1 : MapData (p1 t) 0 (h1 t) t.p t.q h where
+  f₀ := biprod.inr
+  f₁ := biprod.inr
+  f₂ := 0
+  commP := in_p t
+  commQ := by simp
+  commH i j := by simp [h1]
+
+/-- Projection onto the actual source-zero quotient. The condition only records
+that the supplied homotopy increases source index; it is proved for Section4 inputs below. -/
+def quotient0 (hh : ∀ i j, h.hom i j ≫ (biprod.fst : t.L₀ ⟶ t.V₀).f j = 0) :
+    MapData t.p t.q h (p0 t) (q0 t) (h0 t) where
+  f₀ := biprod.fst
+  f₁ := biprod.fst
+  f₂ := 𝟙 _
+  commP := (p_out t).symm
+  commQ := by simpa using (q_out t).symm
+  commH i j := by simpa [h0] using (hh i j).symm
+
+/-- The second filtration step and its source-one quotient. -/
+def p2 : Z (k := k) (B := B) ⟶ t.V₂ := 0
+
+def h2 : Homotopy ((0 : Z ⟶ Z) ≫ p2 t) 0 where
+  hom _ _ := 0
+  zero _ _ _ := rfl
+  comm _ := by simp [p2, dNext, prevD]
+
+def pGrade1 : F1₁ t ⟶ t.V₁ := biproduct.desc t.pb₁
+
+def hGrade1 : Homotopy ((0 : Z ⟶ F1₁ t) ≫ pGrade1 t) 0 where
+  hom _ _ := 0
+  zero _ _ _ := rfl
+  comm _ := by simp [dNext, prevD]
+
+def include2 : MapData (p2 t) 0 (h2 t) (p1 t) 0 (h1 t) where
+  f₀ := biprod.inr
+  f₁ := 0
+  f₂ := 𝟙 _
+  commP := by simp [p2]
+  commQ := by simp
+  commH i j := by simp [h1, h2]
+
+def quotient1 : MapData (p1 t) 0 (h1 t) (pGrade1 t) 0 (hGrade1 t) where
+  f₀ := biprod.fst
+  f₁ := 𝟙 _
+  f₂ := 𝟙 _
+  commP := by
+    rw [Category.id_comp]
+    apply biproduct.hom_ext'
+    intro b
+    simp [p1, pGrade1, Preadditive.sub_comp]
+  commQ := by simp
+  commH i j := by simp [h1, hGrade1]
+
+/-- Changing the endpoint proofs does not change a homotopy's components. -/
+theorem cast_hom {X Y : BiComplex k B} {a b a' b' : X ⟶ Y}
+    (ha : a = a') (hb : b = b') (e : Homotopy a b = Homotopy a' b')
+    (v : Homotopy a b) : (cast e v).hom = v.hom := by
+  subst a'
+  subst b'
+  rfl
+
+variable (s : Quadratic k B (A := A) (J := J) (R := R))
+variable (D₀ D₁ D₂ : RightComplex B)
+variable (f : A → (D₀ ⟶ D₁)) (g : J → (D₁ ⟶ D₂))
+variable (H : ∀ r, Homotopy (relationMap s D₀ D₁ D₂ f g r) 0)
+
+theorem induced_h_out (i j : ℤ) :
+    (nullHomotopy s D₀ D₁ D₂ f g H).hom i j ≫
+      (biprod.fst : L0Prime s D₀ D₁ D₂ f g ⟶
+        (inducedData s D₀ D₁ D₂ f g).V₀).f j = 0 := by
+  classical
+  unfold nullHomotopy
+  simp only [eq_mpr_eq_cast, eq_mp_eq_cast]
+  rw [cast_hom (by simp [AssemblyData.composite]) (by simp)]
+  rw [cast_hom (ha := ?_) (hb := ?_)]
+  rotate_left
+  · simp
+  · simp
+  change ((-1 : k) • h s D₀ D₁ D₂ f g H i j) ≫ _ = 0
+  rw [Linear.smul_comp]
+  suffices h s D₀ D₁ D₂ f g H i j ≫
+      (biprod.fst : L0Prime s D₀ D₁ D₂ f g ⟶
+        (inducedData s D₀ D₁ D₂ f g).V₀).f j = 0 by rw [this, smul_zero]
+  rw [h_formula, Preadditive.sum_comp]
+  apply Finset.sum_eq_zero
+  intro r _
+  dsimp only [AssemblyData.in₂]
+  erw [Category.assoc, Category.assoc, ← comp_f, Category.assoc, biprod.inr_fst,
+    CategoryTheory.Limits.comp_zero]
+
+/-- Actual Section 4 source filtration inclusion; no decomposition is assumed. -/
+abbrev inducedInclude1 := include1 (inducedData s D₀ D₁ D₂ f g)
+  (nullHomotopy s D₀ D₁ D₂ f g H)
+/-- Actual Section 4 source quotient; homotopy compatibility is proved above. -/
+abbrev inducedQuotient0 := quotient0 (inducedData s D₀ D₁ D₂ f g)
+  (nullHomotopy s D₀ D₁ D₂ f g H) (induced_h_out s D₀ D₁ D₂ f g H)
+end ExternalTensor.Section4.SourceFiltration
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Rectification/SourceFiltrationComplex.lean b/lean/OAI/Algebra/Finitistic/Rectification/SourceFiltrationComplex.lean
new file mode 100644
index 0000000000000000000000000000000000000000..ce086d7e61a2598a3ac932dcc97457af4d796f3a
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Rectification/SourceFiltrationComplex.lean
@@ -0,0 +1,66 @@
+import OAI.Algebra.Finitistic.Rectification.FiltrationExactness
+import OAI.Algebra.Finitistic.Bimodule.BimoduleVertex
+
+namespace OAI
+noncomputable section
+open CategoryTheory CategoryTheory.Limits HomologicalComplex
+namespace LittleFinitistic.ModuleComplexExact
+universe u
+variable {S : Type u} [Ring S]
+variable {X Y Z : CochainComplex (ModuleCat.{u} S) ℤ} (f : X ⟶ Y) (g : Y ⟶ Z)
+
+theorem comp_zero (h : ∀ n, Function.Exact (f.f n) (g.f n)) : f ≫ g = 0 := by
+  ext n x
+  exact (h n).apply_apply_eq_zero x
+
+def sequence (h : ∀ n, Function.Exact (f.f n) (g.f n)) :
+    ShortComplex (CochainComplex (ModuleCat.{u} S) ℤ) := .mk f g (comp_zero f g h)
+
+theorem shortExact (h : ∀ n, Function.Injective (f.f n) ∧
+    Function.Exact (f.f n) (g.f n) ∧ Function.Surjective (g.f n)) :
+    (sequence f g (fun n => (h n).2.1)).ShortExact := by
+  apply HomologicalComplex.shortExact_of_degreewise_shortExact
+  intro n
+  exact ModuleCat.shortComplex_shortExact _ (h n).2.1 (h n).1 (h n).2.2
+end LittleFinitistic.ModuleComplexExact
+
+namespace ExternalTensor.Section4.SourceFiltration.Complex
+universe u
+variable {k B : Type u} [Field k] [Ring B] [Algebra k B]
+variable {A J R : Type} [Fintype A] [Fintype J] [Fintype R]
+variable (s : Quadratic k B (A := A) (J := J) (R := R))
+variable (D₀ D₁ D₂ : RightComplex B)
+variable (f : A → (D₀ ⟶ D₁)) (g : J → (D₁ ⟶ D₂))
+variable (H : ∀ r, Homotopy (relationMap s D₀ D₁ D₂ f g r) 0)
+open Exactness LittleFinitistic
+
+def source0 := ModuleComplexExact.sequence (i1 s D₀ D₁ D₂ f g H)
+  (pi0 s D₀ D₁ D₂ f g H)
+  (fun n => (exact_source_filtration s D₀ D₁ D₂ f g H n).1.2.1)
+
+def source1 := ModuleComplexExact.sequence (i2 s D₀ D₁ D₂ f g)
+  (pi1 s D₀ D₁ D₂ f g)
+  (fun n => (v2_shortExact (data s D₀ D₁ D₂ f g) n).2.1)
+
+theorem source0_shortExact : (source0 s D₀ D₁ D₂ f g H).ShortExact :=
+  ModuleComplexExact.shortExact _ _
+    (fun n => (exact_source_filtration s D₀ D₁ D₂ f g H n).1)
+
+omit [Fintype R] in
+theorem source1_shortExact : (source1 s D₀ D₁ D₂ f g).ShortExact :=
+  ModuleComplexExact.shortExact _ _ (v2_shortExact (data s D₀ D₁ D₂ f g))
+
+/-- Every original source filtration remains short exact after taking a left vertex. -/
+theorem vertex_shortExact (e : B) (he : e*e=e)
+    (S : ShortComplex (BiComplex k B)) (hS : S.ShortExact) :
+    (S.map ((BimoduleVertex.functor k B e).mapHomologicalComplex (.up ℤ))).ShortExact := by
+  apply HomologicalComplex.shortExact_of_degreewise_shortExact
+  intro n
+  exact BimoduleVertex.map_shortExact k B e he
+    (S.map (HomologicalComplex.eval _ _ n))
+    ((HomologicalComplex.shortExact_iff_degreewise_shortExact S).1 hS n)
+end ExternalTensor.Section4.SourceFiltration.Complex
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Rectification/SourceFiltrationCone.lean b/lean/OAI/Algebra/Finitistic/Rectification/SourceFiltrationCone.lean
new file mode 100644
index 0000000000000000000000000000000000000000..690f8b1dd1ae8093e6cb08b5aa9c903f803ec7f9
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Rectification/SourceFiltrationCone.lean
@@ -0,0 +1,81 @@
+import OAI.Algebra.Finitistic.Rectification.SourceFiltrationReal
+
+namespace OAI
+open CategoryTheory CategoryTheory.Limits HomologicalComplex CochainComplex
+open LittleFinitistic.RectificationTotal
+noncomputable section
+namespace ExternalTensor.Section4.SourceFiltration
+universe u
+variable {k B : Type u} [Field k] [Ring B] [Algebra k B]
+
+/-- An isomorphism of the two input columns gives an isomorphism of actual cones. -/
+def coneIso {X Y X' Y' : BiComplex k B} (p : X ⟶ Y) (p' : X' ⟶ Y')
+    (a : X ≅ X') (b : Y ≅ Y') (w : a.hom ≫ p' = p ≫ b.hom) :
+    mappingCone p ≅ mappingCone p' where
+  hom := coneMap p p' a.hom b.hom w
+  inv := coneMap p' p a.inv b.inv (by
+    apply (cancel_epi a.hom).1
+    simp only [← Category.assoc, Iso.hom_inv_id, Category.id_comp]
+    rw [w, Category.assoc, Iso.hom_inv_id, Category.comp_id])
+  hom_inv_id := by rw [← coneMap_comp]; simp
+  inv_hom_id := by rw [← coneMap_comp]; simp
+
+variable (X : BiComplex k B)
+
+theorem zeroCone_inclusion_product (n : ℤ) :
+    (mappingCone.inr (0 : Z ⟶ X)).f n ≫
+      ((homotopyCofiber.XIsoBiprod (0 : Z ⟶ X) n (n+1) rfl) ≪≫
+        ModuleCat.biprodIsoProd _ _).hom =
+      ModuleCat.ofHom (LinearMap.inr (Enveloping k B) (Z.X (n+1)) (X.X n)) := by
+  erw [Iso.trans_hom, ← Category.assoc, cone_inr_termIso]
+  exact inr_prod _ _
+
+theorem zeroCone_inclusion_bijective (n : ℤ) :
+    Function.Bijective ((mappingCone.inr (0 : Z ⟶ X)).f n) := by
+  let e := ((homotopyCofiber.XIsoBiprod (0 : Z ⟶ X) n (n+1) rfl) ≪≫
+    ModuleCat.biprodIsoProd _ _).toLinearEquiv
+  have he (x : X.X n) : e ((mappingCone.inr (0 : Z ⟶ X)).f n x) = (0,x) :=
+    congrArg (fun a => a x) (zeroCone_inclusion_product X n)
+  refine ⟨?_, ?_⟩
+  · intro x y hxy
+    have := congrArg e hxy
+    simpa only [he] using congrArg Prod.snd this
+  · intro y
+    refine ⟨(e y).2, e.injective ?_⟩
+    rw [he]
+    exact Prod.ext (Subsingleton.elim _ _) rfl
+
+instance zeroCone_inclusion_isIso : IsIso (mappingCone.inr (0 : Z ⟶ X)) := by
+  have (n : ℤ) : IsIso ((mappingCone.inr (0 : Z ⟶ X)).f n) :=
+    (ConcreteCategory.isIso_iff_bijective _).2 (zeroCone_inclusion_bijective X n)
+  exact HomologicalComplex.Hom.isIso_of_components _
+
+/-- The ordinary two-column total identifies with the three-column API having
+zero relation column; its zero-column inclusion is unchanged. -/
+def twoColumnIso {Y : BiComplex k B} (p : X ⟶ Y)
+    (h : Homotopy ((0 : Z ⟶ X) ≫ p) 0) : mappingCone p ≅ total p 0 h :=
+  coneIso p (rectifyingMap p 0 h) (asIso (mappingCone.inr (0 : Z ⟶ X)))
+    (Iso.refl _) (by simp [rectifyingMap])
+
+theorem twoColumnIso_inclusion {Y : BiComplex k B} (p : X ⟶ Y)
+    (h : Homotopy ((0 : Z ⟶ X) ≫ p) 0) :
+    mappingCone.inr p ≫ (twoColumnIso X p h).hom = inclusion p 0 h := by
+  apply HomologicalComplex.hom_ext
+  intro n
+  change (mappingCone.inr p).f n ≫
+    (coneMap p (rectifyingMap p 0 h) (mappingCone.inr (0 : Z ⟶ X)) (𝟙 Y) _).f n =
+      (mappingCone.inr (rectifyingMap p 0 h)).f n
+  erw [coneMap_inr, id_f, Category.id_comp]
+
+variable {A J R : Type} [Fintype A] [Fintype J] [Fintype R]
+variable (t : AssemblyData (C := BiComplex k B) (A := A) (J := J) (R := R))
+
+def f1ConeIso : mappingCone (p1 t) ≅ total (p1 t) 0 (h1 t) :=
+  twoColumnIso _ _ _
+def grade1ConeIso : mappingCone (pGrade1 t) ≅ total (pGrade1 t) 0 (hGrade1 t) :=
+  twoColumnIso _ _ _
+end ExternalTensor.Section4.SourceFiltration
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Rectification/SourceFiltrationExact.lean b/lean/OAI/Algebra/Finitistic/Rectification/SourceFiltrationExact.lean
new file mode 100644
index 0000000000000000000000000000000000000000..6326b6734a6d144d30cfde56f3ccd914b1d040db
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Rectification/SourceFiltrationExact.lean
@@ -0,0 +1,111 @@
+import OAI.Algebra.Finitistic.Rectification.SourceFiltration
+import OAI.Algebra.Finitistic.Localization.SplitComponentExact
+
+namespace OAI
+open CategoryTheory CategoryTheory.Limits HomologicalComplex CochainComplex
+open LittleFinitistic.RectificationTotal
+noncomputable section
+namespace ExternalTensor.Section4.SourceFiltration
+universe u
+variable {k B : Type u} [Field k] [Ring B] [Algebra k B]
+variable {A J R : Type} [Fintype A] [Fintype J] [Fintype R]
+instance zeroTermSubsingleton (n : ℤ) : Subsingleton ((Z (k := k) (B := B)).X n) := by
+  change Subsingleton PUnit
+  infer_instance
+
+variable (t : AssemblyData (C := BiComplex k B) (A := A) (J := J) (R := R))
+variable (h : Homotopy (t.q ≫ t.p) 0)
+variable (hh : ∀ i j, h.hom i j ≫ (biprod.fst : t.L₀ ⟶ t.V₀).f j = 0)
+
+theorem source0_component0 (n : ℤ) :
+    Function.Injective ((include1 t h).f₀.f n) ∧
+    Function.Exact ((include1 t h).f₀.f n) ((quotient0 t h hh).f₀.f n) ∧
+    Function.Surjective ((quotient0 t h hh).f₀.f n) :=
+  inr_fst_shortExact t.V₀ (t.V₁ ⊞ t.V₂) n
+
+theorem source0_component1 (n : ℤ) :
+    Function.Injective ((include1 t h).f₁.f n) ∧
+    Function.Exact ((include1 t h).f₁.f n) ((quotient0 t h hh).f₁.f n) ∧
+    Function.Surjective ((quotient0 t h hh).f₁.f n) :=
+  inr_fst_shortExact (⨁ t.U) (⨁ t.V) n
+
+theorem source0_component2 (n : ℤ) :
+    Function.Injective ((include1 t h).f₂.f n) ∧
+    Function.Exact ((include1 t h).f₂.f n) ((quotient0 t h hh).f₂.f n) ∧
+    Function.Surjective ((quotient0 t h hh).f₂.f n) :=
+  zero_id_shortExact t.L₂ Z (fun _ => inferInstance) n
+
+/-- The actual F>=1 inclusion and source-zero quotient are termwise short exact. -/
+theorem source0_shortExact (n : ℤ) :
+    Function.Injective ((include1 t h).totalMap.f n) ∧
+    Function.Exact ((include1 t h).totalMap.f n) ((quotient0 t h hh).totalMap.f n) ∧
+    Function.Surjective ((quotient0 t h hh).totalMap.f n) := by
+  exact (include1 t h).totalMap_shortExact (quotient0 t h hh)
+    (fun n => (source0_component0 t h hh n).2.1)
+    (fun n => (source0_component1 t h hh n).2.1)
+    (fun n => (source0_component2 t h hh n).2.1)
+    (fun n => (source0_component0 t h hh n).1)
+    (fun n => (source0_component1 t h hh n).1)
+    (fun n => (source0_component2 t h hh n).1)
+    (fun n => (source0_component0 t h hh n).2.2)
+    (fun n => (source0_component1 t h hh n).2.2)
+    (fun n => (source0_component2 t h hh n).2.2) n
+
+omit [Fintype R] in
+theorem source1_component0 (n : ℤ) :
+    Function.Injective ((include2 t).f₀.f n) ∧
+    Function.Exact ((include2 t).f₀.f n) ((quotient1 t).f₀.f n) ∧
+    Function.Surjective ((quotient1 t).f₀.f n) :=
+  inr_fst_shortExact t.V₁ t.V₂ n
+
+omit [Fintype R] in
+theorem source1_component1 (n : ℤ) :
+    Function.Injective ((include2 t).f₁.f n) ∧
+    Function.Exact ((include2 t).f₁.f n) ((quotient1 t).f₁.f n) ∧
+    Function.Surjective ((quotient1 t).f₁.f n) :=
+  zero_id_shortExact (⨁ t.V) Z (fun _ => inferInstance) n
+
+omit [Fintype R] in
+theorem source1_component2 (n : ℤ) :
+    Function.Injective ((include2 t).f₂.f n) ∧
+    Function.Exact ((include2 t).f₂.f n) ((quotient1 t).f₂.f n) ∧
+    Function.Surjective ((quotient1 t).f₂.f n) := by
+  refine ⟨fun _ _ _ => Subsingleton.elim _ _, ?_, fun x => ⟨x, rfl⟩⟩
+  intro x
+  exact ⟨fun _ => ⟨x, rfl⟩, fun _ => Subsingleton.elim _ _⟩
+
+omit [Fintype R] in
+/-- The actual F>=2 inclusion and source-one quotient are termwise short exact. -/
+theorem source1_shortExact (n : ℤ) :
+    Function.Injective ((include2 t).totalMap.f n) ∧
+    Function.Exact ((include2 t).totalMap.f n) ((quotient1 t).totalMap.f n) ∧
+    Function.Surjective ((quotient1 t).totalMap.f n) := by
+  exact (include2 t).totalMap_shortExact (quotient1 t)
+    (fun n => (source1_component0 t n).2.1)
+    (fun n => (source1_component1 t n).2.1)
+    (fun n => (source1_component2 t n).2.1)
+    (fun n => (source1_component0 t n).1)
+    (fun n => (source1_component1 t n).1)
+    (fun n => (source1_component2 t n).1)
+    (fun n => (source1_component0 t n).2.2)
+    (fun n => (source1_component1 t n).2.2)
+    (fun n => (source1_component2 t n).2.2) n
+
+variable (s : Quadratic k B (A := A) (J := J) (R := R))
+variable (D₀ D₁ D₂ : RightComplex B)
+variable (f : A → (D₀ ⟶ D₁)) (g : J → (D₁ ⟶ D₂))
+variable (H : ∀ r, Homotopy (relationMap s D₀ D₁ D₂ f g r) 0)
+
+/-- No short-exactness or filtration assumption: all component properties are
+proved from the actual induced Section 4 sources. -/
+theorem induced_source0_shortExact (n : ℤ) :
+    Function.Injective ((inducedInclude1 s D₀ D₁ D₂ f g H).totalMap.f n) ∧
+    Function.Exact ((inducedInclude1 s D₀ D₁ D₂ f g H).totalMap.f n)
+      ((inducedQuotient0 s D₀ D₁ D₂ f g H).totalMap.f n) ∧
+    Function.Surjective ((inducedQuotient0 s D₀ D₁ D₂ f g H).totalMap.f n) :=
+  source0_shortExact _ _ _ n
+end ExternalTensor.Section4.SourceFiltration
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Rectification/SourceFiltrationReal.lean b/lean/OAI/Algebra/Finitistic/Rectification/SourceFiltrationReal.lean
new file mode 100644
index 0000000000000000000000000000000000000000..04e72b5d65d4fb7cb5cf0f9442b142d4f280f534
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Rectification/SourceFiltrationReal.lean
@@ -0,0 +1,100 @@
+import OAI.Algebra.Finitistic.Rectification.SourceFiltrationExact
+
+namespace OAI
+open CategoryTheory CategoryTheory.Limits HomologicalComplex CochainComplex
+open LittleFinitistic.RectificationTotal
+noncomputable section
+namespace ExternalTensor.Section4.SourceFiltration
+universe u
+variable {k B : Type u} [Field k] [Ring B] [Algebra k B]
+variable {A J R : Type} [Fintype A] [Fintype J] [Fintype R]
+variable (t : AssemblyData (C := BiComplex k B) (A := A) (J := J) (R := R))
+
+@[reassoc (attr := simp)]
+theorem inr_prod {S : Type u} [Ring S] (X Y : ModuleCat.{u} S) :
+    (biprod.inr : Y ⟶ X ⊞ Y) ≫ (ModuleCat.biprodIsoProd X Y).hom =
+      ModuleCat.ofHom (LinearMap.inr S X Y) := by
+  apply (cancel_mono (ModuleCat.biprodIsoProd X Y).inv).1
+  simp only [Category.assoc, Iso.hom_inv_id, Category.comp_id]
+  apply biprod.hom_ext
+  · simp only [Category.assoc, ModuleCat.biprodIsoProd_inv_comp_fst, biprod.inr_fst]
+    rfl
+  · simp only [Category.assoc, ModuleCat.biprodIsoProd_inv_comp_snd, biprod.inr_snd]
+    rfl
+
+omit [Fintype R] in
+/-- The canonical zero-column inclusion has exactly its original term coordinate. -/
+theorem inclusion_product (n : ℤ) :
+    (inclusion (p2 t) 0 (h2 t)).f n ≫ (totalTermIso (p2 t) 0 (h2 t) n).hom =
+      ModuleCat.ofHom (LinearMap.inr (Enveloping k B)
+        (Z.X (n+2) × Z.X (n+1)) (t.V₂.X n)) := by
+  dsimp only [totalTermIso, termIso, LittleFinitistic.RectificationTotal.inclusion]
+  erw [Iso.trans_hom, Iso.trans_hom, Iso.trans_hom,
+    biprod.mapIso_hom, Iso.refl_hom, biprod.mapIso_hom, Iso.refl_hom]
+  erw [← Category.assoc, ← Category.assoc, ← Category.assoc,
+    cone_inr_termIso, biprod.inr_map, Category.id_comp, biprod.inr_map, Category.id_comp]
+  exact inr_prod _ _
+
+omit [Fintype R] in
+/-- Removing the two zero columns preserves the actual V2 inclusion. -/
+theorem inclusion2_bijective (n : ℤ) :
+    Function.Bijective ((inclusion (p2 t) 0 (h2 t)).f n) := by
+  let e := (totalTermIso (p2 t) 0 (h2 t) n).toLinearEquiv
+  have he (x : t.V₂.X n) : e ((inclusion (p2 t) 0 (h2 t)).f n x) = ((0,0),x) :=
+    congrArg (fun a => a x) (inclusion_product t n)
+  refine ⟨?_, ?_⟩
+  · intro x y hxy
+    have := congrArg e hxy
+    simpa only [he] using congrArg Prod.snd this
+  · intro y
+    refine ⟨(e y).2, e.injective ?_⟩
+    rw [he]
+    exact Prod.ext (Subsingleton.elim _ _) rfl
+
+instance inclusion2_isIso : IsIso (inclusion (p2 t) 0 (h2 t)) := by
+  have (n : ℤ) : IsIso ((inclusion (p2 t) 0 (h2 t)).f n) :=
+    (ConcreteCategory.isIso_iff_bijective _).2 (inclusion2_bijective t n)
+  exact HomologicalComplex.Hom.isIso_of_components _
+
+def v2Iso : t.V₂ ≅ total (p2 t) 0 (h2 t) := asIso (inclusion (p2 t) 0 (h2 t))
+
+/-- F>=2 really is V2, embedded by its original vertex summand inclusion. -/
+def v2Inclusion : t.V₂ ⟶ total (p1 t) 0 (h1 t) :=
+  biprod.inr ≫ inclusion (p1 t) 0 (h1 t)
+
+omit [Fintype R] in
+theorem v2Inclusion_eq : v2Inclusion t = (v2Iso t).hom ≫ (include2 t).totalMap := by
+  symm
+  exact (include2 t).inclusion_totalMap
+
+omit [Fintype R] in
+/-- The source-one sequence with V2 itself as its first term. -/
+theorem v2_shortExact (n : ℤ) :
+    Function.Injective ((v2Inclusion t).f n) ∧
+    Function.Exact ((v2Inclusion t).f n) ((quotient1 t).totalMap.f n) ∧
+    Function.Surjective ((quotient1 t).totalMap.f n) := by
+  have E := source1_shortExact t n
+  have I := inclusion2_bijective t n
+  rw [v2Inclusion_eq]
+  refine ⟨E.1.comp I.1, ?_, E.2.2⟩
+  intro y
+  constructor
+  · intro hy
+    obtain ⟨x, hx⟩ := (E.2.1 y).mp hy
+    obtain ⟨z, rfl⟩ := I.2 x
+    exact ⟨z, hx⟩
+  · rintro ⟨x, rfl⟩
+    exact E.2.1.apply_apply_eq_zero _
+
+variable (h : Homotopy (t.q ≫ t.p) 0)
+/-- The composite filtration inclusion is the original V2-to-total map. -/
+theorem v2_nested : v2Inclusion t ≫ (include1 t h).totalMap =
+    t.in₂ ≫ inclusion t.p t.q h := by
+  dsimp only [v2Inclusion]
+  rw [Category.assoc, (include1 t h).inclusion_totalMap]
+  rfl
+end ExternalTensor.Section4.SourceFiltration
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Rectification/TensorArrowComparison.lean b/lean/OAI/Algebra/Finitistic/Rectification/TensorArrowComparison.lean
new file mode 100644
index 0000000000000000000000000000000000000000..dd1b81fc938535335aad3482dc1c26c7c641b605
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Rectification/TensorArrowComparison.lean
@@ -0,0 +1,74 @@
+import OAI.Algebra.Finitistic.Bimodule.BimoduleTensorVertexBridge
+import OAI.Algebra.Finitistic.Localization.NativeArrowBridge
+
+namespace OAI
+noncomputable section
+open CategoryTheory
+namespace LittleFinitistic.TensorArrowComparison
+open ExternalTensor.Section4
+universe u
+variable (k B : Type u) [Field k] [Ring B] [Algebra k B]
+variable (N : Type u) [AddCommGroup N] [Module k N] [Module B N]
+
+/-- Tensor the actual right vertex, then identify it with the vertex of the full
+left B-module tensor, preserving the original balanced tensor classes. -/
+def component (e : B) (he : e*e=e) (M : ModuleCat.{u} (Enveloping k B)) :
+    (BalancedTensor.tensorFunctor k B N).obj ((BimoduleVertex.functor k B e).obj M) ≅
+      (LeftVertexHomology.vertex k B e).obj ((BimoduleBalancedTensor.functor k B N).obj M) :=
+  (BalancedVertexImage.equiv k B M e he N).toModuleIso ≪≫
+    (BimoduleTensorVertexBridge.equiv k B N e M).symm.toModuleIso
+
+/-- The tensor/vertex comparison retains left multiplication by every original
+supported arrow, and does not require the evaluation module to be flat. -/
+theorem arrow_square (ei ej a : B) (hi : ei*ei=ei) (hj : ej*ej=ej) (ha : ej*a=a)
+    (M : ModuleCat.{u} (Enveloping k B)) :
+    (BalancedTensor.tensorFunctor k B N).map
+        ((ArrowVertex.arrow k B ei ej a ha).app M) ≫ (component k B N ej hj M).hom =
+      (component k B N ei hi M).hom ≫
+        (LeftVertexHomology.arrow k B ei ej a ha).app ((BimoduleBalancedTensor.functor k B N).obj M) := by
+  let l := ((BalancedTensor.tensorFunctor k B N).map
+    ((ArrowVertex.arrow k B ei ej a ha).app M) ≫ (component k B N ej hj M).hom).hom
+  let r := ((component k B N ei hi M).hom ≫
+    (LeftVertexHomology.arrow k B ei ej a ha).app
+      ((BimoduleBalancedTensor.functor k B N).obj M)).hom
+  apply ModuleCat.hom_ext
+  apply LinearMap.ext
+  intro x
+  change l x = r x
+  induction x using BalancedTensor.induction_on with
+  | hz => exact l.map_zero.trans r.map_zero.symm
+  | ht m n => rfl
+  | ha x y hx hy =>
+    exact (l.map_add x y).trans ((congrArg₂ (· + ·) hx hy).trans (r.map_add x y).symm)
+
+/-- Natural comparison for the full B-valued tensor functor. -/
+def comparison (e : B) (he : e*e=e) :
+    BimoduleVertex.functor k B e ⋙ BalancedTensor.tensorFunctor k B N ≅
+      BimoduleBalancedTensor.functor k B N ⋙ LeftVertexHomology.vertex k B e :=
+  BalancedVertexFunctor.comparison k B e he N ≪≫
+    (BimoduleTensorVertexBridge.comparison k B N e).symm
+
+def complexIso (e : B) (he : e*e=e) (P : BiComplex k B) :
+    (((BalancedTensor.tensorFunctor k B N).mapHomologicalComplex (.up ℤ)).obj
+      (((BimoduleVertex.functor k B e).mapHomologicalComplex (.up ℤ)).obj P)) ≅
+    (((LeftVertexHomology.vertex k B e).mapHomologicalComplex (.up ℤ)).obj
+      (((BimoduleBalancedTensor.functor k B N).mapHomologicalComplex (.up ℤ)).obj P)) :=
+  HomologicalComplex.Hom.isoOfComponents (fun n => component k B N e he (P.X n))
+    (fun n m _ => ((comparison k B N e he).hom.naturality (P.d n m)).symm)
+
+/-- The full chain comparison respects the original left multiplication arrows. -/
+theorem complex_arrow_square (ei ej a : B) (hi : ei*ei=ei) (hj : ej*ej=ej) (ha : ej*a=a)
+    (P : BiComplex k B) :
+    ((BalancedTensor.tensorFunctor k B N).mapHomologicalComplex (.up ℤ)).map
+        (ArrowVertex.arrowComplex k B ei ej a ha P) ≫ (complexIso k B N ej hj P).hom =
+      (complexIso k B N ei hi P).hom ≫
+        ((LeftVertexHomology.arrow k B ei ej a ha).mapHomologicalComplex (.up ℤ)).app
+          (((BimoduleBalancedTensor.functor k B N).mapHomologicalComplex (.up ℤ)).obj P) := by
+  apply HomologicalComplex.Hom.ext
+  funext n
+  exact arrow_square k B N ei ej a hi hj ha (P.X n)
+end LittleFinitistic.TensorArrowComparison
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Rectification/TensorArrowSum.lean b/lean/OAI/Algebra/Finitistic/Rectification/TensorArrowSum.lean
new file mode 100644
index 0000000000000000000000000000000000000000..0344b1943db17e98c3402d0de90074e54fd3a1d1
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Rectification/TensorArrowSum.lean
@@ -0,0 +1,51 @@
+import OAI.Algebra.Finitistic.Encoding.ArrowBasisIso
+
+namespace OAI
+noncomputable section
+open CategoryTheory CategoryTheory.Limits
+namespace LittleFinitistic.TensorArrowSum
+universe u
+variable (k : Type u) [Field k] (d : ℕ)
+
+def insertion (a : Fin (d+1)) : ModuleCat.of k k ⟶ ModuleCat.of k (QuadraticEncoding.Arrows k d) :=
+  biproduct.ι (ArrowBasisIso.family k d) a ≫ (ArrowBasisIso.iso k d).hom
+
+@[simp] theorem insertion_apply (a : Fin (d+1)) (c : k) :
+    (insertion k d a).hom c = c • QuadraticEncoding.basis a :=
+  ArrowBasisIso.injection_apply k d a c
+
+/-- An additive realization of the actual arrow-basis sum is an isomorphism. -/
+theorem desc_isIso {C : Type*} [Category C] [Preadditive C] [HasFiniteBiproducts C]
+    (F : ModuleCat.{u} k ⥤ C) [F.Additive] :
+    IsIso (biproduct.desc (fun a : Fin (d+1) => F.map (insertion k d a))) := by
+  have he : biproduct.desc (fun a : Fin (d+1) => F.map (insertion k d a)) =
+      (F.mapBiproduct (ArrowBasisIso.family k d)).inv ≫ F.map (ArrowBasisIso.iso k d).hom := by
+    apply biproduct.hom_ext'
+    intro a
+    simp only [insertion, Functor.map_comp, Functor.mapBiproduct_inv]
+    erw [biproduct.ι_desc, biproduct.ι_desc_assoc]
+  rw [he]
+  infer_instance
+
+/-- Coordinate isomorphisms identify an actual arrow family with the realized basis. -/
+theorem desc_isIso_of_coordinates {C : Type*} [Category C] [Preadditive C]
+    [HasFiniteBiproducts C] (F : ModuleCat.{u} k ⥤ C) [F.Additive]
+    (X : Fin (d+1) → C) (Y : C) (α : ∀ a, X a ≅ F.obj (ModuleCat.of k k))
+    (β : Y ≅ F.obj (ModuleCat.of k (QuadraticEncoding.Arrows k d)))
+    (f : ∀ a, X a ⟶ Y)
+    (hf : ∀ a, (α a).hom ≫ F.map (insertion k d a) = f a ≫ β.hom) :
+    IsIso (biproduct.desc f) := by
+  have he : biproduct.desc f ≫ β.hom =
+      (biproduct.mapIso α).hom ≫ biproduct.desc (fun a => F.map (insertion k d a)) := by
+    apply biproduct.hom_ext'
+    intro a
+    simp only [biproduct.mapIso_hom,biproduct.ι_desc_assoc,biproduct.ι_map_assoc,biproduct.ι_desc]
+    exact (hf a).symm
+  let := desc_isIso k d F
+  rw [← isIso_comp_right_iff _ β.hom,he]
+  infer_instance
+end LittleFinitistic.TensorArrowSum
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Rectification/TensorComplex.lean b/lean/OAI/Algebra/Finitistic/Rectification/TensorComplex.lean
new file mode 100644
index 0000000000000000000000000000000000000000..f562fb7325662d4705a7ec7a624bc90d8c9d3259
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Rectification/TensorComplex.lean
@@ -0,0 +1,143 @@
+import Mathlib.Algebra.Category.ModuleCat.ChangeOfRings
+import OAI.Algebra.Finitistic.Rectification.TensorProjection
+import OAI.Algebra.Finitistic.Encoding.RelationSequence
+
+namespace OAI
+noncomputable section
+open scoped TensorProduct
+open CategoryTheory
+namespace LittleFinitistic.TensorComplex
+attribute [local instance] ExternalTensor.rightModule
+universe u
+variable (k B : Type u) [Field k] [Ring B] [Algebra k B]
+
+abbrev ScalarModule (N : ModuleCat.{u} Bᵐᵒᵖ) :=
+  (ModuleCat.restrictScalars (algebraMap k Bᵐᵒᵖ)).obj N
+
+instance scalarTower (N : ModuleCat.{u} Bᵐᵒᵖ) :
+    IsScalarTower k Bᵐᵒᵖ (ScalarModule k B N) where
+  smul_assoc c b n := by
+    change (c • b) • (n : N) = algebraMap k Bᵐᵒᵖ c • (b • (n : N))
+    rw [Algebra.smul_def,mul_smul]
+
+variable {k B}
+/-- The actual tensor differential, with the original right B-action. -/
+def mapRight (M : ModuleCat.{u} k) {N N' : ModuleCat.{u} Bᵐᵒᵖ} (g : N ⟶ N') :
+    (M ⊗[k] ScalarModule k B N) →ₗ[Bᵐᵒᵖ] (M ⊗[k] ScalarModule k B N') where
+  __ := (TensorProduct.map LinearMap.id
+    ((ModuleCat.restrictScalars (algebraMap k Bᵐᵒᵖ)).map g).hom).toAddMonoidHom
+  map_smul' c x := by
+    induction x using TensorProduct.inductionOn with
+    | tmul m n =>
+      change TensorProduct.mk k M (ScalarModule k B N') m (g.hom (c • (n : N))) = TensorProduct.mk k M (ScalarModule k B N') m (c • g.hom n)
+      exact congrArg (TensorProduct.mk k M (ScalarModule k B N') m) (g.hom.map_smul c (n : N))
+    | add x y hx hy => simp_all [smul_add]
+
+@[simp] theorem mapRight_tmul (M : ModuleCat.{u} k) {N N' : ModuleCat.{u} Bᵐᵒᵖ}
+    (g : N ⟶ N') (m : M) (n : ScalarModule k B N) :
+    mapRight M g (m ⊗ₜ[k] n) = TensorProduct.mk k M (ScalarModule k B N') m (g.hom n) := rfl
+
+variable (D : CochainComplex (ModuleCat.{u} Bᵐᵒᵖ) ℤ)
+/-- Tensor a vector space with every term and differential of the given right-module complex. -/
+def complex (M : ModuleCat.{u} k) : CochainComplex (ModuleCat.{u} Bᵐᵒᵖ) ℤ where
+  X i := ModuleCat.of Bᵐᵒᵖ (M ⊗[k] ScalarModule k B (D.X i))
+  d i j := ModuleCat.ofHom (mapRight M (D.d i j))
+  shape i j hij := by
+    apply ModuleCat.hom_ext
+    apply LinearMap.ext
+    intro x
+    induction x using TensorProduct.inductionOn with
+    | tmul m n =>
+      have h : (D.d i j).hom (n : D.X i) = 0 := by rw [D.shape i j hij]; rfl
+      exact (congrArg (TensorProduct.mk k M (ScalarModule k B (D.X j)) m) h).trans
+        (map_zero (TensorProduct.mk k M (ScalarModule k B (D.X j)) m))
+    | add x y hx hy =>
+      exact (map_add _ _ _).trans ((congrArg₂ (· + ·) hx hy).trans (map_add _ _ _).symm)
+  d_comp_d' i j l hij hjl := by
+    apply ModuleCat.hom_ext
+    apply LinearMap.ext
+    intro x
+    induction x using TensorProduct.inductionOn with
+    | tmul m n =>
+      change TensorProduct.mk k M (ScalarModule k B (D.X l)) m ((D.d j l).hom ((D.d i j).hom n)) = 0
+      have h := congrArg (fun f : D.X i ⟶ D.X l => f.hom n) (D.d_comp_d i j l)
+      change (D.d j l).hom ((D.d i j).hom n) = 0 at h
+      exact (congrArg (TensorProduct.mk k M (ScalarModule k B (D.X l)) m) h).trans
+        (map_zero (TensorProduct.mk k M (ScalarModule k B (D.X l)) m))
+    | add x y hx hy =>
+      exact (map_add _ _ _).trans ((congrArg₂ (· + ·) hx hy).trans (map_add _ _ _).symm)
+
+/-- The first-factor tensor map is a chain map. -/
+def complexMap {M M' : ModuleCat.{u} k} (f : M ⟶ M') : complex D M ⟶ complex D M' where
+  f i := ModuleCat.ofHom (TensorProjection.rightMap (B := B)
+    (N := ScalarModule k B (D.X i)) f.hom)
+  comm' i j hij := by
+    apply ModuleCat.hom_ext
+    apply LinearMap.ext
+    intro x
+    induction x using TensorProduct.inductionOn with
+    | tmul m n => rfl
+    | add x y hx hy =>
+      exact (map_add _ _ _).trans ((congrArg₂ (· + ·) hx hy).trans (map_add _ _ _).symm)
+
+/-- The genuine additive tensor-with-D functor required by the path exact sequence. -/
+def tensorFunctor : ModuleCat.{u} k ⥤ CochainComplex (ModuleCat.{u} Bᵐᵒᵖ) ℤ where
+  obj := complex D
+  map := complexMap D
+  map_id M := by
+    apply HomologicalComplex.Hom.ext
+    funext i
+    apply ModuleCat.hom_ext
+    apply LinearMap.ext
+    intro x
+    induction x using TensorProduct.inductionOn with
+    | tmul m n => rfl
+    | add x y hx hy =>
+      exact (map_add _ _ _).trans ((congrArg₂ (· + ·) hx hy).trans (map_add _ _ _).symm)
+  map_comp f g := by
+    apply HomologicalComplex.Hom.ext
+    funext i
+    apply ModuleCat.hom_ext
+    apply LinearMap.ext
+    intro x
+    induction x using TensorProduct.inductionOn with
+    | tmul m n => rfl
+    | add x y hx hy =>
+      exact (map_add _ _ _).trans ((congrArg₂ (· + ·) hx hy).trans (map_add _ _ _).symm)
+
+instance tensorFunctor_additive : (tensorFunctor (k := k) D).Additive where
+  map_add {M M'} {f g} := by
+    apply HomologicalComplex.Hom.ext
+    funext i
+    apply ModuleCat.hom_ext
+    apply LinearMap.ext
+    intro x
+    induction x using TensorProduct.inductionOn with
+    | tmul m n => exact TensorProduct.add_tmul _ _ _
+    | add x y hx hy =>
+      change TensorProjection.rightMap (B := B) (f.hom + g.hom) (x+y) =
+        TensorProjection.rightMap (B := B) f.hom (x+y) + TensorProjection.rightMap (B := B) g.hom (x+y)
+      simp only [map_add]
+      change TensorProjection.rightMap (B := B) (f.hom + g.hom) x =
+        TensorProjection.rightMap (B := B) f.hom x + TensorProjection.rightMap (B := B) g.hom x at hx
+      change TensorProjection.rightMap (B := B) (f.hom + g.hom) y =
+        TensorProjection.rightMap (B := B) f.hom y + TensorProjection.rightMap (B := B) g.hom y at hy
+      rw [hx,hy]
+      abel
+
+/-- The adjacent-vertex graded piece is the cone of the path-space identity. -/
+theorem adjacent_total_acyclic (M : ModuleCat.{u} k) :
+    (CochainComplex.mappingCone (𝟙 (complex D M))).Acyclic :=
+  RectificationAcyclic.cone_acyclic _
+
+/-- The source-0 path-relation graded piece is acyclic for the actual tensor functor. -/
+theorem relation_total_acyclic {d t : ℕ} (P : QuadraticEncoding.Relations k d t) :
+    (RectificationTotal.total ((RelationSequence.sequence P).map (tensorFunctor (k := k) D)).g
+      ((RelationSequence.sequence P).map (tensorFunctor (k := k) D)).f
+      (Homotopy.ofEq ((RelationSequence.sequence P).map (tensorFunctor (k := k) D)).zero)).Acyclic :=
+  RelationSequence.realized_sequence_total_acyclic P (tensorFunctor (k := k) D)
+end LittleFinitistic.TensorComplex
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Rectification/TensorProjection.lean b/lean/OAI/Algebra/Finitistic/Rectification/TensorProjection.lean
new file mode 100644
index 0000000000000000000000000000000000000000..9c8189a247d7ab5efc503f0f4f9abad3dd4f5b21
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Rectification/TensorProjection.lean
@@ -0,0 +1,82 @@
+import Mathlib.LinearAlgebra.TensorProduct.Tower
+import OAI.Algebra.Finitistic.Rectification.ExternalTensor
+
+namespace OAI
+
+noncomputable section
+open scoped TensorProduct
+namespace LittleFinitistic.TensorProjection
+attribute [local instance] ExternalTensor.rightModule
+variable {k B M M' N : Type*} [Field k] [Ring B] [Algebra k B]
+  [AddCommGroup M] [Module k M] [AddCommGroup M'] [Module k M']
+  [AddCommGroup N] [Module k N] [Module Bᵐᵒᵖ N] [IsScalarTower k Bᵐᵒᵖ N]
+
+/-- Tensor a k-linear map with the identity while retaining the actual right B-action. -/
+def rightMap (f : M →ₗ[k] M') : (M ⊗[k] N) →ₗ[Bᵐᵒᵖ] (M' ⊗[k] N) where
+  __ := (TensorProduct.map f LinearMap.id).toAddMonoidHom
+  map_smul' c x := by
+    induction x using TensorProduct.inductionOn with
+    | tmul m n => simp [ExternalTensor.right_smul_tmul]
+    | add x y hx hy => simp_all [smul_add]
+
+@[simp] theorem rightMap_tmul (f : M →ₗ[k] M') (m : M) (n : N) :
+    rightMap (B := B) f (m ⊗ₜ[k] n) = f m ⊗ₜ[k] n := rfl
+
+/-- Transport a first-factor vector-space equivalence as an actual right-module equivalence. -/
+def rightCongr (e : M ≃ₗ[k] M') : (M ⊗[k] N) ≃ₗ[Bᵐᵒᵖ] (M' ⊗[k] N) where
+  __ := rightMap (B := B) (N := N) e.toLinearMap
+  invFun := rightMap (B := B) (N := N) e.symm.toLinearMap
+  left_inv x := by
+    induction x using TensorProduct.inductionOn with
+    | tmul m n => simp
+    | add x y hx hy => simp_all
+  right_inv x := by
+    induction x using TensorProduct.inductionOn with
+    | tmul m n => simp
+    | add x y hx hy => simp_all
+
+variable (p : M →ₗ[k] M)
+
+/-- The actual fixed submodule for a projector on the first tensor factor. -/
+def fixed : Submodule Bᵐᵒᵖ (M ⊗[k] N) := (rightMap (B := B) p - LinearMap.id).ker
+
+@[simp] theorem mem_fixed (x : M ⊗[k] N) : x ∈ fixed (B := B) p ↔ rightMap (B := B) p x = x := by
+  simp [fixed,sub_eq_zero]
+
+theorem range_fixed (hp : p.comp p = p) (x : p.range) : p x.val = x.val := by
+  obtain ⟨m,hm⟩ := x.property
+  have h := LinearMap.congr_fun hp m
+  simpa only [LinearMap.comp_apply,hm] using h
+
+/-- The eigenspace e(M tensor N) is exactly (eM) tensor N as a right module. -/
+def imageTensorEquiv (hp : p.comp p = p) : (p.range ⊗[k] N) ≃ₗ[Bᵐᵒᵖ] fixed (B := B) (N := N) p where
+  toFun x := ⟨rightMap (B := B) (N := N) p.range.subtype x,by
+    rw [mem_fixed]
+    induction x using TensorProduct.inductionOn with
+    | tmul m n => simp [range_fixed p hp m]
+    | add x y hx hy => simp_all⟩
+  invFun x := rightMap (B := B) (N := N) p.rangeRestrict x.val
+  left_inv x := by
+    induction x using TensorProduct.inductionOn with
+    | tmul m n =>
+      simp only [rightMap_tmul]
+      congr 1
+      apply Subtype.ext
+      exact range_fixed p hp m
+    | add x y hx hy => simp_all
+  right_inv x := by
+    apply Subtype.ext
+    have h : rightMap (B := B) p.range.subtype (rightMap (B := B) (N := N) p.rangeRestrict x.val) =
+        rightMap (B := B) p x.val := by
+      generalize x.val = y
+      induction y using TensorProduct.inductionOn with
+      | tmul m n => rfl
+      | add a b ha hb => simp_all
+    exact h.trans ((mem_fixed p x.val).1 x.property)
+  map_add' x y := Subtype.ext (map_add _ x y)
+  map_smul' c x := Subtype.ext (map_smul _ c x)
+end LittleFinitistic.TensorProjection
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Rectification/ThirdVertex.lean b/lean/OAI/Algebra/Finitistic/Rectification/ThirdVertex.lean
new file mode 100644
index 0000000000000000000000000000000000000000..b13f6362b7a697293ad5ebb1855d543d6a04f181
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Rectification/ThirdVertex.lean
@@ -0,0 +1,55 @@
+import OAI.Algebra.Finitistic.Rectification.ThirdVertexFiltration
+import OAI.Algebra.Finitistic.Rectification.InducedRectification
+import OAI.Algebra.Finitistic.Rectification.FinalGradedAcyclic
+
+namespace OAI
+noncomputable section
+open CategoryTheory CategoryTheory.Limits HomologicalComplex
+namespace LittleFinitistic.ThirdVertex
+open ExternalTensor.Section4 ExternalTensor.Section4.SourceFiltration
+universe u
+variable {k : Type u} [Field k] {d t : ℕ} (P : QuadraticEncoding.Relations k d t)
+variable (D₀ D₁ D₂ : RightComplex (QuadraticEncoding.B P))
+variable (f : Fin (d+1) → (D₀ ⟶ D₁)) (g : Fin (d+1) → (D₁ ⟶ D₂))
+variable (H : ∀ r, Homotopy (relationMap (ConcreteQuadraticDiagram.quadratic P) D₀ D₁ D₂ f g r) 0)
+local notation "s" => ConcreteQuadraticDiagram.quadratic P
+abbrev vertexComplex := AdjacentArrowSum.vertexComplex (QuadraticEncoding.composition P) 2
+
+theorem filtration_inclusion_quasiIso :
+    QuasiIso ((vertexComplex P).map (Exactness.i1 s D₀ D₁ D₂ f g H)) := by
+  let S := Complex.source0 s D₀ D₁ D₂ f g H
+  exact RectificationAcyclic.quasiIso_of_acyclic_quotient (S.map (vertexComplex P))
+    (Complex.vertex_shortExact ((s).e₂)
+      ((ThreeVertexAlgebra.directedSystem (QuadraticEncoding.composition P)).idem 2) S
+      (Complex.source0_shortExact s D₀ D₁ D₂ f g H))
+    (FinalGradedAcyclic.grade0_vertex2_acyclic P D₀ D₁ D₂ f g)
+
+def iota : D₂ ⟶ (vertexComplex P).obj (Exactness.P s D₀ D₁ D₂ f g H) :=
+  (VertexColumnComplex.diagonalComplexIso (QuadraticEncoding.composition P) 2 D₂).hom ≫
+    (vertexComplex P).map (Exactness.i2 s D₀ D₁ D₂ f g) ≫
+    (vertexComplex P).map (Exactness.i1 s D₀ D₁ D₂ f g H)
+
+theorem iota_quasiIso : QuasiIso (iota P D₀ D₁ D₂ f g H) := by
+  let := ThirdVertexFiltration.inclusion_quasiIso P D₀ D₁ D₂ f g
+  let := filtration_inclusion_quasiIso P D₀ D₁ D₂ f g H
+  let e : D₂ ≅ (vertexComplex P).obj ((columnComplex k (QuadraticEncoding.B P) (s).e₂).obj D₂) :=
+    VertexColumnComplex.diagonalComplexIso (QuadraticEncoding.composition P) 2 D₂
+  change QuasiIso (e.hom ≫ (vertexComplex P).map (Exactness.i2 s D₀ D₁ D₂ f g) ≫
+    (vertexComplex P).map (Exactness.i1 s D₀ D₁ D₂ f g H))
+  infer_instance
+
+/-- The final-vertex map is the original e2 tensor insertion followed by the original total inclusion. -/
+theorem iota_original : iota P D₀ D₁ D₂ f g H =
+    (VertexColumnComplex.diagonalComplexIso (QuadraticEncoding.composition P) 2 D₂).hom ≫
+      (vertexComplex P).map ((Exactness.data s D₀ D₁ D₂ f g).in₂) ≫
+      (vertexComplex P).map (InducedRectification.inclusion s D₀ D₁ D₂ f g H) := by
+  dsimp only [iota]
+  erw [← (vertexComplex P).map_comp (Exactness.i2 s D₀ D₁ D₂ f g)
+    (Exactness.i1 s D₀ D₁ D₂ f g H),
+    (Exactness.exact_source_filtration s D₀ D₁ D₂ f g H 0).2.2, Functor.map_comp]
+  rfl
+end LittleFinitistic.ThirdVertex
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Rectification/ThirdVertexFiltration.lean b/lean/OAI/Algebra/Finitistic/Rectification/ThirdVertexFiltration.lean
new file mode 100644
index 0000000000000000000000000000000000000000..bc99ceac0f21403f9b08c5ffdab1e88864a6bce4
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Rectification/ThirdVertexFiltration.lean
@@ -0,0 +1,28 @@
+import OAI.Algebra.Finitistic.Rectification.GradedVertexAcyclic
+
+namespace OAI
+noncomputable section
+open CategoryTheory CategoryTheory.Limits HomologicalComplex
+namespace LittleFinitistic.ThirdVertexFiltration
+open ExternalTensor.Section4 ExternalTensor.Section4.SourceFiltration
+universe u
+variable {k : Type u} [Field k] {d t : ℕ} (P : QuadraticEncoding.Relations k d t)
+variable (D₀ D₁ D₂ : RightComplex (QuadraticEncoding.B P))
+variable (f : Fin (d+1) → (D₀ ⟶ D₁)) (g : Fin (d+1) → (D₁ ⟶ D₂))
+local notation "s" => ConcreteQuadraticDiagram.quadratic P
+abbrev vertexComplex := AdjacentArrowSum.vertexComplex (QuadraticEncoding.composition P) 2
+
+/-- The original deepest source-filtration inclusion is a quasi-isomorphism at vertex two. -/
+theorem inclusion_quasiIso :
+    QuasiIso ((vertexComplex P).map (Exactness.i2 s D₀ D₁ D₂ f g)) := by
+  let S := Complex.source1 s D₀ D₁ D₂ f g
+  exact RectificationAcyclic.quasiIso_of_acyclic_quotient (S.map (vertexComplex P))
+    (Complex.vertex_shortExact ((s).e₂)
+      ((ThreeVertexAlgebra.directedSystem (QuadraticEncoding.composition P)).idem 2) S
+      (Complex.source1_shortExact s D₀ D₁ D₂ f g))
+    (GradedVertexAcyclic.grade1_vertex2_acyclic P D₀ D₁ D₂ f g)
+end LittleFinitistic.ThirdVertexFiltration
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Rectification/TotalExact.lean b/lean/OAI/Algebra/Finitistic/Rectification/TotalExact.lean
new file mode 100644
index 0000000000000000000000000000000000000000..8e81abf7e973e19c9a84771754cc300be84eff29
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Rectification/TotalExact.lean
@@ -0,0 +1,89 @@
+import OAI.Algebra.Finitistic.Rectification.TotalFunctorial
+import OAI.Algebra.Finitistic.Rectification.ExactProducts
+import Mathlib.Algebra.Category.ModuleCat.Biproducts
+
+namespace OAI
+open CategoryTheory CategoryTheory.Limits HomologicalComplex CochainComplex
+noncomputable section
+namespace LittleFinitistic.RectificationTotal
+universe u
+variable {S : Type u} [Ring S]
+
+/-- The canonical binary sum/product identification respects the supplied maps. -/
+theorem prodIso_naturality {X Y X' Y' : ModuleCat.{u} S} (f : X ⟶ X') (g : Y ⟶ Y') :
+    biprod.map f g ≫ (ModuleCat.biprodIsoProd X' Y').hom =
+      (ModuleCat.biprodIsoProd X Y).hom ≫ ModuleCat.ofHom (f.hom.prodMap g.hom) := by
+  apply (cancel_epi (ModuleCat.biprodIsoProd X Y).inv).1
+  apply (cancel_mono (ModuleCat.biprodIsoProd X' Y').inv).1
+  simp only [Category.assoc, Iso.hom_inv_id, Category.comp_id, Iso.inv_hom_id_assoc]
+  apply biprod.hom_ext
+  · simp only [Category.assoc, biprod.map_fst, ModuleCat.biprodIsoProd_inv_comp_fst]
+    rw [← Category.assoc, ModuleCat.biprodIsoProd_inv_comp_fst]
+    rfl
+  · simp only [Category.assoc, biprod.map_snd, ModuleCat.biprodIsoProd_inv_comp_snd]
+    rw [← Category.assoc, ModuleCat.biprodIsoProd_inv_comp_snd]
+    rfl
+
+variable {L₀ L₁ L₂ M₀ M₁ M₂ N₀ N₁ N₂ : CochainComplex (ModuleCat.{u} S) ℤ}
+variable {p : L₁ ⟶ L₀} {q : L₂ ⟶ L₁} {h : Homotopy (q ≫ p) 0}
+variable {p' : M₁ ⟶ M₀} {q' : M₂ ⟶ M₁} {h' : Homotopy (q' ≫ p') 0}
+variable {p'' : N₁ ⟶ N₀} {q'' : N₂ ⟶ N₁} {h'' : Homotopy (q'' ≫ p'') 0}
+
+/-- The native total's term as the actual product of the three input modules. -/
+def totalTermIso (p : L₁ ⟶ L₀) (q : L₂ ⟶ L₁) (h : Homotopy (q ≫ p) 0) (n : ℤ) :
+    (total p q h).X n ≅ ModuleCat.of S ((L₂.X (n+2) × L₁.X (n+1)) × L₀.X n) :=
+  termIso p q h n ≪≫
+    biprod.mapIso (ModuleCat.biprodIsoProd _ _) (Iso.refl _) ≪≫
+    ModuleCat.biprodIsoProd _ _
+
+namespace MapData
+variable (a : MapData p q h p' q' h')
+
+/-- The explicit total map acts componentwise in the concrete term product. -/
+theorem totalMap_product (n : ℤ) :
+    a.totalMap.f n ≫ (totalTermIso p' q' h' n).hom =
+      (totalTermIso p q h n).hom ≫ ModuleCat.ofHom
+        (((a.f₂.f (n+2)).hom.prodMap (a.f₁.f (n+1)).hom).prodMap (a.f₀.f n).hom) := by
+  have hb :
+      biprod.map (biprod.map (a.f₂.f (n+2)) (a.f₁.f (n+1))) (a.f₀.f n) ≫
+        biprod.map (ModuleCat.biprodIsoProd (M₂.X (n+2)) (M₁.X (n+1))).hom (𝟙 (M₀.X n)) =
+      biprod.map (ModuleCat.biprodIsoProd (L₂.X (n+2)) (L₁.X (n+1))).hom (𝟙 (L₀.X n)) ≫
+        biprod.map (ModuleCat.ofHom ((a.f₂.f (n+2)).hom.prodMap (a.f₁.f (n+1)).hom)) (a.f₀.f n) := by
+    rw [biprodMap_comp, biprodMap_comp, Category.comp_id, Category.id_comp,
+      prodIso_naturality]
+  dsimp only [totalTermIso, Iso.trans_hom, biprod.mapIso_hom, Iso.refl_hom]
+  rw [← Category.assoc, a.totalMap_term]
+  simp only [Category.assoc]
+  erw [biprod.mapIso_hom, biprod.mapIso_hom, Iso.refl_hom, Iso.refl_hom]
+  rw [reassoc_of% hb]
+  rw [prodIso_naturality]
+
+/-- A short exact triple of column maps induces short exactness of the actual
+supplied total maps, retaining the inclusion and quotient maps themselves. -/
+theorem totalMap_shortExact (b : MapData p' q' h' p'' q'' h'')
+    (ex₀ : ∀ n, Function.Exact (a.f₀.f n) (b.f₀.f n))
+    (ex₁ : ∀ n, Function.Exact (a.f₁.f n) (b.f₁.f n))
+    (ex₂ : ∀ n, Function.Exact (a.f₂.f n) (b.f₂.f n))
+    (inj₀ : ∀ n, Function.Injective (a.f₀.f n))
+    (inj₁ : ∀ n, Function.Injective (a.f₁.f n))
+    (inj₂ : ∀ n, Function.Injective (a.f₂.f n))
+    (surj₀ : ∀ n, Function.Surjective (b.f₀.f n))
+    (surj₁ : ∀ n, Function.Surjective (b.f₁.f n))
+    (surj₂ : ∀ n, Function.Surjective (b.f₂.f n)) (n : ℤ) :
+    Function.Injective (a.totalMap.f n) ∧
+      Function.Exact (a.totalMap.f n) (b.totalMap.f n) ∧
+      Function.Surjective (b.totalMap.f n) := by
+  let inner := shortExact_prod (ex₂ (n+2)) (ex₁ (n+1))
+    (inj₂ (n+2)) (inj₁ (n+1)) (surj₂ (n+2)) (surj₁ (n+1))
+  let all := shortExact_prod inner.2.1 (ex₀ n) inner.1 (inj₀ n) inner.2.2 (surj₀ n)
+  apply shortExact_transport (totalTermIso p q h n).toLinearEquiv.toEquiv
+    (totalTermIso p' q' h' n).toLinearEquiv.toEquiv
+    (totalTermIso p'' q'' h'' n).toLinearEquiv.toEquiv (by simp)
+    (fun x => congrArg (fun f => f x) (a.totalMap_product n))
+    (fun x => congrArg (fun f => f x) (b.totalMap_product n)) all.1 all.2.1 all.2.2
+end MapData
+end LittleFinitistic.RectificationTotal
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Rectification/TotalFinite.lean b/lean/OAI/Algebra/Finitistic/Rectification/TotalFinite.lean
new file mode 100644
index 0000000000000000000000000000000000000000..f74bfc63ccba198548927cbbac60de42f861d3be
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Rectification/TotalFinite.lean
@@ -0,0 +1,53 @@
+import OAI.Algebra.Finitistic.Rectification.RectificationTotal
+import OAI.Algebra.Finitistic.Rectification.ColumnFinite
+
+namespace OAI
+open CategoryTheory CategoryTheory.Limits HomologicalComplex CochainComplex
+noncomputable section
+namespace ExternalTensor.Section4
+universe u
+variable {k : Type u} [Field k]
+section General
+variable {C : Type*} [Category C] [Preadditive C] [HasBinaryBiproducts C]
+variable {L₀ L₁ L₂ : CochainComplex C ℤ} (p : L₁ ⟶ L₀) (q : L₂ ⟶ L₁)
+    (h : Homotopy (q ≫ p) 0)
+
+/-- The rectification total has finite-dimensional terms whenever
+an additive scalar restriction makes all three columns finite-dimensional. -/
+theorem total_finite_after (F : C ⥤ ModuleCat.{u} k) [F.Additive]
+    (h₀ : ∀ i, FiniteDimensional k (F.obj (L₀.X i)))
+    (h₁ : ∀ i, FiniteDimensional k (F.obj (L₁.X i)))
+    (h₂ : ∀ i, FiniteDimensional k (F.obj (L₂.X i))) (i : ℤ) :
+    FiniteDimensional k (F.obj ((LittleFinitistic.RectificationTotal.total p q h).X i)) := by
+  let := preservesBinaryBiproducts_of_preservesBiproducts F
+  apply finite_of_iso k (F.mapIso (LittleFinitistic.RectificationTotal.termIso p q h i) ≪≫
+    F.mapBiprod _ _ ≪≫ biprod.mapIso (F.mapBiprod _ _) (Iso.refl _))
+  exact biprod_finite k (biprod_finite k (h₂ (i+2)) (h₁ (i+1))) (h₀ i)
+
+end General
+
+variable {B : Type u} [Ring B] [Algebra k B]
+variable {A J R : Type} [Fintype A] [Fintype J] [Fintype R]
+variable (s : Quadratic k B (A := A) (J := J) (R := R))
+variable (D₀ D₁ D₂ : RightComplex B)
+variable (f : A → (D₀ ⟶ D₁)) (g : J → (D₁ ⟶ D₂))
+variable (H : ∀ r, Homotopy (relationMap s D₀ D₁ D₂ f g r) 0)
+
+/-- The finite-dimensionality conclusion for the manuscript's constructed P,
+with no projectivity or finite-dimensionality assumption on P or its columns. -/
+theorem induced_total_finite [FiniteDimensional k B]
+    (h₀ : ∀ i, Module.Finite Bᵐᵒᵖ (D₀.X i))
+    (h₁ : ∀ i, Module.Finite Bᵐᵒᵖ (D₁.X i))
+    (h₂ : ∀ i, Module.Finite Bᵐᵒᵖ (D₂.X i)) (i : ℤ) :
+    FiniteDimensional k ((forgetK k B).obj
+      ((LittleFinitistic.RectificationTotal.total (p s D₀ D₁ D₂ f g)
+        (q s D₀ D₁ D₂ f g) (nullHomotopy s D₀ D₁ D₂ f g H)).X i)) := by
+  exact total_finite_after _ _ _ (forgetK k B)
+    (fun n => (columns_finite s D₀ D₁ D₂ f g h₀ h₁ h₂ n).1)
+    (fun n => (columns_finite s D₀ D₁ D₂ f g h₀ h₁ h₂ n).2.1)
+    (fun n => (columns_finite s D₀ D₁ D₂ f g h₀ h₁ h₂ n).2.2) i
+end ExternalTensor.Section4
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Rectification/TotalFunctorial.lean b/lean/OAI/Algebra/Finitistic/Rectification/TotalFunctorial.lean
new file mode 100644
index 0000000000000000000000000000000000000000..3a3c903ee300cd03dccf6dca54990602debe250a
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Rectification/TotalFunctorial.lean
@@ -0,0 +1,169 @@
+import OAI.Algebra.Finitistic.Rectification.RectificationTotal
+
+namespace OAI
+open CategoryTheory CategoryTheory.Limits HomologicalComplex CochainComplex
+open CochainComplex.HomComplex
+noncomputable section
+namespace LittleFinitistic.RectificationTotal
+variable {C : Type*} [Category C] [Preadditive C] [HasBinaryBiproducts C]
+theorem biprodMap_comp {U V W X Y Z : C} (f : U ⟶ W) (g : V ⟶ X)
+    (f' : W ⟶ Y) (g' : X ⟶ Z) :
+    biprod.map f g ≫ biprod.map f' g' = biprod.map (f ≫ f') (g ≫ g') := by
+  apply biprod.hom_ext <;> simp
+
+variable {A B A' B' A'' B'' : CochainComplex C ℤ}
+
+/-- A strictly commuting square induces the ordinary diagonal map of cones. -/
+def coneMap (q : A ⟶ B) (q' : A' ⟶ B') (u : A ⟶ A') (v : B ⟶ B')
+    (w : u ≫ q' = q ≫ v) : mappingCone q ⟶ mappingCone q' :=
+  homotopyCofiber.mapArrowHom q q' (fun j => ⟨j-1, by simp⟩)
+    (Arrow.homMk u v w)
+
+@[reassoc (attr := simp)]
+theorem coneMap_inl (q : A ⟶ B) (q' : A' ⟶ B') (u : A ⟶ A') (v : B ⟶ B')
+    (w : u ≫ q' = q ≫ v) (i j : ℤ) (hij : i + (-1) = j) :
+    (mappingCone.inl q).v i j hij ≫ (coneMap q q' u v w).f j =
+      u.f i ≫ (mappingCone.inl q').v i j hij := by
+  dsimp [coneMap, homotopyCofiber.mapArrowHom, mappingCone.inl]
+  erw [homotopyCofiber.inlX_desc_f]
+  simp
+  congr 1
+  exact homotopyCofiber.inrCompHomotopy_hom q' _ i j (by change j+1=i; omega)
+
+@[reassoc (attr := simp)]
+theorem coneMap_inr (q : A ⟶ B) (q' : A' ⟶ B') (u : A ⟶ A') (v : B ⟶ B')
+    (w : u ≫ q' = q ≫ v) (i : ℤ) :
+    (mappingCone.inr q).f i ≫ (coneMap q q' u v w).f i =
+      v.f i ≫ (mappingCone.inr q').f i := by
+  dsimp [coneMap, homotopyCofiber.mapArrowHom, mappingCone.inr]
+  exact homotopyCofiber.inrX_desc_f _ _ _ _
+
+@[reassoc (attr := simp)]
+theorem cone_inl_termIso (q : A ⟶ B) (i j : ℤ) (hij : i+1=j) :
+    (mappingCone.inl q).v j i (by omega) ≫ (homotopyCofiber.XIsoBiprod q i j hij).hom =
+      biprod.inl :=
+  homotopyCofiber.inlX_XIsoBiprod_hom _ _ _ _
+
+@[reassoc (attr := simp)]
+theorem cone_inr_termIso (q : A ⟶ B) (i j : ℤ) (hij : i+1=j) :
+    (mappingCone.inr q).f i ≫ (homotopyCofiber.XIsoBiprod q i j hij).hom =
+      biprod.inr :=
+  homotopyCofiber.inrX_XIsoBiprod_hom _ _ _ _
+
+/-- On terms the cone map is exactly the sum of the two supplied maps. -/
+theorem coneMap_term (q : A ⟶ B) (q' : A' ⟶ B') (u : A ⟶ A') (v : B ⟶ B')
+    (w : u ≫ q' = q ≫ v) (i j : ℤ) (hij : i+1=j) :
+    (coneMap q q' u v w).f i ≫ (homotopyCofiber.XIsoBiprod q' i j hij).hom =
+      (homotopyCofiber.XIsoBiprod q i j hij).hom ≫ biprod.map (u.f j) (v.f i) := by
+  apply mappingCone.ext_from q j i hij
+  · erw [coneMap_inl_assoc, cone_inl_termIso, ← Category.assoc, cone_inl_termIso,
+      biprod.inl_map]
+  · erw [coneMap_inr_assoc, cone_inr_termIso, ← Category.assoc, cone_inr_termIso,
+      biprod.inr_map]
+
+@[simp]
+theorem coneMap_id (q : A ⟶ B) : coneMap q q (𝟙 A) (𝟙 B) (by simp) = 𝟙 _ := by
+  change homotopyCofiber.mapArrowHom q q _ (𝟙 _) = 𝟙 _
+  exact homotopyCofiber.mapArrowHom_id _ _
+
+theorem coneMap_comp (q : A ⟶ B) (q' : A' ⟶ B') (q'' : A'' ⟶ B'')
+    (u : A ⟶ A') (v : B ⟶ B') (w : u ≫ q' = q ≫ v)
+    (u' : A' ⟶ A'') (v' : B' ⟶ B'') (w' : u' ≫ q'' = q' ≫ v') :
+    coneMap q q'' (u ≫ u') (v ≫ v') (by rw [Category.assoc, w', ← Category.assoc, w, Category.assoc]) =
+      coneMap q q' u v w ≫ coneMap q' q'' u' v' w' := by
+  exact homotopyCofiber.mapArrowHom_comp _ _ _ _ (Arrow.homMk u v w) (Arrow.homMk u' v' w')
+
+variable {L₀ L₁ L₂ M₀ M₁ M₂ N₀ N₁ N₂ : CochainComplex C ℤ}
+variable {p : L₁ ⟶ L₀} {q : L₂ ⟶ L₁} {h : Homotopy (q ≫ p) 0}
+variable {p' : M₁ ⟶ M₀} {q' : M₂ ⟶ M₁} {h' : Homotopy (q' ≫ p') 0}
+
+/-- Morphisms preserve both degree-zero maps and the specified relation
+homotopy, which is part of the three-column input data. -/
+structure MapData (p : L₁ ⟶ L₀) (q : L₂ ⟶ L₁) (h : Homotopy (q ≫ p) 0)
+    (p' : M₁ ⟶ M₀) (q' : M₂ ⟶ M₁) (h' : Homotopy (q' ≫ p') 0) where
+  f₀ : L₀ ⟶ M₀
+  f₁ : L₁ ⟶ M₁
+  f₂ : L₂ ⟶ M₂
+  commP : f₁ ≫ p' = p ≫ f₀
+  commQ : f₂ ≫ q' = q ≫ f₁
+  commH : ∀ i j, f₂.f i ≫ h'.hom i j = h.hom i j ≫ f₀.f j
+
+namespace MapData
+variable (a : MapData p q h p' q' h')
+
+def inner : mappingCone q ⟶ mappingCone q' := coneMap q q' a.f₂ a.f₁ a.commQ
+
+theorem rectifyingMap_naturality : a.inner ≫ rectifyingMap p' q' h' =
+    rectifyingMap p q h ≫ a.f₀ := by
+  ext n
+  apply mappingCone.ext_from q (n+1) n rfl
+  · simp only [comp_f, inner, coneMap_inl_assoc, rectifyingMap, mappingCone.inl_v_desc_f_assoc,
+      mappingCone.inl_v_desc_f]
+    exact a.commH (n+1) n
+  · simp only [comp_f, inner, coneMap_inr_assoc, rectifyingMap,
+      mappingCone.inr_f_desc_f_assoc, mappingCone.inr_f_desc_f]
+    exact congrArg (fun f => f.f n) a.commP
+
+/-- The induced chain map of the native primary's actual iterated-cone total. -/
+def totalMap : total p q h ⟶ total p' q' h' :=
+  coneMap (rectifyingMap p q h) (rectifyingMap p' q' h') a.inner a.f₀
+    a.rectifyingMap_naturality
+
+/-- The zero-column inclusion is preserved by the actual induced total map. -/
+@[reassoc]
+theorem inclusion_totalMap : inclusion p q h ≫ a.totalMap =
+    a.f₀ ≫ inclusion p' q' h' := by
+  ext n
+  exact coneMap_inr _ _ _ _ _ n
+
+/-- The induced total map is the actual diagonal triple under the native
+term decomposition, including both cohomological shifts. -/
+theorem totalMap_term (n : ℤ) :
+    a.totalMap.f n ≫ (termIso p' q' h' n).hom =
+      (termIso p q h n).hom ≫
+        biprod.map (biprod.map (a.f₂.f (n+2)) (a.f₁.f (n+1))) (a.f₀.f n) := by
+  unfold totalMap termIso
+  erw [Iso.trans_hom, Iso.trans_hom, biprod.mapIso_hom, biprod.mapIso_hom, Iso.refl_hom, Iso.refl_hom]
+  erw [← Category.assoc, coneMap_term]
+  erw [Category.assoc, Category.assoc, biprodMap_comp, biprodMap_comp,
+    Category.comp_id, Category.id_comp]
+  congr 2
+  exact coneMap_term q q' a.f₂ a.f₁ a.commQ (n+1) (n+2) (by omega)
+
+def id (p : L₁ ⟶ L₀) (q : L₂ ⟶ L₁) (h : Homotopy (q ≫ p) 0) :
+    MapData p q h p q h where
+  f₀ := 𝟙 _
+  f₁ := 𝟙 _
+  f₂ := 𝟙 _
+  commP := by simp
+  commQ := by simp
+  commH := by intros; simp
+
+variable {p'' : N₁ ⟶ N₀} {q'' : N₂ ⟶ N₁} {h'' : Homotopy (q'' ≫ p'') 0}
+def comp (b : MapData p' q' h' p'' q'' h'') : MapData p q h p'' q'' h'' where
+  f₀ := a.f₀ ≫ b.f₀
+  f₁ := a.f₁ ≫ b.f₁
+  f₂ := a.f₂ ≫ b.f₂
+  commP := by rw [Category.assoc, b.commP, ← Category.assoc, a.commP, Category.assoc]
+  commQ := by rw [Category.assoc, b.commQ, ← Category.assoc, a.commQ, Category.assoc]
+  commH i j := by
+    simp only [comp_f]
+    rw [Category.assoc, b.commH, ← Category.assoc, a.commH, Category.assoc]
+
+@[simp] theorem totalMap_id : (id p q h).totalMap = 𝟙 _ := by
+  simp [totalMap, inner, id, coneMap_id, total]
+
+theorem totalMap_comp (b : MapData p' q' h' p'' q'' h'') :
+    (a.comp b).totalMap = a.totalMap ≫ b.totalMap := by
+  have hi : (a.comp b).inner = a.inner ≫ b.inner := coneMap_comp _ _ _ _ _ _ _ _ _
+  refine Eq.trans ?_ (coneMap_comp _ _ _ a.inner a.f₀ a.rectifyingMap_naturality
+    b.inner b.f₀ b.rectifyingMap_naturality)
+  change coneMap _ _ (a.comp b).inner (a.f₀ ≫ b.f₀) _ = _
+  congr 1
+
+end MapData
+end LittleFinitistic.RectificationTotal
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Rectification/TotalInterchange.lean b/lean/OAI/Algebra/Finitistic/Rectification/TotalInterchange.lean
new file mode 100644
index 0000000000000000000000000000000000000000..8c74d18366121d5fc4fcf4b38c4549d2e0dc4f06
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Rectification/TotalInterchange.lean
@@ -0,0 +1,107 @@
+import OAI.Algebra.Finitistic.Rectification.TotalFunctorial
+
+namespace OAI
+open CategoryTheory CategoryTheory.Limits HomologicalComplex CochainComplex
+open CochainComplex.HomComplex
+noncomputable section
+namespace LittleFinitistic.RectificationTotal
+variable {C D : Type*} [Category C] [Preadditive C] [HasBinaryBiproducts C]
+  [Category D] [Preadditive D] [HasBinaryBiproducts D]
+variable (F : C ⥤ D) [F.Additive]
+
+abbrev mapComplex := F.mapHomologicalComplex (ComplexShape.up ℤ)
+
+variable {A B A' B' : CochainComplex C ℤ}
+
+/-- The canonical additive comparison for one cone. -/
+def coneInterchange (q : A ⟶ B) :
+    (mapComplex F).obj (mappingCone q) ≅ mappingCone ((mapComplex F).map q) :=
+  homotopyCofiber.mapHomologicalComplexObjIso q F
+
+@[reassoc (attr := simp)]
+theorem coneInterchange_inv_inl (q : A ⟶ B) (i j : ℤ) (hij : i + (-1) = j) :
+    (mappingCone.inl ((mapComplex F).map q)).v i j hij ≫
+      (coneInterchange F q).inv.f j = F.map ((mappingCone.inl q).v i j hij) := by
+  exact homotopyCofiber.inlX_mapHomologicalComplexObjXIso_inv q F i j (by change j+1=i; omega)
+
+@[reassoc (attr := simp)]
+theorem coneInterchange_inv_inr (q : A ⟶ B) (i : ℤ) :
+    (mappingCone.inr ((mapComplex F).map q)).f i ≫
+      (coneInterchange F q).inv.f i = F.map ((mappingCone.inr q).f i) := by
+  exact homotopyCofiber.inrX_mapHomologicalComplexObjXIso_inv q F i
+
+@[reassoc (attr := simp)]
+theorem coneInterchange_hom_inl (q : A ⟶ B) (i j : ℤ) (hij : i + (-1) = j) :
+    F.map ((mappingCone.inl q).v i j hij) ≫ (coneInterchange F q).hom.f j =
+      (mappingCone.inl ((mapComplex F).map q)).v i j hij := by
+  rw [← coneInterchange_inv_inl F q i j hij, Category.assoc]
+  rw [← comp_f, Iso.inv_hom_id, id_f, Category.comp_id]
+
+@[reassoc (attr := simp)]
+theorem coneInterchange_hom_inr (q : A ⟶ B) (i : ℤ) :
+    F.map ((mappingCone.inr q).f i) ≫ (coneInterchange F q).hom.f i =
+      (mappingCone.inr ((mapComplex F).map q)).f i := by
+  rw [← coneInterchange_inv_inr F q i, Category.assoc]
+  rw [← comp_f, Iso.inv_hom_id, id_f, Category.comp_id]
+
+variable {L₀ L₁ L₂ : CochainComplex C ℤ}
+variable (p : L₁ ⟶ L₀) (q : L₂ ⟶ L₁) (h : Homotopy (q ≫ p) 0)
+
+/-- Apply the functor to the supplied null-homotopy, transporting only
+functorial composition and zero equalities. -/
+def mapNullHomotopy : Homotopy ((mapComplex F).map q ≫ (mapComplex F).map p) 0 :=
+  (Homotopy.ofEq (by simp)).trans ((F.mapHomotopy h).trans (Homotopy.ofEq (by simp)))
+
+omit [HasBinaryBiproducts C] [HasBinaryBiproducts D] in
+@[simp] theorem mapNullHomotopy_hom (i j : ℤ) :
+    (mapNullHomotopy F p q h).hom i j = F.map (h.hom i j) := by
+  simp [mapNullHomotopy, Homotopy.trans, Homotopy.ofEq]
+
+/-- Mapping the rectifying map agrees with rectifying the mapped data. -/
+theorem rectifyingMap_interchange_inv :
+    (coneInterchange F q).inv ≫ (mapComplex F).map (rectifyingMap p q h) =
+      rectifyingMap ((mapComplex F).map p) ((mapComplex F).map q)
+        (mapNullHomotopy F p q h) := by
+  ext n
+  apply mappingCone.ext_from ((mapComplex F).map q) (n+1) n rfl
+  · simp only [comp_f, coneInterchange_inv_inl_assoc]
+    dsimp only [mapComplex, Functor.mapHomologicalComplex_map_f]
+    rw [← F.map_comp]
+    simp [rectifyingMap, Cochain.ofHomotopy]
+  · simp only [comp_f, coneInterchange_inv_inr_assoc]
+    dsimp only [mapComplex, Functor.mapHomologicalComplex_map_f]
+    rw [← F.map_comp]
+    simp [rectifyingMap]
+
+theorem rectifyingMap_interchange :
+    (coneInterchange F q).hom ≫
+      rectifyingMap ((mapComplex F).map p) ((mapComplex F).map q)
+        (mapNullHomotopy F p q h) = (mapComplex F).map (rectifyingMap p q h) := by
+  rw [← rectifyingMap_interchange_inv F p q h, ← Category.assoc]
+  simp
+
+/-- Arbitrary additive functors commute with the actual iterated-cone total. -/
+def totalInterchange : (mapComplex F).obj (total p q h) ≅
+    total ((mapComplex F).map p) ((mapComplex F).map q) (mapNullHomotopy F p q h) :=
+  coneInterchange F (rectifyingMap p q h) ≪≫
+    homotopyCofiber.mapArrowIso _ _ (fun j => ⟨j-1, by simp⟩)
+      (Arrow.isoMk (coneInterchange F q) (Iso.refl _)
+        (by simpa using rectifyingMap_interchange F p q h))
+
+/-- The original zero-column inclusion is carried to the original inclusion. -/
+@[reassoc]
+theorem inclusion_totalInterchange :
+    (mapComplex F).map (inclusion p q h) ≫ (totalInterchange F p q h).hom =
+      inclusion ((mapComplex F).map p) ((mapComplex F).map q) (mapNullHomotopy F p q h) := by
+  ext n
+  change F.map ((mappingCone.inr (rectifyingMap p q h)).f n) ≫
+    ((coneInterchange F (rectifyingMap p q h)).hom.f n ≫ _) = _
+  rw [coneInterchange_hom_inr_assoc]
+  change (mappingCone.inr _).f n ≫ (coneMap _ _ _ _ _).f n = _
+  rw [coneMap_inr]
+  simp [inclusion]
+end LittleFinitistic.RectificationTotal
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Rectification/VertexCategoricalAssembly.lean b/lean/OAI/Algebra/Finitistic/Rectification/VertexCategoricalAssembly.lean
new file mode 100644
index 0000000000000000000000000000000000000000..6ebbc4c045cb5140f7c04bca7b07d57b62d360fe
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Rectification/VertexCategoricalAssembly.lean
@@ -0,0 +1,59 @@
+import OAI.Algebra.Finitistic.Encoding.EncodingModuleAssembly
+import OAI.Algebra.Finitistic.Rectification.LeftVertexHomology
+
+namespace OAI
+noncomputable section
+open CategoryTheory
+namespace LittleFinitistic.VertexCategoricalAssembly
+open QuadraticEncoding
+universe u
+variable {k : Type u} [Field k] {d t : ℕ} (P : Relations k d t)
+variable (M N : ModuleCat.{u} (B P))
+variable (E : ∀ i : Fin 3,
+  (LeftVertexHomology.vertex k (B P) (ThreeVertexAlgebra.vertex (composition P) i)).obj M ≅
+    (LeftVertexHomology.vertex k (B P) (ThreeVertexAlgebra.vertex (composition P) i)).obj N)
+
+abbrev scalar (M : ModuleCat.{u} (B P)) := (ModuleCat.restrictScalars (algebraMap k (B P))).obj M
+
+def vertexEquiv (i : Fin 3) :
+    VertexDecomposition.Space (EncodingModuleAssembly.system P) (scalar P M) i ≃ₗ[k]
+      VertexDecomposition.Space (EncodingModuleAssembly.system P) (scalar P N) i :=
+  (LeftVertexHomology.spaceEquiv k (B P) (ThreeVertexAlgebra.vertex (composition P) i) M).symm.trans
+    ((E i).toLinearEquiv.trans
+      (LeftVertexHomology.spaceEquiv k (B P) (ThreeVertexAlgebra.vertex (composition P) i) N))
+
+/-- Compatible categorical vertex isomorphisms determine a full B-module isomorphism.
+The hypotheses are exactly the two finite arrow squares; length-two actions follow. -/
+def iso
+    (h01 : ∀ a,
+      (LeftVertexHomology.arrow k (B P) (ThreeVertexAlgebra.vertex (composition P) 0)
+        (ThreeVertexAlgebra.vertex (composition P) 1) (arrow01 P a)
+        (CanonicalArrowCompatibility.arrow01_target P a)).app M ≫ (E 1).hom =
+      (E 0).hom ≫ (LeftVertexHomology.arrow k (B P) (ThreeVertexAlgebra.vertex (composition P) 0)
+        (ThreeVertexAlgebra.vertex (composition P) 1) (arrow01 P a)
+        (CanonicalArrowCompatibility.arrow01_target P a)).app N)
+    (h12 : ∀ b,
+      (LeftVertexHomology.arrow k (B P) (ThreeVertexAlgebra.vertex (composition P) 1)
+        (ThreeVertexAlgebra.vertex (composition P) 2) (arrow12 P b)
+        (CanonicalArrowCompatibility.arrow12_target P b)).app M ≫ (E 2).hom =
+      (E 1).hom ≫ (LeftVertexHomology.arrow k (B P) (ThreeVertexAlgebra.vertex (composition P) 1)
+        (ThreeVertexAlgebra.vertex (composition P) 2) (arrow12 P b)
+        (CanonicalArrowCompatibility.arrow12_target P b)).app N) : M ≅ N := by
+  let e := EncodingModuleAssembly.equiv P (vertexEquiv P M N E)
+    (fun a x => ?_) (fun b x => ?_)
+  · exact e.toModuleIso
+  · apply Subtype.ext
+    have hh := congrArg (fun f => ModuleCat.Hom.hom f
+      ((LeftVertexHomology.spaceEquiv k (B P) (ThreeVertexAlgebra.vertex (composition P) 0) M).symm x)) (h01 a)
+    have hh' := congrArg Subtype.val hh
+    exact hh'
+  · apply Subtype.ext
+    have hh := congrArg (fun f => ModuleCat.Hom.hom f
+      ((LeftVertexHomology.spaceEquiv k (B P) (ThreeVertexAlgebra.vertex (composition P) 1) M).symm x)) (h12 b)
+    have hh' := congrArg Subtype.val hh
+    exact hh'
+end LittleFinitistic.VertexCategoricalAssembly
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Rectification/VertexColumnComplex.lean b/lean/OAI/Algebra/Finitistic/Rectification/VertexColumnComplex.lean
new file mode 100644
index 0000000000000000000000000000000000000000..bc28b3bfc99d7870e0e6ce9312b7dae42d9d6170
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Rectification/VertexColumnComplex.lean
@@ -0,0 +1,54 @@
+import OAI.Algebra.Finitistic.Rectification.VertexColumnModels
+
+namespace OAI
+noncomputable section
+open CategoryTheory CategoryTheory.Limits
+open scoped TensorProduct ModuleCat.Algebra
+namespace LittleFinitistic.VertexColumnComplex
+universe u
+variable {k V W U : Type u} [Field k] [AddCommGroup V] [Module k V]
+  [AddCommGroup W] [Module k W] [AddCommGroup U] [Module k U]
+variable (μ : W →ₗ[k] V →ₗ[k] U)
+local notation "T" => ThreeVertexAlgebra μ
+attribute [local instance] ExternalTensor.rightModule ExternalTensor.bimodule
+
+abbrev vertexColumn (i j : Fin 3) : ModuleCat.{u} Tᵐᵒᵖ ⥤ ModuleCat.{u} Tᵐᵒᵖ :=
+  ExternalTensor.Section4.columnFunctor k T (ThreeVertexAlgebra.vertex μ j) ⋙
+    BimoduleVertex.functor k T (ThreeVertexAlgebra.vertex μ i)
+
+/-- The diagonal insertion is natural in the original right module. -/
+def diagonalNatIso (i : Fin 3) : 𝟭 (ModuleCat.{u} Tᵐᵒᵖ) ≅ vertexColumn μ i i :=
+  NatIso.ofComponents (fun N => (BimoduleVertex.diagonalEquiv μ N i).symm.toModuleIso) (by
+    intro M N f
+    apply ModuleCat.hom_ext
+    apply LinearMap.ext
+    intro n
+    apply Subtype.ext
+    change ((BimoduleVertex.diagonalEquiv μ N i).symm (f.hom n)).val =
+      ExternalTensor.columnMap k (ThreeVertexAlgebra.vertex μ i) f.hom
+        (((BimoduleVertex.diagonalEquiv μ M i).symm n).val)
+    rw [VertexColumnModels.diagonal_symm_val,VertexColumnModels.diagonal_symm_val]
+    rfl)
+
+/-- On actual complexes, the diagonal vertex is the original complex via its specified insertion. -/
+def diagonalComplexIso (i : Fin 3) (D : CochainComplex (ModuleCat.{u} Tᵐᵒᵖ) ℤ) :
+    D ≅ ((vertexColumn μ i i).mapHomologicalComplex (.up ℤ)).obj D :=
+  HomologicalComplex.Hom.isoOfComponents (fun n => (diagonalNatIso μ i).app (D.X n))
+    (fun n m _ => ((diagonalNatIso μ i).hom.naturality (D.d n m)).symm)
+
+/-- Every term of a reverse vertex column is zero, hence the actual complex is zero. -/
+theorem reverse_isZero (i j : Fin 3) (hij : i < j)
+    (D : CochainComplex (ModuleCat.{u} Tᵐᵒᵖ) ℤ) :
+    IsZero (((vertexColumn μ i j).mapHomologicalComplex (.up ℤ)).obj D) := by
+  apply (IsZero.iff_id_eq_zero _).2
+  apply HomologicalComplex.Hom.ext
+  funext n
+  apply ModuleCat.hom_ext
+  apply LinearMap.ext
+  intro x
+  exact (VertexColumnModels.reverse_zero μ (D.X n) i j hij).elim _ _
+end LittleFinitistic.VertexColumnComplex
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Rectification/VertexColumnModels.lean b/lean/OAI/Algebra/Finitistic/Rectification/VertexColumnModels.lean
new file mode 100644
index 0000000000000000000000000000000000000000..20050ea6af5466410ec701f7c72ae82decaaed10
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Rectification/VertexColumnModels.lean
@@ -0,0 +1,52 @@
+import OAI.Algebra.Finitistic.Bimodule.BimoduleVertex
+
+namespace OAI
+noncomputable section
+open CategoryTheory CategoryTheory.Limits
+open scoped TensorProduct ModuleCat.Algebra
+namespace LittleFinitistic.VertexColumnModels
+universe u
+variable {k V W U : Type u} [Field k] [AddCommGroup V] [Module k V]
+  [AddCommGroup W] [Module k W] [AddCommGroup U] [Module k U]
+variable (μ : W →ₗ[k] V →ₗ[k] U)
+variable (N : ModuleCat.{u} (ThreeVertexAlgebra μ)ᵐᵒᵖ)
+local notation "T" => ThreeVertexAlgebra μ
+attribute [local instance] ExternalTensor.rightModule ExternalTensor.bimodule
+
+/-- The actual vertex of an induced column is its path-corner tensor. -/
+def cornerEquiv (i j : Fin 3) :
+    BimoduleVertex.columnFixed μ N i j ≃ₗ[Tᵐᵒᵖ] (CornerSpaces.corner μ i j ⊗[k] N) :=
+  (BimoduleVertex.columnFixedEquiv μ N i j).trans
+    (CornerTensor.cornerTensorEquiv μ N i j).symm
+
+/-- Vertices below the directed support have zero actual column component. -/
+theorem reverse_zero (i j : Fin 3) (hij : i < j) :
+    Subsingleton (BimoduleVertex.columnFixed μ N i j) := by
+  have hc : Subsingleton (CornerSpaces.corner μ i j) :=
+    ⟨fun x y => (CornerSpaces.corner_zero_of_lt μ i j hij x).trans
+      (CornerSpaces.corner_zero_of_lt μ i j hij y).symm⟩
+  let := hc
+  have ht : ∀ x : CornerSpaces.corner μ i j ⊗[k] N, x = 0 := by
+    intro x
+    induction x using TensorProduct.inductionOn with
+    | tmul x n => simp [Subsingleton.elim x 0]
+    | add x y hx hy => simp [hx,hy]
+  refine ⟨fun x y => (cornerEquiv μ N i j).injective ?_⟩
+  exact (ht _).trans (ht _).symm
+
+/-- The inverse diagonal equivalence is the manuscript's original insertion e_i tensor n. -/
+theorem diagonal_symm_val (i : Fin 3) (n : N) :
+    ((BimoduleVertex.diagonalEquiv μ N i).symm n).val =
+      ExternalTensor.columnInclusion k T N (ThreeVertexAlgebra.vertex μ i) n := by
+  change (⟨(1 : k) • ThreeVertexAlgebra.vertex μ i, _⟩ :
+    ExternalTensor.leftIdeal T (ThreeVertexAlgebra.vertex μ i)) ⊗ₜ[k] n =
+      ExternalTensor.generator T (ThreeVertexAlgebra.vertex μ i) ⊗ₜ[k] n
+  congr 1
+  apply Subtype.ext
+  exact one_smul k _
+
+end LittleFinitistic.VertexColumnModels
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Rectification/VertexDecomposition.lean b/lean/OAI/Algebra/Finitistic/Rectification/VertexDecomposition.lean
new file mode 100644
index 0000000000000000000000000000000000000000..904b8b4090178ed9f00484bbd73ecfcf25d748e9
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Rectification/VertexDecomposition.lean
@@ -0,0 +1,62 @@
+import OAI.Algebra.Finitistic.Tensor.IdempotentTensor
+import OAI.Algebra.Finitistic.Encoding.DirectedBound
+
+namespace OAI
+noncomputable section
+namespace LittleFinitistic.VertexDecomposition
+universe u v
+variable {k A : Type u} [Field k] [Ring A] [Algebra k A] {n : ℕ}
+variable (D : DirectedBound.DirectedSystem k A n)
+variable (M : Type v) [AddCommGroup M] [Module k M] [Module A M]
+  [IsScalarTower k A M]
+
+abbrev Space (i : Fin n) := IdempotentTensor.leftSpace (k := k) (D.e i) M
+
+/-- Projection onto an actual vertex subspace. -/
+def project (i : Fin n) : M →ₗ[k] Space D M i where
+  toFun x := ⟨D.e i • x, by
+    change D.e i • (D.e i • x) = D.e i • x
+    rw [← mul_smul, D.idem]⟩
+  map_add' x y := Subtype.ext (smul_add _ _ _)
+  map_smul' c x := Subtype.ext (smul_comm _ _ _)
+
+/-- A module decomposes into its actual vertex subspaces. This is a vector-space
+isomorphism; off-diagonal arrows act between its factors. -/
+def equiv : M ≃ₗ[k] ((i : Fin n) → Space D M i) where
+  toFun x i := project D M i x
+  invFun x := ∑ i, (x i).val
+  map_add' x y := by funext i; exact (project D M i).map_add x y
+  map_smul' c x := by funext i; exact (project D M i).map_smul c x
+  left_inv x := by
+    change ∑ i, D.e i • x = x
+    rw [← Finset.sum_smul, D.complete, one_smul]
+  right_inv x := by
+    funext i
+    apply Subtype.ext
+    change D.e i • (∑ j, (x j).val) = (x i).val
+    rw [Finset.smul_sum]
+    rw [Finset.sum_eq_single i]
+    · exact (x i).property
+    · intro j _ hji
+      rw [← (x j).property, ← mul_smul, D.orthogonal i j (Ne.symm hji), zero_smul]
+    · simp
+
+@[simp] theorem equiv_apply (x : M) (i : Fin n) :
+    equiv D M x i = project D M i x := rfl
+
+@[simp] theorem equiv_symm_apply (x : (i : Fin n) → Space D M i) :
+    (equiv D M).symm x = ∑ i, (x i).val := rfl
+
+lemma project_self (i : Fin n) (x : Space D M i) : project D M i x.val = x :=
+  Subtype.ext x.property
+
+lemma project_other (i j : Fin n) (hij : i ≠ j) (x : Space D M j) :
+    project D M i x.val = 0 := by
+  apply Subtype.ext
+  change D.e i • x.val = 0
+  rw [← x.property, ← mul_smul, D.orthogonal i j hij, zero_smul]
+end LittleFinitistic.VertexDecomposition
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Rectification/VertexFunctor.lean b/lean/OAI/Algebra/Finitistic/Rectification/VertexFunctor.lean
new file mode 100644
index 0000000000000000000000000000000000000000..54d9fcaeaec7bd04bb85130f8b0298c35d6b9a83
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Rectification/VertexFunctor.lean
@@ -0,0 +1,125 @@
+import Mathlib.Algebra.Category.ModuleCat.ChangeOfRings
+import Mathlib.Algebra.Homology.ShortComplex.ModuleCat
+import Mathlib.Algebra.Module.Projective
+import Mathlib.CategoryTheory.Preadditive.AdditiveFunctor
+
+namespace OAI
+noncomputable section
+open CategoryTheory
+namespace LittleFinitistic.VertexFunctor
+universe u
+variable {A B : Type u} [Ring A] [Ring B]
+variable (β : B →+* A) (e : A) (he : e*e=e) (hc : ∀ b, e*β b=β b*e)
+
+abbrev restricted (M : ModuleCat.{u} A) := (ModuleCat.restrictScalars β).obj M
+
+/-- The original vertex action is linear for the commuting right restriction. -/
+def action (M : ModuleCat.{u} A) : restricted β M →ₗ[B] restricted β M where
+  toFun m := e • (m : M)
+  map_add' x y := smul_add _ _ _
+  map_smul' b m := by
+    change e • (β b • (m : M)) = β b • (e • (m : M))
+    rw [← mul_smul,← mul_smul,hc]
+
+def fixed (M : ModuleCat.{u} A) : Submodule B (restricted β M) :=
+  (action β e hc M - LinearMap.id).ker
+
+@[simp] theorem mem_fixed (M : ModuleCat.{u} A) (m : restricted β M) :
+    m ∈ fixed β e hc M ↔ e • (m : M) = m := by
+  simp [fixed,action,sub_eq_zero]
+
+/-- The genuine projection onto the vertex component. -/
+def projection (M : ModuleCat.{u} A) : restricted β M →ₗ[B] fixed β e hc M :=
+  (action β e hc M).codRestrict _ (by
+    intro m
+    rw [mem_fixed]
+    change e • (e • (m : M)) = e • (m : M)
+    rw [← mul_smul,he])
+
+def inclusion (M : ModuleCat.{u} A) : fixed β e hc M →ₗ[B] restricted β M :=
+  (fixed β e hc M).subtype
+
+theorem projection_inclusion (M : ModuleCat.{u} A) :
+    (projection β e he hc M).comp (inclusion β e hc M) = LinearMap.id := by
+  apply LinearMap.ext
+  intro m
+  apply Subtype.ext
+  exact (mem_fixed β e hc M m.val).1 m.property
+
+/-- Module maps restrict to the actual vertex fixed submodules. -/
+def map {M N : ModuleCat.{u} A} (f : M ⟶ N) :
+    fixed β e hc M →ₗ[B] fixed β e hc N where
+  toFun m := ⟨f.hom m.val,by
+    apply (mem_fixed β e hc N _).2
+    have hm := (mem_fixed β e hc M m.val).1 m.property
+    exact (f.hom.map_smul e (m.val : M)).symm.trans (congrArg f.hom hm)⟩
+  map_add' x y := Subtype.ext (map_add _ _ _)
+  map_smul' b x := by
+    apply Subtype.ext
+    change f.hom (β b • (x.val : M)) = β b • f.hom x.val
+    exact f.hom.map_smul _ _
+
+/-- The actual vertex-component functor; it retains the original right action. -/
+def functor : ModuleCat.{u} A ⥤ ModuleCat.{u} B where
+  obj M := ModuleCat.of B (fixed β e hc M)
+  map f := ModuleCat.ofHom (map β e hc f)
+  map_id M := by
+    apply ModuleCat.hom_ext
+    apply LinearMap.ext
+    intro m
+    rfl
+  map_comp f g := by
+    apply ModuleCat.hom_ext
+    apply LinearMap.ext
+    intro m
+    rfl
+
+instance additive : (functor β e hc).Additive where
+  map_add := by
+    intros
+    apply ModuleCat.hom_ext
+    apply LinearMap.ext
+    intro m
+    rfl
+
+include he in
+/-- Vertex components of right-projective modules are right-projective. -/
+theorem projective (M : ModuleCat.{u} A) [Module.Projective B (restricted β M)] :
+    Module.Projective B (fixed β e hc M) := by
+  exact Module.Projective.of_split (inclusion β e hc M) (projection β e he hc M)
+    (projection_inclusion β e he hc M)
+
+include he in
+/-- Applying a vertex component preserves actual short exact sequences. -/
+theorem map_shortExact (S : ShortComplex (ModuleCat.{u} A)) (hS : S.ShortExact) :
+    (S.map (functor β e hc)).ShortExact := by
+  apply ModuleCat.shortComplex_shortExact
+  · intro x
+    constructor
+    · intro hx
+      have hx' : S.g.hom x.val = 0 := congrArg Subtype.val hx
+      obtain ⟨y,hy⟩ := (ShortComplex.moduleCat_exact_iff S).1 hS.exact x.val hx'
+      refine ⟨projection β e he hc S.X₁ y,?_⟩
+      apply Subtype.ext
+      change S.f.hom (e • y) = x.val
+      rw [S.f.hom.map_smul,hy]
+      exact (mem_fixed β e hc S.X₂ x.val).1 x.property
+    · rintro ⟨y,rfl⟩
+      apply Subtype.ext
+      exact S.moduleCat_zero_apply y.val
+  · intro x y h
+    apply Subtype.ext
+    apply hS.moduleCat_injective_f
+    exact congrArg Subtype.val h
+  · intro z
+    obtain ⟨y,hy⟩ := hS.moduleCat_surjective_g z.val
+    refine ⟨projection β e he hc S.X₂ y,?_⟩
+    apply Subtype.ext
+    change S.g.hom (e • y) = z.val
+    rw [S.g.hom.map_smul,hy]
+    exact (mem_fixed β e hc S.X₃ z.val).1 z.property
+end LittleFinitistic.VertexFunctor
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Rectification/VertexHomology.lean b/lean/OAI/Algebra/Finitistic/Rectification/VertexHomology.lean
new file mode 100644
index 0000000000000000000000000000000000000000..b3be332dd6274974f66f85aed12dcb45c7136e07
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Rectification/VertexHomology.lean
@@ -0,0 +1,49 @@
+import Mathlib.Algebra.Homology.ShortComplex.HomologicalComplex
+import Mathlib.Algebra.Homology.HomologicalComplexAbelian
+import OAI.Algebra.Finitistic.Rectification.VertexFunctor
+import Mathlib.Algebra.Homology.ShortComplex.ExactFunctor
+
+namespace OAI
+noncomputable section
+open CategoryTheory HomologicalComplex
+namespace LittleFinitistic.VertexHomology
+universe u
+variable {A B : Type u} [Ring A] [Ring B]
+variable (β : B →+* A) (e : A) (he : e*e=e) (hc : ∀ b, e*β b=β b*e)
+
+include he
+
+/-- Actual vertex projection preserves homology, because it preserves the
+short exact sequences already proved in VertexFunctor. -/
+theorem preservesHomology : (VertexFunctor.functor β e hc).PreservesHomology :=
+  ((Functor.exact_tfae (VertexFunctor.functor β e hc)).out 1 3).1
+    (VertexFunctor.map_shortExact β e he hc)
+
+/-- Homology of the actual vertex complex is the actual vertex of module homology. -/
+def iso (X : CochainComplex (ModuleCat.{u} A) ℤ) (n : ℤ) :
+    (((VertexFunctor.functor β e hc).mapHomologicalComplex (.up ℤ)).obj X).homology n ≅
+      (VertexFunctor.functor β e hc).obj (X.homology n) := by
+  letI := preservesHomology β e he hc
+  exact (X.sc n).mapHomologyIso (VertexFunctor.functor β e hc)
+
+/-- This comparison respects every natural transformation of the vertex functors,
+so it retains the algebra arrow actions as well as the vertex vector spaces. -/
+theorem natural (e' : A) (he' : e'*e'=e') (hc' : ∀ b, e'*β b=β b*e')
+    (τ : VertexFunctor.functor β e hc ⟶ VertexFunctor.functor β e' hc')
+    (X : CochainComplex (ModuleCat.{u} A) ℤ) (n : ℤ) :
+    homologyMap ((NatTrans.mapHomologicalComplex τ (.up ℤ)).app X) n ≫
+      (iso β e' he' hc' X n).hom =
+    (iso β e he hc X n).hom ≫ τ.app (X.homology n) := by
+  let := preservesHomology β e he hc
+  let := preservesHomology β e' he' hc'
+  have h := ShortComplex.homologyMap_mapNatTrans (X.sc n) τ
+  change homologyMap ((NatTrans.mapHomologicalComplex τ (.up ℤ)).app X) n =
+    (iso β e he hc X n).hom ≫ τ.app (X.homology n) ≫
+      (iso β e' he' hc' X n).inv at h
+  rw [h]
+  simp
+end LittleFinitistic.VertexHomology
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Rectification/VertexHomotopyEquivalence.lean b/lean/OAI/Algebra/Finitistic/Rectification/VertexHomotopyEquivalence.lean
new file mode 100644
index 0000000000000000000000000000000000000000..b8115fa29a308cfa879c43a5d0c2b9e16c4115cd
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Rectification/VertexHomotopyEquivalence.lean
@@ -0,0 +1,81 @@
+import OAI.Algebra.Finitistic.Rectification.ThirdVertex
+import OAI.Algebra.Finitistic.Rectification.VertexTotalProperties
+
+namespace OAI
+noncomputable section
+open CategoryTheory CategoryTheory.Limits HomologicalComplex
+namespace LittleFinitistic.VertexHomotopyEquivalence
+open ExternalTensor.Section4
+universe u
+variable {k : Type u} [Field k] {d t : ℕ} (P : QuadraticEncoding.Relations k d t)
+variable (D₀ D₁ D₂ : RightComplex (QuadraticEncoding.B P))
+variable (f : Fin (d+1) → (D₀ ⟶ D₁)) (g : Fin (d+1) → (D₁ ⟶ D₂))
+variable (H : ∀ r, Homotopy (relationMap (ConcreteQuadraticDiagram.quadratic P) D₀ D₁ D₂ f g r) 0)
+
+abbrev source (v : Fin 3) : RightComplex (QuadraticEncoding.B P) :=
+  Fin.cases D₀ (Fin.cases D₁ (fun _ => D₂)) v
+abbrev target (v : Fin 3) : RightComplex (QuadraticEncoding.B P) :=
+  (AdjacentArrowSum.vertexComplex (QuadraticEncoding.composition P) v).obj
+    (InducedRectification.total (ConcreteQuadraticDiagram.quadratic P) D₀ D₁ D₂ f g H)
+
+def iota (v : Fin 3) : source P D₀ D₁ D₂ v ⟶ target P D₀ D₁ D₂ f g H v := by
+  refine Fin.cases (FirstVertex.iota P D₀ D₁ D₂ f g H)
+    (Fin.cases (SecondVertex.iota P D₀ D₁ D₂ f g H) ?_) v
+  intro j
+  have hj : j = 0 := Subsingleton.elim _ _
+  subst j
+  exact ThirdVertex.iota P D₀ D₁ D₂ f g H
+
+/-- All three original vertex insertions are quasi-isomorphisms. -/
+theorem iota_quasiIso (v : Fin 3) : QuasiIso (iota P D₀ D₁ D₂ f g H v) := by
+  fin_cases v
+  · let := FirstVertex.iota_isIso P D₀ D₁ D₂ f g H
+    change QuasiIso (FirstVertex.iota P D₀ D₁ D₂ f g H)
+    infer_instance
+  · exact SecondVertex.iota_quasiIso P D₀ D₁ D₂ f g H
+  · exact ThirdVertex.iota_quasiIso P D₀ D₁ D₂ f g H
+
+/-- The actual vertex insertions have chain-map inverses and both homotopies.
+Only the boundedness and projectivity of the chosen chain representatives are inputs. -/
+theorem homotopy_inverse (v : Fin 3) (lo hi : ℤ)
+    (b₀ : ∀ n, n < lo ∨ hi < n → IsZero (D₀.X n))
+    (b₁ : ∀ n, n < lo ∨ hi < n → IsZero (D₁.X n))
+    (b₂ : ∀ n, n < lo ∨ hi < n → IsZero (D₂.X n))
+    (p₀ : ∀ n, Module.Projective (QuadraticEncoding.B P)ᵐᵒᵖ (D₀.X n))
+    (p₁ : ∀ n, Module.Projective (QuadraticEncoding.B P)ᵐᵒᵖ (D₁.X n))
+    (p₂ : ∀ n, Module.Projective (QuadraticEncoding.B P)ᵐᵒᵖ (D₂.X n)) :
+    ∃ j : target P D₀ D₁ D₂ f g H v ⟶ source P D₀ D₁ D₂ v,
+      Nonempty (Homotopy (iota P D₀ D₁ D₂ f g H v ≫ j) (𝟙 _)) ∧
+      Nonempty (Homotopy (j ≫ iota P D₀ D₁ D₂ f g H v) (𝟙 _)) := by
+  have : (source P D₀ D₁ D₂ v).IsStrictlyLE hi := by
+    rw [CochainComplex.isStrictlyLE_iff]
+    intro n hn
+    fin_cases v
+    · exact b₀ n (Or.inr hn)
+    · exact b₁ n (Or.inr hn)
+    · exact b₂ n (Or.inr hn)
+  have : (target P D₀ D₁ D₂ f g H v).IsStrictlyLE hi := by
+    rw [CochainComplex.isStrictlyLE_iff]
+    intro n hn
+    exact VertexTotalProperties.total_bounded P D₀ D₁ D₂ f g H v lo hi b₀ b₁ b₂ n (Or.inr hn)
+  have (n : ℤ) : Projective ((source P D₀ D₁ D₂ v).X n) := by
+    fin_cases v
+    · change Projective (D₀.X n)
+      let := p₀ n
+      exact ModuleCat.projective_of_categoryTheory_projective (D₀.X n)
+    · change Projective (D₁.X n)
+      let := p₁ n
+      exact ModuleCat.projective_of_categoryTheory_projective (D₁.X n)
+    · change Projective (D₂.X n)
+      let := p₂ n
+      exact ModuleCat.projective_of_categoryTheory_projective (D₂.X n)
+  have (n : ℤ) : Projective ((target P D₀ D₁ D₂ f g H v).X n) :=
+    VertexTotalProperties.total_projective P D₀ D₁ D₂ f g H v p₀ p₁ p₂ n
+  let := iota_quasiIso P D₀ D₁ D₂ f g H v
+  exact RectificationAcyclic.bounded_projective_homotopy_inverse
+    (iota P D₀ D₁ D₂ f g H v) hi
+end LittleFinitistic.VertexHomotopyEquivalence
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Rectification/VertexModuleAssembly.lean b/lean/OAI/Algebra/Finitistic/Rectification/VertexModuleAssembly.lean
new file mode 100644
index 0000000000000000000000000000000000000000..df6f23c79ffba811951ff2b74b711c7cff2877d3
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Rectification/VertexModuleAssembly.lean
@@ -0,0 +1,72 @@
+import OAI.Algebra.Finitistic.Rectification.VertexDecomposition
+import Mathlib.LinearAlgebra.Pi
+
+namespace OAI
+noncomputable section
+namespace LittleFinitistic.VertexModuleAssembly
+open VertexDecomposition
+universe u v w
+variable {k A : Type u} [Field k] [Ring A] [Algebra k A] {n : ℕ}
+variable (D : DirectedBound.DirectedSystem k A n)
+variable {M : Type v} {N : Type w} [AddCommGroup M] [AddCommGroup N]
+  [Module k M] [Module k N] [Module A M] [Module A N]
+  [IsScalarTower k A M] [IsScalarTower k A N]
+variable (E : ∀ i, Space D M i ≃ₗ[k] Space D N i)
+
+/-- Assemble specified vertex isomorphisms into a vector-space isomorphism. -/
+def assembled : M ≃ₗ[k] N :=
+  (equiv D M).trans ((LinearEquiv.piCongrRight E).trans (equiv D N).symm)
+
+lemma project_assembled (i : Fin n) (x : M) :
+    project D N i (assembled D E x) = E i (project D M i x) := by
+  exact congrFun ((equiv D N).apply_symm_apply
+    ((LinearEquiv.piCongrRight E) (equiv D M x))) i
+
+lemma assembled_vertex (i : Fin n) (x : Space D M i) :
+    assembled D E x.val = (E i x).val := by
+  apply (equiv D N).injective
+  funext j
+  rw [equiv_apply, project_assembled, equiv_apply]
+  by_cases h : j = i
+  · subst j
+    rw [project_self, project_self]
+  · rw [project_other D M j i h, project_other D N j i h, map_zero]
+
+/-- The assembled map commutes with every vertex idempotent. -/
+theorem vertex_smul (i : Fin n) (x : M) :
+    assembled D E (D.e i • x) = D.e i • assembled D E x := by
+  have h := assembled_vertex D E i (project D M i x)
+  have hp := congrArg Subtype.val (project_assembled D E i x)
+  exact h.trans hp.symm
+
+/-- A supported arrow acts between its actual source and target subspaces. -/
+def arrow {i j : Fin n} (a : A) (ha : D.e j * a = a) :
+    Space D M i →ₗ[k] Space D M j where
+  toFun x := ⟨a • x.val, by
+    change D.e j • (a • x.val) = a • x.val
+    rw [← mul_smul, ha]⟩
+  map_add' x y := Subtype.ext (smul_add _ _ _)
+  map_smul' c x := Subtype.ext (smul_comm _ _ _)
+
+/-- Vertexwise compatibility with an actual arrow gives compatibility of the
+assembled map on every element of the full module. -/
+theorem arrow_smul {i j : Fin n} (a : A) (hl : D.e j * a = a) (hr : a * D.e i = a)
+    (hE : ∀ x : Space D M i, E j (arrow D a hl x) = arrow D a hl (E i x))
+    (x : M) : assembled D E (a • x) = a • assembled D E x := by
+  have hax : a • (project D M i x).val = a • x := by
+    change a • (D.e i • x) = a • x
+    rw [← mul_smul, hr]
+  have h := assembled_vertex D E j (arrow D a hl (project D M i x))
+  change assembled D E (a • (project D M i x).val) =
+    (E j (arrow D a hl (project D M i x))).val at h
+  rw [hax, hE] at h
+  have hp := congrArg Subtype.val (project_assembled D E i x)
+  change D.e i • assembled D E x = (E i (project D M i x)).val at hp
+  change assembled D E (a • x) = a • (E i (project D M i x)).val at h
+  rw [← hp, ← mul_smul, hr] at h
+  exact h
+end LittleFinitistic.VertexModuleAssembly
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Rectification/VertexProjectives.lean b/lean/OAI/Algebra/Finitistic/Rectification/VertexProjectives.lean
new file mode 100644
index 0000000000000000000000000000000000000000..06c99475ae6948195716841f9d2ebd4b0c1ca9ef
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Rectification/VertexProjectives.lean
@@ -0,0 +1,63 @@
+import OAI.Algebra.Finitistic.Localization.ProjectiveComplexes
+
+namespace OAI
+noncomputable section
+open CategoryTheory Limits
+namespace LittleFinitistic.VertexProjectives
+universe u
+variable {B : Type u} [Ring B]
+
+/-- eB, represented in the opposite regular module to encode right linearity. -/
+def ideal (e : B) : Submodule Bᵐᵒᵖ Bᵐᵒᵖ :=
+  (LinearMap.mulRight Bᵐᵒᵖ (MulOpposite.op e)).range
+
+theorem fixed (e : B) (he : e * e = e) (x : ideal e) :
+    x.val * MulOpposite.op e = x.val := by
+  obtain ⟨y,hy⟩ := x.property
+  change y * MulOpposite.op e = x.val at hy
+  rw [← hy, mul_assoc, ← MulOpposite.op_mul, he]
+
+instance finite (e : B) : Module.Finite Bᵐᵒᵖ (ideal e) :=
+  inferInstanceAs (Module.Finite Bᵐᵒᵖ (LinearMap.mulRight Bᵐᵒᵖ (MulOpposite.op e)).range)
+
+theorem projective (e : B) (he : e * e = e) : Module.Projective Bᵐᵒᵖ (ideal e) := by
+  apply Module.Projective.of_split (ideal e).subtype
+    (LinearMap.mulRight Bᵐᵒᵖ (MulOpposite.op e)).rangeRestrict
+  ext x
+  exact fixed e he x
+
+/-- The actual finitely generated projective right module eB. -/
+def object (e : B) (he : e * e = e) : ProjectiveComplexes.Proj B :=
+  ⟨ModuleCat.of Bᵐᵒᵖ (ideal e), finite e, projective e he⟩
+
+/-- Left multiplication by an arrow a with target idempotent e'. -/
+def arrow {e e' : B} (he : e * e = e) (he' : e' * e' = e')
+    (a : B) (ha : e' * a = a) : object e he ⟶ object e' he' :=
+  ObjectProperty.homMk (ModuleCat.ofHom
+    (((LinearMap.mulRight Bᵐᵒᵖ (MulOpposite.op a)).comp (ideal e).subtype).codRestrict
+      (ideal e') (fun x => ⟨x.val * MulOpposite.op a, by
+        change (x.val * MulOpposite.op a) * MulOpposite.op e' = x.val * MulOpposite.op a
+        rw [mul_assoc, ← MulOpposite.op_mul, ha]⟩)))
+
+@[simp] theorem arrow_apply {e e' : B} (he : e * e = e) (he' : e' * e' = e')
+    (a : B) (ha : e' * a = a) (x : ideal e) :
+    ((arrow he he' a ha).hom.hom x).val = x.val * MulOpposite.op a := rfl
+
+theorem arrow_comp {e₀ e₁ e₂ : B}
+    (h₀ : e₀*e₀=e₀) (h₁ : e₁*e₁=e₁) (h₂ : e₂*e₂=e₂)
+    (a b : B) (ha : e₁*a=a) (hb : e₂*b=b) :
+    arrow h₀ h₁ a ha ≫ arrow h₁ h₂ b hb =
+      arrow h₀ h₂ (b*a) (by rw [← mul_assoc, hb]) := by
+  apply ObjectProperty.hom_ext
+  apply ModuleCat.hom_ext
+  apply LinearMap.ext
+  intro x
+  apply Subtype.ext
+  change (x.val * MulOpposite.op a) * MulOpposite.op b = x.val * MulOpposite.op (b*a)
+  simp only [MulOpposite.op_mul, mul_assoc]
+
+end LittleFinitistic.VertexProjectives
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Rectification/VertexTensorEvaluation.lean b/lean/OAI/Algebra/Finitistic/Rectification/VertexTensorEvaluation.lean
new file mode 100644
index 0000000000000000000000000000000000000000..67ea129cfd83c64b373555940f1e3cb254af00ac
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Rectification/VertexTensorEvaluation.lean
@@ -0,0 +1,88 @@
+import OAI.Algebra.Finitistic.Localization.EvaluationModule
+import OAI.Algebra.Finitistic.Tensor.IdempotentTensorMaps
+
+namespace OAI
+noncomputable section
+namespace LittleFinitistic.QuadraticEncoding.Representation
+open IdempotentTensor BalancedTensor
+universe u v
+variable {k : Type u} [Field k] {d t : ℕ} {P : Relations k d t}
+variable {Y : Type v} [AddCommGroup Y] [Module k Y]
+variable (X : Representation P Y)
+
+abbrev vertexId (i : Fin 3) : B P := ThreeVertexAlgebra.vertex (composition P) i
+
+/-- Identify the actual fixed-point vertex part of M(Y) with Y. -/
+def vertexFixedEquiv (i : Fin 3) : leftSpace (k := k) (vertexId (P := P) i) X.Evaluation ≃ₗ[k] Y where
+  __ := (X.projection i).comp (leftSpace (k := k) (vertexId (P := P) i) X.Evaluation).subtype
+  invFun y := ⟨X.inclusion i y, by
+    change vertexId (P := P) i • X.inclusion i y = X.inclusion i y
+    rw [X.vertex_smul, X.projection_inclusion]⟩
+  left_inv m := by
+    apply Subtype.ext
+    exact (X.vertex_smul i m.val).symm.trans m.property
+  right_inv y := X.projection_inclusion i y
+
+/-- The manuscript's E_i tensor_B M(Y) ≃ Y, for the actual right ideal E_i=e_iB. -/
+def vertexTensorEquiv (i : Fin 3) :
+    Tensor k (B P) (rightIdeal (vertexId (P := P) i)) X.Evaluation ≃ₗ[k] Y :=
+  (tensorEquiv (k := k) (vertexId (P := P) i) X.Evaluation
+    ((ThreeVertexAlgebra.directedSystem (composition P)).idem i)).trans (X.vertexFixedEquiv i)
+
+@[simp] theorem vertexTensorEquiv_mk (i : Fin 3)
+    (m : rightIdeal (vertexId (P := P) i)) (y : X.Evaluation) :
+    X.vertexTensorEquiv i (BalancedTensor.mk k (B P) (rightIdeal (vertexId (P := P) i)) X.Evaluation m y) =
+      X.projection i (m.val • y) := rfl
+
+@[simp] theorem vertexTensorEquiv_symm (i : Fin 3) (y : Y) :
+    (X.vertexTensorEquiv i).symm y =
+      BalancedTensor.mk k (B P) (rightIdeal (vertexId (P := P) i)) X.Evaluation
+        ⟨vertexId (P := P) i,(ThreeVertexAlgebra.directedSystem (composition P)).idem i⟩
+        (X.inclusion i y) := rfl
+
+/-- Under the natural tensor identifications, an arrow map evaluates to its module action. -/
+theorem tensor_leftMultiply (i j : Fin 3) (b : B P)
+    (ht : vertexId (P := P) j*b=b) (hs : b*vertexId (P := P) i=b) (y : Y) :
+    X.vertexTensorEquiv j
+      (mapLeft (k := k) X.Evaluation (leftMultiply (e := vertexId (P := P) i) b ht)
+        ((X.vertexTensorEquiv i).symm y)) = X.projection j (b • X.inclusion i y) := by
+  rw [vertexTensorEquiv_symm, mapLeft_mk, vertexTensorEquiv_mk]
+  simp only [leftMultiply_apply, hs]
+
+lemma arrow01_target (h : Fin (d+1)) : vertexId (P := P) 1 * arrow01 P h = arrow01 P h := by
+  change ThreeVertexAlgebra.mul (composition P) _ _ = _
+  simp [vertexId,ThreeVertexAlgebra.vertex,ThreeVertexAlgebra.mul,arrow01]
+lemma arrow01_source (h : Fin (d+1)) : arrow01 P h * vertexId (P := P) 0 = arrow01 P h := by
+  change ThreeVertexAlgebra.mul (composition P) _ _ = _
+  simp [vertexId,ThreeVertexAlgebra.vertex,ThreeVertexAlgebra.mul,arrow01]
+lemma arrow12_target (h : Fin (d+1)) : vertexId (P := P) 2 * arrow12 P h = arrow12 P h := by
+  change ThreeVertexAlgebra.mul (composition P) _ _ = _
+  simp [vertexId,ThreeVertexAlgebra.vertex,ThreeVertexAlgebra.mul,arrow12]
+lemma arrow12_source (h : Fin (d+1)) : arrow12 P h * vertexId (P := P) 1 = arrow12 P h := by
+  change ThreeVertexAlgebra.mul (composition P) _ _ = _
+  simp [vertexId,ThreeVertexAlgebra.vertex,ThreeVertexAlgebra.mul,arrow12]
+
+theorem tensor_arrow01 (h : Fin (d+1)) (y : Y) :
+    X.vertexTensorEquiv 1
+      (mapLeft (k := k) X.Evaluation
+        (leftMultiply (e := vertexId (P := P) 0) (arrow01 P h) (arrow01_target h))
+        ((X.vertexTensorEquiv 0).symm y)) =
+      (Fin.cases (motive := fun _ => Module.End k Y) 1 X.generator h) y := by
+  rw [tensor_leftMultiply X 0 1 _ _ (arrow01_source h)]
+  erw [X.arrow01_smul]
+  rfl
+
+theorem tensor_arrow12 (h : Fin (d+1)) (y : Y) :
+    X.vertexTensorEquiv 2
+      (mapLeft (k := k) X.Evaluation
+        (leftMultiply (e := vertexId (P := P) 1) (arrow12 P h) (arrow12_target h))
+        ((X.vertexTensorEquiv 1).symm y)) =
+      (Fin.cases (motive := fun _ => Module.End k Y) 1 X.generator h) y := by
+  rw [tensor_leftMultiply X 1 2 _ _ (arrow12_source h)]
+  erw [X.arrow12_smul]
+  rfl
+end LittleFinitistic.QuadraticEncoding.Representation
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Rectification/VertexTensorLinear.lean b/lean/OAI/Algebra/Finitistic/Rectification/VertexTensorLinear.lean
new file mode 100644
index 0000000000000000000000000000000000000000..ea545ea732895833b6efbe97c97c2c65ffc2469b
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Rectification/VertexTensorLinear.lean
@@ -0,0 +1,49 @@
+import OAI.Algebra.Finitistic.Rectification.CornerPathTransport
+
+namespace OAI
+noncomputable section
+open CategoryTheory
+open scoped TensorProduct ModuleCat.Algebra
+namespace LittleFinitistic.BimoduleVertex
+universe u
+variable (k B : Type u) [Field k] [Ring B] [Algebra k B]
+
+instance linear (e : B) : (functor k B e).Linear k where
+  map_smul := by
+    intro M N f c
+    apply ModuleCat.hom_ext
+    apply LinearMap.ext
+    intro x
+    apply Subtype.ext
+    change algebraMap k (B ⊗[k] Bᵐᵒᵖ) c • (f.hom x.val) =
+      restriction k B (algebraMap k Bᵐᵒᵖ c) • (f.hom x.val)
+    rw [show restriction k B (algebraMap k Bᵐᵒᵖ c) =
+      algebraMap k (B ⊗[k] Bᵐᵒᵖ) c from
+      (Algebra.TensorProduct.includeRight : Bᵐᵒᵖ →ₐ[k] B ⊗[k] Bᵐᵒᵖ).commutes c]
+end LittleFinitistic.BimoduleVertex
+
+namespace LittleFinitistic.TensorComplex
+universe u
+variable {k B : Type u} [Field k] [Ring B] [Algebra k B]
+variable (D : CochainComplex (ModuleCat.{u} Bᵐᵒᵖ) ℤ)
+instance linear : (tensorFunctor (k := k) D).Linear k where
+  map_smul := by
+    intro M N f c
+    apply HomologicalComplex.Hom.ext
+    funext n
+    apply ModuleCat.hom_ext
+    apply LinearMap.ext
+    intro x
+    induction x using TensorProduct.inductionOn with
+    | tmul m y =>
+      change (c • f.hom m) ⊗ₜ[k] y = f.hom m ⊗ₜ[k]
+        ((algebraMap k Bᵐᵒᵖ c) • (y : D.X n))
+      exact TensorProduct.smul_tmul (R := k) c (f.hom m) (y : ScalarModule k B (D.X n))
+    | add x y hx hy =>
+      exact (map_add _ _ _).trans
+        ((congrArg₂ (· + ·) hx hy).trans (map_add _ _ _).symm)
+end LittleFinitistic.TensorComplex
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Rectification/VertexTotalProperties.lean b/lean/OAI/Algebra/Finitistic/Rectification/VertexTotalProperties.lean
new file mode 100644
index 0000000000000000000000000000000000000000..b0a46a83ddfea0a26db2c213dc02ae450880dce3
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Rectification/VertexTotalProperties.lean
@@ -0,0 +1,59 @@
+import OAI.Algebra.Finitistic.Rectification.SecondVertex
+
+namespace OAI
+noncomputable section
+open CategoryTheory CategoryTheory.Limits HomologicalComplex
+namespace LittleFinitistic.VertexTotalProperties
+open ExternalTensor.Section4
+universe u
+variable {k B : Type u} [Field k] [Ring B] [Algebra k B]
+
+/-- The actual vertex of a right-projective bimodule remains right-projective. -/
+theorem projective (e : B) (he : e*e=e) (M : ModuleCat.{u} (Enveloping k B))
+    (hM : Projective ((forgetRight k B).obj M)) :
+    Projective ((BimoduleVertex.functor k B e).obj M) := by
+  let := hM
+  have : Module.Projective Bᵐᵒᵖ (VertexFunctor.restricted (BimoduleVertex.restriction k B) M) :=
+    inferInstanceAs (Module.Projective Bᵐᵒᵖ ((forgetRight k B).obj M))
+  have := VertexFunctor.projective (BimoduleVertex.restriction k B) (BimoduleVertex.vertex k B e)
+      (BimoduleVertex.vertex_idempotent k B e he) (BimoduleVertex.vertex_commute k B e) M
+  change Projective (ModuleCat.of Bᵐᵒᵖ
+    (VertexFunctor.fixed (BimoduleVertex.restriction k B) (BimoduleVertex.vertex k B e)
+      (BimoduleVertex.vertex_commute k B e) M))
+  exact ModuleCat.projective_of_categoryTheory_projective (R := Bᵐᵒᵖ) _
+
+variable {d t : ℕ} (P : QuadraticEncoding.Relations k d t)
+variable (D₀ D₁ D₂ : RightComplex (QuadraticEncoding.B P))
+variable (f : Fin (d+1) → (D₀ ⟶ D₁)) (g : Fin (d+1) → (D₁ ⟶ D₂))
+variable (H : ∀ r, Homotopy
+  (relationMap (ConcreteQuadraticDiagram.quadratic P) D₀ D₁ D₂ f g r) 0)
+
+/-- Every actual vertex of the constructed total has projective right-module terms. -/
+theorem total_projective (v : Fin 3)
+    (h₀ : ∀ n, Module.Projective (QuadraticEncoding.B P)ᵐᵒᵖ (D₀.X n))
+    (h₁ : ∀ n, Module.Projective (QuadraticEncoding.B P)ᵐᵒᵖ (D₁.X n))
+    (h₂ : ∀ n, Module.Projective (QuadraticEncoding.B P)ᵐᵒᵖ (D₂.X n)) (n : ℤ) :
+    Projective (((AdjacentArrowSum.vertexComplex (QuadraticEncoding.composition P) v).obj
+      (InducedRectification.total (ConcreteQuadraticDiagram.quadratic P) D₀ D₁ D₂ f g H)).X n) :=
+  projective (ThreeVertexAlgebra.vertex (QuadraticEncoding.composition P) v)
+    ((ThreeVertexAlgebra.directedSystem (QuadraticEncoding.composition P)).idem v) _
+    (InducedRectification.rightTotal_projective (ConcreteQuadraticDiagram.quadratic P)
+      D₀ D₁ D₂ f g H h₀ h₁ h₂ n)
+
+theorem total_bounded (v : Fin 3) (lo hi : ℤ)
+    (h₀ : ∀ n, n < lo ∨ hi < n → IsZero (D₀.X n))
+    (h₁ : ∀ n, n < lo ∨ hi < n → IsZero (D₁.X n))
+    (h₂ : ∀ n, n < lo ∨ hi < n → IsZero (D₂.X n)) :
+    ∀ n, n < lo-2 ∨ hi < n → IsZero
+      (((AdjacentArrowSum.vertexComplex (QuadraticEncoding.composition P) v).obj
+        (InducedRectification.total (ConcreteQuadraticDiagram.quadratic P) D₀ D₁ D₂ f g H)).X n) := by
+  intro n hn
+  exact (BimoduleVertex.functor k (QuadraticEncoding.B P)
+    (ThreeVertexAlgebra.vertex (QuadraticEncoding.composition P) v)).map_isZero
+    (InducedRectification.total_bounded (ConcreteQuadraticDiagram.quadratic P)
+      D₀ D₁ D₂ f g H lo hi h₀ h₁ h₂ n hn)
+end LittleFinitistic.VertexTotalProperties
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Rectification/VertexZeroTotal.lean b/lean/OAI/Algebra/Finitistic/Rectification/VertexZeroTotal.lean
new file mode 100644
index 0000000000000000000000000000000000000000..684b0953107999a61146cc50cdcf6130a5aa46e5
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Rectification/VertexZeroTotal.lean
@@ -0,0 +1,62 @@
+import OAI.Algebra.Finitistic.Rectification.VertexColumnComplex
+import OAI.Algebra.Finitistic.Rectification.ZeroColumnTotal
+import OAI.Algebra.Finitistic.Rectification.InducedRectification
+import OAI.Algebra.Finitistic.Localization.ConcreteQuadraticDiagram
+
+namespace OAI
+noncomputable section
+open CategoryTheory CategoryTheory.Limits HomologicalComplex
+open scoped TensorProduct ModuleCat.Algebra
+namespace LittleFinitistic.VertexZeroTotal
+open ExternalTensor.Section4
+universe u
+variable {k : Type u} [Field k] {d t : ℕ} (P : QuadraticEncoding.Relations k d t)
+local notation "B" => QuadraticEncoding.B P
+local notation "s" => ConcreteQuadraticDiagram.quadratic P
+abbrev vertexFunctor := BimoduleVertex.functor k (QuadraticEncoding.B P)
+  (ThreeVertexAlgebra.vertex (QuadraticEncoding.composition P) 0)
+
+/-- Actual column terms vanish at vertex zero when their supporting vertex is positive. -/
+theorem column_zero (j : Fin 3) (hj : 0 < j) (D : RightComplex (QuadraticEncoding.B P)) (n : ℤ) :
+    IsZero ((vertexFunctor P).obj
+      (((columnComplex k B (ThreeVertexAlgebra.vertex (QuadraticEncoding.composition P) j)).obj D).X n)) := by
+  exact (HomologicalComplex.eval _ _ n).map_isZero
+    (VertexColumnComplex.reverse_isZero (QuadraticEncoding.composition P) 0 j hj D)
+
+variable (D₀ D₁ D₂ : RightComplex (QuadraticEncoding.B P))
+variable (f : Fin (d+1) → (D₀ ⟶ D₁)) (g : Fin (d+1) → (D₁ ⟶ D₂))
+
+/-- Both higher columns of the constructed total vanish at the first vertex. -/
+theorem higher_zero (n : ℤ) :
+    IsZero ((vertexFunctor P).obj ((L1Prime s D₀ D₁ D₂ f g).X n)) ∧
+    IsZero ((vertexFunctor P).obj ((L2Prime s D₀ D₁ D₂ f g).X n)) := by
+  let G := HomologicalComplex.eval (ModuleCat.{u} (Enveloping k B)) (.up ℤ) n ⋙ vertexFunctor P
+  let := preservesBinaryBiproducts_of_preservesBiproducts G
+  constructor
+  · change IsZero (G.obj ((⨁ fun _ : Fin (d+1) =>
+      (columnComplex k B (s).e₁).obj D₀) ⊞ (⨁ fun _ : Fin (d+1) =>
+      (columnComplex k B (s).e₂).obj D₁)))
+    apply (G.mapBiprod _ _).isZero_iff.mpr
+    rw [biprod_isZero_iff]
+    constructor
+    · apply (G.mapBiproduct _).isZero_iff.mpr
+      exact sum_isZero _ (fun _ => column_zero P 1 (by decide) D₀ n)
+    · apply (G.mapBiproduct _).isZero_iff.mpr
+      exact sum_isZero _ (fun _ => column_zero P 2 (by decide) D₁ n)
+  · change IsZero (G.obj (⨁ fun _ : RelationBasisCoefficients.RelationIndex P =>
+      (columnComplex k B (s).e₂).obj D₀))
+    apply (G.mapBiproduct _).isZero_iff.mpr
+    exact sum_isZero _ (fun _ => column_zero P 2 (by decide) D₀ n)
+
+/-- At vertex zero, the original zero-column inclusion in the actual total is an isomorphism. -/
+theorem inclusion_isIso (H : ∀ r, Homotopy (relationMap s D₀ D₁ D₂ f g r) 0) :
+    IsIso (((vertexFunctor P).mapHomologicalComplex (.up ℤ)).map
+      (InducedRectification.inclusion s D₀ D₁ D₂ f g H)) :=
+  ZeroColumnTotal.mapped_inclusion_isIso _ _ _ (vertexFunctor P)
+    (fun n => (higher_zero P D₀ D₁ D₂ f g n).1)
+    (fun n => (higher_zero P D₀ D₁ D₂ f g n).2)
+end LittleFinitistic.VertexZeroTotal
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Rectification/ZeroColumnTotal.lean b/lean/OAI/Algebra/Finitistic/Rectification/ZeroColumnTotal.lean
new file mode 100644
index 0000000000000000000000000000000000000000..b41d5c21c802278c69fe37bb11225a47b5a77f10
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Rectification/ZeroColumnTotal.lean
@@ -0,0 +1,67 @@
+import OAI.Algebra.Finitistic.Rectification.RectificationTotal
+
+namespace OAI
+noncomputable section
+open CategoryTheory CategoryTheory.Limits CochainComplex HomologicalComplex
+namespace LittleFinitistic.ZeroColumnTotal
+variable {C D : Type*} [Category C] [Category D] [Preadditive C] [Preadditive D]
+  [HasBinaryBiproducts C] [HasBinaryBiproducts D]
+
+def biprodInrIso {X Y : D} (hX : IsZero X) : Y ≅ X ⊞ Y where
+  hom := biprod.inr
+  inv := biprod.snd
+  hom_inv_id := by simp
+  inv_hom_id := by
+    apply biprod.hom_ext
+    · exact hX.eq_of_tgt _ _
+    · simp
+
+omit [HasBinaryBiproducts D] in
+theorem complex_zero {X : CochainComplex D ℤ} (hX : ∀ i, IsZero (X.X i)) : IsZero X := by
+  apply (IsZero.iff_id_eq_zero _).2
+  apply HomologicalComplex.Hom.ext
+  funext i
+  exact (hX i).eq_of_src _ _
+
+/-- If the cone source is zero, its original inclusion is an isomorphism. -/
+theorem cone_inr_isIso {X Y : CochainComplex D ℤ} (f : X ⟶ Y) (hX : IsZero X) :
+    IsIso (mappingCone.inr f) := by
+  have hi : ∀ i, IsIso ((mappingCone.inr f).f i) := by
+    intro i
+    let e : (mappingCone f).X i ≅ X.X (i+1) ⊞ Y.X i :=
+      homotopyCofiber.XIsoBiprod f i (i+1) (by simp)
+    rw [← isIso_comp_right_iff ((mappingCone.inr f).f i) e.hom]
+    have he : (mappingCone.inr f).f i ≫ e.hom = biprod.inr :=
+      homotopyCofiber.inrX_XIsoBiprod_hom f (i+1) i (by simp)
+    rw [he]
+    exact (biprodInrIso ((HomologicalComplex.eval D (.up ℤ) (i+1)).map_isZero hX)).isIso_hom
+  let := hi
+  exact HomologicalComplex.Hom.isIso_of_components _
+
+/-- A mapped cone whose two columns vanish is actually zero. -/
+theorem mappedCone_zero {X Y : CochainComplex C ℤ} (f : X ⟶ Y)
+    (F : C ⥤ D) [F.Additive]
+    (hX : ∀ i, IsZero (F.obj (X.X i))) (hY : ∀ i, IsZero (F.obj (Y.X i))) :
+    IsZero ((F.mapHomologicalComplex (.up ℤ)).obj (mappingCone f)) := by
+  apply (mappingCone.mapHomologicalComplexIso f F).isZero_iff.mpr
+  apply complex_zero
+  intro i
+  rw [mappingCone.isZero_X_iff]
+  exact ⟨hX (i+1),hY i⟩
+
+/-- Vanishing higher columns make the original zero-column inclusion an isomorphism. -/
+theorem mapped_inclusion_isIso {L₀ L₁ L₂ : CochainComplex C ℤ}
+    (p : L₁ ⟶ L₀) (q : L₂ ⟶ L₁) (h : Homotopy (q ≫ p) 0)
+    (F : C ⥤ D) [F.Additive]
+    (h₁ : ∀ i, IsZero (F.obj (L₁.X i))) (h₂ : ∀ i, IsZero (F.obj (L₂.X i))) :
+    IsIso ((F.mapHomologicalComplex (.up ℤ)).map (RectificationTotal.inclusion p q h)) := by
+  let t := RectificationTotal.rectifyingMap p q h
+  change IsIso ((F.mapHomologicalComplex (.up ℤ)).map (mappingCone.inr t))
+  rw [← isIso_comp_right_iff _ (mappingCone.mapHomologicalComplexIso t F).hom,
+    mappingCone.map_inr]
+  exact cone_inr_isIso _ (mappedCone_zero q F h₂ h₁)
+end LittleFinitistic.ZeroColumnTotal
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Rectification/ZeroLastColumn.lean b/lean/OAI/Algebra/Finitistic/Rectification/ZeroLastColumn.lean
new file mode 100644
index 0000000000000000000000000000000000000000..3fe80cb825d3040c0510d162ba2ef3cc0dd5c2ff
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Rectification/ZeroLastColumn.lean
@@ -0,0 +1,47 @@
+import OAI.Algebra.Finitistic.Rectification.TotalFunctorial
+import OAI.Algebra.Finitistic.Rectification.ZeroColumnTotal
+
+namespace OAI
+noncomputable section
+open CategoryTheory CategoryTheory.Limits HomologicalComplex CochainComplex
+namespace LittleFinitistic.ZeroLastColumn
+open RectificationTotal
+variable {C D : Type*} [Category C] [Category D] [Preadditive C] [Preadditive D]
+  [HasBinaryBiproducts C] [HasBinaryBiproducts D]
+
+def coneIso {X Y X' Y' : CochainComplex D ℤ} (p : X ⟶ Y) (p' : X' ⟶ Y')
+    (a : X ≅ X') (b : Y ≅ Y') (w : a.hom ≫ p' = p ≫ b.hom) :
+    mappingCone p ≅ mappingCone p' where
+  hom := coneMap p p' a.hom b.hom w
+  inv := coneMap p' p a.inv b.inv (by
+    apply (cancel_epi a.hom).1
+    simp only [← Category.assoc, Iso.hom_inv_id, Category.id_comp]
+    rw [w, Category.assoc, Iso.hom_inv_id, Category.comp_id])
+  hom_inv_id := by rw [← coneMap_comp]; simp
+  inv_hom_id := by rw [← coneMap_comp]; simp
+
+variable {L₀ L₁ L₂ : CochainComplex C ℤ}
+variable (p : L₁ ⟶ L₀) (q : L₂ ⟶ L₁) (h : Homotopy (q ≫ p) 0)
+variable (F : C ⥤ D) [F.Additive]
+
+/-- Taking an additive image that kills the relation column leaves precisely the ordinary cone. -/
+def mappedTotalIso (h₂ : IsZero ((F.mapHomologicalComplex (.up ℤ)).obj L₂)) :
+    (F.mapHomologicalComplex (.up ℤ)).obj (total p q h) ≅
+      mappingCone ((F.mapHomologicalComplex (.up ℤ)).map p) := by
+  let G := F.mapHomologicalComplex (.up ℤ)
+  have hi : IsIso (G.map (mappingCone.inr q)) := by
+    rw [← isIso_comp_right_iff _ (mappingCone.mapHomologicalComplexIso q F).hom,
+      mappingCone.map_inr]
+    exact ZeroColumnTotal.cone_inr_isIso _ h₂
+  letI := hi
+  refine mappingCone.mapHomologicalComplexIso (rectifyingMap p q h) F ≪≫
+    (coneIso (G.map p) (G.map (rectifyingMap p q h))
+      (asIso (G.map (mappingCone.inr q))) (Iso.refl _) ?_).symm
+  simp only [asIso_hom,Iso.refl_hom,Category.comp_id,← Functor.map_comp]
+  congr 1
+  simp [rectifyingMap]
+end LittleFinitistic.ZeroLastColumn
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Selected/SelectedBarBimodule.lean b/lean/OAI/Algebra/Finitistic/Selected/SelectedBarBimodule.lean
new file mode 100644
index 0000000000000000000000000000000000000000..503b388383e1486ba27b19419b38315c2ce3d68d
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Selected/SelectedBarBimodule.lean
@@ -0,0 +1,35 @@
+import OAI.Algebra.Finitistic.Selected.SelectedOrdinaryResolution
+import OAI.Algebra.Finitistic.Bimodule.BimoduleBarTensorComparison
+
+namespace OAI
+noncomputable section
+open CategoryTheory
+namespace LittleFinitistic.SelectedBarBimodule
+open SelectedOrdinaryAlgebra
+
+/-- The action presentation of X used by the generic native/bar comparison. -/
+abbrev comparisonX := BimoduleBarComparison.Actions ℂ D SelectedOrdinaryResolution.target
+
+/-- Recover exactly the original right action of the constructed ordinary X. -/
+def rightEquiv : comparisonX ≃ₗ[Dᵐᵒᵖ] X :=
+  RetainedBimodule.rightEquiv ℂ D D X
+
+/-- The same identification preserves the original outside left D-action. -/
+theorem left_action (d : D) (x : comparisonX) : rightEquiv (d • x) = d • rightEquiv x :=
+  RetainedBimodule.rightEquiv_left ℂ D D X d x
+
+def leftEquiv : comparisonX ≃ₗ[D] X where
+  toFun := rightEquiv
+  invFun := rightEquiv.symm
+  left_inv := rightEquiv.left_inv
+  right_inv := rightEquiv.right_inv
+  map_add' := rightEquiv.map_add
+  map_smul' := left_action
+
+theorem right_action (d : Dᵐᵒᵖ) (x : comparisonX) :
+    leftEquiv (d • x) = d • leftEquiv x := rightEquiv.map_smul d x
+end LittleFinitistic.SelectedBarBimodule
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Selected/SelectedBarComparison.lean b/lean/OAI/Algebra/Finitistic/Selected/SelectedBarComparison.lean
new file mode 100644
index 0000000000000000000000000000000000000000..c22df3d063410c72b87fbf994e947ae993015d15
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Selected/SelectedBarComparison.lean
@@ -0,0 +1,51 @@
+import OAI.Algebra.Finitistic.Selected.SelectedBarBimodule
+import OAI.Algebra.Finitistic.Bar.BarBimoduleCongruence
+import OAI.Algebra.Finitistic.Bimodule.BimoduleResolutionBarAPI
+import OAI.Algebra.Finitistic.Selected.SelectedBarStart
+
+namespace OAI
+noncomputable section
+open CategoryTheory CategoryTheory.Functor
+namespace LittleFinitistic.SelectedBarComparison
+open SelectedOrdinaryAlgebra SelectedBarBimodule
+local instance : HasDerivedCategory.{1} (ModuleCat.{0} D) :=
+  HasDerivedCategory.standard (ModuleCat.{0} D)
+
+/-- The actual fixed resolution supplies every generic native/bar premise. -/
+def resolution := BimoduleTotal.ofNonpositiveResolution
+  SelectedOrdinaryResolution.complex SelectedOrdinaryResolution.target length
+  SelectedOrdinaryResolution.augmentation SelectedOrdinaryResolution.augmentation_quasiIso
+  (fun n => SelectedOrdinaryResolution.right_projective n) SelectedOrdinaryResolution.bounded
+
+/-- The native finite-interval presentation of tensor by the actual Q_X. Its
+comparison to the ordinary total presentation is proved separately. -/
+abbrev native := resolution.data.derived
+
+/-- The native tensor of the actual Q_X agrees naturally with bar-derived
+ tensor by the ORIGINAL X, with no remaining augmentation or action premise. -/
+def naturalIso : DerivedBar.chainToIntegerDerived D ⋙ native ≅
+    DerivedBar.derivedTensor ℂ D X ⋙ DerivedBar.chainToIntegerDerived D :=
+  BimoduleTotal.nonpositiveResolutionBarIso
+    SelectedOrdinaryResolution.complex SelectedOrdinaryResolution.target length
+    SelectedOrdinaryResolution.augmentation SelectedOrdinaryResolution.augmentation_quasiIso
+    (fun n => SelectedOrdinaryResolution.right_projective n) SelectedOrdinaryResolution.bounded ≪≫
+  isoWhiskerRight (DerivedBar.BimoduleTensor.derivedTensorCongr ℂ D leftEquiv right_action)
+    (DerivedBar.chainToIntegerDerived D)
+
+/-- Every actual native iterate on a stalk is the original-X bar-derived iterate. -/
+def powerIso (N : ModuleCat.{0} D) (r : ℕ) :
+    (native.obj^[r]) (DerivedCategory.Q.obj (BimoduleTotal.singleInput D N)) ≅
+      DerivedBar.IterateSupport.object ℂ D X N r :=
+  BimoduleTotal.nonpositiveResolutionPowerIso
+    SelectedOrdinaryResolution.complex SelectedOrdinaryResolution.target length
+    SelectedOrdinaryResolution.augmentation SelectedOrdinaryResolution.augmentation_quasiIso
+    (fun n => SelectedOrdinaryResolution.right_projective n) SelectedOrdinaryResolution.bounded N r ≪≫
+  (DerivedBar.integerDerivedIterateIndexedIso D ℂ comparisonX N r).symm ≪≫
+  (DerivedBar.chainToIntegerDerived D).mapIso
+    ((DerivedBar.BimoduleTensor.derivedIterateCongr ℂ D leftEquiv right_action r).app
+      ((DerivedBar.chainQ D).obj ((ChainComplex.single₀ (ModuleCat D)).obj N)))
+end LittleFinitistic.SelectedBarComparison
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Selected/SelectedBarPowers.lean b/lean/OAI/Algebra/Finitistic/Selected/SelectedBarPowers.lean
new file mode 100644
index 0000000000000000000000000000000000000000..3e9a38e76620b276ca95b4fb5f152cb0bccd24d0
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Selected/SelectedBarPowers.lean
@@ -0,0 +1,29 @@
+import OAI.Algebra.Finitistic.Selected.SelectedBarComparison
+
+namespace OAI
+noncomputable section
+open CategoryTheory CategoryTheory.Limits
+namespace LittleFinitistic.SelectedBarPowers
+open SelectedOrdinaryAlgebra SelectedBarComparison
+local instance : HasDerivedCategory.{1} (ModuleCat.{0} D) :=
+  HasDerivedCategory.standard (ModuleCat.{0} D)
+
+/-- All powers on the exact selected first-block derived family are the original
+bar-derived powers; every resolution, scalar, action and stalk bridge is discharged. -/
+def comparison (Y : FiniteSelectionFamily.S.{0}) (r : ℕ) :
+    (native.obj^[r]) (SelectedFirstBlockFamily.derived Y) ≅ SelectedBaseIterates.object Y r :=
+  (eqToIso (BimoduleTotal.nativeIterate_obj resolution r (SelectedFirstBlockFamily.derived Y))).symm ≪≫
+  (BimoduleTotal.nativeIterate resolution r).mapIso
+    ((DerivedCategory.singleFunctorIsoCompQ (ModuleCat D) 0).app (SelectedBaseIterates.input Y)) ≪≫
+  eqToIso (BimoduleTotal.nativeIterate_obj resolution r
+    (DerivedCategory.Q.obj (BimoduleTotal.singleInput D (SelectedBaseIterates.input Y)))) ≪≫
+  powerIso (SelectedBaseIterates.input Y) r
+
+theorem isZero_iff (Y : FiniteSelectionFamily.S.{0}) (r : ℕ) :
+    IsZero ((native.obj^[r]) (SelectedFirstBlockFamily.derived Y)) ↔
+      IsZero (SelectedBaseIterates.object Y r) := (comparison Y r).isZero_iff
+end LittleFinitistic.SelectedBarPowers
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Selected/SelectedBarResolution.lean b/lean/OAI/Algebra/Finitistic/Selected/SelectedBarResolution.lean
new file mode 100644
index 0000000000000000000000000000000000000000..2afb89ff084ac44d52ff274a75187d3f22f0f7e8
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Selected/SelectedBarResolution.lean
@@ -0,0 +1,24 @@
+import OAI.Algebra.Finitistic.Selected.SelectedOrdinaryModules
+import OAI.Algebra.Finitistic.Bar.FiniteBarResolution
+
+namespace OAI
+noncomputable section
+open CategoryTheory
+namespace LittleFinitistic.SelectedBarResolution
+open SelectedOrdinaryAlgebra SelectedOrdinaryModules
+
+/-- The genuine absolute bar projective resolution of each actual inflated
+module. It can have infinitely many nonzero degrees. -/
+def resolution (Y : FiniteSelectionFamily.S.{0}) : ProjectiveResolution (module Y) :=
+  DerivedBar.projectiveResolution ℂ A (Inflated Y)
+
+theorem finite_free (Y : FiniteSelectionFamily.S.{0}) (n : ℕ) :
+    Module.Finite A ((resolution Y).complex.X n) ∧
+      Module.Free A ((resolution Y).complex.X n) :=
+  ⟨DerivedBar.projectiveResolution_finite ℂ A (Inflated Y) n,
+    DerivedBar.projectiveResolution_free ℂ A (Inflated Y) n⟩
+end LittleFinitistic.SelectedBarResolution
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Selected/SelectedBarStart.lean b/lean/OAI/Algebra/Finitistic/Selected/SelectedBarStart.lean
new file mode 100644
index 0000000000000000000000000000000000000000..6d357a727d533a6ed9be8ddd35ba941dead1e1dd
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Selected/SelectedBarStart.lean
@@ -0,0 +1,35 @@
+import OAI.Algebra.Finitistic.Selected.SelectedFirstBlockFamily
+import OAI.Algebra.Finitistic.Bar.IntegerStalk
+
+namespace OAI
+noncomputable section
+open CategoryTheory CategoryTheory.Limits
+namespace LittleFinitistic.SelectedBarStart
+open SelectedOrdinaryAlgebra SelectedBaseIterates
+local instance : HasDerivedCategory.{1} (ModuleCat.{0} D) :=
+  HasDerivedCategory.standard (ModuleCat.{0} D)
+
+/-- Bar iteration starts at exactly the same first-block derived stalk as the
+ordinary simulation, through the actual extension and localization isomorphisms. -/
+def startIso (Y : FiniteSelectionFamily.S.{0}) :
+    object Y 0 ≅ SelectedFirstBlockFamily.derived Y :=
+  DerivedBar.IterateSupport.resolvedModelIso ℂ D X (input Y) 0 ≪≫
+    DerivedBar.integerStalkIso D (input Y)
+
+theorem start_zero (Y : FiniteSelectionFamily.S.{0}) :
+    IsZero (object Y 0) ↔ Subsingleton Y.val :=
+  (startIso Y).isZero_iff.trans (SelectedFirstBlockFamily.derived_zero Y)
+
+/-- The selected first-block stalk family has the exact original H-extinction. -/
+theorem firstBlock_extinction (m : ℕ) [NeZero m] :
+    (∀ j < m, ¬ IsZero (SelectedFirstBlockFamily.derived
+      ((FiniteSelectionFamily.H^[j]) (FiniteSelectionFamily.test m)))) ∧
+    IsZero (SelectedFirstBlockFamily.derived
+      ((FiniteSelectionFamily.H^[m]) (FiniteSelectionFamily.test m))) := by
+  simpa only [SelectedFirstBlockFamily.derived_zero, FiniteSelectionFamily.derived_zero] using
+    FiniteSelectionFamily.extinction m
+end LittleFinitistic.SelectedBarStart
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Selected/SelectedBaseIterates.lean b/lean/OAI/Algebra/Finitistic/Selected/SelectedBaseIterates.lean
new file mode 100644
index 0000000000000000000000000000000000000000..42f58879f6681def1ce387aeb7bbab9640360d71
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Selected/SelectedBaseIterates.lean
@@ -0,0 +1,55 @@
+import OAI.Algebra.Finitistic.Selected.SelectedOrdinaryModules
+import OAI.Algebra.Finitistic.Iteration.AdditiveIterateAmplitude
+
+namespace OAI
+noncomputable section
+open CategoryTheory CategoryTheory.Limits
+namespace LittleFinitistic.SelectedBaseIterates
+open SelectedOrdinaryAlgebra SelectedOrdinaryModules
+
+/-- The actual first-block D-module underlying the inflated A-module. -/
+abbrev input (Y : FiniteSelectionFamily.S.{0}) := ModuleCat.of D (Inflated Y)
+
+local instance (N : ModuleCat.{0} D) : Module ℂ N := DerivedBar.BimoduleTensor.scalarModule ℂ D N
+local instance (N : ModuleCat.{0} D) : IsScalarTower ℂ D N where
+  smul_assoc c d n := by
+    change (c • d) • n = (algebraMap ℂ D c) • (d • n)
+    have hd : c • d = (algebraMap ℂ D c) * d := by
+      exact Algebra.smul_def c d
+    rw [hd, mul_smul]
+
+instance input_finiteD (Y : FiniteSelectionFamily.S.{0}) : Module.Finite D (input Y) :=
+  Module.Finite.of_restrictScalars_finite ℂ D (Inflated Y)
+
+instance input_finite (Y : FiniteSelectionFamily.S.{0}) : FiniteDimensional ℂ (input Y) :=
+  Module.Finite.trans D (input Y)
+
+local instance : HasDerivedCategory.{1} (ModuleCat.{0} D) :=
+  HasDerivedCategory.standard (ModuleCat.{0} D)
+
+/-- Genuine bar-derived iteration of the actual X over the actual D. -/
+abbrev object (Y : FiniteSelectionFamily.S.{0}) (r : ℕ) :=
+  DerivedBar.IterateSupport.object ℂ D X (input Y) r
+
+theorem cohomology_finite (Y : FiniteSelectionFamily.S.{0}) (r : ℕ) (i : ℤ) :
+    FiniteDimensional ℂ ((ModuleCat.restrictScalars (algebraMap ℂ D)).obj
+      ((DerivedCategory.homologyFunctor (ModuleCat D) i).obj (object Y r))) := by
+  let : Module ℂ (input Y) := DerivedBar.BimoduleTensor.scalarModule ℂ D (input Y)
+  have : IsScalarTower ℂ D (input Y) := by
+    refine ⟨fun c d n => ?_⟩
+    change (c • d) • n = (algebraMap ℂ D c) • (d • n)
+    have hd : c • d = (algebraMap ℂ D c) * d := by exact Algebra.smul_def c d
+    rw [hd, mul_smul]
+  have : FiniteDimensional ℂ (input Y) := Module.Finite.trans D (input Y)
+  exact DerivedBar.IterateSupport.cohomology_finite ℂ D X (input Y) r i
+
+/-- A global-dimension bound on D bounds the amplitude of every derived iterate. -/
+theorem bounded (g : ℕ) (hg : ∀ M : ModuleCat.{0} D, HasProjectiveDimensionLE M g)
+    (Y : FiniteSelectionFamily.S.{0}) (r : ℕ) :
+    (object Y r).IsGE (-((r*(g+2) : ℕ) : ℤ)) ∧ (object Y r).IsLE 0 :=
+  DerivedBar.IterateSupport.bounded_amplitude ℂ D X g hg (input Y) r
+end LittleFinitistic.SelectedBaseIterates
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Selected/SelectedChainAction.lean b/lean/OAI/Algebra/Finitistic/Selected/SelectedChainAction.lean
new file mode 100644
index 0000000000000000000000000000000000000000..054fdfb176e23cfc01b5195eef1ae16902dab717
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Selected/SelectedChainAction.lean
@@ -0,0 +1,76 @@
+import OAI.Algebra.Finitistic.Selected.SelectedUnderlyingHomology
+
+namespace OAI
+noncomputable section
+open CategoryTheory CategoryTheory.Limits
+attribute [local instance] HasDerivedCategory.standard
+namespace LittleFinitistic.SelectedChainAction
+open QuadraticEncoding SelectedFixedDiagram SelectedNativeEvaluation SelectedChainHomology
+universe v
+variable {Y : Type v} [AddCommGroup Y] [Module ℂ Y]
+  [Module SelectionRing Y] [IsScalarTower ℂ SelectionRing Y]
+
+lemma HAction_one : HAction (Y := Y) 1 = 𝟙 _ := by
+  apply ModuleCat.hom_ext
+  ext x
+  rw [HAction_apply]
+  apply Subtype.ext
+  change selectionAutomorphism 1 (1 : SelectionRing) • x.val = x.val
+  rw [map_one,one_smul]
+
+/-- In the underlying Y, the selected action is exactly restriction of alpha(r). -/
+lemma HAction_val (r : SelectionRing) (x : H (Y := Y)) :
+    ((HAction (Y := Y) r).hom x).val = alpha r • x.val := by
+  rw [HAction_apply]
+  rfl
+
+variable [FiniteDimensional ℂ Y]
+
+lemma distinguished01 (n : ℤ) (hn : n = 0 ∨ n = -3) :
+    HomologicalComplex.homologyMap
+      (SelectedTensorComparison.tensorMap (representation (Y := Y)) (SelectedChainDiagram.fixedChain.f 0)) n ≫
+        (SelectedChainHomology.D1Iso n hn).hom = (SelectedChainHomology.D0Iso n hn).hom := by
+  simpa only [RelationBasisAction.arrow,Fin.cases_zero,HAction_one,Category.comp_id] using
+    (fixed_arrow01 (Y := Y) 0 n hn)
+lemma distinguished12 (n : ℤ) (hn : n = 0 ∨ n = -3) :
+    HomologicalComplex.homologyMap
+      (SelectedTensorComparison.tensorMap (representation (Y := Y)) (SelectedChainDiagram.fixedChain.g 0)) n ≫
+        (SelectedChainHomology.D2Iso n hn).hom = (SelectedChainHomology.D1Iso n hn).hom := by
+  simpa only [RelationBasisAction.arrow,Fin.cases_zero,HAction_one,Category.comp_id] using
+    (fixed_arrow12 (Y := Y) 0 n hn)
+
+/-- Every actual first arrow, on every homology class in either selected degree. -/
+lemma arrow01_val (a : Fin (encoding.generators+1))
+    (f : UnderlyingRepresentatives.complex P fixed.D0 ⟶ UnderlyingRepresentatives.complex P fixed.D1)
+    (hf : (HomotopyCategory.quotient _ _).map f = (SourceModelBridge.ambient P).map (fixed.f a))
+    (n : ℤ) (hn : n = 0 ∨ n = -3) (x : (complex (Y := Y) fixed.D0).homology n) :
+    ((SelectedChainHomology.D1Iso n hn).hom.hom
+      ((HomologicalComplex.homologyMap (SelectedUnderlyingHomology.tensorMap (Y := Y) f) n).hom x)).val =
+      alpha (RelationBasisAction.arrow (SelectionEncoding.generator encoding) a) •
+        ((SelectedChainHomology.D0Iso n hn).hom.hom x).val := by
+  have h := congrArg (fun q => q.hom x) (SelectedUnderlyingHomology.arrow01 (Y := Y) a f hf n hn)
+  change (SelectedChainHomology.D1Iso n hn).hom.hom
+      ((HomologicalComplex.homologyMap (SelectedUnderlyingHomology.tensorMap (Y := Y) f) n).hom x) =
+    (HAction (Y := Y) (RelationBasisAction.arrow (SelectionEncoding.generator encoding) a)).hom
+      ((SelectedChainHomology.D0Iso n hn).hom.hom x) at h
+  exact (congrArg Subtype.val h).trans (HAction_val _ _)
+
+lemma arrow12_val (a : Fin (encoding.generators+1))
+    (g : UnderlyingRepresentatives.complex P fixed.D1 ⟶ UnderlyingRepresentatives.complex P fixed.D2)
+    (hg : (HomotopyCategory.quotient _ _).map g = (SourceModelBridge.ambient P).map (fixed.g a))
+    (n : ℤ) (hn : n = 0 ∨ n = -3) (x : (complex (Y := Y) fixed.D1).homology n) :
+    ((SelectedChainHomology.D2Iso n hn).hom.hom
+      ((HomologicalComplex.homologyMap (SelectedUnderlyingHomology.tensorMap (Y := Y) g) n).hom x)).val =
+      alpha (RelationBasisAction.arrow (SelectionEncoding.generator encoding) a) •
+        ((SelectedChainHomology.D1Iso n hn).hom.hom x).val := by
+  have h := congrArg (fun q => q.hom x) (SelectedUnderlyingHomology.arrow12 (Y := Y) a g hg n hn)
+  change (SelectedChainHomology.D2Iso n hn).hom.hom
+      ((HomologicalComplex.homologyMap (SelectedUnderlyingHomology.tensorMap (Y := Y) g) n).hom x) =
+    (HAction (Y := Y) (RelationBasisAction.arrow (SelectionEncoding.generator encoding) a)).hom
+      ((SelectedChainHomology.D1Iso n hn).hom.hom x) at h
+  exact (congrArg Subtype.val h).trans (HAction_val _ _)
+end LittleFinitistic.SelectedChainAction
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Selected/SelectedChainDiagram.lean b/lean/OAI/Algebra/Finitistic/Selected/SelectedChainDiagram.lean
new file mode 100644
index 0000000000000000000000000000000000000000..afc207b1bfda702b7010af07debf962947ce7956
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Selected/SelectedChainDiagram.lean
@@ -0,0 +1,70 @@
+import OAI.Algebra.Finitistic.Localization.ConcreteChainRepresentatives
+import OAI.Algebra.Finitistic.Selected.SelectedNativeAction
+
+namespace OAI
+noncomputable section
+open CategoryTheory
+namespace LittleFinitistic.SelectedChainDiagram
+open SelectedFixedDiagram RelationBasisCoefficients ConcreteChainRepresentatives
+
+abbrev D0 := representative P fixed.D0
+abbrev D1 := representative P fixed.D1
+abbrev D2 := representative P fixed.D2
+
+/-- Chain representatives and all specified relation homotopies for the one fixed diagram. -/
+structure Data where
+  f : Fin (encoding.generators+1) → (D0 ⟶ D1)
+  g : Fin (encoding.generators+1) → (D1 ⟶ D2)
+  f_quotient : ∀ a, (HomotopyCategory.quotient (SourceVerdier.Proj P) (.up ℤ)).map (f a) = (fixed.f a).hom
+  g_quotient : ∀ b, (HomotopyCategory.quotient (SourceVerdier.Proj P) (.up ℤ)).map (g b) = (fixed.g b).hom
+  homotopy : ∀ r : RelationIndex P,
+    Homotopy (∑ a, ∑ b, basisCoefficient P r a b • (f a ≫ g b)) 0
+
+/-- These choices, too, are made once before any evaluation module Y. -/
+def fixedChain : Data := Classical.choice (by
+  obtain ⟨f,g,hf,hg,⟨h⟩⟩ := quadratic_representatives P _ _ _
+    fixed.D0 fixed.D1 fixed.D2 fixed.f fixed.g (basisCoefficient P) fixed.relations
+  exact ⟨⟨f,g,hf,hg,h⟩⟩)
+
+theorem bounded : BoundedHomotopy.boundedComplex (SourceVerdier.Proj P) D0 ∧
+    BoundedHomotopy.boundedComplex (SourceVerdier.Proj P) D1 ∧
+    BoundedHomotopy.boundedComplex (SourceVerdier.Proj P) D2 :=
+  ⟨representative_bounded P fixed.D0,representative_bounded P fixed.D1,representative_bounded P fixed.D2⟩
+
+def fK (a : Fin (encoding.generators+1)) : fixed.D0 ⟶ fixed.D1 :=
+  ObjectProperty.homMk ((HomotopyCategory.quotient (SourceVerdier.Proj P) (.up ℤ)).map (fixedChain.f a))
+def gK (b : Fin (encoding.generators+1)) : fixed.D1 ⟶ fixed.D2 :=
+  ObjectProperty.homMk ((HomotopyCategory.quotient (SourceVerdier.Proj P) (.up ℤ)).map (fixedChain.g b))
+
+theorem fK_eq (a : Fin (encoding.generators+1)) : fK a = fixed.f a := by
+  apply ObjectProperty.hom_ext
+  exact fixedChain.f_quotient a
+
+theorem gK_eq (b : Fin (encoding.generators+1)) : gK b = fixed.g b := by
+  apply ObjectProperty.hom_ext
+  exact fixedChain.g_quotient b
+
+universe v
+variable {Y : Type v} [AddCommGroup Y] [Module ℂ Y] [FiniteDimensional ℂ Y]
+  [Module SelectionRing Y] [IsScalarTower ℂ SelectionRing Y]
+
+theorem evaluated_f (a : Fin (encoding.generators+1)) :
+    (SelectedDiagramEvaluation.sourceEvaluation (Y := Y)).map (fK a) ≫
+      (SelectedNativeEvaluation.D1Iso (Y := Y)).hom =
+    (SelectedNativeEvaluation.D0Iso (Y := Y)).hom ≫ SelectedNativeEvaluation.targetAction (Y := Y)
+      (RelationBasisAction.arrow (SelectionEncoding.generator encoding) a) := by
+  rw [fK_eq]
+  exact SelectedNativeEvaluation.D_arrow01 a
+
+theorem evaluated_g (b : Fin (encoding.generators+1)) :
+    (SelectedDiagramEvaluation.sourceEvaluation (Y := Y)).map (gK b) ≫
+      (SelectedNativeEvaluation.D2Iso (Y := Y)).hom =
+    (SelectedNativeEvaluation.D1Iso (Y := Y)).hom ≫ SelectedNativeEvaluation.targetAction (Y := Y)
+      (RelationBasisAction.arrow (SelectionEncoding.generator encoding) b) := by
+  rw [gK_eq]
+  exact SelectedNativeEvaluation.D_arrow12 b
+end LittleFinitistic.SelectedChainDiagram
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Selected/SelectedChainHomology.lean b/lean/OAI/Algebra/Finitistic/Selected/SelectedChainHomology.lean
new file mode 100644
index 0000000000000000000000000000000000000000..0f013f644cd183f2d14985b2decee7d447574d5b
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Selected/SelectedChainHomology.lean
@@ -0,0 +1,165 @@
+import OAI.Algebra.Finitistic.Selected.SelectedTargetHomology
+
+namespace OAI
+noncomputable section
+open CategoryTheory CategoryTheory.Limits
+attribute [local instance] HasDerivedCategory.standard
+namespace LittleFinitistic.SelectedChainHomology
+open QuadraticEncoding SelectedFixedDiagram SelectedNativeEvaluation SelectedTensorComparison
+open SelectedTargetHomology
+universe v
+variable {Y : Type v} [AddCommGroup Y] [Module ℂ Y] [FiniteDimensional ℂ Y]
+  [Module SelectionRing Y] [IsScalarTower ℂ SelectionRing Y]
+abbrev representation := SourceActionEvaluation.representation (Y := Y) encoding
+abbrev complex (D : SourceVerdier.K P) := tensor (representation (Y := Y)) D
+abbrev source := SelectedDiagramEvaluation.sourceEvaluation (Y := Y)
+
+def derivedIso (D : SourceVerdier.K P) :
+    DerivedCategory.Q.obj (complex (Y := Y) D) ≅ I.obj ((source (Y := Y)).obj D) :=
+  (DerivedCategory.quotientCompQhIso C).symm.app _ ≪≫
+    DerivedCategory.Qh.mapIso (finiteIso (representation (Y := Y)) D)
+
+def comparison (D : SourceVerdier.K P) (n : ℤ) :
+    (complex (Y := Y) D).homology n ≅ (cohomology n).obj ((source (Y := Y)).obj D) :=
+  (DerivedCategory.homologyFunctorFactors C n).symm.app _ ≪≫
+    (DerivedCategory.homologyFunctor C n).mapIso (derivedIso (Y := Y) D)
+
+lemma derived_map {D E : SourceVerdier.K P}
+    (f : ConcreteChainRepresentatives.representative P D ⟶
+      ConcreteChainRepresentatives.representative P E) (a : D ⟶ E)
+    (ha : (HomotopyCategory.quotient _ _).map f = a.hom) :
+    DerivedCategory.Q.map (tensorMap (representation (Y := Y)) f) ≫
+      (derivedIso (Y := Y) E).hom =
+        (derivedIso (Y := Y) D).hom ≫ I.map ((source (Y := Y)).map a) := by
+  have h := congrArg DerivedCategory.Qh.map (map_comparison (representation (Y := Y)) f a ha)
+  simp only [Functor.map_comp] at h
+  have hn := (DerivedCategory.quotientCompQhIso C).inv.naturality
+    (tensorMap (representation (Y := Y)) f)
+  exact DiagramEvaluationSquares.compose _ _ _
+    ((DerivedCategory.quotientCompQhIso C).symm.app (complex (Y := Y) D))
+    ((DerivedCategory.quotientCompQhIso C).symm.app (complex (Y := Y) E))
+    (DerivedCategory.Qh.mapIso (finiteIso (representation (Y := Y)) D))
+    (DerivedCategory.Qh.mapIso (finiteIso (representation (Y := Y)) E)) hn h
+
+lemma comparison_map {D E : SourceVerdier.K P}
+    (f : ConcreteChainRepresentatives.representative P D ⟶
+      ConcreteChainRepresentatives.representative P E) (a : D ⟶ E)
+    (ha : (HomotopyCategory.quotient _ _).map f = a.hom) (n : ℤ) :
+    HomologicalComplex.homologyMap (tensorMap (representation (Y := Y)) f) n ≫
+      (comparison (Y := Y) E n).hom =
+        (comparison (Y := Y) D n).hom ≫ (cohomology n).map ((source (Y := Y)).map a) := by
+  have h := congrArg (DerivedCategory.homologyFunctor C n).map (derived_map (Y := Y) f a ha)
+  simp only [Functor.map_comp] at h
+  have hn := (DerivedCategory.homologyFunctorFactors C n).inv.naturality
+    (tensorMap (representation (Y := Y)) f)
+  exact DiagramEvaluationSquares.compose _ _ _
+    ((DerivedCategory.homologyFunctorFactors C n).symm.app (complex (Y := Y) D))
+    ((DerivedCategory.homologyFunctorFactors C n).symm.app (complex (Y := Y) E))
+    ((DerivedCategory.homologyFunctor C n).mapIso (derivedIso (Y := Y) D))
+    ((DerivedCategory.homologyFunctor C n).mapIso (derivedIso (Y := Y) E)) hn h
+
+def modelIso (n : ℤ) (hn : n = 0 ∨ n = -3) :
+    (cohomology n).obj (target (Y := Y)) ≅ H (Y := Y) := by
+  by_cases h : n = 0
+  · subst n; exact targetH0
+  · have hm : n = -3 := hn.resolve_left h
+    subst n; exact targetHm3
+
+lemma model_action (n : ℤ) (hn : n = 0 ∨ n = -3) (r : SelectionRing) :
+    (cohomology n).map (targetAction (Y := Y) r) ≫ (modelIso (Y := Y) n hn).hom =
+      (modelIso (Y := Y) n hn).hom ≫ HAction (Y := Y) r := by
+  rcases hn with rfl | rfl
+  · exact targetH0_action r
+  · exact targetHm3_action r
+
+/-- Actual homology of a selected chain tensor, with its chosen target identification. -/
+def homologyIso (D : SourceVerdier.K P)
+    (e : (source (Y := Y)).obj D ≅ target (Y := Y))
+    (n : ℤ) (hn : n = 0 ∨ n = -3) : (complex (Y := Y) D).homology n ≅ H (Y := Y) :=
+  comparison D n ≪≫ (cohomology n).mapIso e ≪≫ modelIso n hn
+
+lemma homology_zero (D : SourceVerdier.K P)
+    (e : (source (Y := Y)).obj D ≅ target (Y := Y))
+    (n : ℤ) (h0 : n ≠ 0) (hm : n ≠ -3) : IsZero ((complex (Y := Y) D).homology n) :=
+  (comparison D n ≪≫ (cohomology n).mapIso e).isZero_iff.mpr (target_zero n h0 hm)
+
+lemma homology_arrow {D E : SourceVerdier.K P}
+    (f : ConcreteChainRepresentatives.representative P D ⟶
+      ConcreteChainRepresentatives.representative P E) (a : D ⟶ E)
+    (ha : (HomotopyCategory.quotient _ _).map f = a.hom)
+    (eD : (source (Y := Y)).obj D ≅ target (Y := Y))
+    (eE : (source (Y := Y)).obj E ≅ target (Y := Y)) (r : SelectionRing)
+    (hs : (source (Y := Y)).map a ≫ eE.hom = eD.hom ≫ targetAction (Y := Y) r)
+    (n : ℤ) (hn : n = 0 ∨ n = -3) :
+    HomologicalComplex.homologyMap (tensorMap (representation (Y := Y)) f) n ≫
+      (homologyIso E eE n hn).hom =
+        (homologyIso D eD n hn).hom ≫ HAction (Y := Y) r := by
+  have h := congrArg (cohomology n).map hs
+  simp only [Functor.map_comp] at h
+  exact DiagramEvaluationSquares.compose _ _ _
+    (comparison D n) (comparison E n)
+    ((cohomology n).mapIso eD ≪≫ modelIso n hn)
+    ((cohomology n).mapIso eE ≪≫ modelIso n hn)
+    (comparison_map f a ha n)
+    (DiagramEvaluationSquares.compose _ _ _ ((cohomology n).mapIso eD)
+      ((cohomology n).mapIso eE) (modelIso n hn) (modelIso n hn) h (model_action n hn r))
+
+/-- All three actual tensors have the primary H(Y) as homology in both selected degrees. -/
+def D0Iso (n : ℤ) (hn : n = 0 ∨ n = -3) :
+    (complex (Y := Y) fixed.D0).homology n ≅ H (Y := Y) :=
+  homologyIso _ SelectedNativeEvaluation.D0Iso n hn
+def D1Iso (n : ℤ) (hn : n = 0 ∨ n = -3) :
+    (complex (Y := Y) fixed.D1).homology n ≅ H (Y := Y) :=
+  homologyIso _ SelectedNativeEvaluation.D1Iso n hn
+def D2Iso (n : ℤ) (hn : n = 0 ∨ n = -3) :
+    (complex (Y := Y) fixed.D2).homology n ≅ H (Y := Y) :=
+  homologyIso _ SelectedNativeEvaluation.D2Iso n hn
+
+lemma D0_zero (n : ℤ) (h0 : n ≠ 0) (hm : n ≠ -3) :
+    IsZero ((complex (Y := Y) fixed.D0).homology n) :=
+  homology_zero _ SelectedNativeEvaluation.D0Iso n h0 hm
+lemma D1_zero (n : ℤ) (h0 : n ≠ 0) (hm : n ≠ -3) :
+    IsZero ((complex (Y := Y) fixed.D1).homology n) :=
+  homology_zero _ SelectedNativeEvaluation.D1Iso n h0 hm
+lemma D2_zero (n : ℤ) (h0 : n ≠ 0) (hm : n ≠ -3) :
+    IsZero ((complex (Y := Y) fixed.D2).homology n) :=
+  homology_zero _ SelectedNativeEvaluation.D2Iso n h0 hm
+
+/-- This applies to any chain representative of the same fixed first arrow. -/
+lemma arrow01 (a : Fin (encoding.generators+1))
+    (f : SelectedChainDiagram.D0 ⟶ SelectedChainDiagram.D1)
+    (hf : (HomotopyCategory.quotient _ _).map f = (fixed.f a).hom)
+    (n : ℤ) (hn : n = 0 ∨ n = -3) :
+    HomologicalComplex.homologyMap (tensorMap (representation (Y := Y)) f) n ≫ (D1Iso n hn).hom =
+      (D0Iso n hn).hom ≫ HAction (Y := Y)
+        (RelationBasisAction.arrow (SelectionEncoding.generator encoding) a) :=
+  homology_arrow f (fixed.f a) hf SelectedNativeEvaluation.D0Iso SelectedNativeEvaluation.D1Iso _
+    (SelectedNativeEvaluation.D_arrow01 a) n hn
+
+lemma arrow12 (a : Fin (encoding.generators+1))
+    (g : SelectedChainDiagram.D1 ⟶ SelectedChainDiagram.D2)
+    (hg : (HomotopyCategory.quotient _ _).map g = (fixed.g a).hom)
+    (n : ℤ) (hn : n = 0 ∨ n = -3) :
+    HomologicalComplex.homologyMap (tensorMap (representation (Y := Y)) g) n ≫ (D2Iso n hn).hom =
+      (D1Iso n hn).hom ≫ HAction (Y := Y)
+        (RelationBasisAction.arrow (SelectionEncoding.generator encoding) a) :=
+  homology_arrow g (fixed.g a) hg SelectedNativeEvaluation.D1Iso SelectedNativeEvaluation.D2Iso _
+    (SelectedNativeEvaluation.D_arrow12 a) n hn
+
+lemma fixed_arrow01 (a : Fin (encoding.generators+1)) (n : ℤ) (hn : n = 0 ∨ n = -3) :
+    HomologicalComplex.homologyMap
+      (tensorMap (representation (Y := Y)) (SelectedChainDiagram.fixedChain.f a)) n ≫ (D1Iso n hn).hom =
+      (D0Iso n hn).hom ≫ HAction (Y := Y)
+        (RelationBasisAction.arrow (SelectionEncoding.generator encoding) a) :=
+  arrow01 a _ (SelectedChainDiagram.fixedChain.f_quotient a) n hn
+lemma fixed_arrow12 (a : Fin (encoding.generators+1)) (n : ℤ) (hn : n = 0 ∨ n = -3) :
+    HomologicalComplex.homologyMap
+      (tensorMap (representation (Y := Y)) (SelectedChainDiagram.fixedChain.g a)) n ≫ (D2Iso n hn).hom =
+      (D1Iso n hn).hom ≫ HAction (Y := Y)
+        (RelationBasisAction.arrow (SelectionEncoding.generator encoding) a) :=
+  arrow12 a _ (SelectedChainDiagram.fixedChain.g_quotient a) n hn
+end LittleFinitistic.SelectedChainHomology
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Selected/SelectedCohomologyAssembly.lean b/lean/OAI/Algebra/Finitistic/Selected/SelectedCohomologyAssembly.lean
new file mode 100644
index 0000000000000000000000000000000000000000..a87ff0f8907af973404981c890469e569e0dcddb
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Selected/SelectedCohomologyAssembly.lean
@@ -0,0 +1,60 @@
+import OAI.Algebra.Finitistic.Selected.SelectedTensor
+import OAI.Algebra.Finitistic.Rectification.VertexCategoricalAssembly
+
+namespace OAI
+noncomputable section
+open CategoryTheory HomologicalComplex
+namespace LittleFinitistic.SelectedCohomologyAssembly
+open SelectedFixedDiagram SelectedRectification QuadraticEncoding
+section General
+variable {C : Type*} [Category C]
+variable {X0 X1 M0 M1 N0 N1 : C}
+lemma transfer_square (f : X0 ⟶ X1) (m : M0 ⟶ M1) (n : N0 ⟶ N1)
+    (c0 : X0 ≅ M0) (c1 : X1 ≅ M1) (e0 : X0 ≅ N0) (e1 : X1 ≅ N1)
+    (hc : f ≫ c1.hom = c0.hom ≫ m) (he : f ≫ e1.hom = e0.hom ≫ n) :
+    m ≫ (c1.symm ≪≫ e1).hom = (c0.symm ≪≫ e0).hom ≫ n := by
+  apply (cancel_epi c0.hom).1
+  dsimp only [Iso.trans_hom, Iso.symm_hom]
+  calc
+    c0.hom ≫ m ≫ c1.inv ≫ e1.hom = (c0.hom ≫ m) ≫ c1.inv ≫ e1.hom := by simp only [Category.assoc]
+    _ = (f ≫ c1.hom) ≫ c1.inv ≫ e1.hom := by rw [← hc]
+    _ = f ≫ e1.hom := by simp
+    _ = e0.hom ≫ n := he
+    _ = c0.hom ≫ (c0.inv ≫ e0.hom) ≫ n := by simp
+end General
+
+variable (N : Type) [AddCommGroup N] [Module ℂ N] [Module (B P) N]
+variable (n : ℤ) (R : ModuleCat (B P))
+variable (E : ∀ v : Fin 3, (SelectedTensor.source N v).homology n ≅
+  (LeftVertexHomology.vertex ℂ (B P) (ThreeVertexAlgebra.vertex (composition P) v)).obj R)
+
+/-- Convert an identified evaluated-representative cohomology diagram into the
+full cohomology B-module of the one fixed selecting tensor. Only the reference
+diagram identification is an input; the tensor vertex comparisons are proved. -/
+def iso
+    (h01 : ∀ a,
+      homologyMap (((BalancedTensor.tensorFunctor ℂ (B P) N).mapHomologicalComplex (.up ℤ)).map (f a)) n ≫
+        (E 1).hom = (E 0).hom ≫
+        (LeftVertexHomology.arrow ℂ (B P) (ThreeVertexAlgebra.vertex (composition P) 0)
+          (ThreeVertexAlgebra.vertex (composition P) 1) (arrow01 P a)
+          (CanonicalArrowCompatibility.arrow01_target P a)).app R)
+    (h12 : ∀ b,
+      homologyMap (((BalancedTensor.tensorFunctor ℂ (B P) N).mapHomologicalComplex (.up ℤ)).map (g b)) n ≫
+        (E 2).hom = (E 1).hom ≫
+        (LeftVertexHomology.arrow ℂ (B P) (ThreeVertexAlgebra.vertex (composition P) 1)
+          (ThreeVertexAlgebra.vertex (composition P) 2) (arrow12 P b)
+          (CanonicalArrowCompatibility.arrow12_target P b)).app R) :
+    (SelectedTensor.complex N).homology n ≅ R :=
+  VertexCategoricalAssembly.iso P _ R
+    (fun v => (SelectedTensor.comparisonIso N v n).symm ≪≫ E v)
+    (fun a => transfer_square _ _ _ (SelectedTensor.comparisonIso N 0 n)
+      (SelectedTensor.comparisonIso N 1 n) (E 0) (E 1)
+      (TensorCohomologyDiagram.arrow01_square P D0 D1 D2 f g relations N a n) (h01 a))
+    (fun b => transfer_square _ _ _ (SelectedTensor.comparisonIso N 1 n)
+      (SelectedTensor.comparisonIso N 2 n) (E 1) (E 2)
+      (TensorCohomologyDiagram.arrow12_square P D0 D1 D2 f g relations N b n) (h12 b))
+end LittleFinitistic.SelectedCohomologyAssembly
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Selected/SelectedCohomologyVanishing.lean b/lean/OAI/Algebra/Finitistic/Selected/SelectedCohomologyVanishing.lean
new file mode 100644
index 0000000000000000000000000000000000000000..7ddff94e59f7287c6deb6417458f6192e25d0f93
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Selected/SelectedCohomologyVanishing.lean
@@ -0,0 +1,42 @@
+import OAI.Algebra.Finitistic.Selected.SelectedCohomologyAssembly
+
+namespace OAI
+noncomputable section
+open CategoryTheory CategoryTheory.Limits
+namespace LittleFinitistic.SelectedCohomologyVanishing
+open QuadraticEncoding
+section General
+universe u
+variable {k : Type u} [Field k] {d t : ℕ} (P : Relations k d t)
+
+/-- The three actual vertex functors jointly detect a zero module. -/
+theorem module_isZero (M : ModuleCat.{u} (B P))
+    (h : ∀ i : Fin 3, IsZero
+      ((LeftVertexHomology.vertex k (B P) (ThreeVertexAlgebra.vertex (composition P) i)).obj M)) :
+    IsZero M := by
+  let M' := (ModuleCat.restrictScalars (algebraMap k (B P))).obj M
+  have (i : Fin 3) : Subsingleton
+      (VertexDecomposition.Space (EncodingModuleAssembly.system P) M' i) := by
+    let := ModuleCat.subsingleton_of_isZero (h i)
+    exact (LeftVertexHomology.spaceEquiv k (B P) (ThreeVertexAlgebra.vertex (composition P) i) M).symm.injective.subsingleton
+  have : Subsingleton M' := (VertexDecomposition.equiv (EncodingModuleAssembly.system P) M').injective.subsingleton
+  have : Subsingleton M := inferInstanceAs (Subsingleton M')
+  exact ModuleCat.isZero_of_subsingleton M
+end General
+
+open SelectedFixedDiagram
+variable (N : Type) [AddCommGroup N] [Module ℂ N] [Module (B P) N]
+
+/-- Vanishing on all three evaluated representatives gives actual cohomology
+vanishing of the fixed selecting tensor as a B-module. -/
+theorem cohomology_isZero (n : ℤ)
+    (h : ∀ v : Fin 3, IsZero ((SelectedTensor.source N v).homology n)) :
+    IsZero ((SelectedTensor.complex N).homology n) := by
+  apply module_isZero P
+  intro v
+  exact (SelectedTensor.comparisonIso N v n).isZero_iff.mp (h v)
+end LittleFinitistic.SelectedCohomologyVanishing
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Selected/SelectedCountCohomology.lean b/lean/OAI/Algebra/Finitistic/Selected/SelectedCountCohomology.lean
new file mode 100644
index 0000000000000000000000000000000000000000..6a3d6f04442c1739d02b20ad11467cf259aed754
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Selected/SelectedCountCohomology.lean
@@ -0,0 +1,73 @@
+import OAI.Algebra.Finitistic.Selected.SelectedFiniteAmplitude
+import OAI.Algebra.Finitistic.Bar.IntegerCountObject
+import OAI.Algebra.Finitistic.Iteration.BinomialVanishing
+
+namespace OAI
+noncomputable section
+open CategoryTheory CategoryTheory.Limits
+namespace LittleFinitistic.SelectedCountCohomology
+open SelectedOrdinaryAlgebra SelectedBaseIterates
+local instance : HasDerivedCategory.{1} (ModuleCat.{0} D) :=
+  HasDerivedCategory.standard (ModuleCat.{0} D)
+
+/-- The original summand with exactly r square-zero factors in the actual bar complex. -/
+abbrev count (Y : FiniteSelectionFamily.S.{0}) (r : ℕ) :=
+  DerivedBar.ParityBridge.countObject ℂ D X (input Y) r
+
+/-- Its exact standard integer-shift identification with the genuine derived iterate. -/
+def comparison (Y : FiniteSelectionFamily.S.{0}) (r : ℕ) :
+    (object Y r)⟦(r : ℤ)⟧ ≅ count Y r :=
+  DerivedBar.ParityBridge.countObjectComparison ℂ D X (input Y) r
+
+theorem isZero_iff (Y : FiniteSelectionFamily.S.{0}) (r : ℕ) :
+    IsZero (count Y r) ↔ IsZero (object Y r) :=
+  (comparison Y r).isZero_iff.symm.trans
+    (ExternalTensor.Binomial.isZero_shift_iff (object Y r) (r : ℤ))
+
+theorem bounded (Y : FiniteSelectionFamily.S.{0}) (r : ℕ) :
+    (count Y r).IsGE (-((r * (3 * length + 5) : ℕ) : ℤ)) ∧
+    (count Y r).IsLE (-(r : ℤ)) := by
+  have := (SelectedFiniteAmplitude.bounded Y r).1
+  have := (SelectedFiniteAmplitude.bounded Y r).2
+  have : ((object Y r)⟦(r : ℤ)⟧).IsGE (-((r * (3 * length + 5) : ℕ) : ℤ)) := by
+    apply DerivedCategory.TStructure.t.isGE_shift (object Y r)
+      (-((r * (3 * length + 4) : ℕ) : ℤ)) (r : ℤ)
+      (-((r * (3 * length + 5) : ℕ) : ℤ)) ?_
+    push_cast
+    ring
+  have : ((object Y r)⟦(r : ℤ)⟧).IsLE (-(r : ℤ)) :=
+    DerivedCategory.TStructure.t.isLE_shift (object Y r) 0 (r : ℤ) (-(r : ℤ)) (by omega)
+  exact ⟨DerivedCategory.TStructure.t.isGE_of_iso (comparison Y r) _,
+    DerivedCategory.TStructure.t.isLE_of_iso (comparison Y r) _⟩
+
+/-- Every surviving iterate contributes a nonzero original count class in a
+homological degree at least r, with an explicit finite upper bound. -/
+theorem nonzero_degree (Y : FiniteSelectionFamily.S.{0}) (r : ℕ)
+    (h : ¬ IsZero (object Y r)) :
+    ∃ n : ℕ, r ≤ n ∧ n ≤ r * (3 * length + 5) ∧
+      ¬ IsZero ((DerivedCategory.homologyFunctor (ModuleCat D) (-(n : ℤ))).obj (count Y r)) := by
+  have := (bounded Y r).1
+  have := (bounded Y r).2
+  by_contra hn
+  push Not at hn
+  have hz (i : ℤ) : IsZero ((DerivedCategory.homologyFunctor (ModuleCat D) i).obj (count Y r)) := by
+    by_cases hi : i ≤ 0
+    · obtain ⟨n,rfl⟩ := Int.exists_eq_neg_ofNat hi
+      by_cases hlo : r ≤ n
+      · by_cases hhi : n ≤ r * (3 * length + 5)
+        · exact hn n hlo hhi
+        · exact DerivedCategory.isZero_of_isGE _ (-((r * (3 * length + 5) : ℕ) : ℤ))
+            (-(n : ℤ)) (by omega)
+      · exact DerivedCategory.isZero_of_isLE _ (-(r : ℤ)) (-(n : ℤ)) (by omega)
+    · exact DerivedCategory.isZero_of_isLE _ (-(r : ℤ)) i (by omega)
+  have : (count Y r).IsLE (-1) := (DerivedCategory.isLE_iff _ _).mpr (fun i _ => hz i)
+  have : (count Y r).IsGE 0 := (DerivedCategory.isGE_iff _ _).mpr (fun i _ => hz i)
+  apply h
+  apply (isZero_iff Y r).mp
+  apply (IsZero.iff_id_eq_zero _).mpr
+  exact DerivedCategory.TStructure.t.zero (𝟙 _) (-1) 0 (by omega)
+end LittleFinitistic.SelectedCountCohomology
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Selected/SelectedCountExtinction.lean b/lean/OAI/Algebra/Finitistic/Selected/SelectedCountExtinction.lean
new file mode 100644
index 0000000000000000000000000000000000000000..797facc3243885468c0bca9197d9bdd2d323444d
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Selected/SelectedCountExtinction.lean
@@ -0,0 +1,49 @@
+import OAI.Algebra.Finitistic.Selected.SelectedCountCohomology
+import OAI.Algebra.Finitistic.Iteration.IntegerIterateExtinction
+
+namespace OAI
+noncomputable section
+open CategoryTheory CategoryTheory.Limits
+namespace LittleFinitistic.SelectedCountExtinction
+open SelectedOrdinaryAlgebra SelectedBaseIterates SelectedCountCohomology
+local instance : HasDerivedCategory.{1} (ModuleCat.{0} D) :=
+  HasDerivedCategory.standard (ModuleCat.{0} D)
+
+/-- After actual tensor extinction, all later original count summands vanish. -/
+theorem tail_zero (Y : FiniteSelectionFamily.S.{0}) (t r : ℕ) (htr : t ≤ r)
+    (h : IsZero (object Y t)) : IsZero (count Y r) :=
+  (SelectedCountCohomology.isZero_iff Y r).mpr
+    (DerivedBar.IterateSupport.zero_of_le ℂ D X (input Y) t r htr h)
+
+/-- A zero iterate gives one finite cohomological window for the entire original
+count family, including the infinitely many counts that have already vanished. -/
+theorem uniform_bounded (Y : FiniteSelectionFamily.S.{0}) (t : ℕ)
+    (h : IsZero (object Y t)) (r : ℕ) :
+    (count Y r).IsGE (-((t * (3 * length + 5) : ℕ) : ℤ)) ∧ (count Y r).IsLE 0 := by
+  have := (SelectedCountCohomology.bounded Y r).1
+  have := (SelectedCountCohomology.bounded Y r).2
+  constructor
+  · by_cases htr : t ≤ r
+    · apply (DerivedCategory.isGE_iff _ _).mpr
+      intro i _
+      exact (DerivedCategory.homologyFunctor (ModuleCat D) i).map_isZero (tail_zero Y t r htr h)
+    · apply DerivedCategory.TStructure.t.isGE_of_ge (count Y r)
+        (-((t * (3 * length + 5) : ℕ) : ℤ)) (-((r * (3 * length + 5) : ℕ) : ℤ)) ?_
+      have hm := Nat.mul_le_mul_right (3 * length + 5) (show r ≤ t by omega)
+      exact neg_le_neg (by exact_mod_cast hm)
+  · exact DerivedCategory.TStructure.t.isLE_of_le (count Y r) (-(r : ℤ)) 0 (by omega)
+
+/-- Every original count has zero cohomology outside that single finite window. -/
+theorem uniform_homology_zero (Y : FiniteSelectionFamily.S.{0}) (t : ℕ)
+    (h : IsZero (object Y t)) (r : ℕ) (i : ℤ)
+    (hi : i < -((t * (3 * length + 5) : ℕ) : ℤ) ∨ 0 < i) :
+    IsZero ((DerivedCategory.homologyFunctor (ModuleCat D) i).obj (count Y r)) := by
+  have := (uniform_bounded Y t h r).1
+  have := (uniform_bounded Y t h r).2
+  exact hi.elim (fun h => DerivedCategory.isZero_of_isGE _ _ i h)
+    (fun h => DerivedCategory.isZero_of_isLE _ 0 i h)
+end LittleFinitistic.SelectedCountExtinction
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Selected/SelectedCountPDConsumer.lean b/lean/OAI/Algebra/Finitistic/Selected/SelectedCountPDConsumer.lean
new file mode 100644
index 0000000000000000000000000000000000000000..8815de5726ba4b153bc5d3ebf8d8a3c8cfb5c851
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Selected/SelectedCountPDConsumer.lean
@@ -0,0 +1,28 @@
+import OAI.Algebra.Finitistic.Selected.SelectedPDBarConsumer
+import OAI.Algebra.Finitistic.Selected.SelectedPDResidueProjection
+import OAI.Algebra.Finitistic.Selected.SelectedCountCohomology
+
+namespace OAI
+noncomputable section
+open CategoryTheory CategoryTheory.Limits
+namespace LittleFinitistic.SelectedPDDetection
+open SelectedOrdinaryAlgebra SelectedOrdinaryModules
+local instance : HasDerivedCategory.{1} (ModuleCat.{0} D) :=
+  HasDerivedCategory.standard (ModuleCat.{0} D)
+
+/-- A supplied inclusion/retraction of the original count summand into the
+actual full bar converts native iterate survival directly into the pd bound.
+Native supplies the proved nonzero degree; no shift/amplitude proof is duplicated. -/
+theorem lower_bound_of_surviving_count (Y : FiniteSelectionFamily.S.{0}) (r : ℕ)
+    (h : ¬ IsZero (SelectedBaseIterates.object Y r))
+    (i : SelectedCountCohomology.count Y r ⟶ PDBarQuotient.baseDerived augmentation (Inflated Y))
+    (p : PDBarQuotient.baseDerived augmentation (Inflated Y) ⟶ SelectedCountCohomology.count Y r)
+    (hip : i ≫ p = 𝟙 (SelectedCountCohomology.count Y r)) :
+    r ≤ projectiveDimension (module Y) := by
+  obtain ⟨n,hrn,_,hn⟩ := SelectedCountCohomology.nonzero_degree Y r h
+  exact lower_bound_of_base_derived_bar Y _ _ (Iso.refl _) i p hip r n hrn hn
+end LittleFinitistic.SelectedPDDetection
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Selected/SelectedDerivedFunctor.lean b/lean/OAI/Algebra/Finitistic/Selected/SelectedDerivedFunctor.lean
new file mode 100644
index 0000000000000000000000000000000000000000..a8e94adce87f0ffe186ac04f99325ba106326c5d
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Selected/SelectedDerivedFunctor.lean
@@ -0,0 +1,45 @@
+import OAI.Algebra.Finitistic.Localization.NativeSingleEvaluation
+import OAI.Algebra.Finitistic.Selected.SelectedWindow
+import OAI.Algebra.Finitistic.Selected.SelectedIteration
+
+namespace OAI
+noncomputable section
+open CategoryTheory CategoryTheory.Limits
+attribute [local instance] HasDerivedCategory.standard HasExt.standard
+namespace LittleFinitistic.SelectedDerivedFunctor
+open SelectedFixedDiagram QuadraticEncoding FiniteSelectionFamily
+
+/-- One fixed genuine derived tensor functor, chosen before any test module. -/
+def model : BimoduleTotal.BoundedProjective ℂ (B P) SelectedRectification.bimodule :=
+  BimoduleTotal.nativeProjectiveModel SelectedRectification.bimodule
+    (SelectedWindow.lo-2) SelectedWindow.hi SelectedWindow.bounded SelectedWindow.verified.projective
+
+abbrev Phi := model.derived
+
+/-- The previously explicit stalk-comparison premise is now discharged for the
+actual fixed selecting bimodule and its actual derived tensor endofunctor. -/
+def comparison (Y : S.{0}) : Phi.obj (derived Y) ≅
+    SelectedTensorSplitting.object (representation Y).Evaluation :=
+  model.nativeSingleEvaluation (representation Y).Evaluation
+
+/-- The actual full B-linear binomial formula for the genuine tensor functor. -/
+def iteration (j : ℕ) (Y : S.{0}) :
+    (Phi.obj^[j]) (derived Y) ≅
+      ⨁ fun q : Fin (j+1) => ⨁ fun _ : Fin (Nat.choose j q.val) =>
+        (derived ((H^[j]) Y))⟦(3 : ℤ)*(q.val : ℤ)⟧ :=
+  SelectedIteration.iteration Phi comparison j Y
+
+theorem isZero_iff (j : ℕ) (Y : S.{0}) :
+    IsZero ((Phi.obj^[j]) (derived Y)) ↔ Subsingleton (selectionIterate Y.val j) :=
+  SelectedIteration.isZero_iff Phi comparison j Y
+
+/-- Exact arbitrarily long finite extinction for one fixed actual tensor functor. -/
+theorem extinction (m : ℕ) [NeZero m] :
+    (∀ j < m, ¬ IsZero ((Phi.obj^[j]) (derived (test m)))) ∧
+      IsZero ((Phi.obj^[m]) (derived (test m))) :=
+  SelectedIteration.extinction Phi comparison m
+end LittleFinitistic.SelectedDerivedFunctor
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Selected/SelectedDiagramEvaluation.lean b/lean/OAI/Algebra/Finitistic/Selected/SelectedDiagramEvaluation.lean
new file mode 100644
index 0000000000000000000000000000000000000000..7979b0e2ce838aacb03bd749185831f6faba1c10
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Selected/SelectedDiagramEvaluation.lean
@@ -0,0 +1,127 @@
+import OAI.Algebra.Finitistic.Selected.SelectedFixedDiagram
+import OAI.Algebra.Finitistic.Localization.SourceOddDoubleEvaluation
+import OAI.Algebra.Finitistic.Localization.DiagramEvaluationSquares
+
+namespace OAI
+noncomputable section
+open CategoryTheory CategoryTheory.Limits CategoryTheory.Idempotents
+attribute [local instance] HasDerivedCategory.standard
+namespace LittleFinitistic.SelectedDiagramEvaluation
+open QuadraticEncoding SelectedFixedDiagram SourceImageEvaluation
+universe v
+variable {Y : Type v} [AddCommGroup Y] [Module ℂ Y] [FiniteDimensional ℂ Y]
+  [Module SelectionRing Y] [IsScalarTower ℂ SelectionRing Y]
+
+abbrev F := SourceImageEvaluation.evaluation (Y := Y) encoding
+abbrev G := completed (Y := Y) encoding
+abbrev target := imageDerived (k := ℂ) (Y := Y) e ⊞ (imageDerived (k := ℂ) (Y := Y) e)⟦(3 : ℤ)⟧
+def targetAction (r : SelectionRing) : target (Y := Y) ⟶ target (Y := Y) :=
+  biprod.map (imageCorner (k := ℂ) (Y := Y) e (alpha r)) ((imageCorner (k := ℂ) (Y := Y) e (alpha r))⟦(3 : ℤ)⟧')
+
+/-- Evaluation of the one fixed actual V0 is precisely eY direct-sum eY[3]. -/
+def V0Iso : (F (Y := Y)).obj fixed.V0 ≅ target (Y := Y) :=
+  (factors (Y := Y) encoding).symm.app fixed.V0 ≪≫
+    ((G (Y := Y)).mapIso fixed.iso ≪≫ oddDoubleImageIso (Y := Y) encoding e idem)
+
+/-- The V0 identification intertwines every selected algebra element on both summands. -/
+theorem V0_action (r : SelectionRing) :
+    (F (Y := Y)).map (fixed.rho r) ≫ (V0Iso (Y := Y)).hom =
+      (V0Iso (Y := Y)).hom ≫ targetAction (Y := Y) r := by
+  have hf := (factors (Y := Y) encoding).inv.naturality (fixed.rho r)
+  have hi := congrArg (fun f => (G (Y := Y)).map f) (fixed.equivariant r)
+  simp only [Functor.map_comp] at hi
+  have ho := oddDouble_selecting_square (Y := Y) encoding e idem central alpha r
+  exact DiagramEvaluationSquares.compose _ _ _
+    ((factors (Y := Y) encoding).symm.app fixed.V0)
+    ((factors (Y := Y) encoding).symm.app fixed.V0)
+    ((G (Y := Y)).mapIso fixed.iso ≪≫ oddDoubleImageIso (Y := Y) encoding e idem)
+    ((G (Y := Y)).mapIso fixed.iso ≪≫ oddDoubleImageIso (Y := Y) encoding e idem)
+    hf (DiagramEvaluationSquares.compose _ _ _
+      ((G (Y := Y)).mapIso fixed.iso) ((G (Y := Y)).mapIso fixed.iso)
+      (oddDoubleImageIso (Y := Y) encoding e idem) (oddDoubleImageIso (Y := Y) encoding e idem)
+      hi ho)
+
+abbrev sourceEvaluation := SourceEvaluation.finite
+  (SourceActionEvaluation.representation (Y := Y) encoding) ⋙ (FiniteProjectiveHomotopy.derivedEmbedding ℂ).toEssImage
+
+def sourceFactors : SourceVerdier.q P ⋙ F (Y := Y) ≅ sourceEvaluation (Y := Y) :=
+  (Functor.associator _ _ _).symm ≪≫ Functor.isoWhiskerRight
+    (SourceEvaluation.finiteFactors (SourceActionEvaluation.representation (Y := Y) encoding))
+    (FiniteProjectiveHomotopy.derivedEmbedding ℂ).toEssImage
+
+def D0Iso : (sourceEvaluation (Y := Y)).obj fixed.D0 ≅ target (Y := Y) :=
+  (sourceFactors (Y := Y)).symm.app fixed.D0 ≪≫ ((F (Y := Y)).mapIso fixed.phi0 ≪≫ V0Iso (Y := Y))
+def D1Iso : (sourceEvaluation (Y := Y)).obj fixed.D1 ≅ target (Y := Y) :=
+  (sourceFactors (Y := Y)).symm.app fixed.D1 ≪≫ ((F (Y := Y)).mapIso fixed.phi1 ≪≫ V0Iso (Y := Y))
+def D2Iso : (sourceEvaluation (Y := Y)).obj fixed.D2 ≅ target (Y := Y) :=
+  (sourceFactors (Y := Y)).symm.app fixed.D2 ≪≫ ((F (Y := Y)).mapIso fixed.phi2 ≪≫ V0Iso (Y := Y))
+
+/-- Every first-family arrow of the same fixed K diagram has its selected action. -/
+theorem D_arrow01 (a : Fin (encoding.generators+1)) :
+    (sourceEvaluation (Y := Y)).map (fixed.f a) ≫ (D1Iso (Y := Y)).hom =
+      (D0Iso (Y := Y)).hom ≫ targetAction (Y := Y)
+        (RelationBasisAction.arrow (SelectionEncoding.generator encoding) a) := by
+  have hn := (sourceFactors (Y := Y)).inv.naturality (fixed.f a)
+  have hp := congrArg (fun f => (F (Y := Y)).map f) (fixed.arrow01 a)
+  simp only [Functor.map_comp] at hp
+  exact DiagramEvaluationSquares.compose _ _ _
+    ((sourceFactors (Y := Y)).symm.app fixed.D0) ((sourceFactors (Y := Y)).symm.app fixed.D1)
+    ((F (Y := Y)).mapIso fixed.phi0 ≪≫ V0Iso (Y := Y))
+    ((F (Y := Y)).mapIso fixed.phi1 ≪≫ V0Iso (Y := Y)) hn
+    (DiagramEvaluationSquares.compose _ _ _
+      ((F (Y := Y)).mapIso fixed.phi0) ((F (Y := Y)).mapIso fixed.phi1)
+      (V0Iso (Y := Y)) (V0Iso (Y := Y)) hp (V0_action _))
+
+theorem D_arrow12 (a : Fin (encoding.generators+1)) :
+    (sourceEvaluation (Y := Y)).map (fixed.g a) ≫ (D2Iso (Y := Y)).hom =
+      (D1Iso (Y := Y)).hom ≫ targetAction (Y := Y)
+        (RelationBasisAction.arrow (SelectionEncoding.generator encoding) a) := by
+  have hn := (sourceFactors (Y := Y)).inv.naturality (fixed.g a)
+  have hp := congrArg (fun f => (F (Y := Y)).map f) (fixed.arrow12 a)
+  simp only [Functor.map_comp] at hp
+  exact DiagramEvaluationSquares.compose _ _ _
+    ((sourceFactors (Y := Y)).symm.app fixed.D1) ((sourceFactors (Y := Y)).symm.app fixed.D2)
+    ((F (Y := Y)).mapIso fixed.phi1 ≪≫ V0Iso (Y := Y))
+    ((F (Y := Y)).mapIso fixed.phi2 ≪≫ V0Iso (Y := Y)) hn
+    (DiagramEvaluationSquares.compose _ _ _
+      ((F (Y := Y)).mapIso fixed.phi1) ((F (Y := Y)).mapIso fixed.phi2)
+      (V0Iso (Y := Y)) (V0Iso (Y := Y)) hp (V0_action _))
+
+theorem targetAction_one : targetAction (Y := Y) (1 : SelectionRing) = 𝟙 _ := by
+  apply (cancel_epi (V0Iso (Y := Y)).hom).mp
+  rw [← V0_action,map_one]
+  change (F (Y := Y)).map (𝟙 fixed.V0) ≫ _ = _
+  rw [CategoryTheory.Functor.map_id,Category.id_comp,Category.comp_id]
+
+theorem distinguished_arrow01 :
+    (sourceEvaluation (Y := Y)).map (fixed.f 0) ≫ (D1Iso (Y := Y)).hom = (D0Iso (Y := Y)).hom := by
+  have h := D_arrow01 (Y := Y) 0
+  simpa only [RelationBasisAction.arrow,Fin.cases_zero,targetAction_one,Category.comp_id] using h
+
+theorem distinguished_arrow12 :
+    (sourceEvaluation (Y := Y)).map (fixed.g 0) ≫ (D2Iso (Y := Y)).hom = (D1Iso (Y := Y)).hom := by
+  have h := D_arrow12 (Y := Y) 0
+  simpa only [RelationBasisAction.arrow,Fin.cases_zero,targetAction_one,Category.comp_id] using h
+
+/-- The same globally chosen K diagram evaluates correctly for every finite module. -/
+theorem fixed_diagram_evaluates :
+    ∃ (i0 : (sourceEvaluation (Y := Y)).obj fixed.D0 ≅ target (Y := Y))
+      (i1 : (sourceEvaluation (Y := Y)).obj fixed.D1 ≅ target (Y := Y))
+      (i2 : (sourceEvaluation (Y := Y)).obj fixed.D2 ≅ target (Y := Y)),
+      (∀ a, (sourceEvaluation (Y := Y)).map (fixed.f a) ≫ i1.hom =
+        i0.hom ≫ targetAction (Y := Y) (RelationBasisAction.arrow (SelectionEncoding.generator encoding) a)) ∧
+      (∀ b, (sourceEvaluation (Y := Y)).map (fixed.g b) ≫ i2.hom =
+        i1.hom ≫ targetAction (Y := Y) (RelationBasisAction.arrow (SelectionEncoding.generator encoding) b)) :=
+  ⟨D0Iso,D1Iso,D2Iso,D_arrow01,D_arrow12⟩
+
+omit [FiniteDimensional ℂ Y] in
+/-- Exact vector formula for the selected action, including the alpha restriction. -/
+theorem targetAction_on_image (r : SelectionRing) (y : imageSpace (k := ℂ) (Y := Y) e) :
+    ((imageCornerEnd (action (k := ℂ) (Y := Y) e).hom (action (k := ℂ) (Y := Y) (alpha r)).hom) y).val =
+      (action (k := ℂ) (Y := Y) (alpha r)).hom y.val :=
+  imageCorner_restriction e (alpha r) idem (central (alpha r)) y
+end LittleFinitistic.SelectedDiagramEvaluation
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Selected/SelectedFiniteAmplitude.lean b/lean/OAI/Algebra/Finitistic/Selected/SelectedFiniteAmplitude.lean
new file mode 100644
index 0000000000000000000000000000000000000000..30773eaf87282814da30d31a42a443e437e880c3
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Selected/SelectedFiniteAmplitude.lean
@@ -0,0 +1,46 @@
+import OAI.Algebra.Finitistic.Selected.SelectedBaseIterates
+import OAI.Algebra.Finitistic.Selected.SelectedOrdinaryDimension
+
+namespace OAI
+noncomputable section
+open CategoryTheory
+namespace LittleFinitistic.SelectedFiniteAmplitude
+open SelectedOrdinaryAlgebra SelectedBaseIterates
+local instance : HasDerivedCategory.{1} (ModuleCat.{0} D) :=
+  HasDerivedCategory.standard (ModuleCat.{0} D)
+
+/-- Every genuine X-derived iterate of each actual test input has finite amplitude.
+The extra two degrees per iteration are harmless for the finite-dimension argument. -/
+theorem bounded (Y : FiniteSelectionFamily.S.{0}) (r : ℕ) :
+    (object Y r).IsGE (-((r * (3 * length + 4) : ℕ) : ℤ)) ∧
+    (object Y r).IsLE 0 := by
+  simpa only [SelectedOrdinaryDimension.bound, Nat.add_assoc] using
+    SelectedBaseIterates.bounded SelectedOrdinaryDimension.bound
+      SelectedOrdinaryDimension.left_module Y r
+
+/-- A nonzero actual iterate is detected in a finite, explicit cohomological window. -/
+theorem nonzero_in_window (Y : FiniteSelectionFamily.S.{0}) (r : ℕ)
+    (h : ¬ Limits.IsZero (object Y r)) :
+    ∃ n : ℕ, n ≤ r * (3 * length + 4) ∧
+      ¬ Limits.IsZero ((DerivedCategory.homologyFunctor (ModuleCat D) (-(n : ℤ))).obj
+        (object Y r)) := by
+  simpa only [SelectedOrdinaryDimension.bound, Nat.add_assoc] using
+    DerivedBar.IterateSupport.nonzero_in_finite_window ℂ D
+      SelectedOrdinaryDimension.bound SelectedOrdinaryDimension.left_module X (input Y) r h
+
+/-- Any additive terminal tensor applied to a resolved actual iterate has a
+uniform finite homological bound. This supplies the later residue/simple tests. -/
+theorem terminal_exact {E : Type*} [Category E] [Abelian E]
+    (F : ModuleCat.{0} D ⥤ E) [F.Additive]
+    (Y : FiniteSelectionFamily.S.{0}) (r n : ℕ)
+    (hn : (r+1) * (3 * length + 4) < n) :
+    ((F.mapHomologicalComplex (.down ℕ)).obj
+      (DerivedBar.barTotal ℂ D (DerivedBar.IterateSupport.resolvedModel ℂ D X (input Y) r))).ExactAt n := by
+  apply DerivedBar.IterateSupport.iterated_additive_exact_above ℂ D F
+    SelectedOrdinaryDimension.bound SelectedOrdinaryDimension.left_module X (input Y) r n
+  simpa only [SelectedOrdinaryDimension.bound, Nat.add_assoc] using hn
+end LittleFinitistic.SelectedFiniteAmplitude
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Selected/SelectedFiniteTensorEvaluation.lean b/lean/OAI/Algebra/Finitistic/Selected/SelectedFiniteTensorEvaluation.lean
new file mode 100644
index 0000000000000000000000000000000000000000..0765b17b80ccc6d3f7bfbc239ddbd1d805831ab0
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Selected/SelectedFiniteTensorEvaluation.lean
@@ -0,0 +1,41 @@
+import OAI.Algebra.Finitistic.Localization.HomotopyEvaluation
+import Mathlib.RingTheory.TensorProduct.Finite
+import Mathlib.LinearAlgebra.FiniteDimensional.Basic
+
+namespace OAI
+noncomputable section
+open CategoryTheory CategoryTheory.Limits
+namespace LittleFinitistic.BalancedTensor
+universe u v w z
+variable {k : Type u} [Field k] {A : Type v} [Ring A] [Algebra k A]
+variable (N : Type z) [AddCommGroup N] [Module k N] [Module A N]
+
+instance tensorFinite (M : Type w) [AddCommGroup M] [Module k M] [Module Aᵐᵒᵖ M]
+    [FiniteDimensional k M] [FiniteDimensional k N] : FiniteDimensional k (Tensor k A M N) := by
+  unfold Tensor
+  infer_instance
+
+theorem tensorFunctor_finite [FiniteDimensional k Aᵐᵒᵖ] [FiniteDimensional k N]
+    (M : ModuleCat.{w} Aᵐᵒᵖ) [Module.Finite Aᵐᵒᵖ M] :
+    FiniteDimensional k ((tensorFunctor k A N).obj M) := by
+  let : Module.Finite Aᵐᵒᵖ (ScalarModule k A M) := inferInstanceAs (Module.Finite Aᵐᵒᵖ M)
+  let : Module.Finite k (ScalarModule k A M) := Module.Finite.trans Aᵐᵒᵖ (ScalarModule k A M)
+  exact inferInstanceAs (FiniteDimensional k (Tensor k A (ScalarModule k A M) N))
+
+/-- The termwise evaluation preserves every actual zero term, hence bounded support. -/
+theorem complex_zero (K : CochainComplex (ModuleCat.{w} Aᵐᵒᵖ) ℤ) (i : ℤ)
+    (h : IsZero (K.X i)) :
+    IsZero (((tensorFunctor k A N).mapHomologicalComplex (ComplexShape.up ℤ)).obj K |>.X i) :=
+  (tensorFunctor k A N).map_isZero h
+
+/-- A bounded input has a bounded output with the same interval of possible nonzero terms. -/
+theorem bounded_support (K : CochainComplex (ModuleCat.{w} Aᵐᵒᵖ) ℤ) (a b : ℤ)
+    (h : ∀ i, i < a ∨ b < i → IsZero (K.X i)) :
+    ∀ i, i < a ∨ b < i →
+      IsZero (((tensorFunctor k A N).mapHomologicalComplex (ComplexShape.up ℤ)).obj K |>.X i) :=
+  fun i hi => complex_zero N K i (h i hi)
+end LittleFinitistic.BalancedTensor
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Selected/SelectedFirstBlockFamily.lean b/lean/OAI/Algebra/Finitistic/Selected/SelectedFirstBlockFamily.lean
new file mode 100644
index 0000000000000000000000000000000000000000..a895f4334d415129752d0ebe684821da213299f7
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Selected/SelectedFirstBlockFamily.lean
@@ -0,0 +1,80 @@
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryRestrictionHomology
+import Mathlib.Algebra.Homology.ShortComplex.ExactFunctor
+import OAI.Algebra.Finitistic.Selected.SelectedBaseIterates
+import OAI.Algebra.Finitistic.Selected.SelectedDerivedFunctor
+import Mathlib.Algebra.Homology.DerivedCategory.ExactFunctor
+
+namespace OAI
+noncomputable section
+open CategoryTheory CategoryTheory.Limits
+namespace LittleFinitistic.SelectedFirstBlockFamily
+attribute [local instance] preservesBinaryBiproducts_of_preservesBiproducts
+open SelectedOrdinaryAlgebra SelectedFixedDiagram QuadraticEncoding
+local instance : HasDerivedCategory.{1} (ModuleCat.{0} (B P)) :=
+  HasDerivedCategory.standard (ModuleCat.{0} (B P))
+local instance : HasDerivedCategory.{1} (ModuleCat.{0} D) :=
+  HasDerivedCategory.standard (ModuleCat.{0} D)
+
+/-- The actual exact inflation functor from B-modules to the first D-block. -/
+abbrev inflation : ModuleCat.{0} (B P) ⥤ ModuleCat.{0} D := ModuleCat.restrictScalars SelectedOrdinaryModules.firstProjection
+instance inflation_preservesFiniteLimits : PreservesFiniteLimits inflation := by
+  have h : PreservesFiniteLimits inflation ∧ PreservesFiniteColimits inflation :=
+    ((Functor.exact_tfae inflation).out 2 4).mp
+      (RestrictionHomology.mapsExact SelectedOrdinaryModules.firstProjection)
+  exact h.1
+instance inflation_preservesFiniteColimits : PreservesFiniteColimits inflation := by
+  have h : PreservesFiniteLimits inflation ∧ PreservesFiniteColimits inflation :=
+    ((Functor.exact_tfae inflation).out 2 4).mp
+      (RestrictionHomology.mapsExact SelectedOrdinaryModules.firstProjection)
+  exact h.2
+abbrev derivedInflation := inflation.mapDerivedCategory
+
+instance derivedInflation_additive : derivedInflation.Additive := by
+  rw [Localization.functor_additive_iff DerivedCategory.Qh
+    (HomotopyCategory.subcategoryAcyclic (ModuleCat.{0} (B P))).trW]
+  exact Functor.additive_of_iso inflation.mapDerivedCategoryFactorsh.symm
+
+/-- This is the original selected input, with precisely its constructed D-action. -/
+def moduleIso (Y : FiniteSelectionFamily.S.{0}) :
+    inflation.obj (FiniteSelectionFamily.module Y) ≅ SelectedBaseIterates.input Y :=
+  Iso.refl _
+
+abbrev derived (Y : FiniteSelectionFamily.S.{0}) :=
+  (DerivedCategory.singleFunctor (ModuleCat D) 0).obj (SelectedBaseIterates.input Y)
+
+/-- Exact inflation on derived categories agrees with the selected first-block stalk. -/
+def stalkIso (Y : FiniteSelectionFamily.S.{0}) :
+    derivedInflation.obj (FiniteSelectionFamily.derived Y) ≅ derived Y :=
+  (inflation.mapDerivedCategorySingleFunctor 0).app (FiniteSelectionFamily.module Y) ≪≫
+    (DerivedCategory.singleFunctor (ModuleCat D) 0).mapIso (moduleIso Y)
+
+theorem module_zero (Y : FiniteSelectionFamily.S.{0}) :
+    IsZero (SelectedBaseIterates.input Y) ↔ Subsingleton Y.val := by
+  rw [← FiniteSelectionFamily.module_zero Y]
+  rw [ModuleCat.isZero_iff_subsingleton, ModuleCat.isZero_iff_subsingleton]
+  rfl
+
+theorem derived_zero (Y : FiniteSelectionFamily.S.{0}) :
+    IsZero (derived Y) ↔ Subsingleton Y.val := by
+  rw [← module_zero Y]
+  constructor
+  · intro h
+    exact ((DerivedCategory.singleFunctorCompHomologyFunctorIso (ModuleCat D) 0).app
+      (SelectedBaseIterates.input Y)).isZero_iff.mp
+        ((DerivedCategory.homologyFunctor (ModuleCat D) 0).map_isZero h)
+  · exact (DerivedCategory.singleFunctor (ModuleCat D) 0).map_isZero
+
+/-- The already proved Phi realization, transported by the actual first-block
+inflation, with no ordinary F² identity assumed or asserted. -/
+def inflated_realization (Y : FiniteSelectionFamily.S.{0}) :
+    derivedInflation.obj (SelectedDerivedFunctor.Phi.obj (FiniteSelectionFamily.derived Y)) ≅
+      derived (FiniteSelectionFamily.H Y) ⊞ (derived (FiniteSelectionFamily.H Y))⟦(3 : ℤ)⟧ :=
+  derivedInflation.mapIso (SelectedDerivedFunctor.comparison Y ≪≫ FiniteSelectionFamily.realization Y) ≪≫
+    derivedInflation.mapBiprod _ _ ≪≫
+      biprod.mapIso (stalkIso _) ((derivedInflation.commShiftIso (3 : ℤ)).app _ ≪≫
+        (shiftFunctor _ (3 : ℤ)).mapIso (stalkIso _))
+end LittleFinitistic.SelectedFirstBlockFamily
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Selected/SelectedFixedDiagram.lean b/lean/OAI/Algebra/Finitistic/Selected/SelectedFixedDiagram.lean
new file mode 100644
index 0000000000000000000000000000000000000000..a1f28473badfd18051d621cfdb592cc1fc1ecc93
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Selected/SelectedFixedDiagram.lean
@@ -0,0 +1,66 @@
+import OAI.Algebra.Finitistic.Localization.SourceQuotientAction
+import OAI.Algebra.Finitistic.Localization.ConcreteFixedDiagram
+
+namespace OAI
+noncomputable section
+open CategoryTheory CategoryTheory.Limits CategoryTheory.Idempotents
+namespace LittleFinitistic.SelectedFixedDiagram
+open SelectionEncoding RelationBasisCoefficients RelationBasisAction FormalSummandAction
+
+abbrev encoding := auxiliaryEncoding
+abbrev P := encoding.relations
+abbrev theta := SourceQuotientAction.theta encoding
+abbrev e := selectionIdempotent 0
+abbrev alpha := (selectionAutomorphism 1).toAlgHom
+lemma idem : e*e=e := selectionIdempotent_square 0
+lemma central (r : SelectionRing) : e*r=r*e := (selectionIdempotent_central 0 r).eq
+
+local instance : HasFiniteBiproducts (Karoubi (SourceVerdier.Q P)) :=
+  Karoubi.karoubi_hasFiniteBiproducts
+local instance : HasBinaryBiproducts (Karoubi (SourceVerdier.Q P)) :=
+  hasBinaryBiproducts_of_finite_biproducts _
+
+abbrev U := summand theta e idem
+abbrev oddDouble := U ⊞ OddDouble.formalShift U 3
+abbrev selectedAction := oddDoubleAction theta e idem central alpha
+
+/-- All choices, arrows, relation-basis equations and equivariant identifications
+for the actual selecting algebra. No evaluation module is a parameter. -/
+structure Data where
+  V0 : SourceVerdier.Q P
+  rho : SelectionRing →ₐ[ℂ] End V0
+  iso : (toKaroubi (SourceVerdier.Q P)).obj V0 ≅ oddDouble
+  D0 : SourceVerdier.K P
+  D1 : SourceVerdier.K P
+  D2 : SourceVerdier.K P
+  phi0 : (SourceVerdier.q P).obj D0 ≅ V0
+  phi1 : (SourceVerdier.q P).obj D1 ≅ V0
+  phi2 : (SourceVerdier.q P).obj D2 ≅ V0
+  f : Fin (encoding.generators+1) → (D0 ⟶ D1)
+  g : Fin (encoding.generators+1) → (D1 ⟶ D2)
+  equivariant : ∀ r : SelectionRing,
+    (toKaroubi (SourceVerdier.Q P)).map (rho r) ≫ iso.hom = iso.hom ≫ selectedAction r
+  arrow01 : ∀ a, (SourceVerdier.q P).map (f a) ≫ phi1.hom =
+    phi0.hom ≫ rho (arrow (generator encoding) a)
+  arrow12 : ∀ b, (SourceVerdier.q P).map (g b) ≫ phi2.hom =
+    phi1.hom ≫ rho (arrow (generator encoding) b)
+  relations : ∀ r : RelationIndex P,
+    ∑ a, ∑ b, basisCoefficient P r a b • (f a ≫ g b) = 0
+
+/-- Choose once, using the proved native finite-diagram theorem and actual theta. -/
+def fixed : Data := Classical.choice (by
+  obtain ⟨V,rho,i,D0,D1,D2,p0,p1,p2,f,g,he,hf,hg,hr⟩ :=
+    ConcreteFixedDiagram.fixed_diagram encoding theta e idem central alpha
+  exact ⟨⟨V,rho,i,D0,D1,D2,p0,p1,p2,f,g,he,hf,hg,hr⟩⟩)
+
+theorem fixed_relations (r : RelationIndex P) :
+    ∑ a, ∑ b, basisCoefficient P r a b • (fixed.f a ≫ fixed.g b) = 0 := fixed.relations r
+
+theorem fixed_equivariant (r : SelectionRing) :
+    (toKaroubi (SourceVerdier.Q P)).map (fixed.rho r) ≫ fixed.iso.hom =
+      fixed.iso.hom ≫ selectedAction r := fixed.equivariant r
+end LittleFinitistic.SelectedFixedDiagram
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Selected/SelectedImageComparison.lean b/lean/OAI/Algebra/Finitistic/Selected/SelectedImageComparison.lean
new file mode 100644
index 0000000000000000000000000000000000000000..29b00a9725aa80f45156b97b5bdb36649be66de4
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Selected/SelectedImageComparison.lean
@@ -0,0 +1,61 @@
+import OAI.Algebra.Finitistic.Localization.SourceCornerEvaluation
+import OAI.Algebra.Finitistic.Selection.SelectionIteration
+
+namespace OAI
+noncomputable section
+open CategoryTheory
+namespace LittleFinitistic.SelectedImageComparison
+open QuadraticEncoding SourceImageEvaluation
+universe v
+variable {Y : Type v} [AddCommGroup Y] [Module ℂ Y]
+  [Module SelectionRing Y] [IsScalarTower ℂ SelectionRing Y]
+
+/-- The evaluator's range is canonically the primary's actual H(Y), as a complex vector space. -/
+def equiv : imageSpace (k := ℂ) (Y := Y) (selectionIdempotent 0) ≃ₗ[ℂ]
+    complexObject (selectionStep (ModuleCat.of SelectionRing Y)) where
+  toFun x := ⟨x.val.down, by
+    obtain ⟨z,hz⟩ := x.property
+    have hz' : selectionIdempotent 0 • z.down = x.val.down := congrArg ULift.down hz
+    change selectionIdempotent 0 • x.val.down = x.val.down
+    rw [← hz',← mul_smul,selectionIdempotent_square]⟩
+  invFun x := ⟨ULift.up x.val, ⟨ULift.up x.val, by
+    change ULift.up (selectionIdempotent 0 • x.val) = ULift.up x.val
+    exact congrArg ULift.up x.property⟩⟩
+  left_inv x := by apply Subtype.ext; rfl
+  right_inv x := by rfl
+  map_add' x y := rfl
+  map_smul' c x := by
+    apply Subtype.ext
+    change c • x.val.down = selectionAutomorphism 1 (algebraMap ℂ SelectionRing c) • x.val.down
+    rw [AlgEquiv.commutes,algebraMap_smul]
+
+abbrev moduleAction (r : SelectionRing) (x : selectionStep (ModuleCat.of SelectionRing Y)) :
+    selectionStep (ModuleCat.of SelectionRing Y) := r • x
+
+/-- The evaluator's compressed alpha action is precisely the action on the primary's H(Y). -/
+theorem equiv_action (r : SelectionRing)
+    (x : imageSpace (k := ℂ) (Y := Y) (selectionIdempotent 0)) :
+    equiv (Y := Y) ((imageCornerEnd (action (k := ℂ) (Y := Y) (selectionIdempotent 0)).hom
+      (action (k := ℂ) (Y := Y) (selectionAutomorphism 1 r)).hom) x) =
+    moduleAction (Y := Y) r (equiv (Y := Y) x) := by
+  apply Subtype.ext
+  have h := imageCorner_restriction (k := ℂ) (Y := Y) (selectionIdempotent 0)
+    (selectionAutomorphism 1 r) (selectionIdempotent_square 0)
+    (selectionIdempotent_central 0 (selectionAutomorphism 1 r)).eq x
+  exact congrArg ULift.down h
+
+theorem image_nontrivial_of (h : Nontrivial (selectionStep (ModuleCat.of SelectionRing Y))) :
+    Nontrivial (imageSpace (k := ℂ) (Y := Y) (selectionIdempotent 0)) := by
+  let i := equiv (Y := Y)
+  obtain ⟨x,y,hxy⟩ := h.exists_pair_ne
+  exact ⟨⟨i.symm x,i.symm y,fun h => hxy (i.symm.injective h)⟩⟩
+
+theorem image_subsingleton_of (h : Subsingleton (selectionStep (ModuleCat.of SelectionRing Y))) :
+    Subsingleton (imageSpace (k := ℂ) (Y := Y) (selectionIdempotent 0)) :=
+  ⟨fun first second => (equiv (Y := Y)).injective
+    (h.elim (equiv (Y := Y) first) (equiv (Y := Y) second))⟩
+end LittleFinitistic.SelectedImageComparison
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Selected/SelectedIteration.lean b/lean/OAI/Algebra/Finitistic/Selected/SelectedIteration.lean
new file mode 100644
index 0000000000000000000000000000000000000000..bf261e62b05680c1bad18f31fd2d6d769cbf61bb
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Selected/SelectedIteration.lean
@@ -0,0 +1,53 @@
+import OAI.Algebra.Finitistic.Selection.FiniteSelectionFamily
+import OAI.Algebra.Finitistic.Iteration.ObjectwiseSplitting
+
+namespace OAI
+noncomputable section
+open CategoryTheory CategoryTheory.Limits
+attribute [local instance] HasDerivedCategory.standard HasExt.standard
+namespace LittleFinitistic.SelectedIteration
+open SelectedFixedDiagram QuadraticEncoding FiniteSelectionFamily
+
+variable (Phi : DerivedCategory (ModuleCat (B P)) ⥤ DerivedCategory (ModuleCat (B P)))
+  [Phi.Additive] [Phi.CommShift ℤ]
+/- This is solely the remaining derived-tensor/stalk comparison. The realization
+and exact reference cohomology have already been proved independently. -/
+variable (comparison : ∀ Y : S, Phi.obj (derived Y) ≅
+  SelectedTensorSplitting.object (representation Y).Evaluation)
+include comparison
+
+def split (Y : S) : Phi.obj (derived Y) ≅ derived (H Y) ⊞ (derived (H Y))⟦(3 : ℤ)⟧ :=
+  comparison Y ≪≫ FiniteSelectionFamily.realization Y
+
+/-- The exact binomial formula, instantiated with the actual finite module family. -/
+def iteration (j : ℕ) (Y : S) :
+    (Phi.obj^[j]) (derived Y) ≅
+      ⨁ fun q : Fin (j+1) => ⨁ fun _ : Fin (Nat.choose j q.val) =>
+        (derived ((H^[j]) Y))⟦(3 : ℤ)*(q.val : ℤ)⟧ :=
+  ExternalTensor.Binomial.section4Iteration Phi derived H (split Phi comparison) j Y
+
+private def shiftedSplit (Y : S) :
+    Phi.obj (derived Y) ≅ (derived (H Y))⟦(0 : ℤ)⟧ ⊞ (derived (H Y))⟦(0+3 : ℤ)⟧ :=
+  split Phi comparison Y ≪≫ biprod.mapIso (shiftZero ℤ (derived (H Y))).symm (Iso.refl _)
+
+theorem isZero_iff (j : ℕ) (Y : S) :
+    IsZero ((Phi.obj^[j]) (derived Y)) ↔ Subsingleton (selectionIterate Y.val j) := by
+  rw [ExternalTensor.Binomial.iteration_isZero_iff Phi derived H 0 3 (shiftedSplit Phi comparison)]
+  rw [derived_zero, iterate_val]
+
+/-- Actual Section 2 tests give arbitrarily long finite extinction for this tensor
+functor, once its stated stalk comparison is instantiated. -/
+theorem extinction (m : ℕ) [NeZero m] :
+    (∀ j < m, ¬ IsZero ((Phi.obj^[j]) (derived (test m)))) ∧
+      IsZero ((Phi.obj^[m]) (derived (test m))) := by
+  constructor
+  · intro j hj hz
+    have hs := (isZero_iff Phi comparison j (test m)).mp hz
+    have hn := selectionIterate_test_nontrivial m j hj
+    exact @not_subsingleton _ hn hs
+  · exact (isZero_iff Phi comparison m (test m)).mpr (selectionIterate_test_subsingleton m)
+end LittleFinitistic.SelectedIteration
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Selected/SelectedMinimalResolution.lean b/lean/OAI/Algebra/Finitistic/Selected/SelectedMinimalResolution.lean
new file mode 100644
index 0000000000000000000000000000000000000000..5a052498639c1e698ca0839290f17e62f638ca20
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Selected/SelectedMinimalResolution.lean
@@ -0,0 +1,31 @@
+import OAI.Algebra.Finitistic.Selected.SelectedOrdinaryModules
+import OAI.Algebra.Finitistic.Dimension.PDDimension
+
+namespace OAI
+noncomputable section
+open CategoryTheory CategoryTheory.Limits
+namespace LittleFinitistic.SelectedMinimalResolution
+open SelectedOrdinaryAlgebra SelectedOrdinaryModules
+
+abbrev finiteModule (Y : FiniteSelectionFamily.S.{0}) : PDMinimal.FiniteModule ℂ A :=
+  PDMinimal.FiniteModule.of (Inflated Y)
+
+/-- A genuine minimal projective resolution of each actual constructed A-module. -/
+def resolution (Y : FiniteSelectionFamily.S.{0}) : ProjectiveResolution (SelectedOrdinaryModules.module Y) :=
+  PDMinimal.resolution (finiteModule Y)
+
+/-- The constructed A-module has projective dimension at most n precisely when
+its actual minimal projective resolution has zero term n+1. -/
+theorem dimension_iff (Y : FiniteSelectionFamily.S.{0}) (n : ℕ) :
+    HasProjectiveDimensionLE (SelectedOrdinaryModules.module Y) n ↔
+      Subsingleton (PDMinimal.term (finiteModule Y) (n+1)) :=
+  PDMinimal.pdLE_iff_term_zero (finiteModule Y) n
+
+/-- The actual minimal-resolution terms are projective. -/
+theorem projective (Y : FiniteSelectionFamily.S.{0}) (n : ℕ) :
+    Projective ((resolution Y).complex.X n) := inferInstance
+end LittleFinitistic.SelectedMinimalResolution
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Selected/SelectedNativeAction.lean b/lean/OAI/Algebra/Finitistic/Selected/SelectedNativeAction.lean
new file mode 100644
index 0000000000000000000000000000000000000000..84e2f79b62629f96048e9ddf18cc85d5c27e2609
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Selected/SelectedNativeAction.lean
@@ -0,0 +1,104 @@
+import OAI.Algebra.Finitistic.Selected.SelectedNativeEvaluation
+
+namespace OAI
+noncomputable section
+open CategoryTheory CategoryTheory.Limits
+attribute [local instance] HasDerivedCategory.standard
+namespace LittleFinitistic.SelectedNativeEvaluation
+open QuadraticEncoding SourceImageEvaluation FiniteProjectiveHomotopy SelectedFixedDiagram
+universe v
+variable {Y : Type v} [AddCommGroup Y] [Module ℂ Y]
+  [Module SelectionRing Y] [IsScalarTower ℂ SelectionRing Y]
+
+abbrev imageEnd (r : SelectionRing) := imageCornerEnd
+  (action (k := ℂ) (Y := Y) e).hom (action (k := ℂ) (Y := Y) (alpha r)).hom
+abbrev moduleIso := (SelectedImageComparison.equiv (Y := Y)).toModuleIso
+
+def HAction (r : SelectionRing) : End (H (Y := Y)) :=
+  (moduleIso (Y := Y)).inv ≫ imageEnd (Y := Y) r ≫ (moduleIso (Y := Y)).hom
+
+/-- The conjugated map is the primary selectionStep module action, on every vector. -/
+theorem HAction_apply (r : SelectionRing) (x : H (Y := Y)) :
+    (HAction (Y := Y) r).hom x = SelectedImageComparison.moduleAction (Y := Y) r x := by
+  have h := SelectedImageComparison.equiv_action (Y := Y) r
+    ((SelectedImageComparison.equiv (Y := Y)).symm x)
+  dsimp only [HAction,moduleIso,LinearEquiv.toModuleIso] at *
+  simp only [LinearEquiv.apply_symm_apply] at h
+  exact h
+
+lemma module_square (r : SelectionRing) :
+    imageEnd (Y := Y) r ≫ (moduleIso (Y := Y)).hom =
+      (moduleIso (Y := Y)).hom ≫ HAction (Y := Y) r := by
+  simp only [HAction,Iso.hom_inv_id_assoc]
+
+variable [FiniteDimensional ℂ Y]
+
+def HKAction (r : SelectionRing) : End (HK (Y := Y)) :=
+  (inclusion ℂ).preimage ((vectorStalk (k := ℂ)).map (HAction (Y := Y) r))
+def HDerivedAction (r : SelectionRing) : End (HDerived (Y := Y)) :=
+  (derivedEmbedding ℂ).toEssImage.map (HKAction (Y := Y) r)
+
+lemma imageIsoK_hom : (inclusion ℂ).map (imageIsoK (Y := Y)).hom =
+    (vectorStalk (k := ℂ)).map (moduleIso (Y := Y)).hom := by
+  simp only [imageIsoK,Functor.preimageIso,Functor.mapIso_hom]
+  erw [Functor.map_preimage]
+
+lemma image_square (r : SelectionRing) :
+    imageCorner (k := ℂ) (Y := Y) e (alpha r) ≫ (imageIso (Y := Y)).hom =
+      (imageIso (Y := Y)).hom ≫ HDerivedAction (Y := Y) r := by
+  apply (derivedTargetInclusion (k := ℂ)).map_injective
+  rw [Functor.map_comp,Functor.map_comp]
+  dsimp only [imageCorner]
+  erw [Functor.map_preimage]
+  change DerivedCategory.Qh.map ((vectorStalk (k := ℂ)).map (imageEnd (Y := Y) r)) ≫
+    DerivedCategory.Qh.map ((inclusion ℂ).map (imageIsoK (Y := Y)).hom) =
+    DerivedCategory.Qh.map ((inclusion ℂ).map (imageIsoK (Y := Y)).hom) ≫
+    DerivedCategory.Qh.map ((inclusion ℂ).map (HKAction (Y := Y) r))
+  rw [imageIsoK_hom]
+  dsimp only [HKAction]
+  erw [Functor.map_preimage]
+  erw [← Functor.map_comp,← Functor.map_comp,← Functor.map_comp,← Functor.map_comp,module_square]
+  rfl
+
+abbrev targetAction (r : SelectionRing) : End (target (Y := Y)) :=
+  biprod.map (HDerivedAction (Y := Y) r) ((HDerivedAction (Y := Y) r)⟦(3 : ℤ)⟧')
+
+lemma target_square (r : SelectionRing) :
+    SelectedDiagramEvaluation.targetAction (Y := Y) r ≫ (targetIso (Y := Y)).hom =
+      (targetIso (Y := Y)).hom ≫ targetAction (Y := Y) r := by
+  have h := image_square (Y := Y) r
+  have hs := congrArg (shiftFunctor (FiniteVectorDerived.{0,v} (k := ℂ)) (3 : ℤ)).map h
+  simp only [Functor.map_comp] at hs
+  dsimp only [SelectedDiagramEvaluation.targetAction,targetIso,targetAction,biprod.mapIso]
+  apply biprod.hom_ext
+  · simp only [Category.assoc,biprod.map_fst,biprod.map_fst_assoc,h]
+  · simp only [Category.assoc,biprod.map_snd,biprod.map_snd_assoc,Functor.mapIso_hom,hs]
+
+/-- The fixed V0 evaluates equivariantly to the primary H(Y) plus H(Y)[3]. -/
+theorem V0_action (r : SelectionRing) :
+    (SelectedDiagramEvaluation.F (Y := Y)).map (fixed.rho r) ≫ (V0Iso (Y := Y)).hom =
+      (V0Iso (Y := Y)).hom ≫ targetAction (Y := Y) r :=
+  DiagramEvaluationSquares.compose _ _ _ SelectedDiagramEvaluation.V0Iso
+    SelectedDiagramEvaluation.V0Iso targetIso targetIso
+    (SelectedDiagramEvaluation.V0_action r) (target_square r)
+
+theorem D_arrow01 (a : Fin (encoding.generators+1)) :
+    (SelectedDiagramEvaluation.sourceEvaluation (Y := Y)).map (fixed.f a) ≫ (D1Iso (Y := Y)).hom =
+      (D0Iso (Y := Y)).hom ≫ targetAction (Y := Y)
+        (RelationBasisAction.arrow (SelectionEncoding.generator encoding) a) :=
+  DiagramEvaluationSquares.compose _ _ _ SelectedDiagramEvaluation.D0Iso
+    SelectedDiagramEvaluation.D1Iso targetIso targetIso
+    (SelectedDiagramEvaluation.D_arrow01 a) (target_square _)
+
+theorem D_arrow12 (a : Fin (encoding.generators+1)) :
+    (SelectedDiagramEvaluation.sourceEvaluation (Y := Y)).map (fixed.g a) ≫ (D2Iso (Y := Y)).hom =
+      (D1Iso (Y := Y)).hom ≫ targetAction (Y := Y)
+        (RelationBasisAction.arrow (SelectionEncoding.generator encoding) a) :=
+  DiagramEvaluationSquares.compose _ _ _ SelectedDiagramEvaluation.D1Iso
+    SelectedDiagramEvaluation.D2Iso targetIso targetIso
+    (SelectedDiagramEvaluation.D_arrow12 a) (target_square _)
+end LittleFinitistic.SelectedNativeEvaluation
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Selected/SelectedNativeEvaluation.lean b/lean/OAI/Algebra/Finitistic/Selected/SelectedNativeEvaluation.lean
new file mode 100644
index 0000000000000000000000000000000000000000..de8c264adf9a302cbfd50ba0981a3dbcc0016c92
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Selected/SelectedNativeEvaluation.lean
@@ -0,0 +1,47 @@
+import OAI.Algebra.Finitistic.Selected.SelectedDiagramEvaluation
+import OAI.Algebra.Finitistic.Selected.SelectedImageComparison
+
+namespace OAI
+noncomputable section
+open CategoryTheory CategoryTheory.Limits
+attribute [local instance] HasDerivedCategory.standard
+namespace LittleFinitistic.SelectedNativeEvaluation
+open QuadraticEncoding SourceImageEvaluation FiniteProjectiveHomotopy SelectedFixedDiagram
+universe v
+variable {Y : Type v} [AddCommGroup Y] [Module ℂ Y] [FiniteDimensional ℂ Y]
+  [Module SelectionRing Y] [IsScalarTower ℂ SelectionRing Y]
+
+abbrev H := complexObject (selectionStep (ModuleCat.of SelectionRing Y))
+instance : FiniteDimensional ℂ (H (Y := Y)) :=
+  Module.Finite.of_surjective (SelectedImageComparison.equiv (Y := Y)).toLinearMap
+    (SelectedImageComparison.equiv (Y := Y)).surjective
+
+def HK : K.{0,v} ℂ := ⟨(vectorStalk (k := ℂ)).obj (H (Y := Y)), single_property _ 0⟩
+def HDerived : FiniteVectorDerived.{0,v} (k := ℂ) :=
+  (derivedEmbedding ℂ).toEssImage.obj (HK (Y := Y))
+def imageIsoK : imageK (k := ℂ) (Y := Y) e ≅ HK (Y := Y) :=
+  (inclusion ℂ).preimageIso ((vectorStalk (k := ℂ)).mapIso
+    (SelectedImageComparison.equiv (Y := Y)).toModuleIso)
+def imageIso : imageDerived (k := ℂ) (Y := Y) e ≅ HDerived (Y := Y) :=
+  (derivedEmbedding ℂ).toEssImage.mapIso (imageIsoK (Y := Y))
+
+/-- The actual primary H(Y), concentrated in degree zero, and its shift by three. -/
+abbrev target := HDerived (Y := Y) ⊞ (HDerived (Y := Y))⟦(3 : ℤ)⟧
+def targetIso : SelectedDiagramEvaluation.target (Y := Y) ≅ target (Y := Y) :=
+  biprod.mapIso (imageIso (Y := Y))
+    ((shiftFunctor (FiniteVectorDerived.{0,v} (k := ℂ)) (3 : ℤ)).mapIso (imageIso (Y := Y)))
+
+def V0Iso : (SelectedDiagramEvaluation.F (Y := Y)).obj fixed.V0 ≅ target (Y := Y) :=
+  SelectedDiagramEvaluation.V0Iso ≪≫ targetIso
+
+def D0Iso : (SelectedDiagramEvaluation.sourceEvaluation (Y := Y)).obj fixed.D0 ≅ target (Y := Y) :=
+  SelectedDiagramEvaluation.D0Iso ≪≫ targetIso
+def D1Iso : (SelectedDiagramEvaluation.sourceEvaluation (Y := Y)).obj fixed.D1 ≅ target (Y := Y) :=
+  SelectedDiagramEvaluation.D1Iso ≪≫ targetIso
+def D2Iso : (SelectedDiagramEvaluation.sourceEvaluation (Y := Y)).obj fixed.D2 ≅ target (Y := Y) :=
+  SelectedDiagramEvaluation.D2Iso ≪≫ targetIso
+end LittleFinitistic.SelectedNativeEvaluation
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Selected/SelectedOrdinaryAlgebra.lean b/lean/OAI/Algebra/Finitistic/Selected/SelectedOrdinaryAlgebra.lean
new file mode 100644
index 0000000000000000000000000000000000000000..68f9d50fe4c3266719c1eccd73fece508835ceeb
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Selected/SelectedOrdinaryAlgebra.lean
@@ -0,0 +1,63 @@
+import OAI.Algebra.Finitistic.Selected.SelectedWindow
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryBlockBimodule
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryRightProjective
+import Mathlib.Algebra.TrivSqZeroExt.Basic
+
+namespace OAI
+noncomputable section
+open CategoryTheory CategoryTheory.Limits
+namespace LittleFinitistic.SelectedOrdinaryAlgebra
+open SelectedFixedDiagram QuadraticEncoding
+open OrdinarySimulation
+
+/-- A fixed support interval containing degree zero, chosen before any test module. -/
+def a : ℤ := min (SelectedWindow.lo-2) 0
+def b : ℤ := max SelectedWindow.hi 0
+def length : ℕ := (b-a).toNat
+
+theorem a_le_zero : a ≤ 0 := min_le_right _ _
+theorem b_nonneg : 0 ≤ b := le_max_right _ _
+theorem endpoints : a + (length : ℤ) = b := by
+  have ha := a_le_zero
+  have hb := b_nonneg
+  dsimp [length]
+  omega
+
+theorem support (n : ℤ) (hn : n < a ∨ b < n) :
+    IsZero (SelectedRectification.bimodule.X n) := by
+  apply SelectedWindow.bounded n
+  dsimp [a,b] at hn
+  omega
+
+instance term_finite (n : ℤ) :
+    FiniteDimensional ℂ ((underlyingComplex (k := ℂ) SelectedRectification.bimodule).X n) :=
+  SelectedWindow.verified.finite n
+instance term_projective (n : ℤ) :
+    Module.Projective (B P)ᵐᵒᵖ ((underlyingRightComplex SelectedRectification.bimodule).X n) := by
+  let : Projective ((underlyingRightComplex SelectedRectification.bimodule).X n) :=
+    SelectedWindow.verified.projective n
+  exact ModuleCat.projective_of_module_projective _
+
+/-- The actual finite-dimensional ordinary algebra and off-diagonal bimodule. -/
+abbrev D := AlgebraD ℂ length (B P)
+abbrev O := BimoduleO SelectedRectification.bimodule a length
+abbrev X := BimoduleX SelectedRectification.bimodule a length
+instance base_finite : FiniteDimensional ℂ (B P) := QuadraticEncoding.finiteDimensional P
+instance D_finite : FiniteDimensional ℂ D := inferInstance
+instance O_finite : FiniteDimensional ℂ O := inferInstance
+instance X_finite : FiniteDimensional ℂ X := ordinary_finite _ _ _
+instance O_right_projective : Module.Projective (B P)ᵐᵒᵖ O :=
+  ordinaryO_right_projective _ _ _
+
+/-- The manuscript's one fixed square-zero algebra. No projective-dimension
+conclusion is asserted here. -/
+abbrev A := TrivSqZeroExt D X
+abbrev augmentation : A →ₐ[ℂ] D := TrivSqZeroExt.fstHom ℂ D X
+
+instance A_finite : FiniteDimensional ℂ A :=
+  inferInstanceAs (FiniteDimensional ℂ (D × X))
+end LittleFinitistic.SelectedOrdinaryAlgebra
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Selected/SelectedOrdinaryDimension.lean b/lean/OAI/Algebra/Finitistic/Selected/SelectedOrdinaryDimension.lean
new file mode 100644
index 0000000000000000000000000000000000000000..4a6685512813052a2fc113820b5fe1a255fea1d6
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Selected/SelectedOrdinaryDimension.lean
@@ -0,0 +1,30 @@
+import OAI.Algebra.Finitistic.Selected.SelectedOrdinaryAlgebra
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryGlobalDimension
+
+namespace OAI
+noncomputable section
+open CategoryTheory
+namespace LittleFinitistic.SelectedOrdinaryDimension
+open SelectedOrdinaryAlgebra SelectedFixedDiagram
+
+/-- A fixed numerical bound determined solely by the fixed selecting bimodule. -/
+abbrev bound : ℕ := 3 * length + 2
+
+/-- The actual D has the manuscript's global dimension bound on both sides. -/
+theorem both_sides :
+    (⨆ M : ModuleCat.{0} D, projectiveDimension M) ≤ bound ∧
+    (⨆ M : ModuleCat.{0} Dᵐᵒᵖ, projectiveDimension M) ≤ bound :=
+  OrdinarySimulation.source_ordinary_globalDimension_bound (QuadraticEncoding.composition P) length
+
+theorem left_module (M : ModuleCat.{0} D) : HasProjectiveDimensionLE M bound := by
+  apply (projectiveDimension_le_iff M bound).mp
+  exact (le_iSup (fun N : ModuleCat.{0} D => projectiveDimension N) M).trans both_sides.1
+
+theorem right_module (M : ModuleCat.{0} Dᵐᵒᵖ) : HasProjectiveDimensionLE M bound := by
+  apply (projectiveDimension_le_iff M bound).mp
+  exact (le_iSup (fun N : ModuleCat.{0} Dᵐᵒᵖ => projectiveDimension N) M).trans both_sides.2
+end LittleFinitistic.SelectedOrdinaryDimension
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Selected/SelectedOrdinaryModules.lean b/lean/OAI/Algebra/Finitistic/Selected/SelectedOrdinaryModules.lean
new file mode 100644
index 0000000000000000000000000000000000000000..925d38147c81e896b6863f6faad4e75c5a6e9676
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Selected/SelectedOrdinaryModules.lean
@@ -0,0 +1,73 @@
+import OAI.Algebra.Finitistic.Selected.SelectedOrdinaryAlgebra
+import OAI.Algebra.Finitistic.Selection.FiniteSelectionFamily
+
+namespace OAI
+noncomputable section
+open CategoryTheory CategoryTheory.Limits
+namespace LittleFinitistic.SelectedOrdinaryModules
+open SelectedFixedDiagram QuadraticEncoding SelectedOrdinaryAlgebra
+open FiniteSelectionFamily
+
+/-- The source module M(Y), supported on the first D-block and inflated to A. -/
+def Inflated (Y : S.{0}) := (representation Y).Evaluation
+instance (Y : S.{0}) : AddCommGroup (Inflated Y) :=
+  inferInstanceAs (AddCommGroup (representation Y).Evaluation)
+instance (Y : S.{0}) : Module ℂ (Inflated Y) :=
+  inferInstanceAs (Module ℂ (representation Y).Evaluation)
+instance (Y : S.{0}) : Module (B P) (Inflated Y) :=
+  inferInstanceAs (Module (B P) (representation Y).Evaluation)
+instance (Y : S.{0}) : IsScalarTower ℂ (B P) (Inflated Y) :=
+  inferInstanceAs (IsScalarTower ℂ (B P) (representation Y).Evaluation)
+
+abbrev firstProjection : D →+* B P := RingHom.fst _ _
+abbrev augmentationRing : A →+* D := SelectedOrdinaryAlgebra.augmentation.toRingHom
+instance (Y : S.{0}) : Module D (Inflated Y) := Module.compHom (Inflated Y) firstProjection
+instance (Y : S.{0}) : Module A (Inflated Y) :=
+  Module.compHom (Inflated Y) (firstProjection.comp augmentationRing)
+instance (Y : S.{0}) : IsScalarTower ℂ D (Inflated Y) where
+  smul_assoc c d x := by
+    change (c • d.1) • x = c • (d.1 • x)
+    exact smul_assoc c d.1 x
+instance (Y : S.{0}) : IsScalarTower ℂ A (Inflated Y) where
+  smul_assoc c a x := by
+    change (c • a.fst.1) • x = c • (a.fst.1 • x)
+    exact smul_assoc c a.fst.1 x
+instance (Y : S.{0}) : FiniteDimensional ℂ (Inflated Y) :=
+  inferInstanceAs (FiniteDimensional ℂ (representation Y).Evaluation)
+
+instance (Y : S.{0}) : Module.Finite A (Inflated Y) :=
+  Module.Finite.of_restrictScalars_finite ℂ A (Inflated Y)
+
+abbrev module (Y : S.{0}) := ModuleCat.of A (Inflated Y)
+
+/-- The actual D-action is exactly the original first B-block action. -/
+theorem first_action (Y : S.{0}) (d : D) (n : Inflated Y) : d • n = d.1 • n := rfl
+/-- The square-zero ideal acts by zero, as required by the bar calculation. -/
+theorem ideal_annihilates (Y : S.{0}) (x : X) (n : Inflated Y) :
+    (TrivSqZeroExt.inr x : A) • n = 0 := by
+  change (0 : B P) • n = 0
+  exact zero_smul _ _
+theorem base_action (Y : S.{0}) (d : D) (n : Inflated Y) :
+    (TrivSqZeroExt.inl d : A) • n = d • n := rfl
+
+/-- Inflation preserves exactly the original module's zero criterion. -/
+theorem isZero_iff (Y : S.{0}) : IsZero (module Y) ↔ Subsingleton Y.val := by
+  rw [← FiniteSelectionFamily.module_zero Y]
+  change IsZero (ModuleCat.of A (Inflated Y)) ↔ IsZero (FiniteSelectionFamily.module Y)
+  rw [ModuleCat.isZero_iff_subsingleton, ModuleCat.isZero_iff_subsingleton]
+  rfl
+
+/-- Actual finite-dimensional modules over the one fixed A; their projective
+ dimensions are the remaining homological conclusion. -/
+abbrev testModule (m : ℕ) [NeZero m] := module (test m)
+
+theorem test_nonzero (m : ℕ) [NeZero m] : ¬ IsZero (testModule m) := by
+  intro h
+  have hs := (isZero_iff (test m)).mp h
+  have hn := selectionIterate_test_nontrivial m 0 (NeZero.pos m)
+  exact @not_subsingleton _ hn hs
+end LittleFinitistic.SelectedOrdinaryModules
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Selected/SelectedOrdinaryOrbit.lean b/lean/OAI/Algebra/Finitistic/Selected/SelectedOrdinaryOrbit.lean
new file mode 100644
index 0000000000000000000000000000000000000000..ff4b20d434e7c010cebef86e21039eb370f95b9c
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Selected/SelectedOrdinaryOrbit.lean
@@ -0,0 +1,83 @@
+import OAI.Algebra.Finitistic.Bimodule.BimoduleShiftedPresentation
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryFirstDerivedRetraction
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryDerivedIterates
+import OAI.Algebra.Finitistic.Selected.SelectedShiftedRealization
+import OAI.Algebra.Finitistic.Selected.SelectedBarPowers
+import OAI.Algebra.Finitistic.Iteration.FunctorObjectIteration
+
+namespace OAI
+noncomputable section
+open CategoryTheory CategoryTheory.Limits
+open scoped TensorProduct
+namespace LittleFinitistic.SelectedOrdinaryOrbit
+open SelectedOrdinaryAlgebra SelectedFixedDiagram QuadraticEncoding
+local instance : HasDerivedCategory.{1} (ModuleCat.{0} D) :=
+  HasDerivedCategory.standard (ModuleCat.{0} D)
+local instance : HasDerivedCategory.{1} (ModuleCat.{0} (B P)) :=
+  HasDerivedCategory.standard (ModuleCat.{0} (B P))
+
+abbrev first := BlockModule.derivedFirst (B P) ((B P) ⊗[ℂ] OrdinarySimulation.ChainAlgebra ℂ length)
+abbrev ordinary := SelectedOrdinaryResolution.derived
+
+/-- The source's first-block localization is the actual selected exact inflation. -/
+def firstIso : first ≅ SelectedFirstBlockFamily.derivedInflation :=
+  BlockModule.derivedFirstIso (B P) ((B P) ⊗[ℂ] OrdinarySimulation.ChainAlgebra ℂ length)
+
+def firstStalk (Y : FiniteSelectionFamily.S.{0}) :
+    first.obj (FiniteSelectionFamily.derived Y) ≅ SelectedFirstBlockFamily.derived Y :=
+  firstIso.app _ ≪≫ SelectedFirstBlockFamily.stalkIso Y
+
+local instance resolution_projective : ∀ n, Module.Projective Dᵐᵒᵖ
+    (ComplexTensor.rightTerm ℂ D (BimoduleTotal.right ℂ D SelectedOrdinaryResolution.complex) n) :=
+  fun n => SelectedOrdinaryResolution.right_projective n
+
+/-- Both tensor presentations use the identical Q_X and signed finite total. -/
+def nativeIso : ordinary ≅ SelectedBarComparison.native :=
+  BimoduleTotalPresentation.boundedNonpositiveDerivedIso ℂ D SelectedOrdinaryResolution.complex
+    SelectedBarComparison.resolution.data length rfl rfl
+
+/-- The source's shifted P[b] tensor is the concrete selecting shifted model. -/
+def shiftedIso : OrdinarySimulation.shiftedDerivedTensor SelectedRectification.bimodule b length ≅
+    SelectedShiftedRealization.G :=
+  BimoduleTotalPresentation.shiftedDerivedIso SelectedRectification.bimodule b length
+    SelectedShiftedRealization.model rfl rfl
+
+/-- Every ordinary iterate on the selected first-block stalk is the original bar iterate. -/
+def barPower (Y : FiniteSelectionFamily.S.{0}) (r : ℕ) :
+    (ordinary.obj^[r]) (SelectedFirstBlockFamily.derived Y) ≅ SelectedBaseIterates.object Y r :=
+  functorObjectIteration nativeIso r _ ≪≫ SelectedBarPowers.comparison Y r
+
+/-- Exact Section 5 even-iteration formula, with both presentation distinctions discharged. -/
+def evenIteration (Y : FiniteSelectionFamily.S.{0}) (j : ℕ) :
+    SelectedBaseIterates.object Y (2*j) ≅
+      first.obj ((SelectedShiftedRealization.G.obj^[j]) (FiniteSelectionFamily.derived Y)) :=
+  (barPower Y (2*j)).symm ≪≫ mapObjectIteration ordinary (firstStalk Y).symm (2*j) ≪≫
+    OrdinarySimulation.XResolution.derivedEvenIterate SelectedRectification.bimodule a length b
+      endpoints support j (FiniteSelectionFamily.derived Y) ≪≫
+    first.mapIso (functorObjectIteration shiftedIso j _)
+
+/-- Every even original-X iterate is zero exactly at the original selection stopping time. -/
+theorem isZero_iff (Y : FiniteSelectionFamily.S.{0}) (j : ℕ) :
+    IsZero (SelectedBaseIterates.object Y (2*j)) ↔ Subsingleton (selectionIterate Y.val j) :=
+  (evenIteration Y j).isZero_iff.trans
+    ((BlockModule.derivedFirst_isZero_iff (B P)
+      ((B P) ⊗[ℂ] OrdinarySimulation.ChainAlgebra ℂ length) _).trans
+        (SelectedShiftedRealization.isZero_iff j Y))
+
+/-- Actual extinction/survival pair required by the main theorem, on one fixed A. -/
+theorem extinction (m : ℕ) [NeZero m] :
+    IsZero (SelectedBaseIterates.object (FiniteSelectionFamily.test m) (2*m)) ∧
+      ¬ IsZero (SelectedBaseIterates.object (FiniteSelectionFamily.test m) (2*m-2)) := by
+  constructor
+  · exact (isZero_iff (FiniteSelectionFamily.test m) m).mpr (selectionIterate_test_subsingleton m)
+  · have hm := NeZero.pos m
+    have he : 2*m-2 = 2*(m-1) := by omega
+    rw [he]
+    intro hz
+    exact @not_subsingleton _ (selectionIterate_test_nontrivial m (m-1) (by omega))
+      ((isZero_iff (FiniteSelectionFamily.test m) (m-1)).mp hz)
+end LittleFinitistic.SelectedOrdinaryOrbit
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Selected/SelectedOrdinaryResolution.lean b/lean/OAI/Algebra/Finitistic/Selected/SelectedOrdinaryResolution.lean
new file mode 100644
index 0000000000000000000000000000000000000000..e33397c50a3a4b88e00d505be19f34db430bd82d
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Selected/SelectedOrdinaryResolution.lean
@@ -0,0 +1,37 @@
+import OAI.Algebra.Finitistic.Selected.SelectedOrdinaryAlgebra
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryXDerivedTensor
+
+namespace OAI
+noncomputable section
+open CategoryTheory CategoryTheory.Limits
+namespace LittleFinitistic.SelectedOrdinaryResolution
+open SelectedOrdinaryAlgebra
+
+/-- The one fixed genuine D-bimodule resolution Q_X used by the source. -/
+abbrev complex := OrdinarySimulation.XResolution.complex SelectedRectification.bimodule a length
+abbrev target := OrdinarySimulation.XResolution.ordinaryXObject SelectedRectification.bimodule a length
+abbrev augmentation := OrdinarySimulation.XResolution.augmentationToX
+  SelectedRectification.bimodule a length
+
+theorem augmentation_quasiIso : QuasiIso augmentation :=
+  OrdinarySimulation.XResolution.augmentationToX_quasiIso SelectedRectification.bimodule a length
+
+theorem right_projective (n : ℤ) : Module.Projective Dᵐᵒᵖ
+    (BimoduleCoefficients ℂ D D (complex.X n)) :=
+  OrdinarySimulation.XResolution.right_projective SelectedRectification.bimodule a length n
+
+theorem bounded (n : ℤ) (hn : n < -(length : ℤ) ∨ 0 < n) : IsZero (complex.X n) :=
+  OrdinarySimulation.XResolution.vanishes SelectedRectification.bimodule a length n hn
+
+local instance : HasDerivedCategory.{1} (ModuleCat.{0} D) :=
+  HasDerivedCategory.standard (ModuleCat.{0} D)
+
+/-- Tensor via the actual bounded right-projective Q_X, with the left D-action retained. -/
+abbrev derived := OrdinarySimulation.XResolution.derivedTensor SelectedRectification.bimodule a length
+abbrev comparison := OrdinarySimulation.XResolution.derivedTensorComparison
+  SelectedRectification.bimodule a length
+end LittleFinitistic.SelectedOrdinaryResolution
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Selected/SelectedPDBarConsumer.lean b/lean/OAI/Algebra/Finitistic/Selected/SelectedPDBarConsumer.lean
new file mode 100644
index 0000000000000000000000000000000000000000..65f89923d4c818774cf29a6612a152c08412f0ba
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Selected/SelectedPDBarConsumer.lean
@@ -0,0 +1,44 @@
+import OAI.Algebra.Finitistic.Selected.SelectedPDDetection
+import OAI.Algebra.Finitistic.Dimension.PDBaseBarConsumer
+
+namespace OAI
+noncomputable section
+open CategoryTheory CategoryTheory.Limits
+namespace LittleFinitistic.SelectedPDDetection
+open SelectedOrdinaryAlgebra SelectedOrdinaryModules
+
+/-- The literal two-sided bar over the one fixed square-zero algebra. -/
+abbrev baseBar (Y : FiniteSelectionFamily.S.{0}) :=
+  DerivedBar.twoSidedComplex ℂ A D (Inflated Y) augmentation
+
+/-- Actual Tor at the native bar model, using the canonical augmentation. -/
+def torIsoBaseBar (Y : FiniteSelectionFamily.S.{0}) (n : ℕ) :
+    PDTensor.Tor (k := ℂ) (PDBarQuotient.RightBase augmentation) (module Y) n ≅
+      (((ModuleCat.restrictScalars (algebraMap ℂ D)).mapHomologicalComplex _).obj
+        (baseBar Y)).homology n :=
+  PDBarQuotient.torIsoTwoSided augmentation (Inflated Y) n
+
+theorem lower_bound_of_base_bar (Y : FiniteSelectionFamily.S.{0})
+    (r n : ℕ) (hrn : r ≤ n) (h : ¬ IsZero ((baseBar Y).homology n)) :
+    r ≤ projectiveDimension (module Y) :=
+  PDBarQuotient.lower_bound_of_base_bar augmentation (Inflated Y) r n hrn h
+
+local instance : HasDerivedCategory.{1} (ModuleCat.{0} D) :=
+  HasDerivedCategory.standard (ModuleCat.{0} D)
+
+/-- Native supplies its actual D-linear derived splitting and the surviving
+summand's cohomology. The detector constructs the projective-dimension bound. -/
+theorem lower_bound_of_base_derived_bar (Y : FiniteSelectionFamily.S.{0})
+    (Z T : DerivedCategory (ModuleCat.{0} D))
+    (e : PDBarQuotient.baseDerived augmentation (Inflated Y) ≅ Z)
+    (i : T ⟶ Z) (p : Z ⟶ T) (hip : i ≫ p = 𝟙 T)
+    (r n : ℕ) (hrn : r ≤ n)
+    (h : ¬ IsZero ((DerivedCategory.homologyFunctor (ModuleCat D) (-(n : ℤ))).obj T)) :
+    r ≤ projectiveDimension (module Y) :=
+  PDBarQuotient.lower_bound_of_base_derived_retract augmentation (Inflated Y)
+    Z T e i p hip r n hrn h
+end LittleFinitistic.SelectedPDDetection
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Selected/SelectedPDConclusion.lean b/lean/OAI/Algebra/Finitistic/Selected/SelectedPDConclusion.lean
new file mode 100644
index 0000000000000000000000000000000000000000..8dd69355d0919b2590a4715c4a505136f20b3a83
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Selected/SelectedPDConclusion.lean
@@ -0,0 +1,58 @@
+import OAI.Algebra.Finitistic.Selected.SelectedPDUpperConsumer
+import OAI.Algebra.Finitistic.Bar.CountTorBounds
+import OAI.Algebra.Finitistic.Selected.SelectedCountExtinction
+
+namespace OAI
+noncomputable section
+open CategoryTheory CategoryTheory.Limits
+namespace LittleFinitistic.SelectedPDConclusion
+open SelectedOrdinaryAlgebra SelectedOrdinaryModules
+local instance : HasDerivedCategory.{1} (ModuleCat.{0} D) :=
+  HasDerivedCategory.standard (ModuleCat.{0} D)
+
+/-- The canonical base-change Tor is computed by the actual selected bar,
+independently of which compatible field-scalar instance presents that bar. -/
+def baseTorIso (Y : FiniteSelectionFamily.S.{0}) (n : ℕ) :
+    ((DerivedBar.Balanced.tensorFunctor augmentation).leftDerived n).obj (module Y) ≅
+      (SelectedPDDetection.baseBar Y).homology n :=
+  DerivedBar.Balanced.tensorBarHomologyIso augmentation (Inflated Y) n ≪≫
+    (HomologicalComplex.homologyFunctor (ModuleCat D) (.down ℕ) n).mapIso
+      (DerivedBar.tensorBarIso ℂ A D (Inflated Y) augmentation)
+
+/-- Actual tensor extinction implies finite projective dimension over the
+one fixed square-zero algebra A. The bar bounds and minimal detector are proved. -/
+theorem finite_pd_of_extinction (Y : FiniteSelectionFamily.S.{0}) (t : ℕ)
+    (h : IsZero (SelectedBaseIterates.object Y t)) :
+    projectiveDimension (module Y) < ⊤ := by
+  apply SelectedPDDetection.finite_pd_of_bounded_base_bar Y
+  refine ⟨t * (3 * length + 5), fun n hn => ?_⟩
+  have hc := DerivedBar.ParityBridge.baseChangeTor_bounded_of_counts ℂ D X
+    (SelectedBaseIterates.input Y) (t * (3 * length + 5))
+    (fun r n hn => SelectedCountExtinction.uniform_homology_zero Y t h r (-(n : ℤ))
+      (Or.inl (by omega))) n hn
+  exact hc.of_iso (baseTorIso Y n).symm
+
+/-- A surviving actual derived iterate supplies a nonzero original count
+class and hence the manuscript's projective-dimension lower bound. -/
+theorem lower_bound_of_survival (Y : FiniteSelectionFamily.S.{0}) (r : ℕ)
+    (h : ¬ IsZero (SelectedBaseIterates.object Y r)) :
+    (r : WithBot ℕ∞) ≤ projectiveDimension (module Y) := by
+  obtain ⟨n,hrn,_,hn⟩ := SelectedCountCohomology.nonzero_degree Y r h
+  have hc := DerivedBar.ParityBridge.baseChangeTor_nonzero_of_count ℂ D X
+    (SelectedBaseIterates.input Y) r n hn
+  apply SelectedPDDetection.lower_bound_of_base_bar Y r n hrn
+  intro hz
+  exact hc (hz.of_iso (baseTorIso Y n))
+
+/-- Both conclusions of the manuscript's projective-dimension detector for
+the actual finite selected family; no bar comparison or pd bound is a premise. -/
+theorem detection (Y : FiniteSelectionFamily.S.{0}) :
+    (∀ t, IsZero (SelectedBaseIterates.object Y t) → projectiveDimension (module Y) < ⊤) ∧
+    (∀ r, ¬ IsZero (SelectedBaseIterates.object Y r) →
+      (r : WithBot ℕ∞) ≤ projectiveDimension (module Y)) :=
+  ⟨finite_pd_of_extinction Y, lower_bound_of_survival Y⟩
+end LittleFinitistic.SelectedPDConclusion
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Selected/SelectedPDDetection.lean b/lean/OAI/Algebra/Finitistic/Selected/SelectedPDDetection.lean
new file mode 100644
index 0000000000000000000000000000000000000000..da7eefd9bd5c633b308de7606173950d28060f73
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Selected/SelectedPDDetection.lean
@@ -0,0 +1,77 @@
+import OAI.Algebra.Finitistic.Dimension.PDResidueScalar
+import OAI.Algebra.Finitistic.Selected.SelectedBarResolution
+import OAI.Algebra.Finitistic.Selected.SelectedMinimalResolution
+import OAI.Algebra.Finitistic.Dimension.PDBarDetection
+import OAI.Algebra.Finitistic.Dimension.PDDerivedBarConsumer
+import OAI.Algebra.Finitistic.Dimension.PDSquareZeroResidue
+
+namespace OAI
+noncomputable section
+open CategoryTheory CategoryTheory.Limits
+namespace LittleFinitistic.SelectedPDDetection
+open SelectedOrdinaryAlgebra SelectedOrdinaryModules
+
+instance residueModuleK : Module ℂ (PDTensor.Residue (A := A)) := PDResidueScalar.moduleK ℂ A
+instance residueTowerK : IsScalarTower ℂ Aᵐᵒᵖ (PDTensor.Residue (A := A)) := PDResidueScalar.towerK ℂ A
+
+open SelectedMinimalResolution (finiteModule)
+
+abbrev barTensor (Y : FiniteSelectionFamily.S.{0})
+    (U : Type) [AddCommGroup U] [Module ℂ U] [Module Aᵐᵒᵖ U] :=
+  PDBar.tensorComplex (finiteModule Y) U (SelectedBarResolution.resolution Y)
+
+def torIsoBar (Y : FiniteSelectionFamily.S.{0})
+    (U : Type) [AddCommGroup U] [Module ℂ U] [Module Aᵐᵒᵖ U] (n : ℕ) :
+    PDTensor.Tor (k := ℂ) U (module Y) n ≅ (barTensor Y U).homology n :=
+  PDBar.torIsoResolution (finiteModule Y) U (SelectedBarResolution.resolution Y) n
+
+theorem pdLE_iff_residue_bar (Y : FiniteSelectionFamily.S.{0}) (n : ℕ) :
+    HasProjectiveDimensionLE (module Y) n ↔
+      IsZero ((barTensor Y (PDTensor.Residue (A := A))).homology (n+1)) :=
+  PDBar.pdLE_iff_residue_resolution (finiteModule Y) (SelectedBarResolution.resolution Y) n
+
+theorem pdLE_iff_simple_bar (Y : FiniteSelectionFamily.S.{0}) (n : ℕ) :
+    HasProjectiveDimensionLE (module Y) n ↔
+      ∀ S : Submodule Aᵐᵒᵖ (PDTensor.Residue (A := A)), IsSimpleModule Aᵐᵒᵖ S →
+        IsZero ((barTensor Y S).homology (n+1)) :=
+  PDBar.pdLE_iff_simple_resolution (finiteModule Y) (SelectedBarResolution.resolution Y) n
+
+theorem finite_pd_of_bar (Y : FiniteSelectionFamily.S.{0})
+    (h : ∃ b : ℕ, ∀ n, b < n →
+      IsZero ((barTensor Y (PDTensor.Residue (A := A))).homology n)) :
+    projectiveDimension (module Y) < ⊤ :=
+  PDTensor.finite_pd_of_resolution (finiteModule Y) (SelectedBarResolution.resolution Y) h
+
+theorem lower_bound_of_bar (Y : FiniteSelectionFamily.S.{0})
+    (U : Type) [AddCommGroup U] [Module ℂ U] [Module Aᵐᵒᵖ U]
+    (r n : ℕ) (hrn : r ≤ n) (h : ¬ IsZero ((barTensor Y U).homology n)) :
+    r ≤ projectiveDimension (module Y) :=
+  PDTensor.lower_bound_of_resolution (finiteModule Y) U
+    (SelectedBarResolution.resolution Y) r n hrn h
+
+local instance : HasDerivedCategory.{1} (ModuleCat.{0} ℂ) :=
+  HasDerivedCategory.standard (ModuleCat.{0} ℂ)
+
+theorem finite_pd_of_derived_bar (Y : FiniteSelectionFamily.S.{0})
+    (Z : DerivedCategory (ModuleCat.{0} ℂ))
+    (e : PDBar.derivedObject (barTensor Y (PDTensor.Residue (A := A))) ≅ Z)
+    (h : ∃ b : ℕ, ∀ n, b < n → IsZero
+      ((DerivedCategory.homologyFunctor (ModuleCat ℂ) (-(n : ℤ))).obj Z)) :
+    projectiveDimension (module Y) < ⊤ :=
+  PDBar.finite_pd_of_derived_iso (finiteModule Y) (SelectedBarResolution.resolution Y) Z e h
+
+theorem lower_bound_of_derived_bar (Y : FiniteSelectionFamily.S.{0})
+    (U : Type) [AddCommGroup U] [Module ℂ U] [Module Aᵐᵒᵖ U]
+    (Z T : DerivedCategory (ModuleCat.{0} ℂ))
+    (e : PDBar.derivedObject (barTensor Y U) ≅ Z)
+    (i : T ⟶ Z) (p : Z ⟶ T) (hip : i ≫ p = 𝟙 T)
+    (r n : ℕ) (hrn : r ≤ n)
+    (h : ¬ IsZero ((DerivedCategory.homologyFunctor (ModuleCat ℂ) (-(n : ℤ))).obj T)) :
+    r ≤ projectiveDimension (module Y) :=
+  PDBar.lower_bound_of_derived_retract (finiteModule Y) (SelectedBarResolution.resolution Y)
+    U Z T e i p hip r n hrn h
+end LittleFinitistic.SelectedPDDetection
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Selected/SelectedPDResidueProjection.lean b/lean/OAI/Algebra/Finitistic/Selected/SelectedPDResidueProjection.lean
new file mode 100644
index 0000000000000000000000000000000000000000..3633b993ca539ecc7f9b5f646ccb4cd4a6fd4ac9
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Selected/SelectedPDResidueProjection.lean
@@ -0,0 +1,37 @@
+import OAI.Algebra.Finitistic.Selected.SelectedPDDetection
+import OAI.Algebra.Finitistic.Dimension.PDResidueProjection
+
+namespace OAI
+noncomputable section
+open CategoryTheory CategoryTheory.Limits
+namespace LittleFinitistic.SelectedPDDetection
+open SelectedOrdinaryAlgebra SelectedOrdinaryModules
+
+theorem augmentation_surjective : Function.Surjective augmentation :=
+  fun d => ⟨TrivSqZeroExt.inl d, rfl⟩
+
+theorem augmentation_kernel_square_zero :
+    ∀ a ∈ RingHom.ker augmentation.toRingHom, ∀ b ∈ RingHom.ker augmentation.toRingHom, a*b=0 :=
+  fun a ha b hb => PDSquareZero.kernel_square_zero X a b ha hb
+
+/-- The detector's canonical residue is the right D-residue inflated along A → D. -/
+def rightResidueEquiv : PDTensor.Residue (A := A) ≃ₗ[Aᵐᵒᵖ]
+    PDResidueProjection.InflatedResidue augmentation :=
+  PDResidueProjection.rightEquiv augmentation augmentation_surjective augmentation_kernel_square_zero
+
+def residueTorIso (Y : FiniteSelectionFamily.S.{0}) (n : ℕ) :
+    PDTensor.Tor (k := ℂ) (PDTensor.Residue (A := A)) (module Y) n ≅
+      PDTensor.Tor (k := ℂ) (PDResidueProjection.InflatedResidue augmentation) (module Y) n :=
+  PDResidueProjection.torIso augmentation augmentation_surjective augmentation_kernel_square_zero
+    (module Y) (SelectedBarResolution.resolution Y) n
+
+theorem pdLE_iff_inflated_D_residueTor (Y : FiniteSelectionFamily.S.{0}) (n : ℕ) :
+    HasProjectiveDimensionLE (module Y) n ↔ IsZero
+      (PDTensor.Tor (k := ℂ) (PDResidueProjection.InflatedResidue augmentation) (module Y) (n+1)) :=
+  (PDTensor.pdLE_iff_residueTor_zero (SelectedMinimalResolution.finiteModule Y) n).trans
+    (residueTorIso Y (n+1)).isZero_iff
+end LittleFinitistic.SelectedPDDetection
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Selected/SelectedPDUpperConsumer.lean b/lean/OAI/Algebra/Finitistic/Selected/SelectedPDUpperConsumer.lean
new file mode 100644
index 0000000000000000000000000000000000000000..0ac9a16a215e994926d1c55b33c8ae622d38dc57
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Selected/SelectedPDUpperConsumer.lean
@@ -0,0 +1,69 @@
+import OAI.Algebra.Finitistic.Selected.SelectedPDResidueProjection
+import OAI.Algebra.Finitistic.Selected.SelectedOrdinaryDimension
+import OAI.Algebra.Finitistic.Dimension.PDResidueBaseBar
+import OAI.Algebra.Finitistic.Selected.SelectedCountPDConsumer
+
+namespace OAI
+noncomputable section
+open CategoryTheory CategoryTheory.Limits
+namespace LittleFinitistic.SelectedPDDetection
+open SelectedOrdinaryAlgebra SelectedOrdinaryModules
+local instance : HasDerivedCategory.{1} (ModuleCat.{0} D) :=
+  HasDerivedCategory.standard (ModuleCat.{0} D)
+
+/-- Exact scalar/action-preserving identification with the source of the
+bar worker's actual derived splitting. -/
+def tensorBarDerivedIso (Y : FiniteSelectionFamily.S.{0}) :
+    (DerivedBar.integerQ D).obj
+      (DerivedBar.tensorBarComplex ℂ A D (Inflated Y) augmentation) ≅
+        PDBarQuotient.baseDerived augmentation (Inflated Y) :=
+  (DerivedBar.integerQ D).mapIso
+    (DerivedBar.tensorBarIso ℂ A D (Inflated Y) augmentation)
+
+/-- For the fixed actual A and Inflated Y, bounded actual D-bar homology
+implies finite projective dimension, using the proved global dimension of D. -/
+theorem finite_pd_of_bounded_base_bar (Y : FiniteSelectionFamily.S.{0})
+    (h : ∃ b : ℕ, ∀ n, b < n → IsZero
+      ((DerivedBar.twoSidedComplex ℂ A D (Inflated Y) augmentation).homology n)) :
+    projectiveDimension (module Y) < ⊤ :=
+  PDResidueAssociativity.finite_pd_of_bounded_base_bar augmentation (Inflated Y)
+    augmentation_surjective augmentation_kernel_square_zero
+    SelectedOrdinaryDimension.bound SelectedOrdinaryDimension.left_module h
+
+/-- Consumer of a supplied actual D-derived bar splitting with bounded target. -/
+theorem finite_pd_of_base_derived_splitting (Y : FiniteSelectionFamily.S.{0})
+    (Z : DerivedCategory (ModuleCat.{0} D))
+    (e : PDBarQuotient.baseDerived augmentation (Inflated Y) ≅ Z)
+    (h : ∃ b : ℕ, ∀ n, b < n → IsZero
+      ((DerivedCategory.homologyFunctor (ModuleCat D) (-(n : ℤ))).obj Z)) :
+    projectiveDimension (module Y) < ⊤ :=
+  PDResidueAssociativity.finite_pd_of_base_derived_iso augmentation (Inflated Y)
+    augmentation_surjective augmentation_kernel_square_zero
+    SelectedOrdinaryDimension.bound SelectedOrdinaryDimension.left_module Z e h
+
+/-- Direct consumer whose source is literally the bar worker's integerQ value. -/
+theorem finite_pd_of_tensor_bar_splitting (Y : FiniteSelectionFamily.S.{0})
+    (Z : DerivedCategory (ModuleCat.{0} D))
+    (e : (DerivedBar.integerQ D).obj
+      (DerivedBar.tensorBarComplex ℂ A D (Inflated Y) augmentation) ≅ Z)
+    (h : ∃ b : ℕ, ∀ n, b < n → IsZero
+      ((DerivedCategory.homologyFunctor (ModuleCat D) (-(n : ℤ))).obj Z)) :
+    projectiveDimension (module Y) < ⊤ :=
+  finite_pd_of_base_derived_splitting Y Z ((tensorBarDerivedIso Y).symm ≪≫ e) h
+
+/-- The count retract can likewise be supplied at the bar worker's exact source. -/
+theorem lower_bound_of_tensor_bar_count (Y : FiniteSelectionFamily.S.{0}) (r : ℕ)
+    (h : ¬ IsZero (SelectedBaseIterates.object Y r))
+    (i : SelectedCountCohomology.count Y r ⟶ (DerivedBar.integerQ D).obj
+      (DerivedBar.tensorBarComplex ℂ A D (Inflated Y) augmentation))
+    (p : (DerivedBar.integerQ D).obj
+      (DerivedBar.tensorBarComplex ℂ A D (Inflated Y) augmentation) ⟶ SelectedCountCohomology.count Y r)
+    (hip : i ≫ p = 𝟙 _) : r ≤ projectiveDimension (module Y) := by
+  apply lower_bound_of_surviving_count Y r h (i ≫ (tensorBarDerivedIso Y).hom)
+    ((tensorBarDerivedIso Y).inv ≫ p)
+  simpa only [Category.assoc, Iso.hom_inv_id_assoc] using hip
+end LittleFinitistic.SelectedPDDetection
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Selected/SelectedRealization.lean b/lean/OAI/Algebra/Finitistic/Selected/SelectedRealization.lean
new file mode 100644
index 0000000000000000000000000000000000000000..e4b091091058427ff2770aac48518ea493204fd7
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Selected/SelectedRealization.lean
@@ -0,0 +1,81 @@
+import OAI.Algebra.Finitistic.Selected.SelectedReferenceCohomology
+import OAI.Algebra.Finitistic.Selected.SelectedTensorSplitting
+import OAI.Algebra.Finitistic.Selected.SelectedChainAction
+
+namespace OAI
+noncomputable section
+open CategoryTheory CategoryTheory.Limits HomologicalComplex
+attribute [local instance] HasDerivedCategory.standard HasExt.standard
+namespace LittleFinitistic.SelectedRealization
+open SelectedFixedDiagram QuadraticEncoding SelectedNativeEvaluation
+variable {Y : Type} [AddCommGroup Y] [Module ℂ Y] [FiniteDimensional ℂ Y]
+  [Module SelectionRing Y] [IsScalarTower ℂ SelectionRing Y]
+
+local instance selectedModule : Module SelectionRing (H (Y := Y)) :=
+  inferInstanceAs (Module SelectionRing (selectionStep (ModuleCat.of SelectionRing Y)))
+local instance selectedTower : IsScalarTower ℂ SelectionRing (H (Y := Y)) :=
+  IsScalarTower.of_algebraMap_smul (fun _ _ => rfl)
+
+abbrev input := (SelectedChainHomology.representation (Y := Y)).Evaluation
+abbrev selectedRepresentation := SourceActionEvaluation.representation (Y := H (Y := Y)) encoding
+abbrev reference := EvaluationVertexDiagram.module (selectedRepresentation (Y := Y))
+
+omit [FiniteDimensional ℂ Y] in
+lemma selected_action (a : Fin (encoding.generators+1)) :
+    EvaluationVertexDiagram.action (Y := H (Y := Y)) (selectedRepresentation (Y := Y)) a =
+      HAction (Y := Y) (RelationBasisAction.arrow (SelectionEncoding.generator encoding) a) := by
+  apply ModuleCat.hom_ext
+  apply LinearMap.ext
+  intro x
+  rw [HAction_apply]
+  refine Fin.cases ?_ (fun j => ?_) a
+  · change x = (1 : SelectionRing) • x
+    rw [one_smul]
+  · rfl
+
+def coordinates (n : ℤ) (hn : n = 0 ∨ n = -3) :
+    ∀ v : Fin 3, (SelectedTensor.source (input (Y := Y)) v).homology n ≅ H (Y := Y) :=
+  Fin.cases (SelectedChainHomology.D0Iso n hn)
+    (Fin.cases (SelectedChainHomology.D1Iso n hn)
+      (fun _ => SelectedChainHomology.D2Iso n hn))
+
+lemma coordinates01 (a : Fin (encoding.generators+1)) (n : ℤ) (hn : n = 0 ∨ n = -3) :
+    homologyMap (((BalancedTensor.tensorFunctor ℂ (B P) (input (Y := Y))).mapHomologicalComplex (.up ℤ)).map
+      (SelectedRectification.f a)) n ≫ (coordinates (Y := Y) n hn 1).hom =
+      (coordinates (Y := Y) n hn 0).hom ≫ EvaluationVertexDiagram.action (Y := H (Y := Y)) (selectedRepresentation (Y := Y)) a := by
+  erw [selected_action (Y := Y)]
+  exact SelectedChainHomology.fixed_arrow01 a n hn
+
+lemma coordinates12 (a : Fin (encoding.generators+1)) (n : ℤ) (hn : n = 0 ∨ n = -3) :
+    homologyMap (((BalancedTensor.tensorFunctor ℂ (B P) (input (Y := Y))).mapHomologicalComplex (.up ℤ)).map
+      (SelectedRectification.g a)) n ≫ (coordinates (Y := Y) n hn 2).hom =
+      (coordinates (Y := Y) n hn 1).hom ≫ EvaluationVertexDiagram.action (Y := H (Y := Y)) (selectedRepresentation (Y := Y)) a := by
+  erw [selected_action (Y := Y)]
+  exact SelectedChainHomology.fixed_arrow12 a n hn
+
+/-- The entire cohomology B-module is the manuscript's M(H(Y)), in both degrees. -/
+def cohomology (n : ℤ) (hn : n = 0 ∨ n = -3) :
+    (SelectedTensor.complex (input (Y := Y))).homology n ≅ reference (Y := Y) :=
+  SelectedReferenceCohomology.iso _ (selectedRepresentation (Y := Y)) n (coordinates (Y := Y) n hn)
+    (fun a => coordinates01 a n hn) (fun a => coordinates12 a n hn)
+
+lemma source_zero (n : ℤ) (hn0 : n ≠ 0) (hn3 : n ≠ -3) (v : Fin 3) :
+    IsZero ((SelectedTensor.source (input (Y := Y)) v).homology n) := by
+  fin_cases v
+  · exact SelectedChainHomology.D0_zero n hn0 hn3
+  · exact SelectedChainHomology.D1_zero n hn0 hn3
+  · exact SelectedChainHomology.D2_zero n hn0 hn3
+
+/-- The one fixed selecting bimodule realizes H on every finite-dimensional Y.
+This is an isomorphism in the full B-module derived category. -/
+def realization :
+    SelectedTensorSplitting.object (input (Y := Y)) ≅
+      (DerivedCategory.singleFunctor (ModuleCat (B P)) 0).obj (reference (Y := Y)) ⊞
+        ((DerivedCategory.singleFunctor (ModuleCat (B P)) 0).obj (reference (Y := Y)))⟦(3 : ℤ)⟧ :=
+  SelectedTensorSplitting.split _ _ (cohomology 0 (Or.inl rfl))
+    (cohomology (-3) (Or.inr rfl)) source_zero
+end LittleFinitistic.SelectedRealization
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Selected/SelectedRectification.lean b/lean/OAI/Algebra/Finitistic/Selected/SelectedRectification.lean
new file mode 100644
index 0000000000000000000000000000000000000000..3d7f1e3e2745fb415a2abef5363a2583611ce7cc
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Selected/SelectedRectification.lean
@@ -0,0 +1,49 @@
+import OAI.Algebra.Finitistic.Selected.SelectedChainDiagram
+import OAI.Algebra.Finitistic.Rectification.RectificationLemma
+import OAI.Algebra.Finitistic.Localization.UnderlyingRepresentatives
+
+namespace OAI
+noncomputable section
+open CategoryTheory CategoryTheory.Limits HomologicalComplex
+namespace LittleFinitistic.SelectedRectification
+open SelectedFixedDiagram ExternalTensor.Section4 RelationBasisCoefficients
+
+abbrev D0 := UnderlyingRepresentatives.complex P fixed.D0
+abbrev D1 := UnderlyingRepresentatives.complex P fixed.D1
+abbrev D2 := UnderlyingRepresentatives.complex P fixed.D2
+abbrev F := (UnderlyingRepresentatives.forget P).mapHomologicalComplex (.up ℤ)
+def f (a : Fin (encoding.generators+1)) : D0 ⟶ D1 := F.map (SelectedChainDiagram.fixedChain.f a)
+def g (b : Fin (encoding.generators+1)) : D1 ⟶ D2 := F.map (SelectedChainDiagram.fixedChain.g b)
+def relations (r : RelationIndex P) :
+    Homotopy (relationMap (ConcreteQuadraticDiagram.quadratic P) D0 D1 D2 f g r) 0 :=
+  UnderlyingRepresentatives.relationHomotopy P (encoding.generators+1) (encoding.generators+1)
+    (Module.finrank ℂ (QuadraticEncoding.relationSpace P)) fixed.D0 fixed.D1 fixed.D2
+    SelectedChainDiagram.fixedChain.f SelectedChainDiagram.fixedChain.g (basisCoefficient P)
+    SelectedChainDiagram.fixedChain.homotopy r
+
+/-- One explicit bimodule complex chosen before any evaluation module. -/
+def bimodule : BiComplex ℂ (QuadraticEncoding.B P) :=
+  InducedRectification.total (ConcreteQuadraticDiagram.quadratic P) D0 D1 D2 f g relations
+
+/-- The single fixed selecting complex satisfies the full rectification lemma,
+including all original vertex and arrow maps, independently of Y. -/
+theorem verified : ∃ lo hi : ℤ, RectificationLemma.Verified P D0 D1 D2 f g relations lo hi := by
+  obtain ⟨l₀,h₀,b₀⟩ := UnderlyingRepresentatives.bounded P fixed.D0
+  obtain ⟨l₁,h₁,b₁⟩ := UnderlyingRepresentatives.bounded P fixed.D1
+  obtain ⟨l₂,h₂,b₂⟩ := UnderlyingRepresentatives.bounded P fixed.D2
+  let lo := min l₀ (min l₁ l₂)
+  let hi := max h₀ (max h₁ h₂)
+  refine ⟨lo,hi,RectificationLemma.rectification P D0 D1 D2 f g relations lo hi
+    (fun n hn => b₀ n ?_) (fun n hn => b₁ n ?_) (fun n hn => b₂ n ?_)
+    (UnderlyingRepresentatives.projective P fixed.D0)
+    (UnderlyingRepresentatives.projective P fixed.D1)
+    (UnderlyingRepresentatives.projective P fixed.D2)
+    (UnderlyingRepresentatives.finite P fixed.D0)
+    (UnderlyingRepresentatives.finite P fixed.D1)
+    (UnderlyingRepresentatives.finite P fixed.D2)⟩
+  all_goals dsimp [lo,hi] at hn; omega
+end LittleFinitistic.SelectedRectification
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Selected/SelectedReferenceCohomology.lean b/lean/OAI/Algebra/Finitistic/Selected/SelectedReferenceCohomology.lean
new file mode 100644
index 0000000000000000000000000000000000000000..56a31576aef69d9d39afcf6568ff2f49ff3c7181
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Selected/SelectedReferenceCohomology.lean
@@ -0,0 +1,50 @@
+import OAI.Algebra.Finitistic.Selected.SelectedCohomologyAssembly
+import OAI.Algebra.Finitistic.Localization.EvaluationVertexDiagram
+
+namespace OAI
+noncomputable section
+open CategoryTheory HomologicalComplex
+namespace LittleFinitistic.SelectedReferenceCohomology
+open SelectedFixedDiagram SelectedRectification QuadraticEncoding
+
+private lemma transfer_to_vertices {C : Type*} [Category C]
+    {A₀ A₁ B₀ B₁ Y₀ Y₁ : C} (f : A₀ ⟶ A₁) (g : B₀ ⟶ B₁) (h : Y₀ ⟶ Y₁)
+    (e₀ : A₀ ≅ Y₀) (e₁ : A₁ ≅ Y₁) (v₀ : B₀ ≅ Y₀) (v₁ : B₁ ≅ Y₁)
+    (hf : f ≫ e₁.hom = e₀.hom ≫ h) (hg : g ≫ v₁.hom = v₀.hom ≫ h) :
+    f ≫ (e₁ ≪≫ v₁.symm).hom = (e₀ ≪≫ v₀.symm).hom ≫ g := by
+  apply (cancel_mono v₁.hom).1
+  simp only [Iso.trans_hom, Iso.symm_hom, Category.assoc, Iso.inv_hom_id,
+    Category.comp_id]
+  rw [hg, Iso.inv_hom_id_assoc]
+  exact hf
+
+variable (N : Type) [AddCommGroup N] [Module ℂ N] [Module (B P) N]
+variable {Y : Type} [AddCommGroup Y] [Module ℂ Y] (X : Representation P Y)
+variable (n : ℤ) (E : ∀ v : Fin 3,
+  (SelectedTensor.source N v).homology n ≅ ModuleCat.of ℂ Y)
+
+/-- Identify the full tensor cohomology with the actual evaluation module from
+three coordinate models and their generator actions. -/
+def iso
+    (h01 : ∀ a,
+      homologyMap (((BalancedTensor.tensorFunctor ℂ (B P) N).mapHomologicalComplex (.up ℤ)).map (f a)) n ≫
+        (E 1).hom = (E 0).hom ≫ EvaluationVertexDiagram.action X a)
+    (h12 : ∀ b,
+      homologyMap (((BalancedTensor.tensorFunctor ℂ (B P) N).mapHomologicalComplex (.up ℤ)).map (g b)) n ≫
+        (E 2).hom = (E 1).hom ≫ EvaluationVertexDiagram.action X b) :
+    (SelectedTensor.complex N).homology n ≅ EvaluationVertexDiagram.module X := by
+  apply SelectedCohomologyAssembly.iso N n (EvaluationVertexDiagram.module X)
+    (fun v => E v ≪≫ (EvaluationVertexDiagram.vertexIso X v).symm)
+  · intro a
+    exact transfer_to_vertices _ _ _ (E 0) (E 1)
+      (EvaluationVertexDiagram.vertexIso X 0) (EvaluationVertexDiagram.vertexIso X 1)
+      (h01 a) (EvaluationVertexDiagram.arrow01_square X a (CanonicalArrowCompatibility.arrow01_target P a))
+  · intro b
+    exact transfer_to_vertices _ _ _ (E 1) (E 2)
+      (EvaluationVertexDiagram.vertexIso X 1) (EvaluationVertexDiagram.vertexIso X 2)
+      (h12 b) (EvaluationVertexDiagram.arrow12_square X b (CanonicalArrowCompatibility.arrow12_target P b))
+end LittleFinitistic.SelectedReferenceCohomology
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Selected/SelectedShiftedRealization.lean b/lean/OAI/Algebra/Finitistic/Selected/SelectedShiftedRealization.lean
new file mode 100644
index 0000000000000000000000000000000000000000..79617aa715d82b28047864bc2ac344dafded19d7
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Selected/SelectedShiftedRealization.lean
@@ -0,0 +1,80 @@
+import OAI.Algebra.Finitistic.Selected.SelectedOrdinaryAlgebra
+import OAI.Algebra.Finitistic.Selected.SelectedDerivedFunctor
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryShiftDerivedTensor
+
+namespace OAI
+noncomputable section
+open CategoryTheory CategoryTheory.Limits
+attribute [local instance] HasDerivedCategory.standard HasExt.standard
+namespace LittleFinitistic.SelectedShiftedRealization
+open SelectedFixedDiagram QuadraticEncoding SelectedOrdinaryAlgebra
+attribute [local instance] preservesBinaryBiproducts_of_preservesBiproducts
+
+/-- The actual shifted selecting bimodule, with its full B actions. -/
+abbrev shifted := SelectedRectification.bimodule⟦b⟧
+
+def model : BimoduleTotal.BoundedProjective ℂ (B P) shifted where
+  lower := -(length : ℤ)
+  upper := 0
+  bounded := OrdinarySimulation.shifted_support _ b length a endpoints support
+  projective n := by
+    exact SelectedOrdinaryAlgebra.term_projective (n+b)
+
+abbrev G := model.derived
+
+/-- Tensoring a selected stalk by the shifted fixed bimodule shifts the already
+verified full B-linear tensor complex. -/
+def comparison (Y : FiniteSelectionFamily.S.{0}) :
+    G.obj (FiniteSelectionFamily.derived Y) ≅
+      (SelectedTensorSplitting.object (FiniteSelectionFamily.representation Y).Evaluation)⟦b⟧ :=
+  model.nativeSingleEvaluation (FiniteSelectionFamily.representation Y).Evaluation ≪≫
+    DerivedCategory.Q.mapIso
+      ((((BimoduleBalancedTensor.functor ℂ (B P)
+        (FiniteSelectionFamily.representation Y).Evaluation).mapHomologicalComplex (.up ℤ)).commShiftIso b).app
+          SelectedRectification.bimodule) ≪≫
+    (DerivedCategory.Q.commShiftIso b).app _
+
+/-- The concrete two summands for one application of the actual shifted tensor. -/
+def realizationNested (Y : FiniteSelectionFamily.S.{0}) :
+    G.obj (FiniteSelectionFamily.derived Y) ≅
+      (FiniteSelectionFamily.derived (FiniteSelectionFamily.H Y))⟦b⟧ ⊞
+        ((FiniteSelectionFamily.derived (FiniteSelectionFamily.H Y))⟦(3 : ℤ)⟧)⟦b⟧ :=
+  comparison Y ≪≫ (shiftFunctor _ b).mapIso (FiniteSelectionFamily.realization Y) ≪≫
+    (shiftFunctor _ b).mapBiprod _ _
+
+/-- The source convention places the two summands in shifts b and b+3. -/
+def realization (Y : FiniteSelectionFamily.S.{0}) :
+    G.obj (FiniteSelectionFamily.derived Y) ≅
+      (FiniteSelectionFamily.derived (FiniteSelectionFamily.H Y))⟦b⟧ ⊞
+        (FiniteSelectionFamily.derived (FiniteSelectionFamily.H Y))⟦b+3⟧ :=
+  realizationNested Y ≪≫ biprod.mapIso (Iso.refl _)
+    ((shiftAdd _ (3 : ℤ) b).symm ≪≫ eqToIso (by rw [add_comm (3 : ℤ) b]))
+
+def iteration (j : ℕ) (Y : FiniteSelectionFamily.S.{0}) :
+    (G.obj^[j]) (FiniteSelectionFamily.derived Y) ≅
+      ExternalTensor.Binomial.binomialObject b 3 j
+        (FiniteSelectionFamily.derived ((FiniteSelectionFamily.H^[j]) Y)) :=
+  ExternalTensor.Binomial.binomialIteration G FiniteSelectionFamily.derived
+    FiniteSelectionFamily.H b 3 realization j Y
+
+theorem isZero_iff (j : ℕ) (Y : FiniteSelectionFamily.S.{0}) :
+    IsZero ((G.obj^[j]) (FiniteSelectionFamily.derived Y)) ↔
+      Subsingleton (selectionIterate Y.val j) :=
+  (ExternalTensor.Binomial.iteration_isZero_iff G FiniteSelectionFamily.derived
+    FiniteSelectionFamily.H b 3 realization j Y).trans
+    ((FiniteSelectionFamily.derived_zero _).trans
+      (by rw [FiniteSelectionFamily.iterate_val]))
+
+theorem extinction (m : ℕ) [NeZero m] :
+    (∀ j < m, ¬ IsZero ((G.obj^[j]) (FiniteSelectionFamily.derived (FiniteSelectionFamily.test m)))) ∧
+      IsZero ((G.obj^[m]) (FiniteSelectionFamily.derived (FiniteSelectionFamily.test m))) := by
+  constructor
+  · intro j hj hz
+    have hs := (isZero_iff j (FiniteSelectionFamily.test m)).mp hz
+    exact @not_subsingleton _ (selectionIterate_test_nontrivial m j hj) hs
+  · exact (isZero_iff m (FiniteSelectionFamily.test m)).mpr (selectionIterate_test_subsingleton m)
+end LittleFinitistic.SelectedShiftedRealization
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Selected/SelectedTargetHomology.lean b/lean/OAI/Algebra/Finitistic/Selected/SelectedTargetHomology.lean
new file mode 100644
index 0000000000000000000000000000000000000000..01d873622c5287690578597b0f2fd3e4ff14f8ba
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Selected/SelectedTargetHomology.lean
@@ -0,0 +1,145 @@
+import OAI.Algebra.Finitistic.Selected.SelectedTensorComparison
+import Mathlib.CategoryTheory.Preadditive.AdditiveFunctor
+import Mathlib.Algebra.Homology.DerivedCategory.TStructure
+import Mathlib.Algebra.Homology.DerivedCategory.FullyFaithful
+
+namespace OAI
+noncomputable section
+open CategoryTheory CategoryTheory.Limits
+attribute [local instance] HasDerivedCategory.standard
+namespace LittleFinitistic.SelectedTargetHomology
+open QuadraticEncoding SelectedNativeEvaluation FiniteProjectiveHomotopy
+universe v
+variable {Y : Type v} [AddCommGroup Y] [Module ℂ Y] [FiniteDimensional ℂ Y]
+  [Module SelectionRing Y] [IsScalarTower ℂ SelectionRing Y]
+abbrev C := ModuleCat.{v} ℂ
+abbrev I := derivedTargetInclusion.{0,v} (k := ℂ)
+abbrev cohomology (n : ℤ) := I ⋙ DerivedCategory.homologyFunctor C n
+instance (n : ℤ) : (cohomology.{v} n).Additive := by dsimp [cohomology]; infer_instance
+instance (n : ℤ) : PreservesBinaryBiproducts (cohomology.{v} n) :=
+  preservesBinaryBiproducts_of_preservesBiproducts _
+
+def stalkIso : I.obj (HDerived (Y := Y)) ≅
+    (DerivedCategory.singleFunctor C 0).obj (H (Y := Y)) := Iso.refl _
+def shiftedIso : I.obj ((HDerived (Y := Y))⟦(3 : ℤ)⟧) ≅
+    (DerivedCategory.singleFunctor C (-3)).obj (H (Y := Y)) :=
+  (I.commShiftIso (3 : ℤ)).app _ ≪≫
+    (shiftFunctor _ (3 : ℤ)).mapIso (stalkIso (Y := Y)) ≪≫
+      ((DerivedCategory.singleFunctors C).shiftIso 3 (-3) 0 (by norm_num)).app _
+
+def stalkHomologyIso : (cohomology 0).obj (HDerived (Y := Y)) ≅ H (Y := Y) :=
+  (DerivedCategory.homologyFunctor C 0).mapIso stalkIso ≪≫
+    (DerivedCategory.singleFunctorCompHomologyFunctorIso C 0).app _
+def shiftedHomologyIso : (cohomology (-3)).obj ((HDerived (Y := Y))⟦(3 : ℤ)⟧) ≅ H (Y := Y) :=
+  (DerivedCategory.homologyFunctor C (-3)).mapIso shiftedIso ≪≫
+    (DerivedCategory.singleFunctorCompHomologyFunctorIso C (-3)).app _
+
+lemma single_zero (M : C) (i n : ℤ) (hn : n ≠ i) :
+    IsZero ((DerivedCategory.homologyFunctor C n).obj
+      ((DerivedCategory.singleFunctor C i).obj M)) := by
+  rcases lt_or_gt_of_ne hn with h | h
+  · exact DerivedCategory.isZero_of_isGE _ i n h
+  · exact DerivedCategory.isZero_of_isLE _ i n h
+lemma stalk_zero (n : ℤ) (hn : n ≠ 0) :
+    IsZero ((cohomology n).obj (HDerived (Y := Y))) :=
+  ((DerivedCategory.homologyFunctor C n).mapIso (stalkIso (Y := Y))).isZero_iff.mpr
+    (single_zero _ _ _ hn)
+lemma shifted_zero (n : ℤ) (hn : n ≠ -3) :
+    IsZero ((cohomology n).obj ((HDerived (Y := Y))⟦(3 : ℤ)⟧)) :=
+  ((DerivedCategory.homologyFunctor C n).mapIso (shiftedIso (Y := Y))).isZero_iff.mpr
+    (single_zero _ _ _ hn)
+
+def targetH0 : (cohomology 0).obj (target (Y := Y)) ≅ H (Y := Y) :=
+  (cohomology 0).mapBiprod _ _ ≪≫
+    (isoBiprodZero (shifted_zero (Y := Y) 0 (by norm_num))).symm ≪≫ stalkHomologyIso
+
+def targetHm3 : (cohomology (-3)).obj (target (Y := Y)) ≅ H (Y := Y) :=
+  (cohomology (-3)).mapBiprod _ _ ≪≫
+    (isoZeroBiprod (stalk_zero (Y := Y) (-3) (by norm_num))).symm ≪≫ shiftedHomologyIso
+
+lemma target_zero (n : ℤ) (h0 : n ≠ 0) (hm : n ≠ -3) :
+    IsZero ((cohomology n).obj (target (Y := Y))) :=
+  ((cohomology n).mapBiprod _ _).isZero_iff.mpr
+    ((biprod_isZero_iff _ _).mpr ⟨stalk_zero n h0,shifted_zero n hm⟩)
+
+lemma stalkHomologyIso_hom : (stalkHomologyIso (Y := Y)).hom =
+    ((DerivedCategory.singleFunctorCompHomologyFunctorIso C 0).app (H (Y := Y))).hom := by
+  change (DerivedCategory.homologyFunctor C 0).map
+    (𝟙 ((DerivedCategory.singleFunctor C 0).obj (H (Y := Y)))) ≫ _ = _
+  rw [CategoryTheory.Functor.map_id,Category.id_comp]
+
+lemma stalk_action (r : SelectionRing) :
+    (cohomology 0).map (HDerivedAction (Y := Y) r) ≫ (stalkHomologyIso (Y := Y)).hom =
+      (stalkHomologyIso (Y := Y)).hom ≫ HAction (Y := Y) r := by
+  rw [stalkHomologyIso_hom]
+  change (DerivedCategory.homologyFunctor C 0).map
+    (DerivedCategory.Qh.map ((inclusion ℂ).map (HKAction (Y := Y) r))) ≫ _ = _
+  dsimp only [HKAction]
+  erw [Functor.map_preimage]
+  change (DerivedCategory.homologyFunctor C 0).map
+    ((DerivedCategory.singleFunctor C 0).map (HAction (Y := Y) r)) ≫ _ = _
+  exact (DerivedCategory.singleFunctorCompHomologyFunctorIso C 0).hom.naturality
+    (HAction (Y := Y) r)
+
+lemma shifted_action (r : SelectionRing) :
+    (cohomology (-3)).map ((HDerivedAction (Y := Y) r)⟦(3 : ℤ)⟧') ≫
+      (shiftedHomologyIso (Y := Y)).hom =
+        (shiftedHomologyIso (Y := Y)).hom ≫ HAction (Y := Y) r := by
+  have hst : I.map (HDerivedAction (Y := Y) r) =
+      (DerivedCategory.singleFunctor C 0).map (HAction (Y := Y) r) := by
+    change DerivedCategory.Qh.map ((inclusion ℂ).map (HKAction (Y := Y) r)) = _
+    dsimp only [HKAction]
+    erw [Functor.map_preimage]
+    rfl
+  have hshift : I.map ((HDerivedAction (Y := Y) r)⟦(3 : ℤ)⟧') ≫ (shiftedIso (Y := Y)).hom =
+      (shiftedIso (Y := Y)).hom ≫
+        (DerivedCategory.singleFunctor C (-3)).map (HAction (Y := Y) r) := by
+    have h1 := (I.commShiftIso (3 : ℤ)).hom.naturality (HDerivedAction (Y := Y) r)
+    have h2 := ((DerivedCategory.singleFunctors C).shiftIso 3 (-3) 0 (by norm_num)).hom.naturality
+      (HAction (Y := Y) r)
+    dsimp only [Functor.comp_map] at h1 h2
+    rw [hst] at h1
+    have hh := (congrArg (fun f => f ≫
+      (((DerivedCategory.singleFunctors C).shiftIso 3 (-3) 0 (by norm_num)).app
+        (H (Y := Y))).hom) h1).trans
+      ((Category.assoc _ _ _).trans
+        (congrArg (fun g => (I.commShiftIso (3 : ℤ)).hom.app (HDerived (Y := Y)) ≫ g) h2))
+    dsimp only [shiftedIso, stalkIso, Iso.trans_hom, Functor.mapIso_hom, Iso.refl_hom]
+    erw [CategoryTheory.Functor.mapIso_hom, Iso.refl_hom,
+      CategoryTheory.Functor.map_id, Category.id_comp]
+    exact (Category.assoc _ _ _).symm.trans (hh.trans (Category.assoc _ _ _).symm)
+
+  have h := congrArg (DerivedCategory.homologyFunctor C (-3)).map hshift
+  simp only [Functor.map_comp] at h
+  have hn := (DerivedCategory.singleFunctorCompHomologyFunctorIso C (-3)).hom.naturality
+    (HAction (Y := Y) r)
+  dsimp only [Functor.comp_map,Functor.id_map] at hn
+  dsimp only [shiftedHomologyIso,Iso.trans_hom,Functor.mapIso_hom,cohomology,Functor.comp_map]
+  rw [← Category.assoc,h,Category.assoc]
+  exact (congrArg (fun g => (DerivedCategory.homologyFunctor C (-3)).map
+    (shiftedIso (Y := Y)).hom ≫ g) hn).trans (Category.assoc _ _ _).symm
+
+lemma targetH0_hom : (targetH0 (Y := Y)).hom =
+    (cohomology 0).map biprod.fst ≫ (stalkHomologyIso (Y := Y)).hom := by
+  simp [targetH0,isoBiprodZero]
+  erw [biprod.lift_fst_assoc]
+lemma targetHm3_hom : (targetHm3 (Y := Y)).hom =
+    (cohomology (-3)).map biprod.snd ≫ (shiftedHomologyIso (Y := Y)).hom := by
+  simp [targetHm3,isoZeroBiprod]
+  erw [biprod.lift_snd_assoc]
+
+lemma targetH0_action (r : SelectionRing) :
+    (cohomology 0).map (targetAction (Y := Y) r) ≫ (targetH0 (Y := Y)).hom =
+      (targetH0 (Y := Y)).hom ≫ HAction (Y := Y) r := by
+  rw [targetH0_hom,← Category.assoc,← Functor.map_comp]
+  simp only [targetAction,biprod.map_fst,Functor.map_comp,Category.assoc,stalk_action]
+lemma targetHm3_action (r : SelectionRing) :
+    (cohomology (-3)).map (targetAction (Y := Y) r) ≫ (targetHm3 (Y := Y)).hom =
+      (targetHm3 (Y := Y)).hom ≫ HAction (Y := Y) r := by
+  rw [targetHm3_hom,← Category.assoc,← Functor.map_comp]
+  simp only [targetAction,biprod.map_snd,Functor.map_comp,Category.assoc,shifted_action]
+end LittleFinitistic.SelectedTargetHomology
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Selected/SelectedTensor.lean b/lean/OAI/Algebra/Finitistic/Selected/SelectedTensor.lean
new file mode 100644
index 0000000000000000000000000000000000000000..1fa0f01d45d038f3936875104d06a2f117a0e6a1
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Selected/SelectedTensor.lean
@@ -0,0 +1,49 @@
+import OAI.Algebra.Finitistic.Selected.SelectedRectification
+import OAI.Algebra.Finitistic.Localization.TensorCohomologyDiagram
+import OAI.Algebra.Finitistic.Rectification.FullTensorProperties
+
+namespace OAI
+noncomputable section
+open CategoryTheory CategoryTheory.Limits HomologicalComplex
+namespace LittleFinitistic.SelectedTensor
+open SelectedFixedDiagram SelectedRectification QuadraticEncoding
+variable (N : Type) [AddCommGroup N] [Module ℂ N] [Module (B P) N]
+
+/-- Evaluate the one fixed selecting bimodule, retaining its full left action. -/
+abbrev complex := FullTensorRectification.tensor P D0 D1 D2 f g relations N
+abbrev source (v : Fin 3) := FullTensorRectification.source P D0 D1 D2 N v
+abbrev comparison (v : Fin 3) (n : ℤ) :=
+  TensorCohomologyDiagram.comparison P D0 D1 D2 f g relations N v n
+
+/-- Every cohomology comparison is invertible for the fixed selected representatives. -/
+instance comparison_isIso (v : Fin 3) (n : ℤ) : IsIso (comparison N v n) := by
+  obtain ⟨l₀,h₀,b₀⟩ := UnderlyingRepresentatives.bounded P fixed.D0
+  obtain ⟨l₁,h₁,b₁⟩ := UnderlyingRepresentatives.bounded P fixed.D1
+  obtain ⟨l₂,h₂,b₂⟩ := UnderlyingRepresentatives.bounded P fixed.D2
+  let lo := min l₀ (min l₁ l₂)
+  let hi := max h₀ (max h₁ h₂)
+  refine TensorCohomologyDiagram.comparison_isIso P D0 D1 D2 f g relations N v n lo hi
+    (fun n hn => b₀ n ?_) (fun n hn => b₁ n ?_) (fun n hn => b₂ n ?_)
+    (UnderlyingRepresentatives.projective P fixed.D0)
+    (UnderlyingRepresentatives.projective P fixed.D1)
+    (UnderlyingRepresentatives.projective P fixed.D2)
+  all_goals dsimp [lo,hi] at hn; omega
+
+def comparisonIso (v : Fin 3) (n : ℤ) := asIso (comparison N v n)
+
+/-- The actual tensor complex has bounded support. -/
+theorem bounded : ∃ lo hi : ℤ, ∀ n, n < lo ∨ hi < n → IsZero ((complex N).X n) := by
+  obtain ⟨lo,hi,h⟩ := SelectedRectification.verified
+  exact ⟨lo-2,hi,FullTensorProperties.bounded ℂ (B P) N bimodule (lo-2) hi h.bounded⟩
+
+/-- Every actual evaluated term is finite-dimensional. -/
+theorem finite [FiniteDimensional ℂ N] (n : ℤ) :
+    FiniteDimensional ℂ ((ModuleCat.restrictScalars (algebraMap ℂ (B P))).obj ((complex N).X n)) := by
+  obtain ⟨lo,hi,h⟩ := SelectedRectification.verified
+  have : FiniteDimensional ℂ ((ExternalTensor.Section4.forgetK ℂ (B P)).obj (bimodule.X n)) := h.finite n
+  exact FullTensorProperties.finite ℂ (B P) N (bimodule.X n)
+end LittleFinitistic.SelectedTensor
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Selected/SelectedTensorComparison.lean b/lean/OAI/Algebra/Finitistic/Selected/SelectedTensorComparison.lean
new file mode 100644
index 0000000000000000000000000000000000000000..dc4d041c9ef5a12c48ca715b91937af78cb53fac
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Selected/SelectedTensorComparison.lean
@@ -0,0 +1,50 @@
+import OAI.Algebra.Finitistic.Localization.UnderlyingRepresentatives
+import OAI.Algebra.Finitistic.Selected.SelectedChainDiagram
+
+namespace OAI
+noncomputable section
+open CategoryTheory CategoryTheory.Limits
+attribute [local instance] HasDerivedCategory.standard
+namespace LittleFinitistic.SelectedTensorComparison
+open QuadraticEncoding FiniteProjectiveHomotopy
+universe u v
+variable {k : Type u} [Field k] {d t : ℕ} {P : Relations k d t}
+variable {Y : Type v} [AddCommGroup Y] [Module k Y] (X : Representation P Y)
+
+abbrev tensor (D : SourceVerdier.K P) :=
+  ((BalancedTensor.tensorFunctor k (B P) X.Evaluation).mapHomologicalComplex (.up ℤ)).obj
+    (UnderlyingRepresentatives.complex P D)
+
+/-- The chosen representative's actual tensor is the source evaluation object. -/
+def homotopyIso (D : SourceVerdier.K P) :
+    (HomotopyCategory.quotient _ _).obj (tensor X D) ≅ (SourceEvaluation.evaluation X).obj D :=
+  Iso.refl _
+
+variable [FiniteDimensional k Y]
+def finiteIso (D : SourceVerdier.K P) :
+    (HomotopyCategory.quotient _ _).obj (tensor X D) ≅
+      (inclusion k).obj ((SourceEvaluation.finite X).obj D) := Iso.refl _
+
+abbrev tensorMap {D E : SourceVerdier.K P}
+    (f : ConcreteChainRepresentatives.representative P D ⟶
+      ConcreteChainRepresentatives.representative P E) :=
+  ((BalancedTensor.tensorFunctor k (B P) X.Evaluation).mapHomologicalComplex (.up ℤ)).map
+    (((UnderlyingRepresentatives.forget P).mapHomologicalComplex (.up ℤ)).map f)
+
+lemma map_comparison {D E : SourceVerdier.K P}
+    (f : ConcreteChainRepresentatives.representative P D ⟶
+      ConcreteChainRepresentatives.representative P E)
+    (a : D ⟶ E)
+    (ha : (HomotopyCategory.quotient _ _).map f = a.hom) :
+    (HomotopyCategory.quotient _ _).map (tensorMap X f) ≫ (finiteIso X E).hom =
+      (finiteIso X D).hom ≫ (inclusion k).map ((SourceEvaluation.finite X).map a) := by
+  dsimp only [finiteIso,Iso.refl_hom]
+  erw [Category.comp_id,Category.id_comp]
+  change _ = ((BalancedTensor.tensorFunctor k (B P) X.Evaluation).mapHomotopyCategory (.up ℤ)).map
+    (((UnderlyingRepresentatives.forget P).mapHomotopyCategory (.up ℤ)).map a.hom)
+  erw [← ha,Functor.mapHomotopyCategory_map,Functor.mapHomotopyCategory_map]
+end LittleFinitistic.SelectedTensorComparison
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Selected/SelectedTensorSplitting.lean b/lean/OAI/Algebra/Finitistic/Selected/SelectedTensorSplitting.lean
new file mode 100644
index 0000000000000000000000000000000000000000..1fd6b1013c3f90961cdef821e7eefec05d70e2c4
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Selected/SelectedTensorSplitting.lean
@@ -0,0 +1,45 @@
+import OAI.Algebra.Finitistic.Selected.SelectedCohomologyVanishing
+import OAI.Algebra.Finitistic.Localization.TwoDegreeFormalityNaturality
+
+namespace OAI
+noncomputable section
+open CategoryTheory CategoryTheory.Limits
+attribute [local instance] HasDerivedCategory.standard HasExt.standard
+namespace LittleFinitistic.SelectedTensorSplitting
+open SelectedFixedDiagram QuadraticEncoding
+variable (N : Type) [AddCommGroup N] [Module ℂ N] [Module (B P) N]
+
+/-- The actual derived object represented by the full B-valued fixed tensor complex. -/
+abbrev object : DerivedCategory (ModuleCat (B P)) := DerivedCategory.Q.obj (SelectedTensor.complex N)
+
+def homologyIso (n : ℤ) :
+    (DerivedCategory.homologyFunctor (ModuleCat (B P)) n).obj (object N) ≅
+      (SelectedTensor.complex N).homology n :=
+  (DerivedCategory.homologyFunctorFactors (ModuleCat (B P)) n).app (SelectedTensor.complex N)
+
+/-- Support of the evaluated representative diagram implies actual derived
+cohomological support of the full tensor object. -/
+theorem twoDegrees
+    (h : ∀ n : ℤ, n ≠ 0 → n ≠ -3 → ∀ v : Fin 3,
+      IsZero ((SelectedTensor.source N v).homology n)) :
+    DerivedTruncation.TwoDegrees (object N) := by
+  intro n hn0 hn3
+  exact (homologyIso N n).isZero_iff.mpr
+    (SelectedCohomologyVanishing.cohomology_isZero N n (h n hn0 hn3))
+
+/-- Apply the proved B-linear truncation splitting to the actual fixed tensor,
+using full module cohomology models and source-diagram support. -/
+def split (R : ModuleCat (B P))
+    (h0 : (SelectedTensor.complex N).homology 0 ≅ R)
+    (h3 : (SelectedTensor.complex N).homology (-3) ≅ R)
+    (hz : ∀ n : ℤ, n ≠ 0 → n ≠ -3 → ∀ v : Fin 3,
+      IsZero ((SelectedTensor.source N v).homology n)) :
+    object N ≅ (DerivedCategory.singleFunctor (ModuleCat (B P)) 0).obj R ⊞
+      ((DerivedCategory.singleFunctor (ModuleCat (B P)) 0).obj R)⟦(3 : ℤ)⟧ :=
+  TwoDegreeFormality.splitIsoWithModels P (object N) (twoDegrees N hz) R R
+    (homologyIso N 0 ≪≫ h0) (homologyIso N (-3) ≪≫ h3)
+end LittleFinitistic.SelectedTensorSplitting
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Selected/SelectedUnderlyingHomology.lean b/lean/OAI/Algebra/Finitistic/Selected/SelectedUnderlyingHomology.lean
new file mode 100644
index 0000000000000000000000000000000000000000..4a339ead1b40fd989ef1a60d227a4bc03dfe2bef
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Selected/SelectedUnderlyingHomology.lean
@@ -0,0 +1,104 @@
+import OAI.Algebra.Finitistic.Selected.SelectedChainHomology
+
+namespace OAI
+noncomputable section
+open CategoryTheory CategoryTheory.Limits
+attribute [local instance] HasDerivedCategory.standard
+namespace LittleFinitistic.SelectedUnderlyingHomology
+open QuadraticEncoding SelectedFixedDiagram SelectedNativeEvaluation SelectedTargetHomology
+open SelectedChainHomology
+universe v
+variable {Y : Type v} [AddCommGroup Y] [Module ℂ Y] [FiniteDimensional ℂ Y]
+  [Module SelectionRing Y] [IsScalarTower ℂ SelectionRing Y]
+
+/-- Tensor an actual map of the underlying right-module complexes. -/
+abbrev tensorMap {D E : SourceVerdier.K P}
+    (f : UnderlyingRepresentatives.complex P D ⟶ UnderlyingRepresentatives.complex P E) :=
+  ((BalancedTensor.tensorFunctor ℂ (B P) (representation (Y := Y)).Evaluation).mapHomologicalComplex
+    (.up ℤ)).map f
+
+lemma derived_map {D E : SourceVerdier.K P}
+    (f : UnderlyingRepresentatives.complex P D ⟶ UnderlyingRepresentatives.complex P E)
+    (a : D ⟶ E)
+    (ha : (HomotopyCategory.quotient _ _).map f = (SourceModelBridge.ambient P).map a) :
+    DerivedCategory.Q.map (tensorMap (Y := Y) f) ≫ (derivedIso (Y := Y) E).hom =
+      (derivedIso (Y := Y) D).hom ≫ I.map ((source (Y := Y)).map a) := by
+  have hq : (HomotopyCategory.quotient _ _).map (tensorMap (Y := Y) f) =
+      (FiniteProjectiveHomotopy.inclusion ℂ).map
+        ((SourceEvaluation.finite (representation (Y := Y))).map a) := by
+    change _ = ((BalancedTensor.tensorFunctor ℂ (B P)
+      (representation (Y := Y)).Evaluation).mapHomotopyCategory (.up ℤ)).map
+        ((SourceModelBridge.ambient P).map a)
+    rw [← ha,Functor.mapHomotopyCategory_map]
+  have h : DerivedCategory.Qh.map ((HomotopyCategory.quotient _ _).map (tensorMap (Y := Y) f)) ≫
+      DerivedCategory.Qh.map (SelectedTensorComparison.finiteIso (representation (Y := Y)) E).hom =
+    DerivedCategory.Qh.map (SelectedTensorComparison.finiteIso (representation (Y := Y)) D).hom ≫
+      I.map ((source (Y := Y)).map a) := by
+    dsimp only [SelectedTensorComparison.finiteIso,Iso.refl_hom]
+    erw [CategoryTheory.Functor.map_id,CategoryTheory.Functor.map_id,Category.comp_id,Category.id_comp,hq]
+    rfl
+  exact DiagramEvaluationSquares.compose _ _ _
+    ((DerivedCategory.quotientCompQhIso C).symm.app (complex (Y := Y) D))
+    ((DerivedCategory.quotientCompQhIso C).symm.app (complex (Y := Y) E))
+    (DerivedCategory.Qh.mapIso (SelectedTensorComparison.finiteIso (representation (Y := Y)) D))
+    (DerivedCategory.Qh.mapIso (SelectedTensorComparison.finiteIso (representation (Y := Y)) E))
+    ((DerivedCategory.quotientCompQhIso C).inv.naturality (tensorMap (Y := Y) f)) h
+
+lemma comparison_map {D E : SourceVerdier.K P}
+    (f : UnderlyingRepresentatives.complex P D ⟶ UnderlyingRepresentatives.complex P E)
+    (a : D ⟶ E)
+    (ha : (HomotopyCategory.quotient _ _).map f = (SourceModelBridge.ambient P).map a) (n : ℤ) :
+    HomologicalComplex.homologyMap (tensorMap (Y := Y) f) n ≫ (comparison (Y := Y) E n).hom =
+      (comparison (Y := Y) D n).hom ≫ (cohomology n).map ((source (Y := Y)).map a) := by
+  have h := congrArg (DerivedCategory.homologyFunctor C n).map (derived_map (Y := Y) f a ha)
+  simp only [Functor.map_comp] at h
+  exact DiagramEvaluationSquares.compose _ _ _
+    ((DerivedCategory.homologyFunctorFactors C n).symm.app (complex (Y := Y) D))
+    ((DerivedCategory.homologyFunctorFactors C n).symm.app (complex (Y := Y) E))
+    ((DerivedCategory.homologyFunctor C n).mapIso (derivedIso (Y := Y) D))
+    ((DerivedCategory.homologyFunctor C n).mapIso (derivedIso (Y := Y) E))
+    ((DerivedCategory.homologyFunctorFactors C n).inv.naturality (tensorMap (Y := Y) f)) h
+
+lemma homology_arrow {D E : SourceVerdier.K P}
+    (f : UnderlyingRepresentatives.complex P D ⟶ UnderlyingRepresentatives.complex P E)
+    (a : D ⟶ E)
+    (ha : (HomotopyCategory.quotient _ _).map f = (SourceModelBridge.ambient P).map a)
+    (eD : (source (Y := Y)).obj D ≅ target (Y := Y))
+    (eE : (source (Y := Y)).obj E ≅ target (Y := Y)) (r : SelectionRing)
+    (hs : (source (Y := Y)).map a ≫ eE.hom = eD.hom ≫ targetAction (Y := Y) r)
+    (n : ℤ) (hn : n = 0 ∨ n = -3) :
+    HomologicalComplex.homologyMap (tensorMap (Y := Y) f) n ≫ (homologyIso E eE n hn).hom =
+      (homologyIso D eD n hn).hom ≫ HAction (Y := Y) r := by
+  have h := congrArg (cohomology n).map hs
+  simp only [Functor.map_comp] at h
+  exact DiagramEvaluationSquares.compose _ _ _
+    (comparison D n) (comparison E n)
+    ((cohomology n).mapIso eD ≪≫ modelIso n hn)
+    ((cohomology n).mapIso eE ≪≫ modelIso n hn)
+    (comparison_map f a ha n)
+    (DiagramEvaluationSquares.compose _ _ _ ((cohomology n).mapIso eD)
+      ((cohomology n).mapIso eE) (modelIso n hn) (modelIso n hn) h (model_action n hn r))
+
+lemma arrow01 (a : Fin (encoding.generators+1))
+    (f : UnderlyingRepresentatives.complex P fixed.D0 ⟶ UnderlyingRepresentatives.complex P fixed.D1)
+    (hf : (HomotopyCategory.quotient _ _).map f = (SourceModelBridge.ambient P).map (fixed.f a))
+    (n : ℤ) (hn : n = 0 ∨ n = -3) :
+    HomologicalComplex.homologyMap (tensorMap (Y := Y) f) n ≫ (SelectedChainHomology.D1Iso n hn).hom =
+      (SelectedChainHomology.D0Iso n hn).hom ≫ HAction (Y := Y)
+        (RelationBasisAction.arrow (SelectionEncoding.generator encoding) a) :=
+  homology_arrow f (fixed.f a) hf SelectedNativeEvaluation.D0Iso SelectedNativeEvaluation.D1Iso _
+    (SelectedNativeEvaluation.D_arrow01 a) n hn
+lemma arrow12 (a : Fin (encoding.generators+1))
+    (g : UnderlyingRepresentatives.complex P fixed.D1 ⟶ UnderlyingRepresentatives.complex P fixed.D2)
+    (hg : (HomotopyCategory.quotient _ _).map g = (SourceModelBridge.ambient P).map (fixed.g a))
+    (n : ℤ) (hn : n = 0 ∨ n = -3) :
+    HomologicalComplex.homologyMap (tensorMap (Y := Y) g) n ≫ (SelectedChainHomology.D2Iso n hn).hom =
+      (SelectedChainHomology.D1Iso n hn).hom ≫ HAction (Y := Y)
+        (RelationBasisAction.arrow (SelectionEncoding.generator encoding) a) :=
+  homology_arrow g (fixed.g a) hg SelectedNativeEvaluation.D1Iso SelectedNativeEvaluation.D2Iso _
+    (SelectedNativeEvaluation.D_arrow12 a) n hn
+end LittleFinitistic.SelectedUnderlyingHomology
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Selected/SelectedVertexTensorEvaluation.lean b/lean/OAI/Algebra/Finitistic/Selected/SelectedVertexTensorEvaluation.lean
new file mode 100644
index 0000000000000000000000000000000000000000..464dac57806b45499ec3e2ce558fad5656508914
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Selected/SelectedVertexTensorEvaluation.lean
@@ -0,0 +1,72 @@
+import OAI.Algebra.Finitistic.Rectification.VertexTensorEvaluation
+import OAI.Algebra.Finitistic.Localization.TensorEvaluationComparison
+
+namespace OAI
+noncomputable section
+open CategoryTheory
+namespace LittleFinitistic.QuadraticEncoding
+open IdempotentTensor BalancedTensor Representation
+universe u v
+variable {k : Type u} [Field k] {d t : ℕ} (P : Relations k d t)
+
+/-- The manuscript's actual right vertex projectives. -/
+def vertexModule (i : Fin 3) : ModuleCat.{u} (B P)ᵐᵒᵖ :=
+  ModuleCat.of (B P)ᵐᵒᵖ (rightIdeal (vertexId (P := P) i))
+
+def arrowModule01 (h : Fin (d+1)) : vertexModule P 0 ⟶ vertexModule P 1 :=
+  ModuleCat.ofHom (leftMultiply (arrow01 P h) (arrow01_target h))
+def arrowModule12 (h : Fin (d+1)) : vertexModule P 1 ⟶ vertexModule P 2 :=
+  ModuleCat.ofHom (leftMultiply (arrow12 P h) (arrow12_target h))
+
+variable {P} {Y : Type v} [AddCommGroup Y] [Module k Y] (X : Representation P Y)
+
+/-- The natural identifications for the actual tensor functor. -/
+def evaluationVertexEquiv (i : Fin 3) :
+    (tensorFunctor k (B P) X.Evaluation).obj (vertexModule P i) ≃ₗ[k] Y :=
+  (tensorFunctorEquiv (rightIdeal (vertexId (P := P) i)) X.Evaluation).trans (X.vertexTensorEquiv i)
+
+theorem evaluation_arrow01 (h : Fin (d+1)) (y : Y) :
+    evaluationVertexEquiv X 1
+      ((tensorFunctor k (B P) X.Evaluation).map (arrowModule01 P h)
+        ((evaluationVertexEquiv X 0).symm y)) =
+      (Fin.cases (motive := fun _ => Module.End k Y) 1 X.generator h) y := by
+  change X.projection 1 ((arrow01 P h * vertexId (P := P) 0) • X.inclusion 0 y) = _
+  rw [arrow01_source]
+  erw [X.arrow01_smul]
+  rfl
+
+theorem evaluation_arrow12 (h : Fin (d+1)) (y : Y) :
+    evaluationVertexEquiv X 2
+      ((tensorFunctor k (B P) X.Evaluation).map (arrowModule12 P h)
+        ((evaluationVertexEquiv X 1).symm y)) =
+      (Fin.cases (motive := fun _ => Module.End k Y) 1 X.generator h) y := by
+  change X.projection 2 ((arrow12 P h * vertexId (P := P) 1) • X.inclusion 1 y) = _
+  rw [arrow12_source]
+  erw [X.arrow12_smul]
+  rfl
+
+/-- Tensor evaluation sends s to an actual isomorphism, conjugate to id_Y. -/
+theorem evaluation_s_isIso : IsIso ((tensorFunctor k (B P) X.Evaluation).map (arrowModule01 P 0)) := by
+  let e := (evaluationVertexEquiv X 0).trans (evaluationVertexEquiv X 1).symm
+  have he : (tensorFunctor k (B P) X.Evaluation).map (arrowModule01 P 0) = e.toModuleIso.hom := by
+    ext z
+    apply (evaluationVertexEquiv X 1).injective
+    have h := evaluation_arrow01 X 0 (evaluationVertexEquiv X 0 z)
+    simpa [e] using h
+  rw [he]
+  infer_instance
+
+theorem evaluation_s'_isIso : IsIso ((tensorFunctor k (B P) X.Evaluation).map (arrowModule12 P 0)) := by
+  let e := (evaluationVertexEquiv X 1).trans (evaluationVertexEquiv X 2).symm
+  have he : (tensorFunctor k (B P) X.Evaluation).map (arrowModule12 P 0) = e.toModuleIso.hom := by
+    ext z
+    apply (evaluationVertexEquiv X 2).injective
+    have h := evaluation_arrow12 X 0 (evaluationVertexEquiv X 1 z)
+    simpa [e] using h
+  rw [he]
+  infer_instance
+end LittleFinitistic.QuadraticEncoding
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Selected/SelectedWindow.lean b/lean/OAI/Algebra/Finitistic/Selected/SelectedWindow.lean
new file mode 100644
index 0000000000000000000000000000000000000000..b45c20769d2db1344878526913d543a55af5faab
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Selected/SelectedWindow.lean
@@ -0,0 +1,49 @@
+import OAI.Algebra.Finitistic.Selected.SelectedRectification
+
+namespace OAI
+noncomputable section
+open CategoryTheory CategoryTheory.Limits
+namespace LittleFinitistic.SelectedWindow
+open SelectedFixedDiagram SelectedRectification
+
+/-- A common finite support window chosen from the fixed representatives alone. -/
+structure Window where
+  lo : ℤ
+  hi : ℤ
+  bound0 : ∀ n, n < lo ∨ hi < n → IsZero (D0.X n)
+  bound1 : ∀ n, n < lo ∨ hi < n → IsZero (D1.X n)
+  bound2 : ∀ n, n < lo ∨ hi < n → IsZero (D2.X n)
+
+instance : Nonempty Window := by
+  obtain ⟨l₀,h₀,b₀⟩ := UnderlyingRepresentatives.bounded P fixed.D0
+  obtain ⟨l₁,h₁,b₁⟩ := UnderlyingRepresentatives.bounded P fixed.D1
+  obtain ⟨l₂,h₂,b₂⟩ := UnderlyingRepresentatives.bounded P fixed.D2
+  refine ⟨⟨min l₀ (min l₁ l₂), max h₀ (max h₁ h₂), ?_, ?_, ?_⟩⟩
+  · intro n hn; apply b₀ n; omega
+  · intro n hn; apply b₁ n; omega
+  · intro n hn; apply b₂ n; omega
+
+def window : Window := Classical.choice inferInstance
+abbrev lo := window.lo
+abbrev hi := window.hi
+
+/-- Every term outside the fixed total's resulting support window is zero. -/
+theorem bounded (n : ℤ) (hn : n < lo - 2 ∨ hi < n) : IsZero (bimodule.X n) :=
+  InducedRectification.total_bounded (ConcreteQuadraticDiagram.quadratic P)
+    D0 D1 D2 f g relations lo hi window.bound0 window.bound1 window.bound2 n hn
+
+/-- The support choices retain the complete proved rectification certificate. -/
+theorem verified : RectificationLemma.Verified P D0 D1 D2 f g relations lo hi :=
+  RectificationLemma.rectification P D0 D1 D2 f g relations lo hi
+    window.bound0 window.bound1 window.bound2
+    (UnderlyingRepresentatives.projective P fixed.D0)
+    (UnderlyingRepresentatives.projective P fixed.D1)
+    (UnderlyingRepresentatives.projective P fixed.D2)
+    (UnderlyingRepresentatives.finite P fixed.D0)
+    (UnderlyingRepresentatives.finite P fixed.D1)
+    (UnderlyingRepresentatives.finite P fixed.D2)
+end LittleFinitistic.SelectedWindow
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Selection/AuxiliaryGroupAlgebraPresentation.lean b/lean/OAI/Algebra/Finitistic/Selection/AuxiliaryGroupAlgebraPresentation.lean
new file mode 100644
index 0000000000000000000000000000000000000000..001af2e3da9aa29425e60067956497b6433ccd9f
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Selection/AuxiliaryGroupAlgebraPresentation.lean
@@ -0,0 +1,39 @@
+import OAI.Algebra.Finitistic.Selection.GroupAlgebraPresentation
+import OAI.Algebra.Finitistic.Selection.FinitePresentation
+
+namespace OAI
+noncomputable section
+namespace LittleFinitistic.GroupAlgebraPresentation
+
+/-- Section 2's complex group algebra, for the exact auxiliary group supplied
+by the manuscript. The stable finite model has 18 generators, including the
+three redundant diagonal W generators killed by its relations. -/
+def auxiliaryGroupAlgebraEquiv :
+    PresentedAlgebra ℂ FinitePresentation.SeedGenerator FinitePresentation.finiteRelators ≃ₐ[ℂ]
+      MonoidAlgebra ℂ Presentation.AuxiliaryGroup :=
+  (quotientEquiv ℂ FinitePresentation.SeedGenerator FinitePresentation.finiteRelators).trans
+    (MonoidAlgebra.domCongr ℂ ℂ FinitePresentation.presentationEquiv)
+
+/-- Same explicit presentation expressed as polynomial zero relations. -/
+def auxiliaryGroupAlgebraZeroEquiv :
+    (zeroRelations ℂ FinitePresentation.SeedGenerator FinitePresentation.finiteRelators).Quotient ≃ₐ[ℂ]
+      MonoidAlgebra ℂ Presentation.AuxiliaryGroup :=
+  (zeroQuotientEquiv ℂ FinitePresentation.SeedGenerator FinitePresentation.finiteRelators).trans
+    (MonoidAlgebra.domCongr ℂ ℂ FinitePresentation.presentationEquiv)
+
+/-- The finite-presentation assertion for R = ℂ[G] in Section 2's proof of
+Proposition selection. This is a NONCOMMUTATIVE unital algebra presentation. -/
+theorem auxiliaryGroupAlgebra_hasFinitePresentation :
+    HasFinitePresentation ℂ (MonoidAlgebra ℂ Presentation.AuxiliaryGroup) := by
+  let := FinitePresentation.auxiliaryGroup_isFinitelyPresented
+  exact groupAlgebra_hasFinitePresentation ℂ Presentation.AuxiliaryGroup
+
+/-- Positive and negative letters for the stable finite model: 36 algebra generators. -/
+theorem auxiliary_algebra_generator_count :
+    Fintype.card (Letter FinitePresentation.SeedGenerator) = 36 := by
+  simp [Letter, Fintype.card_prod, FinitePresentation.seedGenerator_card]
+end LittleFinitistic.GroupAlgebraPresentation
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Selection/CharacterModule.lean b/lean/OAI/Algebra/Finitistic/Selection/CharacterModule.lean
new file mode 100644
index 0000000000000000000000000000000000000000..a77d1be48384a6f0b3855650bb9b197b0a913553
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Selection/CharacterModule.lean
@@ -0,0 +1,89 @@
+import Mathlib.Algebra.MonoidAlgebra.Basic
+import Mathlib.Basic.Complex.Basic
+import Mathlib.Tactic.FieldSimp
+import Mathlib.LinearAlgebra.FiniteDimensional.Basic
+import OAI.Algebra.Finitistic.Selection.MatrixModel
+
+namespace OAI
+open scoped BigOperators
+
+namespace LittleFinitistic
+namespace CharacterModule
+
+open MonoidAlgebra
+
+variable {H F : Type*} [Group H] [Group F] [Fintype H]
+variable (ψ : H →* F) (χ : H →* ℂˣ)
+
+/-- The unnormalized character projector. Its identity coefficient is one,
+so normalization is unnecessary for constructing the nonzero test module. -/
+noncomputable def projector : MonoidAlgebra ℂ F :=
+  ∑ h : H, single (ψ h) ((χ h : ℂ)⁻¹)
+
+theorem projector_coeff_one (hψ : Function.Injective ψ) :
+    (projector ψ χ).coeff 1 = 1 := by
+  classical
+  have hp (h : H) : ψ h = 1 ↔ h = 1 := by
+    rw [← map_one ψ]
+    exact hψ.eq_iff
+  simp [projector, coeff_sum, coeff_single, Finsupp.single_apply, hp]
+
+theorem projector_ne_zero (hψ : Function.Injective ψ) : projector ψ χ ≠ 0 := by
+  intro h
+  have := projector_coeff_one ψ χ hψ
+  rw [h] at this
+  simp at this
+
+theorem projector_eigen (h : H) :
+    single (ψ h) (1 : ℂ) * projector ψ χ = (χ h : ℂ) • projector ψ χ := by
+  classical
+  unfold projector
+  rw [Finset.mul_sum, Finset.smul_sum]
+  have he := Equiv.sum_comp (Equiv.mulLeft h) (fun k : H =>
+    (χ h : ℂ) • single (ψ k) ((χ k : ℂ)⁻¹))
+  rw [← he]
+  apply Finset.sum_congr rfl
+  intro k _
+  change single (ψ h) (1 : ℂ) * single (ψ k) ((χ k : ℂ)⁻¹) =
+    (χ h : ℂ) • single (ψ (h*k)) ((χ (h*k) : ℂ)⁻¹)
+  simp only [map_mul,Units.val_mul,single_mul_single,one_mul,
+    smul_single,smul_eq_mul]
+  congr 1
+  field_simp
+
+variable (hc : ∀ h g, Commute (ψ h) g)
+
+/-- All vectors on which the central subgroup acts by the selected character. -/
+noncomputable def eigenspace : Submodule (MonoidAlgebra ℂ F) (MonoidAlgebra ℂ F) where
+  carrier := {x | ∀ h, single (ψ h) (1 : ℂ) * x = (χ h : ℂ) • x}
+  zero_mem' := by simp
+  add_mem' := by
+    intro a b ha hb h
+    simp [mul_add,ha h,hb h,smul_add]
+  smul_mem' := by
+    intro a x hx h
+    change single (ψ h) (1 : ℂ) * (a*x) = (χ h : ℂ) • (a*x)
+    rw [← mul_assoc, (MonoidAlgebra.single_commute (hc h) Commute.one_left a).eq,
+      mul_assoc,hx h,mul_smul_comm]
+
+theorem projector_mem : projector ψ χ ∈ eigenspace ψ χ hc :=
+  projector_eigen ψ χ
+
+theorem eigenspace_nontrivial (hψ : Function.Injective ψ) :
+    Nontrivial (eigenspace ψ χ hc) := by
+  refine ⟨⟨⟨projector ψ χ,projector_mem ψ χ hc⟩,0,?_⟩⟩
+  intro h
+  exact projector_ne_zero ψ χ hψ (congrArg Subtype.val h)
+
+omit [Fintype H] in
+theorem eigenspace_finiteDimensional [Finite F] :
+    FiniteDimensional ℂ (eigenspace ψ χ hc) := by
+  have : FiniteDimensional ℂ (MonoidAlgebra ℂ F) :=
+    Module.Finite.equiv (MonoidAlgebra.coeffLinearEquiv ℂ : MonoidAlgebra ℂ F ≃ₗ[ℂ] (F →₀ ℂ)).symm
+  exact FiniteDimensional.of_injective ((eigenspace ψ χ hc).restrictScalars ℂ).subtype
+    Subtype.val_injective
+
+end CharacterModule
+end LittleFinitistic
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Selection/FinitePresentation.lean b/lean/OAI/Algebra/Finitistic/Selection/FinitePresentation.lean
new file mode 100644
index 0000000000000000000000000000000000000000..6760fe723221524bea9ce5ae9371bf3b59bc1967
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Selection/FinitePresentation.lean
@@ -0,0 +1,600 @@
+import OAI.Algebra.Finitistic.Selection.GroupSelection
+import Mathlib.GroupTheory.FinitelyPresentedGroup
+import Mathlib.Tactic.DeriveFintype
+
+namespace OAI
+open scoped commutatorElement
+namespace LittleFinitistic.FinitePresentation
+
+/-! Target: Group.IsFinitelyPresented Presentation.AuxiliaryGroup.
+Section 2, Lemma group-finite-presentation. No finite-presentation hypothesis
+is permitted on the target group. Diagonal W generators are redundant.
+-/
+
+section Orbit
+variable {G : Type*} [Group G]
+
+def orbit (t x : G) (r : ℤ) : G := t ^ r * x * (t ^ r)⁻¹
+
+@[simp] theorem orbit_zero (t x : G) : orbit t x 0 = x := by simp [orbit]
+
+theorem orbit_add (t x : G) (a b : ℤ) :
+    orbit t (orbit t x b) a = orbit t x (a+b) := by
+  simp only [orbit, zpow_add, mul_inv_rev]
+  group
+
+theorem orbit_commute (t q x : G) (h : Commute t q) (a : ℤ) :
+    t * orbit q x a * t⁻¹ = orbit q (t*x*t⁻¹) a := by
+  have hc := h.zpow_right a
+  simp only [orbit]
+  calc
+    t * (q^a*x*(q^a)⁻¹) * t⁻¹ = (t*q^a)*x*(q^a)⁻¹*t⁻¹ := by group
+    _ = (q^a*t)*x*(q^a)⁻¹*t⁻¹ := by rw [hc.eq]
+    _ = q^a*(t*x)*((q^a)⁻¹*t⁻¹) := by group
+    _ = q^a*(t*x)*(t⁻¹*(q^a)⁻¹) := by rw [hc.inv_inv.eq]
+    _ = q^a*(t*x*t⁻¹)*(q^a)⁻¹ := by group
+
+theorem orbit_covariance (t q x : G) (h : Commute t q) (d : ℤ)
+    (hx : t*x*t⁻¹ = orbit q x d) (a : ℤ) :
+    t * orbit q x a * t⁻¹ = orbit q x (a+d) := by
+  rw [orbit_commute t q x h a, hx, orbit_add]
+
+theorem family_zpow (t : G) (f : ℤ → G) (d : ℤ)
+    (h : ∀ r, t*f r*t⁻¹ = f (r+d)) (n r : ℤ) :
+    orbit t (f r) n = f (r+n*d) := by
+  induction n using Int.induction_on with
+  | zero => simp
+  | succ n ih =>
+      have he : (↑n + 1 : ℤ) = 1 + ↑n := by omega
+      rw [he, ← orbit_add, ih]
+      change t^ (1:ℤ) * _ * (t^(1:ℤ))⁻¹ = _
+      simp only [zpow_one, h]
+      congr 1
+      ring
+  | pred n ih =>
+      have hi := h (r + (-↑n - 1)*d)
+      have he : r + (-↑n - 1)*d+d = r+(-↑n)*d := by ring
+      rw [he] at hi
+      have he' : (-↑n - 1 : ℤ) = -1 + -↑n := by omega
+      rw [he', ← orbit_add, ih, ← hi]
+      simp only [orbit, zpow_neg_one, inv_inv]
+      group
+
+end Orbit
+
+abbrev Lattice := Fin 3 → ℤ
+
+def coord (i : Fin 3) (r : ℤ) : Lattice := fun h => if h=i then r else 0
+
+def wtU (i : Fin 3) (n : Lattice) := -n i
+
+def wtV (i : Fin 3) (n : Lattice) := n i
+
+def wtW (i j : Fin 3) (n : Lattice) := n i-n j
+
+/- Each theorem supplies the integral preimage in the corresponding table row. -/
+theorem table_UU (i j : Fin 3) (hij : i ≠ j) (r s : ℤ) :
+    ∃ n : Lattice, wtU i n = r ∧ wtU j n = s := by
+  refine ⟨coord i (-r) + coord j (-s), ?_⟩
+  simp [wtU, coord, hij, hij.symm]
+
+theorem table_VV (i j : Fin 3) (hij : i ≠ j) (r s : ℤ) :
+    ∃ n : Lattice, wtV i n = r ∧ wtV j n = s := by
+  refine ⟨coord i r + coord j s, ?_⟩
+  simp [wtV, coord, hij, hij.symm]
+
+theorem table_UV (i j : Fin 3) (hij : i ≠ j) (r s : ℤ) :
+    ∃ n : Lattice, wtU i n = r ∧ wtV j n = s := by
+  refine ⟨coord i (-r) + coord j s, ?_⟩
+  simp [wtU, wtV, coord, hij, hij.symm]
+
+theorem table_WU (i j h : Fin 3) (hij : i ≠ j) (hhi : h ≠ i) (r s : ℤ) :
+    ∃ n : Lattice, wtW i j n = r ∧ wtU h n = s := by
+  by_cases hhj : h=j
+  · subst h
+    refine ⟨coord i (r-s) + coord j (-s), ?_⟩
+    simp [wtW, wtU, coord, hij, hij.symm]
+  · refine ⟨coord i r + coord h (-s), ?_⟩
+    simp [wtW, wtU, coord, hij.symm, hhi, (Ne.symm hhi), (Ne.symm hhj)]
+
+theorem table_WV (i j h : Fin 3) (hij : i ≠ j) (hhj : h ≠ j) (r s : ℤ) :
+    ∃ n : Lattice, wtW i j n = r ∧ wtV h n = s := by
+  by_cases hhi : h=i
+  · subst h
+    refine ⟨coord i s + coord j (s-r), ?_⟩
+    simp [wtW, wtV, coord, hij, hij.symm]
+  · refine ⟨coord i r + coord h s, ?_⟩
+    simp [wtW, wtV, coord, hij.symm, hhi, (Ne.symm hhi), (Ne.symm hhj)]
+
+theorem table_UW (i j : Fin 3) (hij : i ≠ j) (r s : ℤ) :
+    ∃ n : Lattice, wtU i n = r ∧ wtW i j n = s := by
+  refine ⟨coord i (-r) + coord j (-r-s), ?_⟩
+  simp [wtU, wtW, coord, hij, hij.symm]
+
+theorem table_WV_output (i j : Fin 3) (hij : i ≠ j) (r s : ℤ) :
+    ∃ n : Lattice, wtW i j n = r ∧ wtV j n = s := by
+  refine ⟨coord i (r+s) + coord j s, ?_⟩
+  simp [wtW, wtV, coord, hij, hij.symm]
+
+
+section Torus
+variable {G : Type*} [Group G]
+
+def torus (T : Fin 3 → G) (n : Lattice) : G := T 0 ^ n 0 * T 1 ^ n 1 * T 2 ^ n 2
+
+theorem family_torus (T : Fin 3 → G) (f : ℤ → G) (d : Fin 3 → ℤ)
+    (hf : ∀ l r, T l * f r * (T l)⁻¹ = f (r+d l)) (n : Lattice) (r : ℤ) :
+    torus T n * f r * (torus T n)⁻¹ =
+      f (r + n 0*d 0 + n 1*d 1 + n 2*d 2) := by
+  have he : torus T n * f r * (torus T n)⁻¹ =
+      orbit (T 0) (orbit (T 1) (orbit (T 2) (f r) (n 2)) (n 1)) (n 0) := by
+    simp only [torus, orbit]
+    group
+  rw [he, family_zpow _ _ _ (hf 2), family_zpow _ _ _ (hf 1),
+    family_zpow _ _ _ (hf 0)]
+  congr 1
+  ring
+
+theorem torus_U (T : Fin 3 → G) (U : Fin 3 → ℤ → G)
+    (hf : ∀ l i r, T l * U i r * (T l)⁻¹ = U i (r-if l=i then 1 else 0))
+    (n : Lattice) (i : Fin 3) (r : ℤ) :
+    torus T n * U i r * (torus T n)⁻¹ = U i (r+wtU i n) := by
+  have h := family_torus T (U i) (fun l => -(if l=i then 1 else 0))
+    (fun l r => by simpa only [sub_eq_add_neg] using hf l i r) n r
+  convert h using 2; fin_cases i <;> simp [wtU]
+
+theorem torus_V (T : Fin 3 → G) (V : Fin 3 → ℤ → G)
+    (hf : ∀ l i r, T l * V i r * (T l)⁻¹ = V i (r+if l=i then 1 else 0))
+    (n : Lattice) (i : Fin 3) (r : ℤ) :
+    torus T n * V i r * (torus T n)⁻¹ = V i (r+wtV i n) := by
+  have h := family_torus T (V i) (fun l => if l=i then 1 else 0)
+    (fun l r => hf l i r) n r
+  convert h using 2; fin_cases i <;> simp [wtV]
+
+theorem torus_W (T : Fin 3 → G) (W : Fin 3 → Fin 3 → ℤ → G)
+    (hf : ∀ l i j r, T l * W i j r * (T l)⁻¹ =
+      W i j (r+(if l=i then 1 else 0)-if l=j then 1 else 0))
+    (n : Lattice) (i j : Fin 3) (r : ℤ) :
+    torus T n * W i j r * (torus T n)⁻¹ = W i j (r+wtW i j n) := by
+  have h := family_torus T (W i j) (fun l => (if l=i then 1 else 0)-(if l=j then 1 else 0))
+    (fun l r => by simpa only [add_sub_assoc] using hf l i j r) n r
+  convert h using 2; fin_cases i <;> fin_cases j <;> simp [wtW] <;> ring
+end Torus
+
+
+/-- Intermediate data: covariance plus only zero-argument algebraic relations.
+This is constructed below from a finite presented group, not postulated for it. -/
+structure CovariantData (G : Type*) [Group G] where
+  T : Fin 3 → G
+  U : Fin 3 → ℤ → G
+  V : Fin 3 → ℤ → G
+  W : Fin 3 → Fin 3 → ℤ → G
+  TT : ∀ i j, Commute (T i) (T j)
+  TU : ∀ l i a, T l * U i a * (T l)⁻¹ = U i (a-if l=i then 1 else 0)
+  TV : ∀ l i a, T l * V i a * (T l)⁻¹ = V i (a+if l=i then 1 else 0)
+  TW : ∀ l i j a, T l * W i j a * (T l)⁻¹ =
+    W i j (a+(if l=i then 1 else 0)-if l=j then 1 else 0)
+  diagonal : ∀ i a, W i i a = 1
+  square : ∀ i, U i 0 * U i 0 = 1
+  UU : ∀ i j, i ≠ j → Commute (U i 0) (U j 0)
+  VV : ∀ i j, i ≠ j → Commute (V i 0) (V j 0)
+  UV : ∀ i j, i ≠ j → Commute (U i 0) (V j 0)
+  WU : ∀ i j h, h ≠ i → Commute (W i j 0) (U h 0)
+  WV : ∀ i j h, h ≠ j → Commute (W i j 0) (V h 0)
+  UWout : ∀ i j, i ≠ j → ⁅U i 0,W i j 0⁆ = U j 0
+  WVout : ∀ i j, i ≠ j → ⁅W i j 0,V j 0⁆ = V i 0
+
+namespace CovariantData
+variable {G : Type*} [Group G] (D : CovariantData G)
+
+def act (n : Lattice) : G ≃* G := MulAut.conj (torus D.T n)
+
+@[simp] theorem act_U (n : Lattice) (i : Fin 3) (a : ℤ) :
+    D.act n (D.U i a) = D.U i (a+wtU i n) := torus_U D.T D.U D.TU n i a
+@[simp] theorem act_V (n : Lattice) (i : Fin 3) (a : ℤ) :
+    D.act n (D.V i a) = D.V i (a+wtV i n) := torus_V D.T D.V D.TV n i a
+@[simp] theorem act_W (n : Lattice) (i j : Fin 3) (a : ℤ) :
+    D.act n (D.W i j a) = D.W i j (a+wtW i j n) := torus_W D.T D.W D.TW n i j a
+
+/-- All infinite relators follow from the finite zero-argument patterns. -/
+def toSelection : SelectionGroupData G where
+  T := D.T
+  U := D.U
+  V := D.V
+  W := D.W
+  commute_TT := D.TT
+  conj_TU := D.TU
+  conj_TV := D.TV
+  conj_TW := D.TW
+  diagonal_W := D.diagonal
+  square_U i a := by
+    have ha : wtU i (coord i (-a)) = a := by simp [wtU, coord]
+    have h := congrArg (D.act (coord i (-a))) (D.square i)
+    simpa only [map_mul, map_one, act_U, zero_add, ha] using h
+  commute_UU i j a b hij := by
+    obtain ⟨n, ha, hb⟩ := table_UU i j hij a b
+    have h := (D.UU i j hij).map (D.act n)
+    simpa only [act_U, zero_add, ha, hb] using h
+  commute_VV i j a b hij := by
+    obtain ⟨n, ha, hb⟩ := table_VV i j hij a b
+    have h := (D.VV i j hij).map (D.act n)
+    simpa only [act_V, zero_add, ha, hb] using h
+  commute_UV i j a b hij := by
+    obtain ⟨n, ha, hb⟩ := table_UV i j hij a b
+    have h := (D.UV i j hij).map (D.act n)
+    simpa only [act_U, act_V, zero_add, ha, hb] using h
+  commute_WU i j h a b hhi := by
+    by_cases hij : i=j
+    · subst j
+      rw [D.diagonal]
+      exact Commute.one_left _
+    · obtain ⟨n, ha, hb⟩ := table_WU i j h hij hhi a b
+      have hh := (D.WU i j h hhi).map (D.act n)
+      simpa only [act_U, act_W, zero_add, ha, hb] using hh
+  commute_WV i j h a b hhj := by
+    by_cases hij : i=j
+    · subst j
+      rw [D.diagonal]
+      exact Commute.one_left _
+    · obtain ⟨n, ha, hb⟩ := table_WV i j h hij hhj a b
+      have hh := (D.WV i j h hhj).map (D.act n)
+      simpa only [act_V, act_W, zero_add, ha, hb] using hh
+  commutator_UW i j a b hij := by
+    obtain ⟨n, ha, hb⟩ := table_UW i j hij a b
+    have hout : wtU j n = a+b := by dsimp [wtU, wtW] at *; omega
+    have h := congrArg (D.act n) (D.UWout i j hij)
+    simpa only [map_commutatorElement, act_U, act_W, zero_add, ha, hb, hout] using h
+  commutator_WV i j a b hij := by
+    obtain ⟨n, ha, hb⟩ := table_WV_output i j hij a b
+    have hout : wtV i n = a+b := by dsimp [wtV, wtW] at *; omega
+    have h := congrArg (D.act n) (D.WVout i j hij)
+    simpa only [map_commutatorElement, act_V, act_W, zero_add, ha, hb, hout] using h
+end CovariantData
+
+/-- Finitely many seed values. Diagonal W seeds will be killed. -/
+structure SeedValues (G : Type*) where
+  T : Fin 3 → G
+  u : Fin 3 → G
+  v : Fin 3 → G
+  w : Fin 3 → Fin 3 → G
+
+structure SeedData (G : Type*) [Group G] extends SeedValues G where
+  TT : ∀ i j, Commute (T i) (T j)
+  Tu : ∀ l i, T l*u i*(T l)⁻¹ = orbit (T i) (u i) (if l=i then 1 else 0)
+  Tv : ∀ l i, T l*v i*(T l)⁻¹ = orbit (T i) (v i) (if l=i then 1 else 0)
+  Tw : ∀ l i j, T l*w i j*(T l)⁻¹ =
+    orbit (T i) (w i j) ((if l=i then 1 else 0)-(if l=j then 1 else 0))
+  diagonal : ∀ i, w i i = 1
+  square : ∀ i, u i*u i = 1
+  UU : ∀ i j, i ≠ j → Commute (u i) (u j)
+  VV : ∀ i j, i ≠ j → Commute (v i) (v j)
+  UV : ∀ i j, i ≠ j → Commute (u i) (v j)
+  WU : ∀ i j h, h ≠ i → Commute (w i j) (u h)
+  WV : ∀ i j h, h ≠ j → Commute (w i j) (v h)
+  UWout : ∀ i j, i ≠ j → ⁅u i,w i j⁆ = u j
+  WVout : ∀ i j, i ≠ j → ⁅w i j,v j⁆ = v i
+
+namespace SeedData
+variable {G : Type*} [Group G] (D : SeedData G)
+
+def toCovariant : CovariantData G where
+  T := D.T
+  U i r := orbit (D.T i) (D.u i) (-r)
+  V i r := orbit (D.T i) (D.v i) r
+  W i j r := orbit (D.T i) (D.w i j) r
+  TT := D.TT
+  TU l i a := by
+    rw [orbit_covariance _ _ _ (D.TT l i) _ (D.Tu l i)]
+    congr 1
+    omega
+  TV l i a := orbit_covariance _ _ _ (D.TT l i) _ (D.Tv l i) a
+  TW l i j a := by
+    rw [orbit_covariance _ _ _ (D.TT l i) _ (D.Tw l i j)]
+    congr 1
+    omega
+  diagonal i a := by simp [orbit, D.diagonal]
+  square i := by simpa using D.square i
+  UU i j h := by simpa using D.UU i j h
+  VV i j h := by simpa using D.VV i j h
+  UV i j h := by simpa using D.UV i j h
+  WU i j h hh := by simpa using D.WU i j h hh
+  WV i j h hh := by simpa using D.WV i j h hh
+  UWout i j h := by simpa using D.UWout i j h
+  WVout i j h := by simpa using D.WVout i j h
+
+def toSelection : SelectionGroupData G := D.toCovariant.toSelection
+end SeedData
+
+
+inductive SeedGenerator where
+  | T : Fin 3 → SeedGenerator
+  | U : Fin 3 → SeedGenerator
+  | V : Fin 3 → SeedGenerator
+  | W : Fin 3 → Fin 3 → SeedGenerator
+  deriving DecidableEq, Fintype
+
+inductive Rule where
+  | TT : Fin 3 → Fin 3 → Rule
+  | Tu : Fin 3 → Fin 3 → Rule
+  | Tv : Fin 3 → Fin 3 → Rule
+  | Tw : Fin 3 → Fin 3 → Fin 3 → Rule
+  | diagonal : Fin 3 → Rule
+  | square : Fin 3 → Rule
+  | UU : Fin 3 → Fin 3 → Rule
+  | VV : Fin 3 → Fin 3 → Rule
+  | UV : Fin 3 → Fin 3 → Rule
+  | WU : Fin 3 → Fin 3 → Fin 3 → Rule
+  | WV : Fin 3 → Fin 3 → Fin 3 → Rule
+  | UWout : Fin 3 → Fin 3 → Rule
+  | WVout : Fin 3 → Fin 3 → Rule
+  deriving DecidableEq, Fintype
+
+/-- Finite seed equation patterns. Vacuous index combinations give 1=1. -/
+def equation {G : Type*} [Group G] (D : SeedValues G) : Rule → G × G
+  | .TT i j => (D.T i*D.T j, D.T j*D.T i)
+  | .Tu l i => (D.T l*D.u i*(D.T l)⁻¹, orbit (D.T i) (D.u i) (if l=i then 1 else 0))
+  | .Tv l i => (D.T l*D.v i*(D.T l)⁻¹, orbit (D.T i) (D.v i) (if l=i then 1 else 0))
+  | .Tw l i j => (D.T l*D.w i j*(D.T l)⁻¹,
+      orbit (D.T i) (D.w i j) ((if l=i then 1 else 0)-(if l=j then 1 else 0)))
+  | .diagonal i => (D.w i i, 1)
+  | .square i => (D.u i*D.u i, 1)
+  | .UU i j => if i≠j then (D.u i*D.u j, D.u j*D.u i) else (1,1)
+  | .VV i j => if i≠j then (D.v i*D.v j, D.v j*D.v i) else (1,1)
+  | .UV i j => if i≠j then (D.u i*D.v j, D.v j*D.u i) else (1,1)
+  | .WU i j h => if h≠i then (D.w i j*D.u h, D.u h*D.w i j) else (1,1)
+  | .WV i j h => if h≠j then (D.w i j*D.v h, D.v h*D.w i j) else (1,1)
+  | .UWout i j => if i≠j then (⁅D.u i,D.w i j⁆, D.u j) else (1,1)
+  | .WVout i j => if i≠j then (⁅D.w i j,D.v j⁆, D.v i) else (1,1)
+
+def freeSeeds : SeedValues (FreeGroup SeedGenerator) where
+  T i := FreeGroup.of (.T i)
+  u i := FreeGroup.of (.U i)
+  v i := FreeGroup.of (.V i)
+  w i j := FreeGroup.of (.W i j)
+
+def evalSeeds {G : Type*} (D : SeedValues G) : SeedGenerator → G
+  | .T i => D.T i
+  | .U i => D.u i
+  | .V i => D.v i
+  | .W i j => D.w i j
+
+theorem equation_evaluate {G : Type*} [Group G] (D : SeedValues G) (r : Rule) :
+    FreeGroup.lift (evalSeeds D) (equation freeSeeds r).1 = (equation D r).1 ∧
+    FreeGroup.lift (evalSeeds D) (equation freeSeeds r).2 = (equation D r).2 := by
+  cases r <;> dsimp only [equation] <;> (try split_ifs) <;> simp [orbit, freeSeeds, evalSeeds]
+
+def relator (r : Rule) : FreeGroup SeedGenerator :=
+  (equation freeSeeds r).1 * (equation freeSeeds r).2⁻¹
+
+def finiteRelators : Set (FreeGroup SeedGenerator) := Set.range relator
+abbrev Model := PresentedGroup finiteRelators
+
+instance : Finite finiteRelators := Set.finite_range relator
+instance : Group.IsFinitelyPresented Model := inferInstance
+
+def modelValues : SeedValues Model where
+  T i := PresentedGroup.of (.T i)
+  u i := PresentedGroup.of (.U i)
+  v i := PresentedGroup.of (.V i)
+  w i j := PresentedGroup.of (.W i j)
+
+theorem model_equation (r : Rule) :
+    (equation modelValues r).1 = (equation modelValues r).2 := by
+  have hm : FreeGroup.lift (evalSeeds modelValues) = PresentedGroup.mk finiteRelators := by
+    apply FreeGroup.ext_hom
+    intro s
+    cases s <;> rfl
+  have h := PresentedGroup.mk_eq_mk_of_mul_inv_mem (rels := finiteRelators)
+    (x := (equation freeSeeds r).1) (y := (equation freeSeeds r).2) ⟨r,rfl⟩
+  obtain ⟨h₁,h₂⟩ := equation_evaluate modelValues r
+  rw [hm] at h₁ h₂
+  exact h₁.symm.trans (h.trans h₂)
+
+def modelSeedData : SeedData Model where
+  toSeedValues := modelValues
+  TT i j := by simpa [equation, Commute, SemiconjBy] using model_equation (.TT i j)
+  Tu l i := model_equation (.Tu l i)
+  Tv l i := model_equation (.Tv l i)
+  Tw l i j := model_equation (.Tw l i j)
+  diagonal i := model_equation (.diagonal i)
+  square i := model_equation (.square i)
+  UU i j h := by simpa [equation, h, Commute, SemiconjBy] using model_equation (.UU i j)
+  VV i j h := by simpa [equation, h, Commute, SemiconjBy] using model_equation (.VV i j)
+  UV i j h := by simpa [equation, h, Commute, SemiconjBy] using model_equation (.UV i j)
+  WU i j h hh := by simpa [equation, hh, Commute, SemiconjBy] using model_equation (.WU i j h)
+  WV i j h hh := by simpa [equation, hh, Commute, SemiconjBy] using model_equation (.WV i j h)
+  UWout i j h := by simpa [equation, h] using model_equation (.UWout i j)
+  WVout i j h := by simpa [equation, h] using model_equation (.WVout i j)
+
+/-- The homomorphism from the supplied infinite presentation to the finite model. -/
+def toModel : Presentation.AuxiliaryGroup →* Model :=
+  Presentation.ofData modelSeedData.toSelection
+
+
+section OriginalSeeds
+variable {G : Type*} [Group G] (D : SelectionGroupData G)
+
+@[simp] theorem selection_U_orbit (i : Fin 3) (a : ℤ) :
+    orbit (D.T i) (D.U i 0) (-a) = D.U i a := by
+  have h := family_zpow (D.T i) (D.U i) (-1)
+    (fun r => by simpa only [ite_true, sub_eq_add_neg] using D.conj_TU i i r) (-a) 0
+  simpa using h
+
+@[simp] theorem selection_V_orbit (i : Fin 3) (a : ℤ) :
+    orbit (D.T i) (D.V i 0) a = D.V i a := by
+  have h := family_zpow (D.T i) (D.V i) 1
+    (fun r => by simpa only [ite_true] using D.conj_TV i i r) a 0
+  simpa using h
+
+@[simp] theorem selection_W_orbit (i j : Fin 3) (a : ℤ) :
+    orbit (D.T i) (D.W i j 0) a = D.W i j a := by
+  by_cases hij : i=j
+  · subst j
+    simp [orbit, D.diagonal_W]
+  · have h := family_zpow (D.T i) (D.W i j) 1
+      (fun r => by simpa [hij] using D.conj_TW i i j r) a 0
+    simpa using h
+
+/-- The original presentation satisfies each of the finite seed equations. -/
+def originalSeeds : SeedData G where
+  T := D.T
+  u i := D.U i 0
+  v i := D.V i 0
+  w i j := D.W i j 0
+  TT := D.commute_TT
+  Tu l i := by
+    have h := D.conj_TU l i 0
+    have hh := selection_U_orbit D i (-(if l=i then 1 else 0))
+    simp only [neg_neg] at hh
+    rw [hh]
+    simpa using h
+  Tv l i := by
+    rw [selection_V_orbit]
+    simpa using D.conj_TV l i 0
+  Tw l i j := by
+    rw [selection_W_orbit]
+    simpa using D.conj_TW l i j 0
+  diagonal i := D.diagonal_W i 0
+  square i := D.square_U i 0
+  UU i j h := D.commute_UU i j 0 0 h
+  VV i j h := D.commute_VV i j 0 0 h
+  UV i j h := D.commute_UV i j 0 0 h
+  WU i j h hh := D.commute_WU i j h 0 0 hh
+  WV i j h hh := D.commute_WV i j h 0 0 hh
+  UWout i j h := by simpa using D.commutator_UW i j 0 0 h
+  WVout i j h := by simpa using D.commutator_WV i j 0 0 h
+end OriginalSeeds
+
+theorem seed_equation {G : Type*} [Group G] (D : SeedData G) (r : Rule) :
+    (equation D.toSeedValues r).1 = (equation D.toSeedValues r).2 := by
+  cases r with
+  | TT i j => exact (D.TT i j).eq
+  | Tu l i => exact D.Tu l i
+  | Tv l i => exact D.Tv l i
+  | Tw l i j => exact D.Tw l i j
+  | diagonal i => exact D.diagonal i
+  | square i => exact D.square i
+  | UU i j =>
+      by_cases h : i≠j
+      · simpa only [equation, ite_eq_left h] using (D.UU i j h).eq
+      · simp [equation, h]
+  | VV i j =>
+      by_cases h : i≠j
+      · simpa only [equation, ite_eq_left h] using (D.VV i j h).eq
+      · simp [equation, h]
+  | UV i j =>
+      by_cases h : i≠j
+      · simpa only [equation, ite_eq_left h] using (D.UV i j h).eq
+      · simp [equation, h]
+  | WU i j k =>
+      by_cases h : k≠i
+      · simpa only [equation, ite_eq_left h] using (D.WU i j k h).eq
+      · simp [equation, h]
+  | WV i j k =>
+      by_cases h : k≠j
+      · simpa only [equation, ite_eq_left h] using (D.WV i j k h).eq
+      · simp [equation, h]
+  | UWout i j => by_cases h : i≠j <;> simp [equation, h, (D.UWout i j)]
+  | WVout i j => by_cases h : i≠j <;> simp [equation, h, (D.WVout i j)]
+
+/-- Universal evaluation of the finite presentation in any proved seed data. -/
+def modelLift {G : Type*} [Group G] (D : SeedData G) : Model →* G :=
+  PresentedGroup.toGroup (f := evalSeeds D.toSeedValues) (by
+    intro r hr
+    obtain ⟨s,rfl⟩ := hr
+    dsimp only [relator]
+    rw [map_mul, map_inv, (equation_evaluate D.toSeedValues s).1,
+      (equation_evaluate D.toSeedValues s).2, seed_equation D s, mul_inv_cancel])
+
+@[simp] theorem modelLift_of {G : Type*} [Group G] (D : SeedData G) (s : SeedGenerator) :
+    modelLift D (PresentedGroup.of s) = evalSeeds D.toSeedValues s := PresentedGroup.toGroup.of _
+
+def fromModel : Model →* Presentation.AuxiliaryGroup :=
+  modelLift (originalSeeds Presentation.data)
+
+
+@[simp] theorem map_orbit {G H : Type*} [Group G] [Group H] (f : G →* H)
+    (t x : G) (a : ℤ) : f (orbit t x a) = orbit (f t) (f x) a := by simp [orbit]
+
+@[simp] theorem toModel_T (i : Fin 3) :
+    toModel (Presentation.data.T i) = modelValues.T i :=
+  Presentation.ofData_of modelSeedData.toSelection (.T i)
+@[simp] theorem toModel_U (i : Fin 3) (a : ℤ) :
+    toModel (Presentation.data.U i a) = orbit (modelValues.T i) (modelValues.u i) (-a) :=
+  Presentation.ofData_of modelSeedData.toSelection (.U i a)
+@[simp] theorem toModel_V (i : Fin 3) (a : ℤ) :
+    toModel (Presentation.data.V i a) = orbit (modelValues.T i) (modelValues.v i) a :=
+  Presentation.ofData_of modelSeedData.toSelection (.V i a)
+@[simp] theorem toModel_W (i j : Fin 3) (a : ℤ) :
+    toModel (Presentation.data.W i j a) = orbit (modelValues.T i) (modelValues.w i j) a :=
+  Presentation.ofData_of modelSeedData.toSelection (.W i j a)
+
+@[simp] theorem fromModel_T (i : Fin 3) :
+    fromModel (modelValues.T i) = Presentation.data.T i :=
+  modelLift_of (originalSeeds Presentation.data) (.T i)
+@[simp] theorem fromModel_u (i : Fin 3) :
+    fromModel (modelValues.u i) = Presentation.data.U i 0 :=
+  modelLift_of (originalSeeds Presentation.data) (.U i)
+@[simp] theorem fromModel_v (i : Fin 3) :
+    fromModel (modelValues.v i) = Presentation.data.V i 0 :=
+  modelLift_of (originalSeeds Presentation.data) (.V i)
+@[simp] theorem fromModel_w (i j : Fin 3) :
+    fromModel (modelValues.w i j) = Presentation.data.W i j 0 :=
+  modelLift_of (originalSeeds Presentation.data) (.W i j)
+
+theorem fromModel_toModel : fromModel.comp toModel = MonoidHom.id Presentation.AuxiliaryGroup := by
+  apply PresentedGroup.ext
+  intro s
+  cases s with
+  | T i =>
+      change fromModel (toModel (Presentation.data.T i)) = Presentation.data.T i
+      simp
+  | U i a =>
+      change fromModel (toModel (Presentation.data.U i a)) = Presentation.data.U i a
+      simp
+  | V i a =>
+      change fromModel (toModel (Presentation.data.V i a)) = Presentation.data.V i a
+      simp
+  | W i j a =>
+      change fromModel (toModel (Presentation.data.W i j a)) = Presentation.data.W i j a
+      simp
+
+theorem toModel_fromModel : toModel.comp fromModel = MonoidHom.id Model := by
+  apply PresentedGroup.ext
+  intro s
+  cases s with
+  | T i =>
+      change toModel (fromModel (modelValues.T i)) = modelValues.T i
+      simp
+  | U i =>
+      change toModel (fromModel (modelValues.u i)) = modelValues.u i
+      simp
+  | V i =>
+      change toModel (fromModel (modelValues.v i)) = modelValues.v i
+      simp
+  | W i j =>
+      change toModel (fromModel (modelValues.w i j)) = modelValues.w i j
+      simp
+
+/-- Equivalence of the explicit finite presentation and the supplied infinite presentation. -/
+def presentationEquiv : Model ≃* Presentation.AuxiliaryGroup where
+  toFun := fromModel
+  invFun := toModel
+  left_inv x := DFunLike.congr_fun toModel_fromModel x
+  right_inv x := DFunLike.congr_fun fromModel_toModel x
+  map_mul' := fromModel.map_mul
+
+/-- Section 2, Lemma group-finite-presentation, for the exact supplied AuxiliaryGroup. -/
+theorem auxiliaryGroup_isFinitelyPresented :
+    Group.IsFinitelyPresented Presentation.AuxiliaryGroup :=
+  Group.IsFinitelyPresented.equiv presentationEquiv
+
+/-- The finite model retains the three redundant diagonal W generators. -/
+theorem seedGenerator_card : Fintype.card SeedGenerator = 18 := by decide
+/-- Number of indexed finite equation patterns, including tautological cases. -/
+theorem rule_card : Fintype.card Rule = 159 := by decide +kernel
+
+theorem model_isFinitelyPresented : Group.IsFinitelyPresented Model := inferInstance
+end LittleFinitistic.FinitePresentation
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Selection/FiniteQuotient.lean b/lean/OAI/Algebra/Finitistic/Selection/FiniteQuotient.lean
new file mode 100644
index 0000000000000000000000000000000000000000..87c767fdbe4289ab891eb17ea176d07f034e0941
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Selection/FiniteQuotient.lean
@@ -0,0 +1,245 @@
+import Mathlib.LinearAlgebra.Matrix.Diagonal
+import Mathlib.RingTheory.AdjoinRoot
+import Mathlib.Data.ZMod.Basic
+import Mathlib.GroupTheory.Commutator.Basic
+import Mathlib.Tactic.NoncommRing
+import Mathlib.Tactic.Abel
+
+namespace OAI
+/-!
+Exact prerequisites for Section 2 of v5s9.15.
+
+These are the variable-coefficient elementary-matrix calculations in the
+finite-quotient construction, over the actual rings F₂[t]/(t^m - 1).
+They do not establish the paper's main homological theorem.
+-/
+
+open Matrix Polynomial
+
+namespace LittleFinitistic
+
+section ElementaryMatrices
+
+variable {R : Type*} [CommRing R]
+variable {ι : Type*} [Fintype ι] [DecidableEq ι]
+
+def transvection (i j : ι) (a : R) : Matrix ι ι R := 1 + Matrix.single i j a
+
+theorem single_square_zero (i j : ι) (hij : i ≠ j) (a : R) :
+    (Matrix.single i j a : Matrix ι ι R) * Matrix.single i j a = 0 := by
+  exact Matrix.single_mul_single_of_ne a i j i (Ne.symm hij) a
+
+theorem transvection_mul_neg (i j : ι) (hij : i ≠ j) (a : R) :
+    transvection i j a * transvection i j (-a) = 1 := by
+  simp only [transvection, ← Matrix.single_neg, mul_add, add_mul, mul_one, one_mul,
+    mul_neg, single_square_zero i j hij]
+  abel
+
+def transvectionUnit (i j : ι) (hij : i ≠ j) (a : R) : (Matrix ι ι R)ˣ where
+  val := transvection i j a
+  inv := transvection i j (-a)
+  val_inv := transvection_mul_neg i j hij a
+  inv_val := by simpa using transvection_mul_neg i j hij (-a)
+
+theorem transvection_same (i j : ι) (hij : i ≠ j) (a b : R) :
+    transvection i j a * transvection i j b = transvection i j (a + b) := by
+  simp only [transvection, mul_add, add_mul, mul_one, one_mul,
+    Matrix.single_mul_single_of_ne a i j i (Ne.symm hij) b, Matrix.single_add]
+  abel
+
+theorem nilpotent_commutator {A : Type*} [Ring A] (a b : A)
+    (haa : a * a = 0) (hbb : b * b = 0) (hba : b * a = 0) :
+    (1+a)*(1+b)*(1-a)*(1-b) = 1+a*b := by
+  calc
+    (1+a)*(1+b)*(1-a)*(1-b) =
+        1 + a*b - a*a - b*a - a*b*a - b*b - a*b*b + a*a*b + b*a*b + a*b*a*b := by
+          noncomm_ring
+    _ = 1 + a*b := by
+      simp [haa, hbb, hba, mul_assoc]
+
+theorem transvection_commutator (i j k : ι)
+    (hij : i ≠ j) (hjk : j ≠ k) (hik : i ≠ k) (a b : R) :
+    transvection i j a * transvection j k b *
+      transvection i j (-a) * transvection j k (-b) =
+      transvection i k (a*b) := by
+  have haa := single_square_zero i j hij a
+  have hbb := single_square_zero j k hjk b
+  have hba : (Matrix.single j k b : Matrix ι ι R) * Matrix.single i j a = 0 :=
+    Matrix.single_mul_single_of_ne b j k i (Ne.symm hik) a
+  simpa [transvection, ← Matrix.single_neg, sub_eq_add_neg] using
+    nilpotent_commutator (Matrix.single i j a) (Matrix.single j k b) haa hbb hba
+
+theorem transvection_commute (i j k l : ι)
+    (hjk : j ≠ k) (hli : l ≠ i) (a b : R) :
+    Commute (transvection i j a) (transvection k l b) := by
+  show transvection i j a * transvection k l b =
+    transvection k l b * transvection i j a
+  simp only [transvection, mul_add, add_mul, mul_one, one_mul,
+    Matrix.single_mul_single_of_ne a i j k hjk b,
+    Matrix.single_mul_single_of_ne b k l i hli a]
+  abel
+
+omit [Fintype ι] in
+theorem transvection_injective (i j : ι) (hij : i ≠ j) :
+    Function.Injective (transvection (R := R) i j) := by
+  intro a b h
+  have := congrArg (fun M : Matrix ι ι R => M i j) h
+  simpa [transvection, Matrix.single, Matrix.one_apply, hij] using this
+
+def diagonalUnit (d : ι → Rˣ) : (Matrix ι ι R)ˣ where
+  val := Matrix.diagonal (fun i => (d i : R))
+  inv := Matrix.diagonal (fun i => ((d i)⁻¹ : Rˣ))
+  val_inv := by
+    rw [Matrix.diagonal_mul_diagonal]
+    simp
+  inv_val := by
+    rw [Matrix.diagonal_mul_diagonal]
+    simp
+
+theorem diagonal_single_conjugation (d : ι → Rˣ) (i j : ι) (a : R) :
+    (diagonalUnit d : Matrix ι ι R) * Matrix.single i j a *
+      ((diagonalUnit d)⁻¹ : (Matrix ι ι R)ˣ) =
+      Matrix.single i j ((d i : R) * a * ((d j)⁻¹ : Rˣ)) := by
+  ext k l
+  change (Matrix.diagonal (fun s => (d s : R)) * Matrix.single i j a *
+      Matrix.diagonal (fun s => (((d s)⁻¹ : Rˣ) : R))) k l = _
+  rw [Matrix.mul_diagonal,Matrix.diagonal_mul]
+  by_cases hi : i=k <;> by_cases hj : j=l <;>
+    simp [hi, hj]
+
+theorem diagonal_transvection_conjugation (d : ι → Rˣ) (i j : ι) (a : R) :
+    (diagonalUnit d : Matrix ι ι R) * transvection i j a *
+      ((diagonalUnit d)⁻¹ : (Matrix ι ι R)ˣ) =
+      transvection i j ((d i : R) * a * ((d j)⁻¹ : Rˣ)) := by
+  simp only [transvection,mul_add,add_mul,mul_one,Units.mul_inv,diagonal_single_conjugation]
+
+theorem diagonalUnit_commute (d e : ι → Rˣ) : Commute (diagonalUnit d) (diagonalUnit e) := by
+  apply Units.ext
+  exact (Matrix.commute_diagonal (d₁ := fun i => (d i : R))
+    (d₂ := fun i => (e i : R))).eq
+
+theorem transvectionUnit_commute (i j k l : ι) (hij : i≠j) (hkl : k≠l)
+    (hjk : j≠k) (hli : l≠i) (a b : R) :
+    Commute (transvectionUnit i j hij a) (transvectionUnit k l hkl b) := by
+  apply Units.ext
+  exact (transvection_commute i j k l hjk hli a b).eq
+
+open scoped commutatorElement in
+theorem transvectionUnit_commutator (i j k : ι)
+    (hij : i≠j) (hjk : j≠k) (hik : i≠k) (a b : R) :
+    ⁅transvectionUnit i j hij a,transvectionUnit j k hjk b⁆ =
+      transvectionUnit i k hik (a*b) := by
+  apply Units.ext
+  exact transvection_commutator i j k hij hjk hik a b
+
+theorem transvectionUnit_conjugation (d : ι → Rˣ) (i j : ι) (hij : i≠j) (a : R) :
+    diagonalUnit d * transvectionUnit i j hij a * (diagonalUnit d)⁻¹ =
+      transvectionUnit i j hij ((d i : R) * a * ((d j)⁻¹ : Rˣ)) := by
+  apply Units.ext
+  exact diagonal_transvection_conjugation d i j a
+
+end ElementaryMatrices
+
+noncomputable def cyclicPolynomial (m : ℕ) : Polynomial (ZMod 2) := X^m - C 1
+abbrev CyclicRing (m : ℕ) := AdjoinRoot (cyclicPolynomial m)
+
+theorem cyclicPolynomial_monic (m : ℕ) (hm : m ≠ 0) :
+    (cyclicPolynomial m).Monic := Polynomial.monic_X_pow_sub_C 1 hm
+
+theorem cyclicPolynomial_degree (m : ℕ) :
+    (cyclicPolynomial m).natDegree = m := Polynomial.natDegree_X_pow_sub_C
+
+noncomputable def cyclicBasis (m : ℕ) (hm : m ≠ 0) :
+    Module.Basis (Fin m) (ZMod 2) (CyclicRing m) :=
+  ((AdjoinRoot.powerBasis' (cyclicPolynomial_monic m hm)).basis).reindex
+    (finCongr (cyclicPolynomial_degree m))
+
+theorem cyclicRing_finite (m : ℕ) (hm : m ≠ 0) : Finite (CyclicRing m) := by
+  exact Finite.of_injective (cyclicBasis m hm).repr (cyclicBasis m hm).repr.injective
+
+theorem cyclic_root_pow (m : ℕ) :
+    AdjoinRoot.root (cyclicPolynomial m) ^ m = (1 : CyclicRing m) := by
+  have h : AdjoinRoot.mk (cyclicPolynomial m) (X^m - C 1) = 0 :=
+    AdjoinRoot.mk_eq_zero.mpr (dvd_refl _)
+  rw [map_sub, map_pow, AdjoinRoot.mk_X, Polynomial.C_1, map_one] at h
+  exact sub_eq_zero.mp h
+
+theorem cyclic_root_isUnit (m : ℕ) (hm : 0 < m) :
+    IsUnit (AdjoinRoot.root (cyclicPolynomial m)) := by
+  exact IsUnit.of_pow_eq_one (cyclic_root_pow m) (Nat.ne_of_gt hm)
+
+theorem cyclicBasis_apply (m : ℕ) (hm : m ≠ 0) (i : Fin m) :
+    cyclicBasis m hm i = AdjoinRoot.root (cyclicPolynomial m) ^ (i : ℕ) := by
+  simp only [cyclicBasis, Module.Basis.reindex_apply, PowerBasis.basis_eq_pow,
+    AdjoinRoot.powerBasis'_gen]
+  rfl
+
+theorem cyclic_powers_independent (m : ℕ) (hm : m ≠ 0) :
+    LinearIndependent (ZMod 2)
+      (fun i : Fin m => AdjoinRoot.root (cyclicPolynomial m) ^ (i : ℕ)) := by
+  have h : (fun i : Fin m => cyclicBasis m hm i) =
+      (fun i : Fin m => AdjoinRoot.root (cyclicPolynomial m) ^ (i : ℕ)) :=
+    funext (cyclicBasis_apply m hm)
+  rw [← h]
+  exact (cyclicBasis m hm).linearIndependent
+
+/-- The central coefficient embedding in the displayed 5-by-5 matrix model. -/
+noncomputable def centralMatrix (m : ℕ) (c : Fin m → ZMod 2) :
+    Matrix (Fin 5) (Fin 5) (CyclicRing m) :=
+  transvection 0 4 (∑ i, c i • AdjoinRoot.root (cyclicPolynomial m) ^ (i : ℕ))
+
+theorem centralMatrix_zero (m : ℕ) : centralMatrix m 0 = 1 := by
+  simp [centralMatrix, transvection]
+
+theorem centralMatrix_add (m : ℕ) (c d : Fin m → ZMod 2) :
+    centralMatrix m (c + d) = centralMatrix m c * centralMatrix m d := by
+  rw [centralMatrix, centralMatrix, centralMatrix,
+    transvection_same 0 4 (by decide)]
+  congr 1
+  simp only [Pi.add_apply, add_smul, Finset.sum_add_distrib]
+
+theorem centralMatrix_injective (m : ℕ) (hm : m ≠ 0) :
+    Function.Injective (centralMatrix m) := by
+  intro c d h
+  have hs := transvection_injective (R := CyclicRing m) (0 : Fin 5) 4 (by decide) h
+  have hz : ∑ i : Fin m, (c i - d i) •
+      AdjoinRoot.root (cyclicPolynomial m) ^ (i : ℕ) = 0 := by
+    simp only [sub_smul, Finset.sum_sub_distrib, hs, sub_self]
+  have hc := (linearIndependent_iff'.mp (cyclic_powers_independent m hm))
+    Finset.univ (fun i => c i - d i) (by simpa using hz)
+  funext i
+  exact sub_eq_zero.mp (hc i (Finset.mem_univ i))
+
+theorem centralMatrix_involution (m : ℕ) (c : Fin m → ZMod 2) :
+    centralMatrix m c * centralMatrix m c = 1 := by
+  rw [← centralMatrix_add]
+  have h : c + c = 0 := by
+    funext i
+    exact CharTwo.add_self_eq_zero (c i)
+  rw [h, centralMatrix_zero]
+
+/-- This is the concrete copy of the elementary abelian 2-group used by the
+paper's finite matrix quotient. Its realization as a quotient of the presented
+group remains separate from the verified embedding below. -/
+noncomputable def centralEmbedding (m : ℕ) :
+    Multiplicative (Fin m → ZMod 2) →* (Matrix (Fin 5) (Fin 5) (CyclicRing m))ˣ where
+  toFun c :=
+    { val := centralMatrix m c.toAdd
+      inv := centralMatrix m c.toAdd
+      val_inv := centralMatrix_involution m c.toAdd
+      inv_val := centralMatrix_involution m c.toAdd }
+  map_one' := by
+    apply Units.ext
+    exact centralMatrix_zero m
+  map_mul' c d := by
+    apply Units.ext
+    exact centralMatrix_add m c.toAdd d.toAdd
+
+theorem centralEmbedding_injective (m : ℕ) (hm : m ≠ 0) :
+    Function.Injective (centralEmbedding m) := by
+  intro c d h
+  exact (centralMatrix_injective m hm) (congrArg Units.val h)
+
+end LittleFinitistic
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Selection/FiniteSelectionFamily.lean b/lean/OAI/Algebra/Finitistic/Selection/FiniteSelectionFamily.lean
new file mode 100644
index 0000000000000000000000000000000000000000..0694c56fc80e90b57f8891c1de6e838f50fdd9a0
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Selection/FiniteSelectionFamily.lean
@@ -0,0 +1,87 @@
+import OAI.Algebra.Finitistic.Selected.SelectedRealization
+
+namespace OAI
+noncomputable section
+open CategoryTheory CategoryTheory.Limits
+attribute [local instance] HasDerivedCategory.standard HasExt.standard
+namespace LittleFinitistic.FiniteSelectionFamily
+open SelectedFixedDiagram QuadraticEncoding
+
+/-- Actual finite-dimensional modules over the fixed selecting algebra. -/
+def S := {M : ModuleCat SelectionRing // FiniteDimensional ℂ (complexObject M)}
+abbrev vector (Y : S) := complexObject Y.val
+instance (Y : S) : FiniteDimensional ℂ (vector Y) := Y.property
+instance ringModule (Y : S) : Module SelectionRing (vector Y) :=
+  inferInstanceAs (Module SelectionRing Y.val)
+instance tower (Y : S) : IsScalarTower ℂ SelectionRing (vector Y) :=
+  IsScalarTower.of_algebraMap_smul (fun _ _ => rfl)
+
+/-- H preserves this actual finite-dimensional family. -/
+def H (Y : S) : S := ⟨selectionStep Y.val, by
+  let : FiniteDimensional ℂ (complexObject Y.val) := Y.property
+  exact selectionStep_finiteDimensional Y.val⟩
+
+abbrev representation (Y : S) := SourceActionEvaluation.representation (Y := vector Y) encoding
+abbrev module (Y : S) := EvaluationVertexDiagram.module (representation Y)
+abbrev derived (Y : S) := (DerivedCategory.singleFunctor (ModuleCat (B P)) 0).obj (module Y)
+
+/-- The proved one-step realization uses the actual endomap of the finite family. -/
+def realization (Y : S) :
+    SelectedTensorSplitting.object (representation Y).Evaluation ≅
+      derived (H Y) ⊞ (derived (H Y))⟦(3 : ℤ)⟧ :=
+  SelectedRealization.realization (Y := vector Y)
+
+/-- Evaluation on three copies preserves and reflects the zero module. -/
+theorem module_zero (Y : S) : IsZero (module Y) ↔ Subsingleton Y.val := by
+  constructor
+  · intro h
+    let := ModuleCat.subsingleton_of_isZero h
+    have inj : Function.Injective ((representation Y).inclusion 0) := by
+      intro x y hxy
+      have := congrArg ((representation Y).projection 0) hxy
+      simpa only [Representation.projection_inclusion] using this
+    exact inj.subsingleton
+  · intro h
+    let := h
+    have : Subsingleton (representation Y).Evaluation :=
+      inferInstanceAs (Subsingleton (Y.val × Y.val × Y.val))
+    exact ModuleCat.isZero_of_subsingleton _
+
+/-- The same exact zero criterion after embedding in the actual derived category. -/
+theorem derived_zero (Y : S) : IsZero (derived Y) ↔ Subsingleton Y.val := by
+  rw [← module_zero Y]
+  constructor
+  · intro h
+    exact ((DerivedCategory.singleFunctorCompHomologyFunctorIso (ModuleCat (B P)) 0).app
+      (module Y)).isZero_iff.mp ((DerivedCategory.homologyFunctor (ModuleCat (B P)) 0).map_isZero h)
+  · exact (DerivedCategory.singleFunctor (ModuleCat (B P)) 0).map_isZero
+
+/-- Iteration is literally the Section 2 selection operation. -/
+theorem iterate_val (j : ℕ) (Y : S) : ((H^[j]) Y).val = selectionIterate Y.val j := by
+  induction j with
+  | zero => rfl
+  | succ j ih =>
+    rw [Function.iterate_succ_apply']
+    change selectionStep ((H^[j]) Y).val = selectionStep (selectionIterate Y.val j)
+    exact congrArg selectionStep ih
+
+def test (m : ℕ) [NeZero m] : S := ⟨testObject m, testObject_finiteDimensional m⟩
+
+/-- Exact finite extinction is retained by the actual derived evaluation family. -/
+theorem extinction (m : ℕ) [NeZero m] :
+    (∀ j < m, ¬ IsZero (derived ((H^[j]) (test m)))) ∧
+      IsZero (derived ((H^[m]) (test m))) := by
+  constructor
+  · intro j hj hz
+    have hs := (derived_zero _).mp hz
+    rw [iterate_val] at hs
+    have hn := selectionIterate_test_nontrivial m j hj
+    exact @not_subsingleton _ hn hs
+  · apply (derived_zero _).mpr
+    rw [iterate_val]
+    exact selectionIterate_test_subsingleton m
+end LittleFinitistic.FiniteSelectionFamily
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Selection/GroupAlgebraPresentation.lean b/lean/OAI/Algebra/Finitistic/Selection/GroupAlgebraPresentation.lean
new file mode 100644
index 0000000000000000000000000000000000000000..3824ebb19545165c96cc0b629a64680035c0c0df
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Selection/GroupAlgebraPresentation.lean
@@ -0,0 +1,245 @@
+import Mathlib.Algebra.FreeAlgebra
+import Mathlib.RingTheory.Congruence.Hom
+import Mathlib.GroupTheory.FinitelyPresentedGroup
+import Mathlib.Basic.Complex.Basic
+
+namespace OAI
+/-! Section 2 bridge. All algebras here are associative, unital, and may be
+noncommutative. The defining congruence is generated by finitely many equations
+in a free associative algebra; no commutative finite-presentation API is used. -/
+noncomputable section
+namespace LittleFinitistic.GroupAlgebraPresentation
+
+variable (R : Type*) [CommRing R] (α : Type*)
+
+/-- A representative word, chosen only to turn a group relator into a polynomial. -/
+def word (g : FreeGroup α) : List (α × Bool) :=
+  Classical.choose (Quot.exists_rep g)
+
+theorem word_spec (g : FreeGroup α) : FreeGroup.mk (word α g) = g :=
+  Classical.choose_spec (Quot.exists_rep g)
+
+def polynomial (g : FreeGroup α) : FreeAlgebra R (α × Bool) :=
+  ((word α g).map (FreeAlgebra.ι R)).prod
+
+variable {α R}
+
+theorem eval_polynomial {A : Type*} [Ring A] [Algebra R A]
+    (f : α → Aˣ) (F : FreeAlgebra R (α × Bool) →ₐ[R] A)
+    (hf : ∀ a b, F (FreeAlgebra.ι R (a,b)) =
+      ↑(if b then f a else (f a)⁻¹)) (g : FreeGroup α) :
+    F (polynomial R α g) = ↑(FreeGroup.lift f g) := by
+  conv_rhs => rw [← word_spec α g]
+  simp only [polynomial, map_list_prod, List.map_map, FreeGroup.lift_mk]
+  induction word α g with
+  | nil => simp
+  | cons a l ih =>
+    rcases a with ⟨a,b⟩
+    simp only [List.map_cons, List.prod_cons, Function.comp_apply, Units.val_mul]
+    rw [hf, ih]
+    cases b <;> rfl
+
+variable (R α) (rels : Set (FreeGroup α))
+
+abbrev Letter := α × Bool
+abbrev EquationIndex := (α × Bool) ⊕ rels
+
+/-- Two inverse equations per generator, and one polynomial per group relator. -/
+def equation : EquationIndex α rels → FreeAlgebra R (Letter α)
+  | .inl (a,b) => FreeAlgebra.ι R (a,b) * FreeAlgebra.ι R (a,!b)
+  | .inr r => polynomial R α r
+
+def relations : RingCon (FreeAlgebra R (Letter α)) :=
+  ringConGen (fun x y => ∃ i : EquationIndex α rels, x = equation R α rels i ∧ y = 1)
+
+abbrev PresentedAlgebra := (relations R α rels).Quotient
+
+def quotientMap : FreeAlgebra R (Letter α) →ₐ[R] PresentedAlgebra R α rels :=
+  (relations R α rels).mkₐ R
+
+theorem equation_holds (i : EquationIndex α rels) :
+    quotientMap R α rels (equation R α rels i) = 1 := by
+  exact (relations R α rels).eq.mpr (RingConGen.Rel.of _ _ ⟨i,rfl,rfl⟩)
+
+def generatorUnit (a : α) : (PresentedAlgebra R α rels)ˣ where
+  val := quotientMap R α rels (FreeAlgebra.ι R (a,true))
+  inv := quotientMap R α rels (FreeAlgebra.ι R (a,false))
+  val_inv := by simpa [equation, map_mul] using equation_holds R α rels (.inl (a,true))
+  inv_val := by simpa [equation, map_mul] using equation_holds R α rels (.inl (a,false))
+
+theorem quotient_letter (a : α) (b : Bool) :
+    quotientMap R α rels (FreeAlgebra.ι R (a,b)) =
+      ↑(if b then generatorUnit R α rels a else (generatorUnit R α rels a)⁻¹) := by
+  cases b <;> rfl
+
+theorem unit_relator (r : FreeGroup α) (hr : r ∈ rels) :
+    FreeGroup.lift (generatorUnit R α rels) r = 1 := by
+  apply Units.ext
+  rw [← eval_polynomial _ _ (quotient_letter R α rels)]
+  exact equation_holds R α rels (.inr ⟨r,hr⟩)
+
+def groupToUnits : PresentedGroup rels →* (PresentedAlgebra R α rels)ˣ :=
+  PresentedGroup.toGroup (unit_relator R α rels)
+
+def fromGroupAlgebra : MonoidAlgebra R (PresentedGroup rels) →ₐ[R] PresentedAlgebra R α rels :=
+  MonoidAlgebra.lift R _ _ ((Units.coeHom _).comp (groupToUnits R α rels))
+
+def groupAlgebraUnit (a : α) : (MonoidAlgebra R (PresentedGroup rels))ˣ :=
+  (MonoidAlgebra.of R (PresentedGroup rels)).toHomUnits (PresentedGroup.of a)
+
+def evaluation : FreeAlgebra R (Letter α) →ₐ[R] MonoidAlgebra R (PresentedGroup rels) :=
+  FreeAlgebra.lift R (fun (a,b) =>
+    ↑(if b then groupAlgebraUnit R α rels a else (groupAlgebraUnit R α rels a)⁻¹))
+
+theorem evaluation_polynomial (r : FreeGroup α) :
+    evaluation R α rels (polynomial R α r) =
+      MonoidAlgebra.of R _ (PresentedGroup.mk rels r) := by
+  rw [eval_polynomial (groupAlgebraUnit R α rels) _ (by intros; simp [evaluation])]
+  have h : FreeGroup.lift (groupAlgebraUnit R α rels) =
+      (MonoidAlgebra.of R (PresentedGroup rels)).toHomUnits.comp (PresentedGroup.mk rels) := by
+    apply FreeGroup.ext_hom
+    intro a
+    simp [groupAlgebraUnit, PresentedGroup.of]
+  rw [h]
+  rfl
+
+theorem evaluation_equation (i : EquationIndex α rels) :
+    evaluation R α rels (equation R α rels i) = 1 := by
+  rcases i with ⟨a,b⟩ | ⟨r,hr⟩
+  · cases b <;> simp [equation, evaluation]
+  · rw [equation, evaluation_polynomial]
+    have h : PresentedGroup.mk rels r = 1 := by
+      exact PresentedGroup.one_of_mem hr
+    rw [h, map_one]
+
+def toGroupAlgebra : PresentedAlgebra R α rels →ₐ[R] MonoidAlgebra R (PresentedGroup rels) :=
+  (relations R α rels).liftₐ (evaluation R α rels)
+    (RingCon.ringConGen_le.mpr (by
+      rintro x y ⟨i,rfl,rfl⟩
+      exact (evaluation_equation R α rels i).trans (map_one _).symm))
+
+@[simp] theorem toGroupAlgebra_quotient (x : FreeAlgebra R (Letter α)) :
+    toGroupAlgebra R α rels (quotientMap R α rels x) = evaluation R α rels x := rfl
+
+@[simp] theorem fromGroupAlgebra_of (a : α) :
+    fromGroupAlgebra R α rels (MonoidAlgebra.of R _ (PresentedGroup.of a)) =
+      quotientMap R α rels (FreeAlgebra.ι R (a,true)) := by
+  simp [fromGroupAlgebra, groupToUnits, generatorUnit]
+
+@[simp] theorem fromGroupAlgebra_inv_of (a : α) :
+    fromGroupAlgebra R α rels (MonoidAlgebra.of R _ (PresentedGroup.of a)⁻¹) =
+      quotientMap R α rels (FreeAlgebra.ι R (a,false)) := by
+  simp [fromGroupAlgebra, groupToUnits, generatorUnit]
+
+@[simp] theorem from_to_letter (a : α) (b : Bool) :
+    fromGroupAlgebra R α rels (evaluation R α rels (FreeAlgebra.ι R (a,b))) =
+      quotientMap R α rels (FreeAlgebra.ι R (a,b)) := by
+  cases b
+  · simpa only [evaluation, FreeAlgebra.lift_ι_apply, Bool.false_eq_true, ite_false, groupAlgebraUnit, ← map_inv, MonoidHom.coe_toHomUnits]
+      using fromGroupAlgebra_inv_of R α rels a
+  · simpa only [evaluation, FreeAlgebra.lift_ι_apply, ite_true, groupAlgebraUnit, MonoidHom.coe_toHomUnits]
+      using fromGroupAlgebra_of R α rels a
+
+theorem from_to : (fromGroupAlgebra R α rels).comp (toGroupAlgebra R α rels) =
+    AlgHom.id R (PresentedAlgebra R α rels) := by
+  have h : ((fromGroupAlgebra R α rels).comp (toGroupAlgebra R α rels)).comp
+      (quotientMap R α rels) = quotientMap R α rels := by
+    apply FreeAlgebra.hom_ext
+    funext ⟨a,b⟩
+    exact from_to_letter R α rels a b
+  apply AlgHom.ext
+  intro x
+  obtain ⟨p,rfl⟩ := (relations R α rels).mkₐ_surjective (α := R) x
+  exact DFunLike.congr_fun h p
+
+theorem to_from : (toGroupAlgebra R α rels).comp (fromGroupAlgebra R α rels) =
+    AlgHom.id R (MonoidAlgebra R (PresentedGroup rels)) := by
+  apply (MonoidAlgebra.lift R _ _).symm.injective
+  have hext (f g : PresentedGroup rels →* MonoidAlgebra R (PresentedGroup rels))
+      (h : ∀ a, f (PresentedGroup.of a) = g (PresentedGroup.of a)) : f = g := by
+    have hh : f.comp (PresentedGroup.mk rels) = g.comp (PresentedGroup.mk rels) :=
+      FreeGroup.ext_hom _ _ h
+    apply MonoidHom.ext
+    intro x
+    obtain ⟨r,rfl⟩ := PresentedGroup.mk_surjective rels x
+    exact DFunLike.congr_fun hh r
+  apply hext
+  intro a
+  change toGroupAlgebra R α rels
+    (fromGroupAlgebra R α rels (MonoidAlgebra.of R _ (PresentedGroup.of a))) = _
+  rw [fromGroupAlgebra_of, toGroupAlgebra_quotient]
+  simp [evaluation, groupAlgebraUnit]
+
+/-- Explicit free associative algebra quotient presenting the group algebra. -/
+def quotientEquiv : PresentedAlgebra R α rels ≃ₐ[R] MonoidAlgebra R (PresentedGroup rels) :=
+  AlgEquiv.ofAlgHom (toGroupAlgebra R α rels) (fromGroupAlgebra R α rels)
+    (to_from R α rels) (from_to R α rels)
+
+
+/-- A finite presentation in the category of associative unital R-algebras.
+The finite generating set is not required to commute. A ring congruence is
+closed under multiplication on either side; these are two-sided equations. -/
+def HasFinitePresentation (A : Type*) [Ring A] [Algebra R A] : Prop :=
+  ∃ (ι κ : Type) (_ : Finite ι) (_ : Finite κ)
+    (lhs rhs : κ → FreeAlgebra R ι),
+    Nonempty ((ringConGen (fun x y => ∃ i, x = lhs i ∧ y = rhs i)).Quotient ≃ₐ[R] A)
+
+variable {R} in
+/-- Transport of a finite noncommutative presentation along an algebra equivalence. -/
+theorem HasFinitePresentation.of_equiv {A B : Type*} [Ring A] [Ring B]
+    [Algebra R A] [Algebra R B] (h : HasFinitePresentation R A) (e : A ≃ₐ[R] B) :
+    HasFinitePresentation R B := by
+  obtain ⟨ι,κ,hι,hκ,lhs,rhs,⟨q⟩⟩ := h
+  exact ⟨ι,κ,hι,hκ,lhs,rhs,⟨q.trans e⟩⟩
+
+/-- Finitely many group generators and relators give finitely many algebra
+letters and equations, and the explicit quotient is the group algebra. -/
+theorem presentedGroup_hasFinitePresentation (ι : Type) [Finite ι]
+    (s : Set (FreeGroup ι)) [Finite s] :
+    HasFinitePresentation R (MonoidAlgebra R (PresentedGroup s)) := by
+  exact ⟨Letter ι, EquationIndex ι s, inferInstance, inferInstance,
+    equation R ι s, fun _ => 1, ⟨quotientEquiv R ι s⟩⟩
+
+/-- General Section 2 bridge, with no commutativity assumption on the group
+or its group algebra and no finite-presentation assumption on the algebra. -/
+theorem groupAlgebra_hasFinitePresentation (G : Type*) [Group G]
+    [Group.IsFinitelyPresented G] : HasFinitePresentation R (MonoidAlgebra R G) := by
+  obtain ⟨n,s,hs,⟨e⟩⟩ := Group.IsFinitelyPresented.exists_mulEquiv_presentedGroup (G := G)
+  let : Finite s := hs
+  exact (presentedGroup_hasFinitePresentation R (Fin n) s).of_equiv
+    (MonoidAlgebra.domCongr R R e.symm)
+
+
+/-- Polynomial zero relations for the same explicit presentation. -/
+def zeroRelations : RingCon (FreeAlgebra R (Letter α)) :=
+  ringConGen (fun x y => ∃ i : EquationIndex α rels,
+    x = equation R α rels i - 1 ∧ y = 0)
+
+/-- Writing each equation p = 1 as p - 1 = 0 does not change the quotient.
+This matches the manuscript notation k⟨x₁,...,x_d⟩/(p₁,...,p_t). -/
+theorem relations_eq_zeroRelations : relations R α rels = zeroRelations R α rels := by
+  apply le_antisymm
+  · apply RingCon.ringConGen_le.mpr
+    rintro x y ⟨i,rfl,rfl⟩
+    have h : zeroRelations R α rels (equation R α rels i - 1) 0 :=
+      RingConGen.Rel.of _ _ ⟨i,rfl,rfl⟩
+    have hh := (zeroRelations R α rels).add h ((zeroRelations R α rels).refl 1)
+    simpa only [sub_add_cancel, zero_add] using hh
+  · apply RingCon.ringConGen_le.mpr
+    rintro x y ⟨i,rfl,rfl⟩
+    have h : relations R α rels (equation R α rels i) 1 :=
+      RingConGen.Rel.of _ _ ⟨i,rfl,rfl⟩
+    have hh := (relations R α rels).add h ((relations R α rels).refl (-1))
+    simpa only [← sub_eq_add_neg, sub_self] using hh
+
+/-- The explicit presentation is also a quotient by finitely many polynomial
+zero relations, in the exact form used by Section 3 of the manuscript. -/
+def zeroQuotientEquiv : (zeroRelations R α rels).Quotient ≃ₐ[R]
+    MonoidAlgebra R (PresentedGroup rels) :=
+  relations_eq_zeroRelations R α rels ▸ quotientEquiv R α rels
+
+end LittleFinitistic.GroupAlgebraPresentation
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Selection/GroupSelection.lean b/lean/OAI/Algebra/Finitistic/Selection/GroupSelection.lean
new file mode 100644
index 0000000000000000000000000000000000000000..131e632955eba21a9f19d35e66914d5440cd6529
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Selection/GroupSelection.lean
@@ -0,0 +1,354 @@
+import Mathlib.GroupTheory.Commutator.Basic
+import Mathlib.GroupTheory.PresentedGroup
+import Mathlib.Tactic.Group
+import Mathlib.Tactic.FinCases
+import Lean.Elab.Tactic.Omega
+
+namespace OAI
+/-! Group identities used in Section 2 of v5s9.15. -/
+
+open scoped commutatorElement
+
+namespace LittleFinitistic
+
+section GroupTransfer
+
+variable {G : Type*} [Group G]
+
+/-- The commutator transfer identity establishing independence of the
+internal index in the paper's central involutions. -/
+theorem commutator_transfer (x y v u w : G)
+    (hu : x*y = u*y*x) (hw : y*v = w*v*y)
+    (hxv : Commute x v) (hwu : Commute w u) (hwv : Commute w v) :
+    ⁅x,w⁆ = ⁅u,v⁆ := by
+  have hconj : y*x*y⁻¹ = u⁻¹*x := by
+    apply (mul_left_cancel_iff (a := u)).mp
+    calc
+      u*(y*x*y⁻¹) = (u*y*x)*y⁻¹ := by group
+      _ = (x*y)*y⁻¹ := by rw [← hu]
+      _ = u*(u⁻¹*x) := by group
+  have hmove : x*w*v*y = u*w*v*y*x := by
+    calc
+      x*w*v*y = x*(y*v) := by rw [hw]; group
+      _ = (x*y)*v := by group
+      _ = (u*y*x)*v := by rw [hu]
+      _ = u*y*(v*x) := by simp only [mul_assoc, hxv.eq]
+      _ = u*(y*v)*x := by group
+      _ = u*w*v*y*x := by rw [hw]; group
+  have hxw : x*w = u*w*v*u⁻¹*v⁻¹*x := by
+    calc
+      x*w = (x*w*v*y)*y⁻¹*v⁻¹ := by group
+      _ = (u*w*v*y*x)*y⁻¹*v⁻¹ := by rw [hmove]
+      _ = u*w*v*(y*x*y⁻¹)*v⁻¹ := by group
+      _ = u*w*v*(u⁻¹*x)*v⁻¹ := by rw [hconj]
+      _ = u*w*v*u⁻¹*(v⁻¹*x) := by simp only [mul_assoc]; rw [hxv.inv_right.eq]
+      _ = u*w*v*u⁻¹*v⁻¹*x := by group
+  have hwc : Commute w (v*u⁻¹*v⁻¹) := by
+    simpa only [mul_assoc] using hwv.mul_right (hwu.inv_right.mul_right hwv.inv_right)
+  calc
+    ⁅x,w⁆ = x*w*x⁻¹*w⁻¹ := rfl
+    _ = u*w*v*u⁻¹*v⁻¹*w⁻¹ := by rw [hxw]; group
+    _ = u*(w*(v*u⁻¹*v⁻¹))*w⁻¹ := by group
+    _ = u*((v*u⁻¹*v⁻¹)*w)*w⁻¹ := by rw [hwc.eq]
+    _ = ⁅u,v⁆ := by simp only [commutatorElement_def]; group
+
+/-- A central commutator of an involution has order dividing two. -/
+theorem central_commutator_involution (x y : G) (hx : x*x = 1)
+    (hc : Commute x ⁅x,y⁆) : ⁅x,y⁆ * ⁅x,y⁆ = 1 := by
+  calc
+    ⁅x,y⁆ * ⁅x,y⁆ = x * ⁅x,y⁆ * x⁻¹ * ⁅x,y⁆ := by rw [hc.eq]; group
+    _ = ⁅x*x,y⁆ := (commutatorElement_mul_left_eq_conj_mul x x y).symm
+    _ = 1 := by rw [hx]; exact commutatorElement_one_left y
+
+end GroupTransfer
+
+/-- The relators used for the off-diagonal generators in Section 2. The
+presentation and its finite-presentation reduction are separate obligations. -/
+structure SelectionGroupData (G : Type*) [Group G] where
+  T : Fin 3 → G
+  U : Fin 3 → ℤ → G
+  V : Fin 3 → ℤ → G
+  W : Fin 3 → Fin 3 → ℤ → G
+  square_U : ∀ i a, U i a * U i a = 1
+  commute_UU : ∀ i j a b, i ≠ j → Commute (U i a) (U j b)
+  commute_VV : ∀ i j a b, i ≠ j → Commute (V i a) (V j b)
+  commute_UV : ∀ i j a b, i ≠ j → Commute (U i a) (V j b)
+  commute_WU : ∀ i j h a b, h ≠ i → Commute (W i j a) (U h b)
+  commute_WV : ∀ i j h a b, h ≠ j → Commute (W i j a) (V h b)
+  commutator_UW : ∀ i j a b, i ≠ j → ⁅U i a, W i j b⁆ = U j (a+b)
+  commutator_WV : ∀ i j a b, i ≠ j → ⁅W i j a, V j b⁆ = V i (a+b)
+  commute_TT : ∀ i j, Commute (T i) (T j)
+  conj_TU : ∀ l i a, T l * U i a * (T l)⁻¹ = U i (a - if l=i then 1 else 0)
+  conj_TV : ∀ l i a, T l * V i a * (T l)⁻¹ = V i (a + if l=i then 1 else 0)
+  conj_TW : ∀ l i j a, T l * W i j a * (T l)⁻¹ =
+    W i j (a + (if l=i then 1 else 0) - if l=j then 1 else 0)
+  diagonal_W : ∀ i a, W i i a = 1
+
+namespace SelectionGroupData
+
+variable {G : Type*} [Group G] (D : SelectionGroupData G)
+
+theorem split_transfer (i j : Fin 3) (a b c d : ℤ)
+    (hij : i ≠ j) (hsum : a+b = c+d) :
+    ⁅D.U i a, D.V i b⁆ = ⁅D.U j c, D.V j d⁆ := by
+  have hU : D.U i a * D.W i j (c-a) =
+      D.U j c * D.W i j (c-a) * D.U i a := by
+    have h := D.commutator_UW i j a (c-a) hij
+    have hc : a + (c-a) = c := by omega
+    rw [hc] at h
+    rw [← h]
+    simp [commutatorElement_def, mul_assoc]
+  have hV : D.W i j (c-a) * D.V j d =
+      D.V i b * D.V j d * D.W i j (c-a) := by
+    have h := D.commutator_WV i j (c-a) d hij
+    have hb : c-a+d = b := by omega
+    rw [hb] at h
+    rw [← h]
+    simp [commutatorElement_def, mul_assoc]
+  exact commutator_transfer (D.U i a) (D.W i j (c-a)) (D.V j d)
+    (D.U j c) (D.V i b) hU hV (D.commute_UV i j a d hij)
+    (D.commute_UV j i c b hij.symm).symm (D.commute_VV i j b d hij)
+
+theorem splitting_independent (i j : Fin 3) (a b c d : ℤ)
+    (hsum : a+b = c+d) : ⁅D.U i a,D.V i b⁆ = ⁅D.U j c,D.V j d⁆ := by
+  obtain ⟨k, hki, hkj⟩ := Fin.exists_ne_and_ne_of_two_lt i j (by decide)
+  calc
+    ⁅D.U i a,D.V i b⁆ = ⁅D.U k 0,D.V k (a+b)⁆ :=
+      D.split_transfer i k a b 0 (a+b) hki.symm (by omega)
+    _ = ⁅D.U j c,D.V j d⁆ :=
+      D.split_transfer k j 0 (a+b) c d hkj (by omega)
+
+def centralZ (N : ℤ) : G := ⁅D.U 0 0,D.V 0 N⁆
+
+theorem centralZ_eq (N : ℤ) (i : Fin 3) (a b : ℤ) (h : a+b=N) :
+    D.centralZ N = ⁅D.U i a,D.V i b⁆ := by
+  exact D.splitting_independent 0 i 0 N a b (by omega)
+
+theorem centralZ_commute_U (N : ℤ) (h : Fin 3) (a : ℤ) :
+    Commute (D.centralZ N) (D.U h a) := by
+  obtain ⟨i, hih, _⟩ := Fin.exists_ne_and_ne_of_two_lt h h (by decide)
+  rw [D.centralZ_eq N i 0 N (by omega), commutatorElement_def]
+  have hU := D.commute_UU i h 0 a hih
+  have hV := (D.commute_UV h i a N hih.symm).symm
+  exact ((hU.mul_left hV).mul_left hU.inv_left).mul_left hV.inv_left
+
+theorem centralZ_commute_V (N : ℤ) (h : Fin 3) (a : ℤ) :
+    Commute (D.centralZ N) (D.V h a) := by
+  obtain ⟨i, hih, _⟩ := Fin.exists_ne_and_ne_of_two_lt h h (by decide)
+  rw [D.centralZ_eq N i 0 N (by omega), commutatorElement_def]
+  have hU := D.commute_UV i h 0 a hih
+  have hV := D.commute_VV i h N a hih
+  exact ((hU.mul_left hV).mul_left hU.inv_left).mul_left hV.inv_left
+
+theorem centralZ_commute_W (N : ℤ) (i j : Fin 3) (a : ℤ) :
+    Commute (D.centralZ N) (D.W i j a) := by
+  obtain ⟨h, hhi, hhj⟩ := Fin.exists_ne_and_ne_of_two_lt i j (by decide)
+  rw [D.centralZ_eq N h 0 N (by omega), commutatorElement_def]
+  have hU := (D.commute_WU i j h a 0 hhi).symm
+  have hV := (D.commute_WV i j h a N hhj).symm
+  exact ((hU.mul_left hV).mul_left hU.inv_left).mul_left hV.inv_left
+
+theorem centralZ_involution (N : ℤ) : D.centralZ N * D.centralZ N = 1 := by
+  apply central_commutator_involution (D.U 0 0) (D.V 0 N) (D.square_U 0 0)
+  exact (D.centralZ_commute_U N 0 0).symm
+
+theorem centralZ_commute_T (N : ℤ) (l : Fin 3) : Commute (D.centralZ N) (D.T l) := by
+  have hconj : D.T l * D.centralZ N * (D.T l)⁻¹ = D.centralZ N := by
+    rw [centralZ, conjugate_commutatorElement, D.conj_TU, D.conj_TV]
+    exact (D.centralZ_eq N 0 _ _ (by omega)).symm
+  show D.centralZ N * D.T l = D.T l * D.centralZ N
+  calc
+    D.centralZ N * D.T l = (D.T l * D.centralZ N * (D.T l)⁻¹) * D.T l := by rw [hconj]
+    _ = D.T l * D.centralZ N := by group
+
+end SelectionGroupData
+
+namespace Presentation
+
+inductive Generator where
+  | T : Fin 3 → Generator
+  | U : Fin 3 → ℤ → Generator
+  | V : Fin 3 → ℤ → Generator
+  | W : Fin 3 → Fin 3 → ℤ → Generator
+
+private abbrev t (i : Fin 3) := FreeGroup.of (Generator.T i)
+private abbrev u (i : Fin 3) (a : ℤ) := FreeGroup.of (Generator.U i a)
+private abbrev v (i : Fin 3) (a : ℤ) := FreeGroup.of (Generator.V i a)
+private abbrev w (i j : Fin 3) (a : ℤ) := FreeGroup.of (Generator.W i j a)
+
+/-- Explicit equation patterns of the paper's infinite presentation.
+Diagonal W generators are set to one, so the total-index notation introduces
+no additional group generators compared with the manuscript. -/
+inductive Equation : FreeGroup Generator → FreeGroup Generator → Prop where
+  | squareU (i a) : Equation (u i a * u i a) 1
+  | commuteUU (i j a b) (h : i ≠ j) : Equation (u i a * u j b) (u j b * u i a)
+  | commuteVV (i j a b) (h : i ≠ j) : Equation (v i a * v j b) (v j b * v i a)
+  | commuteUV (i j a b) (h : i ≠ j) : Equation (u i a * v j b) (v j b * u i a)
+  | commuteWU (i j h a b) (hhi : h ≠ i) : Equation (w i j a * u h b) (u h b * w i j a)
+  | commuteWV (i j h a b) (hhj : h ≠ j) : Equation (w i j a * v h b) (v h b * w i j a)
+  | commutatorUW (i j a b) (h : i ≠ j) : Equation ⁅u i a,w i j b⁆ (u j (a+b))
+  | commutatorWV (i j a b) (h : i ≠ j) : Equation ⁅w i j a,v j b⁆ (v i (a+b))
+  | commuteTT (i j) : Equation (t i * t j) (t j * t i)
+  | conjTU (l i a) : Equation (t l * u i a * (t l)⁻¹) (u i (a-if l=i then 1 else 0))
+  | conjTV (l i a) : Equation (t l * v i a * (t l)⁻¹) (v i (a+if l=i then 1 else 0))
+  | conjTW (l i j a) : Equation (t l * w i j a * (t l)⁻¹)
+      (w i j (a+(if l=i then 1 else 0)-if l=j then 1 else 0))
+  | diagonalW (i a) : Equation (w i i a) 1
+
+def relators : Set (FreeGroup Generator) := {r | ∃ a b, Equation a b ∧ r=a*b⁻¹}
+abbrev AuxiliaryGroup := PresentedGroup relators
+
+private theorem equation_holds {a b : FreeGroup Generator} (h : Equation a b) :
+    PresentedGroup.mk relators a = PresentedGroup.mk relators b :=
+  PresentedGroup.mk_eq_mk_of_mul_inv_mem ⟨a,b,h,rfl⟩
+
+def data : SelectionGroupData AuxiliaryGroup where
+  T i := PresentedGroup.of (.T i)
+  U i a := PresentedGroup.of (.U i a)
+  V i a := PresentedGroup.of (.V i a)
+  W i j a := PresentedGroup.of (.W i j a)
+  square_U i a := by simpa [u, PresentedGroup.of] using equation_holds (.squareU i a)
+  commute_UU i j a b h := by
+    simpa [u, PresentedGroup.of, Commute, SemiconjBy] using equation_holds (.commuteUU i j a b h)
+  commute_VV i j a b h := by
+    simpa [v, PresentedGroup.of, Commute, SemiconjBy] using equation_holds (.commuteVV i j a b h)
+  commute_UV i j a b h := by
+    simpa [u,v, PresentedGroup.of, Commute, SemiconjBy] using equation_holds (.commuteUV i j a b h)
+  commute_WU i j h a b hhi := by
+    simpa [w,u, PresentedGroup.of, Commute, SemiconjBy] using equation_holds (.commuteWU i j h a b hhi)
+  commute_WV i j h a b hhj := by
+    simpa [w,v, PresentedGroup.of, Commute, SemiconjBy] using equation_holds (.commuteWV i j h a b hhj)
+  commutator_UW i j a b h := by
+    simpa [u,w, PresentedGroup.of] using equation_holds (.commutatorUW i j a b h)
+  commutator_WV i j a b h := by
+    simpa [w,v, PresentedGroup.of] using equation_holds (.commutatorWV i j a b h)
+  commute_TT i j := by
+    simpa [t, PresentedGroup.of, Commute, SemiconjBy] using equation_holds (.commuteTT i j)
+  conj_TU l i a := by simpa [t,u,PresentedGroup.of] using equation_holds (.conjTU l i a)
+  conj_TV l i a := by simpa [t,v,PresentedGroup.of] using equation_holds (.conjTV l i a)
+  conj_TW l i j a := by simpa [t,w,PresentedGroup.of] using equation_holds (.conjTW l i j a)
+  diagonal_W i a := by simpa [w,PresentedGroup.of] using equation_holds (.diagonalW i a)
+
+def z (N : ℤ) : AuxiliaryGroup := data.centralZ N
+
+theorem z_involution (N : ℤ) : z N * z N = 1 := data.centralZ_involution N
+
+theorem z_central (N : ℤ) (g : AuxiliaryGroup) : Commute (z N) g := by
+  have hg : g ∈ Subgroup.closure (Set.range (PresentedGroup.of : Generator → AuxiliaryGroup)) := by
+    rw [PresentedGroup.closure_range_of]
+    trivial
+  induction hg using Subgroup.closure_induction with
+  | mem g hg =>
+      obtain ⟨s,rfl⟩ := hg
+      cases s with
+      | T i => exact data.centralZ_commute_T N i
+      | U i a => exact data.centralZ_commute_U N i a
+      | V i a => exact data.centralZ_commute_V N i a
+      | W i j a => exact data.centralZ_commute_W N i j a
+  | one => exact Commute.one_right _
+  | mul a b ha hb ia ib => exact ia.mul_right ib
+  | inv a ha ia => exact ia.inv_right
+
+def evaluate {G : Type*} [Group G] (D : SelectionGroupData G) : Generator → G
+  | .T i => D.T i
+  | .U i a => D.U i a
+  | .V i a => D.V i a
+  | .W i j a => D.W i j a
+
+theorem evaluate_equation {G : Type*} [Group G] (D : SelectionGroupData G)
+    {a b : FreeGroup Generator} (h : Equation a b) :
+    FreeGroup.lift (evaluate D) a = FreeGroup.lift (evaluate D) b := by
+  cases h with
+  | squareU i a => simpa [u,evaluate] using D.square_U i a
+  | commuteUU i j a b h => simpa [u,evaluate] using (D.commute_UU i j a b h).eq
+  | commuteVV i j a b h => simpa [v,evaluate] using (D.commute_VV i j a b h).eq
+  | commuteUV i j a b h => simpa [u,v,evaluate] using (D.commute_UV i j a b h).eq
+  | commuteWU i j h a b hh => simpa [w,u,evaluate] using (D.commute_WU i j h a b hh).eq
+  | commuteWV i j h a b hh => simpa [w,v,evaluate] using (D.commute_WV i j h a b hh).eq
+  | commutatorUW i j a b h => simpa [u,w,evaluate] using D.commutator_UW i j a b h
+  | commutatorWV i j a b h => simpa [w,v,evaluate] using D.commutator_WV i j a b h
+  | commuteTT i j => simpa [t,evaluate] using (D.commute_TT i j).eq
+  | conjTU l i a => simpa [t,u,evaluate] using D.conj_TU l i a
+  | conjTV l i a => simpa [t,v,evaluate] using D.conj_TV l i a
+  | conjTW l i j a => simpa [t,w,evaluate] using D.conj_TW l i j a
+  | diagonalW i a => simpa [w,evaluate] using D.diagonal_W i a
+
+def ofData {G : Type*} [Group G] (D : SelectionGroupData G) : AuxiliaryGroup →* G :=
+  PresentedGroup.toGroup (f := evaluate D) (by
+    intro r hr
+    obtain ⟨a,b,h,rfl⟩ := hr
+    rw [map_mul,map_inv,evaluate_equation D h,mul_inv_cancel])
+
+@[simp] theorem ofData_of {G : Type*} [Group G] (D : SelectionGroupData G) (s : Generator) :
+    ofData D (PresentedGroup.of s) = evaluate D s := PresentedGroup.toGroup.of _
+
+def shiftData {G : Type*} [Group G] (D : SelectionGroupData G) (k : ℤ) :
+    SelectionGroupData G where
+  T := D.T
+  U i a := D.U i (a+k)
+  V := D.V
+  W := D.W
+  square_U i a := D.square_U i (a+k)
+  commute_UU i j a b h := D.commute_UU i j (a+k) (b+k) h
+  commute_VV := D.commute_VV
+  commute_UV i j a b h := D.commute_UV i j (a+k) b h
+  commute_WU i j h a b hh := D.commute_WU i j h a (b+k) hh
+  commute_WV := D.commute_WV
+  commutator_UW i j a b h := by
+    simpa only [add_assoc,add_comm k b] using D.commutator_UW i j (a+k) b h
+  commutator_WV := D.commutator_WV
+  commute_TT := D.commute_TT
+  conj_TU l i a := by
+    simpa only [add_sub_assoc,sub_add_eq_add_sub] using D.conj_TU l i (a+k)
+  conj_TV := D.conj_TV
+  conj_TW := D.conj_TW
+  diagonal_W := D.diagonal_W
+
+def shiftHom (k : ℤ) : AuxiliaryGroup →* AuxiliaryGroup := ofData (shiftData data k)
+
+@[simp] theorem shiftHom_T (k : ℤ) (i : Fin 3) : shiftHom k (data.T i) = data.T i := by
+  simp [shiftHom,data,shiftData,evaluate]
+
+@[simp] theorem shiftHom_U (k : ℤ) (i : Fin 3) (a : ℤ) :
+    shiftHom k (data.U i a) = data.U i (a+k) := by
+  simp [shiftHom,data,shiftData,evaluate]
+
+@[simp] theorem shiftHom_V (k : ℤ) (i : Fin 3) (a : ℤ) :
+    shiftHom k (data.V i a) = data.V i a := by
+  simp [shiftHom,data,shiftData,evaluate]
+
+@[simp] theorem shiftHom_W (k : ℤ) (i j : Fin 3) (a : ℤ) :
+    shiftHom k (data.W i j a) = data.W i j a := by
+  simp [shiftHom,data,shiftData,evaluate]
+
+theorem shiftHom_comp (k l : ℤ) : (shiftHom k).comp (shiftHom l) = shiftHom (l+k) := by
+  apply PresentedGroup.ext
+  intro s
+  cases s <;> simp [MonoidHom.comp_apply,shiftHom,shiftData,data,evaluate,add_assoc]
+
+theorem shiftHom_zero : shiftHom 0 = MonoidHom.id AuxiliaryGroup := by
+  apply PresentedGroup.ext
+  intro s
+  cases s <;> simp [shiftHom,shiftData,data,evaluate]
+
+def shiftAut (k : ℤ) : AuxiliaryGroup ≃* AuxiliaryGroup where
+  toFun := shiftHom k
+  invFun := shiftHom (-k)
+  left_inv a := by
+    have h := DFunLike.congr_fun (shiftHom_comp (-k) k) a
+    simpa only [add_neg_cancel,shiftHom_zero,MonoidHom.id_apply,MonoidHom.comp_apply] using h
+  right_inv a := by
+    have h := DFunLike.congr_fun (shiftHom_comp k (-k)) a
+    simpa only [neg_add_cancel,shiftHom_zero,MonoidHom.id_apply,MonoidHom.comp_apply] using h
+  map_mul' := (shiftHom k).map_mul
+
+theorem shiftAut_z (k N : ℤ) : shiftAut k (z N) = z (N+k) := by
+  change shiftHom k ⁅data.U 0 0,data.V 0 N⁆ = data.centralZ (N+k)
+  rw [map_commutatorElement,shiftHom_U,shiftHom_V,zero_add]
+  exact (data.centralZ_eq (N+k) 0 k N (by omega)).symm
+
+end Presentation
+
+end LittleFinitistic
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Selection/MatrixModel.lean b/lean/OAI/Algebra/Finitistic/Selection/MatrixModel.lean
new file mode 100644
index 0000000000000000000000000000000000000000..a219a3653a0fe6cf022d4a42709eed680c5cd111
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Selection/MatrixModel.lean
@@ -0,0 +1,307 @@
+import Mathlib.Algebra.Field.ZMod
+import Mathlib.RingTheory.SimpleRing.Basic
+import Mathlib.Algebra.CharP.Algebra
+import OAI.Algebra.Finitistic.Selection.FiniteQuotient
+import OAI.Algebra.Finitistic.Selection.GroupSelection
+
+namespace OAI
+open scoped commutatorElement
+
+namespace LittleFinitistic
+
+def internalIndex (i : Fin 3) : Fin 5 := ⟨i.val+1,by omega⟩
+
+@[simp] theorem internalIndex_ne_zero (i : Fin 3) : internalIndex i ≠ 0 := by
+  intro h
+  have hv := congrArg Fin.val h
+  change i.val+1=0 at hv
+  omega
+@[simp] theorem internalIndex_ne_four (i : Fin 3) : internalIndex i ≠ 4 := by
+  intro h
+  have hv := congrArg Fin.val h
+  change i.val+1=4 at hv
+  omega
+@[simp] theorem internalIndex_inj (i j : Fin 3) : internalIndex i = internalIndex j ↔ i=j := by
+  constructor
+  · intro h
+    apply Fin.ext
+    have hv := congrArg Fin.val h
+    change i.val+1=j.val+1 at hv
+    omega
+  · rintro rfl
+    rfl
+
+section MatrixRepresentation
+
+variable {R : Type*} [CommRing R]
+
+
+def matrixU (r : Rˣ) (i : Fin 3) (a : ℤ) : (Matrix (Fin 5) (Fin 5) R)ˣ :=
+  transvectionUnit 0 (internalIndex i) (Ne.symm (internalIndex_ne_zero i)) (↑(r^a) : R)
+
+def matrixV (r : Rˣ) (i : Fin 3) (a : ℤ) : (Matrix (Fin 5) (Fin 5) R)ˣ :=
+  transvectionUnit (internalIndex i) 4 (internalIndex_ne_four i) (↑(r^a) : R)
+
+def matrixW (r : Rˣ) (i j : Fin 3) (a : ℤ) : (Matrix (Fin 5) (Fin 5) R)ˣ :=
+  if h : i=j then 1 else
+    transvectionUnit (internalIndex i) (internalIndex j) (by simpa using h) (↑(r^a) : R)
+
+def matrixT (r : Rˣ) (i : Fin 3) : (Matrix (Fin 5) (Fin 5) R)ˣ :=
+  diagonalUnit (fun j => if j=internalIndex i then r else 1)
+
+theorem matrixU_square [CharP R 2] (r : Rˣ) (i : Fin 3) (a : ℤ) : matrixU r i a * matrixU r i a = 1 := by
+  apply Units.ext
+  change transvection 0 (internalIndex i) (↑(r^a) : R) *
+      transvection 0 (internalIndex i) (↑(r^a) : R) = 1
+  rw [transvection_same 0 (internalIndex i) (Ne.symm (internalIndex_ne_zero i))]
+  simp [CharTwo.add_self_eq_zero,transvection]
+
+theorem matrix_UU_commute (r : Rˣ) (i j : Fin 3) (a b : ℤ) :
+    Commute (matrixU r i a) (matrixU r j b) := by
+  exact transvectionUnit_commute _ _ _ _ _ _
+    (internalIndex_ne_zero i) (internalIndex_ne_zero j) _ _
+
+theorem matrix_VV_commute (r : Rˣ) (i j : Fin 3) (a b : ℤ) :
+    Commute (matrixV r i a) (matrixV r j b) := by
+  exact transvectionUnit_commute _ _ _ _ _ _
+    (Ne.symm (internalIndex_ne_four j)) (Ne.symm (internalIndex_ne_four i)) _ _
+
+theorem matrix_UV_commute (r : Rˣ) (i j : Fin 3) (a b : ℤ) (hij : i≠j) :
+    Commute (matrixU r i a) (matrixV r j b) := by
+  exact transvectionUnit_commute _ _ _ _ _ _ (by simpa using hij) (by decide) _ _
+
+theorem matrix_WU_commute (r : Rˣ) (i j h : Fin 3) (a b : ℤ) (hhi : h≠i) :
+    Commute (matrixW r i j a) (matrixU r h b) := by
+  unfold matrixW
+  split_ifs with hij
+  · exact Commute.one_left _
+  · exact transvectionUnit_commute _ _ _ _ _ _
+      (internalIndex_ne_zero j) (by simpa using hhi) _ _
+
+theorem matrix_WV_commute (r : Rˣ) (i j h : Fin 3) (a b : ℤ) (hhj : h≠j) :
+    Commute (matrixW r i j a) (matrixV r h b) := by
+  unfold matrixW
+  split_ifs with hij
+  · exact Commute.one_left _
+  · exact transvectionUnit_commute _ _ _ _ _ _
+      (by simpa using hhj.symm) (Ne.symm (internalIndex_ne_four i)) _ _
+
+theorem matrix_UW_commutator (r : Rˣ) (i j : Fin 3) (a b : ℤ) (hij : i≠j) :
+    ⁅matrixU r i a,matrixW r i j b⁆ = matrixU r j (a+b) := by
+  unfold matrixW matrixU
+  rw [dite_eq_right hij]
+  simpa only [zpow_add,Units.val_mul] using
+    transvectionUnit_commutator (R := R) 0 (internalIndex i) (internalIndex j)
+      (Ne.symm (internalIndex_ne_zero i)) (by simpa using hij)
+      (Ne.symm (internalIndex_ne_zero j)) (↑(r^a) : R) (↑(r^b) : R)
+
+theorem matrix_WV_commutator (r : Rˣ) (i j : Fin 3) (a b : ℤ) (hij : i≠j) :
+    ⁅matrixW r i j a,matrixV r j b⁆ = matrixV r i (a+b) := by
+  unfold matrixW matrixV
+  rw [dite_eq_right hij]
+  simpa only [zpow_add,Units.val_mul] using
+    transvectionUnit_commutator (R := R) (internalIndex i) (internalIndex j) 4
+      (by simpa using hij) (internalIndex_ne_four j)
+      (internalIndex_ne_four i) (↑(r^a) : R) (↑(r^b) : R)
+
+theorem matrix_TT_commute (r : Rˣ) (i j : Fin 3) : Commute (matrixT r i) (matrixT r j) :=
+  diagonalUnit_commute _ _
+
+theorem matrix_W_diagonal (r : Rˣ) (i : Fin 3) (a : ℤ) : matrixW r i i a = 1 := by
+  simp [matrixW]
+
+theorem matrix_TU_conjugation (r : Rˣ) (l i : Fin 3) (a : ℤ) :
+    matrixT r l * matrixU r i a * (matrixT r l)⁻¹ =
+      matrixU r i (a-if l=i then 1 else 0) := by
+  unfold matrixT matrixU
+  rw [transvectionUnit_conjugation]
+  have h0 : (0 : Fin 5) ≠ internalIndex l := (internalIndex_ne_zero l).symm
+  by_cases h : l=i
+  · subst l
+    simp [h0,zpow_sub]
+  · have hi : internalIndex i ≠ internalIndex l := by simpa using Ne.symm h
+    simp [h0,hi,h]
+
+theorem matrix_TV_conjugation (r : Rˣ) (l i : Fin 3) (a : ℤ) :
+    matrixT r l * matrixV r i a * (matrixT r l)⁻¹ =
+      matrixV r i (a+if l=i then 1 else 0) := by
+  unfold matrixT matrixV
+  rw [transvectionUnit_conjugation]
+  have h4 : (4 : Fin 5) ≠ internalIndex l := (internalIndex_ne_four l).symm
+  by_cases h : l=i
+  · subst l
+    simp [h4,zpow_add,mul_comm]
+  · have hi : internalIndex i ≠ internalIndex l := by simpa using Ne.symm h
+    simp [h4,hi,h]
+
+theorem matrix_TW_conjugation (r : Rˣ) (l i j : Fin 3) (a : ℤ) :
+    matrixT r l * matrixW r i j a * (matrixT r l)⁻¹ =
+      matrixW r i j (a+(if l=i then 1 else 0)-if l=j then 1 else 0) := by
+  by_cases hij : i=j
+  · subst j
+    simp [matrix_W_diagonal]
+  · simp only [matrixW,dite_eq_right hij,matrixT]
+    rw [transvectionUnit_conjugation]
+    by_cases hli : l=i <;> by_cases hlj : l=j
+    · exact False.elim (hij (hli.symm.trans hlj))
+    · subst l
+      have hji : internalIndex j ≠ internalIndex i := by simpa using Ne.symm hij
+      simp [hji,hlj,zpow_add,mul_comm]
+    · subst l
+      have hij' : internalIndex i ≠ internalIndex j := by simpa using hij
+      simp [hij',hli,zpow_sub]
+    · have hi : internalIndex i ≠ internalIndex l := by simpa using Ne.symm hli
+      have hj : internalIndex j ≠ internalIndex l := by simpa using Ne.symm hlj
+      simp [hi,hj,hli,hlj]
+
+def matrixData [CharP R 2] (r : Rˣ) : SelectionGroupData (Matrix (Fin 5) (Fin 5) R)ˣ where
+  T := matrixT r
+  U := matrixU r
+  V := matrixV r
+  W := matrixW r
+  square_U := matrixU_square r
+  commute_UU i j a b _ := matrix_UU_commute r i j a b
+  commute_VV i j a b _ := matrix_VV_commute r i j a b
+  commute_UV := matrix_UV_commute r
+  commute_WU := matrix_WU_commute r
+  commute_WV := matrix_WV_commute r
+  commutator_UW := matrix_UW_commutator r
+  commutator_WV := matrix_WV_commutator r
+  commute_TT := matrix_TT_commute r
+  conj_TU := matrix_TU_conjugation r
+  conj_TV := matrix_TV_conjugation r
+  conj_TW := matrix_TW_conjugation r
+  diagonal_W := matrix_W_diagonal r
+
+def matrixRepresentation [CharP R 2] (r : Rˣ) : Presentation.AuxiliaryGroup →*
+    (Matrix (Fin 5) (Fin 5) R)ˣ := Presentation.ofData (matrixData r)
+
+theorem matrixRepresentation_z [CharP R 2] (r : Rˣ) (N : ℤ) :
+    matrixRepresentation r (Presentation.z N) = transvectionUnit 0 4 (by decide) (↑(r^N) : R) := by
+  change Presentation.ofData (matrixData r)
+    ⁅PresentedGroup.of (Presentation.Generator.U 0 0),PresentedGroup.of (Presentation.Generator.V 0 N)⁆ = _
+  rw [map_commutatorElement,Presentation.ofData_of,Presentation.ofData_of]
+  change ⁅matrixU r 0 0,matrixV r 0 N⁆ = _
+  unfold matrixU matrixV
+  rw [transvectionUnit_commutator 0 (internalIndex 0) 4 _ _ (by decide)]
+  simp only [zpow_zero,Units.val_one,one_mul]
+
+
+end MatrixRepresentation
+
+instance cyclicRing_nontrivial (m : ℕ) [NeZero m] : Nontrivial (CyclicRing m) := by
+  let i : Fin m := ⟨0,Nat.pos_of_ne_zero (NeZero.ne m)⟩
+  exact ⟨⟨cyclicBasis m (NeZero.ne m) i,0,(cyclicBasis m (NeZero.ne m)).ne_zero i⟩⟩
+
+instance cyclicRing_finiteInst (m : ℕ) [NeZero m] : Finite (CyclicRing m) :=
+  cyclicRing_finite m (NeZero.ne m)
+
+instance cyclicRing_charTwo (m : ℕ) [NeZero m] : CharP (CyclicRing m) 2 :=
+  charP_of_injective_algebraMap (algebraMap (ZMod 2) (CyclicRing m)).injective 2
+
+noncomputable def cyclicUnit (m : ℕ) [NeZero m] : (CyclicRing m)ˣ :=
+  (cyclic_root_isUnit m (Nat.pos_of_ne_zero (NeZero.ne m))).unit
+
+@[simp] theorem cyclicUnit_val (m : ℕ) [NeZero m] :
+    (cyclicUnit m : CyclicRing m) = AdjoinRoot.root (cyclicPolynomial m) :=
+  IsUnit.unit_spec _
+
+noncomputable def cyclicRepresentation (m : ℕ) [NeZero m] : Presentation.AuxiliaryGroup →*
+    (Matrix (Fin 5) (Fin 5) (CyclicRing m))ˣ := matrixRepresentation (cyclicUnit m)
+
+theorem cyclicRepresentation_z (m : ℕ) [NeZero m] (i : ℕ) :
+    cyclicRepresentation m (Presentation.z i) = transvectionUnit 0 4 (by decide)
+      (AdjoinRoot.root (cyclicPolynomial m)^i) := by
+  unfold cyclicRepresentation
+  rw [matrixRepresentation_z]
+  simp only [zpow_natCast,Units.val_pow_eq_pow_val,cyclicUnit_val]
+
+theorem centralEmbedding_basis (m : ℕ) [NeZero m] (i : Fin m) :
+    centralEmbedding m (Multiplicative.ofAdd (Pi.single i 1)) =
+      cyclicRepresentation m (Presentation.z i.val) := by
+  rw [cyclicRepresentation_z]
+  apply Units.ext
+  change transvection (R := CyclicRing m) (0 : Fin 5) 4 (∑ j : Fin m, (Pi.single i (1 : ZMod 2) : Fin m → ZMod 2) j •
+      AdjoinRoot.root (cyclicPolynomial m) ^ (j : ℕ)) = _
+  simp [Pi.single_apply, transvectionUnit]
+
+noncomputable abbrev FiniteQuotientGroup (m : ℕ) [NeZero m] := (cyclicRepresentation m).range
+
+instance finiteQuotientGroup_finite (m : ℕ) [NeZero m] : Finite (FiniteQuotientGroup m) :=
+  inferInstance
+
+noncomputable def finiteQuotientMap (m : ℕ) [NeZero m] :
+    Presentation.AuxiliaryGroup →* FiniteQuotientGroup m := (cyclicRepresentation m).rangeRestrict
+
+theorem finiteQuotientMap_surjective (m : ℕ) [NeZero m] :
+    Function.Surjective (finiteQuotientMap m) := (cyclicRepresentation m).rangeRestrict_surjective
+
+theorem centralEmbedding_mem_center_map (m : ℕ) [NeZero m]
+    (c : Fin m → ZMod 2) : centralEmbedding m (Multiplicative.ofAdd c) ∈
+      (Subgroup.center Presentation.AuxiliaryGroup).map (cyclicRepresentation m) := by
+  classical
+  let S := (Subgroup.center Presentation.AuxiliaryGroup).map (cyclicRepresentation m)
+  apply Pi.single_induction (fun c => centralEmbedding m (Multiplicative.ofAdd c) ∈ S) c
+  · simp
+  · intro f g hf hg
+    change centralEmbedding m (Multiplicative.ofAdd f * Multiplicative.ofAdd g) ∈ S
+    rw [map_mul]
+    exact S.mul_mem hf hg
+  · intro i a
+    fin_cases a
+    · change centralEmbedding m (Multiplicative.ofAdd (Pi.single i (0 : ZMod 2))) ∈ S
+      simpa only [Pi.single_zero,ofAdd_zero,map_one] using S.one_mem
+    · change centralEmbedding m (Multiplicative.ofAdd (Pi.single i (1 : ZMod 2))) ∈ S
+      rw [centralEmbedding_basis]
+      apply Subgroup.mem_map_of_mem
+      exact Subgroup.mem_center_iff.mpr (fun g => (Presentation.z_central i.val g).eq.symm)
+
+theorem centralEmbedding_mem_range (m : ℕ) [NeZero m]
+    (c : Multiplicative (Fin m → ZMod 2)) :
+    centralEmbedding m c ∈ (cyclicRepresentation m).range := by
+  obtain ⟨g, _, hg⟩ := centralEmbedding_mem_center_map m c.toAdd
+  exact ⟨g,hg⟩
+
+noncomputable def quotientCentralEmbedding (m : ℕ) [NeZero m] :
+    Multiplicative (Fin m → ZMod 2) →* FiniteQuotientGroup m where
+  toFun c := ⟨centralEmbedding m c, centralEmbedding_mem_range m c⟩
+  map_one' := Subtype.ext (map_one _)
+  map_mul' a b := Subtype.ext (map_mul _ a b)
+
+theorem quotientCentralEmbedding_injective (m : ℕ) [NeZero m] :
+    Function.Injective (quotientCentralEmbedding m) := by
+  intro a b h
+  exact centralEmbedding_injective m (NeZero.ne m) (congrArg Subtype.val h)
+
+theorem quotientCentralEmbedding_basis (m : ℕ) [NeZero m] (i : Fin m) :
+    quotientCentralEmbedding m (Multiplicative.ofAdd (Pi.single i 1)) =
+      finiteQuotientMap m (Presentation.z i.val) :=
+  Subtype.ext (centralEmbedding_basis m i)
+
+theorem quotientCentralEmbedding_central (m : ℕ) [NeZero m]
+    (c : Multiplicative (Fin m → ZMod 2)) (g : FiniteQuotientGroup m) :
+    Commute (quotientCentralEmbedding m c) g := by
+  obtain ⟨x, hx, hxval⟩ := centralEmbedding_mem_center_map m c.toAdd
+  obtain ⟨y, hy⟩ := finiteQuotientMap_surjective m g
+  subst g
+  apply Subtype.ext
+  change centralEmbedding m c * cyclicRepresentation m y =
+    cyclicRepresentation m y * centralEmbedding m c
+  change cyclicRepresentation m x = centralEmbedding m c at hxval
+  rw [← hxval, ← map_mul, ← map_mul]
+  exact congrArg (cyclicRepresentation m) (Subgroup.mem_center_iff.mp hx y).symm
+
+/-- The actual finite quotient in the manuscript, including the embedded elementary
+abelian central subgroup and the prescribed images of all its basis elements. -/
+theorem finite_central_quotient (m : ℕ) [NeZero m] :
+    Function.Surjective (finiteQuotientMap m) ∧
+    Function.Injective (quotientCentralEmbedding m) ∧
+    (∀ c g, Commute (quotientCentralEmbedding m c) g) ∧
+    (∀ i : Fin m, quotientCentralEmbedding m (Multiplicative.ofAdd (Pi.single i 1)) =
+      finiteQuotientMap m (Presentation.z i.val)) :=
+  ⟨finiteQuotientMap_surjective m,quotientCentralEmbedding_injective m,
+    quotientCentralEmbedding_central m,quotientCentralEmbedding_basis m⟩
+
+end LittleFinitistic
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Selection/SelectionAlgebra.lean b/lean/OAI/Algebra/Finitistic/Selection/SelectionAlgebra.lean
new file mode 100644
index 0000000000000000000000000000000000000000..c07ad383fb9573ecb26f23606f0acd8f581811ae
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Selection/SelectionAlgebra.lean
@@ -0,0 +1,57 @@
+import Mathlib.Algebra.MonoidAlgebra.Basic
+import Mathlib.Tactic.Abel
+import Mathlib.Algebra.MonoidAlgebra.MapDomain
+import Mathlib.Basic.Complex.Basic
+import Mathlib.Tactic.NormNum
+import OAI.Algebra.Finitistic.Selection.GroupSelection
+
+namespace OAI
+namespace LittleFinitistic
+
+open MonoidAlgebra
+
+abbrev SelectionRing := MonoidAlgebra ℂ Presentation.AuxiliaryGroup
+
+noncomputable def algebraZ (q : ℤ) : SelectionRing := single (Presentation.z q) 1
+
+@[simp] theorem algebraZ_square (q : ℤ) : algebraZ q * algebraZ q = 1 := by
+  simp [algebraZ,single_mul_single,Presentation.z_involution]
+  rfl
+
+theorem algebraZ_central (q : ℤ) (a : SelectionRing) : Commute (algebraZ q) a :=
+  MonoidAlgebra.single_commute (Presentation.z_central q) Commute.one_left a
+
+noncomputable def selectionIdempotent (q : ℤ) : SelectionRing :=
+  (1/2 : ℂ) • (1 + algebraZ q)
+
+theorem selectionIdempotent_square (q : ℤ) :
+    selectionIdempotent q * selectionIdempotent q = selectionIdempotent q := by
+  have hz : (1 + algebraZ q)*(1 + algebraZ q) = (1+algebraZ q)+(1+algebraZ q) := by
+    simp only [mul_add,add_mul,one_mul,mul_one,algebraZ_square]
+    abel
+  unfold selectionIdempotent
+  rw [smul_mul_smul,hz,smul_add,← add_smul]
+  norm_num
+
+theorem selectionIdempotent_central (q : ℤ) (a : SelectionRing) :
+    Commute (selectionIdempotent q) a := by
+  show selectionIdempotent q * a = a * selectionIdempotent q
+  unfold selectionIdempotent
+  rw [smul_mul_assoc,mul_smul_comm]
+  congr 1
+  simp only [add_mul,mul_add,one_mul,mul_one,(algebraZ_central q a).eq]
+
+noncomputable def selectionAutomorphism (k : ℤ) : SelectionRing ≃ₐ[ℂ] SelectionRing :=
+  MonoidAlgebra.domCongr ℂ ℂ (Presentation.shiftAut k)
+
+@[simp] theorem selectionAutomorphism_z (k q : ℤ) :
+    selectionAutomorphism k (algebraZ q) = algebraZ (q+k) := by
+  simp [selectionAutomorphism,algebraZ,Presentation.shiftAut_z]
+
+@[simp] theorem selectionAutomorphism_idempotent (k q : ℤ) :
+    selectionAutomorphism k (selectionIdempotent q) = selectionIdempotent (q+k) := by
+  simp [selectionIdempotent]
+
+end LittleFinitistic
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Selection/SelectionCharacter.lean b/lean/OAI/Algebra/Finitistic/Selection/SelectionCharacter.lean
new file mode 100644
index 0000000000000000000000000000000000000000..5e5bf7e37831919872f940e5aea3340037239724
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Selection/SelectionCharacter.lean
@@ -0,0 +1,42 @@
+import Mathlib.Basic.Complex.Basic
+import OAI.Algebra.Finitistic.Selection.MatrixModel
+
+namespace OAI
+namespace LittleFinitistic
+
+noncomputable def parityValue (a : ZMod 2) : ℂˣ := if a = 0 then 1 else -1
+
+@[simp] theorem parityValue_zero : parityValue 0 = 1 := by simp [parityValue]
+@[simp] theorem parityValue_one : parityValue 1 = -1 := by norm_num [parityValue]
+
+theorem parityValue_add (a b : ZMod 2) : parityValue (a+b) = parityValue a * parityValue b := by
+  have hc : ∀ a : ZMod 2, a = 0 ∨ a = 1 := by decide
+  rcases hc a with rfl | rfl <;> rcases hc b with rfl | rfl
+  · simp
+  · simp
+  · simp
+  · rw [show (1 : ZMod 2) + 1 = 0 from rfl,parityValue_zero,parityValue_one]
+    simp
+
+def lastIndex (m : ℕ) [NeZero m] : Fin m := ⟨m-1,by have := NeZero.ne m; omega⟩
+
+noncomputable def selectionCharacter (m : ℕ) [NeZero m] :
+    Multiplicative (Fin m → ZMod 2) →* ℂˣ where
+  toFun c := parityValue (c.toAdd (lastIndex m))
+  map_one' := parityValue_zero
+  map_mul' first second := parityValue_add (first.toAdd (lastIndex m))
+    (second.toAdd (lastIndex m))
+
+@[simp] theorem selectionCharacter_basis (m : ℕ) [NeZero m] (i : Fin m) :
+    selectionCharacter m (Multiplicative.ofAdd (Pi.single i 1)) =
+      if i = lastIndex m then -1 else 1 := by
+  classical
+  change parityValue ((Pi.single i (1 : ZMod 2) : Fin m → ZMod 2) (lastIndex m)) = _
+  by_cases h : i = lastIndex m
+  · subst i
+    simp
+  · simp [h,Ne.symm h]
+
+end LittleFinitistic
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Selection/SelectionEncoding.lean b/lean/OAI/Algebra/Finitistic/Selection/SelectionEncoding.lean
new file mode 100644
index 0000000000000000000000000000000000000000..859b54752d1c180c2a765e0ad6c8b6e2635f5017
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Selection/SelectionEncoding.lean
@@ -0,0 +1,53 @@
+import OAI.Algebra.Finitistic.Encoding.PresentationReindex
+import OAI.Algebra.Finitistic.Selection.SelectionAlgebra
+
+namespace OAI
+
+namespace LittleFinitistic.SelectionEncoding
+open QuadraticPresentation QuadraticEncoding
+
+/-- Concrete finite coefficient data, with an exact presentation equivalence. -/
+structure Encoding (k R : Type*) [Field k] [Ring R] [Algebra k R] where
+  generators : ℕ
+  equations : ℕ
+  relations : Relations k generators equations
+  equiv : Original k (Fin generators) (QuotientAction.polynomial relations) ≃ₐ[k] R
+
+universe u v w
+variable {k : Type u} {R : Type v} [Field k] [Ring R] [Algebra k R] (E : Encoding k R)
+
+noncomputable def generator (h : Fin E.generators) : R :=
+  E.equiv (originalMap k (Fin E.generators) (QuotientAction.polynomial E.relations)
+    (FreeAlgebra.ι k h))
+
+/-- These concrete elements of R satisfy every coefficient equation. -/
+theorem generator_relations (j : Fin E.equations) :
+    (∑ h, ∑ l, E.relations.quadratic j h l • (generator E h * generator E l)) +
+    (∑ h, E.relations.linear j h • generator E h) + E.relations.constant j • (1 : R) = 0 := by
+  have h := congrArg E.equiv (original_relation k (Fin E.generators)
+    (QuotientAction.polynomial E.relations) j)
+  simpa only [QuotientAction.polynomial,map_add,map_sum,map_smul,map_mul,map_one,map_zero,generator]
+    using h
+
+abbrev directedAlgebra := B E.relations
+
+noncomputable instance : Ring (directedAlgebra E) :=
+  ThreeVertexAlgebra.instRing (composition E.relations)
+
+theorem directedAlgebra_finiteDimensional : FiniteDimensional k (directedAlgebra E) :=
+  QuadraticEncoding.finiteDimensional E.relations
+
+open CategoryTheory in
+theorem directedAlgebra_globalDimension_le_two :
+    (⨆ N : ModuleCat.{max u w} (directedAlgebra E), projectiveDimension N) ≤ (2 : ℕ) ∧
+    (⨆ N : ModuleCat.{max u w} (directedAlgebra E)ᵐᵒᵖ, projectiveDimension N) ≤ (2 : ℕ) :=
+  QuadraticEncoding.globalDimension_le_two E.relations
+
+/-- The actual Section 2 selecting algebra has one fixed concrete finite encoding. -/
+noncomputable def auxiliaryEncoding : Encoding ℂ SelectionRing :=
+  Classical.choice (by
+    obtain ⟨d,t,P,⟨E⟩⟩ := PresentationReindex.auxiliaryGroupAlgebra_has_encoding
+    exact ⟨⟨d,t,P,E⟩⟩)
+end LittleFinitistic.SelectionEncoding
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Selection/SelectionIteration.lean b/lean/OAI/Algebra/Finitistic/Selection/SelectionIteration.lean
new file mode 100644
index 0000000000000000000000000000000000000000..a5be1101239861696370e9cffa96d8b4a78804a9
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Selection/SelectionIteration.lean
@@ -0,0 +1,173 @@
+import Mathlib.Algebra.Category.ModuleCat.ChangeOfRings
+import OAI.Algebra.Finitistic.Selection.TestModules
+
+namespace OAI
+namespace LittleFinitistic
+open CategoryTheory
+
+/-- The image of the central idempotent, expressed by its fixed vectors. -/
+noncomputable def selectedSubmodule (M : ModuleCat SelectionRing) : Submodule SelectionRing M where
+  carrier := {x | selectionIdempotent 0 • x = x}
+  zero_mem' := by simp
+  add_mem' := by
+    intro x y hx hy
+    change selectionIdempotent 0 • x = x at hx
+    change selectionIdempotent 0 • y = y at hy
+    change selectionIdempotent 0 • (x+y) = x+y
+    rw [smul_add,hx,hy]
+  smul_mem' := by
+    intro r x hx
+    change selectionIdempotent 0 • (r • x) = r • x
+    rw [← mul_smul,(selectionIdempotent_central 0 r).eq,mul_smul,hx]
+
+theorem selectedSubmodule_eq_image (M : ModuleCat SelectionRing) (x : M) :
+    x ∈ selectedSubmodule M ↔ ∃ y : M, selectionIdempotent 0 • y = x := by
+  constructor
+  · intro hx; exact ⟨x,hx⟩
+  · rintro ⟨y,rfl⟩
+    change selectionIdempotent 0 • (selectionIdempotent 0 • y) = _
+    rw [← mul_smul,selectionIdempotent_square]
+
+/-- Exactly H(Y) = restriction along alpha of eY from the manuscript. -/
+noncomputable def selectionStep (M : ModuleCat SelectionRing) : ModuleCat SelectionRing :=
+  (ModuleCat.restrictScalars (selectionAutomorphism 1).toRingHom).obj
+    (ModuleCat.of SelectionRing (selectedSubmodule M))
+
+noncomputable def selectionIterate (M : ModuleCat SelectionRing) : ℕ → ModuleCat SelectionRing
+  | 0 => M
+  | n+1 => selectionStep (selectionIterate M n)
+
+def IdentityAt (M : ModuleCat SelectionRing) (q : ℕ) : Prop :=
+  ∀ x : M, selectionIdempotent q • x = x
+
+def ZeroAt (M : ModuleCat SelectionRing) (q : ℕ) : Prop :=
+  ∀ x : M, selectionIdempotent q • x = 0
+
+theorem identityAt_step (M : ModuleCat SelectionRing) (q : ℕ)
+    (h : IdentityAt M (q+1)) : IdentityAt (selectionStep M) q := by
+  intro x
+  apply Subtype.ext
+  change selectionAutomorphism 1 (selectionIdempotent q) • x.val = x.val
+  rw [selectionAutomorphism_idempotent]
+  exact_mod_cast h x.val
+
+theorem zeroAt_step (M : ModuleCat SelectionRing) (q : ℕ)
+    (h : ZeroAt M (q+1)) : ZeroAt (selectionStep M) q := by
+  intro x
+  apply Subtype.ext
+  change selectionAutomorphism 1 (selectionIdempotent q) • x.val = 0
+  rw [selectionAutomorphism_idempotent]
+  exact_mod_cast h x.val
+
+theorem selectionStep_nontrivial (M : ModuleCat SelectionRing) [Nontrivial M]
+    (h : IdentityAt M 0) : Nontrivial (selectionStep M) := by
+  obtain ⟨x,y,hxy⟩ := exists_pair_ne M
+  exact ⟨⟨⟨x,h x⟩,⟨y,h y⟩,fun he => hxy (congrArg Subtype.val he)⟩⟩
+
+theorem selectionStep_subsingleton (M : ModuleCat SelectionRing)
+    (h : ZeroAt M 0) : Subsingleton (selectionStep M) := by
+  refine ⟨fun x y => Subtype.ext ?_⟩
+  have hx : x.val = 0 := (x.property).symm.trans (h x.val)
+  have hy : y.val = 0 := (y.property).symm.trans (h y.val)
+  exact hx.trans hy.symm
+
+theorem identityAt_iterate (M : ModuleCat SelectionRing) (n q : ℕ)
+    (h : IdentityAt M (q+n)) : IdentityAt (selectionIterate M n) q := by
+  induction n generalizing q with
+  | zero => simpa [selectionIterate] using h
+  | succ n ih =>
+    apply identityAt_step
+    apply ih
+    simpa [Nat.add_assoc,Nat.add_comm,Nat.add_left_comm] using h
+
+theorem zeroAt_iterate (M : ModuleCat SelectionRing) (n q : ℕ)
+    (h : ZeroAt M (q+n)) : ZeroAt (selectionIterate M n) q := by
+  induction n generalizing q with
+  | zero => simpa [selectionIterate] using h
+  | succ n ih =>
+    apply zeroAt_step
+    apply ih
+    simpa [Nat.add_assoc,Nat.add_comm,Nat.add_left_comm] using h
+
+noncomputable def testObject (m : ℕ) [NeZero m] : ModuleCat SelectionRing :=
+  ModuleCat.of SelectionRing (TestModule m)
+
+theorem testObject_identityAt (m : ℕ) [NeZero m] (q : ℕ) (hq : q < m-1) :
+    IdentityAt (testObject m) q := by
+  intro x
+  let i : Fin m := ⟨q,by omega⟩
+  have hi : i ≠ lastIndex m := by
+    intro h
+    have hv := congrArg Fin.val h
+    change q = m-1 at hv
+    omega
+  exact (testModule_idempotent_action m i x).trans (ite_eq_right hi)
+
+theorem testObject_zeroAt (m : ℕ) [NeZero m] : ZeroAt (testObject m) (m-1) := by
+  intro x
+  exact (testModule_idempotent_action m (lastIndex m) x).trans (ite_eq_left rfl)
+
+theorem selectionIterate_test_nontrivial (m : ℕ) [NeZero m] (n : ℕ) (hn : n < m) :
+    Nontrivial (selectionIterate (testObject m) n) := by
+  induction n with
+  | zero => exact testModule_nontrivial m
+  | succ n ih =>
+    have := ih (by omega)
+    apply selectionStep_nontrivial
+    apply identityAt_iterate
+    simpa only [Nat.zero_add] using testObject_identityAt m n (by omega)
+
+theorem selectionIterate_test_subsingleton (m : ℕ) [NeZero m] :
+    Subsingleton (selectionIterate (testObject m) m) := by
+  have hm : m = (m-1)+1 := by have := NeZero.ne m; omega
+  have hzero : ZeroAt (selectionIterate (testObject m) (m-1)) 0 :=
+    zeroAt_iterate (testObject m) (m-1) 0 (by simpa using testObject_zeroAt m)
+  have h := selectionStep_subsingleton _ hzero
+  change Subsingleton (selectionIterate (testObject m) ((m-1)+1)) at h
+  rwa [← hm] at h
+
+/-- Exact extinction under the manuscript's actual selection operation H:
+every earlier iterate is nonzero and the m-th iterate is zero. -/
+theorem selection_extinction (m : ℕ) [NeZero m] :
+    (∀ n < m, Nontrivial (selectionIterate (testObject m) n)) ∧
+    Subsingleton (selectionIterate (testObject m) m) :=
+  ⟨selectionIterate_test_nontrivial m,selectionIterate_test_subsingleton m⟩
+
+noncomputable def complexObject (M : ModuleCat SelectionRing) : ModuleCat ℂ :=
+  (ModuleCat.restrictScalars (algebraMap ℂ SelectionRing)).obj M
+
+noncomputable def selectionStep_inclusion (M : ModuleCat SelectionRing) :
+    complexObject (selectionStep M) →ₗ[ℂ] complexObject M where
+  toFun x := x.val
+  map_add' _ _ := rfl
+  map_smul' c x := by
+    change selectionAutomorphism 1 (algebraMap ℂ SelectionRing c) • x.val =
+      algebraMap ℂ SelectionRing c • x.val
+    rw [AlgEquiv.commutes]
+
+theorem selectionStep_finiteDimensional (M : ModuleCat SelectionRing)
+    [FiniteDimensional ℂ (complexObject M)] :
+    FiniteDimensional ℂ (complexObject (selectionStep M)) :=
+  FiniteDimensional.of_injective (selectionStep_inclusion M) Subtype.val_injective
+
+theorem testObject_finiteDimensional (m : ℕ) [NeZero m] :
+    FiniteDimensional ℂ (complexObject (testObject m)) := by
+  let f : complexObject (testObject m) →ₗ[ℂ] TestModule m :=
+    { toFun := fun x => x
+      map_add' := fun _ _ => rfl
+      map_smul' := fun c x => by
+        have h : ∀ y : TestModule m, algebraMap ℂ SelectionRing c • y = c • y :=
+          fun y => algebraMap_smul SelectionRing c y
+        exact h x }
+  exact FiniteDimensional.of_injective f (fun _ _ h => h)
+
+theorem selectionIterate_test_finiteDimensional (m : ℕ) [NeZero m] (n : ℕ) :
+    FiniteDimensional ℂ (complexObject (selectionIterate (testObject m) n)) := by
+  induction n with
+  | zero => exact testObject_finiteDimensional m
+  | succ n ih =>
+    have := ih
+    exact selectionStep_finiteDimensional _
+end LittleFinitistic
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Selection/TestModules.lean b/lean/OAI/Algebra/Finitistic/Selection/TestModules.lean
new file mode 100644
index 0000000000000000000000000000000000000000..9cc7de5a7bd156f44f48661530d0c697b9a67b49
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Selection/TestModules.lean
@@ -0,0 +1,67 @@
+import OAI.Algebra.Finitistic.Selection.CharacterModule
+import OAI.Algebra.Finitistic.Selection.SelectionCharacter
+import OAI.Algebra.Finitistic.Selection.SelectionAlgebra
+
+namespace OAI
+namespace LittleFinitistic
+open MonoidAlgebra
+
+noncomputable abbrev TestModule (m : ℕ) [NeZero m] :=
+  CharacterModule.eigenspace (quotientCentralEmbedding m) (selectionCharacter m)
+    (quotientCentralEmbedding_central m)
+
+noncomputable instance testModule_nontrivial (m : ℕ) [NeZero m] : Nontrivial (TestModule m) :=
+  CharacterModule.eigenspace_nontrivial _ _ _ (quotientCentralEmbedding_injective m)
+
+noncomputable instance testModule_finiteDimensional (m : ℕ) [NeZero m] :
+    FiniteDimensional ℂ (TestModule m) :=
+  CharacterModule.eigenspace_finiteDimensional _ _ _
+
+noncomputable def testRingMap (m : ℕ) [NeZero m] :
+    SelectionRing →ₐ[ℂ] MonoidAlgebra ℂ (FiniteQuotientGroup m) :=
+  MonoidAlgebra.mapDomainAlgHom ℂ ℂ (finiteQuotientMap m)
+
+noncomputable instance testModule_module (m : ℕ) [NeZero m] :
+    Module SelectionRing (TestModule m) :=
+  Module.compHom (TestModule m) (testRingMap m).toRingHom
+
+@[simp] theorem testModule_smul_val (m : ℕ) [NeZero m]
+    (r : SelectionRing) (x : TestModule m) :
+    ((r • x : TestModule m) : MonoidAlgebra ℂ (FiniteQuotientGroup m)) = testRingMap m r * x := rfl
+
+instance testModule_scalarTower (m : ℕ) [NeZero m] : IsScalarTower ℂ SelectionRing (TestModule m) where
+  smul_assoc c r x := by
+    apply Subtype.ext
+    change testRingMap m (c • r) * x.val = c • (testRingMap m r * x.val)
+    rw [map_smul,smul_mul_assoc]
+
+@[simp] theorem testRingMap_algebraZ (m : ℕ) [NeZero m] (q : ℤ) :
+    testRingMap m (algebraZ q) = single (finiteQuotientMap m (Presentation.z q)) 1 := by
+  simp [testRingMap,algebraZ]
+
+theorem testModule_basis_action (m : ℕ) [NeZero m] (i : Fin m) (x : TestModule m) :
+    algebraZ i.val • x = (if i = lastIndex m then (-1 : ℂ) else 1) • x := by
+  apply Subtype.ext
+  change testRingMap m (algebraZ i.val) * x.val = _
+  rw [testRingMap_algebraZ,← quotientCentralEmbedding_basis]
+  have hx := x.property (Multiplicative.ofAdd (Pi.single i 1))
+  rw [selectionCharacter_basis] at hx
+  by_cases h : i = lastIndex m
+  · simp only [h,ite_true,Units.val_neg,Units.val_one] at hx ⊢
+    exact hx
+  · simp only [h,ite_false,Units.val_one] at hx ⊢
+    exact hx
+
+/-- The first m−1 selecting idempotents act as identity; the next acts as zero. -/
+theorem testModule_idempotent_action (m : ℕ) [NeZero m] (i : Fin m) (x : TestModule m) :
+    selectionIdempotent i.val • x = if i = lastIndex m then 0 else x := by
+  classical
+  unfold selectionIdempotent
+  rw [smul_assoc,add_smul,one_smul,testModule_basis_action]
+  split_ifs
+  · rw [show (-1 : ℂ) • x = -x from neg_one_smul ℂ x,add_neg_cancel,smul_zero]
+  · rw [one_smul,← two_smul ℂ x,smul_smul]
+    norm_num
+end LittleFinitistic
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Tensor/BalancedFreeLeft.lean b/lean/OAI/Algebra/Finitistic/Tensor/BalancedFreeLeft.lean
new file mode 100644
index 0000000000000000000000000000000000000000..b927c729326628c5e169776f44c66f62db300a0c
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Tensor/BalancedFreeLeft.lean
@@ -0,0 +1,128 @@
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryFreeTensorExactness
+
+namespace OAI
+noncomputable section
+namespace LittleFinitistic.BalancedTensor.FreeLeft
+universe u
+variable {k A : Type u} [Field k] [Ring A] [Algebra k A]
+variable (I M : Type u) [AddCommGroup M] [Module k M] [Module Aᵐᵒᵖ M]
+  [IsScalarTower k Aᵐᵒᵖ M]
+
+/-- A coefficient of a free left module acts on the right tensor factor. -/
+def coefficientAction : A →ₗ[k] M →ₗ[k] M :=
+  (Algebra.lsmul k k M).toLinearMap.comp (MulOpposite.opLinearEquiv k).toLinearMap
+
+def evaluateBilinear : M →ₗ[k] (I →₀ A) →ₗ[k] (I →₀ M) :=
+  (Finsupp.lsum k (fun i =>
+    (coefficientAction (k := k) (A := A) M).compr₂ (Finsupp.lsingle i))).flip
+
+@[simp] theorem evaluateBilinear_single (i : I) (a : A) (m : M) :
+    evaluateBilinear (k := k) I M m (Finsupp.single i a) =
+      Finsupp.single i (MulOpposite.op a • m) := by
+  simp only [evaluateBilinear,LinearMap.flip_apply,Finsupp.lsum_single]
+  rfl
+
+def evaluation : Tensor k A M (I →₀ A) →ₗ[k] (I →₀ M) :=
+  lift (evaluateBilinear (k := k) I M) (by
+    intro a m n
+    induction n using Finsupp.induction_linear with
+    | zero => simp only [smul_zero,map_zero]
+    | add x y hx hy => simp only [smul_add,map_add,hx,hy]
+    | single i x =>
+      rw [Finsupp.smul_single,evaluateBilinear_single,evaluateBilinear_single]
+      change Finsupp.single i (MulOpposite.op x • (MulOpposite.op a • m)) =
+        Finsupp.single i (MulOpposite.op (a*x) • m)
+      rw [← mul_smul,MulOpposite.op_mul])
+
+@[simp] theorem evaluation_single (i : I) (a : A) (m : M) :
+    evaluation (k := k) I M (mk k A M (I →₀ A) m (Finsupp.single i a)) =
+      Finsupp.single i (MulOpposite.op a • m) := evaluateBilinear_single I M i a m
+
+def insertion : (I →₀ M) →ₗ[k] Tensor k A M (I →₀ A) :=
+  Finsupp.lsum k (fun i => (mk k A M (I →₀ A)).flip (Finsupp.single i 1))
+
+omit [IsScalarTower k Aᵐᵒᵖ M] in
+@[simp] theorem insertion_single (i : I) (m : M) :
+    insertion (k := k) (A := A) I M (Finsupp.single i m) =
+      mk k A M (I →₀ A) m (Finsupp.single i 1) := by
+  simp only [insertion,Finsupp.lsum_single,LinearMap.flip_apply]
+
+theorem evaluation_insertion (z : I →₀ M) :
+    evaluation (k := k) (A := A) I M (insertion I M z) = z := by
+  induction z using Finsupp.induction_linear with
+  | zero => simp only [map_zero]
+  | add x y hx hy => simp only [map_add,hx,hy]
+  | single i m => rw [insertion_single,evaluation_single,MulOpposite.op_one,one_smul]
+
+theorem insertion_evaluation (z : Tensor k A M (I →₀ A)) :
+    insertion I M (evaluation (k := k) I M z) = z := by
+  induction z using BalancedTensor.induction_on with
+  | hz => simp only [map_zero]
+  | ht m n =>
+    induction n using Finsupp.induction_linear with
+    | zero => simp only [map_zero]
+    | add x y hx hy => simp only [map_add,hx,hy]
+    | single i a =>
+      rw [evaluation_single,insertion_single,balance]
+      congr 1
+      rw [Finsupp.smul_single,smul_eq_mul,mul_one]
+  | ha x y hx hy => simp only [map_add,hx,hy]
+
+/-- Tensor with an arbitrary free left module is the direct sum of the right module. -/
+def equivalence : Tensor k A M (I →₀ A) ≃ₗ[k] (I →₀ M) where
+  __ := evaluation (k := k) I M
+  invFun := insertion I M
+  left_inv := insertion_evaluation I M
+  right_inv := evaluation_insertion I M
+
+variable {M} {M' M'' : Type u}
+variable [AddCommGroup M'] [Module k M'] [Module Aᵐᵒᵖ M'] [IsScalarTower k Aᵐᵒᵖ M']
+variable [AddCommGroup M''] [Module k M''] [Module Aᵐᵒᵖ M''] [IsScalarTower k Aᵐᵒᵖ M'']
+
+theorem evaluation_naturality (f : M →ₗ[Aᵐᵒᵖ] M') (z : Tensor k A M (I →₀ A)) :
+    evaluation (k := k) I M' (mapLeft (I →₀ A) f z) =
+      Finsupp.mapRange.linearMap (f.restrictScalars k) (evaluation (k := k) I M z) := by
+  induction z using BalancedTensor.induction_on with
+  | hz => simp only [map_zero]
+  | ht m n =>
+    induction n using Finsupp.induction_linear with
+    | zero => simp only [map_zero]
+    | add x y hx hy => simp only [map_add,hx,hy]
+    | single i a =>
+      simp only [mapLeft_mk,evaluation_single]
+      ext j
+      change (Finsupp.single i (MulOpposite.op a • f m)) j =
+        (Finsupp.mapRange f f.map_zero (Finsupp.single i (MulOpposite.op a • m))) j
+      rw [Finsupp.mapRange_single, f.map_smul]
+  | ha x y hx hy => simp only [map_add,hx,hy]
+
+/-- Free left tensor preserves exact sequences of right modules. -/
+theorem tensor_exact (f : M →ₗ[Aᵐᵒᵖ] M') (g : M' →ₗ[Aᵐᵒᵖ] M'')
+    (h : Function.Exact f g) :
+    Function.Exact (mapLeft (k := k) (I →₀ A) f) (mapLeft (k := k) (I →₀ A) g) := by
+  intro z
+  constructor
+  · intro hz
+    have hz' : Finsupp.mapRange.linearMap (g.restrictScalars k) (evaluation (k := k) I M' z) = 0 := by
+      rw [← evaluation_naturality,hz,map_zero]
+    obtain ⟨y,hy⟩ := (Free.finsupp_exact (k := k) I f g h _).mp hz'
+    refine ⟨(equivalence (k := k) (A := A) I M).symm y, ?_⟩
+    apply (equivalence (k := k) (A := A) I M').injective
+    change evaluation (k := k) I M' (mapLeft (I →₀ A) f
+      ((equivalence (k := k) (A := A) I M).symm y)) = _
+    rw [evaluation_naturality]
+    change Finsupp.mapRange.linearMap (f.restrictScalars k)
+      ((equivalence (k := k) (A := A) I M) ((equivalence (k := k) (A := A) I M).symm y)) = _
+    rw [LinearEquiv.apply_symm_apply]
+    exact hy
+  · rintro ⟨y,rfl⟩
+    induction y using BalancedTensor.induction_on with
+    | hz => simp only [map_zero]
+    | ht m n =>
+      rw [mapLeft_mk,mapLeft_mk,(h (f m)).mpr ⟨m,rfl⟩,map_zero,LinearMap.zero_apply]
+    | ha x y hx hy => simp only [map_add,hx,hy,add_zero]
+end LittleFinitistic.BalancedTensor.FreeLeft
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Tensor/BalancedProjectiveLeft.lean b/lean/OAI/Algebra/Finitistic/Tensor/BalancedProjectiveLeft.lean
new file mode 100644
index 0000000000000000000000000000000000000000..8da5a8a1d11255b5888ceb3d00345f6e2f0760ce
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Tensor/BalancedProjectiveLeft.lean
@@ -0,0 +1,94 @@
+import OAI.Algebra.Finitistic.Tensor.BalancedFreeLeft
+import OAI.Algebra.Finitistic.Ordinary.OrdinaryProjectiveTensor
+import OAI.Algebra.Finitistic.Bimodule.BimoduleTensorFunctor
+
+namespace OAI
+noncomputable section
+open CategoryTheory
+namespace LittleFinitistic.BalancedTensor
+universe u
+variable {k A M M' M'' N N' : Type u} [Field k] [Ring A] [Algebra k A]
+variable [AddCommGroup M] [Module k M] [Module Aᵐᵒᵖ M] [IsScalarTower k Aᵐᵒᵖ M]
+variable [AddCommGroup M'] [Module k M'] [Module Aᵐᵒᵖ M'] [IsScalarTower k Aᵐᵒᵖ M']
+variable [AddCommGroup M''] [Module k M''] [Module Aᵐᵒᵖ M''] [IsScalarTower k Aᵐᵒᵖ M'']
+variable [AddCommGroup N] [Module k N] [Module A N] [IsScalarTower k A N]
+variable [AddCommGroup N'] [Module k N'] [Module A N'] [IsScalarTower k A N']
+
+omit [IsScalarTower k Aᵐᵒᵖ M] in
+theorem mapRightTo_split (i : N →ₗ[A] N') (p : N' →ₗ[A] N)
+    (hp : p.comp i = LinearMap.id) (z : Tensor k A M N) :
+    mapRightTo p (mapRightTo i z) = z := by
+  induction z using BalancedTensor.induction_on with
+  | hz => simp
+  | ht m n =>
+    rw [mapRightTo_mk,mapRightTo_mk]
+    exact congrArg (mk k A M N m) (LinearMap.congr_fun hp n)
+  | ha x y hx hy => simp only [map_add,hx,hy]
+
+theorem leftTensor_exact_of_split (i : N →ₗ[A] N') (p : N' →ₗ[A] N)
+    (hp : p.comp i = LinearMap.id) (f : M →ₗ[Aᵐᵒᵖ] M') (g : M' →ₗ[Aᵐᵒᵖ] M'')
+    (h : Function.Exact f g)
+    (h' : Function.Exact (mapLeft (k := k) N' f) (mapLeft (k := k) N' g)) :
+    Function.Exact (mapLeft (k := k) N f) (mapLeft (k := k) N g) := by
+  intro z
+  constructor
+  · intro hz
+    have hi : mapLeft N' g (mapRightTo i z) = 0 := by
+      rw [mapLeft_mapRightTo,hz,map_zero]
+    obtain ⟨y,hy⟩ := (h' _).mp hi
+    refine ⟨mapRightTo p y, ?_⟩
+    rw [mapLeft_mapRightTo,hy,mapRightTo_split i p hp]
+  · rintro ⟨y,rfl⟩
+    induction y using BalancedTensor.induction_on with
+    | hz => simp
+    | ht m n => rw [mapLeft_mk,mapLeft_mk,(h (f m)).mpr ⟨m,rfl⟩,map_zero,LinearMap.zero_apply]
+    | ha x y hx hy => simp only [map_add,hx,hy,add_zero]
+
+/-- Projectivity of the left input preserves every exact sequence in the right variable. -/
+theorem projectiveLeftTensor_exact [Module.Projective A N]
+    (f : M →ₗ[Aᵐᵒᵖ] M') (g : M' →ₗ[Aᵐᵒᵖ] M'') (h : Function.Exact f g) :
+    Function.Exact (mapLeft (k := k) N f) (mapLeft (k := k) N g) := by
+  obtain ⟨i,hi⟩ := (Module.projective_def' (R := A) (P := N)).mp inferInstance
+  exact leftTensor_exact_of_split i (Finsupp.linearCombination A id) hi f g h
+    (FreeLeft.tensor_exact (k := k) N f g h)
+end LittleFinitistic.BalancedTensor
+
+namespace LittleFinitistic.BimoduleBalancedTensor
+open ExternalTensor.Section4
+universe u
+variable (k B N : Type u) [Field k] [Ring B] [Algebra k B]
+variable [AddCommGroup N] [Module k N] [Module B N] [IsScalarTower k B N]
+variable [Module.Projective B N]
+
+/-- Exactness of tensoring genuine bimodules with a projective left module,
+with the result still in B-Mod. -/
+theorem projectiveInput_mapsExact
+    (S : ShortComplex (ModuleCat.{u} (Enveloping k B))) (hS : S.Exact) :
+    (S.map (functor k B N)).Exact := by
+  rw [ShortComplex.moduleCat_exact_iff]
+  have h : Function.Exact
+      (((forgetRight k B).map S.f).hom : Input k B S.X₁ →ₗ[Bᵐᵒᵖ] Input k B S.X₂)
+      (((forgetRight k B).map S.g).hom : Input k B S.X₂ →ₗ[Bᵐᵒᵖ] Input k B S.X₃) := by
+    intro x
+    constructor
+    · exact (ShortComplex.moduleCat_exact_iff S).mp hS x
+    · rintro ⟨y,rfl⟩
+      exact congrArg (fun t => t.hom y) S.zero
+  intro z hz
+  exact ((BalancedTensor.projectiveLeftTensor_exact (k := k) (N := N)
+    (((forgetRight k B).map S.f).hom : Input k B S.X₁ →ₗ[Bᵐᵒᵖ] Input k B S.X₂)
+    (((forgetRight k B).map S.g).hom : Input k B S.X₂ →ₗ[Bᵐᵒᵖ] Input k B S.X₃) h) z).mp hz
+
+theorem projectiveInput_preservesHomology : (functor k B N).PreservesHomology :=
+  Functor.preservesHomology_of_map_exact _ (projectiveInput_mapsExact k B N)
+
+/-- An actual bimodule augmentation quasi-isomorphism remains one on each projective input row. -/
+theorem projectiveInput_quasiIso {P Q : BiComplex k B} (ε : P ⟶ Q) [QuasiIso ε] :
+    QuasiIso (((functor k B N).mapHomologicalComplex (.up ℤ)).map ε) := by
+  have := projectiveInput_preservesHomology k B N
+  infer_instance
+end LittleFinitistic.BimoduleBalancedTensor
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Tensor/BalancedTensor.lean b/lean/OAI/Algebra/Finitistic/Tensor/BalancedTensor.lean
new file mode 100644
index 0000000000000000000000000000000000000000..35eb2b29f458eeda4bc01c7bb17cbc07ad6f75ef
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Tensor/BalancedTensor.lean
@@ -0,0 +1,76 @@
+import Mathlib.LinearAlgebra.TensorProduct.Basic
+import Mathlib.LinearAlgebra.Quotient.Basic
+import Mathlib.Algebra.Algebra.Tower
+
+namespace OAI
+noncomputable section
+open scoped TensorProduct
+namespace LittleFinitistic.BalancedTensor
+universe u v w w' z
+variable (k : Type u) [Field k] (A : Type v) [Ring A]
+variable (M : Type w) [AddCommGroup M] [Module k M] [Module Aᵐᵒᵖ M]
+variable (N : Type w') [AddCommGroup N] [Module k N] [Module A N]
+
+/-- Balancing relations for a right A-module and a left A-module, over k. -/
+def relations : Submodule k (M ⊗[k] N) := Submodule.span k
+  (Set.range fun q : A × M × N =>
+    (MulOpposite.op q.1 • q.2.1) ⊗ₜ[k] q.2.2 - q.2.1 ⊗ₜ[k] (q.1 • q.2.2))
+
+/-- Tensor over the possibly noncommutative algebra A. -/
+abbrev Tensor := (M ⊗[k] N) ⧸ relations k A M N
+
+def mk : M →ₗ[k] N →ₗ[k] Tensor k A M N :=
+  (TensorProduct.mk k M N).compr₂ (relations k A M N).mkQ
+
+variable {k A M N}
+
+theorem balance (a : A) (m : M) (n : N) :
+    mk k A M N (MulOpposite.op a • m) n = mk k A M N m (a • n) := by
+  apply sub_eq_zero.mp
+  change (relations k A M N).mkQ ((MulOpposite.op a • m) ⊗ₜ[k] n) -
+    (relations k A M N).mkQ (m ⊗ₜ[k] (a • n)) = 0
+  rw [← map_sub]
+  exact (Submodule.Quotient.mk_eq_zero _).mpr
+    (Submodule.subset_span ⟨(a,m,n),rfl⟩)
+
+variable {V : Type z} [AddCommGroup V] [Module k V]
+
+/-- Universal property for k-bilinear maps satisfying the actual A-balancing equation. -/
+def lift (f : M →ₗ[k] N →ₗ[k] V)
+    (hf : ∀ (a : A) m n, f (MulOpposite.op a • m) n = f m (a • n)) : Tensor k A M N →ₗ[k] V :=
+  (relations k A M N).liftQ (TensorProduct.lift f) (by
+    rw [relations, Submodule.span_le]
+    rintro _ ⟨⟨a,m,n⟩,rfl⟩
+    change TensorProduct.lift f ((MulOpposite.op a • m) ⊗ₜ[k] n - m ⊗ₜ[k] (a • n)) = 0
+    simp only [map_sub, TensorProduct.lift.tmul, hf, sub_self])
+
+@[simp] theorem lift_mk (f : M →ₗ[k] N →ₗ[k] V)
+    (hf : ∀ (a : A) m n, f (MulOpposite.op a • m) n = f m (a • n)) (m : M) (n : N) :
+    lift f hf (mk k A M N m n) = f m n := rfl
+
+@[elab_as_elim] theorem induction_on {C : Tensor k A M N → Prop} (x : Tensor k A M N)
+    (hz : C 0) (ht : ∀ m n, C (mk k A M N m n))
+    (ha : ∀ a b, C a → C b → C (a+b)) : C x := by
+  classical
+  by_cases zero_tensor : x = 0
+  · simpa [zero_tensor] using hz
+  clear zero_tensor
+  induction x using Submodule.Quotient.induction_on with
+  | _ x =>
+    induction x using TensorProduct.inductionOn with
+    | tmul m n => exact ht m n
+    | add a b h₁ h₂ => exact ha _ _ h₁ h₂
+
+@[ext] theorem ext {f g : Tensor k A M N →ₗ[k] V}
+    (h : ∀ m n, f (mk k A M N m n) = g (mk k A M N m n)) : f = g := by
+  apply LinearMap.ext
+  intro x
+  induction x using induction_on with
+  | hz => simp
+  | ht m n => exact h m n
+  | ha a b h₁ h₂ => simp [h₁,h₂]
+end LittleFinitistic.BalancedTensor
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Tensor/BalancedTensorMaps.lean b/lean/OAI/Algebra/Finitistic/Tensor/BalancedTensorMaps.lean
new file mode 100644
index 0000000000000000000000000000000000000000..11fa74532587a67dda7d3d0c04abc999a2e459fd
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Tensor/BalancedTensorMaps.lean
@@ -0,0 +1,46 @@
+import OAI.Algebra.Finitistic.Tensor.BalancedTensor
+
+namespace OAI
+noncomputable section
+namespace LittleFinitistic.BalancedTensor
+universe u v w w' w'' z
+variable {k : Type u} [Field k] {A : Type v} [Ring A] [Algebra k A]
+variable {M : Type w} [AddCommGroup M] [Module k M] [Module Aᵐᵒᵖ M]
+variable {M' : Type w'} [AddCommGroup M'] [Module k M'] [Module Aᵐᵒᵖ M']
+variable {M'' : Type w''} [AddCommGroup M''] [Module k M''] [Module Aᵐᵒᵖ M'']
+variable (N : Type z) [AddCommGroup N] [Module k N] [Module A N]
+variable [IsScalarTower k Aᵐᵒᵖ M] [IsScalarTower k Aᵐᵒᵖ M']
+  [IsScalarTower k Aᵐᵒᵖ M'']
+
+/-- Tensor an actual right-module homomorphism with the identity. -/
+def mapLeft (f : M →ₗ[Aᵐᵒᵖ] M') : Tensor k A M N →ₗ[k] Tensor k A M' N :=
+  lift ((mk k A M' N).compl₁₂ (f.restrictScalars k) LinearMap.id) (by
+    intro a m n
+    change mk k A M' N (f (MulOpposite.op a • m)) n = mk k A M' N (f m) (a • n)
+    rw [map_smul]
+    exact balance a (f m) n)
+
+@[simp] theorem mapLeft_mk (f : M →ₗ[Aᵐᵒᵖ] M') (m : M) (n : N) :
+    mapLeft (k := k) N f (mk k A M N m n) = mk k A M' N (f m) n := rfl
+
+@[simp] theorem mapLeft_id : mapLeft (k := k) N (LinearMap.id : M →ₗ[Aᵐᵒᵖ] M) = LinearMap.id := by
+  apply ext
+  intro m n
+  rfl
+
+@[simp] theorem mapLeft_comp (f : M →ₗ[Aᵐᵒᵖ] M') (g : M' →ₗ[Aᵐᵒᵖ] M'') :
+    mapLeft (k := k) N (g.comp f) = (mapLeft (k := k) N g).comp (mapLeft (k := k) N f) := by
+  apply ext
+  intro m n
+  rfl
+
+@[simp] theorem mapLeft_add (f g : M →ₗ[Aᵐᵒᵖ] M') :
+    mapLeft (k := k) N (f+g) = mapLeft (k := k) N f + mapLeft (k := k) N g := by
+  apply ext
+  intro m n
+  simp
+end LittleFinitistic.BalancedTensor
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Tensor/BalancedVertexFunctor.lean b/lean/OAI/Algebra/Finitistic/Tensor/BalancedVertexFunctor.lean
new file mode 100644
index 0000000000000000000000000000000000000000..495a8c535a61df0b14316d4255544fc75738f7d8
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Tensor/BalancedVertexFunctor.lean
@@ -0,0 +1,86 @@
+import OAI.Algebra.Finitistic.Tensor.BalancedVertexImage
+
+namespace OAI
+noncomputable section
+open CategoryTheory
+open scoped TensorProduct ModuleCat.Algebra
+namespace LittleFinitistic.BalancedVertexFunctor
+open ExternalTensor.Section4
+universe u
+variable (k B : Type u) [Field k] [Ring B] [Algebra k B]
+variable (e : B) (he : e*e=e)
+variable (N : Type u) [AddCommGroup N] [Module k N] [Module B N]
+
+abbrev Space (M : ModuleCat.{u} (Enveloping k B)) :=
+  IdempotentTensor.leftSpace (k := k) e (BimoduleBalancedTensor.Tensor k B M N)
+
+def spaceMap {M M' : ModuleCat.{u} (Enveloping k B)} (f : M ⟶ M') :
+    Space k B e N M →ₗ[k] Space k B e N M' :=
+  (((BimoduleBalancedTensor.map k B N f).restrictScalars k).comp
+    (Space k B e N M).subtype).codRestrict _ (by
+      intro x
+      change e • (BimoduleBalancedTensor.map k B N f x.val) =
+        BimoduleBalancedTensor.map k B N f x.val
+      rw [← (BimoduleBalancedTensor.map k B N f).map_smul,x.property])
+
+/-- The actual left vertex of the balanced tensor, with its original induced maps. -/
+def functor : ModuleCat.{u} (Enveloping k B) ⥤ ModuleCat.{u} k where
+  obj M := ModuleCat.of k (Space k B e N M)
+  map f := ModuleCat.ofHom (spaceMap k B e N f)
+  map_id M := by
+    apply ModuleCat.hom_ext
+    apply LinearMap.ext
+    intro x
+    apply Subtype.ext
+    exact congrArg (fun f : (BimoduleBalancedTensor.functor k B N).obj M ⟶
+        (BimoduleBalancedTensor.functor k B N).obj M => f.hom x.val)
+      ((BimoduleBalancedTensor.functor k B N).map_id M)
+  map_comp f g := by
+    apply ModuleCat.hom_ext
+    apply LinearMap.ext
+    intro x
+    apply Subtype.ext
+    exact congrArg (fun f => ModuleCat.Hom.hom f x.val)
+      ((BimoduleBalancedTensor.functor k B N).map_comp f g)
+
+instance additive : (functor k B e N).Additive where
+  map_add := by
+    intros M M' f g
+    apply ModuleCat.hom_ext
+    apply LinearMap.ext
+    intro x
+    apply Subtype.ext
+    exact congrArg (fun a : (BimoduleBalancedTensor.functor k B N).obj M ⟶
+      (BimoduleBalancedTensor.functor k B N).obj M' => a.hom x.val)
+      ((BimoduleBalancedTensor.functor k B N).map_add (f := f) (g := g))
+
+/-- Vertex extraction commutes naturally with the original balanced tensor functor. -/
+def comparison : BimoduleVertex.functor k B e ⋙ BalancedTensor.tensorFunctor k B N ≅
+    functor k B e N :=
+  NatIso.ofComponents (fun M => (BalancedVertexImage.equiv k B M e he N).toModuleIso) (by
+    intro M M' f
+    apply ModuleCat.hom_ext
+    apply LinearMap.ext
+    intro x
+    apply Subtype.ext
+    have hn : (BimoduleVertex.functor k B e).map f ≫ BalancedVertexImage.inclusion k B M' e =
+        BalancedVertexImage.inclusion k B M e ≫ (forgetRight k B).map f := by
+      apply ModuleCat.hom_ext
+      apply LinearMap.ext
+      intro y
+      rfl
+    have hF := congrArg (fun a => (BalancedTensor.tensorFunctor k B N).map a) hn
+    simp only [Functor.map_comp] at hF
+    exact congrArg (fun a => ModuleCat.Hom.hom a x) hF)
+
+/-- The natural comparison gives an actual chain isomorphism on every bimodule complex. -/
+def complexIso (P : BiComplex k B) :
+    ((BimoduleVertex.functor k B e ⋙ BalancedTensor.tensorFunctor k B N).mapHomologicalComplex (.up ℤ)).obj P ≅
+      ((functor k B e N).mapHomologicalComplex (.up ℤ)).obj P :=
+  HomologicalComplex.Hom.isoOfComponents (fun n => (comparison k B e he N).app (P.X n))
+    (fun n m _ => ((comparison k B e he N).hom.naturality (P.d n m)).symm)
+end LittleFinitistic.BalancedVertexFunctor
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Tensor/BalancedVertexImage.lean b/lean/OAI/Algebra/Finitistic/Tensor/BalancedVertexImage.lean
new file mode 100644
index 0000000000000000000000000000000000000000..57546dcbf2bcd518dd4c5055a2eaca562294e3b2
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Tensor/BalancedVertexImage.lean
@@ -0,0 +1,70 @@
+import OAI.Algebra.Finitistic.Bimodule.BimoduleTensorFunctor
+import OAI.Algebra.Finitistic.Localization.AdditiveSplitImage
+import OAI.Algebra.Finitistic.Tensor.IdempotentTensor
+
+namespace OAI
+noncomputable section
+open CategoryTheory
+open scoped TensorProduct ModuleCat.Algebra
+namespace LittleFinitistic.BalancedVertexImage
+open ExternalTensor.Section4
+universe u
+variable (k B : Type u) [Field k] [Ring B] [Algebra k B]
+variable (M : ModuleCat.{u} (Enveloping k B)) (e : B) (he : e*e=e)
+variable (N : Type u) [AddCommGroup N] [Module k N] [Module B N]
+
+local instance originalRightModule : Module Bᵐᵒᵖ M :=
+  Module.compHom M (BimoduleVertex.restriction k B)
+
+abbrev V := (BimoduleVertex.functor k B e).obj M
+abbrev W := (forgetRight k B).obj M
+abbrev F := BalancedTensor.tensorFunctor k B N
+
+def inclusion : V k B M e ⟶ W k B M := ModuleCat.ofHom
+  (VertexFunctor.inclusion (BimoduleVertex.restriction k B) (BimoduleVertex.vertex k B e)
+    (BimoduleVertex.vertex_commute k B e) M)
+def projection : W k B M ⟶ V k B M e := ModuleCat.ofHom
+  (VertexFunctor.projection (BimoduleVertex.restriction k B) (BimoduleVertex.vertex k B e)
+    (BimoduleVertex.vertex_idempotent k B e he) (BimoduleVertex.vertex_commute k B e) M)
+
+theorem split : inclusion k B M e ≫ projection k B M e he = 𝟙 _ :=
+  ModuleCat.hom_ext (VertexFunctor.projection_inclusion (BimoduleVertex.restriction k B)
+    (BimoduleVertex.vertex k B e) (BimoduleVertex.vertex_idempotent k B e he)
+    (BimoduleVertex.vertex_commute k B e) M)
+
+theorem projector : ((F k B N).map (projection k B M e he ≫ inclusion k B M e)).hom =
+    BimoduleBalancedTensor.action k B M N e := by
+  apply BalancedTensor.ext
+  intro m n
+  rfl
+
+/-- The image of the original vertex projector after tensoring is the actual left vertex. -/
+def fixedEquiv :
+    AdditiveSplitImage.fixed (F k B N) (inclusion k B M e) (projection k B M e he) ≃ₗ[k]
+      IdempotentTensor.leftSpace (k := k) e (BimoduleBalancedTensor.Tensor k B M N) where
+  toFun x := ⟨x.val,by
+    change BimoduleBalancedTensor.action k B M N e x.val = x.val
+    rw [← projector k B M e he N]
+    exact (AdditiveSplitImage.mem_fixed _ _ _ x.val).1 x.property⟩
+  invFun x := ⟨x.val,by
+    exact (AdditiveSplitImage.mem_fixed (F k B N) (inclusion k B M e)
+      (projection k B M e he) x.val).2
+        ((LinearMap.congr_fun (projector k B M e he N) x.val).trans x.property)⟩
+  left_inv _ := rfl
+  right_inv _ := rfl
+  map_add' _ _ := rfl
+  map_smul' _ _ := rfl
+
+/-- Vertex extraction commutes with actual balanced tensoring, without a flatness assumption. -/
+def equiv : (F k B N).obj (V k B M e) ≃ₗ[k]
+    IdempotentTensor.leftSpace (k := k) e (BimoduleBalancedTensor.Tensor k B M N) :=
+  (AdditiveSplitImage.equiv (F k B N) (inclusion k B M e) (projection k B M e he)
+    (split k B M e he)).trans (fixedEquiv k B M e he N)
+
+@[simp] theorem equiv_apply_val (x : (F k B N).obj (V k B M e)) :
+    (equiv k B M e he N x).val = ((F k B N).map (inclusion k B M e)).hom x := rfl
+end LittleFinitistic.BalancedVertexImage
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Tensor/IdempotentTensor.lean b/lean/OAI/Algebra/Finitistic/Tensor/IdempotentTensor.lean
new file mode 100644
index 0000000000000000000000000000000000000000..fc20067e9236b0fcb347a77247452d60a3307e16
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Tensor/IdempotentTensor.lean
@@ -0,0 +1,81 @@
+import OAI.Algebra.Finitistic.Tensor.BalancedTensorMaps
+
+namespace OAI
+noncomputable section
+namespace LittleFinitistic.IdempotentTensor
+universe u v w
+variable {k : Type u} [Field k] {A : Type v} [Ring A] [Algebra k A]
+variable (e : A)
+
+/-- The actual projective right ideal eA, presented as the fixed points of left multiplication. -/
+def rightIdeal : Submodule Aᵐᵒᵖ A where
+  carrier := {a | e*a=a}
+  zero_mem' := mul_zero e
+  add_mem' ha hb := by change e*(_+_)=_+_; rw [mul_add,ha,hb]
+  smul_mem' b a ha := by
+    change e*(a*b.unop)=a*b.unop
+    rw [← mul_assoc,ha]
+
+variable (N : Type w) [AddCommGroup N] [Module k N] [Module A N]
+  [IsScalarTower k A N]
+
+/-- The vertex part eN, without assuming e is central. -/
+def leftSpace : Submodule k N where
+  carrier := {n | e • n = n}
+  zero_mem' := smul_zero e
+  add_mem' ha hb := by change e • (_+_) = _+_; rw [smul_add,ha,hb]
+  smul_mem' c n hn := by change e • (c • n) = c • n; rw [smul_comm e c,hn]
+
+def productEval : rightIdeal e →ₗ[k] N →ₗ[k] leftSpace (k := k) e N where
+  toFun a :=
+    { toFun := fun n => ⟨a.val • n, by change e • (a.val • n) = a.val • n; rw [← mul_smul,a.property]⟩
+      map_add' n m := Subtype.ext (smul_add a.val n m)
+      map_smul' c n := Subtype.ext (smul_comm a.val c n) }
+  map_add' a b := by ext n; exact add_smul a.val b.val n
+  map_smul' c a := by ext n; exact smul_assoc c a.val n
+
+/-- The natural map eA tensor_A N → eN. -/
+def tensorEval : BalancedTensor.Tensor k A (rightIdeal e) N →ₗ[k] leftSpace (k := k) e N :=
+  BalancedTensor.lift (productEval (k := k) e N) (by
+    intro a m n
+    apply Subtype.ext
+    exact mul_smul m.val a n)
+
+@[simp] theorem tensorEval_mk (m : rightIdeal e) (n : N) :
+    (tensorEval (k := k) e N (BalancedTensor.mk k A (rightIdeal e) N m n)).val = m.val • n := rfl
+
+variable (he : e*e=e)
+
+def tensorInv : leftSpace (k := k) e N →ₗ[k] BalancedTensor.Tensor k A (rightIdeal e) N :=
+  (BalancedTensor.mk k A (rightIdeal e) N ⟨e,he⟩).comp (leftSpace (k := k) e N).subtype
+
+@[simp] theorem tensorEval_tensorInv (n : leftSpace (k := k) e N) :
+    tensorEval (k := k) e N (tensorInv (k := k) e N he n) = n := by
+  apply Subtype.ext
+  exact n.property
+
+@[simp] theorem tensorInv_tensorEval (z : BalancedTensor.Tensor k A (rightIdeal e) N) :
+    tensorInv (k := k) e N he (tensorEval (k := k) e N z) = z := by
+  induction z using BalancedTensor.induction_on with
+  | hz => simp
+  | ht m n =>
+    change BalancedTensor.mk k A (rightIdeal e) N ⟨e,he⟩ (m.val • n) =
+      BalancedTensor.mk k A (rightIdeal e) N m n
+    rw [← BalancedTensor.balance]
+    have hm : MulOpposite.op m.val • (⟨e,he⟩ : rightIdeal e) = m := by
+      apply Subtype.ext
+      exact m.property
+    rw [hm]
+  | ha a b h₁ h₂ => simp [h₁,h₂]
+
+/-- Evaluation on a vertex projective is its actual vertex space. -/
+def tensorEquiv : BalancedTensor.Tensor k A (rightIdeal e) N ≃ₗ[k] leftSpace (k := k) e N where
+  __ := tensorEval (k := k) e N
+  invFun := tensorInv (k := k) e N he
+  left_inv := tensorInv_tensorEval (k := k) e N he
+  right_inv := tensorEval_tensorInv (k := k) e N he
+end LittleFinitistic.IdempotentTensor
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Finitistic/Tensor/IdempotentTensorMaps.lean b/lean/OAI/Algebra/Finitistic/Tensor/IdempotentTensorMaps.lean
new file mode 100644
index 0000000000000000000000000000000000000000..96e8b64804eede87d7f0ead8e1b9de875aea25a8
--- /dev/null
+++ b/lean/OAI/Algebra/Finitistic/Tensor/IdempotentTensorMaps.lean
@@ -0,0 +1,38 @@
+import OAI.Algebra.Finitistic.Tensor.IdempotentTensor
+import Mathlib.Algebra.Module.Projective
+
+namespace OAI
+noncomputable section
+namespace LittleFinitistic.IdempotentTensor
+universe u v w
+variable {A : Type v} [Ring A] {e e' : A}
+
+/-- An element of e'Ae acts by left multiplication on the right projectives. -/
+def leftMultiply (b : A) (hb : e'*b=b) : rightIdeal e →ₗ[Aᵐᵒᵖ] rightIdeal e' where
+  toFun m := ⟨b*m.val, by change e'*(b*m.val)=b*m.val; rw [← mul_assoc,hb]⟩
+  map_add' m n := Subtype.ext (mul_add b m.val n.val)
+  map_smul' a m := by apply Subtype.ext; exact (mul_assoc b m.val a.unop).symm
+
+@[simp] theorem leftMultiply_apply (b : A) (hb : e'*b=b) (m : rightIdeal e) :
+    (leftMultiply b hb m).val = b*m.val := rfl
+
+/-- eA is a retract of the rank-one free right A-module. -/
+def splitProjection (he : e*e=e) : Aᵐᵒᵖ →ₗ[Aᵐᵒᵖ] rightIdeal e where
+  toFun a := ⟨e*a.unop, by change e*(e*a.unop)=e*a.unop; rw [← mul_assoc,he]⟩
+  map_add' a b := Subtype.ext (mul_add e a.unop b.unop)
+  map_smul' a b := by apply Subtype.ext; exact (mul_assoc e b.unop a.unop).symm
+
+def splitInclusion : rightIdeal e →ₗ[Aᵐᵒᵖ] Aᵐᵒᵖ where
+  toFun a := MulOpposite.op a.val
+  map_add' _ _ := rfl
+  map_smul' _ _ := rfl
+
+theorem rightIdeal_projective (he : e*e=e) : Module.Projective Aᵐᵒᵖ (rightIdeal e) := by
+  apply Module.Projective.of_split splitInclusion (splitProjection he)
+  ext a
+  exact a.property
+end LittleFinitistic.IdempotentTensor
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/FinitisticAsymmetry/Asymmetry.lean b/lean/OAI/Algebra/FinitisticAsymmetry/Asymmetry.lean
new file mode 100644
index 0000000000000000000000000000000000000000..15150c9ffe03434392759653137689b520ae0cdb
--- /dev/null
+++ b/lean/OAI/Algebra/FinitisticAsymmetry/Asymmetry.lean
@@ -0,0 +1,52 @@
+import Mathlib
+import OAI.Algebra.FinitisticAsymmetry.Transport.InjectiveGeneration
+import OAI.Algebra.FinitisticAsymmetry.Triangular.Generation
+import OAI.Algebra.FinitisticAsymmetry.Rickard.NonGeneration
+
+namespace OAI
+
+section
+noncomputable section
+open CategoryTheory
+namespace LittleFinitistic.AsymmetryConstruction
+universe u
+variable {k A ι : Type u} [Field k] [Ring A] [Algebra k A]
+  [FiniteDimensional k A] [Nontrivial A] [Fintype ι]
+variable (χ : Aᵐᵒᵖ →ₐ[k] (ι → k))
+abbrev Lambda := (CummingsConstruction.T χ)ᵐᵒᵖ
+
+lemma all_clauses
+    (hχ : Function.Surjective χ)
+    (hnil : ∃ n : ℕ, (RingHom.ker χ.toRingHom)^n = ⊥)
+    (hA : littleFinitisticDimension A = ⊤) :
+    FiniteDimensional k (Lambda χ) ∧
+      littleFinitisticDimension (Lambda χ) = ⊤ ∧
+      bigFinitisticDimension (Lambda χ) = ⊤ ∧
+      littleFinitisticDimension (Lambda χ)ᵐᵒᵖ = 0 ∧
+      bigFinitisticDimension (Lambda χ)ᵐᵒᵖ = 0 ∧
+      ¬ InjectivesGenerate (Lambda χ) ∧ InjectivesGenerate (Lambda χ)ᵐᵒᵖ := by
+  classical
+  let eA := ModuleCat.restrictScalarsEquivalenceOfRingEquiv (RingEquiv.opOp A)
+  have hinf : littleFinitisticDimension (Lambda χ) = ⊤ := by
+    apply top_unique
+    rw [← hA, ← littleFinitisticDimension_equivalence eA]
+    exact TriangularConstruction.right_little_lower_bound _ _ _
+  have hbig : bigFinitisticDimension (Lambda χ) = ⊤ :=
+    top_unique (hinf ▸ littleFinitisticDimension_le_big (Lambda χ))
+  let eT := ModuleCat.restrictScalarsEquivalenceOfRingEquiv
+    (RingEquiv.opOp (CummingsConstruction.T χ))
+  obtain ⟨hlz, hbz⟩ := CummingsConstruction.left_dimensions_zero χ hχ hnil
+  have hlz' : littleFinitisticDimension (Lambda χ)ᵐᵒᵖ = 0 :=
+    (littleFinitisticDimension_equivalence eT).trans hlz
+  have hbz' : bigFinitisticDimension (Lambda χ)ᵐᵒᵖ = 0 :=
+    (bigFinitisticDimension_equivalence eT).trans hbz
+  refine ⟨inferInstance, hinf, hbig, hlz', hbz', ?_, ?_⟩
+  · exact Rickard.not_injectivesGenerate_of_little_eq_top k hinf
+  · exact (injectivesGenerate_equivalence eT).mpr
+      (CummingsConstruction.injectivesGenerate χ hχ hnil)
+end LittleFinitistic.AsymmetryConstruction
+
+end
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/FinitisticAsymmetry/Augmentation/Directed.lean b/lean/OAI/Algebra/FinitisticAsymmetry/Augmentation/Directed.lean
new file mode 100644
index 0000000000000000000000000000000000000000..792ae1c81c4d3cc0df9713440b4b1eca69ff51c5
--- /dev/null
+++ b/lean/OAI/Algebra/FinitisticAsymmetry/Augmentation/Directed.lean
@@ -0,0 +1,135 @@
+import Mathlib
+import OAI.Algebra.Finitistic.Encoding.DirectedBound
+import OAI.Algebra.FinitisticAsymmetry.Model
+
+namespace OAI
+
+section
+noncomputable section
+open scoped BigOperators
+namespace LittleFinitistic.DirectedBound
+universe u
+
+namespace DirectedSystem
+variable {k A : Type u} [Field k] [Ring A] [Algebra k A] {n : ℕ}
+variable (D : DirectedSystem k A n)
+abbrev Vertices := {i : Fin n // D.e i ≠ 0}
+def coefficient (a : A) (i : D.Vertices) : k := (D.diagonal i a).choose
+lemma coefficient_spec (a : A) (i : D.Vertices) :
+    D.e i * a * D.e i = D.coefficient a i • D.e i := (D.diagonal i a).choose_spec
+lemma coefficient_eq_iff (a : A) (i : D.Vertices) (c : k) :
+    D.coefficient a i = c ↔ D.e i * a * D.e i = c • D.e i := by
+  rw [D.coefficient_spec]
+  exact (smul_left_injective k i.property).eq_iff.symm
+
+lemma corner_mul (a b : A) (i j : Fin n) :
+    D.e i * (a * b) * D.e j = ∑ l, (D.e i * a * D.e l) * (D.e l * b * D.e j) := by
+  conv_rhs => arg 2; ext l; rw [mul_assoc, ← mul_assoc (D.e l), ← mul_assoc (D.e l), D.idem]
+  simp only [← mul_assoc]
+  rw [← Finset.sum_mul, ← Finset.sum_mul, ← Finset.mul_sum, D.complete]
+  simp [mul_assoc]
+
+lemma diagonal_mul (a b : A) (i : Fin n) :
+    D.e i * (a * b) * D.e i = (D.e i * a * D.e i) * (D.e i * b * D.e i) := by
+  rw [D.corner_mul, Finset.sum_eq_single i]
+  · intro j _ hji
+    rcases lt_or_gt_of_ne hji with hji | hij
+    · rw [D.directed i j hji b, mul_zero]
+    · rw [D.directed j i hij a, zero_mul]
+  · simp
+
+def augmentation : A →ₐ[k] (D.Vertices → k) where
+  toFun := D.coefficient
+  map_zero' := by ext i; apply (D.coefficient_eq_iff _ _ _).mpr; simp
+  map_one' := by ext i; apply (D.coefficient_eq_iff _ _ _).mpr; simp [D.idem]
+  map_add' a b := by
+    ext i
+    apply (D.coefficient_eq_iff _ _ _).mpr
+    simp [mul_add, add_mul, D.coefficient_spec, add_smul]
+  map_mul' a b := by
+    ext i
+    apply (D.coefficient_eq_iff _ _ _).mpr
+    rw [D.diagonal_mul, D.coefficient_spec, D.coefficient_spec, smul_mul_smul_comm, D.idem]
+    rfl
+  commutes' c := by
+    ext i
+    apply (D.coefficient_eq_iff _ _ _).mpr
+    rw [← (Algebra.commutes c (D.e i)), ← Algebra.smul_def, smul_mul_assoc, D.idem]
+    rfl
+
+lemma coefficient_vertex (i j : D.Vertices) :
+    D.coefficient (D.e i) j = if j = i then 1 else 0 := by
+  classical
+  apply (D.coefficient_eq_iff _ _ _).mpr
+  split_ifs with h
+  · subst j; simp [D.idem]
+  · rw [D.orthogonal j i (fun hji => h (Subtype.ext hji))]
+    simp
+
+lemma augmentation_surjective : Function.Surjective D.augmentation := by
+  classical
+  intro s
+  refine ⟨∑ i : D.Vertices, s i • D.e i, ?_⟩
+  ext j
+  simp [map_sum, map_smul, augmentation, coefficient_vertex]
+
+lemma mem_augmentation_ker_iff (a : A) :
+    a ∈ RingHom.ker D.augmentation.toRingHom ↔ ∀ i : Fin n, D.e i * a * D.e i = 0 := by
+  constructor
+  · intro ha i
+    by_cases hi : D.e i = 0
+    · simp [hi]
+    · rw [D.coefficient_spec a ⟨i, hi⟩]
+      have := congrFun ha ⟨i, hi⟩
+      change D.coefficient a ⟨i, hi⟩ = 0 at this
+      rw [this, zero_smul]
+  · intro ha
+    change D.augmentation a = 0
+    ext i
+    apply (D.coefficient_eq_iff _ _ _).mpr
+    simpa using ha i
+
+lemma ker_corner_vanish {a : A} (ha : a ∈ RingHom.ker D.augmentation.toRingHom)
+    (i j : Fin n) (hij : i.val < j.val + 1) : D.e i * a * D.e j = 0 := by
+  by_cases h : i = j
+  · subst j; exact (D.mem_augmentation_ker_iff a).mp ha i
+  · exact D.directed j i (by have hne : i.val ≠ j.val := fun hval => h (Fin.ext hval); omega) a
+
+lemma pow_ker_corner_vanish (m : ℕ) {a : A}
+    (ha : a ∈ (RingHom.ker D.augmentation.toRingHom) ^ m)
+    (i j : Fin n) (hij : i.val < j.val + m) : D.e i * a * D.e j = 0 := by
+  induction m generalizing a i j with
+  | zero => exact D.directed j i (by simpa using hij) a
+  | succ m ih =>
+    rw [Submodule.pow_succ] at ha
+    refine Submodule.mul_induction_on ha ?_ ?_
+    · intro x hx y hy
+      rw [D.corner_mul]
+      apply Finset.sum_eq_zero
+      intro l _
+      by_cases hil : i.val < l.val + m
+      · rw [ih hx i l hil, zero_mul]
+      · rw [D.ker_corner_vanish hy l j (by omega), mul_zero]
+    · intro x y hx hy
+      simp [mul_add, add_mul, hx, hy]
+
+lemma augmentation_ker_nilpotent :
+    ∃ m : ℕ, (RingHom.ker D.augmentation.toRingHom) ^ m = ⊥ := by
+  refine ⟨n, le_bot_iff.mp ?_⟩
+  intro a ha
+  change a = 0
+  have he : (∑ i, D.e i) * a * (∑ j, D.e j) = 0 := by
+    simp only [Finset.sum_mul, Finset.mul_sum]
+    apply Finset.sum_eq_zero
+    intro j _
+    apply Finset.sum_eq_zero
+    intro i _
+    exact D.pow_ker_corner_vanish n ha i j (by omega)
+  simpa [D.complete] using he
+end DirectedSystem
+end LittleFinitistic.DirectedBound
+
+end
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/FinitisticAsymmetry/Augmentation/SplitBasic.lean b/lean/OAI/Algebra/FinitisticAsymmetry/Augmentation/SplitBasic.lean
new file mode 100644
index 0000000000000000000000000000000000000000..fa04e1f657c522d82c1fe1a473c1a5733949917e
--- /dev/null
+++ b/lean/OAI/Algebra/FinitisticAsymmetry/Augmentation/SplitBasic.lean
@@ -0,0 +1,138 @@
+import Mathlib
+import OAI.Algebra.FinitisticAsymmetry.Model
+
+namespace OAI
+
+section
+noncomputable section
+open scoped BigOperators
+namespace LittleFinitistic.SplitBasic
+universe v
+variable {k : Type v} [Field k]
+lemma pow_le_comap_pow {R S : Type*} [Ring R] [Ring S] (f : R →+* S)
+    (I : Ideal R) (J : Ideal S) (h : I ≤ J.comap f) (n : ℕ) : I ^ n ≤ (J ^ n).comap f := by
+  induction n with
+  | zero => simp [Submodule.pow_zero, Ideal.one_eq_top]
+  | succ n ih =>
+    rw [Submodule.pow_succ, Submodule.pow_succ]
+    apply Ideal.mul_le.mpr
+    intro x hx y hy
+    change f (x * y) ∈ J ^ n * J
+    rw [map_mul]
+    exact Ideal.mul_mem_mul (ih hx) (h hy)
+
+section SquareZero
+variable {R M : Type v} [Ring R] [Algebra k R] [AddCommGroup M]
+  [Module R M] [Module Rᵐᵒᵖ M] [SMulCommClass R Rᵐᵒᵖ M]
+  [Module k M] [IsScalarTower k R M] [IsScalarTower k Rᵐᵒᵖ M]
+variable {ι : Type v} (χ : R →ₐ[k] (ι → k))
+def squareZeroAugmentation : TrivSqZeroExt R M →ₐ[k] (ι → k) :=
+  χ.comp (TrivSqZeroExt.fstHom k R M)
+lemma squareZero_surjective (hχ : Function.Surjective χ) :
+    Function.Surjective (squareZeroAugmentation (M := M) χ) := by
+  intro s
+  obtain ⟨r, hr⟩ := hχ s
+  exact ⟨TrivSqZeroExt.inl r, hr⟩
+lemma squareZero_ker_nilpotent (hJ : ∃ n : ℕ, (RingHom.ker χ.toRingHom) ^ n = ⊥) :
+    ∃ n : ℕ, (RingHom.ker (squareZeroAugmentation (M := M) χ).toRingHom) ^ n = ⊥ := by
+  obtain ⟨n, hn⟩ := hJ
+  let f := (TrivSqZeroExt.fstHom k R M).toRingHom
+  let K := RingHom.ker (squareZeroAugmentation (M := M) χ).toRingHom
+  let J := RingHom.ker χ.toRingHom
+  let L := RingHom.ker f
+  have h : K ^ n ≤ L := by
+    have hp := pow_le_comap_pow f K J (by intro x hx; exact hx) n
+    rw [hn] at hp
+    exact hp
+  have hL : L * L = ⊥ := by
+    apply le_bot_iff.mp
+    apply Ideal.mul_le.mpr
+    intro x hx y hy
+    change x.fst = 0 at hx
+    change y.fst = 0 at hy
+    change x * y = 0
+    apply TrivSqZeroExt.ext <;> simp [TrivSqZeroExt.fst_mul, TrivSqZeroExt.snd_mul, hx, hy]
+  refine ⟨n + n, le_bot_iff.mp ?_⟩
+  rw [Ideal.IsTwoSided.pow_add]
+  exact (Ideal.mul_mono h h).trans hL.le
+end SquareZero
+
+section Product
+variable {R S ι κ : Type v} [Ring R] [Ring S] [Algebra k R] [Algebra k S]
+variable (χ : R →ₐ[k] (ι → k)) (ψ : S →ₐ[k] (κ → k))
+def productAugmentation : R × S →ₐ[k] (Sum ι κ → k) where
+  toFun x := Sum.elim (χ x.1) (ψ x.2)
+  map_one' := by ext i; cases i <;> simp
+  map_zero' := by ext i; cases i <;> simp
+  map_add' x y := by ext i; cases i <;> simp
+  map_mul' x y := by ext i; cases i <;> simp
+  commutes' r := by ext i; cases i <;> simp
+lemma product_surjective (hχ : Function.Surjective χ) (hψ : Function.Surjective ψ) :
+    Function.Surjective (productAugmentation χ ψ) := by
+  intro s
+  obtain ⟨r, hr⟩ := hχ (s ∘ Sum.inl)
+  obtain ⟨t, ht⟩ := hψ (s ∘ Sum.inr)
+  refine ⟨(r,t), ?_⟩
+  ext i
+  cases i <;> simp [productAugmentation, hr, ht]
+lemma product_ker_nilpotent
+    (hχ : ∃ n : ℕ, (RingHom.ker χ.toRingHom) ^ n = ⊥)
+    (hψ : ∃ n : ℕ, (RingHom.ker ψ.toRingHom) ^ n = ⊥) :
+    ∃ n : ℕ, (RingHom.ker (productAugmentation χ ψ).toRingHom) ^ n = ⊥ := by
+  obtain ⟨m, hm⟩ := hχ
+  obtain ⟨n, hn⟩ := hψ
+  let K := RingHom.ker (productAugmentation χ ψ).toRingHom
+  have h₁ := pow_le_comap_pow (RingHom.fst R S) K (RingHom.ker χ.toRingHom)
+    (by intro x hx; exact funext (fun i => congrFun hx (Sum.inl i))) m
+  have h₂ := pow_le_comap_pow (RingHom.snd R S) K (RingHom.ker ψ.toRingHom)
+    (by intro x hx; exact funext (fun i => congrFun hx (Sum.inr i))) n
+  rw [hm] at h₁
+  rw [hn] at h₂
+  refine ⟨m + n, le_bot_iff.mp ?_⟩
+  intro x hx
+  exact Prod.ext (h₁ (Ideal.pow_le_pow_right (by omega) hx))
+    (h₂ (Ideal.pow_le_pow_right (by omega) hx))
+end Product
+
+section Opposite
+variable {R ι : Type v} [Ring R] [Algebra k R] (χ : R →ₐ[k] (ι → k))
+def oppositeAugmentation : Rᵐᵒᵖ →ₐ[k] (ι → k) where
+  toFun x := χ x.unop
+  map_one' := χ.map_one
+  map_zero' := χ.map_zero
+  map_add' x y := χ.map_add _ _
+  map_mul' x y := by simp [map_mul, mul_comm]
+  commutes' r := χ.commutes r
+lemma opposite_surjective (hχ : Function.Surjective χ) :
+    Function.Surjective (oppositeAugmentation χ) := by
+  intro s
+  obtain ⟨r, hr⟩ := hχ s
+  exact ⟨MulOpposite.op r, hr⟩
+lemma unop_mem_pow_ker (n : ℕ) {x : Rᵐᵒᵖ}
+    (hx : x ∈ (RingHom.ker (oppositeAugmentation χ).toRingHom) ^ n) :
+    x.unop ∈ (RingHom.ker χ.toRingHom) ^ n := by
+  induction n generalizing x with
+  | zero => simp [Submodule.pow_zero, Ideal.one_eq_top]
+  | succ n ih =>
+    rw [Submodule.pow_succ] at hx
+    rw [Ideal.IsTwoSided.pow_succ]
+    refine Submodule.mul_induction_on hx ?_ ?_
+    · intro y hy z hz
+      exact Ideal.mul_mem_mul hz (ih hy)
+    · intro y z hy hz
+      exact add_mem hy hz
+lemma opposite_ker_nilpotent (hχ : ∃ n : ℕ, (RingHom.ker χ.toRingHom) ^ n = ⊥) :
+    ∃ n : ℕ, (RingHom.ker (oppositeAugmentation χ).toRingHom) ^ n = ⊥ := by
+  obtain ⟨n, hn⟩ := hχ
+  refine ⟨n, le_bot_iff.mp ?_⟩
+  intro x hx
+  have h := unop_mem_pow_ker χ n hx
+  rw [hn] at h
+  exact MulOpposite.unop_injective h
+end Opposite
+end LittleFinitistic.SplitBasic
+
+end
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/FinitisticAsymmetry/Derived/BoundedGeneration.lean b/lean/OAI/Algebra/FinitisticAsymmetry/Derived/BoundedGeneration.lean
new file mode 100644
index 0000000000000000000000000000000000000000..7a7115fbf63b552aa0e092ef6372c11ec830c8e0
--- /dev/null
+++ b/lean/OAI/Algebra/FinitisticAsymmetry/Derived/BoundedGeneration.lean
@@ -0,0 +1,138 @@
+import Mathlib
+import OAI.Algebra.FinitisticAsymmetry.Derived.Telescopes
+import OAI.Algebra.FinitisticAsymmetry.Derived.Truncations
+
+namespace OAI
+
+noncomputable section
+
+open CategoryTheory CategoryTheory.Limits
+open HomologicalComplex
+
+open CategoryTheory CategoryTheory.Limits HomologicalComplex
+namespace LittleFinitistic.DerivedSupport
+
+section
+universe v w
+variable {C : Type v} [Category.{w} C]
+
+def eventuallyIsoCoconeIsColimit {F : ℕ ⥤ C} (c : Cocone F) (N : ℕ)
+    (h : ∀ n, N ≤ n → IsIso (c.ι.app n)) : IsColimit c := by
+  have := h N le_rfl
+  refine { desc := fun s => inv (c.ι.app N) ≫ s.ι.app N, fac := ?_, uniq := ?_ }
+  · intro s n
+    let m := max n N
+    have hm : N ≤ m := le_max_right _ _
+    have := h m hm
+    have he : inv (c.ι.app N) ≫ s.ι.app N = inv (c.ι.app m) ≫ s.ι.app m := by
+      apply (cancel_epi (c.ι.app N)).1
+      rw [IsIso.hom_inv_id_assoc, ← c.w (homOfLE hm)]
+      simp only [Category.assoc, IsIso.hom_inv_id_assoc, s.w]
+    rw [he, ← c.w (homOfLE (le_max_left n N))]
+    simp only [m, Category.assoc, IsIso.hom_inv_id_assoc, s.w]
+  · intro s m hm
+    apply (cancel_epi (c.ι.app N)).1
+    rw [IsIso.hom_inv_id_assoc, hm]
+
+end
+
+section
+universe u
+variable {R : Type u} [Ring R]
+variable (K : CochainComplex (ModuleCat.{u} R) ℤ)
+
+def cutSequenceMap (n : ℕ) : cut K (-(n : ℤ)) ⟶ cut K (-(n+1 : ℤ)) :=
+  cutMap K (by omega)
+
+def cutSequenceCocone : Cocone (Functor.ofSequence (cutSequenceMap K)) where
+  pt := K
+  ι := NatTrans.ofSequence (fun n => cutι K (-(n : ℤ))) (fun n => by
+    simp [cutSequenceMap]
+    exact (cutMap_ι K _).trans (Category.comp_id _).symm)
+
+def cutSequenceIsColimit : IsColimit (cutSequenceCocone K) := by
+  apply HomologicalComplex.isColimitOfEval
+  intro j
+  apply eventuallyIsoCoconeIsColimit _ (-j).toNat
+  intro n hn
+  change IsIso ((cutι K (-(n : ℤ))).f j)
+  exact cutι_f_isIso K _ _ (by omega)
+
+end
+
+section
+universe u w
+variable {R : Type u} [Ring R]
+variable (K : CochainComplex (ModuleCat.{u} R) ℤ) (b : ℤ)
+  (hK : ∀ j, b < j → IsZero (K.X j))
+
+include hK in
+lemma cut_isZero_of_upperBound (a : ℤ) (ha : b < a) : IsZero (cut K a) := by
+  rw [IsZero.iff_id_eq_zero]
+  apply HomologicalComplex.Hom.ext
+  funext j
+  have hz : IsZero ((cut K a).X j) := by
+    by_cases h : a ≤ j
+    · have := cutι_f_isIso K a j h
+      exact (hK j (lt_of_lt_of_le ha h)).of_iso (asIso ((cutι K a).f j))
+    · exact cut_isZero_X K a j (by omega)
+  exact hz.eq_of_src _ _
+
+variable [HasDerivedCategory.{w} (ModuleCat.{u} R)]
+
+include b hK in
+lemma prop_cut_of_terms (P : ObjectProperty (DerivedCategory (ModuleCat.{u} R)))
+    [P.IsTriangulated] [P.IsClosedUnderIsomorphisms]
+    (hterms : ∀ j, P (DerivedCategory.Q.obj
+      ((HomologicalComplex.single (ModuleCat R) (ComplexShape.up ℤ) j).obj (K.X j))))
+    (a : ℤ) : P (DerivedCategory.Q.obj (cut K a)) := by
+  have step (a : ℤ) (ha : P (DerivedCategory.Q.obj (cut K (a+1)))) :
+      P (DerivedCategory.Q.obj (cut K a)) :=
+    P.ext_of_isTriangulatedClosed₂ _
+      (DerivedCategory.triangleOfSES_distinguished (cut_shortExact K a)) ha (hterms a)
+  have h (n : ℕ) : P (DerivedCategory.Q.obj (cut K (b+1-(n : ℤ)))) := by
+    induction n with
+    | zero =>
+      exact P.prop_of_isZero (DerivedCategory.Q.map_isZero
+        (cut_isZero_of_upperBound K b hK _ (by omega)))
+    | succ n ih =>
+      apply step
+      convert ih using 1
+      congr 2
+      omega
+  by_cases ha : a ≤ b+1
+  · have he : b+1-((b+1-a).toNat : ℤ) = a := by omega
+    simpa only [he] using h ((b+1-a).toNat)
+  · exact P.prop_of_isZero (DerivedCategory.Q.map_isZero
+      (cut_isZero_of_upperBound K b hK a (by omega)))
+
+end
+
+universe u w
+variable {R : Type u} [Ring R] [HasDerivedCategory.{w} (ModuleCat.{u} R)]
+variable (P : ObjectProperty (DerivedCategory (ModuleCat.{u} R)))
+  [P.IsTriangulated] [P.IsClosedUnderIsomorphisms]
+  [P.IsClosedUnderColimitsOfShape (Discrete ℕ)]
+
+omit [P.IsClosedUnderColimitsOfShape (Discrete ℕ)] in
+lemma prop_single_of_zero (M : ModuleCat R)
+    (hM : P ((DerivedCategory.singleFunctor (ModuleCat R) 0).obj M)) (j : ℤ) :
+    P (DerivedCategory.Q.obj
+      ((HomologicalComplex.single (ModuleCat R) (ComplexShape.up ℤ) j).obj M)) := by
+  apply P.prop_of_iso ((DerivedCategory.singleFunctorIsoCompQ (ModuleCat R) j).app M)
+  apply P.prop_of_iso (((DerivedCategory.singleFunctors (ModuleCat R)).shiftIso (-j) j 0 (by omega)).app M)
+  exact P.le_shift (-j) _ hM
+
+lemma prop_of_boundedAbove_terms (K : CochainComplex (ModuleCat R) ℤ)
+    (b : ℤ) (hb : ∀ j, b < j → IsZero (K.X j))
+    (hterms : ∀ j, P ((DerivedCategory.singleFunctor (ModuleCat R) 0).obj (K.X j))) :
+    P (DerivedCategory.Q.obj K) := by
+  exact localizing_sequence_colimit (fun n => cut K (-(n : ℤ))) (cutSequenceMap K)
+    (cutSequenceCocone K) (cutSequenceIsColimit K) P
+    (fun n => prop_cut_of_terms K b hb P (fun j => prop_single_of_zero P _ (hterms j) j) _)
+
+end LittleFinitistic.DerivedSupport
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/FinitisticAsymmetry/Derived/ComplexSums.lean b/lean/OAI/Algebra/FinitisticAsymmetry/Derived/ComplexSums.lean
new file mode 100644
index 0000000000000000000000000000000000000000..4c4b48b8aac943d592b4ff291edb28a98c865bf6
--- /dev/null
+++ b/lean/OAI/Algebra/FinitisticAsymmetry/Derived/ComplexSums.lean
@@ -0,0 +1,110 @@
+import Mathlib
+import OAI.Algebra.FinitisticAsymmetry.Derived.Coproducts
+
+namespace OAI
+
+noncomputable section
+
+open CategoryTheory CategoryTheory.Limits
+open HomologicalComplex
+namespace LittleFinitistic.DerivedSupport
+universe u v w t
+variable {C : Type u} [Category.{v} C] [Abelian C]
+variable {ι : Type t} {c : ComplexShape ι} {I : Type w}
+variable [HasColimitsOfShape (Discrete I) C]
+
+def bundleComplex (K : I → HomologicalComplex C c) :
+    HomologicalComplex (Discrete I ⥤ C) c where
+  X j := Discrete.functor (fun i => (K i).X j)
+  d j l := Discrete.natTrans (fun i => (K i.as).d j l)
+  shape j l hjl := by ext i; exact (K i.as).shape _ _ hjl
+  d_comp_d' i j l _ _ := by ext a; exact (K a.as).d_comp_d i j l
+
+def bundleComplexMap {K L : I → HomologicalComplex C c} (f : ∀ i, K i ⟶ L i) :
+    bundleComplex K ⟶ bundleComplex L where
+  f j := Discrete.natTrans (fun i => (f i.as).f j)
+  comm' j l _ := by ext i; exact (f i.as).comm _ _
+
+def sumComplex (K : I → HomologicalComplex C c) : HomologicalComplex C c :=
+  (colim.mapHomologicalComplex c).obj (bundleComplex K)
+
+def sumComplexMap {K L : I → HomologicalComplex C c} (f : ∀ i, K i ⟶ L i) :
+    sumComplex K ⟶ sumComplex L := (colim.mapHomologicalComplex c).map (bundleComplexMap f)
+
+def sumComplexInj (K : I → HomologicalComplex C c) (i : I) : K i ⟶ sumComplex K where
+  f j := Sigma.ι (fun i => (K i).X j) i
+  comm' j l _ := by
+    exact colimit.ι_map ((bundleComplex K).d j l) (Discrete.mk i)
+
+@[reassoc] lemma sumComplexInj_map {K L : I → HomologicalComplex C c}
+    (f : ∀ i, K i ⟶ L i) (i : I) :
+    sumComplexInj K i ≫ sumComplexMap f = f i ≫ sumComplexInj L i := by
+  ext j
+  exact colimit.ι_map ((bundleComplexMap f).f j) (Discrete.mk i)
+
+def sumComplexCofan (K : I → HomologicalComplex C c) : Cofan K :=
+  Cofan.mk (sumComplex K) (sumComplexInj K)
+
+def sumComplexIsColimit (K : I → HomologicalComplex C c) : IsColimit (sumComplexCofan K) :=
+  HomologicalComplex.isColimitOfEval _ _ (fun j =>
+    (Cofan.isColimitMapCoconeEquiv (eval C c j) K (sumComplexCofan K)).symm
+      (colimit.isColimit (Discrete.functor (fun i => (K i).X j))))
+
+lemma sumComplexMap_quasiIso [HasExactColimitsOfShape (Discrete I) C]
+    {K L : I → HomologicalComplex C c} (f : ∀ i, K i ⟶ L i) [∀ i, QuasiIso (f i)] :
+    QuasiIso (sumComplexMap f) := by
+  have : QuasiIso (bundleComplexMap f) := by
+    rw [HomologicalComplex.quasiIso_iff_evaluation]
+    intro i
+    change QuasiIso (f i.as)
+    infer_instance
+  exact inferInstanceAs (QuasiIso ((colim.mapHomologicalComplex c).map (bundleComplexMap f)))
+
+def homotopySumCofan (X : I → HomotopyCategory C c) : Cofan X :=
+  Cofan.mk ((HomotopyCategory.quotient C c).obj (sumComplex (fun i => (X i).as)))
+    (fun i => (HomotopyCategory.quotient C c).map (sumComplexInj (fun j => (X j).as) i))
+
+def homotopySumIsColimit (X : I → HomotopyCategory C c) :
+    IsColimit (homotopySumCofan X) :=
+  quotientCofanIsColimit _ (sumComplexIsColimit (fun i => (X i).as))
+
+instance homotopyHasCoproducts : HasColimitsOfShape (Discrete I) (HomotopyCategory C c) where
+  has_colimit F := by
+    let X (i : I) := F.obj ⟨i⟩
+    let : HasColimit (Discrete.functor X) := ⟨_, homotopySumIsColimit X⟩
+    exact hasColimit_of_iso (F := Discrete.functor X)
+      (Discrete.natIso (fun i => Iso.refl (F.obj i)))
+
+instance homotopyQuasiIsoCoproducts [HasExactColimitsOfShape (Discrete I) C] :
+    (HomotopyCategory.quasiIso C c).IsStableUnderCoproductsOfShape I := by
+  apply MorphismProperty.IsStableUnderCoproductsOfShape.mk
+  intro X Y _ _ f hf
+  let Q := HomotopyCategory.quotient C c
+  let a := (colimit.isColimit (Discrete.functor X)).coconePointUniqueUpToIso (homotopySumIsColimit X)
+  let b := (colimit.isColimit (Discrete.functor Y)).coconePointUniqueUpToIso (homotopySumIsColimit Y)
+  have hq (i : I) : QuasiIso (f i).out := by
+    rw [← HomologicalComplex.mem_quasiIso_iff, ← HomotopyCategory.quotient_map_mem_quasiIso_iff,
+      HomotopyCategory.quotient_map_out]
+    exact hf i
+  have h : HomotopyCategory.quasiIso C c (Q.map (sumComplexMap (fun i => (f i).out))) := by
+    rw [HomotopyCategory.quotient_map_mem_quasiIso_iff]
+    exact sumComplexMap_quasiIso _
+  refine ((HomotopyCategory.quasiIso C c).arrow_mk_iso_iff ?_).2 h
+  refine Arrow.isoMk a b ?_
+  apply Sigma.hom_ext
+  intro i
+  have ha : Sigma.ι X i ≫ a.hom = Q.map (sumComplexInj (fun j => (X j).as) i) :=
+    IsColimit.comp_coconePointUniqueUpToIso_hom _ _ (Discrete.mk i)
+  have hb : Sigma.ι Y i ≫ b.hom = Q.map (sumComplexInj (fun j => (Y j).as) i) :=
+    IsColimit.comp_coconePointUniqueUpToIso_hom _ _ (Discrete.mk i)
+  change Sigma.ι X i ≫ a.hom ≫ Q.map (sumComplexMap (fun i => (f i).out)) =
+    Sigma.ι X i ≫ Limits.Sigma.map f ≫ b.hom
+  erw [Sigma.ι_map_assoc, hb, ← Category.assoc, ha, ← Q.map_comp, sumComplexInj_map,
+    Q.map_comp, HomotopyCategory.quotient_map_out]
+  rfl
+
+end LittleFinitistic.DerivedSupport
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/FinitisticAsymmetry/Derived/Coproducts.lean b/lean/OAI/Algebra/FinitisticAsymmetry/Derived/Coproducts.lean
new file mode 100644
index 0000000000000000000000000000000000000000..438308c2d8bc96345e53ff33af46a80029be3ac6
--- /dev/null
+++ b/lean/OAI/Algebra/FinitisticAsymmetry/Derived/Coproducts.lean
@@ -0,0 +1,183 @@
+import Mathlib
+import OAI.Algebra.FinitisticAsymmetry.Model
+
+namespace OAI
+
+noncomputable section
+
+open CategoryTheory CategoryTheory.Limits
+open HomologicalComplex
+namespace LittleFinitistic.DerivedSupport
+
+section
+universe u v w t
+variable {C : Type u} [Category.{v} C] [Preadditive C]
+variable {ι : Type t} {c : ComplexShape ι} {I : Type w}
+variable {K : I → HomologicalComplex C c}
+
+def cofanEvalIsColimit (s : Cofan K) (hs : IsColimit s)
+    [HasColimitsOfShape (Discrete I) C] (j : ι) :
+    IsColimit (Cofan.mk (s.pt.X j) (fun i => (s.inj i).f j)) :=
+  (Cofan.isColimitMapCoconeEquiv (eval C c j) K s)
+    (isColimitOfPreserves (eval C c j) hs)
+
+def homotopyCofanDesc (s : Cofan K) (hs : IsColimit s)
+    [HasColimitsOfShape (Discrete I) C] {Y : HomologicalComplex C c}
+    (f g : s.pt ⟶ Y) (h : ∀ i, Homotopy (s.inj i ≫ f) (s.inj i ≫ g)) : Homotopy f g where
+  hom j l := (cofanEvalIsColimit s hs j).desc (Cofan.mk _ fun i => (h i).hom j l)
+  zero j l hrel := by
+    apply (cofanEvalIsColimit s hs j).hom_ext
+    intro i
+    simp only [comp_zero]
+    change (s.inj i.as).f j ≫ _ = 0
+    rw [show (s.inj i.as).f j ≫ (cofanEvalIsColimit s hs j).desc
+      (Cofan.mk _ fun i => (h i).hom j l) = (h i.as).hom j l from
+        (cofanEvalIsColimit s hs j).fac _ i]
+    exact (h i.as).zero j l hrel
+  comm j := by
+    apply (cofanEvalIsColimit s hs j).hom_ext
+    intro i
+    have hh := (h i.as).comm j
+    dsimp only [HomologicalComplex.comp_f] at hh
+    have fac (a b : ι) : (s.inj i.as).f a ≫
+        (cofanEvalIsColimit s hs a).desc (Cofan.mk _ fun i => (h i).hom a b) =
+          (h i.as).hom a b := (cofanEvalIsColimit s hs a).fac _ i
+    let a : s.pt.X (c.next j) ⟶ Y.X j :=
+      (cofanEvalIsColimit s hs (c.next j)).desc (Cofan.mk _ fun i => (h i).hom (c.next j) j)
+    let b : s.pt.X j ⟶ Y.X (c.prev j) :=
+      (cofanEvalIsColimit s hs j).desc (Cofan.mk _ fun i => (h i).hom j (c.prev j))
+    change (s.inj i.as).f j ≫ f.f j = (s.inj i.as).f j ≫
+      (s.pt.d j (c.next j) ≫ a + b ≫ Y.d (c.prev j) j + g.f j)
+    dsimp only [a, b]
+    rw [Preadditive.comp_add, Preadditive.comp_add,
+      (s.inj i.as).comm_assoc, fac, ← Category.assoc, fac]
+    exact hh
+
+def quotientCofanIsColimit (s : Cofan K) (hs : IsColimit s)
+    [HasColimitsOfShape (Discrete I) C] :
+    IsColimit (Cofan.mk ((HomotopyCategory.quotient C c).obj s.pt)
+      (fun i => (HomotopyCategory.quotient C c).map (s.inj i))) := by
+  let Q := HomotopyCategory.quotient C c
+  refine Cofan.IsColimit.mk _
+    (fun t => Q.map (hs.desc (Cofan.mk t.pt.as (fun i => (t.inj i).out)))) ?_ ?_
+  · intro t i
+    change Q.map (s.inj i) ≫ Q.map _ = _
+    rw [← Q.map_comp, Cofan.IsColimit.inj_desc]
+    exact HomotopyCategory.quotient_map_out _
+  · intro t m hm
+    obtain ⟨m, rfl⟩ := Q.map_surjective m
+    apply HomotopyCategory.eq_of_homotopy
+    apply homotopyCofanDesc s hs
+    intro i
+    apply HomotopyCategory.homotopyOfEq
+    change ∀ i, Q.map (s.inj i) ≫ Q.map m = t.inj i at hm
+    rw [Q.map_comp, hm, Cofan.IsColimit.inj_desc]
+    exact (HomotopyCategory.quotient_map_out _).symm
+
+end
+
+open CategoryTheory.MorphismProperty
+universe u₁ u₂ v₁ v₂ w
+variable {C : Type u₁} [Category.{v₁} C] [Preadditive C]
+  {D : Type u₂} [Category.{v₂} D] [Preadditive D]
+variable (W : MorphismProperty C) (F : C ⥤ D) [F.IsLocalization W] [F.Additive]
+variable [W.HasRightCalculusOfFractions] {I : Type w}
+  [HasColimitsOfShape (Discrete I) C] [W.IsStableUnderCoproductsOfShape I]
+
+omit [Preadditive C] [W.HasRightCalculusOfFractions] in
+lemma cofan_desc_mem {X Y : I → C} (s : Cofan Y) (hs : IsColimit s)
+    (f : ∀ i, X i ⟶ Y i) (hf : ∀ i, W (f i)) :
+    W (Sigma.desc (fun i => f i ≫ s.inj i)) := by
+  exact IsStableUnderColimitsOfShape.condition _ _ _ _
+    (colimit.isColimit (Discrete.functor X)) hs
+    (Discrete.natTrans fun i => f i.as) (fun i => hf i.as) _
+    (fun i => by
+      change Sigma.ι X i.as ≫ _ = f i.as ≫ s.inj i.as
+      exact Sigma.ι_comp_desc _ _)
+
+include W
+
+lemma localizationCofan_zero {X : I → C} (s : Cofan X) (hs : IsColimit s)
+    {Y : C} (d : F.obj s.pt ⟶ F.obj Y)
+    (hd : ∀ i, F.map (s.inj i) ≫ d = 0) : d = 0 := by
+  obtain ⟨φ, hφ⟩ := Localization.exists_rightFraction F W d
+  let ρ (i : I) : W.RightFraction (X i) φ.X' :=
+    (LeftFraction.mk (s.inj i) φ.s φ.hs).rightFraction
+  have hρ (i : I) : (ρ i).s ≫ s.inj i = (ρ i).f ≫ φ.s :=
+    (LeftFraction.mk (s.inj i) φ.s φ.hs).rightFraction_fac
+  have hz (i : I) : F.map ((ρ i).f ≫ φ.f) = F.map (0 : (ρ i).X' ⟶ Y) := by
+    have hr := congrArg (fun f => F.map (ρ i).s ≫ f) (hd i)
+    rw [hφ] at hr
+    simpa only [RightFraction.map, comp_zero, ← F.map_comp_assoc, hρ,
+      F.map_comp, Category.assoc, IsIso.hom_inv_id_assoc, F.map_zero] using hr
+  have hex (i : I) := (W.map_eq_iff_precomp F ((ρ i).f ≫ φ.f) 0).mp (hz i)
+  choose Z t ht htf using hex
+  let q : (∐ Z) ⟶ φ.X' := Sigma.desc (fun i => t i ≫ (ρ i).f)
+  have hq : W (q ≫ φ.s) := by
+    have eq : q ≫ φ.s = Sigma.desc (fun i => (t i ≫ (ρ i).s) ≫ s.inj i) := by
+      apply Sigma.hom_ext
+      intro i
+      simp only [q, Sigma.ι_comp_desc_assoc, Sigma.ι_comp_desc, Category.assoc, hρ]
+    rw [eq]
+    exact cofan_desc_mem W s hs _ (fun i => W.comp_mem _ _ (ht i) (ρ i).hs)
+  have hqf : q ≫ φ.f = 0 := by
+    apply Sigma.hom_ext
+    intro i
+    simpa only [q, Sigma.ι_comp_desc_assoc, comp_zero, Category.assoc] using htf i
+  let : IsIso (F.map (q ≫ φ.s)) := Localization.inverts F W _ hq
+  apply (cancel_epi (F.map (q ≫ φ.s))).mp
+  rw [comp_zero, F.map_comp, hφ]
+  let : IsIso (F.map φ.s) := Localization.inverts F W _ φ.hs
+  simp only [RightFraction.map, Category.assoc]
+  rw [IsIso.hom_inv_id_assoc, ← F.map_comp, hqf, F.map_zero]
+
+lemma localizationCofan_hom_ext {X : I → C} (s : Cofan X) (hs : IsColimit s)
+    {Y : C} (f g : F.obj s.pt ⟶ F.obj Y)
+    (h : ∀ i, F.map (s.inj i) ≫ f = F.map (s.inj i) ≫ g) : f = g := by
+  apply sub_eq_zero.mp
+  exact localizationCofan_zero W F s hs (f - g) (fun i => by simp [Preadditive.comp_sub, h i])
+
+omit [Preadditive C] [Preadditive D] [F.Additive] in
+lemma localizationCofan_lift {X : I → C} (s : Cofan X) (hs : IsColimit s)
+    {Y : C} (f : ∀ i, F.obj (X i) ⟶ F.obj Y) :
+    ∃ g : F.obj s.pt ⟶ F.obj Y, ∀ i, F.map (s.inj i) ≫ g = f i := by
+  choose φ hφ using fun i => Localization.exists_rightFraction F W (f i)
+  let q : (∐ fun i => (φ i).X') ⟶ s.pt := Sigma.desc (fun i => (φ i).s ≫ s.inj i)
+  have hq : W q := cofan_desc_mem W s hs _ (fun i => (φ i).hs)
+  let : IsIso (F.map q) := Localization.inverts F W _ hq
+  let p : (∐ fun i => (φ i).X') ⟶ Y := Sigma.desc (fun i => (φ i).f)
+  refine ⟨inv (F.map q) ≫ F.map p, ?_⟩
+  intro i
+  apply (cancel_epi (F.map (φ i).s)).mp
+  have he : F.map (φ i).s ≫ F.map (s.inj i) =
+      F.map (Sigma.ι (fun i => (φ i).X') i) ≫ F.map q := by
+    simp only [← F.map_comp, q, Sigma.ι_comp_desc]
+  rw [← Category.assoc, he, Category.assoc, IsIso.hom_inv_id_assoc,
+    ← F.map_comp,
+    show Sigma.ι (fun i => (φ i).X') i ≫ p = (φ i).f from Sigma.ι_comp_desc _ _, hφ]
+  simp only [RightFraction.map, IsIso.hom_inv_id_assoc]
+
+def localizationCofanIsColimit {X : I → C} (s : Cofan X) (hs : IsColimit s) :
+    IsColimit (Cofan.mk (F.obj s.pt) (fun i => F.map (s.inj i))) := by
+  letI : F.EssSurj := Localization.essSurj F W
+  let lift (t : Cofan (fun i => F.obj (X i))) : F.obj s.pt ⟶ t.pt :=
+    (localizationCofan_lift W F s hs (fun i => t.inj i ≫ (F.objObjPreimageIso t.pt).inv)).choose ≫
+      (F.objObjPreimageIso t.pt).hom
+  have fac (t : Cofan (fun i => F.obj (X i))) (i : I) :
+      F.map (s.inj i) ≫ lift t = t.inj i := by
+    dsimp only [lift]
+    rw [← Category.assoc, (localizationCofan_lift W F s hs _).choose_spec i]
+    simp
+  refine Cofan.IsColimit.mk _ lift fac ?_
+  intro t m hm
+  apply (cancel_mono (F.objObjPreimageIso t.pt).inv).mp
+  apply localizationCofan_hom_ext W F s hs
+  intro i
+  rw [← Category.assoc, ← Category.assoc, fac]
+  exact congrArg (fun f => f ≫ (F.objObjPreimageIso t.pt).inv) (hm i)
+
+end LittleFinitistic.DerivedSupport
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/FinitisticAsymmetry/Derived/DerivedSums.lean b/lean/OAI/Algebra/FinitisticAsymmetry/Derived/DerivedSums.lean
new file mode 100644
index 0000000000000000000000000000000000000000..23af0ccd75773fa5f91f94dcf37053fe00d19e95
--- /dev/null
+++ b/lean/OAI/Algebra/FinitisticAsymmetry/Derived/DerivedSums.lean
@@ -0,0 +1,102 @@
+import Mathlib
+import OAI.Algebra.FinitisticAsymmetry.Derived.ComplexSums
+
+namespace OAI
+
+noncomputable section
+
+open CategoryTheory CategoryTheory.Limits
+open HomologicalComplex
+namespace LittleFinitistic.DerivedSupport
+universe u v w z
+variable {C : Type u} [Category.{v} C] [Abelian C] [HasDerivedCategory.{z} C]
+variable {I : Type w} [HasColimitsOfShape (Discrete I) C]
+  [HasExactColimitsOfShape (Discrete I) C]
+
+def derivedHomotopyCofanIsColimit {X : I → HomotopyCategory C (ComplexShape.up ℤ)}
+    (s : Cofan X) (hs : IsColimit s) :
+    IsColimit (Cofan.mk (DerivedCategory.Qh.obj s.pt)
+      (fun i => DerivedCategory.Qh.map (s.inj i))) :=
+  localizationCofanIsColimit (HomotopyCategory.quasiIso C (ComplexShape.up ℤ))
+    DerivedCategory.Qh s hs
+
+def derivedCofanIsColimit {X : I → CochainComplex C ℤ} (s : Cofan X) (hs : IsColimit s) :
+    IsColimit (Cofan.mk (DerivedCategory.Q.obj s.pt)
+      (fun i => DerivedCategory.Q.map (s.inj i))) := by
+  let h := derivedHomotopyCofanIsColimit _ (quotientCofanIsColimit s hs)
+  let e := DerivedCategory.quotientCompQhIso C
+  refine Cofan.IsColimit.mk _ (fun t =>
+    (e.app s.pt).inv ≫ h.desc (Cofan.mk t.pt (fun i => (e.app (X i)).hom ≫ t.inj i))) ?_ ?_
+  · intro t i
+    change DerivedCategory.Q.map (s.inj i) ≫ (e.app s.pt).inv ≫
+      h.desc (Cofan.mk t.pt (fun i => (e.app (X i)).hom ≫ t.inj i)) = t.inj i
+    have hn : DerivedCategory.Q.map (s.inj i) ≫ (e.app s.pt).inv =
+        (e.app (X i)).inv ≫ DerivedCategory.Qh.map
+          ((HomotopyCategory.quotient C (ComplexShape.up ℤ)).map (s.inj i)) :=
+      e.inv.naturality (s.inj i)
+    have hf : DerivedCategory.Qh.map
+        ((HomotopyCategory.quotient C (ComplexShape.up ℤ)).map (s.inj i)) ≫
+        h.desc (Cofan.mk t.pt (fun j => (e.app (X j)).hom ≫ t.inj j)) =
+        (e.app (X i)).hom ≫ t.inj i := h.fac _ (Discrete.mk i)
+    rw [← Category.assoc, hn, Category.assoc, hf]
+    exact Iso.inv_hom_id_assoc _ _
+  · intro t m hm
+    apply (cancel_epi (e.app s.pt).hom).mp
+    simp only [Iso.hom_inv_id_assoc]
+    apply h.hom_ext
+    intro i
+    change DerivedCategory.Qh.map ((HomotopyCategory.quotient C (ComplexShape.up ℤ)).map
+      (s.inj i.as)) ≫ _ = _
+    rw [IsColimit.fac]
+    change DerivedCategory.Qh.map ((HomotopyCategory.quotient C (ComplexShape.up ℤ)).map
+      (s.inj i.as)) ≫ (e.app s.pt).hom ≫ m = (e.app (X i.as)).hom ≫ t.inj i.as
+    have hn : DerivedCategory.Qh.map ((HomotopyCategory.quotient C (ComplexShape.up ℤ)).map
+        (s.inj i.as)) ≫ (e.app s.pt).hom =
+        (e.app (X i.as)).hom ≫ DerivedCategory.Q.map (s.inj i.as) :=
+      e.hom.naturality (s.inj i.as)
+    change ∀ i, DerivedCategory.Q.map (s.inj i) ≫ m = t.inj i at hm
+    rw [← Category.assoc, hn, Category.assoc, hm]
+
+def derivedSumIsColimit (X : I → CochainComplex C ℤ) :=
+  derivedCofanIsColimit _ (sumComplexIsColimit X)
+
+lemma prop_derived_sum (P : ObjectProperty (DerivedCategory C))
+    [P.IsClosedUnderColimitsOfShape (Discrete I)] (X : I → CochainComplex C ℤ)
+    (hX : ∀ i, P (DerivedCategory.Q.obj (X i))) : P (DerivedCategory.Q.obj (sumComplex X)) :=
+  P.prop_of_isColimit (derivedSumIsColimit X) (fun i => hX i.as)
+
+instance derivedHasCoproducts : HasColimitsOfShape (Discrete I) (DerivedCategory C) where
+  has_colimit G := by
+    let F := DerivedCategory.Qh (C := C)
+    let : F.EssSurj := Localization.essSurj F (HomotopyCategory.quasiIso C (ComplexShape.up ℤ))
+    let X (i : I) := F.objPreimage (G.obj ⟨i⟩)
+    let e (i : I) := F.objObjPreimageIso (G.obj ⟨i⟩)
+    let s : Cofan (fun i => F.obj (X i)) :=
+      Cofan.mk (F.obj (∐ X)) (fun i => F.map (Sigma.ι X i))
+    let h : IsColimit s := derivedHomotopyCofanIsColimit _ (colimit.isColimit _)
+    let t : Cofan (fun i => G.obj ⟨i⟩) :=
+      Cofan.mk s.pt (fun i => (e i).inv ≫ s.inj i)
+    have ht : IsColimit t := by
+      refine Cofan.IsColimit.mk _ (fun z => h.desc (Cofan.mk z.pt
+        (fun i => (e i).hom ≫ z.inj i))) ?_ ?_
+      · intro z i
+        change ((e i).inv ≫ s.inj i) ≫ _ = _
+        rw [Category.assoc, Cofan.IsColimit.inj_desc]
+        exact Iso.inv_hom_id_assoc _ _
+      · intro z m hm
+        apply h.hom_ext
+        intro i
+        rw [IsColimit.fac]
+        change s.inj i.as ≫ m = (e i.as).hom ≫ z.inj i.as
+        rw [← hm i.as]
+        change s.inj i.as ≫ m = (e i.as).hom ≫ ((e i.as).inv ≫ s.inj i.as) ≫ m
+        simp only [Category.assoc, Iso.hom_inv_id_assoc]
+    let : HasColimit (Discrete.functor (fun i : I => G.obj ⟨i⟩)) := ⟨_, ht⟩
+    exact hasColimit_of_iso (F := Discrete.functor (fun i : I => G.obj ⟨i⟩))
+      (Discrete.natIso (fun i => Iso.refl (G.obj i)))
+
+end LittleFinitistic.DerivedSupport
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/FinitisticAsymmetry/Derived/ExactExtension.lean b/lean/OAI/Algebra/FinitisticAsymmetry/Derived/ExactExtension.lean
new file mode 100644
index 0000000000000000000000000000000000000000..ce5899b84915c1b2116467c0c496aa2a459a29f9
--- /dev/null
+++ b/lean/OAI/Algebra/FinitisticAsymmetry/Derived/ExactExtension.lean
@@ -0,0 +1,53 @@
+import Mathlib
+import OAI.Algebra.FinitisticAsymmetry.Model
+
+namespace OAI
+
+noncomputable section
+
+open CategoryTheory CategoryTheory.Limits HomologicalComplex
+namespace LittleFinitistic.DerivedSupport
+universe u v t t'
+variable {C : Type u} [Category.{v} C] [Abelian C]
+variable {ι : Type t} {ι' : Type t'} {c : ComplexShape ι} {c' : ComplexShape ι'}
+variable (e : c.Embedding c') (S : ShortComplex (HomologicalComplex C c))
+
+def extendEvalIso {j : ι} {j' : ι'} (hj : e.f j = j') :
+    (S.map (e.extendFunctor C)).map (HomologicalComplex.eval C c' j') ≅
+    S.map (HomologicalComplex.eval C c j) :=
+  ShortComplex.isoMk (S.X₁.extendXIso e hj) (S.X₂.extendXIso e hj) (S.X₃.extendXIso e hj)
+    (by
+      change (S.X₁.extendXIso e hj).hom ≫ S.f.f j =
+        (extendMap S.f e).f j' ≫ (S.X₂.extendXIso e hj).hom
+      rw [extendMap_f _ e hj]
+      simp)
+    (by
+      change (S.X₂.extendXIso e hj).hom ≫ S.g.f j =
+        (extendMap S.g e).f j' ≫ (S.X₃.extendXIso e hj).hom
+      rw [extendMap_f _ e hj]
+      simp)
+
+lemma extend_shortExact (hS : S.ShortExact) : (S.map (e.extendFunctor C)).ShortExact := by
+  have h (j' : ι') : ((S.map (e.extendFunctor C)).map
+      (HomologicalComplex.eval C c' j')).ShortExact := by
+    by_cases hj' : ∃ j, e.f j = j'
+    · obtain ⟨j, hj⟩ := hj'
+      let := hS.mono_f
+      let := hS.epi_g
+      exact ShortComplex.shortExact_of_iso (extendEvalIso e S hj).symm
+        (hS.map (HomologicalComplex.eval C c j))
+    · have h₁ := S.X₁.isZero_extend_X e j' (fun j h => hj' ⟨j,h⟩)
+      have h₂ := S.X₂.isZero_extend_X e j' (fun j h => hj' ⟨j,h⟩)
+      have h₃ := S.X₃.isZero_extend_X e j' (fun j h => hj' ⟨j,h⟩)
+      exact { exact := ShortComplex.exact_of_isZero_X₂ _ h₂
+              mono_f := h₁.mono _
+              epi_g := h₃.epi _ }
+  exact { exact := HomologicalComplex.exact_of_degreewise_exact _ (fun j => (h j).exact)
+          mono_f := HomologicalComplex.mono_of_mono_f _ (fun j => (h j).mono_f)
+          epi_g := HomologicalComplex.epi_of_epi_f _ (fun j => (h j).epi_g) }
+
+end LittleFinitistic.DerivedSupport
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/FinitisticAsymmetry/Derived/LocalizingRetracts.lean b/lean/OAI/Algebra/FinitisticAsymmetry/Derived/LocalizingRetracts.lean
new file mode 100644
index 0000000000000000000000000000000000000000..7c7d9ed538e7fd76e2c88f3d907343680f1f73db
--- /dev/null
+++ b/lean/OAI/Algebra/FinitisticAsymmetry/Derived/LocalizingRetracts.lean
@@ -0,0 +1,93 @@
+import Mathlib
+import OAI.Algebra.FinitisticAsymmetry.Model
+
+namespace OAI
+
+noncomputable section
+
+open CategoryTheory CategoryTheory.Limits CategoryTheory.Pretriangulated
+namespace LittleFinitistic.DerivedSupport
+universe u v
+variable {C : Type u} [Category.{v} C] [Preadditive C]
+  [HasColimitsOfShape (Discrete ℕ) C]
+variable {X Y : C} (i : X ⟶ Y) (p : Y ⟶ X) (hip : i ≫ p = 𝟙 X)
+
+private def swindleA : (∐ fun _ : ℕ => Y) ⟶ (∐ fun _ : ℕ => Y) :=
+  Sigma.desc fun n => (𝟙 Y - p ≫ i) ≫ Sigma.ι (fun _ : ℕ => Y) n +
+    (p ≫ i) ≫ Sigma.ι (fun _ : ℕ => Y) (n+1)
+private def swindleC : (∐ fun _ : ℕ => Y) ⟶ (∐ fun _ : ℕ => Y) :=
+  Sigma.desc fun n => match n with
+    | 0 => (𝟙 Y - p ≫ i) ≫ Sigma.ι (fun _ : ℕ => Y) 0
+    | n+1 => (p ≫ i) ≫ Sigma.ι (fun _ : ℕ => Y) n +
+        (𝟙 Y - p ≫ i) ≫ Sigma.ι (fun _ : ℕ => Y) (n+1)
+private def swindleB : (∐ fun _ : ℕ => Y) ⟶ X :=
+  Sigma.desc fun n => match n with
+    | 0 => p
+    | _+1 => 0
+private def swindleI : X ⟶ (∐ fun _ : ℕ => Y) := i ≫ Sigma.ι (fun _ : ℕ => Y) 0
+
+include hip
+
+private lemma swindleAC : swindleA i p ≫ swindleC i p = 𝟙 _ := by
+  apply Sigma.hom_ext
+  intro n
+  cases n <;>
+    simp only [swindleA, swindleC, Sigma.ι_comp_desc_assoc, Sigma.ι_comp_desc,
+      Preadditive.add_comp, Preadditive.comp_add, Preadditive.sub_comp,
+      Preadditive.comp_sub, Category.assoc, reassoc_of% hip,
+      Category.id_comp, Category.comp_id] <;> abel
+
+private lemma swindleAB : swindleA i p ≫ swindleB p = 0 := by
+  apply Sigma.hom_ext
+  intro n
+  cases n <;> simp [swindleA, swindleB, Preadditive.add_comp, Preadditive.sub_comp,
+    Category.assoc, hip]
+
+private lemma swindleIB : swindleI i ≫ swindleB p = 𝟙 _ := by
+  simp [swindleI, swindleB, Category.assoc, hip]
+
+private lemma swindleIC : swindleI i ≫ swindleC i p = 0 := by
+  simp [swindleI, swindleC, Category.assoc, Preadditive.comp_sub, reassoc_of% hip]
+
+private lemma swindleTotal : swindleC i p ≫ swindleA i p + swindleB p ≫ swindleI i = 𝟙 _ := by
+  apply Sigma.hom_ext
+  intro n
+  cases n <;>
+    simp only [swindleA, swindleC, swindleB, swindleI, Sigma.ι_comp_desc_assoc,
+      Sigma.ι_comp_desc, Preadditive.add_comp, Preadditive.comp_add,
+      Preadditive.sub_comp, Preadditive.comp_sub, Category.assoc,
+      reassoc_of% hip, Category.id_comp, Category.comp_id, zero_comp] <;> abel
+
+variable [HasZeroObject C] [HasShift C ℤ]
+  [∀ degree : ℤ, (shiftFunctor C degree).Additive] [Pretriangulated C]
+
+def swindleIso : (∐ fun _ : ℕ => Y) ≅ (∐ fun _ : ℕ => Y) ⊞ X where
+  hom := biprod.lift (swindleC i p) (swindleB p)
+  inv := biprod.desc (swindleA i p) (swindleI i)
+  hom_inv_id := by simpa using swindleTotal i p hip
+  inv_hom_id := by
+    apply biprod.hom_ext <;> apply biprod.hom_ext' <;> simp [swindleAC i p hip, swindleAB i p hip,
+      swindleIB i p hip, swindleIC i p hip]
+
+lemma swindle_distinguished : Triangle.mk (swindleA i p) (swindleB p) 0 ∈ distTriang C := by
+  apply isomorphic_distinguished _ (binaryBiproductTriangle_distinguished (∐ fun _ : ℕ => Y) X)
+  refine Triangle.isoMk _ _ (Iso.refl _) (swindleIso i p hip) (Iso.refl _) ?_ ?_ ?_
+  · simp only [Triangle.mk, Iso.refl_hom, binaryBiproductTriangle, Category.id_comp]
+    change swindleA i p ≫ (swindleIso i p hip).hom = biprod.inl
+    apply biprod.hom_ext <;> simp [swindleIso, swindleAC i p hip, swindleAB i p hip]
+  · simp only [Triangle.mk, Iso.refl_hom, binaryBiproductTriangle, Category.comp_id]
+    change swindleB p = (swindleIso i p hip).hom ≫ biprod.snd
+    exact (biprod.lift_snd _ _).symm
+  · simp
+    exact (Category.id_comp _).symm
+
+lemma localizing_of_retract (P : ObjectProperty C) [P.IsClosedUnderIsomorphisms]
+    [P.IsTriangulated] [P.IsClosedUnderColimitsOfShape (Discrete ℕ)] (hY : P Y) : P X := by
+  have h : P (∐ fun _ : ℕ => Y) := P.prop_colimit (Discrete.functor (fun _ : ℕ => Y)) (fun _ => hY)
+  exact P.ext_of_isTriangulatedClosed₃ _ (swindle_distinguished i p hip) h h
+
+end LittleFinitistic.DerivedSupport
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/FinitisticAsymmetry/Derived/ModuleGeneration.lean b/lean/OAI/Algebra/FinitisticAsymmetry/Derived/ModuleGeneration.lean
new file mode 100644
index 0000000000000000000000000000000000000000..a7772d2af4c636f9347bb7d39e106e54af890cef
--- /dev/null
+++ b/lean/OAI/Algebra/FinitisticAsymmetry/Derived/ModuleGeneration.lean
@@ -0,0 +1,210 @@
+import Mathlib
+import OAI.Algebra.FinitisticAsymmetry.Derived.DerivedSums
+import OAI.Algebra.FinitisticAsymmetry.Derived.LocalizingRetracts
+
+namespace OAI
+
+noncomputable section
+
+open CategoryTheory CategoryTheory.Limits HomologicalComplex
+namespace LittleFinitistic.DerivedSupport
+universe u w
+variable {R : Type u} [Ring R] [HasDerivedCategory.{w} (ModuleCat.{u} R)]
+variable (P : ObjectProperty (DerivedCategory (ModuleCat.{u} R)))
+  [P.IsClosedUnderIsomorphisms] [P.IsTriangulated]
+  [P.IsClosedUnderColimitsOfShape (Discrete ℕ)]
+
+omit [P.IsClosedUnderColimitsOfShape (Discrete ℕ)] in
+lemma prop_single_shortExact₁ (S : ShortComplex (ModuleCat R)) (hS : S.ShortExact)
+    (h₂ : P ((DerivedCategory.singleFunctor _ 0).obj S.X₂))
+    (h₃ : P ((DerivedCategory.singleFunctor _ 0).obj S.X₃)) :
+    P ((DerivedCategory.singleFunctor _ 0).obj S.X₁) := by
+  let := hS.mono_f
+  let := hS.epi_g
+  let F := HomologicalComplex.single (ModuleCat R) (.up ℤ) 0
+  let e := DerivedCategory.singleFunctorIsoCompQ (ModuleCat R) 0
+  apply P.prop_of_iso (e.app S.X₁).symm
+  exact P.ext_of_isTriangulatedClosed₁ _
+    (DerivedCategory.triangleOfSES_distinguished (hS.map F))
+    (P.prop_of_iso (e.app S.X₂) h₂) (P.prop_of_iso (e.app S.X₃) h₃)
+
+omit [P.IsClosedUnderColimitsOfShape (Discrete ℕ)] in
+lemma prop_single_shortExact₂ (S : ShortComplex (ModuleCat R)) (hS : S.ShortExact)
+    (h₁ : P ((DerivedCategory.singleFunctor _ 0).obj S.X₁))
+    (h₃ : P ((DerivedCategory.singleFunctor _ 0).obj S.X₃)) :
+    P ((DerivedCategory.singleFunctor _ 0).obj S.X₂) := by
+  let := hS.mono_f
+  let := hS.epi_g
+  let F := HomologicalComplex.single (ModuleCat R) (.up ℤ) 0
+  let e := DerivedCategory.singleFunctorIsoCompQ (ModuleCat R) 0
+  apply P.prop_of_iso (e.app S.X₂).symm
+  exact P.ext_of_isTriangulatedClosed₂ _
+    (DerivedCategory.triangleOfSES_distinguished (hS.map F))
+    (P.prop_of_iso (e.app S.X₁) h₁) (P.prop_of_iso (e.app S.X₃) h₃)
+
+omit [P.IsTriangulated] [P.IsClosedUnderColimitsOfShape (Discrete ℕ)] in
+lemma prop_single_of_cofan {I : Type u} [P.IsClosedUnderColimitsOfShape (Discrete I)]
+    {M : I → ModuleCat R} (s : Cofan M) (hs : IsColimit s)
+    (hM : ∀ i, P ((DerivedCategory.singleFunctor _ 0).obj (M i))) :
+    P ((DerivedCategory.singleFunctor _ 0).obj s.pt) := by
+  let F := HomologicalComplex.single (ModuleCat R) (.up ℤ) 0
+  let e := DerivedCategory.singleFunctorIsoCompQ (ModuleCat R) 0
+  have hs' := isColimitCofanMkObjOfIsColimit F M s.inj hs
+  apply P.prop_of_iso (e.app s.pt).symm
+  exact P.prop_of_isColimit (derivedCofanIsColimit _ hs')
+    (fun i => P.prop_of_iso (e.app (M i.as)) (hM i.as))
+
+variable {S : Type u} [Ring S] (χ : R →+* S)
+variable (hcop : ∀ I : Type u, P.IsClosedUnderColimitsOfShape (Discrete I))
+include hcop
+
+lemma prop_restricted_projective (M : ModuleCat.{u} S) [Module.Projective S M]
+    (hS : P ((DerivedCategory.singleFunctor _ 0).obj
+      ((ModuleCat.restrictScalars χ).obj (ModuleCat.of S S)))) :
+    P ((DerivedCategory.singleFunctor _ 0).obj ((ModuleCat.restrictScalars χ).obj M)) := by
+  classical
+  let F := ModuleCat.restrictScalars χ ⋙ DerivedCategory.singleFunctor (ModuleCat R) 0
+  let := hcop M
+  obtain ⟨s, hs⟩ := (Module.projective_def' (R := S) (P := M)).mp inferInstance
+  let q : ModuleCat.of S (M →₀ S) ⟶ M := ModuleCat.ofHom (Finsupp.linearCombination S id)
+  let j : M ⟶ ModuleCat.of S (M →₀ S) := ModuleCat.ofHom s
+  have hjq : j ≫ q = 𝟙 _ := by ext x; exact congrFun (congrArg DFunLike.coe hs) x
+  apply localizing_of_retract (F.map j) (F.map q) (by rw [← F.map_comp, hjq, F.map_id]) P
+  let cs : Cofan (fun _ : M => ModuleCat.of S S) :=
+    Cofan.mk (ModuleCat.of S (M →₀ S)) (fun x => ModuleCat.ofHom (Finsupp.lsingle x))
+  have hc : IsColimit cs := by
+    refine Cofan.IsColimit.mk _
+      (fun t => ModuleCat.ofHom (Finsupp.lsum ℤ (fun x => (t.inj x).hom))) ?_ ?_
+    · intro t x
+      ext
+      simp [cs]
+    · intro t f hf
+      apply ModuleCat.hom_ext
+      apply Finsupp.lhom_ext'
+      intro x
+      simpa [cs] using congrArg ModuleCat.Hom.hom (hf x)
+  let G := ModuleCat.restrictScalars χ
+  exact prop_single_of_cofan P (Cofan.mk (G.obj cs.pt) (fun x => G.map (cs.inj x)))
+    (isColimitCofanMkObjOfIsColimit G _ cs.inj hc) (fun _ => hS)
+
+omit hcop [HasDerivedCategory.{w} (ModuleCat.{u} R)] in
+lemma submodule_shortExact (M : ModuleCat.{u} R) (N : Submodule R M) :
+    (ShortComplex.mk (ModuleCat.ofHom N.subtype) (ModuleCat.ofHom N.mkQ)
+      (by ext x; exact (Submodule.Quotient.mk_eq_zero N).mpr x.property)).ShortExact where
+  mono_f := (ModuleCat.mono_iff_injective _).mpr N.injective_subtype
+  epi_g := (ModuleCat.epi_iff_surjective _).mpr N.mkQ_surjective
+  exact := by
+    rw [ShortComplex.moduleCat_exact_iff]
+    intro x hx
+    exact ⟨⟨x, (Submodule.Quotient.mk_eq_zero N).mp hx⟩, rfl⟩
+
+variable (J : Ideal R) [J.IsTwoSided] [IsSemisimpleRing (R ⧸ J)]
+
+lemma prop_annihilated_module
+    (hQ : P ((DerivedCategory.singleFunctor _ 0).obj
+      ((ModuleCat.restrictScalars (Ideal.Quotient.mk J)).obj (ModuleCat.of (R ⧸ J) (R ⧸ J)))))
+    (M : ModuleCat.{u} R) (hM : Module.IsTorsionBySet R M J) :
+    P ((DerivedCategory.singleFunctor _ 0).obj M) := by
+  let := hM.module
+  let M' := ModuleCat.of (R ⧸ J) M
+  let : Module.Projective (R ⧸ J) M' := Module.projective_of_isSemisimpleRing _ _
+  have h := prop_restricted_projective P (Ideal.Quotient.mk J) hcop M' hQ
+  let e : ((ModuleCat.restrictScalars (Ideal.Quotient.mk J)).obj M') ≅ M :=
+    LinearEquiv.toModuleIso {
+      toFun := id
+      invFun := id
+      left_inv := fun _ => rfl
+      right_inv := fun _ => rfl
+      map_add' := fun _ _ => rfl
+      map_smul' := fun r x => hM.mk_smul r x }
+  exact P.prop_of_iso ((DerivedCategory.singleFunctor _ 0).mapIso e) h
+
+lemma prop_of_nilpotent_kernel
+    (hQ : P ((DerivedCategory.singleFunctor _ 0).obj
+      ((ModuleCat.restrictScalars (Ideal.Quotient.mk J)).obj (ModuleCat.of (R ⧸ J) (R ⧸ J)))))
+    (hJ : ∃ n : ℕ, J ^ n = ⊥) (M : ModuleCat.{u} R) :
+    P ((DerivedCategory.singleFunctor _ 0).obj M) := by
+  have aux (n : ℕ) (M : ModuleCat.{u} R) (hn : J^n • (⊤ : Submodule R M) = ⊥) :
+      P ((DerivedCategory.singleFunctor _ 0).obj M) := by
+    induction n generalizing M with
+    | zero =>
+      have hm : (⊤ : Submodule R M) = ⊥ := by
+        simpa only [Submodule.pow_zero, Ideal.one_eq_top, Submodule.top_smul] using hn
+      apply P.prop_of_isZero
+      apply (DerivedCategory.singleFunctor _ 0).map_isZero
+      rw [ModuleCat.isZero_iff_subsingleton]
+      exact (Submodule.subsingleton_iff R).mp (subsingleton_of_bot_eq_top hm.symm)
+    | succ n ih =>
+      let N : Submodule R M := J • ⊤
+      have hn' : J^n • (⊤ : Submodule R N) = ⊥ := by
+        apply Submodule.map_injective_of_injective N.injective_subtype
+        rw [Submodule.map_bot, Submodule.map_smul'', Submodule.map_subtype_top]
+        change J^n • (J • (⊤ : Submodule R M)) = ⊥
+        rw [← Submodule.mul_smul, ← Submodule.pow_succ]
+        exact hn
+      apply prop_single_shortExact₂ P _ (submodule_shortExact M N)
+      · exact ih (ModuleCat.of R N) hn'
+      · exact prop_annihilated_module P hcop J hQ (ModuleCat.of R (M ⧸ N))
+          (Module.isTorsionBySet_quotient_ideal_smul M J)
+  obtain ⟨n, hn⟩ := hJ
+  exact aux n M (by simp [hn])
+
+variable {k ι : Type u} [Field k] [Fintype ι] (ψ : R →+* (ι → k))
+
+abbrev coordinateModule (j : ι) : ModuleCat R :=
+  (ModuleCat.restrictScalars ((Pi.evalRingHom (fun _ : ι => k) j).comp ψ)).obj
+    (ModuleCat.of k k)
+
+omit [P.IsTriangulated] [P.IsClosedUnderColimitsOfShape (Discrete ℕ)] in
+lemma prop_restricted_pi
+    (hcoord : ∀ j, P ((DerivedCategory.singleFunctor _ 0).obj (coordinateModule ψ j))) :
+    P ((DerivedCategory.singleFunctor _ 0).obj
+      ((ModuleCat.restrictScalars ψ).obj (ModuleCat.of (ι → k) (ι → k)))) := by
+  classical
+  let := hcop ι
+  let Z := coordinateModule ψ
+  have h := prop_single_of_cofan P (ModuleCat.coproductCocone Z)
+    (ModuleCat.coproductCoconeIsColimit Z) hcoord
+  let e₁ : (Π₀ i, Z i) ≃ₗ[R] (∀ i, Z i) := DFinsupp.linearEquivFunOnFintype
+  let e₂ : (∀ i, Z i) ≃ₗ[R]
+      ((ModuleCat.restrictScalars ψ).obj (ModuleCat.of (ι → k) (ι → k))) := {
+    toFun := fun x i => x i
+    invFun := fun x i => x i
+    left_inv := fun _ => rfl
+    right_inv := fun _ => rfl
+    map_add' := fun _ _ => rfl
+    map_smul' := fun _ _ => rfl }
+  exact P.prop_of_iso ((DerivedCategory.singleFunctor _ 0).mapIso
+    ((e₁.trans e₂).toModuleIso)) h
+
+lemma prop_all_of_product_augmentation (hψ : Function.Surjective ψ)
+    (hnil : ∃ n : ℕ, (RingHom.ker ψ)^n = ⊥)
+    (hcoord : ∀ j, P ((DerivedCategory.singleFunctor _ 0).obj (coordinateModule ψ j)))
+    (M : ModuleCat.{u} R) : P ((DerivedCategory.singleFunctor _ 0).obj M) := by
+  let e := RingHom.quotientKerEquivOfSurjective hψ
+  let : IsSemisimpleRing (R ⧸ RingHom.ker ψ) := e.isSemisimpleRing_iff.mpr inferInstance
+  apply prop_of_nilpotent_kernel P hcop (RingHom.ker ψ) _ hnil M
+  let e' : ((ModuleCat.restrictScalars (Ideal.Quotient.mk (RingHom.ker ψ))).obj
+      (ModuleCat.of (R ⧸ RingHom.ker ψ) (R ⧸ RingHom.ker ψ))) ≅
+      ((ModuleCat.restrictScalars ψ).obj (ModuleCat.of (ι → k) (ι → k))) :=
+    LinearEquiv.toModuleIso (show
+      ((ModuleCat.restrictScalars (Ideal.Quotient.mk (RingHom.ker ψ))).obj
+        (ModuleCat.of (R ⧸ RingHom.ker ψ) (R ⧸ RingHom.ker ψ))) ≃ₗ[R]
+      ((ModuleCat.restrictScalars ψ).obj (ModuleCat.of (ι → k) (ι → k))) from {
+      toFun := e
+      invFun := e.symm
+      left_inv := e.left_inv
+      right_inv := e.right_inv
+      map_add' := e.map_add
+      map_smul' := fun r x => by
+        change e (Ideal.Quotient.mk (RingHom.ker ψ) r * (show R ⧸ RingHom.ker ψ from x)) = ψ r * e x
+        rw [e.map_mul]
+        rfl })
+  exact P.prop_of_iso ((DerivedCategory.singleFunctor _ 0).mapIso e'.symm)
+    (prop_restricted_pi P hcop ψ hcoord)
+
+end LittleFinitistic.DerivedSupport
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/FinitisticAsymmetry/Derived/ModuleSums.lean b/lean/OAI/Algebra/FinitisticAsymmetry/Derived/ModuleSums.lean
new file mode 100644
index 0000000000000000000000000000000000000000..5379ea4ee5afcbf5287be09e1fb02e4289da4741
--- /dev/null
+++ b/lean/OAI/Algebra/FinitisticAsymmetry/Derived/ModuleSums.lean
@@ -0,0 +1,99 @@
+import Mathlib
+import OAI.Algebra.FinitisticAsymmetry.Model
+
+namespace OAI
+
+noncomputable section
+
+open CategoryTheory CategoryTheory.Limits
+open HomologicalComplex
+namespace LittleFinitistic.DerivedSupport
+universe u v
+open HomologicalComplex
+variable {R : Type u} [Ring R] {I : Type v}
+
+def moduleSumCofan (X : I → ModuleCat.{max u v} R) : Cofan X := by
+  classical
+  exact Cofan.mk (ModuleCat.of R (Π₀ i, X i)) (fun i => ModuleCat.ofHom (DFinsupp.lsingle (R := R) (M := fun j => X j) i))
+
+def moduleSumIsColimit (X : I → ModuleCat.{max u v} R) :
+    IsColimit (moduleSumCofan X) := by
+  classical
+  refine Cofan.IsColimit.mk _ (fun s => ModuleCat.ofHom (DFinsupp.lsum ℤ
+    (fun i => (s.inj i).hom))) ?_ ?_
+  · intro s i
+    ext x
+    change DFinsupp.lsum ℤ (fun j => (s.inj j).hom) (DFinsupp.single i x) = _
+    simp only [DFinsupp.lsum_single]
+  · intro s m hm
+    apply ModuleCat.hom_ext
+    apply DFinsupp.lhom_ext
+    intro i x
+    change m (DFinsupp.single i x) = DFinsupp.lsum ℤ (fun j => (s.inj j).hom) (DFinsupp.single i x)
+    rw [DFinsupp.lsum_single]
+    exact ConcreteCategory.congr_hom (hm i) x
+
+def moduleSumComplex (K : I → CochainComplex (ModuleCat.{max u v} R) ℤ) :
+    CochainComplex (ModuleCat R) ℤ where
+  X j := ModuleCat.of R (Π₀ i, (K i).X j)
+  d j k := ModuleCat.ofHom (DFinsupp.mapRange.linearMap (fun i => ((K i).d j k).hom))
+  shape j k hjk := by
+    ext x i
+    change (K i).d j k (x i) = 0
+    rw [(K i).shape j k hjk]
+    rfl
+  d_comp_d' j k l hjk hkl := by
+    ext x i
+    change ((K i).d k l) (((K i).d j k) (x i)) = 0
+    exact ConcreteCategory.congr_hom ((K i).d_comp_d j k l) (x i)
+
+def moduleSumComplexInj (K : I → CochainComplex (ModuleCat.{max u v} R) ℤ) (i : I) :
+    K i ⟶ moduleSumComplex K := by
+  classical
+  refine { f := fun j => ModuleCat.ofHom (DFinsupp.lsingle (R := R)
+      (M := fun n => (K n).X j) i), comm' := ?_ }
+  intro j k hjk
+  ext x
+  change DFinsupp.mapRange (fun i => ((K i).d j k).hom) (fun i => map_zero _) (DFinsupp.single i x) =
+    DFinsupp.single i ((K i).d j k x)
+  rw [DFinsupp.mapRange_single]
+
+def moduleSumComplexCofan (K : I → CochainComplex (ModuleCat.{max u v} R) ℤ) : Cofan K :=
+  Cofan.mk _ (moduleSumComplexInj K)
+
+def moduleSumComplexIsColimit (K : I → CochainComplex (ModuleCat.{max u v} R) ℤ) :
+    IsColimit (moduleSumComplexCofan K) := by
+  classical
+  refine Cofan.IsColimit.mk _ (fun s =>
+    { f := fun j => ModuleCat.ofHom (DFinsupp.lsum ℤ (fun i => ((s.inj i).f j).hom))
+      comm' := ?_ }) ?_ ?_
+  · intro j k hjk
+    apply ModuleCat.hom_ext
+    apply DFinsupp.lhom_ext
+    intro i x
+    change s.pt.d j k (DFinsupp.lsum ℤ (fun i => ((s.inj i).f j).hom)
+        (DFinsupp.single i x)) =
+      DFinsupp.lsum ℤ (fun i => ((s.inj i).f k).hom)
+        (DFinsupp.mapRange (fun i => ((K i).d j k).hom) (fun i => map_zero _) (DFinsupp.single i x))
+    simp only [DFinsupp.mapRange_single, DFinsupp.lsum_single]
+    exact ConcreteCategory.congr_hom ((s.inj i).comm j k) x
+  · intro s i
+    ext j x
+    change DFinsupp.lsum ℤ (fun i => ((s.inj i).f j).hom) (DFinsupp.single i x) = _
+    simp only [DFinsupp.lsum_single]
+  · intro s m hm
+    apply HomologicalComplex.Hom.ext
+    funext j
+    apply ModuleCat.hom_ext
+    apply DFinsupp.lhom_ext
+    intro i x
+    change m.f j (DFinsupp.single i x) =
+      DFinsupp.lsum ℤ (fun i => ((s.inj i).f j).hom) (DFinsupp.single i x)
+    rw [DFinsupp.lsum_single]
+    exact ConcreteCategory.congr_hom (congrArg (fun f => f.f j) (hm i)) x
+
+end LittleFinitistic.DerivedSupport
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/FinitisticAsymmetry/Derived/Telescopes.lean b/lean/OAI/Algebra/FinitisticAsymmetry/Derived/Telescopes.lean
new file mode 100644
index 0000000000000000000000000000000000000000..70d57566f5bff7d006183b865af2060c927d1162
--- /dev/null
+++ b/lean/OAI/Algebra/FinitisticAsymmetry/Derived/Telescopes.lean
@@ -0,0 +1,177 @@
+import Mathlib
+import OAI.Algebra.FinitisticAsymmetry.Derived.DerivedSums
+import OAI.Algebra.FinitisticAsymmetry.Derived.ModuleSums
+
+namespace OAI
+
+noncomputable section
+
+open CategoryTheory CategoryTheory.Limits
+open HomologicalComplex
+namespace LittleFinitistic.DerivedSupport
+
+section
+universe u v
+variable {C : Type u} [Category.{v} C] [Preadditive C]
+variable {X : ℕ → C} (f : ∀ n, X n ⟶ X (n+1)) (s : Cofan X) (hs : IsColimit s)
+
+def telescopeMap : s.pt ⟶ s.pt :=
+  hs.desc (Cofan.mk s.pt (fun n => s.inj n - f n ≫ s.inj (n+1)))
+
+@[reassoc (attr := simp)]
+lemma telescopeMap_inj (n : ℕ) :
+    s.inj n ≫ telescopeMap f s hs = s.inj n - f n ≫ s.inj (n+1) :=
+  hs.fac _ (Discrete.mk n)
+
+def telescopeπ (c : Cocone (Functor.ofSequence f)) : s.pt ⟶ c.pt :=
+  hs.desc (Cofan.mk c.pt c.ι.app)
+
+omit [Preadditive C] in
+@[reassoc (attr := simp)]
+lemma telescopeπ_inj (c : Cocone (Functor.ofSequence f)) (n : ℕ) :
+    s.inj n ≫ telescopeπ f s hs c = c.ι.app n := hs.fac _ (Discrete.mk n)
+
+lemma telescope_zero (c : Cocone (Functor.ofSequence f)) :
+    telescopeMap f s hs ≫ telescopeπ f s hs c = 0 := by
+  apply hs.hom_ext
+  intro n
+  change s.inj n.as ≫ _ = _
+  rw [telescopeMap_inj_assoc, Preadditive.sub_comp, telescopeπ_inj,
+    Category.assoc, telescopeπ_inj, comp_zero]
+  have h := c.w (homOfLE (Nat.le_add_right n.as 1))
+  simpa using! sub_eq_zero.mpr h.symm
+
+def telescopeCokernel (c : Cocone (Functor.ofSequence f)) (hc : IsColimit c) :
+    IsColimit (CokernelCofork.ofπ (telescopeπ f s hs c) (telescope_zero f s hs c)) := by
+  let d {Y : C} (g : s.pt ⟶ Y) (hg : telescopeMap f s hs ≫ g = 0) :
+      Cocone (Functor.ofSequence f) :=
+    { pt := Y
+      ι := NatTrans.ofSequence (F := Functor.ofSequence f) (G := (Functor.const ℕ).obj Y) (fun n => s.inj n ≫ g) (fun n => by
+        have h := congrArg (fun t => s.inj n ≫ t) hg
+        rw [telescopeMap_inj_assoc, Preadditive.sub_comp, comp_zero] at h
+        dsimp only [Functor.const_obj_map]
+        rw [Functor.ofSequence_map_homOfLE_succ]
+        change f n ≫ (s.inj (n+1) ≫ g) = (s.inj n ≫ g) ≫ 𝟙 Y
+        simpa only [Category.comp_id, Category.assoc] using (sub_eq_zero.mp h).symm) }
+  refine CokernelCofork.IsColimit.ofπ _ _ (fun g hg => hc.desc (d g hg)) ?_ ?_
+  · intro Y g hg
+    apply hs.hom_ext
+    intro n
+    change s.inj n.as ≫ _ = _
+    erw [telescopeπ_inj_assoc, hc.fac]
+    rfl
+  · intro Y g hg m hm
+    apply hc.hom_ext
+    intro n
+    rw [hc.fac]
+    change c.ι.app n ≫ m = s.inj n ≫ g
+    rw [← hm, telescopeπ_inj_assoc]
+    rfl
+
+end
+
+section
+universe u
+variable {R : Type u} [Ring R]
+variable (K : ℕ → CochainComplex (ModuleCat.{u} R) ℤ) (f : ∀ n, K n ⟶ K (n+1))
+
+abbrev moduleTelescopeMap := telescopeMap f _ (moduleSumComplexIsColimit K)
+
+def moduleTelescopeLinear (j : ℤ) : (Π₀ n, (K n).X j) →ₗ[R] (Π₀ n, (K n).X j) :=
+  ((moduleTelescopeMap K f).f j).hom
+
+lemma moduleTelescope_at_zero (j : ℤ) (x : Π₀ n, (K n).X j) :
+    (moduleTelescopeLinear K f j x) 0 = x 0 := by
+  classical
+  let : DecidableEq ℕ := Classical.typeDecidableEq ℕ
+  have h : (DFinsupp.lapply 0).comp (moduleTelescopeLinear K f j) =
+      (DFinsupp.lapply 0 : (Π₀ n, (K n).X j) →ₗ[R] (K 0).X j) := by
+    apply DFinsupp.lhom_ext
+    intro n y
+    have hlin := congrArg (fun t => (t.f j).hom) (telescopeMap_inj f _ (moduleSumComplexIsColimit K) n)
+    simp only [HomologicalComplex.comp_f, HomologicalComplex.sub_f_apply, ModuleCat.hom_sub, ModuleCat.hom_comp] at hlin
+    have hfun := LinearMap.congr_fun hlin y
+    simp only [moduleSumComplexCofan, cofan_mk_inj, moduleSumComplexInj] at hfun
+    have hsing : moduleTelescopeLinear K f j (DFinsupp.single n y) =
+        (DFinsupp.single n y : Π₀ n, (K n).X j) - DFinsupp.single (n+1) ((f n).f j y) := by
+      simpa [moduleTelescopeLinear, moduleTelescopeMap, moduleSumComplexCofan, moduleSumComplexInj, moduleSumComplex] using! hfun
+    change (moduleTelescopeLinear K f j (DFinsupp.single n y)) 0 = _
+    rw [hsing, DFinsupp.sub_apply]
+    simp [DFinsupp.lapply_apply]
+  exact LinearMap.congr_fun h x
+
+lemma moduleTelescope_at_succ (j : ℤ) (x : Π₀ n, (K n).X j) (n : ℕ) :
+    (moduleTelescopeLinear K f j x) (n+1) = x (n+1) - (f n).f j (x n) := by
+  classical
+  let : DecidableEq ℕ := Classical.typeDecidableEq ℕ
+  have h : (DFinsupp.lapply (n+1)).comp (moduleTelescopeLinear K f j) =
+      (DFinsupp.lapply (n+1) : (Π₀ n, (K n).X j) →ₗ[R] (K (n+1)).X j) -
+        ((f n).f j).hom.comp (DFinsupp.lapply n) := by
+    apply DFinsupp.lhom_ext
+    intro m y
+    have hlin := congrArg (fun t => (t.f j).hom) (telescopeMap_inj f _ (moduleSumComplexIsColimit K) m)
+    simp only [HomologicalComplex.comp_f, HomologicalComplex.sub_f_apply, ModuleCat.hom_sub, ModuleCat.hom_comp] at hlin
+    have hfun := LinearMap.congr_fun hlin y
+    simp only [moduleSumComplexCofan, cofan_mk_inj, moduleSumComplexInj] at hfun
+    have hsing : moduleTelescopeLinear K f j (DFinsupp.single m y) =
+        (DFinsupp.single m y : Π₀ n, (K n).X j) - DFinsupp.single (m+1) ((f m).f j y) := by
+      simpa [moduleTelescopeLinear, moduleTelescopeMap, moduleSumComplexCofan, moduleSumComplexInj, moduleSumComplex] using! hfun
+    change (moduleTelescopeLinear K f j (DFinsupp.single m y)) (n+1) = _
+    rw [hsing, DFinsupp.sub_apply]
+    by_cases hmn : m = n
+    · subst m
+      simp
+    · simp [hmn]
+  exact LinearMap.congr_fun h x
+
+instance moduleTelescopeMap_mono : Mono (moduleTelescopeMap K f) := by
+  apply HomologicalComplex.mono_of_mono_f
+  intro j
+  rw [ModuleCat.mono_iff_injective]
+  apply (injective_iff_map_eq_zero _).2
+  change ∀ (x : Π₀ n, (K n).X j), moduleTelescopeLinear K f j x = 0 → x = 0
+  intro x hx
+  have he (n : ℕ) : x n = 0 := by
+    induction n with
+    | zero => simpa [hx] using (moduleTelescope_at_zero K f j x).symm
+    | succ n ih =>
+      have h := moduleTelescope_at_succ K f j x n
+      rw [hx, ih, map_zero, sub_zero] at h
+      exact h.symm
+  exact DFinsupp.ext he
+
+end
+
+universe u w
+variable {R : Type u} [Ring R]
+variable (K : ℕ → CochainComplex (ModuleCat.{u} R) ℤ) (f : ∀ n, K n ⟶ K (n+1))
+variable (c : Cocone (Functor.ofSequence f)) (hc : IsColimit c)
+
+def moduleTelescopeShortComplex : ShortComplex (CochainComplex (ModuleCat R) ℤ) :=
+  ShortComplex.mk (moduleTelescopeMap K f)
+    (telescopeπ f _ (moduleSumComplexIsColimit K) c)
+    (telescope_zero f _ (moduleSumComplexIsColimit K) c)
+
+lemma moduleTelescope_shortExact (hc : IsColimit c) : (moduleTelescopeShortComplex K f c).ShortExact where
+  mono_f := by change Mono (moduleTelescopeMap K f); infer_instance
+  epi_g := epi_of_isColimit_cofork (telescopeCokernel f _ (moduleSumComplexIsColimit K) c hc)
+  exact := (moduleTelescopeShortComplex K f c).exact_of_g_is_cokernel
+    (telescopeCokernel f _ (moduleSumComplexIsColimit K) c hc)
+
+variable [HasDerivedCategory.{w} (ModuleCat.{u} R)]
+
+lemma localizing_sequence_colimit (hc : IsColimit c) (P : ObjectProperty (DerivedCategory (ModuleCat.{u} R)))
+    [P.IsTriangulated] [P.IsClosedUnderIsomorphisms]
+    [P.IsClosedUnderColimitsOfShape (Discrete ℕ)]
+    (hK : ∀ n, P (DerivedCategory.Q.obj (K n))) : P (DerivedCategory.Q.obj c.pt) := by
+  have hs : P (DerivedCategory.Q.obj (moduleSumComplex K)) :=
+    P.prop_of_isColimit (derivedCofanIsColimit _ (moduleSumComplexIsColimit K))
+      (fun n => hK n.as)
+  exact P.ext_of_isTriangulatedClosed₃ _
+    (DerivedCategory.triangleOfSES_distinguished (moduleTelescope_shortExact K f c hc)) hs hs
+
+end LittleFinitistic.DerivedSupport
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/FinitisticAsymmetry/Derived/Truncations.lean b/lean/OAI/Algebra/FinitisticAsymmetry/Derived/Truncations.lean
new file mode 100644
index 0000000000000000000000000000000000000000..5294e3d9a637623c510e7f63d724c28ffb9b8e41
--- /dev/null
+++ b/lean/OAI/Algebra/FinitisticAsymmetry/Derived/Truncations.lean
@@ -0,0 +1,151 @@
+import Mathlib
+import OAI.Algebra.FinitisticAsymmetry.Model
+
+namespace OAI
+
+noncomputable section
+
+open CategoryTheory CategoryTheory.Limits
+open HomologicalComplex
+
+open CategoryTheory CategoryTheory.Limits HomologicalComplex
+namespace LittleFinitistic.DerivedSupport
+universe u
+variable {R : Type u} [Ring R]
+
+def cutSub (K : CochainComplex (ModuleCat.{u} R) ℤ) (a j : ℤ) : Submodule R (K.X j) :=
+  if a ≤ j then ⊤ else ⊥
+
+lemma mem_cutSub {K : CochainComplex (ModuleCat.{u} R) ℤ} {a j : ℤ} {x : K.X j} :
+    x ∈ cutSub K a j ↔ a ≤ j ∨ x = 0 := by
+  by_cases h : a ≤ j <;> simp [cutSub, h]
+
+lemma cutSub_d {K : CochainComplex (ModuleCat.{u} R) ℤ} {a j k : ℤ}
+    {x : K.X j} (hx : x ∈ cutSub K a j) : K.d j k x ∈ cutSub K a k := by
+  rw [mem_cutSub] at hx ⊢
+  by_cases h : (ComplexShape.up ℤ).Rel j k
+  · change j + 1 = k at h
+    rcases hx with hx | rfl
+    · exact Or.inl (by omega)
+    · exact Or.inr (map_zero _)
+  · rw [K.shape j k h]
+    exact Or.inr rfl
+
+def cut (K : CochainComplex (ModuleCat.{u} R) ℤ) (a : ℤ) :
+    CochainComplex (ModuleCat R) ℤ where
+  X j := ModuleCat.of R (cutSub K a j)
+  d j k := ModuleCat.ofHom
+    { toFun := fun x => ⟨K.d j k x, cutSub_d x.property⟩
+      map_add' := fun x y => Subtype.ext (map_add _ _ _)
+      map_smul' := fun r x => Subtype.ext (map_smul _ _ _) }
+  shape j k hjk := by
+    ext x
+    change K.d j k x = 0
+    rw [K.shape j k hjk]
+    rfl
+  d_comp_d' j k l hjk hkl := by
+    ext x
+    exact ConcreteCategory.congr_hom (K.d_comp_d j k l) x
+
+def cutι (K : CochainComplex (ModuleCat.{u} R) ℤ) (a : ℤ) : cut K a ⟶ K where
+  f j := ModuleCat.ofHom (cutSub K a j).subtype
+  comm' _ _ _ := rfl
+
+instance cutι_mono (K : CochainComplex (ModuleCat.{u} R) ℤ) (a : ℤ) : Mono (cutι K a) := by
+  apply HomologicalComplex.mono_of_mono_f
+  intro j
+  exact (ModuleCat.mono_iff_injective _).2 Subtype.val_injective
+
+lemma cutSub_le (K : CochainComplex (ModuleCat.{u} R) ℤ) {a b : ℤ} (h : b ≤ a) (j : ℤ) :
+    cutSub K a j ≤ cutSub K b j := by
+  intro x hx
+  rw [mem_cutSub] at hx ⊢
+  exact hx.imp (le_trans h) id
+
+def cutMap (K : CochainComplex (ModuleCat.{u} R) ℤ) {a b : ℤ} (h : b ≤ a) :
+    cut K a ⟶ cut K b where
+  f j := ModuleCat.ofHom (Submodule.inclusion (cutSub_le K h j))
+  comm' _ _ _ := rfl
+
+@[reassoc (attr := simp)]
+lemma cutMap_ι (K : CochainComplex (ModuleCat.{u} R) ℤ) {a b : ℤ} (h : b ≤ a) :
+    cutMap K h ≫ cutι K b = cutι K a := rfl
+
+lemma cut_isZero_X (K : CochainComplex (ModuleCat.{u} R) ℤ) (a j : ℤ) (h : j < a) :
+    IsZero ((cut K a).X j) := by
+  apply ModuleCat.isZero_iff_subsingleton.2
+  have : cutSub K a j = ⊥ := ite_eq_right (by omega)
+  change Subsingleton (cutSub K a j)
+  rw [this]
+  infer_instance
+
+lemma cutι_f_isIso (K : CochainComplex (ModuleCat.{u} R) ℤ) (a j : ℤ) (h : a ≤ j) :
+    IsIso ((cutι K a).f j) := by
+  rw [ConcreteCategory.isIso_iff_bijective]
+  refine ⟨Subtype.val_injective, fun x => ?_⟩
+  exact ⟨⟨x, mem_cutSub.mpr (Or.inl h)⟩, rfl⟩
+
+def cutπ (K : CochainComplex (ModuleCat.{u} R) ℤ) (a : ℤ) :
+    cut K a ⟶ (HomologicalComplex.single (ModuleCat R) (ComplexShape.up ℤ) a).obj (K.X a) :=
+  mkHomToSingle ((cutι K a).f a) (fun i hi => by
+    have h : i < a := by change i + 1 = a at hi; omega
+    exact (cut_isZero_X K a i h).eq_of_src _ _)
+
+lemma cutMap_π (K : CochainComplex (ModuleCat.{u} R) ℤ) (a : ℤ) :
+    cutMap K (show a ≤ a+1 by omega) ≫ cutπ K a = 0 := by
+  apply to_single_hom_ext
+  apply (cut_isZero_X K (a+1) a (by omega)).eq_of_src
+
+instance cutMap_mono (K : CochainComplex (ModuleCat.{u} R) ℤ) {a b : ℤ} (h : b ≤ a) :
+    Mono (cutMap K h) := by
+  have : Mono (cutMap K h ≫ cutι K b) := by
+    rw [cutMap_ι]
+    infer_instance
+  exact mono_of_mono _ (cutι K b)
+
+instance cutπ_f_self_isIso (K : CochainComplex (ModuleCat.{u} R) ℤ) (a : ℤ) :
+    IsIso ((cutπ K a).f a) := by
+  dsimp only [cutπ]
+  rw [mkHomToSingle_f]
+  have := cutι_f_isIso K a a (le_refl a)
+  infer_instance
+
+instance cutπ_epi (K : CochainComplex (ModuleCat.{u} R) ℤ) (a : ℤ) : Epi (cutπ K a) := by
+  apply HomologicalComplex.epi_of_epi_f
+  intro j
+  by_cases h : j = a
+  · subst j; infer_instance
+  · exact (isZero_single_obj_X (ComplexShape.up ℤ) a (K.X a) j h).epi _
+
+def cutShortComplex (K : CochainComplex (ModuleCat.{u} R) ℤ) (a : ℤ) :
+    ShortComplex (CochainComplex (ModuleCat R) ℤ) :=
+  ShortComplex.mk (cutMap K (show a ≤ a+1 by omega)) (cutπ K a) (cutMap_π K a)
+
+lemma cut_shortExact (K : CochainComplex (ModuleCat.{u} R) ℤ) (a : ℤ) :
+    (cutShortComplex K a).ShortExact where
+  exact := by
+    apply HomologicalComplex.exact_of_degreewise_exact
+    intro j
+    rw [ShortComplex.moduleCat_exact_iff]
+    intro x hx
+    change ↥(cutSub K a j) at x
+    change (cutπ K a).f j x = 0 at hx
+    by_cases h : j = a
+    · subst j
+      have hi : Function.Injective ((cutπ K a).f a) :=
+        (ModuleCat.mono_iff_injective _).1 inferInstance
+      have hx' : x = 0 := hi (hx.trans (map_zero _).symm)
+      exact ⟨0, by rw [hx']; rfl⟩
+    · refine ⟨⟨(x : K.X j), ?_⟩, ?_⟩
+      · have hx' := x.property
+        rw [mem_cutSub] at hx' ⊢
+        exact hx'.imp (fun h' => by omega) id
+      · rfl
+  mono_f := by change Mono (cutMap K (show a ≤ a+1 by omega)); infer_instance
+  epi_g := by change Epi (cutπ K a); infer_instance
+
+end LittleFinitistic.DerivedSupport
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/FinitisticAsymmetry/Derived/UpperTruncation.lean b/lean/OAI/Algebra/FinitisticAsymmetry/Derived/UpperTruncation.lean
new file mode 100644
index 0000000000000000000000000000000000000000..d5b2620bc72d2fae9c93524b79ec510e7de5dbaf
--- /dev/null
+++ b/lean/OAI/Algebra/FinitisticAsymmetry/Derived/UpperTruncation.lean
@@ -0,0 +1,144 @@
+import Mathlib
+import OAI.Algebra.FinitisticAsymmetry.Derived.BoundedGeneration
+
+namespace OAI
+
+noncomputable section
+
+open CategoryTheory CategoryTheory.Limits
+open HomologicalComplex
+
+open CategoryTheory CategoryTheory.Limits HomologicalComplex
+
+open CategoryTheory CategoryTheory.Limits HomologicalComplex
+namespace LittleFinitistic.DerivedSupport
+
+section
+universe u
+variable {R : Type u} [Ring R]
+
+def upperSub (K : CochainComplex (ModuleCat.{u} R) ℤ) (a j : ℤ) : Submodule R (K.X j) :=
+  if j < a then ⊤ else if j = a then LinearMap.ker (K.d j (j+1)).hom else ⊥
+
+lemma mem_upperSub {K : CochainComplex (ModuleCat.{u} R) ℤ} {a j : ℤ} {x : K.X j} :
+    x ∈ upperSub K a j ↔ j < a ∨ (j = a ∧ K.d j (j+1) x = 0) ∨ x = 0 := by
+  by_cases h : j < a
+  · simp [upperSub, h]
+  · by_cases he : j = a
+    · simp [upperSub, he, LinearMap.mem_ker]
+      intro hx; subst x; exact map_zero _
+    · simp [upperSub, h, he]
+
+lemma upperSub_d {K : CochainComplex (ModuleCat.{u} R) ℤ} {a j k : ℤ}
+    {x : K.X j} (hx : x ∈ upperSub K a j) : K.d j k x ∈ upperSub K a k := by
+  rw [mem_upperSub] at hx ⊢
+  by_cases h : (ComplexShape.up ℤ).Rel j k
+  · change j + 1 = k at h
+    rcases hx with hx | ⟨rfl, hx⟩ | rfl
+    · by_cases hk : k < a
+      · exact Or.inl hk
+      · exact Or.inr (Or.inl ⟨by omega,
+          ConcreteCategory.congr_hom (K.d_comp_d j k (k+1)) x⟩)
+    · exact Or.inr (Or.inr (by rw [← h]; exact hx))
+    · exact Or.inr (Or.inr (map_zero _))
+  · rw [K.shape j k h]
+    exact Or.inr (Or.inr rfl)
+
+def upper (K : CochainComplex (ModuleCat.{u} R) ℤ) (a : ℤ) :
+    CochainComplex (ModuleCat R) ℤ where
+  X j := ModuleCat.of R (upperSub K a j)
+  d j k := ModuleCat.ofHom
+    { toFun := fun x => ⟨K.d j k x, upperSub_d x.property⟩
+      map_add' := fun x y => Subtype.ext (map_add _ _ _)
+      map_smul' := fun r x => Subtype.ext (map_smul _ _ _) }
+  shape j k hjk := by
+    ext x
+    change K.d j k x = 0
+    rw [K.shape j k hjk]
+    rfl
+  d_comp_d' j k l hjk hkl := by
+    ext x
+    exact ConcreteCategory.congr_hom (K.d_comp_d j k l) x
+
+def upperι (K : CochainComplex (ModuleCat.{u} R) ℤ) (a : ℤ) : upper K a ⟶ K where
+  f j := ModuleCat.ofHom (upperSub K a j).subtype
+  comm' _ _ _ := rfl
+
+lemma upper_le (K : CochainComplex (ModuleCat.{u} R) ℤ) {a b : ℤ} (h : a ≤ b) (j : ℤ) :
+    upperSub K a j ≤ upperSub K b j := by
+  intro x hx
+  rw [mem_upperSub] at hx ⊢
+  rcases hx with hx | ⟨rfl, hx⟩ | rfl
+  · exact Or.inl (lt_of_lt_of_le hx h)
+  · rcases lt_or_eq_of_le h with hh | rfl
+    · exact Or.inl hh
+    · exact Or.inr (Or.inl ⟨rfl, hx⟩)
+  · exact Or.inr (Or.inr rfl)
+
+def upperMap (K : CochainComplex (ModuleCat.{u} R) ℤ) {a b : ℤ} (h : a ≤ b) :
+    upper K a ⟶ upper K b where
+  f j := ModuleCat.ofHom (Submodule.inclusion (upper_le K h j))
+  comm' _ _ _ := by ext; rfl
+
+@[reassoc (attr := simp)]
+lemma upperMap_ι (K : CochainComplex (ModuleCat.{u} R) ℤ) {a b : ℤ} (h : a ≤ b) :
+    upperMap K h ≫ upperι K b = upperι K a := by ext; rfl
+
+lemma upperι_f_isIso (K : CochainComplex (ModuleCat.{u} R) ℤ) (a j : ℤ) (hj : j < a) :
+    IsIso ((upperι K a).f j) := by
+  rw [ConcreteCategory.isIso_iff_bijective]
+  exact ⟨Subtype.val_injective, fun x => ⟨⟨x, by simp [upperSub, hj]⟩, rfl⟩⟩
+
+lemma upper_isZero_X (K : CochainComplex (ModuleCat.{u} R) ℤ) (a j : ℤ) (hj : a < j) :
+    IsZero ((upper K a).X j) := by
+  apply ModuleCat.isZero_iff_subsingleton.2
+  change Subsingleton (upperSub K a j)
+  simp only [upperSub, show ¬ j < a by omega, ↓reduceIte, show ¬ j = a by omega]
+  infer_instance
+
+end
+
+universe u w
+variable {R : Type u} [Ring R]
+variable (K : CochainComplex (ModuleCat.{u} R) ℤ)
+
+def upperSequenceMap (n : ℕ) : upper K (n : ℤ) ⟶ upper K ((n+1 : ℕ) : ℤ) :=
+  upperMap K (by omega)
+
+def upperSequenceCocone : Cocone (Functor.ofSequence (upperSequenceMap K)) where
+  pt := K
+  ι := NatTrans.ofSequence (fun n => upperι K (n : ℤ)) (fun n => by
+    simp [upperSequenceMap]
+    exact (upperMap_ι K _).trans (Category.comp_id _).symm)
+
+def upperSequenceIsColimit : IsColimit (upperSequenceCocone K) := by
+  apply HomologicalComplex.isColimitOfEval
+  intro j
+  apply eventuallyIsoCoconeIsColimit _ (j.toNat + 1)
+  intro n hn
+  change IsIso ((upperι K (n : ℤ)).f j)
+  exact upperι_f_isIso K _ _ (by omega)
+
+variable [HasDerivedCategory.{w} (ModuleCat.{u} R)]
+variable (P : ObjectProperty (DerivedCategory (ModuleCat.{u} R)))
+  [P.IsTriangulated] [P.IsClosedUnderIsomorphisms]
+  [P.IsClosedUnderColimitsOfShape (Discrete ℕ)]
+
+lemma prop_of_all_modules
+    (hM : ∀ (M : ModuleCat R), P ((DerivedCategory.singleFunctor (ModuleCat R) 0).obj M)) :
+    P (DerivedCategory.Q.obj K) := by
+  exact localizing_sequence_colimit (fun n => upper K (n : ℤ)) (upperSequenceMap K)
+    (upperSequenceCocone K) (upperSequenceIsColimit K) P (fun n =>
+      prop_of_boundedAbove_terms P (upper K _) n (upper_isZero_X K _) (fun j => hM _))
+
+lemma localizing_eq_top_of_all_modules
+    (hM : ∀ (M : ModuleCat R), P ((DerivedCategory.singleFunctor (ModuleCat R) 0).obj M))
+    (X : DerivedCategory (ModuleCat R)) : P X := by
+  exact P.prop_of_iso (DerivedCategory.Q.objObjPreimageIso X)
+    (prop_of_all_modules (DerivedCategory.Q.objPreimage X) P hM)
+
+end LittleFinitistic.DerivedSupport
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/FinitisticAsymmetry/Kasch/FiniteDimension.lean b/lean/OAI/Algebra/FinitisticAsymmetry/Kasch/FiniteDimension.lean
new file mode 100644
index 0000000000000000000000000000000000000000..d23b393b905e2666b0924e20ceca3560b94e76ab
--- /dev/null
+++ b/lean/OAI/Algebra/FinitisticAsymmetry/Kasch/FiniteDimension.lean
@@ -0,0 +1,61 @@
+import Mathlib
+import OAI.Algebra.FinitisticAsymmetry.Kasch.ProjectiveSplitting
+
+namespace OAI
+
+section
+section
+noncomputable section
+open CategoryTheory
+namespace LittleFinitistic
+universe u
+variable (A : Type u) [Ring A]
+namespace Kasch
+universe v w
+variable {R : Type u} [Ring R]
+section SplitBasic
+variable {k : Type u} [Field k] [Algebra k R]
+variable {ι : Type u} (χ : R →ₐ[k] (ι → k))
+variable (a : ι → R) (ha : ∀ i, a i ≠ 0)
+  (hmul : ∀ i r, a i * r = χ r i • a i)
+include ha hmul in
+lemma projective_of_hasFiniteBound [Finite ι]
+    (hχ : Function.Surjective χ) (hJ : ∃ n : ℕ, (RingHom.ker χ.toRingHom) ^ n = ⊥)
+    (M : ModuleCat.{u} R) (n : ℕ) [HasProjectiveDimensionLT M n] : Projective M := by
+  induction n generalizing M with
+  | zero =>
+    exact (CategoryTheory.isZero_of_hasProjectiveDimensionLT_zero M).projective
+  | succ n ih =>
+    cases n with
+    | zero => exact projective_iff_hasProjectiveDimensionLT_one.mpr inferInstance
+    | succ n =>
+      let S := ShortComplex.mk (Limits.kernel.ι (Projective.π M)) (Projective.π M)
+        (Limits.kernel.condition (Projective.π M))
+      have hs : S.ShortExact := { exact := ShortComplex.exact_kernel (Projective.π M) }
+      let : HasProjectiveDimensionLT S.X₁ (n + 1) :=
+        (hs.hasProjectiveDimensionLT_X₃_iff n inferInstance).mp inferInstance
+      let : Projective S.X₁ := ih S.X₁
+      obtain ⟨r, hr⟩ := projective_mono_splits χ a ha hmul hχ hJ S.f.hom
+        ((ModuleCat.mono_iff_injective S.f).mp hs.mono_f)
+      let spl := ShortComplex.Splitting.ofExactOfRetraction S hs.exact
+        (ModuleCat.ofHom r) (ModuleCat.hom_ext hr) hs.epi_g
+      exact (show Retract M S.X₂ from
+        { i := spl.s, r := S.g, retract := spl.s_g }).projective
+
+include ha hmul in
+lemma projective_of_finiteDimension [Finite ι]
+    (hχ : Function.Surjective χ) (hJ : ∃ n : ℕ, (RingHom.ker χ.toRingHom) ^ n = ⊥)
+    (M : ModuleCat.{u} R) (hM : projectiveDimension M < ⊤) : Projective M := by
+  obtain ⟨n, hn⟩ := (projectiveDimension_ne_top_iff M).mp hM.ne
+  let := hn
+  exact projective_of_hasFiniteBound χ a ha hmul hχ hJ M (n + 1)
+
+end SplitBasic
+end Kasch
+
+end LittleFinitistic
+end
+end
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/FinitisticAsymmetry/Kasch/ProjectiveSplitting.lean b/lean/OAI/Algebra/FinitisticAsymmetry/Kasch/ProjectiveSplitting.lean
new file mode 100644
index 0000000000000000000000000000000000000000..b9cd8afddf17c109e5f7c707ef4d26d1f23d54c0
--- /dev/null
+++ b/lean/OAI/Algebra/FinitisticAsymmetry/Kasch/ProjectiveSplitting.lean
@@ -0,0 +1,126 @@
+import Mathlib
+import OAI.Algebra.FinitisticAsymmetry.Kasch.Radical
+
+namespace OAI
+
+section
+section
+noncomputable section
+open CategoryTheory
+namespace LittleFinitistic
+universe u
+variable (A : Type u) [Ring A]
+namespace Kasch
+universe v w
+variable {R : Type u} [Ring R]
+section SplitBasic
+variable {k : Type u} [Field k] [Algebra k R]
+variable {ι : Type u} (χ : R →ₐ[k] (ι → k))
+variable (a : ι → R) (ha : ∀ i, a i ≠ 0)
+  (hmul : ∀ i r, a i * r = χ r i • a i)
+
+include hmul in
+lemma annihilates_radical {P : Type v} [AddCommGroup P] [Module R P]
+    {x : P} (hx : x ∈ radicalPart (RingHom.ker χ.toRingHom) P) (i : ι) : a i • x = 0 := by
+  refine Submodule.smul_induction_on hx ?_ ?_
+  · intro r hr y hy
+    rw [← mul_smul, hmul]
+    have h : χ r = 0 := hr
+    simp [h]
+  · intro x y hx hy
+    simp only [smul_add, hx, hy, add_zero]
+
+include ha hmul in
+lemma finsupp_mem_radical_of_annihilated {σ : Type v} (x : σ →₀ R)
+    (hx : ∀ i, a i • x = 0) : x ∈ radicalPart (RingHom.ker χ.toRingHom) (σ →₀ R) := by
+  classical
+  have hcoef (s : σ) : χ (x s) = 0 := by
+    ext i
+    have hi : a i * x s = 0 := congrArg (fun y : σ →₀ R => y s) (hx i)
+    rw [hmul] at hi
+    exact (smul_eq_zero.mp hi).resolve_right (ha i)
+  rw [← Finsupp.sum_single x]
+  apply Submodule.sum_mem
+  intro s hs
+  have heq : Finsupp.single s (x s) = x s • Finsupp.single s (1 : R) := by simp
+  rw [heq]
+  exact Submodule.smul_mem_smul (hcoef s) (Submodule.mem_top)
+
+include ha hmul in
+lemma projective_mem_radical_iff {P : Type v} [AddCommGroup P] [Module R P]
+    [Module.Projective R P] (x : P) :
+    x ∈ radicalPart (RingHom.ker χ.toRingHom) P ↔ ∀ i, a i • x = 0 := by
+  constructor
+  · exact fun hx i => annihilates_radical χ a hmul hx i
+  · intro hx
+    obtain ⟨s, hs⟩ := (Module.projective_def' (R := R) (P := P)).mp inferInstance
+    have hx' : s x ∈ radicalPart (RingHom.ker χ.toRingHom) (P →₀ R) :=
+      finsupp_mem_radical_of_annihilated χ a ha hmul (s x) (fun i => by
+        rw [← s.map_smul, hx i, map_zero])
+    have he : (Finsupp.linearCombination R id) (s x) = x := DFunLike.congr_fun hs x
+    rw [← he]
+    exact map_radical_le (RingHom.ker χ.toRingHom) (Finsupp.linearCombination R id)
+      (Submodule.mem_map_of_mem hx')
+
+include ha hmul in
+lemma projective_mono_reflects_radical {P : Type v} {Q : Type w}
+    [AddCommGroup P] [Module R P] [Module.Projective R P]
+    [AddCommGroup Q] [Module R Q]
+    (f : P →ₗ[R] Q) (hf : Function.Injective f) {x : P}
+    (hx : f x ∈ radicalPart (RingHom.ker χ.toRingHom) Q) :
+    x ∈ radicalPart (RingHom.ker χ.toRingHom) P := by
+  rw [projective_mem_radical_iff χ a ha hmul]
+  intro i
+  apply hf
+  rw [map_smul, map_zero]
+  exact annihilates_radical χ a hmul hx i
+
+include ha hmul in
+lemma projective_mono_splits [Finite ι]
+    (hχ : Function.Surjective χ) (hJ : ∃ n : ℕ, (RingHom.ker χ.toRingHom) ^ n = ⊥)
+    {P : Type v} {Q : Type w} [AddCommGroup P] [Module R P] [Module.Projective R P]
+    [AddCommGroup Q] [Module R Q] [Module.Projective R Q]
+    (f : P →ₗ[R] Q) (hf : Function.Injective f) :
+    ∃ g : Q →ₗ[R] P, g.comp f = LinearMap.id := by
+  let J := RingHom.ker χ.toRingHom
+  let p := radicalPart J P
+  let q := radicalPart J Q
+  let fbar : P ⧸ p →ₗ[R] Q ⧸ q := p.mapQ q f
+    (Submodule.map_le_iff_le_comap.mp (map_radical_le J f))
+  have hfbar : Function.Injective fbar := by
+    apply LinearMap.ker_eq_bot.mp
+    apply le_bot_iff.mp
+    intro x hx
+    obtain ⟨x, rfl⟩ := p.mkQ_surjective x
+    have hx' : f x ∈ q := (Submodule.Quotient.mk_eq_zero q).mp hx
+    exact (Submodule.Quotient.mk_eq_zero p).mpr
+      (projective_mono_reflects_radical χ a ha hmul f hf hx')
+  let : IsSemisimpleModule R (Q ⧸ q) := top_semisimple χ.toRingHom hχ Q
+  obtain ⟨gbar, hgbar⟩ := IsSemisimpleModule.extension_property fbar hfbar
+    (LinearMap.id : P ⧸ p →ₗ[R] P ⧸ p)
+  obtain ⟨g, hg⟩ := Module.projective_lifting_property p.mkQ (gbar.comp q.mkQ)
+    p.mkQ_surjective
+  have hnil : IsNilpotent (1 - g.comp f : Module.End R P) := by
+    apply isNilpotent_of_range_le_radical J hJ
+    rintro _ ⟨x, rfl⟩
+    apply (Submodule.Quotient.mk_eq_zero p).mp
+    change p.mkQ (x - g (f x)) = 0
+    rw [map_sub]
+    have hg' := DFunLike.congr_fun hg (f x)
+    have hgbar' := DFunLike.congr_fun hgbar (p.mkQ x)
+    change p.mkQ (g (f x)) = gbar (q.mkQ (f x)) at hg'
+    change gbar (q.mkQ (f x)) = p.mkQ x at hgbar'
+    rw [hg', hgbar', sub_self]
+  have hu : IsUnit (g.comp f) := by simpa using hnil.isUnit_one_sub
+  obtain ⟨u, hu⟩ := hu.exists_left_inv
+  refine ⟨u.comp g, ?_⟩
+  simpa only [Module.End.mul_eq_comp, Module.End.one_eq_id, LinearMap.comp_assoc] using hu
+
+end SplitBasic
+end Kasch
+end LittleFinitistic
+end
+end
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/FinitisticAsymmetry/Kasch/Radical.lean b/lean/OAI/Algebra/FinitisticAsymmetry/Kasch/Radical.lean
new file mode 100644
index 0000000000000000000000000000000000000000..3c153fd826747cff9ef723aecd0ebad1e2855000
--- /dev/null
+++ b/lean/OAI/Algebra/FinitisticAsymmetry/Kasch/Radical.lean
@@ -0,0 +1,60 @@
+import Mathlib
+import OAI.Algebra.FinitisticAsymmetry.Model
+
+namespace OAI
+
+section
+section
+noncomputable section
+open CategoryTheory
+namespace LittleFinitistic
+universe u
+variable (A : Type u) [Ring A]
+namespace Kasch
+
+universe v w
+variable {R : Type u} [Ring R]
+
+abbrev radicalPart (J : Ideal R) (M : Type v) [AddCommGroup M] [Module R M] :
+    Submodule R M := J • (⊤ : Submodule R M)
+
+lemma map_radical_le (J : Ideal R) {P : Type v} {Q : Type w}
+    [AddCommGroup P] [Module R P] [AddCommGroup Q] [Module R Q]
+    (f : P →ₗ[R] Q) : (radicalPart J P).map f ≤ radicalPart J Q := by
+  rw [radicalPart, Submodule.map_smul'']
+  exact Submodule.smul_mono le_rfl le_top
+
+lemma isNilpotent_of_range_le_radical {P : Type v} [AddCommGroup P] [Module R P]
+    (J : Ideal R) [J.IsTwoSided] (hJ : ∃ n : ℕ, J ^ n = ⊥)
+    (f : P →ₗ[R] P) (hf : LinearMap.range f ≤ radicalPart J P) : IsNilpotent f := by
+  have hn (n : ℕ) : LinearMap.range (f ^ n) ≤ J ^ n • (⊤ : Submodule R P) := by
+    induction n with
+    | zero => simp [Submodule.pow_zero, Ideal.one_eq_top]
+    | succ n ih =>
+      rw [pow_succ, Module.End.mul_eq_comp, LinearMap.range_comp]
+      apply le_trans (Submodule.map_mono hf)
+      rw [radicalPart, Submodule.map_smul'', Submodule.map_top]
+      apply le_trans (Submodule.smul_mono le_rfl ih)
+      rw [← Submodule.mul_smul, Ideal.IsTwoSided.pow_succ]
+  obtain ⟨n, hnil⟩ := hJ
+  refine ⟨n, ?_⟩
+  apply LinearMap.range_eq_bot.mp
+  apply le_bot_iff.mp
+  simpa [hnil] using hn n
+
+lemma top_semisimple {S : Type v} [Ring S] [IsSemisimpleRing S]
+    (χ : R →+* S) (hχ : Function.Surjective χ)
+    (M : Type w) [AddCommGroup M] [Module R M] :
+    IsSemisimpleModule R (M ⧸ radicalPart (RingHom.ker χ) M) := by
+  let : IsSemisimpleRing (R ⧸ (RingHom.ker χ)) :=
+    (χ.quotientKerEquivOfSurjective hχ).symm.isSemisimpleRing
+  exact (Module.isTorsionBySet_quotient_ideal_smul M (RingHom.ker χ)).isSemisimpleModule_iff.mp
+    inferInstance
+
+end Kasch
+end LittleFinitistic
+end
+end
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/FinitisticAsymmetry/Main.lean b/lean/OAI/Algebra/FinitisticAsymmetry/Main.lean
new file mode 100644
index 0000000000000000000000000000000000000000..80f71b7aaf2147e953e01e13b5119990296f9f5f
--- /dev/null
+++ b/lean/OAI/Algebra/FinitisticAsymmetry/Main.lean
@@ -0,0 +1,65 @@
+import Mathlib
+import OAI.Algebra.Finitistic.Main
+import OAI.Algebra.FinitisticAsymmetry.Transport.DiagramMaps
+import OAI.Algebra.FinitisticAsymmetry.Asymmetry
+import OAI.Algebra.FinitisticAsymmetry.Augmentation.Directed
+import OAI.Algebra.FinitisticAsymmetry.Augmentation.SplitBasic
+
+namespace OAI
+
+section
+noncomputable section
+open scoped TensorProduct
+namespace LittleFinitistic.SelectedBasic
+open SelectedOrdinaryAlgebra SelectedFixedDiagram QuadraticEncoding
+open OrdinarySimulation SplitBasic
+
+def baseSystem := ThreeVertexAlgebra.directedSystem (composition P)
+def chainSystem := ChainAlgebra.directedSystem ℂ length
+def tensorSystem := TensorDirected.directedSystem baseSystem chainSystem
+abbrev Vertices := Sum baseSystem.Vertices tensorSystem.Vertices
+
+def diagonalAugmentation : D →ₐ[ℂ] (Vertices → ℂ) :=
+  productAugmentation baseSystem.augmentation tensorSystem.augmentation
+lemma diagonal_surjective : Function.Surjective diagonalAugmentation :=
+  product_surjective _ _ baseSystem.augmentation_surjective tensorSystem.augmentation_surjective
+lemma diagonal_ker_nilpotent :
+    ∃ n : ℕ, (RingHom.ker diagonalAugmentation.toRingHom)^n = ⊥ :=
+  product_ker_nilpotent _ _ baseSystem.augmentation_ker_nilpotent tensorSystem.augmentation_ker_nilpotent
+
+def augmentationA : A →ₐ[ℂ] (Vertices → ℂ) :=
+  squareZeroAugmentation (M := X) diagonalAugmentation
+lemma augmentationA_surjective : Function.Surjective augmentationA :=
+  squareZero_surjective _ diagonal_surjective
+lemma augmentationA_ker_nilpotent :
+    ∃ n : ℕ, (RingHom.ker augmentationA.toRingHom)^n = ⊥ :=
+  squareZero_ker_nilpotent _ diagonal_ker_nilpotent
+
+def augmentationC : Aᵐᵒᵖ →ₐ[ℂ] (Vertices → ℂ) := oppositeAugmentation augmentationA
+lemma augmentationC_surjective : Function.Surjective augmentationC :=
+  opposite_surjective _ augmentationA_surjective
+lemma augmentationC_ker_nilpotent :
+    ∃ n : ℕ, (RingHom.ker augmentationC.toRingHom)^n = ⊥ :=
+  opposite_ker_nilpotent _ augmentationA_ker_nilpotent
+end LittleFinitistic.SelectedBasic
+
+namespace LittleFinitistic
+
+theorem extreme_left_right_asymmetry :
+    ∃ (Λ : Type) (_ : Ring Λ) (_ : Algebra ℂ Λ),
+      FiniteDimensional ℂ Λ ∧
+      littleFinitisticDimension Λ = ⊤ ∧ bigFinitisticDimension Λ = ⊤ ∧
+      littleFinitisticDimension Λᵐᵒᵖ = 0 ∧ bigFinitisticDimension Λᵐᵒᵖ = 0 ∧
+      ¬ InjectivesGenerate Λ ∧ InjectivesGenerate Λᵐᵒᵖ := by
+  classical
+  let Λ := AsymmetryConstruction.Lambda SelectedBasic.augmentationC
+  refine ⟨Λ, inferInstance, inferInstance, ?_⟩
+  exact AsymmetryConstruction.all_clauses SelectedBasic.augmentationC
+    SelectedBasic.augmentationC_surjective SelectedBasic.augmentationC_ker_nilpotent
+    Main.infinite_littleFinitisticDimension
+end LittleFinitistic
+
+end
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/FinitisticAsymmetry/Model.lean b/lean/OAI/Algebra/FinitisticAsymmetry/Model.lean
new file mode 100644
index 0000000000000000000000000000000000000000..f73a7f0c006a27e8abe422a1d7cfbcd78cd86a98
--- /dev/null
+++ b/lean/OAI/Algebra/FinitisticAsymmetry/Model.lean
@@ -0,0 +1,27 @@
+import Mathlib
+import OAI.Algebra.Finitistic.Basic
+
+namespace OAI
+
+noncomputable section
+open CategoryTheory
+namespace LittleFinitistic
+universe u
+variable (A : Type u) [Ring A]
+
+def bigFinitisticDimension : WithBot ℕ∞ :=
+  ⨆ (M : ModuleCat.{u} A) (_ : projectiveDimension M < ⊤), projectiveDimension M
+
+def InjectivesGenerate : Prop :=
+  letI := HasDerivedCategory.standard (ModuleCat.{u} A)
+  ∀ (P : ObjectProperty (DerivedCategory (ModuleCat.{u} A))),
+    P.IsClosedUnderIsomorphisms → P.IsTriangulated →
+    (∀ I : Type u, P.IsClosedUnderColimitsOfShape (Discrete I)) →
+    (∀ (M : ModuleCat.{u} A), Injective M →
+      P ((DerivedCategory.singleFunctor (ModuleCat.{u} A) 0).obj M)) →
+    ∀ X, P X
+
+end LittleFinitistic
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/FinitisticAsymmetry/Nakayama/Coinduction.lean b/lean/OAI/Algebra/FinitisticAsymmetry/Nakayama/Coinduction.lean
new file mode 100644
index 0000000000000000000000000000000000000000..48913a23f953fbb51732a512dfa052425d43e97f
--- /dev/null
+++ b/lean/OAI/Algebra/FinitisticAsymmetry/Nakayama/Coinduction.lean
@@ -0,0 +1,134 @@
+import Mathlib
+import OAI.Algebra.FinitisticAsymmetry.Nakayama.Modules
+import OAI.Algebra.FinitisticAsymmetry.Rickard.InjectiveSums
+
+namespace OAI
+
+noncomputable section
+
+open CategoryTheory CategoryTheory.Limits Module
+namespace LittleFinitistic.Nakayama
+universe u
+variable (k R : Type u) [Field k] [Ring R] [Algebra k R] [FiniteDimensional k R]
+
+lemma da_finite : Module.Finite R (DA k R) := by
+  let : Module.Finite k (DA k R) := Module.Finite.equiv (daEquiv k R).symm
+  exact Module.Finite.of_restrictScalars_finite k R _
+
+variable {k R}
+def coindLine (V : ModuleCat.{u} k) (v : V) : DA k R →ₗ[R] coind k R V :=
+  ((ModuleCat.coextendScalars (algebraMap k R)).map
+    (ModuleCat.ofHom ((LinearMap.id : k →ₗ[k] k).smulRight v))).hom
+
+omit [FiniteDimensional k R] in
+@[simp] lemma coindLine_apply (V : ModuleCat.{u} k) (v : V) (φ : DA k R) (r : R) :
+    coindLine V v φ r = φ r • v := rfl
+
+omit [FiniteDimensional k R] in
+@[simp] private lemma coind_zero_eval (V : ModuleCat.{u} k) (r : R) :
+    (0 : coind k R V) r = 0 := rfl
+
+omit [FiniteDimensional k R] in
+private lemma coind_sum_eval {J : Type*} (s : Finset J) (V : ModuleCat.{u} k)
+    (f : J → coind k R V) (r : R) :
+    (∑ j ∈ s, f j) r = ∑ j ∈ s, f j r := by
+  change (ModuleCat.CoextendScalars.equiv (algebraMap k R) V (∑ j ∈ s, f j)) r = _
+  rw [map_sum]
+  exact LinearMap.sum_apply _ _ _
+
+variable {ι : Type u}
+def coindBasisMap (V : ModuleCat.{u} k) (b : Basis ι k V) :
+    (Π₀ _ : ι, DA k R) →ₗ[R] coind k R V := by
+  classical
+  exact DFinsupp.lsum ℤ (fun i => coindLine V (b i))
+
+omit [FiniteDimensional k R] in
+lemma coindBasisMap_injective (V : ModuleCat.{u} k) (b : Basis ι k V) :
+    Function.Injective (coindBasisMap (R := R) V b) := by
+  classical
+  apply LinearMap.ker_eq_bot.mp
+  apply bot_unique
+  intro φ hφ
+  change φ = 0
+  apply DFinsupp.ext
+  intro i
+  apply ModuleCat.CoextendScalars.ext
+  apply LinearMap.ext
+  intro r
+  change R at r
+  change φ i r = 0
+  have h := congrArg (fun g : coind k R V => b.repr (g r) i) hφ
+  rw [coind_zero_eval, map_zero, Finsupp.zero_apply] at h
+  change coindBasisMap V b φ = 0 at hφ
+  have he : coindBasisMap V b φ r = ∑ j ∈ φ.support, φ j r • b j := by
+    have hexp : coindBasisMap V b φ = ∑ j ∈ φ.support, coindLine V (b j) (φ j) := by
+      simp [coindBasisMap, DFinsupp.lsum_apply_apply, DFinsupp.sumAddHom_apply, DFinsupp.sum]
+    rw [hexp, coind_sum_eval]
+    simp only [coindLine_apply]
+  rw [he] at h
+  simp only [map_sum, map_smul, b.repr_self, Finsupp.finsetSum_apply, Finsupp.smul_apply,
+    Finsupp.single_apply, smul_eq_mul, mul_ite, mul_one, mul_zero] at h
+  by_cases hi : i ∈ φ.support
+  · simpa [hi] using h
+  · have hh := DFinsupp.notMem_support_iff.mp hi
+    rw [hh]
+    rfl
+
+lemma coindBasisMap_surjective
+    (V : ModuleCat.{u} k) (b : Basis ι k V) :
+    Function.Surjective (coindBasisMap (R := R) V b) := by
+  classical
+  intro φ
+  let φ' : R →ₗ[k] V := {
+    toFun := φ
+    map_add' := φ.map_add
+    map_smul' := coind_smul_eval k R V φ }
+  let g : R →ₗ[k] Π₀ _ : ι, k := (finsuppLequivDFinsupp k).toLinearMap.comp
+    (b.repr.toLinearMap.comp φ')
+  obtain ⟨s, hs⟩ := Rickard.finite_support_map (R := k) (fun _ : ι => k) R g
+  let c (i : ι) : DA k R := (daEquiv k R).symm ((Finsupp.lapply i).comp
+    (b.repr.toLinearMap.comp φ'))
+  let x : Π₀ _ : ι, DA k R := ∑ i ∈ s, DFinsupp.single i (c i)
+  refine ⟨x, ?_⟩
+  apply LinearMap.ext
+  intro r
+  change R at r
+  change coindBasisMap V b x r = φ r
+  have he : coindBasisMap V b x r = ∑ i ∈ s, b.repr (φ r) i • b i := by
+    have hx : coindBasisMap V b x = ∑ i ∈ s, coindLine V (b i) (c i) := by
+      simp only [x, map_sum, coindBasisMap, DFinsupp.lsum_single]
+    rw [hx, coind_sum_eval]
+    apply Finset.sum_congr rfl
+    intro i hi
+    rfl
+  rw [he]
+  apply b.repr.injective
+  ext i
+  by_cases hi : i ∈ s
+  · simp [Finsupp.finsetSum_apply, Finsupp.single_apply, hi]
+  · have hh := hs r i hi
+    change b.repr (φ r) i = 0 at hh
+    simp [Finsupp.finsetSum_apply, Finsupp.single_apply, hi, hh]
+
+variable (k R)
+lemma coindBasisMap_bijective (V : ModuleCat.{u} k) (b : Basis ι k V) :
+    Function.Bijective (coindBasisMap (R := R) V b) :=
+  ⟨coindBasisMap_injective V b, coindBasisMap_surjective V b⟩
+
+def moduleCoindInclusion (M : ModuleCat.{u} R) :
+    M ⟶ coind k R ((ModuleCat.restrictScalars (algebraMap k R)).obj M) :=
+  (ModuleCat.restrictCoextendScalarsAdj (algebraMap k R)).unit.app M
+
+omit [FiniteDimensional k R] in
+lemma moduleCoindInclusion_mono (M : ModuleCat.{u} R) : Mono (moduleCoindInclusion k R M) := by
+  apply (ModuleCat.mono_iff_injective _).mpr
+  intro x y h
+  have hh := congrArg (fun g : coind k R ((ModuleCat.restrictScalars (algebraMap k R)).obj M) => g (1 : R)) h
+  change (1 : R) • x = (1 : R) • y at hh
+  simpa using hh
+
+end LittleFinitistic.Nakayama
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/FinitisticAsymmetry/Nakayama/Minimality.lean b/lean/OAI/Algebra/FinitisticAsymmetry/Nakayama/Minimality.lean
new file mode 100644
index 0000000000000000000000000000000000000000..fa5ad1bc44120ff8336aa9b8227a4fe6ede55e5a
--- /dev/null
+++ b/lean/OAI/Algebra/FinitisticAsymmetry/Nakayama/Minimality.lean
@@ -0,0 +1,81 @@
+import Mathlib
+import OAI.Algebra.Finitistic.Dimension.PDMinimalData
+import OAI.Algebra.FinitisticAsymmetry.Nakayama.Modules
+
+namespace OAI
+
+noncomputable section
+
+open CategoryTheory CategoryTheory.Limits
+namespace LittleFinitistic.Nakayama
+universe u
+variable {k R : Type u} [Field k] [Ring R] [Algebra k R]
+
+lemma split_of_dual_surjective {P Q : ModuleCat.{u} R} (F : Frame R P)
+    (d : P ⟶ Q) (h : Function.Surjective (LinearMap.lcomp k R d.hom)) :
+    ∃ s : Q ⟶ P, d ≫ s = 𝟙 P := by
+  classical
+  choose c hc using fun i => h (F.c i)
+  let s : Q →ₗ[R] P := ∑ i, (c i).smulRight (F.b i)
+  refine ⟨ModuleCat.ofHom s, ?_⟩
+  apply ModuleCat.hom_ext
+  ext x
+  change s (d x) = x
+  simp only [s, LinearMap.sum_apply, LinearMap.smulRight_apply]
+  have hh (i : Fin F.n) : c i (d x) = F.c i x := LinearMap.congr_fun (hc i) x
+  simp only [hh]
+  exact F.expand x
+
+lemma nakayama_map_not_injective {P Q : ModuleCat.{u} R}
+    [Module.Finite R P] [Module.Projective R P] [Nontrivial P]
+    (d : P ⟶ Q) (h : ¬ ∃ s : Q ⟶ P, d ≫ s = 𝟙 P) :
+    ¬ Function.Injective (map (k := k) d) := by
+  intro hd
+  apply h
+  obtain ⟨F⟩ := frame_nonempty R P
+  apply split_of_dual_surjective (k := k) F d
+  apply LinearMap.dualMap_injective_iff.mp
+  exact hd
+
+variable [FiniteDimensional k R]
+
+lemma minimal_differential_not_split (M : PDMinimal.FiniteModule k R) (n : ℕ)
+    [Nontrivial (PDMinimal.term M (n+1))] :
+    ¬ ∃ s : (PDMinimal.term M n).cat ⟶ (PDMinimal.term M (n+1)).cat,
+      ModuleCat.ofHom (PDMinimal.differential M n) ≫ s = 𝟙 _ := by
+  rintro ⟨s, hs⟩
+  let d := PDMinimal.differential M n
+  let e : PDMinimal.term M n →ₗ[R] PDMinimal.term M n := LinearMap.id - d.comp s.hom
+  have he : (PDMinimal.augment M n).comp e = PDMinimal.augment M n := by
+    ext x
+    change PDMinimal.augment M n (x - d (s x)) = PDMinimal.augment M n x
+    rw [map_sub]
+    have hh := LinearMap.congr_fun (PDMinimal.augment_differential M n) (s x)
+    change PDMinimal.augment M n (d (s x)) = 0 at hh
+    rw [hh, sub_zero]
+  have hes : Function.Surjective e := (PDMinimal.cover _).minimal e he
+  have hei : Function.Injective e :=
+    (LinearMap.injective_iff_surjective_of_finrank_eq_finrank (f := e.restrictScalars k) rfl).mpr hes
+  have hd (x : PDMinimal.term M (n+1)) : d x = 0 := by
+    have hh : s (d x) = x := ConcreteCategory.congr_hom hs x
+    apply hei
+    change d x - d (s (d x)) = 0 - d (s 0)
+    erw [hh, sub_self, map_zero, map_zero, sub_self]
+  have hz (x : PDMinimal.term M (n+1)) : x=0 := by
+    have hh : s (d x) = x := ConcreteCategory.congr_hom hs x
+    erw [hd, map_zero] at hh
+    exact hh.symm
+  obtain ⟨x,y,hxy⟩ := exists_pair_ne (PDMinimal.term M (n+1))
+  exact hxy ((hz x).trans (hz y).symm)
+
+lemma minimal_nakayama_differential_noninjective (M : PDMinimal.FiniteModule k R) (n : ℕ)
+    [Nontrivial (PDMinimal.term M (n+1))] :
+    ¬ Function.Injective (map (k := k) (ModuleCat.ofHom (PDMinimal.differential M n))) := by
+  apply nakayama_map_not_injective
+  exact minimal_differential_not_split M n
+
+end LittleFinitistic.Nakayama
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/FinitisticAsymmetry/Nakayama/Modules.lean b/lean/OAI/Algebra/FinitisticAsymmetry/Nakayama/Modules.lean
new file mode 100644
index 0000000000000000000000000000000000000000..fd7ef3bc2972b631300750cdbc1da3194214c00a
--- /dev/null
+++ b/lean/OAI/Algebra/FinitisticAsymmetry/Nakayama/Modules.lean
@@ -0,0 +1,325 @@
+import Mathlib
+import OAI.Algebra.FinitisticAsymmetry.Model
+
+namespace OAI
+
+noncomputable section
+
+open CategoryTheory CategoryTheory.Limits
+namespace LittleFinitistic.Nakayama
+universe u
+variable (k R : Type u) [Field k] [Ring R] [Algebra k R]
+
+abbrev rightMult (M : ModuleCat.{u} R) (r : R) : (M →ₗ[R] R) →ₗ[k] (M →ₗ[R] R) :=
+  LinearMap.compRight k (LinearMap.mulRight R r)
+
+@[simp] lemma rightMult_apply (M : ModuleCat.{u} R) (r : R) (f : M →ₗ[R] R) (x : M) :
+    rightMult k R M r f x = f x * r := rfl
+
+def Object (M : ModuleCat.{u} R) := Module.Dual k (M →ₗ[R] R)
+
+namespace Object
+variable {k R}
+def value {M : ModuleCat.{u} R} (x : Object k R M) : Module.Dual k (M →ₗ[R] R) := x
+instance (M : ModuleCat.{u} R) : AddCommGroup (Object k R M) := inferInstanceAs (AddCommGroup (Module.Dual k (M →ₗ[R] R)))
+instance (M : ModuleCat.{u} R) : Module k (Object k R M) := inferInstanceAs (Module k (Module.Dual k (M →ₗ[R] R)))
+@[ext] lemma ext {M : ModuleCat.{u} R} {x y : Object k R M} (h : ∀ f, value x f = value y f) : x = y := LinearMap.ext h
+instance (M : ModuleCat.{u} R) : Module R (Object k R M) where
+  smul r f := (value f).comp (rightMult k R M r)
+  one_smul f := by
+    ext g
+    change (value f) (rightMult k R M 1 g) = (value f) g
+    congr 1
+    ext x
+    exact mul_one _
+  mul_smul r s f := by
+    ext g
+    change (value f) ((rightMult k R M (r*s)) g) =
+      (value f) (rightMult k R M s (rightMult k R M r g))
+    congr 1
+    ext x
+    simp [mul_assoc]
+  smul_zero r := by ext g; rfl
+  smul_add r f g := by ext h; rfl
+  zero_smul f := by
+    ext g
+    change (value f) (rightMult k R M 0 g) = 0
+    have : rightMult k R M 0 g = 0 := by ext x; exact mul_zero _
+    rw [this, map_zero]
+  add_smul r s f := by
+    ext g
+    change (value f) (rightMult k R M (r+s) g) =
+      (value f) (rightMult k R M r g) + (value f) (rightMult k R M s g)
+    rw [← map_add]
+    congr 1
+    ext x
+    simp [mul_add]
+
+instance (M : ModuleCat.{u} R) : SMulCommClass R k (Object k R M) where
+  smul_comm r a f := by ext g; rfl
+instance (M : ModuleCat.{u} R) : IsScalarTower k R (Object k R M) where
+  smul_assoc a r f := by
+    ext g
+    change (value f) (rightMult k R M (a • r) g) = a • (value f) (rightMult k R M r g)
+    rw [← map_smul]
+    congr 1
+    ext x
+    exact mul_smul_comm _ _ _
+end Object
+
+variable {k R}
+def map {M N : ModuleCat.{u} R} (f : M ⟶ N) : Object k R M →ₗ[R] Object k R N where
+  toFun h := (Object.value h).comp (LinearMap.lcomp k R f.hom)
+  map_add' _ _ := rfl
+  map_smul' r h := by
+    ext g
+    change (Object.value h) (rightMult k R M r ((LinearMap.lcomp k R f.hom) g)) =
+      (Object.value h) ((LinearMap.lcomp k R f.hom) (rightMult k R N r g))
+    rfl
+
+variable (k R)
+def functor : ModuleCat.{u} R ⥤ ModuleCat.{u} R where
+  obj M := ModuleCat.of R (Object k R M)
+  map f := ModuleCat.ofHom (map f)
+  map_id M := by ext h g; rfl
+  map_comp f g := by ext h φ; rfl
+instance : (functor k R).Additive where
+  map_add := by
+    intro M N f g
+    apply ModuleCat.hom_ext
+    apply LinearMap.ext
+    intro h
+    apply Object.ext
+    intro φ
+    change (Object.value h) ((LinearMap.lcomp k R (f+g).hom) φ) =
+      (Object.value h) ((LinearMap.lcomp k R f.hom) φ) +
+      (Object.value h) ((LinearMap.lcomp k R g.hom) φ)
+    rw [← map_add]
+    congr 1
+    ext x
+    exact map_add φ _ _
+
+abbrev coind (V : ModuleCat.{u} k) :=
+  (ModuleCat.coextendScalars (algebraMap k R)).obj V
+
+instance coind_modulek (V : ModuleCat.{u} k) : Module k (coind k R V) :=
+  inferInstanceAs (Module k ((ModuleCat.restrictScalars (algebraMap k R)).obj
+    (ModuleCat.of R R) →ₗ[k] V))
+
+instance coind_tower (V : ModuleCat.{u} k) : IsScalarTower k R (coind k R V) where
+  smul_assoc a r h := by
+    apply ModuleCat.CoextendScalars.ext
+    apply LinearMap.ext
+    intro x
+    change R at x
+    change h (x * (a • r)) = a • h (x*r)
+    rw [mul_smul_comm]
+    rw [Algebra.smul_def]
+    exact h.map_smul a (x*r)
+
+instance coind_comm (V : ModuleCat.{u} k) : SMulCommClass R k (coind k R V) where
+  smul_comm _ _ _ := rfl
+
+lemma field_injective (V : ModuleCat.{u} k) : Injective V where
+  factors {X Y} g f hf := by
+    obtain ⟨s, hs⟩ := f.hom.exists_leftInverse_of_injective
+      (LinearMap.ker_eq_bot.mpr ((ModuleCat.mono_iff_injective f).mp hf))
+    refine ⟨ModuleCat.ofHom (g.hom.comp s), ?_⟩
+    apply ModuleCat.hom_ext
+    change g.hom.comp (s.comp f.hom) = g.hom
+    rw [hs, LinearMap.comp_id]
+
+instance coind_injective (V : ModuleCat.{u} k) : Injective (coind k R V) :=
+  (ModuleCat.restrictCoextendScalarsAdj (algebraMap k R)).map_injective _
+    (field_injective k V)
+
+abbrev DA := coind k R (ModuleCat.of k k)
+
+def daEquiv : DA k R ≃ₗ[k] Module.Dual k R where
+  toFun h := {
+    toFun := h
+    map_add' := h.map_add
+    map_smul' a r := by
+      rw [Algebra.smul_def]
+      exact h.map_smul a r }
+  invFun h := {
+    toFun := h
+    map_add' := h.map_add
+    map_smul' a r := by
+      change R at r
+      change h (algebraMap k R a * r) = a • h r
+      rw [← Algebra.smul_def]
+      exact h.map_smul a r }
+  left_inv h := rfl
+  right_inv h := rfl
+  map_add' f g := rfl
+  map_smul' a h := rfl
+
+def etaMap (M : ModuleCat.{u} R) (p : M) : DA k R →ₗ[R] Object k R M where
+  toFun h := (daEquiv k R h).comp (LinearMap.applyₗ' k p)
+  map_add' h g := rfl
+  map_smul' r h := by
+    apply Object.ext
+    intro φ
+    change h (φ p * r) = h (φ p * r)
+    rfl
+
+@[simp] lemma etaMap_apply (M : ModuleCat.{u} R) (p : M) (h : DA k R)
+    (φ : M →ₗ[R] R) : Object.value (etaMap k R M p h) φ = h (φ p) := rfl
+
+lemma eta_natural {M N : ModuleCat.{u} R} (f : M ⟶ N) (p : M) :
+    (map f).comp (etaMap k R M p) = etaMap k R N (f p) := by rfl
+
+structure Frame (M : ModuleCat.{u} R) where
+  n : ℕ
+  b : Fin n → M
+  c : Fin n → (M →ₗ[R] R)
+  expand : ∀ x, ∑ i, c i x • b i = x
+
+lemma frame_nonempty (M : ModuleCat.{u} R) [Module.Finite R M] [Module.Projective R M] :
+    Nonempty (Frame R M) := by
+  classical
+  obtain ⟨n, f, g, _, _, hfg⟩ := Module.Finite.exists_comp_eq_id_of_projective R M
+  refine ⟨⟨n, fun i => f (Pi.single i 1), fun i => (LinearMap.proj i).comp g, ?_⟩⟩
+  intro x
+  simp only [LinearMap.comp_apply, LinearMap.proj_apply, ← map_smul, ← map_sum]
+  have he : ∑ i : Fin n, g x i • Pi.single i (1 : R) = g x := by
+    ext j
+    simp [Pi.single_apply, smul_eq_mul]
+  rw [he]
+  exact LinearMap.congr_fun hfg x
+
+variable {k R}
+lemma Frame.dual_expand {M : ModuleCat.{u} R} (F : Frame R M) (φ : M →ₗ[R] R) :
+    ∑ i, rightMult k R M (φ (F.b i)) (F.c i) = φ := by
+  apply LinearMap.ext
+  intro x
+  simpa only [LinearMap.sum_apply, rightMult_apply, map_sum, map_smul,
+    smul_eq_mul] using congrArg φ (F.expand x)
+
+variable (k R)
+lemma eta_injective [FiniteDimensional k R] (M : ModuleCat.{u} R)
+    (F : Frame R M) : Function.Injective (etaMap k R M) := by
+  intro x y h
+  have hxy (i : Fin F.n) : F.c i x = F.c i y := by
+    apply (Module.evalEquiv k R).injective
+    apply LinearMap.ext
+    intro φ
+    exact congrArg (fun f : DA k R →ₗ[R] Object k R M =>
+      Object.value (f ((daEquiv k R).symm φ)) (F.c i)) h
+  rw [← F.expand x, ← F.expand y]
+  simp only [hxy]
+
+lemma eta_surjective [FiniteDimensional k R] (M : ModuleCat.{u} R)
+    (F : Frame R M) : Function.Surjective (etaMap k R M) := by
+  classical
+  intro f
+  let p : Fin F.n → R := fun i => (Module.evalEquiv k R).symm (
+    (LinearMap.applyₗ' k (F.c i)).comp
+      ((f.restrictScalars k).comp (daEquiv k R).symm.toLinearMap))
+  have hp (i : Fin F.n) (h : DA k R) : h (p i) = Object.value (f h) (F.c i) := by
+    change (daEquiv k R h) (p i) = _
+    dsimp only [p]
+    rw [Module.apply_evalEquiv_symm_apply]
+    change Object.value (f ((daEquiv k R).symm (daEquiv k R h))) (F.c i) = _
+    rw [LinearEquiv.symm_apply_apply]
+
+  refine ⟨∑ i, p i • F.b i, ?_⟩
+  apply LinearMap.ext
+  intro h
+  apply Object.ext
+  intro φ
+  change h (φ (∑ i, p i • F.b i)) = Object.value (f h) φ
+  calc
+    h (φ (∑ i, p i • F.b i)) = ∑ i, h (p i * φ (F.b i)) := by
+      change (daEquiv k R h) (φ (∑ i, p i • F.b i)) = _
+      simp only [map_sum, map_smul, smul_eq_mul]
+      rfl
+    _ = ∑ i, Object.value (f h) (rightMult k R M (φ (F.b i)) (F.c i)) := by
+      apply Finset.sum_congr rfl
+      intro i _
+      rw [show h (p i * φ (F.b i)) =
+        (φ (F.b i) • h : DA k R) (p i) from rfl, hp]
+      rw [map_smul]
+      rfl
+    _ = Object.value (f h) φ := by rw [← map_sum, F.dual_expand]
+
+lemma coind_smul_eval (V : ModuleCat.{u} k) (g : coind k R V) (a : k) (r : R) :
+    g (a • r) = a • g r := by
+  rw [Algebra.smul_def]
+  exact g.map_smul a r
+
+lemma coind_add_eval (V : ModuleCat.{u} k) (g : coind k R V) (r s : R) :
+    g (r+s) = g r + g s := g.map_add r s
+
+def coindInclusion (M : ModuleCat.{u} R) :
+    (functor k R).obj M ⟶ coind k R (ModuleCat.of k (Object k R M)) :=
+  ModuleCat.ofHom {
+    toFun := fun h => {
+      toFun := fun r => (show R from r) • h
+      map_add' := fun r s => add_smul _ _ _
+      map_smul' := fun a r => by
+        change R at r
+        change (algebraMap k R a * r) • h = a • (r • h)
+        rw [← Algebra.smul_def, smul_assoc] }
+    map_add' := fun h g => by
+      apply LinearMap.ext
+      intro r
+      exact smul_add _ _ _
+    map_smul' := fun r h => by
+      apply LinearMap.ext
+      intro s
+      exact (mul_smul (show R from s) r h).symm }
+
+def coindRetraction (M : ModuleCat.{u} R) (F : Frame R M) :
+    coind k R (ModuleCat.of k (Object k R M)) ⟶ (functor k R).obj M :=
+  ModuleCat.ofHom {
+    toFun := fun g => {
+      toFun := fun φ => ∑ i, Object.value (g (φ (F.b i))) (F.c i)
+      map_add' := fun φ ψ => by
+        change ∑ i, Object.value (g ((φ+ψ) (F.b i))) (F.c i) = _
+        have hg (r s : R) : g (r+s) = g r + g s := g.map_add r s
+        simp only [LinearMap.add_apply, hg]
+        change ∑ i, (Object.value (g (φ (F.b i))) (F.c i) +
+          Object.value (g (ψ (F.b i))) (F.c i)) = _
+        exact Finset.sum_add_distrib
+      map_smul' := fun a φ => by
+        change ∑ i, Object.value (g ((a • φ) (F.b i))) (F.c i) =
+          a • (∑ i, Object.value (g (φ (F.b i))) (F.c i))
+        rw [Finset.smul_sum]
+        apply Finset.sum_congr rfl
+        intro i _
+        exact congrArg (fun x : Object k R M => Object.value x (F.c i))
+          (coind_smul_eval k R (ModuleCat.of k (Object k R M)) g a (φ (F.b i))) }
+    map_add' := fun g h => by
+      apply Object.ext
+      intro φ
+      change ∑ i, (Object.value (g (φ (F.b i))) (F.c i) +
+        Object.value (h (φ (F.b i))) (F.c i)) = _
+      exact Finset.sum_add_distrib
+    map_smul' := fun r g => by
+      apply Object.ext
+      intro φ
+      rfl }
+
+lemma coindInclusion_retraction (M : ModuleCat.{u} R) (F : Frame R M) :
+    coindInclusion k R M ≫ coindRetraction k R M F = 𝟙 _ := by
+  apply ModuleCat.hom_ext
+  apply LinearMap.ext
+  intro h
+  apply Object.ext
+  intro φ
+  change ∑ i, Object.value h (rightMult k R M (φ (F.b i)) (F.c i)) = Object.value h φ
+  rw [← map_sum, F.dual_expand]
+
+lemma object_injective (M : ModuleCat.{u} R) [Module.Finite R M] [Module.Projective R M] :
+    Injective ((functor k R).obj M) := by
+  obtain ⟨F⟩ := frame_nonempty R M
+  exact (show Retract ((functor k R).obj M) (coind k R (ModuleCat.of k (Object k R M))) from
+    ⟨coindInclusion k R M, coindRetraction k R M F, coindInclusion_retraction k R M F⟩).injective
+
+end LittleFinitistic.Nakayama
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/FinitisticAsymmetry/Rickard/FiniteFamilies.lean b/lean/OAI/Algebra/FinitisticAsymmetry/Rickard/FiniteFamilies.lean
new file mode 100644
index 0000000000000000000000000000000000000000..2b75855caa9e199037abc709fc7ccbe8d60410ba
--- /dev/null
+++ b/lean/OAI/Algebra/FinitisticAsymmetry/Rickard/FiniteFamilies.lean
@@ -0,0 +1,57 @@
+import Mathlib
+import OAI.Algebra.FinitisticAsymmetry.Model
+import OAI.Algebra.Finitistic.Dimension.PDDimension
+
+namespace OAI
+
+noncomputable section
+
+open CategoryTheory CategoryTheory.Limits
+namespace LittleFinitistic.Rickard
+universe u
+variable {k R : Type u} [Field k] [Ring R] [Algebra k R] [FiniteDimensional k R]
+
+lemma exists_finite_module_high_pd (h : littleFinitisticDimension R = ⊤) (i : ℕ) :
+    ∃ M : PDMinimal.FiniteModule k R,
+      (i : WithBot ℕ∞) < projectiveDimension M.cat ∧ projectiveDimension M.cat < ⊤ := by
+  have hi : (i : WithBot ℕ∞) < littleFinitisticDimension R := by
+    rw [h]
+    exact WithBot.coe_lt_coe.mpr (ENat.natCast_lt_top i)
+  simp only [littleFinitisticDimension, lt_iSup_iff] at hi
+  obtain ⟨M, hfg, hpd, hgt⟩ := hi
+  let := hfg
+  let : Module k M := Module.compHom M (algebraMap k R)
+  let : IsScalarTower k R M := IsScalarTower.of_compHom k R M
+  let : FiniteDimensional k M := Module.Finite.trans R M
+  exact ⟨PDMinimal.FiniteModule.of (k := k) (A := R) M, hgt, hpd⟩
+
+lemma exists_minimal_family (h : littleFinitisticDimension R = ⊤) :
+    ∃ (M : ℕ → PDMinimal.FiniteModule k R) (d : ℕ → ℕ),
+      (∀ i, i < d i) ∧
+      (∀ i, HasProjectiveDimensionLE (M i).cat (d i)) ∧
+      (∀ i, ¬ Subsingleton (PDMinimal.term (M i) (d i))) := by
+  classical
+  choose M hgt hfin using exists_finite_module_high_pd (k := k) h
+  have hb (i : ℕ) : ∃ d, HasProjectiveDimensionLE (M i).cat d :=
+    (projectiveDimension_ne_top_iff _).mp (hfin i).ne
+  let d := fun i => Nat.find (hb i)
+  have hd (i : ℕ) : HasProjectiveDimensionLE (M i).cat (d i) := Nat.find_spec (hb i)
+  have hdi (i : ℕ) : i < d i := by
+    have hp := (projectiveDimension_le_iff _ _).mpr (hd i)
+    have hlt := (hgt i).trans_le hp
+    exact_mod_cast hlt
+  refine ⟨M, d, hdi, hd, ?_⟩
+  intro i hz
+  have hpos := hdi i
+  obtain ⟨n, hn⟩ := Nat.exists_eq_succ_of_ne_zero (by omega : d i ≠ 0)
+  have hh : HasProjectiveDimensionLE (M i).cat n :=
+    (PDMinimal.pdLE_iff_term_zero (M i) n).mpr (by simpa [hn] using hz)
+  have hm := Nat.find_min' (hb i) hh
+  change d i ≤ n at hm
+  omega
+
+end LittleFinitistic.Rickard
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/FinitisticAsymmetry/Rickard/InjectiveSums.lean b/lean/OAI/Algebra/FinitisticAsymmetry/Rickard/InjectiveSums.lean
new file mode 100644
index 0000000000000000000000000000000000000000..02573c08af2f9d8e6f925bd3476361ba62f48db2
--- /dev/null
+++ b/lean/OAI/Algebra/FinitisticAsymmetry/Rickard/InjectiveSums.lean
@@ -0,0 +1,76 @@
+import Mathlib
+import OAI.Algebra.FinitisticAsymmetry.Model
+
+namespace OAI
+
+noncomputable section
+
+open CategoryTheory CategoryTheory.Limits
+namespace LittleFinitistic.Rickard
+universe u v
+variable {R : Type u} [Ring R] {ι : Type v}
+variable (Q : ι → Type u) [∀ i, AddCommGroup (Q i)] [∀ i, Module R (Q i)]
+
+lemma finite_support_map (M : Type u) [AddCommGroup M] [Module R M] [Module.Finite R M]
+    (g : M →ₗ[R] Π₀ i, Q i) : ∃ s : Finset ι, ∀ x i, i ∉ s → g x i = 0 := by
+  classical
+  obtain ⟨n, f, hf⟩ := Module.Finite.exists_fin' R M
+  let s := Finset.univ.biUnion (fun j : Fin n => (g (f (Pi.single j 1))).support)
+  refine ⟨s, ?_⟩
+  intro x i hi
+  obtain ⟨v, rfl⟩ := hf x
+  have hv : ∑ j : Fin n, v j • Pi.single j (1 : R) = v := by
+    ext j
+    simp [Pi.single_apply, smul_eq_mul]
+  have hz (j : Fin n) : (g (f (Pi.single j 1))) i = 0 := by
+    apply DFinsupp.notMem_support_iff.mp
+    intro h
+    apply hi
+    exact Finset.mem_biUnion.mpr ⟨j, Finset.mem_univ _, h⟩
+  rw [← hv, map_sum, map_sum]
+  change (DFinsupp.lapply (R := R) i) (∑ j, g (f (v j • Pi.single j 1))) = 0
+  rw [map_sum]
+  simp only [map_smul, DFinsupp.lapply_apply, hz, smul_zero, Finset.sum_const_zero]
+
+lemma dfinsupp_injective [IsNoetherianRing R] [∀ i, Module.Injective R (Q i)] :
+    Module.Injective R (Π₀ i, Q i) := by
+  classical
+  apply Module.Baer.injective
+  intro I g
+  obtain ⟨s, hs⟩ := finite_support_map Q I g
+  have he (i : ι) : ∃ f : R →ₗ[R] Q i, ∀ (x : R) (hx : x ∈ I),
+      f x = g ⟨x,hx⟩ i :=
+    Module.Baer.of_injective (inferInstance : Module.Injective R (Q i)) I
+      ((DFinsupp.lapply i).comp g)
+  choose f hf using he
+  refine ⟨∑ i ∈ s, (DFinsupp.lsingle i).comp (f i), ?_⟩
+  intro x hx
+  apply DFinsupp.ext
+  intro j
+  simp only [LinearMap.sum_apply, LinearMap.comp_apply, DFinsupp.lsingle_apply]
+  by_cases hj : j ∈ s
+  · simpa [DFinsupp.single_apply, hj] using hf j x hx
+  · simp [DFinsupp.single_apply, hj, hs _ _ hj]
+
+lemma dfinsupp_injective_object [IsNoetherianRing R]
+    (hQ : ∀ i, Injective (ModuleCat.of R (Q i))) :
+    Injective (ModuleCat.of R (Π₀ i, Q i)) := by
+  let (index : ι) : Module.Injective R (Q index) :=
+    (Module.injective_iff_injective_object R (Q index)).mpr (hQ index)
+  let := dfinsupp_injective (R := R) Q
+  exact Module.injective_object_of_injective_module R _
+
+lemma prod_injective (M N : Type u) [AddCommGroup M] [AddCommGroup N]
+    [Module R M] [Module R N] [Module.Injective R M] [Module.Injective R N] :
+    Module.Injective R (M × N) := by
+  constructor
+  intro X Y _ _ _ _ f hf g
+  obtain ⟨a, ha⟩ := Module.Injective.out f hf ((LinearMap.fst R M N).comp g)
+  obtain ⟨b, hb⟩ := Module.Injective.out f hf ((LinearMap.snd R M N).comp g)
+  exact ⟨a.prod b, fun x => Prod.ext (ha x) (hb x)⟩
+
+end LittleFinitistic.Rickard
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/FinitisticAsymmetry/Rickard/NonGeneration.lean b/lean/OAI/Algebra/FinitisticAsymmetry/Rickard/NonGeneration.lean
new file mode 100644
index 0000000000000000000000000000000000000000..45d66f67a399a782f2bbb62975a720592280636e
--- /dev/null
+++ b/lean/OAI/Algebra/FinitisticAsymmetry/Rickard/NonGeneration.lean
@@ -0,0 +1,129 @@
+import Mathlib
+import OAI.Algebra.FinitisticAsymmetry.Derived.ModuleGeneration
+import OAI.Algebra.FinitisticAsymmetry.Rickard.Orthogonal
+import OAI.Algebra.FinitisticAsymmetry.Rickard.ResolutionFamily
+import OAI.Algebra.FinitisticAsymmetry.Nakayama.Coinduction
+import OAI.Algebra.FinitisticAsymmetry.Rickard.ReducedProducts
+import OAI.Algebra.FinitisticAsymmetry.Rickard.OrthogonalStalks
+import OAI.Algebra.FinitisticAsymmetry.Rickard.FiniteFamilies
+
+namespace OAI
+
+noncomputable section
+
+open CategoryTheory CategoryTheory.Limits
+namespace LittleFinitistic.Rickard
+universe u
+variable {k R : Type u} [Field k] [Ring R] [Algebra k R] [FiniteDimensional k R]
+local instance nonGenerationHasDerivedCategory : HasDerivedCategory (ModuleCat.{u} R) :=
+  HasDerivedCategory.standard _
+
+lemma prop_injective_of_da
+    (P : ObjectProperty (DerivedCategory (ModuleCat.{u} R)))
+    [P.IsClosedUnderIsomorphisms] [P.IsTriangulated]
+    (hcop : ∀ I : Type u, P.IsClosedUnderColimitsOfShape (Discrete I))
+    (hD : P ((DerivedCategory.singleFunctor _ 0).obj (Nakayama.DA k R)))
+    (M : ModuleCat.{u} R) [Injective M] :
+    P ((DerivedCategory.singleFunctor _ 0).obj M) := by
+  classical
+  let V := (ModuleCat.restrictScalars (algebraMap k R)).obj M
+  let b := Module.Free.chooseBasis k V
+  let S := ModuleCat.of R (Π₀ _ : Module.Free.ChooseBasisIndex k V, Nakayama.DA k R)
+  let cs : Cofan (fun _ : Module.Free.ChooseBasisIndex k V => Nakayama.DA k R) :=
+    Cofan.mk S (fun i => ModuleCat.ofHom (DFinsupp.lsingle (R := R) (M := fun _ : Module.Free.ChooseBasisIndex k V => Nakayama.DA k R) i))
+  have hc : IsColimit cs := by
+    refine Cofan.IsColimit.mk _
+      (fun t => ModuleCat.ofHom (DFinsupp.lsum ℤ (fun i => (t.inj i).hom))) ?_ ?_
+    · intro t i
+      ext x
+      change (DFinsupp.lsum ℤ (fun i => (t.inj i).hom)) (DFinsupp.single i x) = (t.inj i).hom x
+      simp only [DFinsupp.lsum_single]
+    · intro t f hf
+      apply ModuleCat.hom_ext
+      apply DFinsupp.lhom_ext'
+      intro i
+      apply LinearMap.ext
+      intro x
+      have hh := ConcreteCategory.congr_hom (hf i) x
+      change f.hom (DFinsupp.single i x) =
+        (DFinsupp.lsum ℤ (fun i => (t.inj i).hom)) (DFinsupp.single i x)
+      rw [DFinsupp.lsum_single]
+      exact hh
+  let := hcop (ULift.{u} ℕ)
+  let : P.IsClosedUnderColimitsOfShape (Discrete ℕ) :=
+    ObjectProperty.IsClosedUnderColimitsOfShape.of_equivalence
+      (Discrete.equivalence (Equiv.ulift : ULift.{u} ℕ ≃ ℕ))
+  let := hcop (Module.Free.ChooseBasisIndex k V)
+  have hS : P ((DerivedCategory.singleFunctor _ 0).obj S) :=
+    DerivedSupport.prop_single_of_cofan P cs hc (fun _ => hD)
+  let e : S ≅ Nakayama.coind k R V :=
+    (LinearEquiv.ofBijective (Nakayama.coindBasisMap V b)
+      (Nakayama.coindBasisMap_bijective k R V b)).toModuleIso
+  have hC : P ((DerivedCategory.singleFunctor _ 0).obj (Nakayama.coind k R V)) :=
+    P.prop_of_iso ((DerivedCategory.singleFunctor _ 0).mapIso e) hS
+  let j := Nakayama.moduleCoindInclusion k R M
+  let : Mono j := Nakayama.moduleCoindInclusion_mono k R M
+  let p := Injective.factorThru (𝟙 M) j
+  have hjp : j ≫ p = 𝟙 M := Injective.comp_factorThru (𝟙 M) j
+  let F := DerivedCategory.singleFunctor (ModuleCat R) 0
+  exact DerivedSupport.localizing_of_retract (F.map j) (F.map p)
+    (by rw [← F.map_comp, hjp, F.map_id]) P hC
+
+lemma not_generate_of_minimal_family (M : ℕ → PDMinimal.FiniteModule k R)
+    (d : ℕ → ℕ) (hd : ∀ i, i < d i)
+    (hpd : ∀ i, HasProjectiveDimensionLE (M i).cat (d i))
+    (hlast : ∀ i, ¬ Subsingleton (PDMinimal.term (M i) (d i))) :
+    ¬ InjectivesGenerate R := by
+  classical
+  let K := fun i => nakayamaComplex k (translatedResolution (M i) (d i))
+  let L := reducedComplex K
+  have hkzero : ∀ i j, j < 0 → IsZero ((K i).X j) := fun i j hj =>
+    nakayamaComplex_zero k _ j (translatedResolution_zero_negative (M i) (d i) (hpd i) j hj)
+  have hknon : ∀ i, ∃ x : (K i).X 0, x ≠ 0 ∧ (K i).d 0 1 x = 0 := fun i =>
+    translated_nakayama_zero_cycle k (M i) (d i) (by have := hd i; omega) (hlast i)
+  have hkinj : ∀ i j, Injective ((K i).X j) := fun i j =>
+    nakayamaComplex_injective k _ (translatedResolution_finite (M i) (d i))
+      (translatedResolution_projective (M i) (d i)) j
+  let : IsNoetherianRing R := IsNoetherianRing.of_finite k R
+  let (j : ℤ) : Injective (L.X j) := reducedComplex_injective K hkinj j
+  let : L.IsStrictlyGE (-1) := reduced_isStrictlyGE K hkzero
+  let : L.IsKInjective := CochainComplex.isKInjective_of_injective L (-1)
+  have hnon : ¬ IsZero (DerivedCategory.Q.obj L) :=
+    not_isZero_Q_of_not_exact_zero L (reduced_not_exact_zero K hkzero hknon)
+  let : Module.Finite R (Nakayama.DA k R) := Nakayama.da_finite k R
+  have hex (j : ℤ) (f : Nakayama.DA k R ⟶ L.X j) (hf : f ≫ L.d j (j+1) = 0) :
+      ∃ g : Nakayama.DA k R ⟶ L.X (j-1), g ≫ L.d (j-1) j = f := by
+    have he : ∃ s : Finset ℕ, ∀ i ∉ s, ∀ f : Nakayama.DA k R ⟶ (K i).X (j-1+1),
+        f ≫ (K i).d (j-1+1) (j-1+1+1) = 0 →
+        ∃ g : Nakayama.DA k R ⟶ (K i).X (j-1), g ≫ (K i).d (j-1) (j-1+1) = f := by
+      refine ⟨Finset.range (j.toNat+1), ?_⟩
+      intro i hi f hf
+      apply nakayamaComplex_hom_exact k _ (translatedResolution_finite (M i) (d i))
+        (translatedResolution_projective (M i) (d i)) (j-1) _ f hf
+      apply translatedResolution_exact
+      have hdi := hd i
+      simp only [Finset.mem_range, not_lt] at hi
+      omega
+    have hh := reduced_hom_exact K (Nakayama.DA k R) (j-1) he
+    rw [sub_add_cancel] at hh
+    exact hh f hf
+  apply not_generate_of_orthogonal (DerivedCategory.Q.obj L) hnon
+  intro N hN
+  let := hN
+  apply (perpendicular_iff (DerivedCategory.Q.obj L) _).mp
+  apply prop_injective_of_da (k := k) (perpendicular (DerivedCategory.Q.obj L))
+    (fun I => inferInstance) _ N
+  apply (perpendicular_iff _ _).mpr
+  exact orthogonal_single_of_hom_exact _ L hex
+
+lemma not_injectivesGenerate_of_little_eq_top (k : Type u) [Field k] [Algebra k R]
+    [FiniteDimensional k R]
+    (h : littleFinitisticDimension R = ⊤) : ¬ InjectivesGenerate R := by
+  obtain ⟨M, d, hd, hpd, hterm⟩ := exists_minimal_family (k := k) h
+  exact not_generate_of_minimal_family M d hd hpd hterm
+
+end LittleFinitistic.Rickard
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/FinitisticAsymmetry/Rickard/Orthogonal.lean b/lean/OAI/Algebra/FinitisticAsymmetry/Rickard/Orthogonal.lean
new file mode 100644
index 0000000000000000000000000000000000000000..a67b1808895df51275a751e307417da6c3f0c961
--- /dev/null
+++ b/lean/OAI/Algebra/FinitisticAsymmetry/Rickard/Orthogonal.lean
@@ -0,0 +1,79 @@
+import Mathlib
+import OAI.Algebra.FinitisticAsymmetry.Model
+
+namespace OAI
+
+noncomputable section
+
+open CategoryTheory CategoryTheory.Limits CategoryTheory.Pretriangulated
+namespace LittleFinitistic.Rickard
+universe u v t
+variable {C : Type u} [Category.{v} C]
+
+lemma leftOrthogonal_closed [HasZeroMorphisms C] (P : ObjectProperty C) (J : Type t) [Category J] :
+    P.leftOrthogonal.IsClosedUnderColimitsOfShape J := by
+  apply ObjectProperty.IsClosedUnderColimitsOfShape.mk'
+  rintro _ ⟨F, hF⟩ Y f hY
+  apply colimit.hom_ext
+  intro j
+  simpa using hF j (colimit.ι F j ≫ f) hY
+
+section
+variable [HasZeroObject C] [Preadditive C] [HasShift C ℤ]
+  [∀ n : ℤ, (shiftFunctor C n).Additive] [Pretriangulated C]
+
+def perpendicular (X : C) : ObjectProperty C :=
+  ((ObjectProperty.singleton X).shiftClosure ℤ).leftOrthogonal
+
+instance perpendicular_isClosedUnderIsomorphisms (X : C) :
+    (perpendicular X).IsClosedUnderIsomorphisms := inferInstanceAs
+      (((ObjectProperty.singleton X).shiftClosure ℤ).leftOrthogonal.IsClosedUnderIsomorphisms)
+
+instance perpendicular_isTriangulated (X : C) : (perpendicular X).IsTriangulated :=
+  inferInstanceAs (((ObjectProperty.singleton X).shiftClosure ℤ).leftOrthogonal.IsTriangulated)
+
+instance perpendicular_closed (X : C) (J : Type t) [Category J] :
+    (perpendicular X).IsClosedUnderColimitsOfShape J := leftOrthogonal_closed _ J
+
+omit [HasZeroObject C] [∀ n : ℤ, (shiftFunctor C n).Additive] [Pretriangulated C] in
+lemma perpendicular_iff (X Y : C) : perpendicular X Y ↔
+    ∀ (n : ℤ) (f : Y ⟶ X⟦n⟧), f = 0 := by
+  constructor
+  · intro h n f
+    exact h f ⟨X,n,Iso.refl _, by simp⟩
+  · intro h Z f hZ
+    obtain ⟨X', n, e, he⟩ := hZ
+    have he' : X = X' := by simpa using he
+    subst X'
+    apply (cancel_mono e.hom).mp
+    simpa using h n (f ≫ e.hom)
+
+omit [HasZeroObject C] [∀ n : ℤ, (shiftFunctor C n).Additive] [Pretriangulated C] in
+lemma isZero_of_perpendicular_self (X : C) (hX : perpendicular X X) : IsZero X := by
+  apply (IsZero.iff_id_eq_zero _).mpr
+  exact hX (𝟙 X) ((ObjectProperty.singleton X).le_shiftClosure X (by simp))
+end
+
+variable {R : Type u} [Ring R]
+local instance orthogonalHasDerivedCategory : HasDerivedCategory (ModuleCat.{u} R) :=
+  HasDerivedCategory.standard _
+
+lemma not_generate_of_orthogonal
+    (X : @DerivedCategory (ModuleCat.{u} R) _ _ (HasDerivedCategory.standard _))
+    (hX : ¬ IsZero X)
+    (hI : ∀ (M : ModuleCat.{u} R), Injective M →
+      ∀ (n : ℤ) (f : (DerivedCategory.singleFunctor _ 0).obj M ⟶ X⟦n⟧), f = 0) :
+    ¬ InjectivesGenerate R := by
+  let := HasDerivedCategory.standard (ModuleCat.{u} R)
+  intro h
+  apply hX
+  apply isZero_of_perpendicular_self
+  apply h (perpendicular X) inferInstance inferInstance (fun I => inferInstance)
+  intro M hM
+  exact (perpendicular_iff X _).mpr (hI M hM)
+
+end LittleFinitistic.Rickard
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/FinitisticAsymmetry/Rickard/OrthogonalStalks.lean b/lean/OAI/Algebra/FinitisticAsymmetry/Rickard/OrthogonalStalks.lean
new file mode 100644
index 0000000000000000000000000000000000000000..1f755cae23290156a4171fd51d52395566c21841
--- /dev/null
+++ b/lean/OAI/Algebra/FinitisticAsymmetry/Rickard/OrthogonalStalks.lean
@@ -0,0 +1,57 @@
+import Mathlib
+import OAI.Algebra.FinitisticAsymmetry.Model
+
+namespace OAI
+
+noncomputable section
+
+open CategoryTheory CategoryTheory.Limits CochainComplex CochainComplex.HomComplex
+namespace LittleFinitistic.Rickard
+universe u
+variable {R : Type u} [Ring R]
+local instance orthogonalStalksHasDerivedCategory : HasDerivedCategory (ModuleCat.{u} R) :=
+  HasDerivedCategory.standard _
+
+lemma class_eq_zero_of_hom_exact (D : ModuleCat.{u} R)
+    (L : CochainComplex (ModuleCat.{u} R) ℤ)
+    (hex : ∀ j, ∀ f : D ⟶ L.X j, f ≫ L.d j (j+1) = 0 →
+      ∃ g : D ⟶ L.X (j-1), g ≫ L.d (j-1) j = f)
+    (n : ℤ) (x : CohomologyClass ((singleFunctor _ 0).obj D) L n) : x=0 := by
+  obtain ⟨x, rfl⟩ := CohomologyClass.mk_surjective x
+  obtain ⟨f, hf, rfl⟩ := Cocycle.fromSingleMk_surjective x n (by simp) (n+1) rfl
+  rw [CohomologyClass.mk_eq_zero_iff,
+    Cocycle.fromSingleMk_mem_coboundaries_iff f (by simp) (n+1) rfl hf (n-1) (by omega)]
+  exact hex n f hf
+
+lemma orthogonal_single_of_hom_exact (D : ModuleCat.{u} R)
+    (L : CochainComplex (ModuleCat.{u} R) ℤ) [L.IsKInjective]
+    (hex : ∀ j, ∀ f : D ⟶ L.X j, f ≫ L.d j (j+1) = 0 →
+      ∃ g : D ⟶ L.X (j-1), g ≫ L.d (j-1) j = f)
+    (n : ℤ) (f : (DerivedCategory.singleFunctor _ 0).obj D ⟶ (DerivedCategory.Q.obj L)⟦n⟧) :
+    f=0 := by
+  let S := (singleFunctor (ModuleCat R) 0).obj D
+  have hz (g : (HomotopyCategory.quotient _ _).obj S ⟶
+      (HomotopyCategory.quotient _ _).obj (L⟦n⟧)) : g=0 := by
+    obtain ⟨x, rfl⟩ := (CohomologyClass.toHom_bijective S L n).surjective g
+    rw [class_eq_zero_of_hom_exact D L hex n x, map_zero]
+  have hz' (g : DerivedCategory.Qh.obj ((HomotopyCategory.quotient _ _).obj S) ⟶
+      DerivedCategory.Qh.obj ((HomotopyCategory.quotient _ _).obj (L⟦n⟧))) : g=0 := by
+    obtain ⟨g, rfl⟩ := (CochainComplex.IsKInjective.Qh_map_bijective
+      ((HomotopyCategory.quotient _ _).obj S) (L⟦n⟧)).surjective g
+    rw [hz g, Functor.map_zero]
+  let es := (DerivedCategory.singleFunctorIsoCompQ (ModuleCat R) 0).app D
+  let eqs := (DerivedCategory.quotientCompQhIso (ModuleCat R)).app S
+  let eql := (DerivedCategory.quotientCompQhIso (ModuleCat R)).app (L⟦n⟧)
+  let en := (DerivedCategory.Q.commShiftIso n).app L
+  apply (cancel_epi es.inv).mp
+  apply (cancel_epi eqs.hom).mp
+  apply (cancel_mono en.inv).mp
+  apply (cancel_mono eql.inv).mp
+  simpa only [Category.assoc, comp_zero, zero_comp] using
+    hz' (eqs.hom ≫ es.inv ≫ f ≫ en.inv ≫ eql.inv)
+
+end LittleFinitistic.Rickard
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/FinitisticAsymmetry/Rickard/ReducedProducts.lean b/lean/OAI/Algebra/FinitisticAsymmetry/Rickard/ReducedProducts.lean
new file mode 100644
index 0000000000000000000000000000000000000000..e5f604dfa5b40e417d4d8680dd1efa232a68967b
--- /dev/null
+++ b/lean/OAI/Algebra/FinitisticAsymmetry/Rickard/ReducedProducts.lean
@@ -0,0 +1,211 @@
+import Mathlib
+import OAI.Algebra.FinitisticAsymmetry.Rickard.InjectiveSums
+
+namespace OAI
+
+section
+noncomputable section
+open CategoryTheory CategoryTheory.Limits
+namespace LittleFinitistic.Rickard
+universe u
+variable {R : Type u} [Ring R]
+variable (K : ℕ → CochainComplex (ModuleCat.{u} R) ℤ)
+
+abbrev productTerm (j : ℤ) := ∀ i, (K i).X j
+abbrev sumTerm (j : ℤ) := Π₀ i, (K i).X j
+abbrev reducedTerm (j : ℤ) := productTerm K j × sumTerm K (j+1)
+
+def productD (j : ℤ) : productTerm K j →ₗ[R] productTerm K (j+1) :=
+  LinearMap.pi (fun i => ((K i).d j (j+1)).hom.comp (LinearMap.proj i))
+
+def sumD (j : ℤ) : sumTerm K j →ₗ[R] sumTerm K (j+1) :=
+  DFinsupp.mapRange.linearMap (fun i => ((K i).d j (j+1)).hom)
+
+@[simp] lemma productD_apply (j : ℤ) (p : productTerm K j) (i : ℕ) :
+    productD K j p i = (K i).d j (j+1) (p i) := rfl
+@[simp] lemma sumD_apply (j : ℤ) (s : sumTerm K j) (i : ℕ) :
+    sumD K j s i = (K i).d j (j+1) (s i) := rfl
+
+def sumInclusion (j : ℤ) : sumTerm K j →ₗ[R] productTerm K j :=
+  LinearMap.pi (fun i => DFinsupp.lapply i)
+
+@[simp] lemma sumInclusion_apply (j : ℤ) (s : sumTerm K j) (i : ℕ) :
+    sumInclusion K j s i = s i := rfl
+
+lemma d_d_apply (i : ℕ) (j : ℤ) (p : (K i).X j) :
+    (K i).d (j+1) (j+1+1) ((K i).d j (j+1) p) = 0 := by
+  exact ConcreteCategory.congr_hom ((K i).d_comp_d j (j+1) (j+1+1)) p
+
+def reducedD (j : ℤ) : reducedTerm K j →ₗ[R] reducedTerm K (j+1) :=
+  ((productD K j).comp (LinearMap.fst R _ _) +
+    (sumInclusion K (j+1)).comp (LinearMap.snd R _ _)).prod
+      (-(sumD K (j+1)).comp (LinearMap.snd R _ _))
+
+@[simp] lemma reducedD_fst (j : ℤ) (x : reducedTerm K j) (i : ℕ) :
+    (reducedD K j x).1 i = (K i).d j (j+1) (x.1 i) + x.2 i := rfl
+@[simp] lemma reducedD_snd (j : ℤ) (x : reducedTerm K j) (i : ℕ) :
+    (reducedD K j x).2 i = -(K i).d (j+1) (j+1+1) (x.2 i) := rfl
+
+lemma reducedD_sq (j : ℤ) :
+    (reducedD K (j+1)).comp (reducedD K j) = 0 := by
+  apply LinearMap.ext
+  intro x
+  apply Prod.ext
+  · ext i
+    simp only [LinearMap.comp_apply, reducedD_fst, reducedD_snd, map_add,
+      d_d_apply, zero_add, add_neg_cancel, LinearMap.zero_apply, Prod.fst_zero, Pi.zero_apply]
+  · apply DFinsupp.ext
+    intro i
+    simp only [LinearMap.comp_apply, reducedD_snd, map_neg, d_d_apply, neg_zero,
+      LinearMap.zero_apply, Prod.snd_zero, DFinsupp.zero_apply]
+
+def reducedComplex : CochainComplex (ModuleCat.{u} R) ℤ :=
+  CochainComplex.of (fun j => ModuleCat.of R (reducedTerm K j))
+    (fun j => ModuleCat.ofHom (reducedD K j)) (fun j => by
+      apply ModuleCat.hom_ext
+      exact reducedD_sq K j)
+
+@[simp] lemma reducedComplex_d (j : ℤ) :
+    (reducedComplex K).d j (j+1) = ModuleCat.ofHom (reducedD K j) := by
+  simp [reducedComplex, CochainComplex.of]
+
+lemma reducedComplex_injective [IsNoetherianRing R]
+    (hK : ∀ i j, Injective ((K i).X j)) (j : ℤ) :
+    Injective ((reducedComplex K).X j) := by
+  let (i : ℕ) : Module.Injective R ((K i).X j) :=
+    (Module.injective_iff_injective_object R _).mpr (hK i j)
+  let (i : ℕ) : Module.Injective R ((K i).X (j+1)) :=
+    (Module.injective_iff_injective_object R _).mpr (hK i (j+1))
+  let := dfinsupp_injective (R := R) (fun i => (K i).X (j+1))
+  let := prod_injective (R := R) (productTerm K j) (sumTerm K (j+1))
+  apply Module.injective_object_of_injective_module
+
+lemma reduced_hom_exact (D : ModuleCat.{u} R) [Module.Finite R D]
+    (j : ℤ) (hex : ∃ s : Finset ℕ, ∀ i ∉ s, ∀ f : D ⟶ (K i).X (j+1),
+      f ≫ (K i).d (j+1) (j+1+1) = 0 → ∃ g : D ⟶ (K i).X j,
+      g ≫ (K i).d j (j+1) = f)
+    (f : D ⟶ (reducedComplex K).X (j+1))
+    (hf : f ≫ (reducedComplex K).d (j+1) (j+1+1) = 0) :
+    ∃ g : D ⟶ (reducedComplex K).X j,
+      g ≫ (reducedComplex K).d j (j+1) = f := by
+  classical
+  let a : ∀ i, D →ₗ[R] (K i).X (j+1) := fun i =>
+    (LinearMap.proj i).comp ((LinearMap.fst R _ _).comp f.hom)
+  let b : D →ₗ[R] sumTerm K (j+1+1) := (LinearMap.snd R _ _).comp f.hom
+  obtain ⟨s, hs⟩ := finite_support_map (R := R) _ D b
+  obtain ⟨t, ht⟩ := hex
+  have hcycle (i : ℕ) (x : D) :
+      (K i).d (j+1) (j+1+1) (a i x) + b x i = 0 := by
+    have h := congrArg (fun z : reducedTerm K (j+1+1) => z.1 i)
+      (ConcreteCategory.congr_hom hf x)
+    rw [reducedComplex_d] at h
+    change (reducedD K (j+1) (f x)).1 i = 0 at h
+    exact h
+  have he (i : ℕ) : ∃ c : D →ₗ[R] (K i).X j,
+      i ∉ s ∪ t → ((K i).d j (j+1)).hom.comp c = a i := by
+    by_cases hi : i ∈ s ∪ t
+    · exact ⟨0, fun h => (h hi).elim⟩
+    · have his : i ∉ s := fun h => hi (Finset.mem_union_left _ h)
+      have hit : i ∉ t := fun h => hi (Finset.mem_union_right _ h)
+      obtain ⟨c, hc⟩ := ht i hit (ModuleCat.ofHom (a i)) (by
+        apply ModuleCat.hom_ext
+        apply LinearMap.ext
+        intro x
+        simpa only [ModuleCat.hom_comp, LinearMap.comp_apply, ModuleCat.hom_ofHom,
+          ModuleCat.hom_zero, LinearMap.zero_apply, hs x i his, add_zero] using hcycle i x)
+      exact ⟨c.hom, fun _ => congrArg ModuleCat.Hom.hom hc⟩
+  choose c hc using he
+  let q : D →ₗ[R] productTerm K j := LinearMap.pi c
+  let v : ∀ i, D →ₗ[R] (K i).X (j+1) := fun i => a i - ((K i).d j (j+1)).hom.comp (c i)
+  let w : D →ₗ[R] sumTerm K (j+1) := ∑ i ∈ s ∪ t, (DFinsupp.lsingle i).comp (v i)
+  have hw (x : D) (i : ℕ) : w x i = a i x - (K i).d j (j+1) (c i x) := by
+    by_cases hi : i ∈ s ∪ t
+    · simp [w, LinearMap.sum_apply, DFinsupp.single_apply, hi, v]
+    · have hci : (K i).d j (j+1) (c i x) = a i x := LinearMap.congr_fun (hc i hi) x
+      simp [w, LinearMap.sum_apply, DFinsupp.single_apply, hi, hci, v]
+  let g : D →ₗ[R] reducedTerm K j := q.prod w
+  refine ⟨ModuleCat.ofHom g, ?_⟩
+  apply ModuleCat.hom_ext
+  apply LinearMap.ext
+  intro x
+  apply Prod.ext
+  · ext i
+    rw [reducedComplex_d]
+    change (reducedD K j (g x)).1 i = a i x
+    rw [reducedD_fst]
+    change (K i).d j (j+1) (c i x) + w x i = a i x
+    rw [hw]
+    abel
+  · apply DFinsupp.ext
+    intro i
+    rw [reducedComplex_d]
+    change (reducedD K j (g x)).2 i = b x i
+    rw [reducedD_snd]
+    change -(K i).d (j+1) (j+1+1) (w x i) = b x i
+    rw [hw, map_sub, d_d_apply, sub_zero]
+    exact neg_eq_of_add_eq_zero_right (hcycle i x)
+
+lemma reduced_isStrictlyGE
+    (hK : ∀ i j, j < 0 → IsZero ((K i).X j)) :
+    (reducedComplex K).IsStrictlyGE (-1) := by
+  apply (CochainComplex.isStrictlyGE_iff _ _).mpr
+  intro j hj
+  apply ModuleCat.isZero_iff_subsingleton.mpr
+  let (i : ℕ) : Subsingleton ((K i).X j) :=
+    ModuleCat.isZero_iff_subsingleton.mp (hK i j (by omega))
+  let (i : ℕ) : Subsingleton ((K i).X (j+1)) :=
+    ModuleCat.isZero_iff_subsingleton.mp (hK i (j+1) (by omega))
+  change Subsingleton (reducedTerm K j)
+  infer_instance
+
+lemma reduced_not_exact_zero
+    (hK : ∀ i j, j < 0 → IsZero ((K i).X j))
+    (hnon : ∀ i, ∃ x : (K i).X 0, x ≠ 0 ∧ (K i).d 0 1 x = 0) :
+    ¬ (reducedComplex K).ExactAt 0 := by
+  classical
+  choose x hxne hxd using hnon
+  let p : reducedTerm K 0 := (x, 0)
+  have hp : (reducedComplex K).d 0 1 p = 0 := by
+    rw [show (1 : ℤ)=0+1 from rfl, reducedComplex_d]
+    apply Prod.ext
+    · ext i
+      change (K i).d 0 1 (x i) + 0 = 0
+      simpa only [add_zero] using hxd i
+    · apply DFinsupp.ext
+      intro i
+      change -(K i).d 1 2 0 = 0
+      rw [map_zero, neg_zero]
+  intro hex
+  obtain ⟨y, hy⟩ := (ShortComplex.moduleCat_exact_iff ((reducedComplex K).sc' (-1) 0 1)).mp
+    ((HomologicalComplex.exactAt_iff' _ _ _ _ (by simp) (by simp)).mp hex) p hp
+  change (reducedComplex K).d (-1) 0 y = p at hy
+  have hd : (reducedComplex K).d (-1) 0 = ModuleCat.ofHom (reducedD K (-1)) :=
+    reducedComplex_d K (-1)
+  rw [hd] at hy
+  change reducedTerm K (-1) at y
+  obtain ⟨i, hi⟩ := Infinite.exists_notMem_finset y.2.support
+  have hy0 : y.2 i = 0 := DFinsupp.notMem_support_iff.mp hi
+  have hy1 : y.1 i = 0 :=
+    (ModuleCat.isZero_iff_subsingleton.mp (hK i (-1) (by omega))).elim _ _
+  have h := congrArg (fun z : reducedTerm K 0 => z.1 i) hy
+  change (reducedD K (-1) y).1 i = x i at h
+  rw [reducedD_fst, hy0, hy1, map_zero, zero_add] at h
+  exact hxne i h.symm
+
+local instance reducedProductsHasDerivedCategory : HasDerivedCategory (ModuleCat.{u} R) :=
+  HasDerivedCategory.standard _
+
+lemma not_isZero_Q_of_not_exact_zero (L : CochainComplex (ModuleCat.{u} R) ℤ)
+    (h : ¬ L.ExactAt 0) : ¬ IsZero (DerivedCategory.Q.obj L) := by
+  intro hz
+  apply h
+  apply (HomologicalComplex.exactAt_iff_isZero_homology L 0).mpr
+  exact ((DerivedCategory.homologyFunctor (ModuleCat R) 0).map_isZero hz).of_iso
+    ((DerivedCategory.homologyFunctorFactors (ModuleCat R) 0).app L).symm
+
+end LittleFinitistic.Rickard
+
+end
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/FinitisticAsymmetry/Rickard/ResolutionFamily.lean b/lean/OAI/Algebra/FinitisticAsymmetry/Rickard/ResolutionFamily.lean
new file mode 100644
index 0000000000000000000000000000000000000000..0e1060b96d39820a6bc753a93200757207e05fd1
--- /dev/null
+++ b/lean/OAI/Algebra/FinitisticAsymmetry/Rickard/ResolutionFamily.lean
@@ -0,0 +1,164 @@
+import Mathlib
+import OAI.Algebra.Finitistic.Dimension.PDDimension
+import OAI.Algebra.FinitisticAsymmetry.Nakayama.Minimality
+
+namespace OAI
+
+noncomputable section
+
+open CategoryTheory CategoryTheory.Limits
+namespace LittleFinitistic.Rickard
+private theorem mono_map_of_conjugate {C D : Type*} [Category C] [Category D]
+    (F : C ⥤ D) {X₀ X₁ Y₀ Y₁ : C} (e₀ : X₀ ≅ Y₀) (e₁ : X₁ ≅ Y₁)
+    (f : X₀ ⟶ X₁) (g : Y₀ ⟶ Y₁) (h : f = e₀.hom ≫ g ≫ e₁.inv)
+    (hf : Mono (F.map f)) : Mono (F.map g) := by
+  let := hf
+  have hg : F.map g = F.map e₀.inv ≫ F.map f ≫ F.map e₁.hom := by
+    rw [h, F.map_comp, F.map_comp]
+    simp
+  rw [hg]
+  infer_instance
+
+universe u
+variable {k R : Type u} [Field k] [Ring R] [Algebra k R] [FiniteDimensional k R]
+open PDMinimal
+
+def translatedResolution (M : FiniteModule k R) (d : ℕ) :
+    CochainComplex (ModuleCat.{u} R) ℤ :=
+  (complex M).extend (ComplexShape.embeddingUpIntLE d)
+
+lemma translatedResolution_finite (M : FiniteModule k R) (d : ℕ) (j : ℤ) :
+    Module.Finite R ((translatedResolution M d).X j) := by
+  by_cases h : ∃ n : ℕ, (ComplexShape.embeddingUpIntLE d).f n = j
+  · obtain ⟨n, hn⟩ := h
+    let : Module.Finite R ((complex M).X n) := (inferInstance : Module.Finite R (term M n))
+    exact Module.Finite.equiv ((complex M).extendXIso _ hn).symm.toLinearEquiv
+  · have hz := (complex M).isZero_extend_X (ComplexShape.embeddingUpIntLE d) j (by simpa using h)
+    let : Subsingleton ((translatedResolution M d).X j) := ModuleCat.isZero_iff_subsingleton.mp hz
+    infer_instance
+
+lemma translatedResolution_projective (M : FiniteModule k R) (d : ℕ) (j : ℤ) :
+    Module.Projective R ((translatedResolution M d).X j) := by
+  by_cases h : ∃ n : ℕ, (ComplexShape.embeddingUpIntLE d).f n = j
+  · obtain ⟨n, hn⟩ := h
+    let : Module.Projective R ((complex M).X n) :=
+      (inferInstance : Module.Projective R (term M n))
+    exact Module.Projective.of_equiv ((complex M).extendXIso _ hn).symm.toLinearEquiv
+  · have hz := (complex M).isZero_extend_X (ComplexShape.embeddingUpIntLE d) j (by simpa using h)
+    let : Subsingleton ((translatedResolution M d).X j) := ModuleCat.isZero_iff_subsingleton.mp hz
+    infer_instance
+
+lemma term_zero_above (M : FiniteModule k R) (d n : ℕ)
+    (hd : HasProjectiveDimensionLE M.cat d) (hn : d < n) : Subsingleton (term M n) := by
+  obtain ⟨m, rfl⟩ := Nat.exists_eq_succ_of_ne_zero (by omega : n ≠ 0)
+  apply term_zero_of_pdLE M m
+  rw [← projectiveDimension_le_iff] at hd ⊢
+  exact hd.trans (by exact_mod_cast (by omega : d ≤ m))
+
+lemma translatedResolution_zero_negative (M : FiniteModule k R) (d : ℕ)
+    (hd : HasProjectiveDimensionLE M.cat d) (j : ℤ) (hj : j < 0) :
+    IsZero ((translatedResolution M d).X j) := by
+  let n := (d - j).toNat
+  have hn : (ComplexShape.embeddingUpIntLE d).f n = j := by
+    rw [ComplexShape.embeddingUpIntLE_f]
+    dsimp [n]
+    omega
+  have := term_zero_above M d n hd (by dsimp [n]; omega)
+  exact ((complex M).extendXIso _ hn).isZero_iff.mpr
+    (ModuleCat.isZero_iff_subsingleton.mpr (show Subsingleton (term M n) from inferInstance))
+
+lemma translatedResolution_exact (M : FiniteModule k R) (d : ℕ) (j : ℤ) (hj : j ≠ d) :
+    (translatedResolution M d).ExactAt j := by
+  by_cases h : ∃ n : ℕ, (ComplexShape.embeddingUpIntLE d).f n = j
+  · obtain ⟨n, hn⟩ := h
+    have hn0 : n ≠ 0 := by
+      intro he
+      subst n
+      simp only [ComplexShape.embeddingUpIntLE_f, Nat.cast_zero, sub_zero] at hn
+      exact hj hn.symm
+    obtain ⟨m, rfl⟩ := Nat.exists_eq_succ_of_ne_zero hn0
+    exact ((complex M).extend_exactAt_iff _ hn).mpr (complex_exactAt M m)
+  · exact (complex M).extend_exactAt _ j (by simpa using h)
+
+variable (k)
+def nakayamaComplex (P : CochainComplex (ModuleCat.{u} R) ℤ) :=
+  (Nakayama.functor k R).mapHomologicalComplex (.up ℤ) |>.obj P
+
+lemma nakayamaComplex_hom_exact (P : CochainComplex (ModuleCat.{u} R) ℤ)
+    (hfin : ∀ j, Module.Finite R (P.X j)) (hproj : ∀ j, Module.Projective R (P.X j))
+    (j : ℤ) (hex : P.ExactAt (j+1)) (f : Nakayama.DA k R ⟶ (nakayamaComplex k P).X (j+1))
+    (hf : f ≫ (nakayamaComplex k P).d (j+1) (j+1+1) = 0) :
+    ∃ g : Nakayama.DA k R ⟶ (nakayamaComplex k P).X j,
+      g ≫ (nakayamaComplex k P).d j (j+1) = f := by
+  let (i : ℤ) := hfin i
+  let (i : ℤ) := hproj i
+  obtain ⟨F⟩ := Nakayama.frame_nonempty R (P.X (j+1))
+  obtain ⟨G⟩ := Nakayama.frame_nonempty R (P.X (j+1+1))
+  obtain ⟨p, hp⟩ := Nakayama.eta_surjective k R _ F f.hom
+  have hz : P.d (j+1) (j+1+1) p = 0 := by
+    apply Nakayama.eta_injective k R _ G
+    rw [← Nakayama.eta_natural, hp]
+    have hf' := congrArg ModuleCat.Hom.hom hf
+    change (Nakayama.map (P.d (j+1) (j+1+1))).comp f.hom = 0 at hf'
+    rw [hf']
+    ext h φ
+    simp [Nakayama.etaMap]
+    rfl
+  have hx := (ShortComplex.moduleCat_exact_iff_range_eq_ker _).mp
+    ((HomologicalComplex.exactAt_iff' P j (j+1) (j+1+1) (by simp) (by simp)).mp hex)
+  change LinearMap.range (P.d j (j+1)).hom = LinearMap.ker (P.d (j+1) (j+1+1)).hom at hx
+  have hpker : p ∈ LinearMap.ker (P.d (j+1) (j+1+1)).hom := hz
+  rw [← hx] at hpker
+  obtain ⟨q, hq⟩ := hpker
+  refine ⟨ModuleCat.ofHom (Nakayama.etaMap k R _ q), ?_⟩
+  apply ModuleCat.hom_ext
+  change (Nakayama.map (P.d j (j+1))).comp (Nakayama.etaMap k R _ q) = f.hom
+  rw [Nakayama.eta_natural, hq, hp]
+
+omit [FiniteDimensional k R] in
+lemma nakayamaComplex_injective (P : CochainComplex (ModuleCat.{u} R) ℤ)
+    (hfin : ∀ j, Module.Finite R (P.X j)) (hproj : ∀ j, Module.Projective R (P.X j))
+    (j : ℤ) : Injective ((nakayamaComplex k P).X j) := by
+  let := hfin j
+  let := hproj j
+  exact Nakayama.object_injective k R (P.X j)
+
+omit [FiniteDimensional k R] in
+lemma nakayamaComplex_zero (P : CochainComplex (ModuleCat.{u} R) ℤ)
+    (j : ℤ) (h : IsZero (P.X j)) : IsZero ((nakayamaComplex k P).X j) := by
+  exact (Nakayama.functor k R).map_isZero h
+
+lemma translated_nakayama_zero_cycle (M : FiniteModule k R) (d : ℕ)
+    (hd : 0 < d) (hterm : ¬ Subsingleton (term M d)) :
+    ∃ x : (nakayamaComplex k (translatedResolution M d)).X 0,
+      x ≠ 0 ∧ (nakayamaComplex k (translatedResolution M d)).d 0 1 x = 0 := by
+  obtain ⟨n, rfl⟩ := Nat.exists_eq_succ_of_ne_zero (by omega : d ≠ 0)
+  let : Nontrivial (term M (n+1)) := not_subsingleton_iff_nontrivial.mp hterm
+  let e := ComplexShape.embeddingUpIntLE ((n+1 : ℕ) : ℤ)
+  have h₀ : e.f (n+1) = 0 := by simp [e]
+  have h₁ : e.f n = 1 := by simp [e]
+  let P := translatedResolution M (n+1)
+  let F := Nakayama.functor k R
+  have he : P.d 0 1 = ((complex M).extendXIso e h₀).hom ≫
+      ModuleCat.ofHom (differential M n) ≫ ((complex M).extendXIso e h₁).inv := by
+    simpa only [P, translatedResolution, e, complex_d] using! (complex M).extend_d_eq e h₀ h₁
+  have hn : ¬ Function.Injective ((nakayamaComplex k P).d 0 1).hom := by
+    intro hi
+    have hmono : Mono (F.map (P.d 0 1)) := (ModuleCat.mono_iff_injective _).mpr hi
+    have hh : Mono (F.map (ModuleCat.ofHom (differential M n))) :=
+      mono_map_of_conjugate F ((complex M).extendXIso e h₀) ((complex M).extendXIso e h₁)
+        (P.d 0 1) (ModuleCat.ofHom (differential M n)) he hmono
+    exact Nakayama.minimal_nakayama_differential_noninjective M n
+      ((ModuleCat.mono_iff_injective _).mp hh)
+  rw [Function.Injective] at hn
+  push Not at hn
+  obtain ⟨x, y, hxy, hne⟩ := hn
+  refine ⟨x-y, sub_ne_zero.mpr hne, ?_⟩
+  change ((nakayamaComplex k P).d 0 1).hom (x-y) = 0
+  rw [map_sub, hxy, sub_self]
+
+end LittleFinitistic.Rickard
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/FinitisticAsymmetry/Transport/DerivedEquivalence.lean b/lean/OAI/Algebra/FinitisticAsymmetry/Transport/DerivedEquivalence.lean
new file mode 100644
index 0000000000000000000000000000000000000000..1e692d94bcb44f1ac5e97682fae0287786f681cf
--- /dev/null
+++ b/lean/OAI/Algebra/FinitisticAsymmetry/Transport/DerivedEquivalence.lean
@@ -0,0 +1,50 @@
+import Mathlib
+import OAI.Algebra.FinitisticAsymmetry.Model
+
+namespace OAI
+
+section
+section
+noncomputable section
+open CategoryTheory
+namespace LittleFinitistic
+universe u
+variable (A : Type u) [Ring A]
+section DerivedTransport
+universe w₁ w₂ v₁ v₂ u₁ u₂
+variable {C : Type u₁} [Category.{v₁} C] [Abelian C] [HasDerivedCategory.{w₁} C]
+  {D : Type u₂} [Category.{v₂} D] [Abelian D] [HasDerivedCategory.{w₂} D]
+open CategoryTheory.Limits CategoryTheory.Functor
+
+lemma mapDerivedCategory_isEquivalence (e : C ≌ D)
+    [e.functor.Additive] [e.inverse.Additive] :
+    e.functor.mapDerivedCategory.IsEquivalence := by
+  let f := e.functor.mapHomologicalComplex (ComplexShape.up ℤ)
+  let g := e.inverse.mapHomologicalComplex (ComplexShape.up ℤ)
+  let qC := DerivedCategory.Q (C := C)
+  let qD := DerivedCategory.Q (C := D)
+  let α : (f ⋙ qD) ⋙ e.inverse.mapDerivedCategory ≅ qC :=
+    Functor.associator _ _ _ ≪≫
+    isoWhiskerLeft f e.inverse.mapDerivedCategoryFactors ≪≫
+    (Functor.associator _ _ _).symm ≪≫
+    isoWhiskerRight (e.mapHomologicalComplex (ComplexShape.up ℤ)).unitIso.symm qC ≪≫
+    Functor.leftUnitor qC
+  let β : (g ⋙ qC) ⋙ e.functor.mapDerivedCategory ≅ qD :=
+    Functor.associator _ _ _ ≪≫
+    isoWhiskerLeft g e.functor.mapDerivedCategoryFactors ≪≫
+    (Functor.associator _ _ _).symm ≪≫
+    isoWhiskerRight (e.mapHomologicalComplex (ComplexShape.up ℤ)).counitIso qD ≪≫
+    Functor.leftUnitor qD
+  exact Localization.isEquivalence qC (HomologicalComplex.quasiIso C (ComplexShape.up ℤ))
+    qD (HomologicalComplex.quasiIso D (ComplexShape.up ℤ))
+    (f ⋙ qD) e.functor.mapDerivedCategory
+    (g ⋙ qC) e.inverse.mapDerivedCategory α β
+
+end DerivedTransport
+
+end LittleFinitistic
+end
+end
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/FinitisticAsymmetry/Transport/DiagramMaps.lean b/lean/OAI/Algebra/FinitisticAsymmetry/Transport/DiagramMaps.lean
new file mode 100644
index 0000000000000000000000000000000000000000..14e6ffe61b14218dca543bfc06a3bb850792d160
--- /dev/null
+++ b/lean/OAI/Algebra/FinitisticAsymmetry/Transport/DiagramMaps.lean
@@ -0,0 +1,73 @@
+import Mathlib
+
+namespace OAI
+
+section
+section
+noncomputable section
+open CategoryTheory CategoryTheory.Limits
+namespace LittleFinitistic.DefaultSupport
+universe v₁ v₂ v₃ u₁ u₂ u₃
+variable {C : Type u₁} [Category.{v₁} C] {D : Type u₂} [Category.{v₂} D]
+  {E : Type u₃} [Category.{v₃} E]
+lemma mapped_retract (F : C ⥤ D) (G : D ⥤ E) {X Y : C} {Z : E}
+    (i : X ⟶ Y) (p : Y ⟶ X) (h : i ≫ p = 𝟙 X) (e : G.obj (F.obj Y) ≅ Z) :
+    (G.map (F.map i) ≫ e.hom) ≫ (e.inv ≫ G.map (F.map p)) = 𝟙 _ := by
+  simp only [Category.assoc, Iso.hom_inv_id_assoc]
+  rw [← G.map_comp, ← F.map_comp, h, F.map_id, G.map_id]
+lemma mapped_conjugate (F : C ⥤ D) (G : D ⥤ E) {X Y : C} {W : E}
+    (p : X ⟶ Y) (i : Y ⟶ X) (a : X ⟶ X) (h : p ≫ i = a)
+    (e : W ≅ G.obj (F.obj X)) (c : W ⟶ W)
+    (hc : c ≫ e.hom = e.hom ≫ G.map (F.map a)) :
+    (e.hom ≫ G.map (F.map p)) ≫ (G.map (F.map i) ≫ e.inv) = c := by
+  apply (cancel_mono e.hom).mp
+  simp only [Category.assoc, Iso.inv_hom_id, Category.comp_id]
+  rw [← G.map_comp, ← F.map_comp, h]
+  exact hc.symm
+lemma mapped_square (F : C ⥤ D) (G : D ⥤ E) {X Y : C} {W : E}
+    (a : X ⟶ X) (p : X ⟶ Y) (b : Y ⟶ Y) (h : a ≫ p = p ≫ b)
+    (e : W ≅ G.obj (F.obj X)) (c : W ⟶ W)
+    (hc : c ≫ e.hom = e.hom ≫ G.map (F.map a)) :
+    c ≫ (e.hom ≫ G.map (F.map p)) =
+      (e.hom ≫ G.map (F.map p)) ≫ G.map (F.map b) := by
+  rw [← Category.assoc, hc, Category.assoc, ← G.map_comp, ← F.map_comp, h]
+  simp only [F.map_comp, G.map_comp, Category.assoc]
+lemma natural_square (F : C ⥤ D) (S : C ⥤ C) (T : D ⥤ D) (n : S ⋙ F ≅ F ⋙ T)
+    {X : C} {Y : D} (e : F.obj X ≅ Y) (a : X ⟶ X) (b : Y ⟶ Y)
+    (h : F.map a ≫ e.hom = e.hom ≫ b) :
+    F.map (S.map a) ≫ ((n.app X ≪≫ T.mapIso e).hom) =
+      (n.app X ≪≫ T.mapIso e).hom ≫ T.map b := by
+  have hn := n.hom.naturality a
+  have hm := congrArg T.map h
+  simp only [Functor.map_comp] at hm
+  change _ ≫ (n.hom.app X ≫ T.map e.hom) = (n.hom.app X ≫ T.map e.hom) ≫ _
+  rw [← Category.assoc]
+  change ((S ⋙ F).map a ≫ n.hom.app X) ≫ T.map e.hom = _
+  rw [hn, Category.assoc]
+  change _ ≫ (T.map (F.map a) ≫ T.map e.hom) = _
+  rw [hm, ← Category.assoc]
+lemma biprod_square [HasZeroMorphisms C] [HasZeroMorphisms D]
+    [HasBinaryBiproducts C] [HasBinaryBiproducts D]
+    (F : C ⥤ D) [F.PreservesZeroMorphisms] [PreservesBinaryBiproducts F]
+    {X₁ X₂ : C} {Y₁ Y₂ : D} (e₁ : F.obj X₁ ≅ Y₁) (e₂ : F.obj X₂ ≅ Y₂)
+    (a₁ : X₁ ⟶ X₁) (a₂ : X₂ ⟶ X₂) (b₁ : Y₁ ⟶ Y₁) (b₂ : Y₂ ⟶ Y₂)
+    (h₁ : F.map a₁ ≫ e₁.hom = e₁.hom ≫ b₁)
+    (h₂ : F.map a₂ ≫ e₂.hom = e₂.hom ≫ b₂) :
+    F.map (biprod.map a₁ a₂) ≫ (F.mapBiprod _ _ ≪≫ biprod.mapIso e₁ e₂).hom =
+      (F.mapBiprod _ _ ≪≫ biprod.mapIso e₁ e₂).hom ≫ biprod.map b₁ b₂ := by
+  apply biprod.hom_ext
+  · simp only [Iso.trans_hom, Functor.mapBiprod_hom, biprod.mapIso_hom, Category.assoc,
+      biprod.map_fst, biprod.map_fst_assoc, biprod.lift_fst_assoc]
+    rw [← Category.assoc, ← Functor.map_comp, biprod.map_fst, Functor.map_comp,
+      Category.assoc, h₁]
+  · simp only [Iso.trans_hom, Functor.mapBiprod_hom, biprod.mapIso_hom, Category.assoc,
+      biprod.map_snd, biprod.map_snd_assoc, biprod.lift_snd_assoc]
+    rw [← Category.assoc, ← Functor.map_comp, biprod.map_snd, Functor.map_comp,
+      Category.assoc, h₂]
+end LittleFinitistic.DefaultSupport
+
+end
+end
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/FinitisticAsymmetry/Transport/FiniteModules.lean b/lean/OAI/Algebra/FinitisticAsymmetry/Transport/FiniteModules.lean
new file mode 100644
index 0000000000000000000000000000000000000000..03f9fa20126a7df4a41bb5c61f0511365df07a96
--- /dev/null
+++ b/lean/OAI/Algebra/FinitisticAsymmetry/Transport/FiniteModules.lean
@@ -0,0 +1,86 @@
+import Mathlib
+import OAI.Algebra.FinitisticAsymmetry.Transport.ProjectiveDimension
+
+namespace OAI
+
+section
+section
+noncomputable section
+open CategoryTheory
+namespace LittleFinitistic
+universe u
+variable (A : Type u) [Ring A]
+section FiniteTransport
+universe v
+variable {R S : Type v} [Ring R] [Ring S]
+
+lemma compactElement_orderIso {α β : Type*} [CompleteLattice α] [CompleteLattice β]
+    (e : α ≃o β) {a : α} (h : IsCompactElement a) : IsCompactElement (e a) := by
+  rw [isCompactElement_iff_exists_le_iSup_of_le_iSup]
+  intro ι f hf
+  have hf' : a ≤ ⨆ i, e.symm (f i) := by
+    rw [← e.symm.map_iSup]
+    exact (e.le_symm_apply).mpr hf
+  obtain ⟨s, hs⟩ := h.exists_finset_of_le_iSup (fun i => e.symm (f i)) hf'
+  refine ⟨s, ?_⟩
+  simpa only [e.map_iSup, e.apply_symm_apply, Finset.sup_eq_iSup] using e.monotone hs
+
+lemma moduleFinite_equivalence_iff (e : ModuleCat.{v} R ≌ ModuleCat.{v} S)
+    (M : ModuleCat.{v} R) : Module.Finite S (e.functor.obj M) ↔ Module.Finite R M := by
+  let o : Submodule R M ≃o Submodule S (e.functor.obj M) :=
+    (ModuleCat.subobjectModule M).symm.trans
+      ((Subobject.lowerEquivalence (MonoOver.congr M e)).toOrderIso.trans
+        (ModuleCat.subobjectModule (e.functor.obj M)))
+  rw [Module.finite_def, Module.finite_def, Submodule.fg_iff_compact,
+    Submodule.fg_iff_compact]
+  constructor
+  · intro h
+    simpa using compactElement_orderIso o.symm h
+  · intro h
+    simpa using compactElement_orderIso o h
+
+lemma littleFinitisticDimension_le_big (R : Type v) [Ring R] :
+    littleFinitisticDimension R ≤ bigFinitisticDimension R := by
+  refine iSup_le fun M => iSup_le fun _ => iSup_le fun h => ?_
+  exact le_iSup_of_le M (le_iSup_of_le h le_rfl)
+
+lemma littleFinitisticDimension_le_of_equivalence
+    (e : ModuleCat.{v} R ≌ ModuleCat.{v} S) :
+    littleFinitisticDimension R ≤ littleFinitisticDimension S := by
+  refine iSup_le fun M => iSup_le fun hM => iSup_le fun hpd => ?_
+  have hf : Module.Finite S (e.functor.obj M) :=
+    (moduleFinite_equivalence_iff e M).mpr hM
+  have hd : projectiveDimension (e.functor.obj M) < ⊤ := by
+    rwa [projectiveDimension_equivalence e M]
+  exact le_iSup_of_le (e.functor.obj M) (le_iSup_of_le hf
+    (le_iSup_of_le hd (le_of_eq (projectiveDimension_equivalence e M).symm)))
+
+lemma littleFinitisticDimension_equivalence
+    (e : ModuleCat.{v} R ≌ ModuleCat.{v} S) :
+    littleFinitisticDimension R = littleFinitisticDimension S :=
+  le_antisymm (littleFinitisticDimension_le_of_equivalence e)
+    (littleFinitisticDimension_le_of_equivalence e.symm)
+
+lemma bigFinitisticDimension_le_of_equivalence
+    (e : ModuleCat.{v} R ≌ ModuleCat.{v} S) :
+    bigFinitisticDimension R ≤ bigFinitisticDimension S := by
+  refine iSup_le fun M => iSup_le fun hpd => ?_
+  have hd : projectiveDimension (e.functor.obj M) < ⊤ := by
+    rwa [projectiveDimension_equivalence e M]
+  exact le_iSup_of_le (e.functor.obj M)
+    (le_iSup_of_le hd (le_of_eq (projectiveDimension_equivalence e M).symm))
+
+lemma bigFinitisticDimension_equivalence
+    (e : ModuleCat.{v} R ≌ ModuleCat.{v} S) :
+    bigFinitisticDimension R = bigFinitisticDimension S :=
+  le_antisymm (bigFinitisticDimension_le_of_equivalence e)
+    (bigFinitisticDimension_le_of_equivalence e.symm)
+
+end FiniteTransport
+
+end LittleFinitistic
+end
+end
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/FinitisticAsymmetry/Transport/InjectiveGeneration.lean b/lean/OAI/Algebra/FinitisticAsymmetry/Transport/InjectiveGeneration.lean
new file mode 100644
index 0000000000000000000000000000000000000000..ddd457fb67ec4c4b81dee20e1a86ab652144e5e2
--- /dev/null
+++ b/lean/OAI/Algebra/FinitisticAsymmetry/Transport/InjectiveGeneration.lean
@@ -0,0 +1,51 @@
+import Mathlib
+import OAI.Algebra.FinitisticAsymmetry.Transport.DerivedEquivalence
+
+namespace OAI
+
+section
+section
+noncomputable section
+open CategoryTheory
+namespace LittleFinitistic
+universe u
+variable (A : Type u) [Ring A]
+section InjectiveGenerationTransport
+universe v
+variable {R S : Type v} [Ring R] [Ring S]
+open CategoryTheory.Limits
+
+lemma injectivesGenerate_of_equivalence
+    (e : ModuleCat.{v} R ≌ ModuleCat.{v} S) (hR : InjectivesGenerate R) :
+    InjectivesGenerate S := by
+  let := HasDerivedCategory.standard (ModuleCat.{v} R)
+  let := HasDerivedCategory.standard (ModuleCat.{v} S)
+  let : e.functor.Additive := e.functor.additive_of_preserves_binary_products
+  let : e.inverse.Additive := e.inverse.additive_of_preserves_binary_products
+  let F := e.functor.mapDerivedCategory
+  let : F.IsEquivalence := mapDerivedCategory_isEquivalence e
+  intro P hP hT hCol hI X
+  let := hP
+  let := hT
+  let (index : Type v) := hCol index
+  have h : ∀ Y, (P.inverseImage F) Y := by
+    apply hR (P.inverseImage F) inferInstance inferInstance (fun I => inferInstance)
+    intro M hM
+    let := hM
+    exact P.prop_of_iso ((e.functor.mapDerivedCategorySingleFunctor 0).app M).symm
+      (hI (e.functor.obj M) inferInstance)
+  exact P.prop_of_iso (F.asEquivalence.counitIso.app X) (h (F.asEquivalence.inverse.obj X))
+
+lemma injectivesGenerate_equivalence
+    (e : ModuleCat.{v} R ≌ ModuleCat.{v} S) :
+    InjectivesGenerate R ↔ InjectivesGenerate S :=
+  ⟨injectivesGenerate_of_equivalence e, injectivesGenerate_of_equivalence e.symm⟩
+
+end InjectiveGenerationTransport
+
+end LittleFinitistic
+end
+end
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/FinitisticAsymmetry/Transport/ProjectiveDimension.lean b/lean/OAI/Algebra/FinitisticAsymmetry/Transport/ProjectiveDimension.lean
new file mode 100644
index 0000000000000000000000000000000000000000..79023e7acbb378c021187044aec9e583b71f1890
--- /dev/null
+++ b/lean/OAI/Algebra/FinitisticAsymmetry/Transport/ProjectiveDimension.lean
@@ -0,0 +1,96 @@
+import Mathlib
+import OAI.Algebra.FinitisticAsymmetry.Model
+
+namespace OAI
+
+section
+section
+noncomputable section
+open CategoryTheory
+
+namespace LittleFinitistic
+universe u
+variable (A : Type u) [Ring A]
+
+section ProjectiveTransport
+universe v₁ v₂ u₁ u₂
+variable {C : Type u₁} [Category.{v₁} C] [Abelian C] [EnoughProjectives C]
+  {D : Type u₂} [Category.{v₂} D] [Abelian D] [EnoughProjectives D]
+open CategoryTheory.Limits
+
+omit [EnoughProjectives D] in
+lemma hasProjectiveDimensionLT_of_fullyFaithful
+    (F : C ⥤ D) [F.Additive] [PreservesFiniteLimits F] [PreservesFiniteColimits F]
+    [F.Full] [F.Faithful] [F.PreservesProjectiveObjects]
+    (X : C) (n : ℕ) [HasProjectiveDimensionLT (F.obj X) n] :
+    HasProjectiveDimensionLT X n := by
+  let := HasExt.standard C
+  let := HasExt.standard D
+  apply HasProjectiveDimensionLT.mk
+  intro i hi Y e
+  apply (F.mapExt_bijective_of_preservesProjectiveObjects X Y i).injective
+  rw [map_zero]
+  exact (F.mapExtAddHom X Y i e).eq_zero_of_hasProjectiveDimensionLT n hi
+
+omit [EnoughProjectives D] in
+lemma hasProjectiveDimensionLT_map
+    (F : C ⥤ D) [F.Additive] [PreservesFiniteLimits F] [PreservesFiniteColimits F]
+    [F.PreservesProjectiveObjects] (X : C) (n : ℕ) [HasProjectiveDimensionLT X n] :
+    HasProjectiveDimensionLT (F.obj X) n := by
+  induction n generalizing X with
+  | zero =>
+    exact (F.map_isZero (isZero_of_hasProjectiveDimensionLT_zero X)).hasProjectiveDimensionLT_zero
+  | succ n ih =>
+    cases n with
+    | zero =>
+      let : Projective X := projective_iff_hasProjectiveDimensionLT_one.mpr (by assumption)
+      exact inferInstance
+    | succ n =>
+      let S := ShortComplex.mk (kernel.ι (Projective.π X)) (Projective.π X)
+        (kernel.condition (Projective.π X))
+      have hs : S.ShortExact := { exact := ShortComplex.exact_kernel (Projective.π X) }
+      have hk : HasProjectiveDimensionLT S.X₁ (n + 1) :=
+        (hs.hasProjectiveDimensionLT_X₃_iff n inferInstance).mp inferInstance
+      let := hk
+      exact (hs.map_of_exact F).hasProjectiveDimensionLT_X₃ (n + 1)
+        (ih S.X₁) (by
+          change HasProjectiveDimensionLT (F.obj (Projective.over X)) (n + 1 + 1)
+          exact hasProjectiveDimensionLT_of_ge _ 1 _ (by omega))
+
+omit [EnoughProjectives D] in
+lemma projectiveDimension_fullyFaithful
+    (F : C ⥤ D) [F.Additive] [PreservesFiniteLimits F] [PreservesFiniteColimits F]
+    [F.PreservesProjectiveObjects] [F.Full] [F.Faithful] (X : C) :
+    projectiveDimension (F.obj X) = projectiveDimension X := by
+  have h (n : ℕ) : HasProjectiveDimensionLT (F.obj X) n ↔ HasProjectiveDimensionLT X n :=
+    ⟨fun h => @hasProjectiveDimensionLT_of_fullyFaithful _ _ _ _ _ _ _ F _ _ _ _ _ _ X n h,
+      fun h => @hasProjectiveDimensionLT_map _ _ _ _ _ _ _ F _ _ _ _ X n h⟩
+  simp only [projectiveDimension, h]
+
+lemma hasProjectiveDimensionLT_equivalence_iff (e : C ≌ D) (X : C) (n : ℕ) :
+    HasProjectiveDimensionLT (e.functor.obj X) n ↔ HasProjectiveDimensionLT X n := by
+  let : e.functor.Additive := e.functor.additive_of_preserves_binary_products
+  let : e.inverse.Additive := e.inverse.additive_of_preserves_binary_products
+  constructor
+  · intro h
+    let : HasProjectiveDimensionLT (e.functor.obj X) n := h
+    exact hasProjectiveDimensionLT_of_fullyFaithful e.functor X n
+  · intro h
+    let : HasProjectiveDimensionLT X n := h
+    let : HasProjectiveDimensionLT (e.inverse.obj (e.functor.obj X)) n :=
+      hasProjectiveDimensionLT_of_iso (show X ≅ e.inverse.obj (e.functor.obj X) from
+        e.unitIso.app X) n
+    exact hasProjectiveDimensionLT_of_fullyFaithful e.inverse (e.functor.obj X) n
+
+lemma projectiveDimension_equivalence (e : C ≌ D) (X : C) :
+    projectiveDimension (e.functor.obj X) = projectiveDimension X := by
+  simp only [projectiveDimension, hasProjectiveDimensionLT_equivalence_iff e X]
+
+end ProjectiveTransport
+
+end LittleFinitistic
+end
+end
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/FinitisticAsymmetry/Transport/ScalarRestriction.lean b/lean/OAI/Algebra/FinitisticAsymmetry/Transport/ScalarRestriction.lean
new file mode 100644
index 0000000000000000000000000000000000000000..dc689f3df76af72fabe966dd2d29d20bb0be24d2
--- /dev/null
+++ b/lean/OAI/Algebra/FinitisticAsymmetry/Transport/ScalarRestriction.lean
@@ -0,0 +1,107 @@
+import Mathlib
+import OAI.Algebra.FinitisticAsymmetry.Transport.ProjectiveDimension
+
+namespace OAI
+
+section
+section
+noncomputable section
+open CategoryTheory
+namespace LittleFinitistic
+universe u
+variable (A : Type u) [Ring A]
+
+section RestrictionAlongSurjection
+universe v
+variable {R S : Type v} [Ring R] [Ring S]
+
+open CategoryTheory.Limits
+
+instance restrictScalars_preservesFiniteLimits (f : R →+* S) :
+    PreservesFiniteLimits (ModuleCat.restrictScalars.{v} f) where
+  preservesFiniteLimits _ _ _ := { preservesLimit := fun {_} => inferInstance }
+
+instance restrictScalars_preservesFiniteColimits (f : R →+* S) :
+    PreservesFiniteColimits (ModuleCat.restrictScalars.{v} f) where
+  preservesFiniteColimits _ _ _ := { preservesColimit := fun {_} => inferInstance }
+
+lemma restrictScalars_full (f : R →+* S) (hf : Function.Surjective f) :
+    (ModuleCat.restrictScalars.{v} f).Full where
+  map_surjective {M N} g := by
+    refine ⟨ModuleCat.ofHom { g.hom with map_smul' := ?_ }, ?_⟩
+    · intro s m
+      obtain ⟨r, rfl⟩ := hf s
+      exact g.hom.map_smul r m
+    · rfl
+
+lemma restrictScalars_preservesProjectives (f : R →+* S)
+    [Module.Projective R ((ModuleCat.restrictScalars f).obj (ModuleCat.of S S))] :
+    (ModuleCat.restrictScalars.{v} f).PreservesProjectiveObjects where
+  projective_obj {P} hP := by
+    classical
+    let := hP
+    let F := ModuleCat.restrictScalars.{v} f
+    let Q := F.obj (ModuleCat.of S S)
+    obtain ⟨i, hi⟩ := Module.projective_def'.mp (inferInstance : Module.Projective S P)
+    let : Module.Projective R (F.obj (ModuleCat.of S (P →₀ S))) := by
+      change Module.Projective R (P →₀ Q)
+      exact Module.Projective.of_equiv (finsuppLequivDFinsupp R).symm
+    let : Module.Projective R (F.obj P) := Module.Projective.of_split
+      (F.map (ModuleCat.ofHom i)).hom
+      (F.map (ModuleCat.ofHom (Finsupp.linearCombination S id))).hom (by
+        ext x
+        exact DFunLike.congr_fun hi x)
+    exact inferInstance
+
+lemma finite_restrictScalars (f : R →+* S) (hf : Function.Surjective f)
+    (M : ModuleCat.{v} S) [Module.Finite S M] :
+    Module.Finite R ((ModuleCat.restrictScalars f).obj M) := by
+  let N := (ModuleCat.restrictScalars f).obj M
+  obtain ⟨s, hs⟩ := Module.Finite.fg_top (R := S) (M := M)
+  refine ⟨s, ?_⟩
+  apply top_unique
+  intro x hx
+  have hx' : (x : M) ∈ Submodule.span S (s : Set M) := by rw [hs]; trivial
+  clear hx
+  induction hx' using Submodule.span_induction with
+  | mem x hx => exact Submodule.subset_span hx
+  | zero => exact Submodule.zero_mem _
+  | add x y hx hy ihx ihy => exact Submodule.add_mem _ ihx ihy
+  | smul a x hx ih =>
+    obtain ⟨r, rfl⟩ := hf a
+    exact Submodule.smul_mem (Submodule.span R (show Set N from (s : Set M))) r ih
+
+lemma littleFinitisticDimension_le_restrictScalars (f : R →+* S)
+    (hf : Function.Surjective f)
+    [Module.Projective R ((ModuleCat.restrictScalars f).obj (ModuleCat.of S S))] :
+    littleFinitisticDimension S ≤ littleFinitisticDimension R := by
+  let := restrictScalars_full f hf
+  let := restrictScalars_preservesProjectives f
+  refine iSup_le fun M => iSup_le fun hfg => iSup_le fun hpd => ?_
+  let := hfg
+  have heq := projectiveDimension_fullyFaithful (ModuleCat.restrictScalars f) M
+  rw [← heq]
+  exact le_iSup_of_le ((ModuleCat.restrictScalars f).obj M)
+    (le_iSup_of_le (finite_restrictScalars f hf M)
+      (le_iSup_of_le (by rwa [heq]) le_rfl))
+
+lemma bigFinitisticDimension_le_restrictScalars (f : R →+* S)
+    (hf : Function.Surjective f)
+    [Module.Projective R ((ModuleCat.restrictScalars f).obj (ModuleCat.of S S))] :
+    bigFinitisticDimension S ≤ bigFinitisticDimension R := by
+  let := restrictScalars_full f hf
+  let := restrictScalars_preservesProjectives f
+  refine iSup_le fun M => iSup_le fun hpd => ?_
+  have heq := projectiveDimension_fullyFaithful (ModuleCat.restrictScalars f) M
+  rw [← heq]
+  exact le_iSup_of_le ((ModuleCat.restrictScalars f).obj M)
+    (le_iSup_of_le (by rwa [heq]) le_rfl)
+
+end RestrictionAlongSurjection
+
+end LittleFinitistic
+end
+end
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/FinitisticAsymmetry/Triangular/Algebra.lean b/lean/OAI/Algebra/FinitisticAsymmetry/Triangular/Algebra.lean
new file mode 100644
index 0000000000000000000000000000000000000000..c011c9bb0742a13f2883936826c37a2910ad08b3
--- /dev/null
+++ b/lean/OAI/Algebra/FinitisticAsymmetry/Triangular/Algebra.lean
@@ -0,0 +1,142 @@
+import Mathlib
+import OAI.Algebra.FinitisticAsymmetry.Transport.ScalarRestriction
+
+namespace OAI
+
+section
+section
+noncomputable section
+open CategoryTheory
+namespace LittleFinitistic
+universe u
+variable (A : Type u) [Ring A]
+namespace TriangularConstruction
+universe v
+variable (C E U : Type v)
+
+def OffDiagonal (_C _E U : Type v) := U
+
+def offValue {C E U : Type v} (x : OffDiagonal C E U) : U := x
+
+namespace OffDiagonal
+variable [Ring C] [Ring E] [AddCommGroup U]
+
+instance : AddCommGroup (OffDiagonal C E U) := inferInstanceAs (AddCommGroup U)
+
+instance [Module E U] : Module (C × E) (OffDiagonal C E U) :=
+  Module.compHom U (RingHom.snd C E)
+
+instance [Module Cᵐᵒᵖ U] : Module (C × E)ᵐᵒᵖ (OffDiagonal C E U) :=
+  Module.compHom U (RingHom.fst C E).op
+
+instance [Module E U] [Module Cᵐᵒᵖ U] [SMulCommClass E Cᵐᵒᵖ U] :
+    SMulCommClass (C × E) (C × E)ᵐᵒᵖ (OffDiagonal C E U) where
+  smul_comm p q x := by
+    change p.2 • (MulOpposite.op q.unop.1 • (offValue x)) =
+      MulOpposite.op q.unop.1 • (p.2 • (offValue x))
+    exact smul_comm _ _ _
+
+variable (k : Type v) [Field k] [_root_.Algebra k C] [_root_.Algebra k E] [Module k U]
+
+instance : Module k (OffDiagonal C E U) := inferInstanceAs (Module k U)
+
+instance [Module E U] [IsScalarTower k E U] :
+    IsScalarTower k (C × E) (OffDiagonal C E U) where
+  smul_assoc r p x := by
+    change (r • p.2) • (offValue x) = r • (p.2 • (offValue x))
+    exact smul_assoc _ _ _
+
+instance [Module Cᵐᵒᵖ U] [IsScalarTower k Cᵐᵒᵖ U] :
+    IsScalarTower k (C × E)ᵐᵒᵖ (OffDiagonal C E U) where
+  smul_assoc r p x := by
+    change (r • MulOpposite.op p.unop.1) • (offValue x) =
+      r • (MulOpposite.op p.unop.1 • (offValue x))
+    exact smul_assoc _ _ _
+
+instance [FiniteDimensional k U] : FiniteDimensional k (OffDiagonal C E U) :=
+  inferInstanceAs (FiniteDimensional k U)
+
+end OffDiagonal
+
+abbrev Algebra := TrivSqZeroExt (C × E) (OffDiagonal C E U)
+
+variable [Ring C] [Ring E] [AddCommGroup U] [Module E U] [Module Cᵐᵒᵖ U]
+  [SMulCommClass E Cᵐᵒᵖ U]
+
+omit [SMulCommClass E Cᵐᵒᵖ U] in
+lemma mul_formula (x y : Algebra C E U) :
+    x * y = ((x.fst.1 * y.fst.1, x.fst.2 * y.fst.2),
+      x.fst.2 • (offValue y.snd) + MulOpposite.op y.fst.1 • (offValue x.snd)) := rfl
+
+def toC : Algebra C E U →+* C where
+  toFun x := x.fst.1
+  map_zero' := rfl
+  map_one' := rfl
+  map_add' _ _ := rfl
+  map_mul' _ _ := rfl
+
+omit [SMulCommClass E Cᵐᵒᵖ U] in
+lemma toC_surjective : Function.Surjective (toC C E U) :=
+  fun c => ⟨((c, 0), 0), rfl⟩
+
+def rightCornerSection :
+    ((ModuleCat.restrictScalars (toC C E U).op).obj (ModuleCat.of Cᵐᵒᵖ Cᵐᵒᵖ)) →ₗ[
+      (Algebra C E U)ᵐᵒᵖ] (Algebra C E U)ᵐᵒᵖ where
+  toFun c := MulOpposite.op ((c.unop, 0), 0)
+  map_add' c d := by
+    apply MulOpposite.unop_injective
+    apply TrivSqZeroExt.ext
+    · apply Prod.ext
+      · rfl
+      · exact (zero_add (0 : E)).symm
+    · exact (zero_add (0 : U)).symm
+  map_smul' r c := by
+    apply MulOpposite.unop_injective
+    apply TrivSqZeroExt.ext
+    · apply Prod.ext
+      · rfl
+      · exact (zero_mul _).symm
+    · change 0 = (0 : E) • (offValue r.unop.snd) + MulOpposite.op r.unop.fst.1 • (0 : U)
+      simp
+
+lemma rightCorner_projective :
+    Module.Projective (Algebra C E U)ᵐᵒᵖ
+      ((ModuleCat.restrictScalars (toC C E U).op).obj (ModuleCat.of Cᵐᵒᵖ Cᵐᵒᵖ)) := by
+  apply Module.Projective.of_split (rightCornerSection C E U)
+    (Module.compHom.toLinearMap (toC C E U).op)
+  ext x
+  rfl
+
+lemma right_little_lower_bound :
+    littleFinitisticDimension Cᵐᵒᵖ ≤ littleFinitisticDimension (Algebra C E U)ᵐᵒᵖ := by
+  let := rightCorner_projective C E U
+  apply littleFinitisticDimension_le_restrictScalars (toC C E U).op
+  intro c
+  obtain ⟨t, ht⟩ := toC_surjective C E U c.unop
+  exact ⟨MulOpposite.op t, congrArg MulOpposite.op ht⟩
+
+lemma right_big_lower_bound :
+    bigFinitisticDimension Cᵐᵒᵖ ≤ bigFinitisticDimension (Algebra C E U)ᵐᵒᵖ := by
+  let := rightCorner_projective C E U
+  apply bigFinitisticDimension_le_restrictScalars (toC C E U).op
+  intro c
+  obtain ⟨t, ht⟩ := toC_surjective C E U c.unop
+  exact ⟨MulOpposite.op t, congrArg MulOpposite.op ht⟩
+
+variable (k : Type v) [Field k] [_root_.Algebra k C] [_root_.Algebra k E] [Module k U]
+  [IsScalarTower k E U] [IsScalarTower k Cᵐᵒᵖ U]
+  [FiniteDimensional k C] [FiniteDimensional k E] [FiniteDimensional k U]
+
+omit [Module E U] [Module Cᵐᵒᵖ U] [SMulCommClass E Cᵐᵒᵖ U]
+  [IsScalarTower k E U] [IsScalarTower k Cᵐᵒᵖ U] in
+lemma finiteDimensional : FiniteDimensional k (Algebra C E U) :=
+  inferInstanceAs (FiniteDimensional k ((C × E) × OffDiagonal C E U))
+
+end TriangularConstruction
+
+end LittleFinitistic
+end
+end
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/FinitisticAsymmetry/Triangular/Augmentation.lean b/lean/OAI/Algebra/FinitisticAsymmetry/Triangular/Augmentation.lean
new file mode 100644
index 0000000000000000000000000000000000000000..f2359f44589fe310ac6489e9e1df8d3dcea464c5
--- /dev/null
+++ b/lean/OAI/Algebra/FinitisticAsymmetry/Triangular/Augmentation.lean
@@ -0,0 +1,110 @@
+import Mathlib
+import OAI.Algebra.FinitisticAsymmetry.ZeroDimensions
+import OAI.Algebra.FinitisticAsymmetry.Triangular.Socle
+
+namespace OAI
+
+section
+section
+noncomputable section
+open CategoryTheory
+namespace LittleFinitistic
+universe u
+variable (A : Type u) [Ring A]
+namespace CummingsConstruction
+variable {k C ι : Type u} [Field k] [Ring C] [Algebra k C]
+variable (χ : C →ₐ[k] (ι → k))
+lemma mem_ker_augmentation (x : T χ) :
+    x ∈ RingHom.ker (augmentation χ).toRingHom ↔ χ x.fst.1 = 0 ∧ newAugmentation x.fst.2 = 0 := by
+  change (Sum.elim (χ x.fst.1) (newAugmentation x.fst.2) : Sum ι ι → k) = 0 ↔ _
+  constructor
+  · intro h
+    exact ⟨funext fun i => congrFun h (.inl i), funext fun i => congrFun h (.inr i)⟩
+  · rintro ⟨h₁, h₂⟩
+    ext i
+    cases i <;> simp [h₁, h₂]
+
+def pureOldRadical : Ideal (T χ) where
+  carrier := {x | x.fst.2 = 0 ∧ (SimpleSum.value (TriangularConstruction.offValue x.snd)) = 0 ∧ χ x.fst.1 = 0}
+  zero_mem' := ⟨rfl, rfl, map_zero χ⟩
+  add_mem' := by
+    rintro x y ⟨hxe, hxu, hxc⟩ ⟨hye, hyu, hyc⟩
+    change x.fst.2 + y.fst.2 = 0 ∧
+      SimpleSum.value (TriangularConstruction.offValue x.snd) + SimpleSum.value (TriangularConstruction.offValue y.snd) = 0 ∧ χ (x.fst.1 + y.fst.1) = 0
+    simp [hxe, hye, hxu, hyu, hxc, hyc, map_add]
+  smul_mem' := by
+    rintro r x ⟨hxe, hxu, hxc⟩
+    change r.fst.2 * x.fst.2 = 0 ∧
+      newAugmentation r.fst.2 * SimpleSum.value (TriangularConstruction.offValue x.snd) +
+        χ x.fst.1 * SimpleSum.value (TriangularConstruction.offValue r.snd) = 0 ∧ χ (r.fst.1 * x.fst.1) = 0
+    simp [hxe, hxu, hxc, map_mul]
+
+lemma ker_square_pureOldRadical :
+    (RingHom.ker (augmentation χ).toRingHom) ^ 2 ≤ pureOldRadical χ := by
+  rw [Submodule.pow_succ, Submodule.pow_one]
+  apply Ideal.mul_le.mpr
+  intro x hx y hy
+  obtain ⟨hxc, hxe⟩ := (mem_ker_augmentation χ x).mp hx
+  obtain ⟨hyc, hye⟩ := (mem_ker_augmentation χ y).mp hy
+  change x.fst.2 * y.fst.2 = 0 ∧
+    newAugmentation x.fst.2 * SimpleSum.value (TriangularConstruction.offValue y.snd) +
+      χ y.fst.1 * SimpleSum.value (TriangularConstruction.offValue x.snd) = 0 ∧ χ (x.fst.1 * y.fst.1) = 0
+  refine ⟨?_, by simp [hxe, hyc], by simp [map_mul, hxc]⟩
+  ext i : 1
+  have hx0 : (x.fst.2 i).fst = 0 := congrFun hxe i
+  have hy0 : (y.fst.2 i).fst = 0 := congrFun hye i
+  apply TrivSqZeroExt.ext <;> simp [hx0, hy0]
+
+lemma pow_le_comap_pow_noncomm {R S : Type*} [Ring R] [Ring S] (f : R →+* S)
+    (I : Ideal R) (J : Ideal S) (h : I ≤ J.comap f) (n : ℕ) : I ^ n ≤ (J ^ n).comap f := by
+  induction n with
+  | zero => simp [Submodule.pow_zero, Ideal.one_eq_top]
+  | succ n ih =>
+    rw [Submodule.pow_succ, Submodule.pow_succ]
+    apply Ideal.mul_le.mpr
+    intro x hx y hy
+    change f (x * y) ∈ J ^ n * J
+    rw [map_mul]
+    exact Ideal.mul_mem_mul (ih hx) (h hy)
+
+lemma augmentation_ker_nilpotent (hJ : ∃ n : ℕ, (RingHom.ker χ.toRingHom) ^ n = ⊥) :
+    ∃ n : ℕ, (RingHom.ker (augmentation χ).toRingHom) ^ n = ⊥ := by
+  obtain ⟨n, hn⟩ := hJ
+  let K := RingHom.ker (augmentation χ).toRingHom
+  let J := RingHom.ker χ.toRingHom
+  have hcomap : K ≤ J.comap (TriangularConstruction.toC C (NewCorner k ι) (SimpleSum χ)) := by
+    intro x hx
+    exact ((mem_ker_augmentation χ x).mp hx).1
+  have hpow := pow_le_comap_pow_noncomm _ K J hcomap (n + 2)
+  have hjn : J ^ (n + 2) = ⊥ := by
+    apply le_bot_iff.mp
+    exact (Ideal.pow_le_pow_right (I := J) (Nat.le_add_right n 2)).trans hn.le
+  rw [hjn] at hpow
+  refine ⟨n + 2, le_bot_iff.mp ?_⟩
+  intro x hx
+  have hc : x.fst.1 = 0 := hpow hx
+  have hp := ker_square_pureOldRadical χ ((Ideal.pow_le_pow_right (I := K) (by omega : 2 ≤ n + 2)) hx)
+  change x = 0
+  apply TrivSqZeroExt.ext
+  · exact Prod.ext hc hp.1
+  · exact hp.2.1
+
+variable [DecidableEq ι]
+
+lemma left_dimensions_zero [Finite ι] [Nontrivial C]
+    (hχ : Function.Surjective χ) (hJ : ∃ n : ℕ, (RingHom.ker χ.toRingHom) ^ n = ⊥) :
+    littleFinitisticDimension (T χ) = 0 ∧ bigFinitisticDimension (T χ) = 0 := by
+  let : Nontrivial (T χ) := inferInstanceAs (Nontrivial ((C × NewCorner k ι) ×
+    TriangularConstruction.OffDiagonal C (NewCorner k ι) (SimpleSum χ)))
+  exact dimensions_zero_of_splitBasic_rightSocle (augmentation χ)
+    (augmentation_surjective χ hχ) (augmentation_ker_nilpotent χ hJ)
+    (socle χ) (socle_ne_zero χ) (socle_mul χ)
+
+end CummingsConstruction
+end LittleFinitistic
+
+end
+end
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/FinitisticAsymmetry/Triangular/Generation.lean b/lean/OAI/Algebra/FinitisticAsymmetry/Triangular/Generation.lean
new file mode 100644
index 0000000000000000000000000000000000000000..262b6bfeecd4662fd5d437711b66fa57d5f99769
--- /dev/null
+++ b/lean/OAI/Algebra/FinitisticAsymmetry/Triangular/Generation.lean
@@ -0,0 +1,164 @@
+import Mathlib
+import OAI.Algebra.FinitisticAsymmetry.Triangular.Augmentation
+import OAI.Algebra.FinitisticAsymmetry.Derived.UpperTruncation
+import OAI.Algebra.FinitisticAsymmetry.Derived.ExactExtension
+import OAI.Algebra.FinitisticAsymmetry.Derived.ModuleGeneration
+import OAI.Algebra.FinitisticAsymmetry.Triangular.InjectiveResolution
+
+namespace OAI
+
+noncomputable section
+
+open CategoryTheory CategoryTheory.Limits CategoryTheory.Pretriangulated HomologicalComplex
+namespace LittleFinitistic.CummingsConstruction
+universe u w
+variable {k C ι : Type u} [Field k] [Ring C] [Algebra k C]
+variable (χ : C →ₐ[k] (ι → k)) (i : ι)
+
+lemma periodicOld_d (m n : ℕ) : (periodicOld χ i).d m n = 0 := by
+  by_cases h : m = n+1
+  · subst m
+    simp [periodicOld]
+    rfl
+  · exact (periodicOld χ i).shape m n (by simpa [ComplexShape.down_Rel, eq_comm] using h)
+
+def oldSingleι (n : ℕ) : (HomologicalComplex.single (ModuleCat (T χ)) (.down ℕ) n).obj
+    (oldSimple χ i) ⟶ periodicOld χ i :=
+  mkHomFromSingle (𝟙 _) (fun j hj => by simp [periodicOld_d]; exact Category.id_comp _)
+
+def oldSingleπ (n : ℕ) : periodicOld χ i ⟶
+    (HomologicalComplex.single (ModuleCat (T χ)) (.down ℕ) n).obj (oldSimple χ i) :=
+  mkHomToSingle (𝟙 _) (fun j hj => by simp [periodicOld_d]; exact Category.comp_id _)
+
+lemma oldSingleι_π (n : ℕ) : oldSingleι χ i n ≫ oldSingleπ χ i n = 𝟙 _ := by
+  apply from_single_hom_ext
+  simp [oldSingleι, oldSingleπ]
+  erw [mkHomFromSingle_f, mkHomToSingle_f, Category.comp_id, Category.id_comp,
+    Iso.hom_inv_id]
+
+abbrev extendedInjective := (periodicInjective χ i).extend ComplexShape.embeddingDownNat
+abbrev extendedRegular := (periodicRegular χ i).extend ComplexShape.embeddingDownNat
+abbrev extendedOld := (periodicOld χ i).extend ComplexShape.embeddingDownNat
+
+variable [HasDerivedCategory.{w} (ModuleCat.{u} (T χ))]
+
+def regularDerivedIso : DerivedCategory.Q.obj (extendedRegular χ i) ≅
+    (DerivedCategory.singleFunctor (ModuleCat (T χ)) 0).obj (newSimple χ i) :=
+  asIso (DerivedCategory.Q.map (extendMap (periodicAug χ i) ComplexShape.embeddingDownNat)) ≪≫
+    DerivedCategory.Q.mapIso (extendSingleIso ComplexShape.embeddingDownNat (newSimple χ i) 0 0 rfl) ≪≫
+      ((DerivedCategory.singleFunctorIsoCompQ (ModuleCat (T χ)) 0).app (newSimple χ i)).symm
+
+def oldSingleDerivedIso (n : ℕ) :
+    DerivedCategory.Q.obj (((HomologicalComplex.single (ModuleCat (T χ)) (.down ℕ) n).obj
+      (oldSimple χ i)).extend ComplexShape.embeddingDownNat) ≅
+    (DerivedCategory.singleFunctor (ModuleCat (T χ)) (-(n : ℤ))).obj (oldSimple χ i) :=
+  DerivedCategory.Q.mapIso (extendSingleIso ComplexShape.embeddingDownNat (oldSimple χ i) n (-(n : ℤ)) rfl) ≪≫
+    ((DerivedCategory.singleFunctorIsoCompQ (ModuleCat (T χ)) (-n)).app (oldSimple χ i)).symm
+
+omit [HasDerivedCategory (ModuleCat (T χ))] in
+lemma extended_shortExact :
+    ((ShortComplex.mk (periodicι χ i) (periodicπ χ i) (periodicι_π χ i)).map
+      (ComplexShape.embeddingDownNat.extendFunctor (ModuleCat (T χ)))).ShortExact :=
+  DerivedSupport.extend_shortExact _ _ (periodic_shortExact χ i)
+
+variable (P : ObjectProperty (DerivedCategory (ModuleCat.{u} (T χ))))
+  [P.IsClosedUnderIsomorphisms] [P.IsTriangulated]
+  [P.IsClosedUnderColimitsOfShape (Discrete ℕ)]
+  (hI : ∀ M : ModuleCat.{u} (T χ), Injective M →
+    P ((DerivedCategory.singleFunctor (ModuleCat (T χ)) 0).obj M))
+
+include hI
+
+lemma extendedInjective_mem [DecidableEq ι] : P (DerivedCategory.Q.obj (extendedInjective χ i)) := by
+  apply DerivedSupport.prop_of_boundedAbove_terms P _ 0
+  · intro j hj
+    exact CochainComplex.isZero_of_isStrictlyLE _ 0 j hj
+  · intro j
+    apply hI
+    by_cases hj : ∃ n : ℕ, ComplexShape.embeddingDownNat.f n = j
+    · obtain ⟨n, hn⟩ := hj
+      exact Injective.of_iso ((periodicInjective χ i).extendXIso _ hn).symm
+        (newInjective_injective χ i)
+    · exact (isZero_extend_X _ _ j (fun n hn => hj ⟨n,hn⟩)).injective
+
+lemma oldSimple_shifted_retract [DecidableEq ι] :
+    P ((DerivedCategory.singleFunctor (ModuleCat (T χ)) (-2)).obj (oldSimple χ i)) := by
+  let S := (ShortComplex.mk (periodicι χ i) (periodicπ χ i) (periodicι_π χ i)).map
+    (ComplexShape.embeddingDownNat.extendFunctor (ModuleCat (T χ)))
+  let hS := extended_shortExact χ i
+  let Δ := DerivedCategory.triangleOfSES hS
+  have hΔ : Δ ∈ distTriang _ := DerivedCategory.triangleOfSES_distinguished hS
+  let F := ComplexShape.embeddingDownNat.extendFunctor (ModuleCat (T χ)) ⋙ DerivedCategory.Q
+  let j := F.map (oldSingleι χ i 2)
+  let p := F.map (oldSingleπ χ i 2)
+  have hjp : j ≫ p = 𝟙 _ := by
+    dsimp [j,p]
+    rw [← F.map_comp, oldSingleι_π, F.map_id]
+  have hzero : j ≫ Δ.mor₃ = 0 := by
+    have hle : (DerivedCategory.TStructure.t (C := ModuleCat (T χ))).IsLE (F.obj _) (-2) :=
+      DerivedCategory.TStructure.t.isLE_of_iso (oldSingleDerivedIso χ i 2).symm (-2)
+    have hge : (DerivedCategory.TStructure.t (C := ModuleCat (T χ))).IsGE Δ.obj₁ 0 :=
+      DerivedCategory.TStructure.t.isGE_of_iso (regularDerivedIso χ i).symm 0
+    have hges := DerivedCategory.TStructure.t.isGE_shift Δ.obj₁ 0 1 (-1) (by omega)
+    exact DerivedCategory.TStructure.t.zero (j ≫ Δ.mor₃) (-2) (-1) (by omega)
+  obtain ⟨l, hl⟩ := Triangle.coyoneda_exact₃ Δ hΔ j hzero
+  have hlp : l ≫ (Δ.mor₂ ≫ p) = 𝟙 _ := by erw [← Category.assoc, ← hl, hjp]
+  apply P.prop_of_iso (oldSingleDerivedIso χ i 2)
+  exact DerivedSupport.localizing_of_retract l (Δ.mor₂ ≫ p) hlp P
+    (extendedInjective_mem χ i P hI)
+
+lemma oldSimple_mem [DecidableEq ι] :
+    P ((DerivedCategory.singleFunctor (ModuleCat (T χ)) 0).obj (oldSimple χ i)) := by
+  apply P.prop_of_iso (((DerivedCategory.singleFunctors (ModuleCat (T χ))).shiftIso
+    (-2) 0 (-2) (by omega)).app (oldSimple χ i))
+  exact P.le_shift (-2) _ (oldSimple_shifted_retract χ i P hI)
+
+lemma newRegular_mem [DecidableEq ι] :
+    P ((DerivedCategory.singleFunctor (ModuleCat (T χ)) 0).obj (newRegular χ i)) := by
+  exact DerivedSupport.prop_single_shortExact₁ P _ (newRegular_exact χ i)
+    (hI _ (newInjective_injective χ i)) (oldSimple_mem χ i P hI)
+
+lemma newSimple_mem [DecidableEq ι] :
+    P ((DerivedCategory.singleFunctor (ModuleCat (T χ)) 0).obj (newSimple χ i)) := by
+  apply P.prop_of_iso (regularDerivedIso χ i)
+  apply DerivedSupport.prop_of_boundedAbove_terms P _ 0
+  · intro j hj
+    exact CochainComplex.isZero_of_isStrictlyLE _ 0 j hj
+  · intro j
+    by_cases hj : ∃ n : ℕ, ComplexShape.embeddingDownNat.f n = j
+    · obtain ⟨n, hn⟩ := hj
+      apply P.prop_of_iso ((DerivedCategory.singleFunctor (ModuleCat (T χ)) 0).mapIso
+        ((periodicRegular χ i).extendXIso _ hn).symm)
+      exact newRegular_mem χ i P hI
+    · apply P.prop_of_isZero
+      apply (DerivedCategory.singleFunctor (ModuleCat (T χ)) 0).map_isZero
+      exact isZero_extend_X _ _ j (fun n hn => hj ⟨n,hn⟩)
+
+omit hI [HasDerivedCategory.{w} (ModuleCat.{u} (T χ))] in
+lemma injectivesGenerate [Fintype ι] (hχ : Function.Surjective χ)
+    (hnil : ∃ n : ℕ, (RingHom.ker χ.toRingHom)^n = ⊥) :
+    InjectivesGenerate (T χ) := by
+  classical
+  let := HasDerivedCategory.standard (ModuleCat.{u} (T χ))
+  intro P hP hT hcop hI X
+  let := hP
+  let := hT
+  let (I : Type u) := hcop I
+  let : P.IsClosedUnderColimitsOfShape (Discrete ℕ) :=
+    ObjectProperty.IsClosedUnderColimitsOfShape.of_equivalence
+      (Discrete.equivalence (Equiv.ulift : ULift.{u} ℕ ≃ ℕ))
+  apply DerivedSupport.localizing_eq_top_of_all_modules P
+  · intro M
+    apply DerivedSupport.prop_all_of_product_augmentation P hcop
+      (augmentation χ).toRingHom (augmentation_surjective χ hχ)
+      (augmentation_ker_nilpotent χ hnil) _ M
+    intro j
+    cases j with
+    | inl i => exact oldSimple_mem χ i P hI
+    | inr i => exact newSimple_mem χ i P hI
+
+end LittleFinitistic.CummingsConstruction
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/FinitisticAsymmetry/Triangular/InjectiveCorners.lean b/lean/OAI/Algebra/FinitisticAsymmetry/Triangular/InjectiveCorners.lean
new file mode 100644
index 0000000000000000000000000000000000000000..fcb42efa143a80d99bec06d5d754ab6fc75e22c1
--- /dev/null
+++ b/lean/OAI/Algebra/FinitisticAsymmetry/Triangular/InjectiveCorners.lean
@@ -0,0 +1,248 @@
+import Mathlib
+import OAI.Algebra.FinitisticAsymmetry.Triangular.Socle
+
+namespace OAI
+
+noncomputable section
+
+open CategoryTheory
+namespace LittleFinitistic.CummingsConstruction
+
+section
+universe u
+variable {k C ι : Type u} [Field k] [Ring C] [Algebra k C]
+variable (χ : C →ₐ[k] (ι → k)) (i : ι)
+
+def cval (r : T χ) : k := χ r.fst.1 i
+def ehead (r : T χ) : k := (r.fst.2 i).fst
+def etail (r : T χ) : k := (r.fst.2 i).snd
+def oval (r : T χ) : k := (SimpleSum.value (TriangularConstruction.offValue r.snd)) i
+
+@[simp] lemma cval_mul (r s : T χ) : cval χ i (r*s) = cval χ i r * cval χ i s := by
+  change χ (r.fst.1 * s.fst.1) i = _
+  simp [cval]
+@[simp] lemma ehead_mul (r s : T χ) : ehead χ i (r*s) = ehead χ i r * ehead χ i s := rfl
+@[simp] lemma etail_mul (r s : T χ) : etail χ i (r*s) = ehead χ i r * etail χ i s + ehead χ i s * etail χ i r := by
+  change _ * _ + _ * _ = _
+  change (r.fst.2 i).fst * (s.fst.2 i).snd + (r.fst.2 i).snd * (s.fst.2 i).fst = _
+  dsimp only [ehead, etail]
+  ring
+@[simp] lemma oval_mul (r s : T χ) : oval χ i (r*s) = ehead χ i r * oval χ i s + cval χ i s * oval χ i r := rfl
+
+def NewInjective (_χ : C →ₐ[k] (ι → k)) (_i : ι) := k × (k × k)
+namespace NewInjective
+
+def value (x : NewInjective χ i) : k × (k × k) := x
+
+@[ext] lemma ext {x y : NewInjective χ i}
+    (h₁ : (value χ i x).1 = (value χ i y).1)
+    (h₂ : (value χ i x).2.1 = (value χ i y).2.1)
+    (h₃ : (value χ i x).2.2 = (value χ i y).2.2) : x = y :=
+  Prod.ext h₁ (Prod.ext h₂ h₃)
+instance : AddCommGroup (NewInjective χ i) := inferInstanceAs (AddCommGroup (k × (k × k)))
+
+def act (r : T χ) (x : NewInjective χ i) : NewInjective χ i :=
+  (cval χ i r * (value χ i x).1,
+    ehead χ i r * (value χ i x).2.1,
+    oval χ i r * (value χ i x).1 + etail χ i r * (value χ i x).2.1 + ehead χ i r * (value χ i x).2.2)
+
+instance : SMul (T χ) (NewInjective χ i) := ⟨act χ i⟩
+
+instance : Module (T χ) (NewInjective χ i) where
+  one_smul x := by
+    change (χ 1 i * _, (1 * _, 0 * _ + 0 * _ + 1 * _)) = value χ i x
+    simp
+  mul_smul r s x := by
+    change act χ i (r*s) x = act χ i r (act χ i s x)
+    simp only [act, value, cval_mul, ehead_mul, etail_mul, oval_mul]
+    apply ext <;> dsimp [value, NewInjective] <;> ring
+  smul_zero r := by
+    change act χ i r (0,0,0) = (0,0,0)
+    simp only [act, value, mul_zero, add_zero]
+    rfl
+  smul_add r x y := by
+    apply ext
+    · change cval χ i r * (x.1 + y.1) = cval χ i r*x.1 + cval χ i r*y.1
+      ring
+    · change ehead χ i r * (x.2.1 + y.2.1) = ehead χ i r*x.2.1 + ehead χ i r*y.2.1
+      ring
+    · change oval χ i r * (x.1+y.1) + etail χ i r * (x.2.1+y.2.1) +
+        ehead χ i r * (x.2.2+y.2.2) =
+        (oval χ i r*x.1 + etail χ i r*x.2.1 + ehead χ i r*x.2.2) +
+        (oval χ i r*y.1 + etail χ i r*y.2.1 + ehead χ i r*y.2.2)
+      ring
+  add_smul r s x := by
+    apply ext
+    · change χ (r.fst.1+s.fst.1) i * x.1 = χ r.fst.1 i*x.1 + χ s.fst.1 i*x.1
+      simp [map_add, add_mul]
+    · change ((r.fst.2 i).fst + (s.fst.2 i).fst)*x.2.1 =
+        (r.fst.2 i).fst*x.2.1 + (s.fst.2 i).fst*x.2.1
+      ring
+    · change (oval χ i r + oval χ i s)*x.1 +
+        (etail χ i r + etail χ i s)*x.2.1 +
+        (ehead χ i r + ehead χ i s)*x.2.2 =
+        (oval χ i r*x.1 + etail χ i r*x.2.1 + ehead χ i r*x.2.2) +
+        (oval χ i s*x.1 + etail χ i s*x.2.1 + ehead χ i s*x.2.2)
+      ring
+  zero_smul x := by
+    change (χ 0 i * _, (0 * _, 0 * _ + 0 * _ + 0 * _)) = (0,0,0)
+    simp
+
+end NewInjective
+end
+
+section
+open CategoryTheory
+universe u
+variable {k C ι : Type u} [Field k] [Ring C] [Algebra k C]
+variable (χ : C →ₐ[k] (ι → k)) (i : ι) [DecidableEq ι]
+
+def newIdem : T χ := ((0, Pi.single i 1), 0)
+
+lemma newIdem_mul (r : T χ) : newIdem χ i * r =
+    oval χ i r • socle χ (.inl i) + etail χ i r • socle χ (.inr i) +
+    ehead χ i r • newIdem χ i := by
+  apply TrivSqZeroExt.ext
+  · apply Prod.ext
+    · change (0 : C) * r.fst.1 = _
+      change 0 * r.fst.1 = (oval χ i r) • (0 : C) + (etail χ i r) • 0 + (ehead χ i r) • 0
+      simp
+    · change (Pi.single i 1 : ι → DualNumber k) * r.fst.2 =
+        (oval χ i r) • (0 : ι → DualNumber k) +
+        (etail χ i r) • (Pi.single i (DualNumber.eps : DualNumber k) : ι → DualNumber k) +
+        (ehead χ i r) • (Pi.single i (1 : DualNumber k) : ι → DualNumber k)
+      ext j : 1
+      by_cases hj : j = i
+      · subst j
+        apply TrivSqZeroExt.ext <;>
+          simp [etail, ehead]
+      · apply TrivSqZeroExt.ext <;>
+          simp [hj]
+  · change (newAugmentation (Pi.single i 1 : ι → DualNumber k) *
+      SimpleSum.value (TriangularConstruction.offValue r.snd) +
+      SimpleSum.rightCharacter χ (MulOpposite.op r.fst.1) * 0) = _
+    change (newAugmentation (Pi.single i 1 : ι → DualNumber k) *
+      SimpleSum.value (TriangularConstruction.offValue r.snd) +
+      SimpleSum.rightCharacter χ (MulOpposite.op r.fst.1) * 0) =
+      (oval χ i r) • (Pi.single i (1 : k) : ι → k) + (etail χ i r) • 0 + (ehead χ i r) • 0
+    ext j
+    by_cases hj : j = i
+    · subst j
+      simp [oval, newAugmentation]
+    · simp [oval, newAugmentation, hj]
+
+lemma field_module_injective (V : ModuleCat.{u} k) : Injective V where
+  factors {X Y} g f hf := by
+    obtain ⟨s, hs⟩ := f.hom.exists_leftInverse_of_injective
+      (LinearMap.ker_eq_bot.mpr ((ModuleCat.mono_iff_injective f).mp hf))
+    refine ⟨ModuleCat.ofHom (g.hom.comp s), ?_⟩
+    apply ModuleCat.hom_ext
+    change g.hom.comp (s.comp f.hom) = g.hom
+    rw [hs, LinearMap.comp_id]
+
+abbrev coindField := (ModuleCat.coextendScalars (algebraMap k (T χ))).obj (ModuleCat.of k k)
+
+instance coindField_injective : Injective (coindField χ) :=
+  (ModuleCat.restrictCoextendScalarsAdj (algebraMap k (T χ))).map_injective _
+    (field_module_injective (ModuleCat.of k k))
+
+omit [DecidableEq ι] in
+lemma coindField_smul_eval
+    (h : (ModuleCat.restrictScalars (algebraMap k (T χ))).obj
+      (ModuleCat.of (T χ) (T χ)) →ₗ[k] k) (a : k) (r : T χ) :
+    h (a • r) = a • h r := by
+  have scalar_eq := h.map_smul a r
+  change h (algebraMap k (T χ) a * r) = a • h r at scalar_eq
+  calc
+    h (a • r) = h (algebraMap k (T χ) a * r) := congrArg h (Algebra.smul_def a r)
+    _ = a • h r := scalar_eq
+
+omit [DecidableEq ι] in
+lemma coindField_add_eval
+    (h : (ModuleCat.restrictScalars (algebraMap k (T χ))).obj
+      (ModuleCat.of (T χ) (T χ)) →ₗ[k] k) (r s : T χ) :
+    h (r+s) = h r + h s := h.map_add r s
+
+def newInjectiveRetraction : coindField χ ⟶ ModuleCat.of (T χ) (NewInjective χ i) :=
+  ModuleCat.ofHom {
+    toFun := fun h => (h (socle χ (.inl i)), h (socle χ (.inr i)), h (newIdem χ i))
+    map_add' := fun _ _ => rfl
+    map_smul' := fun r h => by
+      apply NewInjective.ext
+      · change h (socle χ (.inl i) * r) = cval χ i r * h (socle χ (.inl i))
+        rw [socle_mul, coindField_smul_eval]
+        rfl
+      · change h (socle χ (.inr i) * r) = ehead χ i r * h (socle χ (.inr i))
+        rw [socle_mul, coindField_smul_eval]
+        rfl
+      · change h (newIdem χ i * r) = oval χ i r * h (socle χ (.inl i)) +
+          etail χ i r * h (socle χ (.inr i)) + ehead χ i r * h (newIdem χ i)
+        rw [newIdem_mul, coindField_add_eval, coindField_add_eval, coindField_smul_eval,
+          coindField_smul_eval, coindField_smul_eval]
+        rfl }
+
+end
+
+open CategoryTheory
+universe u
+variable {k C ι : Type u} [Field k] [Ring C] [Algebra k C]
+variable (χ : C →ₐ[k] (ι → k)) (i : ι) [DecidableEq ι]
+
+def lastCoordinate : (ModuleCat.restrictScalars (algebraMap k (T χ))).obj
+    (ModuleCat.of (T χ) (NewInjective χ i)) ⟶ ModuleCat.of k k := ModuleCat.ofHom
+  (X := (ModuleCat.restrictScalars (algebraMap k (T χ))).obj
+    (ModuleCat.of (T χ) (NewInjective χ i))) (Y := ModuleCat.of k k)
+  (show (ModuleCat.restrictScalars (algebraMap k (T χ))).obj
+    (ModuleCat.of (T χ) (NewInjective χ i)) →ₗ[k] k from {
+  toFun := fun x => (NewInjective.value χ i x).2.2
+  map_add' := fun _ _ => rfl
+  map_smul' := fun a x => by
+    change (NewInjective.act χ i ((algebraMap k (T χ)) a) x).2.2 = a * x.2.2
+    change (0 * x.1 + 0 * x.2.1 + a * x.2.2) = a * x.2.2
+    simp })
+
+def newInjectiveInclusion : ModuleCat.of (T χ) (NewInjective χ i) ⟶ coindField χ :=
+  ModuleCat.RestrictionCoextensionAdj.HomEquiv.fromRestriction _ (lastCoordinate χ i)
+
+omit [DecidableEq ι] in
+lemma newInjectiveInclusion_apply (x : NewInjective χ i) (r : T χ) :
+    (newInjectiveInclusion χ i x) r = (NewInjective.act χ i r x).2.2 := by
+  change (ModuleCat.RestrictionCoextensionAdj.HomEquiv.fromRestriction _
+    (lastCoordinate χ i)).hom x r = _
+  rw [ModuleCat.RestrictionCoextensionAdj.HomEquiv.fromRestriction_hom_apply_apply]
+  change (r • x : NewInjective χ i).2.2 = _
+  rfl
+
+lemma newInjectiveInclusion_retraction :
+    newInjectiveInclusion χ i ≫ newInjectiveRetraction χ i = 𝟙 _ := by
+  apply ModuleCat.hom_ext
+  apply LinearMap.ext
+  intro x
+  change (newInjectiveRetraction χ i (newInjectiveInclusion χ i x)) = x
+  apply NewInjective.ext (χ := χ) (i := i)
+  · change (newInjectiveInclusion χ i x) (socle χ (.inl i)) = x.1
+    rw [newInjectiveInclusion_apply]
+    change (NewInjective.act χ i (socle χ (.inl i)) x).2.2 = x.1
+    change (Pi.single (M := fun _ : ι => k) i 1) i * x.1 + 0 * x.2.1 + 0 * x.2.2 = x.1
+    simp
+  · change (newInjectiveInclusion χ i x) (socle χ (.inr i)) = x.2.1
+    rw [newInjectiveInclusion_apply]
+    change (NewInjective.act χ i (socle χ (.inr i)) x).2.2 = x.2.1
+    simp [NewInjective.act, NewInjective.value, oval, etail, ehead, socle, TriangularConstruction.offValue, SimpleSum.value]
+    try exact Or.inl rfl
+  · change (newInjectiveInclusion χ i x) (newIdem χ i) = x.2.2
+    rw [newInjectiveInclusion_apply]
+    change (NewInjective.act χ i (newIdem χ i) x).2.2 = x.2.2
+    simp [NewInjective.act, NewInjective.value, oval, etail, ehead, newIdem, TriangularConstruction.offValue, SimpleSum.value]
+    exact Or.inl rfl
+
+lemma newInjective_injective : Injective (ModuleCat.of (T χ) (NewInjective χ i)) := by
+  exact (show CategoryTheory.Retract (ModuleCat.of (T χ) (NewInjective χ i))
+    (coindField χ) from ⟨newInjectiveInclusion χ i, newInjectiveRetraction χ i,
+      newInjectiveInclusion_retraction χ i⟩).injective
+
+end LittleFinitistic.CummingsConstruction
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/FinitisticAsymmetry/Triangular/InjectiveResolution.lean b/lean/OAI/Algebra/FinitisticAsymmetry/Triangular/InjectiveResolution.lean
new file mode 100644
index 0000000000000000000000000000000000000000..5b6c272538203c3f39ddc9efd3c4f2d91a0b8708
--- /dev/null
+++ b/lean/OAI/Algebra/FinitisticAsymmetry/Triangular/InjectiveResolution.lean
@@ -0,0 +1,238 @@
+import Mathlib
+import OAI.Algebra.FinitisticAsymmetry.Triangular.InjectiveCorners
+
+namespace OAI
+
+noncomputable section
+
+open CategoryTheory
+namespace LittleFinitistic.CummingsConstruction
+open CategoryTheory CategoryTheory.Limits HomologicalComplex
+universe u
+variable {k C ι : Type u} [Field k] [Ring C] [Algebra k C]
+variable (χ : C →ₐ[k] (ι → k)) (i : ι)
+
+def oldCharacter : T χ →+* k :=
+  (Pi.evalRingHom (fun _ : Sum ι ι => k) (.inl i)).comp (augmentation χ).toRingHom
+
+def newCharacter : T χ →+* k :=
+  (Pi.evalRingHom (fun _ : Sum ι ι => k) (.inr i)).comp (augmentation χ).toRingHom
+
+def newProjection : T χ →+* DualNumber k where
+  toFun r := r.fst.2 i
+  map_one' := rfl
+  map_zero' := rfl
+  map_add' _ _ := rfl
+  map_mul' _ _ := rfl
+
+abbrev oldSimple := (ModuleCat.restrictScalars (oldCharacter χ i)).obj (ModuleCat.of k k)
+abbrev newSimple := (ModuleCat.restrictScalars (newCharacter χ i)).obj (ModuleCat.of k k)
+abbrev newRegular := (ModuleCat.restrictScalars (newProjection χ i)).obj (ModuleCat.of (DualNumber k) (DualNumber k))
+abbrev newInjectiveObj := ModuleCat.of (T χ) (NewInjective χ i)
+
+def newRegularι : newRegular χ i ⟶ newInjectiveObj χ i := ModuleCat.ofHom
+  (X := newRegular χ i) (Y := newInjectiveObj χ i) (show
+    newRegular χ i →ₗ[T χ] newInjectiveObj χ i from {
+  toFun := fun x => (0,x.fst,x.snd)
+  map_add' := fun x y => by
+    apply NewInjective.ext (χ := χ) (i := i)
+    · exact (zero_add (0 : k)).symm
+    · rfl
+    · rfl
+  map_smul' := fun r x => by
+    apply NewInjective.ext (χ := χ) (i := i)
+    · change (0 : k) = cval χ i r * 0
+      simp
+    · rfl
+    · change ehead χ i r*x.snd + etail χ i r*x.fst =
+        oval χ i r*0 + etail χ i r*x.fst + ehead χ i r*x.snd
+      ring })
+
+def newInjectiveπ : newInjectiveObj χ i ⟶ oldSimple χ i := ModuleCat.ofHom
+  (X := newInjectiveObj χ i) (Y := oldSimple χ i) (show
+    newInjectiveObj χ i →ₗ[T χ] oldSimple χ i from {
+  toFun := fun x => x.1
+  map_add' := fun _ _ => rfl
+  map_smul' := fun _ _ => rfl })
+
+def newRegularπ : newRegular χ i ⟶ newSimple χ i := ModuleCat.ofHom
+  (X := newRegular χ i) (Y := newSimple χ i) (show
+    newRegular χ i →ₗ[T χ] newSimple χ i from {
+  toFun := fun x => x.fst
+  map_add' := fun _ _ => rfl
+  map_smul' := fun _ _ => rfl })
+
+def newSimpleι : newSimple χ i ⟶ newRegular χ i := ModuleCat.ofHom
+  (X := newSimple χ i) (Y := newRegular χ i) (show
+    newSimple χ i →ₗ[T χ] newRegular χ i from {
+  toFun := fun a => (0,a)
+  map_add' := fun a b => by
+    apply TrivSqZeroExt.ext
+    · exact (zero_add (0 : k)).symm
+    · rfl
+  map_smul' := fun r a => by
+    apply TrivSqZeroExt.ext
+    · change (0 : k) = ehead χ i r * 0
+      simp
+    · change ehead χ i r*(show k from a) = ehead χ i r*(show k from a) + etail χ i r*0
+      simp })
+
+def newDifferential : newInjectiveObj χ i ⟶ newInjectiveObj χ i := ModuleCat.ofHom
+  (X := newInjectiveObj χ i) (Y := newInjectiveObj χ i) (show
+    newInjectiveObj χ i →ₗ[T χ] newInjectiveObj χ i from {
+  toFun := fun x => (0,0,x.2.1)
+  map_add' := fun x y => by
+    apply NewInjective.ext (χ := χ) (i := i)
+    · exact (zero_add (0 : k)).symm
+    · exact (zero_add (0 : k)).symm
+    · rfl
+  map_smul' := fun r x => by
+    apply NewInjective.ext (χ := χ) (i := i)
+    · change (0 : k) = cval χ i r * 0
+      simp
+    · change (0 : k) = ehead χ i r * 0
+      simp
+    · change ehead χ i r*x.2.1 = oval χ i r*0 + etail χ i r*0 + ehead χ i r*x.2.1
+      simp })
+
+def epsDifferential : newRegular χ i ⟶ newRegular χ i := newRegularπ χ i ≫ newSimpleι χ i
+
+@[simp] lemma newDifferential_sq : newDifferential χ i ≫ newDifferential χ i = 0 := by
+  apply ModuleCat.hom_ext
+  apply LinearMap.ext
+  intro x
+  rfl
+
+@[simp] lemma epsDifferential_sq : epsDifferential χ i ≫ epsDifferential χ i = 0 := by
+  apply ModuleCat.hom_ext
+  apply LinearMap.ext
+  intro x
+  rfl
+
+lemma newRegularι_comm : newRegularι χ i ≫ newDifferential χ i =
+    epsDifferential χ i ≫ newRegularι χ i := by
+  apply ModuleCat.hom_ext
+  apply LinearMap.ext
+  intro x
+  rfl
+
+lemma newInjectiveπ_comm : newDifferential χ i ≫ newInjectiveπ χ i = 0 := by
+  apply ModuleCat.hom_ext
+  apply LinearMap.ext
+  intro x
+  rfl
+
+lemma newRegularι_π : newRegularι χ i ≫ newInjectiveπ χ i = 0 := by
+  apply ModuleCat.hom_ext
+  apply LinearMap.ext
+  intro x
+  rfl
+
+lemma newRegular_exact :
+    (ShortComplex.mk (newRegularι χ i) (newInjectiveπ χ i) (newRegularι_π χ i)).ShortExact where
+  mono_f := by
+    rw [ModuleCat.mono_iff_injective]
+    intro x y h
+    apply TrivSqZeroExt.ext
+    · exact congrArg (fun z : NewInjective χ i => z.2.1) h
+    · exact congrArg (fun z : NewInjective χ i => z.2.2) h
+  epi_g := by
+    rw [ModuleCat.epi_iff_surjective]
+    intro a
+    exact ⟨(a,0,0), rfl⟩
+  exact := by
+    rw [ShortComplex.moduleCat_exact_iff]
+    intro x hx
+    refine ⟨(x.2.1,x.2.2), ?_⟩
+    apply NewInjective.ext (χ := χ) (i := i)
+    · exact hx.symm
+    · rfl
+    · rfl
+
+def periodicInjective : ChainComplex (ModuleCat (T χ)) ℕ :=
+  ChainComplex.of (fun _ => newInjectiveObj χ i) (fun _ => newDifferential χ i)
+    (fun _ => newDifferential_sq χ i)
+
+def periodicRegular : ChainComplex (ModuleCat (T χ)) ℕ :=
+  ChainComplex.of (fun _ => newRegular χ i) (fun _ => epsDifferential χ i)
+    (fun _ => epsDifferential_sq χ i)
+
+def periodicOld : ChainComplex (ModuleCat (T χ)) ℕ :=
+  ChainComplex.of (fun _ => oldSimple χ i) (fun _ => 0) (fun _ => by simp)
+
+def periodicι : periodicRegular χ i ⟶ periodicInjective χ i :=
+  ChainComplex.ofHom (fun _ => newRegularι χ i) (fun n => by
+    simpa [periodicInjective, periodicRegular] using newRegularι_comm χ i)
+
+def periodicπ : periodicInjective χ i ⟶ periodicOld χ i :=
+  ChainComplex.ofHom (fun _ => newInjectiveπ χ i) (fun n => by
+    simpa [periodicInjective, periodicOld] using (newInjectiveπ_comm χ i).symm)
+
+lemma periodicι_π : periodicι χ i ≫ periodicπ χ i = 0 := by
+  apply HomologicalComplex.hom_ext
+  intro n
+  exact newRegularι_π χ i
+
+lemma periodic_shortExact :
+    (ShortComplex.mk (periodicι χ i) (periodicπ χ i) (periodicι_π χ i)).ShortExact where
+  mono_f := HomologicalComplex.mono_of_mono_f _ (fun _ => (newRegular_exact χ i).mono_f)
+  epi_g := HomologicalComplex.epi_of_epi_f _ (fun _ => (newRegular_exact χ i).epi_g)
+  exact := HomologicalComplex.exact_of_degreewise_exact _ (fun _ => (newRegular_exact χ i).exact)
+
+lemma epsDifferential_π : epsDifferential χ i ≫ newRegularπ χ i = 0 := by
+  apply ModuleCat.hom_ext
+  apply LinearMap.ext
+  intro x
+  rfl
+
+lemma epsDifferential_exact :
+    (ShortComplex.mk (epsDifferential χ i) (epsDifferential χ i)
+      (epsDifferential_sq χ i)).Exact := by
+  rw [ShortComplex.moduleCat_exact_iff]
+  intro x hx
+  have hx' : x.fst = 0 := congrArg TrivSqZeroExt.snd hx
+  refine ⟨(x.snd,0), ?_⟩
+  apply TrivSqZeroExt.ext
+  · exact hx'.symm
+  · rfl
+
+lemma epsDifferential_π_exact :
+    (ShortComplex.mk (epsDifferential χ i) (newRegularπ χ i)
+      (epsDifferential_π χ i)).Exact := by
+  rw [ShortComplex.moduleCat_exact_iff]
+  intro x hx
+  refine ⟨(x.snd,0), ?_⟩
+  apply TrivSqZeroExt.ext
+  · exact hx.symm
+  · rfl
+
+instance newRegularπ_epi : Epi (newRegularπ χ i) := by
+  rw [ModuleCat.epi_iff_surjective]
+  intro a
+  exact ⟨(a,0), rfl⟩
+
+def periodicAug : periodicRegular χ i ⟶ (ChainComplex.single₀ (ModuleCat (T χ))).obj
+    (newSimple χ i) :=
+  (ChainComplex.toSingle₀Equiv _ _).symm ⟨newRegularπ χ i, epsDifferential_π χ i⟩
+
+instance periodicAug_quasiIso : QuasiIso (periodicAug χ i) := ⟨fun n => by
+  cases n with
+  | zero =>
+    rw [ChainComplex.quasiIsoAt₀_iff, ShortComplex.quasiIso_iff_of_zeros']
+    · exact ⟨epsDifferential_π_exact χ i, newRegularπ_epi χ i⟩
+    all_goals rfl
+  | succ n =>
+    rw [quasiIsoAt_iff_exactAt']
+    · rw [HomologicalComplex.exactAt_iff' _ (n+2) (n+1) n (by simp) (by simp)]
+      have hd : ChainComplex.of.d (fun _ : ℕ => newRegular χ i)
+          (fun _ : ℕ => epsDifferential χ i) (n+2) (n+1) = epsDifferential χ i :=
+        ChainComplex.of_d _ _ (n+1)
+      simpa only [HomologicalComplex.sc', HomologicalComplex.shortComplexFunctor',
+        periodicRegular, hd, ChainComplex.of_d] using epsDifferential_exact χ i
+    · apply ChainComplex.exactAt_succ_single_obj⟩
+
+end LittleFinitistic.CummingsConstruction
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/FinitisticAsymmetry/Triangular/Socle.lean b/lean/OAI/Algebra/FinitisticAsymmetry/Triangular/Socle.lean
new file mode 100644
index 0000000000000000000000000000000000000000..5c0f162a7c6f0849072c37a9daf021eb89bbe96d
--- /dev/null
+++ b/lean/OAI/Algebra/FinitisticAsymmetry/Triangular/Socle.lean
@@ -0,0 +1,148 @@
+import Mathlib
+import OAI.Algebra.FinitisticAsymmetry.Triangular.Algebra
+
+namespace OAI
+
+section
+section
+noncomputable section
+open CategoryTheory
+namespace LittleFinitistic
+universe u
+variable (A : Type u) [Ring A]
+namespace CummingsConstruction
+variable {k C ι : Type u} [Field k] [Ring C] [Algebra k C]
+
+abbrev NewCorner (k ι : Type u) := ι → DualNumber k
+
+instance [Finite ι] : FiniteDimensional k (NewCorner k ι) := by
+  let : FiniteDimensional k (DualNumber k) := inferInstanceAs (FiniteDimensional k (k × k))
+  exact inferInstanceAs (FiniteDimensional k (ι → DualNumber k))
+
+def newAugmentation : NewCorner k ι →ₐ[k] (ι → k) :=
+  AlgHom.pi fun i => (TrivSqZeroExt.fstHom k k k).comp (Pi.evalAlgHom k (fun _ : ι => DualNumber k) i)
+
+def SimpleSum (_χ : C →ₐ[k] (ι → k)) := ι → k
+
+namespace SimpleSum
+def value {χ : C →ₐ[k] (ι → k)} (x : SimpleSum χ) : ι → k := x
+variable (χ : C →ₐ[k] (ι → k))
+instance : AddCommGroup (SimpleSum χ) := inferInstanceAs (AddCommGroup (ι → k))
+instance : Module k (SimpleSum χ) := inferInstanceAs (Module k (ι → k))
+instance [Finite ι] : FiniteDimensional k (SimpleSum χ) := inferInstanceAs (FiniteDimensional k (ι → k))
+instance : Module (NewCorner k ι) (SimpleSum χ) :=
+  Module.compHom (ι → k) (newAugmentation (k := k) (ι := ι)).toRingHom
+
+def rightCharacter : Cᵐᵒᵖ →+* (ι → k) where
+  toFun c := χ c.unop
+  map_one' := map_one χ
+  map_zero' := map_zero χ
+  map_add' x y := map_add χ x.unop y.unop
+  map_mul' x y := by simp [map_mul, mul_comm]
+
+instance : Module Cᵐᵒᵖ (SimpleSum χ) := Module.compHom (ι → k) (rightCharacter χ)
+
+instance : SMulCommClass (NewCorner k ι) Cᵐᵒᵖ (SimpleSum χ) where
+  smul_comm e c x := by
+    change newAugmentation e * (rightCharacter χ c * value x) =
+      rightCharacter χ c * (newAugmentation e * value x)
+    exact mul_left_comm _ _ _
+
+instance : IsScalarTower k (NewCorner k ι) (SimpleSum χ) where
+  smul_assoc r e x := by
+    change newAugmentation (r • e) * value x = r • (newAugmentation e * value x)
+    rw [map_smul, smul_mul_assoc]
+
+instance : IsScalarTower k Cᵐᵒᵖ (SimpleSum χ) where
+  smul_assoc r c x := by
+    change χ (r • c.unop) * value x = r • (χ c.unop * value x)
+    rw [map_smul, smul_mul_assoc]
+end SimpleSum
+
+variable (χ : C →ₐ[k] (ι → k))
+abbrev T := TriangularConstruction.Algebra C (NewCorner k ι) (SimpleSum χ)
+
+instance : Algebra k (T χ) := inferInstance
+instance [Finite ι] [FiniteDimensional k C] : FiniteDimensional k (T χ) :=
+  TriangularConstruction.finiteDimensional C (NewCorner k ι) (SimpleSum χ) k
+
+def augmentation : T χ →ₐ[k] (Sum ι ι → k) where
+  toFun x := Sum.elim (χ x.fst.1) (newAugmentation x.fst.2)
+  map_one' := by ext i; cases i <;> simp [newAugmentation]
+  map_zero' := by ext i; cases i <;> simp [newAugmentation]
+  map_add' x y := by ext i; cases i <;> simp [newAugmentation, map_add]
+  map_mul' x y := by ext i; cases i <;> simp [newAugmentation, map_mul]
+  commutes' r := by ext i; cases i <;> simp [newAugmentation, Algebra.algebraMap_eq_smul_one]
+
+lemma augmentation_surjective (hχ : Function.Surjective χ) : Function.Surjective (augmentation χ) := by
+  intro v
+  obtain ⟨c, hc⟩ := hχ (v ∘ Sum.inl)
+  refine ⟨((c, fun i => TrivSqZeroExt.inl (v (.inr i))), 0), ?_⟩
+  ext i
+  cases i with
+  | inl i => exact congrFun hc i
+  | inr i => rfl
+
+variable [DecidableEq ι]
+
+def socle : Sum ι ι → T χ
+  | .inl i => (0, Pi.single i 1)
+  | .inr i => ((0, Pi.single i DualNumber.eps), 0)
+
+lemma socle_ne_zero (i : Sum ι ι) : socle χ i ≠ 0 := by
+  intro h
+  cases i with
+  | inl i =>
+    have := congrArg (fun x : T χ => (TriangularConstruction.offValue x.snd : ι → k) i) h
+    change (Pi.single i (1 : k) : ι → k) i = 0 at this
+    simp at this
+  | inr i =>
+    have := congrArg (fun x : T χ => (x.fst.2 i).snd) h
+    simp [socle] at this
+
+lemma socle_mul (i : Sum ι ι) (x : T χ) :
+    socle χ i * x = augmentation χ x i • socle χ i := by
+  cases i with
+  | inl i =>
+    apply TrivSqZeroExt.ext
+    · change (0 : C × NewCorner k ι) * x.fst = _ • 0
+      simp
+    · change newAugmentation (0 : NewCorner k ι) * (SimpleSum.value (TriangularConstruction.offValue x.snd)) +
+        SimpleSum.rightCharacter χ (MulOpposite.op x.fst.1) * (Pi.single i 1 : ι → k) =
+        χ x.fst.1 i • (Pi.single i 1 : ι → k)
+      ext j
+      by_cases h : j = i
+      · subst j; simp [SimpleSum.rightCharacter]
+      · simp [h]
+  | inr i =>
+    apply TrivSqZeroExt.ext
+    · apply Prod.ext
+      · change (0 : C) * x.fst.1 = _ • 0
+        simp
+      · change (Pi.single i DualNumber.eps : ι → DualNumber k) * x.fst.2 =
+          (x.fst.2 i).fst • (Pi.single i DualNumber.eps : ι → DualNumber k)
+        ext j : 1
+        by_cases h : j = i
+        · subst j
+          simp only [Pi.mul_apply, Pi.smul_apply, Pi.single_eq_same]
+          apply TrivSqZeroExt.ext <;> simp
+        · simp [h]
+    · apply funext
+      intro j
+      change (newAugmentation (Pi.single i (DualNumber.eps : DualNumber k))) j *
+        (SimpleSum.value (TriangularConstruction.offValue x.snd)) j + χ x.fst.1 j * 0 =
+        (x.fst.2 i).fst * 0
+      have he : newAugmentation (Pi.single i (DualNumber.eps : DualNumber k)) = (0 : ι → k) := by
+        ext j
+        by_cases h : j = i
+        · subst j; simp [newAugmentation]
+        · simp [newAugmentation, h]
+      simp [he]
+
+end CummingsConstruction
+end LittleFinitistic
+end
+end
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/FinitisticAsymmetry/ZeroDimensions.lean b/lean/OAI/Algebra/FinitisticAsymmetry/ZeroDimensions.lean
new file mode 100644
index 0000000000000000000000000000000000000000..507072abe8fe5fe9838024b037f69b7b078207fc
--- /dev/null
+++ b/lean/OAI/Algebra/FinitisticAsymmetry/ZeroDimensions.lean
@@ -0,0 +1,46 @@
+import Mathlib
+import OAI.Algebra.FinitisticAsymmetry.Transport.FiniteModules
+import OAI.Algebra.FinitisticAsymmetry.Kasch.FiniteDimension
+
+namespace OAI
+
+section
+section
+noncomputable section
+open CategoryTheory
+namespace LittleFinitistic
+universe u
+variable (A : Type u) [Ring A]
+section ZeroDimensions
+variable {R k : Type u} [Ring R] [Nontrivial R] [Field k] [Algebra k R]
+
+lemma littleFinitisticDimension_nonneg : 0 ≤ littleFinitisticDimension R := by
+  have hpd : projectiveDimension (ModuleCat.of R R) = 0 :=
+    (projectiveDimension_eq_zero_iff _).mpr ⟨inferInstance, fun h => by
+      let := ModuleCat.isZero_iff_subsingleton.mp h
+      exact (one_ne_zero : (1 : R) ≠ 0) (Subsingleton.elim _ _)⟩
+  exact le_iSup_of_le (ModuleCat.of R R) (le_iSup_of_le (inferInstance : Module.Finite R R)
+    (le_iSup_of_le (by rw [hpd]; norm_cast) hpd.ge))
+
+lemma dimensions_zero_of_splitBasic_rightSocle {ι : Type u} [Finite ι]
+    (χ : R →ₐ[k] (ι → k)) (hχ : Function.Surjective χ)
+    (hJ : ∃ n : ℕ, (RingHom.ker χ.toRingHom) ^ n = ⊥)
+    (a : ι → R) (ha : ∀ i, a i ≠ 0)
+    (hmul : ∀ i r, a i * r = χ r i • a i) :
+    littleFinitisticDimension R = 0 ∧ bigFinitisticDimension R = 0 := by
+  have hb : bigFinitisticDimension R ≤ 0 := by
+    refine iSup_le fun M => iSup_le fun hpd => ?_
+    let : Projective M := Kasch.projective_of_finiteDimension χ a ha hmul hχ hJ M hpd
+    exact (projectiveDimension_le_iff M 0).mpr inferInstance
+  have hl : 0 ≤ littleFinitisticDimension R := littleFinitisticDimension_nonneg
+  have hlb := littleFinitisticDimension_le_big R
+  exact ⟨le_antisymm (hlb.trans hb) hl, le_antisymm hb (hl.trans hlb)⟩
+
+end ZeroDimensions
+
+end LittleFinitistic
+end
+end
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/FormalGroup/Honda/ArtinianRigidity.lean b/lean/OAI/Algebra/FormalGroup/Honda/ArtinianRigidity.lean
new file mode 100644
index 0000000000000000000000000000000000000000..45deb6edb73cf11ee7b8af26923e90bf0f02d77a
--- /dev/null
+++ b/lean/OAI/Algebra/FormalGroup/Honda/ArtinianRigidity.lean
@@ -0,0 +1,46 @@
+import OAI.Algebra.FormalGroup.Honda.NilpotentTower
+import OAI.Algebra.FormalGroup.Honda.Transport
+
+namespace OAI
+
+noncomputable section
+
+universe uK uR
+
+namespace HeightThree.ArtinianRigidity
+open HondaTarget DeformationRigidity CoordinateTransport NilpotentTower
+
+lemma automorphism_rigid {K : Type uK} [Field K] (p : ℕ) [Fact p.Prime] [CharP K p]
+    (n : ℕ) (R : Type uR) [CommRing R] [Algebra K R] (ρ : R →ₐ[K] K)
+    (hn : (RingHom.ker ρ)^(n+1)=⊥) (F : FormalGroup R) (e : CoordinateIso F F)
+    (he : e.series.map ρ.toRingHom=PowerSeries.X)
+    (hF : (multiplicationSeries F p).map ρ.toRingHom=PowerSeries.X^(p^3)) :
+    e.series=PowerSeries.X := by
+  induction n generalizing R with
+  | zero =>
+    have hi : Function.Injective ρ.toRingHom := (RingHom.injective_iff_ker_eq_bot ρ).mpr (by simpa using hn)
+    apply PowerSeries.map_injective ρ.toRingHom hi
+    rw [he,PowerSeries.map_X]
+  | succ n ih =>
+    let S := quotient ρ n
+    let π : R →ₐ[K] S := projection ρ n
+    let σ : S →ₐ[K] K := augmentation ρ n
+    have fac : σ.toRingHom.comp π.toRingHom=ρ.toRingHom := rfl
+    have : Nontrivial R := ρ.toRingHom.domain_nontrivial
+    have : CharP R p := (Algebra.charP_iff K R p).mp inferInstance
+    have hsmall : SmallExtension.IsSmall π.toRingHom ρ.toRingHom :=
+      ⟨projection_ker_le ρ n,projection_annihilate ρ n hn⟩
+    let d := CoordinateTransport.CoordinateIso.map e π.toRingHom
+    have hd : d.series.map σ.toRingHom=PowerSeries.X := by
+      change (e.series.map π.toRingHom).map σ.toRingHom=PowerSeries.X
+      rw [unimap_comp,fac,he]
+    have hF' : (multiplicationSeries (F.map π.toRingHom) p).map σ.toRingHom=PowerSeries.X^(p^3) := by
+      rw [multiplication_map,unimap_comp,fac,hF]
+    have hd' := ih S σ (augmentation_nilpotent ρ n) (F.map π.toRingHom) d hd hF'
+    exact SmallExtension.small_automorphism_rigid p π.toRingHom ρ.toRingHom hsmall F e hd' hF
+
+end HeightThree.ArtinianRigidity
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/FormalGroup/Honda/Canonical.lean b/lean/OAI/Algebra/FormalGroup/Honda/Canonical.lean
new file mode 100644
index 0000000000000000000000000000000000000000..515bc4a2564928d2c319f72ac3433f240f9d9c75
--- /dev/null
+++ b/lean/OAI/Algebra/FormalGroup/Honda/Canonical.lean
@@ -0,0 +1,58 @@
+import OAI.Algebra.FormalGroup.Honda.Universality
+
+namespace OAI
+
+noncomputable section
+
+namespace HeightThree.CanonicalUniversality
+open MvPowerSeries HondaTarget HondaConstruction HondaCoordinates HondaSpecialFiber HondaDifferentials
+
+lemma honda_frobenius (p : ℕ) [hp : Fact p.Prime]
+    (K : Type*) [Field K] [CharP K p] :
+    (hondaLaw p K).toPowerSeries^p =
+      expand p hp.out.ne_zero (hondaLaw p K).toPowerSeries := by
+  have hm : (hondaLaw p K).toPowerSeries.map (frobenius K p) =
+      (hondaLaw p K).toPowerSeries := by
+    change ((integralSpecial p).toPowerSeries.map (Int.castRingHom K)).map _ = _
+    rw [MvPowerSeries.map_map]
+    have hh : (frobenius K p).comp (Int.castRingHom K) = Int.castRingHom K := by ext z; simp
+    rw [hh]
+    rfl
+  rw [← map_frobenius_expand p hp.out.ne_zero, map_expand, hm]
+
+noncomputable def data (p : ℕ) [hp : Fact p.Prime]
+    (K : Type*) [Field K] [CharP K p] : ArtinianUniversality.Data p K := by
+  let H := (honda_nonlinear_expand p K).choose
+  have hH := (honda_nonlinear_expand p K).choose_spec
+  have hc := reducedHonda_heightCoordinates p K
+  let g := (Ideal.mem_span_singleton.mp hc.2.2.2).choose
+  have hg := (Ideal.mem_span_singleton.mp hc.2.2.2).choose_spec
+  exact {
+    gamma := hondaLaw p K
+    family := reducedHonda p K
+    family_comm := inferInstance
+    special := reducedHonda_specialFiber p K
+    honda := integralSpecial_honda p K
+    nonlinear := H
+    nonlinear_eq := hH
+    frobenius := honda_frobenius p K
+    first := hc.2.1
+    remainder := g
+    second := by linear_combination hg }
+
+theorem reducedHonda_isUniversal (p : ℕ) [hp : Fact p.Prime]
+    (K : Type*) [Field K] [CharP K p] :
+    IsUniversal (hondaLaw p K) (reducedHonda p K) := by
+  exact (data p K).isUniversal p
+
+theorem canonical_hasUniversalHeightCoordinates (p : ℕ) [hp : Fact p.Prime]
+    (K : Type*) [Field K] [CharP K p] :
+    HasUniversalHeightCoordinates p (hondaLaw p K) := by
+  exact ⟨reducedHonda p K, inferInstance, reducedHonda_specialFiber p K,
+    reducedHonda_isUniversal p K, reducedHonda_heightCoordinates p K⟩
+
+end HeightThree.CanonicalUniversality
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/FormalGroup/Honda/ChainRule.lean b/lean/OAI/Algebra/FormalGroup/Honda/ChainRule.lean
new file mode 100644
index 0000000000000000000000000000000000000000..2605983f90cf674518498ef52056772c7082f2b7
--- /dev/null
+++ b/lean/OAI/Algebra/FormalGroup/Honda/ChainRule.lean
@@ -0,0 +1,126 @@
+import Mathlib
+
+namespace OAI
+
+noncomputable section
+
+namespace HeightThree.OriginalDifferentialSupport
+open MvPowerSeries.WithPiTopology
+section ChainRule
+variable {R σ τ : Type*} [CommRing R] [Fintype σ]
+
+omit [Fintype σ] in
+
+theorem continuous_pderiv [TopologicalSpace R] [IsTopologicalRing R]
+    (i : σ) : Continuous (MvPowerSeries.pderiv (R := R) i) := by
+  apply continuous_pi
+  intro n
+  exact (MvPowerSeries.WithPiTopology.continuous_coeff R (n + Finsupp.single i 1)).mul_const _
+
+theorem pderiv_subst_polynomial (g : σ → MvPowerSeries τ R)
+    (hg : MvPowerSeries.HasSubst g) (i : τ) (f : MvPolynomial σ R) :
+    MvPowerSeries.pderiv i (MvPowerSeries.subst g (f : MvPowerSeries σ R)) =
+      ∑ j, MvPowerSeries.subst g (MvPowerSeries.pderiv j (f : MvPowerSeries σ R)) *
+        MvPowerSeries.pderiv i (g j) := by
+  classical
+  have hz : MvPowerSeries.subst g (0 : MvPowerSeries σ R) = 0 := by
+    rw [← MvPowerSeries.coe_substAlgHom hg]
+    exact map_zero _
+  have ho : MvPowerSeries.subst g (1 : MvPowerSeries σ R) = 1 := by
+    rw [← MvPowerSeries.coe_substAlgHom hg]
+    exact map_one _
+  induction f using MvPolynomial.induction_on with
+  | C r => simp [hz]
+  | add f h hf hh =>
+    simp only [MvPolynomial.coe_add, MvPowerSeries.subst_add hg, map_add,
+      hf, hh, add_mul, Finset.sum_add_distrib]
+  | mul_X f j hf =>
+    simp only [MvPolynomial.coe_mul, MvPolynomial.coe_X,
+      MvPowerSeries.subst_X hg,
+      Derivation.leibniz, smul_eq_mul, hf,
+      MvPowerSeries.subst_add hg, MvPowerSeries.subst_mul hg, add_mul]
+    rw [Finset.sum_add_distrib]
+    have h1 : (∑ j_1, (MvPowerSeries.subst g (f : MvPowerSeries σ R) *
+        MvPowerSeries.subst g (MvPowerSeries.pderiv (R := R) j_1 (MvPowerSeries.X j))) *
+          MvPowerSeries.pderiv i (g j_1)) =
+        MvPowerSeries.subst g (f : MvPowerSeries σ R) * MvPowerSeries.pderiv i (g j) := by
+      simp [MvPowerSeries.pderiv_X, Pi.single_apply, apply_ite,
+        hz, ho]
+    rw [h1]
+    congr 1
+    rw [Finset.mul_sum]
+    apply Finset.sum_congr rfl
+    intro k hk
+    ring
+
+theorem pderiv_subst (g : σ → MvPowerSeries τ R)
+    (hg : MvPowerSeries.HasSubst g) (i : τ) (f : MvPowerSeries σ R) :
+    MvPowerSeries.pderiv i (MvPowerSeries.subst g f) =
+      ∑ j, MvPowerSeries.subst g (MvPowerSeries.pderiv j f) *
+        MvPowerSeries.pderiv i (g j) := by
+  let : UniformSpace R := ⊥
+  let : DiscreteUniformity R := ⟨rfl⟩
+  have hc₁ : Continuous (fun f : MvPowerSeries σ R =>
+      MvPowerSeries.pderiv i (MvPowerSeries.subst g f)) :=
+    (continuous_pderiv i).comp (MvPowerSeries.continuous_subst hg)
+  have hc₂ : Continuous (fun f : MvPowerSeries σ R =>
+      ∑ j, MvPowerSeries.subst g (MvPowerSeries.pderiv j f) *
+        MvPowerSeries.pderiv i (g j)) := by
+    exact continuous_finsetSum _ fun j _ =>
+      ((MvPowerSeries.continuous_subst hg).comp (continuous_pderiv j)).mul_const _
+  exact congrFun (MvPowerSeries.WithPiTopology.denseRange_toMvPowerSeries.equalizer
+    hc₁ hc₂ (by funext f; exact pderiv_subst_polynomial g hg i f)) f
+
+end ChainRule
+
+variable {R : Type*} [CommRing R]
+theorem constantCoeff_subst_zero_axis {σ τ : Type*} (a : σ → MvPowerSeries τ R)
+    (ha : MvPowerSeries.HasSubst a) (h0 : ∀ i, MvPowerSeries.constantCoeff (a i) = 0)
+    (f : MvPowerSeries σ R) :
+    MvPowerSeries.constantCoeff (MvPowerSeries.subst a f) = MvPowerSeries.constantCoeff f := by
+  have hz := MvPowerSeries.constantCoeff_subst_eq_zero ha h0
+    (f := f - MvPowerSeries.C (MvPowerSeries.constantCoeff f)) (by simp)
+  have hs : MvPowerSeries.subst a (f - MvPowerSeries.C (MvPowerSeries.constantCoeff f)) =
+      MvPowerSeries.subst a f - MvPowerSeries.C (MvPowerSeries.constantCoeff f) := by
+    rw [← MvPowerSeries.coe_substAlgHom ha, map_sub]
+    rw [MvPowerSeries.substAlgHom_apply, MvPowerSeries.substAlgHom_apply,
+      MvPowerSeries.subst_C]
+  rw [hs, map_sub, MvPowerSeries.constantCoeff_C, sub_eq_zero] at hz
+  exact hz
+
+theorem constantCoeff_derivative_eq (f : PowerSeries R) :
+    PowerSeries.constantCoeff (PowerSeries.derivative f) = PowerSeries.coeff 1 f := by
+  rw [← PowerSeries.coeff_zero_eq_constantCoeff, PowerSeries.coeff_derivative]
+  simp
+
+theorem coeff_one_formal_add (F : FormalGroup R) (a b : PowerSeries R)
+    (ha : PowerSeries.constantCoeff a = 0) (hb : PowerSeries.constantCoeff b = 0) :
+    PowerSeries.coeff 1 (MvPowerSeries.subst ![a,b] F.toPowerSeries) =
+      PowerSeries.coeff 1 a + PowerSeries.coeff 1 b := by
+  have hs : MvPowerSeries.HasSubst (![a,b] : Fin 2 → PowerSeries R) := by
+    apply MvPowerSeries.hasSubst_of_constantCoeff_nilpotent
+    intro i
+    fin_cases i
+    · exact PowerSeries.HasSubst.of_constantCoeff_zero' ha
+    · exact PowerSeries.HasSubst.of_constantCoeff_zero' hb
+  have h := congrArg (PowerSeries.constantCoeff (R := R)) (pderiv_subst _ hs () F.toPowerSeries)
+  change PowerSeries.constantCoeff (PowerSeries.derivative _) = _ at h
+  rw [constantCoeff_derivative_eq] at h
+  simp only [Fin.sum_univ_two, map_add, map_mul] at h
+  have hc (i : Fin 2) :
+      PowerSeries.constantCoeff (MvPowerSeries.subst ![a,b] (MvPowerSeries.pderiv i F.toPowerSeries)) = 1 := by
+    change MvPowerSeries.constantCoeff (MvPowerSeries.subst ![a,b] (MvPowerSeries.pderiv i F.toPowerSeries)) = 1
+    rw [constantCoeff_subst_zero_axis _ hs (by intro j; fin_cases j; exact ha; exact hb),
+      ← MvPowerSeries.coeff_zero_eq_constantCoeff, MvPowerSeries.coeff_pderiv]
+    fin_cases i <;> simp [F.lin_coeff_X, F.lin_coeff_Y]
+  rw [hc, hc] at h
+  simp only [one_mul, Matrix.cons_val_zero, Matrix.cons_val_one] at h
+  change _ = PowerSeries.constantCoeff (PowerSeries.derivative a) +
+    PowerSeries.constantCoeff (PowerSeries.derivative b) at h
+  simpa only [constantCoeff_derivative_eq] using h
+
+end HeightThree.OriginalDifferentialSupport
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/FormalGroup/Honda/Classification.lean b/lean/OAI/Algebra/FormalGroup/Honda/Classification.lean
new file mode 100644
index 0000000000000000000000000000000000000000..378a620b7bf5cae19fe450d692429137b2721687
--- /dev/null
+++ b/lean/OAI/Algebra/FormalGroup/Honda/Classification.lean
@@ -0,0 +1,178 @@
+import OAI.Algebra.FormalGroup.Honda.Correction
+
+namespace OAI
+
+noncomputable section
+
+namespace HeightThree.HondaClassification
+open MvPowerSeries HeightThree.HondaJets HeightThree.HondaLeading
+open HeightThree.HondaTarget HeightThree.HondaFrobenius HeightThree.HomogeneousCocycle
+open HeightThree.CoordinateTransport HeightThree.HondaCorrection
+variable {K : Type*} [Field K]
+
+lemma all_laws_jet2 (F G : FormalGroup K) : EqJet 2 F.toPowerSeries G.toPowerSeries := by
+  have hf := pair_linear F (X 0 : MvPowerSeries (Fin 2) K) (X 1) (by simp) (by simp)
+  have hg := pair_linear G (X 0 : MvPowerSeries (Fin 2) K) (X 1) (by simp) (by simp)
+  simp only [pair,pair_subst_self] at hf hg
+  exact hf.trans hg.symm
+
+structure Approximation (p h : ℕ) (F G : FormalGroup K) (n : ℕ) where
+  law : FormalGroup K
+  comm : law.IsComm
+  coordinate : CoordinateIso G law
+  match_law : EqJet (n+2) F.toPowerSeries law.toPowerSeries
+  honda : multiplicationSeries law p=PowerSeries.X^(p^h)
+  strict : EqJet 2 coordinate.series PowerSeries.X
+
+variable (p : ℕ) [hp : Fact p.Prime] [CharP K p] (h : ℕ)
+  (F G : FormalGroup K) [F.IsComm] [G.IsComm]
+  (hF : multiplicationSeries F p=PowerSeries.X^(p^h))
+  (hG : multiplicationSeries G p=PowerSeries.X^(p^h))
+
+noncomputable def start : Approximation p h F G 0 where
+  law := G
+  comm := inferInstance
+  coordinate := {
+    series := PowerSeries.X
+    inverse := PowerSeries.X
+    zero_series := PowerSeries.constantCoeff_X
+    zero_inverse := PowerSeries.constantCoeff_X
+    left_inv := PowerSeries.X_subst _
+    right_inv := PowerSeries.X_subst _
+    preserves_addition := by
+      simp only [PowerSeries.subst_X (.of_constantCoeff_zero G.zero_constantCoeff),
+        PowerSeries.subst_X (PowerSeries.HasSubst.X _),pair_subst_self] }
+  match_law := all_laws_jet2 F G
+  honda := hG
+  strict := by exact EqJet.refl 2 (PowerSeries.X : PowerSeries K)
+
+omit [G.IsComm] in
+include hF in
+lemma advance_exists (n : ℕ) (s : Approximation p h F G n) :
+    ∃t : Approximation p h F G (n+1), EqJet (n+2) t.coordinate.series s.coordinate.series := by
+  let : s.law.IsComm := s.comm
+  have hc := leading_isCocycle F s.law (n+2) p s.match_law (hF.trans s.honda.symm)
+  have hfixed := map_leading F s.law (n+2) (iterateFrobenius K p h)
+    (honda_coefficients_fixed p h F hF) (honda_coefficients_fixed p h s.law s.honda)
+  obtain ⟨a,ha,hD⟩ := fixed_coboundary_scalar p _ (n+2) (by omega) hc
+    (leading_homogeneous F s.law (n+2)) (iterateFrobenius K p h) hfixed
+  let c := step (n+2) (by omega) a
+  have he : EqJet (n+2) ((CoordinateIso.trans s.coordinate (c.iso s.law)).series) s.coordinate.series := by
+    exact step_jet (n+2) a _ s.coordinate.zero_series
+  let t : Approximation p h F G (n+1) := {
+    law := c.transport s.law
+    comm := inferInstance
+    coordinate := CoordinateIso.trans s.coordinate (c.iso s.law)
+    match_law := by simpa only [Nat.add_right_comm] using
+      (step_improves F s.law (n+2) (by omega) s.match_law a hD).symm
+    honda := honda_transport p h (n+2) (by omega) a ha s.law s.honda
+    strict := (he.mono (by omega)).trans s.strict }
+  exact ⟨t,he⟩
+
+noncomputable def advance (n : ℕ) (s : Approximation p h F G n) :
+    {t : Approximation p h F G (n+1) // EqJet (n+2) t.coordinate.series s.coordinate.series} :=
+  ⟨(advance_exists p h F G hF n s).choose,(advance_exists p h F G hF n s).choose_spec⟩
+
+noncomputable def tower : (n : ℕ) → Approximation p h F G n
+  | 0 => start p h F G hG
+  | n+1 => (advance p h F G hF n (tower n)).val
+
+lemma tower_step (n : ℕ) :
+    EqJet (n+2) (tower p h F G hF hG (n+1)).coordinate.series
+      (tower p h F G hF hG n).coordinate.series :=
+  (advance p h F G hF n (tower p h F G hF hG n)).prop
+
+end HeightThree.HondaClassification
+
+namespace HeightThree.HondaJetLimit
+open MvPowerSeries HeightThree.HondaJets
+variable {K : Type*} [Field K]
+
+def limit (s : ℕ → PowerSeries K) : PowerSeries K := PowerSeries.mk (fun m=>(s m).coeff m)
+
+lemma later_jet (s : ℕ → PowerSeries K) (hs : ∀n,EqJet (n+2) (s (n+1)) (s n))
+    (n m : ℕ) (hm : n ≤ m) : EqJet (n+2) (s m) (s n) := by
+  induction m,hm using Nat.le_induction with
+  | base => exact EqJet.refl _ _
+  | succ m hm ih => exact ((hs m).mono (by omega)).trans ih
+
+lemma stable_coeff (s : ℕ → PowerSeries K) (hs : ∀n,EqJet (n+2) (s (n+1)) (s n))
+    (m i j : ℕ) (hi : m < i+2) (hj : m < j+2) : (s i).coeff m=(s j).coeff m := by
+  have hi' := later_jet s hs i (max i j) (le_max_left _ _)
+  have hj' := later_jet s hs j (max i j) (le_max_right _ _)
+  have hi'' := hi' (Finsupp.single () m) (by simpa using hi)
+  have hj'' := hj' (Finsupp.single () m) (by simpa using hj)
+  exact hi''.symm.trans hj''
+
+lemma limit_jet (s : ℕ → PowerSeries K) (hs : ∀n,EqJet (n+2) (s (n+1)) (s n))
+    (n : ℕ) : EqJet (n+2) (limit s) (s n) := by
+  intro d hd
+  have he : d=Finsupp.single () (d ()) := Finsupp.unique_single d
+  rw [he] at hd ⊢
+  simp only [Finsupp.degree_single] at hd
+  change PowerSeries.coeff (d ()) (limit s)=PowerSeries.coeff (d ()) (s n)
+  rw [limit,PowerSeries.coeff_mk]
+  exact stable_coeff s hs (d ()) (d ()) n (by omega) hd
+
+end HeightThree.HondaJetLimit
+
+namespace HeightThree.HondaClassification
+open MvPowerSeries HeightThree.HondaJets HeightThree.HondaLeading
+open HeightThree.HondaTarget HeightThree.HondaFrobenius HeightThree.HomogeneousCocycle
+open HeightThree.CoordinateTransport HeightThree.HondaCorrection HeightThree.HondaJetLimit
+variable {K : Type*} [Field K]
+variable (p : ℕ) [hp : Fact p.Prime] [CharP K p] (h : ℕ)
+  (F G : FormalGroup K) [F.IsComm] [G.IsComm]
+  (hF : multiplicationSeries F p=PowerSeries.X^(p^h))
+  (hG : multiplicationSeries G p=PowerSeries.X^(p^h))
+
+include hF hG in
+
+theorem strict_honda_isomorphic : ∃ e : CoordinateIso G F, e.series.coeff 1=1 := by
+  let T := tower p h F G hF hG
+  let s : ℕ → PowerSeries K := fun n=>(T n).coordinate.series
+  have hs : ∀n,EqJet (n+2) (s (n+1)) (s n) := tower_step p h F G hF hG
+  let u := HondaJetLimit.limit s
+  have hu (n : ℕ) : EqJet (n+2) u (s n) := limit_jet s hs n
+  have hstrict : EqJet 2 u PowerSeries.X := (hu 0).trans (T 0).strict
+  have hz : u.constantCoeff=0 := by
+    have hh := hstrict 0 (by simp)
+    change MvPowerSeries.constantCoeff u=0
+    simpa [PowerSeries.X] using hh
+  have hlin : u.coeff 1=1 := by
+    have hh := hstrict (Finsupp.single () 1) (by simp)
+    simpa [PowerSeries.coeff,PowerSeries.X] using hh
+  have hadd : u.subst G.toPowerSeries=F.toPowerSeries.subst ![u.subst (X 0),u.subst (X 1)] := by
+    apply MvPowerSeries.ext
+    intro d
+    let n := d.degree
+    let v := (T n).coordinate.series
+    have hv0 : v.constantCoeff=0 := (T n).coordinate.zero_series
+    have hL : EqJet (n+2) (u.subst G.toPowerSeries) (v.subst G.toPowerSeries) :=
+      (hu n).subst_left (fun _ : Unit=>G.toPowerSeries)
+        (PowerSeries.HasSubst.of_constantCoeff_zero G.zero_constantCoeff).const
+        (fun _=>G.zero_constantCoeff)
+    rw [(T n).coordinate.preserves_addition] at hL
+    let a : Fin 2 → MvPowerSeries (Fin 2) K := ![v.subst (X 0),v.subst (X 1)]
+    let b : Fin 2 → MvPowerSeries (Fin 2) K := ![u.subst (X 0),u.subst (X 1)]
+    have ha0 : ∀i,(a i).constantCoeff=0 := by
+      intro i; fin_cases i <;> exact PowerSeries.constantCoeff_subst_eq_zero (by simp) _ hv0
+    have hb0 : ∀i,(b i).constantCoeff=0 := by
+      intro i; fin_cases i <;> exact PowerSeries.constantCoeff_subst_eq_zero (by simp) _ hz
+    have hM := (T n).match_law.symm.subst_left a (hasSubst_of_constantCoeff_zero ha0) ha0
+    have hR : EqJet (n+2) (F.toPowerSeries.subst a) (F.toPowerSeries.subst b) := by
+      apply EqJet.subst_right _ _ _ (hasSubst_of_constantCoeff_zero ha0) (hasSubst_of_constantCoeff_zero hb0)
+      intro i; fin_cases i
+      · exact (hu n).symm.subst_left (fun _ : Unit=>(X 0 : MvPowerSeries (Fin 2) K))
+          (PowerSeries.HasSubst.X 0).const (by simp)
+      · exact (hu n).symm.subst_left (fun _ : Unit=>(X 1 : MvPowerSeries (Fin 2) K))
+          (PowerSeries.HasSubst.X 1).const (by simp)
+    exact ((hL.trans hM).trans hR) d (by dsimp [n]; omega)
+  let c := Coordinate.ofSeries u hz (by rw [hlin]; exact isUnit_one)
+  exact ⟨{ __ := c, preserves_addition := hadd },hlin⟩
+
+end HeightThree.HondaClassification
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/FormalGroup/Honda/Cocycle.lean b/lean/OAI/Algebra/FormalGroup/Honda/Cocycle.lean
new file mode 100644
index 0000000000000000000000000000000000000000..cb3ffebb2143df82492f37e8d1b17bfc3c1214a6
--- /dev/null
+++ b/lean/OAI/Algebra/FormalGroup/Honda/Cocycle.lean
@@ -0,0 +1,617 @@
+import OAI.Algebra.FormalGroup.Honda.ChainRule
+
+namespace OAI
+
+noncomputable section
+
+namespace HeightThree.HomogeneousCocycle
+open MvPowerSeries
+variable {K σ τ : Type*} [Field K]
+
+lemma degree_pair (d : Fin 2 →₀ ℕ) : d.degree=d 0+d 1 := by
+  rw [Finsupp.degree_eq_sum]
+  simp
+
+lemma pair_exp (d : Fin 2 →₀ ℕ) :
+    d=Finsupp.single 0 (d 0)+Finsupp.single 1 (d 1) := by
+  ext i; fin_cases i <;> simp
+
+lemma monomial_pair (i j : ℕ) (a : K) :
+    monomial (Finsupp.single 0 i+Finsupp.single 1 j) a =
+      C a * (X (0 : Fin 2))^i * X 1^j := by
+  rw [←monomial_zero_eq_C_apply,X_pow_eq,X_pow_eq,
+    monomial_mul_monomial,monomial_mul_monomial]
+  simp
+
+lemma homogeneous_sum (D : MvPowerSeries (Fin 2) K) (n : ℕ) (hD : D.IsHomogeneous n) :
+    D=∑ i ∈ Finset.range (n+1), C (coeff (Finsupp.single 0 i+Finsupp.single 1 (n-i)) D) *
+      X 0^i * X 1^(n-i) := by
+  classical
+  simp_rw [←monomial_pair]
+  ext d
+  rw [map_sum]
+  by_cases hd : d.degree=n
+  · have he : n-d 0=d 1 := by rw [←hd,degree_pair]; omega
+    have hi : d 0∈Finset.range (n+1) := by simp only [Finset.mem_range]; rw [←hd,degree_pair]; omega
+    rw [Finset.sum_eq_single (d 0)]
+    · rw [he,←pair_exp d,coeff_monomial_same]
+    · intro i hi hne
+      rw [coeff_monomial,ite_eq_right]
+      intro h
+      have hh := congrArg (fun e : Fin 2 →₀ ℕ => e 0) h
+      simp at hh
+      exact hne hh.symm
+    · exact fun h => (h hi).elim
+  · rw [hD.coeff_eq_zero hd]
+    symm
+    apply Finset.sum_eq_zero
+    intro i hi
+    rw [coeff_monomial,ite_eq_right]
+    intro h
+    apply hd
+    rw [h,degree_pair]
+    simp
+    have : i≤n := by simpa only [Finset.mem_range,Nat.lt_succ_iff] using hi
+    omega
+
+structure IsCocycle (p : ℕ) (D : MvPowerSeries (Fin 2) K) : Prop where
+  zero_left : D.subst ![(0 : MvPowerSeries (Fin 1) K), X 0]=0
+  zero_right : D.subst ![(X 0 : MvPowerSeries (Fin 1) K),0]=0
+  symmetric : D.subst ![(X 1 : MvPowerSeries (Fin 2) K),X 0]=D
+  associative :
+    (D.subst ![(X 0 : MvPowerSeries (Fin 3) K),X 1]) + D.subst ![(X 0+X 1 : MvPowerSeries (Fin 3) K),X 2] =
+    (D.subst ![(X 1 : MvPowerSeries (Fin 3) K),X 2]) + D.subst ![(X 0 : MvPowerSeries (Fin 3) K),X 1+X 2]
+  trace_zero : ∑ i ∈ Finset.range p, D.subst ![C (i:K)*PowerSeries.X,PowerSeries.X]=0
+
+lemma pair_subst_self (D : MvPowerSeries (Fin 2) K) : D.subst ![X 0,X 1]=D := by
+  rw [show (![X 0,X 1] : Fin 2 → MvPowerSeries (Fin 2) K)=X by ext i; fin_cases i <;> rfl]
+  exact congrFun MvPowerSeries.subst_self D
+
+lemma derivative_cocycle (p : ℕ) (D : MvPowerSeries (Fin 2) K) (hD : IsCocycle p D) :
+    pderiv (R := K) 1 D = (pderiv (R := K) 1 D).subst ![X 0+X 1,0] -
+      (pderiv (R := K) 1 D).subst ![X 1,0] := by
+  let a : Fin 2 → MvPowerSeries (Fin 3) K := ![X 0,X 1]
+  let b : Fin 2 → MvPowerSeries (Fin 3) K := ![X 0+X 1,X 2]
+  let c : Fin 2 → MvPowerSeries (Fin 3) K := ![X 1,X 2]
+  let d : Fin 2 → MvPowerSeries (Fin 3) K := ![X 0,X 1+X 2]
+  have ha : HasSubst a := hasSubst_of_constantCoeff_zero (by intro i; fin_cases i <;> simp [a])
+  have hb : HasSubst b := hasSubst_of_constantCoeff_zero (by intro i; fin_cases i <;> simp [b])
+  have hc : HasSubst c := hasSubst_of_constantCoeff_zero (by intro i; fin_cases i <;> simp [c])
+  have hd : HasSubst d := hasSubst_of_constantCoeff_zero (by intro i; fin_cases i <;> simp [d])
+  have hh := congrArg (pderiv (R := K) (2 : Fin 3)) hD.associative
+  change pderiv (R := K) 2 (D.subst a+D.subst b)=pderiv (R := K) 2 (D.subst c+D.subst d) at hh
+  simp only [map_add, OriginalDifferentialSupport.pderiv_subst a ha,
+    OriginalDifferentialSupport.pderiv_subst b hb, OriginalDifferentialSupport.pderiv_subst c hc,
+    OriginalDifferentialSupport.pderiv_subst d hd, Fin.sum_univ_two] at hh
+  simp [a,b,c,d] at hh
+  let e : Fin 3 → MvPowerSeries (Fin 2) K := ![X 0,X 1,0]
+  have he : HasSubst e := hasSubst_of_constantCoeff_zero (by intro i; fin_cases i <;> simp [e])
+  have hh' := congrArg (substAlgHom he) hh
+  simp only [map_add,substAlgHom_apply] at hh'
+  rw [subst_comp_subst_apply hb he,subst_comp_subst_apply hc he,subst_comp_subst_apply hd he] at hh'
+  have eb : (fun i => (b i).subst e)=![X 0+X 1,0] := by
+    ext i; fin_cases i <;> simp [b,e,subst_add he,subst_X he]
+  have ec : (fun i => (c i).subst e)=![X 1,0] := by
+    ext i; fin_cases i <;> simp [c,e,subst_X he]
+  have ed : (fun i => (d i).subst e)=![X 0,X 1] := by
+    ext i; fin_cases i <;> simp [d,e,subst_add he,subst_X he]
+  rw [eb,ec,ed,pair_subst_self] at hh'
+  exact eq_sub_iff_add_eq.mpr (by simpa only [add_comm] using hh'.symm)
+
+lemma derivative_monomial (a : K) (i j : ℕ) :
+    pderiv (R := K) 1 (C a*(X (0 : Fin 2))^i*X 1^j)=
+      C (a*(j:K))*X 0^i*X 1^(j-1) := by
+  simp [Derivation.leibniz_pow,smul_eq_mul]
+  ring
+
+lemma subst_monomial_pair (c : K) (i j : ℕ) (a b : MvPowerSeries σ K)
+    (ha : a.constantCoeff=0) (hb : b.constantCoeff=0) :
+    (C c*(X (0 : Fin 2))^i*X 1^j).subst ![a,b] = C c*a^i*b^j := by
+  have hs : HasSubst (![a,b] : Fin 2 → MvPowerSeries σ K) :=
+    hasSubst_of_constantCoeff_zero (by intro i; fin_cases i <;> simp [ha,hb])
+  simp only [←coe_substAlgHom hs,map_mul,map_pow,substAlgHom_X,
+    Matrix.cons_val_zero,Matrix.cons_val_one]
+  rw [show (substAlgHom hs) (C c)=C c from (substAlgHom hs).commutes c]
+
+lemma homogeneous_derivative_axis (D : MvPowerSeries (Fin 2) K) (n : ℕ) (hn : 0<n)
+    (hD : D.IsHomogeneous n) (a : MvPowerSeries σ K) (ha : a.constantCoeff=0) :
+    (pderiv (R := K) 1 D).subst ![a,0] =
+      C (coeff (Finsupp.single 0 (n-1)+Finsupp.single 1 1) D)*a^(n-1) := by
+  classical
+  have hs : HasSubst (![a,0] : Fin 2 → MvPowerSeries σ K) :=
+    hasSubst_of_constantCoeff_zero (by intro i; fin_cases i <;> simp [ha])
+  conv_lhs => rw [homogeneous_sum D n hD]
+  simp only [map_sum,derivative_monomial]
+  rw [←coe_substAlgHom hs,map_sum]
+  simp only [coe_substAlgHom,subst_monomial_pair _ _ _ a 0 ha (map_zero _)]
+  rw [Finset.sum_eq_single (n-1)]
+  · have h1 : n-(n-1)=1 := by omega
+    simp [h1]
+  · intro i hi hne
+    have hn1 : n-i≠1 := by omega
+    by_cases hh : n-i=0
+    · simp [hh]
+    · have hn2 : n-i-1≠0 := by omega
+      simp [hn2]
+  · intro h
+    exact (h (by simp only [Finset.mem_range]; omega)).elim
+
+lemma derivative_shape (p : ℕ) (D : MvPowerSeries (Fin 2) K) (n : ℕ) (hn : 0<n)
+    (hD : IsCocycle p D) (hH : D.IsHomogeneous n) :
+    pderiv (R := K) 1 D = C (coeff (Finsupp.single 0 (n-1)+Finsupp.single 1 1) D) *
+      ((X 0+X 1)^(n-1)-X 1^(n-1)) := by
+  rw [derivative_cocycle p D hD,
+    homogeneous_derivative_axis D n hn hH _ (by simp),
+    homogeneous_derivative_axis D n hn hH _ (by simp)]
+  ring
+
+lemma homogeneous_of_coeff (f : MvPowerSeries σ K) (n : ℕ)
+    (h : ∀ d, d.degree≠n → coeff d f=0) : f.IsHomogeneous n := by
+  intro d hd
+  have he : d.degree=n := by
+    by_contra hn
+    exact hd (h d hn)
+  rwa [Finsupp.degree_eq_weight_one] at he
+
+lemma homogeneous_sub {f g : MvPowerSeries σ K} {n : ℕ}
+    (hf : f.IsHomogeneous n) (hg : g.IsHomogeneous n) : (f-g).IsHomogeneous n := by
+  apply homogeneous_of_coeff
+  intro d hd
+  rw [map_sub,hf.coeff_eq_zero hd,hg.coeff_eq_zero hd,sub_self]
+
+lemma homogeneous_smul (a : K) {f : MvPowerSeries σ K} {n : ℕ}
+    (hf : f.IsHomogeneous n) : (a • f).IsHomogeneous n := by
+  apply homogeneous_of_coeff
+  intro d hd
+  rw [map_smul,hf.coeff_eq_zero hd,smul_zero]
+
+lemma homogeneous_X (i : σ) : (X i : MvPowerSeries σ K).IsHomogeneous 1 := by
+  classical
+  apply homogeneous_of_coeff
+  intro d hd
+  rw [coeff_X,ite_eq_right]
+  intro he
+  exact hd (by rw [he]; simp)
+
+lemma homogeneous_one : (1 : MvPowerSeries σ K).IsHomogeneous 0 := by
+  classical
+  apply homogeneous_of_coeff
+  intro d hd
+  rw [coeff_one,ite_eq_right]
+  intro he
+  exact hd (by rw [he]; simp)
+
+lemma homogeneous_pow {f : MvPowerSeries σ K} {d : ℕ} (hf : f.IsHomogeneous d) (n : ℕ) :
+    (f^n).IsHomogeneous (d*n) := by
+  induction n with
+  | zero =>
+    rw [pow_zero,Nat.mul_zero]
+    exact homogeneous_one
+  | succ n ih =>
+    rw [pow_succ,Nat.mul_succ]
+    exact ih.mul hf
+
+def coboundary (n : ℕ) : MvPowerSeries (Fin 2) K := (X 0+X 1)^n-X 0^n-X 1^n
+
+lemma homogeneous_coboundary (n : ℕ) : (coboundary (K := K) n).IsHomogeneous n := by
+  have hx (i : Fin 2) : (X i : MvPowerSeries (Fin 2) K).IsHomogeneous 1 := by
+    exact homogeneous_X i
+  have hxpow (i : Fin 2) : ((X i : MvPowerSeries (Fin 2) K)^n).IsHomogeneous n := by
+    have hh : ((X i : MvPowerSeries (Fin 2) K)^n).IsHomogeneous (1*n) := by
+      exact homogeneous_pow (hx i) n
+    rw [one_mul] at hh
+    exact @hh
+  have h01 : ((X (0 : Fin 2)+X 1 : MvPowerSeries (Fin 2) K)^n).IsHomogeneous n := by
+    have hsum : (X (0 : Fin 2)+X 1 : MvPowerSeries (Fin 2) K).IsHomogeneous 1 :=
+      IsHomogeneous.add (hx 0) (hx 1)
+    have hh : ((X (0 : Fin 2)+X 1 : MvPowerSeries (Fin 2) K)^n).IsHomogeneous (1*n) := by
+      exact homogeneous_pow hsum n
+    rw [one_mul] at hh
+    exact @hh
+  unfold coboundary
+  have hh : ((X (0 : Fin 2)+X 1 : MvPowerSeries (Fin 2) K)^n-X 0^n).IsHomogeneous n :=
+    fun {_} h => homogeneous_sub h01 (hxpow 0) h
+  exact fun {_} h => homogeneous_sub hh (hxpow 1) h
+
+lemma derivative_coboundary (n : ℕ) :
+    pderiv (R := K) 1 (coboundary (K := K) n) =
+      C (n:K)*((X 0+X 1)^(n-1)-X 1^(n-1)) := by
+  simp [coboundary,Derivation.leibniz_pow,smul_eq_mul]
+  ring
+
+lemma coeff_add_pow (n i j : ℕ) (hij : i+j=n) :
+    coeff (Finsupp.single 0 i+Finsupp.single 1 j) ((X (0 : Fin 2)+X 1 : MvPowerSeries (Fin 2) K)^n)=
+      (n.choose i : K) := by
+  classical
+  rw [add_pow,map_sum,Finset.sum_eq_single i]
+  · have he : n-i=j := by omega
+    rw [he]
+    have hm : (X (0 : Fin 2) : MvPowerSeries (Fin 2) K)^i*X 1^j*(n.choose i : MvPowerSeries (Fin 2) K)=
+        monomial (Finsupp.single 0 i+Finsupp.single 1 j) (n.choose i : K) := by
+      rw [monomial_pair,map_natCast]
+      ring
+    rw [hm,coeff_monomial_same]
+  · intro k hk hki
+    have hm : (X (0 : Fin 2) : MvPowerSeries (Fin 2) K)^k*X 1^(n-k)*(n.choose k : MvPowerSeries (Fin 2) K)=
+        monomial (Finsupp.single 0 k+Finsupp.single 1 (n-k)) (n.choose k : K) := by
+      rw [monomial_pair,map_natCast]
+      ring
+    rw [hm,coeff_monomial,ite_eq_right]
+    intro he
+    have hh := congrArg (fun e : Fin 2 →₀ ℕ => e 0) he
+    simp only [Finsupp.add_apply,Finsupp.single_eq_same,Finsupp.single_eq_of_ne (show (0:Fin 2)≠1 by decide),add_zero] at hh
+    exact hki hh.symm
+  · intro hi
+    exact (hi (by simp only [Finset.mem_range]; omega)).elim
+
+lemma derivative_zero_support (p : ℕ) [Fact p.Prime] [CharP K p]
+    (f : MvPowerSeries σ K) (hf : ∀ i, pderiv (R := K) i f=0)
+    (d : σ →₀ ℕ) (hd : coeff d f≠0) : ∀ i, p∣d i := by
+  classical
+  intro i
+  by_cases hi : d i=0
+  · rw [hi]; exact dvd_zero p
+  let e := d.erase i+Finsupp.single i (d i-1)
+  have he : e+Finsupp.single i 1=d := by
+    ext j
+    by_cases hj : j=i
+    · subst j; simp [e,Nat.sub_add_cancel (by omega : 1≤d i)]
+    · simp [e,hj]
+  have hei : (e i : K)+1=(d i : K) := by
+    have hh := congrArg (fun d : σ →₀ ℕ => d i) he
+    simp only [Finsupp.add_apply,Finsupp.single_eq_same] at hh
+    simpa only [Nat.cast_add,Nat.cast_one] using congrArg (fun m : ℕ => (m : K)) hh
+  have hh := congrArg (coeff e) (hf i)
+  rw [coeff_pderiv,he,hei,map_zero] at hh
+  exact (CharP.cast_eq_zero_iff K p (d i)).mp ((mul_eq_zero.mp hh).resolve_left hd)
+
+lemma derivative_symmetry (D : MvPowerSeries (Fin 2) K)
+    (hD : D.subst ![X 1,X 0]=D) :
+    pderiv (R := K) 0 D=(pderiv (R := K) 1 D).subst ![X 1,X 0] := by
+  have hs : HasSubst (![X 1,X 0] : Fin 2 → MvPowerSeries (Fin 2) K) :=
+    hasSubst_of_constantCoeff_zero (by intro i; fin_cases i <;> simp)
+  have hh := congrArg (pderiv (R := K) (0 : Fin 2)) hD
+  rw [OriginalDifferentialSupport.pderiv_subst _ hs] at hh
+  simpa [Fin.sum_univ_two] using hh.symm
+
+lemma coboundary_symmetric (n : ℕ) :
+    (coboundary (K := K) n).subst ![X 1,X 0]=coboundary (K := K) n := by
+  have hs : HasSubst (![X 1,X 0] : Fin 2 → MvPowerSeries (Fin 2) K) :=
+    hasSubst_of_constantCoeff_zero (by intro i; fin_cases i <;> simp)
+  simp only [coboundary,←coe_substAlgHom hs,map_sub,map_add,map_pow,substAlgHom_X,
+    Matrix.cons_val_zero,Matrix.cons_val_one]
+  rw [add_comm (X 1) (X 0)]
+  ring
+
+lemma homogeneous_derivative_zero (p : ℕ) [hp : Fact p.Prime] [CharP K p]
+    (f : MvPowerSeries (Fin 2) K) (n : ℕ) (hn : ¬p∣n)
+    (hH : f.IsHomogeneous n) (hf : ∀ i, pderiv (R := K) i f=0) : f=0 := by
+  ext d
+  rw [map_zero]
+  by_contra hd
+  have he := derivative_zero_support p f hf d hd
+  apply hn
+  have hdn : d.degree=n := by
+    by_contra h
+    exact hd (hH.coeff_eq_zero h)
+  rw [←hdn,degree_pair]
+  exact dvd_add (he 0) (he 1)
+
+lemma coboundary_of_prime_not_dvd (p : ℕ) [hp : Fact p.Prime] [CharP K p]
+    (D : MvPowerSeries (Fin 2) K) (n : ℕ) (hn : ¬p∣n)
+    (hD : IsCocycle p D) (hH : D.IsHomogeneous n) :
+    ∃ a : K, D=a • coboundary n := by
+  let a := coeff (Finsupp.single 0 (n-1)+Finsupp.single 1 1) D/(n:K)
+  have hn0 : (n:K)≠0 := (CharP.cast_eq_zero_iff K p n).not.mpr hn
+  have hnat : 0<n := by
+    by_contra h
+    have hnz : n=0 := by omega
+    exact hn (hnz ▸ dvd_zero p)
+  have hsym : (D-a • coboundary n).subst ![X 1,X 0]=D-a • coboundary n := by
+    have hs : HasSubst (![X 1,X 0] : Fin 2 → MvPowerSeries (Fin 2) K) :=
+      hasSubst_of_constantCoeff_zero (by intro i; fin_cases i <;> simp)
+    rw [subst_sub hs,subst_smul hs,hD.symmetric,coboundary_symmetric]
+  have hd1 : pderiv (R := K) 1 (D-a • coboundary n)=0 := by
+    rw [map_sub,Derivation.map_smul,derivative_shape p D n hnat hD hH,derivative_coboundary]
+    simp only [smul_eq_C_mul,←mul_assoc,←map_mul,div_mul_cancel₀ _ hn0,sub_self,a]
+  have he : D-a • coboundary n=0 := homogeneous_derivative_zero p _ n hn
+    (homogeneous_sub hH (homogeneous_smul a (homogeneous_coboundary n))) (by
+      intro i; fin_cases i
+      · change pderiv (R := K) 0 (D-a • coboundary n)=0
+        rw [derivative_symmetry _ hsym,hd1]
+        rw [←coe_substAlgHom (hasSubst_of_constantCoeff_zero (by intro j; fin_cases j <;> simp)),map_zero]
+      · exact hd1)
+  exact ⟨a,sub_eq_zero.mp he⟩
+
+lemma choose_pred_cast (p n : ℕ) [hp : Fact p.Prime] [CharP K p]
+    (hn : 0<n) (hpn : p∣n) : ((n-1).choose (p-1) : K)=1 := by
+  have hp0 : 0<p := hp.out.pos
+  have hple : p≤n := Nat.le_of_dvd hn hpn
+  have hmod : (n-1)%p=p-1 := by
+    obtain ⟨m,rfl⟩ := hpn
+    have hm : 0 < m := by nlinarith
+    have hm1 : 1 ≤ m := by omega
+    have heq : p*m = p*(m-1)+p := by
+      nth_rw 1 [←Nat.sub_add_cancel hm1]
+      ring
+    have he : p*m-1=p*(m-1)+(p-1) := by omega
+    simp [he,Nat.add_mod,Nat.mod_eq_of_lt (show p-1<p by omega)]
+  have hh : ((n-1).choose (p-1) : K)=
+      (((n-1)%p).choose ((p-1)%p)*((n-1)/p).choose ((p-1)/p) : ℕ) :=
+    (CharP.natCast_eq_natCast K p).mpr Choose.choose_modEq_choose_mod_mul_choose_div_nat
+  simpa [hmod,Nat.mod_eq_of_lt (show p-1<p by omega),Nat.div_eq_of_lt (show p-1<p by omega)] using hh
+
+lemma derivative_vanish_of_large_divisible (p : ℕ) [hp : Fact p.Prime] [CharP K p]
+    (D : MvPowerSeries (Fin 2) K) (n : ℕ) (hn : p<n) (hpn : p∣n)
+    (hD : IsCocycle p D) (hH : D.IsHomogeneous n) : pderiv (R := K) 1 D=0 := by
+  have hp1 : 1≤p := hp.out.one_le
+  have hn0 : 0<n := lt_trans hp.out.pos hn
+  let c := coeff (Finsupp.single 0 (n-1)+Finsupp.single 1 1) D
+  have he := congrArg (coeff (Finsupp.single 0 (n-p)+Finsupp.single 1 (p-1)))
+    (derivative_shape p D n hn0 hD hH)
+  have hc : c=0 := by
+    have hfac : ((p-1 : ℕ):K)+1=0 := by
+      have hh := congrArg (fun m : ℕ => (m : K)) (Nat.sub_add_cancel hp1)
+      simpa only [Nat.cast_add,Nat.cast_one,CharP.cast_eq_zero K p] using hh
+    have hcho : ((n-1).choose (n-p) : K)=1 := by
+      have heq : n-p=(n-1)-(p-1) := by omega
+      rw [heq,Nat.choose_symm (by omega)]
+      exact choose_pred_cast p n hn0 hpn
+    rw [coeff_pderiv] at he
+    simp only [Finsupp.add_apply,Finsupp.single_eq_same,Finsupp.single_eq_of_ne (show (1:Fin 2)≠0 by decide),zero_add,hfac,mul_zero] at he
+    rw [coeff_C_mul,map_sub,coeff_add_pow _ _ _ (by omega),hcho] at he
+    have hz : coeff (Finsupp.single 0 (n-p)+Finsupp.single 1 (p-1)) (X (1 : Fin 2)^(n-1) : MvPowerSeries (Fin 2) K)=0 := by
+      rw [X_pow_eq,coeff_monomial,ite_eq_right]
+      intro h
+      have hh := congrArg (fun d : Fin 2 →₀ ℕ => d 0) h
+      simp at hh
+      omega
+    rw [hz,sub_zero,mul_one] at he
+    exact he.symm
+  rw [derivative_shape p D n hn0 hD hH,show coeff _ D=c from rfl,hc,map_zero,zero_mul]
+
+lemma prime_power_sum (p j : ℕ) [hp : Fact p.Prime] [CharP K p] (hj : j<p) :
+    ∑ i ∈ Finset.range p, (i:K)^j = if j=p-1 then -1 else 0 := by
+  classical
+  have hz : ∑ i : ZMod p, i^j = if j=p-1 then -1 else 0 := by
+    by_cases he : j=p-1
+    · subst j
+      simp only [ite_true]
+      simp_rw [ZMod.pow_card_sub_one]
+      rw [Finset.sum_ite,Finset.sum_const_zero,add_zero,Finset.sum_const,Finset.filter_ne',Finset.card_erase_of_mem (Finset.mem_univ 0)]
+      simp [ZMod.card,Nat.cast_sub (show 1≤p from hp.out.one_le)]
+    · rw [ite_eq_right he]
+      apply FiniteField.sum_pow_lt_card_sub_one
+      rw [ZMod.card]
+      omega
+  have hs : ∑ i ∈ Finset.range p, (i:ZMod p)^j=∑ i : ZMod p, i^j := by
+    rw [←Fin.sum_univ_eq_sum_range]
+    have heq (i : Fin p) : ZMod.finEquiv p i=(i.val : ZMod p) := by
+      cases p with
+      | zero => exact (hp.out.ne_zero rfl).elim
+      | succ p =>
+        apply Fin.ext
+        change i.val = i.val % (p+1)
+        exact (Nat.mod_eq_of_lt i.isLt).symm
+    have hh := (ZMod.finEquiv p).toEquiv.sum_comp (fun x => x^j)
+    change (∑ i : Fin p, (ZMod.finEquiv p i)^j)=_ at hh
+    simpa only [heq] using hh
+  have hh := congrArg (ZMod.castHom (dvd_refl p) K) (hs.trans hz)
+  simpa only [map_sum,map_pow,map_natCast,apply_ite,map_neg,map_one,map_zero] using hh
+
+lemma homogeneous_trace (p n : ℕ) (D : MvPowerSeries (Fin 2) K) (hH : D.IsHomogeneous n) :
+    ∑ i ∈ Finset.range p, D.subst ![C (i:K)*PowerSeries.X,PowerSeries.X] =
+      C (∑ j ∈ Finset.range (n+1), coeff (Finsupp.single 0 j+Finsupp.single 1 (n-j)) D *
+        (∑ i ∈ Finset.range p, (i:K)^j)) * PowerSeries.X^n := by
+  classical
+  have hs (i : ℕ) : HasSubst (![C (i:K)*PowerSeries.X,PowerSeries.X] : Fin 2 → PowerSeries K) :=
+    hasSubst_of_constantCoeff_zero (by intro a; fin_cases a <;> simp [PowerSeries.X])
+  have hx : (PowerSeries.X : PowerSeries K).constantCoeff=0 := PowerSeries.constantCoeff_X
+  have heach (i : ℕ) : D.subst ![C (i:K)*PowerSeries.X,PowerSeries.X]=
+      ∑ j ∈ Finset.range (n+1), C (coeff (Finsupp.single 0 j+Finsupp.single 1 (n-j)) D) *
+        (C (i:K)*PowerSeries.X)^j * PowerSeries.X^(n-j) := by
+    conv_lhs => rw [homogeneous_sum D n hH]
+    rw [←coe_substAlgHom (hs i),map_sum]
+    simp only [coe_substAlgHom,subst_monomial_pair (K := K) _ _ _ (C (i:K)*PowerSeries.X) PowerSeries.X (by simp [PowerSeries.X]) hx]
+  simp_rw [heach]
+  simp_rw [mul_pow,←mul_assoc]
+  have hterm (i j : ℕ) (hj : j∈Finset.range (n+1)) :
+      C (coeff (Finsupp.single 0 j+Finsupp.single 1 (n-j)) D) * C (i:K)^j *
+        PowerSeries.X^j * PowerSeries.X^(n-j)=
+      C (coeff (Finsupp.single 0 j+Finsupp.single 1 (n-j)) D * (i:K)^j)*PowerSeries.X^n := by
+    rw [←map_pow,←map_mul,mul_assoc,←pow_add,Nat.add_sub_of_le]
+    simpa only [Finset.mem_range,Nat.lt_succ_iff] using hj
+  have ht (i : ℕ) : (∑ j ∈ Finset.range (n+1), C (coeff (Finsupp.single 0 j+Finsupp.single 1 (n-j)) D) * C (i:K)^j *
+        PowerSeries.X^j * PowerSeries.X^(n-j))=
+      ∑ j ∈ Finset.range (n+1), C (coeff (Finsupp.single 0 j+Finsupp.single 1 (n-j)) D * (i:K)^j)*PowerSeries.X^n :=
+    Finset.sum_congr rfl (fun j hj => hterm i j hj)
+  simp_rw [ht]
+  rw [Finset.sum_comm]
+  simp only [←Finset.sum_mul,←map_sum,←Finset.mul_sum]
+
+lemma derivative_vanish_at_prime (p : ℕ) [hp : Fact p.Prime] [CharP K p]
+    (D : MvPowerSeries (Fin 2) K) (hD : IsCocycle p D) (hH : D.IsHomogeneous p) :
+    pderiv (R := K) 1 D=0 := by
+  classical
+  have htop : coeff (Finsupp.single 0 p+Finsupp.single 1 0) D=0 := by
+    have hs : HasSubst (![(X (0 : Fin 1) : MvPowerSeries (Fin 1) K),0] : Fin 2 → MvPowerSeries (Fin 1) K) :=
+      hasSubst_of_constantCoeff_zero (by intro i; fin_cases i <;> simp)
+    have hh := hD.zero_right
+    rw [homogeneous_sum D p hH,←coe_substAlgHom hs,map_sum] at hh
+    simp only [coe_substAlgHom,subst_monomial_pair (K := K) _ _ _ (X (0 : Fin 1)) 0 (constantCoeff_X _) (map_zero _)] at hh
+    have hz (j : ℕ) (hj : j∈Finset.range (p+1)) (hjp : j≠p) :
+        C (coeff (Finsupp.single 0 j+Finsupp.single 1 (p-j)) D) * (X (0 : Fin 1))^j * (0 : MvPowerSeries (Fin 1) K)^(p-j)=0 := by
+      have he : p-j≠0 := by simp only [Finset.mem_range] at hj; omega
+      rw [zero_pow he,mul_zero]
+    rw [Finset.sum_eq_single p (fun j hj hne => hz j hj hne) (by simp)] at hh
+    simp only [Nat.sub_self,pow_zero,mul_one] at hh
+    have hc := congrArg (coeff (Finsupp.single (0 : Fin 1) p)) hh
+    simpa only [coeff_C_mul,X_pow_eq,coeff_monomial_same,mul_one,map_zero] using hc
+  have ht := hD.trace_zero
+  rw [homogeneous_trace p p D hH] at ht
+  have hsum : ∑ j ∈ Finset.range (p+1), coeff (Finsupp.single 0 j+Finsupp.single 1 (p-j)) D *
+      (∑ i ∈ Finset.range p, (i:K)^j) = -coeff (Finsupp.single 0 (p-1)+Finsupp.single 1 1) D := by
+    rw [Finset.sum_range_succ,Nat.sub_self,htop,zero_mul,add_zero]
+    have ht : (∑ j ∈ Finset.range p, coeff (Finsupp.single 0 j+Finsupp.single 1 (p-j)) D * (∑ i ∈ Finset.range p, (i:K)^j))=
+        ∑ j ∈ Finset.range p, coeff (Finsupp.single 0 j+Finsupp.single 1 (p-j)) D * (if j=p-1 then -1 else 0) := by
+      apply Finset.sum_congr rfl
+      intro j hj
+      rw [prime_power_sum p j (Finset.mem_range.mp hj)]
+    rw [ht]
+    rw [Finset.sum_eq_single (p-1)]
+    · simp [Nat.sub_sub_self (show 1≤p from hp.out.one_le)]
+    · intro b hb hne; rw [ite_eq_right hne,mul_zero]
+    · intro h; exact (h (Finset.mem_range.mpr (Nat.sub_lt hp.out.pos (by decide)))).elim
+  rw [hsum] at ht
+  change PowerSeries.C (-coeff (Finsupp.single 0 (p-1)+Finsupp.single 1 1) D)*PowerSeries.X^p=0 at ht
+  have hc := congrArg (PowerSeries.coeff p) ht
+  simp only [PowerSeries.coeff_C_mul_X_pow,map_zero,ite_true,neg_eq_zero] at hc
+  rw [derivative_shape p D p hp.out.pos hD hH,hc,map_zero,zero_mul]
+
+lemma exists_expand_of_support {σ R : Type*} [CommRing R] (f : MvPowerSeries σ R)
+    (q : ℕ) (hq : q ≠ 0) (h : ∀ d, coeff d f ≠ 0 → ∀ i, q ∣ d i) :
+    ∃ g, expand q hq g = f := by
+  classical
+  let g : MvPowerSeries σ R := fun d => coeff (q • d) f
+  refine ⟨g, ?_⟩
+  ext d
+  by_cases hd : ∀ i, q ∣ d i
+  · let e := d.mapRange (fun n => n/q) (Nat.zero_div q)
+    have he : q • e = d := by
+      ext i
+      simp only [Finsupp.smul_apply, smul_eq_mul, e, Finsupp.mapRange_apply]
+      exact Nat.mul_div_cancel' (hd i)
+    rw [← he, coeff_expand_smul]
+    rfl
+  · obtain ⟨i, hi⟩ := not_forall.mp hd
+    rw [coeff_expand_of_not_dvd _ _ _ hi]
+    by_contra hf
+    exact hi (h d (Ne.symm hf) i)
+
+lemma expand_injective {R : Type*} [CommRing R] (q : ℕ) (hq : q ≠ 0) :
+    Function.Injective (MvPowerSeries.expand (R := R) (σ := σ) q hq) := by
+  intro f g h
+  ext d
+  simpa only [coeff_expand_smul] using congrArg (coeff (q • d)) h
+
+lemma subst_expand (p : ℕ) (hp : p≠0) (D : MvPowerSeries σ K)
+    (a : σ → MvPowerSeries τ K) (ha : HasSubst a) :
+    (expand p hp D).subst a = D.subst (fun i => a i^p) := by
+  rw [expand,substAlgHom_apply,subst_comp_subst_apply (HasSubst.X_pow hp) ha]
+  congr 1
+  funext i
+  rw [subst_pow ha,subst_X ha]
+
+lemma expand_subst_comm (p : ℕ) (hp : p≠0) (D : MvPowerSeries σ K)
+    (a : σ → MvPowerSeries τ K) (ha : HasSubst a)
+    (hpow : ∀ i, expand p hp (a i)=a i^p) :
+    expand p hp (D.subst a)=(expand p hp D).subst a := by
+  rw [expand_subst p hp ha,subst_expand p hp D a ha]
+  congr 1
+  funext i
+  exact hpow i
+
+local instance seriesCharP (p : ℕ) [CharP K p] : CharP (MvPowerSeries σ K) p :=
+  charP_of_injective_ringHom MvPowerSeries.C_injective p
+
+lemma isCocycle_of_expand (p : ℕ) [hp : Fact p.Prime] [CharP K p]
+    (D : MvPowerSeries (Fin 2) K) (hD : IsCocycle p (expand p hp.out.ne_zero D)) :
+    IsCocycle p D := by
+  have h0 (a : Fin 2 → MvPowerSeries (Fin 1) K) (ha : HasSubst a)
+      (hpow : ∀ i, expand p hp.out.ne_zero (a i)=a i^p) :
+      expand p hp.out.ne_zero (D.subst a)=(expand p hp.out.ne_zero D).subst a :=
+    expand_subst_comm p hp.out.ne_zero D a ha hpow
+  have h3 (a : Fin 2 → MvPowerSeries (Fin 3) K) (ha : HasSubst a)
+      (hpow : ∀ i, expand p hp.out.ne_zero (a i)=a i^p) :
+      expand p hp.out.ne_zero (D.subst a)=(expand p hp.out.ne_zero D).subst a :=
+    expand_subst_comm p hp.out.ne_zero D a ha hpow
+  have hpos : p≠0 := hp.out.ne_zero
+  refine ⟨?_,?_,?_,?_,?_⟩
+  · apply expand_injective p hpos
+    rw [map_zero,h0 _ (hasSubst_of_constantCoeff_zero (by intro i; fin_cases i <;> simp))
+      (by intro i; fin_cases i <;> simp [zero_pow hpos])]
+    exact hD.zero_left
+  · apply expand_injective p hpos
+    rw [map_zero,h0 _ (hasSubst_of_constantCoeff_zero (by intro i; fin_cases i <;> simp))
+      (by intro i; fin_cases i <;> simp [zero_pow hpos])]
+    exact hD.zero_right
+  · apply expand_injective p hpos
+    rw [expand_subst_comm p hpos D _ (hasSubst_of_constantCoeff_zero (by intro i; fin_cases i <;> simp))
+      (by intro i; fin_cases i <;> simp)]
+    exact hD.symmetric
+  · apply expand_injective p hpos
+    rw [map_add,map_add]
+    rw [h3 _ (hasSubst_of_constantCoeff_zero (by intro i; fin_cases i <;> simp))
+      (by intro i; fin_cases i <;> simp)]
+    rw [h3 _ (hasSubst_of_constantCoeff_zero (by intro i; fin_cases i <;> simp))
+      (by intro i; fin_cases i <;> simp [add_pow_char])]
+    rw [h3 _ (hasSubst_of_constantCoeff_zero (by intro i; fin_cases i <;> simp))
+      (by intro i; fin_cases i <;> simp)]
+    rw [h3 _ (hasSubst_of_constantCoeff_zero (by intro i; fin_cases i <;> simp))
+      (by intro i; fin_cases i <;> simp [add_pow_char])]
+    exact hD.associative
+  · apply expand_injective p hpos
+    rw [map_zero,map_sum]
+    have hterm (i : ℕ) : expand p hpos (D.subst ![C (i:K)*PowerSeries.X,PowerSeries.X])=
+        (expand p hpos D).subst ![C (i:K)*PowerSeries.X,PowerSeries.X] := by
+      apply expand_subst_comm p hpos D
+      · apply hasSubst_of_constantCoeff_zero
+        intro j; fin_cases j <;> simp [PowerSeries.X]
+      · have hh : (i:PowerSeries K)^p=(i:PowerSeries K) := (map_natCast (frobenius (PowerSeries K) p) i)
+        intro j; fin_cases j <;> simp [PowerSeries.X,map_mul,mul_pow,hh]
+    simp_rw [hterm]
+    exact hD.trace_zero
+
+lemma homogeneous_of_expand (p : ℕ) (hp : p≠0) (D : MvPowerSeries (Fin 2) K)
+    (n : ℕ) (hD : (expand p hp D).IsHomogeneous n) : D.IsHomogeneous (n/p) := by
+  apply homogeneous_of_coeff
+  intro d hd
+  by_contra hn
+  have hz : coeff (p • d) (expand p hp D)≠0 := by rwa [coeff_expand_smul]
+  have he : (p • d).degree=n := by
+    by_contra hne
+    exact hz (hD.coeff_eq_zero hne)
+  have hdeg : (p • d).degree=p*d.degree := by rw [map_nsmul,smul_eq_mul]
+  apply hd
+  rw [←he,hdeg,Nat.mul_div_cancel_left _ (Nat.pos_of_ne_zero hp)]
+
+lemma expand_coboundary (p : ℕ) [hp : Fact p.Prime] [CharP K p] (n : ℕ) :
+    expand p hp.out.ne_zero (coboundary (K := K) n)=coboundary (p*n) := by
+  simp only [coboundary,map_sub,map_pow,map_add,expand_X]
+  rw [←add_pow_char,←pow_mul,←pow_mul,←pow_mul]
+
+theorem cocycle_is_coboundary (p : ℕ) [hp : Fact p.Prime] [CharP K p]
+    (n : ℕ) (hn : 0<n) (D : MvPowerSeries (Fin 2) K)
+    (hD : IsCocycle p D) (hH : D.IsHomogeneous n) :
+    ∃ a : K, D=a • coboundary n := by
+  induction n using Nat.strong_induction_on generalizing D with
+  | h n ih =>
+    by_cases hpn : p∣n
+    · have hple : p≤n := Nat.le_of_dvd hn hpn
+      have hd1 : pderiv (R := K) 1 D=0 := by
+        rcases hple.eq_or_lt with he | hl
+        · subst n
+          exact derivative_vanish_at_prime p D hD hH
+        · exact derivative_vanish_of_large_divisible p D n hl hpn hD hH
+      have hd : ∀ i, pderiv (R := K) i D=0 := by
+        intro i; fin_cases i
+        · change pderiv (R := K) 0 D=0
+          rw [derivative_symmetry D hD.symmetric,hd1,
+            ←coe_substAlgHom (hasSubst_of_constantCoeff_zero (by intro j; fin_cases j <;> simp)),map_zero]
+        · exact hd1
+      obtain ⟨E,hE⟩ := exists_expand_of_support D p hp.out.ne_zero (derivative_zero_support p D hd)
+      have hEH : E.IsHomogeneous (n/p) := by
+        apply homogeneous_of_expand p hp.out.ne_zero
+        rwa [hE]
+      have hEC : IsCocycle p E := isCocycle_of_expand p E (by rwa [hE])
+      obtain ⟨a,ha⟩ := ih (n/p) (Nat.div_lt_self hn hp.out.one_lt)
+        (Nat.div_pos hple hp.out.pos) E hEC hEH
+      refine ⟨a,?_⟩
+      rw [←hE,ha,map_smul,expand_coboundary,Nat.mul_div_cancel' hpn]
+    · exact coboundary_of_prime_not_dvd p D n hpn hD hH
+
+end HeightThree.HomogeneousCocycle
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/FormalGroup/Honda/Coordinates.lean b/lean/OAI/Algebra/FormalGroup/Honda/Coordinates.lean
new file mode 100644
index 0000000000000000000000000000000000000000..95553db216ba0da87a6aab2fdebb89f312f052f6
--- /dev/null
+++ b/lean/OAI/Algebra/FormalGroup/Honda/Coordinates.lean
@@ -0,0 +1,353 @@
+import OAI.Algebra.FormalGroup.Honda.Recurrence
+
+namespace OAI
+
+noncomputable section
+
+namespace HeightThree.HondaCoordinates
+open MvPowerSeries HondaConstruction HondaTarget LogarithmicConstruction
+variable {A B : Type*} [CommRing A] [CommRing B]
+
+@[simp] lemma multiplication_zero (F : FormalGroup A) : multiplicationSeries F 0 = 0 := rfl
+
+lemma multiplication_succ (F : FormalGroup A) (n : ℕ) :
+    multiplicationSeries F (n+1) =
+      F.toPowerSeries.subst ![multiplicationSeries F n, PowerSeries.X] := by
+  change ((n+1) • variablePoint F).val = _
+  rw [succ_nsmul]
+  rfl
+
+@[simp] lemma multiplication_constant (F : FormalGroup A) (n : ℕ) :
+    (multiplicationSeries F n).constantCoeff = 0 := by
+  induction n with
+  | zero => simp
+  | succ n ih =>
+    rw [multiplication_succ]
+    apply MvPowerSeries.constantCoeff_subst_eq_zero
+      (hasSubst_of_constantCoeff_zero (by intro i; fin_cases i; exact ih; exact PowerSeries.constantCoeff_X))
+      (by intro i; fin_cases i; exact ih; exact PowerSeries.constantCoeff_X) F.zero_constantCoeff
+
+lemma multiplication_map (F : FormalGroup A) (φ : A →+* B) (n : ℕ) :
+    multiplicationSeries (F.map φ) n = (multiplicationSeries F n).map φ := by
+  induction n with
+  | zero => simp
+  | succ n ih =>
+    rw [multiplication_succ, multiplication_succ]
+    change _ = MvPowerSeries.map φ (F.toPowerSeries.subst ![multiplicationSeries F n, PowerSeries.X])
+    have hs : MvPowerSeries.HasSubst ![multiplicationSeries F n, PowerSeries.X] :=
+      hasSubst_of_constantCoeff_zero (by
+        intro i; fin_cases i; exact multiplication_constant F n; exact PowerSeries.constantCoeff_X)
+    rw [map_subst hs, ih]
+    congr 1
+    funext i
+    fin_cases i
+    · rfl
+    · exact (MvPowerSeries.map_X φ ()).symm
+
+lemma log_multiplication (l : StrictLog (R := A)) (n : ℕ) :
+    l.series.subst (multiplicationSeries l.formalGroup n) = n • l.series := by
+  induction n with
+  | zero =>
+    simp only [multiplication_zero, zero_nsmul]
+    exact PowerSeries.subst_zero_of_constantCoeff_zero l.constant_zero
+  | succ n ih =>
+    rw [multiplication_succ]
+    change l.series.subst (l.law.subst ![_, PowerSeries.X]) = _
+    rw [l.log_law_pair _ _ (multiplication_constant _ _) PowerSeries.constantCoeff_X, ih,
+      PowerSeries.X_subst, succ_nsmul]
+
+lemma multiplication_linear (l : StrictLog (R := A)) (n : ℕ) :
+    (multiplicationSeries l.formalGroup n).coeff 1 = (n : A) := by
+  have h := congrArg (PowerSeries.coeff 1) (log_multiplication l n)
+  rw [show (PowerSeries.coeff 1 : PowerSeries A →ₗ[A] A) =
+    MvPowerSeries.coeff (Finsupp.single () 1) from rfl,
+    StrictLog.coeff_subst_linear _ _ (multiplication_constant _ _) (), l.linear_one,
+    one_mul] at h
+  change (multiplicationSeries l.formalGroup n).coeff 1 = n • l.series.coeff 1 at h
+  simpa only [l.linear_one, nsmul_one] using h
+
+end HeightThree.HondaCoordinates
+
+namespace HeightThree.HondaCoordinates
+open MvPowerSeries HondaConstruction HondaTarget LogarithmicConstruction
+variable {R : Type*} [CommRing R]
+
+lemma coeff_pow_below (g : PowerSeries R) (hg : g.constantCoeff = 0)
+    (n j : ℕ) (hjn : j < n) : (g^n).coeff j = 0 := by
+  exact PowerSeries.coeff_of_lt_order j (lt_of_lt_of_le
+    (by exact_mod_cast hjn) (PowerSeries.le_order_pow_of_constantCoeff_eq_zero n hg))
+
+lemma coeff_pow_leading (g : PowerSeries R) (hg : g.constantCoeff = 0) (n : ℕ) :
+    (g^n).coeff n = (g.coeff 1)^n := by
+  obtain ⟨h, rfl⟩ := PowerSeries.X_dvd_iff.mpr hg
+  rw [mul_pow]
+  have hc (h : PowerSeries R) (n : ℕ) : (PowerSeries.X^n * h).coeff n = h.constantCoeff := by
+    simpa only [zero_add, PowerSeries.coeff_zero_eq_constantCoeff] using
+      PowerSeries.coeff_X_pow_mul h n 0
+  rw [hc]
+  rw [show PowerSeries.X * h = PowerSeries.X^1 * h by simp, hc, map_pow]
+
+lemma coeff_subst_before (l : StrictLog (R := R)) (q : ℕ)
+    (hl : ∀ j, 1 < j → j < q → l.series.coeff j = 0)
+    (g : PowerSeries R) (hg : g.constantCoeff = 0) (j : ℕ) (hj : j < q) :
+    PowerSeries.coeff j (l.series.subst g) = g.coeff j := by
+  rw [PowerSeries.coeff_subst' (PowerSeries.HasSubst.of_constantCoeff_zero hg),
+    finsum_eq_single _ 1, l.linear_one, one_smul, pow_one]
+  intro n hn
+  by_cases hn0 : n = 0
+  · subst n
+    rw [PowerSeries.coeff_zero_eq_constantCoeff, l.constant_zero, zero_smul]
+  by_cases hnq : n < q
+  · rw [hl n (by omega) hnq, zero_smul]
+  · rw [coeff_pow_below g hg n j (by omega), smul_zero]
+
+lemma coeff_subst_first (l : StrictLog (R := R)) (q : ℕ) (hq : 1 < q)
+    (hl : ∀ j, 1 < j → j < q → l.series.coeff j = 0)
+    (g : PowerSeries R) (hg : g.constantCoeff = 0) :
+    PowerSeries.coeff q (l.series.subst g) = g.coeff q + l.series.coeff q * (g.coeff 1)^q := by
+  classical
+  rw [PowerSeries.coeff_subst' (PowerSeries.HasSubst.of_constantCoeff_zero hg)]
+  rw [finsum_eq_sum_of_support_subset _ (s := {1, q})]
+  · rw [Finset.sum_insert (by simpa only [Finset.mem_singleton] using (ne_of_lt hq)), Finset.sum_singleton]
+    dsimp
+    simp only [l.linear_one, one_mul, pow_one, coeff_pow_leading g hg q]
+  · intro n hn
+    by_contra hn'
+    have hh : n ≠ 1 ∧ n ≠ q := by simpa using hn'
+    obtain ⟨hn1, hnq⟩ := hh
+    apply hn
+    change l.series.coeff n • (g^n).coeff q = 0
+    by_cases hn0 : n = 0
+    · subst n
+      rw [PowerSeries.coeff_zero_eq_constantCoeff, l.constant_zero, zero_smul]
+    by_cases hnlt : n < q
+    · rw [hl n (by omega) hnlt, zero_smul]
+    · rw [coeff_pow_below g hg n q (by omega), smul_zero]
+
+theorem multiplication_first_coeff (l : StrictLog (R := R)) (q : ℕ) (hq : 1 < q)
+    (hl : ∀ j, 1 < j → j < q → l.series.coeff j = 0) (n : ℕ) :
+    (∀ j < q, (multiplicationSeries l.formalGroup n).coeff j =
+      (n : R) * (PowerSeries.X : PowerSeries R).coeff j) ∧
+    (multiplicationSeries l.formalGroup n).coeff q =
+      l.series.coeff q * ((n : R) - (n : R)^q) := by
+  have hg := multiplication_constant l.formalGroup n
+  constructor
+  · intro j hj
+    have h := congrArg (PowerSeries.coeff j) (log_multiplication l n)
+    rw [coeff_subst_before l q hl _ hg j hj, map_nsmul] at h
+    by_cases hj1 : j = 1
+    · subst j
+      simpa [l.linear_one] using h
+    by_cases hj0 : j = 0
+    · subst j
+      simp
+    · rw [hl j (by omega) hj, smul_zero] at h
+      simpa [PowerSeries.coeff_X, hj1] using h
+  · have h := congrArg (PowerSeries.coeff q) (log_multiplication l n)
+    rw [coeff_subst_first l q hq hl _ hg, multiplication_linear, map_nsmul,
+      nsmul_eq_mul] at h
+    linear_combination h
+
+end HeightThree.HondaCoordinates
+
+namespace HeightThree.HondaCoordinates
+open MvPowerSeries HondaConstruction HondaTarget LogarithmicConstruction PTypical
+variable {A B : Type*} [CommRing A] [CommRing B]
+
+lemma numerator_one (p : ℕ) (ψ : A →+* A) (v : Fin 3 → A) :
+    numerator p ψ v 1 = v 0 := by
+  simp [numerator]
+
+lemma numerator_two (p : ℕ) (ψ : A →+* A) (v : Fin 3 → A) (hv : v 0 = 0) :
+    numerator p ψ v 2 = (p : A) * v 1 := by
+  simp [numerator, Fin.sum_univ_three, hv]
+
+lemma logarithm_coeff_below [Algebra ℚ B] (ι : A →+* B) (p : ℕ) (hp : 2 ≤ p)
+    (ψ : A →+* A) (v : Fin 3 → A) (m : ℕ)
+    (hm : ∀ n, 0 < n → n < m → numerator p ψ v n = 0)
+    (j : ℕ) (hj1 : 1 < j) (hj : j < p^m) :
+    (logarithm ι p ψ v).coeff j = 0 := by
+  by_cases hn : ∃ n : ℕ, p^n = j
+  · obtain ⟨n, rfl⟩ := hn
+    rw [logarithm, coeff_series_power p hp]
+    have hnpos : 0 < n := by by_contra h; simp [show n = 0 by omega] at hj1
+    rw [hm n hnpos ((Nat.pow_lt_pow_iff_right (by omega : 1 < p)).mp hj),
+      map_zero, smul_zero]
+  · exact coeff_series_outside p j _ hn
+
+lemma rational_first_cancel [Algebra ℚ B] (p : ℕ) (hp : p ≠ 0)
+    (q : ℕ) (hq : 0 < q) (v : B) :
+    ((p : ℚ)⁻¹ • v) * ((p : B) - (p : B)^q) = v * (1 - (p : B)^(q-1)) := by
+  have hc : algebraMap ℚ B (p : ℚ)⁻¹ * (p : B) = 1 := by
+    rw [← map_natCast (algebraMap ℚ B), ← map_mul, inv_mul_cancel₀ (by exact_mod_cast hp), map_one]
+  rw [Algebra.smul_def, show q = (q-1)+1 by omega, pow_succ]
+  calc
+    _ = (algebraMap ℚ B (p : ℚ)⁻¹ * (p : B)) * v * (1-(p : B)^(q-1)) := by ring
+    _ = _ := by simp only [hc, one_mul, Nat.add_sub_cancel]
+
+theorem multiplication_first_integral [Algebra ℚ B] (ι : A →+* B)
+    (hinj : Function.Injective ι) (F : FormalGroup A) (l : StrictLog (R := B))
+    (hF : F.map ι = l.formalGroup) (p : ℕ) (hp : p ≠ 0)
+    (q : ℕ) (hq : 1 < q) (v : A)
+    (hl : ∀ j, 1 < j → j < q → l.series.coeff j = 0)
+    (hlq : l.series.coeff q = (p : ℚ)⁻¹ • ι v) :
+    (∀ j < q, (multiplicationSeries F p).coeff j = (p : A) *
+      (PowerSeries.X : PowerSeries A).coeff j) ∧
+    (multiplicationSeries F p).coeff q = v * (1-(p : A)^(q-1)) := by
+  have hmap : (multiplicationSeries F p).map ι = multiplicationSeries l.formalGroup p := by
+    rw [← multiplication_map, hF]
+  have h := multiplication_first_coeff l q hq hl p
+  constructor
+  · intro j hj
+    apply hinj
+    have he := congrArg (PowerSeries.coeff j) hmap
+    rw [PowerSeries.coeff_map, h.1 j hj] at he
+    simpa only [map_mul, map_natCast, PowerSeries.coeff_X, apply_ite ι,
+      map_one, map_zero] using he
+  · apply hinj
+    have he := congrArg (PowerSeries.coeff q) hmap
+    rw [PowerSeries.coeff_map, h.2, hlq, rational_first_cancel p hp q (by omega)] at he
+    simpa only [map_mul, map_sub, map_one, map_pow, map_natCast] using he
+
+lemma integralFormalGroup_map [Algebra ℚ B] (ι : A →+* B) (hinj : Function.Injective ι)
+    (p : ℕ) [hp : Fact p.Prime]
+    (ψ : A →+* A) (χ : B →ₐ[ℚ] B) (hc : χ.toRingHom.comp ι = ι.comp ψ)
+    (hψ : ∀ a : A, (p : A) ∣ ψ a - a^p) (v : Fin 3 → A) :
+    (integralFormalGroup ι hinj p ψ χ hc hψ v).map ι =
+      (heightThreeLog ι p hp.out.two_le ψ v).formalGroup := map_descendFormalGroup ..
+
+theorem integralFormalGroup_height_one [Algebra ℚ B]
+    (ι : A →+* B) (hinj : Function.Injective ι) (p : ℕ) [hp : Fact p.Prime]
+    (ψ : A →+* A) (χ : B →ₐ[ℚ] B) (hc : χ.toRingHom.comp ι = ι.comp ψ)
+    (hψ : ∀ a : A, (p : A) ∣ ψ a - a^p) (v : Fin 3 → A) :
+    (∀ j < p, (multiplicationSeries (integralFormalGroup ι hinj p ψ χ hc hψ v) p).coeff j =
+      (p : A) * (PowerSeries.X : PowerSeries A).coeff j) ∧
+    (multiplicationSeries (integralFormalGroup ι hinj p ψ χ hc hψ v) p).coeff p =
+      v 0 * (1 - (p : A)^(p-1)) := by
+  apply multiplication_first_integral ι hinj _ (heightThreeLog ι p hp.out.two_le ψ v)
+    (integralFormalGroup_map ..) p hp.out.ne_zero p hp.out.one_lt (v 0)
+  · intro j hj1 hj
+    exact logarithm_coeff_below ι p hp.out.two_le ψ v 1 (by intro n hn hn'; omega)
+      j hj1 (by simpa using hj)
+  · change (logarithm ι p ψ v).coeff p = _
+    have he := coeff_series_power p hp.out.two_le
+      (fun n => ((p : ℚ)⁻¹)^n • ι (numerator p ψ v n)) 1
+    simpa only [logarithm, pow_one, numerator_one] using he
+
+end HeightThree.HondaCoordinates
+
+namespace HeightThree.HondaCoordinates
+open MvPowerSeries HondaConstruction HondaTarget LogarithmicConstruction PTypical
+variable {A B C D : Type*} [CommRing A] [CommRing B] [CommRing C] [CommRing D]
+
+theorem integralFormalGroup_height_two [Algebra ℚ B]
+    (ι : A →+* B) (hinj : Function.Injective ι) (p : ℕ) [hp : Fact p.Prime]
+    (ψ : A →+* A) (χ : B →ₐ[ℚ] B) (hc : χ.toRingHom.comp ι = ι.comp ψ)
+    (hψ : ∀ a : A, (p : A) ∣ ψ a - a^p) (v : Fin 3 → A) (hv : v 0 = 0) :
+    (∀ j < p^2, (multiplicationSeries (integralFormalGroup ι hinj p ψ χ hc hψ v) p).coeff j =
+      (p : A) * (PowerSeries.X : PowerSeries A).coeff j) ∧
+    (multiplicationSeries (integralFormalGroup ι hinj p ψ χ hc hψ v) p).coeff (p^2) =
+      v 1 * (1 - (p : A)^(p^2-1)) := by
+  have hp2 : 1 < p^2 := one_lt_pow₀ hp.out.one_lt (by decide)
+  apply multiplication_first_integral ι hinj _ (heightThreeLog ι p hp.out.two_le ψ v)
+    (integralFormalGroup_map ..) p hp.out.ne_zero (p^2) hp2 (v 1)
+  · intro j hj1 hj
+    apply logarithm_coeff_below ι p hp.out.two_le ψ v 2 _ j hj1 hj
+    intro n hn hn'
+    have : n = 1 := by omega
+    simp [this, numerator_one, hv]
+  · change (logarithm ι p ψ v).coeff (p^2) = _
+    rw [logarithm, coeff_series_power p hp.out.two_le, numerator_two p ψ v hv,
+      map_mul, map_natCast]
+    have hs : ((p : ℚ)⁻¹)^2 • ((p : B) * ι (v 1)) = (p : ℚ)⁻¹ • ι (v 1) := by
+      rw [Algebra.smul_def, Algebra.smul_def, ← map_natCast (algebraMap ℚ B),
+        ← mul_assoc, ← map_mul]
+      congr 2
+      field_simp
+    exact hs
+
+lemma numerator_map (α : A →+* B) (p : ℕ) (ψ : A →+* A) (χ : B →+* B)
+    (hc : χ.comp α = α.comp ψ) (v : Fin 3 → A) (n : ℕ) :
+    α (numerator p ψ v n) = numerator p χ (α ∘ v) n := by
+  induction n using Nat.strong_induction_on with
+  | h n ih =>
+    cases n with
+    | zero => simp [numerator]
+    | succ n =>
+      rw [numerator, numerator, map_sum]
+      apply Finset.sum_congr rfl
+      intro i hi
+      split_ifs with hn
+      · rw [map_mul, map_mul, map_pow, map_natCast, ← iterate_comp α ψ χ hc,
+          ih (n-i.val) (by omega)]
+        rfl
+      · exact map_zero α
+
+end HeightThree.HondaCoordinates
+
+namespace HeightThree.LogarithmicConstruction.StrictLog
+open MvPowerSeries
+variable {A B : Type*} [CommRing A] [CommRing B]
+
+def map (l : StrictLog (R := A)) (φ : A →+* B) : StrictLog (R := B) where
+  series := l.series.map φ
+  constant_zero := by
+    change φ l.series.constantCoeff = 0
+    rw [l.constant_zero, map_zero]
+  linear_one := by simp only [PowerSeries.coeff_map, l.linear_one, map_one]
+
+lemma formalGroup_map (l : StrictLog (R := A)) (φ : A →+* B) :
+    l.formalGroup.map φ = (l.map φ).formalGroup := by
+  apply FormalGroup.ext
+  apply (l.map φ).subst_injective
+    (PowerSeries.HasSubst.of_constantCoeff_zero (l.formalGroup.map φ).zero_constantCoeff)
+    (PowerSeries.HasSubst.of_constantCoeff_zero (l.map φ).law_constant)
+  change (l.series.map φ).subst (l.law.map φ) = (l.map φ).series.subst (l.map φ).law
+  rw [(l.map φ).log_law, ← PowerSeries.map_subst
+    (PowerSeries.HasSubst.of_constantCoeff_zero l.law_constant), l.log_law]
+  simp only [StrictLog.sumSeries, map_add, PowerSeries.map_subst (PowerSeries.HasSubst.X _),
+    map_X, map]
+
+@[ext] lemma ext {l m : StrictLog (R := A)} (h : l.series = m.series) : l = m := by
+  cases l
+  cases m
+  congr
+
+end HeightThree.LogarithmicConstruction.StrictLog
+
+namespace HeightThree.HondaCoordinates
+open MvPowerSeries HondaConstruction HondaTarget LogarithmicConstruction PTypical
+variable {A B C D : Type*} [CommRing A] [CommRing B] [CommRing C] [CommRing D]
+
+lemma logarithm_map [Algebra ℚ B] [Algebra ℚ D]
+    (ι : A →+* B) (κ : C →+* D) (α : A →+* C) (β : B →ₐ[ℚ] D)
+    (hi : β.toRingHom.comp ι = κ.comp α) (p : ℕ) (hp : 2 ≤ p)
+    (ψ : A →+* A) (χ : C →+* C) (hc : χ.comp α = α.comp ψ) (v : Fin 3 → A) :
+    (logarithm ι p ψ v).map β.toRingHom = logarithm κ p χ (α ∘ v) := by
+  ext j
+  rw [PowerSeries.coeff_map]
+  by_cases hj : ∃ n : ℕ, p^n = j
+  · obtain ⟨n, rfl⟩ := hj
+    simp only [logarithm, coeff_series_power p hp]
+    change β (((p : ℚ)⁻¹)^n • ι (numerator p ψ v n)) = _
+    rw [β.map_smul_of_tower]
+    congr 1
+    change (β.toRingHom.comp ι) _ = _
+    rw [hi]
+    change κ (α _) = _
+    rw [numerator_map α p ψ χ hc]
+  · simp only [logarithm, coeff_series_outside p j _ hj, map_zero]
+
+lemma heightThreeLog_map [Algebra ℚ B] [Algebra ℚ D]
+    (ι : A →+* B) (κ : C →+* D) (α : A →+* C) (β : B →ₐ[ℚ] D)
+    (hi : β.toRingHom.comp ι = κ.comp α) (p : ℕ) (hp : 2 ≤ p)
+    (ψ : A →+* A) (χ : C →+* C) (hc : χ.comp α = α.comp ψ) (v : Fin 3 → A) :
+    (heightThreeLog ι p hp ψ v).map β.toRingHom = heightThreeLog κ p hp χ (α ∘ v) := by
+  apply StrictLog.ext
+  exact logarithm_map ι κ α β hi p hp ψ χ hc v
+
+end HeightThree.HondaCoordinates
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/FormalGroup/Honda/Correction.lean b/lean/OAI/Algebra/FormalGroup/Honda/Correction.lean
new file mode 100644
index 0000000000000000000000000000000000000000..23a6bbc9ee09a4ff895a306aaa4d7dd34043cf7c
--- /dev/null
+++ b/lean/OAI/Algebra/FormalGroup/Honda/Correction.lean
@@ -0,0 +1,141 @@
+import OAI.Algebra.FormalGroup.Honda.Frobenius
+
+namespace OAI
+
+noncomputable section
+
+namespace HeightThree.HondaCorrection
+open MvPowerSeries HeightThree.HondaJets HeightThree.HondaLeading
+open HeightThree.HondaTarget HeightThree.HondaFrobenius HeightThree.HomogeneousCocycle
+open HeightThree.CoordinateTransport HeightThree.DeformationRigidity
+variable {K σ : Type*} [Field K]
+
+def stepSeries (n : ℕ) (a : K) : PowerSeries K := PowerSeries.X+PowerSeries.C a*PowerSeries.X^n
+
+lemma step_zero (n : ℕ) (hn : 0<n) (a : K) : (stepSeries n a).constantCoeff=0 := by
+  simp [stepSeries,hn.ne']
+lemma step_linear (n : ℕ) (hn : 2≤n) (a : K) : (stepSeries n a).coeff 1=1 := by
+  simp [stepSeries,map_add,PowerSeries.coeff_C_mul,PowerSeries.coeff_X_pow,show 1≠n by omega]
+
+def step (n : ℕ) (hn : 2≤n) (a : K) : Coordinate K :=
+  Coordinate.ofSeries (stepSeries n a) (step_zero n (by omega) a) (by rw [step_linear n hn a]; exact isUnit_one)
+
+lemma step_subst (n : ℕ) (a : K) (z : MvPowerSeries σ K) (hz : z.constantCoeff=0) :
+    (stepSeries n a).subst z=z+C a*z^n := by
+  have hs : PowerSeries.HasSubst z := .of_constantCoeff_zero hz
+  simp [stepSeries,PowerSeries.subst_add hs,PowerSeries.subst_mul hs,PowerSeries.subst_pow hs,
+    PowerSeries.subst_X hs,PowerSeries.subst_C]
+
+lemma step_jet (n : ℕ) (a : K) (z : MvPowerSeries σ K) (hz : z.constantCoeff=0) :
+    EqJet n ((stepSeries n a).subst z) z := by
+  rw [step_subst n a z hz]
+  have hh := (eqJet_pow_zero z hz n).mul_left (C a)
+  simpa using (EqJet.refl n z).add hh
+
+lemma step_Xjet (n : ℕ) (_ : 0<n) (a : K) : EqJet n (stepSeries n a) PowerSeries.X := by
+  have hh := step_jet n a (PowerSeries.X : PowerSeries K) (by simp [PowerSeries.X])
+  simpa only [PowerSeries.X_subst] using hh
+
+lemma pullback_step_jet (c : Coordinate K) (F G : FormalGroup K) (m : ℕ)
+    (h : EqJet m (c.series.subst G.toPowerSeries)
+      (F.toPowerSeries.subst ![c.series.subst (X 0),c.series.subst (X 1)])) :
+    EqJet m (c.transport G).toPowerSeries F.toPowerSeries := by
+  let b : Fin 2 → MvPowerSeries (Fin 2) K := ![c.inverse.subst (X 0),c.inverse.subst (X 1)]
+  have hb0 : ∀i,(b i).constantCoeff=0 := by
+    intro i; fin_cases i <;> exact c.inverse_const _ (by simp)
+  have hb := hasSubst_of_constantCoeff_zero hb0
+  have ha : HasSubst ![c.series.subst (X 0 : MvPowerSeries (Fin 2) K),c.series.subst (X 1)] :=
+    hasSubst_of_constantCoeff_zero (by intro i; fin_cases i <;> exact c.series_const _ (by simp))
+  have hh := h.subst_left b hb hb0
+  rw [subst_after_mv _ _ (.of_constantCoeff_zero G.zero_constantCoeff) _ hb,
+    MvPowerSeries.subst_comp_subst_apply ha hb] at hh
+  have he : (fun i : Fin 2=>
+      (![c.series.subst (X 0 : MvPowerSeries (Fin 2) K),c.series.subst (X 1)] i).subst b)=X := by
+    funext i; fin_cases i
+    · change (c.series.subst (X 0 : MvPowerSeries (Fin 2) K)).subst b=X 0
+      rw [subst_after_mv _ _ (PowerSeries.HasSubst.X _) _ hb,subst_X hb]
+      exact c.series_inverse _ (PowerSeries.HasSubst.X _)
+    · change (c.series.subst (X 1 : MvPowerSeries (Fin 2) K)).subst b=X 1
+      rw [subst_after_mv _ _ (PowerSeries.HasSubst.X _) _ hb,subst_X hb]
+      exact c.series_inverse _ (PowerSeries.HasSubst.X _)
+  rw [he,subst_self] at hh
+  exact hh
+
+lemma step_improves (F G : FormalGroup K) (n : ℕ) (hn : 2≤n)
+    (h : EqJet n F.toPowerSeries G.toPowerSeries) (a : K)
+    (ha : leading F G n=a • coboundary n) :
+    EqJet (n+1) ((step n hn a).transport G).toPowerSeries F.toPowerSeries := by
+  apply pullback_step_jet
+  change EqJet _ ((stepSeries n a).subst G.toPowerSeries)
+    (F.toPowerSeries.subst ![(stepSeries n a).subst (X 0),(stepSeries n a).subst (X 1)])
+  let b : Fin 2 → MvPowerSeries (Fin 2) K := ![(stepSeries n a).subst (X 0),(stepSeries n a).subst (X 1)]
+  have hb0 : ∀i,(b i).constantCoeff=0 := by
+    intro i; fin_cases i <;> exact (step n hn a).series_const _ (by simp)
+  have hbx : ∀i,EqJet n (b i) (X i) := by
+    intro i; fin_cases i <;> exact step_jet n a _ (by simp)
+  have hinner := law_first_order F n b X hb0 (by simp) hbx
+  rw [subst_self] at hinner
+  have hlin : EqJet 2 G.toPowerSeries (X 0+X 1) := by
+    simpa only [pair_subst_self] using pair_linear G (X 0 : MvPowerSeries (Fin 2) K) (X 1) (by simp) (by simp)
+  have hpow := (hlin.pow_leading G.zero_constantCoeff (by simp) n).mul_left (C a)
+  have hout := (EqJet.refl (n+1) G.toPowerSeries).add hpow
+  rw [←step_subst n a _ G.zero_constantCoeff] at hout
+  have hlead := leading_approx F G n h
+  rw [ha] at hlead
+  intro d hd
+  have hi := hinner d hd
+  have ho := hout d hd
+  have hl := hlead d hd
+  simp only [b,Matrix.cons_val_zero,Matrix.cons_val_one,step_subst n a _ (constantCoeff_X _),
+    add_sub_cancel_left,map_add,map_sub] at hi
+  simp only [coboundary,smul_eq_C_mul,mul_sub,map_sub] at hl
+  simp only [map_add] at ho
+  change coeff d ((stepSeries n a).subst G.toPowerSeries)=coeff d (F.toPowerSeries.subst b)
+  simp only [id_eq] at hi
+  simp only [b,step_subst n a _ (constantCoeff_X _)]
+  linear_combination ho-hi-hl
+
+end HeightThree.HondaCorrection
+
+namespace HeightThree.HondaCorrection
+open MvPowerSeries HeightThree.HondaJets HeightThree.HondaLeading
+open HeightThree.HondaTarget HeightThree.HondaFrobenius HeightThree.HomogeneousCocycle
+open HeightThree.CoordinateTransport HeightThree.DeformationRigidity
+variable {K : Type*} [Field K]
+
+lemma step_commutes (p : ℕ) [hp : Fact p.Prime] [CharP K p]
+    (h n : ℕ) (hn : 0<n) (a : K) (ha : (iterateFrobenius K p h) a=a) :
+    (stepSeries n a).subst (PowerSeries.X^(p^h) : PowerSeries K)=
+      (PowerSeries.X^(p^h) : PowerSeries K).subst (stepSeries n a) := by
+  let : CharP (PowerSeries K) p := charP_of_injective_ringHom PowerSeries.C_injective p
+  have hq : p^h≠0 := pow_ne_zero _ hp.out.ne_zero
+  have hqa : a^(p^h)=a := ha
+  rw [step_subst n a _ (by simp [PowerSeries.X,hp.out.ne_zero]),PowerSeries.subst_pow (.of_constantCoeff_zero (step_zero n hn a))]
+  rw [PowerSeries.subst_X (.of_constantCoeff_zero (step_zero n hn a))]
+  rw [stepSeries,add_pow_char_pow,mul_pow,←map_pow,hqa]
+  change PowerSeries.X^(p^h)+PowerSeries.C a*(PowerSeries.X^(p^h))^n=
+    PowerSeries.X^(p^h)+PowerSeries.C a*(PowerSeries.X^n)^(p^h)
+  simp only [←pow_mul,Nat.mul_comm]
+
+lemma honda_transport (p : ℕ) [hp : Fact p.Prime] [CharP K p]
+    (h n : ℕ) (hn : 2≤n) (a : K) (ha : (iterateFrobenius K p h) a=a)
+    (G : FormalGroup K) (hG : multiplicationSeries G p=PowerSeries.X^(p^h)) :
+    multiplicationSeries ((step n hn a).transport G) p=PowerSeries.X^(p^h) := by
+  let c := step n hn a
+  have hh := coordinate_multiplication G (c.transport G) (c.iso G) p
+  change c.series.subst (multiplicationSeries G p)=(multiplicationSeries (c.transport G) p).subst c.series at hh
+  rw [hG] at hh
+  have he := step_commutes p h n (by omega) a ha
+  rw [show c.series=stepSeries n a from rfl,he] at hh
+  change (PowerSeries.X^(p^h) : PowerSeries K).subst c.series=(multiplicationSeries (c.transport G) p).subst c.series at hh
+  have hz := congrArg (fun f : PowerSeries K=>f.subst c.inverse) hh
+  rw [PowerSeries.subst_comp_subst_apply c.hasSubst c.inv_hasSubst,
+    PowerSeries.subst_comp_subst_apply c.hasSubst c.inv_hasSubst,c.left_inv,
+    PowerSeries.X_subst,PowerSeries.X_subst] at hz
+  exact hz.symm
+
+end HeightThree.HondaCorrection
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/FormalGroup/Honda/Differential.lean b/lean/OAI/Algebra/FormalGroup/Honda/Differential.lean
new file mode 100644
index 0000000000000000000000000000000000000000..705c4fde2a839cc36b65727188bb275f4c9ecd9c
--- /dev/null
+++ b/lean/OAI/Algebra/FormalGroup/Honda/Differential.lean
@@ -0,0 +1,76 @@
+import Mathlib
+
+namespace OAI
+
+noncomputable section
+
+namespace HeightThree.PowerSeriesDifferential
+open MvPowerSeries
+variable {R σ : Type*} [CommRing R]
+
+lemma coeff_pow_zero_of_degree_lt (a : MvPowerSeries σ R) (ha : a.constantCoeff = 0)
+    (d : σ →₀ ℕ) (n : ℕ) (hn : d.degree < n) : coeff d (a^n) = 0 := by
+  apply coeff_of_lt_order
+  exact lt_of_lt_of_le (by exact_mod_cast hn) (le_order_pow_of_constantCoeff_eq_zero n ha)
+
+lemma coeff_subst_eq_of_coeff_le (f g : PowerSeries R) (a : MvPowerSeries σ R)
+    (ha : a.constantCoeff = 0) (d : σ →₀ ℕ)
+    (h : ∀ n ≤ d.degree, f.coeff n = g.coeff n) :
+    coeff d (f.subst a) = coeff d (g.subst a) := by
+  rw [PowerSeries.coeff_subst (PowerSeries.HasSubst.of_constantCoeff_zero ha),
+    PowerSeries.coeff_subst (PowerSeries.HasSubst.of_constantCoeff_zero ha)]
+  apply finsum_congr
+  intro n
+  by_cases hn : n ≤ d.degree
+  · rw [h n hn]
+  · rw [coeff_pow_zero_of_degree_lt a ha d n (by omega), smul_zero, smul_zero]
+
+lemma pderiv_subst_coe (f : Polynomial R) (a : MvPowerSeries σ R)
+    (ha : PowerSeries.HasSubst a) (i : σ) :
+    pderiv i ((f : PowerSeries R).subst a) =
+      ((PowerSeries.derivative (f : PowerSeries R)).subst a) * pderiv i a := by
+  simp [PowerSeries.subst_coe ha, PowerSeries.derivative_coe,
+    Derivation.comp_aeval_eq (a := a) (pderiv i) f, smul_eq_mul]
+
+lemma pderiv_subst (f : PowerSeries R) (a : MvPowerSeries σ R)
+    (ha : a.constantCoeff = 0) (i : σ) :
+    pderiv i (f.subst a) = (PowerSeries.derivative f).subst a * pderiv i a := by
+  classical
+  ext d
+  let N := d.degree + 2
+  let g : Polynomial R := PowerSeries.trunc N f
+  have he (e : σ →₀ ℕ) (he : e.degree < N) :
+      coeff e (f.subst a) = coeff e ((g : PowerSeries R).subst a) := by
+    apply coeff_subst_eq_of_coeff_le _ _ _ ha
+    intro n hn
+    exact (PowerSeries.coeff_coe_trunc_of_lt (by omega : n < N)).symm
+  have he' (e : σ →₀ ℕ) (he : e.degree ≤ d.degree) :
+      coeff e ((PowerSeries.derivative f).subst a) =
+        coeff e ((PowerSeries.derivative (g : PowerSeries R)).subst a) := by
+    apply coeff_subst_eq_of_coeff_le _ _ _ ha
+    intro n hn
+    rw [PowerSeries.coeff_derivative, PowerSeries.coeff_derivative]
+    congr 1
+    exact (PowerSeries.coeff_coe_trunc_of_lt (by omega : n+1 < N)).symm
+  rw [coeff_pderiv, he _ (by simp [N, map_add, Finsupp.degree_single]),
+    ← coeff_pderiv, pderiv_subst_coe g a (PowerSeries.HasSubst.of_constantCoeff_zero ha),
+    coeff_mul, coeff_mul]
+  apply Finset.sum_congr rfl
+  intro ef hef
+  rw [he' ef.1]
+  have heq := Finset.HasAntidiagonal.mem_antidiagonal.mp hef
+  have := congrArg Finsupp.degree heq
+  rw [map_add] at this
+  omega
+
+lemma pderiv_map {S : Type*} [CommRing S] (ρ : R →+* S)
+    (f : MvPowerSeries σ R) (i : σ) :
+    pderiv i (f.map ρ) = (pderiv i f).map ρ := by
+  ext d
+  simp only [coeff_pderiv, coeff_map, map_mul, map_add, map_natCast, map_one]
+
+end HeightThree.PowerSeriesDifferential
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/FormalGroup/Honda/Evaluation.lean b/lean/OAI/Algebra/FormalGroup/Honda/Evaluation.lean
new file mode 100644
index 0000000000000000000000000000000000000000..b894d1711af3376a57c1f41ab12e8bb15e02178b
--- /dev/null
+++ b/lean/OAI/Algebra/FormalGroup/Honda/Evaluation.lean
@@ -0,0 +1,257 @@
+import OAI.Algebra.FormalGroup.Honda.ArtinianRigidity
+
+namespace OAI
+
+noncomputable section
+
+namespace HeightThree.NilpotentEvaluation
+open MvPowerSeries
+variable {K R S : Type*} [CommRing K] [CommRing R] [CommRing S]
+
+def constantHom [Algebra K R] : PowerSeries R →ₐ[K] R where
+  __ := (MvPowerSeries.constantCoeff : PowerSeries R →+* R)
+  commutes' r := by simp [MvPowerSeries.algebraMap_apply]
+
+lemma constantsHasSubst (a : Fin 2 → R) (h : ∀ i, IsNilpotent (a i)) :
+    HasSubst (fun i => (C (a i) : PowerSeries R)) :=
+  hasSubst_of_constantCoeff_nilpotent (fun i => by simpa only [constantCoeff_C] using h i)
+
+def eval [Algebra K R] (a : Fin 2 → R) (h : ∀ i, IsNilpotent (a i)) :
+    MvPowerSeries (Fin 2) K →ₐ[K] R :=
+  constantHom.comp (substAlgHom (constantsHasSubst a h))
+
+@[simp] lemma eval_X [Algebra K R] (a : Fin 2 → R) (h : ∀ i, IsNilpotent (a i)) (i : Fin 2) :
+    eval (K := K) a h (X i) = a i := by
+  change constantCoeff (substAlgHom (constantsHasSubst a h) (X i)) = a i
+  rw [substAlgHom_X,constantCoeff_C]
+
+@[simp] lemma eval_C [Algebra K R] (a : Fin 2 → R) (h : ∀ i, IsNilpotent (a i)) (c : K) :
+    eval a h (C c) = algebraMap K R c := by
+  change eval a h (algebraMap K (MvPowerSeries (Fin 2) K) c) = _
+  exact AlgHom.commutes _ c
+
+lemma degree_two (d : Fin 2 →₀ ℕ) : d.degree = d 0+d 1 := by
+  classical
+  change d.sum (fun _ n => n) = _
+  rw [Finsupp.sum_fintype]
+  · exact Fin.sum_univ_two _
+  · simp
+
+lemma tail_rect (f : MvPowerSeries (Fin 2) K) (N : ℕ) :
+    ∃ g h : MvPowerSeries (Fin 2) K,
+      f-(↑(f.truncTotal (2*N)) : MvPowerSeries (Fin 2) K) = X 0^N*g+X 1^N*h := by
+  classical
+  let t := f-(↑(f.truncTotal (2*N)) : MvPowerSeries (Fin 2) K)
+  let t₀ : MvPowerSeries (Fin 2) K := fun d => if N ≤ d 0 then coeff d t else 0
+  let t₁ := t-t₀
+  have h₀ : X 0^N ∣ t₀ := by
+    apply X_pow_dvd_iff.mpr
+    intro d hd
+    change (if N ≤ d 0 then coeff d t else 0) = 0
+    simp [not_le.mpr hd]
+  have h₁ : X 1^N ∣ t₁ := by
+    apply X_pow_dvd_iff.mpr
+    intro d hd
+    change coeff d t-(if N ≤ d 0 then coeff d t else 0) = 0
+    by_cases hN : N ≤ d 0
+    · simp [hN]
+    · have ht : d.degree < 2*N := by rw [degree_two]; omega
+      simp only [ite_eq_right hN,t,map_sub,MvPolynomial.coeff_coe,coeff_truncTotal _ ht,sub_self]
+  obtain ⟨g,hg⟩ := h₀
+  obtain ⟨h,hh⟩ := h₁
+  refine ⟨g,h,?_⟩
+  rw [←hg,←hh]
+  dsimp [t₁,t]
+  ring
+
+lemma hom_apply_eq_trunc [Algebra K R] (φ : MvPowerSeries (Fin 2) K →ₐ[K] R)
+    (N : ℕ) (hN : ∀ i : Fin 2, φ (X i)^N = 0) (f : MvPowerSeries (Fin 2) K) :
+    φ f = φ (↑(f.truncTotal (2*N)) : MvPowerSeries (Fin 2) K) := by
+  obtain ⟨g,h,he⟩ := tail_rect f N
+  have hh := congrArg φ he
+  simp only [map_sub,map_add,map_mul,map_pow,hN,zero_mul,add_zero] at hh
+  exact sub_eq_zero.mp hh
+
+lemma hom_ext_nilpotent [Algebra K R] (φ ψ : MvPowerSeries (Fin 2) K →ₐ[K] R)
+    (hφ : ∀ i : Fin 2, IsNilpotent (φ (X i))) (he : ∀ i : Fin 2, φ (X i)=ψ (X i)) : φ=ψ := by
+  obtain ⟨a,ha⟩ := hφ 0
+  obtain ⟨b,hb⟩ := hφ 1
+  let N := max a b
+  have hN : ∀ i : Fin 2, φ (X i)^N=0 := by
+    intro i; fin_cases i
+    · exact pow_eq_zero_of_le (le_max_left _ _) ha
+    · exact pow_eq_zero_of_le (le_max_right _ _) hb
+  have hN' : ∀ i : Fin 2, ψ (X i)^N=0 := by simpa only [he] using hN
+  have hpoly : ∀ f : MvPolynomial (Fin 2) K,
+      φ (f : MvPowerSeries (Fin 2) K) = ψ (f : MvPowerSeries (Fin 2) K) := by
+    intro f
+    induction f using MvPolynomial.induction_on with
+    | C c => simpa only [MvPolynomial.coe_C,MvPowerSeries.c_eq_algebraMap] using
+        (φ.commutes c).trans (ψ.commutes c).symm
+    | add f g hf hg => simp only [MvPolynomial.coe_add,map_add,hf,hg]
+    | mul_X f i hf => simp only [MvPolynomial.coe_mul,MvPolynomial.coe_X,map_mul,hf,he]
+  ext f
+  rw [hom_apply_eq_trunc φ N hN f, hom_apply_eq_trunc ψ N hN' f]
+  exact hpoly _
+
+lemma eval_natural [Algebra K R] [Algebra K S] (π : R →ₐ[K] S)
+    (a : Fin 2 → R) (h : ∀ i, IsNilpotent (a i)) :
+    π.comp (eval a h) = eval (fun i => π (a i)) (fun i => (h i).map π.toRingHom) := by
+  apply hom_ext_nilpotent
+  · intro i; simpa using (h i).map π.toRingHom
+  · intro i; simp
+
+lemma eval_zero [Algebra K R] (h : ∀ _ : Fin 2, IsNilpotent (0 : R)) (f : MvPowerSeries (Fin 2) K) :
+    eval (fun _ => (0 : R)) h f = algebraMap K R (constantCoeff f) := by
+  let ψ : MvPowerSeries (Fin 2) K →ₐ[K] R :=
+    { __ := (algebraMap K R).comp constantCoeff
+      commutes' := by intro r; simp [MvPowerSeries.algebraMap_apply] }
+  have he : eval (fun _ => (0 : R)) h = ψ := by
+    apply hom_ext_nilpotent
+    · intro i; simp
+    · intro i; simp [ψ]
+  exact congrArg (fun φ : MvPowerSeries (Fin 2) K →ₐ[K] R => φ f) he
+
+lemma linear_coeff_mul_X (f : MvPowerSeries (Fin 2) K) (i j : Fin 2) :
+    coeff (Finsupp.single j 1) (f * X i) = if i=j then constantCoeff f else 0 := by
+  classical
+  by_cases hij : i=j
+  · subst j; simp [X,coeff_mul_monomial]
+  · have hn : ¬Finsupp.single i 1 ≤ (Finsupp.single j 1 : Fin 2 →₀ ℕ) := by
+      intro h
+      have hi := h i
+      simp [hij] at hi
+    simp [X,coeff_mul_monomial,hn,hij]
+
+theorem hom_difference_small [Algebra K R] (π : R →+* S) (ρ : R →ₐ[K] K)
+    (ann : ∀ a b, π a=0 → ρ b=0 → a*b=0)
+    (φ ψ : MvPowerSeries (Fin 2) K →ₐ[K] R)
+    (hπ : ∀ f, π (φ f)=π (ψ f))
+    (hφ : ∀ f, ρ (φ f)=constantCoeff f)
+    (hψ : ∀ f, ρ (ψ f)=constantCoeff f)
+    (hnil : ∀ i : Fin 2, IsNilpotent (φ (X i)))
+    (f : MvPowerSeries (Fin 2) K) :
+    φ f-ψ f = (φ (X 0)-ψ (X 0))*algebraMap K R (coeff (Finsupp.single 0 1) f) +
+      (φ (X 1)-ψ (X 1))*algebraMap K R (coeff (Finsupp.single 1 1) f) := by
+  classical
+  have poly : ∀ f : MvPolynomial (Fin 2) K,
+      φ (f : MvPowerSeries (Fin 2) K)-ψ (f : MvPowerSeries (Fin 2) K) =
+      (φ (X 0)-ψ (X 0))*algebraMap K R (coeff (Finsupp.single 0 1) (f : MvPowerSeries (Fin 2) K)) +
+      (φ (X 1)-ψ (X 1))*algebraMap K R (coeff (Finsupp.single 1 1) (f : MvPowerSeries (Fin 2) K)) := by
+    intro f
+    induction f using MvPolynomial.induction_on with
+    | C c =>
+      simp only [MvPolynomial.coe_C]
+      rw [show φ (C c)=algebraMap K R c from φ.commutes c,
+        show ψ (C c)=algebraMap K R c from ψ.commutes c]
+      simp [coeff_C]
+    | add f g hf hg =>
+      simp only [MvPolynomial.coe_add,map_add] at *
+      linear_combination hf+hg
+    | mul_X f i hf =>
+      let F : MvPowerSeries (Fin 2) K := f
+      have hz₁ : (φ F-ψ F)*φ (X i)=0 :=
+        ann _ _ (by simp only [map_sub,hπ,sub_self]) (by rw [hφ,constantCoeff_X])
+      have hz₂ : (φ (X i)-ψ (X i))*(ψ F-algebraMap K R (constantCoeff F))=0 :=
+        ann _ _ (by simp only [map_sub,hπ,sub_self]) (by simp [hψ])
+      have he : φ (F*X i)-ψ (F*X i) =
+          (φ (X i)-ψ (X i))*algebraMap K R (constantCoeff F) := by
+        simp only [map_mul]
+        linear_combination hz₁+hz₂
+      simp only [MvPolynomial.coe_mul,MvPolynomial.coe_X]
+      change φ (F*X i)-ψ (F*X i) = _
+      rw [he]
+      change _ = (φ (X 0)-ψ (X 0))*algebraMap K R (coeff (Finsupp.single 0 1) (F*X i)) +
+        (φ (X 1)-ψ (X 1))*algebraMap K R (coeff (Finsupp.single 1 1) (F*X i))
+      rw [linear_coeff_mul_X,linear_coeff_mul_X]
+      fin_cases i <;> simp
+
+  have hnil' : ∀ i : Fin 2, IsNilpotent (ψ (X i)) := by
+    intro i
+    have hd : π (φ (X i)-ψ (X i))=0 := by simp only [map_sub,hπ,sub_self]
+    have hz : (φ (X i)-ψ (X i))^2=0 := by
+      rw [pow_two]; exact ann _ _ hd (by rw [map_sub,hφ,hψ,sub_self])
+    have hh := (Commute.all _ _).isNilpotent_sub (hnil i) (show IsNilpotent (φ (X i)-ψ (X i)) from ⟨2,hz⟩)
+    simpa only [sub_sub_cancel] using hh
+  obtain ⟨a,ha⟩ := hnil 0
+  obtain ⟨b,hb⟩ := hnil 1
+  obtain ⟨c,hc⟩ := hnil' 0
+  obtain ⟨d,hd⟩ := hnil' 1
+  let N := max (max a b) (max c d)+1
+  have hN : ∀ i : Fin 2, φ (X i)^N=0 := by
+    intro i; fin_cases i
+    · exact pow_eq_zero_of_le (by dsimp [N]; omega) ha
+    · exact pow_eq_zero_of_le (by dsimp [N]; omega) hb
+  have hN' : ∀ i : Fin 2, ψ (X i)^N=0 := by
+    intro i; fin_cases i
+    · exact pow_eq_zero_of_le (by dsimp [N]; omega) hc
+    · exact pow_eq_zero_of_le (by dsimp [N]; omega) hd
+  rw [hom_apply_eq_trunc φ N hN f,hom_apply_eq_trunc ψ N hN' f,poly]
+  simp only [MvPolynomial.coeff_coe,coeff_truncTotal _ (show (Finsupp.single (0 : Fin 2) 1).degree < 2*N by simp; dsimp [N]; omega),
+    coeff_truncTotal _ (show (Finsupp.single (1 : Fin 2) 1).degree < 2*N by simp; dsimp [N]; omega)]
+
+lemma eval_augmentation [Algebra K R] (ρ : R →ₐ[K] K)
+    (a : Fin 2 → R) (h : ∀ i, IsNilpotent (a i)) (ha : ∀ i, ρ (a i)=0)
+    (f : MvPowerSeries (Fin 2) K) : ρ (eval a h f)=constantCoeff f := by
+  let ε : MvPowerSeries (Fin 2) K →ₐ[K] K :=
+    { __ := constantCoeff
+      commutes' := by intro r; simp [MvPowerSeries.algebraMap_apply] }
+  have he : ρ.comp (eval a h)=ε := by
+    apply hom_ext_nilpotent
+    · intro i; simpa using (h i).map ρ.toRingHom
+    · intro i; simp [ε,ha]
+  exact congrArg (fun φ : MvPowerSeries (Fin 2) K →ₐ[K] K => φ f) he
+
+theorem correct_parameters [Algebra K R] [Algebra K S]
+    (π : R →ₐ[K] S) (ρ : R →ₐ[K] K)
+    (kle : ∀ a, π a=0 → ρ a=0)
+    (ann : ∀ a b, π a=0 → ρ b=0 → a*b=0)
+    (φ : MvPowerSeries (Fin 2) K →ₐ[K] R)
+    (hφ : ∀ f, ρ (φ f)=constantCoeff f)
+    (hnil : ∀ i : Fin 2, IsNilpotent (φ (X i)))
+    (c g : MvPowerSeries (Fin 2) K) (hc : c=X 1+X 0*g)
+    (b₀ b₁ : R) (hb₀ : π b₀=π (φ (X 0))) (hb₁ : π b₁=π (φ c)) :
+    ∃ ψ : MvPowerSeries (Fin 2) K →ₐ[K] R,
+      π.comp ψ=π.comp φ ∧ (∀ f, ρ (ψ f)=constantCoeff f) ∧ ψ (X 0)=b₀ ∧ ψ c=b₁ := by
+  let d₀ := b₀-φ (X 0)
+  let d₁ := b₁-φ c-d₀*algebraMap K R (constantCoeff g)
+  have hd₀ : π d₀=0 := by simp [d₀,hb₀]
+  have hd₁ : π d₁=0 := by simp [d₁,hb₁,hd₀]
+  have hdnil₀ : IsNilpotent d₀ := ⟨2,by rw [pow_two]; exact ann _ _ hd₀ (kle _ hd₀)⟩
+  have hdnil₁ : IsNilpotent d₁ := ⟨2,by rw [pow_two]; exact ann _ _ hd₁ (kle _ hd₁)⟩
+  let a : Fin 2 → R := ![φ (X 0)+d₀,φ (X 1)+d₁]
+  have hanil : ∀ i, IsNilpotent (a i) := by
+    intro i; fin_cases i
+    · exact (Commute.all _ _).isNilpotent_add (hnil 0) hdnil₀
+    · exact (Commute.all _ _).isNilpotent_add (hnil 1) hdnil₁
+  let ψ : MvPowerSeries (Fin 2) K →ₐ[K] R := eval a hanil
+  have hψπ : π.comp ψ=π.comp φ := by
+    apply hom_ext_nilpotent
+    · intro i; simpa [ψ] using (hanil i).map π.toRingHom
+    · intro i; fin_cases i <;> simp [ψ,a,hd₀,hd₁]
+  have hψρ : ∀ f, ρ (ψ f)=constantCoeff f := by
+    apply eval_augmentation ρ a hanil
+    intro i; fin_cases i <;> simp [a,hφ,kle _ hd₀,kle _ hd₁]
+  have hlin₀ : coeff (Finsupp.single 0 1) c=constantCoeff g := by
+    rw [hc,mul_comm (X 0) g,map_add,linear_coeff_mul_X]
+    simp [coeff_index_single_X]
+  have hlin₁ : coeff (Finsupp.single 1 1) c=1 := by
+    rw [hc,mul_comm (X 0) g,map_add,linear_coeff_mul_X]
+    simp
+  have he := hom_difference_small π.toRingHom ρ ann ψ φ
+    (fun f => congrArg (fun η : MvPowerSeries (Fin 2) K →ₐ[K] S => η f) hψπ)
+    hψρ hφ (by intro i; simpa [ψ] using hanil i) c
+  rw [hlin₀,hlin₁,map_one,mul_one] at he
+  have hx₀ : ψ (X 0)-φ (X 0)=d₀ := by simp [ψ,a]
+  have hx₁ : ψ (X 1)-φ (X 1)=d₁ := by simp [ψ,a]
+  rw [hx₀,hx₁] at he
+  refine ⟨ψ,hψπ,hψρ,?_,?_⟩
+  · simp [ψ,a,d₀]
+  · dsimp [d₁] at he
+    linear_combination he
+
+end HeightThree.NilpotentEvaluation
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/FormalGroup/Honda/Frobenius.lean b/lean/OAI/Algebra/FormalGroup/Honda/Frobenius.lean
new file mode 100644
index 0000000000000000000000000000000000000000..ee132366d231333d3c24d14134eff39d6830703e
--- /dev/null
+++ b/lean/OAI/Algebra/FormalGroup/Honda/Frobenius.lean
@@ -0,0 +1,112 @@
+import OAI.Algebra.FormalGroup.Honda.Leading
+
+namespace OAI
+
+noncomputable section
+
+namespace HeightThree.HondaFrobenius
+open MvPowerSeries HeightThree.HondaLeading HeightThree.HondaTarget
+open HeightThree.HondaJets HeightThree.HomogeneousCocycle
+variable {K σ : Type*} [Field K]
+
+lemma law_pair_subst (F : FormalGroup K) (a b : PowerSeries K) (c : MvPowerSeries σ K)
+    (ha : a.constantCoeff=0) (hb : b.constantCoeff=0) (hc : PowerSeries.HasSubst c) :
+    PowerSeries.subst c (pair F a b) = pair F (a.subst c) (b.subst c) := by
+  have hab : MvPowerSeries.HasSubst ![a,b] :=
+    hasSubst_of_constantCoeff_zero (by intro i; fin_cases i <;> assumption)
+  change (F.toPowerSeries.subst ![a,b]).subst (fun _ : Unit => c) = _
+  rw [MvPowerSeries.subst_comp_subst_apply hab hc.const]
+  congr 1
+  funext i; fin_cases i <;> rfl
+
+lemma point_multiplication (F : FormalGroup K) (a : F.Point σ) (ha : a.val.constantCoeff=0) (n : ℕ) :
+    (n • a).val = (multiplicationSeries F n).subst a.val := by
+  induction n with
+  | zero =>
+    change 0=PowerSeries.subst a.val 0
+    rw [←PowerSeries.coe_substAlgHom (PowerSeries.HasSubst.of_constantCoeff_zero ha),map_zero]
+  | succ n ih =>
+    rw [succ_nsmul,FormalGroup.add_apply,ih,multiplication_succ,
+      law_pair_subst F _ _ _ (multiplication_constant F n) PowerSeries.constantCoeff_X a.prop,
+      PowerSeries.subst_X a.prop]
+
+lemma multiplication_add (F : FormalGroup K) [F.IsComm] (n : ℕ) :
+    (multiplicationSeries F n).subst F.toPowerSeries =
+      F.toPowerSeries.subst ![(multiplicationSeries F n).subst (X 0),
+        (multiplicationSeries F n).subst (X 1)] := by
+  let a : F.Point (Fin 2) := ⟨X 0,PowerSeries.HasSubst.X 0⟩
+  let b : F.Point (Fin 2) := ⟨X 1,PowerSeries.HasSubst.X 1⟩
+  have ha : a.val.constantCoeff=0 := by simp [a]
+  have hb : b.val.constantCoeff=0 := by simp [b]
+  have he : (a+b).val=F.toPowerSeries := by
+    change F.toPowerSeries.subst ![X 0,X 1]=_
+    exact pair_subst_self _
+  have hh := congrArg Subtype.val (nsmul_add a b n)
+  rw [point_multiplication F (a+b) (pair_const F _ _ ha hb) n,he] at hh
+  rw [FormalGroup.add_apply,point_multiplication F a ha n,point_multiplication F b hb n] at hh
+  exact hh
+
+lemma Xpow_subst (q : ℕ) (a : MvPowerSeries σ K) (ha : a.constantCoeff=0) :
+    (PowerSeries.X^q : PowerSeries K).subst a=a^q := by
+  rw [PowerSeries.subst_pow (.of_constantCoeff_zero ha),
+    PowerSeries.subst_X (.of_constantCoeff_zero ha)]
+
+lemma honda_expand (p q : ℕ) (hq : q≠0) (F : FormalGroup K) [F.IsComm]
+    (hF : multiplicationSeries F p=PowerSeries.X^q) :
+    F.toPowerSeries^q=F.toPowerSeries.expand q hq := by
+  have hh := multiplication_add F p
+  rw [hF,Xpow_subst q _ F.zero_constantCoeff,Xpow_subst q _ (constantCoeff_X 0),
+    Xpow_subst q _ (constantCoeff_X 1)] at hh
+  rw [MvPowerSeries.expand,MvPowerSeries.coe_substAlgHom]
+  convert hh using 2
+  funext i; fin_cases i <;> rfl
+
+theorem honda_coefficients_fixed (p : ℕ) [hp : Fact p.Prime] [CharP K p]
+    (h : ℕ) (F : FormalGroup K) [F.IsComm]
+    (hF : multiplicationSeries F p=PowerSeries.X^(p^h)) :
+    F.toPowerSeries.map (iterateFrobenius K p h)=F.toPowerSeries := by
+  have hq : p^h≠0 := pow_ne_zero _ hp.out.ne_zero
+  apply expand_injective (p^h) hq
+  rw [←map_expand,MvPowerSeries.map_iterateFrobenius_expand p hp.out.ne_zero]
+  exact honda_expand p (p^h) hq F hF
+
+lemma map_leading (F G : FormalGroup K) (n : ℕ) (φ : K →+* K)
+    (hF : F.toPowerSeries.map φ=F.toPowerSeries) (hG : G.toPowerSeries.map φ=G.toPowerSeries) :
+    (leading F G n).map φ=leading F G n := by
+  have he : (F.toPowerSeries-G.toPowerSeries).map φ=F.toPowerSeries-G.toPowerSeries := by
+    rw [map_sub,hF,hG]
+  ext d
+  rw [coeff_map,coeff_homogeneousComponent]
+  split_ifs with hd
+  · exact congrArg (coeff d) he
+  · exact map_zero _
+
+lemma coboundary_fixed (n : ℕ) (φ : K →+* K) :
+    (coboundary (K:=K) n).map φ=coboundary n := by
+  simp [coboundary]
+
+lemma fixed_coboundary_scalar (p : ℕ) [hp : Fact p.Prime] [CharP K p]
+    (D : MvPowerSeries (Fin 2) K) (n : ℕ) (hn : 0<n)
+    (hC : IsCocycle p D) (hH : D.IsHomogeneous n) (φ : K →+* K)
+    (hD : D.map φ=D) : ∃a : K, φ a=a ∧ D=a • coboundary n := by
+  obtain ⟨a,ha⟩ := cocycle_is_coboundary p n hn D hC hH
+  by_cases he : coboundary (K:=K) n=0
+  · refine ⟨0,map_zero _,?_⟩
+    rw [ha,he,smul_zero,smul_zero]
+  · obtain ⟨d,hd⟩ : ∃d,coeff d (coboundary (K:=K) n)≠0 := by
+      by_contra hh
+      apply he
+      ext d
+      have h0 : coeff d (coboundary (K:=K) n)=0 := not_not.mp (not_exists.mp hh d)
+      simpa using h0
+    have hc : φ (coeff d (coboundary (K:=K) n))=coeff d (coboundary (K:=K) n) :=
+      congrArg (coeff d) (coboundary_fixed n φ)
+    have hh := congrArg (coeff d) hD
+    simp only [coeff_map,ha,map_smul,smul_eq_mul,map_mul,hc] at hh
+    exact ⟨(a), (mul_right_cancel₀ hd hh), ha⟩
+
+end HeightThree.HondaFrobenius
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/FormalGroup/Honda/HeightTransport.lean b/lean/OAI/Algebra/FormalGroup/Honda/HeightTransport.lean
new file mode 100644
index 0000000000000000000000000000000000000000..1639ca5071d350d6d67ab384452c15546769e06a
--- /dev/null
+++ b/lean/OAI/Algebra/FormalGroup/Honda/HeightTransport.lean
@@ -0,0 +1,160 @@
+import OAI.Algebra.FormalGroup.Honda.UniversalTransport
+
+namespace OAI
+
+noncomputable section
+
+namespace HeightThree.HeightTransport
+open MvPowerSeries HeightThree.HondaTarget HeightThree.CoordinateTransport
+open HeightThree.HondaJets HeightThree.DeformationRigidity
+variable {R S : Type*} [CommRing R] [CommRing S]
+
+lemma strict_jet (f : PowerSeries R) (h0 : f.constantCoeff=0) (h1 : f.coeff 1=1) :
+    EqJet 2 f PowerSeries.X := by
+  intro d hd
+  have he : d=Finsupp.single () (d ()) := Finsupp.unique_single d
+  rw [he] at hd ⊢
+  simp only [Finsupp.degree_single] at hd
+  have hj : d ()=0 ∨ d ()=1 := by omega
+  rcases hj with hj | hj
+  · rw [hj]; change PowerSeries.coeff 0 f=PowerSeries.coeff 0 PowerSeries.X
+    simpa using h0
+  · rw [hj]; change PowerSeries.coeff 1 f=PowerSeries.coeff 1 PowerSeries.X
+    simpa using h1
+
+lemma strict_inverse (c : Coordinate R) (hc : c.series.coeff 1=1) :
+    c.inverse.coeff 1=1 := by
+  simpa [hc] using c.linear_inverse
+
+lemma homogeneous_uni (f : PowerSeries R) (n : ℕ) :
+    (f : MvPowerSeries Unit R).homogeneousComponent n=
+      PowerSeries.C (f.coeff n)*PowerSeries.X^n := by
+  apply PowerSeries.ext
+  intro j
+  change coeff (Finsupp.single () j) (f.homogeneousComponent n)=_
+  rw [coeff_homogeneousComponent]
+  simp only [Finsupp.degree_single]
+  change (if j=n then f.coeff j else 0)=_
+  rw [PowerSeries.coeff_C_mul,PowerSeries.coeff_X_pow]
+  by_cases hj : j=n
+  · subst j; simp
+  · simp [hj]
+
+lemma strict_subst_leading (P u : PowerSeries R) (n : ℕ)
+    (hP : EqJet n P 0) (hu0 : u.constantCoeff=0) (hu1 : u.coeff 1=1) :
+    EqJet (n+1) (P.subst u) P := by
+  have hlead := leading_part P n hP
+  rw [homogeneous_uni] at hlead
+  have hs := hlead.subst_left (fun _ : Unit=>u)
+    (PowerSeries.HasSubst.of_constantCoeff_zero hu0).const (fun _=>hu0)
+  change EqJet (n+1) (P.subst u) ((PowerSeries.C (P.coeff n)*PowerSeries.X^n).subst u) at hs
+  rw [PowerSeries.subst_mul (.of_constantCoeff_zero hu0),
+    PowerSeries.subst_C,
+    PowerSeries.subst_pow (.of_constantCoeff_zero hu0),
+    PowerSeries.subst_X (.of_constantCoeff_zero hu0)] at hs
+  have hp := (strict_jet u hu0 hu1).pow_leading hu0 (by simp [PowerSeries.X]) n
+  have hh := hp.mul_left (PowerSeries.C (P.coeff n))
+  exact (hs.trans hh).trans hlead.symm
+
+lemma strict_outer_leading (P u : PowerSeries R) (n : ℕ)
+    (hP : EqJet n P 0) (hP0 : P.constantCoeff=0)
+    (hu0 : u.constantCoeff=0) (hu1 : u.coeff 1=1) :
+    EqJet (n+1) (u.subst P) P := by
+  have hh := subst_first_order u n (fun _ : Unit=>P) (fun _ : Unit=>(0 : PowerSeries R))
+    (fun _=>hP0) (by simp) (fun _=>hP)
+  have hzero : u.subst (0 : PowerSeries R)=0 := by
+    exact PowerSeries.subst_zero_of_constantCoeff_zero hu0
+  change EqJet (n+1) (u.subst P-u.subst (0 : PowerSeries R))
+    (∑i : Unit, C (coeff (Finsupp.single i 1) u)*(P-0)) at hh
+  simpa only [hzero,sub_zero,Fintype.sum_unique,show coeff (Finsupp.single () 1) u=1 from hu1,
+    map_one,one_mul] using hh
+
+lemma multiplication_transport (c : Coordinate R) (F : FormalGroup R) (n : ℕ) :
+    multiplicationSeries (c.transport F) n=
+      c.series.subst ((multiplicationSeries F n).subst c.inverse) := by
+  have hh := coordinate_multiplication F (c.transport F) (c.iso F) n
+  change c.series.subst (multiplicationSeries F n)=
+    (multiplicationSeries (c.transport F) n).subst c.series at hh
+  have hh' := congrArg (fun z : PowerSeries R=>z.subst c.inverse) hh
+  rw [PowerSeries.subst_comp_subst_apply (.of_constantCoeff_zero (multiplication_constant F n)) c.inv_hasSubst,
+    PowerSeries.subst_comp_subst_apply c.hasSubst c.inv_hasSubst,c.left_inv,
+    PowerSeries.X_subst] at hh'
+  exact hh'.symm
+
+lemma conjugate_leading (c : Coordinate R) (hc : c.series.coeff 1=1)
+    (P : PowerSeries R) (n : ℕ) (hP0 : P.constantCoeff=0) (hP : EqJet n P 0) :
+    EqJet (n+1) (c.series.subst (P.subst c.inverse)) P := by
+  have he := strict_subst_leading P c.inverse n hP c.zero_inverse (strict_inverse c hc)
+  have hz : (P.subst c.inverse).constantCoeff=0 :=
+    PowerSeries.constantCoeff_subst_eq_zero c.zero_inverse P hP0
+  have hh := strict_outer_leading (P.subst c.inverse) c.series n
+    ((he.mono (by omega)).trans hP) hz c.zero_series hc
+  exact hh.trans he
+
+end HeightThree.HeightTransport
+
+namespace HeightThree.HeightTransport
+open MvPowerSeries HeightThree.HondaTarget HeightThree.CoordinateTransport
+open HeightThree.HondaJets HeightThree.DeformationRigidity
+variable {R S : Type*} [CommRing R] [CommRing S]
+
+lemma jet_zero_of_coeff (P : PowerSeries R) (n : ℕ) (hP : ∀j<n,P.coeff j=0) :
+    EqJet n P 0 := by
+  intro d hd
+  rw [Finsupp.unique_single d] at hd ⊢
+  simp only [Finsupp.degree_single] at hd
+  change PowerSeries.coeff (d ()) P=0
+  exact hP (d ()) hd
+
+lemma low_leading_transport (c : Coordinate R) (hc : c.series.coeff 1=1)
+    (F : FormalGroup R) (q n : ℕ) (hlow : ∀j<n,(multiplicationSeries F q).coeff j=0) :
+    (∀j<n,(multiplicationSeries (c.transport F) q).coeff j=0) ∧
+    (multiplicationSeries (c.transport F) q).coeff n=(multiplicationSeries F q).coeff n := by
+  have hh := conjugate_leading c hc (multiplicationSeries F q) n (multiplication_constant F q)
+    (jet_zero_of_coeff _ n hlow)
+  rw [←multiplication_transport] at hh
+  constructor
+  · intro j hj
+    have he := hh (Finsupp.single () j) (by simpa using (show j<n+1 by omega))
+    exact he.trans (hlow j hj)
+  · exact hh (Finsupp.single () n) (by simp)
+
+lemma strict_map (c : Coordinate R) (hc : c.series.coeff 1=1) (π : R →+* S) :
+    (c.map π).series.coeff 1=1 := by
+  change π (c.series.coeff 1)=1
+  rw [hc,map_one]
+
+lemma heightCoordinates_transport {K : Type*} [CommRing K] (p : ℕ)
+    (G : FormalGroup (Base K)) (hg : HeightCoordinates p G)
+    (c : Coordinate (Base K)) (hc : c.series.coeff 1=1) :
+    HeightCoordinates p (c.transport G) := by
+  let I : Ideal (Base K) := Ideal.span ({X 0} : Set (Base K))
+  let π := Ideal.Quotient.mk I
+  have h₁ := low_leading_transport c hc G p p hg.1
+  have hlow : ∀j<p^2,(multiplicationSeries (G.map π) p).coeff j=0 := by
+    intro j hj
+    rw [multiplication_map]
+    change π ((multiplicationSeries G p).coeff j)=0
+    exact Ideal.Quotient.eq_zero_iff_mem.mpr (hg.2.2.1 j hj)
+  have h₂ := low_leading_transport (c.map π) (strict_map c hc π) (G.map π) p (p^2) hlow
+  have hmap : (c.map π).transport (G.map π)=(c.transport G).map π :=
+    (c.transport_map G π).symm
+  rw [hmap,multiplication_map] at h₂
+  refine ⟨h₁.1,h₁.2.trans hg.2.1,?_,?_⟩
+  · intro j hj
+    apply Ideal.Quotient.eq_zero_iff_mem.mp
+    exact h₂.1 j hj
+  · apply Ideal.Quotient.eq_zero_iff_mem.mp
+    change π ((multiplicationSeries (c.transport G) p).coeff (p^2)-X 1)=0
+    rw [map_sub]
+    have he : π ((multiplicationSeries (c.transport G) p).coeff (p^2))=
+        π ((multiplicationSeries G p).coeff (p^2)) := by
+      simpa only [multiplication_map,PowerSeries.coeff_map] using h₂.2
+    rw [he,←map_sub]
+    exact Ideal.Quotient.eq_zero_iff_mem.mpr hg.2.2.2
+
+end HeightThree.HeightTransport
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/FormalGroup/Honda/HeightTwo.lean b/lean/OAI/Algebra/FormalGroup/Honda/HeightTwo.lean
new file mode 100644
index 0000000000000000000000000000000000000000..134ec137fd9ac0f6a9ef5dfa495f3c2333da3e6e
--- /dev/null
+++ b/lean/OAI/Algebra/FormalGroup/Honda/HeightTwo.lean
@@ -0,0 +1,231 @@
+import OAI.Algebra.FormalGroup.Honda.Coordinates
+
+namespace OAI
+
+noncomputable section
+
+namespace HeightThree.HondaCoordinates
+open MvPowerSeries HondaConstruction HondaTarget LogarithmicConstruction PTypical
+variable {R S : Type*} [CommRing R] [CommRing S]
+
+def killFirstFun (f : MvPowerSeries (Fin 2) R) : MvPowerSeries (Fin 2) R :=
+  fun d => if d 0 = 0 then coeff d f else 0
+
+@[simp] lemma coeff_killFirstFun (f : MvPowerSeries (Fin 2) R) (d : Fin 2 →₀ ℕ) :
+    coeff d (killFirstFun f) = if d 0 = 0 then coeff d f else 0 := rfl
+
+def killFirst : MvPowerSeries (Fin 2) R →ₐ[R] MvPowerSeries (Fin 2) R where
+  toFun := killFirstFun
+  map_one' := by
+    ext d
+    change (if d 0 = 0 then coeff d (1 : MvPowerSeries (Fin 2) R) else 0) = _
+    by_cases h : d 0 = 0
+    · simp [h]
+    · have hd : d ≠ 0 := by intro he; simp [he] at h
+      simp [h, hd, coeff_one]
+  map_mul' f g := by
+    let : DecidableEq (Fin 2) := Classical.decEq _
+    ext d
+    change (if d 0 = 0 then coeff d (f*g) else 0) = _
+    rw [coeff_mul]
+    by_cases hd : d 0 = 0
+    · rw [ite_eq_left hd, coeff_mul]
+      apply Finset.sum_congr rfl
+      rintro ⟨a,b⟩ hab
+      have hab' := congrArg (fun x : Fin 2 →₀ ℕ => x 0) (Finset.HasAntidiagonal.mem_antidiagonal.mp hab)
+      have ha : a 0 = 0 := by simp only [Finsupp.add_apply] at hab'; omega
+      have hb : b 0 = 0 := by simp only [Finsupp.add_apply] at hab'; omega
+      simp only [coeff_killFirstFun, ha, hb, ite_true]
+    · rw [ite_eq_right hd]
+      symm
+      apply Finset.sum_eq_zero
+      rintro ⟨a,b⟩ hab
+      have hab' := congrArg (fun x : Fin 2 →₀ ℕ => x 0) (Finset.HasAntidiagonal.mem_antidiagonal.mp hab)
+      change (if a 0 = 0 then coeff a f else 0) *
+        (if b 0 = 0 then coeff b g else 0) = 0
+      by_cases ha : a 0 = 0
+      · have hb : b 0 ≠ 0 := by simp only [Finsupp.add_apply] at hab'; omega
+        simp [hb]
+      · simp [ha]
+  map_zero' := by ext d; simp
+  map_add' f g := by
+    ext d
+    change (if d 0 = 0 then coeff d (f+g) else 0) = _
+    rw [map_add]
+    by_cases h : d 0 = 0 <;> simp [h]
+  commutes' r := by
+    ext d
+    change (if d 0 = 0 then coeff d (C r : MvPowerSeries (Fin 2) R) else 0) = coeff d (C r)
+    by_cases h : d 0 = 0
+    · simp [h]
+    · have hd : d ≠ 0 := by intro he; simp [he] at h
+      simp [h, hd, coeff_C]
+
+@[simp] lemma coeff_killFirst (f : MvPowerSeries (Fin 2) R) (d : Fin 2 →₀ ℕ) :
+    coeff d (killFirst f) = if d 0 = 0 then coeff d f else 0 := rfl
+
+@[simp] lemma killFirst_X_zero : killFirst (X 0 : MvPowerSeries (Fin 2) R) = 0 := by
+  ext d
+  rw [coeff_killFirst]
+  by_cases h : d 0 = 0
+  · have hd : d ≠ Finsupp.single 0 1 := by intro he; simp [he] at h
+    simp [h, coeff_X, hd]
+  · simp [h]
+
+@[simp] lemma killFirst_X_one : killFirst (X 1 : MvPowerSeries (Fin 2) R) = X 1 := by
+  ext d
+  rw [coeff_killFirst]
+  by_cases h : d 0 = 0
+  · simp [h]
+  · have hd : d ≠ Finsupp.single 1 1 := by intro he; simp [he] at h
+    simp [h, coeff_X, hd]
+
+lemma killFirst_eq_zero_iff (f : MvPowerSeries (Fin 2) R) :
+    killFirst f = 0 ↔ f ∈ Ideal.span ({X 0} : Set (MvPowerSeries (Fin 2) R)) := by
+  rw [Ideal.mem_span_singleton, X_dvd_iff]
+  constructor
+  · intro h d hd
+    have hc := congrArg (coeff d) h
+    simpa [hd] using hc
+  · intro h
+    ext d
+    by_cases hd : d 0 = 0 <;> simp [hd, h]
+
+lemma map_killFirst (φ : R →+* S) (f : MvPowerSeries (Fin 2) R) :
+    (killFirst f).map φ = killFirst (f.map φ) := by
+  ext d
+  simp only [coeff_map, coeff_killFirst]
+  split_ifs <;> simp
+
+lemma expand_killFirst (p : ℕ) (hp : p ≠ 0) (f : MvPowerSeries (Fin 2) R) :
+    expand p hp (killFirst f) = killFirst (expand p hp f) := by
+  ext d
+  by_cases hd : ∃ e : Fin 2 →₀ ℕ, p • e = d
+  · obtain ⟨e, rfl⟩ := hd
+    rw [coeff_expand_smul, coeff_killFirst, coeff_killFirst, coeff_expand_smul]
+    congr 1
+    simp [Finsupp.smul_apply, smul_eq_mul, hp]
+  · have hz (g : MvPowerSeries (Fin 2) R) : coeff d (expand p hp g) = 0 := by
+      by_contra h
+      have hh := support_expand_subset p hp g h
+      exact hd ⟨hh.choose, hh.choose_spec.2⟩
+    rw [hz, coeff_killFirst, hz]
+    split_ifs <;> rfl
+
+end HeightThree.HondaCoordinates
+
+namespace HeightThree.HondaCoordinates
+open MvPowerSeries HondaConstruction HondaTarget LogarithmicConstruction PTypical
+variable {A B C D : Type*} [CommRing A] [CommRing B] [CommRing C] [CommRing D]
+
+lemma formalGroup_map_map (F : FormalGroup A) (α : A →+* B) (β : B →+* C) :
+    (F.map α).map β = F.map (β.comp α) := by
+  apply FormalGroup.ext
+  rfl
+
+lemma formalGroup_map_injective (α : A →+* B) (hα : Function.Injective α) :
+    Function.Injective (FormalGroup.map · α) := by
+  intro F G h
+  apply FormalGroup.ext
+  apply map_injective α hα
+  exact congrArg FormalGroup.toPowerSeries h
+
+lemma integralFormalGroup_natural [Algebra ℚ B] [Algebra ℚ D]
+    (ι : A →+* B) (hι : Function.Injective ι) (κ : C →+* D) (hκ : Function.Injective κ)
+    (α : A →+* C) (β : B →ₐ[ℚ] D) (hi : β.toRingHom.comp ι = κ.comp α)
+    (p : ℕ) [hp : Fact p.Prime]
+    (ψ : A →+* A) (χ : B →ₐ[ℚ] B) (hc : χ.toRingHom.comp ι = ι.comp ψ)
+    (hψ : ∀ a : A, (p : A) ∣ ψ a - a^p)
+    (ψ' : C →+* C) (χ' : D →ₐ[ℚ] D) (hc' : χ'.toRingHom.comp κ = κ.comp ψ')
+    (hψ' : ∀ a : C, (p : C) ∣ ψ' a - a^p)
+    (hα : ψ'.comp α = α.comp ψ) (v : Fin 3 → A) :
+    (integralFormalGroup ι hι p ψ χ hc hψ v).map α =
+      integralFormalGroup κ hκ p ψ' χ' hc' hψ' (α ∘ v) := by
+  apply formalGroup_map_injective κ hκ
+  dsimp only
+  rw [formalGroup_map_map, ← hi, ← formalGroup_map_map, integralFormalGroup_map,
+    integralFormalGroup_map, StrictLog.formalGroup_map,
+    heightThreeLog_map ι κ α β hi p hp.out.two_le ψ ψ' hα v]
+
+lemma killFirst_inclusion :
+    (killFirst (R := ℚ)).toRingHom.comp coefficientInclusion =
+      coefficientInclusion.comp (killFirst (R := ℤ)).toRingHom := by
+  ext f d
+  exact congrArg (coeff d) (map_killFirst (Int.castRingHom ℚ) f).symm
+
+lemma killFirst_commute_integralFrobenius (p : ℕ) (hp : p ≠ 0) :
+    (integralFrobenius p hp).comp (killFirst (R := ℤ)).toRingHom =
+      (killFirst (R := ℤ)).toRingHom.comp (integralFrobenius p hp) := by
+  ext f d
+  exact congrArg (coeff d) (expand_killFirst p hp f)
+
+lemma integralHonda_killFirst (p : ℕ) [hp : Fact p.Prime] :
+    (integralHonda p).map (killFirst (R := ℤ)).toRingHom =
+      integralFormalGroup coefficientInclusion coefficientInclusion_injective p
+        (integralFrobenius p hp.out.ne_zero) (rationalFrobenius p hp.out.ne_zero)
+        (frobenius_compatible p hp.out.ne_zero) (integralFrobenius_congr p)
+        (killFirst ∘ parameters) := by
+  exact integralFormalGroup_natural _ _ _ _ _ _ killFirst_inclusion p _ _ _ _ _ _ _ _
+    (killFirst_commute_integralFrobenius p hp.out.ne_zero) parameters
+
+lemma integralHonda_height_two (p : ℕ) [hp : Fact p.Prime] :
+    (∀ j < p^2, killFirst ((multiplicationSeries (integralHonda p) p).coeff j) =
+      (p : IntegralBase) * (PowerSeries.X : PowerSeries IntegralBase).coeff j) ∧
+    killFirst ((multiplicationSeries (integralHonda p) p).coeff (p^2)) =
+      X 1 * (1-(p : IntegralBase)^(p^2-1)) := by
+  have h := integralFormalGroup_height_two coefficientInclusion coefficientInclusion_injective p
+    (integralFrobenius p hp.out.ne_zero) (rationalFrobenius p hp.out.ne_zero)
+    (frobenius_compatible p hp.out.ne_zero) (integralFrobenius_congr p)
+    (killFirst ∘ parameters) (by simp [parameters])
+  rw [← integralHonda_killFirst, multiplication_map] at h
+  constructor
+  · intro j hj
+    exact h.1 j hj
+  · convert h.2 using 1 <;> simp [parameters]
+
+theorem reducedHonda_height_one (p : ℕ) [hp : Fact p.Prime]
+    (K : Type*) [CommRing K] [CharP K p] :
+    (∀ j < p, (multiplicationSeries (reducedHonda p K) p).coeff j = 0) ∧
+    (multiplicationSeries (reducedHonda p K) p).coeff p = X 0 := by
+  have h := integralFormalGroup_height_one coefficientInclusion coefficientInclusion_injective p
+    (integralFrobenius p hp.out.ne_zero) (rationalFrobenius p hp.out.ne_zero)
+    (frobenius_compatible p hp.out.ne_zero) (integralFrobenius_congr p) parameters
+  change (∀ j < p, (multiplicationSeries (integralHonda p) p).coeff j = _) ∧
+    (multiplicationSeries (integralHonda p) p).coeff p = parameters 0 * (1-(p : IntegralBase)^(p-1)) at h
+  have hpc : (p : MvPowerSeries (Fin 2) K) = 0 := by
+    simpa only [map_natCast, map_zero] using congrArg
+      (MvPowerSeries.C (σ := Fin 2)) (CharP.cast_eq_zero K p)
+  simp only [reducedHonda, multiplication_map, PowerSeries.coeff_map]
+  constructor
+  · intro j hj
+    rw [h.1 j hj, map_mul, map_natCast, hpc, zero_mul]
+  · rw [h.2]
+    simp only [map_mul, map_sub, map_one, map_pow, map_natCast, hpc,
+      parameters, Matrix.cons_val_zero, map_X, zero_pow (by have := hp.out.two_le; omega : p-1 ≠ 0), sub_zero,
+      mul_one]
+
+theorem reducedHonda_heightCoordinates (p : ℕ) [hp : Fact p.Prime]
+    (K : Type*) [CommRing K] [CharP K p] :
+    HeightCoordinates p (reducedHonda p K) := by
+  have h1 := reducedHonda_height_one p K
+  have hpc : (p : MvPowerSeries (Fin 2) K) = 0 := by
+    simpa only [map_natCast, map_zero] using congrArg
+      (MvPowerSeries.C (σ := Fin 2)) (CharP.cast_eq_zero K p)
+  refine ⟨h1.1, h1.2, ?_, ?_⟩
+  · intro j hj
+    rw [← killFirst_eq_zero_iff]
+    simp only [reducedHonda, multiplication_map, PowerSeries.coeff_map]
+    rw [← map_killFirst, (integralHonda_height_two p).1 j hj,
+      map_mul, map_natCast, hpc, zero_mul]
+  · rw [← killFirst_eq_zero_iff, map_sub, killFirst_X_one]
+    simp only [reducedHonda, multiplication_map, PowerSeries.coeff_map]
+    rw [← map_killFirst, (integralHonda_height_two p).2]
+    simp only [map_mul, map_sub, map_one, map_pow, map_natCast, hpc,
+      map_X, zero_pow (by have : 1 < p^2 := one_lt_pow₀ hp.out.one_lt (by decide); omega : p^2-1 ≠ 0),
+      sub_zero, mul_one, sub_self]
+
+end HeightThree.HondaCoordinates
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/FormalGroup/Honda/HondaDifferential.lean b/lean/OAI/Algebra/FormalGroup/Honda/HondaDifferential.lean
new file mode 100644
index 0000000000000000000000000000000000000000..0b8e470d19cb0f702a0b8ee40c5873d7e86b56ea
--- /dev/null
+++ b/lean/OAI/Algebra/FormalGroup/Honda/HondaDifferential.lean
@@ -0,0 +1,191 @@
+import OAI.Algebra.FormalGroup.Honda.Differential
+import OAI.Algebra.FormalGroup.Honda.SpecialFiber
+
+namespace OAI
+
+noncomputable section
+
+namespace HeightThree.HondaDifferentials
+open MvPowerSeries PTypical HondaConstruction HondaCoordinates HondaSpecialFiber
+open PowerSeriesDifferential LogarithmicConstruction
+
+lemma special_numerator_dvd (p : ℕ) (n : ℕ) (hn : 0 < n) :
+    (p : ℤ)^2 ∣ numerator p (RingHom.id ℤ) specialParameters n := by
+  obtain ⟨n, rfl⟩ := Nat.exists_eq_succ_of_ne_zero (by omega : n ≠ 0)
+  simp only [numerator, Fin.sum_univ_three, specialParameters, Matrix.cons_val_zero,
+    Matrix.cons_val_one, Matrix.cons_val_two, Fin.val_zero, Fin.val_one,
+    Fin.val_two, mul_zero, zero_mul, ite_self, zero_add]
+  split_ifs <;> simp
+
+lemma special_derivative_coeff_power (p : ℕ) [hp : Fact p.Prime]
+    (n j : ℕ) (hj : n+1 = p^j) :
+    (PowerSeries.derivative (specialLog p).series).coeff n =
+      ((numerator p (RingHom.id ℤ) specialParameters j : ℤ) : ℚ) := by
+  have hpq : (p : ℚ) ≠ 0 := by exact_mod_cast hp.out.ne_zero
+  have he : (n : ℚ)+1 = (p : ℚ)^j := by exact_mod_cast hj
+  rw [PowerSeries.coeff_derivative, he]
+  change (logarithm (Int.castRingHom ℚ) p (RingHom.id ℤ) specialParameters).coeff (n+1) *
+    (p : ℚ)^j = _
+  rw [hj]
+  simp only [logarithm, coeff_series_power p hp.out.two_le, smul_eq_mul,
+    inv_pow]
+  change ((p : ℚ)^j)⁻¹ * ((numerator p (RingHom.id ℤ) specialParameters j : ℤ) : ℚ) * (p : ℚ)^j = _
+  field_simp
+
+lemma special_derivative_integral (p : ℕ) [hp : Fact p.Prime] :
+    ∃ b : PowerSeries ℤ,
+      PowerSeries.derivative (specialLog p).series =
+        (1 + (p : PowerSeries ℚ)^2 * b.map (Int.castRingHom ℚ)) := by
+  have hc (n : ℕ) : ∃ b : ℤ,
+      (PowerSeries.derivative (specialLog p).series).coeff n =
+        (if n=0 then 1 else 0) + (p : ℚ)^2 * b := by
+    by_cases hn : n=0
+    · subst n
+      refine ⟨0, ?_⟩
+      simp [PowerSeries.coeff_derivative, (specialLog p).linear_one]
+    · by_cases hj : ∃ j, p^j = n+1
+      · obtain ⟨j, hj⟩ := hj
+        have hjpos : 0 < j := by
+          by_contra h
+          have hj0 : j=0 := by omega
+          rw [hj0, pow_zero] at hj
+          omega
+        obtain ⟨b, hb⟩ := special_numerator_dvd p j hjpos
+        refine ⟨b, ?_⟩
+        rw [special_derivative_coeff_power p n j hj.symm, hb, ite_eq_right hn, zero_add,
+          Int.cast_mul, Int.cast_pow, Int.cast_natCast]
+      · refine ⟨0, ?_⟩
+        rw [PowerSeries.coeff_derivative]
+        dsimp [specialLog, heightThreeLog, logarithm]
+        simp only [coeff_series_outside p (n+1) _ hj, zero_mul, ite_eq_right hn,
+          mul_zero, add_zero]
+  choose b hb using hc
+  refine ⟨PowerSeries.mk b, ?_⟩
+  ext n
+  rw [hb]
+  rw [show (p : PowerSeries ℚ)^2 = PowerSeries.C ((p : ℚ)^2) by simp,
+    map_add, PowerSeries.coeff_one, PowerSeries.coeff_C_mul,
+    PowerSeries.coeff_map, PowerSeries.coeff_mk]
+  rfl
+
+lemma law_map_special (p : ℕ) [hp : Fact p.Prime] :
+    (integralSpecial p).toPowerSeries.map (Int.castRingHom ℚ) = (specialLog p).law := by
+  exact congrArg FormalGroup.toPowerSeries (integralSpecial_map p)
+
+lemma map_unisubst {R S σ : Type*} [CommRing R] [CommRing S]
+    (ρ : R →+* S) (f : PowerSeries R) (a : MvPowerSeries σ R)
+    (ha : PowerSeries.HasSubst a) :
+    (f.subst a).map ρ = (f.map ρ).subst (a.map ρ) :=
+  MvPowerSeries.map_subst ha.const f
+
+lemma special_partial_integral (p : ℕ) [hp : Fact p.Prime] (i : Fin 2) :
+    ∃ b : MvPowerSeries (Fin 2) ℤ,
+      pderiv i (integralSpecial p).toPowerSeries = 1 + (p : MvPowerSeries (Fin 2) ℤ)^2*b := by
+  obtain ⟨b, hb⟩ := special_derivative_integral p
+  let F := (integralSpecial p).toPowerSeries
+  let l := specialLog p
+  have hlog := congrArg (pderiv i) l.log_law
+  have hr : pderiv i l.sumSeries = (PowerSeries.derivative l.series).subst (X i) := by
+    dsimp [StrictLog.sumSeries]
+    rw [map_add, pderiv_subst l.series (X 0) (by simp) i,
+      pderiv_subst l.series (X 1) (by simp) i]
+    fin_cases i <;> simp
+  rw [pderiv_subst _ _ l.law_constant, hr, hb] at hlog
+  have hbF : PowerSeries.HasSubst F :=
+    PowerSeries.HasSubst.of_constantCoeff_zero (integralSpecial p).zero_constantCoeff
+  have hf : (1 + (p : MvPowerSeries (Fin 2) ℤ)^2 * b.subst F) * pderiv i F =
+      1 + (p : MvPowerSeries (Fin 2) ℤ)^2 * b.subst (X i) := by
+    apply HeightThree.HondaConstruction.map_injective (Int.castRingHom ℚ) Int.cast_injective
+    have hF : F.map (Int.castRingHom ℚ) = l.law := law_map_special p
+    simp only [map_mul, map_add, map_one, map_pow, map_natCast, map_unisubst _ _ _ hbF,
+      map_unisubst _ _ _ (PowerSeries.HasSubst.X i), map_X, ← pderiv_map, hF]
+    simpa only [← PowerSeries.coe_substAlgHom
+      (PowerSeries.HasSubst.of_constantCoeff_zero l.law_constant),
+      ← PowerSeries.coe_substAlgHom (PowerSeries.HasSubst.X i),
+      map_add, map_one, map_mul, map_pow, map_natCast] using hlog
+  refine ⟨b.subst (X i) - b.subst F * pderiv i F, ?_⟩
+  calc
+    pderiv i F = ((1 + (p : MvPowerSeries (Fin 2) ℤ)^2 * b.subst F) * pderiv i F) -
+      (p : MvPowerSeries (Fin 2) ℤ)^2 * b.subst F * pderiv i F := by ring
+    _ = _ := by rw [hf]; ring
+
+lemma coeff_mul_index_dvd {σ : Type*} (f : MvPowerSeries σ ℤ)
+    (q : ℤ) (h : ∀ i, ∃ b, pderiv i f = C q * b)
+    (d : σ →₀ ℕ) (i : σ) : q ∣ coeff d f * (d i : ℤ) := by
+  classical
+  by_cases hi : d i = 0
+  · simp [hi]
+  let e := d.erase i + Finsupp.single i (d i - 1)
+  have he : e + Finsupp.single i 1 = d := by
+    ext j
+    by_cases hj : j = i
+    · subst j; simp [e, Nat.sub_add_cancel (by omega : 1 ≤ d i)]
+    · simp [e, hj]
+  have hei : (e i : ℤ) + 1 = (d i : ℤ) := by
+    have hh := congrArg (fun d : σ →₀ ℕ => d i) he
+    simp only [Finsupp.add_apply, Finsupp.single_eq_same] at hh
+    exact_mod_cast hh
+  obtain ⟨b, hb⟩ := h i
+  have hh := congrArg (coeff e) hb
+  rw [coeff_pderiv, he, hei, coeff_C_mul] at hh
+  exact ⟨coeff e b, hh⟩
+
+lemma special_nonlinear_support (p : ℕ) [hp : Fact p.Prime]
+    (K : Type*) [CommRing K] [CharP K p] (d : Fin 2 →₀ ℕ)
+    (hd : coeff d ((hondaLaw p K).toPowerSeries - X 0 - X 1) ≠ 0) :
+    ∀ i, p^2 ∣ d i := by
+  let D := (integralSpecial p).toPowerSeries - X 0 - X 1
+  have hD (i : Fin 2) : ∃ b, pderiv i D = C ((p : ℤ)^2) * b := by
+    obtain ⟨b, hb⟩ := special_partial_integral p i
+    refine ⟨b, ?_⟩
+    dsimp [D]
+    rw [map_sub, map_sub, hb]
+    fin_cases i <;> simp
+  have hn : ¬(p : ℤ) ∣ coeff d D := by
+    intro hn
+    apply hd
+    have hz := (CharP.intCast_eq_zero_iff K p (coeff d D)).mpr hn
+    have hDm : D.map (Int.castRingHom K) = (hondaLaw p K).toPowerSeries - X 0 - X 1 := by
+      simp [D, hondaLaw]
+    rw [← hDm, coeff_map]
+    exact hz
+  have hc : IsCoprime (p : ℤ) (coeff d D) :=
+    (Prime.coprime_iff_not_dvd (Int.prime_iff_natAbs_prime.mpr (by simpa using hp.out))).mpr hn
+  intro i
+  have hh := hc.pow_left.dvd_of_dvd_mul_left (coeff_mul_index_dvd D ((p:ℤ)^2) hD d i)
+  exact Int.natCast_dvd_natCast.mp (by simpa only [Nat.cast_pow] using hh)
+
+lemma exists_expand_of_support {σ R : Type*} [CommRing R] (f : MvPowerSeries σ R)
+    (q : ℕ) (hq : q ≠ 0) (h : ∀ d, coeff d f ≠ 0 → ∀ i, q ∣ d i) :
+    ∃ g, expand q hq g = f := by
+  classical
+  let g : MvPowerSeries σ R := fun d => coeff (q • d) f
+  refine ⟨g, ?_⟩
+  ext d
+  by_cases hd : ∀ i, q ∣ d i
+  · let e := d.mapRange (fun n => n/q) (Nat.zero_div q)
+    have he : q • e = d := by
+      ext i
+      simp only [Finsupp.smul_apply, smul_eq_mul, e, Finsupp.mapRange_apply]
+      exact Nat.mul_div_cancel' (hd i)
+    rw [← he, coeff_expand_smul]
+    rfl
+  · obtain ⟨i, hi⟩ := not_forall.mp hd
+    rw [coeff_expand_of_not_dvd _ _ _ hi]
+    by_contra hf
+    exact hi (h d (Ne.symm hf) i)
+
+theorem honda_nonlinear_expand (p : ℕ) [hp : Fact p.Prime]
+    (K : Type*) [CommRing K] [CharP K p] :
+    ∃ H : MvPowerSeries (Fin 2) K,
+      (hondaLaw p K).toPowerSeries = X 0 + X 1 + expand (p^2) (pow_ne_zero _ hp.out.ne_zero) H := by
+  obtain ⟨H, hH⟩ := exists_expand_of_support
+    ((hondaLaw p K).toPowerSeries - X 0 - X 1) (p^2) (pow_ne_zero _ hp.out.ne_zero)
+    (special_nonlinear_support p K)
+  exact ⟨H, by rw [hH]; ring⟩
+
+end HeightThree.HondaDifferentials
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/FormalGroup/Honda/IntegralLaw.lean b/lean/OAI/Algebra/FormalGroup/Honda/IntegralLaw.lean
new file mode 100644
index 0000000000000000000000000000000000000000..c90c1cc7992c1be67cf9948a9d600b9a84358c5c
--- /dev/null
+++ b/lean/OAI/Algebra/FormalGroup/Honda/IntegralLaw.lean
@@ -0,0 +1,184 @@
+import OAI.Algebra.FormalGroup.Honda.Logarithm
+
+namespace OAI
+
+noncomputable section
+
+namespace HeightThree.HondaConstruction
+open MvPowerSeries PTypical LogarithmicConstruction
+
+variable {A B : Type*} [CommRing A] [CommRing B]
+
+theorem law_integral [Algebra ℚ B] (ι : A →+* B) (p : ℕ) [hp : Fact p.Prime]
+    (ψ : A →+* A) (χ : B →ₐ[ℚ] B) (hc : χ.toRingHom.comp ι = ι.comp ψ)
+    (hψ : ∀ a : A, (p : A) ∣ ψ a - a^p) (v : Fin 3 → A)
+    (l : StrictLog (R := B)) (hf : HasIntegralNumerators ι p l.series)
+    (he : defect p hp.out.ne_zero χ.toRingHom (ι ∘ v) l.series = PowerSeries.X) :
+    IntegralSeries ι l.law := by
+  apply integral_of_defect_log ι p ψ χ hc hψ v l.series hf he l.linear_one _ l.law_constant
+  rw [l.log_law, StrictLog.sumSeries, defect_add]
+  have hi (i : Fin 2) : IntegralSeries ι
+      (defect p hp.out.ne_zero χ.toRingHom (ι ∘ v) (l.series.subst (X i))) := by
+    simpa only [map_X] using
+      defect_log_integral ι p ψ χ hc hψ v l.series hf he (X i) (by simp)
+  exact (hi 0).add ι (hi 1)
+
+lemma map_injective (ι : A →+* B) (hinj : Function.Injective ι) {σ : Type*} :
+    Function.Injective (MvPowerSeries.map (σ := σ) ι) := by
+  intro f g hfg
+  ext d
+  apply hinj
+  simpa only [coeff_map] using congrArg (coeff d) hfg
+
+def descendFormalGroup (ι : A →+* B) (hinj : Function.Injective ι)
+    (F : FormalGroup B) (hF : IntegralSeries ι F.toPowerSeries) : FormalGroup A := by
+  let f := integralLift ι F.toPowerSeries hF
+  have hf : f.map ι = F.toPowerSeries := map_integralLift ι _ hF
+  have hc : f.constantCoeff = 0 := by
+    apply hinj
+    simpa only [← constantCoeff_map, hf, map_zero] using F.zero_constantCoeff
+  refine ⟨f, hc, ?_, ?_, ?_⟩
+  · apply hinj
+    rw [map_one, ← coeff_map, hf, F.lin_coeff_X]
+  · apply hinj
+    rw [map_one, ← coeff_map, hf, F.lin_coeff_Y]
+  · apply map_injective ι hinj
+    have hj (g₁ g₂ : MvPowerSeries (Fin 3) A) :
+        ![g₁.map ι, g₂.map ι] = fun i => (![g₁, g₂] i).map ι := by
+      ext i; fin_cases i <;> rfl
+    rw [map_subst (HasSubst.cons_subst_zero_left (0 : Fin 3) 1 2 hc),
+      map_subst (HasSubst.cons_subst_zero_right (0 : Fin 3) 1 2 hc)]
+    simp_rw [← hj, map_subst HasSubst.X_X, ← hj, map_X, hf]
+    exact F.assoc
+
+@[simp] theorem map_descendFormalGroup (ι : A →+* B) (hinj : Function.Injective ι)
+    (F : FormalGroup B) (hF : IntegralSeries ι F.toPowerSeries) :
+    (descendFormalGroup ι hinj F hF).map ι = F := by
+  apply FormalGroup.ext
+  exact map_integralLift ι _ hF
+
+instance descendFormalGroup_isComm (ι : A →+* B) (hinj : Function.Injective ι)
+    (F : FormalGroup B) [F.IsComm] (hF : IntegralSeries ι F.toPowerSeries) :
+    (descendFormalGroup ι hinj F hF).IsComm where
+  comm := by
+    apply map_injective ι hinj
+    have hf : (descendFormalGroup ι hinj F hF).toPowerSeries.map ι = F.toPowerSeries :=
+      map_integralLift ι _ hF
+    rw [hf, map_subst HasSubst.X_X, hf]
+    calc
+      F.toPowerSeries = F.toPowerSeries.subst ![X 1, X 0] := FormalGroup.IsComm.comm
+      _ = _ := by congr 1; funext i; fin_cases i <;> simp
+
+end HeightThree.HondaConstruction
+
+namespace HeightThree.HondaConstruction
+open MvPowerSeries PTypical LogarithmicConstruction
+variable {A B : Type*} [CommRing A] [CommRing B]
+
+def numerator (p : ℕ) (ψ : A →+* A) (v : Fin 3 → A) : ℕ → A
+  | 0 => 1
+  | n+1 => ∑ i : Fin 3, if i.val ≤ n then
+      (p : A)^i.val * v i * (ψ^(i.val+1)) (numerator p ψ v (n-i.val)) else 0
+termination_by n => n
+
+def logarithm [Algebra ℚ B] (ι : A →+* B) (p : ℕ) (ψ : A →+* A)
+    (v : Fin 3 → A) : PowerSeries B :=
+  series p (fun n => ((p : ℚ)⁻¹)^n • ι (numerator p ψ v n))
+
+lemma logarithm_constant [Algebra ℚ B] (ι : A →+* B) (p : ℕ) (hp : 2 ≤ p)
+    (ψ : A →+* A) (v : Fin 3 → A) :
+    (logarithm ι p ψ v).constantCoeff = 0 := series_constant p hp _
+
+lemma logarithm_linear [Algebra ℚ B] (ι : A →+* B) (p : ℕ) (hp : 2 ≤ p)
+    (ψ : A →+* A) (v : Fin 3 → A) :
+    (logarithm ι p ψ v).coeff 1 = 1 := by
+  simp [logarithm, series_linear p hp, numerator]
+
+lemma twisted_series_coeff (p : ℕ) (hp : 2 ≤ p) (χ : B →+* B)
+    (c : ℕ → B) (k n : ℕ) :
+    PowerSeries.coeff (p^n) ((twist p (by omega) χ ^ k) (series p c)) =
+      if k ≤ n then (χ^k) (c (n-k)) else 0 := by
+  rw [twist_iterate]
+  change PowerSeries.coeff (p^n) (((series p c).map (χ^k)).expand (p^k) _) = _
+  rw [PowerSeries.coeff_expand]
+  simp only [Nat.pow_dvd_pow_iff_le_right (by omega : 1 < p)]
+  split_ifs with h
+  · rw [Nat.pow_div h (by omega : 0 < p), PowerSeries.coeff_map,
+      coeff_series_power p hp]
+  · rfl
+
+lemma twisted_series_coeff_outside (p : ℕ) (hp : 2 ≤ p) (χ : B →+* B)
+    (c : ℕ → B) (k j : ℕ) (hj : ¬ ∃ n : ℕ, p^n = j) :
+    PowerSeries.coeff j ((twist p (by omega) χ ^ k) (series p c)) = 0 := by
+  rw [twist_iterate]
+  change PowerSeries.coeff j (((series p c).map (χ^k)).expand (p^k) _) = _
+  rw [PowerSeries.coeff_expand]
+  split_ifs with h
+  · rw [PowerSeries.coeff_map, coeff_series_outside p (j / p^k) c, map_zero]
+    rintro ⟨n, hn⟩
+    exact hj ⟨k+n, by rw [pow_add, hn, Nat.mul_div_cancel' h]⟩
+  · rfl
+
+end HeightThree.HondaConstruction
+
+namespace HeightThree.HondaConstruction
+open MvPowerSeries PTypical LogarithmicConstruction
+variable {A B : Type*} [CommRing A] [CommRing B]
+
+lemma iterate_smul [Algebra ℚ B] (χ : B →ₐ[ℚ] B) (n : ℕ) (q : ℚ) (b : B) :
+    (χ.toRingHom^n) (q • b) = q • ((χ.toRingHom^n) b) := by
+  induction n with
+  | zero => rfl
+  | succ n ih =>
+    rw [pow_succ']
+    change χ ((χ.toRingHom^n) (q • b)) = q • χ ((χ.toRingHom^n) b)
+    rw [ih, χ.map_smul_of_tower]
+
+lemma iterate_comp (ι : A →+* B) (ψ : A →+* A) (χ : B →+* B)
+    (hc : χ.comp ι = ι.comp ψ) (n : ℕ) (a : A) :
+    (χ^n) (ι a) = ι ((ψ^n) a) := by
+  induction n with
+  | zero => rfl
+  | succ n ih =>
+    rw [pow_succ' χ, pow_succ' ψ]
+    change χ ((χ^n) (ι a)) = ι (ψ ((ψ^n) a))
+    rw [ih]
+    exact DFunLike.congr_fun hc _
+
+lemma scalar_denominator [Algebra ℚ B] (p : ℕ) (hp : p ≠ 0)
+    (n i : ℕ) (hi : i ≤ n) (b : B) :
+    ((p : ℚ)⁻¹)^(n+1) • ((p : B)^i * b) =
+      (p : ℚ)⁻¹ • (((p : ℚ)⁻¹)^(n-i) • b) := by
+  have hpQ : (p : ℚ) ≠ 0 := by exact_mod_cast hp
+  have he : ((p : ℚ)⁻¹)^(n+1) * (p : ℚ)^i =
+      (p : ℚ)⁻¹ * ((p : ℚ)⁻¹)^(n-i) := by
+    rw [show n+1 = i + (n-i+1) by omega, pow_add]
+    calc
+      _ = (((p : ℚ)⁻¹) * p)^i * ((p : ℚ)⁻¹)^(n-i+1) := by ring
+      _ = _ := by simp [hpQ, pow_succ, mul_comm]
+  have hb : ((p : B)^i * b) = (p : ℚ)^i • b := by
+    simp [Algebra.smul_def]
+  rw [hb, smul_smul, he, smul_smul]
+
+lemma logarithm_recurrence [Algebra ℚ B] (ι : A →+* B) (p : ℕ) (hp : p ≠ 0)
+    (ψ : A →+* A) (χ : B →ₐ[ℚ] B) (hc : χ.toRingHom.comp ι = ι.comp ψ)
+    (v : Fin 3 → A) (n : ℕ) :
+    ((p : ℚ)⁻¹)^(n+1) • ι (numerator p ψ v (n+1)) =
+      ∑ i : Fin 3, (p : ℚ)⁻¹ • (ι (v i) *
+        (if i.val ≤ n then (χ.toRingHom^(i.val+1))
+          (((p : ℚ)⁻¹)^(n-i.val) • ι (numerator p ψ v (n-i.val))) else 0)) := by
+  rw [numerator, map_sum, Finset.smul_sum]
+  apply Finset.sum_congr rfl
+  intro i _
+  split_ifs with hi
+  · rw [map_mul, map_mul, map_pow, map_natCast, mul_assoc,
+      scalar_denominator p hp n i.val hi,
+      iterate_smul, iterate_comp ι ψ χ.toRingHom hc,
+      mul_smul_comm]
+  · simp
+
+end HeightThree.HondaConstruction
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/FormalGroup/Honda/Jets.lean b/lean/OAI/Algebra/FormalGroup/Honda/Jets.lean
new file mode 100644
index 0000000000000000000000000000000000000000..9b0102124b4846795e568ebf1dcd686c99b784e2
--- /dev/null
+++ b/lean/OAI/Algebra/FormalGroup/Honda/Jets.lean
@@ -0,0 +1,284 @@
+import OAI.Algebra.FormalGroup.Honda.Cocycle
+import OAI.Algebra.FormalGroup.Honda.Canonical
+
+namespace OAI
+
+noncomputable section
+
+namespace HeightThree.HondaJets
+open MvPowerSeries
+variable {K σ τ : Type*} [CommRing K]
+
+def EqJet (n : ℕ) (f g : MvPowerSeries σ K) : Prop :=
+  ∀ d, d.degree < n → coeff d f = coeff d g
+
+lemma eqJet_iff_order (n : ℕ) (f g : MvPowerSeries σ K) :
+    EqJet n f g ↔ (n : ℕ∞) ≤ (f-g).order := by
+  constructor
+  · intro h; apply nat_le_order; intro d hd; rw [map_sub,h d hd,sub_self]
+  · intro h d hd
+    have hh := coeff_of_lt_order ((show (d.degree : ℕ∞) < n by exact_mod_cast hd).trans_le h)
+    exact sub_eq_zero.mp (by simpa using hh)
+
+lemma eqJet_iff_trunc [Finite σ] (n : ℕ) (f g : MvPowerSeries σ K) :
+    EqJet n f g ↔ f.truncTotal n = g.truncTotal n := by
+  constructor
+  · intro h; ext d
+    by_cases hd : d.degree<n
+    · simpa only [coeff_truncTotal _ hd] using h d hd
+    · simp only [coeff_truncTotal_eq_zero _ (Nat.le_of_not_lt hd)]
+  · intro h d hd
+    simpa only [coeff_truncTotal _ hd] using congrArg (fun polynomial : MvPolynomial σ K => polynomial.coeff d) h
+
+lemma EqJet.refl (n : ℕ) (f : MvPowerSeries σ K) : EqJet n f f := fun _ _ => rfl
+lemma EqJet.symm {n : ℕ} {f g : MvPowerSeries σ K} (h : EqJet n f g) : EqJet n g f :=
+  fun d hd => (h d hd).symm
+lemma EqJet.trans {n : ℕ} {f g h : MvPowerSeries σ K} (h₁ : EqJet n f g)
+    (h₂ : EqJet n g h) : EqJet n f h := fun d hd => (h₁ d hd).trans (h₂ d hd)
+lemma EqJet.mono {n m : ℕ} {f g : MvPowerSeries σ K} (h : EqJet n f g) (hm : m≤n) :
+    EqJet m f g := fun d hd => h d (hd.trans_le hm)
+lemma EqJet.add {n : ℕ} {f g a b : MvPowerSeries σ K}
+    (h : EqJet n f g) (h' : EqJet n a b) : EqJet n (f+a) (g+b) := by
+  intro d hd; simp only [map_add,h d hd,h' d hd]
+lemma EqJet.sub {n : ℕ} {f g a b : MvPowerSeries σ K}
+    (h : EqJet n f g) (h' : EqJet n a b) : EqJet n (f-a) (g-b) := by
+  intro d hd; simp only [map_sub,h d hd,h' d hd]
+lemma EqJet.neg {n : ℕ} {f g : MvPowerSeries σ K} (h : EqJet n f g) : EqJet n (-f) (-g) := by
+  intro d hd; simp only [map_neg,h d hd]
+lemma EqJet.mul_left {n : ℕ} {f g : MvPowerSeries σ K} (h : EqJet n f g) (a : MvPowerSeries σ K) :
+    EqJet n (a*f) (a*g) := by
+  rw [eqJet_iff_order] at h ⊢
+  rw [←mul_sub]
+  exact le_trans (le_trans h (le_add_left le_rfl)) le_order_mul
+lemma EqJet.mul_right {n : ℕ} {f g : MvPowerSeries σ K} (h : EqJet n f g) (a : MvPowerSeries σ K) :
+    EqJet n (f*a) (g*a) := by simpa only [mul_comm] using h.mul_left a
+lemma EqJet.mul {n : ℕ} {f g a b : MvPowerSeries σ K}
+    (h : EqJet n f g) (h' : EqJet n a b) : EqJet n (f*a) (g*b) :=
+  (h.mul_right a).trans (h'.mul_left g)
+lemma EqJet.sum {ι : Type*} {n : ℕ} (s : Finset ι) (f g : ι → MvPowerSeries σ K)
+    (h : ∀ i∈s, EqJet n (f i) (g i)) : EqJet n (∑i∈s,f i) (∑i∈s,g i) := by
+  intro d hd; simp only [map_sum]; exact Finset.sum_congr rfl fun i hi => h i hi d hd
+
+lemma EqJet.subst_left {n : ℕ} {f g : MvPowerSeries σ K} (h : EqJet n f g)
+    (a : σ → MvPowerSeries τ K) (ha : HasSubst a) (ha0 : ∀i,(a i).constantCoeff=0) :
+    EqJet n (f.subst a) (g.subst a) := by
+  rw [eqJet_iff_order] at h ⊢
+  rw [←subst_sub ha]
+  have ho : (1 : ℕ∞) ≤ ⨅ i, (a i).order := le_iInf fun i =>
+    one_le_order_iff_constCoeff_eq_zero.mpr (ha0 i)
+  exact (h.trans (by simpa [mul_comm] using mul_le_mul_right ho (f-g).order)).trans
+    (le_order_subst ha (f-g))
+
+lemma EqJet.subst_right [Finite τ] {n : ℕ} (f : MvPowerSeries σ K)
+    (a b : σ → MvPowerSeries τ K) (ha : HasSubst a) (hb : HasSubst b)
+    (h : ∀i,EqJet n (a i) (b i)) : EqJet n (f.subst a) (f.subst b) := by
+  rw [eqJet_iff_trunc,
+    truncTotal_subst_eq_truncTotal_subst_truncTotal_of_le ha (x:=fun _=>n) (fun _=>le_rfl),
+    truncTotal_subst_eq_truncTotal_subst_truncTotal_of_le hb (x:=fun _=>n) (fun _=>le_rfl)]
+  congr 2
+  funext i
+  exact congrArg MvPolynomial.toMvPowerSeries ((eqJet_iff_trunc n _ _).mp (h i))
+
+lemma eqJet_zero_mul {n m : ℕ} {f g : MvPowerSeries σ K}
+    (hf : EqJet n f 0) (hg : EqJet m g 0) : EqJet (n+m) (f*g) 0 := by
+  rw [eqJet_iff_order,sub_zero] at hf hg ⊢
+  exact (show ((n+m : ℕ) : ℕ∞) ≤ f.order+g.order by simpa using add_le_add hf hg).trans le_order_mul
+
+lemma eqJet_one_zero (f : MvPowerSeries σ K) (hf : f.constantCoeff=0) : EqJet 1 f 0 := by
+  rw [eqJet_iff_order,sub_zero]
+  exact one_le_order_iff_constCoeff_eq_zero.mpr hf
+
+lemma eqJet_sub_zero {n : ℕ} {f g : MvPowerSeries σ K} : EqJet n (f-g) 0 ↔ EqJet n f g := by
+  constructor <;> intro h d hd
+  · exact sub_eq_zero.mp (by simpa only [map_sub,map_zero] using h d hd)
+  · simp only [map_sub,map_zero,h d hd,sub_self]
+
+lemma eqJet_subst_constant (f : MvPowerSeries σ K) (a : σ → MvPowerSeries τ K)
+    (ha : HasSubst a) (ha0 : ∀i,(a i).constantCoeff=0) :
+    EqJet 1 (f.subst a) (C f.constantCoeff) := by
+  rw [←eqJet_sub_zero]
+  apply eqJet_one_zero
+  simp only [map_sub,constantCoeff_C]
+  exact sub_eq_zero.mpr (HeightThree.OriginalDifferentialSupport.constantCoeff_subst_zero_axis a ha ha0 f)
+
+lemma coeff_linear_mul (f g : MvPowerSeries σ K) (i : σ) :
+    coeff (Finsupp.single i 1) (f*g)=
+      f.constantCoeff*coeff (Finsupp.single i 1) g+
+      g.constantCoeff*coeff (Finsupp.single i 1) f := by
+  have h (a : MvPowerSeries σ K) : constantCoeff (pderiv i a)=coeff (Finsupp.single i 1) a := by
+    rw [←coeff_zero_eq_constantCoeff,coeff_pderiv]; simp
+  rw [←h,Derivation.leibniz,smul_eq_mul,smul_eq_mul,map_add,map_mul,map_mul,h,h]
+
+lemma subst_first_order_polynomial [Fintype σ] [Finite τ]
+    (f : MvPolynomial σ K) (n : ℕ)
+    (a b : σ → MvPowerSeries τ K) (ha0 : ∀i,(a i).constantCoeff=0)
+    (hb0 : ∀i,(b i).constantCoeff=0) (hab : ∀i,EqJet n (a i) (b i)) :
+    EqJet (n+1) ((f : MvPowerSeries σ K).subst a - (f : MvPowerSeries σ K).subst b)
+      (∑i, C (coeff (Finsupp.single i 1) (f : MvPowerSeries σ K))*(a i-b i)) := by
+  classical
+  have ha : HasSubst a := hasSubst_of_constantCoeff_zero ha0
+  have hb : HasSubst b := hasSubst_of_constantCoeff_zero hb0
+  induction f using MvPolynomial.induction_on with
+  | C c =>
+    simp only [MvPolynomial.coe_C,subst_C,coeff_C,Finsupp.single_eq_zero,one_ne_zero,
+      ite_false,map_zero,zero_mul,Finset.sum_const_zero,sub_self]
+    exact EqJet.refl _ _
+  | add f g hf hg =>
+    convert hf.add hg using 1
+    · simp only [MvPolynomial.coe_add,subst_add ha,subst_add hb]; ring
+    · simp only [MvPolynomial.coe_add,map_add,add_mul,Finset.sum_add_distrib]
+  | mul_X f j hf =>
+    have h1 : EqJet (n+1) (((f : MvPowerSeries σ K).subst a-C (f : MvPowerSeries σ K).constantCoeff)*(a j-b j)) 0 := by
+      simpa only [add_comm] using eqJet_zero_mul
+        (eqJet_sub_zero.mpr (eqJet_subst_constant _ a ha ha0)) (eqJet_sub_zero.mpr (hab j))
+    have h2 : EqJet (n+1) (((f : MvPowerSeries σ K).subst a-(f : MvPowerSeries σ K).subst b)*b j) 0 :=
+      eqJet_zero_mul (eqJet_sub_zero.mpr (EqJet.subst_right _ a b ha hb hab))
+        (eqJet_one_zero _ (hb0 j))
+    have he : ((f : MvPowerSeries σ K).subst a*a j-(f : MvPowerSeries σ K).subst b*b j) -
+        C (f : MvPowerSeries σ K).constantCoeff*(a j-b j)=
+      (((f : MvPowerSeries σ K).subst a-C (f : MvPowerSeries σ K).constantCoeff)*(a j-b j))+
+      (((f : MvPowerSeries σ K).subst a-(f : MvPowerSeries σ K).subst b)*b j) := by ring
+    have hh₀ : EqJet (n+1)
+        (((f : MvPowerSeries σ K).subst a*a j-(f : MvPowerSeries σ K).subst b*b j) -
+          C (f : MvPowerSeries σ K).constantCoeff*(a j-b j)) 0 := by
+      rw [he]; simpa using h1.add h2
+    have hh := eqJet_sub_zero.mp hh₀
+    convert hh using 1
+    · simp only [MvPolynomial.coe_mul,MvPolynomial.coe_X,subst_mul ha,subst_mul hb,
+        subst_X ha,subst_X hb]
+    · simp only [MvPolynomial.coe_mul,MvPolynomial.coe_X]
+      simp [coeff_linear_mul, coeff_index_single_X,apply_ite]
+
+lemma subst_first_order [Fintype σ] [Finite τ]
+    (f : MvPowerSeries σ K) (n : ℕ)
+    (a b : σ → MvPowerSeries τ K) (ha0 : ∀i,(a i).constantCoeff=0)
+    (hb0 : ∀i,(b i).constantCoeff=0) (hab : ∀i,EqJet n (a i) (b i)) :
+    EqJet (n+1) (f.subst a - f.subst b)
+      (∑i, C (coeff (Finsupp.single i 1) f)*(a i-b i)) := by
+  classical
+  let : UniformSpace K := ⊥
+  let : DiscreteUniformity K := ⟨rfl⟩
+  open MvPowerSeries.WithPiTopology in
+  have hc₁ : Continuous (fun f : MvPowerSeries σ K => f.subst a - f.subst b) :=
+    (continuous_subst (hasSubst_of_constantCoeff_zero ha0)).sub
+      (continuous_subst (hasSubst_of_constantCoeff_zero hb0))
+  intro d hd
+  have hc₂ : Continuous (fun f : MvPowerSeries σ K =>
+      ∑i, C (coeff (Finsupp.single i 1) f)*(a i-b i)) := by
+    apply continuous_finsetSum
+    intro i hi
+    exact ((MvPowerSeries.WithPiTopology.continuous_C).comp
+      (MvPowerSeries.WithPiTopology.continuous_coeff K _)).mul_const _
+  have hh := MvPowerSeries.WithPiTopology.denseRange_toMvPowerSeries.equalizer
+    ((MvPowerSeries.WithPiTopology.continuous_coeff K d).comp hc₁)
+    ((MvPowerSeries.WithPiTopology.continuous_coeff K d).comp hc₂)
+    (by funext g; exact subst_first_order_polynomial g n a b ha0 hb0 hab d hd)
+  exact congrFun hh f
+
+lemma law_first_order [Finite τ] (F : FormalGroup K) (n : ℕ)
+    (a b : Fin 2 → MvPowerSeries τ K) (ha0 : ∀i,(a i).constantCoeff=0)
+    (hb0 : ∀i,(b i).constantCoeff=0) (hab : ∀i,EqJet n (a i) (b i)) :
+    EqJet (n+1) (F.toPowerSeries.subst a - F.toPowerSeries.subst b)
+      ((a 0-b 0)+(a 1-b 1)) := by
+  simpa only [Fin.sum_univ_two,F.lin_coeff_X,F.lin_coeff_Y,map_one,one_mul]
+    using subst_first_order F.toPowerSeries n a b ha0 hb0 hab
+
+lemma EqJet.mul_leading {m n : ℕ} {f g a b : MvPowerSeries σ K}
+    (hfg : EqJet (m+1) f g) (hab : EqJet (n+1) a b)
+    (hg : EqJet m g 0) (ha : EqJet n a 0) : EqJet (m+n+1) (f*a) (g*b) := by
+  rw [←eqJet_sub_zero]
+  have he : f*a-g*b=(f-g)*a+g*(a-b) := by ring
+  rw [he]
+  have h₁ := eqJet_zero_mul (eqJet_sub_zero.mpr hfg) ha
+  have h₂ := eqJet_zero_mul hg (eqJet_sub_zero.mpr hab)
+  have h₁' : EqJet (m+n+1) ((f-g)*a) 0 := by convert h₁ using 1; omega
+  have h₂' : EqJet (m+n+1) (g*(a-b)) 0 := h₂
+  simpa only [add_zero] using h₁'.add h₂'
+
+lemma eqJet_pow_zero (f : MvPowerSeries σ K) (hf : f.constantCoeff=0) (n : ℕ) :
+    EqJet n (f^n) 0 := by
+  rw [eqJet_iff_order,sub_zero]
+  exact le_order_pow_of_constantCoeff_eq_zero n hf
+
+lemma EqJet.pow_leading {f g : MvPowerSeries σ K} (h : EqJet 2 f g)
+    (hf : f.constantCoeff=0) (hg : g.constantCoeff=0) (n : ℕ) :
+    EqJet (n+1) (f^n) (g^n) := by
+  induction n with
+  | zero => exact EqJet.refl _ _
+  | succ n ih =>
+    simpa only [pow_succ] using ih.mul_leading h
+      (eqJet_pow_zero g hg n) (eqJet_one_zero f hf)
+
+lemma leading_part (f : MvPowerSeries σ K) (n : ℕ) (h : EqJet n f 0) :
+    EqJet (n+1) f (f.homogeneousComponent n) := by
+  intro d hd
+  rw [coeff_homogeneousComponent]
+  split_ifs with he
+  · rfl
+  · have hh : d.degree<n := by omega
+    simpa only [map_zero] using h d hh
+
+lemma homogeneous_eq_of_jet {f g : MvPowerSeries σ K} {n : ℕ}
+    (hf : f.IsHomogeneous n) (hg : g.IsHomogeneous n) (h : EqJet (n+1) f g) : f=g := by
+  ext d
+  by_cases hd : d.degree=n
+  · exact h d (by omega)
+  · rw [hf.coeff_eq_zero hd,hg.coeff_eq_zero hd]
+
+section Field
+variable {K : Type*} [Field K]
+open HeightThree.HomogeneousCocycle
+
+lemma subst_homogeneous_leading (D : MvPowerSeries (Fin 2) K) (n : ℕ)
+    (hD : D.IsHomogeneous n) (a b : Fin 2 → MvPowerSeries σ K)
+    (ha : ∀i,(a i).constantCoeff=0) (hb : ∀i,(b i).constantCoeff=0)
+    (hab : ∀i,EqJet 2 (a i) (b i)) : EqJet (n+1) (D.subst a) (D.subst b) := by
+  classical
+  have ha' := hasSubst_of_constantCoeff_zero ha
+  have hb' := hasSubst_of_constantCoeff_zero hb
+  have ea : a=![a 0,a 1] := by ext i; fin_cases i <;> rfl
+  have eb : b=![b 0,b 1] := by ext i; fin_cases i <;> rfl
+  rw [homogeneous_sum D n hD,←coe_substAlgHom ha',←coe_substAlgHom hb',map_sum,map_sum]
+  apply EqJet.sum
+  intro i hi
+  simp only [coe_substAlgHom]
+  rw [ea,eb,subst_monomial_pair _ _ _ _ _ (ha 0) (ha 1),
+    subst_monomial_pair _ _ _ _ _ (hb 0) (hb 1)]
+  have hh := ((hab 0).pow_leading (ha 0) (hb 0) i).mul_leading
+    ((hab 1).pow_leading (ha 1) (hb 1) (n-i))
+    (eqJet_pow_zero (b 0) (hb 0) i) (eqJet_pow_zero (a 1) (ha 1) (n-i))
+  have hi' : i≤n := by simpa only [Finset.mem_range,Nat.lt_succ_iff] using hi
+  simpa only [Nat.add_sub_of_le hi',mul_assoc] using hh.mul_left (C _)
+
+lemma homogeneous_subst_linear (D : MvPowerSeries (Fin 2) K) (n : ℕ)
+    (hD : D.IsHomogeneous n) (a : Fin 2 → MvPowerSeries σ K)
+    (ha : ∀i,(a i).constantCoeff=0) (haH : ∀i,(a i).IsHomogeneous 1) :
+    (D.subst a).IsHomogeneous n := by
+  classical
+  have ha' := hasSubst_of_constantCoeff_zero ha
+  have ea : a=![a 0,a 1] := by ext i; fin_cases i <;> rfl
+  apply homogeneous_of_coeff
+  intro d hd
+  rw [homogeneous_sum D n hD,←coe_substAlgHom ha',map_sum,map_sum]
+  apply Finset.sum_eq_zero
+  intro i hi
+  simp only [coe_substAlgHom]
+  rw [ea,subst_monomial_pair _ _ _ _ _ (ha 0) (ha 1),mul_assoc]
+  have hi' : i≤n := by simpa only [Finset.mem_range,Nat.lt_succ_iff] using hi
+  have h₁ : ((a 0)^i).IsHomogeneous i := by
+    have hh : ((a 0)^i).IsHomogeneous (1*i) := by exact homogeneous_pow (haH 0) i
+    rw [one_mul] at hh; exact @hh
+  have h₂ : ((a 1)^(n-i)).IsHomogeneous (n-i) := by
+    have hh : ((a 1)^(n-i)).IsHomogeneous (1*(n-i)) := by exact homogeneous_pow (haH 1) (n-i)
+    rw [one_mul] at hh; exact @hh
+  have h₃ : ((a 0)^i*(a 1)^(n-i)).IsHomogeneous n := by
+    have hh : ((a 0)^i*(a 1)^(n-i)).IsHomogeneous (i+(n-i)) := by exact h₁.mul h₂
+    rw [Nat.add_sub_of_le hi'] at hh; exact @hh
+  rw [coeff_C_mul,h₃.coeff_eq_zero hd,mul_zero]
+
+end Field
+end HeightThree.HondaJets
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/FormalGroup/Honda/Leading.lean b/lean/OAI/Algebra/FormalGroup/Honda/Leading.lean
new file mode 100644
index 0000000000000000000000000000000000000000..df822922e0b0120f38dde93b6e5b187d08f2aa02
--- /dev/null
+++ b/lean/OAI/Algebra/FormalGroup/Honda/Leading.lean
@@ -0,0 +1,292 @@
+import OAI.Algebra.FormalGroup.Honda.Jets
+
+namespace OAI
+
+noncomputable section
+
+namespace HeightThree.HondaLeading
+open MvPowerSeries HeightThree.HondaJets HeightThree.HomogeneousCocycle
+variable {K σ : Type*} [Field K]
+
+abbrev pair (F : FormalGroup K) (a b : MvPowerSeries σ K) := F.toPowerSeries.subst ![a,b]
+lemma pair_const (F : FormalGroup K) (a b : MvPowerSeries σ K)
+    (ha : a.constantCoeff=0) (hb : b.constantCoeff=0) : (pair F a b).constantCoeff=0 := by
+  exact constantCoeff_subst_eq_zero (hasSubst_of_constantCoeff_zero (by
+    intro i; fin_cases i <;> simp [ha,hb])) (by intro i; fin_cases i <;> simp [ha,hb]) F.zero_constantCoeff
+
+lemma pair_linear [Finite σ] (F : FormalGroup K) (a b : MvPowerSeries σ K)
+    (ha : a.constantCoeff=0) (hb : b.constantCoeff=0) : EqJet 2 (pair F a b) (a+b) := by
+  have hh := law_first_order F 1 ![a,b] ![0,0]
+    (by intro i; fin_cases i <;> simp [ha,hb]) (by intro i; fin_cases i <;> simp)
+    (by intro i; fin_cases i
+        · exact eqJet_one_zero a ha
+        · exact eqJet_one_zero b hb)
+  have h0 : F.toPowerSeries.subst (![0,0] : Fin 2 → MvPowerSeries σ K)=0 := by
+    rw [show (![0,0] : Fin 2 → MvPowerSeries σ K)=0 by ext i; fin_cases i <;> rfl]
+    exact subst_zero_of_constantCoeff_zero F.zero_constantCoeff
+  simpa only [h0,sub_zero,Matrix.cons_val_zero,Matrix.cons_val_one] using hh
+
+abbrev leading (F G : FormalGroup K) (n : ℕ) := (F.toPowerSeries-G.toPowerSeries).homogeneousComponent n
+
+lemma leading_approx (F G : FormalGroup K) (n : ℕ)
+    (h : EqJet n F.toPowerSeries G.toPowerSeries) :
+    EqJet (n+1) (F.toPowerSeries-G.toPowerSeries) (leading F G n) :=
+  leading_part _ n (eqJet_sub_zero.mpr h)
+
+lemma leading_homogeneous (F G : FormalGroup K) (n : ℕ) : (leading F G n).IsHomogeneous n :=
+  isHomogeneous_homogeneousComponent _ _
+
+lemma homogeneous_zero (n : ℕ) : (0 : MvPowerSeries σ K).IsHomogeneous n := by
+  apply homogeneous_of_coeff; intro d hd; simp
+
+lemma homogeneous_C_mul (a : K) {f : MvPowerSeries σ K} {n : ℕ}
+    (hf : f.IsHomogeneous n) : (C a*f).IsHomogeneous n := by
+  apply homogeneous_of_coeff; intro d hd; rw [coeff_C_mul,hf.coeff_eq_zero hd,mul_zero]
+
+lemma linear_pair_homogeneous (D : MvPowerSeries (Fin 2) K) (n : ℕ)
+    (hD : D.IsHomogeneous n) (a b : MvPowerSeries σ K)
+    (ha : a.constantCoeff=0) (hb : b.constantCoeff=0)
+    (hHa : a.IsHomogeneous 1) (hHb : b.IsHomogeneous 1) :
+    (D.subst ![a,b]).IsHomogeneous n := by
+  apply homogeneous_subst_linear D n hD
+  · intro i; fin_cases i <;> simp [ha,hb]
+  · intro i; fin_cases i
+    · exact @hHa
+    · exact @hHb
+
+lemma leading_axis (F G : FormalGroup K) (n : ℕ)
+    (h : EqJet n F.toPowerSeries G.toPowerSeries) :
+    (leading F G n).subst ![(0 : MvPowerSeries (Fin 1) K),X 0]=0 ∧
+    (leading F G n).subst ![(X 0 : MvPowerSeries (Fin 1) K),0]=0 := by
+  have hh := leading_approx F G n h
+  have h0 : PowerSeries.HasSubst (X (0 : Fin 1) : MvPowerSeries (Fin 1) K) := .of_constantCoeff_zero (by simp)
+  constructor
+  · have hs : HasSubst (![0,X 0] : Fin 2 → MvPowerSeries (Fin 1) K) :=
+      hasSubst_of_constantCoeff_zero (by intro i; fin_cases i <;> simp)
+    have he := hh.subst_left _ hs (by intro i; fin_cases i <;> simp)
+    rw [subst_sub hs,F.zero_add h0,G.zero_add h0,sub_self] at he
+    exact homogeneous_eq_of_jet
+      (linear_pair_homogeneous _ n (leading_homogeneous F G n) _ _ (by simp) (by simp)
+        (homogeneous_zero 1) (homogeneous_X 0)) (homogeneous_zero n) he.symm
+  · have hs : HasSubst (![X 0,0] : Fin 2 → MvPowerSeries (Fin 1) K) :=
+      hasSubst_of_constantCoeff_zero (by intro i; fin_cases i <;> simp)
+    have he := hh.subst_left _ hs (by intro i; fin_cases i <;> simp)
+    rw [subst_sub hs,F.add_zero h0,G.add_zero h0,sub_self] at he
+    exact homogeneous_eq_of_jet
+      (linear_pair_homogeneous _ n (leading_homogeneous F G n) _ _ (by simp) (by simp)
+        (homogeneous_X 0) (homogeneous_zero 1)) (homogeneous_zero n) he.symm
+
+lemma leading_symmetric (F G : FormalGroup K) [F.IsComm] [G.IsComm] (n : ℕ)
+    (h : EqJet n F.toPowerSeries G.toPowerSeries) :
+    (leading F G n).subst ![(X 1 : MvPowerSeries (Fin 2) K),X 0]=leading F G n := by
+  have hs : HasSubst (![X 1,X 0] : Fin 2 → MvPowerSeries (Fin 2) K) :=
+    hasSubst_of_constantCoeff_zero (by intro i; fin_cases i <;> simp)
+  have he := (leading_approx F G n h).subst_left _ hs (by intro i; fin_cases i <;> simp)
+  rw [subst_sub hs,←FormalGroup.IsComm.comm,←FormalGroup.IsComm.comm] at he
+  exact homogeneous_eq_of_jet
+    (linear_pair_homogeneous _ n (leading_homogeneous F G n) _ _ (by simp) (by simp)
+      (homogeneous_X 1) (homogeneous_X 0)) (leading_homogeneous F G n)
+    (he.symm.trans (leading_approx F G n h))
+
+lemma leading_evaluate (F G : FormalGroup K) (n : ℕ)
+    (h : EqJet n F.toPowerSeries G.toPowerSeries)
+    (a b u v : MvPowerSeries σ K)
+    (ha : a.constantCoeff=0) (hb : b.constantCoeff=0)
+    (hu : u.constantCoeff=0) (hv : v.constantCoeff=0)
+    (hau : EqJet 2 a u) (hbv : EqJet 2 b v) :
+    EqJet (n+1) (pair F a b-pair G a b) ((leading F G n).subst ![u,v]) := by
+  have hs : HasSubst (![a,b] : Fin 2 → MvPowerSeries σ K) :=
+    hasSubst_of_constantCoeff_zero (by intro i; fin_cases i <;> simp [ha,hb])
+  have he := (leading_approx F G n h).subst_left _ hs (by intro i; fin_cases i <;> simp [ha,hb])
+  rw [subst_sub hs] at he
+  apply he.trans
+  apply subst_homogeneous_leading _ n (leading_homogeneous F G n)
+  · intro i; fin_cases i <;> simp [ha,hb]
+  · intro i; fin_cases i <;> simp [hu,hv]
+  · intro i; fin_cases i
+    · exact hau
+    · exact hbv
+
+lemma leading_variation [Finite σ] (F G : FormalGroup K) (n : ℕ)
+    (h : EqJet n F.toPowerSeries G.toPowerSeries)
+    (a b c d u v : MvPowerSeries σ K)
+    (ha : a.constantCoeff=0) (hb : b.constantCoeff=0)
+    (hc : c.constantCoeff=0) (hd : d.constantCoeff=0)
+    (hu : u.constantCoeff=0) (hv : v.constantCoeff=0)
+    (hau : EqJet 2 a u) (hbv : EqJet 2 b v)
+    (hac : EqJet n a c) (hbd : EqJet n b d) :
+    EqJet (n+1) (pair F a b-pair G c d)
+      ((leading F G n).subst ![u,v]+((a-c)+(b-d))) := by
+  have h₁ := leading_evaluate F G n h a b u v ha hb hu hv hau hbv
+  have h₂ := law_first_order G n ![a,b] ![c,d]
+    (by intro i; fin_cases i <;> simp [ha,hb]) (by intro i; fin_cases i <;> simp [hc,hd])
+    (by intro i; fin_cases i; exact hac; exact hbd)
+  convert h₁.add h₂ using 1
+  · dsimp only [pair]; ring
+  · rfl
+
+lemma leading_associative (F G : FormalGroup K) (n : ℕ)
+    (h : EqJet n F.toPowerSeries G.toPowerSeries) :
+    (leading F G n).subst ![(X 0 : MvPowerSeries (Fin 3) K),X 1] +
+      (leading F G n).subst ![(X 0+X 1 : MvPowerSeries (Fin 3) K),X 2] =
+    (leading F G n).subst ![(X 1 : MvPowerSeries (Fin 3) K),X 2] +
+      (leading F G n).subst ![(X 0 : MvPowerSeries (Fin 3) K),X 1+X 2] := by
+  let x : MvPowerSeries (Fin 3) K := X 0
+  let y : MvPowerSeries (Fin 3) K := X 1
+  let z : MvPowerSeries (Fin 3) K := X 2
+  have hx : x.constantCoeff=0 := by simp [x]
+  have hy : y.constantCoeff=0 := by simp [y]
+  have hz : z.constantCoeff=0 := by simp [z]
+  have hxy : EqJet n (pair F x y) (pair G x y) :=
+    h.subst_left _ (hasSubst_of_constantCoeff_zero (by intro i; fin_cases i <;> simp [hx,hy]))
+      (by intro i; fin_cases i <;> simp [hx,hy])
+  have hyz : EqJet n (pair F y z) (pair G y z) :=
+    h.subst_left _ (hasSubst_of_constantCoeff_zero (by intro i; fin_cases i <;> simp [hy,hz]))
+      (by intro i; fin_cases i <;> simp [hy,hz])
+  have hL := leading_variation F G n h (pair F x y) z (pair G x y) z (x+y) z
+    (pair_const F x y hx hy) hz (pair_const G x y hx hy) hz (by simp [hx,hy]) hz
+    (pair_linear F x y hx hy) (EqJet.refl 2 z) hxy (EqJet.refl n z)
+  have hE₁ := leading_evaluate F G n h x y x y hx hy hx hy (EqJet.refl 2 x) (EqJet.refl 2 y)
+  have hL' : EqJet (n+1) (pair F (pair F x y) z-pair G (pair G x y) z)
+      ((leading F G n).subst ![x+y,z]+(leading F G n).subst ![x,y]) := by
+    refine EqJet.trans ?_ ((EqJet.refl _ _).add hE₁)
+    simpa only [sub_self,add_zero] using hL
+  have hR := leading_variation F G n h x (pair F y z) x (pair G y z) x (y+z)
+    hx (pair_const F y z hy hz) hx (pair_const G y z hy hz) hx (by simp [hy,hz])
+    (EqJet.refl 2 x) (pair_linear F y z hy hz) (EqJet.refl n x) hyz
+  have hE₂ := leading_evaluate F G n h y z y z hy hz hy hz (EqJet.refl 2 y) (EqJet.refl 2 z)
+  have hR' : EqJet (n+1) (pair F x (pair F y z)-pair G x (pair G y z))
+      ((leading F G n).subst ![x,y+z]+(leading F G n).subst ![y,z]) := by
+    refine EqJet.trans ?_ ((EqJet.refl _ _).add hE₂)
+    simpa only [sub_self,zero_add] using hR
+  have heq : pair F (pair F x y) z-pair G (pair G x y) z=
+      pair F x (pair F y z)-pair G x (pair G y z) := by
+    rw [pair,F.assoc' (.of_constantCoeff_zero hx) (.of_constantCoeff_zero hy) (.of_constantCoeff_zero hz)]
+    rw [pair,G.assoc' (.of_constantCoeff_zero hx) (.of_constantCoeff_zero hy) (.of_constantCoeff_zero hz)]
+  rw [heq] at hL'
+  have hlin (a b : MvPowerSeries (Fin 3) K) (ha : a.constantCoeff=0) (hb : b.constantCoeff=0)
+      (haH : a.IsHomogeneous 1) (hbH : b.IsHomogeneous 1) :
+      ((leading F G n).subst ![a,b]).IsHomogeneous n := by
+    exact linear_pair_homogeneous _ n (leading_homogeneous F G n) a b ha hb haH hbH
+  have hxH : x.IsHomogeneous 1 := by exact homogeneous_X 0
+  have hyH : y.IsHomogeneous 1 := by exact homogeneous_X 1
+  have hzH : z.IsHomogeneous 1 := by exact homogeneous_X 2
+  have hsumxy : (x+y).IsHomogeneous 1 := by exact hxH.add hyH
+  have hsumyz : (y+z).IsHomogeneous 1 := by exact hyH.add hzH
+  have hleft : ((leading F G n).subst ![x+y,z]+(leading F G n).subst ![x,y]).IsHomogeneous n := by
+    apply MvPowerSeries.IsHomogeneous.add
+    · exact hlin _ _ (by simp [hx,hy]) hz hsumxy hzH
+    · exact hlin _ _ hx hy hxH hyH
+  have hright : ((leading F G n).subst ![x,y+z]+(leading F G n).subst ![y,z]).IsHomogeneous n := by
+    apply MvPowerSeries.IsHomogeneous.add
+    · exact hlin _ _ hx (by simp [hy,hz]) hxH hsumyz
+    · exact hlin _ _ hy hz hyH hzH
+  simpa only [add_comm] using homogeneous_eq_of_jet hleft hright (hL'.symm.trans hR')
+
+end HeightThree.HondaLeading
+
+namespace HeightThree.HondaLeading
+open MvPowerSeries HeightThree.HondaJets HeightThree.HomogeneousCocycle HeightThree.HondaTarget
+variable {K : Type*} [Field K]
+
+@[simp] lemma multiplication_zero (F : FormalGroup K) : multiplicationSeries F 0=0 := rfl
+lemma multiplication_succ (F : FormalGroup K) (n : ℕ) :
+    multiplicationSeries F (n+1) = pair F (multiplicationSeries F n) PowerSeries.X := by
+  change ((n+1) • variablePoint F).val = _
+  rw [succ_nsmul]
+  rfl
+@[simp] lemma multiplication_constant (F : FormalGroup K) (n : ℕ) :
+    MvPowerSeries.constantCoeff (multiplicationSeries F n)=0 := by
+  induction n with
+  | zero => simp
+  | succ n ih =>
+    rw [multiplication_succ]
+    exact pair_const F _ _ ih (by simp [PowerSeries.X])
+
+lemma multiplication_linear (F : FormalGroup K) (i : ℕ) :
+    EqJet 2 (multiplicationSeries F i) (C (i:K)*PowerSeries.X) := by
+  induction i with
+  | zero => simpa using (EqJet.refl 2 (0 : PowerSeries K))
+  | succ i ih =>
+    rw [multiplication_succ]
+    have hh := pair_linear F (multiplicationSeries F i) PowerSeries.X
+      (by exact multiplication_constant F i) (by simp [PowerSeries.X])
+    have hh' := hh.trans (ih.add (EqJet.refl _ PowerSeries.X))
+    convert hh' using 1
+    simp only [Nat.cast_add,Nat.cast_one,map_add,map_one,add_mul,one_mul]
+
+lemma multiplication_match (F G : FormalGroup K) (n : ℕ)
+    (h : EqJet n F.toPowerSeries G.toPowerSeries) (i : ℕ) :
+    EqJet n (multiplicationSeries F i) (multiplicationSeries G i) := by
+  induction i with
+  | zero => exact EqJet.refl _ _
+  | succ i ih =>
+    rw [multiplication_succ,multiplication_succ]
+    have h₁ := h.subst_left ![multiplicationSeries F i,PowerSeries.X]
+      (hasSubst_of_constantCoeff_zero (by intro j; fin_cases j <;> simp [multiplication_constant,PowerSeries.X]))
+      (by intro j; fin_cases j <;> simp [multiplication_constant,PowerSeries.X])
+    apply h₁.trans
+    apply EqJet.subst_right G.toPowerSeries
+    · exact hasSubst_of_constantCoeff_zero (by intro j; fin_cases j <;> simp [multiplication_constant,PowerSeries.X])
+    · exact hasSubst_of_constantCoeff_zero (by intro j; fin_cases j <;> simp [multiplication_constant,PowerSeries.X])
+    · intro j; fin_cases j
+      · exact ih
+      · exact EqJet.refl _ _
+
+lemma multiplication_leading_trace (F G : FormalGroup K) (n : ℕ)
+    (h : EqJet n F.toPowerSeries G.toPowerSeries) (i : ℕ) :
+    EqJet (n+1) (multiplicationSeries F i-multiplicationSeries G i)
+      (∑j∈Finset.range i, (leading F G n).subst ![C (j:K)*PowerSeries.X,PowerSeries.X]) := by
+  induction i with
+  | zero => simpa using (EqJet.refl (n+1) (0 : PowerSeries K))
+  | succ i ih =>
+    rw [multiplication_succ,multiplication_succ,Finset.sum_range_succ]
+    have hh := leading_variation F G n h (multiplicationSeries F i) PowerSeries.X
+      (multiplicationSeries G i) PowerSeries.X (C (i:K)*PowerSeries.X) PowerSeries.X
+      (multiplication_constant F i) (by simp [PowerSeries.X])
+      (multiplication_constant G i) (by simp [PowerSeries.X])
+      (by simp [PowerSeries.X]) (by simp [PowerSeries.X])
+      (multiplication_linear F i) (EqJet.refl _ _) (multiplication_match F G n h i) (EqJet.refl _ _)
+    have hh₁ : EqJet (n+1)
+        (pair F (multiplicationSeries F i) PowerSeries.X-pair G (multiplicationSeries G i) PowerSeries.X)
+        ((leading F G n).subst ![C (i:K)*PowerSeries.X,PowerSeries.X]+
+          (multiplicationSeries F i-multiplicationSeries G i)) := by
+      simpa only [sub_self,add_zero] using hh
+    have hh₂ := hh₁.trans ((EqJet.refl _ _).add ih)
+    simpa only [add_comm] using hh₂
+
+lemma homogeneous_sum {σ ι : Type*} (s : Finset ι) (f : ι → MvPowerSeries σ K) (n : ℕ)
+    (hf : ∀ i∈s,(f i).IsHomogeneous n) : (∑i∈s,f i).IsHomogeneous n := by
+  apply homogeneous_of_coeff
+  intro d hd; rw [map_sum]; apply Finset.sum_eq_zero
+  intro i hi
+  have hh : (f i).IsHomogeneous n := by exact hf i hi
+  exact hh.coeff_eq_zero hd
+
+lemma leading_trace_zero (F G : FormalGroup K) (n p : ℕ)
+    (h : EqJet n F.toPowerSeries G.toPowerSeries)
+    (hp : multiplicationSeries F p=multiplicationSeries G p) :
+    (∑i∈Finset.range p, (leading F G n).subst ![C (i:K)*PowerSeries.X,PowerSeries.X])=0 := by
+  have hh := multiplication_leading_trace F G n h p
+  rw [hp,sub_self] at hh
+  apply homogeneous_eq_of_jet _ (homogeneous_zero n) hh.symm
+  apply homogeneous_sum
+  intro i hi
+  apply linear_pair_homogeneous _ n (leading_homogeneous F G n)
+  · simp [PowerSeries.X]
+  · simp [PowerSeries.X]
+  · exact homogeneous_C_mul _ (homogeneous_X ())
+  · exact homogeneous_X ()
+
+theorem leading_isCocycle (F G : FormalGroup K) [F.IsComm] [G.IsComm] (n p : ℕ)
+    (h : EqJet n F.toPowerSeries G.toPowerSeries)
+    (hp : multiplicationSeries F p=multiplicationSeries G p) :
+    IsCocycle p (leading F G n) :=
+  ⟨(leading_axis F G n h).1,(leading_axis F G n h).2,leading_symmetric F G n h,
+    leading_associative F G n h,leading_trace_zero F G n p h hp⟩
+
+end HeightThree.HondaLeading
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/FormalGroup/Honda/Logarithm.lean b/lean/OAI/Algebra/FormalGroup/Honda/Logarithm.lean
new file mode 100644
index 0000000000000000000000000000000000000000..54a164e233863d7fe0c22244e6ae92e3cb1a17d5
--- /dev/null
+++ b/lean/OAI/Algebra/FormalGroup/Honda/Logarithm.lean
@@ -0,0 +1,175 @@
+import OAI.Algebra.FormalGroup.Honda.PTypical
+import OAI.Algebra.FormalGroup.Honda.Target
+
+namespace OAI
+
+noncomputable section
+
+namespace HeightThree.LogarithmicConstruction
+
+open MvPowerSeries
+
+variable {R : Type*} [CommRing R]
+
+structure StrictLog where
+  series : PowerSeries R
+  constant_zero : series.constantCoeff = 0
+  linear_one : series.coeff 1 = 1
+
+namespace StrictLog
+
+variable (l : StrictLog (R := R))
+
+lemma hasSubst : PowerSeries.HasSubst l.series :=
+  PowerSeries.HasSubst.of_constantCoeff_zero l.constant_zero
+
+lemma linear_unit : IsUnit (l.series.coeff 1) := l.linear_one ▸ isUnit_one
+
+def inv : PowerSeries R := l.series.substInvOfIsUnit l.linear_unit
+
+@[simp] lemma inv_constant : l.inv.constantCoeff = 0 :=
+  PowerSeries.constantCoeff_substInvOfIsUnit _ _
+
+lemma inv_hasSubst : PowerSeries.HasSubst l.inv :=
+  PowerSeries.HasSubst.of_constantCoeff_zero l.inv_constant
+
+@[simp] lemma subst_inv : l.series.subst l.inv = PowerSeries.X :=
+  PowerSeries.subst_substInvOfIsUnit_right _ l.constant_zero l.linear_unit
+
+@[simp] lemma inv_subst : l.inv.subst l.series = PowerSeries.X :=
+  PowerSeries.subst_substInvOfIsUnit_left _ l.constant_zero l.linear_unit
+
+@[simp] lemma inv_linear : l.inv.coeff 1 = 1 := by
+  rw [inv, PowerSeries.coeff_one_substInvOfIsUnit]
+  have h : l.linear_unit.unit = 1 := by
+    apply Units.ext
+    simpa using l.linear_one
+  rw [h]
+  rfl
+
+lemma log_exp {σ : Type*} (a : MvPowerSeries σ R) (ha : PowerSeries.HasSubst a) :
+    l.series.subst (l.inv.subst a) = a := by
+  rw [← PowerSeries.subst_comp_subst_apply l.inv_hasSubst ha, l.subst_inv,
+    PowerSeries.subst_X ha]
+
+lemma exp_log {σ : Type*} (a : MvPowerSeries σ R) (ha : PowerSeries.HasSubst a) :
+    l.inv.subst (l.series.subst a) = a := by
+  rw [← PowerSeries.subst_comp_subst_apply l.hasSubst ha, l.inv_subst,
+    PowerSeries.subst_X ha]
+
+lemma subst_injective {σ : Type*} {a b : MvPowerSeries σ R}
+    (ha : PowerSeries.HasSubst a) (hb : PowerSeries.HasSubst b)
+    (h : l.series.subst a = l.series.subst b) : a = b := by
+  have := congrArg (fun x : MvPowerSeries σ R => l.inv.subst x) h
+  simpa only [l.exp_log a ha, l.exp_log b hb] using this
+
+def sumSeries : MvPowerSeries (Fin 2) R :=
+  l.series.subst (X 0) + l.series.subst (X 1)
+
+@[simp] lemma sumSeries_constant : l.sumSeries.constantCoeff = 0 := by
+  simp only [sumSeries, map_add]
+  rw [PowerSeries.constantCoeff_subst_eq_zero (by simp) l.series l.constant_zero,
+    PowerSeries.constantCoeff_subst_eq_zero (by simp) l.series l.constant_zero, add_zero]
+
+lemma sumSeries_hasSubst : PowerSeries.HasSubst l.sumSeries :=
+  PowerSeries.HasSubst.of_constantCoeff_zero l.sumSeries_constant
+
+def law : MvPowerSeries (Fin 2) R := l.inv.subst l.sumSeries
+
+@[simp] lemma law_constant : l.law.constantCoeff = 0 :=
+  PowerSeries.constantCoeff_subst_eq_zero l.sumSeries_constant l.inv l.inv_constant
+
+@[simp] lemma log_law : l.series.subst l.law = l.sumSeries :=
+  l.log_exp _ l.sumSeries_hasSubst
+
+lemma coeff_subst_linear {σ : Type*} (f : PowerSeries R)
+    (a : MvPowerSeries σ R) (ha : a.constantCoeff = 0) (i : σ) :
+    coeff (Finsupp.single i 1) (f.subst a) =
+      f.coeff 1 * coeff (Finsupp.single i 1) a := by
+  classical
+  rw [PowerSeries.coeff_subst (PowerSeries.HasSubst.of_constantCoeff_zero ha),
+    finsum_eq_single _ 1]
+  · simp
+  · intro n hn
+    by_cases hn0 : n = 0
+    · subst n
+      simp [MvPowerSeries.coeff_one]
+    · have hlt : ((Finsupp.degree (Finsupp.single i 1 : σ →₀ ℕ) : ℕ) : ℕ∞) < (n : ℕ∞) := by
+        simpa using (show (1 : ℕ∞) < (n : ℕ∞) by exact_mod_cast (by omega : 1 < n))
+      rw [coeff_of_lt_order (lt_of_lt_of_le hlt
+        (le_order_pow_of_constantCoeff_eq_zero n ha)), smul_zero]
+
+@[simp] lemma sumSeries_linear (i : Fin 2) :
+    coeff (Finsupp.single i 1) l.sumSeries = 1 := by
+  simp only [sumSeries, map_add]
+  rw [coeff_subst_linear _ _ (by simp), coeff_subst_linear _ _ (by simp),
+    l.linear_one, one_mul, one_mul]
+  fin_cases i <;> simp [coeff_index_single_X]
+
+@[simp] lemma law_linear (i : Fin 2) :
+    coeff (Finsupp.single i 1) l.law = 1 := by
+  rw [law, coeff_subst_linear _ _ l.sumSeries_constant, l.inv_linear,
+    l.sumSeries_linear, one_mul]
+
+lemma subst_after_mv {σ τ : Type*} (f : PowerSeries R)
+    (a : MvPowerSeries σ R) (ha : PowerSeries.HasSubst a)
+    (b : σ → MvPowerSeries τ R) (hb : MvPowerSeries.HasSubst b) :
+    (f.subst a).subst b = f.subst (a.subst b) := by
+  exact MvPowerSeries.subst_comp_subst_apply ha.const hb f
+
+lemma law_pair {σ : Type*} (a b : MvPowerSeries σ R)
+    (ha : a.constantCoeff = 0) (hb : b.constantCoeff = 0) :
+    l.law.subst ![a, b] = l.inv.subst (l.series.subst a + l.series.subst b) := by
+  have hab : MvPowerSeries.HasSubst ![a, b] :=
+    hasSubst_of_constantCoeff_zero (by intro i; fin_cases i <;> assumption)
+  rw [law, subst_after_mv _ _ l.sumSeries_hasSubst _ hab]
+  congr 1
+  rw [sumSeries, MvPowerSeries.subst_add hab,
+    subst_after_mv _ _ (PowerSeries.HasSubst.X 0) _ hab,
+    subst_after_mv _ _ (PowerSeries.HasSubst.X 1) _ hab,
+    MvPowerSeries.subst_X hab, MvPowerSeries.subst_X hab]
+  rfl
+
+lemma law_pair_constant {σ : Type*} (a b : MvPowerSeries σ R)
+    (ha : a.constantCoeff = 0) (hb : b.constantCoeff = 0) :
+    (l.law.subst ![a, b]).constantCoeff = 0 := by
+  apply MvPowerSeries.constantCoeff_subst_eq_zero
+    (hasSubst_of_constantCoeff_zero (by intro i; fin_cases i <;> assumption))
+    (by intro i; fin_cases i <;> assumption) l.law_constant
+
+lemma log_law_pair {σ : Type*} (a b : MvPowerSeries σ R)
+    (ha : a.constantCoeff = 0) (hb : b.constantCoeff = 0) :
+    l.series.subst (l.law.subst ![a, b]) = l.series.subst a + l.series.subst b := by
+  rw [l.law_pair a b ha hb]
+  exact l.log_exp _ (PowerSeries.HasSubst.of_constantCoeff_zero (by
+    rw [map_add, PowerSeries.constantCoeff_subst_eq_zero ha _ l.constant_zero,
+      PowerSeries.constantCoeff_subst_eq_zero hb _ l.constant_zero, add_zero]))
+
+def formalGroup : FormalGroup R where
+  toPowerSeries := l.law
+  zero_constantCoeff := l.law_constant
+  lin_coeff_X := l.law_linear 0
+  lin_coeff_Y := l.law_linear 1
+  assoc := by
+    have hX (i : Fin 3) : (X i : MvPowerSeries (Fin 3) R).constantCoeff = 0 := by simp
+    apply l.subst_injective
+      (PowerSeries.HasSubst.of_constantCoeff_zero
+        (l.law_pair_constant _ _ (l.law_pair_constant _ _ (hX 0) (hX 1)) (hX 2)))
+      (PowerSeries.HasSubst.of_constantCoeff_zero
+        (l.law_pair_constant _ _ (hX 0) (l.law_pair_constant _ _ (hX 1) (hX 2))))
+    rw [l.log_law_pair _ _ (l.law_pair_constant _ _ (hX 0) (hX 1)) (hX 2),
+      l.log_law_pair _ _ (hX 0) (l.law_pair_constant _ _ (hX 1) (hX 2)),
+      l.log_law_pair _ _ (hX 0) (hX 1), l.log_law_pair _ _ (hX 1) (hX 2), add_assoc]
+
+instance formalGroup_isComm : l.formalGroup.IsComm where
+  comm := by
+    change l.law = l.law.subst ![X 1, X 0]
+    rw [l.law_pair _ _ (by simp) (by simp)]
+    exact congrArg (PowerSeries.subst · l.inv) (add_comm _ _)
+
+end StrictLog
+end HeightThree.LogarithmicConstruction
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/FormalGroup/Honda/Main.lean b/lean/OAI/Algebra/FormalGroup/Honda/Main.lean
new file mode 100644
index 0000000000000000000000000000000000000000..6d6bbb31f14919139907f035f00c0873719f4ec2
--- /dev/null
+++ b/lean/OAI/Algebra/FormalGroup/Honda/Main.lean
@@ -0,0 +1,43 @@
+import OAI.Algebra.FormalGroup.Honda.HeightTransport
+
+namespace OAI
+
+universe uK
+
+noncomputable section
+
+namespace HeightThree.HondaTarget
+open HeightThree.HondaConstruction HeightThree.HondaCoordinates HeightThree.HondaSpecialFiber
+open HeightThree.CanonicalUniversality HeightThree.HondaClassification
+open HeightThree.CoordinateTransport HeightThree.UniversalTransport HeightThree.HeightTransport
+
+theorem universal_framed_honda_height_coordinates
+    (p : ℕ) [Fact p.Prime] (_ : 5 ≤ p)
+    (K : Type uK) [Field K] [Finite K] [CharP K p]
+    (_ : Nonempty (GaloisField p 6 →+* K))
+    (Γ : FormalGroup K) [Γ.IsComm]
+    (hΓ : multiplicationSeries Γ p = PowerSeries.X ^ (p^3)) :
+    HasUniversalHeightCoordinates p Γ := by
+  obtain ⟨e,he⟩ := strict_honda_isomorphic p 3 Γ (hondaLaw p K) hΓ (integralSpecial_honda p K)
+  let c := Coordinate.ofIso e
+  let cB := c.map (algebraMap K (Base K))
+  have hc : c.transport (hondaLaw p K)=Γ := Coordinate.transport_ofIso e
+  have hcB : cB.map MvPowerSeries.constantCoeff=c := by
+    rw [show cB=c.map (algebraMap K (Base K)) from rfl,coordinate_map_map]
+    have hh : MvPowerSeries.constantCoeff.comp (algebraMap K (Base K))=RingHom.id K := by
+      ext a
+      simp [MvPowerSeries.algebraMap_apply]
+    rw [hh,coordinate_map_id]
+  have hs : cB.series.coeff 1=1 := strict_map c he _
+  refine ⟨cB.transport (reducedHonda p K),inferInstance,?_,?_,?_⟩
+  · rw [cB.transport_map,hcB,reducedHonda_specialFiber,hc]
+  · have hh := isUniversal_transport (hondaLaw p K) (reducedHonda p K)
+      (reducedHonda_isUniversal p K) c
+    rwa [hc] at hh
+  · exact heightCoordinates_transport p _ (reducedHonda_heightCoordinates p K) cB hs
+
+end HeightThree.HondaTarget
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/FormalGroup/Honda/NilpotentTower.lean b/lean/OAI/Algebra/FormalGroup/Honda/NilpotentTower.lean
new file mode 100644
index 0000000000000000000000000000000000000000..f46b60e831bc9eb6d873f0e1cce9206b151d1c55
--- /dev/null
+++ b/lean/OAI/Algebra/FormalGroup/Honda/NilpotentTower.lean
@@ -0,0 +1,85 @@
+import Mathlib
+
+namespace OAI
+
+noncomputable section
+
+namespace HeightThree.NilpotentTower
+variable {K R : Type*} [Field K] [CommRing R] [Algebra K R]
+
+def quotient (ρ : R →ₐ[K] K) (n : ℕ) := R ⧸ (RingHom.ker ρ)^(n+1)
+
+instance (ρ : R →ₐ[K] K) (n : ℕ) : CommRing (quotient ρ n) := inferInstanceAs (CommRing (R ⧸ _))
+instance (ρ : R →ₐ[K] K) (n : ℕ) : Algebra K (quotient ρ n) := inferInstanceAs (Algebra K (R ⧸ _))
+
+def projection (ρ : R →ₐ[K] K) (n : ℕ) : R →ₐ[K] quotient ρ n :=
+  Ideal.Quotient.mkₐ K _
+
+def augmentation (ρ : R →ₐ[K] K) (n : ℕ) : quotient ρ n →ₐ[K] K :=
+  Ideal.Quotient.liftₐ _ ρ (fun _ ha => Ideal.pow_le_self (Nat.succ_ne_zero _) ha)
+
+@[simp] lemma augmentation_projection (ρ : R →ₐ[K] K) (n : ℕ) (a : R) :
+    augmentation ρ n (projection ρ n a)=ρ a := rfl
+
+lemma projection_surjective (ρ : R →ₐ[K] K) (n : ℕ) :
+    Function.Surjective (projection ρ n) := Ideal.Quotient.mkₐ_surjective K _
+
+lemma projection_eq_zero (ρ : R →ₐ[K] K) (n : ℕ) (a : R) :
+    projection ρ n a=0 ↔ a∈(RingHom.ker ρ)^(n+1) := Ideal.Quotient.eq_zero_iff_mem
+
+lemma augmentation_ker (ρ : R →ₐ[K] K) (n : ℕ) :
+    RingHom.ker (augmentation ρ n)=Ideal.map (projection ρ n) (RingHom.ker ρ) := by
+  ext a
+  rw [Ideal.mem_map_iff_of_surjective _ (projection_surjective ρ n)]
+  constructor
+  · intro ha
+    obtain ⟨b,rfl⟩ := projection_surjective ρ n a
+    exact ⟨b,ha,rfl⟩
+  · rintro ⟨b,hb,rfl⟩
+    exact hb
+
+lemma augmentation_nilpotent (ρ : R →ₐ[K] K) (n : ℕ) :
+    (RingHom.ker (augmentation ρ n))^(n+1)=⊥ := by
+  rw [augmentation_ker,←Ideal.map_pow,Ideal.map_eq_bot_iff_le_ker]
+  intro a ha
+  exact (projection_eq_zero ρ n a).mpr ha
+
+lemma projection_ker_le (ρ : R →ₐ[K] K) (n : ℕ) (a : R)
+    (ha : projection ρ n a=0) : ρ a=0 := by
+  exact Ideal.pow_le_self (Nat.succ_ne_zero n) ((projection_eq_zero ρ n a).mp ha)
+
+lemma projection_annihilate (ρ : R →ₐ[K] K) (n : ℕ)
+    (h : (RingHom.ker ρ)^(n+2)=⊥) (a b : R)
+    (ha : projection ρ n a=0) (hb : ρ b=0) : a*b=0 := by
+  have hh := Ideal.mul_mem_mul ((projection_eq_zero ρ n a).mp ha) (show b∈RingHom.ker ρ from hb)
+  rw [←pow_succ,show n+1+1=n+2 by omega,h] at hh
+  exact hh
+
+lemma nilpotent_of_mem_ker (ρ : R →ₐ[K] K) {n : ℕ}
+    (h : (RingHom.ker ρ)^n=⊥) {a : R} (ha : ρ a=0) : IsNilpotent a := by
+  refine ⟨n,?_⟩
+  have hh := Ideal.pow_mem_pow (show a∈RingHom.ker ρ from ha) n
+  rw [h] at hh
+  exact hh
+
+lemma augmentation_surjective (ρ : R →ₐ[K] K) : Function.Surjective ρ := by
+  intro a; refine ⟨algebraMap K R a,?_⟩
+  simp
+
+lemma finite_local_nilpotent [IsLocalRing R] [FiniteDimensional K R] (ρ : R →ₐ[K] K) :
+    ∃ n, (RingHom.ker ρ)^(n+1)=⊥ := by
+  have : IsArtinianRing R := IsArtinianRing.of_finite K R
+  have hj := IsArtinianRing.isNilpotent_jacobson_bot (R := R)
+  rw [IsLocalRing.jacobson_eq_maximalIdeal _ bot_ne_top,
+    ←IsLocalRing.ker_eq_maximalIdeal ρ.toRingHom (augmentation_surjective ρ)] at hj
+  obtain ⟨n,hn⟩ := hj
+  change (RingHom.ker ρ)^n=0 at hn
+  refine ⟨n,?_⟩
+  rw [pow_succ,hn,zero_mul]
+  rfl
+
+end HeightThree.NilpotentTower
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/FormalGroup/Honda/PTypical.lean b/lean/OAI/Algebra/FormalGroup/Honda/PTypical.lean
new file mode 100644
index 0000000000000000000000000000000000000000..a8af648038efdd91a68c16f928c816f446fb9bbd
--- /dev/null
+++ b/lean/OAI/Algebra/FormalGroup/Honda/PTypical.lean
@@ -0,0 +1,513 @@
+import Mathlib
+
+namespace OAI
+
+noncomputable section
+
+namespace HeightThree.PTypical
+
+variable {A B : Type*} [CommRing A] [CommRing B]
+
+def series (p : ℕ) (c : ℕ → B) : PowerSeries B :=
+  PowerSeries.mk (Function.extend (fun n : ℕ => p^n) c (fun _ => 0))
+
+@[simp] theorem coeff_series_power (p : ℕ) (hp : 2 ≤ p) (c : ℕ → B) (n : ℕ) :
+    (series p c).coeff (p^n) = c n := by
+  simp only [series, PowerSeries.coeff_mk, (Nat.pow_right_injective hp).extend_apply]
+
+@[simp] theorem coeff_series_outside (p j : ℕ) (c : ℕ → B)
+    (hj : ¬ ∃ n : ℕ, p^n = j) : (series p c).coeff j = 0 := by
+  simp only [series, PowerSeries.coeff_mk, Function.extend_apply' c (fun _ => 0) j hj]
+
+@[simp] theorem series_constant (p : ℕ) (hp : 2 ≤ p) (c : ℕ → B) :
+    (series p c).constantCoeff = 0 := by
+  rw [← PowerSeries.coeff_zero_eq_constantCoeff]
+  exact coeff_series_outside p 0 c (by
+    rintro ⟨n, hn⟩
+    exact pow_ne_zero n (by omega : p ≠ 0) hn)
+
+@[simp] theorem series_linear (p : ℕ) (hp : 2 ≤ p) (c : ℕ → B) :
+    (series p c).coeff 1 = c 0 := by
+  simpa only [pow_zero] using coeff_series_power p hp c 0
+
+def HasIntegralNumerators [Algebra ℚ B] (ι : A →+* B) (p : ℕ)
+    (f : PowerSeries B) : Prop :=
+  ∀ j, (f.coeff j = 0) ∨
+    ∃ n : ℕ, j = p^n ∧ ∃ a : A, f.coeff j = ((p : ℚ)⁻¹)^n • ι a
+
+theorem series_integralNumerators [Algebra ℚ B] (ι : A →+* B)
+    (p : ℕ) (hp : 2 ≤ p) (a : ℕ → A) :
+    HasIntegralNumerators ι p (series p (fun n => ((p : ℚ)⁻¹)^n • ι (a n))) := by
+  intro j
+  by_cases hj : ∃ n : ℕ, p^n = j
+  · obtain ⟨n, rfl⟩ := hj
+    right
+    exact ⟨n, rfl, a n, coeff_series_power p hp _ n⟩
+  · exact Or.inl (coeff_series_outside p j _ hj)
+
+def IntegralSeries (ι : A →+* B) {σ : Type*} (f : MvPowerSeries σ B) : Prop :=
+  ∀ d, ∃ a : A, ι a = MvPowerSeries.coeff d f
+
+def integralLift (ι : A →+* B) {σ : Type*} (f : MvPowerSeries σ B)
+    (hf : IntegralSeries ι f) : MvPowerSeries σ A :=
+  fun d => (hf d).choose
+
+theorem map_integralLift (ι : A →+* B) {σ : Type*} (f : MvPowerSeries σ B)
+    (hf : IntegralSeries ι f) : MvPowerSeries.map ι (integralLift ι f hf) = f := by
+  ext d
+  exact (hf d).choose_spec
+
+theorem integral_iff_range (ι : A →+* B) {σ : Type*} (f : MvPowerSeries σ B) :
+    IntegralSeries ι f ↔ f ∈ (MvPowerSeries.map ι : MvPowerSeries σ A →+*
+      MvPowerSeries σ B).range := by
+  constructor
+  · intro hf
+    exact ⟨integralLift ι f hf, map_integralLift ι f hf⟩
+  · rintro ⟨a, rfl⟩ d
+    exact ⟨MvPowerSeries.coeff d a, by simp⟩
+
+theorem power_difference (p n : ℕ) {σ : Type*}
+    {a b : MvPowerSeries σ A} (h : (p : MvPowerSeries σ A) ∣ a - b) :
+    ∃ v : MvPowerSeries σ A,
+      a^(p^n) - b^(p^n) = (p : MvPowerSeries σ A)^(n+1) * v :=
+  dvd_sub_pow_of_dvd_sub h n
+
+theorem rational_cancel (p : ℕ) (hp : p ≠ 0) (n : ℕ) [Algebra ℚ B] (x : B) :
+    (((p : ℚ)⁻¹)^n) • ((p : B)^(n+1) * x) = (p : B) * x := by
+  have hpQ : (p : ℚ) ≠ 0 := by exact_mod_cast hp
+  have hc : (((p : ℚ)⁻¹)^n) • ((p : B)^n) = 1 := by
+    rw [Algebra.smul_def]
+    calc
+      _ = algebraMap ℚ B ((((p : ℚ)⁻¹)^n) * (p : ℚ)^n) := by simp
+      _ = 1 := by simp [hpQ]
+  rw [pow_succ, mul_assoc, ← smul_mul_assoc, hc, one_mul]
+
+theorem logarithm_difference [Algebra ℚ B] (ι : A →+* B) (p : ℕ)
+    (hp : p ≠ 0) (f : PowerSeries B) (hf : HasIntegralNumerators ι p f)
+    {σ : Type*} (a b : MvPowerSeries σ A)
+    (ha : a.constantCoeff = 0) (hb : b.constantCoeff = 0)
+    (hab : (p : MvPowerSeries σ A) ∣ a - b) :
+    ∃ v : MvPowerSeries σ A,
+      f.subst (a.map ι) - f.subst (b.map ι) =
+        (p : MvPowerSeries σ B) * v.map ι := by
+  classical
+  let θ : A →+ B := (AddMonoidHom.mulLeft (p : B)).comp ι.toAddMonoidHom
+  have ha' : PowerSeries.HasSubst (a.map ι) :=
+    PowerSeries.HasSubst.of_constantCoeff_zero (by simp [ha])
+  have hb' : PowerSeries.HasSubst (b.map ι) :=
+    PowerSeries.HasSubst.of_constantCoeff_zero (by simp [hb])
+  have hc (d : σ →₀ ℕ) :
+      MvPowerSeries.coeff d (f.subst (a.map ι) - f.subst (b.map ι)) ∈ θ.range := by
+    rw [map_sub, PowerSeries.coeff_subst ha', PowerSeries.coeff_subst hb',
+      ← finsum_sub_distrib (PowerSeries.coeff_subst_finite ha' f d)
+        (PowerSeries.coeff_subst_finite hb' f d)]
+    refine finsum_induction (fun z => z ∈ θ.range) θ.range.zero_mem
+      (fun _ _ => θ.range.add_mem) ?_
+    intro j
+    rcases hf j with hzero | ⟨n, rfl, u, hu⟩
+    · simp [hzero]
+    obtain ⟨w, hw⟩ := power_difference p n hab
+    have hwc : ι (MvPowerSeries.coeff d (a^(p^n))) -
+        ι (MvPowerSeries.coeff d (b^(p^n))) =
+          (p : B)^(n+1) * ι (MvPowerSeries.coeff d w) := by
+      have hh := congrArg (fun z => ι (MvPowerSeries.coeff d z)) hw
+      rw [map_sub, map_sub] at hh
+      rw [← map_natCast (MvPowerSeries.C (σ := σ) (R := A)), ← map_pow,
+        MvPowerSeries.coeff_C_mul] at hh
+      simpa using hh
+    refine ⟨u * MvPowerSeries.coeff d w, ?_⟩
+    change (p : B) * ι (u * MvPowerSeries.coeff d w) = _
+    simp only [hu, ← map_pow, MvPowerSeries.coeff_map, smul_eq_mul,
+      ← mul_sub, hwc]
+    rw [smul_mul_assoc]
+    calc
+      (p : B) * ι (u * MvPowerSeries.coeff d w) =
+          ((p : ℚ)⁻¹)^n • ((p : B)^(n+1) * (ι u * ι (MvPowerSeries.coeff d w))) := by
+            rw [rational_cancel p hp, map_mul]
+      _ = ((p : ℚ)⁻¹)^n • (ι u * ((p : B)^(n+1) * ι (MvPowerSeries.coeff d w))) := by
+            congr 1
+            ring
+  choose v hv using hc
+  refine ⟨fun d => v d, ?_⟩
+  ext d
+  have hh := hv d
+  change (p : B) * ι (v d) = _ at hh
+  rw [← map_natCast (MvPowerSeries.C (σ := σ) (R := B)), MvPowerSeries.coeff_C_mul]
+  change _ = (p : B) * ι (v d)
+  exact hh.symm
+
+lemma constant_dvd_iff {σ : Type*} (r : A) (a : MvPowerSeries σ A) :
+    MvPowerSeries.C r ∣ a ↔ ∀ d, r ∣ MvPowerSeries.coeff d a := by
+  constructor
+  · rintro ⟨b, rfl⟩ d
+    exact ⟨MvPowerSeries.coeff d b, MvPowerSeries.coeff_C_mul d b r⟩
+  · intro h
+    choose b hb using h
+    let c : MvPowerSeries σ A := fun d => b d
+    refine ⟨c, ?_⟩
+    ext d
+    exact (hb d).trans (MvPowerSeries.coeff_C_mul d c r).symm
+
+theorem frobenius_lift_series (p : ℕ) [hp : Fact p.Prime]
+    (ψ : A →+* A) (hψ : ∀ a : A, (p : A) ∣ ψ a - a^p)
+    {σ : Type*} (a : MvPowerSeries σ A) :
+    (p : MvPowerSeries σ A) ∣
+      (a.map ψ).expand p hp.out.ne_zero - a^p := by
+  by_cases hu : IsUnit (p : A)
+  · have hu' : IsUnit (p : MvPowerSeries σ A) := by
+      simpa using hu.map (MvPowerSeries.C (σ := σ) (R := A))
+    exact hu'.dvd
+  let I : Ideal A := Ideal.span {(p : A)}
+  let π : A →+* A ⧸ I := Ideal.Quotient.mk I
+  let : CharP (A ⧸ I) p := CharP.quotient A p hu
+  have hπ : π.comp ψ = (frobenius (A ⧸ I) p).comp π := by
+    ext x
+    change π (ψ x) = (π x)^p
+    rw [← map_pow, Ideal.Quotient.eq, Ideal.mem_span_singleton]
+    exact hψ x
+  have heq : (((a.map ψ).expand p hp.out.ne_zero) - a^p).map π = 0 := by
+    rw [map_sub, MvPowerSeries.map_expand, MvPowerSeries.map_map, hπ,
+      ← MvPowerSeries.map_map, ← MvPowerSeries.map_expand,
+      MvPowerSeries.map_frobenius_expand, map_pow, sub_self]
+  rw [← map_natCast (MvPowerSeries.C (σ := σ) (R := A)), constant_dvd_iff]
+  intro d
+  have hd := congrArg (MvPowerSeries.coeff d) heq
+  rw [MvPowerSeries.coeff_map, map_zero] at hd
+  exact Ideal.mem_span_singleton.mp (Ideal.Quotient.eq_zero_iff_mem.mp hd)
+
+def twist {σ : Type*} (p : ℕ) (hp : p ≠ 0) (ψ : A →+* A) :
+    MvPowerSeries σ A →+* MvPowerSeries σ A :=
+  (MvPowerSeries.expand p hp).toRingHom.comp (MvPowerSeries.map ψ)
+
+@[simp] lemma twist_coe {σ : Type*} (p : ℕ) (hp : p ≠ 0) (ψ : A →+* A)
+    (a : MvPowerSeries σ A) : twist p hp ψ a = (a.map ψ).expand p hp := rfl
+
+theorem twist_iterate_congr (p : ℕ) [hp : Fact p.Prime]
+    (ψ : A →+* A) (hψ : ∀ a : A, (p : A) ∣ ψ a - a^p)
+    {σ : Type*} (a : MvPowerSeries σ A) (n : ℕ) :
+    (p : MvPowerSeries σ A) ∣
+      (twist p hp.out.ne_zero ψ ^ n) a - a^(p^n) := by
+  induction n with
+  | zero => simp
+  | succ n ih =>
+    rw [pow_succ', pow_succ, pow_mul]
+    change (p : MvPowerSeries σ A) ∣
+      twist p hp.out.ne_zero ψ ((twist p hp.out.ne_zero ψ ^ n) a) - (a^(p^n))^p
+    have h₁ := frobenius_lift_series p ψ hψ ((twist p hp.out.ne_zero ψ ^ n) a)
+    have h₂ := ih.trans (sub_dvd_pow_sub_pow _ _ p)
+    simpa only [twist_coe, sub_add_sub_cancel] using dvd_add h₁ h₂
+
+theorem twist_iterate {σ : Type*} (p : ℕ) (hp : p ≠ 0) (ψ : A →+* A)
+    (a : MvPowerSeries σ A) (n : ℕ) :
+    (twist p hp ψ ^ n) a = (a.map (ψ^n)).expand (p^n) (pow_ne_zero n hp) := by
+  induction n with
+  | zero =>
+    change a = (a.map (RingHom.id A)).expand 1 _
+    simp [MvPowerSeries.map_id]
+  | succ n ih =>
+    rw [pow_succ']
+    change twist p hp ψ ((twist p hp ψ ^ n) a) = _
+    rw [ih, twist_coe, MvPowerSeries.map_expand, MvPowerSeries.map_map,
+      ← MvPowerSeries.expand_mul]
+    simp only [pow_succ', RingHom.mul_def]
+
+@[simp] theorem twist_iterate_constant {σ : Type*} (p : ℕ) (hp : p ≠ 0) (ψ : A →+* A)
+    (a : MvPowerSeries σ A) (n : ℕ) :
+    ((twist p hp ψ ^ n) a).constantCoeff = (ψ^n) a.constantCoeff := by
+  simp [twist_iterate]
+
+theorem map_twist_iterate {σ : Type*} (p : ℕ) (hp : p ≠ 0)
+    (ι : A →+* B) (ψ : A →+* A) (χ : B →+* B) (hc : χ.comp ι = ι.comp ψ)
+    (a : MvPowerSeries σ A) (n : ℕ) :
+    (MvPowerSeries.map ι) ((twist p hp ψ ^ n) a) =
+      (twist p hp χ ^ n) (a.map ι) := by
+  induction n with
+  | zero => rfl
+  | succ n ih =>
+    rw [pow_succ' (twist p hp ψ), pow_succ' (twist p hp χ)]
+    change (twist p hp ψ ((twist p hp ψ ^ n) a)).map ι =
+      twist p hp χ ((twist p hp χ ^ n) (a.map ι))
+    rw [twist_coe, twist_coe, MvPowerSeries.map_expand, ← ih,
+      MvPowerSeries.map_map, MvPowerSeries.map_map, hc]
+
+theorem twist_iterate_subst {σ : Type*} (p : ℕ) (hp : p ≠ 0) (ψ : A →+* A)
+    (f : PowerSeries A) (a : MvPowerSeries σ A) (ha : PowerSeries.HasSubst a) (n : ℕ) :
+    (twist p hp ψ ^ n) (f.subst a) =
+      (f.map (ψ^n)).subst ((twist p hp ψ ^ n) a) := by
+  rw [twist_iterate, twist_iterate, PowerSeries.map_subst ha,
+    PowerSeries.expand_subst _ _ (show PowerSeries.HasSubst (a.map (ψ^n)) from by
+      simpa only [PowerSeries.HasSubst, MvPowerSeries.constantCoeff_map] using ha.map (ψ^n))]
+
+theorem integralNumerators_map [Algebra ℚ B] (ι : A →+* B)
+    (ψ : A →+* A) (χ : B →ₐ[ℚ] B) (hc : χ.toRingHom.comp ι = ι.comp ψ)
+    (p : ℕ) (f : PowerSeries B) (hf : HasIntegralNumerators ι p f) :
+    HasIntegralNumerators ι p (f.map χ.toRingHom) := by
+  intro j
+  rw [PowerSeries.coeff_map]
+  rcases hf j with h | ⟨n, hn, a, ha⟩
+  · left; simp [h]
+  · right
+    refine ⟨n, hn, ψ a, ?_⟩
+    rw [ha]
+    change χ (((p : ℚ)⁻¹)^n • ι a) = _
+    rw [χ.map_smul_of_tower]
+    congr 1
+    exact DFunLike.congr_fun hc a
+
+theorem integralNumerators_map_iterate [Algebra ℚ B] (ι : A →+* B)
+    (ψ : A →+* A) (χ : B →ₐ[ℚ] B) (hc : χ.toRingHom.comp ι = ι.comp ψ)
+    (p : ℕ) (f : PowerSeries B) (hf : HasIntegralNumerators ι p f) (n : ℕ) :
+    HasIntegralNumerators ι p (f.map (χ.toRingHom^n)) := by
+  induction n with
+  | zero => exact hf
+  | succ n ih =>
+    rw [pow_succ']
+    exact integralNumerators_map ι ψ χ hc p _ ih
+
+theorem order_difference_powers {σ : Type*} (a b : MvPowerSeries σ A)
+    (ha : a.constantCoeff = 0) (hb : b.constantCoeff = 0) (n : ℕ)
+    (hab : (n : ℕ∞) ≤ (a - b).order) (k : ℕ) :
+    ((n+k : ℕ) : ℕ∞) ≤ (a^(k+1) - b^(k+1)).order := by
+  induction k with
+  | zero => simpa using hab
+  | succ k ih =>
+    have heq : a^(k+1+1) - b^(k+1+1) =
+        a * (a^(k+1) - b^(k+1)) + (a-b) * b^(k+1) := by ring
+    rw [heq]
+    apply le_trans _ MvPowerSeries.min_order_le_add
+    apply le_min
+    · apply le_trans _ MvPowerSeries.le_order_mul
+      calc
+        ((n+(k+1) : ℕ) : ℕ∞) = 1 + ((n+k : ℕ) : ℕ∞) := by push_cast; ac_rfl
+        _ ≤ a.order + (a^(k+1) - b^(k+1)).order := add_le_add
+          (MvPowerSeries.one_le_order_iff_constCoeff_eq_zero.mpr ha) ih
+    · apply le_trans _ MvPowerSeries.le_order_mul
+      calc
+        ((n+(k+1) : ℕ) : ℕ∞) = (n : ℕ∞) + ((k+1 : ℕ) : ℕ∞) := by simp
+        _ ≤ (a-b).order + (b^(k+1)).order := add_le_add hab
+          (MvPowerSeries.le_order_pow_of_constantCoeff_eq_zero (k+1) hb)
+
+theorem coeff_log_difference {σ : Type*} (f : PowerSeries A) (hf : f.coeff 1 = 1)
+    (a b : MvPowerSeries σ A) (ha : a.constantCoeff = 0) (hb : b.constantCoeff = 0)
+    (n : ℕ) (hab : (n : ℕ∞) ≤ (a-b).order) (d : σ →₀ ℕ) (hd : d.degree ≤ n) :
+    MvPowerSeries.coeff d (f.subst a - f.subst b) = MvPowerSeries.coeff d (a-b) := by
+  have ha' := PowerSeries.HasSubst.of_constantCoeff_zero ha
+  have hb' := PowerSeries.HasSubst.of_constantCoeff_zero hb
+  rw [map_sub, PowerSeries.coeff_subst ha', PowerSeries.coeff_subst hb',
+    ← finsum_sub_distrib (PowerSeries.coeff_subst_finite ha' f d)
+      (PowerSeries.coeff_subst_finite hb' f d), finsum_eq_single _ 1]
+  · simp [hf]
+  · intro j hj
+    rw [← smul_sub, ← map_sub]
+    by_cases hj0 : j = 0
+    · simp [hj0]
+    · obtain ⟨k, rfl⟩ := Nat.exists_eq_succ_of_ne_zero hj0
+      have hk : 0 < k := by omega
+      have hlt : (d.degree : ℕ∞) < ((n+k : ℕ) : ℕ∞) := by exact_mod_cast (by omega : d.degree < n+k)
+      rw [MvPowerSeries.coeff_of_lt_order (hlt.trans_le
+        (order_difference_powers a b ha hb n hab k)), smul_zero]
+
+theorem order_log_difference {σ : Type*} (f : PowerSeries A) (hf : f.coeff 1 = 1)
+    (a b : MvPowerSeries σ A) (ha : a.constantCoeff = 0) (hb : b.constantCoeff = 0)
+    (n : ℕ) (hab : (n : ℕ∞) ≤ (a-b).order) :
+    (n : ℕ∞) ≤ (f.subst a - f.subst b).order := by
+  apply MvPowerSeries.nat_le_order
+  intro d hd
+  rw [coeff_log_difference f hf a b ha hb n hab d hd.le]
+  exact MvPowerSeries.coeff_of_lt_order (lt_of_lt_of_le (by exact_mod_cast hd) hab)
+
+theorem coeff_twist_iterate_zero {σ : Type*} (p : ℕ) (hp : 2 ≤ p)
+    (ψ : A →+* A) (a : MvPowerSeries σ A) (k : ℕ) (hk : 0 < k)
+    (n : ℕ) (hn : 0 < n) (ha : (n : ℕ∞) ≤ a.order)
+    (d : σ →₀ ℕ) (hd : d.degree ≤ n) :
+    MvPowerSeries.coeff d ((twist p (by omega) ψ ^ k) a) = 0 := by
+  rw [twist_iterate]
+  apply MvPowerSeries.coeff_of_lt_order
+  rw [MvPowerSeries.order_expand, nsmul_eq_mul]
+  have hpk : 1 < p^k := one_lt_pow₀ (by omega) (by omega)
+  have hlt : d.degree < p^k * n := lt_of_le_of_lt hd (by nlinarith)
+  calc
+    (d.degree : ℕ∞) < ((p^k * n : ℕ) : ℕ∞) := by exact_mod_cast hlt
+    _ = (p^k : ℕ) * (n : ℕ∞) := by simp
+    _ ≤ (p^k : ℕ) * (a.map (ψ^k)).order := by
+      gcongr
+      exact ha.trans (MvPowerSeries.le_order_map _)
+
+theorem subst_twist_iterate {σ : Type*} (p : ℕ) (hp : p ≠ 0) (ψ : A →+* A)
+    (f : PowerSeries A) (a : MvPowerSeries σ A) (ha : PowerSeries.HasSubst a) (n : ℕ) :
+    PowerSeries.subst a ((twist p hp ψ ^ n) f) = (f.map (ψ^n)).subst (a^(p^n)) := by
+  rw [twist_iterate]
+  change ((f.map (ψ^n)).expand (p^n) (pow_ne_zero n hp)).subst a = _
+  rw [PowerSeries.expand_apply, PowerSeries.subst_comp_subst_apply
+    (PowerSeries.HasSubst.X_pow (pow_ne_zero n hp)) ha,
+    PowerSeries.subst_pow ha, PowerSeries.subst_X ha]
+
+lemma divide_p_mul [Algebra ℚ B] (p : ℕ) (hp : p ≠ 0) (x : B) :
+    (p : ℚ)⁻¹ • ((p : B) * x) = x := by
+  have h : (p : B) * x = (p : ℚ) • x := by simp [Algebra.smul_def]
+  rw [h, inv_smul_smul₀ (by exact_mod_cast hp : (p : ℚ) ≠ 0)]
+
+def defect [Algebra ℚ B] {σ : Type*} (p : ℕ) (hp : p ≠ 0)
+    (χ : B →+* B) (v : Fin 3 → B) (f : MvPowerSeries σ B) : MvPowerSeries σ B :=
+  f - ∑ i : Fin 3, (p : ℚ)⁻¹ • (v i • ((twist p hp χ ^ (i.val+1)) f))
+
+lemma defect_add [Algebra ℚ B] {σ : Type*} (p : ℕ) (hp : p ≠ 0)
+    (χ : B →+* B) (v : Fin 3 → B) (f g : MvPowerSeries σ B) :
+    defect p hp χ v (f+g) = defect p hp χ v f + defect p hp χ v g := by
+  simp only [defect, map_add, smul_add, Finset.sum_add_distrib]
+  abel
+
+lemma defect_sub [Algebra ℚ B] {σ : Type*} (p : ℕ) (hp : p ≠ 0)
+    (χ : B →+* B) (v : Fin 3 → B) (f g : MvPowerSeries σ B) :
+    defect p hp χ v (f-g) = defect p hp χ v f - defect p hp χ v g := by
+  simp only [defect, map_sub, smul_sub, Finset.sum_sub_distrib]
+  abel
+
+theorem coeff_defect_le [Algebra ℚ B] {σ : Type*} (p : ℕ) (hp : 2 ≤ p)
+    (χ : B →+* B) (v : Fin 3 → B) (f : MvPowerSeries σ B)
+    (n : ℕ) (hn : 0 < n) (hf : (n : ℕ∞) ≤ f.order)
+    (d : σ →₀ ℕ) (hd : d.degree ≤ n) :
+    MvPowerSeries.coeff d (defect p (by omega) χ v f) = MvPowerSeries.coeff d f := by
+  simp only [defect, map_sub, map_sum]
+  have hz (i : Fin 3) : MvPowerSeries.coeff d
+      ((p : ℚ)⁻¹ • (v i • ((twist p (by omega) χ ^ (i.val+1)) f))) = 0 := by
+    rw [(MvPowerSeries.coeff d).map_smul_of_tower, MvPowerSeries.coeff_smul,
+      coeff_twist_iterate_zero p hp χ f (i.val+1) (by omega) n hn hf d hd,
+      mul_zero, smul_zero]
+  simp only [hz, Finset.sum_const_zero, sub_zero]
+
+theorem defect_subst_eq [Algebra ℚ B] {σ : Type*} (p : ℕ) (hp : p ≠ 0)
+    (χ : B →+* B) (v : Fin 3 → B) (f : PowerSeries B)
+    (hf : defect p hp χ v f = PowerSeries.X)
+    (a : MvPowerSeries σ B) (ha : PowerSeries.HasSubst a) :
+    defect p hp χ v (f.subst a) = a + ∑ i : Fin 3,
+      (p : ℚ)⁻¹ • (v i • ((f.map (χ^(i.val+1))).subst (a^(p^(i.val+1))) -
+        (f.map (χ^(i.val+1))).subst ((twist p hp χ ^ (i.val+1)) a))) := by
+  have hsum : PowerSeries.subst a (∑ i : Fin 3,
+        (p : ℚ)⁻¹ • (v i • ((twist p hp χ ^ (i.val+1)) f))) =
+      ∑ i : Fin 3, (p : ℚ)⁻¹ • (v i •
+        (f.map (χ^(i.val+1))).subst (a^(p^(i.val+1)))) := by
+    rw [← PowerSeries.coe_substAlgHom ha, map_sum]
+    apply Finset.sum_congr rfl
+    intro i _
+    rw [AlgHom.map_smul_of_tower, AlgHom.map_smul_of_tower,
+      PowerSeries.coe_substAlgHom, subst_twist_iterate p hp χ f a ha]
+  have he := congrArg (PowerSeries.subst a) hf
+  rw [defect, PowerSeries.subst_sub ha, hsum, PowerSeries.subst_X ha] at he
+  have he' := sub_eq_iff_eq_add.mp he
+  simp only [defect, twist_iterate_subst p hp χ f a ha]
+  rw [he']
+  simp only [smul_sub, Finset.sum_sub_distrib]
+  abel
+
+lemma IntegralSeries.add (ι : A →+* B) {σ : Type*} {f g : MvPowerSeries σ B}
+    (hf : IntegralSeries ι f) (hg : IntegralSeries ι g) : IntegralSeries ι (f+g) := by
+  rw [integral_iff_range] at hf hg ⊢
+  exact Subring.add_mem _ hf hg
+
+lemma IntegralSeries.sub (ι : A →+* B) {σ : Type*} {f g : MvPowerSeries σ B}
+    (hf : IntegralSeries ι f) (hg : IntegralSeries ι g) : IntegralSeries ι (f-g) := by
+  rw [integral_iff_range] at hf hg ⊢
+  exact Subring.sub_mem _ hf hg
+
+lemma integral_map (ι : A →+* B) {σ : Type*} (a : MvPowerSeries σ A) :
+    IntegralSeries ι (a.map ι) := by
+  rw [integral_iff_range]
+  exact ⟨a, rfl⟩
+
+lemma IntegralSeries.sum (ι : A →+* B) {σ τ : Type*} (s : Finset τ)
+    (f : τ → MvPowerSeries σ B) (hf : ∀ i ∈ s, IntegralSeries ι (f i)) :
+    IntegralSeries ι (∑ i ∈ s, f i) := by
+  apply (integral_iff_range ι _).mpr
+  exact Subring.sum_mem _ fun i hi => (integral_iff_range ι _).mp (hf i hi)
+
+theorem defect_log_integral [Algebra ℚ B] (ι : A →+* B) (p : ℕ) [hp : Fact p.Prime]
+    (ψ : A →+* A) (χ : B →ₐ[ℚ] B) (hc : χ.toRingHom.comp ι = ι.comp ψ)
+    (hψ : ∀ a : A, (p : A) ∣ ψ a - a^p)
+    (v : Fin 3 → A) (f : PowerSeries B) (hf : HasIntegralNumerators ι p f)
+    (he : defect p hp.out.ne_zero χ.toRingHom (ι ∘ v) f = PowerSeries.X)
+    {σ : Type*} (a : MvPowerSeries σ A) (ha : a.constantCoeff = 0) :
+    IntegralSeries ι (defect p hp.out.ne_zero χ.toRingHom (ι ∘ v) (f.subst (a.map ι))) := by
+  have ha' : PowerSeries.HasSubst (a.map ι) :=
+    PowerSeries.HasSubst.of_constantCoeff_zero (by simp [ha])
+  rw [defect_subst_eq p hp.out.ne_zero χ.toRingHom (ι ∘ v) f he _ ha']
+  apply (integral_map ι a).add
+  apply IntegralSeries.sum
+  intro i _
+  have hi0 : p^(i.val+1) ≠ 0 := pow_ne_zero _ hp.out.ne_zero
+  have haPow : (a^(p^(i.val+1))).constantCoeff = 0 := by
+    rw [map_pow, ha, zero_pow hi0]
+  have haTw : ((twist p hp.out.ne_zero ψ ^ (i.val+1)) a).constantCoeff = 0 := by
+    rw [twist_iterate_constant, ha, map_zero]
+  obtain ⟨w, hw⟩ := logarithm_difference ι p hp.out.ne_zero
+    (f.map (χ.toRingHom^(i.val+1)))
+    (integralNumerators_map_iterate ι ψ χ hc p f hf (i.val+1))
+    (a^(p^(i.val+1))) ((twist p hp.out.ne_zero ψ ^ (i.val+1)) a)
+    haPow haTw ((dvd_sub_comm).mp (twist_iterate_congr p ψ hψ a (i.val+1)))
+  rw [map_pow, map_twist_iterate p hp.out.ne_zero ι ψ χ.toRingHom hc] at hw
+  rw [hw, smul_comm, divide_p_mul p hp.out.ne_zero]
+  have hm : (ι (v i)) • w.map ι = (v i • w).map ι := by
+    simp only [MvPowerSeries.smul_eq_C_mul, map_mul, MvPowerSeries.map_C]
+  change IntegralSeries ι (ι (v i) • w.map ι)
+  rw [hm]
+  exact integral_map ι _
+
+theorem integral_of_defect_log [Algebra ℚ B] (ι : A →+* B) (p : ℕ) [hp : Fact p.Prime]
+    (ψ : A →+* A) (χ : B →ₐ[ℚ] B) (hc : χ.toRingHom.comp ι = ι.comp ψ)
+    (hψ : ∀ a : A, (p : A) ∣ ψ a - a^p)
+    (v : Fin 3 → A) (f : PowerSeries B) (hf : HasIntegralNumerators ι p f)
+    (he : defect p hp.out.ne_zero χ.toRingHom (ι ∘ v) f = PowerSeries.X)
+    (hf1 : f.coeff 1 = 1)
+    {σ : Type*} (g : MvPowerSeries σ B) (hg : g.constantCoeff = 0)
+    (hint : IntegralSeries ι (defect p hp.out.ne_zero χ.toRingHom (ι ∘ v) (f.subst g))) :
+    IntegralSeries ι g := by
+  classical
+  have main : ∀ n : ℕ, ∀ d : σ →₀ ℕ, d.degree = n → ∃ u : A, ι u = MvPowerSeries.coeff d g := by
+    intro n
+    induction n using Nat.strong_induction_on with
+    | h n ih =>
+      intro d hd
+      by_cases hn : n = 0
+      · have hd0 : d = 0 := Finsupp.degree_eq_zero_iff d |>.mp (hd.trans hn)
+        subst d
+        exact ⟨0, by simpa using hg.symm⟩
+      have hnpos : 0 < n := Nat.pos_of_ne_zero hn
+      let a : MvPowerSeries σ A := fun e =>
+        if e = 0 then 0 else if he : e.degree < n then (ih e.degree he e rfl).choose else 0
+      have haC (e : σ →₀ ℕ) : MvPowerSeries.coeff e a =
+          if e = 0 then 0 else if he : e.degree < n then (ih e.degree he e rfl).choose else 0 := rfl
+      have ha0 : a.constantCoeff = 0 := by
+        rw [← MvPowerSeries.coeff_zero_eq_constantCoeff_apply, haC, ite_eq_left rfl]
+      have hao : (n : ℕ∞) ≤ (g - a.map ι).order := by
+        apply MvPowerSeries.nat_le_order
+        intro e he
+        rw [map_sub, MvPowerSeries.coeff_map, haC]
+        by_cases he0 : e = 0
+        · subst e
+          simpa using hg
+        · rw [ite_eq_right he0, dite_eq_left he, (ih e.degree he e rfl).choose_spec, sub_self]
+      have ham0 : (a.map ι).constantCoeff = 0 := by simp [ha0]
+      have hia := defect_log_integral ι p ψ χ hc hψ v f hf he a ha0
+      have hid := hint.sub ι hia
+      obtain ⟨u, hu⟩ := hid d
+      have heq : MvPowerSeries.coeff d
+          (defect p hp.out.ne_zero χ.toRingHom (ι ∘ v) (f.subst g) -
+            defect p hp.out.ne_zero χ.toRingHom (ι ∘ v) (f.subst (a.map ι))) =
+              MvPowerSeries.coeff d (g - a.map ι) := by
+        rw [← defect_sub, coeff_defect_le p hp.out.two_le χ.toRingHom (ι ∘ v) _ n hnpos
+          (order_log_difference f hf1 g (a.map ι) hg ham0 n hao) d hd.le,
+          coeff_log_difference f hf1 g (a.map ι) hg ham0 n hao d hd.le]
+      change ι u = MvPowerSeries.coeff d
+          (defect p hp.out.ne_zero χ.toRingHom (ι ∘ v) (f.subst g) -
+            defect p hp.out.ne_zero χ.toRingHom (ι ∘ v) (f.subst (a.map ι))) at hu
+      rw [heq, map_sub, MvPowerSeries.coeff_map] at hu
+      refine ⟨u + MvPowerSeries.coeff d a, ?_⟩
+      rw [map_add, hu, sub_add_cancel]
+  intro d
+  exact main d.degree d rfl
+
+end HeightThree.PTypical
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/FormalGroup/Honda/Recurrence.lean b/lean/OAI/Algebra/FormalGroup/Honda/Recurrence.lean
new file mode 100644
index 0000000000000000000000000000000000000000..5f26a7205b9b0806cfe90b599d121967b06765fd
--- /dev/null
+++ b/lean/OAI/Algebra/FormalGroup/Honda/Recurrence.lean
@@ -0,0 +1,139 @@
+import OAI.Algebra.FormalGroup.Honda.IntegralLaw
+
+namespace OAI
+
+noncomputable section
+
+namespace HeightThree.HondaConstruction
+open MvPowerSeries PTypical LogarithmicConstruction
+variable {A B : Type*} [CommRing A] [CommRing B]
+
+theorem logarithm_functional_equation [Algebra ℚ B]
+    (ι : A →+* B) (p : ℕ) (hp : 2 ≤ p)
+    (ψ : A →+* A) (χ : B →ₐ[ℚ] B) (hc : χ.toRingHom.comp ι = ι.comp ψ)
+    (v : Fin 3 → A) :
+    defect p (by omega) χ.toRingHom (ι ∘ v) (logarithm ι p ψ v) = PowerSeries.X := by
+  apply PowerSeries.ext
+  intro j
+  simp only [defect, map_sub, map_sum, (PowerSeries.coeff j).map_smul_of_tower,
+    Function.comp_apply]
+  by_cases hj : ∃ n : ℕ, p^n = j
+  · obtain ⟨n, rfl⟩ := hj
+    simp only [logarithm, twisted_series_coeff p hp, coeff_series_power p hp]
+    cases n with
+    | zero => simp [numerator, PowerSeries.coeff_X]
+    | succ n =>
+      have hpn : p^(n+1) ≠ 1 := by
+        have : 1 < p^(n+1) := one_lt_pow₀ (by omega : 1 < p) (by omega)
+        omega
+      rw [PowerSeries.coeff_X, ite_eq_right hpn, logarithm_recurrence ι p (by omega) ψ χ hc]
+      apply sub_eq_zero.mpr
+      apply Finset.sum_congr rfl
+      intro i _
+      simp only [Nat.add_le_add_iff_right, Nat.add_sub_add_right, smul_eq_mul]
+  · rw [logarithm, coeff_series_outside p j _ hj]
+    have ht (i : Fin 3) : PowerSeries.coeff j
+        ((twist p (by omega) χ.toRingHom ^ (i.val+1))
+          (series p (fun n => ((p : ℚ)⁻¹)^n • ι (numerator p ψ v n)))) = 0 :=
+      twisted_series_coeff_outside p hp χ.toRingHom _ (i.val+1) j hj
+    simp only [ht, smul_zero, Finset.sum_const_zero, sub_zero]
+    rw [PowerSeries.coeff_X, ite_eq_right]
+    intro h
+    exact hj ⟨0, by simpa using h.symm⟩
+
+def heightThreeLog [Algebra ℚ B] (ι : A →+* B) (p : ℕ) (hp : 2 ≤ p)
+    (ψ : A →+* A) (v : Fin 3 → A) : StrictLog (R := B) where
+  series := logarithm ι p ψ v
+  constant_zero := logarithm_constant ι p hp ψ v
+  linear_one := logarithm_linear ι p hp ψ v
+
+def integralFormalGroup [Algebra ℚ B] (ι : A →+* B) (hinj : Function.Injective ι)
+    (p : ℕ) [hp : Fact p.Prime]
+    (ψ : A →+* A) (χ : B →ₐ[ℚ] B) (hc : χ.toRingHom.comp ι = ι.comp ψ)
+    (hψ : ∀ a : A, (p : A) ∣ ψ a - a^p) (v : Fin 3 → A) : FormalGroup A :=
+  descendFormalGroup ι hinj (heightThreeLog ι p hp.out.two_le ψ v).formalGroup
+    (law_integral ι p ψ χ hc hψ v (heightThreeLog ι p hp.out.two_le ψ v)
+      (series_integralNumerators ι p hp.out.two_le _)
+      (logarithm_functional_equation ι p hp.out.two_le ψ χ hc v))
+
+instance integralFormalGroup_isComm [Algebra ℚ B] (ι : A →+* B) (hinj : Function.Injective ι)
+    (p : ℕ) [hp : Fact p.Prime]
+    (ψ : A →+* A) (χ : B →ₐ[ℚ] B) (hc : χ.toRingHom.comp ι = ι.comp ψ)
+    (hψ : ∀ a : A, (p : A) ∣ ψ a - a^p) (v : Fin 3 → A) :
+    (integralFormalGroup ι hinj p ψ χ hc hψ v).IsComm :=
+  by
+  apply descendFormalGroup_isComm
+
+end HeightThree.HondaConstruction
+
+namespace HeightThree.HondaConstruction
+open MvPowerSeries PTypical LogarithmicConstruction
+
+abbrev IntegralBase := MvPowerSeries (Fin 2) ℤ
+abbrev RationalBase := MvPowerSeries (Fin 2) ℚ
+
+def coefficientInclusion : IntegralBase →+* RationalBase :=
+  MvPowerSeries.map (Int.castRingHom ℚ)
+
+lemma coefficientInclusion_injective : Function.Injective coefficientInclusion :=
+  map_injective (Int.castRingHom ℚ) Int.cast_injective
+
+def integralFrobenius (p : ℕ) (hp : p ≠ 0) : IntegralBase →+* IntegralBase :=
+  (MvPowerSeries.expand p hp).toRingHom
+
+def rationalFrobenius (p : ℕ) (hp : p ≠ 0) : RationalBase →ₐ[ℚ] RationalBase :=
+  MvPowerSeries.expand p hp
+
+lemma frobenius_compatible (p : ℕ) (hp : p ≠ 0) :
+    (rationalFrobenius p hp).toRingHom.comp coefficientInclusion =
+      coefficientInclusion.comp (integralFrobenius p hp) := by
+  ext f d
+  exact congrArg (coeff d) (MvPowerSeries.map_expand p hp (Int.castRingHom ℚ) f).symm
+
+lemma integralFrobenius_congr (p : ℕ) [hp : Fact p.Prime] (a : IntegralBase) :
+    (p : IntegralBase) ∣ integralFrobenius p hp.out.ne_zero a - a^p := by
+  have hInt (a : ℤ) : (p : ℤ) ∣ (RingHom.id ℤ) a - a^p :=
+    dvd_sub_comm.mp (Int.prime_dvd_pow_self_sub hp.out a)
+  simpa [MvPowerSeries.map_id, integralFrobenius] using
+    frobenius_lift_series p (RingHom.id ℤ) hInt a
+
+def parameters : Fin 3 → IntegralBase := ![X 0, X 1, 1]
+
+def integralHonda (p : ℕ) [hp : Fact p.Prime] : FormalGroup IntegralBase :=
+  integralFormalGroup coefficientInclusion coefficientInclusion_injective p
+    (integralFrobenius p hp.out.ne_zero) (rationalFrobenius p hp.out.ne_zero)
+    (frobenius_compatible p hp.out.ne_zero) (integralFrobenius_congr p) parameters
+
+instance integralHonda_isComm (p : ℕ) [hp : Fact p.Prime] : (integralHonda p).IsComm := by
+  unfold integralHonda
+  exact integralFormalGroup_isComm ..
+
+def reducedHonda (p : ℕ) [Fact p.Prime] (K : Type*) [CommRing K] :
+    FormalGroup (MvPowerSeries (Fin 2) K) :=
+  (integralHonda p).map (MvPowerSeries.map (Int.castRingHom K))
+
+end HeightThree.HondaConstruction
+
+namespace HeightThree.HondaConstruction
+open MvPowerSeries
+variable {A B : Type*} [CommRing A] [CommRing B]
+
+instance mapFormalGroup_isComm (F : FormalGroup A) [F.IsComm] (f : A →+* B) :
+    (F.map f).IsComm where
+  comm := by
+    change F.toPowerSeries.map f = (F.toPowerSeries.map f).subst ![X 1, X 0]
+    have hc := congrArg (MvPowerSeries.map f) (FormalGroup.IsComm.comm (F := F))
+    rw [map_subst HasSubst.X_X] at hc
+    rw [hc]
+    congr 1
+    funext i
+    fin_cases i <;> simp
+
+instance reducedHonda_isComm (p : ℕ) [Fact p.Prime] (K : Type*) [CommRing K] :
+    (reducedHonda p K).IsComm := mapFormalGroup_isComm ..
+
+end HeightThree.HondaConstruction
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/FormalGroup/Honda/Rigidity.lean b/lean/OAI/Algebra/FormalGroup/Honda/Rigidity.lean
new file mode 100644
index 0000000000000000000000000000000000000000..6a4ef70404dbfad5252c937ef4789f5e6fb6eda9
--- /dev/null
+++ b/lean/OAI/Algebra/FormalGroup/Honda/Rigidity.lean
@@ -0,0 +1,223 @@
+import OAI.Algebra.FormalGroup.Honda.HondaDifferential
+
+namespace OAI
+
+noncomputable section
+
+namespace HeightThree.DeformationRigidity
+open MvPowerSeries HondaTarget
+variable {A B : Type*} [CommRing A] [CommRing B]
+@[simp] lemma multiplication_zero (F : FormalGroup A) :
+    multiplicationSeries F 0 = 0 := rfl
+
+lemma multiplication_succ (F : FormalGroup A) (n : ℕ) :
+    multiplicationSeries F (n+1) =
+      F.toPowerSeries.subst ![multiplicationSeries F n, PowerSeries.X] := by
+  change ((n+1) • variablePoint F).val = _
+  rw [succ_nsmul]
+  rfl
+
+@[simp] lemma multiplication_constant (F : FormalGroup A) (n : ℕ) :
+    (multiplicationSeries F n).constantCoeff = 0 := by
+  induction n with
+  | zero => simp
+  | succ n ih =>
+    rw [multiplication_succ]
+    apply MvPowerSeries.constantCoeff_subst_eq_zero
+      (hasSubst_of_constantCoeff_zero (by intro i; fin_cases i; exact ih; exact PowerSeries.constantCoeff_X))
+      (by intro i; fin_cases i; exact ih; exact PowerSeries.constantCoeff_X) F.zero_constantCoeff
+
+lemma multiplication_map (F : FormalGroup A) (φ : A →+* B) (n : ℕ) :
+    multiplicationSeries (F.map φ) n = (multiplicationSeries F n).map φ := by
+  induction n with
+  | zero => simp
+  | succ n ih =>
+    rw [multiplication_succ, multiplication_succ]
+    change _ = MvPowerSeries.map φ (F.toPowerSeries.subst ![multiplicationSeries F n, PowerSeries.X])
+    have hs : MvPowerSeries.HasSubst ![multiplicationSeries F n, PowerSeries.X] :=
+      hasSubst_of_constantCoeff_zero (by
+        intro i; fin_cases i; exact multiplication_constant F n; exact PowerSeries.constantCoeff_X)
+    rw [map_subst hs, ih]
+    congr 1
+    funext i
+    fin_cases i
+    · rfl
+    · exact (MvPowerSeries.map_X φ ()).symm
+
+end HeightThree.DeformationRigidity
+
+namespace HeightThree.DeformationRigidity
+open MvPowerSeries HondaTarget
+variable {R S : Type*} [CommRing R] [CommRing S]
+
+def SquareZeroKernel (ρ : R →+* S) : Prop :=
+  ∀ a b : R, ρ a = 0 → ρ b = 0 → a * b = 0
+
+lemma subst_eq_of_squareZero (ρ : R →+* S) (hρ : SquareZeroKernel ρ)
+    (f : PowerSeries R) (hf : f.map ρ = 0)
+    {σ : Type*} (a b : MvPowerSeries σ R)
+    (ha : PowerSeries.HasSubst a) (hb : PowerSeries.HasSubst b)
+    (hab : a.map ρ = b.map ρ) : f.subst a = f.subst b := by
+  ext d
+  rw [PowerSeries.coeff_subst ha, PowerSeries.coeff_subst hb]
+  apply finsum_congr
+  intro j
+  have hfj : ρ (PowerSeries.coeff j f) = 0 := by
+    have hh := congrArg (PowerSeries.coeff j) hf
+    simpa only [PowerSeries.coeff_map, map_zero] using hh
+  have hpw : (a^j).map ρ = (b^j).map ρ := by simp only [map_pow, hab]
+  have hc : ρ (coeff d (a^j) - coeff d (b^j)) = 0 := by
+    rw [map_sub]
+    exact sub_eq_zero.mpr (by simpa only [coeff_map] using congrArg (coeff d) hpw)
+  rw [smul_eq_mul, smul_eq_mul, ← sub_eq_zero, ← mul_sub]
+  exact hρ _ _ hfj hc
+
+lemma mul_eq_zero_of_map_zero (ρ : R →+* S) (hρ : SquareZeroKernel ρ)
+    (a b : PowerSeries R) (ha : a.map ρ = 0) (hb : b.map ρ = 0) : a*b = 0 := by
+  ext n
+  rw [PowerSeries.coeff_mul, map_zero]
+  apply Finset.sum_eq_zero
+  intro ij _
+  apply hρ
+  · simpa only [PowerSeries.coeff_map, map_zero] using congrArg (PowerSeries.coeff ij.1) ha
+  · simpa only [PowerSeries.coeff_map, map_zero] using congrArg (PowerSeries.coeff ij.2) hb
+
+lemma highPower_unchanged (p : ℕ) [hp : Fact p.Prime] [CharP R p]
+    (h : ℕ) (hh : 0 < h) (ρ : R →+* S) (hρ : SquareZeroKernel ρ)
+    (u : PowerSeries R) (hu : u.map ρ = PowerSeries.X) :
+    u^(p^h) = PowerSeries.X^(p^h) := by
+  have : CharP (PowerSeries R) p := charP_of_injective_ringHom PowerSeries.C_injective p
+  let d := u - PowerSeries.X
+  have hd : d.map ρ = 0 := by simp [d, hu]
+  have hd2 : d^2 = 0 := by simpa only [pow_two] using mul_eq_zero_of_map_zero ρ hρ d d hd hd
+  have hdq : d^(p^h) = 0 := pow_eq_zero_of_le
+    (by exact le_trans hp.out.two_le (Nat.le_pow hh)) hd2
+  have hu' : u = PowerSeries.X + d := by dsimp [d]; ring
+  rw [hu', add_pow_char_pow, hdq, add_zero]
+
+lemma subst_after_mv {σ τ : Type*} (f : PowerSeries R)
+    (a : MvPowerSeries σ R) (ha : PowerSeries.HasSubst a)
+    (b : σ → MvPowerSeries τ R) (hb : MvPowerSeries.HasSubst b) :
+    (f.subst a).subst b = f.subst (a.subst b) :=
+  MvPowerSeries.subst_comp_subst_apply ha.const hb f
+
+lemma coordinate_add (F G : FormalGroup R) (e : CoordinateIso F G)
+    {σ : Type*} (a b : MvPowerSeries σ R)
+    (ha : a.constantCoeff = 0) (hb : b.constantCoeff = 0) :
+    e.series.subst (F.toPowerSeries.subst ![a,b]) =
+      G.toPowerSeries.subst ![e.series.subst a, e.series.subst b] := by
+  have hab : MvPowerSeries.HasSubst ![a,b] :=
+    hasSubst_of_constantCoeff_zero (by intro i; fin_cases i <;> assumption)
+  have hes (i : Fin 2) : (e.series.subst (X i : MvPowerSeries (Fin 2) R)).constantCoeff = 0 :=
+    PowerSeries.constantCoeff_subst_eq_zero (by simp) _ e.zero_series
+  have hepair : MvPowerSeries.HasSubst
+      ![e.series.subst (X 0 : MvPowerSeries (Fin 2) R),
+        e.series.subst (X 1 : MvPowerSeries (Fin 2) R)] :=
+    hasSubst_of_constantCoeff_zero (by intro i; fin_cases i <;> exact hes _)
+  have he := congrArg (fun z : MvPowerSeries (Fin 2) R => z.subst ![a,b])
+    e.preserves_addition
+  rw [subst_after_mv _ _ (PowerSeries.HasSubst.of_constantCoeff_zero F.zero_constantCoeff)
+    _ hab, MvPowerSeries.subst_comp_subst_apply hepair hab] at he
+  convert he using 1
+  congr 1
+  funext i; fin_cases i
+  · change e.series.subst a = (e.series.subst (X 0 : MvPowerSeries (Fin 2) R)).subst ![a,b]
+    rw [subst_after_mv _ _ (PowerSeries.HasSubst.X _) _ hab, MvPowerSeries.subst_X hab]
+    rfl
+  · change e.series.subst b = (e.series.subst (X 1 : MvPowerSeries (Fin 2) R)).subst ![a,b]
+    rw [subst_after_mv _ _ (PowerSeries.HasSubst.X _) _ hab, MvPowerSeries.subst_X hab]
+    rfl
+
+lemma law_pair_subst (F : FormalGroup R) (a b c : PowerSeries R)
+    (ha : a.constantCoeff = 0) (hb : b.constantCoeff = 0)
+    (hc : PowerSeries.HasSubst c) :
+    PowerSeries.subst c (F.toPowerSeries.subst ![a,b]) =
+      F.toPowerSeries.subst ![a.subst c, b.subst c] := by
+  have hab : MvPowerSeries.HasSubst ![a,b] :=
+    hasSubst_of_constantCoeff_zero (by intro i; fin_cases i <;> assumption)
+  change (F.toPowerSeries.subst ![a,b]).subst (fun _ : Unit => c) = _
+  rw [MvPowerSeries.subst_comp_subst_apply hab hc.const]
+  congr 1
+  funext i; fin_cases i <;> rfl
+
+lemma coordinate_multiplication (F G : FormalGroup R) (e : CoordinateIso F G) (n : ℕ) :
+    e.series.subst (multiplicationSeries F n) =
+      (multiplicationSeries G n).subst e.series := by
+  have he : PowerSeries.HasSubst e.series := PowerSeries.HasSubst.of_constantCoeff_zero e.zero_series
+  induction n with
+  | zero =>
+    simp only [multiplication_zero, PowerSeries.subst_zero_of_constantCoeff_zero e.zero_series]
+    rw [← PowerSeries.coe_substAlgHom he, map_zero]
+  | succ n ih =>
+    rw [multiplication_succ, coordinate_add F G e _ _ (multiplication_constant F n)
+      (by exact PowerSeries.constantCoeff_X), multiplication_succ,
+      law_pair_subst G _ _ _ (multiplication_constant G n) PowerSeries.constantCoeff_X he,
+      ih, PowerSeries.X_subst, PowerSeries.subst_X he]
+
+lemma subst_near_X_highPower (p : ℕ) [hp : Fact p.Prime] [CharP R p]
+    (h : ℕ) (hh : 0 < h) (ρ : R →+* S) (hρ : SquareZeroKernel ρ)
+    (u f : PowerSeries R) (hu0 : u.constantCoeff = 0)
+    (hu : u.map ρ = PowerSeries.X) (hf : f.map ρ = PowerSeries.X^(p^h)) :
+    f.subst u = f := by
+  let v := f - PowerSeries.X^(p^h)
+  have hv : v.map ρ = 0 := by simp only [v, map_sub, map_pow, PowerSeries.map_X, hf, sub_self]
+  have huS : PowerSeries.HasSubst u := PowerSeries.HasSubst.of_constantCoeff_zero hu0
+  have hvu : v.subst u = v := by
+    have he := subst_eq_of_squareZero ρ hρ v hv u PowerSeries.X huS
+      PowerSeries.HasSubst.X' (by change u.map ρ = (PowerSeries.X : PowerSeries R).map ρ; simpa only [PowerSeries.map_X] using hu)
+    simpa only [PowerSeries.X_subst] using he
+  have he : f = PowerSeries.X^(p^h) + v := by dsimp [v]; ring
+  conv_lhs => rw [he]
+  rw [PowerSeries.subst_add huS, PowerSeries.subst_pow huS, PowerSeries.subst_X huS,
+    highPower_unchanged p h hh ρ hρ u hu, hvu]
+  exact he.symm
+
+lemma infinitesimal_pseries (p : ℕ) [hp : Fact p.Prime] [CharP R p]
+    (h : ℕ) (hh : 0 < h) (ρ : R →+* S) (hρ : SquareZeroKernel ρ)
+    (F G : FormalGroup R) (e : CoordinateIso F G)
+    (he : e.series.map ρ = PowerSeries.X)
+    (hF : (multiplicationSeries F p).map ρ = PowerSeries.X^(p^h))
+    (hG : (multiplicationSeries G p).map ρ = PowerSeries.X^(p^h)) :
+    multiplicationSeries F p +
+        (e.series - PowerSeries.X).subst (PowerSeries.X^(p^h)) =
+      multiplicationSeries G p := by
+  let d := e.series - PowerSeries.X
+  have hd : d.map ρ = 0 := by simp [d, he]
+  have hpq : (p^h) ≠ 0 := pow_ne_zero _ hp.out.ne_zero
+  have hq : PowerSeries.HasSubst (PowerSeries.X^(p^h) : PowerSeries R) :=
+    PowerSeries.HasSubst.X_pow hpq
+  have hdf : d.subst (multiplicationSeries F p) = d.subst (PowerSeries.X^(p^h)) :=
+    subst_eq_of_squareZero ρ hρ d hd _ _
+      (PowerSeries.HasSubst.of_constantCoeff_zero (multiplication_constant F p)) hq
+      (by change (multiplicationSeries F p).map ρ = (PowerSeries.X^(p^h)).map ρ; simpa only [map_pow, PowerSeries.map_X] using hF)
+  have hcentral := coordinate_multiplication F G e p
+  have hes : e.series = PowerSeries.X + d := by dsimp [d]; ring
+  rw [subst_near_X_highPower p h hh ρ hρ _ _ e.zero_series he hG] at hcentral
+  conv_lhs at hcentral => rw [hes, PowerSeries.subst_add
+    (PowerSeries.HasSubst.of_constantCoeff_zero (multiplication_constant F p)),
+    PowerSeries.subst_X (PowerSeries.HasSubst.of_constantCoeff_zero (multiplication_constant F p)), hdf]
+  exact hcentral
+
+theorem infinitesimal_automorphism_rigid (p : ℕ) [hp : Fact p.Prime] [CharP R p]
+    (h : ℕ) (hh : 0 < h) (ρ : R →+* S) (hρ : SquareZeroKernel ρ)
+    (F : FormalGroup R) (e : CoordinateIso F F)
+    (he : e.series.map ρ = PowerSeries.X)
+    (hF : (multiplicationSeries F p).map ρ = PowerSeries.X^(p^h)) :
+    e.series = PowerSeries.X := by
+  have hz := infinitesimal_pseries p h hh ρ hρ F F e he hF hF
+  have hd : (e.series - PowerSeries.X).subst (PowerSeries.X^(p^h)) = 0 :=
+    (add_eq_left.mp hz)
+  have hpq : (p^h) ≠ 0 := pow_ne_zero _ hp.out.ne_zero
+  have heq : e.series - PowerSeries.X = 0 := by
+    ext n
+    have hn := congrArg (PowerSeries.coeff (p^h*n)) hd
+    rw [← PowerSeries.expand_apply (p^h) hpq,
+      PowerSeries.coeff_expand_mul, map_zero] at hn
+    simpa only [map_zero] using hn
+  exact sub_eq_zero.mp heq
+
+end HeightThree.DeformationRigidity
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/FormalGroup/Honda/SmallExtension.lean b/lean/OAI/Algebra/FormalGroup/Honda/SmallExtension.lean
new file mode 100644
index 0000000000000000000000000000000000000000..dbc7c82f4de830f67fd0a2d122459def7e163c41
--- /dev/null
+++ b/lean/OAI/Algebra/FormalGroup/Honda/SmallExtension.lean
@@ -0,0 +1,444 @@
+import OAI.Algebra.FormalGroup.Honda.ChainRule
+import OAI.Algebra.FormalGroup.Honda.Tangent
+
+namespace OAI
+
+noncomputable section
+
+namespace HeightThree.SmallExtension
+open MvPowerSeries HondaTarget DeformationRigidity TangentClassification
+variable {R S K σ τ : Type*} [CommRing R] [CommRing S] [CommRing K]
+
+structure IsSmall (π : R →+* S) (ρ : R →+* K) : Prop where
+  ker_le : ∀ a, π a = 0 → ρ a = 0
+  annihilate : ∀ a b, π a = 0 → ρ b = 0 → a*b = 0
+
+lemma IsSmall.squareZero {π : R →+* S} {ρ : R →+* K} (h : IsSmall π ρ) :
+    SquareZeroKernel π := fun a b ha hb => h.annihilate a b ha (h.ker_le b hb)
+
+lemma subst_eq_of_annihilate (π : R →+* S) (ρ : R →+* K)
+    (h : ∀ c e, π c = 0 → ρ e = 0 → c*e = 0)
+    (f : MvPowerSeries σ R) (hf : f.map π = 0)
+    (a b : σ → MvPowerSeries τ R) (ha : HasSubst a) (hb : HasSubst b)
+    (hab : ∀ i, (a i).map ρ = (b i).map ρ) : f.subst a = f.subst b := by
+  ext d
+  rw [coeff_subst ha, coeff_subst hb]
+  apply finsum_congr
+  intro e
+  have hf' : π (coeff e f) = 0 := by
+    simpa only [coeff_map, map_zero] using congrArg (coeff e) hf
+  have he : (e.prod fun i n => (a i)^n).map ρ = (e.prod fun i n => (b i)^n).map ρ := by
+    simp only [Finsupp.prod, map_prod, map_pow, hab]
+  have hd : ρ (coeff d (e.prod fun i n => (a i)^n) - coeff d (e.prod fun i n => (b i)^n)) = 0 := by
+    rw [map_sub]
+    exact sub_eq_zero.mpr (by simpa only [coeff_map] using congrArg (coeff d) he)
+  rw [smul_eq_mul, smul_eq_mul, ← sub_eq_zero, ← mul_sub]
+  exact h _ _ hf' hd
+
+lemma unisubst_eq_of_annihilate (π : R →+* S) (ρ : R →+* K)
+    (h : ∀ c e, π c = 0 → ρ e = 0 → c*e = 0)
+    (f : PowerSeries R) (hf : f.map π = 0)
+    (a b : MvPowerSeries τ R) (ha : PowerSeries.HasSubst a) (hb : PowerSeries.HasSubst b)
+    (hab : a.map ρ = b.map ρ) : f.subst a = f.subst b :=
+  subst_eq_of_annihilate π ρ h f hf _ _ ha.const hb.const (fun _ => hab)
+
+lemma series_mul_zero (π : R →+* S) (ρ : R →+* K)
+    (h : ∀ c e, π c = 0 → ρ e = 0 → c*e = 0)
+    (a b : MvPowerSeries σ R) (ha : a.map π = 0) (hb : b.map ρ = 0) : a*b = 0 := by
+  classical
+  ext d
+  rw [coeff_mul, map_zero]
+  apply Finset.sum_eq_zero
+  intro ij hij
+  apply h
+  · simpa only [coeff_map, map_zero] using congrArg (coeff ij.1) ha
+  · simpa only [coeff_map, map_zero] using congrArg (coeff ij.2) hb
+
+lemma highPower_eq (p : ℕ) [hp : Fact p.Prime] [CharP R p]
+    (n : ℕ) (hn : 0 < n) (π : R →+* S) (hπ : SquareZeroKernel π)
+    (a b : MvPowerSeries σ R) (hab : a.map π = b.map π) : a^(p^n) = b^(p^n) := by
+  let : CharP (MvPowerSeries σ R) p := charP_of_injective_ringHom MvPowerSeries.C_injective p
+  let d := a-b
+  have hd : d.map π = 0 := by simp [d, hab]
+  have hd2 : d^2 = 0 := by simpa only [pow_two] using series_mul_zero π π hπ d d hd hd
+  have hdq : d^(p^n) = 0 := pow_eq_zero_of_le (le_trans hp.out.two_le (Nat.le_pow hn)) hd2
+  have he : a = b+d := by dsimp [d]; ring
+  rw [he, add_pow_char_pow, hdq, add_zero]
+
+lemma subst_expand_inner (q : ℕ) (hq : q ≠ 0) (f : MvPowerSeries σ R)
+    (a : σ → MvPowerSeries τ R) (ha : HasSubst a) :
+    (expand q hq f).subst a = f.subst (fun i => (a i)^q) := by
+  rw [expand, substAlgHom_apply, subst_comp_subst_apply (HasSubst.X_pow hq) ha]
+  congr 1
+  funext i
+  rw [← coe_substAlgHom ha, map_pow, substAlgHom_X]
+
+lemma law_perturbation (p : ℕ) [hp : Fact p.Prime] [CharP R p]
+    (π : R →+* S) (ρ : R →+* K) (h : IsSmall π ρ)
+    (F Γ : FormalGroup R) (hF : F.toPowerSeries.map ρ = Γ.toPowerSeries.map ρ)
+    (H : MvPowerSeries (Fin 2) R)
+    (hΓ : Γ.toPowerSeries = X 0 + X 1 + expand (p^2) (pow_ne_zero _ hp.out.ne_zero) H)
+    (a b : Fin 2 → MvPowerSeries σ R) (ha : HasSubst a) (hb : HasSubst b)
+    (hab : ∀ i, (a i).map π = (b i).map π) :
+    F.toPowerSeries.subst a - F.toPowerSeries.subst b = (a 0-b 0)+(a 1-b 1) := by
+  have he : (F.toPowerSeries-Γ.toPowerSeries).subst a =
+      (F.toPowerSeries-Γ.toPowerSeries).subst b := by
+    apply subst_eq_of_annihilate ρ π (fun c e hc he => by rw [mul_comm]; exact h.annihilate e c he hc)
+    · simpa only [map_sub] using sub_eq_zero.mpr hF
+    · exact ha
+    · exact hb
+    · exact hab
+  rw [← coe_substAlgHom ha, ← coe_substAlgHom hb, map_sub, map_sub] at he
+  have hΓab : Γ.toPowerSeries.subst a - Γ.toPowerSeries.subst b = (a 0-b 0)+(a 1-b 1) := by
+    rw [hΓ]
+    simp only [← coe_substAlgHom ha, ← coe_substAlgHom hb, map_add, substAlgHom_X]
+    have hpowers : (fun i => (a i)^(p^2)) = (fun i => (b i)^(p^2)) := by
+      funext i; exact highPower_eq p 2 (by omega) π h.squareZero _ _ (hab i)
+    rw [coe_substAlgHom ha, coe_substAlgHom hb,
+      subst_expand_inner _ _ _ a ha, subst_expand_inner _ _ _ b hb, hpowers]
+    ring
+  simp only [coe_substAlgHom] at he
+  linear_combination he + hΓab
+
+lemma series_perturbation (p : ℕ) [hp : Fact p.Prime] [CharP R p]
+    (n : ℕ) (hn : 0 < n) (π : R →+* S) (ρ : R →+* K) (h : IsSmall π ρ)
+    (f : PowerSeries R) (hf : f.map ρ = PowerSeries.X^(p^n))
+    (a b : MvPowerSeries σ R) (ha : PowerSeries.HasSubst a) (hb : PowerSeries.HasSubst b)
+    (hab : a.map π = b.map π) : f.subst a = f.subst b := by
+  have he : (f-PowerSeries.X^(p^n)).subst a = (f-PowerSeries.X^(p^n)).subst b := by
+    apply unisubst_eq_of_annihilate ρ π (fun c e hc he => by rw [mul_comm]; exact h.annihilate e c he hc)
+    · change MvPowerSeries.map ρ (f-PowerSeries.X^(p^n)) = 0
+      rw [map_sub, map_pow, show MvPowerSeries.map ρ f = PowerSeries.X^(p^n) from hf]
+      simp [PowerSeries.X]
+    · exact ha
+    · exact hb
+    · exact hab
+  rw [PowerSeries.subst_sub ha, PowerSeries.subst_sub hb, PowerSeries.subst_pow ha,
+    PowerSeries.subst_pow hb, PowerSeries.subst_X ha, PowerSeries.subst_X hb,
+    highPower_eq p n hn π h.squareZero a b hab] at he
+  have hh := congrArg (fun z => z+b^(p^n)) he
+  simpa only [sub_add_cancel] using hh
+
+def point (F : FormalGroup R) (a : MvPowerSeries σ R) (ha : PowerSeries.HasSubst a) : F.Point σ := ⟨a,ha⟩
+
+lemma multiplication_at_point (F : FormalGroup R) (n : ℕ)
+    (a : MvPowerSeries σ R) (ha : PowerSeries.HasSubst a) :
+    (multiplicationSeries F n).subst a = (n • point F a ha).val := by
+  induction n with
+  | zero =>
+    rw [multiplication_zero, ← PowerSeries.coe_substAlgHom ha, map_zero]
+    rfl
+  | succ n ih =>
+    rw [multiplication_succ, succ_nsmul]
+    have hn : HasSubst ![multiplicationSeries F n, PowerSeries.X] :=
+      hasSubst_of_constantCoeff_zero (by intro i; fin_cases i; exact multiplication_constant F n; exact PowerSeries.constantCoeff_X)
+    change MvPowerSeries.subst (fun _ : Unit => a)
+      (F.toPowerSeries.subst ![multiplicationSeries F n, PowerSeries.X]) =
+      F.toPowerSeries.subst ![(n • point F a ha).val,a]
+    rw [subst_comp_subst_apply hn ha.const]
+    congr 1
+    funext i; fin_cases i
+    · exact ih
+    · exact PowerSeries.subst_X ha
+
+lemma multiplication_preserves_addition (F : FormalGroup R) [F.IsComm] (n : ℕ) :
+    (multiplicationSeries F n).subst F.toPowerSeries =
+      F.toPowerSeries.subst ![(multiplicationSeries F n).subst (X 0),
+        (multiplicationSeries F n).subst (X 1)] := by
+  let x : F.Point (Fin 2) := ⟨X 0, PowerSeries.HasSubst.X 0⟩
+  let y : F.Point (Fin 2) := ⟨X 1, PowerSeries.HasSubst.X 1⟩
+  have hxy : (x+y).val = F.toPowerSeries := by
+    change F.toPowerSeries.subst ![X 0, X 1] = F.toPowerSeries
+    rw [show (![X 0, X 1] : Fin 2 → MvPowerSeries (Fin 2) R) = X by funext i; fin_cases i <;> rfl]
+    exact congrFun MvPowerSeries.subst_self F.toPowerSeries
+  have hh := congrArg (fun a : F.Point (Fin 2) => a.val) (nsmul_add x y n)
+  change (n • (x+y)).val = F.toPowerSeries.subst ![(n•x).val,(n•y).val] at hh
+  have hv (a : F.Point (Fin 2)) : (n•a).val = (multiplicationSeries F n).subst a.val := by
+    have hp : point F a.val a.prop = a := rfl
+    have hh := (multiplication_at_point F n a.val a.prop).symm
+    rw [hp] at hh
+    exact hh
+  rw [hv (x+y), hv x, hv y, hxy] at hh
+  exact hh
+
+lemma multiplication_reduction (F Γ : FormalGroup R) (ρ : R →+* K)
+    (hF : F.map ρ = Γ.map ρ) (p q : ℕ)
+    (hΓ : multiplicationSeries Γ p = PowerSeries.X^q) :
+    (multiplicationSeries F p).map ρ = PowerSeries.X^q := by
+  rw [← multiplication_map, hF, multiplication_map, hΓ]
+  change MvPowerSeries.map ρ (PowerSeries.X^q) = _
+  rw [map_pow]
+  simp [PowerSeries.X]
+
+theorem linearized_p_hom (p : ℕ) [hp : Fact p.Prime] [CharP R p]
+    (π : R →+* S) (ρ : R →+* K) (h : IsSmall π ρ)
+    (F G Γ : FormalGroup R) [F.IsComm] [G.IsComm]
+    (hπ : F.map π = G.map π) (hF : F.map ρ = Γ.map ρ) (hG : G.map ρ = Γ.map ρ)
+    (H : MvPowerSeries (Fin 2) R)
+    (hΓ : Γ.toPowerSeries = X 0 + X 1 + expand (p^2) (pow_ne_zero _ hp.out.ne_zero) H)
+    (hΓp : multiplicationSeries Γ p = PowerSeries.X^(p^3)) :
+    delta Γ (multiplicationSeries F p - multiplicationSeries G p) =
+      expand (p^3) (pow_ne_zero _ hp.out.ne_zero) (F.toPowerSeries-G.toPowerSeries) := by
+  let P := multiplicationSeries F p
+  let Q := multiplicationSeries G p
+  let v := P-Q
+  let D := F.toPowerSeries-G.toPowerSeries
+  have hPπ : P.map π = Q.map π := by
+    dsimp [P,Q]; rw [← multiplication_map, ← multiplication_map, hπ]
+  have hvπ : v.map π = 0 := by
+    change MvPowerSeries.map π (P-Q) = 0
+    rw [map_sub]; exact sub_eq_zero.mpr hPπ
+  have hDπ : D.map π = 0 := by
+    dsimp [D]
+    rw [map_sub]
+    exact sub_eq_zero.mpr (congrArg FormalGroup.toPowerSeries hπ)
+  have hPρ : P.map ρ = PowerSeries.X^(p^3) := multiplication_reduction F Γ ρ hF p _ hΓp
+  have hQρ : Q.map ρ = PowerSeries.X^(p^3) := multiplication_reduction G Γ ρ hG p _ hΓp
+  have hFs : PowerSeries.HasSubst F.toPowerSeries := .of_constantCoeff_zero F.zero_constantCoeff
+  have hGs : PowerSeries.HasSubst G.toPowerSeries := .of_constantCoeff_zero G.zero_constantCoeff
+  have hΓs : PowerSeries.HasSubst Γ.toPowerSeries := .of_constantCoeff_zero Γ.zero_constantCoeff
+  have hFGπ : F.toPowerSeries.map π = G.toPowerSeries.map π := congrArg FormalGroup.toPowerSeries hπ
+  have hFΓρ : F.toPowerSeries.map ρ = Γ.toPowerSeries.map ρ := congrArg FormalGroup.toPowerSeries hF
+  have hGΓρ : G.toPowerSeries.map ρ = Γ.toPowerSeries.map ρ := congrArg FormalGroup.toPowerSeries hG
+  have heQ : Q.subst F.toPowerSeries = Q.subst G.toPowerSeries :=
+    series_perturbation p 3 (by omega) π ρ h Q hQρ _ _ hFs hGs hFGπ
+  have hev : v.subst F.toPowerSeries = v.subst Γ.toPowerSeries :=
+    unisubst_eq_of_annihilate π ρ h.annihilate v hvπ _ _ hFs hΓs hFΓρ
+  have hleft : P.subst F.toPowerSeries - Q.subst G.toPowerSeries = v.subst Γ.toPowerSeries := by
+    rw [← hev, PowerSeries.subst_sub hFs]
+    exact congrArg (fun z => P.subst F.toPowerSeries-z) heQ.symm
+  let A : Fin 2 → MvPowerSeries (Fin 2) R := fun i => P.subst (X i)
+  let B : Fin 2 → MvPowerSeries (Fin 2) R := fun i => Q.subst (X i)
+  have hAz (i : Fin 2) : (A i).constantCoeff = 0 :=
+    PowerSeries.constantCoeff_subst_eq_zero (constantCoeff_X i) P (multiplication_constant F p)
+  have hBz (i : Fin 2) : (B i).constantCoeff = 0 :=
+    PowerSeries.constantCoeff_subst_eq_zero (constantCoeff_X i) Q (multiplication_constant G p)
+  have hAs : HasSubst A := hasSubst_of_constantCoeff_zero hAz
+  have hBs : HasSubst B := hasSubst_of_constantCoeff_zero hBz
+  have hABπ : ∀ i, (A i).map π = (B i).map π := by
+    intro i; dsimp [A,B]
+    rw [PowerSeries.map_subst (PowerSeries.HasSubst.X i), PowerSeries.map_subst (PowerSeries.HasSubst.X i), hPπ]
+  have hAXρ : ∀ i, (A i).map ρ = ((X i : MvPowerSeries (Fin 2) R)^(p^3)).map ρ := by
+    intro i; dsimp [A]
+    rw [PowerSeries.map_subst (PowerSeries.HasSubst.X i), hPρ, map_X,
+      PowerSeries.subst_pow (PowerSeries.HasSubst.X i), PowerSeries.subst_X (PowerSeries.HasSubst.X i), map_pow, map_X]
+  have hDD : D.subst A = expand (p^3) (pow_ne_zero _ hp.out.ne_zero) D := by
+    rw [expand, substAlgHom_apply]
+    exact subst_eq_of_annihilate π ρ h.annihilate D hDπ A _ hAs (HasSubst.X_pow (pow_ne_zero _ hp.out.ne_zero)) hAXρ
+  have hGG := law_perturbation p π ρ h G Γ hGΓρ H hΓ A B hAs hBs hABπ
+  have hright : F.toPowerSeries.subst A - G.toPowerSeries.subst B =
+      expand (p^3) (pow_ne_zero _ hp.out.ne_zero) D + v.subst (X 0) + v.subst (X 1) := by
+    change (F.toPowerSeries-G.toPowerSeries).subst A = _ at hDD
+    rw [MvPowerSeries.subst_sub hAs] at hDD
+    simp only [v, PowerSeries.subst_sub (PowerSeries.HasSubst.X (0 : Fin 2)),
+      PowerSeries.subst_sub (PowerSeries.HasSubst.X (1 : Fin 2))]
+    dsimp [A,B] at hGG
+    linear_combination hDD+hGG
+  have heF := multiplication_preserves_addition F p
+  have heG := multiplication_preserves_addition G p
+  have hAF : A = ![P.subst (X 0),P.subst (X 1)] := by funext i; fin_cases i <;> rfl
+  have hBG : B = ![Q.subst (X 0),Q.subst (X 1)] := by funext i; fin_cases i <;> rfl
+  change P.subst F.toPowerSeries = F.toPowerSeries.subst _ at heF
+  change Q.subst G.toPowerSeries = G.toPowerSeries.subst _ at heG
+  rw [← hAF] at heF
+  rw [← hBG] at heG
+  change v.subst Γ.toPowerSeries-v.subst (X 0)-v.subst (X 1) = _
+  linear_combination -hleft + hright + heF - heG
+
+lemma series_map_zero_of_ker_le (π : R →+* S) (ρ : R →+* K)
+    (h : ∀ a, π a = 0 → ρ a = 0) (f : MvPowerSeries σ R) (hf : f.map π = 0) :
+    f.map ρ = 0 := by
+  ext d
+  rw [coeff_map, map_zero]
+  apply h
+  simpa only [coeff_map, map_zero] using congrArg (coeff d) hf
+
+lemma coordinate_of_coboundary (p : ℕ) [hp : Fact p.Prime] [CharP R p]
+    (π : R →+* S) (ρ : R →+* K) (h : IsSmall π ρ)
+    (F G Γ : FormalGroup R) (hF : F.map ρ = Γ.map ρ) (hG : G.map ρ = Γ.map ρ)
+    (H : MvPowerSeries (Fin 2) R)
+    (hΓ : Γ.toPowerSeries = X 0 + X 1 + expand (p^2) (pow_ne_zero _ hp.out.ne_zero) H)
+    (w : PowerSeries R) (hw0 : w.constantCoeff = 0) (hwπ : w.map π = 0)
+    (hd : delta Γ w = F.toPowerSeries-G.toPowerSeries) :
+    ∃ e : CoordinateIso F G, e.series = PowerSeries.X-w ∧ e.series.map π = PowerSeries.X := by
+  have hwρ : w.map ρ = 0 := series_map_zero_of_ker_le π ρ h.ker_le w hwπ
+  let u := PowerSeries.X-w
+  let z := PowerSeries.X+w
+  have hu0 : u.constantCoeff = 0 := by simp [u, hw0]
+  have hz0 : z.constantCoeff = 0 := by simp [z, hw0]
+  have hu : PowerSeries.HasSubst u := .of_constantCoeff_zero hu0
+  have hz : PowerSeries.HasSubst z := .of_constantCoeff_zero hz0
+  have huπ : u.map π = PowerSeries.X := by simp [u,hwπ]
+  have hzπ : z.map π = PowerSeries.X := by simp [z,hwπ]
+  have hwu : w.subst u = w := by
+    have hh := subst_eq_of_squareZero π h.squareZero w hwπ u PowerSeries.X hu PowerSeries.HasSubst.X' (by simpa only [PowerSeries.X, map_X] using (show MvPowerSeries.map π u = PowerSeries.X from huπ))
+    simpa only [PowerSeries.X_subst] using hh
+  have hwz : w.subst z = w := by
+    have hh := subst_eq_of_squareZero π h.squareZero w hwπ z PowerSeries.X hz PowerSeries.HasSubst.X' (by simpa only [PowerSeries.X, map_X] using (show MvPowerSeries.map π z = PowerSeries.X from hzπ))
+    simpa only [PowerSeries.X_subst] using hh
+  have huz : u.subst z = PowerSeries.X := by
+    dsimp [u]; rw [PowerSeries.subst_sub hz, PowerSeries.subst_X hz, hwz]
+    dsimp [z]; ring
+  have hzu : z.subst u = PowerSeries.X := by
+    change (PowerSeries.X+w).subst u = _
+    rw [PowerSeries.subst_add hu, PowerSeries.subst_X hu, hwu]
+    dsimp [u]; ring
+  have hFs : PowerSeries.HasSubst F.toPowerSeries := .of_constantCoeff_zero F.zero_constantCoeff
+  have hΓs : PowerSeries.HasSubst Γ.toPowerSeries := .of_constantCoeff_zero Γ.zero_constantCoeff
+  have hwF : w.subst F.toPowerSeries = w.subst Γ.toPowerSeries :=
+    unisubst_eq_of_annihilate π ρ h.annihilate w hwπ _ _ hFs hΓs (congrArg FormalGroup.toPowerSeries hF)
+  let A : Fin 2 → MvPowerSeries (Fin 2) R := fun i => u.subst (X i)
+  have hAs : HasSubst A := hasSubst_of_constantCoeff_zero (fun i =>
+    PowerSeries.constantCoeff_subst_eq_zero (constantCoeff_X i) u hu0)
+  have hAX : ∀ i, (A i).map π = (X i).map π := by
+    intro i; dsimp [A]
+    rw [PowerSeries.map_subst (PowerSeries.HasSubst.X i), huπ, map_X,
+      PowerSeries.subst_X (PowerSeries.HasSubst.X i)]
+  have hh := law_perturbation p π ρ h G Γ (congrArg FormalGroup.toPowerSeries hG) H hΓ A X hAs HasSubst.X hAX
+  rw [congrFun subst_self G.toPowerSeries] at hh
+  have hA (i : Fin 2) : A i = X i-w.subst (X i) := by
+    dsimp [A,u]; rw [PowerSeries.subst_sub (PowerSeries.HasSubst.X i), PowerSeries.subst_X (PowerSeries.HasSubst.X i)]
+  rw [hA 0,hA 1] at hh
+  dsimp only [id] at hh
+  have he : u.subst F.toPowerSeries = G.toPowerSeries.subst ![u.subst (X 0),u.subst (X 1)] := by
+    change (PowerSeries.X-w).subst F.toPowerSeries = _
+    rw [PowerSeries.subst_sub hFs, PowerSeries.subst_X hFs,hwF]
+    rw [show (![u.subst (X 0),u.subst (X 1)] : Fin 2 → MvPowerSeries (Fin 2) R) = A by
+      funext i; fin_cases i <;> rfl]
+    dsimp [delta] at hd
+    linear_combination -hh-hd
+  refine ⟨⟨u,z,hu0,hz0,huz,hzu,he⟩,rfl,huπ⟩
+
+lemma multiplication_linear (F : FormalGroup R) (n : ℕ) :
+    (multiplicationSeries F n).coeff 1 = (n : R) := by
+  induction n with
+  | zero => simp
+  | succ n ih =>
+    rw [multiplication_succ, OriginalDifferentialSupport.coeff_one_formal_add _ _ _
+      (multiplication_constant F n) PowerSeries.constantCoeff_X, ih]
+    simp
+
+lemma power_expand_iterate (p : ℕ) [hp : Fact p.Prime] (f : MvPowerSeries σ R)
+    (hf : f^p = expand p hp.out.ne_zero f) (n : ℕ) :
+    f^(p^n) = expand (p^n) (pow_ne_zero _ hp.out.ne_zero) f := by
+  induction n with
+  | zero => simp [MvPowerSeries.expand_one]
+  | succ n ih =>
+    calc
+      f^(p^(n+1)) = (f^(p^n))^p := by rw [pow_succ,pow_mul]
+      _ = expand (p^n) (pow_ne_zero _ hp.out.ne_zero) (expand p hp.out.ne_zero f) := by
+        rw [ih, ← map_pow, hf]
+      _ = expand (p^(n+1)) (pow_ne_zero _ hp.out.ne_zero) f := by
+        simpa only [pow_succ] using (expand_mul (p^n) (pow_ne_zero _ hp.out.ne_zero) p hp.out.ne_zero f).symm
+
+theorem small_equivalence_of_matching_parameters [Nontrivial R]
+    (p : ℕ) [hp : Fact p.Prime] [CharP R p]
+    (π : R →+* S) (ρ : R →+* K) (h : IsSmall π ρ)
+    (F G Γ : FormalGroup R) [F.IsComm] [G.IsComm]
+    (hπ : F.map π = G.map π) (hF : F.map ρ = Γ.map ρ) (hG : G.map ρ = Γ.map ρ)
+    (H : MvPowerSeries (Fin 2) R)
+    (hΓ : Γ.toPowerSeries = X 0 + X 1 + expand (p^2) (pow_ne_zero _ hp.out.ne_zero) H)
+    (hΓp : multiplicationSeries Γ p = PowerSeries.X^(p^3))
+    (hΓFr : Γ.toPowerSeries^p = expand p hp.out.ne_zero Γ.toPowerSeries)
+    (h₁ : (multiplicationSeries F p).coeff p = (multiplicationSeries G p).coeff p)
+    (h₂ : (multiplicationSeries F p).coeff (p^2) = (multiplicationSeries G p).coeff (p^2)) :
+    ∃ e : CoordinateIso F G, e.series.map π = PowerSeries.X := by
+  let v := multiplicationSeries F p-multiplicationSeries G p
+  let D := F.toPowerSeries-G.toPowerSeries
+  have hv : delta Γ v = expand (p^3) (pow_ne_zero _ hp.out.ne_zero) D :=
+    linearized_p_hom p π ρ h F G Γ hπ hF hG H hΓ hΓp
+  have hv0 : v.constantCoeff = 0 := by simp [v]
+  have hv1 : v.coeff 1 = 0 := by simp [v, multiplication_linear]
+  have hH : Γ.toPowerSeries-X 0-X 1 = expand (p^2) (pow_ne_zero _ hp.out.ne_zero) H := by rw [hΓ]; ring
+  obtain ⟨a,b,w,hw0,he⟩ := tangent_decomposition p Γ H hΓFr hH v hv0 hv1 D hv
+  have hpp : p < p^2 := by nlinarith [hp.out.one_lt]
+  have hppq : p^2 < p^3 := by exact pow_lt_pow_right₀ hp.out.one_lt (by omega)
+  have hq1 : ¬p^3 ∣ p := Nat.not_dvd_of_pos_of_lt hp.out.pos (lt_trans hpp hppq)
+  have hq2 : ¬p^3 ∣ p^2 := Nat.not_dvd_of_pos_of_lt (pow_pos hp.out.pos _) hppq
+  have hvp : v.coeff p = 0 := by simp only [v,map_sub,h₁,sub_self]
+  have hvp2 : v.coeff (p^2) = 0 := by simp only [v,map_sub,h₂,sub_self]
+  have ha : a = 0 := by
+    have hh := congrArg (PowerSeries.coeff p) he
+    simpa [hvp, PowerSeries.coeff_expand_of_not_dvd _ _ _ hq1, PowerSeries.coeff_X_pow,
+      ne_of_lt hpp, ne_of_gt hpp] using hh.symm
+  have hb : b = 0 := by
+    have hh := congrArg (PowerSeries.coeff (p^2)) he
+    simpa [hvp2, ha, PowerSeries.coeff_expand_of_not_dvd _ _ _ hq2, PowerSeries.coeff_X_pow] using hh.symm
+  have he' : v = PowerSeries.expand (p^3) (pow_ne_zero _ hp.out.ne_zero) w := by simpa [ha,hb] using he
+  have hd : delta Γ w = D := by
+    apply expand_injective (p^3) (pow_ne_zero _ hp.out.ne_zero)
+    rw [← delta_expand (p^3) (pow_ne_zero _ hp.out.ne_zero) Γ
+      (power_expand_iterate p Γ.toPowerSeries hΓFr 3), ← he', hv]
+  have hvπ : v.map π = 0 := by
+    change MvPowerSeries.map π (multiplicationSeries F p-multiplicationSeries G p) = 0
+    rw [map_sub, show MvPowerSeries.map π (multiplicationSeries F p) = multiplicationSeries (F.map π) p from (multiplication_map F π p).symm,
+      show MvPowerSeries.map π (multiplicationSeries G p) = multiplicationSeries (G.map π) p from (multiplication_map G π p).symm, hπ,sub_self]
+  have hwπ : w.map π = 0 := by
+    have hh := hvπ
+    rw [he',PowerSeries.map_expand] at hh
+    ext n
+    have hhc := congrArg (PowerSeries.coeff ((p^3)*n)) hh
+    simpa only [PowerSeries.coeff_expand_mul, map_zero] using hhc
+  obtain ⟨e, _, heπ⟩ := coordinate_of_coboundary p π ρ h F G Γ hF hG H hΓ w hw0 hwπ hd
+  exact ⟨e,heπ⟩
+
+lemma small_isomorphism_pseries (p : ℕ) [hp : Fact p.Prime] [CharP R p]
+    (π : R →+* S) (ρ : R →+* K) (h : IsSmall π ρ)
+    (F G : FormalGroup R) (e : CoordinateIso F G)
+    (he : e.series.map π = PowerSeries.X)
+    (hF : (multiplicationSeries F p).map ρ = PowerSeries.X^(p^3))
+    (hG : (multiplicationSeries G p).map ρ = PowerSeries.X^(p^3)) :
+    multiplicationSeries F p + PowerSeries.expand (p^3) (pow_ne_zero _ hp.out.ne_zero)
+      (e.series-PowerSeries.X) = multiplicationSeries G p := by
+  let d := e.series-PowerSeries.X
+  have hd : d.map π = 0 := by simp [d,he]
+  have hpq : p^3 ≠ 0 := pow_ne_zero _ hp.out.ne_zero
+  have hq : PowerSeries.HasSubst (PowerSeries.X^(p^3) : PowerSeries R) := .X_pow hpq
+  have hdf : d.subst (multiplicationSeries F p) = d.subst (PowerSeries.X^(p^3)) :=
+    unisubst_eq_of_annihilate π ρ h.annihilate d hd _ _
+      (.of_constantCoeff_zero (multiplication_constant F p)) hq
+      (by simpa only [PowerSeries.X,map_pow,map_X] using
+        (show MvPowerSeries.map ρ (multiplicationSeries F p) = PowerSeries.X^(p^3) from hF))
+  have hes : PowerSeries.HasSubst e.series := .of_constantCoeff_zero e.zero_series
+  have hQg : (multiplicationSeries G p).subst e.series = multiplicationSeries G p := by
+    have HH := series_perturbation p 3 (by omega) π ρ h (multiplicationSeries G p) hG
+      e.series PowerSeries.X hes PowerSeries.HasSubst.X'
+      (by simpa only [PowerSeries.X,map_X] using
+        (show MvPowerSeries.map π e.series = PowerSeries.X from he))
+    simpa only [PowerSeries.X_subst] using HH
+  have hc := coordinate_multiplication F G e p
+  rw [hQg] at hc
+  have he' : e.series = PowerSeries.X+d := by dsimp [d]; ring
+  conv_lhs at hc => rw [he',PowerSeries.subst_add (.of_constantCoeff_zero (multiplication_constant F p)),
+    PowerSeries.subst_X (.of_constantCoeff_zero (multiplication_constant F p)),hdf]
+  simpa only [PowerSeries.expand_apply] using hc
+
+lemma small_isomorphism_lowcoeff (p : ℕ) [hp : Fact p.Prime] [CharP R p]
+    (π : R →+* S) (ρ : R →+* K) (h : IsSmall π ρ)
+    (F G : FormalGroup R) (e : CoordinateIso F G)
+    (he : e.series.map π = PowerSeries.X)
+    (hF : (multiplicationSeries F p).map ρ = PowerSeries.X^(p^3))
+    (hG : (multiplicationSeries G p).map ρ = PowerSeries.X^(p^3))
+    (n : ℕ) (hn : 0 < n) (hnq : n < p^3) :
+    (multiplicationSeries F p).coeff n = (multiplicationSeries G p).coeff n := by
+  have HH := congrArg (PowerSeries.coeff n) (small_isomorphism_pseries p π ρ h F G e he hF hG)
+  simpa only [map_add,PowerSeries.coeff_expand_of_not_dvd _ _ _ (Nat.not_dvd_of_pos_of_lt hn hnq),add_zero] using HH
+
+lemma small_automorphism_rigid (p : ℕ) [hp : Fact p.Prime] [CharP R p]
+    (π : R →+* S) (ρ : R →+* K) (h : IsSmall π ρ)
+    (F : FormalGroup R) (e : CoordinateIso F F)
+    (he : e.series.map π = PowerSeries.X)
+    (hF : (multiplicationSeries F p).map ρ = PowerSeries.X^(p^3)) :
+    e.series = PowerSeries.X := by
+  have hh := small_isomorphism_pseries p π ρ h F F e he hF hF
+  have hz : PowerSeries.expand (p^3) (pow_ne_zero _ hp.out.ne_zero) (e.series-PowerSeries.X) = 0 := add_eq_left.mp hh
+  apply sub_eq_zero.mp
+  ext n
+  have hc := congrArg (PowerSeries.coeff ((p^3)*n)) hz
+  simpa only [PowerSeries.coeff_expand_mul,map_zero] using hc
+
+end HeightThree.SmallExtension
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/FormalGroup/Honda/SpecialFiber.lean b/lean/OAI/Algebra/FormalGroup/Honda/SpecialFiber.lean
new file mode 100644
index 0000000000000000000000000000000000000000..362f21316c01caa52730eea390c77a951d55562c
--- /dev/null
+++ b/lean/OAI/Algebra/FormalGroup/Honda/SpecialFiber.lean
@@ -0,0 +1,230 @@
+import OAI.Algebra.FormalGroup.Honda.HeightTwo
+
+namespace OAI
+
+noncomputable section
+
+namespace HeightThree.HondaSpecialFiber
+open MvPowerSeries HondaConstruction HondaTarget HondaCoordinates LogarithmicConstruction PTypical
+
+def augmentation (R : Type*) [CommRing R] : MvPowerSeries (Fin 2) R →ₐ[R] R where
+  __ := MvPowerSeries.constantCoeff
+  commutes' _ := rfl
+
+lemma integerFrobenius (p : ℕ) [hp : Fact p.Prime] (a : ℤ) :
+    (p : ℤ) ∣ (RingHom.id ℤ) a - a^p :=
+  dvd_sub_comm.mp (Int.prime_dvd_pow_self_sub hp.out a)
+
+def specialParameters : Fin 3 → ℤ := ![0,0,1]
+
+def integralSpecial (p : ℕ) [hp : Fact p.Prime] : FormalGroup ℤ :=
+  integralFormalGroup (Int.castRingHom ℚ) Int.cast_injective p (RingHom.id ℤ)
+    (AlgHom.id ℚ ℚ) (by rfl) (integerFrobenius p) specialParameters
+
+def specialLog (p : ℕ) [hp : Fact p.Prime] : StrictLog (R := ℚ) :=
+  heightThreeLog (Int.castRingHom ℚ) p hp.out.two_le (RingHom.id ℤ) specialParameters
+
+lemma integralSpecial_map (p : ℕ) [hp : Fact p.Prime] :
+    (integralSpecial p).map (Int.castRingHom ℚ) = (specialLog p).formalGroup :=
+  integralFormalGroup_map ..
+
+lemma integralHonda_specialize (p : ℕ) [hp : Fact p.Prime] :
+    (integralHonda p).map MvPowerSeries.constantCoeff = integralSpecial p := by
+  have hi : (augmentation ℚ).toRingHom.comp coefficientInclusion =
+      (Int.castRingHom ℚ).comp MvPowerSeries.constantCoeff := by
+    ext f
+    rfl
+  have hψ : (RingHom.id ℤ).comp (MvPowerSeries.constantCoeff (σ := Fin 2)) =
+      MvPowerSeries.constantCoeff.comp (integralFrobenius p hp.out.ne_zero) := by
+    ext f
+    exact (constantCoeff_expand p hp.out.ne_zero f).symm
+  have hv : MvPowerSeries.constantCoeff ∘ parameters = specialParameters := by
+    funext i; fin_cases i <;> simp [parameters, specialParameters]
+  have hh := integralFormalGroup_natural coefficientInclusion coefficientInclusion_injective
+    (Int.castRingHom ℚ) Int.cast_injective MvPowerSeries.constantCoeff
+    (augmentation ℚ) hi p
+    (integralFrobenius p hp.out.ne_zero) (rationalFrobenius p hp.out.ne_zero)
+    (frobenius_compatible p hp.out.ne_zero) (integralFrobenius_congr p)
+    (RingHom.id ℤ) (AlgHom.id ℚ ℚ) (by rfl) (integerFrobenius p) hψ parameters
+  rw [hv] at hh
+  exact hh
+
+lemma specialLog_functional (p : ℕ) [hp : Fact p.Prime] :
+    (p : ℚ) • (specialLog p).series =
+      (p : ℚ) • PowerSeries.X + (specialLog p).series.subst (PowerSeries.X^(p^3)) := by
+  have he := logarithm_functional_equation (Int.castRingHom ℚ) p hp.out.two_le
+    (RingHom.id ℤ) (AlgHom.id ℚ ℚ) (by rfl) specialParameters
+  simp [defect, Fin.sum_univ_three, specialParameters] at he
+  have he' := congrArg (fun x : PowerSeries ℚ => (p : ℚ) • x) he
+  simp only [smul_sub, smul_smul, mul_inv_cancel₀ (by exact_mod_cast hp.out.ne_zero : (p : ℚ) ≠ 0),
+    one_smul] at he'
+  have ht : ((twist p hp.out.ne_zero (RingHom.id ℚ))^3) (specialLog p).series =
+      (specialLog p).series.subst (PowerSeries.X^(p^3)) := by
+    rw [twist_iterate]
+    simp only [show (RingHom.id ℚ)^3 = RingHom.id ℚ by rfl, MvPowerSeries.map_id]
+    exact PowerSeries.expand_apply ..
+  change (p : ℚ) • (specialLog p).series -
+    ((twist p hp.out.ne_zero (RingHom.id ℚ))^3) (specialLog p).series = _ at he'
+  rw [ht] at he'
+  exact sub_eq_iff_eq_add.mp he'
+
+lemma specialLog_divided (p : ℕ) [hp : Fact p.Prime] :
+    ∃ v : StrictLog (R := ℤ),
+      (specialLog p).series.subst ((p : PowerSeries ℚ) * PowerSeries.X) =
+        (p : PowerSeries ℚ) * v.series.map (Int.castRingHom ℚ) := by
+  have hpq : (p : ℚ) ≠ 0 := by exact_mod_cast hp.out.ne_zero
+  have hnum : HasIntegralNumerators (Int.castRingHom ℚ) p (specialLog p).series :=
+    series_integralNumerators _ p hp.out.two_le _
+  obtain ⟨v, hv⟩ := logarithm_difference (Int.castRingHom ℚ) p hp.out.ne_zero
+    (specialLog p).series hnum ((p : PowerSeries ℤ) * PowerSeries.X) 0
+    (by simp [PowerSeries.X]) (by simp) (by simp)
+  simp only [map_mul, map_natCast, PowerSeries.X, map_X, map_zero,
+    PowerSeries.subst_zero_of_constantCoeff_zero (specialLog p).constant_zero, sub_zero] at hv
+  have hc : v.constantCoeff = 0 := by
+    have hh := congrArg (MvPowerSeries.constantCoeff (σ := Unit)) hv
+    rw [PowerSeries.constantCoeff_subst_eq_zero (by simp) _ (specialLog p).constant_zero] at hh
+    simp only [map_mul, map_natCast, MvPowerSeries.constantCoeff_map] at hh
+    have hh' : (v.constantCoeff : ℚ) = 0 := (mul_eq_zero.mp hh.symm).resolve_left hpq
+    exact_mod_cast hh'
+  have hl : PowerSeries.coeff 1 v = 1 := by
+    have hh := congrArg (PowerSeries.coeff 1) hv
+    change MvPowerSeries.coeff (Finsupp.single () 1) _ = _ at hh
+    rw [StrictLog.coeff_subst_linear _ _ (by simp), (specialLog p).linear_one,
+      one_mul] at hh
+    change PowerSeries.coeff 1 ((p : PowerSeries ℚ) * PowerSeries.X) =
+      PowerSeries.coeff 1 ((p : PowerSeries ℚ) * PowerSeries.map (Int.castRingHom ℚ) v) at hh
+    simp only [← map_natCast (PowerSeries.C (R := ℚ)), PowerSeries.coeff_C_mul,
+    PowerSeries.coeff_X, PowerSeries.coeff_map] at hh
+    have hh' : ((PowerSeries.coeff 1 v : ℤ) : ℚ) = 1 := (mul_left_cancel₀ hpq (by simpa using hh.symm))
+    exact_mod_cast hh'
+  exact ⟨⟨v,hc,hl⟩,hv⟩
+
+lemma specialLog_p_error (p : ℕ) [hp : Fact p.Prime] :
+    ∃ a : PowerSeries ℤ, a.constantCoeff = 0 ∧ (p : PowerSeries ℤ) ∣ a ∧
+      (specialLog p).series.subst (a.map (Int.castRingHom ℚ)) =
+        (p : PowerSeries ℚ) * PowerSeries.X := by
+  obtain ⟨v,hv⟩ := specialLog_divided p
+  let b : PowerSeries ℚ := v.inv.map (Int.castRingHom ℚ)
+  have hb : PowerSeries.HasSubst b := PowerSeries.HasSubst.of_constantCoeff_zero
+    (by
+      change (Int.castRingHom ℚ) v.inv.constantCoeff = 0
+      rw [v.inv_constant, map_zero])
+  refine ⟨(p : PowerSeries ℤ) * v.inv, by simp, dvd_mul_right _ _, ?_⟩
+  have hh := congrArg (PowerSeries.subst b) hv
+  rw [PowerSeries.subst_comp_subst_apply
+    (PowerSeries.HasSubst.of_constantCoeff_zero (by simp [PowerSeries.X])) hb] at hh
+  have hx : PowerSeries.subst b ((p : PowerSeries ℚ) * PowerSeries.X) = p * b := by
+    rw [← PowerSeries.coe_substAlgHom hb, map_mul, map_natCast,
+      PowerSeries.substAlgHom_X]
+  have hvb : (v.series.map (Int.castRingHom ℚ)).subst b = PowerSeries.X := by
+    rw [show b = MvPowerSeries.map (Int.castRingHom ℚ) v.inv from rfl,
+      ← PowerSeries.map_subst v.inv_hasSubst, v.subst_inv]
+    exact PowerSeries.map_X _
+  rw [hx, PowerSeries.subst_mul hb] at hh
+  have hnat : PowerSeries.subst b (p : PowerSeries ℚ) = p := by
+    rw [← PowerSeries.coe_substAlgHom hb, map_natCast]
+  rw [hnat, hvb] at hh
+  simpa only [map_mul, map_natCast] using hh
+
+lemma integralSpecial_p_split (p : ℕ) [hp : Fact p.Prime] :
+    ∃ a : PowerSeries ℤ, a.constantCoeff = 0 ∧ (p : PowerSeries ℤ) ∣ a ∧
+      multiplicationSeries (integralSpecial p) p =
+        (integralSpecial p).toPowerSeries.subst ![a, PowerSeries.X^(p^3)] := by
+  obtain ⟨a,ha,had,hal⟩ := specialLog_p_error p
+  have ham : (MvPowerSeries.map (Int.castRingHom ℚ) a).constantCoeff = 0 := by
+    rw [constantCoeff_map]
+    change (Int.castRingHom ℚ) a.constantCoeff = 0
+    rw [ha, map_zero]
+  have hx : (PowerSeries.X^(p^3) : PowerSeries ℚ).constantCoeff = 0 := by
+    simp [PowerSeries.constantCoeff, PowerSeries.X, hp.out.ne_zero]
+  change (specialLog p).series.subst (MvPowerSeries.map (Int.castRingHom ℚ) a) = _ at hal
+  have hQ : multiplicationSeries (specialLog p).formalGroup p =
+      (specialLog p).law.subst ![a.map (Int.castRingHom ℚ), PowerSeries.X^(p^3)] := by
+    apply (specialLog p).subst_injective
+      (PowerSeries.HasSubst.of_constantCoeff_zero (multiplication_constant _ _))
+      (PowerSeries.HasSubst.of_constantCoeff_zero ((specialLog p).law_pair_constant _ _ ham hx))
+    rw [log_multiplication, (specialLog p).log_law_pair _ _ ham hx, hal]
+    convert specialLog_functional p using 1 <;>
+      simp only [smul_eq_C_mul, map_natCast, nsmul_eq_mul]
+  refine ⟨a,ha,had,?_⟩
+  apply map_injective (Int.castRingHom ℚ) Int.cast_injective
+  change PowerSeries.map (Int.castRingHom ℚ) (multiplicationSeries (integralSpecial p) p) = _
+  rw [← multiplication_map, integralSpecial_map]
+  have hpairs : MvPowerSeries.HasSubst ![a, (PowerSeries.X : PowerSeries ℤ)^(p^3)] :=
+    hasSubst_of_constantCoeff_zero (by
+      intro i; fin_cases i; exact ha
+      simp [PowerSeries.X, hp.out.ne_zero])
+  rw [map_subst hpairs]
+  change multiplicationSeries (specialLog p).formalGroup p =
+    ((integralSpecial p).map (Int.castRingHom ℚ)).toPowerSeries.subst _
+  rw [integralSpecial_map]
+  convert hQ using 1
+  congr 2
+  funext i; fin_cases i <;> simp [PowerSeries.X, PowerSeries.map]
+
+theorem integralSpecial_honda (p : ℕ) [hp : Fact p.Prime]
+    (K : Type*) [CommRing K] [CharP K p] :
+    multiplicationSeries ((integralSpecial p).map (Int.castRingHom K)) p =
+      PowerSeries.X^(p^3) := by
+  obtain ⟨a,ha,⟨b,hb⟩,hs⟩ := integralSpecial_p_split p
+  have hap : a.map (Int.castRingHom K) = 0 := by
+    rw [hb, map_mul, map_natCast]
+    have hpK : (p : PowerSeries K) = 0 := by
+      simpa only [map_natCast, map_zero] using congrArg
+        (PowerSeries.C (R := K)) (CharP.cast_eq_zero K p)
+    rw [hpK, zero_mul]
+  rw [multiplication_map, hs]
+  have hpairs : MvPowerSeries.HasSubst ![a, (PowerSeries.X : PowerSeries ℤ)^(p^3)] :=
+    hasSubst_of_constantCoeff_zero (by
+      intro i; fin_cases i; exact ha
+      simp [PowerSeries.X, hp.out.ne_zero])
+  change MvPowerSeries.map (Int.castRingHom K) _ = _
+  rw [map_subst hpairs]
+  have hpair : (fun i => MvPowerSeries.map (Int.castRingHom K)
+      (![a, (PowerSeries.X : PowerSeries ℤ)^(p^3)] i)) =
+      ![0, (PowerSeries.X : PowerSeries K)^(p^3)] := by
+    funext i; fin_cases i
+    · exact hap
+    · simp [PowerSeries.X]
+  rw [hpair]
+  change ((integralSpecial p).map (Int.castRingHom K)).toPowerSeries.subst
+    ![0, (PowerSeries.X : PowerSeries K)^(p^3)] = _
+  exact FormalGroup.zero_add ((integralSpecial p).map (Int.castRingHom K))
+    (PowerSeries.HasSubst.of_constantCoeff_zero
+      (by simp [PowerSeries.X, hp.out.ne_zero]))
+
+def hondaLaw (p : ℕ) [Fact p.Prime] (K : Type*) [CommRing K] : FormalGroup K :=
+  (integralSpecial p).map (Int.castRingHom K)
+
+instance hondaLaw_comm (p : ℕ) [hp : Fact p.Prime] (K : Type*) [CommRing K] :
+    (hondaLaw p K).IsComm := by
+  have : (integralSpecial p).IsComm := integralFormalGroup_isComm ..
+  change ((integralSpecial p).map (Int.castRingHom K)).IsComm
+  infer_instance
+
+lemma reducedHonda_specialFiber (p : ℕ) [hp : Fact p.Prime]
+    (K : Type*) [CommRing K] :
+    (reducedHonda p K).map MvPowerSeries.constantCoeff = hondaLaw p K := by
+  have hc : MvPowerSeries.constantCoeff.comp
+      (MvPowerSeries.map (σ := Fin 2) (Int.castRingHom K)) =
+      (Int.castRingHom K).comp MvPowerSeries.constantCoeff := by
+    ext f
+    rfl
+  change ((integralHonda p).map (MvPowerSeries.map (Int.castRingHom K))).map _ = _
+  rw [formalGroup_map_map, hc, ← formalGroup_map_map, integralHonda_specialize]
+  rfl
+
+theorem constructed_honda_deformation (p : ℕ) [hp : Fact p.Prime]
+    (K : Type*) [CommRing K] [CharP K p] :
+    (reducedHonda p K).IsComm ∧
+    (reducedHonda p K).map MvPowerSeries.constantCoeff = hondaLaw p K ∧
+    multiplicationSeries (hondaLaw p K) p = PowerSeries.X^(p^3) ∧
+    HeightCoordinates p (reducedHonda p K) :=
+  ⟨inferInstance, reducedHonda_specialFiber p K, integralSpecial_honda p K,
+    reducedHonda_heightCoordinates p K⟩
+
+end HeightThree.HondaSpecialFiber
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/FormalGroup/Honda/Tangent.lean b/lean/OAI/Algebra/FormalGroup/Honda/Tangent.lean
new file mode 100644
index 0000000000000000000000000000000000000000..79a7b1acbe1bd33a048eaa0e573d12c4d8a3972b
--- /dev/null
+++ b/lean/OAI/Algebra/FormalGroup/Honda/Tangent.lean
@@ -0,0 +1,209 @@
+import OAI.Algebra.FormalGroup.Honda.Rigidity
+
+namespace OAI
+
+noncomputable section
+
+namespace HeightThree.TangentClassification
+open MvPowerSeries PowerSeriesDifferential
+variable {R σ : Type*} [CommRing R]
+
+lemma expand_injective (q : ℕ) (hq : q ≠ 0) :
+    Function.Injective (MvPowerSeries.expand (R := R) (σ := σ) q hq) := by
+  intro f g h
+  ext d
+  simpa only [coeff_expand_smul] using congrArg (coeff (q • d)) h
+
+lemma pderiv_expand_zero (p : ℕ) [hp : Fact p.Prime] [CharP R p]
+    (f : MvPowerSeries σ R) (i : σ) :
+    pderiv i (expand p hp.out.ne_zero f) = 0 := by
+  ext d
+  rw [coeff_pderiv, map_zero]
+  by_cases h : p ∣ d i + 1
+  · have hn : (d i : R) + 1 = 0 := by
+      simpa only [Nat.cast_add, Nat.cast_one] using (CharP.cast_eq_zero_iff R p (d i+1)).mpr h
+    rw [hn, mul_zero]
+  · rw [coeff_expand_of_not_dvd p hp.out.ne_zero f (i := i) (by simpa using h), zero_mul]
+
+lemma exists_expand_derivative_zero [Nontrivial R] (p : ℕ)
+    [hp : Fact p.Prime] [CharP R p] (f : PowerSeries R)
+    (hf : PowerSeries.derivative f = 0) :
+    ∃ g, PowerSeries.expand p hp.out.ne_zero g = f := by
+  refine ⟨PowerSeries.mk (fun n => f.coeff (p*n)), ?_⟩
+  ext n
+  by_cases hn : p ∣ n
+  · obtain ⟨n, rfl⟩ := hn
+    rw [PowerSeries.coeff_expand_mul, PowerSeries.coeff_mk]
+  · rw [PowerSeries.coeff_expand_of_not_dvd _ _ _ hn]
+    have hn0 : n ≠ 0 := by intro h; exact hn (h ▸ dvd_zero p)
+    have hh := congrArg (PowerSeries.coeff (n-1)) hf
+    rw [PowerSeries.coeff_derivative, Nat.sub_add_cancel (by omega : 1 ≤ n), map_zero] at hh
+    have hunit : IsUnit (n : R) := (CharP.isUnit_natCast_iff hp.out).mpr hn
+    have he : (n-1 : ℕ) + 1 = n := Nat.sub_add_cancel (by omega)
+    have he' : ((n-1 : ℕ) : R)+1 = (n : R) := by simpa only [Nat.cast_add, Nat.cast_one] using congrArg (Nat.cast : ℕ → R) he
+    rw [he'] at hh
+    exact (hunit.mul_left_eq_zero.mp hh).symm
+
+lemma exists_linear_add_expand [Nontrivial R] (p : ℕ)
+    [hp : Fact p.Prime] [CharP R p] (f : PowerSeries R)
+    (hf0 : f.constantCoeff = 0)
+    (hf : PowerSeries.derivative f = PowerSeries.C (f.coeff 1)) :
+    ∃ g : PowerSeries R, g.constantCoeff = 0 ∧
+      f = PowerSeries.C (f.coeff 1) * PowerSeries.X + PowerSeries.expand p hp.out.ne_zero g := by
+  have hzero : PowerSeries.derivative (f - PowerSeries.C (f.coeff 1) * PowerSeries.X) = 0 := by
+    simp [hf]
+  obtain ⟨g, hg⟩ := exists_expand_derivative_zero p _ hzero
+  refine ⟨g, ?_, ?_⟩
+  · have hh := congrArg PowerSeries.constantCoeff hg
+    simpa [hf0] using hh
+  · rw [hg]; ring
+
+def delta (F : FormalGroup R) (f : PowerSeries R) : MvPowerSeries (Fin 2) R :=
+  f.subst F.toPowerSeries - f.subst (X 0) - f.subst (X 1)
+
+lemma delta_sub (F : FormalGroup R) (f g : PowerSeries R) :
+    delta F (f-g) = delta F f - delta F g := by
+  simp only [delta, PowerSeries.subst_sub (PowerSeries.HasSubst.of_constantCoeff_zero F.zero_constantCoeff),
+    PowerSeries.subst_sub (PowerSeries.HasSubst.X (0 : Fin 2)), PowerSeries.subst_sub (PowerSeries.HasSubst.X (1 : Fin 2))]
+  ring
+
+lemma delta_add (F : FormalGroup R) (f g : PowerSeries R) :
+    delta F (f+g) = delta F f + delta F g := by
+  simp only [delta, PowerSeries.subst_add (PowerSeries.HasSubst.of_constantCoeff_zero F.zero_constantCoeff),
+    PowerSeries.subst_add (PowerSeries.HasSubst.X (0 : Fin 2)), PowerSeries.subst_add (PowerSeries.HasSubst.X (1 : Fin 2))]
+  ring
+
+lemma delta_smul (F : FormalGroup R) (a : R) (f : PowerSeries R) :
+    delta F (a • f) = a • delta F f := by
+  simp only [delta, PowerSeries.subst_smul (PowerSeries.HasSubst.of_constantCoeff_zero F.zero_constantCoeff),
+    PowerSeries.subst_smul (PowerSeries.HasSubst.X (0 : Fin 2)), PowerSeries.subst_smul (PowerSeries.HasSubst.X (1 : Fin 2)), smul_sub]
+
+lemma delta_X (F : FormalGroup R) : delta F PowerSeries.X = F.toPowerSeries - X 0 - X 1 := by
+  simp only [delta, PowerSeries.subst_X (PowerSeries.HasSubst.of_constantCoeff_zero F.zero_constantCoeff),
+    PowerSeries.subst_X (PowerSeries.HasSubst.X (0 : Fin 2)), PowerSeries.subst_X (PowerSeries.HasSubst.X (1 : Fin 2))]
+
+lemma pderiv_delta (F : FormalGroup R) (hF : pderiv 0 F.toPowerSeries = 1)
+    (f : PowerSeries R) :
+    pderiv 0 (delta F f) =
+      (PowerSeries.derivative f).subst F.toPowerSeries -
+        (PowerSeries.derivative f).subst (X 0) := by
+  simp only [delta, map_sub, pderiv_subst _ _ F.zero_constantCoeff,
+    pderiv_subst _ _ (constantCoeff_X (R := R) (s := (0 : Fin 2))), pderiv_subst _ _ (constantCoeff_X (R := R) (s := (1 : Fin 2))),
+    hF, pderiv_X]
+  simp
+
+lemma derivative_constant_of_delta_expand (p : ℕ) [hp : Fact p.Prime] [CharP R p]
+    (F : FormalGroup R) (hF : pderiv 0 F.toPowerSeries = 1)
+    (f : PowerSeries R) (D : MvPowerSeries (Fin 2) R)
+    (h : delta F f = expand p hp.out.ne_zero D) :
+    PowerSeries.derivative f = PowerSeries.C (f.coeff 1) := by
+  have hh := congrArg (pderiv 0) h
+  rw [pderiv_delta F hF, pderiv_expand_zero] at hh
+  have he : (PowerSeries.derivative f).subst F.toPowerSeries =
+      (PowerSeries.derivative f).subst (X 0) := sub_eq_zero.mp hh
+  let a : Fin 2 → PowerSeries R := ![0, PowerSeries.X]
+  have ha : MvPowerSeries.HasSubst a := hasSubst_of_constantCoeff_zero (by intro i; fin_cases i <;> simp [a, PowerSeries.X])
+  have he' := congrArg (MvPowerSeries.subst a) he
+  change MvPowerSeries.subst a (MvPowerSeries.subst (fun _ : Unit => F.toPowerSeries) _) =
+    MvPowerSeries.subst a (MvPowerSeries.subst (fun _ : Unit => X 0) _) at he'
+  rw [MvPowerSeries.subst_comp_subst_apply
+    (PowerSeries.HasSubst.of_constantCoeff_zero F.zero_constantCoeff).const ha,
+    MvPowerSeries.subst_comp_subst_apply (PowerSeries.HasSubst.X (0 : Fin 2)).const ha] at he'
+  have hleft : F.toPowerSeries.subst a = PowerSeries.X := by
+    exact F.zero_add PowerSeries.HasSubst.X'
+  simp only [hleft, subst_X ha] at he'
+  change (PowerSeries.derivative f).subst PowerSeries.X =
+    (PowerSeries.derivative f).subst 0 at he'
+  have hc : (PowerSeries.derivative f).constantCoeff = f.coeff 1 := by
+    rw [← PowerSeries.coeff_zero_eq_constantCoeff, PowerSeries.coeff_derivative]
+    simp
+  simpa [PowerSeries.subst_zero_eq_C_constantCoeff, PowerSeries.C, hc] using he'
+
+lemma subst_expand_outer (q : ℕ) (hq : q ≠ 0) (f : PowerSeries R)
+    (a : MvPowerSeries σ R) (ha : PowerSeries.HasSubst a) :
+    (PowerSeries.expand q hq f).subst a = f.subst (a^q) := by
+  rw [PowerSeries.expand_apply, PowerSeries.subst_comp_subst_apply
+    (PowerSeries.HasSubst.X_pow hq) ha, PowerSeries.subst_pow ha,
+    PowerSeries.subst_X ha]
+
+lemma delta_expand (q : ℕ) (hq : q ≠ 0) (F : FormalGroup R)
+    (hF : F.toPowerSeries^q = expand q hq F.toPowerSeries) (f : PowerSeries R) :
+    delta F (PowerSeries.expand q hq f) = expand q hq (delta F f) := by
+  rw [delta, subst_expand_outer q hq f _ (PowerSeries.HasSubst.of_constantCoeff_zero F.zero_constantCoeff),
+    subst_expand_outer q hq f _ (PowerSeries.HasSubst.X (0 : Fin 2)),
+    subst_expand_outer q hq f _ (PowerSeries.HasSubst.X (1 : Fin 2)), hF]
+  simp only [delta, map_sub, PowerSeries.expand_subst q hq
+    (PowerSeries.HasSubst.of_constantCoeff_zero F.zero_constantCoeff),
+    PowerSeries.expand_subst q hq (PowerSeries.HasSubst.X (0 : Fin 2)),
+    PowerSeries.expand_subst q hq (PowerSeries.HasSubst.X (1 : Fin 2)), expand_X]
+
+lemma partial_of_nonlinear_expand (p : ℕ) [hp : Fact p.Prime] [CharP R p]
+    (F : FormalGroup R) (H : MvPowerSeries (Fin 2) R)
+    (hF : F.toPowerSeries - X 0 - X 1 = expand (p^2) (pow_ne_zero _ hp.out.ne_zero) H) :
+    pderiv 0 F.toPowerSeries = 1 := by
+  have hfac : expand (p^2) (pow_ne_zero _ hp.out.ne_zero) H =
+      expand p hp.out.ne_zero (expand p hp.out.ne_zero H) := by
+    simpa only [pow_two] using expand_mul p hp.out.ne_zero p hp.out.ne_zero H
+  have he : F.toPowerSeries = X 0 + X 1 + expand p hp.out.ne_zero (expand p hp.out.ne_zero H) := by
+    rw [← hfac, ← hF]; ring
+  rw [he, map_add, map_add, pderiv_expand_zero]
+  simp
+
+theorem tangent_decomposition [Nontrivial R] (p : ℕ) [hp : Fact p.Prime] [CharP R p]
+    (F : FormalGroup R) (H : MvPowerSeries (Fin 2) R)
+    (hF : F.toPowerSeries^p = expand p hp.out.ne_zero F.toPowerSeries)
+    (hH : F.toPowerSeries - X 0 - X 1 = expand (p^2) (pow_ne_zero _ hp.out.ne_zero) H)
+    (v : PowerSeries R) (hv0 : v.constantCoeff = 0) (hv1 : v.coeff 1 = 0)
+    (D : MvPowerSeries (Fin 2) R)
+    (hv : delta F v = expand (p^3) (pow_ne_zero _ hp.out.ne_zero) D) :
+    ∃ (a b : R) (w : PowerSeries R), w.constantCoeff = 0 ∧
+      v = a • PowerSeries.X^p + b • PowerSeries.X^(p^2) +
+        PowerSeries.expand (p^3) (pow_ne_zero _ hp.out.ne_zero) w := by
+  have hpartial := partial_of_nonlinear_expand p F H hH
+  have hfac3 (D : MvPowerSeries (Fin 2) R) :
+      expand (p^3) (pow_ne_zero _ hp.out.ne_zero) D =
+        expand p hp.out.ne_zero (expand (p^2) (pow_ne_zero _ hp.out.ne_zero) D) := by
+    simpa only [show p^3 = p*(p^2) by ring] using
+      expand_mul p hp.out.ne_zero (p^2) (pow_ne_zero _ hp.out.ne_zero) D
+  have hfac2 (D : MvPowerSeries (Fin 2) R) :
+      expand (p^2) (pow_ne_zero _ hp.out.ne_zero) D =
+        expand p hp.out.ne_zero (expand p hp.out.ne_zero D) := by
+    simpa only [pow_two] using expand_mul p hp.out.ne_zero p hp.out.ne_zero D
+  have hdv : PowerSeries.derivative v = 0 := by
+    rw [derivative_constant_of_delta_expand p F hpartial v _ (by rw [← hfac3]; exact hv), hv1, map_zero]
+  obtain ⟨v₁, hv₁⟩ := exists_expand_derivative_zero p v hdv
+  have hv₁0 : v₁.constantCoeff = 0 := by
+    simpa only [PowerSeries.constantCoeff_expand, hv0] using congrArg PowerSeries.constantCoeff hv₁
+  have hdv₁ : delta F v₁ = expand (p^2) (pow_ne_zero _ hp.out.ne_zero) D := by
+    apply expand_injective p hp.out.ne_zero
+    rw [← delta_expand p hp.out.ne_zero F hF, hv₁, ← hfac3, hv]
+  have hh₁ := derivative_constant_of_delta_expand p F hpartial v₁ _ (by rw [← hfac2]; exact hdv₁)
+  obtain ⟨v₂, hv₂0, hv₂⟩ := exists_linear_add_expand p v₁ hv₁0 hh₁
+  let a := v₁.coeff 1
+  have he₁ : v₁ = a • PowerSeries.X + PowerSeries.expand p hp.out.ne_zero v₂ := by
+    simpa only [smul_eq_mul, ← PowerSeries.smul_eq_C_mul] using hv₂
+  have hdv₂ : delta F v₂ = expand p hp.out.ne_zero (D - a • H) := by
+    have he := hdv₁
+    rw [he₁, delta_add, delta_smul, delta_X, hH, delta_expand p hp.out.ne_zero F hF] at he
+    apply expand_injective p hp.out.ne_zero
+    rw [← hfac2, map_sub, map_smul]
+    apply eq_sub_iff_add_eq.mpr
+    simpa only [add_comm] using he
+  have hh₂ := derivative_constant_of_delta_expand p F hpartial v₂ _ hdv₂
+  obtain ⟨w, hw0, hw⟩ := exists_linear_add_expand p v₂ hv₂0 hh₂
+  let b := v₂.coeff 1
+  have he₂ : v₂ = b • PowerSeries.X + PowerSeries.expand p hp.out.ne_zero w := by
+    simpa only [smul_eq_mul, ← PowerSeries.smul_eq_C_mul] using hw
+  refine ⟨a, b, w, hw0, ?_⟩
+  rw [← hv₁, he₁, he₂]
+  simp only [map_add, map_smul, map_pow, PowerSeries.expand_X]
+  rw [← PowerSeries.expand_mul, ← PowerSeries.expand_mul, ← pow_mul]
+  have he2 : p*p = p^2 := by ring
+  have he3 : p^2*p = p^3 := by ring
+  simp only [he2, he3, add_assoc]
+
+end HeightThree.TangentClassification
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/FormalGroup/Honda/Target.lean b/lean/OAI/Algebra/FormalGroup/Honda/Target.lean
new file mode 100644
index 0000000000000000000000000000000000000000..fda18a737bd9c58bda98d7ff1eb011340140daa0
--- /dev/null
+++ b/lean/OAI/Algebra/FormalGroup/Honda/Target.lean
@@ -0,0 +1,63 @@
+import Mathlib
+
+namespace OAI
+
+noncomputable section
+
+namespace HeightThree.HondaTarget
+
+universe u
+
+abbrev Base (K : Type*) [CommRing K] := MvPowerSeries (Fin 2) K
+
+def variablePoint {R : Type*} [CommRing R] (F : FormalGroup R) : F.Point Unit :=
+  ⟨PowerSeries.X, PowerSeries.HasSubst.X'⟩
+
+def multiplicationSeries {R : Type*} [CommRing R] (F : FormalGroup R) (n : ℕ) :
+    PowerSeries R := (n • variablePoint F).val
+
+structure CoordinateIso {R : Type*} [CommRing R] (F G : FormalGroup R) where
+  series : PowerSeries R
+  inverse : PowerSeries R
+  zero_series : series.constantCoeff = 0
+  zero_inverse : inverse.constantCoeff = 0
+  left_inv : series.subst inverse = PowerSeries.X
+  right_inv : inverse.subst series = PowerSeries.X
+  preserves_addition :
+    series.subst F.toPowerSeries =
+      G.toPowerSeries.subst
+        ![series.subst (MvPowerSeries.X 0), series.subst (MvPowerSeries.X 1)]
+
+def FramedEquivalent {K R : Type*} [CommRing K] [CommRing R]
+    (ρ : R →+* K) (F G : FormalGroup R) : Prop :=
+  ∃ e : CoordinateIso F G, PowerSeries.map ρ e.series = PowerSeries.X
+
+def HeightCoordinates {K : Type*} [CommRing K] (p : ℕ)
+    (G : FormalGroup (Base K)) : Prop :=
+  (∀ j < p, (multiplicationSeries G p).coeff j = 0) ∧
+  (multiplicationSeries G p).coeff p = MvPowerSeries.X 0 ∧
+  (∀ j < p^2, (multiplicationSeries G p).coeff j ∈
+    Ideal.span ({MvPowerSeries.X 0} : Set (Base K))) ∧
+  (multiplicationSeries G p).coeff (p^2) - MvPowerSeries.X 1 ∈
+    Ideal.span ({MvPowerSeries.X 0} : Set (Base K))
+
+def IsUniversal {K : Type u} [Field K] (Γ : FormalGroup K)
+    (G : FormalGroup (Base K)) : Prop :=
+  ∀ (R : Type u) [CommRing R] [Algebra K R] [IsLocalRing R]
+    [FiniteDimensional K R] (ρ : R →ₐ[K] K) (F : FormalGroup R),
+    F.IsComm → F.map ρ.toRingHom = Γ →
+    ∃! f : Base K →ₐ[K] R,
+      ρ.toRingHom.comp f.toRingHom = MvPowerSeries.constantCoeff ∧
+      FramedEquivalent ρ.toRingHom (G.map f.toRingHom) F
+
+def HasUniversalHeightCoordinates {K : Type u} [Field K] (p : ℕ)
+    (Γ : FormalGroup K) : Prop :=
+  ∃ G : FormalGroup (Base K),
+    G.IsComm ∧ G.map MvPowerSeries.constantCoeff = Γ ∧
+    IsUniversal Γ G ∧ HeightCoordinates p G
+
+end HeightThree.HondaTarget
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/FormalGroup/Honda/Transport.lean b/lean/OAI/Algebra/FormalGroup/Honda/Transport.lean
new file mode 100644
index 0000000000000000000000000000000000000000..db567fe485304b6b80ddc2274e5bb030f3f35016
--- /dev/null
+++ b/lean/OAI/Algebra/FormalGroup/Honda/Transport.lean
@@ -0,0 +1,382 @@
+import OAI.Algebra.FormalGroup.Honda.SmallExtension
+
+namespace OAI
+
+noncomputable section
+
+namespace HeightThree.CoordinateTransport
+open MvPowerSeries HondaTarget DeformationRigidity OriginalDifferentialSupport
+variable {R S : Type*} [CommRing R] [CommRing S]
+
+lemma constantCoeff_pderiv {σ : Type*} (f : MvPowerSeries σ R) (i : σ) :
+    constantCoeff (pderiv i f) = coeff (Finsupp.single i 1) f := by
+  rw [←coeff_zero_eq_constantCoeff,coeff_pderiv]; simp
+
+lemma linear_subst {σ τ : Type*} [Fintype σ] (f : MvPowerSeries σ R)
+    (a : σ → MvPowerSeries τ R) (ha : ∀ i, (a i).constantCoeff = 0) (j : τ) :
+    coeff (Finsupp.single j 1) (f.subst a) =
+      ∑ i, coeff (Finsupp.single i 1) f * coeff (Finsupp.single j 1) (a i) := by
+  rw [←constantCoeff_pderiv, pderiv_subst a (hasSubst_of_constantCoeff_zero ha)]
+  simp only [map_sum,map_mul,constantCoeff_subst_zero_axis _ (hasSubst_of_constantCoeff_zero ha) ha,
+    constantCoeff_pderiv]
+
+lemma unilinear_subst {σ : Type*} (f : PowerSeries R) (a : MvPowerSeries σ R)
+    (ha : a.constantCoeff = 0) (i : σ) :
+    coeff (Finsupp.single i 1) (f.subst a) = f.coeff 1*coeff (Finsupp.single i 1) a := by
+  simpa [PowerSeries.subst,PowerSeries.coeff] using linear_subst f (fun _ : Unit => a) (fun _ => ha) i
+
+structure Coordinate (R : Type*) [CommRing R] where
+  series : PowerSeries R
+  inverse : PowerSeries R
+  zero_series : series.constantCoeff = 0
+  zero_inverse : inverse.constantCoeff = 0
+  left_inv : series.subst inverse = PowerSeries.X
+  right_inv : inverse.subst series = PowerSeries.X
+
+namespace Coordinate
+variable (c : Coordinate R)
+def ofSeries (u : PowerSeries R) (hu : u.constantCoeff=0) (hunit : IsUnit (u.coeff 1)) : Coordinate R where
+  series := u
+  inverse := u.substInvOfIsUnit hunit
+  zero_series := hu
+  zero_inverse := PowerSeries.constantCoeff_substInvOfIsUnit _ _
+  left_inv := PowerSeries.subst_substInvOfIsUnit_right _ hu hunit
+  right_inv := PowerSeries.subst_substInvOfIsUnit_left _ hu hunit
+
+def symm : Coordinate R := ⟨c.inverse,c.series,c.zero_inverse,c.zero_series,c.right_inv,c.left_inv⟩
+
+lemma hasSubst : PowerSeries.HasSubst c.series := .of_constantCoeff_zero c.zero_series
+lemma inv_hasSubst : PowerSeries.HasSubst c.inverse := .of_constantCoeff_zero c.zero_inverse
+lemma series_const {σ} (a : MvPowerSeries σ R) (ha : a.constantCoeff=0) :
+    (c.series.subst a).constantCoeff=0 := PowerSeries.constantCoeff_subst_eq_zero ha _ c.zero_series
+lemma inverse_const {σ} (a : MvPowerSeries σ R) (ha : a.constantCoeff=0) :
+    (c.inverse.subst a).constantCoeff=0 := PowerSeries.constantCoeff_subst_eq_zero ha _ c.zero_inverse
+
+lemma series_inverse {σ} (a : MvPowerSeries σ R) (ha : PowerSeries.HasSubst a) :
+    c.series.subst (c.inverse.subst a)=a := by
+  rw [←PowerSeries.subst_comp_subst_apply c.inv_hasSubst ha,c.left_inv,PowerSeries.subst_X ha]
+lemma inverse_series {σ} (a : MvPowerSeries σ R) (ha : PowerSeries.HasSubst a) :
+    c.inverse.subst (c.series.subst a)=a := by
+  rw [←PowerSeries.subst_comp_subst_apply c.hasSubst ha,c.right_inv,PowerSeries.subst_X ha]
+lemma inverse_injective {σ} (a b : MvPowerSeries σ R)
+    (ha : PowerSeries.HasSubst a) (hb : PowerSeries.HasSubst b)
+    (he : c.inverse.subst a=c.inverse.subst b) : a=b := by
+  have hh := congrArg (fun z => c.series.subst z) he
+  simpa only [c.series_inverse _ ha,c.series_inverse _ hb] using hh
+
+lemma linear_inverse : c.series.coeff 1*c.inverse.coeff 1=1 := by
+  have hh := congrArg (PowerSeries.coeff 1) c.left_inv
+  rw [show PowerSeries.coeff 1 (c.series.subst c.inverse) = c.series.coeff 1*c.inverse.coeff 1 from
+    unilinear_subst _ _ c.zero_inverse (), PowerSeries.coeff_one_X] at hh
+  exact hh
+
+def law (F : FormalGroup R) : MvPowerSeries (Fin 2) R :=
+  c.series.subst (F.toPowerSeries.subst ![c.inverse.subst (X 0), c.inverse.subst (X 1)])
+
+lemma formal_pair_const (F : FormalGroup R) {σ} (a b : MvPowerSeries σ R)
+    (ha : a.constantCoeff=0) (hb : b.constantCoeff=0) :
+    (F.toPowerSeries.subst ![a,b]).constantCoeff=0 :=
+  constantCoeff_subst_eq_zero (hasSubst_of_constantCoeff_zero (by intro i; fin_cases i <;> assumption))
+    (by intro i; fin_cases i <;> assumption) F.zero_constantCoeff
+
+lemma law_const (F : FormalGroup R) : (c.law F).constantCoeff=0 :=
+  c.series_const _ (formal_pair_const F _ _ (c.inverse_const _ (by simp)) (c.inverse_const _ (by simp)))
+
+lemma law_pair (F : FormalGroup R) {σ} (a b : MvPowerSeries σ R)
+    (ha : a.constantCoeff=0) (hb : b.constantCoeff=0) :
+    (c.law F).subst ![a,b] =
+      c.series.subst (F.toPowerSeries.subst ![c.inverse.subst a,c.inverse.subst b]) := by
+  have hab : HasSubst ![a,b] := hasSubst_of_constantCoeff_zero (by intro i; fin_cases i <;> assumption)
+  have hi (i : Fin 2) : (c.inverse.subst (X i : MvPowerSeries (Fin 2) R)).constantCoeff=0 := c.inverse_const _ (by simp)
+  have his : HasSubst ![c.inverse.subst (X 0 : MvPowerSeries (Fin 2) R),c.inverse.subst (X 1)] :=
+    hasSubst_of_constantCoeff_zero (by intro i; fin_cases i <;> exact hi _)
+  rw [law,subst_after_mv _ _ (.of_constantCoeff_zero (formal_pair_const F _ _ (hi _) (hi _))) _ hab,
+    MvPowerSeries.subst_comp_subst_apply his hab]
+  congr 2
+  funext i; fin_cases i
+  · change (c.inverse.subst (X 0 : MvPowerSeries (Fin 2) R)).subst ![a,b] = c.inverse.subst a
+    rw [subst_after_mv _ _ (PowerSeries.HasSubst.X _) _ hab,subst_X hab]; rfl
+  · change (c.inverse.subst (X 1 : MvPowerSeries (Fin 2) R)).subst ![a,b] = c.inverse.subst b
+    rw [subst_after_mv _ _ (PowerSeries.HasSubst.X _) _ hab,subst_X hab]; rfl
+  
+lemma law_pair_const (F : FormalGroup R) {σ} (a b : MvPowerSeries σ R)
+    (ha : a.constantCoeff=0) (hb : b.constantCoeff=0) :
+    ((c.law F).subst ![a,b]).constantCoeff=0 := by
+  rw [c.law_pair F a b ha hb]
+  exact c.series_const _ (formal_pair_const F _ _ (c.inverse_const _ ha) (c.inverse_const _ hb))
+
+lemma inverse_law_pair (F : FormalGroup R) {σ} (a b : MvPowerSeries σ R)
+    (ha : a.constantCoeff=0) (hb : b.constantCoeff=0) :
+    c.inverse.subst ((c.law F).subst ![a,b]) =
+      F.toPowerSeries.subst ![c.inverse.subst a,c.inverse.subst b] := by
+  rw [c.law_pair F a b ha hb]
+  exact c.inverse_series _ (.of_constantCoeff_zero
+    (formal_pair_const F _ _ (c.inverse_const _ ha) (c.inverse_const _ hb)))
+
+lemma law_linear (F : FormalGroup R) (i : Fin 2) :
+    coeff (Finsupp.single i 1) (c.law F)=1 := by
+  rw [law,unilinear_subst _ _ (formal_pair_const F _ _ (c.inverse_const _ (by simp)) (c.inverse_const _ (by simp)))]
+  rw [linear_subst _ _ (by intro j; fin_cases j <;> exact c.inverse_const _ (by simp))]
+  simp only [Fin.sum_univ_two,Matrix.cons_val_zero,Matrix.cons_val_one,F.lin_coeff_X,F.lin_coeff_Y,one_mul]
+  change c.series.coeff 1*(coeff (Finsupp.single i 1) (c.inverse.subst (X 0)) +
+    coeff (Finsupp.single i 1) (c.inverse.subst (X 1)))=1
+  rw [unilinear_subst _ _ (constantCoeff_X 0),unilinear_subst _ _ (constantCoeff_X 1)]
+  fin_cases i <;> simpa [coeff_index_single_X] using c.linear_inverse
+
+def transport (F : FormalGroup R) : FormalGroup R where
+  toPowerSeries := c.law F
+  zero_constantCoeff := c.law_const F
+  lin_coeff_X := c.law_linear F 0
+  lin_coeff_Y := c.law_linear F 1
+  assoc := by
+    have hx (i : Fin 3) : (X i : MvPowerSeries (Fin 3) R).constantCoeff=0 := by simp
+    apply c.inverse_injective _ _
+      (.of_constantCoeff_zero (c.law_pair_const F _ _ (c.law_pair_const F _ _ (hx 0) (hx 1)) (hx 2)))
+      (.of_constantCoeff_zero (c.law_pair_const F _ _ (hx 0) (c.law_pair_const F _ _ (hx 1) (hx 2))))
+    rw [c.inverse_law_pair F _ _ (c.law_pair_const F _ _ (hx 0) (hx 1)) (hx 2),
+      c.inverse_law_pair F _ _ (hx 0) (c.law_pair_const F _ _ (hx 1) (hx 2)),
+      c.inverse_law_pair F _ _ (hx 0) (hx 1),c.inverse_law_pair F _ _ (hx 1) (hx 2)]
+    exact F.assoc' (.of_constantCoeff_zero (c.inverse_const _ (hx 0)))
+      (.of_constantCoeff_zero (c.inverse_const _ (hx 1))) (.of_constantCoeff_zero (c.inverse_const _ (hx 2)))
+
+instance transport_isComm (F : FormalGroup R) [F.IsComm] : (c.transport F).IsComm where
+  comm := by
+    change c.law F = (c.law F).subst ![X 1,X 0]
+    rw [c.law_pair F _ _ (by simp) (by simp)]
+    exact congrArg (fun z => c.series.subst z) (F.comm'
+      (.of_constantCoeff_zero (c.inverse_const _ (by simp))) (.of_constantCoeff_zero (c.inverse_const _ (by simp))))
+
+def iso (F : FormalGroup R) : CoordinateIso F (c.transport F) where
+  series := c.series
+  inverse := c.inverse
+  zero_series := c.zero_series
+  zero_inverse := c.zero_inverse
+  left_inv := c.left_inv
+  right_inv := c.right_inv
+  preserves_addition := by
+    change c.series.subst F.toPowerSeries = (c.law F).subst ![c.series.subst (X 0),c.series.subst (X 1)]
+    rw [c.law_pair F _ _ (c.series_const _ (by simp)) (c.series_const _ (by simp)),
+      c.inverse_series _ (PowerSeries.HasSubst.X _),c.inverse_series _ (PowerSeries.HasSubst.X _)]
+    have hX : ![X 0,X 1] = (X : Fin 2 → MvPowerSeries (Fin 2) R) := by
+      funext i; fin_cases i <;> rfl
+    rw [hX,MvPowerSeries.subst_self]
+    rfl
+
+def map (π : R →+* S) : Coordinate S where
+  series := c.series.map π
+  inverse := c.inverse.map π
+  zero_series := by
+    change π (PowerSeries.constantCoeff c.series)=0
+    rw [c.zero_series,map_zero]
+  zero_inverse := by
+    change π (PowerSeries.constantCoeff c.inverse)=0
+    rw [c.zero_inverse,map_zero]
+  left_inv := by
+    change (c.series.map π).subst (MvPowerSeries.map π c.inverse)=PowerSeries.X
+    rw [←PowerSeries.map_subst c.inv_hasSubst,c.left_inv]
+    exact PowerSeries.map_X π
+  right_inv := by
+    change (c.inverse.map π).subst (MvPowerSeries.map π c.series)=PowerSeries.X
+    rw [←PowerSeries.map_subst c.hasSubst,c.right_inv]
+    exact PowerSeries.map_X π
+
+lemma transport_map (F : FormalGroup R) (π : R →+* S) :
+    (c.transport F).map π = (c.map π).transport (F.map π) := by
+  apply FormalGroup.ext
+  change MvPowerSeries.map π (c.law F) = (c.map π).law (F.map π)
+  have hi (i : Fin 2) : (c.inverse.subst (X i : MvPowerSeries (Fin 2) R)).constantCoeff=0 := c.inverse_const _ (by simp)
+  rw [law,PowerSeries.map_subst (.of_constantCoeff_zero (formal_pair_const F _ _ (hi _) (hi _))),
+    MvPowerSeries.map_subst (hasSubst_of_constantCoeff_zero (by intro i; fin_cases i <;> exact hi _))]
+  change (c.series.map π).subst _ = (c.series.map π).subst ((F.map π).toPowerSeries.subst _)
+  congr 2
+  funext i; fin_cases i
+  · change (c.inverse.subst (X 0 : MvPowerSeries (Fin 2) R)).map π = (c.inverse.map π).subst (X 0)
+    rw [PowerSeries.map_subst (PowerSeries.HasSubst.X _),MvPowerSeries.map_X]
+  · change (c.inverse.subst (X 1 : MvPowerSeries (Fin 2) R)).map π = (c.inverse.map π).subst (X 1)
+    rw [PowerSeries.map_subst (PowerSeries.HasSubst.X _),MvPowerSeries.map_X]
+
+def ofIso {F G : FormalGroup R} (e : CoordinateIso F G) : Coordinate R :=
+  ⟨e.series,e.inverse,e.zero_series,e.zero_inverse,e.left_inv,e.right_inv⟩
+
+lemma transport_ofIso {F G : FormalGroup R} (e : CoordinateIso F G) :
+    (ofIso e).transport F=G := by
+  apply FormalGroup.ext
+  change e.series.subst (F.toPowerSeries.subst ![e.inverse.subst (X 0),e.inverse.subst (X 1)])=G.toPowerSeries
+  rw [coordinate_add F G e (e.inverse.subst (X 0 : MvPowerSeries (Fin 2) R))
+    (e.inverse.subst (X 1)) ((ofIso e).inverse_const _ (by simp)) ((ofIso e).inverse_const _ (by simp))]
+  change G.toPowerSeries.subst ![(ofIso e).series.subst ((ofIso e).inverse.subst (X 0)),
+    (ofIso e).series.subst ((ofIso e).inverse.subst (X 1))]=G.toPowerSeries
+  rw [(ofIso e).series_inverse _ (PowerSeries.HasSubst.X _),
+    (ofIso e).series_inverse _ (PowerSeries.HasSubst.X _)]
+  have hX : ![X 0,X 1] = (X : Fin 2 → MvPowerSeries (Fin 2) R) := by
+    funext i; fin_cases i <;> rfl
+  rw [hX,MvPowerSeries.subst_self]; rfl
+
+lemma map_eq_of_series_eq (π : R →+* S) (d : Coordinate S)
+    (he : c.series.map π=d.series) : c.map π=d := by
+  have hi : c.inverse.map π=d.inverse := by
+    have hh := congrArg (fun z => d.inverse.subst z) (c.map π).left_inv
+    rw [show (c.map π).series=d.series from he,d.inverse_series _ (c.map π).inv_hasSubst,
+      PowerSeries.X_subst] at hh
+    exact hh
+  cases c; cases d
+  cases he; cases hi
+  rfl
+
+def ident : Coordinate R :=
+  ⟨PowerSeries.X,PowerSeries.X,by simp,by simp,PowerSeries.X_subst _,PowerSeries.X_subst _⟩
+
+lemma transport_ident (F : FormalGroup R) : (ident (R := R)).transport F=F := by
+  apply FormalGroup.ext
+  change PowerSeries.X.subst (F.toPowerSeries.subst ![PowerSeries.X.subst (X 0),PowerSeries.X.subst (X 1)])=F.toPowerSeries
+  rw [PowerSeries.subst_X (PowerSeries.HasSubst.X _),PowerSeries.subst_X (PowerSeries.HasSubst.X _)]
+  have hX : ![X 0,X 1] = (X : Fin 2 → MvPowerSeries (Fin 2) R) := by
+    funext i; fin_cases i <;> rfl
+  rw [hX,MvPowerSeries.subst_self]
+  exact PowerSeries.subst_X (.of_constantCoeff_zero F.zero_constantCoeff)
+
+lemma transport_map_eq_self (F : FormalGroup R) (π : R →+* S)
+    (he : c.series.map π=PowerSeries.X) : (c.transport F).map π=F.map π := by
+  rw [c.transport_map, c.map_eq_of_series_eq π ident he, transport_ident]
+
+def comp (d : Coordinate R) : Coordinate R where
+  series := d.series.subst c.series
+  inverse := c.inverse.subst d.inverse
+  zero_series := d.series_const _ c.zero_series
+  zero_inverse := c.inverse_const _ d.zero_inverse
+  left_inv := by
+    rw [PowerSeries.subst_comp_subst_apply c.hasSubst
+      (.of_constantCoeff_zero (c.inverse_const _ d.zero_inverse)),
+      c.series_inverse _ d.inv_hasSubst,d.left_inv]
+  right_inv := by
+    rw [PowerSeries.subst_comp_subst_apply d.inv_hasSubst
+      (.of_constantCoeff_zero (d.series_const _ c.zero_series)),
+      d.inverse_series _ c.hasSubst,c.right_inv]
+
+end Coordinate
+
+namespace CoordinateIso
+open Coordinate
+
+def refl (F : FormalGroup R) : CoordinateIso F F := by
+  have e := (Coordinate.ident (R := R)).iso F
+  rw [Coordinate.transport_ident] at e
+  exact e
+
+def symm {F G : FormalGroup R} (e : CoordinateIso F G) : CoordinateIso G F where
+  __ := (Coordinate.ofIso e).symm
+  preserves_addition := by
+    have hh := coordinate_add F G e (e.inverse.subst (X 0 : MvPowerSeries (Fin 2) R)) (e.inverse.subst (X 1))
+      ((Coordinate.ofIso e).inverse_const _ (by simp)) ((Coordinate.ofIso e).inverse_const _ (by simp))
+    have hX : ![X 0,X 1] = (X : Fin 2 → MvPowerSeries (Fin 2) R) := by
+      funext i; fin_cases i <;> rfl
+    have hi0 := (Coordinate.ofIso e).series_inverse (X 0 : MvPowerSeries (Fin 2) R) (PowerSeries.HasSubst.X _)
+    have hi1 := (Coordinate.ofIso e).series_inverse (X 1 : MvPowerSeries (Fin 2) R) (PowerSeries.HasSubst.X _)
+    change e.series.subst (e.inverse.subst (X 0))=X 0 at hi0
+    change e.series.subst (e.inverse.subst (X 1))=X 1 at hi1
+    rw [hi0,hi1,hX,MvPowerSeries.subst_self] at hh
+    have hh' := congrArg (fun z : MvPowerSeries (Fin 2) R => e.inverse.subst z) hh
+    have hc : (F.toPowerSeries.subst ![e.inverse.subst (X 0 : MvPowerSeries (Fin 2) R),
+        e.inverse.subst (X 1)]).constantCoeff=0 :=
+      Coordinate.formal_pair_const F _ _ ((Coordinate.ofIso e).inverse_const _ (by simp))
+        ((Coordinate.ofIso e).inverse_const _ (by simp))
+    have hi := (Coordinate.ofIso e).inverse_series _ (PowerSeries.HasSubst.of_constantCoeff_zero hc)
+    change e.inverse.subst (e.series.subst _) = _ at hi
+    rw [hi] at hh'
+    exact hh'.symm
+
+lemma trans_add {F G H : FormalGroup R} (e : CoordinateIso F G) (d : CoordinateIso G H) :
+    PowerSeries.subst F.toPowerSeries (d.series.subst e.series) =
+      H.toPowerSeries.subst ![PowerSeries.subst (X 0 : MvPowerSeries (Fin 2) R) (d.series.subst e.series),
+        PowerSeries.subst (X 1 : MvPowerSeries (Fin 2) R) (d.series.subst e.series)] := by
+  have h₁ := PowerSeries.subst_comp_subst_apply (.of_constantCoeff_zero e.zero_series)
+      (.of_constantCoeff_zero F.zero_constantCoeff) d.series
+  rw [h₁,e.preserves_addition]
+  have h₂ := coordinate_add G H d (e.series.subst (X 0 : MvPowerSeries (Fin 2) R))
+        (e.series.subst (X 1)) ((Coordinate.ofIso e).series_const _ (by simp))
+        ((Coordinate.ofIso e).series_const _ (by simp))
+  rw [h₂]
+  apply congrArg (fun z : Fin 2 → MvPowerSeries (Fin 2) R => H.toPowerSeries.subst z)
+  funext i; fin_cases i <;>
+    exact (PowerSeries.subst_comp_subst_apply (.of_constantCoeff_zero e.zero_series)
+      (PowerSeries.HasSubst.X _) d.series).symm
+
+def trans {F G H : FormalGroup R} (e : CoordinateIso F G) (d : CoordinateIso G H) : CoordinateIso F H where
+  series := d.series.subst e.series
+  inverse := e.inverse.subst d.inverse
+  zero_series := ((Coordinate.ofIso e).comp (Coordinate.ofIso d)).zero_series
+  zero_inverse := ((Coordinate.ofIso e).comp (Coordinate.ofIso d)).zero_inverse
+  left_inv := ((Coordinate.ofIso e).comp (Coordinate.ofIso d)).left_inv
+  right_inv := ((Coordinate.ofIso e).comp (Coordinate.ofIso d)).right_inv
+  preserves_addition := trans_add e d
+
+def map {F G : FormalGroup R} (e : CoordinateIso F G) (π : R →+* S) : CoordinateIso (F.map π) (G.map π) where
+  __ := (Coordinate.ofIso e).map π
+  preserves_addition := by
+    have hh := congrArg (MvPowerSeries.map π) e.preserves_addition
+    rw [PowerSeries.map_subst (.of_constantCoeff_zero F.zero_constantCoeff),
+      MvPowerSeries.map_subst (hasSubst_of_constantCoeff_zero (by
+        intro i; fin_cases i <;> exact (Coordinate.ofIso e).series_const _ (by simp)))] at hh
+    have he : (fun i : Fin 2 => MvPowerSeries.map π
+        (![e.series.subst (X 0),e.series.subst (X 1)] i)) =
+        ![(e.series.map π).subst (X 0 : MvPowerSeries (Fin 2) S),
+          (e.series.map π).subst (X 1)] := by
+      funext i; fin_cases i <;>
+        simp [PowerSeries.map_subst (PowerSeries.HasSubst.X _)]
+    rw [he] at hh
+    exact hh
+
+end CoordinateIso
+end HeightThree.CoordinateTransport
+
+namespace HeightThree.CoordinateTransport
+open MvPowerSeries HondaTarget
+variable {R S K : Type*} [CommRing R] [CommRing S] [CommRing K]
+
+lemma unimap_comp (π : R →+* S) (ρ : S →+* K) (f : PowerSeries R) :
+    (f.map π).map ρ=f.map (ρ.comp π) := MvPowerSeries.map_map _ _ _
+
+lemma Coordinate.lift (π : R →+* S) (surj : Function.Surjective π)
+    (ρ : R →+* K) (σ : S →+* K) (fac : σ.comp π=ρ)
+    (hnil : ∀ a, ρ a=0 → IsNilpotent a) (d : Coordinate S)
+    (hd : d.series.map σ=PowerSeries.X) :
+    ∃ c : Coordinate R, c.map π=d ∧ c.series.map ρ=PowerSeries.X := by
+  classical
+  let u : PowerSeries R := PowerSeries.mk (fun n => if n=0 then 0 else (surj (d.series.coeff n)).choose)
+  have hu0 : u.constantCoeff=0 := by simp [u,PowerSeries.constantCoeff_mk]
+  have huπ : u.map π=d.series := by
+    ext n
+    rw [PowerSeries.coeff_map]
+    simp only [u,PowerSeries.coeff_mk]
+    split_ifs with hn
+    · subst n; simpa using d.zero_series.symm
+    · exact (surj _).choose_spec
+  have huρ : u.map ρ=PowerSeries.X := by
+    rw [←fac,←unimap_comp,huπ,hd]
+  have hu1 : IsUnit (u.coeff 1) := by
+    have hh := congrArg (PowerSeries.coeff 1) huρ
+    simp only [PowerSeries.coeff_map,PowerSeries.coeff_one_X] at hh
+    have hn := hnil (u.coeff 1-1) (by simp [hh])
+    simpa using hn.isUnit_add_one
+  let c := Coordinate.ofSeries u hu0 hu1
+  refine ⟨c,?_,huρ⟩
+  exact c.map_eq_of_series_eq π d huπ
+
+lemma formal_map_comp (F : FormalGroup R) (π : R →+* S) (ρ : S →+* K) :
+    (F.map π).map ρ=F.map (ρ.comp π) := by
+  apply FormalGroup.ext
+  exact MvPowerSeries.map_map _ _ _
+
+lemma formal_map_injective (π : R →+* S) (hi : Function.Injective π) :
+    Function.Injective (fun F : FormalGroup R => F.map π) := by
+  intro F G he
+  apply FormalGroup.ext
+  ext d
+  apply hi
+  exact congrArg (MvPowerSeries.coeff d ∘ FormalGroup.toPowerSeries) he
+
+end HeightThree.CoordinateTransport
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/FormalGroup/Honda/UniversalTransport.lean b/lean/OAI/Algebra/FormalGroup/Honda/UniversalTransport.lean
new file mode 100644
index 0000000000000000000000000000000000000000..4165b9922c20e16f56323576794d8e6bf6b18708
--- /dev/null
+++ b/lean/OAI/Algebra/FormalGroup/Honda/UniversalTransport.lean
@@ -0,0 +1,116 @@
+import OAI.Algebra.FormalGroup.Honda.Classification
+
+namespace OAI
+
+universe uK
+
+noncomputable section
+
+namespace HeightThree.UniversalTransport
+open MvPowerSeries HeightThree.HondaTarget HeightThree.CoordinateTransport
+open HeightThree.ArtinianUniversality HeightThree.NilpotentTower
+variable {K R S : Type*} [CommRing K] [CommRing R] [CommRing S]
+
+lemma transport_symm (c : Coordinate R) (F : FormalGroup R) :
+    c.symm.transport (c.transport F)=F := by
+  exact Coordinate.transport_ofIso (CoordinateIso.symm (c.iso F))
+
+lemma symm_transport (c : Coordinate R) (F : FormalGroup R) :
+    c.transport (c.symm.transport F)=F := by
+  exact transport_symm c.symm F
+
+lemma coordinate_map_map (c : Coordinate R) (π : R →+* S) (ρ : S →+* K) :
+    (c.map π).map ρ=c.map (ρ.comp π) := by
+  apply Coordinate.map_eq_of_series_eq
+  exact HeightThree.CoordinateTransport.unimap_comp π ρ c.series
+
+lemma coordinate_map_id (c : Coordinate R) : c.map (RingHom.id R)=c := by
+  apply Coordinate.map_eq_of_series_eq
+  exact congrFun PowerSeries.map_id c.series
+
+lemma coordinate_map_symm (c : Coordinate R) (π : R →+* S) :
+    c.symm.map π=(c.map π).symm := rfl
+
+lemma unimap_subst (π : R →+* S) (f g : PowerSeries R) (hg : g.constantCoeff=0) :
+    PowerSeries.map π (f.subst g)=(PowerSeries.map π f).subst (PowerSeries.map π g) :=
+  PowerSeries.map_subst (.of_constantCoeff_zero hg) f
+
+lemma iso_trans_series {F G H : FormalGroup R} (e : CoordinateIso F G) (d : CoordinateIso G H) :
+    (CoordinateIso.trans e d).series=d.series.subst e.series := rfl
+lemma iso_symm_series {F G : FormalGroup R} (e : CoordinateIso F G) :
+    (CoordinateIso.symm e).series=e.inverse := rfl
+lemma iso_series (c : Coordinate R) (F : FormalGroup R) : (c.iso F).series=c.series := rfl
+lemma iso_inverse (c : Coordinate R) (F : FormalGroup R) : (c.iso F).inverse=c.inverse := rfl
+
+lemma framed_transport (ρ : R →+* K) (c : Coordinate R) {F G : FormalGroup R}
+    (he : FramedEquivalent ρ F G) :
+    FramedEquivalent ρ (c.transport F) (c.transport G) := by
+  obtain ⟨e,he⟩ := he
+  refine ⟨CoordinateIso.trans (CoordinateIso.symm (c.iso F))
+    (CoordinateIso.trans e (c.iso G)),?_⟩
+  rw [iso_trans_series,iso_trans_series,iso_symm_series,iso_series,iso_inverse]
+  rw [unimap_subst ρ _ c.inverse c.zero_inverse,
+    unimap_subst ρ c.series e.series e.zero_series,he,PowerSeries.X_subst]
+  exact (c.map ρ).left_inv
+
+lemma framed_transport_iff (ρ : R →+* K) (c : Coordinate R) (F G : FormalGroup R) :
+    FramedEquivalent ρ (c.transport F) (c.transport G) ↔ FramedEquivalent ρ F G := by
+  constructor
+  · intro h
+    have hh := framed_transport ρ c.symm h
+    rwa [transport_symm,transport_symm] at hh
+  · exact framed_transport ρ c
+
+lemma scalar_coordinate_map [Algebra K R] [Algebra K S] (c : Coordinate K) (f : R →ₐ[K] S) :
+    (c.map (algebraMap K R)).map f.toRingHom=c.map (algebraMap K S) := by
+  rw [coordinate_map_map]
+  congr 1
+  ext z
+  exact f.commutes z
+
+lemma scalar_coordinate_reduce [Algebra K R] (c : Coordinate K) (ρ : R →ₐ[K] K) :
+    (c.map (algebraMap K R)).map ρ.toRingHom=c := by
+  rw [scalar_coordinate_map]
+  exact coordinate_map_id c
+
+end HeightThree.UniversalTransport
+
+namespace HeightThree.UniversalTransport
+open MvPowerSeries HeightThree.HondaTarget HeightThree.CoordinateTransport
+open HeightThree.ArtinianUniversality HeightThree.NilpotentTower
+variable {K : Type uK} [Field K]
+
+theorem isUniversal_transport (Γ : FormalGroup K) (G : FormalGroup (Base K))
+    (hG : IsUniversal Γ G) (c : Coordinate K) :
+    IsUniversal (c.transport Γ) ((c.map (algebraMap K (Base K))).transport G) := by
+  intro R _ _ _ _ ρ F hF hred
+  let cR := c.map (algebraMap K R)
+  let F' := cR.symm.transport F
+  have hcR : cR.map ρ.toRingHom=c := scalar_coordinate_reduce c ρ
+  have hF' : F'.IsComm := by
+    have := hF
+    exact inferInstance
+  have hr : F'.map ρ.toRingHom=Γ := by
+    rw [show F'=cR.symm.transport F from rfl,Coordinate.transport_map,
+      coordinate_map_symm,hcR,hred,transport_symm]
+  obtain ⟨f,hf,huniq⟩ := hG R ρ F' hF' hr
+  refine ⟨f,⟨hf.1,?_⟩,?_⟩
+  · have he := framed_transport ρ.toRingHom cR hf.2
+    change FramedEquivalent _ _ (cR.transport (cR.symm.transport F)) at he
+    rw [symm_transport] at he
+    rw [Coordinate.transport_map,scalar_coordinate_map]
+    exact he
+  · intro g hg
+    apply huniq g
+    refine ⟨hg.1,?_⟩
+    have he := hg.2
+    rw [Coordinate.transport_map,scalar_coordinate_map] at he
+    have he' := framed_transport ρ.toRingHom cR.symm he
+    rw [transport_symm] at he'
+    exact he'
+
+end HeightThree.UniversalTransport
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/FormalGroup/Honda/Universality.lean b/lean/OAI/Algebra/FormalGroup/Honda/Universality.lean
new file mode 100644
index 0000000000000000000000000000000000000000..423f67c43ffa87df833b30e4ef3d22e8d79edb78
--- /dev/null
+++ b/lean/OAI/Algebra/FormalGroup/Honda/Universality.lean
@@ -0,0 +1,335 @@
+import OAI.Algebra.FormalGroup.Honda.Evaluation
+
+namespace OAI
+
+universe uK uR
+
+noncomputable section
+
+namespace HeightThree.ArtinianUniversality
+open MvPowerSeries HondaTarget DeformationRigidity CoordinateTransport NilpotentTower NilpotentEvaluation
+variable {K R S : Type*} [Field K] [CommRing R] [CommRing S]
+
+instance mapFormalGroup_isComm (F : FormalGroup R) [F.IsComm] (f : R →+* S) :
+    (F.map f).IsComm where
+  comm := by
+    change F.toPowerSeries.map f = (F.toPowerSeries.map f).subst ![X 1, X 0]
+    have hc := congrArg (MvPowerSeries.map f) (FormalGroup.IsComm.comm (F := F))
+    rw [map_subst HasSubst.X_X] at hc
+    rw [hc]
+    congr 1
+    funext i
+    fin_cases i <;> simp
+
+lemma framed_refl (ρ : R →+* K) (F : FormalGroup R) : FramedEquivalent ρ F F := by
+  refine ⟨{
+    series := PowerSeries.X
+    inverse := PowerSeries.X
+    zero_series := by simp
+    zero_inverse := by simp
+    left_inv := PowerSeries.X_subst _
+    right_inv := PowerSeries.X_subst _
+    preserves_addition := ?_ },PowerSeries.map_X ρ⟩
+  rw [PowerSeries.subst_X (.of_constantCoeff_zero F.zero_constantCoeff),
+    PowerSeries.subst_X (PowerSeries.HasSubst.X _),PowerSeries.subst_X (PowerSeries.HasSubst.X _)]
+  have hX : ![X 0,X 1]=(X : Fin 2 → MvPowerSeries (Fin 2) R) := by funext i; fin_cases i <;> rfl
+  rw [hX,MvPowerSeries.subst_self]; rfl
+
+lemma framed_symm (ρ : R →+* K) {F G : FormalGroup R} (h : FramedEquivalent ρ F G) :
+    FramedEquivalent ρ G F := by
+  obtain ⟨e,he⟩ := h
+  refine ⟨CoordinateTransport.CoordinateIso.symm e,?_⟩
+  have hh := (Coordinate.ofIso e).map_eq_of_series_eq ρ Coordinate.ident he
+  exact congrArg Coordinate.inverse hh
+
+lemma framed_trans (ρ : R →+* K) {F G H : FormalGroup R}
+    (he : FramedEquivalent ρ F G) (hd : FramedEquivalent ρ G H) : FramedEquivalent ρ F H := by
+  obtain ⟨e,he⟩ := he
+  obtain ⟨d,hd⟩ := hd
+  refine ⟨CoordinateTransport.CoordinateIso.trans e d,?_⟩
+  change (d.series.subst e.series).map ρ=PowerSeries.X
+  have hh : (d.series.subst e.series).map ρ = (d.series.map ρ).subst (e.series.map ρ) :=
+    PowerSeries.map_subst (PowerSeries.HasSubst.of_constantCoeff_zero e.zero_series) d.series
+  rw [hh,hd,he,PowerSeries.X_subst]
+
+lemma framed_map (π : R →+* S) (ρ : R →+* K) (σ : S →+* K) (fac : σ.comp π=ρ)
+    {F G : FormalGroup R} (he : FramedEquivalent ρ F G) :
+    FramedEquivalent σ (F.map π) (G.map π) := by
+  obtain ⟨e,he⟩ := he
+  refine ⟨CoordinateTransport.CoordinateIso.map e π,?_⟩
+  change (e.series.map π).map σ=PowerSeries.X
+  rw [unimap_comp,fac,he]
+
+lemma augmentation_of_base_map [Algebra K R] (G : FormalGroup (Base K)) (Γ : FormalGroup K)
+    (hG : G.map constantCoeff=Γ) (ρ : R →ₐ[K] K) (f : Base K →ₐ[K] R)
+    (hf : ∀ z, ρ (f z)=constantCoeff z) : (G.map f.toRingHom).map ρ.toRingHom=Γ := by
+  rw [formal_map_comp,show ρ.toRingHom.comp f.toRingHom=constantCoeff by ext z; exact hf z,hG]
+
+lemma lift_base_map [Algebra K R] [Algebra K S]
+    (π : R →ₐ[K] S) (surj : Function.Surjective π) (ρ : R →ₐ[K] K) (σ : S →ₐ[K] K)
+    (fac : σ.comp π=ρ) (hnil : ∀ a, ρ a=0 → IsNilpotent a)
+    (f : Base K →ₐ[K] S) (hf : ∀ z, σ (f z)=constantCoeff z) :
+    ∃ g : Base K →ₐ[K] R, π.comp g=f ∧ (∀ z, ρ (g z)=constantCoeff z) := by
+  classical
+  let a : Fin 2 → R := fun i => (surj (f (X i))).choose
+  have ha (i : Fin 2) : π (a i)=f (X i) := (surj _).choose_spec
+  have hρa (i : Fin 2) : ρ (a i)=0 := by
+    rw [←fac]; change σ (π (a i))=0
+    rw [ha,hf,constantCoeff_X]
+  let g : Base K →ₐ[K] R := eval a (fun i => hnil _ (hρa i))
+  refine ⟨g,?_,eval_augmentation ρ a _ hρa⟩
+  apply hom_ext_nilpotent
+  · intro i; simpa [g] using (hnil _ (hρa i)).map π.toRingHom
+  · intro i; simp [g,ha]
+
+end HeightThree.ArtinianUniversality
+
+namespace HeightThree.ArtinianUniversality
+open MvPowerSeries HondaTarget DeformationRigidity CoordinateTransport NilpotentTower NilpotentEvaluation
+variable {K R S : Type*} [Field K] [CommRing R] [CommRing S]
+
+structure Data (p : ℕ) [hp : Fact p.Prime] (K : Type*) [Field K] where
+  gamma : FormalGroup K
+  family : FormalGroup (Base K)
+  family_comm : family.IsComm
+  special : family.map constantCoeff=gamma
+  honda : multiplicationSeries gamma p=PowerSeries.X^(p^3)
+  nonlinear : MvPowerSeries (Fin 2) K
+  nonlinear_eq : gamma.toPowerSeries=X 0+X 1+expand (p^2) (pow_ne_zero _ hp.out.ne_zero) nonlinear
+  frobenius : gamma.toPowerSeries^p=expand p hp.out.ne_zero gamma.toPowerSeries
+  first : (multiplicationSeries family p).coeff p=X 0
+  remainder : Base K
+  second : (multiplicationSeries family p).coeff (p^2)=X 1+X 0*remainder
+
+namespace Data
+variable (p : ℕ) [hp : Fact p.Prime] (D : Data p K)
+instance family_isComm : D.family.IsComm := D.family_comm
+
+lemma multiply_coeff_map (F : FormalGroup R) (π : R →+* S) (n j : ℕ) :
+    (multiplicationSeries (F.map π) n).coeff j=π ((multiplicationSeries F n).coeff j) := by
+  rw [multiplication_map,PowerSeries.coeff_map]
+
+lemma base_gamma [Algebra K R] (ρ : R →ₐ[K] K) :
+    (D.gamma.map (algebraMap K R)).map ρ.toRingHom=D.gamma := by
+  rw [formal_map_comp]
+  apply FormalGroup.ext
+  ext d
+  change ρ (algebraMap K R (coeff d D.gamma.toPowerSeries))=coeff d D.gamma.toPowerSeries
+  simp
+
+lemma gamma_honda [Algebra K R] :
+    multiplicationSeries (D.gamma.map (algebraMap K R)) p=PowerSeries.X^(p^3) := by
+  rw [multiplication_map,D.honda,map_pow,PowerSeries.map_X]
+
+lemma gamma_nonlinear [Algebra K R] :
+    (D.gamma.map (algebraMap K R)).toPowerSeries=X 0+X 1+
+      expand (p^2) (pow_ne_zero _ hp.out.ne_zero) (D.nonlinear.map (algebraMap K R)) := by
+  change D.gamma.toPowerSeries.map _=_
+  rw [D.nonlinear_eq,map_add,map_add,map_X,map_X,map_expand]
+
+lemma gamma_frobenius [Algebra K R] :
+    (D.gamma.map (algebraMap K R)).toPowerSeries^p=
+      expand p hp.out.ne_zero (D.gamma.map (algebraMap K R)).toPowerSeries := by
+  change (D.gamma.toPowerSeries.map _)^p=_
+  rw [←map_pow,D.frobenius,map_expand]
+  rfl
+
+variable [CharP K p]
+
+lemma lift_step [Algebra K R] [Algebra K S]
+    (π : R →ₐ[K] S) (surj : Function.Surjective π) (ρ : R →ₐ[K] K) (σ : S →ₐ[K] K)
+    (fac : σ.comp π=ρ) (hsmall : SmallExtension.IsSmall π.toRingHom ρ.toRingHom)
+    (hnil : ∀ a, ρ a=0 → IsNilpotent a)
+    (F : FormalGroup R) [F.IsComm] (hF : F.map ρ.toRingHom=D.gamma)
+    (f : Base K →ₐ[K] S) (hf : ∀ z, σ (f z)=constantCoeff z)
+    (he : FramedEquivalent σ.toRingHom (D.family.map f.toRingHom) (F.map π.toRingHom)) :
+    ∃ g : Base K →ₐ[K] R, π.comp g=f ∧ (∀ z, ρ (g z)=constantCoeff z) ∧
+      FramedEquivalent ρ.toRingHom (D.family.map g.toRingHom) F := by
+  have fac' : σ.toRingHom.comp π.toRingHom=ρ.toRingHom := congrArg AlgHom.toRingHom fac
+  have : Nontrivial R := ρ.toRingHom.domain_nontrivial
+  have : CharP R p := (Algebra.charP_iff K R p).mp inferInstance
+  obtain ⟨e,heσ⟩ := framed_symm σ.toRingHom he
+  obtain ⟨c,hcπ,hcρ⟩ := Coordinate.lift π.toRingHom surj ρ.toRingHom σ.toRingHom fac' hnil
+    (Coordinate.ofIso e) heσ
+  let H := c.transport F
+  have hHπ : H.map π.toRingHom=D.family.map f.toRingHom := by
+    rw [show H=c.transport F from rfl,c.transport_map,hcπ,Coordinate.transport_ofIso]
+  have hHρ : H.map ρ.toRingHom=D.gamma := by
+    rw [show H=c.transport F from rfl,c.transport_map_eq_self F ρ.toRingHom hcρ,hF]
+  obtain ⟨f₀,hf₀π,hf₀ρ⟩ := lift_base_map π surj ρ σ fac hnil f hf
+  have hH₀ : H.map π.toRingHom=(D.family.map f₀.toRingHom).map π.toRingHom := by
+    rw [formal_map_comp]
+    change H.map π.toRingHom=D.family.map (π.comp f₀).toRingHom
+    rw [hf₀π,hHπ]
+  have hcoeff (j : ℕ) : π ((multiplicationSeries H p).coeff j)=π (f₀ ((multiplicationSeries D.family p).coeff j)) := by
+    have hh := congrArg (fun J : FormalGroup S => (multiplicationSeries J p).coeff j) hH₀
+    simp only [multiply_coeff_map] at hh
+    exact hh
+  obtain ⟨g,hgπ,hgρ,hgp,hgpp⟩ := correct_parameters π ρ hsmall.ker_le hsmall.annihilate f₀ hf₀ρ
+    (fun i => hnil _ (by rw [hf₀ρ,constantCoeff_X]))
+    ((multiplicationSeries D.family p).coeff (p^2)) D.remainder D.second
+    ((multiplicationSeries H p).coeff p) ((multiplicationSeries H p).coeff (p^2))
+    (by simpa only [D.first] using hcoeff p) (hcoeff (p^2))
+  have hgπf : π.comp g=f := hgπ.trans hf₀π
+  have hGπ : (D.family.map g.toRingHom).map π.toRingHom=H.map π.toRingHom := by
+    rw [formal_map_comp]
+    change D.family.map (π.comp g).toRingHom=H.map π.toRingHom
+    rw [hgπf,hHπ]
+  have hGρ := augmentation_of_base_map D.family D.gamma D.special ρ g hgρ
+  obtain ⟨a,haπ⟩ := SmallExtension.small_equivalence_of_matching_parameters p π.toRingHom ρ.toRingHom
+    hsmall (D.family.map g.toRingHom) H (D.gamma.map (algebraMap K R)) hGπ
+    (hGρ.trans (D.base_gamma p ρ).symm) (hHρ.trans (D.base_gamma p ρ).symm)
+    (D.nonlinear.map (algebraMap K R)) (D.gamma_nonlinear p) (D.gamma_honda p) (D.gamma_frobenius p)
+    (by rw [multiply_coeff_map,D.first]; exact hgp)
+    (by rw [multiply_coeff_map]; exact hgpp)
+  have haρ : a.series.map ρ.toRingHom=PowerSeries.X := by
+    rw [←fac',←unimap_comp,haπ,PowerSeries.map_X]
+  refine ⟨g,hgπf,hgρ,?_⟩
+  exact framed_trans ρ.toRingHom ⟨a,haρ⟩ (framed_symm ρ.toRingHom ⟨c.iso F,hcρ⟩)
+
+end Data
+end HeightThree.ArtinianUniversality
+
+namespace HeightThree.ArtinianUniversality.Data
+open MvPowerSeries HondaTarget DeformationRigidity CoordinateTransport NilpotentTower NilpotentEvaluation
+variable {K : Type uK} [Field K] (p : ℕ) [hp : Fact p.Prime] [CharP K p] (D : Data p K)
+
+lemma existence (n : ℕ) (R : Type uR) [CommRing R] [Algebra K R] (ρ : R →ₐ[K] K)
+    (hn : (RingHom.ker ρ)^(n+1)=⊥) (F : FormalGroup R) [F.IsComm]
+    (hF : F.map ρ.toRingHom=D.gamma) :
+    ∃ g : Base K →ₐ[K] R, (∀ z, ρ (g z)=constantCoeff z) ∧
+      FramedEquivalent ρ.toRingHom (D.family.map g.toRingHom) F := by
+  induction n generalizing R with
+  | zero =>
+    let g : Base K →ₐ[K] R := eval (fun _ => 0) (fun _ => IsNilpotent.zero)
+    have hg (z : Base K) : ρ (g z)=constantCoeff z := by simp [g,eval_zero]
+    have hi : Function.Injective ρ.toRingHom := (RingHom.injective_iff_ker_eq_bot ρ).mpr (by simpa using hn)
+    have he : D.family.map g.toRingHom=F := formal_map_injective ρ.toRingHom hi
+      ((augmentation_of_base_map D.family D.gamma D.special ρ g hg).trans hF.symm)
+    refine ⟨g,hg,?_⟩
+    rw [he]
+    exact framed_refl ρ.toRingHom F
+  | succ n ih =>
+    let S := quotient ρ n
+    let π : R →ₐ[K] S := projection ρ n
+    let σ : S →ₐ[K] K := augmentation ρ n
+    have fac : σ.comp π=ρ := rfl
+    have hFS : (F.map π.toRingHom).map σ.toRingHom=D.gamma := by
+      rw [formal_map_comp]
+      exact hF
+    obtain ⟨f,hf,he⟩ := ih S σ (augmentation_nilpotent ρ n) (F.map π.toRingHom) hFS
+    obtain ⟨g,_,hg,hge⟩ := D.lift_step p π (projection_surjective ρ n) ρ σ fac
+      ⟨projection_ker_le ρ n,projection_annihilate ρ n hn⟩
+      (fun a ha => nilpotent_of_mem_ker ρ hn ha) F hF f hf he
+    exact ⟨g,hg,hge⟩
+
+omit [CharP K p] in
+lemma family_honda {R : Type*} [CommRing R] [Algebra K R] (ρ : R →ₐ[K] K)
+    (f : Base K →ₐ[K] R) (hf : ∀ z, ρ (f z)=constantCoeff z) :
+    (multiplicationSeries (D.family.map f.toRingHom) p).map ρ.toRingHom=PowerSeries.X^(p^3) := by
+  rw [←multiplication_map,augmentation_of_base_map D.family D.gamma D.special ρ f hf,D.honda]
+
+end HeightThree.ArtinianUniversality.Data
+
+namespace HeightThree.ArtinianRigidity
+open HondaTarget DeformationRigidity CoordinateTransport NilpotentTower
+
+lemma equivalence_rigid {K : Type uK} [Field K] (p : ℕ) [Fact p.Prime] [CharP K p]
+    (n : ℕ) (R : Type uR) [CommRing R] [Algebra K R] (ρ : R →ₐ[K] K)
+    (hn : (RingHom.ker ρ)^(n+1)=⊥) (F G : FormalGroup R) (e : CoordinateIso F G) (hFG : F=G)
+    (he : e.series.map ρ.toRingHom=PowerSeries.X)
+    (hF : (multiplicationSeries F p).map ρ.toRingHom=PowerSeries.X^(p^3)) :
+    e.series=PowerSeries.X := by
+  subst G
+  exact automorphism_rigid p n R ρ hn F e he hF
+
+end HeightThree.ArtinianRigidity
+
+namespace HeightThree.ArtinianUniversality.Data
+open MvPowerSeries HondaTarget DeformationRigidity CoordinateTransport NilpotentTower NilpotentEvaluation
+variable {K : Type uK} [Field K] (p : ℕ) [hp : Fact p.Prime] [CharP K p] (D : Data p K)
+
+lemma base_map_unique (n : ℕ) (R : Type uR) [CommRing R] [Algebra K R] (ρ : R →ₐ[K] K)
+    (hn : (RingHom.ker ρ)^(n+1)=⊥) (f g : Base K →ₐ[K] R)
+    (hf : ∀ z, ρ (f z)=constantCoeff z) (hg : ∀ z, ρ (g z)=constantCoeff z)
+    (he : FramedEquivalent ρ.toRingHom (D.family.map f.toRingHom) (D.family.map g.toRingHom)) : f=g := by
+  induction n generalizing R with
+  | zero =>
+    have hi : Function.Injective ρ := (RingHom.injective_iff_ker_eq_bot ρ).mpr (by simpa using hn)
+    ext z
+    apply hi
+    rw [hf,hg]
+  | succ n ih =>
+    let S := quotient ρ n
+    let π : R →ₐ[K] S := projection ρ n
+    let σ : S →ₐ[K] K := augmentation ρ n
+    have fac : σ.toRingHom.comp π.toRingHom=ρ.toRingHom := rfl
+    have hfS (z : Base K) : σ ((π.comp f) z)=constantCoeff z := hf z
+    have hgS (z : Base K) : σ ((π.comp g) z)=constantCoeff z := hg z
+    have heS : FramedEquivalent σ.toRingHom (D.family.map (π.comp f).toRingHom)
+        (D.family.map (π.comp g).toRingHom) := by
+      have hh := framed_map π.toRingHom ρ.toRingHom σ.toRingHom fac he
+      rw [formal_map_comp,formal_map_comp] at hh
+      exact hh
+    have hfg : π.comp f=π.comp g := ih S σ (augmentation_nilpotent ρ n) (π.comp f) (π.comp g) hfS hgS heS
+    obtain ⟨e,heρ⟩ := he
+    have hFG : (D.family.map f.toRingHom).map π.toRingHom=(D.family.map g.toRingHom).map π.toRingHom := by
+      rw [formal_map_comp,formal_map_comp]
+      change D.family.map (π.comp f).toRingHom=D.family.map (π.comp g).toRingHom
+      rw [hfg]
+    let d := CoordinateTransport.CoordinateIso.map e π.toRingHom
+    have hd : d.series.map σ.toRingHom=PowerSeries.X := by
+      change (e.series.map π.toRingHom).map σ.toRingHom=PowerSeries.X
+      rw [unimap_comp,fac,heρ]
+    have hF' : (multiplicationSeries ((D.family.map f.toRingHom).map π.toRingHom) p).map σ.toRingHom=PowerSeries.X^(p^3) := by
+      rw [formal_map_comp]
+      exact D.family_honda p σ (π.comp f) hfS
+    have heπ : e.series.map π.toRingHom=PowerSeries.X :=
+      ArtinianRigidity.equivalence_rigid p n S σ (augmentation_nilpotent ρ n) _ _ d hFG hd hF'
+    have : Nontrivial R := ρ.toRingHom.domain_nontrivial
+    have : CharP R p := (Algebra.charP_iff K R p).mp inferInstance
+    have hsmall : SmallExtension.IsSmall π.toRingHom ρ.toRingHom :=
+      ⟨projection_ker_le ρ n,projection_annihilate ρ n hn⟩
+    have hlo (j : ℕ) (hj : 0<j) (hj' : j<p^3) :=
+      SmallExtension.small_isomorphism_lowcoeff p π.toRingHom ρ.toRingHom hsmall
+        (D.family.map f.toRingHom) (D.family.map g.toRingHom) e heπ
+        (D.family_honda p ρ f hf) (D.family_honda p ρ g hg) j hj hj'
+    have hx : f (X 0)=g (X 0) := by
+      have hh := hlo p hp.out.pos (by simpa only [pow_one] using pow_lt_pow_right₀ hp.out.one_lt (by decide : 1<3))
+      rw [multiply_coeff_map,multiply_coeff_map,D.first] at hh
+      exact hh
+    have hy : f (X 1)=g (X 1) := by
+      have hh := hlo (p^2) (pow_pos hp.out.pos _) (pow_lt_pow_right₀ hp.out.one_lt (by decide : 2<3))
+      rw [multiply_coeff_map,multiply_coeff_map] at hh
+      change f ((multiplicationSeries D.family p).coeff (p^2))=g ((multiplicationSeries D.family p).coeff (p^2)) at hh
+      rw [D.second,map_add,map_mul,map_add,map_mul,hx] at hh
+      have hk : π (f D.remainder-g D.remainder)=0 := by
+        rw [map_sub,sub_eq_zero]
+        exact congrArg (fun φ : Base K →ₐ[K] S => φ D.remainder) hfg
+      have hr : ρ (g (X 0))=0 := by rw [hg,constantCoeff_X]
+      have hz := hsmall.annihilate (f D.remainder-g D.remainder) (g (X 0)) hk hr
+      linear_combination hh-hz
+    apply hom_ext_nilpotent
+    · intro i; exact nilpotent_of_mem_ker ρ hn (by rw [hf,constantCoeff_X])
+    · intro i; fin_cases i
+      · exact hx
+      · exact hy
+
+theorem isUniversal : IsUniversal D.gamma D.family := by
+  intro R _ _ _ _ ρ F hFcomm hF
+  have := hFcomm
+  obtain ⟨n,hn⟩ := finite_local_nilpotent ρ
+  obtain ⟨f,hf,he⟩ := D.existence p n R ρ hn F hF
+  refine ⟨f,⟨?_,he⟩,?_⟩
+  · ext z; exact hf z
+  · intro g hg
+    apply D.base_map_unique p n R ρ hn g f
+    · intro z; exact congrArg (fun φ : Base K →+* K => φ z) hg.1
+    · exact hf
+    · exact framed_trans ρ.toRingHom hg.2 (framed_symm ρ.toRingHom he)
+
+end HeightThree.ArtinianUniversality.Data
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/FormulaHitting/BitArithmetic.lean b/lean/OAI/Algebra/FormulaHitting/BitArithmetic.lean
new file mode 100644
index 0000000000000000000000000000000000000000..0d48676de71b9d4c7d279f9a584c296597f7e15d
--- /dev/null
+++ b/lean/OAI/Algebra/FormulaHitting/BitArithmetic.lean
@@ -0,0 +1,530 @@
+import OAI.Algebra.FormulaHitting.BitModel
+import Mathlib.Data.Nat.Size
+import Lean.Elab.Tactic.Omega
+import Mathlib.Tactic.Ring
+import Mathlib.Tactic.NormNum
+import Mathlib.Tactic.Linarith
+
+namespace OAI
+
+namespace NCHitting.BitArithmetic
+
+def value : List Bool → ℕ
+  | [] => 0
+  | b :: bs => b.toNat + 2 * value bs
+
+def parity (a b c : Bool) : Bool := xor (xor a b) c
+def carry (a b c : Bool) : Bool := (a && b) || (a && c) || (b && c)
+def borrow (a b c : Bool) : Bool := ((!a) && b) || ((!a) && c) || (b && c)
+def equalStep (a b c : Bool) : Bool := (a == b) && c
+
+theorem fullAdder_identity (a b c : Bool) :
+    (parity a b c).toNat + 2 * (carry a b c).toNat = a.toNat + b.toNat + c.toNat := by
+  cases a <;> cases b <;> cases c <;> decide
+
+theorem fullSubtractor_identity (a b c : Bool) :
+    (parity a b c).toNat + b.toNat + c.toNat = a.toNat + 2 * (borrow a b c).toNat := by
+  cases a <;> cases b <;> cases c <;> decide
+
+structure WordRun where
+  bits : List Bool
+  steps : ℕ
+
+def trim : List Bool → List Bool
+  | [] => []
+  | b :: bs =>
+      let t := trim bs
+      if t = [] ∧ b = false then [] else b :: t
+
+def trimSteps : List Bool → ℕ
+  | [] => 1
+  | _ :: bs => trimSteps bs + 3
+
+theorem trimSteps_eq (bs : List Bool) : trimSteps bs = 3 * bs.length + 1 := by
+  induction bs with
+  | nil => rfl
+  | cons b bs ih => simp only [trimSteps, List.length_cons, ih]; omega
+
+@[simp] theorem value_trim (bs : List Bool) : value (trim bs) = value bs := by
+  induction bs with
+  | nil => rfl
+  | cons b bs ih =>
+    simp only [trim]
+    split_ifs with h
+    · rcases h with ⟨ht, rfl⟩
+      simp only [ht, value] at ih
+      simp [value, ← ih]
+    · simp only [value, ih]
+
+theorem bits_value (bs : List Bool) : (value bs).bits = trim bs := by
+  induction bs with
+  | nil => rfl
+  | cons b bs ih =>
+    by_cases hzero : value bs = 0
+    · have ht : trim bs = [] := by rw [← ih, hzero]; rfl
+      cases b <;> simp [value, hzero, trim, ht]
+    · have ht : trim bs ≠ [] := by
+        intro h
+        have := value_trim bs
+        rw [h] at this
+        exact hzero this.symm
+      have hbit : b.toNat + 2 * value bs = Nat.bit b (value bs) := by
+        rw [Nat.bit_val]
+        omega
+      rw [value, hbit, Nat.bits_append_bit _ _ (fun h => (hzero h).elim), ih]
+      simp [trim, ht]
+
+theorem value_bits (n : ℕ) : value n.bits = n := by
+  induction n using Nat.binaryRec' with
+  | zero => rfl
+  | bit b n hn ih =>
+    rw [Nat.bits_append_bit n b hn, value, ih, Nat.bit_val]
+    omega
+
+theorem trim_length (bs : List Bool) : (trim bs).length = (value bs).size := by
+  rw [← bits_value, Nat.size_eq_bits_len]
+
+def addRaw : List Bool → List Bool → Bool → WordRun
+  | [], [], c => ⟨if c then [true] else [], 3⟩
+  | a :: xs, [], c =>
+      let r := addRaw xs [] (carry a false c)
+      ⟨parity a false c :: r.bits, r.steps + 5⟩
+  | [], b :: ys, c =>
+      let r := addRaw [] ys (carry false b c)
+      ⟨parity false b c :: r.bits, r.steps + 5⟩
+  | a :: xs, b :: ys, c =>
+      let r := addRaw xs ys (carry a b c)
+      ⟨parity a b c :: r.bits, r.steps + 5⟩
+
+theorem addRaw_value (xs ys : List Bool) (c : Bool) :
+    value (addRaw xs ys c).bits = value xs + value ys + c.toNat := by
+  induction xs generalizing ys c with
+  | nil =>
+    induction ys generalizing c with
+    | nil => cases c <;> simp [addRaw, value]
+    | cons b ys ih =>
+      have h := fullAdder_identity false b c
+      simp only [addRaw, value, ih]
+      simp only [Bool.toNat_false] at h
+      omega
+  | cons a xs ih =>
+    cases ys with
+    | nil =>
+      have h := fullAdder_identity a false c
+      simp only [addRaw, value, ih]
+      simp only [Bool.toNat_false] at h
+      omega
+    | cons b ys =>
+      have h := fullAdder_identity a b c
+      simp only [addRaw, value, ih]
+      omega
+
+theorem addRaw_length (xs ys : List Bool) (c : Bool) :
+    (addRaw xs ys c).bits.length ≤ max xs.length ys.length + 1 := by
+  induction xs generalizing ys c with
+  | nil =>
+    induction ys generalizing c with
+    | nil => cases c <;> simp [addRaw]
+    | cons b ys ih =>
+      have h := ih (carry false b c)
+      simp only [addRaw, List.length_cons, List.length_nil, Nat.zero_max] at h ⊢
+      omega
+  | cons a xs ih =>
+    cases ys with
+    | nil =>
+      have h := ih [] (carry a false c)
+      simp only [addRaw, List.length_cons, List.length_nil, Nat.max_zero] at h ⊢
+      omega
+    | cons b ys =>
+      have h := ih ys (carry a b c)
+      simp only [addRaw, List.length_cons] at h ⊢
+      omega
+
+theorem addRaw_steps (xs ys : List Bool) (c : Bool) :
+    (addRaw xs ys c).steps ≤ 5 * (xs.length + ys.length) + 3 := by
+  induction xs generalizing ys c with
+  | nil =>
+    induction ys generalizing c with
+    | nil => simp [addRaw]
+    | cons b ys ih =>
+      have h := ih (carry false b c)
+      simp only [addRaw, List.length_cons, List.length_nil] at h ⊢
+      omega
+  | cons a xs ih =>
+    cases ys with
+    | nil =>
+      have h := ih [] (carry a false c)
+      simp only [addRaw, List.length_cons, List.length_nil] at h ⊢
+      omega
+    | cons b ys =>
+      have h := ih ys (carry a b c)
+      simp only [addRaw, List.length_cons] at h ⊢
+      omega
+
+def add (xs ys : List Bool) : WordRun :=
+  let raw := addRaw xs ys false
+  ⟨trim raw.bits, raw.steps + trimSteps raw.bits⟩
+
+theorem add_value (xs ys : List Bool) : value (add xs ys).bits = value xs + value ys := by
+  simp [add, addRaw_value]
+
+theorem add_steps (xs ys : List Bool) :
+    (add xs ys).steps ≤ 8 * (xs.length + ys.length) + 7 := by
+  have hs := addRaw_steps xs ys false
+  have hl := addRaw_length xs ys false
+  simp only [add, trimSteps_eq]
+  omega
+
+structure BoolRun where
+  bit : Bool
+  steps : ℕ
+
+def lessRaw : List Bool → List Bool → Bool → BoolRun
+  | [], [], c => ⟨c, 2⟩
+  | a :: xs, [], c =>
+      let r := lessRaw xs [] (borrow a false c)
+      ⟨r.bit, r.steps + 3⟩
+  | [], b :: ys, c =>
+      let r := lessRaw [] ys (borrow false b c)
+      ⟨r.bit, r.steps + 3⟩
+  | a :: xs, b :: ys, c =>
+      let r := lessRaw xs ys (borrow a b c)
+      ⟨r.bit, r.steps + 3⟩
+
+theorem lessRaw_value (xs ys : List Bool) (c : Bool) :
+    (lessRaw xs ys c).bit = true ↔ value xs < value ys + c.toNat := by
+  induction xs generalizing ys c with
+  | nil =>
+    induction ys generalizing c with
+    | nil => cases c <;> simp [lessRaw, value]
+    | cons b ys ih =>
+      simp only [lessRaw, ih, value]
+      cases b <;> cases c <;> simp [borrow]
+  | cons a xs ih =>
+    cases ys with
+    | nil =>
+      simp only [lessRaw, ih, value]
+      cases a <;> cases c <;> simp [borrow]
+    | cons b ys =>
+      simp only [lessRaw, ih, value]
+      cases a <;> cases b <;> cases c <;> simp [borrow] <;> omega
+
+theorem lessRaw_steps (xs ys : List Bool) (c : Bool) :
+    (lessRaw xs ys c).steps ≤ 3 * (xs.length + ys.length) + 2 := by
+  induction xs generalizing ys c with
+  | nil =>
+    induction ys generalizing c with
+    | nil => simp [lessRaw]
+    | cons b ys ih =>
+      have h := ih (borrow false b c)
+      simp only [lessRaw, List.length_cons, List.length_nil] at h ⊢
+      omega
+  | cons a xs ih =>
+    cases ys with
+    | nil =>
+      have h := ih [] (borrow a false c)
+      simp only [lessRaw, List.length_cons, List.length_nil] at h ⊢
+      omega
+    | cons b ys =>
+      have h := ih ys (borrow a b c)
+      simp only [lessRaw, List.length_cons] at h ⊢
+      omega
+
+def equalRaw : List Bool → List Bool → Bool → BoolRun
+  | [], [], c => ⟨c, 2⟩
+  | a :: xs, [], c =>
+      let r := equalRaw xs [] (equalStep a false c)
+      ⟨r.bit, r.steps + 3⟩
+  | [], b :: ys, c =>
+      let r := equalRaw [] ys (equalStep false b c)
+      ⟨r.bit, r.steps + 3⟩
+  | a :: xs, b :: ys, c =>
+      let r := equalRaw xs ys (equalStep a b c)
+      ⟨r.bit, r.steps + 3⟩
+
+theorem equalRaw_value (xs ys : List Bool) (c : Bool) :
+    (equalRaw xs ys c).bit = true ↔ value xs = value ys ∧ c = true := by
+  induction xs generalizing ys c with
+  | nil =>
+    induction ys generalizing c with
+    | nil => cases c <;> simp [equalRaw, value]
+    | cons b ys ih =>
+      simp only [equalRaw, ih, value]
+      cases b <;> cases c <;> simp [equalStep] <;> omega
+  | cons a xs ih =>
+    cases ys with
+    | nil =>
+      simp only [equalRaw, ih, value]
+      cases a <;> cases c <;> simp [equalStep]
+    | cons b ys =>
+      simp only [equalRaw, ih, value]
+      cases a <;> cases b <;> cases c <;> simp [equalStep] <;> omega
+
+theorem equalRaw_steps (xs ys : List Bool) (c : Bool) :
+    (equalRaw xs ys c).steps ≤ 3 * (xs.length + ys.length) + 2 := by
+  induction xs generalizing ys c with
+  | nil =>
+    induction ys generalizing c with
+    | nil => simp [equalRaw]
+    | cons b ys ih =>
+      have h := ih (equalStep false b c)
+      simp only [equalRaw, List.length_cons, List.length_nil] at h ⊢
+      omega
+  | cons a xs ih =>
+    cases ys with
+    | nil =>
+      have h := ih [] (equalStep a false c)
+      simp only [equalRaw, List.length_cons, List.length_nil] at h ⊢
+      omega
+    | cons b ys =>
+      have h := ih ys (equalStep a b c)
+      simp only [equalRaw, List.length_cons] at h ⊢
+      omega
+
+structure SubRun extends WordRun where
+  finalBorrow : Bool
+
+def subRaw : List Bool → List Bool → Bool → SubRun
+  | [], [], c => ⟨⟨[], 2⟩, c⟩
+  | a :: xs, [], c =>
+      let r := subRaw xs [] (borrow a false c)
+      ⟨⟨parity a false c :: r.bits, r.steps + 5⟩, r.finalBorrow⟩
+  | [], b :: ys, c =>
+      let r := subRaw [] ys (borrow false b c)
+      ⟨⟨parity false b c :: r.bits, r.steps + 5⟩, r.finalBorrow⟩
+  | a :: xs, b :: ys, c =>
+      let r := subRaw xs ys (borrow a b c)
+      ⟨⟨parity a b c :: r.bits, r.steps + 5⟩, r.finalBorrow⟩
+
+theorem subRaw_borrow (xs ys : List Bool) (c : Bool) :
+    (subRaw xs ys c).finalBorrow = (lessRaw xs ys c).bit := by
+  induction xs generalizing ys c with
+  | nil =>
+    induction ys generalizing c with
+    | nil => simp [subRaw, lessRaw]
+    | cons b ys ih => simp only [subRaw, lessRaw, ih]
+  | cons a xs ih =>
+    cases ys <;> simp only [subRaw, lessRaw, ih]
+
+theorem subRaw_value (xs ys : List Bool) (c : Bool) :
+    value (subRaw xs ys c).bits + value ys + c.toNat =
+      value xs + 2 ^ (max xs.length ys.length) * (subRaw xs ys c).finalBorrow.toNat := by
+  induction xs generalizing ys c with
+  | nil =>
+    induction ys generalizing c with
+    | nil => simp [subRaw, value]
+    | cons b ys ih =>
+      have h := ih (borrow false b c)
+      have hb := fullSubtractor_identity false b c
+      simp only [subRaw, value, List.length_nil, List.length_cons, Nat.zero_max,
+        pow_succ, Bool.toNat_false, Nat.zero_add, Nat.mul_assoc] at h hb ⊢
+      nlinarith
+  | cons a xs ih =>
+    cases ys with
+    | nil =>
+      have h := ih [] (borrow a false c)
+      have hb := fullSubtractor_identity a false c
+      simp only [subRaw, value, List.length_nil, List.length_cons, Nat.max_zero,
+        pow_succ, Bool.toNat_false, Nat.add_zero, Nat.mul_assoc] at h hb ⊢
+      nlinarith
+    | cons b ys =>
+      have h := ih ys (borrow a b c)
+      have hb := fullSubtractor_identity a b c
+      have hm : max (xs.length + 1) (ys.length + 1) = max xs.length ys.length + 1 := by omega
+      simp only [subRaw, value, List.length_cons, hm,
+        pow_succ, Nat.mul_assoc] at h hb ⊢
+      nlinarith
+
+theorem subRaw_length (xs ys : List Bool) (c : Bool) :
+    (subRaw xs ys c).bits.length = max xs.length ys.length := by
+  induction xs generalizing ys c with
+  | nil =>
+    induction ys generalizing c with
+    | nil => simp [subRaw]
+    | cons b ys ih => simp [subRaw, ih]
+  | cons a xs ih => cases ys <;> simp [subRaw, ih, max_add_add_right]
+
+theorem subRaw_steps (xs ys : List Bool) (c : Bool) :
+    (subRaw xs ys c).steps ≤ 5 * (xs.length + ys.length) + 2 := by
+  induction xs generalizing ys c with
+  | nil =>
+    induction ys generalizing c with
+    | nil => simp [subRaw]
+    | cons b ys ih =>
+      have h := ih (borrow false b c)
+      simp only [subRaw, List.length_cons, List.length_nil] at h ⊢
+      omega
+  | cons a xs ih =>
+    cases ys with
+    | nil =>
+      have h := ih [] (borrow a false c)
+      simp only [subRaw, List.length_cons, List.length_nil] at h ⊢
+      omega
+    | cons b ys =>
+      have h := ih ys (borrow a b c)
+      simp only [subRaw, List.length_cons] at h ⊢
+      omega
+
+def sub (xs ys : List Bool) : WordRun :=
+  let raw := subRaw xs ys false
+  if raw.finalBorrow then ⟨[], raw.steps + 1⟩
+  else ⟨trim raw.bits, raw.steps + 1 + trimSteps raw.bits⟩
+
+theorem sub_value (xs ys : List Bool) : value (sub xs ys).bits = value xs - value ys := by
+  have h := subRaw_value xs ys false
+  have hb := lessRaw_value xs ys false
+  rw [← subRaw_borrow] at hb
+  cases hcase : (subRaw xs ys false).finalBorrow with
+  | false =>
+    simp [sub, hcase, value_trim]
+    simp [hcase] at h
+    omega
+  | true =>
+    have hlt : value xs < value ys := by simpa [hcase] using hb.mp hcase
+    simp [sub, hcase, value, Nat.sub_eq_zero_of_le (Nat.le_of_lt hlt)]
+
+theorem sub_steps (xs ys : List Bool) :
+    (sub xs ys).steps ≤ 8 * (xs.length + ys.length) + 4 := by
+  have hs := subRaw_steps xs ys false
+  have hl := subRaw_length xs ys false
+  unfold sub
+  dsimp only
+  split <;> simp only [trimSteps_eq] <;> omega
+
+def mulRaw : List Bool → List Bool → WordRun
+  | [], _ => ⟨[], 1⟩
+  | b :: xs, ys =>
+      let r := mulRaw xs ys
+      if b then
+        let a := addRaw ys (false :: r.bits) false
+        ⟨a.bits, r.steps + a.steps + 3⟩
+      else ⟨false :: r.bits, r.steps + 3⟩
+
+theorem mulRaw_value (xs ys : List Bool) :
+    value (mulRaw xs ys).bits = value xs * value ys := by
+  induction xs with
+  | nil => simp [mulRaw, value]
+  | cons b xs ih =>
+    cases b <;> simp [mulRaw, value, addRaw_value, ih] <;> ring
+
+theorem mulRaw_length (xs ys : List Bool) :
+    (mulRaw xs ys).bits.length ≤ 2 * xs.length + ys.length := by
+  induction xs with
+  | nil => simp [mulRaw]
+  | cons b xs ih =>
+    have ha := addRaw_length ys (false :: (mulRaw xs ys).bits) false
+    cases b <;> simp only [mulRaw, Bool.false_eq_true, ite_false, ite_true,
+      List.length_cons] at * <;> omega
+
+theorem mulRaw_steps (xs ys : List Bool) :
+    (mulRaw xs ys).steps ≤ 10 * xs.length * (xs.length + ys.length + 2) + 1 := by
+  induction xs with
+  | nil => simp [mulRaw]
+  | cons b xs ih =>
+    have ha := addRaw_steps ys (false :: (mulRaw xs ys).bits) false
+    have hl := mulRaw_length xs ys
+    cases b <;> simp only [mulRaw, Bool.false_eq_true, ite_false, ite_true,
+      List.length_cons] at * <;> nlinarith
+
+def mul (xs ys : List Bool) : WordRun :=
+  let raw := mulRaw xs ys
+  ⟨trim raw.bits, raw.steps + trimSteps raw.bits⟩
+
+theorem mul_value (xs ys : List Bool) : value (mul xs ys).bits = value xs * value ys := by
+  simp [mul, mulRaw_value]
+
+theorem mul_steps (xs ys : List Bool) :
+    (mul xs ys).steps ≤ 10 * xs.length * (xs.length + ys.length + 2) +
+      6 * xs.length + 3 * ys.length + 2 := by
+  have hs := mulRaw_steps xs ys
+  have hl := mulRaw_length xs ys
+  simp only [mul, trimSteps_eq]
+  omega
+
+def addNat (a b : ℕ) : WordRun := add a.bits b.bits
+def subNat (a b : ℕ) : WordRun := sub a.bits b.bits
+def mulNat (a b : ℕ) : WordRun := mul a.bits b.bits
+def lessNat (a b : ℕ) : BoolRun := lessRaw a.bits b.bits false
+def equalNat (a b : ℕ) : BoolRun := equalRaw a.bits b.bits true
+def oddNat (a : ℕ) : BoolRun := ⟨a.bits.headD false, 2⟩
+
+theorem oddNat_value (a : ℕ) : (oddNat a).bit.toNat = a % 2 := by
+  have hhead : a.bits.headD false = a.bits.headI := by cases a.bits <;> rfl
+  change (a.bits.headD false).toNat = a % 2
+  rw [hhead, ← Nat.bodd_eq_bits_head]
+  exact (Nat.mod_two_of_bodd a).symm
+
+theorem oddNat_eq (a : ℕ) : (oddNat a).bit = decide (a % 2 = 1) := by
+  have h := oddNat_value a
+  cases hb : (oddNat a).bit <;> simp [hb] at h ⊢ <;> omega
+
+theorem addNat_value (a b : ℕ) : (addNat a b).bits = (a + b).bits := by
+  simp only [addNat, add, ← bits_value, addRaw_value, value_bits, Bool.toNat_false, Nat.add_zero]
+
+theorem mulNat_value (a b : ℕ) : (mulNat a b).bits = (a * b).bits := by
+  simp only [mulNat, mul, ← bits_value, mulRaw_value, value_bits]
+
+theorem subNat_value (a b : ℕ) : (subNat a b).bits = (a - b).bits := by
+  have hv := sub_value a.bits b.bits
+  simp only [value_bits] at hv
+  unfold subNat sub
+  dsimp only
+  split
+  · have hzero : a - b = 0 := by simpa [sub, value, *] using hv.symm
+    simp [hzero]
+  · have hraw : value (subRaw a.bits b.bits false).bits = a - b := by
+      simpa [sub, *] using hv
+    change trim (subRaw a.bits b.bits false).bits = (a - b).bits
+    rw [← bits_value, hraw]
+
+theorem lessNat_value (a b : ℕ) : (lessNat a b).bit = decide (a < b) := by
+  apply Bool.eq_iff_iff.mpr
+  simp [lessNat, lessRaw_value, value_bits]
+
+theorem equalNat_value (a b : ℕ) : (equalNat a b).bit = decide (a = b) := by
+  apply Bool.eq_iff_iff.mpr
+  simp [equalNat, equalRaw_value, value_bits]
+
+theorem addNat_steps (a b : ℕ) : (addNat a b).steps ≤ (BitModel.addCost a b) ^ 2 := by
+  have h := add_steps a.bits b.bits
+  simp only [Nat.size_eq_bits_len] at h
+  unfold addNat BitModel.addCost BitModel.width
+  nlinarith [sq_nonneg (a.size + b.size : ℤ)]
+
+theorem subNat_steps (a b : ℕ) : (subNat a b).steps ≤ (BitModel.addCost a b) ^ 2 := by
+  have h := sub_steps a.bits b.bits
+  simp only [Nat.size_eq_bits_len] at h
+  unfold subNat BitModel.addCost BitModel.width
+  nlinarith [sq_nonneg (a.size + b.size : ℤ)]
+
+theorem lessNat_steps (a b : ℕ) : (lessNat a b).steps ≤ (BitModel.compareCost a b) ^ 2 := by
+  have h := lessRaw_steps a.bits b.bits false
+  simp only [Nat.size_eq_bits_len] at h
+  unfold lessNat BitModel.compareCost BitModel.width
+  nlinarith [sq_nonneg (a.size + b.size : ℤ)]
+
+theorem equalNat_steps (a b : ℕ) : (equalNat a b).steps ≤ (BitModel.compareCost a b) ^ 2 := by
+  have h := equalRaw_steps a.bits b.bits true
+  simp only [Nat.size_eq_bits_len] at h
+  unfold equalNat BitModel.compareCost BitModel.width
+  nlinarith [sq_nonneg (a.size + b.size : ℤ)]
+
+theorem mulNat_steps (a b : ℕ) : (mulNat a b).steps ≤ (BitModel.mulCost a b) ^ 2 := by
+  have h := mul_steps a.bits b.bits
+  simp only [Nat.size_eq_bits_len] at h
+  let W := (a.size + 1) * (b.size + 1)
+  have hW : 1 ≤ W := by
+    exact Nat.mul_le_mul (show 1 ≤ a.size + 1 by omega) (show 1 ≤ b.size + 1 by omega)
+  have ha : a.size ≤ W := by dsimp [W]; nlinarith
+  have hb : b.size ≤ W := by dsimp [W]; nlinarith
+  have hs : a.size + b.size + 2 ≤ 2 * W := by dsimp [W]; nlinarith
+  have hp : a.size * (a.size + b.size + 2) ≤ W * (2 * W) :=
+    Nat.mul_le_mul ha hs
+  change (mul a.bits b.bits).steps ≤ (8 * (a.size + 1) * (b.size + 1)) ^ 2
+  have he : 8 * (a.size + 1) * (b.size + 1) = 8 * W := by dsimp [W]; ring
+  rw [he]
+  nlinarith
+
+end NCHitting.BitArithmetic
+
+end OAI
diff --git a/lean/OAI/Algebra/FormulaHitting/BitBounds.lean b/lean/OAI/Algebra/FormulaHitting/BitBounds.lean
new file mode 100644
index 0000000000000000000000000000000000000000..dc45b89ab5df542c500b3f6d35339c64f245e97f
--- /dev/null
+++ b/lean/OAI/Algebra/FormulaHitting/BitBounds.lean
@@ -0,0 +1,36 @@
+import OAI.Algebra.FormulaHitting.Generator
+import Mathlib.Data.Nat.Log
+
+namespace OAI
+
+namespace NCHitting
+
+theorem size_eq_clog (a : ℕ) : a.size = Nat.clog 2 (a+1) := by
+  apply eq_of_forall_ge_iff
+  intro k
+  rw [Nat.size_le, Nat.clog_le_iff_le_pow (by decide)]
+  omega
+
+theorem entryBitBound_eq_clog (n d : ℕ) :
+    entryBitBound n d = 3 + Nat.clog 2 (d+1) + d * Nat.clog 2 (n+1) := by
+  simp only [entryBitBound, size_eq_clog]
+
+theorem entryBitBound_in_parameters {n s : ℕ} (hn : 0 < n) (hs : 0 < s) :
+    entryBitBound n (2*n*s^2) ≤
+      6 + 3 * Nat.clog 2 (n*s+1) + 2*n*s^2 * Nat.clog 2 (n+1) := by
+  have hnle : n ≤ n*s := Nat.le_mul_of_pos_right n hs
+  have hsle : s ≤ n*s := Nat.le_mul_of_pos_left s hn
+  have hnb := Nat.size_le_size hnle
+  have hsb := Nat.size_le_size hsle
+  have hpow := size_pow_le s 2
+  have hmul₁ := size_mul_le 2 n
+  have hmul₂ := size_mul_le (2*n) (s^2)
+  have htwo : Nat.size 2 = 2 := by decide
+  rw [htwo] at hmul₁
+  rw [← size_eq_clog, ← size_eq_clog]
+  unfold entryBitBound
+  omega
+
+end NCHitting
+
+end OAI
diff --git a/lean/OAI/Algebra/FormulaHitting/BitCost.lean b/lean/OAI/Algebra/FormulaHitting/BitCost.lean
new file mode 100644
index 0000000000000000000000000000000000000000..95f089fc53a18f3ad0af677954ac975eb7267a50
--- /dev/null
+++ b/lean/OAI/Algebra/FormulaHitting/BitCost.lean
@@ -0,0 +1,29 @@
+import OAI.Algebra.FormulaHitting.GeneratorCost
+import OAI.Algebra.FormulaHitting.BitRefinement
+
+namespace OAI
+
+namespace NCHitting
+
+def primitiveBitBound (n s : ℕ) : ℕ := 1024 * generatorCostBound n s ^ 3
+
+def generatorBitTrace (n s : ℕ) : BitRefinement.Trace :=
+  BitRefinement.Step.input [n, s] :: BitRefinement.programTrace [n, s] generatorProgram
+
+theorem generatorBitTrace_executes (n s : ℕ) :
+    BitRefinement.Exec generatorProgram [n, s] (generate n s).output
+      (BitRefinement.Trace.steps (generatorBitTrace n s)) :=
+  ⟨BitRefinement.programTrace [n, s] generatorProgram,
+    BitRefinement.programTrace_correct [n, s] generatorProgram, rfl⟩
+
+theorem generate_primitive_bit_bound (n s : ℕ) :
+    BitRefinement.Exec generatorProgram [n, s] (generate n s).output
+        (BitRefinement.executionSteps generatorProgram [n, s]) ∧
+      BitRefinement.executionSteps generatorProgram [n, s] ≤ primitiveBitBound n s := by
+  refine ⟨BitRefinement.executionSteps_exec generatorProgram [n, s],
+    (BitRefinement.executionSteps_le generatorProgram [n, s]).trans ?_⟩
+  exact Nat.mul_le_mul_left 1024 (Nat.pow_le_pow_left (generate_cost_le n s) 3)
+
+end NCHitting
+
+end OAI
diff --git a/lean/OAI/Algebra/FormulaHitting/BitModel.lean b/lean/OAI/Algebra/FormulaHitting/BitModel.lean
new file mode 100644
index 0000000000000000000000000000000000000000..818491fbcbcc217b0c3555d4cbda0d6b8e2669b0
--- /dev/null
+++ b/lean/OAI/Algebra/FormulaHitting/BitModel.lean
@@ -0,0 +1,137 @@
+import Mathlib.Data.Nat.Size
+import Mathlib.Data.List.Range
+import Mathlib.Algebra.BigOperators.Group.List.Basic
+
+namespace OAI
+
+namespace NCHitting.BitModel
+
+def width (n : ℕ) : ℕ := n.size + 1
+
+def addCost (a b : ℕ) : ℕ := 4 * (width a + width b)
+def mulCost (a b : ℕ) : ℕ := 8 * width a * width b
+def compareCost (a b : ℕ) : ℕ := 2 * (width a + width b)
+
+def listBits (xs : List ℕ) : ℕ := (xs.map width).sum
+
+structure NatResult where
+  value : ℕ
+  cost : ℕ
+  deriving DecidableEq, Repr
+
+def powerRun (base : ℕ) : ℕ → NatResult
+  | 0 => ⟨1, width 1⟩
+  | k + 1 =>
+      let previous := powerRun base k
+      ⟨previous.value * base,
+        previous.cost + mulCost previous.value base + addCost k 1 + 1⟩
+
+@[simp] theorem powerRun_value (base k : ℕ) : (powerRun base k).value = base ^ k := by
+  induction k with
+  | zero => rfl
+  | succ k ih => simp [powerRun, ih, pow_succ]
+
+inductive Expr where
+  | literal : ℕ → Expr
+  | read : ℕ → Expr
+  | add : Expr → Expr → Expr
+  | sub : Expr → Expr → Expr
+  | mul : Expr → Expr → Expr
+  | power : Expr → Expr → Expr
+  | less : Expr → Expr → Expr
+  | equal : Expr → Expr → Expr
+  | odd : Expr → Expr
+  deriving DecidableEq, Repr
+
+def Expr.run (environment : List ℕ) : Expr → NatResult
+  | .literal n => ⟨n, width n + 1⟩
+  | .read index =>
+      ⟨environment[index]?.getD 0,
+        width index + listBits (environment.take (index + 1)) + 1⟩
+  | .add a b =>
+      let x := a.run environment
+      let y := b.run environment
+      ⟨x.value + y.value, x.cost + y.cost + addCost x.value y.value + 1⟩
+  | .sub a b =>
+      let x := a.run environment
+      let y := b.run environment
+      ⟨x.value - y.value, x.cost + y.cost + addCost x.value y.value + 1⟩
+  | .mul a b =>
+      let x := a.run environment
+      let y := b.run environment
+      ⟨x.value * y.value, x.cost + y.cost + mulCost x.value y.value + 1⟩
+  | .power a b =>
+      let x := a.run environment
+      let y := b.run environment
+      let z := powerRun x.value y.value
+      ⟨z.value, x.cost + y.cost + z.cost + 1⟩
+  | .less a b =>
+      let x := a.run environment
+      let y := b.run environment
+      ⟨if x.value < y.value then 1 else 0,
+        x.cost + y.cost + compareCost x.value y.value + 1⟩
+  | .equal a b =>
+      let x := a.run environment
+      let y := b.run environment
+      ⟨if x.value = y.value then 1 else 0,
+        x.cost + y.cost + compareCost x.value y.value + 1⟩
+  | .odd a =>
+      let x := a.run environment
+      ⟨x.value % 2, x.cost + 2⟩
+
+structure RationalCode where
+  negative : Bool
+  numerator : ℕ
+  denominator : ℕ
+  deriving DecidableEq, Repr
+
+def RationalCode.bits (entry : RationalCode) : ℕ :=
+  1 + width entry.numerator + width entry.denominator
+
+def outputBits (entries : List RationalCode) : ℕ := (entries.map RationalCode.bits).sum
+
+inductive Program where
+  | skip : Program
+  | emit : Expr → Expr → Expr → Program
+  | sequence : Program → Program → Program
+  | branch : Expr → Program → Program → Program
+  | loop : Expr → Program → Program
+  deriving DecidableEq, Repr
+
+structure ProgramResult where
+  output : List RationalCode
+  cost : ℕ
+  deriving DecidableEq, Repr
+
+def Program.run (environment : List ℕ) : Program → ProgramResult
+  | .skip => ⟨[], 1⟩
+  | .emit sign numerator denominator =>
+      let s := sign.run environment
+      let a := numerator.run environment
+      let b := denominator.run environment
+      let entry : RationalCode := ⟨decide (s.value % 2 = 1), a.value, b.value⟩
+      ⟨[entry], s.cost + a.cost + b.cost + entry.bits + 2⟩
+  | .sequence p q =>
+      let x := p.run environment
+      let y := q.run environment
+      ⟨x.output ++ y.output, x.cost + y.cost + outputBits x.output + 1⟩
+  | .branch test yes no =>
+      let t := test.run environment
+      let result := if t.value = 0 then no.run environment else yes.run environment
+      ⟨result.output, t.cost + result.cost + 1⟩
+  | .loop bound body =>
+      let b := bound.run environment
+      let iterations := (List.range b.value).map fun index =>
+        let result := body.run (index :: environment)
+        (result, width index + addCost index 1 + 1)
+      ⟨iterations.flatMap (fun result => result.1.output),
+        b.cost + 1 + (iterations.map fun result =>
+          result.1.cost + result.2 + outputBits result.1.output).sum⟩
+
+def execute (program : Program) (inputs : List ℕ) : ProgramResult :=
+  let result := program.run inputs
+  ⟨result.output, listBits inputs + result.cost⟩
+
+end NCHitting.BitModel
+
+end OAI
diff --git a/lean/OAI/Algebra/FormulaHitting/BitRefinement.lean b/lean/OAI/Algebra/FormulaHitting/BitRefinement.lean
new file mode 100644
index 0000000000000000000000000000000000000000..1e5089eb9da8ef59a139feeb2c71e4ba58743132
--- /dev/null
+++ b/lean/OAI/Algebra/FormulaHitting/BitRefinement.lean
@@ -0,0 +1,632 @@
+import OAI.Algebra.FormulaHitting.BitArithmetic
+import OAI.Algebra.FormulaHitting.ProgramCost
+
+namespace OAI
+
+namespace NCHitting.BitRefinement
+
+open BitModel
+
+theorem width_pos (a : ℕ) : 0 < width a := by unfold width; omega
+
+theorem width_mono {a b : ℕ} (h : a ≤ b) : width a ≤ width b :=
+  Nat.add_le_add_right (Nat.size_le_size h) 1
+
+theorem width_add_le (a b : ℕ) : width (a+b) ≤ width a + width b := by
+  have ha := Nat.lt_size_self a
+  have hb := Nat.lt_size_self b
+  have hpa : 2^a.size ≤ 2^(a.size+b.size) :=
+    Nat.pow_le_pow_right (by decide) (by omega)
+  have hpb : 2^b.size ≤ 2^(a.size+b.size) :=
+    Nat.pow_le_pow_right (by decide) (by omega)
+  have hp : a+b < 2^(a.size+b.size+1) := by rw [pow_succ]; omega
+  have hs := Nat.size_le.mpr hp
+  unfold width
+  omega
+
+theorem addCost_ge_widths (a b : ℕ) : width a + width b ≤ addCost a b := by
+  unfold addCost
+  omega
+
+theorem mulCost_ge_widths (a b : ℕ) : width a + width b ≤ mulCost a b := by
+  have ha := width_pos a
+  have hb := width_pos b
+  unfold mulCost
+  nlinarith
+
+theorem powerRun_count_le (base k : ℕ) : k+2 ≤ (powerRun base k).cost := by
+  induction k with
+  | zero => simp [powerRun, width]
+  | succ k ih => simp only [powerRun]; omega
+
+theorem powerRun_width_le (base k : ℕ) :
+    width (base^k) ≤ (powerRun base k).cost := by
+  induction k with
+  | zero => simp [powerRun, width]
+  | succ k ih =>
+    have hw := BitModel.width_mul_le (base^k) base
+    have hc := mulCost_ge_widths (base^k) base
+    simp only [powerRun, powerRun_value, pow_succ]
+    omega
+
+theorem listBits_mem_le {a : ℕ} {env : List ℕ} (h : a ∈ env) :
+    width a ≤ listBits env := by
+  induction env with
+  | nil => simp at h
+  | cons x xs ih =>
+    simp only [List.mem_cons] at h
+    rcases h with rfl | h
+    · simp [listBits]
+    · have hi := ih h
+      change width a ≤ width x + listBits xs
+      omega
+
+theorem expr_width_le (env : List ℕ) (e : Expr) :
+    width (e.run env).value ≤ (e.run env).cost + listBits env := by
+  cases e with
+  | literal a => simp only [Expr.run]; omega
+  | read i =>
+    cases h : env[i]? with
+    | none => simp only [Expr.run, h, Option.getD_none, width, Nat.size_zero]; omega
+    | some a =>
+      have hw := listBits_mem_le (List.mem_of_getElem? h)
+      simp only [Expr.run, h, Option.getD_some]
+      omega
+  | add a b =>
+    have hw := width_add_le (a.run env).value (b.run env).value
+    have hc := addCost_ge_widths (a.run env).value (b.run env).value
+    simp only [Expr.run]
+    omega
+  | sub a b =>
+    have hw := width_mono (Nat.sub_le (a.run env).value (b.run env).value)
+    have hc := addCost_ge_widths (a.run env).value (b.run env).value
+    simp only [Expr.run]
+    omega
+  | mul a b =>
+    have hw := BitModel.width_mul_le (a.run env).value (b.run env).value
+    have hc := mulCost_ge_widths (a.run env).value (b.run env).value
+    simp only [Expr.run]
+    omega
+  | power a b =>
+    have hw := powerRun_width_le (a.run env).value (b.run env).value
+    simpa only [Expr.run, powerRun_value] using hw.trans
+      (by omega : (powerRun (a.run env).value (b.run env).value).cost ≤
+        (a.run env).cost + (b.run env).cost +
+          (powerRun (a.run env).value (b.run env).value).cost + 1 + listBits env)
+  | less a b =>
+    simp only [Expr.run]
+    split <;> simp [width, compareCost] <;> omega
+  | equal a b =>
+    simp only [Expr.run]
+    split <;> simp [width, compareCost] <;> omega
+  | odd a =>
+    have h : (a.run env).value % 2 ≤ 1 := by omega
+    have hw := width_mono h
+    simp only [Expr.run]
+    have : width 1 = 2 := rfl
+    omega
+
+inductive Step where
+  | writeNat : ℕ → Step
+  | read : List ℕ → ℕ → Step
+  | add : ℕ → ℕ → Step
+  | sub : ℕ → ℕ → Step
+  | mul : ℕ → ℕ → Step
+  | less : ℕ → ℕ → Step
+  | equal : ℕ → ℕ → Step
+  | odd : ℕ → Step
+  | emit : RationalCode → Step
+  | copy : List RationalCode → Step
+  | input : List ℕ → Step
+  | control : Step
+  deriving DecidableEq
+
+def Step.tariff : Step → ℕ
+  | .writeNat n => width n
+  | .read env i => width i + listBits (env.take (i+1)) + 1
+  | .add a b | .sub a b => addCost a b
+  | .mul a b => mulCost a b
+  | .less a b | .equal a b => compareCost a b
+  | .odd _ => 2
+  | .emit e => e.bits + 2
+  | .copy es => outputBits es
+  | .input env => listBits env
+  | .control => 1
+
+def Step.steps : Step → ℕ
+  | .add a b => (BitArithmetic.addNat a b).steps
+  | .sub a b => (BitArithmetic.subNat a b).steps
+  | .mul a b => (BitArithmetic.mulNat a b).steps
+  | .less a b => (BitArithmetic.lessNat a b).steps
+  | .equal a b => (BitArithmetic.equalNat a b).steps
+  | s => s.tariff
+
+theorem self_le_square (a : ℕ) : a ≤ a^2 := by
+  cases a with
+  | zero => simp
+  | succ a => nlinarith
+
+theorem Step.steps_le (s : Step) : s.steps ≤ s.tariff^2 := by
+  cases s with
+  | add a b => exact BitArithmetic.addNat_steps a b
+  | sub a b => exact BitArithmetic.subNat_steps a b
+  | mul a b => exact BitArithmetic.mulNat_steps a b
+  | less a b => exact BitArithmetic.lessNat_steps a b
+  | equal a b => exact BitArithmetic.equalNat_steps a b
+  | _ => exact self_le_square _
+
+abbrev Trace := List Step
+def Trace.steps (t : Trace) : ℕ := (t.map Step.steps).sum
+
+def powerTrace (base : ℕ) : ℕ → Trace
+  | 0 => [.equal 0 0, .control, .writeNat 1]
+  | k+1 => [.equal (k+1) 0, .control, .sub (k+1) 1] ++ powerTrace base k ++
+      [.mul (base^k) base]
+
+def exprTrace (env : List ℕ) : Expr → Trace
+  | .literal n => [.writeNat n, .control]
+  | .read i => [.read env i]
+  | .add a b => exprTrace env a ++ exprTrace env b ++
+      [.add (a.run env).value (b.run env).value, .control]
+  | .sub a b => exprTrace env a ++ exprTrace env b ++
+      [.sub (a.run env).value (b.run env).value, .control]
+  | .mul a b => exprTrace env a ++ exprTrace env b ++
+      [.mul (a.run env).value (b.run env).value, .control]
+  | .less a b => exprTrace env a ++ exprTrace env b ++
+      [.less (a.run env).value (b.run env).value, .control]
+  | .equal a b => exprTrace env a ++ exprTrace env b ++
+      [.equal (a.run env).value (b.run env).value, .control]
+  | .power a b => exprTrace env a ++ exprTrace env b ++
+      powerTrace (a.run env).value (b.run env).value ++ [.control]
+  | .odd a => exprTrace env a ++ [.odd (a.run env).value]
+
+def programTrace (env : List ℕ) : Program → Trace
+  | .skip => [.control]
+  | .emit s a b => exprTrace env s ++ exprTrace env a ++ exprTrace env b ++
+      [.emit ⟨decide ((s.run env).value % 2 = 1), (a.run env).value, (b.run env).value⟩]
+  | .sequence p q => programTrace env p ++ programTrace env q ++
+      [.copy (p.run env).output, .control]
+  | .branch e p q => exprTrace env e ++ [.equal (e.run env).value 0, .control] ++
+      (if (e.run env).value = 0 then programTrace env q else programTrace env p)
+  | .loop e p => exprTrace env e ++
+      ((List.range (e.run env).value).flatMap fun i =>
+        [.equal i (e.run env).value, .writeNat i] ++ programTrace (i::env) p ++
+          [.add i 1, .copy (p.run (i::env)).output, .control]) ++
+      [.equal (e.run env).value (e.run env).value, .control]
+
+inductive PowerExecution (base : ℕ) : ℕ → ℕ → Trace → Prop where
+  | zero : PowerExecution base 0 1 [.equal 0 0, .control, .writeNat 1]
+  | succ {k v t} (h : PowerExecution base k v t)
+      (hc : (BitArithmetic.equalNat (k+1) 0).bit = false)
+      (hd : (BitArithmetic.subNat (k+1) 1).bits = k.bits) :
+      PowerExecution base (k+1) (BitArithmetic.value (BitArithmetic.mulNat v base).bits)
+        ([.equal (k+1) 0, .control, .sub (k+1) 1] ++ t ++ [.mul v base])
+
+inductive ExprExecution (env : List ℕ) : Expr → ℕ → Trace → Prop where
+  | literal (n) : ExprExecution env (.literal n) n [.writeNat n, .control]
+  | read (i) : ExprExecution env (.read i) (env[i]?.getD 0) [.read env i]
+  | add {a b x y tx ty} (ha : ExprExecution env a x tx) (hb : ExprExecution env b y ty) :
+      ExprExecution env (.add a b) (BitArithmetic.value (BitArithmetic.addNat x y).bits)
+        (tx ++ ty ++ [.add x y, .control])
+  | sub {a b x y tx ty} (ha : ExprExecution env a x tx) (hb : ExprExecution env b y ty) :
+      ExprExecution env (.sub a b) (BitArithmetic.value (BitArithmetic.subNat x y).bits)
+        (tx ++ ty ++ [.sub x y, .control])
+  | mul {a b x y tx ty} (ha : ExprExecution env a x tx) (hb : ExprExecution env b y ty) :
+      ExprExecution env (.mul a b) (BitArithmetic.value (BitArithmetic.mulNat x y).bits)
+        (tx ++ ty ++ [.mul x y, .control])
+  | less {a b x y tx ty} (ha : ExprExecution env a x tx) (hb : ExprExecution env b y ty) :
+      ExprExecution env (.less a b) (BitArithmetic.lessNat x y).bit.toNat
+        (tx ++ ty ++ [.less x y, .control])
+  | equal {a b x y tx ty} (ha : ExprExecution env a x tx) (hb : ExprExecution env b y ty) :
+      ExprExecution env (.equal a b) (BitArithmetic.equalNat x y).bit.toNat
+        (tx ++ ty ++ [.equal x y, .control])
+  | power {a b x y v tx ty tp} (ha : ExprExecution env a x tx) (hb : ExprExecution env b y ty)
+      (hp : PowerExecution x y v tp) :
+      ExprExecution env (.power a b) v (tx ++ ty ++ tp ++ [.control])
+  | odd {a x tx} (ha : ExprExecution env a x tx) :
+      ExprExecution env (.odd a) (BitArithmetic.oddNat x).bit.toNat (tx ++ [.odd x])
+
+inductive ProgramExecution : List ℕ → Program → List RationalCode → Trace → Prop where
+  | skip (env) : ProgramExecution env .skip [] [.control]
+  | emit {env s a b x y z tx ty tz}
+      (hs : ExprExecution env s x tx) (ha : ExprExecution env a y ty)
+      (hb : ExprExecution env b z tz) :
+      ProgramExecution env (.emit s a b) [⟨(BitArithmetic.oddNat x).bit,y,z⟩]
+        (tx ++ ty ++ tz ++ [.emit ⟨(BitArithmetic.oddNat x).bit,y,z⟩])
+  | sequence {env p q x y tx ty}
+      (hp : ProgramExecution env p x tx) (hq : ProgramExecution env q y ty) :
+      ProgramExecution env (.sequence p q) (x++y) (tx++ty++[.copy x,.control])
+  | branch {env e p q x tx output tp}
+      (he : ExprExecution env e x tx)
+      (hp : ProgramExecution env (if x=0 then q else p) output tp)
+      (hc : (BitArithmetic.equalNat x 0).bit = decide (x=0)) :
+      ProgramExecution env (.branch e p q) output (tx++[.equal x 0,.control]++tp)
+  | loop {env e p b te} (he : ExprExecution env e b te)
+      (outputs : ℕ → List RationalCode) (traces : ℕ → Trace)
+      (hbody : ∀ i < b, ProgramExecution (i::env) p (outputs i) (traces i))
+      (htest : ∀ i < b, (BitArithmetic.equalNat i b).bit = false)
+      (hstep : ∀ i < b, (BitArithmetic.addNat i 1).bits = (i+1).bits)
+      (hfinal : (BitArithmetic.equalNat b b).bit = true) :
+      ProgramExecution env (.loop e p) ((List.range b).flatMap outputs)
+        (te ++ ((List.range b).flatMap fun i =>
+          [.equal i b,.writeNat i] ++ traces i ++ [.add i 1,.copy (outputs i),.control]) ++
+          [.equal b b,.control])
+
+def Exec (p : Program) (inputs : List ℕ) (output : List RationalCode) (steps : ℕ) : Prop :=
+  ∃ t, ProgramExecution inputs p output t ∧ steps = Trace.steps (.input inputs :: t)
+
+theorem powerTrace_correct (base k : ℕ) : PowerExecution base k (base^k) (powerTrace base k) := by
+  induction k with
+  | zero => exact PowerExecution.zero
+  | succ k ih =>
+    simpa [powerTrace, BitArithmetic.mulNat_value, BitArithmetic.value_bits, pow_succ] using
+      PowerExecution.succ ih (by simp [BitArithmetic.equalNat_value])
+        (by simp [BitArithmetic.subNat_value])
+
+theorem exprTrace_correct (env : List ℕ) (e : Expr) :
+    ExprExecution env e (e.run env).value (exprTrace env e) := by
+  induction e with
+  | literal n => exact ExprExecution.literal n
+  | read i => exact ExprExecution.read i
+  | add a b ha hb =>
+    simpa [exprTrace, Expr.run, BitArithmetic.addNat_value, BitArithmetic.value_bits] using ExprExecution.add ha hb
+  | sub a b ha hb =>
+    simpa [exprTrace, Expr.run, BitArithmetic.subNat_value, BitArithmetic.value_bits] using ExprExecution.sub ha hb
+  | mul a b ha hb =>
+    simpa [exprTrace, Expr.run, BitArithmetic.mulNat_value, BitArithmetic.value_bits] using ExprExecution.mul ha hb
+  | less a b ha hb =>
+    by_cases h : (a.run env).value < (b.run env).value <;>
+      simpa [exprTrace, Expr.run, BitArithmetic.lessNat_value, h] using ExprExecution.less ha hb
+  | equal a b ha hb =>
+    by_cases h : (a.run env).value = (b.run env).value <;>
+      simpa [exprTrace, Expr.run, BitArithmetic.equalNat_value, h] using ExprExecution.equal ha hb
+  | power a b ha hb =>
+    simpa [exprTrace, Expr.run] using ExprExecution.power ha hb
+      (powerTrace_correct (a.run env).value (b.run env).value)
+  | odd a ha => simpa [exprTrace, Expr.run, BitArithmetic.oddNat_value] using ExprExecution.odd ha
+
+theorem programTrace_correct (env : List ℕ) (p : Program) :
+    ProgramExecution env p (p.run env).output (programTrace env p) := by
+  induction p generalizing env with
+  | skip => exact ProgramExecution.skip env
+  | emit s a b =>
+    simpa only [programTrace, Program.run, BitArithmetic.oddNat_eq] using
+      (ProgramExecution.emit (exprTrace_correct env s)
+        (exprTrace_correct env a) (exprTrace_correct env b))
+  | sequence p q hp hq => exact ProgramExecution.sequence (hp env) (hq env)
+  | branch e p q hp hq =>
+    have hchoice : ProgramExecution env (if (e.run env).value=0 then q else p)
+        (if (e.run env).value=0 then (q.run env).output else (p.run env).output)
+        (if (e.run env).value=0 then programTrace env q else programTrace env p) := by
+      split <;> [exact hq env; exact hp env]
+    simpa only [Program.run, programTrace, apply_ite] using
+      ProgramExecution.branch (exprTrace_correct env e) hchoice
+        (BitArithmetic.equalNat_value _ _)
+  | loop e p hp =>
+    simpa only [Program.run, programTrace, List.flatMap_map] using
+      ProgramExecution.loop (exprTrace_correct env e)
+        (fun i => (p.run (i::env)).output) (fun i => programTrace (i::env) p)
+        (fun i _ => hp (i::env))
+        (by intro i hi; simp [BitArithmetic.equalNat_value, Nat.ne_of_lt hi])
+        (by intro i _; exact BitArithmetic.addNat_value i 1)
+        (by simp [BitArithmetic.equalNat_value])
+
+structure Bounded (t : Trace) (cost cap : ℕ) : Prop where
+  length_le : t.length ≤ 2*cost
+  tariff_le : ∀ s ∈ t, s.tariff ≤ cap
+
+theorem Bounded.mono {t : Trace} {c b c' b' : ℕ} (h : Bounded t c b)
+    (hc : c ≤ c') (hb : b ≤ b') : Bounded t c' b' :=
+  ⟨h.length_le.trans (Nat.mul_le_mul_left 2 hc), fun s hs => (h.tariff_le s hs).trans hb⟩
+
+theorem Bounded.append {t u : Trace} {c d b : ℕ}
+    (ht : Bounded t c b) (hu : Bounded u d b) : Bounded (t++u) (c+d) b := by
+  refine ⟨?_, ?_⟩
+  · simp only [List.length_append]
+    have h1 := ht.length_le
+    have h2 := hu.length_le
+    omega
+  · intro s hs
+    rcases List.mem_append.mp hs with h | h
+    · exact ht.tariff_le s h
+    · exact hu.tariff_le s h
+
+theorem bounded_flatMap {α : Type*} (xs : List α) (f : α → Trace) (c : α → ℕ) (B : ℕ)
+    (h : ∀ x ∈ xs, Bounded (f x) (c x) B) :
+    Bounded (xs.flatMap f) ((xs.map c).sum) B := by
+  induction xs with
+  | nil => exact ⟨by simp, by simp⟩
+  | cons x xs ih =>
+    exact (h x (by simp)).append (ih (fun y hy => h y (by simp [hy])))
+
+theorem bounded_pair (s : Step) (c B : ℕ) (hs : s.tariff ≤ B) (hB : 1 ≤ B) :
+    Bounded [s,.control] (c+1) B := by
+  refine ⟨by simp, ?_⟩
+  intro t ht
+  simp only [List.mem_cons, List.not_mem_nil, or_false] at ht
+  rcases ht with rfl | rfl
+  · exact hs
+  · exact hB
+
+theorem bounded_single (s : Step) (c B : ℕ) (hc : 0 < c) (hs : s.tariff ≤ B) :
+    Bounded [s] c B := by
+  refine ⟨by simp; omega, ?_⟩
+  intro t ht
+  have ht' : t = s := by simpa using ht
+  subst t
+  exact hs
+
+theorem expr_cost_pos (env : List ℕ) (e : Expr) : 0 < (e.run env).cost := by
+  cases e <;> simp only [Expr.run] <;> omega
+
+theorem program_cost_pos (env : List ℕ) (p : Program) : 0 < (p.run env).cost := by
+  cases p <;> simp only [Program.run] <;> omega
+
+theorem powerTrace_bounded (base k : ℕ) :
+    Bounded (powerTrace base k) (powerRun base k).cost (16*(powerRun base k).cost) := by
+  induction k with
+  | zero =>
+    constructor
+    · simp [powerTrace, powerRun, width]
+    · intro s hs
+      simp only [powerTrace, List.mem_cons, List.not_mem_nil, or_false] at hs
+      rcases hs with rfl | rfl | rfl <;> simp [Step.tariff, powerRun, compareCost, width]
+  | succ k ih =>
+    have hc := powerRun_count_le base (k+1)
+    have hw := BitModel.width_le_of_le (le_refl (k+1))
+    have hold : (powerRun base k).cost ≤ (powerRun base (k+1)).cost := by simp [powerRun]; omega
+    have hmul : mulCost (base^k) base ≤ (powerRun base (k+1)).cost := by
+      simp only [powerRun, powerRun_value]; omega
+    constructor
+    · have hl := ih.length_le
+      have hm := mulCost_ge_widths (base^k) base
+      have hp := width_pos base
+      simp only [powerTrace, List.length_append, List.length_cons, List.length_nil,
+        powerRun, powerRun_value]
+      omega
+    · intro s hs
+      simp only [powerTrace, List.mem_append, List.mem_cons, List.not_mem_nil, or_false] at hs
+      rcases hs with ((rfl | rfl | rfl) | hs) | rfl
+      · simp only [Step.tariff, compareCost]
+        have : width 0 = 1 := rfl
+        omega
+      · simp only [Step.tariff]; omega
+      · simp only [Step.tariff, addCost]
+        have : width 1 = 2 := rfl
+        omega
+      · exact (ih.tariff_le s hs).trans (by omega)
+      · exact hmul.trans (by omega)
+
+theorem binary_bounded (ta tb : Trace) (ca cb charge r : ℕ) (op : Step)
+    (ha : Bounded ta ca (16*(ca+r))) (hb : Bounded tb cb (16*(cb+r)))
+    (hop : op.tariff ≤ charge) :
+    Bounded (ta++tb++[op,.control]) (ca+cb+charge+1) (16*(ca+cb+charge+1+r)) := by
+  have h1 := ha.mono (le_refl _) (by omega : 16*(ca+r) ≤ 16*(ca+cb+charge+1+r))
+  have h2 := hb.mono (le_refl _) (by omega : 16*(cb+r) ≤ 16*(ca+cb+charge+1+r))
+  have h3 := bounded_pair op charge (16*(ca+cb+charge+1+r)) (by omega) (by omega)
+  simpa only [Nat.add_assoc] using (h1.append h2).append h3
+
+theorem exprTrace_bounded (env : List ℕ) (e : Expr) :
+    Bounded (exprTrace env e) (e.run env).cost (16*((e.run env).cost+listBits env)) := by
+  induction e with
+  | literal n =>
+    change Bounded _ (width n+1) (16*(width n+1+listBits env))
+    exact bounded_pair (.writeNat n) (width n) _ (by simp [Step.tariff]; omega) (by omega)
+  | read i =>
+    apply bounded_single _ _ _ (expr_cost_pos env (.read i))
+    change (Expr.read i |>.run env).cost ≤ _
+    omega
+  | add a b ha hb => exact binary_bounded _ _ _ _ _ _ _ ha hb (le_refl _)
+  | sub a b ha hb => exact binary_bounded _ _ _ _ _ _ _ ha hb (le_refl _)
+  | mul a b ha hb => exact binary_bounded _ _ _ _ _ _ _ ha hb (le_refl _)
+  | less a b ha hb => exact binary_bounded _ _ _ _ _ _ _ ha hb (le_refl _)
+  | equal a b ha hb => exact binary_bounded _ _ _ _ _ _ _ ha hb (le_refl _)
+  | power a b ha hb =>
+    let ca := (a.run env).cost
+    let cb := (b.run env).cost
+    let cp := (powerRun (a.run env).value (b.run env).value).cost
+    let B := 16*(ca+cb+cp+1+listBits env)
+    have h1 : Bounded (exprTrace env a) ca B := ha.mono (le_refl _) (by dsimp [B,ca,cb,cp]; omega)
+    have h2 : Bounded (exprTrace env b) cb B := hb.mono (le_refl _) (by dsimp [B,ca,cb,cp]; omega)
+    have h3 : Bounded (powerTrace (a.run env).value (b.run env).value) cp B :=
+      (powerTrace_bounded _ _).mono (le_refl _) (by dsimp [B,ca,cb,cp]; omega)
+    have h4 : Bounded [.control] 1 B := bounded_single _ _ _ (by decide) (by dsimp [Step.tariff,B]; omega)
+    exact ((h1.append h2).append h3).append h4
+  | odd a ha =>
+    have h1 := ha.mono (le_refl _) (by omega :
+      16*((a.run env).cost+listBits env) ≤ 16*((a.run env).cost+2+listBits env))
+    have h2 : Bounded [.odd (a.run env).value] 2 (16*((a.run env).cost+2+listBits env)) :=
+      bounded_single _ _ _ (by decide) (by simp only [Step.tariff]; omega)
+    exact h1.append h2
+
+theorem sum_map_mem_le {α : Type*} (xs : List α) (f : α → ℕ) {x : α} (hx : x ∈ xs) :
+    f x ≤ (xs.map f).sum := by
+  induction xs with
+  | nil => simp at hx
+  | cons y ys ih =>
+    simp only [List.mem_cons] at hx
+    simp only [List.map_cons, List.sum_cons]
+    rcases hx with rfl | hx
+    · omega
+    · have h := ih hx
+      omega
+
+def iterationCost (env : List ℕ) (p : Program) (i : ℕ) : ℕ :=
+  (p.run (i::env)).cost + (width i + addCost i 1 + 1) + outputBits (p.run (i::env)).output
+
+theorem loop_cost (env : List ℕ) (e : Expr) (p : Program) :
+    ((Program.loop e p).run env).cost = (e.run env).cost + 1 +
+      ((List.range (e.run env).value).map (iterationCost env p)).sum := by
+  simp only [Program.run, List.map_map, Function.comp_def]
+  rfl
+
+theorem programTrace_bounded (env : List ℕ) (p : Program) :
+    Bounded (programTrace env p) (p.run env).cost (16*((p.run env).cost+listBits env)) := by
+  induction p generalizing env with
+  | skip =>
+    apply bounded_single _ _ _ (by simp [Program.run])
+    change 1 ≤ 16*(1+listBits env)
+    omega
+  | emit s a b =>
+    let cs := (s.run env).cost
+    let ca := (a.run env).cost
+    let cb := (b.run env).cost
+    let entry : RationalCode := ⟨decide ((s.run env).value%2=1), (a.run env).value, (b.run env).value⟩
+    let B := 16*(cs+ca+cb+entry.bits+2+listBits env)
+    have hs : Bounded (exprTrace env s) cs B := (exprTrace_bounded env s).mono (le_refl _)
+      (by dsimp [B,cs,ca,cb]; omega)
+    have ha : Bounded (exprTrace env a) ca B := (exprTrace_bounded env a).mono (le_refl _)
+      (by dsimp [B,cs,ca,cb]; omega)
+    have hb : Bounded (exprTrace env b) cb B := (exprTrace_bounded env b).mono (le_refl _)
+      (by dsimp [B,cs,ca,cb]; omega)
+    have he : Bounded [.emit entry] (entry.bits+2) B := bounded_single _ _ _ (by omega)
+      (by dsimp [Step.tariff,B]; omega)
+    simpa [programTrace, Program.run, cs, ca, cb, entry, B, Nat.add_assoc] using
+      ((hs.append ha).append hb).append he
+  | sequence p q hp hq =>
+    let cp := (p.run env).cost
+    let cq := (q.run env).cost
+    let co := outputBits (p.run env).output
+    let B := 16*(cp+cq+co+1+listBits env)
+    have h1 : Bounded (programTrace env p) cp B := (hp env).mono (le_refl _)
+      (by dsimp [B,cp,cq,co]; omega)
+    have h2 : Bounded (programTrace env q) cq B := (hq env).mono (le_refl _)
+      (by dsimp [B,cp,cq,co]; omega)
+    have h3 : Bounded [.copy (p.run env).output,.control] (co+1) B := bounded_pair _ _ _
+      (by dsimp [B,cp,cq,co,Step.tariff]; omega) (by dsimp [B]; omega)
+    simpa [programTrace, Program.run, cp, cq, co, B, Nat.add_assoc] using (h1.append h2).append h3
+  | branch e p q hp hq =>
+    let selected := if (e.run env).value=0 then q else p
+    have hi : Bounded (programTrace env selected) (selected.run env).cost
+        (16*((selected.run env).cost+listBits env)) := by
+      dsimp [selected]
+      split <;> [exact hq env; exact hp env]
+    let ce := (e.run env).cost
+    let cp := (selected.run env).cost
+    let B := 16*(ce+cp+1+listBits env)
+    have he := exprTrace_bounded env e
+    have hw := expr_width_le env e
+    have hprefix : Bounded (exprTrace env e ++ [.equal (e.run env).value 0,.control])
+        (ce+1) B := by
+      constructor
+      · have hl := he.length_le
+        simp only [List.length_append, List.length_cons, List.length_nil]
+        dsimp [ce]
+        omega
+      · intro s hs
+        simp only [List.mem_append, List.mem_cons, List.not_mem_nil, or_false] at hs
+        rcases hs with hs | rfl | rfl
+        · exact (he.tariff_le s hs).trans (by dsimp [B,ce,cp]; omega)
+        · dsimp [Step.tariff,compareCost,B,ce,cp]
+          have : width 0 = 1 := rfl
+          omega
+        · dsimp [Step.tariff,B]; omega
+    have hbody : Bounded (programTrace env selected) cp B := hi.mono (le_refl _)
+      (by dsimp [B,ce,cp]; omega)
+    have hboth := hprefix.append hbody
+    by_cases h : (e.run env).value=0 <;>
+      simpa [programTrace,Program.run,selected,h,B,ce,cp,Nat.add_assoc,Nat.add_comm,Nat.add_left_comm] using hboth
+  | loop e p hp =>
+    let b := (e.run env).value
+    let ce := (e.run env).cost
+    let S := ((List.range b).map (iterationCost env p)).sum
+    let C := ce+1+S
+    let B := 16*(C+listBits env)
+    have hC : ((Program.loop e p).run env).cost = C := loop_cost env e p
+    have hCpos : 0 < C := by dsimp [C]; omega
+    have hw := expr_width_le env e
+    have hiter : ∀ i ∈ List.range b,
+        Bounded ([.equal i b,.writeNat i] ++ programTrace (i::env) p ++
+          [.add i 1,.copy (p.run (i::env)).output,.control]) (iterationCost env p i) B := by
+      intro i hi
+      have hic : iterationCost env p i ≤ S := sum_map_mem_le (List.range b) (iterationCost env p) hi
+      have hil : i < b := List.mem_range.mp hi
+      have hwi : width i ≤ width b := width_mono (Nat.le_of_lt hil)
+      have hbody := hp (i::env)
+      constructor
+      · have hl := hbody.length_le
+        have hpw := width_pos i
+        simp only [List.length_append,List.length_cons,List.length_nil]
+        dsimp [iterationCost,addCost]
+        have : width 1 = 2 := rfl
+        omega
+      · intro s hs
+        simp only [List.mem_append,List.mem_cons,List.not_mem_nil,or_false] at hs
+        rcases hs with ((rfl | rfl) | hs) | rfl | rfl | rfl
+        · dsimp [Step.tariff,compareCost,B,C,ce,b]
+          dsimp [b] at hwi
+          omega
+        · dsimp [Step.tariff,B,C]
+          dsimp [iterationCost] at hic
+          omega
+        · have hh := hbody.tariff_le s hs
+          change s.tariff ≤ 16*(C+listBits env)
+          change s.tariff ≤ 16*((p.run (i::env)).cost+(width i+listBits env)) at hh
+          dsimp [iterationCost] at hic
+          dsimp [C]
+          omega
+        · dsimp [Step.tariff,B,C]
+          dsimp [iterationCost] at hic
+          omega
+        · dsimp [Step.tariff,B,C]
+          dsimp [iterationCost] at hic
+          omega
+        · dsimp [Step.tariff,B]
+          omega
+    have hflat := bounded_flatMap (List.range b)
+      (fun i => [.equal i b,.writeNat i] ++ programTrace (i::env) p ++
+        [.add i 1,.copy (p.run (i::env)).output,.control]) (iterationCost env p) B hiter
+    have hbound : Bounded (exprTrace env e) ce B := (exprTrace_bounded env e).mono (le_refl _)
+      (by dsimp [B,C,ce]; omega)
+    have hlast : Bounded [.equal b b,.control] 1 B := by
+      apply bounded_pair (.equal b b) 0 B
+      · dsimp [Step.tariff,compareCost,B,C,b,ce]
+        omega
+      · dsimp [B]
+        omega
+    rw [hC]
+    simpa [programTrace,C,B,ce,S,b,Nat.add_assoc,Nat.add_comm,Nat.add_left_comm] using
+      (hbound.append hflat).append hlast
+
+def executionSteps (p : Program) (inputs : List ℕ) : ℕ :=
+  Trace.steps (.input inputs :: programTrace inputs p)
+
+theorem executionSteps_exec (p : Program) (inputs : List ℕ) :
+    Exec p inputs (BitModel.execute p inputs).output (executionSteps p inputs) :=
+  ⟨programTrace inputs p, programTrace_correct inputs p, rfl⟩
+
+theorem executionSteps_le (p : Program) (inputs : List ℕ) :
+    executionSteps p inputs ≤ 1024 * (BitModel.execute p inputs).cost^3 := by
+  let t := Step.input inputs :: programTrace inputs p
+  let C := (BitModel.execute p inputs).cost
+  have hp := programTrace_bounded inputs p
+  have hpos := program_cost_pos inputs p
+  have hl : t.length ≤ 3*C := by
+    have h := hp.length_le
+    dsimp [t,C,BitModel.execute]
+    omega
+  have ht : ∀ s ∈ t, s.steps ≤ (16*C)^2 := by
+    intro s hs
+    apply (Step.steps_le s).trans
+    apply Nat.pow_le_pow_left
+    simp only [t,List.mem_cons] at hs
+    rcases hs with rfl | hs
+    · change listBits inputs ≤ 16*C
+      dsimp [C,BitModel.execute]
+      omega
+    · simpa [C,BitModel.execute,Nat.add_comm] using hp.tariff_le s hs
+  change Trace.steps t ≤ 1024*C^3
+  calc
+    Trace.steps t ≤ t.length*(16*C)^2 :=
+      BitModel.sum_map_le_length_mul t Step.steps ((16*C)^2) ht
+    _ ≤ (3*C)*(16*C)^2 := Nat.mul_le_mul_right _ hl
+    _ ≤ 1024*C^3 := by ring_nf; omega
+
+theorem execute_refines (p : Program) (inputs : List ℕ) :
+    ∃ steps, Exec p inputs (BitModel.execute p inputs).output steps ∧
+      steps ≤ 1024 * (BitModel.execute p inputs).cost^3 :=
+  ⟨executionSteps p inputs, executionSteps_exec p inputs, executionSteps_le p inputs⟩
+
+end NCHitting.BitRefinement
+
+end OAI
diff --git a/lean/OAI/Algebra/FormulaHitting/DimensionBound.lean b/lean/OAI/Algebra/FormulaHitting/DimensionBound.lean
new file mode 100644
index 0000000000000000000000000000000000000000..faace53e96ce0be869324da2fd37448c10fdb024
--- /dev/null
+++ b/lean/OAI/Algebra/FormulaHitting/DimensionBound.lean
@@ -0,0 +1,43 @@
+import Mathlib.Data.Nat.Choose.Basic
+import Mathlib.Tactic.Ring
+import Lean.Elab.Tactic.Omega
+
+namespace OAI
+
+namespace NCHitting
+
+theorem choose_twice_add {s : ℕ} (hs : 0 < s) :
+    (2*s).choose 2 + s = 2*s^2 := by
+  rw [Nat.choose_two_right]
+  have he : (2*s)*(2*s-1) = (s*(2*s-1))*2 := by ring
+  rw [he, Nat.mul_div_left _ (by decide)]
+  calc
+    s*(2*s-1)+s = s*((2*s-1)+1) := by ring
+    _ = s*(2*s) := by rw [Nat.sub_add_cancel (by omega : 1 ≤ 2*s)]
+    _ = 2*s^2 := by ring
+
+theorem multiplicity_dimension_bound {n s m : ℕ}
+    (hn : 0 < n) (hs : 0 < s) (hm : m ≤ 2*s) :
+    (n-1)*m.choose 2 + m ≤ 2*n*s^2 := by
+  by_cases h1 : n = 1
+  · subst n
+    simp only [Nat.sub_self, zero_mul, zero_add, mul_one]
+    have hsq : s ≤ s*s := Nat.le_mul_of_pos_right s hs
+    calc
+      m ≤ 2*s := hm
+      _ ≤ 2*(s*s) := Nat.mul_le_mul_left 2 hsq
+      _ = 2*s^2 := by ring
+  · have hn2 : 2 ≤ n := by omega
+    have hc : m.choose 2 ≤ (2*s).choose 2 := Nat.choose_le_choose 2 hm
+    calc
+      (n-1)*m.choose 2 + m ≤ n*((2*s).choose 2)+2*s :=
+        Nat.add_le_add (Nat.mul_le_mul (Nat.sub_le _ _) hc) hm
+      _ ≤ n*((2*s).choose 2)+n*s :=
+        Nat.add_le_add_left (Nat.mul_le_mul_right s hn2) _
+      _ = n*((2*s).choose 2+s) := by ring
+      _ = n*(2*s^2) := by rw [choose_twice_add hs]
+      _ = 2*n*s^2 := by ring
+
+end NCHitting
+
+end OAI
diff --git a/lean/OAI/Algebra/FormulaHitting/Evaluation.lean b/lean/OAI/Algebra/FormulaHitting/Evaluation.lean
new file mode 100644
index 0000000000000000000000000000000000000000..37b05dce6284affbb4683ee95d11b01616e687ea
--- /dev/null
+++ b/lean/OAI/Algebra/FormulaHitting/Evaluation.lean
@@ -0,0 +1,168 @@
+import OAI.Algebra.FormulaHitting.Formula
+import Mathlib.Algebra.FreeMonoid.Basic
+import Mathlib.Algebra.MonoidAlgebra.Basic
+
+namespace OAI
+
+namespace NCHitting
+
+local instance {n : ℕ} : DecidableEq (FreeMonoid (Fin n)) :=
+  inferInstanceAs (DecidableEq (List (Fin n)))
+
+private def wordCuts {n : ℕ} (w : Word n) :
+    Finset (FreeMonoid (Fin n) × FreeMonoid (Fin n)) :=
+  (Finset.range (w.length + 1)).image fun k =>
+    (FreeMonoid.ofList (w.take k), FreeMonoid.ofList (w.drop k))
+
+private theorem mem_wordCuts {n : ℕ} (w : Word n)
+    (p : FreeMonoid (Fin n) × FreeMonoid (Fin n)) :
+    p ∈ wordCuts w ↔ p.1 * p.2 = FreeMonoid.ofList w := by
+  unfold wordCuts
+  constructor
+  · rintro h
+    obtain ⟨k, hk, rfl⟩ := Finset.mem_image.mp h
+    change w.take k ++ w.drop k = w
+    exact List.take_append_drop k w
+  · intro h
+    apply Finset.mem_image.mpr
+    have hp : p.1.toList ++ p.2.toList = w := h
+    refine ⟨p.1.toList.length, Finset.mem_range.mpr ?_, ?_⟩
+    · rw [← hp, List.length_append]
+      omega
+    · apply Prod.ext <;> apply FreeMonoid.toList.injective
+      · simp [← hp]
+      · simp [← hp]
+
+private theorem cuts_injective {n : ℕ} (w : Word n) :
+    Set.InjOn (fun k => (FreeMonoid.ofList (w.take k), FreeMonoid.ofList (w.drop k)))
+      (Finset.range (w.length + 1)) := by
+  intro k hk l hl h
+  have he := congrArg (fun p : FreeMonoid (Fin n) × FreeMonoid (Fin n) =>
+    p.1.toList.length) h
+  simp only [FreeMonoid.toList_ofList, List.length_take] at he
+  have hk' : k ≤ w.length := by simpa using Nat.le_of_lt_succ (Finset.mem_range.mp hk)
+  have hl' : l ≤ w.length := by simpa using Nat.le_of_lt_succ (Finset.mem_range.mp hl)
+  simpa [Nat.min_eq_left hk', Nat.min_eq_left hl'] using he
+
+theorem monoidAlgebra_coeff_mul {F : Type*} {n : ℕ} [Semiring F]
+    (f g : MonoidAlgebra F (FreeMonoid (Fin n))) (w : Word n) :
+    (f * g).coeff (FreeMonoid.ofList w) =
+      convolution (fun v => f.coeff (FreeMonoid.ofList v))
+        (fun v => g.coeff (FreeMonoid.ofList v)) w := by
+  rw [MonoidAlgebra.coeff_mul_antidiag f g _ (wordCuts w) (fun {_} => mem_wordCuts w _),
+    convolution_eq_sum]
+  exact Finset.sum_image (cuts_injective w)
+
+theorem sum_eq_sum_wordsOfLength {F M : Type*} {n d : ℕ}
+    [Zero F] [AddCommMonoid M] (p : Word n →₀ F)
+    (hcut : ∀ w, d ≤ w.length → p w = 0)
+    (h : Word n → F → M) (hzero : ∀ w, h w 0 = 0) :
+    p.sum h = ∑ k ∈ Finset.range d, ∑ w ∈ wordsOfLength n k, h w (p w) := by
+  classical
+  let S := (Finset.range d).biUnion (wordsOfLength n)
+  have hsupport : p.support ⊆ S := by
+    intro w hw
+    have hne : p w ≠ 0 := Finsupp.mem_support_iff.mp hw
+    have hlen : w.length < d := by
+      by_contra hn
+      exact hne (hcut w (by omega))
+    exact Finset.mem_biUnion.mpr ⟨w.length, Finset.mem_range.mpr hlen,
+      (mem_wordsOfLength w).mpr rfl⟩
+  rw [Finsupp.sum_of_support_subset p hsupport h (fun w _ => hzero w)]
+  apply Finset.sum_biUnion
+  intro k hk l hl hkl
+  apply Finset.disjoint_left.mpr
+  intro w hwk hwl
+  exact hkl (((mem_wordsOfLength w).mp hwk).symm.trans ((mem_wordsOfLength w).mp hwl))
+
+namespace Formula
+
+noncomputable def monoidPolynomial {F : Type*} {n : ℕ} [Semiring F] :
+    Formula F n → MonoidAlgebra F (FreeMonoid (Fin n))
+  | scalar a => MonoidAlgebra.single 1 a
+  | var i => MonoidAlgebra.single (FreeMonoid.of i) 1
+  | add f g => monoidPolynomial f + monoidPolynomial g
+  | mul f g => monoidPolynomial f * monoidPolynomial g
+
+@[simp] theorem monoidPolynomial_coeff {F : Type*} {n : ℕ} [Semiring F]
+    (f : Formula F n) (w : Word n) :
+    f.monoidPolynomial.coeff (FreeMonoid.ofList w) = f.coeff w := by
+  classical
+  induction f generalizing w with
+  | scalar a =>
+    simp only [monoidPolynomial, coeff, MonoidAlgebra.coeff_single, Finsupp.single_apply]
+    change (if ([] : Word n) = w then a else 0) = (if w = [] then a else 0)
+    simp [eq_comm]
+  | var i =>
+    simp only [monoidPolynomial, coeff, MonoidAlgebra.coeff_single, Finsupp.single_apply]
+    change (if [i] = w then 1 else 0) = (if w = [i] then 1 else (0 : F))
+    simp [eq_comm]
+  | add f g ihf ihg => simp [monoidPolynomial, coeff, ihf, ihg]
+  | mul f g ihf ihg =>
+    rw [monoidPolynomial, monoidAlgebra_coeff_mul]
+    simp only [ihf, ihg, coeff]
+
+theorem eval_eq_lift {F A : Type*} {n : ℕ} [CommSemiring F] [Semiring A]
+    [Algebra F A] (f : Formula F n) (T : Fin n → A) :
+    f.eval (algebraMap F A) T =
+      MonoidAlgebra.lift F A (FreeMonoid (Fin n)) (FreeMonoid.lift T) f.monoidPolynomial := by
+  induction f with
+  | scalar a => simp [eval, monoidPolynomial, Algebra.smul_def]
+  | var i => simp [eval, monoidPolynomial]
+  | add f g ihf ihg => simp [eval, monoidPolynomial, ihf, ihg]
+  | mul f g ihf ihg => simp [eval, monoidPolynomial, ihf, ihg]
+
+theorem eval_eq_sum {F A : Type*} {n : ℕ} [CommSemiring F] [Semiring A]
+    [Algebra F A] (f : Formula F n) (T : Fin n → A) :
+    f.eval (algebraMap F A) T =
+      f.polynomial.sum (fun w a => algebraMap F A a * (w.map T).prod) := by
+  rw [eval_eq_lift, MonoidAlgebra.lift_apply']
+  have hcoeff : f.monoidPolynomial.coeff = f.polynomial := by
+    ext w
+    exact monoidPolynomial_coeff f w
+  rw [hcoeff]
+  apply Finset.sum_congr rfl
+  intro w hw
+  change algebraMap F A (f.coeff w) * FreeMonoid.lift T w =
+    algebraMap F A (f.coeff w) * (w.toList.map T).prod
+  rw [FreeMonoid.lift_apply]
+
+theorem eval_eq_sum_of_cutoff {F A : Type*} {n d : ℕ}
+    [CommSemiring F] [Semiring A] [Algebra F A]
+    (f : Formula F n) (T : Fin n → A)
+    (hcut : ∀ w, d ≤ w.length → f.coeff w = 0) :
+    f.eval (algebraMap F A) T =
+      ∑ k ∈ Finset.range d, ∑ w ∈ wordsOfLength n k,
+        algebraMap F A (f.coeff w) * (w.map T).prod := by
+  rw [eval_eq_sum]
+  exact sum_eq_sum_wordsOfLength f.polynomial hcut _ (by intro w; simp)
+
+theorem eval_eq_sum_wordsOfLength {F A : Type*} {n s : ℕ}
+    [CommSemiring F] [Semiring A] [Algebra F A]
+    (f : Formula F n) (T : Fin n → A) (hs : f.size ≤ s) :
+    f.eval (algebraMap F A) T =
+      ∑ k ∈ Finset.range (s + 1), ∑ w ∈ wordsOfLength n k,
+        algebraMap F A (f.coeff w) * (w.map T).prod := by
+  classical
+  rw [eval_eq_sum]
+  let S := (Finset.range (s + 1)).biUnion (wordsOfLength n)
+  have hsupport : f.polynomial.support ⊆ S := by
+    intro w hw
+    have hne : f.coeff w ≠ 0 := Finsupp.mem_support_iff.mp hw
+    have hlen : w.length ≤ s := by
+      by_contra h
+      exact hne (f.coeff_eq_zero_of_length_gt w (by omega))
+    exact Finset.mem_biUnion.mpr ⟨w.length, Finset.mem_range.mpr (by omega),
+      (mem_wordsOfLength w).mpr rfl⟩
+  rw [Finsupp.sum_of_support_subset f.polynomial hsupport _ (by intros; simp)]
+  change (∑ w ∈ S, algebraMap F A (f.coeff w) * (w.map T).prod) = _
+  apply Finset.sum_biUnion
+  intro k hk l hl hkl
+  apply Finset.disjoint_left.mpr
+  intro w hwk hwl
+  exact hkl (((mem_wordsOfLength w).mp hwk).symm.trans ((mem_wordsOfLength w).mp hwl))
+
+end Formula
+end NCHitting
+
+end OAI
diff --git a/lean/OAI/Algebra/FormulaHitting/Formula.lean b/lean/OAI/Algebra/FormulaHitting/Formula.lean
new file mode 100644
index 0000000000000000000000000000000000000000..1f0590d8c3e656d9abc829c5d55889691ad990c7
--- /dev/null
+++ b/lean/OAI/Algebra/FormulaHitting/Formula.lean
@@ -0,0 +1,147 @@
+import OAI.Algebra.FormulaHitting.Model
+import Mathlib.Data.Finsupp.Basic
+import Mathlib.Algebra.BigOperators.Group.Finset.Basic
+import Mathlib.Data.Finset.Lattice.Fold
+import Lean.Elab.Tactic.Omega
+
+namespace OAI
+
+namespace NCHitting
+
+theorem convolution_eq_sum {F : Type*} {n : ℕ} [Semiring F]
+    (f g : WordSeries F n) (w : Word n) :
+    convolution f g w =
+      ∑ k ∈ Finset.range (w.length + 1), f (w.take k) * g (w.drop k) := by
+  induction w generalizing f with
+  | nil => simp [convolution]
+  | cons i w ih =>
+    rw [List.length_cons, Finset.sum_range_succ']
+    simp only [List.take_zero, List.drop_zero, List.take_succ_cons,
+      List.drop_succ_cons]
+    rw [convolution, ih]
+    exact add_comm _ _
+
+namespace Formula
+
+theorem size_pos {F : Type*} {n : ℕ} (f : Formula F n) : 0 < f.size := by
+  cases f <;> simp [size]
+
+theorem size_le_one_iff {F : Type*} {n : ℕ} (f : Formula F n) :
+    f.size ≤ 1 ↔ (∃ a, f = scalar a) ∨ (∃ i, f = var i) := by
+  cases f with
+  | scalar a => simp [size]
+  | var i => simp [size]
+  | add f g =>
+    have hf := size_pos f
+    have hg := size_pos g
+    constructor
+    · intro h
+      simp only [size] at h
+      omega
+    · rintro (⟨a, h⟩ | ⟨i, h⟩) <;> cases h
+  | mul f g =>
+    have hf := size_pos f
+    have hg := size_pos g
+    constructor
+    · intro h
+      simp only [size] at h
+      omega
+    · rintro (⟨a, h⟩ | ⟨i, h⟩) <;> cases h
+
+theorem eval_one_ne_zero_of_size_le_one {F : Type*} {n : ℕ}
+    [Semiring F] [Nontrivial F] (f : Formula F n) (hs : f.size ≤ 1)
+    (hf : f.coeff ≠ 0) : f.eval id (fun _ => 1) ≠ 0 := by
+  rcases (size_le_one_iff f).mp hs with ⟨a, rfl⟩ | ⟨i, rfl⟩
+  · intro ha
+    apply hf
+    funext w
+    simp only [eval, id_eq] at ha
+    simp [coeff, ha]
+  · simp [eval]
+
+theorem coeff_eq_zero_of_length_gt {F : Type*} {n : ℕ} [Semiring F]
+    (f : Formula F n) (w : Word n) (hw : f.size < w.length) :
+    f.coeff w = 0 := by
+  induction f generalizing w with
+  | scalar a =>
+    simp only [size] at hw
+    have : w ≠ [] := by intro h; simp [h] at hw
+    simp [coeff, this]
+  | var i =>
+    simp only [size] at hw
+    have : w ≠ [i] := by intro h; simp [h] at hw
+    simp [coeff, this]
+  | add f g ihf ihg =>
+    simp only [size] at hw
+    have hf : f.size < w.length := by omega
+    have hg : g.size < w.length := by omega
+    simp [coeff, ihf w hf, ihg w hg]
+  | mul f g ihf ihg =>
+    simp only [size] at hw
+    rw [coeff, convolution_eq_sum]
+    apply Finset.sum_eq_zero
+    intro k hk
+    have hk' : k ≤ w.length := by
+      have hk'' := Finset.mem_range.mp hk
+      omega
+    by_cases hf : f.size < (w.take k).length
+    · rw [ihf _ hf, zero_mul]
+    · have hg : g.size < (w.drop k).length := by
+        simp only [List.length_take, List.length_drop, Nat.min_eq_left hk'] at hf ⊢
+        omega
+      rw [ihg _ hg, mul_zero]
+
+end Formula
+
+def wordsOfLength (n : ℕ) : ℕ → Finset (Word n)
+  | 0 => {[]}
+  | k + 1 => Finset.univ.biUnion fun i => (wordsOfLength n k).image (List.cons i)
+
+theorem mem_wordsOfLength {n k : ℕ} (w : Word n) :
+    w ∈ wordsOfLength n k ↔ w.length = k := by
+  induction k generalizing w with
+  | zero => simp [wordsOfLength]
+  | succ k ih =>
+    cases w with
+    | nil => simp [wordsOfLength]
+    | cons i w => simp [wordsOfLength, ih]
+
+theorem sum_wordsOfLength_succ {M : Type*} [AddCommMonoid M]
+    {n : ℕ} (k : ℕ) (f : Word n → M) :
+    (∑ w ∈ wordsOfLength n (k + 1), f w) =
+      ∑ i : Fin n, ∑ w ∈ wordsOfLength n k, f (i :: w) := by
+  rw [wordsOfLength, Finset.sum_biUnion]
+  · apply Finset.sum_congr rfl
+    intro i _
+    exact Finset.sum_image (by
+      intro a _ b _ h
+      exact (List.cons.inj h).2)
+  · intro i _ j _ hij
+    apply Finset.disjoint_left.mpr
+    intro w hi hj
+    rcases Finset.mem_image.mp hi with ⟨v, _, hv⟩
+    rcases Finset.mem_image.mp hj with ⟨v', _, hv'⟩
+    exact hij (List.cons.inj (hv.trans hv'.symm)).1
+
+theorem Formula.coeff_support_finite {F : Type*} {n : ℕ} [Semiring F]
+    (f : Formula F n) : (Function.support f.coeff).Finite := by
+  classical
+  let bound := (Finset.range (f.size + 1)).biUnion (wordsOfLength n)
+  apply Set.Finite.subset bound.finite_toSet
+  intro w hw
+  have hlen : w.length ≤ f.size := by
+    by_contra h
+    exact hw (f.coeff_eq_zero_of_length_gt w (by omega))
+  exact Finset.mem_biUnion.mpr ⟨w.length, Finset.mem_range.mpr (by omega),
+    (mem_wordsOfLength w).mpr rfl⟩
+
+noncomputable def Formula.polynomial {F : Type*} {n : ℕ} [Semiring F]
+    (f : Formula F n) : Word n →₀ F :=
+  Finsupp.ofSupportFinite f.coeff f.coeff_support_finite
+
+@[simp] theorem Formula.polynomial_apply {F : Type*} {n : ℕ} [Semiring F]
+    (f : Formula F n) (w : Word n) : f.polynomial w = f.coeff w := rfl
+
+end NCHitting
+
+end OAI
diff --git a/lean/OAI/Algebra/FormulaHitting/FormulaBridge.lean b/lean/OAI/Algebra/FormulaHitting/FormulaBridge.lean
new file mode 100644
index 0000000000000000000000000000000000000000..02cdd9ebd5a77019cdf4489c9c39d898ad915180
--- /dev/null
+++ b/lean/OAI/Algebra/FormulaHitting/FormulaBridge.lean
@@ -0,0 +1,40 @@
+import OAI.Algebra.FormulaHitting.Specification
+import OAI.Algebra.FormulaHitting.Formula
+
+namespace OAI
+
+namespace NCHittingSpecification
+
+namespace Formula
+
+def toImplementation {F : Type*} {n : ℕ} : Formula F n → NCHitting.Formula F n
+  | .scalar a => .scalar a
+  | .variable i => .var i
+  | .add f g => .add (toImplementation f) (toImplementation g)
+  | .multiply f g => .mul (toImplementation f) (toImplementation g)
+
+@[simp] theorem toImplementation_size {F : Type*} {n : ℕ} (f : Formula F n) :
+    f.toImplementation.size = f.gates := by
+  induction f <;> simp_all [toImplementation, gates, NCHitting.Formula.size]
+
+@[simp] theorem toImplementation_coeff {F : Type*} {n : ℕ} [Semiring F]
+    (f : Formula F n) (w : List (Fin n)) :
+    f.toImplementation.coeff w = f.coefficient w := by
+  induction f generalizing w with
+  | scalar a => rfl
+  | «variable» i => rfl
+  | add f g hf hg => simp [toImplementation, NCHitting.Formula.coeff, coefficient, hf, hg]
+  | multiply f g hf hg =>
+    simp [toImplementation, NCHitting.Formula.coeff, coefficient,
+      NCHitting.convolution_eq_sum, hf, hg]
+
+@[simp] theorem toImplementation_eval {F : Type*} {n d : ℕ} [Field F]
+    (f : Formula F n) (T : Fin n → Matrix (Fin d) (Fin d) F) :
+    f.toImplementation.eval (Matrix.scalar (Fin d)) T = f.evaluate T := by
+  induction f <;> simp_all [toImplementation, NCHitting.Formula.eval, evaluate]
+
+end Formula
+
+end NCHittingSpecification
+
+end OAI
diff --git a/lean/OAI/Algebra/FormulaHitting/FormulaSeries.lean b/lean/OAI/Algebra/FormulaHitting/FormulaSeries.lean
new file mode 100644
index 0000000000000000000000000000000000000000..e6d1cf464d9637a1405c160d1b0a992f8b5fd710
--- /dev/null
+++ b/lean/OAI/Algebra/FormulaHitting/FormulaSeries.lean
@@ -0,0 +1,37 @@
+import OAI.Algebra.FormulaHitting.Evaluation
+import OAI.Algebra.FormulaHitting.Series
+
+namespace OAI
+
+noncomputable section
+namespace NCHitting
+namespace Formula
+
+variable {F : Type*} {n : ℕ} [Field F]
+
+def series (f : Formula F n) : PowerSeries F :=
+  f.polynomial.sum (fun w a => PowerSeries.C a * wordSeries w)
+
+theorem series_eq_smul_sum (f : Formula F n) :
+    f.series = f.polynomial.sum (fun w a => a • wordSeries w) := by
+  simp only [series, PowerSeries.smul_eq_C_mul]
+
+theorem series_eq_sum_of_cutoff (f : Formula F n) (d : ℕ)
+    (hcut : ∀ w, d ≤ w.length → f.coeff w = 0) :
+    f.series = ∑ k ∈ Finset.range d, ∑ w ∈ wordsOfLength n k,
+      PowerSeries.C (f.coeff w) * wordSeries w := by
+  exact sum_eq_sum_wordsOfLength f.polynomial hcut _ (by intro w; simp)
+
+theorem series_eq_sum_wordsOfLength (f : Formula F n) {s : ℕ} (hs : f.size ≤ s) :
+    f.series = ∑ k ∈ Finset.range (s + 1), ∑ w ∈ wordsOfLength n k,
+      PowerSeries.C (f.coeff w) * wordSeries w := by
+  apply f.series_eq_sum_of_cutoff
+  intro w hw
+  exact f.coeff_eq_zero_of_length_gt w (by omega)
+
+end Formula
+end NCHitting
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/FormulaHitting/Generator.lean b/lean/OAI/Algebra/FormulaHitting/Generator.lean
new file mode 100644
index 0000000000000000000000000000000000000000..7444aaf8daf4a4606ecbf82adfe15ff988ce9820
--- /dev/null
+++ b/lean/OAI/Algebra/FormulaHitting/Generator.lean
@@ -0,0 +1,94 @@
+import OAI.Algebra.FormulaHitting.Model
+import Mathlib.Data.Matrix.Basic
+import Mathlib.Data.Rat.Defs
+import Mathlib.Data.Nat.Size
+import Mathlib.Tactic.NormNum
+import Mathlib.Tactic.Positivity
+
+namespace OAI
+
+namespace NCHitting
+
+theorem dimension_pos {n s : ℕ} (hn : 0 < n) (hs : 0 < s) :
+    0 < dimension n s := by
+  unfold dimension
+  split_ifs <;> positivity
+
+theorem dimension_le {n s : ℕ} (hn : 0 < n) (hs : 0 < s) :
+    dimension n s ≤ 2 * n * s ^ 2 := by
+  unfold dimension
+  split_ifs with h
+  · rcases h with ⟨rfl, rfl⟩
+    norm_num
+  · exact le_rfl
+
+theorem dimension_eq {n s : ℕ} (hns : 2 ≤ n * s) :
+    dimension n s = 2 * n * s ^ 2 := by
+  unfold dimension
+  split_ifs with h
+  · rcases h with ⟨rfl, rfl⟩
+    norm_num at hns
+  · rfl
+
+@[simp] theorem dimension_one : dimension 1 1 = 1 := by decide
+
+theorem generator_one (i : Fin 1) (r q : Fin (dimension 1 1)) :
+    generator 1 1 i r q = 1 := by simp [generator]
+
+theorem generator_entry {n s : ℕ} (hns : 2 ≤ n * s)
+    (i : Fin n) (r q : Fin (dimension n s)) :
+    generator n s i r q = matrixEntry (i.val + 1) r.val q.val := by
+  have h : ¬(n = 1 ∧ s = 1) := by rintro ⟨rfl, rfl⟩; norm_num at hns
+  simp [generator, h]
+
+theorem matrixEntry_of_lt {i r q : ℕ} (h : q < r) :
+    matrixEntry i r q = (-1 : ℚ) ^ (r - q - 1) / ((r : ℚ) * i ^ (r - q)) := by
+  simp [matrixEntry, h]
+
+theorem matrixEntry_of_le {i r q : ℕ} (h : r ≤ q) :
+    matrixEntry i r q = 0 := by simp [matrixEntry, Nat.not_lt.mpr h]
+
+def entryBitBound (n d : ℕ) : ℕ := 3 + d.size + d * n.size
+
+theorem size_mul_le (a b : ℕ) : (a * b).size ≤ a.size + b.size := by
+  apply Nat.size_le.mpr
+  rw [pow_add]
+  exact Nat.mul_lt_mul_of_lt_of_lt (Nat.lt_size_self a) (Nat.lt_size_self b)
+
+theorem size_pow_le (a k : ℕ) : (a ^ k).size ≤ 1 + k * a.size := by
+  induction k with
+  | zero => simp
+  | succ k ih =>
+    calc
+      (a ^ (k + 1)).size = (a ^ k * a).size := by rw [pow_succ]
+      _ ≤ (a ^ k).size + a.size := size_mul_le _ _
+      _ ≤ 1 + (k + 1) * a.size := by rw [Nat.add_mul]; omega
+
+theorem denominator_pos {i r q : ℕ} (hi : 0 < i) (hq : q < r) :
+    0 < r * i ^ (r - q) := Nat.mul_pos (by omega) (pow_pos hi _)
+
+theorem denominator_size_le {n d i r q : ℕ}
+    (hi : i ≤ n) (hr : r < d) :
+    (r * i ^ (r - q)).size ≤ entryBitBound n d := by
+  have hs := Nat.size_le_size hi
+  have ht := Nat.size_le_size (Nat.le_of_lt hr)
+  have hk : r - q ≤ d := by omega
+  calc
+    (r * i ^ (r - q)).size ≤ r.size + (i ^ (r - q)).size := size_mul_le _ _
+    _ ≤ r.size + (1 + (r - q) * i.size) := Nat.add_le_add_left (size_pow_le _ _) _
+    _ ≤ entryBitBound n d := by
+      have hm := Nat.mul_le_mul hk hs
+      unfold entryBitBound
+      omega
+
+theorem size_le_self (a : ℕ) : a.size ≤ a := by
+  apply Nat.size_le.mpr
+  exact Nat.lt_two_pow_self
+
+theorem entryBitBound_le (n d : ℕ) : entryBitBound n d ≤ 3 + d + d * n := by
+  unfold entryBitBound
+  exact Nat.add_le_add (Nat.add_le_add_left (size_le_self _) _) (Nat.mul_le_mul_left _ (size_le_self _))
+
+end NCHitting
+
+end OAI
diff --git a/lean/OAI/Algebra/FormulaHitting/GeneratorBridge.lean b/lean/OAI/Algebra/FormulaHitting/GeneratorBridge.lean
new file mode 100644
index 0000000000000000000000000000000000000000..baefbc5f732a9eb3f52d99430cf8bd9794a7ceb7
--- /dev/null
+++ b/lean/OAI/Algebra/FormulaHitting/GeneratorBridge.lean
@@ -0,0 +1,47 @@
+import OAI.Algebra.FormulaHitting.Specification
+import OAI.Algebra.FormulaHitting.Program
+import OAI.Algebra.FormulaHitting.GeneratorCost
+import OAI.Algebra.FormulaHitting.OutputBounds
+import OAI.Algebra.FormulaHitting.BitCost
+
+namespace OAI
+
+namespace NCHittingSpecification
+
+universe u
+
+theorem dimension_eq (n s : ℕ) : dimension n s = NCHitting.dimension n s := rfl
+
+theorem expectedEntry_eq (n s : ℕ) : expectedEntry n s = NCHitting.generator n s := rfl
+
+theorem expectedProgram_eq : expectedProgram = NCHitting.generatorProgram := rfl
+
+theorem execute_expectedProgram_eq (n s : ℕ) :
+    NCHitting.BitModel.execute expectedProgram [n, s] = NCHitting.generate n s := rfl
+
+theorem expectedOutput_eq (n s : ℕ) : expectedOutput n s = NCHitting.encodedOutput n s := rfl
+
+theorem decode_eq : decode = NCHitting.decode := rfl
+
+theorem entryBitBound_eq (n d : ℕ) : entryBitBound n d = NCHitting.entryBitBound n d := rfl
+
+theorem costBound_eq (n s : ℕ) : costBound n s = NCHitting.generatorCostBound n s := rfl
+
+theorem primitiveBitBound_eq (n s : ℕ) :
+    primitiveBitBound n s = NCHitting.primitiveBitBound n s := rfl
+
+theorem completeClaim_of_hitting {n s : ℕ} (hn : 1 ≤ n) (hs : 1 ≤ s)
+    (hitting : UniversalHitting.{u} n s (dimension n s) (expectedEntry n s)) :
+    CompleteClaim.{u} n s := by
+  refine ⟨NCHitting.dimension_pos hn hs, NCHitting.dimension_le hn hs, ?_, ?_, ?_, ?_, ?_,
+    ?_, hitting⟩
+  · exact NCHitting.generate_output n s
+  · exact NCHitting.generate_output_length n s
+  · exact NCHitting.generate_entry_bounds
+  · exact NCHitting.generate_entry_decode n s
+  · exact NCHitting.generate_cost_le n s
+  · exact NCHitting.generate_primitive_bit_bound n s
+
+end NCHittingSpecification
+
+end OAI
diff --git a/lean/OAI/Algebra/FormulaHitting/GeneratorCost.lean b/lean/OAI/Algebra/FormulaHitting/GeneratorCost.lean
new file mode 100644
index 0000000000000000000000000000000000000000..bebf9f47bed3f6944151a4877f17cfe5f4c79bd1
--- /dev/null
+++ b/lean/OAI/Algebra/FormulaHitting/GeneratorCost.lean
@@ -0,0 +1,344 @@
+import OAI.Algebra.FormulaHitting.Program
+import OAI.Algebra.FormulaHitting.ProgramCost
+
+namespace OAI
+
+namespace NCHitting
+
+open BitModel
+
+def generatorExpressionBudget (M : ℕ) : ℕ :=
+  expressionBudget M (intermediateWidthBound M) (registerReadBound M)
+
+def entryCostBound (M : ℕ) : ℕ :=
+  20 * generatorExpressionBudget M + intermediateWidthBound M + 20
+
+def entryOutputBound (M : ℕ) : ℕ := intermediateWidthBound M + 3
+
+private theorem bounded_dimensionExpr {environment : List ℕ} {M nr sr n s : ℕ}
+    (hM : 2 ≤ M) (hlen : environment.length ≤ 5)
+    (henv : ∀ a ∈ environment, a ≤ M) (hnr : nr ≤ 4) (hsr : sr ≤ 4)
+    (hnread : environment[nr]?.getD 0 = n) (hsread : environment[sr]?.getD 0 = s)
+    (hn : n ≤ M) (hs : s ≤ M) :
+    (dimensionExpr nr sr).Bounded environment M
+      (intermediateWidthBound M) (registerReadBound M) := by
+  have htwo := Expr.bounded_literal (environment := environment) hM
+  have hnvar := Expr.bounded_read hlen hnr henv
+  have hsvar := Expr.bounded_read hlen hsr henv
+  have hsn : s.size ≤ M := (size_le_self s).trans hs
+  have hwn : width n ≤ M + 1 := width_le_of_le hn
+  have hws2 : width (s ^ 2) ≤ 2 + 2 * M := by
+    have h := width_pow_le s 2
+    omega
+  have hw2n : width (2 * n) ≤ M + 4 := by
+    have h := width_mul_le 2 n
+    have ht : width 2 = 3 := rfl
+    omega
+  have hp : (Expr.power (.read sr) (.literal 2)).Bounded environment M
+      (intermediateWidthBound M) (registerReadBound M) := by
+    refine ⟨?_, hsvar, htwo, ?_, ?_⟩
+    · simp only [Expr.run, powerRun_value, hsread]
+      unfold intermediateWidthBound
+      omega
+    · simpa only [Expr.run, hsread] using hs
+    · exact hM
+  have hleft : (Expr.mul (.literal 2) (.read nr)).Bounded environment M
+      (intermediateWidthBound M) (registerReadBound M) := by
+    refine ⟨?_, htwo, hnvar⟩
+    simp only [Expr.run, hnread]
+    unfold intermediateWidthBound
+    omega
+  refine ⟨?_, hleft, hp⟩
+  have hw := width_mul_le (2 * n) (s ^ 2)
+  simp only [Expr.run, powerRun_value, hnread, hsread]
+  unfold intermediateWidthBound
+  omega
+
+theorem dimensionExpr_cost_le {environment : List ℕ} {M nr sr n s : ℕ}
+    (hM : 2 ≤ M) (hlen : environment.length ≤ 5)
+    (henv : ∀ a ∈ environment, a ≤ M) (hnr : nr ≤ 4) (hsr : sr ≤ 4)
+    (hnread : environment[nr]?.getD 0 = n) (hsread : environment[sr]?.getD 0 = s)
+    (hn : n ≤ M) (hs : s ≤ M) :
+    ((dimensionExpr nr sr).run environment).cost ≤ 7 * generatorExpressionBudget M := by
+  have h := Expr.cost_le_nodes_budget environment M (intermediateWidthBound M)
+    (registerReadBound M) (dimensionExpr nr sr)
+    (bounded_dimensionExpr hM hlen henv hnr hsr hnread hsread hn hs)
+  simpa [dimensionExpr, Expr.nodes, generatorExpressionBudget] using h
+
+private theorem bounded_entryExpressions {M q r i n s : ℕ}
+    (hM : 2 ≤ M) (hq : q ≤ M) (hr : r ≤ M) (hi : i + 1 ≤ M)
+    (hn : n ≤ M) (hs : s ≤ M) :
+    let environment := [q, r, i, n, s]
+    let bounded := fun e : Expr => e.Bounded environment M
+      (intermediateWidthBound M) (registerReadBound M)
+    bounded (.less (.read 0) (.read 1)) ∧
+    bounded (.odd (.sub (.sub (.read 1) (.read 0)) (.literal 1))) ∧
+    bounded (.mul (.read 1) (.power (.add (.read 2) (.literal 1))
+      (.sub (.read 1) (.read 0)))) := by
+  dsimp only
+  have henv : ∀ a ∈ [q, r, i, n, s], a ≤ M := by
+    intro a ha
+    simp only [List.mem_cons, List.not_mem_nil, or_false] at ha
+    rcases ha with rfl | rfl | rfl | rfl | rfl <;> omega
+  have hqv := Expr.bounded_read (environment := [q, r, i, n, s])
+    (index := 0) (by simp) (by omega) henv
+  have hrv := Expr.bounded_read (environment := [q, r, i, n, s])
+    (index := 1) (by simp) (by omega) henv
+  have hiv := Expr.bounded_read (environment := [q, r, i, n, s])
+    (index := 2) (by simp) (by omega) henv
+  have hone := Expr.bounded_literal (environment := [q, r, i, n, s])
+    (a := 1) (by omega : 1 ≤ M)
+  have hsub : (Expr.sub (.read 1) (.read 0)).Bounded [q, r, i, n, s] M
+      (intermediateWidthBound M) (registerReadBound M) := by
+    refine ⟨?_, hrv, hqv⟩
+    simpa [Expr.run] using small_width (by omega : r - q ≤ M)
+  have hsubone : (Expr.sub (.sub (.read 1) (.read 0)) (.literal 1)).Bounded
+      [q, r, i, n, s] M (intermediateWidthBound M) (registerReadBound M) := by
+    refine ⟨?_, hsub, hone⟩
+    simpa [Expr.run] using small_width (by omega : r - q - 1 ≤ M)
+  have hadd : (Expr.add (.read 2) (.literal 1)).Bounded [q, r, i, n, s] M
+      (intermediateWidthBound M) (registerReadBound M) := by
+    refine ⟨?_, hiv, hone⟩
+    simpa [Expr.run] using small_width hi
+  have hpwidth : width ((i + 1) ^ (r - q)) ≤ 2 + M * M := by
+    have h := width_pow_le (i + 1) (r - q)
+    have hsiz : (i + 1).size ≤ M := (size_le_self (i + 1)).trans hi
+    have hm := Nat.mul_le_mul (by omega : r - q ≤ M) hsiz
+    omega
+  have hp : (Expr.power (.add (.read 2) (.literal 1))
+      (.sub (.read 1) (.read 0))).Bounded [q, r, i, n, s] M
+      (intermediateWidthBound M) (registerReadBound M) := by
+    refine ⟨?_, hadd, hsub, ?_, ?_⟩
+    · simp only [Expr.run, List.getElem?_cons_zero, List.getElem?_cons_succ,
+        Option.getD_some, powerRun_value]
+      unfold intermediateWidthBound
+      omega
+    · simpa [Expr.run] using hi
+    · simpa [Expr.run] using (by omega : r - q ≤ M)
+  refine ⟨?_, ?_, ?_⟩
+  · refine ⟨?_, hqv, hrv⟩
+    have hw : width (if q < r then (1 : ℕ) else 0) ≤ 2 := by
+      by_cases hqr : q < r <;> simp [hqr, width]
+    have hb : 2 ≤ intermediateWidthBound M := by unfold intermediateWidthBound; omega
+    simpa [Expr.run] using hw.trans hb
+  · refine ⟨?_, hsubone⟩
+    simpa [Expr.run] using
+      small_width (by have := Nat.mod_lt (r - q - 1) (by decide : 0 < 2); omega :
+        (r - q - 1) % 2 ≤ M)
+  · refine ⟨?_, hrv, hp⟩
+    have hw := width_mul_le r ((i + 1) ^ (r - q))
+    have hrw := width_le_of_le hr
+    simp only [Expr.run, List.getElem?_cons_zero, List.getElem?_cons_succ,
+      Option.getD_some, powerRun_value]
+    unfold intermediateWidthBound
+    omega
+
+theorem entryProgram_bounds {M q r i n s : ℕ}
+    (hM : 2 ≤ M) (hq : q ≤ M) (hr : r ≤ M) (hi : i + 1 ≤ M)
+    (hn : n ≤ M) (hs : s ≤ M) :
+    (entryProgram.run [q, r, i, n, s]).cost ≤ entryCostBound M ∧
+      outputBits (entryProgram.run [q, r, i, n, s]).output ≤ entryOutputBound M := by
+  let environment := [q, r, i, n, s]
+  let condition : Expr := .less (.read 0) (.read 1)
+  let sign : Expr := .odd (.sub (.sub (.read 1) (.read 0)) (.literal 1))
+  let denominator : Expr := .mul (.read 1) (.power (.add (.read 2) (.literal 1))
+    (.sub (.read 1) (.read 0)))
+  let positive : Program := .emit sign (.literal 1) denominator
+  let zero : Program := .emit (.literal 0) (.literal 0) (.literal 1)
+  let E := generatorExpressionBudget M
+  let B := intermediateWidthBound M
+  have hE : 10 ≤ E := by unfold E generatorExpressionBudget expressionBudget; omega
+  have hB : 1 ≤ B := by unfold B intermediateWidthBound; omega
+  obtain ⟨hcondition, hsign, hdenominator⟩ := bounded_entryExpressions hM hq hr hi hn hs
+  have hc : (condition.run environment).cost ≤ 3 * E := by
+    have h := Expr.cost_le_nodes_budget environment M B (registerReadBound M) condition hcondition
+    simpa [condition, Expr.nodes, E, B, generatorExpressionBudget] using h
+  have hsc : (sign.run environment).cost ≤ 6 * E := by
+    have h := Expr.cost_le_nodes_budget environment M B (registerReadBound M) sign hsign
+    simpa [sign, Expr.nodes, E, B, generatorExpressionBudget] using h
+  have hdc : (denominator.run environment).cost ≤ 9 * E := by
+    have h := Expr.cost_le_nodes_budget environment M B (registerReadBound M) denominator hdenominator
+    simpa [denominator, Expr.nodes, E, B, generatorExpressionBudget] using h
+  have hdw : width (denominator.run environment).value ≤ B :=
+    Expr.bounded_width hdenominator
+  have hlc : ((Expr.literal 1).run environment).cost ≤ E := by
+    change 3 ≤ E
+    omega
+  have hlw : width ((Expr.literal 1).run environment).value ≤ 2 := by
+    simp [Expr.run, width]
+  have hpc : (positive.run environment).cost ≤ 17 * E + B + 10 := by
+    have h := emit_cost_le environment sign (.literal 1) denominator
+      (6 * E) E (9 * E) 2 B hsc hlc hdc hlw hdw
+    change (positive.run environment).cost ≤ _ at h
+    omega
+  have hpo : outputBits (positive.run environment).output ≤ B + 3 := by
+    have h := emit_outputBits_le environment sign (.literal 1) denominator 2 B hlw hdw
+    simpa [positive, Nat.add_comm, Nat.add_left_comm, Nat.add_assoc] using h
+  have hzc : (zero.run environment).cost ≤ 17 * E + B + 10 := by
+    simp only [zero, Program.run, Expr.run, RationalCode.bits, width, Nat.size_zero, Nat.size_one]
+    omega
+  have hzo : outputBits (zero.run environment).output ≤ B + 3 := by
+    simp only [zero, Program.run, Expr.run, outputBits, List.map_cons, List.map_nil,
+      List.sum_cons, List.sum_nil, RationalCode.bits, width, Nat.size_zero, Nat.size_one]
+    omega
+  have hcost := branch_cost_le environment condition positive zero (3 * E)
+    (17 * E + B + 10) hc hpc hzc
+  have houtput := branch_outputBits_le environment condition positive zero (B + 3) hpo hzo
+  change (entryProgram.run environment).cost ≤ _ at hcost
+  change outputBits (entryProgram.run environment).output ≤ _ at houtput
+  constructor
+  · unfold entryCostBound
+    change (entryProgram.run environment).cost ≤ 20 * E + B + 20
+    omega
+  · exact houtput
+
+def rowCostBound (M d : ℕ) : ℕ :=
+  7 * generatorExpressionBudget M + 1 +
+    d * (entryCostBound M + loopControlBound M + entryOutputBound M)
+
+def rowOutputBound (M d : ℕ) : ℕ := d * entryOutputBound M
+
+def variableCostBound (M d : ℕ) : ℕ :=
+  7 * generatorExpressionBudget M + 1 +
+    d * (rowCostBound M d + loopControlBound M + rowOutputBound M d)
+
+def variableOutputBound (M d : ℕ) : ℕ := d * rowOutputBound M d
+
+theorem rowProgram_bounds {M r i n s : ℕ}
+    (hM : 2 ≤ M) (hr : r ≤ M) (hi : i + 1 ≤ M)
+    (hn : n ≤ M) (hs : s ≤ M) (hd : 2 * n * s ^ 2 ≤ M) :
+    (rowProgram.run [r, i, n, s]).cost ≤ rowCostBound M (2 * n * s ^ 2) ∧
+      outputBits (rowProgram.run [r, i, n, s]).output ≤
+        rowOutputBound M (2 * n * s ^ 2) := by
+  have henv : ∀ a ∈ [r, i, n, s], a ≤ M := by
+    intro a ha
+    simp only [List.mem_cons, List.not_mem_nil, or_false] at ha
+    rcases ha with rfl | rfl | rfl | rfl <;> omega
+  have hv : ((dimensionExpr 2 3).run [r, i, n, s]).value = 2 * n * s ^ 2 := by
+    simp [dimensionExpr, Expr.run]
+  have hc := dimensionExpr_cost_le (environment := [r, i, n, s])
+    (nr := 2) (sr := 3) hM (by simp) henv (by omega) (by omega) rfl rfl hn hs
+  have hb : ∀ q < ((dimensionExpr 2 3).run [r, i, n, s]).value,
+      (entryProgram.run (q :: [r, i, n, s])).cost ≤ entryCostBound M ∧
+      outputBits (entryProgram.run (q :: [r, i, n, s])).output ≤ entryOutputBound M := by
+    intro q hq
+    rw [hv] at hq
+    exact entryProgram_bounds hM (by omega) hr hi hn hs
+  constructor
+  · have h := loop_cost_le [r, i, n, s] (dimensionExpr 2 3) entryProgram M
+      (7 * generatorExpressionBudget M) (entryCostBound M) (entryOutputBound M)
+      (by rw [hv]; exact hd) hc hb
+    simpa only [rowProgram, rowCostBound, hv] using h
+  · have h := loop_outputBits_le [r, i, n, s] (dimensionExpr 2 3) entryProgram
+      (entryOutputBound M) (fun q hq => (hb q hq).2)
+    simpa only [rowProgram, rowOutputBound, hv] using h
+
+theorem variableProgram_bounds {M i n s : ℕ}
+    (hM : 2 ≤ M) (hi : i + 1 ≤ M)
+    (hn : n ≤ M) (hs : s ≤ M) (hd : 2 * n * s ^ 2 ≤ M) :
+    (variableProgram.run [i, n, s]).cost ≤ variableCostBound M (2 * n * s ^ 2) ∧
+      outputBits (variableProgram.run [i, n, s]).output ≤
+        variableOutputBound M (2 * n * s ^ 2) := by
+  have henv : ∀ a ∈ [i, n, s], a ≤ M := by
+    intro a ha
+    simp only [List.mem_cons, List.not_mem_nil, or_false] at ha
+    rcases ha with rfl | rfl | rfl <;> omega
+  have hv : ((dimensionExpr 1 2).run [i, n, s]).value = 2 * n * s ^ 2 := by
+    simp [dimensionExpr, Expr.run]
+  have hc := dimensionExpr_cost_le (environment := [i, n, s])
+    (nr := 1) (sr := 2) hM (by simp) henv (by omega) (by omega) rfl rfl hn hs
+  have hb : ∀ r < ((dimensionExpr 1 2).run [i, n, s]).value,
+      (rowProgram.run (r :: [i, n, s])).cost ≤ rowCostBound M (2 * n * s ^ 2) ∧
+      outputBits (rowProgram.run (r :: [i, n, s])).output ≤
+        rowOutputBound M (2 * n * s ^ 2) := by
+    intro r hr
+    rw [hv] at hr
+    exact rowProgram_bounds hM (by omega) hi hn hs hd
+  constructor
+  · have h := loop_cost_le [i, n, s] (dimensionExpr 1 2) rowProgram M
+      (7 * generatorExpressionBudget M) (rowCostBound M (2 * n * s ^ 2))
+      (rowOutputBound M (2 * n * s ^ 2)) (by rw [hv]; exact hd) hc hb
+    simpa only [variableProgram, variableCostBound, hv] using h
+  · have h := loop_outputBits_le [i, n, s] (dimensionExpr 1 2) rowProgram
+      (rowOutputBound M (2 * n * s ^ 2)) (fun r hr => (hb r hr).2)
+    simpa only [variableProgram, variableOutputBound, hv] using h
+
+def generatorCostBound (n s : ℕ) : ℕ :=
+  let d := 2 * n * s ^ 2
+  let M := n + s + d + 3
+  2 * (M + 1) + 7 * generatorExpressionBudget M + 15 +
+    (registerReadBound M + 1 +
+      n * (variableCostBound M d + loopControlBound M + variableOutputBound M d)) + 1
+
+theorem generate_cost_le (n s : ℕ) : (generate n s).cost ≤ generatorCostBound n s := by
+  let d := 2 * n * s ^ 2
+  let M := n + s + d + 3
+  let E := generatorExpressionBudget M
+  let B := intermediateWidthBound M
+  let R := registerReadBound M
+  let C := R + 1 + n * (variableCostBound M d + loopControlBound M + variableOutputBound M d)
+  have hM : 2 ≤ M := by unfold M; omega
+  have hn : n ≤ M := by unfold M; omega
+  have hs : s ≤ M := by unfold M; omega
+  have hd : d ≤ M := by unfold M; omega
+  have hB : 4 ≤ B := by unfold B intermediateWidthBound; omega
+  have henv : ∀ a ∈ [n, s], a ≤ M := by
+    intro a ha
+    simp only [List.mem_cons, List.not_mem_nil, or_false] at ha
+    rcases ha with rfl | rfl <;> assumption
+  have hnr := Expr.bounded_read (environment := [n, s]) (index := 0)
+    (by simp) (by omega) henv
+  have hsr := Expr.bounded_read (environment := [n, s]) (index := 1)
+    (by simp) (by omega) henv
+  have h1 := Expr.bounded_literal (environment := [n, s]) (a := 1) (by omega : 1 ≤ M)
+  have hwif (a : ℕ) : width (if a = 1 then 1 else 0) ≤ 2 := by
+    split <;> decide
+  have hnt : (Expr.equal (.read 0) (.literal 1)).Bounded [n, s] M B R := by
+    refine ⟨?_, hnr, h1⟩
+    have h := (hwif n).trans (by omega : 2 ≤ B)
+    simpa [Expr.run] using h
+  have hst : (Expr.equal (.read 1) (.literal 1)).Bounded [n, s] M B R := by
+    refine ⟨?_, hsr, h1⟩
+    have h := (hwif s).trans (by omega : 2 ≤ B)
+    simpa [Expr.run] using h
+  let test : Expr := .mul (.equal (.read 0) (.literal 1)) (.equal (.read 1) (.literal 1))
+  have ht : test.Bounded [n, s] M B R := by
+    refine ⟨?_, hnt, hst⟩
+    have h := width_mul_le (if n = 1 then 1 else 0) (if s = 1 then 1 else 0)
+    have hnv := hwif n
+    have hsv := hwif s
+    have hw : width ((if n = 1 then 1 else 0) * (if s = 1 then 1 else 0)) ≤ B := by omega
+    simpa [test, Expr.run] using hw
+  have htc : (test.run [n, s]).cost ≤ 7 * E := by
+    have h := Expr.cost_le_nodes_budget [n, s] M B R test ht
+    simpa [test, Expr.nodes, E, B, R, generatorExpressionBudget] using h
+  have hloop : ((Program.loop (.read 0) variableProgram).run [n, s]).cost ≤ C := by
+    have hc : ((Expr.read 0).run [n, s]).cost ≤ R := hnr.2
+    have hb : ∀ i < ((Expr.read 0).run [n, s]).value,
+        (variableProgram.run (i :: [n, s])).cost ≤ variableCostBound M d ∧
+        outputBits (variableProgram.run (i :: [n, s])).output ≤ variableOutputBound M d := by
+      intro i hi
+      change i < n at hi
+      exact variableProgram_bounds hM (by omega) hn hs hd
+    have h := loop_cost_le [n, s] (.read 0) variableProgram M R
+      (variableCostBound M d) (variableOutputBound M d) hn hc hb
+    exact h
+  have hexception : ((Program.emit (.literal 0) (.literal 1) (.literal 1)).run [n, s]).cost ≤ 15 + C := by
+    simp only [Program.run, Expr.run, RationalCode.bits, width, Nat.size_zero, Nat.size_one]
+    omega
+  have hbranch := branch_cost_le [n, s] test
+    (.emit (.literal 0) (.literal 1) (.literal 1)) (.loop (.read 0) variableProgram)
+    (7 * E) (15 + C) htc hexception (by omega)
+  change (generatorProgram.run [n, s]).cost ≤ _ at hbranch
+  have hinput : listBits [n, s] ≤ 2 * (M + 1) := by
+    have hnw := width_le_of_le hn
+    have hsw := width_le_of_le hs
+    simp only [listBits, List.map_cons, List.map_nil, List.sum_cons, List.sum_nil, Nat.add_zero]
+    omega
+  change listBits [n, s] + (generatorProgram.run [n, s]).cost ≤ _
+  change _ ≤ 2 * (M + 1) + 7 * E + 15 + C + 1
+  omega
+
+end NCHitting
+
+end OAI
diff --git a/lean/OAI/Algebra/FormulaHitting/Hitting.lean b/lean/OAI/Algebra/FormulaHitting/Hitting.lean
new file mode 100644
index 0000000000000000000000000000000000000000..e1edb8aac4b6401f5d845f1c25e2214d7e2ed7b5
--- /dev/null
+++ b/lean/OAI/Algebra/FormulaHitting/Hitting.lean
@@ -0,0 +1,100 @@
+import OAI.Algebra.FormulaHitting.Multiplicity
+import OAI.Algebra.FormulaHitting.DimensionBound
+import OAI.Algebra.FormulaHitting.SystemOutput
+import OAI.Algebra.FormulaHitting.SeriesFaithfulness
+import OAI.Algebra.FormulaHitting.JetMatrix
+
+namespace OAI
+
+noncomputable section
+namespace NCHitting
+
+open Matrix PowerSeries
+
+variable {F : Type*} [Field F] [CharZero F]
+
+omit [CharZero F] in
+theorem AcyclicRepresentation.scalarOutput_eq_contract {n : ℕ}
+    (R : AcyclicRepresentation F n) :
+    systemScalarOutput R.u R.v R.fundamentalMatrix =
+      R.contract R.fundamentalMatrix := by
+  simp only [systemScalarOutput, AcyclicRepresentation.contract,
+    LinearMap.coe_mk, AddHom.coe_mk, dotProduct, Matrix.mulVec,
+    Finset.sum_mul, Finset.mul_sum]
+  rw [Finset.sum_comm]
+  simp only [mul_assoc]
+
+theorem Formula.series_order_lt {n : ℕ} (f : Formula F n) (hn : 0 < n)
+    (hf : f.coeff ≠ 0) :
+    f.series.order.toNat <
+      (n-1) * (Fintype.card f.representation.State).choose 2 +
+        Fintype.card f.representation.State := by
+  let R := f.representation
+  have hq : AcyclicRepresentation.denominator (F := F) n ≠ 0 := by
+    intro hz
+    have he := AcyclicRepresentation.denominator_eval_zero_ne (F := F) (n := n)
+    exact he (by rw [hz, Polynomial.eval_zero])
+  have ho : systemScalarOutput R.u R.v R.fundamentalMatrix = f.series :=
+    R.scalarOutput_eq_contract.trans f.system_output_eq_series
+  have hbound := system_multiplicity n hn
+    (AcyclicRepresentation.denominator (F := F) n) R.systemNumerator R.u R.v
+    R.fundamentalMatrix (AcyclicRepresentation.denominator_degree (F := F) (n := n))
+    hq R.systemNumerator_degree
+    (R.fundamentalMatrix_isUnit f.representation_card_pos)
+    R.fundamentalMatrix_polynomial_system
+    (by rw [ho]; exact f.series_ne_zero hf)
+  rwa [ho] at hbound
+
+theorem Formula.eval_generator_one_ne_zero (f : Formula F 1)
+    (hs : f.size ≤ 1) (hf : f.coeff ≠ 0) :
+    f.eval (Matrix.scalar (Fin (dimension 1 1)))
+      (fun i r q => (generator 1 1 i r q : F)) ≠ 0 := by
+  let r : Fin (dimension 1 1) := ⟨0, by decide⟩
+  rcases (Formula.size_le_one_iff f).mp hs with ⟨a, rfl⟩ | ⟨i, rfl⟩
+  · intro hz
+    have ha : a = 0 := by
+      have he := congrFun (congrFun hz r) r
+      simpa [Formula.eval, Matrix.scalar_apply] using he
+    apply hf
+    funext w
+    simp [Formula.coeff, ha]
+  · intro hz
+    have he := congrFun (congrFun hz r) r
+    simp [Formula.eval, generator_one] at he
+
+theorem Formula.eval_generator_ne_zero {n s : ℕ} (f : Formula F n)
+    (hn : 0 < n) (hs : 0 < s) (hsize : f.size ≤ s) (hf : f.coeff ≠ 0) :
+    f.eval (Matrix.scalar (Fin (dimension n s)))
+      (fun i r q => (generator n s i r q : F)) ≠ 0 := by
+  by_cases he : n = 1 ∧ s = 1
+  · rcases he with ⟨rfl, rfl⟩
+    exact f.eval_generator_one_ne_zero hsize hf
+  · have hns : 2 ≤ n*s := by
+      have hnle : n ≤ n*s := by simpa using Nat.mul_le_mul_left n hs
+      have hsle : s ≤ n*s := by simpa using Nat.mul_le_mul_right s hn
+      omega
+    have hm : Fintype.card f.representation.State ≤ 2*s :=
+      f.representation_card_le.trans (Nat.mul_le_mul_left 2 hsize)
+    have hbound : f.series.order.toNat < dimension n s := by
+      rw [dimension_eq hns]
+      exact (f.series_order_lt hn hf).trans_le (multiplicity_dimension_bound hn hs hm)
+    apply f.eval_generator_ne_zero_of_jet_series_ne_zero hns
+    apply jet_ne_zero_of_order_lt
+    rw [← PowerSeries.coe_toNat_order (f.series_ne_zero hf), ENat.natCast_lt_natCast]
+    exact hbound
+
+theorem universal_hitting (n s : ℕ) (hn : 1 ≤ n) (hs : 1 ≤ s)
+    (F : Type*) [Field F] [CharZero F] (f : Formula F n)
+    (hsize : f.size ≤ s) (hf : ∃ w, f.coeff w ≠ 0) :
+    f.eval (Matrix.scalar (Fin (dimension n s)))
+      (fun i r q => (generator n s i r q : F)) ≠ 0 := by
+  apply f.eval_generator_ne_zero hn hs hsize
+  intro hz
+  obtain ⟨w, hw⟩ := hf
+  exact hw (congrFun hz w)
+
+end NCHitting
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/FormulaHitting/Independence.lean b/lean/OAI/Algebra/FormulaHitting/Independence.lean
new file mode 100644
index 0000000000000000000000000000000000000000..25da5658e23b25bf5d5c78489732df617e88237a
--- /dev/null
+++ b/lean/OAI/Algebra/FormulaHitting/Independence.lean
@@ -0,0 +1,233 @@
+import Mathlib.RingTheory.PowerSeries.Derivative
+import Mathlib.RingTheory.PowerSeries.Order
+import Mathlib.RingTheory.Polynomial.Wronskian
+import Mathlib.RingTheory.PrincipalIdealDomain
+import Mathlib.Algebra.Polynomial.FieldDivision
+import Mathlib.Tactic.Ring
+
+namespace OAI
+
+noncomputable section
+open Polynomial
+namespace NCHitting
+
+variable {F : Type*} [Field F] [CharZero F]
+
+omit [CharZero F] in
+theorem wronskian_mul_common (g p q : F[X]) :
+    Polynomial.wronskian (g*p) (g*q) = g^2 * Polynomial.wronskian p q := by
+  simp only [Polynomial.wronskian, Polynomial.derivative_mul]
+  ring
+
+theorem eq_smul_of_wronskian_eq_zero (p q : F[X]) (hp : p ≠ 0)
+    (hw : Polynomial.wronskian p q = 0) : ∃ c : F, q = c • p := by
+  classical
+  let : GCDMonoid F[X] := IsBezout.toGCDDomain _
+  obtain ⟨a, b, ha, hb, hab⟩ := extract_gcd p q
+  let g := gcd p q
+  change p = g * a at ha
+  change q = g * b at hb
+  have hg : g ≠ 0 := by
+    intro h
+    apply hp
+    simpa [h] using ha
+  have ha0 : a ≠ 0 := by
+    intro h
+    apply hp
+    simpa [h] using ha
+  have hwab : Polynomial.wronskian a b = 0 := by
+    have hfactor : Polynomial.wronskian p q = g^2 * Polynomial.wronskian a b :=
+      (congrArg₂ Polynomial.wronskian ha hb).trans (wronskian_mul_common g a b)
+    rw [hfactor] at hw
+    exact (mul_eq_zero.mp hw).resolve_left (pow_ne_zero _ hg)
+  have hcop : IsCoprime a b := (gcd_isUnit_iff a b).mp hab
+  obtain ⟨had, hbd⟩ := hcop.wronskian_eq_zero_iff.mp hwab
+  have hac : a = C (a.coeff 0) := Polynomial.eq_C_of_derivative_eq_zero had
+  have hbc : b = C (b.coeff 0) := Polynomial.eq_C_of_derivative_eq_zero hbd
+  have hac0 : a.coeff 0 ≠ 0 := by
+    intro h
+    apply ha0
+    simpa [h] using hac
+  refine ⟨b.coeff 0 / a.coeff 0, ?_⟩
+  rw [Polynomial.smul_eq_C_mul]
+  calc
+    q = g * C (b.coeff 0) := hb.trans (congrArg (g * ·) hbc)
+    _ = C (b.coeff 0 / a.coeff 0) * (g * C (a.coeff 0)) := by
+      rw [mul_left_comm, ← C_mul, div_mul_cancel₀ _ hac0]
+    _ = C (b.coeff 0 / a.coeff 0) * p :=
+      congrArg (C (b.coeff 0 / a.coeff 0) * ·) (ha.trans (congrArg (g * ·) hac)).symm
+
+section FormalResidue
+open PowerSeries
+
+theorem coeff_X_mul_derivative (v : PowerSeries F) (k : ℕ) :
+    PowerSeries.coeff k (PowerSeries.X * PowerSeries.derivative (R := F) v) =
+      (k : F) * PowerSeries.coeff k v := by
+  cases k with
+  | zero => simp
+  | succ k =>
+    have hs := PowerSeries.coeff_X_pow_mul (PowerSeries.derivative (R := F) v) 1 k
+    simp only [pow_one] at hs
+    rw [hs, PowerSeries.coeff_derivative]
+    simp only [Nat.cast_add, Nat.cast_one]
+    ring
+
+theorem X_mul_derivative_X_pow (k : ℕ) :
+    PowerSeries.X * PowerSeries.derivative (R := F) ((PowerSeries.X : PowerSeries F)^k) =
+      PowerSeries.C (k : F) * PowerSeries.X^k := by
+  ext r
+  rw [coeff_X_mul_derivative, PowerSeries.coeff_C_mul, PowerSeries.coeff_X_pow]
+  split_ifs with hr
+  · subst r; rfl
+  · simp
+
+private theorem formal_wronskian_factor (A v Q S : PowerSeries F) (k : ℕ) :
+    (PowerSeries.X * Q) *
+        ((PowerSeries.X^k * A) * PowerSeries.derivative (R := F) (A*v) -
+          PowerSeries.derivative (R := F) (PowerSeries.X^k * A) * (A*v)) +
+        (PowerSeries.X^k * A)^2 * S =
+      PowerSeries.X^k * A^2 *
+        (Q * (PowerSeries.X * PowerSeries.derivative (R := F) v - PowerSeries.C (k : F) * v) +
+          PowerSeries.X^k * S) := by
+  simp only [Derivation.leibniz, smul_eq_mul]
+  calc
+    _ = PowerSeries.X^k * A^2 * (Q * (PowerSeries.X * PowerSeries.derivative (R := F) v) +
+          PowerSeries.X^k * S) -
+        (PowerSeries.X * PowerSeries.derivative (R := F) (PowerSeries.X^k)) * A^2 * Q * v := by
+          ring
+    _ = _ := by rw [X_mul_derivative_X_pow]; ring
+
+theorem formal_residue_obstruction (p0 p Q S : PowerSeries F)
+    (hp0 : p0 ≠ 0) (hQ : PowerSeries.constantCoeff Q ≠ 0)
+    (h : (PowerSeries.X * Q) *
+        (p0 * PowerSeries.derivative (R := F) p - PowerSeries.derivative (R := F) p0 * p) +
+        p0^2 * S = 0) : PowerSeries.constantCoeff S = 0 := by
+  let k := p0.order.toNat
+  let A := p0.divXPowOrder
+  let v := A⁻¹ * p
+  have hA : PowerSeries.constantCoeff A ≠ 0 := by
+    exact mt PowerSeries.constantCoeff_divXPowOrder_eq_zero_iff.mp hp0
+  have hA0 : A ≠ 0 := by
+    intro he
+    exact hA (by simp [he])
+  have hpa : PowerSeries.X^k * A = p0 := PowerSeries.X_pow_order_mul_divXPowOrder
+  have hav : A*v = p := by
+    dsimp [v]
+    rw [← mul_assoc, MvPowerSeries.mul_inv_cancel A hA, one_mul]
+  have hf : PowerSeries.X^k * A^2 *
+      (Q * (PowerSeries.X * PowerSeries.derivative (R := F) v - PowerSeries.C (k : F) * v) +
+        PowerSeries.X^k * S) = 0 := by
+    rw [← formal_wronskian_factor]
+    simpa only [hpa, hav] using h
+  have hn : PowerSeries.X^k * A^2 ≠ 0 :=
+    mul_ne_zero (pow_ne_zero _ PowerSeries.X_ne_zero) (pow_ne_zero _ hA0)
+  have he := (mul_eq_zero.mp hf).resolve_left hn
+  have he' :
+      (PowerSeries.X * PowerSeries.derivative (R := F) v - PowerSeries.C (k : F) * v) +
+        PowerSeries.X^k * (Q⁻¹*S) = 0 := by
+    calc
+      _ = Q⁻¹ *
+          (Q * (PowerSeries.X * PowerSeries.derivative (R := F) v - PowerSeries.C (k : F) * v) +
+            PowerSeries.X^k * S) := by
+        simp only [mul_add, ← mul_assoc, MvPowerSeries.inv_mul_cancel Q hQ, one_mul]
+        ring
+      _ = 0 := by rw [he, mul_zero]
+  have hk := congrArg (PowerSeries.coeff k) he'
+  have heuler : PowerSeries.coeff k
+      (PowerSeries.X * PowerSeries.derivative (R := F) v - PowerSeries.C (k : F) * v) = 0 := by
+    rw [map_sub, coeff_X_mul_derivative, PowerSeries.coeff_C_mul, sub_self]
+  have hshift : PowerSeries.coeff k (PowerSeries.X^k * (Q⁻¹*S)) =
+      PowerSeries.constantCoeff (Q⁻¹*S) := by
+    simpa only [zero_add, PowerSeries.coeff_zero_eq_constantCoeff] using
+      PowerSeries.coeff_X_pow_mul (Q⁻¹*S) k 0
+  rw [map_add, heuler, zero_add, hshift, map_zero] at hk
+  rw [map_mul] at hk
+  change (MvPowerSeries.constantCoeff Q⁻¹) * PowerSeries.constantCoeff S = 0 at hk
+  rw [MvPowerSeries.constantCoeff_inv] at hk
+  exact (mul_eq_zero.mp hk).resolve_left (inv_ne_zero hQ)
+
+theorem polynomial_residue_obstruction (a : F) (p0 p Q S : F[X])
+    (hp0 : p0 ≠ 0) (hQ : Q.eval a ≠ 0)
+    (h : ((Polynomial.X - Polynomial.C a) * Q) *
+        (p0 * p.derivative - p0.derivative * p) + p0^2 * S = 0) : S.eval a = 0 := by
+  let shift := Polynomial.X + Polynomial.C a
+  have hzero : (p0.comp shift : PowerSeries F) ≠ 0 := by
+    simpa [shift, Polynomial.comp_X_add_C_eq_zero_iff] using hp0
+  have hQzero : PowerSeries.constantCoeff (Q.comp shift : PowerSeries F) ≠ 0 := by
+    simpa [Polynomial.constantCoeff_coe, Polynomial.coeff_zero_eq_eval_zero,
+      shift, Polynomial.eval_comp] using hQ
+  have heq : (PowerSeries.X * (Q.comp shift : PowerSeries F)) *
+      ((p0.comp shift : PowerSeries F) * PowerSeries.derivative (R := F) (p.comp shift : PowerSeries F) -
+        PowerSeries.derivative (R := F) (p0.comp shift : PowerSeries F) * (p.comp shift : PowerSeries F)) +
+      (p0.comp shift : PowerSeries F)^2 * (S.comp shift : PowerSeries F) = 0 := by
+    have hh := congrArg (fun r : F[X] => (r.comp shift : PowerSeries F)) h
+    simpa [Polynomial.add_comp, Polynomial.mul_comp, Polynomial.sub_comp, Polynomial.pow_comp,
+      PowerSeries.derivative_coe, Polynomial.derivative_comp, shift] using hh
+  have hs := formal_residue_obstruction _ _ _ _ hzero hQzero heq
+  simpa [Polynomial.constantCoeff_coe, Polynomial.coeff_zero_eq_eval_zero,
+    shift, Polynomial.eval_comp] using hs
+
+end FormalResidue
+
+section DistinctPoles
+variable {ι : Type*} [Fintype ι] [DecidableEq ι]
+
+def poleProduct (a : ι → F) : F[X] := ∏ i, (Polynomial.X - Polynomial.C (a i))
+
+def puncturedPoleProduct (a : ι → F) (i : ι) : F[X] :=
+  ∏ j ∈ Finset.univ.erase i, (Polynomial.X - Polynomial.C (a j))
+
+omit [CharZero F] in
+theorem poleProduct_eq (a : ι → F) (i : ι) :
+    poleProduct a = (Polynomial.X - Polynomial.C (a i)) * puncturedPoleProduct a i := by
+  exact (Finset.mul_prod_erase Finset.univ (fun j => Polynomial.X - Polynomial.C (a j))
+    (Finset.mem_univ i)).symm
+
+omit [CharZero F] in
+theorem eval_puncturedPoleProduct_self_ne_zero (a : ι → F) (ha : Function.Injective a) (i : ι) :
+    (puncturedPoleProduct a i).eval (a i) ≠ 0 := by
+  simp only [puncturedPoleProduct, Polynomial.eval_prod, Polynomial.eval_sub,
+    Polynomial.eval_X, Polynomial.eval_C]
+  apply Finset.prod_ne_zero_iff.mpr
+  intro j hj
+  apply sub_ne_zero.mpr
+  intro he
+  have hji := (Finset.mem_erase.mp hj).1
+  exact hji (ha he).symm
+
+omit [CharZero F] in
+theorem eval_puncturedPoleProduct_other (a : ι → F) (i j : ι) (hij : i ≠ j) :
+    (puncturedPoleProduct a j).eval (a i) = 0 := by
+  simp only [puncturedPoleProduct, Polynomial.eval_prod, Polynomial.eval_sub,
+    Polynomial.eval_X, Polynomial.eval_C]
+  apply Finset.prod_eq_zero (i := i)
+  · simp [hij]
+  · simp
+
+theorem no_polynomial_log_primitive (a : ι → F) (ha : Function.Injective a)
+    (p0 p : F[X]) (hp0 : p0 ≠ 0) (c : ι → F)
+    (h : poleProduct a * (p0 * p.derivative - p0.derivative * p) +
+      p0^2 * (∑ i, Polynomial.C (c i) * puncturedPoleProduct a i) = 0) :
+    ∀ i, c i = 0 := by
+  intro i
+  have hr := polynomial_residue_obstruction (a i) p0 p (puncturedPoleProduct a i)
+    (∑ j, Polynomial.C (c j) * puncturedPoleProduct a j) hp0
+    (eval_puncturedPoleProduct_self_ne_zero a ha i) (by simpa [poleProduct_eq a i] using h)
+  have heval : (∑ j, Polynomial.C (c j) * puncturedPoleProduct a j).eval (a i) =
+      c i * (puncturedPoleProduct a i).eval (a i) := by
+    rw [Polynomial.eval_finsetSum]
+    simp only [Polynomial.eval_mul, Polynomial.eval_C]
+    apply Finset.sum_eq_single i
+    · intro j hj hji
+      simp [eval_puncturedPoleProduct_other a i j (Ne.symm hji)]
+    · simp
+  rw [heval] at hr
+  exact (mul_eq_zero.mp hr).resolve_right (eval_puncturedPoleProduct_self_ne_zero a ha i)
+
+end DistinctPoles
+
+end NCHitting
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/FormulaHitting/JetMatrix.lean b/lean/OAI/Algebra/FormulaHitting/JetMatrix.lean
new file mode 100644
index 0000000000000000000000000000000000000000..95a1736d2e3d3b94d243e287909895d77b907f4f
--- /dev/null
+++ b/lean/OAI/Algebra/FormulaHitting/JetMatrix.lean
@@ -0,0 +1,132 @@
+import OAI.Algebra.FormulaHitting.Series
+import OAI.Algebra.FormulaHitting.RationalTransfer
+import OAI.Algebra.FormulaHitting.Generator
+import OAI.Algebra.FormulaHitting.Evaluation
+import OAI.Algebra.FormulaHitting.FormulaSeries
+import Mathlib.Data.Rat.Cast.Lemmas
+
+namespace OAI
+
+noncomputable section
+namespace NCHitting
+
+open Matrix
+
+variable {F : Type*} [Field F] [CharZero F]
+
+omit [CharZero F] in
+theorem jet_eq_zero_iff (d : ℕ) (a : PowerSeries F) :
+    jet d a = 0 ↔ ∀ r < d, PowerSeries.coeff r a = 0 := by
+  constructor
+  · intro h r hr
+    exact congrFun h ⟨r, hr⟩
+  · intro h
+    ext r
+    exact h r.val r.isLt
+
+omit [CharZero F] in
+theorem jet_ne_zero_of_order_lt (d : ℕ) (a : PowerSeries F)
+    (horder : a.order < (d : ℕ∞)) : jet d a ≠ 0 := by
+  intro h
+  exact (not_le_of_gt horder)
+    (PowerSeries.nat_le_order a d ((jet_eq_zero_iff d a).mp h))
+
+def integrationMatrix (d i : ℕ) : Matrix (Fin d) (Fin d) F :=
+  fun r q => (matrixEntry i r.val q.val : F)
+
+theorem integrationMatrix_apply (d i : ℕ) (r q : Fin d) :
+    integrationMatrix (F := F) d i r q =
+      if q.val < r.val then
+        (-1 : F) ^ (r.val - q.val - 1) /
+          ((r.val : F) * (i : F) ^ (r.val - q.val))
+      else 0 := by
+  by_cases h : q.val < r.val <;> simp [integrationMatrix, matrixEntry, h]
+
+theorem jet_J (d i : ℕ) (a : PowerSeries F) :
+    jet d (J i a) = integrationMatrix d i *ᵥ jet d a := by
+  ext r
+  rw [jet_apply, coeff_J]
+  simp only [Matrix.mulVec, dotProduct, integrationMatrix_apply, jet_apply]
+  let term := fun q =>
+    (if q < r.val then (-1 : F) ^ (r.val - q - 1) /
+      ((r.val : F) * (i : F) ^ (r.val - q)) else 0) * PowerSeries.coeff q a
+  change _ = ∑ q : Fin d, term q.val
+  rw [Fin.sum_univ_eq_sum_range term d]
+  calc
+    _ = ∑ q ∈ Finset.range r.val, term q := by
+      apply Finset.sum_congr rfl
+      intro q hq
+      simp only [term, ite_eq_left (Finset.mem_range.mp hq)]
+    _ = ∑ q ∈ Finset.range d, term q := by
+      apply Finset.sum_subset (Finset.range_mono (Nat.le_of_lt r.isLt))
+      intro q hqd hqr
+      have h : ¬q < r.val := by simpa using hqr
+      simp [term, h]
+
+theorem jet_wordSeries {n : ℕ} (d : ℕ) (w : Word n) :
+    jet d (wordSeries (F := F) w) =
+      (w.map (fun i => integrationMatrix (F := F) d (i.val + 1))).prod *ᵥ
+        jet d (1 : PowerSeries F) := by
+  induction w with
+  | nil => simp
+  | cons i w ih =>
+    rw [wordSeries_cons, jet_J, ih]
+    simp only [List.map_cons, List.prod_cons, Matrix.mulVec_mulVec]
+
+omit [CharZero F] in
+theorem generator_cast_eq_integrationMatrix {n s : ℕ} (hns : 2 ≤ n * s)
+    (i : Fin n) :
+    (fun r q => (generator n s i r q : F)) =
+      integrationMatrix (F := F) (dimension n s) (i.val + 1) := by
+  ext r q
+  simp only [integrationMatrix, generator_entry hns]
+
+theorem Formula.jet_wordSum_eq_eval_mulVec {n : ℕ} (f : Formula F n) (d : ℕ) :
+    jet d (f.polynomial.sum fun w a => a • wordSeries (F := F) w) =
+      f.eval (algebraMap F (Matrix (Fin d) (Fin d) F))
+        (fun i => integrationMatrix (F := F) d (i.val + 1)) *ᵥ
+          jet d (1 : PowerSeries F) := by
+  rw [Formula.eval_eq_sum]
+  simp only [Finsupp.sum, map_sum, map_smul, Matrix.sum_mulVec,
+    ← Algebra.smul_def, Matrix.smul_mulVec, jet_wordSeries]
+
+theorem Formula.eval_ne_zero_of_jet_wordSum_ne_zero {n : ℕ}
+    (f : Formula F n) (d : ℕ)
+    (hjet : jet d (f.polynomial.sum fun w a => a • wordSeries (F := F) w) ≠ 0) :
+    f.eval (algebraMap F (Matrix (Fin d) (Fin d) F))
+      (fun i => integrationMatrix (F := F) d (i.val + 1)) ≠ 0 := by
+  intro h
+  apply hjet
+  rw [f.jet_wordSum_eq_eval_mulVec d, h, Matrix.zero_mulVec]
+
+theorem Formula.jet_series_eq_eval_mulVec {n : ℕ} (f : Formula F n) (d : ℕ) :
+    jet d f.series =
+      f.eval (algebraMap F (Matrix (Fin d) (Fin d) F))
+        (fun i => integrationMatrix (F := F) d (i.val + 1)) *ᵥ
+          jet d (1 : PowerSeries F) := by
+  rw [f.series_eq_smul_sum, f.jet_wordSum_eq_eval_mulVec]
+
+theorem Formula.eval_ne_zero_of_jet_series_ne_zero {n : ℕ} (f : Formula F n) (d : ℕ)
+    (hjet : jet d f.series ≠ 0) :
+    f.eval (algebraMap F (Matrix (Fin d) (Fin d) F))
+      (fun i => integrationMatrix (F := F) d (i.val + 1)) ≠ 0 := by
+  apply f.eval_ne_zero_of_jet_wordSum_ne_zero d
+  rwa [← f.series_eq_smul_sum]
+
+theorem Formula.eval_generator_ne_zero_of_jet_series_ne_zero {n s : ℕ}
+    (f : Formula F n) (hns : 2 ≤ n * s)
+    (hjet : jet (dimension n s) f.series ≠ 0) :
+    f.eval (Matrix.scalar (Fin (dimension n s)))
+      (fun i r q => (generator n s i r q : F)) ≠ 0 := by
+  have hT : (fun (i : Fin n) r q => (generator n s i r q : F)) =
+      (fun i => integrationMatrix (F := F) (dimension n s) (i.val + 1)) := by
+    funext i
+    exact generator_cast_eq_integrationMatrix hns i
+  rw [hT]
+  exact f.eval_ne_zero_of_jet_series_ne_zero (dimension n s) hjet
+
+end NCHitting
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/FormulaHitting/Main.lean b/lean/OAI/Algebra/FormulaHitting/Main.lean
new file mode 100644
index 0000000000000000000000000000000000000000..a86025f611fd1de2944c193e922514bc41d192ef
--- /dev/null
+++ b/lean/OAI/Algebra/FormulaHitting/Main.lean
@@ -0,0 +1,4 @@
+import OAI.Algebra.FormulaHitting.Hitting
+import OAI.Algebra.FormulaHitting.RationalMinor
+import OAI.Algebra.FormulaHitting.BitBounds
+import OAI.Algebra.FormulaHitting.Result
diff --git a/lean/OAI/Algebra/FormulaHitting/MinorFactor.lean b/lean/OAI/Algebra/FormulaHitting/MinorFactor.lean
new file mode 100644
index 0000000000000000000000000000000000000000..ed23b12e3a3858737025fab71a4297d8a8eaa368
--- /dev/null
+++ b/lean/OAI/Algebra/FormulaHitting/MinorFactor.lean
@@ -0,0 +1,44 @@
+import OAI.Algebra.FormulaHitting.Minors
+import Mathlib.LinearAlgebra.Matrix.NonsingularInverse
+
+namespace OAI
+
+noncomputable section
+
+namespace NCHitting
+
+open Matrix
+
+variable {R : Type*} [CommRing R] [IsDomain R]
+variable {K I : Type*} [Fintype K] [DecidableEq K] [Fintype I] [DecidableEq I]
+
+theorem exists_nonzero_divisible_minor
+    (Z H : Matrix K I R) (G : Matrix I I R) (D W : Matrix K K R)
+    (C : Matrix K I R) (E : Matrix I K R)
+    (hG : IsUnit G) (hD : D.det ≠ 0) (hW : W.det ≠ 0)
+    (hZG : Z * G = D * H) (hHC : H = W * C) (hHE : W = H * E) :
+    ∃ f : K → I, (Z.submatrix id f).det ≠ 0 ∧ W.det ∣ (Z.submatrix id f).det := by
+  classical
+  have hprod : Z * (G * E) = D * W := by
+    rw [← Matrix.mul_assoc, hZG, Matrix.mul_assoc, ← hHE]
+  have hprod0 : (Z * (G * E)).det ≠ 0 := by
+    rw [hprod, Matrix.det_mul]
+    exact mul_ne_zero hD hW
+  obtain ⟨f, hf⟩ := exists_minor_ne_zero_of_mul_det_ne_zero Z (G * E) hprod0
+  refine ⟨f, hf, ?_⟩
+  have hGdet : IsUnit G.det := (Matrix.isUnit_iff_isUnit_det G).mp hG
+  have hZ : Z = (D * W) * (C * G⁻¹) := by
+    calc
+      Z = (Z * G) * G⁻¹ := (Matrix.mul_nonsing_inv_cancel_right G Z hGdet).symm
+      _ = (D * W) * (C * G⁻¹) := by rw [hZG, hHC]; simp only [Matrix.mul_assoc]
+  have hsub : Z.submatrix id f = (D * W) * ((C * G⁻¹).submatrix id f) := by
+    rw [hZ]
+    rfl
+  rw [hsub, Matrix.det_mul, Matrix.det_mul]
+  exact dvd_mul_of_dvd_left (dvd_mul_left _ _) _
+
+end NCHitting
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/FormulaHitting/Minors.lean b/lean/OAI/Algebra/FormulaHitting/Minors.lean
new file mode 100644
index 0000000000000000000000000000000000000000..8e371ee734229dac0c9ccb9224e64d62a267a2cc
--- /dev/null
+++ b/lean/OAI/Algebra/FormulaHitting/Minors.lean
@@ -0,0 +1,75 @@
+import Mathlib.LinearAlgebra.Matrix.Determinant.Basic
+import Mathlib.Algebra.Polynomial.BigOperators
+
+namespace OAI
+
+noncomputable section
+
+namespace NCHitting
+
+open Matrix Finset Polynomial
+
+variable {R : Type*} [CommRing R]
+variable {I J : Type*} [Fintype I] [DecidableEq I] [Fintype J]
+
+theorem det_rectangular_mul (A : Matrix I J R) (B : Matrix J I R) :
+    (A * B).det = ∑ f : I → J, (A.submatrix id f).det * ∏ i, B (f i) i := by
+  classical
+  calc
+    (A * B).det = ∑ f : I → J, ∑ σ : Equiv.Perm I,
+        (Equiv.Perm.sign σ : R) * ∏ i, A (σ i) (f i) * B (f i) i := by
+      simp only [Matrix.det_apply', Matrix.mul_apply, Finset.prod_univ_sum,
+        Finset.mul_sum, Fintype.piFinset_univ]
+      rw [Finset.sum_comm]
+    _ = _ := by
+      apply Finset.sum_congr rfl
+      intro f _
+      simp only [Matrix.det_apply', Matrix.submatrix_apply, id_eq,
+        Finset.prod_mul_distrib, Finset.sum_mul, mul_assoc]
+
+theorem dvd_det_rectangular_mul (A : Matrix I J R) (B : Matrix J I R)
+    (p : R) (h : ∀ f : I → J, p ∣ (A.submatrix id f).det) :
+    p ∣ (A * B).det := by
+  rw [det_rectangular_mul]
+  exact Finset.dvd_sum (fun f _ => dvd_mul_of_dvd_left (h f) _)
+
+theorem exists_minor_ne_zero_of_mul_det_ne_zero (A : Matrix I J R)
+    (B : Matrix J I R) (h : (A * B).det ≠ 0) :
+    ∃ f : I → J, (A.submatrix id f).det ≠ 0 := by
+  classical
+  by_contra hn
+  push Not at hn
+  apply h
+  simp [det_rectangular_mul, hn]
+
+theorem dvd_det_of_column_dvd (A : Matrix I I R) (c : I) (p : R)
+    (h : ∀ i, p ∣ A i c) : p ∣ A.det := by
+  classical
+  rw [Matrix.det_apply']
+  apply Finset.dvd_sum
+  intro σ _
+  apply dvd_mul_of_dvd_right
+  exact (h (σ c)).trans (Finset.dvd_prod_of_mem (fun i => A (σ i) i) (Finset.mem_univ c))
+
+theorem natDegree_det_le_sum {F : Type*} [Field F]
+    (A : Matrix I I F[X]) (d : I → ℕ)
+    (h : ∀ i j, (A i j).natDegree ≤ d i) :
+    A.det.natDegree ≤ ∑ i, d i := by
+  classical
+  rw [Matrix.det_apply']
+  apply Polynomial.natDegree_sum_le_of_forall_le
+  intro σ _
+  apply (Polynomial.natDegree_mul_le).trans
+  have hsign : (↑(Equiv.Perm.sign σ) : F[X]).natDegree = 0 := by
+    exact Polynomial.natDegree_intCast _
+  rw [hsign, zero_add]
+  calc
+    (∏ i, A (σ i) i).natDegree ≤ ∑ i, d (σ i) :=
+      (Polynomial.natDegree_prod_le Finset.univ (fun i => A (σ i) i)).trans (Finset.sum_le_sum (fun i _ => h (σ i) i))
+    _ = ∑ i, d i := Equiv.sum_comp σ d
+
+end NCHitting
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/FormulaHitting/Model.lean b/lean/OAI/Algebra/FormulaHitting/Model.lean
new file mode 100644
index 0000000000000000000000000000000000000000..3bfc473e9d7b79ecd3a8e0adefab9f8e3e5d4b51
--- /dev/null
+++ b/lean/OAI/Algebra/FormulaHitting/Model.lean
@@ -0,0 +1,57 @@
+import Mathlib.Data.Matrix.Basic
+import Mathlib.Data.Rat.Defs
+
+namespace OAI
+
+namespace NCHitting
+
+abbrev Word (n : ℕ) := List (Fin n)
+abbrev WordSeries (F : Type*) (n : ℕ) := Word n → F
+
+def convolution {F : Type*} {n : ℕ} [Semiring F]
+    (f g : WordSeries F n) : Word n → F
+  | [] => f [] * g []
+  | i :: w => f [] * g (i :: w) + convolution (fun v => f (i :: v)) g w
+
+inductive Formula (F : Type*) (n : ℕ) where
+  | scalar : F → Formula F n
+  | var : Fin n → Formula F n
+  | add : Formula F n → Formula F n → Formula F n
+  | mul : Formula F n → Formula F n → Formula F n
+
+namespace Formula
+
+def size {F : Type*} {n : ℕ} : Formula F n → ℕ
+  | scalar _ => 1
+  | var _ => 1
+  | add f g => f.size + g.size + 1
+  | mul f g => f.size + g.size + 1
+
+noncomputable def coeff {F : Type*} {n : ℕ} [Semiring F] :
+    Formula F n → WordSeries F n
+  | scalar a => fun w => if w = [] then a else 0
+  | var i => fun w => if w = [i] then 1 else 0
+  | add f g => fun w => coeff f w + coeff g w
+  | mul f g => convolution (coeff f) (coeff g)
+
+def eval {F A : Type*} {n : ℕ} [Semiring A]
+    (scalarMap : F → A) (T : Fin n → A) : Formula F n → A
+  | scalar a => scalarMap a
+  | var i => T i
+  | add f g => eval scalarMap T f + eval scalarMap T g
+  | mul f g => eval scalarMap T f * eval scalarMap T g
+
+end Formula
+
+def dimension (n s : ℕ) : ℕ := if n = 1 ∧ s = 1 then 1 else 2 * n * s ^ 2
+
+def matrixEntry (i r q : ℕ) : ℚ :=
+  if q < r then (-1 : ℚ) ^ (r - q - 1) / ((r : ℚ) * (i : ℚ) ^ (r - q))
+  else 0
+
+def generator (n s : ℕ) : Fin n → Matrix (Fin (dimension n s)) (Fin (dimension n s)) ℚ :=
+  fun i r q => if n = 1 ∧ s = 1 then 1 else matrixEntry (i.val + 1) r.val q.val
+
+end NCHitting
+
+end OAI
diff --git a/lean/OAI/Algebra/FormulaHitting/Multiplicity.lean b/lean/OAI/Algebra/FormulaHitting/Multiplicity.lean
new file mode 100644
index 0000000000000000000000000000000000000000..ec10a8cacf5d7b6b5ee9f6dad74fa274e160580a
--- /dev/null
+++ b/lean/OAI/Algebra/FormulaHitting/Multiplicity.lean
@@ -0,0 +1,176 @@
+import OAI.Algebra.FormulaHitting.ScaledDerivatives
+import OAI.Algebra.FormulaHitting.WronskianBound
+import OAI.Algebra.FormulaHitting.MinorFactor
+import Mathlib.RingTheory.PowerSeries.NoZeroDivisors
+import Mathlib.Data.Nat.Choose.Basic
+import Mathlib.Algebra.BigOperators.Intervals
+
+namespace OAI
+
+noncomputable section
+
+namespace NCHitting
+
+open PowerSeries Polynomial Matrix Submodule
+
+variable {F : Type*} [Field F] [CharZero F]
+
+def derivativeMatrix {I : Type*} (k : ℕ) (h : I → PowerSeries F) :
+    Matrix (Fin k) I (PowerSeries F) := fun j t => derivativeIter j.val (h t)
+
+omit [CharZero F] in
+theorem derivativeMatrix_combination {I J : Type*} [Fintype I]
+    (k : ℕ) (h : I → PowerSeries F) (C : Matrix I J F) :
+    derivativeMatrix k (fun l => ∑ t : I, C t l • h t) =
+      derivativeMatrix k h * C.map PowerSeries.C := by
+  classical
+  funext j l
+  change derivativeIter j.val (∑ t : I, C t l • h t) =
+    ∑ t : I, derivativeIter j.val (h t) * PowerSeries.C (C t l)
+  rw [derivativeIter_sum]
+  simp only [derivativeIter_smul]
+  simp only [PowerSeries.smul_eq_C_mul]
+  apply Finset.sum_congr rfl
+  intro t _
+  exact mul_comm _ _
+
+omit [CharZero F] in
+theorem order_le_natDegree_of_dvd (f : PowerSeries F) (p : F[X])
+    (hp : p ≠ 0) (h : f ∣ (p : PowerSeries F)) : f.order.toNat ≤ p.natDegree := by
+  by_contra hn
+  have hd : PowerSeries.X^f.order.toNat ∣ (p : PowerSeries F) :=
+    PowerSeries.X_pow_order_dvd.trans h
+  have hz := (PowerSeries.X_pow_dvd_iff.mp hd) p.natDegree (by omega)
+  exact (Polynomial.leadingCoeff_ne_zero.mpr hp) (by simpa using hz)
+
+theorem sum_fin_eq_choose (k : ℕ) : (∑ j : Fin k, j.val) = k.choose 2 := by
+  calc
+    (∑ j : Fin k, j.val) = ∑ j ∈ Finset.range k, j :=
+      Fin.sum_univ_eq_sum_range (fun j => j) k
+    _ = k.choose 2 := by rw [Finset.sum_range_id, Nat.choose_two_right]
+
+variable {I : Type*} [Fintype I] [DecidableEq I]
+
+def systemScalarOutput (u v : I → F) (G : Matrix I I (PowerSeries F)) :
+    PowerSeries F := ∑ l : I, (∑ t : I, PowerSeries.C (u t) * G t l) * PowerSeries.C (v l)
+
+theorem system_multiplicity (n : ℕ) (hn : 0 < n)
+    (q : F[X]) (P : Matrix I I F[X]) (u v : I → F)
+    (G : Matrix I I (PowerSeries F))
+    (hq : q.natDegree ≤ n) (hqn : q ≠ 0)
+    (hP : ∀ t l, (P t l).natDegree ≤ n-1) (hG : IsUnit G)
+    (hD : ∀ t l, (q : PowerSeries F) * PowerSeries.derivative (R := F) (G t l) =
+      ∑ a : I, (P t a : PowerSeries F) * G a l)
+    (hy : systemScalarOutput u v G ≠ 0) :
+    (systemScalarOutput u v G).order.toNat <
+      (n-1) * (Fintype.card I).choose 2 + Fintype.card I := by
+  classical
+  let h : I → PowerSeries F := fun l => ∑ t : I, PowerSeries.C (u t) * G t l
+  let V := Submodule.span F (Set.range h)
+  let : FiniteDimensional F V := FiniteDimensional.span_of_finite F (Set.finite_range h)
+  obtain ⟨k, b, a, hbi, hspan, ha, hlead, hzero⟩ := hasOrderBasis V
+  have hbn : wronskian b ≠ 0 := (wronskian_order_sum b a ha hlead hzero).1
+  have hk : k ≤ Fintype.card I := by
+    have hkdim : Module.finrank F (Submodule.span F (Set.range b)) = k := by
+      simpa using finrank_span_eq_card hbi
+    rw [hspan] at hkdim
+    rw [← hkdim]
+    exact finrank_range_le_card h
+  have hhmem : ∀ l, h l ∈ Submodule.span F (Set.range b) := by
+    intro l
+    rw [hspan]
+    exact Submodule.subset_span ⟨l, rfl⟩
+  have hbmem : ∀ l, b l ∈ Submodule.span F (Set.range h) := by
+    intro l
+    change b l ∈ V
+    rw [← hspan]
+    exact Submodule.subset_span ⟨l, rfl⟩
+  have hc : ∀ l : I, ∃ c : Fin k → F, ∑ j : Fin k, c j • b j = h l := by
+    intro l
+    exact (Submodule.mem_span_range_iff_exists_fun F).mp (hhmem l)
+  have he : ∀ l : Fin k, ∃ c : I → F, ∑ j : I, c j • h j = b l := by
+    intro l
+    exact (Submodule.mem_span_range_iff_exists_fun F).mp (hbmem l)
+  choose c hc using hc
+  choose e he using he
+  let H := derivativeMatrix k h
+  let W := wronskianMatrix b
+  let C : Matrix (Fin k) I (PowerSeries F) :=
+    fun j l => PowerSeries.C (c l j)
+  let E : Matrix I (Fin k) (PowerSeries F) :=
+    fun j l => PowerSeries.C (e l j)
+  let D : Matrix (Fin k) (Fin k) (PowerSeries F) :=
+    Matrix.diagonal (fun j => (q : PowerSeries F)^j.val)
+  let Zp : Matrix (Fin k) I F[X] := fun j t => numeratorRow q P u j.val t
+  let Z : Matrix (Fin k) I (PowerSeries F) :=
+    fun j t => (Zp j t : PowerSeries F)
+  have hHC : H = W * C := by
+    funext j l
+    change derivativeIter j.val (h l) =
+      ∑ t : Fin k, derivativeIter j.val (b t) * PowerSeries.C (c l t)
+    rw [← hc l, derivativeIter_sum]
+    simp only [derivativeIter_smul]
+    simp only [PowerSeries.smul_eq_C_mul]
+    apply Finset.sum_congr rfl
+    intro t _
+    exact mul_comm _ _
+  have hHE : W = H * E := by
+    funext j l
+    change derivativeIter j.val (b l) =
+      ∑ t : I, derivativeIter j.val (h t) * PowerSeries.C (e l t)
+    rw [← he l, derivativeIter_sum]
+    simp only [derivativeIter_smul]
+    simp only [PowerSeries.smul_eq_C_mul]
+    apply Finset.sum_congr rfl
+    intro t _
+    exact mul_comm _ _
+  have hZG : Z * G = D * H := by
+    funext j l
+    rw [Matrix.diagonal_mul]
+    exact (scaled_derivative_row q P u G hD j.val l).symm
+  have hDn : D.det ≠ 0 := by
+    rw [Matrix.det_diagonal]
+    apply Finset.prod_ne_zero_iff.mpr
+    intro j _
+    exact pow_ne_zero _ (Polynomial.coe_eq_zero_iff.not.mpr hqn)
+  obtain ⟨f, hfn, hdiv⟩ := exists_nonzero_divisible_minor Z H G D W C E hG hDn hbn hZG hHC hHE
+  let p : F[X] := (Zp.submatrix id f).det
+  have hpcoe : (p : PowerSeries F) = (Z.submatrix id f).det := by
+    exact RingHom.map_det Polynomial.coeToPowerSeries.ringHom (Zp.submatrix id f)
+  have hpn : p ≠ 0 := by
+    intro hp
+    apply hfn
+    rw [← hpcoe, hp, Polynomial.coe_zero]
+  have hdegree : p.natDegree ≤ (n-1) * k.choose 2 := by
+    calc
+      p.natDegree ≤ ∑ j : Fin k, j.val * (n-1) := by
+        apply natDegree_det_le_sum
+        intro j l
+        exact numeratorRow_degree hn q P u hq hP j.val (f l)
+      _ = (n-1) * k.choose 2 := by
+        rw [← Finset.sum_mul, sum_fin_eq_choose, mul_comm]
+  have horder : (wronskian b).order.toNat ≤ (n-1) * k.choose 2 := by
+    apply (order_le_natDegree_of_dvd (wronskian b) p hpn ?_).trans hdegree
+    rwa [hpcoe]
+  have hymem : systemScalarOutput u v G ∈ Submodule.span F (Set.range b) := by
+    apply Submodule.sum_mem
+    intro l _
+    change h l * PowerSeries.C (v l) ∈ _
+    rw [mul_comm, ← PowerSeries.smul_eq_C_mul]
+    exact Submodule.smul_mem _ _ (hhmem l)
+  have hybound := order_le_wronskian_add b hbn (systemScalarOutput u v G) hy hymem
+  have hkpos : 0 < k := by
+    by_contra hn
+    have hk0 : k = 0 := by omega
+    subst k
+    have : systemScalarOutput u v G = 0 := by simpa using hymem
+    exact hy this
+  have hchoose : k.choose 2 ≤ (Fintype.card I).choose 2 := Nat.choose_le_choose 2 hk
+  have hmul := Nat.mul_le_mul_left (n-1) hchoose
+  omega
+
+end NCHitting
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/FormulaHitting/NumeratorRows.lean b/lean/OAI/Algebra/FormulaHitting/NumeratorRows.lean
new file mode 100644
index 0000000000000000000000000000000000000000..9211800e51c9908c3b31d6c108d66d93299ad5f4
--- /dev/null
+++ b/lean/OAI/Algebra/FormulaHitting/NumeratorRows.lean
@@ -0,0 +1,69 @@
+import Mathlib.Algebra.Polynomial.Derivative
+import Mathlib.Algebra.Polynomial.BigOperators
+import Mathlib.Data.Matrix.Basic
+import Lean.Elab.Tactic.Omega
+
+namespace OAI
+
+noncomputable section
+
+namespace NCHitting
+
+open Polynomial
+
+variable {F : Type*} [Field F]
+
+def numeratorRow {I : Type*} [Fintype I] (q : F[X]) (P : Matrix I I F[X])
+    (u : I → F) : ℕ → I → F[X]
+  | 0, l => C (u l)
+  | j + 1, l => q * (numeratorRow q P u j l).derivative -
+      C (j : F) * q.derivative * numeratorRow q P u j l +
+      ∑ t : I, numeratorRow q P u j t * P t l
+
+private theorem degree_q_derivative {q p : F[X]} {n b : ℕ}
+    (hn : 0 < n) (hq : q.natDegree ≤ n) (hp : p.natDegree ≤ b) :
+    (q * p.derivative).natDegree ≤ b + (n-1) := by
+  by_cases hzero : p.natDegree = 0
+  · simp [Polynomial.derivative_of_natDegree_zero hzero]
+  · have hb : 0 < b := by omega
+    have hd := p.natDegree_derivative_le
+    have hm : (q * p.derivative).natDegree ≤ q.natDegree + p.derivative.natDegree :=
+      Polynomial.natDegree_mul_le
+    omega
+
+theorem numeratorRow_degree {I : Type*} [Fintype I] {n : ℕ} (hn : 0 < n)
+    (q : F[X]) (P : Matrix I I F[X]) (u : I → F)
+    (hq : q.natDegree ≤ n) (hP : ∀ t l, (P t l).natDegree ≤ n-1)
+    (j : ℕ) (l : I) :
+    (numeratorRow q P u j l).natDegree ≤ j * (n-1) := by
+  induction j generalizing l with
+  | zero => simp [numeratorRow]
+  | succ j ih =>
+    have ihall : ∀ l, (numeratorRow q P u j l).natDegree ≤ j * (n-1) := by
+      intro l'
+      exact ih l'
+    have ha := degree_q_derivative hn hq (ihall l)
+    have hb : (C (j : F) * q.derivative * numeratorRow q P u j l).natDegree ≤
+        j * (n-1) + (n-1) := by
+      have hq' : q.derivative.natDegree ≤ n-1 :=
+        q.natDegree_derivative_le.trans (Nat.sub_le_sub_right hq 1)
+      have hC := Polynomial.natDegree_C_mul_le (j : F) q.derivative
+      have hmul : (C (j : F) * q.derivative * numeratorRow q P u j l).natDegree ≤
+          (C (j : F) * q.derivative).natDegree + (numeratorRow q P u j l).natDegree :=
+        Polynomial.natDegree_mul_le
+      have hp := ihall l
+      omega
+    have hc : (∑ t : I, numeratorRow q P u j t * P t l).natDegree ≤
+        j * (n-1) + (n-1) := by
+      apply Polynomial.natDegree_sum_le_of_forall_le
+      intro t _
+      exact Polynomial.natDegree_mul_le.trans (Nat.add_le_add (ihall t) (hP t l))
+    rw [numeratorRow, Nat.add_mul, one_mul]
+    apply Polynomial.natDegree_add_le_of_degree_le _ hc
+    exact (Polynomial.natDegree_sub_le _ _).trans (max_le ha hb)
+
+end NCHitting
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/FormulaHitting/OrderBasis.lean b/lean/OAI/Algebra/FormulaHitting/OrderBasis.lean
new file mode 100644
index 0000000000000000000000000000000000000000..69bcda690c7bc59e4a08fdc4d54327a2dc088f41
--- /dev/null
+++ b/lean/OAI/Algebra/FormulaHitting/OrderBasis.lean
@@ -0,0 +1,157 @@
+import OAI.Algebra.FormulaHitting.Wronskian
+import Mathlib.LinearAlgebra.FiniteDimensional.Lemmas
+import Mathlib.LinearAlgebra.LinearIndependent.Lemmas
+
+namespace OAI
+
+noncomputable section
+
+namespace NCHitting
+
+open PowerSeries Submodule
+
+variable {F : Type*} [Field F] [CharZero F]
+
+def HasOrderBasis (V : Submodule F (PowerSeries F)) : Prop :=
+  ∃ (k : ℕ) (b : Fin k → PowerSeries F) (a : Fin k → ℕ),
+    LinearIndependent F b ∧ Submodule.span F (Set.range b) = V ∧
+      Function.Injective a ∧
+      (∀ i, PowerSeries.coeff (a i) (b i) ≠ 0) ∧
+      (∀ i r, r < a i → PowerSeries.coeff r (b i) = 0)
+
+omit [CharZero F] in
+theorem hasOrderBasis_bot : HasOrderBasis (⊥ : Submodule F (PowerSeries F)) := by
+  refine ⟨0, Fin.elim0, Fin.elim0, ?_, ?_, ?_, ?_, ?_⟩
+  · exact linearIndependent_empty_type
+  · simp
+  · intro i; exact Fin.elim0 i
+  · intro i; exact Fin.elim0 i
+  · intro i; exact Fin.elim0 i
+
+omit [CharZero F] in
+theorem hasOrderBasis_of_finrank_le (N : ℕ) :
+    ∀ (V : Submodule F (PowerSeries F)) [FiniteDimensional F V],
+      Module.finrank F V ≤ N → HasOrderBasis V := by
+  classical
+  induction N with
+  | zero =>
+    intro V _ hV
+    have he : V = ⊥ := Submodule.finrank_eq_zero.mp (Nat.eq_zero_of_le_zero hV)
+    rw [he]
+    exact hasOrderBasis_bot
+  | succ N ih =>
+    intro V _ hV
+    by_cases he : V = ⊥
+    · rw [he]; exact hasOrderBasis_bot
+    have hex : ∃ a : ℕ, ∃ v : PowerSeries F, v ∈ V ∧ PowerSeries.coeff a v ≠ 0 := by
+      obtain ⟨v, hv, hv0⟩ := Submodule.exists_mem_ne_zero_of_ne_bot he
+      have hc : ∃ a, PowerSeries.coeff a v ≠ 0 := by
+        by_contra h
+        push Not at h
+        apply hv0
+        ext a
+        simpa using h a
+      obtain ⟨a, ha⟩ := hc
+      exact ⟨a, v, hv, ha⟩
+    let a := Nat.find hex
+    obtain ⟨v, hv, hva⟩ := Nat.find_spec hex
+    have hlow : ∀ x ∈ V, ∀ r < a, PowerSeries.coeff r x = 0 := by
+      intro x hx r hr
+      by_contra hc
+      have hh := Nat.find_min' hex ⟨x, hx, hc⟩
+      omega
+    let W : Submodule F (PowerSeries F) := V ⊓ LinearMap.ker (PowerSeries.coeff a)
+    have hWlt : W < V := by
+      refine lt_of_le_of_ne inf_le_left ?_
+      intro h
+      have hvW : v ∈ W := h.symm ▸ hv
+      exact hva ((LinearMap.mem_ker.mp hvW.2))
+    have hdim : Module.finrank F W ≤ N := by
+      have hlt := Submodule.finrank_lt_finrank_of_lt hWlt
+      omega
+    obtain ⟨k, b, aa, hli, hspan, hinj, hlead, hzero⟩ := ih W hdim
+    have hbW : ∀ i, b i ∈ W := by
+      intro i
+      rw [← hspan]
+      exact Submodule.subset_span ⟨i, rfl⟩
+    have hvnot : v ∉ Submodule.span F (Set.range b) := by
+      rw [hspan]
+      intro h
+      exact hva (LinearMap.mem_ker.mp h.2)
+    have hneq : ∀ i, a ≠ aa i := by
+      intro i hi
+      exact hlead i (hi ▸ LinearMap.mem_ker.mp (hbW i).2)
+    refine ⟨k+1, Fin.cons v b, Fin.cons a aa, hli.finCons hvnot, ?_, ?_, ?_, ?_⟩
+    · apply le_antisymm
+      · apply Submodule.span_le.mpr
+        rintro x ⟨i, rfl⟩
+        refine Fin.cases ?_ (fun j => ?_) i
+        · simpa using hv
+        · simpa using (hbW j).1
+      · intro x hx
+        let c : F := PowerSeries.coeff a x / PowerSeries.coeff a v
+        have hy : x - c • v ∈ W := by
+          constructor
+          · exact V.sub_mem hx (V.smul_mem c hv)
+          · apply LinearMap.mem_ker.mpr
+            simp only [map_sub, map_smul, smul_eq_mul, c]
+            rw [div_mul_cancel₀ _ hva, sub_self]
+        have hvm : v ∈ Submodule.span F (Set.range (Fin.cons v b)) :=
+          Submodule.subset_span ⟨0, rfl⟩
+        have hym : x - c • v ∈ Submodule.span F (Set.range (Fin.cons v b)) := by
+          apply (Submodule.span_mono (s := Set.range b) ?_)
+          · rwa [hspan]
+          · rintro y ⟨j, rfl⟩
+            exact ⟨j.succ, rfl⟩
+        have := Submodule.add_mem (Submodule.span F (Set.range (Fin.cons v b)))
+          hym (Submodule.smul_mem _ c hvm)
+        simpa using this
+    · intro i j
+      refine Fin.cases ?_ (fun i' => ?_) i
+      · refine Fin.cases ?_ (fun j' => ?_) j
+        · intro _; rfl
+        · intro hij; exact (hneq j' (by simpa using hij)).elim
+      · refine Fin.cases ?_ (fun j' => ?_) j
+        · intro hij; exact (hneq i' (by simpa using hij.symm)).elim
+        · intro hij
+          have hij' : aa i' = aa j' := by simpa using hij
+          exact congrArg Fin.succ (hinj hij')
+    · intro i
+      exact Fin.cases hva hlead i
+    · intro i
+      exact Fin.cases (hlow v hv) hzero i
+
+omit [CharZero F] in
+theorem hasOrderBasis (V : Submodule F (PowerSeries F)) [FiniteDimensional F V] :
+    HasOrderBasis V := hasOrderBasis_of_finrank_le (Module.finrank F V) V le_rfl
+
+theorem wronskian_ne_zero_of_linearIndependent {k : ℕ}
+    (f : Fin k → PowerSeries F) (hf : LinearIndependent F f) : wronskian f ≠ 0 := by
+  classical
+  let := FiniteDimensional.span_of_finite F (Set.finite_range f)
+  obtain ⟨l, b, a, hb, hspan, ha, hlead, hzero⟩ := hasOrderBasis (Submodule.span F (Set.range f))
+  have hdimf : Module.finrank F (Submodule.span F (Set.range f)) = k := by
+    simpa using finrank_span_eq_card hf
+  have hdimb : Module.finrank F (Submodule.span F (Set.range b)) = l := by
+    simpa using finrank_span_eq_card hb
+  rw [hspan, hdimf] at hdimb
+  subst l
+  have hm : ∀ j, ∃ c : Fin k → F, ∑ i : Fin k, c i • f i = b j := by
+    intro j
+    apply (Submodule.mem_span_range_iff_exists_fun F).mp
+    rw [← hspan]
+    exact Submodule.subset_span ⟨j, rfl⟩
+  choose c hc using hm
+  have hfn : (fun j => ∑ i : Fin k, c j i • f i) = b := funext hc
+  have he := wronskian_linearCombination f (fun i j => c j i)
+  rw [hfn] at he
+  have hbn := (wronskian_order_sum b a ha hlead hzero).1
+  intro h
+  rw [h, zero_mul] at he
+  exact hbn he
+
+end NCHitting
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/FormulaHitting/OutputBounds.lean b/lean/OAI/Algebra/FormulaHitting/OutputBounds.lean
new file mode 100644
index 0000000000000000000000000000000000000000..6e422266758322e4ee64fde0c446fc0375156cd8
--- /dev/null
+++ b/lean/OAI/Algebra/FormulaHitting/OutputBounds.lean
@@ -0,0 +1,154 @@
+import OAI.Algebra.FormulaHitting.Program
+
+namespace OAI
+
+namespace NCHitting
+
+open BitModel
+
+private theorem length_flatMap_uniform {α β : Type*} (xs : List α) (f : α → List β)
+    (k : ℕ) (h : ∀ x ∈ xs, (f x).length = k) :
+    (xs.flatMap f).length = xs.length * k := by
+  induction xs with
+  | nil => simp
+  | cons x xs ih =>
+    have hx := h x (by simp)
+    have hxs : ∀ y ∈ xs, (f y).length = k := by
+      intro y hy
+      exact h y (by simp [hy])
+    simp only [List.flatMap_cons, List.length_append, List.length_cons]
+    rw [hx, ih hxs, Nat.add_mul]
+    omega
+
+private theorem getElem?_flatMap_uniform {α β : Type*} (xs : List α) (f : α → List β)
+    (k : ℕ) (h : ∀ x ∈ xs, (f x).length = k) (i j : ℕ) (hj : j < k) :
+    (xs.flatMap f)[i * k + j]? = xs[i]?.bind (fun x => (f x)[j]?) := by
+  induction xs generalizing i with
+  | nil => simp
+  | cons x xs ih =>
+    have hx := h x (by simp)
+    have hxs : ∀ y ∈ xs, (f y).length = k := by
+      intro y hy
+      exact h y (by simp [hy])
+    cases i with
+    | zero =>
+      simp only [Nat.zero_mul, Nat.zero_add, List.flatMap_cons,
+        List.getElem?_cons_zero, Option.bind_some]
+      exact List.getElem?_append_left (by omega)
+    | succ i =>
+      have hlarge : (f x).length ≤ (i + 1) * k + j := by
+        rw [hx, Nat.add_mul]
+        omega
+      have hindex : (i + 1) * k + j - (f x).length = i * k + j := by
+        rw [hx, Nat.add_mul]
+        omega
+      simp only [List.flatMap_cons, List.getElem?_cons_succ]
+      rw [List.getElem?_append_right hlarge, hindex]
+      exact ih hxs i
+
+private theorem rows_length (d i : ℕ) :
+    ((List.range d).flatMap fun r => (List.range d).map fun q => encodedEntry i r q).length = d * d := by
+  apply (length_flatMap_uniform (List.range d) _ d ?_).trans
+  · simp
+  · intro r hr
+    simp
+
+theorem generate_output_length (n s : ℕ) :
+    (generate n s).output.length = n * dimension n s * dimension n s := by
+  rw [generate_output]
+  by_cases h : n = 1 ∧ s = 1
+  · rcases h with ⟨rfl, rfl⟩
+    simp [encodedOutput, dimension]
+  · simp only [encodedOutput, ite_eq_right h, dimension]
+    have hl := length_flatMap_uniform (List.range n)
+      (fun i => (List.range (2 * n * s ^ 2)).flatMap fun r =>
+        (List.range (2 * n * s ^ 2)).map fun q => encodedEntry i r q)
+      ((2 * n * s ^ 2) * (2 * n * s ^ 2)) (fun i _ => rows_length _ i)
+    simp [Nat.mul_assoc] at hl ⊢
+
+theorem encodedEntry_numerator_le (i r q : ℕ) : (encodedEntry i r q).numerator ≤ 1 := by
+  unfold encodedEntry
+  split_ifs <;> simp
+
+theorem encodedEntry_denominator_size_le {n d i r q : ℕ} (hi : i < n) (hr : r < d) :
+    (encodedEntry i r q).denominator.size ≤ entryBitBound n d := by
+  unfold encodedEntry
+  split_ifs with h
+  · exact denominator_size_le (q := q) (Nat.succ_le_of_lt hi) hr
+  · simp only [Nat.size_one]
+    unfold entryBitBound
+    omega
+
+theorem generate_entry_bounds {n s : ℕ} (entry : RationalCode)
+    (hentry : entry ∈ (generate n s).output) :
+    0 < entry.denominator ∧ entry.numerator ≤ 1 ∧
+      entry.denominator.size ≤ entryBitBound n (dimension n s) ∧
+      entry.bits ≤ 4 + entryBitBound n (dimension n s) := by
+  rw [generate_output] at hentry
+  by_cases h : n = 1 ∧ s = 1
+  · rcases h with ⟨rfl, rfl⟩
+    simp only [encodedOutput, and_self, ite_true, List.mem_singleton] at hentry
+    subst entry
+    norm_num [dimension, entryBitBound, RationalCode.bits, width]
+  · simp only [encodedOutput, ite_eq_right h, List.mem_flatMap, List.mem_map, List.mem_range] at hentry
+    obtain ⟨i, hi, r, hr, q, hq, rfl⟩ := hentry
+    have hd : dimension n s = 2 * n * s ^ 2 := by simp [dimension, h]
+    rw [hd]
+    exact ⟨encodedEntry_denominator_pos i r q, encodedEntry_numerator_le i r q,
+      encodedEntry_denominator_size_le hi hr, encodedEntry_bits_le hi hr⟩
+
+private theorem flattened_entry {n d i r q : ℕ} (hi : i < n) (hr : r < d) (hq : q < d) :
+    ((List.range n).flatMap fun i => (List.range d).flatMap fun r =>
+      (List.range d).map fun q => encodedEntry i r q)[i * d * d + r * d + q]? =
+        some (encodedEntry i r q) := by
+  have hj : r * d + q < d * d := by
+    calc
+      r * d + q < r * d + d := Nat.add_lt_add_left hq _
+      _ = (r + 1) * d := by rw [Nat.add_mul]; omega
+      _ ≤ d * d := Nat.mul_le_mul_right d (by omega)
+  have hout := getElem?_flatMap_uniform (List.range n)
+    (fun i => (List.range d).flatMap fun r => (List.range d).map fun q => encodedEntry i r q)
+    (d * d) (fun i _ => rows_length d i) i (r * d + q) hj
+  rw [List.getElem?_range hi] at hout
+  simp only [Option.bind_some] at hout
+  have hin := getElem?_flatMap_uniform (List.range d)
+    (fun r => (List.range d).map fun q => encodedEntry i r q)
+    d (by intro r _; simp) r q hq
+  rw [List.getElem?_range hr] at hin
+  simp only [Option.bind_some] at hin
+  rw [List.getElem?_map, List.getElem?_range hq] at hin
+  simp only [Option.map_some] at hin
+  simpa only [Nat.mul_assoc, Nat.add_assoc] using hout.trans hin
+
+theorem generate_entry_code {n s i r q : ℕ} (hi : i < n)
+    (hr : r < dimension n s) (hq : q < dimension n s) :
+    (generate n s).output[i * dimension n s * dimension n s + r * dimension n s + q]? =
+      some (if n = 1 ∧ s = 1 then ⟨false, 1, 1⟩ else encodedEntry i r q) := by
+  rw [generate_output]
+  by_cases h : n = 1 ∧ s = 1
+  · rcases h with ⟨rfl, rfl⟩
+    have hi0 : i = 0 := by omega
+    have hr0 : r = 0 := by simpa [dimension] using hr
+    have hq0 : q = 0 := by simpa [dimension] using hq
+    subst i
+    subst r
+    subst q
+    simp [encodedOutput, dimension]
+  · have hd : dimension n s = 2 * n * s ^ 2 := by simp [dimension, h]
+    rw [hd] at hr hq ⊢
+    simp only [encodedOutput, ite_eq_right h]
+    exact flattened_entry hi hr hq
+
+theorem generate_entry_decode (n s : ℕ) (i : Fin n) (r q : Fin (dimension n s)) :
+    decode (((generate n s).output[i.val * dimension n s * dimension n s +
+      r.val * dimension n s + q.val]?).getD ⟨false, 0, 1⟩) = generator n s i r q := by
+  rw [generate_entry_code i.isLt r.isLt q.isLt]
+  simp only [Option.getD_some]
+  by_cases h : n = 1 ∧ s = 1
+  · simp [h, generator, decode]
+  · simp only [generator, ite_eq_right h]
+    exact decode_encodedEntry i.val r.val q.val
+
+end NCHitting
+
+end OAI
diff --git a/lean/OAI/Algebra/FormulaHitting/Program.lean b/lean/OAI/Algebra/FormulaHitting/Program.lean
new file mode 100644
index 0000000000000000000000000000000000000000..518311e8f4da76779d651f815d45a65ff9950e86
--- /dev/null
+++ b/lean/OAI/Algebra/FormulaHitting/Program.lean
@@ -0,0 +1,101 @@
+import OAI.Algebra.FormulaHitting.Generator
+import OAI.Algebra.FormulaHitting.BitModel
+
+namespace OAI
+
+namespace NCHitting
+
+open BitModel
+
+def dimensionExpr (nRegister sRegister : ℕ) : Expr :=
+  .mul (.mul (.literal 2) (.read nRegister)) (.power (.read sRegister) (.literal 2))
+
+def entryProgram : Program :=
+  .branch (.less (.read 0) (.read 1))
+    (.emit (.odd (.sub (.sub (.read 1) (.read 0)) (.literal 1)))
+      (.literal 1)
+      (.mul (.read 1) (.power (.add (.read 2) (.literal 1))
+        (.sub (.read 1) (.read 0)))))
+    (.emit (.literal 0) (.literal 0) (.literal 1))
+
+def rowProgram : Program := .loop (dimensionExpr 2 3) entryProgram
+
+def variableProgram : Program := .loop (dimensionExpr 1 2) rowProgram
+
+def generatorProgram : Program :=
+  .branch (.mul (.equal (.read 0) (.literal 1)) (.equal (.read 1) (.literal 1)))
+    (.emit (.literal 0) (.literal 1) (.literal 1))
+    (.loop (.read 0) variableProgram)
+
+def encodedEntry (i r q : ℕ) : BitModel.RationalCode :=
+  if q < r then ⟨decide ((r-q-1) % 2 = 1), 1, r * (i+1)^(r-q)⟩
+  else ⟨false, 0, 1⟩
+
+def encodedOutput (n s : ℕ) : List BitModel.RationalCode :=
+  if n = 1 ∧ s = 1 then [⟨false, 1, 1⟩]
+  else (List.range n).flatMap fun i =>
+    (List.range (2*n*s^2)).flatMap fun r =>
+      (List.range (2*n*s^2)).map fun q => encodedEntry i r q
+
+def generate (n s : ℕ) : ProgramResult := BitModel.execute generatorProgram [n, s]
+
+theorem entryProgram_output (n s i r q : ℕ) :
+    (entryProgram.run [q,r,i,n,s]).output = [encodedEntry i r q] := by
+  by_cases h : q < r <;>
+    simp [entryProgram, Program.run, Expr.run, encodedEntry, h]
+
+theorem rowProgram_output (n s i r : ℕ) :
+    (rowProgram.run [r,i,n,s]).output =
+      (List.range (2*n*s^2)).map (encodedEntry i r) := by
+  simp [rowProgram, Program.run, dimensionExpr, Expr.run, List.flatMap_map,
+    entryProgram_output, ← List.map_eq_flatMap]
+
+theorem variableProgram_output (n s i : ℕ) :
+    (variableProgram.run [i,n,s]).output =
+      (List.range (2*n*s^2)).flatMap fun r =>
+        (List.range (2*n*s^2)).map (encodedEntry i r) := by
+  simp [variableProgram, Program.run, dimensionExpr, Expr.run, List.flatMap_map,
+    rowProgram_output]
+
+theorem generate_output (n s : ℕ) : (generate n s).output = encodedOutput n s := by
+  by_cases hn : n = 1 <;> by_cases hs : s = 1 <;>
+    simp [generate, BitModel.execute, generatorProgram, Program.run, Expr.run,
+      hn, hs, List.flatMap_map, variableProgram_output, encodedOutput]
+
+theorem encodedEntry_denominator_pos (i r q : ℕ) :
+    0 < (encodedEntry i r q).denominator := by
+  unfold encodedEntry
+  split_ifs with h
+  · simp only
+    apply Nat.mul_pos (by omega)
+    exact pow_pos (by omega) _
+  · decide
+
+def decode (entry : BitModel.RationalCode) : ℚ :=
+  (if entry.negative then -(entry.numerator : ℚ) else entry.numerator) / entry.denominator
+
+theorem decode_encodedEntry (i r q : ℕ) :
+    decode (encodedEntry i r q) = matrixEntry (i+1) r q := by
+  by_cases h : q < r
+  · simp only [encodedEntry, ite_eq_left h, decode, matrixEntry]
+    rw [neg_one_pow_eq_pow_mod_two]
+    by_cases hm : (r-q-1) % 2 = 1
+    · simp [hm, Nat.cast_mul, Nat.cast_pow]
+    · have hz : (r-q-1) % 2 = 0 := by omega
+      simp [hz, Nat.cast_mul, Nat.cast_pow]
+  · simp [encodedEntry, decode, matrixEntry, h]
+
+theorem encodedEntry_bits_le {n d i r q : ℕ} (hi : i < n) (hr : r < d) :
+    (encodedEntry i r q).bits ≤ 4 + entryBitBound n d := by
+  unfold encodedEntry
+  split_ifs with h
+  · have hb := denominator_size_le (i := i+1) (q := q) (show i+1 ≤ n by omega) hr
+    simp only [BitModel.RationalCode.bits, BitModel.width, Nat.size_one]
+    omega
+  · simp only [BitModel.RationalCode.bits, BitModel.width, Nat.size_one, Nat.size_zero]
+    unfold entryBitBound
+    omega
+
+end NCHitting
+
+end OAI
diff --git a/lean/OAI/Algebra/FormulaHitting/ProgramCost.lean b/lean/OAI/Algebra/FormulaHitting/ProgramCost.lean
new file mode 100644
index 0000000000000000000000000000000000000000..b09213c9acd6be8fcc72ca96372ac0ddf81c8d44
--- /dev/null
+++ b/lean/OAI/Algebra/FormulaHitting/ProgramCost.lean
@@ -0,0 +1,349 @@
+import Mathlib.Data.Nat.Size
+import OAI.Algebra.FormulaHitting.BitModel
+import Lean.Elab.Tactic.Omega
+
+namespace OAI
+
+namespace NCHitting.BitModel
+
+private theorem bitSize_le_self (a : ℕ) : a.size ≤ a := by
+  apply Nat.size_le.mpr
+  exact Nat.lt_two_pow_self
+
+private theorem bitSize_mul_le (a b : ℕ) : (a * b).size ≤ a.size + b.size := by
+  apply Nat.size_le.mpr
+  rw [pow_add]
+  exact Nat.mul_lt_mul_of_lt_of_lt (Nat.lt_size_self a) (Nat.lt_size_self b)
+
+private theorem bitSize_pow_le (a k : ℕ) : (a ^ k).size ≤ 1 + k * a.size := by
+  induction k with
+  | zero => simp
+  | succ k ih =>
+    calc
+      (a ^ (k + 1)).size = (a ^ k * a).size := by rw [pow_succ]
+      _ ≤ (a ^ k).size + a.size := bitSize_mul_le _ _
+      _ ≤ 1 + (k + 1) * a.size := by rw [Nat.add_mul]; omega
+
+def powerStepBound (M : ℕ) : ℕ :=
+  8 * (M * M + 2) * (M + 1) + 4 * (M + 3) + 1
+
+theorem width_le_of_le {a M : ℕ} (ha : a ≤ M) : width a ≤ M + 1 := by
+  exact Nat.add_le_add_right (Nat.le_trans (bitSize_le_self a) ha) 1
+
+theorem powerRun_cost_le {base k M : ℕ} (hb : base ≤ M) (hk : k ≤ M) :
+    (powerRun base k).cost ≤ 2 + k * powerStepBound M := by
+  induction k with
+  | zero => simp [powerRun, width]
+  | succ k ih =>
+    have hk' : k ≤ M := by omega
+    have hbase : base.size ≤ M := (bitSize_le_self base).trans hb
+    have hpow : width (base ^ k) ≤ M * M + 2 := by
+      have h := bitSize_pow_le base k
+      have hm : k * base.size ≤ M * M := Nat.mul_le_mul hk' hbase
+      unfold width
+      omega
+    have hwbase : width base ≤ M + 1 := width_le_of_le hb
+    have hwk : width k ≤ M + 1 := width_le_of_le hk'
+    have hmul : mulCost (base ^ k) base ≤ 8 * (M * M + 2) * (M + 1) := by
+      unfold mulCost
+      exact Nat.mul_le_mul (Nat.mul_le_mul_left 8 hpow) hwbase
+    have hadd : addCost k 1 ≤ 4 * (M + 3) := by
+      unfold addCost
+      have : width 1 = 2 := rfl
+      rw [this]
+      exact Nat.mul_le_mul_left 4 (by omega)
+    have hstep : mulCost (base ^ k) base + addCost k 1 + 1 ≤ powerStepBound M := by
+      unfold powerStepBound
+      omega
+    simp only [powerRun, powerRun_value]
+    calc
+      (powerRun base k).cost + mulCost (base ^ k) base + addCost k 1 + 1
+          ≤ (2 + k * powerStepBound M) + powerStepBound M := by
+        have hprevious := ih hk'
+        omega
+      _ = 2 + (k + 1) * powerStepBound M := by rw [Nat.add_mul]; omega
+
+theorem sum_map_le_length_mul {α : Type*} (xs : List α) (f : α → ℕ) (C : ℕ)
+    (h : ∀ x ∈ xs, f x ≤ C) : (xs.map f).sum ≤ xs.length * C := by
+  induction xs with
+  | nil => simp
+  | cons x xs ih =>
+    have hx := h x (by simp)
+    have hxs : ∀ y ∈ xs, f y ≤ C := by
+      intro y hy
+      exact h y (by simp [hy])
+    have ht := ih hxs
+    simp only [List.map_cons, List.sum_cons, List.length_cons, Nat.add_mul]
+    omega
+
+theorem outputBits_append (xs ys : List RationalCode) :
+    outputBits (xs ++ ys) = outputBits xs + outputBits ys := by
+  simp [outputBits]
+
+theorem outputBits_flatMap {α : Type*} (xs : List α) (f : α → List RationalCode) :
+    outputBits (xs.flatMap f) = (xs.map fun x => outputBits (f x)).sum := by
+  induction xs with
+  | nil => rfl
+  | cons x xs ih => simp [outputBits_append, ih]
+
+def loopControlBound (M : ℕ) : ℕ := M + 1 + 4 * (M + 3) + 1
+
+theorem loop_control_le {index M : ℕ} (hi : index ≤ M) :
+    width index + addCost index 1 + 1 ≤ loopControlBound M := by
+  have hw := width_le_of_le hi
+  have h1 : width 1 = 2 := rfl
+  unfold addCost loopControlBound
+  rw [h1]
+  omega
+
+theorem loop_cost_le (environment : List ℕ) (bound : Expr) (body : Program)
+    (M B C O : ℕ)
+    (hvalue : (bound.run environment).value ≤ M)
+    (hbound : (bound.run environment).cost ≤ B)
+    (hbody : ∀ index < (bound.run environment).value,
+      (body.run (index :: environment)).cost ≤ C ∧
+      outputBits (body.run (index :: environment)).output ≤ O) :
+    ((Program.loop bound body).run environment).cost ≤
+      B + 1 + (bound.run environment).value * (C + loopControlBound M + O) := by
+  simp only [Program.run, List.map_map, Function.comp_def]
+  have hsum := sum_map_le_length_mul
+    (List.range (bound.run environment).value)
+    (fun index => (body.run (index :: environment)).cost +
+      (width index + addCost index 1 + 1) +
+      outputBits (body.run (index :: environment)).output)
+    (C + loopControlBound M + O) (by
+      intro index hindex
+      have hi : index < (bound.run environment).value := List.mem_range.mp hindex
+      obtain ⟨hc, ho⟩ := hbody index hi
+      have hcontrol := loop_control_le (M := M) (by omega : index ≤ M)
+      omega)
+  simp only [List.length_range] at hsum
+  omega
+
+theorem loop_outputBits_le (environment : List ℕ) (bound : Expr) (body : Program)
+    (O : ℕ)
+    (hbody : ∀ index < (bound.run environment).value,
+      outputBits (body.run (index :: environment)).output ≤ O) :
+    outputBits ((Program.loop bound body).run environment).output ≤
+      (bound.run environment).value * O := by
+  simp only [Program.run, List.flatMap_map]
+  rw [outputBits_flatMap]
+  have hsum := sum_map_le_length_mul
+    (List.range (bound.run environment).value)
+    (fun index => outputBits (body.run (index :: environment)).output) O (by
+      intro index hindex
+      exact hbody index (List.mem_range.mp hindex))
+  simpa only [List.length_range] using hsum
+
+def expressionBudget (M B R : ℕ) : ℕ :=
+  R + 8 * B * B + 8 * B + (2 + M * powerStepBound M) + 10
+
+def Expr.nodes : Expr → ℕ
+  | .literal _ | .read _ => 1
+  | .add a b | .sub a b | .mul a b | .power a b | .less a b | .equal a b =>
+      a.nodes + b.nodes + 1
+  | .odd a => a.nodes + 1
+
+def Expr.Bounded (environment : List ℕ) (M B R : ℕ) : Expr → Prop
+  | .literal n => width n ≤ B ∧ True
+  | .read index =>
+      width ((Expr.read index).run environment).value ≤ B ∧
+        ((Expr.read index).run environment).cost ≤ R
+  | .add a b => width ((Expr.add a b).run environment).value ≤ B ∧
+      a.Bounded environment M B R ∧ b.Bounded environment M B R
+  | .sub a b => width ((Expr.sub a b).run environment).value ≤ B ∧
+      a.Bounded environment M B R ∧ b.Bounded environment M B R
+  | .mul a b => width ((Expr.mul a b).run environment).value ≤ B ∧
+      a.Bounded environment M B R ∧ b.Bounded environment M B R
+  | .less a b => width ((Expr.less a b).run environment).value ≤ B ∧
+      a.Bounded environment M B R ∧ b.Bounded environment M B R
+  | .equal a b => width ((Expr.equal a b).run environment).value ≤ B ∧
+      a.Bounded environment M B R ∧ b.Bounded environment M B R
+  | .power a b => width ((Expr.power a b).run environment).value ≤ B ∧
+      a.Bounded environment M B R ∧ b.Bounded environment M B R ∧
+        (a.run environment).value ≤ M ∧ (b.run environment).value ≤ M
+  | .odd a => width ((Expr.odd a).run environment).value ≤ B ∧
+      a.Bounded environment M B R
+
+theorem Expr.bounded_width {environment : List ℕ} {M B R : ℕ} {e : Expr}
+    (h : e.Bounded environment M B R) : width (e.run environment).value ≤ B := by
+  cases e <;> exact h.1
+
+private theorem addCost_le_budget {a b M B R : ℕ}
+    (ha : width a ≤ B) (hb : width b ≤ B) :
+    addCost a b + 1 ≤ expressionBudget M B R := by
+  unfold addCost expressionBudget
+  omega
+
+private theorem mulCost_le_budget {a b M B R : ℕ}
+    (ha : width a ≤ B) (hb : width b ≤ B) :
+    mulCost a b + 1 ≤ expressionBudget M B R := by
+  have hm : 8 * width a * width b ≤ 8 * B * B :=
+    Nat.mul_le_mul (Nat.mul_le_mul_left 8 ha) hb
+  unfold mulCost expressionBudget
+  omega
+
+private theorem compareCost_le_budget {a b M B R : ℕ}
+    (ha : width a ≤ B) (hb : width b ≤ B) :
+    compareCost a b + 1 ≤ expressionBudget M B R := by
+  unfold compareCost expressionBudget
+  omega
+
+theorem Expr.cost_le_nodes_budget (environment : List ℕ) (M B R : ℕ) (e : Expr) :
+    e.Bounded environment M B R →
+      (e.run environment).cost ≤ e.nodes * expressionBudget M B R := by
+  induction e with
+  | literal n =>
+    intro h
+    have hw := h.1
+    simp only [Expr.run, Expr.nodes, Nat.one_mul]
+    unfold expressionBudget
+    omega
+  | read index =>
+    intro h
+    have hr := h.2
+    simp only [Expr.nodes, Nat.one_mul]
+    unfold expressionBudget
+    omega
+  | add a b iha ihb =>
+    intro h
+    obtain ⟨ha, hb⟩ := h.2
+    have hca := iha ha
+    have hcb := ihb hb
+    have hc := addCost_le_budget (M := M) (R := R) (Expr.bounded_width ha) (Expr.bounded_width hb)
+    simp only [Expr.run, Expr.nodes, Nat.add_mul, Nat.one_mul]
+    omega
+  | sub a b iha ihb =>
+    intro h
+    obtain ⟨ha, hb⟩ := h.2
+    have hca := iha ha
+    have hcb := ihb hb
+    have hc := addCost_le_budget (M := M) (R := R) (Expr.bounded_width ha) (Expr.bounded_width hb)
+    simp only [Expr.run, Expr.nodes, Nat.add_mul, Nat.one_mul]
+    omega
+  | mul a b iha ihb =>
+    intro h
+    obtain ⟨ha, hb⟩ := h.2
+    have hca := iha ha
+    have hcb := ihb hb
+    have hc := mulCost_le_budget (M := M) (R := R) (Expr.bounded_width ha) (Expr.bounded_width hb)
+    simp only [Expr.run, Expr.nodes, Nat.add_mul, Nat.one_mul]
+    omega
+  | power a b iha ihb =>
+    intro h
+    obtain ⟨ha, hb, hav, hbv⟩ := h.2
+    have hca := iha ha
+    have hcb := ihb hb
+    have hp := powerRun_cost_le hav hbv
+    have hm := Nat.mul_le_mul_right (powerStepBound M) hbv
+    have hc : (powerRun (a.run environment).value (b.run environment).value).cost + 1 ≤
+        expressionBudget M B R := by unfold expressionBudget; omega
+    simp only [Expr.run, Expr.nodes, Nat.add_mul, Nat.one_mul]
+    omega
+  | less a b iha ihb =>
+    intro h
+    obtain ⟨ha, hb⟩ := h.2
+    have hca := iha ha
+    have hcb := ihb hb
+    have hc := compareCost_le_budget (M := M) (R := R) (Expr.bounded_width ha) (Expr.bounded_width hb)
+    simp only [Expr.run, Expr.nodes, Nat.add_mul, Nat.one_mul]
+    omega
+  | equal a b iha ihb =>
+    intro h
+    obtain ⟨ha, hb⟩ := h.2
+    have hca := iha ha
+    have hcb := ihb hb
+    have hc := compareCost_le_budget (M := M) (R := R) (Expr.bounded_width ha) (Expr.bounded_width hb)
+    simp only [Expr.run, Expr.nodes, Nat.add_mul, Nat.one_mul]
+    omega
+  | odd a iha =>
+    intro h
+    have hca := iha h.2
+    have hc : 2 ≤ expressionBudget M B R := by unfold expressionBudget; omega
+    simp only [Expr.run, Expr.nodes, Nat.add_mul, Nat.one_mul]
+    omega
+
+theorem width_mul_le (a b : ℕ) : width (a * b) ≤ width a + width b := by
+  have h := bitSize_mul_le a b
+  unfold width
+  omega
+
+theorem width_pow_le (a k : ℕ) : width (a ^ k) ≤ 2 + k * a.size := by
+  have h := bitSize_pow_le a k
+  unfold width
+  omega
+
+def registerReadBound (M : ℕ) : ℕ := 5 * (M + 1) + 6
+
+def intermediateWidthBound (M : ℕ) : ℕ := M * M + 4 * M + 10
+
+theorem small_width {a M : ℕ} (ha : a ≤ M) : width a ≤ intermediateWidthBound M := by
+  have h := width_le_of_le ha
+  unfold intermediateWidthBound
+  omega
+
+theorem Expr.bounded_literal {environment : List ℕ} {a M : ℕ} (ha : a ≤ M) :
+    (Expr.literal a).Bounded environment M (intermediateWidthBound M) (registerReadBound M) := by
+  exact ⟨small_width ha, trivial⟩
+
+theorem Expr.bounded_read {environment : List ℕ} {M index : ℕ}
+    (hlen : environment.length ≤ 5) (hindex : index ≤ 4)
+    (henv : ∀ a ∈ environment, a ≤ M) :
+    (Expr.read index).Bounded environment M
+      (intermediateWidthBound M) (registerReadBound M) := by
+  have hvalue : environment[index]?.getD 0 ≤ M := by
+    cases h : environment[index]? with
+    | none => simp
+    | some a => simpa [h] using henv a (List.mem_of_getElem? h)
+  refine ⟨small_width hvalue, ?_⟩
+  have hiwidth := width_le_of_le hindex
+  have hprefix : (environment.take (index + 1)).length ≤ 5 := by
+    simp only [List.length_take]
+    exact (Nat.min_le_right _ _).trans hlen
+  have hsum := sum_map_le_length_mul (environment.take (index + 1)) width (M + 1) (by
+    intro a ha
+    exact width_le_of_le (henv a (List.mem_of_mem_take ha)))
+  have hm := Nat.mul_le_mul_right (M + 1) hprefix
+  change width index + listBits (environment.take (index + 1)) + 1 ≤ registerReadBound M
+  unfold listBits registerReadBound
+  omega
+
+theorem emit_cost_le (environment : List ℕ) (sign numerator denominator : Expr)
+    (S N D A B : ℕ)
+    (hs : (sign.run environment).cost ≤ S)
+    (hn : (numerator.run environment).cost ≤ N)
+    (hd : (denominator.run environment).cost ≤ D)
+    (ha : width (numerator.run environment).value ≤ A)
+    (hb : width (denominator.run environment).value ≤ B) :
+    ((Program.emit sign numerator denominator).run environment).cost ≤
+      S + N + D + (1 + A + B) + 2 := by
+  simp only [Program.run, RationalCode.bits]
+  omega
+
+theorem emit_outputBits_le (environment : List ℕ) (sign numerator denominator : Expr)
+    (A B : ℕ)
+    (ha : width (numerator.run environment).value ≤ A)
+    (hb : width (denominator.run environment).value ≤ B) :
+    outputBits ((Program.emit sign numerator denominator).run environment).output ≤
+      1 + A + B := by
+  simp only [Program.run, outputBits, List.map_cons, List.map_nil, List.sum_cons,
+    List.sum_nil, Nat.add_zero, RationalCode.bits]
+  omega
+
+theorem branch_cost_le (environment : List ℕ) (test : Expr) (yes no : Program)
+    (T C : ℕ) (ht : (test.run environment).cost ≤ T)
+    (hy : (yes.run environment).cost ≤ C) (hn : (no.run environment).cost ≤ C) :
+    ((Program.branch test yes no).run environment).cost ≤ T + C + 1 := by
+  simp only [Program.run]
+  split <;> omega
+
+theorem branch_outputBits_le (environment : List ℕ) (test : Expr) (yes no : Program)
+    (O : ℕ) (hy : outputBits (yes.run environment).output ≤ O)
+    (hn : outputBits (no.run environment).output ≤ O) :
+    outputBits ((Program.branch test yes no).run environment).output ≤ O := by
+  simp only [Program.run]
+  split <;> assumption
+
+end NCHitting.BitModel
+
+end OAI
diff --git a/lean/OAI/Algebra/FormulaHitting/RationalMinor.lean b/lean/OAI/Algebra/FormulaHitting/RationalMinor.lean
new file mode 100644
index 0000000000000000000000000000000000000000..f8b0c68d0c74966be41b27955ea7f8b06c3ecf54
--- /dev/null
+++ b/lean/OAI/Algebra/FormulaHitting/RationalMinor.lean
@@ -0,0 +1,50 @@
+import OAI.Algebra.FormulaHitting.RationalTransfer
+import OAI.Algebra.FormulaHitting.Minors
+import Mathlib.LinearAlgebra.Matrix.ToLin
+
+namespace OAI
+
+noncomputable section
+namespace NCHitting
+
+open Matrix
+
+variable {ι : Type*} [Fintype ι] [DecidableEq ι]
+
+theorem exists_rational_coefficient_minor (a : ι → PowerSeries ℚ)
+    (ha : LinearIndependent ℚ a) :
+    ∃ rows : ι → ℕ,
+      Matrix.det (fun r i => PowerSeries.coeff (rows r) (a i) : Matrix ι ι ℚ) ≠ 0 := by
+  obtain ⟨d, hd⟩ := exists_independent_jet a ha
+  let L := Fintype.linearCombination ℚ (fun i => jet d (a i))
+  have hL : LinearMap.ker L = ⊥ :=
+    LinearMap.ker_eq_bot.mpr hd.fintypeLinearCombination_injective
+  obtain ⟨K, hK⟩ := L.exists_leftInverse_of_injective hL
+  let A := LinearMap.toMatrix' L
+  let B := LinearMap.toMatrix' K
+  have hBA : B * A = 1 := by
+    rw [← LinearMap.toMatrix'_comp, hK, LinearMap.toMatrix'_id]
+  have hAB : A.transpose * B.transpose = 1 := by
+    rw [← Matrix.transpose_mul, hBA, Matrix.transpose_one]
+  obtain ⟨rows, hrows⟩ := exists_minor_ne_zero_of_mul_det_ne_zero A.transpose B.transpose
+    (by rw [hAB, Matrix.det_one]; exact one_ne_zero)
+  refine ⟨fun i => (rows i).val, ?_⟩
+  have hm : (A.transpose.submatrix id rows).transpose =
+      (fun r i => PowerSeries.coeff (rows r).val (a i) : Matrix ι ι ℚ) := by
+    ext r i
+    simp [A, L, LinearMap.toMatrix'_apply, Matrix.transpose_apply,
+      Matrix.submatrix_apply]
+  rw [← hm, Matrix.det_transpose]
+  exact hrows
+
+theorem rational_minor_transfer {F : Type*} [Field F] [CharZero F]
+    (a : ι → PowerSeries ℚ) (ha : LinearIndependent ℚ a) :
+    LinearIndependent F (fun i => PowerSeries.map (algebraMap ℚ F) (a i)) := by
+  obtain ⟨rows, hrows⟩ := exists_rational_coefficient_minor a ha
+  exact independent_of_rational_minor a rows hrows
+
+end NCHitting
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/FormulaHitting/RationalTransfer.lean b/lean/OAI/Algebra/FormulaHitting/RationalTransfer.lean
new file mode 100644
index 0000000000000000000000000000000000000000..7ee4d127641555613f2ac6364d9509e549d05f1d
--- /dev/null
+++ b/lean/OAI/Algebra/FormulaHitting/RationalTransfer.lean
@@ -0,0 +1,112 @@
+import Mathlib.RingTheory.PowerSeries.Basic
+import Mathlib.Algebra.Algebra.Rat
+import Mathlib.LinearAlgebra.LinearIndependent.BaseChange
+import Mathlib.RingTheory.Artinian.Module
+import Mathlib.LinearAlgebra.FiniteDimensional.Basic
+import Mathlib.LinearAlgebra.Matrix.NonsingularInverse
+import Lean.Elab.Tactic.Omega
+
+namespace OAI
+
+noncomputable section
+open PowerSeries
+namespace NCHitting
+
+variable {F : Type*} [Field F]
+
+def jet (d : ℕ) : PowerSeries F →ₗ[F] (Fin d → F) where
+  toFun a r := PowerSeries.coeff r.val a
+  map_add' a b := by ext r; simp
+  map_smul' c a := by ext r; simp
+
+@[simp] theorem jet_apply (d : ℕ) (a : PowerSeries F) (r : Fin d) :
+    jet d a r = PowerSeries.coeff r.val a := rfl
+
+section FiniteFamily
+variable {ι : Type*} [Fintype ι]
+
+def jetKernel (a : ι → PowerSeries F) (d : ℕ) : Submodule F (ι → F) :=
+  LinearMap.ker ((jet d).comp (Fintype.linearCombination F a))
+
+@[simp] theorem mem_jetKernel (a : ι → PowerSeries F) (d : ℕ) (c : ι → F) :
+    c ∈ jetKernel a d ↔ ∀ r < d,
+      PowerSeries.coeff r (Fintype.linearCombination F a c) = 0 := by
+  simp only [jetKernel, LinearMap.mem_ker, LinearMap.comp_apply]
+  constructor
+  · intro h r hr
+    exact congrFun h ⟨r, hr⟩
+  · intro h
+    ext r
+    exact h r.val r.isLt
+
+theorem jetKernel_antitone (a : ι → PowerSeries F) : Antitone (jetKernel a) := by
+  intro d e hde c hc
+  rw [mem_jetKernel] at hc ⊢
+  exact fun r hr => hc r (lt_of_lt_of_le hr hde)
+
+theorem exists_independent_jet (a : ι → PowerSeries F) (ha : LinearIndependent F a) :
+    ∃ d : ℕ, LinearIndependent F (fun i => jet d (a i)) := by
+  classical
+  obtain ⟨d, hd⟩ := IsArtinian.monotone_stabilizes
+    (R := F) (M := ι → F) ⟨jetKernel a, jetKernel_antitone a⟩
+  refine ⟨d, Fintype.linearIndependent_iff.mpr ?_⟩
+  intro c hc i
+  have hcd : c ∈ jetKernel a d := by
+    simp only [jetKernel, LinearMap.mem_ker, LinearMap.comp_apply,
+      Fintype.linearCombination_apply, map_sum, map_smul]
+    exact hc
+  have hcz : Fintype.linearCombination F a c = 0 := by
+    apply PowerSeries.ext
+    intro r
+    have hce : c ∈ jetKernel a (max d (r+1)) := by
+      have hstab := hd (max d (r+1)) (le_max_left _ _)
+      change jetKernel a d = jetKernel a (max d (r+1)) at hstab
+      rwa [← hstab]
+    exact (mem_jetKernel a _ c).mp hce r (by omega)
+  have he : c = 0 := ha.fintypeLinearCombination_injective (by simpa using hcz)
+  exact congrFun he i
+
+theorem rational_series_independent [CharZero F] (a : ι → PowerSeries ℚ)
+    (ha : LinearIndependent ℚ a) :
+    LinearIndependent F (fun i => PowerSeries.map (algebraMap ℚ F) (a i)) := by
+  classical
+  obtain ⟨d, hd⟩ := exists_independent_jet a ha
+  have ht : LinearIndependent F (fun i =>
+      (algebraMap ℚ F) ∘ (jet d (a i))) :=
+    linearIndependent_algebraMap_comp_iff.mpr hd
+  apply LinearIndependent.of_comp (jet d)
+  simpa [Function.comp_def, jet] using ht
+
+theorem rational_minor_ne_zero [DecidableEq ι] [CharZero F]
+    (A : Matrix ι ι ℚ) (hA : A.det ≠ 0) :
+    (A.map (algebraMap ℚ F)).det ≠ 0 := by
+  change ((algebraMap ℚ F).mapMatrix A).det ≠ 0
+  rw [← RingHom.map_det]
+  exact (map_ne_zero (algebraMap ℚ F)).mpr hA
+
+theorem independent_of_rational_minor [DecidableEq ι] [CharZero F]
+    (a : ι → PowerSeries ℚ) (rows : ι → ℕ)
+    (hA : Matrix.det (fun r i => PowerSeries.coeff (rows r) (a i) : Matrix ι ι ℚ) ≠ 0) :
+    LinearIndependent F (fun i => PowerSeries.map (algebraMap ℚ F) (a i)) := by
+  classical
+  let A : Matrix ι ι ℚ := fun r i => PowerSeries.coeff (rows r) (a i)
+  have hunit : IsUnit (A.map (algebraMap ℚ F)) := by
+    apply (Matrix.isUnit_iff_isUnit_det _).mpr
+    exact isUnit_iff_ne_zero.mpr (rational_minor_ne_zero A hA)
+  have hinj := Matrix.mulVec_injective_iff_isUnit.mpr hunit
+  refine Fintype.linearIndependent_iff.mpr ?_
+  intro c hc i
+  have he : (A.map (algebraMap ℚ F)).mulVec c = 0 := by
+    ext r
+    change (∑ i, (algebraMap ℚ F) (PowerSeries.coeff (rows r) (a i)) * c i) = 0
+    have hr := congrArg (PowerSeries.coeff (rows r)) hc
+    simpa [mul_comm] using hr
+  have hz : c = 0 := hinj (by simpa using he)
+  exact congrFun hz i
+
+end FiniteFamily
+end NCHitting
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/FormulaHitting/Representation.lean b/lean/OAI/Algebra/FormulaHitting/Representation.lean
new file mode 100644
index 0000000000000000000000000000000000000000..a06bd4d8e396a82ab82fa9e3e081dd38a05f3fe0
--- /dev/null
+++ b/lean/OAI/Algebra/FormulaHitting/Representation.lean
@@ -0,0 +1,353 @@
+import OAI.Algebra.FormulaHitting.Formula
+import Mathlib.Data.Matrix.Block
+import Mathlib.Algebra.BigOperators.Fin
+import Mathlib.Tactic.FinCases
+
+namespace OAI
+
+namespace NCHitting
+
+open Matrix
+
+def automatonValue {F I : Type*} {n : ℕ} [Semiring F] [Fintype I]
+    (B : Fin n → Matrix I I F) (u v : I → F) : Word n → F
+  | [] => u ⬝ᵥ v
+  | i :: w => automatonValue B (u ᵥ* B i) v w
+
+theorem automatonValue_add {F I : Type*} {n : ℕ} [Semiring F] [Fintype I]
+    (B : Fin n → Matrix I I F) (u u' v : I → F) (w : Word n) :
+    automatonValue B (u + u') v w =
+      automatonValue B u v w + automatonValue B u' v w := by
+  induction w generalizing u u' with
+  | nil => simp [automatonValue, add_dotProduct]
+  | cons i w ih => simp [automatonValue, add_vecMul, ih]
+
+theorem automatonValue_smul {F I : Type*} {n : ℕ} [CommSemiring F] [Fintype I]
+    (B : Fin n → Matrix I I F) (a : F) (u v : I → F) (w : Word n) :
+    automatonValue B (a • u) v w = a * automatonValue B u v w := by
+  induction w generalizing u with
+  | nil => simp [automatonValue, smul_dotProduct]
+  | cons i w ih => simp [automatonValue, smul_vecMul, ih]
+
+theorem automatonValue_zero {F I : Type*} {n : ℕ} [Semiring F] [Fintype I]
+    (B : Fin n → Matrix I I F) (v : I → F) (w : Word n) :
+    automatonValue B 0 v w = 0 := by
+  induction w with
+  | nil => simp [automatonValue]
+  | cons i w ih => simp [automatonValue, ih]
+
+def wordMatrix {F I : Type*} {n : ℕ} [Semiring F] [Fintype I] [DecidableEq I]
+    (B : Fin n → Matrix I I F) (w : Word n) : Matrix I I F :=
+  (w.map B).prod
+
+theorem automatonValue_eq_matrix {F I : Type*} {n : ℕ}
+    [Semiring F] [Fintype I] [DecidableEq I]
+    (B : Fin n → Matrix I I F) (u v : I → F) (w : Word n) :
+    automatonValue B u v w = u ⬝ᵥ (wordMatrix B w *ᵥ v) := by
+  induction w generalizing u with
+  | nil => simp [automatonValue, wordMatrix]
+  | cons i w ih =>
+    simp only [automatonValue, ih, wordMatrix, List.map_cons, List.prod_cons]
+    rw [← dotProduct_mulVec, mulVec_mulVec]
+
+theorem automatonValue_sumBlocks {F I J : Type*} {n : ℕ}
+    [Semiring F] [Fintype I] [Fintype J]
+    (A : Fin n → Matrix I I F) (B : Fin n → Matrix J J F)
+    (u v : I → F) (u' v' : J → F) (w : Word n) :
+    automatonValue (fun i => fromBlocks (A i) 0 0 (B i))
+        (Sum.elim u u') (Sum.elim v v') w =
+      automatonValue A u v w + automatonValue B u' v' w := by
+  induction w generalizing u u' with
+  | nil => simp [automatonValue, sumElim_dotProduct_sumElim]
+  | cons i w ih =>
+    simpa [automatonValue, vecMul_fromBlocks, Function.comp_def] using
+      ih (u ᵥ* A i) (u' ᵥ* B i)
+
+def productTransition {F I J : Type*} {n : ℕ}
+    [Semiring F] [Fintype J]
+    (A : Fin n → Matrix I I F) (B : Fin n → Matrix J J F)
+    (v : I → F) (u' : J → F) (i : Fin n) : Matrix (I ⊕ J) (I ⊕ J) F :=
+  fromBlocks (A i) (vecMulVec v (u' ᵥ* B i)) 0 (B i)
+
+theorem automatonValue_productBlocks_general {F I J : Type*} {n : ℕ}
+    [CommSemiring F] [Fintype I] [Fintype J]
+    (A : Fin n → Matrix I I F) (B : Fin n → Matrix J J F)
+    (u v : I → F) (u' b v' : J → F) (w : Word n) :
+    automatonValue (productTransition A B v u') (Sum.elim u b)
+        (Sum.elim ((u' ⬝ᵥ v') • v) v') w =
+      convolution (automatonValue A u v) (automatonValue B u' v') w +
+        automatonValue B b v' w := by
+  induction w generalizing u b with
+  | nil =>
+    simp [automatonValue, convolution, sumElim_dotProduct_sumElim,
+      dotProduct_smul, mul_comm]
+  | cons i w ih =>
+    rw [automatonValue]
+    simp only [productTransition, vecMul_fromBlocks, Function.comp_def,
+      Sum.elim_inl, Sum.elim_inr, vecMul_zero, add_zero, vecMul_vecMulVec]
+    rw [ih, automatonValue_add, automatonValue_smul]
+    simp only [convolution, automatonValue]
+    ac_rfl
+
+theorem automatonValue_productBlocks {F I J : Type*} {n : ℕ}
+    [CommSemiring F] [Fintype I] [Fintype J]
+    (A : Fin n → Matrix I I F) (B : Fin n → Matrix J J F)
+    (u v : I → F) (u' v' : J → F) (w : Word n) :
+    automatonValue (productTransition A B v u') (Sum.elim u 0)
+        (Sum.elim ((u' ⬝ᵥ v') • v) v') w =
+      convolution (automatonValue A u v) (automatonValue B u' v') w := by
+  rw [automatonValue_productBlocks_general, automatonValue_zero, add_zero]
+
+structure AcyclicRepresentation (F : Type*) (n : ℕ) [CommSemiring F] where
+  State : Type
+  [fintype : Fintype State]
+  [decidableEq : DecidableEq State]
+  u : State → F
+  v : State → F
+  B : Fin n → Matrix State State F
+  rank : State → ℕ
+  rank_lt : ∀ a, rank a < Fintype.card State
+  upper : ∀ i a b, rank b ≤ rank a → B i a b = 0
+
+attribute [instance] AcyclicRepresentation.fintype AcyclicRepresentation.decidableEq
+
+namespace AcyclicRepresentation
+
+variable {F : Type*} {n : ℕ} [CommSemiring F]
+
+def value (R : AcyclicRepresentation F n) : WordSeries F n :=
+  automatonValue R.B R.u R.v
+
+theorem wordMatrix_entry_zero (R : AcyclicRepresentation F n)
+    (w : Word n) (a b : R.State) (h : R.rank b < R.rank a + w.length) :
+    wordMatrix R.B w a b = 0 := by
+  induction w generalizing a with
+  | nil =>
+    have hne : a ≠ b := by intro he; subst b; simp at h
+    simp [wordMatrix, hne]
+  | cons i w ih =>
+    simp only [wordMatrix, List.map_cons, List.prod_cons, Matrix.mul_apply]
+    apply Finset.sum_eq_zero
+    intro c _
+    by_cases hc : R.rank c ≤ R.rank a
+    · rw [R.upper i a c hc, zero_mul]
+    · have hbc : R.rank b < R.rank c + w.length := by
+        simp only [List.length_cons] at h
+        omega
+      rw [show (List.map R.B w).prod c b = 0 from ih c hbc, mul_zero]
+
+theorem wordMatrix_eq_zero (R : AcyclicRepresentation F n)
+    (w : Word n) (h : Fintype.card R.State ≤ w.length) : wordMatrix R.B w = 0 := by
+  ext a b
+  apply R.wordMatrix_entry_zero w a b
+  have hb := R.rank_lt b
+  omega
+
+theorem value_eq_matrix (R : AcyclicRepresentation F n) (w : Word n) :
+    R.value w = R.u ⬝ᵥ (wordMatrix R.B w *ᵥ R.v) :=
+  automatonValue_eq_matrix R.B R.u R.v w
+
+def sumRank (R S : AcyclicRepresentation F n) : R.State ⊕ S.State → ℕ :=
+  Sum.elim R.rank (fun a => Fintype.card R.State + S.rank a)
+
+theorem sumRank_lt (R S : AcyclicRepresentation F n) (a : R.State ⊕ S.State) :
+    sumRank R S a < Fintype.card (R.State ⊕ S.State) := by
+  cases a with
+  | inl a =>
+    have h := R.rank_lt a
+    simp only [sumRank, Sum.elim_inl, Fintype.card_sum]
+    omega
+  | inr a =>
+    have h := S.rank_lt a
+    simp only [sumRank, Sum.elim_inr, Fintype.card_sum]
+    omega
+
+theorem block_upper (R S : AcyclicRepresentation F n)
+    (C : Fin n → Matrix R.State S.State F) (i : Fin n)
+    (a b : R.State ⊕ S.State) (h : sumRank R S b ≤ sumRank R S a) :
+    fromBlocks (R.B i) (C i) 0 (S.B i) a b = 0 := by
+  cases a with
+  | inl a =>
+    cases b with
+    | inl b => exact R.upper i a b h
+    | inr b =>
+      have ha := R.rank_lt a
+      simp only [sumRank, Sum.elim_inl, Sum.elim_inr] at h
+      omega
+  | inr a =>
+    cases b with
+    | inl b => rfl
+    | inr b =>
+      apply S.upper i a b
+      simp only [sumRank, Sum.elim_inr] at h
+      omega
+
+def add (R S : AcyclicRepresentation F n) : AcyclicRepresentation F n where
+  State := R.State ⊕ S.State
+  fintype := inferInstance
+  decidableEq := inferInstance
+  u := Sum.elim R.u S.u
+  v := Sum.elim R.v S.v
+  B i := fromBlocks (R.B i) 0 0 (S.B i)
+  rank := sumRank R S
+  rank_lt := sumRank_lt R S
+  upper := block_upper R S (fun _ => 0)
+
+theorem add_value (R S : AcyclicRepresentation F n) (w : Word n) :
+    (R.add S).value w = R.value w + S.value w :=
+  automatonValue_sumBlocks R.B S.B R.u R.v S.u S.v w
+
+def mul (R S : AcyclicRepresentation F n) : AcyclicRepresentation F n where
+  State := R.State ⊕ S.State
+  fintype := inferInstance
+  decidableEq := inferInstance
+  u := Sum.elim R.u 0
+  v := Sum.elim ((S.u ⬝ᵥ S.v) • R.v) S.v
+  B := productTransition R.B S.B R.v S.u
+  rank := sumRank R S
+  rank_lt := sumRank_lt R S
+  upper := block_upper R S (fun i => vecMulVec R.v (S.u ᵥ* S.B i))
+
+theorem mul_value (R S : AcyclicRepresentation F n) (w : Word n) :
+    (R.mul S).value w = convolution R.value S.value w :=
+  automatonValue_productBlocks R.B S.B R.u R.v S.u S.v w
+
+def scalar (a : F) : AcyclicRepresentation F n where
+  State := Unit
+  fintype := inferInstance
+  decidableEq := inferInstance
+  u _ := a
+  v _ := 1
+  B _ := 0
+  rank _ := 0
+  rank_lt _ := by simp
+  upper _ _ _ _ := rfl
+
+theorem scalar_value (a : F) (w : Word n) :
+    (scalar (n := n) a).value w = if w = [] then a else 0 := by
+  cases w with
+  | nil =>
+    change (∑ _ : Unit, a * 1) = a
+    simp
+  | cons i w =>
+    change automatonValue (fun _ : Fin n => (0 : Matrix Unit Unit F))
+      ((fun _ : Unit => a) ᵥ* 0) (fun _ => 1) w = 0
+    rw [vecMul_zero, automatonValue_zero]
+
+def ofVariable (i : Fin n) : AcyclicRepresentation F n where
+  State := Fin 2
+  fintype := inferInstance
+  decidableEq := inferInstance
+  u a := if a = 0 then 1 else 0
+  v a := if a = 1 then 1 else 0
+  B j a b := if a = 0 ∧ b = 1 ∧ j = i then 1 else 0
+  rank a := a.val
+  rank_lt a := by simp
+  upper j a b h := by
+    by_cases hab : a = 0 ∧ b = 1 ∧ j = i
+    · rcases hab with ⟨rfl, rfl, _⟩
+      simp at h
+    · simp [hab]
+
+theorem variable_value (i : Fin n) (w : Word n) :
+    (ofVariable (F := F) i).value w = if w = [i] then 1 else 0 := by
+  change automatonValue
+    (fun j (a b : Fin 2) => if a = 0 ∧ b = 1 ∧ j = i then (1 : F) else 0)
+    (fun a : Fin 2 => if a = 0 then 1 else 0)
+    (fun a : Fin 2 => if a = 1 then 1 else 0) w = _
+  cases w with
+  | nil => simp [automatonValue, dotProduct]
+  | cons j w =>
+    cases w with
+    | nil =>
+      simp [automatonValue, vecMul, dotProduct, Fin.sum_univ_two]
+    | cons k w =>
+      have hz : ((ofVariable (F := F) i).u ᵥ* (ofVariable i).B j) ᵥ*
+          (ofVariable i).B k = 0 := by
+        change ((fun a : Fin 2 => if a = 0 then (1 : F) else 0) ᵥ*
+          (fun a b : Fin 2 => if a = 0 ∧ b = 1 ∧ j = i then 1 else 0)) ᵥ*
+          (fun a b : Fin 2 => if a = 0 ∧ b = 1 ∧ k = i then 1 else 0) = 0
+        ext a
+        change _ = (0 : F)
+        fin_cases a <;>
+          simp [vecMul, dotProduct, Fin.sum_univ_two]
+      rw [ite_eq_right (show (j :: k :: w : Word n) ≠ [i] by simp)]
+      change automatonValue (ofVariable (F := F) i).B
+        (((ofVariable i).u ᵥ* (ofVariable i).B j) ᵥ* (ofVariable i).B k)
+        (ofVariable i).v w = 0
+      rw [hz, automatonValue_zero]
+
+@[simp] theorem scalar_card (a : F) : Fintype.card (scalar (n := n) a).State = 1 := rfl
+
+@[simp] theorem variable_card (i : Fin n) :
+    Fintype.card (ofVariable (F := F) i).State = 2 := rfl
+
+@[simp] theorem add_card (R S : AcyclicRepresentation F n) :
+    Fintype.card (R.add S).State = Fintype.card R.State + Fintype.card S.State :=
+  Fintype.card_sum
+
+@[simp] theorem mul_card (R S : AcyclicRepresentation F n) :
+    Fintype.card (R.mul S).State = Fintype.card R.State + Fintype.card S.State :=
+  Fintype.card_sum
+
+end AcyclicRepresentation
+
+noncomputable def Formula.representation {F : Type*} {n : ℕ} [CommSemiring F] :
+    Formula F n → AcyclicRepresentation F n
+  | .scalar a => .scalar a
+  | .var i => .ofVariable i
+  | .add f g => f.representation.add g.representation
+  | .mul f g => f.representation.mul g.representation
+
+theorem Formula.representation_card_le {F : Type*} {n : ℕ} [CommSemiring F]
+    (f : Formula F n) : Fintype.card f.representation.State ≤ 2 * f.size := by
+  induction f with
+  | scalar a => change 1 ≤ 2 * 1; decide
+  | var i => change 2 ≤ 2 * 1; decide
+  | add f g ihf ihg =>
+    change Fintype.card (f.representation.State ⊕ g.representation.State) ≤
+      2 * (f.size + g.size + 1)
+    rw [Fintype.card_sum]
+    omega
+  | mul f g ihf ihg =>
+    change Fintype.card (f.representation.State ⊕ g.representation.State) ≤
+      2 * (f.size + g.size + 1)
+    rw [Fintype.card_sum]
+    omega
+
+theorem Formula.representation_card_pos {F : Type*} {n : ℕ} [CommSemiring F]
+    (f : Formula F n) : 0 < Fintype.card f.representation.State := by
+  induction f with
+  | scalar a => change 0 < 1; decide
+  | var i => change 0 < 2; decide
+  | add f g ihf ihg =>
+    change 0 < Fintype.card (f.representation.State ⊕ g.representation.State)
+    rw [Fintype.card_sum]
+    omega
+  | mul f g ihf ihg =>
+    change 0 < Fintype.card (f.representation.State ⊕ g.representation.State)
+    rw [Fintype.card_sum]
+    omega
+
+theorem Formula.representation_correct {F : Type*} {n : ℕ} [CommSemiring F]
+    (f : Formula F n) (w : Word n) : f.representation.value w = f.coeff w := by
+  induction f generalizing w with
+  | scalar a => exact AcyclicRepresentation.scalar_value a w
+  | var i => exact AcyclicRepresentation.variable_value i w
+  | add f g ihf ihg =>
+    simp only [Formula.representation, AcyclicRepresentation.add_value,
+      Formula.coeff, ihf, ihg]
+  | mul f g ihf ihg =>
+    simp only [Formula.representation, AcyclicRepresentation.mul_value, Formula.coeff]
+    congr 1 <;> funext w <;> first | exact ihf w | exact ihg w
+
+theorem Formula.coeff_zero_of_representation_dimension_le
+    {F : Type*} {n : ℕ} [CommSemiring F] (f : Formula F n) (w : Word n)
+    (h : Fintype.card f.representation.State ≤ w.length) : f.coeff w = 0 := by
+  rw [← f.representation_correct w, f.representation.value_eq_matrix,
+    f.representation.wordMatrix_eq_zero w h]
+  simp
+
+end NCHitting
+
+end OAI
diff --git a/lean/OAI/Algebra/FormulaHitting/Result.lean b/lean/OAI/Algebra/FormulaHitting/Result.lean
new file mode 100644
index 0000000000000000000000000000000000000000..f9eb86abe4ca73e3d11e1e9ed8b997c46c3d9146
--- /dev/null
+++ b/lean/OAI/Algebra/FormulaHitting/Result.lean
@@ -0,0 +1,24 @@
+import OAI.Algebra.FormulaHitting.Hitting
+import OAI.Algebra.FormulaHitting.FormulaBridge
+import OAI.Algebra.FormulaHitting.GeneratorBridge
+
+namespace OAI
+
+namespace NCHitting
+
+universe u
+
+theorem complete_result : NCHittingSpecification.CompleteTheorem.{u} := by
+  intro n s hn hs
+  apply NCHittingSpecification.completeClaim_of_hitting hn hs
+  intro F instField instCharZero f hsize hf
+  have hi := NCHitting.universal_hitting n s hn hs F f.toImplementation
+    (by simpa using hsize) (by simpa using hf)
+  intro hz
+  apply hi
+  exact (f.toImplementation_eval (fun i => Matrix.of
+    (fun r q => (NCHittingSpecification.expectedEntry n s i r q : F)))).trans hz
+
+end NCHitting
+
+end OAI
diff --git a/lean/OAI/Algebra/FormulaHitting/ScaledDerivatives.lean b/lean/OAI/Algebra/FormulaHitting/ScaledDerivatives.lean
new file mode 100644
index 0000000000000000000000000000000000000000..88954de7da910a0253aa7866b1e7371229a903fb
--- /dev/null
+++ b/lean/OAI/Algebra/FormulaHitting/ScaledDerivatives.lean
@@ -0,0 +1,97 @@
+import OAI.Algebra.FormulaHitting.Wronskian
+import OAI.Algebra.FormulaHitting.NumeratorRows
+
+namespace OAI
+
+noncomputable section
+
+namespace NCHitting
+
+open PowerSeries Polynomial Matrix
+
+variable {F : Type*} [Field F]
+variable {I : Type*} [Fintype I]
+
+theorem derivative_scaled_power (q f : PowerSeries F) (j : ℕ) :
+    q * PowerSeries.derivative (R := F) (q^j * f) =
+      (j : PowerSeries F) * PowerSeries.derivative (R := F) q * (q^j * f) +
+        q^(j+1) * PowerSeries.derivative (R := F) f := by
+  rw [Derivation.leibniz]
+  cases j with
+  | zero => simp
+  | succ j =>
+    rw [PowerSeries.derivative_pow]
+    simp only [Nat.add_sub_cancel, smul_eq_mul, pow_succ]
+    ring
+
+theorem coePolynomial_sum (Z : I → F[X]) :
+    ((∑ t : I, Z t : F[X]) : PowerSeries F) = ∑ t : I, (Z t : PowerSeries F) :=
+  map_sum Polynomial.coeToPowerSeries.ringHom Z Finset.univ
+
+theorem coePolynomial_sub (p q : F[X]) :
+    ((p - q : F[X]) : PowerSeries F) = (p : PowerSeries F) - (q : PowerSeries F) :=
+  map_sub Polynomial.coeToPowerSeries.ringHom p q
+
+theorem coePolynomial_natCast (k : ℕ) :
+    ((k : F[X]) : PowerSeries F) = (k : PowerSeries F) :=
+  map_natCast Polynomial.coeToPowerSeries.ringHom k
+
+theorem derivative_polynomial_row (q : F[X]) (P : Matrix I I F[X])
+    (G : Matrix I I (PowerSeries F))
+    (hG : ∀ t l, (q : PowerSeries F) * PowerSeries.derivative (R := F) (G t l) =
+      ∑ a : I, (P t a : PowerSeries F) * G a l)
+    (Z : I → F[X]) (l : I) :
+    (q : PowerSeries F) * PowerSeries.derivative (R := F)
+        (∑ t : I, (Z t : PowerSeries F) * G t l) =
+      ∑ t : I, ((q * (Z t).derivative + ∑ a : I, Z a * P a t : F[X]) :
+        PowerSeries F) * G t l := by
+  classical
+  calc
+    _ = ∑ t : I, (((q : PowerSeries F) * ((Z t).derivative : PowerSeries F)) * G t l +
+          (Z t : PowerSeries F) * ((q : PowerSeries F) * PowerSeries.derivative (R := F) (G t l))) := by
+      rw [map_sum, Finset.mul_sum]
+      apply Finset.sum_congr rfl
+      intro t _
+      rw [Derivation.leibniz, PowerSeries.derivative_coe]
+      simp only [smul_eq_mul]
+      ring
+    _ = ∑ t : I, (((q : PowerSeries F) * ((Z t).derivative : PowerSeries F)) * G t l +
+          ∑ a : I, (Z t : PowerSeries F) * (P t a : PowerSeries F) * G a l) := by
+      simp_rw [hG, Finset.mul_sum, mul_assoc]
+    _ = _ := by
+      simp only [Polynomial.coe_add, Polynomial.coe_mul, coePolynomial_sum,
+        add_mul, Finset.sum_mul, Finset.sum_add_distrib]
+      congr 1
+      rw [Finset.sum_comm]
+
+theorem scaled_derivative_row (q : F[X]) (P : Matrix I I F[X]) (u : I → F)
+    (G : Matrix I I (PowerSeries F))
+    (hG : ∀ t l, (q : PowerSeries F) * PowerSeries.derivative (R := F) (G t l) =
+      ∑ a : I, (P t a : PowerSeries F) * G a l)
+    (j : ℕ) (l : I) :
+    (q : PowerSeries F)^j * derivativeIter j
+        (∑ t : I, PowerSeries.C (u t) * G t l) =
+      ∑ t : I, (numeratorRow q P u j t : PowerSeries F) * G t l := by
+  classical
+  induction j with
+  | zero => simp [derivativeIter, numeratorRow]
+  | succ j ih =>
+    have hd := congrArg (fun f : PowerSeries F =>
+      (q : PowerSeries F) * PowerSeries.derivative (R := F) f) ih
+    rw [derivative_scaled_power, derivative_polynomial_row q P G hG] at hd
+    have he := eq_sub_of_add_eq' hd
+    change (q : PowerSeries F)^(j+1) * PowerSeries.derivative (R := F)
+      (derivativeIter j (∑ t : I, PowerSeries.C (u t) * G t l)) = _
+    rw [he, ih]
+    simp only [numeratorRow, Polynomial.coe_add, coePolynomial_sub,
+      Polynomial.coe_mul, coePolynomial_sum,
+      PowerSeries.derivative_coe, Finset.mul_sum, Finset.sum_sub_distrib,
+      Finset.sum_add_distrib, add_mul, sub_mul, map_natCast, coePolynomial_natCast]
+    simp only [mul_comm, mul_left_comm, mul_assoc]
+    ring
+
+end NCHitting
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/FormulaHitting/Series.lean b/lean/OAI/Algebra/FormulaHitting/Series.lean
new file mode 100644
index 0000000000000000000000000000000000000000..8857570e3355b3153cbc6053b620ab75e10405e6
--- /dev/null
+++ b/lean/OAI/Algebra/FormulaHitting/Series.lean
@@ -0,0 +1,221 @@
+import Mathlib.RingTheory.PowerSeries.Derivative
+import Mathlib.RingTheory.PowerSeries.Order
+import Mathlib.Algebra.BigOperators.NatAntidiagonal
+import Mathlib.Tactic.Ring
+import Mathlib.Tactic.FieldSimp
+import Lean.Elab.Tactic.Omega
+
+namespace OAI
+
+noncomputable section
+open PowerSeries
+namespace NCHitting
+
+variable {F : Type*} [Field F] [CharZero F]
+
+def integral (a : PowerSeries F) : PowerSeries F :=
+  PowerSeries.mk fun r => match r with
+    | 0 => 0
+    | r + 1 => PowerSeries.coeff r a / (r + 1 : F)
+
+omit [CharZero F] in
+@[simp] theorem coeff_integral_zero (a : PowerSeries F) :
+    PowerSeries.coeff 0 (integral a) = 0 := by simp [integral]
+
+omit [CharZero F] in
+@[simp] theorem coeff_integral_succ (a : PowerSeries F) (r : ℕ) :
+    PowerSeries.coeff (r+1) (integral a) = PowerSeries.coeff r a / (r+1 : F) := by
+  simp [integral]
+
+omit [CharZero F] in
+@[simp] theorem constantCoeff_integral (a : PowerSeries F) :
+    PowerSeries.constantCoeff (integral a) = 0 := by
+  simpa only [PowerSeries.coeff_zero_eq_constantCoeff] using coeff_integral_zero a
+
+@[simp] theorem derivative_integral (a : PowerSeries F) :
+    PowerSeries.derivative (R := F) (integral a) = a := by
+  ext r
+  rw [PowerSeries.coeff_derivative, coeff_integral_succ]
+  exact div_mul_cancel₀ _ (by simpa using (Nat.cast_ne_zero.mpr (Nat.succ_ne_zero r) : ((r + 1 : ℕ) : F) ≠ 0))
+
+theorem integral_unique (a b : PowerSeries F)
+    (hd : PowerSeries.derivative (R := F) b = a) (hc : PowerSeries.constantCoeff b = 0) :
+    b = integral a := by
+  apply PowerSeries.derivative.ext
+  · simpa using hd
+  · simpa using hc
+
+omit [CharZero F] in
+@[simp] theorem integral_zero : integral (0 : PowerSeries F) = 0 := by
+  ext r
+  cases r <;> simp [integral]
+
+omit [CharZero F] in
+@[simp] theorem integral_add (a b : PowerSeries F) :
+    integral (a+b) = integral a + integral b := by
+  ext r
+  cases r with
+  | zero => simp
+  | succ r => simp [add_div]
+
+omit [CharZero F] in
+@[simp] theorem integral_smul (c : F) (a : PowerSeries F) :
+    integral (c • a) = c • integral a := by
+  ext r
+  cases r with
+  | zero => simp
+  | succ r => simp [smul_eq_mul, mul_div_assoc]
+
+def kernel (i : ℕ) : PowerSeries F :=
+  PowerSeries.mk fun r => (-1 : F)^r / (i : F)^(r+1)
+
+omit [CharZero F] in
+@[simp] theorem coeff_kernel (i r : ℕ) :
+    PowerSeries.coeff r (kernel (F := F) i) = (-1 : F)^r / (i : F)^(r+1) := by
+  simp [kernel]
+
+def J (i : ℕ) (a : PowerSeries F) : PowerSeries F := integral (a * kernel i)
+
+@[simp] theorem derivative_J (i : ℕ) (a : PowerSeries F) :
+    PowerSeries.derivative (R := F) (J i a) = a * kernel i := by simp [J]
+
+omit [CharZero F] in
+@[simp] theorem constantCoeff_J (i : ℕ) (a : PowerSeries F) :
+    PowerSeries.constantCoeff (J i a) = 0 := by simp [J]
+
+omit [CharZero F] in
+@[simp] theorem J_zero (i : ℕ) : J i (0 : PowerSeries F) = 0 := by simp [J]
+
+omit [CharZero F] in
+@[simp] theorem J_add (i : ℕ) (a b : PowerSeries F) :
+    J i (a+b) = J i a + J i b := by simp [J, add_mul]
+
+omit [CharZero F] in
+@[simp] theorem J_smul (i : ℕ) (c : F) (a : PowerSeries F) :
+    J i (c • a) = c • J i a := by simp [J]
+
+def JLinear (i : ℕ) : PowerSeries F →ₗ[F] PowerSeries F where
+  toFun := J i
+  map_add' := J_add i
+  map_smul' := J_smul i
+
+omit [CharZero F] in
+@[simp] theorem J_sum {ι : Type*} (i : ℕ) (s : Finset ι) (a : ι → PowerSeries F) :
+    J i (∑ j ∈ s, a j) = ∑ j ∈ s, J i (a j) :=
+  map_sum (JLinear i) a s
+
+omit [CharZero F] in
+theorem coeff_J (i r : ℕ) (a : PowerSeries F) :
+    PowerSeries.coeff r (J i a) =
+      ∑ q ∈ Finset.range r,
+        ((-1 : F)^(r-q-1) / ((r : F) * (i : F)^(r-q))) * PowerSeries.coeff q a := by
+  cases r with
+  | zero => simp [J]
+  | succ r =>
+    rw [J, coeff_integral_succ, PowerSeries.coeff_mul,
+      Finset.Nat.sum_antidiagonal_eq_sum_range_succ_mk, div_eq_mul_inv, Finset.sum_mul]
+    apply Finset.sum_congr rfl
+    intro q hq
+    have hqr : q ≤ r := Nat.lt_succ_iff.mp (Finset.mem_range.mp hq)
+    have hsub' : r+1-q = r-q+1 := by omega
+    simp only [coeff_kernel, hsub', Nat.add_sub_cancel, Nat.cast_add, Nat.cast_one]
+    simp only [div_eq_mul_inv, mul_inv_rev]
+    ring
+
+omit [CharZero F] in
+theorem coeff_J_eq_zero (i r : ℕ) (a : PowerSeries F)
+    (h : ∀ q < r, PowerSeries.coeff q a = 0) :
+    PowerSeries.coeff r (J i a) = 0 := by
+  rw [coeff_J]
+  apply Finset.sum_eq_zero
+  intro q hq
+  rw [h q (Finset.mem_range.mp hq), mul_zero]
+
+theorem kernel_mul_linear (i : ℕ) (hi : i ≠ 0) :
+    kernel (F := F) i * (PowerSeries.X + PowerSeries.C (i : F)) = 1 := by
+  have hiF : (i : F) ≠ 0 := Nat.cast_ne_zero.mpr hi
+  ext r
+  cases r with
+  | zero => simp [mul_add, kernel, hiF]
+  | succ r =>
+    rw [mul_add, map_add, PowerSeries.coeff_mul_C]
+    have hx : PowerSeries.coeff (r+1) (kernel (F := F) i * PowerSeries.X) =
+        PowerSeries.coeff r (kernel (F := F) i) := by
+      simp
+    rw [hx]
+    simp only [coeff_kernel, PowerSeries.coeff_one, Nat.succ_ne_zero, ite_false,
+      pow_succ]
+    field_simp
+    ring
+
+def wordSeries {n : ℕ} : List (Fin n) → PowerSeries F
+  | [] => 1
+  | i :: w => J (i.val + 1) (wordSeries w)
+
+omit [CharZero F] in
+@[simp] theorem wordSeries_nil {n : ℕ} : wordSeries (F := F) (n := n) [] = 1 := rfl
+omit [CharZero F] in
+@[simp] theorem wordSeries_cons {n : ℕ} (i : Fin n) (w : List (Fin n)) :
+    wordSeries (F := F) (i :: w) = J (i.val + 1) (wordSeries w) := rfl
+
+@[simp] theorem derivative_wordSeries_cons {n : ℕ} (i : Fin n) (w : List (Fin n)) :
+    PowerSeries.derivative (R := F) (wordSeries (i :: w)) = wordSeries w * kernel (i.val + 1) := by simp
+
+omit [CharZero F] in
+@[simp] theorem constantCoeff_wordSeries_cons {n : ℕ} (i : Fin n) (w : List (Fin n)) :
+    PowerSeries.constantCoeff (wordSeries (F := F) (i :: w)) = 0 := by simp
+
+omit [CharZero F] in
+theorem coeff_wordSeries_below {n : ℕ} (w : List (Fin n)) (r : ℕ) (hr : r < w.length) :
+    PowerSeries.coeff r (wordSeries (F := F) w) = 0 := by
+  induction w generalizing r with
+  | nil => simp at hr
+  | cons i w ih =>
+    rw [wordSeries_cons]
+    apply coeff_J_eq_zero
+    intro q hq
+    apply ih q
+    simp only [List.length_cons] at hr
+    omega
+
+omit [CharZero F] in
+theorem length_le_order_wordSeries {n : ℕ} (w : List (Fin n)) :
+    (w.length : ℕ∞) ≤ (wordSeries (F := F) w).order :=
+  PowerSeries.nat_le_order _ _ (coeff_wordSeries_below w)
+
+section Map
+variable {K : Type*} [Field K] [CharZero K]
+
+omit [CharZero F] [CharZero K] in
+theorem map_integral (f : F →+* K) (a : PowerSeries F) :
+    PowerSeries.map f (integral a) = integral (PowerSeries.map f a) := by
+  ext r
+  cases r with
+  | zero => simp
+  | succ r => simp [map_div₀]
+
+omit [CharZero F] [CharZero K] in
+theorem map_kernel (f : F →+* K) (i : ℕ) :
+    PowerSeries.map f (kernel (F := F) i) = kernel (F := K) i := by
+  ext r
+  simp [map_div₀]
+
+omit [CharZero F] [CharZero K] in
+theorem map_J (f : F →+* K) (i : ℕ) (a : PowerSeries F) :
+    PowerSeries.map f (J i a) = J i (PowerSeries.map f a) := by
+  simp [J, map_integral, map_kernel]
+
+omit [CharZero F] [CharZero K] in
+theorem map_wordSeries (f : F →+* K) {n : ℕ} (w : List (Fin n)) :
+    PowerSeries.map f (wordSeries (F := F) w) = wordSeries (F := K) w := by
+  induction w with
+  | nil => simp
+  | cons i w ih => simp [map_J, ih]
+
+end Map
+
+end NCHitting
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/FormulaHitting/SeriesFaithfulness.lean b/lean/OAI/Algebra/FormulaHitting/SeriesFaithfulness.lean
new file mode 100644
index 0000000000000000000000000000000000000000..7409ace51b34a1d7160da833c9422394f8161a1d
--- /dev/null
+++ b/lean/OAI/Algebra/FormulaHitting/SeriesFaithfulness.lean
@@ -0,0 +1,34 @@
+import OAI.Algebra.FormulaHitting.FormulaSeries
+import OAI.Algebra.FormulaHitting.WordIndependence
+
+namespace OAI
+
+namespace NCHitting
+namespace Formula
+
+variable {F : Type*} {n : ℕ} [Field F] [CharZero F]
+
+theorem series_eq_zero_iff (f : Formula F n) : f.series = 0 ↔ f.coeff = 0 := by
+  constructor
+  · intro h
+    have hc : Finsupp.linearCombination F (wordSeries (F := F) (n := n))
+        f.polynomial = 0 := by
+      simpa only [Finsupp.linearCombination_apply] using
+        (f.series_eq_smul_sum.symm.trans h)
+    have hp : f.polynomial = 0 :=
+      (linearIndependent_iff.mp (wordSeries_independent (F := F) (n := n))) f.polynomial hc
+    funext w
+    exact congrArg (fun p : Word n →₀ F => p w) hp
+  · intro h
+    have hp : f.polynomial = 0 := by
+      ext w
+      exact congrFun h w
+    simp [series, hp]
+
+theorem series_ne_zero (f : Formula F n) (hf : f.coeff ≠ 0) : f.series ≠ 0 :=
+  mt f.series_eq_zero_iff.mp hf
+
+end Formula
+end NCHitting
+
+end OAI
diff --git a/lean/OAI/Algebra/FormulaHitting/Specification.lean b/lean/OAI/Algebra/FormulaHitting/Specification.lean
new file mode 100644
index 0000000000000000000000000000000000000000..d41795bbdf89f7e4ff441de4058c8e5321c1f894
--- /dev/null
+++ b/lean/OAI/Algebra/FormulaHitting/Specification.lean
@@ -0,0 +1,135 @@
+import Mathlib.Data.Matrix.Basic
+import Mathlib.Data.Rat.Cast.Order
+import Mathlib.Algebra.BigOperators.Group.Finset.Basic
+import OAI.Algebra.FormulaHitting.BitModel
+import OAI.Algebra.FormulaHitting.BitRefinement
+
+namespace OAI
+
+namespace NCHittingSpecification
+
+universe u
+
+inductive Formula (F : Type*) (n : ℕ) where
+  | scalar : F → Formula F n
+  | variable : Fin n → Formula F n
+  | add : Formula F n → Formula F n → Formula F n
+  | multiply : Formula F n → Formula F n → Formula F n
+
+namespace Formula
+
+def gates {F : Type*} {n : ℕ} : Formula F n → ℕ
+  | .scalar _ => 1
+  | .variable _ => 1
+  | .add f g => gates f + gates g + 1
+  | .multiply f g => gates f + gates g + 1
+
+noncomputable def coefficient {F : Type*} {n : ℕ} [Semiring F] :
+    Formula F n → List (Fin n) → F
+  | .scalar a, w => if w = [] then a else 0
+  | .variable i, w => if w = [i] then 1 else 0
+  | .add f g, w => coefficient f w + coefficient g w
+  | .multiply f g, w =>
+      ∑ k ∈ Finset.range (w.length + 1),
+        coefficient f (w.take k) * coefficient g (w.drop k)
+
+def evaluate {F : Type*} {n d : ℕ} [Field F]
+    (T : Fin n → Matrix (Fin d) (Fin d) F) :
+    Formula F n → Matrix (Fin d) (Fin d) F
+  | .scalar a => Matrix.scalar (Fin d) a
+  | .variable i => T i
+  | .add f g => evaluate T f + evaluate T g
+  | .multiply f g => evaluate T f * evaluate T g
+
+end Formula
+
+def dimension (n s : ℕ) : ℕ :=
+  if n = 1 ∧ s = 1 then 1 else 2 * n * s ^ 2
+
+def expectedEntry (n s : ℕ) (i : Fin n)
+    (r q : Fin (dimension n s)) : ℚ :=
+  if n = 1 ∧ s = 1 then 1
+  else if q.val < r.val then
+    (-1 : ℚ) ^ (r.val - q.val - 1) /
+      ((r.val : ℚ) * ((i.val + 1 : ℕ) : ℚ) ^ (r.val - q.val))
+  else 0
+
+def UniversalHitting (n s d : ℕ)
+    (T : Fin n → Matrix (Fin d) (Fin d) ℚ) : Prop :=
+  ∀ (F : Type*) [Field F] [CharZero F], ∀ f : Formula F n,
+    f.gates ≤ s → (∃ w, f.coefficient w ≠ 0) →
+      f.evaluate (fun i r q => (T i r q : F)) ≠ 0
+
+open NCHitting.BitModel
+
+def expectedProgram : Program :=
+  .branch (.mul (.equal (.read 0) (.literal 1)) (.equal (.read 1) (.literal 1)))
+    (.emit (.literal 0) (.literal 1) (.literal 1))
+    (.loop (.read 0)
+      (.loop (.mul (.mul (.literal 2) (.read 1)) (.power (.read 2) (.literal 2)))
+        (.loop (.mul (.mul (.literal 2) (.read 2)) (.power (.read 3) (.literal 2)))
+          (.branch (.less (.read 0) (.read 1))
+            (.emit (.odd (.sub (.sub (.read 1) (.read 0)) (.literal 1)))
+              (.literal 1)
+              (.mul (.read 1) (.power (.add (.read 2) (.literal 1))
+                (.sub (.read 1) (.read 0)))))
+            (.emit (.literal 0) (.literal 0) (.literal 1))))))
+
+def expectedCode (i r q : ℕ) : NCHitting.BitModel.RationalCode :=
+  if q < r then ⟨decide ((r - q - 1) % 2 = 1), 1, r * (i + 1) ^ (r - q)⟩
+  else ⟨false, 0, 1⟩
+
+def expectedOutput (n s : ℕ) : List NCHitting.BitModel.RationalCode :=
+  if n = 1 ∧ s = 1 then [⟨false, 1, 1⟩]
+  else (List.range n).flatMap fun i =>
+    (List.range (2 * n * s ^ 2)).flatMap fun r =>
+      (List.range (2 * n * s ^ 2)).map fun q => expectedCode i r q
+
+def decode (entry : NCHitting.BitModel.RationalCode) : ℚ :=
+  (if entry.negative then -(entry.numerator : ℚ) else entry.numerator) / entry.denominator
+
+def entryBitBound (n d : ℕ) : ℕ := 3 + d.size + d * n.size
+
+def costBound (n s : ℕ) : ℕ :=
+  let d := 2 * n * s ^ 2
+  let M := n + s + d + 3
+  let B := M * M + 4 * M + 10
+  let R := 5 * (M + 1) + 6
+  let P := 8 * (M * M + 2) * (M + 1) + 4 * (M + 3) + 1
+  let E := R + 8 * B * B + 8 * B + (2 + M * P) + 10
+  let L := M + 1 + 4 * (M + 3) + 1
+  let entryCost := 20 * E + B + 20
+  let entryOutput := B + 3
+  let rowCost := 7 * E + 1 + d * (entryCost + L + entryOutput)
+  let rowOutput := d * entryOutput
+  let variableCost := 7 * E + 1 + d * (rowCost + L + rowOutput)
+  let variableOutput := d * rowOutput
+  2 * (M + 1) + 7 * E + 15 + (R + 1 + n * (variableCost + L + variableOutput)) + 1
+
+def primitiveBitBound (n s : ℕ) : ℕ := 1024 * costBound n s ^ 3
+
+def CompleteClaim (n s : ℕ) : Prop :=
+  let d := dimension n s
+  let result := execute expectedProgram [n, s]
+  0 < d ∧ d ≤ 2 * n * s ^ 2 ∧
+  result.output = expectedOutput n s ∧
+  result.output.length = n * d * d ∧
+  (∀ entry ∈ result.output,
+    0 < entry.denominator ∧ entry.numerator ≤ 1 ∧
+    entry.denominator.size ≤ entryBitBound n d ∧
+    entry.bits ≤ 4 + entryBitBound n d) ∧
+  (∀ (i : Fin n) (r q : Fin d),
+    decode ((result.output[i.val * d * d + r.val * d + q.val]?).getD ⟨false, 0, 1⟩) =
+      expectedEntry n s i r q) ∧
+  result.cost ≤ costBound n s ∧
+  (NCHitting.BitRefinement.Exec expectedProgram [n, s] result.output
+      (NCHitting.BitRefinement.executionSteps expectedProgram [n, s]) ∧
+    NCHitting.BitRefinement.executionSteps expectedProgram [n, s] ≤ primitiveBitBound n s) ∧
+  UniversalHitting.{u} n s d (expectedEntry n s)
+
+def CompleteTheorem : Prop :=
+  ∀ n s : ℕ, 1 ≤ n → 1 ≤ s → CompleteClaim.{u} n s
+
+end NCHittingSpecification
+
+end OAI
diff --git a/lean/OAI/Algebra/FormulaHitting/System.lean b/lean/OAI/Algebra/FormulaHitting/System.lean
new file mode 100644
index 0000000000000000000000000000000000000000..5fb576f9da2bb6730347c6ca000057ece4047ab8
--- /dev/null
+++ b/lean/OAI/Algebra/FormulaHitting/System.lean
@@ -0,0 +1,301 @@
+import OAI.Algebra.FormulaHitting.Representation
+import OAI.Algebra.FormulaHitting.Series
+import Mathlib.LinearAlgebra.Matrix.NonsingularInverse
+import Mathlib.Algebra.Polynomial.BigOperators
+import Mathlib.RingTheory.PowerSeries.Inverse
+
+namespace OAI
+
+noncomputable section
+namespace NCHitting
+namespace AcyclicRepresentation
+
+open Matrix
+variable {F : Type*} {n : ℕ} [Field F] [CharZero F]
+
+omit [CharZero F] in
+theorem J_sum {I : Type*} (i : ℕ) (s : Finset I) (f : I → PowerSeries F) :
+    J i (∑ a ∈ s, f a) = ∑ a ∈ s, J i (f a) := by
+  classical
+  induction s using Finset.induction_on with
+  | empty => simp
+  | @insert a s ha ih => simp [ha, J_add, ih]
+
+omit [CharZero F] in
+theorem J_C_mul (i : ℕ) (c : F) (f : PowerSeries F) :
+    J i (PowerSeries.C c * f) = PowerSeries.C c * J i f := by
+  simpa only [PowerSeries.smul_eq_C_mul] using J_smul i c f
+
+def systemLevel (R : AcyclicRepresentation F n) :
+    ℕ → Matrix R.State R.State (PowerSeries F)
+  | 0 => 1
+  | k + 1 => fun a b => ∑ i : Fin n, ∑ c : R.State,
+      PowerSeries.C (R.B i a c) * J (i.val + 1) (systemLevel R k c b)
+
+def systemMatrix (R : AcyclicRepresentation F n) :
+    Matrix R.State R.State (PowerSeries F) :=
+  fun a b => ∑ i : Fin n, PowerSeries.C (R.B i a b) * kernel (i.val + 1)
+
+def fundamentalMatrix (R : AcyclicRepresentation F n) :
+    Matrix R.State R.State (PowerSeries F) :=
+  fun a b => ∑ k ∈ Finset.range (Fintype.card R.State), R.systemLevel k a b
+
+def denominator (n : ℕ) : Polynomial F :=
+  ∏ i : Fin n, (Polynomial.X + Polynomial.C ((i.val + 1 : ℕ) : F))
+
+def cofactor (i : Fin n) : Polynomial F :=
+  ∏ j ∈ Finset.univ.erase i, (Polynomial.X + Polynomial.C ((j.val + 1 : ℕ) : F))
+
+def systemNumerator (R : AcyclicRepresentation F n) :
+    Matrix R.State R.State (Polynomial F) :=
+  fun a b => ∑ i : Fin n, Polynomial.C (R.B i a b) * cofactor i
+
+omit [CharZero F] in
+theorem denominator_eq (i : Fin n) : denominator (F := F) n =
+    (Polynomial.X + Polynomial.C ((i.val + 1 : ℕ) : F)) * cofactor i := by
+  exact (Finset.mul_prod_erase _ _ (Finset.mem_univ i)).symm
+
+omit [CharZero F] in
+theorem denominator_degree : (denominator (F := F) n).natDegree ≤ n := by
+  apply (Polynomial.natDegree_prod_le _ _).trans
+  simp only [Polynomial.natDegree_X_add_C]
+  simp
+
+omit [CharZero F] in
+theorem cofactor_degree (i : Fin n) : (cofactor (F := F) i).natDegree ≤ n - 1 := by
+  apply (Polynomial.natDegree_prod_le _ _).trans
+  simp only [Polynomial.natDegree_X_add_C]
+  simp
+
+omit [CharZero F] in
+theorem systemNumerator_degree (R : AcyclicRepresentation F n) (a b : R.State) :
+    (R.systemNumerator a b).natDegree ≤ n - 1 := by
+  apply Polynomial.natDegree_sum_le_of_forall_le
+  intro i _
+  exact (Polynomial.natDegree_C_mul_le _ _).trans (cofactor_degree i)
+
+theorem denominator_eval_zero_ne : (denominator (F := F) n).eval 0 ≠ 0 := by
+  simp only [denominator, Polynomial.eval_prod, Polynomial.eval_add,
+    Polynomial.eval_X, Polynomial.eval_C, zero_add]
+  apply Finset.prod_ne_zero_iff.mpr
+  intro i _
+  exact Nat.cast_ne_zero.mpr (Nat.succ_ne_zero i.val)
+
+theorem denominator_mul_kernel (i : Fin n) :
+    (denominator (F := F) n : PowerSeries F) * kernel (i.val + 1) =
+      (cofactor (F := F) i : PowerSeries F) := by
+  rw [denominator_eq i]
+  simp only [Polynomial.coe_mul, Polynomial.coe_add, Polynomial.coe_X, Polynomial.coe_C]
+  calc
+    (PowerSeries.X + PowerSeries.C ((i.val + 1 : ℕ) : F)) *
+        (cofactor (F := F) i : PowerSeries F) * kernel (i.val + 1) =
+        (cofactor (F := F) i : PowerSeries F) *
+          (kernel (i.val + 1) * (PowerSeries.X + PowerSeries.C ((i.val + 1 : ℕ) : F))) := by ring
+    _ = _ := by rw [kernel_mul_linear _ (Nat.succ_ne_zero _)]; simp
+
+omit [CharZero F] in
+theorem polynomial_coe_sum {I : Type*} [Fintype I] (p : I → Polynomial F) :
+    ((∑ i, p i : Polynomial F) : PowerSeries F) = ∑ i, (p i : PowerSeries F) :=
+  map_sum Polynomial.coeToPowerSeries.ringHom p Finset.univ
+
+theorem denominator_mul_systemMatrix (R : AcyclicRepresentation F n) (a b : R.State) :
+    (denominator (F := F) n : PowerSeries F) * R.systemMatrix a b =
+      (R.systemNumerator a b : PowerSeries F) := by
+  simp only [systemMatrix, systemNumerator, polynomial_coe_sum, Polynomial.coe_mul,
+    Polynomial.coe_C, Finset.mul_sum]
+  apply Finset.sum_congr rfl
+  intro i _
+  rw [mul_left_comm, denominator_mul_kernel]
+
+omit [CharZero F] in
+theorem systemLevel_wordSum (R : AcyclicRepresentation F n)
+    (k : ℕ) (a b : R.State) :
+    R.systemLevel k a b = ∑ w ∈ wordsOfLength n k,
+      PowerSeries.C (wordMatrix R.B w a b) * wordSeries w := by
+  induction k generalizing a b with
+  | zero =>
+    by_cases h : a = b <;>
+      simp [systemLevel, wordsOfLength, wordMatrix, Matrix.one_apply, h]
+  | succ k ih =>
+    rw [sum_wordsOfLength_succ]
+    simp only [systemLevel, ih, J_sum, J_C_mul, wordSeries_cons,
+      wordMatrix, List.map_cons, List.prod_cons, Matrix.mul_apply,
+      map_sum, map_mul, Finset.mul_sum, Finset.sum_mul, mul_assoc]
+    apply Finset.sum_congr rfl
+    intro i _
+    exact Finset.sum_comm
+
+def contract (R : AcyclicRepresentation F n) :
+    Matrix R.State R.State (PowerSeries F) →ₗ[PowerSeries F] PowerSeries F where
+  toFun M := (fun a => PowerSeries.C (R.u a)) ⬝ᵥ
+    (M *ᵥ (fun b => PowerSeries.C (R.v b)))
+  map_add' M N := by simp [add_mulVec, dotProduct_add]
+  map_smul' c M := by simp [smul_mulVec, dotProduct_smul]
+
+omit [CharZero F] in
+theorem contract_eq_sum (R : AcyclicRepresentation F n)
+    (M : Matrix R.State R.State (PowerSeries F)) :
+    R.contract M = ∑ b : R.State, PowerSeries.C (R.v b) *
+      ∑ a : R.State, PowerSeries.C (R.u a) * M a b := by
+  simp only [contract, LinearMap.coe_mk, AddHom.coe_mk, dotProduct, Matrix.mulVec,
+    Finset.mul_sum]
+  rw [Finset.sum_comm]
+  apply Finset.sum_congr rfl
+  intro b _
+  apply Finset.sum_congr rfl
+  intro a _
+  ring
+
+omit [CharZero F] in
+theorem contract_wordMatrix (R : AcyclicRepresentation F n) (w : Word n) :
+    R.contract ((wordMatrix R.B w).map PowerSeries.C) = PowerSeries.C (R.value w) := by
+  rw [R.value_eq_matrix]
+  simp [contract, dotProduct, Matrix.mulVec, Matrix.map_apply, map_sum, map_mul]
+
+omit [CharZero F] in
+theorem systemLevel_eq_sum (R : AcyclicRepresentation F n) (k : ℕ) :
+    R.systemLevel k = ∑ w ∈ wordsOfLength n k,
+      wordSeries (F := F) w • (wordMatrix R.B w).map PowerSeries.C := by
+  apply Matrix.ext
+  intro a b
+  simpa [Matrix.sum_apply, Matrix.map_apply, Pi.smul_apply, smul_eq_mul, mul_comm] using
+    R.systemLevel_wordSum k a b
+
+omit [CharZero F] in
+theorem fundamentalMatrix_eq_sum (R : AcyclicRepresentation F n) :
+    R.fundamentalMatrix =
+      ∑ k ∈ Finset.range (Fintype.card R.State), R.systemLevel k := by
+  apply Matrix.ext
+  intro a b
+  simp [fundamentalMatrix, Matrix.sum_apply]
+
+omit [CharZero F] in
+theorem contract_fundamentalMatrix (R : AcyclicRepresentation F n) :
+    R.contract R.fundamentalMatrix =
+      ∑ k ∈ Finset.range (Fintype.card R.State), ∑ w ∈ wordsOfLength n k,
+        PowerSeries.C (R.value w) * wordSeries w := by
+  rw [fundamentalMatrix_eq_sum]
+  simp [systemLevel_eq_sum, contract_wordMatrix, smul_eq_mul, mul_comm]
+
+omit [CharZero F] in
+theorem systemLevel_constant_zero (R : AcyclicRepresentation F n)
+    (k : ℕ) (a b : R.State) :
+    PowerSeries.constantCoeff (R.systemLevel (k + 1) a b) = 0 := by
+  simp [systemLevel]
+
+omit [CharZero F] in
+theorem systemLevel_entry_zero (R : AcyclicRepresentation F n)
+    (k : ℕ) (a b : R.State) (h : R.rank b < R.rank a + k) :
+    R.systemLevel k a b = 0 := by
+  induction k generalizing a with
+  | zero =>
+    have hne : a ≠ b := by intro he; subst b; simp at h
+    simp [systemLevel, hne]
+  | succ k ih =>
+    simp only [systemLevel]
+    apply Finset.sum_eq_zero
+    intro i _
+    apply Finset.sum_eq_zero
+    intro c _
+    by_cases hc : R.rank c ≤ R.rank a
+    · simp [R.upper i a c hc]
+    · have hbc : R.rank b < R.rank c + k := by omega
+      rw [ih c hbc]
+      simp
+
+omit [CharZero F] in
+theorem systemLevel_eq_zero (R : AcyclicRepresentation F n)
+    (k : ℕ) (h : Fintype.card R.State ≤ k) : R.systemLevel k = 0 := by
+  apply Matrix.ext
+  intro a b
+  apply R.systemLevel_entry_zero k a b
+  have hb := R.rank_lt b
+  omega
+
+theorem derivative_systemLevel (R : AcyclicRepresentation F n)
+    (k : ℕ) (a b : R.State) :
+    PowerSeries.derivative (R := F) (R.systemLevel (k + 1) a b) =
+      (R.systemMatrix * R.systemLevel k) a b := by
+  simp only [systemLevel, map_sum, Derivation.leibniz, smul_eq_mul, derivative_J,
+    PowerSeries.derivative_C, systemMatrix, Matrix.mul_apply,
+    Finset.sum_mul]
+  rw [Finset.sum_comm]
+  apply Finset.sum_congr rfl
+  intro c _
+  apply Finset.sum_congr rfl
+  intro i _
+  ring
+
+omit [CharZero F] in
+theorem fundamentalMatrix_constant (R : AcyclicRepresentation F n)
+    (hm : 0 < Fintype.card R.State) :
+    R.fundamentalMatrix.map PowerSeries.constantCoeff = 1 := by
+  apply Matrix.ext
+  intro a b
+  obtain ⟨k, hk⟩ := Nat.exists_eq_succ_of_ne_zero (Nat.ne_of_gt hm)
+  simp only [Matrix.map_apply, fundamentalMatrix, hk,
+    Finset.sum_range_succ']
+  simp [systemLevel, Matrix.one_apply]
+
+omit [CharZero F] in
+theorem fundamentalMatrix_isUnit (R : AcyclicRepresentation F n)
+    (hm : 0 < Fintype.card R.State) : IsUnit R.fundamentalMatrix := by
+  apply (Matrix.isUnit_iff_isUnit_det _).mpr
+  apply (PowerSeries.isUnit_iff_constantCoeff).mpr
+  have hc : PowerSeries.constantCoeff R.fundamentalMatrix.det = 1 := by
+    rw [RingHom.map_det]
+    change (R.fundamentalMatrix.map PowerSeries.constantCoeff).det = 1
+    rw [R.fundamentalMatrix_constant hm, Matrix.det_one]
+  rw [hc]
+  exact isUnit_one
+
+theorem fundamentalMatrix_derivative (R : AcyclicRepresentation F n) :
+    R.fundamentalMatrix.map (PowerSeries.derivative (R := F)) =
+      R.systemMatrix * R.fundamentalMatrix := by
+  apply Matrix.ext
+  intro a b
+  let D : ℕ → PowerSeries F := fun k => PowerSeries.derivative (R := F) (R.systemLevel k a b)
+  have hD0 : D 0 = 0 := by
+    by_cases h : a = b <;> simp [D, systemLevel, h]
+  have hDm : D (Fintype.card R.State) = 0 := by
+    simp [D, R.systemLevel_eq_zero _ (le_refl _)]
+  have hshift : (∑ k ∈ Finset.range (Fintype.card R.State), D k) =
+      ∑ k ∈ Finset.range (Fintype.card R.State), D (k + 1) := by
+    have hleft := Finset.sum_range_succ D (Fintype.card R.State)
+    have hright := Finset.sum_range_succ' D (Fintype.card R.State)
+    simpa [hD0, hDm] using hleft.symm.trans hright
+  simp only [Matrix.map_apply, fundamentalMatrix, map_sum]
+  change (∑ k ∈ Finset.range (Fintype.card R.State), D k) = _
+  rw [hshift]
+  simp only [D, derivative_systemLevel, Matrix.mul_apply, fundamentalMatrix,
+    Finset.mul_sum]
+  exact Finset.sum_comm
+
+theorem fundamentalMatrix_polynomial_system (R : AcyclicRepresentation F n)
+    (a b : R.State) :
+    (denominator (F := F) n : PowerSeries F) *
+        PowerSeries.derivative (R := F) (R.fundamentalMatrix a b) =
+      ∑ c : R.State, (R.systemNumerator a c : PowerSeries F) *
+        R.fundamentalMatrix c b := by
+  have hder := congrFun (congrFun R.fundamentalMatrix_derivative a) b
+  change PowerSeries.derivative (R := F) (R.fundamentalMatrix a b) =
+    ∑ c : R.State, R.systemMatrix a c * R.fundamentalMatrix c b at hder
+  rw [hder, Finset.mul_sum]
+  apply Finset.sum_congr rfl
+  intro c _
+  rw [← mul_assoc, denominator_mul_systemMatrix]
+
+end AcyclicRepresentation
+
+theorem Formula.system_output {F : Type*} {n : ℕ} [Field F] [CharZero F]
+    (f : Formula F n) :
+    f.representation.contract f.representation.fundamentalMatrix =
+      ∑ k ∈ Finset.range (Fintype.card f.representation.State),
+        ∑ w ∈ wordsOfLength n k, PowerSeries.C (f.coeff w) * wordSeries w := by
+  simp only [AcyclicRepresentation.contract_fundamentalMatrix, Formula.representation_correct]
+
+end NCHitting
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/FormulaHitting/SystemOutput.lean b/lean/OAI/Algebra/FormulaHitting/SystemOutput.lean
new file mode 100644
index 0000000000000000000000000000000000000000..84910bd9381659a0a4aae20acd19cac5a7fa0fa7
--- /dev/null
+++ b/lean/OAI/Algebra/FormulaHitting/SystemOutput.lean
@@ -0,0 +1,16 @@
+import OAI.Algebra.FormulaHitting.System
+import OAI.Algebra.FormulaHitting.FormulaSeries
+
+namespace OAI
+
+namespace NCHitting
+
+theorem Formula.system_output_eq_series {F : Type*} {n : ℕ}
+    [Field F] [CharZero F] (f : Formula F n) :
+    f.representation.contract f.representation.fundamentalMatrix = f.series := by
+  rw [f.system_output, f.series_eq_sum_of_cutoff
+    (Fintype.card f.representation.State) f.coeff_zero_of_representation_dimension_le]
+
+end NCHitting
+
+end OAI
diff --git a/lean/OAI/Algebra/FormulaHitting/WordIndependence.lean b/lean/OAI/Algebra/FormulaHitting/WordIndependence.lean
new file mode 100644
index 0000000000000000000000000000000000000000..94f75ab786c6cf7783cada88539f2a6e4504ffb2
--- /dev/null
+++ b/lean/OAI/Algebra/FormulaHitting/WordIndependence.lean
@@ -0,0 +1,341 @@
+import OAI.Algebra.FormulaHitting.Series
+import OAI.Algebra.FormulaHitting.Independence
+import Mathlib.Data.Finsupp.Basic
+import Mathlib.Algebra.BigOperators.Finsupp.Basic
+import Mathlib.LinearAlgebra.Finsupp.LinearCombination
+
+namespace OAI
+
+noncomputable section
+open Polynomial PowerSeries
+namespace NCHitting
+
+variable {F : Type*} [Field F] [CharZero F] {n : ℕ}
+
+abbrev PolyWords (F : Type*) [Field F] (n : ℕ) := List (Fin n) →₀ F[X]
+
+def polynomialEncode : PolyWords F n →+ PowerSeries F :=
+  Finsupp.liftAddHom fun w =>
+    { toFun := fun p => (p : PowerSeries F) * wordSeries w
+      map_zero' := by simp
+      map_add' := by intro p q; simp [add_mul] }
+
+omit [CharZero F] in
+@[simp] theorem polynomialEncode_single (w : List (Fin n)) (p : F[X]) :
+    polynomialEncode (Finsupp.single w p) = (p : PowerSeries F) * wordSeries w := by
+  simp [polynomialEncode]
+
+def stripLetter (i : Fin n) : PolyWords F n →+ PolyWords F n :=
+  Finsupp.comapDomain.addMonoidHom (List.cons_injective (a := i))
+
+omit [CharZero F] in
+@[simp] theorem stripLetter_apply (i : Fin n) (c : PolyWords F n) (w : List (Fin n)) :
+    stripLetter i c w = c (i :: w) := rfl
+
+omit [CharZero F] in
+@[simp] theorem stripLetter_single_nil (i : Fin n) (p : F[X]) :
+    stripLetter i (Finsupp.single [] p) = 0 := by
+  ext w
+  simp [stripLetter_apply]
+
+omit [CharZero F] in
+@[simp] theorem stripLetter_single_cons (i j : Fin n) (w : List (Fin n)) (p : F[X]) :
+    stripLetter i (Finsupp.single (j :: w) p) =
+      if i = j then Finsupp.single w p else 0 := by
+  classical
+  by_cases h : i = j
+  · subst j
+    ext v
+    simp [stripLetter_apply, Finsupp.single_apply]
+  · ext v
+    simp [stripLetter_apply, h]
+
+def polynomialDifferential (q p0 : F[X]) : F[X] →+ F[X] where
+  toFun p := q * (p0 * p.derivative - p0.derivative * p)
+  map_zero' := by simp
+  map_add' p r := by simp [Polynomial.derivative_add]; ring
+
+def polynomialMul (q : F[X]) : F[X] →+ F[X] where
+  toFun p := q * p
+  map_zero' := mul_zero q
+  map_add' := mul_add q
+
+def polynomialTransform (q p0 : F[X]) (Q : Fin n → F[X]) : PolyWords F n →+ PolyWords F n :=
+  Finsupp.mapRange.addMonoidHom (polynomialDifferential q p0) +
+    ∑ i, (Finsupp.mapRange.addMonoidHom (polynomialMul (p0 * Q i))).comp (stripLetter i)
+
+omit [CharZero F] in
+@[simp] theorem polynomialTransform_apply (q p0 : F[X]) (Q : Fin n → F[X])
+    (c : PolyWords F n) (w : List (Fin n)) :
+    polynomialTransform q p0 Q c w =
+      q * (p0 * (c w).derivative - p0.derivative * c w) +
+        ∑ i, (p0 * Q i) * c (i :: w) := by
+  classical
+  simp [polynomialTransform, polynomialDifferential, polynomialMul]
+
+omit [CharZero F] in
+@[simp] theorem polynomialTransform_single_nil (q p0 : F[X]) (Q : Fin n → F[X])
+    (p : F[X]) :
+    polynomialTransform q p0 Q (Finsupp.single [] p) =
+      Finsupp.single [] (q * (p0 * p.derivative - p0.derivative * p)) := by
+  classical
+  simp [polynomialTransform, polynomialDifferential, polynomialMul]
+
+omit [CharZero F] in
+@[simp] theorem polynomialTransform_single_cons (q p0 : F[X]) (Q : Fin n → F[X])
+    (i : Fin n) (w : List (Fin n)) (p : F[X]) :
+    polynomialTransform q p0 Q (Finsupp.single (i :: w) p) =
+      Finsupp.single (i :: w) (q * (p0 * p.derivative - p0.derivative * p)) +
+        Finsupp.single w ((p0 * Q i) * p) := by
+  classical
+  simp [polynomialTransform, polynomialDifferential, polynomialMul, apply_ite]
+
+omit [CharZero F] in
+theorem polynomialEncode_transform (q p0 : F[X]) (Q : Fin n → F[X])
+    (hq : ∀ (i : Fin n) (w : List (Fin n)),
+      (q : PowerSeries F) * PowerSeries.derivative (R := F) (wordSeries (i :: w)) =
+        (Q i : PowerSeries F) * wordSeries w)
+    (c : PolyWords F n) :
+    polynomialEncode (polynomialTransform q p0 Q c) =
+      (q : PowerSeries F) * ((p0 : PowerSeries F) *
+        PowerSeries.derivative (R := F) (polynomialEncode c) -
+          (p0.derivative : PowerSeries F) * polynomialEncode c) := by
+  classical
+  induction c using Finsupp.induction_linear with
+  | zero => simp
+  | add c d hc hd =>
+    simp only [map_add, hc, hd]
+    ring
+  | single w p =>
+    cases w with
+    | nil => simp [PowerSeries.derivative_coe]
+    | cons i w =>
+      rw [polynomialTransform_single_cons, map_add, polynomialEncode_single,
+        polynomialEncode_single, polynomialEncode_single]
+      simp only [Polynomial.coe_mul, Polynomial.coe_sub]
+      symm
+      calc
+        _ = ((q : PowerSeries F) * ((p0 : PowerSeries F) *
+              (p.derivative : PowerSeries F) - (p0.derivative : PowerSeries F) *
+                (p : PowerSeries F))) *
+              wordSeries (i :: w) +
+            ((p0 : PowerSeries F) * (p : PowerSeries F)) *
+              ((q : PowerSeries F) * PowerSeries.derivative (R := F) (wordSeries (i :: w))) := by
+          rw [Derivation.leibniz, PowerSeries.derivative_coe]
+          simp only [smul_eq_mul]
+          ring
+        _ = _ := by rw [hq]; ring
+
+def naturalPoles (i : Fin n) : F := -((i.val + 1 : ℕ) : F)
+
+theorem naturalPoles_injective : Function.Injective (naturalPoles (F := F) (n := n)) := by
+  intro i j h
+  apply Fin.ext
+  have he : ((i.val + 1 : ℕ) : F) = ((j.val + 1 : ℕ) : F) := neg_injective h
+  have hn := Nat.cast_injective he
+  omega
+
+omit [CharZero F] in
+theorem natural_poleProduct_ne_zero : poleProduct (naturalPoles (F := F) (n := n)) ≠ 0 := by
+  apply Finset.prod_ne_zero_iff.mpr
+  intro i hi
+  exact Polynomial.X_sub_C_ne_zero _
+
+theorem natural_poleProduct_mul_kernel (i : Fin n) :
+    (poleProduct (naturalPoles (F := F) (n := n)) : PowerSeries F) * kernel (i.val + 1) =
+      (puncturedPoleProduct (naturalPoles (F := F)) i : PowerSeries F) := by
+  rw [poleProduct_eq _ i]
+  simp only [Polynomial.coe_mul, Polynomial.coe_add,
+    Polynomial.coe_X, Polynomial.coe_C,
+    naturalPoles, map_neg, sub_neg_eq_add]
+  calc
+    _ = (puncturedPoleProduct (naturalPoles (F := F)) i : PowerSeries F) *
+          (kernel (i.val + 1) * (PowerSeries.X + PowerSeries.C (((i.val + 1 : ℕ) : F)))) := by ring
+    _ = _ := by rw [kernel_mul_linear _ (Nat.succ_ne_zero _)]; simp
+
+theorem natural_poleProduct_derivative (i : Fin n) (w : List (Fin n)) :
+    (poleProduct (naturalPoles (F := F) (n := n)) : PowerSeries F) *
+      PowerSeries.derivative (R := F) (wordSeries (i :: w)) =
+        (puncturedPoleProduct (naturalPoles (F := F)) i : PowerSeries F) * wordSeries w := by
+  rw [derivative_wordSeries_cons]
+  rw [mul_left_comm, natural_poleProduct_mul_kernel, mul_comm]
+
+def LengthBound (D : ℕ) (c : PolyWords F n) : Prop :=
+  ∀ w, c w ≠ 0 → w.length ≤ D
+
+def topSupport (D : ℕ) (c : PolyWords F n) : Finset (List (Fin n)) :=
+  c.support.filter fun w => w.length = D
+
+omit [CharZero F] in
+@[simp] theorem mem_topSupport (D : ℕ) (c : PolyWords F n) (w : List (Fin n)) :
+    w ∈ topSupport D c ↔ c w ≠ 0 ∧ w.length = D := by
+  simp [topSupport]
+
+omit [CharZero F] in
+theorem transform_lengthBound (D : ℕ) (c : PolyWords F n) (hc : LengthBound D c)
+    (q p0 : F[X]) (Q : Fin n → F[X]) : LengthBound D (polynomialTransform q p0 Q c) := by
+  intro w hw
+  by_contra hlen
+  have hcw : c w = 0 := by
+    by_contra hne
+    exact hlen (hc w hne)
+  have hchild : ∀ i, c (i :: w) = 0 := by
+    intro i
+    by_contra hne
+    have hb := hc (i :: w) hne
+    simp only [List.length_cons] at hb
+    omega
+  apply hw
+  simp [hcw, hchild]
+
+omit [CharZero F] in
+theorem transform_top_coefficient (D : ℕ) (c : PolyWords F n) (hc : LengthBound D c)
+    (q p0 : F[X]) (Q : Fin n → F[X]) (w : List (Fin n)) (hw : w.length = D) :
+    polynomialTransform q p0 Q c w = q * (p0 * (c w).derivative - p0.derivative * c w) := by
+  have hchild : ∀ i, c (i :: w) = 0 := by
+    intro i
+    by_contra hne
+    have hb := hc (i :: w) hne
+    simp only [List.length_cons, hw] at hb
+    omega
+  simp [hchild]
+
+omit [CharZero F] in
+private theorem topSupport_transform_ssubset (D : ℕ) (c : PolyWords F n)
+    (hc : LengthBound D c) (q : F[X]) (Q : Fin n → F[X])
+    (w0 : List (Fin n)) (hw0 : w0 ∈ topSupport D c) :
+    topSupport D (polynomialTransform q (c w0) Q c) ⊂ topSupport D c := by
+  have hsub : topSupport D (polynomialTransform q (c w0) Q c) ⊆ topSupport D c := by
+    intro w hw
+    obtain ⟨hne, hlen⟩ := (mem_topSupport _ _ _).mp hw
+    apply (mem_topSupport _ _ _).mpr
+    refine ⟨?_, hlen⟩
+    intro hz
+    apply hne
+    rw [transform_top_coefficient D c hc q (c w0) Q w hlen, hz]
+    simp
+  apply Finset.ssubset_iff_subset_ne.mpr
+  refine ⟨hsub, ?_⟩
+  intro heq
+  have hm : w0 ∈ topSupport D (polynomialTransform q (c w0) Q c) := by rwa [heq]
+  have hz : polynomialTransform q (c w0) Q c w0 = 0 := by
+    rw [transform_top_coefficient D c hc q (c w0) Q w0
+      ((mem_topSupport _ _ _).mp hw0).2]
+    ring
+  exact ((mem_topSupport _ _ _).mp hm).1 hz
+
+theorem polynomialEncode_eq_zero (D : ℕ) (c : PolyWords F n)
+    (hc : LengthBound D c) (he : polynomialEncode c = 0) : c = 0 := by
+  classical
+  induction D generalizing c with
+  | zero =>
+    have hs : c = Finsupp.single [] (c []) := by
+      ext w
+      cases w with
+      | nil => simp
+      | cons i w =>
+        have hz : c (i :: w) = 0 := by
+          by_contra hne
+          have hh := hc (i :: w) hne
+          simp [List.length_cons] at hh
+        simp [hz]
+    have hz : c [] = 0 := by
+      have hh := he
+      rw [hs, polynomialEncode_single, wordSeries_nil, mul_one] at hh
+      exact Polynomial.coe_eq_zero_iff.mp hh
+    rw [hs, hz, Finsupp.single_zero]
+  | succ D ih =>
+    by_contra hcne
+    have top_exists : ∀ b : PolyWords F n, LengthBound (D+1) b →
+        polynomialEncode b = 0 → b ≠ 0 → (topSupport (D+1) b).Nonempty := by
+      intro b hb hbe hbne
+      by_contra hn
+      apply hbne
+      apply ih b ?_ hbe
+      intro w hw
+      have hbnd := hb w hw
+      have hneq : w.length ≠ D+1 := by
+        intro hlen
+        exact hn ⟨w, (mem_topSupport _ _ _).mpr ⟨hw, hlen⟩⟩
+      omega
+    let P : ℕ → Prop := fun k => ∃ b : PolyWords F n,
+      LengthBound (D+1) b ∧ polynomialEncode b = 0 ∧ b ≠ 0 ∧
+        (topSupport (D+1) b).card = k
+    have hex : ∃ k, P k := ⟨(topSupport (D+1) c).card, c, hc, he, hcne, rfl⟩
+    obtain ⟨b, hb, hbe, hbne, hbcard⟩ := Nat.find_spec hex
+    obtain ⟨w0, hw0⟩ := top_exists b hb hbe hbne
+    have hp0 : b w0 ≠ 0 := ((mem_topSupport _ _ _).mp hw0).1
+    have hwlen : w0.length = D+1 := ((mem_topSupport _ _ _).mp hw0).2
+    let q := poleProduct (naturalPoles (F := F) (n := n))
+    let Q := puncturedPoleProduct (naturalPoles (F := F) (n := n))
+    let p0 := b w0
+    let b' := polynomialTransform q p0 Q b
+    have hb' : LengthBound (D+1) b' := transform_lengthBound _ b hb q p0 Q
+    have hb'e : polynomialEncode b' = 0 := by
+      rw [polynomialEncode_transform q p0 Q natural_poleProduct_derivative, hbe]
+      simp
+    have hcard : (topSupport (D+1) b').card < (topSupport (D+1) b).card :=
+      Finset.card_lt_card (topSupport_transform_ssubset (D+1) b hb q Q w0 hw0)
+    have hb'zero : b' = 0 := by
+      by_contra hne
+      have hmin : Nat.find hex ≤ (topSupport (D+1) b').card :=
+        Nat.find_min' hex ⟨b', hb', hb'e, hne, rfl⟩
+      omega
+    have htop : ∀ w, w.length = D+1 →
+        Polynomial.wronskian p0 (b w) = 0 := by
+      intro w hw
+      have hh : polynomialTransform q p0 Q b w = 0 := by
+        exact DFunLike.congr_fun hb'zero w
+      rw [transform_top_coefficient (D+1) b hb q p0 Q w hw] at hh
+      have hq : q ≠ 0 := natural_poleProduct_ne_zero
+      exact (mul_eq_zero.mp hh).resolve_left hq
+    cases w0 with
+    | nil => simp at hwlen
+    | cons i v =>
+      have hvl : v.length = D := by simpa using hwlen
+      have hprop : ∀ j : Fin n, ∃ a : F, b (j :: v) = a • p0 := by
+        intro j
+        apply eq_smul_of_wronskian_eq_zero p0 (b (j :: v)) hp0
+        apply htop
+        simp [hvl]
+      choose a ha using hprop
+      have hraw : q * (p0 * (b v).derivative - p0.derivative * b v) +
+          ∑ j, (p0 * Q j) * b (j :: v) = 0 := by
+        rw [← polynomialTransform_apply]
+        exact DFunLike.congr_fun hb'zero v
+      have hsum : (∑ j, (p0 * Q j) * b (j :: v)) =
+          p0^2 * (∑ j, Polynomial.C (a j) * Q j) := by
+        rw [Finset.mul_sum]
+        apply Finset.sum_congr rfl
+        intro j hj
+        rw [ha j, Polynomial.smul_eq_C_mul]
+        ring
+      rw [hsum] at hraw
+      have ha0 := no_polynomial_log_primitive (naturalPoles (F := F) (n := n))
+        naturalPoles_injective p0 (b v) hp0 a hraw i
+      apply hp0
+      rw [ha i, ha0, zero_smul]
+
+omit [CharZero F] in
+private theorem linearCombination_eq_polynomialEncode (c : PolyWords F n) :
+    Finsupp.linearCombination F[X] (wordSeries (F := F) (n := n)) c = polynomialEncode c := by
+  simp [Finsupp.linearCombination_apply, polynomialEncode, Finsupp.liftAddHom_apply,
+    Algebra.smul_def, PowerSeries.algebraMap_apply']
+
+theorem wordSeries_polynomial_independent :
+    LinearIndependent F[X] (wordSeries (F := F) (n := n)) := by
+  rw [linearIndependent_iff]
+  intro c hc
+  apply polynomialEncode_eq_zero (c.support.sup List.length) c
+  · intro w hw
+    exact Finset.le_sup (Finsupp.mem_support_iff.mpr hw)
+  · rwa [linearCombination_eq_polynomialEncode] at hc
+
+theorem wordSeries_independent : LinearIndependent F (wordSeries (F := F) (n := n)) :=
+  wordSeries_polynomial_independent.restrict_scalars' F
+
+end NCHitting
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/FormulaHitting/Wronskian.lean b/lean/OAI/Algebra/FormulaHitting/Wronskian.lean
new file mode 100644
index 0000000000000000000000000000000000000000..b459cbcc3ce0a541975169139baaf1f6617519f3
--- /dev/null
+++ b/lean/OAI/Algebra/FormulaHitting/Wronskian.lean
@@ -0,0 +1,196 @@
+import Mathlib.RingTheory.PowerSeries.Derivative
+import Mathlib.RingTheory.PowerSeries.Order
+import Mathlib.LinearAlgebra.Vandermonde
+import Mathlib.Tactic.Ring
+import Lean.Elab.Tactic.Omega
+
+namespace OAI
+
+noncomputable section
+
+namespace NCHitting
+
+open PowerSeries Matrix
+
+variable {F : Type*} [Field F]
+
+def derivativeIter : ℕ → PowerSeries F → PowerSeries F
+  | 0, f => f
+  | j + 1, f => PowerSeries.derivative (R := F) (derivativeIter j f)
+
+@[simp] theorem derivativeIter_zero (f : PowerSeries F) : derivativeIter 0 f = f := rfl
+
+@[simp] theorem derivativeIter_add (j : ℕ) (f g : PowerSeries F) :
+    derivativeIter j (f + g) = derivativeIter j f + derivativeIter j g := by
+  induction j with
+  | zero => rfl
+  | succ j ih => simp [derivativeIter, ih]
+
+@[simp] theorem derivativeIter_smul (j : ℕ) (c : F) (f : PowerSeries F) :
+    derivativeIter j (c • f) = c • derivativeIter j f := by
+  induction j with
+  | zero => rfl
+  | succ j ih => simp [derivativeIter, ih]
+
+theorem derivativeIter_sum {ι : Type*} (j : ℕ) (s : Finset ι) (f : ι → PowerSeries F) :
+    derivativeIter j (∑ i ∈ s, f i) = ∑ i ∈ s, derivativeIter j (f i) := by
+  induction j with
+  | zero => rfl
+  | succ j ih => simp [derivativeIter, ih]
+
+theorem coeff_derivativeIter (j r : ℕ) (f : PowerSeries F) :
+    PowerSeries.coeff r (derivativeIter j f) =
+      PowerSeries.coeff (r+j) f * ((r+j).descFactorial j : F) := by
+  induction j generalizing r with
+  | zero => simp [derivativeIter]
+  | succ j ih =>
+    rw [derivativeIter, PowerSeries.coeff_derivative, ih]
+    have he : r + 1 + j = r + (j + 1) := by omega
+    have hs : r + (j + 1) - j = r + 1 := by omega
+    rw [he, Nat.descFactorial_succ, hs, Nat.cast_mul]
+    push_cast
+    ring
+
+theorem coeff_X_pow_derivativeIter (j r : ℕ) (f : PowerSeries F) :
+    PowerSeries.coeff r (PowerSeries.X ^ j * derivativeIter j f) =
+      PowerSeries.coeff r f * (r.descFactorial j : F) := by
+  rw [PowerSeries.coeff_X_pow_mul']
+  split_ifs with h
+  · rw [coeff_derivativeIter, Nat.sub_add_cancel h]
+  · rw [Nat.descFactorial_of_lt (by omega), Nat.cast_zero, mul_zero]
+
+def derivativeTail (f : PowerSeries F) (a j : ℕ) : PowerSeries F :=
+  PowerSeries.mk fun r => PowerSeries.coeff (r+a) f * ((r+a).descFactorial j : F)
+
+@[simp] theorem coeff_derivativeTail (f : PowerSeries F) (a j r : ℕ) :
+    PowerSeries.coeff r (derivativeTail f a j) =
+      PowerSeries.coeff (r+a) f * ((r+a).descFactorial j : F) := by
+  simp [derivativeTail]
+
+theorem X_pow_derivativeIter_eq (f : PowerSeries F) (a j : ℕ)
+    (h : ∀ r < a, PowerSeries.coeff r f = 0) :
+    PowerSeries.X ^ j * derivativeIter j f =
+      PowerSeries.X ^ a * derivativeTail f a j := by
+  ext r
+  rw [coeff_X_pow_derivativeIter, PowerSeries.coeff_X_pow_mul']
+  split_ifs with ha
+  · rw [coeff_derivativeTail, Nat.sub_add_cancel ha]
+  · rw [h r (by omega), zero_mul]
+
+def wronskianMatrix {k : ℕ} (b : Fin k → PowerSeries F) :
+    Matrix (Fin k) (Fin k) (PowerSeries F) :=
+  fun j l => derivativeIter j.val (b l)
+
+def wronskian {k : ℕ} (b : Fin k → PowerSeries F) : PowerSeries F :=
+  (wronskianMatrix b).det
+
+theorem wronskian_linearCombination {k : ℕ} (b : Fin k → PowerSeries F)
+    (C : Matrix (Fin k) (Fin k) F) :
+    wronskian (fun l => ∑ i : Fin k, C i l • b i) =
+      wronskian b * PowerSeries.C C.det := by
+  have he : wronskianMatrix (fun l => ∑ i : Fin k, C i l • b i) =
+      wronskianMatrix b * (PowerSeries.C : F →+* PowerSeries F).mapMatrix C := by
+    funext j l
+    change derivativeIter j.val (∑ i : Fin k, C i l • b i) =
+      ∑ i : Fin k, derivativeIter j.val (b i) * PowerSeries.C (C i l)
+    rw [derivativeIter_sum]
+    simp only [derivativeIter_smul]
+    simp only [PowerSeries.smul_eq_C_mul]
+    apply Finset.sum_congr rfl
+    intro i _
+    exact mul_comm _ _
+  rw [wronskian, he, Matrix.det_mul, ← RingHom.map_det]
+  rfl
+
+def normalizedWronskianMatrix {k : ℕ} (b : Fin k → PowerSeries F)
+    (a : Fin k → ℕ) : Matrix (Fin k) (Fin k) (PowerSeries F) :=
+  fun j l => derivativeTail (b l) (a l) j.val
+
+theorem wronskianMatrix_scaling {k : ℕ} (b : Fin k → PowerSeries F)
+    (a : Fin k → ℕ) (h : ∀ l r, r < a l → PowerSeries.coeff r (b l) = 0) :
+    Matrix.diagonal (fun j : Fin k => (PowerSeries.X : PowerSeries F)^j.val) *
+      wronskianMatrix b =
+    normalizedWronskianMatrix b a *
+      Matrix.diagonal (fun l => (PowerSeries.X : PowerSeries F)^(a l)) := by
+  ext j l
+  simp only [Matrix.diagonal_mul, Matrix.mul_diagonal, wronskianMatrix,
+    normalizedWronskianMatrix]
+  rw [X_pow_derivativeIter_eq (b l) (a l) j.val (h l), mul_comm]
+
+theorem wronskian_det_scaling {k : ℕ} (b : Fin k → PowerSeries F)
+    (a : Fin k → ℕ) (h : ∀ l r, r < a l → PowerSeries.coeff r (b l) = 0) :
+    ((∏ j : Fin k, (PowerSeries.X : PowerSeries F)^j.val) * wronskian b) =
+      (normalizedWronskianMatrix b a).det *
+        ∏ l : Fin k, (PowerSeries.X : PowerSeries F)^(a l) := by
+  have hd := congrArg Matrix.det (wronskianMatrix_scaling b a h)
+  simpa only [Matrix.det_mul, Matrix.det_diagonal, wronskian] using hd
+
+theorem det_descFactorial {k : ℕ} (a : Fin k → ℕ) :
+    (Matrix.of fun j l : Fin k => ((a l).descFactorial j.val : F)).det =
+      (Matrix.vandermonde fun l => (a l : F)).det := by
+  have hh := Matrix.det_eval_matrixOfPolynomials_eq_det_vandermonde
+    (fun l : Fin k => (a l : F)) (fun j : Fin k => descPochhammer F j.val)
+    (fun j => descPochhammer_natDegree F j.val)
+    (fun j => monic_descPochhammer F j.val)
+  rw [← Matrix.det_transpose]
+  change (Matrix.of fun i j : Fin k => ((a i).descFactorial j.val : F)).det = _
+  simpa only [descPochhammer_eval_eq_descFactorial] using hh.symm
+
+theorem det_descFactorial_ne_zero [CharZero F] {k : ℕ} (a : Fin k → ℕ)
+    (ha : Function.Injective a) :
+    (Matrix.of fun j l : Fin k => ((a l).descFactorial j.val : F)).det ≠ 0 := by
+  rw [det_descFactorial]
+  apply Matrix.det_vandermonde_ne_zero_iff.mpr
+  exact (Nat.cast_injective (R := F)).comp ha
+
+theorem normalizedWronskian_constant_ne_zero [CharZero F] {k : ℕ} (b : Fin k → PowerSeries F)
+    (a : Fin k → ℕ) (ha : Function.Injective a)
+    (hb : ∀ l, PowerSeries.coeff (a l) (b l) ≠ 0) :
+    PowerSeries.constantCoeff (normalizedWronskianMatrix b a).det ≠ 0 := by
+  have he : (PowerSeries.constantCoeff : PowerSeries F →+* F).mapMatrix
+      (normalizedWronskianMatrix b a) =
+      (Matrix.of fun j l : Fin k => ((a l).descFactorial j.val : F)) *
+        Matrix.diagonal (fun l => PowerSeries.coeff (a l) (b l)) := by
+    funext j l
+    rw [Matrix.mul_diagonal]
+    change PowerSeries.constantCoeff (derivativeTail (b l) (a l) j.val) =
+      ((a l).descFactorial j.val : F) * PowerSeries.coeff (a l) (b l)
+    rw [← PowerSeries.coeff_zero_eq_constantCoeff, coeff_derivativeTail, Nat.zero_add]
+    exact mul_comm _ _
+  rw [RingHom.map_det, he, Matrix.det_mul, Matrix.det_diagonal]
+  exact mul_ne_zero (det_descFactorial_ne_zero a ha) (Finset.prod_ne_zero_iff.mpr (fun l _ => hb l))
+
+theorem wronskian_order_sum [CharZero F] {k : ℕ} (b : Fin k → PowerSeries F)
+    (a : Fin k → ℕ) (ha : Function.Injective a)
+    (hb : ∀ l, PowerSeries.coeff (a l) (b l) ≠ 0)
+    (hz : ∀ l r, r < a l → PowerSeries.coeff r (b l) = 0) :
+    wronskian b ≠ 0 ∧
+      (wronskian b).order.toNat + (∑ j : Fin k, j.val) = ∑ l : Fin k, a l := by
+  have hc := normalizedWronskian_constant_ne_zero b a ha hb
+  have hn : (normalizedWronskianMatrix b a).det ≠ 0 := by
+    intro h
+    exact hc (by rw [h, map_zero])
+  have ho : (normalizedWronskianMatrix b a).det.order = 0 := by
+    apply PowerSeries.order_eq_nat.mpr
+    exact ⟨by simpa only [PowerSeries.coeff_zero_eq_constantCoeff] using hc,
+      fun r hr => (Nat.not_lt_zero r hr).elim⟩
+  have he := wronskian_det_scaling b a hz
+  simp only [Finset.prod_pow_eq_pow_sum] at he
+  have hw : wronskian b ≠ 0 := by
+    intro h
+    rw [h, mul_zero] at he
+    exact (mul_ne_zero hn (pow_ne_zero _ PowerSeries.X_ne_zero)) he.symm
+  refine ⟨hw, ?_⟩
+  have hord := congrArg PowerSeries.order he
+  rw [PowerSeries.order_mul, PowerSeries.order_mul, ho, zero_add,
+    PowerSeries.order_X_pow, PowerSeries.order_X_pow,
+    ← PowerSeries.coe_toNat_order hw] at hord
+  have heq : (∑ j : Fin k, j.val) + (wronskian b).order.toNat = ∑ l : Fin k, a l := by
+    exact_mod_cast hord
+  omega
+
+end NCHitting
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/FormulaHitting/WronskianBound.lean b/lean/OAI/Algebra/FormulaHitting/WronskianBound.lean
new file mode 100644
index 0000000000000000000000000000000000000000..0892aafb65f156551f9b639ed0d2638f8ee7859d
--- /dev/null
+++ b/lean/OAI/Algebra/FormulaHitting/WronskianBound.lean
@@ -0,0 +1,78 @@
+import OAI.Algebra.FormulaHitting.OrderBasis
+import OAI.Algebra.FormulaHitting.Minors
+
+namespace OAI
+
+noncomputable section
+
+namespace NCHitting
+
+open PowerSeries Matrix Submodule
+
+variable {F : Type*} [Field F] [CharZero F]
+
+omit [CharZero F] in
+theorem derivativeIter_X_dvd (f : PowerSeries F) {a j : ℕ}
+    (h : a+j ≤ f.order.toNat) :
+    PowerSeries.X^a ∣ derivativeIter j f := by
+  rw [PowerSeries.X_pow_dvd_iff]
+  intro r hr
+  rw [coeff_derivativeIter, PowerSeries.coeff_of_lt_order_toNat _ (by omega), zero_mul]
+
+omit [CharZero F] in
+theorem derivativeIter_column_X_dvd (f : PowerSeries F) {k : ℕ}
+    (j : Fin k) :
+    PowerSeries.X^(f.order.toNat+1-k) ∣ derivativeIter j.val f := by
+  by_cases hk : k ≤ f.order.toNat+1
+  · apply derivativeIter_X_dvd
+    have hj := j.isLt
+    omega
+  · have ha : f.order.toNat+1-k = 0 := by omega
+    simp [ha]
+
+omit [CharZero F] in
+theorem order_le_wronskian_add {k : ℕ} (b : Fin k → PowerSeries F)
+    (hb : wronskian b ≠ 0) (y : PowerSeries F) (hy : y ≠ 0)
+    (hspan : y ∈ Submodule.span F (Set.range b)) :
+    y.order.toNat ≤ (wronskian b).order.toNat + k - 1 := by
+  classical
+  obtain ⟨c, hc⟩ := (Submodule.mem_span_range_iff_exists_fun F).mp hspan
+  have hex : ∃ l, c l ≠ 0 := by
+    by_contra h
+    push Not at h
+    apply hy
+    rw [← hc]
+    simp [h]
+  obtain ⟨l, hl⟩ := hex
+  let W := (wronskianMatrix b).updateCol l (fun j => derivativeIter j.val y)
+  have he : W.det = PowerSeries.C (c l) * wronskian b := by
+    have hcol : (fun j : Fin k => derivativeIter j.val y) =
+        fun j => ∑ i : Fin k, PowerSeries.C (c i) • wronskianMatrix b j i := by
+      funext j
+      rw [← hc, derivativeIter_sum]
+      simp only [derivativeIter_smul]
+      simp only [wronskianMatrix, PowerSeries.smul_eq_C_mul, smul_eq_mul]
+    change ((wronskianMatrix b).updateCol l _).det = _
+    rw [hcol, Matrix.det_updateCol_sum]
+    rfl
+  have hd : PowerSeries.X^(y.order.toNat+1-k) ∣ W.det := by
+    apply dvd_det_of_column_dvd W l
+    intro j
+    simpa [W] using derivativeIter_column_X_dvd y j
+  have hco : (PowerSeries.C (c l)).order = 0 := by
+    apply PowerSeries.order_eq_nat.mpr
+    exact ⟨by simpa using hl, fun r hr => (Nat.not_lt_zero r hr).elim⟩
+  have hlow : ((y.order.toNat+1-k : ℕ) : ℕ∞) ≤ (wronskian b).order := by
+    have hx := PowerSeries.nat_le_order W.det (y.order.toNat+1-k)
+      (PowerSeries.X_pow_dvd_iff.mp hd)
+    rwa [he, PowerSeries.order_mul, hco, zero_add] at hx
+  rw [← PowerSeries.coe_toNat_order hb] at hlow
+  have hn : y.order.toNat+1-k ≤ (wronskian b).order.toNat := by exact_mod_cast hlow
+  have hk := l.isLt
+  omega
+
+end NCHitting
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/FrobeniusObstruction/ActualBlocks.lean b/lean/OAI/Algebra/FrobeniusObstruction/ActualBlocks.lean
new file mode 100644
index 0000000000000000000000000000000000000000..e602d2540668d4aad5fcc00cd3c1fb7b0d157bff
--- /dev/null
+++ b/lean/OAI/Algebra/FrobeniusObstruction/ActualBlocks.lean
@@ -0,0 +1,246 @@
+import Mathlib
+import OAI.Algebra.FrobeniusObstruction.BlockPairing
+import OAI.Algebra.FrobeniusObstruction.ParameterLifts
+
+namespace OAI
+
+noncomputable section
+open scoped BigOperators
+
+namespace BoundaryOnly.FormalObstruction.ActualBlocks
+open Frobenius MixedForms FormsSplit GlobalForms SignedTensor
+open scoped TensorProduct BigOperators
+variable {k : Type*} [Field k] {d : ℕ} {n : Fin d → ℕ}
+
+abbrev Variables (n : Fin d → ℕ) (i : Fin d) := Bool × Fin (n i)
+
+def grouping : (Σ i, Variables n i) ≃ InternalVar n where
+  toFun x := (x.2.1, ⟨x.1,x.2.2⟩)
+  invFun x := ⟨x.2.1,(x.1,x.2.2)⟩
+  left_inv := by rintro ⟨i,b,y⟩; rfl
+  right_inv := by rintro ⟨b,i,y⟩; rfl
+
+def coordinates : Coordinates d (Variables n) ≃ InternalVar n :=
+  (coordinateEquiv d (Variables n)).trans grouping
+
+variable (ell : ℕ) [Fact ell.Prime] [CharP k ell]
+
+abbrev Scalar (i : Fin d) := Frobenius.Ring (ι := Variables n i) (k := k) ell
+abbrev Block (i : Fin d) := GlobalForms.QForms (k := k) ell (Variables n i)
+abbrev Ambient := GlobalForms.QForms (k := k) ell (InternalVar n)
+
+def includeScalar (i : Fin d) : Scalar (n := n) (k := k) ell i →ₐ[k]
+    Frobenius.Ring (ι := InternalVar n) (k := k) ell :=
+  includeVariables ell (fun y => (y.1,⟨i,y.2⟩))
+
+def includeBlock (i : Fin d) : Block (n := n) (k := k) ell i →ₐ[k]
+    Ambient (n := n) (k := k) ell :=
+  (FormsReindex.equiv ell coordinates).toAlgHom.comp
+    (insertForms ell d (Variables n) i)
+
+omit [Fact ell.Prime] [CharP k ell] in
+@[simp] theorem reindex_insertScalar (i : Fin d) (a : Scalar (n := n) (k := k) ell i) :
+    Frobenius.reindex ell coordinates (insertScalar ell d (Variables n) i a) =
+      includeScalar ell i a := by
+  have h : (Frobenius.reindex (k := k) ell (coordinates (n := n))).toAlgHom.comp
+      (insertScalar ell d (Variables n) i) = includeScalar ell i := by
+    apply algHom_ext
+    intro y
+    simp only [AlgHom.comp_apply, AlgEquiv.coe_toAlgHom, insertScalar_coordinate, reindex_coordinate,
+      includeScalar, includeVariables_coordinate]
+    congr 1
+    change grouping (coordinateEquiv d (Variables n) ((coordinateEquiv d (Variables n)).symm ⟨i,y⟩)) = _
+    rw [Equiv.apply_symm_apply]
+    rfl
+  exact AlgHom.congr_fun h a
+
+omit [Fact ell.Prime] [CharP k ell] in
+@[simp] theorem includeBlock_coeff (i : Fin d) (a : Scalar (n := n) (k := k) ell i) :
+    includeBlock ell i (coeff a) = coeff (includeScalar ell i a) := by
+  simp only [includeBlock, AlgHom.comp_apply, AlgEquiv.coe_toAlgHom, insertForms_coeff,
+    FormsReindex.equiv_coeff, reindex_insertScalar]
+
+def wall (b : Bool) (i : Fin d) :
+    Frobenius.Ring (ι := WallVar n i) (k := k) ell →ₐ[k] Scalar (n := n) (k := k) ell i :=
+  eval ell (Sum.elim (fun _ => 0) (fun y => coordinate ell (b,y))) (by
+    intro v
+    cases v with
+    | inl _ => exact zero_pow (Nat.Prime.ne_zero Fact.out)
+    | inr _ => exact coordinate_pow ell _)
+
+omit [CharP k ell] in
+@[simp] theorem include_wall (b : Bool) (i : Fin d)
+    (x : Frobenius.Ring (ι := WallVar n i) (k := k) ell) :
+    includeScalar ell i (wall ell b i x) = wallSpecial ell b i x := by
+  have h : (includeScalar (n := n) (k := k) ell i).comp (wall ell b i) = wallSpecial ell b i := by
+    apply algHom_ext
+    intro y
+    simp only [AlgHom.comp_apply, wall, eval_coordinate]
+    cases y with
+    | inl j => simp only [Sum.elim_inl, map_zero, wallSpecial_slope]
+    | inr y => simp only [Sum.elim_inr, includeScalar, includeVariables_coordinate,
+        wallSpecial_internal]
+  exact AlgHom.congr_fun h x
+
+def blockPotential (D : FormalData (k := k) n) (i : Fin d) : Scalar (n := n) (k := k) ell i :=
+  wall ell true i (Ideal.Quotient.mk _ (D.P i)) -
+    wall ell false i (Ideal.Quotient.mk _ (D.P i))
+
+def blockSlope (D : FormalData (k := k) n) (i : Fin d) : Scalar (n := n) (k := k) ell i :=
+  includeVariables ell (fun y => (true,y)) (Ideal.Quotient.mk _ (slopeDerivative n D.P i))
+
+omit [Fact ell.Prime] [CharP k ell] in
+@[simp] theorem include_blockSlope (D : FormalData (k := k) n) (i : Fin d) :
+    includeScalar ell i (blockSlope ell D i) = specialSlope ell D true i := by
+  have h : (includeScalar (k := k) ell i).comp (includeVariables ell (fun y : Fin (n i) => (true,y))) =
+      includeVariables ell (fun y : Fin (n i) => (true,⟨i,y⟩)) := by
+    apply algHom_ext
+    intro y
+    simp only [AlgHom.comp_apply, includeVariables_coordinate, includeScalar]
+  exact AlgHom.congr_fun h (Ideal.Quotient.mk _ (slopeDerivative n D.P i))
+
+@[simp] theorem reindex_potential (D : FormalData (k := k) n) :
+    Frobenius.reindex ell coordinates
+      (GlobalForms.potential ell d (Variables n) (blockPotential ell D)) =
+      specialPotential ell D := by
+  rw [GlobalForms.potential_sum, map_sum, specialPotential_separated]
+  apply Finset.sum_congr rfl
+  intro i _
+  rw [reindex_insertScalar]
+  simp only [blockPotential, map_sub, include_wall]
+
+variable (hell : 0 < ell)
+
+def tensorToForms : (⨂[k] i, Block (n := n) (k := k) ell i) ≃ₗ[k]
+    Ambient (n := n) (k := k) ell :=
+  (blockEquiv (k := k) ell hell d (Variables n)).symm.trans
+    (FormsReindex.equiv ell coordinates).toLinearEquiv
+
+omit [Fact ell.Prime] [CharP k ell] in
+@[simp] theorem tensorToForms_tprod (x : ∀ i, Block (n := n) (k := k) ell i) :
+    tensorToForms ell hell (PiTensorProduct.tprod k x) =
+      (List.ofFn fun i => includeBlock ell i (x i)).prod := by
+  change FormsReindex.equiv ell coordinates
+    ((blockEquiv ell hell d (Variables n)).symm (PiTensorProduct.tprod k x)) = _
+  rw [blockEquiv_symm_tprod_prod, map_list_prod, List.map_ofFn]
+  rfl
+
+omit [Fact ell.Prime] in
+@[simp] theorem tensorToForms_D (x : ⨂[k] i, Block (n := n) (k := k) ell i) :
+    tensorToForms ell hell (differential (Block (n := n) (k := k) ell)
+      (fun i => (parity (k := k) (A := Scalar (n := n) (k := k) ell i) (ι := Variables n i)).toLinearMap)
+      (fun i => MixedForms.d (partialDeriv (ι := Variables n i) (k := k) ell)) x) =
+      MixedForms.d (partialDeriv ell) (tensorToForms ell hell x) := by
+  change FormsReindex.equiv ell coordinates ((blockEquiv ell hell d (Variables n)).symm _) = _
+  rw [← blockEquiv_symm_d, FormsReindex.equiv_d]
+  rfl
+
+@[simp] theorem tensorToForms_delta (D : FormalData (k := k) n)
+    (x : ⨂[k] i, Block (n := n) (k := k) ell i) :
+    tensorToForms ell hell (differential (Block (n := n) (k := k) ell)
+      (fun i => (parity (k := k) (A := Scalar (n := n) (k := k) ell i) (ι := Variables n i)).toLinearMap)
+      (fun i => delta (partialDeriv (ι := Variables n i) (k := k) ell) (blockPotential ell D i)) x) =
+      delta (partialDeriv ell) (specialPotential ell D) (tensorToForms ell hell x) := by
+  change FormsReindex.equiv ell coordinates ((blockEquiv ell hell d (Variables n)).symm _) = _
+  rw [← blockEquiv_symm_delta, FormsReindex.equiv_delta, reindex_potential]
+  rfl
+
+omit [Fact ell.Prime] in
+ theorem d_includeBlock (i : Fin d) (x : Block (n := n) (k := k) ell i) :
+    MixedForms.d (partialDeriv ell) (includeBlock ell i x) =
+      includeBlock ell i (MixedForms.d (partialDeriv ell) x) := by
+  simp only [includeBlock, AlgHom.comp_apply, AlgEquiv.coe_toAlgHom, ← FormsReindex.equiv_d, d_insertForms]
+
+omit [Fact ell.Prime] in
+ theorem gradient_includeScalar (i : Fin d) (a : Scalar (n := n) (k := k) ell i) :
+    gradient (partialDeriv ell) (includeScalar ell i a) =
+      includeBlock ell i (gradient (partialDeriv ell) a) := by
+  rw [← d_coeff, ← includeBlock_coeff, d_includeBlock, d_coeff]
+
+omit [Fact ell.Prime] in
+ theorem delta_includeBlock (i : Fin d) (a : Scalar (n := n) (k := k) ell i)
+    (x : Block (n := n) (k := k) ell i) :
+    delta (partialDeriv ell) (includeScalar ell i a) (includeBlock ell i x) =
+      includeBlock ell i (delta (partialDeriv ell) a x) := by
+  rw [delta_apply, delta_apply, gradient_includeScalar, map_mul]
+
+end BoundaryOnly.FormalObstruction.ActualBlocks
+
+namespace BoundaryOnly.FormalObstruction.MixedForms
+variable {k A ι t : Type*} [CommRing k] [CommRing A] [Algebra k A]
+variable [Fintype ι] [DecidableEq ι]
+
+omit [Fintype ι] [DecidableEq ι] in
+theorem list_prod_coeff_mul (l : List t) (a : t → A)
+    (x : t → Forms (k := k) (A := A) (ι := ι)) :
+    (l.map (fun i => coeff (a i) * x i)).prod =
+      coeff ((l.map a).prod) * (l.map x).prod := by
+  induction l with
+  | nil => simp only [List.map_nil, List.prod_nil, map_one, one_mul]
+  | cons i l ih =>
+    simp only [List.map_cons, List.prod_cons, ih, map_mul]
+    rw [mul_assoc (coeff (a i)), ← mul_assoc (x i), ← coeff_commute,
+      mul_assoc, mul_assoc]
+
+theorem left_cycle_mul_delta (pd : ι → Derivation k A A) (F : A)
+    (x y : Forms (k := k) (A := A) (ι := ι)) (hx : delta pd F x = 0) :
+    x * delta pd F y = 0 := by
+  have hp : gradient pd F * parity x = 0 := by
+    have h := congrArg parity hx
+    simpa only [delta_apply, map_mul, parity_gradient, neg_mul,
+      map_zero, neg_eq_zero] using h
+  rw [gradient_supercommute, parity_sq] at hp
+  rw [delta_apply, ← mul_assoc, hp, zero_mul]
+
+end BoundaryOnly.FormalObstruction.MixedForms
+
+namespace BoundaryOnly.FormalObstruction.ActualBlocks
+open Frobenius MixedForms FormsSplit GlobalForms SignedTensor
+open scoped TensorProduct BigOperators
+variable {k : Type*} [Field k] {d : ℕ} {n : Fin d → ℕ}
+variable (ell : ℕ) [Fact ell.Prime] [CharP k ell] (hell : 0 < ell)
+
+omit [Fact ell.Prime] [CharP k ell] in
+ theorem tensorToForms_S (s : ∀ i, Scalar (n := n) (k := k) ell i)
+    (I : Finset (Fin d)) (z : ⨂[k] i, Block (n := n) (k := k) ell i) :
+    tensorToForms ell hell
+      (tensorAction (Block (n := n) (k := k) ell) (BlockTensor.S s) I z) =
+      coeff (∏ i ∈ I, includeScalar ell i (s i)) * tensorToForms ell hell z := by
+  induction z using PiTensorProduct.induction_on with
+  | add x y hx hy => simp only [map_add, hx, hy, mul_add]
+  | smul_tprod r x =>
+    simp only [map_smul, mul_smul_comm]
+    congr 1
+    rw [tensorAction, PiTensorProduct.map_tprod, tensorToForms_tprod, tensorToForms_tprod]
+    have h (i : Fin d) :
+        includeBlock ell i ((if i ∈ I then BlockTensor.S s i else LinearMap.id) (x i)) =
+          coeff (if i ∈ I then includeScalar ell i (s i) else 1) * includeBlock ell i (x i) := by
+      by_cases hi : i ∈ I
+      · simp only [ite_eq_left hi]
+        change includeBlock ell i (coeff (s i)*x i) = _
+        rw [map_mul, includeBlock_coeff]
+      · simp only [ite_eq_right hi, LinearMap.id_apply, map_one, one_mul]
+    change (List.ofFn (fun i => includeBlock ell i
+      ((if i ∈ I then BlockTensor.S s i else LinearMap.id) (x i)))).prod = _
+    have hh : (List.ofFn (fun i => includeBlock ell i
+        ((if i ∈ I then BlockTensor.S s i else LinearMap.id) (x i)))) =
+        List.ofFn (fun i => coeff (if i ∈ I then includeScalar ell i (s i) else 1) *
+          includeBlock ell i (x i)) := by
+      apply congrArg List.ofFn
+      funext i
+      exact h i
+    rw [hh]
+    have hp := list_prod_coeff_mul (k := k) (ι := InternalVar n)
+      (List.ofFn (fun i : Fin d => i))
+      (fun i => if i ∈ I then includeScalar ell i (s i) else 1)
+      (fun i => includeBlock ell i (x i))
+    simp only [List.map_ofFn, Function.comp_def] at hp
+    rw [hp]
+    congr 2
+    rw [List.prod_ofFn, Finset.prod_ite_mem_eq]
+
+end BoundaryOnly.FormalObstruction.ActualBlocks
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/FrobeniusObstruction/BlockCohomology.lean b/lean/OAI/Algebra/FrobeniusObstruction/BlockCohomology.lean
new file mode 100644
index 0000000000000000000000000000000000000000..9b74b166b20cf19c589b700446d0505ac7e47fe4
--- /dev/null
+++ b/lean/OAI/Algebra/FrobeniusObstruction/BlockCohomology.lean
@@ -0,0 +1,111 @@
+import Mathlib
+import OAI.Algebra.FrobeniusObstruction.MixedForms
+import OAI.Algebra.FrobeniusObstruction.Retractions
+
+namespace OAI
+
+noncomputable section
+open scoped BigOperators
+
+namespace BoundaryOnly.FormalObstruction.BlockCohomology
+open MixedForms SquareZero
+variable {k A ι : Type*} [Field k] [CommRing A] [Algebra k A]
+  [Fintype ι] [DecidableEq ι]
+variable (pd : ι → Derivation k A A) (q : A)
+variable (hcomm : ∀ i j a, pd i (pd j a) = pd j (pd i a))
+
+abbrev H := Cohomology (delta pd q) (delta_sq pd q)
+
+theorem delta_parity (x : Forms (k := k) (A := A) (ι := ι)) :
+    delta pd q (parity x) = -parity (delta pd q x) := by
+  simp only [delta_apply, map_mul, parity_gradient, neg_mul, neg_neg]
+
+include hcomm in
+theorem delta_d (x : Forms (k := k) (A := A) (ι := ι)) :
+    delta pd q (d pd x) = -d pd (delta pd q x) :=
+  eq_neg_of_add_eq_zero_right (d_delta pd hcomm q x)
+
+def P : Module.End k (H pd q) :=
+  oddInduced (delta pd q) (delta_sq pd q) parity.toLinearMap (delta_parity pd q)
+
+def D : Module.End k (H pd q) :=
+  oddInduced (delta pd q) (delta_sq pd q) (d pd) (delta_d pd q hcomm)
+
+def coefficient (s : A) : Module.End k (Forms (k := k) (A := A) (ι := ι)) :=
+  (Algebra.lmul k _).toLinearMap (coeff s)
+
+omit [Fintype ι] [DecidableEq ι] in
+@[simp] theorem coefficient_apply (s : A) (x : Forms (k := k) (A := A) (ι := ι)) :
+    coefficient s x = coeff s * x := rfl
+
+theorem delta_coefficient (s : A) (x : Forms (k := k) (A := A) (ι := ι)) :
+    delta pd q (coefficient s x) = coefficient s (delta pd q x) := by
+  simp only [coefficient_apply, delta_apply]
+  rw [← mul_assoc, ← coeff_commute, mul_assoc]
+
+def S (s : A) : Module.End k (H pd q) :=
+  evenInduced (delta pd q) (delta_sq pd q) (coefficient s) (delta_coefficient pd q s)
+
+theorem P_sq (x : H pd q) : P pd q (P pd q x) = x := by
+  obtain ⟨z,rfl⟩ := classMap_surjective (delta pd q) (delta_sq pd q) x
+  change classMap _ _ (cycleMap _ _ _ _ (cycleMap _ _ _ _ z)) = classMap _ _ z
+  congr 1
+  exact Subtype.ext (parity_sq (z : Forms (k := k) (A := A) (ι := ι)))
+
+theorem D_sq (x : H pd q) : D pd q hcomm (D pd q hcomm x) = 0 :=
+  oddInduced_square_zero (delta pd q) (delta_sq pd q) (d pd) (delta_d pd q hcomm)
+    (d_sq pd hcomm) x
+
+theorem D_P (x : H pd q) : D pd q hcomm (P pd q x) = -P pd q (D pd q hcomm x) := by
+  obtain ⟨z,rfl⟩ := classMap_surjective (delta pd q) (delta_sq pd q) x
+  change classMap _ _ (cycleMap _ _ _ _ (cycleMap _ _ _ _ z)) =
+    -classMap _ _ (cycleMap _ _ _ _ (cycleMap _ _ _ _ z))
+  rw [← map_neg]
+  congr 1
+  exact Subtype.ext (d_parity pd (z : Forms (k := k) (A := A) (ι := ι)))
+
+theorem S_P (s : A) (x : H pd q) : S pd q s (P pd q x) = P pd q (S pd q s x) := by
+  obtain ⟨z,rfl⟩ := classMap_surjective (delta pd q) (delta_sq pd q) x
+  change classMap _ _ (cycleMap _ _ _ _ (cycleMap _ _ _ _ z)) =
+    classMap _ _ (cycleMap _ _ _ _ (cycleMap _ _ _ _ z))
+  congr 1
+  apply Subtype.ext
+  change coeff s * parity (z : Forms (k := k) (A := A) (ι := ι)) = parity (coeff s * (z : Forms (k := k) (A := A) (ι := ι)))
+  rw [map_mul, parity_coeff]
+
+                                                                           
+                                                                    
+theorem retraction (htwo : (2 : k) ≠ 0) (s : A) :
+    ∃ r h : Module.End k (H pd q),
+      (∀ x, D pd q hcomm (r x) = r (D pd q hcomm x)) ∧
+      (∀ x, P pd q (r x) = r (P pd q x)) ∧
+      (∀ x, P pd q (h x) = -h (P pd q x)) ∧
+      (∀ x, x-r x = D pd q hcomm (h x) + h (D pd q hcomm x)) ∧
+      (∀ x, S pd q s x = 0 → S pd q s (r x) = 0 ∧ S pd q s (D pd q hcomm (r x)) = 0) :=
+  parity_retraction htwo (D pd q hcomm) (S pd q s) (P pd q)
+    (D_sq pd q hcomm) (P_sq pd q) (D_P pd q hcomm) (S_P pd q s)
+
+                                                                            
+                                                
+theorem correction (s : A) (x : Cycles (delta pd q))
+    (hS : S pd q s (classMap _ (delta_sq pd q) x) = 0)
+    (hSD : S pd q s (D pd q hcomm (classMap _ (delta_sq pd q) x)) = 0) :
+    ∃ y, delta pd q y = -delta pd s x := by
+  apply correction_of_kernel (delta pd q) (delta_sq pd q) (d pd)
+    (coefficient s) (delta pd s) (delta_d pd q hcomm)
+    (delta_coefficient pd q s) _ _ x hS hSD
+  · intro z
+    simp only [delta_apply]
+    rw [← mul_assoc]
+    have hanti : MixedForms.gradient pd q * MixedForms.gradient pd s =
+        -(MixedForms.gradient pd s * MixedForms.gradient pd q) := by
+      rw [gradient_supercommute, parity_gradient, neg_mul]
+    rw [hanti, neg_mul, mul_assoc]
+  · intro z
+    exact d_commutator pd s z
+
+end BoundaryOnly.FormalObstruction.BlockCohomology
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/FrobeniusObstruction/BlockPairing.lean b/lean/OAI/Algebra/FrobeniusObstruction/BlockPairing.lean
new file mode 100644
index 0000000000000000000000000000000000000000..3e54cfc6376293921ef027b61e80c36871a3123b
--- /dev/null
+++ b/lean/OAI/Algebra/FrobeniusObstruction/BlockPairing.lean
@@ -0,0 +1,255 @@
+import Mathlib
+import OAI.Algebra.FrobeniusObstruction.ChartPairing
+
+namespace OAI
+
+noncomputable section
+open scoped BigOperators
+
+namespace BoundaryOnly.FormalObstruction
+open Frobenius MixedForms
+variable {k : Type*} [Field k] {d : ℕ} {n : Fin d → ℕ}
+variable (ell : ℕ) (htwo : 1 < ell) [CharP k ell] [Fact ell.Prime]
+
+                                                                                       
+def wallSpecial (b : Bool) (i : Fin d) :
+    Frobenius.Ring (ι := WallVar n i) (k := k) ell →ₐ[k]
+      Frobenius.Ring (ι := InternalVar n) (k := k) ell :=
+  eval ell (Sum.elim (fun _ => 0) (fun y => coordinate ell (b,⟨i,y⟩))) (by
+    intro v
+    cases v with
+    | inl _ => exact zero_pow (Nat.Prime.ne_zero Fact.out)
+    | inr y => exact coordinate_pow ell _)
+
+omit [CharP k ell] in
+@[simp] theorem wallSpecial_slope (b : Bool) (i : Fin d) (j : Fin 3) :
+    wallSpecial (n := n) (k := k) ell b i (coordinate ell (.inl j)) = 0 :=
+  eval_coordinate ell _ _ _
+
+omit [CharP k ell] in
+@[simp] theorem wallSpecial_internal (b : Bool) (i : Fin d) (y : Fin (n i)) :
+    wallSpecial (k := k) ell b i (coordinate ell (.inr y)) = coordinate ell (b,⟨i,y⟩) :=
+  eval_coordinate ell _ _ _
+
+ theorem plusCoordinates_constant_zero (i : Fin d) (v : WallVar n i) :
+    MvPowerSeries.constantCoeff (plusCoordinates (k := k) n i v) = 0 := by
+  cases v <;> simp [plusCoordinates]
+
+ theorem minusCoordinates_constant_zero (i : Fin d) (v : WallVar n i) :
+    MvPowerSeries.constantCoeff (minusCoordinates (k := k) n i v) = 0 := by
+  cases v <;> simp [minusCoordinates]
+
+ theorem specialAmbient_plus (i : Fin d) (p : MvPowerSeries (WallVar n i) k) :
+    specialAmbient (n := n) (k := k) ell (Ideal.Quotient.mk _ (MvPowerSeries.subst (plusCoordinates n i) p)) =
+      wallSpecial ell true i (Ideal.Quotient.mk _ p) := by
+  have hh : (specialAmbient (n := n) (k := k) ell).comp
+      (substitute ell (plusCoordinates n i) (plusCoordinates_constant_zero i)) =
+      wallSpecial ell true i := by
+    apply algHom_ext
+    intro v
+    simp only [AlgHom.comp_apply, substitute_coordinate]
+    cases v with
+    | inl j =>
+      rw [wallSpecial_slope]
+      exact specialAmbient_slope ell (i,j)
+    | inr y =>
+      rw [wallSpecial_internal]
+      exact specialAmbient_internal ell (true,⟨i,y⟩)
+  simpa only [AlgHom.comp_apply, substitute_mk] using
+    AlgHom.congr_fun hh (Ideal.Quotient.mk _ p)
+
+ theorem specialAmbient_minus (i : Fin d) (p : MvPowerSeries (WallVar n i) k) :
+    specialAmbient (n := n) (k := k) ell (Ideal.Quotient.mk _ (MvPowerSeries.subst (minusCoordinates n i) p)) =
+      wallSpecial ell false i (Ideal.Quotient.mk _ p) := by
+  have hh : (specialAmbient (n := n) (k := k) ell).comp
+      (substitute ell (minusCoordinates n i) (minusCoordinates_constant_zero i)) =
+      wallSpecial ell false i := by
+    apply algHom_ext
+    intro v
+    simp only [AlgHom.comp_apply, substitute_coordinate]
+    cases v with
+    | inl j => simp only [minusCoordinates, map_zero, wallSpecial_slope]
+    | inr y =>
+      rw [wallSpecial_internal]
+      exact specialAmbient_internal ell (false,⟨i,y⟩)
+  simpa only [AlgHom.comp_apply, substitute_mk] using
+    AlgHom.congr_fun hh (Ideal.Quotient.mk _ p)
+
+ theorem specialPotential_separated (D : FormalData (k := k) n) :
+    specialPotential ell D = ∑ i,
+      (wallSpecial ell true i (Ideal.Quotient.mk _ (D.P i)) -
+       wallSpecial ell false i (Ideal.Quotient.mk _ (D.P i))) := by
+  simp only [specialPotential, potential, map_sum, map_sub,
+    specialAmbient_plus, specialAmbient_minus]
+
+omit [CharP k ell] in
+ theorem swap_wallSpecial (b : Bool) (i : Fin d)
+    (x : Frobenius.Ring (ι := WallVar n i) (k := k) ell) :
+    Frobenius.reindex ell swapEquiv (wallSpecial ell b i x) = wallSpecial ell (!b) i x := by
+  have hh : (Frobenius.reindex (k := k) ell (swapEquiv (n := n))).toAlgHom.comp
+      (wallSpecial (k := k) ell b i) = wallSpecial ell (!b) i := by
+    apply algHom_ext
+    intro v
+    cases v <;> simp only [AlgHom.comp_apply, AlgEquiv.coe_toAlgHom,
+      wallSpecial_slope, wallSpecial_internal, map_zero,
+      reindex_coordinate, swapEquiv_apply]
+  exact AlgHom.congr_fun hh x
+
+ theorem specialPotential_swap (D : FormalData (k := k) n) :
+    Frobenius.reindex ell swapEquiv (specialPotential ell D) = -specialPotential ell D := by
+  rw [specialPotential_separated]
+  simp only [map_sum, map_sub, swap_wallSpecial, Bool.not_true, Bool.not_false]
+  rw [← Finset.sum_neg_distrib]
+  apply Finset.sum_congr rfl
+  intro i _
+  abel
+
+ theorem negativeNormal_d (D : FormalData (k := k) n) :
+    MixedForms.d (partialDeriv ell) (negativeNormal ell htwo D) = 0 := by
+  rw [negativeNormal, ← FormsReindex.equiv_d, specialNormal_d, map_zero]
+
+omit [Fact ell.Prime] in
+ theorem gradient_neg (x : Frobenius.Ring (ι := InternalVar n) (k := k) ell) :
+    MixedForms.gradient (partialDeriv ell) (-x) = -MixedForms.gradient (partialDeriv ell) x := by
+  change MixedForms.d (partialDeriv ell) (coeff (-x)) = -MixedForms.d (partialDeriv ell) (coeff x)
+  rw [map_neg, map_neg]
+
+ theorem negativeNormal_delta (D : FormalData (k := k) n) :
+    delta (partialDeriv ell) (specialPotential ell D) (negativeNormal ell htwo D) = 0 := by
+  have hh := congrArg (FormsReindex.equiv ell swapEquiv) (specialNormal_delta ell htwo D)
+  rw [FormsReindex.equiv_delta, specialPotential_swap, map_zero, delta_apply,
+    gradient_neg, neg_mul, neg_eq_zero] at hh
+  exact hh
+
+                                                          
+def specialSlope (D : FormalData (k := k) n) (b : Bool) (i : Fin d) :
+    Frobenius.Ring (ι := InternalVar n) (k := k) ell :=
+  includeVariables ell (fun y => (b,⟨i,y⟩))
+    (Ideal.Quotient.mk _ (slopeDerivative n D.P i))
+
+omit [CharP k ell] [Fact ell.Prime] in
+ theorem specialSlope_swap (D : FormalData (k := k) n) (b : Bool) (i : Fin d) :
+    Frobenius.reindex ell swapEquiv (specialSlope ell D b i) = specialSlope ell D (!b) i := by
+  have hh : (Frobenius.reindex (k := k) ell (swapEquiv (n := n))).toAlgHom.comp
+      (includeVariables (k := k) ell (fun y : Fin (n i) => ((b,⟨i,y⟩) : InternalVar n))) =
+      includeVariables ell (fun y : Fin (n i) => ((!b,⟨i,y⟩) : InternalVar n)) := by
+    apply algHom_ext
+    intro y
+    simp only [AlgHom.comp_apply, AlgEquiv.coe_toAlgHom,
+      includeVariables_coordinate, reindex_coordinate, swapEquiv_apply]
+  exact AlgHom.congr_fun hh _
+
+omit [CharP k ell] in
+ theorem specialPlane_graphSlot (x : Frobenius.Ring (ι := GraphVar n) (k := k) ell) :
+    planeRestriction ell (by omega) normalIndices (graphSlot ell false x) = graphSlot ell false x := by
+  have hh : (planeRestriction (k := k) ell (by omega) (normalIndices (n := n))).comp (graphSlot ell false) =
+      graphSlot ell false := by
+    apply algHom_ext
+    intro v
+    cases v <;> simp only [AlgHom.comp_apply, graphSlot_slope, graphSlot_tangent,
+      map_zero, planeRestriction_coordinate, mem_normalIndices, Bool.false_eq_true, ite_false]
+  exact AlgHom.congr_fun hh x
+
+omit [CharP k ell] [Fact ell.Prime] in
+ theorem specialPlane_fixedComplement (D : FormalData (k := k) n) (c : InternalVar n) :
+    planeRestriction ell (by omega) normalIndices (fixedComplement ell D c) = 0 := by
+  simp only [fixedComplement, map_sum, map_smul, planeRestriction_coordinate,
+    mem_normalIndices, ite_true, smul_zero, Finset.sum_const_zero]
+
+ theorem specialSlope_restriction (D : FormalData (k := k) n) (i : Fin d) :
+    planeRestriction ell (by omega) normalIndices (specialChart ell D (specialSlope ell D false i)) =
+      graphSlot ell false (Ideal.Quotient.mk _ (negativeSlopeValue n D.P D.Y i)) := by
+  have ha (y : Fin (n i)) : MvPowerSeries.constantCoeff (D.Y (false,⟨i,y⟩)) = 0 :=
+    graph_constant_zero D _
+  have hh : ((planeRestriction ell (by omega) (normalIndices (n := n))).comp (specialChart ell D)).comp
+      (includeVariables ell (fun y : Fin (n i) => ((false,⟨i,y⟩) : InternalVar n))) =
+      (graphSlot ell false).comp (substitute ell (fun y : Fin (n i) => D.Y (false,⟨i,y⟩)) ha) := by
+    apply algHom_ext
+    intro y
+    simp only [AlgHom.comp_apply, includeVariables_coordinate, specialChart_coordinate,
+      specialChartCoordinate, map_add, specialPlane_fixedComplement ell htwo D, add_zero,
+      specialPlane_graphSlot ell htwo, substitute_coordinate]
+  simpa only [AlgHom.comp_apply, substitute_mk, specialSlope, negativeSlopeValue] using
+    AlgHom.congr_fun hh (Ideal.Quotient.mk _ (slopeDerivative n D.P i))
+
+ theorem specialSlope_mul_normal (D : FormalData (k := k) n) (i : Fin d) :
+    coeff (specialSlope ell D false i) * specialNormal ell htwo D =
+      coeff ((specialChartEquiv ell htwo D).symm
+        (graphSlot ell false (Ideal.Quotient.mk _ (negativeSlopeValue n D.P D.Y i)))) *
+        specialNormal ell htwo D := by
+  apply sub_eq_zero.mp
+  rw [← sub_mul, ← map_sub]
+  apply chartNormal_annihilate ell (by omega)
+  apply (chart_restriction_eq_zero_iff ell (by omega) (specialChartEquiv ell htwo D).symm
+    normalIndices _).mp
+  simp only [map_sub, AlgEquiv.symm_symm, AlgEquiv.apply_symm_apply,
+    specialPlane_graphSlot ell htwo]
+  exact sub_eq_zero.mpr (specialSlope_restriction ell htwo D i)
+
+omit [CharP k ell] [Fact ell.Prime] in
+ theorem specialPlane_idempotent (x : Frobenius.Ring (ι := InternalVar n) (k := k) ell) :
+    planeRestriction ell (show 0 < ell by omega) normalIndices
+      (planeRestriction ell (show 0 < ell by omega) normalIndices x) =
+        planeRestriction ell (show 0 < ell by omega) normalIndices x := by
+  have hh : (planeRestriction (ι := InternalVar n) (k := k) ell (by omega) normalIndices).comp
+      (planeRestriction ell (by omega) normalIndices) =
+        planeRestriction ell (by omega) normalIndices := by
+    apply algHom_ext
+    intro i
+    by_cases hi : i ∈ normalIndices
+    · simp only [AlgHom.comp_apply, planeRestriction_coordinate, ite_eq_left hi, map_zero]
+    · simp only [AlgHom.comp_apply, planeRestriction_coordinate, ite_eq_right hi]
+  exact AlgHom.congr_fun hh x
+
+ theorem specialScalar_mul_normal (D : FormalData (k := k) n)
+    (x : Frobenius.Ring (ι := InternalVar n) (k := k) ell) :
+    coeff x * specialNormal ell htwo D =
+      coeff ((specialChartEquiv ell htwo D).symm
+        (planeRestriction ell (by omega) normalIndices (specialChart ell D x))) *
+          specialNormal ell htwo D := by
+  apply sub_eq_zero.mp
+  rw [← sub_mul, ← map_sub]
+  apply chartNormal_annihilate ell (by omega)
+  apply (chart_restriction_eq_zero_iff ell (by omega) (specialChartEquiv ell htwo D).symm
+    normalIndices _).mp
+  simp only [map_sub, AlgEquiv.symm_symm, AlgEquiv.apply_symm_apply,
+    specialPlane_idempotent ell htwo]
+  exact sub_self _
+
+ theorem specialNegativeTriple_boundary (D : FormalData (k := k) n) (i j l : Fin d) :
+    ∃ eta : Forms (k := k) (A := Frobenius.Ring (ι := InternalVar n) (k := k) ell)
+        (ι := InternalVar n),
+      delta (partialDeriv ell) (specialPotential ell D) eta =
+        coeff (specialSlope ell D false i * specialSlope ell D false j * specialSlope ell D false l) *
+          specialNormal ell htwo D := by
+  obtain ⟨eta,he⟩ := specialNormal_primitive ell htwo D _ (D.negative_cubic i j l)
+  refine ⟨eta, he.trans ?_⟩
+  symm
+  calc
+    _ = coeff ((specialChartEquiv ell htwo D).symm
+      (planeRestriction ell (by omega) normalIndices
+        (specialChart ell D (specialSlope ell D false i * specialSlope ell D false j * specialSlope ell D false l)))) *
+        specialNormal ell htwo D := specialScalar_mul_normal ell htwo D _
+    _ = _ := by simp only [map_mul, specialSlope_restriction ell htwo D]
+
+                                                                                         
+ theorem negativeNormal_triple (D : FormalData (k := k) n) (i j l : Fin d) :
+    ∃ eta : Forms (k := k) (A := Frobenius.Ring (ι := InternalVar n) (k := k) ell)
+        (ι := InternalVar n),
+      delta (partialDeriv ell) (specialPotential ell D) eta =
+        coeff (specialSlope ell D true i * specialSlope ell D true j * specialSlope ell D true l) *
+          negativeNormal ell htwo D := by
+  obtain ⟨eta,he⟩ := specialNegativeTriple_boundary ell htwo D i j l
+  refine ⟨-FormsReindex.equiv ell swapEquiv eta, ?_⟩
+  have hh := congrArg (FormsReindex.equiv ell swapEquiv) he
+  rw [FormsReindex.equiv_delta, specialPotential_swap] at hh
+  simp only [map_mul, FormsReindex.equiv_coeff, specialSlope_swap] at hh
+  simp only [Bool.not_false] at hh
+  rw [delta_apply, gradient_neg, neg_mul] at hh
+  simpa only [delta_apply, mul_neg, map_mul, negativeNormal] using hh
+
+end BoundaryOnly.FormalObstruction
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/FrobeniusObstruction/BlockTensor.lean b/lean/OAI/Algebra/FrobeniusObstruction/BlockTensor.lean
new file mode 100644
index 0000000000000000000000000000000000000000..da3fe59b1717c31f9089bc37e3e9673b97923294
--- /dev/null
+++ b/lean/OAI/Algebra/FrobeniusObstruction/BlockTensor.lean
@@ -0,0 +1,390 @@
+import Mathlib
+import OAI.Algebra.FrobeniusObstruction.TensorKernels
+
+namespace OAI
+
+noncomputable section
+open scoped BigOperators TensorProduct
+
+namespace BoundaryOnly.FormalObstruction.BlockCohomology
+open SquareZero MixedForms
+variable {k A ι : Type*} [Field k] [CommRing A] [Algebra k A]
+  [Fintype ι] [DecidableEq ι]
+variable (pd : ι → Derivation k A A) (q : A)
+
+                                                                       
+                                                                                
+structure Contraction where
+  j : H pd q →ₗ[k] Forms (k := k) (A := A) (ι := ι)
+  p : Forms (k := k) (A := A) (ι := ι) →ₗ[k] H pd q
+  h : Module.End k (Forms (k := k) (A := A) (ι := ι))
+  cycle_j : ∀ x, delta pd q (j x) = 0
+  p_boundary : ∀ x, p (delta pd q x) = 0
+  p_j : ∀ x, p (j x) = x
+  p_cycle : ∀ z : Cycles (delta pd q), p z = classMap _ (delta_sq pd q) z
+  j_parity : ∀ x, j (P pd q x) = parity (j x)
+  p_parity : ∀ x, p (parity x) = P pd q (p x)
+  h_parity : ∀ x, h (parity x) = -parity (h x)
+  homotopy : ∀ x, x - j (p x) = delta pd q (h x) + h (delta pd q x)
+
+ theorem contraction_exists (htwo : (2 : k) ≠ 0) : Nonempty (Contraction pd q) := by
+  obtain ⟨j,p,h,hj,hp,hpj,hpc,hjP,hpP,hhP,hh⟩ := parity_cohomology_contraction
+    htwo (delta pd q) parity.toLinearMap (delta_sq pd q) parity_sq (delta_parity pd q)
+  exact ⟨⟨j,p,h,hj,hp,hpj,hpc,hjP,hpP,hhP,hh⟩⟩
+
+def contraction (htwo : (2 : k) ≠ 0) : Contraction pd q :=
+  Classical.choice (contraction_exists pd q htwo)
+
+namespace Contraction
+variable {pd q} (c : Contraction pd q)
+
+ theorem class_j (x : H pd q) :
+    classMap _ (delta_sq pd q) ⟨c.j x, c.cycle_j x⟩ = x :=
+  (c.p_cycle ⟨c.j x, c.cycle_j x⟩).symm.trans (c.p_j x)
+
+ theorem project_odd (f : Module.End k (Forms (k := k) (A := A) (ι := ι)))
+    (hf : ∀ x, delta pd q (f x) = -f (delta pd q x)) (x : H pd q) :
+    c.p (f (c.j x)) = oddInduced _ (delta_sq pd q) f hf x := by
+  conv_rhs => rw [← c.class_j x, oddInduced_class, ← c.p_cycle]
+  rfl
+
+ theorem project_even (f : Module.End k (Forms (k := k) (A := A) (ι := ι)))
+    (hf : ∀ x, delta pd q (f x) = f (delta pd q x)) (x : H pd q) :
+    c.p (f (c.j x)) = evenInduced _ (delta_sq pd q) f hf x := by
+  conv_rhs => rw [← c.class_j x, evenInduced_class, ← c.p_cycle]
+  rfl
+
+ theorem project_d (hc : ∀ i j a, pd i (pd j a) = pd j (pd i a)) (x : H pd q) :
+    c.p (d pd (c.j x)) = D pd q hc x :=
+  c.project_odd (d pd) (delta_d pd q hc) x
+
+ theorem project_coefficient (s : A) (x : H pd q) :
+    c.p (coefficient s (c.j x)) = S pd q s x :=
+  c.project_even (coefficient s) (delta_coefficient pd q s) x
+
+end Contraction
+end BoundaryOnly.FormalObstruction.BlockCohomology
+
+namespace BoundaryOnly.FormalObstruction.SignedTensor
+variable {k ι : Type*} [Field k] [Fintype ι] [LinearOrder ι]
+variable {V W : ι → Type*} [∀ i, AddCommGroup (V i)] [∀ i, Module k (V i)]
+  [∀ i, AddCommGroup (W i)] [∀ i, Module k (W i)]
+
+theorem differential_map (P D : EndFamily (k := k) V) (Q E : EndFamily (k := k) W)
+    (f : ∀ i, V i →ₗ[k] W i)
+    (hP : ∀ i, (f i).comp (P i) = (Q i).comp (f i))
+    (hD : ∀ i, (f i).comp (D i) = (E i).comp (f i)) :
+    (PiTensorProduct.map f).comp (differential V P D) =
+      (differential W Q E).comp (PiTensorProduct.map f) := by
+  apply PiTensorProduct.ext
+  ext v
+  simp only [LinearMap.compMultilinearMap_apply, LinearMap.comp_apply,
+    differential, LinearMap.sum_apply, PiTensorProduct.map_tprod, map_sum]
+  apply Finset.sum_congr rfl
+  intro i _
+  congr 1
+  funext a
+  by_cases ha : a < i
+  · simp only [dSlot, ite_eq_left ha]
+    exact LinearMap.congr_fun (hP a) (v a)
+  · by_cases he : a = i
+    · simp only [dSlot, ite_eq_right ha, ite_eq_left he]
+      exact LinearMap.congr_fun (hD a) (v a)
+    · simp only [dSlot, ite_eq_right ha, ite_eq_right he, Module.End.one_apply]
+
+end BoundaryOnly.FormalObstruction.SignedTensor
+
+namespace BoundaryOnly.FormalObstruction.BlockTensor
+open MixedForms SquareZero SignedTensor
+variable {k t : Type*} [Field k] [Fintype t] [LinearOrder t]
+variable (A K : t → Type*) [∀ i, CommRing (A i)] [∀ i, Algebra k (A i)]
+  [∀ i, Fintype (K i)] [∀ i, DecidableEq (K i)]
+abbrev V (i : t) := Forms (k := k) (A := A i) (ι := K i)
+variable {A K}
+variable (pd : ∀ i, K i → Derivation k (A i) (A i)) (q : ∀ i, A i)
+abbrev H (i : t) := BlockCohomology.H (pd i) (q i)
+def P : EndFamily (k := k) (V (k := k) A K) := fun _ => parity.toLinearMap
+local notation "PV" => (P (k := k) (A := A) (K := K))
+def D : EndFamily (k := k) (V (k := k) A K) := fun i => d (pd i)
+def delta : EndFamily (k := k) (V (k := k) A K) := fun i => MixedForms.delta (pd i) (q i)
+def S (s : ∀ i, A i) : EndFamily (k := k) (V (k := k) A K) :=
+  fun i => BlockCohomology.coefficient (s i)
+def HP : EndFamily (k := k) (H pd q) := fun i => BlockCohomology.P (pd i) (q i)
+def HD (hc : ∀ a i j x, pd a i (pd a j x) = pd a j (pd a i x)) :
+    EndFamily (k := k) (H pd q) := fun i => BlockCohomology.D (pd i) (q i) (hc i)
+def HS (s : ∀ i, A i) : EndFamily (k := k) (H pd q) :=
+  fun i => BlockCohomology.S (pd i) (q i) (s i)
+variable (c : ∀ i, BlockCohomology.Contraction (pd i) (q i))
+def j : (⨂[k] i, H pd q i) →ₗ[k] (⨂[k] i, V (k := k) A K i) :=
+  PiTensorProduct.map (fun i => (c i).j)
+def p : (⨂[k] i, V (k := k) A K i) →ₗ[k] (⨂[k] i, H pd q i) :=
+  PiTensorProduct.map (fun i => (c i).p)
+
+theorem projection_boundary (x : ⨂[k] i, V (k := k) A K i) :
+    p pd q c (differential (V (k := k) A K) PV (delta pd q) x) = 0 := by
+  exact LinearMap.congr_fun (projection_boundaries PV (delta pd q)
+    (fun i => (c i).p) (fun i => by apply LinearMap.ext; intro z; exact (c i).p_boundary z)) x
+
+theorem representatives_cycle (x : ⨂[k] i, H pd q i) :
+    differential (V (k := k) A K) PV (delta pd q) (j pd q c x) = 0 := by
+  exact LinearMap.congr_fun (representatives_cycles PV (delta pd q)
+    (fun i => (c i).j) (fun i => by apply LinearMap.ext; intro z; exact (c i).cycle_j z)) x
+
+theorem cycle_decomposition (z : ⨂[k] i, V (k := k) A K i)
+    (hz : differential (V (k := k) A K) PV (delta pd q) z = 0) :
+    ∃ y, z - j pd q c (p pd q c z) = differential (V (k := k) A K) PV (delta pd q) y := by
+  apply tensor_cycle_decomposition PV (delta pd q)
+    (fun i => (c i).j) (fun i => (c i).p) (fun i => (c i).h) _ _ _ _ _ _ _ z hz
+  · intro i; apply LinearMap.ext; intro x; exact parity_sq x
+  · intro i; apply LinearMap.ext; intro x; exact BlockCohomology.delta_parity (pd i) (q i) x
+  · intro i; apply LinearMap.ext; intro x; exact (c i).cycle_j x
+  · intro i; apply LinearMap.ext; intro x; exact (c i).p_boundary x
+  · intro i; apply LinearMap.ext; intro x
+    change parity ((c i).j ((c i).p x)) = (c i).j ((c i).p (parity x))
+    rw [(c i).p_parity, (c i).j_parity]
+  · intro i; apply LinearMap.ext; intro x
+    change parity ((c i).h x) = -(c i).h (parity x)
+    rw [(c i).h_parity, neg_neg]
+  · intro i; apply LinearMap.ext; intro x
+    exact ((c i).homotopy x).symm
+
+omit [Fintype t] [LinearOrder t] in
+theorem project_parity (i : t) :
+    (c i).p.comp ((PV i).comp (c i).j) = HP pd q i := by
+  apply LinearMap.ext; intro x
+  change (c i).p (parity ((c i).j x)) = BlockCohomology.P (pd i) (q i) x
+  rw [(c i).p_parity, (c i).p_j]
+
+theorem project_D (hc : ∀ a i j x, pd a i (pd a j x) = pd a j (pd a i x)) :
+    (p pd q c).comp ((differential (V (k := k) A K) PV (D pd)).comp (j pd q c)) =
+      differential (H pd q) (HP pd q) (HD pd q hc) := by
+  apply project_differential
+  · intro i; apply LinearMap.ext; intro x; exact (c i).p_j x
+  · exact project_parity pd q c
+  · intro i; apply LinearMap.ext; intro x; exact (c i).project_d (hc i) x
+
+omit [Fintype t] in
+theorem project_S (s : ∀ i, A i) (I : Finset t) :
+    (p pd q c).comp ((tensorAction (V (k := k) A K) (S s) I).comp (j pd q c)) =
+      tensorAction (H pd q) (HS pd q s) I := by
+  apply project_tensor_map
+  intro i
+  by_cases hi : i ∈ I
+  · apply LinearMap.ext; intro x
+    simpa only [tensorAction, ite_eq_left hi, LinearMap.comp_apply, S, HS]
+      using (c i).project_coefficient (s i) x
+  · apply LinearMap.ext; intro x
+    simpa only [tensorAction, ite_eq_right hi, LinearMap.comp_apply, LinearMap.id_apply]
+      using (c i).p_j x
+
+end BoundaryOnly.FormalObstruction.BlockTensor
+
+namespace BoundaryOnly.FormalObstruction.SignedTensor
+variable {k t : Type*} [Field k] [Fintype t] [LinearOrder t]
+variable (V : t → Type*) [∀ i, AddCommGroup (V i)] [∀ i, Module k (V i)]
+
+theorem differential_anticomm (P D E : EndFamily (k := k) V)
+    (hP : ∀ i, P i * P i = 1)
+    (hD : ∀ i, D i * P i = -(P i * D i))
+    (hE : ∀ i, P i * E i = -(E i * P i))
+    (hDE : ∀ i, D i * E i + E i * D i = 0) :
+    differential V P D * differential V P E +
+      differential V P E * differential V P D = 0 := by
+  have hh : homotopy V P (fun _ => 1) E = differential V P E := by
+    unfold homotopy differential
+    apply Finset.sum_congr rfl
+    intro i _
+    congr 1
+  have h := tensor_homotopy P D (fun _ => 1) E hP hD
+    (fun i => by simp only [mul_one, one_mul])
+    (fun i => by simp only [mul_one, one_mul]) hE
+    (fun i => by rw [sub_self]; exact hDE i)
+  rw [hh] at h
+  have hi : PiTensorProduct.map (fun i : t => (1 : Module.End k (V i))) = 1 :=
+    PiTensorProduct.map_id
+  rwa [hi, sub_self] at h
+
+end BoundaryOnly.FormalObstruction.SignedTensor
+
+namespace BoundaryOnly.FormalObstruction.BlockTensor
+open MixedForms SquareZero SignedTensor
+variable {k t : Type*} [Field k] [Fintype t] [LinearOrder t]
+variable {A K : t → Type*} [∀ i, CommRing (A i)] [∀ i, Algebra k (A i)]
+  [∀ i, Fintype (K i)] [∀ i, DecidableEq (K i)]
+variable (pd : ∀ i, K i → Derivation k (A i) (A i)) (q : ∀ i, A i)
+local notation "PV" => (P (k := k) (A := A) (K := K))
+
+theorem D_delta_anticomm (hc : ∀ a i j x, pd a i (pd a j x) = pd a j (pd a i x))
+    (x : ⨂[k] i, V (k := k) A K i) :
+    differential (V (k := k) A K) PV (D pd)
+      (differential (V (k := k) A K) PV (delta pd q) x) =
+    -differential (V (k := k) A K) PV (delta pd q)
+      (differential (V (k := k) A K) PV (D pd) x) := by
+  have h := differential_anticomm (V (k := k) A K) PV (D pd) (delta pd q)
+    (fun i => by apply LinearMap.ext; intro y; exact parity_sq y)
+    (fun i => by apply LinearMap.ext; intro y; exact d_parity (pd i) y)
+    (fun i => by
+      apply LinearMap.ext; intro y
+      change parity (MixedForms.delta (pd i) (q i) y) =
+        -MixedForms.delta (pd i) (q i) (parity y)
+      rw [BlockCohomology.delta_parity, neg_neg])
+    (fun i => by
+      apply LinearMap.ext; intro y
+      change d (pd i) (MixedForms.delta (pd i) (q i) y) +
+        MixedForms.delta (pd i) (q i) (d (pd i) y) = 0
+      exact d_delta (pd i) (hc i) (q i) y)
+  exact eq_neg_of_add_eq_zero_left (LinearMap.congr_fun h x)
+
+theorem S_delta_comm (s : ∀ i, A i) (I : Finset t)
+    (x : ⨂[k] i, V (k := k) A K i) :
+    tensorAction (V (k := k) A K) (S s) I
+      (differential (V (k := k) A K) PV (delta pd q) x) =
+    differential (V (k := k) A K) PV (delta pd q)
+      (tensorAction (V (k := k) A K) (S s) I x) := by
+  apply LinearMap.congr_fun (differential_map PV (delta pd q) PV (delta pd q)
+    (fun i => if i ∈ I then S s i else LinearMap.id) ?_ ?_) x
+  · intro i
+    by_cases hi : i ∈ I
+    · simp only [ite_eq_left hi]
+      apply LinearMap.ext; intro y
+      change coeff (s i) * parity y = parity (coeff (s i) * y)
+      rw [map_mul, parity_coeff]
+    · simp only [ite_eq_right hi, LinearMap.id_comp, LinearMap.comp_id]
+  · intro i
+    by_cases hi : i ∈ I
+    · simp only [ite_eq_left hi]
+      apply LinearMap.ext; intro y
+      exact (BlockCohomology.delta_coefficient (pd i) (q i) (s i) y).symm
+    · simp only [ite_eq_right hi, LinearMap.id_comp, LinearMap.comp_id]
+
+end BoundaryOnly.FormalObstruction.BlockTensor
+
+namespace BoundaryOnly.FormalObstruction.BlockTensor
+open MixedForms SquareZero SignedTensor
+variable {k t : Type*} [Field k] [Fintype t] [LinearOrder t]
+variable {A K : t → Type*} [∀ i, CommRing (A i)] [∀ i, Algebra k (A i)]
+  [∀ i, Fintype (K i)] [∀ i, DecidableEq (K i)]
+variable (pd : ∀ i, K i → Derivation k (A i) (A i)) (q : ∀ i, A i)
+local notation "PV" => (P (k := k) (A := A) (K := K))
+local notation "Ω" => (V (k := k) A K)
+local notation "δt" => (differential Ω PV (delta pd q))
+local notation "Dt" => (differential Ω PV (D pd))
+
+theorem project_D_cycle
+    (hc : ∀ a i j x, pd a i (pd a j x) = pd a j (pd a i x))
+    (c : ∀ i, BlockCohomology.Contraction (pd i) (q i))
+    (z : ⨂[k] i, Ω i) (hz : δt z = 0) :
+    differential (H pd q) (HP pd q) (HD pd q hc) (p pd q c z) = p pd q c (Dt z) := by
+  refine CycleTransfer.operator (H := ⨂[k] i, H pd q i) δt (j pd q c) (p pd q c)
+    (projection_boundary pd q c) (cycle_decomposition pd q c) Dt (-Dt)
+    (differential (H pd q) (HP pd q) (HD pd q hc)) ?_ ?_ z hz
+  · intro x
+    simpa only [LinearMap.neg_apply, map_neg] using D_delta_anticomm pd q hc x
+  · intro x
+    exact (LinearMap.congr_fun (project_D pd q c hc) x).symm
+
+theorem pairing_project_D
+    (hc : ∀ a i j x, pd a i (pd a j x) = pd a j (pd a i x))
+    (c : ∀ i, BlockCohomology.Contraction (pd i) (q i))
+    (Φ : (⨂[k] i, Ω i) →ₗ[k] k)
+    (hΦδ : ∀ x, Φ (δt x) = 0) (hΦD : ∀ x, Φ (Dt x) = 0)
+    (x : ⨂[k] i, H pd q i) :
+    Φ (j pd q c (differential (H pd q) (HP pd q) (HD pd q hc) x)) = 0 := by
+  refine CycleTransfer.pairing_operator (H := ⨂[k] i, H pd q i) δt (j pd q c) (p pd q c)
+    (cycle_decomposition pd q c) Dt (-Dt)
+    (differential (H pd q) (HP pd q) (HD pd q hc)) ?_ ?_ ?_ Φ hΦδ hΦD x
+  · intro z
+    change _ = -(Dt (δt z))
+    rw [D_delta_anticomm pd q hc z, neg_neg]
+  · exact representatives_cycle pd q c
+  · intro z
+    exact (LinearMap.congr_fun (project_D pd q c hc) z).symm
+
+theorem project_S_cycle
+    (c : ∀ i, BlockCohomology.Contraction (pd i) (q i))
+    (s : ∀ i, A i) (I : Finset t)
+    (z : ⨂[k] i, Ω i) (hz : δt z = 0) :
+    tensorAction (H pd q) (HS pd q s) I (p pd q c z) =
+      p pd q c (tensorAction Ω (S s) I z) := by
+  refine CycleTransfer.operator (H := ⨂[k] i, H pd q i) δt (j pd q c) (p pd q c)
+    (projection_boundary pd q c) (cycle_decomposition pd q c)
+    (tensorAction Ω (S s) I) (tensorAction Ω (S s) I)
+    (tensorAction (H pd q) (HS pd q s) I) ?_ ?_ z hz
+  · exact S_delta_comm pd q s I
+  · intro x
+    exact (LinearMap.congr_fun (project_S pd q c s I) x).symm
+
+                                                                               
+                                                                             
+theorem selected_classes (htwo : (2 : k) ≠ 0)
+    (hc : ∀ a i j x, pd a i (pd a j x) = pd a j (pd a i x))
+    (s : ∀ i, A i) (active : Finset t) (hcard : 5 ≤ active.card)
+    (c : ∀ i, BlockCohomology.Contraction (pd i) (q i))
+    (Φ : (⨂[k] i, Ω i) →ₗ[k] k)
+    (hΦδ : ∀ x, Φ (δt x) = 0) (hΦD : ∀ x, Φ (Dt x) = 0)
+    (z : ⨂[k] i, Ω i) (hz : δt z = 0) (hDz : Dt z = 0) (hΦz : Φ z ≠ 0)
+    (htriple : ∀ I : Finset t, I ⊆ active → I.card = 3 →
+      ∃ y, tensorAction Ω (S s) I z = δt y) :
+    ∃ (J : Finset t) (m : ∀ i, H pd q i),
+      J ⊆ active ∧ 3 ≤ J.card ∧
+      (∀ i ∈ J, HS pd q s i (m i) = 0 ∧
+        HS pd q s i (HD pd q hc i (m i)) = 0) ∧
+      Φ (j pd q c (PiTensorProduct.tprod k m)) ≠ 0 := by
+  let φ := Φ.comp (j pd q c)
+  have hHD : differential (H pd q) (HP pd q) (HD pd q hc) (p pd q c z) = 0 := by
+    rw [project_D_cycle pd q hc c z hz, hDz, map_zero]
+  have hφD (x : ⨂[k] i, H pd q i) :
+      φ (differential (H pd q) (HP pd q) (HD pd q hc) x) = 0 :=
+    pairing_project_D pd q hc c Φ hΦδ hΦD x
+  have hφz : φ (p pd q c z) ≠ 0 := by
+    change Φ (j pd q c (p pd q c z)) ≠ 0
+    rw [CycleTransfer.pairing (H := ⨂[k] i, H pd q i) δt (j pd q c) (p pd q c) (cycle_decomposition pd q c) Φ hΦδ z hz]
+    exact hΦz
+  have hSz (I : Finset t) (hi : I ⊆ active) (hI : I.card = 3) :
+      tensorAction (H pd q) (HS pd q s) I (p pd q c z) = 0 := by
+    rw [project_S_cycle pd q c s I z hz]
+    obtain ⟨y,hy⟩ := htriple I hi hI
+    rw [hy, projection_boundary]
+  choose r h hrD hrP hhP hDh hNr using
+    (fun i => BlockCohomology.retraction (pd i) (q i) (hc i) htwo (s i))
+  apply select_special_fiber_tensor (HS pd q s) (HP pd q) (HD pd q hc) r h
+    active hcard _ _ _ _ _ _ _ φ hφD (p pd q c z) hHD hφz hSz
+  · intro i; apply LinearMap.ext; intro x; exact BlockCohomology.P_sq (pd i) (q i) x
+  · intro i; apply LinearMap.ext; intro x; exact BlockCohomology.D_P (pd i) (q i) (hc i) x
+  · intro i; apply LinearMap.ext; intro x; exact hrD i x
+  · intro i; apply LinearMap.ext; intro x; exact hrP i x
+  · intro i; apply LinearMap.ext; intro x; exact hhP i x
+  · intro i; apply LinearMap.ext; intro x; exact (hDh i x).symm
+  · intro i _ x hx; exact hNr i x hx
+
+                                                                           
+                                                                    
+theorem selected_cycles (htwo : (2 : k) ≠ 0)
+    (hc : ∀ a i j x, pd a i (pd a j x) = pd a j (pd a i x))
+    (s : ∀ i, A i) (active : Finset t) (hcard : 5 ≤ active.card)
+    (Φ : (⨂[k] i, Ω i) →ₗ[k] k)
+    (hΦδ : ∀ x, Φ (δt x) = 0) (hΦD : ∀ x, Φ (Dt x) = 0)
+    (z : ⨂[k] i, Ω i) (hz : δt z = 0) (hDz : Dt z = 0) (hΦz : Φ z ≠ 0)
+    (htriple : ∀ I : Finset t, I ⊆ active → I.card = 3 →
+      ∃ y, tensorAction Ω (S s) I z = δt y) :
+    ∃ (J : Finset t) (x : ∀ i, Ω i),
+      J ⊆ active ∧ 3 ≤ J.card ∧ (∀ i, delta pd q i (x i) = 0) ∧
+      (∀ i ∈ J, ∃ y : Ω i, delta pd q i y = -MixedForms.delta (pd i) (s i) (x i)) ∧
+      Φ (PiTensorProduct.tprod k x) ≠ 0 := by
+  let c := fun i => BlockCohomology.contraction (pd i) (q i) htwo
+  obtain ⟨J,m,hJ,hcardJ,hm,hpair⟩ := selected_classes pd q htwo hc s active hcard c
+    Φ hΦδ hΦD z hz hDz hΦz htriple
+  refine ⟨J,fun i => (c i).j (m i),hJ,hcardJ,?_,?_,?_⟩
+  · intro i; exact (c i).cycle_j (m i)
+  · intro i hi
+    apply BlockCohomology.correction (pd i) (q i) (hc i) (s i)
+      ⟨(c i).j (m i), (c i).cycle_j (m i)⟩
+    · rw [(c i).class_j]; exact (hm i hi).1
+    · rw [(c i).class_j]; exact (hm i hi).2
+  · simpa only [j, PiTensorProduct.map_tprod] using hpair
+
+end BoundaryOnly.FormalObstruction.BlockTensor
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/FrobeniusObstruction/ChartPairing.lean b/lean/OAI/Algebra/FrobeniusObstruction/ChartPairing.lean
new file mode 100644
index 0000000000000000000000000000000000000000..724caa9986ec750ffa14903a7c3d195af8fc8c32
--- /dev/null
+++ b/lean/OAI/Algebra/FrobeniusObstruction/ChartPairing.lean
@@ -0,0 +1,350 @@
+import Mathlib
+import OAI.Algebra.FrobeniusObstruction.ResiduePairing
+import OAI.Algebra.FrobeniusObstruction.NormalPrimitives
+
+namespace OAI
+
+noncomputable section
+open scoped BigOperators
+
+namespace BoundaryOnly.FormalObstruction.FormsReindex
+open Frobenius MixedForms
+variable {ι κ k : Type*} [Fintype ι] [Fintype κ] [DecidableEq ι] [DecidableEq κ]
+  [CommRing k] (ell : ℕ) [CharP k ell]
+
+@[simp] theorem equiv_cartier (e : ι ≃ κ) (a : Ring (ι := ι) (k := k) ell) (m : ℕ) :
+    equiv ell e (cartier (partialDeriv ell) m a) =
+      cartier (partialDeriv ell) m (Frobenius.reindex ell e a) := by
+  simp only [cartier, map_mul, equiv_coeff, map_pow, equiv_gradient]
+
+@[simp] theorem equiv_normal (e : ι ≃ κ) (us : List (Ring (ι := ι) (k := k) ell)) (m : ℕ) :
+    equiv ell e (normal (partialDeriv ell) m us) =
+      normal (partialDeriv ell) m (us.map (Frobenius.reindex ell e)) := by
+  simp only [normal, map_list_prod, List.map_map, Function.comp_def, equiv_cartier]
+
+end BoundaryOnly.FormalObstruction.FormsReindex
+
+namespace BoundaryOnly.FormalObstruction
+open Frobenius MixedForms
+variable {k : Type*} [Field k] {d : ℕ} {n : Fin d → ℕ}
+variable (ell : ℕ) (htwo : 1 < ell) [CharP k ell] [Fact ell.Prime]
+
+                                                                            
+def swapEquiv : InternalVar n ≃ InternalVar n where
+  toFun := swapBlocks n
+  invFun := swapBlocks n
+  left_inv c := by simp [swapBlocks]
+  right_inv c := by simp [swapBlocks]
+
+@[simp] theorem swapEquiv_apply (c : InternalVar n) :
+    swapEquiv (n := n) c = (!c.1,c.2) := rfl
+
+@[simp] theorem swapEquiv_symm : (swapEquiv (n := n)).symm = swapEquiv := rfl
+
+@[simp] theorem complementaryMatrix_swap (Y : InternalVar n → MvPowerSeries (GraphVar n) k) :
+    (complementaryMatrix n Y).submatrix swapEquiv swapEquiv = complementaryMatrix n Y := by
+  ext i j
+  obtain ⟨b,t⟩ := j
+  cases b <;> simp [Matrix.submatrix_apply, complementaryMatrix, swapEquiv, swapBlocks]
+
+                                                                                
+theorem inverseChart_tangent (D : FormalData (k := k) n) :
+    tangentJacobian ell htwo (specialChartEquiv ell htwo D).symm.toAlgHom =
+      (complementaryMatrix n D.Y)⁻¹ := by
+  have he : (specialChartEquiv ell htwo D).symm.toAlgHom.comp
+      (specialChartEquiv ell htwo D).toAlgHom = AlgHom.id k _ := by
+    ext x
+    exact (specialChartEquiv ell htwo D).symm_apply_apply x
+  have h := tangentJacobian_comp ell htwo (specialChartEquiv ell htwo D).symm.toAlgHom
+    (specialChartEquiv ell htwo D).toAlgHom
+  rw [he, tangentJacobian_id] at h
+  have hM : tangentJacobian ell htwo (specialChartEquiv ell htwo D).toAlgHom =
+      complementaryMatrix n D.Y := specialChart_tangent_matrix ell htwo D
+  rw [hM] at h
+  exact (Matrix.inv_eq_right_inv h.symm).symm
+
+theorem inverseChart_tangent_swap (D : FormalData (k := k) n) (i j : InternalVar n) :
+    tangentCoeff ell htwo (swapEquiv j)
+      ((specialChartEquiv ell htwo D).symm (coordinate ell (swapEquiv i))) =
+    tangentCoeff ell htwo j ((specialChartEquiv ell htwo D).symm (coordinate ell i)) := by
+  have hs := congrArg (fun M : Matrix (InternalVar n) (InternalVar n) k => M⁻¹)
+    (complementaryMatrix_swap D.Y)
+  rw [Matrix.inv_submatrix_equiv] at hs
+  have h := congrArg (fun M : Matrix (InternalVar n) (InternalVar n) k => M i j) hs
+  rw [← inverseChart_tangent ell htwo D] at h
+  exact h
+
+omit [Fact ell.Prime] in
+theorem tangentCoeff_swap (j : InternalVar n)
+    (x : Frobenius.Ring (ι := InternalVar n) (k := k) ell) :
+    tangentCoeff ell htwo j (Frobenius.reindex ell swapEquiv x) =
+      tangentCoeff ell htwo (swapEquiv j) x := by
+  calc
+    _ = augmentation ell (by omega) (partialDeriv ell j (Frobenius.reindex ell swapEquiv x)) :=
+      tangentCoeff_eq_augmentation_partial ell htwo j _
+    _ = augmentation ell (by omega) (Frobenius.reindex ell swapEquiv
+        (partialDeriv ell (swapEquiv j) x)) := by
+      congr 1
+      simpa only [swapEquiv_apply, Bool.not_not, Prod.eta] using
+        partial_reindex ell (swapEquiv (n := n)) (swapEquiv j) x
+    _ = augmentation ell (by omega) (partialDeriv ell (swapEquiv j) x) :=
+      AlgHom.congr_fun (augmentation_natural ell htwo
+        (Frobenius.reindex (k := k) ell (swapEquiv (n := n))).toAlgHom) _
+    _ = _ := (tangentCoeff_eq_augmentation_partial ell htwo _ x).symm
+
+def jointNormalCoordinate (D : FormalData (k := k) n) (c : InternalVar n) :
+    Frobenius.Ring (ι := InternalVar n) (k := k) ell :=
+  if c.1 then (specialChartEquiv ell htwo D).symm (coordinate ell c)
+  else Frobenius.reindex ell swapEquiv
+    ((specialChartEquiv ell htwo D).symm (coordinate ell (swapEquiv c)))
+
+theorem jointNormalCoordinate_pow (D : FormalData (k := k) n) (c : InternalVar n) :
+    jointNormalCoordinate ell htwo D c ^ ell = 0 := by
+  unfold jointNormalCoordinate
+  split <;> simp only [← map_pow, coordinate_pow, map_zero]
+
+def jointNormalChart (D : FormalData (k := k) n) :
+    Frobenius.Ring (ι := InternalVar n) (k := k) ell →ₐ[k]
+      Frobenius.Ring (ι := InternalVar n) (k := k) ell :=
+  eval ell (jointNormalCoordinate ell htwo D) (jointNormalCoordinate_pow ell htwo D)
+
+@[simp] theorem jointNormalChart_coordinate (D : FormalData (k := k) n) (c : InternalVar n) :
+    jointNormalChart ell htwo D (coordinate ell c) = jointNormalCoordinate ell htwo D c :=
+  eval_coordinate ell _ _ _
+
+ theorem jointNormalChart_tangent (D : FormalData (k := k) n) :
+    tangentJacobian ell htwo (jointNormalChart ell htwo D) =
+      tangentJacobian ell htwo (specialChartEquiv ell htwo D).symm.toAlgHom := by
+  ext i j
+  change tangentCoeff ell htwo j (jointNormalChart ell htwo D (coordinate ell i)) = _
+  rw [jointNormalChart_coordinate, jointNormalCoordinate]
+  split
+  · rfl
+  · rw [tangentCoeff_swap]
+    exact inverseChart_tangent_swap ell htwo D i j
+
+ theorem jointNormalChart_bijective (D : FormalData (k := k) n) :
+    Function.Bijective (jointNormalChart ell htwo D) := by
+  apply bijective_of_tangent_matrix ell htwo
+  change IsUnit (tangentJacobian ell htwo (jointNormalChart ell htwo D)).det
+  rw [jointNormalChart_tangent]
+  exact tangentJacobian_det_unit ell htwo (specialChartEquiv ell htwo D).symm
+
+end BoundaryOnly.FormalObstruction
+
+namespace BoundaryOnly.FormalObstruction.Frobenius
+variable {ι κ k : Type*} [Fintype ι] [Fintype κ] [DecidableEq ι] [DecidableEq κ]
+  [Field k] (ell : ℕ) (htwo : 1 < ell) [CharP k ell] [Fact ell.Prime]
+
+theorem reindex_mk (e : ι ≃ κ) (p : MvPowerSeries ι k) :
+    reindex ell e (Ideal.Quotient.mk _ p) = Ideal.Quotient.mk _ (MvPowerSeries.rename e p) := by
+  let a : ι → MvPowerSeries κ k := fun i => MvPowerSeries.X (e i)
+  have ha : ∀ i, MvPowerSeries.constantCoeff (a i) = 0 := by intro i; simp [a]
+  have hh : (reindex (k := k) ell e).toAlgHom = substitute ell a ha := by
+    apply algHom_ext
+    intro i
+    rw [AlgEquiv.coe_toAlgHom, reindex_coordinate,
+      substitute_coordinate]
+    rfl
+  change (reindex ell e).toAlgHom (Ideal.Quotient.mk _ p) = _
+  rw [hh, substitute_mk, MvPowerSeries.rename_eq_subst]
+  rfl
+
+omit [DecidableEq ι] [DecidableEq κ] [Fact ell.Prime] in
+theorem embDomain_top (e : ι ≃ κ) :
+    Finsupp.embDomain e.toEmbedding (topExponent (ι := ι) ell) = topExponent (ι := κ) ell := by
+  ext i
+  obtain ⟨j,rfl⟩ := e.surjective i
+  exact (Finsupp.embDomain_apply_self e.toEmbedding (topExponent ell) j).trans
+    (topExponent_apply ell j)
+
+ theorem topCoeff_reindex (e : ι ≃ κ) (x : Ring (ι := ι) (k := k) ell) :
+    quotientCoeff ell (topExponent ell) (topExponent_good (by omega)) (reindex ell e x) =
+      quotientCoeff ell (topExponent ell) (topExponent_good (by omega)) x := by
+  obtain ⟨p,rfl⟩ := Ideal.Quotient.mk_surjective x
+  rw [reindex_mk ell e p, quotientCoeff_mk, quotientCoeff_mk, ← embDomain_top ell e]
+  exact MvPowerSeries.coeff_embDomain_rename e.toEmbedding p (topExponent ell)
+
+end BoundaryOnly.FormalObstruction.Frobenius
+
+namespace BoundaryOnly.FormalObstruction.MixedForms
+variable {k A ι : Type*} [CommRing k] [CommRing A] [Algebra k A]
+  [Fintype ι] [DecidableEq ι]
+
+                                                                                        
+def fixedResidue (ρ : A →ₗ[k] k) (v : Ext (k := k) (ι := ι) →ₗ[k] k) :
+    Forms (k := k) (A := A) (ι := ι) →ₗ[k] k :=
+  (LinearMap.mul' k k).comp (TensorProduct.map ρ v)
+
+omit [Fintype ι] [DecidableEq ι] in
+@[simp] theorem fixedResidue_tmul (ρ : A →ₗ[k] k) (v : Ext (k := k) (ι := ι) →ₗ[k] k)
+    (a : A) (x : Ext (k := k) (ι := ι)) :
+    fixedResidue ρ v (a ⊗ₜ[k] x) = ρ a * v x := rfl
+
+ theorem fixedResidue_d (pd : ι → Derivation k A A) (ρ : A →ₗ[k] k)
+    (v : Ext (k := k) (ι := ι) →ₗ[k] k) (hρ : ∀ i a, ρ (pd i a) = 0)
+    (x : Forms (k := k) (A := A) (ι := ι)) : fixedResidue ρ v (d pd x) = 0 := by
+  induction x using TensorProduct.inductionOn with
+  | add x y hx hy => simp only [map_add, hx, hy, add_zero]
+  | tmul a x => simp only [d_tmul, map_sum, fixedResidue_tmul, hρ, zero_mul, Finset.sum_const_zero]
+
+ theorem fixedResidue_mul_d (pd : ι → Derivation k A A) (ρ : A →ₗ[k] k)
+    (v : Ext (k := k) (ι := ι) →ₗ[k] k) (hρ : ∀ i a, ρ (pd i a) = 0)
+    (x y : Forms (k := k) (A := A) (ι := ι)) (hx : d pd x = 0) :
+    fixedResidue ρ v (x * d pd y) = 0 := by
+  have h := fixedResidue_d pd ρ v hρ (parity x * y)
+  rw [d_mul, d_parity, hx, map_zero, neg_zero, zero_mul, parity_sq, zero_add] at h
+  exact h
+
+end BoundaryOnly.FormalObstruction.MixedForms
+
+namespace BoundaryOnly.FormalObstruction.FormsReindex
+open Frobenius MixedForms
+variable {ι k : Type*} [Fintype ι] [DecidableEq ι] [Field k]
+  (ell : ℕ) (htwo : 1 < ell) [CharP k ell] [Fact ell.Prime] {N : ℕ}
+
+ theorem residue_equiv (e : ι ≃ Fin N) (x : QForms (k := k) ell ι) :
+    NormalPairing.res ell htwo (equiv ell e x) =
+      fixedResidue (quotientCoeff ell (topExponent ell) (topExponent_good (by omega)))
+        ((volumeCoeff (k := k)).comp (exterior e).toLinearMap) x := by
+  induction x using TensorProduct.inductionOn with
+  | add x y hx hy => simp only [map_add, hx, hy]
+  | tmul a x =>
+      simp only [equiv_tmul, NormalPairing.res, residue_tmul, fixedResidue_tmul,
+        topCoeff_reindex ell htwo, LinearMap.comp_apply, AlgEquiv.toLinearMap_apply]
+
+end BoundaryOnly.FormalObstruction.FormsReindex
+
+namespace BoundaryOnly.FormalObstruction
+open Frobenius MixedForms
+variable {d : ℕ} {n : Fin d → ℕ}
+
+def fullNormalIndexList : List (InternalVar n) :=
+  (normalIndices (n := n)).toList ++ (normalIndices (n := n)).toList.map swapEquiv
+
+ theorem fullNormalIndexList_nodup : (fullNormalIndexList (n := n)).Nodup := by
+  apply List.nodup_append.mpr
+  refine ⟨Finset.nodup_toList _, (Finset.nodup_toList _).map swapEquiv.injective, ?_⟩
+  intro c hc c' hc' hcc
+  subst c'
+  have hct : c.1 = true := mem_normalIndices c |>.mp (Finset.mem_toList.mp hc)
+  obtain ⟨j,hj,hjc⟩ := List.mem_map.mp hc'
+  have hjt : j.1 = true := mem_normalIndices j |>.mp (Finset.mem_toList.mp hj)
+  have hb := congrArg Prod.fst hjc
+  simp only [swapEquiv_apply, hjt, Bool.not_true, hct] at hb
+  cases hb
+
+ theorem mem_fullNormalIndexList (c : InternalVar n) : c ∈ fullNormalIndexList (n := n) := by
+  obtain ⟨b,t⟩ := c
+  cases b
+  · apply List.mem_append_right
+    apply List.mem_map.mpr
+    exact ⟨(true,t), by simp [normalIndices], rfl⟩
+  · apply List.mem_append_left
+    simp [normalIndices]
+
+                                                                                    
+def normalEnumeration : Fin (fullNormalIndexList (n := n)).length ≃ InternalVar n :=
+  Equiv.ofBijective (fullNormalIndexList (n := n)).get
+    ⟨fullNormalIndexList_nodup.injective_get,
+      fun x => List.mem_iff_get.mp (mem_fullNormalIndexList x)⟩
+
+ theorem normalEnumeration_list :
+    List.ofFn (normalEnumeration (n := n)) = fullNormalIndexList (n := n) :=
+  List.ofFn_get _
+
+end BoundaryOnly.FormalObstruction
+
+namespace BoundaryOnly.FormalObstruction
+open Frobenius MixedForms
+variable {k : Type*} [Field k] {d : ℕ} {n : Fin d → ℕ}
+variable (ell : ℕ) (htwo : 1 < ell) [CharP k ell] [Fact ell.Prime]
+
+                                                                                  
+def negativeNormal (D : FormalData (k := k) n) :
+    Forms (k := k) (A := Frobenius.Ring (ι := InternalVar n) (k := k) ell) (ι := InternalVar n) :=
+  FormsReindex.equiv ell swapEquiv (specialNormal ell htwo D)
+
+ theorem jointNormal_list (D : FormalData (k := k) n) :
+    (fullNormalIndexList (n := n)).map (jointNormalCoordinate ell htwo D) =
+      normalCoordinateList ell (specialChartEquiv ell htwo D).symm normalIndices ++
+        (normalCoordinateList ell (specialChartEquiv ell htwo D).symm normalIndices).map
+          (Frobenius.reindex ell swapEquiv) := by
+  simp only [fullNormalIndexList, List.map_append, List.map_map, normalCoordinateList]
+  congr 1
+  · apply List.map_congr_left
+    intro c hc
+    have hct := (mem_normalIndices c).mp (Finset.mem_toList.mp hc)
+    simp only [jointNormalCoordinate, hct, ite_true]
+  · apply List.map_congr_left
+    intro c hc
+    have hct := (mem_normalIndices c).mp (Finset.mem_toList.mp hc)
+    simp only [Function.comp_apply, jointNormalCoordinate, swapEquiv_apply,
+      hct, Bool.not_true, Bool.false_eq_true, ite_false, Bool.not_false]
+    congr 3
+    exact Prod.ext hct.symm rfl
+
+ theorem specialNormal_product (D : FormalData (k := k) n) :
+    specialNormal ell htwo D * negativeNormal ell htwo D =
+      normal (partialDeriv ell) (ell-1)
+        ((fullNormalIndexList (n := n)).map (jointNormalCoordinate ell htwo D)) := by
+  rw [jointNormal_list]
+  rw [negativeNormal, specialNormal, chartNormal, FormsReindex.equiv_normal]
+  simp only [normal, List.map_append, List.prod_append]
+
+ def finiteNormalChart (D : FormalData (k := k) n) :
+    Frobenius.Ring (ι := Fin (fullNormalIndexList (n := n)).length) (k := k) ell ≃ₐ[k]
+      Frobenius.Ring (ι := Fin (fullNormalIndexList (n := n)).length) (k := k) ell :=
+  ((Frobenius.reindex ell normalEnumeration).trans
+    (AlgEquiv.ofBijective (jointNormalChart ell htwo D) (jointNormalChart_bijective ell htwo D))).trans
+      (Frobenius.reindex ell normalEnumeration.symm)
+
+@[simp] theorem finiteNormalChart_coordinate (D : FormalData (k := k) n)
+    (i : Fin (fullNormalIndexList (n := n)).length) :
+    finiteNormalChart ell htwo D (coordinate ell i) =
+      Frobenius.reindex ell normalEnumeration.symm
+        (jointNormalCoordinate ell htwo D (normalEnumeration i)) := by
+  change Frobenius.reindex ell normalEnumeration.symm
+    (jointNormalChart ell htwo D (Frobenius.reindex ell normalEnumeration (coordinate ell i))) = _
+  rw [reindex_coordinate, jointNormalChart_coordinate]
+
+ theorem specialNormal_product_reindex (D : FormalData (k := k) n) :
+    FormsReindex.equiv ell normalEnumeration.symm
+      (specialNormal ell htwo D * negativeNormal ell htwo D) =
+      normal (partialDeriv ell) (ell-1)
+        (List.ofFn fun i => finiteNormalChart ell htwo D (coordinate ell i)) := by
+  rw [specialNormal_product, FormsReindex.equiv_normal]
+  congr 1
+  calc
+    _ = ((List.ofFn (normalEnumeration (n := n))).map
+        (jointNormalCoordinate ell htwo D)).map
+        (Frobenius.reindex ell normalEnumeration.symm) :=
+      congrArg (fun l : List (InternalVar n) =>
+        (l.map (jointNormalCoordinate ell htwo D)).map
+          (Frobenius.reindex ell normalEnumeration.symm)) normalEnumeration_list.symm
+    _ = _ := by
+      simp only [List.map_ofFn]
+      congr 1
+      funext i
+      exact (finiteNormalChart_coordinate ell htwo D i).symm
+
+                                                                          
+                                                                                        
+theorem specialNormal_pairing (D : FormalData (k := k) n) :
+    ∃ v : Ext (k := k) (ι := InternalVar n) →ₗ[k] k,
+      fixedResidue (quotientCoeff ell (topExponent ell) (topExponent_good (by omega))) v
+        (specialNormal ell htwo D * negativeNormal ell htwo D) ≠ 0 := by
+  let v := (volumeCoeff (k := k)).comp
+    (FormsReindex.exterior (normalEnumeration (n := n)).symm).toLinearMap
+  refine ⟨v, ?_⟩
+  rw [← FormsReindex.residue_equiv ell htwo normalEnumeration.symm,
+    specialNormal_product_reindex]
+  exact NormalPairing.coordinate_residue_ne_zero ell htwo
+    (finiteNormalChart ell htwo D).toAlgHom (finiteNormalChart ell htwo D).bijective
+    (tangentJacobian_det_unit ell htwo (finiteNormalChart ell htwo D))
+
+end BoundaryOnly.FormalObstruction
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/FrobeniusObstruction/CoordinateMaps.lean b/lean/OAI/Algebra/FrobeniusObstruction/CoordinateMaps.lean
new file mode 100644
index 0000000000000000000000000000000000000000..38aa77a8baebf46c0d3a761c96f6b54e359e569d
--- /dev/null
+++ b/lean/OAI/Algebra/FrobeniusObstruction/CoordinateMaps.lean
@@ -0,0 +1,79 @@
+import Mathlib
+import OAI.Algebra.FrobeniusObstruction.LinearChange
+
+namespace OAI
+
+noncomputable section
+open scoped BigOperators
+
+namespace BoundaryOnly.FormalObstruction.Frobenius
+variable {ι k l : Type*} [Fintype ι] [DecidableEq ι] [CommRing k] [CommRing l]
+variable (ell : ℕ)
+
+                                                                             
+def mapCoefficients (f : k →+* l) : Ring (ι := ι) (k := k) ell →+*
+    Ring (ι := ι) (k := l) ell :=
+  Ideal.Quotient.lift _ ((Ideal.Quotient.mk _).comp (MvPowerSeries.map f)) (by
+    intro p hp
+    obtain ⟨c, rfl⟩ := Ideal.mem_span_range_iff_exists_fun.mp hp
+    simp only [RingHom.comp_apply, map_sum, map_mul, map_pow, MvPowerSeries.map_X]
+    apply Finset.sum_eq_zero
+    intro i _
+    change _ * coordinate (k := l) ell i ^ ell = 0
+    rw [coordinate_pow, mul_zero])
+
+omit [DecidableEq ι] in
+@[simp] theorem mapCoefficients_mk (f : k →+* l) (p : Series (ι := ι) (k := k)) :
+    mapCoefficients ell f (Ideal.Quotient.mk _ p) =
+      Ideal.Quotient.mk _ (MvPowerSeries.map f p) := rfl
+
+omit [DecidableEq ι] in
+@[simp] theorem mapCoefficients_coordinate (f : k →+* l) (i : ι) :
+    mapCoefficients ell f (coordinate ell i) = coordinate ell i := by
+  simp [coordinate]
+
+omit [DecidableEq ι] in
+@[simp] theorem mapCoefficients_monomial (f : k →+* l) (v : Box (ι := ι) ell) :
+    mapCoefficients ell f (monomial ell v) = monomial ell v := by
+  simp [monomial]
+
+omit [DecidableEq ι] in
+@[simp] theorem coefficients_mapCoefficients (f : k →+* l) (x : Ring (ι := ι) (k := k) ell)
+    (v : Box (ι := ι) ell) :
+    coefficients ell (mapCoefficients ell f x) v = f (coefficients ell x v) := by
+  obtain ⟨p, rfl⟩ := Ideal.Quotient.mk_surjective x
+  simp only [mapCoefficients_mk, coefficients_apply, quotientCoeff_mk, MvPowerSeries.coeff_map]
+
+                                                                             
+def monomialBasis : Module.Basis (Box (ι := ι) ell) k (Ring (ι := ι) (k := k) ell) :=
+  (Pi.basisFun k (Box (ι := ι) ell)).map (coefficientEquiv ell).symm
+
+@[simp] theorem monomialBasis_apply (v : Box (ι := ι) ell) :
+    monomialBasis (k := k) ell v = monomial ell v := by
+  apply coefficients_injective ell
+  funext w
+  change (coefficientEquiv ell) ((coefficientEquiv ell).symm
+    ((Pi.basisFun k (Box (ι := ι) ell)) v)) w = _
+  rw [LinearEquiv.apply_symm_apply]
+  simp [coefficients_apply, Pi.basisFun_apply, Pi.single_apply, eq_comm]
+
+@[simp] theorem monomialBasis_repr (x : Ring (ι := ι) (k := k) ell) (v : Box (ι := ι) ell) :
+    (monomialBasis ell).repr x v = coefficients ell x v := by
+  simp [monomialBasis, coefficientEquiv]
+  rfl
+
+end BoundaryOnly.FormalObstruction.Frobenius
+
+   
+                                                                            
+                                                                       
+                                                                                
+  
+
+noncomputable section
+open scoped BigOperators
+
+end
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/FrobeniusObstruction/Coordinates.lean b/lean/OAI/Algebra/FrobeniusObstruction/Coordinates.lean
new file mode 100644
index 0000000000000000000000000000000000000000..7cbf07606c4ffdd6a53ed98f4f7c8d1d9827619c
--- /dev/null
+++ b/lean/OAI/Algebra/FrobeniusObstruction/Coordinates.lean
@@ -0,0 +1,108 @@
+import Mathlib
+import OAI.Algebra.FrobeniusObstruction.FrobeniusRing
+
+namespace OAI
+
+noncomputable section
+open scoped BigOperators
+
+namespace BoundaryOnly.FormalObstruction.Frobenius
+open scoped TensorProduct
+variable {ι κ k : Type*} [Fintype ι] [Fintype κ] [DecidableEq ι] [DecidableEq κ]
+  [CommRing k]
+variable (ell : ℕ)
+
+noncomputable def includeVariables (f : ι → κ) :
+    Ring (ι := ι) (k := k) ell →ₐ[k] Ring (ι := κ) (k := k) ell :=
+  eval ell (fun i => coordinate ell (f i)) (fun i => coordinate_pow ell (f i))
+
+omit [Fintype κ] [DecidableEq ι] [DecidableEq κ] in
+@[simp] theorem includeVariables_coordinate (f : ι → κ) (i : ι) :
+    includeVariables (k := k) ell f (coordinate ell i) = coordinate ell (f i) :=
+  eval_coordinate _ _ _ _
+
+noncomputable def merge :
+    Ring (ι := ι) (k := k) ell ⊗[k] Ring (ι := κ) (k := k) ell →ₐ[k]
+      Ring (ι := ι ⊕ κ) (k := k) ell :=
+  Algebra.TensorProduct.lift (includeVariables ell Sum.inl) (includeVariables ell Sum.inr)
+    (fun _ _ => Commute.all _ _)
+
+omit [DecidableEq ι] [DecidableEq κ] in
+@[simp] theorem merge_tmul (a : Ring (ι := ι) (k := k) ell)
+    (b : Ring (ι := κ) (k := k) ell) : merge (k := k) (ι := ι) (κ := κ) ell (a ⊗ₜ[k] b) =
+      includeVariables (k := k) ell (Sum.inl : ι → ι ⊕ κ) a * includeVariables (k := k) ell (Sum.inr : κ → ι ⊕ κ) b := by
+  exact Algebra.TensorProduct.lift_tmul _ _ _ a b
+
+noncomputable def splitCoordinates : ι ⊕ κ →
+    Ring (ι := ι) (k := k) ell ⊗[k] Ring (ι := κ) (k := k) ell
+  | .inl i => (Algebra.TensorProduct.includeLeft : Ring (ι := ι) (k := k) ell →ₐ[k] Ring (ι := ι) (k := k) ell ⊗[k] Ring (ι := κ) (k := k) ell) (coordinate ell i)
+  | .inr j => (Algebra.TensorProduct.includeRight : Ring (ι := κ) (k := k) ell →ₐ[k] Ring (ι := ι) (k := k) ell ⊗[k] Ring (ι := κ) (k := k) ell) (coordinate ell j)
+
+omit [Fintype ι] [Fintype κ] [DecidableEq ι] [DecidableEq κ] in
+theorem splitCoordinates_pow (i : ι ⊕ κ) :
+    splitCoordinates (k := k) ell i ^ ell = 0 := by
+  cases i with
+  | inl i => change ((Algebra.TensorProduct.includeLeft : Ring (ι := ι) (k := k) ell →ₐ[k] Ring (ι := ι) (k := k) ell ⊗[k] Ring (ι := κ) (k := k) ell) (coordinate ell i))^ell = 0
+             rw [← map_pow, coordinate_pow, map_zero]
+  | inr j => change ((Algebra.TensorProduct.includeRight : Ring (ι := κ) (k := k) ell →ₐ[k] Ring (ι := ι) (k := k) ell ⊗[k] Ring (ι := κ) (k := k) ell) (coordinate ell j))^ell = 0
+             rw [← map_pow, coordinate_pow, map_zero]
+
+noncomputable def splitBlocks : Ring (ι := ι ⊕ κ) (k := k) ell →ₐ[k]
+    Ring (ι := ι) (k := k) ell ⊗[k] Ring (ι := κ) (k := k) ell :=
+  eval ell (splitCoordinates (k := k) (ι := ι) (κ := κ) ell) (splitCoordinates_pow ell)
+
+omit [DecidableEq ι] [DecidableEq κ] in
+@[simp] theorem split_coordinate (i : ι ⊕ κ) :
+    splitBlocks (k := k) ell (coordinate ell i) = splitCoordinates ell i :=
+  eval_coordinate _ _ _ _
+
+omit [DecidableEq κ] in
+@[simp] theorem split_includeVariables_left :
+    (splitBlocks (k := k) (ι := ι) (κ := κ) ell).comp (includeVariables ell Sum.inl) =
+      Algebra.TensorProduct.includeLeft := by
+  refine algHom_ext (ι := ι) (k := k) (S := Ring (ι := ι) (k := k) ell ⊗[k] Ring (ι := κ) (k := k) ell) ell _ _ ?_
+  intro i
+  simp only [AlgHom.comp_apply, includeVariables_coordinate, split_coordinate]
+  rfl
+
+omit [DecidableEq ι] in
+@[simp] theorem split_includeVariables_right :
+    (splitBlocks (k := k) (ι := ι) (κ := κ) ell).comp (includeVariables ell Sum.inr) =
+      Algebra.TensorProduct.includeRight := by
+  refine algHom_ext (ι := κ) (k := k) (S := Ring (ι := ι) (k := k) ell ⊗[k] Ring (ι := κ) (k := k) ell) ell _ _ ?_
+  intro i
+  simp only [AlgHom.comp_apply, includeVariables_coordinate, split_coordinate]
+  rfl
+
+theorem merge_split :
+    (merge (k := k) (ι := ι) (κ := κ) ell).comp (splitBlocks ell) = AlgHom.id k _ := by
+  refine algHom_ext (ι := ι ⊕ κ) (k := k) (S := Ring (ι := ι ⊕ κ) (k := k) ell) ell _ _ ?_
+  intro i
+  cases i with
+  | inl i => simp [splitCoordinates, Algebra.TensorProduct.includeLeft_apply]
+  | inr j => simp [splitCoordinates, Algebra.TensorProduct.includeRight_apply]
+
+theorem split_merge :
+    (splitBlocks (k := k) (ι := ι) (κ := κ) ell).comp (merge (k := k) (ι := ι) (κ := κ) ell) = AlgHom.id k _ := by
+  apply AlgHom.ext
+  intro x
+  induction x using TensorProduct.inductionOn with
+  | add x y hx hy => simp only [map_add, hx, hy]
+  | tmul a b =>
+      change splitBlocks (k := k) (ι := ι) (κ := κ) ell (merge (k := k) (ι := ι) (κ := κ) ell (a ⊗ₜ[k] b)) = a ⊗ₜ[k] b
+      rw [merge_tmul, map_mul]
+      have h1 := AlgHom.congr_fun (split_includeVariables_left (k := k) (ι := ι) (κ := κ) ell) a
+      have h2 := AlgHom.congr_fun (split_includeVariables_right (k := k) (ι := ι) (κ := κ) ell) b
+      rw [AlgHom.comp_apply] at h1 h2
+      rw [h1, h2]
+      simp [Algebra.TensorProduct.includeLeft_apply, Algebra.TensorProduct.includeRight_apply]
+
+noncomputable def sumEquiv : Ring (ι := ι ⊕ κ) (k := k) ell ≃ₐ[k]
+    Ring (ι := ι) (k := k) ell ⊗[k] Ring (ι := κ) (k := k) ell :=
+  AlgEquiv.ofAlgHom (splitBlocks ell) (merge (k := k) (ι := ι) (κ := κ) ell) (split_merge ell) (merge_split (k := k) (ι := ι) (κ := κ) ell)
+
+end BoundaryOnly.FormalObstruction.Frobenius
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/FrobeniusObstruction/CycleTransfer.lean b/lean/OAI/Algebra/FrobeniusObstruction/CycleTransfer.lean
new file mode 100644
index 0000000000000000000000000000000000000000..b189f4eb08165195982de359b25d3150a24f5895
--- /dev/null
+++ b/lean/OAI/Algebra/FrobeniusObstruction/CycleTransfer.lean
@@ -0,0 +1,53 @@
+import Mathlib
+
+namespace OAI
+
+noncomputable section
+open scoped BigOperators
+
+namespace BoundaryOnly.FormalObstruction.CycleTransfer
+variable {k A H : Type*} [Field k] [AddCommGroup A] [Module k A]
+  [AddCommGroup H] [Module k H]
+variable (δ : A →ₗ[k] A) (j : H →ₗ[k] A) (p : A →ₗ[k] H)
+variable (hpδ : ∀ x, p (δ x) = 0)
+variable (hdecomp : ∀ z, δ z = 0 → ∃ y, z - j (p z) = δ y)
+
+                                                                          
+                                                                         
+include hpδ hdecomp in
+theorem operator (F G : A →ₗ[k] A) (T : H →ₗ[k] H)
+    (hF : ∀ x, F (δ x) = δ (G x))
+    (hT : ∀ x, T x = p (F (j x))) (z : A) (hz : δ z = 0) :
+    T (p z) = p (F z) := by
+  obtain ⟨y,hy⟩ := hdecomp z hz
+  have h := congrArg (fun a => p (F a)) hy
+  simp only [map_sub, hF, hpδ] at h
+  rw [hT]
+  exact (sub_eq_zero.mp h).symm
+
+                                                                  
+include hdecomp in
+theorem pairing (Φ : A →ₗ[k] k) (hΦδ : ∀ a, Φ (δ a) = 0)
+    (z : A) (hz : δ z = 0) : Φ (j (p z)) = Φ z := by
+  obtain ⟨y,hy⟩ := hdecomp z hz
+  have h := congrArg Φ hy
+  simp only [map_sub, hΦδ] at h
+  exact (sub_eq_zero.mp h).symm
+
+                                                                        
+                                                                                
+include hdecomp in
+theorem pairing_operator (F G : A →ₗ[k] A) (T : H →ₗ[k] H)
+    (hδF : ∀ x, δ (F x) = G (δ x)) (hδj : ∀ x, δ (j x) = 0)
+    (hT : ∀ x, T x = p (F (j x)))
+    (Φ : A →ₗ[k] k) (hΦδ : ∀ a, Φ (δ a) = 0) (hΦF : ∀ a, Φ (F a) = 0)
+    (x : H) : Φ (j (T x)) = 0 := by
+  rw [hT, pairing δ j p hdecomp Φ hΦδ]
+  · exact hΦF _
+  · rw [hδF, hδj, map_zero]
+
+end BoundaryOnly.FormalObstruction.CycleTransfer
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/FrobeniusObstruction/Derivations.lean b/lean/OAI/Algebra/FrobeniusObstruction/Derivations.lean
new file mode 100644
index 0000000000000000000000000000000000000000..f673a5ddb7aa4e2051e814cd9c426dbd1c2c6ab9
--- /dev/null
+++ b/lean/OAI/Algebra/FrobeniusObstruction/Derivations.lean
@@ -0,0 +1,140 @@
+import Mathlib
+import OAI.Algebra.FrobeniusObstruction.Coordinates
+
+namespace OAI
+
+noncomputable section
+open scoped BigOperators
+
+namespace BoundaryOnly.FormalObstruction.Frobenius
+variable {ι k S : Type*} [Fintype ι] [DecidableEq ι] [CommRing k]
+  [CommRing S] [Algebra k S] (ell : ℕ)
+
+                                                                          
+                                                                                     
+theorem relativeDeriv_ext (f : Ring (ι := ι) (k := k) ell →ₐ[k] S)
+    (u v : Ring (ι := ι) (k := k) ell →ₗ[k] S)
+    (hu1 : u 1 = 0) (hv1 : v 1 = 0)
+    (hu : ∀ x y, u (x*y) = u x * f y + f x * u y)
+    (hv : ∀ x y, v (x*y) = v x * f y + f x * v y)
+    (h : ∀ i, u (coordinate ell i) = v (coordinate ell i)) : u = v := by
+  let X : ι → Ring (ι := ι) (k := k) ell := coordinate ell
+  have hp (i : ι) (r : ℕ) : u (X i ^ r) = v (X i ^ r) := by
+    induction r with
+    | zero => exact hu1.trans hv1.symm
+    | succ r hr =>
+      rw [pow_succ, hu, hv, hr, h i]
+  have hm (s : Finset ι) (p : ι → ℕ) :
+      u (∏ i ∈ s, X i ^ p i) = v (∏ i ∈ s, X i ^ p i) := by
+    induction s using Finset.induction_on with
+    | empty => exact hu1.trans hv1.symm
+    | @insert i s hi ih =>
+      rw [Finset.prod_insert hi, hu, hv, hp, ih]
+  apply LinearMap.ext
+  intro x
+  rw [monomial_expansion ell x, map_sum, map_sum]
+  apply Finset.sum_congr rfl
+  intro a _
+  rw [map_smul, map_smul, monomial_eq_prod]
+  congr 1
+  simpa only [monomial_eq_prod, Finsupp.prod, X] using hm _ (exponent ell a)
+
+variable {κ : Type*} [Fintype κ] [DecidableEq κ] [CharP k ell]
+
+@[simp] theorem partial_include_left (i : ι) (a : Ring (ι := ι) (k := k) ell) :
+    partialDeriv ell (Sum.inl i : ι ⊕ κ)
+      (includeVariables (k := k) ell Sum.inl a) =
+    includeVariables (k := k) ell Sum.inl (partialDeriv ell i a) := by
+  let f : Ring (ι := ι) (k := k) ell →ₐ[k] Ring (ι := ι ⊕ κ) (k := k) ell :=
+    includeVariables ell Sum.inl
+  have H : (partialDeriv (k := k) ell (Sum.inl i : ι ⊕ κ)).toLinearMap.comp f.toLinearMap =
+      f.toLinearMap.comp (partialDeriv ell i).toLinearMap := by
+    apply relativeDeriv_ext ell f
+    · simp
+    · simp
+    · intro x y
+      simp only [LinearMap.comp_apply, Derivation.coeFn_coe, AlgHom.toLinearMap_apply,
+        map_mul, Derivation.leibniz, smul_eq_mul]
+      ring
+    · intro x y
+      simp only [LinearMap.comp_apply, Derivation.coeFn_coe, AlgHom.toLinearMap_apply,
+        Derivation.leibniz, smul_eq_mul, map_add, map_mul]
+      ring
+    · intro j
+      simp only [LinearMap.comp_apply, Derivation.coeFn_coe, AlgHom.toLinearMap_apply,
+        f, includeVariables_coordinate]
+      simp only [coordinate, partial_coordinate, Sum.inl.injEq]
+      split_ifs <;> simp
+  exact LinearMap.congr_fun H a
+
+@[simp] theorem partial_include_left_other (j : κ) (a : Ring (ι := ι) (k := k) ell) :
+    partialDeriv ell (Sum.inr j : ι ⊕ κ)
+      (includeVariables (k := k) ell Sum.inl a) = 0 := by
+  let f : Ring (ι := ι) (k := k) ell →ₐ[k] Ring (ι := ι ⊕ κ) (k := k) ell :=
+    includeVariables ell Sum.inl
+  have H : (partialDeriv (k := k) ell (Sum.inr j : ι ⊕ κ)).toLinearMap.comp f.toLinearMap = 0 := by
+    apply relativeDeriv_ext ell f
+    · simp
+    · rfl
+    · intro x y
+      simp only [LinearMap.comp_apply, Derivation.coeFn_coe, AlgHom.toLinearMap_apply,
+        map_mul, Derivation.leibniz, smul_eq_mul]
+      ring
+    · intros; simp
+    · intro i
+      simp only [LinearMap.comp_apply, Derivation.coeFn_coe, AlgHom.toLinearMap_apply,
+        f, includeVariables_coordinate, LinearMap.zero_apply]
+      simp only [coordinate, partial_coordinate, Sum.inr_ne_inl, ↓reduceIte]
+  exact LinearMap.congr_fun H a
+
+@[simp] theorem partial_include_right (i : κ) (a : Ring (ι := κ) (k := k) ell) :
+    partialDeriv ell (Sum.inr i : ι ⊕ κ)
+      (includeVariables (k := k) ell Sum.inr a) =
+    includeVariables (k := k) ell Sum.inr (partialDeriv ell i a) := by
+  let f : Ring (ι := κ) (k := k) ell →ₐ[k] Ring (ι := ι ⊕ κ) (k := k) ell :=
+    includeVariables ell Sum.inr
+  have H : (partialDeriv (k := k) ell (Sum.inr i : ι ⊕ κ)).toLinearMap.comp f.toLinearMap =
+      f.toLinearMap.comp (partialDeriv ell i).toLinearMap := by
+    apply relativeDeriv_ext ell f
+    · simp
+    · simp
+    · intro x y
+      simp only [LinearMap.comp_apply, Derivation.coeFn_coe, AlgHom.toLinearMap_apply,
+        map_mul, Derivation.leibniz, smul_eq_mul]
+      ring
+    · intro x y
+      simp only [LinearMap.comp_apply, Derivation.coeFn_coe, AlgHom.toLinearMap_apply,
+        Derivation.leibniz, smul_eq_mul, map_add, map_mul]
+      ring
+    · intro j
+      simp only [LinearMap.comp_apply, Derivation.coeFn_coe, AlgHom.toLinearMap_apply,
+        f, includeVariables_coordinate]
+      simp only [coordinate, partial_coordinate, Sum.inr.injEq]
+      split_ifs <;> simp
+  exact LinearMap.congr_fun H a
+
+@[simp] theorem partial_include_right_other (j : ι) (a : Ring (ι := κ) (k := k) ell) :
+    partialDeriv ell (Sum.inl j : ι ⊕ κ)
+      (includeVariables (k := k) ell Sum.inr a) = 0 := by
+  let f : Ring (ι := κ) (k := k) ell →ₐ[k] Ring (ι := ι ⊕ κ) (k := k) ell :=
+    includeVariables ell Sum.inr
+  have H : (partialDeriv (k := k) ell (Sum.inl j : ι ⊕ κ)).toLinearMap.comp f.toLinearMap = 0 := by
+    apply relativeDeriv_ext ell f
+    · simp
+    · rfl
+    · intro x y
+      simp only [LinearMap.comp_apply, Derivation.coeFn_coe, AlgHom.toLinearMap_apply,
+        map_mul, Derivation.leibniz, smul_eq_mul]
+      ring
+    · intros; simp
+    · intro i
+      simp only [LinearMap.comp_apply, Derivation.coeFn_coe, AlgHom.toLinearMap_apply,
+        f, includeVariables_coordinate, LinearMap.zero_apply]
+      simp only [coordinate, partial_coordinate, Sum.inl_ne_inr, ↓reduceIte]
+  exact LinearMap.congr_fun H a
+
+end BoundaryOnly.FormalObstruction.Frobenius
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/FrobeniusObstruction/ExteriorSplit.lean b/lean/OAI/Algebra/FrobeniusObstruction/ExteriorSplit.lean
new file mode 100644
index 0000000000000000000000000000000000000000..d264688feb0226d7268afc210f29b2e6635f09cb
--- /dev/null
+++ b/lean/OAI/Algebra/FrobeniusObstruction/ExteriorSplit.lean
@@ -0,0 +1,63 @@
+import Mathlib
+
+namespace OAI
+
+noncomputable section
+open scoped BigOperators
+
+noncomputable section
+open scoped TensorProduct
+namespace BoundaryOnly.FormalObstruction.ExteriorSplit
+variable {k ι κ : Type*} [CommRing k]
+
+abbrev Ext (k ι : Type*) [CommRing k] := ExteriorAlgebra k (ι → k)
+
+def leftVec : (ι → k) →ₗ[k] (ι ⊕ κ → k) where
+  toFun v := Sum.elim v (fun _ => 0)
+  map_add' x y := by funext i; cases i <;> simp
+  map_smul' a x := by funext i; cases i <;> simp
+
+def rightVec : (κ → k) →ₗ[k] (ι ⊕ κ → k) where
+  toFun v := Sum.elim (fun _ => 0) v
+  map_add' x y := by funext i; cases i <;> simp
+  map_smul' a x := by funext i; cases i <;> simp
+
+def splitIsometry : (0 : QuadraticForm k (ι ⊕ κ → k)).IsometryEquiv
+    ((0 : QuadraticForm k (ι → k)).prod (0 : QuadraticForm k (κ → k))) :=
+  { LinearEquiv.sumArrowLequivProdArrow ι κ k k with
+    map_app' := fun x => by simp }
+
+noncomputable def sumEquiv : Ext k (ι ⊕ κ) ≃ₗ[k] Ext k ι ⊗[k] Ext k κ :=
+  ((CliffordAlgebra.equivOfIsometry (splitIsometry (k := k) (ι := ι) (κ := κ))).toLinearEquiv.trans
+    (CliffordAlgebra.prodEquiv (0 : QuadraticForm k (ι → k))
+      (0 : QuadraticForm k (κ → k))).toLinearEquiv).trans
+        (GradedTensorProduct.of k _ _).symm
+
+@[simp] theorem sumEquiv_symm_tmul (x : Ext k ι) (y : Ext k κ) :
+    (sumEquiv (k := k) (ι := ι) (κ := κ)).symm (x ⊗ₜ[k] y) =
+      ExteriorAlgebra.map leftVec x * ExteriorAlgebra.map rightVec y := by
+  change (CliffordAlgebra.equivOfIsometry splitIsometry).symm
+    (CliffordAlgebra.toProd _ _ (GradedTensorProduct.of k _ _ (x ⊗ₜ[k] y))) = _
+  rw [CliffordAlgebra.toProd, GradedTensorProduct.lift_tmul, map_mul]
+  congr 1
+  · have h : ((CliffordAlgebra.equivOfIsometry
+          (splitIsometry (k := k) (ι := ι) (κ := κ))).symm.toAlgHom).comp
+          (CliffordAlgebra.map (QuadraticMap.Isometry.inl _ _)) =
+        ExteriorAlgebra.map leftVec := by
+      ext v
+      simp [CliffordAlgebra.equivOfIsometry, splitIsometry, leftVec]; rfl
+    exact AlgHom.congr_fun h x
+  · have h : ((CliffordAlgebra.equivOfIsometry
+          (splitIsometry (k := k) (ι := ι) (κ := κ))).symm.toAlgHom).comp
+          (CliffordAlgebra.map (QuadraticMap.Isometry.inr _ _)) =
+        ExteriorAlgebra.map rightVec := by
+      ext v
+      simp [CliffordAlgebra.equivOfIsometry, splitIsometry, rightVec]; rfl
+    exact AlgHom.congr_fun h y
+
+end BoundaryOnly.FormalObstruction.ExteriorSplit
+
+end
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/FrobeniusObstruction/FixedResidue.lean b/lean/OAI/Algebra/FrobeniusObstruction/FixedResidue.lean
new file mode 100644
index 0000000000000000000000000000000000000000..94564d1ef1f104c08ba332cbb8e68753b5ad08e7
--- /dev/null
+++ b/lean/OAI/Algebra/FrobeniusObstruction/FixedResidue.lean
@@ -0,0 +1,151 @@
+import Mathlib
+import OAI.Algebra.FrobeniusObstruction.BlockTensor
+import OAI.Algebra.FrobeniusObstruction.ResiduePairing
+import OAI.Algebra.FrobeniusObstruction.NormalPrimitives
+
+namespace OAI
+
+noncomputable section
+open scoped BigOperators
+
+namespace BoundaryOnly.FormalObstruction.MixedForms
+open scoped TensorProduct
+variable {k A ι : Type*} [CommRing k] [CommRing A] [Algebra k A]
+theorem coeff_mul_tmul (a b : A) (x : Ext (k := k) (ι := ι)) :
+    coeff a * (b ⊗ₜ[k] x) = (a*b) ⊗ₜ[k] x := by
+  simp only [coeff_apply, Algebra.TensorProduct.tmul_mul_tmul, one_mul]
+end BoundaryOnly.FormalObstruction.MixedForms
+
+namespace BoundaryOnly.FormalObstruction.FixedResidue
+open Frobenius MixedForms
+open scoped TensorProduct
+variable {ι k : Type*} [Fintype ι] [DecidableEq ι] [Field k]
+variable (ell : ℕ) (hell : 0 < ell)
+
+abbrev Scalar := Frobenius.Ring (ι := ι) (k := k) ell
+abbrev BScalar := Frobenius.Ring (ι := ι) (k := ThreeParameters.Ring k) ell
+
+                                                                             
+                                                                                
+def scalar (v : Ext (k := k) (ι := ι) →ₗ[k] k) :
+    Forms (k := k) (A := Scalar (ι := ι) (k := k) ell) (ι := ι) →ₗ[k] k :=
+  (TensorProduct.lid k k).toLinearMap.comp
+    (TensorProduct.map (quotientCoeff ell (topExponent ell) (topExponent_good hell)) v)
+
+def parameter (v : Ext (k := k) (ι := ι) →ₗ[k] k) :
+    Forms (k := k) (A := BScalar (ι := ι) (k := k) ell) (ι := ι) →ₗ[k] ThreeParameters.Ring k :=
+  (TensorProduct.rid k (ThreeParameters.Ring k)).toLinearMap.comp
+    (TensorProduct.map
+      ((quotientCoeff (ι := ι) (k := ThreeParameters.Ring k) ell
+        (topExponent ell) (topExponent_good hell)).restrictScalars k) v)
+
+omit [DecidableEq ι] in
+@[simp] theorem scalar_tmul (v : Ext (k := k) (ι := ι) →ₗ[k] k)
+    (a : Scalar (ι := ι) (k := k) ell) (x : Ext (k := k) (ι := ι)) :
+    scalar ell hell v (a ⊗ₜ[k] x) =
+      quotientCoeff ell (topExponent ell) (topExponent_good hell) a * v x := rfl
+
+omit [DecidableEq ι] in
+@[simp] theorem parameter_tmul (v : Ext (k := k) (ι := ι) →ₗ[k] k)
+    (a : BScalar (ι := ι) (k := k) ell) (x : Ext (k := k) (ι := ι)) :
+    parameter ell hell v (a ⊗ₜ[k] x) =
+      (v x) • quotientCoeff ell (topExponent ell) (topExponent_good hell) a := rfl
+
+omit [DecidableEq ι] in
+theorem parameter_coeff_mul (v : Ext (k := k) (ι := ι) →ₗ[k] k)
+    (b : ThreeParameters.Ring k)
+    (x : Forms (k := k) (A := BScalar (ι := ι) (k := k) ell) (ι := ι)) :
+    parameter ell hell v (coeff (@algebraMap (ThreeParameters.Ring k)
+      (BScalar (ι := ι) (k := k) ell) inferInstance inferInstance inferInstance b) * x) = b * parameter ell hell v x := by
+  induction x using TensorProduct.inductionOn with
+  | add x y hx hy => simp only [mul_add, map_add, hx, hy]
+  | tmul a x =>
+    rw [coeff_mul_tmul, parameter_tmul, parameter_tmul]
+    rw [← Algebra.smul_def, map_smul]
+    exact smul_comm (v x) b _
+
+omit [DecidableEq ι] in
+theorem topCoeff_reduction (x : BScalar (ι := ι) (k := k) ell) :
+    ThreeParameters.augmentation k
+      (quotientCoeff ell (topExponent ell) (topExponent_good hell) x) =
+      quotientCoeff ell (topExponent ell) (topExponent_good hell) (reduction ell x) := by
+  induction x using Quotient.inductionOn with
+  | h f =>
+    change ThreeParameters.augmentation k (MvPowerSeries.coeff (topExponent ell) f) =
+      MvPowerSeries.coeff (topExponent ell)
+        (MvPowerSeries.map (ThreeParameters.augmentation k) f)
+    simp only [MvPowerSeries.coeff_map]
+
+omit [DecidableEq ι] in
+theorem reduction_parameter (v : Ext (k := k) (ι := ι) →ₗ[k] k)
+    (x : Forms (k := k) (A := BScalar (ι := ι) (k := k) ell) (ι := ι)) :
+    ThreeParameters.augmentation k (parameter ell hell v x) =
+      scalar ell hell v (coefficientMap (reduction ell) x) := by
+  induction x using TensorProduct.inductionOn with
+  | add x y hx hy => simp only [map_add, hx, hy]
+  | tmul a x =>
+    rw [parameter_tmul, coefficientMap_tmul, scalar_tmul]
+    let f : ThreeParameters.Ring k →ₐ[k] k :=
+      { ThreeParameters.augmentation k with
+        commutes' := ThreeParameters.augmentation_algebraMap k }
+    have hs := f.toLinearMap.map_smul (v x)
+      (quotientCoeff ell (topExponent ell) (topExponent_good hell) a)
+    change ThreeParameters.augmentation k (v x • _) =
+      v x • ThreeParameters.augmentation k (quotientCoeff ell (topExponent ell)
+        (topExponent_good hell) a) at hs
+    rw [hs, topCoeff_reduction ell hell]
+    exact mul_comm _ _
+
+ theorem mul_delta_of_cycle {A : Type*} [CommRing A] [Algebra k A]
+    (pd : ι → Derivation k A A) (F : A)
+    (x y : Forms (k := k) (A := A) (ι := ι)) (hy : delta pd F y = 0) :
+    delta pd F x * y = 0 := by
+  rw [delta_apply, gradient_supercommute, mul_assoc, ← delta_apply, hy, mul_zero]
+
+omit [DecidableEq ι] in
+theorem parameter_pair_isUnit
+    (v : Ext (k := k) (ι := ι) →ₗ[k] k)
+    (x : Forms (k := k) (A := BScalar (ι := ι) (k := k) ell) (ι := ι))
+    (hx : scalar ell hell v (coefficientMap (reduction ell) x) ≠ 0) :
+    IsUnit (parameter ell hell v x) := by
+  apply ThreeParameters.isUnit_of_augmentation_ne_zero k
+  rwa [reduction_parameter ell hell v]
+
+theorem residue_zero_of_w_boundary
+    (v : Ext (k := k) (ι := ι) →ₗ[k] k)
+    (pd : ι → Derivation k (BScalar (ι := ι) (k := k) ell)
+      (BScalar (ι := ι) (k := k) ell)) (F : BScalar (ι := ι) (k := k) ell)
+    (alpha beta eta : Forms (k := k) (A := BScalar (ι := ι) (k := k) ell) (ι := ι))
+    (hbeta : delta pd F beta = 0)
+    (heta : delta pd F eta =
+      coeff (@algebraMap (ThreeParameters.Ring k) (BScalar (ι := ι) (k := k) ell)
+        inferInstance inferInstance inferInstance (ThreeParameters.w k)) * alpha) :
+    ThreeParameters.w k * parameter ell hell v (alpha * beta) = 0 := by
+  have hz : delta pd F eta * beta = 0 := by
+    rw [delta_apply, gradient_supercommute, mul_assoc, ← delta_apply, hbeta, mul_zero]
+  rw [heta, mul_assoc] at hz
+  have hr := congrArg (parameter ell hell v) hz
+  rw [parameter_coeff_mul ell hell v, map_zero] at hr
+  exact hr
+
+                                                                          
+                                                                        
+theorem unit_residue_contradiction
+    (v : Ext (k := k) (ι := ι) →ₗ[k] k)
+    (pd : ι → Derivation k (BScalar (ι := ι) (k := k) ell)
+      (BScalar (ι := ι) (k := k) ell)) (F : BScalar (ι := ι) (k := k) ell)
+    (alpha beta eta : Forms (k := k) (A := BScalar (ι := ι) (k := k) ell) (ι := ι))
+    (hbeta : delta pd F beta = 0)
+    (heta : delta pd F eta =
+      coeff (@algebraMap (ThreeParameters.Ring k) (BScalar (ι := ι) (k := k) ell)
+        inferInstance inferInstance inferInstance (ThreeParameters.w k)) * alpha)
+    (hpair : scalar ell hell v (coefficientMap (reduction ell) (alpha * beta)) ≠ 0) : False := by
+  have hu := parameter_pair_isUnit ell hell v (alpha * beta) hpair
+  have hz := residue_zero_of_w_boundary ell hell v pd F alpha beta eta hbeta heta
+  exact ThreeParameters.w_ne_zero k ((hu.mul_left_eq_zero).mp hz)
+
+end BoundaryOnly.FormalObstruction.FixedResidue
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/FrobeniusObstruction/FormTensor.lean b/lean/OAI/Algebra/FrobeniusObstruction/FormTensor.lean
new file mode 100644
index 0000000000000000000000000000000000000000..682bd35f0777c855d7d5c8077450e0daa4103708
--- /dev/null
+++ b/lean/OAI/Algebra/FrobeniusObstruction/FormTensor.lean
@@ -0,0 +1,266 @@
+import Mathlib
+import OAI.Algebra.FrobeniusObstruction.MixedForms
+import OAI.Algebra.FrobeniusObstruction.ExteriorSplit
+import OAI.Algebra.FrobeniusObstruction.Derivations
+
+namespace OAI
+
+noncomputable section
+open scoped BigOperators
+
+namespace BoundaryOnly.FormalObstruction.FormsSplit
+open scoped TensorProduct
+open Frobenius MixedForms
+variable {ι κ k : Type*} [Fintype ι] [Fintype κ] [DecidableEq ι] [DecidableEq κ]
+  [CommRing k] (ell : ℕ)
+
+abbrev QForms (ι : Type*) [Fintype ι] [DecidableEq ι] :=
+  MixedForms.Forms (k := k) (A := Frobenius.Ring (ι := ι) (k := k) ell) (ι := ι)
+
+noncomputable def includeLeft : QForms (k := k) ell ι →ₐ[k] QForms (k := k) ell (ι ⊕ κ) :=
+  Algebra.TensorProduct.map (includeVariables ell Sum.inl)
+    (ExteriorAlgebra.map ExteriorSplit.leftVec)
+noncomputable def includeRight : QForms (k := k) ell κ →ₐ[k] QForms (k := k) ell (ι ⊕ κ) :=
+  Algebra.TensorProduct.map (includeVariables ell Sum.inr)
+    (ExteriorAlgebra.map ExteriorSplit.rightVec)
+
+                                                                            
+                                                                               
+noncomputable def sumEquiv : QForms (k := k) ell (ι ⊕ κ) ≃ₗ[k]
+    QForms (k := k) ell ι ⊗[k] QForms (k := k) ell κ :=
+  (TensorProduct.congr (Frobenius.sumEquiv (k := k) (ι := ι) (κ := κ) ell).toLinearEquiv
+      (ExteriorSplit.sumEquiv (k := k) (ι := ι) (κ := κ))).trans
+    (TensorProduct.tensorTensorTensorComm k _ _ _ _)
+
+@[simp] theorem sumEquiv_symm_tmul (x : QForms (k := k) ell ι)
+    (y : QForms (k := k) ell κ) :
+    (sumEquiv (k := k) (ι := ι) (κ := κ) ell).symm (x ⊗ₜ[k] y) =
+      includeLeft ell x * includeRight ell y := by
+  induction x using TensorProduct.inductionOn with
+  | add x x' hx hx' => simp only [TensorProduct.add_tmul, map_add, add_mul, hx, hx']
+  | tmul a e =>
+    induction y using TensorProduct.inductionOn with
+    | add y y' hy hy' => simp only [TensorProduct.tmul_add, map_add, mul_add, hy, hy']
+    | tmul b f =>
+      change (TensorProduct.congr
+        (Frobenius.sumEquiv (k := k) (ι := ι) (κ := κ) ell).toLinearEquiv
+        (ExteriorSplit.sumEquiv (k := k) (ι := ι) (κ := κ))).symm
+          ((TensorProduct.tensorTensorTensorComm k _ _ _ _).symm
+            ((a ⊗ₜ[k] e) ⊗ₜ[k] (b ⊗ₜ[k] f))) = _
+      rw [TensorProduct.tensorTensorTensorComm_symm, TensorProduct.tensorTensorTensorComm_tmul, TensorProduct.congr_symm,
+        TensorProduct.congr_tmul, ExteriorSplit.sumEquiv_symm_tmul]
+      change merge (k := k) (ι := ι) (κ := κ) ell (a ⊗ₜ[k] b) ⊗ₜ[k]
+        (ExteriorAlgebra.map ExteriorSplit.leftVec e * ExteriorAlgebra.map ExteriorSplit.rightVec f) = _
+      rw [merge_tmul]
+      simp only [includeLeft, includeRight, Algebra.TensorProduct.map_tmul,
+        Algebra.TensorProduct.tmul_mul_tmul]
+
+omit [Fintype ι] [Fintype κ] in
+@[simp] theorem exterior_left_gen (i : ι) :
+    ExteriorAlgebra.map (ExteriorSplit.leftVec (k := k) (κ := κ)) (gen i) =
+      gen (Sum.inl i : ι ⊕ κ) := by
+  rw [gen, ExteriorAlgebra.map_apply_ι]
+  congr 1
+  funext j
+  cases j <;> simp [ExteriorSplit.leftVec, Pi.single_apply]
+
+omit [Fintype ι] [Fintype κ] in
+@[simp] theorem exterior_right_gen (i : κ) :
+    ExteriorAlgebra.map (ExteriorSplit.rightVec (k := k) (ι := ι)) (gen i) =
+      gen (Sum.inr i : ι ⊕ κ) := by
+  rw [gen, ExteriorAlgebra.map_apply_ι]
+  congr 1
+  funext j
+  cases j <;> simp [ExteriorSplit.rightVec, Pi.single_apply]
+
+ theorem involute_map {V W : Type*} [AddCommGroup V] [AddCommGroup W]
+    [Module k V] [Module k W] (f : V →ₗ[k] W) (e : ExteriorAlgebra k V) :
+    CliffordAlgebra.involute (ExteriorAlgebra.map f e) =
+      ExteriorAlgebra.map f (CliffordAlgebra.involute e) := by
+  have h : (CliffordAlgebra.involute : ExteriorAlgebra k W →ₐ[k] _).comp
+      (ExteriorAlgebra.map f) = (ExteriorAlgebra.map f).comp CliffordAlgebra.involute := by
+    ext v
+    simp
+  exact AlgHom.congr_fun h e
+
+@[simp] theorem parity_includeLeft (x : QForms (k := k) ell ι) :
+    parity (includeLeft (κ := κ) ell x) = includeLeft ell (parity x) := by
+  induction x using TensorProduct.inductionOn with
+  | add x y hx hy => simp only [map_add, hx, hy]
+  | tmul a e => simp only [includeLeft, Algebra.TensorProduct.map_tmul, parity_tmul,
+      involute_map]
+
+@[simp] theorem parity_includeRight (x : QForms (k := k) ell κ) :
+    parity (includeRight (ι := ι) ell x) = includeRight ell (parity x) := by
+  induction x using TensorProduct.inductionOn with
+  | add x y hx hy => simp only [map_add, hx, hy]
+  | tmul a e => simp only [includeRight, Algebra.TensorProduct.map_tmul, parity_tmul,
+      involute_map]
+
+variable [CharP k ell]
+
+@[simp] theorem d_includeLeft (x : QForms (k := k) ell ι) :
+    d (partialDeriv ell) (includeLeft (κ := κ) ell x) =
+      includeLeft ell (d (partialDeriv ell) x) := by
+  induction x using TensorProduct.inductionOn with
+  | add x y hx hy => simp only [map_add, hx, hy]
+  | tmul a e =>
+    simp only [includeLeft, Algebra.TensorProduct.map_tmul, d_tmul,
+      Fintype.sum_sum_type, partial_include_left, partial_include_left_other,
+      TensorProduct.zero_tmul, Finset.sum_const_zero, add_zero, map_sum, map_mul,
+      exterior_left_gen]
+
+@[simp] theorem d_includeRight (x : QForms (k := k) ell κ) :
+    d (partialDeriv ell) (includeRight (ι := ι) ell x) =
+      includeRight ell (d (partialDeriv ell) x) := by
+  induction x using TensorProduct.inductionOn with
+  | add x y hx hy => simp only [map_add, hx, hy]
+  | tmul a e =>
+    simp only [includeRight, Algebra.TensorProduct.map_tmul, d_tmul,
+      Fintype.sum_sum_type, partial_include_right, partial_include_right_other,
+      TensorProduct.zero_tmul, Finset.sum_const_zero, zero_add, map_sum, map_mul,
+      exterior_right_gen]
+
+omit [CharP k ell] in
+@[simp] theorem includeLeft_coeff (a : Ring (ι := ι) (k := k) ell) :
+    includeLeft (κ := κ) ell (coeff a) = coeff (includeVariables ell Sum.inl a) := by
+  simp only [includeLeft, coeff_apply, Algebra.TensorProduct.map_tmul, map_one]
+omit [CharP k ell] in
+@[simp] theorem includeRight_coeff (a : Ring (ι := κ) (k := k) ell) :
+    includeRight (ι := ι) ell (coeff a) = coeff (includeVariables ell Sum.inr a) := by
+  simp only [includeRight, coeff_apply, Algebra.TensorProduct.map_tmul, map_one]
+
+@[simp] theorem gradient_include_left (a : Ring (ι := ι) (k := k) ell) :
+    gradient (partialDeriv ell) (includeVariables ell (Sum.inl : ι → ι ⊕ κ) a) =
+      includeLeft ell (gradient (partialDeriv ell) a) := by
+  change d (partialDeriv ell) (coeff (includeVariables ell Sum.inl a)) = _
+  rw [← includeLeft_coeff, d_includeLeft, d_coeff]
+
+@[simp] theorem gradient_include_right (a : Ring (ι := κ) (k := k) ell) :
+    gradient (partialDeriv ell) (includeVariables ell (Sum.inr : κ → ι ⊕ κ) a) =
+      includeRight ell (gradient (partialDeriv ell) a) := by
+  change d (partialDeriv ell) (coeff (includeVariables ell Sum.inr a)) = _
+  rw [← includeRight_coeff, d_includeRight, d_coeff]
+
+theorem gradient_add {A : Type*} [CommRing A] [Algebra k A]
+    (pd : ι → Derivation k A A) (a b : A) :
+    gradient pd (a + b) = gradient pd a + gradient pd b := by
+  simp only [MixedForms.gradient, TensorProduct.add_tmul, map_add]
+
+                                                                           
+                                                                        
+theorem delta_product (Q : Ring (ι := ι) (k := k) ell)
+    (R : Ring (ι := κ) (k := k) ell) (x : QForms (k := k) ell ι)
+    (y : QForms (k := k) ell κ) :
+    delta (partialDeriv ell) (includeVariables ell Sum.inl Q + includeVariables ell Sum.inr R)
+      (includeLeft ell x * includeRight ell y) =
+        includeLeft ell (delta (partialDeriv ell) Q x) * includeRight ell y +
+          includeLeft ell (parity x) * includeRight ell (delta (partialDeriv ell) R y) := by
+  rw [delta_apply, gradient_add, gradient_include_left, gradient_include_right, add_mul]
+  congr 1
+  · rw [delta_apply, map_mul, mul_assoc]
+  · rw [← gradient_include_right, ← mul_assoc, gradient_supercommute, parity_includeLeft,
+      mul_assoc, delta_apply, map_mul, gradient_include_right]
+
+end BoundaryOnly.FormalObstruction.FormsSplit
+
+namespace BoundaryOnly.FormalObstruction.GlobalForms
+open Frobenius MixedForms
+open scoped TensorProduct
+variable {k : Type*} [CommRing k]
+
+                                                                         
+abbrev Coordinates : (n : ℕ) → (Fin n → Type) → Type
+  | 0, _ => PEmpty
+  | n + 1, V => V 0 ⊕ Coordinates n (fun i => V i.succ)
+
+instance coordinatesFintype : ∀ (n : ℕ) (V : Fin n → Type) [∀ i, Fintype (V i)],
+    Fintype (Coordinates n V)
+  | 0, _, _ => inferInstanceAs (Fintype PEmpty)
+  | n + 1, V, _ => by
+      letI := coordinatesFintype n (fun i => V i.succ)
+      exact inferInstanceAs (Fintype (V 0 ⊕ Coordinates n (fun i => V i.succ)))
+
+instance coordinatesDecidableEq : ∀ (n : ℕ) (V : Fin n → Type) [∀ i, DecidableEq (V i)],
+    DecidableEq (Coordinates n V)
+  | 0, _, _ => inferInstanceAs (DecidableEq PEmpty)
+  | n + 1, V, _ => by
+      letI := coordinatesDecidableEq n (fun i => V i.succ)
+      exact inferInstanceAs (DecidableEq (V 0 ⊕ Coordinates n (fun i => V i.succ)))
+
+abbrev consIndex (n : ℕ) : Unit ⊕ Fin n ≃ Fin (n + 1) where
+  toFun := Sum.elim (fun _ => 0) Fin.succ
+  invFun := Fin.cases (Sum.inl ()) Sum.inr
+  left_inv := by intro i; cases i with
+    | inl u => cases u; rfl
+    | inr i => rfl
+  right_inv := by intro i; refine Fin.cases ?_ (fun j => ?_) i <;> rfl
+
+@[simp] theorem consIndex_zero (n : ℕ) : consIndex n (.inl ()) = 0 := rfl
+@[simp] theorem consIndex_succ (n : ℕ) (i : Fin n) : consIndex n (.inr i) = i.succ := rfl
+
+                                                                                  
+def tensorCons {n : ℕ} (V : Fin (n + 1) → Type*) [∀ i, AddCommGroup (V i)]
+    [∀ i, Module k (V i)] : (⨂[k] i, V i) ≃ₗ[k] V 0 ⊗[k] (⨂[k] i : Fin n, V i.succ) :=
+  ((PiTensorProduct.reindex k V (consIndex n).symm).trans
+    (PiTensorProduct.tmulEquivDep k (fun j => V (consIndex n j))).symm).trans
+      (TensorProduct.congr (PiTensorProduct.subsingletonEquiv ()) (LinearEquiv.refl _ _))
+
+@[simp] theorem tensorCons_tprod {n : ℕ} (V : Fin (n + 1) → Type*)
+    [∀ i, AddCommGroup (V i)] [∀ i, Module k (V i)] (v : ∀ i, V i) :
+    tensorCons (k := k) V (PiTensorProduct.tprod k v) =
+      v 0 ⊗ₜ[k] PiTensorProduct.tprod k (fun i : Fin n => v i.succ) := by
+  simp only [tensorCons, LinearEquiv.trans_apply, PiTensorProduct.reindex_tprod,
+    PiTensorProduct.tmulEquivDep_symm_apply, Equiv.symm_symm]
+  change (TensorProduct.congr
+      (PiTensorProduct.subsingletonEquiv (R := k) (s := fun _ : Unit => V 0) ())
+      (LinearEquiv.refl k (⨂[k] i : Fin n, V i.succ)))
+      ((PiTensorProduct.tprod k (fun _ : Unit => v 0)) ⊗ₜ[k]
+        PiTensorProduct.tprod k (fun i : Fin n => v i.succ)) = _
+  rw [TensorProduct.congr_tmul, PiTensorProduct.subsingletonEquiv_apply_tprod]
+  rfl
+
+def emptyCoefficients (ell : ℕ) (hell : 0 < ell) :
+    Ring (ι := PEmpty) (k := k) ell ≃ₐ[k] k :=
+  AlgEquiv.ofAlgHom
+    { constantHom ell hell with commutes' := constantHom_algebraMap ell hell }
+    (Algebra.ofId k _)
+    (by ext)
+    (by apply algHom_ext; intro i; exact PEmpty.elim i)
+
+def emptyExterior : ExteriorAlgebra k (PEmpty.{1} → k) ≃ₐ[k] k :=
+  AlgEquiv.ofAlgHom (ExteriorAlgebra.lift k ⟨0, by simp⟩) (Algebra.ofId k _)
+    (by ext)
+    (by apply ExteriorAlgebra.hom_ext
+        apply LinearMap.ext
+        intro v
+        have hv : v = 0 := Subsingleton.elim _ _
+        rw [hv]
+        simp only [LinearMap.comp_apply, AlgHom.toLinearMap_apply]
+        rw [show (ExteriorAlgebra.ι k) (0 : PEmpty.{1} → k) = 0 from
+          (ExteriorAlgebra.ι k).map_zero]
+        simp)
+
+abbrev QForms (ell : ℕ) (ι : Type) [Fintype ι] [DecidableEq ι] :=
+  MixedForms.Forms (k := k) (A := Ring (ι := ι) (k := k) ell) (ι := ι)
+
+def emptyForms (ell : ℕ) (hell : 0 < ell) : QForms (k := k) ell PEmpty ≃ₗ[k] k :=
+  (TensorProduct.congr (emptyCoefficients (k := k) ell hell).toLinearEquiv
+    (emptyExterior (k := k)).toLinearEquiv).trans (TensorProduct.lid k k)
+
+                                                                             
+noncomputable def blockEquiv (ell : ℕ) (hell : 0 < ell) :
+    ∀ (n : ℕ) (V : Fin n → Type) [∀ i, Fintype (V i)] [∀ i, DecidableEq (V i)],
+      QForms (k := k) ell (Coordinates n V) ≃ₗ[k] (⨂[k] i, QForms (k := k) ell (V i))
+  | 0, _, _, _ => (emptyForms ell hell).trans (PiTensorProduct.isEmptyEquiv (Fin 0)).symm
+  | n + 1, V, _, _ =>
+    ((FormsSplit.sumEquiv (k := k) (ι := V 0) (κ := Coordinates n (fun i => V i.succ)) ell).trans
+      (TensorProduct.congr (LinearEquiv.refl k (QForms (k := k) ell (V 0)))
+        (blockEquiv ell hell n (fun i => V i.succ)))).trans
+          (tensorCons (k := k) (fun i => QForms (k := k) ell (V i))).symm
+
+end BoundaryOnly.FormalObstruction.GlobalForms
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/FrobeniusObstruction/FormalData.lean b/lean/OAI/Algebra/FrobeniusObstruction/FormalData.lean
new file mode 100644
index 0000000000000000000000000000000000000000..2022a190d13b9d2be6ce7c36f0a6762ea29b6d90
--- /dev/null
+++ b/lean/OAI/Algebra/FrobeniusObstruction/FormalData.lean
@@ -0,0 +1,98 @@
+import Mathlib
+import OAI.Algebra.FrobeniusObstruction.LinearChange
+
+namespace OAI
+
+noncomputable section
+open scoped BigOperators
+
+namespace BoundaryOnly.FormalObstruction
+
+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*} [Field 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 : (complementaryMatrix n Y).det ≠ 0
+  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
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/FrobeniusObstruction/FrobeniusRing.lean b/lean/OAI/Algebra/FrobeniusObstruction/FrobeniusRing.lean
new file mode 100644
index 0000000000000000000000000000000000000000..87cc159a0f6dd47ec253069ea9bc204d0ae7e103
--- /dev/null
+++ b/lean/OAI/Algebra/FrobeniusObstruction/FrobeniusRing.lean
@@ -0,0 +1,494 @@
+import Mathlib
+
+namespace OAI
+
+noncomputable section
+open scoped BigOperators
+
+namespace BoundaryOnly.FormalObstruction
+namespace Frobenius
+
+variable {ι k : Type*} [Fintype ι] [DecidableEq ι] [CommRing k]
+
+abbrev Series := MvPowerSeries ι k
+
+def powerIdeal (ell : ℕ) : Ideal (Series (ι := ι) (k := k)) :=
+  Ideal.span (Set.range fun i : ι => (MvPowerSeries.X i : Series (ι := ι) (k := k))^ell)
+
+abbrev Ring (ell : ℕ) := Series (ι := ι) (k := k) ⧸ powerIdeal (ι := ι) (k := k) ell
+
+def Good (ell : ℕ) (e : ι →₀ ℕ) : Prop := ∀ i, e i < ell
+
+def cut (ell : ℕ) (s : Finset ι) (f : Series (ι := ι) (k := k)) : Series (ι := ι) (k := k) :=
+  fun e => if ∀ i ∈ s, e i < ell then MvPowerSeries.coeff e f else 0
+
+@[simp] theorem coeff_cut (ell : ℕ) (s : Finset ι) (f : Series (ι := ι) (k := k)) (e : ι →₀ ℕ) :
+    MvPowerSeries.coeff e (cut ell s f) =
+      if ∀ i ∈ s, e i < ell then MvPowerSeries.coeff e f else 0 := rfl
+
+@[simp] theorem cut_empty (ell : ℕ) (f : Series (ι := ι) (k := k)) :
+    cut ell ∅ f = f := by
+  ext e
+  simp
+
+                                                          
+def tail (ell : ℕ) (i : ι) (f : Series (ι := ι) (k := k)) : Series (ι := ι) (k := k) :=
+  fun e => MvPowerSeries.coeff (e + Finsupp.single i ell) f
+
+omit [Fintype ι] [DecidableEq ι] in
+@[simp] theorem coeff_tail (ell : ℕ) (i : ι) (f : Series (ι := ι) (k := k)) (e : ι →₀ ℕ) :
+    MvPowerSeries.coeff e (tail ell i f) =
+      MvPowerSeries.coeff (e + Finsupp.single i ell) f := rfl
+
+theorem one_coordinate_decomposition (ell : ℕ) (i : ι) (f : Series (ι := ι) (k := k)) :
+    f - cut ell {i} f = (MvPowerSeries.X i)^ell * tail ell i f := by
+  ext e
+  simp only [map_sub, coeff_cut, Finset.mem_singleton, forall_eq, MvPowerSeries.X_pow_eq,
+    MvPowerSeries.coeff_monomial_mul, one_mul, coeff_tail]
+  by_cases hi : ell ≤ e i
+  · rw [ite_eq_right (by omega), ite_eq_left (Finsupp.single_le_iff.mpr hi),
+      tsub_add_cancel_of_le (Finsupp.single_le_iff.mpr hi), sub_zero]
+  · rw [ite_eq_left (by omega), ite_eq_right (by simpa only [Finsupp.single_le_iff] using hi), sub_self]
+
+theorem cut_insert (ell : ℕ) (s : Finset ι) (i : ι) (f : Series (ι := ι) (k := k)) :
+    cut ell (insert i s) f = cut ell {i} (cut ell s f) := by
+  ext e
+  simp only [coeff_cut, Finset.mem_insert, forall_eq_or_imp, Finset.mem_singleton, forall_eq]
+  by_cases hi : e i < ell <;> by_cases hs : ∀ j ∈ s, e j < ell <;> simp [hi, hs]
+
+theorem subtract_cut_mem (ell : ℕ) (s : Finset ι) (f : Series (ι := ι) (k := k)) :
+    f - cut ell s f ∈ powerIdeal (ι := ι) (k := k) ell := by
+  induction s using Finset.induction_on with
+  | empty => simp
+  | @insert i s his ih =>
+      rw [cut_insert]
+      have htail : cut ell s f - cut ell {i} (cut ell s f) ∈ powerIdeal ell := by
+        rw [one_coordinate_decomposition]
+        exact Ideal.mul_mem_right _ _ (Ideal.subset_span ⟨i, rfl⟩)
+      convert (powerIdeal (ι := ι) (k := k) ell).add_mem ih htail using 1
+      abel
+
+omit [DecidableEq ι] in
+theorem coeff_ideal_eq_zero (ell : ℕ) (e : ι →₀ ℕ) (he : Good ell e)
+    (f : Series (ι := ι) (k := k)) (hf : f ∈ powerIdeal ell) :
+    MvPowerSeries.coeff e f = 0 := by
+  obtain ⟨c, rfl⟩ := Ideal.mem_span_range_iff_exists_fun.mp hf
+  rw [map_sum]
+  apply Finset.sum_eq_zero
+  intro i _
+  rw [MvPowerSeries.X_pow_eq, MvPowerSeries.coeff_mul_monomial]
+  exact ite_eq_right (by simpa only [Finsupp.single_le_iff, not_le] using he i)
+
+theorem mem_powerIdeal_iff (ell : ℕ) (f : Series (ι := ι) (k := k)) :
+    f ∈ powerIdeal ell ↔ ∀ e, Good ell e → MvPowerSeries.coeff e f = 0 := by
+  constructor
+  · exact fun hf e he => coeff_ideal_eq_zero ell e he f hf
+  · intro hf
+    have hc : cut ell Finset.univ f = 0 := by
+      ext e
+      simp only [coeff_cut, Finset.mem_univ, forall_const, map_zero]
+      split_ifs with he
+      · exact hf e he
+      · rfl
+    simpa only [hc, sub_zero] using subtract_cut_mem ell Finset.univ f
+
+                                                                            
+def quotientCoeff (ell : ℕ) (e : ι →₀ ℕ) (he : Good ell e) : Ring (ι := ι) (k := k) ell →ₗ[k] k :=
+  (powerIdeal (ι := ι) (k := k) ell).restrictScalars k |>.liftQ
+    (MvPowerSeries.coeff e) (by
+      intro f hf
+      exact coeff_ideal_eq_zero ell e he f hf)
+
+omit [DecidableEq ι] in
+@[simp] theorem quotientCoeff_mk (ell : ℕ) (e : ι →₀ ℕ) (he : Good ell e)
+    (f : Series (ι := ι) (k := k)) :
+    quotientCoeff ell e he (Ideal.Quotient.mk _ f) = MvPowerSeries.coeff e f := rfl
+
+theorem quotient_ext (ell : ℕ) (x y : Ring (ι := ι) (k := k) ell)
+    (h : ∀ e (he : Good ell e), quotientCoeff ell e he x = quotientCoeff ell e he y) : x = y := by
+  obtain ⟨f, rfl⟩ := Ideal.Quotient.mk_surjective x
+  obtain ⟨g, rfl⟩ := Ideal.Quotient.mk_surjective y
+  apply sub_eq_zero.mp
+  rw [← map_sub, Ideal.Quotient.eq_zero_iff_mem, mem_powerIdeal_iff]
+  intro e he
+  simpa only [map_sub, sub_eq_zero, quotientCoeff_mk] using h e he
+
+                                                   
+abbrev Box (ell : ℕ) := ι → Fin ell
+
+def exponent (ell : ℕ) (v : Box (ι := ι) ell) : ι →₀ ℕ :=
+  Finsupp.equivFunOnFinite.symm (fun i => (v i).val)
+
+omit [DecidableEq ι] in
+@[simp] theorem exponent_apply (ell : ℕ) (v : Box (ι := ι) ell) (i : ι) :
+    exponent ell v i = (v i).val := by simp [exponent]
+
+omit [DecidableEq ι] in
+theorem exponent_good (ell : ℕ) (v : Box (ι := ι) ell) : Good ell (exponent ell v) := by
+  intro i
+  simpa only [exponent_apply] using (v i).isLt
+
+omit [DecidableEq ι] in
+theorem exponent_injective (ell : ℕ) : Function.Injective (exponent (ι := ι) ell) := by
+  intro v w h
+  funext i
+  apply Fin.ext
+  have := DFunLike.congr_fun h i
+  simpa only [exponent_apply] using this
+
+def boxOfGood (ell : ℕ) (e : ι →₀ ℕ) (he : Good ell e) : Box (ι := ι) ell :=
+  fun i => ⟨e i, he i⟩
+
+omit [DecidableEq ι] in
+@[simp] theorem exponent_boxOfGood (ell : ℕ) (e : ι →₀ ℕ) (he : Good ell e) :
+    exponent ell (boxOfGood ell e he) = e := by
+  ext i
+  simp [boxOfGood]
+
+                                                     
+def monomial (ell : ℕ) (v : Box (ι := ι) ell) : Ring (ι := ι) (k := k) ell :=
+  Ideal.Quotient.mk _ (MvPowerSeries.monomial (exponent ell v) 1)
+
+@[simp] theorem quotientCoeff_monomial (ell : ℕ) (v w : Box (ι := ι) ell) :
+    quotientCoeff ell (exponent ell v) (exponent_good ell v) (monomial (k := k) ell w) =
+      if v = w then 1 else 0 := by
+  rw [monomial, quotientCoeff_mk, MvPowerSeries.coeff_monomial]
+  simp only [(exponent_injective ell).eq_iff]
+
+def coefficients (ell : ℕ) : Ring (ι := ι) (k := k) ell →ₗ[k] (Box (ι := ι) ell → k) :=
+  LinearMap.pi fun v => quotientCoeff ell (exponent ell v) (exponent_good ell v)
+
+omit [DecidableEq ι] in
+@[simp] theorem coefficients_apply (ell : ℕ) (x : Ring (ι := ι) (k := k) ell)
+    (v : Box (ι := ι) ell) : coefficients ell x v =
+      quotientCoeff ell (exponent ell v) (exponent_good ell v) x := rfl
+
+theorem coefficients_injective (ell : ℕ) :
+    Function.Injective (coefficients (ι := ι) (k := k) ell) := by
+  intro x y h
+  apply quotient_ext
+  intro e he
+  have hh := congrFun h (boxOfGood ell e he)
+  simpa only [coefficients_apply, exponent_boxOfGood] using hh
+
+def fromCoefficients (ell : ℕ) (c : Box (ι := ι) ell → k) : Ring (ι := ι) (k := k) ell :=
+  ∑ v, c v • monomial ell v
+
+@[simp] theorem coefficients_fromCoefficients (ell : ℕ) (c : Box (ι := ι) ell → k) :
+    coefficients ell (fromCoefficients ell c) = c := by
+  funext v
+  simp [fromCoefficients]
+
+                                                                                 
+def coefficientEquiv (ell : ℕ) :
+    Ring (ι := ι) (k := k) ell ≃ₗ[k] (Box (ι := ι) ell → k) :=
+  LinearEquiv.ofBijective (coefficients ell)
+    ⟨coefficients_injective ell, fun c => ⟨fromCoefficients ell c, coefficients_fromCoefficients ell c⟩⟩
+
+instance moduleFinite_quotient (ell : ℕ) : Module.Finite k (Ring (ι := ι) (k := k) ell) :=
+  Module.Finite.equiv (coefficientEquiv (ι := ι) (k := k) ell).symm
+
+instance moduleFree_quotient (ell : ℕ) : Module.Free k (Ring (ι := ι) (k := k) ell) :=
+  Module.Free.of_equiv (coefficientEquiv (ι := ι) (k := k) ell).symm
+
+theorem monomial_expansion (ell : ℕ) (x : Ring (ι := ι) (k := k) ell) :
+    x = ∑ v, coefficients ell x v • monomial ell v := by
+  apply coefficients_injective ell
+  exact (coefficients_fromCoefficients ell _).symm
+
+def topExponent (ell : ℕ) : ι →₀ ℕ :=
+  Finsupp.equivFunOnFinite.symm (fun _ => ell - 1)
+
+omit [DecidableEq ι] in
+@[simp] theorem topExponent_apply (ell : ℕ) (i : ι) :
+    topExponent (ι := ι) ell i = ell - 1 := by simp [topExponent]
+
+omit [DecidableEq ι] in
+theorem topExponent_good {ell : ℕ} (hell : 0 < ell) : Good ell (topExponent (ι := ι) ell) := by
+  intro i
+  simp only [topExponent_apply]
+  omega
+
+omit [DecidableEq ι] in
+theorem good_le_top {ell : ℕ} (e : ι →₀ ℕ) (he : Good ell e) : e ≤ topExponent ell := by
+  intro i
+  simp only [topExponent_apply]
+  have := he i
+  omega
+
+                                                                                
+def topMonomial (ell : ℕ) : Ring (ι := ι) (k := k) ell :=
+  Ideal.Quotient.mk _ (MvPowerSeries.monomial (topExponent ell) 1)
+
+omit [DecidableEq ι] in
+@[simp] theorem topMonomial_coefficient {ell : ℕ} (hell : 0 < ell) :
+    quotientCoeff ell (topExponent ell) (topExponent_good hell)
+      (topMonomial (ι := ι) (k := k) ell) = 1 := by
+  simp [topMonomial]
+
+omit [DecidableEq ι] in
+theorem topMonomial_ne_zero [Nontrivial k] {ell : ℕ} (hell : 0 < ell) :
+    topMonomial (ι := ι) (k := k) ell ≠ 0 := by
+  intro h
+  have hc := topMonomial_coefficient (ι := ι) (k := k) hell
+  rw [h, map_zero] at hc
+  exact zero_ne_one hc
+
+def constantHom (ell : ℕ) (hell : 0 < ell) : Ring (ι := ι) (k := k) ell →+* k :=
+  Ideal.Quotient.lift _ MvPowerSeries.constantCoeff (by
+    intro f hf
+    exact coeff_ideal_eq_zero ell 0 (fun i => by simpa using hell) f hf)
+
+omit [DecidableEq ι] in
+@[simp] theorem constantHom_mk (ell : ℕ) (hell : 0 < ell) (f : Series (ι := ι) (k := k)) :
+    constantHom ell hell (Ideal.Quotient.mk _ f) = MvPowerSeries.constantCoeff f := rfl
+
+theorem topMonomial_mul {ell : ℕ} (hell : 0 < ell) (x : Ring (ι := ι) (k := k) ell) :
+    topMonomial ell * x = constantHom ell hell x • topMonomial ell := by
+  obtain ⟨f, rfl⟩ := Ideal.Quotient.mk_surjective x
+  apply quotient_ext
+  intro e he
+  rw [map_smul, constantHom_mk]
+  change quotientCoeff ell e he
+    (Ideal.Quotient.mk _ (MvPowerSeries.monomial (topExponent ell) 1) *
+      Ideal.Quotient.mk _ f) = _
+  rw [← map_mul, quotientCoeff_mk, MvPowerSeries.coeff_monomial_mul]
+  rw [topMonomial, quotientCoeff_mk, MvPowerSeries.coeff_monomial]
+  by_cases ht : e = topExponent ell
+  · subst e
+    simp only [le_refl, ite_true, tsub_self, one_mul, smul_eq_mul, mul_one]
+    rfl
+  · have hnot : ¬ topExponent ell ≤ e := fun h => ht (le_antisymm (good_le_top e he) h)
+    simp [hnot, ht]
+
+omit [DecidableEq ι] in
+@[simp] theorem constantHom_algebraMap (ell : ℕ) (hell : 0 < ell) (a : k) :
+    constantHom (ι := ι) ell hell (algebraMap k (Ring (ι := ι) (k := k) ell) a) = a := by
+  rw [← Ideal.Quotient.mk_algebraMap k (powerIdeal (ι := ι) (k := k) ell),
+    constantHom_mk, ← MvPowerSeries.c_eq_algebraMap, MvPowerSeries.constantCoeff_C]
+
+omit [DecidableEq ι] in
+theorem algebraMap_injective (ell : ℕ) (hell : 0 < ell) :
+    Function.Injective (algebraMap k (Ring (ι := ι) (k := k) ell)) :=
+  Function.LeftInverse.injective (constantHom_algebraMap ell hell)
+
+omit [DecidableEq ι] in
+theorem quotient_charP {ell : ℕ} (hell : 0 < ell) [CharP k ell] :
+    CharP (Ring (ι := ι) (k := k) ell) ell :=
+  charP_of_injective_algebraMap (algebraMap_injective ell hell) ell
+
+                                                                                   
+theorem monomial_power_zero {ell : ℕ} (e : ι →₀ ℕ) (he : e ≠ 0) :
+    (Ideal.Quotient.mk (powerIdeal (ι := ι) (k := k) ell)
+      (MvPowerSeries.monomial e (1 : k))) ^ ell = 0 := by
+  rw [← map_pow, MvPowerSeries.monomial_pow, one_pow, Ideal.Quotient.eq_zero_iff_mem,
+    mem_powerIdeal_iff]
+  intro a ha
+  rw [MvPowerSeries.coeff_monomial]
+  apply ite_eq_right
+  intro h
+  obtain ⟨i, hi⟩ : ∃ i, e i ≠ 0 := Function.ne_iff.mp (by
+    intro heq
+    exact he (DFunLike.ext _ _ (congrFun heq)))
+  have hh := ha i
+  rw [h, Finsupp.nsmul_apply, smul_eq_mul] at hh
+  have : ell ≤ ell * e i := by
+    nth_rw 1 [← mul_one ell]
+    exact Nat.mul_le_mul_left ell (by omega)
+  omega
+
+                                                                          
+                                                                                 
+theorem frobenius_zero_of_constant {ell : ℕ} [CharP k ell] [Fact ell.Prime]
+    (x : Ring (ι := ι) (k := k) ell)
+    (hx : (constantHom ell (Nat.Prime.pos Fact.out) x)^ell = 0) : x^ell = 0 := by
+  let : CharP (Ring (ι := ι) (k := k) ell) ell := quotient_charP (Nat.Prime.pos Fact.out)
+  rw [monomial_expansion ell x, sum_pow_char]
+  apply Finset.sum_eq_zero
+  intro v _
+  rw [smul_pow]
+  by_cases he : exponent ell v = 0
+  · have hc : coefficients ell x v = constantHom ell (Nat.Prime.pos Fact.out) x := by
+      obtain ⟨f, rfl⟩ := Ideal.Quotient.mk_surjective x
+      change MvPowerSeries.coeff (exponent ell v) f = MvPowerSeries.constantCoeff f
+      rw [he, MvPowerSeries.coeff_zero_eq_constantCoeff]
+    rw [hc, hx, zero_smul]
+  · rw [monomial, monomial_power_zero _ he, smul_zero]
+
+theorem series_frobenius_mem {ell : ℕ} [CharP k ell] [Fact ell.Prime]
+    (f : Series (ι := ι) (k := k)) (hf : (MvPowerSeries.constantCoeff f)^ell = 0) :
+    f^ell ∈ powerIdeal ell := by
+  apply Ideal.Quotient.eq_zero_iff_mem.mp
+  rw [map_pow]
+  exact frobenius_zero_of_constant _ hf
+
+section Evaluation
+
+variable {S : Type*} [CommRing S] [Algebra k S]
+
+                                                                           
+                                                                        
+def nilpotentSubst (b : ι → S) : ι → MvPowerSeries Unit S :=
+  fun i => MvPowerSeries.C (b i)
+
+omit [DecidableEq ι] in
+theorem has_nilpotentSubst (b : ι → S) (hb : ∀ i, IsNilpotent (b i)) :
+    MvPowerSeries.HasSubst (nilpotentSubst b) := {
+    const_coeff := fun i => by simpa [nilpotentSubst] using hb i
+    coeff_zero := fun _ => Set.toFinite _ }
+
+def nilpotentEval (b : ι → S) (hb : ∀ i, IsNilpotent (b i)) : Series (ι := ι) (k := k) →ₐ[k] S :=
+  { toRingHom := MvPowerSeries.constantCoeff.comp
+      (MvPowerSeries.substAlgHom (R := k) (has_nilpotentSubst b hb)).toRingHom
+    commutes' := fun r => by
+      change MvPowerSeries.constantCoeff
+        ((MvPowerSeries.substAlgHom (R := k) (has_nilpotentSubst b hb))
+          (algebraMap k (Series (ι := ι) (k := k)) r)) = _
+      rw [AlgHom.commutes, MvPowerSeries.algebraMap_apply, MvPowerSeries.constantCoeff_C] }
+
+omit [DecidableEq ι] in
+@[simp] theorem nilpotentEval_X (b : ι → S) (hb : ∀ i, IsNilpotent (b i)) (i : ι) :
+    nilpotentEval (k := k) b hb (MvPowerSeries.X i) = b i := by
+  change MvPowerSeries.constantCoeff
+    ((MvPowerSeries.substAlgHom (R := k) (has_nilpotentSubst b hb)) (MvPowerSeries.X i)) = _
+  rw [MvPowerSeries.substAlgHom_X]
+  exact MvPowerSeries.constantCoeff_C _
+
+omit [Fintype ι] [DecidableEq ι] in
+theorem isNilpotent_of_powers (ell : ℕ) (b : ι → S) (hb : ∀ i, b i ^ ell = 0) :
+    ∀ i, IsNilpotent (b i) := fun i => ⟨ell, hb i⟩
+
+omit [DecidableEq ι] in
+theorem nilpotentEval_zero_on_powerIdeal (ell : ℕ) (b : ι → S) (hb : ∀ i, b i ^ ell = 0)
+    (f : Series (ι := ι) (k := k)) (hf : f ∈ powerIdeal ell) :
+    nilpotentEval (k := k) b (isNilpotent_of_powers ell b hb) f = 0 := by
+  obtain ⟨c, rfl⟩ := Ideal.mem_span_range_iff_exists_fun.mp hf
+  rw [map_sum]
+  apply Finset.sum_eq_zero
+  intro i _
+  rw [map_mul, map_pow, nilpotentEval_X, hb, mul_zero]
+
+                                                                          
+def eval (ell : ℕ) (b : ι → S) (hb : ∀ i, b i ^ ell = 0) : Ring (ι := ι) (k := k) ell →ₐ[k] S :=
+  Ideal.Quotient.liftₐ (powerIdeal (ι := ι) (k := k) ell)
+    (nilpotentEval (k := k) b (isNilpotent_of_powers ell b hb))
+    (nilpotentEval_zero_on_powerIdeal (k := k) ell b hb)
+
+def coordinate (ell : ℕ) (i : ι) : Ring (ι := ι) (k := k) ell :=
+  Ideal.Quotient.mk _ (MvPowerSeries.X i)
+
+omit [Fintype ι] [DecidableEq ι] in
+@[simp] theorem coordinate_pow (ell : ℕ) (i : ι) :
+    coordinate (k := k) ell i ^ ell = 0 := by
+  rw [coordinate, ← map_pow, Ideal.Quotient.eq_zero_iff_mem]
+  exact Ideal.subset_span ⟨i, rfl⟩
+
+omit [DecidableEq ι] in
+@[simp] theorem eval_coordinate (ell : ℕ) (b : ι → S) (hb : ∀ i, b i ^ ell = 0) (i : ι) :
+    eval (k := k) ell b hb (coordinate ell i) = b i := by
+  change nilpotentEval (k := k) b (isNilpotent_of_powers ell b hb) (MvPowerSeries.X i) = b i
+  exact nilpotentEval_X b (isNilpotent_of_powers ell b hb) i
+
+omit [DecidableEq ι] in
+theorem monomial_eq_prod (ell : ℕ) (v : Box (ι := ι) ell) :
+    monomial (k := k) ell v = (exponent ell v).prod (fun i n => coordinate ell i ^ n) := by
+  rw [monomial, MvPowerSeries.monomial_one_eq]
+  simp only [Finsupp.prod, map_prod, map_pow, coordinate]
+
+                                                                                    
+theorem algHom_ext (ell : ℕ) (f g : Ring (ι := ι) (k := k) ell →ₐ[k] S)
+    (h : ∀ i, f (coordinate ell i) = g (coordinate ell i)) : f = g := by
+  ext x
+  rw [monomial_expansion ell x, map_sum, map_sum]
+  apply Finset.sum_congr rfl
+  intro v _
+  rw [map_smul, map_smul, monomial_eq_prod]
+  congr 1
+  simp only [Finsupp.prod, map_prod, map_pow, h]
+
+@[simp] theorem eval_self (ell : ℕ) :
+    eval ell (coordinate (ι := ι) (k := k) ell) (coordinate_pow ell) = AlgHom.id k _ := by
+  apply algHom_ext
+  intro i
+  simp
+
+end Evaluation
+
+section Derivatives
+
+variable (ell : ℕ) [CharP k ell]
+
+omit [DecidableEq ι] in
+theorem pderiv_powerIdeal (i : ι) (f : Series (ι := ι) (k := k)) (hf : f ∈ powerIdeal ell) :
+    MvPowerSeries.pderiv i f ∈ powerIdeal ell := by
+  obtain ⟨c, rfl⟩ := Ideal.mem_span_range_iff_exists_fun.mp hf
+  rw [map_sum]
+  apply Ideal.sum_mem
+  intro j _
+  have hz : (ell : Series (ι := ι) (k := k)) = 0 := by
+    simpa only [map_natCast, map_zero] using
+      congrArg (MvPowerSeries.C : k →+* Series (ι := ι) (k := k)) (CharP.cast_eq_zero k ell)
+  rw [Derivation.leibniz, MvPowerSeries.pderiv_pow]
+  simp only [smul_eq_mul, hz, zero_mul, mul_zero, zero_add]
+  exact Ideal.mul_mem_right _ _ (Ideal.subset_span ⟨j, rfl⟩)
+
+def partialDeriv (i : ι) : Derivation k (Ring (ι := ι) (k := k) ell) (Ring (ι := ι) (k := k) ell) :=
+  Derivation.liftOfSurjective (f := Ideal.Quotient.mkₐ k (powerIdeal ell))
+    Ideal.Quotient.mk_surjective (d := MvPowerSeries.pderiv i) (by
+      intro f hf
+      apply Ideal.Quotient.eq_zero_iff_mem.mpr
+      exact pderiv_powerIdeal ell i f (Ideal.Quotient.eq_zero_iff_mem.mp hf))
+
+omit [DecidableEq ι] in
+@[simp] theorem partial_mk (i : ι) (f : Series (ι := ι) (k := k)) :
+    partialDeriv ell i (Ideal.Quotient.mk _ f) =
+      Ideal.Quotient.mk _ (MvPowerSeries.pderiv i f) := by
+  unfold partialDeriv
+  apply Derivation.liftOfSurjective_apply
+
+@[simp] theorem partial_coordinate (i j : ι) :
+    partialDeriv (k := k) ell i (Ideal.Quotient.mk _ (MvPowerSeries.X j)) = if i = j then 1 else 0 := by
+  rw [partial_mk]
+  by_cases h : i = j
+  · subst j; simp
+  · simp [MvPowerSeries.pderiv_X_of_ne (Ne.symm h), h]
+
+omit [Fintype ι] in
+theorem series_pderiv_commute (i j : ι) (f : Series (ι := ι) (k := k)) :
+    MvPowerSeries.pderiv i (MvPowerSeries.pderiv j f) =
+      MvPowerSeries.pderiv j (MvPowerSeries.pderiv i f) := by
+  by_cases hij : i = j
+  · subst j; rfl
+  ext e
+  simp only [MvPowerSeries.coeff_pderiv, Finsupp.add_apply]
+  simp only [Finsupp.single_eq_of_ne hij, Finsupp.single_eq_of_ne (Ne.symm hij), add_zero]
+  rw [add_assoc, add_comm (Finsupp.single i 1) (Finsupp.single j 1), ← add_assoc]
+  ring
+
+theorem partial_commute (i j : ι) (x : Ring (ι := ι) (k := k) ell) :
+    partialDeriv ell i (partialDeriv ell j x) = partialDeriv ell j (partialDeriv ell i x) := by
+  obtain ⟨f, rfl⟩ := Ideal.Quotient.mk_surjective x
+  simp only [partial_mk, series_pderiv_commute i j]
+
+                                                                                   
+omit [DecidableEq ι] in
+theorem residue_partial_zero (hell : 0 < ell) (i : ι)
+    (x : Ring (ι := ι) (k := k) ell) :
+    quotientCoeff ell (topExponent ell) (topExponent_good hell) (partialDeriv ell i x) = 0 := by
+  obtain ⟨f, rfl⟩ := Ideal.Quotient.mk_surjective x
+  rw [partial_mk, quotientCoeff_mk, MvPowerSeries.coeff_pderiv, topExponent_apply]
+  have hn : (ell - 1 : ℕ) + 1 = ell := by omega
+  have hc : ((ell - 1 : ℕ) : k) + 1 = 0 := by
+    calc
+      ((ell - 1 : ℕ) : k) + 1 = ((ell - 1 + 1 : ℕ) : k) := by simp only [Nat.cast_add, Nat.cast_one]
+      _ = 0 := by rw [hn]; exact CharP.cast_eq_zero k ell
+  rw [hc, mul_zero]
+
+end Derivatives
+
+end Frobenius
+end BoundaryOnly.FormalObstruction
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/FrobeniusObstruction/GlobalForms.lean b/lean/OAI/Algebra/FrobeniusObstruction/GlobalForms.lean
new file mode 100644
index 0000000000000000000000000000000000000000..120817080d6aa72abb2d374672821d53ca33c2d5
--- /dev/null
+++ b/lean/OAI/Algebra/FrobeniusObstruction/GlobalForms.lean
@@ -0,0 +1,339 @@
+import Mathlib
+import OAI.Algebra.FrobeniusObstruction.SignedTensor
+
+namespace OAI
+
+noncomputable section
+open scoped BigOperators
+
+namespace BoundaryOnly.FormalObstruction.GlobalForms
+open Frobenius MixedForms FormsSplit SignedTensor
+open scoped TensorProduct BigOperators
+variable {k : Type*} [Field k] (ell : ℕ) (hell : 0 < ell)
+
+@[simp] theorem blockEquiv_succ_symm_tensorCons {n : ℕ} (V : Fin (n + 1) → Type)
+    [∀ i, Fintype (V i)] [∀ i, DecidableEq (V i)]
+    (x : QForms (k := k) ell (V 0))
+    (y : ⨂[k] i : Fin n, QForms (k := k) ell (V i.succ)) :
+    (blockEquiv (k := k) ell hell (n + 1) V).symm
+      ((tensorCons (k := k) (fun i => QForms (k := k) ell (V i))).symm (x ⊗ₜ[k] y)) =
+      includeLeft (κ := Coordinates n (fun i => V i.succ)) ell x * includeRight (ι := V 0) ell
+        ((blockEquiv ell hell n (fun i => V i.succ)).symm y) := by
+  simp only [blockEquiv, LinearEquiv.trans_symm, LinearEquiv.trans_apply,
+    LinearEquiv.symm_symm, LinearEquiv.apply_symm_apply, TensorProduct.congr_symm_tmul,
+    LinearEquiv.refl_symm, LinearEquiv.refl_apply, sumEquiv_symm_tmul]
+
+@[simp] theorem blockEquiv_succ_symm_tprod {n : ℕ} (V : Fin (n + 1) → Type)
+    [∀ i, Fintype (V i)] [∀ i, DecidableEq (V i)]
+    (v : ∀ i, QForms (k := k) ell (V i)) :
+    (blockEquiv (k := k) ell hell (n + 1) V).symm (PiTensorProduct.tprod k v) =
+      includeLeft (κ := Coordinates n (fun i => V i.succ)) ell (v 0) * includeRight (ι := V 0) ell
+        ((blockEquiv ell hell n (fun i => V i.succ)).symm
+          (PiTensorProduct.tprod k (fun i => v i.succ))) := by
+  have h := blockEquiv_succ_symm_tensorCons ell hell V (v 0)
+    (PiTensorProduct.tprod k (fun i : Fin n => v i.succ))
+  rw [← tensorCons_tprod (k := k) (fun i => QForms (k := k) ell (V i)) v,
+    LinearEquiv.symm_apply_apply] at h
+  exact h
+
+                                                                       
+noncomputable def potential : ∀ (n : ℕ) (V : Fin n → Type)
+    [∀ i, Fintype (V i)] [∀ i, DecidableEq (V i)],
+    (∀ i, Ring (ι := V i) (k := k) ell) → Ring (ι := Coordinates n V) (k := k) ell
+  | 0, _, _, _, _ => 0
+  | n + 1, V, _, _, q => includeVariables ell Sum.inl (q 0) +
+      includeVariables ell Sum.inr (potential n (fun i => V i.succ) (fun i => q i.succ))
+
+end BoundaryOnly.FormalObstruction.GlobalForms
+
+namespace BoundaryOnly.FormalObstruction.GlobalForms
+open Frobenius MixedForms FormsSplit SignedTensor
+open scoped TensorProduct BigOperators
+variable {k : Type*} [Field k] (ell : ℕ) (hell : 0 < ell)
+
+@[simp] theorem parity_empty (x : QForms (k := k) ell PEmpty) : parity x = x := by
+  induction x using TensorProduct.inductionOn with
+  | add x y hx hy => rw [map_add, hx, hy]
+  | tmul a e =>
+    rw [parity_tmul]
+    congr 1
+    induction e using ExteriorAlgebra.induction with
+    | algebraMap r => exact AlgHom.commutes _ _
+    | ι v =>
+      have hv : v = 0 := Subsingleton.elim _ _
+      simp [hv]
+    | mul x y hx hy => simp only [map_mul, hx, hy]
+    | add x y hx hy => simp only [map_add, hx, hy]
+
+                                                                            
+theorem blockEquiv_symm_parity (n : ℕ) (V : Fin n → Type)
+    [∀ i, Fintype (V i)] [∀ i, DecidableEq (V i)]
+    (t : ⨂[k] i, QForms (k := k) ell (V i)) :
+    parity ((blockEquiv (k := k) ell hell n V).symm t) =
+      (blockEquiv (k := k) ell hell n V).symm
+        (PiTensorProduct.map (fun i => (parity (k := k) (A := Ring (ι := V i) (k := k) ell)
+          (ι := V i)).toLinearMap) t) := by
+  induction n with
+  | zero =>
+    rw [parity_empty]
+    congr 1
+    have h : (fun i : Fin 0 => (parity (k := k) (A := Ring (ι := V i) (k := k) ell)
+        (ι := V i)).toLinearMap) = (fun i => LinearMap.id (R := k) (M := QForms (k := k) ell (V i))) := by
+      funext i; exact Fin.elim0 i
+    rw [h, PiTensorProduct.map_id, LinearMap.id_apply]
+  | succ n ih =>
+    induction t using PiTensorProduct.induction_on with
+    | add x y hx hy => simp only [map_add, hx, hy]
+    | smul_tprod r v =>
+      simp only [map_smul, PiTensorProduct.map_tprod]
+      congr 1
+      rw [blockEquiv_succ_symm_tprod, blockEquiv_succ_symm_tprod,
+        map_mul, parity_includeLeft, parity_includeRight, ih]
+      rw [PiTensorProduct.map_tprod]
+      rfl
+
+ theorem blockEquiv_succ_symm_differential_tprod {n : ℕ} (V : Fin (n + 1) → Type)
+    [∀ i, Fintype (V i)] [∀ i, DecidableEq (V i)]
+    (P D : EndFamily (k := k) (fun i => QForms (k := k) ell (V i)))
+    (v : ∀ i, QForms (k := k) ell (V i)) :
+    (blockEquiv (k := k) ell hell (n + 1) V).symm
+      (differential (fun i => QForms (k := k) ell (V i)) P D (PiTensorProduct.tprod k v)) =
+      includeLeft (κ := Coordinates n (fun i => V i.succ)) ell (D 0 (v 0)) *
+        includeRight (ι := V 0) ell ((blockEquiv (k := k) ell hell n (fun i => V i.succ)).symm
+          (PiTensorProduct.tprod k (fun i => v i.succ))) +
+      includeLeft (κ := Coordinates n (fun i => V i.succ)) ell (P 0 (v 0)) *
+        includeRight (ι := V 0) ell ((blockEquiv (k := k) ell hell n (fun i => V i.succ)).symm
+          (differential (fun i : Fin n => QForms (k := k) ell (V i.succ))
+            (fun i => P i.succ) (fun i => D i.succ)
+            (PiTensorProduct.tprod k (fun i => v i.succ)))) := by
+  have h := congrArg (fun z => (blockEquiv (k := k) ell hell (n + 1) V).symm
+      ((tensorCons (k := k) (fun i => QForms (k := k) ell (V i))).symm z))
+    (differential_cons_tprod (fun i => QForms (k := k) ell (V i)) P D v)
+  simp only [LinearEquiv.symm_apply_apply, LinearEquiv.map_add] at h
+  rw [blockEquiv_succ_symm_tensorCons (k := k) ell hell V,
+    blockEquiv_succ_symm_tensorCons (k := k) ell hell V] at h
+  exact h
+
+variable [CharP k ell]
+
+                                                                                 
+theorem blockEquiv_symm_d (n : ℕ) (V : Fin n → Type)
+    [∀ i, Fintype (V i)] [∀ i, DecidableEq (V i)]
+    (t : ⨂[k] i, QForms (k := k) ell (V i)) :
+    d (partialDeriv (k := k) ell) ((blockEquiv (k := k) ell hell n V).symm t) =
+      (blockEquiv (k := k) ell hell n V).symm
+        (differential (fun i => QForms (k := k) ell (V i))
+          (fun i => (parity (k := k) (A := Ring (ι := V i) (k := k) ell) (ι := V i)).toLinearMap)
+          (fun i => d (partialDeriv (ι := V i) (k := k) ell)) t) := by
+  induction n with
+  | zero =>
+    simp only [d, differential, Fin.sum_univ_zero, LinearMap.zero_apply, LinearEquiv.map_zero]
+    have h : (∑ i : Coordinates 0 V, TensorProduct.map
+        (partialDeriv (k := k) ell i).toLinearMap (wedge i)) = 0 := by
+      exact Finset.sum_eq_zero (fun i _ => PEmpty.elim i)
+    rw [h, LinearMap.zero_apply]
+  | succ n ih =>
+    induction t using PiTensorProduct.induction_on with
+    | add x y hx hy => simp only [map_add, hx, hy]
+    | smul_tprod r v =>
+      simp only [map_smul]
+      congr 1
+      rw [blockEquiv_succ_symm_tprod, blockEquiv_succ_symm_differential_tprod,
+        d_mul, d_includeLeft, d_includeRight, parity_includeLeft, ih]
+      rfl
+
+                                                                           
+                                                             
+theorem blockEquiv_symm_delta (n : ℕ) (V : Fin n → Type)
+    [∀ i, Fintype (V i)] [∀ i, DecidableEq (V i)]
+    (q : ∀ i, Ring (ι := V i) (k := k) ell)
+    (t : ⨂[k] i, QForms (k := k) ell (V i)) :
+    delta (partialDeriv (k := k) ell) (potential (k := k) ell n V q)
+      ((blockEquiv (k := k) ell hell n V).symm t) =
+      (blockEquiv (k := k) ell hell n V).symm
+        (differential (fun i => QForms (k := k) ell (V i))
+          (fun i => (parity (k := k) (A := Ring (ι := V i) (k := k) ell) (ι := V i)).toLinearMap)
+          (fun i => delta (partialDeriv (ι := V i) (k := k) ell) (q i)) t) := by
+  induction n with
+  | zero => simp only [potential, delta_apply, MixedForms.gradient, TensorProduct.zero_tmul,
+      LinearMap.map_zero, LinearEquiv.map_zero, zero_mul, differential,
+      Fin.sum_univ_zero, LinearMap.zero_apply]
+  | succ n ih =>
+    induction t using PiTensorProduct.induction_on with
+    | add x y hx hy => simp only [map_add, hx, hy]
+    | smul_tprod r v =>
+      simp only [map_smul]
+      congr 1
+      rw [blockEquiv_succ_symm_tprod, blockEquiv_succ_symm_differential_tprod]
+      change delta (partialDeriv (k := k) ell)
+        (includeVariables ell Sum.inl (q 0) + includeVariables ell Sum.inr
+          (potential (k := k) ell n (fun i => V i.succ) (fun i => q i.succ))) _ = _
+      rw [delta_product, ih]
+      rfl
+
+end BoundaryOnly.FormalObstruction.GlobalForms
+
+namespace BoundaryOnly.FormalObstruction.GlobalForms
+open Frobenius MixedForms FormsSplit SignedTensor
+open scoped TensorProduct BigOperators
+variable {k : Type*} [Field k] (ell : ℕ) (hell : 0 < ell)
+
+                                                                                 
+def insertScalar : ∀ (n : ℕ) (V : Fin n → Type)
+    [∀ i, Fintype (V i)] [∀ i, DecidableEq (V i)],
+    (i : Fin n) → Ring (ι := V i) (k := k) ell →ₐ[k]
+      Ring (ι := Coordinates n V) (k := k) ell
+  | 0, _, _, _, i => Fin.elim0 i
+  | n+1, V, _, _, i => Fin.cases (includeVariables ell Sum.inl)
+      (fun i => (includeVariables ell Sum.inr).comp
+        (insertScalar n (fun j => V j.succ) i)) i
+
+                                                                                   
+def insertForms : ∀ (n : ℕ) (V : Fin n → Type)
+    [∀ i, Fintype (V i)] [∀ i, DecidableEq (V i)],
+    (i : Fin n) → QForms (k := k) ell (V i) →ₐ[k] QForms (k := k) ell (Coordinates n V)
+  | 0, _, _, _, i => Fin.elim0 i
+  | n+1, V, _, _, i => Fin.cases (includeLeft ell)
+      (fun i => (includeRight ell).comp (insertForms n (fun j => V j.succ) i)) i
+
+@[simp] theorem includeLeft_coeff {ι κ : Type} [Fintype ι] [Fintype κ]
+    [DecidableEq ι] [DecidableEq κ] (a : Ring (ι := ι) (k := k) ell) :
+    includeLeft (κ := κ) ell (coeff a) = coeff (includeVariables ell Sum.inl a) := by
+  simp only [includeLeft, coeff_apply, Algebra.TensorProduct.map_tmul, map_one]
+
+@[simp] theorem includeRight_coeff {ι κ : Type} [Fintype ι] [Fintype κ]
+    [DecidableEq ι] [DecidableEq κ] (a : Ring (ι := κ) (k := k) ell) :
+    includeRight (ι := ι) ell (coeff a) = coeff (includeVariables ell Sum.inr a) := by
+  simp only [includeRight, coeff_apply, Algebra.TensorProduct.map_tmul, map_one]
+
+@[simp] theorem insertForms_coeff (n : ℕ) (V : Fin n → Type)
+    [∀ i, Fintype (V i)] [∀ i, DecidableEq (V i)]
+    (i : Fin n) (a : Ring (ι := V i) (k := k) ell) :
+    insertForms ell n V i (coeff a) = coeff (insertScalar ell n V i a) := by
+  induction n with
+  | zero => exact Fin.elim0 i
+  | succ n ih =>
+    cases i using Fin.cases with
+    | zero => exact includeLeft_coeff ell a
+    | succ i =>
+      change includeRight ell (insertForms ell n (fun j => V j.succ) i (coeff a)) = _
+      rw [ih, includeRight_coeff]
+      rfl
+
+ theorem potential_sum (n : ℕ) (V : Fin n → Type)
+    [∀ i, Fintype (V i)] [∀ i, DecidableEq (V i)]
+    (q : ∀ i, Ring (ι := V i) (k := k) ell) :
+    potential ell n V q = ∑ i, insertScalar ell n V i (q i) := by
+  induction n with
+  | zero => simp [potential]
+  | succ n ih =>
+    rw [potential, ih, map_sum, Fin.sum_univ_succ]
+    rfl
+
+ theorem blockEquiv_symm_tprod_prod (n : ℕ) (V : Fin n → Type)
+    [∀ i, Fintype (V i)] [∀ i, DecidableEq (V i)]
+    (x : ∀ i, QForms (k := k) ell (V i)) :
+    (blockEquiv (k := k) ell hell n V).symm (PiTensorProduct.tprod k x) =
+      (List.ofFn fun i => insertForms ell n V i (x i)).prod := by
+  induction n with
+  | zero =>
+    apply (emptyForms (k := k) ell hell).injective
+    simp only [blockEquiv, LinearEquiv.trans_symm, LinearEquiv.trans_apply,
+      LinearEquiv.apply_symm_apply, List.ofFn_zero, List.prod_nil]
+    simp [emptyForms, emptyCoefficients, emptyExterior, Algebra.TensorProduct.one_def]
+  | succ n ih =>
+    rw [blockEquiv_succ_symm_tprod, ih, List.ofFn_succ, List.prod_cons]
+    change _ = includeLeft ell (x 0) *
+      (List.ofFn fun i => includeRight ell (insertForms ell n (fun j => V j.succ) i (x i.succ))).prod
+    rw [map_list_prod, List.map_ofFn]
+    rfl
+
+variable [CharP k ell]
+
+ theorem d_insertForms (n : ℕ) (V : Fin n → Type)
+    [∀ i, Fintype (V i)] [∀ i, DecidableEq (V i)]
+    (i : Fin n) (x : QForms (k := k) ell (V i)) :
+    d (partialDeriv ell) (insertForms ell n V i x) =
+      insertForms ell n V i (d (partialDeriv ell) x) := by
+  induction n with
+  | zero => exact Fin.elim0 i
+  | succ n ih =>
+    cases i using Fin.cases with
+    | zero => exact d_includeLeft ell x
+    | succ i =>
+      change d (partialDeriv ell) (includeRight ell (insertForms ell n (fun j => V j.succ) i x)) = _
+      rw [d_includeRight, ih]
+      rfl
+
+ theorem gradient_insertScalar (n : ℕ) (V : Fin n → Type)
+    [∀ i, Fintype (V i)] [∀ i, DecidableEq (V i)]
+    (i : Fin n) (q : Ring (ι := V i) (k := k) ell) :
+    gradient (partialDeriv ell) (insertScalar ell n V i q) =
+      insertForms ell n V i (gradient (partialDeriv ell) q) := by
+  rw [← d_coeff, ← insertForms_coeff, d_insertForms, d_coeff]
+
+ theorem delta_insertForms (n : ℕ) (V : Fin n → Type)
+    [∀ i, Fintype (V i)] [∀ i, DecidableEq (V i)]
+    (i : Fin n) (q : Ring (ι := V i) (k := k) ell) (x : QForms (k := k) ell (V i)) :
+    delta (partialDeriv ell) (insertScalar ell n V i q) (insertForms ell n V i x) =
+      insertForms ell n V i (delta (partialDeriv ell) q x) := by
+  rw [delta_apply, gradient_insertScalar, delta_apply, map_mul]
+
+end BoundaryOnly.FormalObstruction.GlobalForms
+
+namespace BoundaryOnly.FormalObstruction.GlobalForms
+open Frobenius MixedForms FormsSplit
+open scoped BigOperators TensorProduct
+variable {k : Type*} [Field k]
+
+def sigmaSucc {n : ℕ} (V : Fin (n+1) → Type) :
+    (Σ i, V i) ≃ V 0 ⊕ (Σ i : Fin n, V i.succ) where
+  toFun x := Fin.cases (fun y => Sum.inl y) (fun i y => Sum.inr ⟨i,y⟩) x.1 x.2
+  invFun := Sum.elim (fun y => ⟨0,y⟩) (fun y => ⟨y.1.succ,y.2⟩)
+  left_inv := by rintro ⟨i,y⟩; cases i using Fin.cases <;> rfl
+  right_inv := by intro y; cases y <;> rfl
+
+def coordinateEquiv : ∀ (n : ℕ) (V : Fin n → Type), Coordinates n V ≃ (Σ i, V i)
+  | 0, _ => Equiv.equivOfIsEmpty _ _
+  | n+1, V => (Equiv.sumCongr (Equiv.refl (V 0))
+      (coordinateEquiv n (fun i => V i.succ))).trans (sigmaSucc V).symm
+
+@[simp] theorem coordinateEquiv_zero {n : ℕ} (V : Fin (n+1) → Type) (y : V 0) :
+    coordinateEquiv (n+1) V (Sum.inl y) = ⟨0,y⟩ := rfl
+
+@[simp] theorem coordinateEquiv_succ {n : ℕ} (V : Fin (n+1) → Type)
+    (y : Coordinates n (fun i => V i.succ)) :
+    coordinateEquiv (n+1) V (Sum.inr y) =
+      ⟨(coordinateEquiv n (fun i => V i.succ) y).1.succ,
+        (coordinateEquiv n (fun i => V i.succ) y).2⟩ := rfl
+
+@[simp] theorem coordinateEquiv_symm_zero {n : ℕ} (V : Fin (n+1) → Type) (y : V 0) :
+    (coordinateEquiv (n+1) V).symm ⟨0,y⟩ = Sum.inl y := rfl
+
+@[simp] theorem coordinateEquiv_symm_succ {n : ℕ} (V : Fin (n+1) → Type)
+    (i : Fin n) (y : V i.succ) :
+    (coordinateEquiv (n+1) V).symm ⟨i.succ,y⟩ =
+      Sum.inr ((coordinateEquiv n (fun i => V i.succ)).symm ⟨i,y⟩) := rfl
+
+variable (ell : ℕ)
+@[simp] theorem insertScalar_coordinate (n : ℕ) (V : Fin n → Type)
+    [∀ i, Fintype (V i)] [∀ i, DecidableEq (V i)]
+    (i : Fin n) (y : V i) :
+    insertScalar (k := k) ell n V i (coordinate ell y) =
+      coordinate ell ((coordinateEquiv n V).symm ⟨i,y⟩) := by
+  induction n with
+  | zero => exact Fin.elim0 i
+  | succ n ih =>
+    cases i using Fin.cases with
+    | zero => exact includeVariables_coordinate ell Sum.inl y
+    | succ i =>
+      change includeVariables ell Sum.inr
+        (insertScalar ell n (fun i => V i.succ) i (coordinate ell y)) = _
+      rw [ih, includeVariables_coordinate]
+      rfl
+
+end BoundaryOnly.FormalObstruction.GlobalForms
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/FrobeniusObstruction/GraphPotential.lean b/lean/OAI/Algebra/FrobeniusObstruction/GraphPotential.lean
new file mode 100644
index 0000000000000000000000000000000000000000..2aa6d43c8252597457776797853ff0e0a93d7c00
--- /dev/null
+++ b/lean/OAI/Algebra/FrobeniusObstruction/GraphPotential.lean
@@ -0,0 +1,246 @@
+import Mathlib
+import OAI.Algebra.FrobeniusObstruction.MovingCharts
+
+namespace OAI
+
+noncomputable section
+open scoped BigOperators
+
+namespace BoundaryOnly.FormalObstruction
+open Frobenius
+variable {k : Type*} [Field k] {d : ℕ} {n : Fin d → ℕ}
+variable (ell : ℕ) (htwo : 1 < ell) [CharP k ell] [Fact ell.Prime]
+
+abbrev ParameterScalar := Frobenius.Ring (ι := InternalVar n) (k := ThreeParameters.Ring k) ell
+
+def normalIndices : Finset (InternalVar n) := Finset.univ.filter fun c => c.1 = true
+
+@[simp] theorem mem_normalIndices (c : InternalVar n) : c ∈ normalIndices (n := n) ↔ c.1 = true := by
+  simp [normalIndices]
+
+def normalPlane : ParameterScalar (n := n) (k := k) ell →ₐ[ThreeParameters.Ring k]
+    ParameterScalar (n := n) (k := k) ell :=
+  planeRestriction ell (Nat.Prime.pos Fact.out) normalIndices
+
+omit [CharP k ell] in
+@[simp] theorem normalPlane_coordinate (b : Bool) (t : TangentVar n) :
+    normalPlane (k := k) ell (coordinate ell (b,t)) =
+      if b then 0 else coordinate ell (b,t) := by
+  simp only [normalPlane, planeRestriction_coordinate, mem_normalIndices]
+
+theorem normalPlane_movingGraphSlot (a : SlopeVar d → ThreeParameters.Ring k)
+    (ha : ∀ i, ThreeParameters.augmentation k (a i) = 0) :
+    ((normalPlane (n := n) ell).restrictScalars k).comp (movingGraphSlot ell a ha false) =
+      movingGraphSlot ell a ha false := by
+  refine algHom_ext (ι := GraphVar n) (k := k)
+    (S := ParameterScalar (n := n) (k := k) ell) ell _ _ ?_
+  intro v
+  simp only [AlgHom.comp_apply, AlgHom.restrictScalars_apply, movingGraphSlot_coordinate]
+  cases v with
+  | inl i => exact AlgHom.commutes (normalPlane (n := n) ell) _
+  | inr t => simp [movingGraphCoordinates]
+
+omit [CharP k ell] in
+theorem normalPlane_smul (r : k) (x : ParameterScalar (n := n) (k := k) ell) :
+    normalPlane ell (r • x) = r • normalPlane ell x :=
+  map_smul ((normalPlane ell).restrictScalars k) r x
+
+omit [CharP k ell] in
+theorem normalPlane_fixedComplement (D : FormalData (k := k) n) (c : InternalVar n) :
+    normalPlane ell (baseChange (l := ThreeParameters.Ring k) ell (fixedComplement ell D c)) = 0 := by
+  simp only [fixedComplement, map_sum, map_smul, baseChange_coordinate,
+    normalPlane_smul, normalPlane_coordinate, ite_true, smul_zero, Finset.sum_const_zero]
+
+                                                                                  
+def ambientCoordinates (a : SlopeVar d → ThreeParameters.Ring k) :
+    AmbientVar n → ParameterScalar (n := n) (k := k) ell
+  | .inl i => @algebraMap (ThreeParameters.Ring k) (ParameterScalar (n := n) (k := k) ell)
+      inferInstance inferInstance inferInstance (a i)
+  | .inr c => coordinate ell c
+
+theorem ambientCoordinates_pow (a : SlopeVar d → ThreeParameters.Ring k)
+    (ha : ∀ i, ThreeParameters.augmentation k (a i) = 0) (i : AmbientVar n) :
+    ambientCoordinates (n := n) ell a i ^ ell = 0 := by
+  cases i with
+  | inl i =>
+      change (@algebraMap (ThreeParameters.Ring k) (ParameterScalar (n := n) (k := k) ell)
+        inferInstance inferInstance inferInstance (a i)) ^ ell = 0
+      rw [← map_pow, ThreeParameters.augmentation_zero_pow k ell (a i) (ha i), map_zero]
+  | inr c => exact coordinate_pow ell c
+
+def ambientSlot (a : SlopeVar d → ThreeParameters.Ring k)
+    (ha : ∀ i, ThreeParameters.augmentation k (a i) = 0) :
+    Frobenius.Ring (ι := AmbientVar n) (k := k) ell →ₐ[k] ParameterScalar (n := n) (k := k) ell :=
+  eval ell (ambientCoordinates ell a) (ambientCoordinates_pow ell a ha)
+
+@[simp] theorem ambientSlot_coordinate (a : SlopeVar d → ThreeParameters.Ring k)
+    (ha : ∀ i, ThreeParameters.augmentation k (a i) = 0) (v : AmbientVar n) :
+    ambientSlot ell a ha (coordinate ell v) = ambientCoordinates (n := n) ell a v :=
+  eval_coordinate ell _ _ _
+
+theorem graphCoordinates_constant_zero (D : FormalData (k := k) n) (v : AmbientVar n) :
+    MvPowerSeries.constantCoeff (graphCoordinates n D.Y v) = 0 := by
+  cases v with
+  | inl i => simp [graphCoordinates]
+  | inr c => exact graph_constant_zero D c
+
+def formalGraph (D : FormalData (k := k) n) :
+    Frobenius.Ring (ι := AmbientVar n) (k := k) ell →ₐ[k]
+      Frobenius.Ring (ι := GraphVar n) (k := k) ell :=
+  substitute ell (graphCoordinates n D.Y) (graphCoordinates_constant_zero D)
+
+@[simp] theorem formalGraph_mk (D : FormalData (k := k) n) (p : MvPowerSeries (AmbientVar n) k) :
+    formalGraph ell D (Ideal.Quotient.mk _ p) =
+      Ideal.Quotient.mk _ (MvPowerSeries.subst (graphCoordinates n D.Y) p) :=
+  substitute_mk ell _ _ _
+
+                                                                 
+theorem graph_restriction_hom (D : FormalData (k := k) n)
+    (a : SlopeVar d → ThreeParameters.Ring k)
+    (ha : ∀ i, ThreeParameters.augmentation k (a i) = 0) :
+    (((normalPlane (n := n) ell).comp (movingChart ell D a ha)).restrictScalars k).comp
+      (ambientSlot ell a ha) = (movingGraphSlot ell a ha false).comp (formalGraph ell D) := by
+  refine algHom_ext (ι := AmbientVar n) (k := k)
+    (S := ParameterScalar (n := n) (k := k) ell) ell _ _ ?_
+  intro v
+  simp only [AlgHom.comp_apply, AlgHom.restrictScalars_apply, ambientSlot_coordinate,
+    formalGraph, substitute_coordinate]
+  cases v with
+  | inl i =>
+      change normalPlane ell (movingChart ell D a ha
+        ((algebraMap (ThreeParameters.Ring k) (ParameterScalar (n := n) (k := k) ell)) (a i))) = _
+      rw [AlgHom.commutes, AlgHom.commutes]
+      exact (movingGraphSlot_coordinate ell a ha false (.inl i)).symm
+  | inr c =>
+      change normalPlane ell (movingChart ell D a ha (coordinate ell c)) = _
+      rw [movingChart_coordinate, movingChartCoordinate, map_add, normalPlane_fixedComplement, add_zero]
+      exact AlgHom.congr_fun (normalPlane_movingGraphSlot ell a ha)
+        (Ideal.Quotient.mk _ (D.Y c))
+
+def movingPotential (D : FormalData (k := k) n) (a : SlopeVar d → ThreeParameters.Ring k)
+    (ha : ∀ i, ThreeParameters.augmentation k (a i) = 0) : ParameterScalar (n := n) (k := k) ell :=
+  ambientSlot ell a ha (Ideal.Quotient.mk _ (potential n D.P))
+
+theorem movingPotential_graph_zero (D : FormalData (k := k) n)
+    (a : SlopeVar d → ThreeParameters.Ring k)
+    (ha : ∀ i, ThreeParameters.augmentation k (a i) = 0) :
+    normalPlane ell (movingChart ell D a ha (movingPotential ell D a ha)) = 0 := by
+  have h := AlgHom.congr_fun (graph_restriction_hom ell D a ha)
+    (Ideal.Quotient.mk _ (potential n D.P))
+  change _ = 0
+  simp only [AlgHom.comp_apply, formalGraph_mk, D.graph_zero, map_zero] at h
+  exact h
+
+end BoundaryOnly.FormalObstruction
+
+namespace BoundaryOnly.FormalObstruction
+open Frobenius
+variable {k : Type*} [Field k] {d : ℕ} {n : Fin d → ℕ}
+variable (ell : ℕ) (htwo : 1 < ell) [CharP k ell] [Fact ell.Prime]
+
+omit [Fact (Nat.Prime ell)] in
+theorem partial_ambientCoordinates (a : SlopeVar d → ThreeParameters.Ring k)
+    (i : InternalVar n) (v : AmbientVar n) :
+    partialDeriv ell i (ambientCoordinates ell a v) =
+      if v = .inr i then 1 else 0 := by
+  cases v with
+  | inl a => simp only [ambientCoordinates, Derivation.map_algebraMap, reduceCtorEq, ite_false]
+  | inr c =>
+      simp only [ambientCoordinates, coordinate, partial_coordinate, Sum.inr.injEq]
+      by_cases h : i = c
+      · simp [h]
+      · simp [h, Ne.symm h]
+
+                                                                                 
+omit [Fact (Nat.Prime ell)] in
+theorem parameter_chain_rule
+    (f : Frobenius.Ring (ι := AmbientVar n) (k := k) ell →ₐ[k]
+      ParameterScalar (n := n) (k := k) ell)
+    (i : InternalVar n) (x : Frobenius.Ring (ι := AmbientVar n) (k := k) ell) :
+    partialDeriv ell i (f x) =
+      ∑ v : AmbientVar n, f (partialDeriv ell v x) * partialDeriv ell i (f (coordinate ell v)) := by
+  let : Module k (ParameterScalar (n := n) (k := k) ell) :=
+    @Algebra.toModule k (ParameterScalar (n := n) (k := k) ell) inferInstance inferInstance inferInstance
+  exact derivation_chain_rule (S := ParameterScalar (n := n) (k := k) ell)
+    (k := k) (ι := AmbientVar n) ell f
+    ((partialDeriv (k := ThreeParameters.Ring k) ell i).restrictScalars k) x
+
+theorem sum_mul_single {J R : Type*} [Fintype J] [DecidableEq J] [Semiring R]
+    (u : J → R) (i : J) : (∑ v, u v * (if v = i then 1 else 0)) = u i := by
+  simp only [mul_ite, mul_one, mul_zero, Finset.sum_ite_eq', Finset.mem_univ, ite_true]
+
+                                                                                             
+theorem partial_ambientSlot (a : SlopeVar d → ThreeParameters.Ring k)
+    (ha : ∀ i, ThreeParameters.augmentation k (a i) = 0)
+    (i : InternalVar n) (x : Frobenius.Ring (ι := AmbientVar n) (k := k) ell) :
+    partialDeriv ell i (ambientSlot ell a ha x) =
+      ambientSlot ell a ha (partialDeriv ell (.inr i) x) := by
+  have h := parameter_chain_rule ell (ambientSlot ell a ha) i x
+  simp only [ambientSlot_coordinate, partial_ambientCoordinates] at h
+  exact h.trans (sum_mul_single (fun v => ambientSlot ell a ha (partialDeriv ell v x)) (.inr i))
+
+theorem movingPotential_restricted_partial (D : FormalData (k := k) n)
+    (a : SlopeVar d → ThreeParameters.Ring k)
+    (ha : ∀ i, ThreeParameters.augmentation k (a i) = 0) (c : InternalVar n) :
+    normalPlane ell (movingChart ell D a ha (partialDeriv ell c (movingPotential ell D a ha))) =
+      movingGraphSlot ell a ha false (Ideal.Quotient.mk _ (restrictedGradient n D.P D.Y c)) := by
+  rw [movingPotential, partial_ambientSlot, partial_mk]
+  have h := AlgHom.congr_fun (graph_restriction_hom ell D a ha)
+    (Ideal.Quotient.mk _ (MvPowerSeries.pderiv (.inr c) (potential n D.P)))
+  simp only [AlgHom.comp_apply, AlgHom.restrictScalars_apply, formalGraph_mk] at h
+  exact h
+
+end BoundaryOnly.FormalObstruction
+
+namespace BoundaryOnly.FormalObstruction
+open Frobenius
+variable {k : Type*} [Field k] {d : ℕ} {n : Fin d → ℕ}
+variable (ell : ℕ) (htwo : 1 < ell) [CharP k ell] [Fact ell.Prime]
+
+@[simp] theorem normalPlane_slot_apply (a : SlopeVar d → ThreeParameters.Ring k)
+    (ha : ∀ i, ThreeParameters.augmentation k (a i) = 0)
+    (x : Frobenius.Ring (ι := GraphVar n) (k := k) ell) :
+    normalPlane ell (movingGraphSlot ell a ha false x) = movingGraphSlot ell a ha false x :=
+  AlgHom.congr_fun (normalPlane_movingGraphSlot ell a ha) x
+
+theorem movingPotential_mem_normalIdeal (D : FormalData (k := k) n)
+    (a : SlopeVar d → ThreeParameters.Ring k)
+    (ha : ∀ i, ThreeParameters.augmentation k (a i) = 0) :
+    movingPotential ell D a ha ∈
+      chartNormalIdeal ell (movingChartEquiv ell htwo D a ha).symm normalIndices := by
+  apply (chart_restriction_eq_zero_iff ell (Nat.Prime.pos Fact.out)
+    (movingChartEquiv ell htwo D a ha).symm normalIndices _).mp
+  exact movingPotential_graph_zero ell D a ha
+
+                                                                            
+                                                       
+theorem graphIdeal_ambient_discrepancy (D : FormalData (k := k) n)
+    (a : SlopeVar d → ThreeParameters.Ring k)
+    (ha : ∀ i, ThreeParameters.augmentation k (a i) = 0)
+    (g : MvPowerSeries (GraphVar n) k) (hg : g ∈ gradientIdeal n D.P D.Y) :
+    ∃ h : InternalVar n → ParameterScalar (n := n) (k := k) ell,
+      ((movingChartEquiv ell htwo D a ha).symm
+        (movingGraphSlot ell a ha false (Ideal.Quotient.mk _ g)) -
+        ∑ c, h c * partialDeriv ell c (movingPotential ell D a ha)) ∈
+          chartNormalIdeal ell (movingChartEquiv ell htwo D a ha).symm normalIndices := by
+  obtain ⟨h, hh⟩ := Ideal.mem_span_range_iff_exists_fun.mp hg
+  let e := movingChartEquiv ell htwo D a ha
+  refine ⟨fun c => e.symm (movingGraphSlot ell a ha false (Ideal.Quotient.mk _ (h c))), ?_⟩
+  apply (chart_restriction_eq_zero_iff ell (Nat.Prime.pos Fact.out) e.symm normalIndices _).mp
+  change normalPlane ell (e (e.symm (movingGraphSlot ell a ha false (Ideal.Quotient.mk _ g)) -
+    ∑ c, e.symm (movingGraphSlot ell a ha false (Ideal.Quotient.mk _ (h c))) *
+      partialDeriv ell c (movingPotential ell D a ha))) = 0
+  simp only [map_sub, map_sum, map_mul, AlgEquiv.apply_symm_apply, normalPlane_slot_apply]
+  have he (x : ParameterScalar (n := n) (k := k) ell) : e x = movingChart ell D a ha x := rfl
+  simp only [he, movingPotential_restricted_partial]
+  apply sub_eq_zero.mpr
+  simp only [← map_mul, ← map_sum]
+  apply congrArg (movingGraphSlot ell a ha false)
+  apply congrArg (Ideal.Quotient.mk (powerIdeal (k := k) ell))
+  exact hh.symm
+
+end BoundaryOnly.FormalObstruction
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/FrobeniusObstruction/LiftProducts.lean b/lean/OAI/Algebra/FrobeniusObstruction/LiftProducts.lean
new file mode 100644
index 0000000000000000000000000000000000000000..1306973d659df5f625092d3d38691c76d8193e8b
--- /dev/null
+++ b/lean/OAI/Algebra/FrobeniusObstruction/LiftProducts.lean
@@ -0,0 +1,197 @@
+import Mathlib
+import OAI.Algebra.FrobeniusObstruction.SelectedCycles
+
+namespace OAI
+
+noncomputable section
+open scoped BigOperators
+
+namespace BoundaryOnly.FormalObstruction.ThreeParameters
+variable {k : Type*} [Field k] {d : ℕ}
+
+                                                             
+def chosen (i j l : Fin d) (r : Fin d) : Ring k :=
+  if r = i then s k 0 else if r = j then s k 1 else if r = l then s k 2 else 0
+
+ theorem chosen_augmentation (i j l r : Fin d) :
+    augmentation k (chosen (k := k) i j l r) = 0 := by
+  simp only [chosen]
+  split_ifs <;> simp only [augmentation_s, map_zero]
+
+ theorem chosen_square (i j l r : Fin d) :
+    chosen (k := k) i j l r * chosen (k := k) i j l r = 0 := by
+  simp only [chosen]
+  split_ifs <;> simp only [← pow_two, s_sq, zero_pow (by decide : 2 ≠ 0)]
+
+ theorem chosen_outside (J : Finset (Fin d)) (i j l : Fin d)
+    (hi : i ∈ J) (hj : j ∈ J) (hl : l ∈ J) (r : Fin d) (hr : r ∉ J) :
+    chosen (k := k) i j l r = 0 := by
+  have hri : r ≠ i := by rintro rfl; exact hr hi
+  have hrj : r ≠ j := by rintro rfl; exact hr hj
+  have hrl : r ≠ l := by rintro rfl; exact hr hl
+  simp only [chosen, ite_eq_right hri, ite_eq_right hrj, ite_eq_right hrl]
+
+ theorem chosen_product (i j l : Fin d) (hij : i ≠ j) (hil : i ≠ l) (hjl : j ≠ l) :
+    chosen (k := k) i j l i * chosen (k := k) i j l j * chosen (k := k) i j l l = w k := by
+  simp [chosen, hij.symm, hil.symm, hjl.symm, w]
+
+end BoundaryOnly.FormalObstruction.ThreeParameters
+
+namespace BoundaryOnly.FormalObstruction.MixedForms
+variable {k A ι : Type*} [CommRing k] [CommRing A] [Algebra k A]
+variable [Fintype ι] [DecidableEq ι]
+
+                                                                              
+                                                                                  
+theorem separated_parameter_lift_some {b : ℕ}
+    (pd : ι → Derivation k A A) (Q p s : Fin b → A) (J : Finset (Fin b))
+    (hs : ∀ j i, pd i (s j) = 0) (hs2 : ∀ j, s j * s j = 0)
+    (hout : ∀ j ∉ J, s j = 0)
+    (x y : Fin b → Forms (k := k) (A := A) (ι := ι))
+    (hx : ∀ j, gradient pd (Q j) * x j = 0)
+    (hy : ∀ j ∈ J, gradient pd (Q j) * y j = -(gradient pd (p j) * x j)) :
+    delta pd (∑ j, (Q j + s j * p j))
+      (List.ofFn (fun j => x j + coeff (s j) * y j)).prod = 0 := by
+  change gradient pd (∑ j, (Q j + s j * p j)) * _ = 0
+  have hg : gradient pd (∑ j, (Q j + s j * p j)) =
+      ∑ j, gradient pd (Q j + s j * p j) := by
+    change d pd (coeff (k := k) (ι := ι) (∑ j, (Q j + s j * p j))) = _
+    rw [map_sum, map_sum]
+    rfl
+  rw [hg, Finset.sum_mul]
+  apply Finset.sum_eq_zero
+  intro j _
+  apply gradient_mul_list_prod_zero pd (Q j + s j * p j)
+    _ (x j + coeff (s j) * y j)
+  · exact List.mem_ofFn.mpr ⟨j,rfl⟩
+  · by_cases hj : j ∈ J
+    · exact perturbed_factor pd (Q j) (p j) (s j) (hs j) (hs2 j) (x j) (y j) (hx j) (hy j hj)
+    · rw [hout j hj, zero_mul, add_zero, map_zero, zero_mul, add_zero, hx]
+
+end BoundaryOnly.FormalObstruction.MixedForms
+
+namespace BoundaryOnly.FormalObstruction.ActualBlocks
+open Frobenius MixedForms
+open scoped TensorProduct BigOperators
+variable {k : Type*} [Field k] {d : ℕ} {n : Fin d → ℕ}
+variable (ell : ℕ) [Fact ell.Prime] [CharP k ell]
+
+def liftScalar (i : Fin d) : Scalar (n := n) (k := k) ell i →ₐ[k]
+    ParameterScalar (n := n) (k := k) ell :=
+  (baseChange (l := ThreeParameters.Ring k) ell).comp (includeScalar ell i)
+
+def liftBlock (i : Fin d) : Block (n := n) (k := k) ell i →ₐ[k]
+    ParameterForms (n := n) (k := k) ell :=
+  (coefficientMap (baseChange (l := ThreeParameters.Ring k) ell)).comp (includeBlock ell i)
+
+omit [Fact ell.Prime] in
+ theorem liftBlock_delta (i : Fin d) (F : Scalar (n := n) (k := k) ell i)
+    (x : Block (n := n) (k := k) ell i) :
+    liftBlock ell i (delta (partialDeriv ell) F x) =
+      delta (parameterPartial ell) (liftScalar ell i F) (liftBlock ell i x) := by
+  simp only [liftBlock, liftScalar, AlgHom.comp_apply]
+  rw [← delta_includeBlock]
+  exact coefficientMap_delta _ _ _ (baseChange_partial ell) _ _
+
+omit [Fact ell.Prime] [CharP k ell] in
+ theorem reduce_liftBlock (i : Fin d) (x : Block (n := n) (k := k) ell i) :
+    coefficientMap (reduction ell) (liftBlock ell i x) = includeBlock ell i x := by
+  simp only [liftBlock, AlgHom.comp_apply]
+  generalize includeBlock ell i x = z
+  induction z using TensorProduct.inductionOn with
+  | add a b ha hb => simp only [map_add, ha, hb]
+  | tmul a e => simp only [coefficientMap_tmul, reduction_baseChange]
+
+omit [CharP k ell] in
+ theorem liftScalar_potential (D : FormalData (k := k) n) (i : Fin d) :
+    liftScalar ell i (blockPotential ell D i) =
+      baseChange (l := ThreeParameters.Ring k) ell
+        (wallSpecial ell true i (Ideal.Quotient.mk _ (D.P i)) -
+          wallSpecial ell false i (Ideal.Quotient.mk _ (D.P i))) := by
+  simp only [liftScalar, AlgHom.comp_apply, blockPotential, map_sub, include_wall]
+
+omit [Fact ell.Prime] [CharP k ell] in
+ theorem liftScalar_slope (D : FormalData (k := k) n) (i : Fin d) :
+    liftScalar ell i (blockSlope ell D i) =
+      baseChange (l := ThreeParameters.Ring k) ell (specialSlope ell D true i) := by
+  simp only [liftScalar, AlgHom.comp_apply, include_blockSlope]
+
+omit [Fact ell.Prime] [CharP k ell] in
+theorem reduction_lifted_product
+    (v : Fin d → ParameterScalar (n := n) (k := k) ell)
+    (hv : ∀ i, reduction ell (v i) = 0)
+    (x y : ∀ i, Block (n := n) (k := k) ell i) :
+    coefficientMap (reduction ell)
+      (List.ofFn (fun i => liftBlock ell i (x i) + coeff (v i) * liftBlock ell i (y i))).prod =
+        (List.ofFn fun i => includeBlock ell i (x i)).prod := by
+  rw [map_list_prod, List.map_ofFn]
+  apply congrArg List.prod
+  apply congrArg List.ofFn
+  funext i
+  simp only [Function.comp_apply]
+  rw [map_add, reduce_liftBlock, map_mul, coefficientMap_coeff, hv, map_zero, zero_mul, add_zero]
+
+                                                                           
+                                                                            
+theorem parameter_cycle (D : FormalData (k := k) n) (J : Finset (Fin d))
+    (s : Fin d → ThreeParameters.Ring k)
+    (hs : ∀ i, ThreeParameters.augmentation k (s i) = 0)
+    (hs2 : ∀ i, s i * s i = 0) (hout : ∀ i ∉ J, s i = 0)
+    (x : ∀ i, Block (n := n) (k := k) ell i)
+    (hx : ∀ i, delta (partialDeriv ell) (blockPotential ell D i) (x i) = 0)
+    (hy : ∀ i ∈ J, ∃ y : Block (n := n) (k := k) ell i,
+      delta (partialDeriv ell) (blockPotential ell D i) y =
+        -delta (partialDeriv ell) (blockSlope ell D i) (x i)) :
+    ∃ beta : ParameterForms (n := n) (k := k) ell,
+      delta (parameterPartial ell)
+        (movingPotential ell D (firstSlopes s) (firstSlopes_augmentation s hs)) beta = 0 ∧
+      coefficientMap (reduction ell) beta = (List.ofFn fun i => includeBlock ell i (x i)).prod := by
+  classical
+  let y : ∀ i, Block (n := n) (k := k) ell i := fun i =>
+    if hi : i ∈ J then Classical.choose (hy i hi) else 0
+  have hy' (i : Fin d) (hi : i ∈ J) :
+      delta (partialDeriv ell) (blockPotential ell D i) (y i) =
+        -delta (partialDeriv ell) (blockSlope ell D i) (x i) := by
+    simp only [y, dite_eq_left hi]
+    exact Classical.choose_spec (hy i hi)
+  let v : Fin d → ParameterScalar (n := n) (k := k) ell :=
+    fun i => @algebraMap (ThreeParameters.Ring k) (ParameterScalar (n := n) (k := k) ell)
+      inferInstance inferInstance inferInstance (s i)
+  let beta := (List.ofFn (fun i => liftBlock ell i (x i) + coeff (v i) * liftBlock ell i (y i))).prod
+  refine ⟨beta, ?_, ?_⟩
+  · have hc := separated_parameter_lift_some (parameterPartial (n := n) (k := k) ell)
+      (fun i => liftScalar ell i (blockPotential ell D i))
+      (fun i => liftScalar ell i (blockSlope ell D i)) v J
+      (by
+        intro i c
+        change partialDeriv (k := ThreeParameters.Ring k) ell c
+          (algebraMap (ThreeParameters.Ring k) _ (s i)) = 0
+        exact Derivation.map_algebraMap _ _)
+      (by intro i; dsimp [v]; rw [← map_mul, hs2, map_zero])
+      (by intro i hi; dsimp [v]; rw [hout i hi, map_zero])
+      (fun i => liftBlock ell i (x i)) (fun i => liftBlock ell i (y i))
+      (by
+        intro i
+        change delta (parameterPartial ell) (liftScalar ell i (blockPotential ell D i))
+          (liftBlock ell i (x i)) = 0
+        rw [← liftBlock_delta, hx, map_zero])
+      (by
+        intro i hi
+        change delta (parameterPartial ell) (liftScalar ell i (blockPotential ell D i))
+          (liftBlock ell i (y i)) =
+            -delta (parameterPartial ell) (liftScalar ell i (blockSlope ell D i))
+              (liftBlock ell i (x i))
+        rw [← liftBlock_delta, ← liftBlock_delta, hy' i hi, map_neg])
+    change delta (parameterPartial ell) _ beta = 0 at hc
+    rw [movingPotential_first_order ell D s hs hs2]
+    simpa only [liftScalar_potential, liftScalar_slope] using hc
+  · apply reduction_lifted_product ell v _ x y
+    intro i
+    change reduction ell (algebraMap (ThreeParameters.Ring k) _ (s i)) = 0
+    rw [reduction_base, hs, map_zero]
+
+end BoundaryOnly.FormalObstruction.ActualBlocks
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/FrobeniusObstruction/LinearChange.lean b/lean/OAI/Algebra/FrobeniusObstruction/LinearChange.lean
new file mode 100644
index 0000000000000000000000000000000000000000..2c56c802a0a9ced8714768795dd20c0dfcdc59dc
--- /dev/null
+++ b/lean/OAI/Algebra/FrobeniusObstruction/LinearChange.lean
@@ -0,0 +1,368 @@
+import Mathlib
+import OAI.Algebra.FrobeniusObstruction.Derivations
+import OAI.Algebra.FrobeniusObstruction.NilpotentInverse
+
+namespace OAI
+
+noncomputable section
+open scoped BigOperators
+
+namespace BoundaryOnly.FormalObstruction.Frobenius
+variable {ι k : Type*} [Fintype ι] [DecidableEq ι] [Field k]
+variable (ell : ℕ) (hell : 0 < ell)
+
+def augmentation : Ring (ι := ι) (k := k) ell →ₐ[k] k :=
+  { constantHom ell hell with commutes' := constantHom_algebraMap ell hell }
+
+omit [DecidableEq ι] in
+@[simp] theorem augmentation_coordinate (i : ι) :
+    augmentation (k := k) ell hell (coordinate ell i) = 0 := by
+  change MvPowerSeries.constantCoeff (MvPowerSeries.X i : Series (k := k)) = 0
+  simp
+
+def maximalIdeal : Ideal (Ring (ι := ι) (k := k) ell) :=
+  RingHom.ker (augmentation ell hell)
+
+theorem maximalIdeal_nilpotent [CharP k ell] [Fact ell.Prime] :
+    IsNilpotent (maximalIdeal (ι := ι) (k := k) ell hell) := by
+  let : IsNoetherianRing (Ring (ι := ι) (k := k) ell) :=
+    IsNoetherianRing.of_finite k _
+  apply (Ideal.FG.isNilpotent_iff_le_nilradical
+    (IsNoetherian.noetherian (maximalIdeal (ι := ι) (k := k) ell hell))).mpr
+  intro x hx
+  apply mem_nilradical.mpr
+  refine ⟨ell, frobenius_zero_of_constant x ?_⟩
+  have hx' : constantHom ell hell x = 0 := hx
+  rw [hx', zero_pow (by omega)]
+
+                                                                      
+                                                    
+theorem augmentation_comp (f : Ring (ι := ι) (k := k) ell →ₐ[k] Ring (ι := ι) (k := k) ell) :
+    (augmentation ell hell).comp f = augmentation ell hell := by
+  apply algHom_ext
+  intro i
+  rw [AlgHom.comp_apply, augmentation_coordinate]
+  have hz : ((augmentation ell hell) (f (coordinate ell i)))^ell = 0 := by
+    rw [← map_pow, ← map_pow, coordinate_pow, map_zero, map_zero]
+  exact eq_zero_of_pow_eq_zero hz
+
+theorem endomorphism_difference_mem
+    (f : Ring (ι := ι) (k := k) ell →ₐ[k] Ring (ι := ι) (k := k) ell) (x) :
+    f x - x ∈ maximalIdeal ell hell := by
+  change augmentation ell hell (f x - x) = 0
+  rw [map_sub, ← AlgHom.comp_apply, augmentation_comp, sub_self]
+
+                                                                       
+                                                                   
+theorem bijective_of_tangent_identity [CharP k ell] [Fact ell.Prime]
+    (f : Ring (ι := ι) (k := k) ell →ₐ[k] Ring (ι := ι) (k := k) ell)
+    (hfirst : ∀ x ∈ maximalIdeal ell hell,
+      f x - x ∈ (maximalIdeal ell hell)^2) : Function.Bijective f :=
+  NilpotentInverse.bijective_of_first_jet _ (maximalIdeal_nilpotent ell hell) f
+    (endomorphism_difference_mem ell hell f) hfirst
+
+                                                                       
+omit [Fintype ι] [DecidableEq ι] in
+theorem monomial_mem_coordinate_pow (e : ι →₀ ℕ) :
+    Ideal.Quotient.mk _ (MvPowerSeries.monomial e (1 : k)) ∈
+      (Ideal.span (Set.range (coordinate (ι := ι) (k := k) ell)))^e.degree := by
+  induction e using Finsupp.induction with
+  | zero => simp
+  | single_add i b e hi hb ih =>
+      rw [map_add, Finsupp.degree_single]
+      rw [pow_add (Ideal.span (Set.range (coordinate (ι := ι) (k := k) ell))) b e.degree]
+      rw [← one_mul (1 : k), ← MvPowerSeries.monomial_mul_monomial,
+        map_mul, ← MvPowerSeries.X_pow_eq, map_pow]
+      exact Ideal.mul_mem_mul
+        (Ideal.pow_mem_pow
+          (show coordinate (k := k) ell i ∈ Ideal.span (Set.range (coordinate (ι := ι) (k := k) ell)) from
+            Ideal.subset_span ⟨i, rfl⟩) b) ih
+
+                                                                          
+                                                  
+theorem maximalIdeal_eq_span : maximalIdeal (ι := ι) (k := k) ell hell =
+    Ideal.span (Set.range (coordinate (ι := ι) (k := k) ell)) := by
+  apply le_antisymm
+  · intro x hx
+    rw [monomial_expansion ell x]
+    apply Submodule.sum_mem
+    intro v _
+    by_cases he : exponent ell v = 0
+    · have hc : coefficients ell x v = 0 := by
+        obtain ⟨f, rfl⟩ := Ideal.Quotient.mk_surjective x
+        change MvPowerSeries.coeff (exponent ell v) f = 0
+        rw [he, MvPowerSeries.coeff_zero_eq_constantCoeff]
+        exact hx
+      rw [hc, zero_smul]
+      exact Submodule.zero_mem _
+    · apply (Ideal.span (Set.range (coordinate (ι := ι) (k := k) ell))).restrictScalars k |>.smul_mem
+      have hd : 1 ≤ (exponent ell v).degree := by
+        have := (Finsupp.degree_eq_zero_iff (exponent ell v)).not.mpr he
+        omega
+      exact (show (Ideal.span (Set.range (coordinate (ι := ι) (k := k) ell)))^
+          (exponent ell v).degree ≤ _ from
+        (Ideal.pow_le_pow_right hd).trans_eq (pow_one (Ideal.span (Set.range (coordinate (ι := ι) (k := k) ell)))))
+          (monomial_mem_coordinate_pow ell (exponent ell v))
+  · apply Ideal.span_le.mpr
+    rintro _ ⟨i, rfl⟩
+    exact augmentation_coordinate ell hell i
+
+theorem bijective_of_coordinate_first_jet [CharP k ell] [Fact ell.Prime]
+    (f : Ring (ι := ι) (k := k) ell →ₐ[k] Ring (ι := ι) (k := k) ell)
+    (hfirst : ∀ i, f (coordinate ell i) - coordinate ell i ∈ (maximalIdeal ell hell)^2) :
+    Function.Bijective f := by
+  apply bijective_of_tangent_identity ell hell f
+  rw [maximalIdeal_eq_span] at *
+  apply NilpotentInverse.first_jet_of_generators _ f
+  · intro x
+    rw [← maximalIdeal_eq_span ell hell]
+    exact endomorphism_difference_mem ell hell f x
+  · exact hfirst
+
+                                                                          
+theorem endomorphism_pow_mem
+    (f : Ring (ι := ι) (k := k) ell →ₐ[k] Ring (ι := ι) (k := k) ell)
+    (n : ℕ) {x} (hx : x ∈ (maximalIdeal ell hell)^n) : f x ∈ (maximalIdeal ell hell)^n := by
+  have hf : Ideal.map f.toRingHom (maximalIdeal (ι := ι) (k := k) ell hell) ≤ maximalIdeal ell hell := by
+    apply Ideal.map_le_iff_le_comap.mpr
+    intro y hy
+    change augmentation ell hell (f y) = 0
+    rw [← AlgHom.comp_apply, augmentation_comp]
+    exact hy
+  have hfn : Ideal.map f.toRingHom ((maximalIdeal (ι := ι) (k := k) ell hell)^n) ≤ (maximalIdeal ell hell)^n := by
+    rw [Ideal.map_pow]
+    exact pow_le_pow_left' hf n
+  exact hfn (Ideal.mem_map_of_mem f.toRingHom hx)
+
+def linearCoordinates (M : Matrix ι ι k) (i : ι) : Ring (ι := ι) (k := k) ell :=
+  ∑ j, M i j • coordinate ell j
+
+omit [DecidableEq ι] in
+@[simp] theorem augmentation_linearCoordinates (M : Matrix ι ι k) (i : ι) :
+    augmentation ell hell (linearCoordinates ell M i) = 0 := by
+  simp [linearCoordinates]
+
+section Prime
+variable [CharP k ell] [Fact ell.Prime]
+
+include hell in
+theorem linearCoordinates_pow (M : Matrix ι ι k) (i : ι) :
+    (linearCoordinates ell M i)^ell = 0 := by
+  apply frobenius_zero_of_constant
+  change (augmentation ell hell (linearCoordinates ell M i))^ell = 0
+  rw [augmentation_linearCoordinates, zero_pow (by omega)]
+
+def linearSubst (M : Matrix ι ι k) : Ring (ι := ι) (k := k) ell →ₐ[k] Ring (ι := ι) (k := k) ell :=
+  eval ell (linearCoordinates ell M) (linearCoordinates_pow ell hell M)
+
+@[simp] theorem linearSubst_coordinate (M : Matrix ι ι k) (i : ι) :
+    linearSubst ell hell M (coordinate ell i) = linearCoordinates ell M i :=
+  eval_coordinate ell _ _ i
+
+theorem linearSubst_comp (M N : Matrix ι ι k) :
+    (linearSubst ell hell M).comp (linearSubst ell hell N) = linearSubst ell hell (N*M) := by
+  apply algHom_ext
+  intro i
+  simp only [AlgHom.comp_apply, linearSubst_coordinate, linearCoordinates,
+    map_sum, map_smul, linearSubst_coordinate, Finset.smul_sum, smul_smul,
+    Matrix.mul_apply, Finset.sum_smul]
+  rw [Finset.sum_comm]
+
+@[simp] theorem linearSubst_one :
+    linearSubst (ι := ι) (k := k) ell hell 1 = AlgHom.id k _ := by
+  apply algHom_ext
+  intro i
+  simp [linearCoordinates, Matrix.one_apply]
+
+theorem linearSubst_injective (M : Matrix ι ι k) (hM : IsUnit M.det) :
+    Function.Injective (linearSubst ell hell M) := by
+  have hi : (linearSubst ell hell M⁻¹).comp (linearSubst ell hell M) = AlgHom.id k _ := by
+    rw [linearSubst_comp, Matrix.mul_nonsing_inv M hM, linearSubst_one]
+  intro x y h
+  have ht := congrArg (linearSubst ell hell M⁻¹) h
+  change ((linearSubst ell hell M⁻¹).comp (linearSubst ell hell M)) x =
+    ((linearSubst ell hell M⁻¹).comp (linearSubst ell hell M)) y at ht
+  simpa only [hi, AlgHom.id_apply] using ht
+
+                                                                      
+                                                                    
+theorem bijective_of_invertible_first_jet
+    (f : Ring (ι := ι) (k := k) ell →ₐ[k] Ring (ι := ι) (k := k) ell)
+    (M : Matrix ι ι k) (hM : IsUnit M.det)
+    (hfirst : ∀ i, f (coordinate ell i) - linearCoordinates ell M i ∈ (maximalIdeal ell hell)^2) :
+    Function.Bijective f := by
+  let g := linearSubst ell hell M⁻¹
+  have hi : g.comp (linearSubst ell hell M) = AlgHom.id k _ := by
+    dsimp only [g]
+    rw [linearSubst_comp, Matrix.mul_nonsing_inv M hM, linearSubst_one]
+  have hgf : Function.Bijective (g.comp f) := by
+    apply bijective_of_coordinate_first_jet ell hell
+    intro i
+    have ht := endomorphism_pow_mem ell hell g 2 (hfirst i)
+    rw [map_sub, ← linearSubst_coordinate ell hell M i] at ht
+    have hic := AlgHom.congr_fun hi (coordinate ell i)
+    change g ((linearSubst ell hell M) (coordinate ell i)) = coordinate ell i at hic
+    rw [hic] at ht
+    exact ht
+  have hg : Function.Injective g := by
+    apply linearSubst_injective ell hell
+    simpa only [Matrix.det_nonsing_inv, Ring.inverse_eq_inv] using hM.inv
+  constructor
+  · intro x y h
+    apply hgf.1
+    change g (f x) = g (f y)
+    rw [h]
+  · intro y
+    obtain ⟨x, hx⟩ := hgf.2 (g y)
+    exact ⟨x, hg hx⟩
+
+end Prime
+end BoundaryOnly.FormalObstruction.Frobenius
+
+namespace BoundaryOnly.FormalObstruction.Frobenius
+variable {ι k : Type*} [Fintype ι] [DecidableEq ι] [Field k]
+variable (ell : ℕ) (htwo : 1 < ell)
+
+def tangentCoeff (i : ι) : Ring (ι := ι) (k := k) ell →ₗ[k] k :=
+  quotientCoeff ell (Finsupp.single i 1) (by
+    intro j
+    by_cases h : i = j
+    · subst j; simpa using htwo
+    · simp [Finsupp.single_eq_of_ne (Ne.symm h)]; omega)
+
+@[simp] theorem tangentCoeff_mk (i : ι) (f : Series (ι := ι) (k := k)) :
+    tangentCoeff ell htwo i (Ideal.Quotient.mk _ f) =
+      MvPowerSeries.coeff (Finsupp.single i 1) f := rfl
+
+@[simp] theorem tangentCoeff_coordinate (i j : ι) :
+    tangentCoeff (k := k) ell htwo i (coordinate ell j) = if i = j then 1 else 0 := by
+  simp [coordinate, MvPowerSeries.coeff_X, Finsupp.single_left_inj (one_ne_zero : (1 : ℕ) ≠ 0)]
+
+@[simp] theorem tangentCoeff_one (i : ι) :
+    tangentCoeff (k := k) ell htwo i 1 = 0 := by
+  change tangentCoeff (k := k) ell htwo i (Ideal.Quotient.mk _ (1 : Series (ι := ι) (k := k))) = 0
+  rw [tangentCoeff_mk, MvPowerSeries.coeff_one]
+  simp
+
+def firstJetError : Ring (ι := ι) (k := k) ell →ₗ[k] Ring (ι := ι) (k := k) ell :=
+  LinearMap.id - (augmentation (ι := ι) (k := k) ell (by omega)).toLinearMap.smulRight (1 : Ring (ι := ι) (k := k) ell) -
+    ∑ i, (tangentCoeff ell htwo i).smulRight (coordinate ell i)
+
+@[simp] theorem firstJetError_apply (x : Ring (ι := ι) (k := k) ell) :
+    firstJetError ell htwo x = x - augmentation ell (by omega) x • 1 -
+      ∑ i, tangentCoeff ell htwo i x • coordinate ell i := by
+  simp [firstJetError]
+
+@[simp] theorem firstJetError_one : firstJetError (ι := ι) (k := k) ell htwo 1 = 0 := by
+  simp
+
+@[simp] theorem firstJetError_coordinate (i : ι) :
+    firstJetError (k := k) ell htwo (coordinate ell i) = 0 := by
+  simp
+
+                                                                            
+                                                                                  
+theorem firstJetError_mem_square (x : Ring (ι := ι) (k := k) ell) :
+    firstJetError ell htwo x ∈ (maximalIdeal ell (by omega))^2 := by
+  rw [monomial_expansion ell x, map_sum]
+  apply Submodule.sum_mem
+  intro v _
+  rw [map_smul]
+  refine (((maximalIdeal (ι := ι) (k := k) ell (by omega))^2).restrictScalars k).smul_mem _ ?_
+  by_cases hz : (exponent ell v).degree = 0
+  · have he := (Finsupp.degree_eq_zero_iff _).mp hz
+    have hm : monomial (k := k) ell v = 1 := by simp [monomial, he]
+    rw [hm, firstJetError_one]
+    exact Submodule.zero_mem _
+  by_cases ho : (exponent ell v).degree = 1
+  · obtain ⟨i, hi⟩ : exponent ell v ∈ Set.range (fun i : ι => Finsupp.single i 1) := by
+      rw [Finsupp.range_single_one]
+      exact ho
+    have hm : monomial (k := k) ell v = coordinate ell i := by
+      simp [monomial, ← hi, coordinate, MvPowerSeries.X_def]
+    rw [hm, firstJetError_coordinate]
+    exact Submodule.zero_mem _
+  · have he : exponent ell v ≠ 0 := (Finsupp.degree_eq_zero_iff _).not.mp hz
+    have hs (i : ι) : Finsupp.single i 1 ≠ exponent ell v := by
+      intro hi
+      apply ho
+      simp [← hi]
+    have ha : augmentation ell (by omega) (monomial (k := k) ell v) = 0 := by
+      change MvPowerSeries.constantCoeff (MvPowerSeries.monomial (exponent ell v) (1:k)) = 0
+      rw [← MvPowerSeries.coeff_zero_eq_constantCoeff, MvPowerSeries.coeff_monomial]
+      simp [Ne.symm he]
+    have hc (i : ι) : tangentCoeff ell htwo i (monomial (k := k) ell v) = 0 := by
+      simp [monomial, MvPowerSeries.coeff_monomial, hs i]
+    rw [firstJetError_apply, ha, zero_smul, sub_zero]
+    simp only [hc, zero_smul, Finset.sum_const_zero, sub_zero]
+    rw [maximalIdeal_eq_span]
+    apply Ideal.pow_le_pow_right (show 2 ≤ (exponent ell v).degree by omega)
+    exact monomial_mem_coordinate_pow ell (exponent ell v)
+
+                                                                             
+                                             
+theorem bijective_of_tangent_matrix [CharP k ell] [Fact ell.Prime]
+    (f : Ring (ι := ι) (k := k) ell →ₐ[k] Ring (ι := ι) (k := k) ell)
+    (hM : IsUnit (Matrix.det (fun i j => tangentCoeff ell htwo j (f (coordinate ell i))))) :
+    Function.Bijective f := by
+  apply bijective_of_invertible_first_jet ell (by omega) f _ hM
+  intro i
+  have ha : augmentation ell (by omega) (f (coordinate ell i)) = 0 := by
+    rw [← AlgHom.comp_apply, augmentation_comp, augmentation_coordinate]
+  simpa only [firstJetError_apply, ha, zero_smul, sub_zero, linearCoordinates]
+    using firstJetError_mem_square ell htwo (f (coordinate ell i))
+
+end BoundaryOnly.FormalObstruction.Frobenius
+
+namespace BoundaryOnly.FormalObstruction.Frobenius
+variable {ι k S : Type*} [Fintype ι] [DecidableEq ι] [CommRing k]
+  [CommRing S] [Algebra k S] (ell : ℕ) [CharP k ell]
+
+                                                                                
+theorem derivation_chain_rule (f : Ring (ι := ι) (k := k) ell →ₐ[k] S)
+    (D : Derivation k S S) (x : Ring (ι := ι) (k := k) ell) :
+    D (f x) = ∑ i, f (partialDeriv ell i x) * D (f (coordinate ell i)) := by
+  let u := D.toLinearMap.comp f.toLinearMap
+  let v : Ring (ι := ι) (k := k) ell →ₗ[k] S :=
+    ∑ i, D (f (coordinate ell i)) • (f.toLinearMap.comp (partialDeriv ell i).toLinearMap)
+  have hv (x) : v x = ∑ i, f (partialDeriv ell i x) * D (f (coordinate ell i)) := by
+    simp only [v, LinearMap.sum_apply, LinearMap.smul_apply, LinearMap.comp_apply,
+      Derivation.coeFn_coe, AlgHom.toLinearMap_apply, smul_eq_mul]
+    apply Finset.sum_congr rfl
+    intro i _
+    exact mul_comm _ _
+  have h : u = v := by
+    apply relativeDeriv_ext ell f
+    · simp [u]
+    · rw [hv]; simp
+    · intro x y
+      simp only [u, LinearMap.comp_apply, Derivation.coeFn_coe,
+        AlgHom.toLinearMap_apply, map_mul, Derivation.leibniz, smul_eq_mul]
+      ring
+    · intro x y
+      rw [hv, hv, hv, Finset.sum_mul, Finset.mul_sum, ← Finset.sum_add_distrib]
+      apply Finset.sum_congr rfl
+      intro i _
+      simp only [Derivation.leibniz, smul_eq_mul, map_add, map_mul]
+      ring
+    · intro i
+      rw [hv]
+      simp only [coordinate, partial_coordinate, u, LinearMap.comp_apply, Derivation.coeFn_coe,
+        AlgHom.toLinearMap_apply, apply_ite f, map_one, map_zero, ite_mul,
+        one_mul, zero_mul, Finset.sum_ite_eq', Finset.mem_univ, ite_true]
+  exact (LinearMap.congr_fun h x).trans (hv x)
+
+variable {κ : Type*} [Fintype κ] [DecidableEq κ]
+
+omit [DecidableEq κ] in
+theorem partial_chain_rule (f : Ring (ι := ι) (k := k) ell →ₐ[k]
+    Ring (ι := κ) (k := k) ell) (j : κ) (x : Ring (ι := ι) (k := k) ell) :
+    partialDeriv ell j (f x) = ∑ i, f (partialDeriv ell i x) *
+      partialDeriv ell j (f (coordinate ell i)) :=
+  derivation_chain_rule ell f (partialDeriv ell j) x
+
+end BoundaryOnly.FormalObstruction.Frobenius
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/FrobeniusObstruction/MixedForms.lean b/lean/OAI/Algebra/FrobeniusObstruction/MixedForms.lean
new file mode 100644
index 0000000000000000000000000000000000000000..ce478e65fc5bdeefea2c05c4acbc3b8eb86e9c2c
--- /dev/null
+++ b/lean/OAI/Algebra/FrobeniusObstruction/MixedForms.lean
@@ -0,0 +1,399 @@
+import Mathlib
+
+namespace OAI
+
+noncomputable section
+open scoped BigOperators
+
+noncomputable section
+open scoped BigOperators TensorProduct
+
+namespace BoundaryOnly.FormalObstruction
+namespace MixedForms
+
+variable {k A ι : Type*} [CommRing k] [CommRing A] [Algebra k A]
+  [DecidableEq ι]
+
+abbrev Ext := ExteriorAlgebra k (ι → k)
+abbrev Forms := A ⊗[k] Ext (k := k) (ι := ι)
+
+def gen (i : ι) : Ext (k := k) (ι := ι) := ExteriorAlgebra.ι k (Pi.single i 1)
+
+def wedge (i : ι) : Module.End k (Ext (k := k) (ι := ι)) :=
+  (Algebra.lmul k _).toLinearMap (gen i)
+
+@[simp] theorem wedge_apply (i : ι) (e : Ext (k := k) (ι := ι)) :
+    wedge i e = gen i * e := rfl
+
+theorem gen_anticommute (i j : ι) :
+    gen (k := k) i * gen j = -(gen j * gen i) := by
+  apply eq_neg_iff_add_eq_zero.mpr
+  exact ExteriorAlgebra.ι_add_mul_swap _ _
+
+theorem gen_sq (i : ι) : gen (k := k) i * gen i = 0 :=
+  ExteriorAlgebra.ι_sq_zero _
+
+                                                         
+omit [DecidableEq ι] in
+theorem vector_supercommute (v : ι → k) (e : Ext (k := k) (ι := ι)) :
+    ExteriorAlgebra.ι k v * e = CliffordAlgebra.involute e * ExteriorAlgebra.ι k v := by
+  induction e using ExteriorAlgebra.induction with
+  | algebraMap r =>
+      rw [AlgHom.commutes]
+      exact (Algebra.commutes r _).symm
+  | ι u =>
+      rw [CliffordAlgebra.involute_ι, neg_mul]
+      exact eq_neg_iff_add_eq_zero.mpr (ExteriorAlgebra.ι_add_mul_swap _ _)
+  | mul a b ha hb =>
+      rw [map_mul, ← mul_assoc, ha, mul_assoc, hb, ← mul_assoc]
+  | add a b ha hb => simp only [map_add, mul_add, add_mul, ha, hb]
+
+theorem gen_supercommute (i : ι) (e : Ext (k := k) (ι := ι)) :
+    gen i * e = CliffordAlgebra.involute e * gen i :=
+  vector_supercommute (Pi.single i 1) e
+
+def parity : Forms (k := k) (A := A) (ι := ι) →ₐ[k] Forms (k := k) (A := A) (ι := ι) :=
+  Algebra.TensorProduct.map (AlgHom.id k A) CliffordAlgebra.involute
+
+omit [DecidableEq ι] in
+@[simp] theorem parity_tmul (a : A) (e : Ext (k := k) (ι := ι)) :
+    parity (a ⊗ₜ[k] e) = a ⊗ₜ[k] CliffordAlgebra.involute e := rfl
+
+omit [DecidableEq ι] in
+theorem parity_sq (x : Forms (k := k) (A := A) (ι := ι)) : parity (parity x) = x := by
+  induction x using TensorProduct.inductionOn with
+  | tmul a e => simp [CliffordAlgebra.involute_involute]
+  | add x y hx hy => simp [hx, hy]
+
+                                                                            
+variable [Fintype ι]
+
+def d (pd : ι → Derivation k A A) : Module.End k (Forms (k := k) (A := A) (ι := ι)) :=
+  ∑ i, TensorProduct.map (pd i).toLinearMap (wedge i)
+
+@[simp] theorem d_tmul (pd : ι → Derivation k A A) (a : A)
+    (e : Ext (k := k) (ι := ι)) :
+    d pd (a ⊗ₜ[k] e) = ∑ i, pd i a ⊗ₜ[k] (gen i * e) := by
+  simp [d]
+
+theorem d_mul (pd : ι → Derivation k A A)
+    (x y : Forms (k := k) (A := A) (ι := ι)) :
+    d pd (x * y) = d pd x * y + parity x * d pd y := by
+  induction x using TensorProduct.inductionOn with
+  | add x₁ x₂ hx₁ hx₂ => simp only [add_mul, map_add, hx₁, hx₂]; abel
+  | tmul a e =>
+      induction y using TensorProduct.inductionOn with
+      | add y₁ y₂ hy₁ hy₂ => simp only [mul_add, map_add, hy₁, hy₂]; abel
+      | tmul b f =>
+          simp only [Algebra.TensorProduct.tmul_mul_tmul, d_tmul, parity_tmul,
+            Derivation.leibniz, smul_eq_mul, TensorProduct.add_tmul,
+            Finset.sum_mul, Finset.mul_sum, Finset.sum_add_distrib]
+          rw [add_comm]
+          congr 1 <;> apply Finset.sum_congr rfl <;> intro i _
+          · rw [mul_comm b, mul_assoc]
+          · rw [← mul_assoc, gen_supercommute i e, mul_assoc]
+
+theorem d_parity (pd : ι → Derivation k A A)
+    (x : Forms (k := k) (A := A) (ι := ι)) :
+    d pd (parity x) = -(parity (d pd x)) := by
+  induction x using TensorProduct.inductionOn with
+  | add x y hx hy => simp only [map_add, hx, hy, neg_add_rev]; abel
+  | tmul a e =>
+      simp only [parity_tmul, d_tmul, map_sum, map_mul,
+        gen, CliffordAlgebra.involute_ι, neg_mul, TensorProduct.tmul_neg,
+        Finset.sum_neg_distrib, neg_neg]
+
+                                                       
+def gradient (pd : ι → Derivation k A A) (F : A) :
+    Forms (k := k) (A := A) (ι := ι) := d pd (F ⊗ₜ[k] 1)
+
+def delta (pd : ι → Derivation k A A) (F : A) :
+    Module.End k (Forms (k := k) (A := A) (ι := ι)) :=
+  (Algebra.lmul k _).toLinearMap (gradient pd F)
+
+@[simp] theorem delta_apply (pd : ι → Derivation k A A) (F : A)
+    (x : Forms (k := k) (A := A) (ι := ι)) :
+    delta pd F x = gradient pd F * x := rfl
+
+                                                                                 
+omit [DecidableEq ι] in
+theorem antisymmetric_sum {M : Type*} [AddCommGroup M] (f : ι → ι → M)
+    (hd : ∀ i, f i i = 0) (ha : ∀ i j, f i j + f j i = 0) :
+    ∑ i, ∑ j, f i j = 0 := by
+  rw [← Finset.sum_product']
+  apply Finset.sum_involution (fun ij _ => (ij.2, ij.1))
+  · intro ij _; exact ha _ _
+  · intro ij _ hn he
+    have heq : ij.2 = ij.1 := congrArg Prod.fst he
+    exact hn (by simpa only [heq] using hd ij.1)
+  · intro ij _; simp
+  · intro ij _; rfl
+
+                                                                                      
+theorem d_sq (pd : ι → Derivation k A A)
+    (hcomm : ∀ i j a, pd i (pd j a) = pd j (pd i a))
+    (x : Forms (k := k) (A := A) (ι := ι)) : d pd (d pd x) = 0 := by
+  induction x using TensorProduct.inductionOn with
+  | add x y hx hy => simp only [map_add, hx, hy, add_zero]
+  | tmul a e =>
+      simp only [d_tmul, map_sum]
+      apply antisymmetric_sum
+      · intro i
+        rw [← mul_assoc, gen_sq, zero_mul, TensorProduct.tmul_zero]
+      · intro i j
+        rw [hcomm j i, ← mul_assoc, gen_anticommute j i, neg_mul,
+          TensorProduct.tmul_neg, ← mul_assoc, neg_add_cancel]
+
+                                                                                    
+theorem oneform_sq (v : ι → A) :
+    (∑ i, v i ⊗ₜ[k] gen (k := k) i) * (∑ i, v i ⊗ₜ[k] gen (k := k) i) = 0 := by
+  simp only [Finset.sum_mul, Finset.mul_sum, Algebra.TensorProduct.tmul_mul_tmul]
+  apply antisymmetric_sum
+  · intro i; rw [gen_sq, TensorProduct.tmul_zero]
+  · intro i j
+    rw [mul_comm (v j), gen_anticommute j i, TensorProduct.tmul_neg, neg_add_cancel]
+
+@[simp] theorem gradient_eq (pd : ι → Derivation k A A) (F : A) :
+    gradient pd F = ∑ i, pd i F ⊗ₜ[k] gen (k := k) i := by
+  simp only [gradient, d_tmul, mul_one]
+
+@[simp] theorem parity_gradient (pd : ι → Derivation k A A) (F : A) :
+    parity (gradient pd F) = -gradient pd F := by
+  simp only [gradient_eq, map_sum, parity_tmul, gen, CliffordAlgebra.involute_ι,
+    TensorProduct.tmul_neg, Finset.sum_neg_distrib]
+
+theorem delta_sq (pd : ι → Derivation k A A) (F : A)
+    (x : Forms (k := k) (A := A) (ι := ι)) : delta pd F (delta pd F x) = 0 := by
+  simp only [delta_apply, ← mul_assoc, gradient_eq, oneform_sq, zero_mul]
+
+                                                         
+theorem d_delta (pd : ι → Derivation k A A)
+    (hcomm : ∀ i j a, pd i (pd j a) = pd j (pd i a))
+    (F : A) (x : Forms (k := k) (A := A) (ι := ι)) :
+    d pd (delta pd F x) + delta pd F (d pd x) = 0 := by
+  rw [delta_apply, d_mul, parity_gradient]
+  have hz : d pd (gradient pd F) = 0 := d_sq pd hcomm _
+  rw [hz, zero_mul, zero_add, neg_mul, delta_apply, neg_add_cancel]
+
+                                                           
+omit [Fintype ι] [DecidableEq ι] in
+theorem constant_commute (F : A) (x : Forms (k := k) (A := A) (ι := ι)) :
+    (F ⊗ₜ[k] (1 : Ext (k := k) (ι := ι))) * x =
+      x * (F ⊗ₜ[k] (1 : Ext (k := k) (ι := ι))) := by
+  induction x using TensorProduct.inductionOn with
+  | add x y hx hy => simp only [mul_add, add_mul, hx, hy]
+  | tmul a e => simp only [Algebra.TensorProduct.tmul_mul_tmul, one_mul, mul_one, mul_comm F a]
+
+                                                             
+theorem d_commutator (pd : ι → Derivation k A A) (p : A)
+    (x : Forms (k := k) (A := A) (ι := ι)) :
+    d pd ((p ⊗ₜ[k] 1) * x) - (p ⊗ₜ[k] 1) * d pd x = delta pd p x := by
+  rw [d_mul, parity_tmul, map_one, add_sub_cancel_right]
+  rfl
+
+                                                                                   
+theorem oneform_supercommute (v : ι → A) (x : Forms (k := k) (A := A) (ι := ι)) :
+    (∑ i, v i ⊗ₜ[k] gen (k := k) i) * x =
+      parity x * (∑ i, v i ⊗ₜ[k] gen (k := k) i) := by
+  induction x using TensorProduct.inductionOn with
+  | add x y hx hy => simp only [mul_add, map_add, add_mul, hx, hy]
+  | tmul a e =>
+    simp only [Finset.sum_mul, parity_tmul, Finset.mul_sum, Algebra.TensorProduct.tmul_mul_tmul]
+    apply Finset.sum_congr rfl
+    intro i _
+    rw [mul_comm (v i), gen_supercommute]
+
+theorem gradient_supercommute (pd : ι → Derivation k A A) (F : A)
+    (x : Forms (k := k) (A := A) (ι := ι)) :
+    gradient pd F * x = parity x * gradient pd F := by
+  rw [gradient_eq]
+  exact oneform_supercommute _ _
+
+theorem gradient_sq (pd : ι → Derivation k A A) (F : A) :
+    gradient pd F * gradient pd F = 0 := by
+  rw [gradient_eq]
+  exact oneform_sq _
+
+                                                                           
+def coeff : A →+* Forms (k := k) (A := A) (ι := ι) :=
+  Algebra.TensorProduct.includeLeftRingHom
+
+omit [Fintype ι] [DecidableEq ι] in
+@[simp] theorem coeff_apply (a : A) : coeff (k := k) (ι := ι) a = a ⊗ₜ[k] 1 := rfl
+
+omit [Fintype ι] [DecidableEq ι] in
+@[simp] theorem parity_coeff (a : A) : parity (coeff (k := k) (ι := ι) a) = coeff a := by
+  simp only [coeff_apply, parity_tmul, map_one]
+
+omit [Fintype ι] [DecidableEq ι] in
+theorem coeff_commute (a : A) (x : Forms (k := k) (A := A) (ι := ι)) :
+    coeff a * x = x * coeff a := constant_commute a x
+
+@[simp] theorem d_coeff (pd : ι → Derivation k A A) (a : A) :
+    d pd (coeff (k := k) (ι := ι) a) = gradient pd a := rfl
+
+                                                                                
+def cartier (pd : ι → Derivation k A A) (n : ℕ) (u : A) :
+    Forms (k := k) (A := A) (ι := ι) := coeff (u ^ n) * gradient pd u
+
+@[simp] theorem parity_cartier (pd : ι → Derivation k A A) (n : ℕ) (u : A) :
+    parity (cartier pd n u) = -cartier pd n u := by
+  simp only [cartier, map_mul, parity_coeff, parity_gradient, mul_neg]
+
+theorem gradient_mul_cartier (pd : ι → Derivation k A A) (n : ℕ) (u : A) :
+    gradient pd u * cartier pd n u = 0 := by
+  rw [cartier, ← mul_assoc, ← coeff_commute, mul_assoc, gradient_sq, mul_zero]
+
+theorem d_cartier (pd : ι → Derivation k A A)
+    (hcomm : ∀ i j a, pd i (pd j a) = pd j (pd i a)) (n : ℕ) (u : A) :
+    d pd (cartier pd n u) = 0 := by
+  induction n with
+  | zero =>
+      simp only [cartier, pow_zero, map_one, one_mul, gradient]
+      exact d_sq pd hcomm _
+  | succ n ih =>
+      have hs : cartier pd (n+1) u = coeff u * cartier pd n u := by
+        simp only [cartier, pow_succ', map_mul, mul_assoc]
+      rw [hs, d_mul, d_coeff, gradient_mul_cartier, ih, mul_zero, add_zero]
+
+                                                           
+def normal (pd : ι → Derivation k A A) (n : ℕ) (us : List A) :
+    Forms (k := k) (A := A) (ι := ι) := (us.map (cartier pd n)).prod
+
+@[simp] theorem normal_nil (pd : ι → Derivation k A A) (n : ℕ) : normal pd n [] = 1 := rfl
+@[simp] theorem normal_cons (pd : ι → Derivation k A A) (n : ℕ) (u : A) (us : List A) :
+    normal pd n (u :: us) = cartier pd n u * normal pd n us := rfl
+
+theorem d_one (pd : ι → Derivation k A A) :
+    d pd (1 : Forms (k := k) (A := A) (ι := ι)) = 0 := by
+  change d pd ((1 : A) ⊗ₜ[k] (1 : Ext (k := k) (ι := ι))) = 0
+  simp only [d_tmul, Derivation.map_one_eq_zero, TensorProduct.zero_tmul, Finset.sum_const_zero]
+
+theorem d_normal (pd : ι → Derivation k A A)
+    (hcomm : ∀ i j a, pd i (pd j a) = pd j (pd i a)) (n : ℕ) (us : List A) :
+    d pd (normal pd n us) = 0 := by
+  induction us with
+  | nil => exact d_one pd
+  | cons u us ih => rw [normal_cons, d_mul, d_cartier pd hcomm, ih, zero_mul, mul_zero, add_zero]
+
+theorem coeff_mul_normal (pd : ι → Derivation k A A) (n : ℕ) (us : List A)
+    (hpow : ∀ u ∈ us, u^(n+1) = 0) (u : A) (hu : u ∈ us) :
+    coeff u * normal pd n us = 0 := by
+  induction us with
+  | nil => simp at hu
+  | cons a us ih =>
+    rw [List.mem_cons] at hu
+    rcases hu with rfl | hu
+    · have hz : coeff u * cartier pd n u = 0 := by
+        rw [cartier, ← mul_assoc, ← map_mul, ← pow_succ', hpow u (by simp), map_zero, zero_mul]
+      rw [normal_cons, ← mul_assoc, hz, zero_mul]
+    · rw [normal_cons, ← mul_assoc, coeff_commute u (cartier pd n a), mul_assoc,
+        ih (fun v hv => hpow v (List.mem_cons_of_mem a hv)) hu, mul_zero]
+
+theorem gradient_mul_normal (pd : ι → Derivation k A A) (n : ℕ) (us : List A)
+    (u : A) (hu : u ∈ us) : gradient pd u * normal pd n us = 0 := by
+  induction us with
+  | nil => simp at hu
+  | cons a us ih =>
+    rw [List.mem_cons] at hu
+    rcases hu with rfl | hu
+    · rw [normal_cons, ← mul_assoc, gradient_mul_cartier, zero_mul]
+    · rw [normal_cons, ← mul_assoc, gradient_supercommute, parity_cartier]
+      simp only [neg_mul, mul_assoc, ih hu, mul_zero, neg_zero]
+
+theorem coeff_mul_normal_ideal (pd : ι → Derivation k A A) (n : ℕ) (us : List A)
+    (hpow : ∀ u ∈ us, u^(n+1) = 0) (F : A)
+    (hF : F ∈ Ideal.span {u | u ∈ us}) : coeff F * normal pd n us = 0 := by
+  induction hF using Submodule.span_induction with
+  | mem u hu => exact coeff_mul_normal pd n us hpow u hu
+  | zero => rw [map_zero, zero_mul]
+  | add a b ha hb hga hgb => rw [map_add, add_mul, hga, hgb, add_zero]
+  | smul a b hb hgb =>
+      change coeff (a*b) * normal pd n us = 0
+      rw [map_mul, mul_assoc, hgb, mul_zero]
+
+                                                                                     
+theorem delta_normal (pd : ι → Derivation k A A) (n : ℕ) (us : List A)
+    (hpow : ∀ u ∈ us, u^(n+1) = 0) (F : A)
+    (hF : F ∈ Ideal.span {u | u ∈ us}) : delta pd F (normal pd n us) = 0 := by
+  change gradient pd F * normal pd n us = 0
+  induction hF using Submodule.span_induction with
+  | mem u hu => exact gradient_mul_normal pd n us u hu
+  | zero => simp [gradient]
+  | add a b ha hb hga hgb =>
+      simp only [gradient, map_add, TensorProduct.add_tmul, add_mul] at *
+      rw [hga, hgb, add_zero]
+  | smul a b hb hgb =>
+      change gradient pd (a*b) * normal pd n us = 0
+      have hgrad : gradient pd (a*b) =
+          gradient pd a * coeff b + coeff a * gradient pd b := by
+        change d pd (coeff (k := k) (ι := ι) (a*b)) = _
+        rw [map_mul, d_mul, parity_coeff, d_coeff, d_coeff]
+      rw [hgrad, add_mul, mul_assoc, coeff_mul_normal_ideal pd n us hpow b hb, mul_zero, mul_assoc, hgb,
+        mul_zero, add_zero]
+
+                                                                    
+def contract (i : ι) : Module.End k (Forms (k := k) (A := A) (ι := ι)) :=
+  TensorProduct.map LinearMap.id (CliffordAlgebra.contractLeft (LinearMap.proj i))
+
+omit [Fintype ι] [DecidableEq ι] in
+@[simp] theorem contract_tmul (i : ι) (a : A) (e : Ext (k := k) (ι := ι)) :
+    contract i (a ⊗ₜ[k] e) = a ⊗ₜ[k] CliffordAlgebra.contractLeft (LinearMap.proj i) e := rfl
+
+omit [Fintype ι] [DecidableEq ι] in
+theorem contract_coeff (i : ι) (a : A) (x : Forms (k := k) (A := A) (ι := ι)) :
+    contract i (coeff a * x) = coeff a * contract i x := by
+  induction x using TensorProduct.inductionOn with
+  | add x y hx hy => simp only [mul_add, map_add, hx, hy]
+  | tmul b e => simp only [coeff_apply, Algebra.TensorProduct.tmul_mul_tmul, one_mul,
+      contract_tmul]
+
+theorem contraction_identity (pd : ι → Derivation k A A) (F : A) (i : ι)
+    (x : Forms (k := k) (A := A) (ι := ι)) :
+    delta pd F (contract i x) + contract i (delta pd F x) = coeff (pd i F) * x := by
+  induction x using TensorProduct.inductionOn with
+  | add x y hx hy => simp only [map_add, mul_add] at *; rw [add_add_add_comm, hx, hy]
+  | tmul a e =>
+      simp only [delta_apply, gradient_eq, contract_tmul, Finset.sum_mul,
+        Algebra.TensorProduct.tmul_mul_tmul, map_sum, gen,
+        CliffordAlgebra.contractLeft_ι_mul, LinearMap.proj_apply,
+        TensorProduct.tmul_sub, TensorProduct.tmul_smul]
+      simp only [← Finset.sum_add_distrib]
+      try simp only [add_sub_cancel_left]
+      simp [Pi.single_apply, coeff_apply]
+
+                                                                                 
+theorem ambient_primitive (pd : ι → Derivation k A A) (F : A)
+    (x : Forms (k := k) (A := A) (ι := ι)) (g : A) (h : ι → A)
+    (hcycle : delta pd F x = 0)
+    (herror : coeff (g - ∑ i, h i * pd i F) * x = 0) :
+    coeff g * x = delta pd F (∑ i, coeff (h i) * contract i x) := by
+  have hc (i : ι) : delta pd F (contract i x) = coeff (pd i F) * x := by
+    simpa only [hcycle, map_zero, add_zero] using contraction_identity pd F i x
+  have hx : coeff g * x = coeff (∑ i, h i * pd i F) * x := by
+    apply sub_eq_zero.mp
+    simpa only [map_sub, sub_mul] using herror
+  rw [hx, map_sum, map_sum, Finset.sum_mul]
+  apply Finset.sum_congr rfl
+  intro i _
+  rw [map_mul, mul_assoc, ← hc i, delta_apply, delta_apply, ← mul_assoc,
+    coeff_commute (h i) (gradient pd F), mul_assoc]
+
+                                                                          
+                                                
+theorem normal_primitive (pd : ι → Derivation k A A) (n : ℕ) (us : List A)
+    (hpow : ∀ u ∈ us, u^(n+1) = 0) (F g : A) (h : ι → A)
+    (hF : F ∈ Ideal.span {u | u ∈ us})
+    (hg : g - ∑ i, h i * pd i F ∈ Ideal.span {u | u ∈ us}) :
+    coeff g * normal pd n us =
+      delta pd F (∑ i, coeff (h i) * contract i (normal pd n us)) :=
+  ambient_primitive pd F _ g h (delta_normal pd n us hpow F hF)
+    (coeff_mul_normal_ideal pd n us hpow _ hg)
+
+end MixedForms
+end BoundaryOnly.FormalObstruction
+
+end
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/FrobeniusObstruction/MovingCharts.lean b/lean/OAI/Algebra/FrobeniusObstruction/MovingCharts.lean
new file mode 100644
index 0000000000000000000000000000000000000000..332138ba502ac49f7decf379559d8427b362246b
--- /dev/null
+++ b/lean/OAI/Algebra/FrobeniusObstruction/MovingCharts.lean
@@ -0,0 +1,314 @@
+import Mathlib
+import OAI.Algebra.FrobeniusObstruction.TangentCharts
+import OAI.Algebra.FrobeniusObstruction.VanishingIdeals
+
+namespace OAI
+
+noncomputable section
+open scoped BigOperators
+
+namespace BoundaryOnly.FormalObstruction
+open Frobenius
+variable {k : Type*} [Field k] {d : ℕ} {n : Fin d → ℕ}
+variable (ell : ℕ) (htwo : 1 < ell) [CharP k ell] [Fact ell.Prime]
+
+                                                                             
+def movingGraphCoordinates (a : SlopeVar d → ThreeParameters.Ring k) (b : Bool) :
+    GraphVar n → Frobenius.Ring (ι := InternalVar n) (k := ThreeParameters.Ring k) ell
+  | .inl i => @algebraMap (ThreeParameters.Ring k)
+      (Frobenius.Ring (ι := InternalVar n) (k := ThreeParameters.Ring k) ell) inferInstance inferInstance inferInstance (a i)
+  | .inr t => coordinate ell (b,t)
+
+theorem movingGraphCoordinates_pow (a : SlopeVar d → ThreeParameters.Ring k)
+    (ha : ∀ i, ThreeParameters.augmentation k (a i) = 0) (b : Bool) (v : GraphVar n) :
+    movingGraphCoordinates (n := n) ell a b v ^ ell = 0 := by
+  cases v with
+  | inl i =>
+    change (@algebraMap (ThreeParameters.Ring k)
+      (Frobenius.Ring (ι := InternalVar n) (k := ThreeParameters.Ring k) ell) inferInstance inferInstance inferInstance (a i)) ^ ell = 0
+    rw [← map_pow, ThreeParameters.augmentation_zero_pow k ell _ (ha i), map_zero]
+  | inr t => exact coordinate_pow ell (b,t)
+
+def movingGraphSlot (a : SlopeVar d → ThreeParameters.Ring k)
+    (ha : ∀ i, ThreeParameters.augmentation k (a i) = 0) (b : Bool) :
+    Frobenius.Ring (ι := GraphVar n) (k := k) ell →ₐ[k]
+      Frobenius.Ring (ι := InternalVar n) (k := ThreeParameters.Ring k) ell :=
+  eval ell (movingGraphCoordinates ell a b) (movingGraphCoordinates_pow ell a ha b)
+
+@[simp] theorem movingGraphSlot_coordinate (a : SlopeVar d → ThreeParameters.Ring k)
+    (ha : ∀ i, ThreeParameters.augmentation k (a i) = 0) (b : Bool) (v : GraphVar n) :
+    movingGraphSlot ell a ha b (coordinate ell v) = movingGraphCoordinates ell a b v :=
+  eval_coordinate ell _ _ _
+
+theorem reduce_movingGraphSlot (a : SlopeVar d → ThreeParameters.Ring k)
+    (ha : ∀ i, ThreeParameters.augmentation k (a i) = 0) (b : Bool) :
+    (reduction ell).comp (movingGraphSlot (n := n) ell a ha b) = graphSlot ell b := by
+  apply algHom_ext
+  intro v
+  simp only [AlgHom.comp_apply, movingGraphSlot_coordinate]
+  cases v with
+  | inl i => simp [movingGraphCoordinates, ha]
+  | inr t => simp [movingGraphCoordinates]
+
+def movingChartCoordinate (D : FormalData (k := k) n)
+    (a : SlopeVar d → ThreeParameters.Ring k)
+    (ha : ∀ i, ThreeParameters.augmentation k (a i) = 0) (c : InternalVar n) :
+    Frobenius.Ring (ι := InternalVar n) (k := ThreeParameters.Ring k) ell :=
+  movingGraphSlot ell a ha false (Ideal.Quotient.mk _ (D.Y c)) +
+    baseChange (l := ThreeParameters.Ring k) ell (fixedComplement ell D c)
+
+theorem movingChartCoordinate_pow (D : FormalData (k := k) n)
+    (a : SlopeVar d → ThreeParameters.Ring k)
+    (ha : ∀ i, ThreeParameters.augmentation k (a i) = 0) (c : InternalVar n) :
+    movingChartCoordinate ell D a ha c ^ ell = 0 := by
+  let : CharP (Frobenius.Ring (ι := InternalVar n) (k := ThreeParameters.Ring k) ell) ell :=
+    quotient_charP (Nat.Prime.pos Fact.out)
+  have h (c : InternalVar n) :
+      (Ideal.Quotient.mk (powerIdeal (k := k) ell) (D.Y c)) ^ ell = 0 := by
+    apply frobenius_zero_of_constant
+    rw [constantHom_mk, graph_constant_zero D c]
+    exact zero_pow (Nat.Prime.ne_zero Fact.out)
+  have hslot (a : SlopeVar d → ThreeParameters.Ring k)
+      (ha : ∀ i, ThreeParameters.augmentation k (a i) = 0) (b : Bool) (c : InternalVar n) :
+      (movingGraphSlot ell a ha b (Ideal.Quotient.mk _ (D.Y c))) ^ ell = 0 := by
+    rw [← map_pow, h, map_zero]
+  have hL : (baseChange (l := ThreeParameters.Ring k) ell (fixedComplement ell D c)) ^ ell = 0 := by
+    rw [← map_pow, fixedComplement_pow, map_zero]
+  change (movingGraphSlot ell a ha false (Ideal.Quotient.mk _ (D.Y c)) +
+    baseChange (l := ThreeParameters.Ring k) ell (fixedComplement ell D c)) ^ ell = 0
+  have hadd := add_pow_char
+    (movingGraphSlot ell a ha false (Ideal.Quotient.mk _ (D.Y c)))
+    (baseChange (l := ThreeParameters.Ring k) ell (fixedComplement ell D c)) ell
+  exact hadd.trans (by rw [hslot, hL, zero_add])
+
+def movingChart (D : FormalData (k := k) n)
+    (a : SlopeVar d → ThreeParameters.Ring k)
+    (ha : ∀ i, ThreeParameters.augmentation k (a i) = 0) :
+    Frobenius.Ring (ι := InternalVar n) (k := ThreeParameters.Ring k) ell →ₐ[ThreeParameters.Ring k]
+      Frobenius.Ring (ι := InternalVar n) (k := ThreeParameters.Ring k) ell :=
+  eval ell (movingChartCoordinate ell D a ha) (movingChartCoordinate_pow ell D a ha)
+
+@[simp] theorem movingChart_coordinate (D : FormalData (k := k) n)
+    (a : SlopeVar d → ThreeParameters.Ring k)
+    (ha : ∀ i, ThreeParameters.augmentation k (a i) = 0) (c : InternalVar n) :
+    movingChart ell D a ha (coordinate ell c) = movingChartCoordinate ell D a ha c :=
+  eval_coordinate ell _ _ _
+
+theorem movingChart_specialFiber (D : FormalData (k := k) n)
+    (a : SlopeVar d → ThreeParameters.Ring k)
+    (ha : ∀ i, ThreeParameters.augmentation k (a i) = 0)
+    (x : Frobenius.Ring (ι := InternalVar n) (k := ThreeParameters.Ring k) ell) :
+    reduction ell (movingChart ell D a ha x) = specialChart ell D (reduction ell x) := by
+  apply specialFiber_of_coordinates
+  intro c
+  rw [movingChart_coordinate, specialChart_coordinate, movingChartCoordinate, map_add]
+  rw [reduction_baseChange]
+  have h := AlgHom.congr_fun (reduce_movingGraphSlot (n := n) ell a ha false)
+    (Ideal.Quotient.mk (powerIdeal (k := k) ell) (D.Y c))
+  exact congrArg (fun x => x + fixedComplement ell D c) h
+
+                                                                        
+                                                                          
+include htwo in
+theorem movingChart_bijective (D : FormalData (k := k) n)
+    (a : SlopeVar d → ThreeParameters.Ring k)
+    (ha : ∀ i, ThreeParameters.augmentation k (a i) = 0) :
+    Function.Bijective (movingChart ell D a ha) :=
+  bijective_of_specialFiber ell (movingChart ell D a ha) (specialChartEquiv ell htwo D)
+    (movingChart_specialFiber ell D a ha)
+
+def movingChartEquiv (D : FormalData (k := k) n)
+    (a : SlopeVar d → ThreeParameters.Ring k)
+    (ha : ∀ i, ThreeParameters.augmentation k (a i) = 0) :
+    Frobenius.Ring (ι := InternalVar n) (k := ThreeParameters.Ring k) ell ≃ₐ[ThreeParameters.Ring k]
+      Frobenius.Ring (ι := InternalVar n) (k := ThreeParameters.Ring k) ell :=
+  AlgEquiv.ofBijective (movingChart ell D a ha) (movingChart_bijective ell htwo D a ha)
+
+end BoundaryOnly.FormalObstruction
+
+namespace BoundaryOnly.FormalObstruction.Frobenius
+variable {ι κ k : Type*} [Fintype ι] [DecidableEq ι]
+  [Fintype κ] [DecidableEq κ] [CommRing k]
+variable (ell : ℕ) [CharP k ell] [Fact ell.Prime]
+
+theorem centered_mk_pow (a : Series (ι := κ) (k := k))
+    (ha : MvPowerSeries.constantCoeff a = 0) :
+    (Ideal.Quotient.mk (powerIdeal (ι := κ) (k := k) ell) a) ^ ell = 0 := by
+  rw [← map_pow, Ideal.Quotient.eq_zero_iff_mem]
+  apply series_frobenius_mem
+  rw [ha]
+  exact zero_pow (Fact.out : ell.Prime).ne_zero
+
+omit [DecidableEq ι] in
+private theorem substitute_kernel (a : ι → Series (ι := κ) (k := k))
+    (ha : ∀ i, MvPowerSeries.constantCoeff (a i) = 0)
+    (p : Series (ι := ι) (k := k)) (hp : p ∈ powerIdeal ell) :
+    ((Ideal.Quotient.mkₐ k (powerIdeal (ι := κ) ell)).comp
+      (MvPowerSeries.substAlgHom (R := k)
+        (MvPowerSeries.hasSubst_of_constantCoeff_zero ha))) p = 0 := by
+  obtain ⟨c, rfl⟩ := Ideal.mem_span_range_iff_exists_fun.mp hp
+  simp only [map_sum, map_mul, map_pow, AlgHom.comp_apply, MvPowerSeries.substAlgHom_X]
+  apply Finset.sum_eq_zero
+  intro i _
+  change _ * (Ideal.Quotient.mk (powerIdeal (ι := κ) (k := k) ell) (a i)) ^ ell = 0
+  rw [centered_mk_pow ell (a i) (ha i), mul_zero]
+
+                                                                                 
+def substitute (a : ι → Series (ι := κ) (k := k))
+    (ha : ∀ i, MvPowerSeries.constantCoeff (a i) = 0) :
+    Ring (ι := ι) (k := k) ell →ₐ[k] Ring (ι := κ) (k := k) ell :=
+  Ideal.Quotient.liftₐ (powerIdeal (ι := ι) (k := k) ell)
+    ((Ideal.Quotient.mkₐ k (powerIdeal (ι := κ) (k := k) ell)).comp
+      (MvPowerSeries.substAlgHom (MvPowerSeries.hasSubst_of_constantCoeff_zero ha)))
+    (substitute_kernel ell a ha)
+
+omit [DecidableEq ι] in
+@[simp] theorem substitute_mk (a : ι → Series (ι := κ) (k := k))
+    (ha : ∀ i, MvPowerSeries.constantCoeff (a i) = 0) (p : Series (ι := ι) (k := k)) :
+    substitute ell a ha (Ideal.Quotient.mk _ p) =
+      Ideal.Quotient.mk _ (MvPowerSeries.subst a p) := by
+  change Ideal.Quotient.mk _ (MvPowerSeries.substAlgHom
+    (MvPowerSeries.hasSubst_of_constantCoeff_zero ha) p) = _
+  rw [MvPowerSeries.substAlgHom_apply]
+
+omit [DecidableEq ι] in
+@[simp] theorem substitute_coordinate (a : ι → Series (ι := κ) (k := k))
+    (ha : ∀ i, MvPowerSeries.constantCoeff (a i) = 0) (i : ι) :
+    substitute ell a ha (coordinate ell i) = Ideal.Quotient.mk _ (a i) := by
+  rw [coordinate, substitute_mk, MvPowerSeries.subst_X
+    (MvPowerSeries.hasSubst_of_constantCoeff_zero ha)]
+
+                                                                         
+                               
+theorem substitute_eq_eval (a : ι → Series (ι := κ) (k := k))
+    (ha : ∀ i, MvPowerSeries.constantCoeff (a i) = 0) :
+    substitute ell a ha = eval ell
+      (fun i => Ideal.Quotient.mk (powerIdeal (ι := κ) (k := k) ell) (a i))
+      (fun i => centered_mk_pow ell (a i) (ha i)) := by
+  apply algHom_ext
+  intro i
+  rw [substitute_coordinate, eval_coordinate]
+
+                                                                           
+                                                                                
+theorem eval_substitute {S : Type*} [CommRing S] [Algebra k S]
+    (a : ι → Series (ι := κ) (k := k))
+    (ha : ∀ i, MvPowerSeries.constantCoeff (a i) = 0)
+    (b : κ → S) (hb : ∀ j, b j ^ ell = 0)
+    (x : Ring (ι := ι) (k := k) ell) :
+    eval ell b hb (substitute ell a ha x) =
+      eval ell (fun i => eval ell b hb (Ideal.Quotient.mk _ (a i)))
+        (fun i => by
+          rw [← map_pow, centered_mk_pow ell (a i) (ha i), map_zero]) x := by
+  have h : (eval ell b hb).comp (substitute ell a ha) =
+      eval ell (fun i => eval ell b hb (Ideal.Quotient.mk _ (a i)))
+        (fun i => by rw [← map_pow, centered_mk_pow ell (a i) (ha i), map_zero]) := by
+    apply algHom_ext
+    intro i
+    simp only [AlgHom.comp_apply, substitute_coordinate, eval_coordinate]
+  exact AlgHom.congr_fun h x
+
+end BoundaryOnly.FormalObstruction.Frobenius
+
+namespace BoundaryOnly.FormalObstruction.Frobenius
+variable {ι k : Type*} [Fintype ι] [DecidableEq ι] [CommRing k]
+variable (ell : ℕ) (hell : 0 < ell)
+
+noncomputable def planeRestriction (s : Finset ι) :
+    Ring (ι := ι) (k := k) ell →ₐ[k] Ring (ι := ι) (k := k) ell :=
+  eval ell (fun i => if i ∈ s then 0 else coordinate ell i) (by
+    intro i
+    split_ifs
+    · exact zero_pow (by omega)
+    · exact coordinate_pow ell i)
+
+@[simp] theorem planeRestriction_coordinate (s : Finset ι) (i : ι) :
+    planeRestriction ell hell s (coordinate (k := k) ell i) =
+      if i ∈ s then 0 else coordinate ell i := by
+  exact eval_coordinate _ _ _ _
+
+noncomputable def coordinatePlaneIdeal (s : Finset ι) : Ideal (Ring (ι := ι) (k := k) ell) :=
+  Ideal.span (coordinate ell '' (s : Set ι))
+
+theorem coordinatePlaneIdeal_le_ker (s : Finset ι) :
+    coordinatePlaneIdeal (k := k) ell s ≤ RingHom.ker (planeRestriction (k := k) ell hell s) := by
+  apply Ideal.span_le.mpr
+  rintro _ ⟨i,hi,rfl⟩
+  change planeRestriction (k := k) ell hell s (coordinate ell i) = 0
+  change i ∈ s at hi
+  simp only [planeRestriction_coordinate, ite_eq_left hi]
+
+theorem planeRestriction_mod_ideal (s : Finset ι) :
+    (Ideal.Quotient.mkₐ k (coordinatePlaneIdeal (k := k) ell s)).comp
+      (planeRestriction ell hell s) = Ideal.Quotient.mkₐ k (coordinatePlaneIdeal (k := k) ell s) := by
+  refine algHom_ext (ι := ι) (k := k)
+    (S := Ring (ι := ι) (k := k) ell ⧸ coordinatePlaneIdeal (k := k) ell s) ell _ _ ?_
+  intro i
+  simp only [AlgHom.comp_apply, planeRestriction_coordinate]
+  by_cases hi : i ∈ s
+  · rw [ite_eq_left hi, map_zero]
+    symm
+    exact Ideal.Quotient.eq_zero_iff_mem.mpr (Ideal.subset_span ⟨i,hi,rfl⟩)
+  · rw [ite_eq_right hi]
+
+                                                         
+theorem planeRestriction_eq_zero_iff (s : Finset ι) (x : Ring (ι := ι) (k := k) ell) :
+    planeRestriction ell hell s x = 0 ↔ x ∈ coordinatePlaneIdeal ell s := by
+  constructor
+  · intro hx
+    apply Ideal.Quotient.eq_zero_iff_mem.mp
+    have h := AlgHom.congr_fun (planeRestriction_mod_ideal (k := k) ell hell s) x
+    simp only [AlgHom.comp_apply, hx, map_zero] at h
+    exact h.symm
+  · intro hx
+    exact coordinatePlaneIdeal_le_ker ell hell s hx
+
+def chartNormalIdeal (f : Ring (ι := ι) (k := k) ell ≃ₐ[k] Ring (ι := ι) (k := k) ell)
+    (s : Finset ι) : Ideal (Ring (ι := ι) (k := k) ell) :=
+  Ideal.span ((fun i => f (coordinate ell i)) '' (s : Set ι))
+
+                                                                             
+omit [Fintype ι] [DecidableEq ι] in
+theorem chartNormalIdeal_mem_iff
+    (f : Ring (ι := ι) (k := k) ell ≃ₐ[k] Ring (ι := ι) (k := k) ell)
+    (s : Finset ι) (x : Ring (ι := ι) (k := k) ell) :
+    x ∈ chartNormalIdeal ell f s ↔ f.symm x ∈ coordinatePlaneIdeal ell s := by
+  constructor
+  · intro hx
+    induction hx using Submodule.span_induction with
+    | mem x hx =>
+      obtain ⟨i,hi,rfl⟩ := hx
+      simp only [AlgEquiv.symm_apply_apply]
+      exact Ideal.subset_span ⟨i,hi,rfl⟩
+    | zero => simpa only [map_zero] using (coordinatePlaneIdeal (k := k) ell s).zero_mem
+    | add a b ha hb hfa hfb =>
+      rw [map_add]; exact (coordinatePlaneIdeal ell s).add_mem hfa hfb
+    | smul a b hb hfb =>
+      change f.symm (a*b) ∈ _
+      rw [map_mul]; exact Ideal.mul_mem_left _ _ hfb
+  · intro hx
+    have H : ∀ y ∈ coordinatePlaneIdeal (k := k) ell s, f y ∈ chartNormalIdeal ell f s := by
+      intro y hy
+      induction hy using Submodule.span_induction with
+      | mem y hy =>
+        obtain ⟨i,hi,rfl⟩ := hy
+        exact Ideal.subset_span ⟨i,hi,rfl⟩
+      | zero => simpa only [map_zero] using (chartNormalIdeal ell f s).zero_mem
+      | add a b ha hb hfa hfb =>
+        rw [map_add]; exact (chartNormalIdeal ell f s).add_mem hfa hfb
+      | smul a b hb hfb =>
+        change f (a*b) ∈ _
+        rw [map_mul]; exact Ideal.mul_mem_left _ _ hfb
+    simpa only [AlgEquiv.apply_symm_apply] using H (f.symm x) hx
+
+theorem chart_restriction_eq_zero_iff
+    (f : Ring (ι := ι) (k := k) ell ≃ₐ[k] Ring (ι := ι) (k := k) ell)
+    (s : Finset ι) (x : Ring (ι := ι) (k := k) ell) :
+    planeRestriction ell hell s (f.symm x) = 0 ↔ x ∈ chartNormalIdeal ell f s := by
+  rw [planeRestriction_eq_zero_iff, chartNormalIdeal_mem_iff]
+
+end BoundaryOnly.FormalObstruction.Frobenius
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/FrobeniusObstruction/NilpotentInverse.lean b/lean/OAI/Algebra/FrobeniusObstruction/NilpotentInverse.lean
new file mode 100644
index 0000000000000000000000000000000000000000..d747ab348f9387d544fd9ece4d05ae489c02b750
--- /dev/null
+++ b/lean/OAI/Algebra/FrobeniusObstruction/NilpotentInverse.lean
@@ -0,0 +1,94 @@
+import Mathlib
+
+namespace OAI
+
+noncomputable section
+open scoped BigOperators
+
+namespace BoundaryOnly.FormalObstruction
+namespace NilpotentInverse
+variable {k A : Type*} [Field k] [CommRing A] [Algebra k A]
+
+                                                                             
+                                                                 
+theorem difference_pow (I : Ideal A) (f : A →ₐ[k] A)
+    (haf : ∀ x : A, f x - x ∈ I)
+    (hfirst : ∀ x ∈ I, f x - x ∈ I^2) (n : ℕ) :
+    ∀ x ∈ I^n, f x - x ∈ I^(n+1) := by
+  induction n with
+  | zero => intro x _; simpa only [zero_add, pow_one] using haf x
+  | succ n ih =>
+      intro x hx
+      rw [pow_succ] at hx
+      refine Submodule.mul_induction_on hx ?_ ?_
+      · intro a ha b hb
+        have hfb : f b ∈ I := by
+          simpa only [sub_add_cancel] using I.add_mem (haf b) hb
+        have h₁ : (f a - a) * f b ∈ I^(n+1+1) := by
+          rw [pow_succ]
+          exact Ideal.mul_mem_mul (ih a ha) hfb
+        have h₂ : a * (f b - b) ∈ I^(n+1+1) := by
+          rw [show n+1+1 = n+2 by omega, pow_add]
+          exact Ideal.mul_mem_mul ha (hfirst b hb)
+        convert (I^(n+1+1)).add_mem h₁ h₂ using 1
+        simp only [map_mul]
+        ring
+      · intro a b ha hb
+        convert (I^(n+1+1)).add_mem ha hb using 1
+        simp only [map_add]
+        ring
+                                                                     
+                                                                      
+theorem injective_of_first_jet (I : Ideal A) (hI : IsNilpotent I) (f : A →ₐ[k] A)
+    (haf : ∀ x : A, f x - x ∈ I)
+    (hfirst : ∀ x ∈ I, f x - x ∈ I^2) : Function.Injective f := by
+  apply (injective_iff_map_eq_zero f).mpr
+  intro x hx
+  have hn (n : ℕ) : x ∈ I^n := by
+    induction n with
+    | zero => simp only [pow_zero, Ideal.one_eq_top, Submodule.mem_top]
+    | succ n ih =>
+        have ht := difference_pow I f haf hfirst n x ih
+        rw [hx, zero_sub] at ht
+        exact (I^(n+1)).neg_mem_iff.mp ht
+  obtain ⟨n, hn₀⟩ := hI
+  have ht := hn n
+  rw [hn₀] at ht
+  exact ht
+
+theorem bijective_of_first_jet [Module.Finite k A] (I : Ideal A) (hI : IsNilpotent I)
+    (f : A →ₐ[k] A)
+    (haf : ∀ x : A, f x - x ∈ I)
+    (hfirst : ∀ x ∈ I, f x - x ∈ I^2) : Function.Bijective f := by
+  have hi := injective_of_first_jet I hI f haf hfirst
+  exact ⟨hi, (LinearMap.injective_iff_surjective (f := f.toLinearMap)).mp hi⟩
+
+                                                                           
+theorem first_jet_of_generators {σ : Type*} (c : σ → A) (f : A →ₐ[k] A)
+    (haf : ∀ x : A, f x - x ∈ Ideal.span (Set.range c))
+    (hgen : ∀ i, f (c i) - c i ∈ (Ideal.span (Set.range c))^2) :
+    ∀ x ∈ Ideal.span (Set.range c), f x - x ∈ (Ideal.span (Set.range c))^2 := by
+  intro x hx
+  induction hx using Submodule.span_induction with
+  | mem y hy => obtain ⟨i, rfl⟩ := hy; exact hgen i
+  | zero => simp
+  | add a b ha hb ha₁ hb₁ =>
+      convert (Ideal.span (Set.range c)^2).add_mem ha₁ hb₁ using 1
+      simp only [map_add]
+      ring
+  | smul a b hb hb₁ =>
+      change f (a*b) - a*b ∈ _
+      have ht : (f a - a)*b ∈ Ideal.span (Set.range c)^2 := by
+        rw [pow_two]
+        exact Ideal.mul_mem_mul (haf a) hb
+      have ht' := (Ideal.span (Set.range c)^2).mul_mem_left (f a) hb₁
+      convert (Ideal.span (Set.range c)^2).add_mem ht' ht using 1
+      simp only [map_mul]
+      ring
+
+end NilpotentInverse
+end BoundaryOnly.FormalObstruction
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/FrobeniusObstruction/NormalPrimitives.lean b/lean/OAI/Algebra/FrobeniusObstruction/NormalPrimitives.lean
new file mode 100644
index 0000000000000000000000000000000000000000..27be754ef2d2198831d2ceccc900afda73dfd895
--- /dev/null
+++ b/lean/OAI/Algebra/FrobeniusObstruction/NormalPrimitives.lean
@@ -0,0 +1,415 @@
+import Mathlib
+import OAI.Algebra.FrobeniusObstruction.GraphPotential
+import OAI.Algebra.FrobeniusObstruction.GlobalForms
+
+namespace OAI
+
+noncomputable section
+open scoped BigOperators
+
+noncomputable section
+open scoped BigOperators TensorProduct
+
+namespace BoundaryOnly.FormalObstruction.Frobenius
+open MixedForms
+variable {ι k : Type*} [Fintype ι] [DecidableEq ι] [CommRing k]
+variable (ell : ℕ) [CharP k ell]
+
+                                                                                     
+def normalCoordinateList
+    (e : Ring (ι := ι) (k := k) ell ≃ₐ[k] Ring (ι := ι) (k := k) ell)
+    (s : Finset ι) : List (Ring (ι := ι) (k := k) ell) :=
+  s.toList.map (fun i => e (coordinate ell i))
+
+omit [Fintype ι] [DecidableEq ι] [CharP k ell] in
+theorem normalCoordinateList_span
+    (e : Ring (ι := ι) (k := k) ell ≃ₐ[k] Ring (ι := ι) (k := k) ell)
+    (s : Finset ι) : Ideal.span {u | u ∈ normalCoordinateList ell e s} =
+      chartNormalIdeal ell e s := by
+  congr 1
+  ext u
+  simp only [normalCoordinateList, List.mem_map, Finset.mem_toList,
+    Set.mem_ofPred_eq, Set.mem_image, Finset.mem_coe]
+
+omit [Fintype ι] [DecidableEq ι] [CharP k ell] in
+theorem normalCoordinateList_pow (hell : 0 < ell)
+    (e : Ring (ι := ι) (k := k) ell ≃ₐ[k] Ring (ι := ι) (k := k) ell)
+    (s : Finset ι) (u : Ring (ι := ι) (k := k) ell)
+    (hu : u ∈ normalCoordinateList ell e s) : u ^ (ell-1+1) = 0 := by
+  obtain ⟨i, _, rfl⟩ := List.mem_map.mp hu
+  rw [Nat.sub_add_cancel hell, ← map_pow, coordinate_pow, map_zero]
+
+def chartNormal
+    (e : Ring (ι := ι) (k := k) ell ≃ₐ[k] Ring (ι := ι) (k := k) ell)
+    (s : Finset ι) : Forms (k := k) (A := Ring (ι := ι) (k := k) ell) (ι := ι) :=
+  normal (partialDeriv ell) (ell-1) (normalCoordinateList ell e s)
+
+theorem chartNormal_d
+    (e : Ring (ι := ι) (k := k) ell ≃ₐ[k] Ring (ι := ι) (k := k) ell)
+    (s : Finset ι) : d (partialDeriv ell) (chartNormal ell e s) = 0 :=
+  d_normal _ (partial_commute ell) _ _
+
+theorem chartNormal_annihilate (hell : 0 < ell)
+    (e : Ring (ι := ι) (k := k) ell ≃ₐ[k] Ring (ι := ι) (k := k) ell)
+    (s : Finset ι) (g : Ring (ι := ι) (k := k) ell)
+    (hg : g ∈ chartNormalIdeal ell e s) : coeff g * chartNormal ell e s = 0 :=
+  coeff_mul_normal_ideal _ _ _ (normalCoordinateList_pow ell hell e s) g
+    (by rwa [normalCoordinateList_span])
+
+theorem chartNormal_delta (hell : 0 < ell)
+    (e : Ring (ι := ι) (k := k) ell ≃ₐ[k] Ring (ι := ι) (k := k) ell)
+    (s : Finset ι) (F : Ring (ι := ι) (k := k) ell)
+    (hF : F ∈ chartNormalIdeal ell e s) :
+    delta (partialDeriv ell) F (chartNormal ell e s) = 0 :=
+  delta_normal _ _ _ (normalCoordinateList_pow ell hell e s) F
+    (by rwa [normalCoordinateList_span])
+
+theorem chartNormal_primitive (hell : 0 < ell)
+    (e : Ring (ι := ι) (k := k) ell ≃ₐ[k] Ring (ι := ι) (k := k) ell)
+    (s : Finset ι) (F g : Ring (ι := ι) (k := k) ell)
+    (h : ι → Ring (ι := ι) (k := k) ell)
+    (hF : F ∈ chartNormalIdeal ell e s)
+    (hg : g - ∑ i, h i * partialDeriv ell i F ∈ chartNormalIdeal ell e s) :
+    coeff g * chartNormal ell e s = delta (partialDeriv ell) F
+      (∑ i, coeff (h i) * contract i (chartNormal ell e s)) :=
+  normal_primitive _ _ _ (normalCoordinateList_pow ell hell e s) F g h
+    (by rwa [normalCoordinateList_span]) (by rwa [normalCoordinateList_span])
+
+end BoundaryOnly.FormalObstruction.Frobenius
+
+namespace BoundaryOnly.FormalObstruction
+open Frobenius MixedForms
+variable {k : Type*} [Field k] {d : ℕ} {n : Fin d → ℕ}
+variable (ell : ℕ) (htwo : 1 < ell) [CharP k ell] [Fact ell.Prime]
+
+                                                                                  
+                                                                              
+abbrev ParameterForms := Forms (k := k)
+  (A := ParameterScalar (n := n) (k := k) ell) (ι := InternalVar n)
+
+def parameterPartial (i : InternalVar n) :
+    Derivation k (ParameterScalar (n := n) (k := k) ell)
+      (ParameterScalar (n := n) (k := k) ell) :=
+  (partialDeriv (k := ThreeParameters.Ring k) ell i).restrictScalars k
+
+omit [Fact ell.Prime] in
+@[simp] theorem parameterPartial_apply (i : InternalVar n)
+    (x : ParameterScalar (n := n) (k := k) ell) :
+    parameterPartial ell i x = partialDeriv ell i x := rfl
+
+omit [Fact ell.Prime] in
+theorem parameterPartial_commute (i j : InternalVar n)
+    (x : ParameterScalar (n := n) (k := k) ell) :
+    parameterPartial ell i (parameterPartial ell j x) =
+    parameterPartial ell j (parameterPartial ell i x) := partial_commute ell i j x
+
+def movingNormal (D : FormalData (k := k) n)
+    (a : SlopeVar d → ThreeParameters.Ring k)
+    (ha : ∀ i, ThreeParameters.augmentation k (a i) = 0) :
+    ParameterForms (n := n) (k := k) ell :=
+  normal (parameterPartial ell) (ell-1)
+    (normalCoordinateList ell (movingChartEquiv ell htwo D a ha).symm normalIndices)
+
+theorem movingNormal_d (D : FormalData (k := k) n)
+    (a : SlopeVar d → ThreeParameters.Ring k)
+    (ha : ∀ i, ThreeParameters.augmentation k (a i) = 0) :
+    MixedForms.d (parameterPartial ell) (movingNormal ell htwo D a ha) = 0 :=
+  d_normal _ (parameterPartial_commute ell) _ _
+
+theorem movingNormal_delta (D : FormalData (k := k) n)
+    (a : SlopeVar d → ThreeParameters.Ring k)
+    (ha : ∀ i, ThreeParameters.augmentation k (a i) = 0) :
+    delta (parameterPartial ell) (movingPotential ell D a ha)
+      (movingNormal ell htwo D a ha) = 0 :=
+  delta_normal _ _ _ (normalCoordinateList_pow ell (Nat.Prime.pos Fact.out) _ _)
+    _ (by rw [normalCoordinateList_span]; exact movingPotential_mem_normalIdeal ell htwo D a ha)
+
+theorem movingNormal_annihilate (D : FormalData (k := k) n)
+    (a : SlopeVar d → ThreeParameters.Ring k)
+    (ha : ∀ i, ThreeParameters.augmentation k (a i) = 0)
+    (g : ParameterScalar (n := n) (k := k) ell)
+    (hg : g ∈ chartNormalIdeal ell (movingChartEquiv ell htwo D a ha).symm normalIndices) :
+    coeff g * movingNormal ell htwo D a ha = 0 :=
+  coeff_mul_normal_ideal _ _ _ (normalCoordinateList_pow ell (Nat.Prime.pos Fact.out) _ _)
+    g (by rwa [normalCoordinateList_span])
+
+                                                                                 
+theorem movingNormal_primitive (D : FormalData (k := k) n)
+    (a : SlopeVar d → ThreeParameters.Ring k)
+    (ha : ∀ i, ThreeParameters.augmentation k (a i) = 0)
+    (g : MvPowerSeries (GraphVar n) k) (hg : g ∈ gradientIdeal n D.P D.Y) :
+    ∃ eta : ParameterForms (n := n) (k := k) ell,
+      delta (parameterPartial ell) (movingPotential ell D a ha) eta =
+        coeff ((movingChartEquiv ell htwo D a ha).symm
+          (movingGraphSlot ell a ha false (Ideal.Quotient.mk _ g))) *
+            movingNormal ell htwo D a ha := by
+  obtain ⟨h, hh⟩ := graphIdeal_ambient_discrepancy ell htwo D a ha g hg
+  refine ⟨∑ i, coeff (h i) * contract i (movingNormal ell htwo D a ha), ?_⟩
+  apply Eq.symm
+  apply normal_primitive _ _ _ (normalCoordinateList_pow ell (Nat.Prime.pos Fact.out) _ _) _ _ h
+  · rw [normalCoordinateList_span]; exact movingPotential_mem_normalIdeal ell htwo D a ha
+  · rw [normalCoordinateList_span]; exact hh
+
+                                                                           
+theorem movingNormal_cubic_primitive (D : FormalData (k := k) n)
+    (a : SlopeVar d → ThreeParameters.Ring k)
+    (ha : ∀ i, ThreeParameters.augmentation k (a i) = 0) (i j l : Fin d) :
+    ∃ eta : ParameterForms (n := n) (k := k) ell,
+      delta (parameterPartial ell) (movingPotential ell D a ha) eta =
+        coeff (@algebraMap (ThreeParameters.Ring k) (ParameterScalar (n := n) (k := k) ell)
+          inferInstance inferInstance inferInstance (a (i,0) * a (j,0) * a (l,0))) *
+            movingNormal ell htwo D a ha := by
+  obtain ⟨eta, he⟩ := movingNormal_primitive ell htwo D a ha
+    (slope n i * slope n j * slope n l) (D.positive_cubic i j l)
+  have hs : (movingChartEquiv ell htwo D a ha).symm
+      (movingGraphSlot ell a ha false
+        (Ideal.Quotient.mk _ (slope n i * slope n j * slope n l))) =
+      @algebraMap (ThreeParameters.Ring k) (ParameterScalar (n := n) (k := k) ell)
+        inferInstance inferInstance inferInstance (a (i,0) * a (j,0) * a (l,0)) := by
+    simp only [map_mul, slope]
+    change (movingChartEquiv ell htwo D a ha).symm
+      (movingGraphSlot ell a ha false (coordinate ell (.inl (i,0)))) *
+        (movingChartEquiv ell htwo D a ha).symm
+          (movingGraphSlot ell a ha false (coordinate ell (.inl (j,0)))) *
+        (movingChartEquiv ell htwo D a ha).symm
+          (movingGraphSlot ell a ha false (coordinate ell (.inl (l,0)))) = _
+    simp only [movingGraphSlot_coordinate, movingGraphCoordinates, AlgEquiv.commutes]
+  rw [hs] at he
+  exact ⟨eta, he⟩
+
+end BoundaryOnly.FormalObstruction
+
+namespace BoundaryOnly.FormalObstruction.Frobenius
+variable {ι k l : Type*} [Fintype ι] [DecidableEq ι] [CommRing k] [CommRing l]
+variable (ell : ℕ) [CharP k ell] [CharP l ell]
+
+omit [Fintype ι] [DecidableEq ι] [CharP k ell] [CharP l ell] in
+theorem series_pderiv_map (f : k →+* l) (i : ι) (x : Series (ι := ι) (k := k)) :
+    MvPowerSeries.map f (MvPowerSeries.pderiv i x) =
+      MvPowerSeries.pderiv i (MvPowerSeries.map f x) := by
+  ext e
+  simp only [MvPowerSeries.coeff_map, MvPowerSeries.coeff_pderiv, map_mul, map_add, map_natCast, map_one]
+
+omit [DecidableEq ι] in
+theorem mapCoefficients_partial (f : k →+* l) (i : ι)
+    (x : Ring (ι := ι) (k := k) ell) :
+    mapCoefficients ell f (partialDeriv ell i x) =
+      partialDeriv ell i (mapCoefficients ell f x) := by
+  obtain ⟨p,rfl⟩ := Ideal.Quotient.mk_surjective x
+  simp only [partial_mk, mapCoefficients_mk, series_pderiv_map]
+
+variable [Algebra k l]
+omit [DecidableEq ι] in
+theorem baseChange_partial (i : ι)
+    (x : Ring (ι := ι) (k := k) ell) :
+    baseChange (l := l) ell (partialDeriv ell i x) =
+      partialDeriv ell i (baseChange (l := l) ell x) :=
+  mapCoefficients_partial ell (algebraMap k l) i x
+
+end BoundaryOnly.FormalObstruction.Frobenius
+
+namespace BoundaryOnly.FormalObstruction.MixedForms
+open scoped TensorProduct
+variable {k A B ι : Type*} [CommRing k] [CommRing A] [CommRing B]
+  [Algebra k A] [Algebra k B] [Fintype ι] [DecidableEq ι]
+
+                                                         
+def coefficientMap (f : A →ₐ[k] B) :
+    Forms (k := k) (A := A) (ι := ι) →ₐ[k] Forms (k := k) (A := B) (ι := ι) :=
+  Algebra.TensorProduct.map f (AlgHom.id k _)
+
+omit [Fintype ι] [DecidableEq ι] in
+@[simp] theorem coefficientMap_tmul (f : A →ₐ[k] B)
+    (a : A) (e : Ext (k := k) (ι := ι)) :
+    coefficientMap f (a ⊗ₜ[k] e) = f a ⊗ₜ[k] e := rfl
+
+omit [Fintype ι] [DecidableEq ι] in
+@[simp] theorem coefficientMap_coeff (f : A →ₐ[k] B) (a : A) :
+    coefficientMap (ι := ι) f (coeff a) = coeff (f a) := rfl
+
+ theorem coefficientMap_d (f : A →ₐ[k] B)
+    (pA : ι → Derivation k A A) (pB : ι → Derivation k B B)
+    (hp : ∀ i a, f (pA i a) = pB i (f a))
+    (x : Forms (k := k) (A := A) (ι := ι)) :
+    coefficientMap f (d pA x) = d pB (coefficientMap f x) := by
+  induction x using TensorProduct.inductionOn with
+  | add x y hx hy => simp only [map_add, hx, hy]
+  | tmul a e => simp only [d_tmul, coefficientMap_tmul, map_sum, hp]
+
+ theorem coefficientMap_gradient (f : A →ₐ[k] B)
+    (pA : ι → Derivation k A A) (pB : ι → Derivation k B B)
+    (hp : ∀ i a, f (pA i a) = pB i (f a)) (F : A) :
+    coefficientMap f (gradient pA F) = gradient pB (f F) := by
+  exact coefficientMap_d f pA pB hp (coeff F)
+
+ theorem coefficientMap_delta (f : A →ₐ[k] B)
+    (pA : ι → Derivation k A A) (pB : ι → Derivation k B B)
+    (hp : ∀ i a, f (pA i a) = pB i (f a)) (F : A)
+    (x : Forms (k := k) (A := A) (ι := ι)) :
+    coefficientMap f (delta pA F x) = delta pB (f F) (coefficientMap f x) := by
+  simp only [delta_apply, map_mul, coefficientMap_gradient f pA pB hp]
+
+ theorem coefficientMap_cartier (f : A →ₐ[k] B)
+    (pA : ι → Derivation k A A) (pB : ι → Derivation k B B)
+    (hp : ∀ i a, f (pA i a) = pB i (f a)) (e : ℕ) (u : A) :
+    coefficientMap f (cartier pA e u) = cartier pB e (f u) := by
+  simp only [cartier, map_mul, coefficientMap_coeff, map_pow,
+    coefficientMap_gradient f pA pB hp]
+
+ theorem coefficientMap_normal (f : A →ₐ[k] B)
+    (pA : ι → Derivation k A A) (pB : ι → Derivation k B B)
+    (hp : ∀ i a, f (pA i a) = pB i (f a)) (e : ℕ) (us : List A) :
+    coefficientMap f (normal pA e us) = normal pB e (us.map f) := by
+  induction us with
+  | nil => simp only [normal, List.map_nil, List.prod_nil, map_one]
+  | cons u us ih =>
+      simpa only [normal, List.map_cons, List.prod_cons, map_mul,
+        coefficientMap_cartier f pA pB hp] using congrArg
+        (fun x => cartier pB e (f u) * x) ih
+
+end BoundaryOnly.FormalObstruction.MixedForms
+
+namespace BoundaryOnly.FormalObstruction
+open Frobenius MixedForms
+variable {k : Type*} [Field k] {d : ℕ} {n : Fin d → ℕ}
+variable (ell : ℕ) (htwo : 1 < ell) [CharP k ell] [Fact ell.Prime]
+
+theorem movingChart_inverse_specialFiber (D : FormalData (k := k) n)
+    (a : SlopeVar d → ThreeParameters.Ring k)
+    (ha : ∀ i, ThreeParameters.augmentation k (a i) = 0)
+    (x : ParameterScalar (n := n) (k := k) ell) :
+    reduction ell ((movingChartEquiv ell htwo D a ha).symm x) =
+      (specialChartEquiv ell htwo D).symm (reduction ell x) := by
+  apply (specialChartEquiv ell htwo D).injective
+  rw [AlgEquiv.apply_symm_apply]
+  change specialChart ell D (reduction ell ((movingChartEquiv ell htwo D a ha).symm x)) = _
+  rw [← movingChart_specialFiber ell D a ha]
+  change reduction ell ((movingChartEquiv ell htwo D a ha)
+    ((movingChartEquiv ell htwo D a ha).symm x)) = _
+  rw [AlgEquiv.apply_symm_apply]
+
+def specialNormal (D : FormalData (k := k) n) :
+    Forms (k := k) (A := Frobenius.Ring (ι := InternalVar n) (k := k) ell)
+      (ι := InternalVar n) :=
+  chartNormal ell (specialChartEquiv ell htwo D).symm normalIndices
+
+theorem reduce_normalList (D : FormalData (k := k) n)
+    (a : SlopeVar d → ThreeParameters.Ring k)
+    (ha : ∀ i, ThreeParameters.augmentation k (a i) = 0) :
+    (normalCoordinateList ell (movingChartEquiv ell htwo D a ha).symm normalIndices).map
+      (reduction ell) = normalCoordinateList ell (specialChartEquiv ell htwo D).symm normalIndices := by
+  simp only [normalCoordinateList, List.map_map]
+  apply List.map_congr_left
+  intro i hi
+  simp only [Function.comp_apply, movingChart_inverse_specialFiber, reduction_coordinate]
+
+theorem reduce_movingNormal (D : FormalData (k := k) n)
+    (a : SlopeVar d → ThreeParameters.Ring k)
+    (ha : ∀ i, ThreeParameters.augmentation k (a i) = 0) :
+    coefficientMap (reduction ell) (movingNormal ell htwo D a ha) =
+      specialNormal ell htwo D := by
+  have hp (i : InternalVar n) (x : ParameterScalar (n := n) (k := k) ell) :
+      reduction ell (parameterPartial ell i x) = partialDeriv ell i (reduction ell x) :=
+    mapCoefficients_partial ell (ThreeParameters.augmentation k) i x
+  have hn := coefficientMap_normal (reduction (ι := InternalVar n) (k := k) ell)
+    (parameterPartial ell) (partialDeriv ell) hp (ell-1)
+    (normalCoordinateList ell (movingChartEquiv ell htwo D a ha).symm normalIndices)
+  rw [reduce_normalList ell htwo D a ha] at hn
+  exact hn
+
+end BoundaryOnly.FormalObstruction
+
+namespace BoundaryOnly.FormalObstruction
+open Frobenius MixedForms
+variable {k : Type*} [Field k] {d : ℕ} {n : Fin d → ℕ}
+variable (ell : ℕ) (htwo : 1 < ell) [CharP k ell] [Fact ell.Prime]
+
+def specialAmbient : Frobenius.Ring (ι := AmbientVar n) (k := k) ell →ₐ[k]
+    Frobenius.Ring (ι := InternalVar n) (k := k) ell :=
+  eval ell (Sum.elim (fun _ => 0) (coordinate ell)) (by
+    intro v
+    cases v with
+    | inl _ => exact zero_pow (Nat.Prime.ne_zero Fact.out)
+    | inr c => exact coordinate_pow ell c)
+
+omit [CharP k ell] in
+@[simp] theorem specialAmbient_slope (i : SlopeVar d) :
+    specialAmbient (n := n) (k := k) ell (coordinate ell (.inl i)) = 0 :=
+  eval_coordinate _ _ _ _
+
+omit [CharP k ell] in
+@[simp] theorem specialAmbient_internal (i : InternalVar n) :
+    specialAmbient (n := n) (k := k) ell (coordinate ell (.inr i)) = coordinate ell i :=
+  eval_coordinate _ _ _ _
+
+ theorem reduce_ambientSlot (a : SlopeVar d → ThreeParameters.Ring k)
+    (ha : ∀ i, ThreeParameters.augmentation k (a i) = 0)
+    (x : Frobenius.Ring (ι := AmbientVar n) (k := k) ell) :
+    reduction ell (ambientSlot ell a ha x) = specialAmbient ell x := by
+  have h : (reduction ell).comp (ambientSlot ell a ha) =
+      specialAmbient (n := n) (k := k) ell := by
+    apply algHom_ext
+    intro v
+    simp only [AlgHom.comp_apply, ambientSlot_coordinate]
+    cases v with
+    | inl i => simp only [ambientCoordinates, reduction_base, ha, map_zero, specialAmbient_slope]
+    | inr c => simp only [ambientCoordinates, reduction_coordinate, specialAmbient_internal]
+  exact AlgHom.congr_fun h x
+
+def specialPotential (D : FormalData (k := k) n) :
+    Frobenius.Ring (ι := InternalVar n) (k := k) ell :=
+  specialAmbient ell (Ideal.Quotient.mk _ (potential n D.P))
+
+ theorem reduce_movingPotential (D : FormalData (k := k) n)
+    (a : SlopeVar d → ThreeParameters.Ring k)
+    (ha : ∀ i, ThreeParameters.augmentation k (a i) = 0) :
+    reduction ell (movingPotential ell D a ha) = specialPotential ell D :=
+  reduce_ambientSlot ell a ha _
+
+ theorem specialNormal_d (D : FormalData (k := k) n) :
+    MixedForms.d (partialDeriv ell) (specialNormal ell htwo D) = 0 :=
+  chartNormal_d ell _ _
+
+omit [Fact ell.Prime] in
+theorem parameter_reduction_partial (i : InternalVar n)
+    (x : ParameterScalar (n := n) (k := k) ell) :
+    reduction ell (parameterPartial ell i x) = partialDeriv ell i (reduction ell x) :=
+  mapCoefficients_partial ell (ThreeParameters.augmentation k) i x
+
+ theorem specialNormal_delta (D : FormalData (k := k) n) :
+    delta (partialDeriv ell) (specialPotential ell D) (specialNormal ell htwo D) = 0 := by
+  let a : SlopeVar d → ThreeParameters.Ring k := fun _ => 0
+  have ha : ∀ i, ThreeParameters.augmentation k (a i) = 0 := fun _ => map_zero _
+  have h := congrArg (coefficientMap (reduction ell)) (movingNormal_delta ell htwo D a ha)
+  rw [coefficientMap_delta _ _ _ (parameter_reduction_partial ell),
+    reduce_movingPotential, reduce_movingNormal, map_zero] at h
+  exact h
+
+                                                                                
+theorem specialNormal_primitive (D : FormalData (k := k) n)
+    (g : MvPowerSeries (GraphVar n) k) (hg : g ∈ gradientIdeal n D.P D.Y) :
+    ∃ eta : Forms (k := k) (A := Frobenius.Ring (ι := InternalVar n) (k := k) ell)
+        (ι := InternalVar n),
+      delta (partialDeriv ell) (specialPotential ell D) eta =
+        coeff ((specialChartEquiv ell htwo D).symm
+          (graphSlot ell false (Ideal.Quotient.mk _ g))) * specialNormal ell htwo D := by
+  let a : SlopeVar d → ThreeParameters.Ring k := fun _ => 0
+  have ha : ∀ i, ThreeParameters.augmentation k (a i) = 0 := fun _ => map_zero _
+  obtain ⟨eta, he⟩ := movingNormal_primitive ell htwo D a ha g hg
+  refine ⟨coefficientMap (reduction ell) eta, ?_⟩
+  have h := congrArg (coefficientMap (reduction ell)) he
+  rw [coefficientMap_delta _ _ _ (parameter_reduction_partial ell),
+    reduce_movingPotential, map_mul, coefficientMap_coeff,
+    movingChart_inverse_specialFiber, reduce_movingNormal] at h
+  have hr := AlgHom.congr_fun (reduce_movingGraphSlot ell a ha false)
+    (Ideal.Quotient.mk _ g)
+  change reduction ell (movingGraphSlot ell a ha false (Ideal.Quotient.mk _ g)) = _ at hr
+  rw [hr] at h
+  exact h
+
+end BoundaryOnly.FormalObstruction
+
+end
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/FrobeniusObstruction/Obstruction.lean b/lean/OAI/Algebra/FrobeniusObstruction/Obstruction.lean
new file mode 100644
index 0000000000000000000000000000000000000000..3f62c483388749e22c4f7db304a957645c1afa10
--- /dev/null
+++ b/lean/OAI/Algebra/FrobeniusObstruction/Obstruction.lean
@@ -0,0 +1,67 @@
+import Mathlib
+import OAI.Algebra.FrobeniusObstruction.LiftProducts
+
+namespace OAI
+
+noncomputable section
+open scoped BigOperators
+
+namespace BoundaryOnly.FormalObstruction.FixedResidue
+open Frobenius MixedForms
+variable {ι k : Type*} [Fintype ι] [DecidableEq ι] [Field k]
+variable (ell : ℕ) (hell : 0 < ell)
+
+ omit [DecidableEq ι] in
+ theorem scalar_eq_fixedResidue (v : Ext (k := k) (ι := ι) →ₗ[k] k) :
+    scalar ell hell v = fixedResidue
+      (quotientCoeff ell (topExponent ell) (topExponent_good hell)) v := by
+  apply TensorProduct.ext
+  apply LinearMap.ext
+  intro a
+  apply LinearMap.ext
+  intro e
+  rfl
+
+end BoundaryOnly.FormalObstruction.FixedResidue
+
+namespace BoundaryOnly.FormalObstruction
+open Frobenius MixedForms
+
+                                                                  
+                                                                              
+                                                          
+theorem no_formal_data
+    (k : Type*) [Field k] (ell : ℕ) [CharP k ell]
+    (hprime : ell.Prime) (hchar : 2 < ell)
+    (d : ℕ) (hd : 5 ≤ d) (n : Fin d → ℕ) :
+    ¬ Nonempty (FormalData (k := k) n) := by
+  let : Fact ell.Prime := ⟨hprime⟩
+  rintro ⟨D⟩
+  let hell : 0 < ell := by omega
+  let htwo : 1 < ell := by omega
+  obtain ⟨v,J,x,hJ,hx,hy,hpair⟩ := ActualBlocks.selected_block_cycles ell hchar hd D
+  obtain ⟨i,j,l,hi,hj,hl,hij,hil,hjl⟩ := Finset.two_lt_card_iff.mp (by omega : 2 < J.card)
+  let s : Fin d → ThreeParameters.Ring k := ThreeParameters.chosen i j l
+  have hs (r : Fin d) : ThreeParameters.augmentation k (s r) = 0 :=
+    ThreeParameters.chosen_augmentation i j l r
+  have hs2 (r : Fin d) : s r * s r = 0 := ThreeParameters.chosen_square i j l r
+  have hout (r : Fin d) (hr : r ∉ J) : s r = 0 :=
+    ThreeParameters.chosen_outside J i j l hi hj hl r hr
+  obtain ⟨beta,hbeta,hbeta0⟩ := ActualBlocks.parameter_cycle ell D J s hs hs2 hout x hx hy
+  let a := firstSlopes s
+  have ha : ∀ r, ThreeParameters.augmentation k (a r) = 0 := firstSlopes_augmentation s hs
+  obtain ⟨eta,heta⟩ := movingNormal_cubic_primitive ell htwo D a ha i j l
+  have hw : a (i,0) * a (j,0) * a (l,0) = ThreeParameters.w k := by
+    simp only [a, firstSlopes, ite_true]
+    exact ThreeParameters.chosen_product i j l hij hil hjl
+  rw [hw] at heta
+  apply FixedResidue.unit_residue_contradiction ell hell v (parameterPartial ell)
+    (movingPotential ell D a ha) (movingNormal ell htwo D a ha) beta eta hbeta heta
+  rw [map_mul, reduce_movingNormal, hbeta0, FixedResidue.scalar_eq_fixedResidue]
+  exact hpair
+
+end BoundaryOnly.FormalObstruction
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/FrobeniusObstruction/ParameterLifts.lean b/lean/OAI/Algebra/FrobeniusObstruction/ParameterLifts.lean
new file mode 100644
index 0000000000000000000000000000000000000000..f52c8a5f5e50ace27a88f6c6bea9a1cac2b5c4ab
--- /dev/null
+++ b/lean/OAI/Algebra/FrobeniusObstruction/ParameterLifts.lean
@@ -0,0 +1,130 @@
+import Mathlib
+import OAI.Algebra.FrobeniusObstruction.FixedResidue
+
+namespace OAI
+
+noncomputable section
+open scoped BigOperators
+
+namespace BoundaryOnly.FormalObstruction.MixedForms
+variable {k A ι : Type*} [CommRing k] [CommRing A] [Algebra k A]
+variable [Fintype ι] [DecidableEq ι]
+open scoped TensorProduct
+
+                                                                          
+                                                                        
+theorem gradient_mul_list_prod_zero (pd : ι → Derivation k A A) (q : A)
+    (xs : List (Forms (k := k) (A := A) (ι := ι)))
+    (x : Forms (k := k) (A := A) (ι := ι)) (hx : x ∈ xs)
+    (hq : gradient pd q * x = 0) : gradient pd q * xs.prod = 0 := by
+  induction xs with
+  | nil => simp at hx
+  | cons a xs ih =>
+    rcases List.mem_cons.mp hx with h | h
+    · subst x
+      rw [List.prod_cons, ← mul_assoc, hq, zero_mul]
+    · rw [List.prod_cons, ← mul_assoc, gradient_supercommute, mul_assoc,
+        ih h, mul_zero]
+
+theorem gradient_constant (pd : ι → Derivation k A A) (s : A)
+    (hs : ∀ i, pd i s = 0) : gradient pd s = 0 := by
+  simp only [gradient_eq, hs, TensorProduct.zero_tmul, Finset.sum_const_zero]
+
+theorem gradient_mul_constant (pd : ι → Derivation k A A) (s p : A)
+    (hs : ∀ i, pd i s = 0) : gradient pd (s*p) = coeff s * gradient pd p := by
+  change d pd (coeff (k := k) (ι := ι) (s*p)) = _
+  rw [map_mul, d_mul, d_coeff, gradient_constant pd s hs, zero_mul, parity_coeff,
+    d_coeff, zero_add]
+
+theorem perturbed_factor (pd : ι → Derivation k A A) (Q p s : A)
+    (hs : ∀ i, pd i s = 0) (hs2 : s*s = 0)
+    (x y : Forms (k := k) (A := A) (ι := ι))
+    (hx : gradient pd Q * x = 0)
+    (hy : gradient pd Q * y = -(gradient pd p * x)) :
+    gradient pd (Q+s*p) * (x+coeff s*y) = 0 := by
+  have hg : gradient pd (Q+s*p) = gradient pd Q + coeff s * gradient pd p := by
+    change d pd (coeff (k := k) (ι := ι) (Q+s*p)) = _
+    rw [map_add, map_add, d_coeff, d_coeff, gradient_mul_constant pd s p hs]
+  have hc (z : Forms (k := k) (A := A) (ι := ι)) : z * coeff s = coeff s * z :=
+    (coeff_commute s z).symm
+  rw [hg, add_mul, mul_add, mul_add, hx, zero_add,
+    ← mul_assoc (gradient pd Q), hc, mul_assoc, hy,
+    ← mul_assoc (coeff s * gradient pd p), mul_assoc (coeff s) (gradient pd p) (coeff s),
+    hc, ← mul_assoc (coeff s) (coeff s), ← map_mul, hs2, map_zero, zero_mul,
+    mul_neg, mul_assoc, zero_mul, add_zero, neg_add_cancel]
+
+                                                                      
+                                                                        
+                                                     
+theorem separated_parameter_lift {b : ℕ}
+    (pd : ι → Derivation k A A) (Q p s : Fin b → A)
+    (hs : ∀ j i, pd i (s j) = 0) (hs2 : ∀ j, s j * s j = 0)
+    (x y : Fin b → Forms (k := k) (A := A) (ι := ι))
+    (hx : ∀ j, gradient pd (Q j) * x j = 0)
+    (hy : ∀ j, gradient pd (Q j) * y j = -(gradient pd (p j) * x j)) :
+    delta pd (∑ j, (Q j + s j * p j))
+      (List.ofFn (fun j => x j + coeff (s j) * y j)).prod = 0 := by
+  change gradient pd (∑ j, (Q j + s j * p j)) * _ = 0
+  have hg : gradient pd (∑ j, (Q j + s j * p j)) =
+      ∑ j, gradient pd (Q j + s j * p j) := by
+    change d pd (coeff (k := k) (ι := ι) (∑ j, (Q j + s j * p j))) = _
+    rw [map_sum, map_sum]
+    rfl
+  rw [hg, Finset.sum_mul]
+  apply Finset.sum_eq_zero
+  intro j _
+  apply gradient_mul_list_prod_zero pd (Q j + s j * p j)
+    _ (x j + coeff (s j) * y j)
+  · exact List.mem_ofFn.mpr ⟨j,rfl⟩
+  · exact perturbed_factor pd (Q j) (p j) (s j) (hs j) (hs2 j) (x j) (y j) (hx j) (hy j)
+
+end BoundaryOnly.FormalObstruction.MixedForms
+
+namespace BoundaryOnly.FormalObstruction
+variable {k A B : Type*} [CommRing k] [CommRing A] [CommRing B]
+variable [Algebra k A] [Algebra k B]
+
+                                                                                  
+                                                                             
+                                        
+def firstOrder (f : A →ₐ[k] B) (D : Derivation k A A) (s : B) (hs : s*s = 0) : A →ₐ[k] B where
+  toFun x := f x + s * f (D x)
+  map_one' := by simp only [map_one, Derivation.map_one_eq_zero, map_zero, mul_zero, add_zero]
+  map_mul' x y := by
+    simp only [map_mul, Derivation.leibniz, smul_eq_mul, map_add]
+    linear_combination -(f (D x) * f (D y)) * hs
+  map_zero' := by simp only [map_zero, mul_zero, add_zero]
+  map_add' x y := by simp only [map_add]; ring
+  commutes' r := by
+    simp only [AlgHom.commutes, Derivation.map_algebraMap, map_zero, mul_zero, add_zero]
+
+@[simp] theorem firstOrder_apply (f : A →ₐ[k] B) (D : Derivation k A A)
+    (s : B) (hs : s*s = 0) (x : A) :
+    firstOrder f D s hs x = f x + s*f (D x) := rfl
+end BoundaryOnly.FormalObstruction
+
+namespace BoundaryOnly.FormalObstruction.Frobenius
+variable {ι k S : Type*} [Fintype ι] [DecidableEq ι] [CommRing k]
+variable [CommRing S] [Algebra k S] (ell : ℕ) [CharP k ell]
+
+                                                                         
+                                                                           
+theorem evaluation_first_order (f g : Ring (ι := ι) (k := k) ell →ₐ[k] S)
+    (j : ι) (s : S) (hs : s*s = 0)
+    (hg : ∀ i, g (coordinate ell i) = f (coordinate ell i) + if j = i then s else 0)
+    (x : Ring (ι := ι) (k := k) ell) :
+    g x = f x + s*f (partialDeriv ell j x) := by
+  have he : g = firstOrder f (partialDeriv ell j) s hs := by
+    apply algHom_ext
+    intro i
+    rw [firstOrder_apply, hg, show partialDeriv ell j (coordinate ell i) =
+      (if j = i then 1 else 0) from partial_coordinate ell j i]
+    by_cases hi : j = i
+    · simp only [ite_eq_left hi, map_one, mul_one]
+    · simp only [ite_eq_right hi, map_zero, mul_zero]
+  exact AlgHom.congr_fun he x
+end BoundaryOnly.FormalObstruction.Frobenius
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/FrobeniusObstruction/ResiduePairing.lean b/lean/OAI/Algebra/FrobeniusObstruction/ResiduePairing.lean
new file mode 100644
index 0000000000000000000000000000000000000000..1e362c4f48926cdd5af5fe55e1598f845c94770e
--- /dev/null
+++ b/lean/OAI/Algebra/FrobeniusObstruction/ResiduePairing.lean
@@ -0,0 +1,280 @@
+import Mathlib
+import OAI.Algebra.FrobeniusObstruction.TopResidue
+
+namespace OAI
+
+noncomputable section
+open scoped BigOperators
+
+namespace BoundaryOnly.FormalObstruction.MixedForms
+variable {k A : Type*} [CommRing k] [CommRing A] [Algebra k A] {n : ℕ}
+
+                                                              
+def oneFormLinear : (Fin n → A) →ₗ[A] Forms (k := k) (A := A) (ι := Fin n) where
+  toFun v := ∑ i, v i ⊗ₜ[k] gen (k := k) i
+  map_add' v w := by simp [TensorProduct.add_tmul, Finset.sum_add_distrib]
+  map_smul' c v := by
+    simp only [Pi.smul_apply, smul_eq_mul, RingHom.id_apply, Finset.smul_sum]
+    apply Finset.sum_congr rfl
+    intro i _
+    exact (TensorProduct.smul_tmul' c (v i) (gen (k := k) i)).symm
+
+                                                                           
+                              
+def exteriorBase : ExteriorAlgebra A (Fin n → A) →ₐ[A]
+    Forms (k := k) (A := A) (ι := Fin n) :=
+  ExteriorAlgebra.lift A ⟨oneFormLinear, fun v => oneform_sq v⟩
+
+@[simp] theorem exteriorBase_ι (v : Fin n → A) :
+    exteriorBase (k := k) (ExteriorAlgebra.ι A v) = ∑ i, v i ⊗ₜ[k] gen i := by
+  exact ExteriorAlgebra.lift_ι_apply A (oneFormLinear (k := k)) (fun v => oneform_sq v) v
+
+                                                                                   
+theorem alternating_det {M : Type*} [AddCommGroup M] [Module A M]
+    (f : (Fin n → A) [⋀^Fin n]→ₗ[A] M) (v : Fin n → Fin n → A) :
+    f v = Matrix.det v • f (Pi.basisFun A (Fin n)) := by
+  let b := Pi.basisFun A (Fin n)
+  let g : (Fin n → A) [⋀^Fin n]→ₗ[A] M :=
+    (LinearMap.toSpanSingleton A M (f b)).compAlternatingMap Matrix.detRowAlternating
+  have hfg : f = g := by
+    apply b.ext_alternating
+    intro i hi
+    let σ := Equiv.ofBijective i (Finite.injective_iff_bijective.mp hi)
+    change f (b ∘ σ) = g (b ∘ σ)
+    simp only [AlternatingMap.map_perm]
+    congr 1
+    change f b = Matrix.det (fun i => b i) • f b
+    have hb : (fun i => b i) = (1 : Matrix (Fin n) (Fin n) A) := by
+      funext i j
+      simp [b, Pi.basisFun_apply, Pi.single_apply, Matrix.one_apply, eq_comm]
+    rw [hb, Matrix.det_one, one_smul]
+  calc
+    f v = g v := congrArg (fun u => u v) hfg
+    _ = _ := rfl
+
+                                                                                
+theorem oneForms_product (v : Fin n → Fin n → A) :
+    (List.ofFn fun i => oneFormLinear (k := k) (v i)).prod =
+      Matrix.det v • (List.ofFn fun i => (1 : A) ⊗ₜ[k] gen (k := k) i).prod := by
+  have h := alternating_det
+    ((exteriorBase (k := k) (A := A)).toLinearMap.compAlternatingMap
+      (ExteriorAlgebra.ιMulti A n)) v
+  simpa only [LinearMap.compAlternatingMap_apply, AlgHom.toLinearMap_apply,
+    ExteriorAlgebra.ιMulti_apply, map_list_prod, List.map_ofFn, Function.comp_def,
+    exteriorBase_ι, oneFormLinear, Pi.basisFun_apply, Pi.single_apply,
+    LinearMap.coe_mk, AddHom.coe_mk, TensorProduct.ite_tmul, TensorProduct.zero_tmul, Finset.sum_ite_eq', Finset.mem_univ, ite_true] using h
+
+end BoundaryOnly.FormalObstruction.MixedForms
+
+namespace BoundaryOnly.FormalObstruction.MixedForms
+variable {k A : Type*} [CommRing k] [CommRing A] [Algebra k A] {n : ℕ}
+
+                                                                             
+                          
+def volumeCoeff : Ext (k := k) (ι := Fin n) →ₗ[k] k :=
+  ExteriorAlgebra.liftAlternating fun m =>
+    if h : m = n then h.symm ▸ Matrix.detRowAlternating else 0
+
+@[simp] theorem volumeCoeff_volume :
+    volumeCoeff (k := k) ((List.ofFn fun i : Fin n => gen (k := k) i).prod) = 1 := by
+  have hm : ExteriorAlgebra.ιMulti k n (Pi.basisFun k (Fin n)) =
+      (List.ofFn fun i : Fin n => gen (k := k) i).prod := by
+    simp only [ExteriorAlgebra.ιMulti_apply, Pi.basisFun_apply, gen]
+  rw [← hm]
+  rw [volumeCoeff, ExteriorAlgebra.liftAlternating_apply_ιMulti]
+  rw [dite_eq_left rfl]
+  change Matrix.det (fun i => Pi.basisFun k (Fin n) i) = 1
+  have hb : (fun i => Pi.basisFun k (Fin n) i) = (1 : Matrix (Fin n) (Fin n) k) := by
+    ext i j
+    simp [Pi.basisFun_apply, Pi.single_apply, Matrix.one_apply, eq_comm]
+  rw [hb, Matrix.det_one]
+
+                                                                         
+                                                                                 
+def residue (ρ : A →ₗ[k] k) : Forms (k := k) (A := A) (ι := Fin n) →ₗ[k] k :=
+  (LinearMap.mul' k k).comp (TensorProduct.map ρ volumeCoeff)
+
+@[simp] theorem residue_tmul (ρ : A →ₗ[k] k) (a : A) (e : Ext (k := k) (ι := Fin n)) :
+    residue ρ (a ⊗ₜ[k] e) = ρ a * volumeCoeff e := rfl
+
+                                                                        
+                                    
+theorem residue_d (pd : Fin n → Derivation k A A) (ρ : A →ₗ[k] k)
+    (hρ : ∀ i a, ρ (pd i a) = 0) (x : Forms (k := k) (A := A) (ι := Fin n)) :
+    residue ρ (d pd x) = 0 := by
+  induction x using TensorProduct.inductionOn with
+  | add x y hx hy => simp [hx, hy]
+  | tmul a e => simp [d_tmul, hρ]
+
+                                                                               
+theorem residue_mul_d (pd : Fin n → Derivation k A A) (ρ : A →ₗ[k] k)
+    (hρ : ∀ i a, ρ (pd i a) = 0)
+    (x y : Forms (k := k) (A := A) (ι := Fin n)) (hx : d pd x = 0) :
+    residue ρ (x * d pd y) = 0 := by
+  have h := residue_d pd ρ hρ (parity x * y)
+  rw [d_mul, d_parity, hx, map_zero, neg_zero, zero_mul,
+    parity_sq, zero_add] at h
+  exact h
+
+                                                               
+theorem mul_delta_of_cycle (pd : Fin n → Derivation k A A) (F : A)
+    (x y : Forms (k := k) (A := A) (ι := Fin n)) (hx : delta pd F x = 0) :
+    x * delta pd F y = 0 := by
+  have hp : gradient pd F * parity x = 0 := by
+    have h := congrArg parity hx
+    simpa only [delta_apply, map_mul, parity_gradient, neg_mul,
+      map_zero, neg_eq_zero] using h
+  rw [gradient_supercommute, parity_sq] at hp
+  rw [delta_apply, ← mul_assoc, hp, zero_mul]
+
+theorem residue_mul_delta (pd : Fin n → Derivation k A A) (F : A) (ρ : A →ₗ[k] k)
+    (x y : Forms (k := k) (A := A) (ι := Fin n)) (hx : delta pd F x = 0) :
+    residue ρ (x * delta pd F y) = 0 := by
+  rw [mul_delta_of_cycle pd F x y hx, map_zero]
+
+                                                                             
+                                                                      
+theorem normal_factor (pd : Fin n → Derivation k A A) (e : ℕ) (us : List A) :
+    normal pd e us = coeff ((us.map (fun u => u^e)).prod) *
+      (us.map (gradient pd)).prod := by
+  induction us with
+  | nil => simp only [normal_nil, List.map_nil, List.prod_nil, map_one, mul_one]
+  | cons u us ih =>
+      simp only [normal_cons, ih, cartier, List.map_cons, List.prod_cons, map_mul]
+      rw [mul_assoc, ← mul_assoc (gradient pd u), ← coeff_commute,
+        mul_assoc, ← mul_assoc]
+
+@[simp] theorem normal_append (pd : Fin n → Derivation k A A) (e : ℕ) (us vs : List A) :
+    normal pd e (us ++ vs) = normal pd e us * normal pd e vs := by
+  simp [normal, List.map_append, List.prod_append]
+
+                                                                       
+theorem normal_ofFn (pd : Fin n → Derivation k A A) (e : ℕ) (u : Fin n → A) :
+    normal pd e (List.ofFn u) =
+      ((∏ i, u i ^ e) * Matrix.det (fun i j => pd j (u i))) ⊗ₜ[k]
+        (List.ofFn fun i => gen (k := k) i).prod := by
+  rw [normal_factor]
+  simp only [List.map_ofFn, Function.comp_def, List.prod_ofFn]
+  have hg : (fun i => gradient pd (u i)) = (fun i => oneFormLinear (fun j => pd j (u i))) := by
+    funext i
+    exact gradient_eq pd (u i)
+  rw [hg]
+  have hw := oneForms_product (k := k) (fun i j => pd j (u i))
+  rw [hw]
+  have hv : (List.ofFn fun i : Fin n => (1 : A) ⊗ₜ[k] gen (k := k) i).prod =
+      (1 : A) ⊗ₜ[k] (List.ofFn fun i => gen (k := k) i).prod := by
+    have h := map_list_prod (Algebra.TensorProduct.includeRight (R := k) (A := A))
+      (List.ofFn fun i : Fin n => gen (k := k) i)
+    simpa only [List.map_ofFn, Function.comp_def,
+      Algebra.TensorProduct.includeRight_apply] using h.symm
+  rw [hv, TensorProduct.smul_tmul', smul_eq_mul, mul_one, coeff_apply,
+    Algebra.TensorProduct.tmul_mul_tmul, one_mul]
+
+end BoundaryOnly.FormalObstruction.MixedForms
+
+namespace BoundaryOnly.FormalObstruction.Frobenius
+variable {ι k : Type*} [Fintype ι] [DecidableEq ι] [Field k]
+variable (ell : ℕ) (hell : 0 < ell)
+
+omit [DecidableEq ι] in
+theorem topMonomial_eq_prod : topMonomial (ι := ι) (k := k) ell =
+    ∏ i, coordinate ell i ^ (ell - 1) := by
+  rw [topMonomial, MvPowerSeries.monomial_one_eq]
+  simp only [Finsupp.prod, map_prod, map_pow, coordinate]
+  apply Finset.prod_subset (Finset.subset_univ _)
+  intro i _ hi
+  have hx : topExponent ell i = 0 := by simpa only [Finsupp.mem_support_iff, not_not] using hi
+  simpa only [topExponent_apply, pow_zero] using congrArg (fun e =>
+    Ideal.Quotient.mk (powerIdeal (ι := ι) (k := k) ell) (MvPowerSeries.X i)^e) hx
+
+variable [CharP k ell] (htwo : 1 < ell)
+
+@[simp] theorem augmentation_partial (i : ι) (x : Ring (ι := ι) (k := k) ell) :
+    augmentation ell hell (partialDeriv ell i x) = tangentCoeff ell htwo i x := by
+  obtain ⟨f,rfl⟩ := Ideal.Quotient.mk_surjective x
+  rw [partial_mk, tangentCoeff_mk]
+  change MvPowerSeries.constantCoeff (MvPowerSeries.pderiv i f) = _
+  rw [← MvPowerSeries.coeff_zero_eq_constantCoeff_apply, MvPowerSeries.coeff_pderiv]
+  simp
+
+end BoundaryOnly.FormalObstruction.Frobenius
+
+namespace BoundaryOnly.FormalObstruction.NormalPairing
+open Frobenius MixedForms
+variable {k : Type*} [Field k] {n : ℕ} (ell : ℕ) (htwo : 1 < ell)
+  [CharP k ell]
+
+abbrev Scalar := Frobenius.Ring (ι := Fin n) (k := k) ell
+abbrev OriginalForms := Forms (k := k) (A := Scalar (n := n) (k := k) ell) (ι := Fin n)
+
+def res : OriginalForms (n := n) (k := k) ell →ₗ[k] k :=
+  residue (quotientCoeff ell (topExponent ell) (topExponent_good (by omega)))
+
+theorem jacobian_augmentation
+    (f : Scalar (n := n) (k := k) ell →ₐ[k] Scalar (n := n) (k := k) ell) :
+    augmentation ell (by omega)
+      (Matrix.det (fun i j : Fin n => partialDeriv ell j (f (coordinate ell i)))) =
+    Matrix.det (fun i j : Fin n => tangentCoeff ell htwo j (f (coordinate ell i))) := by
+  change (augmentation (ι := Fin n) (k := k) ell (by omega)).toRingHom
+    (Matrix.det _) = _
+  refine (RingHom.map_det (augmentation (ι := Fin n) (k := k) ell (by omega)).toRingHom
+    (fun i j : Fin n => partialDeriv ell j (f (coordinate ell i)))).trans ?_
+  apply congrArg Matrix.det
+  ext i j
+  exact augmentation_partial ell (by omega) htwo j _
+
+omit [CharP k ell] in
+theorem chart_top_product
+    (f : Scalar (n := n) (k := k) ell →ₐ[k] Scalar (n := n) (k := k) ell)
+    (c : k) (hq : f (topMonomial ell) = c • topMonomial ell) :
+    (∏ i : Fin n, f (coordinate ell i) ^ (ell-1)) = c • topMonomial ell := by
+  rw [← hq, topMonomial_eq_prod, map_prod]
+  simp only [map_pow]
+
+theorem residue_chart_formula
+    (f : Scalar (n := n) (k := k) ell →ₐ[k] Scalar (n := n) (k := k) ell)
+    (c : k) (hq : f (topMonomial ell) = c • topMonomial ell) :
+    res ell htwo (normal (partialDeriv ell) (ell-1)
+      (List.ofFn fun i : Fin n => f (coordinate ell i))) =
+      c * Matrix.det (fun i j : Fin n => tangentCoeff ell htwo j (f (coordinate ell i))) := by
+  unfold res
+  rw [normal_ofFn, residue_tmul, volumeCoeff_volume, mul_one,
+    chart_top_product ell f c hq, smul_mul_assoc,
+    topMonomial_mul (ι := Fin n) (k := k) (ell := ell) (by omega)]
+  rw [map_smul, map_smul,
+    topMonomial_coefficient (ι := Fin n) (k := k) (ell := ell) (by omega)]
+  change c * (augmentation (ι := Fin n) (k := k) ell (by omega)
+    (Matrix.det (fun i j : Fin n => partialDeriv ell j (f (coordinate ell i)))) * 1) = _
+  rw [mul_one, jacobian_augmentation ell htwo f]
+
+                                                                         
+                                                                              
+                                            
+theorem coordinate_residue_ne_zero
+    (f : Scalar (n := n) (k := k) ell →ₐ[k] Scalar (n := n) (k := k) ell)
+    (hf : Function.Bijective f)
+    (hM : IsUnit (Matrix.det (fun i j => tangentCoeff ell htwo j (f (coordinate ell i))))) :
+    res ell htwo (normal (partialDeriv ell) (ell-1)
+      (List.ofFn fun i : Fin n => f (coordinate ell i))) ≠ 0 := by
+  obtain ⟨c,hc,hq⟩ := automorphism_top ell (by omega) f hf
+  rw [residue_chart_formula ell htwo f c hq]
+  exact mul_ne_zero hc hM.ne_zero
+
+                                                                         
+                                                                             
+theorem normals_pair_ne_zero
+    (f : Scalar (n := n) (k := k) ell →ₐ[k] Scalar (n := n) (k := k) ell)
+    (hf : Function.Bijective f)
+    (hM : IsUnit (Matrix.det (fun i j => tangentCoeff ell htwo j (f (coordinate ell i)))))
+    (us vs : List (Scalar (n := n) (k := k) ell))
+    (huv : us ++ vs = List.ofFn fun i : Fin n => f (coordinate ell i)) :
+    res ell htwo (normal (partialDeriv ell) (ell-1) us *
+      normal (partialDeriv ell) (ell-1) vs) ≠ 0 := by
+  rw [← normal_append, huv]
+  exact coordinate_residue_ne_zero ell htwo f hf hM
+
+end BoundaryOnly.FormalObstruction.NormalPairing
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/FrobeniusObstruction/Retractions.lean b/lean/OAI/Algebra/FrobeniusObstruction/Retractions.lean
new file mode 100644
index 0000000000000000000000000000000000000000..71351f7c227b2c2510f9028acbfef2582134c9e2
--- /dev/null
+++ b/lean/OAI/Algebra/FrobeniusObstruction/Retractions.lean
@@ -0,0 +1,183 @@
+import Mathlib
+import OAI.Algebra.FrobeniusObstruction.SquareZero
+
+namespace OAI
+
+noncomputable section
+open scoped BigOperators
+
+noncomputable section
+namespace BoundaryOnly.FormalObstruction
+
+variable {k V : Type*} [Field k] [AddCommGroup V] [Module k V]
+
+                                                                                           
+theorem retraction_core (D : V →ₗ[k] V) (d2 : ∀ x, D (D x) = 0)
+    (N : Submodule k V) :
+    ∃ r h : V →ₗ[k] V,
+      (∀ x, D (r x) = r (D x)) ∧
+      (∀ x, r (r x) = r x) ∧
+      N.map r = N ⊓ N.comap D ∧
+      (∀ x ∈ N ⊓ N.comap D, r x = x) ∧
+      (∀ x, x - r x = D (h x) + h (D x)) := by
+  let K := N ⊓ N.comap D
+  obtain ⟨E, hKE, hsup⟩ := IsModularLattice.exists_disjoint_and_sup_eq (show K ≤ N from inf_le_left)
+  have hEN : E ≤ N := by
+    rw [← hsup]
+    exact le_sup_right
+  have hDz (e : E) (he : D e ∈ N) : (e : V) = 0 :=
+    Submodule.disjoint_def.mp hKE _ ⟨hEN e.property, he⟩ e.property
+  let f : E × N →ₗ[k] V := (D.comp E.subtype).coprod N.subtype
+  have hf : LinearMap.ker f = ⊥ := by
+    apply LinearMap.ker_eq_bot'.mpr
+    rintro ⟨e, n⟩ hz
+    change D (e : V) + (n : V) = 0 at hz
+    have he : (e : V) = 0 := hDz e (by
+      have heq : D (e : V) = -(n : V) := eq_neg_of_add_eq_zero_left hz
+      rw [heq]
+      exact N.neg_mem n.property)
+    have hn : (n : V) = 0 := by simpa [he] using hz
+    exact Prod.ext (Subtype.ext he) (Subtype.ext hn)
+  obtain ⟨g, hg⟩ := f.exists_leftInverse_of_injective hf
+  let h : V →ₗ[k] V := E.subtype.comp ((LinearMap.fst k E N).comp g)
+  have hrange (x : V) : h x ∈ E := (g x).1.property
+  have hgval (e : E) (n : N) : g (D e + n) = (e,n) :=
+    LinearMap.congr_fun hg (e,n)
+  have hN (x : V) (hx : x ∈ N) : h x = 0 := by
+    have hv := hgval 0 ⟨x,hx⟩
+    simp only [ZeroMemClass.coe_zero, map_zero, zero_add] at hv
+    change ((g x).1 : V) = 0
+    rw [hv]
+    rfl
+  have hDE (e : E) : h (D e) = e := by
+    have hv := hgval e 0
+    simp only [ZeroMemClass.coe_zero, add_zero] at hv
+    change ((g (D e)).1 : V) = e
+    rw [hv]
+  let Q : V →ₗ[k] V := D.comp h + h.comp D
+  have hQE (e : E) : Q e = e := by
+    change D (h e) + h (D e) = e
+    rw [hN e (hEN e.property), map_zero, zero_add, hDE]
+  have hQDE (e : E) : Q (D e) = D e := by
+    change D (h (D e)) + h (D (D e)) = D e
+    rw [hDE, d2, map_zero, add_zero]
+  have hQK (x : V) (hx : x ∈ K) : Q x = 0 := by
+    change D (h x) + h (D x) = 0
+    rw [hN x hx.1, map_zero, hN (D x) hx.2, add_zero]
+  have hQQ (x : V) : Q (Q x) = Q x := by
+    change Q (D (h x) + h (D x)) = D (h x) + h (D x)
+    rw [map_add, hQDE ⟨h x,hrange x⟩, hQE ⟨h (D x),hrange (D x)⟩]
+  have hDQ (x : V) : D (Q x) = Q (D x) := by
+    change D (D (h x) + h (D x)) = D (h (D x)) + h (D (D x))
+    rw [map_add, d2, zero_add, d2, map_zero, add_zero]
+  let r : V →ₗ[k] V := LinearMap.id - Q
+  have hr (x : V) : r x = x - Q x := rfl
+  have hrK (x : V) (hx : x ∈ K) : r x = x := by rw [hr, hQK x hx, sub_zero]
+  have hrE (e : E) : r e = 0 := by rw [hr, hQE, sub_self]
+  have hrN (x : V) (hx : x ∈ N) : r x ∈ K := by
+    rw [← hsup, Submodule.mem_sup] at hx
+    obtain ⟨y, hy, z, hz, rfl⟩ := hx
+    rw [map_add, hrK y hy, hrE ⟨z,hz⟩, add_zero]
+    exact hy
+  refine ⟨r, h, ?_, ?_, ?_, hrK, ?_⟩
+  · intro x
+    rw [hr, hr, map_sub, hDQ]
+  · intro x
+    simp only [hr, map_sub, hQQ, sub_self, sub_zero]
+  · apply le_antisymm
+    · rintro _ ⟨x,hx,rfl⟩
+      exact hrN x hx
+    · intro x hx
+      exact ⟨x, hx.1, hrK x hx⟩
+  · intro x
+    rw [hr, sub_sub_cancel]
+    rfl
+
+                                                                
+theorem kernel_retraction_core [FiniteDimensional k V]
+    (D S : V →ₗ[k] V) (d2 : ∀ x, D (D x) = 0) :
+    ∃ r h : V →ₗ[k] V,
+      (∀ x, D (r x) = r (D x)) ∧
+      (∀ x, r (r x) = r x) ∧
+      (LinearMap.ker S).map r = LinearMap.ker S ⊓ (LinearMap.ker S).comap D ∧
+      (∀ x ∈ LinearMap.ker S ⊓ (LinearMap.ker S).comap D, r x = x) ∧
+      (∀ x, x - r x = D (h x) + h (D x)) :=
+  retraction_core D d2 (LinearMap.ker S)
+
+end BoundaryOnly.FormalObstruction
+
+namespace BoundaryOnly.FormalObstruction
+variable {k V : Type*} [Field k] [AddCommGroup V] [Module k V]
+
+                                                                             
+                                                                          
+                                                                     
+theorem parity_retraction (htwo : (2 : k) ≠ 0)
+    (D S P : V →ₗ[k] V)
+    (hDD : ∀ x, D (D x) = 0) (hPP : ∀ x, P (P x) = x)
+    (hDP : ∀ x, D (P x) = -P (D x))
+    (hSP : ∀ x, S (P x) = P (S x)) :
+    ∃ r h : V →ₗ[k] V,
+      (∀ x, D (r x) = r (D x)) ∧
+      (∀ x, P (r x) = r (P x)) ∧
+      (∀ x, P (h x) = -h (P x)) ∧
+      (∀ x, x - r x = D (h x) + h (D x)) ∧
+      (∀ x, S x = 0 → S (r x) = 0 ∧ S (D (r x)) = 0) := by
+  obtain ⟨r,h,hrD,_,hrN,_,hrh⟩ :=
+    retraction_core D hDD (LinearMap.ker S)
+  let c : k := (2 : k)⁻¹
+  have hc : c+c = 1 := by dsimp [c]; field_simp; ring
+  let r' : V →ₗ[k] V := c • (r + P.comp (r.comp P))
+  let h' : V →ₗ[k] V := c • (h - P.comp (h.comp P))
+  have hr' (x : V) : r' x = c • (r x + P (r (P x))) := rfl
+  have hh' (x : V) : h' x = c • (h x - P (h (P x))) := rfl
+  have hPD (x : V) : P (D x) = -D (P x) := by rw [hDP, neg_neg]
+  have hrN' (x : V) (hx : S x = 0) : S (r x) = 0 ∧ S (D (r x)) = 0 := by
+    have hx' : r x ∈ (LinearMap.ker S).map r := ⟨x, hx, rfl⟩
+    rw [hrN] at hx'
+    exact hx'
+  refine ⟨r',h',?_,?_,?_,?_,?_⟩
+  · intro x
+    simp only [hr', map_smul, map_add, hDP, hrD, map_neg]
+    module
+  · intro x
+    simp only [hr', map_smul, map_add, hPP]
+    module
+  · intro x
+    simp only [hh', map_smul, map_sub, hPP]
+    module
+  · intro x
+    have h₁ := hrh x
+    have h₂ := congrArg P (hrh (P x))
+    simp only [map_sub, map_add, hPP] at h₂
+    rw [hPD (h (P x)), hDP x, map_neg, map_neg] at h₂
+    rw [hr', hh', hh']
+    simp only [map_smul, map_sub]
+    have hh : c • (D (h x) + h (D x)) = c • (x - r x) := congrArg (c • ·) h₁.symm
+    have hh₂ : c • (-D (P (h (P x))) - P (h (P (D x)))) =
+        c • (x - P (r (P x))) := by
+      apply congrArg (c • ·)
+      simpa only [sub_eq_add_neg] using h₂.symm
+    have hc' : c • x + c • x = x := by rw [← add_smul, hc, one_smul]
+    calc
+      x - c • (r x + P (r (P x))) =
+          (c • x + c • x) - c • (r x + P (r (P x))) := by rw [hc']
+      _ = c • (x - r x) + c • (x - P (r (P x))) := by module
+      _ = c • (D (h x) + h (D x)) +
+          c • (-D (P (h (P x))) - P (h (P (D x)))) := by rw [hh, hh₂]
+      _ = _ := by module
+  · intro x hx
+    have hSx := hrN' x hx
+    have hSPx := hrN' (P x) (by rw [hSP, hx, map_zero])
+    constructor
+    · simp only [hr', map_smul, map_add, hSP, hSx.1, hSPx.1, map_zero, add_zero,
+        smul_zero]
+    · simp only [hr', map_smul, map_add, hDP, hSP, map_neg, hSx.2, hSPx.2,
+        map_zero, neg_zero, add_zero, smul_zero]
+
+end BoundaryOnly.FormalObstruction
+
+end
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/FrobeniusObstruction/SelectedCycles.lean b/lean/OAI/Algebra/FrobeniusObstruction/SelectedCycles.lean
new file mode 100644
index 0000000000000000000000000000000000000000..aad31f158a4cac4719107dc6ba51cfd31627124e
--- /dev/null
+++ b/lean/OAI/Algebra/FrobeniusObstruction/SelectedCycles.lean
@@ -0,0 +1,241 @@
+import Mathlib
+import OAI.Algebra.FrobeniusObstruction.ActualBlocks
+
+namespace OAI
+
+noncomputable section
+open scoped BigOperators
+
+namespace BoundaryOnly.FormalObstruction.ActualBlocks
+open Frobenius MixedForms FormsSplit GlobalForms SignedTensor
+open scoped TensorProduct BigOperators
+variable {k : Type*} [Field k] {d : ℕ} {n : Fin d → ℕ}
+variable (ell : ℕ) [Fact ell.Prime] [CharP k ell] (hchar : 2 < ell)
+
+ theorem selected_block_cycles (hd : 5 ≤ d) (D : FormalData (k := k) n) :
+    ∃ (v : Ext (k := k) (ι := InternalVar n) →ₗ[k] k)
+      (J : Finset (Fin d)) (x : ∀ i, Block (n := n) (k := k) ell i),
+      3 ≤ J.card ∧
+      (∀ i, delta (partialDeriv ell) (blockPotential ell D i) (x i) = 0) ∧
+      (∀ i ∈ J, ∃ y : Block (n := n) (k := k) ell i,
+        delta (partialDeriv ell) (blockPotential ell D i) y =
+          -delta (partialDeriv ell) (blockSlope ell D i) (x i)) ∧
+      fixedResidue (quotientCoeff ell (topExponent ell) (topExponent_good (by omega))) v
+        (specialNormal ell (by omega) D *
+          (List.ofFn fun i => includeBlock ell i (x i)).prod) ≠ 0 := by
+  let hell : 0 < ell := by omega
+  let htwo : 1 < ell := by omega
+  have htwoK : (2 : k) ≠ 0 := by
+    intro h
+    have hv : ell ∣ 2 := (CharP.cast_eq_zero_iff k ell 2).mp (by simpa using h)
+    have := Nat.le_of_dvd (by omega : 0 < 2) hv
+    omega
+  obtain ⟨v,hpair⟩ := specialNormal_pairing ell htwo D
+  let alpha := specialNormal ell htwo D
+  let beta := negativeNormal ell htwo D
+  let e := tensorToForms (n := n) (k := k) ell hell
+  let pd := fun i : Fin d => partialDeriv (ι := Variables n i) (k := k) ell
+  let q := blockPotential ell D
+  let s := blockSlope ell D
+  let rho := quotientCoeff (ι := InternalVar n) (k := k) ell (topExponent ell) (topExponent_good hell)
+  let Φ : (⨂[k] i, Block (n := n) (k := k) ell i) →ₗ[k] k :=
+    (fixedResidue rho v).comp (((Algebra.lmul k _).toLinearMap alpha).comp e.toLinearMap)
+  have heD (z : ⨂[k] i, Block (n := n) (k := k) ell i) :
+      e (differential (Block (n := n) (k := k) ell) BlockTensor.P (BlockTensor.D pd) z) =
+        MixedForms.d (partialDeriv ell) (e z) := tensorToForms_D ell hell z
+  have heδ (z : ⨂[k] i, Block (n := n) (k := k) ell i) :
+      e (differential (Block (n := n) (k := k) ell) BlockTensor.P (BlockTensor.delta pd q) z) =
+        delta (partialDeriv ell) (specialPotential ell D) (e z) := tensorToForms_delta ell hell D z
+  have hPhiD (z) : Φ (differential (Block (n := n) (k := k) ell) BlockTensor.P (BlockTensor.D pd) z) = 0 := by
+    change fixedResidue rho v (alpha * e _) = 0
+    rw [heD]
+    exact fixedResidue_mul_d (partialDeriv ell) rho v (residue_partial_zero ell hell)
+      alpha (e z) (specialNormal_d ell htwo D)
+  have hPhiδ (z) : Φ (differential (Block (n := n) (k := k) ell) BlockTensor.P (BlockTensor.delta pd q) z) = 0 := by
+    change fixedResidue rho v (alpha * e _) = 0
+    rw [heδ, left_cycle_mul_delta _ _ _ _ (specialNormal_delta ell htwo D), map_zero]
+  have hz : differential (Block (n := n) (k := k) ell) BlockTensor.P
+      (BlockTensor.delta pd q) (e.symm beta) = 0 := by
+    apply e.injective
+    rw [heδ, e.apply_symm_apply, LinearEquiv.map_zero]
+    exact negativeNormal_delta ell htwo D
+  have hDz : differential (Block (n := n) (k := k) ell) BlockTensor.P
+      (BlockTensor.D pd) (e.symm beta) = 0 := by
+    apply e.injective
+    rw [heD, e.apply_symm_apply, LinearEquiv.map_zero]
+    exact negativeNormal_d ell htwo D
+  have hPhiz : Φ (e.symm beta) ≠ 0 := by
+    change fixedResidue rho v (alpha * e (e.symm beta)) ≠ 0
+    rw [e.apply_symm_apply]
+    exact hpair
+  have htriple (I : Finset (Fin d)) (_hi : I ⊆ Finset.univ) (hI : I.card = 3) :
+      ∃ y, tensorAction (Block (n := n) (k := k) ell) (BlockTensor.S s) I (e.symm beta) =
+        differential (Block (n := n) (k := k) ell) BlockTensor.P (BlockTensor.delta pd q) y := by
+    obtain ⟨i,j,l,hij,hil,hjl,rfl⟩ := Finset.card_eq_three.mp hI
+    obtain ⟨eta,heta⟩ := negativeNormal_triple ell htwo D i j l
+    refine ⟨e.symm eta, ?_⟩
+    apply e.injective
+    rw [heδ, e.apply_symm_apply]
+    change tensorToForms ell hell (tensorAction _ _ _ _) = _
+    rw [tensorToForms_S]
+    change coeff _ * e (e.symm beta) = _
+    rw [e.apply_symm_apply]
+    dsimp only [s]
+    simpa [hij, hil, hjl, beta, mul_assoc] using heta.symm
+  obtain ⟨J,x,_hJ,hJcard,hx,hy,hΦx⟩ := BlockTensor.selected_cycles pd q htwoK
+    (fun i a b z => partial_commute ell a b z) s Finset.univ
+    (by simpa using hd) Φ hPhiδ hPhiD (e.symm beta) hz hDz hPhiz htriple
+  refine ⟨v,J,x,hJcard,hx,hy,?_⟩
+  change fixedResidue rho v (alpha * e (PiTensorProduct.tprod k x)) ≠ 0 at hΦx
+  simpa only [e, tensorToForms_tprod] using hΦx
+
+end BoundaryOnly.FormalObstruction.ActualBlocks
+
+namespace BoundaryOnly.FormalObstruction
+open Frobenius MixedForms
+open scoped BigOperators
+variable {k : Type*} [Field k] {d : ℕ} {n : Fin d → ℕ}
+variable (ell : ℕ) [Fact ell.Prime] [CharP k ell]
+
+ def firstSlopes (s : Fin d → ThreeParameters.Ring k) : SlopeVar d → ThreeParameters.Ring k :=
+  fun ij => if ij.2 = 0 then s ij.1 else 0
+
+ theorem firstSlopes_augmentation (s : Fin d → ThreeParameters.Ring k)
+    (hs : ∀ i, ThreeParameters.augmentation k (s i) = 0) (ij : SlopeVar d) :
+    ThreeParameters.augmentation k (firstSlopes s ij) = 0 := by
+  dsimp [firstSlopes]
+  split_ifs <;> simp only [hs, map_zero]
+
+ theorem zeroSlopes_constant_zero (i : Fin d) (j : WallVar n i) :
+    MvPowerSeries.constantCoeff (zeroSlopes (k := k) n i j) = 0 := by
+  cases j <;> simp [zeroSlopes]
+
+ theorem wallSpecial_zeroSlopes (b : Bool) (i : Fin d)
+    (p : MvPowerSeries (WallVar n i) k) :
+    wallSpecial (n := n) (k := k) ell b i (Ideal.Quotient.mk _ p) =
+      includeVariables (k := k) ell (fun y => (b,⟨i,y⟩))
+        (Ideal.Quotient.mk _ (MvPowerSeries.subst (zeroSlopes n i) p)) := by
+  have h : wallSpecial (n := n) (k := k) ell b i =
+      (includeVariables (k := k) ell (fun y : Fin (n i) => ((b,⟨i,y⟩) : InternalVar n))).comp
+        (substitute ell (zeroSlopes n i) (zeroSlopes_constant_zero i)) := by
+    apply Frobenius.algHom_ext (ι := WallVar n i) (k := k) ell
+    intro j
+    simp only [AlgHom.comp_apply, substitute_coordinate]
+    cases j with
+    | inl j => simp only [zeroSlopes, map_zero, wallSpecial_slope]
+    | inr y =>
+      rw [wallSpecial_internal]
+      change coordinate ell (b,⟨i,y⟩) =
+        includeVariables (k := k) ell (fun y : Fin (n i) => ((b,⟨i,y⟩) : InternalVar n))
+          (coordinate ell y)
+      exact (includeVariables_coordinate (k := k) ell
+        (fun y : Fin (n i) => ((b,⟨i,y⟩) : InternalVar n)) y).symm
+  rw [h, AlgHom.comp_apply, substitute_mk]
+
+ theorem wallSpecial_slopePartial (D : FormalData (k := k) n) (b : Bool) (i : Fin d) :
+    wallSpecial ell b i (partialDeriv ell (.inl 0) (Ideal.Quotient.mk _ (D.P i))) =
+      specialSlope ell D b i := by
+  rw [partial_mk, wallSpecial_zeroSlopes]
+  rfl
+
+ def movingWall (s : Fin d → ThreeParameters.Ring k)
+    (hs : ∀ i, ThreeParameters.augmentation k (s i) = 0) (i : Fin d) :
+    Frobenius.Ring (ι := WallVar n i) (k := k) ell →ₐ[k]
+      ParameterScalar (n := n) (k := k) ell :=
+  (ambientSlot ell (firstSlopes s) (firstSlopes_augmentation s hs)).comp
+    (substitute ell (plusCoordinates n i) (plusCoordinates_constant_zero i))
+
+ @[simp] theorem movingWall_slope (s : Fin d → ThreeParameters.Ring k)
+    (hs : ∀ i, ThreeParameters.augmentation k (s i) = 0) (i : Fin d) (j : Fin 3) :
+    movingWall (n := n) ell s hs i (coordinate ell (.inl j)) =
+      if j = 0 then @algebraMap (ThreeParameters.Ring k) (ParameterScalar (n := n) (k := k) ell)
+        inferInstance inferInstance inferInstance (s i) else 0 := by
+  simp only [movingWall, AlgHom.comp_apply, substitute_coordinate, plusCoordinates]
+  change ambientSlot ell _ _ (coordinate ell (.inl (i,j))) = _
+  rw [ambientSlot_coordinate]
+  change @algebraMap (ThreeParameters.Ring k) (ParameterScalar (n := n) (k := k) ell)
+      inferInstance inferInstance inferInstance (if j = 0 then s i else 0) = _
+  split_ifs <;> simp only [map_zero]
+
+ @[simp] theorem movingWall_internal (s : Fin d → ThreeParameters.Ring k)
+    (hs : ∀ i, ThreeParameters.augmentation k (s i) = 0) (i : Fin d) (y : Fin (n i)) :
+    movingWall (n := n) ell s hs i (coordinate ell (.inr y)) = coordinate ell (true,⟨i,y⟩) := by
+  simp only [movingWall, AlgHom.comp_apply, substitute_coordinate, plusCoordinates]
+  exact ambientSlot_coordinate ell _ _ _
+
+ theorem movingWall_first_order (s : Fin d → ThreeParameters.Ring k)
+    (hs : ∀ i, ThreeParameters.augmentation k (s i) = 0)
+    (hs2 : ∀ i, s i * s i = 0) (i : Fin d)
+    (x : Frobenius.Ring (ι := WallVar n i) (k := k) ell) :
+    movingWall ell s hs i x =
+      baseChange (k := k) (l := ThreeParameters.Ring k) ell (wallSpecial ell true i x) +
+      (@algebraMap (ThreeParameters.Ring k) (ParameterScalar (n := n) (k := k) ell)
+        inferInstance inferInstance inferInstance (s i)) *
+        baseChange (k := k) (l := ThreeParameters.Ring k) ell
+          (wallSpecial ell true i (partialDeriv ell (.inl 0) x)) := by
+  let f := (baseChange (ι := InternalVar n) (k := k) (l := ThreeParameters.Ring k) ell).comp
+    (wallSpecial ell true i)
+  refine evaluation_first_order ell f (movingWall ell s hs i) (.inl 0)
+    (@algebraMap (ThreeParameters.Ring k) (ParameterScalar (n := n) (k := k) ell)
+      inferInstance inferInstance inferInstance (s i)) ?_ ?_ x
+  · rw [← map_mul, hs2, map_zero]
+  · intro j
+    cases j with
+    | inl j =>
+      simp only [movingWall_slope, f, AlgHom.comp_apply, wallSpecial_slope, map_zero, zero_add,
+        Sum.inl.injEq]
+      simp only [eq_comm]
+    | inr y =>
+      simp only [movingWall_internal, f, AlgHom.comp_apply, wallSpecial_internal,
+        baseChange_coordinate, Sum.inl_ne_inr, ite_false, add_zero]
+
+ theorem ambientSlot_minus (a : SlopeVar d → ThreeParameters.Ring k)
+    (ha : ∀ i, ThreeParameters.augmentation k (a i) = 0)
+    (i : Fin d) (p : MvPowerSeries (WallVar n i) k) :
+    ambientSlot (n := n) ell a ha
+      (Ideal.Quotient.mk _ (MvPowerSeries.subst (minusCoordinates n i) p)) =
+      baseChange (k := k) (l := ThreeParameters.Ring k) ell (wallSpecial ell false i (Ideal.Quotient.mk _ p)) := by
+  have h : (ambientSlot (n := n) ell a ha).comp
+      (substitute (k := k) ell (minusCoordinates n i) (minusCoordinates_constant_zero i)) =
+      (baseChange (ι := InternalVar n) (k := k) (l := ThreeParameters.Ring k) ell).comp
+        (wallSpecial (n := n) (k := k) ell false i) := by
+    refine Frobenius.algHom_ext (ι := WallVar n i) (k := k)
+      (S := ParameterScalar (n := n) (k := k) ell) ell _ _ ?_
+    intro j
+    simp only [AlgHom.comp_apply, substitute_coordinate]
+    cases j with
+    | inl j => simp only [minusCoordinates, map_zero, wallSpecial_slope]
+    | inr y =>
+      rw [wallSpecial_internal, baseChange_coordinate]
+      exact ambientSlot_coordinate ell _ _ _
+  simpa only [AlgHom.comp_apply, substitute_mk] using AlgHom.congr_fun h (Ideal.Quotient.mk _ p)
+
+                                                                        
+                                                                        
+ theorem movingPotential_first_order (D : FormalData (k := k) n)
+    (s : Fin d → ThreeParameters.Ring k)
+    (hs : ∀ i, ThreeParameters.augmentation k (s i) = 0)
+    (hs2 : ∀ i, s i * s i = 0) :
+    movingPotential ell D (firstSlopes s) (firstSlopes_augmentation s hs) =
+      ∑ i, (baseChange (k := k) (l := ThreeParameters.Ring k) ell
+          (wallSpecial ell true i (Ideal.Quotient.mk _ (D.P i)) -
+            wallSpecial ell false i (Ideal.Quotient.mk _ (D.P i))) +
+        @algebraMap (ThreeParameters.Ring k) (ParameterScalar (n := n) (k := k) ell)
+          inferInstance inferInstance inferInstance (s i) *
+            baseChange (k := k) (l := ThreeParameters.Ring k) ell (specialSlope ell D true i)) := by
+  simp only [movingPotential, potential, map_sum, map_sub, ambientSlot_minus]
+  apply Finset.sum_congr rfl
+  intro i _
+  have hh := movingWall_first_order (n := n) ell s hs hs2 i (Ideal.Quotient.mk _ (D.P i))
+  change ambientSlot ell (firstSlopes s) (firstSlopes_augmentation s hs)
+    (substitute ell (plusCoordinates n i) (plusCoordinates_constant_zero i)
+      (Ideal.Quotient.mk _ (D.P i))) = _ at hh
+  rw [substitute_mk, wallSpecial_slopePartial] at hh
+  rw [hh]
+  ring
+
+end BoundaryOnly.FormalObstruction
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/FrobeniusObstruction/SignedTensor.lean b/lean/OAI/Algebra/FrobeniusObstruction/SignedTensor.lean
new file mode 100644
index 0000000000000000000000000000000000000000..6b35f3337c7022057084bf26ba4fcd45ae4f365c
--- /dev/null
+++ b/lean/OAI/Algebra/FrobeniusObstruction/SignedTensor.lean
@@ -0,0 +1,219 @@
+import Mathlib
+import OAI.Algebra.FrobeniusObstruction.FormTensor
+
+namespace OAI
+
+noncomputable section
+open scoped BigOperators TensorProduct
+
+namespace BoundaryOnly.FormalObstruction
+namespace SignedTensor
+
+variable {k ι : Type*} [Field k] [Fintype ι] [LinearOrder ι]
+variable (V : ι → Type*) [∀ i, AddCommGroup (V i)] [∀ i, Module k (V i)]
+
+abbrev EndFamily := ∀ i, Module.End k (V i)
+abbrev TensorEnd := Module.End k (⨂[k] i, V i)
+
+def dSlot (P D : EndFamily (k := k) V) (i : ι) : EndFamily (k := k) V :=
+  fun j => if j < i then P j else if j = i then D j else 1
+
+def hSlot (P r h : EndFamily (k := k) V) (i : ι) : EndFamily (k := k) V :=
+  fun j => if j < i then r j * P j else if j = i then h j else 1
+
+def diagSlot (r : EndFamily (k := k) V) (i : ι) : EndFamily (k := k) V :=
+  fun j => if j < i then r j else if j = i then 1 - r j else 1
+
+def differential (P D : EndFamily (k := k) V) : TensorEnd (k := k) V :=
+  ∑ i, PiTensorProduct.map (dSlot V P D i)
+
+def homotopy (P r h : EndFamily (k := k) V) : TensorEnd (k := k) V :=
+  ∑ i, PiTensorProduct.map (hSlot V P r h i)
+
+omit [Fintype ι] in
+private theorem tensor_neg_at (f g : EndFamily (k := k) V) (i : ι)
+    (hii : f i = -g i) (hij : ∀ j, j ≠ i → f j = g j) :
+    PiTensorProduct.map f = -PiTensorProduct.map g := by
+  have heq : f = Function.update g i (-g i) := by
+    funext j
+    by_cases h : j = i
+    · subst j; simpa using hii
+    · simp only [Function.update_of_ne h, hij j h]
+  rw [heq]
+  exact (PiTensorProduct.mapMultilinear k V V).map_update_neg g i (g i) |>.trans
+    (by rw [Function.update_eq_self]; rfl)
+
+omit [Fintype ι] in
+private theorem tensor_add_at (f g b : EndFamily (k := k) V) (i : ι)
+    (hf : ∀ j, j ≠ i → f j = b j) (hg : ∀ j, j ≠ i → g j = b j) :
+    PiTensorProduct.map f + PiTensorProduct.map g =
+      PiTensorProduct.map (Function.update b i (f i + g i)) := by
+  have hh (a : EndFamily (k := k) V) (ha : ∀ j, j ≠ i → a j = b j) :
+      a = Function.update b i (a i) := by
+    funext j
+    by_cases h : j = i
+    · subst j; simp
+    · simp only [Function.update_of_ne h, ha j h]
+  conv_lhs => rw [hh f hf, hh g hg]
+  exact ((PiTensorProduct.mapMultilinear k V V).map_update_add b i (f i) (g i)).symm
+
+variable {V}
+
+                                                    
+omit [Fintype ι] in
+theorem mixed_cancel (P D r h : EndFamily (k := k) V)
+    (hDP : ∀ i, D i * P i = -(P i * D i))
+    (hDr : ∀ i, D i * r i = r i * D i)
+    (hPr : ∀ i, P i * r i = r i * P i)
+    (hPh : ∀ i, P i * h i = -(h i * P i))
+    (i j : ι) (hij : i ≠ j) :
+    PiTensorProduct.map (dSlot V P D i) * PiTensorProduct.map (hSlot V P r h j) +
+      PiTensorProduct.map (hSlot V P r h j) * PiTensorProduct.map (dSlot V P D i) = 0 := by
+  rw [← PiTensorProduct.map_mul, ← PiTensorProduct.map_mul]
+  suffices hh : PiTensorProduct.map (dSlot V P D i * hSlot V P r h j) =
+      -PiTensorProduct.map (hSlot V P r h j * dSlot V P D i) by exact add_eq_zero_iff_eq_neg.mpr hh
+  rcases lt_or_gt_of_ne hij with hij | hji
+  · apply tensor_neg_at V _ _ i
+    · simp only [Pi.mul_apply, dSlot, hSlot, lt_irrefl, ite_false, ite_true, hij]
+      rw [← mul_assoc, hDr, mul_assoc, hDP, mul_neg, ← mul_assoc]
+    · intro a hai
+      by_cases haj : a = j
+      · subst a
+        simp [dSlot, hSlot, hai, not_lt_of_gt hij]
+      · by_cases hal : a < i
+        · have hajl : a < j := hal.trans hij
+          simp only [Pi.mul_apply, dSlot, hSlot, hal, hajl, ite_true]
+          rw [← mul_assoc, hPr, mul_assoc]
+        · by_cases hajl : a < j
+          · simp [dSlot, hSlot, hal, hajl, hai]
+          · simp [dSlot, hSlot, hal, hajl, hai, haj]
+  · apply tensor_neg_at V _ _ j
+    · simp only [Pi.mul_apply, dSlot, hSlot, lt_irrefl, ite_false, ite_true, hji]
+      exact hPh j
+    · intro a haj
+      by_cases hai : a = i
+      · subst a
+        simp [dSlot, hSlot, haj, not_lt_of_gt hji]
+      · by_cases hal : a < j
+        · have hail : a < i := hal.trans hji
+          simp only [Pi.mul_apply, dSlot, hSlot, hal, hail, ite_true]
+          rw [← mul_assoc, hPr, mul_assoc]
+        · by_cases hail : a < i
+          · simp [dSlot, hSlot, hal, hail, haj]
+          · simp [dSlot, hSlot, hal, hail, hai, haj]
+
+                                                                
+omit [Fintype ι] in
+theorem diagonal_term (P D r h : EndFamily (k := k) V)
+    (hP2 : ∀ i, P i * P i = 1)
+    (hPr : ∀ i, P i * r i = r i * P i)
+    (hDh : ∀ i, D i * h i + h i * D i = 1 - r i)
+    (i : ι) :
+    PiTensorProduct.map (dSlot V P D i) * PiTensorProduct.map (hSlot V P r h i) +
+      PiTensorProduct.map (hSlot V P r h i) * PiTensorProduct.map (dSlot V P D i) =
+        PiTensorProduct.map (diagSlot V r i) := by
+  rw [← PiTensorProduct.map_mul, ← PiTensorProduct.map_mul]
+  have hbefore (a : ι) : P a * (r a * P a) = r a := by
+    rw [← mul_assoc, hPr, mul_assoc, hP2, mul_one]
+  rw [tensor_add_at V _ _ (diagSlot V r i) i]
+  · congr 1
+    funext a
+    by_cases hai : a = i
+    · subst a
+      simp only [Function.update_self, dSlot, hSlot, diagSlot,
+        lt_irrefl, ite_false, ite_true, hDh]
+    · rw [Function.update_of_ne hai]
+  · intro a hai
+    by_cases hal : a < i
+    · simp [dSlot, hSlot, diagSlot, hal, hbefore]
+    · simp [dSlot, hSlot, diagSlot, hal, hai]
+  · intro a hai
+    by_cases hal : a < i
+    · simp only [dSlot, hSlot, diagSlot, hal, ite_true]
+      rw [mul_assoc, hP2, mul_one]
+    · simp [dSlot, hSlot, diagSlot, hal, hai]
+
+                                                                      
+theorem diagonal_sum (r : EndFamily (k := k) V) :
+    ∑ i, PiTensorProduct.map (diagSlot V r i) = 1 - PiTensorProduct.map r := by
+  let m := PiTensorProduct.mapMultilinear k V V
+  have H := m.map_piecewise_sub_map_piecewise r (1 : EndFamily (k := k) V) (1 : EndFamily (k := k) V) Finset.univ
+  simp only [Finset.piecewise_univ, Finset.mem_univ, ↓reduceIte] at H
+  have hn (i : ι) : m (fun j => if j < i then r j else if j = i then r j - 1 else 1) =
+      -PiTensorProduct.map (diagSlot V r i) := by
+    apply tensor_neg_at V _ _ i
+    · simp [diagSlot]
+    · intro j hji
+      simp [diagSlot, hji]
+  change m r - m (1 : EndFamily (k := k) V) =
+    ∑ i, m (fun j => if j < i then r j else if j = i then r j - 1 else 1) at H
+  simp_rw [hn] at H
+  change PiTensorProduct.map r - PiTensorProduct.map (1 : EndFamily (k := k) V) = _ at H
+  have hone : PiTensorProduct.map (1 : EndFamily (k := k) V) = 1 := PiTensorProduct.map_one
+  rw [hone, Finset.sum_neg_distrib] at H
+  apply neg_injective
+  rw [← H]
+  abel
+
+                                                                                       
+theorem tensor_homotopy (P D r h : EndFamily (k := k) V)
+    (hP2 : ∀ i, P i * P i = 1)
+    (hDP : ∀ i, D i * P i = -(P i * D i))
+    (hDr : ∀ i, D i * r i = r i * D i)
+    (hPr : ∀ i, P i * r i = r i * P i)
+    (hPh : ∀ i, P i * h i = -(h i * P i))
+    (hDh : ∀ i, D i * h i + h i * D i = 1 - r i) :
+    differential V P D * homotopy V P r h + homotopy V P r h * differential V P D =
+      1 - PiTensorProduct.map r := by
+  simp only [differential, homotopy, Finset.sum_mul, Finset.mul_sum]
+  rw [Finset.sum_comm (f := fun i j =>
+    PiTensorProduct.map (dSlot V P D j) * PiTensorProduct.map (hSlot V P r h i)),
+    ← Finset.sum_add_distrib]
+  simp_rw [← Finset.sum_add_distrib]
+  have hsum (i : ι) : ∑ j,
+      (PiTensorProduct.map (dSlot V P D i) * PiTensorProduct.map (hSlot V P r h j) +
+        PiTensorProduct.map (hSlot V P r h j) * PiTensorProduct.map (dSlot V P D i)) =
+      PiTensorProduct.map (diagSlot V r i) := by
+    rw [Finset.sum_eq_single i]
+    · exact diagonal_term P D r h hP2 hPr hDh i
+    · intro j _ hji
+      exact mixed_cancel P D r h hDP hDr hPr hPh i j hji.symm
+    · simp
+  simp_rw [hsum]
+  exact diagonal_sum r
+
+end SignedTensor
+end BoundaryOnly.FormalObstruction
+
+namespace BoundaryOnly.FormalObstruction.SignedTensor
+open GlobalForms
+open scoped TensorProduct BigOperators
+variable {k : Type*} [Field k] {n : ℕ}
+variable (V : Fin (n + 1) → Type*) [∀ i, AddCommGroup (V i)] [∀ i, Module k (V i)]
+
+                                                                          
+                                              
+theorem differential_cons_tprod (P D : EndFamily (k := k) V) (v : ∀ i, V i) :
+    tensorCons V (differential V P D (PiTensorProduct.tprod k v)) =
+      D 0 (v 0) ⊗ₜ[k] PiTensorProduct.tprod k (fun i : Fin n => v i.succ) +
+        P 0 (v 0) ⊗ₜ[k] differential (fun i : Fin n => V i.succ)
+          (fun i => P i.succ) (fun i => D i.succ)
+          (PiTensorProduct.tprod k (fun i : Fin n => v i.succ)) := by
+  simp only [differential, LinearMap.sum_apply, PiTensorProduct.map_tprod, map_sum,
+    tensorCons_tprod]
+  rw [Fin.sum_univ_succ, TensorProduct.tmul_sum]
+  simp only [dSlot, Fin.lt_def, Fin.ext_iff, Fin.val_zero, Fin.val_succ,
+    Nat.not_lt_zero, Nat.succ_ne_zero, Nat.zero_lt_succ, Nat.add_lt_add_iff_right,
+    Nat.add_right_cancel_iff, ite_false, ite_true, Module.End.one_apply]
+
+@[simp] theorem parity_cons_tprod (P : EndFamily (k := k) V) (v : ∀ i, V i) :
+    tensorCons V (PiTensorProduct.map P (PiTensorProduct.tprod k v)) =
+      P 0 (v 0) ⊗ₜ[k] PiTensorProduct.map (fun i : Fin n => P i.succ)
+        (PiTensorProduct.tprod k (fun i : Fin n => v i.succ)) := by
+  simp only [PiTensorProduct.map_tprod, tensorCons_tprod]
+
+end BoundaryOnly.FormalObstruction.SignedTensor
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/FrobeniusObstruction/SquareZero.lean b/lean/OAI/Algebra/FrobeniusObstruction/SquareZero.lean
new file mode 100644
index 0000000000000000000000000000000000000000..d4f329645d5243bd167518c5e04ca1c2b38452bc
--- /dev/null
+++ b/lean/OAI/Algebra/FrobeniusObstruction/SquareZero.lean
@@ -0,0 +1,384 @@
+import Mathlib
+
+namespace OAI
+
+noncomputable section
+open scoped BigOperators
+
+namespace BoundaryOnly.FormalObstruction
+namespace SquareZero
+variable {k V : Type*} [Field k] [AddCommGroup V] [Module k V]
+variable (δ : V →ₗ[k] V) (hδ : ∀ x, δ (δ x) = 0)
+
+abbrev Cycles := LinearMap.ker δ
+
+def boundaryMap : V →ₗ[k] Cycles δ :=
+  δ.codRestrict (Cycles δ) (fun x => hδ x)
+
+def boundaries : Submodule k (Cycles δ) := (boundaryMap δ hδ).range
+
+abbrev Cohomology := (Cycles δ) ⧸ boundaries δ hδ
+
+def classMap : Cycles δ →ₗ[k] Cohomology δ hδ := (boundaries δ hδ).mkQ
+
+@[simp] theorem class_boundary (x : V) :
+    classMap δ hδ (boundaryMap δ hδ x) = 0 := by
+  change (Submodule.Quotient.mk (boundaryMap δ hδ x) : Cohomology δ hδ) = 0
+  exact (Submodule.Quotient.mk_eq_zero _).mpr ⟨x, rfl⟩
+
+theorem class_eq_zero (x : Cycles δ) : classMap δ hδ x = 0 ↔ ∃ y, δ y = x := by
+  change (Submodule.Quotient.mk x : Cohomology δ hδ) = 0 ↔ _
+  rw [Submodule.Quotient.mk_eq_zero]
+  constructor
+  · rintro ⟨y, hy⟩
+    exact ⟨y, congrArg Subtype.val hy⟩
+  · rintro ⟨y, hy⟩
+    exact ⟨y, Subtype.ext hy⟩
+
+theorem classMap_surjective : Function.Surjective (classMap δ hδ) :=
+  Submodule.mkQ_surjective _
+
+                                                                               
+                                                                    
+def cycleMap (f g : V →ₗ[k] V) (hfg : ∀ x, δ (f x) = g (δ x)) :
+    Cycles δ →ₗ[k] Cycles δ :=
+  (f.comp (Cycles δ).subtype).codRestrict (Cycles δ) (fun x => by
+    change δ (f (x : V)) = 0
+    rw [hfg, x.property, map_zero])
+
+@[simp] theorem cycleMap_val (f g : V →ₗ[k] V) (hfg : ∀ x, δ (f x) = g (δ x))
+    (x : Cycles δ) : (cycleMap δ f g hfg x : V) = f x := rfl
+
+def induced (f g j : V →ₗ[k] V)
+    (hfg : ∀ x, δ (f x) = g (δ x)) (hfj : ∀ x, f (δ x) = δ (j x)) :
+    Cohomology δ hδ →ₗ[k] Cohomology δ hδ :=
+  (boundaries δ hδ).mapQ (boundaries δ hδ) (cycleMap δ f g hfg) (by
+    rintro _ ⟨x, rfl⟩
+    exact ⟨j x, Subtype.ext (hfj x).symm⟩)
+
+@[simp] theorem induced_class (f g j : V →ₗ[k] V)
+    (hfg : ∀ x, δ (f x) = g (δ x)) (hfj : ∀ x, f (δ x) = δ (j x))
+    (x : Cycles δ) :
+    induced δ hδ f g j hfg hfj (classMap δ hδ x) =
+      classMap δ hδ (cycleMap δ f g hfg x) := rfl
+
+                                                                            
+theorem induced_ext (f g : Cohomology δ hδ →ₗ[k] Cohomology δ hδ)
+    (h : ∀ z : Cycles δ, f (classMap δ hδ z) = g (classMap δ hδ z)) : f = g := by
+  apply LinearMap.ext
+  intro x
+  obtain ⟨z, rfl⟩ := classMap_surjective δ hδ x
+  exact h z
+
+theorem induced_square_zero (f g j : V →ₗ[k] V)
+    (hfg : ∀ x, δ (f x) = g (δ x)) (hfj : ∀ x, f (δ x) = δ (j x))
+    (hf : ∀ x, f (f x) = 0) (x : Cohomology δ hδ) :
+    induced δ hδ f g j hfg hfj (induced δ hδ f g j hfg hfj x) = 0 := by
+  obtain ⟨z, rfl⟩ := classMap_surjective δ hδ x
+  rw [induced_class, induced_class]
+  have hz : cycleMap δ f g hfg (cycleMap δ f g hfg z) = 0 := Subtype.ext (hf z)
+  rw [hz, map_zero]
+
+                                                                        
+                                                              
+def oddInduced (D : V →ₗ[k] V) (hD : ∀ x, δ (D x) = -D (δ x)) :
+    Cohomology δ hδ →ₗ[k] Cohomology δ hδ :=
+  induced δ hδ D (-D) (-D) hD (fun x => by
+    change D (δ x) = δ (-D x)
+    rw [map_neg, hD, neg_neg])
+
+@[simp] theorem oddInduced_class (D : V →ₗ[k] V) (hD : ∀ x, δ (D x) = -D (δ x))
+    (z : Cycles δ) :
+    oddInduced δ hδ D hD (classMap δ hδ z) =
+      classMap δ hδ (cycleMap δ D (-D) hD z) := rfl
+
+theorem oddInduced_square_zero (D : V →ₗ[k] V) (hD : ∀ x, δ (D x) = -D (δ x))
+    (hDD : ∀ x, D (D x) = 0) (x : Cohomology δ hδ) :
+    oddInduced δ hδ D hD (oddInduced δ hδ D hD x) = 0 :=
+  induced_square_zero δ hδ _ _ _ _ _ hDD x
+
+                                                                                   
+def evenInduced (S : V →ₗ[k] V) (hS : ∀ x, δ (S x) = S (δ x)) :
+    Cohomology δ hδ →ₗ[k] Cohomology δ hδ :=
+  induced δ hδ S S S hS (fun x => (hS x).symm)
+
+@[simp] theorem evenInduced_class (S : V →ₗ[k] V) (hS : ∀ x, δ (S x) = S (δ x))
+    (z : Cycles δ) :
+    evenInduced δ hδ S hS (classMap δ hδ z) =
+      classMap δ hδ (cycleMap δ S S hS z) := rfl
+
+                                                                            
+                                
+theorem correction_of_kernel (D S T : V →ₗ[k] V)
+    (hD : ∀ x, δ (D x) = -D (δ x))
+    (hS : ∀ x, δ (S x) = S (δ x))
+    (_ : ∀ x, δ (T x) = -T (δ x))
+    (hDS : ∀ x, D (S x) - S (D x) = T x)
+    (x : Cycles δ)
+    (hSx : evenInduced δ hδ S hS (classMap δ hδ x) = 0)
+    (hSDx : evenInduced δ hδ S hS
+      (oddInduced δ hδ D hD (classMap δ hδ x)) = 0) :
+    ∃ y : V, δ y = -T x := by
+  rw [evenInduced_class] at hSx
+  obtain ⟨u, hu⟩ := (class_eq_zero δ hδ _).mp hSx
+  rw [oddInduced_class, evenInduced_class] at hSDx
+  obtain ⟨v, hv⟩ := (class_eq_zero δ hδ _).mp hSDx
+  change δ u = S x at hu
+  change δ v = S (D x) at hv
+  refine ⟨D u + v, ?_⟩
+  rw [map_add, hD, hu, hv, ← hDS]
+  abel
+
+end SquareZero
+end BoundaryOnly.FormalObstruction
+
+namespace BoundaryOnly.FormalObstruction.SquareZero
+variable {k V : Type*} [Field k] [AddCommGroup V] [Module k V]
+
+private theorem generalized_inverse (S : V →ₗ[k] V) :
+    ∃ L : V →ₗ[k] V, ∀ x, S (L (S x)) = S x := by
+  obtain ⟨g,hg⟩ := S.rangeRestrict.exists_rightInverse_of_surjective S.range_rangeRestrict
+  obtain ⟨h,hh⟩ := S.range.subtype.exists_leftInverse_of_injective S.range.ker_subtype
+  refine ⟨g.comp h, fun x => ?_⟩
+  have hx : h (S x) = S.rangeRestrict x := LinearMap.congr_fun hh (S.rangeRestrict x)
+  change S (g (h (S x))) = S x
+  rw [hx]
+  exact congrArg Subtype.val (LinearMap.congr_fun hg (S.rangeRestrict x))
+
+                                                                          
+                                                                               
+theorem cohomology_contraction (δ : V →ₗ[k] V) (hδ : ∀ x, δ (δ x) = 0) :
+    ∃ (i : Cohomology δ hδ →ₗ[k] V) (p : V →ₗ[k] Cohomology δ hδ) (h : V →ₗ[k] V),
+      (∀ x, δ (i x) = 0) ∧ (∀ x, p (δ x) = 0) ∧
+      (∀ x, p (i x) = x) ∧
+      (∀ z : Cycles δ, p z = classMap δ hδ z) ∧
+      (∀ x, x - i (p x) = δ (h x) + h (δ x)) := by
+  obtain ⟨g, hg⟩ := generalized_inverse δ
+  let q := LinearMap.id - δ.comp g - g.comp δ
+  have hq (x : V) : q x = x - δ (g x) - g (δ x) := rfl
+  have hδq (x : V) : δ (q x) = 0 := by
+    rw [hq, map_sub, map_sub, hδ, sub_zero, hg, sub_self]
+  have hqδ (x : V) : q (δ x) = 0 := by
+    rw [hq, hg, sub_self, hδ, map_zero, sub_zero]
+  let qz := q.codRestrict (Cycles δ) hδq
+  have hqz (z : Cycles δ) :
+      qz z = z - boundaryMap δ hδ (g z) := by
+    apply Subtype.ext
+    change q z = (z : V) - δ (g z)
+    rw [hq, z.property, map_zero, sub_zero]
+  obtain ⟨j, hj⟩ := (classMap δ hδ).exists_rightInverse_of_surjective
+    (LinearMap.range_eq_top.mpr (classMap_surjective δ hδ))
+  have hj' (x : Cohomology δ hδ) : classMap δ hδ (j x) = x :=
+    LinearMap.congr_fun hj x
+  let i := (Cycles δ).subtype.comp j
+  let p := (classMap δ hδ).comp qz
+  have hpz (z : Cycles δ) : p z = classMap δ hδ z := by
+    change classMap δ hδ (qz z) = _
+    rw [hqz, map_sub, class_boundary, sub_zero]
+  have hpδ (x : V) : p (δ x) = 0 := by
+    change classMap δ hδ (qz (δ x)) = 0
+    have hz : qz (δ x) = 0 := Subtype.ext (hqδ x)
+    rw [hz, map_zero]
+  let K : V →ₗ[k] boundaries δ hδ :=
+    (qz - j.comp p).codRestrict (boundaries δ hδ) (fun x => by
+      apply (Submodule.Quotient.mk_eq_zero _).mp
+      change classMap δ hδ (qz x - j (p x)) = 0
+      rw [map_sub, hj']
+      exact sub_self _)
+  obtain ⟨b, hb⟩ := (boundaryMap δ hδ).rangeRestrict.exists_rightInverse_of_surjective
+    (boundaryMap δ hδ).range_rangeRestrict
+  let b' : boundaries δ hδ →ₗ[k] V := b
+  let h₁ := b'.comp K
+  have hh₁ (x : V) : δ (h₁ x) = q x - i (p x) :=
+    congrArg (fun z : boundaries δ hδ => ((z : Cycles δ) : V))
+      (LinearMap.congr_fun hb (K x))
+  have hKδ (x : V) : K (δ x) = 0 := by
+    apply Subtype.ext
+    apply Subtype.ext
+    change q (δ x) - i (p (δ x)) = 0
+    rw [hqδ, hpδ, map_zero, sub_zero]
+  refine ⟨i, p, g + h₁, ?_, hpδ, ?_, hpz, ?_⟩
+  · intro x; exact (j x).property
+  · intro x; exact (hpz (j x)).trans (hj' x)
+  · intro x
+    have hz : h₁ (δ x) = 0 := by change b' (K (δ x)) = 0; rw [hKδ, map_zero]
+    simp only [LinearMap.add_apply, map_add, hh₁, hz, add_zero]
+    rw [hq]
+    abel
+
+end BoundaryOnly.FormalObstruction.SquareZero
+
+namespace BoundaryOnly.FormalObstruction.SquareZero
+variable {k V : Type*} [Field k] [AddCommGroup V] [Module k V]
+
+                                                                               
+theorem odd_generalized_inverse (htwo : (2 : k) ≠ 0)
+    (δ P : V →ₗ[k] V) (hPP : ∀ x, P (P x) = x)
+    (hDP : ∀ x, δ (P x) = -P (δ x)) :
+    ∃ g : V →ₗ[k] V, (∀ x, δ (g (δ x)) = δ x) ∧
+      (∀ x, g (P x) = -P (g x)) := by
+  obtain ⟨g,hg⟩ := generalized_inverse δ
+  let c : k := (2 : k)⁻¹
+  have hc : c+c = 1 := by dsimp [c]; field_simp; ring
+  let g' : V →ₗ[k] V := c • (g - P.comp (g.comp P))
+  have hg' (x : V) : g' x = c • (g x - P (g (P x))) := rfl
+  refine ⟨g', ?_, ?_⟩
+  · intro x
+    have hpd : P (δ x) = -δ (P x) := by rw [hDP, neg_neg]
+    rw [hg', map_smul, map_sub, hg, hDP (g (P (δ x))), hpd]
+    simp only [map_neg]
+    rw [hg, hDP]
+    simp only [map_neg, hPP, neg_neg, sub_neg_eq_add]
+    rw [smul_add, ← add_smul, hc, one_smul]
+  · intro x
+    simp only [hg', map_smul, map_sub, hPP]
+    module
+
+                                                                
+theorem odd_homotopy (htwo : (2 : k) ≠ 0)
+    (δ P r h : V →ₗ[k] V) (hPP : ∀ x, P (P x) = x)
+    (hDP : ∀ x, δ (P x) = -P (δ x))
+    (hrP : ∀ x, r (P x) = P (r x))
+    (hrh : ∀ x, x - r x = δ (h x) + h (δ x)) :
+    ∃ h' : V →ₗ[k] V,
+      (∀ x, h' (P x) = -P (h' x)) ∧
+      (∀ x, x - r x = δ (h' x) + h' (δ x)) := by
+  let c : k := (2 : k)⁻¹
+  have hc : c+c = 1 := by dsimp [c]; field_simp; ring
+  let h' : V →ₗ[k] V := c • (h - P.comp (h.comp P))
+  have hh' (x : V) : h' x = c • (h x - P (h (P x))) := rfl
+  have hPD (x : V) : P (δ x) = -δ (P x) := by rw [hDP, neg_neg]
+  refine ⟨h', ?_, ?_⟩
+  · intro x
+    simp only [hh', map_smul, map_sub, hPP]
+    module
+  · intro x
+    have h₂ := congrArg P (hrh (P x))
+    simp only [map_sub, map_add, hrP, hPP] at h₂
+    rw [hPD (h (P x)), hDP x, map_neg, map_neg] at h₂
+    rw [hh', hh']
+    simp only [map_smul, map_sub]
+    calc
+      x - r x = c • (x - r x) + c • (x - r x) := by
+        rw [← add_smul, hc, one_smul]
+      _ = c • (δ (h x) + h (δ x)) +
+          c • (-δ (P (h (P x))) - P (h (P (δ x)))) := by
+        conv_lhs => arg 1; rw [hrh]
+        congr 1
+        exact congrArg (c • ·) (by simpa only [sub_eq_add_neg] using h₂)
+      _ = _ := by module
+
+end BoundaryOnly.FormalObstruction.SquareZero
+
+namespace BoundaryOnly.FormalObstruction.SquareZero
+variable {k V W : Type*} [Field k] [AddCommGroup V] [Module k V]
+  [AddCommGroup W] [Module k W]
+
+private theorem equivariant_section (htwo : (2 : k) ≠ 0)
+    (f : V →ₗ[k] W) (hf : Function.Surjective f)
+    (P : V →ₗ[k] V) (Q : W →ₗ[k] W)
+    (hPP : ∀ x, P (P x) = x) (hQQ : ∀ x, Q (Q x) = x)
+    (hfP : ∀ x, f (P x) = Q (f x)) :
+    ∃ j : W →ₗ[k] V, (∀ x, f (j x) = x) ∧ (∀ x, j (Q x) = P (j x)) := by
+  obtain ⟨j,hj⟩ := f.exists_rightInverse_of_surjective (LinearMap.range_eq_top.mpr hf)
+  have hj' (x : W) : f (j x) = x := LinearMap.congr_fun hj x
+  let c : k := (2 : k)⁻¹
+  have hc : c+c = 1 := by dsimp [c]; field_simp; ring
+  let j' : W →ₗ[k] V := c • (j + P.comp (j.comp Q))
+  have hj'val (x : W) : j' x = c • (j x + P (j (Q x))) := rfl
+  refine ⟨j', ?_, ?_⟩
+  · intro x
+    simp only [hj'val, map_smul, map_add, hfP, hj', hQQ]
+    rw [smul_add, ← add_smul, hc, one_smul]
+  · intro x
+    simp only [hj'val, map_smul, map_add, hPP, hQQ]
+    module
+
+                                                                              
+                                                                             
+theorem parity_cohomology_contraction (htwo : (2 : k) ≠ 0)
+    (δ P : V →ₗ[k] V) (hδ : ∀ x, δ (δ x) = 0)
+    (hPP : ∀ x, P (P x) = x) (hDP : ∀ x, δ (P x) = -P (δ x)) :
+    ∃ (i : Cohomology δ hδ →ₗ[k] V) (p : V →ₗ[k] Cohomology δ hδ)
+      (h : V →ₗ[k] V),
+      (∀ x, δ (i x) = 0) ∧ (∀ x, p (δ x) = 0) ∧
+      (∀ x, p (i x) = x) ∧
+      (∀ z : Cycles δ, p z = classMap δ hδ z) ∧
+      (∀ x, i (oddInduced δ hδ P hDP x) = P (i x)) ∧
+      (∀ x, p (P x) = oddInduced δ hδ P hDP (p x)) ∧
+      (∀ x, h (P x) = -P (h x)) ∧
+      (∀ x, x - i (p x) = δ (h x) + h (δ x)) := by
+  let PZ := cycleMap δ P (-P) hDP
+  let PH := oddInduced δ hδ P hDP
+  have hPZ (x : Cycles δ) : PZ (PZ x) = x := Subtype.ext (hPP x)
+  have hclP (z : Cycles δ) : classMap δ hδ (PZ z) = PH (classMap δ hδ z) := rfl
+  have hPH (x : Cohomology δ hδ) : PH (PH x) = x := by
+    obtain ⟨z, rfl⟩ := classMap_surjective δ hδ x
+    rw [← hclP, ← hclP, hPZ]
+  obtain ⟨j,hj',hjP⟩ := equivariant_section htwo (classMap δ hδ)
+    (classMap_surjective δ hδ) PZ PH hPZ hPH hclP
+  obtain ⟨g,hg,hgP⟩ := odd_generalized_inverse htwo δ P hPP hDP
+  let q := LinearMap.id - δ.comp g - g.comp δ
+  have hq (x : V) : q x = x - δ (g x) - g (δ x) := rfl
+  have hδq (x : V) : δ (q x) = 0 := by
+    rw [hq, map_sub, map_sub, hδ, sub_zero, hg, sub_self]
+  have hqδ (x : V) : q (δ x) = 0 := by
+    rw [hq, hg, sub_self, hδ, map_zero, sub_zero]
+  have hqP (x : V) : q (P x) = P (q x) := by
+    simp only [hq, hgP, hDP, map_sub, map_neg, neg_neg]
+  let qz := q.codRestrict (Cycles δ) hδq
+  have hqz (z : Cycles δ) : qz z = z - boundaryMap δ hδ (g z) := by
+    apply Subtype.ext
+    change q z = (z : V) - δ (g z)
+    rw [hq, z.property, map_zero, sub_zero]
+  let i := (Cycles δ).subtype.comp j
+  let p := (classMap δ hδ).comp qz
+  have hpz (z : Cycles δ) : p z = classMap δ hδ z := by
+    change classMap δ hδ (qz z) = _
+    rw [hqz, map_sub, class_boundary, sub_zero]
+  have hpδ (x : V) : p (δ x) = 0 := by
+    change classMap δ hδ (qz (δ x)) = 0
+    have hz : qz (δ x) = 0 := Subtype.ext (hqδ x)
+    rw [hz, map_zero]
+  have hiP (x : Cohomology δ hδ) : i (PH x) = P (i x) :=
+    congrArg Subtype.val (hjP x)
+  have hpP (x : V) : p (P x) = PH (p x) := by
+    change classMap δ hδ (qz (P x)) = PH (classMap δ hδ (qz x))
+    rw [← hclP]
+    exact congrArg (classMap δ hδ) (Subtype.ext (hqP x))
+  let K : V →ₗ[k] boundaries δ hδ :=
+    (qz - j.comp p).codRestrict (boundaries δ hδ) (fun x => by
+      apply (Submodule.Quotient.mk_eq_zero _).mp
+      change classMap δ hδ (qz x - j (p x)) = 0
+      rw [map_sub, hj']
+      exact sub_self _)
+  obtain ⟨b, hb⟩ := (boundaryMap δ hδ).rangeRestrict.exists_rightInverse_of_surjective
+    (boundaryMap δ hδ).range_rangeRestrict
+  let b' : boundaries δ hδ →ₗ[k] V := b
+  let h₁ := b'.comp K
+  have hh₁ (x : V) : δ (h₁ x) = q x - i (p x) :=
+    congrArg (fun z : boundaries δ hδ => ((z : Cycles δ) : V))
+      (LinearMap.congr_fun hb (K x))
+  have hKδ (x : V) : K (δ x) = 0 := by
+    apply Subtype.ext
+    apply Subtype.ext
+    change q (δ x) - i (p (δ x)) = 0
+    rw [hqδ, hpδ, map_zero, sub_zero]
+  have hraw (x : V) : x - i (p x) = δ ((g+h₁) x) + (g+h₁) (δ x) := by
+    have hz : h₁ (δ x) = 0 := by change b' (K (δ x)) = 0; rw [hKδ, map_zero]
+    simp only [LinearMap.add_apply, map_add, hh₁, hz, add_zero]
+    rw [hq]
+    abel
+  have hrP (x : V) : (i.comp p) (P x) = P ((i.comp p) x) := by
+    change i (p (P x)) = P (i (p x))
+    rw [hpP, hiP]
+  obtain ⟨h,hhP,hhh⟩ := odd_homotopy htwo δ P (i.comp p) (g+h₁) hPP hDP hrP hraw
+  refine ⟨i,p,h,?_,hpδ,?_,hpz,hiP,hpP,hhP,hhh⟩
+  · intro x; exact (j x).property
+  · intro x; exact (hpz (j x)).trans (hj' x)
+
+end BoundaryOnly.FormalObstruction.SquareZero
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/FrobeniusObstruction/TangentCharts.lean b/lean/OAI/Algebra/FrobeniusObstruction/TangentCharts.lean
new file mode 100644
index 0000000000000000000000000000000000000000..e9958239df8ea9e3d1f792e30c738a284ae3d5f8
--- /dev/null
+++ b/lean/OAI/Algebra/FrobeniusObstruction/TangentCharts.lean
@@ -0,0 +1,221 @@
+import Mathlib
+import OAI.Algebra.FrobeniusObstruction.FormalData
+
+namespace OAI
+
+noncomputable section
+open scoped BigOperators
+
+namespace BoundaryOnly.FormalObstruction.Frobenius
+variable {ι κ k : Type*} [Fintype ι] [DecidableEq ι]
+  [Fintype κ] [DecidableEq κ] [Field k]
+variable (ell : ℕ) (htwo : 1 < ell) [CharP k ell]
+
+theorem tangentCoeff_eq_augmentation_partial (i : ι) (x : Ring (ι := ι) (k := k) ell) :
+    tangentCoeff ell htwo i x = augmentation ell (by omega) (partialDeriv ell i x) := by
+  obtain ⟨p, rfl⟩ := Ideal.Quotient.mk_surjective x
+  rw [tangentCoeff_mk, partial_mk]
+  change _ = MvPowerSeries.constantCoeff (MvPowerSeries.pderiv i p)
+  rw [← MvPowerSeries.coeff_zero_eq_constantCoeff, MvPowerSeries.coeff_pderiv]
+  simp
+
+omit [DecidableEq κ] [CharP k ell] in
+theorem augmentation_natural (f : Ring (ι := ι) (k := k) ell →ₐ[k]
+    Ring (ι := κ) (k := k) ell) :
+    (augmentation ell (by omega)).comp f = augmentation ell (by omega) := by
+  apply algHom_ext
+  intro i
+  rw [AlgHom.comp_apply, augmentation_coordinate]
+  apply eq_zero_of_pow_eq_zero (n := ell)
+  rw [← map_pow, ← map_pow, coordinate_pow, map_zero, map_zero]
+
+theorem tangentCoeff_chain_rule (f : Ring (ι := ι) (k := k) ell →ₐ[k]
+    Ring (ι := κ) (k := k) ell) (j : κ) (x : Ring (ι := ι) (k := k) ell) :
+    tangentCoeff ell htwo j (f x) = ∑ i, tangentCoeff ell htwo i x *
+      tangentCoeff ell htwo j (f (coordinate ell i)) := by
+  rw [tangentCoeff_eq_augmentation_partial, partial_chain_rule, map_sum]
+  apply Finset.sum_congr rfl
+  intro i _
+  rw [map_mul, ← tangentCoeff_eq_augmentation_partial,
+    ← AlgHom.comp_apply, augmentation_natural ell htwo f, ← tangentCoeff_eq_augmentation_partial]
+
+end BoundaryOnly.FormalObstruction.Frobenius
+
+namespace BoundaryOnly.FormalObstruction
+variable {k : Type*} [Field k] {d : ℕ} {n : Fin d → ℕ}
+variable (ell : ℕ) (htwo : 1 < ell) [CharP k ell] [Fact ell.Prime]
+open Frobenius
+
+                                                                        
+theorem graph_constant_zero (D : FormalData (k := k) n) (c : InternalVar n) :
+    MvPowerSeries.constantCoeff (D.Y c) = 0 := by
+  have h : originIdeal k (GraphVar n) ≤ RingHom.ker MvPowerSeries.constantCoeff := by
+    apply Ideal.span_le.mpr
+    rintro _ ⟨i, rfl⟩
+    simp
+  exact h (D.centered c)
+
+                                                                            
+                             
+def graphSlot (b : Bool) : Frobenius.Ring (ι := GraphVar n) (k := k) ell →ₐ[k]
+    Frobenius.Ring (ι := InternalVar n) (k := k) ell :=
+  eval ell (fun v => match v with
+    | .inl _ => 0
+    | .inr t => coordinate ell (b,t)) (by
+      intro v
+      cases v with
+      | inl a => exact zero_pow (Nat.Prime.ne_zero Fact.out)
+      | inr t => exact coordinate_pow ell (b,t))
+
+omit [CharP k ell] in
+@[simp] theorem graphSlot_slope (b : Bool) (a : SlopeVar d) :
+    graphSlot (n := n) (k := k) ell b (coordinate ell (.inl a)) = 0 :=
+  eval_coordinate ell _ _ _
+
+omit [CharP k ell] in
+@[simp] theorem graphSlot_tangent (b : Bool) (t : TangentVar n) :
+    graphSlot (k := k) ell b (coordinate ell (.inr t)) = coordinate ell (b,t) :=
+  eval_coordinate ell _ _ _
+
+                                                                             
+def fixedComplement (D : FormalData (k := k) n) (c : InternalVar n) :
+    Frobenius.Ring (ι := InternalVar n) (k := k) ell :=
+  ∑ t : TangentVar n, tangentMatrix n D.Y (swapBlocks n c) t • coordinate ell (true,t)
+
+omit [CharP k ell] in
+@[simp] theorem fixedComplement_augmentation (D : FormalData (k := k) n) (c : InternalVar n) :
+    augmentation ell (Nat.Prime.pos Fact.out) (fixedComplement ell D c) = 0 := by
+  simp [fixedComplement]
+
+theorem fixedComplement_pow (D : FormalData (k := k) n) (c : InternalVar n) :
+    fixedComplement ell D c ^ ell = 0 := by
+  apply frobenius_zero_of_constant
+  change (augmentation ell (Nat.Prime.pos Fact.out) (fixedComplement ell D c)) ^ ell = 0
+  rw [fixedComplement_augmentation, zero_pow (Nat.Prime.ne_zero Fact.out)]
+
+def specialChartCoordinate (D : FormalData (k := k) n) (c : InternalVar n) :
+    Frobenius.Ring (ι := InternalVar n) (k := k) ell :=
+  graphSlot ell false (Ideal.Quotient.mk _ (D.Y c)) + fixedComplement ell D c
+
+theorem specialChartCoordinate_pow (D : FormalData (k := k) n) (c : InternalVar n) :
+    specialChartCoordinate ell D c ^ ell = 0 := by
+  have h (c : InternalVar n) :
+      (Ideal.Quotient.mk (powerIdeal (k := k) ell) (D.Y c)) ^ ell = 0 := by
+    apply frobenius_zero_of_constant
+    rw [constantHom_mk, graph_constant_zero D c]
+    exact zero_pow (Nat.Prime.ne_zero Fact.out)
+  let : CharP (Frobenius.Ring (ι := InternalVar n) (k := k) ell) ell :=
+    quotient_charP (Nat.Prime.pos Fact.out)
+  have hslot :
+      (graphSlot ell false (Ideal.Quotient.mk _ (D.Y c))) ^ ell = 0 := by
+    rw [← map_pow, h, map_zero]
+  rw [specialChartCoordinate, add_pow_char, hslot, fixedComplement_pow, zero_add]
+
+                                                                        
+def specialChart (D : FormalData (k := k) n) :
+    Frobenius.Ring (ι := InternalVar n) (k := k) ell →ₐ[k]
+      Frobenius.Ring (ι := InternalVar n) (k := k) ell :=
+  eval ell (specialChartCoordinate ell D) (specialChartCoordinate_pow ell D)
+
+@[simp] theorem specialChart_coordinate (D : FormalData (k := k) n) (c : InternalVar n) :
+    specialChart ell D (coordinate ell c) = specialChartCoordinate ell D c :=
+  eval_coordinate ell _ _ _
+
+theorem graphSlot_tangentCoeff (b : Bool) (j : InternalVar n)
+    (x : Frobenius.Ring (ι := GraphVar n) (k := k) ell) :
+    tangentCoeff ell htwo j (graphSlot ell b x) =
+      if j.1 = b then tangentCoeff ell htwo (.inr j.2) x else 0 := by
+  rw [tangentCoeff_chain_rule]
+  rw [Fintype.sum_sum_type]
+  simp only [graphSlot_slope, map_zero, mul_zero, Finset.sum_const_zero, zero_add,
+    graphSlot_tangent, tangentCoeff_coordinate]
+  obtain ⟨b', t⟩ := j
+  by_cases hb : b' = b
+  · subst b'
+    simp only [Prod.mk.injEq, true_and, mul_ite, mul_one, mul_zero, Finset.sum_ite_eq,
+      Finset.mem_univ, ite_true]
+  · simp only [Prod.mk.injEq, hb, false_and, ite_false, mul_zero, Finset.sum_const_zero]
+
+omit [CharP k ell] [Fact (Nat.Prime ell)] in
+theorem fixedComplement_tangentCoeff (D : FormalData (k := k) n)
+    (c j : InternalVar n) :
+    tangentCoeff ell htwo j (fixedComplement ell D c) =
+      if j.1 then tangentMatrix n D.Y (swapBlocks n c) j.2 else 0 := by
+  unfold fixedComplement
+  simp only [map_sum, map_smul, tangentCoeff_coordinate, smul_eq_mul]
+  obtain ⟨b,t⟩ := j
+  cases b <;> simp
+
+theorem specialChart_tangent_matrix (D : FormalData (k := k) n) :
+    (fun i j => tangentCoeff ell htwo j (specialChart ell D (coordinate ell i))) =
+      complementaryMatrix n D.Y := by
+  funext i j
+  rw [specialChart_coordinate, specialChartCoordinate, map_add,
+    graphSlot_tangentCoeff, fixedComplement_tangentCoeff]
+  have h (c : InternalVar n) : tangentCoeff ell htwo (.inr j.2)
+        (Ideal.Quotient.mk (powerIdeal (k := k) ell) (D.Y c)) = tangentMatrix n D.Y c j.2 := by
+    rw [tangentCoeff_eq_augmentation_partial, partial_mk]
+    rfl
+  rw [h]
+  obtain ⟨b,t⟩ := j
+  cases b <;> simp [complementaryMatrix]
+
+include htwo in
+theorem specialChart_bijective (D : FormalData (k := k) n) :
+    Function.Bijective (specialChart ell D) := by
+  apply bijective_of_tangent_matrix ell htwo
+  rw [specialChart_tangent_matrix]
+  exact isUnit_iff_ne_zero.mpr D.complementary
+
+def specialChartEquiv (D : FormalData (k := k) n) :
+    Frobenius.Ring (ι := InternalVar n) (k := k) ell ≃ₐ[k]
+      Frobenius.Ring (ι := InternalVar n) (k := k) ell :=
+  AlgEquiv.ofBijective (specialChart ell D) (specialChart_bijective ell htwo D)
+
+end BoundaryOnly.FormalObstruction
+
+namespace BoundaryOnly.FormalObstruction.Frobenius
+variable {ι k : Type*} [Fintype ι] [DecidableEq ι] [Field k]
+variable (ell : ℕ) (htwo : 1 < ell) [CharP k ell]
+
+def tangentJacobian (f : Ring (ι := ι) (k := k) ell →ₐ[k] Ring (ι := ι) (k := k) ell) :
+    Matrix ι ι k := fun i j => tangentCoeff ell htwo j (f (coordinate ell i))
+
+theorem tangentJacobian_comp
+    (f g : Ring (ι := ι) (k := k) ell →ₐ[k] Ring (ι := ι) (k := k) ell) :
+    tangentJacobian ell htwo (f.comp g) =
+      tangentJacobian ell htwo g * tangentJacobian ell htwo f := by
+  ext i j
+  exact tangentCoeff_chain_rule ell htwo f j (g (coordinate ell i))
+
+omit [CharP k ell] in
+@[simp] theorem tangentJacobian_id :
+    tangentJacobian (ι := ι) (k := k) ell htwo (AlgHom.id k _) = 1 := by
+  ext i j
+  simp only [tangentJacobian, AlgHom.id_apply, tangentCoeff_coordinate, Matrix.one_apply]
+  by_cases h : i = j
+  · subst j; simp only [ite_true]
+  · rw [ite_eq_right (Ne.symm h), ite_eq_right h]
+
+                                                                              
+                                                                           
+theorem tangentJacobian_det_unit
+    (f : Ring (ι := ι) (k := k) ell ≃ₐ[k] Ring (ι := ι) (k := k) ell) :
+    IsUnit (tangentJacobian ell htwo f.toAlgHom).det := by
+  have he : f.symm.toAlgHom.comp f.toAlgHom = AlgHom.id k _ := by
+    ext x
+    exact f.symm_apply_apply x
+  have hm := tangentJacobian_comp ell htwo f.symm.toAlgHom f.toAlgHom
+  rw [he, tangentJacobian_id] at hm
+  have hd := congrArg Matrix.det hm
+  rw [Matrix.det_one, Matrix.det_mul] at hd
+  apply isUnit_iff_ne_zero.mpr
+  intro h
+  rw [h, zero_mul] at hd
+  exact one_ne_zero hd
+
+end BoundaryOnly.FormalObstruction.Frobenius
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/FrobeniusObstruction/TensorCohomology.lean b/lean/OAI/Algebra/FrobeniusObstruction/TensorCohomology.lean
new file mode 100644
index 0000000000000000000000000000000000000000..31695b5fe71509ea8340f078400aff1f5777dab6
--- /dev/null
+++ b/lean/OAI/Algebra/FrobeniusObstruction/TensorCohomology.lean
@@ -0,0 +1,149 @@
+import Mathlib
+import OAI.Algebra.FrobeniusObstruction.SignedTensor
+import OAI.Algebra.FrobeniusObstruction.BlockCohomology
+
+namespace OAI
+
+noncomputable section
+open scoped BigOperators TensorProduct
+
+namespace BoundaryOnly.FormalObstruction.SignedTensor
+variable {k ι : Type*} [Field k] [Fintype ι] [LinearOrder ι]
+variable {V W : ι → Type*} [∀ i, AddCommGroup (V i)] [∀ i, Module k (V i)]
+  [∀ i, AddCommGroup (W i)] [∀ i, Module k (W i)]
+
+                                                                           
+                     
+omit [Fintype ι] in
+theorem tensor_map_zero_at (f : ∀ i, V i →ₗ[k] W i) (i : ι) (hi : f i = 0) :
+    PiTensorProduct.map f = 0 := by
+  have hf : f = Function.update f i 0 := (Function.update_eq_self_iff.mpr hi.symm).symm
+  rw [hf]
+  exact (PiTensorProduct.mapMultilinear k V W).map_update_zero f i
+
+                                                      
+theorem representatives_cycles (P D : EndFamily (k := k) V)
+    (j : ∀ i, W i →ₗ[k] V i) (hj : ∀ i, (D i).comp (j i) = 0) :
+    (differential V P D).comp (PiTensorProduct.map j) = 0 := by
+  change (∑ i, PiTensorProduct.map (dSlot V P D i)).comp (PiTensorProduct.map j) = 0
+  rw [show (∑ i, PiTensorProduct.map (dSlot V P D i)).comp (PiTensorProduct.map j) =
+    ∑ i, (PiTensorProduct.map (dSlot V P D i)).comp (PiTensorProduct.map j) from by
+      ext x; simp]
+  apply Finset.sum_eq_zero
+  intro i _
+  rw [← PiTensorProduct.map_comp]
+  apply tensor_map_zero_at _ i
+  simpa [dSlot] using hj i
+
+                                                    
+theorem projection_boundaries (P D : EndFamily (k := k) V)
+    (p : ∀ i, V i →ₗ[k] W i) (hp : ∀ i, (p i).comp (D i) = 0) :
+    (PiTensorProduct.map p).comp (differential V P D) = 0 := by
+  change (PiTensorProduct.map p).comp (∑ i, PiTensorProduct.map (dSlot V P D i)) = 0
+  rw [show (PiTensorProduct.map p).comp (∑ i, PiTensorProduct.map (dSlot V P D i)) =
+    ∑ i, (PiTensorProduct.map p).comp (PiTensorProduct.map (dSlot V P D i)) from by
+      ext x; simp]
+  apply Finset.sum_eq_zero
+  intro i _
+  rw [← PiTensorProduct.map_comp]
+  apply tensor_map_zero_at _ i
+  simpa [dSlot] using hp i
+
+                                                                              
+                                                                                
+                                                                                   
+theorem tensor_cycle_decomposition (P D : EndFamily (k := k) V)
+    (j : ∀ i, W i →ₗ[k] V i) (p : ∀ i, V i →ₗ[k] W i)
+    (h : EndFamily (k := k) V)
+    (hP2 : ∀ i, P i * P i = 1) (hDP : ∀ i, D i * P i = -(P i * D i))
+    (hDj : ∀ i, (D i).comp (j i) = 0) (hpD : ∀ i, (p i).comp (D i) = 0)
+    (hjP : ∀ i, P i * ((j i).comp (p i)) = ((j i).comp (p i)) * P i)
+    (hPh : ∀ i, P i * h i = -(h i * P i))
+    (hDh : ∀ i, D i * h i + h i * D i = 1 - ((j i).comp (p i)))
+    (z : ⨂[k] i, V i) (hz : differential V P D z = 0) :
+    ∃ y : ⨂[k] i, V i,
+      z - PiTensorProduct.map j (PiTensorProduct.map p z) = differential V P D y := by
+  let r : EndFamily (k := k) V := fun i => (j i).comp (p i)
+  have hdr (i : ι) : D i * r i = r i * D i := by
+    change (D i).comp ((j i).comp (p i)) = ((j i).comp (p i)).comp (D i)
+    rw [← LinearMap.comp_assoc, hDj, LinearMap.zero_comp,
+      LinearMap.comp_assoc, hpD, LinearMap.comp_zero]
+  have H := tensor_homotopy P D r h hP2 hDP hdr hjP hPh hDh
+  have He := LinearMap.congr_fun H z
+  simp only [Module.End.mul_apply, LinearMap.add_apply, LinearMap.sub_apply,
+    Module.End.one_apply, hz, map_zero, add_zero] at He
+  refine ⟨homotopy V P r h z, ?_⟩
+  change z - ((PiTensorProduct.map j).comp (PiTensorProduct.map p)) z = _
+  rw [← PiTensorProduct.map_comp]
+  exact He.symm
+
+                                                                            
+                                                                             
+theorem tensor_representatives_injective_mod_boundaries (P D : EndFamily (k := k) V)
+    (j : ∀ i, W i →ₗ[k] V i) (p : ∀ i, V i →ₗ[k] W i)
+    (hpj : ∀ i, (p i).comp (j i) = LinearMap.id)
+    (hpD : ∀ i, (p i).comp (D i) = 0)
+    (w : ⨂[k] i, W i) (z : ⨂[k] i, V i)
+    (hwz : PiTensorProduct.map j w = differential V P D z) : w = 0 := by
+  have h := congrArg (PiTensorProduct.map p) hwz
+  have hpj' : (PiTensorProduct.map p).comp (PiTensorProduct.map j) = LinearMap.id := by
+    rw [← PiTensorProduct.map_comp]
+    simpa only [hpj] using (PiTensorProduct.map_id (R := k) (s := W))
+  change ((PiTensorProduct.map p).comp (PiTensorProduct.map j)) w =
+    ((PiTensorProduct.map p).comp (differential V P D)) z at h
+  rw [hpj', projection_boundaries P D p hpD] at h
+  exact h
+
+end BoundaryOnly.FormalObstruction.SignedTensor
+
+namespace BoundaryOnly.FormalObstruction.SignedTensor
+variable {k ι : Type*} [Field k] [Fintype ι] [LinearOrder ι]
+variable {V W : ι → Type*} [∀ i, AddCommGroup (V i)] [∀ i, Module k (V i)]
+  [∀ i, AddCommGroup (W i)] [∀ i, Module k (W i)]
+
+                                                                            
+                                                               
+theorem project_differential (P D : EndFamily (k := k) V)
+    (Q E : EndFamily (k := k) W)
+    (j : ∀ i, W i →ₗ[k] V i) (p : ∀ i, V i →ₗ[k] W i)
+    (hpj : ∀ i, (p i).comp (j i) = LinearMap.id)
+    (hP : ∀ i, (p i).comp ((P i).comp (j i)) = Q i)
+    (hD : ∀ i, (p i).comp ((D i).comp (j i)) = E i) :
+    (PiTensorProduct.map p).comp ((differential V P D).comp (PiTensorProduct.map j)) =
+      differential W Q E := by
+  apply PiTensorProduct.ext
+  ext v
+  simp only [LinearMap.compMultilinearMap_apply, LinearMap.comp_apply,
+    differential, LinearMap.sum_apply, PiTensorProduct.map_tprod, map_sum]
+  apply Finset.sum_congr rfl
+  intro i _
+  congr 1
+  funext a
+  change p a (dSlot V P D i a (j a (v a))) = dSlot W Q E i a (v a)
+  by_cases hlt : a < i
+  · simp only [dSlot, ite_eq_left hlt]
+    exact LinearMap.congr_fun (hP a) (v a)
+  · by_cases heq : a = i
+    · simp only [dSlot, ite_eq_right hlt, ite_eq_left heq]
+      exact LinearMap.congr_fun (hD a) (v a)
+    · simp only [dSlot, ite_eq_right hlt, ite_eq_right heq, Module.End.one_apply]
+      exact LinearMap.congr_fun (hpj a) (v a)
+
+                                                                       
+                               
+omit [Fintype ι] [LinearOrder ι] in
+theorem project_tensor_map (S : EndFamily (k := k) V) (T : EndFamily (k := k) W)
+    (j : ∀ i, W i →ₗ[k] V i) (p : ∀ i, V i →ₗ[k] W i)
+    (hS : ∀ i, (p i).comp ((S i).comp (j i)) = T i) :
+    (PiTensorProduct.map p).comp ((PiTensorProduct.map S).comp (PiTensorProduct.map j)) =
+      PiTensorProduct.map T := by
+  rw [← PiTensorProduct.map_comp, ← PiTensorProduct.map_comp]
+  congr 1
+  funext i
+  exact hS i
+
+end BoundaryOnly.FormalObstruction.SignedTensor
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/FrobeniusObstruction/TensorKernels.lean b/lean/OAI/Algebra/FrobeniusObstruction/TensorKernels.lean
new file mode 100644
index 0000000000000000000000000000000000000000..60ce69926887e64e7766dee8c64591e6f3c3ce3c
--- /dev/null
+++ b/lean/OAI/Algebra/FrobeniusObstruction/TensorKernels.lean
@@ -0,0 +1,225 @@
+import Mathlib
+import OAI.Algebra.FrobeniusObstruction.TensorCohomology
+import OAI.Algebra.FrobeniusObstruction.CycleTransfer
+
+namespace OAI
+
+noncomputable section
+open scoped BigOperators TensorProduct
+
+namespace BoundaryOnly.FormalObstruction
+
+variable {k : Type*} [Field k]
+
+private theorem generalized_inverse {V : Type*} [AddCommGroup V] [Module k V]
+    (S : V →ₗ[k] V) : ∃ L : V →ₗ[k] V, ∀ x, S (L (S x)) = S x := by
+  obtain ⟨g,hg⟩ := S.rangeRestrict.exists_rightInverse_of_surjective S.range_rangeRestrict
+  obtain ⟨h,hh⟩ := S.range.subtype.exists_leftInverse_of_injective S.range.ker_subtype
+  refine ⟨g.comp h, fun x => ?_⟩
+  have hx : h (S x) = S.rangeRestrict x :=
+    LinearMap.congr_fun hh (S.rangeRestrict x)
+  change S (g (h (S x))) = S x
+  rw [hx]
+  exact congrArg Subtype.val (LinearMap.congr_fun hg (S.rangeRestrict x))
+
+variable {ι : Type*} [Fintype ι] [DecidableEq ι]
+variable (V : ι → Type*) [∀ i, AddCommGroup (V i)] [∀ i, Module k (V i)]
+
+                                                                       
+                             
+def kernelTensorSpace (S : ∀ i, V i →ₗ[k] V i) (J : Finset ι) :
+    Submodule k (⨂[k] i, V i) :=
+  Submodule.span k {z | ∃ m : ∀ i, V i,
+    (∀ i ∈ J, S i (m i) = 0) ∧ PiTensorProduct.tprod k m = z}
+
+                                         
+def tensorAction (S : ∀ i, V i →ₗ[k] V i) (I : Finset ι) :
+    (⨂[k] i, V i) →ₗ[k] (⨂[k] i, V i) :=
+  PiTensorProduct.map fun i => if i ∈ I then S i else LinearMap.id
+
+                                                                             
+                                                                            
+                                                                        
+theorem joint_tensor_kernel (S : ∀ i, V i →ₗ[k] V i) (active : Finset ι) :
+    (⨅ (I : Finset ι) (_ : I ⊆ active) (_ : I.card = 3),
+      LinearMap.ker (tensorAction V S I)) =
+    (⨆ (J : Finset ι) (_ : J ⊆ active) (_ : (active \ J).card ≤ 2),
+      kernelTensorSpace V S J) := by
+  classical
+  let R := ⨆ (J : Finset ι) (_ : J ⊆ active) (_ : (active \ J).card ≤ 2),
+      kernelTensorSpace V S J
+  have hR (J : Finset ι) (hJ : J ⊆ active) (hc : (active \ J).card ≤ 2) :
+      kernelTensorSpace V S J ≤ R := le_iSup_of_le J (le_iSup_of_le hJ (le_iSup_of_le hc le_rfl))
+  apply le_antisymm
+  · intro x hx
+    have hz (I : Finset ι) (hI : I ⊆ active) (hcard : I.card = 3) :
+        tensorAction V S I x = 0 := by
+      exact ((Submodule.mem_iInf _).mp ((Submodule.mem_iInf _).mp ((Submodule.mem_iInf _).mp hx I) hI) hcard)
+    choose L hL using fun i => generalized_inverse (S i)
+    let Q (i : ι) := (L i).comp (S i)
+    let P (i : ι) := LinearMap.id - Q i
+    have hSP (i : ι) (v : V i) : S i (P i v) = 0 := by
+      change S i (v - L i (S i v)) = 0
+      rw [map_sub, hL, sub_self]
+    let F (A : Finset ι) := PiTensorProduct.map fun i => if i ∈ A then Q i else P i
+    have hsum : ∑ A : Finset ι, F A = LinearMap.id := by
+      apply PiTensorProduct.ext
+      ext m
+      simp only [LinearMap.compMultilinearMap_apply, LinearMap.sum_apply, LinearMap.id_apply]
+      simp only [F, PiTensorProduct.map_tprod]
+      have hm : (fun i => Q i (m i)) + (fun i => P i (m i)) = m := by
+        funext i
+        change Q i (m i) + (m i - Q i (m i)) = m i
+        abel
+      conv_rhs => rw [← hm, (PiTensorProduct.tprod k).map_add_univ]
+      apply Finset.sum_congr rfl
+      intro A ha
+      congr 1
+      funext i
+      simp only [Finset.piecewise]
+      split_ifs <;> rfl
+    have hFx (A : Finset ι) : F A x ∈ R := by
+      by_cases hc : (active ∩ A).card ≤ 2
+      · let J := active \ A
+        have hJ : J ⊆ active := Finset.sdiff_subset
+        have hjc : (active \ J).card ≤ 2 := by
+          simpa only [J, Finset.sdiff_sdiff_self_left] using hc
+        apply hR J hJ hjc
+        clear hx hz
+        induction x using PiTensorProduct.induction_on with
+        | smul_tprod c m =>
+          rw [map_smul]
+          apply Submodule.smul_mem
+          apply Submodule.subset_span
+          refine ⟨fun i => (if i ∈ A then Q i else P i) (m i), ?_, ?_⟩
+          · intro i hi
+            have hiA : i ∉ A := (Finset.mem_sdiff.mp hi).2
+            simpa only [ite_eq_right hiA] using hSP i (m i)
+          · exact (PiTensorProduct.map_tprod _ _).symm
+        | add x y hx hy =>
+          rw [map_add]
+          exact Submodule.add_mem _ hx hy
+      · have hc' : 3 ≤ (active ∩ A).card := by omega
+        obtain ⟨I,hI,hcard⟩ := Finset.exists_subset_card_eq hc'
+        have hIa : I ⊆ active := fun i hi => (Finset.mem_inter.mp (hI hi)).1
+        have hIA : I ⊆ A := fun i hi => (Finset.mem_inter.mp (hI hi)).2
+        let H := PiTensorProduct.map fun i =>
+          if i ∈ I then L i else if i ∈ A then Q i else P i
+        have hcomp : F A = H.comp (tensorAction V S I) := by
+          dsimp only [F, H, tensorAction]
+          rw [← PiTensorProduct.map_comp]
+          congr 1
+          funext i
+          by_cases hi : i ∈ I
+          · simp only [ite_eq_left hi, ite_eq_left (hIA hi), Q]
+          · simp only [ite_eq_right hi, LinearMap.comp_id]
+        rw [hcomp, LinearMap.comp_apply, hz I hIa hcard, map_zero]
+        exact R.zero_mem
+    change x ∈ R
+    have hsx := LinearMap.congr_fun hsum x
+    simp only [LinearMap.sum_apply, LinearMap.id_apply] at hsx
+    rw [← hsx]
+    exact Submodule.sum_mem R (fun A _ => hFx A)
+  · refine iSup_le fun J => iSup_le fun hJ => iSup_le fun hc => ?_
+    refine le_iInf fun I => le_iInf fun hI => le_iInf fun hcard => ?_
+    apply Submodule.span_le.mpr
+    rintro z ⟨m,hm,rfl⟩
+    have hex : ∃ i ∈ I, i ∈ J := by
+      by_contra hn
+      have hsub : I ⊆ active \ J := by
+        intro i hi
+        exact Finset.mem_sdiff.mpr ⟨hI hi, fun hij => hn ⟨i,hi,hij⟩⟩
+      have := Finset.card_le_card hsub
+      omega
+    obtain ⟨i,hiI,hiJ⟩ := hex
+    change tensorAction V S I (PiTensorProduct.tprod k m) = 0
+    rw [tensorAction, PiTensorProduct.map_tprod]
+    apply (PiTensorProduct.tprod k).map_coord_zero i
+    simpa only [ite_eq_left hiI] using hm i hiJ
+
+end BoundaryOnly.FormalObstruction
+
+namespace BoundaryOnly.FormalObstruction
+open scoped BigOperators TensorProduct
+
+variable {k ι : Type*} [Field k] [Fintype ι] [LinearOrder ι]
+variable {V : ι → Type*} [∀ i, AddCommGroup (V i)] [∀ i, Module k (V i)]
+
+                                                                       
+                                                                       
+                                                                           
+theorem select_special_fiber_tensor
+    (S P D r h : SignedTensor.EndFamily (k := k) V)
+    (active : Finset ι) (hcard : 5 ≤ active.card)
+    (hP2 : ∀ i, P i * P i = 1)
+    (hDP : ∀ i, D i * P i = -(P i * D i))
+    (hDr : ∀ i, D i * r i = r i * D i)
+    (hPr : ∀ i, P i * r i = r i * P i)
+    (hPh : ∀ i, P i * h i = -(h i * P i))
+    (hDh : ∀ i, D i * h i + h i * D i = 1 - r i)
+    (hNr : ∀ i ∈ active, ∀ x, S i x = 0 →
+      S i (r i x) = 0 ∧ S i (D i (r i x)) = 0)
+    (φ : (⨂[k] i, V i) →ₗ[k] k)
+    (hφD : ∀ x, φ (SignedTensor.differential V P D x) = 0)
+    (z : ⨂[k] i, V i)
+    (hDz : SignedTensor.differential V P D z = 0)
+    (hφz : φ z ≠ 0)
+    (hz : ∀ I : Finset ι, I ⊆ active → I.card = 3 → tensorAction V S I z = 0) :
+    ∃ (J : Finset ι) (m : ∀ i, V i),
+      J ⊆ active ∧ 3 ≤ J.card ∧
+      (∀ i ∈ J, S i (m i) = 0 ∧ S i (D i (m i)) = 0) ∧
+      φ (PiTensorProduct.tprod k m) ≠ 0 := by
+  classical
+  let Good : Set (⨂[k] i, V i) := {x | ∃ (J : Finset ι) (m : ∀ i, V i),
+    J ⊆ active ∧ (active \ J).card ≤ 2 ∧
+    (∀ i ∈ J, S i (m i) = 0 ∧ S i (D i (m i)) = 0) ∧
+    PiTensorProduct.tprod k m = x}
+  let T := Submodule.span k Good
+  have hm : (⨅ (I : Finset ι) (_ : I ⊆ active) (_ : I.card = 3),
+      LinearMap.ker (tensorAction V S I)) ≤ T.comap (PiTensorProduct.map r) := by
+    rw [joint_tensor_kernel]
+    refine iSup_le fun J => iSup_le fun hJ => iSup_le fun hJc => ?_
+    apply Submodule.span_le.mpr
+    rintro _ ⟨m,hm,rfl⟩
+    change PiTensorProduct.map r (PiTensorProduct.tprod k m) ∈ T
+    rw [PiTensorProduct.map_tprod]
+    apply Submodule.subset_span
+    refine ⟨J,fun i => r i (m i),hJ,hJc,?_,rfl⟩
+    intro i hi
+    exact hNr i (hJ hi) (m i) (hm i hi)
+  have hzmem : z ∈ (⨅ (I : Finset ι) (_ : I ⊆ active) (_ : I.card = 3),
+      LinearMap.ker (tensorAction V S I)) := by
+    simp only [Submodule.mem_iInf, LinearMap.mem_ker]
+    exact hz
+  have hRz : PiTensorProduct.map r z ∈ T := hm hzmem
+  have hpair : φ (PiTensorProduct.map r z) = φ z := by
+    have H := LinearMap.congr_fun
+      (SignedTensor.tensor_homotopy P D r h hP2 hDP hDr hPr hPh hDh) z
+    change SignedTensor.differential V P D (SignedTensor.homotopy V P r h z) +
+      SignedTensor.homotopy V P r h (SignedTensor.differential V P D z) =
+        z - PiTensorProduct.map r z at H
+    have Hφ := congrArg φ H
+    rw [hDz, map_zero, add_zero, hφD, map_sub] at Hφ
+    exact (sub_eq_zero.mp Hφ.symm).symm
+  have hex : ∃ x ∈ Good, φ x ≠ 0 := by
+    by_contra hn
+    have hle : T ≤ LinearMap.ker φ := by
+      apply Submodule.span_le.mpr
+      intro x hx
+      change φ x = 0
+      by_contra hnx
+      exact hn ⟨x,hx,hnx⟩
+    apply hφz
+    rw [← hpair]
+    exact hle hRz
+  obtain ⟨_,⟨J,m,hJ,hJc,hm,rfl⟩,hp⟩ := hex
+  refine ⟨J,m,hJ,?_,hm,hp⟩
+  have hc := Finset.card_sdiff_of_subset hJ
+  have hle := Finset.card_le_card hJ
+  omega
+
+end BoundaryOnly.FormalObstruction
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/FrobeniusObstruction/ThreeParameters.lean b/lean/OAI/Algebra/FrobeniusObstruction/ThreeParameters.lean
new file mode 100644
index 0000000000000000000000000000000000000000..d5957ee478047a33a4d42f41aeac12ec75758565
--- /dev/null
+++ b/lean/OAI/Algebra/FrobeniusObstruction/ThreeParameters.lean
@@ -0,0 +1,158 @@
+import Mathlib
+
+namespace OAI
+
+noncomputable section
+open scoped BigOperators
+
+namespace BoundaryOnly.FormalObstruction
+namespace ThreeParameters
+
+variable (k : Type*) [Field k]
+
+abbrev Poly := MvPolynomial (Fin 3) k
+
+def squareIdeal : Ideal (Poly k) :=
+  Ideal.span (Set.range fun i : Fin 3 => (MvPolynomial.X i : Poly k) ^ 2)
+
+abbrev Ring := Poly k ⧸ squareIdeal k
+
+def s (i : Fin 3) : Ring k := Ideal.Quotient.mk _ (MvPolynomial.X i)
+
+def w : Ring k := s k 0 * s k 1 * s k 2
+
+@[simp] theorem s_sq (i : Fin 3) : s k i ^ 2 = 0 := by
+  rw [s, ← map_pow]
+  apply Ideal.Quotient.eq_zero_iff_mem.mpr
+  exact Ideal.subset_span ⟨i, rfl⟩
+
+def topExponent : Fin 3 →₀ ℕ := Finsupp.equivFunOnFinite.symm (fun _ => 1)
+
+@[simp] theorem topExponent_apply (i : Fin 3) : topExponent i = 1 := by
+  simp [topExponent]
+
+theorem topCoeff_ideal (p : Poly k) (hp : p ∈ squareIdeal k) :
+    p.coeff topExponent = 0 := by
+  obtain ⟨c, rfl⟩ := Ideal.mem_span_range_iff_exists_fun.mp hp
+  rw [MvPolynomial.coeff_sum]
+  apply Finset.sum_eq_zero
+  intro i _
+  rw [MvPolynomial.X_pow_eq_monomial, MvPolynomial.coeff_mul_monomial']
+  have hi : ¬ Finsupp.single i 2 ≤ topExponent := by
+    intro h
+    have := h i
+    simp only [Finsupp.single_eq_same, topExponent_apply] at this
+    omega
+  rw [ite_eq_right hi]
+
+theorem w_ne_zero : w k ≠ 0 := by
+  intro hw
+  have hmem : (MvPolynomial.X 0 * MvPolynomial.X 1 * MvPolynomial.X 2 : Poly k)
+      ∈ squareIdeal k := by
+    apply Ideal.Quotient.eq_zero_iff_mem.mp
+    simpa only [map_mul, s, w] using hw
+  have hc := topCoeff_ideal k _ hmem
+  have he : Finsupp.single (0 : Fin 3) 1 + Finsupp.single 1 1 +
+      Finsupp.single 2 1 = topExponent := by
+    ext i
+    fin_cases i <;> norm_num [Finsupp.single_apply]
+  have hprod : (MvPolynomial.X 0 * MvPolynomial.X 1 * MvPolynomial.X 2 : Poly k) =
+      MvPolynomial.monomial topExponent 1 := by
+    simp only [MvPolynomial.X, MvPolynomial.monomial_mul_monomial, one_mul, he]
+  rw [hprod, MvPolynomial.coeff_monomial, ite_eq_left rfl] at hc
+  exact one_ne_zero hc
+
+                                                                                
+def augmentation : Ring k →+* k :=
+  Ideal.Quotient.lift _ MvPolynomial.constantCoeff (by
+    intro p hp
+    obtain ⟨c, rfl⟩ := Ideal.mem_span_range_iff_exists_fun.mp hp
+    simp)
+
+@[simp] theorem augmentation_mk (p : Poly k) :
+    augmentation k (Ideal.Quotient.mk _ p) = MvPolynomial.constantCoeff p := rfl
+
+@[simp] theorem w_mul_s (i : Fin 3) : w k * s k i = 0 := by
+  fin_cases i
+  · calc
+      w k * s k 0 = s k 0 ^ 2 * s k 1 * s k 2 := by dsimp [w]; ring
+      _ = 0 := by simp
+  · calc
+      w k * s k 1 = s k 0 * s k 1 ^ 2 * s k 2 := by dsimp [w]; ring
+      _ = 0 := by simp
+  · calc
+      w k * s k 2 = s k 0 * s k 1 * s k 2 ^ 2 := by dsimp [w]; ring
+      _ = 0 := by simp
+
+                                                                    
+theorem w_mul (b : Ring k) : w k * b = augmentation k b • w k := by
+  obtain ⟨p, rfl⟩ := Ideal.Quotient.mk_surjective b
+  induction p using MvPolynomial.induction_on with
+  | C c =>
+    simp only [augmentation_mk, MvPolynomial.constantCoeff_C]
+    change w k * algebraMap k (Ring k) c = c • w k
+    simpa only [mul_comm] using (Algebra.smul_def c (w k)).symm
+  | add p q hp hq =>
+    simp only [map_add, mul_add, augmentation_mk, hp, hq, add_smul]
+  | mul_X p i hp =>
+    simp only [map_mul, augmentation_mk, MvPolynomial.constantCoeff_X, mul_zero, zero_smul]
+    change w k * (Ideal.Quotient.mk _ p * s k i) = 0
+    rw [← mul_assoc, mul_right_comm, w_mul_s, zero_mul]
+
+                                                                            
+                                                                        
+theorem residue_contradiction (b : Ring k) (hb : augmentation k b ≠ 0)
+    (hwb : w k * b = 0) : False := by
+  rw [w_mul] at hwb
+  exact w_ne_zero k ((smul_eq_zero.mp hwb).resolve_left hb)
+
+end ThreeParameters
+end BoundaryOnly.FormalObstruction
+
+namespace BoundaryOnly.FormalObstruction.ThreeParameters
+variable (k : Type*) [Field k]
+
+@[simp] theorem augmentation_s (i : Fin 3) : augmentation k (s k i) = 0 := by
+  simp [s]
+
+@[simp] theorem augmentation_algebraMap (a : k) :
+    augmentation k (algebraMap k (Ring k) a) = a := by
+  change MvPolynomial.constantCoeff (MvPolynomial.C a) = a
+  simp
+
+                                                                                 
+theorem nilpotent_sub_augmentation (b : Ring k) :
+    IsNilpotent (b - algebraMap k (Ring k) (augmentation k b)) := by
+  obtain ⟨p, rfl⟩ := Ideal.Quotient.mk_surjective b
+  induction p using MvPolynomial.induction_on with
+  | C c =>
+    rw [augmentation_mk, MvPolynomial.constantCoeff_C]
+    change IsNilpotent (algebraMap k (Ring k) c - algebraMap k (Ring k) c)
+    simp
+  | add p q hp hq =>
+    simp only [map_add]
+    rw [show (Ideal.Quotient.mk _ p + Ideal.Quotient.mk _ q) -
+        (algebraMap k (Ring k) (augmentation k (Ideal.Quotient.mk _ p)) +
+         algebraMap k (Ring k) (augmentation k (Ideal.Quotient.mk _ q))) =
+        (Ideal.Quotient.mk _ p - algebraMap k (Ring k) (augmentation k (Ideal.Quotient.mk _ p))) +
+        (Ideal.Quotient.mk _ q - algebraMap k (Ring k) (augmentation k (Ideal.Quotient.mk _ q))) by ring]
+    exact (Commute.all _ _).isNilpotent_add hp hq
+  | mul_X p i hp =>
+    simp only [map_mul, augmentation_mk, MvPolynomial.constantCoeff_X, mul_zero, map_zero,
+      sub_zero]
+    exact (Commute.all _ _).isNilpotent_mul_left ⟨2, s_sq k i⟩
+
+                                                              
+theorem isUnit_of_augmentation_ne_zero (b : Ring k) (hb : augmentation k b ≠ 0) :
+    IsUnit b := by
+  have hunit : IsUnit (algebraMap k (Ring k) (augmentation k b)) :=
+    (isUnit_iff_ne_zero.mpr hb).map _
+  have hnil := nilpotent_sub_augmentation k b
+  have h := hnil.isUnit_add_left_of_commute hunit (Commute.all _ _)
+  simpa only [add_sub_cancel] using h
+
+end BoundaryOnly.FormalObstruction.ThreeParameters
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/FrobeniusObstruction/TopResidue.lean b/lean/OAI/Algebra/FrobeniusObstruction/TopResidue.lean
new file mode 100644
index 0000000000000000000000000000000000000000..0e8df9b060219249b7c97c89ac8b959ec4947ac9
--- /dev/null
+++ b/lean/OAI/Algebra/FrobeniusObstruction/TopResidue.lean
@@ -0,0 +1,195 @@
+import Mathlib
+import OAI.Algebra.FrobeniusObstruction.LinearChange
+import OAI.Algebra.FrobeniusObstruction.FormTensor
+
+namespace OAI
+
+noncomputable section
+open scoped BigOperators
+
+namespace BoundaryOnly.FormalObstruction.Frobenius
+variable {ι κ k : Type*} [Fintype ι] [Fintype κ] [DecidableEq ι] [DecidableEq κ]
+  [CommRing k] (ell : ℕ)
+
+def reindex (e : ι ≃ κ) : Ring (ι := ι) (k := k) ell ≃ₐ[k] Ring (ι := κ) (k := k) ell :=
+  AlgEquiv.ofAlgHom (includeVariables ell e) (includeVariables ell e.symm)
+    (by apply algHom_ext; intro i; simp)
+    (by apply algHom_ext; intro i; simp)
+
+@[simp] theorem reindex_coordinate (e : ι ≃ κ) (i : ι) :
+    reindex (k := k) ell e (coordinate ell i) = coordinate ell (e i) :=
+  includeVariables_coordinate ell e i
+
+@[simp] theorem partial_reindex [CharP k ell] (e : ι ≃ κ) (i : ι)
+    (a : Ring (ι := ι) (k := k) ell) :
+    partialDeriv ell (e i) (reindex ell e a) = reindex ell e (partialDeriv ell i a) := by
+  let f : Ring (ι := ι) (k := k) ell →ₐ[k] Ring (ι := κ) (k := k) ell :=
+    (reindex ell e).toAlgHom
+  have H : (partialDeriv (k := k) ell (e i)).toLinearMap.comp f.toLinearMap =
+      f.toLinearMap.comp (partialDeriv ell i).toLinearMap := by
+    apply relativeDeriv_ext ell f
+    · simp
+    · simp
+    · intro x y; simp only [LinearMap.comp_apply, AlgHom.toLinearMap_apply, map_mul,
+        Derivation.coeFn_coe, Derivation.leibniz, smul_eq_mul]; ring
+    · intro x y; simp only [LinearMap.comp_apply, AlgHom.toLinearMap_apply,
+        Derivation.coeFn_coe, Derivation.leibniz, smul_eq_mul, map_add, map_mul]
+      ring
+    · intro j
+      change partialDeriv ell (e i) (reindex ell e (coordinate ell j)) =
+        reindex ell e (partialDeriv ell i (coordinate ell j))
+      rw [reindex_coordinate]
+      simp only [coordinate, partial_coordinate]
+      by_cases hij : i = j
+      · subst j; simp
+      · simp [hij, e.injective.ne hij]
+  exact LinearMap.congr_fun H a
+
+end BoundaryOnly.FormalObstruction.Frobenius
+
+namespace BoundaryOnly.FormalObstruction.FormsReindex
+open Frobenius MixedForms
+open scoped TensorProduct
+variable {ι κ k : Type*} [DecidableEq ι] [DecidableEq κ]
+  [CommRing k] (ell : ℕ)
+
+def vec (e : ι ≃ κ) : (ι → k) ≃ₗ[k] (κ → k) :=
+  LinearEquiv.piCongrLeft' k (fun _ : ι => k) e
+
+def exterior (e : ι ≃ κ) : ExteriorAlgebra k (ι → k) ≃ₐ[k] ExteriorAlgebra k (κ → k) :=
+  AlgEquiv.ofAlgHom (ExteriorAlgebra.map (vec (k := k) e).toLinearMap)
+    (ExteriorAlgebra.map (vec (k := k) e).symm.toLinearMap)
+    (by ext v; simp)
+    (by ext v; simp)
+
+@[simp] theorem exterior_gen (e : ι ≃ κ) (i : ι) :
+    exterior (k := k) e (gen i) = gen (e i) := by
+  change ExteriorAlgebra.map (vec e).toLinearMap (ExteriorAlgebra.ι k (Pi.single i 1)) = _
+  rw [ExteriorAlgebra.map_apply_ι]
+  congr 1
+  funext j
+  simp only [vec, Pi.single_apply]
+  by_cases h : j = e i
+  · subst j; simp
+  · have h' : e.symm j ≠ i := by intro he; exact h (by simpa using congrArg e he)
+    simp [h, h']
+
+variable [Fintype ι] [Fintype κ]
+
+abbrev QForms (ι : Type*) [Fintype ι] [DecidableEq ι] :=
+  MixedForms.Forms (k := k) (A := Ring (ι := ι) (k := k) ell) (ι := ι)
+
+def equiv (e : ι ≃ κ) : QForms (k := k) ell ι ≃ₐ[k] QForms (k := k) ell κ :=
+  Algebra.TensorProduct.congr (Frobenius.reindex ell e) (exterior e)
+
+@[simp] theorem equiv_tmul (e : ι ≃ κ) (a : Ring (ι := ι) (k := k) ell)
+    (x : ExteriorAlgebra k (ι → k)) : equiv ell e (a ⊗ₜ[k] x) =
+      Frobenius.reindex ell e a ⊗ₜ[k] exterior e x := rfl
+
+@[simp] theorem equiv_d [CharP k ell] (e : ι ≃ κ) (x : QForms (k := k) ell ι) :
+    equiv ell e (d (partialDeriv ell) x) = d (partialDeriv ell) (equiv ell e x) := by
+  induction x using TensorProduct.inductionOn with
+  | add x y hx hy => simp only [map_add, hx, hy]
+  | tmul a x =>
+    simp only [d_tmul, map_sum, equiv_tmul, map_mul, exterior_gen]
+    rw [← Equiv.sum_comp e]
+    apply Finset.sum_congr rfl
+    intro i _
+    rw [partial_reindex]
+
+@[simp] theorem equiv_coeff (e : ι ≃ κ) (a : Ring (ι := ι) (k := k) ell) :
+    equiv ell e (coeff a) = coeff (Frobenius.reindex ell e a) := by
+  change equiv ell e (a ⊗ₜ[k] (1 : ExteriorAlgebra k (ι → k))) =
+    Frobenius.reindex ell e a ⊗ₜ[k] (1 : ExteriorAlgebra k (κ → k))
+  rw [equiv_tmul, map_one]
+
+@[simp] theorem equiv_gradient [CharP k ell] (e : ι ≃ κ)
+    (a : Ring (ι := ι) (k := k) ell) :
+    equiv ell e (gradient (partialDeriv ell) a) =
+      gradient (partialDeriv ell) (Frobenius.reindex ell e a) := by
+  rw [← d_coeff, equiv_d, equiv_coeff, d_coeff]
+
+@[simp] theorem equiv_delta [CharP k ell] (e : ι ≃ κ)
+    (a : Ring (ι := ι) (k := k) ell) (x : QForms (k := k) ell ι) :
+    equiv ell e (delta (partialDeriv ell) a x) =
+      delta (partialDeriv ell) (Frobenius.reindex ell e a) (equiv ell e x) := by
+  simp only [delta_apply, map_mul, equiv_gradient]
+
+end BoundaryOnly.FormalObstruction.FormsReindex
+
+namespace BoundaryOnly.FormalObstruction.Frobenius
+variable {ι k : Type*} [Fintype ι] [DecidableEq ι] [Field k]
+variable (ell : ℕ) (hell : 0 < ell)
+
+                                                                               
+omit [DecidableEq ι] in
+theorem quotientCoeff_coordinate_mul (i : ι) (e : ι →₀ ℕ)
+    (he : Good ell e) (hes : Good ell (Finsupp.single i 1 + e))
+    (x : Ring (ι := ι) (k := k) ell) :
+    quotientCoeff ell (Finsupp.single i 1 + e) hes (coordinate ell i * x) =
+      quotientCoeff ell e he x := by
+  obtain ⟨f, rfl⟩ := Ideal.Quotient.mk_surjective x
+  change quotientCoeff ell (Finsupp.single i 1 + e) hes
+    (Ideal.Quotient.mk _ (MvPowerSeries.X i) * Ideal.Quotient.mk _ f) = _
+  rw [← map_mul, quotientCoeff_mk, quotientCoeff_mk]
+  rw [MvPowerSeries.X_def, MvPowerSeries.coeff_monomial_mul]
+  simp
+
+                                                                             
+theorem eq_smul_top_of_coordinate_annihilate
+    (x : Ring (ι := ι) (k := k) ell) (hx : ∀ i, coordinate ell i * x = 0) :
+    x = quotientCoeff ell (topExponent ell) (topExponent_good hell) x • topMonomial ell := by
+  apply quotient_ext
+  intro e he
+  rw [map_smul]
+  change quotientCoeff ell e he x = _ *
+    quotientCoeff ell e he (Ideal.Quotient.mk _ (MvPowerSeries.monomial (topExponent ell) (1 : k)))
+  rw [quotientCoeff_mk, MvPowerSeries.coeff_monomial]
+  by_cases het : e = topExponent ell
+  · subst e
+    simp
+  · rw [ite_eq_right het, mul_zero]
+    have hlt : ∃ i, e i < ell - 1 := by
+      by_contra hn
+      push Not at hn
+      apply het
+      ext i
+      have hi := he i
+      simp only [topExponent_apply]
+      exact Nat.le_antisymm (by omega) (hn i)
+    obtain ⟨i, hi⟩ := hlt
+    have hs : Good ell (Finsupp.single i 1 + e) := by
+      intro j
+      by_cases hij : i = j
+      · subst j; simp only [Finsupp.add_apply, Finsupp.single_eq_same]; omega
+      · simpa only [Finsupp.add_apply, Finsupp.single_eq_of_ne (Ne.symm hij), zero_add]
+          using he j
+    have hshift := quotientCoeff_coordinate_mul ell i e he hs x
+    rw [hx, map_zero] at hshift
+    exact hshift.symm
+
+include hell in
+                                                                           
+                                                                          
+                                 
+theorem automorphism_top (f : Ring (ι := ι) (k := k) ell →ₐ[k] Ring (ι := ι) (k := k) ell)
+    (hf : Function.Bijective f) :
+    ∃ c : k, c ≠ 0 ∧ f (topMonomial ell) = c • topMonomial ell := by
+  have hx (i : ι) : coordinate ell i * f (topMonomial ell) = 0 := by
+    obtain ⟨y, hy⟩ := hf.2 (coordinate ell i)
+    have ha : augmentation ell hell y = 0 := by
+      rw [← augmentation_comp ell hell f, AlgHom.comp_apply, hy, augmentation_coordinate]
+    rw [← hy, ← map_mul, mul_comm, topMonomial_mul hell]
+    change f ((augmentation ell hell y) • topMonomial ell) = 0
+    rw [ha, zero_smul, map_zero]
+  refine ⟨_, ?_, eq_smul_top_of_coordinate_annihilate ell hell _ hx⟩
+  intro hc
+  have hz := eq_smul_top_of_coordinate_annihilate ell hell _ hx
+  rw [hc, zero_smul, ← map_zero f] at hz
+  exact topMonomial_ne_zero hell (hf.1 hz)
+
+end BoundaryOnly.FormalObstruction.Frobenius
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/FrobeniusObstruction/VanishingIdeals.lean b/lean/OAI/Algebra/FrobeniusObstruction/VanishingIdeals.lean
new file mode 100644
index 0000000000000000000000000000000000000000..399d3adcb17d8fb2d16e7557ef6250a69fc92739
--- /dev/null
+++ b/lean/OAI/Algebra/FrobeniusObstruction/VanishingIdeals.lean
@@ -0,0 +1,191 @@
+import Mathlib
+import OAI.Algebra.FrobeniusObstruction.CoordinateMaps
+import OAI.Algebra.FrobeniusObstruction.ThreeParameters
+
+namespace OAI
+
+noncomputable section
+open scoped BigOperators
+
+namespace BoundaryOnly.FormalObstruction.Frobenius
+variable {ι k : Type*} [Fintype ι] [DecidableEq ι] [Field k] (ell : ℕ)
+
+                                                                          
+                                                                            
+                                                                                 
+theorem bijective_of_specialFiber
+    (f : Ring (ι := ι) (k := ThreeParameters.Ring k) ell →ₐ[ThreeParameters.Ring k]
+      Ring (ι := ι) (k := ThreeParameters.Ring k) ell)
+    (g : Ring (ι := ι) (k := k) ell ≃ₐ[k] Ring (ι := ι) (k := k) ell)
+    (h : ∀ x, mapCoefficients ell (ThreeParameters.augmentation k) (f x) =
+      g (mapCoefficients ell (ThreeParameters.augmentation k) x)) :
+    Function.Bijective f := by
+  let b := monomialBasis (ι := ι) (k := ThreeParameters.Ring k) ell
+  let b₀ := monomialBasis (ι := ι) (k := k) ell
+  let A := LinearMap.toMatrix b b f.toLinearMap
+  let A₀ := LinearMap.toMatrix b₀ b₀ g.toLinearEquiv.toLinearMap
+  have hm : (ThreeParameters.augmentation k).mapMatrix A = A₀ := by
+    ext v w
+    rw [RingHom.mapMatrix_apply, Matrix.map_apply]
+    dsimp only [A, A₀]
+    rw [LinearMap.toMatrix_apply, LinearMap.toMatrix_apply]
+    change ThreeParameters.augmentation k ((b.repr (f (b w))) v) =
+      (b₀.repr (g (b₀ w))) v
+    dsimp only [b, b₀]
+    simp only [monomialBasis_apply, monomialBasis_repr]
+    rw [← coefficients_mapCoefficients, h, mapCoefficients_monomial]
+  have hu₀ : IsUnit A₀.det := g.toLinearEquiv.isUnit_det b₀ b₀
+  have hd : ThreeParameters.augmentation k A.det ≠ 0 := by
+    rw [RingHom.map_det, hm]
+    exact isUnit_iff_ne_zero.mp hu₀
+  have hu : IsUnit A.det := ThreeParameters.isUnit_of_augmentation_ne_zero k _ hd
+  let e := Matrix.toLinearEquiv b A hu
+  have he : ∀ x, e x = f x := by
+    intro x
+    rw [Matrix.toLinearEquiv_apply]
+    change (Matrix.toLin b b (LinearMap.toMatrix b b f.toLinearMap)) x = _
+    rw [Matrix.toLin_toMatrix]
+    rfl
+  exact ⟨fun x y hxy => e.injective (by rw [he, he, hxy]), fun y =>
+    ⟨e.symm y, by rw [← he, e.apply_symm_apply]⟩⟩
+
+noncomputable def liftInverse
+    (f : Ring (ι := ι) (k := ThreeParameters.Ring k) ell →ₐ[ThreeParameters.Ring k]
+      Ring (ι := ι) (k := ThreeParameters.Ring k) ell)
+    (g : Ring (ι := ι) (k := k) ell ≃ₐ[k] Ring (ι := ι) (k := k) ell)
+    (h : ∀ x, mapCoefficients ell (ThreeParameters.augmentation k) (f x) =
+      g (mapCoefficients ell (ThreeParameters.augmentation k) x)) :
+    Ring (ι := ι) (k := ThreeParameters.Ring k) ell ≃ₐ[ThreeParameters.Ring k]
+      Ring (ι := ι) (k := ThreeParameters.Ring k) ell :=
+  AlgEquiv.ofBijective f (bijective_of_specialFiber ell f g h)
+
+end BoundaryOnly.FormalObstruction.Frobenius
+
+namespace BoundaryOnly.FormalObstruction.ThreeParameters
+variable (k : Type*) [Field k]
+
+instance parameterNontrivial : Nontrivial (Ring k) := ⟨⟨w k, 0, w_ne_zero k⟩⟩
+
+instance parameterCharP (ell : ℕ) [CharP k ell] : CharP (Ring k) ell :=
+  (Algebra.charP_iff k (Ring k) ell).mp inferInstance
+
+                                                                       
+                                                                                  
+theorem pow_eq_augmentation (ell : ℕ) [Fact ell.Prime] [CharP k ell]
+    (b : Ring k) : b ^ ell = (algebraMap k (Ring k) (augmentation k b)) ^ ell := by
+  obtain ⟨p, rfl⟩ := Ideal.Quotient.mk_surjective b
+  induction p using MvPolynomial.induction_on with
+    | C c => simp only [augmentation_mk, MvPolynomial.constantCoeff_C]; rfl
+    | add p q hp hq =>
+      simp only [map_add, add_pow_char, hp, hq]
+    | mul_X p i hp =>
+      have hs : s k i ^ ell = 0 :=
+        pow_eq_zero_of_le (Fact.out : ell.Prime).two_le (s_sq k i)
+      simp only [map_mul, augmentation_mk, MvPolynomial.constantCoeff_X,
+        mul_zero, map_zero, mul_pow]
+      change _ * s k i ^ ell = (0 : Ring k) ^ ell
+      rw [hs, mul_zero, zero_pow (Fact.out : ell.Prime).ne_zero]
+
+ theorem augmentation_zero_pow (ell : ℕ) [Fact ell.Prime] [CharP k ell]
+    (b : Ring k) (hb : augmentation k b = 0) : b ^ ell = 0 := by
+  rw [pow_eq_augmentation k ell, hb, map_zero, zero_pow (Fact.out : ell.Prime).ne_zero]
+
+end BoundaryOnly.FormalObstruction.ThreeParameters
+
+namespace BoundaryOnly.FormalObstruction.Frobenius
+variable {ι κ k l S : Type*} [Fintype ι] [DecidableEq ι]
+  [Fintype κ] [DecidableEq κ] [CommRing k] [CommRing l]
+variable (ell : ℕ)
+
+omit [DecidableEq ι] in
+@[simp] theorem mapCoefficients_algebraMap (f : k →+* l) (a : k) :
+    mapCoefficients (ι := ι) ell f (algebraMap k _ a) = algebraMap l _ (f a) := by
+  change Ideal.Quotient.mk _ (MvPowerSeries.map f (MvPowerSeries.C a)) = _
+  rw [MvPowerSeries.map_C]
+  rfl
+
+omit [DecidableEq ι] in
+@[simp] theorem mapCoefficients_smul (f : k →+* l) (a : k)
+    (x : Ring (ι := ι) (k := k) ell) :
+    mapCoefficients ell f (a • x) = f a • mapCoefficients ell f x := by
+  rw [Algebra.smul_def a x, Algebra.smul_def (f a) (mapCoefficients ell f x),
+    map_mul, mapCoefficients_algebraMap]
+
+end BoundaryOnly.FormalObstruction.Frobenius
+
+namespace BoundaryOnly.FormalObstruction.Frobenius
+variable {ι k l : Type*} [Fintype ι] [DecidableEq ι] [CommRing k] [CommRing l]
+variable (ell : ℕ)
+variable [Algebra k l]
+
+def baseChange : Ring (ι := ι) (k := k) ell →ₐ[k] Ring (ι := ι) (k := l) ell :=
+  { mapCoefficients ell (algebraMap k l) with
+    commutes' := fun a => by
+      change mapCoefficients ell (algebraMap k l) (algebraMap k _ a) = _
+      rw [mapCoefficients_algebraMap]
+      exact (IsScalarTower.algebraMap_apply k l (Ring (ι := ι) (k := l) ell) a).symm }
+
+omit [DecidableEq ι] in
+@[simp] theorem baseChange_coordinate (i : ι) :
+    baseChange (k := k) (l := l) ell (coordinate ell i) = coordinate ell i :=
+  mapCoefficients_coordinate ell _ i
+
+end BoundaryOnly.FormalObstruction.Frobenius
+
+namespace BoundaryOnly.FormalObstruction.Frobenius
+variable {ι k : Type*} [Fintype ι] [DecidableEq ι] [Field k] (ell : ℕ)
+
+                                                                         
+def reduction : Ring (ι := ι) (k := ThreeParameters.Ring k) ell →ₐ[k]
+    Ring (ι := ι) (k := k) ell :=
+  { mapCoefficients ell (ThreeParameters.augmentation k) with
+    commutes' := fun a => by
+      change mapCoefficients ell (ThreeParameters.augmentation k)
+        (algebraMap k (Ring (ι := ι) (k := ThreeParameters.Ring k) ell) a) = _
+      rw [IsScalarTower.algebraMap_apply k (ThreeParameters.Ring k) (Ring (ι := ι) (k := ThreeParameters.Ring k) ell)]
+      change mapCoefficients ell (ThreeParameters.augmentation k)
+        (@algebraMap (ThreeParameters.Ring k) (Ring (ι := ι) (k := ThreeParameters.Ring k) ell) inferInstance inferInstance inferInstance (algebraMap k (ThreeParameters.Ring k) a)) = _
+      rw [mapCoefficients_algebraMap, ThreeParameters.augmentation_algebraMap] }
+
+omit [DecidableEq ι] in
+@[simp] theorem reduction_coordinate (i : ι) :
+    reduction (k := k) ell (coordinate ell i) = coordinate ell i :=
+  mapCoefficients_coordinate ell _ i
+
+omit [DecidableEq ι] in
+@[simp] theorem reduction_base (a : ThreeParameters.Ring k) :
+    reduction (ι := ι) (k := k) ell (@algebraMap (ThreeParameters.Ring k) (Ring (ι := ι) (k := ThreeParameters.Ring k) ell) inferInstance inferInstance inferInstance a) =
+      algebraMap k _ (ThreeParameters.augmentation k a) :=
+  mapCoefficients_algebraMap ell _ a
+
+@[simp] theorem reduction_baseChange (x : Ring (ι := ι) (k := k) ell) :
+    reduction ell (baseChange (l := ThreeParameters.Ring k) ell x) = x := by
+  have h : (reduction (ι := ι) (k := k) ell).comp
+      (baseChange (l := ThreeParameters.Ring k) ell) = AlgHom.id k _ := by
+    apply algHom_ext
+    intro i
+    simp only [AlgHom.comp_apply, baseChange_coordinate, reduction_coordinate, AlgHom.id_apply]
+  exact AlgHom.congr_fun h x
+
+theorem specialFiber_of_coordinates
+    (f : Ring (ι := ι) (k := ThreeParameters.Ring k) ell →ₐ[ThreeParameters.Ring k]
+      Ring (ι := ι) (k := ThreeParameters.Ring k) ell)
+    (g : Ring (ι := ι) (k := k) ell →ₐ[k] Ring (ι := ι) (k := k) ell)
+    (h : ∀ i, reduction ell (f (coordinate ell i)) = g (coordinate ell i))
+    (x : Ring (ι := ι) (k := ThreeParameters.Ring k) ell) :
+    reduction ell (f x) = g (reduction ell x) := by
+  have hm (v : Box (ι := ι) ell) :
+      reduction ell (f (monomial ell v)) = g (reduction ell (monomial ell v)) := by
+    rw [monomial_eq_prod]
+    simp only [Finsupp.prod, map_prod, map_pow, h, reduction_coordinate]
+  have hs (a : ThreeParameters.Ring k) (z : Ring (ι := ι) (k := ThreeParameters.Ring k) ell) :
+      reduction ell (a • z) = ThreeParameters.augmentation k a • reduction ell z :=
+    mapCoefficients_smul ell _ a z
+  rw [monomial_expansion ell x]
+  simp only [map_sum, map_smul, hs, hm]
+
+end BoundaryOnly.FormalObstruction.Frobenius
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/GroupRing/AbsorbCells.lean b/lean/OAI/Algebra/GroupRing/AbsorbCells.lean
new file mode 100644
index 0000000000000000000000000000000000000000..27ecea1c72adb0038c813295bee67ae8a83532c0
--- /dev/null
+++ b/lean/OAI/Algebra/GroupRing/AbsorbCells.lean
@@ -0,0 +1,74 @@
+import Mathlib
+import OAI.Algebra.GroupRing.AbsorbTracks
+
+namespace OAI
+
+
+
+section
+namespace TorsionFreeZeroDivisors.AbsorbCells
+open Set GroupRingTopology GroupRingTopology.Attachment
+open scoped unitInterval
+noncomputable section
+variable {G S Q Y : Type} [Group G] [TopologicalSpace G] [DiscreteTopology G]
+  [TopologicalSpace Y] [SimplyConnectedSpace Y]
+  (s : S→G) (w : Q→FreeGroup S) (hw : ∀i,FreeGroup.lift s (w i)=1)
+  (L : CellModule.Module G S→+CellModule.Module G Q)
+  (hL : ∀g i,L (CellModule.translate g (CellModule.fox (FreeGroup.lift s) (w i)))=Finsupp.single (g,i) 1)
+  (f : C(IndexedCells.Cover s w hw,Y)) (y : Y)
+  (hv : ∀g,f (IndexedCells.inclusion s w hw (Cayley.vertex s g))=y)
+def graphHomotopy : (AbsorbTracks.graph s w hw f).Homotopy (.const _ y) :=
+  (ContinuousMap.Homotopy.refl _).trans (AbsorbTracks.final s w hw L f y hv)
+def diskHomotopy (e : G×Q) : (AbsorbTracks.cellMap s w hw f e.1 e.2).Homotopy (.const _ y) :=
+  DiskTracks.extension (AbsorbTracks.cellMap s w hw f e.1 e.2)
+    (AbsorbTracks.cellMap_boundary s w hw f y hv e.1 e.2)
+    (AbsorbTracks.finalTrack s w hw L f y hv e.1 e.2)
+    (AbsorbTracks.homotopic s w hw L hL f y hv e.1 e.2).some
+lemma diskHomotopy_boundary (e : G×Q) (t : unitInterval) (z : Sphere 2) :
+    diskHomotopy s w hw L hL f y hv e (t,boundary 2 z)=
+      graphHomotopy s w hw L f y hv (t,equivariantFamily (G:=G) (IndexedCells.attaching s w hw) e z) := by
+  change DiskTracks.extension _ _ _ _ (t,boundary 2 z)=_
+  erw [DiskTracks.extension_boundary]
+  change _=((ContinuousMap.Homotopy.refl _).trans (AbsorbTracks.final s w hw L f y hv)) _
+  rw [ContinuousMap.Homotopy.trans_apply,IndexedCells.attaching_translated]
+  split_ifs
+  · exact ContinuousMap.congr_fun (HomotopyTracks.natural_cast (f:=AbsorbTracks.graph s w hw f) (hv e.1) (IndexedCells.translated s w hw e.1 e.2)) z
+  · exact HomotopyTracks.track_boundary (f:=AbsorbTracks.graph s w hw f) (hv e.1) (AbsorbTracks.final s w hw L f y hv)
+      (fun t=>AbsorbTracks.final_vertex s w hw L f y hv t e.1) (IndexedCells.translated s w hw e.1 e.2) _ z
+
+def graphPaths : C(Cayley.Graph s,C(unitInterval,Y)) :=
+  ((graphHomotopy s w hw L f y hv).toContinuousMap.comp ⟨Prod.swap,continuous_swap⟩).curry
+def cellPaths (e : G×Q) : C(Disk 2,C(unitInterval,Y)) :=
+  ((diskHomotopy s w hw L hL f y hv e).toContinuousMap.comp ⟨Prod.swap,continuous_swap⟩).curry
+lemma paths_boundary (e : G×Q) (z : Sphere 2) : cellPaths s w hw L hL f y hv e (boundary 2 z)=
+    graphPaths s w hw L f y hv (equivariantFamily (G:=G) (IndexedCells.attaching s w hw) e z) := by
+  ext t
+  exact diskHomotopy_boundary s w hw L hL f y hv e t z
+def paths : C(IndexedCells.Cover s w hw,C(unitInterval,Y)) :=
+  lift (equivariantFamily (G:=G) (IndexedCells.attaching s w hw))
+    (graphPaths s w hw L f y hv) (cellPaths s w hw L hL f y hv) (paths_boundary s w hw L hL f y hv)
+lemma paths_zero (z : IndexedCells.Cover s w hw) : paths s w hw L hL f y hv z 0=f z := by
+  cases z with
+  | inl z => exact (graphHomotopy s w hw L f y hv).apply_zero z
+  | inr z =>
+    change diskHomotopy s w hw L hL f y hv z.1 (0,interior 2 z.2)=_
+    rw [ContinuousMap.Homotopy.apply_zero]
+    change f (cell _ z.1 (interior 2 z.2))=f (Sum.inr z)
+    rw [cell_interior]
+lemma paths_one (z : IndexedCells.Cover s w hw) : paths s w hw L hL f y hv z 1=y := by
+  cases z with
+  | inl z=>exact (graphHomotopy s w hw L f y hv).apply_one z
+  | inr z=>exact (diskHomotopy s w hw L hL f y hv z.1).apply_one (interior 2 z.2)
+def homotopy : f.Homotopy (.const _ y) where
+  toFun z:=paths s w hw L hL f y hv z.2 z.1
+  continuous_toFun:=(paths s w hw L hL f y hv).uncurry.continuous.comp continuous_swap
+  map_zero_left:=paths_zero s w hw L hL f y hv
+  map_one_left:=paths_one s w hw L hL f y hv
+end
+end TorsionFreeZeroDivisors.AbsorbCells
+
+end
+
+
+
+end OAI
diff --git a/lean/OAI/Algebra/GroupRing/AbsorbTracks.lean b/lean/OAI/Algebra/GroupRing/AbsorbTracks.lean
new file mode 100644
index 0000000000000000000000000000000000000000..cd9a982a4c51fac8edd4adb0c4d7f89efe5ea02e
--- /dev/null
+++ b/lean/OAI/Algebra/GroupRing/AbsorbTracks.lean
@@ -0,0 +1,114 @@
+import Mathlib
+import OAI.Algebra.GroupRing.IndexedCells
+import OAI.Algebra.GroupRing.FixedGraph
+import OAI.Algebra.GroupRing.GraphLabels
+
+namespace OAI
+
+
+
+section
+namespace TorsionFreeZeroDivisors.AbsorbTracks
+open Set GroupRingTopology GroupRingTopology.Attachment GroupRingTopology.PathExtension
+open scoped unitInterval
+noncomputable section
+variable {G S Q Y : Type} [Group G] [TopologicalSpace G] [DiscreteTopology G]
+  [TopologicalSpace Y] [SimplyConnectedSpace Y]
+  (s : S→G) (w : Q→FreeGroup S) (hw : ∀i,FreeGroup.lift s (w i)=1)
+  (L : CellModule.Module G S→+CellModule.Module G Q)
+  (hL : ∀g i,L (CellModule.translate g (CellModule.fox (FreeGroup.lift s) (w i)))=Finsupp.single (g,i) 1)
+  (f : C(IndexedCells.Cover s w hw,Y)) (y : Y)
+  (hv : ∀g,f (IndexedCells.inclusion s w hw (Cayley.vertex s g))=y)
+def graph : C(Cayley.Graph s,Y) := f.comp (IndexedCells.inclusion s w hw)
+def initial : (graph s w hw f).Homotopy (.const _ y) := FixedGraph.homotopy s (graph s w hw f) y hv
+lemma initial_vertex (t : unitInterval) (g : G) : initial s w hw f y hv (t,Cayley.vertex s g)=y :=
+  FixedGraph.homotopy_vertex s (graph s w hw f) y hv t g
+def boundaryLoop (g : G) (i : Q) : Path y y := HomotopyTracks.mapped (f:=graph s w hw f) (hv g) (IndexedCells.translated s w hw g i)
+def initialTrack (g : G) (i : Q) : Path (boundaryLoop s w hw f y hv g i) (Path.refl y) :=
+  HomotopyTracks.track (f:=graph s w hw f) (hv g) (initial s w hw f y hv) (fun t=>initial_vertex s w hw f y hv t g)
+    (IndexedCells.translated s w hw g i)
+def cellMap (g : G) (i : Q) : C(Disk 2,Y) := f.comp (cell (equivariantFamily (G:=G) (IndexedCells.attaching s w hw)) (g,i))
+include hv in
+omit [SimplyConnectedSpace Y] in
+lemma cellMap_boundary (g : G) (i : Q) (z : Sphere 2) :
+    cellMap s w hw f g i (boundary 2 z)=LoopSphere.map (boundaryLoop s w hw f y hv g i) z := by
+  change f (cell _ (g,i) (boundary 2 z))=_
+  erw [cell_boundary]
+  rw [IndexedCells.attaching_translated]
+  exact (ContinuousMap.congr_fun (HomotopyTracks.natural_cast (f:=graph s w hw f) (hv g) (IndexedCells.translated s w hw g i)) z).symm
+def physical (g : G) (i : Q) : Path (boundaryLoop s w hw f y hv g i) (Path.refl y) :=
+  DiskTracks.physical (cellMap s w hw f g i) (cellMap_boundary s w hw f y hv g i)
+local instance : CommGroup (FundamentalGroup (Path y y) (Path.refl y)) :=
+  { (inferInstance : Group (FundamentalGroup (Path y y) (Path.refl y))) with
+    mul_comm:=LoopTracks.loopGroup_comm y }
+abbrev Coef := Additive (FundamentalGroup (Path y y) (Path.refl y))
+def obstruction (g : G) (i : Q) : Coef y := Additive.ofMul
+  (Path.Homotopic.Quotient.mk ((initialTrack s w hw f y hv g i).symm.trans (physical s w hw f y hv g i)))
+def obstructionMap : CellModule.Module G Q→+Coef y :=
+  Finsupp.liftAddHom (fun e=>zmultiplesHom _ (obstruction s w hw f y hv e.1 e.2))
+lemma obstructionMap_single (g : G) (i : Q) : obstructionMap s w hw f y hv (Finsupp.single (g,i) 1)=obstruction s w hw f y hv g i := by
+  simp [obstructionMap]
+def turnBack : Coef y→+Coef y where
+  toFun a := Additive.ofMul ((LoopTranspose.turn y).symm a.toMul)
+  map_zero' := (LoopTranspose.turn y).symm.map_one
+  map_add' a b := (LoopTranspose.turn y).symm.map_mul a.toMul b.toMul
+def correction : CellModule.Module G S→+Coef y := (turnBack y).comp ((obstructionMap s w hw f y hv).comp L)
+def labels : C(Cayley.Graph s,Path y y) :=
+  GraphLabels.map s (Path.refl y) (fun e=>(correction s w hw L f y hv (Finsupp.single e 1)).toMul)
+lemma labels_vertex (g : G) : labels s w hw L f y hv (Cayley.vertex s g)=Path.refl y :=
+  GraphLabels.map_vertex _ _ _ g
+
+def final : (graph s w hw f).Homotopy (.const _ y) :=
+  (initial s w hw f y hv).trans (HomotopyTracks.run (labels s w hw L f y hv))
+lemma final_vertex (t : unitInterval) (g : G) : final s w hw L f y hv (t,Cayley.vertex s g)=y :=
+  HomotopyTracks.trans_base (initial s w hw f y hv) (fun t=>initial_vertex s w hw f y hv t g)
+    (labels s w hw L f y hv) (labels_vertex s w hw L f y hv g) t
+
+def finalTrack (g : G) (i : Q) : Path (boundaryLoop s w hw f y hv g i) (Path.refl y) :=
+  HomotopyTracks.track (f:=graph s w hw f) (hv g) (final s w hw L f y hv) (fun t=>final_vertex s w hw L f y hv t g)
+    (IndexedCells.translated s w hw g i)
+include hL in
+lemma response (g : G) (i : Q) :
+    Path.Homotopic.Quotient.mk (LoopTranspose.turnPath y
+      (((IndexedCells.translated s w hw g i).map (labels s w hw L f y hv).continuous).cast
+        (labels_vertex s w hw L f y hv g).symm (labels_vertex s w hw L f y hv g).symm))=
+      (obstruction s w hw f y hv g i).toMul := by
+  rw [←LoopTranspose.turn_mk]
+  have he := WordResponse.basedClass_equal (IndexedCells.translated_equal s w hw g i)
+    (labels s w hw L f y hv) (Path.refl y) (labels_vertex s w hw L f y hv g)
+    (labels_vertex s w hw L f y hv g)
+    (WordResponse.source_eq s (labels s w hw L f y hv) (Path.refl y) (labels_vertex s w hw L f y hv) g)
+    (WordResponse.target_eq s (labels s w hw L f y hv) (Path.refl y) (labels_vertex s w hw L f y hv) g (w i))
+  change Path.Homotopic.Quotient.mk (((IndexedCells.translated s w hw g i).map (labels s w hw L f y hv).continuous).cast _ _)=
+    (WordResponse.response s (labels s w hw L f y hv) (Path.refl y) (labels_vertex s w hw L f y hv) g (w i)).toMul at he
+  rw [he]
+  have hr:=GraphLabels.realizes s (Path.refl y) (correction s w hw L f y hv) g (w i)
+  change WordResponse.response s (labels s w hw L f y hv) (Path.refl y) (labels_vertex s w hw L f y hv) g (w i)=_ at hr
+  rw [hr]
+  change LoopTranspose.turn y ((LoopTranspose.turn y).symm
+    ((obstructionMap s w hw f y hv) (L (CellModule.translate g (CellModule.fox (FreeGroup.lift s) (w i))))).toMul)=_
+  rw [hL,obstructionMap_single]
+  exact (LoopTranspose.turn y).apply_symm_apply _
+include hL in
+lemma homotopic (g : G) (i : Q) : (physical s w hw f y hv g i).Homotopic (finalTrack s w hw L f y hv g i) := by
+  apply Path.Homotopic.Quotient.eq.mp
+  change Path.Homotopic.Quotient.mk (physical s w hw f y hv g i)=Path.Homotopic.Quotient.mk
+    (HomotopyTracks.track (f:=graph s w hw f) (hv g) ((initial s w hw f y hv).trans (HomotopyTracks.run (labels s w hw L f y hv))) _ _)
+  erw [HomotopyTracks.track_trans (f:=graph s w hw f) (hv g) (initial s w hw f y hv)
+    (fun t=>initial_vertex s w hw f y hv t g) (labels s w hw L f y hv)
+    (labels_vertex s w hw L f y hv g) (IndexedCells.translated s w hw g i)]
+  erw [Path.Homotopic.Quotient.mk_trans]
+  erw [response s w hw L hL f y hv g i]
+  change Path.Homotopic.Quotient.mk (physical s w hw f y hv g i)=
+    (Path.Homotopic.Quotient.mk (initialTrack s w hw f y hv g i)).trans
+      ((Path.Homotopic.Quotient.mk (initialTrack s w hw f y hv g i)).symm.trans
+        (Path.Homotopic.Quotient.mk (physical s w hw f y hv g i)))
+  rw [←Path.Homotopic.Quotient.trans_assoc,Path.Homotopic.Quotient.trans_symm,Path.Homotopic.Quotient.refl_trans]
+end
+end TorsionFreeZeroDivisors.AbsorbTracks
+
+end
+
+
+
+end OAI
diff --git a/lean/OAI/Algebra/GroupRing/AffineIntervals.lean b/lean/OAI/Algebra/GroupRing/AffineIntervals.lean
new file mode 100644
index 0000000000000000000000000000000000000000..ed41e85688fa437ba9185f264eb77f11a0fd1363
--- /dev/null
+++ b/lean/OAI/Algebra/GroupRing/AffineIntervals.lean
@@ -0,0 +1,476 @@
+import Mathlib
+import OAI.Algebra.GroupRing.EntropyStages
+
+namespace OAI
+
+noncomputable section
+
+namespace TorsionFreeZeroDivisors.AffineIntervals
+open scoped Classical
+open BlockAlignment
+
+/-- Boundary action of a signed interval isometry. On half-integer centers it
+agrees with the manuscript's letter-index affine action. -/
+def boundary (r : Bool) (a x : ℤ) : ℤ := if r then a-x else x+a
+
+def compOffset (r : Bool) (a b : ℤ) : ℤ := if r then a-b else a+b
+
+lemma affine_comp (r s : Bool) (a b x : ℤ) :
+    affine r a (affine s b x)=affine (r.xor s) (compOffset r a b) x := by
+  cases r <;> cases s <;> simp [affine,compOffset] <;> ring
+
+lemma boundary_comp (r s : Bool) (a b x : ℤ) :
+    boundary r a (boundary s b x)=boundary (r.xor s) (compOffset r a b) x := by
+  cases r <;> cases s <;> simp [boundary,compOffset] <;> ring
+
+lemma integer_positions (a b : ℤ) : positions a b=Finset.Ico a b := by
+  ext x
+  rw [mem_positions,Finset.mem_Ico]
+  constructor
+  · rintro ⟨h1,h2⟩
+    constructor
+    · by_contra h
+      have : x+1≤a := by omega
+      have : (x:ℝ)+1≤a := by exact_mod_cast this
+      linarith
+    · by_contra h
+      have : b≤x := by omega
+      have : (b:ℝ)≤x := by exact_mod_cast this
+      linarith
+  · rintro ⟨h1,h2⟩
+    have h1' : (a:ℝ)≤x := by exact_mod_cast h1
+    have h2' : (x:ℝ)+1≤b := by exact_mod_cast (show x+1≤b by omega)
+    constructor <;> linarith
+
+lemma nat_positions (n : ℕ) : positions 0 (n : ℝ)=Finset.Ico (0:ℤ) (n:ℤ) := by
+  simpa only [Int.cast_zero,Int.cast_natCast] using integer_positions (0:ℤ) (n:ℤ)
+
+/-- Exact integer endpoints of the inverse image; reflection does not incur
+any rounding loss on the source half-integer convention. -/
+def preLo (r : Bool) (a lo hi : ℤ) : ℤ := if r then a-hi else lo-a
+def preHi (r : Bool) (a lo hi : ℤ) : ℤ := if r then a-lo else hi-a
+
+lemma mem_preimage (r : Bool) (a lo hi x : ℤ) :
+    affine r a x∈Finset.Ico lo hi ↔ x∈Finset.Ico (preLo r a lo hi) (preHi r a lo hi) := by
+  cases r <;> simp only [affine,preLo,preHi,Bool.false_eq_true,ite_false,ite_true,Finset.mem_Ico] <;> omega
+
+lemma preimage_bounds (r : Bool) (a lo hi l h : ℤ)
+    (hl : preLo r a lo hi≤l) (hh : h≤preHi r a lo hi) :
+    if r then lo≤a-h ∧ a-l≤hi else lo≤l+a ∧ h+a≤hi := by
+  cases r <;> simp only [preLo,preHi,Bool.false_eq_true,ite_false,ite_true] at * <;> omega
+
+/-- Empty comparison sides may be placed at the preimage of target boundary
+zero; this has no occurrences and satisfies the global range condition. -/
+def anchor (r : Bool) (a : ℤ) : ℤ := if r then a else -a
+
+lemma anchor_bounds (r : Bool) (a : ℤ) (n : ℕ) :
+    if r then 0≤a-anchor r a ∧ a-anchor r a≤n
+    else 0≤anchor r a+a ∧ anchor r a+a≤n := by
+  cases r <;> simp [anchor]
+
+end TorsionFreeZeroDivisors.AffineIntervals
+namespace TorsionFreeZeroDivisors.ChunkComparisons
+open scoped Classical
+open BlockAlignment ComparedBlocks AffineIntervals EntropyStages
+
+variable {P T E : Type*} {lp : P → ℕ} {lt : T → ℕ}
+
+/-- A literal partition into signed integer chunks, not a count of formal pieces. -/
+structure Chunking (lp : P → ℕ) (lt : T → ℕ) where
+  equiv : Position lt ≃ Position lp
+  path : T → P
+  reverse : T → Bool
+  offset : T → ℤ
+  source : ∀ x, (equiv x).1 = path x.1
+  coordinate : ∀ x, (equiv x).2.val = affine (reverse x.1) (offset x.1) x.2.val
+
+lemma position_ext {x y : Position lp} (hs : x.1=y.1) (hc : x.2.val=y.2.val) : x=y := by
+  rcases x with ⟨x,q⟩; rcases y with ⟨y,r⟩
+  dsimp at hs hc
+  subst y
+  congr 1
+  exact Subtype.ext hc
+
+namespace Chunking
+variable (K : Chunking lp lt) (C : Comparisons (E := E) lp)
+
+def pairing : Pairing (Position lt) where
+  partner x := K.equiv.symm (C.pairing.partner (K.equiv x))
+  involutive x := by
+    dsimp
+    rw [K.equiv.apply_symm_apply,C.pairing.involutive (K.equiv x),K.equiv.symm_apply_apply]
+
+lemma partner_image (x : Position lt) :
+    K.equiv ((K.pairing C).partner x)=C.pairing.partner (K.equiv x) := by
+  simp [pairing]
+
+def rev (e : E) (t u : T) : Bool :=
+  (K.reverse u).xor ((C.reverse e).xor (K.reverse t))
+
+def off (e : E) (t u : T) : ℤ :=
+  compOffset (K.reverse u) (inverseOffset (K.reverse u) (K.offset u))
+    (compOffset (C.reverse e) (C.offset e) (K.offset t))
+
+lemma new_affine (e : E) (t u : T) (q : ℤ) :
+    affine (K.rev C e t u) (K.off C e t u) q =
+      affine (K.reverse u) (inverseOffset (K.reverse u) (K.offset u))
+        (affine (C.reverse e) (C.offset e) (affine (K.reverse t) (K.offset t) q)) := by
+  rw [affine_comp (C.reverse e) (K.reverse t),affine_comp]
+  rfl
+
+lemma new_affine_image (e : E) (t u : T) (q : ℤ) :
+    affine (K.reverse u) (K.offset u) (affine (K.rev C e t u) (K.off C e t u) q) =
+      affine (C.reverse e) (C.offset e) (affine (K.reverse t) (K.offset t) q) := by
+  rw [K.new_affine]
+  generalize affine (C.reverse e) (C.offset e) (affine (K.reverse t) (K.offset t) q) = z
+  cases K.reverse u <;> simp [affine,inverseOffset]
+
+lemma partner_coordinate {x : Position lt} {e : E} (he : C.side (K.equiv x)=some e) :
+    ((K.pairing C).partner x).2.val =
+      affine (K.rev C e x.1 ((K.pairing C).partner x).1)
+        (K.off C e x.1 ((K.pairing C).partner x).1) x.2.val := by
+  have h := C.partner_coordinate (K.equiv x) e he
+  rw [← K.partner_image, K.coordinate, K.coordinate] at h
+  apply affine_injective (K.reverse ((K.pairing C).partner x).1)
+    (K.offset ((K.pairing C).partner x).1)
+  rw [K.new_affine_image]
+  exact h
+
+/-- The image of an old partner is in a given chunk precisely when the
+conjugate affine index is in that chunk. -/
+lemma partner_chunk_iff {x : Position lt} {e : E} {u : T}
+    (he : C.side (K.equiv x)=some e) (hu : K.path u=C.source (C.flip e)) :
+    ((K.pairing C).partner x).1=u ↔
+      affine (K.rev C e x.1 u) (K.off C e x.1 u) x.2.val ∈ positions 0 (lt u) := by
+  constructor
+  · intro h
+    have hm := ((K.pairing C).partner x).2.property
+    rw [K.partner_coordinate C he,h] at hm
+    exact hm
+  · intro hm
+    let y : Position lt := ⟨u,⟨_,hm⟩⟩
+    have hy : K.equiv y=C.pairing.partner (K.equiv x) := by
+      apply position_ext
+      · rw [K.source,C.partner_source _ _ he]
+        exact hu
+      · rw [K.coordinate,C.partner_coordinate _ _ he,K.coordinate]
+        exact K.new_affine_image C e x.1 u x.2.val
+    have : y=(K.pairing C).partner x := K.equiv.injective (hy.trans (K.partner_image C x).symm)
+    exact (congrArg Sigma.fst this).symm
+
+variable (lo hi : E → ℤ)
+
+def rawLo (e : E) (t u : T) : ℤ :=
+  max 0 (max (preLo (K.reverse t) (K.offset t) (lo e) (hi e))
+    (preLo (K.rev C e t u) (K.off C e t u) 0 (lt u)))
+def rawHi (e : E) (t u : T) : ℤ :=
+  min (lt t) (min (preHi (K.reverse t) (K.offset t) (lo e) (hi e))
+    (preHi (K.rev C e t u) (K.off C e t u) 0 (lt u)))
+
+def valid (e : E) (t u : T) : Prop :=
+  K.path t=C.source e ∧ K.path u=C.source (C.flip e) ∧
+    K.rawLo C lo hi e t u ≤ K.rawHi C lo hi e t u
+
+def lower (e : E) (t u : T) : ℤ :=
+  if K.valid C lo hi e t u then K.rawLo C lo hi e t u
+  else anchor (K.rev C e t u) (K.off C e t u)
+def upper (e : E) (t u : T) : ℤ :=
+  if K.valid C lo hi e t u then K.rawHi C lo hi e t u
+  else anchor (K.rev C e t u) (K.off C e t u)
+
+variable (hlo : ∀ e, C.lo e=(lo e : ℝ)) (hhi : ∀ e, C.hi e=(hi e : ℝ))
+
+include hlo hhi in
+lemma interval_iff (x : Position lt) (e : E) (u : T) :
+    x.2.val ∈ positions (K.lower C lo hi e x.1 u) (K.upper C lo hi e x.1 u) ↔
+      C.side (K.equiv x)=some e ∧ ((K.pairing C).partner x).1=u := by
+  rw [integer_positions]
+  by_cases hv : K.valid C lo hi e x.1 u
+  · rw [lower,upper,ite_eq_left hv,ite_eq_left hv]
+    have hx := x.2.property
+    simp only [nat_positions] at hx
+    have hpart := hv.1
+    have htarget := hv.2.1
+    have hmem : x.2.val ∈ Finset.Ico (K.rawLo C lo hi e x.1 u) (K.rawHi C lo hi e x.1 u) ↔
+        affine (K.reverse x.1) (K.offset x.1) x.2.val ∈ Finset.Ico (lo e) (hi e) ∧
+        affine (K.rev C e x.1 u) (K.off C e x.1 u) x.2.val ∈ Finset.Ico (0:ℤ) (lt u:ℤ) := by
+      rw [mem_preimage,mem_preimage]
+      simp only [rawLo,rawHi,Finset.mem_Ico,max_le_iff,lt_min_iff]
+      simp only [Finset.mem_Ico] at hx
+      omega
+    rw [hmem]
+    have hside : C.side (K.equiv x)=some e ↔
+        affine (K.reverse x.1) (K.offset x.1) x.2.val ∈ Finset.Ico (lo e) (hi e) := by
+      rw [C.side_iff,K.coordinate]
+      simp only [K.source,hlo,hhi,integer_positions]
+      exact and_iff_right hpart
+    rw [← hside]
+    apply and_congr_right
+    intro he
+    rw [K.partner_chunk_iff C he htarget]
+    simp only [nat_positions]
+  · rw [lower,upper,ite_eq_right hv,ite_eq_right hv,Finset.Ico_self]
+    simp only [Finset.notMem_empty,false_iff,not_and]
+    intro he hu
+    apply hv
+    have hp := (C.side_iff (K.equiv x) e).mp he
+    have ht := C.partner_source (K.equiv x) e he
+    rw [← K.partner_image,K.source,hu] at ht
+    refine ⟨(K.source x).symm.trans hp.1,ht,?_⟩
+    have hq := hp.2
+    rw [hlo,hhi,integer_positions,K.coordinate,mem_preimage] at hq
+    have hr := (K.partner_chunk_iff C he ht).mp hu
+    simp only [nat_positions] at hr
+    rw [mem_preimage] at hr
+    have hx := x.2.property
+    simp only [nat_positions] at hx
+    simp only [Finset.mem_Ico] at hx hq hr
+    simp only [rawLo,rawHi,max_le_iff,le_min_iff]
+    omega
+
+lemma range_bounds (e : E) (t u : T) :
+    if K.rev C e t u then
+      0≤K.off C e t u-K.upper C lo hi e t u ∧ K.off C e t u-K.lower C lo hi e t u≤lt u
+    else 0≤K.lower C lo hi e t u+K.off C e t u ∧ K.upper C lo hi e t u+K.off C e t u≤lt u := by
+  by_cases hv : K.valid C lo hi e t u
+  · simp only [lower,upper,ite_eq_left hv]
+    apply preimage_bounds
+    · exact (le_max_right _ _).trans (le_max_right _ _)
+    · exact (min_le_right _ _).trans (min_le_right _ _)
+  · simp only [lower,upper,ite_eq_right hv]
+    exact anchor_bounds _ _ _
+
+def side (x : Position lt) : Option (E×T×T) :=
+  (C.side (K.equiv x)).map (fun e => (e,x.1,((K.pairing C).partner x).1))
+
+lemma side_iff (x : Position lt) (e : E) (t u : T) :
+    K.side C x=some (e,t,u) ↔
+      C.side (K.equiv x)=some e ∧ x.1=t ∧ ((K.pairing C).partner x).1=u := by
+  cases h : C.side (K.equiv x) <;> simp [side,h,Prod.mk.injEq]
+
+/-- Split every side at the boundaries of both chunks. Empty pieces carry no
+positions; their chosen endpoint maintains the exact range convention. -/
+def comparisons : Comparisons (E := E×T×T) lt where
+  pairing := K.pairing C
+  side := K.side C
+  flip a := (C.flip a.1,a.2.2,a.2.1)
+  flip_inv a := by rcases a with ⟨e,t,u⟩; simp [C.flip_inv e]
+  flip_ne a := by
+    intro h
+    exact C.flip_ne a.1 (congrArg Prod.fst h)
+  side_partner x a ha := by
+    rcases a with ⟨e,t,u⟩
+    obtain ⟨he,ht,hu⟩ := (K.side_iff C x e t u).mp ha
+    apply (K.side_iff C _ _ _ _).mpr
+    refine ⟨?_,hu,?_⟩
+    · rw [K.partner_image]
+      exact C.side_partner (K.equiv x) e he
+    · rw [(K.pairing C).involutive x]
+      exact ht
+  none_iff x := by
+    simp only [side,Option.map_eq_none_iff,C.none_iff]
+    constructor
+    · intro h
+      apply K.equiv.injective
+      rw [K.partner_image,h]
+    · intro h
+      rw [← K.partner_image,h]
+  source a := a.2.1
+  lo a := K.lower C lo hi a.1 a.2.1 a.2.2
+  hi a := K.upper C lo hi a.1 a.2.1 a.2.2
+  reverse a := K.rev C a.1 a.2.1 a.2.2
+  offset a := K.off C a.1 a.2.1 a.2.2
+  side_iff x a := by
+    rcases a with ⟨e,t,u⟩
+    rw [K.side_iff]
+    constructor
+    · rintro ⟨he,ht,hu⟩
+      refine ⟨ht,?_⟩
+      subst t
+      exact (K.interval_iff C lo hi hlo hhi x e u).mpr ⟨he,hu⟩
+    · rintro ⟨ht,hm⟩
+      change x.1=t at ht
+      subst t
+      obtain ⟨he,hu⟩ := (K.interval_iff C lo hi hlo hhi x e u).mp hm
+      exact ⟨he,rfl,hu⟩
+  partner_source x a ha := ((K.side_iff C x a.1 a.2.1 a.2.2).mp ha).2.2
+  partner_coordinate x a ha := by
+    obtain ⟨he,ht,hu⟩ := (K.side_iff C x a.1 a.2.1 a.2.2).mp ha
+    simpa only [ht,hu] using K.partner_coordinate C he
+  target_range a := by
+    have h := K.range_bounds C lo hi a.1 a.2.1 a.2.2
+    cases hr : K.rev C a.1 a.2.1 a.2.2 <;> simp only [hr,Bool.false_eq_true,ite_false,ite_true] at h ⊢
+    · exact_mod_cast h
+    · exact_mod_cast h
+
+lemma fixed_iff (x : Position lt) :
+    (K.pairing C).partner x=x ↔ C.pairing.partner (K.equiv x)=K.equiv x := by
+  constructor
+  · intro h
+    rw [← K.partner_image,h]
+  · intro h
+    apply K.equiv.injective
+    rw [K.partner_image,h]
+
+def unpairedEquiv : {x : Position lt // (K.pairing C).partner x=x} ≃
+    {x : Position lp // C.pairing.partner x=x} :=
+  K.equiv.subtypeEquiv (K.fixed_iff C)
+
+/-- Splitting and orientation normalization neither deletes nor duplicates an
+unpaired occurrence. -/
+theorem unpaired_card [Fintype P] [Fintype T] :
+    Fintype.card {x : Position lt // (K.comparisons C lo hi hlo hhi).pairing.partner x=x} =
+      Fintype.card {x : Position lp // C.pairing.partner x=x} :=
+  Fintype.card_congr (K.unpairedEquiv C)
+
+lemma xor_labels {A : Type*} (bar : A → A) (hb : Function.Involutive bar)
+    (r s t : Bool) (x y : A)
+    (h : (if r then bar x else x) = if s then
+      bar (if t then bar y else y) else (if t then bar y else y)) :
+    x = if t.xor (s.xor r) then bar y else y := by
+  have hbb (z : A) : bar (bar z)=z := hb z
+  cases r <;> cases s <;> cases t <;> simp only [Bool.xor_false,Bool.xor_true,
+    Bool.not_false,Bool.not_true,Bool.false_eq_true,ite_false,ite_true,hbb] at h ⊢
+  all_goals first | exact h | simpa only [hbb] using congrArg bar h
+
+/-- Every literal compatible labeling survives splitting with exactly the
+xor of the path comparison and the two chain orientations. -/
+theorem compatible {A : Type*} (bar : A → A) (hb : Function.Involutive bar)
+    (old : Position lp → A) (word : Position lt → A)
+    (hn : ∀ x,old (K.equiv x)=if K.reverse x.1 then bar (word x) else word x)
+    (hc : ∀ x e,C.side x=some e → old x = if C.reverse e then
+      bar (old (C.pairing.partner x)) else old (C.pairing.partner x)) :
+    ∀ x a, (K.comparisons C lo hi hlo hhi).side x=some a →
+      word x=if (K.comparisons C lo hi hlo hhi).reverse a then
+        bar (word ((K.comparisons C lo hi hlo hhi).pairing.partner x))
+      else word ((K.comparisons C lo hi hlo hhi).pairing.partner x) := by
+  intro x a ha
+  obtain ⟨he,ht,hu⟩ := (K.side_iff C x a.1 a.2.1 a.2.2).mp ha
+  have h := hc (K.equiv x) a.1 he
+  rw [← K.partner_image,hn,hn] at h
+  have h' := xor_labels bar hb (K.reverse x.1) (C.reverse a.1)
+    (K.reverse ((K.pairing C).partner x).1) (word x) (word ((K.pairing C).partner x)) h
+  change word x=(if K.rev C a.1 a.2.1 a.2.2 then
+    bar (word ((K.pairing C).partner x)) else word ((K.pairing C).partner x))
+  dsimp only [rev]
+  exact h'.trans (by congr 1; simp only [ht,hu])
+
+end Chunking
+end TorsionFreeZeroDivisors.ChunkComparisons
+
+namespace TorsionFreeZeroDivisors.FiniteChunking
+open scoped Classical BigOperators
+open BlockAlignment ComparedBlocks AffineIntervals ChunkComparisons
+
+variable {n : ℕ}
+
+def before (i : Fin n) : Finset (Fin n) := Finset.univ.filter (fun j => j < i)
+def start (f : Fin n → ℕ) (i : Fin n) : ℕ := ∑ j∈before i,f j
+
+lemma not_before (i : Fin n) : i∉before i := by simp [before]
+
+lemma start_next (f : Fin n → ℕ) {i j : Fin n} (h : i < j) :
+    start f i+f i ≤ start f j := by
+  rw [start,add_comm,← Finset.sum_insert (not_before i)]
+  apply Finset.sum_le_sum_of_subset
+  intro k hk
+  rcases Finset.mem_insert.mp hk with rfl|hk
+  · simpa [before] using h
+  · have hk' : k < i := by simpa [before] using hk
+    simpa [before] using hk'.trans h
+
+lemma start_end (f : Fin n → ℕ) (i : Fin n) : start f i+f i ≤ ∑ j,f j := by
+  rw [start,add_comm,← Finset.sum_insert (not_before i)]
+  exact Finset.sum_le_sum_of_subset (Finset.subset_univ _)
+
+def localIndex (r : Bool) (n : ℕ) (q : ℤ) : ℤ := affine r (if r then n else 0) q
+
+lemma local_bounds (r : Bool) (n : ℕ) {q : ℤ} (hq : q∈positions 0 n) :
+    0≤localIndex r n q ∧ localIndex r n q<n := by
+  simp only [nat_positions,Finset.mem_Ico] at hq
+  cases r <;> simp only [localIndex,affine,Bool.false_eq_true,ite_false,ite_true] <;> omega
+
+lemma affine_offset (r : Bool) (pre len : ℕ) (q : ℤ) :
+    affine r (pre+(if r then (len:ℤ) else 0)) q = pre+localIndex r len q := by
+  cases r <;> simp [localIndex,affine] <;> omega
+
+lemma positions_card (n : ℕ) : (positions 0 n).card=n := by
+  rw [nat_positions,Int.card_Ico,sub_zero,Int.toNat_natCast]
+
+lemma position_card {T : Type*} [Fintype T] (len : T → ℕ) :
+    Fintype.card (Position len)=∑ t,len t := by
+  simp only [Position,Fintype.card_sigma,Fintype.card_coe,positions_card]
+
+variable {P : Type*} [Fintype P] (chunks : P → ℕ)
+  (len : (p : P) → Fin (chunks p) → ℕ) (rev : (p : P) → Fin (chunks p) → Bool)
+
+abbrev Traversal := (p : P) × Fin (chunks p)
+abbrev traversalLength : Traversal chunks → ℕ := fun t => len t.1 t.2
+def pathLength (p : P) : ℕ := ∑ i,len p i
+
+def offset (t : Traversal chunks) : ℤ := start (len t.1) t.2 + if rev t.1 t.2 then (len t.1 t.2:ℤ) else 0
+
+def image (x : Position (traversalLength chunks len)) : Position (pathLength chunks len) :=
+  ⟨x.1.1,⟨affine (rev x.1.1 x.1.2) (offset chunks len rev x.1) x.2.val,by
+    simp only [nat_positions,Finset.mem_Ico]
+    have hq := local_bounds (rev x.1.1 x.1.2) (len x.1.1 x.1.2) x.2.property
+    have hp : (start (len x.1.1) x.1.2:ℤ)+len x.1.1 x.1.2 ≤ pathLength chunks len x.1.1 := by
+      exact_mod_cast start_end (len x.1.1) x.1.2
+    rw [offset,affine_offset]
+    have hz : (0:ℤ)≤ start (len x.1.1) x.1.2 := Int.natCast_nonneg _
+    omega⟩⟩
+
+omit [Fintype P] in
+lemma image_val (x : Position (traversalLength chunks len)) :
+    (image chunks len rev x).2.val =
+      start (len x.1.1) x.1.2+localIndex (rev x.1.1 x.1.2) (len x.1.1 x.1.2) x.2.val :=
+  affine_offset _ _ _ _
+
+omit [Fintype P] in
+lemma image_injective : Function.Injective (image chunks len rev) := by
+  rintro ⟨⟨p,i⟩,q⟩ ⟨⟨r,j⟩,v⟩ hh
+  have hp : p=r := congrArg Sigma.fst hh
+  subst r
+  have hc := congrArg (fun x : Position (pathLength chunks len) => x.2.val) hh
+  rw [image_val,image_val] at hc
+  dsimp only at hc
+  have hq := local_bounds (rev p i) (len p i) q.property
+  have hv := local_bounds (rev p j) (len p j) v.property
+  have he : i=j := by
+    rcases lt_trichotomy i j with hij|hij|hji
+    · have hpre : (start (len p) i:ℤ)+len p i ≤ start (len p) j := by
+        exact_mod_cast start_next (len p) hij
+      omega
+    · exact hij
+    · have hpre : (start (len p) j:ℤ)+len p j ≤ start (len p) i := by
+        exact_mod_cast start_next (len p) hji
+      omega
+  subst j
+  have hqv : q=v := by
+    apply Subtype.ext
+    apply affine_injective (rev p i) (if rev p i then (len p i:ℤ) else 0)
+    unfold localIndex at hc
+    omega
+  subst v
+  rfl
+
+/-- The prescribed offsets define an actual equivalence. In particular, this
+partition covers every old letter even when a path is empty. -/
+def equiv : Position (traversalLength chunks len) ≃ Position (pathLength chunks len) :=
+  Equiv.ofBijective (image chunks len rev) <|
+    (Fintype.bijective_iff_injective_and_card _).mpr ⟨image_injective chunks len rev,by
+      simp only [position_card,Fintype.sum_sigma,traversalLength,pathLength]⟩
+
+def chunking : Chunking (pathLength chunks len) (traversalLength chunks len) where
+  equiv := equiv chunks len rev
+  path t := t.1
+  reverse t := rev t.1 t.2
+  offset := offset chunks len rev
+  source _ := rfl
+  coordinate _ := rfl
+
+end TorsionFreeZeroDivisors.FiniteChunking
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/GroupRing/AlgebraicPictures.lean b/lean/OAI/Algebra/GroupRing/AlgebraicPictures.lean
new file mode 100644
index 0000000000000000000000000000000000000000..fb376332806032407719fd9d52333615240bd2f1
--- /dev/null
+++ b/lean/OAI/Algebra/GroupRing/AlgebraicPictures.lean
@@ -0,0 +1,394 @@
+import Mathlib
+import OAI.Algebra.GroupRing.WordBlocks
+
+namespace OAI
+
+noncomputable section
+
+namespace TorsionFreeZeroDivisors.WordBlocks
+open scoped Classical
+variable {A : Type*}
+open FreeGroup
+/-- Remove exactly the actual conjugating word, not a replacement reduced
+representative. Each removal is the proved cap splice on the same boundary. -/
+def Matching.removeConjugator (c w : List (A×Bool)) (ws : List (List (A×Bool)))
+    (d : Matching WordPairing.inverseLetter ((c++w++invRev c)::ws)) :
+    Matching WordPairing.inverseLetter (w::ws) := by
+  induction c with
+  | nil=>simpa only [List.nil_append,invRev_empty,List.append_nil] using d
+  | cons a c ih=>
+    have he : (a::c)++w++invRev (a::c)=a::((c++w++invRev c)++[WordPairing.inverseLetter a]) := by
+      simp only [List.cons_append,invRev,WordPairing.inverseLetter,
+        List.reverse_cons,List.map_cons,List.append_assoc]
+    rw [he] at d
+    exact ih (d.removeCaps WordPairing.inverseLetter_involutive a (c++w++invRev c) ws)
+
+def Matching.removeConjugatorAt (c w : List (A×Bool)) (pre post : List (List (A×Bool)))
+    (d : Matching WordPairing.inverseLetter (pre++(c++w++invRev c)::post)) :
+    Matching WordPairing.inverseLetter (pre++w::post) :=
+  (d.focus.removeConjugator c w (pre++post)).unfocus
+
+end TorsionFreeZeroDivisors.WordBlocks
+namespace TorsionFreeZeroDivisors.AlgebraicPictures
+open FreeGroup
+variable {A I : Type*} (rel : I→List (A×Bool))
+def coreWords (ts : List (Term (A:=A) (I:=I))) : List (List (A×Bool)) := ts.map (Term.core rel)
+def stripConjugators (ts : List (Term (A:=A) (I:=I)))
+    (pre : List (List (A×Bool)))
+    (d : WordBlocks.Matching WordPairing.inverseLetter (pre++ts.map (Term.word rel))) :
+    WordBlocks.Matching WordPairing.inverseLetter (pre++coreWords rel ts) := by
+  induction ts generalizing pre with
+  | nil=>exact d
+  | cons t ts ih=>
+    change WordBlocks.Matching WordPairing.inverseLetter
+      (pre++(t.connector++t.core rel++invRev t.connector)::ts.map (Term.word rel)) at d
+    have d' := d.removeConjugatorAt t.connector (t.core rel) pre (ts.map (Term.word rel))
+    have d'' := ih (pre++[t.core rel]) (by simpa only [List.append_assoc,List.singleton_append] using d')
+    simpa only [List.append_assoc,List.singleton_append,coreWords,List.map_cons] using d''
+/-- A literal quotient-null word supplies actual planar inverse-letter matching
+on the outer inverse word and signed relator cores, with all conjugating paths
+removed by genuine genus-zero preserving surgery. This is still finite
+permutation data, not an assumed topological surface or graph lift. -/
+theorem quotient_core_matching (outer : List (A×Bool))
+    (h : PresentedGroup.mk (relations rel) (mk outer)=1) :
+    ∃ts : List (Term (A:=A) (I:=I)),
+      Nonempty (WordBlocks.Matching WordPairing.inverseLetter (invRev outer::coreWords rel ts)) := by
+  obtain ⟨ts,⟨d⟩⟩ := quotient_block_matching rel outer h
+  exact ⟨ts,⟨stripConjugators rel ts [invRev outer] d⟩⟩
+
+end TorsionFreeZeroDivisors.AlgebraicPictures
+
+namespace TorsionFreeZeroDivisors.GraphPresentation
+open PortSubdivision
+open scoped Classical
+variable {V D : Type} (Γ : PortGraph V D)
+
+/-- An ordinary port path; no reduction assumption, and loops and parallel
+edges remain distinct. This is used for the exact graph relators. -/
+inductive Path : V→V→Type
+  | nil (v : V) : Path v v
+  | cons (d : D) {b : V} (p : Path (Γ.origin (Γ.reverse d)) b) : Path (Γ.origin d) b
+namespace Path
+variable {Γ} {a b c : V}
+def append : {a b c : V} → Path Γ a b→Path Γ b c→Path Γ a c
+  | _,_,_,.nil _,q => q
+  | _,_,_,.cons d p,q => .cons d (p.append q)
+def single (d : D) : Path Γ (Γ.origin d) (Γ.origin (Γ.reverse d)) := .cons d (.nil _)
+def cast {a b a' b' : V} (ha : a=a') (hb : b=b') (p : Path Γ a b) : Path Γ a' b' := by
+  subst a'; subst b'; exact p
+def reverse : Path Γ a b→Path Γ b a := by
+  intro p
+  induction p with
+  | nil v => exact .nil v
+  | cons d p ih =>
+    exact (ih.append (single (Γ:=Γ) (Γ.reverse d))).cast rfl
+      (congrArg Γ.origin (PortGraph.reverse_reverse_apply Γ d))
+
+def eval {G : Type*} [Group G] (label : D→G) : {a b : V} → Path Γ a b→G
+  | _,_,.nil _ => 1
+  | _,_,.cons d p => label d*p.eval label
+@[simp] lemma eval_nil {G : Type*} [Group G] (label : D→G) (v : V) :
+    (Path.nil (Γ:=Γ) v).eval label=1 := rfl
+@[simp] lemma eval_cons {G : Type*} [Group G] (label : D→G) (d : D)
+    (p : Path Γ (Γ.origin (Γ.reverse d)) b) :
+    (Path.cons d p).eval label=label d*p.eval label := rfl
+@[simp] lemma eval_append {G : Type*} [Group G] (label : D→G)
+    (p : Path Γ a b) (q : Path Γ b c) :
+    (p.append q).eval label=p.eval label*q.eval label := by
+  induction p with
+  | nil v => simp [append]
+  | cons d p ih => simp only [append,eval_cons,ih,mul_assoc]
+@[simp] lemma eval_single {G : Type*} [Group G] (label : D→G) (d : D) :
+    (single (Γ:=Γ) d).eval label=label d := by simp [single]
+@[simp] lemma eval_cast {G : Type*} [Group G] (label : D→G)
+    {a b a' b' : V} (ha : a=a') (hb : b=b') (p : Path Γ a b) :
+    (p.cast ha hb).eval label=p.eval label := by
+  subst a'; subst b'; rfl
+lemma eval_reverse {G : Type*} [Group G] (label : D→G)
+    (hl : ∀ d,label (Γ.reverse d)=(label d)⁻¹) (p : Path Γ a b) :
+    p.reverse.eval label=(p.eval label)⁻¹ := by
+  induction p with
+  | nil v => simp [reverse]
+  | cons d p ih =>
+    simp only [reverse] at ih
+    simp only [reverse, eval_cast, eval_append,eval_single,ih,hl,eval_cons,mul_inv_rev]
+
+lemma eval_map {G H : Type*} [Group G] [Group H] (f : G→*H)
+    (label : D→G) (p : Path Γ a b) :
+    p.eval (fun d => f (label d))=f (p.eval label) := by
+  induction p with
+  | nil v => simp
+  | cons d p ih => simp only [eval_cons,ih,map_mul]
+
+end Path
+end TorsionFreeZeroDivisors.GraphPresentation
+namespace TorsionFreeZeroDivisors.GraphPresentation.Path
+open PortSubdivision
+variable {V D : Type} {Γ : PortGraph V D} {a b c : V}
+def darts : {a b : V}→Path Γ a b→List D
+  | _,_,.nil _=>[]
+  | _,_,.cons d p=>d::darts p
+@[simp] lemma darts_nil (v : V) : darts (Path.nil (Γ:=Γ) v)=[] := rfl
+@[simp] lemma darts_cons (d : D) (p : Path Γ (Γ.origin (Γ.reverse d)) b) :
+    darts (.cons d p)=d::darts p := rfl
+@[simp] lemma darts_cast {a b a' b' : V} (ha : a=a') (hb : b=b') (p : Path Γ a b) :
+    darts (p.cast ha hb)=p.darts := by subst a';subst b';rfl
+lemma darts_append (p : Path Γ a b) (q : Path Γ b c) :
+    (p.append q).darts=p.darts++q.darts := by
+  induction p with
+  | nil=>rfl
+  | cons d p ih=>simp only [append,darts_cons,ih,List.cons_append]
+lemma darts_reverse (p : Path Γ a b) : p.reverse.darts=p.darts.reverse.map Γ.reverse := by
+  induction p with
+  | nil=>rfl
+  | cons d p ih=>
+    simp only [reverse] at ih
+    simp only [reverse,darts_cast,darts_append,single,darts_cons,darts_nil,
+      List.reverse_cons,List.map_append,List.map_cons,List.map_nil]
+    exact congrArg (fun l=>l++[Γ.reverse d]) ih
+lemma empty_ends (p : Path Γ a b) (he : p.darts=[]) : a=b := by
+  cases p with
+  | nil=>rfl
+  | cons d p=>simp only [darts_cons,List.cons_ne_nil] at he
+lemma first_origin (p : Path Γ a b) (hn : p.darts≠[]) : Γ.origin (p.darts.head hn)=a := by
+  cases p with
+  | nil=>exact False.elim (hn rfl)
+  | cons d p=>rfl
+lemma last_origin (p : Path Γ a b) (hn : p.darts≠[]) :
+    Γ.origin (Γ.reverse (p.darts.getLast hn))=b := by
+  induction p with
+  | nil=>exact False.elim (hn rfl)
+  | cons d p ih=>
+    by_cases he : p.darts=[]
+    · simpa only [darts_cons,he,List.getLast_singleton] using p.empty_ends he
+    · simpa only [darts_cons,List.getLast_cons he] using ih he
+lemma chain (p : Path Γ a b) : p.darts.IsChain (fun d e=>Γ.origin (Γ.reverse d)=Γ.origin e) := by
+  induction p with
+  | nil=>exact List.IsChain.nil
+  | cons d p ih=>
+    rw [darts_cons,List.isChain_cons]
+    refine ⟨?_,ih⟩
+    intro e he
+    have hn : p.darts≠[] := by intro h;simp [h] at he
+    have hh : e=p.darts.head hn := by
+      exact (by simpa only [List.head?_eq_some_head hn,Option.mem_def,Option.some.injEq] using he : p.darts.head hn=e).symm
+    rw [hh]
+    exact (p.first_origin hn).symm
+variable {A : Type*} (label : D→A×Bool)
+def letters (p : Path Γ a b) : List (A×Bool) := p.darts.map label
+lemma letters_mk (p : Path Γ a b) :
+    FreeGroup.mk (p.letters label)=p.eval (fun d=>FreeGroup.mk [label d]) := by
+  induction p with
+  | nil=>rfl
+  | cons d p ih=>
+    change FreeGroup.mk (label d::p.letters label)=_
+    rw [show label d::p.letters label=[label d]++p.letters label from rfl,←FreeGroup.mul_mk,ih]
+    rfl
+lemma letters_reverse (hl : ∀d,label (Γ.reverse d)=WordPairing.inverseLetter (label d))
+    (p : Path Γ a b) : p.reverse.letters label=FreeGroup.invRev (p.letters label) := by
+  simp only [letters,darts_reverse,List.map_map,FreeGroup.invRev,List.map_reverse]
+  apply congrArg List.reverse
+  apply List.map_congr_left
+  intro d _
+  exact hl d
+
+end TorsionFreeZeroDivisors.GraphPresentation.Path
+namespace TorsionFreeZeroDivisors.WordBlocks
+open scoped Classical
+variable {D A : Type*} (label : D→A)
+def mapCoordinates : (ws : List (List D))→Occ ws≃Occ (ws.map (List.map label))
+  | []=>Equiv.refl _
+  | w::ws=>Equiv.sumCongr (finCongr (List.length_map (f:=label) (as:=w)).symm) (mapCoordinates ws)
+lemma mapCoordinates_letter (ws : List (List D)) (x : Occ ws) :
+    letter (ws.map (List.map label)) (mapCoordinates label ws x)=label (letter ws x) := by
+  induction ws with
+  | nil=>exact Empty.elim x
+  | cons w ws ih=>
+    cases x with
+    | inl i=>exact List.getElem_map _
+    | inr i=>exact ih i
+lemma rotate_cast {n m : ℕ} (h : n=m) (i : Fin n) :
+    finCongr h (finRotate n i)=finRotate m (finCongr h i) := by subst m;rfl
+lemma mapCoordinates_rotation (ws : List (List D)) (x : Occ ws) :
+    mapCoordinates label ws (BlockBoundary.rotation (lengths ws) x)=
+      BlockBoundary.rotation (lengths (ws.map (List.map label))) (mapCoordinates label ws x) := by
+  induction ws with
+  | nil=>exact Empty.elim x
+  | cons w ws ih=>
+    cases x with
+    | inl i=>exact congrArg Sum.inl (rotate_cast (List.length_map (f:=label) (as:=w)).symm i)
+    | inr i=>exact congrArg Sum.inr (ih i)
+/-- Actual boundary occurrences are graph darts; only their labels are inverse
+matched. In particular, this does not silently require equal graph lifts. -/
+structure LiftedMatching (inv : A→A) (ws : List (List D)) where
+  partner : Equiv.Perm (Occ ws)
+  involutive : Function.Involutive partner
+  fixed_free : ∀x,partner x≠x
+  compatible : ∀x,label (letter ws (partner x))=inv (label (letter ws x))
+  genusZero : MapEuler.GenusZero (BlockBoundary.rotation (lengths ws)) partner
+def Matching.lift {inv : A→A} {ws : List (List D)}
+    (d : Matching inv (ws.map (List.map label))) : LiftedMatching label inv ws where
+  partner := (mapCoordinates label ws).symm.permCongr d.partner
+  involutive := PermutationTransport.involutive _ _ d.involutive
+  fixed_free := PermutationTransport.fixed_free _ _ d.fixed_free
+  compatible x := by
+    rw [←mapCoordinates_letter label ws,←mapCoordinates_letter label ws]
+    simp only [Equiv.permCongr_apply,Equiv.symm_symm,Equiv.apply_symm_apply]
+    exact d.compatible (mapCoordinates label ws x)
+  genusZero := by
+    have hh := MapConjugation.genusZero (mapCoordinates label ws).symm _ _ d.genusZero
+    have he : (mapCoordinates label ws).symm.permCongr
+        (BlockBoundary.rotation (lengths (ws.map (List.map label))))=BlockBoundary.rotation (lengths ws) := by
+      apply Equiv.ext
+      intro x
+      apply (mapCoordinates label ws).injective
+      simp only [Equiv.permCongr_apply,Equiv.symm_symm,Equiv.apply_symm_apply]
+      exact (mapCoordinates_rotation label ws x).symm
+    rwa [he] at hh
+
+end TorsionFreeZeroDivisors.WordBlocks
+namespace TorsionFreeZeroDivisors.MapDeletion
+open scoped Classical
+open DeleteCycle MapEuler PermutationCycles
+variable {O : Type} [Fintype O] (σ α : Equiv.Perm O) (p : O) (ha : α p=p)
+lemma genusZero_iff_delete (hs : σ p≠p) :
+    GenusZero σ α ↔ GenusZero (rotation σ p) (partner α p ha) := by
+  refine ⟨genusZero_delete σ α p ha hs,fun hz=>?_⟩
+  have hv := bypass_count σ p hs
+  have hf := bypass_count (α*σ) p (face_nonfixed σ α p ha hs)
+  rw [bypass_mul σ p α ha] at hf
+  have hc := Nat.card_congr (componentEquiv σ α p ha hs)
+  have he := support_count α p ha
+  simp only [←Nat.card_eq_fintype_card] at hv hf
+  dsimp only [GenusZero] at hz ⊢
+  change Nat.card (Cycle (rotation σ p))=Nat.card (Cycle σ) at hv
+  change Nat.card (Cycle (partner α p ha*rotation σ p))=Nat.card (Cycle (α*σ)) at hf
+  rw [←hv,←hf,hc]
+  have hsup : ∀ (i j : Fintype (Rest p)) (d e : DecidableEq (Rest p)),
+      @Equiv.Perm.support (Rest p) d i (partner α p ha) =
+      @Equiv.Perm.support (Rest p) e j (partner α p ha) := by
+    intro i j d e
+    cases Subsingleton.elim i j
+    cases Subsingleton.elim d e
+    rfl
+  convert hz using 1
+  rw [←he]
+  congr 1
+  exact congrArg Finset.card (hsup _ _ _ _)
+end TorsionFreeZeroDivisors.MapDeletion
+namespace TorsionFreeZeroDivisors.MarkerInsertion
+open scoped Classical
+open DeleteCycle
+variable {O : Type} (σ α : Equiv.Perm O) (p : O)
+/-- Insert an unpaired marker immediately before p. -/
+def rotation : Equiv.Perm (Option O) := Equiv.swap none (some p)*Equiv.optionCongr σ
+def partner : Equiv.Perm (Option O) := Equiv.optionCongr α
+@[simp] lemma rotation_none : rotation σ p none=some p := by simp [rotation,Equiv.Perm.mul_apply]
+@[simp] lemma partner_none : partner α none=none := rfl
+lemma rotation_some (x : O) (hx : σ x≠p) : rotation σ p (some x)=some (σ x) := by
+  simp only [rotation,Equiv.Perm.mul_apply,Equiv.optionCongr_apply,Option.map_some]
+  exact Equiv.swap_apply_of_ne_of_ne (by simp) (by simpa using hx)
+lemma rotation_predecessor : rotation σ p (some (σ.symm p))=none := by
+  simp [rotation,Equiv.Perm.mul_apply]
+lemma rotation_nonfixed : rotation σ p none≠none := by rw [rotation_none];exact Option.some_ne_none p
+lemma partner_involutive (hi : Function.Involutive α) : Function.Involutive (partner α) := by
+  intro x
+  cases x with
+  | none=>rfl
+  | some x=>exact congrArg some (hi x)
+lemma fixed_only (hf : ∀ x,α x≠x) (x : Option O) (hx : partner α x=x) : x=none := by
+  cases x with
+  | none=>rfl
+  | some x=>exact False.elim (hf x (Option.some.inj hx))
+def coordinates : O≃Rest (none : Option O) where
+  toFun x := ⟨some x,Option.some_ne_none x⟩
+  invFun x := x.val.get (Option.isSome_iff_ne_none.mpr x.property)
+  left_inv _ := rfl
+  right_inv _ := Subtype.ext (Option.some_get _)
+variable [Fintype O]
+lemma boundary_commutes (x : O) : bypass (rotation σ p) none (coordinates x)=coordinates (σ x) := by
+  apply Subtype.ext
+  rw [bypass_apply]
+  simp only [coordinates,Equiv.coe_fn_mk,rotation_none]
+  by_cases hx : σ x=p <;> simp [rotation,Equiv.Perm.mul_apply,Equiv.swap_apply_def,hx]
+omit [Fintype O] in
+lemma partner_commutes (x : O) : restrict (partner α) none (partner_none α) (coordinates x)=coordinates (α x) := rfl
+lemma boundary_conjugate : bypass (rotation σ p) none=coordinates.permCongr σ := by
+  apply Equiv.ext
+  intro x
+  obtain ⟨x,rfl⟩ := coordinates.surjective x
+  rw [boundary_commutes]
+  simp only [Equiv.permCongr_apply,Equiv.symm_apply_apply]
+omit [Fintype O] in
+lemma partner_conjugate : restrict (partner α) none (partner_none α)=coordinates.permCongr α := by
+  apply Equiv.ext
+  intro x
+  obtain ⟨x,rfl⟩ := coordinates.surjective x
+  rw [partner_commutes]
+  simp only [Equiv.permCongr_apply,Equiv.symm_apply_apply]
+/-- The literal marked rotation retains the exact genus-zero certificate.
+This is only finite permutation insertion, not a surface realization. -/
+theorem genusZero (hz : MapEuler.GenusZero σ α) : MapEuler.GenusZero (rotation σ p) (partner α) := by
+  apply (MapDeletion.genusZero_iff_delete (rotation σ p) (partner α) none (partner_none α) (rotation_nonfixed σ p)).mpr
+  unfold MapDeletion.rotation MapDeletion.partner
+  rw [boundary_conjugate,partner_conjugate]
+  have hh := MapConjugation.genusZero coordinates σ α hz
+  convert hh using 1
+
+end TorsionFreeZeroDivisors.MarkerInsertion
+namespace TorsionFreeZeroDivisors.FinitePicture
+open scoped Classical
+open PortSubdivision
+variable {V D A O : Type} [Fintype O] (Γ : PortGraph V D) (label : D→A) (inv : A→A) (x y : V)
+  (σ α : Equiv.Perm O) (hi : Function.Involutive α) (hf : ∀i,α i≠i)
+  (edge : O→D) (p : O)
+  (hc : ∀i,label (edge (α i))=inv (label (edge i)))
+  (hj : ∀i,σ i≠p → Γ.origin (Γ.reverse (edge i))=Γ.origin (edge (σ i)))
+  (hp : Γ.origin (edge p)=x)
+  (he : ∀i,σ i=p → Γ.origin (Γ.reverse (edge i))=y)
+  (hz : MapEuler.GenusZero σ α)
+/-- Insert the literal root break in a lifted genus-zero full matching. This
+retains every graph dart and all endpoints; no graph path is replaced by its
+rose label. The initial existence of this full matching must still be proved. -/
+def ofBoundary : Data (O:=Option O) Γ label inv x y where
+  rotation := MarkerInsertion.rotation σ p
+  partner := MarkerInsertion.partner α
+  involutive := MarkerInsertion.partner_involutive α hi
+  marker := none
+  marker_fixed := rfl
+  fixed_only := MarkerInsertion.fixed_only α hf
+  dart := Option.map edge
+  none_iff i := by cases i <;> simp
+  before i := i.elim y (fun j=>Γ.origin (edge j))
+  after i := i.elim x (fun j=>Γ.origin (Γ.reverse (edge j)))
+  begins i d hd := by
+    cases i with
+    | none=>simp at hd
+    | some i=>exact congrArg Γ.origin (Option.some.inj hd)
+  ends i d hd := by
+    cases i with
+    | none=>simp at hd
+    | some i=>exact congrArg (Γ.origin ∘ Γ.reverse) (Option.some.inj hd)
+  marker_before := rfl
+  marker_after := rfl
+  consistent i := by
+    cases i with
+    | none=>simpa only [MarkerInsertion.rotation_none,Option.elim_none,Option.elim_some] using hp.symm
+    | some i=>
+      by_cases hi : σ i=p
+      · have hx : i=σ.symm p := σ.injective (hi.trans (σ.apply_symm_apply p).symm)
+        rw [hx,MarkerInsertion.rotation_predecessor]
+        exact he _ (σ.apply_symm_apply p)
+      · rw [MarkerInsertion.rotation_some σ p i hi]
+        exact hj i hi
+  compatible i := by
+    cases i with
+    | none=>rfl
+    | some i=>exact congrArg some (hc i)
+  genusZero := MarkerInsertion.genusZero σ α p hz
+
+end TorsionFreeZeroDivisors.FinitePicture
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/GroupRing/Attachment.lean b/lean/OAI/Algebra/GroupRing/Attachment.lean
new file mode 100644
index 0000000000000000000000000000000000000000..5546753d4f055a5a75647db4b89260b5c4c9d929
--- /dev/null
+++ b/lean/OAI/Algebra/GroupRing/Attachment.lean
@@ -0,0 +1,462 @@
+import Mathlib
+import OAI.Algebra.GroupRing.HomotopyFunctor
+
+namespace OAI
+
+noncomputable section
+
+open Set Metric Topology BigOperators
+open Set Metric Topology
+
+namespace GroupRingTopology.Cellular
+universe u
+variable {X Y : Type u} [TopologicalSpace X] [TopologicalSpace Y] [Nonempty X]
+variable {C : Set X} [CWComplex C] {f : X → Y} (hf : IsClosedEmbedding f)
+
+def transportedMap (n : ℕ) (i : RelCWComplex.cell C n) : PartialEquiv (Fin n → ℝ) Y :=
+  (RelCWComplex.map n i).trans (hf.isEmbedding.toPartialHomeomorph f).toPartialEquiv
+
+@[simp] lemma transportedMap_apply (n : ℕ) (i : RelCWComplex.cell C n) (x : Fin n → ℝ) :
+    transportedMap hf n i x = f (RelCWComplex.map n i x) := rfl
+
+lemma transportedMap_source (n : ℕ) (i : RelCWComplex.cell C n) :
+    (transportedMap hf n i).source = ball 0 1 := by
+  simp only [transportedMap,PartialEquiv.trans_source,
+    IsEmbedding.toPartialHomeomorph_source,Set.preimage_univ,Set.inter_univ,
+    RelCWComplex.source_eq]
+
+lemma transportedMap_image (n : ℕ) (i : RelCWComplex.cell C n) (S : Set (Fin n → ℝ)) :
+    transportedMap hf n i '' S = f '' (RelCWComplex.map n i '' S) :=
+  Set.image_comp f (RelCWComplex.map n i) S
+
+lemma transportedMap_continuousOn (n : ℕ) (i : RelCWComplex.cell C n) :
+    ContinuousOn (transportedMap hf n i) (closedBall 0 1) :=
+  hf.continuous.comp_continuousOn (RelCWComplex.continuousOn n i)
+
+lemma transportedMap_continuousOn_symm (n : ℕ) (i : RelCWComplex.cell C n) :
+    ContinuousOn (transportedMap hf n i).symm (transportedMap hf n i).target := by
+  let e := hf.isEmbedding.toPartialHomeomorph f
+  change ContinuousOn (fun y => (RelCWComplex.map n i).symm (e.symm y))
+    (e.target ∩ e.symm ⁻¹' (RelCWComplex.map n i).target)
+  exact (RelCWComplex.continuousOn_symm n i).comp
+    (e.continuousOn_symm.mono Set.inter_subset_left) (fun _ h => h.2)
+
+variable [T2Space X]
+
+/-- Closed embeddings transport classical CW structures, including their weak
+ topology, with precisely the same cells. -/
+@[instance_reducible]
+def transportCW : CWComplex (f '' C) where
+  cell := RelCWComplex.cell C
+  map := transportedMap hf
+  source_eq := transportedMap_source hf
+  continuousOn := transportedMap_continuousOn hf
+  continuousOn_symm := transportedMap_continuousOn_symm hf
+  pairwiseDisjoint' := by
+    intro p _ q _ hpq
+    change Disjoint (transportedMap hf p.1 p.2 '' ball 0 1)
+      (transportedMap hf q.1 q.2 '' ball 0 1)
+    rw [transportedMap_image,transportedMap_image]
+    exact (CWComplex.disjoint_openCell_of_ne hpq).image hf.injective.injOn (Set.subset_univ _) (Set.subset_univ _)
+  mapsTo' := by
+    intro n i
+    obtain ⟨I,hI⟩ := CWComplex.cellFrontier_subset_finite_closedCell n i
+    refine ⟨I,?_⟩
+    intro x hx
+    have h := hI (show RelCWComplex.map n i x ∈ CWComplex.cellFrontier n i from ⟨x,hx,rfl⟩)
+    simp only [Set.mem_iUnion] at h
+    obtain ⟨m,hm,j,hj,hx⟩ := h
+    refine Set.mem_iUnion.mpr ⟨m,Set.mem_iUnion.mpr ⟨hm,Set.mem_iUnion.mpr
+      ⟨j,Set.mem_iUnion.mpr ⟨hj,?_⟩⟩⟩⟩
+    rw [transportedMap_image]
+    exact ⟨_,hx,rfl⟩
+  closed' := by
+    intro A hA hclosed
+    have hpre : IsClosed (f ⁻¹' A) := by
+      apply (CWComplex.closed C (f ⁻¹' A) ?_).mpr
+      · intro n i
+        have h := (hclosed n i).preimage hf.continuous
+        rw [transportedMap_image,Set.preimage_inter,
+          Set.preimage_image_eq _ hf.injective] at h
+        exact h
+      · intro x hx
+        obtain ⟨y,hy,hyx⟩ := hA hx
+        exact hf.injective hyx ▸ hy
+    have h := hf.isClosedMap _ hpre
+    rwa [Set.image_preimage_eq_of_subset (hA.trans (Set.image_subset_range f C))] at h
+  union' := by
+    simp only [transportedMap_image,← Set.image_iUnion]
+    change f '' (⋃ n, ⋃ i, CWComplex.closedCell n i) = f '' C
+    rw [CWComplex.union]
+
+end GroupRingTopology.Cellular
+open Set Metric Topology
+namespace GroupRingTopology.Attachment
+
+section
+open Set Metric Topology
+universe z
+variable {X : Type z} [TopologicalSpace X] [T2Space X] [Nonempty X]
+variable [CWComplex (Set.univ : Set X)] {ι : Type z} {n : ℕ}
+variable (a : ι → C(Sphere n,X))
+
+abbrev OldCell (m : ℕ) := RelCWComplex.cell (Set.univ : Set X) m
+
+omit [Nonempty X] in
+lemma attaching_finite_frontier
+    (hdim : ∀ m (_ : OldCell (X := X) m), m < n) (i : ι) :
+    ∃ I : ∀ m, Finset (OldCell (X := X) m),
+      ∀ x, a i x ∈ ⋃ m < n, ⋃ j ∈ I m, CWComplex.closedCell m j := by
+  classical
+  let S := {p : Σ m, OldCell (X := X) m |
+    (Set.range (a i) ∩ CWComplex.openCell p.1 p.2).Nonempty}
+  have hS : S.Finite := Cellular.compact_finitely_many_cells (C := (Set.univ : Set X))
+    (isCompact_range (a i).continuous)
+  have hSm (m : ℕ) : ((Sigma.mk m) ⁻¹' S).Finite :=
+    hS.preimage (Set.injOn_of_injective (fun _ _ h => eq_of_heq (Sigma.mk.inj_iff.mp h).2))
+  refine ⟨fun m => (hSm m).toFinset,?_⟩
+  intro x
+  have hx : a i x ∈ (Set.univ : Set X) := Set.mem_univ _
+  rw [← CWComplex.iUnion_openCell_eq_complex (C := (Set.univ : Set X))] at hx
+  simp only [Set.mem_iUnion] at hx
+  obtain ⟨m,j,hx⟩ := hx
+  exact Set.mem_iUnion.mpr ⟨m,Set.mem_iUnion.mpr ⟨hdim m j,Set.mem_iUnion.mpr
+    ⟨j,Set.mem_iUnion.mpr ⟨(hSm m).mem_toFinset.mpr ⟨a i x,⟨x,rfl⟩,hx⟩,
+      CWComplex.openCell_subset_closedCell m j hx⟩⟩⟩⟩
+
+abbrev LayerCell (m : ℕ) := OldCell (X := X) m ⊕ CellIndex.{z,z} m n ι
+
+def layerMap (m : ℕ) : LayerCell (X := X) (ι := ι) (n := n) m →
+    PartialEquiv (Fin m → ℝ) (Space a)
+  | Sum.inl i => Cellular.transportedMap (C := Set.univ) (base_closedEmbedding a) m i
+  | Sum.inr i => cellMap a m i
+
+omit [T2Space X] in
+lemma layerMap_old_apply (m : ℕ) (i : OldCell (X := X) m) (x : Fin m → ℝ) :
+    layerMap a m (Sum.inl i) x = base a (RelCWComplex.map m i x) := rfl
+
+omit [T2Space X] in
+lemma layerMap_old_image (m : ℕ) (i : OldCell (X := X) m) (S : Set (Fin m → ℝ)) :
+    layerMap a m (Sum.inl i) '' S = base a '' (RelCWComplex.map m i '' S) :=
+  Cellular.transportedMap_image (base_closedEmbedding a) m i S
+
+omit [T2Space X] in
+lemma layerMap_new (i : ι) :
+    layerMap a n (Sum.inr ⟨⟨⟨rfl⟩,i⟩⟩) = characteristicPE a i := rfl
+
+@[instance_reducible]
+def layerCW (hdim : ∀ m (_ : OldCell (X := X) m), m < n) :
+    CWComplex (Set.univ : Set (Space a)) where
+  cell := LayerCell (X := X) (ι := ι) (n := n)
+  map := layerMap a
+  source_eq := by
+    intro m i
+    cases i with
+    | inl i => exact Cellular.transportedMap_source (base_closedEmbedding a) m i
+    | inr i => exact (relCWComplex a).source_eq m i
+  continuousOn := by
+    intro m i
+    cases i with
+    | inl i => exact Cellular.transportedMap_continuousOn (base_closedEmbedding a) m i
+    | inr i => exact (relCWComplex a).continuousOn m i
+  continuousOn_symm := by
+    intro m i
+    cases i with
+    | inl i => exact Cellular.transportedMap_continuousOn_symm (base_closedEmbedding a) m i
+    | inr i => exact (relCWComplex a).continuousOn_symm m i
+  pairwiseDisjoint' := by
+    rintro ⟨m,i⟩ _ ⟨k,j⟩ _ hne
+    change Disjoint (layerMap a m i '' ball 0 1) (layerMap a k j '' ball 0 1)
+    cases i with
+    | inl i =>
+      cases j with
+      | inl j =>
+        rw [layerMap_old_image,layerMap_old_image]
+        apply (CWComplex.disjoint_openCell_of_ne ?_).image (base_closedEmbedding a).injective.injOn (Set.subset_univ _) (Set.subset_univ _)
+        intro h
+        cases h
+        exact hne rfl
+      | inr j =>
+        obtain ⟨⟨⟨hk⟩,j⟩⟩ := j
+        subst k
+        rw [layerMap_old_image,layerMap_new,characteristicPE_image_ball]
+        apply Set.disjoint_left.mpr
+        rintro z ⟨x,_,rfl⟩ ⟨y,h⟩
+        cases h
+    | inr i =>
+      obtain ⟨⟨⟨hm⟩,i⟩⟩ := i
+      subst m
+      cases j with
+      | inl j =>
+        rw [layerMap_new,characteristicPE_image_ball,layerMap_old_image]
+        apply Set.disjoint_left.mpr
+        rintro z ⟨x,rfl⟩ ⟨y,_,h⟩
+        cases h
+      | inr j =>
+        obtain ⟨⟨⟨hk⟩,j⟩⟩ := j
+        subst k
+        rw [layerMap_new,layerMap_new,characteristicPE_image_ball,characteristicPE_image_ball]
+        apply Set.disjoint_left.mpr
+        rintro z ⟨x,rfl⟩ ⟨y,h⟩
+        have hij : j = i := congrArg Sigma.fst (Sum.inr_injective h)
+        subst j
+        exact hne rfl
+  mapsTo' := by
+    classical
+    intro m c
+    cases c with
+    | inl i =>
+      obtain ⟨I,hI⟩ := CWComplex.cellFrontier_subset_finite_closedCell m i
+      refine ⟨fun k => (I k).image Sum.inl,?_⟩
+      intro x hx
+      have hh := hI (show RelCWComplex.map m i x ∈ CWComplex.cellFrontier m i from ⟨x,hx,rfl⟩)
+      simp only [Set.mem_iUnion] at hh
+      obtain ⟨k,hkm,j,hj,hx⟩ := hh
+      refine Set.mem_iUnion.mpr ⟨k,Set.mem_iUnion.mpr ⟨hkm,Set.mem_iUnion.mpr
+        ⟨Sum.inl j,Set.mem_iUnion.mpr ⟨Finset.mem_image.mpr ⟨j,hj,rfl⟩,?_⟩⟩⟩⟩
+      rw [layerMap_old_image]
+      exact ⟨_,hx,rfl⟩
+    | inr i =>
+      obtain ⟨⟨⟨hm⟩,i⟩⟩ := i
+      subst m
+      obtain ⟨I,hI⟩ := attaching_finite_frontier a hdim i
+      refine ⟨fun k => (I k).image Sum.inl,?_⟩
+      intro x hx
+      have hh := hI ⟨x,hx⟩
+      simp only [Set.mem_iUnion] at hh
+      obtain ⟨k,hkn,j,hj,hx'⟩ := hh
+      refine Set.mem_iUnion.mpr ⟨k,Set.mem_iUnion.mpr ⟨hkn,Set.mem_iUnion.mpr
+        ⟨Sum.inl j,Set.mem_iUnion.mpr ⟨Finset.mem_image.mpr ⟨j,hj,rfl⟩,?_⟩⟩⟩⟩
+      rw [layerMap_old_image]
+      refine ⟨a i ⟨x,hx⟩,hx',?_⟩
+      change base a (a i ⟨x,hx⟩) = characteristic a i x
+      exact (cell_boundary a i ⟨x,hx⟩).symm.trans
+        (characteristic_disk a i (boundary n ⟨x,hx⟩)).symm
+  closed' := by
+    intro A _ hA
+    apply (isClosed_iff a A).mpr
+    constructor
+    · apply (CWComplex.closed Set.univ (base a ⁻¹' A) (Set.subset_univ _)).mpr
+      intro m i
+      have h := (hA m (Sum.inl i)).preimage (continuous_base a)
+      rw [layerMap_old_image,Set.preimage_inter,
+        Set.preimage_image_eq _ (base_closedEmbedding a).injective] at h
+      exact h
+    · intro i
+      have h := (hA n (Sum.inr ⟨⟨⟨rfl⟩,i⟩⟩)).preimage (cell a i).continuous
+      rw [layerMap_new,characteristicPE_image_closedBall,Set.preimage_inter] at h
+      simpa only [Set.preimage_range,Set.inter_univ] using h
+  union' := by
+    apply Set.eq_univ_of_forall
+    intro z
+    cases z with
+    | inl x =>
+      have hx : x ∈ (Set.univ : Set X) := Set.mem_univ _
+      rw [← CWComplex.union (C := (Set.univ : Set X))] at hx
+      simp only [Set.mem_iUnion] at hx
+      obtain ⟨m,i,hx⟩ := hx
+      refine Set.mem_iUnion.mpr ⟨m,Set.mem_iUnion.mpr ⟨Sum.inl i,?_⟩⟩
+      rw [layerMap_old_image]
+      exact ⟨x,hx,rfl⟩
+    | inr p =>
+      refine Set.mem_iUnion.mpr ⟨n,Set.mem_iUnion.mpr ⟨Sum.inr ⟨⟨⟨rfl⟩,p.1⟩⟩,?_⟩⟩
+      rw [layerMap_new,characteristicPE_image_closedBall]
+      exact ⟨interior n p.2,cell_interior a p.1 p.2⟩
+
+lemma layerCW_dimensions (hdim : ∀ m (_ : OldCell (X := X) m), m < n)
+    (m : ℕ) (i : (layerCW a hdim).cell m) : m < n+1 := by
+  cases i with
+  | inl i => exact (hdim m i).trans (Nat.lt_succ_self n)
+  | inr i =>
+    obtain ⟨⟨⟨hm⟩,i⟩⟩ := i
+    subst m
+    exact Nat.lt_succ_self n
+
+lemma layerCW_finite_cells [Finite ι]
+    (hfin : ∀ m, Finite (OldCell (X := X) m))
+    (hdim : ∀ m (_ : OldCell (X := X) m), m < n) (m : ℕ) :
+    Finite ((layerCW a hdim).cell m) := by
+  let := hfin m
+  change Finite (LayerCell (X := X) (ι := ι) (n := n) m)
+  infer_instance
+
+end
+
+section
+open Set Metric Topology
+universe u v w z
+variable {X : Type u} [TopologicalSpace X] {ι : Type v} {n : ℕ}
+variable (a : ι → C(Sphere n,X))
+variable {G : Type w} [Group G] [MulAction G X] [MulAction G ι]
+
+instance spaceMulAction : MulAction G (Space a) where
+  smul g := Sum.elim (fun x => Sum.inl (g • x)) (fun p => Sum.inr ⟨g • p.1,p.2⟩)
+  one_smul := by
+    intro x
+    cases x with
+    | inl x => change Sum.inl ((1 : G) • x) = Sum.inl x; rw [one_smul]
+    | inr p => change Sum.inr ⟨(1 : G) • p.1,p.2⟩ = Sum.inr p; rw [one_smul]
+  mul_smul := by
+    intro g h x
+    cases x with
+    | inl x => change Sum.inl ((g * h) • x) = Sum.inl (g • h • x); rw [mul_smul]
+    | inr p => change (Sum.inr ⟨(g * h) • p.1,p.2⟩ : Space a) = Sum.inr ⟨g • h • p.1,p.2⟩; rw [mul_smul]
+
+@[simp] lemma smul_base (g : G) (x : X) : g • base a x = base a (g • x) := rfl
+@[simp] lemma smul_openCell (g : G) (i : ι) (x : OpenDisk n) :
+    g • openCell a i x = openCell a (g • i) x := rfl
+
+variable (ha : ∀ (g : G) i x, a (g • i) x = g • a i x)
+include ha
+lemma smul_cell (g : G) (i : ι) (d : Disk n) :
+    g • cell a i d = cell a (g • i) d := by
+  classical
+  by_cases hd : d.1 ∈ ball (0 : Fin n → ℝ) 1
+  · have heq : d = interior n ⟨d.1,hd⟩ := rfl
+    rw [heq,cell_interior,cell_interior]
+    rfl
+  · let x : Sphere n := ⟨d.1,by
+      have hm := d.2
+      simp only [mem_closedBall,mem_ball,mem_sphere] at *
+      exact le_antisymm hm (le_of_not_gt hd)⟩
+    have heq : d = boundary n x := rfl
+    rw [heq,cell_boundary,cell_boundary,smul_base,ha]
+
+lemma continuousConstSMul [ContinuousConstSMul G X] : ContinuousConstSMul G (Space a) where
+  continuous_const_smul g := (continuous_iff a _).mpr ⟨
+    (continuous_base a).comp (continuous_const_smul g),fun i => by
+      have heq : (g • ·) ∘ cell a i = cell a (g • i) := funext (smul_cell a ha g i)
+      rw [heq]
+      exact (cell a (g • i)).continuous⟩
+
+omit ha in
+lemma isOpen_iff (S : Set (Space a)) :
+    IsOpen S ↔ IsOpen (base a ⁻¹' S) ∧ ∀ i, IsOpen (cell a i ⁻¹' S) := by
+  change @IsOpen _ (TopologicalSpace.coinduced (quotient a) inferInstance) S ↔ _
+  rw [isOpen_coinduced,isOpen_sum_iff,isOpen_sigma_iff]
+  rfl
+
+end
+
+open Set Metric Topology
+universe u v w
+abbrev Collar (n : ℕ) := {d : Disk n | (1 / 2 : ℝ) < ‖d.1‖}
+
+def collarInclusion (n : ℕ) : Collar n → Disk n := Subtype.val
+
+def radial (n : ℕ) : Collar n → Sphere n := fun d =>
+  ⟨‖d.1.1‖⁻¹ • d.1.1,by
+    have hn : ‖d.1.1‖ ≠ 0 := ne_of_gt (lt_trans (by norm_num) d.2)
+    rw [mem_sphere,dist_zero_right,norm_smul,Real.norm_eq_abs,abs_inv,abs_norm,
+      inv_mul_cancel₀ hn]⟩
+
+lemma continuous_radial (n : ℕ) : Continuous (radial n) := by
+  apply Continuous.subtype_mk
+  have hn : ∀ d : Collar n, ‖d.1.1‖ ≠ 0 := fun d => ne_of_gt (lt_trans (by norm_num) d.2)
+  exact ((continuous_subtype_val.comp continuous_subtype_val).norm.inv₀ hn).smul
+    (continuous_subtype_val.comp continuous_subtype_val)
+
+lemma collar_openEmbedding (n : ℕ) : IsOpenEmbedding (collarInclusion n) :=
+  (isOpen_lt continuous_const continuous_subtype_val.norm).isOpenEmbedding_subtypeVal
+
+lemma radial_boundary (n : ℕ) (x : Sphere n) (h : (1/2:ℝ) < ‖(boundary n x).1‖) :
+    radial n ⟨boundary n x,h⟩ = x := by
+  apply Subtype.ext
+  have hx : ‖x.1‖ = 1 := by simpa only [mem_sphere,dist_zero_right] using x.2
+  simp only [radial,boundary,hx,inv_one,one_smul]
+
+variable {X : Type u} [TopologicalSpace X] {ι : Type v} {n : ℕ}
+variable (a : ι → C(Sphere n,X))
+
+/-- An open old-space neighborhood thickened by the outer half of each disk.
+Membership is tested by radial retraction of the disk to its attaching sphere. -/
+def thickening (U : Set X) : Set (Space a) := fun z =>
+  match z with
+  | Sum.inl x => x ∈ U
+  | Sum.inr p => ∃ h : (1/2:ℝ) < ‖p.2.1‖,
+      a p.1 (radial n ⟨interior n p.2,h⟩) ∈ U
+
+@[simp] lemma base_mem_thickening (U : Set X) (x : X) :
+    base a x ∈ thickening a U ↔ x ∈ U := Iff.rfl
+
+lemma cell_preimage_thickening (U : Set X) (i : ι) :
+    cell a i ⁻¹' thickening a U =
+      collarInclusion n '' ((a i ∘ radial n) ⁻¹' U) := by
+  classical
+  ext d
+  by_cases hd : d.1 ∈ ball (0 : Fin n → ℝ) 1
+  · have heq : d = interior n ⟨d.1,hd⟩ := rfl
+    rw [heq]
+    simp only [Set.mem_preimage,cell_interior,Set.mem_image]
+    constructor
+    · rintro ⟨h,hh⟩
+      exact ⟨⟨d,h⟩,hh,rfl⟩
+    · rintro ⟨y,hy,he⟩
+      have heq' : y.1 = d := he
+      subst d
+      exact ⟨y.2,hy⟩
+  · let x : Sphere n := ⟨d.1,by
+      have hm := d.2
+      simp only [mem_closedBall,mem_ball,mem_sphere] at *
+      exact le_antisymm hm (le_of_not_gt hd)⟩
+    have heq : d = boundary n x := rfl
+    have hx : ‖x.1‖ = 1 := by simpa only [mem_sphere,dist_zero_right] using x.2
+    have hhalf : (1/2:ℝ) < ‖(boundary n x).1‖ := by change (1/2:ℝ) < ‖x.1‖; rw [hx]; norm_num
+    rw [heq]
+    simp only [Set.mem_preimage,cell_boundary,base_mem_thickening,Set.mem_image]
+    constructor
+    · intro h
+      exact ⟨⟨boundary n x,hhalf⟩,by simpa only [Function.comp_apply,radial_boundary] using h,rfl⟩
+    · rintro ⟨y,hy,he⟩
+      have heq' : y = ⟨boundary n x,hhalf⟩ := Subtype.ext he
+      simpa only [heq',Function.comp_apply,radial_boundary] using hy
+
+lemma thickening_isOpen {U : Set X} (hU : IsOpen U) : IsOpen (thickening a U) := by
+  rw [isOpen_iff]
+  refine ⟨hU,fun i => ?_⟩
+  rw [cell_preimage_thickening]
+  exact (collar_openEmbedding n).isOpenMap _
+    (hU.preimage ((a i).continuous.comp (continuous_radial n)))
+
+variable {G : Type w} [Group G] [MulAction G X] [MulAction G ι]
+variable (ha : ∀ (g : G) i x, a (g • i) x = g • a i x)
+include ha
+lemma thickening_disjoint {U : Set X}
+    (hU : ∀ g : G, ((g • ·) '' U ∩ U).Nonempty → g = 1) :
+    ∀ g : G, ((g • ·) '' thickening a U ∩ thickening a U).Nonempty → g = 1 := by
+  intro g h
+  obtain ⟨_,⟨z,hz,rfl⟩,hgz⟩ := h
+  cases z with
+  | inl x => exact hU g ⟨g • x,⟨x,hz,rfl⟩,hgz⟩
+  | inr p =>
+    obtain ⟨hhalf,hz⟩ := hz
+    obtain ⟨_,hgz⟩ := hgz
+    change a (g • p.1) (radial n ⟨interior n p.2,hhalf⟩) ∈ U at hgz
+    rw [ha] at hgz
+    exact hU g ⟨g • a p.1 (radial n ⟨interior n p.2,hhalf⟩),⟨_,hz,rfl⟩,hgz⟩
+
+lemma exists_disjoint_nhds [IsCancelSMul G ι]
+    (hX : ∀ x : X, ∃ U ∈ 𝓝 x, ∀ g : G, ((g • ·) '' U ∩ U).Nonempty → g = 1) :
+    ∀ z : Space a, ∃ U ∈ 𝓝 z, ∀ g : G, ((g • ·) '' U ∩ U).Nonempty → g = 1 := by
+  intro z
+  cases z with
+  | inl x =>
+    obtain ⟨U,hUx,hU⟩ := hX x
+    obtain ⟨V,hVU,hV,hxV⟩ := mem_nhds_iff.mp hUx
+    refine ⟨thickening a V,(thickening_isOpen a hV).mem_nhds hxV,
+      thickening_disjoint a ha (fun g hg => hU g ?_)⟩
+    exact hg.mono (Set.inter_subset_inter (Set.image_mono hVU) hVU)
+  | inr p =>
+    refine ⟨Set.range (openCell a p.1),(openCell_openEmbedding a p.1).isOpen_range.mem_nhds
+      (Set.mem_range_self p.2),?_⟩
+    intro g hg
+    obtain ⟨_,⟨_,⟨x,rfl⟩,rfl⟩,⟨y,hy⟩⟩ := hg
+    have hi : p.1 = g • p.1 := congrArg Sigma.fst (Sum.inr_injective hy)
+    apply IsCancelSMul.right_cancel g 1 p.1
+    simpa only [one_smul] using hi.symm
+
+end GroupRingTopology.Attachment
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/GroupRing/AttachmentFurther.lean b/lean/OAI/Algebra/GroupRing/AttachmentFurther.lean
new file mode 100644
index 0000000000000000000000000000000000000000..f37426b3221c6b2bdd8a0632c8b3be7b16943f0f
--- /dev/null
+++ b/lean/OAI/Algebra/GroupRing/AttachmentFurther.lean
@@ -0,0 +1,414 @@
+import Mathlib
+import OAI.Algebra.GroupRing.CellularFurther
+
+namespace OAI
+
+noncomputable section
+
+open Set Metric Topology BigOperators
+open Set Metric Topology
+open Set Topology
+open Set Metric Topology
+open scoped NNReal
+open Set Metric Topology
+open scoped NNReal ENNReal
+
+namespace GroupRingTopology.Attachment
+
+section
+open Set Metric Topology
+variable {X : Type*} [TopologicalSpace X] {ι : Type*} {n : ℕ}
+variable (a : ι → C(Sphere n,X)) [T2Space (Space a)]
+
+lemma sphere_filling_preserved {m : ℕ} (hm : m < n)
+    (hX : ∀ f : C(Sphere (m+1),X), SphereTopology.Extends f)
+    (f : C(Sphere (m+1),Space a)) : SphereTopology.Extends f := by
+  let := SphereTopology.sphere_nonempty m
+  have hdim : dimH (Set.univ : Set (Sphere (m+1))) < n :=
+    (GeneralPosition.dimH_cube_boundary_subtype_le m).trans_lt (by exact_mod_cast hm)
+  obtain ⟨g,H,_⟩ := exists_deformation_into_base a f hdim
+  apply SphereTopology.extends_of_homotopy H
+  obtain ⟨F,hF⟩ := hX g
+  refine ⟨(⟨base a,continuous_base a⟩ : C(X,Space a)).comp F,?_⟩
+  ext x
+  exact congrArg (base a) (ContinuousMap.congr_fun hF x)
+
+lemma dimH_disk_subtype_le (m : ℕ) : dimH (Set.univ : Set (Disk m)) ≤ m := by
+  rw [← isometry_subtype_coe.dimH_image]
+  have hm := dimH_mono (Set.subset_univ (closedBall (0 : Fin m → ℝ) 1))
+  simpa only [Set.image_univ,Subtype.range_coe_subtype,Set.ofPred_mem_eq,Real.dimH_univ_pi_fin] using hm
+
+/-- Relative cellular approximation implies that a low-dimensional sphere that
+bounds after a high-dimensional attachment already bounded beforehand. -/
+lemma filling_reflected {m : ℕ} (hm : m < n) (b : C(Sphere m,X))
+    (hb : SphereTopology.Extends ((⟨base a,continuous_base a⟩ : C(X,Space a)).comp b)) :
+    SphereTopology.Extends b := by
+  obtain ⟨F,hF⟩ := hb
+  have hdim : dimH (Set.univ : Set (Disk m)) < n :=
+    (dimH_disk_subtype_le m).trans_lt (by exact_mod_cast hm)
+  obtain ⟨g,H,hstat⟩ := exists_deformation_into_base a F hdim
+  refine ⟨g,?_⟩
+  ext x
+  apply (base_closedEmbedding a).injective
+  have hb' : F (SphereTopology.boundary m x) = base a (b x) := ContinuousMap.congr_fun hF x
+  have hh := hstat 1 (SphereTopology.boundary m x) ⟨b x,hb'.symm⟩
+  simpa only [ContinuousMap.Homotopy.apply_one,ContinuousMap.comp_apply,ContinuousMap.coe_mk,hb'] using hh
+
+end
+open Set Metric Topology
+variable {X : Type*} [TopologicalSpace X] [PathConnectedSpace X]
+variable {ι : Type*} {n : ℕ} (a : ι → C(Sphere n,X)) [Nonempty (Sphere n)]
+lemma pathConnectedSpace : PathConnectedSpace (Space a) := by
+  let x₀ : X := Classical.choice inferInstance
+  let s₀ : Sphere n := Classical.choice inferInstance
+  have hj : ∀ z : Space a, Joined (base a x₀) z := by
+    intro z
+    cases z with
+    | inl x => exact (PathConnectedSpace.joined x₀ x).map (continuous_base a)
+    | inr p =>
+      have h : Joined (boundary n s₀) (interior n p.2) := PathConnectedSpace.joined _ _
+      have hh := h.map (cell a p.1).continuous
+      rw [cell_interior,cell_boundary] at hh
+      exact ((PathConnectedSpace.joined x₀ (a p.1 s₀)).map (continuous_base a)).trans hh
+  exact ⟨⟨base a x₀⟩,fun x y => (hj x).symm.trans (hj y)⟩
+end GroupRingTopology.Attachment
+
+namespace GroupRingTopology.Cayley
+open Set Metric Topology Attachment
+universe u
+variable {G : Type u} [Group G] [TopologicalSpace G] [DiscreteTopology G]
+variable {S : Type u} (s : S → G) (rels : Set (FreeGroup S))
+variable (hrel : ∀ r ∈ rels, FreeGroup.lift s r = 1)
+variable (hs : Function.Surjective (FreeGroup.lift s))
+variable (hker : (FreeGroup.lift s).ker = Subgroup.normalClosure rels)
+
+instance presentationCoverT2 : T2Space (PresentationCover s rels hrel) :=
+  t2Space _ (realSeparated _ (realSeparated_of_tychonoff (Y := G)))
+
+instance presentationCoverCW : CWComplex (Set.univ : Set (PresentationCover s rels hrel)) :=
+  layerCW _ (graph_dimension s)
+
+include hs in
+lemma presentationCover_pathConnected : PathConnectedSpace (PresentationCover s rels hrel) := by
+  have hgen : Subgroup.closure (Set.range s) = ⊤ := by
+    rw [←FreeGroup.range_lift_eq_closure,MonoidHom.range_eq_top]
+    exact hs
+  let := graph_pathConnected s hgen
+  let := SphereTopology.sphere_nonempty 1
+  exact Attachment.pathConnectedSpace _
+
+include hs hker in
+lemma presentationCover_sphereFill (b : C(Sphere 2,PresentationCover s rels hrel)) : SphereTopology.Extends b := by
+  let := SphereTopology.sphere_nonempty 1
+  have hdim : dimH (Set.univ : Set (Sphere 2)) < 2 :=
+    (GeneralPosition.dimH_cube_boundary_subtype_le 1).trans_lt (by norm_num)
+  obtain ⟨g,H,_⟩ := exists_deformation_into_base _ b hdim
+  apply SphereTopology.extends_of_homotopy H
+  exact SphereTopology.extends_of_nullhomotopic
+    (((presentationGraphNullhomotopy s rels hrel hs hker).compContinuousMap g).symm)
+
+include hs hker in
+lemma presentationCover_simplyConnected : SimplyConnectedSpace (PresentationCover s rels hrel) := by
+  apply simply_connected_iff_loops_nullhomotopic.mpr
+  refine ⟨presentationCover_pathConnected s rels hrel hs,?_⟩
+  intro x p
+  obtain ⟨F,hF⟩ := presentationCover_sphereFill s rels hrel hs hker (LoopSphere.map p)
+  apply LoopSphere.homotopic_of_fill p F
+  intro z
+  exact ContinuousMap.congr_fun hF z
+end GroupRingTopology.Cayley
+
+namespace GroupRingTopology
+universe u v
+variable {G : Type u} [Group G] {A : Type v} [MulAction G A]
+
+abbrev Orbits := Quotient (MulAction.orbitRel G A)
+
+lemma orbit_mk_smul (g : G) (a : A) : (Quotient.mk'' (g • a) : Orbits (G := G) (A := A)) = Quotient.mk'' a := by
+  apply Quotient.sound
+  exact ⟨g,rfl⟩
+
+lemma orbit_out_translate (a : A) : ∃ g : G, a = g • (Quotient.mk'' a : Orbits (G := G)).out := by
+  have h := Quotient.exact (Quotient.out_eq' (q := (Quotient.mk'' a : Orbits (G := G))))
+  obtain ⟨g,hg⟩ := h
+  refine ⟨g⁻¹,?_⟩
+  rw [←hg,inv_smul_smul]
+
+variable (hfree : ∀ (g : G) (a : A), g • a = a → g = 1)
+
+include hfree in
+lemma orbitCoordinates_bijective : Function.Bijective (fun p : G × Orbits (G := G) (A := A) => p.1 • p.2.out) := by
+  constructor
+  · rintro ⟨g,q⟩ ⟨h,r⟩ he
+    have hqr : q = r := by
+      have hh := congrArg (fun a : A => (Quotient.mk'' a : Orbits (G := G))) he
+      simpa only [orbit_mk_smul,Quotient.out_eq'] using hh
+    subst r
+    change g • q.out = h • q.out at he
+    have hh : (h⁻¹*g) • q.out = q.out := by rw [mul_smul,he,inv_smul_smul]
+    have hh := hfree (h⁻¹*g) q.out hh
+    have hgh : g = h := (inv_mul_eq_one.mp hh).symm
+    exact Prod.ext hgh rfl
+  · intro a
+    obtain ⟨g,hg⟩ := orbit_out_translate (G := G) a
+    exact ⟨(g,Quotient.mk'' a),hg.symm⟩
+
+def orbitCoordinates : (G × Orbits (G := G) (A := A)) ≃ A :=
+  Equiv.ofBijective _ (orbitCoordinates_bijective hfree)
+
+lemma orbitCoordinates_apply (g : G) (q : Orbits (G := G) (A := A)) :
+    orbitCoordinates hfree (g,q) = g • q.out := rfl
+
+end GroupRingTopology
+
+open Set Metric Topology
+namespace GroupRingTopology.Cellular
+universe u
+variable {G : Type u} [Group G] {X : Type u} [TopologicalSpace X]
+  [MulAction G X] [ContinuousConstSMul G X]
+variable [CWComplex (univ : Set X)] {ι : ℕ → Type u}
+variable (σ : ∀ n, (G × ι n) ≃ RelCWComplex.cell (univ : Set X) n)
+
+def actionChart (n : ℕ) (i : G × ι n) : PartialEquiv (Fin n → ℝ) X :=
+  (RelCWComplex.map n (σ n (1,i.2))).trans (Homeomorph.smul i.1).toEquiv.toPartialEquiv
+
+lemma actionChart_apply (n : ℕ) (i : G × ι n) (x : Fin n → ℝ) :
+    actionChart σ n i x = i.1 • RelCWComplex.map n (σ n (1,i.2)) x := rfl
+
+lemma actionChart_image (n : ℕ) (i : G × ι n) (A : Set (Fin n → ℝ)) :
+    actionChart σ n i '' A = (fun x : X => i.1 • x) '' (RelCWComplex.map n (σ n (1,i.2)) '' A) :=
+  Set.image_comp (fun x : X => i.1 • x) (RelCWComplex.map n (σ n (1,i.2))) A
+
+lemma actionChart_source (n : ℕ) (i : G × ι n) :
+    (actionChart σ n i).source = ball 0 1 := by
+  simp [actionChart,PartialEquiv.trans_source,RelCWComplex.source_eq]
+
+lemma actionChart_continuousOn (n : ℕ) (i : G × ι n) :
+    ContinuousOn (actionChart σ n i) (closedBall 0 1) :=
+  (continuous_const_smul i.1).comp_continuousOn (RelCWComplex.continuousOn _ _)
+
+lemma actionChart_continuousOn_symm (n : ℕ) (i : G × ι n) :
+    ContinuousOn (actionChart σ n i).symm (actionChart σ n i).target := by
+  change ContinuousOn (fun y => (RelCWComplex.map n (σ n (1,i.2))).symm (i.1⁻¹ • y))
+    (univ ∩ (fun y : X => i.1⁻¹ • y) ⁻¹' (RelCWComplex.map n (σ n (1,i.2))).target)
+  exact (RelCWComplex.continuousOn_symm _ _).comp (continuous_const_smul _).continuousOn
+    (fun _ h => h.2)
+
+variable
+  (ho : ∀ n (g : G) (i : ι n),
+    (fun x : X => g • x) '' RelCWComplex.openCell n (σ n (1,i)) = RelCWComplex.openCell n (σ n (g,i)))
+  (hc : ∀ n (g : G) (i : ι n),
+    (fun x : X => g • x) '' RelCWComplex.closedCell n (σ n (1,i)) = RelCWComplex.closedCell n (σ n (g,i)))
+
+include ho in
+lemma actionChart_open (n : ℕ) (i : G × ι n) :
+    actionChart σ n i '' ball 0 1 = RelCWComplex.openCell n (σ n i) := by
+  rw [actionChart_image]
+  exact ho n i.1 i.2
+
+include hc in
+lemma actionChart_closed (n : ℕ) (i : G × ι n) :
+    actionChart σ n i '' closedBall 0 1 = RelCWComplex.closedCell n (σ n i) := by
+  rw [actionChart_image]
+  exact hc n i.1 i.2
+
+omit [ContinuousConstSMul G X] in
+include hc in
+lemma closedCell_smul (n : ℕ) (g h : G) (i : ι n) :
+    (fun x : X => g • x) '' RelCWComplex.closedCell n (σ n (h,i)) =
+      RelCWComplex.closedCell n (σ n (g*h,i)) := by
+  rw [←hc n h i,←Set.image_comp]
+  simpa only [Function.comp_def,mul_smul] using hc n (g*h) i
+
+variable [T2Space X]
+
+/-- A free permutation of cell orbits can be made strictly equivariant at the
+level of characteristic maps. This changes neither the space nor the cells. -/
+@[instance_reducible]
+def actionCW : CWComplex (univ : Set X) where
+  cell n := G × ι n
+  map := actionChart σ
+  source_eq := actionChart_source σ
+  continuousOn := actionChart_continuousOn σ
+  continuousOn_symm := actionChart_continuousOn_symm σ
+  pairwiseDisjoint' := by
+    intro p _ q _ hpq
+    change Disjoint (actionChart σ p.1 p.2 '' ball 0 1) (actionChart σ q.1 q.2 '' ball 0 1)
+    rw [actionChart_open σ ho,actionChart_open σ ho]
+    apply CWComplex.disjoint_openCell_of_ne
+    intro he
+    apply hpq
+    cases p with | mk n i =>
+      cases q with | mk m j =>
+        have hnm : n = m := congrArg Sigma.fst he
+        subst m
+        have hij : σ n i = σ n j := (Sigma.mk.inj he).2 |> eq_of_heq
+        exact congrArg (Sigma.mk n) ((σ n).injective hij)
+  mapsTo' := by
+    classical
+    intro n i
+    obtain ⟨I,hI⟩ := CWComplex.cellFrontier_subset_finite_closedCell n (σ n (1,i.2))
+    let f (m : ℕ) (j : RelCWComplex.cell (univ : Set X) m) : G × ι m :=
+      (i.1 * ((σ m).symm j).1,((σ m).symm j).2)
+    refine ⟨fun m => (I m).image (f m),?_⟩
+    intro x hx
+    have h := hI (show RelCWComplex.map n (σ n (1,i.2)) x ∈ RelCWComplex.cellFrontier n (σ n (1,i.2)) from ⟨x,hx,rfl⟩)
+    simp only [Set.mem_iUnion] at h
+    obtain ⟨m,hm,j,hj,hxj⟩ := h
+    refine Set.mem_iUnion.mpr ⟨m,Set.mem_iUnion.mpr ⟨hm,Set.mem_iUnion.mpr
+      ⟨f m j,Set.mem_iUnion.mpr ⟨Finset.mem_image.mpr ⟨j,hj,rfl⟩,?_⟩⟩⟩⟩
+    rw [actionChart_closed σ hc]
+    change i.1 • RelCWComplex.map n (σ n (1,i.2)) x ∈ RelCWComplex.closedCell m
+      (σ m (i.1 * ((σ m).symm j).1,((σ m).symm j).2))
+    rw [←closedCell_smul σ hc]
+    refine ⟨_,?_,rfl⟩
+    simpa only [Prod.eta,Equiv.apply_symm_apply] using hxj
+  closed' := by
+    intro A hA hclosed
+    apply (CWComplex.closed (univ : Set X) A hA).mpr
+    intro n j
+    obtain ⟨i,rfl⟩ := (σ n).surjective j
+    simpa only [actionChart_closed σ hc] using hclosed n i
+  union' := by
+    simp only [actionChart_closed σ hc]
+    have he (n : ℕ) : (⋃ j : G × ι n, RelCWComplex.closedCell n (σ n j)) =
+        ⋃ j : RelCWComplex.cell (univ : Set X) n, RelCWComplex.closedCell n j := by
+      ext x
+      simp only [mem_iUnion]
+      constructor
+      · rintro ⟨j,hj⟩; exact ⟨σ n j,hj⟩
+      · rintro ⟨j,hj⟩; exact ⟨(σ n).symm j,by simpa only [Equiv.apply_symm_apply] using hj⟩
+    simp_rw [he]
+    exact CWComplex.union
+
+omit [T2Space X] in
+lemma actionChart_smul (n : ℕ) (g : G) (i : G × ι n) (x : Fin n → ℝ) :
+    actionChart σ n (g*i.1,i.2) x = g • actionChart σ n i x := by
+  exact mul_smul _ _ _
+end GroupRingTopology.Cellular
+
+namespace GroupRingTopology.Milnor
+open Set Metric Topology GroupRingTopology.Simplicial
+universe u
+variable (G : Type u) [Group G]
+local instance (priority := 2000) (α : Type*) : DecidableEq (ℕ × α) := Classical.decEq (ℕ × α)
+
+lemma vertexTranslate_injective (g : G) : Function.Injective (fun v : ℕ × G => (v.1,g*v.2)) := by
+  rintro ⟨i,a⟩ ⟨j,b⟩ h
+  change (i,g*a) = (j,g*b) at h
+  apply Prod.ext
+  · simpa only using congrArg (fun v : ℕ × G => v.1) h
+  · exact mul_left_cancel (congrArg Prod.snd h)
+
+lemma translate_card (g : G) (s : Finset (ℕ × G)) : (translate g s).card = s.card :=
+  Finset.card_image_of_injective _ (vertexTranslate_injective G g)
+
+abbrev StageCell (S : Shapes G) (n : ℕ) := Simplicial.Cell (stage G S) n
+
+def cellTranslate (S : Shapes G) (n : ℕ) (g : G) (c : StageCell G S n) : StageCell G S n :=
+  ⟨⟨translate g c.1.1,orbitSpan_invariant _ g c.1.2⟩,by rw [translate_card]; exact c.2⟩
+
+instance cellAction (S : Shapes G) (n : ℕ) : MulAction G (StageCell G S n) where
+  smul := cellTranslate G S n
+  one_smul c := by apply Subtype.ext; apply Subtype.ext; exact translate_one _
+  mul_smul g h c := by apply Subtype.ext; apply Subtype.ext; exact (translate_mul _ _ _).symm
+
+lemma cell_smul_val (S : Shapes G) (n : ℕ) (g : G) (c : StageCell G S n) :
+    (g • c).1.1 = translate g c.1.1 := rfl
+
+lemma cellAction_free (S : Shapes G) (n : ℕ) (g : G) (c : StageCell G S n)
+    (h : g • c = c) : g = 1 := by
+  have he : translate g c.1.1 = c.1.1 := congrArg (fun c : StageCell G S n => c.1.1) h
+  obtain ⟨v,hv⟩ := c.1.2.1.1
+  have ht : (v.1,g*v.2) ∈ c.1.1 := he ▸ Finset.mem_image.mpr ⟨v,hv,rfl⟩
+  have heq := c.1.2.1.2 ht hv rfl
+  have hg : g * v.2 = v.2 := congrArg Prod.snd heq
+  exact mul_right_cancel (hg.trans (one_mul _).symm)
+
+abbrev CellOrbits (S : Shapes G) (n : ℕ) := Orbits (G := G) (A := StageCell G S n)
+
+def cellCoordinates (S : Shapes G) (n : ℕ) : (G × CellOrbits G S n) ≃ StageCell G S n :=
+  orbitCoordinates (cellAction_free G S n)
+
+lemma cellCoordinates_apply (S : Shapes G) (n : ℕ) (g : G) (c : CellOrbits G S n) :
+    cellCoordinates G S n (g,c) = g • c.out := rfl
+
+instance cellOrbits_finite (S : Shapes G) (n : ℕ) : Finite (CellOrbits G S n) := by
+  classical
+  obtain ⟨T,hT⟩ := orbitSpan_finite_representatives (basedShapes G S)
+  let R : Set (StageCell G S n) := {c | c.1.1 ∈ T}
+  have hinj : Function.Injective (fun c : StageCell G S n => c.1.1) := by
+    intro c d h; exact Subtype.ext (Subtype.ext h)
+  have hR : R.Finite := T.finite_toSet.preimage hinj.injOn
+  let := hR.fintype
+  apply Finite.of_surjective (fun c : R => (Quotient.mk'' c.1 : CellOrbits G S n))
+  intro q
+  obtain ⟨s,hs,g,hg⟩ := hT q.out.1.1 q.out.1.2
+  let c : StageCell G S n := g⁻¹ • q.out
+  have hc : c ∈ R := by
+    change translate g⁻¹ q.out.1.1 ∈ T
+    rw [hg,translate_mul,inv_mul_cancel,translate_one]
+    exact hs
+  refine ⟨⟨c,hc⟩,?_⟩
+  exact (orbit_mk_smul g⁻¹ q.out).trans (Quotient.out_eq' _)
+
+lemma stage_smul_support (S : Shapes G) (g : G) (x : Stage G S) :
+    (g • x).1.support = translate g x.1.support :=
+  Finsupp.mapDomain_support_of_injective (vertexTranslate_injective G g) _
+
+lemma stage_openCell (S : Shapes G) (n : ℕ) (c : StageCell G S n) :
+    RelCWComplex.openCell (C := (univ : Set (Stage G S))) n c = {x : Stage G S | x.1.support = c.1.1} :=
+  Simplicial.characteristicPE_open _ _
+
+lemma stage_closedCell (S : Shapes G) (n : ℕ) (c : StageCell G S n) :
+    RelCWComplex.closedCell (C := (univ : Set (Stage G S))) n c = {x : Stage G S | x.1.support ⊆ c.1.1} := by
+  change Simplicial.characteristicPE _ c '' closedBall 0 1 = _
+  rw [Simplicial.characteristicPE_closed,Simplicial.range_faceMap]
+
+lemma stage_openCell_smul (S : Shapes G) (n : ℕ) (g : G) (c : StageCell G S n) :
+    (fun x : Stage G S => g • x) '' RelCWComplex.openCell (C := (univ : Set (Stage G S))) n c = RelCWComplex.openCell (C := (univ : Set (Stage G S))) n (g • c) := by
+  rw [stage_openCell,stage_openCell]
+  ext x
+  constructor
+  · rintro ⟨y,hy,rfl⟩
+    change (g • y).1.support = (g • c).1.1
+    rw [stage_smul_support,cell_smul_val,hy]
+  · intro hx
+    refine ⟨g⁻¹ • x,?_,smul_inv_smul _ _⟩
+    change (g⁻¹ • x).1.support = c.1.1
+    change x.1.support = translate g c.1.1 at hx
+    rw [stage_smul_support,hx,translate_mul,inv_mul_cancel,translate_one]
+
+lemma stage_closedCell_smul (S : Shapes G) (n : ℕ) (g : G) (c : StageCell G S n) :
+    (fun x : Stage G S => g • x) '' RelCWComplex.closedCell (C := (univ : Set (Stage G S))) n c = RelCWComplex.closedCell (C := (univ : Set (Stage G S))) n (g • c) := by
+  rw [stage_closedCell,stage_closedCell]
+  ext x
+  constructor
+  · rintro ⟨y,hy,rfl⟩
+    change (g • y).1.support ⊆ (g • c).1.1
+    rw [stage_smul_support,cell_smul_val]
+    exact translate_mono _ hy
+  · intro hx
+    refine ⟨g⁻¹ • x,?_,smul_inv_smul _ _⟩
+    change (g⁻¹ • x).1.support ⊆ c.1.1
+    rw [stage_smul_support]
+    have h := translate_mono g⁻¹ hx
+    simpa only [cell_smul_val,translate_mul,inv_mul_cancel,translate_one] using h
+
+@[instance_reducible]
+def stageEquivariantCW (S : Shapes G) : CWComplex (univ : Set (Stage G S)) :=
+  Cellular.actionCW (cellCoordinates G S)
+    (fun n g i => by
+      change (fun x : Stage G S => g • x) '' RelCWComplex.openCell (C := (univ : Set (Stage G S))) n ((1:G) • i.out) = RelCWComplex.openCell (C := (univ : Set (Stage G S))) n (g • i.out)
+      rw [one_smul]
+      exact stage_openCell_smul G S n g i.out)
+    (fun n g i => by
+      change (fun x : Stage G S => g • x) '' RelCWComplex.closedCell (C := (univ : Set (Stage G S))) n ((1:G) • i.out) = RelCWComplex.closedCell (C := (univ : Set (Stage G S))) n (g • i.out)
+      rw [one_smul]
+      exact stage_closedCell_smul G S n g i.out)
+
+end GroupRingTopology.Milnor
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/GroupRing/AttachmentHEP.lean b/lean/OAI/Algebra/GroupRing/AttachmentHEP.lean
new file mode 100644
index 0000000000000000000000000000000000000000..688984ca9cfe8a9217ecbb761b34d384fa14006a
--- /dev/null
+++ b/lean/OAI/Algebra/GroupRing/AttachmentHEP.lean
@@ -0,0 +1,69 @@
+import Mathlib
+import OAI.Algebra.GroupRing.HomotopyFunctor
+import OAI.Algebra.GroupRing.CellHEP
+
+namespace OAI
+
+
+
+section
+namespace TorsionFreeZeroDivisors.AttachmentHEP
+open Set Metric Topology GroupRingTopology GroupRingTopology.Attachment
+open scoped unitInterval
+noncomputable section
+universe u v w
+variable {X : Type u} {Y : Type v} {J : Type w} [TopologicalSpace X] [TopologicalSpace Y]
+variable {n : ℕ} (a : J→C(Sphere n,X)) (f : C(Space a,Y))
+  (H : C(unitInterval × X,Y)) (h : ∀x,H (0,x)=f (base a x))
+def eval (t : unitInterval) : C(C(unitInterval,Y),Y) := ⟨fun p=>p t,continuous_eval_const t⟩
+def basePaths : C(X,C(unitInterval,Y)) := H.comp ⟨Prod.swap,continuous_swap⟩ |>.curry
+def cellPaths (i : J) : C(Disk n,C(unitInterval,Y)) :=
+  ((CellHEP.extension (f.comp (cell a i))
+    (H.comp ⟨fun z : unitInterval × Sphere n=>(z.1,a i z.2),
+      continuous_fst.prodMk ((a i).continuous.comp continuous_snd)⟩)
+    (fun x=>by change H (0,a i x)=f (cell a i (boundary n x));rw [h,cell_boundary])).comp
+      ⟨Prod.swap,continuous_swap⟩).curry
+lemma cellPaths_boundary (i : J) (x : Sphere n) :
+    cellPaths a f H h i (boundary n x)=basePaths H (a i x) := by
+  apply ContinuousMap.ext
+  intro t
+  dsimp only [cellPaths,basePaths,ContinuousMap.curry_apply,ContinuousMap.comp_apply,ContinuousMap.coe_mk,Prod.swap]
+  change CellHEP.extension _ _ _ (t,Cellular.boundary n x)=_
+  rw [CellHEP.extension_boundary]
+  rfl
+lemma cellPaths_zero (i : J) (d : Disk n) : cellPaths a f H h i d 0=f (cell a i d) := by
+  dsimp only [cellPaths,ContinuousMap.curry_apply,ContinuousMap.comp_apply,ContinuousMap.coe_mk,Prod.swap]
+  rw [CellHEP.extension_zero]
+  rfl
+def paths : C(Space a,C(unitInterval,Y)) :=
+  lift a (basePaths H) (cellPaths a f H h) (cellPaths_boundary a f H h)
+lemma paths_base (x : X) (t : unitInterval) : paths a f H h (base a x) t=H (t,x) := rfl
+lemma paths_zero (x : Space a) : paths a f H h x 0=f x := by
+  have he : (eval 0).comp (paths a f H h)=f := by
+    apply lift_unique a
+    · intro x
+      exact h x
+    · intro i d
+      change paths a f H h (cell a i d) 0=f (cell a i d)
+      rw [paths,lift_cell]
+      exact cellPaths_zero a f H h i d
+  exact ContinuousMap.congr_fun he x
+/-- Homotopy extension for a genuine disk attachment with arbitrarily many
+cells. Currying into the compact-open path space respects the weak topology. -/
+def extend : C(unitInterval × Space a,Y) := (paths a f H h).uncurry.comp ⟨Prod.swap,continuous_swap⟩
+lemma extend_base (t : unitInterval) (x : X) : extend a f H h (t,base a x)=H (t,x) := rfl
+lemma extend_zero (x : Space a) : extend a f H h (0,x)=f x := paths_zero a f H h x
+def endpoint : C(Space a,Y) := (eval 1).comp (paths a f H h)
+def homotopy : f.Homotopy (endpoint a f H h) where
+  toContinuousMap := extend a f H h
+  map_zero_left := extend_zero a f H h
+  map_one_left _ := rfl
+lemma endpoint_base (x : X) : endpoint a f H h (base a x)=H (1,x) := rfl
+end
+end TorsionFreeZeroDivisors.AttachmentHEP
+
+end
+
+
+
+end OAI
diff --git a/lean/OAI/Algebra/GroupRing/BFSTree.lean b/lean/OAI/Algebra/GroupRing/BFSTree.lean
new file mode 100644
index 0000000000000000000000000000000000000000..cd838a466a86af67330ff1c00ee5dcfe03b8c787
--- /dev/null
+++ b/lean/OAI/Algebra/GroupRing/BFSTree.lean
@@ -0,0 +1,426 @@
+import Mathlib
+import OAI.Algebra.GroupRing.ConedMap
+
+namespace OAI
+
+noncomputable section
+
+namespace TorsionFreeZeroDivisors.ConedMap
+open scoped Classical
+open PermutationCycles MapEuler
+variable {O : Type} [Fintype O] (σ α : Equiv.Perm O) (ha : Function.Involutive α)
+local notation "ρ" => rotation σ α
+local notation "π" => pairing α
+local notation "G" => graph σ α ha
+local notation "G'" => graph ρ π (pairing_involutive α ha)
+
+def oldVertex (v : Cycle σ) : Cycle ρ := (vertexEquiv σ α).symm (.inl v)
+def centerVertex (f : Cycle (α*σ)) : Cycle ρ := (vertexEquiv σ α).symm (.inr f)
+lemma oldVertex_injective : Function.Injective (oldVertex σ α) :=
+  (vertexEquiv σ α).symm.injective.comp Sum.inl_injective
+lemma centerVertex_injective : Function.Injective (centerVertex σ α) :=
+  (vertexEquiv σ α).symm.injective.comp Sum.inr_injective
+lemma old_ne_center (v : Cycle σ) (f : Cycle (α*σ)) : oldVertex σ α v≠centerVertex σ α f := by
+  intro he
+  have hh := (vertexEquiv σ α).symm.injective he
+  exact Sum.inl_ne_inr hh
+
+@[simp] lemma oldVertex_cycle (x : O) : oldVertex σ α (cycle σ x)=cycle ρ (old x) := rfl
+@[simp] lemma centerVertex_cycle (x : O) : centerVertex σ α (cycle (α*σ) x)=cycle ρ (center x) := rfl
+
+lemma old_adj {v w : Cycle σ} (he : (G).Adj v w) : (G').Adj (oldVertex σ α v) (oldVertex σ α w) := by
+  obtain ⟨hne,x,hx,hy⟩ := he
+  refine ⟨(oldVertex_injective σ α).ne hne,old x,?_,?_⟩
+  · rw [←oldVertex_cycle,hx]
+  · rw [pairing_old,←oldVertex_cycle,hy]
+
+lemma radial_adj (x : O) : (G').Adj (oldVertex σ α (cycle σ x))
+    (centerVertex σ α (cycle (α*σ) x)) := by
+  refine ⟨old_ne_center σ α _ _,radial x,?_,?_⟩
+  · rw [vertex_radial,oldVertex_cycle]
+  · rw [pairing_radial,centerVertex_cycle]
+
+def oldHom : G →g G' := ⟨oldVertex σ α,fun h=>old_adj σ α ha h⟩
+
+theorem connected (hc : (G).Connected) : (G').Connected := by
+  apply connected_of_component_card_one
+  rw [Nat.card_congr (componentEquiv σ α)]
+  exact component_card_one_of_connected σ α ha hc
+
+lemma old_distance_le (hc : (G).Connected) (v w : Cycle σ) :
+    (G').dist (oldVertex σ α v) (oldVertex σ α w)≤(G).dist v w := by
+  obtain ⟨p,hp⟩ := hc.exists_walk_length_eq_dist v w
+  have hh := (G').dist_le (p.map (oldHom σ α ha))
+  rwa [SimpleGraph.Walk.length_map,hp] at hh
+
+lemma center_distance_le (hc : (G).Connected) (root : Cycle σ) (r : ℕ)
+    (hr : ∀ v,(G).dist root v≤r) (f : Cycle (α*σ)) :
+    (G').dist (oldVertex σ α root) (centerVertex σ α f)≤r+1 := by
+  obtain ⟨x,rfl⟩ := cycle_surjective (α*σ) f
+  have hh := (connected σ α ha hc).dist_triangle
+    (u:=oldVertex σ α root) (v:=oldVertex σ α (cycle σ x))
+    (w:=centerVertex σ α (cycle (α*σ) x))
+  rw [SimpleGraph.dist_eq_one_iff_adj.mpr (radial_adj σ α ha x)] at hh
+  exact hh.trans (Nat.add_le_add_right ((old_distance_le σ α ha hc _ _).trans (hr _)) _)
+
+def oldEmbedding : Cycle σ ↪ Cycle ρ := ⟨oldVertex σ α,oldVertex_injective σ α⟩
+def liftSet (s : Finset (Cycle σ)) : Finset (Cycle ρ) := s.map (oldEmbedding σ α)
+lemma liftSet_card (s : Finset (Cycle σ)) : (liftSet σ α s).card=s.card := Finset.card_map _
+lemma old_mem_liftSet (s : Finset (Cycle σ)) (v : Cycle σ) :
+    oldVertex σ α v∈liftSet σ α s ↔ v∈s := Finset.mem_map' (oldEmbedding σ α)
+lemma center_not_liftSet (s : Finset (Cycle σ)) (f : Cycle (α*σ)) :
+    centerVertex σ α f∉liftSet σ α s := by
+  intro hf
+  obtain ⟨v,_,hv⟩ := Finset.mem_map.mp hf
+  exact old_ne_center σ α v f hv
+
+/-- Distances to zero-cost auxiliary centers incur one extra step, but all
+original vertices remain within the original radius. -/
+theorem distance_cost (hc : (G).Connected) (root : Cycle σ) (r : ℕ)
+    (hr : ∀ v,(G).dist root v≤r) (v : Cycle ρ) :
+    (G').dist (oldVertex σ α root) v + (if v∈liftSet σ α Finset.univ then 1 else 0)≤r+1 := by
+  obtain ⟨q,rfl⟩ := (vertexEquiv σ α).symm.surjective v
+  rcases q with v|f
+  · change (G').dist (oldVertex σ α root) (oldVertex σ α v)+
+      (if oldVertex σ α v∈liftSet σ α Finset.univ then 1 else 0)≤r+1
+    rw [ite_eq_left ((old_mem_liftSet σ α Finset.univ v).mpr (Finset.mem_univ _))]
+    exact Nat.add_le_add_right ((old_distance_le σ α ha hc root v).trans (hr v)) _
+  · change (G').dist (oldVertex σ α root) (centerVertex σ α f)+
+      (if centerVertex σ α f∈liftSet σ α Finset.univ then 1 else 0)≤r+1
+    rw [ite_eq_right (center_not_liftSet σ α Finset.univ f),Nat.add_zero]
+    exact center_distance_le σ α ha hc root r hr f
+
+end TorsionFreeZeroDivisors.ConedMap
+
+/-! A literal breadth-first spanning tree, with its distances and radius
+preserved. This is the rooted tree used in the sharp planar separator. -/
+namespace TorsionFreeZeroDivisors.BFSTree
+open scoped Classical
+open SimpleGraph
+variable {V : Type} (G : SimpleGraph V) (hc : G.Connected) (root : V)
+
+include hc in
+lemma exists_parent (v : V) (hv : v≠root) :
+    ∃ u,G.Adj v u ∧ G.dist u root+1=G.dist v root := by
+  obtain ⟨p,hp⟩ := hc.exists_walk_length_eq_dist v root
+  cases p with
+  | nil => exact (hv rfl).elim
+  | @cons v u root h p =>
+    refine ⟨u,h,?_⟩
+    have h₁ := G.dist_le p
+    have h₂ := hc.dist_triangle (u:=v) (v:=u) (w:=root)
+    rw [G.dist_eq_one_iff_adj.mpr h] at h₂
+    simp only [Walk.length_cons] at hp
+    omega
+
+def parent (v : V) : V := if hv : v=root then root else (exists_parent G hc root v hv).choose
+lemma parent_adj (v : V) (hv : v≠root) : G.Adj v (parent G hc root v) := by
+  rw [parent,dite_eq_right hv]
+  exact (exists_parent G hc root v hv).choose_spec.1
+lemma parent_dist (v : V) (hv : v≠root) :
+    G.dist (parent G hc root v) root+1=G.dist v root := by
+  rw [parent,dite_eq_right hv]
+  exact (exists_parent G hc root v hv).choose_spec.2
+lemma parent_ne (v : V) (hv : v≠root) : parent G hc root v≠v := (parent_adj G hc root v hv).ne'
+
+def tree : SimpleGraph V where
+  Adj v w := (v≠root ∧ parent G hc root v=w) ∨ (w≠root ∧ parent G hc root w=v)
+  symm := ⟨fun _ _ h=>h.elim Or.inr Or.inl⟩
+  loopless := ⟨fun v h=>h.elim (fun h=>parent_ne G hc root v h.1 h.2)
+    (fun h=>parent_ne G hc root v h.1 h.2)⟩
+
+lemma tree_le : tree G hc root≤G := by
+  intro v w h
+  rcases h with ⟨hv,h⟩|⟨hw,h⟩
+  · rw [←h]
+    exact parent_adj G hc root v hv
+  · rw [←h]
+    exact (parent_adj G hc root w hw).symm
+
+lemma exists_tree_walk (v : V) :
+    ∃ p : (tree G hc root).Walk v root,p.length=G.dist v root := by
+  generalize hn : G.dist v root=n
+  induction n using Nat.strong_induction_on generalizing v with
+  | h n ih =>
+    by_cases hv : v=root
+    · subst v
+      exact ⟨Walk.nil,by simp only [Walk.length_nil,dist_self] at hn ⊢; omega⟩
+    · have hp := parent_dist G hc root v hv
+      obtain ⟨p,hl⟩ := ih (G.dist (parent G hc root v) root) (by omega)
+        (parent G hc root v) rfl
+      have he : (tree G hc root).Adj v (parent G hc root v) := Or.inl ⟨hv,rfl⟩
+      exact ⟨Walk.cons he p,by rw [Walk.length_cons,hl];omega⟩
+
+lemma connected : (tree G hc root).Connected := by
+  have : Nonempty V := ⟨root⟩
+  refine ⟨fun v w=>?_⟩
+  obtain ⟨p,_⟩ := exists_tree_walk G hc root v
+  obtain ⟨q,_⟩ := exists_tree_walk G hc root w
+  exact ⟨p.append q.reverse⟩
+
+/-- All root distances are unchanged, not merely bounded by an abstract height. -/
+theorem dist_root (v : V) : (tree G hc root).dist v root=G.dist v root := by
+  apply Nat.le_antisymm
+  · obtain ⟨p,hp⟩ := exists_tree_walk G hc root v
+    rw [←hp]
+    exact (tree G hc root).dist_le p
+  · exact Reachable.dist_anti (tree_le G hc root) ((connected G hc root) v root)
+
+def parentEdge (v : {v : V // v≠root}) : (tree G hc root).edgeSet :=
+  ⟨s(v.val,parent G hc root v.val),Or.inl ⟨v.property,rfl⟩⟩
+lemma parentEdge_surjective : Function.Surjective (parentEdge G hc root) := by
+  rintro ⟨e,he⟩
+  induction e using Sym2.inductionOn with
+  | _ v w =>
+    rcases he with ⟨hv,h⟩|⟨hw,h⟩
+    · refine ⟨⟨v,hv⟩,Subtype.ext ?_⟩
+      change s(v,parent G hc root v)=s(v,w)
+      rw [h]
+    · refine ⟨⟨w,hw⟩,Subtype.ext ?_⟩
+      change s(w,parent G hc root w)=s(v,w)
+      rw [h,Sym2.eq_swap]
+
+variable [Fintype V]
+/-- The parent edges form an actual spanning tree of the original graph. -/
+theorem isTree : (tree G hc root).IsTree := by
+  apply SimpleGraph.isTree_iff_connected_and_card.mpr
+  refine ⟨connected G hc root,?_⟩
+  have hl := Fintype.card_le_of_surjective _ (parentEdge_surjective G hc root)
+  have hr := (connected G hc root).card_vert_le_card_edgeSet_add_one
+  have hcard : Fintype.card {v : V // v≠root}+1=Fintype.card V := by
+    simpa only [Fintype.card_subtype_compl,Fintype.card_unique] using
+      Nat.sub_add_cancel (Fintype.card_pos_iff.mpr ⟨root⟩)
+  rw [←Nat.card_eq_fintype_card,←Nat.card_eq_fintype_card] at hl hcard
+  omega
+
+end TorsionFreeZeroDivisors.BFSTree
+
+namespace TorsionFreeZeroDivisors.TreeCentroid
+open scoped Classical
+open SimpleGraph
+variable {V : Type} [Fintype V] {T : SimpleGraph V} (ht : T.IsTree)
+
+omit [Fintype V] in
+lemma rootPath_cost (budget : Finset V) (root v : V) (r : ℕ)
+    (hr : T.dist root v+(if v∈budget then 1 else 0)≤r+1) :
+    ((rootPath ht root v)∩budget).card≤r+1 := by
+  by_cases hv : v∈budget
+  · have hh := Finset.card_le_card (show rootPath ht root v∩budget⊆rootPath ht root v from Finset.inter_subset_left)
+    rw [rootPath_card] at hh
+    rw [ite_eq_left hv] at hr
+    omega
+  · have hs : rootPath ht root v∩budget⊆(rootPath ht root v).erase v := by
+      intro x hx
+      obtain ⟨hx,hxb⟩ := Finset.mem_inter.mp hx
+      exact Finset.mem_erase.mpr ⟨fun he=>hv (he ▸ hxb),hx⟩
+    have hh := Finset.card_le_card hs
+    rw [Finset.card_erase_of_mem (self_mem_rootPath ht root v),rootPath_card] at hh
+    rw [ite_eq_right hv] at hr
+    omega
+
+omit [Fintype V] in
+/-- Zero-cost face centers may be introduced for triangulation without losing
+the sharp original-vertex bound. Only original vertices are charged. -/
+theorem two_root_paths_cost (budget : Finset V) (root v w : V) (r : ℕ)
+    (hroot : root∈budget)
+    (hv : T.dist root v+(if v∈budget then 1 else 0)≤r+1)
+    (hw : T.dist root w+(if w∈budget then 1 else 0)≤r+1) :
+    ((rootPath ht root v∪rootPath ht root w)∩budget).card≤2*r+1 := by
+  have h₁ := rootPath_cost ht budget root v r hv
+  have h₂ := rootPath_cost ht budget root w r hw
+  have hp : 0<((rootPath ht root v∩budget)∩(rootPath ht root w∩budget)).card :=
+    Finset.card_pos.mpr ⟨root,Finset.mem_inter.mpr
+      ⟨Finset.mem_inter.mpr ⟨root_mem_rootPath ht root v,hroot⟩,
+       Finset.mem_inter.mpr ⟨root_mem_rootPath ht root w,hroot⟩⟩⟩
+  rw [Finset.union_inter_distrib_right]
+  have hh := Finset.card_union_add_card_inter (rootPath ht root v∩budget) (rootPath ht root w∩budget)
+  omega
+
+omit [Fintype V] in
+lemma two_root_paths_cost_erase_root (budget : Finset V) (root v w : V) (r : ℕ)
+    (hroot : root∈budget)
+    (hv : T.dist root v+(if v∈budget then 1 else 0)≤r+1)
+    (hw : T.dist root w+(if w∈budget then 1 else 0)≤r+1) :
+    (((rootPath ht root v∪rootPath ht root w)∩budget).erase root).card≤2*r := by
+  have hc := two_root_paths_cost ht budget root v w r hroot hv hw
+  have hm : root∈(rootPath ht root v∪rootPath ht root w)∩budget :=
+    Finset.mem_inter.mpr ⟨Finset.mem_union_left _ (root_mem_rootPath ht _ _),hroot⟩
+  rw [Finset.card_erase_of_mem hm]
+  omega
+
+end TorsionFreeZeroDivisors.TreeCentroid
+
+namespace TorsionFreeZeroDivisors.MapEuler
+open scoped Classical
+open PermutationCycles
+variable {O : Type} [Fintype O]
+
+/-- The exact bounded-radius separator on a genus-zero rotation map.  The
+partition balances any chosen set of unit-weight vertices.  In particular the
+root is charged once, so deleting a contracted root saves one unit. -/
+theorem radius_separator (σ α : Equiv.Perm O) (ha : Function.Involutive α)
+    (hz : GenusZero σ α) (hc : (graph σ α ha).Connected)
+    (root : Cycle σ) (r : ℕ) (hr : ∀ v,(graph σ α ha).dist root v≤r)
+    (active : Finset (Cycle σ)) :
+    ∃ cut side : Finset (Cycle σ), root∈cut ∧ cut.card≤2*r+1 ∧
+      (cut.erase root).card≤2*r ∧
+      3*(active.filter (fun v=>v∉cut ∧ v∈side)).card≤2*active.card ∧
+      3*(active.filter (fun v=>v∉cut ∧ v∉side)).card≤2*active.card ∧
+      ∀ v w,v∉cut→w∉cut→(graph σ α ha).Adj v w→(v∈side↔w∈side) := by
+  classical
+  let ρ := ConedMap.rotation σ α
+  let π := ConedMap.pairing α
+  have hπ := ConedMap.pairing_involutive α ha
+  let g := graph ρ π hπ
+  have hgc : g.Connected := ConedMap.connected σ α ha hc
+  let e := ConedMap.oldEmbedding σ α
+  let u := e root
+  let T := BFSTree.tree g hgc u
+  have hT : T≤g := BFSTree.tree_le g hgc u
+  have ht : T.IsTree := BFSTree.isTree g hgc u
+  have hz' : GenusZero ρ π := ConedMap.genusZero σ α hz
+  have htri : ∀ c : Cycle (π*ρ),(members (π*ρ) c).card≤3 :=
+    fun c=>(ConedMap.triangular σ α c).le
+  let a := ConedMap.liftSet σ α active
+  obtain ⟨d,h₁,h₂⟩ := triangular_balanced_fundamental ρ π hπ T hT hz' ht a u htri
+  let F := fundamentalVertices ρ π T ht u d
+  let D := cotreeSide ρ π hπ T hT hz' ht d
+  let cut := Finset.univ.filter (fun v=>e v∈F)
+  let side := Finset.univ.filter (fun v=>homeFace ρ π (e v)∈D)
+  have hcut (v : Cycle σ) : v∈cut↔e v∈F := by simp only [cut,Finset.mem_filter,Finset.mem_univ,true_and]
+  have hside (v : Cycle σ) : v∈side↔homeFace ρ π (e v)∈D := by
+    simp only [side,Finset.mem_filter,Finset.mem_univ,true_and]
+  have hroot : root∈cut := (hcut root).mpr (root_mem_fundamentalVertices ρ π T ht u d)
+  let budget : Finset (Cycle ρ) := ConedMap.liftSet σ α Finset.univ
+  have hcost (v : Cycle ρ) : T.dist u v+(if v∈budget then 1 else 0)≤r+1 := by
+    rw [SimpleGraph.dist_comm,BFSTree.dist_root,SimpleGraph.dist_comm]
+    exact ConedMap.distance_cost σ α ha hc root r hr v
+  have hmap : cut.map e=F∩ConedMap.liftSet σ α Finset.univ := by
+    ext v
+    simp only [Finset.mem_map,Finset.mem_inter,ConedMap.liftSet,Finset.mem_univ,true_and]
+    constructor
+    · rintro ⟨x,hx,rfl⟩
+      exact ⟨(hcut x).mp hx,⟨x,rfl⟩⟩
+    · rintro ⟨hv,x,rfl⟩
+      exact ⟨x,(hcut x).mpr hv,rfl⟩
+  have hcard : cut.card≤2*r+1 := by
+    rw [←Finset.card_map (f:=e),hmap]
+    have hh := TreeCentroid.two_root_paths_cost ht budget
+      u (cycle ρ d) (cycle ρ (π d)) r
+      ((ConedMap.old_mem_liftSet σ α Finset.univ root).mpr (Finset.mem_univ _)) (by convert hcost (cycle ρ d) using 1; congr 2) (by convert hcost (cycle ρ (π d)) using 1; congr 2)
+    convert hh using 1
+    congr 1
+    ext v
+    simp only [F,budget,fundamentalVertices,Finset.mem_inter,Finset.mem_union,TreeCentroid.rootPath,List.mem_toFinset]
+  have hfilter (p : Cycle ρ→Prop) [DecidablePred p] :
+      (active.filter (fun v=>p (e v))).card=(a.filter p).card := by
+    rw [←Finset.card_map (f:=e)]
+    congr 1
+    ext v
+    simp only [Finset.mem_map,Finset.mem_filter]
+    constructor
+    · rintro ⟨x,⟨hx,hp⟩,rfl⟩
+      exact ⟨Finset.mem_map.mpr ⟨x,hx,rfl⟩,hp⟩
+    · rintro ⟨hv,hp⟩
+      obtain ⟨x,hx,rfl⟩ := Finset.mem_map.mp hv
+      exact ⟨x,⟨hx,hp⟩,rfl⟩
+  refine ⟨cut,side,hroot,hcard,?_,?_,?_,?_⟩
+  · rw [Finset.card_erase_of_mem hroot]
+    omega
+  · have he : active.filter (fun v=>v∉cut ∧ v∈side)=
+        active.filter (fun v=>e v∉F ∧ homeFace ρ π (e v)∈D) := by
+      ext v
+      simp only [Finset.mem_filter,hcut,hside]
+    rw [he,hfilter (fun v=>v∉F ∧ homeFace ρ π v∈D),←ConedMap.liftSet_card σ α active]
+    exact h₁
+  · have he : active.filter (fun v=>v∉cut ∧ v∉side)=
+        active.filter (fun v=>e v∉F ∧ homeFace ρ π (e v)∉D) := by
+      ext v
+      simp only [Finset.mem_filter,hcut,hside]
+    rw [he,hfilter (fun v=>v∉F ∧ homeFace ρ π v∉D),←ConedMap.liftSet_card σ α active]
+    exact h₂
+  · intro v w hv hw he
+    rw [hside,hside]
+    exact fundamental_no_crossing ρ π hπ T hT hz' ht
+      (fun h=>hv ((hcut v).mpr h)) (fun h=>hw ((hcut w).mpr h))
+      (ConedMap.old_adj σ α ha he) (home_cycle ρ (e v)) (home_cycle ρ (e w))
+
+end TorsionFreeZeroDivisors.MapEuler
+
+namespace TorsionFreeZeroDivisors.MapRestrict
+open scoped Classical
+open PermutationCycles
+variable {O : Type} [Fintype O] (f : Equiv.Perm O) (P : O→Prop) (hf : ∀ x,P (f x)↔P x)
+
+def perm : Equiv.Perm {x // P x} := f.subtypeEquiv (fun x=>(hf x).symm)
+omit [Fintype O] in
+@[simp] lemma perm_val (x : {x // P x}) : (perm f P hf x).val=f x := rfl
+omit [Fintype O] in
+include hf in
+lemma not_invariant (x : O) : (¬P (f x))↔¬P x := not_congr (hf x)
+local notation "fP" => perm f P hf
+local notation "fN" => perm f (fun x=>¬P x) (not_invariant f P hf)
+
+def cycleInclude : Cycle fP→Cycle f :=
+  PermutationCycles.lift fP (fun x=>cycle f x.val) (fun x=>cycle_apply f x.val)
+@[simp] lemma cycleInclude_cycle (x : {x // P x}) : cycleInclude f P hf (cycle fP x)=cycle f x.val := rfl
+
+def cycleRaw (x : O) : Cycle fP ⊕ Cycle fN :=
+  if h:P x then .inl (cycle fP ⟨x,h⟩) else .inr (cycle fN ⟨x,h⟩)
+omit [Fintype O] in
+lemma cycleRaw_apply (x : O) : cycleRaw f P hf (f x)=cycleRaw f P hf x := by
+  by_cases hx : P x
+  · rw [cycleRaw,dite_eq_left ((hf x).mpr hx),cycleRaw,dite_eq_left hx]
+    exact congrArg Sum.inl (cycle_apply fP ⟨x,hx⟩)
+  · rw [cycleRaw,dite_eq_right (fun h=>hx ((hf x).mp h)),cycleRaw,dite_eq_right hx]
+    exact congrArg Sum.inr (cycle_apply fN ⟨x,hx⟩)
+
+def cycleEquiv : Cycle f≃Cycle fP ⊕ Cycle fN where
+  toFun := PermutationCycles.lift f (cycleRaw f P hf) (cycleRaw_apply f P hf)
+  invFun := Sum.elim (cycleInclude f P hf) (cycleInclude f (fun x=>¬P x) (not_invariant f P hf))
+  left_inv := by
+    intro c
+    obtain ⟨x,rfl⟩ := cycle_surjective f c
+    change (Sum.elim _ _) (cycleRaw f P hf x)=cycle f x
+    unfold cycleRaw
+    split_ifs <;> rfl
+  right_inv := by
+    intro c
+    rcases c with c|c
+    · obtain ⟨x,rfl⟩ := cycle_surjective fP c
+      change cycleRaw f P hf x.val=Sum.inl (cycle fP x)
+      rw [cycleRaw,dite_eq_left x.property]
+    · obtain ⟨x,rfl⟩ := cycle_surjective fN c
+      change cycleRaw f P hf x.val=Sum.inr (cycle fN x)
+      rw [cycleRaw,dite_eq_right x.property]
+
+lemma cycle_card : Nat.card (Cycle f)=Nat.card (Cycle fP)+Nat.card (Cycle fN) := by
+  rw [Nat.card_congr (cycleEquiv f P hf),Nat.card_sum]
+omit [Fintype O] in
+lemma perm_involutive (hi : Function.Involutive f) : Function.Involutive fP :=
+  fun x=>Subtype.ext (hi x.val)
+
+def supportEquiv : {x : O // f x≠x} ≃
+    {x : Subtype P // fP x≠x} ⊕ {x : {x // ¬P x} // fN x≠x} where
+  toFun x := if h:P x.val then .inl ⟨⟨x.val,h⟩,fun he=>x.property (congrArg Subtype.val he)⟩
+    else .inr ⟨⟨x.val,h⟩,fun he=>x.property (congrArg Subtype.val he)⟩
+  invFun := Sum.elim (fun x=>⟨x.val.val,fun he=>x.property (Subtype.ext he)⟩)
+    (fun x=>⟨x.val.val,fun he=>x.property (Subtype.ext he)⟩)
+  left_inv := by intro x;dsimp;split_ifs <;> rfl
+  right_inv := by
+    intro x
+    rcases x with x|x
+    · dsimp
+      rw [dite_eq_left x.val.property]
+    · dsimp
+      rw [dite_eq_right x.val.property]
+
+lemma support_card : f.support.card=(fP).support.card+(fN).support.card := by
+  simp only [ConedMap.support_card_nat]
+  rw [Nat.card_congr (supportEquiv f P hf),Nat.card_sum]
+
+end TorsionFreeZeroDivisors.MapRestrict
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/GroupRing/BalancedPieces.lean b/lean/OAI/Algebra/GroupRing/BalancedPieces.lean
new file mode 100644
index 0000000000000000000000000000000000000000..caacd1ce15ea62209b47d78dc2191887d4659fc4
--- /dev/null
+++ b/lean/OAI/Algebra/GroupRing/BalancedPieces.lean
@@ -0,0 +1,382 @@
+import Mathlib
+import OAI.Algebra.GroupRing.ClusterLocalization
+
+namespace OAI
+
+noncomputable section
+
+namespace TorsionFreeZeroDivisors.BalancedPieces
+open scoped Classical BigOperators
+
+def count (h cap : ℕ) : ℕ := (h+cap-1)/cap
+def length (h m : ℕ) (i : Fin m) : ℕ := h/m + if i.val<h%m then 1 else 0
+lemma sum_length (h m : ℕ) (hm : 0 < m) : (∑ i,length h m i)=h := by
+  unfold length
+  rw [Finset.sum_add_distrib]
+  have hi : (∑ i : Fin m,if i.val<h%m then 1 else 0)=h%m := by
+    rw [←Finset.sum_filter]
+    have he : (Finset.univ.filter (fun i : Fin m => i.val<h%m))=Finset.Iio ⟨h%m,Nat.mod_lt _ hm⟩ := by
+      ext i
+      simp [Fin.lt_def]
+    rw [he,Finset.sum_const,Fin.card_Iio,smul_eq_mul,mul_one]
+  rw [hi,Finset.sum_const,Finset.card_univ,Fintype.card_fin,smul_eq_mul]
+  exact Nat.div_add_mod h m
+lemma length_pos (h m : ℕ) (hm : m≤h) (hm0 : 0 < m) (i : Fin m) : 0<length h m i := by
+  have hh : 0<h/m := (Nat.div_pos_iff).mpr ⟨hm0,hm⟩
+  unfold length
+  omega
+lemma count_bounds {h cap : ℕ} (hc : 0<cap) (hh : cap<h) :
+    2≤count h cap ∧ h≤count h cap*cap ∧ (count h cap-1)*cap<h := by
+  have h1 := Nat.div_mul_le_self (h+cap-1) cap
+  have h2 := Nat.lt_div_mul_add (a:=h+cap-1) hc
+  dsimp only [count]
+  have h3 : 2≤(h+cap-1)/cap := by
+    apply (Nat.le_div_iff_mul_le hc).mpr
+    omega
+  constructor
+  · exact h3
+  constructor
+  · omega
+  · rw [Nat.mul_sub_right_distrib]
+    omega
+lemma count_le {h cap : ℕ} (hc : 1≤cap) (hh : cap<h) : count h cap≤h := by
+  have hb := count_bounds (by omega : 0<cap) hh
+  have hm := Nat.mul_le_mul_left (count h cap-1) hc
+  omega
+lemma quotient_bounds {h cap : ℕ} (hc : 6≤cap) (hh : cap<h) :
+    cap≤3*(h/count h cap) ∧ (h/count h cap)+(if h%count h cap=0 then 0 else 1)≤cap := by
+  obtain ⟨hm,hup,hlo⟩ := count_bounds (by omega : 0<cap) hh
+  have hdiv := Nat.div_add_mod h (count h cap)
+  have hrem := Nat.mod_lt h (by omega : 0<count h cap)
+  have hprod : (count h cap-1)*cap=count h cap*cap-cap := by simp only [Nat.mul_sub_right_distrib,one_mul]
+  have hmcap : cap≤count h cap*cap := by nlinarith
+  have hlow' : count h cap*cap-cap<h := by rwa [hprod] at hlo
+  constructor
+  · by_contra hn
+    have hq : 3*(h/count h cap)<cap := by omega
+    have h2 : 2*(h/count h cap+1)≤cap := by omega
+    have h2m := Nat.mul_le_mul_left (count h cap) h2
+    have hmc := Nat.mul_le_mul_right cap hm
+    have hlow'' : count h cap*cap<h+cap := by omega
+    nlinarith only [h2m,hmc,hlow'',hdiv,hrem]
+  · split_ifs with hr
+    · have hq := Nat.div_le_of_le_mul hup
+      simpa using hq
+    · have hrp : 0<h%count h cap := by omega
+      by_contra hn
+      have hq : cap≤h/count h cap := by omega
+      nlinarith
+lemma length_bounds {h cap : ℕ} (hc : 6≤cap) (hh : cap<h) (i : Fin (count h cap)) :
+    cap≤3*length h (count h cap) i ∧ length h (count h cap) i≤cap := by
+  obtain ⟨hl,hu⟩ := quotient_bounds hc hh
+  unfold length
+  constructor
+  · split_ifs <;> omega
+  · by_cases hr : h%count h cap=0
+    · rw [ite_eq_left hr] at hu
+      simp only [hr,Nat.not_lt_zero,ite_false,add_zero]
+      exact hu
+    · rw [ite_eq_right hr] at hu
+      split_ifs <;> omega
+lemma count_charge {h cap : ℕ} (hc : 6≤cap) (hh : cap<h) : count h cap*cap≤3*h := by
+  have hs := sum_length h (count h cap) (by have hb := count_bounds (by omega : 0<cap) hh; omega)
+  have hi : (∑ i : Fin (count h cap),cap)≤∑ i : Fin (count h cap),3*length h (count h cap) i :=
+    Finset.sum_le_sum fun i _ => (length_bounds hc hh i).1
+  simpa only [Finset.sum_const,Finset.card_univ,Fintype.card_fin,smul_eq_mul,←Finset.mul_sum,hs] using hi
+
+def number (h cap : ℕ) : ℕ := if h≤cap then 1 else count h cap
+def sizes (h cap : ℕ) (i : Fin (number h cap)) : ℕ :=
+  if h≤cap then h else length h (number h cap) i
+lemma number_pos {h cap : ℕ} (hc : 0<cap) : 0<number h cap := by
+  by_cases hh : h≤cap
+  · simp only [number,ite_eq_left hh]; omega
+  · have hb := (count_bounds hc (show cap<h by omega)).1
+    simp only [number,ite_eq_right hh]
+    omega
+lemma sizes_sum {h cap : ℕ} (hc : 0<cap) : (∑ i,sizes h cap i)=h := by
+  by_cases hh : h≤cap
+  · have hn : number h cap=1 := ite_eq_left hh
+    simp only [sizes,ite_eq_left hh,Finset.sum_const,Finset.card_univ,Fintype.card_fin,hn,one_smul]
+  · simp only [sizes,ite_eq_right hh]
+    exact sum_length h (number h cap) (number_pos hc)
+lemma sizes_pos {h cap : ℕ} (hc : 0<cap) (hh : 0<h) (i : Fin (number h cap)) : 0<sizes h cap i := by
+  by_cases hle : h≤cap
+  · simpa only [sizes,ite_eq_left hle] using hh
+  · simp only [sizes,ite_eq_right hle]
+    apply length_pos _ _ _ (number_pos hc)
+    simp only [number,ite_eq_right hle]
+    exact count_le hc (by omega)
+lemma sizes_upper {h cap : ℕ} (hc : 6≤cap) (i : Fin (number h cap)) : sizes h cap i≤cap := by
+  by_cases hh : h≤cap
+  · simpa only [sizes,ite_eq_left hh] using hh
+  · simp only [sizes,ite_eq_right hh]
+    have he : number h cap=count h cap := ite_eq_right hh
+    have hb := (length_bounds hc (show cap<h by omega) (Fin.cast he i)).2
+    convert hb using 1
+    unfold length
+    simp only [Fin.val_cast,he]
+lemma sizes_lower_long {h cap : ℕ} (hc : 6≤cap) (hh : cap<h) (i : Fin (number h cap)) :
+    cap≤3*sizes h cap i := by
+  have hn : ¬h≤cap := by omega
+  simp only [sizes,ite_eq_right hn]
+  have hi : number h cap=count h cap := ite_eq_right hn
+  have hb := (length_bounds hc hh (Fin.cast hi i)).1
+  convert hb using 1
+  unfold length
+  simp only [Fin.val_cast,hi]
+lemma number_charge {h cap : ℕ} (hc : 6≤cap) :
+    (if cap<h then number h cap else 0)*cap≤3*h := by
+  by_cases hh : cap<h
+  · simp only [ite_eq_left hh,number,ite_eq_right (show ¬h≤cap by omega)]
+    exact count_charge hc hh
+  · simp only [ite_eq_right hh,Nat.zero_mul,Nat.zero_le]
+lemma sizes_lower {h L U : ℕ} (hU : 3≤U) (hcap : 6≤U*L) (hh : L≤h)
+    (i : Fin (number h (U*L))) : L ≤ sizes h (U*L) i := by
+  by_cases hle : h≤U*L
+  · simpa only [sizes,ite_eq_left hle] using hh
+  · have hb := sizes_lower_long hcap (by omega : U*L<h) i
+    nlinarith
+end TorsionFreeZeroDivisors.BalancedPieces
+namespace TorsionFreeZeroDivisors.ConsecutivePieces
+open scoped Classical BigOperators
+variable {A : Type*} {m : ℕ} (l : List A) (n : Fin m → ℕ) (hs : (∑ i,n i)=l.length)
+
+def index : ((i : Fin m) × Fin (n i)) ≃ Fin l.length := finSigmaFinEquiv.trans (finCongr hs)
+def offset (i : Fin m) : ℕ := ∑ j : Fin i.val,n (Fin.castLE i.isLt.le j)
+lemma index_val (i : Fin m) (j : Fin (n i)) : (index l n hs ⟨i,j⟩).val=offset n i+j.val := by
+  simp only [index,Equiv.trans_apply,finCongr_apply,Fin.val_cast,finSigmaFinEquiv_apply,offset]
+def segment (i : Fin m) : List A := List.ofFn fun j : Fin (n i) => l[index l n hs ⟨i,j⟩]
+lemma length_segment (i : Fin m) : (segment l n hs i).length=n i := List.length_ofFn
+lemma segment_get (i : Fin m) (j : Fin (n i)) :
+    (segment l n hs i)[j.val]'(by rw [length_segment]; exact j.isLt)=l[index l n hs ⟨i,j⟩] := by
+  simp only [segment,List.getElem_ofFn]
+lemma segment_nonempty (i : Fin m) (h : 0<n i) : segment l n hs i≠[] := by
+  intro he
+  have ht := length_segment l n hs i
+  rw [he,List.length_nil] at ht
+  omega
+lemma successor_index (i : Fin m) (j : ℕ) (hj : j+1<n i) :
+    (index l n hs ⟨i,⟨j+1,hj⟩⟩).val=(index l n hs ⟨i,⟨j,by omega⟩⟩).val+1 := by
+  rw [index_val,index_val]
+  change offset n i+(j+1)=offset n i+j+1
+  omega
+lemma segment_chain {R : A → A → Prop} (hp : l.IsChain R) (i : Fin m) :
+    (segment l n hs i).IsChain R := by
+  rw [List.isChain_iff_getElem]
+  intro j hj
+  have hj' : j+1<n i := by simpa only [length_segment] using hj
+  have he := successor_index l n hs i j hj'
+  have hb := (index l n hs ⟨i,⟨j+1,hj'⟩⟩).isLt
+  have hp' := (List.isChain_iff_getElem.mp hp) (index l n hs ⟨i,⟨j,by omega⟩⟩).val (by omega)
+  simp only [segment,List.getElem_ofFn]
+  change R l[(index l n hs ⟨i,⟨j,by omega⟩⟩).val] l[(index l n hs ⟨i,⟨j+1,hj'⟩⟩).val]
+  simpa only [←he] using hp'
+lemma total_length : (∑ i,(segment l n hs i).length)=l.length := by simp only [length_segment,hs]
+
+/-- Every original occurrence is retained exactly once, at its actual index. -/
+lemma occurrence_unique (j : Fin l.length) :
+    ∃! p : (i : Fin m) × Fin (n i),index l n hs p=j := (index l n hs).bijective.existsUnique j
+end TorsionFreeZeroDivisors.ConsecutivePieces
+namespace TorsionFreeZeroDivisors.BalancedWords
+open scoped Classical BigOperators
+variable {T A : Type} (w : T → List A) (cap : ℕ) (hc : 0<cap)
+abbrev Piece := (t : T) × Fin (BalancedPieces.number (w t).length cap)
+def old (p : Piece w cap) : ℕ := BalancedPieces.sizes (w p.1).length cap p.2
+def segment (p : Piece w cap) : List A :=
+  ConsecutivePieces.segment (w p.1) (BalancedPieces.sizes (w p.1).length cap)
+    (BalancedPieces.sizes_sum (h:=(w p.1).length) hc) p.2
+lemma segment_length (p : Piece w cap) : (segment w cap hc p).length=old w cap p :=
+  ConsecutivePieces.length_segment _ _ _ _
+include hc in
+lemma old_pos (hpos : ∀ t,(w t)≠[]) (p : Piece w cap) : 0<old w cap p :=
+  BalancedPieces.sizes_pos hc (List.length_pos_iff.mpr (hpos p.1)) p.2
+lemma segment_nonempty (hpos : ∀ t,(w t)≠[]) (p : Piece w cap) : segment w cap hc p≠[] := by
+  apply List.length_pos_iff.mp
+  rw [segment_length]
+  exact old_pos w cap hc hpos p
+lemma segment_chain {R : A → A → Prop} (h : ∀ t,(w t).IsChain R) (p : Piece w cap) :
+    (segment w cap hc p).IsChain R := ConsecutivePieces.segment_chain _ _ _ (h p.1) p.2
+lemma old_le (hcap : 6≤cap) (p : Piece w cap) : old w cap p≤cap :=
+  BalancedPieces.sizes_upper hcap p.2
+lemma intact (p : Piece w cap) (hp : (w p.1).length≤cap) : segment w cap hc p=w p.1 := by
+  have hi : p.2.val=0 := by
+    have hh := p.2.isLt
+    have hh' : p.2.val<1 := by simpa only [BalancedPieces.number,ite_eq_left hp] using hh
+    omega
+  apply List.ext_getElem
+  · rw [segment_length]
+    simp only [old,BalancedPieces.sizes,ite_eq_left hp]
+  · intro j hj hk
+    have hj' : j<BalancedPieces.sizes (w p.1).length cap p.2 := by simpa only [segment_length,old] using hj
+    simp only [segment,ConsecutivePieces.segment,List.getElem_ofFn,Fin.getElem_fin]
+    congr 1
+    rw [ConsecutivePieces.index_val]
+    have hz : ConsecutivePieces.offset (BalancedPieces.sizes (w p.1).length cap) p.2=0 := by
+      apply Finset.sum_eq_zero
+      intro i _
+      have hilt := i.isLt
+      omega
+    rw [hz,zero_add]
+
+variable [Fintype T]
+include hc in
+lemma old_sum : (∑p : Piece w cap,old w cap p)=∑t,(w t).length := by
+  rw [Fintype.sum_sigma]
+  apply Finset.sum_congr rfl
+  intro t _
+  exact BalancedPieces.sizes_sum (h:=(w t).length) hc
+
+/-- Quantitative closing, before identifying the added positions as fixed.
+Only genuinely split words get closure terms. -/
+lemma closure_charge (tail : Piece w cap → List A) (tailCap : ℕ) (hcap : 6≤cap)
+    (hshort : ∀ p,(w p.1).length≤cap → tail p=[])
+    (htail : ∀ p,(tail p).length≤tailCap) :
+    cap*(∑p,(tail p).length)≤3*tailCap*(∑t,(w t).length) := by
+  rw [Fintype.sum_sigma,Finset.mul_sum,Finset.mul_sum]
+  apply Finset.sum_le_sum
+  intro t _
+  by_cases hs : (w t).length≤cap
+  · have he : ∀ i : Fin (BalancedPieces.number (w t).length cap),tail ⟨t,i⟩=[] := fun i=>hshort ⟨t,i⟩ hs
+    simp only [he,List.length_nil,Finset.sum_const_zero,Nat.mul_zero,Nat.zero_le]
+  · have hsum : (∑i : Fin (BalancedPieces.number (w t).length cap),(tail ⟨t,i⟩).length)≤
+        BalancedPieces.number (w t).length cap*tailCap := by
+      calc
+        _ ≤ ∑_i : Fin (BalancedPieces.number (w t).length cap),tailCap := Finset.sum_le_sum fun i _=>htail ⟨t,i⟩
+        _ = _ := by simp
+    have hcount := BalancedPieces.number_charge (h:= (w t).length) hcap
+    rw [ite_eq_left (show cap<(w t).length by omega)] at hcount
+    have ha := Nat.mul_le_mul_left cap hsum
+    have hb := Nat.mul_le_mul_right tailCap hcount
+    nlinarith
+end TorsionFreeZeroDivisors.BalancedWords
+namespace TorsionFreeZeroDivisors.ShortClosure
+open PortSubdivision WeightedMoore.PortWalk
+variable {V D : Type} (Γ : PortGraph V D)
+lemma endpoint_cons' (a : V) (d : D) (p : List D) :
+    endpoint Γ a (d::p)=endpoint Γ (Γ.origin (Γ.reverse d)) p := by
+  cases p with
+  | nil => rfl
+  | cons e p => simp only [endpoint,List.getLast?_cons,Option.map_some,Option.getD_some]
+
+lemma ReducedPath.exists_walk {a b : V} {p : List D} (hp : ReducedPath Γ a b p) :
+    ∃ q : Γ.Walk a b,q.darts=p := by
+  induction p generalizing a with
+  | nil =>
+    have he : a=b := hp.finish
+    subst b
+    exact ⟨.nil a,rfl⟩
+  | cons d p ih =>
+    have hc := List.isChain_cons.mp hp.chain
+    have ht : ReducedPath Γ (Γ.origin (Γ.reverse d)) b p := {
+      chain := hc.2
+      start := fun e he=>(hc.1 e he).1.symm
+      finish := by rw [←endpoint_cons' Γ a d p]; exact hp.finish }
+    obtain ⟨q,hq⟩ := ih ht
+    exact ⟨.cons d (hp.start d (by simp)) q,by simp only [PortGraph.Walk.darts,hq]⟩
+
+lemma ReducedPath.length_ge {a : V} {p : List D} (hp : ReducedPath Γ a a p)
+    (hn : p≠[]) (L : ℕ) (hg : (3*L:ℕ)≤Γ.subdivision.egirth) : L≤p.length := by
+  obtain ⟨q,hq⟩ := hp.exists_walk Γ
+  have hr : q.IsReduced := by
+    rw [PortGraph.Walk.IsReduced,hq]
+    exact hp.chain.imp (fun _ _ h=>h.2)
+  have hn' : 0<q.length := by rw [←q.length_darts,hq]; exact List.length_pos_iff.mpr hn
+  have hh := TypedGraphs.reduced_circuit_length Γ L hg q hr hn'
+  simpa only [←q.length_darts,hq] using hh
+
+lemma of_cyclic {p : List D} (hn : p≠[])
+    (hch : p.IsChain (step Γ.origin Γ.reverse))
+    (hc : ∀ᵉ (x∈p.getLast?) (y∈p.head?),step Γ.origin Γ.reverse x y) :
+    ReducedPath Γ (Γ.origin (p.head hn)) (Γ.origin (p.head hn)) p where
+  chain := hch
+  start := by
+    intro d hd
+    rw [List.head?_eq_some_head hn] at hd
+    exact congrArg Γ.origin (Option.some.inj hd.symm)
+  finish := by
+    have h := (hc (p.getLast hn) (List.getLast_mem_getLast? hn) (p.head hn) (List.head_mem_head? hn)).1
+    simpa only [endpoint,List.getLast?_eq_some_getLast hn,Option.map_some,Option.getD_some] using h
+end TorsionFreeZeroDivisors.ShortClosure
+namespace TorsionFreeZeroDivisors.SampleGraph.ClosedWords
+open scoped Classical BigOperators
+open GirthAsymptotics ActualPatternEvent TypedGraphs WeightedMoore
+variable {rep : ℕ} {r : Match rep} {x : VA rep} {y : VB rep}
+    (s : PathSystem rep r x y) (cap : ℕ) (hc : 0<cap)
+    (hL : 1≤L (size rep)) (hd : GraphSample.Diameters rep r)
+abbrev Piece := BalancedWords.Piece s.paths cap
+abbrev seg (p : Piece s cap) := BalancedWords.segment s.paths cap hc p
+abbrev seg_ne (p : Piece s cap) : seg s cap hc p≠[] :=
+  BalancedWords.segment_nonempty s.paths cap hc s.nonempty p
+abbrev start (p : Piece s cap) := (graph rep r).origin ((seg s cap hc p).head (seg_ne s cap hc p))
+lemma segment_path (p : Piece s cap) :
+    ShortClosure.ReducedPath (graph rep r) (start s cap hc p)
+      (ShortClosure.endpoint (graph rep r) (start s cap hc p) (seg s cap hc p)) (seg s cap hc p) where
+  chain := BalancedWords.segment_chain s.paths cap hc s.path_chain p
+  start := by
+    intro d hd
+    rw [List.head?_eq_some_head (seg_ne s cap hc p)] at hd
+    exact congrArg (graph rep r).origin (Option.some.inj hd.symm)
+  finish := rfl
+
+abbrev D : ℕ := TypedDiameter.D₀+1608
+
+def chosenTail (p : Piece s cap) : List (DA rep⊕DB rep) :=
+  (SampleGraph.short_closure rep r hL hd (segment_path s cap hc p) (seg_ne s cap hc p)).choose
+lemma chosenTail_spec (p : Piece s cap) :
+    (chosenTail s cap hc hL hd p).length≤ D*L (size rep) ∧
+      ShortClosure.ReducedPath (graph rep r) (start s cap hc p) (start s cap hc p)
+        (seg s cap hc p++chosenTail s cap hc hL hd p) ∧
+      ∀ᵉ (a∈(seg s cap hc p++chosenTail s cap hc hL hd p).getLast?)
+          (b∈(seg s cap hc p++chosenTail s cap hc hL hd p).head?),
+        PortWalk.step (graph rep r).origin (graph rep r).reverse a b :=
+  (SampleGraph.short_closure rep r hL hd (segment_path s cap hc p) (seg_ne s cap hc p)).choose_spec
+
+def tail (p : Piece s cap) : List (DA rep⊕DB rep) :=
+  if (s.paths p.1).length≤cap then [] else chosenTail s cap hc hL hd p
+def word (p : Piece s cap) : List (DA rep⊕DB rep) := seg s cap hc p++tail s cap hc hL hd p
+lemma tail_short (p : Piece s cap) (hp : (s.paths p.1).length≤cap) : tail s cap hc hL hd p=[] := ite_eq_left hp
+lemma tail_bound (p : Piece s cap) : (tail s cap hc hL hd p).length≤D*L (size rep) := by
+  unfold tail
+  split_ifs
+  · simp only [List.length_nil,Nat.zero_le]
+  · exact (chosenTail_spec s cap hc hL hd p).1
+lemma word_short (p : Piece s cap) (hp : (s.paths p.1).length≤cap) : word s cap hc hL hd p=s.paths p.1 := by
+  rw [word,tail_short s cap hc hL hd p hp,List.append_nil]
+  exact BalancedWords.intact s.paths cap hc p hp
+lemma nonempty (p : Piece s cap) : word s cap hc hL hd p≠[] := by
+  intro h
+  exact seg_ne s cap hc p (List.append_eq_nil_iff.mp h).1
+lemma chain (p : Piece s cap) :
+    (word s cap hc hL hd p).IsChain (PortWalk.step (graph rep r).origin (graph rep r).reverse) := by
+  by_cases hp : (s.paths p.1).length≤cap
+  · rw [word_short s cap hc hL hd p hp]
+    exact s.path_chain p.1
+  · simpa only [word,tail,ite_eq_right hp] using (chosenTail_spec s cap hc hL hd p).2.1.chain
+lemma cyclic_of_long (p : Piece s cap) (hp : cap<(s.paths p.1).length) :
+    ∀ᵉ (a∈(word s cap hc hL hd p).getLast?) (b∈(word s cap hc hL hd p).head?),
+      PortWalk.step (graph rep r).origin (graph rep r).reverse a b := by
+  simpa only [word,tail,ite_eq_right (show ¬(s.paths p.1).length≤cap by omega)] using
+    (chosenTail_spec s cap hc hL hd p).2.2
+
+lemma original_girth (hr : r∈samples rep) (t : s.P) (ht : s.root≠some t) : L (size rep)≤(s.paths t).length := by
+  have hc' := s.cyclic_chain t (by simp only [StageRoot.cyclic,decide_eq_true_eq]; exact ht)
+  exact (ShortClosure.of_cyclic (graph rep r) (s.nonempty t) (s.path_chain t) hc').length_ge
+    (graph rep r) (s.nonempty t) (L (size rep)) (girth rep r hr)
+
+lemma old_le_word (p : Piece s cap) : BalancedWords.old s.paths cap p≤(word s cap hc hL hd p).length := by
+  simp only [word,List.length_append,BalancedWords.segment_length]
+  omega
+lemma word_bound (hcap : 6≤cap) (p : Piece s cap) : (word s cap hc hL hd p).length≤cap+D*L (size rep) := by
+  have ho := BalancedWords.old_le s.paths cap hcap p
+  have ht := tail_bound s cap hc hL hd p
+  simp only [word,List.length_append,BalancedWords.segment_length]
+  omega
+lemma total_added (hcap : 6≤cap) : cap*(∑p : Piece s cap,(tail s cap hc hL hd p).length)≤
+    3*(D*L (size rep))*(∑t,(s.paths t).length) :=
+  BalancedWords.closure_charge s.paths cap (tail s cap hc hL hd) (D*L (size rep)) hcap
+    (tail_short s cap hc hL hd) (tail_bound s cap hc hL hd)
+end TorsionFreeZeroDivisors.SampleGraph.ClosedWords
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/GroupRing/BallCount.lean b/lean/OAI/Algebra/GroupRing/BallCount.lean
new file mode 100644
index 0000000000000000000000000000000000000000..bae2f5750202d3dd202ad8200a8eeff6def67a17
--- /dev/null
+++ b/lean/OAI/Algebra/GroupRing/BallCount.lean
@@ -0,0 +1,187 @@
+import Mathlib
+
+namespace OAI
+
+
+
+section
+
+/-!
+The uniform maximum-degree exclusion bound for finite graph balls.
+This treats labelled port graphs too: `neighbors` forgets multiplicities;
+loops and multiple edges only decrease the number of distinct vertices.
+-/
+
+namespace TorsionFreeZeroDivisors.BallCount
+
+open scoped BigOperators
+noncomputable section
+
+variable {V : Type*} [DecidableEq V]
+
+/-- Endpoints of walks of exactly k steps. -/
+def ends (neighbors : V → Finset V) (x : V) : ℕ → Finset V
+  | 0 => {x}
+  | k + 1 => (ends neighbors x k).biUnion neighbors
+
+/-- Finite closed combinatorial ball. -/
+def ball (neighbors : V → Finset V) (x : V) (r : ℕ) : Finset V :=
+  (Finset.range (r + 1)).biUnion (ends neighbors x)
+
+theorem card_ends_le (neighbors : V → Finset V) (d : ℕ)
+    (hd : ∀ v, (neighbors v).card ≤ d) (x : V) (k : ℕ) :
+    (ends neighbors x k).card ≤ d ^ k := by
+  induction k with
+  | zero => simp [ends]
+  | succ k ih =>
+    calc
+      (ends neighbors x (k+1)).card ≤
+          ∑ v ∈ ends neighbors x k, (neighbors v).card := Finset.card_biUnion_le
+      _ ≤ ∑ _v ∈ ends neighbors x k, d := Finset.sum_le_sum fun v _ => hd v
+      _ = (ends neighbors x k).card * d := by simp
+      _ ≤ d^k * d := Nat.mul_le_mul_right d ih
+      _ = d^(k+1) := (pow_succ d k).symm
+
+/-- A non-asymptotic geometric-sum bound. -/
+theorem sum_powers_le (d r : ℕ) (hd : 2 ≤ d) :
+    ∑ k ∈ Finset.range (r+1), d^k ≤ 2 * d^r - 1 := by
+  induction r with
+  | zero => simp
+  | succ r ih =>
+    rw [Finset.sum_range_succ, pow_succ]
+    have hp : 0 < d^r := pow_pos (by omega) _
+    have hm : 2 * d^r ≤ d^r*d := by nlinarith
+    omega
+
+theorem card_ball_le (neighbors : V → Finset V) (d : ℕ) (h2 : 2 ≤ d)
+    (hd : ∀ v, (neighbors v).card ≤ d) (x : V) (r : ℕ) :
+    (ball neighbors x r).card ≤ d^(r+1) := by
+  calc
+    (ball neighbors x r).card ≤ ∑ k ∈ Finset.range (r+1), (ends neighbors x k).card :=
+      Finset.card_biUnion_le
+    _ ≤ ∑ k ∈ Finset.range (r+1), d^k :=
+      Finset.sum_le_sum fun k _ => card_ends_le neighbors d hd x k
+    _ ≤ 2 * d^r - 1 := sum_powers_le d r h2
+    _ ≤ d^(r+1) := by
+      rw [pow_succ]
+      have hm : 2*d^r ≤ d^r*d := by simpa [Nat.mul_comm] using Nat.mul_le_mul_left (d^r) h2
+      omega
+
+@[simp] theorem mem_ball_iff (neighbors : V → Finset V) (x y : V) (r : ℕ) :
+    y ∈ ball neighbors x r ↔ ∃ k ≤ r, y ∈ ends neighbors x k := by
+  simp [ball]
+
+theorem self_mem_ball (neighbors : V → Finset V) (x : V) (r : ℕ) :
+    x ∈ ball neighbors x r := by
+  rw [mem_ball_iff]
+  exact ⟨0,Nat.zero_le _,by simp [ends]⟩
+
+/-- Forgetting parallel edges is sound for the endpoint bound. -/
+theorem port_degree_bound {T : Type*} (outgoing : V → Finset T) (next : V → T → V)
+    (d : ℕ) (hd : ∀ v, (outgoing v).card ≤ d) (v : V) :
+    ((outgoing v).image (next v)).card ≤ d :=
+  (Finset.card_image_le).trans (hd v)
+
+/-- The ordinary finite neighbor set, with its classical finiteness data fixed. -/
+def graphNeighbors [Fintype V] (G : SimpleGraph V) (v : V) : Finset V := by
+  classical
+  exact G.neighborFinset v
+
+omit [DecidableEq V] in
+@[simp] theorem mem_graphNeighbors [Fintype V] (G : SimpleGraph V) (a b : V) :
+    b ∈ graphNeighbors G a ↔ G.Adj a b := by
+  classical
+  simp [graphNeighbors]
+
+omit [DecidableEq V] in
+theorem card_graphNeighbors [Fintype V] (G : SimpleGraph V) (v : V) :
+    (graphNeighbors G v).card = Nat.card (G.neighborSet v) := by
+  classical
+  rw [Nat.card_eq_fintype_card, SimpleGraph.card_neighborSet_eq_degree]
+  exact SimpleGraph.card_neighborFinset_eq_degree G v
+
+/-- The finite combinatorial balls contain all walk endpoints, not just paths. -/
+theorem mem_ends_of_walk [Fintype V] (G : SimpleGraph V) {a b : V} (p : G.Walk a b) :
+    b ∈ ends (graphNeighbors G) a p.length := by
+  classical
+  induction p using SimpleGraph.Walk.concatRec with
+  | Hnil => simp [ends]
+  | @Hconcat a b c p h ih =>
+    simp only [SimpleGraph.Walk.length_concat,ends,Finset.mem_biUnion]
+    exact ⟨b,ih,by simpa using h⟩
+
+theorem mem_ball_of_walk [Fintype V] (G : SimpleGraph V) {a b : V}
+    (p : G.Walk a b) (r : ℕ) (hr : p.length ≤ r) : b ∈ ball (graphNeighbors G) a r := by
+  exact mem_ball_iff _ _ _ _ |>.mpr ⟨p.length,hr,mem_ends_of_walk G p⟩
+
+theorem far_of_not_mem_ball [Fintype V] (G : SimpleGraph V) {a b : V} (r : ℕ)
+    (h : b ∉ ball (graphNeighbors G) a r) (p : G.Walk a b) : r < p.length := by
+  by_contra hn
+  exact h (mem_ball_of_walk G p r (by omega))
+
+section Matchings
+variable {X Y : Type*} [Fintype X] [DecidableEq X]
+
+/-- Removing source and target ports in a bad vertex set discards at most twice
+its cardinality, since each labelled carrier embeds in the vertex set. -/
+theorem matching_bad_card (f : X ≃ Y) (locX : X → V) (locY : Y → V)
+    (hX : Function.Injective locX) (hY : Function.Injective locY) (B : Finset V) :
+    (Finset.univ.filter (fun u => locX u ∈ B ∨ locY (f u) ∈ B)).card ≤ 2 * B.card := by
+  classical
+  have hx : (Finset.univ.filter (fun u => locX u ∈ B)).card ≤ B.card := by
+    apply Finset.card_le_card_of_injOn locX
+    · intro u hu; exact (Finset.mem_filter.mp hu).2
+    · exact hX.injOn
+  have hy : (Finset.univ.filter (fun u => locY (f u) ∈ B)).card ≤ B.card := by
+    apply Finset.card_le_card_of_injOn (fun u => locY (f u))
+    · intro u hu; exact (Finset.mem_filter.mp hu).2
+    · exact (hY.comp f.injective).injOn
+  rw [Finset.filter_or]
+  exact (Finset.card_union_le _ _).trans (by omega)
+
+/-- A labelled matching has uniformly many choices outside both endpoint balls
+and outside a prescribed set. This is the quantitative geometric input to the
+conditioned transposition injection. -/
+theorem admissible_card (f : X ≃ Y) (locX : X → V) (locY : Y → V)
+    (hX : Function.Injective locX) (hY : Function.Injective locY)
+    (neighbors : V → Finset V) (d : ℕ) (h2 : 2 ≤ d)
+    (hd : ∀ v, (neighbors v).card ≤ d) (x y : V) (r : ℕ) (P : Finset X) :
+    Fintype.card X - P.card - 4*d^(r+1) ≤
+      (Finset.univ.filter (fun u => u ∉ P ∧
+        locX u ∉ ball neighbors x r ∪ ball neighbors y r ∧
+        locY (f u) ∉ ball neighbors x r ∪ ball neighbors y r)).card := by
+  classical
+  let B := ball neighbors x r ∪ ball neighbors y r
+  let bad := Finset.univ.filter (fun u => locX u ∈ B ∨ locY (f u) ∈ B)
+  have hb : bad.card ≤ 4*d^(r+1) := by
+    have hb' := matching_bad_card f locX locY hX hY B
+    have hB : B.card ≤ 2*d^(r+1) :=
+      (Finset.card_union_le _ _).trans (by
+        have hx := card_ball_le neighbors d h2 hd x r
+        have hy := card_ball_le neighbors d h2 hd y r
+        omega)
+    exact hb'.trans (by omega)
+  have he : Finset.univ.filter (fun u => u ∉ P ∧ locX u ∉ B ∧ locY (f u) ∉ B) =
+      Finset.univ \ (P ∪ bad) := by
+    ext u
+    simp [bad, not_or]
+  change _ ≤ (Finset.univ.filter (fun u => u ∉ P ∧ locX u ∉ B ∧ locY (f u) ∉ B)).card
+  rw [he,Finset.card_sdiff_of_subset (Finset.subset_univ _),Finset.card_univ]
+  have hu := Finset.card_union_le P bad
+  omega
+
+end Matchings
+end
+end TorsionFreeZeroDivisors.BallCount
+
+
+/-!
+A faithful simple-graph encoding of the manuscript's labelled multigraphs.
+An original edge has two opposite ports, and its threefold subdivision is
+original vertex -- port -- opposite port -- original vertex. Loops become
+triangles and parallel edges remain distinct, so neither is silently discarded.
+-/
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/GroupRing/Basic.lean b/lean/OAI/Algebra/GroupRing/Basic.lean
new file mode 100644
index 0000000000000000000000000000000000000000..19558126b20b8798423d4cb13f7a327563e5b2a6
--- /dev/null
+++ b/lean/OAI/Algebra/GroupRing/Basic.lean
@@ -0,0 +1,42 @@
+import Mathlib
+
+namespace OAI
+
+
+
+namespace TorsionFreeZeroDivisors
+
+/-- Ordinary group torsion-freeness, without requiring uniqueness of all roots. -/
+def TorsionFree (G : Type) [Group G] : Prop :=
+  ∀ (g : G) (n : ℕ), 0 < n → g ^ n = 1 → g = 1
+
+/-- A connected finite Hausdorff 2-dimensional CW K(G,1). -/
+def HasFiniteTwoDimensionalClassifyingSpace (G : Type) [Group G] : Prop :=
+  ∃ (X : Type) (topX : TopologicalSpace X),
+    letI : TopologicalSpace X := topX
+    ∃ (_hausdorff : T2Space X) (_connected : PathConnectedSpace X)
+      (cw : Topology.CWComplex (Set.univ : Set X)),
+      letI : Topology.CWComplex (Set.univ : Set X) := cw
+      Topology.CWComplex.Finite (Set.univ : Set X) ∧
+      (∀ n : ℕ, 2 < n → IsEmpty (Topology.CWComplex.cell (Set.univ : Set X) n)) ∧
+      Nonempty (Topology.CWComplex.cell (Set.univ : Set X) 2) ∧
+      ∃ (x : X), Nonempty (G ≃* FundamentalGroup X x) ∧
+        ∃ (E : Type) (topE : TopologicalSpace E),
+          letI : TopologicalSpace E := topE
+          ContractibleSpace E ∧
+          ∃ p : E → X, IsCoveringMap p ∧ Function.Surjective p
+
+/-- The entire main theorem, including its "Moreover" clause. -/
+def MainTheorem : Prop :=
+  ∃ (G : Type) (inst : Group G),
+    letI : Group G := inst
+    Group.IsFinitelyPresented G ∧ TorsionFree G ∧
+    HasFiniteTwoDimensionalClassifyingSpace G ∧
+    ∃ α β : MonoidAlgebra (ZMod 2) G, α ≠ 0 ∧ β ≠ 0 ∧ α * β = 0
+
+
+end TorsionFreeZeroDivisors
+
+
+
+end OAI
diff --git a/lean/OAI/Algebra/GroupRing/BlockGrid.lean b/lean/OAI/Algebra/GroupRing/BlockGrid.lean
new file mode 100644
index 0000000000000000000000000000000000000000..0fac52ab8f96225380ea60c1507c4812dfbb507f
--- /dev/null
+++ b/lean/OAI/Algebra/GroupRing/BlockGrid.lean
@@ -0,0 +1,360 @@
+import Mathlib
+
+namespace OAI
+
+noncomputable section
+
+namespace TorsionFreeZeroDivisors.BlockGrid
+
+/-- Partition the unit interval into N half-open equal cells. -/
+def cell (N : ℕ) (hN : 0 < N) (x : ℝ) : Fin N :=
+  ⟨⌊(N : ℝ) * Int.fract x⌋₊, by
+    apply (Nat.floor_lt (mul_nonneg (Nat.cast_nonneg _) (Int.fract_nonneg x))).mpr
+    simpa using mul_lt_mul_of_pos_left (Int.fract_lt_one x) (Nat.cast_pos.mpr hN)⟩
+
+theorem same_cell {N : ℕ} (hN : 0 < N) {x y : ℝ} (he : cell N hN x = cell N hN y) :
+    |Int.fract x - Int.fract y| < 1 / (N : ℝ) := by
+  have hf := congrArg Fin.val he
+  dsimp [cell] at hf
+  have hx0 := Nat.floor_le (mul_nonneg (Nat.cast_nonneg N) (Int.fract_nonneg x))
+  have hy0 := Nat.floor_le (mul_nonneg (Nat.cast_nonneg N) (Int.fract_nonneg y))
+  have hx1 := Nat.lt_floor_add_one ((N : ℝ) * Int.fract x)
+  have hy1 := Nat.lt_floor_add_one ((N : ℝ) * Int.fract y)
+  rw [hf] at hx0 hx1
+  have hNr : (0 : ℝ) < N := Nat.cast_pos.mpr hN
+  rw [abs_lt]
+  constructor
+  · apply (neg_lt_iff_pos_add).mpr
+    apply (mul_pos_iff_of_pos_left hNr).mp
+    have hi : (N : ℝ) * (1 / N) = 1 := by field_simp
+    nlinarith
+  · apply (lt_div_iff₀ hNr).mpr
+    nlinarith
+
+/-- Simultaneous approximation in all d coordinates, with the exact
+denominator bound N^d, by the pigeonhole principle. -/
+theorem simultaneous {d N : ℕ} (hN : 0 < N) (a : Fin d → ℝ) :
+    ∃ u : ℕ, 1 ≤ u ∧ u ≤ N ^ d ∧
+      ∃ z : Fin d → ℤ, ∀ i, |(u : ℝ) * a i - (z i : ℝ)| < 1 / (N : ℝ) := by
+  classical
+  let code : Fin (N ^ d + 1) → (Fin d → Fin N) :=
+    fun k i => cell N hN ((k.val : ℝ) * a i)
+  obtain ⟨j, k, hne, he⟩ := Fintype.exists_ne_map_eq_of_card_lt code (by simp)
+  have diff (j k : Fin (N^d+1)) (hjk : j.val < k.val) (he : code j = code k) :
+      ∃ u : ℕ, 1 ≤ u ∧ u ≤ N^d ∧
+        ∃ z : Fin d → ℤ, ∀ i, |(u : ℝ)*a i - (z i : ℝ)| < 1/(N : ℝ) := by
+    refine ⟨k.val-j.val, by omega, by omega,
+      (fun i => ⌊(k.val : ℝ)*a i⌋ - ⌊(j.val : ℝ)*a i⌋), ?_⟩
+    intro i
+    have hi := same_cell hN (congrFun he i).symm
+    have hcast : ((k.val-j.val : ℕ) : ℝ) = (k.val : ℝ) - j.val :=
+      Nat.cast_sub (Nat.le_of_lt hjk)
+    simpa only [code] using (by
+      rw [hcast, Int.cast_sub]
+      convert hi using 1
+      simp only [Int.fract]
+      ring_nf)
+  rcases lt_or_gt_of_ne (Fin.val_injective.ne hne) with hjk | hkj
+  · exact diff j k hjk he
+  · exact diff k j hkj he.symm
+
+/-- Scaling the simultaneous approximation gives the common block
+scale s=L/(uR), with error at most R/N for every prescribed offset. -/
+theorem scale_approximation {d N : ℕ} (hN : 0 < N)
+    (L R : ℝ) (hL : 0 < L) (hR : 0 < R) (offset : Fin d → ℝ) :
+    ∃ u : ℕ, 1 ≤ u ∧ u ≤ N^d ∧
+      ∃ z : Fin d → ℤ,
+        let s := L / ((u : ℝ)*R)
+        0 < s ∧ L / ((N^d : ℕ)*R) ≤ s ∧ s ≤ L/R ∧
+          ∀ i, |offset i / s - R*(z i : ℝ)| < R / N := by
+  obtain ⟨u, hu, hub, z, hz⟩ := simultaneous hN (fun i => offset i / L)
+  have hur : (0 : ℝ) < u := by exact_mod_cast hu
+  have hNr : (0 : ℝ) < N := Nat.cast_pos.mpr hN
+  have hpow : (0 : ℝ) < (N^d : ℕ) := by positivity
+  refine ⟨u,hu,hub,z,?_,?_,?_,?_⟩
+  · exact div_pos hL (mul_pos hur hR)
+  · exact div_le_div_of_nonneg_left hL.le (mul_pos hur hR)
+      (mul_le_mul_of_nonneg_right (by exact_mod_cast hub) hR.le)
+  · apply div_le_div_of_nonneg_left hL.le hR
+    simpa using mul_le_mul_of_nonneg_right (show (1 : ℝ) ≤ u by exact_mod_cast hu) hR.le
+  · intro i
+    have he := mul_lt_mul_of_pos_left (hz i) hR
+    have hscalar : offset i / (L / ((u : ℝ)*R)) - R*(z i : ℝ) =
+        R*((u : ℝ)*(offset i/L) - (z i : ℝ)) := by field_simp
+    rw [hscalar, abs_mul, abs_of_pos hR]
+    simpa [div_eq_mul_inv, mul_assoc] using he
+
+end TorsionFreeZeroDivisors.BlockGrid
+
+/-! Exact half-integer alignment, including the reflection endpoint conventions.
+Uniform deficit bounds converge to zero relative to s
+when |a/s-ν| does; no rounding of the prescribed real grid s is needed. -/
+namespace TorsionFreeZeroDivisors.BlockAlignment
+
+section
+open scoped Classical
+
+/-- Integer edge indices whose half-integer centers belong to a real interval. -/
+def positions (lo hi : ℝ) : Finset ℤ := Finset.Ico ⌈lo-1/2⌉ ⌈hi-1/2⌉
+
+theorem mem_positions {lo hi : ℝ} {q : ℤ} :
+    q ∈ positions lo hi ↔ lo ≤ (q : ℝ)+1/2 ∧ (q : ℝ)+1/2 < hi := by
+  simp only [positions,Finset.mem_Ico,Int.ceil_le,Int.lt_ceil]
+  constructor <;> rintro ⟨h1,h2⟩ <;> constructor <;> linarith
+
+/-- Works even for a reversed/empty real interval. -/
+theorem card_lower (lo hi : ℝ) : hi-lo-1 ≤ ((positions lo hi).card : ℝ) := by
+  have h1 := Int.le_ceil (lo-1/2)
+  have h2 := Int.ceil_lt_add_one (lo-1/2)
+  have h3 := Int.le_ceil (hi-1/2)
+  have h4 : (⌈hi-1/2⌉-⌈lo-1/2⌉ : ℤ) ≤ ((positions lo hi).card : ℤ) := by
+    simp only [positions,Int.card_Ico]
+    exact Int.self_le_toNat _
+  have h5 : ((⌈hi-1/2⌉ : ℤ) : ℝ)-⌈lo-1/2⌉ ≤ ((positions lo hi).card : ℝ) := by exact_mod_cast h4
+  linarith
+
+theorem card_upper {lo hi : ℝ} (hab : lo ≤ hi) :
+    ((positions lo hi).card : ℝ) ≤ hi-lo+1 := by
+  have hc : ⌈lo-1/2⌉ ≤ ⌈hi-1/2⌉ := Int.ceil_mono (by linarith)
+  have he : ((positions lo hi).card : ℤ) = ⌈hi-1/2⌉-⌈lo-1/2⌉ := by
+    simp only [positions,Int.card_Ico]
+    exact Int.toNat_of_nonneg (sub_nonneg.mpr hc)
+  have he' : ((positions lo hi).card : ℝ) = ((⌈hi-1/2⌉ : ℤ) : ℝ)-⌈lo-1/2⌉ := by exact_mod_cast he
+  have h1 := Int.le_ceil (lo-1/2)
+  have h2 := Int.ceil_lt_add_one (hi-1/2)
+  linarith
+
+def block (s : ℝ) (k : ℤ) : Finset ℤ := positions ((k : ℝ)*s) (((k : ℝ)+1)*s)
+
+def affine (reverse : Bool) (a q : ℤ) : ℤ := if reverse then a-1-q else q+a
+
+def partnerIndex (reverse : Bool) (ν k : ℤ) : ℤ := if reverse then ν-k-1 else k+ν
+
+def overlap (s : ℝ) (reverse : Bool) (a k ν : ℤ) : Finset ℤ :=
+  (block s k).filter (fun q => affine reverse a q ∈ block s (partnerIndex reverse ν k))
+
+/-- A central interval survives both translation and reflection. Using one
+extra unit of margin removes the open/closed endpoint distinction. -/
+theorem core_subset (s : ℝ) (reverse : Bool) (a k ν : ℤ) :
+    positions ((k : ℝ)*s+(|a-(ν : ℝ)*s|+1))
+      (((k : ℝ)+1)*s-(|a-(ν : ℝ)*s|+1)) ⊆ overlap s reverse a k ν := by
+  intro q hq
+  obtain ⟨hlo,hhi⟩ := mem_positions.mp hq
+  have ha0 := abs_nonneg ((a : ℝ)-(ν : ℝ)*s)
+  have ha1 := le_abs_self ((a : ℝ)-(ν : ℝ)*s)
+  have ha2 := neg_abs_le ((a : ℝ)-(ν : ℝ)*s)
+  refine Finset.mem_filter.mpr ⟨?_,?_⟩
+  · apply mem_positions.mpr
+    constructor <;> linarith
+  · apply mem_positions.mpr
+    cases reverse <;> simp only [affine,partnerIndex,Bool.false_eq_true,ite_false,ite_true,
+      Int.cast_add,Int.cast_sub,Int.cast_one] <;> constructor <;> nlinarith
+
+/-- An explicit o(s) deficit for the exact grid and signed isometry. -/
+theorem overlap_deficit (s : ℝ) (hs : 0 ≤ s) (reverse : Bool) (a k ν : ℤ) :
+    (((block s k).card - (overlap s reverse a k ν).card : ℕ) : ℝ) ≤
+      2*|a-(ν : ℝ)*s|+4 := by
+  have hlo := card_lower ((k : ℝ)*s+(|a-(ν : ℝ)*s|+1))
+    (((k : ℝ)+1)*s-(|a-(ν : ℝ)*s|+1))
+  have hsub := Finset.card_le_card (core_subset s reverse a k ν)
+  have hsub' : ((positions ((k : ℝ)*s+(|a-(ν : ℝ)*s|+1))
+    (((k : ℝ)+1)*s-(|a-(ν : ℝ)*s|+1))).card : ℝ) ≤ (overlap s reverse a k ν).card := by exact_mod_cast hsub
+  have hhi := card_upper (lo := (k : ℝ)*s) (hi := ((k : ℝ)+1)*s) (by nlinarith)
+  have hcard : (overlap s reverse a k ν).card ≤ (block s k).card :=
+    Finset.card_le_card (Finset.filter_subset _ _)
+  rw [Nat.cast_sub hcard]
+  dsimp [block] at *
+  linarith
+
+/-- An overlap larger than half of its block dominates every disjoint one. -/
+theorem dominant_unique {B D E : Finset ℤ} (hD : D ⊆ B) (hE : E ⊆ B)
+    (hdis : Disjoint D E) (hd : B.card < 2*D.card) (he : B.card < 2*E.card) : False := by
+  have hc : D.card+E.card ≤ B.card := by
+    rw [← Finset.card_union_of_disjoint hdis]
+    exact Finset.card_le_card (Finset.union_subset hD hE)
+  omega
+
+end
+
+open scoped Classical BigOperators
+
+def inverseOffset (reverse : Bool) (a : ℤ) : ℤ := if reverse then a else -a
+
+theorem affine_inverse (reverse : Bool) (a q : ℤ) :
+    affine reverse (inverseOffset reverse a) (affine reverse a q) = q := by
+  cases reverse <;> simp [affine,inverseOffset]
+
+theorem affine_injective (reverse : Bool) (a : ℤ) : Function.Injective (affine reverse a) :=
+  Function.LeftInverse.injective (affine_inverse reverse a)
+
+theorem partner_inverse (reverse : Bool) (ν k : ℤ) :
+    partnerIndex reverse (inverseOffset reverse ν) (partnerIndex reverse ν k) = k := by
+  cases reverse <;> simp [partnerIndex,inverseOffset]; omega
+
+/-- The overlap on the partner block is exactly the image of the first overlap. -/
+def overlapEquiv (s : ℝ) (reverse : Bool) (a k ν : ℤ) :
+    overlap s reverse a k ν ≃
+      overlap s reverse (inverseOffset reverse a) (partnerIndex reverse ν k) (inverseOffset reverse ν) where
+  toFun q := ⟨affine reverse a q.val, by
+    obtain ⟨hq,hp⟩ := Finset.mem_filter.mp q.property
+    apply Finset.mem_filter.mpr
+    exact ⟨hp,by rw [affine_inverse,partner_inverse]; exact hq⟩⟩
+  invFun q := ⟨affine reverse (inverseOffset reverse a) q.val,by
+    obtain ⟨hq,hp⟩ := Finset.mem_filter.mp q.property
+    apply Finset.mem_filter.mpr
+    refine ⟨?_,?_⟩
+    · rwa [partner_inverse] at hp
+    · have he : affine reverse a (affine reverse (inverseOffset reverse a) q.val) = q.val := by
+        cases reverse <;> simp [affine,inverseOffset]
+      rw [he]
+      exact hq⟩
+  left_inv q := Subtype.ext (affine_inverse reverse a q.val)
+  right_inv q := by
+    apply Subtype.ext
+    cases reverse <;> simp [affine,inverseOffset]
+
+theorem block_disjoint (s : ℝ) (hs : 0 < s) {k j : ℤ} (hne : k ≠ j) :
+    Disjoint (block s k) (block s j) := by
+  apply Finset.disjoint_left.mpr
+  intro q hk hj
+  obtain ⟨hk0,hk1⟩ := mem_positions.mp hk
+  obtain ⟨hj0,hj1⟩ := mem_positions.mp hj
+  rcases lt_or_gt_of_ne hne with hkj | hjk
+  · have hh : (k : ℝ)+1 ≤ j := by exact_mod_cast hkj
+    nlinarith
+  · have hh : (j : ℝ)+1 ≤ k := by exact_mod_cast hjk
+    nlinarith
+
+def blockCount (s : ℝ) (ell : ℕ) : ℕ := ⌊(ell : ℝ)/s⌋₊
+
+def tail (s : ℝ) (ell : ℕ) : Finset ℤ := positions ((blockCount s ell : ℝ)*s) ell
+
+theorem count_bound (s : ℝ) (hs : 0 < s) (ell : ℕ) :
+    (blockCount s ell : ℝ)*s ≤ ell ∧ (ell : ℝ) < (blockCount s ell+1)*s := by
+  have h1 := Nat.floor_le (div_nonneg (Nat.cast_nonneg ell) hs.le)
+  have h2 := Nat.lt_floor_add_one ((ell : ℝ)/s)
+  constructor
+  · exact (le_div_iff₀ hs).mp h1
+  · exact (div_lt_iff₀ hs).mp h2
+
+theorem tail_bound (s : ℝ) (hs : 0 < s) (ell : ℕ) :
+    ((tail s ell).card : ℝ) ≤ s+1 := by
+  have he := count_bound s hs ell
+  have hh := card_upper he.1
+  dsimp [tail]
+  linarith
+
+/-- Literal partition into full blocks and the end fragment. -/
+theorem full_or_tail (s : ℝ) (hs : 0 < s) (ell : ℕ) {q : ℤ}
+    (hq : q ∈ positions 0 ell) :
+    (∃ k : Fin (blockCount s ell), q ∈ block s k.val) ∨ q ∈ tail s ell := by
+  obtain ⟨hq0,hq1⟩ := mem_positions.mp hq
+  by_cases he : (q : ℝ)+1/2 < (blockCount s ell : ℝ)*s
+  · let k := ⌊((q : ℝ)+1/2)/s⌋₊
+    have hk : k < blockCount s ell := by
+      apply (Nat.floor_lt (div_nonneg hq0 hs.le)).mpr
+      exact (div_lt_iff₀ hs).mpr he
+    left
+    refine ⟨⟨k,hk⟩,?_⟩
+    apply mem_positions.mpr
+    simp only [Int.cast_natCast]
+    exact ⟨(le_div_iff₀ hs).mp (Nat.floor_le (div_nonneg hq0 hs.le)),
+      (div_lt_iff₀ hs).mp (Nat.lt_floor_add_one (((q : ℝ)+1/2)/s))⟩
+  · right
+    exact mem_positions.mpr ⟨not_lt.mp he,hq1⟩
+
+/-- A full block is entirely within its marked chain. -/
+theorem full_subset (s : ℝ) (hs : 0 < s) (ell : ℕ) (k : Fin (blockCount s ell)) :
+    block s k.val ⊆ positions 0 ell := by
+  intro q hq
+  obtain ⟨hlo,hhi⟩ := mem_positions.mp hq
+  apply mem_positions.mpr
+  have hk : (k.val : ℝ)+1 ≤ blockCount s ell := by exact_mod_cast k.isLt
+  have he := (count_bound s hs ell).1
+  simp only [Int.cast_natCast] at hlo hhi
+  constructor
+  · have hkn : (0 : ℝ) ≤ k.val := Nat.cast_nonneg _
+    nlinarith
+  · nlinarith
+
+/-- A grid block situated inside a comparison with one-block margins has a
+full indicated target block. This includes negative offsets and reflections. -/
+theorem partner_full (s : ℝ) (hs : 0 < s) (reverse : Bool) (a k ν : ℤ)
+    (lo hi ell : ℝ) (herr : |(a : ℝ)-(ν : ℝ)*s| ≤ s)
+    (hlo : lo ≤ (k : ℝ)*s-s) (hhi : ((k : ℝ)+1)*s+s ≤ hi)
+    (htarget : if reverse then 0 ≤ (a : ℝ)-hi ∧ (a : ℝ)-lo ≤ ell
+      else 0 ≤ lo+(a : ℝ) ∧ hi+(a : ℝ) ≤ ell) :
+    0 ≤ partnerIndex reverse ν k ∧ ((partnerIndex reverse ν k : ℤ)+1 : ℝ)*s ≤ ell := by
+  have he1 : (a : ℝ)-(ν : ℝ)*s ≤ s := (le_abs_self _).trans herr
+  have he2 : -s ≤ (a : ℝ)-(ν : ℝ)*s := by
+    have hh := neg_abs_le ((a : ℝ)-(ν : ℝ)*s)
+    linarith
+  cases reverse <;> simp only [Bool.false_eq_true,ite_false,ite_true,partnerIndex,
+    Int.cast_add,Int.cast_sub,Int.cast_one] at htarget ⊢
+  · constructor
+    · have hz : (0 : ℝ) ≤ (k : ℝ)+(ν : ℝ) := by nlinarith [htarget.1]
+      exact_mod_cast hz
+    · nlinarith [htarget.2]
+  · constructor
+    · have hz : (0 : ℝ) ≤ (ν : ℝ)-(k : ℝ)-1 := by nlinarith [htarget.1]
+      exact_mod_cast hz
+    · nlinarith [htarget.2]
+
+theorem inverse_error (reverse : Bool) (a ν : ℤ) (s : ℝ) :
+    |(inverseOffset reverse a : ℝ)-(inverseOffset reverse ν : ℝ)*s| =
+      |(a : ℝ)-(ν : ℝ)*s| := by
+  cases reverse
+  · simp only [inverseOffset,Bool.false_eq_true,ite_false,Int.cast_neg]
+    have he : -(a : ℝ)- -(ν : ℝ)*s = -((a : ℝ)-(ν : ℝ)*s) := by ring
+    rw [he,abs_neg]
+  · rfl
+
+/-- Uniformly bounded exceptional grid indices near one real cut. -/
+def nearCut (s t : ℝ) : Finset ℤ := Finset.Icc ⌈t/s-5⌉ ⌊t/s+5⌋
+
+theorem mem_nearCut (s t : ℝ) (k : ℤ) :
+    k ∈ nearCut s t ↔ |(k : ℝ)-t/s| ≤ 5 := by
+  simp only [nearCut,Finset.mem_Icc,Int.ceil_le,Int.le_floor,abs_le]
+  constructor <;> rintro ⟨h1,h2⟩ <;> constructor <;> linarith
+
+theorem nearCut_card (s t : ℝ) : (nearCut s t).card ≤ 11 := by
+  have h1 := Int.le_ceil (t/s-5)
+  have h2 := Int.floor_le (t/s+5)
+  have hi : ⌊t/s+5⌋+1-⌈t/s-5⌉ ≤ (11 : ℤ) := by
+    have hr : ((⌊t/s+5⌋ : ℤ) : ℝ)+1-⌈t/s-5⌉ ≤ 11 := by linarith
+    exact_mod_cast hr
+  simp only [nearCut,Int.card_Icc]
+  omega
+
+/-- A block containing a compared position and avoiding both endpoint
+neighborhoods is deep inside that exact comparison interval. -/
+theorem margin_of_not_near (s : ℝ) (hs : 0 < s) (lo hi : ℝ) (k q : ℤ)
+    (hq : q ∈ block s k) (hdom : q ∈ positions lo hi)
+    (hnlo : k ∉ nearCut s lo) (hnhi : k ∉ nearCut s hi) :
+    lo ≤ (k : ℝ)*s-s ∧ ((k : ℝ)+1)*s+s ≤ hi := by
+  have hlo := not_le.mp (mt (mem_nearCut s lo k).mpr hnlo)
+  have hhi := not_le.mp (mt (mem_nearCut s hi k).mpr hnhi)
+  obtain ⟨hk0,hk1⟩ := mem_positions.mp hq
+  obtain ⟨hq0,hq1⟩ := mem_positions.mp hdom
+  rcases (lt_abs.mp hlo) with hl | hl
+  · have hz : 5+lo/s < (k : ℝ) := by linarith
+    have hz' := (div_lt_iff₀ hs).mp (show lo/s < (k : ℝ)-5 by linarith)
+    constructor
+    · nlinarith
+    · rcases (lt_abs.mp hhi) with hh | hh
+      · have ht := (div_lt_iff₀ hs).mp (show hi/s < (k : ℝ)-5 by linarith)
+        nlinarith
+      · have ht := (lt_div_iff₀ hs).mp (show (k : ℝ)+5 < hi/s by linarith)
+        nlinarith
+  · have ht := (lt_div_iff₀ hs).mp (show (k : ℝ)+5 < lo/s by linarith)
+    nlinarith
+
+end TorsionFreeZeroDivisors.BlockAlignment
+
+/-! Extraction of the actual partial matching of block occurrences from the
+original comparison pairing. Comparison sides are retained,
+so a block cannot join itself by aggregating several short comparisons. -/
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/GroupRing/BlockPropagation.lean b/lean/OAI/Algebra/GroupRing/BlockPropagation.lean
new file mode 100644
index 0000000000000000000000000000000000000000..0b4d5013c1e9784bc9f38a16216b50aff104cac7
--- /dev/null
+++ b/lean/OAI/Algebra/GroupRing/BlockPropagation.lean
@@ -0,0 +1,371 @@
+import Mathlib
+
+namespace OAI
+
+noncomputable section
+
+namespace TorsionFreeZeroDivisors.BlockPropagation
+
+open scoped BigOperators
+
+structure Skeleton (I : Type*) where
+  root : I
+  parent : I → I
+  rank : I → ℕ
+  decreasing : ∀ i, i ≠ root → rank (parent i) < rank i
+
+/-- A connected comparison graph supplies a decreasing parent system, with
+any chosen block as root (in particular the minimizer of its weight bin). -/
+theorem exists_skeleton {I : Type*} (G : SimpleGraph I) (hc : G.Connected) (r : I) :
+    ∃ S : Skeleton I, S.root = r ∧ ∀ i, i ≠ r → G.Adj i (S.parent i) := by
+  classical
+  have hn (i : I) (hi : i ≠ r) :
+      ∃ j, G.Adj i j ∧ G.dist j r < G.dist i r := by
+    obtain ⟨p, hp⟩ := hc.exists_walk_length_eq_dist i r
+    cases p with
+    | nil => exact False.elim (hi rfl)
+    | @cons a b c hab p =>
+      refine ⟨b, hab, ?_⟩
+      have hle := G.dist_le p
+      simp only [SimpleGraph.Walk.length_cons] at hp
+      omega
+  let parent := fun i => if hi : i = r then r else (hn i hi).choose
+  refine ⟨⟨r, parent, fun i => G.dist i r, ?_⟩, rfl, ?_⟩
+  · intro i hi
+    dsimp [parent]
+    rw [dite_eq_right hi]
+    exact (hn i hi).choose_spec.2
+  · intro i hi
+    dsimp [parent]
+    rw [dite_eq_right hi]
+    exact (hn i hi).choose_spec.1
+
+namespace Skeleton
+
+variable {I T : Type*} (S : Skeleton I) (h : I → ℕ)
+    (known : (i : I) → Finset (Fin (h i)))
+    (determine : (i : I) → Fin (h i) → (Fin (h (S.parent i)) → T) → T)
+
+abbrev Assignment := (i : I) → Fin (h i) → T
+
+def Consistent (w : Assignment h (T := T)) : Prop :=
+  ∀ i, i ≠ S.root → ∀ k ∈ known i, w i k = determine i k (w (S.parent i))
+
+abbrev FreePosition := {p : (i : I) × Fin (h i) // p.1 ≠ S.root ∧ p.2 ∉ known p.1}
+
+/-- The omitted coordinates plus the root word determine every full word. -/
+theorem assignment_ext {w v : Assignment h (T := T)}
+    (hw : S.Consistent h known determine w) (hv : S.Consistent h known determine v)
+    (hroot : w S.root = v S.root)
+    (hfree : ∀ p : S.FreePosition h known, w p.val.1 p.val.2 = v p.val.1 p.val.2) : w = v := by
+  have hall (n : ℕ) : ∀ i, S.rank i = n → w i = v i := by
+    induction n using Nat.strong_induction_on with
+    | h n ih =>
+      intro i hi
+      by_cases hir : i = S.root
+      · subst i
+        exact hroot
+      · funext k
+        by_cases hk : k ∈ known i
+        · rw [hw i hir k hk, hv i hir k hk]
+          have hp : S.rank (S.parent i) < n := hi ▸ S.decreasing i hir
+          rw [ih _ hp (S.parent i) rfl]
+        · exact hfree ⟨⟨i,k⟩,hir,hk⟩
+  funext i
+  exact hall (S.rank i) i rfl
+
+variable [Fintype I] [Fintype T] [DecidableEq I]
+
+/-- Exact number of unrecorded letters after the tree comparisons. -/
+theorem card_freePositions :
+    Nat.card (S.FreePosition h known) =
+      ∑ i : {i : I // i ≠ S.root}, (h i.val - (known i.val).card) := by
+  classical
+  let e : S.FreePosition h known ≃
+      (i : {i : I // i ≠ S.root}) × {k : Fin (h i.val) // k ∉ known i.val} :=
+    { toFun := fun p => ⟨⟨p.val.1,p.property.1⟩,⟨p.val.2,p.property.2⟩⟩
+      invFun := fun p => ⟨⟨p.1.val,p.2.val⟩,p.1.property,p.2.property⟩
+      left_inv := fun _ => rfl
+      right_inv := fun _ => rfl }
+  rw [Nat.card_congr e, Nat.card_eq_fintype_card, Fintype.card_sigma]
+  apply Finset.sum_congr rfl
+  intro i _
+  rw [Fintype.card_subtype_compl, Fintype.card_fin, Fintype.card_coe]
+
+/-- Choose actual root words from R, then at most |T| choices per omitted
+coordinate. The remaining coordinates are forced by the comparisons. -/
+theorem card_assignments (R : Finset (Fin (h S.root) → T)) :
+    Nat.card {w : Assignment h (T := T) //
+      S.Consistent h known determine w ∧ w S.root ∈ R} ≤
+      R.card * (Fintype.card T) ^
+        (∑ i : {i : I // i ≠ S.root}, (h i.val - (known i.val).card)) := by
+  classical
+  let encode : {w : Assignment h (T := T) //
+        S.Consistent h known determine w ∧ w S.root ∈ R} →
+      R × (S.FreePosition h known → T) := fun w =>
+    (⟨w.val S.root,w.property.2⟩,fun p => w.val p.val.1 p.val.2)
+  have henc : Function.Injective encode := by
+    intro w v he
+    apply Subtype.ext
+    apply S.assignment_ext h known determine w.property.1 v.property.1
+    · exact congrArg (fun p => p.1.val) he
+    · intro p
+      exact congrFun (congrArg Prod.snd he) p
+  have hc := Fintype.card_le_of_injective encode henc
+  rw [Fintype.card_prod, Fintype.card_coe, Fintype.card_fun] at hc
+  have he : Fintype.card (S.FreePosition h known) =
+      ∑ i : {i : I // i ≠ S.root}, (h i.val - (known i.val).card) := by
+    simpa only [Nat.card_eq_fintype_card] using S.card_freePositions h known
+  simpa only [Nat.card_eq_fintype_card, he] using hc
+
+end Skeleton
+end TorsionFreeZeroDivisors.BlockPropagation
+
+/-! Label projection along connected substring links.
+A link determines a specified subset of one block from positions in its
+partner word, via a letter equivalence such as identity or inversion.
+No embedding of inactive graph vertices is requested or assumed. -/
+namespace TorsionFreeZeroDivisors.StageLabels
+
+section
+open scoped Classical BigOperators
+open BlockPropagation
+
+variable {I T : Type*} [Fintype I] [Fintype T] [Nonempty T]
+
+/-- A finite directed presentation of substring links. Both directions of
+an actual interval-isometry link may be included; extra constraints only
+reduce the set of feasible strings. -/
+structure Links (h : I → ℕ) where
+  graph : SimpleGraph I
+  known : (i j : I) → Finset (Fin (h i))
+  source : (i j : I) → known i j → Fin (h j)
+  symbol : I → I → (T ≃ T)
+
+namespace Links
+variable {h : I → ℕ} (L : Links (T := T) h)
+
+abbrev Word := (i : I) → Fin (h i) → T
+
+def Consistent (w : Word (T := T) (h := h)) : Prop :=
+  ∀ i j, L.graph.Adj i j → ∀ k : L.known i j,
+    w i k.val = L.symbol i j (w j (L.source i j k))
+
+abbrev RootedWords (r : I) (R : Finset (Fin (h r) → T)) :=
+  {w : Word (T := T) (h := h) // L.Consistent w ∧ w r ∈ R}
+
+/-- Full strings on a connected link component, with a chosen root, are
+bounded by the root choices times one alphabet choice per missing position. -/
+theorem connected_count (hc : L.graph.Connected) (r : I)
+    (R : Finset (Fin (h r) → T)) (e : ℕ)
+    (he : ∀ i j, L.graph.Adj i j → h i - (L.known i j).card ≤ e) :
+    Fintype.card (L.RootedWords r R) ≤
+      R.card * (Fintype.card T)^(e*(Fintype.card I-1)) := by
+  obtain ⟨S,hr,hparent⟩ := exists_skeleton L.graph hc r
+  subst r
+  let known := fun i => L.known i (S.parent i)
+  let determine := fun i (k : Fin (h i)) (w : Fin (h (S.parent i)) → T) =>
+    if hk : k ∈ known i then L.symbol i (S.parent i) (w (L.source i (S.parent i) ⟨k,hk⟩))
+    else Classical.choice (inferInstance : Nonempty T)
+  let forget : L.RootedWords S.root R →
+      {w : Skeleton.Assignment h (T := T) // S.Consistent h known determine w ∧ w S.root ∈ R} :=
+    fun w => ⟨w.val,by
+      constructor
+      · intro i hi k hk
+        dsimp [determine]
+        rw [dite_eq_left hk]
+        exact w.property.1 i (S.parent i) (hparent i hi) ⟨k,hk⟩
+      · exact w.property.2⟩
+  have hf : Function.Injective forget := by
+    intro a b heq
+    apply Subtype.ext
+    exact congrArg (fun q : {w : Skeleton.Assignment h (T := T) //
+      S.Consistent h known determine w ∧ w S.root ∈ R} => q.val) heq
+  have hk : (∑ i : {i : I // i ≠ S.root}, (h i.val - (known i.val).card)) ≤
+      e*(Fintype.card I-1) := by
+    calc
+      _ ≤ ∑ _i : {i : I // i ≠ S.root}, e := Finset.sum_le_sum (fun i _ =>
+        he i.val (S.parent i.val) (hparent i.val i.property))
+      _ = e*(Fintype.card I-1) := by
+        simp only [Finset.sum_const,Finset.card_univ,nsmul_eq_mul,Fintype.card_subtype_compl]
+        have hr : Fintype.card {i : I // i = S.root} = 1 := by simp
+        rw [hr,mul_comm]
+        rfl
+  calc
+    _ ≤ Fintype.card {w : Skeleton.Assignment h (T := T) //
+        S.Consistent h known determine w ∧ w S.root ∈ R} :=
+      Fintype.card_le_of_injective forget hf
+    _ ≤ R.card * (Fintype.card T)^
+        (∑ i : {i : I // i ≠ S.root}, (h i.val - (known i.val).card)) := by
+      simpa only [Nat.card_eq_fintype_card] using S.card_assignments h known determine R
+    _ ≤ _ := Nat.mul_le_mul_left _ (Nat.pow_le_pow_right Fintype.card_pos hk)
+
+end Links
+
+variable {C : Type*} [Fintype C] (color : I → C) (h : I → ℕ)
+
+abbrev Fiber (c : C) := {i : I // color i = c}
+abbrev PieceWord (c : C) := (i : Fiber color c) → Fin (h i.val) → T
+
+def restrictWord (w : (i : I) → Fin (h i) → T) (c : C) : PieceWord (T := T) color h c :=
+  fun i => w i.val
+
+def activeComponents (A : Finset I) : Finset C :=
+  A.image color
+
+def stageWords (A : Finset I) (P : ((i : I) → Fin (h i) → T) → Prop) :
+    Finset ((i : A) → Fin (h i.val) → T) :=
+  (Finset.univ.filter P).image (fun w i => w i.val)
+
+omit [Nonempty T] [Fintype C] in
+/-- Restriction to active blocks is bounded by complete strings only on the
+components they meet. The representative root of a component need not be
+active: the witness is a *string*, not an embedding in a sampled graph. -/
+theorem projection_count (A : Finset I) (P : ((i : I) → Fin (h i) → T) → Prop)
+    (Q : (c : C) → PieceWord (T := T) color h c → Prop)
+    (hQ : ∀ w, P w → ∀ c ∈ activeComponents color A, Q c (restrictWord color h w c)) :
+    (stageWords h A P).card ≤
+      ∏ c : activeComponents color A, Fintype.card {w : PieceWord (T := T) color h c.val // Q c.val w} := by
+  have hs (w : stageWords h A P) :
+      ∃ W : (i : I) → Fin (h i) → T, P W ∧ (fun i : A => W i.val) = w.val := by
+    obtain ⟨W,hW,hw⟩ := Finset.mem_image.mp w.property
+    exact ⟨W,(Finset.mem_filter.mp hW).2,hw⟩
+  let full (w : stageWords h A P) := (hs w).choose
+  have full_spec (w : stageWords h A P) :
+      P (full w) ∧ (fun i : A => full w i.val) = w.val := (hs w).choose_spec
+  let encode (w : stageWords h A P) : (c : activeComponents color A) →
+      {W : PieceWord (T := T) color h c.val // Q c.val W} :=
+    fun c => ⟨restrictWord color h (full w) c.val,hQ _ (full_spec w).1 c.val c.property⟩
+  have he : Function.Injective encode := by
+    intro w v heq
+    apply Subtype.ext
+    funext i
+    let c : activeComponents color A := ⟨color i.val,Finset.mem_image.mpr ⟨i.val,i.property,rfl⟩⟩
+    have h1 := congrFun (congrArg (fun f => (f c).val) heq) (⟨i.val,rfl⟩ : Fiber color c.val)
+    change full w i.val = full v i.val at h1
+    rw [← (congrFun (full_spec w).2 i),← (congrFun (full_spec v).2 i)]
+    exact h1
+  have hc := Fintype.card_le_of_injective encode he
+  simpa only [Fintype.card_coe,Fintype.card_pi] using hc
+
+end
+
+open scoped Classical BigOperators
+variable {I T : Type*} [Fintype I] [Fintype T] [Nonempty T]
+variable {h : I → ℕ} (L : Links (T := T) h)
+
+namespace Links
+
+def component (c : L.graph.ConnectedComponent) : Links (T := T) (fun i : c => h i.val) where
+  graph := c.toSimpleGraph
+  known i j := L.known i.val j.val
+  source i j := L.source i.val j.val
+  symbol i j := L.symbol i.val j.val
+
+omit [Fintype I] [Fintype T] [Nonempty T] in
+theorem restrict_consistent {w : (i : I) → Fin (h i) → T} (hw : L.Consistent w)
+    (c : L.graph.ConnectedComponent) :
+    (L.component c).Consistent (fun i => w i.val) := by
+  intro i j hij k
+  exact hw i.val j.val hij k
+
+/-- Exact local bound on one actual connected component; its root is arbitrary. -/
+theorem component_count (c : L.graph.ConnectedComponent) (r : c)
+    (R : Finset (Fin (h r.val) → T)) (e : ℕ)
+    (he : ∀ i j, L.graph.Adj i j → h i - (L.known i j).card ≤ e) :
+    Fintype.card ((L.component c).RootedWords r R) ≤
+      R.card * (Fintype.card T)^(e*(Fintype.card c-1)) := by
+  have hc : (L.component c).graph.Connected := c.connected_toSimpleGraph
+  have hh := (L.component c).connected_count hc r R e
+    (fun i j hij => he i.val j.val hij)
+  simpa only [← Nat.card_eq_fintype_card] using hh
+
+omit [Fintype T] [Nonempty T] in
+/-- Sum of sizes only over components met by the stage. -/
+theorem active_component_size (A : Finset I) :
+    (∑ c : activeComponents L.graph.connectedComponentMk A, Fintype.card c.val) ≤
+      Fintype.card I := by
+  let f : (c : activeComponents L.graph.connectedComponentMk A) × c.val → I :=
+    fun x => x.2.val
+  have hf : Function.Injective f := by
+    rintro ⟨c,i⟩ ⟨d,j⟩ hij
+    change i.val = j.val at hij
+    have hcd : c = d := Subtype.ext (i.property.symm.trans (hij ▸ j.property))
+    subst d
+    have hi : i = j := Subtype.ext hij
+    subst j
+    rfl
+  simpa only [Fintype.card_sigma] using Fintype.card_le_of_injective f hf
+
+/-- Completing strings on each active link component before projection gives
+an exponential stage bound. No vertices of an inactive chain are embedded. -/
+theorem stage_exp (A : Finset I)
+    (r : (c : L.graph.ConnectedComponent) → c)
+    (R : (c : L.graph.ConnectedComponent) → Finset (Fin (h (r c).val) → T))
+    (P : ((i : I) → Fin (h i) → T) → Prop)
+    (hP : ∀ w, P w → L.Consistent w)
+    (hroot : ∀ w, P w → ∀ c, w (r c).val ∈ R c)
+    (e : ℕ) (he : ∀ i j, L.graph.Adj i j → h i - (L.known i j).card ≤ e)
+    (cost : L.graph.ConnectedComponent → ℝ)
+    (hcost : ∀ c, ((R c).card : ℝ) ≤ Real.exp (cost c)) :
+    ((stageWords h A P).card : ℝ) ≤
+      Real.exp ((∑ c : activeComponents L.graph.connectedComponentMk A, cost c.val) +
+        (e : ℝ) * Fintype.card I * Real.log (Fintype.card T)) := by
+  let C := activeComponents L.graph.connectedComponentMk A
+  have hp : (stageWords h A P).card ≤
+      ∏ c : C, Fintype.card ((L.component c.val).RootedWords (r c.val) (R c.val)) := by
+    have hh := projection_count L.graph.connectedComponentMk h A P
+      (fun c w => (L.component c).Consistent w ∧ w (r c) ∈ R c)
+      (fun w hw c _ => ⟨L.restrict_consistent (hP w hw) c, hroot w hw c⟩)
+    convert hh using 1
+    apply congrArg
+    funext c
+    simp only [← Nat.card_eq_fintype_card]
+    rfl
+  have ha : 0 < (Fintype.card T : ℝ) := by exact_mod_cast Fintype.card_pos
+  have halog : 0 ≤ Real.log (Fintype.card T) := Real.log_nonneg (by exact_mod_cast Fintype.card_pos (α := T))
+  have hcard (c : C) :
+      (Fintype.card ((L.component c.val).RootedWords (r c.val) (R c.val)) : ℝ) ≤
+        Real.exp (cost c.val + (e : ℝ) * Fintype.card c.val * Real.log (Fintype.card T)) := by
+    have hn := L.component_count c.val (r c.val) (R c.val) e he
+    have hn' : (Fintype.card ((L.component c.val).RootedWords (r c.val) (R c.val)) : ℝ) ≤
+        ((R c.val).card : ℝ) * (Fintype.card T : ℝ)^(e*(Fintype.card c.val-1)) := by exact_mod_cast hn
+    calc
+      _ ≤ ((R c.val).card : ℝ) * (Fintype.card T : ℝ)^(e*(Fintype.card c.val-1)) := hn'
+      _ ≤ Real.exp (cost c.val) * (Fintype.card T : ℝ)^(e*(Fintype.card c.val-1)) :=
+        mul_le_mul_of_nonneg_right (hcost _) (pow_nonneg ha.le _)
+      _ = Real.exp (cost c.val + (e*(Fintype.card c.val-1) : ℕ) * Real.log (Fintype.card T)) := by
+        rw [Real.exp_add,Real.exp_nat_mul,Real.exp_log ha]
+      _ ≤ _ := by
+        apply Real.exp_le_exp.mpr
+        apply add_le_add_right
+        apply mul_le_mul_of_nonneg_right _ halog
+        rw [Nat.cast_mul]
+        apply mul_le_mul_of_nonneg_left _ (Nat.cast_nonneg e)
+        exact_mod_cast Nat.sub_le (Fintype.card c.val) 1
+  calc
+    _ ≤ (∏ c : C, (Fintype.card ((L.component c.val).RootedWords (r c.val) (R c.val)) : ℝ)) := by
+      exact_mod_cast hp
+    _ ≤ ∏ c : C, Real.exp (cost c.val + (e : ℝ)*Fintype.card c.val*Real.log (Fintype.card T)) :=
+      Finset.prod_le_prod₀ (fun _ _ => Nat.cast_nonneg _) (fun component _ => hcard component)
+    _ = Real.exp ((∑ c : C, cost c.val) +
+        (e : ℝ)*(∑ c : C, (Fintype.card c.val : ℝ))*Real.log (Fintype.card T)) := by
+      rw [← Real.exp_sum,Finset.sum_add_distrib]
+      congr 1
+      simp only [Finset.mul_sum,Finset.sum_mul]
+    _ ≤ _ := by
+      apply Real.exp_le_exp.mpr
+      apply add_le_add_right
+      apply mul_le_mul_of_nonneg_right _ halog
+      apply mul_le_mul_of_nonneg_left _ (Nat.cast_nonneg e)
+      exact_mod_cast L.active_component_size A
+
+end Links
+end TorsionFreeZeroDivisors.StageLabels
+
+/-! The link constraints are now extracted from the actual occurrence
+matching, rather than supplied as an unexplained propagation hypothesis. -/
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/GroupRing/BoundedSystem.lean b/lean/OAI/Algebra/GroupRing/BoundedSystem.lean
new file mode 100644
index 0000000000000000000000000000000000000000..948e358dbeb5d2908817c5b550b33f55562a4afb
--- /dev/null
+++ b/lean/OAI/Algebra/GroupRing/BoundedSystem.lean
@@ -0,0 +1,499 @@
+import Mathlib
+import OAI.Algebra.GroupRing.SupportedImage
+import OAI.Algebra.GroupRing.WeightedGirth
+
+namespace OAI
+
+noncomputable section
+
+namespace TorsionFreeZeroDivisors.SampleGraph
+open scoped Classical BigOperators
+open PortSubdivision ComparedBlocks ComparisonGeometry GirthAsymptotics TypedGraphs ActualPatternEvent
+attribute [instance] BoundedSystem.fP BoundedSystem.fE
+
+namespace BoundedSystem
+variable {Bnd K I rep : ℕ} {r : Match rep} {x : VA rep} {y : VB rep}
+    (s : BoundedSystem Bnd K I rep r x y)
+def data (hr : r∈samples rep) : AmbientPattern.Data Bnd K I rep where
+  V := VA rep⊕VB rep
+  D := DA rep⊕DB rep
+  P := s.P
+  E := s.E
+  graph := graph rep r
+  side := SumPort.side
+  side_edge := SumPort.side_edge _ _
+  paths := s.paths
+  nonempty := s.nonempty
+  root := s.root
+  path_bound := s.path_bound
+  comparison_bound := s.comparison_bound
+  path_chain := s.path_chain
+  cyclic_chain := s.cyclic_chain
+  girth := weighted_girth rep r hr
+  length_le := s.length_le
+  length_ge := s.length_ge
+  comparisons := s.comparisons
+  lower := s.lower
+  upper := s.upper
+  lower_eq := s.lower_eq
+  upper_eq := s.upper_eq
+  lower_le := s.lower_le
+  upper_le := s.upper_le
+  reduced := s.reduced
+  unpaired_le := s.unpaired_le
+lemma event (hr : r∈samples rep) : (s.data hr).event x y r :=
+  ⟨label rep,label_reverse rep r,immersed rep r,s.compatible,
+    ⟨embeddingA rep r _ x s.rootA⟩,⟨embeddingB rep r _ y s.rootB⟩⟩
+end BoundedSystem
+
+/-- A literal finite typed graph on both sides, simultaneously with diameter,
+large girth, and exclusion of every bounded nearly-paired rooted path system.
+This is an actual-word theorem, not a condition on encoded surrogate patterns. -/
+theorem exists_avoiding (Bnd K I : ℕ) (hK : 0<K) (hI : 0<I) :
+    ∀ᶠ rep in Filter.atTop,∀ (x : VA rep) (y : VB rep),
+      ∃ r∈samples rep,GraphSample.Diameters rep r ∧
+        IsEmpty (BoundedSystem Bnd K I rep r x y) := by
+  filter_upwards [AmbientPattern.with_diameter Bnd K I hK hI] with rep hrep
+  intro x y
+  obtain ⟨r,hr,hd,ha⟩ := hrep x y
+  refine ⟨r,hr,hd,⟨?_⟩⟩
+  intro s
+  exact ha (s.data hr) (s.event hr)
+end TorsionFreeZeroDivisors.SampleGraph
+namespace TorsionFreeZeroDivisors.ShortClosure
+
+section
+open scoped Classical BigOperators
+open PortSubdivision WeightedMoore
+variable {V D : Type} [Fintype V] [Fintype D] (Γ : PortGraph V D)
+    (allowed : D → Prop) (z : V)
+
+/-- Terminal vertex of a literal path, including the empty path at `z`. -/
+def endpoint (l : List D) : V := ((l.getLast?).map (fun d => Γ.origin (Γ.reverse d))).getD z
+
+omit [Fintype V] [Fintype D] in
+lemma endpoint_nil : endpoint Γ z []=z := rfl
+omit [Fintype V] [Fintype D] in
+lemma endpoint_append (l : List D) (d : D) : endpoint Γ z (l++[d])=Γ.origin (Γ.reverse d) := by
+  simp [endpoint]
+
+def choices (l : List D) : Finset D := Finset.univ.filter fun d =>
+  allowed d ∧ Γ.origin d=endpoint Γ z l ∧ ∀ e∈l.getLast?,d≠Γ.reverse e
+
+def walks : ℕ → Finset (List D)
+  | 0 => {[]}
+  | k+1 => (walks k).biUnion (fun l => (choices Γ allowed z l).image (fun d => l++[d]))
+
+omit [Fintype V] in
+lemma mem_walks_succ {k : ℕ} {l : List D} : l∈walks Γ allowed z (k+1) ↔
+    ∃ p∈walks Γ allowed z k,∃ d∈choices Γ allowed z p,l=p++[d] := by
+  simp only [walks,Finset.mem_biUnion,Finset.mem_image]
+  aesop
+
+omit [Fintype V] in
+lemma length_mem {k : ℕ} {l : List D} (hl : l∈walks Γ allowed z k) : l.length=k := by
+  induction k generalizing l with
+  | zero => simpa only [List.length_nil] using congrArg List.length (Finset.mem_singleton.mp hl)
+  | succ k ih =>
+    obtain ⟨p,hp,d,_,rfl⟩ := (mem_walks_succ Γ allowed z).mp hl
+    simp only [List.length_append,List.length_singleton,ih hp]
+
+omit [Fintype V] in
+lemma chain_mem {k : ℕ} {l : List D} (hl : l∈walks Γ allowed z k) :
+    l.IsChain (PortWalk.step Γ.origin Γ.reverse) := by
+  induction k generalizing l with
+  | zero => have := Finset.mem_singleton.mp hl; subst l; simp
+  | succ k ih =>
+    obtain ⟨p,hp,d,hd,rfl⟩ := (mem_walks_succ Γ allowed z).mp hl
+    have hd := (Finset.mem_filter.mp hd).2
+    refine (ih hp).append (by simp) ?_
+    intro e he f hf
+    have hf : f=d := by simpa [eq_comm] using hf
+    subst f
+    refine ⟨?_,hd.2.2 e he⟩
+    have he' : p.getLast?=some e := he
+    simpa only [endpoint,he',Option.map_some,Option.getD_some] using hd.2.1.symm
+
+omit [Fintype V] in
+lemma allowed_mem {k : ℕ} {l : List D} (hl : l∈walks Γ allowed z k) :
+    ∀ d∈l,allowed d := by
+  induction k generalizing l with
+  | zero => have := Finset.mem_singleton.mp hl; subst l; simp
+  | succ k ih =>
+    obtain ⟨p,hp,e,he,rfl⟩ := (mem_walks_succ Γ allowed z).mp hl
+    intro d hd
+    rcases List.mem_append.mp hd with hd | hd
+    · exact ih hp d hd
+    · have hde : d=e := by simpa [eq_comm] using hd
+      subst d
+      exact (Finset.mem_filter.mp he).2.1
+
+omit [Fintype V] in
+lemma head_mem {k : ℕ} {l : List D} (hl : l∈walks Γ allowed z k) :
+    ∀ d∈l.head?,Γ.origin d=z := by
+  induction k generalizing l with
+  | zero => have := Finset.mem_singleton.mp hl; subst l; simp
+  | succ k ih =>
+    obtain ⟨p,hp,e,he,rfl⟩ := (mem_walks_succ Γ allowed z).mp hl
+    intro d hd
+    cases p with
+    | nil =>
+      have hde : d=e := by simpa [eq_comm] using hd
+      subst d
+      exact (Finset.mem_filter.mp he).2.2.1
+    | cons f p =>
+      have hdf : d=f := by simpa [eq_comm] using hd
+      subst d
+      exact ih hp f (by simp)
+
+omit [Fintype V] in
+lemma choices_card (l : List D) (hdeg : ∀ v,3≤(Finset.univ.filter (fun d => allowed d ∧ Γ.origin d=v)).card) :
+    2≤(choices Γ allowed z l).card := by
+  let s := Finset.univ.filter (fun d => allowed d ∧ Γ.origin d=endpoint Γ z l)
+  cases he : l.getLast? with
+  | none =>
+    have hh : choices Γ allowed z l=s := by ext d; simp [choices,s,he]
+    rw [hh]
+    exact (by omega : 2≤3).trans (hdeg _)
+  | some e =>
+    have hh : choices Γ allowed z l=s.erase (Γ.reverse e) := by
+      ext d
+      simp only [choices,s,Finset.mem_filter,Finset.mem_univ,true_and,he,
+        Option.mem_some_iff,Finset.mem_erase]
+      constructor
+      · rintro ⟨ha,ho,hh⟩
+        exact ⟨hh e rfl,ha,ho⟩
+      · rintro ⟨hh,ha,ho⟩
+        exact ⟨ha,ho,fun f hf => hf ▸ hh⟩
+    rw [hh]
+    have hc3 : s.card ≤ (s.erase (Γ.reverse e)).card+1 := by
+      calc
+        _ ≤ (insert (Γ.reverse e) (s.erase (Γ.reverse e))).card := Finset.card_le_card (by intro d hd; by_cases h : d=Γ.reverse e <;> simp_all)
+        _ ≤ _ := Finset.card_insert_le _ _
+    have hc' := hdeg (endpoint Γ z l)
+    change 3 ≤ s.card at hc'
+    omega
+
+omit [Fintype V] in
+lemma card_walks_succ (k : ℕ) (hdeg : ∀ v,3≤(Finset.univ.filter (fun d => allowed d ∧ Γ.origin d=v)).card) :
+    2*(walks Γ allowed z k).card≤(walks Γ allowed z (k+1)).card := by
+  rw [walks,Finset.card_biUnion]
+  · calc
+      _ = ∑ _l∈walks Γ allowed z k,2 := by simp [Nat.mul_comm]
+      _ ≤ _ := by
+        apply Finset.sum_le_sum
+        intro l _
+        rw [Finset.card_image_of_injective _ (by intro d e h; simpa using (List.append_cancel_left h))]
+        exact choices_card Γ allowed z l hdeg
+  · intro p hp q hq hpq
+    apply Finset.disjoint_left.mpr
+    intro l hl hl'
+    obtain ⟨d,_,hd⟩ := Finset.mem_image.mp hl
+    obtain ⟨e,_,he⟩ := Finset.mem_image.mp hl'
+    have hh := List.append_inj (hd.trans he.symm) ((length_mem Γ allowed z hp).trans (length_mem Γ allowed z hq).symm)
+    exact hpq hh.1
+
+omit [Fintype V] in
+lemma card_walks (k : ℕ) (hdeg : ∀ v,3≤(Finset.univ.filter (fun d => allowed d ∧ Γ.origin d=v)).card) :
+    2^k≤(walks Γ allowed z k).card := by
+  induction k with
+  | zero => simp [walks]
+  | succ k ih =>
+    calc
+      _ = 2*2^k := by rw [pow_succ]; omega
+      _ ≤ 2*(walks Γ allowed z k).card := Nat.mul_le_mul_left 2 ih
+      _ ≤ _ := card_walks_succ Γ allowed z k hdeg
+ 
+/-- Collision of equal-length nonbacktracking paths, before any cancellation. -/
+def Collision (k : ℕ) : Prop :=
+  ∃ p∈walks Γ allowed z k,∃ q∈walks Γ allowed z k,p≠q ∧ endpoint Γ z p=endpoint Γ z q
+
+lemma collision_exists (k : ℕ) (hk : Fintype.card V<2^k)
+    (hdeg : ∀ v,3≤(Finset.univ.filter (fun d => allowed d ∧ Γ.origin d=v)).card) :
+    Collision Γ allowed z k := by
+  apply Finset.exists_ne_map_eq_of_card_lt_of_maps_to
+    (t:=Finset.univ) (f:=endpoint Γ z)
+  · simpa only [Finset.card_univ] using hk.trans_le (card_walks Γ allowed z k hdeg)
+  · intro p _
+    exact Finset.mem_univ _
+
+omit [Fintype V] [Fintype D] in
+lemma chain_reverse {l : List D} (hl : l.IsChain (PortWalk.step Γ.origin Γ.reverse)) :
+    (l.reverse.map Γ.reverse).IsChain (PortWalk.step Γ.origin Γ.reverse) := by
+  rw [List.isChain_map,List.isChain_reverse]
+  apply hl.imp
+  intro a b hab
+  refine ⟨?_,?_⟩
+  · simpa only [PortWalk.step,PortGraph.reverse_reverse_apply] using hab.1.symm
+  · intro hh
+    apply hab.2
+    simpa only [PortGraph.reverse_reverse_apply] using hh.symm
+
+/-- A based reduced loop with excluded darts never used. No cyclic reduction at
+its base is asserted or needed. Least collision length avoids common suffixes. -/
+theorem based_loop (k : ℕ) (hk : Fintype.card V<2^k)
+    (hdeg : ∀ v,3≤(Finset.univ.filter (fun d => allowed d ∧ Γ.origin d=v)).card)
+    (hsymm : ∀ d,allowed d → allowed (Γ.reverse d)) :
+    ∃ l : List D,l≠[] ∧ l.length≤2*k ∧
+      l.IsChain (PortWalk.step Γ.origin Γ.reverse) ∧
+      (∀ d∈l,allowed d) ∧ (∀ d∈l.head?,Γ.origin d=z) ∧ endpoint Γ z l=z := by
+  have H : ∃ m,Collision Γ allowed z m := ⟨k,collision_exists Γ allowed z k hk hdeg⟩
+  let m := Nat.find H
+  have hmle : m≤k := Nat.find_min' H (collision_exists Γ allowed z k hk hdeg)
+  obtain ⟨p,hp,q,hq,hpq,hep⟩ := Nat.find_spec H
+  have hmpos : 0 < m := by
+    by_contra hn
+    have hm0 : m=0 := by omega
+    change p∈walks Γ allowed z m at hp
+    change q∈walks Γ allowed z m at hq
+    rw [hm0] at hp hq
+    exact hpq ((Finset.mem_singleton.mp hp).trans (Finset.mem_singleton.mp hq).symm)
+  obtain ⟨j,hj⟩ := Nat.exists_eq_succ_of_ne_zero (Nat.ne_of_gt hmpos)
+  change p∈walks Γ allowed z m at hp
+  change q∈walks Γ allowed z m at hq
+  rw [hj] at hp hq
+  obtain ⟨p',hp',d,hd,hpd⟩ := (mem_walks_succ Γ allowed z).mp hp
+  obtain ⟨q',hq',e,he,hqe⟩ := (mem_walks_succ Γ allowed z).mp hq
+  have hde : d≠e := by
+    intro hde
+    have hc : Collision Γ allowed z j := by
+      refine ⟨p',hp',q',hq',?_,?_⟩
+      · intro heq
+        apply hpq
+        simp only [hpd,hqe,heq,hde]
+      · exact (Finset.mem_filter.mp hd).2.2.1.symm.trans
+          (hde ▸ (Finset.mem_filter.mp he).2.2.1)
+    exact Nat.find_min H (by change j < m; omega) hc
+  have hpne : p≠[] := by
+    intro hh
+    have hh' := length_mem Γ allowed z hp
+    simp only [hh,List.length_nil] at hh'
+    omega
+  have hqne : q≠[] := by
+    intro hh
+    have hh' := length_mem Γ allowed z hq
+    simp only [hh,List.length_nil] at hh'
+    omega
+  refine ⟨p++q.reverse.map Γ.reverse,?_,?_,?_,?_,?_,?_⟩
+  · intro hh
+    exact hpne (List.append_eq_nil_iff.mp hh).1
+  · simp only [List.length_append,List.length_map,List.length_reverse,
+      length_mem Γ allowed z hp,length_mem Γ allowed z hq]
+    omega
+  · apply (chain_mem Γ allowed z hp).append (chain_reverse Γ (chain_mem Γ allowed z hq))
+    intro x hx y hy
+    have hxd : x=d := by simpa only [hpd,List.getLast?_append,List.getLast?_singleton,
+      Option.some_or,Option.some.injEq] using hx.symm
+    have hye : y=Γ.reverse e := by
+      simpa only [hqe,List.head?_map,List.head?_reverse,List.getLast?_append,
+        List.getLast?_singleton,Option.some_or,Option.map_some,Option.some.injEq] using hy.symm
+    subst x; subst y
+    refine ⟨?_,fun h => hde (Γ.reverse_reverse.injective h).symm⟩
+    simpa only [hpd,hqe,endpoint_append] using hep
+  · intro x hx
+    rcases List.mem_append.mp hx with hx|hx
+    · exact allowed_mem Γ allowed z hp x hx
+    · obtain ⟨y,hy,rfl⟩ := List.mem_map.mp hx
+      exact hsymm y (allowed_mem Γ allowed z hq y (List.mem_reverse.mp hy))
+  · intro x hx
+    apply head_mem Γ allowed z hp x
+    cases p with
+    | nil => exact (hpne rfl).elim
+    | cons a p => simpa using hx
+  · cases hqq : q with
+    | nil => exact (hqne hqq).elim
+    | cons a q' =>
+      simp only [List.reverse_cons,List.map_append,List.map_singleton,←List.append_assoc,endpoint_append,
+        PortGraph.reverse_reverse_apply]
+      exact head_mem Γ allowed z (hqq ▸ hq) a (by simp)
+
+/-- A logarithmic loop bound, valid even before excluding loops and parallel edges. -/
+theorem logarithmic_based_loop
+    (hdeg : ∀ v,3≤(Finset.univ.filter (fun d => allowed d ∧ Γ.origin d=v)).card)
+    (hsymm : ∀ d,allowed d → allowed (Γ.reverse d)) :
+    ∃ l : List D,l≠[] ∧ l.length≤2*(Nat.log 2 (Fintype.card V)+1) ∧
+      l.IsChain (PortWalk.step Γ.origin Γ.reverse) ∧
+      (∀ d∈l,allowed d) ∧ (∀ d∈l.head?,Γ.origin d=z) ∧ endpoint Γ z l=z :=
+  based_loop Γ allowed z _ (Nat.lt_pow_succ_log_self (by decide) _) hdeg hsymm
+
+end
+open scoped Classical BigOperators
+open PortSubdivision WeightedMoore
+variable {V D : Type} (Γ : PortGraph V D)
+
+structure ReducedPath (a b : V) (l : List D) : Prop where
+  chain : l.IsChain (PortWalk.step Γ.origin Γ.reverse)
+  start : ∀ d∈l.head?,Γ.origin d=a
+  finish : endpoint Γ a l=b
+
+lemma endpoint_append_list (a : V) (p q : List D) :
+    endpoint Γ a (p++q)=endpoint Γ (endpoint Γ a p) q := by
+  simp only [endpoint,List.getLast?_append]
+  cases p.getLast? <;> cases q.getLast? <;> rfl
+
+namespace ReducedPath
+variable {Γ} {a b c : V} {p q : List D}
+lemma nil_iff (h : ReducedPath Γ a b []) : a=b := h.finish
+lemma last (h : ReducedPath Γ a b p) {d : D} (hd : d∈p.getLast?) : Γ.origin (Γ.reverse d)=b := by
+  have hd : p.getLast?=some d := hd
+  simpa only [endpoint,hd,Option.map_some,Option.getD_some] using h.finish
+
+lemma append (hp : ReducedPath Γ a b p) (hq : ReducedPath Γ b c q)
+    (hb : ∀ᵉ (x∈p.getLast?) (y∈q.head?),y≠Γ.reverse x) :
+    ReducedPath Γ a c (p++q) where
+  chain := hp.chain.append hq.chain fun x hx y hy => ⟨(hp.last hx).trans (hq.start y hy).symm,hb x hx y hy⟩
+  start := by
+    cases p with
+    | nil =>
+      have hab : a=b := hp.nil_iff
+      intro d hd
+      simpa only [List.nil_append,hab] using hq.start d hd
+    | cons d p =>
+      intro e he
+      exact hp.start e (by simpa using he)
+  finish := by rw [endpoint_append_list,hp.finish]; exact hq.finish
+
+lemma cyclic_join (hp : ReducedPath Γ a a p)
+    (hb : ∀ᵉ (x∈p.getLast?) (y∈p.head?),y≠Γ.reverse x) :
+    ∀ᵉ (x∈p.getLast?) (y∈p.head?),PortWalk.step Γ.origin Γ.reverse x y := by
+  intro x hx y hy
+  exact ⟨(hp.last hx).trans (hp.start y hy).symm,hb x hx y hy⟩
+end ReducedPath
+
+/-- Excluding an undirected edge means excluding both of its darts. -/
+def forbidden (d e : D) : Finset D := {d,Γ.reverse d,e,Γ.reverse e}
+def avoids (d e x : D) : Prop := x∉forbidden Γ d e
+lemma avoids_symm (d e x : D) (hx : avoids Γ d e x) : avoids Γ d e (Γ.reverse x) := by
+  simp only [avoids,forbidden,Finset.mem_insert,Finset.mem_singleton] at hx ⊢
+  rcases not_or.mp hx with ⟨h₁,hx⟩
+  rcases not_or.mp hx with ⟨h₂,hx⟩
+  rcases not_or.mp hx with ⟨h₃,h₄⟩
+  intro hx
+  rcases hx with hx|hx|hx|hx
+  · exact h₂ (by simpa using congrArg Γ.reverse hx)
+  · exact h₁ (Γ.reverse_reverse.injective hx)
+  · exact h₄ (by simpa using congrArg Γ.reverse hx)
+  · exact h₃ (Γ.reverse_reverse.injective hx)
+lemma avoids_left (d e x : D) (hx : avoids Γ d e x) : x≠d ∧ x≠Γ.reverse d := by
+  have hx : x≠d ∧ x≠Γ.reverse d ∧ x≠e ∧ x≠Γ.reverse e := by
+    simpa only [avoids,forbidden,Finset.mem_insert,Finset.mem_singleton,not_or] using hx
+  exact ⟨hx.1,hx.2.1⟩
+lemma avoids_right (d e x : D) (hx : avoids Γ d e x) : x≠e ∧ x≠Γ.reverse e := by
+  have hx : x≠d ∧ x≠Γ.reverse d ∧ x≠e ∧ x≠Γ.reverse e := by
+    simpa only [avoids,forbidden,Finset.mem_insert,Finset.mem_singleton,not_or] using hx
+  exact hx.2.2
+
+variable [Fintype V] [Fintype D]
+omit [Fintype V] in
+lemma avoiding_degree (d e : D)
+    (hdeg : ∀ v,7≤(Finset.univ.filter (fun x : D => Γ.origin x=v)).card) :
+    ∀ v,3≤(Finset.univ.filter (fun x => avoids Γ d e x ∧ Γ.origin x=v)).card := by
+  intro v
+  have hsub : Finset.univ.filter (fun x : D => Γ.origin x=v) ⊆
+      Finset.univ.filter (fun x => avoids Γ d e x ∧ Γ.origin x=v) ∪ forbidden Γ d e := by
+    intro x hx
+    have hv := (Finset.mem_filter.mp hx).2
+    by_cases hb : x∈forbidden Γ d e
+    · exact Finset.mem_union_right _ hb
+    · exact Finset.mem_union_left _ (Finset.mem_filter.mpr ⟨Finset.mem_univ _,hb,hv⟩)
+  have hc := (Finset.card_le_card hsub).trans (Finset.card_union_le _ _)
+  have hf : (forbidden Γ d e).card≤4 := by
+    unfold forbidden
+    calc
+      _ ≤ ({Γ.reverse d,e,Γ.reverse e}:Finset D).card+1 := Finset.card_insert_le _ _
+      _ ≤ ({e,Γ.reverse e}:Finset D).card+2 := by have := Finset.card_insert_le (Γ.reverse d) ({e,Γ.reverse e}:Finset D); omega
+      _ ≤ ({Γ.reverse e}:Finset D).card+3 := by have := Finset.card_insert_le e ({Γ.reverse e}:Finset D); omega
+      _ = 4 := by simp
+  have hv := hdeg v
+  omega
+
+/-- Literal reduced based loops avoiding both prescribed unoriented edges. -/
+lemma avoiding_loop (d e : D) (z : V)
+    (hdeg : ∀ v,7≤(Finset.univ.filter (fun x : D => Γ.origin x=v)).card) :
+    ∃ l : List D,l≠[] ∧ l.length≤2*(Nat.log 2 (Fintype.card V)+1) ∧
+      ReducedPath Γ z z l ∧ ∀ x∈l,avoids Γ d e x := by
+  obtain ⟨l,hn,hl,hc,ha,hs,he⟩ := logarithmic_based_loop Γ (avoids Γ d e) z
+    (avoiding_degree Γ d e hdeg) (avoids_symm Γ d e)
+  exact ⟨l,hn,hl,⟨hc,hs,he⟩,ha⟩
+
+omit [Fintype D] in
+lemma mem_head_eq {l : List D} (hn : l≠[]) {x : D} (hx : x∈l.head?) : x=l.head hn := by
+  have h := List.head?_eq_some_head hn
+  rw [h] at hx
+  exact Option.some.inj hx.symm
+omit [Fintype D] in
+lemma mem_last_eq {l : List D} (hn : l≠[]) {x : D} (hx : x∈l.getLast?) : x=l.getLast hn := by
+  have h := List.getLast?_eq_some_getLast hn
+  rw [h] at hx
+  exact Option.some.inj hx.symm
+
+/-- Short closure, before the uniform logarithmic-to-L bound.
+Only a reduced return path is used; its length need not be minimal. -/
+theorem extend_of_return {a b : V} {p q : List D}
+    (hp : ReducedPath Γ a b p) (hpn : p≠[]) (hq : ReducedPath Γ b a q)
+    (hdeg : ∀ v,7≤(Finset.univ.filter (fun x : D => Γ.origin x=v)).card) :
+    ∃ t : List D,t.length≤q.length+4*(Nat.log 2 (Fintype.card V)+1) ∧
+      ReducedPath Γ a a (p++t) ∧
+      ∀ᵉ (x∈(p++t).getLast?) (y∈(p++t).head?),PortWalk.step Γ.origin Γ.reverse x y := by
+  by_cases hqn : q=[]
+  · subst q
+    have hba : b=a := hq.nil_iff
+    subst b
+    obtain ⟨j,hjn,hjl,hj,ha⟩ := avoiding_loop Γ (p.getLast hpn) (p.head hpn) a hdeg
+    have hjp : ReducedPath Γ a a (p++j) := hp.append hj (by
+      intro x hx y hy
+      have hx := mem_last_eq hpn hx
+      subst x
+      exact (avoids_left Γ _ _ _ (ha y (List.mem_of_mem_head? hy))).2)
+    refine ⟨j,?_,hjp,hjp.cyclic_join ?_⟩
+    · simp only [List.length_nil,zero_add]
+      omega
+    · intro x hx y hy
+      rw [List.getLast?_append_of_ne_nil _ hjn] at hx
+      rw [List.head?_append_of_ne_nil _ hpn] at hy
+      have hy := mem_head_eq hpn hy
+      subst y
+      intro he
+      have hx' := (avoids_right Γ _ _ _ (ha x (List.mem_of_mem_getLast? hx))).2
+      exact hx' (by simpa using (congrArg Γ.reverse he).symm)
+  · obtain ⟨jb,hjbn,hjbl,hjb,hab⟩ := avoiding_loop Γ (p.getLast hpn) (q.head hqn) b hdeg
+    obtain ⟨ja,hjan,hjal,hja,haa⟩ := avoiding_loop Γ (q.getLast hqn) (p.head hpn) a hdeg
+    have hpjb : ReducedPath Γ a b (p++jb) := hp.append hjb (by
+      intro x hx y hy
+      have hx := mem_last_eq hpn hx
+      subst x
+      exact (avoids_left Γ _ _ _ (hab y (List.mem_of_mem_head? hy))).2)
+    have hpjbq : ReducedPath Γ a a ((p++jb)++q) := hpjb.append hq (by
+      intro x hx y hy
+      rw [List.getLast?_append_of_ne_nil _ hjbn] at hx
+      have hy := mem_head_eq hqn hy
+      subst y
+      intro he
+      have hx' := (avoids_right Γ _ _ _ (hab x (List.mem_of_mem_getLast? hx))).2
+      exact hx' (by simpa using (congrArg Γ.reverse he).symm))
+    have hall : ReducedPath Γ a a (((p++jb)++q)++ja) := hpjbq.append hja (by
+      intro x hx y hy
+      rw [List.getLast?_append_of_ne_nil _ hqn] at hx
+      have hx := mem_last_eq hqn hx
+      subst x
+      exact (avoids_left Γ _ _ _ (haa y (List.mem_of_mem_head? hy))).2)
+    refine ⟨jb++q++ja,?_,?_,?_⟩
+    · simp only [List.length_append]
+      omega
+    · simpa only [List.append_assoc] using hall
+    · have hcy := hall.cyclic_join (by
+        intro x hx y hy
+        rw [List.getLast?_append_of_ne_nil _ hjan] at hx
+        rw [List.append_assoc,List.append_assoc,List.head?_append_of_ne_nil _ hpn] at hy
+        have hy := mem_head_eq hpn hy
+        subst y
+        intro he
+        have hx' := (avoids_right Γ _ _ _ (haa x (List.mem_of_mem_getLast? hx))).2
+        exact hx' (by simpa using (congrArg Γ.reverse he).symm))
+      simpa only [List.append_assoc] using hcy
+
+end TorsionFreeZeroDivisors.ShortClosure
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/GroupRing/Cayley.lean b/lean/OAI/Algebra/GroupRing/Cayley.lean
new file mode 100644
index 0000000000000000000000000000000000000000..1b2db6f9474bd4ebfcf5858dc3cc89dc07ebaae1
--- /dev/null
+++ b/lean/OAI/Algebra/GroupRing/Cayley.lean
@@ -0,0 +1,483 @@
+import Mathlib
+import OAI.Algebra.GroupRing.Attachment
+
+namespace OAI
+
+noncomputable section
+
+open Set Metric Topology BigOperators
+open Set Metric Topology
+
+namespace GroupRingTopology.Attachment
+
+section
+open Set Metric Topology
+universe u v w z
+variable {X : Type u} {Y : Type v} [TopologicalSpace X] [TopologicalSpace Y]
+variable {ι : Type w} {κ : Type z} {n : ℕ}
+variable (a : ι → C(Sphere n,X)) (b : κ → C(Sphere n,Y))
+
+def map (p : C(X,Y)) (σ : ι → κ) (h : ∀ i x, p (a i x) = b (σ i) x) :
+    C(Space a,Space b) :=
+  lift a ⟨base b ∘ p,(continuous_base b).comp p.continuous⟩
+    (fun i => cell b (σ i)) (fun i x => by simp only [cell_boundary,ContinuousMap.coe_mk,Function.comp_apply,h])
+
+@[simp] lemma map_base (p : C(X,Y)) (σ : ι → κ)
+    (h : ∀ i x, p (a i x) = b (σ i) x) (x : X) :
+    map a b p σ h (base a x) = base b (p x) := rfl
+
+@[simp] lemma map_cell (p : C(X,Y)) (σ : ι → κ)
+    (h : ∀ i x, p (a i x) = b (σ i) x) (i : ι) (d : Disk n) :
+    map a b p σ h (cell a i d) = cell b (σ i) d := lift_cell a _ _ _ i d
+
+@[simp] lemma map_openCell (p : C(X,Y)) (σ : ι → κ)
+    (h : ∀ i x, p (a i x) = b (σ i) x) (i : ι) (d : OpenDisk n) :
+    map a b p σ h (openCell a i d) = openCell b (σ i) d := by
+  change map a b p σ h (Sum.inr ⟨i,d⟩) = Sum.inr ⟨σ i,d⟩
+  rw [← cell_interior a i d,map_cell,cell_interior]
+
+lemma map_surjective (p : C(X,Y)) (σ : ι → κ)
+    (h : ∀ i x, p (a i x) = b (σ i) x)
+    (hp : Function.Surjective p) (hσ : Function.Surjective σ) :
+    Function.Surjective (map a b p σ h) := by
+  intro z
+  cases z with
+  | inl y =>
+    obtain ⟨x,rfl⟩ := hp y
+    exact ⟨base a x,rfl⟩
+  | inr q =>
+    obtain ⟨i,hi⟩ := hσ q.1
+    exact ⟨openCell a i q.2,by rw [map_openCell,hi]; rfl⟩
+
+lemma map_isQuotientMap (p : C(X,Y)) (σ : ι → κ)
+    (h : ∀ i x, p (a i x) = b (σ i) x)
+    (hp : IsQuotientMap p) (hσ : Function.Surjective σ) :
+    IsQuotientMap (map a b p σ h) := by
+  refine ⟨?_,map_surjective a b p σ h hp.surjective hσ⟩
+  rw [isCoinducing_iff]
+  intro U
+  constructor
+  · intro hU
+    rw [isOpen_iff] at hU ⊢
+    constructor
+    · apply hp.isOpen_preimage.mp
+      exact hU.1
+    · intro j
+      obtain ⟨i,rfl⟩ := hσ j
+      convert hU.2 i using 1
+      ext d
+      simp only [Set.mem_preimage,map_cell]
+  · exact fun hU => hU.preimage (map a b p σ h).continuous
+
+end
+
+open Set Metric Topology
+universe u v w z
+
+def FreeIndex (G : Type u) (ι : Type v) := G × ι
+
+instance {G : Type u} [Group G] {ι : Type v} : MulAction G (FreeIndex G ι) where
+  smul g p := (g * p.1,p.2)
+  one_smul p := by change ((1:G)*p.1,p.2)=p; simp only [one_mul]; rfl
+  mul_smul g h p := by change ((g*h)*p.1,p.2)=(g*(h*p.1),p.2); rw [mul_assoc]
+
+instance {G : Type u} [Group G] {ι : Type v} : IsCancelSMul G (FreeIndex G ι) where
+  right_cancel' _ _ _ he := mul_right_cancel (congrArg (fun p : FreeIndex G ι => p.1) he)
+
+variable {G : Type u} [Group G]
+variable {E : Type v} [TopologicalSpace E] [MulAction G E] [ContinuousConstSMul G E]
+variable {X : Type w} [TopologicalSpace X] {ι : Type z} {n : ℕ}
+variable (a : ι → C(Sphere n,E))
+
+def equivariantFamily : FreeIndex G ι → C(Sphere n,E) :=
+  fun i => ⟨fun x => i.1 • a i.2 x,(continuous_const_smul i.1).comp (a i.2).continuous⟩
+
+lemma equivariantFamily_smul (g : G) (i : FreeIndex G ι) (x : Sphere n) :
+    equivariantFamily (G := G) a (g • i) x = g • equivariantFamily a i x := mul_smul g i.1 _
+
+instance equivariantAttachmentContinuousAction :
+    ContinuousConstSMul G (Space (equivariantFamily (G := G) a)) :=
+  continuousConstSMul _ (equivariantFamily_smul a)
+
+variable (p : C(E,X)) (hp : IsQuotientCoveringMap p G)
+variable (b : ι → C(Sphere n,X)) (h : ∀ i x, p (a i x) = b i x)
+
+include hp h in
+lemma equivariantFamily_over (i : FreeIndex G ι) (x : Sphere n) :
+    p (equivariantFamily (G := G) a i x) = b i.2 x :=
+  (hp.map_smul i.1).trans (h i.2 x)
+
+def coverMap : C(Space (equivariantFamily (G := G) a),Space b) :=
+  map _ b p Prod.snd (equivariantFamily_over a p hp b h)
+
+lemma coverMap_isQuotient : IsQuotientMap (coverMap a p hp b h) :=
+  map_isQuotientMap _ b p Prod.snd _ hp.toIsQuotientMap (fun i => ⟨(1,i),rfl⟩)
+
+lemma coverMap_fibers {e₁ e₂ : Space (equivariantFamily (G := G) a)} :
+    coverMap a p hp b h e₁ = coverMap a p hp b h e₂ ↔ e₁ ∈ MulAction.orbit G e₂ := by
+  classical
+  cases e₁ with
+  | inl x =>
+    cases e₂ with
+    | inl y =>
+      change Sum.inl (p x) = Sum.inl (p y) ↔ _
+      rw [Sum.inl.injEq,hp.apply_eq_iff_mem_orbit]
+      constructor
+      · rintro ⟨g,hg⟩; exact ⟨g,congrArg Sum.inl hg⟩
+      · rintro ⟨g,hg⟩; exact ⟨g,Sum.inl_injective hg⟩
+    | inr q =>
+      constructor
+      · intro hh
+        change base b (p x) = map _ b p Prod.snd _ (openCell _ q.1 q.2) at hh
+        erw [map_openCell] at hh
+        cases hh
+      · rintro ⟨g,hg⟩; cases hg
+  | inr q =>
+    cases e₂ with
+    | inl y =>
+      constructor
+      · intro hh
+        change map _ b p Prod.snd _ (openCell _ q.1 q.2) = base b (p y) at hh
+        erw [map_openCell] at hh
+        cases hh
+      · rintro ⟨g,hg⟩; cases hg
+    | inr r =>
+      change map _ b p Prod.snd _ (openCell _ q.1 q.2) =
+        map _ b p Prod.snd _ (openCell _ r.1 r.2) ↔ _
+      erw [map_openCell,map_openCell]
+      constructor
+      · intro hh
+        have hi : q.1.2 = r.1.2 := congrArg Sigma.fst (Sum.inr_injective hh)
+        have hd : q.2 = r.2 := congrArg (fun p : Σ _ : ι, OpenDisk n => p.2) (Sum.inr_injective hh)
+        refine ⟨q.1.1 * r.1.1⁻¹,?_⟩
+        change Sum.inr ⟨((q.1.1 * r.1.1⁻¹) * r.1.1,r.1.2),r.2⟩ = Sum.inr q
+        simp only [inv_mul_cancel_right,← hi,← hd]
+        rfl
+      · rintro ⟨g,hg⟩
+        change (Sum.inr ⟨g • r.1,r.2⟩ : Space (equivariantFamily (G := G) a)) = Sum.inr q at hg
+        have hi : (g • r.1) = q.1 := congrArg Sigma.fst (Sum.inr_injective hg)
+        have htuple : (⟨g • r.1,r.2⟩ : Σ _ : FreeIndex G ι, OpenDisk n) = q := Sum.inr_injective hg
+        have hd' := congrArg (fun p : Σ _ : FreeIndex G ι, OpenDisk n => p.2) htuple
+        have hd : r.2 = q.2 := hd' 
+        have his' := congrArg (fun p : FreeIndex G ι => p.2) hi
+        have his : r.1.2 = q.1.2 := his'
+        change (Sum.inr ⟨q.1.2,q.2⟩ : Space b) = Sum.inr ⟨r.1.2,r.2⟩
+        rw [his,hd]
+
+/-- Free, equivariant cell attachments preserve a genuine regular covering.
+The proof constructs collars of disjoint slices; no local-finiteness or
+local-compactness hypothesis is imposed. -/
+lemma coverMap_isQuotientCovering : IsQuotientCoveringMap (coverMap a p hp b h) G where
+  __ := coverMap_isQuotient a p hp b h
+  __ := equivariantAttachmentContinuousAction a
+  apply_eq_iff_mem_orbit := coverMap_fibers a p hp b h
+  disjoint := exists_disjoint_nhds _ (equivariantFamily_smul a) hp.disjoint
+
+lemma coverMap_isCovering : IsCoveringMap (coverMap a p hp b h) :=
+  (coverMap_isQuotientCovering a p hp b h).isCoveringMap
+
+end GroupRingTopology.Attachment
+
+namespace GroupRingTopology.Cayley
+open Set Metric Topology Attachment
+universe u
+
+lemma sphere_one_cases (x : Sphere 1) : x.1 0 = -1 ∨ x.1 0 = 1 := by
+  have hn : ‖x.1‖ = 1 := by simpa only [mem_sphere,dist_zero_right] using x.2
+  have hc : x.1 = fun _ => x.1 0 := funext (fun i => congrArg x.1 (Subsingleton.elim i 0))
+  rw [hc,pi_norm_const,Real.norm_eq_abs] at hn
+  exact ((abs_eq (by norm_num : (0:ℝ) ≤ 1)).mp hn).symm
+
+instance : Finite (Sphere 1) := by
+  have he : {r : ℝ | r = -1 ∨ r = 1} = {-1,1} := by ext r; simp
+  have hS : Set.Finite {r : ℝ | r = -1 ∨ r = 1} := he.symm ▸ ((Set.finite_singleton (1 : ℝ)).insert (-1))
+  let : Finite {r : ℝ // r = -1 ∨ r = 1} := hS.to_subtype
+  apply Finite.of_injective (fun x : Sphere 1 => (⟨x.1 0,sphere_one_cases x⟩ :
+    {r : ℝ // r = -1 ∨ r = 1}))
+  intro x y h
+  apply Subtype.ext
+  funext i
+  have hi : i = 0 := Subsingleton.elim _ _
+  simpa only [hi] using congrArg Subtype.val h
+
+instance : DiscreteTopology (Sphere 1) := inferInstance
+
+def minus : Sphere 1 := ⟨fun _ => -1,by norm_num [mem_sphere,dist_pi_def]⟩
+def plus : Sphere 1 := ⟨fun _ => 1,by norm_num [mem_sphere,dist_pi_def]⟩
+
+variable {G : Type u} [Group G] [TopologicalSpace G] [DiscreteTopology G]
+variable {S : Type u} (s : S → G)
+
+def attaching (i : S) : C(Sphere 1,G) :=
+  ⟨fun x => if x.1 0 = -1 then 1 else s i,continuous_of_discreteTopology⟩
+
+abbrev Graph := Space (equivariantFamily (G := G) (attaching s))
+
+instance : Nonempty (Graph s) := ⟨base _ 1⟩
+
+def vertex (g : G) : Graph s := base _ g
+
+omit [Group G] in
+lemma discrete_dimension (m : ℕ) (i : RelCWComplex.cell (Set.univ : Set G) m) : m < 1 := by
+  cases m with
+  | zero => omega
+  | succ m => exact i.elim
+
+instance graphCW : CWComplex (Set.univ : Set (Graph s)) :=
+  layerCW _ discrete_dimension
+
+instance : T2Space (Graph s) :=
+  t2Space _ ((realSeparated_of_tychonoff (Y := G)))
+
+lemma graph_dimension (m : ℕ) (i : RelCWComplex.cell (Set.univ : Set (Graph s)) m) : m < 2 :=
+  layerCW_dimensions _ discrete_dimension m i
+
+lemma vertex_injective : Function.Injective (vertex s) := Sum.inl_injective
+
+lemma cell_minus (g : G) (i : S) :
+    cell (equivariantFamily (G := G) (attaching s)) (g,i) (boundary 1 minus) = vertex s g := by
+  erw [cell_boundary]
+  simp only [equivariantFamily,attaching,ContinuousMap.coe_mk,minus,ite_true,smul_eq_mul,mul_one]
+  rfl
+
+lemma cell_plus (g : G) (i : S) :
+    cell (equivariantFamily (G := G) (attaching s)) (g,i) (boundary 1 plus) = vertex s (g*s i) := by
+  erw [cell_boundary]
+  norm_num only [equivariantFamily,attaching,ContinuousMap.coe_mk,plus,ite_false,smul_eq_mul]
+  rfl
+
+instance disk_pathConnected (n : ℕ) : PathConnectedSpace (Disk n) :=
+  isPathConnected_iff_pathConnectedSpace.mp ((convex_closedBall (0 : Fin n → ℝ) 1).isPathConnected ⟨0,mem_closedBall_self (by norm_num)⟩)
+
+lemma cell_joined (g : G) (i : S) : Joined (vertex s g) (vertex s (g*s i)) := by
+  have h : Joined (boundary 1 minus) (boundary 1 plus) := PathConnectedSpace.joined _ _
+  have hh := h.map (cell (equivariantFamily (G := G) (attaching s)) (g,i)).continuous
+  simpa only [cell_minus,cell_plus] using hh
+
+lemma vertex_smul (g h : G) : g • vertex s h = vertex s (g*h) := rfl
+
+lemma vertices_joined (hs : Subgroup.closure (Set.range s) = ⊤) (g : G) :
+    Joined (vertex s 1) (vertex s g) := by
+  let K : Subgroup G :=
+    { carrier := {g | Joined (vertex s 1) (vertex s g)}
+      one_mem' := Joined.refl _
+      mul_mem' := by
+        intro g h hg hh
+        have hh' := hh.map (continuous_const_smul g : Continuous (fun x : Graph s => g • x))
+        rw [vertex_smul,vertex_smul,mul_one] at hh'
+        exact hg.trans hh'
+      inv_mem' := by
+        intro g hg
+        have hh := hg.symm.map (continuous_const_smul g⁻¹ : Continuous (fun x : Graph s => g⁻¹ • x))
+        change Joined (vertex s 1) (vertex s g⁻¹)
+        simpa only [vertex_smul,mul_one,inv_mul_cancel] using hh }
+  have hK : Subgroup.closure (Set.range s) ≤ K := (Subgroup.closure_le K).2 (by
+    rintro _ ⟨i,rfl⟩
+    change Joined (vertex s 1) (vertex s (s i))
+    simpa only [one_mul] using cell_joined s 1 i)
+  rw [hs] at hK
+  exact hK (Subgroup.mem_top g)
+
+lemma graph_pathConnected (hs : Subgroup.closure (Set.range s) = ⊤) : PathConnectedSpace (Graph s) := by
+  have hj : ∀ x : Graph s, Joined (vertex s 1) x := by
+    intro x
+    cases x with
+    | inl g => exact vertices_joined s hs g
+    | inr p =>
+      have h : Joined (boundary 1 minus) (interior 1 p.2) := PathConnectedSpace.joined _ _
+      have hh := h.map (cell (equivariantFamily (G := G) (attaching s)) p.1).continuous
+      rw [cell_interior] at hh
+      have hp : cell (equivariantFamily (G := G) (attaching s)) p.1 (boundary 1 minus) = vertex s p.1.1 :=
+        cell_minus s p.1.1 p.1.2
+      rw [hp] at hh
+      exact (vertices_joined s hs p.1.1).trans hh
+  exact ⟨inferInstance,fun x y => (hj x).symm.trans (hj y)⟩
+
+end GroupRingTopology.Cayley
+
+namespace GroupRingTopology.PathSquares
+open Set
+open scoped unitInterval
+variable {X : Type*} [TopologicalSpace X] {x a b : X}
+
+lemma turn (p : Path x a) (q : Path x b) (e : Path a b)
+    (h : (p.trans e).Homotopic q) : e.Homotopic (p.symm.trans q) := by
+  apply (Path.Homotopic.refl_trans e).symm.trans
+  apply ((Path.Homotopic.symm_trans p).symm.hcomp (Path.Homotopic.refl e)).trans
+  exact (Path.Homotopic.trans_assoc p.symm p e).trans ((Path.Homotopic.refl p.symm).hcomp h)
+
+def spanContract (p : Path x a) (q : Path x b) :
+    (p.symm.trans q).toContinuousMap.Homotopy (.const _ x) where
+  toFun z := if (z.2 : ℝ) ≤ 1/2 then p.extend ((1-z.1)*(1-2*z.2))
+    else q.extend ((1-z.1)*(2*z.2-1))
+  continuous_toFun := continuous_if_le (by fun_prop) continuous_const
+    (by fun_prop) (by fun_prop) (by intro z hz; simp [hz])
+  map_zero_left z := by simp [Path.trans,Path.extend_symm_apply]
+  map_one_left z := by simp
+
+lemma spanContract_source (p : Path x a) (q : Path x b) (t : I) :
+    spanContract p q (t,0) = p.symm t := by
+  change (if (0 : ℝ) ≤ 1/2 then p.extend ((1-(t:ℝ))*(1-2*0)) else q.extend ((1-(t:ℝ))*(2*0-1))) = _
+  norm_num only [show (0:ℝ)≤1/2 by norm_num,ite_true,mul_zero,sub_zero,mul_one]
+  rw [← Path.extend_symm_apply,Path.extend_extends' ]
+lemma spanContract_target (p : Path x a) (q : Path x b) (t : I) :
+    spanContract p q (t,1) = q.symm t := by
+  change (if (1 : ℝ) ≤ 1/2 then p.extend ((1-(t:ℝ))*(1-2*1)) else q.extend ((1-(t:ℝ))*(2*1-1))) = _
+  norm_num only [mul_one,show (2:ℝ)-1=1 by norm_num,show ¬(1:ℝ)≤1/2 by norm_num,ite_false]
+  rw [← Path.extend_symm_apply,Path.extend_extends' ]
+
+def pauseReverse (p : Path x a) : C(I,X) := ((Path.refl a).trans p.symm).toContinuousMap
+
+/-- Compatible vertex paths fill every edge square, without any path-word
+approximation assertion. The pause at the vertex is the same for every edge. -/
+theorem edgeSquare (p : Path x a) (q : Path x b) (e : Path a b)
+    (h : (p.trans e).Homotopic q) :
+    ∃ H : e.toContinuousMap.Homotopy (.const _ x),
+      (∀ t, H (t,0) = pauseReverse p t) ∧ (∀ t, H (t,1) = pauseReverse q t) := by
+  obtain ⟨A⟩ := turn p q e h
+  refine ⟨A.toHomotopy.trans (spanContract p q),?_,?_⟩
+  · intro t
+    rw [ContinuousMap.Homotopy.trans_apply]
+    split_ifs with ht
+    · change (t:ℝ) ≤ 1/2 at ht
+      change A (_,0) = ((Path.refl a).trans p.symm) t
+      rw [Path.trans_apply,dite_eq_left ht]
+      exact A.source _
+    · change ¬(t:ℝ) ≤ 1/2 at ht
+      change spanContract p q (_,0) = ((Path.refl a).trans p.symm) t
+      rw [Path.trans_apply,dite_eq_right ht,spanContract_source]
+  · intro t
+    rw [ContinuousMap.Homotopy.trans_apply]
+    split_ifs with ht
+    · change (t:ℝ) ≤ 1/2 at ht
+      change A (_,1) = ((Path.refl b).trans q.symm) t
+      rw [Path.trans_apply,dite_eq_left ht]
+      exact A.target _
+    · change ¬(t:ℝ) ≤ 1/2 at ht
+      change spanContract p q (_,1) = ((Path.refl b).trans q.symm) t
+      rw [Path.trans_apply,dite_eq_right ht,spanContract_target]
+end GroupRingTopology.PathSquares
+namespace GroupRingTopology.Cayley
+open Set Metric Topology Attachment
+open scoped unitInterval
+universe u v
+
+def edgeParam (t : I) : Disk 1 := ⟨fun _ => 2*(t:ℝ)-1,by
+  rw [mem_closedBall,dist_zero_right,pi_norm_le_iff_of_nonneg zero_le_one]
+  intro i
+  rw [Real.norm_eq_abs,abs_le]
+  constructor <;> linarith [t.2.1,t.2.2]⟩
+lemma continuous_edgeParam : Continuous edgeParam := by unfold edgeParam; fun_prop
+
+def edgeTime (d : Disk 1) : I := ⟨(d.1 0+1)/2,by
+  have hh : |d.1 0| ≤ 1 := by
+    have := d.2
+    rw [mem_closedBall,dist_zero_right,pi_norm_le_iff_of_nonneg zero_le_one] at this
+    exact this 0
+  rw [abs_le] at hh
+  constructor <;> linarith⟩
+lemma continuous_edgeTime : Continuous edgeTime := by
+  apply Continuous.subtype_mk
+  exact (((continuous_apply 0).comp continuous_subtype_val).add continuous_const).div_const 2
+lemma edgeParam_time (d : Disk 1) : edgeParam (edgeTime d) = d := by
+  apply Subtype.ext
+  funext i
+  have hi : i = 0 := Subsingleton.elim _ _
+  subst i
+  dsimp [edgeParam,edgeTime]
+  ring
+lemma edgeTime_param (t : I) : edgeTime (edgeParam t) = t := by
+  apply Subtype.ext
+  dsimp [edgeTime,edgeParam]
+  ring
+lemma edgeParam_zero : edgeParam 0 = boundary 1 minus := by
+  apply Subtype.ext
+  funext i
+  norm_num [edgeParam,minus,boundary]
+lemma edgeParam_one : edgeParam 1 = boundary 1 plus := by
+  apply Subtype.ext
+  funext i
+  norm_num [edgeParam,plus,boundary]
+lemma edgeTime_minus : edgeTime (boundary 1 minus) = 0 := by
+  rw [←edgeParam_zero,edgeTime_param]
+lemma edgeTime_plus : edgeTime (boundary 1 plus) = 1 := by
+  rw [←edgeParam_one,edgeTime_param]
+lemma sphere_one_eq (t : Sphere 1) : t = minus ∨ t = plus := by
+  obtain h|h := sphere_one_cases t
+  · left; apply Subtype.ext; funext i; have hi : i=0 := Subsingleton.elim _ _; subst i; exact h
+  · right; apply Subtype.ext; funext i; have hi : i=0 := Subsingleton.elim _ _; subst i; exact h
+
+variable {G : Type u} [Group G] [TopologicalSpace G] [DiscreteTopology G]
+variable {S : Type u} (s : S → G)
+
+def edge (g : G) (i : S) : Path (vertex s g) (vertex s (g*s i)) where
+  toFun t := cell (equivariantFamily (G := G) (attaching s)) (g,i) (edgeParam t)
+  continuous_toFun := (cell _ _).continuous.comp continuous_edgeParam
+  source' := by rw [edgeParam_zero,cell_minus]
+  target' := by rw [edgeParam_one,cell_plus]
+
+variable {Y : Type v} [TopologicalSpace Y] (f : C(Graph s,Y)) (y : Y)
+variable (p : ∀ g, Path y (f (vertex s g)))
+variable (hp : ∀ g i, ((p g).trans ((edge s g i).map f.continuous)).Homotopic (p (g*s i)))
+
+def edgeSquare (g : G) (i : S) : ((edge s g i).map f.continuous).toContinuousMap.Homotopy (.const _ y) :=
+  (PathSquares.edgeSquare (p g) (p (g*s i)) ((edge s g i).map f.continuous) (hp g i)).choose
+lemma edgeSquare_source (g : G) (i : S) (t : I) :
+    edgeSquare s f y p hp g i (t,0) = PathSquares.pauseReverse (p g) t :=
+  (PathSquares.edgeSquare (p g) (p (g*s i)) ((edge s g i).map f.continuous) (hp g i)).choose_spec.1 t
+lemma edgeSquare_target (g : G) (i : S) (t : I) :
+    edgeSquare s f y p hp g i (t,1) = PathSquares.pauseReverse (p (g*s i)) t :=
+  (PathSquares.edgeSquare (p g) (p (g*s i)) ((edge s g i).map f.continuous) (hp g i)).choose_spec.2 t
+
+def edgePaths (i : FreeIndex G S) : C(Disk 1,C(I,Y)) :=
+  ContinuousMap.curry ⟨fun z => edgeSquare s f y p hp i.1 i.2 (z.2,edgeTime z.1),
+    (edgeSquare s f y p hp i.1 i.2).continuous.comp
+      (continuous_snd.prodMk (continuous_edgeTime.comp continuous_fst))⟩
+def vertexPaths : C(G,C(I,Y)) := ⟨fun g => PathSquares.pauseReverse (p g),continuous_of_discreteTopology⟩
+lemma edgePaths_boundary (i : FreeIndex G S) (t : Sphere 1) :
+    edgePaths s f y p hp i (boundary 1 t) =
+      vertexPaths s f y p (equivariantFamily (G := G) (attaching s) i t) := by
+  obtain rfl|rfl := sphere_one_eq t
+  · apply ContinuousMap.ext; intro z
+    change edgeSquare s f y p hp i.1 i.2 (z,edgeTime (boundary 1 minus)) = _
+    rw [edgeTime_minus,edgeSquare_source]
+    simp only [vertexPaths,equivariantFamily,attaching,ContinuousMap.coe_mk,minus,ite_true,smul_eq_mul,mul_one]
+  · apply ContinuousMap.ext; intro z
+    change edgeSquare s f y p hp i.1 i.2 (z,edgeTime (boundary 1 plus)) = _
+    rw [edgeTime_plus,edgeSquare_target]
+    norm_num [vertexPaths,equivariantFamily,attaching,plus]
+
+def graphPaths : C(Graph s,C(I,Y)) :=
+  lift _ (vertexPaths s f y p) (edgePaths s f y p hp) (edgePaths_boundary s f y p hp)
+
+lemma graphPaths_zero (z : Graph s) : graphPaths s f y p hp z 0 = f z := by
+  cases z with
+  | inl g =>
+    change PathSquares.pauseReverse (p g) 0 = _
+    exact Path.source _
+  | inr z =>
+    change edgeSquare s f y p hp z.1.1 z.1.2 (0,edgeTime (interior 1 z.2)) = _
+    rw [ContinuousMap.Homotopy.apply_zero]
+    change f (cell _ z.1 (edgeParam (edgeTime (interior 1 z.2)))) = f _
+    rw [edgeParam_time,cell_interior]
+lemma graphPaths_one (z : Graph s) : graphPaths s f y p hp z 1 = y := by
+  cases z with
+  | inl g =>
+    change PathSquares.pauseReverse (p g) 1 = y
+    exact Path.target _
+  | inr z =>
+    change edgeSquare s f y p hp z.1.1 z.1.2 (1,edgeTime (interior 1 z.2)) = y
+    exact ContinuousMap.Homotopy.apply_one _ _
+
+/-- A coherent system of vertex paths contracts the entire graph map. -/
+def graphNullhomotopy : f.Homotopy (.const _ y) where
+  toFun z := graphPaths s f y p hp z.2 z.1
+  continuous_toFun := (graphPaths s f y p hp).uncurry.continuous.comp continuous_swap
+  map_zero_left := graphPaths_zero s f y p hp
+  map_one_left := graphPaths_one s f y p hp
+end GroupRingTopology.Cayley
+open Set Metric Topology
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/GroupRing/CayleyFurther.lean b/lean/OAI/Algebra/GroupRing/CayleyFurther.lean
new file mode 100644
index 0000000000000000000000000000000000000000..7edc456dfce98fbf23a43758a1a67b137584cc11
--- /dev/null
+++ b/lean/OAI/Algebra/GroupRing/CayleyFurther.lean
@@ -0,0 +1,437 @@
+import Mathlib
+import OAI.Algebra.GroupRing.LoopSphere
+
+namespace OAI
+
+noncomputable section
+
+open Set Metric Topology BigOperators
+open Set Metric Topology
+
+namespace GroupRingTopology.Cayley
+
+section
+open Set Metric Topology Attachment PathExtension
+open scoped unitInterval
+universe u v
+variable {G : Type u} [Group G] [TopologicalSpace G] [DiscreteTopology G]
+variable {S : Type u} (s : S → G)
+variable {Y : Type v} [TopologicalSpace Y] [MulAction G Y] [ContinuousConstSMul G Y]
+variable (f : C(Graph s,Y)) (hf : ∀ (g : G) x, f (g • x) = g • f x)
+include hf in
+omit [ContinuousConstSMul G Y] in
+lemma vertex_action (g : G) : f (vertex s g) = g • f (vertex s 1) := by
+  rw [← hf,smul_vertex,_root_.mul_one]
+
+lemma pathGenerator_equal (i : S) : Q.Equal (pathGenerator s i).2 (Path.Homotopic.Quotient.mk (edge s 1 i)) := by
+  refine ⟨rfl,?_,?_⟩
+  · rw [smul_vertex]; simp only [_root_.one_mul,_root_.mul_one]; rfl
+  · exact Path.Homotopic.hpath_hext (fun _ => rfl)
+
+include hf in
+lemma edge_smul_equal (g : G) (i : S) :
+    Q.Equal (((Path.Homotopic.Quotient.mk (edge s 1 i)).map f).map (smulMap g))
+      (Path.Homotopic.Quotient.mk ((edge s g i).map f.continuous)) := by
+  refine ⟨(vertex_action s f hf g).symm,?_,?_⟩
+  · change g • f (vertex s (1*s i)) = f (vertex s (g*s i))
+    rw [←hf,smul_vertex,_root_.one_mul]
+  · apply Path.Homotopic.hpath_hext
+    intro t
+    change g • f (cell _ ((1:G),i) (edgeParam t)) = f (cell _ (g,i) (edgeParam t))
+    erw [←hf,smul_cell _ (equivariantFamily_smul (attaching s))]
+    change f (cell _ (g*1,i) (edgeParam t)) = _
+    rw [_root_.mul_one]
+
+variable (τ : G →* PathExtension.Extension G (f (vertex s 1)))
+variable (hτ : ∀ g, (τ g).1 = g)
+def coherentClass (g : G) : Path.Homotopic.Quotient (f (vertex s 1)) (f (vertex s g)) :=
+  (τ g).2.cast rfl (by rw [hτ]; exact vertex_action s f hf g)
+def coherentPath (g : G) : Path (f (vertex s 1)) (f (vertex s g)) :=
+  (Path.Homotopic.Quotient.mk_surjective (coherentClass s f hf τ hτ g)).choose
+lemma coherentPath_equal (g : G) : Q.Equal (Path.Homotopic.Quotient.mk (coherentPath s f hf τ hτ g)) (τ g).2 :=
+  (Q.Equal.ofEq (Path.Homotopic.Quotient.mk_surjective (coherentClass s f hf τ hτ g)).choose_spec).trans
+    (Q.cast_equal _ _ _)
+
+variable (hgen : ∀ i, Q.Equal (τ (s i)).2 (Path.Homotopic.Quotient.mk ((edge s 1 i).map f.continuous)))
+include hgen in
+lemma coherentPath_edge (g : G) (i : S) :
+    ((coherentPath s f hf τ hτ g).trans ((edge s g i).map f.continuous)).Homotopic
+      (coherentPath s f hf τ hτ (g*s i)) := by
+  apply Path.Homotopic.Quotient.exact
+  change (Path.Homotopic.Quotient.mk (coherentPath s f hf τ hτ g)).trans
+    (Path.Homotopic.Quotient.mk ((edge s g i).map f.continuous)) = _
+  apply eq_of_heq
+  apply Q.Equal.path
+  have he : Q.Equal ((τ (s i)).2.map (smulMap (τ g).1))
+      (Path.Homotopic.Quotient.mk ((edge s g i).map f.continuous)) := by
+    apply ((hgen i).map (smulMap (τ g).1)).trans
+    rw [hτ]
+    exact edge_smul_equal s f hf g i
+  apply (Q.Equal.comp (coherentPath_equal s f hf τ hτ g) he.symm).trans
+  apply (mul_path_equal (τ g) (τ (s i))).symm.trans
+  have hm : Q.Equal (τ g * τ (s i)).2 (τ (g*s i)).2 := by
+    rw [←τ.map_mul]
+    exact .refl _
+  exact hm.trans (coherentPath_equal s f hf τ hτ (g*s i)).symm
+
+def nullhomotopyOfSection : f.Homotopy (.const _ (f (vertex s 1))) :=
+  graphNullhomotopy s f (f (vertex s 1)) (coherentPath s f hf τ hτ)
+    (coherentPath_edge s f hf τ hτ hgen)
+end
+open PathExtension Attachment
+universe u
+variable {G : Type u} [Group G] [TopologicalSpace G] [DiscreteTopology G]
+variable {S : Type u} (s : S → G) (rels : Set (FreeGroup S))
+variable (hrel : ∀ r ∈ rels, FreeGroup.lift s r = 1)
+variable (hs : Function.Surjective (FreeGroup.lift s))
+variable (hker : (FreeGroup.lift s).ker = Subgroup.normalClosure rels)
+lemma presentationSection_generator (i : S) :
+    Q.Equal (presentationSection s rels hrel hs hker (s i)).2
+      (Path.Homotopic.Quotient.mk ((edge s 1 i).map (presentationBase s rels hrel).continuous)) := by
+  have hh : presentationSection s rels hrel hs hker (s i) =
+      PathExtension.map (presentationBase s rels hrel) (presentationBase_smul s rels hrel) (vertex s 1)
+        (pathGenerator s i) := by
+    simpa only [FreeGroup.lift_apply_of,coverWordLift,MonoidHom.comp_apply,wordLift]
+      using presentationSection_lift s rels hrel hs hker (FreeGroup.of i)
+  rw [hh]
+  exact (PathExtension.mapFun_equal (presentationBase s rels hrel) (presentationBase_smul s rels hrel) (vertex s 1) (pathGenerator s i)).trans
+    ((pathGenerator_equal s i).map (presentationBase s rels hrel))
+
+def presentationGraphNullhomotopy :
+    (presentationBase s rels hrel).Homotopy
+      (.const _ (presentationBase s rels hrel (vertex s 1))) :=
+  nullhomotopyOfSection s (presentationBase s rels hrel) (presentationBase_smul s rels hrel)
+    (presentationSection s rels hrel hs hker) (presentationSection_fst s rels hrel hs hker)
+    (presentationSection_generator s rels hrel hs hker)
+end GroupRingTopology.Cayley
+namespace GroupRingTopology.Attachment
+open Set Metric Topology
+universe u v w z
+variable {G : Type u} [Group G]
+variable {X : Type v} [TopologicalSpace X] [MulAction G X] [ContinuousConstSMul G X]
+variable {Y : Type w} [TopologicalSpace Y] [MulAction G Y] [ContinuousConstSMul G Y]
+variable {ι : Type z} {n : ℕ} (a : ι → C(Sphere n,X))
+
+/-- Fill one disk per orbit and translate the fillings, preserving the action. -/
+lemma exists_equivariant_extension (f : C(X,Y))
+    (hf : ∀ (g : G) x, f (g • x) = g • f x) (hY : Cellular.SphereFillable Y) :
+    ∃ F : C(Space (equivariantFamily (G := G) a),Y),
+      (∀ x, F (base _ x) = f x) ∧ (∀ (g : G) x, F (g • x) = g • F x) := by
+  choose e he using fun i => hY n (f.comp (a i))
+  let b : FreeIndex G ι → C(Disk n,Y) := fun i =>
+    ⟨fun d => i.1 • e i.2 d,(continuous_const_smul i.1).comp (e i.2).continuous⟩
+  have hb (i : FreeIndex G ι) (x : Sphere n) :
+      b i (boundary n x) = f (equivariantFamily a i x) := by
+    change i.1 • e i.2 (Cellular.boundary n x) = f (i.1 • a i.2 x)
+    rw [he,hf]
+    rfl
+  refine ⟨lift _ f b hb,fun _ => rfl,?_⟩
+  intro g x
+  cases x with
+  | inl x => exact hf g x
+  | inr p => exact (mul_smul g p.1.1 (e p.1.2 (interior n p.2)))
+
+/-- Finitely many free cell orbits preserve existence of a compact fundamental set. -/
+lemma compactFundamentalSet [Finite ι] (hX : Milnor.CompactFundamentalSet G (X := X)) :
+    Milnor.CompactFundamentalSet G (X := Space (equivariantFamily (G := G) a)) := by
+  let b := equivariantFamily (G := G) a
+  obtain ⟨K,hK,hcov⟩ := hX
+  let L : Set (Space b) := (base b '' K) ∪ ⋃ i : ι, Set.range (cell b ((1:G),i))
+  refine ⟨L,(hK.image (continuous_base b)).union (isCompact_iUnion (fun i =>
+    isCompact_range (cell b ((1:G),i)).continuous)),?_⟩
+  intro x
+  cases x with
+  | inl x =>
+    obtain ⟨g,y,hy,rfl⟩ := hcov x
+    exact ⟨g,base b y,Or.inl ⟨y,hy,rfl⟩,rfl⟩
+  | inr p =>
+    refine ⟨p.1.1,cell b ((1:G),p.1.2) (interior n p.2),?_,?_⟩
+    · exact Or.inr (Set.mem_iUnion.mpr ⟨p.1.2,Set.mem_range_self _⟩)
+    · erw [smul_cell _ (equivariantFamily_smul a)]
+      change Sum.inr p = cell b (p.1.1*1,p.1.2) (interior n p.2)
+      erw [mul_one,cell_interior]
+      rfl
+end GroupRingTopology.Attachment
+
+namespace GroupRingTopology.Milnor
+open Set Metric Topology Attachment
+universe u
+variable {G : Type u} [Group G] [TopologicalSpace G] [DiscreteTopology G]
+variable {A : Type u} (s : A → G)
+
+omit [DiscreteTopology G] in
+lemma group_compactFundamentalSet : CompactFundamentalSet G (X := G) := by
+  refine ⟨{1},isCompact_singleton,?_⟩
+  intro g
+  exact ⟨g,1,Set.mem_singleton _,by simp only [smul_eq_mul,mul_one]⟩
+
+lemma graph_compactFundamentalSet [Finite A] : CompactFundamentalSet G (X := Cayley.Graph s) :=
+  Attachment.compactFundamentalSet (Cayley.attaching s) group_compactFundamentalSet
+
+variable (rels : Set (FreeGroup A)) (hrel : ∀ r ∈ rels, FreeGroup.lift s r = 1)
+lemma presentation_compactFundamentalSet [Finite A] (hrels : rels.Finite) :
+    CompactFundamentalSet G (X := Cayley.PresentationCover s rels hrel) := by
+  let := hrels.to_subtype
+  exact Attachment.compactFundamentalSet (Cayley.relatorAttaching s rels hrel)
+    (graph_compactFundamentalSet s)
+
+lemma presentation_equivariant_map :
+    ∃ f : C(Cayley.PresentationCover s rels hrel,Space G),
+      ∀ (g : G) x, f (g • x) = g • f x := by
+  let f₀ : C(G,Space G) := ⟨fun g => g • vertex (0,1),continuous_of_discreteTopology⟩
+  have hf₀ (g h : G) : f₀ (g • h) = g • f₀ h := mul_smul g h _
+  obtain ⟨f₁,_,hf₁⟩ := Attachment.exists_equivariant_extension (Cayley.attaching s) f₀ hf₀
+    (sphereFillable (1:G))
+  obtain ⟨f₂,_,hf₂⟩ := Attachment.exists_equivariant_extension (Cayley.relatorAttaching s rels hrel)
+    f₁ hf₁ (sphereFillable (1:G))
+  exact ⟨f₂,hf₂⟩
+
+include hrel in
+/-- Finite presentability supplies a coherent group section in ONE Milnor stage.
+This is genuine low-dimensional control, not a simply-connected-stage assumption. -/
+lemma exists_stage_section [Finite A] (hrels : rels.Finite)
+    (hs : Function.Surjective (FreeGroup.lift s))
+    (hker : (FreeGroup.lift s).ker = Subgroup.normalClosure rels) :
+    ∃ (S : Shapes G) (x : Stage G S) (τ : G →* PathExtension.Extension G x), ∀ g, (τ g).1 = g := by
+  obtain ⟨f,hf⟩ := presentation_equivariant_map s rels hrel
+  obtain ⟨S,hS⟩ := equivariant_controlled G (presentation_compactFundamentalSet s rels hrel hrels) f hf
+  let F := factorStage G f S hS
+  have hF : ∀ (g : G) x, F (g • x) = g • F x := factorStage_smul G f S hS hf
+  let x := Cayley.presentationBase s rels hrel (Cayley.vertex s 1)
+  let τ := (PathExtension.map F hF x).comp (Cayley.presentationSection s rels hrel hs hker)
+  refine ⟨S,F x,τ,?_⟩
+  intro g
+  exact Cayley.presentationSection_fst s rels hrel hs hker g
+end GroupRingTopology.Milnor
+
+namespace GroupRingTopology.Attachment
+open Set Metric Topology
+variable {X : Type*} [TopologicalSpace X] {ι : Type*} {n : ℕ}
+variable (a : ι → C(Sphere n,X))
+
+def cellCenter (i : ι) : Space a := openCell a i ⟨0,by simp⟩
+def punctured : Set (Space a) := (Set.range (cellCenter a))ᶜ
+
+def rawCoordinate : Space a → (Fin n → ℝ)
+  | Sum.inl _ => 0 | Sum.inr p => p.2.1
+
+lemma base_mem_punctured (x : X) : base a x ∈ punctured a := by
+  rintro ⟨i,h⟩
+  cases h
+
+lemma cell_mem_punctured (i : ι) (d : Disk n) : cell a i d ∈ punctured a ↔ d.1 ≠ 0 := by
+  classical
+  constructor
+  · intro hd hzero
+    apply hd
+    refine ⟨i,?_⟩
+    have heq : d = interior n ⟨0,by simp⟩ := Subtype.ext hzero
+    rw [heq,cell_interior]
+    rfl
+  · intro hzero
+    rintro ⟨j,hj⟩
+    by_cases h : d.1 ∈ ball (0 : Fin n → ℝ) 1
+    · have heq : d = interior n ⟨d.1,h⟩ := rfl
+      rw [heq,cell_interior] at hj
+      exact hzero (congrArg (rawCoordinate a) hj).symm
+    · let s : Sphere n := ⟨d.1,by
+        have hd := d.2
+        simp only [mem_sphere,mem_ball,mem_closedBall] at *
+        exact le_antisymm hd (le_of_not_gt h)⟩
+      have heq : d = boundary n s := rfl
+      rw [heq,cell_boundary] at hj
+      cases hj
+
+lemma punctured_open : IsOpen (punctured a) := by
+  change IsOpen (Set.range (cellCenter a))ᶜ
+  rw [isOpen_compl_iff]
+  rw [isClosed_iff]
+  constructor
+  · have h : base a ⁻¹' Set.range (cellCenter a) = ∅ := by
+      ext x
+      simp only [mem_preimage,mem_empty_iff_false,iff_false]
+      exact base_mem_punctured a x
+    rw [h]
+    exact isClosed_empty
+  · intro i
+    have h : cell a i ⁻¹' Set.range (cellCenter a) = {d : Disk n | d.1 = 0} := by
+      ext d
+      exact not_iff_not.mp (cell_mem_punctured a i d)
+    rw [h]
+    exact isClosed_eq continuous_subtype_val continuous_const
+
+lemma continuous_punctured {Y : Type*} [TopologicalSpace Y] (F : punctured a → Y)
+    (hb : Continuous (fun x : X => F ⟨base a x,base_mem_punctured a x⟩))
+    (hc : ∀ i, Continuous (fun d : {d : Disk n // d.1 ≠ 0} =>
+      F ⟨cell a i d.1,(cell_mem_punctured a i d.1).mpr d.2⟩)) : Continuous F := by
+  let q := quotient a
+  have hq : IsQuotientMap q := ⟨⟨rfl⟩,quotient_surjective a⟩
+  have hp := hq.restrictPreimage_isOpen (punctured_open a)
+  apply hp.continuous_iff.mpr
+  apply continuous_iff_continuousAt.mpr
+  rintro ⟨z,hz⟩
+  cases z with
+  | inl x =>
+    let e : X → q ⁻¹' punctured a := fun x => ⟨Sum.inl x,base_mem_punctured a x⟩
+    have he : IsOpenEmbedding e := by
+      have hi : IsOpenEmbedding (Sum.inl : X → X ⊕ (Σ _ : ι, Disk n)) := .inl
+      exact ⟨hi.isEmbedding.codRestrict (q ⁻¹' punctured a) (fun x => base_mem_punctured a x),by
+        have hr : Set.range e = Subtype.val ⁻¹' Set.range Sum.inl := by
+          ext z
+          simp only [mem_range,mem_preimage,e]
+          constructor
+          · rintro ⟨x,rfl⟩; exact ⟨x,rfl⟩
+          · rintro ⟨x,hx⟩; exact ⟨x,Subtype.ext hx⟩
+        rw [hr]
+        exact hi.isOpen_range.preimage continuous_subtype_val⟩
+    exact (he.continuousAt_iff (g := F ∘ (punctured a).restrictPreimage q)).mp (hb.continuousAt (x := x))
+  | inr p =>
+    rcases p with ⟨i,d⟩
+    have hd : d.1 ≠ 0 := (cell_mem_punctured a i d).mp hz
+    let e : {d : Disk n // d.1 ≠ 0} → q ⁻¹' punctured a :=
+      fun d => ⟨Sum.inr ⟨i,d.1⟩,(cell_mem_punctured a i d.1).mpr d.2⟩
+    have he : IsOpenEmbedding e := by
+      have hi : IsOpenEmbedding (fun d : Disk n => (Sum.inr ⟨i,d⟩ : X ⊕ (Σ _ : ι, Disk n))) :=
+        IsOpenEmbedding.inr.comp IsOpenEmbedding.sigmaMk
+      exact hi.restrict (fun d hd => (cell_mem_punctured a i d).mpr hd)
+        (isClosed_eq continuous_subtype_val continuous_const).isOpen_compl
+    have hc' : ContinuousAt ((F ∘ (punctured a).restrictPreimage q) ∘ e) ⟨d,hd⟩ := by
+      change ContinuousAt (fun d : {d : Disk n // d.1 ≠ 0} =>
+        F ⟨cell a i d.1,(cell_mem_punctured a i d.1).mpr d.2⟩) ⟨d,hd⟩
+      exact (hc i).continuousAt
+    have result := (he.continuousAt_iff (g := F ∘ (punctured a).restrictPreimage q)).mp hc'
+    exact result
+
+abbrev PuncturedDisk (n : ℕ) := {d : Disk n // d.1 ≠ 0}
+
+def puncturedBoundary (x : Sphere n) : PuncturedDisk n :=
+  ⟨boundary n x,by
+    intro h
+    change x.1 = 0 at h
+    have hx := x.2
+    simp only [mem_sphere,dist_zero_right] at hx
+    rw [h,norm_zero] at hx
+    norm_num at hx⟩
+
+def puncturedCell (i : ι) (d : PuncturedDisk n) : punctured a :=
+  ⟨cell a i d.1,(cell_mem_punctured a i d.1).mpr d.2⟩
+
+def puncturedBase (x : X) : punctured a := ⟨base a x,base_mem_punctured a x⟩
+
+lemma puncturedCell_boundary (i : ι) (x : Sphere n) :
+    puncturedCell a i (puncturedBoundary x) = puncturedBase a (a i x) :=
+  Subtype.ext (cell_boundary a i x)
+
+noncomputable def puncturedLift {Y : Type*} [TopologicalSpace Y] (f : C(X,Y))
+    (g : ι → C(PuncturedDisk n,Y))
+    (h : ∀ i x, g i (puncturedBoundary x) = f (a i x)) : C(punctured a,Y) := by
+  classical
+  let F : punctured a → Y := fun z => match heq : z.1 with
+    | Sum.inl x => f x
+    | Sum.inr p => g p.1 ⟨interior n p.2,by
+        exact (cell_mem_punctured a p.1 (interior n p.2)).mp
+          (by simpa only [cell_interior,← heq] using z.2)⟩
+  have hcell (i : ι) : F ∘ puncturedCell a i = g i := by
+    funext d
+    by_cases hd : d.1.1 ∈ ball (0 : Fin n → ℝ) 1
+    · have heq : d.1 = interior n ⟨d.1.1,hd⟩ := rfl
+      change F ⟨cell a i d.1,_⟩ = g i d
+      have hc : cell a i d.1 = Sum.inr ⟨i,⟨d.1.1,hd⟩⟩ := (congrArg (cell a i) heq).trans (cell_interior a i ⟨d.1.1,hd⟩)
+      simp only [hc,F]
+      exact congrArg (g i) (Subtype.ext (Subtype.ext rfl))
+    · let x : Sphere n := ⟨d.1.1,by
+        have hm := d.1.2
+        simp only [mem_closedBall,mem_ball,mem_sphere] at *
+        exact le_antisymm hm (le_of_not_gt hd)⟩
+      have heq : d.1 = boundary n x := rfl
+      change F ⟨cell a i d.1,_⟩ = g i d
+      have hc : cell a i d.1 = base a (a i x) := (congrArg (cell a i) heq).trans (cell_boundary a i x)
+      simp only [hc,base,F]
+      exact (h i x).symm.trans (congrArg (g i) (Subtype.ext (Subtype.ext rfl)))
+  exact ⟨F,continuous_punctured a F f.continuous (fun i => by
+    change Continuous (F ∘ puncturedCell a i)
+    rw [hcell]
+    exact (g i).continuous)⟩
+
+@[simp] lemma puncturedLift_base {Y : Type*} [TopologicalSpace Y] (f : C(X,Y))
+    (g : ι → C(PuncturedDisk n,Y))
+    (h : ∀ i x, g i (puncturedBoundary x) = f (a i x)) (x : X) :
+    puncturedLift a f g h (puncturedBase a x) = f x := rfl
+
+@[simp] lemma puncturedLift_cell {Y : Type*} [TopologicalSpace Y] (f : C(X,Y))
+    (g : ι → C(PuncturedDisk n,Y))
+    (h : ∀ i x, g i (puncturedBoundary x) = f (a i x))
+    (i : ι) (d : PuncturedDisk n) :
+    puncturedLift a f g h (puncturedCell a i d) = g i d := by
+  classical
+  by_cases hd : d.1.1 ∈ ball (0 : Fin n → ℝ) 1
+  · have heq : d.1 = interior n ⟨d.1.1,hd⟩ := rfl
+    change puncturedLift a f g h ⟨cell a i d.1,_⟩ = _
+    have hc : cell a i d.1 = Sum.inr ⟨i,⟨d.1.1,hd⟩⟩ := (congrArg (cell a i) heq).trans (cell_interior a i ⟨d.1.1,hd⟩)
+    simp only [hc,puncturedLift,ContinuousMap.coe_mk]
+    exact congrArg (g i) (Subtype.ext (Subtype.ext rfl))
+  · let x : Sphere n := ⟨d.1.1,by
+      have hm := d.1.2
+      simp only [mem_closedBall,mem_ball,mem_sphere] at *
+      exact le_antisymm hm (le_of_not_gt hd)⟩
+    have hd : d = puncturedBoundary x := rfl
+    rw [hd,puncturedCell_boundary,puncturedLift_base,h]
+
+lemma punctured_surjective (z : punctured a) :
+    (∃ x, z = puncturedBase a x) ∨ ∃ i d, z = puncturedCell a i d := by
+  cases heq : z.1 with
+  | inl x => exact Or.inl ⟨x,Subtype.ext heq⟩
+  | inr p =>
+    have hd : p.2.1 ≠ 0 := (cell_mem_punctured a p.1 (interior n p.2)).mp
+      (by simpa only [cell_interior,← heq] using z.2)
+    exact Or.inr ⟨p.1,⟨interior n p.2,hd⟩,Subtype.ext (heq.trans (cell_interior a p.1 p.2).symm)⟩
+
+/-- Radial projection of a nonzero disk point onto its sphere. -/
+def radialSphere : C(PuncturedDisk n,Sphere n) := by
+  have hm (d : PuncturedDisk n) : ‖d.1.1‖⁻¹ • d.1.1 ∈ sphere (0 : Fin n → ℝ) 1 := by
+    simp only [mem_sphere,dist_zero_right,norm_smul,Real.norm_eq_abs,abs_inv,
+      abs_norm,inv_mul_cancel₀ (norm_ne_zero_iff.mpr d.2)]
+  refine ⟨fun d => ⟨‖d.1.1‖⁻¹ • d.1.1,hm d⟩,?_⟩
+  exact (((continuous_subtype_val.comp continuous_subtype_val).norm.inv₀
+    (fun d : PuncturedDisk n => norm_ne_zero_iff.mpr d.2)).smul
+      (continuous_subtype_val.comp continuous_subtype_val)).subtype_mk hm
+
+@[simp] lemma radialSphere_boundary (x : Sphere n) : radialSphere (puncturedBoundary x) = x := by
+  apply Subtype.ext
+  have hx : ‖x.1‖ = 1 := by simpa only [mem_sphere,dist_zero_right] using x.2
+  change ‖x.1‖⁻¹ • x.1 = x.1
+  rw [hx,inv_one,one_smul]
+
+/-- Radial straight-line deformation, in the full disk. -/
+def radialDisk : C(unitInterval × PuncturedDisk n,Disk n) := by
+  let f (p : unitInterval × PuncturedDisk n) :=
+    (1-(p.1:ℝ)) • p.2.1.1 + (p.1:ℝ) • (radialSphere p.2).1
+  have hm (p : unitInterval × PuncturedDisk n) : f p ∈ closedBall (0 : Fin n → ℝ) 1 :=
+    (convex_closedBall (0 : Fin n → ℝ) 1) p.2.1.2
+      (sphere_subset_closedBall (radialSphere p.2).2)
+      (sub_nonneg.mpr p.1.2.2) p.1.2.1 (by ring)
+  have hc : Continuous f :=
+    ((continuous_const.sub (continuous_subtype_val.comp continuous_fst)).smul
+      (continuous_subtype_val.comp (continuous_subtype_val.comp continuous_snd))).add
+      ((continuous_subtype_val.comp continuous_fst).smul
+        (continuous_subtype_val.comp (radialSphere.continuous.comp continuous_snd)))
+  exact ⟨fun p => ⟨f p,hm p⟩,hc.subtype_mk hm⟩
+
+@[simp] lemma radialDisk_zero (d : PuncturedDisk n) : radialDisk (0,d) = d.1 := by
+  apply Subtype.ext
+  simp [radialDisk]
+@[simp] lemma radialDisk_one (d : PuncturedDisk n) : radialDisk (1,d) = boundary n (radialSphere d) := by
+  apply Subtype.ext
+  simp [radialDisk,boundary]
+@[simp] lemma radialDisk_boundary (t : unitInterval) (x : Sphere n) :
+    radialDisk (t,puncturedBoundary x) = boundary n x := by
+  apply Subtype.ext
+  simp only [radialDisk,ContinuousMap.coe_mk,radialSphere_boundary]
+  change (1-(t:ℝ)) • x.1 + (t:ℝ) • x.1 = x.1
+  rw [← add_smul,sub_add_cancel,one_smul]
+
+end GroupRingTopology.Attachment
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/GroupRing/CellHEP.lean b/lean/OAI/Algebra/GroupRing/CellHEP.lean
new file mode 100644
index 0000000000000000000000000000000000000000..1f180e90a02a3c794e5386d93083c3f899c45764
--- /dev/null
+++ b/lean/OAI/Algebra/GroupRing/CellHEP.lean
@@ -0,0 +1,153 @@
+import Mathlib
+import OAI.Algebra.GroupRing.PartialLift
+
+namespace OAI
+
+
+
+section
+namespace TorsionFreeZeroDivisors.CellHEP
+open Set Metric Topology GroupRingTopology GroupRingTopology.Cellular
+open scoped unitInterval
+noncomputable section
+variable {n : ℕ}
+abbrev Cylinder (n : ℕ) := unitInterval × Disk n
+def denom (q : Cylinder n) : ℝ := max (2-q.1.1) (2*‖q.2.1‖)
+lemma denom_pos (q : Cylinder n) : 0<denom q :=
+  lt_of_lt_of_le (by linarith [q.1.2.2] : 0<2-q.1.1) (le_max_left _ _)
+lemma denom_le_two (q : Cylinder n) : denom q ≤ 2 := by
+  have h := mem_closedBall_zero_iff.mp q.2.2
+  exact max_le (by linarith [q.1.2.1]) (by linarith)
+def scale (q : Cylinder n) : ℝ := 2/denom q
+lemma scale_nonneg (q : Cylinder n) : 0 ≤ scale q := div_nonneg (by norm_num) (denom_pos q).le
+lemma scale_ge_one (q : Cylinder n) : 1 ≤ scale q := by
+  rw [scale,le_div_iff₀ (denom_pos q)]
+  simpa using denom_le_two q
+lemma scale_time (q : Cylinder n) : scale q*(2-q.1.1) ≤ 2 := by
+  dsimp [scale]
+  rw [div_mul_eq_mul_div,div_le_iff₀ (denom_pos q)]
+  have h : 2-q.1.1 ≤ denom q := le_max_left _ _
+  nlinarith
+lemma scale_norm (q : Cylinder n) : scale q*‖q.2.1‖ ≤ 1 := by
+  dsimp [scale]
+  rw [div_mul_eq_mul_div,div_le_iff₀ (denom_pos q)]
+  simpa only [one_mul,denom] using le_max_right (2-q.1.1) (2*‖q.2.1‖)
+def retract (q : Cylinder n) : Cylinder n :=
+  (⟨2-scale q*(2-q.1.1),by
+      constructor
+      · linarith [scale_time q]
+      · have h := mul_le_mul_of_nonneg_right (scale_ge_one q) (by linarith [q.1.2.2] : 0 ≤ 2-q.1.1)
+        linarith [q.1.2.2]⟩,
+   ⟨scale q • q.2.1,by
+      rw [mem_closedBall_zero_iff,norm_smul,Real.norm_eq_abs,abs_of_nonneg (scale_nonneg q)]
+      exact scale_norm q⟩)
+lemma continuous_retract : Continuous (@retract n) := by
+  have hd : Continuous (@denom n) := by unfold denom;fun_prop
+  have hs : Continuous (@scale n) := continuous_const.div hd (fun q=>(denom_pos q).ne')
+  exact (Continuous.subtype_mk ((continuous_const.sub (hs.mul
+    (continuous_const.sub (continuous_subtype_val.comp continuous_fst))))) _).prodMk
+    (Continuous.subtype_mk (hs.smul (continuous_subtype_val.comp continuous_snd)) _)
+def Rim (n : ℕ) : Set (Cylinder n) := {q | q.1=0 ∨ q.2.1 ∈ sphere 0 1}
+lemma retract_mem (q : Cylinder n) : retract q∈Rim n := by
+  rcases le_total (2*‖q.2.1‖) (2-q.1.1) with h|h
+  · left
+    apply Subtype.ext
+    change 2-scale q*(2-q.1.1)=0
+    have he : denom q=2-q.1.1 := max_eq_left h
+    rw [scale,←he,div_mul_cancel₀ _ (denom_pos q).ne']
+    ring
+  · right
+    rw [mem_sphere_zero_iff_norm]
+    change ‖scale q • q.2.1‖=1
+    rw [norm_smul,Real.norm_eq_abs,abs_of_nonneg (scale_nonneg q)]
+    have he : denom q=2*‖q.2.1‖ := max_eq_right h
+    rw [scale,div_mul_eq_mul_div]
+    change (2*‖q.2.1‖)/denom q=1
+    rw [←he,div_self (denom_pos q).ne']
+lemma retract_eq (q : Cylinder n) (h : q∈Rim n) : retract q=q := by
+  have hm : denom q=2 := by
+    apply le_antisymm (denom_le_two q)
+    rcases h with h|h
+    · have ht : q.1.1=0 := congrArg Subtype.val h
+      simp [denom,ht]
+    · have hn : ‖q.2.1‖=1 := mem_sphere_zero_iff_norm.mp h
+      simp [denom,hn]
+  have hs : scale q=1 := by simp [scale,hm]
+  apply Prod.ext
+  · apply Subtype.ext
+    change 2-scale q*(2-q.1.1)=q.1.1
+    rw [hs];ring
+  · apply Subtype.ext
+    change scale q • q.2.1=q.2.1
+    rw [hs,one_smul]
+
+def retraction : C(Cylinder n,Rim n) := ⟨fun q=>⟨retract q,retract_mem q⟩,
+  continuous_retract.subtype_mk _⟩
+variable {Y : Type*} [TopologicalSpace Y]
+def face (n : ℕ) : Bool → Set (Rim n)
+  | false => {z | z.1.1=0}
+  | true => {z | z.1.2.1∈sphere 0 1}
+lemma face_closed (b : Bool) : IsClosed (face n b) := by
+  cases b
+  · exact isClosed_eq (continuous_fst.comp continuous_subtype_val) continuous_const
+  · exact isClosed_sphere.preimage (continuous_subtype_val.comp
+      (continuous_snd.comp continuous_subtype_val))
+lemma face_cover : ⋃b,face n b=univ := by
+  apply eq_univ_of_forall
+  rintro ⟨q,hq⟩
+  rcases hq with hq|hq
+  · exact mem_iUnion.mpr ⟨false,hq⟩
+  · exact mem_iUnion.mpr ⟨true,hq⟩
+variable (f : C(Disk n,Y)) (H : C(unitInterval × Sphere n,Y))
+  (h : ∀x,H (0,x)=f (boundary n x))
+def faceMap : ∀ b : Bool,C(face n b,Y)
+  | false => ⟨fun z=>f z.1.1.2,
+      f.continuous.comp (continuous_snd.comp (continuous_subtype_val.comp continuous_subtype_val))⟩
+  | true => ⟨fun z=>H (z.1.1.1,⟨z.1.1.2.1,z.2⟩),H.continuous.comp
+      ((continuous_fst.comp (continuous_subtype_val.comp continuous_subtype_val)).prodMk
+        ((continuous_subtype_val.comp (continuous_snd.comp
+          (continuous_subtype_val.comp continuous_subtype_val))).subtype_mk _))⟩
+include h in
+lemma faceMap_compat (b c : Bool) (z : Rim n) (hb : z∈face n b) (hc : z∈face n c) :
+    faceMap f H b ⟨z,hb⟩=faceMap f H c ⟨z,hc⟩ := by
+  have cross (hb : z∈face n false) (hc : z∈face n true) :
+      faceMap f H false ⟨z,hb⟩=faceMap f H true ⟨z,hc⟩ := by
+    change f z.1.2=H (z.1.1,⟨z.1.2.1,hc⟩)
+    change z.1.1=0 at hb
+    rw [hb,h]
+    rfl
+  cases b <;> cases c
+  · rfl
+  · exact cross hb hc
+  · exact (cross hc hb).symm
+  · rfl
+def rimMap : C(Rim n,Y) := ⟨Set.liftCover (face n) (fun b=>faceMap f H b)
+  (faceMap_compat f H h) face_cover,
+  continuous_liftCover _ _ _ _ face_closed⟩
+lemma rimMap_face (b : Bool) (z : face n b) :
+    rimMap f H h z.1=faceMap f H b z := by
+  apply Set.liftCover_coe (S:=face n) (f:=fun b=>faceMap f H b)
+    (hf:=faceMap_compat f H h) (hS:=face_cover)
+/-- Literal homotopy extension for a cell, with no fibrancy premise. -/
+def extension : C(Cylinder n,Y) := (rimMap f H h).comp retraction
+lemma extension_zero (x : Disk n) : extension f H h (0,x)=f x := by
+  have hr : retract (0,x)=(0,x) := retract_eq _ (Or.inl rfl)
+  change rimMap f H h ⟨retract (0,x),retract_mem (0,x)⟩=f x
+  simp only [hr]
+  exact rimMap_face f H h false ⟨⟨(0,x),Or.inl rfl⟩,rfl⟩
+lemma extension_boundary (t : unitInterval) (x : Sphere n) :
+    extension f H h (t,boundary n x)=H (t,x) := by
+  have hr : retract (t,boundary n x)=(t,boundary n x) := retract_eq _ (Or.inr x.2)
+  change rimMap f H h ⟨retract (t,boundary n x),retract_mem (t,boundary n x)⟩=H (t,x)
+  simp only [hr]
+  exact rimMap_face f H h true ⟨⟨(t,boundary n x),Or.inr x.2⟩,x.2⟩
+
+end
+end TorsionFreeZeroDivisors.CellHEP
+
+
+end
+
+
+
+end OAI
diff --git a/lean/OAI/Algebra/GroupRing/CellModule.lean b/lean/OAI/Algebra/GroupRing/CellModule.lean
new file mode 100644
index 0000000000000000000000000000000000000000..bc96492ab388f1d3f6647dc28243a75f1c963c7c
--- /dev/null
+++ b/lean/OAI/Algebra/GroupRing/CellModule.lean
@@ -0,0 +1,84 @@
+import Mathlib
+
+namespace OAI
+
+
+
+section
+namespace TorsionFreeZeroDivisors.CellModule
+open scoped Classical BigOperators
+noncomputable section
+variable {G I : Type} [Group G]
+abbrev Module (G I : Type) := G×I→₀ℤ
+def translate (g : G) : Module G I ≃+ Module G I :=
+  Finsupp.domCongr (Equiv.prodCongr (Equiv.mulLeft g) (Equiv.refl I))
+@[simp] lemma translate_apply (g : G) (x : Module G I) (p : G×I) :
+    translate g x p=x (g⁻¹*p.1,p.2) := rfl
+@[simp] lemma translate_single (g : G) (p : G×I) (z : ℤ) :
+    translate g (Finsupp.single p z)=Finsupp.single (g*p.1,p.2) z := by
+  simp only [translate,Finsupp.domCongr_apply,Finsupp.equivMapDomain_single,
+    Equiv.prodCongr_apply]
+  rfl
+@[simp] lemma translate_one (x : Module G I) : translate 1 x=x := by ext p;simp
+lemma translate_mul (g h : G) (x : Module G I) : translate (g*h) x=translate g (translate h x) := by
+  ext p;simp only [translate_apply,mul_inv_rev,mul_assoc]
+def action : G→*MulAut (Multiplicative (Module G I)) where
+  toFun g := (translate g).toMultiplicative
+  map_one' := by apply MulEquiv.ext;intro x;exact translate_one x
+  map_mul' g h := by apply MulEquiv.ext;intro x;exact translate_mul g h x
+variable (q : FreeGroup I→*G)
+abbrev Crossed := SemidirectProduct (Multiplicative (Module G I)) G (action (I:=I))
+def lift : FreeGroup I→*Crossed (G:=G) (I:=I) :=
+  FreeGroup.lift (fun i=>⟨Multiplicative.ofAdd (Finsupp.single (1,i) 1),q (FreeGroup.of i)⟩)
+lemma lift_right (w : FreeGroup I) : (lift q w).right=q w := by
+  have h : (SemidirectProduct.rightHom.comp (lift q))=q := by
+    ext i;simp [lift]
+  exact DFunLike.congr_fun h w
+def fox (w : FreeGroup I) : Module G I := Multiplicative.toAdd (lift q w).left
+@[simp] lemma fox_one : fox q 1=0 := rfl
+@[simp] lemma fox_of (i : I) : fox q (FreeGroup.of i)=Finsupp.single (1,i) 1 := by
+  simp [fox,lift]
+lemma fox_mul (w u : FreeGroup I) : fox q (w*u)=fox q w+translate (q w) (fox q u) := by
+  simp only [fox,map_mul,SemidirectProduct.mul_left,lift_right]
+  rfl
+lemma fox_inv (w : FreeGroup I) : fox q w⁻¹= -translate (q w)⁻¹ (fox q w) := by
+  apply (translate (q w)).injective
+  have h := fox_mul q w w⁻¹
+  rw [mul_inv_cancel,fox_one] at h
+  rw [map_neg,←translate_mul,mul_inv_cancel,translate_one]
+  exact eq_neg_of_add_eq_zero_right h.symm
+
+def boundary : Module G I→+Module G PUnit :=
+  Finsupp.liftAddHom (fun p=>
+    (Finsupp.singleAddHom (p.1*q (FreeGroup.of p.2),PUnit.unit))-
+    (Finsupp.singleAddHom (p.1,PUnit.unit)))
+@[simp] lemma boundary_single (p : G×I) (z : ℤ) :
+    boundary q (Finsupp.single p z)=Finsupp.single (p.1*q (FreeGroup.of p.2),PUnit.unit) z-
+      Finsupp.single (p.1,PUnit.unit) z := by
+  simp only [boundary,Finsupp.liftAddHom_apply_single,AddMonoidHom.sub_apply,Finsupp.singleAddHom_apply]
+lemma boundary_translate (g : G) (x : Module G I) :
+    boundary q (translate g x)=translate g (boundary q x) := by
+  induction x using Finsupp.induction_linear with
+  | zero=>simp
+  | add a b ha hb=>simp only [map_add,ha,hb]
+  | single p z=>simp only [translate_single,boundary_single,map_sub,mul_assoc]
+lemma boundary_fox (w : FreeGroup I) :
+    boundary q (fox q w)=Finsupp.single (q w,PUnit.unit) 1-Finsupp.single (1,PUnit.unit) 1 := by
+  induction w using FreeGroup.induction_on with
+  | one=>simp
+  | of i=>simp [boundary_single]
+  | inv_of i _=>
+    rw [fox_inv,fox_of,map_neg,boundary_translate,boundary_single]
+    simp only [one_mul]
+    simp only [map_sub,translate_single,inv_mul_cancel,mul_one,map_inv,neg_sub]
+  | mul w u hw hu=>
+    rw [fox_mul,map_add,boundary_translate,hw,hu]
+    simp only [map_sub,translate_single,mul_one,map_mul]
+    abel
+end
+end TorsionFreeZeroDivisors.CellModule
+
+end
+
+
+end OAI
diff --git a/lean/OAI/Algebra/GroupRing/CellNorm.lean b/lean/OAI/Algebra/GroupRing/CellNorm.lean
new file mode 100644
index 0000000000000000000000000000000000000000..aa07936a79afacbd83b848b340d731b470afeadb
--- /dev/null
+++ b/lean/OAI/Algebra/GroupRing/CellNorm.lean
@@ -0,0 +1,83 @@
+import Mathlib
+import OAI.Algebra.GroupRing.CellModule
+import OAI.Algebra.GroupRing.FreeActionNorm
+
+namespace OAI
+
+
+
+section
+namespace TorsionFreeZeroDivisors.CellNorm
+open scoped Classical BigOperators
+open CellModule
+noncomputable section
+variable {H G I : Type} [CommGroup H] [Group G] [Fintype H]
+  (φ : H→*G) (hφ : Function.Injective φ)
+def norm (x : CellModule.Module G I) : CellModule.Module G I := ∑h:H,translate (φ h) x
+lemma norm_add (x y : CellModule.Module G I) : norm φ (x+y)=norm φ x+norm φ y := by
+  simp only [norm,map_add,Finset.sum_add_distrib]
+lemma norm_sub (x y : CellModule.Module G I) : norm φ (x-y)=norm φ x-norm φ y := by
+  simp only [norm,map_sub,Finset.sum_sub_distrib]
+lemma equivariance (J : Type) (f : CellModule.Module G I→+CellModule.Module G J)
+    (hf : ∀g x,f (translate g x)=translate g (f x)) (x : CellModule.Module G I) :
+    f (norm φ x)=norm φ (f x) := by
+  simp only [norm,map_sum,hf]
+@[instance_reducible] def moduleAction : MulAction H (G×I) where
+  smul h p := (φ h*p.1,p.2)
+  one_smul p := by change (φ 1*p.1,p.2)=p; simp
+  mul_smul h k p := by change (φ (h*k)*p.1,p.2)=(φ h*(φ k*p.1),p.2); rw [map_mul,mul_assoc]
+include hφ in
+lemma invariant_norm (g : H) (hg : ∀h,h∈Subgroup.zpowers g) (x : CellModule.Module G I)
+    (hx : translate (φ g) x=x) : ∃y,norm φ y=x := by
+  let : MulAction H (G×I) := moduleAction φ
+  let : IsCancelSMul H (G×I) := {
+    right_cancel' h k p he := hφ (mul_right_cancel (congrArg Prod.fst he)) }
+  have hact (h : H) (y : CellModule.Module G I) : FreeActionNorm.act h y=translate (φ h) y := by
+    ext p
+    change y (φ h⁻¹*p.1,p.2)=y ((φ h)⁻¹*p.1,p.2)
+    rw [map_inv]
+  obtain ⟨y,hy⟩ := FreeActionNorm.invariant_norm g hg x ((hact g x).trans hx)
+  exact ⟨y,by simpa only [FreeActionNorm.norm,hact,norm] using hy⟩
+include hφ in
+lemma kernel_norm (g : H) (hg : ∀h,h∈Subgroup.zpowers g) (x : CellModule.Module G I)
+    (hx : norm φ x=0) : ∃y,translate (φ g) y-y=x := by
+  let : MulAction H (G×I) := moduleAction φ
+  let : IsCancelSMul H (G×I) := {
+    right_cancel' h k p he := hφ (mul_right_cancel (congrArg Prod.fst he)) }
+  have hact (h : H) (y : CellModule.Module G I) : FreeActionNorm.act h y=translate (φ h) y := by
+    ext p
+    change y (φ h⁻¹*p.1,p.2)=y ((φ h)⁻¹*p.1,p.2)
+    rw [map_inv]
+  have hn : FreeActionNorm.norm (H:=H) x=0 := by simpa only [FreeActionNorm.norm,hact,norm] using hx
+  obtain ⟨y,hy⟩ := FreeActionNorm.kernel_norm g hg x hn
+  exact ⟨y,by rw [hact] at hy;exact hy⟩
+
+def augmentation : CellModule.Module G I→+ℤ := Finsupp.liftAddHom (fun _=>AddMonoidHom.id ℤ)
+omit [Group G] in
+@[simp] lemma augmentation_single (p : G×I) (z : ℤ) : augmentation (Finsupp.single p z)=z := by simp [augmentation]
+lemma augmentation_translate (g : G) (x : CellModule.Module G I) : augmentation (translate g x)=augmentation x := by
+  induction x using Finsupp.induction_linear with
+  | zero=>simp
+  | add a b ha hb=>simp only [map_add,ha,hb]
+  | single p z=>simp only [translate_single,augmentation_single]
+lemma augmentation_norm (x : CellModule.Module G I) : augmentation (norm φ x)=(Fintype.card H:ℤ)*augmentation x := by
+  simp only [norm,map_sum,augmentation_translate,Finset.sum_const,Finset.card_univ,nsmul_eq_mul]
+lemma augmentation_boundary {A : Type} (q : FreeGroup A→*G) (x : CellModule.Module G A) :
+    augmentation (boundary q x)=0 := by
+  induction x using Finsupp.induction_linear with
+  | zero=>simp
+  | add a b ha hb=>simp only [map_add,ha,hb,add_zero]
+  | single p z=>simp only [boundary_single,map_sub,augmentation_single,sub_self]
+include hφ in
+lemma invariant_augmentation (g : H) (hg : ∀h,h∈Subgroup.zpowers g) (x : CellModule.Module G I)
+    (hx : translate (φ g) x=x) : (Fintype.card H:ℤ)∣augmentation x := by
+  obtain ⟨y,hy⟩ := invariant_norm φ hφ g hg x hx
+  exact ⟨augmentation y,by rw [←hy,augmentation_norm]⟩
+end
+end TorsionFreeZeroDivisors.CellNorm
+
+end
+
+
+
+end OAI
diff --git a/lean/OAI/Algebra/GroupRing/Cellular.lean b/lean/OAI/Algebra/GroupRing/Cellular.lean
new file mode 100644
index 0000000000000000000000000000000000000000..c5a005c6962d65f75f2d6338377003afeef66f45
--- /dev/null
+++ b/lean/OAI/Algebra/GroupRing/Cellular.lean
@@ -0,0 +1,426 @@
+import Mathlib
+import OAI.Algebra.GroupRing.Simplicial
+
+namespace OAI
+
+noncomputable section
+
+open Set Metric Topology BigOperators
+open Set Metric Topology
+
+namespace GroupRingTopology.Cellular
+universe u
+variable {X : Type u} [TopologicalSpace X] [T2Space X]
+variable {C : Set X} [CWComplex C]
+
+omit [T2Space X] in
+/-- Closure finiteness in terms of a single finite list of open cells. -/
+lemma closedCell_subset_finite_openCells (n : ℕ) (i : RelCWComplex.cell C n) :
+    ∃ I : Finset (Σ m, RelCWComplex.cell C m),
+      CWComplex.closedCell n i ⊆ ⋃ p ∈ I, CWComplex.openCell p.1 p.2 := by
+  classical
+  obtain ⟨J,hJ⟩ := CWComplex.cellFrontier_subset_finite_openCell n i
+  refine ⟨insert ⟨n,i⟩ ((Finset.range n).sigma J),?_⟩
+  intro x hx
+  rw [← CWComplex.cellFrontier_union_openCell_eq_closedCell] at hx
+  rcases hx with hx | hx
+  swap
+  · exact Set.mem_iUnion.mpr ⟨⟨n,i⟩,Set.mem_iUnion.mpr ⟨Finset.mem_insert_self _ _,hx⟩⟩
+  · have hxx := hJ hx
+    simp only [Set.mem_iUnion] at hxx
+    obtain ⟨m,hm,j,hj,hx⟩ := hxx
+    exact Set.mem_iUnion.mpr ⟨⟨m,j⟩,Set.mem_iUnion.mpr
+      ⟨Finset.mem_insert_of_mem (by simp only [Finset.mem_sigma,Finset.mem_range]; exact ⟨hm,hj⟩),hx⟩⟩
+
+/-- Any selection of at most one point from each open cell has all its subsets
+closed. This is the closure-finite weak-topology argument behind compactness. -/
+lemma cellSelection_closed {I : Type u} (c : I → Σ n, RelCWComplex.cell C n)
+    (hc : Function.Injective c) (x : I → X)
+    (hx : ∀ i, x i ∈ CWComplex.openCell (c i).1 (c i).2) (S : Set X)
+    (hS : S ⊆ Set.range x) : IsClosed S := by
+  apply (CWComplex.closed C S ?_).mpr
+  · intro n j
+    obtain ⟨J,hJ⟩ := closedCell_subset_finite_openCells n j
+    have hfinite : (S ∩ CWComplex.closedCell n j).Finite := by
+      have hcpre : (c ⁻¹' (J : Set (Σ n, RelCWComplex.cell C n))).Finite :=
+        J.finite_toSet.preimage hc.injOn
+      apply (hcpre.image x).subset
+      rintro y ⟨hyS,hycell⟩
+      obtain ⟨i,rfl⟩ := hS hyS
+      have hxx := hJ hycell
+      simp only [Set.mem_iUnion] at hxx
+      obtain ⟨p,hpJ,hxp⟩ := hxx
+      have heq : c i = p := by
+        by_contra hne
+        exact (CWComplex.disjoint_openCell_of_ne hne).notMem_of_mem_left (hx i) hxp
+      exact ⟨i,by change c i ∈ J; rw [heq]; exact hpJ,rfl⟩
+    exact hfinite.isClosed
+  · rintro y hy
+    obtain ⟨i,rfl⟩ := hS hy
+    exact CWComplex.openCell_subset_complex (c i).1 (c i).2 (hx i)
+
+/-- A compact part of a CW complex can meet only finitely many open cells. -/
+theorem compact_finitely_many_cells {K : Set X} (hK : IsCompact K) :
+    {p : Σ n, RelCWComplex.cell C n | (K ∩ CWComplex.openCell p.1 p.2).Nonempty}.Finite := by
+  classical
+  let I := {p : Σ n, RelCWComplex.cell C n | (K ∩ CWComplex.openCell p.1 p.2).Nonempty}
+  let x : I → X := fun i => i.2.choose
+  have hx (i : I) : x i ∈ CWComplex.openCell i.1.1 i.1.2 := i.2.choose_spec.2
+  have hxK (i : I) : x i ∈ K := i.2.choose_spec.1
+  have hinj : Function.Injective x := by
+    intro i j hij
+    apply Subtype.ext
+    by_contra hne
+    exact (CWComplex.disjoint_openCell_of_ne hne).notMem_of_mem_left (hx i) (hij ▸ hx j)
+  have hall : ∀ S ⊆ Set.range x, IsClosed S :=
+    cellSelection_closed (C := C) Subtype.val Subtype.val_injective x hx
+  have hcompact : IsCompact (Set.range x) :=
+    hK.of_isClosed_subset (hall _ subset_rfl) (Set.range_subset_iff.mpr hxK)
+  have hdiscrete : IsDiscrete (Set.range x) := by
+    apply isDiscrete_iff_forall_mem_exists_isClosed.mpr
+    intro S hS
+    exact ⟨S,hall S hS,Set.inter_eq_left.mpr hS⟩
+  have hrange := hcompact.finite hdiscrete
+  have : Finite I := (Set.finite_range_iff hinj).mp hrange
+  exact Set.toFinite I
+
+/-- Compact maps cannot run out through infinitely many dimensions. -/
+theorem compact_bounded_skeleton {K : Set X} (hK : IsCompact K) (hKC : K ⊆ C) :
+    ∃ n : ℕ, K ⊆ CWComplex.skeletonLT C n := by
+  classical
+  let S := {p : Σ n, RelCWComplex.cell C n | (K ∩ CWComplex.openCell p.1 p.2).Nonempty}
+  have hS : S.Finite := compact_finitely_many_cells hK
+  let I := hS.toFinset
+  refine ⟨I.sup (fun p => p.1+1),?_⟩
+  intro x hx
+  have hxC := hKC hx
+  rw [← CWComplex.iUnion_openCell_eq_complex (C := C)] at hxC
+  simp only [Set.mem_iUnion] at hxC
+  obtain ⟨m,j,hj⟩ := hxC
+  have hmem : (⟨m,j⟩ : Σ n, RelCWComplex.cell C n) ∈ I := by
+    exact hS.mem_toFinset.mpr ⟨x,hx,hj⟩
+  have hm : m+1 ≤ I.sup (fun p => p.1+1) := Finset.le_sup (f := fun p => p.1+1) hmem
+  apply CWComplex.skeletonLT_mono (C := C)
+    (m := (m : ℕ∞)+1) (n := ((I.sup (fun p => p.1+1) : ℕ) : ℕ∞)) (by exact_mod_cast hm)
+  exact CWComplex.closedCell_subset_skeletonLT m j (CWComplex.openCell_subset_closedCell m j hj)
+
+/-- The bounded-skeleton property in its map form, used for spheres and disks. -/
+theorem compactMap_bounded_skeleton {A : Type*} [TopologicalSpace A] [CompactSpace A]
+    (f : C(A,X)) (hf : ∀ a, f a ∈ C) :
+    ∃ n : ℕ, ∀ a, f a ∈ CWComplex.skeletonLT C n := by
+  obtain ⟨n,hn⟩ := compact_bounded_skeleton (C := C) (isCompact_range f.continuous)
+    (Set.range_subset_iff.mpr hf)
+  exact ⟨n,fun a => hn (Set.mem_range_self a)⟩
+
+end GroupRingTopology.Cellular
+
+namespace GroupRingTopology.Simplicial
+open Set Metric Topology BigOperators
+open scoped Classical
+universe u
+variable {V : Type u} (K : PreAbstractSimplicialComplex V)
+
+lemma compact_bounded_vertices {A : Set (Space K)} (hA : IsCompact A) :
+    ∃ S : Finset V, ∀ x ∈ A, x.1.support ⊆ S := by
+  let T := {p : Σ n, Topology.RelCWComplex.cell (Set.univ : Set (Space K)) n |
+    (A ∩ CWComplex.openCell p.1 p.2).Nonempty}
+  have hT : T.Finite := Cellular.compact_finitely_many_cells hA
+  let S := hT.toFinset.biUnion (fun p => p.2.1.1)
+  refine ⟨S,?_⟩
+  intro x hx
+  let s : Face K := ⟨x.1.support,x.2.2.2⟩
+  let c := cellOfFace K s
+  have hc : (⟨s.1.card-1,c⟩ : Σ n, Topology.RelCWComplex.cell (Set.univ : Set (Space K)) n) ∈ hT.toFinset := by
+    rw [hT.mem_toFinset]
+    refine ⟨x,hx,?_⟩
+    change x ∈ characteristicPE K c '' ball 0 1
+    rw [characteristicPE_open]
+    rfl
+  exact Finset.subset_biUnion_of_mem (fun p => p.2.1.1) hc
+
+end GroupRingTopology.Simplicial
+
+open Set Metric Topology
+namespace GroupRingTopology.SphereTopology
+abbrev Disk (n : ℕ) := closedBall (0 : Fin n → ℝ) 1
+abbrev Sphere (n : ℕ) := sphere (0 : Fin n → ℝ) 1
+
+def boundary (n : ℕ) : C(Sphere n,Disk n) :=
+  ⟨fun x => ⟨x.1,sphere_subset_closedBall x.2⟩,continuous_subtype_val.subtype_mk _⟩
+
+lemma sphere_norm {n : ℕ} (x : Sphere n) : ‖x.1‖ = 1 := by
+  simpa only [mem_sphere,dist_zero_right] using x.2
+lemma disk_norm {n : ℕ} (x : Disk n) : ‖x.1‖ ≤ 1 := by
+  simpa only [mem_closedBall,dist_zero_right] using x.2
+
+def cone (n : ℕ) : C(unitInterval × Sphere n,Disk n) := by
+  have hm (p : unitInterval × Sphere n) : (p.1:ℝ) • p.2.1 ∈ closedBall (0 : Fin n → ℝ) 1 := by
+    simp only [mem_closedBall,dist_zero_right,norm_smul,Real.norm_eq_abs,abs_of_nonneg p.1.2.1,sphere_norm,mul_one]
+    exact p.1.2.2
+  exact ⟨fun p => ⟨(p.1:ℝ) • p.2.1,hm p⟩,
+    ((continuous_subtype_val.comp continuous_fst).smul
+      (continuous_subtype_val.comp continuous_snd)).subtype_mk hm⟩
+
+lemma cone_norm {n : ℕ} (p : unitInterval × Sphere n) : ‖(cone n p).1‖ = (p.1:ℝ) := by
+  simp only [cone,ContinuousMap.coe_mk,norm_smul,Real.norm_eq_abs,abs_of_nonneg p.1.2.1,sphere_norm,mul_one]
+
+lemma cone_surjective (n : ℕ) [Nonempty (Sphere n)] : Function.Surjective (cone n) := by
+  intro x
+  by_cases hx : x.1 = 0
+  · obtain ⟨s⟩ := ‹Nonempty (Sphere n)›
+    refine ⟨(0,s),Subtype.ext ?_⟩
+    simp only [cone,ContinuousMap.coe_mk,Set.Icc.coe_zero,zero_smul,hx]
+  · let s : Sphere n := ⟨‖x.1‖⁻¹ • x.1,by
+      simp only [mem_sphere,dist_zero_right,norm_smul,Real.norm_eq_abs,abs_inv,abs_norm,
+        inv_mul_cancel₀ (norm_ne_zero_iff.mpr hx)]⟩
+    refine ⟨(⟨‖x.1‖,norm_nonneg _,disk_norm x⟩,s),Subtype.ext ?_⟩
+    change ‖x.1‖ • (‖x.1‖⁻¹ • x.1) = x.1
+    rw [smul_smul,mul_inv_cancel₀ (norm_ne_zero_iff.mpr hx),one_smul]
+
+lemma cone_quotient (n : ℕ) [Nonempty (Sphere n)] : IsQuotientMap (cone n) :=
+  IsQuotientMap.of_surjective_continuous (cone_surjective n) (cone n).continuous
+
+variable {Y : Type*} [TopologicalSpace Y] {n : ℕ}
+
+def Extends (f : C(Sphere n,Y)) : Prop := ∃ F : C(Disk n,Y), F.comp (boundary n) = f
+
+lemma extends_of_nullhomotopic [Nonempty (Sphere n)] {y : Y} {f : C(Sphere n,Y)}
+    (H : (ContinuousMap.const (Sphere n) y).Homotopy f) : Extends f := by
+  have hf : Function.FactorsThrough H.toContinuousMap (cone n) := by
+    intro p q hpq
+    have ht : p.1 = q.1 := Subtype.ext ((cone_norm p).symm.trans ((congrArg (fun z : Disk n => ‖z.1‖) hpq).trans (cone_norm q)))
+    by_cases hzero : (p.1:ℝ) = 0
+    · have hp : p.1 = 0 := Subtype.ext hzero
+      have hq : q.1 = 0 := ht.symm.trans hp
+      change H (p.1,p.2) = H (q.1,q.2)
+      rw [hp,hq,H.apply_zero,H.apply_zero]
+      rfl
+    · have hs : p.2 = q.2 := by
+        apply Subtype.ext
+        have heq := congrArg (fun z : Disk n => z.1) hpq
+        change (p.1:ℝ) • p.2.1 = (q.1:ℝ) • q.2.1 at heq
+        rw [← ht] at heq
+        exact (smul_right_injective _ hzero) heq
+      exact congrArg H.toContinuousMap (Prod.ext ht hs)
+  let F : C(Disk n,Y) := (cone_quotient n).lift H.toContinuousMap hf
+  refine ⟨F,?_⟩
+  ext s
+  have hh := ContinuousMap.congr_fun ((cone_quotient n).lift_comp H.toContinuousMap hf) (1,s)
+  have hcone : cone n (1,s) = boundary n s := by apply Subtype.ext; simp [cone,boundary]
+  simpa only [ContinuousMap.comp_apply,hcone,ContinuousMap.Homotopy.coe_toContinuousMap,
+    ContinuousMap.Homotopy.apply_one] using hh
+
+lemma nullhomotopic_of_extends {f : C(Sphere n,Y)} (hf : Extends f) :
+    ∃ y : Y, Nonempty ((ContinuousMap.const (Sphere n) y).Homotopy f) := by
+  obtain ⟨F,hF⟩ := hf
+  let z : Disk n := ⟨0,by simp⟩
+  refine ⟨F z,⟨{
+    toFun := fun p => F (cone n p)
+    continuous_toFun := F.continuous.comp (cone n).continuous
+    map_zero_left := ?_
+    map_one_left := ?_ }⟩⟩
+  · intro s
+    exact congrArg F (Subtype.ext (by simp [cone,z]))
+  · intro s
+    have hs : cone n (1,s) = boundary n s := by apply Subtype.ext; simp [cone,boundary]
+    rw [hs]
+    exact ContinuousMap.congr_fun hF s
+
+lemma extends_of_homotopy [Nonempty (Sphere n)] {f g : C(Sphere n,Y)}
+    (H : f.Homotopy g) (hg : Extends g) : Extends f := by
+  obtain ⟨y,⟨J⟩⟩ := nullhomotopic_of_extends hg
+  exact extends_of_nullhomotopic (J.trans H.symm)
+
+lemma sphere_nonempty (n : ℕ) : Nonempty (Sphere (n+1)) :=
+  (NormedSpace.sphere_nonempty.mpr (by norm_num : (0:ℝ) ≤ 1)).coe_sort
+
+end GroupRingTopology.SphereTopology
+
+/-! Classical cellular lifting and its geometric foundations.
+No classifying-space existence or Hurewicz theorem is assumed. -/
+open Set Metric Topology
+
+namespace GroupRingTopology.Cellular
+universe u v w
+
+abbrev Disk (n : ℕ) := closedBall (0 : Fin n → ℝ) 1
+abbrev Sphere (n : ℕ) := sphere (0 : Fin n → ℝ) 1
+
+def boundary (n : ℕ) : Sphere n → Disk n :=
+  fun x => ⟨x.1, sphere_subset_closedBall x.2⟩
+
+lemma continuous_boundary (n : ℕ) : Continuous (boundary n) :=
+  continuous_subtype_val.subtype_mk _
+
+variable {X : Type u} [TopologicalSpace X] [T2Space X]
+variable {C : Set X} [CWComplex C]
+
+/-- A characteristic map on its closed disk. -/
+def characteristic (n : ℕ) (i : RelCWComplex.cell C n) : C(Disk n, X) :=
+  ⟨fun x => RelCWComplex.map n i x.1, (RelCWComplex.continuousOn n i).domRestrict⟩
+
+omit [T2Space X] in
+lemma range_characteristic (n : ℕ) (i : RelCWComplex.cell C n) :
+    Set.range (characteristic n i) = CWComplex.closedCell n i := by
+  ext x
+  constructor
+  · rintro ⟨y,rfl⟩; exact ⟨y.1,y.2,rfl⟩
+  · rintro ⟨y,hy,rfl⟩; exact ⟨⟨y,hy⟩,rfl⟩
+
+/-- The weak topology is genuinely final with respect to closed characteristic
+maps; no finiteness or local-finiteness hypothesis is needed. -/
+lemma continuousOn_iff_characteristic {Y : Type v} [TopologicalSpace Y] (f : X → Y) :
+    ContinuousOn f C ↔ ∀ n (i : RelCWComplex.cell C n),
+      Continuous (f ∘ characteristic n i) := by
+  constructor
+  · intro hf n i
+    exact hf.comp_continuous (characteristic n i).continuous
+      (fun x => CWComplex.closedCell_subset_complex n i ⟨x.1,x.2,rfl⟩)
+  · intro hf
+    rw [continuousOn_iff_continuous_domRestrict, continuous_iff_isClosed]
+    intro S hS
+    have hclosed : IsClosed (C ∩ f ⁻¹' S) := by
+      apply (CWComplex.closed C _ inter_subset_left).2
+      intro n i
+      have hpre : IsClosed ((f ∘ characteristic n i) ⁻¹' S) :=
+        hS.preimage (hf n i)
+      have hcompact := hpre.isCompact.image (characteristic n i).continuous
+      convert hcompact.isClosed using 1
+      ext x
+      constructor
+      · rintro ⟨⟨hxC,hxS⟩, y,hy,rfl⟩
+        exact ⟨⟨y,hy⟩,hxS,rfl⟩
+      · rintro ⟨y,hy,rfl⟩
+        exact ⟨⟨CWComplex.closedCell_subset_complex n i ⟨y.1,y.2,rfl⟩,hy⟩,
+          y.1,y.2,rfl⟩
+    convert hclosed.preimage continuous_subtype_val using 1
+    ext x
+    simp only [Set.mem_preimage, Set.mem_inter_iff, and_iff_right x.2, Set.domRestrict_apply]
+
+abbrev Skeleton (C : Set X) [CWComplex C] (n : ℕ) : Set X :=
+  CWComplex.skeletonLT C n
+
+lemma skeleton_mono {m n : ℕ} (h : m ≤ n) :
+    Skeleton C m ⊆ Skeleton C n :=
+  CWComplex.skeletonLT_mono (by exact_mod_cast h)
+
+lemma sphere_mem_skeleton (n : ℕ) (i : RelCWComplex.cell C n) (x : Sphere n) :
+    characteristic n i (boundary n x) ∈ Skeleton C n :=
+  CWComplex.cellFrontier_subset_skeletonLT n i ⟨x.1,x.2,rfl⟩
+
+lemma characteristic_mem_skeleton {m n : ℕ} (h : m < n)
+    (i : RelCWComplex.cell C m) (x : Disk m) :
+    characteristic m i x ∈ Skeleton C n := by
+  apply skeleton_mono (Nat.succ_le_of_lt h)
+  exact CWComplex.closedCell_subset_skeletonLT m i ⟨x.1,x.2,rfl⟩
+
+lemma openCell_not_skeleton (n : ℕ) (i : RelCWComplex.cell C n) {x : X}
+    (hx : x ∈ CWComplex.openCell n i) : x ∉ Skeleton C n :=
+  (CWComplex.disjoint_skeletonLT_openCell (C := C) (j := i) le_rfl).notMem_of_mem_right hx
+
+/-- A continuous partial lift on the (n-1)-skeleton, represented by a total
+function only to avoid transported subtype terms. Values outside the skeleton
+carry no condition and are never used. -/
+structure PartialLift {E : Type v} {B : Type w} [TopologicalSpace E] [TopologicalSpace B]
+    (p : C(E,B)) (f : C(X,B)) (n : ℕ) where
+  val : X → E
+  continuousOn : ContinuousOn val (Skeleton C n)
+  fac : ∀ x ∈ Skeleton C n, p (val x) = f x
+
+/-- The concrete disk-boundary right lifting property. -/
+def DiskRLP {E : Type v} {B : Type w} [TopologicalSpace E] [TopologicalSpace B]
+    (p : C(E,B)) : Prop :=
+  ∀ n (a : C(Sphere n,E)) (b : C(Disk n,B)),
+    (∀ x, p (a x) = b (boundary n x)) →
+    ∃ e : C(Disk n,E), (∀ x, e (boundary n x) = a x) ∧ ∀ x, p (e x) = b x
+
+variable {E : Type v} [TopologicalSpace E] {n : ℕ}
+
+/-- Glue the old skeleton map to a prescribed disk map on each new cell. -/
+noncomputable def attachValue (a : X → E) (e : ∀ _ : RelCWComplex.cell C n, C(Disk n,E))
+    (x : X) : E := by
+  classical
+  exact if x ∈ Skeleton C n then a x
+    else if h : ∃ i : RelCWComplex.cell C n, x ∈ CWComplex.openCell n i then
+      let i := h.choose
+      let y := h.choose_spec.choose
+      e i ⟨y,ball_subset_closedBall h.choose_spec.choose_spec.1⟩
+    else a x
+
+lemma attachValue_old (a : X → E) (e : ∀ _ : RelCWComplex.cell C n, C(Disk n,E))
+    {x : X} (hx : x ∈ Skeleton C n) : attachValue a e x = a x := by
+  classical
+  simp only [attachValue, ite_eq_left hx]
+
+lemma attachValue_interior (a : X → E) (e : ∀ _ : RelCWComplex.cell C n, C(Disk n,E))
+    (i : RelCWComplex.cell C n) (y : Disk n) (hy : y.1 ∈ ball 0 1) :
+    attachValue a e (characteristic n i y) = e i y := by
+  classical
+  have hx : characteristic n i y ∈ CWComplex.openCell n i := ⟨y.1,hy,rfl⟩
+  have h : ∃ j : RelCWComplex.cell C n,
+      characteristic n i y ∈ CWComplex.openCell n j := ⟨i,hx⟩
+  rw [attachValue,ite_eq_right (openCell_not_skeleton n i hx),dite_eq_left h]
+  have hi : h.choose = i := by
+    by_contra hne
+    have hd := CWComplex.disjoint_openCell_of_ne (C := C) (i := h.choose) (j := i)
+      (fun hEq => hne (sigma_mk_injective hEq))
+    exact Set.disjoint_left.mp hd h.choose_spec hx
+  have hz := h.choose_spec.choose_spec.1
+  have hmap : RelCWComplex.map n i h.choose_spec.choose = characteristic n i y := by
+    calc
+      RelCWComplex.map n i h.choose_spec.choose =
+          RelCWComplex.map n h.choose h.choose_spec.choose :=
+        congrArg (fun k => RelCWComplex.map n k h.choose_spec.choose) hi.symm
+      _ = _ := h.choose_spec.choose_spec.2
+  have hcoord : h.choose_spec.choose = y.1 :=
+    (RelCWComplex.map n i).injOn
+      (by simpa only [RelCWComplex.source_eq] using hz)
+      (by simpa only [RelCWComplex.source_eq] using hy) hmap
+  exact (congrArg (fun k => e k ⟨h.choose_spec.choose,ball_subset_closedBall hz⟩) hi).trans
+    (congrArg (e i) (Subtype.ext hcoord))
+
+lemma attachValue_characteristic (a : X → E)
+    (e : ∀ _ : RelCWComplex.cell C n, C(Disk n,E))
+    (he : ∀ i (x : Sphere n), e i (boundary n x) =
+      a (characteristic n i (boundary n x)))
+    (i : RelCWComplex.cell C n) (y : Disk n) :
+    attachValue a e (characteristic n i y) = e i y := by
+  by_cases hy : y.1 ∈ ball 0 1
+  · exact attachValue_interior a e i y hy
+  · have hs : y.1 ∈ sphere 0 1 := le_antisymm y.2 (le_of_not_gt hy)
+    have hx : characteristic n i y ∈ Skeleton C n := sphere_mem_skeleton n i ⟨y,hs⟩
+    rw [attachValue_old a e hx]
+    exact (he i ⟨y,hs⟩).symm
+
+lemma attachValue_continuous (a : X → E) (ha : ContinuousOn a (Skeleton C n))
+    (e : ∀ _ : RelCWComplex.cell C n, C(Disk n,E))
+    (he : ∀ i (x : Sphere n), e i (boundary n x) =
+      a (characteristic n i (boundary n x))) :
+    ContinuousOn (attachValue a e) (Skeleton C (n+1)) := by
+  apply (continuousOn_iff_characteristic (C := Skeleton C (n+1)) _).2
+  intro m j
+  change Continuous (fun x : Disk m => attachValue a e (characteristic m j.1 x))
+  have hm : m < n+1 := by
+    have h : (m : ℕ∞) < ((n+1 : ℕ) : ℕ∞) := by
+      simpa only [RelCWComplex.skeletonLT_I,Set.mem_ofPred_eq] using j.2
+    exact_mod_cast h
+  rcases Nat.lt_succ_iff_lt_or_eq.mp hm with hm | hm
+  · have hEq : (fun x : Disk m => attachValue a e (characteristic m j.1 x)) =
+        (fun x : Disk m => a (characteristic m j.1 x)) := by
+      funext x
+      exact attachValue_old a e (characteristic_mem_skeleton hm j.1 x)
+    rw [hEq]
+    exact ha.comp_continuous (characteristic m j.1).continuous
+      (characteristic_mem_skeleton hm j.1)
+  · subst m
+    have hEq : (fun x : Disk n => attachValue a e (characteristic n j.1 x)) = e j.1 := by
+      funext x
+      exact attachValue_characteristic a e he j.1 x
+    rw [hEq]
+    exact (e j.1).continuous
+
+end GroupRingTopology.Cellular
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/GroupRing/CellularFurther.lean b/lean/OAI/Algebra/GroupRing/CellularFurther.lean
new file mode 100644
index 0000000000000000000000000000000000000000..9d38724f15a292375d591d8d78397ff29e10519c
--- /dev/null
+++ b/lean/OAI/Algebra/GroupRing/CellularFurther.lean
@@ -0,0 +1,384 @@
+import Mathlib
+import OAI.Algebra.GroupRing.GeneralPosition
+
+namespace OAI
+
+noncomputable section
+
+open Set Metric Topology BigOperators
+open Set Metric Topology
+open Set Topology
+open Set Metric Topology
+open scoped NNReal
+
+namespace GroupRingTopology.Cellular
+
+section
+open Set Metric Topology
+open scoped ENNReal NNReal
+variable {Y : Type*} [TopologicalSpace Y] [T2Space Y] {n : ℕ}
+
+abbrev ChartDisk (n : ℕ) := Metric.ball (0 : Fin n → ℝ) 1
+abbrev ChartCore (n : ℕ) := Metric.closedBall (0 : Fin n → ℝ) (1/2)
+
+def chartCoreInclusion (n : ℕ) : C(ChartCore n,ChartDisk n) :=
+  ⟨fun x => ⟨x.1, (mem_closedBall.mp x.2).trans_lt (by norm_num)⟩,
+    continuous_subtype_val.subtype_mk _⟩
+
+def chartCore (e : C(ChartDisk n,Y)) : C(ChartCore n,Y) := e.comp (chartCoreInclusion n)
+
+lemma chartCore_closedEmbedding (e : C(ChartDisk n,Y)) (he : IsOpenEmbedding e) :
+    IsClosedEmbedding (chartCore e) := by
+  apply (chartCore e).continuous.isClosedEmbedding
+  intro x y h
+  apply Subtype.ext
+  exact congrArg (fun z : ChartDisk n => z.1) (he.injective h)
+
+variable {K : Type*} [MetricSpace K]
+
+def chartDomain (e : C(ChartDisk n,Y)) (f : C(K,Y)) : Set K := f ⁻¹' Set.range (chartCore e)
+
+lemma chartDomain_closed (e : C(ChartDisk n,Y)) (he : IsOpenEmbedding e) (f : C(K,Y)) :
+    IsClosed (chartDomain e f) := (chartCore_closedEmbedding e he).isClosed_range.preimage f.continuous
+
+def coreCoordinate (e : C(ChartDisk n,Y)) (he : IsOpenEmbedding e) (f : C(K,Y)) :
+    C(chartDomain e f,ChartCore n) :=
+  ⟨fun x => (chartCore_closedEmbedding e he).toIsEmbedding.toHomeomorph.symm ⟨f x,x.2⟩,
+    (chartCore_closedEmbedding e he).toIsEmbedding.toHomeomorph.symm.continuous.comp
+      ((f.continuous.comp continuous_subtype_val).subtype_mk _)⟩
+
+lemma coreCoordinate_fac (e : C(ChartDisk n,Y)) (he : IsOpenEmbedding e) (f : C(K,Y))
+    (x : chartDomain e f) : chartCore e (coreCoordinate e he f x) = f x :=
+  congrArg Subtype.val ((chartCore_closedEmbedding e he).toIsEmbedding.toHomeomorph.apply_symm_apply _)
+
+lemma coreCoordinate_frontier (e : C(ChartDisk n,Y)) (he : IsOpenEmbedding e) (f : C(K,Y))
+    (x : chartDomain e f) (hx : (x:K) ∈ frontier (chartDomain e f)) :
+    ‖(coreCoordinate e he f x : Fin n → ℝ)‖ = 1/2 := by
+  apply le_antisymm
+  · simpa only [mem_closedBall,dist_zero_right] using (coreCoordinate e he f x).2
+  · by_contra! h
+    let U : Set (ChartDisk n) := {z | ‖(z : Fin n → ℝ)‖ < 1/2}
+    have hU : IsOpen U := isOpen_lt (continuous_subtype_val.norm) continuous_const
+    have hsub : f ⁻¹' (e '' U) ⊆ chartDomain e f := by
+      intro y hy
+      obtain ⟨z,hz,hzy⟩ := hy
+      exact ⟨⟨z.1,by simpa only [mem_closedBall,dist_zero_right] using le_of_lt hz⟩,hzy⟩
+    have hxU : (x:K) ∈ f ⁻¹' (e '' U) := by
+      refine ⟨chartCoreInclusion n (coreCoordinate e he f x),h,?_⟩
+      exact coreCoordinate_fac e he f x
+    exact hx.2 (mem_interior.mpr ⟨f ⁻¹' (e '' U),hsub,
+      (he.isOpenMap U hU).preimage f.continuous,hxU⟩)
+
+omit [T2Space Y] in
+lemma chartDomain_dimH_le (e : C(ChartDisk n,Y)) (f : C(K,Y)) :
+    dimH (Set.univ : Set (chartDomain e f)) ≤ dimH (Set.univ : Set K) := by
+  rw [← isometry_subtype_coe.dimH_image]
+  exact dimH_mono (Set.subset_univ _)
+
+end
+
+section
+open Set Metric Topology
+open scoped ENNReal NNReal
+variable {Y : Type*} [TopologicalSpace Y] {n : ℕ}
+variable {K : Type*} [MetricSpace K]
+
+def chartCenter (e : C(ChartDisk n,Y)) : Y := e ⟨0,by simp⟩
+
+/-- A map of smaller dimension can be homotoped off one cell centre,
+without changing it outside the cell. This works for merely continuous maps,
+not just piecewise linear maps. -/
+lemma exists_chart_avoidance [T2Space Y] [CompactSpace K] (e : C(ChartDisk n,Y)) (he : IsOpenEmbedding e) (f : C(K,Y))
+    (hdim : dimH (Set.univ : Set K) < n) :
+    ∃ (g : C(K,Y)) (H : f.Homotopy g),
+      (∀ x, g x ≠ chartCenter e) ∧
+      (∀ (t : unitInterval) (x : K), f x ∉ Set.range e → H (t,x) = f x) ∧
+      (∀ (t : unitInterval) (x : K), H (t,x) = f x ∨ H (t,x) ∈ Set.range e) := by
+  let A := chartDomain e f
+  have hA : IsClosed A := chartDomain_closed e he f
+  let : CompactSpace A := isCompact_iff_compactSpace.mp hA.isCompact
+  let u : C(A,Fin n → ℝ) := ⟨fun x => (coreCoordinate e he f x).1,
+    continuous_subtype_val.comp (coreCoordinate e he f).continuous⟩
+  obtain ⟨v,hv0,hvfix,hvdist⟩ := GeneralPosition.exists_relative_nonzero_approximation u
+    ((chartDomain_dimH_le e f).trans_lt hdim) (δ := 1/8) (by norm_num)
+  have hi (t : unitInterval) (x : A) : ‖u x+(t:ℝ) • (v x-u x)‖ ≤ 1/2 := by
+    have hu : ‖u x‖ ≤ 4*(1/8:ℝ) := by
+      simpa only [u,ContinuousMap.coe_mk,show (4:ℝ)*(1/8)=1/2 by norm_num,mem_closedBall,dist_zero_right]
+        using (coreCoordinate e he f x).2
+    simpa only [show (4:ℝ)*(1/8)=1/2 by norm_num] using
+      GeneralPosition.relative_interpolation_bound (by norm_num : (0:ℝ)<1/8)
+        hvfix hvdist x hu t
+  have hvc (x : A) : v x ∈ ChartCore n := by
+    have h := hi 1 x
+    simpa only [Set.Icc.coe_one,one_smul,add_sub_cancel,mem_closedBall,dist_zero_right] using h
+  let vcore : C(A,ChartCore n) := ⟨fun x => ⟨v x,hvc x⟩,
+    v.continuous.subtype_mk hvc⟩
+  let gA : C(A,Y) := (chartCore e).comp vcore
+  let HA : (f.restrict A).Homotopy gA :=
+    { toFun := fun tx => chartCore e ⟨u tx.2+(tx.1:ℝ) • (v tx.2-u tx.2),by
+        simpa only [mem_closedBall,dist_zero_right] using hi tx.1 tx.2⟩
+      continuous_toFun := (chartCore e).continuous.comp
+        (((u.continuous.comp continuous_snd).add
+          ((continuous_subtype_val.comp continuous_fst).smul
+            ((v.continuous.comp continuous_snd).sub (u.continuous.comp continuous_snd)))).subtype_mk
+            (fun tx => by
+              simpa only [ChartCore,mem_closedBall,dist_zero_right,Pi.add_apply,
+                Pi.smul_apply',Pi.sub_apply,Function.comp_apply] using hi tx.1 tx.2))
+      map_zero_left := fun x => by
+        simp only [Set.Icc.coe_zero,zero_smul,add_zero]
+        exact coreCoordinate_fac e he f x
+      map_one_left := fun x => by
+        simp only [Set.Icc.coe_one,one_smul,add_sub_cancel]
+        rfl }
+  have hboundary (t : unitInterval) (x : A) (hx : (x:K) ∈ frontier A) :
+      HA (t,x) = f x := by
+    have hfix : v x = u x := hvfix x (by
+      change 2*(1/8:ℝ) ≤ ‖(coreCoordinate e he f x).1‖
+      rw [coreCoordinate_frontier e he f x hx]
+      norm_num)
+    change chartCore e ⟨u x+(t:ℝ) • (v x-u x),_⟩ = f x
+    simp only [hfix,sub_self,smul_zero,add_zero]
+    exact coreCoordinate_fac e he f x
+  let hg : ∀ x : A, (x:K) ∈ frontier A → gA x = f x :=
+    fun x hx => by simpa using hboundary 1 x hx
+  let g := patch hA f gA hg
+  let H : f.Homotopy g := patchHomotopy hA f gA HA hboundary
+  have hOn (t : unitInterval) (x : A) : H (t,(x:K)) = HA (t,x) := by
+    change patchFun (Prod.snd ⁻¹' A) _ _ (t,(x:K)) = _
+    rw [patchFun,dite_eq_left (show (t,(x:K)) ∈ Prod.snd ⁻¹' A from x.2)]
+    rfl
+  have hOff (t : unitInterval) (x : K) (hx : x ∉ A) : H (t,x) = f x := by
+    change patchFun (Prod.snd ⁻¹' A) _ _ (t,x) = _
+    rw [patchFun,dite_eq_right (show (t,x) ∉ Prod.snd ⁻¹' A from hx)]
+    rfl
+  refine ⟨g,H,?_,?_,?_⟩
+  · intro x hzero
+    by_cases hx : x ∈ A
+    · have hv : chartCore e (vcore ⟨x,hx⟩) = chartCenter e := by
+        exact (patch_on hA f gA hg ⟨x,hx⟩).symm.trans hzero
+      have hu := congrArg (fun z : ChartDisk n => z.1) (he.injective hv)
+      exact hv0 ⟨x,hx⟩ hu
+    · have hfx : f x = chartCenter e := (patch_off hA f gA hg hx).symm.trans hzero
+      apply hx
+      exact ⟨⟨0,by simp⟩,hfx.symm⟩
+  · intro t x hx
+    apply hOff
+    rintro ⟨z,hz⟩
+    exact hx ⟨chartCoreInclusion n z,hz⟩
+  · intro t x
+    by_cases hx : x ∈ A
+    · right
+      rw [hOn t ⟨x,hx⟩]
+      exact ⟨_,rfl⟩
+    · exact Or.inl (hOff t x hx)
+
+end
+
+open Set Metric Topology
+open scoped ENNReal NNReal
+section
+variable {Y : Type*} [TopologicalSpace Y] {K : Type*} [TopologicalSpace K]
+
+lemma homotopy_trans_pointwise {f g h : C(K,Y)} (H : f.Homotopy g) (J : g.Homotopy h)
+    (P : K → Y → Prop) (hH : ∀ t x, P x (H (t,x))) (hJ : ∀ t x, P x (J (t,x))) :
+    ∀ t x, P x (H.trans J (t,x)) := by
+  intro t x
+  erw [ContinuousMap.Homotopy.trans_apply]
+  split_ifs
+  · exact hH _ x
+  · exact hJ _ x
+
+end
+variable {Y : Type*} [TopologicalSpace Y] [T2Space Y] {n : ℕ}
+variable {K : Type*} [MetricSpace K] [CompactSpace K] {ι : Type*}
+variable (e : ι → C(ChartDisk n,Y)) (he : ∀ i, IsOpenEmbedding (e i))
+variable (hd : Pairwise (fun i j => Disjoint (Set.range (e i)) (Set.range (e j))))
+
+omit [T2Space Y] in
+lemma chartCenter_mem_range (i : ι) : chartCenter (e i) ∈ Set.range (e i) := ⟨_,rfl⟩
+
+include he hd in
+lemma exists_finite_chart_avoidance (f : C(K,Y)) (hdim : dimH (Set.univ : Set K) < n)
+    (S : Finset ι) :
+    ∃ (g : C(K,Y)) (H : f.Homotopy g),
+      (∀ i ∈ S, ∀ x, g x ≠ chartCenter (e i)) ∧
+      (∀ t x, H (t,x) = f x ∨ ∃ i ∈ S, H (t,x) ∈ Set.range (e i)) ∧
+      (∀ t x, (∀ i ∈ S, f x ∉ Set.range (e i)) → H (t,x) = f x) := by
+  classical
+  induction S using Finset.induction_on with
+  | empty =>
+    exact ⟨f,.refl f,by simp,(fun _ _ => Or.inl rfl),fun _ _ _ => rfl⟩
+  | @insert a S ha ih =>
+    obtain ⟨g,H,hg,hH,hstat⟩ := ih
+    obtain ⟨g',J,hg',hJstat,hJ⟩ := exists_chart_avoidance (e a) (he a) g hdim
+    refine ⟨g',H.trans J,?_,?_,?_⟩
+    · intro i hi x
+      rcases Finset.mem_insert.mp hi with rfl | hi
+      · exact hg' x
+      · intro hzero
+        rcases hJ 1 x with hj | hj
+        · have hh : g' x = g x := by simpa using hj
+          exact hg i hi x (hh.symm.trans hzero)
+        · have hj : g' x ∈ Set.range (e a) := by simpa using hj
+          rw [hzero] at hj
+          exact (hd (by intro heq; subst i; exact ha hi)).notMem_of_mem_left hj
+            (chartCenter_mem_range e i)
+    · apply homotopy_trans_pointwise H J
+        (fun x y => y = f x ∨ ∃ i ∈ insert a S, y ∈ Set.range (e i))
+      · intro t x
+        rcases hH t x with h | ⟨i,hi,h⟩
+        · exact Or.inl h
+        · exact Or.inr ⟨i,Finset.mem_insert_of_mem hi,h⟩
+      · intro t x
+        rcases hJ t x with h | h
+        · rw [h]
+          have hh : g x = f x ∨ ∃ i ∈ S, g x ∈ Set.range (e i) := by simpa using hH 1 x
+          rcases hh with h | ⟨i,hi,h⟩
+          · exact Or.inl h
+          · exact Or.inr ⟨i,Finset.mem_insert_of_mem hi,h⟩
+        · exact Or.inr ⟨a,Finset.mem_insert_self _ _,h⟩
+    · intro t x hx
+      have hfixed : ∀ t, H (t,x) = f x := fun t =>
+        hstat t x (fun i hi => hx i (Finset.mem_insert_of_mem hi))
+      have hgx : g x = f x := by simpa using hfixed 1
+      have hjfixed : ∀ t, J (t,x) = f x := fun t =>
+        (hJstat t x (by rw [hgx]; exact hx a (Finset.mem_insert_self _ _))).trans hgx
+      erw [ContinuousMap.Homotopy.trans_apply]
+      split_ifs
+      · exact hfixed _
+      · exact hjfixed _
+
+include he hd in
+lemma exists_all_chart_avoidance (f : C(K,Y)) (hdim : dimH (Set.univ : Set K) < n)
+    (S : Finset ι) (hs : ∀ i, i ∉ S → ∀ x, f x ∉ Set.range (e i)) :
+    ∃ (g : C(K,Y)) (H : f.Homotopy g),
+      (∀ i x, g x ≠ chartCenter (e i)) ∧
+      (∀ t x, (∀ i, f x ∉ Set.range (e i)) → H (t,x) = f x) := by
+  classical
+  obtain ⟨g,H,hg,hH,hstat⟩ := exists_finite_chart_avoidance e he hd f hdim S
+  refine ⟨g,H,?_,?_⟩
+  · intro i x
+    by_cases hi : i ∈ S
+    · exact hg i hi x
+    · intro hzero
+      have hh : g x = f x ∨ ∃ j ∈ S, g x ∈ Set.range (e j) := by simpa using hH 1 x
+      rcases hh with h | ⟨j,hj,h⟩
+      · apply hs i hi x
+        rw [← h,hzero]
+        exact chartCenter_mem_range e i
+      · rw [hzero] at h
+        exact (hd (by intro heq; subst j; exact hi hj)).notMem_of_mem_left h
+          (chartCenter_mem_range e i)
+  · intro t x hx
+    exact hstat t x (fun i _ => hx i)
+
+end GroupRingTopology.Cellular
+
+namespace GroupRingTopology.Attachment
+open Set Metric Topology
+variable {X : Type*} [TopologicalSpace X] {ι : Type*} {n : ℕ}
+variable (a : ι → C(Sphere n,X)) [T2Space (Space a)]
+variable {K : Type*} [MetricSpace K] [CompactSpace K]
+
+def chart (i : ι) : C(Cellular.ChartDisk n,Space a) :=
+  ⟨openCell a i,(openCell_openEmbedding a i).continuous⟩
+
+/-- Maps of dimension below the newly attached cells can be deformed into the
+old space. The deformation is stationary on the original preimage of it. -/
+lemma exists_deformation_into_base (f : C(K,Space a))
+    (hdim : dimH (Set.univ : Set K) < n) :
+    ∃ (g : C(K,X)) (H : f.Homotopy ((⟨base a,continuous_base a⟩ : C(X,Space a)).comp g)),
+      ∀ t x, f x ∈ Set.range (base a) → H (t,x) = f x := by
+  classical
+  let I := {i : ι | (Set.range f ∩ Set.range (openCell a i)).Nonempty}
+  have hI : I.Finite := compact_finitely_many_openCells a (isCompact_range f.continuous)
+  have hs : ∀ i, i ∉ hI.toFinset → ∀ x, f x ∉ Set.range (chart a i) := by
+    intro i hi x hx
+    apply hi
+    rw [Set.Finite.mem_toFinset]
+    exact ⟨f x,Set.mem_range_self x,hx⟩
+  obtain ⟨g,H,hg,hstat⟩ := Cellular.exists_all_chart_avoidance (chart a)
+    (fun i => openCell_openEmbedding a i) (fun i j hij => openCell_disjoint a i j hij)
+    f hdim hI.toFinset hs
+  have hgp (x : K) : g x ∈ punctured a := by
+    rintro ⟨i,hi⟩
+    exact hg i x hi.symm
+  let gp : C(K,punctured a) := ⟨fun x => ⟨g x,hgp x⟩,g.continuous.subtype_mk hgp⟩
+  let J := (radialHomotopy a).compContinuousMap gp
+  have hJ0 : (puncturedInclusion a).comp gp = g := rfl
+  let J' : g.Homotopy ((radialEnd a).comp gp) := hJ0 ▸ J
+  refine ⟨(radialRetraction a).comp gp,H.trans J',?_⟩
+  intro t x hx
+  obtain ⟨y,hy⟩ := hx
+  have hfixed (s : unitInterval) : H (s,x) = f x := by
+    apply hstat s x
+    intro i
+    rintro ⟨d,hd⟩
+    rw [← hy] at hd
+    cases hd
+  have hgx : g x = base a y := by simpa only [ContinuousMap.Homotopy.apply_one,← hy] using hfixed 1
+  have hgp' : gp x = puncturedBase a y := Subtype.ext hgx
+  have hjfixed (s : unitInterval) : J' (s,x) = f x := by
+    change radialHomotopy a (s,gp x) = f x
+    rw [hgp',radialHomotopy_base,hy]
+  erw [ContinuousMap.Homotopy.trans_apply]
+  split_ifs
+  · exact hfixed _
+  · exact hjfixed _
+
+end GroupRingTopology.Attachment
+open Set Metric Topology
+open scoped NNReal ENNReal
+namespace GroupRingTopology.GeneralPosition
+
+lemma lipschitz_insertNth {n : ℕ} (i : Fin (n+1)) (c : ℝ) :
+    LipschitzWith 1 (Fin.insertNth (α := fun _ : Fin (n+1) => ℝ) i c : (Fin n → ℝ) → (Fin (n+1) → ℝ)) := by
+  apply LipschitzWith.of_dist_le_mul
+  intro x y
+  simp only [NNReal.coe_one,one_mul]
+  rw [dist_pi_le_iff dist_nonneg]
+  intro j
+  refine Fin.succAboveCases i ?_ (fun k => ?_) j
+  · simp only [Fin.insertNth_apply_same,dist_self,dist_nonneg]
+  · simp only [Fin.insertNth_apply_succAbove]
+    exact dist_le_pi_dist x y k
+
+lemma sphere_subset_faces (n : ℕ) :
+    Metric.sphere (0 : Fin (n+1) → ℝ) 1 ⊆
+      ⋃ i : Fin (n+1), ⋃ c ∈ ({1,-1}:Set ℝ), Set.range (Fin.insertNth (α := fun _ : Fin (n+1) => ℝ) i c : (Fin n → ℝ) → _) := by
+  intro x hx
+  have hxnorm : ‖x‖ = 1 := by simpa only [Metric.mem_sphere,dist_zero_right] using hx
+  have hi : ∃ i, 1 ≤ ‖x i‖ := by
+    by_contra! hh
+    have := (pi_norm_lt_iff (by norm_num : (0:ℝ)<1)).mpr hh
+    linarith
+  obtain ⟨i,hi⟩ := hi
+  have heq : |x i| = 1 := le_antisymm ((norm_le_pi_norm x i).trans_eq hxnorm) hi
+  have hc : x i ∈ ({1,-1}:Set ℝ) := by
+    rcases abs_eq (by norm_num : (0:ℝ)≤1) |>.mp heq with h | h <;> simp [h]
+  refine Set.mem_iUnion.mpr ⟨i,Set.mem_iUnion.mpr ⟨x i,Set.mem_iUnion.mpr ⟨hc,?_⟩⟩⟩
+  exact ⟨fun j => x (i.succAbove j),Fin.insertNth_self_removeNth _ _⟩
+
+lemma dimH_cube_boundary_le (n : ℕ) :
+    dimH (Metric.sphere (0 : Fin (n+1) → ℝ) 1) ≤ n := by
+  apply (dimH_mono (sphere_subset_faces n)).trans
+  rw [dimH_iUnion]
+  apply iSup_le
+  intro i
+  rw [dimH_bUnion (Set.toFinite ({1,-1}:Set ℝ)).countable]
+  apply iSup_le
+  intro c
+  apply iSup_le
+  intro _
+  exact (lipschitz_insertNth i c).dimH_range_le.trans_eq (Real.dimH_univ_pi_fin n)
+
+lemma dimH_cube_boundary_subtype_le (n : ℕ) :
+    dimH (Set.univ : Set (Metric.sphere (0 : Fin (n+1) → ℝ) 1)) ≤ n := by
+  rw [← isometry_subtype_coe.dimH_image]
+  simpa only [Subtype.range_coe_subtype,Set.image_univ,Set.ofPred_mem_eq] using dimH_cube_boundary_le n
+
+end GroupRingTopology.GeneralPosition
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/GroupRing/CellularFurther2.lean b/lean/OAI/Algebra/GroupRing/CellularFurther2.lean
new file mode 100644
index 0000000000000000000000000000000000000000..05dd9a3fb0e259deb89a021d8498f8701d946635
--- /dev/null
+++ b/lean/OAI/Algebra/GroupRing/CellularFurther2.lean
@@ -0,0 +1,431 @@
+import Mathlib
+import OAI.Algebra.GroupRing.HomotopyFunctor
+
+namespace OAI
+
+noncomputable section
+
+open Set Metric Topology BigOperators
+open Set Metric Topology
+open Set Topology
+open Set Metric Topology
+open scoped NNReal
+open Set Metric Topology
+open scoped NNReal ENNReal
+open Set Metric Topology
+
+namespace GroupRingTopology.Cellular
+
+section
+open Set Metric Topology
+universe u
+variable {X : Type u} [TopologicalSpace X] [T2Space X]
+variable {C : Set X} [CWComplex C]
+
+/-- The actual attaching maps of a classical CW skeleton. -/
+def skeletonBoundary (n : ℕ) (i : RelCWComplex.cell C n) :
+    C(Attachment.Sphere n,Skeleton C n) :=
+  ⟨fun x => ⟨characteristic n i (boundary n x),sphere_mem_skeleton n i x⟩,
+    ((characteristic n i).continuous.comp (continuous_boundary n)).subtype_mk _⟩
+
+def skeletonBase (n : ℕ) : C(Skeleton C n,Skeleton C (n+1)) :=
+  ⟨fun x => ⟨x.1,skeleton_mono (Nat.le_succ n) x.2⟩,continuous_subtype_val.subtype_mk _⟩
+
+def skeletonCell (n : ℕ) (i : RelCWComplex.cell C n) :
+    C(Attachment.Disk n,Skeleton C (n+1)) :=
+  ⟨fun x => ⟨characteristic n i x,characteristic_mem_skeleton (Nat.lt_succ_self n) i x⟩,
+    (characteristic n i).continuous.subtype_mk _⟩
+
+def skeletonAssembly (n : ℕ) : C(Attachment.Space (skeletonBoundary (C := C) n),Skeleton C (n+1)) :=
+  Attachment.lift _ (skeletonBase n) (skeletonCell n) (fun _ _ => rfl)
+
+lemma skeletonAssembly_base (n : ℕ) (x : Skeleton C n) :
+    skeletonAssembly n (Attachment.base _ x) = skeletonBase n x :=
+  Attachment.lift_base _ _ _ _ x
+
+lemma skeletonAssembly_cell (n : ℕ) (i : RelCWComplex.cell C n) (x : Disk n) :
+    skeletonAssembly n (Attachment.cell _ i x) = skeletonCell n i x :=
+  Attachment.lift_cell _ _ _ _ i x
+
+lemma skeletonAssembly_interior (n : ℕ) (i : RelCWComplex.cell C n) (x : Attachment.OpenDisk n) :
+    skeletonAssembly n (Sum.inr ⟨i,x⟩) = skeletonCell n i (Attachment.interior n x) := by
+  rw [← Attachment.cell_interior (skeletonBoundary n) i x,skeletonAssembly_cell]
+
+lemma skeletonAssembly_injective (n : ℕ) : Function.Injective (skeletonAssembly (C := C) n) := by
+  intro a b hab
+  rcases a with a|⟨i,a⟩ <;> rcases b with b|⟨j,b⟩
+  · change skeletonAssembly n (Attachment.base _ a) = skeletonAssembly n (Attachment.base _ b) at hab
+    rw [skeletonAssembly_base,skeletonAssembly_base] at hab
+    exact congrArg Sum.inl (Subtype.ext (congrArg (fun z : Skeleton C (n+1) => z.1) hab))
+  · have hh := congrArg Subtype.val hab
+    rw [← show Attachment.base (skeletonBoundary n) a = Sum.inl a from rfl,
+      skeletonAssembly_base,skeletonAssembly_interior] at hh
+    have hm : a.1 ∈ CWComplex.openCell n j := ⟨b.1,b.2,hh.symm⟩
+    exact False.elim (openCell_not_skeleton n j hm a.2)
+  · have hh := congrArg Subtype.val hab
+    rw [skeletonAssembly_interior,
+      ← show Attachment.base (skeletonBoundary n) b = Sum.inl b from rfl,
+      skeletonAssembly_base] at hh
+    have hm : b.1 ∈ CWComplex.openCell n i := ⟨a.1,a.2,hh⟩
+    exact False.elim (openCell_not_skeleton n i hm b.2)
+  · have hh := congrArg Subtype.val hab
+    rw [skeletonAssembly_interior,skeletonAssembly_interior] at hh
+    have hij : i = j := by
+      by_contra hne
+      have hd := CWComplex.disjoint_openCell_of_ne (C := C) (i := i) (j := j)
+        (fun h => hne (sigma_mk_injective h))
+      exact Set.disjoint_left.mp hd ⟨a.1,a.2,rfl⟩ ⟨b.1,b.2,hh.symm⟩
+    subst j
+    have he : a = b := Subtype.ext ((RelCWComplex.map n i).injOn
+      (by simpa only [RelCWComplex.source_eq] using a.2)
+      (by simpa only [RelCWComplex.source_eq] using b.2) hh)
+    subst b; rfl
+
+lemma skeletonAssembly_surjective (n : ℕ) : Function.Surjective (skeletonAssembly (C := C) n) := by
+  intro x
+  have hx := x.2
+  have heq : Skeleton C (n+1) = Skeleton C n ∪
+      ⋃ i : RelCWComplex.cell C n,CWComplex.closedCell n i := by
+    simpa only [Skeleton,Nat.cast_add,Nat.cast_one] using
+      (CWComplex.skeletonLT_union_iUnion_closedCell_eq_skeletonLT_succ (C := C) n).symm
+  have hx' := (congrArg (fun S : Set X => x.1 ∈ S) heq).mp hx
+  rcases hx' with hx|hx
+  · exact ⟨Attachment.base _ ⟨x.1,hx⟩,skeletonAssembly_base n _⟩
+  · obtain ⟨i,y,hy,he⟩ := Set.mem_iUnion.mp hx
+    refine ⟨Attachment.cell _ i ⟨y,hy⟩,?_⟩
+    rw [skeletonAssembly_cell]
+    exact Subtype.ext he
+
+lemma skeletonAssembly_closed (n : ℕ) : IsClosedMap (skeletonAssembly (C := C) n) := by
+  intro S hS
+  let e : Attachment.Space (skeletonBoundary (C := C) n) → X :=
+    fun x => (skeletonAssembly n x).1
+  have hei : Function.Injective e := Subtype.val_injective.comp (skeletonAssembly_injective n)
+  have hclosed : IsClosed (e '' S) := by
+    apply (CWComplex.closed (Skeleton C (n+1)) _ ?_).mpr
+    · intro m j
+      have hm : m < n+1 := by
+        have hh : (m : ℕ∞) < ((n+1 : ℕ) : ℕ∞) := by
+          simpa only [RelCWComplex.skeletonLT_I,Set.mem_ofPred_eq] using j.2
+        exact_mod_cast hh
+      have hu : ∃ u : C(Disk m,Attachment.Space (skeletonBoundary (C := C) n)),
+          ∀ x, e (u x) = characteristic m j.1 x := by
+        rcases Nat.lt_succ_iff_lt_or_eq.mp hm with hm|hm
+        · refine ⟨⟨fun x => Attachment.base _
+            ⟨characteristic m j.1 x,characteristic_mem_skeleton hm j.1 x⟩,
+            (Attachment.continuous_base _).comp ((characteristic m j.1).continuous.subtype_mk _)⟩,?_⟩
+          intro x; exact congrArg Subtype.val (skeletonAssembly_base n _)
+        · subst m
+          exact ⟨Attachment.cell _ j.1,fun x => congrArg Subtype.val (skeletonAssembly_cell n j.1 x)⟩
+      obtain ⟨u,hu⟩ := hu
+      have heq : (e '' S) ∩ CWComplex.closedCell m j =
+          characteristic m j.1 '' (u ⁻¹' S) := by
+        ext x
+        constructor
+        · rintro ⟨⟨y,hy,rfl⟩,z,hz,he⟩
+          refine ⟨⟨z,hz⟩,?_,he⟩
+          change u ⟨z,hz⟩ ∈ S
+          have hh : u ⟨z,hz⟩ = y := hei ((hu _).trans he)
+          rwa [hh]
+        · rintro ⟨z,hz,rfl⟩
+          exact ⟨⟨u z,hz,hu z⟩,z.1,z.2,rfl⟩
+      rw [heq]
+      exact ((hS.preimage u.continuous).isCompact.image (characteristic m j.1).continuous).isClosed
+    · rintro x ⟨y,hy,rfl⟩
+      exact (skeletonAssembly n y).2
+  have h : IsClosed ((Subtype.val : Skeleton C (n+1) → X) ⁻¹' (e '' S)) :=
+    hclosed.preimage continuous_subtype_val
+  convert h using 1
+  ext x
+  constructor
+  · rintro ⟨y,hy,rfl⟩; exact ⟨y,hy,rfl⟩
+  · rintro ⟨y,hy,he⟩; exact ⟨y,hy,Subtype.ext he⟩
+
+/-- A classical CW skeleton is literally the topological adjunction of the
+previous skeleton and its disks, including arbitrary infinite cell families. -/
+def skeletonHomeomorph (n : ℕ) :
+    Attachment.Space (skeletonBoundary (C := C) n) ≃ₜ Skeleton C (n+1) :=
+  (isHomeomorph_iff_continuous_isClosedMap_bijective.mpr
+    ⟨(skeletonAssembly n).continuous,skeletonAssembly_closed n,
+      skeletonAssembly_injective n,skeletonAssembly_surjective n⟩).homeomorph _
+end
+
+section
+open Set Metric Topology
+universe u
+variable {G : Type u} [Group G] {X : Type u} [TopologicalSpace X] [T2Space X]
+  [MulAction G X] [ContinuousConstSMul G X] [CWComplex (univ : Set X)]
+variable {ι : ℕ → Type u}
+variable (σ : ∀ n, (G × ι n) ≃ RelCWComplex.cell (univ : Set X) n)
+variable (hσ : ∀ n (g h : G) (i : ι n) (x : Fin n → ℝ),
+  RelCWComplex.map n (σ n (g*h,i)) x = g • RelCWComplex.map n (σ n (h,i)) x)
+
+omit [ContinuousConstSMul G X] in
+include hσ in
+lemma skeleton_smul_mem (n : ℕ) (g : G) {x : X} (hx : x ∈ Skeleton (univ : Set X) n) :
+    g • x ∈ Skeleton (univ : Set X) n := by
+  obtain ⟨m,hm,j,y,hy,rfl⟩ := (CWComplex.mem_skeletonLT_iff (C := (univ : Set X))).mp hx
+  let i := (σ m).symm j
+  have hj : σ m i = j := (σ m).apply_symm_apply j
+  apply (CWComplex.mem_skeletonLT_iff (C := (univ : Set X))).mpr
+  refine ⟨m,hm,σ m (g*i.1,i.2),y,hy,?_⟩
+  rw [hσ]
+  exact congrArg (fun j => g • RelCWComplex.map m j y) hj
+
+def skeletonTranslate (n : ℕ) (g : G) : C(Skeleton (univ : Set X) n,Skeleton (univ : Set X) n) :=
+  ⟨fun x => ⟨g • x.1,skeleton_smul_mem σ hσ n g x.2⟩,
+    ((continuous_const_smul g).comp continuous_subtype_val).subtype_mk _⟩
+
+lemma skeletonTranslate_base (n : ℕ) (g : G) (x : Skeleton (univ : Set X) n) :
+    skeletonTranslate σ hσ (n+1) g (skeletonBase n x) =
+      skeletonBase n (skeletonTranslate σ hσ n g x) := rfl
+
+lemma skeletonTranslate_cell (n : ℕ) (g h : G) (i : ι n) (x : Disk n) :
+    skeletonTranslate σ hσ (n+1) g (skeletonCell n (σ n (h,i)) x) =
+      skeletonCell n (σ n (g*h,i)) x := by
+  apply Subtype.ext
+  exact (hσ n g h i x.1).symm
+
+variable {E : Type u} [TopologicalSpace E] [MulAction G E] [ContinuousConstSMul G E]
+
+lemma exists_equivariant_skeleton_extension (n : ℕ)
+    (b : C(Skeleton (univ : Set X) n,E))
+    (hb : ∀ (g : G) x, b (skeletonTranslate σ hσ n g x) = g • b x)
+    (hfill : ∀ a : C(Sphere n,E), ∃ d : C(Disk n,E), ∀ x, d (boundary n x) = a x) :
+    ∃ e : C(Skeleton (univ : Set X) (n+1),E),
+      (∀ x, e (skeletonBase n x) = b x) ∧
+      ∀ (g : G) x, e (skeletonTranslate σ hσ (n+1) g x) = g • e x := by
+  let a (i : ι n) := b.comp (skeletonBoundary n (σ n (1,i)))
+  choose d hd using fun i => hfill (a i)
+  let D (j : RelCWComplex.cell (univ : Set X) n) : C(Disk n,E) :=
+    ⟨fun x => ((σ n).symm j).1 • d ((σ n).symm j).2 x,
+      (continuous_const_smul _).comp (d _).continuous⟩
+  have hD (j : RelCWComplex.cell (univ : Set X) n) (x : Sphere n) :
+      D j (boundary n x) = b (skeletonBoundary n j x) := by
+    obtain ⟨⟨g,i⟩,rfl⟩ := (σ n).surjective j
+    change ((σ n).symm (σ n (g,i))).1 • d ((σ n).symm (σ n (g,i))).2 (boundary n x) = _
+    rw [Equiv.symm_apply_apply,hd]
+    change g • b (skeletonBoundary n (σ n (1,i)) x) = _
+    rw [←hb]
+    congr 1
+    apply Subtype.ext
+    exact (hσ n g 1 i x.1).symm.trans (by rw [mul_one]; rfl)
+  let f := Attachment.lift (skeletonBoundary (C := (univ : Set X)) n) b D hD
+  let e : C(Skeleton (univ : Set X) (n+1),E) := f.comp ⟨(skeletonHomeomorph n).symm,(skeletonHomeomorph n).symm.continuous⟩
+  have he_base (x : Skeleton (univ : Set X) n) : e (skeletonBase n x) = b x := by
+    change f ((skeletonHomeomorph n).symm (skeletonBase n x)) = _
+    rw [←skeletonAssembly_base]
+    change f ((skeletonHomeomorph n).symm ((skeletonHomeomorph n) (Attachment.base _ x))) = _
+    rw [Homeomorph.symm_apply_apply]
+    rfl
+  have he_cell (j : RelCWComplex.cell (univ : Set X) n) (x : Disk n) :
+      e (skeletonCell n j x) = D j x := by
+    change f ((skeletonHomeomorph n).symm (skeletonCell n j x)) = _
+    rw [←skeletonAssembly_cell]
+    change f ((skeletonHomeomorph n).symm ((skeletonHomeomorph n) (Attachment.cell _ j x))) = _
+    rw [Homeomorph.symm_apply_apply]
+    exact Attachment.lift_cell _ _ _ _ _ _
+  refine ⟨e,he_base,?_⟩
+  intro g x
+  obtain ⟨y,rfl⟩ := skeletonAssembly_surjective n x
+  cases y with
+  | inl x =>
+    change e (skeletonTranslate σ hσ (n+1) g (skeletonBase n x)) = g • e (skeletonBase n x)
+    rw [skeletonTranslate_base,he_base,he_base,hb]
+  | inr p =>
+    obtain ⟨⟨h,i⟩,hj⟩ := (σ n).surjective p.1
+    have heq : skeletonAssembly n (Sum.inr p) = skeletonCell n p.1 (Attachment.interior n p.2) := by
+      exact skeletonAssembly_interior n p.1 p.2
+    rw [heq,←hj,skeletonTranslate_cell,he_cell,he_cell]
+    change ((σ n).symm (σ n (g*h,i))).1 • d ((σ n).symm (σ n (g*h,i))).2 _ =
+      g • (((σ n).symm (σ n (h,i))).1 • d ((σ n).symm (σ n (h,i))).2 _)
+    simp only [Equiv.symm_apply_apply,mul_smul]
+end
+
+section
+open Set Metric Topology
+universe u
+variable {G : Type u} [Group G] {X : Type u} [TopologicalSpace X] [T2Space X]
+  [MulAction G X] [ContinuousConstSMul G X] [CWComplex (univ : Set X)]
+variable {ι : ℕ → Type u}
+variable (σ : ∀ n, (G × ι n) ≃ RelCWComplex.cell (univ : Set X) n)
+variable (hσ : ∀ n (g h : G) (i : ι n) (x : Fin n → ℝ),
+  RelCWComplex.map n (σ n (g*h,i)) x = g • RelCWComplex.map n (σ n (h,i)) x)
+variable {E B : Type u} [TopologicalSpace E] [TopologicalSpace B]
+  [MulAction G E] [ContinuousConstSMul G E] [MulAction G B]
+
+lemma exists_equivariant_skeleton_lift (n : ℕ) (p : C(E,B))
+    (hp : ∀ (g : G) e, p (g • e) = g • p e) (hRLP : DiskRLP p)
+    (F : C(Skeleton (univ : Set X) (n+1),B))
+    (hF : ∀ (g : G) x, F (skeletonTranslate σ hσ (n+1) g x) = g • F x)
+    (b : C(Skeleton (univ : Set X) n,E))
+    (hb : ∀ (g : G) x, b (skeletonTranslate σ hσ n g x) = g • b x)
+    (hbF : ∀ x, p (b x) = F (skeletonBase n x)) :
+    ∃ e : C(Skeleton (univ : Set X) (n+1),E),
+      (∀ x, e (skeletonBase n x) = b x) ∧ (∀ x, p (e x) = F x) ∧
+      ∀ (g : G) x, e (skeletonTranslate σ hσ (n+1) g x) = g • e x := by
+  let a (i : ι n) := b.comp (skeletonBoundary n (σ n (1,i)))
+  let c (i : ι n) := F.comp (skeletonCell n (σ n (1,i)))
+  have hsq (i : ι n) (x : Sphere n) : p (a i x) = c i (boundary n x) := by
+    change p (b (skeletonBoundary n (σ n (1,i)) x)) = F (skeletonCell n (σ n (1,i)) (boundary n x))
+    rw [hbF]
+    rfl
+  choose d hd hf using fun i => hRLP n (a i) (c i) (hsq i)
+  let D (j : RelCWComplex.cell (univ : Set X) n) : C(Disk n,E) :=
+    ⟨fun x => ((σ n).symm j).1 • d ((σ n).symm j).2 x,
+      (continuous_const_smul _).comp (d _).continuous⟩
+  have hD (j : RelCWComplex.cell (univ : Set X) n) (x : Sphere n) :
+      D j (boundary n x) = b (skeletonBoundary n j x) := by
+    obtain ⟨⟨g,i⟩,rfl⟩ := (σ n).surjective j
+    change ((σ n).symm (σ n (g,i))).1 • d ((σ n).symm (σ n (g,i))).2 (boundary n x) = _
+    rw [Equiv.symm_apply_apply,hd]
+    change g • b (skeletonBoundary n (σ n (1,i)) x) = _
+    rw [←hb]
+    congr 1
+    apply Subtype.ext
+    exact (hσ n g 1 i x.1).symm.trans (by rw [mul_one]; rfl)
+  let f := Attachment.lift (skeletonBoundary (C := (univ : Set X)) n) b D hD
+  let e : C(Skeleton (univ : Set X) (n+1),E) := f.comp ⟨(skeletonHomeomorph n).symm,(skeletonHomeomorph n).symm.continuous⟩
+  have he_base (x : Skeleton (univ : Set X) n) : e (skeletonBase n x) = b x := by
+    change f ((skeletonHomeomorph n).symm (skeletonBase n x)) = _
+    rw [←skeletonAssembly_base]
+    change f ((skeletonHomeomorph n).symm ((skeletonHomeomorph n) (Attachment.base _ x))) = _
+    rw [Homeomorph.symm_apply_apply]
+    rfl
+  have he_cell (j : RelCWComplex.cell (univ : Set X) n) (x : Disk n) :
+      e (skeletonCell n j x) = D j x := by
+    change f ((skeletonHomeomorph n).symm (skeletonCell n j x)) = _
+    rw [←skeletonAssembly_cell]
+    change f ((skeletonHomeomorph n).symm ((skeletonHomeomorph n) (Attachment.cell _ j x))) = _
+    rw [Homeomorph.symm_apply_apply]
+    exact Attachment.lift_cell _ _ _ _ _ _
+  have he (g : G) (x : Skeleton (univ : Set X) (n+1)) :
+      e (skeletonTranslate σ hσ (n+1) g x) = g • e x := by
+    obtain ⟨y,rfl⟩ := skeletonAssembly_surjective n x
+    cases y with
+    | inl x =>
+      change e (skeletonTranslate σ hσ (n+1) g (skeletonBase n x)) = g • e (skeletonBase n x)
+      rw [skeletonTranslate_base,he_base,he_base,hb]
+    | inr q =>
+      obtain ⟨⟨h,i⟩,hj⟩ := (σ n).surjective q.1
+      have heq : skeletonAssembly n (Sum.inr q) = skeletonCell n q.1 (Attachment.interior n q.2) :=
+        skeletonAssembly_interior n q.1 q.2
+      rw [heq,←hj,skeletonTranslate_cell,he_cell,he_cell]
+      change ((σ n).symm (σ n (g*h,i))).1 • d ((σ n).symm (σ n (g*h,i))).2 _ =
+        g • (((σ n).symm (σ n (h,i))).1 • d ((σ n).symm (σ n (h,i))).2 _)
+      simp only [Equiv.symm_apply_apply,mul_smul]
+  refine ⟨e,he_base,?_,he⟩
+  intro x
+  obtain ⟨y,rfl⟩ := skeletonAssembly_surjective n x
+  cases y with
+  | inl x =>
+    change p (e (skeletonBase n x)) = F (skeletonBase n x)
+    rw [he_base,hbF]
+  | inr q =>
+    rw [skeletonAssembly_interior,he_cell]
+    obtain ⟨⟨g,i⟩,hj⟩ := (σ n).surjective q.1
+    rw [←hj]
+    change p (((σ n).symm (σ n (g,i))).1 • d ((σ n).symm (σ n (g,i))).2 _) = _
+    rw [Equiv.symm_apply_apply,hp,hf]
+    change g • F (skeletonCell n (σ n (1,i)) _) = _
+    rw [←hF,skeletonTranslate_cell,mul_one]
+end
+
+open Set Metric Topology
+universe u
+variable {G : Type u} [Group G] {X : Type u} [TopologicalSpace X] [T2Space X]
+  [MulAction G X] [ContinuousConstSMul G X] [CWComplex (univ : Set X)]
+variable {ι : ℕ → Type u}
+variable (σ : ∀ n, (G × ι n) ≃ RelCWComplex.cell (univ : Set X) n)
+variable (hσ : ∀ n (g h : G) (i : ι n) (x : Fin n → ℝ),
+  RelCWComplex.map n (σ n (g*h,i)) x = g • RelCWComplex.map n (σ n (h,i)) x)
+omit [MulAction G X] [ContinuousConstSMul G X] in
+lemma isEmpty_skeleton_zero : IsEmpty (Skeleton (univ : Set X) 0) := by
+  refine ⟨fun x => ?_⟩
+  have hx := x.2
+  change x.1 ∈ (CWComplex.skeletonLT (univ : Set X) 0 : Set X) at hx
+  rw [CWComplex.skeletonLT_zero_eq_empty] at hx
+  exact hx
+
+variable {E B : Type u} [TopologicalSpace E] [TopologicalSpace B]
+  [MulAction G E] [ContinuousConstSMul G E] [MulAction G B]
+
+lemma exists_equivariant_lift_on_skeleton (d : ℕ) (p : C(E,B))
+    (hp : ∀ (g : G) e, p (g • e) = g • p e) (hRLP : DiskRLP p)
+    (F : C(Skeleton (univ : Set X) d,B))
+    (hF : ∀ (g : G) x, F (skeletonTranslate σ hσ d g x) = g • F x) :
+    ∃ e : C(Skeleton (univ : Set X) d,E), (∀ x, p (e x) = F x) ∧
+      ∀ (g : G) x, e (skeletonTranslate σ hσ d g x) = g • e x := by
+  induction d with
+  | zero =>
+    let := isEmpty_skeleton_zero (X := X)
+    exact ⟨⟨isEmptyElim,continuous_of_discreteTopology⟩,fun x => isEmptyElim x,fun _ x => isEmptyElim x⟩
+  | succ d ih =>
+    obtain ⟨b,hbF,hb⟩ := ih (F.comp (skeletonBase d)) (fun g x => by
+      change F (skeletonBase d (skeletonTranslate σ hσ d g x)) = g • F (skeletonBase d x)
+      rw [←skeletonTranslate_base,hF])
+    obtain ⟨e,_,heF,he⟩ := exists_equivariant_skeleton_lift σ hσ d p hp hRLP F hF b hb hbF
+    exact ⟨e,heF,he⟩
+
+lemma exists_equivariant_map_on_skeleton (d : ℕ)
+    (hfill : ∀ n < d, ∀ a : C(Sphere n,E), ∃ e : C(Disk n,E), ∀ x, e (boundary n x) = a x) :
+    ∃ e : C(Skeleton (univ : Set X) d,E),
+      ∀ (g : G) x, e (skeletonTranslate σ hσ d g x) = g • e x := by
+  induction d with
+  | zero =>
+    let := isEmpty_skeleton_zero (X := X)
+    exact ⟨⟨isEmptyElim,continuous_of_discreteTopology⟩,fun _ x => isEmptyElim x⟩
+  | succ d ih =>
+    obtain ⟨b,hb⟩ := ih (fun n hn => hfill n (Nat.lt_succ_of_lt hn))
+    obtain ⟨e,_,he⟩ := exists_equivariant_skeleton_extension σ hσ d b hb (hfill d (Nat.lt_succ_self d))
+    exact ⟨e,he⟩
+
+variable {Y : Type u} [TopologicalSpace Y] [MulAction G Y] [ContinuousConstSMul G Y]
+lemma exists_equivariant_homotopy_on_skeleton (d : ℕ) (hY : SphereFillable Y)
+    (a b : C(Skeleton (univ : Set X) d,Y))
+    (ha : ∀ (g : G) x, a (skeletonTranslate σ hσ d g x) = g • a x)
+    (hb : ∀ (g : G) x, b (skeletonTranslate σ hσ d g x) = g • b x) :
+    ∃ H : a.Homotopy b, ∀ (g : G) t x,
+      H (t,skeletonTranslate σ hσ d g x) = g • H (t,x) := by
+  let F : C(Skeleton (univ : Set X) d,Y × Y) := a.prodMk b
+  have hF (g : G) x : F (skeletonTranslate σ hσ d g x) = g • F x := by
+    exact Prod.ext (ha g x) (hb g x)
+  obtain ⟨e,heF,he⟩ := exists_equivariant_lift_on_skeleton σ hσ d pathEndpoint
+    (fun _ _ => rfl) (pathEndpoint_RLP hY) F hF
+  let H : a.Homotopy b :=
+    { toFun := fun z => e z.2 z.1
+      continuous_toFun := e.continuous.comp continuous_snd |>.eval continuous_fst
+      map_zero_left := fun x => congrArg Prod.fst (heF x)
+      map_one_left := fun x => congrArg Prod.snd (heF x) }
+  refine ⟨H,?_⟩
+  intro g t x
+  exact ContinuousMap.congr_fun (he g x) t
+
+omit [MulAction G X] [ContinuousConstSMul G X] in
+def skeletonChart (n m : ℕ) (hm : m < n) (i : RelCWComplex.cell (univ : Set X) m) :
+    C(Disk m,Skeleton (univ : Set X) n) :=
+  ⟨fun z => ⟨characteristic m i z,characteristic_mem_skeleton hm i z⟩,
+    (characteristic m i).continuous.subtype_mk _⟩
+
+lemma skeleton_compact_representatives (n : ℕ) [∀ m,Finite (ι m)] :
+    ∃ K : Set (Skeleton (univ : Set X) n), IsCompact K ∧
+      ∀ x, ∃ g : G, ∃ y ∈ K, x = skeletonTranslate σ hσ n g y := by
+  let K := ⋃ m : Fin n, ⋃ i : ι m, Set.range (skeletonChart n m m.2 (σ m (1,i)))
+  have hK : IsCompact K := isCompact_iUnion fun m => isCompact_iUnion fun i =>
+    isCompact_range (skeletonChart n m m.2 (σ m (1,i))).continuous
+  refine ⟨K,hK,?_⟩
+  intro x
+  obtain ⟨m,hm,j,z,hz,hj⟩ := (CWComplex.mem_skeletonLT_iff (C := (univ : Set X))).mp x.2
+  obtain ⟨⟨g,i⟩,rfl⟩ := (σ m).surjective j
+  have hmn : m < n := by exact_mod_cast hm
+  let y := skeletonChart n m hmn (σ m (1,i)) ⟨z,ball_subset_closedBall hz⟩
+  refine ⟨g,y,Set.mem_iUnion.mpr ⟨⟨m,hmn⟩,Set.mem_iUnion.mpr ⟨i,Set.mem_range_self _⟩⟩,?_⟩
+  apply Subtype.ext
+  change x.1 = g • RelCWComplex.map m (σ m (1,i)) z
+  rw [←hσ,mul_one]
+  exact hj.symm
+end GroupRingTopology.Cellular
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/GroupRing/ChainActiveStages.lean b/lean/OAI/Algebra/GroupRing/ChainActiveStages.lean
new file mode 100644
index 0000000000000000000000000000000000000000..d9f05ab105860107e953619e9ae847d6e477d3dd
--- /dev/null
+++ b/lean/OAI/Algebra/GroupRing/ChainActiveStages.lean
@@ -0,0 +1,368 @@
+import Mathlib
+import OAI.Algebra.GroupRing.ChunkComparisons
+
+namespace OAI
+
+noncomputable section
+
+namespace TorsionFreeZeroDivisors.ChainActiveStages
+open scoped Classical BigOperators
+open Function PortSubdivision ChainSuppression DegreeTwoSuppression SuppressedMoore ChainPaths
+open ChainIsomorphism ChainChunkTransport ChainMultiplicity ChunkComparisons FiniteChunking
+open StageSubgraphs
+variable {V D : Type*} [Fintype D] (Γ : PortGraph V D)
+    (mark : V → Prop) (h2 : ∀ v, ¬mark v → (out Γ.origin v).card=2)
+    {P : Type*} [Fintype P] (paths : P → List {d : D // turn Γ.origin mark h2 d=d})
+local notation "B" => {d : D // turn Γ.origin mark h2 d=d}
+local notation "S" => suppressed Γ mark h2
+local notation "R" => ChainIsomorphism.Rep Γ mark h2
+local notation "col" => color Γ mark h2 paths
+local notation "e" => ListStageExponents.edge paths
+local notation "m" => StageSubgraphs.multiplicity (S) e
+abbrev ActiveChain (j : ℕ) := {c : R // j < ChunkComparisons.multiplicity col c}
+local notation "A" => ActiveChain Γ mark h2 paths
+
+/-- Literal active chain orientations, with no padding by inactive chains. -/
+def activeOrientation (j : ℕ) : ActiveD m j ≃ A j × Bool where
+  toFun d := (⟨representative Γ mark h2 d.val,by
+    rw [←multiplicity_at Γ mark h2 paths]; exact d.property⟩,reversed Γ mark h2 d.val)
+  invFun c := ⟨orientation Γ mark h2 (c.1.val,c.2),by
+    rw [multiplicity_at Γ mark h2 paths]
+    change j < ChunkComparisons.multiplicity col (((orientation Γ mark h2).symm ((orientation Γ mark h2) (c.1.val,c.2))).1)
+    rw [Equiv.symm_apply_apply]
+    exact c.1.property⟩
+  left_inv d := by
+    apply Subtype.ext
+    exact (orientation Γ mark h2).apply_symm_apply d.val
+  right_inv c := by
+    apply Prod.ext
+    · apply Subtype.ext
+      change ((orientation Γ mark h2).symm ((orientation Γ mark h2) (c.1.val,c.2))).1=c.1.val
+      rw [Equiv.symm_apply_apply]
+    · change ((orientation Γ mark h2).symm ((orientation Γ mark h2) (c.1.val,c.2))).2=c.2
+      rw [Equiv.symm_apply_apply]
+
+variable [Fintype V]
+
+omit [Fintype V] in
+lemma edges_card (j : ℕ) :
+    (edges (stage (S) m (multiplicity_reverse (S) e) j)).card=Fintype.card (A j) := by
+  have ha := Fintype.card_congr (activeOrientation Γ mark h2 paths j)
+  rw [Fintype.card_prod,Fintype.card_bool] at ha
+  have he := two_edges (stage (S) m (multiplicity_reverse (S) e) j)
+  omega
+
+def first (j : ℕ) (c : A j) : ActiveV (S) m j :=
+  ⟨ChainIsomorphism.first Γ mark h2 c.val,c.val.val,rfl,by
+    rw [multiplicity_eq Γ mark h2 paths]; exact c.property⟩
+
+def last (j : ℕ) (c : A j) : ActiveV (S) m j :=
+  ⟨ChainIsomorphism.last Γ mark h2 c.val,(S).reverse c.val.val,rfl,by
+    rw [multiplicity_reverse,multiplicity_eq Γ mark h2 paths]; exact c.property⟩
+
+omit [Fintype V] in
+lemma incident (j : ℕ) (v : ActiveV (S) m j) :
+    ∃ c : A j, first Γ mark h2 paths j c=v ∨ last Γ mark h2 paths j c=v := by
+  rcases v.property with ⟨d,hd,hm⟩
+  let c : A j := ⟨representative Γ mark h2 d,by rwa [←multiplicity_at Γ mark h2 paths]⟩
+  refine ⟨c,?_⟩
+  have h := oriented Γ mark h2 d
+  cases hr : reversed Γ mark h2 d
+  · left
+    apply Subtype.ext
+    change (S).origin c.val.val=v.val
+    simp only [hr,Bool.false_eq_true,ite_false] at h
+    change d=c.val.val at h
+    rw [←h,hd]
+  · right
+    apply Subtype.ext
+    change (S).origin ((S).reverse c.val.val)=v.val
+    simp only [hr,ite_true] at h
+    change d=(S).reverse c.val.val at h
+    rw [←h,hd]
+
+/-- The signed exponent counted by the chain expectation is exactly the one
+bounded by immersed path incidence, including the first-stage root saving. -/
+theorem exponent_nonpos (hp : ∀ i,paths i≠[]) (cyclic : P → Bool)
+    (hc : ∀ i,(paths i).IsChain (WeightedMoore.PortWalk.step (S).origin (S).reverse))
+    (hclose : ∀ i,cyclic i=true → ∀ᵉ (x∈(paths i).getLast?) (y∈(paths i).head?),
+      WeightedMoore.PortWalk.step (S).origin (S).reverse x y)
+    (M : ℕ) (hM : 0<M) (hm : ∀ c : R,ChunkComparisons.multiplicity col c ≤ M) :
+    (∑ j : Fin M, ((Fintype.card (ActiveV (S) m j.val):ℤ)-Fintype.card (A j.val)-
+      if j.val=0 then Fintype.card {i : P // cyclic i=false} else 0)) ≤ 0 := by
+  have hd : ∀ d,m d ≤ M := by
+    intro d
+    rw [multiplicity_at Γ mark h2 paths]
+    exact hm _
+  have h := ListStageExponents.exponent_nonpos (S) paths hp cyclic hc hclose M hM hd
+  simpa only [ListStageExponents.mult,edges_card Γ mark h2 paths] using h
+
+end TorsionFreeZeroDivisors.ChainActiveStages
+
+namespace TorsionFreeZeroDivisors.SubdivisionRestriction
+open scoped Classical
+open ChainSubdivision
+variable {C V : Type*} (len : C → ℕ) (first last : C → V)
+    (active : C → Prop) (incident : V → Prop)
+    (hf : ∀ c,active c → incident (first c))
+    (hl : ∀ c,active c → incident (last c))
+
+abbrev length : {c // active c} → ℕ := fun c => len c.val
+def firstPoint (c : {c // active c}) : {v // incident v} := ⟨first c.val,hf _ c.property⟩
+def lastPoint (c : {c // active c}) : {v // incident v} := ⟨last c.val,hl _ c.property⟩
+
+local notation "P" => graph len first last
+local notation "Q" => graph (length len active) (firstPoint first active incident hf) (lastPoint last active incident hl)
+
+def vertex : Vertex (length len active) (V := {v // incident v}) → Vertex len (V := V)
+  | .inl v => .inl v.val
+  | .inr ⟨c,i⟩ => .inr ⟨c.val,i⟩
+
+def dart : Dart (length len active) → Dart len := fun d => (⟨d.1.1.val,d.1.2⟩,d.2)
+
+lemma vertex_injective : Function.Injective (vertex len active incident) := by
+  intro v w h
+  cases v with
+  | inl v =>
+    cases w with
+    | inl w => exact congrArg Sum.inl (Subtype.ext (Sum.inl.inj h))
+    | inr w => cases h
+  | inr v =>
+    cases w with
+    | inl w => cases h
+    | inr w =>
+      rcases v with ⟨⟨c,hc⟩,i⟩
+      rcases w with ⟨⟨d,hd⟩,k⟩
+      have h' := Sum.inr.inj h
+      have hcd := congrArg Sigma.fst h'
+      cases hcd
+      have hik : i=k := eq_of_heq (Sigma.mk.inj_iff.mp h').2
+      cases hik
+      rfl
+
+lemma dart_injective : Function.Injective (dart len active) := by
+  rintro ⟨⟨⟨c,hc⟩,i⟩,r⟩ ⟨⟨⟨d,hd⟩,k⟩,s⟩ h
+  have hrs := congrArg Prod.snd h
+  cases hrs
+  have h' := congrArg Prod.fst h
+  have hcd := congrArg Sigma.fst h'
+  cases hcd
+  have hik : i=k := eq_of_heq (Sigma.mk.inj_iff.mp h').2
+  cases hik
+  rfl
+
+lemma point_map (c : {c // active c}) (k : Fin ((length len active) c+1)) :
+    vertex len active incident
+      (point (length len active) (firstPoint first active incident hf) (lastPoint last active incident hl) c k) =
+      point len first last c.val k := by
+  unfold point
+  split_ifs <;> rfl
+
+lemma origin_map (d : Dart (length len active)) :
+    vertex len active incident ((Q).origin d)=(P).origin (dart len active d) := by
+  rcases d with ⟨⟨c,i⟩,r⟩
+  cases r
+  · simpa only [dart,origin_forward] using
+      point_map len first last active incident hf hl c ⟨i.val,by have h:=i.isLt; omega⟩
+  · simpa only [dart,origin_backward] using
+      point_map len first last active incident hf hl c ⟨i.val+1,by have h:=i.isLt; omega⟩
+
+lemma reverse_map (d : Dart (length len active)) :
+    dart len active ((Q).reverse d)=(P).reverse (dart len active d) := rfl
+
+end TorsionFreeZeroDivisors.SubdivisionRestriction
+
+namespace TorsionFreeZeroDivisors.ChainStageEmbedding
+open scoped Classical BigOperators
+open Function PortSubdivision ChainSuppression DegreeTwoSuppression SuppressedMoore ChainPaths
+open ChainIsomorphism ChainChunkTransport ChainMultiplicity ChunkComparisons FiniteChunking
+open StageSubgraphs
+variable {V D : Type*} [Fintype D] (Γ : PortGraph V D)
+    (mark : V → Prop) (h2 : ∀ v, ¬mark v → (out Γ.origin v).card=2)
+    {P : Type*} [Fintype P] (paths : P → List {d : D // turn Γ.origin mark h2 d=d}) (j : ℕ)
+local notation "S" => suppressed Γ mark h2
+local notation "R" => ChainIsomorphism.Rep Γ mark h2
+local notation "col" => color Γ mark h2 paths
+local notation "e" => ListStageExponents.edge paths
+local notation "m" => StageSubgraphs.multiplicity (S) e
+local notation "A" => ChainActiveStages.ActiveChain Γ mark h2 paths j
+local notation "W" => ActiveV (S) m j
+
+abbrev length : A → ℕ := fun c => repLength Γ mark h2 c.val
+abbrev graph := ChainSubdivision.graph (length Γ mark h2 paths j)
+  (ChainActiveStages.first Γ mark h2 paths j) (ChainActiveStages.last Γ mark h2 paths j)
+local notation "Q" => graph Γ mark h2 paths j
+
+abbrev active (c : R) : Prop := j<ChunkComparisons.multiplicity col c
+def marked (v : W) : Mark mark := ⟨v.val,by
+  rcases v.property with ⟨d,hd,_⟩
+  rw [←hd]
+  exact (turn_fixed_iff Γ.origin mark h2 d.val).mp d.property⟩
+
+lemma marked_injective : Injective (marked Γ mark h2 paths j) := by
+  intro v w h
+  apply Subtype.ext
+  exact congrArg (fun z : Mark mark => z.val) h
+
+def vertexLift : ChainSubdivision.Vertex (length Γ mark h2 paths j) (V := W) →
+    ChainSubdivision.Vertex (repLength Γ mark h2) (V := Mark mark)
+  | .inl v => .inl (marked Γ mark h2 paths j v)
+  | .inr ⟨c,i⟩ => .inr ⟨c.val,i⟩
+
+lemma vertexLift_injective : Injective (vertexLift Γ mark h2 paths j) := by
+  intro v w h
+  cases v with
+  | inl v =>
+    cases w with
+    | inl w => exact congrArg Sum.inl (marked_injective Γ mark h2 paths j (Sum.inl.inj h))
+    | inr w => cases h
+  | inr v =>
+    cases w with
+    | inl w => cases h
+    | inr w =>
+      rcases v with ⟨⟨c,hc⟩,i⟩
+      rcases w with ⟨⟨d,hd⟩,k⟩
+      have h' := Sum.inr.inj h
+      have hcd := congrArg Sigma.fst h'
+      cases hcd
+      have hik : i=k := eq_of_heq (Sigma.mk.inj_iff.mp h').2
+      cases hik
+      rfl
+
+lemma point_lift (c : A) (k : Fin ((length Γ mark h2 paths j) c+1)) :
+    vertexLift Γ mark h2 paths j
+      (ChainSubdivision.point (length Γ mark h2 paths j)
+        (ChainActiveStages.first Γ mark h2 paths j) (ChainActiveStages.last Γ mark h2 paths j) c k) =
+      ChainSubdivision.point (repLength Γ mark h2) (ChainIsomorphism.first Γ mark h2)
+        (ChainIsomorphism.last Γ mark h2) c.val k := by
+  unfold ChainSubdivision.point
+  split_ifs <;> rfl
+
+def vertexMap : ChainSubdivision.Vertex (length Γ mark h2 paths j) (V := W) → V :=
+  ChainIsomorphism.vertexMap Γ mark h2 ∘ vertexLift Γ mark h2 paths j
+
+def dartMap : ChainSubdivision.Dart (length Γ mark h2 paths j) → D :=
+  ChainIsomorphism.dartMap Γ mark h2 ∘ SubdivisionRestriction.dart (repLength Γ mark h2)
+    (active Γ mark h2 paths j)
+
+lemma vertexMap_injective : Injective (vertexMap Γ mark h2 paths j) :=
+  (ChainIsomorphism.vertexMap_injective Γ mark h2).comp
+    (vertexLift_injective Γ mark h2 paths j)
+
+lemma dartMap_injective : Injective (dartMap Γ mark h2 paths j) :=
+  (ChainIsomorphism.dartMap_injective Γ mark h2).comp
+    (SubdivisionRestriction.dart_injective _ _)
+
+lemma origin_map (d : ChainSubdivision.Dart (length Γ mark h2 paths j)) :
+    vertexMap Γ mark h2 paths j ((Q).origin d)=Γ.origin (dartMap Γ mark h2 paths j d) := by
+  unfold vertexMap dartMap
+  dsimp only [Function.comp_apply]
+  have h : vertexLift Γ mark h2 paths j ((Q).origin d) =
+      (ChainSubdivision.graph (repLength Γ mark h2) (ChainIsomorphism.first Γ mark h2)
+        (ChainIsomorphism.last Γ mark h2)).origin
+        (SubdivisionRestriction.dart (repLength Γ mark h2) (active Γ mark h2 paths j) d) := by
+    rcases d with ⟨⟨c,i⟩,r⟩
+    cases r
+    · simpa only [SubdivisionRestriction.dart,ChainSubdivision.origin_forward] using
+        point_lift Γ mark h2 paths j c ⟨i.val,by have h:=i.isLt; omega⟩
+    · simpa only [SubdivisionRestriction.dart,ChainSubdivision.origin_backward] using
+        point_lift Γ mark h2 paths j c ⟨i.val+1,by have h:=i.isLt; omega⟩
+  rw [h]
+  exact ChainIsomorphism.origin_map Γ mark h2 _
+
+lemma reverse_map (d : ChainSubdivision.Dart (length Γ mark h2 paths j)) :
+    dartMap Γ mark h2 paths j ((Q).reverse d)=Γ.reverse (dartMap Γ mark h2 paths j d) := by
+  unfold dartMap
+  dsimp only [Function.comp_apply]
+  rw [show SubdivisionRestriction.dart (repLength Γ mark h2) (active Γ mark h2 paths j) ((Q).reverse d)=
+      (ChainSubdivision.graph (repLength Γ mark h2) (ChainIsomorphism.first Γ mark h2)
+        (ChainIsomorphism.last Γ mark h2)).reverse
+        (SubdivisionRestriction.dart (repLength Γ mark h2) (active Γ mark h2 paths j) d) from rfl]
+  exact ChainIsomorphism.dartMap_reverse Γ mark h2 _
+
+/-- Restricting an immersed realization keeps every active chain vertex and
+port injective, without ever trying to embed inactive marked vertices. -/
+theorem immersed {T : Type*} (label : D → T)
+    (hlabel : Injective (fun d => (Γ.origin d,label d))) :
+    Injective (fun d => ((Q).origin d,label (dartMap Γ mark h2 paths j d))) := by
+  intro a b h
+  apply dartMap_injective Γ mark h2 paths j
+  apply hlabel
+  apply Prod.ext
+  · change Γ.origin (dartMap Γ mark h2 paths j a) = Γ.origin (dartMap Γ mark h2 paths j b)
+    rw [←origin_map,←origin_map]
+    exact congrArg (vertexMap Γ mark h2 paths j) (congrArg Prod.fst h)
+  · change label (dartMap Γ mark h2 paths j a) = label (dartMap Γ mark h2 paths j b)
+    exact congrArg Prod.snd h
+
+end TorsionFreeZeroDivisors.ChainStageEmbedding
+
+namespace TorsionFreeZeroDivisors.RootPins
+open scoped Classical BigOperators
+variable {V T : Type*} [Fintype V]
+
+/-- At most one prescribed root. All other vertices remain unpinned. -/
+def pin (root : Option V) (target : T) (v : V) : Option T :=
+  if root=some v then some target else none
+
+def free (root : Option V) (target : T) : ℕ :=
+  (Finset.univ.filter fun v => pin root target v=none).card
+
+lemma free_none (target : T) : free (V:=V) none target=Fintype.card V := by
+  simp [free,pin]
+
+lemma free_some (root : V) (target : T) : free (some root) target+1=Fintype.card V := by
+  have h : (Finset.univ.filter fun v => pin (some root) target v=none) = Finset.univ.erase root := by
+    ext v
+    simp [pin,eq_comm]
+  unfold free
+  rw [h,Finset.card_erase_add_one (Finset.mem_univ root),Finset.card_univ]
+
+lemma free_cast (root : Option V) (target : T) :
+    (free root target : ℤ)=(Fintype.card V:ℤ)-(if root.isSome then 1 else 0) := by
+  cases root with
+  | none => simp only [free_none,Option.isSome_none,Bool.false_eq_true,ite_false,sub_zero]
+  | some v =>
+    have h := free_some v target
+    simp only [Option.isSome_some,ite_true]
+    omega
+
+omit [Fintype V] in
+lemma respects {root : Option V} {target : T} (f : V → T)
+    (h : ∀ v,root=some v → f v=target) :
+    ∀ v y,pin root target v=some y → f v=y := by
+  intro v y hy
+  unfold pin at hy
+  split_ifs at hy with hv
+  · cases Option.some.inj hy
+    exact h v hv
+
+end TorsionFreeZeroDivisors.RootPins
+
+namespace TorsionFreeZeroDivisors.ActiveRoot
+open scoped Classical
+open PortSubdivision StageSubgraphs
+variable {V D P : Type*} [Fintype D] [Fintype P]
+    (Γ : PortGraph V D) (paths : P → List D) (hp : ∀ p,paths p≠[])
+
+omit [Fintype D] in
+lemma occurrence_positive (p : P) (i : Fin (paths p).length) :
+    0<ListStageExponents.mult Γ paths ((paths p).get i) := by
+  apply Fintype.card_pos_iff.mpr
+  exact ⟨⟨⟨p,i,false⟩,rfl⟩⟩
+
+/-- The actual initial vertex belongs to the first active stage. -/
+def vertex (p : P) : ActiveV Γ (ListStageExponents.mult Γ paths) 0 :=
+  let i : Fin (paths p).length := ⟨0,List.length_pos_iff.mpr (hp p)⟩
+  ⟨Γ.origin ((paths p).get i),(paths p).get i,rfl,occurrence_positive Γ paths p i⟩
+
+omit [Fintype D] in
+@[simp] lemma vertex_val (p : P) :
+    (vertex Γ paths hp p).val=Γ.origin ((paths p).head (hp p)) := by
+  simp [vertex,List.head_eq_getElem]
+
+end TorsionFreeZeroDivisors.ActiveRoot
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/GroupRing/ChainCoverage.lean b/lean/OAI/Algebra/GroupRing/ChainCoverage.lean
new file mode 100644
index 0000000000000000000000000000000000000000..886938d197607f1e893d594ad648701aaa47667e
--- /dev/null
+++ b/lean/OAI/Algebra/GroupRing/ChainCoverage.lean
@@ -0,0 +1,411 @@
+import Mathlib
+import OAI.Algebra.GroupRing.CoreStripping
+
+namespace OAI
+
+noncomputable section
+
+namespace TorsionFreeZeroDivisors.ChainCoverage
+open Function ChainSuppression
+open scoped Classical
+variable {D : Type*} [Finite D] (σ τ : D → D)
+    (hσ : Involutive σ) (hτ : Involutive τ)
+
+/-- A dart lying in one of the actual maximal marked chains. -/
+def Covered (d : D) : Prop :=
+  ∃ (x : {x : D // τ x = x}) (i : Fin (length σ τ hσ hτ x.val x.property)),
+    (next σ τ)^[i.val] x.val = d
+
+lemma covered_fixed {d : D} (hd : τ d=d) : Covered σ τ hσ hτ d := by
+  exact ⟨⟨d,hd⟩, ⟨0,length_pos σ τ hσ hτ d hd⟩,rfl⟩
+
+lemma covered_next {d : D} (hd : Covered σ τ hσ hτ d) :
+    Covered σ τ hσ hτ (next σ τ d) := by
+  obtain ⟨x,i,rfl⟩ := hd
+  by_cases hi : i.val+1 < length σ τ hσ hτ x.val x.property
+  · refine ⟨x,⟨i.val+1,hi⟩,?_⟩
+    exact iterate_succ_apply' _ _ _
+  · have he : i.val+1 = length σ τ hσ hτ x.val x.property := by omega
+    apply covered_fixed
+    rw [← iterate_succ_apply' (next σ τ) i.val x.val]
+    change τ ((next σ τ)^[i.val+1] x.val) = (next σ τ)^[i.val+1] x.val
+    rw [he]
+    exact length_fixed σ τ hσ hτ x.val x.property
+
+/-- Reversing an original dart stays in the opposite oriented marked chain. -/
+lemma covered_reverse {d : D} (hd : Covered σ τ hσ hτ d) :
+    Covered σ τ hσ hτ (σ d) := by
+  obtain ⟨x,i,rfl⟩ := hd
+  let k := length σ τ hσ hτ x.val x.property
+  let e := endpoint σ τ hσ hτ x
+  have hi : i.val < k := i.isLt
+  have hk : length σ τ hσ hτ e.val e.property=k := length_endpoint σ τ hσ hτ x
+  have hj : k-i.val-1 < length σ τ hσ hτ e.val e.property := by omega
+  refine ⟨e,⟨k-i.val-1,hj⟩,?_⟩
+  have hf := endpoint_reverse σ τ hσ hτ (x:=x) (i:=k-i.val) (by omega)
+  have he : k-(k-i.val)=i.val := by omega
+  have hs : k-i.val=(k-i.val-1)+1 := by omega
+  change (next σ τ)^[k-i.val] e.val = τ ((next σ τ)^[k-(k-i.val)] x.val) at hf
+  rw [he,hs,iterate_succ_apply'] at hf
+  have h := congrArg τ hf
+  change τ (τ (σ ((next σ τ)^[k-i.val-1] e.val))) = τ (τ ((next σ τ)^[i.val] x.val)) at h
+  rw [hτ,hτ] at h
+  have hh := congrArg σ h
+  rwa [hσ] at hh
+
+end TorsionFreeZeroDivisors.ChainCoverage
+
+namespace TorsionFreeZeroDivisors.ActualMarkedChains
+open Function PortSubdivision ChainSuppression DegreeTwoSuppression ChainCoverage
+open scoped Classical
+variable {V D : Type*} [Fintype D] (Γ : PortGraph V D)
+    (mark : V → Prop) (h2 : ∀ v, ¬mark v → (out Γ.origin v).card=2)
+
+lemma forced_turn {d e : D} (hst : WeightedMoore.PortWalk.step Γ.origin Γ.reverse d e)
+    (he : ¬mark (Γ.origin e)) :
+    turn Γ.origin mark h2 (Γ.reverse d)=e := by
+  have hd : ¬mark (Γ.origin (Γ.reverse d)) := hst.1 ▸ he
+  apply (unique_other Γ.origin (Γ.reverse d) (h2 _ hd)).unique
+  · exact turn_of_unmarked Γ.origin mark h2 (Γ.reverse d) hd
+  · exact ⟨hst.1.symm,hst.2⟩
+
+lemma covered_step {d e : D}
+    (hd : Covered Γ.reverse (turn Γ.origin mark h2) Γ.reverse_reverse
+      (turn_involutive Γ.origin mark h2) d)
+    (hst : WeightedMoore.PortWalk.step Γ.origin Γ.reverse d e) :
+    Covered Γ.reverse (turn Γ.origin mark h2) Γ.reverse_reverse
+      (turn_involutive Γ.origin mark h2) e := by
+  by_cases he : mark (Γ.origin e)
+  · exact covered_fixed _ _ _ _ (turn_of_mark Γ.origin mark h2 e he)
+  · have hh := covered_next _ _ _ _ hd
+    change Covered _ _ _ _ (turn Γ.origin mark h2 (Γ.reverse d)) at hh
+    rwa [forced_turn Γ mark h2 hst he] at hh
+
+lemma covered_path (p : List D)
+    (hp : p.IsChain (WeightedMoore.PortWalk.step Γ.origin Γ.reverse))
+    (hh : ∀ d∈p.head?, Covered Γ.reverse (turn Γ.origin mark h2) Γ.reverse_reverse
+      (turn_involutive Γ.origin mark h2) d) :
+    ∀ d∈p, Covered Γ.reverse (turn Γ.origin mark h2) Γ.reverse_reverse
+      (turn_involutive Γ.origin mark h2) d := by
+  induction p with
+  | nil => simp
+  | cons a p ih =>
+    have ha := hh a (by simp)
+    intro d hd
+    rcases List.mem_cons.mp hd with rfl | hd
+    · exact ha
+    · apply ih hp.tail ?_ d hd
+      cases p with
+      | nil => simp
+      | cons b p =>
+        intro e he
+        have heb : b=e := by simpa using he
+        subst e
+        exact covered_step Γ mark h2 ha (List.isChain_cons_cons.mp hp).1
+
+/-- Every dart of the actual image belongs to a marked chain. No circle
+component is dropped: a path start is marked in every component. -/
+theorem actual_image_covered {J : Type*} (paths : J → List D)
+    (hpaths : ∀ j, (paths j).IsChain (WeightedMoore.PortWalk.step Γ.origin Γ.reverse))
+    (hstarts : ∀ j d, d∈(paths j).head? → mark (Γ.origin d))
+    (himage : ∀ d : D, ∃ j, d∈paths j ∨ Γ.reverse d∈paths j) :
+    ∀ d, Covered Γ.reverse (turn Γ.origin mark h2) Γ.reverse_reverse
+      (turn_involutive Γ.origin mark h2) d := by
+  intro d
+  obtain ⟨j,hj⟩ := himage d
+  have hp := covered_path Γ mark h2 (paths j) (hpaths j) (by
+    intro e he
+    exact covered_fixed _ _ _ _ (turn_of_mark Γ.origin mark h2 e (hstarts j e he)))
+  rcases hj with hj|hj
+  · exact hp d hj
+  · have hh := covered_reverse _ _ _ _ (hp (Γ.reverse d) hj)
+    rwa [Γ.reverse_reverse d] at hh
+
+/-- Exact length accounting after suppressing the actual image, rather than
+only the inequality for a possibly incomplete set of marked components. -/
+theorem actual_chain_total {J : Type*} (paths : J → List D)
+    (hpaths : ∀ j, (paths j).IsChain (WeightedMoore.PortWalk.step Γ.origin Γ.reverse))
+    (hstarts : ∀ j d, d∈(paths j).head? → mark (Γ.origin d))
+    (himage : ∀ d : D, ∃ j, d∈paths j ∨ Γ.reverse d∈paths j) :
+    ∑ d : {d : D // turn Γ.origin mark h2 d=d}, chainLength Γ mark h2 d = Fintype.card D := by
+  have hsurj : Surjective (fun p : (d : {d : D // turn Γ.origin mark h2 d=d}) ×
+        Fin (chainLength Γ mark h2 d) => (next Γ.reverse (turn Γ.origin mark h2))^[p.2.val] p.1.val) := by
+    intro d
+    obtain ⟨x,i,hi⟩ := actual_image_covered Γ mark h2 paths hpaths hstarts himage d
+    exact ⟨⟨x,i⟩,hi⟩
+  exact le_antisymm (chainLength_total Γ mark h2) (by
+    simpa only [Fintype.card_sigma,Fintype.card_fin] using Fintype.card_le_of_surjective _ hsurj)
+
+end TorsionFreeZeroDivisors.ActualMarkedChains
+
+namespace TorsionFreeZeroDivisors.MarkedChainBound
+open PortSubdivision DegreeTwoSuppression CoreStripping ImageComplexity
+open scoped Classical BigOperators
+variable {V D : Type} [Fintype V] [Fintype D] (Γ : PortGraph V D)
+
+/-- Mark all irregular vertices and the specified
+start/end vertices. -/
+def marks (M : Finset V) (v : V) : Prop := degree Γ Finset.univ v ≠ 2 ∨ v∈M
+
+omit [Fintype V] in
+lemma marks_degree_two (M : Finset V) (v : V) (hv : ¬marks Γ M v) :
+    (out Γ.origin v).card=2 := by
+  change degree Γ Finset.univ v=2
+  exact Classical.not_not.mp (fun h => hv (Or.inl h))
+
+lemma marked_dart_bound (M : Finset V) :
+    (Finset.univ.filter (fun d => marks Γ M (Γ.origin d))).card ≤
+      (Finset.univ.filter (fun d => 3≤degree Γ Finset.univ (Γ.origin d))).card +
+      (Finset.univ.filter (fun v => degree Γ Finset.univ v=1)).card + 2*M.card := by
+  rw [← fiber_count Γ Finset.univ (marks Γ M)]
+  calc (∑ v, if marks Γ M v then degree Γ Finset.univ v else 0) ≤
+      ∑ v, ((if 3≤degree Γ Finset.univ v then degree Γ Finset.univ v else 0) +
+        (if degree Γ Finset.univ v=1 then 1 else 0) + (if v∈M then 2 else 0)) := by
+        apply Finset.sum_le_sum
+        intro v _
+        by_cases hb : 3 ≤ degree Γ Finset.univ v <;>
+          by_cases hl : degree Γ Finset.univ v = 1 <;>
+          by_cases hm : v ∈ M <;>
+          simp_all [marks] <;> split_ifs <;> omega
+    _ = (Finset.univ.filter (fun d => 3≤degree Γ Finset.univ (Γ.origin d))).card +
+      (Finset.univ.filter (fun v => degree Γ Finset.univ v=1)).card + 2*M.card := by
+        rw [Finset.sum_add_distrib,Finset.sum_add_distrib,fiber_count]
+        simp [Finset.sum_ite_mem,Nat.mul_comm]
+
+omit [Fintype V] in
+lemma chain_dart_card (M : Finset V) :
+    Fintype.card {d : D // turn Γ.origin (marks Γ M) (marks_degree_two Γ M) d=d} =
+      (Finset.univ.filter (fun d => marks Γ M (Γ.origin d))).card := by
+  rw [Fintype.card_subtype]
+  congr 1
+  ext d
+  simp only [Finset.mem_filter,Finset.mem_univ,true_and,turn_fixed_iff]
+
+/-- Uniformly bounded many marked chains of the actual image, before choosing
+any label assignments. The bound depends only on C and K. -/
+theorem bounded_marked_chains (C : ℝ) (hC : 0≤C) (K : ℕ) :
+    ∃ R : ℕ, ∀ {V D : Type} [Fintype V] [Fintype D] (Γ : PortGraph V D)
+      (L : ℝ) (_ : 0<L) (_ : (Fintype.card D:ℝ)≤2*C*L)
+      (_ : ∀ a (c : Γ.subdivision.Walk a a), c.IsCycle →
+        L≤WeightedCycles.weight (WeightedPortMoore.edgeWeight (fun _ : D => (1:ℝ))) c)
+      (_ : (Finset.univ.filter (fun v => degree Γ Finset.univ v=1)).card≤2)
+      (M : Finset V) (_ : M.card≤2*K),
+      Fintype.card {d : D // turn Γ.origin (marks Γ M) (marks_degree_two Γ M) d=d}≤R := by
+  obtain ⟨R,hR⟩ := bounded_image_branches C hC 2
+  refine ⟨R+2+4*K,?_⟩
+  intro V D _ _ Γ L hL hsize hg hleaves M hM
+  rw [chain_dart_card]
+  have hb := marked_dart_bound Γ M
+  have hr := hR Γ L hL hsize hg hleaves
+  omega
+
+end TorsionFreeZeroDivisors.MarkedChainBound
+
+namespace TorsionFreeZeroDivisors.ChainPaths
+open Function PortSubdivision ChainSuppression DegreeTwoSuppression
+open WeightedMoore WeightedPortMoore SuppressedMoore ActualMarkedChains
+open scoped Classical
+variable {V D : Type*} [Fintype D] (Γ : PortGraph V D)
+    (mark : V → Prop) (h2 : ∀ v, ¬mark v → (DegreeTwoSuppression.out Γ.origin v).card=2)
+local notation "τ" => turn Γ.origin mark h2
+local notation "F" => next Γ.reverse τ
+local notation "B" => {d : D // τ d=d}
+local notation "len" => chainLength Γ mark h2
+
+/-- The literal nonempty word of original darts in one oriented marked chain. -/
+def word (d : B) : List D := outWord (iterChain F (len d-1) d.val)
+
+omit [Fintype D] in
+lemma outWord_length {k : ℕ} (p : Chain D k) : (outWord p).length=k+1 := by
+  induction k with
+  | zero => rfl
+  | succ k ih => simpa only [outWord,List.length_cons,Nat.succ_eq_add_one,Nat.add_right_cancel_iff] using ih p.2
+
+omit [Fintype D] in
+lemma outWord_last {k : ℕ} (p : Chain D k) : (outWord p).getLast?=some (last p) := by
+  induction k with
+  | zero => rfl
+  | succ k ih =>
+    change (p.1 :: outWord p.2).getLast? = some (last p.2)
+    simp only [List.getLast?_cons,ih,Option.getD_some]
+
+lemma word_length (d : B) : (word Γ mark h2 d).length=len d := by
+  rw [word,outWord_length]
+  have h := chainLength_pos Γ mark h2 d
+  omega
+
+lemma word_end (d : B) : ∀ e∈(word Γ mark h2 d).getLast?, mark (Γ.origin (Γ.reverse e)) := by
+  intro e he
+  rw [word,outWord_last] at he
+  have he' : last (iterChain F (len d-1) d.val)=e := by simpa using he
+  rw [←he',chain_last]
+  exact (turn_fixed_iff Γ.origin mark h2 _).mp ((suppressed Γ mark h2).reverse d).property
+
+/-- A reduced path cannot stop before the end of its current marked chain:
+its prescribed last vertex is marked, while all interior chain vertices are not. -/
+lemma iter_chain_prefix (n : ℕ) (x : D) (p : List D)
+    (hp : p.IsChain (PortWalk.step Γ.origin Γ.reverse)) (hh : p.head?=some x)
+    (ht : ∀ d∈p.getLast?, mark (Γ.origin (Γ.reverse d)))
+    (hn : ∀ i : ℕ, 0 < i → i ≤ n → ¬mark (Γ.origin (F^[i] x))) :
+    outWord (iterChain F n x) <+: p := by
+  induction n generalizing x p with
+  | zero =>
+    cases p with
+    | nil => simp at hh
+    | cons a p =>
+      have ha : a=x := Option.some.inj hh
+      subst a
+      exact ⟨p,rfl⟩
+  | succ n ih =>
+    cases p with
+    | nil => simp at hh
+    | cons a p =>
+      have ha : a=x := Option.some.inj hh
+      subst a
+      cases p with
+      | nil =>
+        have ht' := ht x (by simp)
+        have hu := hn 1 (by omega) (by omega)
+        apply False.elim
+        apply hu
+        simpa only [iterate_one,next,comp_apply,turn_origin] using ht'
+      | cons y p =>
+        have hst := (List.isChain_cons_cons.mp hp).1
+        have hy : ¬mark (Γ.origin y) := by
+          have ho : Γ.origin (F x)=Γ.origin y := by
+            exact (turn_origin Γ.origin mark h2 (Γ.reverse x)).trans hst.1
+          have hu := hn 1 (by omega) (by omega)
+          simpa only [iterate_one,ho] using hu
+        have he : F x=y := forced_turn Γ mark h2 hst hy
+        have htt : ∀ d∈(y::p).getLast?, mark (Γ.origin (Γ.reverse d)) := by
+          simpa only [List.getLast?_cons_cons] using ht
+        have hnn : ∀ i : ℕ, 0 < i → i ≤ n → ¬mark (Γ.origin (F^[i] y)) := by
+          intro i hi hin
+          have h := hn (i+1) (by omega) (by omega)
+          simpa only [iterate_succ_apply,he] using h
+        obtain ⟨q,hq⟩ := ih y (y::p) hp.tail rfl htt hnn
+        refine ⟨q,?_⟩
+        change x :: (outWord (iterChain F n (F x)) ++ q) = x :: y :: p
+        rw [he,hq]
+
+lemma word_prefix (d : B) (p : List D)
+    (hp : p.IsChain (PortWalk.step Γ.origin Γ.reverse)) (hh : p.head?=some d.val)
+    (ht : ∀ e∈p.getLast?, mark (Γ.origin (Γ.reverse e))) : word Γ mark h2 d <+: p := by
+  apply iter_chain_prefix Γ mark h2 (len d-1) d.val p hp hh ht
+  intro i hi hil
+  rw [←turn_fixed_iff Γ.origin mark h2]
+  apply no_internal_mark Γ.reverse τ Γ.reverse_reverse (turn_involutive Γ.origin mark h2)
+    d.val d.property hi
+  have h := chainLength_pos Γ mark h2 d
+  change i<len d
+  omega
+
+/-- Every original path traverses whole marked chains.
+This includes a path that returns to a mark, and does not require it embedded. -/
+theorem path_decomposes (p : List D)
+    (hp : p.IsChain (PortWalk.step Γ.origin Γ.reverse))
+    (hs : ∀ d∈p.head?, mark (Γ.origin d))
+    (ht : ∀ d∈p.getLast?, mark (Γ.origin (Γ.reverse d))) :
+    ∃ ds : List B, ds.flatMap (word Γ mark h2)=p := by
+  cases p with
+  | nil => exact ⟨[],rfl⟩
+  | cons a p =>
+    let d : B := ⟨a, turn_of_mark Γ.origin mark h2 a (hs a (by simp))⟩
+    obtain ⟨r,hr⟩ := word_prefix Γ mark h2 d (a::p) hp rfl ht
+    have hparts := List.isChain_append.mp (hr.symm ▸ hp)
+    have hsr : ∀ b∈r.head?, mark (Γ.origin b) := by
+      intro b hb
+      let e := last (iterChain F (len d-1) d.val)
+      have he : e∈(word Γ mark h2 d).getLast? := by
+        rw [word,outWord_last]
+        exact rfl
+      have hstep := hparts.2.2 e he b hb
+      exact hstep.1 ▸ word_end Γ mark h2 d e he
+    have htr : ∀ b∈r.getLast?, mark (Γ.origin (Γ.reverse b)) := by
+      intro b hb
+      have hrne : r≠[] := by intro he; simp [he] at hb
+      apply ht b
+      rw [←hr,List.getLast?_append_of_ne_nil _ hrne]
+      exact hb
+    have hlen : r.length < (a::p).length := by
+      have h := congrArg List.length hr
+      simp only [List.length_append,word_length] at h
+      have hd := chainLength_pos Γ mark h2 d
+      omega
+    obtain ⟨ds,hds⟩ := path_decomposes r hparts.2.1 hsr htr
+    refine ⟨d::ds,?_⟩
+    simpa only [List.flatMap_cons,hds] using hr
+termination_by p.length
+
+omit [Fintype D] in
+/-- Enumerating a chain lists precisely the forward iterates before its first mark. -/
+lemma outWord_iterChain (f : D → D) (n : ℕ) (x : D) :
+    outWord (iterChain f n x) = (List.range (n+1)).map (fun i => f^[i] x) := by
+  induction n generalizing x with
+  | zero => simp [iterChain,outWord]
+  | succ n ih =>
+    rw [List.range_succ_eq_map]
+    simp only [iterChain,outWord,ih,List.map_cons,List.map_map,iterate_zero,id_eq]
+    congr 1
+
+lemma word_eq_range (d : B) :
+    word Γ mark h2 d = (List.range (len d)).map (fun i => F^[i] d.val) := by
+  rw [word,outWord_iterChain]
+  have h := chainLength_pos Γ mark h2 d
+  congr 2
+  omega
+
+lemma mem_word_iff (d : B) (x : D) :
+    x∈word Γ mark h2 d ↔ ∃ i : Fin (len d), F^[i.val] d.val=x := by
+  rw [word_eq_range,List.mem_map]
+  constructor
+  · rintro ⟨i,hi,hx⟩
+    exact ⟨⟨i,List.mem_range.mp hi⟩,hx⟩
+  · rintro ⟨i,hx⟩
+    exact ⟨i.val,List.mem_range.mpr i.isLt,hx⟩
+
+lemma word_nodup (d : B) : (word Γ mark h2 d).Nodup := by
+  rw [word_eq_range]
+  apply List.Nodup.map_on ?_ List.nodup_range
+  intro i hi j hj he
+  have h := chain_dart_injective Γ.reverse τ Γ.reverse_reverse
+    (turn_involutive Γ.origin mark h2)
+    (a₁ := ⟨d,⟨i,List.mem_range.mp hi⟩⟩)
+    (a₂ := ⟨d,⟨j,List.mem_range.mp hj⟩⟩) he
+  exact congrArg (fun p => p.2.val) h
+
+lemma words_disjoint {d e : B} (hne : d≠e) :
+    List.Disjoint (word Γ mark h2 d) (word Γ mark h2 e) := by
+  intro x hx hy
+  obtain ⟨i,hi⟩ := (mem_word_iff Γ mark h2 d x).mp hx
+  obtain ⟨j,hj⟩ := (mem_word_iff Γ mark h2 e x).mp hy
+  have h := chain_dart_injective Γ.reverse τ Γ.reverse_reverse
+    (turn_involutive Γ.origin mark h2) (a₁ := ⟨d,i⟩) (a₂ := ⟨e,j⟩) (hi.trans hj.symm)
+  exact hne (congrArg Sigma.fst h)
+
+lemma count_word (d e : B) (x : D) (hx : x∈word Γ mark h2 d) :
+    (word Γ mark h2 e).count x = if e=d then 1 else 0 := by
+  by_cases he : e=d
+  · subst e
+    simpa using List.count_eq_one_of_mem (word_nodup Γ mark h2 d) hx
+  · have hnot : x∉word Γ mark h2 e := by
+      intro hy
+      exact words_disjoint Γ mark h2 he hy hx
+    simp [he,List.count_eq_zero.mpr hnot]
+
+/-- Every directed edge in one chain has the same traversal multiplicity,
+namely the number of occurrences of that oriented chain in the decomposition. -/
+lemma multiplicity_constant (ds : List B) (d : B) (x : D)
+    (hx : x∈word Γ mark h2 d) :
+    (ds.flatMap (word Γ mark h2)).count x = ds.count d := by
+  induction ds with
+  | nil => rfl
+  | cons e ds ih =>
+    simp only [List.flatMap_cons,List.count_append,count_word Γ mark h2 d e x hx,ih]
+    by_cases he : e=d <;> simp [he,Nat.add_comm]
+
+end TorsionFreeZeroDivisors.ChainPaths
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/GroupRing/ChainUsage.lean b/lean/OAI/Algebra/GroupRing/ChainUsage.lean
new file mode 100644
index 0000000000000000000000000000000000000000..5a485d43ae7b4efef61f2fec4841f3aadc8a95c9
--- /dev/null
+++ b/lean/OAI/Algebra/GroupRing/ChainUsage.lean
@@ -0,0 +1,398 @@
+import Mathlib
+import OAI.Algebra.GroupRing.PatternTotalCoding
+
+namespace OAI
+
+noncomputable section
+
+namespace TorsionFreeZeroDivisors.ChainUsage
+open scoped Classical BigOperators
+open PortSubdivision DegreeTwoSuppression ChainSuppression SuppressedMoore ChainPaths
+open ChainIsomorphism ChainChunkTransport ChainMultiplicity
+variable {V D P : Type} [Fintype D] [Fintype P] (Γ : PortGraph V D)
+    (mark : V → Prop) (h2 : ∀ v,¬mark v → (out Γ.origin v).card=2)
+local notation "B" => {d : D // turn Γ.origin mark h2 d=d}
+local notation "S" => suppressed Γ mark h2
+local notation "R" => Rep Γ mark h2
+local notation "w" => word Γ mark h2
+variable (paths : P → List {d : D // turn Γ.origin mark h2 d=d})
+local notation "col" => color Γ mark h2 paths
+local notation "m" => ChunkComparisons.multiplicity col
+
+def Used : Prop := ∀ d,∃ p,d∈(paths p).flatMap w ∨ Γ.reverse d∈(paths p).flatMap w
+
+omit [Fintype P] in
+lemma representative_used (hu : Used Γ mark h2 paths) (c : R) :
+    ∃ p b,b∈paths p ∧ representative Γ mark h2 b=c := by
+  obtain ⟨p,hp⟩ := hu c.val.val
+  rcases hp with hp|hp
+  · obtain ⟨b,hb,he⟩ := List.mem_flatMap.mp hp
+    have heq := same_word Γ mark h2 he (start_mem_word Γ mark h2 c.val)
+    exact ⟨p,b,hb,heq ▸ representative_val Γ mark h2 c⟩
+  · obtain ⟨b,hb,he⟩ := List.mem_flatMap.mp hp
+    have heq := same_word Γ mark h2 he
+      (reverse_mem_word Γ mark h2 c.val c.val.val (start_mem_word Γ mark h2 c.val))
+    exact ⟨p,b,hb,by rw [heq,representative_reverse,representative_val]⟩
+
+lemma multiplicity_pos (hu : Used Γ mark h2 paths) (c : R) : 1 ≤ m c := by
+  simp only [ChunkComparisons.multiplicity,Fintype.card_eq_nat_card]
+  obtain ⟨p,b,hb,he⟩ := representative_used Γ mark h2 paths hu c
+  obtain ⟨i,hi⟩ := List.mem_iff_get.mp hb
+  have hn : Nonempty {t // col t=c} := by
+    refine ⟨⟨⟨p,i⟩,?_⟩⟩
+    change representative Γ mark h2 ((paths p).get i)=c
+    rw [hi,he]
+  exact Nat.card_pos
+
+lemma traversal_card : Fintype.card (RepeatedBlocks.Traversal m)=∑p,(paths p).length := by
+  rw [Fintype.card_congr (ChunkComparisons.enumeration col)]
+  simp only [FiniteChunking.Traversal,chunks]
+  exact (Fintype.card_sigma (α:=fun p : P => Fin (paths p).length)).trans (Finset.sum_congr rfl (fun p _ => Fintype.card_fin _))
+
+lemma multiplicity_le (c : R) : m c≤∑p,(paths p).length := by
+  simp only [ChunkComparisons.multiplicity,Fintype.card_eq_nat_card]
+  have h := Nat.card_le_card_of_injective (Subtype.val : {t // col t=c} → _)
+    Subtype.val_injective
+  simpa only [FiniteChunking.Traversal,chunks,Nat.card_sigma,Nat.card_fin] using h
+
+omit [Fintype D] [Fintype P] in
+lemma flatMap_length_le {A Z : Type*} (f : A → List Z) (l : List A) {a : A} (ha : a∈l) :
+    (f a).length≤(l.flatMap f).length := by
+  induction l with
+  | nil => simp at ha
+  | cons b l ih =>
+    rcases List.mem_cons.mp ha with rfl|ha
+    · simp only [List.flatMap_cons,List.length_append]
+      omega
+    · have h := ih ha
+      simp only [List.flatMap_cons,List.length_append]
+      omega
+
+lemma length_le_total_of_mem (p : P) (b : B) (hb : b∈paths p) :
+    chainLength Γ mark h2 b≤∑p,((paths p).flatMap w).length := by
+  rw [←word_length]
+  exact (flatMap_length_le w _ hb).trans
+    (Finset.single_le_sum (f:=fun p => ((paths p).flatMap w).length)
+      (fun _ _ => Nat.zero_le _) (Finset.mem_univ p))
+
+lemma chain_length_le (hu : Used Γ mark h2 paths) (b : B) :
+    chainLength Γ mark h2 b≤∑p,((paths p).flatMap w).length := by
+  obtain ⟨p,a,ha,he⟩ := representative_used Γ mark h2 paths hu (representative Γ mark h2 b)
+  have h := length_le_total_of_mem Γ mark h2 paths p a ha
+  rw [oriented_length Γ mark h2 a,he,←oriented_length Γ mark h2 b] at h
+  exact h
+
+lemma rep_card_le : Fintype.card R≤Fintype.card B := Fintype.card_subtype_le _
+
+end TorsionFreeZeroDivisors.ChainUsage
+
+namespace TorsionFreeZeroDivisors.SourcePattern
+open scoped Classical BigOperators
+open PortSubdivision MarkedChainBound DegreeTwoSuppression ChainSuppression SuppressedMoore ChainPaths
+open ChainIsomorphism ChainChunkTransport ChunkComparisons FiniteChunking ComparedBlocks
+open ActualComplexity CoreStripping ImageComplexity GirthAsymptotics TypedGraphs
+
+/-- The uniformly bounded number of marked darts is derived, not required of an
+original pattern. Extra marks are just the prescribed path endpoints. -/
+theorem marked_bound (B K : ℕ) : ∃ R : ℕ,0<R ∧
+    ∀ {V D P : Type} [Fintype V] [Fintype D] [Fintype P]
+      (Γ : PortGraph V D) (M : Finset V) (_hM : M.card≤2*K)
+      (paths : P → List D) (_hp : ∀ p,paths p≠[])
+      (_ : Fintype.card P≤K) (_ : Function.Surjective Γ.origin)
+      (_ : ∀ p,(paths p).IsChain (WeightedMoore.PortWalk.step Γ.origin Γ.reverse))
+      (_ : ∀ d,∃ p,d∈paths p ∨ Γ.reverse d∈paths p)
+      (L : ℝ) (_ : 0<L) (_ : (∑ p,(paths p).length:ℕ)≤(B:ℝ)*L)
+      (_ : ∀ a (c : Γ.subdivision.Walk a a),c.IsCycle →
+        L≤WeightedCycles.weight (WeightedPortMoore.edgeWeight (fun _ : D => (1:ℝ))) c),
+      Fintype.card {d : D // turn Γ.origin (marks Γ M) (marks_degree_two Γ M) d=d}≤R ∧
+        Fintype.card (Mark (marks Γ M))≤R := by
+  obtain ⟨R,hR⟩ := bounded_image_branches (B:ℝ) (Nat.cast_nonneg _) (2*K)
+  refine ⟨R+6*K+1,by omega,?_⟩
+  intro V D P _ _ _ Γ M hM paths hp hP hv hc hi L hL hH hg
+  have hleaf := leaf_bound Γ paths hp hc hi
+  have hdc := dart_count Γ paths hi
+  have hdc' : (Fintype.card D:ℝ)≤2*(B:ℝ)*L := by
+    have hdc' : (Fintype.card D:ℝ)≤2*(∑ p,(paths p).length:ℕ) := by exact_mod_cast hdc
+    nlinarith
+  have hleaf' : (Finset.univ.filter (fun v => degree Γ Finset.univ v=1)).card≤2*K :=
+    hleaf.trans (Nat.mul_le_mul_left _ hP)
+  have hb := hR Γ L hL hdc' hg hleaf'
+  have hd := marked_dart_bound Γ M
+  have hseed : Fintype.card {d : D //
+      turn Γ.origin (marks Γ M) (marks_degree_two Γ M) d=d}≤R+6*K+1 := by
+    rw [chain_dart_card]
+    omega
+  exact ⟨hseed,(marked_vertices_le Γ _ _ hv).trans hseed⟩
+
+abbrev Seeds {V D : Type} [Fintype D] (Γ : PortGraph V D) (M : Finset V) :=
+  {d : D // turn Γ.origin (marks Γ M) (marks_degree_two Γ M) d=d}
+
+def R (B K : ℕ) : ℕ := (marked_bound B K).choose
+lemma R_pos (B K : ℕ) : 0<R B K := (marked_bound B K).choose_spec.1
+def T (B K : ℕ) : ℕ := R B K*(B+K)
+
+/-- The actual suppressed form of source paths. No bound on the resulting
+skeleton, chain lengths, multiplicities or number of traversals is assumed. -/
+structure Data (B K I rep : ℕ) where
+  V : Type
+  D : Type
+  P : Type
+  E : Type
+  [fV : Fintype V]
+  [fD : Fintype D]
+  [fP : Fintype P]
+  [fE : Fintype E]
+  graph : PortGraph V D
+  vertices : Finset V
+  vertices_bound : vertices.card≤2*K
+  no_isolated : Function.Surjective graph.origin
+  side : V → Bool
+  side_edge : ∀ d,side (graph.origin (graph.reverse d))=side (graph.origin d)
+  paths : P → List (Seeds graph vertices)
+  nonempty : ∀ p,paths p≠[]
+  root : Option P
+  path_bound : Fintype.card P≤K
+  comparison_bound : Fintype.card E≤I
+  image : ChainUsage.Used graph (marks graph vertices) (marks_degree_two graph vertices) paths
+  path_chain : ∀ p,((paths p).flatMap (word graph (marks graph vertices) (marks_degree_two graph vertices))).IsChain
+    (WeightedMoore.PortWalk.step graph.origin graph.reverse)
+  cyclic_chain : ∀ p,StageRoot.cyclic root p=true →
+    ∀ᵉ (x∈((paths p).flatMap (word graph (marks graph vertices) (marks_degree_two graph vertices))).getLast?)
+        (y∈((paths p).flatMap (word graph (marks graph vertices) (marks_degree_two graph vertices))).head?),
+      WeightedMoore.PortWalk.step graph.origin graph.reverse x y
+  girth : ∀ a (c : graph.subdivision.Walk a a),c.IsCycle →
+    (L (size rep):ℝ)≤WeightedCycles.weight (WeightedPortMoore.edgeWeight (fun _ : D => (1:ℝ))) c
+  length_le : (∑p,((paths p).flatMap (word graph (marks graph vertices) (marks_degree_two graph vertices))).length:ℕ)≤B*L (size rep)
+  length_ge : L (size rep)≤(∑p,((paths p).flatMap (word graph (marks graph vertices) (marks_degree_two graph vertices))).length:ℕ)
+  comparisons : Comparisons (E:=E) (pathLength (chunks graph (marks graph vertices) (marks_degree_two graph vertices) paths)
+    (chunkLength graph (marks graph vertices) (marks_degree_two graph vertices) paths))
+  lower : E → ℕ
+  upper : E → ℕ
+  lower_eq : ∀ e,comparisons.lo e=lower e
+  upper_eq : ∀ e,comparisons.hi e=upper e
+  lower_le : ∀ e,lower e≤upper e
+  upper_le : ∀ e,upper e≤pathLength (chunks graph (marks graph vertices) (marks_degree_two graph vertices) paths)
+    (chunkLength graph (marks graph vertices) (marks_degree_two graph vertices) paths) (comparisons.source e)
+  reduced : ∀ x e,comparisons.side x=some e →
+    originalDart graph (marks graph vertices) (marks_degree_two graph vertices) paths x≠
+      originalDart graph (marks graph vertices) (marks_degree_two graph vertices) paths (comparisons.pairing.partner x) ∧
+    originalDart graph (marks graph vertices) (marks_degree_two graph vertices) paths x≠graph.reverse
+      (originalDart graph (marks graph vertices) (marks_degree_two graph vertices) paths (comparisons.pairing.partner x))
+  unpaired_le : ((Finset.univ.filter (fun x => comparisons.pairing.partner x=x)).card:ℝ)≤
+    StageFusion.epsilon (1/600) 256*
+      (∑p,((paths p).flatMap (word graph (marks graph vertices) (marks_degree_two graph vertices))).length:ℕ)
+
+attribute [instance] Data.fV Data.fD Data.fP Data.fE
+
+namespace Data
+variable {B K I rep : ℕ} (a : Data B K I rep)
+abbrev mark := marks a.graph a.vertices
+abbrev degree_two := marks_degree_two a.graph a.vertices
+abbrev words (p : a.P) := (a.paths p).flatMap (word a.graph a.mark a.degree_two)
+abbrev totalLength : ℕ := ∑p,(a.words p).length
+abbrev lengths : a.P → ℕ := pathLength (chunks a.graph a.mark a.degree_two a.paths)
+  (chunkLength a.graph a.mark a.degree_two a.paths)
+
+lemma words_nonempty (p : a.P) : a.words p≠[] := by
+  intro he
+  obtain ⟨b,hb⟩ := List.exists_mem_of_ne_nil (a.paths p) (a.nonempty p)
+  have hm : b.val∈a.words p := by
+    apply List.mem_flatMap.mpr
+    exact ⟨b,hb,start_mem_word a.graph a.mark a.degree_two b⟩
+  simp [he] at hm
+
+lemma lengths_le (p : a.P) : a.lengths p≤B*L (size rep) := by
+  rw [lengths,pathLength_eq]
+  apply le_trans (b:=a.totalLength) _ a.length_le
+  exact Finset.single_le_sum (f:=fun p => (a.words p).length)
+    (fun _ _ => Nat.zero_le _) (Finset.mem_univ p)
+
+lemma upper_bound (e : a.E) : a.upper e≤B*L (size rep) :=
+  (a.upper_le e).trans (a.lengths_le _)
+
+lemma lower_bound (e : a.E) : a.lower e≤B*L (size rep) :=
+  (a.lower_le e).trans (a.upper_bound e)
+
+lemma covered : ∀ d,ChainCoverage.Covered a.graph.reverse (turn a.graph.origin a.mark a.degree_two)
+    a.graph.reverse_reverse (turn_involutive a.graph.origin a.mark a.degree_two) d := by
+  apply ActualMarkedChains.actual_image_covered a.graph a.mark a.degree_two a.words a.path_chain _ a.image
+  intro p d hd
+  rw [words,ChainPathTransport.flatMap_head] at hd
+  obtain ⟨b,_hb,hbd⟩ := Option.mem_map.mp hd
+  subst d
+  exact (turn_fixed_iff a.graph.origin a.mark a.degree_two b.val).mp b.property
+
+lemma mark_bounds (hL : 0<L (size rep)) :
+    Fintype.card (Seeds a.graph a.vertices)≤R B K ∧ Fintype.card (Mark a.mark)≤R B K := by
+  apply (marked_bound B K).choose_spec.2 a.graph a.vertices a.vertices_bound a.words
+    a.words_nonempty a.path_bound a.no_isolated a.path_chain a.image (L (size rep))
+    (by exact_mod_cast hL) _ a.girth
+  exact_mod_cast a.length_le
+
+lemma total_traversals_le (hL : 0<L (size rep)) : ∑p,(a.paths p).length≤T B K := by
+  have h := ChainPaths.bounded_chain_traversals a.graph a.mark a.degree_two
+    (B:ℝ) (Nat.cast_nonneg _) K (R B K) a.path_bound (a.mark_bounds hL).1
+    (L (size rep)) (by exact_mod_cast hL) a.girth a.paths a.path_chain
+    (by exact_mod_cast a.length_le)
+  have he : (R B K:ℝ)*((B:ℝ)+K)=(T B K:ℝ) := by simp only [T,Nat.cast_mul,Nat.cast_add]
+  rw [he,Nat.ceil_natCast] at h
+  exact h
+
+lemma traversal_le (hL : 0<L (size rep)) (p : a.P) : (a.paths p).length≤T B K :=
+  (Finset.single_le_sum (f:=fun p => (a.paths p).length)
+    (fun _ _ => Nat.zero_le _) (Finset.mem_univ p)).trans (a.total_traversals_le hL)
+
+lemma offset_bounds (e : a.E) :
+    -(2*(B*L (size rep):ℕ):ℤ)≤a.comparisons.offset e ∧
+      a.comparisons.offset e≤(2*(B*L (size rep):ℕ):ℤ) := by
+  have hlo : (0:ℝ)≤a.comparisons.lo e := by rw [a.lower_eq]; positivity
+  have hhi : (0:ℝ)≤a.comparisons.hi e := by rw [a.upper_eq]; positivity
+  have hlb : a.comparisons.lo e≤(B*L (size rep):ℕ) := by
+    rw [a.lower_eq]; exact_mod_cast a.lower_bound e
+  have hub : a.comparisons.hi e≤(B*L (size rep):ℕ) := by
+    rw [a.upper_eq]; exact_mod_cast a.upper_bound e
+  have hlen : (a.lengths (a.comparisons.source (a.comparisons.flip e)):ℝ)≤(B*L (size rep):ℕ) :=
+    by exact_mod_cast a.lengths_le _
+  have hr := a.comparisons.target_range e
+  have he : -2*((B*L (size rep):ℕ):ℝ)≤(a.comparisons.offset e:ℝ) ∧
+      (a.comparisons.offset e:ℝ)≤2*((B*L (size rep):ℕ):ℝ) := by
+    cases hh : a.comparisons.reverse e <;> simp only [hh,Bool.false_eq_true,↓reduceIte] at hr
+    · constructor <;> linarith
+    · constructor <;> linarith
+  exact_mod_cast he
+
+def bounded (hL : 0<L (size rep)) : BoundedPattern.Data (R B K) K (T B K) I (B*L (size rep)) where
+  V := a.V
+  D := a.D
+  P := a.P
+  E := a.E
+  graph := a.graph
+  mark := a.mark
+  degree_two := a.degree_two
+  covered := a.covered
+  side := a.side
+  side_edge := a.side_edge
+  paths := a.paths
+  nonempty := a.nonempty
+  root := a.root
+  comparisons := a.comparisons
+  lower e := ⟨a.lower e,by have := a.lower_bound e; omega⟩
+  upper e := ⟨a.upper e,by have := a.upper_bound e; omega⟩
+  offset e := ⟨(a.comparisons.offset e+2*(B*L (size rep):ℕ)).toNat,by
+    obtain ⟨hl,hu⟩ := a.offset_bounds e
+    omega⟩
+  lower_eq := a.lower_eq
+  upper_eq := a.upper_eq
+  offset_eq e := by
+    obtain ⟨hl,hu⟩ := a.offset_bounds e
+    dsimp
+    omega
+  dart_bound := (a.mark_bounds hL).1
+  vertex_bound := (a.mark_bounds hL).2
+  path_bound := a.path_bound
+  comparison_bound := a.comparison_bound
+  chain_length_bound d := (ChainUsage.chain_length_le a.graph a.mark a.degree_two a.paths a.image d).trans a.length_le
+  traversal_bound := a.traversal_le hL
+
+lemma bounded_good (hL : 0<L (size rep)) :
+    (a.bounded hL).Good B (R B K) (T B K) (I*(T B K)^2) rep where
+  multiplicity_le c := (ChainUsage.multiplicity_le a.graph a.mark a.degree_two a.paths c).trans
+    (a.total_traversals_le hL)
+  multiplicity_pos := ChainUsage.multiplicity_pos a.graph a.mark a.degree_two a.paths a.image
+  path_chain p := ChainPathTransport.isChain a.graph a.mark a.degree_two (a.paths p) (a.path_chain p)
+  cyclic_chain p hp := ChainPathTransport.closing a.graph a.mark a.degree_two (a.paths p) (a.cyclic_chain p hp)
+  reduced := a.reduced
+  chains_le := (ChainUsage.rep_card_le a.graph a.mark a.degree_two).trans (a.mark_bounds hL).1
+  cut_comparisons_le := by
+    change Fintype.card a.E*(Fintype.card (RepeatedBlocks.Traversal
+      (ChunkComparisons.multiplicity (color a.graph a.mark a.degree_two a.paths))))^2≤_
+    rw [ChainUsage.traversal_card]
+    exact Nat.mul_le_mul a.comparison_bound (Nat.pow_le_pow_left (a.total_traversals_le hL) 2)
+  length_le := by
+    change (∑p,(a.words p).length:ℝ)≤_
+    exact_mod_cast a.length_le
+  length_ge := by
+    change _≤(∑p,(a.words p).length:ℝ)
+    exact_mod_cast a.length_ge
+  unpaired_le := by
+    change _≤StageFusion.epsilon (1/600) 256*(∑p,(a.words p).length:ℝ)
+    exact_mod_cast a.unpaired_le
+
+end Data
+end TorsionFreeZeroDivisors.SourcePattern
+
+namespace TorsionFreeZeroDivisors.BoundedPattern
+open scoped Classical Topology
+open Filter GirthAsymptotics TypedGraphs ActualPatternEvent
+
+lemma polynomial_exp_tendsto (c B d M : ℕ) (hM : 0<M) :
+    Tendsto (fun rep => (c:ℝ)*(B*L (size rep)+1:ℕ)^d*
+      Real.exp (-(L (size rep):ℝ)/(4800*M))) atTop (𝓝 0) := by
+  have hL : Tendsto (fun rep => (L (size rep):ℝ)) atTop atTop :=
+    tendsto_natCast_atTop_atTop.comp (L_tendsto.comp size_tendsto)
+  have ht := (tendsto_rpow_mul_exp_neg_mul_atTop_nhds_zero (d:ℝ)
+    (1/(4800*M)) (by positivity)).comp hL
+  simp only [Function.comp_def,Real.rpow_natCast] at ht
+  have ht' := ht.const_mul ((c:ℝ)*(B+1:ℝ)^d)
+  simp only [mul_zero] at ht'
+  apply squeeze_zero' (Eventually.of_forall (fun _ => by positivity)) _ ht'
+  filter_upwards [hL.eventually (eventually_ge_atTop (1:ℝ))] with rep hr
+  have hp : ((B*L (size rep)+1:ℕ):ℝ)^d≤((B+1:ℝ)*(L (size rep):ℝ))^d := by
+    gcongr
+    push_cast
+    nlinarith
+  calc
+    _ ≤ (c:ℝ)*((B+1:ℝ)*(L (size rep):ℝ))^d*
+        Real.exp (-(L (size rep):ℝ)/(4800*M)) := by gcongr
+    _ = (c:ℝ)*(B+1:ℝ)^d*((L (size rep):ℝ)^d*
+        Real.exp (-(1/(4800*M:ℝ))*(L (size rep):ℝ))) := by
+      have he : -(L (size rep):ℝ)/(4800*M)=-(1/(4800*M:ℝ))*(L (size rep):ℝ) := by ring
+      rw [he,mul_pow]
+      ring
+
+lemma mem_samples (rep : ℕ) (r : Match rep) : r∈samples rep ↔
+    (r.1.Contains ∅ ∧ ((3*L (size rep):ℕ):ℕ∞)≤(r.1.graph (PatternEmbeddings.origin (@Types.outgoingA rep))).subdivision.egirth) ∧
+    (r.2.Contains ∅ ∧ ((3*L (size rep):ℕ):ℕ∞)≤(r.2.graph (PatternEmbeddings.origin (@Types.outgoingB rep))).subdivision.egirth) := by
+  simp only [samples,ConditionedMatchings.Matching.conditioned,Finset.mem_product,
+    Finset.mem_filter,Finset.mem_univ,true_and]
+
+lemma samples_eventually_nonempty : ∀ᶠ rep in atTop,(samples rep).Nonempty := by
+  filter_upwards [TypedGraphs.eventual_nonempty] with rep hr
+  obtain ⟨a,ha⟩ := hr.1
+  obtain ⟨b,hb⟩ := hr.2
+  simp only [ConditionedMatchings.Matching.conditioned, Finset.mem_filter,
+    Finset.mem_univ, true_and] at ha hb
+  refine ⟨(a,b),(mem_samples rep (a,b)).mpr ?_⟩
+  exact ⟨ha,hb⟩
+
+/-- With the bounds fixed beforehand, for every sufficiently large admissible
+size there is an actual pair of conditioned matchings avoiding every bounded
+pattern. The roots are universally quantified after the size threshold. -/
+theorem eventually_avoids (R K T I B Q M J : ℕ)
+    (hR : 0<R) (hK : 0<K) (hI : 0<I) (hM : 0<M) :
+    ∀ᶠ rep in atTop,∀ (x : Types.VertexA rep) (y : Types.VertexB rep),
+      ∃ r∈samples rep,∀ a : Data R K T I (B*L (size rep)),
+        a.Good B Q M J rep → ¬a.event rep x y r := by
+  have hsmall := (polynomial_exp_tendsto (PatternTotalCoding.coefficient R K T I)
+    B (R+3*I) M hM).eventually_lt_const (by norm_num : (0:ℝ)<1)
+  filter_upwards [hsmall, samples_eventually_nonempty,PatternUniform.eventually_ready B M Q J hM]
+    with rep hb hs hr
+  intro x y
+  have hprob := (probability_union R K T I (B*L (size rep)) B Q M J rep hR hK hI hM hs hr x y).trans_lt hb
+  by_contra hn
+  have hall : ∀ r∈samples rep,∃ a : Data R K T I (B*L (size rep)),
+      a.Good B Q M J rep ∧ a.event rep x y r := by
+    push Not at hn
+    exact hn
+  have he : (samples rep).filter (fun r => ∃ a : Data R K T I (B*L (size rep)),
+      a.Good B Q M J rep ∧ a.event rep x y r)=samples rep := by
+    apply Finset.filter_eq_self.mpr
+    exact hall
+  rw [he,div_self (by exact_mod_cast (Finset.card_pos.mpr hs).ne')] at hprob
+  exact (lt_irrefl (1:ℝ)) hprob
+
+end TorsionFreeZeroDivisors.BoundedPattern
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/GroupRing/ChunkComparisons.lean b/lean/OAI/Algebra/GroupRing/ChunkComparisons.lean
new file mode 100644
index 0000000000000000000000000000000000000000..4ec5455ff1f39c99f558ffe70199e70e72a41f0d
--- /dev/null
+++ b/lean/OAI/Algebra/GroupRing/ChunkComparisons.lean
@@ -0,0 +1,470 @@
+import Mathlib
+import OAI.Algebra.GroupRing.ListPassages
+import OAI.Algebra.GroupRing.AffineIntervals
+
+namespace OAI
+
+noncomputable section
+
+namespace TorsionFreeZeroDivisors.ChunkComparisons
+open scoped Classical
+open ComparedBlocks
+variable {P T U C : Type*} {lp : P → ℕ} {lt : T → ℕ}
+
+def positionEquiv (r : U ≃ T) (lu : U → ℕ) (hlen : ∀ u,lu u=lt (r u)) :
+    Position lu ≃ Position lt :=
+  Equiv.sigmaCongr r (fun u => (Equiv.refl ℤ).subtypeEquiv (by
+    intro q
+    change q∈BlockAlignment.positions 0 (lu u) ↔ q∈BlockAlignment.positions 0 (lt (r u))
+    rw [hlen]))
+
+lemma positionEquiv_source (r : U ≃ T) (lu : U → ℕ) (hlen : ∀ u,lu u=lt (r u)) (x : Position lu) :
+    (positionEquiv r lu hlen x).1=r x.1 := rfl
+
+lemma positionEquiv_coordinate (r : U ≃ T) (lu : U → ℕ) (hlen : ∀ u,lu u=lt (r u)) (x : Position lu) :
+    (positionEquiv r lu hlen x).2.val=x.2.val := rfl
+
+namespace Chunking
+/-- Re-enumerating occurrence chunks does not change their geometric partition. -/
+def reindex (K : Chunking lp lt) (r : U ≃ T) (lu : U → ℕ) (hlen : ∀ u,lu u=lt (r u)) : Chunking lp lu where
+  equiv := (positionEquiv r lu hlen).trans K.equiv
+  path u := K.path (r u)
+  reverse u := K.reverse (r u)
+  offset u := K.offset (r u)
+  source x := K.source (positionEquiv r lu hlen x)
+  coordinate x := K.coordinate (positionEquiv r lu hlen x)
+end Chunking
+
+variable [Fintype T] (color : T → C)
+def multiplicity (c : C) : ℕ := Fintype.card {t // color t=c}
+
+/-- Exact color-fibre enumeration, identifying the literal path traversals
+with the multiplicity-indexed traversal type used in every stage estimate. -/
+def enumeration : ((c : C) × Fin (multiplicity color c)) ≃ T :=
+  (Equiv.sigmaCongrRight (fun c => (Fintype.equivFin {t // color t=c}).symm)).trans
+    (Equiv.sigmaFiberEquiv color)
+
+lemma enumeration_color (o : (c : C) × Fin (multiplicity color c)) : color (enumeration color o)=o.1 :=
+  ((Fintype.equivFin {t // color t=o.1}).symm o.2).property
+
+lemma enumeration_length (len : C → ℕ) (hl : ∀ t,lt t=len (color t))
+    (o : (c : C) × Fin (multiplicity color c)) : len o.1=lt (enumeration color o) := by
+  rw [hl (enumeration color o),enumeration_color color o]
+
+/-- The complete finite reindexing into underlying chain and occurrence number. -/
+def repeated (K : Chunking lp lt) (len : C → ℕ) (hl : ∀ t,lt t=len (color t)) :
+    Chunking lp (fun o : (c : C) × Fin (multiplicity color c) => len o.1) :=
+  K.reindex (enumeration color) _ (enumeration_length color len hl)
+
+end TorsionFreeZeroDivisors.ChunkComparisons
+
+namespace TorsionFreeZeroDivisors.ListChunkCoordinates
+open scoped Classical BigOperators
+open FiniteChunking
+variable {A D : Type*} (ds : List A) (word : A → List D)
+
+abbrev lengths (i : Fin ds.length) : ℕ := (word (ds.get i)).length
+
+lemma ofFn_lengths : List.ofFn (lengths ds word)=ds.map (fun a => (word a).length) := by
+  change List.ofFn (fun i : Fin ds.length => (word ds[i.val]).length) = _
+  exact List.ofFn_getElem_eq_map ds (fun a => (word a).length)
+
+lemma total_length : (∑ i,lengths ds word i)=(ds.flatMap word).length := by
+  rw [← List.sum_ofFn,ofFn_lengths,List.length_flatMap]
+
+lemma start_eq (i : Fin ds.length) :
+    start (lengths ds word) i = ((ds.take i.val).flatMap word).length := by
+  rw [List.length_flatMap,List.map_take,← ofFn_lengths,List.sum_take_ofFn]
+  simp only [start,before,Fin.lt_def]
+
+/-- Literal indexing through a list concatenation, including repeated chunks. -/
+lemma get_flatMap (i : Fin ds.length) (q : Fin (lengths ds word i)) :
+    (ds.flatMap word)[start (lengths ds word) i+q.val]? = some ((word (ds.get i)).get q) := by
+  rw [start_eq]
+  have hdec : ds.take i.val ++ ds.get i :: ds.drop (i.val+1)=ds := by
+    simpa only [List.drop_eq_getElem_cons i.isLt,List.get_eq_getElem] using List.take_append_drop i.val ds
+  have hflat := congrArg (List.flatMap word) hdec
+  simp only [List.flatMap_append,List.flatMap_cons] at hflat
+  calc
+    _ = (((ds.take i.val).flatMap word) ++
+        (word (ds.get i) ++ (ds.drop (i.val+1)).flatMap word))[
+          ((ds.take i.val).flatMap word).length+q.val]? := by rw [hflat]
+    _ = (word (ds.get i) ++ (ds.drop (i.val+1)).flatMap word)[q.val]? := by
+      rw [List.getElem?_append_right (Nat.le_add_right _ _),Nat.add_sub_cancel_left]
+    _ = some ((word (ds.get i)).get q) := by
+      rw [List.getElem?_append_left q.isLt,List.getElem?_eq_getElem q.isLt]
+      rfl
+
+end TorsionFreeZeroDivisors.ListChunkCoordinates
+
+namespace TorsionFreeZeroDivisors.ChainChunkTransport
+open Function PortSubdivision ChainSuppression DegreeTwoSuppression SuppressedMoore ChainPaths
+open ChainIsomorphism ChunkComparisons FiniteChunking ComparedBlocks
+open scoped Classical BigOperators
+variable {V D : Type*} [Fintype D] (Γ : PortGraph V D)
+    (mark : V → Prop) (h2 : ∀ v, ¬mark v → (out Γ.origin v).card=2)
+local notation "τ" => turn Γ.origin mark h2
+local notation "F" => next Γ.reverse τ
+local notation "B" => {d : D // τ d=d}
+local notation "S" => suppressed Γ mark h2
+local notation "len" => chainLength Γ mark h2
+local notation "R" => ChainIsomorphism.Rep Γ mark h2
+local notation "w" => word Γ mark h2
+
+def orientation : R × Bool ≃ B := InvolutionOrientation.equiv (S).reverse (S).reverse_reverse (S).reverse_ne
+
+def representative (b : B) : R := ((orientation Γ mark h2).symm b).1
+def reversed (b : B) : Bool := ((orientation Γ mark h2).symm b).2
+
+lemma oriented (b : B) : b=if reversed Γ mark h2 b then (S).reverse (representative Γ mark h2 b).val
+    else (representative Γ mark h2 b).val := (orientation Γ mark h2).apply_symm_apply b |>.symm
+
+lemma oriented_length (b : B) : len b=len (representative Γ mark h2 b).val := by
+  have h := oriented Γ mark h2 b
+  conv_lhs => rw [h]
+  split_ifs <;> simp only [chainLength_reverse]
+
+lemma word_get (b : B) (i : ℕ) (hi : i < len b) : (w b)[i]?=some (F^[i] b.val) := by
+  simp [word_eq_range,hi]
+
+lemma reverse_iter (b : B) (i : ℕ) (hi : i < len b) :
+    F^[len b-i-1] ((S).reverse b).val=Γ.reverse (F^[i] b.val) := by
+  let k := len b
+  have hf := endpoint_reverse Γ.reverse τ Γ.reverse_reverse
+    (turn_involutive Γ.origin mark h2) (x:=b) (i:=k-i) (by change k-i ≤ k; omega)
+  have he : k-(k-i)=i := by dsimp [k]; omega
+  have hs : k-i=(k-i-1)+1 := by dsimp [k]; omega
+  change F^[k-i] ((S).reverse b).val = τ (F^[k-(k-i)] b.val) at hf
+  rw [he,hs,iterate_succ_apply'] at hf
+  have h := congrArg τ hf
+  change τ (τ (Γ.reverse (F^[k-i-1] ((S).reverse b).val))) = τ (τ (F^[i] b.val)) at h
+  rw [turn_involutive Γ.origin mark h2,turn_involutive Γ.origin mark h2] at h
+  have hh := congrArg Γ.reverse h
+  rwa [Γ.reverse_reverse] at hh
+
+lemma listDart (b : B) (q : ℤ) (hq : q∈BlockAlignment.positions 0 (len b)) :
+    (w b)[(localIndex (reversed Γ mark h2 b) (len b) q).toNat]? =
+      some (if reversed Γ mark h2 b then Γ.reverse (F^[q.toNat] (representative Γ mark h2 b).val.val)
+        else F^[q.toNat] (representative Γ mark h2 b).val.val) := by
+  have hz : 0 ≤ q ∧ q < len b := by simpa only [AffineIntervals.nat_positions,Finset.mem_Ico] using hq
+  have hqcast : (q.toNat : ℤ)=q := Int.toNat_of_nonneg hz.1
+  have hqn : q.toNat < len b := by omega
+  have h := oriented Γ mark h2 b
+  cases hr : reversed Γ mark h2 b
+  · simp only [hr,Bool.false_eq_true,ite_false] at h ⊢
+    simp only [localIndex,BlockAlignment.affine,Bool.false_eq_true,ite_false,add_zero]
+    rw [word_get Γ mark h2 b q.toNat hqn,show b.val=(representative Γ mark h2 b).val.val from congrArg Subtype.val h]
+  · simp only [hr,ite_true] at h ⊢
+    have he : (localIndex true (len b) q).toNat=len b-q.toNat-1 := by
+      simp only [localIndex,BlockAlignment.affine,ite_true]
+      omega
+    have hi : len b-q.toNat-1 < len b := by omega
+    rw [he,word_get Γ mark h2 b _ hi]
+    apply congrArg some
+    rw [oriented_length Γ mark h2 b,show b.val=((S).reverse (representative Γ mark h2 b).val).val from congrArg Subtype.val h]
+    apply reverse_iter
+    rwa [←oriented_length Γ mark h2 b]
+
+variable {P : Type*} [Fintype P] (paths : P → List {d : D // turn Γ.origin mark h2 d=d})
+
+def chunks (p : P) : ℕ := (paths p).length
+def chunkLength (p : P) (i : Fin (chunks Γ mark h2 paths p)) : ℕ := (w ((paths p).get i)).length
+def chunkReverse (p : P) (i : Fin (chunks Γ mark h2 paths p)) : Bool := reversed Γ mark h2 ((paths p).get i)
+def color (t : Traversal (chunks Γ mark h2 paths)) : R := representative Γ mark h2 ((paths t.1).get t.2)
+
+def splitChunks := FiniteChunking.chunking (chunks Γ mark h2 paths) (chunkLength Γ mark h2 paths) (chunkReverse Γ mark h2 paths)
+
+omit [Fintype P] in
+lemma chunkLength_eq (t : Traversal (chunks Γ mark h2 paths)) :
+    traversalLength (chunks Γ mark h2 paths) (chunkLength Γ mark h2 paths) t=repLength Γ mark h2 (color Γ mark h2 paths t) := by
+  exact (word_length Γ mark h2 _).trans (oriented_length Γ mark h2 _)
+
+omit [Fintype P] in
+lemma pathLength_eq (p : P) :
+    pathLength (chunks Γ mark h2 paths) (chunkLength Γ mark h2 paths) p=((paths p).flatMap w).length :=
+  ListChunkCoordinates.total_length (paths p) w
+
+/-- The original path's actual dart at the signed chunk image. -/
+lemma chunk_dart (x : Position (traversalLength (chunks Γ mark h2 paths) (chunkLength Γ mark h2 paths))) :
+    ((paths x.1.1).flatMap w)[((splitChunks Γ mark h2 paths).equiv x).2.val.toNat]? =
+      some (if (splitChunks Γ mark h2 paths).reverse x.1 then
+        Γ.reverse (F^[x.2.val.toNat] (color Γ mark h2 paths x.1).val.val)
+        else F^[x.2.val.toNat] (color Γ mark h2 paths x.1).val.val) := by
+  let b := (paths x.1.1).get x.1.2
+  let q := localIndex (reversed Γ mark h2 b) (len b) x.2.val
+  have hlen : chunkLength Γ mark h2 paths x.1.1 x.1.2=len b := word_length Γ mark h2 b
+  have hq : x.2.val∈BlockAlignment.positions 0 (len b) := by
+    have h := x.2.property
+    change x.2.val∈BlockAlignment.positions 0 (chunkLength Γ mark h2 paths x.1.1 x.1.2) at h
+    rwa [hlen] at h
+  have hqb := local_bounds (reversed Γ mark h2 b) (len b) hq
+  have hn : q.toNat < chunkLength Γ mark h2 paths x.1.1 x.1.2 := by
+    rw [hlen]
+    dsimp [q]
+    omega
+  have hflat := ListChunkCoordinates.get_flatMap (paths x.1.1) w x.1.2 ⟨q.toNat,hn⟩
+  have him : ((splitChunks Γ mark h2 paths).equiv x).2.val.toNat=
+      start (chunkLength Γ mark h2 paths x.1.1) x.1.2+q.toNat := by
+    change (FiniteChunking.image _ _ _ x).2.val.toNat = _
+    rw [FiniteChunking.image_val]
+    change ((start (chunkLength Γ mark h2 paths x.1.1) x.1.2:ℤ)+
+      localIndex (reversed Γ mark h2 b) (chunkLength Γ mark h2 paths x.1.1 x.1.2) x.2.val).toNat = _
+    rw [hlen]
+    omega
+  change ((paths x.1.1).flatMap w)[start (chunkLength Γ mark h2 paths x.1.1) x.1.2+q.toNat]? =
+    some ((w b).get ⟨q.toNat,hn⟩) at hflat
+  rw [him,hflat]
+  have hd := listDart Γ mark h2 b x.2.val hq
+  rw [List.getElem?_eq_getElem hn] at hd
+  exact hd
+
+/-- Literal darts at all original path positions. -/
+def originalDart (x : Position (pathLength (chunks Γ mark h2 paths) (chunkLength Γ mark h2 paths))) : D :=
+  ((paths x.1).flatMap w).get ⟨x.2.val.toNat,by
+    have hx := x.2.property
+    have hz : 0≤x.2.val ∧ x.2.val < pathLength (chunks Γ mark h2 paths) (chunkLength Γ mark h2 paths) x.1 := by
+      simpa only [AffineIntervals.nat_positions,Finset.mem_Ico] using hx
+    rw [←pathLength_eq Γ mark h2 paths]
+    omega⟩
+
+omit [Fintype P] in
+lemma originalDart_get (x : Position (pathLength (chunks Γ mark h2 paths) (chunkLength Γ mark h2 paths))) :
+    ((paths x.1).flatMap w)[x.2.val.toNat]?=some (originalDart Γ mark h2 paths x) :=
+  List.getElem?_eq_getElem _
+
+lemma chunk_original (x : Position (traversalLength (chunks Γ mark h2 paths) (chunkLength Γ mark h2 paths))) :
+    originalDart Γ mark h2 paths ((splitChunks Γ mark h2 paths).equiv x)=
+      if (splitChunks Γ mark h2 paths).reverse x.1 then
+        Γ.reverse (F^[x.2.val.toNat] (color Γ mark h2 paths x.1).val.val)
+      else F^[x.2.val.toNat] (color Γ mark h2 paths x.1).val.val := by
+  apply Option.some.inj
+  rw [←originalDart_get]
+  exact chunk_dart Γ mark h2 paths x
+
+def repeatedChunks := ChunkComparisons.repeated (color Γ mark h2 paths)
+  (splitChunks Γ mark h2 paths) (repLength Γ mark h2) (chunkLength_eq Γ mark h2 paths)
+
+lemma repeated_original (x : Position (fun o : (c : R) × Fin (multiplicity (color Γ mark h2 paths) c) => repLength Γ mark h2 o.1)) :
+    originalDart Γ mark h2 paths ((repeatedChunks Γ mark h2 paths).equiv x)=
+      if (repeatedChunks Γ mark h2 paths).reverse x.1 then
+        Γ.reverse (F^[x.2.val.toNat] x.1.1.val.val)
+      else F^[x.2.val.toNat] x.1.1.val.val := by
+  unfold repeatedChunks ChunkComparisons.repeated Chunking.reindex
+  change originalDart Γ mark h2 paths ((splitChunks Γ mark h2 paths).equiv _)=_
+  rw [chunk_original]
+  simp only [positionEquiv_source,positionEquiv_coordinate,enumeration_color]
+
+omit [Fintype D] in
+lemma signed_eq_or_reverse (r s : Bool) (d : D) :
+    (if r then Γ.reverse d else d) = (if s then Γ.reverse d else d) ∨
+    (if r then Γ.reverse d else d) = Γ.reverse (if s then Γ.reverse d else d) := by
+  cases r <;> cases s <;> simp
+
+variable {E : Type*}
+    (cmp : Comparisons (E:=E) (pathLength (chunks Γ mark h2 paths) (chunkLength Γ mark h2 paths)))
+    (lo hi : E → ℤ) (hlo : ∀ e,cmp.lo e=(lo e:ℝ)) (hhi : ∀ e,cmp.hi e=(hi e:ℝ))
+
+/-- Reduction survives signed normalization: neither orientation of an actual
+paired undirected edge can become the same chain-coordinate position. -/
+lemma normalized_reduced
+    (hred : ∀ x e,cmp.side x=some e →
+      originalDart Γ mark h2 paths x≠originalDart Γ mark h2 paths (cmp.pairing.partner x) ∧
+      originalDart Γ mark h2 paths x≠Γ.reverse (originalDart Γ mark h2 paths (cmp.pairing.partner x))) :
+    ∀ x a,((repeatedChunks Γ mark h2 paths).comparisons cmp lo hi hlo hhi).side x=some a →
+      (x.1.1,x.2.val)≠
+      ((((repeatedChunks Γ mark h2 paths).comparisons cmp lo hi hlo hhi).pairing.partner x).1.1,
+       (((repeatedChunks Γ mark h2 paths).comparisons cmp lo hi hlo hhi).pairing.partner x).2.val) := by
+  intro x a ha heq
+  let K := repeatedChunks Γ mark h2 paths
+  have he := ((K.side_iff cmp x a.1 a.2.1 a.2.2).mp ha).1
+  have hbad := hred (K.equiv x) a.1 he
+  rw [←K.partner_image, repeated_original, repeated_original] at hbad
+  have hd : F^[x.2.val.toNat] x.1.1.val.val =
+      F^[((K.pairing cmp).partner x).2.val.toNat] ((K.pairing cmp).partner x).1.1.val.val := by
+    have h1 := congrArg Prod.fst heq
+    have h2 := congrArg Prod.snd heq
+    change x.1.1=((K.pairing cmp).partner x).1.1 at h1
+    change x.2.val=((K.pairing cmp).partner x).2.val at h2
+    rw [h1,h2]
+  rw [hd] at hbad
+  exact (signed_eq_or_reverse Γ (K.reverse x.1) (K.reverse ((K.pairing cmp).partner x).1) _).elim hbad.1 hbad.2
+
+/-- Actual graph labels, including reversal, induce precisely the literal
+compatibility constraints used by the repeated-block entropy estimates. -/
+lemma normalized_compatible {A : Type*} (bar : A → A) (hb : Function.Involutive bar)
+    (label : D → A) (hl : ∀ d,label (Γ.reverse d)=bar (label d))
+    (hc : ∀ x e,cmp.side x=some e → label (originalDart Γ mark h2 paths x)=
+      if cmp.reverse e then bar (label (originalDart Γ mark h2 paths (cmp.pairing.partner x)))
+      else label (originalDart Γ mark h2 paths (cmp.pairing.partner x))) :
+    ∀ x a,((repeatedChunks Γ mark h2 paths).comparisons cmp lo hi hlo hhi).side x=some a →
+      label (F^[x.2.val.toNat] x.1.1.val.val)=
+      if ((repeatedChunks Γ mark h2 paths).comparisons cmp lo hi hlo hhi).reverse a then
+        bar (label (F^[(((repeatedChunks Γ mark h2 paths).pairing cmp).partner x).2.val.toNat]
+          (((repeatedChunks Γ mark h2 paths).pairing cmp).partner x).1.1.val.val))
+      else label (F^[(((repeatedChunks Γ mark h2 paths).pairing cmp).partner x).2.val.toNat]
+          (((repeatedChunks Γ mark h2 paths).pairing cmp).partner x).1.1.val.val) := by
+  apply (repeatedChunks Γ mark h2 paths).compatible cmp lo hi hlo hhi bar hb
+    (fun x => label (originalDart Γ mark h2 paths x))
+    (fun x => label (F^[x.2.val.toNat] x.1.1.val.val)) _ hc
+  intro x
+  rw [repeated_original]
+  split_ifs <;> simp only [hl]
+
+/-- A step strictly inside a suppressed chain is an actual reduced graph
+passage, with both outgoing ports at precisely the same original vertex. -/
+lemma internal_step (d : B) (i : ℕ) (hi : i+1 < len d) :
+    Γ.origin (F^[i+1] d.val)=Γ.origin (Γ.reverse (F^[i] d.val)) ∧
+      F^[i+1] d.val≠Γ.reverse (F^[i] d.val) := by
+  constructor
+  · rw [iterate_succ_apply']
+    exact turn_origin Γ.origin mark h2 _
+  · intro he
+    have hn := ChainSuppression.no_internal_mark Γ.reverse τ Γ.reverse_reverse
+      (turn_involutive Γ.origin mark h2) d.val d.property (by omega : 0 < i+1) hi
+    apply hn
+    conv_lhs => rw [iterate_succ_apply']
+    change τ (τ (Γ.reverse (F^[i] d.val)))=F^[i+1] d.val
+    rw [turn_involutive Γ.origin mark h2,he]
+
+/-- Immersion of the literal labelled graph gives the reduced signed chain
+words required by every reflection and squared-word argument. -/
+lemma normalized_immersed {A : Type*} (bar : A → A) (label : D → A)
+    (hl : ∀ d,label (Γ.reverse d)=bar (label d))
+    (hinj : ∀ d e,Γ.origin d=Γ.origin e → label d=label e → d=e)
+    (c : R) (q : ℤ) (hq : 0≤q) (hq' : q+1<repLength Γ mark h2 c) :
+    label (F^[(q+1).toNat] c.val.val)≠bar (label (F^[q.toNat] c.val.val)) := by
+  have hn : (q+1).toNat=q.toNat+1 := by omega
+  have hi : q.toNat+1<len c.val := by change q+1<len c.val at hq'; omega
+  have hs := internal_step Γ mark h2 c.val q.toNat hi
+  intro he
+  rw [hn,←hl] at he
+  exact hs.2 (hinj _ _ hs.1 he)
+
+end TorsionFreeZeroDivisors.ChainChunkTransport
+
+namespace TorsionFreeZeroDivisors.ChainMultiplicity
+open scoped Classical BigOperators
+open Function PortSubdivision ChainSuppression DegreeTwoSuppression SuppressedMoore ChainPaths
+open ChainIsomorphism ChainChunkTransport ChunkComparisons FiniteChunking
+variable {V D : Type*} [Fintype D] (Γ : PortGraph V D)
+    (mark : V → Prop) (h2 : ∀ v, ¬mark v → (out Γ.origin v).card=2)
+local notation "B" => {d : D // turn Γ.origin mark h2 d=d}
+local notation "S" => suppressed Γ mark h2
+local notation "R" => ChainIsomorphism.Rep Γ mark h2
+
+lemma representative_val (c : R) : representative Γ mark h2 c.val=c := by
+  change ((orientation Γ mark h2).symm ((orientation Γ mark h2) (c,false))).1=c
+  rw [Equiv.symm_apply_apply]
+
+lemma reverse_oriented (b : B) :
+    (S).reverse b=(orientation Γ mark h2) (representative Γ mark h2 b,!(reversed Γ mark h2 b)) := by
+  have h := oriented Γ mark h2 b
+  cases hr : reversed Γ mark h2 b
+  · simp only [hr,Bool.false_eq_true,ite_false] at h
+    change (S).reverse b=(S).reverse (representative Γ mark h2 b).val
+    exact congrArg (S).reverse h
+  · simp only [hr,ite_true] at h
+    change (S).reverse b=(representative Γ mark h2 b).val
+    calc
+      _ = (S).reverse ((S).reverse (representative Γ mark h2 b).val) := congrArg (S).reverse h
+      _ = _ := (S).reverse_reverse _
+
+lemma representative_reverse (b : B) : representative Γ mark h2 ((S).reverse b)=representative Γ mark h2 b := by
+  rw [reverse_oriented]
+  change ((orientation Γ mark h2).symm ((orientation Γ mark h2) _)).1=_
+  rw [Equiv.symm_apply_apply]
+
+lemma unsigned (b : B) :
+    (if reversed Γ mark h2 b then (S).reverse b else b)=(representative Γ mark h2 b).val := by
+  have h := oriented Γ mark h2 b
+  cases hr : reversed Γ mark h2 b
+  · simpa only [hr,Bool.false_eq_true,ite_false] using h
+  · simp only [hr,ite_true] at h ⊢
+    calc
+      _ = (S).reverse ((S).reverse (representative Γ mark h2 b).val) := congrArg (S).reverse h
+      _ = _ := (S).reverse_reverse _
+
+lemma signed_representative (b : B) (r : Bool) :
+    representative Γ mark h2 (if r then (S).reverse b else b)=representative Γ mark h2 b := by
+  cases r <;> simp only [Bool.false_eq_true,ite_false,ite_true,representative_reverse]
+
+lemma representative_iff (b : B) (c : R) :
+    representative Γ mark h2 b=c ↔ b=c.val ∨ b=(S).reverse c.val := by
+  constructor
+  · intro h
+    have hb := oriented Γ mark h2 b
+    rw [h] at hb
+    cases hr : reversed Γ mark h2 b
+    · left; simpa only [hr,Bool.false_eq_true,ite_false] using hb
+    · right; simpa only [hr,ite_true] using hb
+  · rintro (rfl|rfl)
+    · exact representative_val Γ mark h2 c
+    · rw [representative_reverse,representative_val]
+
+lemma sign_injective (b : B) : Function.Injective (fun r : Bool => if r then (S).reverse b else b) := by
+  intro r t h
+  cases r <;> cases t <;> simp only [Bool.false_eq_true,ite_false,ite_true] at h ⊢
+  · exact ((S).reverse_ne b h.symm).elim
+  · exact ((S).reverse_ne b h).elim
+
+variable {P : Type*} [Fintype P]
+    (paths : P → List {d : D // turn Γ.origin mark h2 d=d})
+
+local notation "col" => color Γ mark h2 paths
+local notation "tp" => Traversal (chunks Γ mark h2 paths)
+local notation "e" => ListStageExponents.edge paths
+
+/-- The incidence fibre used in the Euler-exponent proof is the exact colour
+fibre used in the chain/block first moment. Both chain orientations count once. -/
+def incidenceEquiv (c : R) :
+    {o : (p : P) × (Fin (paths p).length × Bool) // PathIncidences.familyPort (S).reverse e o=c.val} ≃
+      {t : tp // col t=c} where
+  toFun o := ⟨⟨o.val.1,o.val.2.1⟩,by
+    have h := congrArg (representative Γ mark h2) o.property
+    change representative Γ mark h2 (if o.val.2.2 then (S).reverse ((paths o.val.1).get o.val.2.1)
+      else (paths o.val.1).get o.val.2.1)=representative Γ mark h2 c.val at h
+    rw [signed_representative,representative_val] at h
+    exact h⟩
+  invFun t := ⟨⟨t.val.1,t.val.2,reversed Γ mark h2 ((paths t.val.1).get t.val.2)⟩,by
+    change (if reversed Γ mark h2 ((paths t.val.1).get t.val.2) then
+      (S).reverse ((paths t.val.1).get t.val.2) else (paths t.val.1).get t.val.2)=c.val
+    rw [unsigned]
+    exact congrArg Subtype.val t.property⟩
+  left_inv := by
+    rintro ⟨⟨p,i,r⟩,ho⟩
+    apply Subtype.ext
+    change (⟨p,i,reversed Γ mark h2 ((paths p).get i)⟩ : (p : P) × (Fin (paths p).length × Bool))=⟨p,i,r⟩
+    have hr : reversed Γ mark h2 ((paths p).get i)=r := by
+      apply sign_injective Γ mark h2 ((paths p).get i)
+      dsimp only
+      rw [unsigned]
+      have h := congrArg (representative Γ mark h2) ho
+      change representative Γ mark h2 (if r then (S).reverse ((paths p).get i)
+        else (paths p).get i)=representative Γ mark h2 c.val at h
+      rw [signed_representative,representative_val] at h
+      rw [h]
+      exact ho.symm
+    rw [hr]
+  right_inv _ := rfl
+
+lemma multiplicity_eq (c : R) :
+    StageSubgraphs.multiplicity (S) e c.val=ChunkComparisons.multiplicity col c := by
+  classical
+  unfold StageSubgraphs.multiplicity IncidenceStages.Passages.multiplicity ChunkComparisons.multiplicity
+  simp only [Fintype.card_eq_nat_card]
+  exact Nat.card_congr (incidenceEquiv Γ mark h2 paths c)
+
+lemma multiplicity_at (b : B) :
+    StageSubgraphs.multiplicity (S) e b=
+      ChunkComparisons.multiplicity col (representative Γ mark h2 b) := by
+  have h := oriented Γ mark h2 b
+  conv_lhs => rw [h]
+  split_ifs
+  · rw [StageSubgraphs.multiplicity_reverse,multiplicity_eq]
+  · exact multiplicity_eq Γ mark h2 paths _
+
+end TorsionFreeZeroDivisors.ChainMultiplicity
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/GroupRing/ClosedWords.lean b/lean/OAI/Algebra/GroupRing/ClosedWords.lean
new file mode 100644
index 0000000000000000000000000000000000000000..f2481bbd4016032afb16cd2cd24f8b6af5b057a6
--- /dev/null
+++ b/lean/OAI/Algebra/GroupRing/ClosedWords.lean
@@ -0,0 +1,5499 @@
+import Mathlib
+import OAI.Algebra.GroupRing.BalancedPieces
+
+namespace OAI
+
+noncomputable section
+
+namespace TorsionFreeZeroDivisors.SampleGraph.ClosedWords
+open scoped Classical BigOperators
+open GirthAsymptotics ActualPatternEvent TypedGraphs WeightedMoore
+variable {rep : ℕ} {r : Match rep} {x : VA rep} {y : VB rep}
+    (s : PathSystem rep r x y) (cap : ℕ) (hc : 0<cap)
+    (hL : 1≤L (size rep)) (hd : GraphSample.Diameters rep r)
+def root : Option (Piece s cap) := s.root.bind fun t=>
+  if (s.paths t).length≤cap then some ⟨t,⟨0,BalancedPieces.number_pos hc⟩⟩ else none
+lemma piece_eq (p q : Piece s cap) (h : p.1=q.1) (hp : (s.paths p.1).length≤cap) : p=q := by
+  rcases p with ⟨t,i⟩
+  rcases q with ⟨u,j⟩
+  dsimp only at h hp
+  subst u
+  have hij : i=j := by
+    apply Fin.ext
+    have hi := i.isLt
+    have hj := j.isLt
+    simp only [BalancedPieces.number,ite_eq_left hp] at hi hj
+    omega
+  cases hij
+  rfl
+lemma root_eq_some (p : Piece s cap) : root s cap hc=some p ↔ s.root=some p.1 ∧ (s.paths p.1).length≤cap := by
+  cases hr : s.root with
+  | none => simp [root,hr]
+  | some t =>
+    by_cases ht : (s.paths t).length≤cap
+    · simp only [root,hr,Option.bind_some,ite_eq_left ht,Option.some.injEq]
+      constructor
+      · intro h
+        rw [←h]
+        exact ⟨rfl,ht⟩
+      · intro h
+        exact piece_eq s cap _ p h.1 ht
+    · simp only [root,hr,Option.bind_some,ite_eq_right ht,Option.some.injEq]
+      constructor
+      · intro h; cases h
+      · intro h; exact False.elim (ht (h.1 ▸ h.2))
+lemma cyclic_iff {T : Type} (root : Option T) (t : T) :
+    StageRoot.cyclic root t=true ↔ root≠some t := by
+  simp only [StageRoot.cyclic,decide_eq_true_eq]
+lemma cyclic (p : Piece s cap) (hp : StageRoot.cyclic (root s cap hc) p=true) :
+    ∀ᵉ (a∈(word s cap hc hL hd p).getLast?) (b∈(word s cap hc hL hd p).head?),
+      PortWalk.step (graph rep r).origin (graph rep r).reverse a b := by
+  have hp' := (cyclic_iff (root s cap hc) p).mp hp
+  by_cases hs : (s.paths p.1).length≤cap
+  · rw [word_short s cap hc hL hd p hs]
+    apply s.cyclic_chain
+    apply (cyclic_iff _ _).mpr
+    intro he
+    exact hp' ((root_eq_some s cap hc p).mpr ⟨he,hs⟩)
+  · exact cyclic_of_long s cap hc hL hd p (by omega)
+lemma root_start (p : Piece s cap) (hp : root s cap hc=some p) :
+    (word s cap hc hL hd p).head (nonempty s cap hc hL hd p)=(s.paths p.1).head (s.nonempty p.1) := by
+  have hs := ((root_eq_some s cap hc p).mp hp).2
+  simp only [word_short s cap hc hL hd p hs]
+lemma rootA (z : VA rep) (hz : (root s cap hc).map (fun p=>(graph rep r).origin
+      ((word s cap hc hL hd p).head (nonempty s cap hc hL hd p)))=some (.inl z)) : z=x := by
+  obtain ⟨p,hp,he⟩ := Option.map_eq_some_iff.mp hz
+  apply s.rootA z
+  have hh := (root_eq_some s cap hc p).mp hp
+  rw [hh.1,Option.map_some]
+  rw [root_start s cap hc hL hd p hp] at he
+  exact congrArg some he
+lemma rootB (z : VB rep) (hz : (root s cap hc).map (fun p=>(graph rep r).origin
+      ((word s cap hc hL hd p).head (nonempty s cap hc hL hd p)))=some (.inr z)) : z=y := by
+  obtain ⟨p,hp,he⟩ := Option.map_eq_some_iff.mp hz
+  apply s.rootB z
+  have hh := (root_eq_some s cap hc p).mp hp
+  rw [hh.1,Option.map_some]
+  rw [root_start s cap hc hL hd p hp] at he
+  exact congrArg some he
+end TorsionFreeZeroDivisors.SampleGraph.ClosedWords
+namespace TorsionFreeZeroDivisors.SingleException
+open scoped Classical BigOperators
+variable {T : Type} [Fintype T] (root : Option T) (f : T → ℕ) (L : ℕ)
+lemma cardinal_charge (h : ∀t,root≠some t → L≤f t) : Fintype.card T*L≤(∑t,f t)+L := by
+  classical
+  have hsum : (∑_t : T,L)≤∑t,(f t+if root=some t then L else 0) := by
+    apply Finset.sum_le_sum
+    intro t _
+    by_cases ht : root=some t
+    · simp only [ite_eq_left ht]; omega
+    · simpa only [ite_eq_right ht,Nat.add_zero] using h t ht
+  rw [Finset.sum_add_distrib] at hsum
+  have he : (∑t : T,if root=some t then L else 0)≤L := by
+    cases root with
+    | none => simp
+    | some t => simp
+  simp only [Finset.sum_const,Finset.card_univ,smul_eq_mul] at hsum
+  omega
+lemma two_mass (a b : T) (hab : a≠b) : f a+f b≤∑t,f t := by
+  classical
+  have h := Finset.sum_le_sum_of_subset (s:={a,b}) (t:=Finset.univ) (f:=f) (by simp)
+  simpa only [Finset.sum_pair hab] using h
+lemma divide_cast {U L D A H : ℕ} (hU : 0<U) (hL : 0<L)
+    (h : U*L*A≤3*(D*L)*H) : (A:ℝ)≤3*(D:ℝ)/U*(H:ℝ) := by
+  have hh : (U:ℝ)*L*A≤3*((D:ℝ)*L)*H := by exact_mod_cast h
+  have hu : (0:ℝ)<U := by exact_mod_cast hU
+  have hl : (0:ℝ)<L := by exact_mod_cast hL
+  rw [div_mul_eq_mul_div]
+  apply (le_div_iff₀ hu).mpr
+  nlinarith
+end TorsionFreeZeroDivisors.SingleException
+namespace TorsionFreeZeroDivisors.SampleGraph.ClosedWords
+open scoped Classical BigOperators
+open GirthAsymptotics ActualPatternEvent TypedGraphs WeightedMoore
+variable {rep : ℕ} {r : Match rep} {x : VA rep} {y : VB rep}
+    (s : PathSystem rep r x y) (U : ℕ) (hU : 3≤U)
+    (hL : 1≤L (size rep)) (hcap : 6≤U*L (size rep))
+    (hd : GraphSample.Diameters rep r) (hr : r∈samples rep)
+    (hordinary : ∃t,s.root≠some t)
+abbrev cap_pos : 0<U*L (size rep) := lt_of_lt_of_le (by norm_num : 0<6) hcap
+abbrev H₀ : ℕ := ∑t,(s.paths t).length
+include hr hordinary in
+lemma H₀_ge : L (size rep)≤H₀ s := by
+  obtain ⟨t,ht⟩ := hordinary
+  exact (original_girth s hr t ht).trans (Finset.single_le_sum (f:=fun t=>(s.paths t).length) (fun _ _=>Nat.zero_le _) (Finset.mem_univ t))
+include hU hr in
+lemma old_lower (p : Piece s (U*L (size rep)))
+    (hp : root s _ (cap_pos U hcap)≠some p) :
+    L (size rep)≤BalancedWords.old s.paths (U*L (size rep)) p := by
+  have hc := cap_pos U hcap
+  by_cases hs : (s.paths p.1).length≤U*L (size rep)
+  · have ht : s.root≠some p.1 := fun he=>hp ((root_eq_some s _ hc p).mpr ⟨he,hs⟩)
+    simp only [BalancedWords.old,BalancedPieces.sizes,ite_eq_left hs]
+    exact original_girth s hr p.1 ht
+  · have hh := BalancedPieces.sizes_lower_long hcap (by omega : U*L (size rep)<(s.paths p.1).length) p.2
+    change L (size rep)≤BalancedPieces.sizes (s.paths p.1).length (U*L (size rep)) p.2
+    nlinarith
+include hU hcap hr hordinary in
+lemma piece_charge : Fintype.card (Piece s (U*L (size rep)))*L (size rep)≤2*H₀ s := by
+  have hh := SingleException.cardinal_charge (root s _ (cap_pos U hcap)) (BalancedWords.old s.paths _) (L (size rep))
+    (old_lower s U hU hcap hr)
+  rw [BalancedWords.old_sum s.paths _ (cap_pos U hcap)] at hh
+  have hH := H₀_ge s hr hordinary
+  change L (size rep)≤∑t,(s.paths t).length at hH
+  change _≤2*(∑t,(s.paths t).length)
+  omega
+include hU hr in
+lemma lower_word (p : Piece s (U*L (size rep)))
+    (hp : root s _ (cap_pos U hcap)≠some p) :
+    L (size rep)≤(word s _ (cap_pos U hcap) hL hd p).length :=
+  (old_lower s U hU hcap hr p hp).trans (old_le_word s _ (cap_pos U hcap) hL hd p)
+include hr hordinary in
+lemma root_mass (p : Piece s (U*L (size rep)))
+    (hp : root s _ (cap_pos U hcap)=some p)
+    (hshort : (word s _ (cap_pos U hcap) hL hd p).length<L (size rep)) :
+    2*(word s _ (cap_pos U hcap) hL hd p).length≤H₀ s := by
+  obtain ⟨t,ht⟩ := hordinary
+  have hs := (root_eq_some s _ (cap_pos U hcap) p).mp hp
+  have hne : p.1≠t := by intro h; exact ht (h ▸ hs.1)
+  have hg := original_girth s hr t ht
+  have hsum := SingleException.two_mass (fun t=> (s.paths t).length) p.1 t hne
+  rw [word_short s _ (cap_pos U hcap) hL hd p hs.2] at hshort ⊢
+  change _≤∑t,(s.paths t).length
+  omega
+include hU in
+lemma added_real : (∑p : Piece s (U*L (size rep)),((tail s _ (cap_pos U hcap) hL hd p).length:ℝ))≤
+    3*(D:ℝ)/U*(H₀ s:ℝ) := by
+  have h := total_added s _ (cap_pos U hcap) hL hd hcap
+  have hh := SingleException.divide_cast (U:=U) (L:=L (size rep)) (D:=D)
+    (A:=∑p : Piece s (U*L (size rep)),(tail s _ (cap_pos U hcap) hL hd p).length)
+    (H:=H₀ s) (by omega) (by omega) h
+  rw [Nat.cast_sum] at hh
+  exact hh
+end TorsionFreeZeroDivisors.SampleGraph.ClosedWords
+
+/-! Finite rotation systems. The Euler inequality here
+is explicitly an input from a planar realization; no PL realization or planar
+separator theorem is asserted by this file. The face cycles and bad-gap count,
+however, are computed from the actual boundary and pairing permutations. -/
+namespace TorsionFreeZeroDivisors.PermutationCycles
+open scoped Classical BigOperators
+variable {O : Type} [Fintype O] (f : Equiv.Perm O)
+abbrev Cycle := Quotient (Equiv.Perm.SameCycle.setoid f)
+instance : Fintype (Cycle f) := Fintype.ofFinite _
+def cycle (x : O) : Cycle f := Quotient.mk _ x
+def members (c : Cycle f) : Finset O := Finset.univ.filter (fun x => cycle f x=c)
+@[simp] lemma mem_members {c : Cycle f} {x : O} : x∈members f c ↔ cycle f x=c := by simp [members]
+omit [Fintype O] in
+lemma cycle_eq {x y : O} : cycle f x=cycle f y ↔ f.SameCycle x y := Quotient.eq
+omit [Fintype O] in
+@[simp] lemma cycle_apply (x : O) : cycle f (f x)=cycle f x := by
+  apply (cycle_eq f).mpr
+  simpa only [Equiv.Perm.sameCycle_apply_left] using Equiv.Perm.SameCycle.refl f x
+omit [Fintype O] in
+lemma cycle_surjective : Function.Surjective (cycle f) := Quotient.mk_surjective
+lemma members_nonempty (c : Cycle f) : (members f c).Nonempty := by
+  obtain ⟨x,rfl⟩ := cycle_surjective f c
+  exact ⟨x,(mem_members f).mpr rfl⟩
+lemma mem_of_mem {c : Cycle f} {x : O} (hx : x∈members f c) : f x∈members f c := by
+  simpa only [mem_members,cycle_apply] using hx
+lemma card_one_fixed {x : O} (h : (members f (cycle f x)).card=1) : f x=x := by
+  obtain ⟨a,ha⟩ := Finset.card_eq_one.mp h
+  have hx : x∈members f (cycle f x) := (mem_members f).mpr rfl
+  have hf := mem_of_mem f hx
+  rw [ha,Finset.mem_singleton] at hx hf
+  exact hf.trans hx.symm
+lemma card_le_two_square {x : O} (h : (members f (cycle f x)).card≤2) : f (f x)=x := by
+  by_contra hn
+  have hfx : f x≠x := fun he => hn (by rw [he,he])
+  have hff : f (f x)≠f x := fun he => hfx (f.injective he)
+  have hx : x∈members f (cycle f x) := (mem_members f).mpr rfl
+  have hs : {x,f x,f (f x)}⊆members f (cycle f x) := by
+    intro a ha
+    simp only [Finset.mem_insert,Finset.mem_singleton] at ha
+    rcases ha with rfl|rfl|rfl
+    · exact hx
+    · exact mem_of_mem f hx
+    · exact mem_of_mem f (mem_of_mem f hx)
+  have hc := (Finset.card_le_card hs).trans h
+  have he : ({x,f x,f (f x)} : Finset O).card=3 := by
+    simp [Ne.symm hfx,Ne.symm hn,Ne.symm hff]
+  omega
+
+def fixed : Finset O := Finset.univ.filter (fun x => f x=x)
+lemma fixed_le_cycles : (fixed f).card≤Fintype.card (Cycle f) := by
+  have hi : Function.Injective (fun x : {x // x∈fixed f} => cycle f x.val) := by
+    intro x y he
+    apply Subtype.ext
+    exact ((cycle_eq f).mp he).eq_of_left ((Finset.mem_filter.mp x.property).2)
+  simpa only [Fintype.card_coe] using Fintype.card_le_of_injective _ hi
+lemma singleton_cycles_le_fixed :
+    (Finset.univ.filter (fun c : Cycle f => (members f c).card=1)).card≤(fixed f).card := by
+  let pick : {c : Cycle f // (members f c).card=1} → {x // x∈fixed f} := fun c =>
+    ⟨Quotient.out c.val,by
+      apply Finset.mem_filter.mpr
+      refine ⟨Finset.mem_univ _,?_⟩
+      apply card_one_fixed f
+      have he : cycle f (Quotient.out c.val)=c.val := Quotient.out_eq c.val
+      simpa only [he] using c.property⟩
+  have hi : Function.Injective pick := by
+    intro c d he
+    apply Subtype.ext
+    have h := congrArg (fun x : {x // x∈fixed f} => cycle f x.val) he
+    simpa only [pick,cycle,Quotient.out_eq] using h
+  simpa only [Fintype.card_subtype,Finset.filter_mem_eq_inter,Finset.univ_inter] using Fintype.card_le_of_injective pick hi
+lemma sum_card : (∑ c : Cycle f,(members f c).card)=Fintype.card O := by
+  have h := Finset.card_eq_sum_card_fiberwise (f:=cycle f)
+    (s:=Finset.univ) (t:=Finset.univ) (fun _ _ => Finset.mem_univ _)
+  exact h.symm
+lemma large_count :
+    (∑ c∈Finset.univ.filter (fun c : Cycle f => 3≤(members f c).card),(members f c).card)=
+     (Finset.univ.filter (fun x : O => 3≤(members f (cycle f x)).card)).card := by
+  calc
+    _ = (Finset.univ.filter (fun x : O => cycle f x∈Finset.univ.filter
+      (fun c : Cycle f => 3≤(members f c).card))).card :=
+      Finset.sum_card_fiberwise_eq_card_filter _ _ (cycle f)
+    _ = _ := by congr 1; ext x; simp
+
+end TorsionFreeZeroDivisors.PermutationCycles
+
+namespace TorsionFreeZeroDivisors.PlanarRotation
+open scoped Classical BigOperators
+open PermutationCycles
+lemma excess_identity {C : Type} [Fintype C] (len : C→ℕ) (hp : ∀ c,0<len c) :
+    (∑ c,(len c-2))+2*Fintype.card C=(∑ c,len c)+
+      (Finset.univ.filter (fun c => len c=1)).card := by
+  calc
+    _ = ∑ c,(len c-2+2) := by simp [Finset.sum_add_distrib,Nat.mul_comm]
+    _ = ∑ c,(len c+if len c=1 then 1 else 0) := by
+      apply Finset.sum_congr rfl
+      intro c _
+      have h := hp c
+      split_ifs <;> omega
+    _ = _ := by simp only [Finset.sum_add_distrib,Finset.sum_boole,Nat.cast_id]
+lemma large_sum_le {C : Type} [Fintype C] (len : C→ℕ) :
+    (∑ c∈Finset.univ.filter (fun c => 3≤len c),len c)≤3*∑ c,(len c-2) := by
+  rw [Finset.sum_filter,Finset.mul_sum]
+  apply Finset.sum_le_sum
+  intro c _
+  split_ifs <;> omega
+
+variable {O : Type} [Fintype O] (σ α : Equiv.Perm O)
+def opposite : Equiv.Perm O := α*σ
+/-- An actual distinct-arc digon gap, read solely from the two permutations. -/
+def Good (x : O) : Prop :=
+  opposite σ α (opposite σ α x)=x ∧ opposite σ α x≠x ∧ σ x≠x
+def bad : Finset O := Finset.univ.filter (fun x => ¬Good σ α x)
+lemma bad_card_bound :
+    (bad σ α).card≤(fixed (opposite σ α)).card+(fixed σ).card+
+      (Finset.univ.filter (fun x => 3≤(members (opposite σ α) (cycle (opposite σ α) x)).card)).card := by
+  let f := opposite σ α
+  let large := Finset.univ.filter (fun x => 3≤(members f (cycle f x)).card)
+  have hs : bad σ α⊆(fixed f∪fixed σ)∪large := by
+    intro x hx
+    have hx := (Finset.mem_filter.mp hx).2
+    by_cases h1 : f x=x
+    · exact Finset.mem_union_left _ (Finset.mem_union_left _ (Finset.mem_filter.mpr ⟨Finset.mem_univ _,h1⟩))
+    by_cases h2 : σ x=x
+    · exact Finset.mem_union_left _ (Finset.mem_union_right _ (Finset.mem_filter.mpr ⟨Finset.mem_univ _,h2⟩))
+    apply Finset.mem_union_right
+    apply Finset.mem_filter.mpr
+    refine ⟨Finset.mem_univ _,?_⟩
+    by_contra hn
+    exact hx ⟨card_le_two_square f (by omega),h1,h2⟩
+  exact (Finset.card_le_card hs).trans ((Finset.card_union_le _ _).trans
+    (Nat.add_le_add_right (Finset.card_union_le _ _) _))
+
+/-- The exact `8N` estimate. The planar input is only its explicit Euler
+inequality; no comparison-count estimate is assumed. -/
+theorem bad_gaps_le
+    (heuler : Fintype.card O+4≤2*Fintype.card (Cycle σ)+2*Fintype.card (Cycle (opposite σ α)))
+    (hmono : (fixed (opposite σ α)).card≤1) :
+    (bad σ α).card≤8*Fintype.card (Cycle σ) := by
+  let f := opposite σ α
+  let P := ∑ c : Cycle f,((members f c).card-2)
+  let M := (Finset.univ.filter (fun c : Cycle f => (members f c).card=1)).card
+  have hM : M≤1 := (singleton_cycles_le_fixed f).trans hmono
+  change (fixed f).card≤1 at hmono
+  have hP : P+2*Fintype.card (Cycle f)=Fintype.card O+M := by
+    have h := excess_identity (fun c : Cycle f => (members f c).card)
+      (fun c => Finset.card_pos.mpr (members_nonempty f c))
+    rw [sum_card] at h
+    exact h
+  have hl := large_sum_le (fun c : Cycle f => (members f c).card)
+  rw [large_count] at hl
+  have hb := bad_card_bound σ α
+  have hs := fixed_le_cycles σ
+  change (bad σ α).card≤(fixed f).card+(fixed σ).card+
+    (Finset.univ.filter (fun x => 3≤(members f (cycle f x)).card)).card at hb
+  change (Finset.univ.filter (fun x => 3≤(members f (cycle f x)).card)).card≤3*P at hl
+  change Fintype.card O+4≤2*Fintype.card (Cycle σ)+2*Fintype.card (Cycle f) at heuler
+  omega
+
+omit [Fintype O] in
+lemma good_opposite (hr : Function.Involutive α) {x : O} (hx : Good σ α x) :
+    Good σ α (opposite σ α x) := by
+  have he : σ (opposite σ α x)=α x := by
+    have h := congrArg α hx.1
+    change α (α (σ (α (σ x))))=α x at h
+    rw [hr] at h
+    exact h
+  refine ⟨congrArg (opposite σ α) hx.1,?_,?_⟩
+  · intro h
+    exact hx.2.1 (h.symm.trans hx.1)
+  · intro h
+    rw [he] at h
+    exact hx.2.2 (α.injective h).symm
+
+/-- Cut every bad gap and every prescribed marking together with its opposite. -/
+def cuts (marks : Finset O) : Finset O := bad σ α∪marks∪marks.image (opposite σ α)
+lemma cardinal_cuts (marks : Finset O) : (cuts σ α marks).card≤(bad σ α).card+2*marks.card := by
+  have h := (Finset.card_union_le (bad σ α∪marks) (marks.image (opposite σ α))).trans
+    (Nat.add_le_add (Finset.card_union_le _ _) (Finset.card_image_le))
+  unfold cuts
+  omega
+lemma cut_stable (hr : Function.Involutive α) (marks : Finset O) {x : O} (hx : Good σ α x) :
+    x∈cuts σ α marks ↔ opposite σ α x∈cuts σ α marks := by
+  have hy := good_opposite σ α hr hx
+  have image_iff {z : O} (hz : Good σ α z) :
+      z∈marks.image (opposite σ α) ↔ opposite σ α z∈marks := by
+    constructor
+    · intro hm
+      obtain ⟨w,hw,he⟩ := Finset.mem_image.mp hm
+      have hwz : w=opposite σ α z := (opposite σ α).injective (he.trans hz.1.symm)
+      simpa only [hwz] using hw
+    · intro h
+      exact Finset.mem_image.mpr ⟨opposite σ α z,h,hz.1⟩
+  simp only [cuts,Finset.mem_union,bad,Finset.mem_filter,Finset.mem_univ,true_and,
+    not_true_eq_false, hx,hy,false_or,image_iff hx,image_iff hy,hx.1]
+  exact or_comm
+
+/-- The source's `J ≤ 12N'`, retaining the exact boundary and splitting count. -/
+theorem cuts_le_twelve (marks : Finset O) (pieces : ℕ)
+    (heuler : Fintype.card O+4≤2*Fintype.card (Cycle σ)+2*Fintype.card (Cycle (opposite σ α)))
+    (hmono : (fixed (opposite σ α)).card≤1)
+    (hpieces : Fintype.card (Cycle σ)≤pieces)
+    (hmarks : marks.card≤Fintype.card (Cycle σ)+pieces) :
+    (cuts σ α marks).card≤12*pieces := by
+  have hb := bad_gaps_le σ α heuler hmono
+  have hc := cardinal_cuts σ α marks
+  omega
+end TorsionFreeZeroDivisors.PlanarRotation
+namespace TorsionFreeZeroDivisors.PlanarRuns
+open scoped Classical BigOperators
+open PlanarRotation
+variable {O : Type}
+
+/-- A finite circular boundary cut at least once in each boundary component. -/
+structure CutSystem (σ : Equiv.Perm O) where
+  cut : Finset O
+  hits : ∀ x, ∃ n : ℕ, (σ^n) x∈cut
+
+namespace CutSystem
+variable {σ : Equiv.Perm O} (S : CutSystem σ)
+def distance (x : O) : ℕ := Nat.find (S.hits x)
+def finish (x : O) : O := (σ^(S.distance x)) x
+lemma finish_mem (x : O) : S.finish x∈S.cut := Nat.find_spec (S.hits x)
+lemma before {x : O} {i : ℕ} (hi : i<S.distance x) : (σ^i) x∉S.cut :=
+  Nat.find_min (S.hits x) hi
+lemma distance_zero {x : O} (hx : x∈S.cut) : S.distance x=0 := by
+  apply Nat.eq_zero_of_le_zero
+  exact Nat.find_min' (S.hits x) (by simpa using hx)
+lemma finish_cut {x : O} (hx : x∈S.cut) : S.finish x=x := by
+  simp only [finish,S.distance_zero hx,pow_zero,Equiv.Perm.one_apply]
+lemma zero_iff (x : O) : S.distance x=0 ↔ x∈S.cut := by
+  constructor
+  · intro h
+    simpa only [finish,h,pow_zero,Equiv.Perm.one_apply] using S.finish_mem x
+  · exact S.distance_zero
+lemma distance_next {x : O} (hx : x∉S.cut) : S.distance x=S.distance (σ x)+1 := by
+  have hp : 0<S.distance x := Nat.pos_of_ne_zero (fun h => hx ((S.zero_iff x).mp h))
+  apply Nat.le_antisymm
+  · apply Nat.find_min'
+    simpa only [finish,pow_succ,Equiv.Perm.mul_apply] using S.finish_mem (σ x)
+  · have hm := Nat.find_min' (S.hits (σ x)) (show (σ^(S.distance x-1)) (σ x)∈S.cut from by
+      rw [← Equiv.Perm.mul_apply,← pow_succ,Nat.sub_add_cancel hp]
+      exact S.finish_mem x)
+    change S.distance (σ x)≤S.distance x-1 at hm
+    omega
+lemma finish_next {x : O} (hx : x∉S.cut) : S.finish (σ x)=S.finish x := by
+  simp only [finish,S.distance_next hx,pow_succ,Equiv.Perm.mul_apply]
+lemma finish_surjective : Function.Surjective (fun x => (⟨S.finish x,S.finish_mem x⟩ : {x // x∈S.cut})) := by
+  intro x
+  exact ⟨x.val,Subtype.ext (S.finish_cut x.property)⟩
+
+lemma distance_iterate (x : O) : ∀ i, i≤S.distance x →
+    S.distance ((σ^i) x)=S.distance x-i := by
+  intro i
+  induction i with
+  | zero => simp
+  | succ i ih =>
+    intro hi
+    have hp := S.before (x:=x) (i:=i) (by omega)
+    have hn := S.distance_next hp
+    have hh := ih (by omega)
+    rw [pow_succ',Equiv.Perm.mul_apply]
+    omega
+lemma finish_iterate (x : O) : ∀ i, i≤S.distance x → S.finish ((σ^i) x)=S.finish x := by
+  intro i hi
+  unfold finish
+  rw [S.distance_iterate x i hi,← Equiv.Perm.mul_apply,← pow_add,Nat.sub_add_cancel hi]
+
+/-- Every uncut adjacency is a distinct-arc digon, and cuts are stable under
+its opposite gap. These are precisely the hypotheses obtained by cutting bad
+and marked gaps in `PlanarRotation`. -/
+structure Paired (α : Equiv.Perm O) : Prop where
+  involutive : Function.Involutive α
+  fixed_free : ∀ x, α x≠x
+  good : ∀ x, x∉S.cut → Good σ α x
+  stable : ∀ x, Good σ α x → (x∈S.cut ↔ opposite σ α x∈S.cut)
+
+namespace Paired
+variable {S}
+variable {α : Equiv.Perm O} (P : S.Paired α)
+include P
+lemma opposite_next {x : O} (hx : x∉S.cut) : σ (α (σ x))=α x := by
+  have h := congrArg α (P.good x hx).1
+  change α (α (σ (α (σ x))))=α x at h
+  rw [P.involutive] at h
+  exact h
+lemma opposite_uncut {x : O} (hx : x∉S.cut) : α (σ x)∉S.cut := by
+  exact fun h => hx ((P.stable x (P.good x hx)).mpr h)
+lemma finish_opposite {x : O} (hx : x∉S.cut) : S.finish (α (σ x))=S.finish (α x) := by
+  have h := S.finish_next (P.opposite_uncut hx)
+  rw [P.opposite_next hx] at h
+  exact h.symm
+lemma finish_pair (x : O) : S.finish (α (S.finish x))=S.finish (α x) := by
+  generalize hn : S.distance x=n
+  induction n using Nat.strong_induction_on generalizing x with
+  | h n ih =>
+    by_cases hx : x∈S.cut
+    · rw [S.finish_cut hx]
+    · have hd := S.distance_next hx
+      have he := ih (S.distance (σ x)) (by omega) (σ x) rfl
+      rw [S.finish_next hx] at he
+      exact he.trans (P.finish_opposite hx)
+
+def pair (_P : S.Paired α) (c : {x // x∈S.cut}) : {x // x∈S.cut} := ⟨S.finish (α c.val),S.finish_mem _⟩
+lemma pair_involutive : Function.Involutive (P.pair) := by
+  intro c
+  apply Subtype.ext
+  change S.finish (α (S.finish (α c.val)))=c.val
+  rw [P.finish_pair,P.involutive,S.finish_cut c.property]
+
+lemma reverse_steps (c : {x // x∈S.cut}) (hs : P.pair c=c) :
+    ∀ i, i≤S.distance (α c.val) →
+      α ((σ^i) (α c.val))=(σ^(S.distance (α c.val)-i)) (α c.val) := by
+  intro i
+  induction i with
+  | zero =>
+    intro _
+    have h := congrArg Subtype.val hs
+    change S.finish (α c.val)=c.val at h
+    simp only [pow_zero,Equiv.Perm.one_apply,Nat.sub_zero]
+    rw [P.involutive]
+    exact h.symm
+  | succ i ih =>
+    intro hi
+    have hj : i<S.distance (α c.val) := by omega
+    have hcut := S.before hj
+    have he := P.opposite_next hcut
+    have hh := ih (by omega)
+    apply σ.injective
+    rw [pow_succ',Equiv.Perm.mul_apply,he,hh]
+    have hd : S.distance (α c.val)-i=(S.distance (α c.val)-(i+1))+1 := by omega
+    rw [hd,pow_succ',Equiv.Perm.mul_apply]
+lemma pair_fixed_free (c : {x // x∈S.cut}) : P.pair c≠c := by
+  intro hs
+  let d := S.distance (α c.val)
+  let k := d/2
+  have hk : k≤d := Nat.div_le_self _ _
+  have he := P.reverse_steps c hs k hk
+  by_cases hp : d=2*k
+  · have hdk : S.distance (α c.val)-k=k := by change d-k=k; omega
+    rw [hdk] at he
+    exact P.fixed_free _ he
+  · have hd : d=2*k+1 := by dsimp [k]; omega
+    have hdk : S.distance (α c.val)-k=k+1 := by change d-k=k+1; omega
+    rw [hdk,pow_succ',Equiv.Perm.mul_apply] at he
+    have hc : (σ^k) (α c.val)∉S.cut := S.before (by change k<d; omega)
+    have hg := P.good _ hc
+    apply hg.2.1
+    change α (σ ((σ^k) (α c.val)))=(σ^k) (α c.val)
+    rw [← he,P.involutive]
+
+lemma predecessor_cut (c : {x // x∈S.cut}) : σ.symm (α c.val)∈S.cut := by
+  by_contra hn
+  have h := P.opposite_uncut hn
+  rw [Equiv.apply_symm_apply,P.involutive] at h
+  exact h c.property
+
+/-- Each cut is the last occurrence of its run; the first occurrence is the
+partner of the final occurrence of the opposite run. -/
+def first (c : {x // x∈S.cut}) : O := α (P.pair c).val
+lemma finish_first (c : {x // x∈S.cut}) : S.finish (P.first c)=c.val := by
+  exact congrArg Subtype.val (P.pair_involutive c)
+lemma before_first_cut (c : {x // x∈S.cut}) : σ.symm (P.first c)∈S.cut :=
+  P.predecessor_cut (P.pair c)
+
+lemma distance_le_first {c : {x // x∈S.cut}} {x : O} (hx : S.finish x=c.val) :
+    S.distance x≤S.distance (P.first c) := by
+  by_contra hn
+  have hd : S.distance (P.first c)+1≤S.distance x := by omega
+  have he : (σ^(S.distance x-S.distance (P.first c))) x=P.first c := by
+    apply (σ^(S.distance (P.first c))).injective
+    rw [← Equiv.Perm.mul_apply,← pow_add,Nat.add_sub_of_le (by omega)]
+    exact hx.trans (P.finish_first c).symm
+  have hg : (σ^(S.distance x-S.distance (P.first c)-1)) x=σ.symm (P.first c) := by
+    apply σ.injective
+    rw [Equiv.apply_symm_apply,← Equiv.Perm.mul_apply,← pow_succ']
+    have heq : S.distance x-S.distance (P.first c)-1+1=S.distance x-S.distance (P.first c) := by omega
+    rw [heq]
+    exact he
+  have hcut := P.before_first_cut c
+  rw [← hg] at hcut
+  exact S.before (by omega) hcut
+
+lemma run_coordinates {c : {x // x∈S.cut}} {x : O} (hx : S.finish x=c.val) :
+    (σ^(S.distance (P.first c)-S.distance x)) (P.first c)=x := by
+  have hd := P.distance_le_first hx
+  apply (σ^(S.distance x)).injective
+  rw [← Equiv.Perm.mul_apply,← pow_add,Nat.add_sub_of_le hd]
+  exact (P.finish_first c).trans hx.symm
+
+def run (c : {x // x∈S.cut}) : List O :=
+  (List.range (S.distance (P.first c)+1)).map (fun i => (σ^i) (P.first c))
+lemma mem_run {c : {x // x∈S.cut}} {x : O} : x∈P.run c ↔ S.finish x=c.val := by
+  constructor
+  · intro h
+    obtain ⟨i,hi,rfl⟩ := List.mem_map.mp h
+    have hi' : i≤S.distance (P.first c) := by simpa only [List.mem_range,Nat.lt_succ_iff] using hi
+    exact (S.finish_iterate _ _ hi').trans (P.finish_first c)
+  · intro hx
+    apply List.mem_map.mpr
+    exact ⟨S.distance (P.first c)-S.distance x,
+      List.mem_range.mpr (by omega),P.run_coordinates hx⟩
+lemma run_nonempty (c : {x // x∈S.cut}) : P.run c≠[] := by
+  simp [run]
+lemma run_nodup (c : {x // x∈S.cut}) : (P.run c).Nodup := by
+  apply List.Nodup.map_on _ List.nodup_range
+  intro i hi j hj he
+  have hi' : i≤S.distance (P.first c) := by simpa only [List.mem_range,Nat.lt_succ_iff] using hi
+  have hj' : j≤S.distance (P.first c) := by simpa only [List.mem_range,Nat.lt_succ_iff] using hj
+  have h := congrArg S.distance he
+  rw [S.distance_iterate _ _ hi',S.distance_iterate _ _ hj'] at h
+  omega
+lemma belongs_opposite {c : {x // x∈S.cut}} {x : O} (hx : x∈P.run c) :
+    α x∈P.run (P.pair c) := by
+  apply P.mem_run.mpr
+  have he := P.mem_run.mp hx
+  have h := P.finish_pair x
+  rw [he] at h
+  exact h.symm
+lemma distinct_runs (c : {x // x∈S.cut}) : P.run c≠P.run (P.pair c) := by
+  intro h
+  have hc : c.val∈P.run c := P.mem_run.mpr (S.finish_cut c.property)
+  rw [h] at hc
+  have he := P.mem_run.mp hc
+  rw [S.finish_cut c.property] at he
+  exact P.pair_fixed_free c (Subtype.ext he.symm)
+
+lemma first_pair (c : {x // x∈S.cut}) : P.first (P.pair c)=α c.val := by
+  unfold first
+  rw [P.pair_involutive]
+lemma distance_reverse (c : {x // x∈S.cut}) : ∀ i,i≤S.distance (P.first c) →
+    S.distance (α ((σ^i) (P.first c)))=i := by
+  intro i
+  induction i with
+  | zero =>
+    intro _
+    simp only [pow_zero,Equiv.Perm.one_apply,first]
+    rw [P.involutive]
+    exact S.distance_zero (P.pair c).property
+  | succ i ih =>
+    intro hi
+    have hc := S.before (x:=P.first c) (i:=i) (by omega)
+    have hd := S.distance_next (P.opposite_uncut hc)
+    rw [P.opposite_next hc,ih (by omega)] at hd
+    simpa only [pow_succ',Equiv.Perm.mul_apply] using hd
+lemma distance_first_pair (c : {x // x∈S.cut}) :
+    S.distance (P.first (P.pair c))=S.distance (P.first c) := by
+  have h := P.distance_reverse c (S.distance (P.first c)) le_rfl
+  change S.distance (α (S.finish (P.first c)))=S.distance (P.first c) at h
+  rw [P.finish_first] at h
+  rw [P.first_pair]
+  exact h
+lemma reverse_coordinate (c : {x // x∈S.cut}) (i : ℕ) (hi : i≤S.distance (P.first c)) :
+    α ((σ^i) (P.first c))=(σ^(S.distance (P.first c)-i)) (P.first (P.pair c)) := by
+  have hmem : (σ^i) (P.first c)∈P.run c :=
+    P.mem_run.mpr ((S.finish_iterate _ _ hi).trans (P.finish_first c))
+  have he := P.run_coordinates (P.mem_run.mp (P.belongs_opposite hmem))
+  rw [P.distance_first_pair,P.distance_reverse c i hi] at he
+  exact he.symm
+lemma run_reverse (c : {x // x∈S.cut}) : (P.run c).map α=(P.run (P.pair c)).reverse := by
+  apply List.ext_getElem
+  · simp only [List.length_map,List.length_reverse,run,List.length_range,P.distance_first_pair]
+  · intro i hi hj
+    have hi' : i≤S.distance (P.first c) := by simpa only [List.length_map,run,List.length_range,Nat.lt_succ_iff] using hi
+    simp only [run,List.getElem_map,List.getElem_range,List.getElem_reverse,
+      List.length_map,List.length_range,P.distance_first_pair]
+    have he : S.distance (P.first c)+1-1-i=S.distance (P.first c)-i := by omega
+    simpa only [he] using P.reverse_coordinate c i hi'
+
+end Paired
+namespace PairOrbit
+variable {A : Type} (r : A→A) (hr : Function.Involutive r)
+def relation : Setoid A where
+  r x y := x=y ∨ r x=y
+  iseqv := ⟨fun _ => Or.inl rfl,fun {x y} h => by
+    rcases h with h|h
+    · exact Or.inl h.symm
+    · exact Or.inr (by rw [←h,hr]),fun {x y z} h k => by
+    rcases h with rfl|h
+    · exact k
+    · rcases k with rfl|k
+      · exact Or.inr h
+      · exact Or.inl (by rw [←k,←h,hr])⟩
+abbrev Orbit := Quotient (relation r hr)
+variable [Fintype A]
+instance : Fintype (Orbit r hr) := Fintype.ofFinite _
+def project (x : A) : Orbit r hr := Quotient.mk _ x
+lemma fiber_two (hf : ∀ x,r x≠x) (c : Orbit r hr) :
+    (Finset.univ.filter (fun x => project r hr x=c)).card=2 := by
+  obtain ⟨x,rfl⟩ := Quotient.mk_surjective c
+  have he : Finset.univ.filter (fun y => project r hr y=project r hr x)={x,r x} := by
+    ext y
+    simp only [Finset.mem_filter,Finset.mem_univ,true_and,Finset.mem_insert,Finset.mem_singleton]
+    change Quotient.mk (relation r hr) y=Quotient.mk (relation r hr) x ↔ y=x ∨ y=r x
+    rw [Quotient.eq]
+    change (y=x ∨ r y=x) ↔ y=x ∨ y=r x
+    constructor
+    · rintro (h|h)
+      · exact Or.inl h
+      · exact Or.inr (by rw [←h,hr])
+    · rintro (h|h)
+      · exact Or.inl h
+      · exact Or.inr (by rw [h,hr])
+  change (Finset.univ.filter (fun y => project r hr y=project r hr x)).card=2
+  rw [he]
+  simp [Ne.symm (hf x)]
+lemma card_twice (hf : ∀ x,r x≠x) : 2*Fintype.card (Orbit r hr)=Fintype.card A := by
+  have h := Finset.card_eq_sum_card_fiberwise (s:=Finset.univ) (t:=Finset.univ)
+    (f:=project r hr) (fun _ _ => Finset.mem_univ _)
+  simpa only [fiber_two r hr hf,Finset.sum_const,Finset.card_univ,smul_eq_mul,Nat.mul_comm] using h.symm
+end PairOrbit
+
+namespace Paired
+variable {S} {α : Equiv.Perm O} (P : S.Paired α)
+abbrev IntervalPair := PairOrbit.Orbit P.pair P.pair_involutive
+instance : Fintype P.IntervalPair := PairOrbit.instFintypeOrbit _ _
+lemma twice_interval_pairs : 2*Fintype.card P.IntervalPair=S.cut.card := by
+  simpa only [Fintype.card_coe] using PairOrbit.card_twice P.pair P.pair_involutive P.pair_fixed_free
+lemma interval_pairs_le (pieces : ℕ) (hcut : S.cut.card≤12*pieces) :
+    Fintype.card P.IntervalPair≤6*pieces := by
+  have h := P.twice_interval_pairs
+  omega
+end Paired
+
+/-- The literal source cut construction has at least one cut per boundary,
+using one chosen indexing mark there. -/
+def ofMarks [Fintype O] (α : Equiv.Perm O) (marks : Finset O)
+    (hmark : ∀ x,∃ y∈marks,σ.SameCycle x y) : CutSystem σ where
+  cut := PlanarRotation.cuts σ α marks
+  hits x := by
+    obtain ⟨y,hy,hxy⟩ := hmark x
+    obtain ⟨n,hn⟩ := hxy.exists_nat_pow_eq
+    refine ⟨n,?_⟩
+    rw [hn]
+    exact Finset.mem_union.mpr (Or.inl (Finset.mem_union.mpr (Or.inr hy)))
+lemma ofMarks_paired [Fintype O] (α : Equiv.Perm O) (marks : Finset O)
+    (hmark : ∀ x,∃ y∈marks,σ.SameCycle x y)
+    (hr : Function.Involutive α) (hf : ∀ x,α x≠x) :
+    (ofMarks α marks hmark).Paired α where
+  involutive := hr
+  fixed_free := hf
+  good x hx := by
+    by_contra hn
+    exact hx (Finset.mem_union.mpr (Or.inl (Finset.mem_union.mpr
+      (Or.inl (Finset.mem_filter.mpr ⟨Finset.mem_univ _,hn⟩)))))
+  stable x hx := PlanarRotation.cut_stable σ α hr marks hx
+
+/-- Exact `6N'` interval-pair count for the finite rotation data of the
+manuscript. Euler planarity and the at-most-one exceptional monogon remain
+explicit geometric inputs; the resulting intervals and their reversal are
+constructed, not presumed. -/
+theorem source_interval_bound [Fintype O] (α : Equiv.Perm O) (marks : Finset O)
+    (hmark : ∀ x,∃ y∈marks,σ.SameCycle x y)
+    (hr : Function.Involutive α) (hf : ∀ x,α x≠x) (pieces : ℕ)
+    (heuler : Fintype.card O+4≤2*Fintype.card (PermutationCycles.Cycle σ)+
+      2*Fintype.card (PermutationCycles.Cycle (opposite σ α)))
+    (hmono : (PermutationCycles.fixed (opposite σ α)).card≤1)
+    (hpieces : Fintype.card (PermutationCycles.Cycle σ)≤pieces)
+    (hmarks : marks.card≤Fintype.card (PermutationCycles.Cycle σ)+pieces) :
+    Fintype.card (ofMarks_paired α marks hmark hr hf).IntervalPair≤6*pieces := by
+  apply Paired.interval_pairs_le
+  exact PlanarRotation.cuts_le_twelve σ α marks pieces heuler hmono hpieces hmarks
+
+end CutSystem
+end TorsionFreeZeroDivisors.PlanarRuns
+
+namespace TorsionFreeZeroDivisors.PlanarIntervals
+open scoped Classical BigOperators
+open BlockAlignment ComparedBlocks PlanarRuns PlanarRuns.CutSystem
+variable {T : Type} {len : T→ℕ} {σ α : Equiv.Perm (Position len)}
+    (S : CutSystem σ) (P : S.Paired α)
+    (hstep : ∀ x,x∉S.cut → (σ x).1=x.1 ∧ (σ x).2.val=x.2.val+1)
+
+lemma position_ext {x y : Position len} (hs : x.1=y.1) (hc : x.2.val=y.2.val) : x=y := by
+  rcases x with ⟨x,q⟩; rcases y with ⟨y,r⟩
+  dsimp at hs hc
+  subst y
+  congr 1
+  exact Subtype.ext hc
+
+include hstep
+lemma coordinate_iterate (x : Position len) (i : ℕ) (hi : i≤S.distance x) :
+    ((σ^i) x).1=x.1 ∧ ((σ^i) x).2.val=x.2.val+i := by
+  induction i with
+  | zero =>
+    change x.1=x.1 ∧ x.2.val=x.2.val+(0:ℤ)
+    simp
+  | succ i ih =>
+    have hh := hstep ((σ^i) x) (S.before (by omega))
+    have ih := ih (by omega)
+    rw [pow_succ',Equiv.Perm.mul_apply]
+    constructor
+    · exact hh.1.trans ih.1
+    · rw [hh.2,ih.2,Nat.cast_add,Nat.cast_one]; ring
+
+def lower (c : {x // x∈S.cut}) : ℤ := (P.first c).2.val
+def upper (c : {x // x∈S.cut}) : ℤ := c.val.2.val+1
+lemma finish_coordinates (c : {x // x∈S.cut}) :
+    c.val.1=(P.first c).1 ∧ upper S c=lower S P c+S.distance (P.first c)+1 := by
+  have hh := coordinate_iterate S hstep (P.first c) (S.distance (P.first c)) le_rfl
+  change (S.finish (P.first c)).1=_ ∧ (S.finish (P.first c)).2.val=_ at hh
+  rw [P.finish_first] at hh
+  exact ⟨hh.1,by dsimp only [upper,lower]; omega⟩
+lemma bounds (c : {x // x∈S.cut}) :
+    0≤lower S P c ∧ lower S P c<upper S c ∧ upper S c≤len (P.first c).1 := by
+  have hf := (P.first c).2.property
+  have hc := c.val.2.property
+  rw [mem_positions] at hf hc
+  have he := finish_coordinates S P hstep c
+  have h0 : (0:ℝ)≤((P.first c).2.val:ℝ) := by
+    have : (0:ℤ)≤(P.first c).2.val := by exact_mod_cast (show (-1:ℝ)<((P.first c).2.val:ℝ) by linarith [hf.1])
+    exact_mod_cast this
+  have h1 : c.val.2.val+1≤(len c.val.1:ℤ) := by
+    have : (c.val.2.val:ℝ)<len c.val.1 := by linarith [hc.2]
+    exact_mod_cast this
+  have h1 := h1.trans_eq (congrArg (fun t => (len t : ℤ)) he.1)
+  refine ⟨by exact_mod_cast h0,?_,h1⟩
+  rw [he.2]
+  omega
+
+lemma finish_iff (x : Position len) (c : {x // x∈S.cut}) :
+    S.finish x=c.val ↔ x.1=(P.first c).1 ∧ lower S P c≤x.2.val ∧ x.2.val<upper S c := by
+  constructor
+  · intro hx
+    have hc := P.run_coordinates hx
+    have hi : S.distance (P.first c)-S.distance x≤S.distance (P.first c) := Nat.sub_le _ _
+    have hh := coordinate_iterate S hstep (P.first c) _ hi
+    rw [hc] at hh
+    have hd := P.distance_le_first hx
+    have he := (finish_coordinates S P hstep c).2
+    refine ⟨hh.1,?_,?_⟩ <;> dsimp only [lower] at * <;> omega
+  · rintro ⟨hs,hl,hu⟩
+    have he := (finish_coordinates S P hstep c).2
+    let i := (x.2.val-lower S P c).toNat
+    have hi : i≤S.distance (P.first c) := by dsimp only [i]; omega
+    have hh := coordinate_iterate S hstep (P.first c) i hi
+    have hp : (σ^i) (P.first c)=x := by
+      apply position_ext
+      · exact hh.1.trans hs.symm
+      · rw [hh.2]
+        dsimp only [i,lower] at *
+        omega
+    rw [←hp]
+    exact (S.finish_iterate _ _ hi).trans (P.finish_first c)
+
+lemma finish_real_iff (x : Position len) (c : {x // x∈S.cut}) :
+    S.finish x=c.val ↔ x.1=(P.first c).1 ∧
+      x.2.val∈positions (lower S P c) (upper S c) := by
+  rw [finish_iff S P hstep,mem_positions]
+  constructor
+  · rintro ⟨hs,hl,hu⟩
+    have hl' : (lower S P c:ℝ)≤x.2.val := by exact_mod_cast hl
+    have hu' : (x.2.val:ℝ)+1≤upper S c := by exact_mod_cast hu
+    exact ⟨hs,by linarith,by linarith⟩
+  · rintro ⟨hs,hl,hu⟩
+    have hl' : lower S P c≤x.2.val := by
+      have : (lower S P c:ℝ)-1<x.2.val := by linarith
+      have hh : lower S P c-1<x.2.val := by exact_mod_cast this
+      omega
+    have hu' : x.2.val<upper S c := by exact_mod_cast (show (x.2.val:ℝ)<upper S c by linarith)
+    exact ⟨hs,hl',hu'⟩
+
+lemma partner_coordinate {x : Position len} {c : {x // x∈S.cut}} (hx : S.finish x=c.val) :
+    (α x).2.val=lower S P (P.pair c)+upper S c-1-x.2.val := by
+  let i := S.distance (P.first c)-S.distance x
+  have hi : i≤S.distance (P.first c) := Nat.sub_le _ _
+  have hp := P.run_coordinates hx
+  change (σ^i) (P.first c)=x at hp
+  have hα := P.reverse_coordinate c i hi
+  rw [hp] at hα
+  have ht := coordinate_iterate S hstep (P.first (P.pair c)) (S.distance (P.first c)-i) (by
+    rw [P.distance_first_pair]; omega)
+  rw [←hα] at ht
+  have hh := coordinate_iterate S hstep (P.first c) i hi
+  rw [hp] at hh
+  have he := (finish_coordinates S P hstep c).2
+  dsimp only [lower] at *
+  omega
+
+/-- Every actual maximal run yields a literal integer comparison side. No
+real-grid or arbitrary interval compatibility is postulated. -/
+def comparisons : Comparisons (E:={x // x∈S.cut}) len where
+  pairing := ⟨α,P.involutive⟩
+  side x := some ⟨S.finish x,S.finish_mem x⟩
+  flip := P.pair
+  flip_inv := P.pair_involutive
+  flip_ne := P.pair_fixed_free
+  side_partner := by
+    intro x c hc
+    have he : S.finish x=c.val := congrArg Subtype.val (Option.some.inj hc)
+    apply congrArg some
+    apply Subtype.ext
+    change S.finish (α x)=S.finish (α c.val)
+    rw [←he,←P.finish_pair]
+  none_iff x := by simp only [Option.some_ne_none,false_iff]; exact P.fixed_free x
+  source c := (P.first c).1
+  lo c := lower S P c
+  hi c := upper S c
+  reverse _ := true
+  offset c := lower S P (P.pair c)+upper S c
+  side_iff x c := by
+    rw [Option.some.injEq,Subtype.ext_iff]
+    exact finish_real_iff S P hstep x c
+  partner_source := by
+    intro x c hc
+    have he : S.finish x=c.val := congrArg Subtype.val (Option.some.inj hc)
+    have ht : S.finish (α x)=(P.pair c).val := by
+      change S.finish (α x)=S.finish (α c.val)
+      rw [←he,←P.finish_pair]
+    exact ((finish_iff S P hstep _ _).mp ht).1
+  partner_coordinate := by
+    intro x c hc
+    exact partner_coordinate S P hstep (congrArg Subtype.val (Option.some.inj hc))
+  target_range := by
+    intro c
+    simp only [ite_true,Int.cast_add]
+    have hb := bounds S P hstep (P.pair c)
+    have h1 := (finish_coordinates S P hstep c).2
+    have h2 := (finish_coordinates S P hstep (P.pair c)).2
+    rw [P.distance_first_pair] at h2
+    constructor
+    · have hh : (0:ℝ)≤lower S P (P.pair c) := by exact_mod_cast hb.1
+      linarith
+    · have hh : lower S P (P.pair c)+upper S c-lower S P c≤(len (P.first (P.pair c)).1:ℤ) := by omega
+      exact_mod_cast hh
+end TorsionFreeZeroDivisors.PlanarIntervals
+namespace TorsionFreeZeroDivisors.ExtendComparisons
+open scoped Classical BigOperators
+open BlockAlignment ComparedBlocks
+variable {T E : Type} {len more : T → ℕ} (C : Comparisons (E:=E) len)
+    (hle : ∀ t,len t ≤ more t)
+
+lemma positions_mono {m n : ℕ} (h : m≤n) : positions 0 m⊆positions 0 n := by
+  intro q hq
+  rw [mem_positions] at hq ⊢
+  exact ⟨hq.1,hq.2.trans_le (by exact_mod_cast h)⟩
+def embed (x : Position len) : Position more :=
+  ⟨x.1,⟨x.2.val,positions_mono (hle x.1) x.2.property⟩⟩
+abbrev Old (x : Position more) : Prop := x.2.val∈positions 0 (len x.1)
+def project (x : Position more) (h : Old (len:=len) x) : Position len := ⟨x.1,⟨x.2.val,h⟩⟩
+lemma old_embed (x : Position len) : Old (len:=len) (embed hle x) := x.2.property
+lemma project_embed (x : Position len) : project (embed hle x) (old_embed hle x)=x := by cases x; rfl
+lemma embed_project (x : Position more) (h : Old (len:=len) x) : embed hle (project x h)=x := by cases x; rfl
+lemma embed_injective : Function.Injective (embed hle) := by
+  intro x y h
+  apply PlanarIntervals.position_ext
+  · exact congrArg (fun x : Position more => x.1) h
+  · exact congrArg (fun x : Position more => x.2.val) h
+
+def partner (x : Position more) : Position more :=
+  if h : Old (len:=len) x then embed hle (C.pairing.partner (project x h)) else x
+lemma partner_embed (x : Position len) : partner C hle (embed hle x)=embed hle (C.pairing.partner x) := by
+  simp only [partner,dite_eq_left (old_embed hle x),project_embed]
+lemma partner_new (x : Position more) (h : ¬Old (len:=len) x) : partner C hle x=x := by
+  simp only [partner,dite_eq_right h]
+lemma partner_inv : Function.Involutive (partner C hle) := by
+  intro x
+  by_cases h : Old (len:=len) x
+  · rw [←embed_project hle x h,partner_embed,partner_embed,C.pairing.involutive]
+  · rw [partner_new C hle x h,partner_new C hle x h]
+def side (x : Position more) : Option E :=
+  if h : Old (len:=len) x then C.side (project x h) else none
+lemma side_embed (x : Position len) : side C (embed hle x)=C.side x := by
+  simp only [side,dite_eq_left (old_embed hle x),project_embed]
+lemma side_some_old {x : Position more} {e : E} (h : side C x=some e) : Old (len:=len) x := by
+  by_contra hn
+  simp only [side,dite_eq_right hn] at h
+  cases h
+lemma side_none (x : Position more) : side C x=none ↔ partner C hle x=x := by
+  by_cases h : Old (len:=len) x
+  · rw [←embed_project hle x h,side_embed,partner_embed]
+    exact (C.none_iff _).trans (embed_injective hle).eq_iff.symm
+  · simp only [side,dite_eq_right h,partner_new C hle x h]
+
+variable (hupper : ∀ e,C.hi e≤len (C.source e))
+include hupper in
+lemma side_iff (x : Position more) (e : E) :
+    side C x=some e ↔ x.1=C.source e ∧ x.2.val∈positions (C.lo e) (C.hi e) := by
+  constructor
+  · intro hx
+    have ho := side_some_old C hx
+    rw [side,dite_eq_left ho] at hx
+    exact (C.side_iff _ _).mp hx
+  · intro hx
+    have ho : Old (len:=len) x := by
+      apply mem_positions.mpr
+      have h1 := (mem_positions.mp x.2.property).1
+      have h2 := (mem_positions.mp hx.2).2
+      have h3 : C.hi e≤len x.1 := by simpa only [hx.1] using hupper e
+      exact ⟨h1,h2.trans_le h3⟩
+    rw [side,dite_eq_left ho]
+    exact (C.side_iff _ _).mpr hx
+
+lemma partner_side {x : Position more} {e : E} (hx : side C x=some e) :
+    side C (partner C hle x)=some (C.flip e) := by
+  have ho := side_some_old C hx
+  rw [←embed_project hle x ho,partner_embed,side_embed]
+  apply C.side_partner
+  rwa [←side_embed C hle,embed_project]
+lemma partner_source {x : Position more} {e : E} (hx : side C x=some e) :
+    (partner C hle x).1=C.source (C.flip e) := by
+  have ho := side_some_old C hx
+  rw [←embed_project hle x ho,partner_embed]
+  exact C.partner_source _ _ (by rwa [←side_embed C hle,embed_project])
+lemma partner_coordinate {x : Position more} {e : E} (hx : side C x=some e) :
+    (partner C hle x).2.val=affine (C.reverse e) (C.offset e) x.2.val := by
+  have ho := side_some_old C hx
+  have hx' : C.side (project x ho)=some e := by
+    simpa only [side,dite_eq_left ho] using hx
+  have he : partner C hle x=embed hle (C.pairing.partner (project x ho)) := dite_eq_left ho
+  rw [he]
+  exact C.partner_coordinate (project x ho) e hx' 
+include hle in
+lemma target_range (e : E) : if C.reverse e then
+    0≤(C.offset e:ℝ)-C.hi e ∧ (C.offset e:ℝ)-C.lo e ≤ more (C.source (C.flip e))
+    else 0≤C.lo e+(C.offset e:ℝ) ∧ C.hi e+(C.offset e:ℝ) ≤ more (C.source (C.flip e)) := by
+  have hh := C.target_range e
+  have hn : (len (C.source (C.flip e)):ℝ) ≤ more (C.source (C.flip e)) := by exact_mod_cast hle _
+  split_ifs at hh ⊢ <;> exact ⟨hh.1,hh.2.trans hn⟩
+
+def comparisons : Comparisons (E:=E) more where
+  pairing := ⟨partner C hle,partner_inv C hle⟩
+  side := side C
+  flip := C.flip
+  flip_inv := C.flip_inv
+  flip_ne := C.flip_ne
+  side_partner _ _ := partner_side C hle
+  none_iff := side_none C hle
+  source := C.source
+  lo := C.lo
+  hi := C.hi
+  reverse := C.reverse
+  offset := C.offset
+  side_iff := side_iff C hupper
+  partner_source _ _ := partner_source C hle
+  partner_coordinate _ _ := partner_coordinate C hle
+  target_range := target_range C hle
+
+variable [Fintype T]
+include hle in
+lemma old_card : (Finset.univ.filter (fun x : Position more => Old (len:=len) x)).card=
+    Fintype.card (Position len) := by
+  symm
+  rw [←Finset.card_univ]
+  apply Finset.card_bij (fun x _ => embed hle x)
+  · intro x _
+    exact Finset.mem_filter.mpr ⟨Finset.mem_univ _,old_embed hle x⟩
+  · intro x _ y _ h
+    exact embed_injective hle h
+  · intro x hx
+    have ho := (Finset.mem_filter.mp hx).2
+    exact ⟨project x ho,Finset.mem_univ _,embed_project hle x ho⟩
+lemma fixed_old_card : (Finset.univ.filter (fun x : Position more => Old (len:=len) x ∧ partner C hle x=x)).card=
+    (Finset.univ.filter (fun x : Position len => C.pairing.partner x=x)).card := by
+  symm
+  apply Finset.card_bij (fun x _ => embed hle x)
+  · intro x hx
+    refine Finset.mem_filter.mpr ⟨Finset.mem_univ _,old_embed hle x,?_⟩
+    rw [partner_embed,(Finset.mem_filter.mp hx).2]
+  · intro x _ y _ h
+    exact embed_injective hle h
+  · intro x hx
+    obtain ⟨ho,hf⟩ := (Finset.mem_filter.mp hx).2
+    refine ⟨project x ho,Finset.mem_filter.mpr ⟨Finset.mem_univ _,?_⟩,embed_project hle x ho⟩
+    apply embed_injective hle
+    rw [←partner_embed,embed_project,hf]
+lemma fixed_card : (Finset.univ.filter (fun x : Position more => partner C hle x=x)).card=
+    (Finset.univ.filter (fun x : Position len => C.pairing.partner x=x)).card+
+    (Finset.univ.filter (fun x : Position more => ¬Old (len:=len) x)).card := by
+  have he : (Finset.univ.filter (fun x : Position more => partner C hle x=x))=
+      (Finset.univ.filter (fun x : Position more => Old (len:=len) x ∧ partner C hle x=x))∪
+      (Finset.univ.filter (fun x : Position more => ¬Old (len:=len) x)) := by
+    ext x
+    simp only [Finset.mem_filter,Finset.mem_univ,true_and,Finset.mem_union]
+    by_cases h : Old (len:=len) x
+    · simp only [h,true_and,not_true_eq_false,or_false]
+    · simp only [h,false_and,not_false_eq_true,or_true,iff_true]
+      exact partner_new C hle x h
+  have hd : Disjoint (Finset.univ.filter (fun x : Position more => Old (len:=len) x ∧ partner C hle x=x))
+      (Finset.univ.filter (fun x : Position more => ¬Old (len:=len) x)) := by
+    apply Finset.disjoint_left.mpr
+    intro x hx hy
+    exact (Finset.mem_filter.mp hy).2 (Finset.mem_filter.mp hx).2.1
+  rw [he,Finset.card_union_of_disjoint hd,fixed_old_card]
+end TorsionFreeZeroDivisors.ExtendComparisons
+namespace TorsionFreeZeroDivisors.WordPositions
+
+section
+open scoped Classical BigOperators
+open BlockAlignment ComparedBlocks
+lemma bounds {n : ℕ} (q : {z // z∈positions 0 (n:ℝ)}) : 0≤q.val ∧ q.val<(n:ℤ) := by
+  simpa only [AffineIntervals.nat_positions,Finset.mem_Ico] using q.property
+variable {T : Type} (len : T → ℕ)
+def fin : Position len ≃ ((t : T) × Fin (len t)) where
+  toFun x := ⟨x.1,⟨x.2.val.toNat,by
+    have hx := bounds x.2
+    omega⟩⟩
+  invFun x := ⟨x.1,⟨x.2.val,by
+    simpa only [AffineIntervals.nat_positions,Finset.mem_Ico] using
+      (show (0:ℤ)≤x.2.val ∧ (x.2.val:ℤ)<len x.1 from ⟨by omega,by exact_mod_cast x.2.isLt⟩)⟩⟩
+  left_inv x := by
+    apply PlanarIntervals.position_ext
+    · rfl
+    · have hx := bounds x.2
+      dsimp only
+      omega
+  right_inv x := by
+    rcases x with ⟨t,i⟩
+    simp only [Int.toNat_natCast]
+lemma fin_val (x : Position len) : (fin len x).2.val=x.2.val.toNat := rfl
+lemma fin_symm_val (x : (t : T) × Fin (len t)) : ((fin len).symm x).2.val=x.2.val := rfl
+variable {A : Type} (w : T → List A)
+lemma dart_fin (x : (t : T) × Fin (w t).length) :
+    RawDecomposition.dart w ((fin (fun t=>(w t).length)).symm x)=(w x.1).get x.2 := by
+  change (w x.1).get ⟨(x.2.val:ℤ).toNat,_⟩=(w x.1).get x.2
+  congr 1
+lemma dart_prefix (v : T → List A) (x : Position (fun t=>(w t).length)) :
+    RawDecomposition.dart (fun t=>w t++v t)
+      (ExtendComparisons.embed (fun t=>by simp only [List.length_append]; omega) x)=
+    RawDecomposition.dart w x := by
+  dsimp only [RawDecomposition.dart,ExtendComparisons.embed]
+  simpa only [List.get_eq_getElem] using List.getElem_append_left
+    (show x.2.val.toNat<(w x.1).length from (fin _ x).2.isLt)
+
+variable (cap : ℕ) (hc : 0<cap)
+def joinFin : ((p : BalancedWords.Piece w cap) × Fin (BalancedWords.old w cap p)) ≃
+      ((t : T) × Fin (w t).length) :=
+  (Equiv.sigmaAssoc fun t i=>Fin (BalancedPieces.sizes (w t).length cap i)).trans
+    (Equiv.sigmaCongrRight fun t=>ConsecutivePieces.index (w t)
+      (BalancedPieces.sizes (w t).length cap) (BalancedPieces.sizes_sum hc))
+def join : Position (BalancedWords.old w cap) ≃ Position (fun t=>(w t).length) :=
+  (fin _).trans ((joinFin w cap hc).trans (fin _).symm)
+lemma join_first (x : Position (BalancedWords.old w cap)) : (join w cap hc x).1=x.1.1 := rfl
+lemma join_value (x : Position (BalancedWords.old w cap)) : (join w cap hc x).2.val=
+    (ConsecutivePieces.offset (BalancedPieces.sizes (w x.1.1).length cap) x.1.2:ℤ)+x.2.val := by
+  let q : Fin (BalancedPieces.sizes (w x.1.1).length cap x.1.2) :=
+    ⟨x.2.val.toNat,by
+      have hb := (fin _ x).2.isLt
+      exact hb⟩
+  change ((ConsecutivePieces.index (w x.1.1) (BalancedPieces.sizes (w x.1.1).length cap)
+    (BalancedPieces.sizes_sum hc) ⟨x.1.2,q⟩).val:ℤ)=_
+  rw [ConsecutivePieces.index_val,Nat.cast_add]
+  congr 1
+  exact Int.toNat_of_nonneg (bounds x.2).1
+
+def segments : Position (fun p=>(BalancedWords.segment w cap hc p).length) ≃
+    Position (fun t=>(w t).length) :=
+  (ComparisonGeometry.position (Equiv.refl _) (BalancedWords.segment_length w cap hc)).trans (join w cap hc)
+lemma segments_dart (x : Position (fun p=>(BalancedWords.segment w cap hc p).length)) :
+    RawDecomposition.dart (BalancedWords.segment w cap hc) x=
+      RawDecomposition.dart w (segments w cap hc x) := by
+  unfold RawDecomposition.dart
+  simp only [BalancedWords.segment,ConsecutivePieces.segment,List.get_eq_getElem,List.getElem_ofFn,
+    Fin.getElem_fin]
+  congr 1
+end
+open scoped Classical BigOperators
+open BlockAlignment ComparedBlocks
+variable {T : Type} [Fintype T] (len : T → ℕ)
+lemma cardinal : Fintype.card (Position len)=∑t,len t := by
+  rw [Fintype.card_congr (fin len),Fintype.card_sigma]
+  simp only [Fintype.card_fin]
+variable {A : Type} (w v : T → List A)
+abbrev prefix_bound (t : T) : (w t).length≤(w t++v t).length := by
+  simp only [List.length_append]
+  omega
+lemma new_card : (Finset.univ.filter (fun x : Position (fun t=>(w t++v t).length)=>
+    ¬ExtendComparisons.Old (len:=fun t=>(w t).length) x)).card=∑t,(v t).length := by
+  have hp := Finset.card_filter_add_card_filter_not
+    (s:=Finset.univ (α:=Position (fun t=>(w t++v t).length)))
+    (p:=fun x=>ExtendComparisons.Old (len:=fun t=>(w t).length) x)
+  have ho := ExtendComparisons.old_card (prefix_bound w v)
+  rw [ho,Finset.card_univ,cardinal,cardinal] at hp
+  simp only [List.length_append,Finset.sum_add_distrib] at hp
+  omega
+variable {E : Type} (C : Comparisons (E:=E) (fun t=>(w t).length))
+lemma fixed_card (hfull : ∀ x,C.pairing.partner x≠x) :
+    (Finset.univ.filter (fun x=>ExtendComparisons.partner C (prefix_bound w v) x=x)).card=
+      ∑t,(v t).length := by
+  rw [ExtendComparisons.fixed_card,new_card]
+  have he : (Finset.univ.filter (fun x=>C.pairing.partner x=x))=∅ := by
+    ext x
+    simp only [Finset.mem_filter,Finset.mem_univ,true_and,Finset.notMem_empty,iff_false]
+    exact hfull x
+  rw [he,Finset.card_empty,Nat.zero_add]
+omit [Fintype T] in
+lemma nonfixed_old (p : Position (fun t=>(w t++v t).length))
+    (hp : ExtendComparisons.partner C (prefix_bound w v) p≠p) :
+    p.2.val∈positions 0 (w p.1).length := by
+  by_contra hn
+  exact hp (ExtendComparisons.partner_new C (prefix_bound w v) p hn)
+end TorsionFreeZeroDivisors.WordPositions
+
+namespace TorsionFreeZeroDivisors.SampleGraph.ClosedWords
+open scoped Classical BigOperators
+open GirthAsymptotics ActualPatternEvent TypedGraphs WeightedMoore BlockAlignment ComparedBlocks
+variable {rep : ℕ} {r : Match rep} {x : VA rep} {y : VB rep}
+    (s : PathSystem rep r x y) (cap : ℕ) (hc : 0<cap)
+    (hL : 1≤L (size rep)) (hd : GraphSample.Diameters rep r)
+    {E : Type} [Fintype E]
+    (C : Comparisons (E:=E) (fun p=>(seg s cap hc p).length))
+    (lo hi : E → ℕ) (hlo : ∀ e,C.lo e=lo e) (hhi : ∀ e,C.hi e=hi e)
+    (hle : ∀ e,lo e≤hi e) (hh : ∀ e,hi e≤(seg s cap hc (C.source e)).length)
+    (hred : ∀ p e,C.side p=some e →
+      RawDecomposition.dart (seg s cap hc) p≠RawDecomposition.dart (seg s cap hc) (C.pairing.partner p) ∧
+      RawDecomposition.dart (seg s cap hc) p≠(graph rep r).reverse (RawDecomposition.dart (seg s cap hc) (C.pairing.partner p)))
+    (hcomp : ∀ p e,C.side p=some e → label rep (RawDecomposition.dart (seg s cap hc) p)=
+      if C.reverse e then Types.inverse (label rep (RawDecomposition.dart (seg s cap hc) (C.pairing.partner p)))
+      else label rep (RawDecomposition.dart (seg s cap hc) (C.pairing.partner p)))
+abbrev grow := WordPositions.prefix_bound (seg s cap hc) (tail s cap hc hL hd)
+include hhi hh in
+omit [Fintype E] in
+lemma upper_real (e : E) : C.hi e≤((seg s cap hc (C.source e)).length:ℝ) := by
+  rw [hhi]
+  exact_mod_cast hh e
+
+/-- Appending the actual short closures changes neither original comparison nor
+its underlying graph lifts. Every newly added position is unpaired. -/
+def system : PathSystem rep r x y where
+  P := Piece s cap
+  E := E
+  fP := inferInstance
+  fE := inferInstance
+  paths := word s cap hc hL hd
+  nonempty := nonempty s cap hc hL hd
+  root := root s cap hc
+  path_chain := chain s cap hc hL hd
+  cyclic_chain := cyclic s cap hc hL hd
+  comparisons := ExtendComparisons.comparisons C (grow s cap hc hL hd) (upper_real s cap hc C hi hhi hh)
+  lower := lo
+  upper := hi
+  lower_eq := hlo
+  upper_eq := hhi
+  lower_le := hle
+  upper_le e := (hh e).trans (grow s cap hc hL hd _)
+  reduced := by
+    intro p e he
+    have hp := ExtendComparisons.side_some_old C he
+    have he' : C.side (ExtendComparisons.project p hp)=some e := by
+      simpa only [ExtendComparisons.comparisons,ExtendComparisons.side,dite_eq_left hp] using he
+    have hg := hred (ExtendComparisons.project p hp) e he'
+    rw [←ExtendComparisons.embed_project (grow s cap hc hL hd) p hp]
+    change RawDecomposition.dart (fun p=>seg s cap hc p++tail s cap hc hL hd p) _≠
+      RawDecomposition.dart _ (ExtendComparisons.partner C (grow s cap hc hL hd) _) ∧
+      RawDecomposition.dart (fun p=>seg s cap hc p++tail s cap hc hL hd p) _ ≠(graph rep r).reverse (RawDecomposition.dart _ (ExtendComparisons.partner C (grow s cap hc hL hd) _))
+    rw [ExtendComparisons.partner_embed]
+    simpa only [word,WordPositions.dart_prefix] using hg
+  rootA := rootA s cap hc hL hd
+  rootB := rootB s cap hc hL hd
+  compatible := by
+    intro p e he
+    have hp := ExtendComparisons.side_some_old C he
+    have he' : C.side (ExtendComparisons.project p hp)=some e := by
+      simpa only [ExtendComparisons.comparisons,ExtendComparisons.side,dite_eq_left hp] using he
+    have hg := hcomp (ExtendComparisons.project p hp) e he'
+    rw [←ExtendComparisons.embed_project (grow s cap hc hL hd) p hp]
+    change label rep (RawDecomposition.dart (fun p=>seg s cap hc p++tail s cap hc hL hd p) _)=
+      if C.reverse e then Types.inverse (label rep (RawDecomposition.dart _ (ExtendComparisons.partner C (grow s cap hc hL hd) _)))
+      else label rep (RawDecomposition.dart _ (ExtendComparisons.partner C (grow s cap hc hL hd) _))
+    rw [ExtendComparisons.partner_embed]
+    simpa only [word,WordPositions.dart_prefix] using hg
+end TorsionFreeZeroDivisors.SampleGraph.ClosedWords
+
+namespace TorsionFreeZeroDivisors.BoundaryRotation
+
+section
+open scoped Classical BigOperators
+open BlockAlignment ComparedBlocks WordPositions PermutationCycles
+variable {T : Type} (len : T → ℕ)
+def perm : Equiv.Perm (Position len) :=
+  (fin len).symm.permCongr (Equiv.sigmaCongrRight fun t=>finRotate (len t))
+lemma apply_fin (t : T) (i : Fin (len t)) :
+    perm len ((fin len).symm ⟨t,i⟩)=(fin len).symm ⟨t,finRotate (len t) i⟩ := by
+  simp only [perm,Equiv.permCongr_apply,Equiv.symm_symm,Equiv.apply_symm_apply,
+    Equiv.sigmaCongrRight_apply]
+lemma pow_fin (t : T) (i : Fin (len t)) (n : ℕ) :
+    (perm len^n) ((fin len).symm ⟨t,i⟩)=(fin len).symm ⟨t,(finRotate (len t)^n) i⟩ := by
+  induction n with
+  | zero => rfl
+  | succ n ih => rw [pow_succ',Equiv.Perm.mul_apply,ih,apply_fin,pow_succ',Equiv.Perm.mul_apply]
+lemma first (x : Position len) : (perm len x).1=x.1 := by
+  rw [←(fin len).symm_apply_apply x]
+  exact rfl
+lemma finRotate_same {n : ℕ} (i j : Fin n) : (finRotate n).SameCycle i j := by
+  by_cases hn : 2≤n
+  · apply Equiv.Perm.IsCycle.sameCycle (isCycle_finRotate_of_le hn)
+    · have hm : i∈(finRotate n).support := by rw [support_finRotate_of_le hn]; exact Finset.mem_univ _
+      exact Equiv.Perm.mem_support.mp hm
+    · have hm : j∈(finRotate n).support := by rw [support_finRotate_of_le hn]; exact Finset.mem_univ _
+      exact Equiv.Perm.mem_support.mp hm
+  · have he : i=j := by apply Fin.ext; omega
+    exact he.sameCycle _
+lemma same_first {x y : Position len} (h : x.1=y.1) : (perm len).SameCycle x y := by
+  rcases x with ⟨a',i'⟩
+  rcases y with ⟨b',j'⟩
+  dsimp at h
+  subst b'
+  let u : Fin (len a') := ⟨i'.val.toNat,by have hb:=bounds i'; omega⟩
+  let v : Fin (len a') := ⟨j'.val.toNat,by have hb:=bounds j'; omega⟩
+  obtain ⟨n,hn⟩ := (finRotate_same u v).exists_nat_pow_eq
+  refine ⟨(n:ℤ),?_⟩
+  rw [zpow_natCast]
+  have hh := pow_fin len a' u n
+  rw [hn] at hh
+  change (perm len^n) ((fin len).symm (fin len ⟨a',i'⟩))=(fin len).symm (fin len ⟨a',j'⟩) at hh
+  simpa only [Equiv.symm_apply_apply] using hh
+lemma next {x : Position len} (hx : x.2.val+1<(len x.1:ℤ)) :
+    (perm len x).2.val=x.2.val+1 := by
+  let i : Fin (len x.1) := ⟨x.2.val.toNat,by have hb:=bounds x.2; omega⟩
+  have he := apply_fin len x.1 i
+  change perm len ((fin len).symm (fin len x))=(fin len).symm ⟨x.1,finRotate (len x.1) i⟩ at he
+  rw [Equiv.symm_apply_apply] at he
+  rw [he]
+  change ((finRotate (len x.1) i).val:ℤ)=x.2.val+1
+  have hb := bounds x.2
+  have hp : 0<len x.1 := by omega
+  obtain ⟨n,hn⟩ := Nat.exists_eq_succ_of_ne_zero (by omega : len x.1≠0)
+  have hc : ∀ i : Fin (len x.1),i.val+1<len x.1 → (finRotate (len x.1) i).val=i.val+1 := by
+    rw [hn]
+    intro i hi
+    apply coe_finRotate_of_ne_last
+    intro he
+    rw [he,Fin.val_last] at hi
+    omega
+  rw [hc _ (by change x.2.val.toNat+1<len x.1; omega)]
+  change ((x.2.val.toNat+1:ℕ):ℤ)=x.2.val+1
+  push_cast
+  rw [Int.toNat_of_nonneg hb.1]
+variable [Fintype T]
+lemma cycles_le : Fintype.card (Cycle (perm len))≤Fintype.card T := by
+  let f : Cycle (perm len) → T := fun c=>(Quotient.out c).1
+  have hi : Function.Injective f := by
+    intro c d h
+    have hh := same_first len h
+    have he := (cycle_eq (perm len)).mpr hh
+    simpa only [cycle,Quotient.out_eq] using he
+  exact Fintype.card_le_of_injective f hi
+
+def ends : Finset (Position len) := Finset.univ.filter (fun x=>x.2.val+1=len x.1)
+lemma ends_le : (ends len).card≤Fintype.card T := by
+  let f : {x // x∈ends len} → T := fun x=>x.val.1
+  have hi : Function.Injective f := by
+    intro x y h
+    apply Subtype.ext
+    apply PlanarIntervals.position_ext h
+    have hx := (Finset.mem_filter.mp x.property).2
+    have hy := (Finset.mem_filter.mp y.property).2
+    change x.val.1=y.val.1 at h
+    have hh := congrArg (fun t=>(len t:ℤ)) h
+    omega
+  simpa only [Fintype.card_coe] using Fintype.card_le_of_injective f hi
+lemma hits (x : Position len) : ∃ y∈ends len,(perm len).SameCycle x y := by
+  have hb := bounds x.2
+  let j : Fin (len x.1) := ⟨len x.1-1,by omega⟩
+  refine ⟨(fin len).symm ⟨x.1,j⟩,?_,same_first len rfl⟩
+  apply Finset.mem_filter.mpr
+  refine ⟨Finset.mem_univ _,?_⟩
+  change ((len x.1-1:ℕ):ℤ)+1=len x.1
+  omega
+end
+
+section
+open scoped Classical BigOperators
+open BlockAlignment ComparedBlocks WordPositions PermutationCycles
+variable {T A : Type} [Fintype T] (len : T → ℕ) (root : Option T)
+    (label : Position len → A) (bar : A → A) (α : Equiv.Perm (Position len))
+    (hr : Function.Involutive α)
+    (hcomp : ∀ x,label (α x)=bar (label x))
+    (hred : ∀ x,root≠some x.1 ∨ x∉ends len → label (perm len x)≠bar (label x))
+include hr hcomp hred in
+lemma fixed_root_end {x : Position len} (hx : PlanarRotation.opposite (perm len) α x=x) :
+    root=some x.1 ∧ x∈ends len := by
+  have he : perm len x=α x := by
+    have hh := congrArg α hx
+    change α (α (perm len x))=α x at hh
+    rwa [hr] at hh
+  have hl : label (perm len x)=bar (label x) := he ▸ hcomp x
+  constructor
+  · by_contra hn
+    exact hred x (Or.inl hn) hl
+  · by_contra hn
+    exact hred x (Or.inr hn) hl
+include hr hcomp hred in
+lemma monogons_le : (fixed (PlanarRotation.opposite (perm len) α)).card≤1 := by
+  apply Finset.card_le_one.mpr
+  intro x hx y hy
+  simp only [fixed,Finset.mem_filter,Finset.mem_univ,true_and] at hx hy
+  have hx := fixed_root_end len root label bar α hr hcomp hred hx
+  have hy := fixed_root_end len root label bar α hr hcomp hred hy
+  have hs : x.1=y.1 := Option.some.inj (hx.1.symm.trans hy.1)
+  apply PlanarIntervals.position_ext hs
+  have hx' := (Finset.mem_filter.mp hx.2).2
+  have hy' := (Finset.mem_filter.mp hy.2).2
+  have hh := congrArg (fun t=>(len t:ℤ)) hs
+  omega
+end
+
+open scoped Classical BigOperators
+open BlockAlignment ComparedBlocks WordPositions
+variable {T : Type} (len : T → ℕ)
+lemma last_next {x : Position len} (hx : x.2.val+1=(len x.1:ℤ)) : (perm len x).2.val=0 := by
+  have hb := bounds x.2
+  let i : Fin (len x.1) := ⟨x.2.val.toNat,by omega⟩
+  have he := apply_fin len x.1 i
+  change perm len ((fin len).symm (fin len x))=(fin len).symm ⟨x.1,finRotate (len x.1) i⟩ at he
+  rw [Equiv.symm_apply_apply] at he
+  rw [he]
+  change ((finRotate (len x.1) i).val:ℤ)=0
+  have hn : len x.1≠0 := by omega
+  obtain ⟨n,hn⟩ := Nat.exists_eq_succ_of_ne_zero hn
+  have hc : ∀ j : Fin (len x.1),j.val+1=len x.1 → (finRotate (len x.1) j).val=0 := by
+    rw [hn]
+    intro j hj
+    have he : j=Fin.last n := by apply Fin.ext; simp only [Fin.val_last]; omega
+    rw [he,finRotate_last]
+    rfl
+  rw [hc _ (by dsimp only [i]; omega)]
+  rfl
+variable {A : Type} (w : T → List A) (R : A → A → Prop)
+lemma step_nonlast (hc : ∀t,(w t).IsChain R) (x : Position (fun t=>(w t).length))
+    (hx : x.2.val+1<(w x.1).length) :
+    R (RawDecomposition.dart w x) (RawDecomposition.dart w (perm (fun t=>(w t).length) x)) := by
+  have hb := bounds x.2
+  have hh := next (fun t=>(w t).length) hx
+  have hi : x.2.val.toNat+1<(w x.1).length := by omega
+  have hn : (perm (fun t=>(w t).length) x).2.val.toNat=x.2.val.toNat+1 := by omega
+  have hc := (List.isChain_iff_getElem.mp (hc x.1)) x.2.val.toNat hi
+  change R (w x.1)[x.2.val.toNat] (w x.1)[(perm (fun t=>(w t).length) x).2.val.toNat]
+  simpa only [hn] using hc
+lemma step_last (hne : ∀t,w t≠[]) (x : Position (fun t=>(w t).length))
+    (hx : x.2.val+1=(w x.1).length)
+    (hcyc : ∀ᵉ (a∈(w x.1).getLast?) (b∈(w x.1).head?),R a b) :
+    R (RawDecomposition.dart w x) (RawDecomposition.dart w (perm (fun t=>(w t).length) x)) := by
+  have hb := bounds x.2
+  have hn : x.2.val.toNat=(w x.1).length-1 := by omega
+  have hh := last_next (fun t=>(w t).length) hx
+  have hc := hcyc ((w x.1).getLast (hne x.1)) (List.getLast_mem_getLast? (hne x.1))
+    ((w x.1).head (hne x.1)) (List.head_mem_head? (hne x.1))
+  change R (w x.1)[x.2.val.toNat] (w x.1)[(perm (fun t=>(w t).length) x).2.val.toNat]
+  simpa only [hn,hh,List.getLast_eq_getElem,List.head_eq_getElem,Int.toNat_zero] using hc
+end TorsionFreeZeroDivisors.BoundaryRotation
+
+namespace TorsionFreeZeroDivisors.SampleGraph.PathSystem
+open scoped Classical BigOperators
+open BlockAlignment ComparedBlocks WordPositions BoundaryRotation WeightedMoore ActualPatternEvent GirthAsymptotics
+variable {rep : ℕ} {r : Match rep} {x : VA rep} {y : VB rep} (s : PathSystem rep r x y)
+lemma step_label {d e : DA rep⊕DB rep}
+    (h : PortWalk.step (graph rep r).origin (graph rep r).reverse d e) :
+    label rep e≠Types.inverse (label rep d) := by
+  intro he
+  exact h.2 (immersed rep r e ((graph rep r).reverse d) h.1.symm
+    (he.trans (label_reverse rep r d).symm))
+lemma boundary_reduced (p : Position (fun t=>(s.paths t).length))
+    (hp : s.root≠some p.1 ∨ p∉BoundaryRotation.ends (fun t=>(s.paths t).length)) :
+    label rep (RawDecomposition.dart s.paths (perm (fun t=>(s.paths t).length) p))≠
+      Types.inverse (label rep (RawDecomposition.dart s.paths p)) := by
+  have hb : 0≤p.2.val ∧ p.2.val<((s.paths p.1).length:ℤ) := bounds p.2
+  apply step_label
+  by_cases hl : p.2.val+1=(s.paths p.1).length
+  · apply step_last s.paths _ s.nonempty p hl
+    apply s.cyclic_chain p.1
+    apply (ClosedWords.cyclic_iff _ _).mpr
+    rcases hp with hp|hp
+    · exact hp
+    · exact False.elim (hp (Finset.mem_filter.mpr ⟨Finset.mem_univ _,hl⟩))
+  · exact step_nonlast s.paths _ s.path_chain p (by omega)
+end TorsionFreeZeroDivisors.SampleGraph.PathSystem
+
+namespace TorsionFreeZeroDivisors.PermutationTransport
+variable {A B : Type} (e : A ≃ B) (f : Equiv.Perm A)
+lemma pow_apply (x : A) (n : ℕ) : (e.permCongr f^n) (e x)=e ((f^n) x) := by
+  induction n with
+  | zero => rfl
+  | succ n ih => simp only [pow_succ',Equiv.Perm.mul_apply,ih,Equiv.permCongr_apply,Equiv.symm_apply_apply]
+lemma sameCycle [Finite A] {x y : A} (h : f.SameCycle x y) : (e.permCongr f).SameCycle (e x) (e y) := by
+  obtain ⟨n,hn⟩ := h.exists_nat_pow_eq
+  exact ⟨(n:ℤ),by rw [zpow_natCast,pow_apply,hn]⟩
+lemma involutive (h : Function.Involutive f) : Function.Involutive (e.permCongr f) := by
+  intro x
+  simp only [Equiv.permCongr_apply,Equiv.symm_apply_apply]
+  rw [h,Equiv.apply_symm_apply]
+lemma fixed_free (h : ∀x,f x≠x) (x : B) : e.permCongr f x≠x := by
+  intro he
+  apply h (e.symm x)
+  simpa only [Equiv.permCongr_apply,Equiv.symm_apply_apply] using congrArg e.symm he
+lemma mul (g : Equiv.Perm A) : e.permCongr (f*g)=e.permCongr f*e.permCongr g := by
+  ext x
+  simp only [Equiv.Perm.mul_apply,Equiv.permCongr_apply,Equiv.symm_apply_apply]
+end TorsionFreeZeroDivisors.PermutationTransport
+
+namespace TorsionFreeZeroDivisors.BalancedRotation
+open scoped Classical BigOperators
+open BlockAlignment ComparedBlocks WordPositions PermutationCycles
+variable {T A : Type} [Fintype T] (w : T → List A) (cap : ℕ) (hc : 0<cap)
+abbrev len (p : BalancedWords.Piece w cap) := (BalancedWords.segment w cap hc p).length
+abbrev e := WordPositions.segments w cap hc
+omit [Fintype T] in
+lemma source (x : Position (len w cap hc)) : (e w cap hc x).1=x.1.1 := rfl
+omit [Fintype T] in
+lemma value (x : Position (len w cap hc)) : (e w cap hc x).2.val=
+    (ConsecutivePieces.offset (BalancedPieces.sizes (w x.1.1).length cap) x.1.2:ℤ)+x.2.val :=
+  WordPositions.join_value w cap hc (ComparisonGeometry.position (Equiv.refl _) (BalancedWords.segment_length w cap hc) x)
+def perm : Equiv.Perm (Position (len w cap hc)) :=
+  (e w cap hc).symm.permCongr (BoundaryRotation.perm (fun t=>(w t).length))
+omit [Fintype T] in
+lemma transport (x : Position (len w cap hc)) :
+    e w cap hc (perm w cap hc x)=BoundaryRotation.perm (fun t=>(w t).length) (e w cap hc x) := by
+  simp only [perm,Equiv.permCongr_apply,Equiv.symm_symm,Equiv.apply_symm_apply]
+lemma same_source {x y : Position (len w cap hc)} (h : x.1.1=y.1.1) : (perm w cap hc).SameCycle x y := by
+  have hh := BoundaryRotation.same_first (fun t=>(w t).length) (x:=e w cap hc x) (y:=e w cap hc y) h
+  have hp := PermutationTransport.sameCycle (e w cap hc).symm _ hh
+  change ((e w cap hc).symm.permCongr (BoundaryRotation.perm (fun t=>(w t).length))).SameCycle x y
+  simpa only [Equiv.symm_apply_apply] using hp
+omit [Fintype T] in
+lemma step {x : Position (len w cap hc)} (hx : x.2.val+1<(len w cap hc x.1:ℤ)) :
+    (perm w cap hc x).1=x.1 ∧ (perm w cap hc x).2.val=x.2.val+1 := by
+  have hb := bounds x.2
+  let y : Position (len w cap hc) := ⟨x.1,⟨x.2.val+1,by
+    simp only [AffineIntervals.nat_positions,Finset.mem_Ico]
+    exact ⟨by omega,hx⟩⟩⟩
+  have hy := bounds (e w cap hc y).2
+  have hxe := value w cap hc x
+  have hye := value w cap hc y
+  dsimp only [y] at hye
+  have ht : (e w cap hc x).2.val+1<((w (e w cap hc x).1).length:ℤ) := by
+    have hy2 := hy.2
+    change (e w cap hc y).2.val<((w x.1.1).length:ℤ) at hy2
+    change (e w cap hc y).2.val=_+ (x.2.val+1) at hye
+    change (e w cap hc x).2.val+1<((w x.1.1).length:ℤ)
+    omega
+  have he : e w cap hc (perm w cap hc x)=e w cap hc y := by
+    rw [transport]
+    apply PlanarIntervals.position_ext
+    · exact BoundaryRotation.first _ _
+    · rw [BoundaryRotation.next _ ht,hxe,hye]
+      omega
+  have he := (e w cap hc).injective he
+  rw [he]
+  exact ⟨rfl,rfl⟩
+lemma hits (x : Position (len w cap hc)) :
+    ∃ y∈BoundaryRotation.ends (len w cap hc),(perm w cap hc).SameCycle x y := by
+  have hb := bounds x.2
+  let j : Fin (len w cap hc x.1) := ⟨len w cap hc x.1-1,by omega⟩
+  let y := (fin (len w cap hc)).symm ⟨x.1,j⟩
+  refine ⟨y,?_,same_source w cap hc rfl⟩
+  apply Finset.mem_filter.mpr
+  refine ⟨Finset.mem_univ _,?_⟩
+  change ((len w cap hc x.1-1:ℕ):ℤ)+1=len w cap hc x.1
+  omega
+lemma cycles_le : Fintype.card (Cycle (perm w cap hc))≤Fintype.card (BalancedWords.Piece w cap) := by
+  have hT : Fintype.card (Cycle (perm w cap hc))≤Fintype.card T := by
+    let f : Cycle (perm w cap hc) → T := fun c=>(Quotient.out c).1.1
+    have hf : Function.Injective f := by
+      intro c d hd
+      have hh := same_source w cap hc hd
+      have he := (cycle_eq (perm w cap hc)).mpr hh
+      simpa only [cycle,Quotient.out_eq] using he
+    exact Fintype.card_le_of_injective f hf
+  apply hT.trans
+  let f : T → BalancedWords.Piece w cap := fun t=>⟨t,⟨0,BalancedPieces.number_pos hc⟩⟩
+  exact Fintype.card_le_of_injective f (fun _ _ h=>congrArg Sigma.fst h)
+end TorsionFreeZeroDivisors.BalancedRotation
+
+namespace TorsionFreeZeroDivisors.SampleGraph
+open scoped Classical BigOperators
+open BlockAlignment ComparedBlocks GirthAsymptotics ActualPatternEvent
+variable {rep : ℕ} {r : Match rep} {x : VA rep} {y : VB rep}
+/-- The full inverse-letter pairing of the original boundary words, retaining
+actual graph lifts. Planarity is additional data, not asserted here. -/
+structure FullPairing (s : PathSystem rep r x y) where
+  perm : Equiv.Perm (Position (fun t=>(s.paths t).length))
+  involutive : Function.Involutive perm
+  fixed_free : ∀p,perm p≠p
+  compatible : ∀p,label rep (RawDecomposition.dart s.paths (perm p))=
+    Types.inverse (label rep (RawDecomposition.dart s.paths p))
+  reduced : ∀p,RawDecomposition.dart s.paths p≠RawDecomposition.dart s.paths (perm p) ∧
+    RawDecomposition.dart s.paths p≠(graph rep r).reverse (RawDecomposition.dart s.paths (perm p))
+namespace FullPairing
+variable {s : PathSystem rep r x y} (a : FullPairing s) (cap : ℕ) (hc : 0<cap)
+def α : Equiv.Perm (Position (BalancedRotation.len s.paths cap hc)) := (BalancedRotation.e s.paths cap hc).symm.permCongr a.perm
+lemma α_involutive : Function.Involutive (a.α cap hc) :=
+  PermutationTransport.involutive (BalancedRotation.e s.paths cap hc).symm a.perm a.involutive
+lemma α_fixed_free (p : Position (BalancedRotation.len s.paths cap hc)) : a.α cap hc p≠p :=
+  PermutationTransport.fixed_free (BalancedRotation.e s.paths cap hc).symm a.perm a.fixed_free p
+lemma transport (p : Position (BalancedRotation.len s.paths cap hc)) : BalancedRotation.e s.paths cap hc (a.α cap hc p)=a.perm (BalancedRotation.e s.paths cap hc p) := by
+  simp only [α,Equiv.permCongr_apply,Equiv.symm_symm,Equiv.apply_symm_apply]
+def cuts : PlanarRuns.CutSystem (BalancedRotation.perm s.paths cap hc) :=
+  PlanarRuns.CutSystem.ofMarks (a.α cap hc) (BoundaryRotation.ends (BalancedRotation.len s.paths cap hc))
+    (BalancedRotation.hits s.paths cap hc)
+theorem paired : (a.cuts cap hc).Paired (a.α cap hc) :=
+  PlanarRuns.CutSystem.ofMarks_paired (a.α cap hc) (BoundaryRotation.ends (BalancedRotation.len s.paths cap hc))
+    (BalancedRotation.hits s.paths cap hc) (a.α_involutive cap hc) (a.α_fixed_free cap hc)
+lemma step (p : Position (BalancedRotation.len s.paths cap hc)) (hp : p∉(a.cuts cap hc).cut) :
+    (BalancedRotation.perm s.paths cap hc p).1=p.1 ∧ (BalancedRotation.perm s.paths cap hc p).2.val=p.2.val+1 := by
+  apply BalancedRotation.step
+  have hb := WordPositions.bounds p.2
+  have hn : p∉BoundaryRotation.ends (BalancedRotation.len s.paths cap hc) := by
+    intro hm
+    apply hp
+    simp only [cuts,PlanarRuns.CutSystem.ofMarks,PlanarRotation.cuts,Finset.mem_union]
+    exact Or.inl (Or.inr hm)
+  have hn : p.2.val+1≠(BalancedRotation.len s.paths cap hc p.1:ℤ) := by
+    intro he
+    exact hn (Finset.mem_filter.mpr ⟨Finset.mem_univ _,he⟩)
+  omega
+abbrev Side := {p // p∈(a.cuts cap hc).cut}
+def comparisons : Comparisons (E:=a.Side cap hc) (BalancedRotation.len s.paths cap hc) :=
+  PlanarIntervals.comparisons (a.cuts cap hc) (a.paired cap hc) (a.step cap hc)
+def lower (d : a.Side cap hc) : ℕ := (PlanarIntervals.lower (a.cuts cap hc) (a.paired cap hc) d).toNat
+def upper (d : a.Side cap hc) : ℕ := (PlanarIntervals.upper (a.cuts cap hc) d).toNat
+lemma bounds (d : a.Side cap hc) :
+    0≤PlanarIntervals.lower (a.cuts cap hc) (a.paired cap hc) d ∧
+    PlanarIntervals.lower (a.cuts cap hc) (a.paired cap hc) d<PlanarIntervals.upper (a.cuts cap hc) d ∧
+    PlanarIntervals.upper (a.cuts cap hc) d≤BalancedRotation.len s.paths cap hc ((a.paired cap hc).first d).1 :=
+  PlanarIntervals.bounds (a.cuts cap hc) (a.paired cap hc) (a.step cap hc) d
+lemma lower_eq (d : a.Side cap hc) : (a.comparisons cap hc).lo d=a.lower cap hc d := by
+  change (PlanarIntervals.lower (a.cuts cap hc) (a.paired cap hc) d:ℝ)=_
+  rw [lower,←Int.cast_natCast,Int.toNat_of_nonneg (a.bounds cap hc d).1]
+lemma upper_eq (d : a.Side cap hc) : (a.comparisons cap hc).hi d=a.upper cap hc d := by
+  change (PlanarIntervals.upper (a.cuts cap hc) d:ℝ)=_
+  rw [upper,←Int.cast_natCast,Int.toNat_of_nonneg (by have := a.bounds cap hc d; omega)]
+lemma lower_le (d : a.Side cap hc) : a.lower cap hc d≤a.upper cap hc d := by
+  have := a.bounds cap hc d
+  dsimp only [lower,upper]
+  omega
+lemma upper_le (d : a.Side cap hc) : a.upper cap hc d≤BalancedRotation.len s.paths cap hc ((a.comparisons cap hc).source d) := by
+  exact Int.toNat_le.mpr (a.bounds cap hc d).2.2
+lemma dart (p : Position (BalancedRotation.len s.paths cap hc)) : RawDecomposition.dart (ClosedWords.seg s cap hc) p=
+    RawDecomposition.dart s.paths (BalancedRotation.e s.paths cap hc p) := WordPositions.segments_dart s.paths cap hc p
+lemma balanced_reduced (p : Position (BalancedRotation.len s.paths cap hc)) :
+    RawDecomposition.dart (ClosedWords.seg s cap hc) p≠RawDecomposition.dart (ClosedWords.seg s cap hc) (a.α cap hc p) ∧
+    RawDecomposition.dart (ClosedWords.seg s cap hc) p≠(graph rep r).reverse (RawDecomposition.dart (ClosedWords.seg s cap hc) (a.α cap hc p)) := by
+  rw [dart cap hc,dart cap hc,a.transport]
+  exact a.reduced (BalancedRotation.e s.paths cap hc p)
+lemma balanced_compatible (p : Position (BalancedRotation.len s.paths cap hc)) :
+    label rep (RawDecomposition.dart (ClosedWords.seg s cap hc) p)=
+      Types.inverse (label rep (RawDecomposition.dart (ClosedWords.seg s cap hc) (a.α cap hc p))) := by
+  rw [dart cap hc,dart cap hc,a.transport,a.compatible,Types.inverse_inverse]
+end FullPairing
+end TorsionFreeZeroDivisors.SampleGraph
+
+namespace TorsionFreeZeroDivisors.PermutationTransport
+open PermutationCycles
+variable {A B : Type} [Fintype A] [Fintype B] (e : A ≃ B) (f : Equiv.Perm A)
+lemma sameCycle_iff (x y : A) : f.SameCycle x y ↔ (e.permCongr f).SameCycle (e x) (e y) := by
+  refine ⟨sameCycle e f,?_⟩
+  intro h
+  obtain ⟨n,hn⟩ := h.exists_nat_pow_eq
+  refine ⟨(n:ℤ),?_⟩
+  rw [zpow_natCast]
+  apply e.injective
+  rwa [pow_apply] at hn
+def cycles : Cycle f ≃ Cycle (e.permCongr f) := Quotient.congr e (sameCycle_iff e f)
+lemma card_cycles : Fintype.card (Cycle (e.permCongr f))=Fintype.card (Cycle f) :=
+  (Fintype.card_congr (cycles e f)).symm
+end TorsionFreeZeroDivisors.PermutationTransport
+
+namespace TorsionFreeZeroDivisors.SampleGraph.FullPairing
+
+section
+open scoped Classical BigOperators
+open BlockAlignment ComparedBlocks GirthAsymptotics ActualPatternEvent PermutationCycles PlanarRotation
+variable {rep : ℕ} {r : Match rep} {x : VA rep} {y : VB rep}
+    {s : PathSystem rep r x y} (a : FullPairing s) (cap : ℕ) (hc : 0<cap)
+lemma opposite_eq : opposite (BalancedRotation.perm s.paths cap hc) (a.α cap hc)=
+    (BalancedRotation.e s.paths cap hc).symm.permCongr
+      (opposite (BoundaryRotation.perm (fun t=>(s.paths t).length)) a.perm) := by
+  exact (PermutationTransport.mul (BalancedRotation.e s.paths cap hc).symm a.perm _).symm
+lemma opposite_transport (p : Position (BalancedRotation.len s.paths cap hc)) :
+    BalancedRotation.e s.paths cap hc (opposite (BalancedRotation.perm s.paths cap hc) (a.α cap hc) p)=
+      opposite (BoundaryRotation.perm (fun t=>(s.paths t).length)) a.perm (BalancedRotation.e s.paths cap hc p) := by
+  change BalancedRotation.e s.paths cap hc (a.α cap hc (BalancedRotation.perm s.paths cap hc p))=_
+  rw [a.transport,BalancedRotation.transport]
+  rfl
+lemma monogons : (fixed (opposite (BalancedRotation.perm s.paths cap hc) (a.α cap hc))).card≤1 := by
+  have ho := BoundaryRotation.monogons_le (fun t=>(s.paths t).length) s.root
+    (fun p=>label rep (RawDecomposition.dart s.paths p)) Types.inverse a.perm a.involutive
+    a.compatible s.boundary_reduced
+  apply Finset.card_le_one.mpr
+  intro p hp q hq
+  simp only [fixed,Finset.mem_filter,Finset.mem_univ,true_and] at hp hq
+  apply (BalancedRotation.e s.paths cap hc).injective
+  apply Finset.card_le_one.mp ho
+  · simp only [fixed,Finset.mem_filter,Finset.mem_univ,true_and]
+    rw [←a.opposite_transport,hp]
+  · simp only [fixed,Finset.mem_filter,Finset.mem_univ,true_and]
+    rw [←a.opposite_transport,hq]
+/-- Only Euler planarity is needed in the interval-count argument. This file
+proves neither Euler planarity for an abstract pairing nor its PL realization. -/
+def Euler : Prop := Fintype.card (Position (fun t=>(s.paths t).length))+4≤
+  2*Fintype.card (Cycle (BoundaryRotation.perm (fun t=>(s.paths t).length)))+
+  2*Fintype.card (Cycle (opposite (BoundaryRotation.perm (fun t=>(s.paths t).length)) a.perm))
+lemma balanced_euler (h : a.Euler) : Fintype.card (Position (BalancedRotation.len s.paths cap hc))+4≤
+    2*Fintype.card (Cycle (BalancedRotation.perm s.paths cap hc))+
+    2*Fintype.card (Cycle (opposite (BalancedRotation.perm s.paths cap hc) (a.α cap hc))) := by
+  rw [a.opposite_eq,PermutationTransport.card_cycles]
+  change _≤2*Fintype.card (Cycle ((BalancedRotation.e s.paths cap hc).symm.permCongr
+    (BoundaryRotation.perm (fun t=>(s.paths t).length))))+_
+  rw [PermutationTransport.card_cycles,Fintype.card_congr (BalancedRotation.e s.paths cap hc)]
+  exact h
+lemma sides_le (h : a.Euler) : Fintype.card (a.Side cap hc)≤12*Fintype.card (ClosedWords.Piece s cap) := by
+  rw [Fintype.card_coe]
+  apply cuts_le_twelve
+  · exact a.balanced_euler cap hc h
+  · exact a.monogons cap hc
+  · exact BalancedRotation.cycles_le s.paths cap hc
+  · have hm := BoundaryRotation.ends_le (BalancedRotation.len s.paths cap hc)
+    exact hm.trans (Nat.le_add_left _ _)
+end
+
+open scoped Classical BigOperators
+open BlockAlignment ComparedBlocks GirthAsymptotics ActualPatternEvent TypedGraphs
+variable {rep : ℕ} {r : Match rep} {x : VA rep} {y : VB rep}
+    {s : PathSystem rep r x y} (a : FullPairing s) (cap : ℕ) (hc : 0<cap)
+    (hL : 1≤L (size rep)) (hd : GraphSample.Diameters rep r)
+/-- The actual balanced and short-closed system, with all cut comparisons and
+all closure positions left unpaired. -/
+def closed : PathSystem rep r x y := ClosedWords.system s cap hc hL hd (a.comparisons cap hc)
+  (a.lower cap hc) (a.upper cap hc) (a.lower_eq cap hc) (a.upper_eq cap hc)
+  (a.lower_le cap hc) (a.upper_le cap hc)
+  (fun p _ _=>a.balanced_reduced cap hc p) (fun p _ _=>a.balanced_compatible cap hc p)
+lemma closed_fixed : (Finset.univ.filter (fun p=>(a.closed cap hc hL hd).comparisons.pairing.partner p=p)).card=
+    ∑t,(ClosedWords.tail s cap hc hL hd t).length :=
+  WordPositions.fixed_card (ClosedWords.seg s cap hc) (ClosedWords.tail s cap hc hL hd)
+    (a.comparisons cap hc) (a.α_fixed_free cap hc)
+lemma closed_old (p : Position (fun t=>((a.closed cap hc hL hd).paths t).length))
+    (hp : (a.closed cap hc hL hd).comparisons.pairing.partner p≠p) :
+    p.2.val∈positions 0 (BalancedWords.old s.paths cap p.1) := by
+  have hh := WordPositions.nonfixed_old (ClosedWords.seg s cap hc) (ClosedWords.tail s cap hc hL hd)
+    (a.comparisons cap hc) p hp
+  convert hh using 2
+  exact_mod_cast (BalancedWords.segment_length s.paths cap hc p.1).symm
+end TorsionFreeZeroDivisors.SampleGraph.FullPairing
+
+/-! Recursive separation. This is the actual deletion-set
+construction and sharp charging estimate. The one-step Lipton–Tarjan theorem
+is kept as an explicit dependency, not asserted from an unspecified planar
+predicate.  No claim of a completed planar realization is made here. -/
+namespace TorsionFreeZeroDivisors.RecursiveSeparator
+open scoped Classical BigOperators
+variable {V : Type} [DecidableEq V] (R : V → V → Prop)
+
+/-- Every retained vertex lies in a small set closed under all retained edges. -/
+def Small (S : Finset V) (K : ℕ) : Prop :=
+  ∀ x∈S, ∃ T : Finset V, T⊆S ∧ x∈T ∧ T.card≤K ∧
+    ∀ y∈T, ∀ z∈S, R y z → z∈T
+
+omit [DecidableEq V] in
+lemma small_of_card {S : Finset V} {K : ℕ} (h : S.card≤K) : Small R S K := by
+  intro x hx
+  exact ⟨S,Finset.Subset.refl _,hx,h,fun _ _ _ hz _ => hz⟩
+
+/-- A genuine one-step separator, including its actual components/blocks. -/
+structure Split (S : Finset V) where
+  remove : Finset V
+  parts : Finset (Finset V)
+  remove_subset : remove⊆S
+  cover : parts.biUnion id=S\remove
+  disjoint : (parts : Set (Finset V)).Pairwise Disjoint
+  closed : ∀ b∈parts,∀ x∈b,∀ y∈S\remove,R x y → y∈b
+  size : ∀ b∈parts,3*b.card≤2*S.card
+  cost : (remove.card : ℝ)≤2*Real.sqrt 2*Real.sqrt S.card
+
+namespace Split
+variable {R} {S : Finset V} (P : Split R S)
+lemma subset {b : Finset V} (hb : b∈P.parts) : b⊆S\P.remove := by
+  intro x hx
+  rw [←P.cover]
+  exact Finset.mem_biUnion.mpr ⟨b,hb,hx⟩
+lemma mass : (∑ b∈P.parts,b.card)+P.remove.card=S.card := by
+  have h := Finset.card_biUnion P.disjoint
+  change (P.parts.biUnion id).card=∑ b∈P.parts,b.card at h
+  rw [P.cover] at h
+  rw [←h,Finset.card_sdiff_of_subset P.remove_subset]
+  exact Nat.sub_add_cancel (Finset.card_le_card P.remove_subset)
+lemma smaller {b : Finset V} (hb : b∈P.parts) (hS : 0<S.card) : b.card<S.card := by
+  have h := P.size b hb
+  omega
+end Split
+
+def q : ℝ := Real.sqrt (2/3)
+def a : ℝ := 2*Real.sqrt 2
+def Csep : ℝ := a/(1-q)
+lemma q_pos : 0<q := Real.sqrt_pos.mpr (by norm_num)
+lemma q_lt_one : q<1 := by
+  unfold q
+  have h := Real.sqrt_lt_sqrt (by norm_num : (0:ℝ)≤2/3) (by norm_num : (2/3:ℝ)<1)
+  simpa only [Real.sqrt_one] using h
+lemma a_pos : 0<a := mul_pos (by norm_num) (Real.sqrt_pos.mpr (by norm_num))
+lemma Csep_pos : 0<Csep := div_pos a_pos (sub_pos.mpr q_lt_one)
+lemma Csep_identity : Csep*(1-q)=a := div_mul_cancel₀ _ (ne_of_gt (sub_pos.mpr q_lt_one))
+
+lemma sqrt_size {b s : ℕ} (h : 3*b≤2*s) : Real.sqrt b≤q*Real.sqrt s := by
+  unfold q
+  rw [←Real.sqrt_mul (by norm_num : (0:ℝ)≤2/3)]
+  apply Real.sqrt_le_sqrt
+  have hh : 3*(b:ℝ)≤2*(s:ℝ) := by exact_mod_cast h
+  linarith
+
+/-- Charge bound for one recursive child, including leaves that incur no cost. -/
+lemma child_charge {K s b : ℕ} (hK : 0<K) (hs : K<s) (hb : 3*b≤2*s)
+    {d : ℝ} (hd : if b≤K then d=0 else d≤Csep*b/Real.sqrt K-Csep*q*Real.sqrt b) :
+    d≤Csep*b/Real.sqrt K-Csep*b/Real.sqrt s := by
+  have hKp : 0<Real.sqrt (K:ℝ) := Real.sqrt_pos.mpr (by exact_mod_cast hK)
+  have hsp : 0<Real.sqrt (s:ℝ) := Real.sqrt_pos.mpr (by exact_mod_cast (hK.trans hs))
+  have hKs : Real.sqrt (K:ℝ)≤Real.sqrt (s:ℝ) := Real.sqrt_le_sqrt (by exact_mod_cast hs.le)
+  by_cases hbK : b≤K
+  · rw [ite_eq_left hbK] at hd
+    rw [hd]
+    apply sub_nonneg.mpr
+    exact div_le_div_of_nonneg_left (mul_nonneg Csep_pos.le (Nat.cast_nonneg _)) hKp hKs
+  · rw [ite_eq_right hbK] at hd
+    apply hd.trans
+    apply sub_le_sub_left
+    have hh := mul_le_mul_of_nonneg_left (sqrt_size hb) (Real.sqrt_nonneg (b:ℝ))
+    rw [Real.mul_self_sqrt (Nat.cast_nonneg _)] at hh
+    have hh' : (b:ℝ)/Real.sqrt s≤q*Real.sqrt b := by
+      apply (div_le_iff₀ hsp).mpr
+      nlinarith only [hh]
+    have hh'' := mul_le_mul_of_nonneg_left hh' Csep_pos.le
+    simpa only [mul_div_assoc,mul_assoc] using hh''
+
+lemma parent_charge {K s d : ℕ} (hK : 0<K) (hs : K<s) (hd : d ≤ s)
+    (hcost : (d:ℝ)≤a*Real.sqrt s) :
+    (d:ℝ)+Csep*((s-d:ℕ):ℝ)/Real.sqrt K-Csep*((s-d:ℕ):ℝ)/Real.sqrt s
+      ≤ Csep*s/Real.sqrt K-Csep*q*Real.sqrt s := by
+  have hKp : 0<Real.sqrt (K:ℝ) := Real.sqrt_pos.mpr (by exact_mod_cast hK)
+  have hsp : 0<Real.sqrt (s:ℝ) := Real.sqrt_pos.mpr (by exact_mod_cast (hK.trans hs))
+  have hKs : Real.sqrt (K:ℝ)≤Real.sqrt (s:ℝ) := Real.sqrt_le_sqrt (by exact_mod_cast hs.le)
+  have hcoeff : 0≤Csep/Real.sqrt K-Csep/Real.sqrt s := sub_nonneg.mpr
+    (div_le_div_of_nonneg_left Csep_pos.le hKp hKs)
+  have hnonneg := mul_nonneg (Nat.cast_nonneg d) hcoeff
+  have he : (s:ℝ)/Real.sqrt s=Real.sqrt s := by
+    apply (div_eq_iff (ne_of_gt hsp)).mpr
+    exact (Real.mul_self_sqrt (Nat.cast_nonneg _)).symm
+  rw [Nat.cast_sub hd]
+  have hc := Csep_identity
+  calc
+    _ ≤ a*Real.sqrt s+Csep*s/Real.sqrt K-Csep*s/Real.sqrt s := by
+      simp only [div_eq_mul_inv] at hnonneg ⊢
+      nlinarith only [hnonneg,hcost]
+    _ = _ := by
+      have he' : Csep*(s:ℝ)/Real.sqrt s=Csep*Real.sqrt s := by rw [mul_div_assoc,he]
+      rw [he']
+      have hcs := congrArg (fun x : ℝ => x*Real.sqrt s) hc
+      nlinarith only [hcs]
+
+namespace Split
+variable {R} {S : Finset V} (P : Split R S) (D : Finset V → Finset V)
+def combined : Finset V := P.remove∪P.parts.biUnion D
+lemma child_deleted {b : Finset V} (hb : b∈P.parts) : D b⊆P.combined D := by
+  intro x hx
+  exact Finset.mem_union_right _ (Finset.mem_biUnion.mpr ⟨b,hb,hx⟩)
+lemma combined_subset (hD : ∀ b∈P.parts,D b⊆b) : P.combined D⊆S := by
+  intro x hx
+  rcases Finset.mem_union.mp hx with hx|hx
+  · exact P.remove_subset hx
+  · obtain ⟨b,hb,hx⟩ := Finset.mem_biUnion.mp hx
+    exact (Finset.mem_sdiff.mp (P.subset hb (hD b hb hx))).1
+lemma combined_small {K : ℕ} (hsmall : ∀ b∈P.parts,Small R (b\D b) K) :
+    Small R (S\P.combined D) K := by
+  intro x hx
+  have hxS := (Finset.mem_sdiff.mp hx).1
+  have hxr : x∉P.remove := fun h => (Finset.mem_sdiff.mp hx).2 (Finset.mem_union_left _ h)
+  have hcover : x∈P.parts.biUnion id := by rw [P.cover]; exact Finset.mem_sdiff.mpr ⟨hxS,hxr⟩
+  obtain ⟨b,hb,hxb⟩ := Finset.mem_biUnion.mp hcover
+  have hxd : x∉D b := fun h => (Finset.mem_sdiff.mp hx).2 (P.child_deleted D hb h)
+  obtain ⟨T,hTb,hxT,hTK,hclosed⟩ := hsmall b hb x (Finset.mem_sdiff.mpr ⟨hxb,hxd⟩)
+  refine ⟨T∩(S\P.combined D),Finset.inter_subset_right,Finset.mem_inter.mpr ⟨hxT,hx⟩,
+    (Finset.card_le_card Finset.inter_subset_left).trans hTK,?_⟩
+  intro y hy z hz hyz
+  have hyT := (Finset.mem_inter.mp hy).1
+  have hyb := (Finset.mem_sdiff.mp (hTb hyT)).1
+  have hzS := (Finset.mem_sdiff.mp hz).1
+  have hzr : z∉P.remove := fun h => (Finset.mem_sdiff.mp hz).2 (Finset.mem_union_left _ h)
+  have hzb := P.closed b hb y hyb z (Finset.mem_sdiff.mpr ⟨hzS,hzr⟩) hyz
+  have hzd : z∉D b := fun h => (Finset.mem_sdiff.mp hz).2 (P.child_deleted D hb h)
+  exact Finset.mem_inter.mpr ⟨hclosed y hyT z (Finset.mem_sdiff.mpr ⟨hzb,hzd⟩) hyz,hz⟩
+lemma combined_card : (P.combined D).card≤P.remove.card+∑ b∈P.parts,(D b).card := by
+  exact (Finset.card_union_le _ _).trans (Nat.add_le_add_left (Finset.card_biUnion_le) _)
+end Split
+
+/-- Exact recursive deletion, with a stronger potential bound used internally. -/
+theorem recursive (K : ℕ) (hK : 0<K)
+    (oneStep : ∀ S : Finset V,K<S.card → Nonempty (Split R S)) (S : Finset V) :
+    ∃ D : Finset V,D⊆S ∧ Small R (S\D) K ∧
+      (if S.card≤K then D=∅ else
+        (D.card:ℝ)≤Csep*S.card/Real.sqrt K-Csep*q*Real.sqrt S.card) := by
+  suffices ∀ m,∀ S : Finset V,S.card=m →
+      ∃ D : Finset V,D⊆S ∧ Small R (S\D) K ∧
+        (if S.card≤K then D=∅ else
+          (D.card:ℝ)≤Csep*S.card/Real.sqrt K-Csep*q*Real.sqrt S.card) from this _ S rfl
+  intro m
+  induction m using Nat.strong_induction_on with
+  | h m ih =>
+    intro S hm
+    by_cases hSK : S.card≤K
+    · refine ⟨∅,Finset.empty_subset _,?_,by simp only [ite_eq_left hSK]⟩
+      simpa only [Finset.sdiff_empty] using small_of_card R hSK
+    have hKS : K<S.card := lt_of_not_ge hSK
+    let P := (oneStep S hKS).some
+    have hchild : ∀ b∈P.parts,∃ D : Finset V,D⊆b ∧ Small R (b\D) K ∧
+        (if b.card≤K then D=∅ else
+          (D.card:ℝ)≤Csep*b.card/Real.sqrt K-Csep*q*Real.sqrt b.card) := by
+      intro b hb
+      exact ih b.card (hm ▸ P.smaller hb (hK.trans hKS)) b rfl
+    let D : Finset V → Finset V := fun b => if hb : b∈P.parts then (hchild b hb).choose else ∅
+    have hD : ∀ b∈P.parts,D b⊆b ∧ Small R (b\D b) K ∧
+        (if b.card≤K then D b=∅ else
+          ((D b).card:ℝ)≤Csep*b.card/Real.sqrt K-Csep*q*Real.sqrt b.card) := by
+      intro b hb
+      dsimp only [D]
+      rw [dite_eq_left hb]
+      exact (hchild b hb).choose_spec
+    refine ⟨P.combined D,P.combined_subset D (fun b hb => (hD b hb).1),
+      P.combined_small D (fun b hb => (hD b hb).2.1),?_⟩
+    rw [ite_eq_right hSK]
+    have hcharge : ∀ b∈P.parts,((D b).card:ℝ)≤
+        Csep*b.card/Real.sqrt K-Csep*b.card/Real.sqrt S.card := by
+      intro b hb
+      apply child_charge hK hKS (P.size b hb)
+      have hh := (hD b hb).2.2
+      split_ifs at hh ⊢ with hc
+      · simp only [hh,Finset.card_empty,Nat.cast_zero]
+      · exact hh
+    have hsummass : (∑ b∈P.parts,(b.card:ℝ))=(S.card:ℝ)-P.remove.card := by
+      have hh : (∑ b∈P.parts,(b.card:ℝ))+(P.remove.card:ℝ)=S.card := by exact_mod_cast P.mass
+      linarith
+    have hsum : (∑ b∈P.parts,((D b).card:ℝ))≤
+        Csep*((S.card:ℝ)-P.remove.card)/Real.sqrt K-
+        Csep*((S.card:ℝ)-P.remove.card)/Real.sqrt S.card := by
+      calc
+        _ ≤ ∑ b∈P.parts,(Csep*b.card/Real.sqrt K-Csep*b.card/Real.sqrt S.card) :=
+          Finset.sum_le_sum hcharge
+        _ = _ := by rw [Finset.sum_sub_distrib,←Finset.sum_div,←Finset.mul_sum,
+          ←Finset.sum_div,←Finset.mul_sum,hsummass]
+    have hcard : ((P.combined D).card:ℝ)≤P.remove.card+∑ b∈P.parts,((D b).card:ℝ) := by
+      exact_mod_cast P.combined_card D
+    have hp := parent_charge hK hKS (Finset.card_le_card P.remove_subset) P.cost
+    rw [Nat.cast_sub (Finset.card_le_card P.remove_subset)] at hp
+    linarith only [hcard,hsum,hp]
+
+/-- Source recursive planar-separation bound, once the actual one-step planar
+separator is supplied for every induced subgraph. -/
+theorem separator (K : ℕ) (hK : 1≤K)
+    (oneStep : ∀ S : Finset V,K<S.card → Nonempty (Split R S)) (S : Finset V) :
+    ∃ D : Finset V,D⊆S ∧ Small R (S\D) K ∧ (D.card:ℝ)≤Csep*S.card/Real.sqrt K := by
+  obtain ⟨D,hD,hsmall,hcost⟩ := recursive R K hK oneStep S
+  refine ⟨D,hD,hsmall,?_⟩
+  split_ifs at hcost with h
+  · rw [hcost,Finset.card_empty,Nat.cast_zero]
+    exact div_nonneg (mul_nonneg Csep_pos.le (Nat.cast_nonneg _)) (Real.sqrt_nonneg _)
+  · exact hcost.trans (sub_le_self _ (mul_nonneg (mul_nonneg Csep_pos.le q_pos.le) (Real.sqrt_nonneg _)))
+end TorsionFreeZeroDivisors.RecursiveSeparator
+
+namespace TorsionFreeZeroDivisors.PlanarParameters
+open scoped Classical
+open RecursiveSeparator
+variable (ε : ℝ) (D : ℕ)
+def U : ℕ := max 3 ⌈96*(D:ℝ)/ε⌉₊
+def η : ℝ := min (1/(32*(U ε D:ℝ))) (ε/(64*(U ε D:ℝ)))
+def K : ℕ := max 1 ⌈(Csep/η ε D)^2⌉₊
+def C : ℕ := K ε D*(U ε D+D)
+def C₂ : ℕ := 32*6
+/-- Oriented interval sides; the manuscript's I counts pairs. -/
+def sides : ℕ := 2*C₂*C ε D
+lemma U_ge : 3≤U ε D := le_max_left _ _
+lemma U_pos : 0<U ε D := lt_of_lt_of_le (by norm_num) (U_ge ε D)
+lemma η_pos (hε : 0<ε) : 0<η ε D := by
+  have hu : (0:ℝ)<U ε D := by exact_mod_cast U_pos ε D
+  exact lt_min (by positivity) (by positivity)
+lemma K_pos : 0<K ε D := lt_of_lt_of_le (by norm_num) (le_max_left _ _)
+lemma C_pos : 0<C ε D := Nat.mul_pos (K_pos ε D) (Nat.add_pos_left (U_pos ε D) _)
+lemma sides_pos : 0<sides ε D := by
+  unfold sides C₂
+  exact Nat.mul_pos (by norm_num) (C_pos ε D)
+
+lemma closure_loss (hε : 0<ε) : 3*(D:ℝ)/(U ε D:ℝ)≤ε/32 := by
+  have hu : (0:ℝ)<U ε D := by exact_mod_cast U_pos ε D
+  have hc : 96*(D:ℝ)/ε≤U ε D :=
+    (Nat.le_ceil _).trans (Nat.cast_le.mpr (le_max_right _ _))
+  have hh := (div_le_iff₀ hε).mp hc
+  apply (div_le_iff₀ hu).mpr
+  nlinarith
+lemma deletion_loss : 2*η ε D*(U ε D:ℝ)≤1/16 := by
+  have hu : (0:ℝ)<U ε D := by exact_mod_cast U_pos ε D
+  have h := min_le_left (1/(32*(U ε D:ℝ))) (ε/(64*(U ε D:ℝ)))
+  change η ε D≤1/(32*(U ε D:ℝ)) at h
+  have hh := (le_div_iff₀ (mul_pos (by norm_num) hu)).mp h
+  nlinarith
+lemma unpaired_loss : 2*η ε D*(U ε D:ℝ)≤ε/32 := by
+  have hu : (0:ℝ)<U ε D := by exact_mod_cast U_pos ε D
+  have h := min_le_right (1/(32*(U ε D:ℝ))) (ε/(64*(U ε D:ℝ)))
+  change η ε D≤ε/(64*(U ε D:ℝ)) at h
+  have hh := (le_div_iff₀ (mul_pos (by norm_num) hu)).mp h
+  nlinarith
+lemma separator_factor (hε : 0<ε) : Csep/Real.sqrt (K ε D:ℝ)≤η ε D := by
+  have he := η_pos ε D hε
+  have hk : (0:ℝ)<K ε D := by exact_mod_cast K_pos ε D
+  have hq : (Csep/η ε D)^2≤K ε D :=
+    (Nat.le_ceil _).trans (Nat.cast_le.mpr (le_max_right _ _))
+  have hs := Real.sqrt_nonneg (K ε D:ℝ)
+  have hs2 := Real.sq_sqrt hk.le
+  have hp : 0<Csep/η ε D := div_pos Csep_pos he
+  have hs' : Csep/η ε D≤Real.sqrt (K ε D:ℝ) := by nlinarith
+  have hh := (div_le_iff₀ he).mp hs'
+  apply (div_le_iff₀ (Real.sqrt_pos.mpr hk)).mpr
+  nlinarith
+
+/-- No planar theorem is hidden here: this uses the actual one-step Split
+objects and constructs a literal deletion set, with the fixed source K. -/
+theorem delete {V : Type} [Fintype V] (R : V → V → Prop) (hε : 0<ε)
+    (oneStep : ∀ S : Finset V,K ε D<S.card → Nonempty (Split R S)) :
+    ∃ A : Finset V,Small R (Finset.univ\A) (K ε D) ∧
+      (A.card:ℝ)≤η ε D*Fintype.card V := by
+  obtain ⟨A,_hA,hsmall,hcost⟩ := separator R (K ε D) (K_pos ε D) oneStep Finset.univ
+  refine ⟨A,hsmall,?_⟩
+  apply hcost.trans
+  rw [Finset.card_univ,mul_div_right_comm]
+  exact mul_le_mul_of_nonneg_right (separator_factor ε D hε) (Nat.cast_nonneg _)
+end TorsionFreeZeroDivisors.PlanarParameters
+
+namespace TorsionFreeZeroDivisors.LocalizationCounts
+open scoped Classical BigOperators
+open ComparedBlocks BlockAlignment
+variable {T E : Type} [Fintype T] {len : T → ℕ}
+    (C : Comparisons (E:=E) len) (keep : T → Prop) (old : T → ℕ)
+    (hprefix : ∀ p : Position len,C.pairing.partner p≠p → p.2.val∈positions 0 (old p.1))
+
+def deletedMap (p : {p : Position len // ¬keep p.1 ∧ C.pairing.partner p≠p}) :
+    Position (fun t : {t // ¬keep t}=>old t.val) :=
+  ⟨⟨p.val.1,p.property.1⟩,⟨p.val.2.val,hprefix p.val p.property.2⟩⟩
+omit [Fintype T] in
+lemma deleted_injective : Function.Injective (deletedMap C keep old hprefix) := by
+  intro a b h
+  have ht : a.val.1=b.val.1 := congrArg (fun p=>p.1.val) h
+  have hq : a.val.2.val=b.val.2.val := congrArg (fun p=>p.2.val) h
+  apply Subtype.ext
+  rcases a with ⟨⟨t,x⟩,ha⟩
+  rcases b with ⟨⟨u,y⟩,hb⟩
+  dsimp only at ht hq ⊢
+  subst u
+  exact Sigma.ext rfl (heq_of_eq (Subtype.ext hq))
+
+include hprefix in
+/-- Only deleted ORIGINAL occurrences, not closures, can destroy a partner. -/
+lemma deleted_nonfixed_le :
+    (Finset.univ.filter (fun p : Position len=>¬keep p.1 ∧ C.pairing.partner p≠p)).card≤
+      ∑t∈Finset.univ.filter (fun t=>¬keep t),old t := by
+  have hh := Fintype.card_le_of_injective _ (deleted_injective C keep old hprefix)
+  have hs : (∑t : {t // ¬keep t},old t.val)=∑t∈Finset.univ.filter (fun t=>¬keep t),old t :=
+    (Finset.sum_subtype _ (by intro t; simp) old).symm
+  rw [FiniteChunking.position_card,hs] at hh
+  simpa only [Fintype.card_subtype] using hh
+
+/-- The exact removed-original-position bound, from the actual deletion set. -/
+lemma deleted_mass {U L : ℕ} {η H₀ : ℝ}
+    (hcap : ∀ t,old t≤U*L) (hη : 0≤η)
+    (hcount : ((Finset.univ.filter (fun t=>¬keep t)).card:ℝ)≤η*Fintype.card T)
+    (hpieces : (Fintype.card T:ℝ)*L≤2*H₀) :
+    (∑t∈Finset.univ.filter (fun t=>¬keep t),(old t:ℝ))≤2*η*U*H₀ := by
+  calc
+    _ ≤ ∑_t∈Finset.univ.filter (fun t=>¬keep t),(U:ℝ)*L := by
+      apply Finset.sum_le_sum
+      intro t _
+      exact_mod_cast hcap t
+    _ = ((Finset.univ.filter (fun t=>¬keep t)).card:ℝ)*(U:ℝ)*L := by simp; ring
+    _ ≤ (η*Fintype.card T)*(U:ℝ)*L :=
+      mul_le_mul_of_nonneg_right (mul_le_mul_of_nonneg_right hcount (Nat.cast_nonneg _)) (Nat.cast_nonneg _)
+    _ = η*U*((Fintype.card T:ℝ)*L) := by ring
+    _ ≤ η*U*(2*H₀) := mul_le_mul_of_nonneg_left hpieces (mul_nonneg hη (Nat.cast_nonneg _))
+    _ = _ := by ring
+end TorsionFreeZeroDivisors.LocalizationCounts
+
+namespace TorsionFreeZeroDivisors.SampleGraph.PathSystem
+open scoped Classical BigOperators
+open GirthAsymptotics ActualPatternEvent TypedGraphs ComparedBlocks ClusterLocalization
+abbrev ε : ℝ := StageFusion.epsilon (1/600) 256
+lemma ε_pos : 0<ε := StageFusion.epsilon_pos (by norm_num) (by norm_num)
+variable {rep : ℕ} {r : Match rep} {x : VA rep} {y : VB rep}
+    (s : PathSystem rep r x y)
+local instance : Fintype s.P := s.fP
+local instance : Fintype s.E := s.fE
+
+/-- The complete deterministic separator-to-forbidden-system implication.
+The one-step separator is explicitly the still-missing planar geometry input;
+the deletion set, losses, clusters, and realized forbidden words are constructed. -/
+theorem excluded_of_separator (D : ℕ) (H₀ : ℝ) (old : s.P → ℕ)
+    (hH₀ : 0<H₀) (hL : 0<L (size rep))
+    (ho : ∀ t,old t≤(s.paths t).length)
+    (hcapOld : ∀ t,old t≤PlanarParameters.U ε D*L (size rep))
+    (hcap : ∀ t,(s.paths t).length≤(PlanarParameters.U ε D+D)*L (size rep))
+    (hbase : H₀≤∑t,(old t:ℝ))
+    (hpieces : (Fintype.card s.P:ℝ)*L (size rep)≤2*H₀)
+    (hadded : ((Finset.univ.filter (fun p=>s.comparisons.pairing.partner p=p)).card:ℝ)≤
+      3*(D:ℝ)/PlanarParameters.U ε D*H₀)
+    (hprefix : ∀ p : Position (fun t=>(s.paths t).length),s.comparisons.pairing.partner p≠p →
+      p.2.val∈BlockAlignment.positions 0 (old p.1))
+    (hcompare : Fintype.card s.E≤12*Fintype.card s.P)
+    (hlong : ∀ t,s.root≠some t → L (size rep)≤(s.paths t).length)
+    (hroot : ∀ t,s.root=some t → (s.paths t).length<L (size rep) → ((s.paths t).length:ℝ)≤H₀/2)
+    (oneStep : ∀ S : Finset s.P,PlanarParameters.K ε D<S.card →
+      Nonempty (RecursiveSeparator.Split
+        (PairingClusters.Rel (fun p : Position (fun t=>(s.paths t).length)=>p.1) s.comparisons.pairing.partner) S))
+    (havoid : IsEmpty (BoundedSystem (PlanarParameters.C ε D) (PlanarParameters.K ε D)
+      (PlanarParameters.sides ε D) rep r x y)) : False := by
+  classical
+  let R := PairingClusters.Rel (fun p : Position (fun t=>(s.paths t).length)=>p.1) s.comparisons.pairing.partner
+  obtain ⟨A,hsmall,hA⟩ := PlanarParameters.delete ε D R ε_pos oneStep
+  let keep : s.P → Prop := fun t=>t∉A
+  have hcount : ((Finset.univ.filter (fun t=>¬keep t)).card:ℝ)≤PlanarParameters.η ε D*Fintype.card s.P := by
+    simpa only [keep,not_not,Finset.filter_mem_eq_inter,Finset.univ_inter] using hA
+  have hsize : ∀ c : Cluster s.comparisons keep,(ClusterLocalization.paths s.comparisons keep c).card≤PlanarParameters.K ε D := by
+    apply ClusterLocalization.paths_card_le
+    intro t ht
+    obtain ⟨B,_hB,htB,hBK,hcl⟩ := hsmall t (by simpa only [Finset.mem_sdiff,Finset.mem_univ,true_and] using ht)
+    refine ⟨B,htB,hBK,?_⟩
+    intro a ha b hb hab
+    exact hcl a ha b (by simpa only [Finset.mem_sdiff,Finset.mem_univ,true_and] using hb) hab
+  have hη := (PlanarParameters.η_pos ε D ε_pos).le
+  have hd : (∑t∈Finset.univ.filter (fun t=>¬keep t),(old t:ℝ))≤2*PlanarParameters.η ε D*PlanarParameters.U ε D*H₀ := by
+    convert LocalizationCounts.deleted_mass keep old hcapOld hη (by
+      convert hcount using 1
+      congr 2
+      ext t
+      simp) hpieces using 1
+    congr 1
+    ext t
+    simp
+  have hdshort : (∑t∈Finset.univ.filter (fun t=>¬keep t),(old t:ℝ))≤H₀/16 := by
+    apply hd.trans
+    have hh := mul_le_mul_of_nonneg_right (PlanarParameters.deletion_loss ε D) hH₀.le
+    nlinarith
+  have hdε : (∑t∈Finset.univ.filter (fun t=>¬keep t),(old t:ℝ))≤ε/32*H₀ := by
+    exact hd.trans (mul_le_mul_of_nonneg_right (PlanarParameters.unpaired_loss ε D) hH₀.le)
+  have hb : ((Finset.univ.filter (fun p=>s.comparisons.pairing.partner p=p)).card:ℝ)+
+      ((Finset.univ.filter (fun p=>¬keep p.1 ∧ s.comparisons.pairing.partner p≠p)).card:ℝ)≤ε/16*H₀ := by
+    have hnew : ((Finset.univ.filter (fun p=>¬keep p.1 ∧ s.comparisons.pairing.partner p≠p)).card:ℝ)≤
+        ∑t∈Finset.univ.filter (fun t=>¬keep t),(old t:ℝ) := by
+      have hn := LocalizationCounts.deleted_nonfixed_le s.comparisons keep old hprefix
+      have hn' : (Finset.univ.filter (fun p=>¬keep p.1 ∧ s.comparisons.pairing.partner p≠p)).card≤
+          ∑t∈Finset.univ.filter (fun t=>¬keep t),old t := by
+        convert hn using 1 <;> congr 1 <;> ext t <;> simp
+      exact_mod_cast hn'
+    have ha := mul_le_mul_of_nonneg_right (PlanarParameters.closure_loss ε D ε_pos) hH₀.le
+    linarith
+  have hcomp : (Fintype.card s.E:ℝ)/2≤(192:ℝ)/(16*L (size rep))*H₀ := by
+    have hh : (Fintype.card s.E:ℝ)≤12*Fintype.card s.P := by exact_mod_cast hcompare
+    have hLr : (0:ℝ)<L (size rep) := by exact_mod_cast hL
+    rw [show (192:ℝ)/(16*L (size rep))*H₀=12*H₀/L (size rep) by ring]
+    apply (le_div_iff₀ hLr).mpr
+    have hc := mul_le_mul_of_nonneg_right hh hLr.le
+    nlinarith
+  have hi : ⌈2*(192:ℝ)*(PlanarParameters.K ε D*(PlanarParameters.U ε D+D):ℝ)⌉₊=
+      PlanarParameters.sides ε D := by
+    rw [show 2*(192:ℝ)*(PlanarParameters.K ε D*(PlanarParameters.U ε D+D):ℝ)=
+      (2*192*(PlanarParameters.K ε D*(PlanarParameters.U ε D+D)):ℕ) by push_cast; ring]
+    rw [Nat.ceil_natCast]
+    rfl
+  have havoid' : IsEmpty (BoundedSystem (PlanarParameters.K ε D*(PlanarParameters.U ε D+D))
+      (PlanarParameters.K ε D) ⌈2*(192:ℝ)*(PlanarParameters.K ε D*(PlanarParameters.U ε D+D):ℝ)⌉₊ rep r x y) := by
+    rw [hi]
+    exact havoid
+  exact s.excluded_of_local_totals keep (PlanarParameters.K ε D) (PlanarParameters.U ε D+D)
+    192 H₀ old ho hH₀ hL (by norm_num) hsize hcap hbase (by
+      convert hdshort using 1
+      congr 1
+      ext t
+      simp) (by
+      convert hb using 1
+      congr 3
+      ext t
+      simp) hcomp hlong hroot (by
+      convert havoid' using 1
+      push_cast
+      rfl)
+end TorsionFreeZeroDivisors.SampleGraph.PathSystem
+
+namespace TorsionFreeZeroDivisors.SampleGraph.FullPairing
+open scoped Classical BigOperators
+open BlockAlignment ComparedBlocks GirthAsymptotics ActualPatternEvent TypedGraphs
+abbrev U₀ : ℕ := PlanarParameters.U PathSystem.ε ClosedWords.D
+lemma U₀_ge : 3≤U₀ := PlanarParameters.U_ge _ _
+lemma cap_lower {rep : ℕ} (hL : 2≤L (size rep)) : 6≤U₀*L (size rep) := by
+  have := U₀_ge
+  nlinarith
+abbrev cap_positive {rep : ℕ} (hL : 2≤L (size rep)) : 0<U₀*L (size rep) := by
+  have := cap_lower hL
+  omega
+variable {rep : ℕ} {r : Match rep} {x : VA rep} {y : VB rep}
+    {s : PathSystem rep r x y} (a : FullPairing s) (hL : 2≤L (size rep))
+    (hd : GraphSample.Diameters rep r)
+def prepared : PathSystem rep r x y := a.closed (U₀*L (size rep)) (cap_positive hL) (by omega) hd
+/-- Literal full-pairing exclusion. Euler planarity and the one-step separator
+are the two remaining geometric inputs, not extra source hypotheses on the
+main theorem. No claim of their unconditional existence is made here. -/
+theorem excluded (hr : r∈samples rep) (hordinary : ∃t,s.root≠some t) (heuler : a.Euler)
+    (oneStep : ∀ S : Finset (a.prepared hL hd).P,PlanarParameters.K PathSystem.ε ClosedWords.D<S.card →
+      Nonempty (RecursiveSeparator.Split
+        (PairingClusters.Rel (fun p : Position (fun t=>((a.prepared hL hd).paths t).length)=>p.1)
+          (a.prepared hL hd).comparisons.pairing.partner) S))
+    (havoid : IsEmpty (BoundedSystem (PlanarParameters.C PathSystem.ε ClosedWords.D)
+      (PlanarParameters.K PathSystem.ε ClosedWords.D) (PlanarParameters.sides PathSystem.ε ClosedWords.D) rep r x y)) : False := by
+  have hLl : 1≤L (size rep) := by omega
+  have hc := cap_positive hL
+  have hcp := cap_lower hL
+  have hH : 0<(ClosedWords.H₀ s:ℝ) := by
+    have hm := ClosedWords.H₀_ge s hr hordinary
+    have : 0<ClosedWords.H₀ s := by omega
+    exact_mod_cast this
+  apply (a.prepared hL hd).excluded_of_separator ClosedWords.D (ClosedWords.H₀ s)
+    (BalancedWords.old s.paths (U₀*L (size rep))) hH (by omega)
+  · exact ClosedWords.old_le_word s _ hc hLl hd
+  · exact BalancedWords.old_le s.paths _ hcp
+  · intro t
+    change (ClosedWords.word s _ hc hLl hd t).length≤_
+    have hh := ClosedWords.word_bound s _ hc hLl hd hcp t
+    simpa only [Nat.add_mul] using hh
+  · change (ClosedWords.H₀ s:ℝ)≤∑t : ClosedWords.Piece s (U₀*L (size rep)),
+      (BalancedWords.old s.paths (U₀*L (size rep)) t:ℝ)
+    rw [←Nat.cast_sum,BalancedWords.old_sum s.paths _ hc]
+  · have hh := ClosedWords.piece_charge s U₀ U₀_ge hcp hr hordinary
+    exact_mod_cast hh
+  · change ((Finset.univ.filter (fun p=>(a.closed _ hc hLl hd).comparisons.pairing.partner p=p)).card:ℝ)≤_
+    rw [a.closed_fixed,Nat.cast_sum]
+    exact ClosedWords.added_real s U₀ U₀_ge hLl hcp hd
+  · exact a.closed_old _ hc hLl hd
+  · exact a.sides_le _ hc heuler
+  · exact ClosedWords.lower_word s U₀ U₀_ge hLl hcp hd hr
+  · intro t ht hs
+    have hh := ClosedWords.root_mass s U₀ hLl hcp hd hr hordinary t ht hs
+    have hh' : 2*((ClosedWords.word s _ hc hLl hd t).length:ℝ)≤ClosedWords.H₀ s := by exact_mod_cast hh
+    change ((ClosedWords.word s _ hc hLl hd t).length:ℝ)≤_
+    linarith
+  · exact oneStep
+  · exact havoid
+end TorsionFreeZeroDivisors.SampleGraph.FullPairing
+
+namespace TorsionFreeZeroDivisors.PermutationCycles
+variable {O B : Type} [Fintype O] (f : Equiv.Perm O)
+omit [Fintype O] in
+lemma invariant_pow (q : O → B) (hq : ∀x,q (f x)=q x) (n : ℕ) (x : O) :
+    q ((f^n) x)=q x := by
+  induction n with
+  | zero => rfl
+  | succ n ih => rw [pow_succ',Equiv.Perm.mul_apply,hq,ih]
+def lift (q : O → B) (hq : ∀x,q (f x)=q x) : Cycle f → B :=
+  Quotient.lift q (by
+    intro x y h
+    obtain ⟨n,hn⟩ := h.exists_nat_pow_eq
+    rw [←hn]
+    exact (invariant_pow f q hq n x).symm)
+@[simp] lemma lift_cycle (q : O → B) (hq : ∀x,q (f x)=q x) (x : O) :
+    lift f q hq (cycle f x)=q x := rfl
+lemma lift_surjective (q : O → B) (hq : ∀x,q (f x)=q x) (hs : Function.Surjective q) :
+    Function.Surjective (lift f q hq) := by
+  intro b
+  obtain ⟨x,rfl⟩ := hs b
+  exact ⟨cycle f x,rfl⟩
+end TorsionFreeZeroDivisors.PermutationCycles
+
+namespace TorsionFreeZeroDivisors.InsertedRotation
+open scoped Classical
+open PermutationCycles
+variable {O : Type} (σ α : Equiv.Perm O) (p : O)
+
+def rotation : Equiv.Perm (O⊕Bool) :=
+  Equiv.sumCongr σ (Equiv.refl _) * Equiv.swap (.inl p) (.inr true) *
+    Equiv.swap (.inl p) (.inr false)
+def pairing : Equiv.Perm (O⊕Bool) := Equiv.sumCongr α Equiv.boolNot
+def face : Equiv.Perm (O⊕Bool) := pairing α * rotation σ p
+lemma rotation_left (i : O) (hi : i≠p) : rotation σ p (.inl i)=.inl (σ i) := by
+  simp [rotation,Equiv.Perm.mul_apply,Equiv.swap_apply_of_ne_of_ne,hi]
+@[simp] lemma rotation_p : rotation σ p (.inl p)=.inr false := by
+  simp [rotation,Equiv.Perm.mul_apply,Equiv.swap_apply_def]
+@[simp] lemma rotation_false : rotation σ p (.inr false)=.inr true := by
+  simp [rotation,Equiv.Perm.mul_apply]
+@[simp] lemma rotation_true : rotation σ p (.inr true)=.inl (σ p) := by
+  simp [rotation,Equiv.Perm.mul_apply,Equiv.swap_apply_def]
+lemma face_left (i : O) (hi : i≠p) : face σ α p (.inl i)=.inl ((α*σ) i) := by
+  simp only [face,Equiv.Perm.mul_apply,rotation_left σ p i hi,pairing,Equiv.sumCongr_apply,Sum.map_inl]
+@[simp] lemma face_p : face σ α p (.inl p)=.inr true := by
+  simp [face,Equiv.Perm.mul_apply,pairing]
+@[simp] lemma face_false : face σ α p (.inr false)=.inr false := by
+  simp [face,Equiv.Perm.mul_apply,pairing]
+@[simp] lemma face_true : face σ α p (.inr true)=.inl ((α*σ) p) := by
+  simp [face,Equiv.Perm.mul_apply,pairing]
+
+def classify : O⊕Bool → Option (Cycle (α*σ))
+  | .inl i => some (cycle _ i)
+  | .inr false => none
+  | .inr true => some (cycle _ p)
+lemma classify_invariant (i : O⊕Bool) : classify σ α p (face σ α p i)=classify σ α p i := by
+  cases i with
+  | inl i =>
+    by_cases he : i=p
+    · subst i; rw [face_p]; rfl
+    · rw [face_left σ α p i he]
+      simp only [classify,cycle_apply]
+  | inr b => cases b <;> simp only [face_false,face_true,classify,cycle_apply]
+lemma classify_surjective : Function.Surjective (classify σ α p) := by
+  intro b
+  cases b with
+  | none => exact ⟨.inr false,rfl⟩
+  | some c =>
+    obtain ⟨i,rfl⟩ := cycle_surjective (α*σ) c
+    exact ⟨.inl i,rfl⟩
+variable [Fintype O]
+/-- Inserting an ear creates a new face and retains all old face cycles. -/
+theorem face_count : Fintype.card (Cycle (α*σ))+1≤Fintype.card (Cycle (face σ α p)) := by
+  have h := Fintype.card_le_of_surjective _ (lift_surjective (face σ α p)
+    (classify σ α p) (classify_invariant σ α p) (classify_surjective σ α p))
+  simpa only [Fintype.card_option] using h
+
+end TorsionFreeZeroDivisors.InsertedRotation
+
+namespace TorsionFreeZeroDivisors.SwapCycles
+
+section
+open scoped Classical
+open PermutationCycles
+variable {O : Type} (f : Equiv.Perm O) (p q : O)
+abbrev Away := {c : Cycle f // c≠cycle f p ∧ c≠cycle f q}
+def classify (x : O) : Option (Away f p q) :=
+  if h : cycle f x≠cycle f p ∧ cycle f x≠cycle f q then some ⟨cycle f x,h⟩ else none
+lemma classify_apply (x : O) : classify f p q (f x)=classify f p q x := by
+  simp only [classify,cycle_apply]
+@[simp] lemma classify_p : classify f p q p=none := by simp [classify]
+@[simp] lemma classify_q : classify f p q q=none := by simp [classify]
+lemma classify_swap (x : O) : classify f p q (Equiv.swap p q x)=classify f p q x := by
+  by_cases hp : x=p
+  · subst x; simp
+  · by_cases hq : x=q
+    · subst x; simp
+    · rw [Equiv.swap_apply_of_ne_of_ne hp hq]
+lemma invariant (x : O) : classify f p q ((Equiv.swap p q*f) x)=classify f p q x := by
+  rw [Equiv.Perm.mul_apply,classify_swap,classify_apply]
+lemma surjective : Function.Surjective (classify f p q) := by
+  intro b
+  cases b with
+  | none => exact ⟨p,classify_p f p q⟩
+  | some c =>
+    obtain ⟨x,hx⟩ := cycle_surjective f c.val
+    refine ⟨x,?_⟩
+    have h : cycle f x≠cycle f p ∧ cycle f x≠cycle f q := hx ▸ c.property
+    rw [classify,dite_eq_left h]
+    exact congrArg some (Subtype.ext hx)
+variable [Fintype O]
+lemma lower : Fintype.card (Away f p q)+1≤Fintype.card (Cycle (Equiv.swap p q*f)) := by
+  have h := Fintype.card_le_of_surjective _ (lift_surjective (Equiv.swap p q*f)
+    (classify f p q) (invariant f p q) (surjective f p q))
+  simpa only [Fintype.card_option] using h
+lemma away_count : Fintype.card (Cycle f)≤Fintype.card (Away f p q)+2 := by
+  let rest : Finset (Cycle f) := Finset.univ.filter (fun c=>c≠cycle f p ∧ c≠cycle f q)
+  have hs : (Finset.univ : Finset (Cycle f))⊆rest∪{cycle f p,cycle f q} := by
+    intro c _
+    by_cases h : c≠cycle f p ∧ c≠cycle f q
+    · exact Finset.mem_union_left _ (Finset.mem_filter.mpr ⟨Finset.mem_univ _,h⟩)
+    · apply Finset.mem_union_right
+      simp only [Finset.mem_insert,Finset.mem_singleton]
+      tauto
+  have h := (Finset.card_le_card hs).trans (Finset.card_union_le _ _)
+  have hr : rest.card=Fintype.card (Away f p q) := by
+    simp [rest,Fintype.card_subtype]
+  rw [Finset.card_univ,hr] at h
+  exact h.trans (Nat.add_le_add_left (Finset.card_insert_le _ _) _)
+/-- A two-endpoint switch loses at most one permutation cycle. -/
+theorem count_le : Fintype.card (Cycle f)≤Fintype.card (Cycle (Equiv.swap p q*f))+1 := by
+  have h₁ := lower f p q
+  have h₂ := away_count f p q
+  omega
+
+end
+
+section
+open scoped Classical
+open PermutationCycles
+variable {O : Type} (f : Equiv.Perm O) (p q : O)
+lemma cycle_swap (h : cycle f p=cycle f q) (x : O) :
+    cycle f (Equiv.swap p q x)=cycle f x := by
+  by_cases hp : x=p
+  · subst x; simpa using h.symm
+  · by_cases hq : x=q
+    · subst x; simpa using h
+    · rw [Equiv.swap_apply_of_ne_of_ne hp hq]
+
+def adjacentClass (x : O) : Option (Cycle f) := if x=p then none else some (cycle f x)
+lemma adjacent_fixed : (Equiv.swap p (f p)*f) p=p := by simp
+lemma adjacentClass_invariant (x : O) :
+    adjacentClass f p ((Equiv.swap p (f p)*f) x)=adjacentClass f p x := by
+  by_cases hx : x=p
+  · subst x; rw [adjacent_fixed]
+  · have hg : (Equiv.swap p (f p)*f) x≠p := by
+      intro h
+      exact hx ((Equiv.swap p (f p)*f).injective (h.trans (adjacent_fixed f p).symm))
+    rw [adjacentClass,ite_eq_right hg,adjacentClass,ite_eq_right hx]
+    apply congrArg some
+    rw [Equiv.Perm.mul_apply,cycle_swap f p (f p) (cycle_apply f p).symm,cycle_apply]
+lemma adjacentClass_surjective (hp : f p≠p) : Function.Surjective (adjacentClass f p) := by
+  intro c
+  cases c with
+  | none => exact ⟨p,by simp [adjacentClass]⟩
+  | some c =>
+    obtain ⟨x,rfl⟩ := cycle_surjective f c
+    by_cases hx : x=p
+    · subst x
+      exact ⟨f p,by simp [adjacentClass,hp]⟩
+    · exact ⟨x,by simp [adjacentClass,hx]⟩
+
+variable [Fintype O]
+lemma count_reverse : Fintype.card (Cycle (Equiv.swap p q*f))≤Fintype.card (Cycle f)+1 := by
+  simpa only [←mul_assoc,Equiv.swap_mul_self,one_mul] using count_le (Equiv.swap p q*f) p q
+/-- Switching the two arrows adjacent to a nonfixed point splits off that point
+as one new actual cycle. -/
+lemma adjacent_count (hp : f p≠p) :
+    Fintype.card (Cycle (Equiv.swap p (f p)*f))=Fintype.card (Cycle f)+1 := by
+  have h := Fintype.card_le_of_surjective _ (lift_surjective (Equiv.swap p (f p)*f)
+    (adjacentClass f p) (adjacentClass_invariant f p) (adjacentClass_surjective f p hp))
+  simp only [Fintype.card_option] at h
+  exact Nat.le_antisymm (count_reverse f p (f p)) h
+lemma adjacent_support (hp : f p≠p) :
+    (Equiv.swap p (f p)*f).support.card<f.support.card := by
+  have hs : (Equiv.swap p (f p)*f).support⊆f.support.erase p := by
+    intro x hx
+    simp only [Finset.mem_erase,Equiv.Perm.mem_support] at *
+    refine ⟨?_,?_⟩
+    · intro he; subst x; exact hx (adjacent_fixed f p)
+    · intro he
+      have hxp : x≠p := by intro h; subst x; exact hp he
+      have hxf : x≠f p := by
+        intro h
+        have he' : f x=f p := he.trans h
+        exact hxp (f.injective he')
+      exact hx (by simp [Equiv.Perm.mul_apply,he,Equiv.swap_apply_of_ne_of_ne hxp hxf])
+  exact (Finset.card_le_card hs).trans_lt (Finset.card_erase_lt_of_mem (Equiv.Perm.mem_support.mpr hp))
+
+lemma away_same (h : cycle f p=cycle f q) :
+    Fintype.card (Cycle f)≤Fintype.card (Away f p q)+1 := by
+  let rest : Finset (Cycle f) := Finset.univ.filter (fun c=>c≠cycle f p ∧ c≠cycle f q)
+  have hs : (Finset.univ : Finset (Cycle f))⊆rest∪{cycle f p} := by
+    intro c _
+    by_cases hc : c=cycle f p
+    · exact Finset.mem_union_right _ (Finset.mem_singleton.mpr hc)
+    · exact Finset.mem_union_left _ (Finset.mem_filter.mpr ⟨Finset.mem_univ _,hc,by rwa [←h]⟩)
+  have hh := (Finset.card_le_card hs).trans (Finset.card_union_le _ _)
+  have hr : rest.card=Fintype.card (Away f p q) := by simp [rest,Fintype.card_subtype]
+  simpa [hr] using hh
+lemma same_monotone (h : cycle f p=cycle f q) :
+    Fintype.card (Cycle f)≤Fintype.card (Cycle (Equiv.swap p q*f)) :=
+  (away_same f p q h).trans (lower f p q)
+
+end
+
+section
+open scoped Classical
+open PermutationCycles
+variable {O : Type} [Fintype O]
+lemma identity_count : Fintype.card (Cycle (1 : Equiv.Perm O))=Fintype.card O := by
+  apply (Fintype.card_of_bijective (f:=cycle (1 : Equiv.Perm O)) ?_).symm
+  refine ⟨?_,cycle_surjective _⟩
+  intro x y h
+  exact ((cycle_eq _).mp h).eq_of_left rfl
+/-- The ordinary permutation sign in terms of all cycles, including fixed points. -/
+lemma sign_formula (f : Equiv.Perm O) :
+    Equiv.Perm.sign f=(-1 : ℤˣ)^(Fintype.card O+Fintype.card (Cycle f)) := by
+  have aux : ∀m,∀g : Equiv.Perm O,g.support.card=m →
+      Equiv.Perm.sign g=(-1 : ℤˣ)^(Fintype.card O+Fintype.card (Cycle g)) := by
+    intro m
+    induction m using Nat.strong_induction_on with
+    | h m ih =>
+      intro g hg
+      by_cases he : g=1
+      · subst g
+        rw [Equiv.Perm.sign_one,identity_count,←two_mul,pow_mul]
+        norm_num
+      · obtain ⟨p,hp⟩ : ∃p,g p≠p := by
+          by_contra! h
+          exact he (Equiv.ext h)
+        have hsmall := adjacent_support g p hp
+        have hh := ih (Equiv.swap p (g p)*g).support.card (hg ▸ hsmall)
+          (Equiv.swap p (g p)*g) rfl
+        rw [Equiv.Perm.sign_mul,Equiv.Perm.sign_swap hp.symm,adjacent_count g p hp,
+          ←Nat.add_assoc,pow_succ,mul_comm] at hh
+        exact mul_right_cancel hh
+  exact aux f.support.card f rfl
+
+/-- A switch between distinct positions of one cycle splits it in two. -/
+theorem split_count (f : Equiv.Perm O) (p q : O) (hpq : p≠q)
+    (h : cycle f p=cycle f q) :
+    Fintype.card (Cycle (Equiv.swap p q*f))=Fintype.card (Cycle f)+1 := by
+  have hlo := same_monotone f p q h
+  have hhi := count_reverse f p q
+  have hne : Fintype.card (Cycle (Equiv.swap p q*f))≠Fintype.card (Cycle f) := by
+    intro he
+    have hs : Equiv.Perm.sign (Equiv.swap p q*f)=Equiv.Perm.sign f := by
+      rw [sign_formula,sign_formula,he]
+    rw [Equiv.Perm.sign_mul,Equiv.Perm.sign_swap hpq] at hs
+    have hn : (-1 : ℤˣ)=1 := mul_right_cancel (hs.trans (one_mul _).symm)
+    norm_num at hn
+  omega
+
+end
+
+section
+open scoped Classical
+open PermutationCycles
+variable {O : Type} [Fintype O] (σ α : Equiv.Perm O) (p q : O)
+omit [Fintype O] in
+lemma face_switch : α*(Equiv.swap p q*σ)=Equiv.swap (α p) (α q)*(α*σ) := by
+  apply Equiv.ext
+  intro x
+  simp only [Equiv.Perm.mul_apply]
+  exact (α.injective.swap_apply p q (σ x)).symm
+/-- The global sphere Euler lower bound is preserved when one boundary cycle
+is split at two distinct positions. This finite statement does not identify
+which realized component contains the outer disk in a self-band surgery. -/
+theorem split_euler (hpq : p≠q) (h : cycle σ p=cycle σ q)
+    (he : Fintype.card O+4≤2*Fintype.card (Cycle σ)+2*Fintype.card (Cycle (α*σ))) :
+    Fintype.card O+4≤2*Fintype.card (Cycle (Equiv.swap p q*σ))+
+      2*Fintype.card (Cycle (α*(Equiv.swap p q*σ))) := by
+  have hv := split_count σ p q hpq h
+  have hf := count_le (α*σ) (α p) (α q)
+  rw [face_switch,hv]
+  omega
+end
+
+open scoped Classical
+open PermutationCycles
+variable {O : Type} [Fintype O] (f : Equiv.Perm O) (p q : O)
+/-- Switching two distinct cycles joins the two selected positions in one
+actual new cycle. The witness follows the old cycle up to its first return. -/
+lemma merge_same (h : cycle f p≠cycle f q) :
+    (Equiv.swap p q*f).SameCycle p q := by
+  have hp : ∃n : ℕ,0<n ∧ (f^n) p=p :=
+    ⟨orderOf f,orderOf_pos f,by rw [pow_orderOf_eq_one];rfl⟩
+  let n := Nat.find hp
+  have hn : 0<n ∧ (f^n) p=p := Nat.find_spec hp
+  have hmin : ∀k,0<k → k<n → (f^k) p≠p := by
+    intro k hk hkn he
+    have hh := Nat.find_min' hp ⟨hk,he⟩
+    omega
+  have no_q (k : ℕ) : (f^k) p≠q := by
+    intro he
+    exact h ((cycle_eq f).mpr ⟨(k:ℤ),by simpa only [zpow_natCast] using he⟩)
+  have heq : ∀k,k<n → ((Equiv.swap p q*f)^k) p=(f^k) p := by
+    intro k
+    induction k with
+    | zero => intro _;rfl
+    | succ k ih =>
+      intro hk
+      rw [pow_succ',Equiv.Perm.mul_apply,ih (by omega),Equiv.Perm.mul_apply]
+      have hf : f ((f^k) p)=(f^(k+1)) p := by rw [pow_succ',Equiv.Perm.mul_apply]
+      rw [hf,Equiv.swap_apply_of_ne_of_ne (hmin _ (by omega) hk) (no_q _)]
+  obtain ⟨m,hm⟩ := Nat.exists_eq_succ_of_ne_zero (by omega : n≠0)
+  refine ⟨(n:ℤ),?_⟩
+  rw [zpow_natCast,hm,pow_succ',Equiv.Perm.mul_apply,heq m (by omega),Equiv.Perm.mul_apply]
+  have he : f ((f^m) p)=p := by
+    rw [←Equiv.Perm.mul_apply,←pow_succ']
+    simpa only [hm, Nat.succ_eq_add_one] using hn.2
+  rw [he,Equiv.swap_apply_left]
+
+lemma merge_count (h : cycle f p≠cycle f q) :
+    Fintype.card (Cycle (Equiv.swap p q*f))+1=Fintype.card (Cycle f) := by
+  have hpq : p≠q := by intro he;exact h (he ▸ rfl)
+  have hh := split_count (Equiv.swap p q*f) p q hpq ((cycle_eq _).mpr (merge_same f p q h))
+  simpa only [←mul_assoc,Equiv.swap_mul_self,one_mul] using hh.symm
+end TorsionFreeZeroDivisors.SwapCycles
+
+namespace TorsionFreeZeroDivisors.ComponentEuler
+open scoped Classical
+open PermutationCycles SwapCycles
+variable {O : Type} [Fintype O]
+
+def Refines (f g : Equiv.Perm O) : Prop := ∀x y,cycle f x=cycle f y → cycle g x=cycle g y
+lemma refines_of_invariant (f g : Equiv.Perm O) (h : ∀x,cycle g (f x)=cycle g x) : Refines f g := by
+  intro x y hxy
+  exact congrArg (lift f (cycle g) h) hxy
+
+lemma merge_refines (f : Equiv.Perm O) (p q : O) (h : cycle f p≠cycle f q) :
+    Refines f (Equiv.swap p q*f) := by
+  apply refines_of_invariant
+  intro x
+  have hs : cycle (Equiv.swap p q*f) p=cycle (Equiv.swap p q*f) q :=
+    (cycle_eq _).mpr (merge_same f p q h)
+  calc
+    cycle (Equiv.swap p q*f) (f x)=cycle (Equiv.swap p q*f) (Equiv.swap p q ((Equiv.swap p q*f) x)) := by simp
+    _ = cycle (Equiv.swap p q*f) ((Equiv.swap p q*f) x) := cycle_swap _ p q hs _
+    _ = cycle (Equiv.swap p q*f) x := cycle_apply _ _
+
+def merge (f : Equiv.Perm O) (p q : O) : Equiv.Perm O :=
+  if cycle f p=cycle f q then f else Equiv.swap p q*f
+lemma merge_refines' (f : Equiv.Perm O) (p q : O) : Refines f (merge f p q) := by
+  by_cases h : cycle f p=cycle f q
+  · simp only [merge,ite_eq_left h];exact fun _ _ h=>h
+  · simp only [merge,ite_eq_right h];exact merge_refines f p q h
+lemma merge_pair (f : Equiv.Perm O) (p q : O) : cycle (merge f p q) p=cycle (merge f p q) q := by
+  by_cases h : cycle f p=cycle f q
+  · rw [merge,ite_eq_left h]; exact h
+  · rw [merge,ite_eq_right h]; exact (cycle_eq _).mpr (merge_same f p q h)
+
+def forest (σ : Equiv.Perm O) : List (O×O) → Equiv.Perm O
+  | []=>σ
+  | e::l=>merge (forest σ l) e.1 e.2
+def face (σ : Equiv.Perm O) : List (O×O) → Equiv.Perm O
+  | []=>σ
+  | e::l=>Equiv.swap e.1 e.2*face σ l
+lemma face_invariant (σ : Equiv.Perm O) (l : List (O×O)) (x : O) :
+    cycle (forest σ l) (face σ l x)=cycle (forest σ l) x := by
+  induction l with
+  | nil=>exact cycle_apply σ x
+  | cons e l ih=>
+    change cycle (merge (forest σ l) e.1 e.2) (Equiv.swap e.1 e.2 (face σ l x))=_
+    rw [cycle_swap _ _ _ (merge_pair _ _ _)]
+    exact merge_refines' _ _ _ _ _ ih
+lemma face_refines (σ : Equiv.Perm O) (l : List (O×O)) : Refines (face σ l) (forest σ l) :=
+  refines_of_invariant _ _ (face_invariant σ l)
+
+/-- Euler's upper bound for the actual component partition formed by gluing
+listed bands. The forest permutation is a computed partition, not a planar input. -/
+theorem upper (σ : Equiv.Perm O) (l : List (O×O)) :
+    Nat.card (Cycle σ)+Nat.card (Cycle (face σ l))≤
+      l.length+2*Nat.card (Cycle (forest σ l)) := by
+  induction l with
+  | nil=>simp only [face,forest,List.length_nil];omega
+  | cons e l ih=>
+    by_cases h : cycle (forest σ l) e.1=cycle (forest σ l) e.2
+    · have hf := count_reverse (face σ l) e.1 e.2
+      simp only [face,forest,merge,ite_eq_left h,List.length_cons]
+      simp only [←Nat.card_eq_fintype_card] at *
+      omega
+    · have hc := merge_count (forest σ l) e.1 e.2 h
+      have hn : cycle (face σ l) e.1≠cycle (face σ l) e.2 := fun hh=>h (face_refines σ l _ _ hh)
+      have hf := merge_count (face σ l) e.1 e.2 hn
+      simp only [face,forest,merge,ite_eq_right h,List.length_cons]
+      simp only [←Nat.card_eq_fintype_card] at *
+      omega
+lemma forest_refines (σ : Equiv.Perm O) (l : List (O×O)) : Refines σ (forest σ l) := by
+  induction l with
+  | nil=>exact fun _ _ h=>h
+  | cons e l ih=>exact fun x y h=>merge_refines' (forest σ l) e.1 e.2 x y (ih x y h)
+lemma forest_pair (σ : Equiv.Perm O) (l : List (O×O)) (e : O×O) (he : e∈l) :
+    cycle (forest σ l) e.1=cycle (forest σ l) e.2 := by
+  induction l with
+  | nil=>simp at he
+  | cons a l ih=>
+    rcases List.mem_cons.mp he with rfl|he
+    · exact merge_pair _ _ _
+    · exact merge_refines' _ _ _ _ _ (ih he)
+
+def Edge (σ : Equiv.Perm O) (l : List (O×O)) (x y : O) : Prop :=
+  σ x=y ∨ (x,y)∈l
+abbrev Component (σ : Equiv.Perm O) (l : List (O×O)) := Quotient (Relation.EqvGen.setoid (Edge σ l))
+def component (σ : Equiv.Perm O) (l : List (O×O)) (x : O) : Component σ l := Quotient.mk _ x
+lemma forest_of_component (σ : Equiv.Perm O) (l : List (O×O)) {x y : O}
+    (h : component σ l x=component σ l y) : cycle (forest σ l) x=cycle (forest σ l) y := by
+  have hxy : Relation.EqvGen (Edge σ l) x y := Quotient.exact h
+  clear h
+  induction hxy with
+  | rel x y h=>
+    rcases h with h|h
+    · exact forest_refines σ l x y (by rw [←h,cycle_apply])
+    · exact forest_pair σ l (x,y) h
+  | refl=>rfl
+  | symm _ _ _ ih=>exact ih.symm
+  | trans _ _ _ _ _ ih ih'=>exact ih.trans ih'
+
+omit [Fintype O] in
+lemma invariant_forest {B : Type} (σ : Equiv.Perm O) (l : List (O×O)) (q : O→B)
+    (hσ : ∀x,q (σ x)=q x) (hl : ∀e∈l,q e.1=q e.2) : ∀x,q (forest σ l x)=q x := by
+  induction l with
+  | nil=>exact hσ
+  | cons e l ih=>
+    have he := hl e (List.mem_cons_self)
+    have hi := ih (fun a ha=>hl a (List.mem_cons_of_mem _ ha))
+    intro x
+    change q (merge (forest σ l) e.1 e.2 x)=q x
+    dsimp only [merge]
+    split
+    · exact hi x
+    · change q (Equiv.swap e.1 e.2 (forest σ l x))=q x
+      have hs : ∀z,q (Equiv.swap e.1 e.2 z)=q z := by
+        intro z
+        by_cases hz : z=e.1
+        · subst z;rw [Equiv.swap_apply_left];exact he.symm
+        · by_cases hz' : z=e.2
+          · subst z;rw [Equiv.swap_apply_right];exact he
+          · rw [Equiv.swap_apply_of_ne_of_ne hz hz']
+      rw [hs,hi]
+omit [Fintype O] in
+lemma component_invariant (σ : Equiv.Perm O) (l : List (O×O)) (x : O) :
+    component σ l (forest σ l x)=component σ l x := by
+  apply invariant_forest σ l
+  · intro y
+    exact Quotient.sound (Relation.EqvGen.symm _ _ (Relation.EqvGen.rel _ _ (Or.inl rfl)))
+  · intro e he
+    exact Quotient.sound (Relation.EqvGen.rel _ _ (Or.inr (by simpa using he)))
+lemma component_of_forest (σ : Equiv.Perm O) (l : List (O×O)) {x y : O}
+    (h : cycle (forest σ l) x=cycle (forest σ l) y) : component σ l x=component σ l y :=
+  congrArg (lift (forest σ l) (component σ l) (component_invariant σ l)) h
+
+def componentEquiv (σ : Equiv.Perm O) (l : List (O×O)) : Cycle (forest σ l) ≃ Component σ l :=
+  Equiv.ofBijective (lift (forest σ l) (component σ l) (component_invariant σ l)) ⟨by
+    intro a b he
+    obtain ⟨x,rfl⟩ := cycle_surjective (forest σ l) a
+    obtain ⟨y,rfl⟩ := cycle_surjective (forest σ l) b
+    exact forest_of_component σ l he,
+    lift_surjective _ _ _ Quotient.mk_surjective⟩
+lemma upper_components (σ : Equiv.Perm O) (l : List (O×O)) :
+    Nat.card (Cycle σ)+Nat.card (Cycle (face σ l))≤l.length+2*Nat.card (Component σ l) := by
+  have h := upper σ l
+  rw [Nat.card_congr (componentEquiv σ l)] at h
+  exact h
+lemma connected_upper (σ : Equiv.Perm O) (l : List (O×O))
+    (hc : ∀x y,Relation.EqvGen (Edge σ l) x y) :
+    Nat.card (Cycle σ)+Nat.card (Cycle (face σ l))≤l.length+2 := by
+  let : Subsingleton (Component σ l) := ⟨by
+    intro a b
+    obtain ⟨x,rfl⟩ := Quotient.mk_surjective a
+    obtain ⟨y,rfl⟩ := Quotient.mk_surjective b
+    exact Quotient.sound (hc x y)⟩
+  have hh : Nat.card (Component σ l)≤1 := (Finite.card_le_one_iff_subsingleton).mpr inferInstance
+  have := upper_components σ l
+  omega
+end TorsionFreeZeroDivisors.ComponentEuler
+
+namespace TorsionFreeZeroDivisors.PairingFactors
+open scoped Classical
+variable {O : Type} [Fintype O] (α : Equiv.Perm O) (hi : Function.Involutive α) (p : O)
+def strip : Equiv.Perm O := Equiv.swap p (α p)*α
+omit [Fintype O] in
+lemma strip_p : strip α p p=p := by simp [strip]
+omit [Fintype O] in
+include hi in
+lemma strip_q : strip α p (α p)=α p := by simp only [strip,Equiv.Perm.mul_apply,hi p,Equiv.swap_apply_left]
+omit [Fintype O] in
+include hi in
+lemma strip_away (x : O) (hp : x≠p) (hq : x≠α p) : strip α p x=α x := by
+  have hxp : α x≠p := by intro h;exact hq ((hi x).symm.trans (congrArg α h))
+  have hxq : α x≠α p := α.injective.ne hp
+  exact Equiv.swap_apply_of_ne_of_ne hxp hxq
+omit [Fintype O] in
+include hi in
+lemma strip_involutive : Function.Involutive (strip α p) := by
+  intro x
+  by_cases hp : x=p
+  · subst x;rw [strip_p,strip_p]
+  · by_cases hq : x=α p
+    · subst x;rw [strip_q α hi p,strip_q α hi p]
+    · rw [strip_away α hi p x hp hq,strip_away α hi p (α x)]
+      · exact hi x
+      · intro h;exact hq ((hi x).symm.trans (congrArg α h))
+      · exact α.injective.ne hp
+include hi in
+lemma strip_support : (strip α p).support=α.support\{p,α p} := by
+  ext x
+  simp only [Finset.mem_sdiff,Finset.mem_insert,Finset.mem_singleton,not_or,Equiv.Perm.mem_support]
+  constructor
+  · intro h
+    have hp : x≠p := by intro he;subst x;exact h (strip_p α p)
+    have hq : x≠α p := by intro he;subst x;exact h (strip_q α hi p)
+    exact ⟨by rwa [strip_away α hi p x hp hq] at h,hp,hq⟩
+  · rintro ⟨h,hp,hq⟩
+    rwa [strip_away α hi p x hp hq]
+include hi in
+lemma strip_card (hp : α p≠p) : (strip α p).support.card+2=α.support.card := by
+  rw [strip_support α hi p,Finset.card_sdiff_of_subset]
+  · have hc : ({p,α p} : Finset O).card=2 := by simp [Ne.symm hp]
+    have hs : {p,α p}⊆α.support := by
+      intro x hx
+      simp only [Finset.mem_insert,Finset.mem_singleton] at hx
+      rcases hx with rfl|rfl
+      · exact Equiv.Perm.mem_support.mpr hp
+      · exact Equiv.Perm.mem_support.mpr (by rw [hi];exact Ne.symm hp)
+    have hh := Finset.card_le_card hs
+    rw [hc] at *
+    omega
+  · intro x hx
+    simp only [Finset.mem_insert,Finset.mem_singleton] at hx
+    rcases hx with rfl|rfl
+    · exact Equiv.Perm.mem_support.mpr hp
+    · exact Equiv.Perm.mem_support.mpr (by rw [hi];exact Ne.symm hp)
+
+include hi in
+/-- Every finite involution is literally a product of its own nontrivial
+paired-edge swaps, with exactly one factor for each pair. -/
+theorem factorization : ∃l : List (O×O),
+    (l.map (fun e=>Equiv.swap e.1 e.2)).prod=α ∧
+      2*l.length=α.support.card ∧ ∀e∈l,e.1≠e.2 ∧ α e.1=e.2 := by
+  generalize hn : α.support.card=n
+  induction n using Nat.strong_induction_on generalizing α with
+  | h n ih=>
+    by_cases hn0 : n=0
+    · have hs : α.support=∅ := Finset.card_eq_zero.mp (hn.trans hn0)
+      have ha : α=1 := Equiv.Perm.support_eq_empty_iff.mp hs
+      refine ⟨[],?_,by simp [←hn,hs],by simp⟩
+      simpa using ha.symm
+    · obtain ⟨p,hp⟩ := Finset.card_pos.mp (by omega : 0<α.support.card)
+      have hp' := Equiv.Perm.mem_support.mp hp
+      have hc := strip_card α hi p hp'
+      obtain ⟨l,hl,hL,hedge⟩ := ih (strip α p).support.card (by omega)
+        (strip α p) (strip_involutive α hi p) rfl
+      refine ⟨(p,α p)::l,?_,?_,?_⟩
+      · simp only [List.map_cons,List.prod_cons,hl,strip]
+        rw [←mul_assoc,Equiv.swap_mul_self,one_mul]
+      · simp only [List.length_cons]
+        omega
+      · intro e he
+        rcases List.mem_cons.mp he with rfl|he
+        · exact ⟨Ne.symm hp',rfl⟩
+        · obtain ⟨hne,heq⟩ := hedge e he
+          have hep : e.1≠p := by
+            intro hh
+            have hy : e.2=p := (heq.symm.trans (congrArg (strip α p) hh)).trans (strip_p α p)
+            exact hne (hh.trans hy.symm)
+          have heq' : e.1≠α p := by
+            intro hh
+            have hy : e.2=α p := (heq.symm.trans (congrArg (strip α p) hh)).trans (strip_q α hi p)
+            exact hne (hh.trans hy.symm)
+          exact ⟨hne,(strip_away α hi p e.1 hep heq').symm.trans heq⟩
+end TorsionFreeZeroDivisors.PairingFactors
+namespace TorsionFreeZeroDivisors.MapEuler
+open scoped Classical
+open PermutationCycles ComponentEuler
+variable {O : Type} [Fintype O]
+omit [Fintype O] in
+lemma product_invariant {B : Type} (l : List (O×O)) (q : O→B)
+    (hl : ∀e∈l,q e.1=q e.2) (x : O) :
+    q ((l.map (fun e=>Equiv.swap e.1 e.2)).prod x)=q x := by
+  induction l with
+  | nil=>rfl
+  | cons e l ih=>
+    have he := hl e List.mem_cons_self
+    have hi := ih (fun a ha=>hl a (List.mem_cons_of_mem _ ha))
+    simp only [List.map_cons,List.prod_cons,Equiv.Perm.mul_apply]
+    have hs : ∀z,q (Equiv.swap e.1 e.2 z)=q z := by
+      intro z
+      by_cases hz : z=e.1
+      · subst z;rw [Equiv.swap_apply_left];exact he.symm
+      · by_cases hz' : z=e.2
+        · subst z;rw [Equiv.swap_apply_right];exact he
+        · rw [Equiv.swap_apply_of_ne_of_ne hz hz']
+    rw [hs,hi]
+omit [Fintype O] in
+lemma face_product (σ : Equiv.Perm O) (l : List (O×O)) :
+    face σ l=(l.map (fun e=>Equiv.swap e.1 e.2)).prod*σ := by
+  induction l with
+  | nil=>simp [face]
+  | cons e l ih=>simp only [face,List.map_cons,List.prod_cons,ih,mul_assoc]
+
+def Edge (σ α : Equiv.Perm O) (x y : O) : Prop := σ x=y ∨ α x=y
+abbrev Component (σ α : Equiv.Perm O) := Quotient (Relation.EqvGen.setoid (Edge σ α))
+def component (σ α : Equiv.Perm O) (x : O) : Component σ α := Quotient.mk _ x
+variable (σ α : Equiv.Perm O) (l : List (O×O))
+    (hl : (l.map (fun e=>Equiv.swap e.1 e.2)).prod=α)
+    (he : ∀e∈l,α e.1=e.2)
+omit [Fintype O] in
+include he in
+lemma component_forest (x : O) : component σ α (forest σ l x)=component σ α x := by
+  apply invariant_forest σ l
+  · intro y
+    exact Quotient.sound (Relation.EqvGen.symm _ _ (Relation.EqvGen.rel _ _ (Or.inl rfl)))
+  · intro e h
+    exact Quotient.sound (Relation.EqvGen.rel _ _ (Or.inr (he e h)))
+include hl in
+lemma forest_alpha (x : O) : cycle (forest σ l) (α x)=cycle (forest σ l) x := by
+  rw [←hl]
+  exact product_invariant l (cycle (forest σ l)) (forest_pair σ l) x
+include hl in
+lemma forest_component {x y : O} (h : component σ α x=component σ α y) :
+    cycle (forest σ l) x=cycle (forest σ l) y := by
+  have hxy : Relation.EqvGen (Edge σ α) x y := Quotient.exact h
+  clear h
+  induction hxy with
+  | rel x y h=>
+    rcases h with h|h
+    · exact forest_refines σ l x y (by rw [←h,cycle_apply])
+    · rw [←h,forest_alpha σ α l hl]
+  | refl=>rfl
+  | symm _ _ _ ih=>exact ih.symm
+  | trans _ _ _ _ _ ih ih'=>exact ih.trans ih'
+
+def componentEquiv : Cycle (forest σ l) ≃ Component σ α :=
+  Equiv.ofBijective (lift (forest σ l) (component σ α) (component_forest σ α l he)) ⟨by
+    intro a b hh
+    obtain ⟨x,rfl⟩ := cycle_surjective (forest σ l) a
+    obtain ⟨y,rfl⟩ := cycle_surjective (forest σ l) b
+    exact forest_component σ α l hl hh,
+    lift_surjective _ _ _ Quotient.mk_surjective⟩
+include hl he in
+lemma upper_factors : Nat.card (Cycle σ)+Nat.card (Cycle (α*σ))≤l.length+2*Nat.card (Component σ α) := by
+  have hh := upper σ l
+  rw [face_product,hl,Nat.card_congr (componentEquiv σ α l hl he)] at hh
+  exact hh
+
+/-- Every finite orientable permutation map obeys the Euler upper bound. This
+uses only its actual involution and actual connected-component equivalence;
+no topological realization or Euler inequality is assumed. -/
+theorem upper (hi : Function.Involutive α) :
+    2*Nat.card (Cycle σ)+2*Nat.card (Cycle (α*σ))≤α.support.card+4*Nat.card (Component σ α) := by
+  obtain ⟨l,hl,hL,he⟩ := PairingFactors.factorization α hi
+  have hh := upper_factors σ α l hl (fun e h=>(he e h).2)
+  omega
+lemma fixedFree_upper (hi : Function.Involutive α) (hf : ∀x,α x≠x) :
+    2*Nat.card (Cycle σ)+2*Nat.card (Cycle (α*σ))≤Nat.card O+4*Nat.card (Component σ α) := by
+  have hs : α.support=Finset.univ := by ext x;simp [Equiv.Perm.mem_support,hf]
+  have hh := upper σ α hi
+  simpa only [hs,Finset.card_univ,←Nat.card_eq_fintype_card] using hh
+lemma connected_upper (hi : Function.Involutive α) (hf : ∀x,α x≠x)
+    (hc : ∀x y,Relation.EqvGen (Edge σ α) x y) :
+    2*Nat.card (Cycle σ)+2*Nat.card (Cycle (α*σ))≤Nat.card O+4 := by
+  let : Subsingleton (Component σ α) := ⟨by
+    intro a b
+    obtain ⟨x,rfl⟩ := Quotient.mk_surjective a
+    obtain ⟨y,rfl⟩ := Quotient.mk_surjective b
+    exact Quotient.sound (hc x y)⟩
+  have hh : Nat.card (Component σ α)≤1 := Finite.card_le_one_iff_subsingleton.mpr inferInstance
+  have := fixedFree_upper σ α hi hf
+  omega
+end TorsionFreeZeroDivisors.MapEuler
+namespace TorsionFreeZeroDivisors.ComponentEuler
+open scoped Classical
+open PermutationCycles SwapCycles
+variable {O : Type} [Fintype O]
+/-- A handle is precisely an edge whose endpoints are already in one component
+but which merges two distinct face cycles when glued. -/
+def handles (σ : Equiv.Perm O) : List (O×O) → ℕ
+  | []=>0
+  | e::l=>handles σ l+if cycle (forest σ l) e.1=cycle (forest σ l) e.2 ∧
+      cycle (face σ l) e.1≠cycle (face σ l) e.2 then 1 else 0
+omit [Fintype O] in
+lemma handles_tail (σ : Equiv.Perm O) (e : O×O) (l : List (O×O)) : handles σ l≤handles σ (e::l) := by
+  simp only [handles];omega
+lemma handles_exact (σ : Equiv.Perm O) (l : List (O×O)) (hd : ∀e∈l,e.1≠e.2) :
+    Nat.card (Cycle σ)+Nat.card (Cycle (face σ l))+2*handles σ l=
+      l.length+2*Nat.card (Cycle (forest σ l)) := by
+  induction l with
+  | nil=>simp only [face,forest,handles,List.length_nil];omega
+  | cons e l ih=>
+    have he := hd e List.mem_cons_self
+    have hh := ih (fun a ha=>hd a (List.mem_cons_of_mem _ ha))
+    by_cases hc : cycle (forest σ l) e.1=cycle (forest σ l) e.2
+    · by_cases hf : cycle (face σ l) e.1=cycle (face σ l) e.2
+      · have hg := split_count (face σ l) e.1 e.2 he hf
+        simp only [←Nat.card_eq_fintype_card] at hg
+        have hn : ¬(cycle (forest σ l) e.1=cycle (forest σ l) e.2 ∧
+            cycle (face σ l) e.1≠cycle (face σ l) e.2) := fun h=>h.2 hf
+        simp only [face,forest,merge,ite_eq_left hc,handles,ite_eq_right hn,List.length_cons]
+        omega
+      · have hg := merge_count (face σ l) e.1 e.2 hf
+        simp only [←Nat.card_eq_fintype_card] at hg
+        simp only [face,forest,merge,ite_eq_left hc,handles,ite_eq_left (And.intro hc hf),List.length_cons]
+        omega
+    · have hn : cycle (face σ l) e.1≠cycle (face σ l) e.2 := fun hh=>hc (face_refines σ l _ _ hh)
+      have hg := merge_count (face σ l) e.1 e.2 hn
+      have hj := merge_count (forest σ l) e.1 e.2 hc
+      simp only [←Nat.card_eq_fintype_card] at hg hj
+      have hn' : ¬(cycle (forest σ l) e.1=cycle (forest σ l) e.2 ∧
+          cycle (face σ l) e.1≠cycle (face σ l) e.2) := fun h=>hc h.1
+      simp only [face,forest,merge,ite_eq_right hc,handles,ite_eq_right hn',List.length_cons]
+      omega
+lemma zero_handles (σ : Equiv.Perm O) (l : List (O×O)) (hd : ∀e∈l,e.1≠e.2)
+    (he : l.length+2*Nat.card (Component σ l)≤Nat.card (Cycle σ)+Nat.card (Cycle (face σ l))) :
+    handles σ l=0 := by
+  have hh := handles_exact σ l hd
+  rw [Nat.card_congr (componentEquiv σ l)] at hh
+  omega
+end TorsionFreeZeroDivisors.ComponentEuler
+namespace TorsionFreeZeroDivisors.MapEuler
+open scoped Classical
+open PermutationCycles ComponentEuler
+variable {O : Type} [Fintype O] (σ α : Equiv.Perm O)
+/-- Combinatorial genus zero, including disconnected maps and isolated darts.
+This is a definition in permutation data, not an asserted sphere embedding. -/
+def GenusZero : Prop :=
+  2*Nat.card (Cycle σ)+2*Nat.card (Cycle (α*σ))=α.support.card+4*Nat.card (Component σ α)
+lemma genusZero_of_lower (hi : Function.Involutive α)
+    (h : α.support.card+4*Nat.card (Component σ α)≤2*Nat.card (Cycle σ)+2*Nat.card (Cycle (α*σ))) :
+    GenusZero σ α := Nat.le_antisymm h (upper σ α hi) |>.symm
+lemma genusZero_iff_handles (l : List (O×O))
+    (hl : (l.map (fun e=>Equiv.swap e.1 e.2)).prod=α)
+    (hd : ∀e∈l,e.1≠e.2 ∧ α e.1=e.2) (hL : 2*l.length=α.support.card) :
+    GenusZero σ α ↔ handles σ l=0 := by
+  have hh := handles_exact σ l (fun e he=>(hd e he).1)
+  rw [face_product,hl,Nat.card_congr (componentEquiv σ α l hl (fun e he=>(hd e he).2))] at hh
+  dsimp only [GenusZero]
+  omega
+end TorsionFreeZeroDivisors.MapEuler
+namespace TorsionFreeZeroDivisors.PairingFactors
+open scoped Classical
+variable {O : Type} (α : Equiv.Perm O) (hi : Function.Involutive α) (p : O)
+include hi in
+lemma strip_edge {x y : O} (hne : x≠y) (he : strip α p x=y) : α x=y := by
+  have hxp : x≠p := by
+    intro hx
+    have hy : y=p := (he.symm.trans (congrArg (strip α p) hx)).trans (strip_p α p)
+    exact hne (hx.trans hy.symm)
+  have hxq : x≠α p := by
+    intro hx
+    have hy : y=α p := (he.symm.trans (congrArg (strip α p) hx)).trans (strip_q α hi p)
+    exact hne (hx.trans hy.symm)
+  exact (strip_away α hi p x hxp hxq).symm.trans he
+end TorsionFreeZeroDivisors.PairingFactors
+namespace TorsionFreeZeroDivisors.MapEuler
+open scoped Classical
+open PermutationCycles ComponentEuler PairingFactors
+variable {O : Type} [Fintype O] (σ α : Equiv.Perm O) (hi : Function.Involutive α)
+include hi in
+/-- Deleting an actual paired edge cannot create a handle in any component. -/
+lemma genusZero_strip (hz : GenusZero σ α) (p : O) (hp : α p≠p) : GenusZero σ (strip α p) := by
+  obtain ⟨l,hl,hL,he⟩ := factorization (strip α p) (strip_involutive α hi p)
+  have he' : ∀e∈(p,α p)::l,e.1≠e.2 ∧ α e.1=e.2 := by
+    intro e hm
+    rcases List.mem_cons.mp hm with rfl|hm
+    · exact ⟨Ne.symm hp,rfl⟩
+    · exact ⟨(he e hm).1,strip_edge α hi p (he e hm).1 (he e hm).2⟩
+  have hl' : (((p,α p)::l).map (fun e=>Equiv.swap e.1 e.2)).prod=α := by
+    simp only [List.map_cons,List.prod_cons,hl,strip]
+    rw [←mul_assoc,Equiv.swap_mul_self,one_mul]
+  have hL' : 2*((p,α p)::l).length=α.support.card := by
+    have hc := strip_card α hi p hp
+    simp only [List.length_cons]
+    omega
+  have hh := (genusZero_iff_handles σ α ((p,α p)::l) hl' he' hL').mp hz
+  have ht : handles σ l=0 := Nat.eq_zero_of_le_zero ((handles_tail σ (p,α p) l).trans_eq hh)
+  exact (genusZero_iff_handles σ (strip α p) l hl he hL).mpr ht
+omit [Fintype O] in
+include hi in
+lemma dual_rel {x y : O} (h : Relation.EqvGen (Edge σ α) x y) :
+    Relation.EqvGen (Edge (α*σ) α) x y := by
+  induction h with
+  | rel x y h=>
+    rcases h with hs|ha
+    · exact Relation.EqvGen.trans x ((α*σ) x) y
+        (Relation.EqvGen.rel _ _ (Or.inl rfl))
+        (Relation.EqvGen.rel _ _ (Or.inr (by rw [Equiv.Perm.mul_apply,hi];exact hs)))
+    · exact Relation.EqvGen.rel _ _ (Or.inr ha)
+  | refl=>exact Relation.EqvGen.refl _
+  | symm _ _ _ ih=>exact Relation.EqvGen.symm _ _ ih
+  | trans _ _ _ _ _ ih ih'=>exact Relation.EqvGen.trans _ _ _ ih ih'
+omit [Fintype O] in
+include hi in
+lemma dual_twice : α*(α*σ)=σ := by
+  ext x
+  exact hi (σ x)
+def dualEquiv : Component σ α ≃ Component (α*σ) α := Quotient.congrRight (fun x y=>⟨
+  dual_rel σ α hi,fun h=>by
+    have hh := dual_rel (α*σ) α hi h
+    rwa [dual_twice σ α hi] at hh⟩)
+include hi in
+lemma genusZero_dual : GenusZero σ α ↔ GenusZero (α*σ) α := by
+  have hc := Nat.card_congr (dualEquiv σ α hi)
+  simp only [GenusZero,dual_twice σ α hi]
+  omega
+include hi in
+/-- The actual band splice preserves componentwise combinatorial genus zero,
+prior to bypassing its two now-unpaired occurrences. Both the merge and the
+split vertex cases are covered by dual edge deletion. -/
+theorem genusZero_band (hz : GenusZero σ α) (p : O) (hp : α p≠p) :
+    GenusZero (Equiv.swap p (α p)*σ) (strip α p) := by
+  have hd := (genusZero_dual σ α hi).mp hz
+  have hs := genusZero_strip (α*σ) α hi hd p hp
+  have hh := (genusZero_dual (α*σ) (strip α p) (strip_involutive α hi p)).mp hs
+  have he : strip α p*(α*σ)=Equiv.swap p (α p)*σ := by
+    rw [strip,mul_assoc,dual_twice σ α hi]
+  rwa [he] at hh
+end TorsionFreeZeroDivisors.MapEuler
+
+namespace TorsionFreeZeroDivisors.DeleteCycle
+
+section
+open scoped Classical
+open PermutationCycles
+variable {O : Type} (f : Equiv.Perm O) (p : O)
+abbrev Rest := {x : O // x ≠ p}
+lemma invariant (h : f p=p) (x : O) : f x ≠ p ↔ x ≠ p := by
+  constructor
+  · intro hx he; exact hx (he ▸ h)
+  · intro hx he; exact hx (f.injective (he.trans h.symm))
+def restrict (h : f p=p) : Equiv.Perm (Rest p) := f.subtypePerm (invariant f p h)
+lemma restrict_pow (h : f p=p) (x : Rest p) (k : ℕ) :
+    ((restrict f p h ^ k) x).val=(f^k) x := by
+  simp only [restrict,Equiv.Perm.subtypePerm_pow,Equiv.Perm.subtypePerm_apply]
+variable [Fintype O]
+lemma restrict_same (h : f p=p) (x y : Rest p) :
+    (restrict f p h).SameCycle x y ↔ f.SameCycle x y := by
+  constructor
+  · intro hs
+    obtain ⟨k,hk⟩ := hs.exists_nat_pow_eq
+    refine ⟨(k:ℤ),?_⟩
+    rw [zpow_natCast]
+    exact (restrict_pow f p h x k).symm.trans (congrArg Subtype.val hk)
+  · intro hs
+    obtain ⟨k,hk⟩ := hs.exists_nat_pow_eq
+    refine ⟨(k:ℤ),?_⟩
+    rw [zpow_natCast]
+    apply Subtype.ext
+    exact (restrict_pow f p h x k).trans hk
+
+def classify (h : f p=p) (x : O) : Option (Cycle (restrict f p h)) :=
+  if hx : x=p then none else some (cycle (restrict f p h) ⟨x,hx⟩)
+omit [Fintype O] in
+lemma classify_apply (h : f p=p) (x : O) : classify f p h (f x)=classify f p h x := by
+  by_cases hx : x=p
+  · subst x; rw [h]
+  · have hfx := (invariant f p h x).mpr hx
+    rw [classify,dite_eq_right hfx,classify,dite_eq_right hx]
+    apply congrArg some
+    exact cycle_apply (restrict f p h) ⟨x,hx⟩
+omit [Fintype O] in
+lemma classify_surjective (h : f p=p) : Function.Surjective (classify f p h) := by
+  intro c
+  cases c with
+  | none => exact ⟨p,by simp [classify]⟩
+  | some c =>
+    obtain ⟨x,rfl⟩ := cycle_surjective (restrict f p h) c
+    exact ⟨x,by simp [classify,x.property]⟩
+lemma classify_eq (h : f p=p) {x y : O} (he : classify f p h x=classify f p h y) : f.SameCycle x y := by
+  by_cases hx : x=p
+  · subst x
+    have hy : y=p := by
+      by_contra hy
+      simp [classify,hy] at he
+    subst y
+    exact Equiv.Perm.SameCycle.refl _ _
+  · by_cases hy : y=p
+    · subst y; simp [classify,hx] at he
+    · simp only [classify,dite_eq_right hx,dite_eq_right hy,Option.some.injEq] at he
+      exact (restrict_same f p h ⟨x,hx⟩ ⟨y,hy⟩).mp ((cycle_eq _).mp he)
+def cycleEquiv (h : f p=p) : Cycle f ≃ Option (Cycle (restrict f p h)) :=
+  Equiv.ofBijective (lift f (classify f p h) (classify_apply f p h)) ⟨by
+    intro c d he
+    obtain ⟨x,rfl⟩ := cycle_surjective f c
+    obtain ⟨y,rfl⟩ := cycle_surjective f d
+    exact (cycle_eq f).mpr (classify_eq f p h he),
+    lift_surjective f _ _ (classify_surjective f p h)⟩
+lemma fixed_count (h : f p=p) :
+    Fintype.card (Cycle f)=Fintype.card (Cycle (restrict f p h))+1 := by
+  simpa only [Fintype.card_option] using Fintype.card_congr (cycleEquiv f p h)
+
+/-- Delete an occurrence by bypassing it in its boundary cycle. -/
+def bypass : Equiv.Perm (Rest p) := restrict (Equiv.swap p (f p)*f) p (SwapCycles.adjacent_fixed f p)
+lemma bypass_count (h : f p≠p) : Fintype.card (Cycle (bypass f p))=Fintype.card (Cycle f) := by
+  have h₁ := fixed_count (Equiv.swap p (f p)*f) p (SwapCycles.adjacent_fixed f p)
+  have h₂ := SwapCycles.adjacent_count f p h
+  change _=Fintype.card (Cycle (bypass f p))+1 at h₁
+  omega
+end
+open scoped Classical
+open PermutationCycles
+variable {O : Type} (f : Equiv.Perm O) (p : O)
+lemma bypass_apply [Fintype O] (x : Rest p) :
+    (bypass f p x).val=Equiv.swap p (f p) (f x) := rfl
+/-- Bypassing a point commutes with a left permutation fixing that point. -/
+lemma bypass_mul [Fintype O] (a : Equiv.Perm O) (ha : a p=p) :
+    bypass (a*f) p=restrict a p ha*bypass f p := by
+  apply Equiv.ext
+  intro x
+  apply Subtype.ext
+  change Equiv.swap p (a (f p)) (a (f x))=a (Equiv.swap p (f p) (f x))
+  simpa only [ha] using (a.injective.swap_apply p (f p) (f x))
+lemma bypass_nonfixed [Fintype O] (q : Rest p) (hq : f q≠q)
+    (hshort : f q=p → f p≠q) : bypass f p q≠q := by
+  intro he
+  have he := congrArg Subtype.val he
+  rw [bypass_apply] at he
+  by_cases h : f q=p
+  · rw [h,Equiv.swap_apply_left] at he
+    exact hshort h he
+  · have hh : f q≠f p := fun he=>q.property (f.injective he)
+    rw [Equiv.swap_apply_of_ne_of_ne h hh] at he
+    exact hq he
+variable [Fintype O]
+lemma card_rest : Fintype.card (Rest p)+1=Fintype.card O := by
+  have h := Fintype.card_subtype_compl (fun x : O=>x=p)
+  have he : Fintype.card {x : O // x=p}=1 := Fintype.card_unique
+  change Fintype.card (Rest p)=_ at h
+  rw [he] at h
+  have hn : 0<Fintype.card O := Fintype.card_pos_iff.mpr ⟨p⟩
+  omega
+end TorsionFreeZeroDivisors.DeleteCycle
+namespace TorsionFreeZeroDivisors.MapEuler
+open scoped Classical
+variable {O B : Type} (σ α : Equiv.Perm O)
+lemma component_rotation (x : O) : component σ α (σ x)=component σ α x :=
+  Quotient.sound (Relation.EqvGen.symm _ _ (Relation.EqvGen.rel _ _ (Or.inl rfl)))
+lemma component_partner (x : O) : component σ α (α x)=component σ α x :=
+  Quotient.sound (Relation.EqvGen.symm _ _ (Relation.EqvGen.rel _ _ (Or.inr rfl)))
+def lift (q : O→B) (hσ : ∀x,q (σ x)=q x) (hα : ∀x,q (α x)=q x) : Component σ α →B :=
+  Quotient.lift q (by
+    intro x y h
+    induction h with
+    | rel x y h=>
+      rcases h with h|h
+      · exact (hσ x).symm.trans (congrArg q h)
+      · exact (hα x).symm.trans (congrArg q h)
+    | refl=>rfl
+    | symm _ _ _ ih=>exact ih.symm
+    | trans _ _ _ _ _ ih ih'=>exact ih.trans ih')
+@[simp] lemma lift_component (q : O→B) (hσ : ∀x,q (σ x)=q x) (hα : ∀x,q (α x)=q x) (x : O) :
+    lift σ α q hσ hα (component σ α x)=q x := rfl
+lemma swap_invariant (q : O→B) (p r : O) (h : q p=q r) (x : O) : q (Equiv.swap p r x)=q x := by
+  by_cases hp : x=p
+  · subst x;rw [Equiv.swap_apply_left];exact h.symm
+  · by_cases hr : x=r
+    · subst x;rw [Equiv.swap_apply_right];exact h
+    · rw [Equiv.swap_apply_of_ne_of_ne hp hr]
+end TorsionFreeZeroDivisors.MapEuler
+namespace TorsionFreeZeroDivisors.MapDeletion
+
+section
+open scoped Classical
+open DeleteCycle MapEuler
+variable {O : Type} [Fintype O] (σ α : Equiv.Perm O) (p : O) (ha : α p=p) (hs : σ p≠p)
+abbrev rotation := bypass σ p
+abbrev partner := restrict α p ha
+def push (x : O) : Rest p := if hx : x=p then ⟨σ p,hs⟩ else ⟨x,hx⟩
+omit [Fintype O] in
+lemma push_p : push σ p hs p=⟨σ p,hs⟩ := by simp [push]
+omit [Fintype O] in
+lemma push_val (x : Rest p) : push σ p hs x=x := by simp [push,x.property]
+lemma push_rotation (x : Rest p) : push σ p hs (σ x)=rotation σ p x := by
+  apply Subtype.ext
+  rw [bypass_apply]
+  by_cases h : σ x=p
+  · simp only [push,h,dite_eq_left trivial,Equiv.swap_apply_left]
+  · have hn : σ x≠σ p := σ.injective.ne x.property
+    simp only [push,dite_eq_right h,Equiv.swap_apply_of_ne_of_ne h hn]
+def projectRaw (x : O) : MapEuler.Component (rotation σ p) (partner α p ha) :=
+  component (rotation σ p) (partner α p ha) (push σ p hs x)
+lemma project_rotation (x : O) : projectRaw σ α p ha hs (σ x)=projectRaw σ α p ha hs x := by
+  by_cases hx : x=p
+  · subst x
+    change component _ _ (push σ p hs (σ p))=component _ _ (push σ p hs p)
+    rw [push_p]
+    simp only [push,dite_eq_right hs]
+  · change component _ _ (push σ p hs (σ (⟨x,hx⟩ : Rest p)))=_
+    rw [push_rotation]
+    change component _ _ (rotation σ p ⟨x,hx⟩)=component _ _ (push σ p hs (⟨x,hx⟩ : Rest p))
+    rw [push_val,component_rotation]
+omit [Fintype O] in
+lemma project_partner (x : O) : projectRaw σ α p ha hs (α x)=projectRaw σ α p ha hs x := by
+  by_cases hx : x=p
+  · subst x;rw [ha]
+  · have hn : α x≠p := (DeleteCycle.invariant α p ha x).mpr hx
+    change component _ _ (push σ p hs (α x))=component _ _ (push σ p hs x)
+    simp only [push,dite_eq_right hx,dite_eq_right hn]
+    exact component_partner (rotation σ p) (partner α p ha) ⟨x,hx⟩
+def project : MapEuler.Component σ α → MapEuler.Component (rotation σ p) (partner α p ha) :=
+  MapEuler.lift σ α (projectRaw σ α p ha hs) (project_rotation σ α p ha hs) (project_partner σ α p ha hs)
+lemma include_rotation (x : Rest p) : component σ α (rotation σ p x)=component σ α x := by
+  rw [bypass_apply,MapEuler.swap_invariant (component σ α) p (σ p) (component_rotation σ α p).symm]
+  exact component_rotation σ α x
+omit [Fintype O] in
+lemma include_partner (x : Rest p) : component σ α (partner α p ha x)=component σ α x :=
+  component_partner σ α x
+def inclusion : MapEuler.Component (rotation σ p) (partner α p ha) → MapEuler.Component σ α :=
+  MapEuler.lift _ _ (fun x : Rest p=>component σ α x) (include_rotation σ α p) (include_partner σ α p ha)
+omit [Fintype O] in
+lemma component_push (x : O) : component σ α (push σ p hs x)=component σ α x := by
+  by_cases hx : x=p
+  · subst x;rw [push_p];exact component_rotation σ α p
+  · simp only [push,dite_eq_right hx]
+lemma left_inverse : Function.LeftInverse (inclusion σ α p ha) (project σ α p ha hs) := by
+  intro c
+  obtain ⟨x,rfl⟩ := Quotient.mk_surjective c
+  exact component_push σ α p hs x
+lemma project_surjective : Function.Surjective (project σ α p ha hs) := by
+  intro c
+  obtain ⟨x,rfl⟩ := Quotient.mk_surjective c
+  refine ⟨component σ α x,?_⟩
+  change component _ _ (push σ p hs x)=component _ _ x
+  rw [push_val]
+def componentEquiv : MapEuler.Component σ α ≃ MapEuler.Component (rotation σ p) (partner α p ha) :=
+  Equiv.ofBijective (project σ α p ha hs) ⟨(left_inverse σ α p ha hs).injective,project_surjective σ α p ha hs⟩
+end
+open scoped Classical
+open DeleteCycle MapEuler PermutationCycles
+variable {O : Type} [Fintype O] (σ α : Equiv.Perm O) (p : O) (ha : α p=p)
+def support_equiv : ↥(partner α p ha).support ≃ ↥α.support where
+  toFun x := ⟨x.val.val,by
+    have h := Equiv.Perm.mem_support.mp x.property
+    exact Equiv.Perm.mem_support.mpr (fun he=>h (Subtype.ext he))⟩
+  invFun x := ⟨⟨x.val,by
+    intro he
+    have hn := Equiv.Perm.mem_support.mp x.property
+    exact hn (he ▸ ha)⟩,by
+      apply Equiv.Perm.mem_support.mpr
+      intro he
+      exact Equiv.Perm.mem_support.mp x.property (congrArg Subtype.val he)⟩
+  left_inv x := by cases x; rfl
+  right_inv x := by cases x; rfl
+lemma support_count : (partner α p ha).support.card=α.support.card := by
+  simpa only [Fintype.card_coe] using Fintype.card_congr (support_equiv α p ha)
+omit [Fintype O] in
+include ha in
+lemma face_nonfixed (hs : σ p≠p) : (α*σ) p≠p := by
+  intro he
+  exact hs (α.injective ((show α (σ p)=p from he).trans ha.symm))
+/-- Removing a dart fixed by the partner involution preserves all actual map
+components and the Euler equality when its vertex is not a singleton. -/
+theorem genusZero_delete (hs : σ p≠p) (hz : GenusZero σ α) :
+    GenusZero (rotation σ p) (partner α p ha) := by
+  have hv := bypass_count σ p hs
+  have hf := bypass_count (α*σ) p (face_nonfixed σ α p ha hs)
+  rw [bypass_mul σ p α ha] at hf
+  have hc := Nat.card_congr (componentEquiv σ α p ha hs)
+  have he := support_count α p ha
+  simp only [←Nat.card_eq_fintype_card] at hv hf
+  dsimp only [GenusZero] at hz ⊢
+  change Nat.card (Cycle (rotation σ p))=Nat.card (Cycle σ) at hv
+  change Nat.card (Cycle (partner α p ha*rotation σ p))=Nat.card (Cycle (α*σ)) at hf
+  rw [hv,hf,←hc]
+  have hsup : ∀ (i j : Fintype (Rest p)) (d e : DecidableEq (Rest p)),
+      @Equiv.Perm.support (Rest p) d i (partner α p ha) =
+      @Equiv.Perm.support (Rest p) e j (partner α p ha) := by
+    intro i j d e
+    cases Subsingleton.elim i j
+    cases Subsingleton.elim d e
+    rfl
+  convert hz using 1
+  rw [←he]
+  congr 1
+  exact congrArg Finset.card (hsup _ _ _ _)
+end TorsionFreeZeroDivisors.MapDeletion
+namespace TorsionFreeZeroDivisors.BandEuler
+open scoped Classical
+open PermutationCycles DeleteCycle
+variable {O A : Type} [Fintype O] (σ α : Equiv.Perm O)
+  (hi : Function.Involutive α) (p q : O) (hpq : p≠q) (hpair : α p=q)
+abbrev q' : Rest p := ⟨q,hpq.symm⟩
+abbrev Residual := Rest (q' p q hpq)
+def adjusted := α*Equiv.swap p q
+omit [Fintype O] in
+include hi hpair in
+lemma adjusted_p : adjusted α p q p=p := by
+  rw [adjusted,Equiv.Perm.mul_apply,Equiv.swap_apply_left]
+  exact (congrArg α hpair).symm.trans (hi p)
+omit [Fintype O] in
+include hpair in
+lemma adjusted_q : adjusted α p q q=q := by
+  rw [adjusted,Equiv.Perm.mul_apply,Equiv.swap_apply_right,hpair]
+def α₁ : Equiv.Perm (Rest p) := restrict (adjusted α p q) p (adjusted_p α hi p q hpair)
+omit [Fintype O] in
+lemma α₁_q : α₁ α hi p q hpair (q' p q hpq)=q' p q hpq := by
+  apply Subtype.ext
+  exact adjusted_q α p q hpair
+
+def partner : Equiv.Perm (Residual p q hpq) :=
+  restrict (α₁ α hi p q hpair) (q' p q hpq) (α₁_q α hi p q hpq hpair)
+def switched : Equiv.Perm O := Equiv.swap p q*σ
+def rotation : Equiv.Perm (Residual p q hpq) := bypass (bypass (switched σ p q) p) (q' p q hpq)
+def face : Equiv.Perm O := α*σ
+
+def val (x : Residual p q hpq) : O := x.val.val
+omit [Fintype O] in
+lemma val_ne_p (x : Residual p q hpq) : val p q hpq x≠p := x.val.property
+omit [Fintype O] in
+lemma val_ne_q (x : Residual p q hpq) : val p q hpq x≠q := by
+  intro h
+  exact x.property (Subtype.ext h)
+omit [Fintype O] in
+lemma val_injective : Function.Injective (val p q hpq) := by
+  intro x y h
+  exact Subtype.ext (Subtype.ext h)
+omit [Fintype O] in
+lemma partner_val (x : Residual p q hpq) :
+    val p q hpq (partner α hi p q hpq hpair x)=α (val p q hpq x) := by
+  change α (Equiv.swap p q (val p q hpq x))=_
+  rw [Equiv.swap_apply_of_ne_of_ne (val_ne_p p q hpq x) (val_ne_q p q hpq x)]
+omit [Fintype O] in
+lemma partner_involutive : Function.Involutive (partner α hi p q hpq hpair) := by
+  intro x
+  apply val_injective p q hpq
+  rw [partner_val,partner_val,hi]
+omit [Fintype O] in
+include hpair in
+lemma partner_distinct (hf : ∀x,α x≠x) (x : Residual p q hpq) : partner α hi p q hpq hpair x≠x := by
+  intro he
+  have h := congrArg (val p q hpq) he
+  rw [partner_val] at h
+  exact hf _ h
+lemma face_eq : partner α hi p q hpq hpair*rotation σ p q hpq=
+    bypass (bypass (face σ α) p) (q' p q hpq) := by
+  have he : face σ α=adjusted α p q*switched σ p q := by
+    simp only [face,adjusted,switched]
+    rw [mul_assoc α (Equiv.swap p q),←mul_assoc (Equiv.swap p q),Equiv.swap_mul_self,one_mul]
+  rw [he,bypass_mul _ _ _ (adjusted_p α hi p q hpair)]
+  change _=bypass (α₁ α hi p q hpair*bypass (switched σ p q) p) (q' p q hpq)
+  rw [bypass_mul _ _ _ (α₁_q α hi p q hpq hpair)]
+  rfl
+
+variable (hs : σ p≠p) (hfp : face σ α p≠p) (hfq : face σ α q≠q)
+omit [Fintype O] in
+include hi hpair hfp in
+lemma switched_p : switched σ p q p≠p := by
+  intro he
+  apply hfp
+  have hh : adjusted α p q*switched σ p q=face σ α := by
+    simp only [adjusted,switched,face]
+    rw [mul_assoc α (Equiv.swap p q),←mul_assoc (Equiv.swap p q),Equiv.swap_mul_self,one_mul]
+  rw [←hh,Equiv.Perm.mul_apply,he,adjusted_p α hi p q hpair]
+omit [Fintype O] in
+include hpair hfq in
+lemma switched_q : switched σ p q q≠q := by
+  intro he
+  apply hfq
+  have hh : adjusted α p q*switched σ p q=face σ α := by
+    simp only [adjusted,switched,face]
+    rw [mul_assoc α (Equiv.swap p q),←mul_assoc (Equiv.swap p q),Equiv.swap_mul_self,one_mul]
+  rw [←hh,Equiv.Perm.mul_apply,he,adjusted_q α p q hpair]
+omit [Fintype O] in
+include hs in
+lemma switched_p_ne_q : switched σ p q p≠q := by
+  intro he
+  have hh := congrArg (Equiv.swap p q) he
+  simp only [switched,Equiv.Perm.mul_apply,Equiv.swap_apply_self,Equiv.swap_apply_right] at hh
+  exact hs hh
+omit [Fintype O] in
+include hs hpair in
+lemma face_p_ne_q : face σ α p≠q := by
+  intro he
+  exact hs (α.injective (he.trans hpair.symm))
+include hi hpair hs hfp hfq in
+lemma rotation_count : Fintype.card (Cycle (rotation σ p q hpq))=
+    Fintype.card (Cycle (switched σ p q)) := by
+  rw [rotation,bypass_count]
+  · exact bypass_count _ _ (switched_p σ α hi p q hpair hfp)
+  · apply bypass_nonfixed
+    · exact switched_q σ α p q hpair hfq
+    · intro _
+      exact switched_p_ne_q σ p q hs
+include hs hfp hfq in
+lemma face_count : Fintype.card (Cycle (partner α hi p q hpq hpair*rotation σ p q hpq))=
+    Fintype.card (Cycle (face σ α)) := by
+  rw [face_eq,bypass_count]
+  · exact bypass_count _ _ hfp
+  · apply bypass_nonfixed
+    · exact hfq
+    · intro _
+      exact face_p_ne_q σ α p q hpair hs
+lemma two_fewer : Fintype.card (Residual p q hpq)+2=Fintype.card O := by
+  have h₁ := card_rest (p:=p)
+  have h₂ := card_rest (p:=q' p q hpq)
+  simp only [←Nat.card_eq_fintype_card] at h₁ h₂ ⊢
+  change Nat.card (Residual p q hpq)+1=Nat.card (Rest p) at h₂
+  omega
+include hs hfp hfq in
+/-- The literal removal of a paired band preserves the global sphere Euler
+lower bound. No componentwise planarity or essentiality is concluded here. -/
+theorem euler (he : Fintype.card O+4≤2*Fintype.card (Cycle σ)+2*Fintype.card (Cycle (face σ α))) :
+    Fintype.card (Residual p q hpq)+4≤2*Fintype.card (Cycle (rotation σ p q hpq))+
+      2*Fintype.card (Cycle (partner α hi p q hpq hpair*rotation σ p q hpq)) := by
+  rw [rotation_count σ α hi p q hpq hpair hs hfp hfq,face_count σ α hi p q hpq hpair hs hfp hfq]
+  have hv := SwapCycles.count_le σ p q
+  have hc := two_fewer p q hpq
+  change Fintype.card (Cycle σ)≤Fintype.card (Cycle (switched σ p q))+1 at hv
+  omega
+end TorsionFreeZeroDivisors.BandEuler
+namespace TorsionFreeZeroDivisors.MapEuler
+lemma genusZero_fintype {O : Type} (i j : Fintype O) (σ α : Equiv.Perm O) :
+    @GenusZero O i σ α ↔ @GenusZero O j σ α := by
+  cases Subsingleton.elim i j
+  rfl
+end TorsionFreeZeroDivisors.MapEuler
+namespace TorsionFreeZeroDivisors.BandEuler
+open scoped Classical
+open DeleteCycle MapEuler
+variable {O : Type} [Fintype O] (σ α : Equiv.Perm O)
+  (hi : Function.Involutive α) (p q : O) (hpq : p≠q) (hpair : α p=q)
+omit [Fintype O] in
+include hi hpair in
+lemma adjusted_strip : adjusted α p q=PairingFactors.strip α p := by
+  rw [←hpair]
+  ext x
+  change α (Equiv.swap p (α p) x)=Equiv.swap p (α p) (α x)
+  rw [←α.injective.swap_apply,hi p,Equiv.swap_comm (α p) p]
+include hi hpq hpair in
+lemma switched_genusZero (hz : GenusZero σ α) :
+    GenusZero (switched σ p q) (adjusted α p q) := by
+  rw [adjusted_strip α hi p q hpair]
+  have hp : α p≠p := by rw [hpair];exact hpq.symm
+  have hh := genusZero_band σ α hi hz p hp
+  simpa only [switched,hpair] using hh
+include hi hpair in
+/-- The genuine remaining map after deleting a paired band has genus zero in
+all its actual components. This strengthens the global Euler estimate and uses
+no assumed planar embedding. Local degenerate faces are explicitly excluded. -/
+theorem genusZero (hz : GenusZero σ α) (hs : σ p≠p)
+    (hfp : face σ α p≠p) (hfq : face σ α q≠q) :
+    GenusZero (rotation σ p q hpq) (partner α hi p q hpq hpair) := by
+  have h₀ := switched_genusZero σ α hi p q hpq hpair hz
+  have h₁ := MapDeletion.genusZero_delete (switched σ p q) (adjusted α p q) p
+    (adjusted_p α hi p q hpair) (switched_p σ α hi p q hpair hfp) h₀
+  have hn : bypass (switched σ p q) p (q' p q hpq)≠q' p q hpq := by
+    apply bypass_nonfixed
+    · exact switched_q σ α p q hpair hfq
+    · intro _
+      exact switched_p_ne_q σ p q hs
+  have h₂ := MapDeletion.genusZero_delete (bypass (switched σ p q) p) (α₁ α hi p q hpair)
+    (q' p q hpq) (α₁_q α hi p q hpq hpair) hn h₁
+  exact (genusZero_fintype _ _ _ _).mp h₂
+end TorsionFreeZeroDivisors.BandEuler
+
+/-! Actual finite noncrossing word matchings, the cancellation part of the
+cone-picture construction. An ear is inserted at two adjacent positions.
+This file asserts no sphere realization or asphericity theorem. -/
+namespace TorsionFreeZeroDivisors.WordPairing
+
+section
+variable {A : Type*} {n : ℕ}
+
+structure Data (inv : A → A) (label : Fin n → A) where
+  partner : Equiv.Perm (Fin n)
+  involutive : Function.Involutive partner
+  distinct : ∀ i,partner i≠i
+  compatible : ∀ i,label (partner i)=inv (label i)
+  noncrossing : ∀ i j,i<j → j<partner i → partner i<partner j → False
+
+namespace Ear
+variable (k : ℕ)
+def raise (i : Fin n) : Fin (n+2) := ⟨if i.val<k then i.val else i.val+2,by
+  split_ifs with h <;> omega⟩
+lemma raise_lt (i j : Fin n) : raise k i<raise k j ↔ i<j := by
+  simp only [raise,Fin.lt_def]
+  split_ifs <;> omega
+lemma raise_injective : Function.Injective (raise (n:=n) k) := by
+  intro i j he
+  apply Fin.ext
+  have hh := congrArg Fin.val he
+  simp only [raise] at hh
+  split_ifs at hh <;> omega
+lemma raise_avoid (i : Fin n) : (raise k i).val≠k ∧ (raise k i).val≠k+1 := by
+  simp only [raise]
+  split_ifs <;> omega
+
+def insert (hk : k≤n) : Fin n⊕Bool → Fin (n+2)
+  | .inl i => raise k i
+  | .inr false => ⟨k,by omega⟩
+  | .inr true => ⟨k+1,by omega⟩
+lemma insert_injective (hk : k≤n) : Function.Injective (insert k hk) := by
+  intro x y he
+  cases x with
+  | inl i =>
+    cases y with
+    | inl j => exact congrArg Sum.inl (raise_injective k he)
+    | inr b =>
+      have hh := congrArg Fin.val he
+      have ha := raise_avoid k i
+      cases b <;> simp only [insert] at hh <;> omega
+  | inr b =>
+    cases y with
+    | inl i =>
+      have hh := congrArg Fin.val he
+      have ha := raise_avoid k i
+      cases b <;> simp only [insert] at hh <;> omega
+    | inr c =>
+      have hh := congrArg Fin.val he
+      cases b <;> cases c <;> simp only [insert] at hh <;> first | rfl | omega
+lemma insert_surjective (hk : k≤n) : Function.Surjective (insert k hk) := by
+  intro y
+  by_cases h : y.val<k
+  · refine ⟨.inl ⟨y.val,by omega⟩,?_⟩
+    apply Fin.ext
+    simp only [insert,raise,ite_eq_left h]
+  · by_cases he : y.val=k
+    · exact ⟨.inr false,Fin.ext he.symm⟩
+    · by_cases he' : y.val=k+1
+      · exact ⟨.inr true,Fin.ext he'.symm⟩
+      · refine ⟨.inl ⟨y.val-2,by omega⟩,?_⟩
+        apply Fin.ext
+        have hh : ¬y.val-2<k := by omega
+        simp only [insert,raise,ite_eq_right hh]
+        omega
+
+def equiv (hk : k≤n) : Fin n⊕Bool ≃ Fin (n+2) :=
+  Equiv.ofBijective (insert k hk) ⟨insert_injective k hk,insert_surjective k hk⟩
+@[simp] lemma equiv_left (hk : k≤n) (i : Fin n) : equiv k hk (.inl i)=raise k i := rfl
+@[simp] lemma equiv_false (hk : k≤n) : (equiv k hk (.inr false)).val=k := rfl
+@[simp] lemma equiv_true (hk : k≤n) : (equiv k hk (.inr true)).val=k+1 := rfl
+
+variable {inv : A → A} {label : Fin n → A} (d : Data inv label)
+def sumPartner : Equiv.Perm (Fin n⊕Bool) := Equiv.sumCongr d.partner Equiv.boolNot
+
+def partner (hk : k≤n) : Equiv.Perm (Fin (n+2)) :=
+  (equiv k hk).permCongr (sumPartner d)
+lemma partner_apply (hk : k≤n) (i : Fin n⊕Bool) :
+    partner k d hk (equiv k hk i)=equiv k hk (sumPartner d i) := by
+  simp only [partner,Equiv.permCongr_apply,Equiv.symm_apply_apply]
+
+lemma involutive (hk : k≤n) : Function.Involutive (partner k d hk) := by
+  intro i
+  obtain ⟨i,rfl⟩ := (equiv k hk).surjective i
+  rw [partner_apply,partner_apply]
+  congr 1
+  cases i with
+  | inl i => exact congrArg Sum.inl (d.involutive i)
+  | inr b => cases b <;> rfl
+lemma distinct (hk : k≤n) (i : Fin (n+2)) : partner k d hk i≠i := by
+  obtain ⟨i,rfl⟩ := (equiv k hk).surjective i
+  rw [partner_apply]
+  intro he
+  have hh := (equiv k hk).injective he
+  cases i with
+  | inl i => exact d.distinct i (Sum.inl.inj hh)
+  | inr b => cases b <;> cases hh
+
+lemma noncrossing (hk : k≤n) : ∀ i j : Fin (n+2),
+    i<j → j<partner k d hk i → partner k d hk i<partner k d hk j → False := by
+  intro i j hij hjp hpp
+  obtain ⟨i,rfl⟩ := (equiv k hk).surjective i
+  obtain ⟨j,rfl⟩ := (equiv k hk).surjective j
+  rw [partner_apply] at hjp hpp
+  rw [partner_apply] at hpp
+  cases i with
+  | inl i =>
+    cases j with
+    | inl j =>
+      exact d.noncrossing i j ((raise_lt k _ _).mp hij)
+        ((raise_lt k _ _).mp hjp) ((raise_lt k _ _).mp hpp)
+    | inr b =>
+      cases b with
+      | false =>
+        change k < (raise k (d.partner i)).val at hjp
+        change (raise k (d.partner i)).val < k+1 at hpp
+        omega
+      | true =>
+        change k+1 < (raise k (d.partner i)).val at hjp
+        change (raise k (d.partner i)).val < k at hpp
+        omega
+  | inr b =>
+    cases b with
+    | false =>
+      change k < (equiv k hk j).val at hij
+      change (equiv k hk j).val < k+1 at hjp
+      omega
+    | true =>
+      change k+1 < (equiv k hk j).val at hij
+      change (equiv k hk j).val < k at hjp
+      omega
+end Ear
+end
+
+section
+variable {A : Type*} {n m : ℕ} {inv : A → A} {label : Fin n → A}
+
+namespace Data
+variable (d : Data inv label)
+lemma reindex_apply (e : Fin n ≃o Fin m) (i : Fin n) :
+    e.toEquiv.permCongr d.partner (e i)=e (d.partner i) := by
+  change e (d.partner (e.symm (e i)))=e (d.partner i)
+  rw [e.symm_apply_apply]
+def reindex (e : Fin n ≃o Fin m) (label' : Fin m → A)
+    (hl : ∀ i,label' (e i)=label i) : Data inv label' where
+  partner := e.toEquiv.permCongr d.partner
+  involutive := by
+    intro i
+    obtain ⟨i,rfl⟩ := e.surjective i
+    rw [d.reindex_apply,d.reindex_apply,d.involutive]
+  distinct := by
+    intro i
+    obtain ⟨i,rfl⟩ := e.surjective i
+    rw [d.reindex_apply]
+    exact fun he=>d.distinct i (e.injective he)
+  compatible := by
+    intro i
+    obtain ⟨i,rfl⟩ := e.surjective i
+    rw [d.reindex_apply,hl,hl]
+    exact d.compatible i
+  noncrossing := by
+    intro i j hij hjp hpp
+    obtain ⟨i,rfl⟩ := e.surjective i
+    obtain ⟨j,rfl⟩ := e.surjective j
+    rw [d.reindex_apply] at hjp
+    rw [d.reindex_apply,d.reindex_apply] at hpp
+    exact d.noncrossing i j ((e.lt_iff_lt).mp hij)
+      ((e.lt_iff_lt).mp hjp) ((e.lt_iff_lt).mp hpp)
+end Data
+
+namespace Ear
+variable (k : ℕ) (hk : k≤n) (a : A)
+def labels (i : Fin (n+2)) : A :=
+  Sum.elim label (fun b=>if b then inv a else a) ((equiv k hk).symm i)
+@[simp] lemma labels_left (i : Fin n) :
+    labels (label:=label) (inv:=inv) k hk a (equiv k hk (.inl i))=label i := by
+  simp only [labels,Equiv.symm_apply_apply,Sum.elim_inl]
+@[simp] lemma labels_false :
+    labels (label:=label) (inv:=inv) k hk a (equiv k hk (.inr false))=a := by
+  simp only [labels,Equiv.symm_apply_apply,Sum.elim_inr,Bool.false_eq_true,ite_false]
+@[simp] lemma labels_true :
+    labels (label:=label) (inv:=inv) k hk a (equiv k hk (.inr true))=inv a := by
+  simp only [labels,Equiv.symm_apply_apply,Sum.elim_inr,ite_true]
+
+def data (d : Data inv label) (ha : inv (inv a)=a) :
+    Data inv (labels (label:=label) (inv:=inv) k hk a) where
+  partner := partner k d hk
+  involutive := involutive k d hk
+  distinct := distinct k d hk
+  compatible := by
+    intro i
+    obtain ⟨i,rfl⟩ := (equiv k hk).surjective i
+    rw [partner_apply]
+    cases i with
+    | inl i =>
+      change labels k hk a (equiv k hk (.inl (d.partner i)))=_
+      rw [labels_left,labels_left]
+      exact d.compatible i
+    | inr b =>
+      cases b with
+      | false => exact (labels_true k hk a).trans (congrArg inv (labels_false k hk a).symm)
+      | true =>
+        change labels k hk a (equiv k hk (.inr false))=inv (labels k hk a (equiv k hk (.inr true)))
+        rw [labels_false,labels_true,ha]
+  noncrossing := noncrossing k d hk
+end Ear
+
+namespace ListInsert
+variable (u v : List A) (a b : A)
+lemma get_old (i : ℕ) (hi : i<(u++v).length) :
+    (u++a::b::v)[if i<u.length then i else i+2]'(by split_ifs <;> simp only [List.length_append,List.length_cons] at * <;> omega)=
+      (u++v)[i] := by
+  by_cases h : i<u.length
+  · simp only [ite_eq_left h,List.getElem_append_left h]
+  · have hh : ¬i+2<u.length := by omega
+    have he : i+2-u.length=(i-u.length)+2 := by omega
+    simp only [ite_eq_right h,List.getElem_append,dite_eq_right h,dite_eq_right hh,he,List.getElem_cons_succ]
+lemma get_first :
+    (u++a::b::v)[u.length]'(by simp only [List.length_append,List.length_cons];omega)=a := by
+  simp only [List.getElem_append,dite_eq_right (Nat.lt_irrefl _),Nat.sub_self,List.getElem_cons_zero]
+lemma get_second :
+    (u++a::b::v)[u.length+1]'(by simp only [List.length_append,List.length_cons];omega)=b := by
+  have hh : ¬u.length+1<u.length := by omega
+  simp only [List.getElem_append,dite_eq_right hh,Nat.add_sub_cancel_left,List.getElem_cons_succ,List.getElem_cons_zero]
+end ListInsert
+
+end
+variable {A : Type*}
+namespace ListInsert
+variable (u v : List A) (inv : A → A) (a : A)
+lemma length_eq : (u++v).length+2=(u++a::inv a::v).length := by
+  simp only [List.length_append,List.length_cons]
+  omega
+
+def orderIso : Fin ((u++v).length+2) ≃o Fin (u++a::inv a::v).length :=
+  Fin.castOrderIso (length_eq u v inv a)
+
+lemma labels_eq (i : Fin ((u++v).length+2)) :
+    (u++a::inv a::v).get (orderIso u v inv a i)=
+      Ear.labels (label:=(u++v).get) (inv:=inv) u.length
+        (by simp only [List.length_append];omega) a i := by
+  obtain ⟨i,rfl⟩ := (Ear.equiv u.length (show u.length≤(u++v).length by
+    simp only [List.length_append];omega)).surjective i
+  cases i with
+  | inl i =>
+    rw [Ear.labels_left]
+    change (u++a::inv a::v)[if i.val<u.length then i.val else i.val+2]'(by
+      have hi := i.isLt
+      split_ifs <;> simp only [List.length_append,List.length_cons] at * <;> omega)=
+      (u++v)[i.val]
+    exact get_old u v a (inv a) i.val i.isLt
+  | inr b =>
+    cases b with
+    | false =>
+      rw [Ear.labels_false]
+      exact get_first u v a (inv a)
+    | true =>
+      rw [Ear.labels_true]
+      exact get_second u v a (inv a)
+
+def data (d : Data inv (u++v).get) (ha : inv (inv a)=a) :
+    Data inv (u++a::inv a::v).get :=
+  (Ear.data u.length (by simp only [List.length_append];omega) a d ha).reindex
+    (orderIso u v inv a) _ (labels_eq u v inv a)
+end ListInsert
+
+def inverseLetter (p : A × Bool) : A × Bool := (p.1,!p.2)
+lemma inverseLetter_involutive : Function.Involutive (inverseLetter (A:=A)) := by
+  intro p
+  cases p with
+  | mk a b => cases b <;> rfl
+
+def emptyData : Data (inverseLetter (A:=A)) ([] : List (A×Bool)).get where
+  partner := Equiv.refl _
+  involutive := fun _=>rfl
+  distinct i := Fin.elim0 i
+  compatible i := Fin.elim0 i
+  noncrossing i := Fin.elim0 i
+
+theorem of_reduction {w : List (A×Bool)} (h : FreeGroup.Red w []) :
+    Nonempty (Data inverseLetter w.get) := by
+  induction h using Relation.ReflTransGen.head_induction_on with
+  | refl => exact ⟨emptyData⟩
+  | @head x y hxy hy ih =>
+    cases hxy with
+    | @not u v a b =>
+      obtain ⟨d⟩ := ih
+      exact ⟨ListInsert.data u v inverseLetter (a,b) d (inverseLetter_involutive _)⟩
+
+theorem of_identity {w : List (A×Bool)} (h : FreeGroup.mk w=1) :
+    Nonempty (Data inverseLetter w.get) := by
+  classical
+  have he : FreeGroup.reduce w=[] := by
+    have hh := FreeGroup.reduce.sound h
+    exact hh
+  apply of_reduction
+  rw [←he]
+  exact FreeGroup.reduce.red
+
+end TorsionFreeZeroDivisors.WordPairing
+namespace TorsionFreeZeroDivisors.WordPairing.Ear
+open PermutationCycles
+variable {A : Type*} {n : ℕ} {inv : A → A} {label : Fin n → A}
+lemma rotate_val (i : Fin n) : (finRotate n i).val=if i.val+1<n then i.val+1 else 0 := by
+  cases n with
+  | zero => exact i.elim0
+  | succ n =>
+    rw [coe_finRotate]
+    simp only [Fin.ext_iff,Fin.val_last]
+    split_ifs <;> have := i.isLt <;> omega
+
+def previous (k : ℕ) (hk : k≤n) (hn : 0<n) : Fin n :=
+  ⟨if k=0 then n-1 else k-1,by split_ifs <;> omega⟩
+variable (k : ℕ) (hk : k≤n) (hn : 0<n)
+lemma previous_rotate : finRotate (n+2) (raise k (previous k hk hn))=equiv k hk (.inr false) := by
+  apply Fin.ext
+  change (finRotate (n+2) (raise k (previous k hk hn))).val=k
+  rw [rotate_val]
+  simp only [raise,previous]
+  split_ifs <;> omega
+lemma rotate_old (i : Fin n) (hi : i≠previous k hk hn) :
+    finRotate (n+2) (raise k i)=raise k (finRotate n i) := by
+  apply Fin.ext
+  have hi' : i.val≠(previous k hk hn).val := fun h=>hi (Fin.ext h)
+  rw [rotate_val]
+  simp only [raise,rotate_val,previous] at *
+  have hb := i.isLt
+  split_ifs at * <;> omega
+lemma rotate_false : finRotate (n+2) (equiv k hk (.inr false))=equiv k hk (.inr true) := by
+  apply Fin.ext
+  rw [rotate_val]
+  change (if k+1<n+2 then k+1 else 0)=k+1
+  rw [ite_eq_left (by omega)]
+lemma rotate_true : finRotate (n+2) (equiv k hk (.inr true))=
+    raise k (finRotate n (previous k hk hn)) := by
+  apply Fin.ext
+  rw [rotate_val]
+  change (if k+1+1<n+2 then k+1+1 else 0)=_
+  simp only [raise,rotate_val,previous]
+  split_ifs <;> omega
+
+lemma rotation_transport (i : Fin n⊕Bool) :
+    finRotate (n+2) (equiv k hk i)=equiv k hk
+      (InsertedRotation.rotation (finRotate n) (previous k hk hn) i) := by
+  cases i with
+  | inl i =>
+    by_cases hi : i=previous k hk hn
+    · subst i
+      rw [InsertedRotation.rotation_p,equiv_left]
+      exact previous_rotate k hk hn
+    · rw [InsertedRotation.rotation_left _ _ i hi,equiv_left,equiv_left]
+      exact rotate_old k hk hn i hi
+  | inr b =>
+    cases b with
+    | false => rw [InsertedRotation.rotation_false]; exact rotate_false k hk
+    | true => rw [InsertedRotation.rotation_true,equiv_left]; exact rotate_true k hk hn
+
+lemma rotation_eq : (equiv k hk).permCongr
+    (InsertedRotation.rotation (finRotate n) (previous k hk hn))=finRotate (n+2) := by
+  apply Equiv.ext
+  intro i
+  obtain ⟨i,rfl⟩ := (equiv k hk).surjective i
+  simp only [Equiv.permCongr_apply,Equiv.symm_apply_apply]
+  exact (rotation_transport k hk hn i).symm
+
+variable (d : Data inv label)
+lemma face_eq : (equiv k hk).permCongr
+    (InsertedRotation.face (finRotate n) d.partner (previous k hk hn))=
+    partner k d hk *finRotate (n+2) := by
+  rw [InsertedRotation.face,PermutationTransport.mul,rotation_eq k hk hn]
+  rfl
+
+include hn in
+theorem face_count :
+    Fintype.card (Cycle (d.partner*finRotate n))+1≤
+      Fintype.card (Cycle (partner k d hk*finRotate (n+2))) := by
+  rw [←face_eq k hk hn d,PermutationTransport.card_cycles]
+  exact InsertedRotation.face_count _ _ _
+
+end TorsionFreeZeroDivisors.WordPairing.Ear
+
+namespace TorsionFreeZeroDivisors.PermutationCycles
+variable (O : Type) [Fintype O]
+lemma card_identity : Fintype.card (Cycle (1 : Equiv.Perm O))=Fintype.card O := by
+  apply (Fintype.card_of_bijective (f:=cycle (1 : Equiv.Perm O)) ?_).symm
+  refine ⟨?_,cycle_surjective _⟩
+  intro x y h
+  exact ((cycle_eq _).mp h).eq_of_left rfl
+end TorsionFreeZeroDivisors.PermutationCycles
+
+namespace TorsionFreeZeroDivisors.WordPairing
+
+section
+open PermutationCycles
+variable {A : Type*} {n m : ℕ} {inv : A → A} {label : Fin n → A}
+
+/-- The disk Euler estimate for the actual circle rotation and word matching.
+The empty word is distinguished, since it has no boundary occurrences. -/
+def DiskEuler (d : Data inv label) : Prop :=
+  n=0 ∨ n+2≤2*Fintype.card (Cycle (d.partner*finRotate n))
+
+lemma Data.reindex_euler (d : Data inv label) (h : n=m) (label' : Fin m→A)
+    (hl : ∀i,label' (Fin.castOrderIso h i)=label i) (hd : DiskEuler d) :
+    DiskEuler (d.reindex (Fin.castOrderIso h) label' hl) := by
+  subst m
+  exact hd
+
+namespace Ear
+variable (k : ℕ) (hk : k≤n) (d : Data inv label)
+lemma empty_rotation (hn : n=0) : partner k d hk=finRotate (n+2) := by
+  subst n
+  have he : k=0 := by omega
+  subst k
+  apply Equiv.ext
+  intro i
+  obtain ⟨i,rfl⟩ := (equiv 0 hk).surjective i
+  rw [partner_apply]
+  cases i with
+  | inl i => exact i.elim0
+  | inr b => cases b <;> rfl
+
+lemma euler (hd : DiskEuler d) :
+    n+2+2≤2*Fintype.card (Cycle (partner k d hk*finRotate (n+2))) := by
+  by_cases he : n=0
+  · have hrot := empty_rotation k hk d he
+    have hf : partner k d hk*finRotate (n+2)=1 := by
+      apply Equiv.ext
+      intro i
+      rw [Equiv.Perm.mul_apply,←hrot]
+      exact involutive k d hk i
+    rw [hf,card_identity,Fintype.card_fin,he]
+  · have hn : 0<n := Nat.pos_of_ne_zero he
+    have hc := face_count k hk hn d
+    rcases hd with hh|hh
+    · exact (he hh).elim
+    · omega
+end Ear
+
+namespace ListInsert
+variable (u v : List A) (inv : A → A) (a : A)
+lemma data_euler (d : Data inv (u++v).get) (ha : inv (inv a)=a) (hd : DiskEuler d) :
+    DiskEuler (data u v inv a d ha) := by
+  apply Data.reindex_euler
+  apply Or.inr
+  exact Ear.euler u.length (by simp only [List.length_append];omega) d hd
+end ListInsert
+
+/-- The face-count input is now proved for the matching constructed from literal
+free cancellation. This does not yet claim a multi-disk PL realization. -/
+theorem of_reduction_euler {w : List (A×Bool)} (h : FreeGroup.Red w []) :
+    ∃ d : Data inverseLetter w.get,DiskEuler d := by
+  induction h using Relation.ReflTransGen.head_induction_on with
+  | refl => exact ⟨emptyData,Or.inl rfl⟩
+  | @head x y hxy hy ih =>
+    cases hxy with
+    | @not u v a b =>
+      obtain ⟨d,hd⟩ := ih
+      refine ⟨ListInsert.data u v inverseLetter (a,b) d (inverseLetter_involutive _),?_⟩
+      exact ListInsert.data_euler u v inverseLetter (a,b) d (inverseLetter_involutive _) hd
+
+theorem of_identity_euler {w : List (A×Bool)} (h : FreeGroup.mk w=1) :
+    ∃ d : Data inverseLetter w.get,DiskEuler d := by
+  classical
+  have he : FreeGroup.reduce w=[] := FreeGroup.reduce.sound h
+  apply of_reduction_euler
+  rw [←he]
+  exact FreeGroup.reduce.red
+
+end
+open scoped Classical
+variable {A : Type*} {n : ℕ} {inv : A → A} {label : Fin n → A}
+/-- Every nonempty finite noncrossing perfect matching has a literal adjacent
+ear, obtained by minimizing the positive distance between matched positions. -/
+theorem adjacent_ear (d : Data inv label) (hn : 0 < n) :
+    ∃i : Fin n,(d.partner i).val=i.val+1 := by
+  let s : Finset (Fin n) := Finset.univ.filter (fun i=> i < d.partner i)
+  have hs : s.Nonempty := by
+    let z : Fin n := ⟨0,hn⟩
+    refine ⟨z,Finset.mem_filter.mpr ⟨Finset.mem_univ _,?_⟩⟩
+    have he := d.distinct z
+    have hv : (d.partner z).val ≠ 0 := by intro h;exact he (Fin.ext h)
+    change 0 < (d.partner z).val
+    omega
+  obtain ⟨i,hi,hmin⟩ := Finset.exists_min_image s (fun i=> (d.partner i).val-i.val) hs
+  have hip : i < d.partner i := (Finset.mem_filter.mp hi).2
+  refine ⟨i,?_⟩
+  by_contra he
+  have hgap : i.val+1 < (d.partner i).val := by change i.val < (d.partner i).val at hip;omega
+  let j : Fin n := ⟨i.val+1,lt_trans hgap (d.partner i).isLt⟩
+  have hij : i < j := by change i.val < i.val+1;omega
+  have hjp : j < d.partner i := hgap
+  have hpj : j < d.partner j := by
+    by_contra h
+    have hpj : d.partner j < j := lt_of_le_of_ne (le_of_not_gt h) (d.distinct j)
+    have hai : d.partner j ≠ i := by
+      intro h
+      have h' : j=d.partner i := (d.involutive j).symm.trans (congrArg d.partner h)
+      exact (ne_of_lt hjp) h'
+    have hapi : d.partner j < i := by
+      have haival : (d.partner j).val ≠ i.val := by intro hh;exact hai (Fin.ext hh)
+      change (d.partner j).val < i.val
+      change (d.partner j).val < i.val+1 at hpj
+      omega
+    apply d.noncrossing (d.partner j) i hapi
+    · simpa only [d.involutive j] using hij
+    · simpa only [d.involutive j] using hjp
+  have upper : d.partner j < d.partner i := by
+    have hnlt : ¬d.partner i < d.partner j := fun h=> d.noncrossing i j hij hjp h
+    have hne : d.partner j ≠ d.partner i := fun hh=> ne_of_gt hij (d.partner.injective hh)
+    exact lt_of_le_of_ne (le_of_not_gt hnlt) hne
+  have hmem : j∈s := Finset.mem_filter.mpr ⟨Finset.mem_univ _,hpj⟩
+  have hm := hmin j hmem
+  change (d.partner i).val-i.val ≤ (d.partner j).val-(i.val+1) at hm
+  change (d.partner j).val < (d.partner i).val at upper
+  omega
+end TorsionFreeZeroDivisors.WordPairing
+namespace TorsionFreeZeroDivisors.WordPairing.EraseEar
+open scoped Classical
+variable {A : Type*} {n : ℕ} {inv : A→A} {label : Fin (n+2)→A}
+  (d : Data inv label) (k : ℕ) (hk : k≤n)
+  (hpair : d.partner (Ear.equiv k hk (.inr false))=Ear.equiv k hk (.inr true))
+include hpair in
+lemma back : d.partner (Ear.equiv k hk (.inr true))=Ear.equiv k hk (.inr false) :=
+  (congrArg d.partner hpair).symm.trans (d.involutive _)
+include hpair in
+lemma remains (i : Fin n) : ∃j : Fin n,Ear.raise k j=d.partner (Ear.raise k i) := by
+  obtain ⟨a,ha⟩ := (Ear.equiv k hk).surjective (d.partner (Ear.raise k i))
+  cases a with
+  | inl j => exact ⟨j,ha⟩
+  | inr b =>
+    cases b with
+    | false =>
+      have he := hpair.symm.trans ((congrArg d.partner ha).trans (d.involutive _))
+      change Ear.equiv k hk (.inr true)=Ear.equiv k hk (.inl i) at he
+      cases (Ear.equiv k hk).injective he
+    | true =>
+      have he := (back d k hk hpair).symm.trans ((congrArg d.partner ha).trans (d.involutive _))
+      change Ear.equiv k hk (.inr false)=Ear.equiv k hk (.inl i) at he
+      cases (Ear.equiv k hk).injective he
+
+def lower (i : Fin n) : Fin n := Classical.choose (remains d k hk hpair i)
+lemma lower_spec (i : Fin n) : Ear.raise k (lower d k hk hpair i)=d.partner (Ear.raise k i) :=
+  Classical.choose_spec (remains d k hk hpair i)
+lemma lower_involutive : Function.Involutive (lower d k hk hpair) := by
+  intro i
+  apply Ear.raise_injective k
+  rw [lower_spec,lower_spec,d.involutive]
+
+def data : Data inv (fun i=>label (Ear.raise (n:=n) k i)) where
+  partner := ⟨lower d k hk hpair,lower d k hk hpair,
+    lower_involutive d k hk hpair,lower_involutive d k hk hpair⟩
+  involutive := lower_involutive d k hk hpair
+  distinct i := by
+    intro he
+    have hh := congrArg (Ear.raise k) he
+    change Ear.raise k (lower d k hk hpair i)=Ear.raise k i at hh
+    rw [lower_spec] at hh
+    exact d.distinct _ hh
+  compatible i := by
+    change label (Ear.raise k (lower d k hk hpair i))=inv (label (Ear.raise k i))
+    rw [lower_spec,d.compatible]
+  noncrossing i j hij hji hpp := by
+    apply d.noncrossing (Ear.raise k i) (Ear.raise k j) ((Ear.raise_lt k i j).mpr hij)
+    · rw [←lower_spec d k hk hpair i]
+      exact (Ear.raise_lt k _ _).mpr hji
+    · rw [←lower_spec d k hk hpair i,←lower_spec d k hk hpair j]
+      exact (Ear.raise_lt k _ _).mpr hpp
+
+lemma recover : Ear.partner k (data d k hk hpair) hk=d.partner := by
+  apply Equiv.ext
+  intro i
+  obtain ⟨a,rfl⟩ := (Ear.equiv k hk).surjective i
+  rw [Ear.partner_apply]
+  cases a with
+  | inl i => exact lower_spec d k hk hpair i
+  | inr b =>
+    cases b with
+    | false => exact hpair.symm
+    | true => exact (back d k hk hpair).symm
+
+lemma euler (hd : DiskEuler (data d k hk hpair)) : DiskEuler d := by
+  apply Or.inr
+  rw [←recover d k hk hpair]
+  exact Ear.euler k hk (data d k hk hpair) hd
+end TorsionFreeZeroDivisors.WordPairing.EraseEar
+namespace TorsionFreeZeroDivisors.WordPairing
+open scoped Classical
+variable {A : Type*} {inv : A → A}
+/-- Every literal finite noncrossing inverse-letter matching has the disk Euler
+estimate, independently of its choice as a free cancellation witness. -/
+theorem Data.diskEuler {n : ℕ} {label : Fin n → A} (d : Data inv label) : DiskEuler d := by
+  induction n using Nat.strong_induction_on with
+  | h n ih =>
+    cases n with
+    | zero => exact Or.inl rfl
+    | succ n =>
+      cases n with
+      | zero => exact False.elim (d.distinct 0 (Fin.ext (by have h := (d.partner 0).isLt; omega)))
+      | succ n =>
+        obtain ⟨i,hi⟩ := adjacent_ear d (by omega)
+        have hk : i.val ≤ n := by have hb := (d.partner i).isLt;omega
+        have hp : d.partner (Ear.equiv i.val hk (.inr false))=
+            Ear.equiv i.val hk (.inr true) := by
+          have he : Ear.equiv i.val hk (.inr false)=i := Fin.ext rfl
+          rw [he]
+          exact Fin.ext hi
+        apply EraseEar.euler d i.val hk hp
+        exact ih n (by omega) (EraseEar.data d i.val hk hp)
+end TorsionFreeZeroDivisors.WordPairing
+
+namespace TorsionFreeZeroDivisors.MapEuler
+open PermutationCycles
+variable {O : Type} [Fintype O] (σ α : Equiv.Perm O)
+lemma component_sameCycle {x y : O} (h : σ.SameCycle x y) :
+    component σ α x=component σ α y := by
+  obtain ⟨k,hk⟩ := h.exists_nat_pow_eq
+  have hh := PermutationCycles.invariant_pow σ (component σ α) (component_rotation σ α) k x
+  rw [hk] at hh
+  exact hh.symm
+end TorsionFreeZeroDivisors.MapEuler
+namespace TorsionFreeZeroDivisors.WordPairing
+open scoped Classical
+open MapEuler PermutationCycles
+variable {A : Type*} {n : ℕ} {inv : A→A} {label : Fin n→A} (d : Data inv label)
+lemma rotate_sameCycle (hn : 2≤n) (x y : Fin n) : (finRotate n).SameCycle x y := by
+  apply (isCycle_finRotate_of_le hn).sameCycle
+  · exact Equiv.Perm.mem_support.mp (by rw [support_finRotate_of_le hn];exact Finset.mem_univ _)
+  · exact Equiv.Perm.mem_support.mp (by rw [support_finRotate_of_le hn];exact Finset.mem_univ _)
+/-- The noncrossing cancellation matching has actual combinatorial genus zero,
+not just a scalar disk face estimate. Nonempty words (necessarily of length at
+least two) have a single map component; the empty case is separate. -/
+theorem Data.genusZero : GenusZero (finRotate n) d.partner := by
+  by_cases hn : n=0
+  · subst n
+    have hi : IsEmpty (Fin 0) := inferInstance
+    have hV : IsEmpty (Cycle (finRotate 0)) := inferInstance
+    have hF : IsEmpty (Cycle (d.partner*finRotate 0)) := inferInstance
+    have hC : IsEmpty (Component (finRotate 0) d.partner) := inferInstance
+    simp only [GenusZero,Nat.card_of_isEmpty,mul_zero,add_zero]
+    simp only [Equiv.Perm.support,Finset.univ_eq_empty,Finset.filter_empty,Finset.card_empty]
+  have hn2 : 2≤n := by
+    by_contra hh
+    have he : n=1 := by omega
+    subst n
+    exact d.distinct 0 (Subsingleton.elim _ _)
+  let : Nonempty (Fin n) := ⟨⟨0,by omega⟩⟩
+  let : Subsingleton (Cycle (finRotate n)) := ⟨by
+    intro x y
+    obtain ⟨a,rfl⟩ := cycle_surjective _ x
+    obtain ⟨b,rfl⟩ := cycle_surjective _ y
+    exact (cycle_eq _).mpr (rotate_sameCycle hn2 a b)⟩
+  let : Subsingleton (Component (finRotate n) d.partner) := ⟨by
+    intro x y
+    obtain ⟨a,rfl⟩ := Quotient.mk_surjective x
+    obtain ⟨b,rfl⟩ := Quotient.mk_surjective y
+    exact component_sameCycle _ _ (rotate_sameCycle hn2 a b)⟩
+  let : Nonempty (Cycle (finRotate n)) := ⟨cycle _ ⟨0,by omega⟩⟩
+  let : Nonempty (Component (finRotate n) d.partner) := ⟨component _ _ ⟨0,by omega⟩⟩
+  have hV : Nat.card (Cycle (finRotate n))=1 := Nat.card_unique
+  have hC : Nat.card (Component (finRotate n) d.partner)=1 := Nat.card_unique
+  have hd := (d.diskEuler).resolve_left hn
+  simp only [←Nat.card_eq_fintype_card] at hd
+  apply genusZero_of_lower (finRotate n) d.partner d.involutive
+  rw [hV,hC]
+  have he := d.distinct
+  simp only [Equiv.Perm.support,he,ne_eq,not_false_eq_true,Finset.filter_true,Finset.card_univ,Fintype.card_fin]
+  omega
+end TorsionFreeZeroDivisors.WordPairing
+
+namespace TorsionFreeZeroDivisors.DeleteCycle
+open scoped Classical
+variable {O : Type} (σ : Equiv.Perm O) (p : O)
+lemma bypass_fixed (h : σ p=p) : bypass σ p=restrict σ p h := by
+  ext x
+  change Equiv.swap p (σ p) (σ x)=σ x
+  rw [h,Equiv.swap_self]
+  rfl
+end TorsionFreeZeroDivisors.DeleteCycle
+namespace TorsionFreeZeroDivisors.IsolatedDeletion
+open scoped Classical
+open DeleteCycle MapEuler
+variable {O : Type} (σ α : Equiv.Perm O) (p : O) (hs : σ p=p) (ha : α p=p)
+def classify (x : O) : Option (Component (restrict σ p hs) (restrict α p ha)) :=
+  if hx : x=p then none else some (component _ _ ⟨x,hx⟩)
+lemma classify_rotation (x : O) : classify σ α p hs ha (σ x)=classify σ α p hs ha x := by
+  by_cases hx : x=p
+  · subst x;rw [hs]
+  · rw [classify,dite_eq_right ((invariant σ p hs x).mpr hx),classify,dite_eq_right hx]
+    exact congrArg some (component_rotation (restrict σ p hs) (restrict α p ha) ⟨x,hx⟩)
+lemma classify_partner (x : O) : classify σ α p hs ha (α x)=classify σ α p hs ha x := by
+  by_cases hx : x=p
+  · subst x;rw [ha]
+  · rw [classify,dite_eq_right ((invariant α p ha x).mpr hx),classify,dite_eq_right hx]
+    exact congrArg some (component_partner (restrict σ p hs) (restrict α p ha) ⟨x,hx⟩)
+def project : Component σ α → Option (Component (restrict σ p hs) (restrict α p ha)) :=
+  MapEuler.lift σ α (classify σ α p hs ha) (classify_rotation σ α p hs ha) (classify_partner σ α p hs ha)
+def inclusion : Component (restrict σ p hs) (restrict α p ha) → Component σ α :=
+  MapEuler.lift _ _ (fun x : Rest p=>component σ α x)
+    (fun x=>component_rotation σ α x) (fun x=>component_partner σ α x)
+lemma project_injective : Function.Injective (project σ α p hs ha) := by
+  intro c d he
+  obtain ⟨x,rfl⟩ := Quotient.mk_surjective c
+  obtain ⟨y,rfl⟩ := Quotient.mk_surjective d
+  change classify σ α p hs ha x=classify σ α p hs ha y at he
+  by_cases hx : x=p
+  · subst x
+    have hy : y=p := by
+      by_contra hy
+      simp [classify,hy] at he
+    subst y;rfl
+  · by_cases hy : y=p
+    · subst y;simp [classify,hx] at he
+    · simp only [classify,dite_eq_right hx,dite_eq_right hy,Option.some.injEq] at he
+      exact congrArg (inclusion σ α p hs ha) he
+lemma project_surjective : Function.Surjective (project σ α p hs ha) := by
+  intro c
+  cases c with
+  | none=>exact ⟨component σ α p,by simp [project,MapEuler.lift,classify,component]⟩
+  | some c=>
+    obtain ⟨x,rfl⟩ := Quotient.mk_surjective c
+    refine ⟨component σ α x,?_⟩
+    change classify σ α p hs ha x=some (component _ _ x)
+    simp only [classify,dite_eq_right x.property]
+def componentEquiv : Component σ α ≃ Option (Component (restrict σ p hs) (restrict α p ha)) :=
+  Equiv.ofBijective (project σ α p hs ha) ⟨project_injective σ α p hs ha,project_surjective σ α p hs ha⟩
+variable [Fintype O]
+lemma component_count : Nat.card (Component σ α)=Nat.card (Component (restrict σ p hs) (restrict α p ha))+1 := by
+  simpa only [Nat.card_eq_fintype_card,Fintype.card_option] using Nat.card_congr (componentEquiv σ α p hs ha)
+include hs in
+/-- Deleting an isolated unpaired occurrence removes one vertex, one face and
+one actual connected component; genus zero is preserved also in the empty case. -/
+theorem genusZero (hz : GenusZero σ α) :
+    GenusZero (bypass σ p) (restrict α p ha) := by
+  rw [bypass_fixed σ p hs]
+  have hv := fixed_count σ p hs
+  have hf := fixed_count (α*σ) p (show (α*σ) p=p by change α (σ p)=p;rw [hs,ha])
+  have hc := component_count σ α p hs ha
+  have he := MapDeletion.support_count α p ha
+  simp only [←Nat.card_eq_fintype_card] at hv hf
+  have hface : restrict (α*σ) p (show (α*σ) p=p by change α (σ p)=p;rw [hs,ha])=
+      restrict α p ha*restrict σ p hs := by ext x;rfl
+  rw [hface] at hf
+  dsimp only [GenusZero] at hz ⊢
+  have hsup : (restrict α p ha).support.card=α.support.card := by
+    convert he using 1
+  have hh : 2*Nat.card (PermutationCycles.Cycle (restrict σ p hs))+
+      2*Nat.card (PermutationCycles.Cycle (restrict α p ha*restrict σ p hs))=
+      (restrict α p ha).support.card+4*Nat.card (Component (restrict σ p hs) (restrict α p ha)) := by omega
+  have hinst : ∀ (i j : Fintype (Rest p)) (d e : DecidableEq (Rest p)),
+      @Equiv.Perm.support (Rest p) d i (restrict α p ha)=
+      @Equiv.Perm.support (Rest p) e j (restrict α p ha) := by
+    intro i j d e
+    cases Subsingleton.elim i j
+    cases Subsingleton.elim d e
+    rfl
+  convert hh using 1
+  congr 1
+  exact congrArg Finset.card (hinst _ _ _ _)
+end TorsionFreeZeroDivisors.IsolatedDeletion
+namespace TorsionFreeZeroDivisors.MapDeletion
+open scoped Classical
+open DeleteCycle MapEuler
+variable {O : Type} [Fintype O] (σ α : Equiv.Perm O) (p : O) (ha : α p=p)
+/-- Unconditional deletion of an unpaired occurrence, including isolated
+vertices/components. -/
+theorem genusZero_delete_all (hz : GenusZero σ α) : GenusZero (bypass σ p) (restrict α p ha) := by
+  by_cases hs : σ p=p
+  · exact IsolatedDeletion.genusZero σ α p hs ha hz
+  · exact genusZero_delete σ α p ha hs hz
+end TorsionFreeZeroDivisors.MapDeletion
+
+namespace TorsionFreeZeroDivisors.BandEuler
+open scoped Classical
+open DeleteCycle MapEuler
+variable {O : Type} [Fintype O] (σ α : Equiv.Perm O)
+  (hi : Function.Involutive α) (p q : O) (hpq : p≠q) (hpair : α p=q)
+include hi hpair in
+/-- Paired-band deletion preserves genus zero without any degree or face
+nondegeneracy assumptions. Empty residual maps, isolated disks, monogons, digons,
+and split components are all included. This is purely a permutation-map result,
+not an assertion that an essential sphere survives the surgery. -/
+theorem genusZero_all (hz : GenusZero σ α) :
+    GenusZero (rotation σ p q hpq) (partner α hi p q hpq hpair) := by
+  have h₀ := switched_genusZero σ α hi p q hpq hpair hz
+  have h₁ := MapDeletion.genusZero_delete_all (switched σ p q) (adjusted α p q) p
+    (adjusted_p α hi p q hpair) h₀
+  have h₂ := MapDeletion.genusZero_delete_all (bypass (switched σ p q) p) (α₁ α hi p q hpair)
+    (q' p q hpq) (α₁_q α hi p q hpq hpair) h₁
+  exact (genusZero_fintype _ _ _ _).mp h₂
+end TorsionFreeZeroDivisors.BandEuler
+namespace TorsionFreeZeroDivisors.MapEuler
+open scoped Classical
+open PermutationCycles
+variable {O : Type} [Fintype O] (σ α : Equiv.Perm O)
+/-- Exact Euler lower bound used by the source interval estimate, extracted
+from actual combinatorial genus zero. No connectivity is assumed: one actual
+occurrence suffices to make the component count positive. -/
+theorem euler_of_genusZero [Nonempty O] (hz : GenusZero σ α) (hf : ∀x,α x≠x) :
+    Fintype.card O+4≤2*Fintype.card (Cycle σ)+2*Fintype.card (Cycle (α*σ)) := by
+  let : Nonempty (Component σ α) := ⟨component σ α (Classical.choice inferInstance)⟩
+  have hc : 0<Nat.card (Component σ α) := Nat.card_pos
+  have he : α.support.card=Fintype.card O := by
+    simp only [Equiv.Perm.support,hf,ne_eq,not_false_eq_true,Finset.filter_true,Finset.card_univ]
+  dsimp only [GenusZero] at hz
+  simp only [Nat.card_eq_fintype_card] at hz hc
+  rw [he] at hz
+  omega
+end TorsionFreeZeroDivisors.MapEuler
+
+namespace TorsionFreeZeroDivisors.BoundarySurgery
+open scoped Classical
+open DeleteCycle BandEuler
+variable {O V : Type} [Fintype O] (σ : Equiv.Perm O) (before after : O→V)
+/-- Consecutive edge endpoint agreement. A marked exterior break can be encoded
+by one extra formal item with distinct prescribed before/after endpoints. -/
+def Consistent : Prop := ∀ x,after x=before (σ x)
+include σ in
+lemma bypass_consistent (h : Consistent σ before after) (p : O) (hp : after p=before p) :
+    Consistent (bypass σ p) (fun x : Rest p=>before x) (fun x : Rest p=>after x) := by
+  intro x
+  change after (x : O)=before ((bypass σ p x : Rest p) : O)
+  rw [bypass_apply,MapEuler.swap_invariant before p (σ p) (hp.symm.trans (h p))]
+  exact h x
+variable (p q : O) (hpq : p≠q)
+def swappedBefore (x : O) : V := before (Equiv.swap p q x)
+omit [Fintype O] in
+lemma switched_consistent (h : Consistent σ before after) :
+    Consistent (switched σ p q) (swappedBefore before p q) after := by
+  intro x
+  change after x=before (Equiv.swap p q (Equiv.swap p q (σ x)))
+  rw [Equiv.swap_apply_self]
+  exact h x
+/-- The literal band-spliced boundary preserves the graph endpoint equations.
+The two crossed endpoints are exactly those forced by an edge and its reverse.
+No statement about homotopy or essentiality is hidden in this combinatorial
+lemma, and neither distinct-boundary nor same-boundary cases are excluded. -/
+theorem consistent (h : Consistent σ before after)
+    (hp : after p=before q) (hq : after q=before p) :
+    Consistent (rotation σ p q hpq) (fun x=>before (val p q hpq x))
+      (fun x=>after (val p q hpq x)) := by
+  have hp' : after p=swappedBefore before p q p := by rw [swappedBefore,Equiv.swap_apply_left];exact hp
+  have hq' : after q=swappedBefore before p q q := by rw [swappedBefore,Equiv.swap_apply_right];exact hq
+  have h₁ := bypass_consistent (switched σ p q) (swappedBefore before p q) after
+    (switched_consistent σ before after p q h) p hp'
+  have h₂ := bypass_consistent (bypass (switched σ p q) p)
+    (fun x : Rest p=>swappedBefore before p q x) (fun x : Rest p=>after x) h₁
+    (q' p q hpq) hq'
+  intro x
+  have hh := h₂ x
+  change after (val p q hpq x)=swappedBefore before p q (val p q hpq (rotation σ p q hpq x)) at hh
+  rw [swappedBefore,Equiv.swap_apply_of_ne_of_ne (val_ne_p p q hpq _) (val_ne_q p q hpq _)] at hh
+  exact hh
+/-- A surviving exterior marker keeps its prescribed distinct endpoints, so
+its new boundary contains at least one actual edge after the deletion. -/
+lemma marker_nonfixed (h : Consistent σ before after)
+    (hp : after p=before q) (hq : after q=before p)
+    (m : Residual p q hpq) (hm : after (val p q hpq m)≠before (val p q hpq m)) :
+    rotation σ p q hpq m≠m := by
+  intro he
+  have hh := consistent σ before after p q hpq h hp hq m
+  rw [he] at hh
+  exact hm hh
+end TorsionFreeZeroDivisors.BoundarySurgery
+
+namespace TorsionFreeZeroDivisors.VertexSplit
+open scoped Classical
+open PermutationCycles ComponentEuler
+variable {O : Type} [Fintype O] (σ α : Equiv.Perm O) (p q : O)
+  (l : List (O×O)) (hl : (l.map (fun e=>Equiv.swap e.1 e.2)).prod=α)
+  (he : ∀e∈l,α e.1=e.2)
+  (hc : cycle σ p=cycle σ q)
+local notation "σ'" => Equiv.swap p q*σ
+local notation "L'" => (α p,α q)::l
+local notation "f'" => forest σ' L'
+include hl in
+lemma forest_partner (x : O) : cycle f' (α x)=cycle f' x := by
+  have h := MapEuler.product_invariant l (cycle f')
+    (fun e h=>forest_pair σ' L' e (List.mem_cons_of_mem _ h)) x
+  simpa only [hl] using h
+include hl in
+lemma forest_join : cycle f' p=cycle f' q := by
+  have h := forest_pair σ' L' (α p,α q) List.mem_cons_self
+  dsimp only at h
+  rw [forest_partner σ α p q l hl,forest_partner σ α p q l hl] at h
+  exact h
+include hl in
+lemma forest_rotation (x : O) : cycle f' (σ x)=cycle f' x := by
+  have hh := forest_refines σ' L' (σ' x) x (cycle_apply σ' x)
+  change cycle f' (Equiv.swap p q (σ x))=cycle f' x at hh
+  rw [SwapCycles.cycle_swap f' p q (forest_join σ α p q l hl) (σ x)] at hh
+  exact hh
+include he hc in
+lemma original_invariant (x : O) : MapEuler.component σ α (f' x)=MapEuler.component σ α x := by
+  have hpq : MapEuler.component σ α p=MapEuler.component σ α q :=
+    MapEuler.component_sameCycle σ α ((cycle_eq σ).mp hc)
+  apply invariant_forest σ' L' (MapEuler.component σ α)
+  · intro y
+    change MapEuler.component σ α (Equiv.swap p q (σ y))=MapEuler.component σ α y
+    rw [MapEuler.swap_invariant (MapEuler.component σ α) p q hpq]
+    exact MapEuler.component_rotation σ α y
+  · intro e h
+    rcases List.mem_cons.mp h with rfl|h
+    · dsimp only
+      rw [MapEuler.component_partner,MapEuler.component_partner]
+      exact hpq
+    · rw [←he e h]
+      exact (MapEuler.component_partner σ α e.1).symm
+
+def toOriginal : Cycle f' → MapEuler.Component σ α :=
+  PermutationCycles.lift f' (MapEuler.component σ α) (original_invariant σ α p q l he hc)
+def toForest : MapEuler.Component σ α → Cycle f' :=
+  MapEuler.lift σ α (cycle f') (forest_rotation σ α p q l hl) (forest_partner σ α p q l hl)
+def componentEquiv : Cycle f' ≃ MapEuler.Component σ α :=
+  Equiv.ofBijective (toOriginal σ α p q l he hc) ⟨by
+    intro c d h
+    obtain ⟨x,rfl⟩ := cycle_surjective f' c
+    obtain ⟨y,rfl⟩ := cycle_surjective f' d
+    exact congrArg (toForest σ α p q l hl) h,
+    PermutationCycles.lift_surjective _ _ _ Quotient.mk_surjective⟩
+omit [Fintype O] in
+include hl in
+lemma face_eq : face σ' L'=α*σ := by
+  rw [MapEuler.face_product,List.map_cons,List.prod_cons,hl]
+  have hs : Equiv.swap (α p) (α q)*α=α*Equiv.swap p q := by
+    ext x
+    exact α.injective.swap_apply p q x
+  rw [hs,mul_assoc,←mul_assoc (Equiv.swap p q),Equiv.swap_mul_self,one_mul]
+end TorsionFreeZeroDivisors.VertexSplit
+namespace TorsionFreeZeroDivisors.MapEuler
+open scoped Classical
+open PermutationCycles ComponentEuler
+variable {O : Type} [Fintype O] (σ α : Equiv.Perm O) (hi : Function.Involutive α)
+include hi in
+/-- Splitting a vertex along two gaps preserves combinatorial genus zero.
+This permits empty/isolated components and needs no topological embedding
+assumption. The two gaps must be on the same actual vertex cycle. -/
+theorem genusZero_vertexSplit (hz : GenusZero σ α) (p q : O) (hpq : p≠q)
+    (hc : cycle σ p=cycle σ q) : GenusZero (Equiv.swap p q*σ) α := by
+  obtain ⟨l,hl,hL,he⟩ := PairingFactors.factorization α hi
+  let σ' := Equiv.swap p q*σ
+  let L' := (α p,α q)::l
+  have hC := Nat.card_congr (VertexSplit.componentEquiv σ α p q l hl (fun e h=>(he e h).2) hc)
+  have hV := SwapCycles.split_count σ p q hpq hc
+  simp only [←Nat.card_eq_fintype_card] at hV
+  have hF := VertexSplit.face_eq σ α p q l hl
+  have hD : ∀e∈L',e.1≠e.2 := by
+    intro e h
+    rcases List.mem_cons.mp h with rfl|h
+    · exact fun h=>hpq (α.injective h)
+    · exact (he e h).1
+  have hh := handles_exact σ' L' hD
+  change Nat.card (Cycle σ')+Nat.card (Cycle (face σ' L'))+2*handles σ' L'=
+    L'.length+2*Nat.card (Cycle (forest σ' L')) at hh
+  change face σ' L'=α*σ at hF
+  rw [hF,hC] at hh
+  have hh₀ : handles σ' L'=0 := by
+    dsimp only [L',List.length_cons] at hh
+    dsimp only [GenusZero] at hz
+    change Nat.card (Cycle σ')=Nat.card (Cycle σ)+1 at hV
+    change handles σ' ((α p,α q)::l)=0
+    omega
+  have ht : handles σ' l=0 := Nat.eq_zero_of_le_zero
+    ((handles_tail σ' (α p,α q) l).trans_eq hh₀)
+  exact (genusZero_iff_handles σ' α l hl he hL).mpr ht
+end TorsionFreeZeroDivisors.MapEuler
+
+namespace TorsionFreeZeroDivisors.MapConjugation
+open scoped Classical
+open MapEuler PermutationCycles
+variable {A B : Type} (e : A ≃ B) (σ α : Equiv.Perm A)
+local notation "σ'" => e.permCongr σ
+local notation "α'" => e.permCongr α
+def forward : Component σ α → Component σ' α' :=
+  MapEuler.lift σ α (fun x=>component σ' α' (e x))
+    (fun x=>by simpa only [Equiv.permCongr_apply,Equiv.symm_apply_apply] using component_rotation σ' α' (e x))
+    (fun x=>by simpa only [Equiv.permCongr_apply,Equiv.symm_apply_apply] using component_partner σ' α' (e x))
+def backward : Component σ' α' → Component σ α :=
+  MapEuler.lift σ' α' (fun x=>component σ α (e.symm x))
+    (fun x=>by simpa only [Equiv.permCongr_apply,Equiv.symm_apply_apply] using component_rotation σ α (e.symm x))
+    (fun x=>by simpa only [Equiv.permCongr_apply,Equiv.symm_apply_apply] using component_partner σ α (e.symm x))
+def components : Component σ α ≃ Component σ' α' where
+  toFun := forward e σ α
+  invFun := backward e σ α
+  left_inv c := by
+    obtain ⟨x,rfl⟩ := Quotient.mk_surjective c
+    change component σ α (e.symm (e x))=component σ α x
+    rw [e.symm_apply_apply]
+  right_inv c := by
+    obtain ⟨x,rfl⟩ := Quotient.mk_surjective c
+    change component σ' α' (e (e.symm x))=component σ' α' x
+    rw [e.apply_symm_apply]
+variable [Fintype A] [Fintype B]
+def supports : ↥α.support ≃ ↥(α').support where
+  toFun x := ⟨e x,by
+    apply Equiv.Perm.mem_support.mpr
+    intro h
+    have hn := Equiv.Perm.mem_support.mp x.property
+    exact hn (e.injective (by simpa only [Equiv.permCongr_apply,Equiv.symm_apply_apply] using h))⟩
+  invFun x := ⟨e.symm x,by
+    apply Equiv.Perm.mem_support.mpr
+    intro h
+    have hn := Equiv.Perm.mem_support.mp x.property
+    apply hn
+    change e (α (e.symm x))=x
+    rw [h,e.apply_symm_apply]⟩
+  left_inv x := by ext;simp
+  right_inv x := by ext;simp
+lemma support_count : (α').support.card=α.support.card := by
+  simpa only [Fintype.card_coe] using (Fintype.card_congr (supports e α)).symm
+/-- Changing the actual finite occurrence coordinates does not change genus. -/
+theorem genusZero (h : GenusZero σ α) : GenusZero σ' α' := by
+  have hC := Nat.card_congr (components e σ α)
+  have hV := Nat.card_congr (PermutationTransport.cycles e σ)
+  have hF := Nat.card_congr (PermutationTransport.cycles e (α*σ))
+  rw [PermutationTransport.mul] at hF
+  have hE := support_count e α
+  dsimp only [GenusZero] at h ⊢
+  rw [←hC,←hV,←hF,hE]
+  exact h
+end TorsionFreeZeroDivisors.MapConjugation
+
+/-! The finite matching operation for the same-lifted-edge band surgery.
+Deleting two inverse occurrences splices their partners unless they were already
+paired. Labels, involutivity and the absence of fixed points are proved from the
+actual matching. This file does not assert a surface realization or essentiality.
+-/
+namespace TorsionFreeZeroDivisors.MatchingSurgery
+open scoped Classical
+variable {O A : Type*} (α : Equiv.Perm O) (hi : Function.Involutive α)
+  (hf : ∀x,α x≠x) (p q : O) (hpq : p≠q)
+
+abbrev Remaining := {x : O // x≠p ∧ x≠q}
+def splice (x : O) : O := if α x=p then α q else if α x=q then α p else α x
+
+include hi hf in
+lemma splice_avoids (x : Remaining p q) : splice α p q x≠p ∧ splice α p q x≠q := by
+  by_cases h1 : α x=p
+  · have hx : α p=x := (congrArg α h1).symm.trans (hi x)
+    have hqp : α q≠p := by
+      intro h
+      have h' : q=α p := (hi _).symm.trans (congrArg α h)
+      exact x.property.2 (hx ▸ h'.symm)
+    rw [splice,ite_eq_left h1]
+    exact ⟨hqp,hf q⟩
+  · by_cases h2 : α x=q
+    · have hx : α q=x := (congrArg α h2).symm.trans (hi x)
+      have hpq' : α p≠q := by
+        intro h
+        have h' : p=α q := (hi _).symm.trans (congrArg α h)
+        exact x.property.1 (hx ▸ h'.symm)
+      rw [splice,ite_eq_right h1,ite_eq_left h2]
+      exact ⟨hf p,hpq'⟩
+    · rw [splice,ite_eq_right h1,ite_eq_right h2]
+      exact ⟨h1,h2⟩
+
+def apply (x : Remaining p q) : Remaining p q := ⟨splice α p q x,splice_avoids α hi hf p q x⟩
+
+include hpq in
+lemma involutive : Function.Involutive (apply α hi hf p q) := by
+  intro x
+  apply Subtype.ext
+  change splice α p q (splice α p q x)=x
+  by_cases h1 : α x=p
+  · have hx : α p=x := (congrArg α h1).symm.trans (hi x)
+    have hs : splice α p q x=α q := by rw [splice,ite_eq_left h1]
+    rw [hs,splice,hi q,ite_eq_right hpq.symm,ite_eq_left rfl]
+    exact hx
+  · by_cases h2 : α x=q
+    · have hx : α q=x := (congrArg α h2).symm.trans (hi x)
+      have hs : splice α p q x=α p := by rw [splice,ite_eq_right h1,ite_eq_left h2]
+      rw [hs,splice,hi p,ite_eq_left rfl]
+      exact hx
+    · have hs : splice α p q x=α x := by rw [splice,ite_eq_right h1,ite_eq_right h2]
+      rw [hs,splice,hi x,ite_eq_right x.property.1,ite_eq_right x.property.2]
+
+include hpq in
+lemma distinct (x : Remaining p q) : apply α hi hf p q x≠x := by
+  intro he
+  have he := congrArg Subtype.val he
+  change splice α p q x=x at he
+  by_cases h1 : α x=p
+  · have hx : α p=x := (congrArg α h1).symm.trans (hi x)
+    rw [splice,ite_eq_left h1] at he
+    exact hpq (α.injective (hx.trans he.symm))
+  · by_cases h2 : α x=q
+    · have hx : α q=x := (congrArg α h2).symm.trans (hi x)
+      rw [splice,ite_eq_right h1,ite_eq_left h2] at he
+      exact hpq (α.injective (he.trans hx.symm))
+    · exact hf x (by simpa [splice,h1,h2] using he)
+
+def partner : Equiv.Perm (Remaining p q) := ⟨apply α hi hf p q,apply α hi hf p q,involutive α hi hf p q hpq,involutive α hi hf p q hpq⟩
+
+variable (inv : A→A) (hinv : Function.Involutive inv) (label : O→A)
+  (hl : ∀x,label (α x)=inv (label x)) (hlabel : label q=inv (label p))
+include hinv hl hlabel in
+lemma compatible (x : Remaining p q) :
+    label (partner α hi hf p q hpq x)=inv (label x) := by
+  change label (splice α p q x)=_
+  by_cases h1 : α x=p
+  · rw [splice,ite_eq_left h1,hl,hlabel,hinv]
+    exact (congrArg label h1).symm.trans (hl x)
+  · by_cases h2 : α x=q
+    · rw [splice,ite_eq_right h1,ite_eq_left h2,hl,←hlabel]
+      exact (congrArg label h2).symm.trans (hl x)
+    · rw [splice,ite_eq_right h1,ite_eq_right h2,hl]
+
+end TorsionFreeZeroDivisors.MatchingSurgery
+namespace TorsionFreeZeroDivisors.Smoothing
+open scoped Classical
+open DeleteCycle
+variable {O : Type} (σ α : Equiv.Perm O)
+  (hi : Function.Involutive α) (hf : ∀x,α x≠x)
+  (p q : O) (hpq : p≠q) (hsp : σ p=q) (hsq : σ q=p)
+
+include hsp hsq in
+lemma rotation_invariant (x : O) : (σ x≠p ∧ σ x≠q) ↔ (x≠p ∧ x≠q) := by
+  constructor
+  · rintro ⟨hp,hq⟩
+    exact ⟨fun h=>hq (h ▸ hsp),fun h=>hp (h ▸ hsq)⟩
+  · rintro ⟨hp,hq⟩
+    exact ⟨fun h=>hq (σ.injective (h.trans hsq.symm)),fun h=>hp (σ.injective (h.trans hsp.symm))⟩
+def rotation : Equiv.Perm (MatchingSurgery.Remaining p q) :=
+  σ.subtypePerm (rotation_invariant σ p q hsp hsq)
+
+abbrev r := α p
+include hf in
+lemma pr : p≠r α p := (hf p).symm
+include hf hpq in
+lemma rename_invariant (x : O) :
+    (Equiv.swap q (r α p) x≠p ∧ Equiv.swap q (r α p) x≠q) ↔ (x≠p ∧ x≠r α p) := by
+  have hp : Equiv.swap q (r α p) p=p := Equiv.swap_apply_of_ne_of_ne hpq (pr α hf p)
+  have hr : Equiv.swap q (r α p) (r α p)=q := Equiv.swap_apply_right _ _
+  constructor
+  · rintro ⟨h1,h2⟩
+    exact ⟨fun h=>h1 (h ▸ hp),fun h=>h2 (h ▸ hr)⟩
+  · rintro ⟨h1,h2⟩
+    exact ⟨fun h=>h1 ((Equiv.swap q (r α p)).injective (h.trans hp.symm)),
+      fun h=>h2 ((Equiv.swap q (r α p)).injective (h.trans hr.symm))⟩
+def flatten : BandEuler.Residual p (r α p) (pr α hf p) ≃ MatchingSurgery.Remaining p (r α p) where
+  toFun x := ⟨BandEuler.val p (r α p) (pr α hf p) x,
+    BandEuler.val_ne_p p (r α p) (pr α hf p) x,BandEuler.val_ne_q p (r α p) (pr α hf p) x⟩
+  invFun x := ⟨⟨x,x.property.1⟩,fun he=>x.property.2 (congrArg Subtype.val he)⟩
+  left_inv _ := rfl
+  right_inv _ := rfl
+def rename : MatchingSurgery.Remaining p (r α p) ≃ MatchingSurgery.Remaining p q :=
+  (Equiv.swap q (r α p)).subtypeEquiv (fun x=>(rename_invariant α hf p q hpq x).symm)
+def coordinates : BandEuler.Residual p (r α p) (pr α hf p) ≃ MatchingSurgery.Remaining p q :=
+  (flatten α hf p).trans (rename α hf p q hpq)
+lemma coordinates_val (x : BandEuler.Residual p (r α p) (pr α hf p)) :
+    (coordinates α hf p q hpq x).val=Equiv.swap q (r α p) (BandEuler.val p (r α p) (pr α hf p) x) := rfl
+
+lemma partner_commutes (x : BandEuler.Residual p (r α p) (pr α hf p)) :
+    coordinates α hf p q hpq (BandEuler.partner α hi p (r α p) (pr α hf p) rfl x)=
+      MatchingSurgery.partner α hi hf p q hpq (coordinates α hf p q hpq x) := by
+  apply Subtype.ext
+  rw [coordinates_val,BandEuler.partner_val]
+  change Equiv.swap q (α p) (α (BandEuler.val p (α p) (pr α hf p) x))=
+    MatchingSurgery.splice α p q (Equiv.swap q (α p) (BandEuler.val p (α p) (pr α hf p) x))
+  let v := BandEuler.val p (α p) (pr α hf p) x
+  change Equiv.swap q (α p) (α v)=MatchingSurgery.splice α p q (Equiv.swap q (α p) v)
+  have hvp : v≠p := BandEuler.val_ne_p _ _ _ x
+  have hvr : v≠α p := BandEuler.val_ne_q _ _ _ x
+  have havp : α v≠p := fun h=>hvr ((hi _).symm.trans (congrArg α h))
+  have havr : α v≠α p := α.injective.ne hvp
+  by_cases hvq : v=q
+  · rw [hvq,Equiv.swap_apply_left,MatchingSurgery.splice,hi p,ite_eq_left rfl]
+    have hαq : α q≠q := hf q
+    have hαqr : α q≠α p := α.injective.ne hpq.symm
+    exact Equiv.swap_apply_of_ne_of_ne hαq hαqr
+  · rw [Equiv.swap_apply_of_ne_of_ne hvq hvr,MatchingSurgery.splice,ite_eq_right havp]
+    by_cases havq : α v=q
+    · rw [ite_eq_left havq,havq,Equiv.swap_apply_left]
+    · rw [ite_eq_right havq,Equiv.swap_apply_of_ne_of_ne havq havr]
+
+lemma bypass_value (f : Equiv.Perm O) (a : O) (x : Rest a) :
+    (bypass f a x).val=if f x=a then f a else f x := by
+  change Equiv.swap a (f a) (f x)=_
+  by_cases h : f x=a
+  · rw [ite_eq_left h,h,Equiv.swap_apply_left]
+  · rw [ite_eq_right h,Equiv.swap_apply_of_ne_of_ne h (f.injective.ne x.property)]
+lemma rotation_value (a b : O) (hab : a≠b) (x : BandEuler.Residual a b hab) :
+    BandEuler.val a b hab (BandEuler.rotation σ a b hab x)=
+      let f := BandEuler.switched σ a b
+      let g := fun y=>if f y=a then f a else f y
+      if g (BandEuler.val a b hab x)=b then g b else g (BandEuler.val a b hab x) := by
+  let f := BandEuler.switched σ a b
+  let g := fun y=>if f y=a then f a else f y
+  change ((bypass (bypass f a) (BandEuler.q' a b hab) x).val).val=
+    if g x.val.val=b then g b else g x.val.val
+  have he : bypass f a x.val=BandEuler.q' a b hab ↔ g x.val.val=b := by
+    rw [Subtype.ext_iff,bypass_value]
+  by_cases hc : g x.val.val=b
+  · rw [ite_eq_left hc]
+    have hv := bypass_value (bypass f a) (BandEuler.q' a b hab) x
+    rw [ite_eq_left (he.mpr hc)] at hv
+    exact (congrArg Subtype.val hv).trans (bypass_value f a (BandEuler.q' a b hab))
+  · rw [ite_eq_right hc]
+    have hv := bypass_value (bypass f a) (BandEuler.q' a b hab) x
+    rw [ite_eq_right (fun h=>hc (he.mp h))] at hv
+    exact (congrArg Subtype.val hv).trans (bypass_value f a x.val)
+
+include hsp hsq hpq in
+lemma smoothing_value (r v : O) (hpr : p≠r) (hvp : v≠p) (hvr : v≠r) :
+    let f := Equiv.swap p r*σ
+    let g := fun y=>if f y=p then f p else f y
+    Equiv.swap q r (if g v=r then g r else g v)=σ (Equiv.swap q r v) := by
+  let f := Equiv.swap p r*σ
+  let g := fun y=>if f y=p then f p else f y
+  change Equiv.swap q r (if g v=r then g r else g v)=_
+  by_cases hqr : q=r
+  · subst r
+    have hsvp : σ v≠p := fun h=>hvr (σ.injective (h.trans hsq.symm))
+    have hsvq : σ v≠q := fun h=>hvp (σ.injective (h.trans hsp.symm))
+    have hfv : f v=σ v := Equiv.swap_apply_of_ne_of_ne hsvp hsvq
+    have hg : g v=σ v := by
+      change (if f v=p then f p else f v)=σ v
+      simp only [hfv,ite_eq_right hsvp]
+    rw [hg,ite_eq_right hsvq,Equiv.swap_self]
+    rfl
+  · have hfp : f p=q := by
+      dsimp only [f,Equiv.Perm.mul_apply]
+      rw [hsp,Equiv.swap_apply_of_ne_of_ne hpq.symm hqr]
+    have hG (y : O) (hyp : y≠p) (hyq : y≠q) : Equiv.swap q r (g y)=σ y := by
+      have hsyp : σ y≠p := fun h=>hyq (σ.injective (h.trans hsq.symm))
+      have hsyq : σ y≠q := fun h=>hyp (σ.injective (h.trans hsp.symm))
+      by_cases hsyr : σ y=r
+      · have hfy : f y=p := by simp only [f,Equiv.Perm.mul_apply,hsyr,Equiv.swap_apply_right]
+        change Equiv.swap q r (if f y=p then f p else f y)=σ y
+        rw [ite_eq_left hfy,hfp,Equiv.swap_apply_left,hsyr]
+      · have hfy : f y=σ y := by
+          exact Equiv.swap_apply_of_ne_of_ne hsyp hsyr
+        change Equiv.swap q r (if f y=p then f p else f y)=σ y
+        simp only [hfy,ite_eq_right hsyp,Equiv.swap_apply_of_ne_of_ne hsyq hsyr]
+    by_cases hvq : v=q
+    · have hfq : f q=r := by simp only [f,Equiv.Perm.mul_apply,hsq,Equiv.swap_apply_left]
+      have hgq : g q=r := by
+        change (if f q=p then f p else f q)=r
+        simp only [hfq,ite_eq_right hpr.symm]
+      rw [hvq,hgq,ite_eq_left rfl,Equiv.swap_apply_left]
+      exact hG r hpr.symm (Ne.symm hqr)
+    · have hgv : g v≠r := by
+        intro he
+        have hh := hG v hvp hvq
+        rw [he,Equiv.swap_apply_right] at hh
+        exact hvp (σ.injective (hh.symm.trans hsp.symm))
+      rw [ite_eq_right hgv,Equiv.swap_apply_of_ne_of_ne hvq hvr]
+      exact hG v hvp hvq
+
+lemma rotation_commutes (x : BandEuler.Residual p (r α p) (pr α hf p)) :
+    coordinates α hf p q hpq (BandEuler.rotation σ p (r α p) (pr α hf p) x)=
+      rotation σ p q hsp hsq (coordinates α hf p q hpq x) := by
+  apply Subtype.ext
+  rw [coordinates_val,rotation_value]
+  exact smoothing_value σ p q hpq hsp hsq (r α p)
+    (BandEuler.val p (r α p) (pr α hf p) x) (pr α hf p)
+    (BandEuler.val_ne_p _ _ _ x) (BandEuler.val_ne_q _ _ _ x)
+
+variable [Fintype O]
+/-- Suppressing an actual two-occurrence boundary splices its matching partners,
+including the already-paired case, and preserves combinatorial genus zero. -/
+theorem genusZero (hz : MapEuler.GenusZero σ α) :
+    MapEuler.GenusZero (rotation σ p q hsp hsq)
+      (MatchingSurgery.partner α hi hf p q hpq) := by
+  let e := coordinates α hf p q hpq
+  let σ₀ := BandEuler.rotation σ p (r α p) (pr α hf p)
+  let α₀ := BandEuler.partner α hi p (r α p) (pr α hf p) rfl
+  have hz₀ : MapEuler.GenusZero σ₀ α₀ := BandEuler.genusZero_all σ α hi p
+    (r α p) (pr α hf p) rfl hz
+  have h := MapConjugation.genusZero e σ₀ α₀ hz₀
+  have hσ : e.permCongr σ₀=rotation σ p q hsp hsq := by
+    apply Equiv.ext
+    intro y
+    obtain ⟨x,rfl⟩ := e.surjective y
+    rw [Equiv.permCongr_apply,e.symm_apply_apply]
+    exact rotation_commutes σ α hf p q hpq hsp hsq x
+  have hα : e.permCongr α₀=MatchingSurgery.partner α hi hf p q hpq := by
+    apply Equiv.ext
+    intro y
+    obtain ⟨x,rfl⟩ := e.surjective y
+    rw [Equiv.permCongr_apply,e.symm_apply_apply]
+    exact partner_commutes α hi hf p q hpq x
+  rwa [hσ,hα] at h
+
+end TorsionFreeZeroDivisors.Smoothing
+namespace TorsionFreeZeroDivisors.Tightening
+open scoped Classical
+open PermutationCycles
+variable {O V : Type} (σ : Equiv.Perm O) (p q : O) (hpq : p≠q) (hsp : σ p=q)
+def isolate : Equiv.Perm O := Equiv.swap p (σ q)*σ
+include hpq hsp in
+lemma q_ne_next : q≠σ q := fun h=>hpq (σ.injective (hsp.trans h))
+include hpq hsp in
+lemma isolate_p : isolate σ p q p=q := by
+  change Equiv.swap p (σ q) (σ p)=q
+  rw [hsp,Equiv.swap_apply_of_ne_of_ne hpq.symm (q_ne_next σ p q hpq hsp)]
+lemma isolate_q : isolate σ p q q=p := Equiv.swap_apply_right _ _
+def rotation : Equiv.Perm (MatchingSurgery.Remaining p q) :=
+  Smoothing.rotation (isolate σ p q) p q (isolate_p σ p q hpq hsp) (isolate_q σ p q)
+
+variable [Fintype O] (α : Equiv.Perm O) (hi : Function.Involutive α) (hf : ∀x,α x≠x)
+include hsp hi in
+lemma isolate_genusZero (hz : MapEuler.GenusZero σ α) : MapEuler.GenusZero (isolate σ p q) α := by
+  by_cases he : p=σ q
+  · have hs : isolate σ p q=σ := by rw [isolate,←he,Equiv.swap_self];rfl
+    rwa [hs]
+  · apply MapEuler.genusZero_vertexSplit σ α hi hz p (σ q) he
+    rw [cycle_apply,←hsp,cycle_apply]
+/-- Deleting an actual adjacent backtracking pair from its boundary, with the
+forced partner splice, preserves genus zero even if the two occurrences were
+not paired. This supplies the finite-map part of cyclic tightening. -/
+theorem genusZero (hz : MapEuler.GenusZero σ α) :
+    MapEuler.GenusZero (rotation σ p q hpq hsp) (MatchingSurgery.partner α hi hf p q hpq) :=
+  Smoothing.genusZero (isolate σ p q) α hi hf p q hpq
+    (isolate_p σ p q hpq hsp) (isolate_q σ p q) (isolate_genusZero σ p q hsp α hi hz)
+
+variable (before after : O→V)
+omit [Fintype O] in
+/-- The graph endpoint conditions, not just the rose labels, survive the
+backtracking deletion. The second occurrence really returns to the first
+occurrence's starting vertex. -/
+theorem consistent (h : BoundarySurgery.Consistent σ before after) (hq : after q=before p) :
+    BoundarySurgery.Consistent (rotation σ p q hpq hsp)
+      (fun x=>before x) (fun x=>after x) := by
+  have he : before p=before (σ q) := hq.symm.trans (h q)
+  intro x
+  change after (x : O)=before (Equiv.swap p (σ q) (σ x))
+  rw [MapEuler.swap_invariant before p (σ q) he]
+  exact h x
+omit [Fintype O] in
+lemma marker_nonfixed (h : BoundarySurgery.Consistent σ before after) (hq : after q=before p)
+    (m : MatchingSurgery.Remaining p q) (hm : after m≠before m) :
+    rotation σ p q hpq hsp m≠m := by
+  intro he
+  have hh := consistent σ p q hpq hsp before after h hq m
+  rw [he] at hh
+  exact hm hh
+end TorsionFreeZeroDivisors.Tightening
+
+/-! The finite matching operation for the same-lifted-edge band surgery.
+Deleting two inverse occurrences splices their partners unless they were already
+paired. Labels, involutivity and the absence of fixed points are proved from the
+actual matching. This file does not assert a surface realization or essentiality.
+-/
+namespace TorsionFreeZeroDivisors.PartialMatchingSurgery
+open scoped Classical
+variable {O A : Type*} (α : Equiv.Perm O) (hi : Function.Involutive α)
+  (p q : O) (hpq : p≠q) (hfp : α p≠p) (hfq : α q≠q)
+
+abbrev Remaining := {x : O // x≠p ∧ x≠q}
+def splice (x : O) : O := if α x=p then α q else if α x=q then α p else α x
+
+include hi hfp hfq in
+lemma splice_avoids (x : Remaining p q) : splice α p q x≠p ∧ splice α p q x≠q := by
+  by_cases h1 : α x=p
+  · have hx : α p=x := (congrArg α h1).symm.trans (hi x)
+    have hqp : α q≠p := by
+      intro h
+      have h' : q=α p := (hi _).symm.trans (congrArg α h)
+      exact x.property.2 (hx ▸ h'.symm)
+    rw [splice,ite_eq_left h1]
+    exact ⟨hqp,hfq⟩
+  · by_cases h2 : α x=q
+    · have hx : α q=x := (congrArg α h2).symm.trans (hi x)
+      have hpq' : α p≠q := by
+        intro h
+        have h' : p=α q := (hi _).symm.trans (congrArg α h)
+        exact x.property.1 (hx ▸ h'.symm)
+      rw [splice,ite_eq_right h1,ite_eq_left h2]
+      exact ⟨hfp,hpq'⟩
+    · rw [splice,ite_eq_right h1,ite_eq_right h2]
+      exact ⟨h1,h2⟩
+
+def apply (x : Remaining p q) : Remaining p q := ⟨splice α p q x,splice_avoids α hi p q hfp hfq x⟩
+
+include hpq in
+lemma involutive : Function.Involutive (apply α hi p q hfp hfq) := by
+  intro x
+  apply Subtype.ext
+  change splice α p q (splice α p q x)=x
+  by_cases h1 : α x=p
+  · have hx : α p=x := (congrArg α h1).symm.trans (hi x)
+    have hs : splice α p q x=α q := by rw [splice,ite_eq_left h1]
+    rw [hs,splice,hi q,ite_eq_right hpq.symm,ite_eq_left rfl]
+    exact hx
+  · by_cases h2 : α x=q
+    · have hx : α q=x := (congrArg α h2).symm.trans (hi x)
+      have hs : splice α p q x=α p := by rw [splice,ite_eq_right h1,ite_eq_left h2]
+      rw [hs,splice,hi p,ite_eq_left rfl]
+      exact hx
+    · have hs : splice α p q x=α x := by rw [splice,ite_eq_right h1,ite_eq_right h2]
+      rw [hs,splice,hi x,ite_eq_right x.property.1,ite_eq_right x.property.2]
+
+include hpq in
+lemma distinct (x : Remaining p q) (hfx : α x≠x) : apply α hi p q hfp hfq x≠x := by
+  intro he
+  have he := congrArg Subtype.val he
+  change splice α p q x=x at he
+  by_cases h1 : α x=p
+  · have hx : α p=x := (congrArg α h1).symm.trans (hi x)
+    rw [splice,ite_eq_left h1] at he
+    exact hpq (α.injective (hx.trans he.symm))
+  · by_cases h2 : α x=q
+    · have hx : α q=x := (congrArg α h2).symm.trans (hi x)
+      rw [splice,ite_eq_right h1,ite_eq_left h2] at he
+      exact hpq (α.injective (he.trans hx.symm))
+    · exact hfx (by simpa [splice,h1,h2] using he)
+
+def partner : Equiv.Perm (Remaining p q) := ⟨apply α hi p q hfp hfq,apply α hi p q hfp hfq,involutive α hi p q hpq hfp hfq,involutive α hi p q hpq hfp hfq⟩
+
+variable (inv : A→A) (hinv : Function.Involutive inv) (label : O→A)
+  (hl : ∀x,label (α x)=inv (label x)) (hlabel : label q=inv (label p))
+include hinv hl hlabel in
+lemma compatible (x : Remaining p q) :
+    label (partner α hi p q hpq hfp hfq x)=inv (label x) := by
+  change label (splice α p q x)=_
+  by_cases h1 : α x=p
+  · rw [splice,ite_eq_left h1,hl,hlabel,hinv]
+    exact (congrArg label h1).symm.trans (hl x)
+  · by_cases h2 : α x=q
+    · rw [splice,ite_eq_right h1,ite_eq_left h2,hl,←hlabel]
+      exact (congrArg label h2).symm.trans (hl x)
+    · rw [splice,ite_eq_right h1,ite_eq_right h2,hl]
+
+lemma fixed (x : Remaining p q) (hx : α x=x) : partner α hi p q hpq hfp hfq x=x := by
+  apply Subtype.ext
+  change splice α p q x=x
+  rw [splice,hx,ite_eq_right x.property.1,ite_eq_right x.property.2]
+
+end TorsionFreeZeroDivisors.PartialMatchingSurgery
+namespace TorsionFreeZeroDivisors.PartialSmoothing
+open scoped Classical
+open DeleteCycle
+variable {O : Type} (σ α : Equiv.Perm O)
+  (hi : Function.Involutive α)
+  (p q : O) (hpq : p≠q) (hfp : α p≠p) (hfq : α q≠q) (hsp : σ p=q) (hsq : σ q=p)
+
+include hsp hsq in
+lemma rotation_invariant (x : O) : (σ x≠p ∧ σ x≠q) ↔ (x≠p ∧ x≠q) := by
+  constructor
+  · rintro ⟨hp,hq⟩
+    exact ⟨fun h=>hq (h ▸ hsp),fun h=>hp (h ▸ hsq)⟩
+  · rintro ⟨hp,hq⟩
+    exact ⟨fun h=>hq (σ.injective (h.trans hsq.symm)),fun h=>hp (σ.injective (h.trans hsp.symm))⟩
+def rotation : Equiv.Perm (PartialMatchingSurgery.Remaining p q) :=
+  σ.subtypePerm (rotation_invariant σ p q hsp hsq)
+
+abbrev r := α p
+include hfp in
+lemma pr : p≠r α p := (hfp).symm
+include hfp hpq in
+lemma rename_invariant (x : O) :
+    (Equiv.swap q (r α p) x≠p ∧ Equiv.swap q (r α p) x≠q) ↔ (x≠p ∧ x≠r α p) := by
+  have hp : Equiv.swap q (r α p) p=p := Equiv.swap_apply_of_ne_of_ne hpq (pr α p hfp)
+  have hr : Equiv.swap q (r α p) (r α p)=q := Equiv.swap_apply_right _ _
+  constructor
+  · rintro ⟨h1,h2⟩
+    exact ⟨fun h=>h1 (h ▸ hp),fun h=>h2 (h ▸ hr)⟩
+  · rintro ⟨h1,h2⟩
+    exact ⟨fun h=>h1 ((Equiv.swap q (r α p)).injective (h.trans hp.symm)),
+      fun h=>h2 ((Equiv.swap q (r α p)).injective (h.trans hr.symm))⟩
+def flatten : BandEuler.Residual p (r α p) (pr α p hfp) ≃ PartialMatchingSurgery.Remaining p (r α p) where
+  toFun x := ⟨BandEuler.val p (r α p) (pr α p hfp) x,
+    BandEuler.val_ne_p p (r α p) (pr α p hfp) x,BandEuler.val_ne_q p (r α p) (pr α p hfp) x⟩
+  invFun x := ⟨⟨x,x.property.1⟩,fun he=>x.property.2 (congrArg Subtype.val he)⟩
+  left_inv _ := rfl
+  right_inv _ := rfl
+def rename : PartialMatchingSurgery.Remaining p (r α p) ≃ PartialMatchingSurgery.Remaining p q :=
+  (Equiv.swap q (r α p)).subtypeEquiv (fun x=>(rename_invariant α p q hpq hfp x).symm)
+def coordinates : BandEuler.Residual p (r α p) (pr α p hfp) ≃ PartialMatchingSurgery.Remaining p q :=
+  (flatten α p hfp).trans (rename α p q hpq hfp)
+lemma coordinates_val (x : BandEuler.Residual p (r α p) (pr α p hfp)) :
+    (coordinates α p q hpq hfp x).val=Equiv.swap q (r α p) (BandEuler.val p (r α p) (pr α p hfp) x) := rfl
+
+lemma partner_commutes (x : BandEuler.Residual p (r α p) (pr α p hfp)) :
+    coordinates α p q hpq hfp (BandEuler.partner α hi p (r α p) (pr α p hfp) rfl x)=
+      PartialMatchingSurgery.partner α hi p q hpq hfp hfq (coordinates α p q hpq hfp x) := by
+  apply Subtype.ext
+  rw [coordinates_val,BandEuler.partner_val]
+  change Equiv.swap q (α p) (α (BandEuler.val p (α p) (pr α p hfp) x))=
+    PartialMatchingSurgery.splice α p q (Equiv.swap q (α p) (BandEuler.val p (α p) (pr α p hfp) x))
+  let v := BandEuler.val p (α p) (pr α p hfp) x
+  change Equiv.swap q (α p) (α v)=PartialMatchingSurgery.splice α p q (Equiv.swap q (α p) v)
+  have hvp : v≠p := BandEuler.val_ne_p _ _ _ x
+  have hvr : v≠α p := BandEuler.val_ne_q _ _ _ x
+  have havp : α v≠p := fun h=>hvr ((hi _).symm.trans (congrArg α h))
+  have havr : α v≠α p := α.injective.ne hvp
+  by_cases hvq : v=q
+  · rw [hvq,Equiv.swap_apply_left,PartialMatchingSurgery.splice,hi p,ite_eq_left rfl]
+    have hαq : α q≠q := hfq
+    have hαqr : α q≠α p := α.injective.ne hpq.symm
+    exact Equiv.swap_apply_of_ne_of_ne hαq hαqr
+  · rw [Equiv.swap_apply_of_ne_of_ne hvq hvr,PartialMatchingSurgery.splice,ite_eq_right havp]
+    by_cases havq : α v=q
+    · rw [ite_eq_left havq,havq,Equiv.swap_apply_left]
+    · rw [ite_eq_right havq,Equiv.swap_apply_of_ne_of_ne havq havr]
+
+lemma bypass_value (f : Equiv.Perm O) (a : O) (x : Rest a) :
+    (bypass f a x).val=if f x=a then f a else f x := by
+  change Equiv.swap a (f a) (f x)=_
+  by_cases h : f x=a
+  · rw [ite_eq_left h,h,Equiv.swap_apply_left]
+  · rw [ite_eq_right h,Equiv.swap_apply_of_ne_of_ne h (f.injective.ne x.property)]
+lemma rotation_value (a b : O) (hab : a≠b) (x : BandEuler.Residual a b hab) :
+    BandEuler.val a b hab (BandEuler.rotation σ a b hab x)=
+      let f := BandEuler.switched σ a b
+      let g := fun y=>if f y=a then f a else f y
+      if g (BandEuler.val a b hab x)=b then g b else g (BandEuler.val a b hab x) := by
+  let f := BandEuler.switched σ a b
+  let g := fun y=>if f y=a then f a else f y
+  change ((bypass (bypass f a) (BandEuler.q' a b hab) x).val).val=
+    if g x.val.val=b then g b else g x.val.val
+  have he : bypass f a x.val=BandEuler.q' a b hab ↔ g x.val.val=b := by
+    rw [Subtype.ext_iff,bypass_value]
+  by_cases hc : g x.val.val=b
+  · rw [ite_eq_left hc]
+    have hv := bypass_value (bypass f a) (BandEuler.q' a b hab) x
+    rw [ite_eq_left (he.mpr hc)] at hv
+    exact (congrArg Subtype.val hv).trans (bypass_value f a (BandEuler.q' a b hab))
+  · rw [ite_eq_right hc]
+    have hv := bypass_value (bypass f a) (BandEuler.q' a b hab) x
+    rw [ite_eq_right (fun h=>hc (he.mp h))] at hv
+    exact (congrArg Subtype.val hv).trans (bypass_value f a x.val)
+
+include hsp hsq hpq in
+lemma smoothing_value (r v : O) (hpr : p≠r) (hvp : v≠p) (hvr : v≠r) :
+    let f := Equiv.swap p r*σ
+    let g := fun y=>if f y=p then f p else f y
+    Equiv.swap q r (if g v=r then g r else g v)=σ (Equiv.swap q r v) := by
+  let f := Equiv.swap p r*σ
+  let g := fun y=>if f y=p then f p else f y
+  change Equiv.swap q r (if g v=r then g r else g v)=_
+  by_cases hqr : q=r
+  · subst r
+    have hsvp : σ v≠p := fun h=>hvr (σ.injective (h.trans hsq.symm))
+    have hsvq : σ v≠q := fun h=>hvp (σ.injective (h.trans hsp.symm))
+    have hfv : f v=σ v := Equiv.swap_apply_of_ne_of_ne hsvp hsvq
+    have hg : g v=σ v := by
+      change (if f v=p then f p else f v)=σ v
+      simp only [hfv,ite_eq_right hsvp]
+    rw [hg,ite_eq_right hsvq,Equiv.swap_self]
+    rfl
+  · have hfp : f p=q := by
+      dsimp only [f,Equiv.Perm.mul_apply]
+      rw [hsp,Equiv.swap_apply_of_ne_of_ne hpq.symm hqr]
+    have hG (y : O) (hyp : y≠p) (hyq : y≠q) : Equiv.swap q r (g y)=σ y := by
+      have hsyp : σ y≠p := fun h=>hyq (σ.injective (h.trans hsq.symm))
+      have hsyq : σ y≠q := fun h=>hyp (σ.injective (h.trans hsp.symm))
+      by_cases hsyr : σ y=r
+      · have hfy : f y=p := by simp only [f,Equiv.Perm.mul_apply,hsyr,Equiv.swap_apply_right]
+        change Equiv.swap q r (if f y=p then f p else f y)=σ y
+        rw [ite_eq_left hfy,hfp,Equiv.swap_apply_left,hsyr]
+      · have hfy : f y=σ y := by
+          exact Equiv.swap_apply_of_ne_of_ne hsyp hsyr
+        change Equiv.swap q r (if f y=p then f p else f y)=σ y
+        simp only [hfy,ite_eq_right hsyp,Equiv.swap_apply_of_ne_of_ne hsyq hsyr]
+    by_cases hvq : v=q
+    · have hfq : f q=r := by simp only [f,Equiv.Perm.mul_apply,hsq,Equiv.swap_apply_left]
+      have hgq : g q=r := by
+        change (if f q=p then f p else f q)=r
+        simp only [hfq,ite_eq_right hpr.symm]
+      rw [hvq,hgq,ite_eq_left rfl,Equiv.swap_apply_left]
+      exact hG r hpr.symm (Ne.symm hqr)
+    · have hgv : g v≠r := by
+        intro he
+        have hh := hG v hvp hvq
+        rw [he,Equiv.swap_apply_right] at hh
+        exact hvp (σ.injective (hh.symm.trans hsp.symm))
+      rw [ite_eq_right hgv,Equiv.swap_apply_of_ne_of_ne hvq hvr]
+      exact hG v hvp hvq
+
+lemma rotation_commutes (x : BandEuler.Residual p (r α p) (pr α p hfp)) :
+    coordinates α p q hpq hfp (BandEuler.rotation σ p (r α p) (pr α p hfp) x)=
+      rotation σ p q hsp hsq (coordinates α p q hpq hfp x) := by
+  apply Subtype.ext
+  rw [coordinates_val,rotation_value]
+  exact smoothing_value σ p q hpq hsp hsq (r α p)
+    (BandEuler.val p (r α p) (pr α p hfp) x) (pr α p hfp)
+    (BandEuler.val_ne_p _ _ _ x) (BandEuler.val_ne_q _ _ _ x)
+
+variable [Fintype O]
+/-- Suppressing an actual two-occurrence boundary splices its matching partners,
+including the already-paired case, and preserves combinatorial genus zero. -/
+theorem genusZero (hz : MapEuler.GenusZero σ α) :
+    MapEuler.GenusZero (rotation σ p q hsp hsq)
+      (PartialMatchingSurgery.partner α hi p q hpq hfp hfq) := by
+  let e := coordinates α p q hpq hfp
+  let σ₀ := BandEuler.rotation σ p (r α p) (pr α p hfp)
+  let α₀ := BandEuler.partner α hi p (r α p) (pr α p hfp) rfl
+  have hz₀ : MapEuler.GenusZero σ₀ α₀ := BandEuler.genusZero_all σ α hi p
+    (r α p) (pr α p hfp) rfl hz
+  have h := MapConjugation.genusZero e σ₀ α₀ hz₀
+  have hσ : e.permCongr σ₀=rotation σ p q hsp hsq := by
+    apply Equiv.ext
+    intro y
+    obtain ⟨x,rfl⟩ := e.surjective y
+    rw [Equiv.permCongr_apply,e.symm_apply_apply]
+    exact rotation_commutes σ α p q hpq hfp hsp hsq x
+  have hα : e.permCongr α₀=PartialMatchingSurgery.partner α hi p q hpq hfp hfq := by
+    apply Equiv.ext
+    intro y
+    obtain ⟨x,rfl⟩ := e.surjective y
+    rw [Equiv.permCongr_apply,e.symm_apply_apply]
+    exact partner_commutes α hi p q hpq hfp hfq x
+  rwa [hσ,hα] at h
+
+end TorsionFreeZeroDivisors.PartialSmoothing
+namespace TorsionFreeZeroDivisors.Tightening
+open scoped Classical
+variable {O : Type} [Fintype O] (σ : Equiv.Perm O) (p q : O) (hpq : p≠q) (hsp : σ p=q)
+  (α : Equiv.Perm O) (hi : Function.Involutive α) (hfp : α p≠p) (hfq : α q≠q)
+/-- The tightening operation also allows unrelated unpaired markers. Only the
+actual two deleted letter occurrences are required to be nonfixed. -/
+theorem partial_genusZero (hz : MapEuler.GenusZero σ α) :
+    MapEuler.GenusZero (rotation σ p q hpq hsp)
+      (PartialMatchingSurgery.partner α hi p q hpq hfp hfq) :=
+  PartialSmoothing.genusZero (isolate σ p q) α hi p q hpq hfp hfq
+    (isolate_p σ p q hpq hsp) (isolate_q σ p q) (isolate_genusZero σ p q hsp α hi hz)
+end TorsionFreeZeroDivisors.Tightening
+namespace TorsionFreeZeroDivisors.FinitePicture
+open scoped Classical
+open PortSubdivision
+variable {V D A O : Type} (Γ : PortGraph V D) (label : D→A) (inv : A→A) (x y : V) [Fintype O]
+/-- A purely finite lifted boundary certificate. The single unpaired marker
+records the break from the exterior endpoint y back to the prescribed root x.
+No surface map, cone filling, essentiality, or CW realization is asserted. -/
+structure Data where
+  rotation : Equiv.Perm O
+  partner : Equiv.Perm O
+  involutive : Function.Involutive partner
+  marker : O
+  marker_fixed : partner marker=marker
+  fixed_only : ∀ i,partner i=i → i=marker
+  dart : O→Option D
+  none_iff : ∀i,dart i=none ↔ i=marker
+  before : O→V
+  after : O→V
+  begins : ∀i d,dart i=some d → before i=Γ.origin d
+  ends : ∀i d,dart i=some d → after i=Γ.origin (Γ.reverse d)
+  marker_before : before marker=y
+  marker_after : after marker=x
+  consistent : BoundarySurgery.Consistent rotation before after
+  compatible : ∀i,(dart (partner i)).map label=(dart i).map (inv ∘ label)
+  genusZero : MapEuler.GenusZero rotation partner
+namespace Data
+variable {Γ label inv x y} (a : Data (O:=O) Γ label inv x y)
+lemma nonfixed {p : O} (hp : p≠a.marker) : a.partner p≠p := fun h=>hp (a.fixed_only p h)
+lemma partner_ne_marker {p : O} (hp : p≠a.marker) : a.partner p≠a.marker :=
+  fun h=>hp (a.partner.injective (h.trans a.marker_fixed.symm))
+lemma swap_endpoints {p q : O} (hp : p≠a.marker)
+    (he : a.dart q=(a.dart p).map Γ.reverse) :
+    a.after p=a.before q ∧ a.after q=a.before p := by
+  cases hd : a.dart p with
+  | none => exact False.elim (hp ((a.none_iff p).mp hd))
+  | some d =>
+    have hq : a.dart q=some (Γ.reverse d) := by simpa only [hd,Option.map_some] using he
+    constructor
+    · rw [a.ends p d hd,a.begins q (Γ.reverse d) hq]
+    · rw [a.ends q (Γ.reverse d) hq,Γ.reverse_reverse d,a.begins p d hd]
+lemma marker_not_fixed_rotation (hxy : x≠y) : a.rotation a.marker≠a.marker := by
+  intro h
+  have hh := a.consistent a.marker
+  rw [h,a.marker_before,a.marker_after] at hh
+  exact hxy hh
+
+variable {O' : Type} [Fintype O']
+def reindex (e : O≃O') : Data (O:=O') Γ label inv x y where
+  rotation := e.permCongr a.rotation
+  partner := e.permCongr a.partner
+  involutive := by
+    intro i
+    simp only [Equiv.permCongr_apply,e.symm_apply_apply]
+    rw [a.involutive (e.symm i),e.apply_symm_apply]
+  marker := e a.marker
+  marker_fixed := by simp only [Equiv.permCongr_apply,e.symm_apply_apply,a.marker_fixed]
+  fixed_only i hi := by
+    apply e.symm.injective
+    rw [e.symm_apply_apply]
+    apply a.fixed_only
+    have hh := congrArg e.symm hi
+    simpa only [Equiv.permCongr_apply,e.symm_apply_apply] using hh
+  dart i := a.dart (e.symm i)
+  none_iff i := by
+    rw [a.none_iff]
+    exact ⟨fun h=>(e.apply_symm_apply i).symm.trans (congrArg e h),
+      fun h=>(congrArg e.symm h).trans (e.symm_apply_apply a.marker)⟩
+  before i := a.before (e.symm i)
+  after i := a.after (e.symm i)
+  begins i d h := a.begins _ d h
+  ends i d h := a.ends _ d h
+  marker_before := by rw [e.symm_apply_apply,a.marker_before]
+  marker_after := by rw [e.symm_apply_apply,a.marker_after]
+  consistent i := by simpa only [Equiv.permCongr_apply,e.symm_apply_apply] using a.consistent (e.symm i)
+  compatible i := by simpa only [Equiv.permCongr_apply,e.symm_apply_apply] using a.compatible (e.symm i)
+  genusZero := MapConjugation.genusZero e _ _ a.genusZero
+
+variable (p q : O) (hpq : p≠q) (hp : p≠a.marker) (hq : q≠a.marker)
+abbrev bandMarker : BandEuler.Residual p q hpq := ⟨⟨a.marker,hp.symm⟩,fun he=>hq (congrArg Subtype.val he).symm⟩
+def band (hpair : a.partner p=q) (he : a.dart q=(a.dart p).map Γ.reverse) :
+    Data (O:=BandEuler.Residual p q hpq) Γ label inv x y where
+  rotation := BandEuler.rotation a.rotation p q hpq
+  partner := BandEuler.partner a.partner a.involutive p q hpq hpair
+  involutive := BandEuler.partner_involutive a.partner a.involutive p q hpq hpair
+  marker := a.bandMarker p q hpq hp hq
+  marker_fixed := by
+    apply BandEuler.val_injective p q hpq
+    rw [BandEuler.partner_val]
+    exact a.marker_fixed
+  fixed_only i hi := by
+    apply BandEuler.val_injective p q hpq
+    apply a.fixed_only
+    have hh := congrArg (BandEuler.val p q hpq) hi
+    rwa [BandEuler.partner_val] at hh
+  dart i := a.dart (BandEuler.val p q hpq i)
+  none_iff i := by
+    rw [a.none_iff]
+    exact ⟨fun h=>BandEuler.val_injective p q hpq h,fun h=>congrArg (BandEuler.val p q hpq) h⟩
+  before i := a.before (BandEuler.val p q hpq i)
+  after i := a.after (BandEuler.val p q hpq i)
+  begins i d h := a.begins _ d h
+  ends i d h := a.ends _ d h
+  marker_before := a.marker_before
+  marker_after := a.marker_after
+  consistent := BoundarySurgery.consistent a.rotation a.before a.after p q hpq a.consistent
+    (a.swap_endpoints hp he).1 (a.swap_endpoints hp he).2
+  compatible i := by
+    rw [BandEuler.partner_val]
+    exact a.compatible _
+  genusZero := BandEuler.genusZero_all a.rotation a.partner a.involutive p q hpq hpair a.genusZero
+
+abbrev tightMarker : PartialMatchingSurgery.Remaining p q := ⟨a.marker,hp.symm,hq.symm⟩
+lemma option_inverse (hinv : Function.Involutive inv) : Function.Involutive (Option.map inv) := by
+  intro z
+  cases z with
+  | none => rfl
+  | some z => simp only [Option.map_some,hinv z]
+lemma option_compatible (i : O) :
+    (a.dart (a.partner i)).map label=((a.dart i).map label).map inv := by
+  rw [Option.map_map]
+  exact a.compatible i
+lemma option_backtrack (hlabel : ∀d,label (Γ.reverse d)=inv (label d))
+    (he : a.dart q=(a.dart p).map Γ.reverse) :
+    (a.dart q).map label=((a.dart p).map label).map inv := by
+  rw [he,Option.map_map,Option.map_map]
+  congr 1
+  exact funext hlabel
+/-- The actual adjacent reverse-edge deletion with the forced partner splice.
+In contrast to the paired band move, p and q need not be partners. -/
+def tighten (hinv : Function.Involutive inv)
+    (hlabel : ∀d,label (Γ.reverse d)=inv (label d))
+    (hsp : a.rotation p=q) (he : a.dart q=(a.dart p).map Γ.reverse) :
+    Data (O:=PartialMatchingSurgery.Remaining p q) Γ label inv x y where
+  rotation := Tightening.rotation a.rotation p q hpq hsp
+  partner := PartialMatchingSurgery.partner a.partner a.involutive p q hpq (a.nonfixed hp) (a.nonfixed hq)
+  involutive := PartialMatchingSurgery.involutive a.partner a.involutive p q hpq (a.nonfixed hp) (a.nonfixed hq)
+  marker := a.tightMarker p q hp hq
+  marker_fixed := PartialMatchingSurgery.fixed a.partner a.involutive p q hpq (a.nonfixed hp) (a.nonfixed hq)
+    (a.tightMarker p q hp hq) a.marker_fixed
+  fixed_only i hi := by
+    apply Subtype.ext
+    by_contra h
+    exact PartialMatchingSurgery.distinct a.partner a.involutive p q hpq (a.nonfixed hp) (a.nonfixed hq)
+      i (a.nonfixed h) hi
+  dart i := a.dart i
+  none_iff i := by
+    rw [a.none_iff]
+    exact ⟨fun h=>Subtype.ext h,fun h=>congrArg Subtype.val h⟩
+  before i := a.before i
+  after i := a.after i
+  begins i d h := a.begins _ d h
+  ends i d h := a.ends _ d h
+  marker_before := a.marker_before
+  marker_after := a.marker_after
+  consistent := Tightening.consistent a.rotation p q hpq hsp a.before a.after a.consistent
+    (a.swap_endpoints hp he).2
+  compatible i := by
+    have h := PartialMatchingSurgery.compatible a.partner a.involutive p q hpq (a.nonfixed hp) (a.nonfixed hq)
+      (Option.map inv) (option_inverse hinv) (fun z=>(a.dart z).map label) a.option_compatible
+      (a.option_backtrack p q hlabel he) i
+    rw [Option.map_map] at h
+    exact h
+  genusZero := Tightening.partial_genusZero a.rotation p q hpq hsp a.partner a.involutive
+    (a.nonfixed hp) (a.nonfixed hq) a.genusZero
+include hp in
+lemma unequal_backtrack (he : a.dart q=(a.dart p).map Γ.reverse) : p≠q := by
+  intro h
+  subst q
+  cases hd : a.dart p with
+  | none => exact hp ((a.none_iff p).mp hd)
+  | some d =>
+    have h' : d=Γ.reverse d := Option.some.inj (by simpa only [hd,Option.map_some] using he)
+    exact Γ.reverse_ne d h'.symm
+/-- Both kinds of shortening forbidden in a least marked finite certificate. -/
+def Reduced : Prop :=
+  (∀p,p≠a.marker → a.dart (a.partner p)≠(a.dart p).map Γ.reverse) ∧
+  (∀p,p≠a.marker → a.rotation p≠a.marker → a.dart (a.rotation p)≠(a.dart p).map Γ.reverse)
+def deletionCoordinates : BandEuler.Residual p q hpq ≃ PartialMatchingSurgery.Remaining p q where
+  toFun z := ⟨BandEuler.val p q hpq z,BandEuler.val_ne_p p q hpq z,BandEuler.val_ne_q p q hpq z⟩
+  invFun z := ⟨⟨z,z.property.1⟩,fun he=>z.property.2 (congrArg Subtype.val he)⟩
+  left_inv _ := rfl
+  right_inv _ := rfl
+include hpq in
+lemma remaining_two_fewer : Fintype.card (PartialMatchingSurgery.Remaining p q)+2=Fintype.card O := by
+  rw [←Fintype.card_congr (deletionCoordinates p q hpq)]
+  exact BandEuler.two_fewer p q hpq
+theorem reduced_of_minimum (hinv : Function.Involutive inv)
+    (hlabel : ∀d,label (Γ.reverse d)=inv (label d))
+    (hmin : ∀ {M : Type} [Fintype M],Data (O:=M) Γ label inv x y → Nat.card O≤Nat.card M) :
+    a.Reduced := by
+  constructor
+  · intro p hp he
+    let q := a.partner p
+    have hq : q≠a.marker := a.partner_ne_marker hp
+    have hpq : p≠q := (a.nonfixed hp).symm
+    let c := a.band p q hpq hp hq rfl he
+    have hc := BandEuler.two_fewer p q hpq
+    have hm := hmin c
+    simp only [←Nat.card_eq_fintype_card] at hc
+    omega
+  · intro p hp hq he
+    let q := a.rotation p
+    have hpq : p≠q := a.unequal_backtrack p q hp he
+    let c := a.tighten p q hpq hp hq hinv hlabel rfl he
+    have hc := remaining_two_fewer p q hpq
+    have hm := hmin c
+    simp only [←Nat.card_eq_fintype_card] at hc
+    omega
+include a in
+/-- From an actual finite marked certificate obtain one with the same distinct
+endpoints and with no same-lift paired band or adjacent backtracking. This is a
+finite combinatorial reduction, not existence of a certificate for a null word. -/
+theorem exists_reduced (hinv : Function.Involutive inv)
+    (hlabel : ∀d,label (Γ.reverse d)=inv (label d)) :
+    ∃n,n≤Fintype.card O ∧ ∃b : Data (O:=Fin n) Γ label inv x y,b.Reduced := by
+  let P := fun n=>Nonempty (Data (O:=Fin n) Γ label inv x y)
+  have hx : ∃n,P n := ⟨Fintype.card O,⟨a.reindex (Fintype.equivFin O)⟩⟩
+  let n := Nat.find hx
+  obtain ⟨b⟩ := Nat.find_spec hx
+  have hn : n≤Fintype.card O := Nat.find_min' hx ⟨a.reindex (Fintype.equivFin O)⟩
+  refine ⟨n,hn,b,b.reduced_of_minimum hinv hlabel ?_⟩
+  intro M _ c
+  have hm : n≤Fintype.card M := Nat.find_min' hx ⟨c.reindex (Fintype.equivFin M)⟩
+  simpa only [Nat.card_eq_fintype_card,Fintype.card_fin] using hm
+end Data
+end TorsionFreeZeroDivisors.FinitePicture
+
+namespace TorsionFreeZeroDivisors.PermutationCycles
+open scoped Classical BigOperators
+variable {O : Type} [Fintype O] (f : Equiv.Perm O)
+private lemma excess_identity {C : Type} [Fintype C] (len : C→ℕ) (hp : ∀ c,0<len c) :
+    (∑ c,(len c-2))+2*Fintype.card C=(∑ c,len c)+
+      (Finset.univ.filter (fun c => len c=1)).card := by
+  calc
+    _ = ∑ c,(len c-2+2) := by simp [Finset.sum_add_distrib,Nat.mul_comm]
+    _ = ∑ c,(len c+if len c=1 then 1 else 0) := by
+      apply Finset.sum_congr rfl
+      intro c _
+      have h := hp c
+      split_ifs <;> omega
+    _ = _ := by simp only [Finset.sum_add_distrib,Finset.sum_boole,Nat.cast_id]
+lemma twice_cycles_le : 2*Fintype.card (Cycle f)≤Fintype.card O+(fixed f).card := by
+  have he := excess_identity (fun c=>(members f c).card)
+    (fun c=>Finset.card_pos.mpr (members_nonempty f c))
+  rw [sum_card] at he
+  have hm := singleton_cycles_le_fixed f
+  omega
+end TorsionFreeZeroDivisors.PermutationCycles
+namespace TorsionFreeZeroDivisors.FinitePicture.Data
+open scoped Classical
+open DeleteCycle MapEuler PermutationCycles
+variable {V D A O : Type} [Fintype O] {Γ : PortSubdivision.PortGraph V D}
+  {label : D→A} {inv : A→A} {x y : V} (a : Data (O:=O) Γ label inv x y)
+abbrev Occ := Rest a.marker
+def closedRotation : Equiv.Perm a.Occ := bypass a.rotation a.marker
+def fullPartner : Equiv.Perm a.Occ := restrict a.partner a.marker a.marker_fixed
+lemma fullPartner_val (i : a.Occ) : (a.fullPartner i).val=a.partner i := rfl
+lemma fullPartner_involutive : Function.Involutive a.fullPartner := by
+  intro i
+  apply Subtype.ext
+  exact a.involutive i
+lemma fullPartner_nonfixed (i : a.Occ) : a.fullPartner i≠i := by
+  intro he
+  exact a.nonfixed i.property (congrArg Subtype.val he)
+lemma dart_isSome (i : a.Occ) : (a.dart i).isSome := by
+  apply Option.isSome_iff_ne_none.mpr
+  exact fun he=>i.property ((a.none_iff i).mp he)
+def edge (i : a.Occ) : D := (a.dart i).get (a.dart_isSome i)
+lemma some_edge (i : a.Occ) : some (a.edge i)=a.dart i := Option.some_get _
+lemma edge_begins (i : a.Occ) : a.before i=Γ.origin (a.edge i) := a.begins _ _ (a.some_edge i).symm
+lemma edge_ends (i : a.Occ) : a.after i=Γ.origin (Γ.reverse (a.edge i)) := a.ends _ _ (a.some_edge i).symm
+lemma edge_compatible (i : a.Occ) : label (a.edge (a.fullPartner i))=inv (label (a.edge i)) := by
+  have h := a.compatible i
+  change (a.dart (a.fullPartner i).val).map label=(a.dart i).map (inv ∘ label) at h
+  rw [←a.some_edge (a.fullPartner i),←a.some_edge i] at h
+  exact Option.some.inj h
+variable (hxy : x≠y)
+def first : a.Occ := ⟨a.rotation a.marker,a.marker_not_fixed_rotation hxy⟩
+lemma first_start : Γ.origin (a.edge (a.first hxy))=x := by
+  rw [←a.edge_begins]
+  exact (a.consistent a.marker).symm.trans a.marker_after
+lemma closedRotation_at_first (i : a.Occ) : a.closedRotation i=a.first hxy ↔ a.rotation i=a.marker := by
+  constructor
+  · intro he
+    have hh := congrArg Subtype.val he
+    change Equiv.swap a.marker (a.rotation a.marker) (a.rotation i)=a.rotation a.marker at hh
+    exact (Equiv.swap a.marker (a.rotation a.marker)).injective
+      (hh.trans (Equiv.swap_apply_left _ _).symm)
+  · intro he
+    apply Subtype.ext
+    change Equiv.swap a.marker (a.rotation a.marker) (a.rotation i)=a.rotation a.marker
+    rw [he,Equiv.swap_apply_left]
+lemma closedRotation_val (i : a.Occ) (hi : a.closedRotation i≠a.first hxy) :
+    (a.closedRotation i).val=a.rotation i := by
+  have h₁ : a.rotation i≠a.marker := fun h=>hi ((a.closedRotation_at_first hxy i).mpr h)
+  have h₂ : a.rotation i≠a.rotation a.marker := a.rotation.injective.ne i.property
+  change Equiv.swap a.marker (a.rotation a.marker) (a.rotation i)=a.rotation i
+  exact Equiv.swap_apply_of_ne_of_ne h₁ h₂
+/-- All joins other than the unique root break are actual graph joins. -/
+lemma edge_consistent (i : a.Occ) (hi : a.closedRotation i≠a.first hxy) :
+    Γ.origin (Γ.reverse (a.edge i))=Γ.origin (a.edge (a.closedRotation i)) := by
+  rw [←a.edge_ends,←a.edge_begins,a.closedRotation_val hxy i hi]
+  exact a.consistent i
+lemma last_end (i : a.Occ) (hi : a.closedRotation i=a.first hxy) :
+    Γ.origin (Γ.reverse (a.edge i))=y := by
+  rw [←a.edge_ends,a.consistent i,(a.closedRotation_at_first hxy i).mp hi,a.marker_before]
+include hxy in
+lemma closedRotation_genusZero : GenusZero a.closedRotation a.fullPartner :=
+  MapDeletion.genusZero_delete a.rotation a.partner a.marker a.marker_fixed
+    (a.marker_not_fixed_rotation hxy) a.genusZero
+include hxy in
+/-- The unmarked pairing is nonempty and has the literal sphere Euler bound.
+This proves the scalar input needed by interval cutting, not a PL realization. -/
+lemma closedRotation_euler : Fintype.card a.Occ+4≤2*Fintype.card (Cycle a.closedRotation)+
+    2*Fintype.card (Cycle (a.fullPartner*a.closedRotation)) := by
+  let : Nonempty a.Occ := ⟨a.first hxy⟩
+  exact MapEuler.euler_of_genusZero _ _ (a.closedRotation_genusZero hxy) a.fullPartner_nonfixed
+variable (hr : a.Reduced)
+include hr in
+lemma edge_partner_not_reverse (i : a.Occ) : a.edge (a.fullPartner i)≠Γ.reverse (a.edge i) := by
+  intro he
+  apply hr.1 i i.property
+  change a.dart (a.fullPartner i).val=(a.dart i).map Γ.reverse
+  rw [←a.some_edge (a.fullPartner i),←a.some_edge i,Option.map_some,he]
+lemma edge_partner_not_same (hn : ∀d,inv (label d)≠label d) (i : a.Occ) :
+    a.edge i≠a.edge (a.fullPartner i) := by
+  intro he
+  have h := a.edge_compatible i
+  rw [←he] at h
+  exact hn _ h.symm
+include hr in
+lemma edge_reduced (hn : ∀d,inv (label d)≠label d) (i : a.Occ) :
+    a.edge i≠a.edge (a.fullPartner i) ∧ a.edge i≠Γ.reverse (a.edge (a.fullPartner i)) := by
+  refine ⟨a.edge_partner_not_same hn i,?_⟩
+  intro he
+  apply a.edge_partner_not_reverse hr i
+  have hh := congrArg Γ.reverse he
+  rw [Γ.reverse_reverse] at hh
+  exact hh.symm
+include hr in
+lemma edge_no_backtrack (i : a.Occ) (hi : a.closedRotation i≠a.first hxy) :
+    a.edge (a.closedRotation i)≠Γ.reverse (a.edge i) := by
+  intro he
+  have hn : a.rotation i≠a.marker := fun h=>hi ((a.closedRotation_at_first hxy i).mpr h)
+  apply hr.2 i i.property hn
+  rw [←a.closedRotation_val hxy i hi,←a.some_edge (a.closedRotation i),←a.some_edge i,Option.map_some,he]
+variable (hlabel : ∀d,label (Γ.reverse d)=inv (label d))
+  (himm : ∀d e,Γ.origin d=Γ.origin e → label d=label e → d=e)
+include hr hlabel himm in
+lemma face_fixed_break (i : a.Occ) (hf : (a.fullPartner*a.closedRotation) i=i) :
+    a.closedRotation i=a.first hxy := by
+  by_contra hi
+  have he : a.closedRotation i=a.fullPartner i := by
+    have hh := congrArg a.fullPartner hf
+    change a.fullPartner (a.fullPartner (a.closedRotation i))=a.fullPartner i at hh
+    rwa [a.fullPartner_involutive] at hh
+  apply a.edge_no_backtrack hxy hr i hi
+  symm
+  apply himm
+  · exact a.edge_consistent hxy i hi
+  · rw [hlabel,he,a.edge_compatible]
+include hxy hr hlabel himm in
+lemma face_monogons_le : (fixed (a.fullPartner*a.closedRotation)).card≤1 := by
+  apply Finset.card_le_one.mpr
+  intro i hi j hj
+  apply a.closedRotation.injective
+  have hfi : (a.fullPartner*a.closedRotation) i=i := by
+    simpa only [fixed,Finset.mem_filter,Finset.mem_univ,true_and] using hi
+  have hfj : (a.fullPartner*a.closedRotation) j=j := by
+    simpa only [fixed,Finset.mem_filter,Finset.mem_univ,true_and] using hj
+  exact (a.face_fixed_break hxy hr hlabel himm i hfi).trans
+    (a.face_fixed_break hxy hr hlabel himm j hfj).symm
+include hxy hr hlabel himm in
+/-- A reduced distinct-endpoint certificate necessarily contains an ordinary
+boundary, not just the exceptional root cycle. This includes singleton cycles. -/
+lemma at_least_two_boundaries : 2≤Fintype.card (Cycle a.closedRotation) := by
+  have he := a.closedRotation_euler hxy
+  have hf := twice_cycles_le (a.fullPartner*a.closedRotation)
+  have hm := a.face_monogons_le hxy hr hlabel himm
+  omega
+include hr hlabel himm in
+lemma ordinary_boundary : ∃c : Cycle a.closedRotation,c≠cycle a.closedRotation (a.first hxy) := by
+  by_contra he
+  push Not at he
+  have hi : Function.Injective (fun _ : Cycle a.closedRotation=>(() : Unit)) := by
+    intro c d _
+    exact (he c).trans (he d).symm
+  have hc := Fintype.card_le_of_injective _ hi
+  simp only [Fintype.card_unit] at hc
+  have hb := a.at_least_two_boundaries hxy hr hlabel himm
+  omega
+end TorsionFreeZeroDivisors.FinitePicture.Data
+
+/-! Exact finite permutation cycles, including singleton cycles, as nonempty
+lists with their literal successor. This is the coordinate bridge from marked
+picture surgery to boundary words; it asserts no geometric realization. -/
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/GroupRing/ClusterLocalization.lean b/lean/OAI/Algebra/GroupRing/ClusterLocalization.lean
new file mode 100644
index 0000000000000000000000000000000000000000..c98d8b55aa4c272a873e419de99203bb2b76d4e7
--- /dev/null
+++ b/lean/OAI/Algebra/GroupRing/ClusterLocalization.lean
@@ -0,0 +1,400 @@
+import Mathlib
+import OAI.Algebra.GroupRing.FiniteClusters
+
+namespace OAI
+
+noncomputable section
+
+namespace TorsionFreeZeroDivisors.ClusterLocalization
+
+section
+open scoped Classical BigOperators
+open ComparedBlocks
+variable {T E : Type} [Fintype T] {len : T → ℕ}
+    (C : Comparisons (E:=E) len) (keep : T → Prop)
+local instance clusterFintype : Fintype (Cluster C keep) := Fintype.ofFinite _
+
+def pathEquiv (c : Cluster C keep) : {t // belongs C keep c t} ≃
+    {v : {t // keep t} // (graph C keep).connectedComponentMk v=c} where
+  toFun t := by
+    have hk : keep t.val := (cluster_exists C keep).mp ⟨c,t.property⟩
+    refine ⟨⟨t.val,hk⟩,?_⟩
+    have he := PairingClusters.cluster_some (fun x : Position len => x.1)
+      C.pairing.partner C.pairing.involutive keep hk
+    exact Option.some.inj (he.symm.trans t.property)
+  invFun v := ⟨v.val.val,by
+    change PairingClusters.cluster _ _ _ _ v.val.val=some c
+    rw [PairingClusters.cluster_some _ _ _ _ v.val.property]
+    exact congrArg some v.property⟩
+  left_inv t := Subtype.ext rfl
+  right_inv v := Subtype.ext (Subtype.ext rfl)
+
+lemma paths_card (c : Cluster C keep) : (paths C keep c).card=(FiniteClusters.block (graph C keep) c).card := by
+  simpa only [Fintype.card_subtype,paths,FiniteClusters.block] using Fintype.card_congr (pathEquiv C keep c)
+lemma member_exists (c : Cluster C keep) : ∃ t,belongs C keep c t := by
+  obtain ⟨v,hv⟩ := FiniteClusters.block_nonempty (graph C keep) c
+  let t := (pathEquiv C keep c).symm ⟨v,(FiniteClusters.mem_block _).mp hv⟩
+  exact ⟨t.val,t.property⟩
+
+/-- A closed retained subset supplied by recursive separation bounds the
+actual connected component, even when the pairing has loops or parallel arcs. -/
+lemma paths_card_le {K : ℕ}
+    (hs : ∀ t,keep t → ∃ B : Finset T,t∈B ∧ B.card≤K ∧
+      ∀ x∈B,∀ y,keep y → PairingClusters.Rel (fun x : Position len=>x.1) C.pairing.partner x y → y∈B)
+    (c : Cluster C keep) : (paths C keep c).card≤K := by
+  rw [paths_card]
+  apply FiniteClusters.block_card
+  intro t
+  obtain ⟨B,hB,hBK,hcl⟩ := hs t.val t.property
+  refine ⟨B.subtype keep,?_,?_,?_⟩
+  · simpa only [Finset.mem_subtype] using hB
+  · exact (by rw [Finset.card_subtype]; exact Finset.card_filter_le _ _ : (B.subtype keep).card≤B.card).trans hBK
+  · intro x hx y hxy
+    have hx' : x.val∈B := by simpa only [Finset.mem_subtype] using hx
+    have hy := hcl x.val hx' y.val y.property hxy.2
+    simpa only [Finset.mem_subtype] using hy
+
+lemma mass_upper {K cap : ℕ} (hK : ∀ c : Cluster C keep,(paths C keep c).card≤K)
+    (hcap : ∀ t,len t≤cap) (c : Cluster C keep) : mass C keep c≤K*cap := by
+  calc
+    _ ≤ ∑ _t∈paths C keep c,cap := Finset.sum_le_sum fun t _=>hcap t
+    _ = (paths C keep c).card*cap := by simp
+    _ ≤ K*cap := Nat.mul_le_mul_right _ (hK c)
+
+lemma mass_lower {L : ℕ} (hL : ∀ t,L≤len t) (c : Cluster C keep) : L ≤ mass C keep c := by
+  obtain ⟨t,ht⟩ := member_exists C keep c
+  apply (hL t).trans
+  exact Finset.single_le_sum (fun _ _=>Nat.zero_le _) (Finset.mem_filter.mpr ⟨Finset.mem_univ _,ht⟩)
+
+lemma short_mass_refined {L : ℕ} (root : Option T)
+    (ho : ∀ t,root≠some t → L≤len t) :
+    (∑ c∈Finset.univ.filter (fun c=>mass C keep c<L),mass C keep c)≤
+      ∑ t∈Finset.univ.filter (fun t=>root=some t ∧ len t<L),len t := by
+  cases root with
+  | none => simpa using short_mass C keep none ho
+  | some r =>
+    by_cases h : len r<L
+    · have he : Finset.univ.filter (fun t=>some r=some t ∧ len t<L)=
+          Finset.univ.filter (fun t=>some r=some t) := by
+        ext t
+        simp only [Finset.mem_filter,Finset.mem_univ,true_and,Option.some.injEq]
+        constructor
+        · exact And.left
+        · intro ht; exact ⟨ht,ht ▸ h⟩
+      rw [he]
+      exact short_mass C keep (some r) ho
+    · have hall : ∀ t,L≤len t := by
+        intro t
+        by_cases ht : r=t
+        · subst t; omega
+        · exact ho t (fun he=>ht (Option.some.inj he))
+      have hn : ∀ c : Cluster C keep,¬mass C keep c<L :=
+        fun c=>not_lt_of_ge (mass_lower C keep hall c)
+      simp only [Finset.filter_false_of_mem (fun c _=>hn c),Finset.sum_empty,Nat.zero_le]
+
+lemma short_mass_half {L : ℕ} (root : Option T) (H₀ : ℝ) (hH₀ : 0≤H₀)
+    (ho : ∀ t,root≠some t → L≤len t)
+    (hr : ∀ t,root=some t → len t<L → (len t:ℝ)≤H₀/2) :
+    ((∑ c∈Finset.univ.filter (fun c=>mass C keep c<L),mass C keep c):ℝ)≤H₀/2 := by
+  have hh : ((∑ c∈Finset.univ.filter (fun c=>mass C keep c<L),mass C keep c):ℝ)≤
+      ((∑ t∈Finset.univ.filter (fun t=>root=some t ∧ len t<L),len t):ℝ) := by
+    exact_mod_cast short_mass_refined C keep root ho
+  apply hh.trans
+  cases root with
+  | none => simp only [reduceCtorEq,false_and]; simp; positivity
+  | some r =>
+    by_cases h : len r<L
+    · have he : (Finset.univ.filter (fun t=>some r=some t ∧ len t<L))={r} := by ext t; simp; aesop
+      rw [he,Finset.sum_singleton]
+      exact hr r rfl h
+    · have he : (Finset.univ.filter (fun t=>some r=some t ∧ len t<L))=∅ := by ext t; simp; aesop
+      rw [he,Finset.sum_empty]
+      positivity
+end
+
+open scoped Classical BigOperators
+open ComparedBlocks
+variable {T E : Type} [Fintype T] [Fintype E] {len : T → ℕ}
+    (C : Comparisons (E:=E) len) (keep : T → Prop)
+local instance selectedClusterFintype : Fintype (Cluster C keep) := Fintype.ofFinite _
+
+omit [Fintype E] in
+/-- Retained closures are nonnegative; only deleted original positions are
+charged in the lower bound for retained mass. -/
+lemma retained_original (old : T → ℕ) (ho : ∀ t,old t≤len t) :
+    (∑t,old t)≤(∑c,mass C keep c)+∑t∈Finset.univ.filter (fun t=>¬keep t),old t := by
+  rw [mass_sum]
+  calc
+    _ = (∑t∈Finset.univ.filter keep,old t)+∑t∈Finset.univ.filter (fun t=>¬keep t),old t :=
+      (Finset.sum_filter_add_sum_filter_not _ _ _).symm
+    _ ≤ _ := Nat.add_le_add_right (Finset.sum_le_sum fun t _=>ho t) _
+
+/-- An averaging argument on the actual connected components of the
+retained pairing graph. E counts oriented interval sides, hence its factor 2. -/
+theorem exists_selected (old : T → ℕ) (ho : ∀ t,old t≤len t)
+    (root : Option T) (L K cap : ℕ) (H₀ ε C₂ : ℝ)
+    (hH₀ : 0<H₀) (hL : 0<L) (hε : 0<ε) (hC₂ : 0<C₂)
+    (hsize : ∀ c : Cluster C keep,(paths C keep c).card≤K)
+    (hcap : ∀ t,len t≤cap*L)
+    (hbase : H₀≤∑t,(old t:ℝ))
+    (hdelete : (∑t∈Finset.univ.filter (fun t=>¬keep t),(old t:ℝ))≤H₀/16)
+    (hbad : ((Finset.univ.filter (fun x : Position len=>C.pairing.partner x=x)).card:ℝ)+
+      ((Finset.univ.filter (fun x : Position len=>¬keep x.1 ∧ C.pairing.partner x≠x)).card:ℝ)≤ε/16*H₀)
+    (hcompare : (Fintype.card E:ℝ)/2≤C₂/(16*L)*H₀)
+    (hlong : ∀ t,root≠some t → L≤len t)
+    (hroot : ∀ t,root=some t → len t<L → (len t:ℝ)≤H₀/2) :
+    ∃ c : Cluster C keep,L ≤ mass C keep c ∧ mass C keep c≤K*cap*L ∧
+      (bad C keep c:ℝ)≤ε*mass C keep c ∧
+      (comparisons C keep c:ℝ)/2≤C₂*mass C keep c/L := by
+  have hret : 15/16*H₀≤∑c,(mass C keep c:ℝ) := by
+    have hh : (∑t,(old t:ℝ))≤(∑c,(mass C keep c:ℝ))+
+        ∑t∈Finset.univ.filter (fun t=>¬keep t),(old t:ℝ) := by
+      exact_mod_cast retained_original C keep old ho
+    linarith
+  have hb : (∑c,(bad C keep c:ℝ))≤ε/16*H₀ := by
+    have hh : (∑c,(bad C keep c:ℝ))≤
+        ((Finset.univ.filter (fun x : Position len=>C.pairing.partner x=x)).card:ℝ)+
+        ((Finset.univ.filter (fun x : Position len=>¬keep x.1 ∧ C.pairing.partner x≠x)).card:ℝ) := by
+      exact_mod_cast bad_sum C keep
+    exact hh.trans hbad
+  have hi : (∑c,(comparisons C keep c:ℝ)/2)≤C₂/(16*L)*H₀ := by
+    rw [←Finset.sum_div]
+    apply le_trans _ hcompare
+    apply div_le_div_of_nonneg_right _ (by norm_num)
+    exact_mod_cast comparisons_sum C keep
+  have hu : ∀ c : Cluster C keep,(mass C keep c:ℝ)≤(K*cap:ℝ)*L := by
+    intro c
+    have h := mass_upper C keep hsize hcap c
+    rw [←Nat.mul_assoc] at h
+    exact_mod_cast h
+  have hs : (∑c∈Finset.univ.filter (fun c=>(mass C keep c:ℝ)<L),(mass C keep c:ℝ))≤H₀/2 := by
+    have h := short_mass_half C keep root H₀ hH₀.le hlong hroot
+    simpa only [Nat.cast_sum,Nat.cast_lt] using h
+  obtain ⟨c,hcl,hcu,hcb,hci⟩ := PlanarLocalization.exists_good_cluster
+    (fun c=>(mass C keep c:ℝ)) (fun c=>(bad C keep c:ℝ))
+    (fun c=>(comparisons C keep c:ℝ)/2) H₀ L ε (K*cap) C₂ hH₀
+    (by exact_mod_cast hL) hε hC₂ (fun _=>Nat.cast_nonneg _) (fun _=>Nat.cast_nonneg _)
+    (fun _=>by positivity) hu hret hb hi hs
+  refine ⟨c,?_,?_,hcb,hci⟩
+  · exact_mod_cast hcl
+  · exact_mod_cast hcu
+end TorsionFreeZeroDivisors.ClusterLocalization
+namespace TorsionFreeZeroDivisors.RestrictComparisons
+open scoped Classical
+variable {T : Type} (root : Option T) (keep : T → Prop)
+def rootPath : Option {t // keep t} := root.bind fun t=>if h : keep t then some ⟨t,h⟩ else none
+lemma rootPath_some (t : {t // keep t}) : rootPath root keep=some t ↔ root=some t.val := by
+  cases root with
+  | none => simp [rootPath]
+  | some r =>
+    by_cases hr : keep r
+    · simp only [rootPath,Option.bind_some,dite_eq_left hr,Option.some.injEq,Subtype.ext_iff]
+    · simp only [rootPath,Option.bind_some,dite_eq_right hr,reduceCtorEq,false_iff,Option.some.injEq]
+      intro h; subst r; exact hr t.property
+lemma rootPath_cyclic (t : {t // keep t}) : StageRoot.cyclic (rootPath root keep) t=StageRoot.cyclic root t.val := by
+  simp only [StageRoot.cyclic,ne_eq,rootPath_some]
+lemma rootPath_map {Z : Type} (f : T → Z) {z : Z}
+    (h : (rootPath root keep).map (f ∘ Subtype.val)=some z) : root.map f=some z := by
+  cases root with
+  | none => simp [rootPath] at h
+  | some r =>
+    by_cases hr : keep r
+    · simpa only [rootPath,Option.bind_some,dite_eq_left hr,Option.map_some,Function.comp_apply] using h
+    · simp only [rootPath,Option.bind_some,dite_eq_right hr,Option.map_none,reduceCtorEq] at h
+end TorsionFreeZeroDivisors.RestrictComparisons
+
+namespace TorsionFreeZeroDivisors.SampleGraph
+open scoped Classical BigOperators
+open PortSubdivision ComparedBlocks ComparisonGeometry GirthAsymptotics TypedGraphs ActualPatternEvent
+/-- Literal path/comparison data before the separator and averaging step.
+Unlike BoundedSystem it makes no quantitative smallness or pairing assumption. -/
+structure PathSystem (rep : ℕ) (r : Match rep) (x : VA rep) (y : VB rep) where
+  P : Type
+  E : Type
+  [fP : Fintype P]
+  [fE : Fintype E]
+  paths : P → List (DA rep⊕DB rep)
+  nonempty : ∀ p,paths p≠[]
+  root : Option P
+  path_chain : ∀ p,(paths p).IsChain (WeightedMoore.PortWalk.step (graph rep r).origin (graph rep r).reverse)
+  cyclic_chain : ∀ p,StageRoot.cyclic root p=true →
+    ∀ᵉ (x∈(paths p).getLast?) (y∈(paths p).head?),
+      WeightedMoore.PortWalk.step (graph rep r).origin (graph rep r).reverse x y
+  comparisons : Comparisons (E:=E) (fun p => (paths p).length)
+  lower : E → ℕ
+  upper : E → ℕ
+  lower_eq : ∀ e,comparisons.lo e=lower e
+  upper_eq : ∀ e,comparisons.hi e=upper e
+  lower_le : ∀ e,lower e≤upper e
+  upper_le : ∀ e,upper e≤(paths (comparisons.source e)).length
+  reduced : ∀ x e,comparisons.side x=some e →
+    RawDecomposition.dart paths x≠RawDecomposition.dart paths (comparisons.pairing.partner x) ∧
+    RawDecomposition.dart paths x≠(graph rep r).reverse (RawDecomposition.dart paths (comparisons.pairing.partner x))
+  rootA : ∀ z,root.map (fun p => (graph rep r).origin ((paths p).head (nonempty p)))=some (.inl z) → z=x
+  rootB : ∀ z,root.map (fun p => (graph rep r).origin ((paths p).head (nonempty p)))=some (.inr z) → z=y
+  compatible : ∀ p e,comparisons.side p=some e → label rep (RawDecomposition.dart paths p)=
+    if comparisons.reverse e then Types.inverse (label rep (RawDecomposition.dart paths (comparisons.pairing.partner p)))
+    else label rep (RawDecomposition.dart paths (comparisons.pairing.partner p))
+attribute [instance] PathSystem.fP PathSystem.fE
+namespace PathSystem
+variable {rep : ℕ} {r : Match rep} {x : VA rep} {y : VB rep}
+    (s : PathSystem rep r x y) (keep : s.P → Prop)
+lemma dart_embed (p : Position (fun t : {t // keep t}=>(s.paths t.val).length)) :
+    RawDecomposition.dart (fun t : {t // keep t}=>s.paths t.val) p=
+      RawDecomposition.dart s.paths (RestrictComparisons.embed keep p) := rfl
+
+abbrev restrict : PathSystem rep r x y where
+  P := {p // keep p}
+  E := {e // RestrictComparisons.Active s.comparisons keep e}
+  fP := inferInstance
+  fE := inferInstance
+  paths := fun p=>s.paths p.val
+  nonempty := fun p=>s.nonempty p.val
+  root := RestrictComparisons.rootPath s.root keep
+  path_chain := fun p=>s.path_chain p.val
+  cyclic_chain := by
+    intro p hp
+    exact s.cyclic_chain p.val ((RestrictComparisons.rootPath_cyclic s.root keep p) ▸ hp)
+  comparisons := RestrictComparisons.comparisons s.comparisons keep
+  lower := fun e=>s.lower e.val
+  upper := fun e=>s.upper e.val
+  lower_eq := fun e=>s.lower_eq e.val
+  upper_eq := fun e=>s.upper_eq e.val
+  lower_le := fun e=>s.lower_le e.val
+  upper_le := fun e=>s.upper_le e.val
+  reduced := by
+    intro p e he
+    have hh := s.reduced (RestrictComparisons.embed keep p) e.val
+      ((RestrictComparisons.side_some s.comparisons keep p e).mp he)
+    rw [←RestrictComparisons.partner_image_of_side s.comparisons keep he] at hh
+    exact hh
+  rootA := fun z hz=>s.rootA z (RestrictComparisons.rootPath_map s.root keep
+    (fun p=>(graph rep r).origin ((s.paths p).head (s.nonempty p))) hz)
+  rootB := fun z hz=>s.rootB z (RestrictComparisons.rootPath_map s.root keep
+    (fun p=>(graph rep r).origin ((s.paths p).head (s.nonempty p))) hz)
+  compatible := by
+    intro p e he
+    have hh := s.compatible (RestrictComparisons.embed keep p) e.val
+      ((RestrictComparisons.side_some s.comparisons keep p e).mp he)
+    rw [←RestrictComparisons.partner_image_of_side s.comparisons keep he] at hh
+    exact hh
+
+/-- Bounding a literal system adds no realizability or word constraints. -/
+def bounded {Bnd K I : ℕ}
+    (hP : Fintype.card s.P≤K) (hE : Fintype.card s.E≤I)
+    (hlo : L (size rep)≤∑p,(s.paths p).length)
+    (hhi : (∑p,(s.paths p).length)≤Bnd*L (size rep))
+    (hbad : ((Finset.univ.filter (fun p=>s.comparisons.pairing.partner p=p)).card:ℝ)≤
+      StageFusion.epsilon (1/600) 256*(∑p,(s.paths p).length:ℕ)) : BoundedSystem Bnd K I rep r x y where
+  P := s.P
+  E := s.E
+  paths := s.paths
+  nonempty := s.nonempty
+  root := s.root
+  path_bound := hP
+  comparison_bound := hE
+  path_chain := s.path_chain
+  cyclic_chain := s.cyclic_chain
+  length_le := hhi
+  length_ge := hlo
+  comparisons := s.comparisons
+  lower := s.lower
+  upper := s.upper
+  lower_eq := s.lower_eq
+  upper_eq := s.upper_eq
+  lower_le := s.lower_le
+  upper_le := s.upper_le
+  reduced := s.reduced
+  unpaired_le := hbad
+  rootA := s.rootA
+  rootB := s.rootB
+  compatible := s.compatible
+end PathSystem
+end TorsionFreeZeroDivisors.SampleGraph
+namespace TorsionFreeZeroDivisors.SampleGraph.PathSystem
+open scoped Classical BigOperators
+open ComparedBlocks ClusterLocalization GirthAsymptotics TypedGraphs ActualPatternEvent
+variable {rep : ℕ} {r : Match rep} {x : VA rep} {y : VB rep}
+    (s : PathSystem rep r x y) (keep : s.P → Prop)
+local instance : Fintype (Cluster s.comparisons keep) := Fintype.ofFinite _
+
+/-- Realizes the selected component by exactly its literal retained paths and
+interval sides, with the same signs, noncoincident lifts, and prescribed root. -/
+def selected_bounded {Bnd K I : ℕ} (c : Cluster s.comparisons keep)
+    (hP : (ClusterLocalization.paths s.comparisons keep c).card≤K)
+    (hE : ClusterLocalization.comparisons s.comparisons keep c≤I)
+    (hlo : L (size rep) ≤ mass s.comparisons keep c)
+    (hhi : mass s.comparisons keep c≤Bnd*L (size rep))
+    (hbad : (bad s.comparisons keep c:ℝ)≤
+      StageFusion.epsilon (1/600) 256*mass s.comparisons keep c) :
+    BoundedSystem Bnd K I rep r x y := by
+  let sc := s.restrict (belongs s.comparisons keep c)
+  refine {
+    P := {p // belongs s.comparisons keep c p}
+    E := {e // RestrictComparisons.Active s.comparisons (belongs s.comparisons keep c) e}
+    fP := inferInstance
+    fE := inferInstance
+    paths := fun p=>s.paths p.val
+    nonempty := fun p=>s.nonempty p.val
+    root := sc.root
+    path_bound := ?_
+    comparison_bound := hE
+    path_chain := sc.path_chain
+    cyclic_chain := sc.cyclic_chain
+    length_le := ?_
+    length_ge := ?_
+    comparisons := localC s.comparisons keep c
+    lower := sc.lower
+    upper := sc.upper
+    lower_eq := sc.lower_eq
+    upper_eq := sc.upper_eq
+    lower_le := sc.lower_le
+    upper_le := sc.upper_le
+    reduced := sc.reduced
+    unpaired_le := ?_
+    rootA := sc.rootA
+    rootB := sc.rootB
+    compatible := sc.compatible }
+  · simpa only [Fintype.card_subtype,ClusterLocalization.paths] using hP
+  · rw [local_mass]; exact hhi
+  · rw [local_mass]; exact hlo
+  · rw [←fixed_card s.comparisons keep c,←local_mass s.comparisons keep c] at hbad
+    convert hbad using 2
+    congr 1
+    ext p
+    simp
+
+/-- The analytic union bound excludes the localized system using the sharp
+mass and interval estimates. -/
+theorem excluded_of_local_totals (K cap : ℕ) (C₂ H₀ : ℝ) (old : s.P → ℕ)
+    (ho : ∀ t,old t≤(s.paths t).length)
+    (hH₀ : 0<H₀) (hL : 0<L (size rep)) (hC₂ : 0<C₂)
+    (hsize : ∀ c : Cluster s.comparisons keep,(ClusterLocalization.paths s.comparisons keep c).card≤K)
+    (hcap : ∀ t,(s.paths t).length≤cap*L (size rep))
+    (hbase : H₀≤∑t,(old t:ℝ))
+    (hdelete : (∑t∈Finset.univ.filter (fun t=>¬keep t),(old t:ℝ))≤H₀/16)
+    (hbad : ((Finset.univ.filter (fun p=>s.comparisons.pairing.partner p=p)).card:ℝ)+
+      ((Finset.univ.filter (fun p=>¬keep p.1 ∧ s.comparisons.pairing.partner p≠p)).card:ℝ)≤
+        StageFusion.epsilon (1/600) 256/16*H₀)
+    (hcompare : (Fintype.card s.E:ℝ)/2≤C₂/(16*L (size rep))*H₀)
+    (hlong : ∀ t,s.root≠some t → L (size rep)≤(s.paths t).length)
+    (hroot : ∀ t,s.root=some t → (s.paths t).length<L (size rep) → ((s.paths t).length:ℝ)≤H₀/2)
+    (havoid : IsEmpty (BoundedSystem (K*cap) K ⌈2*C₂*(K*cap:ℝ)⌉₊ rep r x y)) : False := by
+  have hε : 0<StageFusion.epsilon (1/600) 256 := StageFusion.epsilon_pos (by norm_num) (by norm_num)
+  obtain ⟨c,hlo,hhi,hb,hi⟩ := exists_selected s.comparisons keep old ho s.root
+    (L (size rep)) K cap H₀ (StageFusion.epsilon (1/600) 256) C₂ hH₀ hL hε hC₂
+    hsize hcap hbase hdelete hbad hcompare hlong hroot
+  have he : ClusterLocalization.comparisons s.comparisons keep c≤⌈2*C₂*(K*cap:ℝ)⌉₊ := by
+    suffices (ClusterLocalization.comparisons s.comparisons keep c:ℝ)≤(⌈2*C₂*(K*cap:ℝ)⌉₊:ℝ) by exact_mod_cast this
+    apply le_trans _ (Nat.le_ceil _)
+    have hLr : (0:ℝ)<L (size rep) := by exact_mod_cast hL
+    have hi' := (le_div_iff₀ hLr).mp hi
+    have hh : (mass s.comparisons keep c:ℝ)≤(K*cap:ℝ)*L (size rep) := by exact_mod_cast hhi
+    have hm := mul_le_mul_of_nonneg_left hh hC₂.le
+    nlinarith
+  exact havoid.false (s.selected_bounded keep c (hsize c) he hlo hhi hb)
+end TorsionFreeZeroDivisors.SampleGraph.PathSystem
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/GroupRing/ComparisonCoding.lean b/lean/OAI/Algebra/GroupRing/ComparisonCoding.lean
new file mode 100644
index 0000000000000000000000000000000000000000..61195eecc801ceb510feb2961f21d657c9ef3e00
--- /dev/null
+++ b/lean/OAI/Algebra/GroupRing/ComparisonCoding.lean
@@ -0,0 +1,374 @@
+import Mathlib
+import OAI.Algebra.GroupRing.Iso
+
+namespace OAI
+
+noncomputable section
+
+namespace TorsionFreeZeroDivisors.ComparisonCoding
+open scoped Classical
+open PatternCoding
+
+/-- Full integer affine comparison geometry. The offset uses [-2H,2H]. -/
+structure Data (P E : Type*) (H : ℕ) where
+  flip : E → E
+  source : E → P
+  lower : E → Fin (H+1)
+  upper : E → Fin (H+1)
+  reverse : E → Bool
+  offset : E → Fin (4*H+1)
+
+abbrev Code (K I H : ℕ) := (Fin I → Fin I) × (Fin I → Fin K) ×
+  (Fin I → Fin (H+1)) × (Fin I → Fin (H+1)) ×
+  (Fin I → Bool) × (Fin I → Fin (4*H+1))
+
+def coefficient (K I : ℕ) := (8*I*K)^I
+
+lemma card_code (K I H : ℕ) : Fintype.card (Code K I H) =
+    I^I*K^I*(H+1)^(2*I)*2^I*(4*H+1)^I := by
+  simp only [Code,Fintype.card_prod,Fintype.card_fun,Fintype.card_fin,Fintype.card_bool]
+  rw [show 2*I=I+I by omega, pow_add]
+  ring
+
+lemma card_code_bound (K I H : ℕ) : Fintype.card (Code K I H) ≤
+    coefficient K I*(H+1)^(3*I) := by
+  rw [card_code]
+  have h : (4*H+1)^I≤(4*(H+1))^I := Nat.pow_le_pow_left (by omega) I
+  apply le_trans (Nat.mul_le_mul_left _ h)
+  apply le_of_eq
+  simp only [coefficient,mul_pow,show 2*I=I+I by omega,
+    show 3*I=I+(I+I) by omega,pow_add]
+  rw [show (8:ℕ)^I=2^I*4^I by rw [←mul_pow]; norm_num]
+  ring
+
+variable {P E P' E' : Type*} [Fintype P] [Fintype E] [Fintype P'] [Fintype E']
+    (K I H : ℕ) (hK : 0<K) (hI : 0<I)
+    (hP : Fintype.card P≤K) (hE : Fintype.card E≤I)
+
+def encode (a : Data P E H) : Code K I H :=
+  (pad I hE ⟨0,hI⟩ (fun e => names I hE (a.flip e)),
+   pad I hE ⟨0,hK⟩ (fun e => names K hP (a.source e)),
+   pad I hE 0 a.lower,pad I hE 0 a.upper,
+   pad I hE false a.reverse,pad I hE 0 a.offset)
+
+structure Isomorphism (a : Data P E H) (b : Data P' E' H) where
+  path : P ≃ P'
+  comparison : E ≃ E'
+  flip_eq : ∀ e,comparison (a.flip e)=b.flip (comparison e)
+  source_eq : ∀ e,path (a.source e)=b.source (comparison e)
+  lower_eq : ∀ e,a.lower e=b.lower (comparison e)
+  upper_eq : ∀ e,a.upper e=b.upper (comparison e)
+  reverse_eq : ∀ e,a.reverse e=b.reverse (comparison e)
+  offset_eq : ∀ e,a.offset e=b.offset (comparison e)
+
+variable (hP' : Fintype.card P'≤K) (hE' : Fintype.card E'≤I)
+
+theorem encode_complete (a : Data P E H) (b : Data P' E' H)
+    (cP : Fintype.card P=Fintype.card P') (cE : Fintype.card E=Fintype.card E')
+    (he : encode K I H hK hI hP hE a=encode K I H hK hI hP' hE' b) :
+    ∃ f : Isomorphism H a b, f.path=rename cP ∧ f.comparison=rename cE := by
+  simp only [encode,Prod.mk.injEq] at he
+  obtain ⟨hf,hs,hl,hu,hr,ho⟩ := he
+  have hflip (e : E) : rename cE (a.flip e)=b.flip (rename cE e) := by
+    apply names_injective hE'
+    rw [rename_names I hE hE']
+    exact same_pad I hE hE' cE (⟨0,hI⟩ : Fin I) _ _ hf e
+  have hsource (e : E) : rename cP (a.source e)=b.source (rename cE e) := by
+    apply names_injective hP'
+    rw [rename_names K hP hP']
+    exact same_pad I hE hE' cE (⟨0,hK⟩ : Fin K) _ _ hs e
+  exact ⟨⟨rename cP,rename cE,hflip,hsource,
+    same_pad I hE hE' cE 0 _ _ hl,same_pad I hE hE' cE 0 _ _ hu,
+    same_pad I hE hE' cE false _ _ hr,same_pad I hE hE' cE 0 _ _ ho⟩,rfl,rfl⟩
+
+end TorsionFreeZeroDivisors.ComparisonCoding
+
+namespace TorsionFreeZeroDivisors.SubdivisionIso
+open scoped Classical
+open ChainSubdivision PortSubdivision
+variable {C V C' V' : Type*} (len : C → ℕ) (len' : C' → ℕ)
+    (first last : C → V) (first' last' : C' → V')
+    (eC : C ≃ C') (eV : V ≃ V') (hl : ∀ c,len c=len' (eC c))
+
+def edge : Edge len ≃ Edge len' := Equiv.sigmaCongr eC (fun c => finCongr (hl c))
+def interior : Interior len ≃ Interior len' := Equiv.sigmaCongr eC (fun c => finCongr (congrArg (fun n => n-1) (hl c)))
+def vertex : Vertex len (V:=V) ≃ Vertex len' (V:=V') := Equiv.sumCongr eV (interior len len' eC hl)
+def dart : Dart len ≃ Dart len' := Equiv.prodCongr (edge len len' eC hl) (Equiv.refl Bool)
+
+variable (hf : ∀ c,eV (first c)=first' (eC c)) (ht : ∀ c,eV (last c)=last' (eC c))
+
+include hf ht in
+lemma point_eq (c : C) (k : Fin (len c+1)) :
+    vertex len len' eC eV hl (point len first last c k)=
+      point len' first' last' (eC c) ⟨k.val,by rw [←hl c]; exact k.isLt⟩ := by
+  by_cases hz : k.val=0
+  · simp [point,hz,vertex,hf]
+  · by_cases ht' : k.val=len c
+    · have hn : k.val=len' (eC c) := ht'.trans (hl c)
+      simp only [point,dite_eq_right hz,dite_eq_left ht',dite_eq_left hn]
+      exact congrArg Sum.inl (ht c)
+    · have hn : k.val≠len' (eC c) := by rwa [←hl c]
+      simp only [point,dite_eq_right hz,dite_eq_right ht',dite_eq_right hn]
+      rfl
+
+include hf ht in
+lemma origin_eq (d : Dart len) :
+    vertex len len' eC eV hl ((graph len first last).origin d)=
+      (graph len' first' last').origin (dart len len' eC hl d) := by
+  exact point_eq len len' first last first' last' eC eV hl hf ht d.1.1 _
+
+omit eV in
+lemma reverse_eq (d : Dart len) :
+    dart len len' eC hl ((graph len first last).reverse d)=
+      (graph len' first' last').reverse (dart len len' eC hl d) := rfl
+
+end TorsionFreeZeroDivisors.SubdivisionIso
+
+namespace TorsionFreeZeroDivisors.RankedSuppressionIso
+
+section
+open scoped Classical
+open PortSubdivision ChainSuppression DegreeTwoSuppression SuppressedMoore ChainPaths ChainIsomorphism
+variable {V D V' D' : Type*} [Fintype D] [Fintype D']
+    (Γ : PortGraph V D) (mark : V → Prop) (h2 : ∀ v,¬mark v → (out Γ.origin v).card=2)
+    (Γ' : PortGraph V' D') (mark' : V' → Prop) (h2' : ∀ v,¬mark' v → (out Γ'.origin v).card=2)
+def skeleton : PortGraph (Mark mark) {d : D // turn Γ.origin mark h2 d=d} where
+  origin d := ⟨Γ.origin d.val,(turn_fixed_iff Γ.origin mark h2 _).mp d.property⟩
+  reverse := (suppressed Γ mark h2).reverse
+  reverse_reverse := (suppressed Γ mark h2).reverse_reverse
+  reverse_ne := (suppressed Γ mark h2).reverse_ne
+
+local notation "S" => skeleton Γ mark h2
+local notation "S'" => skeleton Γ' mark' h2'
+local notation "B" => {d : D // turn Γ.origin mark h2 d=d}
+local notation "B'" => {d : D' // turn Γ'.origin mark' h2' d=d}
+local notation "R" => Rep Γ mark h2
+local notation "R'" => Rep Γ' mark' h2'
+
+lemma chosen_iff (f : Iso S S')
+    (hrank : ∀ d,(Fintype.equivFin B' (f.dart d)).val=(Fintype.equivFin B d).val) (d : B) : InvolutionOrientation.Chosen (S).reverse d ↔
+    InvolutionOrientation.Chosen (S').reverse (f.dart d) := by
+  unfold InvolutionOrientation.Chosen InvolutionOrientation.rank
+  change (Fintype.equivFin B d).val < (Fintype.equivFin B ((S).reverse d)).val ↔
+    (Fintype.equivFin B' (f.dart d)).val < (Fintype.equivFin B' ((S').reverse (f.dart d))).val
+  rw [←f.reverse_eq,hrank,hrank]
+
+def rep (f : Iso S S')
+    (hrank : ∀ d,(Fintype.equivFin B' (f.dart d)).val=(Fintype.equivFin B d).val) : R ≃ R' :=
+  f.dart.subtypeEquiv (chosen_iff Γ mark h2 Γ' mark' h2' f hrank)
+
+lemma rep_length (f : Iso S S')
+    (hrank : ∀ d,(Fintype.equivFin B' (f.dart d)).val=(Fintype.equivFin B d).val)
+    (hlen : ∀ d,chainLength Γ mark h2 d=chainLength Γ' mark' h2' (f.dart d)) (c : R) : repLength Γ mark h2 c=
+    repLength Γ' mark' h2' (rep Γ mark h2 Γ' mark' h2' f hrank c) := hlen c.val
+
+lemma first_eq (f : Iso S S')
+    (hrank : ∀ d,(Fintype.equivFin B' (f.dart d)).val=(Fintype.equivFin B d).val) (c : R) : f.vertex (first Γ mark h2 c)=
+    first Γ' mark' h2' (rep Γ mark h2 Γ' mark' h2' f hrank c) := f.origin_eq c.val
+
+lemma last_eq (f : Iso S S')
+    (hrank : ∀ d,(Fintype.equivFin B' (f.dart d)).val=(Fintype.equivFin B d).val) (c : R) : f.vertex (last Γ mark h2 c)=
+    last Γ' mark' h2' (rep Γ mark h2 Γ' mark' h2' f hrank c) := by
+  change f.vertex ((S).origin ((S).reverse c.val))=(S').origin ((S').reverse (f.dart c.val))
+  rw [f.origin_eq,f.reverse_eq]
+
+/-- Exact canonical-rank suppression isomorphisms lift to actual subdivisions. -/
+def subdivided (f : Iso S S')
+    (hrank : ∀ d,(Fintype.equivFin B' (f.dart d)).val=(Fintype.equivFin B d).val)
+    (hlen : ∀ d,chainLength Γ mark h2 d=chainLength Γ' mark' h2' (f.dart d)) :
+    Iso (ChainSubdivision.graph (repLength Γ mark h2) (first Γ mark h2) (last Γ mark h2))
+      (ChainSubdivision.graph (repLength Γ' mark' h2') (first Γ' mark' h2') (last Γ' mark' h2')) where
+  vertex := SubdivisionIso.vertex _ _ (rep Γ mark h2 Γ' mark' h2' f hrank) f.vertex
+    (rep_length Γ mark h2 Γ' mark' h2' f hrank hlen)
+  dart := SubdivisionIso.dart _ _ (rep Γ mark h2 Γ' mark' h2' f hrank)
+    (rep_length Γ mark h2 Γ' mark' h2' f hrank hlen)
+  origin_eq := SubdivisionIso.origin_eq _ _ _ _ _ _ _ _ _
+    (first_eq Γ mark h2 Γ' mark' h2' f hrank) (last_eq Γ mark h2 Γ' mark' h2' f hrank)
+  reverse_eq := SubdivisionIso.reverse_eq _ _ _ _ _ _ _ _
+
+variable (hcovered : ∀ d,ChainCoverage.Covered Γ.reverse (turn Γ.origin mark h2)
+    Γ.reverse_reverse (turn_involutive Γ.origin mark h2) d)
+  (hcovered' : ∀ d,ChainCoverage.Covered Γ'.reverse (turn Γ'.origin mark' h2')
+    Γ'.reverse_reverse (turn_involutive Γ'.origin mark' h2') d)
+
+def actual (hcovered : ∀ d,ChainCoverage.Covered Γ.reverse (turn Γ.origin mark h2)
+    Γ.reverse_reverse (turn_involutive Γ.origin mark h2) d) :
+    Iso (ChainSubdivision.graph (repLength Γ mark h2) (first Γ mark h2) (last Γ mark h2)) Γ where
+  vertex := vertexEquiv Γ mark h2 hcovered
+  dart := dartEquiv Γ mark h2 hcovered
+  origin_eq := origin_map Γ mark h2
+  reverse_eq := dartMap_reverse Γ mark h2
+
+include hcovered hcovered' in
+/-- No vertex or dart names survive, but all actual graph incidence does. -/
+def full (f : Iso S S')
+    (hrank : ∀ d,(Fintype.equivFin B' (f.dart d)).val=(Fintype.equivFin B d).val)
+    (hlen : ∀ d,chainLength Γ mark h2 d=chainLength Γ' mark' h2' (f.dart d)) : Iso Γ Γ' :=
+  ((actual Γ mark h2 hcovered).symm.trans (subdivided Γ mark h2 Γ' mark' h2' f hrank hlen)).trans
+    (actual Γ' mark' h2' hcovered')
+
+end
+
+section
+open scoped Classical
+open Function PortSubdivision ChainSuppression DegreeTwoSuppression SuppressedMoore ChainPaths ChainIsomorphism
+variable {V D V' D' : Type*} [Fintype D] [Fintype D']
+    (Γ : PortGraph V D) (mark : V → Prop) (h2 : ∀ v,¬mark v → (out Γ.origin v).card=2)
+    (Γ' : PortGraph V' D') (mark' : V' → Prop) (h2' : ∀ v,¬mark' v → (out Γ'.origin v).card=2)
+    (hcovered : ∀ d,ChainCoverage.Covered Γ.reverse (turn Γ.origin mark h2)
+      Γ.reverse_reverse (turn_involutive Γ.origin mark h2) d)
+    (hcovered' : ∀ d,ChainCoverage.Covered Γ'.reverse (turn Γ'.origin mark' h2')
+      Γ'.reverse_reverse (turn_involutive Γ'.origin mark' h2') d)
+local notation "S" => skeleton Γ mark h2
+local notation "S'" => skeleton Γ' mark' h2'
+local notation "B" => {d : D // turn Γ.origin mark h2 d=d}
+local notation "B'" => {d : D' // turn Γ'.origin mark' h2' d=d}
+local notation "R" => Rep Γ mark h2
+local notation "F" => next Γ.reverse (turn Γ.origin mark h2)
+local notation "F'" => next Γ'.reverse (turn Γ'.origin mark' h2')
+local notation "len" => chainLength Γ mark h2
+local notation "len'" => chainLength Γ' mark' h2'
+
+lemma full_dartMap (f : Iso S S')
+    (hrank : ∀ d,(Fintype.equivFin B' (f.dart d)).val=(Fintype.equivFin B d).val)
+    (hlen : ∀ d,len d=len' (f.dart d)) (d : ChainSubdivision.Dart (repLength Γ mark h2)) :
+    (full Γ mark h2 Γ' mark' h2' hcovered hcovered' f hrank hlen).dart (dartMap Γ mark h2 d)=
+      dartMap Γ' mark' h2' ((subdivided Γ mark h2 Γ' mark' h2' f hrank hlen).dart d) := by
+  change (dartEquiv Γ' mark' h2' hcovered')
+    ((subdivided Γ mark h2 Γ' mark' h2' f hrank hlen).dart
+      ((dartEquiv Γ mark h2 hcovered).symm ((dartEquiv Γ mark h2 hcovered) d))) = _
+  rw [Equiv.symm_apply_apply]
+  rfl
+
+lemma full_forward (f : Iso S S')
+    (hrank : ∀ d,(Fintype.equivFin B' (f.dart d)).val=(Fintype.equivFin B d).val)
+    (hlen : ∀ d,len d=len' (f.dart d)) (c : R) (i : Fin (len c.val)) :
+    (full Γ mark h2 Γ' mark' h2' hcovered hcovered' f hrank hlen).dart (F^[i.val] c.val.val)=
+      F'^[i.val] (f.dart c.val).val :=
+  full_dartMap Γ mark h2 Γ' mark' h2' hcovered hcovered' f hrank hlen (⟨c,i⟩,false)
+
+lemma full_iter (f : Iso S S')
+    (hrank : ∀ d,(Fintype.equivFin B' (f.dart d)).val=(Fintype.equivFin B d).val)
+    (hlen : ∀ d,len d=len' (f.dart d)) (d : B) (i : ℕ) (hi : i<len d) :
+    (full Γ mark h2 Γ' mark' h2' hcovered hcovered' f hrank hlen).dart (F^[i] d.val)=
+      F'^[i] (f.dart d).val := by
+  rcases InvolutionOrientation.chosen_or_reverse (S).reverse (S).reverse_reverse (S).reverse_ne d with hd|hd
+  · exact full_forward Γ mark h2 Γ' mark' h2' hcovered hcovered' f hrank hlen ⟨d,hd⟩ ⟨i,hi⟩
+  · have hj : len d-i-1<len ((S).reverse d) := by
+      change len d-i-1<len ((suppressed Γ mark h2).reverse d)
+      rw [chainLength_reverse]
+      omega
+    have hj' : i<len' (f.dart d) := by rwa [←hlen d]
+    apply Γ'.reverse_reverse.injective
+    rw [←(full Γ mark h2 Γ' mark' h2' hcovered hcovered' f hrank hlen).reverse_eq]
+    rw [←ChainChunkTransport.reverse_iter Γ mark h2 d i hi,
+      ←ChainChunkTransport.reverse_iter Γ' mark' h2' (f.dart d) i hj']
+    have h := full_forward Γ mark h2 Γ' mark' h2' hcovered hcovered' f hrank hlen
+      ⟨(S).reverse d,hd⟩ ⟨len d-i-1,hj⟩
+    have hrev : f.dart ((suppressed Γ mark h2).reverse d)=
+        (suppressed Γ' mark' h2').reverse (f.dart d) := f.reverse_eq d
+    simpa only [skeleton,hlen d,hrev] using h
+
+lemma full_word (f : Iso S S')
+    (hrank : ∀ d,(Fintype.equivFin B' (f.dart d)).val=(Fintype.equivFin B d).val)
+    (hlen : ∀ d,len d=len' (f.dart d)) (d : B) :
+    (word Γ mark h2 d).map (full Γ mark h2 Γ' mark' h2' hcovered hcovered' f hrank hlen).dart =
+      word Γ' mark' h2' (f.dart d) := by
+  rw [word_eq_range,word_eq_range,List.map_map,←hlen d]
+  apply List.map_congr_left
+  intro i hi
+  exact full_iter Γ mark h2 Γ' mark' h2' hcovered hcovered' f hrank hlen d i (List.mem_range.mp hi)
+
+end
+
+open scoped Classical
+open Function PortSubdivision ChainSuppression DegreeTwoSuppression SuppressedMoore ChainPaths ChainIsomorphism
+variable {V D V' D' : Type} [Fintype D] [Fintype D']
+    (Γ : PortGraph V D) (mark : V → Prop) (h2 : ∀ v,¬mark v → (out Γ.origin v).card=2)
+    (Γ' : PortGraph V' D') (mark' : V' → Prop) (h2' : ∀ v,¬mark' v → (out Γ'.origin v).card=2)
+    (hcovered : ∀ d,ChainCoverage.Covered Γ.reverse (turn Γ.origin mark h2)
+      Γ.reverse_reverse (turn_involutive Γ.origin mark h2) d)
+    (hcovered' : ∀ d,ChainCoverage.Covered Γ'.reverse (turn Γ'.origin mark' h2')
+      Γ'.reverse_reverse (turn_involutive Γ'.origin mark' h2') d)
+local notation "S" => skeleton Γ mark h2
+local notation "S'" => skeleton Γ' mark' h2'
+local notation "B" => {d : D // turn Γ.origin mark h2 d=d}
+local notation "B'" => {d : D' // turn Γ'.origin mark' h2' d=d}
+local notation "len" => chainLength Γ mark h2
+local notation "len'" => chainLength Γ' mark' h2'
+variable (f : Iso (skeleton Γ mark h2) (skeleton Γ' mark' h2'))
+    (hrank : ∀ d,(Fintype.equivFin {d : D' // turn Γ'.origin mark' h2' d=d} (f.dart d)).val=
+      (Fintype.equivFin {d : D // turn Γ.origin mark h2 d=d} d).val)
+    (hlen : ∀ d,chainLength Γ mark h2 d=chainLength Γ' mark' h2' (f.dart d))
+local notation "F" => full Γ mark h2 Γ' mark' h2' hcovered hcovered' f hrank hlen
+
+lemma full_seed (d : B) : (F).dart d.val=(f.dart d).val :=
+  full_iter Γ mark h2 Γ' mark' h2' hcovered hcovered' f hrank hlen d 0
+    (chainLength_pos Γ mark h2 d)
+
+lemma full_vertexMap (v : ChainSubdivision.Vertex (repLength Γ mark h2) (V:=Mark mark)) :
+    (F).vertex (vertexMap Γ mark h2 v)=vertexMap Γ' mark' h2'
+      ((subdivided Γ mark h2 Γ' mark' h2' f hrank hlen).vertex v) := by
+  change (vertexEquiv Γ' mark' h2' hcovered')
+    ((subdivided Γ mark h2 Γ' mark' h2' f hrank hlen).vertex
+      ((vertexEquiv Γ mark h2 hcovered).symm ((vertexEquiv Γ mark h2 hcovered) v)))=_
+  rw [Equiv.symm_apply_apply]
+  rfl
+
+variable (side : V → Bool) (side' : V' → Bool)
+    (hs : ∀ d,side (Γ.origin (Γ.reverse d))=side (Γ.origin d))
+    (hs' : ∀ d,side' (Γ'.origin (Γ'.reverse d))=side' (Γ'.origin d))
+    (hside : ∀ v : Mark mark,side v.val=side' (f.vertex v).val)
+
+include hside hs hs' in
+lemma full_side (v : V) : side v=side' ((F).vertex v) := by
+  obtain ⟨v,rfl⟩ := (vertexEquiv Γ mark h2 hcovered).surjective v
+  change side (vertexMap Γ mark h2 v)=side' ((F).vertex (vertexMap Γ mark h2 v))
+  rw [full_vertexMap]
+  cases v with
+  | inl v => exact hside v
+  | inr v =>
+    rcases v with ⟨c,i⟩
+    change side (Γ.origin ((next Γ.reverse (turn Γ.origin mark h2))^[i.val+1] c.val.val))=
+      side' (Γ'.origin ((next Γ'.reverse (turn Γ'.origin mark' h2'))^[i.val+1] (f.dart c.val).val))
+    rw [ChainSide.iterate_side Γ mark h2 side hs,ChainSide.iterate_side Γ' mark' h2' side' hs']
+    have he := congrArg (fun x : Mark mark' => side' x.val) (f.origin_eq c.val)
+    exact (hside ((S).origin c.val)).trans he
+
+variable {P P' : Type} (paths : P → List {d : D // turn Γ.origin mark h2 d=d})
+    (paths' : P' → List {d : D' // turn Γ'.origin mark' h2' d=d})
+    (eP : P ≃ P') (hp : ∀ p,(paths p).map f.dart=paths' (eP p))
+
+include hp in
+lemma full_words (p : P) : ((paths p).flatMap (word Γ mark h2)).map (F).dart =
+    (paths' (eP p)).flatMap (word Γ' mark' h2') := by
+  rw [List.map_flatMap,←hp,List.flatMap_map]
+  apply List.flatMap_congr
+  intro d _
+  exact full_word Γ mark h2 Γ' mark' h2' hcovered hcovered' f hrank hlen d
+
+variable (hne : ∀ p,paths p≠[]) (hne' : ∀ p,paths' p≠[])
+    (root : Option P) (root' : Option P') (hroot : root.map eP=root')
+
+include hp hroot in
+lemma full_source : (StageRoot.source Γ mark h2 paths hne root).map (F).vertex=
+    StageRoot.source Γ' mark' h2' paths' hne' root' := by
+  rw [←hroot]
+  cases root with
+  | none => rfl
+  | some p =>
+    simp only [StageRoot.source,Option.map_some]
+    apply congrArg some
+    change (F).vertex (Γ.origin ((paths p).head (hne p)).val)=
+      Γ'.origin ((paths' (eP p)).head (hne' _)).val
+    rw [(F).origin_eq,full_seed]
+    have hh := congrArg List.head? (hp p)
+    rw [List.head?_map,List.head?_eq_some_head (hne p),
+      List.head?_eq_some_head (hne' (eP p))] at hh
+    exact congrArg (fun d => Γ'.origin d.val) (Option.some.inj hh)
+
+end TorsionFreeZeroDivisors.RankedSuppressionIso
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/GroupRing/ConcreteGroup.lean b/lean/OAI/Algebra/GroupRing/ConcreteGroup.lean
new file mode 100644
index 0000000000000000000000000000000000000000..9476185615d800230ef76f89c4f4880b44774052
--- /dev/null
+++ b/lean/OAI/Algebra/GroupRing/ConcreteGroup.lean
@@ -0,0 +1,356 @@
+import Mathlib
+import OAI.Algebra.GroupRing.CycleLists
+import OAI.Algebra.GroupRing.Path
+
+namespace OAI
+
+noncomputable section
+
+namespace TorsionFreeZeroDivisors.ConcreteGroup
+open scoped Classical
+open SampleGraph
+variable {rep : ℕ} (r : ActualPatternEvent.Match rep)
+/-- Equal values at distinct endpoints within one graph component have an
+actual reduced lifted disk picture. This is the precise obstruction needed
+for the nonvanishing of the authors' factors, with no graph embedding assumed. -/
+theorem equal_value_picture {z w : VA rep⊕VB rep}
+    (hp : (ShortClosure.simpleGraph (Γ rep r)).Reachable z w) (hzw : z≠w)
+    (hv : value rep r z=value rep r w) :
+    ∃n,∃a : FinitePicture.Data (O:=Fin n) (Γ rep r) (SampleGraph.label rep) Types.inverse z w,
+      a.Reduced := by
+  let p := GraphPresentation.Path.ofWalk (Γ:=Γ rep r) (Classical.choice hp)
+  apply reduced_picture r p hzw
+  rw [path_value,hv,inv_mul_cancel]
+
+end TorsionFreeZeroDivisors.ConcreteGroup
+namespace TorsionFreeZeroDivisors.SampleGraph.Picture
+open scoped Classical
+open BlockAlignment ComparedBlocks
+variable {rep : ℕ} (r : ActualPatternEvent.Match rep) (x : VA rep) (y : VB rep)
+  (hL : 2≤GirthAsymptotics.L (TypedGraphs.size rep)) (hd : GraphSample.Diameters rep r)
+/-- The exact remaining sharp-separator obligation for the literal prepared
+interaction graphs of disk pictures. This is NOT proved or inserted as a
+hypothesis into the main target: it records the unclosed dependency. -/
+def SeparatorObligation : Prop :=
+  ∀(z w : VA rep⊕VB rep) (n : ℕ)
+    (a : FinitePicture.Data (O:=Fin n) (graph rep r) (label rep) Types.inverse z w)
+    (hzw : z≠w) (hr : a.Reduced) (hz : z=Sum.inl x ∨ z=Sum.inr y),
+  ∀ S : Finset ((pairing a hzw hr hz).prepared hL hd).P,
+    PlanarParameters.K PathSystem.ε ClosedWords.D<S.card →
+    Nonempty (RecursiveSeparator.Split
+      (PairingClusters.Rel (fun p : Position (fun t=>(((pairing a hzw hr hz).prepared hL hd).paths t).length)=>p.1)
+        ((pairing a hzw hr hz).prepared hL hd).comparisons.pairing.partner) S)
+/-- The actual disk/path endpoint, conditional on exactly the
+still-missing sharp-separator dependency, not a replacement main theorem. -/
+theorem root_path_nontrivial (hsample : r∈ActualPatternEvent.samples rep)
+    (hsep : SeparatorObligation r x y hL hd)
+    (havoid : IsEmpty (BoundedSystem (PlanarParameters.C PathSystem.ε ClosedWords.D)
+      (PlanarParameters.K PathSystem.ε ClosedWords.D) (PlanarParameters.sides PathSystem.ε ClosedWords.D) rep r x y))
+    {z w : VA rep⊕VB rep} (p : GraphPresentation.Path (graph rep r) z w)
+    (hzw : z≠w) (hz : z=Sum.inl x ∨ z=Sum.inr y) :
+    p.eval (ConcreteGroup.letter rep r ∘ label rep)≠1 := by
+  intro hp
+  obtain ⟨n,a,hr⟩ := ConcreteGroup.reduced_picture r p hzw hp
+  exact excluded a hzw hr hz hL hd hsample (hsep z w n a hzw hr hz) havoid
+
+end TorsionFreeZeroDivisors.SampleGraph.Picture
+
+namespace TorsionFreeZeroDivisors.BoundaryRefinement
+
+section
+open scoped Classical
+variable {I : Type} {O : I→Type} [∀i,Fintype (O i)]
+/-- Performing literal vertex cuts in one boundary fiber performs the same
+cuts in the whole occurrence set, leaving every other fiber unchanged. -/
+lemma fiber {i : I} {σ τ : Equiv.Perm (O i)} (h : Cuts σ τ)
+    (ρ : ∀j,Equiv.Perm (O j)) :
+    Cuts (Equiv.sigmaCongrRight (Function.update ρ i σ))
+      (Equiv.sigmaCongrRight (Function.update ρ i τ)) := by
+  induction h with
+  | refl=>exact .refl _
+  | step σ p q hn hc=>
+    have he : Equiv.sigmaCongrRight (Function.update ρ i (Equiv.swap p q*σ))=
+        Equiv.swap (Sigma.mk i p) (Sigma.mk i q)*
+          Equiv.sigmaCongrRight (Function.update ρ i σ) := by
+      apply Equiv.ext
+      rintro ⟨j,x⟩
+      by_cases hj : j=i
+      · subst j
+        simp only [Equiv.sigmaCongrRight_apply,Function.update_self,Equiv.Perm.mul_apply]
+        by_cases hp : σ x=p
+        · rw [hp];simp
+        · by_cases hq : σ x=q
+          · rw [hq];simp
+          · simp [Equiv.swap_apply_def,hp,hq]
+      · have h₁ : (⟨j,ρ j x⟩ : Sigma O)≠⟨i,p⟩ := fun he=>hj (congrArg Sigma.fst he)
+        have h₂ : (⟨j,ρ j x⟩ : Sigma O)≠⟨i,q⟩ := fun he=>hj (congrArg Sigma.fst he)
+        simp only [Equiv.sigmaCongrRight_apply,Function.update_of_ne hj,
+          Equiv.Perm.mul_apply,Equiv.swap_apply_of_ne_of_ne h₁ h₂]
+    rw [he]
+    have hh := Cuts.step (Equiv.sigmaCongrRight (Function.update ρ i σ))
+      (Sigma.mk i p) (Sigma.mk i q)
+      (fun he=>hn (eq_of_heq (Sigma.mk.inj_iff.mp he).2))
+      (mapped_sameCycle (Sigma.mk i) σ (Equiv.sigmaCongrRight (Function.update ρ i σ))
+        (fun x=>by simp) hc)
+    convert hh using 1
+    apply Equiv.ext
+    intro x
+    simp only [Equiv.Perm.mul_apply,Equiv.swap_apply_def]
+    split_ifs <;> rfl
+  | trans h h' ih ih'=>exact ih.trans ih'
+variable [Fintype I]
+/-- All of a finite family's contiguous boundary refinements may be carried
+out simultaneously, with the matching on the whole occurrence set retained. -/
+lemma sigma {σ τ : ∀i,Equiv.Perm (O i)} (h : ∀i,Cuts (σ i) (τ i)) :
+    Cuts (Equiv.sigmaCongrRight σ) (Equiv.sigmaCongrRight τ) := by
+  let mix (s : Finset I) (i : I) := if i∈s then τ i else σ i
+  have hm : ∀s : Finset I,Cuts (Equiv.sigmaCongrRight σ) (Equiv.sigmaCongrRight (mix s)) := by
+    intro s
+    induction s using Finset.induction_on with
+    | empty=>simpa only [mix,Finset.notMem_empty,ite_false] using (Cuts.refl (Equiv.sigmaCongrRight σ))
+    | @insert i s hi ih=>
+      have h₁ : Function.update (mix s) i (σ i)=mix s := by
+        apply funext
+        intro j
+        by_cases hj : j=i
+        · subst j;simp [mix,hi]
+        · simp [Function.update_of_ne hj]
+      have h₂ : Function.update (mix s) i (τ i)=mix (insert i s) := by
+        apply funext
+        intro j
+        by_cases hj : j=i
+        · subst j;simp [mix]
+        · simp [mix,hj]
+      have hh := fiber (h i) (mix s)
+      rw [h₁,h₂] at hh
+      exact ih.trans hh
+  simpa only [mix,Finset.mem_univ,ite_true] using hm Finset.univ
+
+end
+
+open scoped Classical BigOperators
+lemma finCongr_rotate {n m : ℕ} (h : n=m) :
+    (finCongr h).permCongr (finRotate n)=finRotate m := by
+  subst m
+  rfl
+lemma sigmaCongrLeft_rotation {I J : Type} {O : J→Type} (e : I≃J)
+    (σ : ∀j,Equiv.Perm (O j)) :
+    (e.sigmaCongrLeft).permCongr (Equiv.sigmaCongrRight fun i=>σ (e i))=
+      Equiv.sigmaCongrRight σ := by
+  apply Equiv.ext
+  intro x
+  obtain ⟨⟨i,j⟩,rfl⟩ := e.sigmaCongrLeft.surjective x
+  simp only [Equiv.permCongr_apply,Equiv.symm_apply_apply]
+  rfl
+lemma sumSigma_rotation {I J : Type} {O : I⊕J→Type}
+    (σ : ∀j,Equiv.Perm (O j)) :
+    (Equiv.sumSigmaDistrib O).permCongr (Equiv.sigmaCongrRight σ)=
+      Equiv.sumCongr (Equiv.sigmaCongrRight fun i=>σ (Sum.inl i))
+        (Equiv.sigmaCongrRight fun j=>σ (Sum.inr j)) := by
+  apply Equiv.ext
+  rintro (⟨i,x⟩|⟨j,x⟩) <;> rfl
+lemma uniqueSigma_rotation {I : Type} [Unique I] {O : I→Type}
+    (σ : ∀i,Equiv.Perm (O i)) :
+    (Equiv.uniqueSigma O).permCongr (Equiv.sigmaCongrRight σ)=σ default := by
+  apply Equiv.ext
+  intro x
+  rfl
+/-- The pinned `finSigmaFinEquiv` is the literal consecutive sum indexing;
+cutting exactly at its fiber boundaries preserves the entire matching. -/
+lemma fin_refinement {m : ℕ} (n : Fin m→ℕ) :
+    Cuts (finSigmaFinEquiv.symm.permCongr (finRotate (∑i,n i)))
+      (Equiv.sigmaCongrRight fun i=>finRotate (n i)) := by
+  induction m with
+  | zero=>
+    have he : finSigmaFinEquiv.symm.permCongr (finRotate (∑i,n i))=
+        Equiv.sigmaCongrRight (fun i=>finRotate (n i)) := by
+      apply Equiv.ext
+      rintro ⟨i,j⟩
+      exact i.elim0
+    rw [he]
+    exact .refl _
+  | succ m ih=>
+    let L : Fin m→ℕ := fun i=>n i.castSucc
+    let R : Fin 1→ℕ := fun i=>n (Fin.natAdd m i)
+    let e₁ : ((i : Fin m⊕Fin 1) × Fin (n (finSumFinEquiv i)))≃((i : Fin (m+1)) × Fin (n i)) :=
+      Equiv.sigmaCongrLeft (β:=fun i=>Fin (n i)) (@finSumFinEquiv m 1)
+    let e₂ := Equiv.sumSigmaDistrib (fun i : Fin m⊕Fin 1=>Fin (n (finSumFinEquiv i)))
+    let e₃ : (((i : Fin m) × Fin (L i))⊕((i : Fin 1) × Fin (R i)))≃
+      (Fin (∑i,L i)⊕Fin (n (Fin.last m))) :=
+      Equiv.sumCongr finSigmaFinEquiv (Equiv.uniqueSigma _)
+    let e : (((i : Fin m) × Fin (L i))⊕((i : Fin 1) × Fin (R i)))≃
+      ((i : Fin (m+1)) × Fin (n i)) := e₂.symm.trans e₁
+    have hh := conjugate (BlockBoundary.fin_cut (∑i,L i) (n (Fin.last m))) e₃.symm
+    have he₁ : e₃.symm.permCongr
+        (finSumFinEquiv.symm.permCongr (finRotate ((∑i,L i)+n (Fin.last m))))=
+        e.symm.permCongr (finSigmaFinEquiv.symm.permCongr (finRotate (∑i,n i))) := by
+      have hf : (finSigmaFinEquiv : ((i : Fin (m+1)) × Fin (n i))≃Fin (∑i,n i))=
+          e.symm.trans (e₃.trans (finSumFinEquiv.trans (finCongr (Fin.sum_univ_castSucc n).symm))) := rfl
+      rw [hf]
+      have hc := finCongr_rotate (Fin.sum_univ_castSucc n)
+      apply Equiv.ext
+      intro x
+      have hc' := congrArg (fun f=>f (finSumFinEquiv (e₃ x))) hc
+      simp only [Equiv.permCongr_apply] at hc'
+      simp only [Equiv.permCongr_apply,Equiv.trans_apply,Equiv.symm_trans_apply,
+        Equiv.symm_symm,Equiv.symm_apply_apply]
+      congr 2
+      exact hc'.symm
+    have he₂ : e₃.symm.permCongr (Equiv.sumCongr (finRotate (∑i,L i)) (finRotate (n (Fin.last m))))=
+        Equiv.sumCongr (finSigmaFinEquiv.symm.permCongr (finRotate (∑i,L i)))
+          (Equiv.sigmaCongrRight fun i=>finRotate (R i)) := by
+      apply Equiv.ext
+      rintro (x|x)
+      · rfl
+      · rcases x with ⟨i,j⟩
+        have hi : i=default := Subsingleton.elim _ _
+        subst i
+        rfl
+    rw [he₁,he₂] at hh
+    have hl := hh.trans (left (ih L) (Equiv.sigmaCongrRight fun i=>finRotate (R i)))
+    have ht := conjugate hl e
+    have he₃ : e.permCongr (Equiv.sumCongr (Equiv.sigmaCongrRight fun i=>finRotate (L i))
+        (Equiv.sigmaCongrRight fun i=>finRotate (R i)))=
+        Equiv.sigmaCongrRight fun i=>finRotate (n i) := by
+      have hd := sumSigma_rotation (fun i : Fin m⊕Fin 1=>finRotate (n (finSumFinEquiv i)))
+      change e₂.permCongr (Equiv.sigmaCongrRight fun i=>finRotate (n (finSumFinEquiv i)))=
+        Equiv.sumCongr (Equiv.sigmaCongrRight fun i=>finRotate (L i))
+          (Equiv.sigmaCongrRight fun i=>finRotate (R i)) at hd
+      rw [←hd]
+      change e₁.permCongr (e₂.symm.permCongr (e₂.permCongr _))=_
+      rw [←Equiv.permCongr_symm,Equiv.symm_apply_apply]
+      exact sigmaCongrLeft_rotation (O:=fun i=>Fin (n i)) (@finSumFinEquiv m 1) (fun i=>finRotate (n i))
+    simpa only [←Equiv.permCongr_symm,Equiv.apply_symm_apply,he₃] using ht
+
+lemma fin_index_refinement {m h : ℕ} (n : Fin m→ℕ) (hs : (∑i,n i)=h) :
+    Cuts ((finSigmaFinEquiv.trans (finCongr hs)).symm.permCongr (finRotate h))
+      (Equiv.sigmaCongrRight fun i=>finRotate (n i)) := by
+  have hc := finCongr_rotate hs.symm
+  have he : (finSigmaFinEquiv.trans (finCongr hs)).symm.permCongr (finRotate h)=
+      finSigmaFinEquiv.symm.permCongr (finRotate (∑i,n i)) := by
+    change finSigmaFinEquiv.symm.permCongr ((finCongr hs).symm.permCongr (finRotate h))=_
+    rw [show (finCongr hs).symm=finCongr hs.symm from rfl,hc]
+  rw [he]
+  exact fin_refinement n
+end TorsionFreeZeroDivisors.BoundaryRefinement
+namespace TorsionFreeZeroDivisors.BalancedGenus
+open scoped Classical BigOperators
+open BlockAlignment ComparedBlocks WordPositions BoundaryRefinement
+variable {T A : Type} [Fintype T] (w : T→List A) (cap : ℕ) (hc : 0<cap)
+lemma join_refinement : Cuts
+    ((WordPositions.join w cap hc).symm.permCongr (BoundaryRotation.perm fun t=>(w t).length))
+    (BoundaryRotation.perm (BalancedWords.old w cap)) := by
+  let N (t : T) := BalancedPieces.number (w t).length cap
+  let n (t : T) : Fin (N t)→ℕ := BalancedPieces.sizes (w t).length cap
+  let idx (t : T) := ConsecutivePieces.index (w t) (n t) (BalancedPieces.sizes_sum hc)
+  have hh : ∀ t,Cuts ((idx t).symm.permCongr (finRotate (w t).length))
+      (Equiv.sigmaCongrRight fun i=>finRotate (n t i)) :=
+    fun t=>fin_index_refinement (n t) (BalancedPieces.sizes_sum hc)
+  let e : ((t : T) × (i : Fin (N t)) × Fin (n t i))≃Position (BalancedWords.old w cap) :=
+    (Equiv.sigmaAssoc fun t i=>Fin (n t i)).symm.trans (fin _).symm
+  have ht := conjugate (sigma hh) e
+  have he₁ : e.permCongr (Equiv.sigmaCongrRight fun t=>(idx t).symm.permCongr (finRotate (w t).length))=
+      (WordPositions.join w cap hc).symm.permCongr (BoundaryRotation.perm fun t=>(w t).length) := by
+    apply Equiv.ext
+    intro p
+    simp only [e,WordPositions.join,WordPositions.joinFin,BoundaryRotation.perm,
+      Equiv.permCongr_apply,Equiv.trans_apply,Equiv.symm_trans_apply,
+      Equiv.symm_symm]
+    rfl
+  have he₂ : e.permCongr (Equiv.sigmaCongrRight fun t=>Equiv.sigmaCongrRight fun i=>finRotate (n t i))=
+      BoundaryRotation.perm (BalancedWords.old w cap) := by
+    apply Equiv.ext
+    intro p
+    simp only [e,BoundaryRotation.perm,Equiv.permCongr_apply,Equiv.symm_symm]
+    rfl
+  rwa [he₁,he₂] at ht
+lemma position_refinement {T : Type} {l k : T→ℕ} (h : ∀t,l t=k t) :
+    (ComparisonGeometry.position (Equiv.refl T) h).permCongr (BoundaryRotation.perm l)=
+      BoundaryRotation.perm k := by
+  have he : l=k := funext h
+  subst k
+  rfl
+lemma refinement : Cuts (BalancedRotation.perm w cap hc)
+    (BoundaryRotation.perm (BalancedRotation.len w cap hc)) := by
+  let g := ComparisonGeometry.position (Equiv.refl _) (BalancedWords.segment_length w cap hc)
+  have ht := conjugate (join_refinement w cap hc) g.symm
+  have hr := position_refinement (BalancedWords.segment_length w cap hc)
+  change g.permCongr (BoundaryRotation.perm (BalancedRotation.len w cap hc))=
+    BoundaryRotation.perm (BalancedWords.old w cap) at hr
+  rw [←hr,←Equiv.permCongr_symm,Equiv.symm_apply_apply] at ht
+  exact ht
+lemma genusZero (α : Equiv.Perm (Position fun t=>(w t).length))
+    (hi : Function.Involutive α) (hz : MapEuler.GenusZero
+      (BoundaryRotation.perm fun t=>(w t).length) α) :
+    MapEuler.GenusZero (BoundaryRotation.perm (BalancedRotation.len w cap hc))
+      ((BalancedRotation.e w cap hc).symm.permCongr α) :=
+  preserves (refinement w cap hc) _ (PermutationTransport.involutive _ _ hi)
+    (MapConjugation.genusZero (BalancedRotation.e w cap hc).symm _ _ hz)
+
+end TorsionFreeZeroDivisors.BalancedGenus
+namespace TorsionFreeZeroDivisors.ExtendComparisons
+open scoped Classical
+open BlockAlignment ComparedBlocks
+variable {T E : Type} {len more : T→ℕ} (C : Comparisons (E:=E) len)
+  (hle : ∀t,len t ≤ more t)
+/-- Added closure letters are fixed; they introduce no interaction between
+DIFFERENT boundary pieces. This statement does not discard self-loops silently. -/
+lemma rel_iff {p q : T} (hpq : p≠q) :
+    PairingClusters.Rel (fun x : Position more=>x.1) (partner C hle) p q ↔
+      PairingClusters.Rel (fun x : Position len=>x.1) C.pairing.partner p q := by
+  constructor
+  · rintro ⟨x,hx,hy⟩
+    by_cases ho : Old (len:=len) x
+    · refine ⟨project x ho,hx,?_⟩
+      simpa only [partner,dite_eq_left ho,embed] using hy
+    · rw [partner_new C hle x ho] at hy
+      exact False.elim (hpq (hx.symm.trans hy))
+  · rintro ⟨x,hx,hy⟩
+    refine ⟨embed hle x,hx,?_⟩
+    rw [partner_embed]
+    exact hy
+
+end TorsionFreeZeroDivisors.ExtendComparisons
+namespace TorsionFreeZeroDivisors.RecursiveSeparator.Split
+open scoped Classical
+def changeDecidableEq {V : Type} {d d' : DecidableEq V} {R : V→V→Prop} {S : Finset V}
+    (P : @RecursiveSeparator.Split V d R S) : @RecursiveSeparator.Split V d' R S := by
+  cases Subsingleton.elim d d'
+  exact P
+variable {V : Type} [DecidableEq V] {R Q : V→V→Prop} {S : Finset V}
+/-- Loops have no effect on separator closure. -/
+def of_off_diagonal (h : ∀p q,p≠q→(R p q↔Q p q)) (P : RecursiveSeparator.Split R S) :
+    RecursiveSeparator.Split Q S where
+  remove := P.remove
+  parts := P.parts
+  remove_subset := P.remove_subset
+  cover := P.cover
+  disjoint := P.disjoint
+  closed := by
+    intro b hb x hx y hy hq
+    by_cases he : x=y
+    · simpa only [←he] using hx
+    · exact P.closed b hb x hx y hy ((h x y he).mpr hq)
+  size := P.size
+  cost := P.cost
+
+end TorsionFreeZeroDivisors.RecursiveSeparator.Split
+namespace TorsionFreeZeroDivisors.SampleGraph.FullPairing
+open scoped Classical
+open BlockAlignment ComparedBlocks GirthAsymptotics ActualPatternEvent TypedGraphs
+variable {rep : ℕ} {r : Match rep} {x : VA rep} {y : VB rep}
+  {s : PathSystem rep r x y} (a : FullPairing s) (cap : ℕ) (hc : 0<cap)
+  (hL : 1≤L (size rep)) (hd : GraphSample.Diameters rep r)
+lemma closed_rel {p q : ClosedWords.Piece s cap} (hpq : p≠q) :
+    PairingClusters.Rel (fun z : Position (fun t=>((a.closed cap hc hL hd).paths t).length)=>z.1)
+      (a.closed cap hc hL hd).comparisons.pairing.partner p q ↔
+    PairingClusters.Rel (fun z : Position (BalancedRotation.len s.paths cap hc)=>z.1)
+      (a.α cap hc) p q := by
+  exact ExtendComparisons.rel_iff (a.comparisons cap hc)
+    (ClosedWords.grow s cap hc hL hd) hpq
+
+end TorsionFreeZeroDivisors.SampleGraph.FullPairing
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/GroupRing/ConcreteModel.lean b/lean/OAI/Algebra/GroupRing/ConcreteModel.lean
new file mode 100644
index 0000000000000000000000000000000000000000..5549e51df5e2b661ad097cc6f43f9ac50c83dfe9
--- /dev/null
+++ b/lean/OAI/Algebra/GroupRing/ConcreteModel.lean
@@ -0,0 +1,53 @@
+import Mathlib
+import OAI.Algebra.GroupRing.SplitModel
+import OAI.Algebra.GroupRing.ConcreteTorsion
+
+namespace OAI
+
+noncomputable section
+
+namespace TorsionFreeZeroDivisors
+lemma HasFiniteTwoDimensionalClassifyingSpace.of_equiv {G H : Type} [Group G] [Group H]
+    (e : G ≃* H) (h : HasFiniteTwoDimensionalClassifyingSpace H) :
+    HasFiniteTwoDimensionalClassifyingSpace G := by
+  rcases h with ⟨X,topX,hT,hP,cw,hf,hh,h2,x,⟨k⟩,E,topE,hE,p,hp,hps⟩
+  exact ⟨X,topX,hT,hP,cw,hf,hh,h2,x,⟨e.trans k⟩,E,topE,hE,p,hp,hps⟩
+end TorsionFreeZeroDivisors
+namespace TorsionFreeZeroDivisors.ConcreteModel
+open scoped Classical
+open SampleGraph
+variable (rep : ℕ) (r : ActualPatternEvent.Match rep)
+  (x : VA rep) (y : VB rep)
+  (hL : 2≤GirthAsymptotics.L (TypedGraphs.size rep)) (hd : GraphSample.Diameters rep r)
+  (hsample : r∈ActualPatternEvent.samples rep)
+  (havoid : IsEmpty (BoundedSystem (PlanarParameters.C PathSystem.ε ClosedWords.D)
+    (PlanarParameters.K PathSystem.ε ClosedWords.D) (PlanarParameters.sides PathSystem.ε ClosedWords.D) rep r x y))
+include hL hd hsample havoid in
+/-- The finite exact two-dimensional model of the actual sampled graph group.
+The cover contraction is built by absorbing physical disk-track obstructions
+through the proved integral cell-boundary splitting. -/
+theorem has_model : HasFiniteTwoDimensionalClassifyingSpace (ConcreteGroup.G rep r) := by
+  have hex {O : Type} [Fintype O] [Nonempty O]
+      (a : SphericalPicture.Data (O:=O) (graph rep r) (ConcreteTorsion.signedLabels rep) WordPairing.inverseLetter) : ¬a.Reduced := by
+    intro ha
+    exact SpherePicture.excluded (ConcreteTorsion.unsigned rep r a) ha hL hd hsample havoid
+  obtain ⟨t,ht⟩ := Finset.card_pos.mp (show 0<(Types.outgoingA x).card by
+    have h := (Types.degreeA_bounds x).1
+    omega)
+  let : Nonempty (GraphConePresentation.Edge (graph rep r)) :=
+    ⟨GraphConePresentation.edge (graph rep r) (Sum.inl ⟨(x,t),ht⟩)⟩
+  have hm := RelationModel.has_model
+    (ConeArea.words (graph rep r) (ConcreteGroup.routes rep r) (ConcreteTorsion.signedLabels rep))
+    (ConeTorsion.total_zero (graph rep r) (ConcreteGroup.routes rep r) (ConcreteTorsion.signedLabels rep)
+      (ConcreteTorsion.signedLabels_reverse rep r) hex)
+  unfold RelationArea.G at hm
+  rw [ConeTorsion.relations_eq _ _ _ (ConcreteTorsion.signedLabels_reverse rep r)] at hm
+  rw [ConcreteTorsion.letters_eq] at hm
+  exact HasFiniteTwoDimensionalClassifyingSpace.of_equiv
+    (GraphConePresentation.equivalence (graph rep r) (ConcreteGroup.labels rep) (ConcreteGroup.routes rep r)
+      (ConcreteGroup.labels_reverse rep r) (GraphConePresentation.canonical_base _)) hm
+end TorsionFreeZeroDivisors.ConcreteModel
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/GroupRing/ConcreteTorsion.lean b/lean/OAI/Algebra/GroupRing/ConcreteTorsion.lean
new file mode 100644
index 0000000000000000000000000000000000000000..30063e6c92c1aa0e172d6a32e7b997dffd2cf676
--- /dev/null
+++ b/lean/OAI/Algebra/GroupRing/ConcreteTorsion.lean
@@ -0,0 +1,73 @@
+import Mathlib
+import OAI.Algebra.GroupRing.TypedComponent
+import OAI.Algebra.GroupRing.ConeTorsion
+
+namespace OAI
+
+noncomputable section
+
+namespace TorsionFreeZeroDivisors.ConcreteTorsion
+open scoped Classical
+open SampleGraph
+variable (rep : ℕ) (r : ActualPatternEvent.Match rep)
+def signedLabels : DA rep⊕DB rep→Types.Generator×Bool :=
+  Types.signedLetter.symm ∘ label rep
+lemma signedLabels_reverse (d : DA rep⊕DB rep) :
+    signedLabels rep ((graph rep r).reverse d)=WordPairing.inverseLetter (signedLabels rep d) := by
+  simp only [signedLabels,Function.comp_apply,label_reverse,Types.inverse,Equiv.symm_apply_apply]
+  rfl
+lemma freeLetter_eq (t : Types.Letter) :
+    ConeSigned.freeLetter (Types.signedLetter.symm t)=ConcreteGroup.freeLetter t := by
+  obtain ⟨⟨g,b⟩,rfl⟩ := Types.signedLetter.surjective t
+  cases b <;> simp only [ConeSigned.freeLetter,ConcreteGroup.freeLetter,Equiv.symm_apply_apply,Bool.false_eq_true,ite_false,ite_true] <;> rfl
+lemma letters_eq : ConeSigned.freeLetter ∘ signedLabels rep=ConcreteGroup.labels rep := by
+  funext d
+  exact freeLetter_eq _
+def unsigned {O : Type} [Fintype O]
+    (a : SphericalPicture.Data (O:=O) (graph rep r) (signedLabels rep) WordPairing.inverseLetter) :
+    SphericalPicture.Data (O:=O) (graph rep r) (label rep) Types.inverse where
+  rotation := a.rotation
+  partner := a.partner
+  involutive := a.involutive
+  fixed_free := a.fixed_free
+  dart := a.dart
+  consistent := a.consistent
+  compatible i := by
+    have h := congrArg Types.signedLetter (a.compatible i)
+    simpa only [signedLabels,Function.comp_apply,Equiv.apply_symm_apply,WordPairing.inverseLetter,Types.inverse] using h
+  genusZero := a.genusZero
+variable (x : VA rep) (y : VB rep)
+  (hL : 2≤GirthAsymptotics.L (TypedGraphs.size rep)) (hd : GraphSample.Diameters rep r)
+  (hsample : r∈ActualPatternEvent.samples rep)
+  (havoid : IsEmpty (BoundedSystem (PlanarParameters.C PathSystem.ε ClosedWords.D)
+    (PlanarParameters.K PathSystem.ε ClosedWords.D) (PlanarParameters.sides PathSystem.ε ClosedWords.D) rep r x y))
+include hL hd hsample havoid in
+theorem torsion_free : ∀ (g : ConcreteGroup.G rep r) (n : ℕ), 0 < n → g ^ n = 1 → g = 1 := by
+  have hex {O : Type} [Fintype O] [Nonempty O]
+      (a : SphericalPicture.Data (O:=O) (graph rep r) (signedLabels rep) WordPairing.inverseLetter) : ¬a.Reduced := by
+    intro ha
+    exact SpherePicture.excluded (unsigned rep r a) ha hL hd hsample havoid
+  have h := ConeTorsion.graph_torsion_free (graph rep r) (ConcreteGroup.routes rep r)
+    (signedLabels rep) (signedLabels_reverse rep r) (GraphConePresentation.canonical_base _) hex
+  rw [letters_eq] at h
+  exact h
+end TorsionFreeZeroDivisors.ConcreteTorsion
+
+namespace TorsionFreeZeroDivisors
+/-- The exact group's ordinary torsion-freeness and both nonzero zero-divisor
+factors, proved without assuming a resolution or topological asphericity. The
+finite classifying-space clause remains separate and is not asserted here. -/
+theorem torsion_free_finitely_presented_zero_divisors :
+    ∃ (G : Type) (inst : Group G), letI : Group G := inst
+      Group.IsFinitelyPresented G ∧
+      (∀ (g : G) (n : ℕ), 0 < n → g ^ n = 1 → g = 1) ∧
+      ∃ α β : MonoidAlgebra (ZMod 2) G, α≠0 ∧ β≠0 ∧ α*β=0 := by
+  obtain ⟨rep,r,x,y,hr,hL,hd,ha,hx,hy,hz⟩ := SampleGraph.exists_nonzero_factors
+  exact ⟨ConcreteGroup.G rep r,inferInstance,inferInstance,
+    ConcreteTorsion.torsion_free rep r x y hL hd hr ha,
+    ConcreteFactors.alpha rep r x,ConcreteFactors.beta rep r y,hx,hy,hz⟩
+end TorsionFreeZeroDivisors
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/GroupRing/ConeArea.lean b/lean/OAI/Algebra/GroupRing/ConeArea.lean
new file mode 100644
index 0000000000000000000000000000000000000000..e3533715d24f5da9a438838259617b606228c9af
--- /dev/null
+++ b/lean/OAI/Algebra/GroupRing/ConeArea.lean
@@ -0,0 +1,156 @@
+import Mathlib
+import OAI.Algebra.GroupRing.FramedLoopIdentities
+import OAI.Algebra.GroupRing.ConeSigned
+
+namespace OAI
+
+
+
+section
+namespace TorsionFreeZeroDivisors.ConeArea
+open scoped Classical BigOperators
+open PortSubdivision GraphPresentation GraphConePresentation ConeSigned WordCursor
+noncomputable section
+variable {V D S : Type} (Γ : PortGraph V D) (R : Routes Γ) (label : D→S×Bool)
+  (hl : ∀d,label (Γ.reverse d)=WordPairing.inverseLetter (label d))
+local notation "letters" => freeLetter ∘ label
+local notation "G" => GraphConePresentation.Group Γ letters R
+local notation "v" => ConeSigned.eval Γ R label ∘ ConeSigned.labels Γ R label
+local notation "c" => ConeChains.coneCharge Γ R label freeLetter
+include hl in
+lemma letters_reverse (d : D) : letters (Γ.reverse d)=(letters d)⁻¹ := by
+  simp only [Function.comp_apply,hl,freeLetter_inverse]
+lemma path_value {a b : V} (p : Path (ConePicture.graph Γ R) a b) :
+    value v p.darts=PresentedGroup.mk _ (p.eval (ConePicture.wordLabel Γ R letters)) := by
+  induction p with
+  | nil=>simp [Path.darts_nil]
+  | cons d p ih=>
+    rw [Path.darts_cons,value_cons,ih,Path.eval_cons,map_mul]
+    congr 1
+    exact congrArg (PresentedGroup.mk _) (wordLabel_eq Γ R label d)
+lemma root_value (a : V) : value v (ConePicture.rootPath Γ R a).darts=radialValue Γ letters R a := by
+  rw [path_value,ConePicture.rootPath_eval]
+  rfl
+lemma root_charge (g : G) (a : V) :
+    PathCharges.charge v c g (ConePicture.rootPath Γ R a).darts=0 := by
+  by_cases ha : a=R.base a
+  · simp only [ConePicture.rootPath,dite_eq_left ha,Path.darts_cast,Path.darts_nil,PathCharges.charge_nil]
+  · simp only [ConePicture.rootPath,dite_eq_right ha,Path.darts_cast,Path.single,Path.darts_cons,
+      Path.darts_nil,PathCharges.charge_cons,PathCharges.charge_nil,ConeChains.coneCharge,add_zero]
+include hl in
+lemma eval_reverse (d : ConePicture.Dart Γ R) :
+    v ((ConePicture.graph Γ R).reverse d)=(v d)⁻¹ := by
+  dsimp only [Function.comp_apply]
+  rw [ConeSigned.labels_reverse Γ R label hl,ConeSigned.eval_inverse]
+include hl in
+lemma charge_reverse (g : G) (d : ConePicture.Dart Γ R) :
+    c (g*v d) ((ConePicture.graph Γ R).reverse d)=-c g d := by
+  change c (g*ConeSigned.eval Γ R label (pack Γ R (ConePicture.labels Γ R label d))) _=_
+  rw [eval_pack]
+  exact ConeChains.coneCharge_reverse Γ R label WordPairing.inverseLetter freeLetter hl freeLetter_inverse g d
+include hl in
+lemma reverse_root_charge (g : G) (a : V) :
+    PathCharges.charge v c g (ConePicture.rootPath Γ R a).reverse.darts=0 := by
+  let w := (ConePicture.rootPath Γ R a).darts
+  have h := PathCharges.charge_reverse v c (ConePicture.graph Γ R).reverse
+    (eval_reverse Γ R label hl) (charge_reverse Γ R label hl) (g*(value v w)⁻¹) w
+  rw [inv_mul_cancel_right,root_charge,neg_zero] at h
+  simpa only [Path.darts_reverse] using h
+include hl in
+lemma triangle_charge (g : G) (d : D) :
+    PathCharges.charge v c g (ConePicture.trianglePath Γ R d).darts=
+      ConeChains.charge Γ R label freeLetter (g*radialValue Γ letters R (Γ.origin d)) d := by
+  simp only [ConePicture.trianglePath,Path.darts_cast,Path.darts_append,PathCharges.charge_append]
+  rw [root_charge,zero_add,root_value]
+  rw [reverse_root_charge Γ R label hl,add_zero]
+  simp only [Path.single,Path.darts_cons,Path.darts_nil,PathCharges.charge_cons,
+    PathCharges.charge_nil,add_zero,ConeChains.coneCharge]
+def loops (e : Edge Γ) : InitialPicture.Loop (ConePicture.graph Γ R) :=
+  ⟨R.base (Γ.origin (representative Γ e)),ConePicture.trianglePath Γ R (representative Γ e)⟩
+def words : Edge Γ→List (Generator (S:=S) Γ R × Bool) :=
+  InitialPicture.relWords (ConePicture.graph Γ R) (ConeSigned.labels Γ R label) (loops Γ R)
+include hl in
+lemma words_mk (e : Edge Γ) : FreeGroup.mk (words Γ R label e)=attachment Γ letters R e := by
+  rw [words,InitialPicture.relWords,Path.letters_mk]
+  have hh : (fun d=>FreeGroup.mk [ConeSigned.labels Γ R label d])=ConePicture.wordLabel Γ R letters := by
+    funext d;exact wordLabel_eq Γ R label d
+  rw [hh]
+  exact ConePicture.trianglePath_eval Γ R letters (letters_reverse Γ label hl) (representative Γ e)
+include hl in
+lemma loop_value (e : Edge Γ) : value v (loops Γ R e).2.darts=1 := by
+  rw [path_value]
+  change PresentedGroup.mk _ ((ConePicture.trianglePath Γ R (representative Γ e)).eval _)=1
+  rw [ConePicture.trianglePath_eval Γ R letters (letters_reverse Γ label hl)]
+  exact triangle_trivial Γ letters R (letters_reverse Γ label hl) _
+include hl in
+lemma loop_charge (g : G) (e : Edge Γ) :
+    PathCharges.charge v c g (loops Γ R e).2.darts=Finsupp.single (g,e) (1:ℤ) := by
+  rw [loops,triangle_charge Γ R label hl,ConeChains.charge]
+  have he : edge Γ (representative Γ e)=e := ConeChains.representative_edge Γ e
+  rw [he,ite_eq_left rfl]
+  congr 1
+  apply Prod.ext
+  · exact mul_inv_cancel_right _ _
+  · exact he
+include hl in
+lemma signed_charge (g : G) (t : AlgebraicPictures.Term (A:=Generator (S:=S) Γ R) (I:=Edge Γ)) :
+    PathCharges.charge v c g (InitialPicture.signedLoop (ConePicture.graph Γ R) (loops Γ R) t).2.darts=
+      if t.positive then Finsupp.single (g,t.index) (1:ℤ) else -Finsupp.single (g,t.index) (1:ℤ) := by
+  obtain ⟨i,b,co⟩ := t
+  cases b
+  · change PathCharges.charge v c g (loops Γ R i).2.reverse.darts= -Finsupp.single (g,i) (1:ℤ)
+    rw [Path.darts_reverse]
+    have h := PathCharges.charge_reverse v c (ConePicture.graph Γ R).reverse
+      (eval_reverse Γ R label hl) (charge_reverse Γ R label hl) g (loops Γ R i).2.darts
+    rw [loop_value Γ R label hl,mul_one,loop_charge Γ R label hl] at h
+    exact h
+  · exact loop_charge Γ R label hl g i
+include hl in
+lemma term_value (t : AlgebraicPictures.Term (A:=Generator (S:=S) Γ R) (I:=Edge Γ)) :
+    value (ConeSigned.eval Γ R label) (t.word (words Γ R label))=1 := by
+  rw [AlgebraicPictures.Term.word,value_append,value_append]
+  have hr : value (ConeSigned.eval Γ R label) (words Γ R label t.index)=1 := by
+    rw [eval_value,words_mk Γ R label hl]
+    exact PresentedGroup.one_of_mem ⟨_,rfl⟩
+  have hi (w) := PathCharges.value_reverse (ConeSigned.eval Γ R label)
+    WordPairing.inverseLetter (ConeSigned.eval_inverse Γ R label) w
+  have hh (w : List (Generator (S:=S) Γ R × Bool)) : FreeGroup.invRev w=w.reverse.map WordPairing.inverseLetter := by
+    simp only [FreeGroup.invRev,List.map_reverse]
+    congr 1
+  rw [hh,hi]
+  cases hb : t.positive <;>
+    simp only [AlgebraicPictures.Term.core,hb,Bool.false_eq_true,ite_false,ite_true,hh,hi,hr,inv_one,mul_one,mul_inv_cancel]
+def termArea (t : AlgebraicPictures.Term (A:=Generator (S:=S) Γ R) (I:=Edge Γ)) :
+    ConeChains.TwoChain Γ R label freeLetter :=
+  if t.positive then Finsupp.single (PresentedGroup.mk _ (FreeGroup.mk t.connector),t.index) 1
+  else -Finsupp.single (PresentedGroup.mk _ (FreeGroup.mk t.connector),t.index) 1
+include hl in
+lemma termArea_eq (t : AlgebraicPictures.Term (A:=Generator (S:=S) Γ R) (I:=Edge Γ)) :
+    termArea Γ R label t=FramedLoopIdentities.area (ConePicture.graph Γ R)
+      (ConeSigned.labels Γ R label) (loops Γ R) (ConeSigned.eval Γ R label) c t := by
+  rw [FramedLoopIdentities.area,signed_charge Γ R label hl,eval_value]
+  rfl
+include hl in
+/-- Every actual free identity of the physical triangular presentation has zero
+integral translated physical-cell area. No cellular realization is presumed. -/
+theorem identity_zero
+    (hex : ∀{P : Type}[Fintype P][Nonempty P]
+      (a : SphericalPicture.Data (O:=P) Γ label WordPairing.inverseLetter),¬a.Reduced)
+    (ts : List (AlgebraicPictures.Term (A:=Generator (S:=S) Γ R) (I:=Edge Γ)))
+    (he : FreeGroup.mk (AlgebraicPictures.word (words Γ R label) ts)=1) :
+    (ts.map (termArea Γ R label)).sum=0 := by
+  have hh := FramedLoopIdentities.identity_area_zero (ConePicture.graph Γ R)
+    (ConeSigned.labels Γ R label) (ConeSigned.labels_reverse Γ R label hl) (loops Γ R)
+    (ConeSigned.eval Γ R label) (ConeSigned.eval_inverse Γ R label) c
+    (charge_reverse Γ R label hl) ts he (fun t _=>term_value Γ R label hl t)
+    (fun a=>ConeSigned.reduces_to_empty Γ R label hl hex a)
+  have heq : termArea Γ R label=FramedLoopIdentities.area (ConePicture.graph Γ R)
+      (ConeSigned.labels Γ R label) (loops Γ R) (ConeSigned.eval Γ R label) c := by
+    funext t;exact termArea_eq Γ R label hl t
+  rw [heq];exact hh
+end
+end TorsionFreeZeroDivisors.ConeArea
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/GroupRing/ConeBoundaryPaths.lean b/lean/OAI/Algebra/GroupRing/ConeBoundaryPaths.lean
new file mode 100644
index 0000000000000000000000000000000000000000..e01c912c052a31173cf38bcee5207e25d3a189d9
--- /dev/null
+++ b/lean/OAI/Algebra/GroupRing/ConeBoundaryPaths.lean
@@ -0,0 +1,68 @@
+import Mathlib
+import OAI.Algebra.GroupRing.ConePicture
+import OAI.Algebra.GroupRing.GraphConePresentation
+
+namespace OAI
+
+noncomputable section
+
+namespace TorsionFreeZeroDivisors.ConePicture
+open PortSubdivision GraphPresentation
+open scoped Classical
+variable {V D S : Type} (Γ : PortGraph V D) (R : Routes Γ)
+  (letters : D→FreeGroup S)
+def wordLabel : Dart Γ R→FreeGroup (GraphConePresentation.Generator (S:=S) Γ R)
+  | .inl d => GraphConePresentation.old Γ R (letters d)
+  | .inr (v,b) => if b then FreeGroup.of (Sum.inr v) else (FreeGroup.of (Sum.inr v))⁻¹
+lemma wordLabel_reverse (hl : ∀d,letters (Γ.reverse d)=(letters d)⁻¹) (d : Dart Γ R) :
+    wordLabel Γ R letters ((graph Γ R).reverse d)=(wordLabel Γ R letters d)⁻¹ := by
+  rcases d with d|⟨v,b⟩
+  · exact (congrArg (GraphConePresentation.old Γ R) (hl d)).trans (map_inv _ _)
+  · cases b <;> simp [wordLabel,graph,reverse]
+def rootPath (v : V) : Path (graph Γ R) (R.base v) v :=
+  if h : v=R.base v then (Path.nil (Γ:=graph Γ R) (R.base v)).cast rfl h.symm
+  else (Path.single (Γ:=graph Γ R) (Sum.inr (⟨v,h⟩,true))).cast
+    (show (graph Γ R).origin (Sum.inr (⟨v,h⟩,true))=R.base v from rfl)
+    (show (graph Γ R).origin ((graph Γ R).reverse (Sum.inr (⟨v,h⟩,true)))=v from rfl)
+lemma rootPath_eval (v : V) :
+    (rootPath Γ R v).eval (wordLabel Γ R letters)=GraphConePresentation.radial Γ R v := by
+  by_cases hv : v=R.base v
+  · simp only [rootPath,dite_eq_left hv,Path.eval_cast,Path.eval_nil,GraphConePresentation.radial]
+  · simp only [rootPath,dite_eq_right hv,Path.eval_cast,Path.eval_single,wordLabel,ite_true,
+      GraphConePresentation.radial]
+/-- The actual triangular closed boundary, with a root radial omitted exactly
+when it is collapsed in the finite CW model. No directed-edge duplication. -/
+def trianglePath (d : D) : Path (graph Γ R) (R.base (Γ.origin d)) (R.base (Γ.origin d)) :=
+  ((rootPath Γ R (Γ.origin d)).append
+    (((Path.single (Γ:=graph Γ R) (Sum.inl d)).cast
+      (show (graph Γ R).origin (Sum.inl d)=Γ.origin d from rfl)
+      (show (graph Γ R).origin ((graph Γ R).reverse (Sum.inl d))=Γ.origin (Γ.reverse d) from rfl)).append ((rootPath Γ R (Γ.origin (Γ.reverse d))).reverse))).cast
+      rfl (R.same d).symm
+lemma trianglePath_eval (hl : ∀d,letters (Γ.reverse d)=(letters d)⁻¹) (d : D) :
+    (trianglePath Γ R d).eval (wordLabel Γ R letters)=GraphConePresentation.triangle Γ letters R d := by
+  rw [trianglePath,Path.eval_cast,Path.eval_append (Γ:=graph Γ R),
+    Path.eval_append (Γ:=graph Γ R),Path.eval_cast,Path.eval_single (Γ:=graph Γ R),
+    Path.eval_reverse _ (wordLabel_reverse Γ R letters hl),rootPath_eval,rootPath_eval]
+  exact (mul_assoc _ _ _).symm
+end TorsionFreeZeroDivisors.ConePicture
+namespace TorsionFreeZeroDivisors.SampleGraph.ConeSpherePicture
+open scoped Classical
+variable {rep : ℕ} {r : ActualPatternEvent.Match rep} {x : VA rep} {y : VB rep}
+theorem reduces_to_empty
+    (hL : 2≤GirthAsymptotics.L (TypedGraphs.size rep))
+    (hd : GraphSample.Diameters rep r) (hsample : r∈ActualPatternEvent.samples rep)
+    (havoid : IsEmpty (BoundedSystem (PlanarParameters.C PathSystem.ε ClosedWords.D)
+      (PlanarParameters.K PathSystem.ε ClosedWords.D) (PlanarParameters.sides PathSystem.ε ClosedWords.D) rep r x y))
+    {O : Type} [Fintype O]
+    (a : SphericalPicture.Data (O:=O) (ConePicture.graph (graph rep r) (ConcreteGroup.routes rep r))
+      (ConePicture.labels (graph rep r) (ConcreteGroup.routes rep r) (label rep))
+      (ConePicture.inverse (graph rep r) (ConcreteGroup.routes rep r) Types.inverse)) :
+    SphericalPicture.ReducesToEmpty _ _ _ a := by
+  apply ConePicture.reduces_to_empty a Types.inverse_inverse (fun d=>label_reverse rep r d)
+  intro P _ _ b hb
+  exact SpherePicture.excluded b hb hL hd hsample havoid
+end TorsionFreeZeroDivisors.SampleGraph.ConeSpherePicture
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/GroupRing/ConeCells.lean b/lean/OAI/Algebra/GroupRing/ConeCells.lean
new file mode 100644
index 0000000000000000000000000000000000000000..31456b6e2577aa161ed2a018e88ac8ca97de8538
--- /dev/null
+++ b/lean/OAI/Algebra/GroupRing/ConeCells.lean
@@ -0,0 +1,261 @@
+import Mathlib
+import OAI.Algebra.GroupRing.GeneralPosition
+
+namespace OAI
+
+
+
+section
+namespace TorsionFreeZeroDivisors.GraphConeCW
+open Set Metric Topology GroupRingTopology GroupRingTopology.Attachment
+open GroupRingTopology.Cellular hiding Disk Sphere boundary
+open scoped unitInterval Classical
+noncomputable section
+lemma cons_tail_time {n : ℕ} (d : Disk (n+1)) : diskCons (diskTail d) (diskTime d)=d := by
+  apply Subtype.ext
+  funext i
+  refine Fin.cases ?_ (fun j=>?_) i
+  · simp only [diskCons,diskTime,Fin.cons_zero]
+    ring
+  · rfl
+lemma cylinder_side {Y : Type*} [TopologicalSpace Y] {n : ℕ}
+    (a : C(Sphere n,C(I,Y))) (b : C(Disk n,Y×Y))
+    (h : ∀x,pathEndpoint (a x)=b (boundary n x)) (x : Sphere n) (t : I) :
+    cylinderBoundaryMap a b h ⟨_,cons_mem_sphere_of_boundary x t⟩=a x t := by
+  let z : Sphere (n+1) := ⟨_,cons_mem_sphere_of_boundary x t⟩
+  have hz : z∈cylinderFace n none := by
+    change (diskTail (diskCons (boundary n x) t)).1∈sphere 0 1
+    rw [diskTail_cons]
+    exact x.2
+  rw [cylinderBoundaryMap_face a b h none ⟨z,hz⟩]
+  change a (faceSphere ⟨z,hz⟩) (diskTime (diskCons (boundary n x) t))=a x t
+  rw [diskTime_cons]
+  congr 1
+lemma cylinder_bottom {Y : Type*} [TopologicalSpace Y] {n : ℕ}
+    (a : C(Sphere n,C(I,Y))) (b : C(Disk n,Y×Y))
+    (h : ∀x,pathEndpoint (a x)=b (boundary n x)) (d : Disk n) :
+    cylinderBoundaryMap a b h ⟨_,cons_zero_mem_sphere d⟩=(b d).1 := by
+  let z : Sphere (n+1) := ⟨_,cons_zero_mem_sphere d⟩
+  have hz : z∈cylinderFace n (some false) := by norm_num [z,cylinderFace,diskCons]
+  rw [cylinderBoundaryMap_face a b h (some false) ⟨z,hz⟩]
+  change (b (diskTail (diskCons d 0))).1=_
+  rw [diskTail_cons]
+lemma cylinder_top {Y : Type*} [TopologicalSpace Y] {n : ℕ}
+    (a : C(Sphere n,C(I,Y))) (b : C(Disk n,Y×Y))
+    (h : ∀x,pathEndpoint (a x)=b (boundary n x)) (d : Disk n) :
+    cylinderBoundaryMap a b h ⟨_,cons_one_mem_sphere d⟩=(b d).2 := by
+  let z : Sphere (n+1) := ⟨_,cons_one_mem_sphere d⟩
+  have hz : z∈cylinderFace n (some true) := by norm_num [z,cylinderFace,diskCons]
+  rw [cylinderBoundaryMap_face a b h (some true) ⟨z,hz⟩]
+  change (b (diskTail (diskCons d 1))).2=_
+  rw [diskTail_cons]
+variable {V E : Type*} (src dst : E→V)
+local instance : TopologicalSpace (Option V) := ⊥
+local instance : DiscreteTopology (Option V) := ⟨rfl⟩
+def endpoint : V⊕E → Bool → Option V
+  | .inl v,false => some v
+  | .inl _,true => none
+  | .inr e,false => some (src e)
+  | .inr e,true => some (dst e)
+def oneBoundary (i : V⊕E) : C(Sphere 1,Option V) :=
+  ⟨fun x=>endpoint src dst i (if x=Cayley.minus then false else true),continuous_of_discreteTopology⟩
+abbrev One := Space (oneBoundary src dst)
+def vertex (v : Option V) : One src dst := base _ v
+lemma minus_ne_plus : Cayley.minus≠Cayley.plus := by
+  intro he
+  have := congrArg (fun x : Sphere 1=>x.1 0) he
+  norm_num [Cayley.minus,Cayley.plus] at this
+@[simp] lemma oneBoundary_minus (i : V⊕E) : oneBoundary src dst i Cayley.minus=endpoint src dst i false := by
+  simp [oneBoundary]
+@[simp] lemma oneBoundary_plus (i : V⊕E) : oneBoundary src dst i Cayley.plus=endpoint src dst i true := by
+  simp [oneBoundary,Ne.symm minus_ne_plus]
+def radial (v : V) : C(I,One src dst) := (cell _ (.inl v)).comp ⟨Cayley.edgeParam,Cayley.continuous_edgeParam⟩
+def outer (e : E) : C(Disk 1,One src dst) := cell _ (.inr e)
+@[simp] lemma radial_zero (v : V) : radial src dst v 0=vertex src dst (some v) := by
+  change cell _ _ (Cayley.edgeParam 0)=_
+  rw [Cayley.edgeParam_zero,cell_boundary,oneBoundary_minus]
+  rfl
+@[simp] lemma radial_one (v : V) : radial src dst v 1=vertex src dst none := by
+  change cell _ _ (Cayley.edgeParam 1)=_
+  rw [Cayley.edgeParam_one,cell_boundary,oneBoundary_plus]
+  rfl
+@[simp] lemma outer_minus (e : E) : outer src dst e (boundary 1 Cayley.minus)=vertex src dst (some (src e)) := by
+  change cell _ _ (boundary 1 Cayley.minus)=_
+  rw [cell_boundary,oneBoundary_minus]
+  rfl
+@[simp] lemma outer_plus (e : E) : outer src dst e (boundary 1 Cayley.plus)=vertex src dst (some (dst e)) := by
+  change cell _ _ (boundary 1 Cayley.plus)=_
+  rw [cell_boundary,oneBoundary_plus]
+  rfl
+def sides (e : E) : C(Sphere 1,C(I,One src dst)) :=
+  ⟨fun x=>radial src dst (if x=Cayley.minus then src e else dst e),continuous_of_discreteTopology⟩
+def ends (e : E) : C(Disk 1,One src dst × One src dst) :=
+  ⟨fun d=>(outer src dst e d,vertex src dst none),(outer src dst e).continuous.prodMk continuous_const⟩
+lemma compatible (e : E) (x : Sphere 1) : pathEndpoint (sides src dst e x)=ends src dst e (boundary 1 x) := by
+  rcases Cayley.sphere_one_eq x with rfl|rfl <;>
+    simp [pathEndpoint,sides,ends,Ne.symm minus_ne_plus]
+def twoBoundary (e : E) : C(Sphere 2,One src dst) := cylinderBoundaryMap (sides src dst e) (ends src dst e) (compatible src dst e)
+abbrev Cone := Space (twoBoundary src dst)
+def inclusion : C(One src dst,Cone src dst) := ⟨base _,continuous_base _⟩
+def apex : Cone src dst := inclusion src dst (vertex src dst none)
+def square (e : E) : C(Disk 2,Cone src dst) := cell _ e
+lemma square_side (e : E) (x : Sphere 1) (t : I) :
+    square src dst e (diskCons (boundary 1 x) t)=inclusion src dst (sides src dst e x t) := by
+  change cell _ e (boundary 2 ⟨_,cons_mem_sphere_of_boundary x t⟩)=_
+  rw [cell_boundary]
+  exact congrArg (inclusion src dst) (cylinder_side _ _ _ x t)
+lemma square_bottom (e : E) (d : Disk 1) :
+    square src dst e (diskCons d 0)=inclusion src dst (outer src dst e d) := by
+  change cell _ e (boundary 2 ⟨_,cons_zero_mem_sphere d⟩)=_
+  rw [cell_boundary]
+  exact congrArg (inclusion src dst) (cylinder_bottom _ _ _ d)
+lemma square_top (e : E) (d : Disk 1) : square src dst e (diskCons d 1)=apex src dst := by
+  change cell _ e (boundary 2 ⟨_,cons_one_mem_sphere d⟩)=_
+  rw [cell_boundary]
+  exact congrArg (inclusion src dst) (cylinder_top _ _ _ d)
+def joinTime (r t : I) : I := ⟨r.1+(1-r.1)*t.1,by
+  constructor
+  · nlinarith [r.2.1,r.2.2,t.2.1,t.2.2]
+  · nlinarith [r.2.1,r.2.2,t.2.1,t.2.2]⟩
+lemma continuous_joinTime : Continuous (fun p : I×I=>joinTime p.1 p.2) := by
+  unfold joinTime
+  fun_prop
+@[simp] lemma joinTime_zero (r : I) : joinTime r 0=r := by ext; simp [joinTime]
+@[simp] lemma joinTime_one (r : I) : joinTime r 1=1 := by ext; simp [joinTime]
+@[simp] lemma zero_joinTime (t : I) : joinTime 0 t=t := by ext; simp [joinTime]
+@[simp] lemma one_joinTime (t : I) : joinTime 1 t=1 := by ext; simp [joinTime]
+def vertexPaths : C(Option V,C(I,Cone src dst)) :=
+  ⟨fun v=>match v with
+    | none => .const _ (apex src dst)
+    | some v => (inclusion src dst).comp (radial src dst v),continuous_of_discreteTopology⟩
+def radialPaths (v : V) : C(Disk 1,C(I,Cone src dst)) :=
+  (⟨fun p : Disk 1×I=>inclusion src dst (radial src dst v (joinTime (Cayley.edgeTime p.1) p.2)),
+    (inclusion src dst).continuous.comp ((radial src dst v).continuous.comp
+      (continuous_joinTime.comp ((Cayley.continuous_edgeTime.comp continuous_fst).prodMk continuous_snd)))⟩ :
+    C(Disk 1×I,Cone src dst)).curry
+def outerPaths (e : E) : C(Disk 1,C(I,Cone src dst)) :=
+  ((square src dst e).comp ⟨fun p : Disk 1×I=>diskCons p.1 p.2,continuous_diskCons⟩).curry
+def edgePaths : V⊕E → C(Disk 1,C(I,Cone src dst)) := Sum.elim (radialPaths src dst) (outerPaths src dst)
+lemma edgePaths_boundary (i : V⊕E) (x : Sphere 1) :
+    edgePaths src dst i (boundary 1 x)=vertexPaths src dst (oneBoundary src dst i x) := by
+  ext t
+  cases i with
+  | inl v =>
+    rcases Cayley.sphere_one_eq x with rfl|rfl
+    · change inclusion src dst (radial src dst v (joinTime (Cayley.edgeTime (boundary 1 Cayley.minus)) t))=_
+      simp [Cayley.edgeTime_minus,vertexPaths,endpoint]
+    · change inclusion src dst (radial src dst v (joinTime (Cayley.edgeTime (boundary 1 Cayley.plus)) t))=_
+      simp [Cayley.edgeTime_plus,vertexPaths,endpoint,apex]
+  | inr e =>
+    change square src dst e (diskCons (boundary 1 x) t)=_
+    rw [square_side]
+    rcases Cayley.sphere_one_eq x with rfl|rfl <;>
+      simp [sides,vertexPaths,endpoint,Ne.symm minus_ne_plus]
+def onePaths : C(One src dst,C(I,Cone src dst)) :=
+  lift _ (vertexPaths src dst) (edgePaths src dst) (edgePaths_boundary src dst)
+@[simp] lemma onePaths_vertex (v : Option V) : onePaths src dst (vertex src dst v)=vertexPaths src dst v := rfl
+@[simp] lemma onePaths_outer (e : E) (d : Disk 1) (t : I) :
+    onePaths src dst (outer src dst e d) t=square src dst e (diskCons d t) := by
+  change onePaths src dst (cell (oneBoundary src dst) (.inr e) d) t=_
+  simp only [onePaths,lift_cell]
+  rfl
+@[simp] lemma onePaths_radial (v : V) (r t : I) :
+    onePaths src dst (radial src dst v r) t=inclusion src dst (radial src dst v (joinTime r t)) := by
+  change onePaths src dst (cell (oneBoundary src dst) (.inl v) (Cayley.edgeParam r)) t=_
+  simp only [onePaths,lift_cell]
+  change inclusion src dst (radial src dst v (joinTime (Cayley.edgeTime (Cayley.edgeParam r)) t))=_
+  rw [Cayley.edgeTime_param]
+def squarePaths (e : E) : C(Disk 2,C(I,Cone src dst)) :=
+  (⟨fun p : Disk 2×I=>square src dst e (diskCons (diskTail p.1) (joinTime (diskTime p.1) p.2)),
+    (square src dst e).continuous.comp (continuous_diskCons.comp
+      ((continuous_diskTail.comp continuous_fst).prodMk (continuous_joinTime.comp
+      ((continuous_diskTime.comp continuous_fst).prodMk continuous_snd))))⟩ : C(Disk 2×I,Cone src dst)).curry
+lemma squarePaths_boundary (e : E) (x : Sphere 2) :
+    squarePaths src dst e (boundary 2 x)=onePaths src dst (twoBoundary src dst e x) := by
+  ext t
+  change square src dst e (diskCons (diskTail (boundary 2 x)) (joinTime (diskTime (boundary 2 x)) t))=_
+  rcases sphere_split x with hz|ho|hs
+  · have ht : diskTime (boundary 2 x)=0 := faceTime_eq_zero x hz
+    rw [ht,zero_joinTime]
+    have hx : twoBoundary src dst e x=outer src dst e (diskTail (boundary 2 x)) := by
+      exact cylinderBoundaryMap_face _ _ _ (some false) ⟨x,hz⟩
+    rw [hx,onePaths_outer]
+  · have ht : diskTime (boundary 2 x)=1 := faceTime_eq_one x ho
+    rw [ht,one_joinTime,square_top]
+    have hx : twoBoundary src dst e x=vertex src dst none := by
+      exact cylinderBoundaryMap_face _ _ _ (some true) ⟨x,ho⟩
+    rw [hx,onePaths_vertex]
+    rfl
+  · let z : Sphere 1 := ⟨(diskTail (boundary 2 x)).1,hs⟩
+    have hx : twoBoundary src dst e x=sides src dst e z (diskTime (boundary 2 x)) :=
+      cylinderBoundaryMap_face _ _ _ none ⟨x,hs⟩
+    rw [hx]
+    change square src dst e (diskCons (boundary 1 z) (joinTime (diskTime (boundary 2 x)) t))=_
+    rw [square_side]
+    change inclusion src dst (radial src dst (if z=Cayley.minus then src e else dst e) _)=
+      onePaths src dst (radial src dst (if z=Cayley.minus then src e else dst e) _) _
+    rw [onePaths_radial]
+def contractionPaths : C(Cone src dst,C(I,Cone src dst)) :=
+  lift _ (onePaths src dst) (squarePaths src dst) (squarePaths_boundary src dst)
+lemma onePaths_zero (z : One src dst) : onePaths src dst z 0=inclusion src dst z := by
+  obtain ⟨q,rfl⟩ := quotient_surjective (oneBoundary src dst) z
+  cases q with
+  | inl v =>
+    change vertexPaths src dst v 0=inclusion src dst (vertex src dst v)
+    cases v <;> simp [vertexPaths,apex]
+  | inr p =>
+    change onePaths src dst (cell (oneBoundary src dst) p.1 p.2) 0=_
+    simp only [onePaths,lift_cell]
+    rcases p with ⟨v|e,d⟩
+    · change inclusion src dst (radial src dst v (joinTime (Cayley.edgeTime d) 0))=_
+      rw [joinTime_zero]
+      change inclusion src dst (cell _ (.inl v) (Cayley.edgeParam (Cayley.edgeTime d)))=_
+      rw [Cayley.edgeParam_time]
+      rfl
+    · exact square_bottom src dst e d
+lemma onePaths_one (z : One src dst) : onePaths src dst z 1=apex src dst := by
+  obtain ⟨q,rfl⟩ := quotient_surjective (oneBoundary src dst) z
+  cases q with
+  | inl v =>
+    change vertexPaths src dst v 1=apex src dst
+    cases v <;> simp [vertexPaths,apex]
+  | inr p =>
+    change onePaths src dst (cell (oneBoundary src dst) p.1 p.2) 1=_
+    simp only [onePaths,lift_cell]
+    rcases p with ⟨v|e,d⟩
+    · change inclusion src dst (radial src dst v (joinTime (Cayley.edgeTime d) 1))=_
+      rw [joinTime_one,radial_one]
+      rfl
+    · exact square_top src dst e d
+def contraction : (ContinuousMap.id (Cone src dst)).Homotopy (.const _ (apex src dst)) where
+  toFun p := contractionPaths src dst p.2 p.1
+  continuous_toFun := (contractionPaths src dst).uncurry.continuous.comp continuous_swap
+  map_zero_left z := by
+    obtain ⟨q,rfl⟩ := quotient_surjective (twoBoundary src dst) z
+    cases q with
+    | inl v => exact onePaths_zero src dst v
+    | inr p =>
+      change contractionPaths src dst (cell (twoBoundary src dst) p.1 p.2) 0=_
+      simp only [contractionPaths,lift_cell]
+      change square src dst p.1 (diskCons (diskTail p.2) (joinTime (diskTime p.2) 0))=_
+      rw [joinTime_zero,cons_tail_time]
+      rfl
+  map_one_left z := by
+    obtain ⟨q,rfl⟩ := quotient_surjective (twoBoundary src dst) z
+    cases q with
+    | inl v => exact onePaths_one src dst v
+    | inr p =>
+      change contractionPaths src dst (cell (twoBoundary src dst) p.1 p.2) 1=_
+      simp only [contractionPaths,lift_cell]
+      change square src dst p.1 (diskCons (diskTail p.2) (joinTime (diskTime p.2) 1))=_
+      rw [joinTime_one,square_top]
+      rfl
+instance contractible : ContractibleSpace (Cone src dst) :=
+  (contractible_iff_id_nullhomotopic _).mpr ⟨apex src dst,⟨contraction src dst⟩⟩
+end
+end TorsionFreeZeroDivisors.GraphConeCW
+
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/GroupRing/ConeChains.lean b/lean/OAI/Algebra/GroupRing/ConeChains.lean
new file mode 100644
index 0000000000000000000000000000000000000000..c3457ec77499a0d0085f4e1b4d03fcfeb16a2369
--- /dev/null
+++ b/lean/OAI/Algebra/GroupRing/ConeChains.lean
@@ -0,0 +1,101 @@
+import Mathlib
+import OAI.Algebra.GroupRing.PictureChains
+import OAI.Algebra.GroupRing.GraphConePresentation
+
+namespace OAI
+
+
+
+section
+namespace TorsionFreeZeroDivisors.ConeChains
+open PortSubdivision GraphPresentation GraphConePresentation
+open scoped Classical BigOperators
+noncomputable section
+variable {V D A S : Type} (Γ : PortGraph V D) (R : Routes Γ)
+  (label : D→A) (inv : A→A) (letters : A→FreeGroup S)
+  (hi : Function.Involutive inv) (hl : ∀d,label (Γ.reverse d)=inv (label d))
+  (hw : ∀a,letters (inv a)=(letters a)⁻¹)
+local notation "G" => GraphConePresentation.Group Γ (letters ∘ label) R
+abbrev Cells := G × Edge Γ
+abbrev TwoChain := Cells Γ R label letters →₀ ℤ
+lemma edge_reverse (d : D) : edge Γ (Γ.reverse d)=edge Γ d :=
+  Quotient.sound (Or.inr rfl)
+lemma representative_edge (e : Edge Γ) : edge Γ (representative Γ e)=e := Quotient.out_eq e
+include hl hw in
+lemma letters_reverse (d : D) : (letters ∘ label) (Γ.reverse d)=((letters ∘ label) d)⁻¹ := by
+  simp only [Function.comp_apply,hl,hw]
+def eval : A ⊕ (ConePicture.Radial Γ R × Bool)→G
+  | .inl a => oldMap Γ (letters ∘ label) R (letters a)
+  | .inr (v,b) => if b then radialValue Γ (letters ∘ label) R v else (radialValue Γ (letters ∘ label) R v)⁻¹
+include hw in
+lemma eval_inverse (a : A ⊕ (ConePicture.Radial Γ R × Bool)) :
+    eval Γ R label letters (ConePicture.inverse Γ R inv a)=(eval Γ R label letters a)⁻¹ := by
+  rcases a with a|⟨v,b⟩
+  · simp only [ConePicture.inverse,eval,hw,map_inv]
+  · cases b <;> simp [ConePicture.inverse,eval]
+/-- Actual oriented physical two-cell with its group translate. The translation
+is measured from the common cone apex, not from the endpoint of the edge. -/
+def cell (g : G) (d : D) : Cells Γ R label letters :=
+  (g*(radialValue Γ (letters ∘ label) R (Γ.origin d))⁻¹,edge Γ d)
+include hl hw in
+lemma cell_reverse (g : G) (d : D) :
+    cell Γ R label letters (g*oldMap Γ (letters ∘ label) R (letters (label d))) (Γ.reverse d)=
+      cell Γ R label letters g d := by
+  apply Prod.ext
+  · dsimp [cell]
+    rw [edge_value Γ (letters ∘ label) R (letters_reverse Γ label inv letters hl hw)]
+    dsimp only [Function.comp_apply]
+    group
+  · exact edge_reverse Γ d
+
+def charge (g : G) (d : D) : TwoChain Γ R label letters :=
+  if d=representative Γ (edge Γ d) then Finsupp.single (cell Γ R label letters g d) 1
+  else -Finsupp.single (cell Γ R label letters g d) 1
+include hl hw in
+lemma charge_reverse (g : G) (d : D) :
+    charge Γ R label letters (g*oldMap Γ (letters ∘ label) R (letters (label d))) (Γ.reverse d)=
+      -charge Γ R label letters g d := by
+  rw [charge,cell_reverse Γ R label inv letters hl hw,edge_reverse]
+  by_cases hd : d=representative Γ (edge Γ d)
+  · have hr : Γ.reverse d≠representative Γ (edge Γ d) := by
+      rw [←hd];exact Γ.reverse_ne d
+    rw [ite_eq_right hr,charge,ite_eq_left hd]
+  · have hr : Γ.reverse d=representative Γ (edge Γ d) := by
+      rcases representative_cases Γ d with hh|hh
+      · exact (hd hh).elim
+      · exact (congrArg Γ.reverse hh).trans (Γ.reverse_reverse_apply _)
+    rw [ite_eq_left hr,charge,ite_eq_right hd,neg_neg]
+def coneCharge (g : G) : ConePicture.Dart Γ R→TwoChain Γ R label letters
+  | .inl d => charge Γ R label letters g d
+  | .inr _ => 0
+include hl hw in
+lemma coneCharge_reverse (g : G) (d : ConePicture.Dart Γ R) :
+    coneCharge Γ R label letters
+      (g*eval Γ R label letters (ConePicture.labels Γ R label d)) ((ConePicture.graph Γ R).reverse d)=
+    -coneCharge Γ R label letters g d := by
+  rcases d with d|p
+  · exact charge_reverse Γ R label inv letters hl hw g d
+  · exact (neg_zero).symm
+
+variable {O : Type} [Fintype O]
+  (a : SphericalPicture.Data (O:=O) (ConePicture.graph Γ R)
+    (ConePicture.labels Γ R label) (ConePicture.inverse Γ R inv))
+  (l : PictureChains.Lift _ _ _ (eval Γ R label letters) a)
+include hi hl hw in
+/-- Sharp arrangement exclusion annihilates the genuine free integral
+physical-cell charge of every lifted cone boundary picture. -/
+theorem chain_zero
+    (hex : ∀{P : Type}[Fintype P][Nonempty P]
+      (b : SphericalPicture.Data (O:=P) Γ label inv),¬b.Reduced) :
+    (∑i,coneCharge Γ R label letters (l.position i) (a.dart i))=0 :=
+  PictureChains.chain_eq_zero (eval_inverse Γ R label inv letters hw)
+    (ConePicture.label_reverse Γ R label inv hl) a l (coneCharge Γ R label letters)
+    (coneCharge_reverse Γ R label inv letters hl hw)
+    (ConePicture.reduces_to_empty a hi hl hex)
+end
+end TorsionFreeZeroDivisors.ConeChains
+
+end
+
+
+end OAI
diff --git a/lean/OAI/Algebra/GroupRing/ConePicture.lean b/lean/OAI/Algebra/GroupRing/ConePicture.lean
new file mode 100644
index 0000000000000000000000000000000000000000..35f5c20a9612af7184611724b23e4cf5e619a6fc
--- /dev/null
+++ b/lean/OAI/Algebra/GroupRing/ConePicture.lean
@@ -0,0 +1,431 @@
+import Mathlib
+import OAI.Algebra.GroupRing.PlanarMap
+
+namespace OAI
+
+noncomputable section
+
+namespace TorsionFreeZeroDivisors.SphericalPicture
+open scoped Classical
+open PortSubdivision PermutationCycles CycleLists
+variable {V D A O : Type} [Fintype O] (Γ : PortGraph V D) (label : D→A) (inv : A→A)
+/-- A finite lifted spherical boundary map; empty boundary components are not
+recorded. Unlike the disk certificate there is NO marked exceptional boundary.
+This is combinatorial data, not yet a claim about a continuous sphere map. -/
+structure Data where
+  rotation : Equiv.Perm O
+  partner : Equiv.Perm O
+  involutive : Function.Involutive partner
+  fixed_free : ∀ i,partner i≠i
+  dart : O→D
+  consistent : ∀ i,Γ.origin (Γ.reverse (dart i))=Γ.origin (dart (rotation i))
+  compatible : ∀ i,label (dart (partner i))=inv (label (dart i))
+  genusZero : MapEuler.GenusZero rotation partner
+namespace Data
+variable {Γ label inv} (a : Data (O:=O) Γ label inv)
+
+def Reduced : Prop := (∀i,a.dart (a.partner i)≠Γ.reverse (a.dart i)) ∧
+  ∀i,a.dart (a.rotation i)≠Γ.reverse (a.dart i)
+
+variable {O' : Type} [Fintype O']
+def reindex (e : O≃O') : Data (O:=O') Γ label inv where
+  rotation := e.permCongr a.rotation
+  partner := e.permCongr a.partner
+  involutive := PermutationTransport.involutive e _ a.involutive
+  fixed_free := PermutationTransport.fixed_free e _ a.fixed_free
+  dart i := a.dart (e.symm i)
+  consistent i := by simpa only [Equiv.permCongr_apply,e.symm_apply_apply] using a.consistent (e.symm i)
+  compatible i := by simpa only [Equiv.permCongr_apply,e.symm_apply_apply] using a.compatible (e.symm i)
+  genusZero := MapConjugation.genusZero e _ _ a.genusZero
+
+variable (p q : O) (hpq : p≠q)
+def band (hpair : a.partner p=q) (he : a.dart q=Γ.reverse (a.dart p)) :
+    Data (O:=BandEuler.Residual p q hpq) Γ label inv where
+  rotation := BandEuler.rotation a.rotation p q hpq
+  partner := BandEuler.partner a.partner a.involutive p q hpq hpair
+  involutive := BandEuler.partner_involutive a.partner a.involutive p q hpq hpair
+  fixed_free i hi := by
+    apply a.fixed_free (BandEuler.val p q hpq i)
+    have hh := congrArg (BandEuler.val p q hpq) hi
+    rwa [BandEuler.partner_val] at hh
+  dart i := a.dart (BandEuler.val p q hpq i)
+  consistent := BoundarySurgery.consistent a.rotation (Γ.origin ∘ a.dart)
+    (Γ.origin ∘ Γ.reverse ∘ a.dart) p q hpq a.consistent
+    (by dsimp;rw [he]) (by dsimp;rw [he,Γ.reverse_reverse])
+  compatible i := by rw [BandEuler.partner_val];exact a.compatible _
+  genusZero := BandEuler.genusZero_all a.rotation a.partner a.involutive p q hpq hpair a.genusZero
+
+def tighten (hinv : Function.Involutive inv) (hlabel : ∀d,label (Γ.reverse d)=inv (label d))
+    (hsp : a.rotation p=q) (he : a.dart q=Γ.reverse (a.dart p)) :
+    Data (O:=PartialMatchingSurgery.Remaining p q) Γ label inv where
+  rotation := Tightening.rotation a.rotation p q hpq hsp
+  partner := PartialMatchingSurgery.partner a.partner a.involutive p q hpq (a.fixed_free p) (a.fixed_free q)
+  involutive := PartialMatchingSurgery.involutive a.partner a.involutive p q hpq (a.fixed_free p) (a.fixed_free q)
+  fixed_free i := PartialMatchingSurgery.distinct a.partner a.involutive p q hpq (a.fixed_free p)
+    (a.fixed_free q) i (a.fixed_free i)
+  dart i := a.dart i
+  consistent := Tightening.consistent a.rotation p q hpq hsp (Γ.origin ∘ a.dart)
+    (Γ.origin ∘ Γ.reverse ∘ a.dart) a.consistent (by dsimp;rw [he,Γ.reverse_reverse])
+  compatible i := PartialMatchingSurgery.compatible a.partner a.involutive p q hpq (a.fixed_free p)
+    (a.fixed_free q) inv hinv (label ∘ a.dart) a.compatible (by dsimp;rw [he,hlabel]) i
+  genusZero := Tightening.partial_genusZero a.rotation p q hpq hsp a.partner a.involutive
+    (a.fixed_free p) (a.fixed_free q) a.genusZero
+
+lemma unequal_backtrack (he : a.dart q=Γ.reverse (a.dart p)) : p≠q := by
+  intro h
+  subst q
+  exact Γ.reverse_ne (a.dart p) he.symm
+
+def boundaryRep (c : Cycle a.rotation) : O := Quotient.out c
+lemma boundaryRep_cycle (c : Cycle a.rotation) : cycle a.rotation (a.boundaryRep c)=c := Quotient.out_eq c
+def occurrences (c : Cycle a.rotation) : List O := orbit a.rotation (a.boundaryRep c)
+def paths (c : Cycle a.rotation) : List D := (a.occurrences c).map a.dart
+lemma occurrences_nonempty (c : Cycle a.rotation) : a.occurrences c≠[] := orbit_nonempty _ _
+lemma paths_nonempty (c : Cycle a.rotation) : a.paths c≠[] := by
+  intro he
+  exact a.occurrences_nonempty c (List.map_eq_nil_iff.mp he)
+lemma paths_length (c : Cycle a.rotation) : (a.paths c).length=(a.occurrences c).length := List.length_map _
+lemma occurrences_succ (c : Cycle a.rotation) (i : ℕ) (hi : i+1<(a.occurrences c).length) :
+    a.rotation ((a.occurrences c)[i])=(a.occurrences c)[i+1] := orbit_succ _ _ _ hi
+lemma occurrences_last (c : Cycle a.rotation) :
+    a.rotation ((a.occurrences c).getLast (a.occurrences_nonempty c))=
+      (a.occurrences c).head (a.occurrences_nonempty c) := orbit_last _ _
+
+variable (hr : a.Reduced)
+include hr in
+lemma paths_chain (c : Cycle a.rotation) : (a.paths c).IsChain
+    (fun d e=>Γ.origin (Γ.reverse d)=Γ.origin e ∧ e≠Γ.reverse d) := by
+  rw [paths,List.isChain_map,List.isChain_iff_getElem]
+  intro i hi
+  have hh := a.consistent ((a.occurrences c)[i])
+  have hb := hr.2 ((a.occurrences c)[i])
+  rw [a.occurrences_succ c i hi] at hh hb
+  exact ⟨hh,hb⟩
+include hr in
+lemma paths_closed (c : Cycle a.rotation) :
+    Γ.origin (Γ.reverse ((a.paths c).getLast (a.paths_nonempty c)))=
+      Γ.origin ((a.paths c).head (a.paths_nonempty c)) ∧
+    (a.paths c).head (a.paths_nonempty c)≠Γ.reverse ((a.paths c).getLast (a.paths_nonempty c)) := by
+  have hh := a.consistent ((a.occurrences c).getLast (a.occurrences_nonempty c))
+  have hb := hr.2 ((a.occurrences c).getLast (a.occurrences_nonempty c))
+  rw [a.occurrences_last c] at hh hb
+  simpa only [paths,List.head_map,List.getLast_map] using And.intro hh hb
+
+def pathCoordinates : (Σc : Cycle a.rotation,Fin (a.paths c).length)≃O :=
+  (Equiv.sigmaCongrRight fun c=>finCongr (a.paths_length c)).trans
+    (coordinates a.rotation a.boundaryRep a.boundaryRep_cycle)
+lemma pathCoordinates_apply (p : Σc : Cycle a.rotation,Fin (a.paths c).length) :
+    a.pathCoordinates p=(a.occurrences p.1)[p.2.val]'(by simpa only [a.paths_length] using p.2.isLt) := rfl
+lemma paths_dart (p : Σc : Cycle a.rotation,Fin (a.paths c).length) :
+    (a.paths p.1)[p.2.val]=a.dart (a.pathCoordinates p) := by
+  rw [a.pathCoordinates_apply p]
+  exact List.getElem_map _
+lemma pathCoordinates_rotate (c : Cycle a.rotation) (i : Fin (a.paths c).length) :
+    a.pathCoordinates ⟨c,finRotate (a.paths c).length i⟩=a.rotation (a.pathCoordinates ⟨c,i⟩) := by
+  simp only [pathCoordinates_apply]
+  have hh := orbit_rotate a.rotation (a.boundaryRep c) (finCongr (a.paths_length c) i)
+  have commute : ∀{m n : ℕ}(h : m=n)(i : Fin m),finCongr h (finRotate m i)=finRotate n (finCongr h i) := by
+    intro m n h i;subst n;rfl
+  exact (congrArg (fun j : Fin (a.occurrences c).length=>(a.occurrences c)[j.val])
+    (commute (a.paths_length c) i)).trans hh
+end Data
+end TorsionFreeZeroDivisors.SphericalPicture
+
+namespace TorsionFreeZeroDivisors.SampleGraph.SpherePicture
+open scoped Classical
+open BlockAlignment ComparedBlocks WordPositions PermutationCycles
+variable {rep : ℕ} {r : ActualPatternEvent.Match rep} {x : VA rep} {y : VB rep}
+  {O : Type} [Fintype O]
+  (a : SphericalPicture.Data (O:=O) (graph rep r) (label rep) Types.inverse) (hr : a.Reduced)
+
+def system : PathSystem rep r x y where
+  P := Cycle a.rotation
+  E := Empty
+  paths := a.paths
+  nonempty := a.paths_nonempty
+  root := none
+  path_chain := a.paths_chain hr
+  cyclic_chain c _ := by
+    intro d hd e he
+    rw [List.getLast?_eq_some_getLast (a.paths_nonempty c)] at hd
+    rw [Option.mem_some] at hd
+    rw [List.head?_eq_some_head (a.paths_nonempty c)] at he
+    rw [Option.mem_some] at he
+    subst d
+    subst e
+    exact a.paths_closed hr c
+  comparisons := Comparisons.empty _
+  lower := Empty.elim
+  upper := Empty.elim
+  lower_eq := fun e=>Empty.elim e
+  upper_eq := fun e=>Empty.elim e
+  lower_le := fun e=>Empty.elim e
+  upper_le := fun e=>Empty.elim e
+  reduced := fun _ e=>Empty.elim e
+  rootA q hq := by cases hq
+  rootB q hq := by cases hq
+  compatible := fun _ e=>Empty.elim e
+
+def coordinates : Position (fun c=>(a.paths c).length)≃O :=
+  (WordPositions.fin _).trans a.pathCoordinates
+lemma dart (p : Position (fun c=>(a.paths c).length)) :
+    RawDecomposition.dart a.paths p=a.dart (coordinates a p) := by
+  rw [←(WordPositions.fin _).symm_apply_apply p,WordPositions.dart_fin]
+  exact a.paths_dart _
+lemma rotation (p : Position (fun c=>(a.paths c).length)) :
+    coordinates a (BoundaryRotation.perm (fun c=>(a.paths c).length) p)=a.rotation (coordinates a p) := by
+  generalize he : (WordPositions.fin (fun c=>(a.paths c).length)) p=q
+  have hp : p=(WordPositions.fin _).symm q := by rw [←he,Equiv.symm_apply_apply]
+  rw [hp]
+  rcases q with ⟨c,i⟩
+  rw [BoundaryRotation.apply_fin]
+  simp only [coordinates,Equiv.trans_apply,Equiv.apply_symm_apply]
+  exact a.pathCoordinates_rotate c i
+lemma rotation_conjugate : BoundaryRotation.perm (fun c=>(a.paths c).length)=
+    (coordinates a).symm.permCongr a.rotation := by
+  apply Equiv.ext
+  intro p
+  apply (coordinates a).injective
+  simp only [Equiv.permCongr_apply,Equiv.symm_symm,Equiv.apply_symm_apply]
+  exact rotation a p
+lemma partner_compatible (p : Position (fun c=>(a.paths c).length)) :
+    label rep (RawDecomposition.dart a.paths ((coordinates a).symm.permCongr a.partner p))=
+      Types.inverse (label rep (RawDecomposition.dart a.paths p)) := by
+  rw [dart,dart]
+  simp only [Equiv.permCongr_apply,Equiv.symm_symm,Equiv.apply_symm_apply]
+  exact a.compatible _
+include hr in
+lemma partner_reduced (p : Position (fun c=>(a.paths c).length)) :
+    RawDecomposition.dart a.paths p≠RawDecomposition.dart a.paths ((coordinates a).symm.permCongr a.partner p) ∧
+    RawDecomposition.dart a.paths p≠(graph rep r).reverse
+      (RawDecomposition.dart a.paths ((coordinates a).symm.permCongr a.partner p)) := by
+  rw [dart,dart]
+  simp only [Equiv.permCongr_apply,Equiv.symm_symm,Equiv.apply_symm_apply]
+  constructor
+  · intro he
+    have hh := a.compatible (coordinates a p)
+    rw [←he] at hh
+    exact Types.inverse_ne _ hh.symm
+  · intro he
+    apply hr.1 (coordinates a p)
+    have hh := congrArg (graph rep r).reverse he
+    rw [(graph rep r).reverse_reverse] at hh
+    exact hh.symm
+
+def pairing : FullPairing (system (x:=x) (y:=y) a hr) where
+  perm := (coordinates a).symm.permCongr a.partner
+  involutive := PermutationTransport.involutive _ _ a.involutive
+  fixed_free := PermutationTransport.fixed_free _ _ a.fixed_free
+  compatible p := partner_compatible a p
+  reduced p := partner_reduced a hr p
+lemma pairing_genusZero : MapEuler.GenusZero
+    (BoundaryRotation.perm (fun c=>(a.paths c).length)) (pairing (x:=x) (y:=y) a hr).perm := by
+  change MapEuler.GenusZero (BoundaryRotation.perm (fun c=>(a.paths c).length))
+    ((coordinates a).symm.permCongr a.partner)
+  rw [rotation_conjugate]
+  exact MapConjugation.genusZero (coordinates a).symm _ _ a.genusZero
+lemma pairing_euler [Nonempty O] : (pairing (x:=x) (y:=y) a hr).Euler := by
+  let : Nonempty (Position (fun c=>((system (x:=x) (y:=y) a hr).paths c).length)) :=
+    ⟨(coordinates a).symm (Classical.choice inferInstance)⟩
+  exact MapEuler.euler_of_genusZero _ _ (pairing_genusZero a hr) (pairing a hr).fixed_free
+lemma system_ordinary [Nonempty O] : ∃c,(system (x:=x) (y:=y) a hr).root≠some c :=
+  ⟨cycle a.rotation (Classical.choice inferInstance),by intro h;cases h⟩
+
+/-- Unconditional sharp split for the prepared all-cyclic spherical system. -/
+lemma separator (hL : 2≤GirthAsymptotics.L (TypedGraphs.size rep)) (hd : GraphSample.Diameters rep r)
+    (S : Finset ((pairing (x:=x) (y:=y) a hr).prepared hL hd).P) :
+    Nonempty (RecursiveSeparator.Split (PairingClusters.Rel
+      (fun p : Position (fun t=>(((pairing a hr).prepared hL hd).paths t).length)=>p.1)
+      ((pairing a hr).prepared hL hd).comparisons.pairing.partner) S) := by
+  let s := system (x:=x) (y:=y) a hr
+  let cap := FullPairing.U₀*GirthAsymptotics.L (TypedGraphs.size rep)
+  let hc : 0<cap := FullPairing.cap_positive hL
+  have hp : ∀p,0<BalancedRotation.len s.paths cap hc p := fun p=>
+    List.length_pos_iff.mpr (BalancedWords.segment_nonempty s.paths cap hc s.nonempty p)
+  have hz := BalancedGenus.genusZero s.paths cap hc (pairing a hr).perm
+    (pairing a hr).involutive (pairing_genusZero a hr)
+  obtain ⟨P⟩ := BoundaryRotation.split (BalancedRotation.len s.paths cap hc) hp
+    ((pairing a hr).α cap hc) ((pairing a hr).α_involutive cap hc) hz S
+  exact ⟨(pairing a hr).closed_split cap hc (by omega) hd _ S P⟩
+
+include a hr in
+/-- There is no NONEMPTY reduced spherical boundary certificate in the sample. -/
+theorem excluded [Nonempty O] (hL : 2≤GirthAsymptotics.L (TypedGraphs.size rep))
+    (hd : GraphSample.Diameters rep r) (hsample : r∈ActualPatternEvent.samples rep)
+    (havoid : IsEmpty (BoundedSystem (PlanarParameters.C PathSystem.ε ClosedWords.D)
+      (PlanarParameters.K PathSystem.ε ClosedWords.D) (PlanarParameters.sides PathSystem.ε ClosedWords.D) rep r x y)) :
+    False :=
+  FullPairing.excluded (pairing a hr) hL hd hsample (system_ordinary a hr) (pairing_euler a hr)
+    (fun S _=>separator a hr hL hd S) havoid
+end TorsionFreeZeroDivisors.SampleGraph.SpherePicture
+
+namespace TorsionFreeZeroDivisors.SphericalPicture
+open scoped Classical
+variable {V D A : Type} (Γ : PortSubdivision.PortGraph V D) (label : D→A) (inv : A→A)
+/-- Literal finite surgery trace, including the empty terminal picture.  This
+records no geometric realization or implicit essentiality hypothesis. -/
+inductive ReducesToEmpty : {O : Type} → [Fintype O] → Data (O:=O) Γ label inv → Prop
+  | empty {O : Type} [Fintype O] (a : Data (O:=O) Γ label inv) (h : IsEmpty O) :
+      ReducesToEmpty a
+  | band {O : Type} [Fintype O] (a : Data (O:=O) Γ label inv) (p q : O) (hpq : p≠q)
+      (hpair : a.partner p=q) (he : a.dart q=Γ.reverse (a.dart p))
+      (next : ReducesToEmpty (a.band p q hpq hpair he)) : ReducesToEmpty a
+  | tighten {O : Type} [Fintype O] (a : Data (O:=O) Γ label inv) (p q : O) (hpq : p≠q)
+      (hinv : Function.Involutive inv) (hlabel : ∀d,label (Γ.reverse d)=inv (label d))
+      (hsp : a.rotation p=q) (he : a.dart q=Γ.reverse (a.dart p))
+      (next : ReducesToEmpty (a.tighten p q hpq hinv hlabel hsp he)) : ReducesToEmpty a
+variable {Γ label inv}
+namespace Data
+variable {O : Type} [Fintype O] (p q : O) (hpq : p≠q)
+def deletionCoordinates : BandEuler.Residual p q hpq ≃ PartialMatchingSurgery.Remaining p q where
+  toFun z := ⟨BandEuler.val p q hpq z,BandEuler.val_ne_p p q hpq z,BandEuler.val_ne_q p q hpq z⟩
+  invFun z := ⟨⟨z,z.property.1⟩,fun he=>z.property.2 (congrArg Subtype.val he)⟩
+  left_inv _ := rfl
+  right_inv _ := rfl
+include hpq in
+lemma remaining_two_fewer : Fintype.card (PartialMatchingSurgery.Remaining p q)+2=Fintype.card O := by
+  rw [←Fintype.card_congr (deletionCoordinates p q hpq)]
+  exact BandEuler.two_fewer p q hpq
+end Data
+/-- Strong induction on the actual number of boundary occurrences: each
+nonterminal step deletes two occurrences. -/
+theorem reduces_of_no_reduced (hinv : Function.Involutive inv)
+    (hlabel : ∀d,label (Γ.reverse d)=inv (label d))
+    (hex : ∀{O : Type}[Fintype O][Nonempty O](a : Data (O:=O) Γ label inv),¬a.Reduced)
+    {O : Type} [Fintype O] (a : Data (O:=O) Γ label inv) : ReducesToEmpty Γ label inv a := by
+  generalize he : Fintype.card O=n
+  induction n using Nat.strong_induction_on generalizing O with
+  | h n ih =>
+    by_cases hzero : IsEmpty O
+    · exact .empty a hzero
+    let : Nonempty O := not_isEmpty_iff.mp hzero
+    have hn := hex a
+    simp only [Data.Reduced,not_and_or,not_forall,Classical.not_not] at hn
+    rcases hn with ⟨p,hp⟩ | ⟨p,hp⟩
+    · let q := a.partner p
+      have hpq : p≠q := (a.fixed_free p).symm
+      refine .band a p q hpq rfl hp (ih (Fintype.card (BandEuler.Residual p q hpq)) ?_ _ rfl)
+      have hc := BandEuler.two_fewer p q hpq
+      omega
+    · let q := a.rotation p
+      have hpq : p≠q := a.unequal_backtrack p q hp
+      refine .tighten a p q hpq hinv hlabel rfl hp
+        (ih (Fintype.card (PartialMatchingSurgery.Remaining p q)) ?_ _ rfl)
+      have hc := Data.remaining_two_fewer p q hpq
+      omega
+end TorsionFreeZeroDivisors.SphericalPicture
+namespace TorsionFreeZeroDivisors.SampleGraph.SpherePicture
+open scoped Classical
+variable {rep : ℕ} {r : ActualPatternEvent.Match rep} {x : VA rep} {y : VB rep}
+theorem reduces_to_empty
+    (hL : 2≤GirthAsymptotics.L (TypedGraphs.size rep))
+    (hd : GraphSample.Diameters rep r) (hsample : r∈ActualPatternEvent.samples rep)
+    (havoid : IsEmpty (BoundedSystem (PlanarParameters.C PathSystem.ε ClosedWords.D)
+      (PlanarParameters.K PathSystem.ε ClosedWords.D) (PlanarParameters.sides PathSystem.ε ClosedWords.D) rep r x y))
+    {O : Type} [Fintype O]
+    (a : SphericalPicture.Data (O:=O) (graph rep r) (label rep) Types.inverse) :
+    SphericalPicture.ReducesToEmpty (graph rep r) (label rep) Types.inverse a := by
+  apply SphericalPicture.reduces_of_no_reduced Types.inverse_inverse (fun d=>label_reverse rep r d)
+  intro O _ _ b hr
+  exact excluded b hr hL hd hsample havoid
+end TorsionFreeZeroDivisors.SampleGraph.SpherePicture
+
+namespace TorsionFreeZeroDivisors.ConePicture
+open PortSubdivision GraphPresentation SphericalPicture
+open scoped Classical
+variable {V D A : Type} (Γ : PortGraph V D) (R : Routes Γ)
+abbrev Radial := {v : V // v≠R.base v}
+abbrev Dart := D ⊕ (Radial Γ R × Bool)
+def reverse : Dart Γ R→Dart Γ R
+  | .inl d => .inl (Γ.reverse d)
+  | .inr (v,b) => .inr (v,!b)
+def origin : Dart Γ R→V
+  | .inl d => Γ.origin d
+  | .inr (v,b) => if b then R.base v else v
+/-- The one-skeleton in an abstract graph cone after its root radial edge
+is collapsed. Physical graph edges and all other radial edges are retained. -/
+def graph : PortGraph V (Dart Γ R) where
+  origin := origin Γ R
+  reverse := reverse Γ R
+  reverse_reverse d := by
+    rcases d with d|⟨v,b⟩
+    · exact congrArg Sum.inl (Γ.reverse_reverse d)
+    · cases b <;> rfl
+  reverse_ne d := by
+    rcases d with d|⟨v,b⟩
+    · intro he; exact Γ.reverse_ne d (Sum.inl.inj he)
+    · cases b <;> simp [reverse]
+variable (label : D→A) (inv : A→A)
+def labels : Dart Γ R→ A ⊕ (Radial Γ R × Bool)
+  | .inl d => .inl (label d)
+  | .inr p => .inr p
+def inverse : A ⊕ (Radial Γ R × Bool) → A ⊕ (Radial Γ R × Bool)
+  | .inl a => .inl (inv a)
+  | .inr (v,b) => .inr (v,!b)
+lemma inverse_inverse (hi : Function.Involutive inv) : Function.Involutive (inverse Γ R inv) := by
+  rintro (a|⟨v,b⟩)
+  · exact congrArg Sum.inl (hi a)
+  · cases b <;> rfl
+lemma label_reverse (hl : ∀d,label (Γ.reverse d)=inv (label d)) (d : Dart Γ R) :
+    labels Γ R label ((graph Γ R).reverse d)=inverse Γ R inv (labels Γ R label d) := by
+  rcases d with d|⟨v,b⟩
+  · exact congrArg Sum.inl (hl d)
+  · rfl
+variable {Γ R label inv} {O : Type} [Fintype O]
+  (a : Data (O:=O) (graph Γ R) (labels Γ R label) (inverse Γ R inv))
+lemma reduced_old (hr : a.Reduced) (i : O) : ∃d,a.dart i=Sum.inl d := by
+  cases he : a.dart i with
+  | inl d => exact ⟨d,rfl⟩
+  | inr p =>
+    exfalso
+    have hc := a.compatible i
+    rw [he] at hc
+    have hp : a.dart (a.partner i)=Sum.inr (p.1,!p.2) := by
+      cases hq : a.dart (a.partner i) with
+      | inl d => simp [hq,labels,inverse] at hc
+      | inr q =>
+        have heq : q=(p.1,!p.2) := Sum.inr.inj (by simpa only [hq,labels,inverse] using hc)
+        rw [heq]
+    exact hr.1 i (by rw [he,hp];rfl)
+/-- Removing the ghost radial alphabet from a reduced picture changes
+NEITHER its permutation genus nor its boundary representatives. -/
+def oldData (hr : a.Reduced) : Data (O:=O) Γ label inv where
+  rotation := a.rotation
+  partner := a.partner
+  involutive := a.involutive
+  fixed_free := a.fixed_free
+  dart i := (reduced_old a hr i).choose
+  consistent i := by
+    have h := a.consistent i
+    rw [(reduced_old a hr i).choose_spec,(reduced_old a hr (a.rotation i)).choose_spec] at h
+    exact h
+  compatible i := by
+    have h := a.compatible i
+    rw [(reduced_old a hr i).choose_spec,(reduced_old a hr (a.partner i)).choose_spec] at h
+    exact Sum.inl.inj h
+  genusZero := a.genusZero
+lemma oldData_reduced (hr : a.Reduced) : (oldData a hr).Reduced := by
+  constructor
+  · intro i hi
+    apply hr.1 i
+    rw [(reduced_old a hr i).choose_spec,(reduced_old a hr (a.partner i)).choose_spec]
+    exact congrArg Sum.inl hi
+  · intro i hi
+    apply hr.2 i
+    rw [(reduced_old a hr i).choose_spec,(reduced_old a hr (a.rotation i)).choose_spec]
+    exact congrArg Sum.inl hi
+variable (hi : Function.Involutive inv) (hl : ∀d,label (Γ.reverse d)=inv (label d))
+include hi hl in
+/-- Actual triangular cone presentations introduce no extra reduced spherical
+pictures: every paired radial occurrence is the very same physical radial edge. -/
+theorem reduces_to_empty
+    (hex : ∀{P : Type}[Fintype P][Nonempty P](b : Data (O:=P) Γ label inv),¬b.Reduced) :
+    ReducesToEmpty (graph Γ R) (labels Γ R label) (inverse Γ R inv) a := by
+  apply SphericalPicture.reduces_of_no_reduced (inverse_inverse Γ R inv hi) (label_reverse Γ R label inv hl)
+  intro P _ _ b hb
+  exact hex (oldData b hb) (oldData_reduced b hb)
+end TorsionFreeZeroDivisors.ConePicture
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/GroupRing/ConeSigned.lean b/lean/OAI/Algebra/GroupRing/ConeSigned.lean
new file mode 100644
index 0000000000000000000000000000000000000000..68d5d6f92b9b7ba63cf48b4057006b782de8c3ae
--- /dev/null
+++ b/lean/OAI/Algebra/GroupRing/ConeSigned.lean
@@ -0,0 +1,104 @@
+import Mathlib
+import OAI.Algebra.GroupRing.WordCursor
+import OAI.Algebra.GroupRing.ConeBoundaryPaths
+import OAI.Algebra.GroupRing.ConeChains
+
+namespace OAI
+
+
+
+section
+namespace TorsionFreeZeroDivisors.ConeSigned
+open scoped Classical
+open PortSubdivision GraphPresentation GraphConePresentation
+noncomputable section
+variable {V D S : Type} (Γ : PortGraph V D) (R : Routes Γ) (label : D→S×Bool)
+def pack : (S×Bool) ⊕ (ConePicture.Radial Γ R × Bool) ≃ (Generator (S:=S) Γ R × Bool) where
+  toFun | .inl (s,b)=>(.inl s,b) | .inr (v,b)=>(.inr v,b)
+  invFun | (.inl s,b)=>.inl (s,b) | (.inr v,b)=>.inr (v,b)
+  left_inv x := by rcases x with ⟨s,b⟩|⟨v,b⟩ <;> rfl
+  right_inv x := by rcases x with ⟨s|v,b⟩ <;> rfl
+lemma pack_inverse (a : (S×Bool) ⊕ (ConePicture.Radial Γ R × Bool)) :
+    pack (S:=S) Γ R (ConePicture.inverse Γ R WordPairing.inverseLetter a)=
+      WordPairing.inverseLetter (pack Γ R a) := by
+  rcases a with ⟨s,b⟩|⟨v,b⟩ <;> rfl
+def labels : ConePicture.Dart Γ R→Generator (S:=S) Γ R × Bool := pack Γ R ∘ ConePicture.labels Γ R label
+lemma labels_reverse (hl : ∀d,label (Γ.reverse d)=WordPairing.inverseLetter (label d))
+    (d : ConePicture.Dart Γ R) :
+    labels Γ R label ((ConePicture.graph Γ R).reverse d)=WordPairing.inverseLetter (labels Γ R label d) := by
+  dsimp only [labels,Function.comp_apply]
+  rw [ConePicture.label_reverse Γ R label WordPairing.inverseLetter hl,pack_inverse]
+def unpack {O : Type}[Fintype O]
+    (a : SphericalPicture.Data (O:=O) (ConePicture.graph Γ R) (labels Γ R label) WordPairing.inverseLetter) :
+    SphericalPicture.Data (O:=O) (ConePicture.graph Γ R) (ConePicture.labels Γ R label)
+      (ConePicture.inverse Γ R WordPairing.inverseLetter) where
+  rotation := a.rotation
+  partner := a.partner
+  involutive := a.involutive
+  fixed_free := a.fixed_free
+  dart := a.dart
+  consistent := a.consistent
+  compatible i := by
+    apply (pack Γ R).injective
+    rw [pack_inverse]
+    exact a.compatible i
+  genusZero := a.genusZero
+lemma reduces_to_empty (hl : ∀d,label (Γ.reverse d)=WordPairing.inverseLetter (label d))
+    (hex : ∀{P : Type}[Fintype P][Nonempty P]
+      (a : SphericalPicture.Data (O:=P) Γ label WordPairing.inverseLetter),¬a.Reduced)
+    {O : Type}[Fintype O]
+    (a : SphericalPicture.Data (O:=O) (ConePicture.graph Γ R) (labels Γ R label) WordPairing.inverseLetter) :
+    SphericalPicture.ReducesToEmpty _ _ _ a := by
+  apply SphericalPicture.reduces_of_no_reduced WordPairing.inverseLetter_involutive (labels_reverse Γ R label hl)
+  intro P _ _ b hb
+  exact hex (ConePicture.oldData (unpack Γ R label b) hb)
+    (ConePicture.oldData_reduced _ hb)
+def freeLetter {A : Type} (a : A×Bool) : FreeGroup A := FreeGroup.mk [a]
+lemma freeLetter_inverse {A : Type} (a : A×Bool) :
+    freeLetter (WordPairing.inverseLetter a)=(freeLetter a)⁻¹ := by
+  change FreeGroup.mk [WordPairing.inverseLetter a]=(FreeGroup.mk [a])⁻¹
+  rw [FreeGroup.inv_mk]
+  rfl
+lemma freeLetter_map {A B : Type} (f : A→B) (a : A×Bool) :
+    FreeGroup.map f (freeLetter a)=freeLetter (f a.1,a.2) := by
+  simp only [freeLetter,FreeGroup.map.mk,List.map_singleton]
+local notation "letters" => freeLetter ∘ label
+local notation "G" => GraphConePresentation.Group Γ letters R
+def eval (a : Generator (S:=S) Γ R × Bool) : G := PresentedGroup.mk _ (freeLetter a)
+lemma eval_inverse (a : Generator (S:=S) Γ R × Bool) :
+    eval Γ R label (WordPairing.inverseLetter a)=(eval Γ R label a)⁻¹ := by
+  simp only [eval,freeLetter_inverse,map_inv]
+lemma eval_pack (a : (S×Bool) ⊕ (ConePicture.Radial Γ R × Bool)) :
+    eval Γ R label (pack Γ R a)=ConeChains.eval Γ R label freeLetter a := by
+  rcases a with ⟨s,b⟩|⟨v,b⟩
+  · change PresentedGroup.mk _ (freeLetter (Sum.inl s,b))=
+      oldMap Γ letters R (freeLetter (s,b))
+    rw [oldMap,MonoidHom.comp_apply,old,freeLetter_map]
+  · cases b
+    · change PresentedGroup.mk _ (FreeGroup.of (Sum.inr v))⁻¹=
+        (radialValue Γ letters R v)⁻¹
+      rw [map_inv,radialValue,radial,dite_eq_right v.property]
+    · change PresentedGroup.mk _ (FreeGroup.of (Sum.inr v))=radialValue Γ letters R v
+      rw [radialValue,radial,dite_eq_right v.property]
+lemma wordLabel_eq (d : ConePicture.Dart Γ R) :
+    freeLetter (labels Γ R label d)=ConePicture.wordLabel Γ R letters d := by
+  rcases d with d|⟨v,b⟩
+  · change freeLetter (Sum.inl (label d).1,(label d).2)=FreeGroup.map Sum.inl (freeLetter (label d))
+    exact (freeLetter_map _ _).symm
+  · cases b <;> rfl
+lemma value_mk {A H : Type} [Group H] (q : FreeGroup A→*H) (w : List (A×Bool)) :
+    WordCursor.value (fun a=>q (freeLetter a)) w=q (FreeGroup.mk w) := by
+  induction w with
+  | nil=>exact (map_one q).symm
+  | cons a w ih=>rw [WordCursor.value_cons,ih,show a::w=[a]++w from rfl,←FreeGroup.mul_mk,map_mul];rfl
+lemma eval_value (w : List (Generator (S:=S) Γ R × Bool)) :
+    WordCursor.value (eval Γ R label) w=PresentedGroup.mk _ (FreeGroup.mk w) :=
+  value_mk _ w
+
+end
+end TorsionFreeZeroDivisors.ConeSigned
+
+end
+
+
+end OAI
diff --git a/lean/OAI/Algebra/GroupRing/ConeTorsion.lean b/lean/OAI/Algebra/GroupRing/ConeTorsion.lean
new file mode 100644
index 0000000000000000000000000000000000000000..a354c27ed23151b813868d230aba4830348b3f8e
--- /dev/null
+++ b/lean/OAI/Algebra/GroupRing/ConeTorsion.lean
@@ -0,0 +1,61 @@
+import Mathlib
+import OAI.Algebra.GroupRing.ConeArea
+import OAI.Algebra.GroupRing.RelationTorsion
+
+namespace OAI
+
+
+
+section
+namespace TorsionFreeZeroDivisors.ConeTorsion
+open scoped Classical
+open PortSubdivision GraphPresentation GraphConePresentation
+noncomputable section
+variable {V D S : Type} (Γ : PortGraph V D) (R : Routes Γ) (label : D→S×Bool)
+  (hl : ∀d,label (Γ.reverse d)=WordPairing.inverseLetter (label d))
+local notation "letters" => ConeSigned.freeLetter ∘ label
+include hl in
+lemma relations_eq : AlgebraicPictures.relations (ConeArea.words Γ R label)=
+    GraphConePresentation.relations Γ letters R := by
+  change Set.range (fun e=>FreeGroup.mk (ConeArea.words Γ R label e))=Set.range _
+  congr 1
+  funext e
+  exact ConeArea.words_mk Γ R label hl e
+include hl in
+lemma total_zero
+    (hex : ∀{P : Type}[Fintype P][Nonempty P]
+      (a : SphericalPicture.Data (O:=P) Γ label WordPairing.inverseLetter),¬a.Reduced)
+    (ts : List (AlgebraicPictures.Term (A:=Generator (S:=S) Γ R) (I:=Edge Γ)))
+    (he : FreeGroup.mk (AlgebraicPictures.word (ConeArea.words Γ R label) ts)=1) :
+    RelationArea.total (ConeArea.words Γ R label) ts=0 := by
+  have h := ConeArea.identity_zero Γ R label hl hex ts he
+  unfold RelationArea.total RelationArea.term RelationArea.q RelationArea.G
+  rw [relations_eq Γ R label hl]
+  exact h
+include hl in
+theorem cone_torsion_free
+    (hex : ∀{P : Type}[Fintype P][Nonempty P]
+      (a : SphericalPicture.Data (O:=P) Γ label WordPairing.inverseLetter),¬a.Reduced) :
+    ∀ (g : GraphConePresentation.Group Γ letters R) (n : ℕ), 0 < n → g ^ n = 1 → g = 1 := by
+  have h := RelationTorsion.torsion_free (ConeArea.words Γ R label) (total_zero Γ R label hl hex)
+  unfold RelationArea.G at h
+  rw [relations_eq Γ R label hl] at h
+  exact h
+include hl in
+theorem graph_torsion_free (hbase : ∀v,R.base (R.base v)=R.base v)
+    (hex : ∀{P : Type}[Fintype P][Nonempty P]
+      (a : SphericalPicture.Data (O:=P) Γ label WordPairing.inverseLetter),¬a.Reduced) :
+    ∀ (g : GraphPresentation.Group Γ letters R) (n : ℕ), 0 < n → g ^ n = 1 → g = 1 := by
+  intro g n hn he
+  let e := GraphConePresentation.equivalence Γ letters R (ConeArea.letters_reverse Γ label hl) hbase
+  apply e.injective
+  rw [map_one]
+  exact cone_torsion_free Γ R label hl hex (e g) n hn (by rw [←map_pow,he,map_one])
+end
+end TorsionFreeZeroDivisors.ConeTorsion
+
+end
+
+
+
+end OAI
diff --git a/lean/OAI/Algebra/GroupRing/ConedMap.lean b/lean/OAI/Algebra/GroupRing/ConedMap.lean
new file mode 100644
index 0000000000000000000000000000000000000000..43eb1808cae780ee1fb379ee939bdc9bfc9b26a3
--- /dev/null
+++ b/lean/OAI/Algebra/GroupRing/ConedMap.lean
@@ -0,0 +1,426 @@
+import Mathlib
+import OAI.Algebra.GroupRing.TreeCentroid
+
+namespace OAI
+
+noncomputable section
+
+namespace TorsionFreeZeroDivisors.MapEuler
+open scoped Classical BigOperators
+open PermutationCycles
+variable {O : Type} [Fintype O] (σ α : Equiv.Perm O) (ha : Function.Involutive α)
+    (T : SimpleGraph (Cycle σ)) (hT : T≤graph σ α ha)
+    (hz : GenusZero σ α) (ht : T.IsTree)
+local notation "β" => subgraphPair σ α ha T hT
+local notation "γ" => α*β
+local notation "φ" => α*σ
+local notation "hγ" => complement_involutive α β ha (subgraphPair_involutive σ α ha T hT)
+  (subgraphPair_subpairing σ α ha T hT)
+local notation "D" => graph φ γ hγ
+local notation "htD" => spanning_cotree_isTree σ α ha T hT hz ht
+
+def homeFace (v : Cycle σ) : Cycle φ := cycle φ (Quotient.out v)
+
+omit [Fintype O] in
+lemma home_cycle (v : Cycle σ) : cycle σ (Quotient.out v)=v := Quotient.out_eq v
+
+def vertexSide (active : Finset (Cycle σ)) (d : O) : Finset (Cycle σ) :=
+  active.filter (fun v=>homeFace σ α v∈cotreeSide σ α ha T hT hz ht d)
+
+def centralDeleted (active : Finset (Cycle σ)) (root : Cycle σ) (c : Cycle φ) (d : O) :
+    Finset (Cycle σ) :=
+  active.filter (fun v=>homeFace σ α v=c ∧ v∈fundamentalVertices σ α T ht root d)
+
+def pressure (active : Finset (Cycle σ)) (root : Cycle σ) (c : Cycle φ) (d : O) :
+    Finset (Cycle σ) :=
+  vertexSide σ α ha T hT hz ht active d ∪ centralDeleted σ α T ht active root c d
+
+lemma pressure_subset (active : Finset (Cycle σ)) (root : Cycle σ) (c : Cycle φ) (d : O) :
+    pressure σ α ha T hT hz ht active root c d⊆active :=
+  Finset.union_subset (Finset.filter_subset _ _) (Finset.filter_subset _ _)
+
+lemma pressure_cover (active : Finset (Cycle σ)) (root : Cycle σ) (c : Cycle φ) :
+    active⊆(members φ c).biUnion (pressure σ α ha T hT hz ht active root c) := by
+  intro v hv
+  by_cases he : homeFace σ α v=c
+  · refine Finset.mem_biUnion.mpr ⟨Quotient.out v,(mem_members φ).mpr he,?_⟩
+    apply Finset.mem_union_right
+    refine Finset.mem_filter.mpr ⟨hv,he,?_⟩
+    apply Finset.mem_union_left
+    rw [home_cycle]
+    exact TreeCentroid.self_mem_rootPath ht root v
+  · have hn := TreeCentroid.next_adj htD (Ne.symm he)
+    obtain ⟨_,d,hd,hd'⟩ := hn
+    refine Finset.mem_biUnion.mpr ⟨d,(mem_members φ).mpr hd,?_⟩
+    apply Finset.mem_union_left
+    apply Finset.mem_filter.mpr
+    refine ⟨hv,?_⟩
+    change homeFace σ α v∈TreeCentroid.branch htD (cycle φ d) (cycle φ (γ d))
+    rw [hd,hd']
+    exact (TreeCentroid.mem_branch htD).mpr ⟨he,rfl⟩
+
+/-- A weighted centroid face and at most three boundary occurrences force one
+fundamental separator to remove or put on its small side at least one third
+of the active vertices. Active vertices have unit cost; all others have zero. -/
+theorem triangular_dart (active : Finset (Cycle σ)) (root : Cycle σ)
+    (htri : ∀ c : Cycle φ,(members φ c).card≤3) :
+    ∃ c : Cycle φ,∃ d∈members φ c,
+      2*(vertexSide σ α ha T hT hz ht active d).card≤active.card ∧
+      active.card≤3*(pressure σ α ha T hT hz ht active root c d).card := by
+  let weight : Cycle φ→ℕ := fun c=>(active.filter (fun v=>homeFace σ α v=c)).card
+  have hsum : ∑ c,weight c=active.card := by
+    simpa only [weight,Finset.mem_univ,Finset.filter_true] using
+      (Finset.sum_card_fiberwise_eq_card_filter active Finset.univ (homeFace σ α))
+  obtain ⟨c,hc⟩ := TreeCentroid.exists_centroid htD weight
+  obtain ⟨d,hd,hm⟩ := (members φ c).exists_max_image
+    (fun d=>(pressure σ α ha T hT hz ht active root c d).card) (members_nonempty φ c)
+  refine ⟨c,d,hd,?_,?_⟩
+  · have hh := hc (cycle φ (γ d))
+    rw [hsum] at hh
+    have hf := Finset.sum_card_fiberwise_eq_card_filter active
+      (cotreeSide σ α ha T hT hz ht d) (homeFace σ α)
+    have hdc := (mem_members φ).mp hd
+    change ∑ f∈cotreeSide σ α ha T hT hz ht d,weight f=
+      (vertexSide σ α ha T hT hz ht active d).card at hf
+    unfold cotreeSide at hf
+    rw [hdc] at hf
+    rwa [←hf]
+  · have hb := (Finset.card_le_card (pressure_cover σ α ha T hT hz ht active root c)).trans
+      (Finset.card_biUnion_le)
+    have hm' := Finset.sum_le_sum (fun x hx=>hm x hx)
+    have ht' := htri c
+    simp only [Finset.sum_const,smul_eq_mul] at hm'
+    exact hb.trans (hm'.trans (Nat.mul_le_mul_right _ ht'))
+
+/-- The opposite retained side of a fundamental cut is disjoint from its
+pressure set. -/
+lemma opposite_disjoint_pressure (active : Finset (Cycle σ)) (root : Cycle σ)
+    (c : Cycle φ) (d : O) :
+    Disjoint (active.filter (fun v=>v∉fundamentalVertices σ α T ht root d ∧
+      homeFace σ α v∉cotreeSide σ α ha T hT hz ht d))
+      (pressure σ α ha T hT hz ht active root c d) := by
+  apply Finset.disjoint_left.mpr
+  intro v hv hp
+  obtain ⟨_,hvC,hvS⟩ := Finset.mem_filter.mp hv
+  rcases Finset.mem_union.mp hp with hp|hp
+  · exact hvS (Finset.mem_filter.mp hp).2
+  · exact hvC (Finset.mem_filter.mp hp).2.2
+
+/-- The literal two-root-path separator balances both retained sides in a
+triangular genus-zero map. This is the sharp bounded-radius crux; no planar
+embedding or separator theorem is imported. -/
+theorem triangular_balanced_fundamental (active : Finset (Cycle σ)) (root : Cycle σ)
+    (htri : ∀ c : Cycle φ,(members φ c).card≤3) :
+    ∃ d : O,
+      3*(active.filter (fun v=>v∉fundamentalVertices σ α T ht root d ∧
+        homeFace σ α v∈cotreeSide σ α ha T hT hz ht d)).card≤2*active.card ∧
+      3*(active.filter (fun v=>v∉fundamentalVertices σ α T ht root d ∧
+        homeFace σ α v∉cotreeSide σ α ha T hT hz ht d)).card≤2*active.card := by
+  obtain ⟨c,d,_,hsmall,hlarge⟩ := triangular_dart σ α ha T hT hz ht active root htri
+  refine ⟨d,?_,?_⟩
+  · have hsub : active.filter (fun v=>v∉fundamentalVertices σ α T ht root d ∧
+        homeFace σ α v∈cotreeSide σ α ha T hT hz ht d)⊆
+        vertexSide σ α ha T hT hz ht active d := by
+      intro v hv
+      exact Finset.mem_filter.mpr ⟨(Finset.mem_filter.mp hv).1,(Finset.mem_filter.mp hv).2.2⟩
+    have hh := Finset.card_le_card hsub
+    omega
+  · have hsub : (active.filter (fun v=>v∉fundamentalVertices σ α T ht root d ∧
+        homeFace σ α v∉cotreeSide σ α ha T hT hz ht d)) ∪
+        pressure σ α ha T hT hz ht active root c d⊆active :=
+      Finset.union_subset (Finset.filter_subset _ _)
+        (pressure_subset σ α ha T hT hz ht active root c d)
+    have hh := Finset.card_le_card hsub
+    rw [Finset.card_union_of_disjoint (opposite_disjoint_pressure σ α ha T hT hz ht active root c d)] at hh
+    omega
+
+end TorsionFreeZeroDivisors.MapEuler
+
+namespace TorsionFreeZeroDivisors.ConedMap
+
+section
+open scoped Classical BigOperators
+open PermutationCycles MapEuler
+variable {O : Type} (σ α : Equiv.Perm O)
+
+/-- Original darts plus one radial pair for each face corner. Radial true is
+at the new face center, radial false at the original vertex. -/
+abbrev Dart (O : Type) := O ⊕ (O × Bool)
+def old (x : O) : Dart O := .inl x
+def radial (x : O) : Dart O := .inr (x,false)
+def center (x : O) : Dart O := .inr (x,true)
+
+def rotation : Equiv.Perm (Dart O) where
+  toFun
+    | .inl x => radial x
+    | .inr (x,false) => old (σ x)
+    | .inr (x,true) => center ((α*σ).symm x)
+  invFun
+    | .inl x => radial (σ.symm x)
+    | .inr (x,false) => old x
+    | .inr (x,true) => center ((α*σ) x)
+  left_inv := by
+    rintro (x|⟨x,b⟩)
+    · rfl
+    · cases b
+      · exact congrArg radial (σ.symm_apply_apply x)
+      · exact congrArg center ((α*σ).apply_symm_apply x)
+  right_inv := by
+    rintro (x|⟨x,b⟩)
+    · exact congrArg old (σ.apply_symm_apply x)
+    · cases b
+      · rfl
+      · exact congrArg center ((α*σ).symm_apply_apply x)
+
+def pairing : Equiv.Perm (Dart O) := Equiv.sumCongr α (Equiv.prodCongr (Equiv.refl O) Equiv.boolNot)
+
+@[simp] lemma rotation_old (x : O) : rotation σ α (old x)=radial x := rfl
+@[simp] lemma rotation_radial (x : O) : rotation σ α (radial x)=old (σ x) := rfl
+@[simp] lemma rotation_center (x : O) : rotation σ α (center x)=center ((α*σ).symm x) := rfl
+@[simp] lemma pairing_old (x : O) : pairing α (old x)=old (α x) := rfl
+@[simp] lemma pairing_radial (x : O) : pairing α (radial x)=center x := rfl
+@[simp] lemma pairing_center (x : O) : pairing α (center x)=radial x := rfl
+
+lemma pairing_involutive (ha : Function.Involutive α) : Function.Involutive (pairing α) := by
+  rintro (x|⟨x,b⟩)
+  · change old (α (α x))=old x
+    rw [ha]
+  · cases b <;> rfl
+
+local notation "ρ" => rotation σ α
+local notation "π" => pairing α
+local notation "φ" => α*σ
+local notation "ψ" => π*ρ
+
+@[simp] lemma face_old (x : O) : ψ (old x)=center x := rfl
+@[simp] lemma face_center (x : O) : ψ (center x)=radial ((α*σ).symm x) := rfl
+@[simp] lemma face_radial (x : O) : ψ (radial x)=old (φ x) := rfl
+
+lemma vertex_radial (x : O) : cycle ρ (radial x)=cycle ρ (old x) := cycle_apply ρ (old x)
+lemma vertex_old_apply (x : O) : cycle ρ (old (σ x))=cycle ρ (old x) :=
+  (cycle_apply ρ (radial x)).trans (vertex_radial σ α x)
+lemma vertex_center_apply (x : O) : cycle ρ (center (φ x))=cycle ρ (center x) := by
+  have h := cycle_apply ρ (center (φ x))
+  simpa only [rotation_center,Equiv.symm_apply_apply] using h.symm
+
+/-- Literal vertex classification: original vertices and the inserted face centers. -/
+def vertexRaw : Dart O → Cycle σ ⊕ Cycle φ
+  | .inl x => .inl (cycle σ x)
+  | .inr (x,false) => .inl (cycle σ x)
+  | .inr (x,true) => .inr (cycle φ x)
+lemma vertexRaw_invariant (x : Dart O) : vertexRaw σ α (ρ x)=vertexRaw σ α x := by
+  rcases x with x|⟨x,b⟩
+  · rfl
+  · cases b
+    · exact congrArg Sum.inl (cycle_apply σ x)
+    · change Sum.inr (cycle φ ((α*σ).symm x))=Sum.inr (cycle φ x)
+      rw [←cycle_apply φ ((α*σ).symm x),(α*σ).apply_symm_apply]
+
+variable [Fintype O]
+
+def vertices : Cycle ρ → Cycle σ ⊕ Cycle φ :=
+  PermutationCycles.lift ρ (vertexRaw σ α) (vertexRaw_invariant σ α)
+def vertexInverse : Cycle σ ⊕ Cycle φ → Cycle ρ
+  | .inl v=>PermutationCycles.lift σ (fun x=>cycle ρ (old x)) (vertex_old_apply σ α) v
+  | .inr f=>PermutationCycles.lift φ (fun x=>cycle ρ (center x)) (vertex_center_apply σ α) f
+lemma vertices_right_inverse : Function.RightInverse (vertexInverse σ α) (vertices σ α) := by
+  rintro (v|f)
+  · obtain ⟨x,rfl⟩ := cycle_surjective σ v
+    rfl
+  · obtain ⟨x,rfl⟩ := cycle_surjective φ f
+    rfl
+lemma vertices_left_inverse : Function.LeftInverse (vertexInverse σ α) (vertices σ α) := by
+  intro v
+  obtain ⟨x,rfl⟩ := cycle_surjective ρ v
+  rcases x with x|⟨x,b⟩
+  · rfl
+  · cases b
+    · exact (vertex_radial σ α x).symm
+    · rfl
+
+def vertexEquiv : Cycle ρ≃Cycle σ ⊕ Cycle φ :=
+  ⟨vertices σ α,vertexInverse σ α,vertices_left_inverse σ α,vertices_right_inverse σ α⟩
+
+@[simp] lemma vertexEquiv_old (x : O) : vertexEquiv σ α (cycle ρ (old x))=.inl (cycle σ x) := rfl
+@[simp] lemma vertexEquiv_radial (x : O) : vertexEquiv σ α (cycle ρ (radial x))=.inl (cycle σ x) := rfl
+@[simp] lemma vertexEquiv_center (x : O) : vertexEquiv σ α (cycle ρ (center x))=.inr (cycle φ x) := rfl
+
+/-- Each coned face is the actual three-cycle old--center--radial. -/
+def faceRaw : Dart O → O
+  | .inl x=>x
+  | .inr (x,false)=>φ x
+  | .inr (x,true)=>x
+omit [Fintype O] in
+lemma faceRaw_invariant (x : Dart O) : faceRaw σ α (ψ x)=faceRaw σ α x := by
+  rcases x with x|⟨x,b⟩
+  · rfl
+  · cases b
+    · rfl
+    · exact (α*σ).apply_symm_apply x
+
+def faces : Cycle ψ→O := PermutationCycles.lift ψ (faceRaw σ α) (faceRaw_invariant σ α)
+omit [Fintype O] in
+lemma face_cycle_center (x : O) : cycle ψ (center x)=cycle ψ (old x) := cycle_apply ψ (old x)
+omit [Fintype O] in
+lemma face_cycle_radial (x : O) : cycle ψ (radial x)=cycle ψ (old (φ x)) :=
+  (cycle_apply ψ (radial x)).symm
+lemma faces_left_inverse : Function.LeftInverse (fun x=>cycle ψ (old x)) (faces σ α) := by
+  intro f
+  obtain ⟨x,rfl⟩ := cycle_surjective ψ f
+  rcases x with x|⟨x,b⟩
+  · rfl
+  · cases b
+    · exact (face_cycle_radial σ α x).symm
+    · exact (face_cycle_center σ α x).symm
+
+def faceEquiv : Cycle ψ≃O :=
+  ⟨faces σ α,fun x=>cycle ψ (old x),faces_left_inverse σ α,fun _=>rfl⟩
+
+lemma face_members (x : O) : members ψ (cycle ψ (old x))={old x,center x,radial ((α*σ).symm x)} := by
+  ext y
+  rw [mem_members]
+  constructor
+  · intro hy
+    have hh := congrArg (faceEquiv σ α) hy
+    rcases y with y|⟨y,b⟩
+    · change y=x at hh
+      subst y
+      exact Finset.mem_insert_self _ _
+    · cases b
+      · change φ y=x at hh
+        have he : y=(α*σ).symm x := (α*σ).injective (hh.trans ((α*σ).apply_symm_apply x).symm)
+        subst y
+        exact Finset.mem_insert_of_mem (Finset.mem_insert_of_mem (Finset.mem_singleton_self _))
+      · change y=x at hh
+        subst y
+        exact Finset.mem_insert_of_mem (Finset.mem_insert_self _ _)
+  · intro hy
+    simp only [Finset.mem_insert,Finset.mem_singleton] at hy
+    rcases hy with rfl|rfl|rfl
+    · rfl
+    · exact face_cycle_center σ α x
+    · rw [face_cycle_radial,(α*σ).apply_symm_apply]
+
+lemma triangular (f : Cycle ψ) : (members ψ f).card=3 := by
+  obtain ⟨x,rfl⟩ := (faceEquiv σ α).symm.surjective f
+  change (members ψ (cycle ψ (old x))).card=3
+  rw [face_members]
+  simp [old,center,radial]
+
+lemma vertex_count : Nat.card (Cycle ρ)=Nat.card (Cycle σ)+Nat.card (Cycle φ) := by
+  rw [Nat.card_congr (vertexEquiv σ α),Nat.card_sum]
+lemma face_count : Nat.card (Cycle ψ)=Nat.card O := Nat.card_congr (faceEquiv σ α)
+
+end
+
+open scoped Classical
+open PermutationCycles MapEuler
+variable {O : Type} (σ α : Equiv.Perm O)
+local notation "ρ" => rotation σ α
+local notation "π" => pairing α
+local notation "φ" => α*σ
+
+lemma component_face (x : O) : component σ α ((α*σ) x)=component σ α x :=
+  (component_partner σ α (σ x)).trans (component_rotation σ α x)
+
+def componentRaw : Dart O → Component σ α
+  | .inl x=>component σ α x
+  | .inr (x,_)=>component σ α x
+lemma componentRaw_rotation (x : Dart O) : componentRaw σ α (ρ x)=componentRaw σ α x := by
+  rcases x with x|⟨x,b⟩
+  · rfl
+  · cases b
+    · exact component_rotation σ α x
+    · change component σ α ((α*σ).symm x)=component σ α x
+      rw [←component_face σ α ((α*σ).symm x),(α*σ).apply_symm_apply]
+lemma componentRaw_pairing (x : Dart O) : componentRaw σ α (π x)=componentRaw σ α x := by
+  rcases x with x|⟨x,b⟩
+  · exact component_partner σ α x
+  · cases b <;> rfl
+
+def componentForward : Component ρ π→ Component σ α :=
+  MapEuler.lift ρ π (componentRaw σ α) (componentRaw_rotation σ α) (componentRaw_pairing σ α)
+lemma component_radial (x : O) : component ρ π (radial x)=component ρ π (old x) :=
+  component_rotation ρ π (old x)
+lemma component_center (x : O) : component ρ π (center x)=component ρ π (old x) :=
+  (component_partner ρ π (radial x)).trans (component_radial σ α x)
+lemma component_old_rotation (x : O) : component ρ π (old (σ x))=component ρ π (old x) :=
+  (component_rotation ρ π (radial x)).trans (component_radial σ α x)
+lemma component_old_pairing (x : O) : component ρ π (old (α x))=component ρ π (old x) :=
+  component_partner ρ π (old x)
+def componentInverse : Component σ α→ Component ρ π :=
+  MapEuler.lift σ α (fun x=>component ρ π (old x))
+    (component_old_rotation σ α) (component_old_pairing σ α)
+
+def componentEquiv : Component ρ π≃Component σ α where
+  toFun := componentForward σ α
+  invFun := componentInverse σ α
+  left_inv := by
+    intro c
+    obtain ⟨x,rfl⟩ := Quotient.mk_surjective c
+    rcases x with x|⟨x,b⟩
+    · rfl
+    · cases b
+      · exact (component_radial σ α x).symm
+      · exact (component_center σ α x).symm
+  right_inv := by
+    intro c
+    obtain ⟨x,rfl⟩ := Quotient.mk_surjective c
+    rfl
+
+variable [Fintype O]
+
+def supportEquiv : ↥(pairing α).support ≃ ↥α.support ⊕ (O×Bool) where
+  toFun x := match x with
+    | ⟨.inl y,hy⟩=>.inl ⟨y,by
+        apply Equiv.Perm.mem_support.mpr
+        intro he
+        exact Equiv.Perm.mem_support.mp hy (congrArg old he)⟩
+    | ⟨.inr y,_⟩=>.inr y
+  invFun
+    | .inl y=>⟨old y.val,by
+        apply Equiv.Perm.mem_support.mpr
+        intro he
+        exact Equiv.Perm.mem_support.mp y.property (Sum.inl.inj he)⟩
+    | .inr (x,b)=>⟨.inr (x,b),by
+        apply Equiv.Perm.mem_support.mpr
+        cases b <;> simp [pairing,Equiv.sumCongr_apply,Equiv.prodCongr_apply]⟩
+  left_inv := by
+    rintro ⟨x,hx⟩
+    rcases x with x|⟨x,b⟩ <;> rfl
+  right_inv := by
+    rintro (x|⟨x,b⟩) <;> rfl
+
+lemma support_count : (pairing α).support.card=α.support.card+2*Nat.card O := by
+  have h := Fintype.card_congr (supportEquiv α)
+  simp only [Fintype.card_coe,Fintype.card_sum,Fintype.card_prod,Fintype.card_bool] at h
+  rw [←Nat.card_eq_fintype_card] at h
+  omega
+
+omit [Fintype O] in
+lemma support_card_nat {X : Type} [Fintype X] [DecidableEq X] (p : Equiv.Perm X) :
+    p.support.card=Nat.card {x : X // p x≠x} := by
+  rw [←Fintype.card_coe,←Nat.card_eq_fintype_card]
+  exact Nat.card_congr
+    ⟨fun x=>⟨x.val,Equiv.Perm.mem_support.mp x.property⟩,
+     fun x=>⟨x.val,Equiv.Perm.mem_support.mpr x.property⟩,
+     fun _=>rfl,fun _=>rfl⟩
+
+/-- Coning all literal face cycles preserves Euler genus zero, with no
+geometric embedding premise and without identifying or deleting any original vertex. -/
+theorem genusZero (hz : GenusZero σ α) : GenusZero ρ π := by
+  classical
+  have hv := vertex_count σ α
+  have hf := face_count σ α
+  have hc := Nat.card_congr (componentEquiv σ α)
+  have hs := support_count α
+  unfold GenusZero at hz ⊢
+  rw [hv,hf,hc]
+  simp only [support_card_nat] at hz hs ⊢
+  omega
+
+end TorsionFreeZeroDivisors.ConedMap
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/GroupRing/ContiguousSplit.lean b/lean/OAI/Algebra/GroupRing/ContiguousSplit.lean
new file mode 100644
index 0000000000000000000000000000000000000000..380fd05c250ed0aff9030a9500523b6b7dbfbd62
--- /dev/null
+++ b/lean/OAI/Algebra/GroupRing/ContiguousSplit.lean
@@ -0,0 +1,393 @@
+import Mathlib
+import OAI.Algebra.GroupRing.ClosedWords
+
+namespace OAI
+
+noncomputable section
+
+namespace TorsionFreeZeroDivisors.ContiguousSplit
+open scoped Classical
+open PermutationCycles
+lemma rotate_val {n : ℕ} (i : Fin n) :
+    (finRotate n i).val=if i.val+1=n then 0 else i.val+1 := by
+  cases n with
+  | zero=>exact i.elim0
+  | succ n=>
+    rw [coe_finRotate]
+    have hh : i=Fin.last n ↔ i.val+1=n+1 := by
+      constructor
+      · rintro rfl;rfl
+      · intro successor_eq
+        exact Fin.ext (Nat.add_right_cancel successor_eq)
+    simp only [hh]
+variable (n m : ℕ)
+abbrev O := Fin (n+1)⊕Fin (m+1)
+def split : Equiv.Perm (O n m) := Equiv.sumCongr (finRotate (n+1)) (finRotate (m+1))
+def joined : Equiv.Perm (O n m) := Equiv.swap (.inl 0) (.inr 0)*split n m
+lemma joined_commutes (x : O n m) :
+    finSumFinEquiv (joined n m x)=finRotate ((n+1)+(m+1)) (finSumFinEquiv x) := by
+  cases x with
+  | inl i=>
+    by_cases hi : i=Fin.last n
+    · subst i
+      simp only [joined,split,Equiv.Perm.mul_apply,Equiv.sumCongr_apply,Sum.map_inl,
+        finRotate_last,Equiv.swap_apply_left,finSumFinEquiv_apply_left,finSumFinEquiv_apply_right]
+      apply Fin.ext
+      rw [rotate_val]
+      simp only [Fin.val_natAdd,Fin.val_zero,add_zero,Fin.val_castAdd,Fin.val_last]
+      rw [ite_eq_right (by omega)]
+    · have hn : finRotate (n+1) i≠0 := by
+        intro hh
+        have h : finRotate (n+1) i=finRotate (n+1) (Fin.last n) := hh.trans (finRotate_last (n:=n)).symm
+        exact hi ((finRotate _).injective h)
+      simp only [joined,split,Equiv.Perm.mul_apply,Equiv.sumCongr_apply,Sum.map_inl]
+      rw [Equiv.swap_apply_of_ne_of_ne (by simpa using hn) (by simp)]
+      simp only [finSumFinEquiv_apply_left]
+      apply Fin.ext
+      rw [Fin.val_castAdd,rotate_val,rotate_val]
+      have hit : i.val < n := (Fin.lt_last_iff_ne_last).mpr hi
+      simp only [Fin.val_castAdd]
+      rw [ite_eq_right (by omega),ite_eq_right (by omega)]
+  | inr i=>
+    by_cases hi : i=Fin.last m
+    · subst i
+      simp only [joined,split,Equiv.Perm.mul_apply,Equiv.sumCongr_apply,Sum.map_inr,
+        finRotate_last,Equiv.swap_apply_right,finSumFinEquiv_apply_left,finSumFinEquiv_apply_right]
+      apply Fin.ext
+      rw [rotate_val]
+      simp only [Fin.val_castAdd,Fin.val_zero,Fin.val_natAdd,Fin.val_last]
+      rw [ite_eq_left (by omega)]
+    · have hn : finRotate (m+1) i≠0 := by
+        intro hh
+        have h : finRotate (m+1) i=finRotate (m+1) (Fin.last m) := hh.trans (finRotate_last (n:=m)).symm
+        exact hi ((finRotate _).injective h)
+      simp only [joined,split,Equiv.Perm.mul_apply,Equiv.sumCongr_apply,Sum.map_inr]
+      rw [Equiv.swap_apply_of_ne_of_ne (by simp) (by simpa using hn)]
+      simp only [finSumFinEquiv_apply_right]
+      apply Fin.ext
+      rw [Fin.val_natAdd,rotate_val,rotate_val]
+      have hit : i.val < m := (Fin.lt_last_iff_ne_last).mpr hi
+      simp only [Fin.val_natAdd]
+      rw [ite_eq_right (by omega),ite_eq_right (by omega)]
+      omega
+lemma joined_conjugate : joined n m=finSumFinEquiv.symm.permCongr (finRotate ((n+1)+(m+1))) := by
+  apply Equiv.ext
+  intro x
+  apply finSumFinEquiv.injective
+  simp only [Equiv.permCongr_apply,Equiv.symm_symm,Equiv.apply_symm_apply,joined_commutes]
+lemma joined_sameCycle (x y : O n m) : (joined n m).SameCycle x y := by
+  rw [joined_conjugate]
+  have hh := WordPairing.rotate_sameCycle (show 2≤(n+1)+(m+1) by omega)
+    (finSumFinEquiv x) (finSumFinEquiv y)
+  have ht := PermutationTransport.sameCycle finSumFinEquiv.symm (finRotate ((n+1)+(m+1))) hh
+  simpa only [Equiv.symm_apply_apply] using ht
+/-- A literal contiguous cut of one cyclic boundary preserves genus zero for
+any actual involutive matching, including bands across the cut. -/
+theorem genusZero (α : Equiv.Perm (O n m)) (hi : Function.Involutive α)
+    (hz : MapEuler.GenusZero (joined n m) α) : MapEuler.GenusZero (split n m) α := by
+  have hh := MapEuler.genusZero_vertexSplit (joined n m) α hi hz
+    (.inl 0) (.inr 0) (by simp) ((cycle_eq _).mpr (joined_sameCycle n m _ _))
+  have he : Equiv.swap (Sum.inl (0 : Fin (n+1))) (Sum.inr (0 : Fin (m+1))) *
+      joined n m=split n m := by
+    ext x
+    simp only [joined,Equiv.Perm.mul_apply]
+    convert Equiv.swap_apply_self (Sum.inl (0 : Fin (n+1)))
+      (Sum.inr (0 : Fin (m+1))) (split n m x) using 1
+  have hh' : MapEuler.GenusZero (Equiv.swap (Sum.inl (0 : Fin (n+1)))
+      (Sum.inr (0 : Fin (m+1))) * joined n m) α := by
+    convert hh using 1
+    apply Equiv.ext
+    intro x
+    simp only [Equiv.Perm.mul_apply,Equiv.swap_apply_def]
+    split_ifs <;> rfl
+  rw [he] at hh'
+  exact hh' 
+
+end TorsionFreeZeroDivisors.ContiguousSplit
+namespace TorsionFreeZeroDivisors.BoundaryRefinement
+open scoped Classical
+open PermutationCycles
+variable {O : Type}
+/-- Finite sequences of actual vertex cuts. This retains the whole matching;
+only cyclic boundary order changes. Cuts must occur on the same current cycle. -/
+inductive Cuts : Equiv.Perm O → Equiv.Perm O → Prop
+  | refl (σ) : Cuts σ σ
+  | step (σ) (p q : O) (hne : p≠q) (hcycle : σ.SameCycle p q) :
+      Cuts σ (Equiv.swap p q*σ)
+  | trans {σ τ υ} : Cuts σ τ → Cuts τ υ → Cuts σ υ
+variable [Fintype O]
+lemma preserves {σ τ : Equiv.Perm O} (h : Cuts σ τ) (α : Equiv.Perm O)
+    (hi : Function.Involutive α) (hz : MapEuler.GenusZero σ α) :
+    MapEuler.GenusZero τ α := by
+  induction h with
+  | refl=>exact hz
+  | step σ p q hn hc=>
+    have hh := MapEuler.genusZero_vertexSplit σ α hi hz p q hn ((cycle_eq σ).mpr hc)
+    convert hh using 1
+  | trans h h' ih ih'=>exact ih' (ih hz)
+lemma mapped_sameCycle {P : Type} (f : O→P) (σ : Equiv.Perm O) (τ : Equiv.Perm P)
+    (hc : ∀x,τ (f x)=f (σ x)) {x y : O} (h : σ.SameCycle x y) :
+    τ.SameCycle (f x) (f y) := by
+  obtain ⟨k,hk⟩ := h.exists_nat_pow_eq
+  have he : ∀k x,(τ^k) (f x)=f ((σ^k) x) := by
+    intro k
+    induction k with
+    | zero=>intro x;rfl
+    | succ k ih=>intro x;simp only [pow_succ',Equiv.Perm.mul_apply,ih,hc]
+  exact ⟨(k:ℤ),by rw [zpow_natCast,he,hk]⟩
+variable {P : Type} [Fintype P]
+omit [Fintype P] in
+lemma conjugate {σ τ : Equiv.Perm O} (h : Cuts σ τ) (e : O≃P) :
+    Cuts (e.permCongr σ) (e.permCongr τ) := by
+  induction h with
+  | refl=>exact .refl _
+  | step σ p q hn hc=>
+    have hex : e.permCongr (Equiv.swap p q*σ)=Equiv.swap (e p) (e q)*e.permCongr σ := by
+      apply Equiv.ext
+      intro x
+      simp only [Equiv.permCongr_apply,Equiv.Perm.mul_apply,Equiv.swap_apply_def]
+      have he₂ : σ (e.symm x)=p ↔ e (σ (e.symm x))=e p := e.injective.eq_iff.symm
+      have he₃ : σ (e.symm x)=q ↔ e (σ (e.symm x))=e q := e.injective.eq_iff.symm
+      split_ifs <;> first | rfl | simp_all
+    rw [hex]
+    exact .step _ _ _ (fun h=>hn (e.injective h)) (PermutationTransport.sameCycle e σ hc)
+  | trans h h' ih ih'=>exact ih.trans ih'
+omit [Fintype P] in
+lemma left {σ τ : Equiv.Perm O} (h : Cuts σ τ) (ρ : Equiv.Perm P) :
+    Cuts (Equiv.sumCongr σ ρ) (Equiv.sumCongr τ ρ) := by
+  let : DecidableEq (O⊕P) := fun _ _=>Classical.propDecidable _
+  induction h with
+  | refl=>exact .refl _
+  | step σ p q hn hc=>
+    have hex : Equiv.sumCongr (Equiv.swap p q*σ) ρ=
+        Equiv.swap (Sum.inl p) (Sum.inl q)*Equiv.sumCongr σ ρ := by
+      apply Equiv.ext
+      intro x
+      cases x with
+      | inl x=>simp [Equiv.Perm.mul_apply,Equiv.swap_apply_def];split_ifs <;> simp_all
+      | inr x=>simp [Equiv.Perm.mul_apply,Equiv.swap_apply_def]
+    rw [hex]
+    exact .step _ _ _ (fun h=>hn (Sum.inl.inj h))
+      (mapped_sameCycle Sum.inl σ (Equiv.sumCongr σ ρ) (fun _=>rfl) hc)
+  | trans h h' ih ih'=>exact ih.trans ih'
+lemma right {σ τ : Equiv.Perm P} (h : Cuts σ τ) (ρ : Equiv.Perm O) :
+    Cuts (Equiv.sumCongr ρ σ) (Equiv.sumCongr ρ τ) := by
+  have hh := conjugate (left h ρ) (Equiv.sumComm P O)
+  convert hh using 1 <;> apply Equiv.ext <;> intro x <;> cases x <;> rfl
+
+end TorsionFreeZeroDivisors.BoundaryRefinement
+namespace TorsionFreeZeroDivisors.BlockBoundary
+open scoped Classical
+open BoundaryRefinement
+lemma fin_cut (n m : ℕ) : Cuts
+    (finSumFinEquiv.symm.permCongr (finRotate (n+m)))
+    (Equiv.sumCongr (finRotate n) (finRotate m)) := by
+  cases n with
+  | zero=>
+    have he : finSumFinEquiv.symm.permCongr (finRotate (0+m))=
+        Equiv.sumCongr (finRotate 0) (finRotate m) := by
+      apply Equiv.ext
+      intro x
+      cases x with
+      | inl x=>exact x.elim0
+      | inr x=>
+        apply finSumFinEquiv.injective
+        simp only [Equiv.permCongr_apply,Equiv.symm_symm,Equiv.apply_symm_apply,
+          Equiv.sumCongr_apply,Sum.map_inr,finSumFinEquiv_apply_right]
+        simp
+        apply Fin.ext
+        simp [Fin.val_add]
+    rw [he];exact .refl _
+  | succ n=>
+    cases m with
+    | zero=>
+      have he : finSumFinEquiv.symm.permCongr (finRotate ((n+1)+0))=
+          Equiv.sumCongr (finRotate (n+1)) (finRotate 0) := by
+        apply Equiv.ext
+        intro x
+        cases x with
+        | inr x=>exact x.elim0
+        | inl x=>
+          apply finSumFinEquiv.injective
+          simp only [Equiv.permCongr_apply,Equiv.symm_symm,Equiv.apply_symm_apply,
+            Equiv.sumCongr_apply,Sum.map_inl,finSumFinEquiv_apply_left]
+          congr 1
+      rw [he];exact .refl _
+    | succ m=>
+      rw [←ContiguousSplit.joined_conjugate n m]
+      have hh := Cuts.step (ContiguousSplit.joined n m)
+        (Sum.inl (0 : Fin (n+1))) (Sum.inr (0 : Fin (m+1)))
+        (by simp) (ContiguousSplit.joined_sameCycle n m _ _)
+      have he : Equiv.swap (Sum.inl (0 : Fin (n+1))) (Sum.inr (0 : Fin (m+1))) *
+          ContiguousSplit.joined n m=ContiguousSplit.split n m := by
+        apply Equiv.ext
+        intro x
+        simp only [ContiguousSplit.joined,Equiv.Perm.mul_apply]
+        convert Equiv.swap_apply_self (Sum.inl (0 : Fin (n+1)))
+          (Sum.inr (0 : Fin (m+1))) (ContiguousSplit.split n m x) using 1
+      have hh' : Cuts (ContiguousSplit.joined n m)
+          (Equiv.swap (Sum.inl (0 : Fin (n+1))) (Sum.inr (0 : Fin (m+1))) *
+          ContiguousSplit.joined n m) := by
+        convert hh using 1
+        apply Equiv.ext
+        intro x
+        simp only [Equiv.Perm.mul_apply,Equiv.swap_apply_def]
+        split_ifs <;> rfl
+      rw [he] at hh'
+      exact hh'
+/-- Each original block has its own actual finite cyclic boundary. Empty
+blocks contribute no occurrences, rather than an artificial marked vertex. -/
+def Occ : List ℕ→Type
+  | []=>Empty
+  | n::ns=>Fin n⊕Occ ns
+instance (ns : List ℕ) : Fintype (Occ ns) := by
+  induction ns with
+  | nil=>exact inferInstanceAs (Fintype Empty)
+  | cons n ns ih=>
+    let : Fintype (Occ ns) := ih
+    exact inferInstanceAs (Fintype (Fin n⊕Occ ns))
+
+def coordinates : (ns : List ℕ)→Occ ns≃Fin ns.sum
+  | []=>@Equiv.equivOfIsEmpty Empty (Fin 0) inferInstance inferInstance
+  | _n::ns=>(Equiv.sumCongr (Equiv.refl _) (coordinates ns)).trans finSumFinEquiv
+
+def rotation : (ns : List ℕ)→Equiv.Perm (Occ ns)
+  | []=>1
+  | n::ns=>Equiv.sumCongr (finRotate n) (rotation ns)
+def full (ns : List ℕ) : Equiv.Perm (Occ ns) :=
+  (coordinates ns).symm.permCongr (finRotate ns.sum)
+/-- Split the flattened boundary at every literal word boundary. The
+matching is retained in full, including pairs joining different blocks. -/
+theorem refinement (ns : List ℕ) : Cuts (full ns) (rotation ns) := by
+  induction ns with
+  | nil=>
+    have he : full []=rotation [] := by
+      apply Equiv.ext
+      intro x
+      exact Empty.elim x
+    rw [he];exact .refl _
+  | cons n ns ih=>
+    let e : Fin n⊕Fin ns.sum≃Occ (n::ns) :=
+      Equiv.sumCongr (Equiv.refl _) (coordinates ns).symm
+    have hh := conjugate (fin_cut n ns.sum) e
+    have he₁ : e.permCongr (finSumFinEquiv.symm.permCongr (finRotate (n+ns.sum)))=
+        full (n::ns) := by
+      rfl
+    have he₂ : e.permCongr (Equiv.sumCongr (finRotate n) (finRotate ns.sum))=
+        Equiv.sumCongr (finRotate n) (full ns) := by
+      apply Equiv.ext
+      intro x
+      cases x <;> rfl
+    rw [he₁,he₂] at hh
+    exact hh.trans (right ih (finRotate n))
+variable {A : Type*} {ns : List ℕ} {inv : A→A} {label : Fin ns.sum→A}
+/-- Any actual disk word matching induces a genus-zero matching on all its
+literal blocks. This alone does not remove conjugator occurrences. -/
+theorem genusZero (d : WordPairing.Data inv label) :
+    MapEuler.GenusZero (rotation ns) ((coordinates ns).symm.permCongr d.partner) :=
+  preserves (refinement ns) _ (PermutationTransport.involutive _ _ d.involutive)
+    (MapConjugation.genusZero (coordinates ns).symm _ _ d.genusZero)
+
+end TorsionFreeZeroDivisors.BlockBoundary
+/-! Algebraic disk-picture certificates. The relator words are retained literally,
+not replaced by their reduced representatives. Connector words may be arbitrary.
+No planar-surface realization or minimal-band theorem is assumed here. -/
+namespace TorsionFreeZeroDivisors.AlgebraicPictures
+open FreeGroup
+variable {A I : Type*} (rel : I → List (A×Bool))
+
+structure Term where
+  index : I
+  positive : Bool
+  connector : List (A×Bool)
+namespace Term
+variable (t : Term (A:=A) (I:=I))
+def core : List (A×Bool) := if t.positive then rel t.index else invRev (rel t.index)
+def word : List (A×Bool) := t.connector++t.core rel++invRev t.connector
+def flip : Term (A:=A) (I:=I) := ⟨t.index,!t.positive,t.connector⟩
+lemma core_flip : t.flip.core rel=invRev (t.core rel) := by
+  cases t with
+  | mk i b c => cases b <;> simp [flip,core]
+lemma word_flip : t.flip.word rel=invRev (t.word rel) := by
+  change t.connector++t.flip.core rel++invRev t.connector=_
+  rw [core_flip]
+  simp only [word,invRev_append,invRev_invRev,List.append_assoc]
+end Term
+
+def word (ts : List (Term (A:=A) (I:=I))) : List (A×Bool) := ts.flatMap (Term.word rel)
+def relations : Set (FreeGroup A) := Set.range (fun i=>mk (rel i))
+lemma word_append (s t : List (Term (A:=A) (I:=I))) :
+    word rel (s++t)=word rel s++word rel t := List.flatMap_append
+lemma word_reverse_flip (s : List (Term (A:=A) (I:=I))) :
+    word rel (s.reverse.map Term.flip)=invRev (word rel s) := by
+  induction s with
+  | nil => rfl
+  | cons t s ih =>
+    simp only [List.reverse_cons,List.map_append,List.map_singleton,
+      word,List.flatMap_append,List.flatMap_cons,List.flatMap_nil,List.append_nil] at *
+    rw [ih,Term.word_flip,invRev_append]
+
+lemma term_mem (t : Term (A:=A) (I:=I)) :
+    mk (t.word rel)∈Subgroup.normalClosure (relations rel) := by
+  have h : mk (t.core rel)∈Subgroup.normalClosure (relations rel) := by
+    have hr : mk (rel t.index)∈Subgroup.normalClosure (relations rel) :=
+      Subgroup.subset_normalClosure ⟨t.index,rfl⟩
+    cases hb : t.positive <;> simp only [Term.core,hb,Bool.false_eq_true,ite_false,ite_true]
+    · rw [←inv_mk]
+      exact Subgroup.inv_mem _ hr
+    · exact hr
+  simpa only [Term.word,←mul_mk,←inv_mk] using
+    (Subgroup.normalClosure_normal (s:=relations rel)).conj_mem _ h (mk t.connector)
+
+lemma word_mem (s : List (Term (A:=A) (I:=I))) :
+    mk (word rel s)∈Subgroup.normalClosure (relations rel) := by
+  induction s with
+  | nil => exact Subgroup.one_mem _
+  | cons t s ih =>
+    change mk (t.word rel++word rel s)∈_
+    rw [←mul_mk]
+    exact Subgroup.mul_mem _ (term_mem rel t) ih
+
+/-- Literal normal-closure expansion, with each actual relator and its sign. -/
+theorem expansion {g : FreeGroup A} (h : g∈Subgroup.normalClosure (relations rel)) :
+    ∃ ts : List (Term (A:=A) (I:=I)),mk (word rel ts)=g := by
+  classical
+  induction h using Subgroup.closure_induction with
+  | mem g hg =>
+    obtain ⟨r,⟨i,rfl⟩,hc⟩ := Group.mem_conjugatesOfSet_iff.mp hg
+    obtain ⟨c,rfl⟩ := isConj_iff.mp hc
+    refine ⟨[⟨i,true,c.toWord⟩],?_⟩
+    simp only [word,List.flatMap_cons,List.flatMap_nil,List.append_nil,
+      Term.word,Term.core,ite_true,←mul_mk,←inv_mk,mk_toWord]
+  | one => exact ⟨[],rfl⟩
+  | mul x y _ _ hx hy =>
+    obtain ⟨s,hs⟩ := hx
+    obtain ⟨t,ht⟩ := hy
+    exact ⟨s++t,by rw [word_append,←mul_mk,hs,ht]⟩
+  | inv x _ hx =>
+    obtain ⟨s,hs⟩ := hx
+    exact ⟨s.reverse.map Term.flip,by rw [word_reverse_flip,←inv_mk,hs]⟩
+
+variable (outer : List (A×Bool))
+def cutWord (ts : List (Term (A:=A) (I:=I))) : List (A×Bool) :=
+  invRev outer++word rel ts
+
+/-- A null word in the literal quotient has an actual finite inverse-letter
+noncrossing matching after cutting along its conjugating paths. This is the
+algebraic cancellation step; it does not assert the later band reduction. -/
+theorem quotient_identity (h : PresentedGroup.mk (relations rel) (mk outer)=1) :
+    ∃ ts : List (Term (A:=A) (I:=I)),
+      Nonempty (WordPairing.Data WordPairing.inverseLetter (cutWord rel outer ts).get) := by
+  obtain ⟨ts,ht⟩ := expansion rel (PresentedGroup.mk_eq_one_iff.mp h)
+  refine ⟨ts,WordPairing.of_identity ?_⟩
+  rw [cutWord,←mul_mk,←inv_mk,ht,inv_mul_cancel]
+
+/-- The empty-relator case is not silently excluded: its boundary must itself
+be a free-group identity. -/
+lemma empty_relators (h : mk (word rel [])=mk outer) : mk outer=1 := h.symm
+
+end TorsionFreeZeroDivisors.AlgebraicPictures
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/GroupRing/CoreStripping.lean b/lean/OAI/Algebra/GroupRing/CoreStripping.lean
new file mode 100644
index 0000000000000000000000000000000000000000..eebc9722dcd8bad53fd4d5fad16c38bb10ce83a2
--- /dev/null
+++ b/lean/OAI/Algebra/GroupRing/CoreStripping.lean
@@ -0,0 +1,404 @@
+import Mathlib
+import OAI.Algebra.GroupRing.DegreeTwoSuppression
+
+namespace OAI
+
+noncomputable section
+
+namespace TorsionFreeZeroDivisors.CoreStripping
+open PortSubdivision
+open scoped Classical
+variable {V D : Type*} (Γ : PortGraph V D)
+
+def degree (S : Finset D) (v : V) : ℕ := (S.filter (fun d => Γ.origin d=v)).card
+
+def Symmetric (S : Finset D) : Prop := ∀ d ∈ S, Γ.reverse d ∈ S
+
+def delete (S : Finset D) (d : D) : Finset D := (S.erase d).erase (Γ.reverse d)
+
+lemma delete_subset (S : Finset D) (d : D) : delete Γ S d ⊆ S :=
+  (Finset.erase_subset _ _).trans (Finset.erase_subset _ _)
+
+lemma degree_pos (S : Finset D) {d : D} (hd : d∈S) : 0 < degree Γ S (Γ.origin d) := by
+  exact Finset.card_pos.mpr ⟨d,Finset.mem_filter.mpr ⟨hd,rfl⟩⟩
+
+lemma leaf_unique (S : Finset D) {d : D} (hd : d∈S) (hleaf : degree Γ S (Γ.origin d)=1)
+    {e : D} (he : e∈S) (ho : Γ.origin e=Γ.origin d) : e=d := by
+  have hu := Finset.card_eq_one.mp hleaf
+  obtain ⟨z,hz⟩ := hu
+  have hd' : d∈S.filter (fun e => Γ.origin e=Γ.origin d) := by simp [hd]
+  have he' : e∈S.filter (fun e => Γ.origin e=Γ.origin d) := by simp [he,ho]
+  rw [hz] at hd' he'
+  exact (Finset.mem_singleton.mp he').trans (Finset.mem_singleton.mp hd').symm
+
+lemma leaf_not_loop (S : Finset D) (hs : Symmetric Γ S) {d : D} (hd : d∈S)
+    (hleaf : degree Γ S (Γ.origin d)=1) : Γ.origin (Γ.reverse d)≠Γ.origin d := by
+  intro he
+  exact Γ.reverse_ne d (leaf_unique Γ S hd hleaf (hs d hd) he)
+
+lemma delete_symmetric (S : Finset D) (hs : Symmetric Γ S) (d : D) :
+    Symmetric Γ (delete Γ S d) := by
+  intro e he
+  simp only [delete,Finset.mem_erase] at he ⊢
+  refine ⟨?_,?_,hs e he.2.2⟩
+  · exact fun h => he.2.1 (Γ.reverse_reverse.injective h)
+  · intro h
+    have hh := congrArg Γ.reverse h
+    rw [Γ.reverse_reverse] at hh
+    exact he.1 hh
+
+lemma delete_degree_leaf (S : Finset D) {d : D} (hd : d∈S)
+    (hleaf : degree Γ S (Γ.origin d)=1) : degree Γ (delete Γ S d) (Γ.origin d)=0 := by
+  apply Finset.card_eq_zero.mpr
+  apply Finset.eq_empty_iff_forall_notMem.mpr
+  intro e he
+  obtain ⟨he,ho⟩ := Finset.mem_filter.mp he
+  have heq := leaf_unique Γ S hd hleaf (delete_subset Γ S d he) ho
+  exact (Finset.mem_erase.mp (Finset.mem_erase.mp he).2).1 heq
+
+lemma delete_degree_neighbor (S : Finset D) (hs : Symmetric Γ S) {d : D} (hd : d∈S)
+    (hleaf : degree Γ S (Γ.origin d)=1) :
+    degree Γ (delete Γ S d) (Γ.origin (Γ.reverse d))+1 = degree Γ S (Γ.origin (Γ.reverse d)) := by
+  have hn := leaf_not_loop Γ S hs hd hleaf
+  have he : (delete Γ S d).filter (fun e => Γ.origin e=Γ.origin (Γ.reverse d)) =
+      (S.filter (fun e => Γ.origin e=Γ.origin (Γ.reverse d))).erase (Γ.reverse d) := by
+    ext e
+    simp only [delete,Finset.mem_filter,Finset.mem_erase]
+    constructor
+    · tauto
+    · rintro ⟨he,hs',ho⟩
+      refine ⟨⟨he,?_,hs'⟩,ho⟩
+      intro hd'
+      subst e
+      exact hn ho.symm
+  unfold degree
+  rw [he]
+  exact Finset.card_erase_add_one (by simp [hs d hd])
+
+lemma delete_degree_other (S : Finset D) (d : D) {v : V}
+    (hu : v≠Γ.origin d) (hv : v≠Γ.origin (Γ.reverse d)) :
+    degree Γ (delete Γ S d) v=degree Γ S v := by
+  unfold degree
+  congr 1
+  ext e
+  simp only [delete,Finset.mem_filter,Finset.mem_erase]
+  constructor
+  · tauto
+  · rintro ⟨he,ho⟩
+    refine ⟨⟨?_,?_,he⟩,ho⟩
+    · intro hh; subst e; exact hv ho.symm
+    · intro hh; subst e; exact hu ho.symm
+
+/-- Euler surplus without counting isolated vertices. It equals the sum of
+branch excesses minus the number of leaves. -/
+def surplus (n : ℕ) : ℤ := if n=0 then 0 else (n:ℤ)-2
+
+lemma surplus_succ (n : ℕ) : surplus (n+1) ≤ surplus n+1 := by
+  rcases n with _ | n
+  · norm_num [surplus]
+  · simp only [surplus,Nat.add_eq_zero_iff,one_ne_zero,and_false,ite_false,Nat.cast_add,Nat.cast_one]
+    omega
+
+variable [Fintype V]
+
+def potential (S : Finset D) : ℤ := ∑ v, surplus (degree Γ S v)
+
+lemma delete_potential (S : Finset D) (hs : Symmetric Γ S) {d : D} (hd : d∈S)
+    (hleaf : degree Γ S (Γ.origin d)=1) : potential Γ S≤potential Γ (delete Γ S d) := by
+  have hn := leaf_not_loop Γ S hs hd hleaf
+  have hpoint (v : V) : surplus (degree Γ S v) ≤
+      surplus (degree Γ (delete Γ S d) v) + (if v=Γ.origin (Γ.reverse d) then 1 else 0) -
+        (if v=Γ.origin d then 1 else 0) := by
+    by_cases hu : v=Γ.origin d
+    · subst v
+      rw [hleaf,delete_degree_leaf Γ S hd hleaf]
+      simp [surplus,Ne.symm hn]
+    · by_cases hv : v=Γ.origin (Γ.reverse d)
+      · subst v
+        rw [← delete_degree_neighbor Γ S hs hd hleaf]
+        simpa only [ite_eq_left rfl,ite_eq_right hn,ite_true,sub_zero] using surplus_succ
+          (degree Γ (delete Γ S d) (Γ.origin (Γ.reverse d)))
+      · rw [delete_degree_other Γ S d hu hv,ite_eq_right hu,ite_eq_right hv,add_zero,sub_zero]
+  have hsum := Finset.sum_le_sum (fun v (_ : v∈Finset.univ) => hpoint v)
+  unfold potential
+  simpa only [Finset.sum_sub_distrib,Finset.sum_add_distrib,Finset.sum_ite_eq',
+    Finset.mem_univ,ite_true,add_sub_cancel_right] using hsum
+
+/-- Actual repeated leaf deletion. The terminal subgraph has minimum degree
+two on every surviving dart; Euler surplus can only increase. -/
+theorem exists_core (S : Finset D) (hs : Symmetric Γ S) :
+    ∃ Q : Finset D, Q⊆S ∧ Symmetric Γ Q ∧
+      (∀ d∈Q, 2≤degree Γ Q (Γ.origin d)) ∧ potential Γ S≤potential Γ Q := by
+  induction hn : S.card using Nat.strong_induction_on generalizing S with
+  | h n ih =>
+    by_cases hleaf : ∃ d∈S, degree Γ S (Γ.origin d)=1
+    · obtain ⟨d,hd,hleaf⟩ := hleaf
+      let S' := delete Γ S d
+      have hlt : S'.card<n := by
+        have he : S'.card≤(S.erase d).card := Finset.card_le_card (Finset.erase_subset _ _)
+        have ht := Finset.card_erase_lt_of_mem hd
+        omega
+      obtain ⟨Q,hQS,hQ,hdeg,hpot⟩ := ih S'.card hlt S' (delete_symmetric Γ S hs d) rfl
+      exact ⟨Q,hQS.trans (delete_subset Γ S d),hQ,hdeg,
+        (delete_potential Γ S hs hd hleaf).trans hpot⟩
+    · refine ⟨S,Finset.Subset.refl _,hs,?_,le_refl _⟩
+      intro d hd
+      have hp := degree_pos Γ S hd
+      have hn : degree Γ S (Γ.origin d)≠1 := by aesop
+      omega
+
+end TorsionFreeZeroDivisors.CoreStripping
+
+namespace TorsionFreeZeroDivisors.ImageComplexity
+open PortSubdivision WeightedPortMoore WeightedCycles CoreStripping
+open scoped BigOperators Classical
+variable {V D : Type} [Fintype V] [Fintype D] (Γ : PortGraph V D)
+
+/-- The actual symmetric subgraph on a specified set of original darts. -/
+def restrict (Q : Finset D) (hs : Symmetric Γ Q) : PortGraph V Q where
+  origin d := Γ.origin d
+  reverse d := ⟨Γ.reverse d,hs d d.property⟩
+  reverse_reverse d := Subtype.ext (Γ.reverse_reverse d)
+  reverse_ne d h := Γ.reverse_ne d (congrArg Subtype.val h)
+
+def inclusion (Q : Finset D) (hs : Symmetric Γ Q) :
+    (restrict Γ Q hs).subdivision →g Γ.subdivision where
+  toFun := Sum.map id Subtype.val
+  map_rel' := by
+    intro a b h
+    rcases a with a|a <;> rcases b with b|b
+    · exact h
+    · exact h
+    · exact h
+    · exact congrArg Subtype.val h
+
+omit [Fintype V] [Fintype D] in
+lemma inclusion_injective (Q : Finset D) (hs : Symmetric Γ Q) :
+    Function.Injective (inclusion Γ Q hs) := Sum.map_injective.mpr ⟨Function.injective_id,Subtype.val_injective⟩
+
+omit [Fintype V] [Fintype D] in
+lemma restrict_degree (Q : Finset D) (hs : Symmetric Γ Q) (v : V) :
+    (DegreeTwoSuppression.out (restrict Γ Q hs).origin v).card=degree Γ Q v := by
+  classical
+  unfold DegreeTwoSuppression.out degree
+  apply Finset.card_bij (fun d _ => d.val)
+  · intro d hd
+    exact Finset.mem_filter.mpr ⟨d.property,(Finset.mem_filter.mp hd).2⟩
+  · intro a _ b _ h
+    exact Subtype.ext h
+  · intro d hd
+    refine ⟨⟨d,(Finset.mem_filter.mp hd).1⟩,?_,rfl⟩
+    simp only [Finset.mem_filter,Finset.mem_univ,true_and]
+    exact (Finset.mem_filter.mp hd).2
+
+omit [Fintype V] [Fintype D] in
+lemma inclusion_weight (Q : Finset D) (hs : Symmetric Γ Q) {a b : V ⊕ Q}
+    (p : (restrict Γ Q hs).subdivision.Walk a b) :
+    weight (edgeWeight (fun _ : D => (1:ℝ))) (p.map (inclusion Γ Q hs)) =
+      weight (edgeWeight (fun _ : Q => (1:ℝ))) p := by
+  induction p with
+  | nil => rfl
+  | @cons a b c h p ih =>
+    rw [SimpleGraph.Walk.map_cons,weight_cons,weight_cons,ih]
+    congr 1
+    cases a <;> cases b <;> rfl
+
+omit [Fintype D] in
+/-- Vertexwise counting, including loops through their two different darts. -/
+lemma fiber_count (S : Finset D) (P : V → Prop) [DecidablePred P] :
+    ∑ v, (if P v then degree Γ S v else 0) = (S.filter (fun d => P (Γ.origin d))).card := by
+  classical
+  unfold degree
+  simp only [Finset.card_eq_sum_ones,Finset.sum_filter]
+  trans ∑ v, ∑ d ∈ S, if Γ.origin d=v ∧ P v then 1 else 0
+  · apply Finset.sum_congr rfl
+    intro v hv
+    by_cases hh : P v <;> simp [hh]
+  rw [Finset.sum_comm]
+  apply Finset.sum_congr rfl
+  intro d hd
+  simp [ite_and]
+
+lemma surplus_excess (n : ℕ) : surplus n = ((n-2:ℕ):ℤ) - (if n=1 then 1 else 0) := by
+  unfold surplus
+  split_ifs <;> omega
+
+lemma surplus_le_branch (n : ℕ) : surplus n ≤ (if n=2 then (0:ℕ) else n) := by
+  unfold surplus
+  split_ifs <;> omega
+
+omit [Fintype D] in
+lemma excess_le_potential_add_leaves (S : Finset D) :
+    ((∑ v, (degree Γ S v - 2) : ℕ):ℤ) ≤ potential Γ S +
+      ((Finset.univ.filter (fun v => degree Γ S v=1)).card:ℤ) := by
+  unfold potential
+  simp only [surplus_excess,Finset.sum_sub_distrib,Nat.cast_sum]
+  have he : (∑ v : V, (if degree Γ S v=1 then (1:ℤ) else 0)) =
+      ((Finset.univ.filter (fun v => degree Γ S v=1)).card:ℤ) := by simp
+  rw [he]
+  omega
+
+omit [Fintype D] in
+lemma branch_degrees_bound_excess (S : Finset D) :
+    (S.filter (fun d => 3 ≤ degree Γ S (Γ.origin d))).card ≤
+      3 * (∑ v, (degree Γ S v - 2)) := by
+  rw [← fiber_count Γ S (fun v => 3 ≤ degree Γ S v),Finset.mul_sum]
+  apply Finset.sum_le_sum
+  intro v hv
+  split_ifs <;> omega
+
+/-- Bounded branching in the actual image, not in a hypothesized bounded-rank
+pattern. A bounded number of leaves is the only endpoint correction. -/
+theorem bounded_image_branches (C : ℝ) (hC : 0 ≤ C) (leaves : ℕ) :
+    ∃ R : ℕ, ∀ {V D : Type} [Fintype V] [Fintype D] (Γ : PortGraph V D)
+      (L : ℝ) (_ : 0 < L)
+      (_ : (Fintype.card D:ℝ) ≤ 2*C*L)
+      (_ : ∀ a (c : Γ.subdivision.Walk a a), c.IsCycle →
+        L ≤ weight (edgeWeight (fun _ : D => (1:ℝ))) c)
+      (_ : (Finset.univ.filter (fun v => degree Γ Finset.univ v=1)).card ≤ leaves),
+      (Finset.univ.filter (fun d => 3≤degree Γ Finset.univ (Γ.origin d))).card ≤ R := by
+  obtain ⟨R,hR⟩ := SuppressedMoore.bounded_branch_ports C hC
+  refine ⟨3*(R+leaves),?_⟩
+  intro V D _ _ Γ L hL htot hg hl
+  obtain ⟨Q,_hQ,hs,hmin,hpot⟩ := exists_core Γ Finset.univ (by simp [CoreStripping.Symmetric])
+  have hsub : (Fintype.card Q:ℝ)≤2*C*L := by
+    exact (Nat.cast_le.mpr (by simpa using Finset.card_le_univ Q)).trans htot
+  have hbound := hR (restrict Γ Q hs) (fun d => by
+    rw [restrict_degree]; exact hmin d d.property) L hL hsub (by
+      intro a c hc
+      have hp := hg _ (c.map (inclusion Γ Q hs)) (hc.map (inclusion_injective Γ Q hs))
+      rwa [inclusion_weight] at hp)
+  have hc : (Q.filter (fun d => degree Γ Q (Γ.origin d)≠2)).card≤R := by
+    have he : (Finset.univ.filter (fun d : Q =>
+        (DegreeTwoSuppression.out (restrict Γ Q hs).origin ((restrict Γ Q hs).origin d)).card≠2)).card =
+        (Q.filter (fun d => degree Γ Q (Γ.origin d)≠2)).card := by
+      simp only [restrict_degree]
+      apply Finset.card_bij (fun d _ => d.val)
+      · intro d hd; exact Finset.mem_filter.mpr ⟨d.property,(Finset.mem_filter.mp hd).2⟩
+      · intro a _ b _ h; exact Subtype.ext h
+      · intro d hd
+        exact ⟨⟨d,(Finset.mem_filter.mp hd).1⟩,Finset.mem_filter.mpr ⟨Finset.mem_univ _,(Finset.mem_filter.mp hd).2⟩,rfl⟩
+    rwa [he] at hbound
+  have hpQ : potential Γ Q ≤ (R:ℤ) := by
+    calc potential Γ Q ≤ ((∑ v : V, (if degree Γ Q v≠2 then degree Γ Q v else 0)):ℕ) := by
+          rw [Nat.cast_sum]
+          unfold potential
+          apply Finset.sum_le_sum
+          intro v hv
+          simpa only [ite_not] using surplus_le_branch (degree Γ Q v)
+      _ = ((Q.filter (fun d => degree Γ Q (Γ.origin d)≠2)).card:ℤ) := by
+          rw [fiber_count]
+      _ ≤ R := by exact_mod_cast hc
+  have hex := excess_le_potential_add_leaves Γ Finset.univ
+  have hle : (∑ v, (degree Γ Finset.univ v - 2))≤R+leaves := by
+    have hl' : ((Finset.univ.filter (fun v => degree Γ Finset.univ v=1)).card:ℤ)≤leaves := by
+      exact_mod_cast hl
+    have hh : (((∑ v, (degree Γ Finset.univ v - 2)):ℕ):ℤ)≤(R:ℤ)+leaves := by omega
+    exact_mod_cast hh
+  exact (branch_degrees_bound_excess Γ Finset.univ).trans (Nat.mul_le_mul_left 3 hle)
+
+end TorsionFreeZeroDivisors.ImageComplexity
+
+namespace TorsionFreeZeroDivisors.SystemLeaves
+open SimpleGraph PortSubdivision
+open scoped Classical
+variable {W : Type*} {G : SimpleGraph W}
+
+/-- The combinatorial leaf condition, stated without assuming local finiteness. -/
+def AtMostOneNeighbor (x : W) : Prop := ∀ a b, G.Adj x a → G.Adj x b → a=b
+
+lemma leaf_in_reduced_walk {a b x : W} (p : G.Walk a b)
+    (hr : p.edges.IsChain (· ≠ ·)) (hx : AtMostOneNeighbor (G := G) x)
+    (hm : x∈p.support) : x=a ∨ x=b := by
+  induction p with
+  | nil => exact Or.inl (by simpa using hm)
+  | @cons a c b h p ih =>
+    by_cases he : x=a
+    · exact Or.inl he
+    have hm' : x∈p.support := by simpa only [Walk.support_cons,List.mem_cons,he,false_or] using hm
+    have htail := (List.isChain_cons.mp hr).2
+    rcases ih htail hm' with hec | heb
+    · subst x
+      cases p with
+      | nil => exact Or.inr rfl
+      | @cons c d b h' p =>
+        have hda : d=a := hx d a h' h.symm
+        subst d
+        have hh := (List.isChain_cons_cons.mp hr).1
+        exact False.elim (hh (Sym2.eq_swap))
+    · exact Or.inr heb
+
+/-- Including the closing turn, not just linear immersion. -/
+def CyclicallyReduced {a : W} (p : G.Walk a a) : Prop :=
+  p.edges.IsChain (· ≠ ·) ∧ (¬p.Nil → s(a,p.snd) ≠ s(p.penultimate,a))
+
+lemma leaf_not_in_cyclic {a x : W} (p : G.Walk a a)
+    (hr : CyclicallyReduced p) (hne : ¬p.Nil)
+    (hx : AtMostOneNeighbor (G := G) x) : x∉p.support := by
+  intro hm
+  have he : x=a := (leaf_in_reduced_walk p hr.1 hx hm).elim id id
+  subst x
+  have heq : p.snd=p.penultimate := hx _ _ (p.adj_snd hne) (p.adj_penultimate hne).symm
+  exact hr.2 hne (by rw [heq,Sym2.eq_swap])
+
+variable {V D : Type*} [Fintype D] (Γ : PortGraph V D)
+
+def degree (v : V) : ℕ := (Finset.univ.filter (fun d => Γ.origin d=v)).card
+
+lemma leaf_original (v : V) (hv : degree Γ v=1) :
+    AtMostOneNeighbor (G := Γ.subdivision) (.inl v) := by
+  intro a b ha hb
+  rcases a with a|a <;> rcases b with b|b
+  · exact False.elim ha
+  · exact False.elim ha
+  · exact False.elim hb
+  · have hsingle := Finset.card_eq_one.mp hv
+    obtain ⟨d,hd⟩ := hsingle
+    have ha' : a∈Finset.univ.filter (fun e => Γ.origin e=v) := Finset.mem_filter.mpr ⟨Finset.mem_univ _,ha⟩
+    have hb' : b∈Finset.univ.filter (fun e => Γ.origin e=v) := Finset.mem_filter.mpr ⟨Finset.mem_univ _,hb⟩
+    rw [hd] at ha' hb'
+    exact congrArg Sum.inr ((Finset.mem_singleton.mp ha').trans (Finset.mem_singleton.mp hb').symm)
+
+/-- In the actual image of any number of cyclically immersed closed walks and
+one immersed interval, every leaf is an endpoint of that interval. -/
+lemma actual_image_leaf_endpoints {J : Type*} (base : J → V)
+    (loops : ∀ j, Γ.subdivision.Walk (.inl (base j)) (.inl (base j)))
+    (hloops : ∀ j, CyclicallyReduced (loops j)) (hne : ∀ j, ¬(loops j).Nil)
+    {a b : V} (p : Γ.subdivision.Walk (.inl a) (.inl b))
+    (hp : p.edges.IsChain (· ≠ ·))
+    (himage : ∀ d : D, Sum.inl (Γ.origin d)∈p.support ∨
+      ∃ j, Sum.inl (Γ.origin d)∈(loops j).support)
+    (v : V) (hv : degree Γ v=1) : v=a ∨ v=b := by
+  have hpos : 0<(Finset.univ.filter (fun d => Γ.origin d=v)).card := by rw [← degree,hv]; decide
+  obtain ⟨d,hd⟩ := Finset.card_pos.mp hpos
+  have ho := (Finset.mem_filter.mp hd).2
+  have hi := himage d
+  rw [ho] at hi
+  rcases hi with hi | ⟨j,hj⟩
+  · have hh := leaf_in_reduced_walk p hp (leaf_original Γ v hv) hi
+    exact hh.imp Sum.inl.inj Sum.inl.inj
+  · exact False.elim (leaf_not_in_cyclic (loops j) (hloops j) (hne j) (leaf_original Γ v hv) hj)
+
+variable [Fintype V]
+
+lemma actual_image_at_most_two_leaves {J : Type*} (base : J → V)
+    (loops : ∀ j, Γ.subdivision.Walk (.inl (base j)) (.inl (base j)))
+    (hloops : ∀ j, CyclicallyReduced (loops j)) (hne : ∀ j, ¬(loops j).Nil)
+    {a b : V} (p : Γ.subdivision.Walk (.inl a) (.inl b))
+    (hp : p.edges.IsChain (· ≠ ·))
+    (himage : ∀ d : D, Sum.inl (Γ.origin d)∈p.support ∨
+      ∃ j, Sum.inl (Γ.origin d)∈(loops j).support) :
+    (Finset.univ.filter (fun v => degree Γ v=1)).card≤2 := by
+  classical
+  calc (Finset.univ.filter (fun v => degree Γ v=1)).card ≤ ({a,b}:Finset V).card := by
+        apply Finset.card_le_card
+        intro v hv
+        simpa only [Finset.mem_insert,Finset.mem_singleton] using
+          actual_image_leaf_endpoints Γ base loops hloops hne p hp himage v (Finset.mem_filter.mp hv).2
+    _ ≤ 2 := (Finset.card_insert_le a {b}).trans (by simp)
+
+end TorsionFreeZeroDivisors.SystemLeaves
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/GroupRing/CycleLists.lean b/lean/OAI/Algebra/GroupRing/CycleLists.lean
new file mode 100644
index 0000000000000000000000000000000000000000..c4a33f027b93898658e953d29cea87a716fabb0d
--- /dev/null
+++ b/lean/OAI/Algebra/GroupRing/CycleLists.lean
@@ -0,0 +1,357 @@
+import Mathlib
+import OAI.Algebra.GroupRing.ClosedWords
+
+namespace OAI
+
+noncomputable section
+
+namespace TorsionFreeZeroDivisors.CycleLists
+open scoped Classical
+open PermutationCycles
+variable {O : Type} [Fintype O] (f : Equiv.Perm O)
+def orbit (x : O) : List O := if f x=x then [x] else f.toList x
+lemma mem_orbit {x y : O} : y∈orbit f x ↔ f.SameCycle x y := by
+  by_cases hx : f x=x
+  · simp only [orbit,ite_eq_left hx,List.mem_singleton]
+    exact ⟨fun h=>h.symm.sameCycle f,fun h=>(h.eq_of_left hx).symm⟩
+  · rw [orbit,ite_eq_right hx,Equiv.Perm.mem_toList_iff]
+    exact and_iff_left (Equiv.Perm.mem_support.mpr hx)
+lemma orbit_nonempty (x : O) : orbit f x≠[] :=
+  List.ne_nil_of_mem ((mem_orbit f).mpr (Equiv.Perm.SameCycle.refl f x))
+lemma orbit_nodup (x : O) : (orbit f x).Nodup := by
+  by_cases hx : f x=x
+  · simp only [orbit,ite_eq_left hx,List.nodup_singleton]
+  · rw [orbit,ite_eq_right hx]
+    exact f.nodup_toList x
+lemma orbit_head (x : O) : (orbit f x).head (orbit_nonempty f x)=x := by
+  by_cases hx : f x=x
+  · simp only [orbit,ite_eq_left hx,List.head_cons]
+  · simpa only [orbit,ite_eq_right hx,List.head_eq_getElem] using
+      f.toList_getElem_zero x (Equiv.Perm.mem_support.mpr hx)
+lemma orbit_next {x y : O} (hy : y∈orbit f x) : (orbit f x).next y hy=f y := by
+  by_cases hx : f x=x
+  · have he : y=x := by simpa only [orbit,ite_eq_left hx,List.mem_singleton] using hy
+    subst y
+    simp [orbit,hx]
+  · simpa only [orbit,ite_eq_right hx] using f.next_toList_eq_apply x y
+      (by simpa only [orbit,ite_eq_right hx] using hy)
+lemma orbit_rotate (x : O) (i : Fin (orbit f x).length) :
+    (orbit f x)[(finRotate (orbit f x).length i).val]=f ((orbit f x)[i.val]) := by
+  have h := orbit_next f (List.getElem_mem i.isLt)
+  rw [List.next_getElem _ (orbit_nodup f x)] at h
+  have hv : (finRotate (orbit f x).length i).val=(i.val+1)%(orbit f x).length := by
+    let _ := i.neZero
+    rw [finRotate_apply,Fin.val_add,Fin.val_one',Nat.add_mod_mod]
+  simpa only [hv] using h
+lemma orbit_succ (x : O) (i : ℕ) (hi : i+1<(orbit f x).length) :
+    f ((orbit f x)[i])=(orbit f x)[i+1] := by
+  have h := orbit_next f (List.getElem_mem (by omega : i<(orbit f x).length))
+  rw [List.next_getElem _ (orbit_nodup f x)] at h
+  simpa only [Nat.mod_eq_of_lt hi] using h.symm
+lemma orbit_last (x : O) :
+    f ((orbit f x).getLast (orbit_nonempty f x))=(orbit f x).head (orbit_nonempty f x) := by
+  exact (orbit_next f (List.getLast_mem (orbit_nonempty f x))).symm.trans
+    (List.next_getLast_eq_head (orbit f x) (orbit_nonempty f x) (orbit_nodup f x))
+variable (rep : Cycle f→O) (hrep : ∀c,cycle f (rep c)=c)
+def words (c : Cycle f) : List O := orbit f (rep c)
+def atIndex (p : Σc : Cycle f,Fin (words f rep c).length) : O := (words f rep p.1)[p.2.val]
+include hrep in
+lemma atIndex_cycle (p : Σc : Cycle f,Fin (words f rep c).length) :
+    cycle f (atIndex f rep p)=p.1 := by
+  have hm : atIndex f rep p∈orbit f (rep p.1) := List.getElem_mem p.2.isLt
+  exact ((cycle_eq f).mpr ((mem_orbit f).mp hm)).symm.trans (hrep p.1)
+include hrep in
+lemma atIndex_bijective : Function.Bijective (atIndex f rep) := by
+  constructor
+  · rintro ⟨c,i⟩ ⟨d,j⟩ he
+    have hd : c=d := (atIndex_cycle f rep hrep ⟨c,i⟩).symm.trans
+      ((congrArg (cycle f) he).trans (atIndex_cycle f rep hrep ⟨d,j⟩))
+    subst d
+    have hi : i=j := (List.nodup_iff_injective_getElem.mp (orbit_nodup f (rep c))) he
+    subst j
+    rfl
+  · intro x
+    let c := cycle f x
+    have hx : x∈words f rep c := (mem_orbit f).mpr ((cycle_eq f).mp (hrep c))
+    obtain ⟨i,hi,he⟩ := List.mem_iff_getElem.mp hx
+    exact ⟨⟨c,⟨i,hi⟩⟩,he⟩
+def coordinates : (Σc : Cycle f,Fin (words f rep c).length)≃O :=
+  Equiv.ofBijective (atIndex f rep) (atIndex_bijective f rep hrep)
+lemma atIndex_rotate (c : Cycle f) (i : Fin (words f rep c).length) :
+    atIndex f rep ⟨c,finRotate (words f rep c).length i⟩=f (atIndex f rep ⟨c,i⟩) :=
+  orbit_rotate f (rep c) i
+lemma coordinates_rotate (c : Cycle f) (i : Fin (words f rep c).length) :
+    coordinates f rep hrep ⟨c,finRotate (words f rep c).length i⟩=
+      f (coordinates f rep hrep ⟨c,i⟩) := atIndex_rotate f rep c i
+/-- Prescribe the representative of one root cycle without disturbing others. -/
+def rootedRep (z : O) (c : Cycle f) : O := if c=cycle f z then z else Quotient.out c
+omit [Fintype O] in
+lemma rootedRep_cycle (z : O) (c : Cycle f) : cycle f (rootedRep f z c)=c := by
+  by_cases hc : c=cycle f z
+  · simp only [rootedRep,ite_eq_left hc];exact hc.symm
+  · rw [rootedRep,ite_eq_right hc]
+    exact Quotient.out_eq c
+omit [Fintype O] in
+lemma rootedRep_root (z : O) : rootedRep f z (cycle f z)=z := by simp [rootedRep]
+end TorsionFreeZeroDivisors.CycleLists
+
+namespace TorsionFreeZeroDivisors.FinitePicture.Data
+open scoped Classical
+open PermutationCycles CycleLists
+variable {V D A O : Type} [Fintype O] {Γ : PortSubdivision.PortGraph V D}
+  {label : D→A} {inv : A→A} {x y : V} (a : Data (O:=O) Γ label inv x y) (hxy : x≠y)
+def rootCycle : Cycle a.closedRotation := cycle a.closedRotation (a.first hxy)
+def boundaryRep : Cycle a.closedRotation→a.Occ := rootedRep a.closedRotation (a.first hxy)
+def occurrences (c : Cycle a.closedRotation) : List a.Occ := orbit a.closedRotation (a.boundaryRep hxy c)
+def paths (c : Cycle a.closedRotation) : List D := (a.occurrences hxy c).map a.edge
+lemma occurrences_nonempty (c : Cycle a.closedRotation) : a.occurrences hxy c≠[] := orbit_nonempty _ _
+lemma occurrences_nodup (c : Cycle a.closedRotation) : (a.occurrences hxy c).Nodup := orbit_nodup _ _
+lemma paths_nonempty (c : Cycle a.closedRotation) : a.paths hxy c≠[] := by
+  intro he
+  exact a.occurrences_nonempty hxy c (List.map_eq_nil_iff.mp he)
+lemma paths_length (c : Cycle a.closedRotation) : (a.paths hxy c).length=(a.occurrences hxy c).length := List.length_map _
+lemma occurrences_cycle {c : Cycle a.closedRotation} {i : a.Occ} (hi : i∈a.occurrences hxy c) :
+    cycle a.closedRotation i=c := by
+  have hh := (mem_orbit a.closedRotation).mp hi
+  exact ((cycle_eq _).mpr hh).symm.trans (rootedRep_cycle _ _ c)
+lemma occurrences_root_head : (a.occurrences hxy (a.rootCycle hxy)).head (a.occurrences_nonempty hxy _) =a.first hxy := by
+  change (orbit a.closedRotation (a.boundaryRep hxy (a.rootCycle hxy))).head _=a.first hxy
+  rw [orbit_head]
+  exact rootedRep_root _ _
+lemma root_occurrence_position {c : Cycle a.closedRotation} (i : Fin (a.occurrences hxy c).length)
+    (hi : (a.occurrences hxy c)[i.val]=a.first hxy) : c=a.rootCycle hxy ∧ i.val=0 := by
+  have hc : c=a.rootCycle hxy := (a.occurrences_cycle hxy (List.getElem_mem i.isLt)).symm.trans
+    (congrArg (cycle a.closedRotation) hi)
+  subst c
+  have hp : 0<(a.occurrences hxy (a.rootCycle hxy)).length := List.length_pos_iff.mpr (a.occurrences_nonempty hxy _)
+  have hz : (a.occurrences hxy (a.rootCycle hxy))[0]=a.first hxy := by
+    simpa only [List.head_eq_getElem] using a.occurrences_root_head hxy
+  have he : i=⟨0,hp⟩ := (List.nodup_iff_injective_getElem.mp (a.occurrences_nodup hxy _)) (hi.trans hz.symm)
+  exact ⟨rfl,congrArg Fin.val he⟩
+lemma occurrences_succ {c : Cycle a.closedRotation} (i : ℕ) (hi : i+1<(a.occurrences hxy c).length) :
+    a.closedRotation ((a.occurrences hxy c)[i])=(a.occurrences hxy c)[i+1] := orbit_succ _ _ _ hi
+lemma occurrences_succ_ne_first {c : Cycle a.closedRotation} (i : ℕ) (hi : i+1<(a.occurrences hxy c).length) :
+    a.closedRotation ((a.occurrences hxy c)[i])≠a.first hxy := by
+  rw [a.occurrences_succ hxy i hi]
+  intro he
+  have hh := (a.root_occurrence_position hxy ⟨i+1,hi⟩ he).2
+  simp only at hh
+  omega
+lemma occurrences_last (c : Cycle a.closedRotation) :
+    a.closedRotation ((a.occurrences hxy c).getLast (a.occurrences_nonempty hxy c))=
+      (a.occurrences hxy c).head (a.occurrences_nonempty hxy c) := orbit_last _ _
+lemma ordinary_last_ne_first (c : Cycle a.closedRotation) (hc : c≠a.rootCycle hxy) :
+    a.closedRotation ((a.occurrences hxy c).getLast (a.occurrences_nonempty hxy c))≠a.first hxy := by
+  intro he
+  apply hc
+  have hm : a.closedRotation ((a.occurrences hxy c).getLast (a.occurrences_nonempty hxy c))∈a.occurrences hxy c := by
+    rw [a.occurrences_last hxy c]
+    exact List.head_mem _
+  exact (a.occurrences_cycle hxy hm).symm.trans (congrArg (cycle a.closedRotation) he)
+variable (hr : a.Reduced)
+include hr in
+lemma paths_chain (c : Cycle a.closedRotation) : (a.paths hxy c).IsChain
+    (fun d e=>Γ.origin (Γ.reverse d)=Γ.origin e ∧ e≠Γ.reverse d) := by
+  rw [paths,List.isChain_map,List.isChain_iff_getElem]
+  intro i hi
+  have hn := a.occurrences_succ_ne_first hxy i hi
+  have hh := a.edge_consistent hxy ((a.occurrences hxy c)[i]) hn
+  have hb := a.edge_no_backtrack hxy hr ((a.occurrences hxy c)[i]) hn
+  rw [a.occurrences_succ hxy i hi] at hh hb
+  exact ⟨hh,hb⟩
+include hr in
+lemma paths_closed (c : Cycle a.closedRotation) (hc : c≠a.rootCycle hxy) :
+    Γ.origin (Γ.reverse ((a.paths hxy c).getLast (a.paths_nonempty hxy c)))=
+      Γ.origin ((a.paths hxy c).head (a.paths_nonempty hxy c)) ∧
+    (a.paths hxy c).head (a.paths_nonempty hxy c)≠
+      Γ.reverse ((a.paths hxy c).getLast (a.paths_nonempty hxy c)) := by
+  have hn := a.ordinary_last_ne_first hxy c hc
+  have hh := a.edge_consistent hxy ((a.occurrences hxy c).getLast (a.occurrences_nonempty hxy c)) hn
+  have hb := a.edge_no_backtrack hxy hr ((a.occurrences hxy c).getLast (a.occurrences_nonempty hxy c)) hn
+  rw [a.occurrences_last hxy c] at hh hb
+  simpa only [paths,List.head_map,List.getLast_map] using And.intro hh hb
+lemma paths_root_begins : Γ.origin ((a.paths hxy (a.rootCycle hxy)).head (a.paths_nonempty hxy _))=x := by
+  simpa only [paths,List.head_map,a.occurrences_root_head hxy] using a.first_start hxy
+lemma paths_root_ends : Γ.origin (Γ.reverse ((a.paths hxy (a.rootCycle hxy)).getLast (a.paths_nonempty hxy _)))=y := by
+  simp only [paths,List.getLast_map]
+  apply a.last_end hxy
+  rw [a.occurrences_last hxy,a.occurrences_root_head hxy]
+/-- Every literal boundary position is exactly one surviving picture occurrence. -/
+def pathCoordinates : (Σ c : Cycle a.closedRotation,Fin (a.paths hxy c).length)≃a.Occ :=
+  (Equiv.sigmaCongrRight fun c=>finCongr (a.paths_length hxy c)).trans
+    (coordinates a.closedRotation (a.boundaryRep hxy) (rootedRep_cycle _ _))
+lemma pathCoordinates_apply (p : Σ c : Cycle a.closedRotation,Fin (a.paths hxy c).length) :
+    a.pathCoordinates hxy p=(a.occurrences hxy p.1)[p.2.val]'(by simpa only [a.paths_length] using p.2.isLt) := rfl
+lemma paths_dart (p : Σ c : Cycle a.closedRotation,Fin (a.paths hxy c).length) :
+    (a.paths hxy p.1)[p.2.val]=a.edge (a.pathCoordinates hxy p) := by
+  rw [a.pathCoordinates_apply hxy p]
+  exact List.getElem_map _
+lemma pathCoordinates_rotate (c : Cycle a.closedRotation) (i : Fin (a.paths hxy c).length) :
+    a.pathCoordinates hxy ⟨c,finRotate (a.paths hxy c).length i⟩=
+      a.closedRotation (a.pathCoordinates hxy ⟨c,i⟩) := by
+  simp only [pathCoordinates_apply]
+  have hh := orbit_rotate a.closedRotation (a.boundaryRep hxy c)
+    (finCongr (a.paths_length hxy c) i)
+  have commute : ∀ {n m : ℕ} (h : n=m) (i : Fin n),
+      finCongr h (finRotate n i)=finRotate m (finCongr h i) := by
+    intro n m h i
+    subst m
+    rfl
+  exact (congrArg (fun j : Fin (a.occurrences hxy c).length=>(a.occurrences hxy c)[j.val])
+    (commute (a.paths_length hxy c) i)).trans hh
+end TorsionFreeZeroDivisors.FinitePicture.Data
+
+namespace TorsionFreeZeroDivisors.ComparedBlocks.Comparisons
+open scoped Classical
+open BlockAlignment
+def empty {T : Type} (len : T→ℕ) : Comparisons (E:=Empty) len where
+  pairing := ⟨id,fun _=>rfl⟩
+  side := fun _=>none
+  flip := Empty.elim
+  flip_inv := fun e=>Empty.elim e
+  flip_ne := fun e=>Empty.elim e
+  side_partner := fun _ e=>Empty.elim e
+  none_iff := fun _=>⟨fun _=>rfl,fun _=>rfl⟩
+  source := Empty.elim
+  lo := Empty.elim
+  hi := Empty.elim
+  reverse := Empty.elim
+  offset := Empty.elim
+  side_iff := fun _ e=>Empty.elim e
+  partner_source := fun _ e=>Empty.elim e
+  partner_coordinate := fun _ e=>Empty.elim e
+  target_range := fun e=>Empty.elim e
+end TorsionFreeZeroDivisors.ComparedBlocks.Comparisons
+namespace TorsionFreeZeroDivisors.SampleGraph.Picture
+open scoped Classical
+open BlockAlignment ComparedBlocks WordPositions PermutationCycles
+variable {rep : ℕ} {r : ActualPatternEvent.Match rep} {x : VA rep} {y : VB rep} {z w : VA rep⊕VB rep}
+  {O : Type} [Fintype O]
+  (a : FinitePicture.Data (O:=O) (graph rep r) (label rep) Types.inverse z w)
+  (hzw : z≠w) (hr : a.Reduced) (hz : z=Sum.inl x ∨ z=Sum.inr y)
+def system : PathSystem rep r x y where
+  P := Cycle a.closedRotation
+  E := Empty
+  paths := a.paths hzw
+  nonempty := a.paths_nonempty hzw
+  root := some (a.rootCycle hzw)
+  path_chain := a.paths_chain hzw hr
+  cyclic_chain c hc := by
+    have hd : c≠a.rootCycle hzw := by
+      have hc' := hc
+      simp only [StageRoot.cyclic,decide_eq_true_eq] at hc'
+      exact fun he=>hc' (congrArg some he.symm)
+    intro d hd' e he
+    rw [List.getLast?_eq_some_getLast (a.paths_nonempty hzw c)] at hd'
+    rw [Option.mem_some] at hd'
+    rw [List.head?_eq_some_head (a.paths_nonempty hzw c)] at he
+    rw [Option.mem_some] at he
+    subst d
+    subst e
+    exact a.paths_closed hzw hr c hd
+  comparisons := Comparisons.empty _
+  lower := Empty.elim
+  upper := Empty.elim
+  lower_eq := fun e=>Empty.elim e
+  upper_eq := fun e=>Empty.elim e
+  lower_le := fun e=>Empty.elim e
+  upper_le := fun e=>Empty.elim e
+  reduced := fun _ e=>Empty.elim e
+  rootA q hq := by
+    have he : z=Sum.inl q := by
+      simpa only [Option.map_some,a.paths_root_begins hzw,Option.some.injEq] using hq
+    rcases hz with ha|hb
+    · exact Sum.inl.inj (he.symm.trans ha)
+    · exact False.elim (Sum.inl_ne_inr (he.symm.trans hb))
+  rootB q hq := by
+    have he : z=Sum.inr q := by
+      simpa only [Option.map_some,a.paths_root_begins hzw,Option.some.injEq] using hq
+    rcases hz with ha|hb
+    · exact False.elim (Sum.inr_ne_inl (he.symm.trans ha))
+    · exact Sum.inr.inj (he.symm.trans hb)
+  compatible := fun _ e=>Empty.elim e
+
+def coordinates : Position (fun c=>(a.paths hzw c).length)≃a.Occ :=
+  (WordPositions.fin _).trans (a.pathCoordinates hzw)
+lemma dart (p : Position (fun c=>(a.paths hzw c).length)) :
+    RawDecomposition.dart (a.paths hzw) p=a.edge (coordinates a hzw p) := by
+  rw [←(WordPositions.fin _).symm_apply_apply p,WordPositions.dart_fin]
+  exact a.paths_dart hzw _
+lemma rotation (p : Position (fun c=>(a.paths hzw c).length)) :
+    coordinates a hzw (BoundaryRotation.perm (fun c=>(a.paths hzw c).length) p)=
+      a.closedRotation (coordinates a hzw p) := by
+  generalize he : (WordPositions.fin (fun c=>(a.paths hzw c).length)) p=q
+  have hp : p=(WordPositions.fin _).symm q := by rw [←he,Equiv.symm_apply_apply]
+  rw [hp]
+  rcases q with ⟨c,i⟩
+  rw [BoundaryRotation.apply_fin]
+  simp only [coordinates,Equiv.trans_apply,Equiv.apply_symm_apply]
+  exact a.pathCoordinates_rotate hzw c i
+
+lemma partner_compatible (p : Position (fun c=>(a.paths hzw c).length)) :
+    label rep (RawDecomposition.dart (a.paths hzw) ((coordinates a hzw).symm.permCongr a.fullPartner p))=
+      Types.inverse (label rep (RawDecomposition.dart (a.paths hzw) p)) := by
+  rw [dart,dart]
+  simp only [Equiv.permCongr_apply,Equiv.symm_symm,Equiv.apply_symm_apply]
+  exact a.edge_compatible _
+include hr in
+lemma partner_reduced (p : Position (fun c=>(a.paths hzw c).length)) :
+    RawDecomposition.dart (a.paths hzw) p≠RawDecomposition.dart (a.paths hzw) ((coordinates a hzw).symm.permCongr a.fullPartner p) ∧
+    RawDecomposition.dart (a.paths hzw) p≠(graph rep r).reverse (RawDecomposition.dart (a.paths hzw) ((coordinates a hzw).symm.permCongr a.fullPartner p)) := by
+  rw [dart,dart]
+  simp only [Equiv.permCongr_apply,Equiv.symm_symm,Equiv.apply_symm_apply]
+  exact a.edge_reduced hr (fun d=>Types.inverse_ne (label rep d)) _
+
+def pairing : FullPairing (system a hzw hr hz) where
+  perm := (coordinates a hzw).symm.permCongr a.fullPartner
+  involutive := PermutationTransport.involutive _ _ a.fullPartner_involutive
+  fixed_free := PermutationTransport.fixed_free _ _ a.fullPartner_nonfixed
+  compatible p := partner_compatible a hzw p
+  reduced p := partner_reduced a hzw hr p
+
+lemma rotation_conjugate : BoundaryRotation.perm (fun c=>(a.paths hzw c).length)=
+    (coordinates a hzw).symm.permCongr a.closedRotation := by
+  apply Equiv.ext
+  intro p
+  apply (coordinates a hzw).injective
+  simp only [Equiv.permCongr_apply,Equiv.symm_symm,Equiv.apply_symm_apply]
+  exact rotation a hzw p
+/-- Literal finite marked-certificate reduction supplies the Euler hypothesis
+of the actual boundary-pairing exclusion; nothing geometric is assumed here. -/
+lemma pairing_euler : (pairing a hzw hr hz).Euler := by
+  change Fintype.card (Position (fun c=>(a.paths hzw c).length))+4≤
+    2*Fintype.card (Cycle (BoundaryRotation.perm (fun c=>(a.paths hzw c).length)))+
+    2*Fintype.card (Cycle ((coordinates a hzw).symm.permCongr a.fullPartner *
+      BoundaryRotation.perm (fun c=>(a.paths hzw c).length)))
+  rw [rotation_conjugate,←PermutationTransport.mul,PermutationTransport.card_cycles,
+    PermutationTransport.card_cycles,Fintype.card_congr (coordinates a hzw)]
+  exact a.closedRotation_euler hzw
+lemma system_ordinary : ∃c,(system a hzw hr hz).root≠some c := by
+  obtain ⟨c,hc⟩ := a.ordinary_boundary hzw hr (label_reverse rep r) (immersed rep r)
+  exact ⟨c,fun he=>hc (Option.some.inj he).symm⟩
+lemma pairing_genusZero : MapEuler.GenusZero
+    (BoundaryRotation.perm (fun c=>(a.paths hzw c).length)) (pairing a hzw hr hz).perm := by
+  change MapEuler.GenusZero (BoundaryRotation.perm (fun c=>(a.paths hzw c).length))
+    ((coordinates a hzw).symm.permCongr a.fullPartner)
+  rw [rotation_conjugate]
+  exact MapConjugation.genusZero (coordinates a hzw).symm _ _ (a.closedRotation_genusZero hzw)
+/-- Actual finite picture exclusion, conditional only on the still-missing
+sharp planar separator for its literal prepared interval graph. This is not
+an unconditional topology theorem or a proof of the manuscript's main result. -/
+theorem excluded (hL : 2≤GirthAsymptotics.L (TypedGraphs.size rep))
+    (hd : GraphSample.Diameters rep r) (hsample : r∈ActualPatternEvent.samples rep)
+    (oneStep : ∀ S : Finset ((pairing a hzw hr hz).prepared hL hd).P,
+      PlanarParameters.K PathSystem.ε ClosedWords.D<S.card →
+      Nonempty (RecursiveSeparator.Split
+        (PairingClusters.Rel (fun p : Position (fun t=>(((pairing a hzw hr hz).prepared hL hd).paths t).length)=>p.1)
+          ((pairing a hzw hr hz).prepared hL hd).comparisons.pairing.partner) S))
+    (havoid : IsEmpty (BoundedSystem (PlanarParameters.C PathSystem.ε ClosedWords.D)
+      (PlanarParameters.K PathSystem.ε ClosedWords.D) (PlanarParameters.sides PathSystem.ε ClosedWords.D) rep r x y)) : False :=
+  FullPairing.excluded (pairing a hzw hr hz) hL hd hsample
+    (system_ordinary a hzw hr hz) (pairing_euler a hzw hr hz) oneStep havoid
+
+end TorsionFreeZeroDivisors.SampleGraph.Picture
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/GroupRing/CylinderRetention.lean b/lean/OAI/Algebra/GroupRing/CylinderRetention.lean
new file mode 100644
index 0000000000000000000000000000000000000000..63762d7222294724e139a7e35ae7a35c0d9e42b9
--- /dev/null
+++ b/lean/OAI/Algebra/GroupRing/CylinderRetention.lean
@@ -0,0 +1,176 @@
+import Mathlib
+import OAI.Algebra.GroupRing.LoopSphere
+
+namespace OAI
+
+open Set Metric Topology BigOperators
+open Set Metric Topology
+open Set Topology
+open Set Metric Topology
+open scoped NNReal
+open Set Metric Topology
+open scoped NNReal ENNReal
+open Set Metric Topology
+
+namespace TorsionFreeZeroDivisors.CylinderRetention
+open Set Metric Topology GroupRingTopology GroupRingTopology.Cellular
+noncomputable section
+variable {Y : Type*} [TopologicalSpace Y] {n : ℕ}
+
+/-- Converse to the cylinder filling construction: an extension of the family
+of paths, with its specified ends, extends the entire cylinder boundary. -/
+theorem extends_of_path_family (a : C(Sphere n,C(unitInterval,Y)))
+    (b : C(Disk n,Y × Y)) (h : ∀ x, pathEndpoint (a x) = b (boundary n x))
+    (e : C(Disk n,C(unitInterval,Y))) (he : ∀ x, e (boundary n x) = a x)
+    (hend : ∀ x, pathEndpoint (e x) = b x) :
+    SphereTopology.Extends (cylinderBoundaryMap a b h) := by
+  let F : C(Disk (n+1),Y) :=
+    ⟨fun x => e (diskTail x) (diskTime x),
+      continuous_eval.comp ((e.continuous.comp continuous_diskTail).prodMk continuous_diskTime)⟩
+  refine ⟨F,ContinuousMap.ext fun x => ?_⟩
+  obtain ⟨i,hi⟩ := Set.mem_iUnion.mp (show x ∈ ⋃ i, cylinderFace n i by rw [cylinderFace_cover]; trivial)
+  rw [ContinuousMap.comp_apply,cylinderBoundaryMap_face a b h i ⟨x,hi⟩]
+  cases i with
+  | none =>
+    change e (diskTail (boundary (n+1) x)) (diskTime (boundary (n+1) x)) =
+      a (faceSphere ⟨x,hi⟩) (diskTime (boundary (n+1) x))
+    exact congrArg (fun q : C(unitInterval,Y) => q (diskTime (boundary (n+1) x)))
+      (he (faceSphere ⟨x,hi⟩))
+  | some c =>
+    cases c
+    · change e (diskTail (boundary (n+1) x)) (diskTime (boundary (n+1) x)) =
+        (b (diskTail (boundary (n+1) x))).1
+      rw [faceTime_eq_zero x hi]
+      exact congrArg Prod.fst (hend _)
+    · change e (diskTail (boundary (n+1) x)) (diskTime (boundary (n+1) x)) =
+        (b (diskTail (boundary (n+1) x))).2
+      rw [faceTime_eq_one x hi]
+      exact congrArg Prod.snd (hend _)
+
+def firstHalf : C(unitInterval,unitInterval) :=
+  ⟨fun t => ⟨t.1/2,by constructor <;> nlinarith [t.2.1,t.2.2]⟩,
+    by apply Continuous.subtype_mk; fun_prop⟩
+def secondHalf : C(unitInterval,unitInterval) :=
+  ⟨fun t => ⟨(t.1+1)/2,by constructor <;> nlinarith [t.2.1,t.2.2]⟩,
+    by apply Continuous.subtype_mk; fun_prop⟩
+def mid : unitInterval := ⟨1/2,by constructor <;> norm_num⟩
+@[simp] lemma firstHalf_zero : firstHalf 0 = 0 := by ext; norm_num [firstHalf]
+@[simp] lemma firstHalf_one : firstHalf 1 = mid := by ext; norm_num [firstHalf,mid]
+@[simp] lemma secondHalf_zero : secondHalf 0 = mid := by ext; norm_num [secondHalf,mid]
+@[simp] lemma secondHalf_one : secondHalf 1 = 1 := by ext; norm_num [secondHalf]
+
+def restrictPaths (a : C(Sphere n,C(unitInterval,Y))) (r : C(unitInterval,unitInterval)) :
+    C(Sphere n,C(unitInterval,Y)) :=
+  (a.uncurry.comp ⟨fun p => (p.1,r p.2),continuous_fst.prodMk (r.continuous.comp continuous_snd)⟩).curry
+@[simp] lemma restrictPaths_apply (a : C(Sphere n,C(unitInterval,Y)))
+    (r : C(unitInterval,unitInterval)) (x : Sphere n) (t : unitInterval) :
+    restrictPaths a r x t = a x (r t) := rfl
+
+def leftEnds (b : C(Disk n,Y × Y)) (k : C(Disk n,Y)) : C(Disk n,Y × Y) :=
+  ⟨fun x => ((b x).1,k x),(continuous_fst.comp b.continuous).prodMk k.continuous⟩
+def rightEnds (b : C(Disk n,Y × Y)) (k : C(Disk n,Y)) : C(Disk n,Y × Y) :=
+  ⟨fun x => (k x,(b x).2),k.continuous.prodMk (continuous_snd.comp b.continuous)⟩
+
+variable (a : C(Sphere n,C(unitInterval,Y))) (b : C(Disk n,Y × Y))
+  (h : ∀ x, pathEndpoint (a x) = b (boundary n x))
+  (k : C(Disk n,Y)) (hk : ∀ x, k (boundary n x) = a x mid)
+include h hk in
+lemma left_compatible (x : Sphere n) :
+    pathEndpoint (restrictPaths a firstHalf x) = leftEnds b k (boundary n x) := by
+  apply Prod.ext
+  · change a x (firstHalf 0) = (b (boundary n x)).1
+    rw [firstHalf_zero]
+    exact congrArg Prod.fst (h x)
+  · change a x (firstHalf 1) = k (boundary n x)
+    rw [firstHalf_one,hk]
+include h hk in
+lemma right_compatible (x : Sphere n) :
+    pathEndpoint (restrictPaths a secondHalf x) = rightEnds b k (boundary n x) := by
+  apply Prod.ext
+  · change a x (secondHalf 0) = k (boundary n x)
+    rw [secondHalf_zero,hk]
+  · change a x (secondHalf 1) = (b (boundary n x)).2
+    rw [secondHalf_one]
+    exact congrArg Prod.snd (h x)
+
+/-- If both spheres cut and capped by the SAME middle disk extend, so does
+ the original sphere. This is a topological gluing statement, not word reduction. -/
+theorem extends_of_capped_halves
+    (hL : SphereTopology.Extends (cylinderBoundaryMap (restrictPaths a firstHalf)
+      (leftEnds b k) (left_compatible a b h k hk)))
+    (hR : SphereTopology.Extends (cylinderBoundaryMap (restrictPaths a secondHalf)
+      (rightEnds b k) (right_compatible a b h k hk))) :
+    SphereTopology.Extends (cylinderBoundaryMap a b h) := by
+  obtain ⟨FL,hFL⟩ := hL
+  obtain ⟨FR,hFR⟩ := hR
+  obtain ⟨eL,heL,hendL⟩ := cylinderFill _ _ (left_compatible a b h k hk) FL
+    (fun x => congrArg (fun f : C(Sphere (n+1),Y) => f x) hFL)
+  obtain ⟨eR,heR,hendR⟩ := cylinderFill _ _ (right_compatible a b h k hk) FR
+    (fun x => congrArg (fun f : C(Sphere (n+1),Y) => f x) hFR)
+  let b0 : C(Disk n,Y) := ⟨fun x=>(b x).1,continuous_fst.comp b.continuous⟩
+  let b1 : C(Disk n,Y) := ⟨fun x=>(b x).2,continuous_snd.comp b.continuous⟩
+  let HL : ContinuousMap.Homotopy b0 k :=
+    { toFun := fun p => eL p.2 p.1
+      continuous_toFun := eL.uncurry.continuous.comp continuous_swap
+      map_zero_left := fun x => congrArg Prod.fst (hendL x)
+      map_one_left := fun x => congrArg Prod.snd (hendL x) }
+  let HR : ContinuousMap.Homotopy k b1 :=
+    { toFun := fun p => eR p.2 p.1
+      continuous_toFun := eR.uncurry.continuous.comp continuous_swap
+      map_zero_left := fun x => congrArg Prod.fst (hendR x)
+      map_one_left := fun x => congrArg Prod.snd (hendR x) }
+  let H := HL.trans HR
+  let e : C(Disk n,C(unitInterval,Y)) :=
+    (H.toContinuousMap.comp ⟨Prod.swap,continuous_swap⟩).curry
+  apply extends_of_path_family a b h e
+  · intro x
+    ext t
+    change H (t,boundary n x) = a x t
+    rw [ContinuousMap.Homotopy.trans_apply]
+    split_ifs with ht
+    · change eL (boundary n x) _ = a x t
+      rw [heL,restrictPaths_apply]
+      congr 1
+      apply Subtype.ext
+      change (2*t.1)/2=t.1
+      ring
+    · change eR (boundary n x) _ = a x t
+      rw [heR,restrictPaths_apply]
+      congr 1
+      apply Subtype.ext
+      change (2*t.1-1+1)/2=t.1
+      ring
+  · intro x
+    apply Prod.ext
+    · exact H.map_zero_left x
+    · exact H.map_one_left x
+
+/-- A nonextendable sphere retains an essential capped component. -/
+theorem essential_capped_half
+    (hess : ¬ SphereTopology.Extends (cylinderBoundaryMap a b h)) :
+    (¬ SphereTopology.Extends (cylinderBoundaryMap (restrictPaths a firstHalf)
+      (leftEnds b k) (left_compatible a b h k hk))) ∨
+    (¬ SphereTopology.Extends (cylinderBoundaryMap (restrictPaths a secondHalf)
+      (rightEnds b k) (right_compatible a b h k hk))) := by
+  by_contra hc
+  push Not at hc
+  exact hess (extends_of_capped_halves a b h k hk hc.1 hc.2)
+/-- A common contractible cone supplies one and the same middle cap to both
+pieces. No universal-cover homology comparison is needed for this gluing proof. -/
+theorem exists_common_cap {Z : Type*} [TopologicalSpace Z] [ContractibleSpace Z]
+    [Nonempty (Sphere n)] (j : C(Z,Y)) (m : C(Sphere n,Z))
+    (hm : ∀ x, j (m x) = a x mid) :
+    ∃ k : C(Disk n,Y), ∀ x, k (boundary n x) = a x mid := by
+  have hn : m.Nullhomotopic := by
+    simpa only [ContinuousMap.id_comp] using (id_nullhomotopic Z).comp_left m
+  obtain ⟨z,⟨H⟩⟩ := hn
+  obtain ⟨K,hK⟩ := SphereTopology.extends_of_nullhomotopic H.symm
+  refine ⟨j.comp K,fun x => ?_⟩
+  change j (K (boundary n x)) = a x mid
+  rw [show K (boundary n x) = m x from ContinuousMap.congr_fun hK x]
+  exact hm x
+
+end
+end TorsionFreeZeroDivisors.CylinderRetention
+
+end OAI
diff --git a/lean/OAI/Algebra/GroupRing/DegreeTwoSuppression.lean b/lean/OAI/Algebra/GroupRing/DegreeTwoSuppression.lean
new file mode 100644
index 0000000000000000000000000000000000000000..8813ab4ebb8c9b65386f7237e4b0446ad4351d16
--- /dev/null
+++ b/lean/OAI/Algebra/GroupRing/DegreeTwoSuppression.lean
@@ -0,0 +1,500 @@
+import Mathlib
+import OAI.Algebra.GroupRing.WeightedPortMoore
+
+namespace OAI
+
+noncomputable section
+
+namespace TorsionFreeZeroDivisors.DegreeTwoSuppression
+open Function
+open scoped Classical
+open TorsionFreeZeroDivisors ChainSuppression PortSubdivision
+variable {V D : Type*} [Fintype D]
+
+def out (o : D → V) (v : V) : Finset D := Finset.univ.filter (fun d => o d=v)
+@[simp] lemma mem_out (o : D → V) (v : V) (d : D) : d∈out o v ↔ o d=v := by
+  simp [out]
+
+lemma unique_other (o : D → V) (d : D) (hc : (out o (o d)).card=2) :
+    ∃! e : D, o e=o d ∧ e≠d := by
+  obtain ⟨a,b,hab,hs⟩ := Finset.card_eq_two.mp hc
+  have hm (e : D) : o e=o d ↔ e=a ∨ e=b := by
+    rw [← mem_out,hs]
+    simp
+  have hd : d=a ∨ d=b := (hm d).mp rfl
+  rcases hd with rfl | rfl
+  · refine ⟨b,⟨(hm b).mpr (Or.inr rfl),Ne.symm hab⟩,?_⟩
+    intro e he
+    exact ((hm e).mp he.1).resolve_left he.2
+  · refine ⟨a,⟨(hm a).mpr (Or.inl rfl),hab⟩,?_⟩
+    intro e he
+    exact ((hm e).mp he.1).resolve_right he.2
+
+variable (o : D → V) (mark : V → Prop)
+    (h2 : ∀ v, ¬mark v → (out o v).card=2)
+
+def turn (d : D) : D := if h : mark (o d) then d else
+  Classical.choose (unique_other o d (h2 (o d) h)).exists
+
+lemma turn_of_mark (d : D) (hd : mark (o d)) : turn o mark h2 d=d := by
+  simp [turn,hd]
+
+lemma turn_of_unmarked (d : D) (hd : ¬mark (o d)) :
+    o (turn o mark h2 d)=o d ∧ turn o mark h2 d≠d := by
+  simpa only [turn,dite_eq_right hd] using
+    Classical.choose_spec (unique_other o d (h2 (o d) hd)).exists
+
+lemma turn_origin (d : D) : o (turn o mark h2 d)=o d := by
+  by_cases hd : mark (o d)
+  · rw [turn_of_mark o mark h2 d hd]
+  · exact (turn_of_unmarked o mark h2 d hd).1
+
+lemma turn_fixed_iff (d : D) : turn o mark h2 d=d ↔ mark (o d) := by
+  constructor
+  · intro he
+    by_contra hd
+    exact (turn_of_unmarked o mark h2 d hd).2 he
+  · exact turn_of_mark o mark h2 d
+
+lemma turn_involutive : Involutive (turn o mark h2) := by
+  intro d
+  by_cases hd : mark (o d)
+  · rw [turn_of_mark o mark h2 d hd,turn_of_mark o mark h2 d hd]
+  · have he := turn_of_unmarked o mark h2 d hd
+    have hemark : ¬mark (o (turn o mark h2 d)) := he.1 ▸ hd
+    have hef := turn_of_unmarked o mark h2 (turn o mark h2 d) hemark
+    exact (unique_other o (turn o mark h2 d) (h2 _ hemark)).unique hef
+      ⟨he.1.symm,he.2.symm⟩
+
+/-- Darts of the actual suppressed multigraph: all outgoing darts at marked
+vertices. The return map pairs them by the unique maximal degree-two chain. -/
+def suppressed (Γ : PortGraph V D) (mark : V → Prop)
+    (h2 : ∀ v, ¬mark v → (out Γ.origin v).card=2) :
+    PortGraph V {d : D // turn Γ.origin mark h2 d=d} where
+  origin d := Γ.origin d.val
+  reverse := endpoint Γ.reverse (turn Γ.origin mark h2) Γ.reverse_reverse
+    (turn_involutive Γ.origin mark h2)
+  reverse_reverse := endpoint_involutive Γ.reverse (turn Γ.origin mark h2)
+    Γ.reverse_reverse (turn_involutive Γ.origin mark h2)
+  reverse_ne := endpoint_ne Γ.reverse (turn Γ.origin mark h2)
+    Γ.reverse_reverse (turn_involutive Γ.origin mark h2) Γ.reverse_ne
+
+/-- Positive integral lengths count exactly the original directed edges along
+the chains; the two orientations have the same length. -/
+def chainLength (Γ : PortGraph V D) (mark : V → Prop)
+    (h2 : ∀ v, ¬mark v → (out Γ.origin v).card=2)
+    (d : {d : D // turn Γ.origin mark h2 d=d}) : ℕ :=
+  length Γ.reverse (turn Γ.origin mark h2) Γ.reverse_reverse
+    (turn_involutive Γ.origin mark h2) d.val d.property
+
+lemma chainLength_pos (Γ : PortGraph V D) (mark : V → Prop)
+    (h2 : ∀ v, ¬mark v → (out Γ.origin v).card=2)
+    (d : {d : D // turn Γ.origin mark h2 d=d}) : 0 < chainLength Γ mark h2 d :=
+  length_pos _ _ _ _ _ _
+
+lemma chainLength_reverse (Γ : PortGraph V D) (mark : V → Prop)
+    (h2 : ∀ v, ¬mark v → (out Γ.origin v).card=2)
+    (d : {d : D // turn Γ.origin mark h2 d=d}) :
+    chainLength Γ mark h2 ((suppressed Γ mark h2).reverse d)=chainLength Γ mark h2 d :=
+  length_endpoint _ _ _ _ _
+
+lemma chainLength_total (Γ : PortGraph V D) (mark : V → Prop)
+    (h2 : ∀ v, ¬mark v → (out Γ.origin v).card=2) :
+    ∑ d : {d : D // turn Γ.origin mark h2 d=d}, chainLength Γ mark h2 d ≤ Fintype.card D :=
+  total_length_le _ _ _ _
+
+lemma suppressed_degree (Γ : PortGraph V D) (mark : V → Prop)
+    (h2 : ∀ v, ¬mark v → (out Γ.origin v).card=2)
+    (v : V) (hv : mark v) :
+    (out (suppressed Γ mark h2).origin v).card = (out Γ.origin v).card := by
+  classical
+  apply Finset.card_bij (fun d _ => d.val)
+  · intro d hd
+    exact (mem_out Γ.origin v d.val).mpr ((mem_out _ v d).mp hd)
+  · intro d _ e _ he
+    exact Subtype.ext he
+  · intro d hd
+    have ho : Γ.origin d=v := (mem_out _ v d).mp hd
+    let e : {d : D // turn Γ.origin mark h2 d=d} :=
+      ⟨d,(turn_fixed_iff Γ.origin mark h2 d).mpr (ho ▸ hv)⟩
+    exact ⟨e,(mem_out _ v e).mpr ho,rfl⟩
+
+/-- Minimum degree two becomes minimum degree three whenever a component has
+some branching. Pure circle components give no darts and are treated separately. -/
+lemma suppressed_min_degree (Γ : PortGraph V D)
+    (hmin : ∀ d, 2 ≤ (out Γ.origin (Γ.origin d)).card) :
+    let mark := fun v => (out Γ.origin v).card≠2
+    let h2 := fun v (h : ¬mark v) => Classical.not_not.mp h
+    ∀ d, 3 ≤ (out (suppressed Γ mark h2).origin ((suppressed Γ mark h2).origin d)).card := by
+  intro mark h2 d
+  have hm : mark (Γ.origin d.val) := (turn_fixed_iff Γ.origin mark h2 d.val).mp d.property
+  change 3 ≤ (out (suppressed Γ mark h2).origin (Γ.origin d.val)).card
+  rw [suppressed_degree Γ mark h2 _ hm]
+  have hc := hmin d.val
+  dsimp [mark] at hm
+  omega
+
+end TorsionFreeZeroDivisors.DegreeTwoSuppression
+
+namespace TorsionFreeZeroDivisors.SuppressedMoore
+open Function SimpleGraph
+open scoped Classical
+open TorsionFreeZeroDivisors PortSubdivision WeightedMoore WeightedPortMoore
+variable {V D : Type*} [Fintype D] (Γ : PortGraph V D)
+    (mark : V → Prop) (h2 : ∀ v, ¬mark v → (DegreeTwoSuppression.out Γ.origin v).card=2)
+
+local notation "τ" => DegreeTwoSuppression.turn Γ.origin mark h2
+local notation "hτ" => DegreeTwoSuppression.turn_involutive Γ.origin mark h2
+local notation "F" => ChainSuppression.next Γ.reverse τ
+local notation "B" => {d : D // τ d=d}
+local notation "Γ'" => DegreeTwoSuppression.suppressed Γ mark h2
+local notation "len" => DegreeTwoSuppression.chainLength Γ mark h2
+
+def iterChain (f : D → D) : (n : ℕ) → D → Chain D n
+  | 0, x => x
+  | n+1, x => (x,iterChain f n (f x))
+
+omit [Fintype D] in
+@[simp] lemma head_iterChain (f : D → D) (n : ℕ) (x : D) : head (iterChain f n x)=x := by
+  cases n <;> rfl
+
+omit [Fintype D] in
+@[simp] lemma last_iterChain (f : D → D) (n : ℕ) (x : D) :
+    last (iterChain f n x)=f^[n] x := by
+  induction n generalizing x with
+  | zero => rfl
+  | succ n ih =>
+    change last (iterChain f n (f x))=f^[n+1] x
+    rw [ih,iterate_succ_apply]
+
+lemma iterChain_good (n : ℕ) (x : D)
+    (hm : ∀ i : ℕ, 0 < i → i ≤ n → τ (F^[i] x) ≠ F^[i] x) :
+    Good Γ (iterChain F n x) := by
+  induction n generalizing x with
+  | zero => trivial
+  | succ n ih =>
+    refine ⟨?_,?_⟩
+    · change PortWalk.step Γ.origin Γ.reverse x (head (iterChain F n (F x)))
+      rw [head_iterChain]
+      have hne : F x ≠ Γ.reverse x := by
+        intro he
+        have h0 : τ (F x)=F x := by
+          change τ (τ (Γ.reverse x))=F x
+          rw [hτ,he]
+        exact hm 1 (by omega) (by omega) (by simpa only [iterate_one] using h0)
+      exact ⟨(DegreeTwoSuppression.turn_origin Γ.origin mark h2 (Γ.reverse x)).symm,hne⟩
+    · apply ih (F x)
+      intro i hi hin
+      have his : i+1≤n+1 := by omega
+      simpa only [iterate_succ_apply] using hm (i+1) (by omega) his
+
+lemma chain_good (d : B) : Good Γ (iterChain F (len d-1) d.val) := by
+  apply iterChain_good
+  intro i hi hil
+  exact ChainSuppression.no_internal_mark Γ.reverse τ Γ.reverse_reverse hτ d.val d.property hi
+    (by change i < len d; have hp := DegreeTwoSuppression.chainLength_pos Γ mark h2 d; omega)
+
+lemma chain_last (d : B) : Γ.reverse (last (iterChain F (len d-1) d.val)) = ((Γ').reverse d).val := by
+  rw [last_iterChain]
+  have hf := ((Γ').reverse d).property
+  change τ (F^[len d] d.val)=F^[len d] d.val at hf
+  have hk : len d=(len d-1)+1 := by
+    have hp := DegreeTwoSuppression.chainLength_pos Γ mark h2 d
+    omega
+  conv_lhs at hf => rw [hk,iterate_succ_apply']
+  change τ (τ (Γ.reverse (F^[len d-1] d.val)))=F^[len d] d.val at hf
+  rw [hτ] at hf
+  exact hf
+
+/-- Literal expansion of one suppressed edge into the original graph. Its
+endpoints are the two marked ports, and every internal vertex is degree two. -/
+def chainWalk (d : B) : Γ.subdivision.Walk (.inr d.val) (.inr ((Γ').reverse d).val) :=
+  (draw Γ (iterChain F (len d-1) d.val) (chain_good Γ mark h2 d)).copy
+    (congrArg Sum.inr (head_iterChain F _ _)) (congrArg Sum.inr (chain_last Γ mark h2 d))
+
+lemma chainWalk_reduced (d : B) : (chainWalk Γ mark h2 d).edges.IsChain (·≠·) := by
+  simpa only [chainWalk,Walk.edges_copy] using
+    draw_reduced Γ (iterChain F (len d-1) d.val) (chain_good Γ mark h2 d)
+
+omit [Fintype D] in
+lemma cost_iterChain_one (f : D → D) (n : ℕ) (d : D) :
+    cost (fun _ => (1:ℝ)) (iterChain f n d) = n+1 := by
+  induction n generalizing d with
+  | zero => simp [cost]
+  | succ n ih =>
+    change 1+cost (fun _ => (1:ℝ)) (iterChain f n (f d))=(n+1:ℕ)+1
+    rw [ih]
+    push_cast
+    ring
+
+lemma chainWalk_weight (d : B) :
+    WeightedCycles.weight (edgeWeight (fun _ : D => (1:ℝ))) (chainWalk Γ mark h2 d)=len d := by
+  simp only [chainWalk,WeightedCycles.weight,Walk.edges_copy]
+  change WeightedCycles.weight (edgeWeight (fun _ : D => (1:ℝ)))
+    (draw Γ (iterChain F (len d-1) d.val) (chain_good Γ mark h2 d))=len d
+  rw [draw_weight Γ _ (fun _ => rfl),cost_iterChain_one]
+  have hp := DegreeTwoSuppression.chainLength_pos Γ mark h2 d
+  norm_cast
+  omega
+
+/- The variable-length concatenation keeps all occurrences: no quotient by
+cyclic words and no assumption that the original paths are embedded. -/
+omit [Fintype D] in
+def join : {k : ℕ} → Chain D k → (Σ l, Chain D l) → (Σ l, Chain D l)
+  | 0, d, ⟨l,q⟩ => ⟨l+1,(d,q)⟩
+  | _+1, p, q => let r := join p.2 q; ⟨r.1+1,(p.1,r.2)⟩
+
+omit [Fintype D] in
+lemma join_head {k : ℕ} (p : Chain D k) (q : Σ l, Chain D l) :
+    head (join p q).2 = head p := by cases k <;> rfl
+
+omit [Fintype D] in
+lemma join_last {k : ℕ} (p : Chain D k) (q : Σ l, Chain D l) :
+    last (join p q).2 = last q.2 := by
+  induction k with
+  | zero => rfl
+  | succ k ih => exact ih p.2
+
+omit [Fintype D] in
+lemma join_cost (w : D → ℝ) {k : ℕ} (p : Chain D k) (q : Σ l, Chain D l) :
+    cost w (join p q).2 = cost w p + cost w q.2 := by
+  induction k with
+  | zero => rfl
+  | succ k ih =>
+    change w p.1+cost w (join p.2 q).2 = (w p.1+cost w p.2)+cost w q.2
+    rw [ih]; ring
+
+omit [Fintype D] in
+lemma join_good {k : ℕ} (p : Chain D k) (q : Σ l, Chain D l)
+    (hp : Good Γ p) (hq : Good Γ q.2)
+    (hlink : PortWalk.step Γ.origin Γ.reverse (last p) (head q.2)) :
+    Good Γ (join p q).2 := by
+  induction k with
+  | zero => exact ⟨hlink,hq⟩
+  | succ k ih =>
+    change PortWalk.step Γ.origin Γ.reverse p.1 (head (join p.2 q).2) ∧ _
+    rw [join_head]
+    exact ⟨hp.1,ih p.2 hp.2 hlink⟩
+
+omit [Fintype D] in
+def outWord : {k : ℕ} → Chain D k → List D
+  | 0, d => [d]
+  | _+1, p => p.1 :: outWord p.2
+
+omit [Fintype D] in
+lemma outWord_injective (k : ℕ) : Injective (@outWord D k) := by
+  induction k with
+  | zero => intro p q h; exact List.cons.inj h |>.1
+  | succ k ih =>
+    intro p q h
+    exact Prod.ext (List.cons.inj h).1 (ih (List.cons.inj h).2)
+
+omit [Fintype D] in
+lemma outWord_join {k : ℕ} (p : Chain D k) (q : Σ l, Chain D l) :
+    outWord (join p q).2 = outWord p ++ outWord q.2 := by
+  induction k with
+  | zero => rfl
+  | succ k ih => change p.1 :: outWord (join p.2 q).2 = _; rw [ih]; rfl
+
+omit [Fintype D] in
+def pickEven : List D → List D
+  | [] => []
+  | [d] => [d]
+  | d::_::ds => d::pickEven ds
+
+omit [Fintype D] in
+lemma pickEven_portWord {k : ℕ} (p : Chain D k) :
+    pickEven (portWord Γ p) = outWord p := by
+  induction k with
+  | zero => rfl
+  | succ k ih => change p.1::pickEven (portWord Γ p.2)=_; rw [ih]; rfl
+
+lemma iterChain_no_marks (n : ℕ) (d : D)
+    (hn : ∀ i : ℕ, i≤n → τ (F^[i] d) ≠ F^[i] d) :
+    (outWord (iterChain F n d)).filter (fun d => τ d=d) = [] := by
+  induction n generalizing d with
+  | zero => simpa [outWord,iterChain] using hn 0 (by omega)
+  | succ n ih =>
+    change (d::outWord (iterChain F n (F d))).filter (fun d => τ d=d)=[]
+    rw [List.filter_cons_of_neg (by simpa using hn 0 (by omega))]
+    apply ih
+    intro i hi
+    simpa only [iterate_succ_apply] using hn (i+1) (by omega)
+
+lemma chain_one_mark (d : B) :
+    (outWord (iterChain F (len d-1) d.val)).filter (fun d => τ d=d) = [d.val] := by
+  have hp := DegreeTwoSuppression.chainLength_pos Γ mark h2 d
+  have hn (i : ℕ) (hi : 0 < i) (hil : i < len d) : τ (F^[i] d.val)≠F^[i] d.val :=
+    ChainSuppression.no_internal_mark Γ.reverse τ Γ.reverse_reverse hτ d.val d.property hi hil
+  generalize he : len d-1 = n
+  cases n with
+  | zero => simp [outWord,iterChain,d.property]
+  | succ n =>
+    change (d.val::outWord (iterChain F n (F d.val))).filter (fun d => τ d=d)=[d.val]
+    rw [List.filter_cons_of_pos (by simpa using d.property)]
+    rw [iterChain_no_marks]
+    intro i hi
+    simpa only [iterate_succ_apply] using hn (i+1) (by omega) (by omega)
+
+/-- Expand every macro-edge, preserving the ordered path occurrence data. -/
+def expand : {k : ℕ} → Chain B k → (Σ l, Chain D l)
+  | 0, d => ⟨len d-1,iterChain F (len d-1) d.val⟩
+  | _+1, p => join (iterChain F (len p.1-1) p.1.val) (expand p.2)
+
+lemma expand_head {k : ℕ} (p : Chain B k) : head (expand Γ mark h2 p).2 = (head p).val := by
+  cases k with
+  | zero => exact head_iterChain F _ _
+  | succ k => change head (join _ _).2 = p.1.val; rw [join_head,head_iterChain]
+
+lemma expand_last {k : ℕ} (p : Chain B k) :
+    Γ.reverse (last (expand Γ mark h2 p).2) = ((Γ').reverse (last p)).val := by
+  induction k with
+  | zero => exact chain_last Γ mark h2 p
+  | succ k ih => change Γ.reverse (last (join _ _).2)=_; rw [join_last]; exact ih p.2
+
+lemma expand_good {k : ℕ} (p : Chain B k) (hp : Good (Γ') p) :
+    Good Γ (expand Γ mark h2 p).2 := by
+  induction k with
+  | zero => exact chain_good Γ mark h2 p
+  | succ k ih =>
+    apply join_good Γ _ _ (chain_good Γ mark h2 p.1) (ih p.2 hp.2)
+    unfold PortWalk.step
+    rw [chain_last,expand_head]
+    exact ⟨hp.1.1,fun he => hp.1.2 (Subtype.ext he)⟩
+
+lemma expand_cost {k : ℕ} (p : Chain B k) :
+    cost (fun _ : D => (1:ℝ)) (expand Γ mark h2 p).2 = cost (fun d => (len d : ℝ)) p := by
+  have hs (d : B) : cost (fun _ : D => (1:ℝ)) (iterChain F (len d-1) d.val) = len d := by
+    rw [cost_iterChain_one]
+    have hp := DegreeTwoSuppression.chainLength_pos Γ mark h2 d
+    norm_cast
+    omega
+  induction k with
+  | zero => exact hs p
+  | succ k ih => change cost _ (join _ _).2 = _; rw [join_cost,hs,ih]; rfl
+
+lemma expand_marks {k : ℕ} (p : Chain B k) :
+    (outWord (expand Γ mark h2 p).2).filter (fun d => τ d=d) = (outWord p).map Subtype.val := by
+  induction k with
+  | zero => exact chain_one_mark Γ mark h2 p
+  | succ k ih =>
+    change (outWord (join _ _).2).filter _ = _
+    rw [outWord_join,List.filter_append,chain_one_mark,ih]
+    rfl
+
+/-- The stationary Moore collision in the suppressed graph expands to a
+literal original cycle. Girth is imposed only on the original graph. -/
+theorem original_short_cycle [Nonempty B]
+    (hdeg : ∀ d, 3 ≤ (PortWalk.out (Γ').origin ((Γ').origin d)).card) :
+    let k := Nat.log 2 (Fintype.card B) + 2
+    ∃ (a : V ⊕ D) (c : Γ.subdivision.Walk a a), c.IsCycle ∧
+      WeightedCycles.weight (edgeWeight (fun _ : D => (1:ℝ))) c ≤
+        4*(k+1:ℝ)*(∑ d : B, (len d : ℝ))/Fintype.card B := by
+  let T := PortWalk.transition (Γ').origin (Γ').reverse
+  have ht : Transition T := PortWalk.transition_law (Γ').origin (Γ').reverse
+    (Γ').reverse_reverse hdeg
+  have hlpos (d : B) : (0:ℝ) < len d := by
+    exact_mod_cast DegreeTwoSuppression.chainLength_pos Γ mark h2 d
+  obtain ⟨p,q,hne,hh,hl,hp,hq,hcost⟩ := logarithmic_short_collision ht (fun d => (len d : ℝ)) hlpos
+  have hgp : Good (Γ') p := positive_good (Γ') ht p hp
+  have hgq : Good (Γ') q := positive_good (Γ') ht q hq
+  let ep := expand Γ mark h2 p
+  let eq := expand Γ mark h2 q
+  have hep : Good Γ ep.2 := expand_good Γ mark h2 p hgp
+  have heq : Good Γ eq.2 := expand_good Γ mark h2 q hgq
+  have heh : head eq.2 = head ep.2 := by
+    change head (expand Γ mark h2 q).2=head (expand Γ mark h2 p).2
+    rw [expand_head,expand_head,hh]
+  have hel : Γ.reverse (last eq.2) = Γ.reverse (last ep.2) := by
+    change Γ.reverse (last (expand Γ mark h2 q).2)=Γ.reverse (last (expand Γ mark h2 p).2)
+    rw [expand_last,expand_last,hl]
+  let qp : Γ.subdivision.Walk (.inr (head ep.2)) (.inr (Γ.reverse (last ep.2))) :=
+    (draw Γ eq.2 heq).copy (congrArg Sum.inr heh) (congrArg Sum.inr hel)
+  have hqp : draw Γ ep.2 hep ≠ qp := by
+    intro he
+    have hr := congrArg (fun r => r.support.filterMap onlyPort) he
+    simp only [qp,Walk.support_copy,draw_portWord] at hr
+    have ho := congrArg pickEven hr
+    simp only [pickEven_portWord] at ho
+    have hm := congrArg (fun ds => ds.filter (fun d => τ d=d)) ho
+    change (outWord (expand Γ mark h2 p).2).filter _ =
+      (outWord (expand Γ mark h2 q).2).filter _ at hm
+    rw [expand_marks,expand_marks] at hm
+    exact hne (outWord_injective _ ((List.map_inj_right (fun _ _ => Subtype.ext)).mp hm))
+  have hqred : qp.edges.IsChain (· ≠ ·) := by
+    simpa only [qp,Walk.edges_copy] using draw_reduced Γ eq.2 heq
+  have hwp : WeightedCycles.weight (edgeWeight (fun _ : D => (1:ℝ))) (draw Γ ep.2 hep) =
+      cost (fun d => (len d : ℝ)) p := by
+    rw [draw_weight Γ _ (fun _ => rfl)]
+    exact expand_cost Γ mark h2 p
+  have hwq : WeightedCycles.weight (edgeWeight (fun _ : D => (1:ℝ))) qp =
+      cost (fun d => (len d : ℝ)) q := by
+    simp only [qp,WeightedCycles.weight,Walk.edges_copy]
+    change WeightedCycles.weight (edgeWeight (fun _ : D => (1:ℝ))) (draw Γ eq.2 heq)=_
+    rw [draw_weight Γ _ (fun _ => rfl)]
+    exact expand_cost Γ mark h2 q
+  obtain ⟨a,c,hc,hwc⟩ := WeightedCycles.distinct_reduced_cycle
+    (edgeWeight (fun _ : D => (1:ℝ))) (edgeWeight_nonneg _ (fun _ => by norm_num))
+    (draw Γ ep.2 hep) qp hqp (draw_reduced Γ ep.2 hep) hqred
+  refine ⟨a,c,hc,?_⟩
+  rw [hwp,hwq] at hwc
+  exact hwc.trans hcost
+
+/-- Actual branch-port complexity from original edge count and original girth,
+without an a priori graph-rank or chain-count hypothesis. -/
+theorem original_dart_inequality [Nonempty B]
+    (hdeg : ∀ d, 3 ≤ (PortWalk.out (Γ').origin ((Γ').origin d)).card)
+    (L C : ℝ) (hL : 0 < L)
+    (htotal : (Fintype.card D : ℝ) ≤ 2*C*L)
+    (hgirth : ∀ a (c : Γ.subdivision.Walk a a), c.IsCycle →
+      L ≤ WeightedCycles.weight (edgeWeight (fun _ : D => (1:ℝ))) c) :
+    (Fintype.card B : ℝ) ≤ 8*C*(Nat.log 2 (Fintype.card B)+3:ℝ) := by
+  obtain ⟨a,c,hc,hbound⟩ := original_short_cycle Γ mark h2 hdeg
+  have hD : (0:ℝ) < Fintype.card B := Nat.cast_pos.mpr Fintype.card_pos
+  have he := (le_div_iff₀ hD).mp ((hgirth a c hc).trans hbound)
+  have hs : (∑ d : B, (len d : ℝ)) ≤ Fintype.card D := by
+    exact_mod_cast DegreeTwoSuppression.chainLength_total Γ mark h2
+  have hn : (0:ℝ) ≤ 4*((Nat.log 2 (Fintype.card B)+2:ℕ)+1:ℝ) := by positivity
+  have hm := mul_le_mul_of_nonneg_left (hs.trans htotal) hn
+  push_cast at he hm
+  nlinarith
+
+omit [Fintype D] in
+/-- Uniformly many branch ports in an actual finite graph of minimum degree
+two with O(L) edges and girth L. Pure circles contribute no branch ports. -/
+theorem bounded_branch_ports (C : ℝ) (hC : 0 ≤ C) :
+    ∃ R : ℕ, ∀ {V D : Type} [Fintype D] (Γ : PortGraph V D)
+      (_ : ∀ d, 2 ≤ (DegreeTwoSuppression.out Γ.origin (Γ.origin d)).card)
+      (L : ℝ) (_ : 0 < L)
+      (_ : (Fintype.card D : ℝ) ≤ 2*C*L)
+      (_ : ∀ a (c : Γ.subdivision.Walk a a), c.IsCycle →
+          L ≤ WeightedCycles.weight (edgeWeight (fun _ : D => (1:ℝ))) c),
+      (Finset.univ.filter (fun d : D =>
+        (DegreeTwoSuppression.out Γ.origin (Γ.origin d)).card≠2)).card ≤ R := by
+  obtain ⟨R,hR⟩ := logarithmic_inequality_bounded (8*C) (by positivity)
+  refine ⟨R,?_⟩
+  intro V D _ Γ hmin L hL htotal hg
+  let mark := fun v => (DegreeTwoSuppression.out Γ.origin v).card≠2
+  let h2 := fun v (h : ¬mark v) => Classical.not_not.mp h
+  let CoreD := {d : D // DegreeTwoSuppression.turn Γ.origin mark h2 d=d}
+  have he : (Finset.univ.filter (fun d : D =>
+      (DegreeTwoSuppression.out Γ.origin (Γ.origin d)).card≠2)).card = Fintype.card CoreD := by
+    change (Finset.univ.filter (fun d : D => mark (Γ.origin d))).card = _
+    simpa only [CoreD,Fintype.card_subtype] using congrArg Finset.card (show
+      Finset.univ.filter (fun d : D => mark (Γ.origin d)) =
+      Finset.univ.filter (fun d : D => DegreeTwoSuppression.turn Γ.origin mark h2 d=d) by
+        ext d; simp [DegreeTwoSuppression.turn_fixed_iff])
+  rw [he]
+  cases isEmpty_or_nonempty CoreD with
+  | inl hi => have := hi; rw [Fintype.card_eq_zero]; exact Nat.zero_le R
+  | inr hi =>
+    have := hi
+    apply hR
+    apply original_dart_inequality Γ mark h2 ?_ L C hL htotal hg
+    exact DegreeTwoSuppression.suppressed_min_degree Γ hmin
+
+end TorsionFreeZeroDivisors.SuppressedMoore
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/GroupRing/DiskHomotopy.lean b/lean/OAI/Algebra/GroupRing/DiskHomotopy.lean
new file mode 100644
index 0000000000000000000000000000000000000000..4f93782ab9c3a4ab73536d868667166d2ab265de
--- /dev/null
+++ b/lean/OAI/Algebra/GroupRing/DiskHomotopy.lean
@@ -0,0 +1,63 @@
+import Mathlib
+import OAI.Algebra.GroupRing.DiskTracks
+import OAI.Algebra.GroupRing.HomotopyTracks
+
+namespace OAI
+
+noncomputable section
+
+namespace TorsionFreeZeroDivisors.DiskTracks
+open Set Metric Topology GroupRingTopology GroupRingTopology.Attachment
+open GroupRingTopology.Cellular hiding Disk Sphere boundary
+open scoped unitInterval
+variable {Y : Type} [TopologicalSpace Y] {y : Y} {p : Path y y}
+  {c h : Path p (Path.refl y)}
+def squareHomotopy (H : c.Homotopy h) : (square c).Homotopy (square h) where
+  toFun z := square (H.eval z.1) z.2
+  continuous_toFun := (Path.continuous_uncurry_iff.mpr H.continuous).comp
+    ((continuous_fst.prodMk (continuous_diskTime.comp continuous_snd)).prodMk
+      (Cayley.continuous_edgeTime.comp (continuous_diskTail.comp continuous_snd)))
+  map_zero_left d := by
+    change H (0,diskTime d) _=c _ _
+    rw [H.apply_zero];rfl
+  map_one_left d := by
+    change H (1,diskTime d) _=h _ _
+    rw [H.apply_one];rfl
+lemma squareHomotopy_boundary (H : c.Homotopy h) (t : unitInterval) (z : Sphere 2) :
+    squareHomotopy H (t,boundary 2 z)=LoopSphere.map p z := square_boundary (H.eval t) z
+
+def extension (F : C(Disk 2,Y)) (hF : ∀z,F (boundary 2 z)=LoopSphere.map p z)
+    (h : Path p (Path.refl y)) (H : (physical F hF).Homotopy h) : F.Homotopy (.const _ y) := by
+  have e := (squareHomotopy H).trans (contract h)
+  exact { e with
+    map_zero_left := fun d=>(e.apply_zero d).trans (ContinuousMap.congr_fun (square_physical F hF) d) }
+lemma extension_boundary (F : C(Disk 2,Y)) (hF : ∀z,F (boundary 2 z)=LoopSphere.map p z)
+    (h : Path p (Path.refl y)) (H : (physical F hF).Homotopy h)
+    (t : unitInterval) (z : Sphere 2) :
+    extension F hF h H (t,boundary 2 z)=
+      if ht : (t:ℝ)≤1/2 then LoopSphere.map p z
+      else LoopSphere.map (h ⟨2*t-1,unitInterval.two_mul_sub_one_mem_iff.2 ⟨(not_le.1 ht).le,t.2.2⟩⟩) z := by
+  change ((squareHomotopy H).trans (contract h)) (t,boundary 2 z)=_
+  rw [ContinuousMap.Homotopy.trans_apply]
+  split_ifs
+  · exact squareHomotopy_boundary H _ z
+  · exact contract_boundary h _ z
+end TorsionFreeZeroDivisors.DiskTracks
+namespace TorsionFreeZeroDivisors.HomotopyTracks
+open GroupRingTopology GroupRingTopology.Attachment
+open scoped unitInterval
+variable {X Y : Type} [TopologicalSpace X] [TopologicalSpace Y]
+  {x : X} {y : Y} {f : C(X,Y)} (hx : f x=y)
+lemma natural_cast (p : Path x x) : LoopSphere.map (mapped hx p)=f.comp (LoopSphere.map p) := by
+  subst y
+  exact LoopSphere.natural p f
+variable (H : f.Homotopy (.const _ y)) (hH : ∀t,H (t,x)=y)
+lemma track_boundary (p : Path x x) (t : unitInterval) (z : Sphere 2) :
+    LoopSphere.map ((track hx H hH p) t) z=H (t,LoopSphere.map p z) := by
+  let k : C(X,Y) := ⟨fun u=>H (t,u),H.continuous.comp (continuous_const.prodMk continuous_id)⟩
+  exact ContinuousMap.congr_fun (natural_cast (f:=k) (hH t) p) z
+end TorsionFreeZeroDivisors.HomotopyTracks
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/GroupRing/DiskTracks.lean b/lean/OAI/Algebra/GroupRing/DiskTracks.lean
new file mode 100644
index 0000000000000000000000000000000000000000..b3c439be7ee26756214e5be8c5899276db275de3
--- /dev/null
+++ b/lean/OAI/Algebra/GroupRing/DiskTracks.lean
@@ -0,0 +1,113 @@
+import Mathlib
+import OAI.Algebra.GroupRing.ConeCells
+
+namespace OAI
+
+
+
+section
+namespace TorsionFreeZeroDivisors.DiskTracks
+open Set Metric Topology GroupRingTopology GroupRingTopology.Attachment
+open GroupRingTopology.Cellular hiding Disk Sphere boundary
+open scoped unitInterval
+noncomputable section
+variable {Y : Type} [TopologicalSpace Y] {y : Y} {p : Path y y}
+def square (c : Path p (Path.refl y)) : C(Disk 2,Y) :=
+  ⟨fun d=>c (diskTime d) (Cayley.edgeTime (diskTail d)),
+   (Path.continuous_uncurry_iff.mpr c.continuous).comp
+     (continuous_diskTime.prodMk (Cayley.continuous_edgeTime.comp continuous_diskTail))⟩
+lemma square_boundary (c : Path p (Path.refl y)) (z : Sphere 2) :
+    square c (boundary 2 z)=LoopSphere.map p z := by
+  have hz : z∈⋃i,cylinderFace 1 i := by rw [cylinderFace_cover];trivial
+  obtain ⟨i,hi⟩ := Set.mem_iUnion.mp hz
+  change _=cylinderBoundaryMap _ _ _ z
+  rw [cylinderBoundaryMap_face _ _ _ i ⟨z,hi⟩]
+  cases i with
+  | none =>
+    have he : diskTail (boundary 2 z)=boundary 1 (faceSphere ⟨z,hi⟩) := rfl
+    change c (diskTime (boundary 2 z)) (Cayley.edgeTime (diskTail (boundary 2 z)))=y
+    rw [he]
+    obtain hh|hh := Cayley.sphere_one_eq (faceSphere ⟨z,hi⟩)
+    · rw [hh,Cayley.edgeTime_minus,Path.source]
+    · rw [hh,Cayley.edgeTime_plus,Path.target]
+  | some b =>
+    cases b
+    · have ht : diskTime (boundary 2 z)=0 := by
+        apply Subtype.ext
+        change (z.1 0+1)/2=0
+        change z.1 0= -1 at hi
+        rw [hi];norm_num
+      change c (diskTime (boundary 2 z)) (Cayley.edgeTime (diskTail (boundary 2 z)))=p _
+      rw [ht,c.source];rfl
+    · have ht : diskTime (boundary 2 z)=1 := by
+        apply Subtype.ext
+        change (z.1 0+1)/2=1
+        change z.1 0=1 at hi
+        rw [hi];norm_num
+      change c (diskTime (boundary 2 z)) (Cayley.edgeTime (diskTail (boundary 2 z)))=y
+      rw [ht,c.target];rfl
+variable (F : C(Disk 2,Y)) (hF : ∀z,F (boundary 2 z)=LoopSphere.map p z)
+def physical : Path p (Path.refl y) where
+  toFun t := {
+    toFun s := F (diskCons (Cayley.edgeParam s) t)
+    continuous_toFun := F.continuous.comp (continuous_diskCons.comp
+      (Cayley.continuous_edgeParam.prodMk continuous_const))
+    source' := by
+      rw [Cayley.edgeParam_zero]
+      erw [hF ⟨_,cons_mem_sphere_of_boundary Cayley.minus t⟩]
+      exact GraphConeCW.cylinder_side _ _ _ _ _
+    target' := by
+      rw [Cayley.edgeParam_one]
+      erw [hF ⟨_,cons_mem_sphere_of_boundary Cayley.plus t⟩]
+      exact GraphConeCW.cylinder_side _ _ _ _ _ }
+  continuous_toFun := Path.continuous_uncurry_iff.mp (F.continuous.comp
+    (continuous_diskCons.comp ((Cayley.continuous_edgeParam.comp continuous_snd).prodMk continuous_fst)))
+  source' := by
+    ext s
+    change F (diskCons (Cayley.edgeParam s) 0)=p s
+    erw [hF ⟨_,cons_zero_mem_sphere (Cayley.edgeParam s)⟩]
+    unfold LoopSphere.map
+    erw [GraphConeCW.cylinder_bottom]
+    change p (Cayley.edgeTime (Cayley.edgeParam s))=p s
+    rw [Cayley.edgeTime_param]
+  target' := by
+    ext s
+    change F (diskCons (Cayley.edgeParam s) 1)=y
+    erw [hF ⟨_,cons_one_mem_sphere (Cayley.edgeParam s)⟩]
+    exact GraphConeCW.cylinder_top _ _ _ _
+lemma square_physical : square (physical F hF)=F := by
+  ext d
+  change F (diskCons (Cayley.edgeParam (Cayley.edgeTime (diskTail d))) (diskTime d))=F d
+  rw [Cayley.edgeParam_time,GraphConeCW.cons_tail_time]
+
+def shift (t s : unitInterval) : unitInterval :=
+  ⟨t+(1-t)*s,by constructor <;> nlinarith [t.2.1,t.2.2,s.2.1,s.2.2]⟩
+lemma continuous_shift : Continuous (fun q : unitInterval×unitInterval=>shift q.1 q.2) := by
+  apply Continuous.subtype_mk
+  fun_prop
+@[simp] lemma shift_zero (s : unitInterval) : shift 0 s=s := by ext;simp [shift]
+@[simp] lemma shift_one (s : unitInterval) : shift 1 s=1 := by ext;simp [shift]
+@[simp] lemma shift_zero_right (t : unitInterval) : shift t 0=t := by ext;simp [shift]
+@[simp] lemma shift_one_right (t : unitInterval) : shift t 1=1 := by ext;simp [shift]
+def tail (c : Path p (Path.refl y)) (t : unitInterval) : Path (c t) (Path.refl y) where
+  toFun s:=c (shift t s)
+  continuous_toFun:=c.continuous.comp (continuous_shift.comp (continuous_const.prodMk continuous_id))
+  source':=by rw [shift_zero_right]
+  target':=by rw [shift_one_right,c.target]
+def contract (c : Path p (Path.refl y)) : (square c).Homotopy (.const _ y) where
+  toFun z:=square (tail c z.1) z.2
+  continuous_toFun := (Path.continuous_uncurry_iff.mpr c.continuous).comp
+    ((continuous_shift.comp (continuous_fst.prodMk (continuous_diskTime.comp continuous_snd))).prodMk
+      (Cayley.continuous_edgeTime.comp (continuous_diskTail.comp continuous_snd)))
+  map_zero_left d := by change c (shift 0 (diskTime d)) _=c _ _;rw [shift_zero]
+  map_one_left d := by change c (shift 1 (diskTime d)) _=y;rw [shift_one,c.target];rfl
+lemma contract_boundary (c : Path p (Path.refl y)) (t : unitInterval) (z : Sphere 2) :
+    contract c (t,boundary 2 z)=LoopSphere.map (c t) z := square_boundary (tail c t) z
+end
+end TorsionFreeZeroDivisors.DiskTracks
+
+end
+
+
+
+end OAI
diff --git a/lean/OAI/Algebra/GroupRing/EntropyStages.lean b/lean/OAI/Algebra/GroupRing/EntropyStages.lean
new file mode 100644
index 0000000000000000000000000000000000000000..e03605eb501feba5b1249c0ae5c80e561419f5b8
--- /dev/null
+++ b/lean/OAI/Algebra/GroupRing/EntropyStages.lean
@@ -0,0 +1,516 @@
+import Mathlib
+import OAI.Algebra.GroupRing.BlockGrid
+
+namespace OAI
+
+noncomputable section
+
+namespace TorsionFreeZeroDivisors.EntropyStages
+structure Pairing (O : Type*) where
+  partner : O → O
+  involutive : Function.Involutive partner
+end TorsionFreeZeroDivisors.EntropyStages
+
+namespace TorsionFreeZeroDivisors.OccurrenceMatching
+open scoped Classical
+open EntropyStages
+variable {Ω B E : Type*}
+
+structure Data where
+  /-- Uniform bound for discarded letters in every selected comparison. -/
+  error : ℕ
+  positions : B → Finset Ω
+  disjoint : ∀ {o p}, o ≠ p → Disjoint (positions o) (positions p)
+  pairing : Pairing Ω
+  side : Ω → Option E
+  flip : E → E
+  flip_inv : Function.Involutive flip
+  flip_ne : ∀ e, flip e ≠ e
+  side_partner : ∀ x e, side x = some e → side (pairing.partner x) = some (flip e)
+
+namespace Data
+variable (D : Data (Ω := Ω) (B := B) (E := E))
+
+/-- The positions of one comparison side in a pair of occurrence blocks. -/
+def slice (e : E) (o p : B) : Finset Ω :=
+  (D.positions o).filter (fun x => D.side x = some e ∧ D.pairing.partner x ∈ D.positions p)
+
+theorem slice_mem {e : E} {o p : B} {x : Ω} :
+    x ∈ D.slice e o p ↔ x ∈ D.positions o ∧ D.side x = some e ∧ D.pairing.partner x ∈ D.positions p := by
+  simp only [slice,Finset.mem_filter]
+
+def reverseSlice (e : E) (o p : B) : D.slice e o p ≃ D.slice (D.flip e) p o where
+  toFun x := ⟨D.pairing.partner x.val,by
+    obtain ⟨hx,he,hp⟩ := D.slice_mem.mp x.property
+    exact D.slice_mem.mpr ⟨hp,D.side_partner x.val e he,by rwa [D.pairing.involutive]⟩⟩
+  invFun x := ⟨D.pairing.partner x.val,by
+    obtain ⟨hx,he,hp⟩ := D.slice_mem.mp x.property
+    exact D.slice_mem.mpr ⟨hp,by simpa only [D.flip_inv e] using D.side_partner x.val (D.flip e) he,
+      by rwa [D.pairing.involutive]⟩⟩
+  left_inv x := Subtype.ext (D.pairing.involutive x.val)
+  right_inv x := Subtype.ext (D.pairing.involutive x.val)
+
+theorem slice_card (e : E) (o p : B) : (D.slice e o p).card = (D.slice (D.flip e) p o).card := by
+  simpa using Fintype.card_congr (D.reverseSlice e o p)
+
+def Joined (o p : B) : Prop :=
+  ∃ e, (D.positions o).card < 2*(D.slice e o p).card ∧
+    (D.positions p).card < 2*(D.slice e o p).card ∧
+    (D.positions o).card ≤ (D.slice e o p).card+D.error ∧
+    (D.positions p).card ≤ (D.slice e o p).card+D.error
+
+theorem joined_symm {o p : B} (h : D.Joined o p) : D.Joined p o := by
+  obtain ⟨e,ho,hp,heo,hep⟩ := h
+  rw [D.slice_card e o p] at ho hp heo hep
+  exact ⟨D.flip e,hp,ho,hep,heo⟩
+
+theorem joined_ne {o p : B} (h : D.Joined o p) : o ≠ p := by
+  intro he
+  subst p
+  obtain ⟨e,ho,_⟩ := h
+  have hd : Disjoint (D.slice e o o) (D.slice (D.flip e) o o) := by
+    apply Finset.disjoint_left.mpr
+    intro x hx hy
+    have hx' := (D.slice_mem.mp hx).2.1
+    have hy' := (D.slice_mem.mp hy).2.1
+    exact D.flip_ne e (Option.some.inj (hy'.symm.trans hx'))
+  have hu : D.slice e o o ∪ D.slice (D.flip e) o o ⊆ D.positions o :=
+    Finset.union_subset (Finset.filter_subset _ _) (Finset.filter_subset _ _)
+  have hc := Finset.card_le_card hu
+  rw [Finset.card_union_of_disjoint hd,← D.slice_card e o o] at hc
+  omega
+
+theorem joined_unique {o p q : B} (hp : D.Joined o p) (hq : D.Joined o q) : p = q := by
+  by_contra hne
+  obtain ⟨e,ho,_⟩ := hp
+  obtain ⟨f,ho',_⟩ := hq
+  have hd : Disjoint (D.slice e o p) (D.slice f o q) := by
+    apply Finset.disjoint_left.mpr
+    intro x hx hy
+    exact Finset.disjoint_left.mp (D.disjoint hne) (D.slice_mem.mp hx).2.2 (D.slice_mem.mp hy).2.2
+  have hu : D.slice e o p ∪ D.slice f o q ⊆ D.positions o :=
+    Finset.union_subset (Finset.filter_subset _ _) (Finset.filter_subset _ _)
+  have hc := Finset.card_le_card hu
+  rw [Finset.card_union_of_disjoint hd] at hc
+  omega
+
+def partner (o : B) : B := if h : ∃ p, D.Joined o p then h.choose else o
+
+theorem partner_spec {o p : B} (h : D.Joined o p) : D.partner o = p := by
+  unfold partner
+  rw [dite_eq_left ⟨p,h⟩]
+  exact D.joined_unique (Exists.choose_spec _) h
+
+theorem partner_involutive : Function.Involutive D.partner := by
+  intro o
+  by_cases h : ∃ p, D.Joined o p
+  · obtain ⟨p,hp⟩ := h
+    rw [D.partner_spec hp,D.partner_spec (D.joined_symm hp)]
+  · simp only [partner,dite_eq_right h]
+
+def matching : Pairing B := ⟨D.partner,D.partner_involutive⟩
+
+theorem matched_iff (o : B) : (D.matching.partner o ≠ o) ↔ ∃ p, D.Joined o p := by
+  change D.partner o ≠ o ↔ _
+  constructor
+  · intro h
+    by_contra hn
+    exact h (by simp [partner,hn])
+  · rintro ⟨p,hp⟩
+    rw [D.partner_spec hp]
+    exact (D.joined_ne hp).symm
+
+theorem unmatched_iff (o : B) : D.matching.partner o = o ↔ ∀ p, ¬D.Joined o p := by
+  simpa using not_congr (D.matched_iff o)
+
+/-- Explicit error criterion usable with the half-integer alignment lemma. -/
+theorem joined_of_small_deficit {o p : B} {e : E}
+    (hbig_o : 2*D.error < (D.positions o).card) (hbig_p : 2*D.error < (D.positions p).card)
+    (hdef_o : (D.positions o).card-(D.slice e o p).card ≤ D.error)
+    (hdef_p : (D.positions p).card-(D.slice e o p).card ≤ D.error) : D.Joined o p := by
+  exact ⟨e,by omega,by omega,by omega,by omega⟩
+
+open scoped BigOperators
+variable [Fintype Ω] [Fintype B]
+
+def unmatchedBlocks : Finset B := Finset.univ.filter (fun o => D.matching.partner o = o)
+def unpairedPositions : Finset Ω := Finset.univ.filter (fun x => D.pairing.partner x = x)
+
+/-- The source unmatched-block charge, with every rounding/cut error explicit.
+Only the stated local geometric coverage of nonexceptional blocks is needed. -/
+theorem unmatched_mass (s : ℝ) (hs : 0 ≤ s) (exceptional : Finset B)
+    (hsize : ∀ o, s-1 ≤ ((D.positions o).card : ℝ))
+    (hcover : ∀ o, D.matching.partner o = o → o ∉ exceptional →
+      D.positions o ⊆ D.unpairedPositions) :
+    s*(D.unmatchedBlocks.card : ℝ) ≤ (D.unpairedPositions.card : ℝ) +
+      s*exceptional.card + Fintype.card B := by
+  let good := D.unmatchedBlocks \ exceptional
+  have hsubset : good.biUnion D.positions ⊆ D.unpairedPositions := by
+    intro x hx
+    obtain ⟨o,ho,hx⟩ := Finset.mem_biUnion.mp hx
+    obtain ⟨ho,hn⟩ := Finset.mem_sdiff.mp ho
+    exact hcover o (Finset.mem_filter.mp ho).2 hn hx
+  have hsum : (∑ o ∈ good, (D.positions o).card) ≤ D.unpairedPositions.card := by
+    rw [← Finset.card_biUnion (fun o _ p _ hne => D.disjoint hne)]
+    exact Finset.card_le_card hsubset
+  have hsumr : (∑ o ∈ good, ((D.positions o).card : ℝ)) ≤ D.unpairedPositions.card := by
+    exact_mod_cast hsum
+  have hlower : s*(good.card : ℝ) ≤ D.unpairedPositions.card + good.card := by
+    have hh := Finset.sum_le_sum (s := good) (fun o _ => hsize o)
+    simp only [Finset.sum_const,nsmul_eq_mul] at hh
+    nlinarith
+  have hcount : D.unmatchedBlocks.card ≤ good.card+exceptional.card := by
+    have hh := Finset.card_sdiff_add_card_inter D.unmatchedBlocks exceptional
+    have hi := Finset.card_le_card (Finset.inter_subset_right : D.unmatchedBlocks ∩ exceptional ⊆ exceptional)
+    dsimp [good]
+    omega
+  have hcount' : (D.unmatchedBlocks.card : ℝ) ≤ good.card+exceptional.card := by exact_mod_cast hcount
+  have hb : (good.card : ℝ) ≤ Fintype.card B := by exact_mod_cast Finset.card_le_univ good
+  have hh := mul_le_mul_of_nonneg_left hcount' hs
+  nlinarith
+
+end Data
+end TorsionFreeZeroDivisors.OccurrenceMatching
+
+/-! The actual common-grid block matching of an affine comparison system.
+Positions are the literal half-integer edge indices within each traversal. -/
+namespace TorsionFreeZeroDivisors.ComparedBlocks
+open scoped Classical BigOperators
+open BlockAlignment EntropyStages
+variable {T E : Type*}
+
+abbrev Position (len : T → ℕ) := (t : T) × (positions 0 (len t))
+abbrev Block (s : ℝ) (len : T → ℕ) := (t : T) × Fin (blockCount s (len t))
+
+variable (s : ℝ) (hs : 0 < s) (len : T → ℕ)
+
+def includeBlock (b : Block s len) : block s b.2.val ↪ Position len where
+  toFun q := ⟨b.1,⟨q.val,full_subset s hs (len b.1) b.2 q.property⟩⟩
+  inj' := by
+    intro q r h
+    exact Subtype.ext (congrArg (fun x : Position len => x.2.val) h)
+
+def blockPositions (b : Block s len) : Finset (Position len) :=
+  (block s b.2.val).attach.map (includeBlock s hs len b)
+
+theorem mem_blockPositions {b : Block s len} {x : Position len} :
+    x ∈ blockPositions s hs len b ↔ x.1 = b.1 ∧ x.2.val ∈ block s b.2.val := by
+  constructor
+  · intro hx
+    obtain ⟨y,_,he⟩ := Finset.mem_map.mp hx
+    cases he
+    exact ⟨rfl,y.property⟩
+  · rintro ⟨he,hq⟩
+    apply Finset.mem_map.mpr
+    refine ⟨⟨x.2.val,hq⟩,Finset.mem_attach _ _,?_⟩
+    cases b; cases x; dsimp at he; subst he; rfl
+
+theorem blockPositions_card (b : Block s len) :
+    (blockPositions s hs len b).card = (block s b.2.val).card := by
+  simp only [blockPositions,Finset.card_map,Finset.card_attach]
+
+theorem blockPositions_disjoint {b c : Block s len} (hne : b ≠ c) :
+    Disjoint (blockPositions s hs len b) (blockPositions s hs len c) := by
+  apply Finset.disjoint_left.mpr
+  intro x hx hy
+  obtain ⟨he,hx⟩ := (mem_blockPositions s hs len).mp hx
+  obtain ⟨he',hy⟩ := (mem_blockPositions s hs len).mp hy
+  have hb : b.1 = c.1 := he.symm.trans he'
+  have hk : (b.2.val : ℤ) = c.2.val := by
+    by_contra h
+    exact Finset.disjoint_left.mp (block_disjoint s hs h) hx hy
+  cases b; cases c; dsimp at hb hk; subst hb
+  exact hne (by congr 1; apply Fin.ext; exact_mod_cast hk)
+
+include hs in
+/-- Exact full-grid-index converse, rather than clipping a target partner. -/
+theorem fullIndex {t : T} {k : ℤ} (hk : 0 ≤ k)
+    (hfull : ((k : ℝ)+1)*s ≤ len t) :
+    ∃ j : Fin (blockCount s (len t)), (j.val : ℤ) = k := by
+  have hcast : (k.toNat : ℝ) = (k : ℝ) := by exact_mod_cast Int.toNat_of_nonneg hk
+  have hle : k.toNat+1 ≤ blockCount s (len t) := by
+    apply Nat.le_floor
+    rw [Nat.cast_add,Nat.cast_one,hcast]
+    exact (le_div_iff₀ hs).mpr hfull
+  exact ⟨⟨k.toNat,by omega⟩,Int.toNat_of_nonneg hk⟩
+
+/-- Data of the original disjoint signed interval comparisons on traversals.
+The involution and side predicates retain occurrence indices throughout. -/
+structure Comparisons where
+  pairing : Pairing (Position len)
+  side : Position len → Option E
+  flip : E → E
+  flip_inv : Function.Involutive flip
+  flip_ne : ∀ e, flip e ≠ e
+  side_partner : ∀ x e, side x = some e → side (pairing.partner x) = some (flip e)
+  none_iff : ∀ x, side x = none ↔ pairing.partner x = x
+  source : E → T
+  lo : E → ℝ
+  hi : E → ℝ
+  reverse : E → Bool
+  offset : E → ℤ
+  side_iff : ∀ x e, side x = some e ↔ x.1 = source e ∧ x.2.val ∈ positions (lo e) (hi e)
+  partner_source : ∀ x e, side x = some e → (pairing.partner x).1 = source (flip e)
+  partner_coordinate : ∀ x e, side x = some e →
+    (pairing.partner x).2.val = affine (reverse e) (offset e) x.2.val
+  target_range : ∀ e, if reverse e then
+      0 ≤ (offset e : ℝ)-hi e ∧ (offset e : ℝ)-lo e ≤ len (source (flip e))
+    else 0 ≤ lo e+(offset e : ℝ) ∧ hi e+(offset e : ℝ) ≤ len (source (flip e))
+
+namespace Comparisons
+variable (C : Comparisons (E := E) len) (err : ℕ)
+
+def matchingData : OccurrenceMatching.Data (Ω := Position len) (B := Block s len) (E := E) where
+  error := err
+  positions := blockPositions s hs len
+  disjoint := blockPositions_disjoint s hs len
+  pairing := C.pairing
+  side := C.side
+  flip := C.flip
+  flip_inv := C.flip_inv
+  flip_ne := C.flip_ne
+  side_partner := C.side_partner
+
+/-- The literal integer slice before making any near-full grid approximation. -/
+def integerSlice (e : E) (b p : Block s len) : Finset ℤ :=
+  (block s b.2.val ∩ positions (C.lo e) (C.hi e)).filter
+    (fun q => affine (C.reverse e) (C.offset e) q ∈ block s p.2.val)
+
+theorem slice_sources {e : E} {b p : Block s len}
+    (hne : ((C.matchingData s hs len err).slice e b p).Nonempty) :
+    b.1 = C.source e ∧ p.1 = C.source (C.flip e) := by
+  obtain ⟨x,hx⟩ := hne
+  obtain ⟨hb,he,hp⟩ := (OccurrenceMatching.Data.slice_mem _).mp hx
+  have hb' := ((mem_blockPositions s hs len).mp hb).1
+  have hp' := ((mem_blockPositions s hs len).mp hp).1
+  exact ⟨hb'.symm.trans ((C.side_iff x e).mp he).1,
+    hp'.symm.trans (C.partner_source x e he)⟩
+
+theorem slice_integer_card {e : E} {b p : Block s len}
+    (hsource : b.1 = C.source e) (htarget : p.1 = C.source (C.flip e)) :
+    ((C.matchingData s hs len err).slice e b p).card =
+      (C.integerSlice s len e b p).card := by
+  apply Finset.card_bij (fun x _ => x.2.val)
+  · intro x hx
+    obtain ⟨hb,he,hp⟩ := (OccurrenceMatching.Data.slice_mem _).mp hx
+    refine Finset.mem_filter.mpr ⟨Finset.mem_inter.mpr
+      ⟨((mem_blockPositions s hs len).mp hb).2,((C.side_iff x e).mp he).2⟩,?_⟩
+    have hh := ((mem_blockPositions s hs len).mp hp).2
+    change (C.pairing.partner x).2.val ∈ block s p.2.val at hh
+    rwa [C.partner_coordinate x e he] at hh
+  · intro x hx y hy he
+    have hx' := ((mem_blockPositions s hs len).mp ((OccurrenceMatching.Data.slice_mem _).mp hx).1).1
+    have hy' := ((mem_blockPositions s hs len).mp ((OccurrenceMatching.Data.slice_mem _).mp hy).1).1
+    have hxy := hx'.trans hy'.symm
+    cases x; cases y; dsimp at hxy he; subst hxy
+    congr 1
+    exact Subtype.ext he
+  · intro q hq
+    obtain ⟨hq,hp⟩ := Finset.mem_filter.mp hq
+    obtain ⟨hb,he⟩ := Finset.mem_inter.mp hq
+    let x : Position len := ⟨b.1,⟨q,full_subset s hs (len b.1) b.2 hb⟩⟩
+    have hx : C.side x = some e := (C.side_iff x e).mpr ⟨hsource,he⟩
+    refine ⟨x,(OccurrenceMatching.Data.slice_mem _).mpr ⟨?_,hx,?_⟩,rfl⟩
+    · exact (mem_blockPositions s hs len).mpr ⟨rfl,hb⟩
+    · apply (mem_blockPositions s hs len).mpr
+      refine ⟨(C.partner_source x e hx).trans htarget.symm,?_⟩
+      change (C.pairing.partner x).2.val ∈ block s p.2.val
+      rwa [C.partner_coordinate x e hx]
+
+/-- The original side comparison covers this entire source block. -/
+theorem side_of_margin {b : Block s len} {e : E} (hsource : b.1 = C.source e)
+    (hlo : C.lo e ≤ (b.2.val : ℝ)*s-s)
+    (hhi : ((b.2.val : ℝ)+1)*s+s ≤ C.hi e)
+    {x : Position len} (hx : x ∈ blockPositions s hs len b) : C.side x = some e := by
+  obtain ⟨he,hx⟩ := (mem_blockPositions s hs len).mp hx
+  obtain ⟨hx0,hx1⟩ := mem_positions.mp hx
+  apply (C.side_iff x e).mpr
+  refine ⟨he.trans hsource,mem_positions.mpr ?_⟩
+  simp only [Int.cast_natCast] at hx0 hx1
+  constructor <;> linarith
+
+/-- The full slice is exactly the algebraic source overlap. -/
+theorem slice_card_eq {b p : Block s len} {e : E} {ν : ℤ}
+    (hsource : b.1 = C.source e) (htarget : p.1 = C.source (C.flip e))
+    (hindex : (p.2.val : ℤ) = partnerIndex (C.reverse e) ν b.2.val)
+    (hlo : C.lo e ≤ (b.2.val : ℝ)*s-s)
+    (hhi : ((b.2.val : ℝ)+1)*s+s ≤ C.hi e) :
+    ((C.matchingData s hs len err).slice e b p).card =
+      (overlap s (C.reverse e) (C.offset e) b.2.val ν).card := by
+  apply Finset.card_bij (fun x _ => x.2.val)
+  · intro x hx
+    obtain ⟨hx,he,hp⟩ := (OccurrenceMatching.Data.slice_mem _).mp hx
+    have hc := C.partner_coordinate x e he
+    have hm := ((mem_blockPositions s hs len).mp hp).2
+    change (C.pairing.partner x).2.val ∈ block s p.2.val at hm
+    refine Finset.mem_filter.mpr ⟨((mem_blockPositions s hs len).mp hx).2,?_⟩
+    rwa [hc,hindex] at hm
+  · intro x hx y hy he
+    have hx' := ((mem_blockPositions s hs len).mp ((OccurrenceMatching.Data.slice_mem _).mp hx).1).1
+    have hy' := ((mem_blockPositions s hs len).mp ((OccurrenceMatching.Data.slice_mem _).mp hy).1).1
+    have hxy := hx'.trans hy'.symm
+    cases x; cases y; dsimp at hxy he; subst hxy
+    congr 1
+    exact Subtype.ext he
+  · intro q hq
+    obtain ⟨hq,hq'⟩ := Finset.mem_filter.mp hq
+    let x : Position len := ⟨b.1,⟨q,full_subset s hs (len b.1) b.2 hq⟩⟩
+    have hx : x ∈ blockPositions s hs len b := (mem_blockPositions s hs len).mpr ⟨rfl,hq⟩
+    have he := C.side_of_margin s hs len hsource hlo hhi hx
+    refine ⟨x,(OccurrenceMatching.Data.slice_mem _).mpr ⟨hx,he,?_⟩,rfl⟩
+    apply (mem_blockPositions s hs len).mpr
+    refine ⟨(C.partner_source x e he).trans htarget.symm,?_⟩
+    change (C.pairing.partner x).2.val ∈ block s p.2.val
+    rw [C.partner_coordinate x e he,hindex]
+    exact hq'
+
+/-- A block deep inside an actual comparison has a near-full selected partner. -/
+theorem joined_of_margin {b : Block s len} {e : E} {ν : ℤ}
+    (hsource : b.1 = C.source e)
+    (hsmall : 2*(err : ℝ) < s-1)
+    (herr : 2*|(C.offset e : ℝ)-(ν : ℝ)*s|+4 ≤ err)
+    (hlo : C.lo e ≤ (b.2.val : ℝ)*s-s)
+    (hhi : ((b.2.val : ℝ)+1)*s+s ≤ C.hi e) :
+    ∃ p, (C.matchingData s hs len err).Joined b p := by
+  have ha : |(C.offset e : ℝ)-(ν : ℝ)*s| ≤ s := by
+    have hh := abs_nonneg ((C.offset e : ℝ)-(ν : ℝ)*s)
+    linarith
+  obtain ⟨hk0,hk1⟩ := partner_full s hs (C.reverse e) (C.offset e) b.2.val ν
+    (C.lo e) (C.hi e) (len (C.source (C.flip e))) ha hlo hhi (C.target_range e)
+  obtain ⟨j,hj⟩ := fullIndex s hs len hk0 hk1
+  let p : Block s len := ⟨C.source (C.flip e),j⟩
+  have hslice := C.slice_card_eq s hs len err hsource (p := p) rfl hj hlo hhi
+  refine ⟨p,OccurrenceMatching.Data.joined_of_small_deficit _ (e := e) ?_ ?_ ?_ ?_⟩
+  · change 2*err < (blockPositions s hs len b).card
+    rw [blockPositions_card]
+    have hh := card_lower ((b.2.val : ℝ)*s) (((b.2.val : ℝ)+1)*s)
+    have hr : 2*(err : ℝ) < (block s b.2.val).card := by simp only [block,Int.cast_natCast]; nlinarith
+    exact_mod_cast hr
+  · change 2*err < (blockPositions s hs len p).card
+    rw [blockPositions_card]
+    have hh := card_lower ((p.2.val : ℝ)*s) (((p.2.val : ℝ)+1)*s)
+    have hr : 2*(err : ℝ) < (block s p.2.val).card := by simp only [block,Int.cast_natCast]; nlinarith
+    exact_mod_cast hr
+  · change (blockPositions s hs len b).card- _ ≤ err
+    rw [blockPositions_card,hslice]
+    have hh := (overlap_deficit s hs.le (C.reverse e) (C.offset e) b.2.val ν).trans herr
+    exact_mod_cast hh
+  · change (blockPositions s hs len p).card- _ ≤ err
+    rw [blockPositions_card,hslice]
+    have hc := Fintype.card_congr (overlapEquiv s (C.reverse e) (C.offset e) b.2.val ν)
+    simp only [Fintype.card_coe] at hc
+    rw [hc]
+    have hh := overlap_deficit s hs.le (C.reverse e) (inverseOffset (C.reverse e) (C.offset e))
+      (partnerIndex (C.reverse e) ν b.2.val) (inverseOffset (C.reverse e) ν)
+    rw [inverse_error] at hh
+    have hr := hh.trans herr
+    change ((block s j.val).card - _) ≤ _
+    rw [hj]
+    exact_mod_cast hr
+
+variable [Fintype T] [Fintype E]
+
+def nearCutBlocks (t : T) (cut : ℝ) : Finset (Block s len) :=
+  Finset.univ.filter (fun b => b.1 = t ∧ (b.2.val : ℤ) ∈ nearCut s cut)
+
+theorem nearCutBlocks_card (t : T) (cut : ℝ) : (nearCutBlocks s len t cut).card ≤ 11 := by
+  apply le_trans ?_ (nearCut_card s cut)
+  refine Finset.card_le_card_of_injOn (fun b : Block s len => (b.2.val : ℤ)) ?_ ?_
+  · intro b hb
+    exact (Finset.mem_filter.mp hb).2.2
+  · intro b hb c hc he
+    have hb' := (Finset.mem_filter.mp hb).2.1
+    have hc' := (Finset.mem_filter.mp hc).2.1
+    have hbc := hb'.trans hc'.symm
+    cases b; cases c; dsimp at hbc he; subst hbc
+    congr 1
+    apply Fin.ext
+    exact_mod_cast he
+
+def exceptional : Finset (Block s len) :=
+  Finset.univ.biUnion (fun e : E =>
+    nearCutBlocks s len (C.source e) (C.lo e) ∪ nearCutBlocks s len (C.source e) (C.hi e))
+
+theorem exceptional_card : (C.exceptional s len).card ≤ 22*Fintype.card E := by
+  have h1 := Finset.card_biUnion_le (s := (Finset.univ : Finset E))
+    (t := fun e => nearCutBlocks s len (C.source e) (C.lo e) ∪ nearCutBlocks s len (C.source e) (C.hi e))
+  have h2 : ∀ e : E, (nearCutBlocks s len (C.source e) (C.lo e) ∪
+      nearCutBlocks s len (C.source e) (C.hi e)).card ≤ 22 := by
+    intro e
+    have h := Finset.card_union_le (nearCutBlocks s len (C.source e) (C.lo e))
+      (nearCutBlocks s len (C.source e) (C.hi e))
+    have h3 := nearCutBlocks_card s len (C.source e) (C.lo e)
+    have h4 := nearCutBlocks_card s len (C.source e) (C.hi e)
+    omega
+  have h3 := Finset.sum_le_sum (s := (Finset.univ : Finset E)) (fun e _ => h2 e)
+  simpa [exceptional,Nat.mul_comm] using h1.trans h3
+
+/-- No point of a deep unmatched block belongs to any original comparison. -/
+theorem unmatched_unpaired (ν : E → ℤ)
+    (hsmall : 2*(err : ℝ) < s-1)
+    (herr : ∀ e, 2*|(C.offset e : ℝ)-(ν e : ℝ)*s|+4 ≤ err)
+    {b : Block s len} (hb : (C.matchingData s hs len err).matching.partner b = b)
+    (hn : b ∉ C.exceptional s len) :
+    blockPositions s hs len b ⊆ (C.matchingData s hs len err).unpairedPositions := by
+  intro x hx
+  simp only [OccurrenceMatching.Data.unpairedPositions,Finset.mem_filter,Finset.mem_univ,true_and]
+  change C.pairing.partner x = x
+  apply (C.none_iff x).mp
+  cases he : C.side x with
+  | none => rfl
+  | some e =>
+    exfalso
+    obtain ⟨hxsource,hdom⟩ := (C.side_iff x e).mp he
+    obtain ⟨hxb,hxk⟩ := (mem_blockPositions s hs len).mp hx
+    have hsource := hxb.symm.trans hxsource
+    have hnlo : (b.2.val : ℤ) ∉ nearCut s (C.lo e) := by
+      intro h
+      apply hn
+      exact Finset.mem_biUnion.mpr ⟨e,Finset.mem_univ _,Finset.mem_union_left _
+        (Finset.mem_filter.mpr ⟨Finset.mem_univ _,hsource,h⟩)⟩
+    have hnhi : (b.2.val : ℤ) ∉ nearCut s (C.hi e) := by
+      intro h
+      apply hn
+      exact Finset.mem_biUnion.mpr ⟨e,Finset.mem_univ _,Finset.mem_union_right _
+        (Finset.mem_filter.mpr ⟨Finset.mem_univ _,hsource,h⟩)⟩
+    obtain ⟨hl,hr⟩ := margin_of_not_near s hs (C.lo e) (C.hi e) b.2.val x.2.val hxk hdom hnlo hnhi
+    obtain ⟨p,hp⟩ := C.joined_of_margin s hs len err hsource hsmall (herr e) hl hr
+    exact (OccurrenceMatching.Data.unmatched_iff _ b).mp hb p hp
+
+include hs in
+/-- The full block mass and hence the rounding charge use the total actual
+traversal length, with no prescribed occurrence-count estimate. -/
+theorem block_mass : s*(Fintype.card (Block s len) : ℝ) ≤ ∑ t, (len t : ℝ) := by
+  have he : (Fintype.card (Block s len) : ℝ) = ∑ t, (blockCount s (len t) : ℝ) := by
+    simp only [Block,Fintype.card_sigma,Fintype.card_fin,Nat.cast_sum]
+  rw [he,Finset.mul_sum]
+  apply Finset.sum_le_sum
+  intro t _
+  simpa [mul_comm] using (count_bound s hs (len t)).1
+
+theorem unmatched_bound (ν : E → ℤ)
+    (hsmall : 2*(err : ℝ) < s-1)
+    (herr : ∀ e, 2*|(C.offset e : ℝ)-(ν e : ℝ)*s|+4 ≤ err) :
+    s*((C.matchingData s hs len err).unmatchedBlocks.card : ℝ) ≤
+      (C.matchingData s hs len err).unpairedPositions.card +
+      22*s*Fintype.card E + (∑ t, (len t : ℝ))/s := by
+  have hm := OccurrenceMatching.Data.unmatched_mass (C.matchingData s hs len err)
+    s hs.le (C.exceptional s len) (fun b => ?_) (fun b hb hn =>
+      C.unmatched_unpaired s hs len err ν hsmall herr hb hn)
+  · have hex : ((C.exceptional s len).card : ℝ) ≤ 22*Fintype.card E := by
+      exact_mod_cast C.exceptional_card s len
+    have hb : (Fintype.card (Block s len) : ℝ) ≤ (∑ t, (len t : ℝ))/s :=
+      (le_div_iff₀ hs).mpr (by simpa [mul_comm] using block_mass s hs len)
+    have hmul := mul_le_mul_of_nonneg_left hex hs.le
+    nlinarith
+  · change s-1 ≤ (blockPositions s hs len b).card
+    rw [blockPositions_card]
+    have hh := card_lower ((b.2.val : ℝ)*s) (((b.2.val : ℝ)+1)*s)
+    simpa [block,mul_add,add_mul] using hh
+
+end Comparisons
+end TorsionFreeZeroDivisors.ComparedBlocks
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/GroupRing/ExpansionDiameter.lean b/lean/OAI/Algebra/GroupRing/ExpansionDiameter.lean
new file mode 100644
index 0000000000000000000000000000000000000000..ffcc643cc01193331b37702ef589d295ae99653f
--- /dev/null
+++ b/lean/OAI/Algebra/GroupRing/ExpansionDiameter.lean
@@ -0,0 +1,417 @@
+import Mathlib
+import OAI.Algebra.GroupRing.RawDecomposition
+
+namespace OAI
+
+noncomputable section
+
+namespace TorsionFreeZeroDivisors.ExpansionDiameter
+open scoped Classical BigOperators
+variable {V : Type*} [Fintype V] (G : SimpleGraph V)
+
+def ball (v : V) (r : ℕ) : Finset V :=
+  Finset.univ.filter fun w => G.edist v w  ≤  r
+
+@[simp] lemma mem_ball (v w : V) (r : ℕ) : w∈ball G v r ↔ G.edist v w  ≤  r := by
+  simp [ball]
+
+lemma self_mem_ball (v : V) (r : ℕ) : v∈ball G v r := by simp
+
+lemma ball_mono (v : V) {r s : ℕ} (h : r ≤ s) : ball G v r ⊆ ball G v s := by
+  intro w hw
+  exact (mem_ball G v w s).mpr (((mem_ball G v w r).mp hw).trans (by exact_mod_cast h))
+
+def neighbors (S : Finset V) : Finset V :=
+  S ∪ Finset.univ.filter fun w => ∃ v∈S, G.Adj v w
+
+lemma neighbors_ball (v : V) (r : ℕ) : neighbors G (ball G v r) ⊆ ball G v (r+1) := by
+  intro w hw
+  rcases Finset.mem_union.mp hw with hw | hw
+  · exact ball_mono G v (Nat.le_succ r) hw
+  · obtain ⟨z,hz,hzw⟩ := (Finset.mem_filter.mp hw).2
+    apply (mem_ball G v w (r+1)).mpr
+    calc
+      G.edist v w  ≤  G.edist v z + G.edist z w := G.edist_triangle
+      _  ≤  (r:ℕ∞)+1 := by
+        apply add_le_add
+        · exact (mem_ball G v z r).mp hz
+        · exact (SimpleGraph.edist_eq_one_iff_adj.mpr hzw).le
+      _ = _ := by simp
+
+/-- Doubling small sets forces every logarithmic-radius ball above the
+expansion threshold, uniformly over all connected components. -/
+theorem ball_large (B R : ℕ)
+    (hexp : ∀ S : Finset V, S.Nonempty → S.card ≤ B → 2*S.card  ≤  (neighbors G S).card)
+    (hR : B<2^R) (v : V) : B<(ball G v R).card := by
+  have hstep (r : ℕ) : B<(ball G v r).card ∨ 2^r  ≤  (ball G v r).card := by
+    induction r with
+    | zero => exact Or.inr (by simpa using Finset.card_pos.mpr ⟨v,self_mem_ball G v 0⟩)
+    | succ r ih =>
+      have hmono := Finset.card_le_card (ball_mono G v (Nat.le_succ r))
+      rcases ih with h | h
+      · exact Or.inl (h.trans_le hmono)
+      · by_cases ht : B<(ball G v r).card
+        · exact Or.inl (ht.trans_le hmono)
+        · right
+          have hh := (hexp (ball G v r) ⟨v,self_mem_ball G v r⟩ (Nat.le_of_not_gt ht)).trans
+            (Finset.card_le_card (neighbors_ball G v r))
+          calc
+            2^(r+1) = 2*2^r := by rw [pow_succ,Nat.mul_comm]
+            _  ≤  2*(ball G v r).card := Nat.mul_le_mul_left _ h
+            _  ≤  _ := hh
+  rcases hstep R with h | h
+  · exact h
+  · exact hR.trans_le h
+
+omit [Fintype V] in
+lemma shortest_prefix {u v : V} (p : G.Walk u v)
+    (hp : p.length=G.dist u v) (i : ℕ) (hi : i ≤ p.length) :
+    G.edist u (p.getVert i) = i := by
+  have hd := SimpleGraph.length_eq_dist_of_subwalk hp (p.isSubwalk_take i)
+  have hdi : G.dist u (p.getVert i)=i := by
+    rw [← hd,SimpleGraph.Walk.take_length,inf_eq_left.mpr hi]
+  rw [← (p.take i).reachable.coe_dist_eq_edist,hdi]
+
+lemma spaced_balls_disjoint {u v : V} (p : G.Walk u v)
+    (hp : p.length=G.dist u v) (R i j : ℕ) (hij : i<j)
+    (hj : j*(2*R+1) ≤ p.length) :
+    Disjoint (ball G (p.getVert (i*(2*R+1))) R)
+      (ball G (p.getVert (j*(2*R+1))) R) := by
+  apply Finset.disjoint_left.mpr
+  intro z hz hz'
+  have hi : i*(2*R+1) ≤ p.length :=
+    (Nat.mul_le_mul_right _ (Nat.le_of_lt hij)).trans hj
+  have hzz : G.edist (p.getVert (i*(2*R+1))) (p.getVert (j*(2*R+1)))  ≤  (2*R:ℕ) := by
+    calc
+      _  ≤  G.edist (p.getVert (i*(2*R+1))) z +
+          G.edist z (p.getVert (j*(2*R+1))) := G.edist_triangle
+      _  ≤  (R:ℕ∞)+R := add_le_add ((mem_ball G _ _ _).mp hz)
+        (by rw [G.edist_comm]; exact (mem_ball G _ _ _).mp hz')
+      _ = _ := by push_cast; ring
+  have htri := G.edist_triangle (u:=u) (v:=p.getVert (i*(2*R+1)))
+    (w:=p.getVert (j*(2*R+1)))
+  rw [shortest_prefix G p hp _ hi,shortest_prefix G p hp _ hj] at htri
+  have hle := htri.trans (add_le_add le_rfl hzz)
+  have hle' : j*(2*R+1) ≤ i*(2*R+1)+2*R := by exact_mod_cast hle
+  have hgap := Nat.mul_le_mul_right (2*R+1) (Nat.succ_le_of_lt hij)
+  rw [Nat.succ_mul] at hgap
+  omega
+
+/-- Quantitative packing: a shortest walk carries disjoint large balls at
+uniformly spaced centers. -/
+theorem diameter_bound (B R : ℕ)
+    (hexp : ∀ S : Finset V, S.Nonempty → S.card ≤ B → 2*S.card  ≤  (neighbors G S).card)
+    (hR : B<2^R) {u v : V} (huv : G.Reachable u v) :
+    G.dist u v < (Fintype.card V/(B+1)+1)*(2*R+1) := by
+  obtain ⟨p,hp⟩ := huv.exists_walk_length_eq_dist
+  let step := 2*R+1
+  let q := p.length/step+1
+  let centers (i : Fin q) := p.getVert (i.val*step)
+  have hpos : 0<step := by dsimp [step]; omega
+  have hcenter (i : Fin q) : i.val*step ≤ p.length := by
+    have hi : i.val ≤ p.length/step := by have := i.isLt; dsimp [q] at this; omega
+    exact (Nat.mul_le_mul_right _ hi).trans (Nat.div_mul_le_self _ _)
+  have hdis : (↑(Finset.univ : Finset (Fin q)) : Set (Fin q)).PairwiseDisjoint (fun i => ball G (centers i) R) := by
+    intro i _ j _ hij
+    rcases lt_or_gt_of_ne (Fin.val_ne_of_ne hij) with hlt | hlt
+    · exact spaced_balls_disjoint G p hp R i.val j.val hlt (hcenter j)
+    · exact (spaced_balls_disjoint G p hp R j.val i.val hlt (hcenter i)).symm
+  have hpack : q*(B+1)  ≤  Fintype.card V := by
+    calc
+      _ = ∑ _i : Fin q, (B+1) := by simp
+      _  ≤  ∑ i : Fin q, (ball G (centers i) R).card := by
+        apply Finset.sum_le_sum
+        intro i _
+        exact Nat.succ_le_of_lt (ball_large G B R hexp hR (centers i))
+      _ = (Finset.univ.biUnion (fun i : Fin q => ball G (centers i) R)).card :=
+        (Finset.card_biUnion hdis).symm
+      _  ≤  Fintype.card V := Finset.card_le_univ _
+  have hq : q ≤ Fintype.card V/(B+1) := (Nat.le_div_iff_mul_le (by omega)).mpr hpack
+  have hpq : p.length < q*step := by
+    dsimp [q]
+    simpa [Nat.mul_comm] using Nat.lt_mul_div_succ p.length hpos
+  rw [← hp]
+  exact hpq.trans_le (Nat.mul_le_mul_right _ (hq.trans (Nat.le_succ _)))
+
+end TorsionFreeZeroDivisors.ExpansionDiameter
+
+/-! Quantitative probability estimates for dense witnesses in conditioned
+matchings. -/
+namespace TorsionFreeZeroDivisors.DiameterProbability
+open scoped BigOperators Topology Classical
+open Filter
+
+lemma choose_bound (n r : ℕ) (hr : 0<r) :
+    (n.choose r : ℝ) ≤ (3*n/r)^r := by
+  have hr0 : (0:ℝ)<r := by exact_mod_cast hr
+  have hpow : (r:ℝ)^r/(r.factorial:ℝ) ≤ Real.exp (r:ℝ) :=
+    Real.pow_div_factorial_le_exp _ (le_of_lt hr0) _
+  have he : Real.exp (r:ℝ) ≤ (3:ℝ)^r := by
+    rw [show (r:ℝ)=(r:ℝ)*1 by ring,Real.exp_nat_mul]
+    exact pow_le_pow_left₀ (le_of_lt (Real.exp_pos 1))
+      (le_of_lt (lt_trans Real.exp_one_lt_d9 (by norm_num))) r
+  calc
+    (n.choose r : ℝ) ≤ (n:ℝ)^r/(r.factorial:ℝ) := Nat.choose_le_pow_div _ _
+    _ = ((n:ℝ)/r)^r * ((r:ℝ)^r/(r.factorial:ℝ)) := by
+      rw [div_pow]
+      field_simp
+    _ ≤ ((n:ℝ)/r)^r * (3:ℝ)^r :=
+      mul_le_mul_of_nonneg_left (hpow.trans he) (by positivity)
+    _ = (3*n/r)^r := by rw [← mul_pow]; congr 1; ring
+
+/-- A summable envelope with exponent 62, sufficient to obtain an o(1) event. -/
+lemma witness_envelope (n k r : ℕ) (d p R : ℝ)
+    (hk : 0<k) (hn : (k:ℝ) ≤ n) (hd : 1 ≤ d) (hp : 0<p) (hp1 : p ≤ 1) (hR : p*n ≤ R)
+    (hr₁ : 64*k ≤ r) (hr₂ : r ≤ 65*k) (hm : ℕ) (hhm : (hm:ℝ) ≤ (2*k*d)^2) :
+    (n.choose (2*k):ℝ)*(hm.choose r:ℝ)/R^r ≤
+      (9*(12*d^2/p)^65*((k:ℝ)/n)^62)^k := by
+  have hk0 : (0:ℝ)<k := by exact_mod_cast hk
+  have hn0 : (0:ℝ)<n := hk0.trans_le hn
+  have hR0 : (0:ℝ)<R := (mul_pos hp hn0).trans_le hR
+  have hr0 : 0<r := by omega
+  have hr0' : (0:ℝ)<r := by exact_mod_cast hr0
+  have hkr : (k:ℝ) ≤ r := by exact_mod_cast (show k ≤ r by omega)
+  have ha : (0:ℝ) ≤ 3*n/(2*k) := by positivity
+  have hb : (0:ℝ) ≤ 12*d^2*k/(p*n) := by positivity
+  have hc : (0:ℝ) ≤ (hm.choose r:ℝ) := by positivity
+  have hterm : (n.choose (2*k):ℝ)*(hm.choose r:ℝ)/R^r ≤
+      (3*n/(2*k))^(2*k)*(12*d^2*k/(p*n))^r := by
+    calc
+      _ ≤ (3*n/(2*k))^(2*k) * (3*hm/r)^r / R^r := by
+        apply div_le_div_of_nonneg_right _ (by positivity)
+        apply mul_le_mul (by simpa using choose_bound n (2*k) (by omega))
+          (choose_bound hm r hr0) hc (by positivity)
+      _ = (3*n/(2*k))^(2*k) * (3*hm/r/R)^r := by rw [div_pow]; ring
+      _ ≤ _ := by
+        apply mul_le_mul_of_nonneg_left _ (by positivity)
+        apply pow_le_pow_left₀ (by positivity)
+        apply (div_le_iff₀ hR0).mpr
+        have hh : 3*(hm:ℝ)/r ≤ 12*d^2*k := by
+          apply (div_le_iff₀ hr0').mpr
+          have hkk := mul_le_mul_of_nonneg_left hkr (show 0 ≤ 12*d^2*k by positivity)
+          nlinarith
+        calc
+          _ ≤ 12*d^2*k := hh
+          _ = (12*d^2*k/(p*n))*(p*n) := by field_simp
+          _ ≤ _ := mul_le_mul_of_nonneg_left hR hb
+  -- Keep constants independent of n,k and use 64k≤r≤65k.
+  have ht : 0 ≤ (k:ℝ)/n := by positivity
+  have ht1 : (k:ℝ)/n ≤ 1 := (div_le_one hn0).mpr hn
+  have hC : 1 ≤ 12*d^2/p := (le_div_iff₀ hp).mpr (by nlinarith [sq_nonneg d])
+  have hbase : (12*d^2*k/(p*n))^r ≤ (12*d^2/p)^(65*k)*((k:ℝ)/n)^(64*k) := by
+    rw [show 12*d^2*k/(p*n)=(12*d^2/p)*((k:ℝ)/n) by ring,mul_pow]
+    apply mul_le_mul
+    · exact pow_le_pow_right₀ hC hr₂
+    · exact pow_le_pow_of_le_one ht ht1 hr₁
+    · positivity
+    · positivity
+  calc
+    _ ≤ (3*n/(2*k))^(2*k)*((12*d^2/p)^(65*k)*((k:ℝ)/n)^(64*k)) :=
+      hterm.trans (mul_le_mul_of_nonneg_left hbase (by positivity))
+    _ ≤ (3*n/k)^(2*k)*((12*d^2/p)^(65*k)*((k:ℝ)/n)^(64*k)) := by
+      apply mul_le_mul_of_nonneg_right _ (by positivity)
+      apply pow_le_pow_left₀ (by positivity)
+      apply div_le_div_of_nonneg_left (by positivity) hk0
+      nlinarith
+    _ = _ := by
+      rw [pow_mul,pow_mul,pow_mul,← mul_pow,← mul_pow]
+      congr 1
+      rw [show (64:ℕ)=2+62 by norm_num,pow_add]
+      have hi : (3*(n:ℝ)/k)^2*((k:ℝ)/n)^2=9 := by
+        rw [← mul_pow]
+        have he : (3*(n:ℝ)/k)*((k:ℝ)/n)=3 := by
+          field_simp
+        rw [he]
+        norm_num
+      calc
+        _ = ((3*(n:ℝ)/k)^2*((k:ℝ)/n)^2)*
+            ((12*d^2/p)^65*((k:ℝ)/n)^62) := by ring
+        _ = _ := by rw [hi]; ring
+
+noncomputable def witnessTerm (C ρ : ℝ) (n k : ℕ) : ℝ :=
+  if 0<k ∧ (k:ℝ) ≤ ρ*n then (C*((k:ℝ)/n)^62)^k else 0
+
+lemma witnessTerm_nonneg {C ρ : ℝ} (hC : 0 ≤ C) (n k : ℕ) :
+    0 ≤ witnessTerm C ρ n k := by
+  unfold witnessTerm
+  split_ifs <;> positivity
+
+lemma witnessTerm_majorant {C ρ : ℝ} (hC : 0 ≤ C)
+    (hsmall : C*ρ^62 ≤ 1/2) (n k : ℕ) (hn : 0<n) :
+    ‖witnessTerm C ρ n k‖ ≤ (1/2:ℝ)^k := by
+  rw [Real.norm_eq_abs,abs_of_nonneg (witnessTerm_nonneg hC n k)]
+  unfold witnessTerm
+  split_ifs with h
+  · apply pow_le_pow_left₀ (by positivity)
+    have hn0 : (0:ℝ)<n := by exact_mod_cast hn
+    have ht : (k:ℝ)/n ≤ ρ := (div_le_iff₀ hn0).mpr h.2
+    exact (mul_le_mul_of_nonneg_left
+      (pow_le_pow_left₀ (by positivity) ht 62) hC).trans hsmall
+  · positivity
+
+lemma witnessTerm_tendsto {C ρ : ℝ} (hC : 0 ≤ C) (k : ℕ) :
+    Tendsto (fun n : ℕ => witnessTerm C ρ n k) atTop (𝓝 0) := by
+  by_cases hk : k=0
+  · subst k
+    simp [witnessTerm]
+  · have ht : Tendsto (fun n : ℕ => (k:ℝ)/n) atTop (𝓝 0) :=
+      tendsto_const_nhds.div_atTop (tendsto_natCast_atTop_atTop (R:=ℝ))
+    have ht' : Tendsto (fun n : ℕ => (C*((k:ℝ)/n)^62)^k) atTop (𝓝 0) := by
+      simpa [hk] using ((ht.pow 62).const_mul C).pow k
+    apply squeeze_zero (witnessTerm_nonneg hC · k) _ ht'
+    intro n
+    unfold witnessTerm
+    split_ifs
+    · exact le_rfl
+    · positivity
+
+/-- The full varying-size union bound tends to zero by dominated convergence. -/
+theorem witness_sum_tendsto {C ρ : ℝ} (hC : 0 ≤ C)
+    (hsmall : C*ρ^62 ≤ 1/2) :
+    Tendsto (fun n : ℕ => ∑' k : ℕ, witnessTerm C ρ n k) atTop (𝓝 0) := by
+  have hsum : Summable (fun k : ℕ => (1/2:ℝ)^k) :=
+    summable_geometric_of_abs_lt_one (by norm_num)
+  have hh := tendsto_tsum_of_dominated_convergence hsum (witnessTerm_tendsto hC)
+    (show ∀ᶠ n : ℕ in atTop, ∀ k : ℕ, ‖witnessTerm C ρ n k‖ ≤ (1/2:ℝ)^k from by
+      filter_upwards [eventually_gt_atTop 0] with n hn k
+      exact witnessTerm_majorant hC hsmall n k hn)
+  simpa using hh
+
+end TorsionFreeZeroDivisors.DiameterProbability
+
+namespace TorsionFreeZeroDivisors.MatchingDiameter
+open scoped Classical BigOperators
+open ConditionedMatchings DiameterCounting
+variable {V D T : Type*} [Fintype V] [Fintype D]
+variable (origin : D → V) {label : D → T} {bar : T → T}
+
+/-- Forgetting multiplicities, with loops contributing only the already
+present vertex to a closed neighborhood. -/
+def simpleGraph (r : Matching label bar) : SimpleGraph V where
+  Adj v w := v ≠ w ∧ ∃ e : D, origin e=v ∧ origin (r e)=w
+  symm := ⟨by
+    rintro v w ⟨h,e,he,hef⟩
+    exact ⟨h.symm,r e,hef,by rw [r.reverse_reverse,he]⟩⟩
+  loopless := ⟨fun _ h => h.1 rfl⟩
+
+lemma neighbors_eq (r : Matching label bar) (S : Finset V) :
+    ExpansionDiameter.neighbors (simpleGraph origin r) S = closedNeighbors origin r S := by
+  ext v
+  simp only [ExpansionDiameter.neighbors,closedNeighbors,Finset.mem_union,
+    Finset.mem_image,mem_ports,Finset.mem_filter,Finset.mem_univ,true_and]
+  change (v ∈ S ∨ ∃ w ∈ S, w ≠ v ∧ ∃ e, origin e = w ∧ origin (r e) = v) ↔ _
+  constructor
+  · rintro (h | ⟨w,hw,_,e,he,hef⟩)
+    · exact Or.inl h
+    · exact Or.inr ⟨e,he ▸ hw,hef⟩
+  · rintro (h | ⟨e,he,hef⟩)
+    · exact Or.inl h
+    · by_cases h : origin e=v
+      · exact Or.inl (h ▸ he)
+      · exact Or.inr ⟨origin e,he,h,e,rfl,hef⟩
+
+def Expands (B : ℕ) (r : Matching label bar) : Prop :=
+  ∀ S : Finset V, S.Nonempty → S.card ≤ B → 2*S.card ≤ (closedNeighbors origin r S).card
+
+def failure (B N : ℕ) : Finset (Matching label bar) :=
+  (Matching.conditioned (label:=label) (bar:=bar) origin N ∅).filter (fun r => ¬Expands origin B r)
+
+theorem failure_subset_dense (B N : ℕ) (hd : ∀ v, 129 ≤ Nat.card {e : D // origin e=v})
+    (hB : 2*B ≤ Fintype.card V) :
+    failure (label:=label) (bar:=bar) origin B N ⊆
+      (Finset.Icc 1 B).biUnion (fun k => denseEvent (label:=label) (bar:=bar) origin N
+        (2*k) ((129*k+1)/2)) := by
+  intro r hr
+  obtain ⟨hr,hf⟩ := Finset.mem_filter.mp hr
+  simp only [Expands,not_forall,not_le] at hf
+  obtain ⟨S,hS,hSB,hfail⟩ := hf
+  apply Finset.mem_biUnion.mpr
+  refine ⟨S.card,Finset.mem_Icc.mpr ⟨Finset.card_pos.mpr hS,hSB⟩,?_⟩
+  exact mem_dense_of_failure origin N S.card 129 r hr hd
+    ((Nat.mul_le_mul_left 2 hSB).trans hB) S rfl (le_of_lt hfail)
+
+lemma r_bounds (k : ℕ) (hk : 0<k) :
+    64*k ≤ (129*k+1)/2 ∧ (129*k+1)/2 ≤ 65*k := by omega
+
+/-- A failure of doubling in the actual conditioned port graph is bounded
+by the summable analytic witness envelope. -/
+theorem failure_probability_bound (B N d R : ℕ) (p ρ : ℝ)
+    (hbar : ∀ t, bar t ≠ t) (hd2 : 2 ≤ d)
+    (hd₀ : ∀ v, 129 ≤ Nat.card {e : D // origin e=v})
+    (hd : ∀ v, Nat.card {e : D // origin e=v} ≤ d)
+    (hB : 2*B ≤ Fintype.card V) (hBρ : (B:ℝ) ≤ ρ*Fintype.card V)
+    (hp : 0<p) (hp1 : p ≤ 1) (hρ : ρ ≤ 1)
+    (hRreal : p*Fintype.card V ≤ R) (hR0 : 0<R)
+    (hR : ∀ x, R+65*B+4*d^(2*N+1) ≤ Nat.card {e : D // label e=label x})
+    (hΩ : (Matching.conditioned (label:=label) (bar:=bar) origin N ∅).Nonempty)
+    (hsum : Summable (fun k : ℕ => DiameterProbability.witnessTerm
+      (9*(12*(d:ℝ)^2/p)^65) ρ (Fintype.card V) k)) :
+    (failure (label:=label) (bar:=bar) origin B N).card /
+      ((Matching.conditioned (label:=label) (bar:=bar) origin N ∅).card:ℝ) ≤
+      ∑' k : ℕ, DiameterProbability.witnessTerm
+        (9*(12*(d:ℝ)^2/p)^65) ρ (Fintype.card V) k := by
+  let Ω := Matching.conditioned (label:=label) (bar:=bar) origin N ∅
+  let event := fun k => denseEvent (label:=label) (bar:=bar) origin N (2*k) ((129*k+1)/2)
+  have hΩ0 : (0:ℝ)<Ω.card := by exact_mod_cast Finset.card_pos.mpr hΩ
+  have hR0' : (0:ℝ)<R := by exact_mod_cast hR0
+  have hkbound (k : ℕ) (hk : k∈Finset.Icc 1 B) :
+      (event k).card/(Ω.card:ℝ) ≤ DiameterProbability.witnessTerm
+        (9*(12*(d:ℝ)^2/p)^65) ρ (Fintype.card V) k := by
+    have hk0 : 0<k := (Finset.mem_Icc.mp hk).1
+    have hkB := (Finset.mem_Icc.mp hk).2
+    have hkρ : (k:ℝ) ≤ ρ*Fintype.card V :=
+      (show (k:ℝ) ≤ B by exact_mod_cast hkB).trans hBρ
+    have hkn : (k:ℝ) ≤ Fintype.card V := hkρ.trans (by
+      simpa using mul_le_mul_of_nonneg_right hρ (Nat.cast_nonneg (Fintype.card V)))
+    have hr := r_bounds k hk0
+    have hprob := dense_count (label:=label) (bar:=bar) origin N (2*k) ((129*k+1)/2)
+      d R hbar hd2 hd (by
+        intro x
+        have hrr := hr.2.trans (Nat.mul_le_mul_left 65 hkB)
+        exact (Nat.add_le_add_right (Nat.add_le_add_left hrr R) _).trans (hR x))
+    have hprob' : (event k).card/(Ω.card:ℝ) ≤
+        ((Fintype.card V).choose (2*k):ℝ)*((((2*k)*d)^2).choose ((129*k+1)/2):ℝ)/
+          (R:ℝ)^((129*k+1)/2) := by
+      apply (div_le_div_iff₀ hΩ0 (pow_pos hR0' _)).mpr
+      exact_mod_cast hprob
+    have hh := DiameterProbability.witness_envelope (Fintype.card V) k ((129*k+1)/2)
+      (d:ℝ) p (R:ℝ) hk0 hkn (by exact_mod_cast (show 1 ≤ d by omega)) hp hp1
+      hRreal hr.1 hr.2 (((2*k)*d)^2) (by push_cast; rfl)
+    unfold DiameterProbability.witnessTerm
+    rw [ite_eq_left (show 0 < k ∧ (k:ℝ) ≤ ρ*Fintype.card V from ⟨hk0,hkρ⟩)]
+    exact hprob'.trans hh
+  calc
+    _ ≤ ((Finset.Icc 1 B).biUnion event).card/(Ω.card:ℝ) := by
+      apply div_le_div_of_nonneg_right _ (le_of_lt hΩ0)
+      exact_mod_cast Finset.card_le_card (failure_subset_dense origin B N hd₀ hB)
+    _ ≤ (∑ k∈Finset.Icc 1 B, (event k).card:ℕ)/(Ω.card:ℝ) := by
+      apply div_le_div_of_nonneg_right _ (le_of_lt hΩ0)
+      exact_mod_cast (Finset.card_biUnion_le : ((Finset.Icc 1 B).biUnion event).card ≤ _)
+    _ = ∑ k∈Finset.Icc 1 B, (event k).card/(Ω.card:ℝ) := by
+      push_cast
+      rw [Finset.sum_div]
+    _ ≤ ∑ k∈Finset.Icc 1 B, DiameterProbability.witnessTerm
+        (9*(12*(d:ℝ)^2/p)^65) ρ (Fintype.card V) k := Finset.sum_le_sum hkbound
+    _ ≤ _ := Summable.sum_le_tsum (Finset.Icc 1 B)
+      (fun k _ => DiameterProbability.witnessTerm_nonneg (by positivity) _ k) hsum
+
+/-- On the complement of the counted event the diameter conclusion follows
+with an explicit bound, including components of disconnected graphs. -/
+theorem diameter_of_not_failure (B N R : ℕ) (r : Matching label bar)
+    (hr : r∈Matching.conditioned (label:=label) (bar:=bar) origin N ∅)
+    (hf : r∉failure (label:=label) (bar:=bar) origin B N) (hR : B<2^R)
+    {u v : V} (huv : (simpleGraph origin r).Reachable u v) :
+    (simpleGraph origin r).dist u v < (Fintype.card V/(B+1)+1)*(2*R+1) := by
+  have hexp : Expands origin B r := by
+    by_contra h
+    exact hf (Finset.mem_filter.mpr ⟨hr,h⟩)
+  apply ExpansionDiameter.diameter_bound _ B R _ hR huv
+  intro S hs hSB
+  rw [neighbors_eq]
+  exact hexp S hs hSB
+
+end TorsionFreeZeroDivisors.MatchingDiameter
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/GroupRing/FiniteClusters.lean b/lean/OAI/Algebra/GroupRing/FiniteClusters.lean
new file mode 100644
index 0000000000000000000000000000000000000000..89f0cd371ce7033ebde64e0908f5949a3dd46343
--- /dev/null
+++ b/lean/OAI/Algebra/GroupRing/FiniteClusters.lean
@@ -0,0 +1,406 @@
+import Mathlib
+import OAI.Algebra.GroupRing.ShortClosure
+
+namespace OAI
+
+noncomputable section
+
+namespace TorsionFreeZeroDivisors.FiniteClusters
+open scoped Classical BigOperators
+variable {V : Type} [Fintype V] (G : SimpleGraph V)
+local instance : Fintype G.ConnectedComponent := Fintype.ofFinite _
+
+def block (c : G.ConnectedComponent) : Finset V :=
+  Finset.univ.filter (fun v => G.connectedComponentMk v=c)
+lemma mem_block {c : G.ConnectedComponent} {v : V} :
+    v∈block G c ↔ G.connectedComponentMk v=c := by simp [block]
+lemma block_nonempty (c : G.ConnectedComponent) : (block G c).Nonempty := by
+  exact ⟨c.out,(mem_block G).mpr c.out_eq⟩
+omit [Fintype V] in
+lemma same_of_adj {v w : V} (h : G.Adj v w) : G.connectedComponentMk v=G.connectedComponentMk w :=
+  SimpleGraph.ConnectedComponent.connectedComponentMk_eq_of_adj h
+
+omit [Fintype V] in
+lemma reachable_closed {B : Finset V}
+    (hc : ∀ x∈B,∀ y,G.Adj x y → y∈B) {x y : V}
+    (hp : G.Reachable x y) (hx : x∈B) : y∈B := by
+  obtain ⟨p⟩ := hp
+  induction p with
+  | nil => exact hx
+  | @cons u v w h p ih => exact ih (hc u hx v h)
+
+lemma block_card {K : ℕ}
+    (hs : ∀ x : V,∃ B : Finset V,x∈B ∧ B.card≤K ∧ ∀ y∈B,∀ z,G.Adj y z → z∈B)
+    (c : G.ConnectedComponent) : (block G c).card≤K := by
+  obtain ⟨x,hx⟩ := block_nonempty G c
+  obtain ⟨B,hB,hBK,hclosed⟩ := hs x
+  apply (Finset.card_le_card (show block G c⊆B from ?_)).trans hBK
+  intro y hy
+  apply reachable_closed G hclosed _ hB
+  apply SimpleGraph.ConnectedComponent.exact
+  exact (mem_block G).mp hx |>.trans ((mem_block G).mp hy).symm
+
+lemma sum_blocks {M : Type*} [AddCommMonoid M] (w : V → M) :
+    (∑ c : G.ConnectedComponent,∑ v∈block G c,w v)=∑ v,w v := by
+  simp only [block,Finset.sum_filter]
+  rw [Finset.sum_comm]
+  apply Finset.sum_congr rfl
+  intro v _
+  simp
+
+lemma block_sum_le {w : V → ℝ} {b : ℝ} (h : ∀ v,w v≤b) (c : G.ConnectedComponent) :
+    (∑ v∈block G c,w v)≤(block G c).card*b := by
+  calc
+    _ ≤ ∑ _v∈block G c,b := Finset.sum_le_sum fun v _ => h v
+    _ = _ := by simp
+end TorsionFreeZeroDivisors.FiniteClusters
+
+namespace TorsionFreeZeroDivisors.PairingClusters
+open scoped Classical BigOperators
+variable {O T : Type} [Fintype O] [Fintype T]
+    (f : O → T) (α : O → O) (hα : Function.Involutive α) (keep : T → Prop)
+abbrev Vertex := {t // keep t}
+def Rel (p q : T) : Prop := ∃ o,f o=p ∧ f (α o)=q
+include hα in
+omit [Fintype O] [Fintype T] in
+lemma rel_symm {p q : T} (h : Rel f α p q) : Rel f α q p := by
+  obtain ⟨o,ho,hp⟩ := h
+  exact ⟨α o,hp,by simpa only [hα o] using ho⟩
+def graph : SimpleGraph (Vertex keep) where
+  Adj p q := p≠q ∧ Rel f α p.val q.val
+  symm := ⟨by
+    intro p q h
+    exact ⟨Ne.symm h.1,rel_symm f α hα h.2⟩⟩
+  loopless := ⟨by intro p h; exact h.1 rfl⟩
+local instance : Fintype (graph f α hα keep).ConnectedComponent := Fintype.ofFinite _
+abbrev Cluster := (graph f α hα keep).ConnectedComponent
+
+def cluster (t : T) : Option (Cluster f α hα keep) :=
+  if h : keep t then some ((graph f α hα keep).connectedComponentMk ⟨t,h⟩) else none
+omit [Fintype O] [Fintype T] in
+lemma cluster_some {t : T} (h : keep t) :
+    cluster f α hα keep t=some ((graph f α hα keep).connectedComponentMk ⟨t,h⟩) := dite_eq_left h
+omit [Fintype O] [Fintype T] in
+lemma cluster_none {t : T} (h : ¬keep t) : cluster f α hα keep t=none := dite_eq_right h
+omit [Fintype O] [Fintype T] in
+lemma cluster_exists {t : T} : (∃ c,cluster f α hα keep t=some c) ↔ keep t := by
+  by_cases h : keep t
+  · simp only [cluster_some f α hα keep h,Option.some.injEq,exists_eq',h]
+  · simp only [cluster_none f α hα keep h,reduceCtorEq,exists_false,false_iff]; exact h
+omit [Fintype O] [Fintype T] in
+lemma cluster_pair {o : O} (h : keep (f o)) (h' : keep (f (α o))) :
+    cluster f α hα keep (f o)=cluster f α hα keep (f (α o)) := by
+  rw [cluster_some f α hα keep h,cluster_some f α hα keep h']
+  apply congrArg some
+  by_cases he : (⟨f o,h⟩ : Vertex keep)=⟨f (α o),h'⟩
+  · rw [he]
+  · apply FiniteClusters.same_of_adj
+    exact ⟨he,⟨o,rfl,rfl⟩⟩
+omit [Fintype O] [Fintype T] in
+lemma same_cluster_partner {o : O} {c : Cluster f α hα keep}
+    (hc : cluster f α hα keep (f o)=some c) :
+    (cluster f α hα keep (f (α o))=some c ↔ keep (f (α o))) := by
+  constructor
+  · intro h; exact (cluster_exists f α hα keep).mp ⟨c,h⟩
+  · intro h
+    rw [←cluster_pair f α hα keep ((cluster_exists f α hα keep).mp ⟨c,hc⟩) h,hc]
+
+def bad (o : O) : Prop := keep (f o) ∧ (α o=o ∨ ¬keep (f (α o)))
+def localBad (c : Cluster f α hα keep) (o : O) : Prop :=
+  cluster f α hα keep (f o)=some c ∧
+    (α o=o ∨ cluster f α hα keep (f (α o))≠some c)
+omit [Fintype O] [Fintype T] in
+lemma localBad_iff (c : Cluster f α hα keep) (o : O) :
+    localBad f α hα keep c o ↔ bad f α keep o ∧ cluster f α hα keep (f o)=some c := by
+  constructor
+  · rintro ⟨hc,hb⟩
+    refine ⟨⟨(cluster_exists f α hα keep).mp ⟨c,hc⟩,?_⟩,hc⟩
+    exact hb.imp_right fun hn h => hn ((same_cluster_partner f α hα keep hc).mpr h)
+  · rintro ⟨⟨_,hb⟩,hc⟩
+    exact ⟨hc,hb.imp_right fun hn h => hn ((same_cluster_partner f α hα keep hc).mp h)⟩
+
+lemma local_bad_sum :
+    (∑ c : Cluster f α hα keep,(Finset.univ.filter (localBad f α hα keep c)).card)=
+    (Finset.univ.filter (bad f α keep)).card := by
+  simp only [Finset.card_eq_sum_ones,Finset.sum_filter]
+  rw [Finset.sum_comm]
+  apply Finset.sum_congr rfl
+  intro o _
+  simp only [localBad_iff]
+  by_cases hb : bad f α keep o
+  · obtain ⟨c,hc⟩ := (cluster_exists f α hα keep).mpr hb.1
+    simp [hb,hc]
+  · simp [hb]
+
+include hα in
+omit [Fintype T] in
+lemma total_bad_bound : (Finset.univ.filter (bad f α keep)).card≤
+    (Finset.univ.filter (fun o => α o=o)).card+
+    (Finset.univ.filter (fun o => ¬keep (f o) ∧ α o≠o)).card := by
+  let old := Finset.univ.filter (fun o : O => keep (f o) ∧ α o=o)
+  let cut := Finset.univ.filter (fun o : O => keep (f o) ∧ α o≠o ∧ ¬keep (f (α o)))
+  have cover : Finset.univ.filter (bad f α keep)⊆old∪cut := by
+    intro o ho
+    have ho := (Finset.mem_filter.mp ho).2
+    by_cases he : α o=o
+    · exact Finset.mem_union_left _ (Finset.mem_filter.mpr ⟨Finset.mem_univ _,ho.1,he⟩)
+    · exact Finset.mem_union_right _ (Finset.mem_filter.mpr ⟨Finset.mem_univ _,ho.1,he,ho.2.resolve_left he⟩)
+  have hold : old.card≤(Finset.univ.filter (fun o => α o=o)).card := by
+    apply Finset.card_le_card
+    intro o ho
+    exact Finset.mem_filter.mpr ⟨Finset.mem_univ _,(Finset.mem_filter.mp ho).2.2⟩
+  have hcut : cut.card≤(Finset.univ.filter (fun o => ¬keep (f o) ∧ α o≠o)).card := by
+    apply Finset.card_le_card_of_injOn (f:=α)
+    · intro o ho
+      have ho := (Finset.mem_filter.mp ho).2
+      exact Finset.mem_filter.mpr ⟨Finset.mem_univ _,ho.2.2,by simpa only [hα o] using Ne.symm ho.2.1⟩
+    · exact fun _ _ _ _ h => hα.injective h
+  exact (Finset.card_le_card cover).trans ((Finset.card_union_le _ _).trans (Nat.add_le_add hold hcut))
+
+lemma total_local_bad_bound :
+    (∑ c : Cluster f α hα keep,(Finset.univ.filter (localBad f α hα keep c)).card)≤
+    (Finset.univ.filter (fun o => α o=o)).card+
+    (Finset.univ.filter (fun o => ¬keep (f o) ∧ α o≠o)).card := by
+  rw [local_bad_sum]
+  exact total_bad_bound f α hα keep
+end TorsionFreeZeroDivisors.PairingClusters
+
+/-! Arithmetic localization of finite-cluster mass and comparison bounds. -/
+namespace TorsionFreeZeroDivisors.PlanarLocalization
+open scoped Classical BigOperators
+
+lemma bad_mass {Z : Type} [Fintype Z] (h b : Z → ℝ) (ε : ℝ)
+    (hb : ∀ z,0 ≤ b z) :
+    ε*(∑ z∈Finset.univ.filter (fun z => ε*h z < b z),h z) ≤ ∑ z,b z := by
+  calc
+    _ = ∑ z∈Finset.univ.filter (fun z => ε*h z < b z),ε*h z := by rw [Finset.mul_sum]
+    _ ≤ ∑ z∈Finset.univ.filter (fun z => ε*h z < b z),b z :=
+      Finset.sum_le_sum fun z hz => (Finset.mem_filter.mp hz).2.le
+    _ ≤ _ := Finset.sum_le_sum_of_subset_of_nonneg (Finset.filter_subset _ _)
+      (fun z _ _ => hb z)
+
+/-- Three exact exclusions leave a positive amount of source length. -/
+theorem exists_good_cluster {Z : Type} [Fintype Z]
+    (h b i : Z → ℝ) (H₀ L ε C C₂ : ℝ)
+    (hH₀ : 0 < H₀) (hL : 0 < L) (hε : 0 < ε) (hC₂ : 0 < C₂)
+    (hh : ∀ z,0 ≤ h z) (hb : ∀ z,0 ≤ b z) (hi : ∀ z,0 ≤ i z)
+    (hupper : ∀ z,h z ≤ C*L)
+    (hretained : 15/16*H₀ ≤ ∑ z,h z)
+    (hunpaired : ∑ z,b z ≤ ε/16*H₀)
+    (hcomparisons : ∑ z,i z ≤ C₂/(16*L)*H₀)
+    (hshort : ∑ z∈Finset.univ.filter (fun z => h z < L),h z ≤ H₀/2) :
+    ∃ z,L ≤ h z ∧ h z ≤ C*L ∧ b z ≤ ε*h z ∧ i z ≤ C₂*h z/L := by
+  let badB := Finset.univ.filter (fun z => ε*h z < b z)
+  let badI := Finset.univ.filter (fun z => (C₂/L)*h z < i z)
+  let short := Finset.univ.filter (fun z => h z < L)
+  have hB : ∑ z∈badB,h z ≤ H₀/16 := by
+    have ht := (bad_mass h b ε hb).trans hunpaired
+    change ε*(∑ z∈badB,h z) ≤ ε/16*H₀ at ht
+    nlinarith
+  have hI : ∑ z∈badI,h z ≤ H₀/16 := by
+    have ht := (bad_mass h i (C₂/L) hi).trans hcomparisons
+    change (C₂/L)*(∑ z∈badI,h z) ≤ C₂/(16*L)*H₀ at ht
+    have he : C₂/(16*L)*H₀=(C₂/L)*(H₀/16) := by ring
+    rw [he] at ht
+    have hp := div_pos hC₂ hL
+    nlinarith
+  by_contra hn
+  have hc : ∀ z,z∈badB ∨ z∈badI ∨ z∈short := by
+    intro z
+    by_cases hB : b z ≤ ε*h z
+    · by_cases hI : i z ≤ C₂*h z/L
+      · have hs : h z < L := by
+          by_contra hl
+          exact hn ⟨z,le_of_not_gt hl,hupper z,hB,hI⟩
+        exact Or.inr (Or.inr (Finset.mem_filter.mpr ⟨Finset.mem_univ _,hs⟩))
+      · right; left
+        apply Finset.mem_filter.mpr
+        refine ⟨Finset.mem_univ _,?_⟩
+        simpa only [div_mul_eq_mul_div] using lt_of_not_ge hI
+    · exact Or.inl (Finset.mem_filter.mpr ⟨Finset.mem_univ _,lt_of_not_ge hB⟩)
+  have hsum : (∑ z,h z) ≤ (∑ z∈badB,h z)+(∑ z∈badI,h z)+(∑ z∈short,h z) := by
+    rw [Finset.sum_filter,Finset.sum_filter,Finset.sum_filter,←Finset.sum_add_distrib,
+      ←Finset.sum_add_distrib]
+    apply Finset.sum_le_sum
+    intro z _
+    have hc := hc z
+    simp only [badB,badI,short,Finset.mem_filter,Finset.mem_univ,true_and] at hc
+    rcases hc with hc|hc|hc
+    · simp only [ite_eq_left hc]
+      have h1 : 0 ≤ if C₂/L*h z < i z then h z else 0 := by split <;> first | exact hh z | exact le_rfl
+      have h2 : 0 ≤ if h z < L then h z else 0 := by split <;> first | exact hh z | exact le_rfl
+      linarith
+    · simp only [ite_eq_left hc]
+      have h1 : 0 ≤ if ε*h z < b z then h z else 0 := by split <;> first | exact hh z | exact le_rfl
+      have h2 : 0 ≤ if h z < L then h z else 0 := by split <;> first | exact hh z | exact le_rfl
+      linarith
+    · simp only [ite_eq_left hc]
+      have h1 : 0 ≤ if ε*h z < b z then h z else 0 := by split <;> first | exact hh z | exact le_rfl
+      have h2 : 0 ≤ if C₂/L*h z < i z then h z else 0 := by split <;> first | exact hh z | exact le_rfl
+      linarith
+  change (∑ z∈short,h z) ≤ H₀/2 at hshort
+  linarith
+
+/-- The discarded short exceptional cluster really costs less than half; the
+ordinary girth-length boundary is accounted for separately, not silently lost. -/
+lemma exceptional_short_cost (h L H₀ : ℝ) (hlen : h < L) (hordinary : h+L ≤ H₀) :
+    h < H₀/2 := by linarith
+
+end TorsionFreeZeroDivisors.PlanarLocalization
+
+namespace TorsionFreeZeroDivisors.ClusterLocalization
+open scoped Classical BigOperators
+open ComparedBlocks
+variable {T E : Type} [Fintype T] {len : T → ℕ}
+    (C : Comparisons (E:=E) len) (keep : T → Prop)
+
+abbrev graph := PairingClusters.graph (fun x : Position len => x.1)
+  C.pairing.partner C.pairing.involutive keep
+abbrev Cluster := (graph C keep).ConnectedComponent
+local instance : Fintype (Cluster C keep) := Fintype.ofFinite _
+def cluster := PairingClusters.cluster (fun x : Position len => x.1)
+  C.pairing.partner C.pairing.involutive keep
+abbrev belongs (c : Cluster C keep) (t : T) : Prop := cluster C keep t=some c
+abbrev localC (c : Cluster C keep) := RestrictComparisons.comparisons C (belongs C keep c)
+def mass (c : Cluster C keep) : ℕ := ∑ t∈Finset.univ.filter (belongs C keep c),len t
+def bad (c : Cluster C keep) : ℕ :=
+  (Finset.univ.filter (PairingClusters.localBad (fun x : Position len => x.1)
+    C.pairing.partner C.pairing.involutive keep c)).card
+def comparisons [Fintype E] (c : Cluster C keep) : ℕ :=
+  Fintype.card {e // RestrictComparisons.Active C (belongs C keep c) e}
+def paths (c : Cluster C keep) : Finset T := Finset.univ.filter (belongs C keep c)
+
+omit [Fintype T] in
+lemma cluster_exists {t : T} : (∃ c,belongs C keep c t) ↔ keep t :=
+  PairingClusters.cluster_exists _ _ _ _
+lemma mass_pos (hlen : ∀ t,0<len t) (c : Cluster C keep) : 0 < mass C keep c := by
+  obtain ⟨t,ht⟩ := FiniteClusters.block_nonempty (graph C keep) c
+  have ht' : belongs C keep c t.val := by
+    change PairingClusters.cluster _ _ _ _ t.val=some c
+    rw [PairingClusters.cluster_some _ _ _ _ t.property]
+    exact congrArg some ((FiniteClusters.mem_block _).mp ht)
+  exact Finset.sum_pos' (fun t _ => Nat.zero_le _) ⟨t.val,Finset.mem_filter.mpr ⟨Finset.mem_univ _,ht'⟩,hlen _⟩
+
+lemma mass_sum : (∑ c,mass C keep c)=∑ t∈Finset.univ.filter keep,len t := by
+  simp only [mass,Finset.sum_filter]
+  rw [Finset.sum_comm]
+  apply Finset.sum_congr rfl
+  intro t _
+  by_cases ht : keep t
+  · obtain ⟨c,hc⟩ := (cluster_exists C keep).mpr ht
+    change cluster C keep t=some c at hc
+    simp [belongs,hc,ht]
+  · have hc : cluster C keep t=none := PairingClusters.cluster_none _ _ _ _ ht
+    simp [belongs,hc,ht]
+
+lemma mass_original_loss : (∑ t,len t)≤(∑ c,mass C keep c)+∑ t∈Finset.univ.filter (fun t=>¬keep t),len t := by
+  rw [mass_sum]
+  exact (le_of_eq (Finset.sum_filter_add_sum_filter_not _ _ _).symm)
+
+lemma bad_sum : (∑ c,bad C keep c)≤
+    (Finset.univ.filter (fun x : Position len=>C.pairing.partner x=x)).card+
+    (Finset.univ.filter (fun x : Position len=>¬keep x.1 ∧ C.pairing.partner x≠x)).card := by
+  convert PairingClusters.total_local_bad_bound (fun x : Position len => x.1) C.pairing.partner C.pairing.involutive keep using 1
+  · apply Finset.sum_congr (by ext c; simp)
+    intro c _
+    unfold bad
+    congr 1
+  · congr 1 <;> congr 1 <;> ext x <;> simp
+
+lemma comparisons_sum [Fintype E] : (∑ c,comparisons C keep c)≤Fintype.card E := by
+  simp only [comparisons,Fintype.card_subtype,Finset.card_eq_sum_ones,Finset.sum_filter]
+  rw [Finset.sum_comm]
+  calc
+    _ ≤ ∑ _e : E,1 := by
+      apply Finset.sum_le_sum
+      intro e _
+      by_cases hk : keep (C.source e)
+      · obtain ⟨c,hc⟩ := (cluster_exists C keep).mpr hk
+        change cluster C keep (C.source e)=some c at hc
+        calc
+          _ ≤ ∑ d : Cluster C keep, if belongs C keep d (C.source e) then 1 else 0 := by
+            apply Finset.sum_le_sum
+            intro d _
+            by_cases h : belongs C keep d (C.source e)
+            · simp only [ite_eq_left h]; split_ifs <;> omega
+            · simp only [RestrictComparisons.Active,h,false_and,ite_false,le_refl]
+          _ = 1 := by simp [belongs,hc]
+      · have hc : cluster C keep (C.source e)=none := PairingClusters.cluster_none _ _ _ _ hk
+        simp [RestrictComparisons.Active,belongs,hc]
+    _ = _ := by simp
+
+/-- The fixed positions in the literal restricted comparison system are exactly
+this cluster's old fixed or lost-partner occurrences. -/
+def fixedEquiv (c : Cluster C keep) :
+    {x : Position (RestrictComparisons.Length (belongs C keep c) (len:=len)) //
+      (localC C keep c).pairing.partner x=x} ≃
+    {x : Position len // PairingClusters.localBad (fun x : Position len => x.1)
+      C.pairing.partner C.pairing.involutive keep c x} where
+  toFun x := ⟨RestrictComparisons.embed _ x.val,x.val.1.property,
+    (RestrictComparisons.fixed_iff C _ _).mp x.property⟩
+  invFun x := by
+    have hx : belongs C keep c x.val.1 ∧
+        (C.pairing.partner x.val=x.val ∨ ¬belongs C keep c (C.pairing.partner x.val).1) := x.property
+    refine ⟨RestrictComparisons.liftPosition _ x.val hx.1,?_⟩
+    apply (RestrictComparisons.fixed_iff C _ _).mpr
+    simpa only [RestrictComparisons.embed_local] using hx.2
+  left_inv x := by rcases x with ⟨⟨⟨t,ht⟩,q⟩,hx⟩; rfl
+  right_inv x := by rcases x with ⟨⟨t,q⟩,hx⟩; rfl
+lemma fixed_card (c : Cluster C keep) :
+    (Finset.univ.filter (fun x => (localC C keep c).pairing.partner x=x)).card=bad C keep c := by
+  simpa only [bad,Fintype.card_subtype] using Fintype.card_congr (fixedEquiv C keep c)
+
+lemma local_mass (c : Cluster C keep) :
+    (∑ t : {t // belongs C keep c t},len t.val)=mass C keep c := by
+  exact (Finset.sum_subtype (Finset.univ.filter (belongs C keep c)) (by intro t; simp) len).symm
+
+lemma short_member {L : ℕ} (c : Cluster C keep) (hc : mass C keep c<L)
+    {t : T} (ht : belongs C keep c t) : len t<L := by
+  apply lt_of_le_of_lt _ hc
+  exact Finset.single_le_sum (fun _ _=>Nat.zero_le _) (Finset.mem_filter.mpr ⟨Finset.mem_univ _,ht⟩)
+
+/-- With at most one short exceptional piece there is at most one short cluster.
+The estimate counts actual retained path lengths, not abstract cluster masses. -/
+lemma short_mass {L : ℕ} (root : Option T)
+    (ho : ∀ t,root≠some t → L≤len t) :
+    (∑ c∈Finset.univ.filter (fun c=>mass C keep c<L),mass C keep c)≤
+      ∑ t∈Finset.univ.filter (fun t=>root=some t),len t := by
+  simp only [Finset.sum_filter]
+  have expand (c : Cluster C keep) :
+      (if mass C keep c<L then mass C keep c else 0)=
+      ∑ t,if mass C keep c<L then (if belongs C keep c t then len t else 0) else 0 := by
+    by_cases h : mass C keep c<L
+    · simp only [ite_eq_left h]
+      simp only [mass,Finset.sum_filter]
+    · simp only [ite_eq_right h,Finset.sum_const_zero]
+  simp_rw [expand]
+  rw [Finset.sum_comm]
+  apply Finset.sum_le_sum
+  intro t _
+  by_cases hr : root=some t
+  · rw [ite_eq_left hr]
+    by_cases hk : keep t
+    · obtain ⟨c,hc⟩ := (cluster_exists C keep).mpr hk
+      change cluster C keep t=some c at hc
+      simp only [belongs,hc,Option.some.injEq]
+      calc
+        _ ≤ ∑ d : Cluster C keep,if c=d then len t else 0 := by
+          apply Finset.sum_le_sum
+          intro d _
+          split_ifs <;> omega
+        _ = len t := by simp
+    · have hc : cluster C keep t=none := PairingClusters.cluster_none _ _ _ _ hk
+      simp [belongs,hc]
+  · rw [ite_eq_right hr]
+    apply Nat.le_zero.mpr
+    apply Finset.sum_eq_zero
+    intro c _
+    by_cases hc : mass C keep c<L
+    · have hnt : ¬belongs C keep c t := fun h => (not_lt_of_ge (ho t hr)) (short_member C keep c hc h)
+      simp only [ite_eq_left hc,ite_eq_right hnt]
+    · simp only [ite_eq_right hc]
+end TorsionFreeZeroDivisors.ClusterLocalization
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/GroupRing/FixedGraph.lean b/lean/OAI/Algebra/GroupRing/FixedGraph.lean
new file mode 100644
index 0000000000000000000000000000000000000000..79bb3e76b9c34c14da7278abfddce13d4d5a426a
--- /dev/null
+++ b/lean/OAI/Algebra/GroupRing/FixedGraph.lean
@@ -0,0 +1,35 @@
+import Mathlib
+import OAI.Algebra.GroupRing.Cayley
+
+namespace OAI
+
+
+
+section
+namespace TorsionFreeZeroDivisors.FixedGraph
+open GroupRingTopology GroupRingTopology.Attachment
+open scoped unitInterval
+noncomputable section
+variable {G S Y : Type} [Group G] [TopologicalSpace G] [DiscreteTopology G]
+  [TopologicalSpace Y] [SimplyConnectedSpace Y]
+  (s : S→G) (f : C(Cayley.Graph s,Y)) (y : Y) (hv : ∀g,f (Cayley.vertex s g)=y)
+def vertices (g : G) : Path y (f (Cayley.vertex s g)) := (Path.refl y).cast rfl (hv g)
+lemma compatible (g : G) (a : S) :
+    ((vertices s f y hv g).trans ((Cayley.edge s g a).map f.continuous)).Homotopic
+      (vertices s f y hv (g*s a)) := by
+  apply Path.Homotopic.Quotient.eq.mp
+  exact Subsingleton.elim _ _
+def homotopy : f.Homotopy (.const _ y) :=
+  Cayley.graphNullhomotopy s f y (vertices s f y hv) (compatible s f y hv)
+lemma homotopy_vertex (t : unitInterval) (g : G) : homotopy s f y hv (t,Cayley.vertex s g)=y := by
+  change ((Path.refl (f (Cayley.vertex s g))).trans (vertices s f y hv g).symm) t=y
+  rw [Path.trans_apply]
+  split_ifs <;> simp [vertices,hv]
+end
+end TorsionFreeZeroDivisors.FixedGraph
+
+end
+
+
+
+end OAI
diff --git a/lean/OAI/Algebra/GroupRing/FramedConjugators.lean b/lean/OAI/Algebra/GroupRing/FramedConjugators.lean
new file mode 100644
index 0000000000000000000000000000000000000000..5fbcaf917131e26483fe1f1cb0601cd23845c40c
--- /dev/null
+++ b/lean/OAI/Algebra/GroupRing/FramedConjugators.lean
@@ -0,0 +1,110 @@
+import Mathlib
+import OAI.Algebra.GroupRing.WordFrames
+
+namespace OAI
+
+
+
+section
+namespace TorsionFreeZeroDivisors.WordFrames
+open scoped Classical
+open WordBlocks WordCursor FreeGroup AlgebraicPictures
+noncomputable section
+variable {A G : Type} [Group G] (v : A×Bool→G)
+  (hv : ∀a,v (WordPairing.inverseLetter a)=(v a)⁻¹)
+def Data.removeConjugator (g : G) (c w : List (A×Bool)) (bs : List (G×List (A×Bool)))
+    (d : Data v WordPairing.inverseLetter ((g,c++w++invRev c)::bs)) :
+    Data v WordPairing.inverseLetter ((g*value v c,w)::bs) := by
+  induction c generalizing g with
+  | nil=>simpa only [List.nil_append,invRev_empty,List.append_nil,value_nil,mul_one] using d
+  | cons a c ih=>
+    have he : (a::c)++w++invRev (a::c)=a::((c++w++invRev c)++[WordPairing.inverseLetter a]) := by
+      simp only [List.cons_append,invRev,WordPairing.inverseLetter,
+        List.reverse_cons,List.map_cons,List.append_assoc]
+    rw [he] at d
+    have dd := d.removeCaps hv WordPairing.inverseLetter_involutive g a (c++w++invRev c) bs
+    have ee := ih (g*v a) dd
+    simpa only [value_cons,mul_assoc] using ee
+def Data.removeConjugatorAt (g : G) (c w : List (A×Bool)) (pre post : List (G×List (A×Bool)))
+    (d : Data v WordPairing.inverseLetter (pre++(g,c++w++invRev c)::post)) :
+    Data v WordPairing.inverseLetter (pre++(g*value v c,w)::post) :=
+  ((d.focus v pre g (c++w++invRev c) post).removeConjugator v hv g c w (pre++post)).unfocus v pre (g*value v c) w post
+variable {I : Type} (rel : I→List (A×Bool))
+def framedCores (ts : List (Term (A:=A) (I:=I))) : List (G×List (A×Bool)) :=
+  ts.map (fun t=>(value v t.connector,t.core rel))
+def framedWords (ts : List (Term (A:=A) (I:=I))) : List (G×List (A×Bool)) :=
+  ts.map (fun t=>(1,t.word rel))
+def Data.strip (ts : List (Term (A:=A) (I:=I))) (pre : List (G×List (A×Bool)))
+    (d : Data v WordPairing.inverseLetter (pre++framedWords (G:=G) rel ts)) :
+    Data v WordPairing.inverseLetter (pre++framedCores v rel ts) := by
+  induction ts generalizing pre with
+  | nil=>exact d
+  | cons t ts ih=>
+    change Data v WordPairing.inverseLetter
+      (pre++(1,t.connector++t.core rel++invRev t.connector)::framedWords (G:=G) rel ts) at d
+    have d' := d.removeConjugatorAt v hv 1 t.connector (t.core rel) pre (framedWords (G:=G) rel ts)
+    rw [one_mul] at d'
+    have d'' := ih (pre++[(value v t.connector,t.core rel)])
+      (by simpa only [List.append_assoc,List.singleton_append] using d')
+    simpa only [framedCores,List.map_cons,List.append_assoc,List.singleton_append] using d''
+lemma flat_position (bs : List (G×List (A×Bool))) (h : ∀b∈bs,value v b.2=1) (hg : ∀b∈bs,b.1=1)
+    (i : Occ (words bs)) :
+    cursor v (words bs).flatten (coordinates (words bs) i).val=position v bs i := by
+  induction bs with
+  | nil=>exact Empty.elim i
+  | cons b bs ih=>
+    cases b with
+    | mk g w=>
+      have hg' := hg (g,w) (List.mem_cons_self)
+      have hw := h (g,w) (List.mem_cons_self)
+      change g=1 at hg'
+      change value v w=1 at hw
+      cases i with
+      | inl i=>
+        change cursor v (w++(words bs).flatten) i.val=g*cursor v w i.val
+        rw [cursor_append_left v _ _ _ i.isLt.le,hg',one_mul]
+      | inr i=>
+        change cursor v (w++(words bs).flatten) (w.length+(coordinates (words bs) i).val)=position v bs i
+        rw [cursor_append_right,hw,one_mul]
+        exact ih (fun b hb=>h b (List.mem_cons_of_mem _ hb)) (fun b hb=>hg b (List.mem_cons_of_mem _ hb)) i
+include hv in
+lemma of_identity (bs : List (G×List (A×Bool)))
+    (he : FreeGroup.mk (words bs).flatten=1) (h : ∀b∈bs,value v b.2=1) (hg : ∀b∈bs,b.1=1) :
+    Nonempty (Data v WordPairing.inverseLetter bs) := by
+  obtain ⟨d,hd⟩ := WordCursor.of_identity v hv he
+  have hh : ∀w∈words bs,value v w=1 := by
+    intro w hw
+    obtain ⟨b,hb,rfl⟩ := List.mem_map.mp hw
+    exact h b hb
+  refine ⟨⟨WordBlocks.ofDisk (words bs) d,WordBlocks.liftOfDisk d hd hh,?_⟩⟩
+  exact flat_position v bs h hg
+include hv in
+/-- Every literal free identity among the conjugated relators gives a genuine
+planar matching on the signed CORE words, retaining the actual conjugating
+group coordinate at EVERY occurrence. No expected relator-area identity is
+used as an assumption. -/
+theorem identity_framed_cores (ts : List (Term (A:=A) (I:=I)))
+    (he : FreeGroup.mk (AlgebraicPictures.word rel ts)=1)
+    (ht : ∀t∈ts,value v (t.word rel)=1) :
+    Nonempty (Data v WordPairing.inverseLetter (framedCores v rel ts)) := by
+  have hw : words (framedWords (G:=G) rel ts)=ts.map (Term.word rel) := by
+    simp only [words,framedWords,List.map_map]
+    rfl
+  obtain ⟨d⟩ := of_identity v hv (framedWords (G:=G) rel ts) (by
+    rw [hw]
+    simpa only [List.flatMap_def,AlgebraicPictures.word] using he) (by
+      rintro b hb
+      obtain ⟨t,ht',rfl⟩ := List.mem_map.mp hb
+      exact ht t ht') (by
+      rintro b hb
+      obtain ⟨t,_,rfl⟩ := List.mem_map.mp hb
+      rfl)
+  exact ⟨d.strip v hv rel ts []⟩
+end
+end TorsionFreeZeroDivisors.WordFrames
+
+end
+
+
+
+end OAI
diff --git a/lean/OAI/Algebra/GroupRing/FramedLoopIdentities.lean b/lean/OAI/Algebra/GroupRing/FramedLoopIdentities.lean
new file mode 100644
index 0000000000000000000000000000000000000000..05b605285ccc5fc2fe0dd0555edb7f4d6a533e76
--- /dev/null
+++ b/lean/OAI/Algebra/GroupRing/FramedLoopIdentities.lean
@@ -0,0 +1,61 @@
+import Mathlib
+import OAI.Algebra.GroupRing.FramedConjugators
+import OAI.Algebra.GroupRing.FramedSpherical
+import OAI.Algebra.GroupRing.PathCharges
+
+namespace OAI
+
+
+
+section
+namespace TorsionFreeZeroDivisors.FramedLoopIdentities
+open scoped Classical BigOperators
+open PortSubdivision GraphPresentation AlgebraicPictures InitialPicture WordFrames WordCursor
+noncomputable section
+variable {V D A I G M : Type} [Group G] [AddCommGroup M]
+  (Γ : PortGraph V D) (label : D→A×Bool)
+  (hl : ∀d,label (Γ.reverse d)=WordPairing.inverseLetter (label d))
+  (rel : I→Loop Γ) (v : A×Bool→G)
+  (hv : ∀a,v (WordPairing.inverseLetter a)=(v a)⁻¹)
+  (c : G→D→M) (hc : ∀g d,c (g*v (label d)) (Γ.reverse d)=-c g d)
+  (ts : List (Term (A:=A) (I:=I)))
+def frames : List (G×List D) := ts.map (fun t=>(value v t.connector,(signedLoop Γ rel t).2.darts))
+include hl in
+lemma frames_labels : mapLabels label (frames Γ rel v ts)=framedCores v (relWords Γ label rel) ts := by
+  simp only [mapLabels,frames,framedCores,List.map_map]
+  apply List.map_congr_left
+  intro t _
+  apply Prod.ext
+  · rfl
+  · exact signedLoop_letters Γ label hl rel t
+lemma frames_closed : WordBlocks.AllClosed Γ (words (frames Γ rel v ts)) := by
+  intro w hw
+  obtain ⟨b,hb,rfl⟩ := List.mem_map.mp hw
+  obtain ⟨t,_,rfl⟩ := List.mem_map.mp hb
+  exact ⟨(signedLoop Γ rel t).1,(signedLoop Γ rel t).2,rfl⟩
+def area (t : Term (A:=A) (I:=I)) : M :=
+  PathCharges.charge (v∘label) c (value v t.connector) (signedLoop Γ rel t).2.darts
+include hl hv hc in
+/-- A free identity among conjugated closed relators has exactly zero lifted
+edge area whenever sharp arrangement exclusion reduces all its actual spherical
+pictures. The frames are not erased or existentially replaced. -/
+theorem identity_area_zero
+    (he : FreeGroup.mk (AlgebraicPictures.word (relWords Γ label rel) ts)=1)
+    (ht : ∀t∈ts,value v (t.word (relWords Γ label rel))=1)
+    (hred : ∀{O : Type}[Fintype O](a : SphericalPicture.Data (O:=O) Γ label WordPairing.inverseLetter),
+      SphericalPicture.ReducesToEmpty Γ label WordPairing.inverseLetter a) :
+    (ts.map (area Γ label rel v c)).sum=0 := by
+  obtain ⟨d⟩ := identity_framed_cores v hv (relWords Γ label rel) ts he ht
+  rw [←frames_labels Γ label hl rel v ts] at d
+  have hh := WordFrames.charge_zero Γ d (frames_closed Γ rel v ts) hv hl c hc (hred _)
+  rw [PathCharges.frames_sum] at hh
+  simp only [frames,List.map_map] at hh
+  exact hh
+end
+end TorsionFreeZeroDivisors.FramedLoopIdentities
+
+end
+
+
+
+end OAI
diff --git a/lean/OAI/Algebra/GroupRing/FramedSpherical.lean b/lean/OAI/Algebra/GroupRing/FramedSpherical.lean
new file mode 100644
index 0000000000000000000000000000000000000000..510621d75aef861b0a6890b4af942ebc4ef7d146
--- /dev/null
+++ b/lean/OAI/Algebra/GroupRing/FramedSpherical.lean
@@ -0,0 +1,105 @@
+import Mathlib
+import OAI.Algebra.GroupRing.WordFrames
+import OAI.Algebra.GroupRing.PictureChains
+
+namespace OAI
+
+
+
+section
+namespace TorsionFreeZeroDivisors.WordFrames
+open scoped Classical BigOperators
+open WordBlocks WordCursor PortSubdivision
+noncomputable section
+variable {V D A G : Type} [Group G] (Γ : PortGraph V D) (lab : D→A) (v : A→G) (inv : A→A)
+def mapLabels (bs : List (G×List D)) : List (G×List A) := bs.map (fun b=>(b.1,b.2.map lab))
+def labelCoordinates : (bs : List (G×List D))→Occ (words bs)≃Occ (words (mapLabels lab bs))
+  | []=>Equiv.refl _
+  | b::bs=>Equiv.sumCongr (finCongr (List.length_map (f:=lab) (as:=b.2)).symm) (labelCoordinates bs)
+omit [Group G] in
+lemma labelCoordinates_letter (bs : List (G×List D)) (i : Occ (words bs)) :
+    letter (words (mapLabels lab bs)) (labelCoordinates lab bs i)=lab (letter (words bs) i) := by
+  induction bs with
+  | nil=>exact Empty.elim i
+  | cons b bs ih=>
+    cases i with
+    | inl i=>exact List.getElem_map _
+    | inr i=>exact ih i
+omit [Group G] in
+lemma labelCoordinates_rotation (bs : List (G×List D)) (i : Occ (words bs)) :
+    labelCoordinates lab bs (BlockBoundary.rotation (lengths (words bs)) i)=
+      BlockBoundary.rotation (lengths (words (mapLabels lab bs))) (labelCoordinates lab bs i) := by
+  induction bs with
+  | nil=>exact Empty.elim i
+  | cons b bs ih=>
+    cases i with
+    | inl i=>exact congrArg Sum.inl (rotate_cast (List.length_map (f:=lab) (as:=b.2)).symm i)
+    | inr i=>exact congrArg Sum.inr (ih i)
+lemma cursor_map (w : List D) (n : ℕ) : cursor v (w.map lab) n=cursor (v∘lab) w n := by
+  simp only [cursor,value,←List.map_take,List.map_map]
+lemma labelCoordinates_position (bs : List (G×List D)) (i : Occ (words bs)) :
+    position v (mapLabels lab bs) (labelCoordinates lab bs i)=position (v∘lab) bs i := by
+  induction bs with
+  | nil=>exact Empty.elim i
+  | cons b bs ih=>
+    cases b with
+    | mk g w=>
+      cases i with
+      | inl i=>exact congrArg (g*·) (cursor_map lab v w i.val)
+      | inr i=>exact ih i
+variable {v inv lab} {bs : List (G×List D)}
+  (d : Data v inv (mapLabels lab bs)) (hc : AllClosed Γ (words bs))
+def spherical : SphericalPicture.Data (O:=Occ (words bs)) Γ lab inv where
+  rotation := BlockBoundary.rotation (lengths (words bs))
+  partner := (labelCoordinates lab bs).symm.permCongr d.matching.partner
+  involutive := PermutationTransport.involutive _ _ d.matching.involutive
+  fixed_free := PermutationTransport.fixed_free _ _ d.matching.fixed_free
+  dart := letter (words bs)
+  consistent := closed_consistent Γ (words bs) hc
+  compatible i := by
+    rw [←labelCoordinates_letter lab bs,←labelCoordinates_letter lab bs]
+    simp only [Equiv.permCongr_apply,Equiv.symm_symm,Equiv.apply_symm_apply]
+    exact d.matching.compatible (labelCoordinates lab bs i)
+  genusZero := by
+    have hh := MapConjugation.genusZero (labelCoordinates lab bs).symm _ _ d.matching.genusZero
+    have he : (labelCoordinates lab bs).symm.permCongr
+        (BlockBoundary.rotation (lengths (words (mapLabels lab bs))))=BlockBoundary.rotation (lengths (words bs)) := by
+      apply Equiv.ext
+      intro i
+      apply (labelCoordinates lab bs).injective
+      simp only [Equiv.permCongr_apply,Equiv.symm_symm,Equiv.apply_symm_apply]
+      exact (labelCoordinates_rotation lab bs i).symm
+    rwa [he] at hh
+def sphericalLift : PictureChains.Lift Γ lab inv v (spherical Γ d hc) where
+  position i := d.lifted.position (labelCoordinates lab bs i)
+  next i := by
+    change d.lifted.position (labelCoordinates lab bs (BlockBoundary.rotation (lengths (words bs)) i))=_
+    rw [labelCoordinates_rotation,d.lifted.next,labelCoordinates_letter]
+    rfl
+  pair i := by
+    change d.lifted.position (labelCoordinates lab bs (((labelCoordinates lab bs).symm.permCongr d.matching.partner) i))=_
+    simp only [Equiv.permCongr_apply,Equiv.symm_symm,Equiv.apply_symm_apply]
+    rw [d.lifted.pair,labelCoordinates_letter]
+    rfl
+lemma sphericalLift_position (i : Occ (words bs)) :
+    (sphericalLift Γ d hc).position i=position (v∘lab) bs i := by
+  change d.lifted.position (labelCoordinates lab bs i)=_
+  rw [d.framed,labelCoordinates_position]
+variable {M : Type} [AddCommGroup M]
+  (hv : ∀a,v (inv a)=(v a)⁻¹) (hl : ∀b,lab (Γ.reverse b)=inv (lab b))
+  (c : G→D→M) (hcharge : ∀g b,c (g*v (lab b)) (Γ.reverse b)=-c g b)
+include hv hl hcharge in
+/-- Relator frames retain their ACTUAL conjugating coordinates when the
+matching is interpreted as a spherical graph picture. -/
+theorem charge_zero (hred : SphericalPicture.ReducesToEmpty Γ lab inv (spherical Γ d hc)) :
+    (∑i : Occ (words bs),c (position (v∘lab) bs i) (letter (words bs) i))=0 := by
+  have hh := PictureChains.chain_eq_zero hv hl (spherical Γ d hc) (sphericalLift Γ d hc) c hcharge hred
+  simpa only [PictureChains.chain,sphericalLift_position,spherical] using hh
+end
+end TorsionFreeZeroDivisors.WordFrames
+
+end
+
+
+
+end OAI
diff --git a/lean/OAI/Algebra/GroupRing/FreeActionNorm.lean b/lean/OAI/Algebra/GroupRing/FreeActionNorm.lean
new file mode 100644
index 0000000000000000000000000000000000000000..14add106db80a3b62743f4480283ed530293fcf8
--- /dev/null
+++ b/lean/OAI/Algebra/GroupRing/FreeActionNorm.lean
@@ -0,0 +1,101 @@
+import Mathlib
+
+namespace OAI
+
+
+
+section
+namespace TorsionFreeZeroDivisors.FreeActionNorm
+open scoped Classical BigOperators
+open CategoryTheory
+noncomputable section
+variable {H X : Type} [CommGroup H] [MulAction H X] [IsCancelSMul H X]
+abbrev Orbit := Quotient (MulAction.orbitRel H X)
+def orbitMap (p : Orbit (H:=H) (X:=X) × H) : X := p.2 • p.1.out
+omit [IsCancelSMul H X] in
+lemma orbit_class (h : H) (x : X) : (Quotient.mk'' (h • x) : Orbit (H:=H))=Quotient.mk'' x := by
+  apply Quotient.sound
+  exact MulAction.mem_orbit_iff.mpr ⟨h,rfl⟩
+lemma orbitMap_bijective : Function.Bijective (orbitMap (H:=H) (X:=X)) := by
+  constructor
+  · rintro ⟨j,h⟩ ⟨k,g⟩ he
+    have hjk : j=k := by
+      have := congrArg (fun x=>(Quotient.mk'' x : Orbit (H:=H))) he
+      simpa only [orbitMap,orbit_class,Quotient.out_eq'] using this
+    subst k
+    exact Prod.ext rfl (IsCancelSMul.right_cancel h g j.out he)
+  · intro x
+    have hx : x∈MulAction.orbit H (Quotient.mk'' x : Orbit (H:=H)).out := by
+      exact (MulAction.orbitRel_apply).mp (Quotient.exact (Quotient.out_eq' (Quotient.mk'' x : Orbit (H:=H))).symm)
+    obtain ⟨h,hh⟩ := MulAction.mem_orbit_iff.mp hx
+    exact ⟨⟨Quotient.mk'' x,h⟩,hh⟩
+def orbitEquiv : Orbit (H:=H) (X:=X) × H ≃ X := Equiv.ofBijective orbitMap orbitMap_bijective
+@[simp] lemma orbitEquiv_apply (j : Orbit (H:=H) (X:=X)) (h : H) : orbitEquiv (j,h)=h • j.out := rfl
+
+def act (h : H) : (X→₀ℤ)≃+(X→₀ℤ) := Finsupp.domCongr (MulAction.toPerm h)
+omit [IsCancelSMul H X] in
+@[simp] lemma act_apply (h : H) (x : X→₀ℤ) (a : X) : act h x a=x (h⁻¹ • a) := rfl
+
+def coords : (X→₀ℤ)≃+(Orbit (H:=H) (X:=X)→₀MonoidAlgebra ℤ H) :=
+  ((Finsupp.domCongr orbitEquiv.symm).trans Finsupp.curryAddEquiv).trans
+    (Finsupp.mapRange.addEquiv (MonoidAlgebra.coeffLinearEquiv ℤ).symm.toAddEquiv)
+@[simp] lemma coords_coeff (x : X→₀ℤ) (j : Orbit (H:=H) (X:=X)) (h : H) :
+    ((coords x) j).coeff h=x (h • j.out) := rfl
+lemma coords_act (h : H) (x : X→₀ℤ) (j : Orbit (H:=H) (X:=X)) :
+    coords (act h x) j=(Representation.leftRegular ℤ H h) (coords x j) := by
+  ext g
+  simp only [coords_coeff,act_apply,←mul_smul,Representation.coeff_ofMulAction]
+  rfl
+variable [Fintype H]
+def norm (x : X→₀ℤ) : X→₀ℤ := ∑h : H,act h x
+lemma coords_norm (x : X→₀ℤ) (j : Orbit (H:=H) (X:=X)) :
+    coords (norm (H:=H) x) j=(Rep.leftRegular ℤ H).norm.hom (coords x j) := by
+  simp only [norm,map_sum,Finsupp.finsetSum_apply,coords_act]
+  simp [Rep.norm,Representation.norm,Rep.leftRegular]
+lemma invariant_norm (g : H) (hg : ∀h,h∈Subgroup.zpowers g) (x : X→₀ℤ) (hx : act g x=x) :
+    ∃y : X→₀ℤ,norm (H:=H) y=x := by
+  let f := (Rep.leftRegular ℤ H).norm.hom.toLinearMap
+  have hxj (j : Orbit (H:=H) (X:=X)) : coords x j∈Set.range f := by
+    change coords x j∈LinearMap.range f
+    rw [Rep.FiniteCyclicGroup.leftRegular.range_norm_eq_ker_applyAsHom_sub ℤ g hg]
+    have he := congrArg (fun t=>coords t j) hx
+    rw [coords_act] at he
+    simpa only [LinearMap.mem_ker,Representation.IntertwiningMap.toLinearMap_apply,
+      Rep.sub_hom,Representation.IntertwiningMap.coe_sub,Pi.sub_apply,Rep.applyAsHom,Rep.hom_ofHom,Representation.IntertwiningMap.coe_mk,
+      Rep.hom_id,Representation.IntertwiningMap.id_apply,sub_eq_zero] using he
+  have hm : coords x∈Set.range (Finsupp.mapRange f f.map_zero) := by
+    rw [Finsupp.range_mapRange]
+    exact hxj
+  obtain ⟨z,hz⟩ := hm
+  refine ⟨(coords (H:=H) (X:=X)).symm z,(coords (H:=H) (X:=X)).injective ?_⟩
+  apply Finsupp.ext
+  intro j
+  rw [coords_norm,coords.apply_symm_apply]
+  exact congrArg (fun y=>y j) hz
+lemma kernel_norm (g : H) (hg : ∀h,h∈Subgroup.zpowers g) (x : X→₀ℤ) (hx : norm (H:=H) x=0) :
+    ∃y : X→₀ℤ,act g y-y=x := by
+  let f := (Rep.applyAsHom (Rep.leftRegular ℤ H) g-𝟙 _).hom.toLinearMap
+  have hxj (j : Orbit (H:=H) (X:=X)) : coords x j∈Set.range f := by
+    change coords x j∈LinearMap.range f
+    rw [Rep.FiniteCyclicGroup.leftRegular.range_applyAsHom_sub_eq_ker_norm ℤ g hg]
+    have he := congrArg (fun t=>coords t j) hx
+    simpa only [coords_norm,map_zero,Finsupp.zero_apply,LinearMap.mem_ker,
+      Representation.IntertwiningMap.toLinearMap_apply] using he
+  have hm : coords x∈Set.range (Finsupp.mapRange f f.map_zero) := by
+    rw [Finsupp.range_mapRange]
+    exact hxj
+  obtain ⟨z,hz⟩ := hm
+  refine ⟨(coords (H:=H) (X:=X)).symm z,(coords (H:=H) (X:=X)).injective ?_⟩
+  apply Finsupp.ext
+  intro j
+  rw [map_sub,Finsupp.sub_apply,coords_act,coords.apply_symm_apply]
+  exact congrArg (fun y=>y j) hz
+end
+end TorsionFreeZeroDivisors.FreeActionNorm
+
+
+end
+
+
+
+end OAI
diff --git a/lean/OAI/Algebra/GroupRing/FullPairing.lean b/lean/OAI/Algebra/GroupRing/FullPairing.lean
new file mode 100644
index 0000000000000000000000000000000000000000..eb75df5f6ffe4b48c0df7666ca8a59b8568b5ed5
--- /dev/null
+++ b/lean/OAI/Algebra/GroupRing/FullPairing.lean
@@ -0,0 +1,433 @@
+import Mathlib
+import OAI.Algebra.GroupRing.ConcreteGroup
+
+namespace OAI
+
+noncomputable section
+
+namespace TorsionFreeZeroDivisors.SampleGraph.FullPairing
+open scoped Classical
+open BlockAlignment ComparedBlocks GirthAsymptotics ActualPatternEvent TypedGraphs
+variable {rep : ℕ} {r : Match rep} {x : VA rep} {y : VB rep}
+  {s : PathSystem rep r x y} (a : FullPairing s) (cap : ℕ) (hc : 0<cap)
+  (hL : 1≤L (size rep)) (hd : GraphSample.Diameters rep r)
+/-- Transfer the SAME separator sets/parts/cost to the actual short-closed
+paths. In particular no extra charge for the appended tails is introduced. -/
+def closed_split (d : DecidableEq (ClosedWords.Piece s cap)) (S : Finset (ClosedWords.Piece s cap))
+    (P : @RecursiveSeparator.Split (ClosedWords.Piece s cap) d
+      (PairingClusters.Rel (fun z : Position (BalancedRotation.len s.paths cap hc)=>z.1)
+        (a.α cap hc)) S) :
+    @RecursiveSeparator.Split (ClosedWords.Piece s cap) d
+      (PairingClusters.Rel (fun z : Position (fun t=>((a.closed cap hc hL hd).paths t).length)=>z.1)
+        (a.closed cap hc hL hd).comparisons.pairing.partner) S :=
+  @RecursiveSeparator.Split.of_off_diagonal (ClosedWords.Piece s cap) d _ _ _
+      (fun _ _ h=>(a.closed_rel cap hc hL hd h).symm) P
+
+end TorsionFreeZeroDivisors.SampleGraph.FullPairing
+namespace TorsionFreeZeroDivisors.SampleGraph.Picture
+open scoped Classical
+open BlockAlignment ComparedBlocks
+variable {rep : ℕ} {r : ActualPatternEvent.Match rep} {x : VA rep} {y : VB rep} {z w : VA rep⊕VB rep}
+  {O : Type} [Fintype O]
+  (a : FinitePicture.Data (O:=O) (graph rep r) (label rep) Types.inverse z w)
+  (hzw : z≠w) (hr : a.Reduced) (hz : z=Sum.inl x ∨ z=Sum.inr y)
+  (cap : ℕ) (hc : 0<cap)
+/-- The actual segmented words of a reduced lifted disk picture have genus
+zero, with their literal segment-boundary rotation and full letter pairing.
+This does not assert the missing sharp planar separator theorem. -/
+lemma segmented_genusZero :
+    MapEuler.GenusZero
+      (BoundaryRotation.perm (BalancedRotation.len (system a hzw hr hz).paths cap hc))
+      ((pairing a hzw hr hz).α cap hc) :=
+  BalancedGenus.genusZero (system a hzw hr hz).paths cap hc
+    (pairing a hzw hr hz).perm (pairing a hzw hr hz).involutive
+    (pairing_genusZero a hzw hr hz)
+
+end TorsionFreeZeroDivisors.SampleGraph.Picture
+namespace TorsionFreeZeroDivisors.MapEuler
+
+section
+open scoped Classical
+open PermutationCycles PairingFactors
+variable {O : Type} [Fintype O]
+
+/-- Any submatching of a literal genus-zero map is still genus zero; dangling
+half-edges are retained as fixed points. No embedding predicate is assumed. -/
+theorem genusZero_subpairing (σ α β : Equiv.Perm O)
+    (ha : Function.Involutive α) (_hb : Function.Involutive β)
+    (hsub : ∀ x, β x = x ∨ β x = α x) (hz : GenusZero σ α) :
+    GenusZero σ β := by
+  classical
+  generalize hn : α.support.card = n at *
+  induction n using Nat.strong_induction_on generalizing α with
+  | h n ih =>
+    by_cases he : α = β
+    · simpa only [he] using hz
+    · obtain ⟨p,hp⟩ : ∃ p, α p ≠ β p := by
+        by_contra h
+        push Not at h
+        exact he (Equiv.ext h)
+      have hbp : β p = p := (hsub p).resolve_right (Ne.symm hp)
+      have hap : α p ≠ p := by simpa only [hbp] using hp
+      have hbq : β (α p) = α p := by
+        rcases hsub (α p) with hh|hh
+        · exact hh
+        · rw [ha] at hh
+          exact (hap (β.injective (hh.trans hbp.symm))).elim
+      have hs : ∀ x, β x = x ∨ β x = strip α p x := by
+        intro x
+        by_cases hxp : x = p
+        · exact Or.inl (hxp ▸ hbp)
+        by_cases hxq : x = α p
+        · exact Or.inl (hxq ▸ hbq)
+        rcases hsub x with hh|hh
+        · exact Or.inl hh
+        · exact Or.inr (hh.trans (strip_away α ha p x hxp hxq).symm)
+      have hc := strip_card α ha p hap
+      exact ih (strip α p).support.card (by omega) (strip α p)
+        (strip_involutive α ha p) hs (genusZero_strip σ α ha hz p hap) rfl
+
+/-- Keep a pair precisely when both its actual endpoint darts satisfy P. -/
+def inducedPairFun (α : Equiv.Perm O) (P : O → Prop) (x : O) : O :=
+  if P x ∧ P (α x) then α x else x
+
+omit [Fintype O] in
+lemma inducedPairFun_involutive (α : Equiv.Perm O) (ha : Function.Involutive α)
+    (P : O → Prop) : Function.Involutive (inducedPairFun α P) := by
+  intro x
+  by_cases h : P x ∧ P (α x)
+  · have h' : P (α x) ∧ P (α (α x)) := ⟨h.2,by rw [ha x]; exact h.1⟩
+    simp only [inducedPairFun, ite_eq_left h, ite_eq_left h']
+    exact ha x
+  · simp only [inducedPairFun, ite_eq_right h]
+
+def inducedPair (α : Equiv.Perm O) (ha : Function.Involutive α) (P : O → Prop) :
+    Equiv.Perm O where
+  toFun := inducedPairFun α P
+  invFun := inducedPairFun α P
+  left_inv := inducedPairFun_involutive α ha P
+  right_inv := inducedPairFun_involutive α ha P
+
+omit [Fintype O] in
+lemma inducedPair_apply (α : Equiv.Perm O) (ha : Function.Involutive α)
+    (P : O → Prop) (x : O) :
+    inducedPair α ha P x = if P x ∧ P (α x) then α x else x := rfl
+
+/-- The rotation of every vertex is unchanged; only crossing/outside pairs
+are removed. This handles loops, parallel edges, and disconnected graphs. -/
+theorem genusZero_inducedPair (σ α : Equiv.Perm O) (ha : Function.Involutive α)
+    (P : O → Prop) (hz : GenusZero σ α) : GenusZero σ (inducedPair α ha P) := by
+  apply genusZero_subpairing σ α _ ha (inducedPairFun_involutive α ha P) _ hz
+  intro x
+  rw [inducedPair_apply]
+  split_ifs <;> simp
+
+/-- The underlying simple graph of the actual permutation map. Ignoring loops
+and parallel copies does not discard any adjacency between distinct vertices. -/
+def graph (σ α : Equiv.Perm O) (ha : Function.Involutive α) : SimpleGraph (Cycle σ) where
+  Adj v w := v ≠ w ∧ ∃ x, cycle σ x = v ∧ cycle σ (α x) = w
+  symm := ⟨by
+    intro v w ⟨hne,x,hx,hy⟩
+    exact ⟨hne.symm,α x,hy,by rw [ha x]; exact hx⟩⟩
+  loopless := ⟨fun _ h => h.1 rfl⟩
+
+omit [Fintype O] in
+lemma graph_adj (σ α : Equiv.Perm O) (ha : Function.Involutive α) (v w : Cycle σ) :
+    (graph σ α ha).Adj v w ↔ v ≠ w ∧ ∃ x, cycle σ x = v ∧ cycle σ (α x) = w := Iff.rfl
+
+omit [Fintype O] in
+/-- The graph after matching deletion is exactly the induced relation on the
+chosen vertices, with the other vertices isolated. This is literal equality of
+adjacencies, not an assumption of inherited planarity. -/
+theorem graph_inducedPair (σ α : Equiv.Perm O) (ha : Function.Involutive α)
+    (S : Set (Cycle σ)) (v w : Cycle σ) :
+    (graph σ (inducedPair α ha (fun x=>cycle σ x∈S))
+      (inducedPairFun_involutive α ha _)).Adj v w ↔
+    (graph σ α ha).Adj v w ∧ v ∈ S ∧ w ∈ S := by
+  classical
+  simp only [graph_adj]
+  constructor
+  · rintro ⟨hne,x,hx,hy⟩
+    change cycle σ (if cycle σ x ∈ S ∧ cycle σ (α x) ∈ S then α x else x) = w at hy
+    by_cases h : cycle σ x ∈ S ∧ cycle σ (α x) ∈ S
+    · rw [ite_eq_left h] at hy
+      exact ⟨⟨hne,x,hx,hy⟩,hx ▸ h.1,hy ▸ h.2⟩
+    · rw [ite_eq_right h] at hy
+      exact (hne (hx.symm.trans hy)).elim
+  · rintro ⟨⟨hne,x,hx,hy⟩,hv,hw⟩
+    refine ⟨hne,x,hx,?_⟩
+    change cycle σ (if cycle σ x ∈ S ∧ cycle σ (α x) ∈ S then α x else x) = w
+    rw [ite_eq_left (show cycle σ x ∈ S ∧ cycle σ (α x) ∈ S by simpa only [hx,hy] using And.intro hv hw)]
+    exact hy
+
+end
+
+section
+open scoped Classical
+open PermutationCycles
+variable {O : Type} (σ α : Equiv.Perm O) (ha : Function.Involutive α)
+
+lemma component_rot (x : O) : component σ α (σ x)=component σ α x :=
+  Quotient.sound (Relation.EqvGen.symm _ _ (Relation.EqvGen.rel _ _ (Or.inl rfl)))
+lemma component_pair (x : O) : component σ α (α x)=component σ α x :=
+  Quotient.sound (Relation.EqvGen.symm _ _ (Relation.EqvGen.rel _ _ (Or.inr rfl)))
+
+include ha in
+lemma reachable_pair (x : O) :
+    (graph σ α ha).Reachable (cycle σ x) (cycle σ (α x)) := by
+  by_cases h : cycle σ x=cycle σ (α x)
+  · rw [h]
+  · exact SimpleGraph.Adj.reachable ⟨h,x,rfl,rfl⟩
+
+include ha in
+lemma reachable_of_component {x y : O}
+    (h : component σ α x=component σ α y) :
+    (graph σ α ha).Reachable (cycle σ x) (cycle σ y) := by
+  have hh : Relation.EqvGen (Edge σ α) x y := Quotient.exact h
+  clear h
+  induction hh with
+  | rel x y h =>
+    rcases h with h|h
+    · rw [←h,cycle_apply]
+    · rw [←h]
+      exact reachable_pair σ α ha x
+  | refl => exact SimpleGraph.Reachable.refl _
+  | symm _ _ _ ih => exact ih.symm
+  | trans _ _ _ _ _ ih ih' => exact ih.trans ih'
+
+variable [Fintype O]
+def vertexComponent : Cycle σ → Component σ α :=
+  PermutationCycles.lift σ (component σ α) (component_rot σ α)
+
+@[simp] lemma vertexComponent_cycle (x : O) :
+    vertexComponent σ α (cycle σ x)=component σ α x := rfl
+
+lemma vertexComponent_adj {v w : Cycle σ} (h : (graph σ α ha).Adj v w) :
+    vertexComponent σ α v=vertexComponent σ α w := by
+  obtain ⟨_,x,rfl,rfl⟩ := h
+  exact (component_pair σ α x).symm
+
+include ha in
+lemma vertexComponent_reachable {v w : Cycle σ} (h : (graph σ α ha).Reachable v w) :
+    vertexComponent σ α v=vertexComponent σ α w := by
+  obtain ⟨p⟩ := h
+  induction p with
+  | nil => rfl
+  | cons h p ih => exact (vertexComponent_adj σ α ha h).trans ih
+
+/-- Equality of actual map components is exactly graph reachability, including
+unpaired darts, loops and parallel edges. No graph planarity predicate intervenes. -/
+theorem component_eq_iff_reachable (x y : O) :
+    component σ α x=component σ α y ↔
+      (graph σ α ha).Reachable (cycle σ x) (cycle σ y) :=
+  ⟨reachable_of_component σ α ha,vertexComponent_reachable σ α ha⟩
+
+/-- The map and the underlying simple graph have literally the same components. -/
+def graphComponentEquiv : Component σ α ≃ (graph σ α ha).ConnectedComponent where
+  toFun := Quotient.lift (fun x=>(graph σ α ha).connectedComponentMk (cycle σ x))
+    (fun x y h=>SimpleGraph.ConnectedComponent.sound
+      (reachable_of_component σ α ha (Quotient.sound h)))
+  invFun := Quot.lift (vertexComponent σ α) (fun _ _ h=>vertexComponent_reachable σ α ha h)
+  left_inv := by
+    intro c
+    induction c using Quotient.inductionOn with | h x => rfl
+  right_inv := by
+    intro c
+    induction c using Quot.inductionOn with
+    | h v =>
+      obtain ⟨x,rfl⟩ := cycle_surjective σ v
+      rfl
+
+lemma graphComponent_card : Nat.card (Component σ α)=Nat.card (graph σ α ha).ConnectedComponent :=
+  Nat.card_congr (graphComponentEquiv σ α ha)
+
+end
+
+section
+open scoped Classical
+open PermutationCycles
+variable {O : Type} [Fintype O] (σ α : Equiv.Perm O) (ha : Function.Involutive α)
+
+/-- Pick an actual occurrence realizing each directed edge; this is injective
+because both endpoint vertices of an occurrence are fixed. -/
+def realizeDart (d : (graph σ α ha).Dart) : O := d.adj.2.choose
+omit [Fintype O] in
+lemma realizeDart_fst (d : (graph σ α ha).Dart) :
+    cycle σ (realizeDart σ α ha d)=d.fst := d.adj.2.choose_spec.1
+omit [Fintype O] in
+lemma realizeDart_snd (d : (graph σ α ha).Dart) :
+    cycle σ (α (realizeDart σ α ha d))=d.snd := d.adj.2.choose_spec.2
+lemma realizeDart_mem (d : (graph σ α ha).Dart) : realizeDart σ α ha d∈α.support := by
+  apply Equiv.Perm.mem_support.mpr
+  intro he
+  apply d.fst_ne_snd
+  rw [←realizeDart_fst σ α ha d,←realizeDart_snd σ α ha d,he]
+omit [Fintype O] in
+lemma realizeDart_injective : Function.Injective (realizeDart σ α ha) := by
+  intro d e h
+  apply SimpleGraph.Dart.ext
+  apply Prod.ext
+  · rw [←realizeDart_fst σ α ha d,←realizeDart_fst σ α ha e,h]
+  · rw [←realizeDart_snd σ α ha d,←realizeDart_snd σ α ha e,h]
+
+/-- Removing loops and parallel copies lowers the true paired-edge count. -/
+theorem twice_graph_edges_le_support :
+    2*Nat.card (graph σ α ha).edgeSet≤α.support.card := by
+  let f : (graph σ α ha).Dart → {x // x∈α.support} :=
+    fun d=>⟨realizeDart σ α ha d,realizeDart_mem σ α ha d⟩
+  have hi : Function.Injective f := fun _ _ h=>
+    realizeDart_injective σ α ha (congrArg Subtype.val h)
+  have hc := Fintype.card_le_of_injective f hi
+  rw [Fintype.card_coe,SimpleGraph.dart_card_eq_twice_card_edges,
+    SimpleGraph.edgeFinset_card,←Nat.card_eq_fintype_card] at hc
+  exact hc
+
+/-- A connected map with the minimal possible true edge count is a tree,
+even though the ambient definition permits loops and parallel edges. -/
+theorem graph_isTree_of_support (hc : (graph σ α ha).Connected)
+    (he : α.support.card+2=2*Nat.card (Cycle σ)) : (graph σ α ha).IsTree := by
+  apply SimpleGraph.isTree_iff_connected_and_card.mpr
+  refine ⟨hc,?_⟩
+  have h₁ := twice_graph_edges_le_support σ α ha
+  have h₂ := hc.card_vert_le_card_edgeSet_add_one
+  omega
+
+end
+
+open scoped Classical BigOperators
+open PermutationCycles
+variable {O : Type} (σ α : Equiv.Perm O) (ha : Function.Involutive α)
+
+lemma edge_has_realizer (e : (graph σ α ha).edgeSet) :
+    ∃ x : O, α x≠x ∧ s(cycle σ x,cycle σ (α x))=e.val := by
+  obtain ⟨e,he⟩ := e
+  induction e using Sym2.inductionOn with
+  | _ v w =>
+    obtain ⟨hne,x,hx,hy⟩ := he
+    refine ⟨x,?_,?_⟩
+    rotate_left
+    · change s(cycle σ x,cycle σ (α x))=s(v,w)
+      rw [hx,hy]
+    intro h
+    exact hne (hx.symm.trans ((congrArg (cycle σ) h).symm.trans hy))
+
+def edgeRep (e : (graph σ α ha).edgeSet) : O := (edge_has_realizer σ α ha e).choose
+lemma edgeRep_ne (e : (graph σ α ha).edgeSet) : α (edgeRep σ α ha e)≠edgeRep σ α ha e :=
+  (edge_has_realizer σ α ha e).choose_spec.1
+lemma edgeRep_edge (e : (graph σ α ha).edgeSet) :
+    s(cycle σ (edgeRep σ α ha e),cycle σ (α (edgeRep σ α ha e)))=e.val :=
+  (edge_has_realizer σ α ha e).choose_spec.2
+
+variable (T : SimpleGraph (Cycle σ)) (hT : T≤graph σ α ha)
+def edgeOfSubgraph (e : T.edgeSet) : (graph σ α ha).edgeSet :=
+  ⟨e.val,SimpleGraph.edgeSet_mono hT e.property⟩
+def pairFinset (e : T.edgeSet) : Finset O :=
+  {edgeRep σ α ha (edgeOfSubgraph σ α ha T hT e),
+    α (edgeRep σ α ha (edgeOfSubgraph σ α ha T hT e))}
+
+lemma pairFinset_card (e : T.edgeSet) : (pairFinset σ α ha T hT e).card=2 := by
+  simp [pairFinset,Ne.symm (edgeRep_ne σ α ha _)]
+lemma pairFinset_nonfixed (e : T.edgeSet) {x : O} (hx : x∈pairFinset σ α ha T hT e) : α x≠x := by
+  simp only [pairFinset,Finset.mem_insert,Finset.mem_singleton] at hx
+  rcases hx with rfl|rfl
+  · exact edgeRep_ne σ α ha _
+  · rw [ha]
+    exact Ne.symm (edgeRep_ne σ α ha _)
+lemma pairFinset_pair (e : T.edgeSet) {x : O} (hx : x∈pairFinset σ α ha T hT e) :
+    α x∈pairFinset σ α ha T hT e := by
+  simp only [pairFinset,Finset.mem_insert,Finset.mem_singleton] at hx ⊢
+  rcases hx with rfl|rfl
+  · exact Or.inr rfl
+  · exact Or.inl (ha _)
+lemma pairFinset_edge (e : T.edgeSet) {x : O} (hx : x∈pairFinset σ α ha T hT e) :
+    s(cycle σ x,cycle σ (α x))=e.val := by
+  simp only [pairFinset,Finset.mem_insert,Finset.mem_singleton] at hx
+  rcases hx with rfl|rfl
+  · exact edgeRep_edge σ α ha _
+  · rw [ha,Sym2.eq_swap]
+    exact edgeRep_edge σ α ha _
+
+lemma pairFinset_disjoint {e f : T.edgeSet} (hef : e≠f) :
+    Disjoint (pairFinset σ α ha T hT e) (pairFinset σ α ha T hT f) := by
+  apply Finset.disjoint_left.mpr
+  intro x hx hy
+  exact hef (Subtype.ext ((pairFinset_edge σ α ha T hT e hx).symm.trans
+    (pairFinset_edge σ α ha T hT f hy)))
+
+variable [Fintype O]
+def pickedDarts : Finset O := Finset.univ.biUnion (pairFinset σ α ha T hT)
+lemma mem_pickedDarts (x : O) :
+    x∈pickedDarts σ α ha T hT ↔ ∃ e : T.edgeSet,x∈pairFinset σ α ha T hT e := by
+  simp only [pickedDarts,Finset.mem_biUnion,Finset.mem_univ,true_and]
+lemma pickedDarts_nonfixed {x : O} (hx : x∈pickedDarts σ α ha T hT) : α x≠x := by
+  obtain ⟨e,he⟩ := (mem_pickedDarts σ α ha T hT x).mp hx
+  exact pairFinset_nonfixed σ α ha T hT e he
+lemma pickedDarts_pair {x : O} (hx : x∈pickedDarts σ α ha T hT) : α x∈pickedDarts σ α ha T hT := by
+  obtain ⟨e,he⟩ := (mem_pickedDarts σ α ha T hT x).mp hx
+  exact (mem_pickedDarts σ α ha T hT (α x)).mpr ⟨e,pairFinset_pair σ α ha T hT e he⟩
+lemma pickedDarts_card : (pickedDarts σ α ha T hT).card=2*Nat.card T.edgeSet := by
+  rw [pickedDarts,Finset.card_biUnion]
+  · simp only [pairFinset_card,Finset.sum_const,Finset.card_univ,smul_eq_mul,Nat.card_eq_fintype_card]
+    omega
+  · intro e _ f _ hef
+    exact pairFinset_disjoint σ α ha T hT hef
+
+/-- A chosen simple subgraph is realized by exactly one original paired edge
+per simple edge, with the original vertex rotations unchanged. -/
+def subgraphPair : Equiv.Perm O := inducedPair α ha (fun x=>x∈pickedDarts σ α ha T hT)
+lemma subgraphPair_involutive : Function.Involutive (subgraphPair σ α ha T hT) :=
+  inducedPairFun_involutive α ha _
+lemma subgraphPair_apply (x : O) : subgraphPair σ α ha T hT x=
+    if x∈pickedDarts σ α ha T hT then α x else x := by
+  rw [subgraphPair,inducedPair_apply]
+  by_cases hx : x∈pickedDarts σ α ha T hT
+  · rw [ite_eq_left hx,ite_eq_left ⟨hx,pickedDarts_pair σ α ha T hT hx⟩]
+  · rw [ite_eq_right hx,ite_eq_right (fun h=>hx h.1)]
+lemma subgraphPair_support : (subgraphPair σ α ha T hT).support=pickedDarts σ α ha T hT := by
+  ext x
+  rw [Equiv.Perm.mem_support,subgraphPair_apply]
+  by_cases hx : x∈pickedDarts σ α ha T hT
+  · rw [ite_eq_left hx]
+    exact iff_of_true (pickedDarts_nonfixed σ α ha T hT hx) hx
+  · rw [ite_eq_right hx]
+    simp only [ne_eq,not_true_eq_false,false_iff]
+    exact hx
+lemma subgraphPair_support_card : (subgraphPair σ α ha T hT).support.card=2*Nat.card T.edgeSet := by
+  rw [subgraphPair_support,pickedDarts_card]
+
+lemma subgraphPair_graph :
+    graph σ (subgraphPair σ α ha T hT) (subgraphPair_involutive σ α ha T hT)=T := by
+  ext v w
+  constructor
+  · rintro ⟨hne,x,hx,hy⟩
+    rw [subgraphPair_apply] at hy
+    by_cases hp : x∈pickedDarts σ α ha T hT
+    · rw [ite_eq_left hp] at hy
+      obtain ⟨e,he⟩ := (mem_pickedDarts σ α ha T hT x).mp hp
+      have hedge := pairFinset_edge σ α ha T hT e he
+      rw [hx,hy] at hedge
+      exact (T.mem_edgeSet).mp (hedge.symm ▸ e.property)
+    · rw [ite_eq_right hp] at hy
+      exact (hne (hx.symm.trans hy)).elim
+  · intro h
+    let e : T.edgeSet := ⟨s(v,w),h⟩
+    let p := edgeRep σ α ha (edgeOfSubgraph σ α ha T hT e)
+    have hmem : p∈pickedDarts σ α ha T hT :=
+      (mem_pickedDarts σ α ha T hT p).mpr ⟨e,Finset.mem_insert_self _ _⟩
+    have he : s(cycle σ p,cycle σ (α p))=s(v,w) := edgeRep_edge σ α ha _
+    rcases Sym2.eq_iff.mp he with ⟨hv,hw⟩|⟨hw,hv⟩
+    · refine ⟨h.ne,p,hv,?_⟩
+      rw [subgraphPair_apply,ite_eq_left hmem]
+      exact hw
+    · refine ⟨h.ne,α p,hv,?_⟩
+      rw [subgraphPair_apply,ite_eq_left (pickedDarts_pair σ α ha T hT hmem),ha]
+      exact hw
+
+lemma genusZero_subgraphPair (hz : GenusZero σ α) :
+    GenusZero σ (subgraphPair σ α ha T hT) := genusZero_inducedPair σ α ha _ hz
+
+end TorsionFreeZeroDivisors.MapEuler
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/GroupRing/GeneralPosition.lean b/lean/OAI/Algebra/GroupRing/GeneralPosition.lean
new file mode 100644
index 0000000000000000000000000000000000000000..119a25fcf61611fa08c9297a8286241d2d7e23ff
--- /dev/null
+++ b/lean/OAI/Algebra/GroupRing/GeneralPosition.lean
@@ -0,0 +1,400 @@
+import Mathlib
+import OAI.Algebra.GroupRing.CayleyFurther
+
+namespace OAI
+
+noncomputable section
+
+open Set Metric Topology BigOperators
+open Set Metric Topology
+
+namespace GroupRingTopology.Attachment
+open Set Metric Topology
+variable {X : Type*} [TopologicalSpace X] {ι : Type*} {n : ℕ}
+variable (a : ι → C(Sphere n,X))
+
+def radialRetraction : C(punctured a,X) :=
+  puncturedLift a (.id X) (fun i => (a i).comp radialSphere)
+    (fun i x => by simp only [ContinuousMap.comp_apply,radialSphere_boundary,ContinuousMap.id_apply])
+
+@[simp] lemma radialRetraction_base (x : X) : radialRetraction a (puncturedBase a x) = x := rfl
+@[simp] lemma radialRetraction_cell (i : ι) (d : PuncturedDisk n) :
+    radialRetraction a (puncturedCell a i d) = a i (radialSphere d) := by
+  exact puncturedLift_cell _ _ _ _ _ _
+
+def radialPaths : C(punctured a,C(unitInterval,Space a)) := by
+  let f : C(X × unitInterval,Space a) := ⟨fun p => base a p.1,(continuous_base a).comp continuous_fst⟩
+  let g (i : ι) : C(PuncturedDisk n × unitInterval,Space a) :=
+    (cell a i).comp (radialDisk.comp ⟨Prod.swap,continuous_swap⟩)
+  have h (i : ι) (x : Sphere n) : (g i).curry (puncturedBoundary x) = f.curry (a i x) := by
+    ext t
+    change cell a i (radialDisk (t,puncturedBoundary x)) = base a (a i x)
+    rw [radialDisk_boundary,cell_boundary]
+  exact puncturedLift a f.curry (fun i => (g i).curry) h
+
+@[simp] lemma radialPaths_base (x : X) (t : unitInterval) :
+    radialPaths a (puncturedBase a x) t = base a x := rfl
+@[simp] lemma radialPaths_cell (i : ι) (d : PuncturedDisk n) (t : unitInterval) :
+    radialPaths a (puncturedCell a i d) t = cell a i (radialDisk (t,d)) := by
+  unfold radialPaths
+  rw [puncturedLift_cell]
+  rfl
+
+def puncturedInclusion : C(punctured a,Space a) := ⟨Subtype.val,continuous_subtype_val⟩
+def radialEnd : C(punctured a,Space a) := (⟨base a,continuous_base a⟩ : C(X,Space a)).comp (radialRetraction a)
+
+/-- The punctured attachment deformation-retracts to the original space. -/
+def radialHomotopy : (puncturedInclusion a).Homotopy (radialEnd a) where
+  toFun p := radialPaths a p.2 p.1
+  continuous_toFun := (radialPaths a).uncurry.continuous.comp continuous_swap
+  map_zero_left z := by
+    rcases punctured_surjective a z with ⟨x,rfl⟩ | ⟨i,d,rfl⟩
+    · rfl
+    · rw [radialPaths_cell,radialDisk_zero]
+      rfl
+  map_one_left z := by
+    rcases punctured_surjective a z with ⟨x,rfl⟩ | ⟨i,d,rfl⟩
+    · rfl
+    · rw [radialPaths_cell,radialDisk_one,cell_boundary]
+      change base a (a i (radialSphere d)) = base a (radialRetraction a (puncturedCell a i d))
+      rw [radialRetraction_cell]
+
+@[simp] lemma radialHomotopy_base (x : X) (t : unitInterval) :
+    radialHomotopy a (t,puncturedBase a x) = base a x := rfl
+
+lemma cell_eq_openCell_iff (i j : ι) (d : Disk n) (x : OpenDisk n) :
+    cell a i d = openCell a j x ↔ i = j ∧ d.1 = x.1 := by
+  classical
+  constructor
+  · intro h
+    by_cases hd : d.1 ∈ ball (0 : Fin n → ℝ) 1
+    · have hi : cell a i d = Sum.inr ⟨i,⟨d.1,hd⟩⟩ :=
+        cell_interior a i ⟨d.1,hd⟩
+      rw [hi] at h
+      have hh : (⟨i,⟨d.1,hd⟩⟩ : Σ _ : ι, OpenDisk n) = ⟨j,x⟩ := Sum.inr_injective h
+      exact ⟨congrArg Sigma.fst hh,congrArg (fun p : Σ _ : ι, OpenDisk n => p.2.1) hh⟩
+    · let s : Sphere n := ⟨d.1,by
+        have hm := d.2
+        simp only [mem_sphere,mem_ball,mem_closedBall] at *
+        exact le_antisymm hm (le_of_not_gt hd)⟩
+      have hi : cell a i d = base a (a i s) := cell_boundary a i s
+      rw [hi] at h
+      cases h
+  · rintro ⟨rfl,h⟩
+    have hd : d = interior n x := Subtype.ext h
+    rw [hd,cell_interior]
+    rfl
+
+lemma openCell_disjoint (i j : ι) (hij : i ≠ j) :
+    Disjoint (Set.range (openCell a i)) (Set.range (openCell a j)) := by
+  apply Set.disjoint_left.mpr
+  rintro z ⟨x,rfl⟩ ⟨y,h⟩
+  exact hij (congrArg Sigma.fst (Sum.inr_injective h)).symm
+
+lemma openCell_selection_closed {I : Type*} (c : I → ι) (hc : Function.Injective c)
+    (x : I → OpenDisk n) (S : Set (Space a))
+    (hS : S ⊆ Set.range (fun i => openCell a (c i) (x i))) : IsClosed S := by
+  rw [isClosed_iff]
+  constructor
+  · have h : base a ⁻¹' S = ∅ := by
+      apply Set.eq_empty_iff_forall_notMem.mpr
+      intro y hy
+      obtain ⟨i,hi⟩ := hS hy
+      cases hi
+    rw [h]
+    exact isClosed_empty
+  · intro j
+    suffices (cell a j ⁻¹' S).Subsingleton from this.finite.isClosed
+    intro d hd e he
+    obtain ⟨i,hi⟩ := hS hd
+    obtain ⟨k,hk⟩ := hS he
+    have hdi := (cell_eq_openCell_iff a j (c i) d (x i)).mp hi.symm
+    have hek := (cell_eq_openCell_iff a j (c k) e (x k)).mp hk.symm
+    have hik : i = k := hc (hdi.1.symm.trans hek.1)
+    subst k
+    exact Subtype.ext (hdi.2.trans hek.2.symm)
+
+/-- The weak adjunction topology prevents compact sets from meeting infinitely
+many of the new open cells. No local-finiteness assumption is needed. -/
+lemma compact_finitely_many_openCells {K : Set (Space a)} (hK : IsCompact K) :
+    {i : ι | (K ∩ Set.range (openCell a i)).Nonempty}.Finite := by
+  classical
+  let I := {i : ι | (K ∩ Set.range (openCell a i)).Nonempty}
+  have hchoice (i : I) : ∃ x : OpenDisk n, openCell a i.1 x ∈ K := by
+    obtain ⟨z,hz,⟨x,hx⟩⟩ := i.2
+    exact ⟨x,hx ▸ hz⟩
+  choose x hx using hchoice
+  let y : I → Space a := fun i => openCell a i.1 (x i)
+  have hyinj : Function.Injective y := by
+    intro i j h
+    apply Subtype.ext
+    exact congrArg Sigma.fst (Sum.inr_injective h)
+  have hclosed : ∀ S ⊆ Set.range y, IsClosed S :=
+    openCell_selection_closed a Subtype.val Subtype.val_injective x
+  have hcompact : IsCompact (Set.range y) := hK.of_isClosed_subset
+    (hclosed _ subset_rfl) (Set.range_subset_iff.mpr hx)
+  have hdisc : IsDiscrete (Set.range y) := by
+    apply isDiscrete_iff_forall_mem_exists_isClosed.mpr
+    intro S hS
+    exact ⟨S,hclosed S hS,Set.inter_eq_left.mpr hS⟩
+  have hrange := hcompact.finite hdisc
+  have : Finite I := (Set.finite_range_iff hyinj).mp hrange
+  exact Set.toFinite I
+
+end GroupRingTopology.Attachment
+
+open Set Topology
+namespace GroupRingTopology.Cellular
+variable {X Y : Type*} [TopologicalSpace X] [TopologicalSpace Y]
+
+def patchFun (A : Set X) (f : C(X,Y)) (g : C(A,Y)) (x : X) : Y := by
+  classical
+  exact if hx : x ∈ A then g ⟨x,hx⟩ else f x
+
+lemma patchFun_on (A : Set X) (f : C(X,Y)) (g : C(A,Y)) (x : A) :
+    patchFun A f g x = g x := by simp only [patchFun,dite_eq_left x.2]
+
+lemma patchFun_off (A : Set X) (f : C(X,Y)) (g : C(A,Y)) {x : X} (hx : x ∉ A) :
+    patchFun A f g x = f x := by simp only [patchFun,dite_eq_right hx]
+
+lemma continuous_patchFun {A : Set X} (hA : IsClosed A) (f : C(X,Y)) (g : C(A,Y))
+    (hboundary : ∀ (x : A), (x:X) ∈ frontier A → g x = f x) :
+    Continuous (patchFun A f g) := by
+  classical
+  have hOn : ContinuousOn (patchFun A f g) A := by
+    rw [continuousOn_iff_continuous_domRestrict]
+    have heq : A.domRestrict (patchFun A f g) = g := funext (patchFun_on A f g)
+    rw [heq]
+    exact g.continuous
+  have h := continuous_if (p := fun x => x ∈ A) (f := patchFun A f g) (g := f)
+    (fun x hx => by
+      have hxa : x ∈ A := hA.closure_eq ▸ hx.1
+      exact (patchFun_on A f g ⟨x,hxa⟩).trans (hboundary ⟨x,hxa⟩ hx))
+    (by simpa only [Set.ofPred_mem_eq,hA.closure_eq] using hOn) f.continuous.continuousOn
+  convert h using 1
+  ext x
+  by_cases hx : x ∈ A
+  · simp only [ite_eq_left hx]
+  · simp only [ite_eq_right hx,patchFun_off A f g hx]
+
+def patch {A : Set X} (hA : IsClosed A) (f : C(X,Y)) (g : C(A,Y))
+    (hboundary : ∀ (x : A), (x:X) ∈ frontier A → g x = f x) : C(X,Y) :=
+  ⟨patchFun A f g,continuous_patchFun hA f g hboundary⟩
+
+lemma patch_on {A : Set X} (hA : IsClosed A) (f : C(X,Y)) (g : C(A,Y))
+    (hboundary : ∀ (x : A), (x:X) ∈ frontier A → g x = f x) (x : A) :
+    patch hA f g hboundary x = g x := patchFun_on A f g x
+
+lemma patch_off {A : Set X} (hA : IsClosed A) (f : C(X,Y)) (g : C(A,Y))
+    (hboundary : ∀ (x : A), (x:X) ∈ frontier A → g x = f x) {x : X} (hx : x ∉ A) :
+    patch hA f g hboundary x = f x := patchFun_off A f g hx
+
+/-- Homotopies on a closed subset glue to the stationary homotopy outside it,
+provided they are stationary on the frontier. -/
+def patchHomotopy {A : Set X} (hA : IsClosed A) (f : C(X,Y)) (g : C(A,Y))
+    (H : (f.restrict A).Homotopy g)
+    (hboundary : ∀ (t : unitInterval) (x : A), (x:X) ∈ frontier A → H (t,x) = f x) :
+    f.Homotopy (patch hA f g (fun x hx => by simpa using hboundary 1 x hx)) := by
+  let B : Set (unitInterval × X) := Prod.snd ⁻¹' A
+  let H' : C(B,Y) := ⟨fun z => H (z.1.1,⟨z.1.2,z.2⟩),
+    H.continuous.comp ((continuous_fst.comp continuous_subtype_val).prodMk
+      ((continuous_snd.comp continuous_subtype_val).subtype_mk _))⟩
+  let hB : IsClosed B := hA.preimage continuous_snd
+  let F : C(unitInterval × X,Y) := f.comp ⟨Prod.snd,continuous_snd⟩
+  have hb : ∀ z : B, (z : unitInterval × X) ∈ frontier B → H' z = F z := by
+    intro z hz
+    exact hboundary z.1.1 ⟨z.1.2,z.2⟩ (continuous_snd.frontier_preimage_subset A hz)
+  refine ⟨patch hB F H' hb,?_,?_⟩
+  · intro x
+    change patch hB F H' hb (0,x) = f x
+    by_cases hx : x ∈ A
+    · rw [patch_on hB F H' hb ⟨(0,x),hx⟩]
+      exact H.apply_zero ⟨x,hx⟩
+    · exact patch_off hB F H' hb (x := (_,x)) hx
+  · intro x
+    change patch hB F H' hb (1,x) = patch hA f g _ x
+    by_cases hx : x ∈ A
+    · rw [patch_on hB F H' hb ⟨(1,x),hx⟩,patch_on hA f g _ ⟨x,hx⟩]
+      exact H.apply_one ⟨x,hx⟩
+    · rw [patch_off hB F H' hb (x := (_,x)) hx,patch_off hA f g _ hx]
+      rfl
+
+end GroupRingTopology.Cellular
+open Set Metric Topology
+open scoped NNReal
+namespace GroupRingTopology.GeneralPosition
+
+section
+variable {K : Type*} [MetricSpace K] [CompactSpace K]
+
+lemma lipschitz_mul {f g : C(K,ℝ)} {L M : ℝ≥0}
+    (hf : LipschitzWith L f) (hg : LipschitzWith M g) :
+    LipschitzWith (‖f‖₊ * M + ‖g‖₊ * L) (f * g) := by
+  apply LipschitzWith.of_dist_le_mul
+  intro x y
+  simp only [ContinuousMap.mul_apply,NNReal.coe_add,NNReal.coe_mul,coe_nnnorm]
+  calc
+    dist (f x * g x) (f y * g y)
+        = ‖f x * (g x-g y) + g y * (f x-f y)‖ := by
+          rw [dist_eq_norm]; congr 1; ring
+    _ ≤ ‖f x * (g x-g y)‖ + ‖g y * (f x-f y)‖ := norm_add_le _ _
+    _ = ‖f x‖ * dist (g x) (g y) + ‖g y‖ * dist (f x) (f y) := by
+      rw [norm_mul,norm_mul,dist_eq_norm,dist_eq_norm]
+    _ ≤ ‖f‖ * ((M:ℝ) * dist x y) + ‖g‖ * ((L:ℝ) * dist x y) := by
+      gcongr
+      · exact f.norm_coe_le_norm x
+      · exact hg.dist_le_mul x y
+      · exact g.norm_coe_le_norm y
+      · exact hf.dist_le_mul x y
+    _ = (‖f‖ * M + ‖g‖ * L) * dist x y := by ring
+
+def lipschitzAlgebra : Subalgebra ℝ C(K,ℝ) where
+  carrier := {f | ∃ L, LipschitzWith L f}
+  zero_mem' := ⟨0,LipschitzWith.const 0⟩
+  one_mem' := ⟨0,LipschitzWith.const 1⟩
+  add_mem' := by rintro f g ⟨L,hL⟩ ⟨M,hM⟩; exact ⟨L+M,hL.add hM⟩
+  mul_mem' := by rintro f g ⟨L,hL⟩ ⟨M,hM⟩; exact ⟨_,lipschitz_mul hL hM⟩
+  algebraMap_mem' r := ⟨0,LipschitzWith.const r⟩
+
+lemma lipschitzAlgebra_separates : (lipschitzAlgebra (K := K)).SeparatesPoints := by
+  intro x y hxy
+  refine ⟨fun z => dist z y,⟨⟨fun z => dist z y,continuous_id.dist continuous_const⟩,
+    ⟨1,LipschitzWith.dist_left y⟩,rfl⟩,?_⟩
+  simpa using hxy
+
+/-- Uniform Lipschitz approximation on an arbitrary compact metric space. -/
+lemma exists_lipschitz_approximation (f : C(K,ℝ)) {ε : ℝ} (hε : 0 < ε) :
+    ∃ g : C(K,ℝ), (∃ L, LipschitzWith L g) ∧ ∀ x, ‖g x-f x‖ < ε := by
+  obtain ⟨g,hg⟩ := ContinuousMap.exists_mem_subalgebra_near_continuous_of_separatesPoints
+    lipschitzAlgebra lipschitzAlgebra_separates f f.continuous ε hε
+  exact ⟨g,g.2,hg⟩
+
+end
+
+section
+open Set Metric Topology
+open scoped NNReal ENNReal
+variable {K : Type*} [MetricSpace K] [CompactSpace K]
+
+lemma exists_lipschitz_vector_approximation {n : ℕ} (f : C(K,Fin n → ℝ))
+    {ε : ℝ} (hε : 0 < ε) :
+    ∃ g : C(K,Fin n → ℝ), (∃ L, LipschitzWith L g) ∧ ∀ x, ‖g x-f x‖ < ε := by
+  classical
+  have hex : ∀ i : Fin n, ∃ g : C(K,ℝ), (∃ L, LipschitzWith L g) ∧
+      ∀ x, ‖g x-f x i‖ < ε := fun i =>
+    exists_lipschitz_approximation ⟨fun x => f x i,(continuous_apply i).comp f.continuous⟩ hε
+  choose g hg he using hex
+  choose L hL using hg
+  let H : C(K,Fin n → ℝ) := ⟨fun x i => g i x,continuous_pi (fun i => (g i).continuous)⟩
+  refine ⟨H,⟨Finset.univ.sup L,?_⟩,?_⟩
+  · apply LipschitzWith.of_dist_le_mul
+    intro x y
+    rw [dist_pi_le_iff (mul_nonneg (NNReal.coe_nonneg _) dist_nonneg)]
+    intro i
+    exact (hL i).dist_le_mul x y |>.trans (mul_le_mul_of_nonneg_right
+      (by exact_mod_cast Finset.le_sup (f := L) (Finset.mem_univ i)) dist_nonneg)
+  · intro x
+    exact (pi_norm_lt_iff hε).mpr (fun i => he i x)
+
+omit [CompactSpace K] in
+/-- A Lipschitz image of smaller Hausdorff dimension misses points in every
+positive-radius ball of Euclidean target space. -/
+lemma exists_missing_point {n : ℕ} {g : K → Fin n → ℝ} {L : ℝ≥0}
+    (hg : LipschitzWith L g) (hdim : dimH (Set.univ : Set K) < n)
+    (c : Fin n → ℝ) {r : ℝ} (hr : 0 < r) :
+    ∃ a ∈ Metric.ball c r, a ∉ Set.range g := by
+  by_contra! h
+  have hle : dimH (Metric.ball c r) ≤ dimH (Set.range g) := dimH_mono h
+  rw [Real.dimH_ball_pi_fin _ hr] at hle
+  exact (not_le_of_gt hdim) (hle.trans hg.dimH_range_le)
+
+/-- Every map from a compact metric space of dimension less than n can be
+uniformly approximated by a map into punctured ℝ^n. -/
+lemma exists_nonzero_approximation {n : ℕ} (f : C(K,Fin n → ℝ))
+    (hdim : dimH (Set.univ : Set K) < n) {ε : ℝ} (hε : 0 < ε) :
+    ∃ g : C(K,Fin n → ℝ), (∀ x, g x ≠ 0) ∧ ∀ x, ‖g x-f x‖ < ε := by
+  obtain ⟨h,⟨L,hL⟩,hh⟩ := exists_lipschitz_vector_approximation f (half_pos hε)
+  obtain ⟨a,ha,ha'⟩ := exists_missing_point hL hdim 0 (half_pos hε)
+  refine ⟨h - ContinuousMap.const K a,?_,?_⟩
+  · intro x hx
+    apply ha'
+    exact ⟨x,sub_eq_zero.mp hx⟩
+  · intro x
+    have ha : ‖a‖ < ε/2 := by simpa only [Metric.mem_ball,dist_zero_right] using ha
+    change ‖(h x-a)-f x‖ < ε
+    have hhx := hh x
+    calc
+      ‖(h x-a)-f x‖ = ‖(h x-f x)-a‖ := by congr 1; abel
+      _ ≤ ‖h x-f x‖+‖a‖ := norm_sub_le _ _
+      _ < ε := by linarith
+
+end
+
+open Set Metric Topology
+open scoped NNReal ENNReal
+variable {K : Type*} [MetricSpace K] [CompactSpace K]
+
+def cutoff (δ r : ℝ) : ℝ := min 1 (max 0 (2-r/δ))
+lemma cutoff_nonneg (δ r : ℝ) : 0 ≤ cutoff δ r := le_min (by norm_num) (le_max_left _ _)
+lemma cutoff_le_one (δ r : ℝ) : cutoff δ r ≤ 1 := min_le_left _ _
+lemma cutoff_small {δ r : ℝ} (hδ : 0 < δ) (hr : r ≤ δ) : cutoff δ r = 1 := by
+  apply min_eq_left
+  apply le_max_of_le_right
+  have : r/δ ≤ 1 := (div_le_one hδ).mpr hr
+  linarith
+lemma cutoff_large {δ r : ℝ} (hδ : 0 < δ) (hr : 2*δ ≤ r) : cutoff δ r = 0 := by
+  have : 2 ≤ r/δ := (le_div_iff₀ hδ).mpr hr
+  simp only [cutoff,max_eq_left (by linarith : 2-r/δ ≤ 0),min_eq_right (by norm_num : (0:ℝ)≤1)]
+lemma continuous_cutoff (δ : ℝ) : Continuous (cutoff δ) :=
+  continuous_const.min (continuous_const.max (continuous_const.sub (continuous_id.div_const δ)))
+
+/-- General position relative to the region already far from the origin. -/
+lemma exists_relative_nonzero_approximation {n : ℕ} (f : C(K,Fin n → ℝ))
+    (hdim : dimH (Set.univ : Set K) < n) {δ : ℝ} (hδ : 0 < δ) :
+    ∃ g : C(K,Fin n → ℝ), (∀ x, g x ≠ 0) ∧
+      (∀ x, 2*δ ≤ ‖f x‖ → g x = f x) ∧ ∀ x, ‖g x-f x‖ < δ/2 := by
+  obtain ⟨h,hne,hh⟩ := exists_nonzero_approximation f hdim (half_pos hδ)
+  let g : C(K,Fin n → ℝ) := ⟨fun x => f x + cutoff δ ‖f x‖ • (h x-f x),
+    f.continuous.add (((continuous_cutoff δ).comp f.continuous.norm).smul
+      (h.continuous.sub f.continuous))⟩
+  have hdist (x : K) : ‖g x-f x‖ < δ/2 := by
+    change ‖(f x+cutoff δ ‖f x‖ • (h x-f x))-f x‖ < δ/2
+    rw [add_sub_cancel_left,norm_smul,Real.norm_of_nonneg (cutoff_nonneg _ _)]
+    exact (mul_le_of_le_one_left (norm_nonneg _) (cutoff_le_one _ _)).trans_lt (hh x)
+  refine ⟨g,?_,?_,hdist⟩
+  · intro x hx
+    by_cases hnorm : ‖f x‖ ≤ δ
+    · have hg : g x = h x := by
+        change f x+cutoff δ ‖f x‖ • (h x-f x)=h x
+        rw [cutoff_small hδ hnorm,one_smul,add_sub_cancel]
+      exact hne x (hg.symm.trans hx)
+    · have hd := hdist x
+      rw [hx,zero_sub,norm_neg] at hd
+      linarith
+  · intro x hx
+    change f x+cutoff δ ‖f x‖ • (h x-f x)=f x
+    rw [cutoff_large hδ hx,zero_smul,add_zero]
+
+omit [MetricSpace K] [CompactSpace K] in
+/-- The straight-line homotopy from the original to the perturbed map stays
+inside any disk of radius 4δ, and is stationary outside the core of radius 2δ. -/
+lemma relative_interpolation_bound {n : ℕ} {f g : K → Fin n → ℝ} {δ : ℝ} (hδ : 0 < δ)
+    (hfix : ∀ x, 2*δ ≤ ‖f x‖ → g x = f x)
+    (hdist : ∀ x, ‖g x-f x‖ < δ/2)
+    (x : K) (hx : ‖f x‖ ≤ 4*δ) (t : unitInterval) :
+    ‖f x+(t:ℝ) • (g x-f x)‖ ≤ 4*δ := by
+  by_cases hc : 2*δ ≤ ‖f x‖
+  · rw [hfix x hc,sub_self,smul_zero,add_zero]
+    exact hx
+  · have ht : ‖(t:ℝ) • (g x-f x)‖ ≤ ‖g x-f x‖ := by
+      rw [norm_smul,Real.norm_of_nonneg t.2.1]
+      exact mul_le_of_le_one_left (norm_nonneg _) t.2.2
+    have hsum := norm_add_le (f x) ((t:ℝ) • (g x-f x))
+    have hd := hdist x
+    linarith
+
+end GroupRingTopology.GeneralPosition
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/GroupRing/GraphConeCW.lean b/lean/OAI/Algebra/GroupRing/GraphConeCW.lean
new file mode 100644
index 0000000000000000000000000000000000000000..bff6d6ab4a090def88493f8a184468515a8a4d32
--- /dev/null
+++ b/lean/OAI/Algebra/GroupRing/GraphConeCW.lean
@@ -0,0 +1,311 @@
+import Mathlib
+import OAI.Algebra.GroupRing.SphereTopology
+import OAI.Algebra.GroupRing.ConeCells
+
+namespace OAI
+
+noncomputable section
+
+namespace TorsionFreeZeroDivisors.GraphConeCW
+open Set Metric Topology GroupRingTopology GroupRingTopology.Attachment
+open scoped unitInterval Classical
+variable {V E : Type} (src dst : E→V)
+local instance optionVertexTopology : TopologicalSpace (Option V) := ⊥
+local instance optionVertexDiscreteTopology : DiscreteTopology (Option V) := ⟨rfl⟩
+instance oneNonempty : Nonempty (One src dst) := ⟨vertex src dst none⟩
+lemma zero_dimension (n : ℕ) (i : RelCWComplex.cell (Set.univ : Set (Option V)) n) : n<1 := by
+  cases n with
+  | zero => omega
+  | succ n => exact i.elim
+instance oneCW : CWComplex (Set.univ : Set (One src dst)) := layerCW _ zero_dimension
+instance oneT2 : T2Space (One src dst) := t2Space _ realSeparated_of_tychonoff
+lemma one_dimension (n : ℕ) (i : RelCWComplex.cell (Set.univ : Set (One src dst)) n) : n<2 :=
+  layerCW_dimensions _ zero_dimension n i
+instance coneCW : CWComplex (Set.univ : Set (Cone src dst)) := layerCW _ (one_dimension src dst)
+instance coneT2 : T2Space (Cone src dst) := t2Space _ (realSeparated _ realSeparated_of_tychonoff)
+lemma no_higher (n : ℕ) (hn : 2<n) : IsEmpty (RelCWComplex.cell (Set.univ : Set (Cone src dst)) n) := by
+  refine ⟨fun i=>?_⟩
+  have := layerCW_dimensions (twoBoundary src dst) (one_dimension src dst) n i
+  omega
+lemma finite [Finite V] [Finite E] : CWComplex.Finite (Set.univ : Set (Cone src dst)) where
+  eventually_isEmpty_cell := Filter.eventually_atTop.mpr ⟨3,fun n hn=>no_higher src dst n (by omega)⟩
+  finite_cell n := by
+    apply layerCW_finite_cells
+    intro m
+    apply layerCW_finite_cells
+    intro k
+    cases k with
+    | zero => change Finite (Set.univ : Set (Option V)); infer_instance
+    | succ k => change Finite PEmpty; infer_instance
+lemma two_cell [Nonempty E] : Nonempty (RelCWComplex.cell (Set.univ : Set (Cone src dst)) 2) :=
+  ⟨Sum.inr ⟨⟨⟨rfl⟩,Classical.choice inferInstance⟩⟩⟩
+variable {Y : Type*} [TopologicalSpace Y]
+variable (v : C(Option V,Y)) (ed : V⊕E→C(Disk 1,Y))
+    (hed : ∀i x,ed i (boundary 1 x)=v (oneBoundary src dst i x))
+def mapOne : C(One src dst,Y) := lift _ v ed hed
+@[simp] lemma mapOne_vertex (x : Option V) : mapOne src dst v ed hed (vertex src dst x)=v x := rfl
+@[simp] lemma mapOne_edge (i : V⊕E) (d : Disk 1) : mapOne src dst v ed hed (cell (oneBoundary src dst) i d)=ed i d :=
+  lift_cell _ _ _ _ i d
+variable (sq : E→C(Disk 2,Y)) (hsq : ∀e x,sq e (boundary 2 x)=mapOne src dst v ed hed (twoBoundary src dst e x))
+def mapCone : C(Cone src dst,Y) := lift _ (mapOne src dst v ed hed) sq hsq
+@[simp] lemma mapCone_one (x : One src dst) : mapCone src dst v ed hed sq hsq (inclusion src dst x)=mapOne src dst v ed hed x := rfl
+@[simp] lemma mapCone_square (e : E) (d : Disk 2) : mapCone src dst v ed hed sq hsq (square src dst e d)=sq e d :=
+  lift_cell _ _ _ _ e d
+end TorsionFreeZeroDivisors.GraphConeCW
+
+namespace TorsionFreeZeroDivisors.CellPresentation
+open Set Metric Topology GroupRingTopology GroupRingTopology.Attachment GroupRingTopology.PathExtension
+open scoped unitInterval
+variable {G S Q : Type} [Group G] [TopologicalSpace G] [DiscreteTopology G]
+variable (s : S→G) (a : Q→C(Sphere 2,Cayley.Graph s))
+abbrev Cover := Space (equivariantFamily (G:=G) a)
+def inclusion : C(Cayley.Graph s,Cover s a) := ⟨base _,continuous_base _⟩
+lemma inclusion_smul (g : G) (x : Cayley.Graph s) : inclusion s a (g • x)=g • inclusion s a x := rfl
+def wordLift : FreeGroup S →* Extension G (inclusion s a (Cayley.vertex s 1)) :=
+  (PathExtension.map (inclusion s a) (inclusion_smul s a) (Cayley.vertex s 1)).comp (Cayley.wordLift s)
+variable (rel : Q→FreeGroup S) (ha : ∀q,wordLift s a (rel q)=1)
+variable (hs : Function.Surjective (FreeGroup.lift s))
+    (hker : (FreeGroup.lift s).ker=Subgroup.normalClosure (Set.range rel))
+include ha hker in
+lemma wordLift_ker : (FreeGroup.lift s).ker≤(wordLift s a).ker := by
+  rw [hker]
+  apply Subgroup.normalClosure_le_normal
+  rintro _ ⟨q,rfl⟩
+  exact ha q
+def sectionMap : G →* Extension G (inclusion s a (Cayley.vertex s 1)) :=
+  (FreeGroup.lift s).liftOfSurjective hs ⟨wordLift s a,wordLift_ker s a rel ha hker⟩
+lemma sectionMap_lift (w : FreeGroup S) :
+    sectionMap s a rel ha hs hker (FreeGroup.lift s w)=wordLift s a w :=
+  MonoidHom.liftOfRightInverse_comp_apply ..
+lemma sectionMap_fst (g : G) : (sectionMap s a rel ha hs hker g).1=g := by
+  obtain ⟨w,rfl⟩ := hs g
+  rw [sectionMap_lift]
+  exact Cayley.wordLift_fst s w
+lemma sectionMap_generator (i : S) : PathExtension.Q.Equal
+    (sectionMap s a rel ha hs hker (s i)).2
+    (Path.Homotopic.Quotient.mk ((Cayley.edge s 1 i).map (inclusion s a).continuous)) := by
+  have hh : sectionMap s a rel ha hs hker (s i)=
+      PathExtension.map (inclusion s a) (inclusion_smul s a) (Cayley.vertex s 1)
+        (Cayley.pathGenerator s i) := by
+    simpa only [FreeGroup.lift_apply_of,wordLift,MonoidHom.comp_apply,Cayley.wordLift]
+      using sectionMap_lift s a rel ha hs hker (FreeGroup.of i)
+  rw [hh]
+  exact (PathExtension.mapFun_equal (inclusion s a) (inclusion_smul s a)
+    (Cayley.vertex s 1) (Cayley.pathGenerator s i)).trans
+      ((Cayley.pathGenerator_equal s i).map (inclusion s a))
+def graphNullhomotopy : (inclusion s a).Homotopy
+    (.const _ (inclusion s a (Cayley.vertex s 1))) :=
+  Cayley.nullhomotopyOfSection s (inclusion s a) (inclusion_smul s a)
+    (sectionMap s a rel ha hs hker) (sectionMap_fst s a rel ha hs hker)
+    (sectionMap_generator s a rel ha hs hker)
+instance coverT2 : T2Space (Cover s a) :=
+  t2Space _ (realSeparated _ (realSeparated_of_tychonoff (Y:=G)))
+instance coverCW : CWComplex (Set.univ : Set (Cover s a)) :=
+  layerCW _ (Cayley.graph_dimension s)
+include hs in
+lemma cover_pathConnected : PathConnectedSpace (Cover s a) := by
+  have hgen : Subgroup.closure (Set.range s)=⊤ := by
+    rw [←FreeGroup.range_lift_eq_closure,MonoidHom.range_eq_top]
+    exact hs
+  let := Cayley.graph_pathConnected s hgen
+  let := SphereTopology.sphere_nonempty 1
+  exact Attachment.pathConnectedSpace _
+include ha hs hker in
+lemma cover_circleFill (b : C(Sphere 2,Cover s a)) : SphereTopology.Extends b := by
+  let := SphereTopology.sphere_nonempty 1
+  have hdim : dimH (Set.univ : Set (Sphere 2))<2 :=
+    (GeneralPosition.dimH_cube_boundary_subtype_le 1).trans_lt (by norm_num)
+  obtain ⟨g,H,_⟩ := exists_deformation_into_base _ b hdim
+  apply SphereTopology.extends_of_homotopy H
+  exact SphereTopology.extends_of_nullhomotopic
+    (((graphNullhomotopy s a rel ha hs hker).compContinuousMap g).symm)
+include ha hs hker in
+lemma cover_simplyConnected : SimplyConnectedSpace (Cover s a) := by
+  apply simply_connected_iff_loops_nullhomotopic.mpr
+  refine ⟨cover_pathConnected s a hs,?_⟩
+  intro x p
+  obtain ⟨F,hF⟩ := cover_circleFill s a rel ha hs hker (LoopSphere.map p)
+  apply LoopSphere.homotopic_of_fill p F
+  intro z
+  exact ContinuousMap.congr_fun hF z
+
+def diskAttaching : Q→C(Sphere 2,PresentationTopology.Rose s) := fun q=>
+  (PresentationTopology.graphProjection s).comp (a q)
+abbrev Base := Space (diskAttaching s a)
+def projection : C(Cover s a,Base s a) :=
+  coverMap a (PresentationTopology.graphProjection s)
+    (PresentationTopology.graphProjection_quotient s) (diskAttaching s a) (fun _ _=>rfl)
+lemma projection_quotient : IsQuotientCoveringMap (projection s a) G :=
+  coverMap_isQuotientCovering _ _ _ _ _
+instance baseT2 : T2Space (Base s a) := t2Space _ (realSeparated _ realSeparated_of_tychonoff)
+instance baseCW : CWComplex (Set.univ : Set (Base s a)) :=
+  layerCW _ (PresentationTopology.rose_dimension s)
+lemma base_dimension (m : ℕ) (i : RelCWComplex.cell (Set.univ : Set (Base s a)) m) : m < 3 :=
+  layerCW_dimensions _ (PresentationTopology.rose_dimension s) m i
+lemma base_no_higher (m : ℕ) (hm : 2 < m) : IsEmpty (RelCWComplex.cell (Set.univ : Set (Base s a)) m) :=
+  ⟨fun i=>by have := base_dimension s a m i; omega⟩
+lemma base_finite [Finite S] [Finite Q] : CWComplex.Finite (Set.univ : Set (Base s a)) where
+  eventually_isEmpty_cell := Filter.eventually_atTop.mpr ⟨3,fun m hm=>base_no_higher s a m (by omega)⟩
+  finite_cell m := layerCW_finite_cells _ (PresentationTopology.rose_finite s) (PresentationTopology.rose_dimension s) m
+lemma base_two_cell [Nonempty Q] : Nonempty (RelCWComplex.cell (Set.univ : Set (Base s a)) 2) :=
+  ⟨Sum.inr ⟨⟨⟨rfl⟩,Classical.choice inferInstance⟩⟩⟩
+instance basePathConnected : PathConnectedSpace (Base s a) := by
+  let := SphereTopology.sphere_nonempty 1
+  exact Attachment.pathConnectedSpace _
+def coverPoint : Cover s a := inclusion s a (Cayley.vertex s 1)
+def basePoint : Base s a := projection s a (coverPoint s a)
+def fundamentalEquiv : G ≃* FundamentalGroup (Base s a) (basePoint s a) := by
+  let := cover_simplyConnected s a rel ha hs hker
+  exact (MulEquiv.inv' G).trans
+    ((projection_quotient s a).fundamentalGroupEquiv ⟨coverPoint s a,rfl⟩).symm
+lemma cover_no_higher (m : ℕ) (hm : 2 < m) :
+    IsEmpty (RelCWComplex.cell (Set.univ : Set (Cover s a)) m) := by
+  refine ⟨fun i=>?_⟩
+  have := layerCW_dimensions (equivariantFamily (G:=G) a) (Cayley.graph_dimension s) m i
+  omega
+include ha hs hker in
+lemma contractible_cover
+    (hfill : ∀a : C(Sphere 3,Cover s a),SphereTopology.Extends a) :
+    ContractibleSpace (Cover s a) := by
+  let := cover_pathConnected s a hs
+  exact FiniteDimensionalCW.contractible_of_two_dimensional_fills (cover_no_higher s a)
+    (cover_circleFill s a rel ha hs hker) hfill
+end TorsionFreeZeroDivisors.CellPresentation
+namespace TorsionFreeZeroDivisors.ConeCells
+open Set Metric Topology GroupRingTopology GroupRingTopology.Attachment GroupRingTopology.PathExtension
+open scoped unitInterval Classical
+variable {G S V E : Type} [Group G] [TopologicalSpace G] [DiscreteTopology G]
+variable (s : S→G)
+def wordClass (w : FreeGroup S) : Path.Homotopic.Quotient (Cayley.vertex s 1) (Cayley.vertex s (FreeGroup.lift s w)) :=
+  (Cayley.wordLift s w).2.cast rfl (by rw [Cayley.wordLift_fst,Cayley.smul_vertex,_root_.mul_one])
+def wordPath (w : FreeGroup S) : Path (Cayley.vertex s 1) (Cayley.vertex s (FreeGroup.lift s w)) :=
+  (Path.Homotopic.Quotient.mk_surjective (wordClass s w)).choose
+lemma wordPath_equal (w : FreeGroup S) : Q.Equal (Path.Homotopic.Quotient.mk (wordPath s w)) (Cayley.wordLift s w).2 :=
+  (Q.Equal.ofEq (Path.Homotopic.Quotient.mk_surjective (wordClass s w)).choose_spec).trans (Q.cast_equal _ _ _)
+variable (src dst : E→V) (z : V→FreeGroup S) (lab : E→FreeGroup S)
+variable (he : ∀e,FreeGroup.lift s (z (src e))*FreeGroup.lift s (lab e)=FreeGroup.lift s (z (dst e)))
+def outerPath (e : E) : Path (Cayley.vertex s (FreeGroup.lift s (z (src e)))) (Cayley.vertex s (FreeGroup.lift s (z (dst e)))) :=
+  ((wordPath s (lab e)).map (smulMap (FreeGroup.lift s (z (src e)))).continuous).cast
+    (by simp [smulMap,Cayley.smul_vertex]) (by simpa only [smulMap,ContinuousMap.coe_mk,Cayley.smul_vertex] using congrArg (Cayley.vertex s) (he e).symm)
+lemma outerPath_equal (e : E) : Q.Equal (Path.Homotopic.Quotient.mk (outerPath s src dst z lab he e))
+    ((Cayley.wordLift s (lab e)).2.map (smulMap (Cayley.wordLift s (z (src e))).1)) := by
+  rw [Cayley.wordLift_fst]
+  exact (Q.cast_equal _ _ _).trans ((wordPath_equal s (lab e)).map _)
+local instance optionVertexTopology : TopologicalSpace (Option V) := ⊥
+local instance optionVertexDiscreteTopology : DiscreteTopology (Option V) := ⟨rfl⟩
+def vertexMap : C(Option V,Cayley.Graph s) :=
+  ⟨fun v=>Cayley.vertex s (match v with | none=>1 | some v=>FreeGroup.lift s (z v)),continuous_of_discreteTopology⟩
+def edgeMap : V⊕E→C(Disk 1,Cayley.Graph s)
+  | .inl v => (wordPath s (z v)).symm.toContinuousMap.comp ⟨Cayley.edgeTime,Cayley.continuous_edgeTime⟩
+  | .inr e => (outerPath s src dst z lab he e).toContinuousMap.comp ⟨Cayley.edgeTime,Cayley.continuous_edgeTime⟩
+lemma edgeMap_boundary (i : V⊕E) (x : Sphere 1) :
+    edgeMap s src dst z lab he i (boundary 1 x)=vertexMap s z (GraphConeCW.oneBoundary src dst i x) := by
+  cases i with
+  | inl v =>
+    rcases Cayley.sphere_one_eq x with rfl|rfl <;>
+      simp [edgeMap,Cayley.edgeTime_minus,Cayley.edgeTime_plus,GraphConeCW.endpoint,vertexMap]
+  | inr e =>
+    rcases Cayley.sphere_one_eq x with rfl|rfl <;>
+      simp [edgeMap,Cayley.edgeTime_minus,Cayley.edgeTime_plus,GraphConeCW.endpoint,vertexMap]
+def oneMap : C(GraphConeCW.One src dst,Cayley.Graph s) :=
+  GraphConeCW.mapOne src dst (vertexMap s z) (edgeMap s src dst z lab he) (edgeMap_boundary s src dst z lab he)
+def attaching (e : E) : C(Sphere 2,Cayley.Graph s) :=
+  (oneMap s src dst z lab he).comp (GraphConeCW.twoBoundary src dst e)
+abbrev Cover := CellPresentation.Cover s (attaching s src dst z lab he)
+def coneMap : C(GraphConeCW.Cone src dst,Cover s src dst z lab he) :=
+  lift _ ((CellPresentation.inclusion s (attaching s src dst z lab he)).comp (oneMap s src dst z lab he))
+    (fun e=>cell _ (show FreeIndex G E from ((1:G),e))) (by
+      intro e x
+      rw [cell_boundary]
+      simp only [equivariantFamily,ContinuousMap.coe_mk,one_smul]
+      rfl)
+@[simp] lemma coneMap_one (x : GraphConeCW.One src dst) :
+    coneMap s src dst z lab he (GraphConeCW.inclusion src dst x)=
+      CellPresentation.inclusion s (attaching s src dst z lab he) (oneMap s src dst z lab he x) := rfl
+@[simp] lemma coneMap_square (e : E) (d : Disk 2) :
+    coneMap s src dst z lab he (GraphConeCW.square src dst e d)=cell _ (show FreeIndex G E from ((1:G),e)) d := lift_cell _ _ _ _ e d
+lemma path_equal_of_pointwise {Y : Type*} [TopologicalSpace Y] {a b c d : Y}
+    (p : Path a b) (q : Path c d) (h : ∀t,p t=q t) :
+    Q.Equal (Path.Homotopic.Quotient.mk p) (Path.Homotopic.Quotient.mk q) :=
+  ⟨by simpa using h 0,by simpa using h 1,Path.Homotopic.hpath_hext h⟩
+def coneRadial (v : V) : Path
+    (GraphConeCW.inclusion src dst (GraphConeCW.vertex src dst (some v))) (GraphConeCW.apex src dst) where
+  toFun t := GraphConeCW.inclusion src dst (GraphConeCW.radial src dst v t)
+  continuous_toFun := (GraphConeCW.inclusion src dst).continuous.comp (GraphConeCW.radial src dst v).continuous
+  source' := by rw [GraphConeCW.radial_zero]
+  target' := by rw [GraphConeCW.radial_one]; rfl
+@[simp] lemma coneRadial_apply (v : V) (t : I) : coneRadial src dst v t =
+    GraphConeCW.inclusion src dst (GraphConeCW.radial src dst v t) := rfl
+def coneOuter (e : E) : Path
+    (GraphConeCW.inclusion src dst (GraphConeCW.vertex src dst (some (src e))))
+    (GraphConeCW.inclusion src dst (GraphConeCW.vertex src dst (some (dst e)))) where
+  toFun t := GraphConeCW.inclusion src dst (GraphConeCW.outer src dst e (Cayley.edgeParam t))
+  continuous_toFun := (GraphConeCW.inclusion src dst).continuous.comp
+    ((GraphConeCW.outer src dst e).continuous.comp Cayley.continuous_edgeParam)
+  source' := by rw [Cayley.edgeParam_zero,GraphConeCW.outer_minus]
+  target' := by rw [Cayley.edgeParam_one,GraphConeCW.outer_plus]
+lemma map_radial (v : V) (t : I) :
+    coneMap s src dst z lab he ((coneRadial src dst v).symm t)=
+      CellPresentation.inclusion s (attaching s src dst z lab he) (wordPath s (z v) t) := by
+  simp only [Path.symm_apply,Function.comp_apply,coneRadial_apply]
+  rw [coneMap_one]
+  change CellPresentation.inclusion s _ (GraphConeCW.mapOne _ _ _ _ _
+    (cell (GraphConeCW.oneBoundary src dst) (.inl v) (Cayley.edgeParam (unitInterval.symm t))))=_
+  rw [GraphConeCW.mapOne_edge]
+  change CellPresentation.inclusion s _ ((wordPath s (z v)).symm (Cayley.edgeTime (Cayley.edgeParam (unitInterval.symm t))))=_
+  rw [Cayley.edgeTime_param]
+  simp only [Path.symm_apply,Function.comp_apply,unitInterval.symm_symm]
+lemma map_outer (e : E) (t : I) :
+    coneMap s src dst z lab he (coneOuter src dst e t)=
+      CellPresentation.inclusion s (attaching s src dst z lab he) (outerPath s src dst z lab he e t) := by
+  change coneMap s src dst z lab he (GraphConeCW.inclusion src dst
+    (cell (GraphConeCW.oneBoundary src dst) (.inr e) (Cayley.edgeParam t)))=_
+  rw [coneMap_one]
+  change CellPresentation.inclusion s _ (GraphConeCW.mapOne _ _ _ _ _ (cell _ _ _))=_
+  rw [GraphConeCW.mapOne_edge]
+  change CellPresentation.inclusion s _ (outerPath s src dst z lab he e (Cayley.edgeTime (Cayley.edgeParam t)))=_
+  rw [Cayley.edgeTime_param]
+lemma route_equal (e : E) : Q.Equal
+    (Path.Homotopic.Quotient.mk ((wordPath s (z (src e))).trans (outerPath s src dst z lab he e)))
+    (Cayley.wordLift s (z (src e)*lab e)).2 := by
+  rw [map_mul]
+  exact (Q.Equal.comp (wordPath_equal s _) (outerPath_equal s src dst z lab he e)).trans (mul_path_equal _ _).symm
+lemma wordLift_edge (e : E) :
+    CellPresentation.wordLift s (attaching s src dst z lab he) (z (src e)*lab e)=
+      CellPresentation.wordLift s (attaching s src dst z lab he) (z (dst e)) := by
+  let f := coneMap s src dst z lab he
+  let inc := CellPresentation.inclusion s (attaching s src dst z lab he)
+  let p := ((coneRadial src dst (src e)).symm).trans (coneOuter src dst e)
+  let q := (coneRadial src dst (dst e)).symm
+  have hpq : p.Homotopic q := SimplyConnectedSpace.paths_homotopic p q
+  have hleft : Q.Equal (Path.Homotopic.Quotient.mk (p.map f.continuous))
+      ((Cayley.wordLift s (z (src e)*lab e)).2.map inc) := by
+    apply Q.Equal.trans ?_ ((route_equal s src dst z lab he e).map inc)
+    change Q.Equal (Path.Homotopic.Quotient.mk (((coneRadial src dst (src e)).symm.trans (coneOuter src dst e)).map f.continuous)) _
+    rw [Path.map_trans]
+    have h1 := path_equal_of_pointwise
+      (((coneRadial src dst (src e)).symm).map f.continuous)
+      ((wordPath s (z (src e))).map inc.continuous) (map_radial s src dst z lab he (src e))
+    have h2 := path_equal_of_pointwise ((coneOuter src dst e).map f.continuous)
+      ((outerPath s src dst z lab he e).map inc.continuous) (map_outer s src dst z lab he e)
+    exact (Q.Equal.comp h1 h2).trans (Q.Equal.ofEq (Q.map_trans
+      (Path.Homotopic.Quotient.mk (wordPath s (z (src e))))
+      (Path.Homotopic.Quotient.mk (outerPath s src dst z lab he e)) inc).symm)
+  have hright : Q.Equal (Path.Homotopic.Quotient.mk (q.map f.continuous))
+      ((Cayley.wordLift s (z (dst e))).2.map inc) :=
+    (path_equal_of_pointwise _ _ (map_radial s src dst z lab he (dst e))).trans ((wordPath_equal s _).map inc)
+  apply PathExtension.ext
+  · change (Cayley.wordLift s (z (src e)*lab e)).1=(Cayley.wordLift s (z (dst e))).1
+    rw [Cayley.wordLift_fst,Cayley.wordLift_fst,map_mul,he]
+  · apply Q.Equal.path
+    exact (PathExtension.mapFun_equal inc (CellPresentation.inclusion_smul s _) (Cayley.vertex s 1) _).trans
+      (hleft.symm.trans ((Q.Equal.ofEq (Path.Homotopic.Quotient.eq.mpr (hpq.map f))).trans
+      (hright.trans (PathExtension.mapFun_equal inc (CellPresentation.inclusion_smul s _) (Cayley.vertex s 1) _).symm)))
+lemma wordLift_triangle (e : E) :
+    CellPresentation.wordLift s (attaching s src dst z lab he) (z (src e)*lab e*(z (dst e))⁻¹)=1 := by
+  rw [map_mul,map_inv,wordLift_edge,mul_inv_cancel]
+end TorsionFreeZeroDivisors.ConeCells
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/GroupRing/GraphConePresentation.lean b/lean/OAI/Algebra/GroupRing/GraphConePresentation.lean
new file mode 100644
index 0000000000000000000000000000000000000000..57e0d1e2131e0059111a7ec7ce747a926c80ba54
--- /dev/null
+++ b/lean/OAI/Algebra/GroupRing/GraphConePresentation.lean
@@ -0,0 +1,176 @@
+import Mathlib
+import OAI.Algebra.GroupRing.Path
+
+namespace OAI
+
+
+
+section
+namespace TorsionFreeZeroDivisors.GraphConePresentation
+open PortSubdivision GraphPresentation
+open scoped Classical
+noncomputable section
+variable {V D S : Type} (Γ : PortGraph V D)
+/-- Physical unoriented edges, retaining loops and parallel edges. -/
+def edgeSetoid : Setoid D where
+  r d e := d=e ∨ d=Γ.reverse e
+  iseqv := ⟨fun _=>Or.inl rfl, by
+    intro d e h
+    rcases h with rfl|h
+    · exact Or.inl rfl
+    · exact Or.inr (by rw [h,Γ.reverse_reverse_apply]), by
+    intro d e f h k
+    rcases h with rfl|h
+    · exact k
+    · rcases k with rfl|k
+      · exact Or.inr h
+      · exact Or.inl (by rw [h,k,Γ.reverse_reverse_apply])⟩
+abbrev Edge := Quotient (edgeSetoid Γ)
+def edge (d : D) : Edge Γ := Quotient.mk _ d
+def representative (e : Edge Γ) : D := e.out
+lemma representative_cases (d : D) :
+    d=representative Γ (edge Γ d) ∨ d=Γ.reverse (representative Γ (edge Γ d)) :=
+  Quotient.exact (Quotient.out_eq (edge Γ d)).symm
+
+variable (letters : D→FreeGroup S) (R : Routes Γ)
+/-- Radial edges except for the one edge collapsed at the root of each component. -/
+abbrev Generator := S ⊕ {v : V // v≠R.base v}
+def old : FreeGroup S →* FreeGroup (Generator (S:=S) Γ R) := FreeGroup.map Sum.inl
+def radial (v : V) : FreeGroup (Generator (S:=S) Γ R) :=
+  if h : v=R.base v then 1 else FreeGroup.of (Sum.inr ⟨v,h⟩)
+def triangle (d : D) : FreeGroup (Generator (S:=S) Γ R) :=
+  radial Γ R (Γ.origin d)*old Γ R (letters d)*(radial Γ R (Γ.origin (Γ.reverse d)))⁻¹
+/-- There is one two-cell per physical edge, NOT one per directed dart. -/
+def attachment (e : Edge Γ) : FreeGroup (Generator (S:=S) Γ R) := triangle Γ letters R (representative Γ e)
+def relations : Set (FreeGroup (Generator (S:=S) Γ R)) := Set.range (attachment Γ letters R)
+abbrev Group := PresentedGroup (relations Γ letters R)
+def radialValue (v : V) : Group Γ letters R := PresentedGroup.mk _ (radial Γ R v)
+def oldMap : FreeGroup S →* Group Γ letters R := (PresentedGroup.mk _).comp (old Γ R)
+lemma triangle_reverse (hl : ∀ d,letters (Γ.reverse d)=(letters d)⁻¹) (d : D) :
+    triangle Γ letters R (Γ.reverse d)=(triangle Γ letters R d)⁻¹ := by
+  simp only [triangle,Γ.reverse_reverse_apply,hl,map_inv,mul_inv_rev,inv_inv]
+  group
+lemma triangle_trivial (hl : ∀ d,letters (Γ.reverse d)=(letters d)⁻¹) (d : D) :
+    PresentedGroup.mk (relations Γ letters R) (triangle Γ letters R d)=1 := by
+  have h := PresentedGroup.one_of_mem (show attachment Γ letters R (edge Γ d)∈relations Γ letters R from ⟨_,rfl⟩)
+  change PresentedGroup.mk _ (triangle Γ letters R (representative Γ (edge Γ d)))=1 at h
+  rcases representative_cases Γ d with hd|hd
+  · rw [hd]; exact h
+  · rw [hd,triangle_reverse Γ letters R hl,map_inv,h,inv_one]
+lemma edge_value (hl : ∀ d,letters (Γ.reverse d)=(letters d)⁻¹) (d : D) :
+    radialValue Γ letters R (Γ.origin (Γ.reverse d))=
+      radialValue Γ letters R (Γ.origin d)*oldMap Γ letters R (letters d) := by
+  have h := triangle_trivial Γ letters R hl d
+  simp only [triangle,map_mul,map_inv] at h
+  exact (mul_inv_eq_one.mp h).symm
+lemma path_value (hl : ∀ d,letters (Γ.reverse d)=(letters d)⁻¹)
+    {a b : V} (p : Path Γ a b) :
+    p.eval (fun d=>oldMap Γ letters R (letters d))=
+      (radialValue Γ letters R a)⁻¹*radialValue Γ letters R b := by
+  induction p with
+  | nil v => simp
+  | cons d p ih =>
+    rw [Path.eval_cons,ih,edge_value Γ letters R hl]
+    group
+lemma radial_base (hbase : ∀v,R.base (R.base v)=R.base v) (v : V) :
+    radial (S:=S) Γ R (R.base v)=1 := by simp [radial,hbase]
+lemma old_word (hl : ∀ d,letters (Γ.reverse d)=(letters d)⁻¹)
+    (hbase : ∀v,R.base (R.base v)=R.base v) (v : V) :
+    oldMap Γ letters R (word Γ letters R v)=radialValue Γ letters R v := by
+  rw [word,←Path.eval_map,path_value Γ letters R hl]
+  simp [radialValue,radial_base Γ R hbase]
+
+/-- The original graph-loop group maps to the nonredundant cone group. -/
+def fromGraph (hl : ∀ d,letters (Γ.reverse d)=(letters d)⁻¹)
+    (hbase : ∀v,R.base (R.base v)=R.base v) :
+    GraphPresentation.Group Γ letters R →* Group Γ letters R :=
+  PresentedGroup.toGroup (f:=fun s=>oldMap Γ letters R (FreeGroup.of s)) (by
+    have hf : FreeGroup.lift (fun s=>oldMap Γ letters R (FreeGroup.of s))=oldMap Γ letters R := by
+      ext s; simp
+    rintro w ⟨d,rfl⟩
+    rw [hf,relator,map_mul,map_mul,map_inv,old_word Γ letters R hl hbase,
+      old_word Γ letters R hl hbase,←edge_value Γ letters R hl]
+    simp)
+
+lemma graph_value_base (hbase : ∀v,R.base (R.base v)=R.base v) (v : V) :
+    value Γ letters R (R.base v)=1 := by
+  have h := closed_value Γ letters R (R.base v)
+    ((R.path (R.base v)).cast (hbase v) rfl)
+  rw [Path.eval_cast] at h
+  change (R.path (R.base v)).eval (fun d=>PresentedGroup.mk _ (letters d))=1 at h
+  rw [Path.eval_map] at h
+  exact h
+
+def toGraphGenerator : Generator (S:=S) Γ R → GraphPresentation.Group Γ letters R
+  | .inl s => PresentedGroup.of s
+  | .inr v => value Γ letters R v
+lemma lift_old : (FreeGroup.lift (toGraphGenerator Γ letters R)).comp (old Γ R)=
+    PresentedGroup.mk (GraphPresentation.relations Γ letters R) := by
+  ext s
+  simp [old,toGraphGenerator,PresentedGroup.of]
+lemma lift_radial (hbase : ∀v,R.base (R.base v)=R.base v) (v : V) :
+    FreeGroup.lift (toGraphGenerator Γ letters R) (radial Γ R v)=value Γ letters R v := by
+  by_cases h : v=R.base v
+  · simp only [radial,dite_eq_left h,map_one]
+    rw [h,graph_value_base Γ letters R hbase]
+  · simp [radial,h,toGraphGenerator]
+/-- The precise reverse Tietze map, keeping each new radial generator's value. -/
+def toGraph (hbase : ∀v,R.base (R.base v)=R.base v) :
+    Group Γ letters R →* GraphPresentation.Group Γ letters R :=
+  PresentedGroup.toGroup (f:=toGraphGenerator Γ letters R) (by
+    rintro _ ⟨e,rfl⟩
+    simp only [attachment,triangle,map_mul,map_inv,lift_radial Γ letters R hbase]
+    rw [←MonoidHom.comp_apply,lift_old]
+    change value Γ letters R _*letter Γ letters R _*(value Γ letters R _)⁻¹=1
+    rw [←GraphPresentation.edge]
+    simp)
+lemma fromGraph_mk (hl : ∀ d,letters (Γ.reverse d)=(letters d)⁻¹)
+    (hbase : ∀v,R.base (R.base v)=R.base v) (w : FreeGroup S) :
+    fromGraph Γ letters R hl hbase (PresentedGroup.mk _ w)=oldMap Γ letters R w := by
+  have h : (fromGraph Γ letters R hl hbase).comp (PresentedGroup.mk _)=oldMap Γ letters R := by
+    ext s
+    change fromGraph Γ letters R hl hbase (PresentedGroup.of s)=_
+    simp [fromGraph]
+  exact DFunLike.congr_fun h w
+lemma fromGraph_value (hl : ∀ d,letters (Γ.reverse d)=(letters d)⁻¹)
+    (hbase : ∀v,R.base (R.base v)=R.base v) (v : V) :
+    fromGraph Γ letters R hl hbase (value Γ letters R v)=radialValue Γ letters R v := by
+  rw [value,fromGraph_mk,old_word Γ letters R hl hbase]
+
+def equivalence (hl : ∀ d,letters (Γ.reverse d)=(letters d)⁻¹)
+    (hbase : ∀v,R.base (R.base v)=R.base v) :
+    GraphPresentation.Group Γ letters R ≃* Group Γ letters R :=
+  MonoidHom.toMulEquiv (fromGraph Γ letters R hl hbase) (toGraph Γ letters R hbase) (by
+    apply PresentedGroup.ext
+    intro s
+    change toGraph Γ letters R hbase (oldMap Γ letters R (FreeGroup.of s))=PresentedGroup.of s
+    change toGraph Γ letters R hbase (PresentedGroup.of (Sum.inl s))=_
+    simp [toGraph,toGraphGenerator]) (by
+    apply PresentedGroup.ext
+    intro s
+    cases s with
+    | inl s =>
+      simp only [MonoidHom.comp_apply,MonoidHom.id_apply,toGraph,PresentedGroup.toGroup.of,toGraphGenerator]
+      change fromGraph Γ letters R hl hbase (PresentedGroup.of s)=PresentedGroup.of (Sum.inl s)
+      rw [PresentedGroup.of,fromGraph_mk]
+      rfl
+    | inr v =>
+      simp only [MonoidHom.comp_apply,MonoidHom.id_apply,toGraph,PresentedGroup.toGroup.of,toGraphGenerator]
+      change fromGraph Γ letters R hl hbase (value Γ letters R v)=PresentedGroup.of (Sum.inr v)
+      rw [fromGraph_value]
+      simp [radialValue,radial,v.property,PresentedGroup.of])
+
+lemma canonical_base (v : V) : (routes Γ).base ((routes Γ).base v)=(routes Γ).base v := by
+  exact congrArg (fun q : Quot (ShortClosure.simpleGraph Γ).Reachable=>q.out)
+    ((ShortClosure.simpleGraph Γ).connectedComponentMk v).out_eq
+
+instance [Finite S] [Finite V] [Finite D] : _root_.Group.IsFinitelyPresented (Group Γ letters R) := by
+  have : Finite (relations Γ letters R) := Set.finite_range (attachment Γ letters R) |>.to_subtype
+  infer_instance
+end
+end TorsionFreeZeroDivisors.GraphConePresentation
+
+end
+
+
+end OAI
diff --git a/lean/OAI/Algebra/GroupRing/GraphLabels.lean b/lean/OAI/Algebra/GroupRing/GraphLabels.lean
new file mode 100644
index 0000000000000000000000000000000000000000..973077c5f7fa67f4044c8d66401048818d3c87a9
--- /dev/null
+++ b/lean/OAI/Algebra/GroupRing/GraphLabels.lean
@@ -0,0 +1,95 @@
+import Mathlib
+import OAI.Algebra.GroupRing.CayleyFurther
+import OAI.Algebra.GroupRing.WordResponse
+
+namespace OAI
+
+
+
+section
+namespace TorsionFreeZeroDivisors.GraphLabels
+open GroupRingTopology GroupRingTopology.Attachment GroupRingTopology.PathExtension
+open scoped unitInterval
+noncomputable section
+variable {G S Y : Type} [Group G] [TopologicalSpace G] [DiscreteTopology G]
+  [TopologicalSpace Y] (s : S→G) (y : Y) (k : G×S→FundamentalGroup Y y)
+def representative (e : G×S) : Path y y :=
+  (Path.Homotopic.Quotient.mk_surjective (k e)).choose
+omit [Group G] [TopologicalSpace G] [DiscreteTopology G] in
+lemma representative_class (e : G×S) : Path.Homotopic.Quotient.mk (representative y k e)=k e :=
+  (Path.Homotopic.Quotient.mk_surjective (k e)).choose_spec
+def edgeMap (e : G×S) : C(Disk 1,Y) :=
+  (representative y k e).toContinuousMap.comp ⟨Cayley.edgeTime,Cayley.continuous_edgeTime⟩
+omit [Group G] [TopologicalSpace G] [DiscreteTopology G] in
+lemma edgeMap_boundary (e : G×S) (z : Sphere 1) : edgeMap y k e (boundary 1 z)=y := by
+  obtain rfl|rfl:=Cayley.sphere_one_eq z
+  · change representative y k e (Cayley.edgeTime (boundary 1 Cayley.minus))=y
+    rw [Cayley.edgeTime_minus,Path.source]
+  · change representative y k e (Cayley.edgeTime (boundary 1 Cayley.plus))=y
+    rw [Cayley.edgeTime_plus,Path.target]
+def map : C(Cayley.Graph s,Y) :=
+  lift (equivariantFamily (G:=G) (Cayley.attaching s)) (.const _ y) (edgeMap y k)
+    (fun e z=>edgeMap_boundary y k e z)
+lemma map_vertex (g : G) : map s y k (Cayley.vertex s g)=y := rfl
+lemma map_edge (g : G) (a : S) (t : unitInterval) :
+    map s y k (Cayley.edge s g a t)=representative y k (g,a) t := by
+  change map s y k (cell _ (g,a) (Cayley.edgeParam t))=_
+  unfold map
+  erw [lift_cell]
+  change representative y k (g,a) (Cayley.edgeTime (Cayley.edgeParam t))=_
+  rw [Cayley.edgeTime_param]
+
+lemma edge_translate (g : G) (a : S) : Q.Equal
+    ((Path.Homotopic.Quotient.mk (Cayley.edge s 1 a)).map (smulMap g))
+    (Path.Homotopic.Quotient.mk (Cayley.edge s g a)) := by
+  refine ⟨?_,?_,Path.Homotopic.hpath_hext ?_⟩
+  · change g • Cayley.vertex s 1=Cayley.vertex s g
+    rw [Cayley.smul_vertex,_root_.mul_one]
+  · change g • Cayley.vertex s (1*s a)=Cayley.vertex s (g*s a)
+    rw [Cayley.smul_vertex,_root_.one_mul]
+  · intro t
+    change g • cell (equivariantFamily (G:=G) (Cayley.attaching s)) ((1:G),a) (Cayley.edgeParam t)=cell (equivariantFamily (G:=G) (Cayley.attaching s)) (g,a) (Cayley.edgeParam t)
+    erw [smul_cell _ (equivariantFamily_smul (Cayley.attaching s))]
+    change cell (equivariantFamily (G:=G) (Cayley.attaching s)) (g*1,a) (Cayley.edgeParam t)=_
+    rw [_root_.mul_one]
+lemma response_generator (g : G) (a : S) :
+    WordResponse.response s (map s y k) y (map_vertex s y k) g (FreeGroup.of a)=Additive.ofMul (k (g,a)) := by
+  have hh : Q.Equal (((Cayley.wordLift s (FreeGroup.of a)).2).map (smulMap g))
+      (Path.Homotopic.Quotient.mk (Cayley.edge s g a)) :=
+    by
+      rw [show Cayley.wordLift s (FreeGroup.of a)=Cayley.pathGenerator s a from FreeGroup.lift_apply_of]
+      exact ((Cayley.pathGenerator_equal s a).map (smulMap g)).trans (edge_translate s g a)
+  change WordResponse.basedClass (((Cayley.wordLift s (FreeGroup.of a)).2).map (smulMap g)) (map s y k) y
+    (WordResponse.source_eq s (map s y k) y (map_vertex s y k) g)
+    (WordResponse.target_eq s (map s y k) y (map_vertex s y k) g (FreeGroup.of a))=k (g,a)
+  erw [WordResponse.basedClass_equal hh (map s y k) y _ _ (map_vertex s y k g) (map_vertex s y k (g*s a))]
+  change Path.Homotopic.Quotient.mk (((Cayley.edge s g a).map (map s y k).continuous).cast _ _)=k (g,a)
+  rw [show (((Cayley.edge s g a).map (map s y k).continuous).cast (map_vertex s y k g).symm
+    (map_vertex s y k (g*s a)).symm)=representative y k (g,a) from by
+      ext t;exact map_edge s y k g a t]
+  exact representative_class y k (g,a)
+variable [IsMulCommutative (FundamentalGroup Y y)]
+local instance : CommGroup (FundamentalGroup Y y) :=
+  { (inferInstance : Group (FundamentalGroup Y y)) with mul_comm:=isMulCommutative_iff.mp inferInstance }
+lemma realizes (c : CellModule.Module G S→+Additive (FundamentalGroup Y y)) (g : G) (w : FreeGroup S) :
+    WordResponse.response s (map s y (fun e=>(c (Finsupp.single e 1)).toMul)) y
+      (map_vertex s y _) g w=c (CellModule.translate g (CellModule.fox (FreeGroup.lift s) w)) := by
+  rw [←WordResponse.edges_fox]
+  have he : WordResponse.edges s (map s y (fun e=>(c (Finsupp.single e 1)).toMul)) y
+      (map_vertex s y _)=c := by
+    apply Finsupp.addHom_ext
+    intro e z
+    simp only [WordResponse.edges,Finsupp.liftAddHom_apply_single,zmultiplesHom_apply,response_generator]
+    change z • c (Finsupp.single e 1)=c (Finsupp.single e z)
+    rw [←map_zsmul]
+    congr 1
+    simp
+  rw [he]
+end
+end TorsionFreeZeroDivisors.GraphLabels
+
+end
+
+
+
+end OAI
diff --git a/lean/OAI/Algebra/GroupRing/GraphQuotient.lean b/lean/OAI/Algebra/GroupRing/GraphQuotient.lean
new file mode 100644
index 0000000000000000000000000000000000000000..484aee5a8fa5de4763675711a1319f735a03a414
--- /dev/null
+++ b/lean/OAI/Algebra/GroupRing/GraphQuotient.lean
@@ -0,0 +1,457 @@
+import Mathlib
+import OAI.Algebra.GroupRing.MapRestrict
+
+namespace OAI
+
+noncomputable section
+
+namespace TorsionFreeZeroDivisors.GraphQuotient
+open SimpleGraph
+variable {V W : Type} (G : SimpleGraph V) (H : SimpleGraph W) (q : V→W)
+    (hq : ∀ v w,G.Adj v w→q v=q w ∨ H.Adj (q v) (q w))
+include hq in
+lemma reachable {v w : V} (h : G.Reachable v w) : H.Reachable (q v) (q w) := by
+  obtain ⟨p⟩ := h
+  induction p with
+  | nil => exact Reachable.rfl
+  | @cons v u w h p ih =>
+    rcases hq v u h with h|h
+    · exact h ▸ ih
+    · exact h.reachable.trans ih
+
+include hq in
+lemma connected (hs : Function.Surjective q) (hc : G.Connected) : H.Connected := by
+  have : Nonempty W := hc.nonempty.map q
+  refine ⟨fun v w=>?_⟩
+  obtain ⟨v,rfl⟩ := hs v
+  obtain ⟨w,rfl⟩ := hs w
+  exact reachable G H q hq (hc v w)
+
+include hq in
+lemma distance_sub (hc : G.Connected) (hcH : H.Connected) (root : V) (N : ℕ)
+    (hb : ∀ v,G.dist v root≤N→q v=q root) (v : V) :
+    H.dist (q v) (q root)≤G.dist v root-N := by
+  generalize hn : G.dist v root=n
+  induction n using Nat.strong_induction_on generalizing v with
+  | h n ih =>
+    by_cases hv : G.dist v root≤N
+    · rw [hb v hv,dist_self]
+      exact Nat.zero_le _
+    · have hv' : v≠root := by rintro rfl;simp only [dist_self] at hv;omega
+      obtain ⟨u,hu,hd⟩ := BFSTree.exists_parent G hc root v hv'
+      have hi := ih (G.dist u root) (by omega) u rfl
+      rcases hq v u hu with he|he
+      · rw [he]
+        omega
+      · have hh := hcH.dist_triangle (u:=q v) (v:=q u) (w:=q root)
+        rw [H.dist_eq_one_iff_adj.mpr he] at hh
+        omega
+end TorsionFreeZeroDivisors.GraphQuotient
+
+namespace TorsionFreeZeroDivisors.PlanarMap
+
+section
+open scoped Classical
+open PermutationCycles MapEuler
+variable {V : Type} (G : SimpleGraph V)
+/-- A concrete finite rotation map, with its exact Euler equality and an
+isomorphism to the represented simple graph. Loops and parallel darts are
+allowed; no abstract planar-minor or separator hypotheses are used. -/
+structure Model where
+  Dart : Type
+  [finiteDart : Fintype Dart]
+  rotation : Equiv.Perm Dart
+  pairing : Equiv.Perm Dart
+  involutive : Function.Involutive pairing
+  genus : GenusZero rotation pairing
+  iso : graph rotation pairing involutive ≃g G
+attribute [instance] Model.finiteDart
+variable {G}
+
+def Model.induced (M : Model G) (S : Set V) : Model (G.induce S) where
+  Dart := {x : M.Dart // M.iso (cycle M.rotation x)∈S}
+  rotation := MapRestrict.rotation M.rotation {v | M.iso v∈S}
+  pairing := MapRestrict.pairing M.rotation M.pairing M.involutive {v | M.iso v∈S}
+  involutive := MapRestrict.pairing_involutive M.rotation M.pairing M.involutive {v | M.iso v∈S}
+  genus := MapRestrict.induced_genusZero M.rotation M.pairing M.involutive {v | M.iso v∈S} M.genus
+  iso := (MapRestrict.graphIso M.rotation M.pairing M.involutive {v | M.iso v∈S}).trans
+    (M.iso.induce ⟨fun _ h=>h,M.iso.injective.injOn,fun v hv=>by
+      refine ⟨M.iso.symm v,?_,M.iso.apply_symm_apply v⟩
+      change M.iso (M.iso.symm v)∈S
+      simpa only [M.iso.apply_symm_apply] using hv⟩)
+
+/-- Sharp radius separation transported along the actual graph isomorphism. -/
+theorem Model.radius_separator (M : Model G) (hc : G.Connected) (root : V) (r : ℕ)
+    (hr : ∀ v,G.dist root v≤r) (active : Finset V) :
+    ∃ cut side : Finset V,root∈cut ∧ cut.card≤2*r+1 ∧ (cut.erase root).card≤2*r ∧
+      3*(active.filter (fun v=>v∉cut ∧ v∈side)).card≤2*active.card ∧
+      3*(active.filter (fun v=>v∉cut ∧ v∉side)).card≤2*active.card ∧
+      ∀ v w,v∉cut→w∉cut→G.Adj v w→(v∈side↔w∈side) := by
+  let e := M.iso.toEquiv
+  let A := active.map e.symm.toEmbedding
+  obtain ⟨C,D,hrC,hC,hCe,h₁,h₂,hsep⟩ := MapEuler.radius_separator M.rotation M.pairing
+    M.involutive M.genus (M.iso.connected_iff.mpr hc) (e.symm root) r (by
+      intro v
+      obtain ⟨p,hp⟩ := hc.exists_walk_length_eq_dist root (e v)
+      have hh := (graph M.rotation M.pairing M.involutive).dist_le (p.map M.iso.symm.toHom)
+      change (graph M.rotation M.pairing M.involutive).dist (e.symm root) (e.symm (e v))≤(p.map M.iso.symm.toHom).length at hh
+      rw [e.symm_apply_apply,SimpleGraph.Walk.length_map,hp] at hh
+      exact hh.trans (hr (e v))) A
+  let cut := C.map e.toEmbedding
+  let side := D.map e.toEmbedding
+  have hcut (v : V) : v∈cut↔e.symm v∈C := by simp only [cut,Finset.mem_map_equiv]
+  have hside (v : V) : v∈side↔e.symm v∈D := by simp only [side,Finset.mem_map_equiv]
+  have hroot : root∈cut := (hcut root).mpr hrC
+  have hcard : cut.card=C.card := Finset.card_map _
+  have hfilter (p : Cycle M.rotation→Prop) [DecidablePred p] :
+      (active.filter (fun v=>p (e.symm v))).card=(A.filter p).card := by
+    rw [←Finset.card_map (f:=e.symm.toEmbedding)]
+    congr 1
+    ext v
+    simp only [Finset.mem_map,Finset.mem_filter]
+    constructor
+    · rintro ⟨x,⟨hx,hp⟩,rfl⟩
+      exact ⟨Finset.mem_map.mpr ⟨x,hx,rfl⟩,hp⟩
+    · rintro ⟨hv,hp⟩
+      obtain ⟨x,hx,rfl⟩ := Finset.mem_map.mp hv
+      exact ⟨x,⟨hx,hp⟩,rfl⟩
+  refine ⟨cut,side,hroot,by omega,?_,?_,?_,?_⟩
+  · rw [Finset.card_erase_of_mem hroot,hcard,←Finset.card_erase_of_mem hrC]
+    exact hCe
+  · have he : active.filter (fun v=>v∉cut ∧ v∈side)=active.filter (fun v=>e.symm v∉C ∧ e.symm v∈D) := by
+      ext v;simp only [Finset.mem_filter,hcut,hside]
+    rw [he,hfilter (fun v=>v∉C ∧ v∈D)]
+    simpa only [A,Finset.card_map] using h₁
+  · have he : active.filter (fun v=>v∉cut ∧ v∉side)=active.filter (fun v=>e.symm v∉C ∧ e.symm v∉D) := by
+      ext v;simp only [Finset.mem_filter,hcut,hside]
+    rw [he,hfilter (fun v=>v∉C ∧ v∉D)]
+    simpa only [A,Finset.card_map] using h₂
+  · intro v w hv hw he
+    rw [hside,hside]
+    exact hsep (e.symm v) (e.symm w) (fun h=>hv ((hcut v).mpr h))
+      (fun h=>hw ((hcut w).mpr h)) (M.iso.symm.toHom.map_adj he)
+
+end
+
+open scoped Classical
+open PermutationCycles MapEuler
+variable {V : Type} (G : SimpleGraph V) (B : Set V)
+structure Contraction where
+  Vertex : Type
+  [finiteVertex : Fintype Vertex]
+  graph : SimpleGraph Vertex
+  model : Model graph
+  quotient : V→Vertex
+  surjective : Function.Surjective quotient
+  eq_iff : ∀ v w,quotient v=quotient w↔v=w ∨ (v∈B ∧ w∈B)
+  adj : ∀ v w,G.Adj v w→quotient v=quotient w ∨ graph.Adj (quotient v) (quotient w)
+  lift_adj : ∀ v w,graph.Adj v w→∃ x y,G.Adj x y ∧ quotient x=v ∧ quotient y=w
+attribute [instance] Contraction.finiteVertex
+variable {G B}
+
+/-- A connected induced set is contracted by choosing its literal spanning
+submatching and replacing the rotations by the contour permutation. -/
+def Model.contract (M : Model G) (hB : (G.induce B).Connected) : Contraction G B := by
+  let S : Set (Cycle M.rotation) := {v | M.iso v∈B}
+  let s := MapRestrict.rotation M.rotation S
+  let a := MapRestrict.pairing M.rotation M.pairing M.involutive S
+  let hi := MapRestrict.pairing_involutive M.rotation M.pairing M.involutive S
+  have hc : (graph s a hi).Connected := ((M.induced B).iso.connected_iff).mpr hB
+  let T := hc.exists_isTree_le.choose
+  have hT : T≤graph s a hi := hc.exists_isTree_le.choose_spec.1
+  have ht : T.IsTree := hc.exists_isTree_le.choose_spec.2
+  let ρ := MapContract.rotation M.rotation M.pairing M.involutive S T hT
+  let γ := MapContract.pairing M.rotation M.pairing M.involutive S T hT
+  let hγ := MapContract.pairing_involutive M.rotation M.pairing M.involutive S T hT
+  let q := MapContract.quotient M.rotation M.pairing M.involutive S T hT M.genus ht
+  refine { Vertex := Cycle ρ
+           graph := graph ρ γ hγ
+           model := {
+             Dart := M.Dart
+             rotation := ρ
+             pairing := γ
+             involutive := hγ
+             genus := MapContract.genusZero M.rotation M.pairing M.involutive S T hT M.genus
+             iso := .refl }
+           quotient := fun v=>q (M.iso.symm v)
+           surjective := (MapContract.quotient_surjective M.rotation M.pairing M.involutive S T hT M.genus ht).comp M.iso.symm.surjective
+           eq_iff := ?_
+           adj := ?_
+           lift_adj := ?_ }
+  · intro v w
+    rw [MapContract.quotient_eq_iff]
+    simp only [S,Set.mem_ofPred_eq,M.iso.apply_symm_apply,M.iso.symm.injective.eq_iff]
+  · intro v w h
+    exact MapContract.quotient_adj M.rotation M.pairing M.involutive S T hT M.genus ht (M.iso.symm.toHom.map_adj h)
+  · intro v w h
+    obtain ⟨x,y,hxy,hx,hy⟩ := MapContract.adj_lift M.rotation M.pairing M.involutive S T hT M.genus ht h
+    exact ⟨M.iso x,M.iso y,M.iso.toHom.map_adj hxy,by simpa only [M.iso.symm_apply_apply] using hx,by simpa only [M.iso.symm_apply_apply] using hy⟩
+
+end TorsionFreeZeroDivisors.PlanarMap
+
+namespace TorsionFreeZeroDivisors.CutTransfer
+open scoped Classical
+variable {V W : Type} [Fintype V] [DecidableEq W] (G : SimpleGraph V) (H : SimpleGraph W)
+    (A : Finset V) (f : V→W)
+
+theorem pullback (hinj : Set.InjOn f A)
+    (hmap : ∀ v∈A,∀ w∈A,G.Adj v w→f v=f w ∨ H.Adj (f v) (f w))
+    (C D budget : Finset W) (K : ℕ) (hcost : budget.card≤K)
+    (hbudget : ∀ v∈A,f v∈C→f v∈budget)
+    (h₁ : 3*((A.image f).filter (fun v=>v∉C ∧ v∈D)).card≤2*(A.image f).card)
+    (h₂ : 3*((A.image f).filter (fun v=>v∉C ∧ v∉D)).card≤2*(A.image f).card)
+    (hsep : ∀ v w,v∉C→w∉C→H.Adj v w→(v∈D↔w∈D)) :
+    ∃ cut side : Finset V,cut⊆A ∧ cut.card≤K ∧
+      3*(A.filter (fun v=>v∉cut ∧ v∈side)).card≤2*A.card ∧
+      3*(A.filter (fun v=>v∉cut ∧ v∉side)).card≤2*A.card ∧
+      ∀ v∈A,∀ w∈A,v∉cut→w∉cut→G.Adj v w→(v∈side↔w∈side) := by
+  let cut := A.filter (fun v=>f v∈C)
+  let side := Finset.univ.filter (fun v=>f v∈D)
+  have hsub : cut⊆A := Finset.filter_subset _ _
+  have hcut {v : V} (hv : v∈A) : v∈cut↔f v∈C := by simp only [cut,Finset.mem_filter,hv,true_and]
+  have hside (v : V) : v∈side↔f v∈D := by simp only [side,Finset.mem_filter,Finset.mem_univ,true_and]
+  have hcard : (A.image f).card=A.card := Finset.card_image_of_injOn hinj
+  have hfilter (p : W→Prop) [DecidablePred p] :
+      ((A.image f).filter p).card=(A.filter (fun v=>p (f v))).card := by
+    rw [Finset.filter_image]
+    exact Finset.card_image_of_injOn (hinj.mono (Finset.filter_subset _ _))
+  have hfirst : (A.image f).filter (fun v=>v∉C ∧ v∈D) =
+      (A.filter (fun v=>v∉cut ∧ v∈side)).image f := by
+    rw [Finset.filter_image]
+    congr 1
+    apply Finset.filter_congr
+    intro v hv
+    simp only [hcut hv,hside]
+  have hsecond : (A.image f).filter (fun v=>v∉C ∧ v∉D) =
+      (A.filter (fun v=>v∉cut ∧ v∉side)).image f := by
+    rw [Finset.filter_image]
+    congr 1
+    apply Finset.filter_congr
+    intro v hv
+    simp only [hcut hv,hside]
+  have himage : cut.image f⊆budget := by
+    intro v hv
+    obtain ⟨x,hx,rfl⟩ := Finset.mem_image.mp hv
+    exact hbudget x (hsub hx) ((hcut (hsub hx)).mp hx)
+  refine ⟨cut,side,hsub,?_,?_,?_,?_⟩
+  · have he : (cut.image f).card=cut.card := Finset.card_image_of_injOn (hinj.mono hsub)
+    rw [←he]
+    exact (Finset.card_le_card himage).trans hcost
+  · rw [hfirst,Finset.card_image_of_injOn (hinj.mono (Finset.filter_subset _ _)),hcard] at h₁
+    exact h₁
+  · rw [hsecond,Finset.card_image_of_injOn (hinj.mono (Finset.filter_subset _ _)),hcard] at h₂
+    exact h₂
+  · intro v hv w hw hvC hwC he
+    rw [hside,hside]
+    rcases hmap v hv w hw he with h|h
+    · rw [h]
+    · exact hsep (f v) (f w) (fun h=>hvC ((hcut hv).mpr h)) (fun h=>hwC ((hcut hw).mpr h)) h
+end TorsionFreeZeroDivisors.CutTransfer
+
+namespace TorsionFreeZeroDivisors.PlanarMap
+open scoped Classical
+open SimpleGraph
+variable {V : Type} [Fintype V] {G : SimpleGraph V}
+
+/-- Root-saving radius separation after literal connected lower-ball
+contraction. Only vertices of `active` are charged or retained. -/
+theorem Model.annular_separator (M : Model G) (hc : G.Connected) (root : V)
+    (lo hi : ℕ) (active : Finset V)
+    (hA : ∀ v∈active,lo<G.dist v root ∧ G.dist v root≤hi) :
+    ∃ cut side : Finset V,cut⊆active ∧ cut.card≤2*(hi-lo) ∧
+      3*(active.filter (fun v=>v∉cut ∧ v∈side)).card≤2*active.card ∧
+      3*(active.filter (fun v=>v∉cut ∧ v∉side)).card≤2*active.card ∧
+      ∀ v∈active,∀ w∈active,v∉cut→w∉cut→G.Adj v w→(v∈side↔w∈side) := by
+  let S := GraphBall.vertices G root hi
+  let H := G.induce S
+  let r : S := GraphBall.rootVertex G root hi
+  have hH : H.Connected := GraphBall.connected G hc root hi
+  let B := GraphBall.vertices H r lo
+  let J := (M.induced S).contract (GraphBall.connected H hH r lo)
+  let q := J.quotient
+  have hJ : J.graph.Connected := GraphQuotient.connected H J.graph q J.adj J.surjective hH
+  have hcollapse (v : S) (hv : H.dist v r≤lo) : q v=q r :=
+    (J.eq_iff v r).mpr (Or.inr ⟨hv,by change H.dist r r≤lo;simp only [SimpleGraph.dist_self];omega⟩)
+  have hdist (v : S) : J.graph.dist (q v) (q r)≤G.dist v.val root-lo := by
+    have h := GraphQuotient.distance_sub H J.graph q J.adj hH hJ r lo hcollapse v
+    have he : H.dist v r=G.dist v.val root := GraphBall.dist_root G hc root hi v
+    rwa [he] at h
+  have hr (w : J.Vertex) : J.graph.dist (q r) w≤hi-lo := by
+    obtain ⟨v,rfl⟩ := J.surjective w
+    rw [SimpleGraph.dist_comm]
+    exact (hdist v).trans (Nat.sub_le_sub_right v.property lo)
+  let f : V→J.Vertex := fun v=>if hv:v∈S then q ⟨v,hv⟩ else q r
+  have hf (v : V) (hv : v∈S) : f v=q ⟨v,hv⟩ := dite_eq_left hv
+  have hAS {v : V} (hv : v∈active) : v∈S := (hA v hv).2
+  have hout (v : V) (hv : v∈active) : (⟨v,hAS hv⟩ : S)∉B := by
+    change ¬H.dist ⟨v,hAS hv⟩ r≤lo
+    rw [GraphBall.dist_root G hc root hi]
+    exact Nat.not_le.mpr (hA v hv).1
+  have hinj : Set.InjOn f active := by
+    intro v hv w hw he
+    rw [hf v (hAS hv),hf w (hAS hw)] at he
+    rcases (J.eq_iff _ _).mp he with he|he
+    · exact congrArg Subtype.val he
+    · exact (hout v hv he.1).elim
+  have hroot (v : V) (hv : v∈active) : f v≠q r := by
+    intro he
+    rw [hf v (hAS hv)] at he
+    rcases (J.eq_iff _ _).mp he with he|he
+    · have hd : H.dist (⟨v,hAS hv⟩ : S) r=0 := by rw [he,SimpleGraph.dist_self]
+      have hh : (⟨v,hAS hv⟩ : S)∈B := by change H.dist _ r≤lo;omega
+      exact hout v hv hh
+    · exact hout v hv he.1
+  have hmap : ∀ v∈active,∀ w∈active,G.Adj v w→f v=f w ∨ J.graph.Adj (f v) (f w) := by
+    intro v hv w hw he
+    rw [hf v (hAS hv),hf w (hAS hw)]
+    exact J.adj ⟨v,hAS hv⟩ ⟨w,hAS hw⟩ he
+  obtain ⟨C,D,_,_,hCe,h₁,h₂,hsep⟩ := J.model.radius_separator hJ (q r) (hi-lo) hr (active.image f)
+  exact CutTransfer.pullback G J.graph active f hinj hmap C D (C.erase (q r)) (2*(hi-lo)) hCe
+    (fun v hv h=>Finset.mem_erase.mpr ⟨hroot v hv,h⟩) h₁ h₂ hsep
+
+/-- The uncontracted alternative, needed when the selected lower level is
+negative. Its extra root vertex fits strictly within the level-gap budget. -/
+theorem Model.ball_separator (M : Model G) (hc : G.Connected) (root : V)
+    (hi : ℕ) (active : Finset V) (hA : ∀ v∈active,G.dist v root≤hi) :
+    ∃ cut side : Finset V,cut⊆active ∧ cut.card≤2*hi+1 ∧
+      3*(active.filter (fun v=>v∉cut ∧ v∈side)).card≤2*active.card ∧
+      3*(active.filter (fun v=>v∉cut ∧ v∉side)).card≤2*active.card ∧
+      ∀ v∈active,∀ w∈active,v∉cut→w∉cut→G.Adj v w→(v∈side↔w∈side) := by
+  let S := GraphBall.vertices G root hi
+  let : DecidableEq S := Classical.decEq S
+  let H := G.induce S
+  let r : S := GraphBall.rootVertex G root hi
+  have hH : H.Connected := GraphBall.connected G hc root hi
+  let f : V→S := fun v=>if hv:v∈S then ⟨v,hv⟩ else r
+  have hf (v : V) (hv : v∈S) : f v=⟨v,hv⟩ := dite_eq_left hv
+  have hinj : Set.InjOn f active := by
+    intro v hv w hw he
+    rw [hf v (hA v hv),hf w (hA w hw)] at he
+    exact congrArg Subtype.val he
+  have hmap : ∀ v∈active,∀ w∈active,G.Adj v w→f v=f w ∨ H.Adj (f v) (f w) := by
+    intro v hv w hw he
+    rw [hf v (hA v hv),hf w (hA w hw)]
+    exact Or.inr he
+  have hr (v : S) : H.dist r v≤hi := by
+    rw [SimpleGraph.dist_comm,GraphBall.dist_root G hc root hi]
+    exact v.property
+  obtain ⟨C,D,_,hC,_,h₁,h₂,hsep⟩ := (M.induced S).radius_separator hH r hi hr (active.image f)
+  exact CutTransfer.pullback G H active f hinj hmap C D C (2*hi+1) hC (fun _ _ h=>h) h₁ h₂ hsep
+
+end TorsionFreeZeroDivisors.PlanarMap
+
+/-!
+Sharp level-selection arithmetic for the planar-separator dependency.  The
+profile is the actual number of vertices on each integer BFS level.  No planar
+separator is assumed or concluded here: the bounded-radius geometric step is
+separate.
+-/
+namespace TorsionFreeZeroDivisors.SeparatorLevels
+open scoped BigOperators
+
+private theorem twice_sum_succ (h : ℕ) :
+    (∑ k ∈ Finset.range h, 2*(k+1)) = h*(h+1) := by
+  induction h with
+  | zero => simp
+  | succ h ih => rw [Finset.sum_range_succ,ih]; ring
+
+/-- The exact discrete triangle under a minimum level cost. -/
+theorem triangular_bound (m : ℕ) (c : ℕ → ℕ)
+    (hc : ∀ k < m/2, m ≤ c k + 2*(k+1)) :
+    m^2 ≤ 4*(∑ k ∈ Finset.range (m/2), c k) + 2*m := by
+  have hs : (m/2)*m ≤ (∑ k ∈ Finset.range (m/2),c k)+(m/2)*(m/2+1) := by
+    have hh := Finset.sum_le_sum (s:=Finset.range (m/2))
+      (fun k hk => hc k (Finset.mem_range.mp hk))
+    simpa only [Finset.sum_add_distrib,twice_sum_succ,Finset.sum_const,
+      Finset.card_range,smul_eq_mul] using hh
+  have hr := Nat.mod_add_div m 2
+  have hr' := Nat.mod_lt m (by decide : 0<2)
+  have : m%2=0 ∨ m%2=1 := by omega
+  rcases this with he | he <;> rw [he] at hr <;> nlinarith
+
+theorem exists_minimum (f : ℕ → ℕ) : ∃ k, ∀ j, f k ≤ f j := by
+  obtain ⟨m,⟨k,hk⟩,hm⟩ := Nat.lt_wfRel.wf.has_min (Set.range f) ⟨f 0,0,rfl⟩
+  refine ⟨k,fun j => ?_⟩
+  have hh := hm (f j) ⟨j,rfl⟩
+  change ¬ f j < m at hh
+  rw [hk]
+  omega
+
+/-- A nonnegative integer profile with total mass at most `N` has two levels
+whose combined width plus twice their separation is at most `sqrt(8*N)`.
+The center level is counted only once in the mass estimate. -/
+theorem select (a : ℤ → ℕ) (N : ℕ) (center : ℤ)
+    (mass : ∀ s : Finset ℤ, ∑ z ∈ s,a z ≤ N) :
+    ∃ kL kR : ℕ,
+      (a (center-kL) + a (center+kR) + 2*(kL+kR) : ℝ) ≤
+        2*Real.sqrt 2*Real.sqrt N := by
+  classical
+  obtain ⟨kL,hL⟩ := exists_minimum (fun k=>a (center-k)+2*k)
+  obtain ⟨kR,hR⟩ := exists_minimum (fun k=>a (center+k)+2*k)
+  let A := a (center-kL)+2*kL
+  let B := a (center+kR)+2*kR
+  have hA : A ≤ a center := by
+    simpa only [sub_zero,Nat.cast_zero,mul_zero,add_zero] using hL 0
+  have hB : B ≤ a center := by
+    simpa only [add_zero,Nat.cast_zero,mul_zero] using hR 0
+  have tA := triangular_bound A (fun k=>a (center-(k+1:ℕ)))
+    (fun k _ => hL (k+1))
+  have tB := triangular_bound B (fun k=>a (center+(k+1:ℕ)))
+    (fun k _ => hR (k+1))
+  let left := (Finset.range (A/2)).image (fun k:ℕ=>center-(k+1:ℕ))
+  let right := (Finset.range (B/2)).image (fun k:ℕ=>center+(k+1:ℕ))
+  have hl : ∀ z ∈ left,z<center := by
+    intro z hz
+    obtain ⟨k,_,rfl⟩ := Finset.mem_image.mp hz
+    omega
+  have hr : ∀ z ∈ right,center<z := by
+    intro z hz
+    obtain ⟨k,_,rfl⟩ := Finset.mem_image.mp hz
+    omega
+  have hlr : Disjoint left right := by
+    apply Finset.disjoint_left.mpr
+    intro z hzl hzr
+    have := hl z hzl
+    have := hr z hzr
+    omega
+  have hc : center ∉ left ∪ right := by
+    intro hh
+    rcases Finset.mem_union.mp hh with hh|hh
+    · exact (lt_irrefl center) (hl center hh)
+    · exact (lt_irrefl center) (hr center hh)
+  have sal : ∑ z ∈ left,a z = ∑ k ∈ Finset.range (A/2),a (center-(k+1:ℕ)) := by
+    apply Finset.sum_image
+    intro x _ y _ he
+    change center-(x+1:ℕ)=center-(y+1:ℕ) at he
+    omega
+  have sar : ∑ z ∈ right,a z = ∑ k ∈ Finset.range (B/2),a (center+(k+1:ℕ)) := by
+    apply Finset.sum_image
+    intro x _ y _ he
+    change center+(x+1:ℕ)=center+(y+1:ℕ) at he
+    omega
+  have hmass := mass (insert center (left ∪ right))
+  rw [Finset.sum_insert hc,Finset.sum_union hlr,sal,sar] at hmass
+  have hs : A^2+B^2 ≤ 4*N := by nlinarith
+  have hs' : (A:ℝ)^2+(B:ℝ)^2 ≤ 4*(N:ℝ) := by exact_mod_cast hs
+  have hab : ((A:ℝ)+(B:ℝ))^2 ≤ 8*(N:ℝ) := by nlinarith [sq_nonneg ((A:ℝ)-B)]
+  have sqn := Real.sq_sqrt (show (0:ℝ)≤N by positivity)
+  have sq2 := Real.sq_sqrt (show (0:ℝ)≤2 by norm_num)
+  have hp : (2*Real.sqrt 2*Real.sqrt N)^2=8*(N:ℝ) := by
+    calc
+      _ = 4*(Real.sqrt 2)^2*(Real.sqrt N)^2 := by ring
+      _ = _ := by rw [sqn,sq2]; ring
+  have hfinal : (A:ℝ)+B ≤ 2*Real.sqrt 2*Real.sqrt N := by
+    apply (sq_le_sq₀ (by positivity) (by positivity)).mp
+    rw [hp]
+    exact hab
+  refine ⟨kL,kR,?_⟩
+  convert hfinal using 1
+  dsimp [A,B]
+  push_cast
+  ring
+
+end TorsionFreeZeroDivisors.SeparatorLevels
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/GroupRing/GridUniform.lean b/lean/OAI/Algebra/GroupRing/GridUniform.lean
new file mode 100644
index 0000000000000000000000000000000000000000..726e065f850a373eac67210fbb79b4bd77bfba9b
--- /dev/null
+++ b/lean/OAI/Algebra/GroupRing/GridUniform.lean
@@ -0,0 +1,377 @@
+import Mathlib
+import OAI.Algebra.GroupRing.StageEntropy
+
+namespace OAI
+
+noncomputable section
+
+namespace TorsionFreeZeroDivisors.GridUniform
+open scoped Topology BigOperators
+open Filter GridAsymptotics
+
+def rate (d : ℕ) (L : ℝ) : ℝ :=
+  1/(R d L:ℝ)+1/Real.sqrt L+(R d L:ℝ)/(N d L)+1/L
+
+theorem rate_nonneg (d : ℕ) {L : ℝ} (hL : 0≤L) : 0≤rate d L := by
+  unfold rate
+  positivity
+
+theorem rate_tendsto (d : ℕ) : Tendsto (rate d) atTop (𝓝 0) := by
+  have hr : Tendsto (fun L : ℝ => 1/(R d L:ℝ)) atTop (𝓝 0) :=
+    tendsto_const_nhds.div_atTop (R_tendsto d)
+  have hs : Tendsto (fun L : ℝ => 1/Real.sqrt L) atTop (𝓝 0) :=
+    tendsto_const_nhds.div_atTop Real.tendsto_sqrt_atTop
+  have hi : Tendsto (fun L : ℝ => 1/L) atTop (𝓝 0) := tendsto_const_nhds.div_atTop tendsto_id
+  unfold rate
+  simpa only [add_zero] using ((hr.add hs).add (alignment_error_tendsto d)).add hi
+
+/-- A single offset-independent rate controls every scalar rounding loss. -/
+theorem bounds (d : ℕ) {L : ℝ} (hL : 1≤L) (offset : Fin d → ℤ) :
+    chosenScale d L offset/L ≤ rate d L ∧
+    1/chosenScale d L offset ≤ rate d L ∧
+    (letterError d L offset:ℝ)/chosenScale d L offset ≤ 5*rate d L ∧
+    1/L ≤ rate d L := by
+  have hL0 : 0<L := by linarith
+  have hs := chosenScale_pos d hL offset
+  have hroot := Real.sqrt_pos.mpr hL0
+  have hb := scale_bounds d hL (chosen_spec d hL offset).1 (chosen_bound d hL offset)
+  change Real.sqrt L ≤ chosenScale d L offset ∧
+    chosenScale d L offset/L ≤ 1/(R d L:ℝ) at hb
+  have hi : 1/chosenScale d L offset ≤ 1/Real.sqrt L :=
+    one_div_le_one_div_of_le hroot hb.1
+  have he : (letterError d L offset:ℝ)/chosenScale d L offset ≤
+      2*((R d L:ℝ)/(N d L))+5/chosenScale d L offset := by
+    apply (div_le_iff₀ hs).mpr
+    have hh := (letterError_bounds d hL offset).2
+    have hh' : (2*((R d L:ℝ)/(N d L))+5/chosenScale d L offset)*chosenScale d L offset =
+        2*((R d L:ℝ)/(N d L))*chosenScale d L offset+5 := by field_simp
+    rwa [hh']
+  have hr : 0 ≤ 1/(R d L:ℝ) := by positivity
+  have hn : 0 ≤ (R d L:ℝ)/(N d L) := by positivity
+  have hlo : 0 ≤ 1/L := by positivity
+  have hso : 0 ≤ 1/Real.sqrt L := by positivity
+  unfold rate
+  simp only [div_eq_mul_inv,one_mul] at *
+  refine ⟨?_,?_,?_,?_⟩ <;> linarith
+
+/-- Unlike a chosen offset sequence, this statement is uniform over ALL
+integer comparison offsets at each common length scale. -/
+theorem eventually_geometry (d : ℕ) : ∀ᶠ L in atTop, ∀ offset : Fin d → ℤ,
+    3003 ≤ chosenScale d L offset ∧
+    2*(letterError d L offset:ℝ) < chosenScale d L offset-1 := by
+  have hr := (rate_tendsto d).eventually_lt_const (by norm_num : (0:ℝ)<1/12)
+  have hroot := Real.tendsto_sqrt_atTop.eventually (eventually_ge_atTop (3003:ℝ))
+  filter_upwards [hr,hroot,eventually_ge_atTop (1:ℝ)] with L hr hroot hL offset
+  have hb := bounds d hL offset
+  have hs := chosenScale_pos d hL offset
+  have hlo := (scale_bounds d hL (chosen_spec d hL offset).1 (chosen_bound d hL offset)).1
+  change Real.sqrt L ≤ chosenScale d L offset at hlo
+  have he := (div_le_iff₀ hs).mp hb.2.2.1
+  have hi := (div_le_iff₀ hs).mp hb.2.1
+  refine ⟨hroot.trans hlo,?_⟩
+  nlinarith
+end TorsionFreeZeroDivisors.GridUniform
+namespace TorsionFreeZeroDivisors.StageUniform
+open scoped Classical BigOperators Topology
+open BlockAlignment ComparedBlocks RepeatedBlocks GridAsymptotics Filter
+
+def alphabetLog : ℝ := Real.log (Fintype.card WordEstimate.Letter)
+
+theorem alphabetLog_nonneg : 0 ≤ alphabetLog := by
+  apply Real.log_nonneg
+  norm_num [WordEstimate.Letter]
+
+def coefficient (D K M Q : ℕ) : ℝ :=
+  256*(22*D+K)+(1/1200:ℝ)*M*Q+M*(10*K+2*Q)*alphabetLog
+
+/-- Uniform scalar estimate. Its inputs are just the explicit common-grid
+loss bounds, not an entropy or probability estimate. -/
+theorem scalar_bound (D K M Q : ℕ) (L s H blocks err rate den : ℝ)
+    (hL : 0 < L) (hs : 0 < s) (_hH : 0 ≤ H) (hb : 0 ≤ blocks)
+    (hr : 0 ≤ rate) (hscale : s/L≤ rate) (hinv : 1/s≤ rate)
+    (hone : 1/L≤ rate) (he : err/s≤5*rate)
+    (hsize : H≤K*L) (hblocks : s*blocks≤K*L) :
+    (256*(22*s*D+H/s)+(1/1200:ℝ)*s*M*Q+
+      M*((2*err*blocks+(s+1)*Q)*alphabetLog+den))/L ≤
+        coefficient D K M Q*rate+M*den/L := by
+  have hsl := (div_le_iff₀ hL).mp hscale
+  have hon := (div_le_iff₀ hL).mp hone
+  have he' := (div_le_iff₀ hs).mp he
+  have hHl : H/s ≤ (K:ℝ)*L*rate := by
+    calc
+      _ ≤ ((K:ℝ)*L)/s := div_le_div_of_nonneg_right hsize hs.le
+      _ = ((K:ℝ)*L)*(1/s) := by ring
+      _ ≤ _ := mul_le_mul_of_nonneg_left hinv (by positivity)
+  have heb := mul_le_mul_of_nonneg_right he' hb
+  have hbc := mul_le_mul_of_nonneg_left hblocks (show 0 ≤ 10*rate by positivity)
+  have htail : (s+1)*(Q:ℝ) ≤ 2*rate*L*Q :=
+    mul_le_mul_of_nonneg_right (by linarith) (Nat.cast_nonneg Q)
+  have hloss : 2*err*blocks+(s+1)*Q ≤ (10*K+2*Q)*rate*L := by nlinarith
+  have hlog := mul_le_mul_of_nonneg_right hloss alphabetLog_nonneg
+  have hst := mul_le_mul_of_nonneg_right hsl (show 0 ≤ 22*(D:ℝ) by positivity)
+  have hsq := mul_le_mul_of_nonneg_right hsl (show 0 ≤ (1/1200:ℝ)*M*Q by positivity)
+  have hM := mul_le_mul_of_nonneg_left hlog (Nat.cast_nonneg M)
+  apply (div_le_iff₀ hL).mpr
+  have hcancel : (coefficient D K M Q*rate+M*den/L)*L =
+      coefficient D K M Q*rate*L+M*den := by field_simp
+  rw [hcancel]
+  unfold coefficient
+  nlinarith
+
+variable {C E : Type*} [Fintype C] [Fintype E]
+
+/-- Specialization to the literal stage remainder: the ONLY scale-dependent
+upper bound is `rate`, which does not mention offsets or labelled words. -/
+theorem residual_bound (K M Q : ℕ) (L : ℝ) (hL : 1≤L)
+    (offset : Fin (Fintype.card E) → ℤ) (len m : C → ℕ) (hQ : Fintype.card C≤Q)
+    (hH : StageMass.totalLength len m ≤ K*L) (hpositive : ∀ c,1≤ m c) (den : ℝ) :
+    StageMass.residual (E := E) (chosenScale (Fintype.card E) L offset) len m
+      (letterError (Fintype.card E) L offset) M Q den/L ≤
+        coefficient (Fintype.card E) K M Q*GridUniform.rate (Fintype.card E) L+M*den/L := by
+  let s := chosenScale (Fintype.card E) L offset
+  let err := letterError (Fintype.card E) L offset
+  have hs : 0 < s := chosenScale_pos _ hL offset
+  have hcard : s*Fintype.card (Underlying s len) ≤ (K:ℝ)*L := by
+    apply (Comparisons.block_mass s hs len).trans
+    apply le_trans ?_ hH
+    rw [StageMass.totalLength_eq]
+    apply Finset.sum_le_sum
+    intro c _
+    have hp : (1:ℝ)≤ m c := by exact_mod_cast hpositive c
+    have hm := mul_le_mul_of_nonneg_right hp (Nat.cast_nonneg (len c): (0:ℝ) ≤ len c)
+    simpa only [one_mul] using hm
+  have hr := GridUniform.bounds (Fintype.card E) hL offset
+  have h := scalar_bound (Fintype.card E) K M Q L s (StageMass.totalLength len m)
+    (Fintype.card (Underlying s len)) err (GridUniform.rate (Fintype.card E) L) den
+    (by linarith) hs (Finset.sum_nonneg (fun _ _ => Nat.cast_nonneg _))
+    (Nat.cast_nonneg _) (GridUniform.rate_nonneg _ (by linarith))
+    hr.1 hr.2.1 hr.2.2.2 hr.2.2.1 hH hcard
+  apply le_trans ?_ h
+  apply div_le_div_of_nonneg_right _ (by linarith)
+  unfold StageMass.residual StageEntropy.looseCost alphabetLog
+  have htail := mul_le_mul_of_nonneg_left (show (Fintype.card C:ℝ) ≤ Q by exact_mod_cast hQ)
+    (show 0 ≤  s+1 by linarith)
+  have hlog := mul_le_mul_of_nonneg_right htail alphabetLog_nonneg
+  have hh := mul_le_mul_of_nonneg_left hlog (Nat.cast_nonneg M)
+  dsimp only [alphabetLog] at hh
+  linarith
+
+open GirthAsymptotics TypedGraphs
+
+/-- All patterns of the stated fixed bounds share one threshold. No offset,
+chain length, bin, or word is fixed before this eventual quantifier. -/
+theorem eventually_residual (K M Q : ℕ) : ∀ᶠ rep in atTop,
+    ∀ (offset : Fin (Fintype.card E) → ℤ) (len m : C → ℕ),
+      Fintype.card C ≤ Q → StageMass.totalLength len m ≤ K*(L (size rep):ℝ) →
+      (L (size rep):ℝ) ≤ StageMass.totalLength len m → (∀ c,1 ≤ m c) →
+      StageMass.residual (E := E) (chosenScale (Fintype.card E) (L (size rep)) offset) len m
+        (letterError (Fintype.card E) (L (size rep)) offset) M Q
+        (StageDenominator.error K Q rep) ≤ StageMass.totalLength len m/4800 := by
+  have hL : Tendsto (fun rep => (L (size rep):ℝ)) atTop atTop :=
+    tendsto_natCast_atTop_atTop.comp (L_tendsto.comp size_tendsto)
+  have hr := ((GridUniform.rate_tendsto (Fintype.card E)).comp hL).const_mul
+    (coefficient (Fintype.card E) K M Q)
+  have he := (StageDenominator.error_ratio K Q).const_mul (M:ℝ)
+  have ht := hr.add he
+  simp only [mul_zero,add_zero] at ht
+  have hevent := ht.eventually_lt_const (by norm_num : (0:ℝ)<1/4800)
+  filter_upwards [hevent,hL.eventually (eventually_ge_atTop (1:ℝ))] with rep hrate hlen
+  intro offset len m hQ hupper hlower hpos
+  have h := residual_bound K M Q (L (size rep)) hlen offset len m hQ hupper hpos
+    (StageDenominator.error K Q rep)
+  have hrate' : coefficient (Fintype.card E) K M Q*GridUniform.rate (Fintype.card E)
+      (L (size rep))+M*StageDenominator.error K Q rep/(L (size rep):ℝ) < 1/4800 := by
+    simpa only [Function.comp_def,mul_div_assoc] using hrate
+  have hb := (div_le_iff₀ (show (0:ℝ)<L (size rep) by linarith)).mp (h.trans hrate'.le)
+  linarith
+end TorsionFreeZeroDivisors.StageUniform
+namespace TorsionFreeZeroDivisors.GridUniform
+open scoped Topology BigOperators
+open Filter GridAsymptotics
+
+def binRate (L : ℝ) : ℝ := (Real.log 257+Real.log L)/Real.sqrt L
+
+theorem binRate_tendsto : Tendsto binRate atTop (𝓝 0) := by
+  have hc : Tendsto (fun L : ℝ => Real.log 257/Real.sqrt L) atTop (𝓝 0) :=
+    tendsto_const_nhds.div_atTop Real.tendsto_sqrt_atTop
+  have hl := (isLittleO_log_rpow_atTop (by norm_num : (0:ℝ)<1/2)).tendsto_div_nhds_zero
+  have he : (fun L : ℝ => Real.log L / L^(1/2:ℝ)) =
+      (fun L : ℝ => Real.log L/Real.sqrt L) := by
+    funext L
+    rw [Real.sqrt_eq_rpow]
+  rw [he] at hl
+  unfold binRate
+  simpa only [add_div,add_zero] using hc.add hl
+
+theorem scale_le (d : ℕ) {L : ℝ} (hL : 1 ≤ L) (offset : Fin d → ℤ) :
+    chosenScale d L offset ≤ L := by
+  have h := (scale_bounds d hL (chosen_spec d hL offset).1 (chosen_bound d hL offset)).2
+  change chosenScale d L offset/L ≤ 1/(R d L:ℝ) at h
+  have hR : (1:ℝ) ≤ R d L := by exact_mod_cast R_pos d hL
+  have hi := one_div_le_one_div_of_le (by norm_num : (0:ℝ)<1) hR
+  norm_num only [div_one] at hi
+  have hh := (div_le_iff₀ (show 0<L by linarith)).mp (h.trans hi)
+  simpa only [one_mul] using hh
+
+/-- A single common-grid bound for the logarithm of the number of all bin
+profiles, without fixing any comparison offsets. -/
+theorem bin_bound (d : ℕ) {L : ℝ} (hL : 1 ≤ L) (offset : Fin d → ℤ) :
+    Real.log (256*chosenScale d L offset+1)/chosenScale d L offset ≤ binRate L := by
+  let s := chosenScale d L offset
+  have hs : 0<s := chosenScale_pos d hL offset
+  have hsl : s ≤ L := scale_le d hL offset
+  have hlo := (scale_bounds d hL (chosen_spec d hL offset).1 (chosen_bound d hL offset)).1
+  change Real.sqrt L ≤ s at hlo
+  have hL0 : 0<L := by linarith
+  have hlog := Real.log_le_log (show 0<256*s+1 by positivity)
+    (show 256*s+1 ≤ 257*L by linarith)
+  rw [Real.log_mul (by norm_num : (257:ℝ)≠0) hL0.ne'] at hlog
+  calc
+    _ ≤ (Real.log 257+Real.log L)/s := div_le_div_of_nonneg_right hlog hs.le
+    _ ≤ _ := div_le_div_of_nonneg_left (by positivity [Real.log_nonneg hL])
+      (Real.sqrt_pos.mpr hL0) hlo
+
+end TorsionFreeZeroDivisors.GridUniform
+namespace TorsionFreeZeroDivisors.BinProfiles
+open scoped Classical
+open BlockAlignment ComparedBlocks RepeatedBlocks WordEstimate
+variable {C E : Type*} [Fintype C] [Fintype E]
+
+omit [Fintype C] in
+theorem height_bounds (s : ℝ) (hs : 0 ≤ s) (len : C → ℕ) (i : Underlying s len) :
+    s-1 ≤ (height s len i:ℝ) ∧ (height s len i:ℝ) ≤ s+1 := by
+  have hl := card_lower ((i.2.val:ℝ)*s) (((i.2.val:ℝ)+1)*s)
+  have hu := card_upper (lo := (i.2.val:ℝ)*s) (hi := ((i.2.val:ℝ)+1)*s) (by nlinarith)
+  simp only [height,block,Int.cast_natCast]
+  constructor <;> linarith
+
+omit [Fintype E] in
+/-- Feasible literal blocks obey BOTH entropy cutoffs and belong to the finite
+profile family. This includes the empty block carrier. -/
+theorem feasible_bounds (s : ℝ) (hs : 3003 ≤ s) (len m : C → ℕ)
+    (cmp : Comparisons (E := E) (traversalLength len m))
+    (d : Underlying s len → ℤ) (W : (i : Underlying s len) → Fin (height s len i) → Letter)
+    (hW : ActualStageLabels.Feasible s len m cmp d W) :
+    d ∈ profiles s len ∧ ∀ i, (1/600:ℝ)*s/2 ≤ d i ∧ (d i:ℝ) ≤ 256*s := by
+  have hh (i : Underlying s len) : 3002 ≤ height s len i ∧
+      s+1200 ≤ 2*(height s len i:ℝ) ∧ (height s len i:ℝ) ≤ 2*s := by
+    have hb := height_bounds s (by linarith) len i
+    have hn : (3002:ℝ) ≤ height s len i := by linarith
+    exact ⟨by exact_mod_cast hn,by linarith,by linarith⟩
+  refine ⟨Fintype.mem_piFinset.mpr (fun i => ?_),fun i => ?_⟩
+  · exact mem_values (hh i).1 s (by linarith) (hh i).2.1 (hh i).2.2 (d i) (W i) (hW.1 i)
+  · have h := bin_full_bounds (height s len i) (hh i).1 s (hh i).2.1 (hh i).2.2
+      (d i) (W i) (hW.1 i)
+    exact ⟨h.1,h.2.1⟩
+end TorsionFreeZeroDivisors.BinProfiles
+
+namespace TorsionFreeZeroDivisors.RealizationTransport
+open scoped Classical BigOperators
+open PortSubdivision ConditionedMatchings PatternEmbeddings
+variable {PV PD TV T : Type*} [Fintype PV] [Fintype PD] [Fintype TV] [Fintype T]
+
+/-- An injective realization in a fixed sampled matching. These are actual
+maps on vertices and ports; no random-event bound is part of the data. -/
+structure Embedding (Γ : PortGraph PV PD) (plabel : PD → T) (outgoing : TV → Finset T)
+    (pin : PV → Option TV) (bar : T → T) (r : Matching (label outgoing) bar) where
+  vertex : PV ↪ TV
+  port : PD ↪ Dart outgoing
+  origin_eq : ∀ d, origin outgoing (port d) = vertex (Γ.origin d)
+  label_eq : ∀ d, label outgoing (port d) = plabel d
+  reverse_eq : ∀ d, r.val (port d) = port (Γ.reverse d)
+  pin_eq : ∀ v y, pin v = some y → vertex v = y
+
+variable {Γ : PortGraph PV PD} {plabel : PD → T} {outgoing : TV → Finset T}
+    {pin : PV → Option TV} {bar : T → T} {r : Matching (label outgoing) bar}
+    (e : Embedding Γ plabel outgoing pin bar r)
+
+include e in
+omit [Fintype PV] [Fintype PD] [Fintype TV] [Fintype T] in
+theorem immersed : Function.Injective (fun d => (Γ.origin d,plabel d)) := by
+  intro d f h
+  apply e.port.injective
+  apply Subtype.ext
+  apply Prod.ext
+  · change origin outgoing (e.port d) = origin outgoing (e.port f)
+    rw [e.origin_eq,e.origin_eq]
+    exact congrArg e.vertex (congrArg Prod.fst h)
+  · change label outgoing (e.port d) = label outgoing (e.port f)
+    rw [e.label_eq,e.label_eq]
+    exact congrArg Prod.snd h
+
+def vertexMap : VertexMap (StageRealization.allowed Γ plabel outgoing pin) :=
+  ⟨e.vertex,e.vertex.injective,by
+    intro v
+    apply Finset.mem_filter.mpr
+    refine ⟨Finset.mem_univ _,?_,e.pin_eq v⟩
+    intro d hd
+    have hp := (e.port d).property
+    change label outgoing (e.port d) ∈ outgoing (origin outgoing (e.port d)) at hp
+    simpa only [e.label_eq,e.origin_eq,hd] using hp⟩
+
+omit [Fintype PV] [Fintype T] in
+theorem dartMap_eq (d : PD) :
+    dartMap Γ plabel outgoing _ (StageRealization.allowed_ports Γ plabel outgoing pin)
+      (vertexMap e) d = e.port d := by
+  apply Subtype.ext
+  apply Prod.ext
+  · exact (e.origin_eq d).symm
+  · exact (e.label_eq d).symm
+
+include e in
+omit [Fintype T] in
+/-- A literal embedding contributes at least one to the exact realization
+count. The event direction is explicit rather than postulated. -/
+theorem realizations_pos : 0 < StageRealization.realizations Γ plabel outgoing pin bar r := by
+  apply Finset.card_pos.mpr
+  refine ⟨vertexMap e,Finset.mem_filter.mpr ⟨Finset.mem_univ _,?_⟩⟩
+  intro d
+  rw [dartMap_eq,dartMap_eq]
+  exact e.reverse_eq d
+
+variable {PV' PD' : Type*} [Fintype PV'] [Fintype PD']
+
+/-- Graph isomorphisms, such as actual marked-chain subdivision, preserve
+all event data, including the root pin and exact directed labels. -/
+def pullback (Γ' : PortGraph PV' PD') (eV : PV' ≃ PV) (eD : PD' ≃ PD)
+    (ho : ∀ d,eV (Γ'.origin d)=Γ.origin (eD d))
+    (hr : ∀ d,eD (Γ'.reverse d)=Γ.reverse (eD d)) :
+    Embedding Γ' (plabel ∘ eD) outgoing (pin ∘ eV) bar r where
+  vertex := eV.toEmbedding.trans e.vertex
+  port := eD.toEmbedding.trans e.port
+  origin_eq d := by simpa only [Function.Embedding.trans_apply,Equiv.toEmbedding_apply,ho] using e.origin_eq (eD d)
+  label_eq d := e.label_eq (eD d)
+  reverse_eq d := by simpa only [Function.Embedding.trans_apply,Equiv.toEmbedding_apply,hr] using e.reverse_eq (eD d)
+  pin_eq v y hy := e.pin_eq (eV v) y hy
+
+end TorsionFreeZeroDivisors.RealizationTransport
+
+namespace TorsionFreeZeroDivisors.TwoSideStage
+open scoped Classical BigOperators
+variable {W : Type*}
+
+/-- Every actual globally compatible embedding is contained in the event
+counted by the two-side first moment. -/
+theorem count_pos (A B : Side) (X : Finset W) (WA : W → A.Word) (WB : W → B.Word)
+    (r : A.Match × B.Match) (w : W) (hw : w∈X)
+    (eA : RealizationTransport.Embedding (ChainSubdivision.graph A.len A.first A.last)
+      (ChainRealization.label A.len (StageExpectation.readWord A.len (WA w))) A.outgoing
+      (ChainRealization.pin A.len A.pin) Types.inverse r.1)
+    (eB : RealizationTransport.Embedding (ChainSubdivision.graph B.len B.first B.last)
+      (ChainRealization.label B.len (StageExpectation.readWord B.len (WB w))) B.outgoing
+      (ChainRealization.pin B.len B.pin) Types.inverse r.2) :
+    0<count A B X WA WB r := by
+  have hm : w∈immersedLabels A B X WA WB :=
+    Finset.mem_filter.mpr ⟨hw,RealizationTransport.immersed eA,RealizationTransport.immersed eB⟩
+  have hp : 0<A.realizations (WA w) r.1*B.realizations (WB w) r.2 :=
+    Nat.mul_pos (RealizationTransport.realizations_pos eA) (RealizationTransport.realizations_pos eB)
+  apply hp.trans_le
+  unfold count
+  exact Finset.single_le_sum (f := fun w => A.realizations (WA w) r.1 * B.realizations (WB w) r.2)
+    (fun _ _ => Nat.zero_le _) hm
+
+end TorsionFreeZeroDivisors.TwoSideStage
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/GroupRing/HomotopyFunctor.lean b/lean/OAI/Algebra/GroupRing/HomotopyFunctor.lean
new file mode 100644
index 0000000000000000000000000000000000000000..6ce73e6c9465f5939cd9b504087f582e007adfdb
--- /dev/null
+++ b/lean/OAI/Algebra/GroupRing/HomotopyFunctor.lean
@@ -0,0 +1,766 @@
+import Mathlib
+import OAI.Algebra.GroupRing.Milnor
+
+namespace OAI
+
+noncomputable section
+
+open Set Metric Topology BigOperators
+open Set Metric Topology
+
+namespace GroupRingTopology.HomotopyFunctor
+open scoped Topology Topology.Homotopy
+universe u v w
+variable {N : Type u} {X : Type v} {Y : Type w} [TopologicalSpace X] [TopologicalSpace Y]
+variable {x : X} {y : Y}
+lemma map_eq_of_homotopy (f g : C(X,Y)) (hf : f x = y) (hg : g x = y)
+    (H : f.Homotopy g) (hH : ∀ t, H (t,x) = y) (a : HomotopyGroup N X x) :
+    map f hf a = map g hg a := by
+  induction a using Quotient.inductionOn with | h p =>
+  apply Quotient.sound
+  refine ⟨{ toHomotopy := H.compContinuousMap p.1,prop' := ?_ }⟩
+  intro t z hz
+  change H (t,p z) = f (p z)
+  rw [GenLoop.boundary p z hz,hH,hf]
+end GroupRingTopology.HomotopyFunctor
+namespace GroupRingTopology.Milnor
+
+section
+open Set Metric Topology BigOperators GroupRingTopology.Simplicial
+open scoped Classical Topology.Homotopy
+universe u v
+variable (G : Type u) [Group G]
+local instance (priority := 2000) (α : Type*) : DecidableEq (ℕ × α) := Classical.decEq (ℕ × α)
+
+abbrev Shapes := Finset (Finset (ℕ × G))
+def basedShapes (S : Shapes G) : Shapes G := insert {(0,1)} S
+def stage (S : Shapes G) := orbitSpan (basedShapes G S)
+
+lemma stage_mono {S T : Shapes G} (h : S ⊆ T) : stage G S ≤ stage G T :=
+  orbitSpan_mono (Finset.insert_subset_insert _ h)
+
+lemma stage_point_face (S : Shapes G) : {(0,1)} ∈ stage G S := by
+  apply orbitSpan_contains (basedShapes G S)
+  · exact ⟨Finset.singleton_nonempty _,by simpa only [Finset.coe_singleton] using Set.injOn_singleton Prod.fst (0,(1:G))⟩
+  · exact ⟨{(0,1)},Finset.mem_insert_self _ _,Finset.Subset.refl _⟩
+
+def stagePoint (S : Shapes G) : Simplicial.Space (stage G S) :=
+  ⟨Finsupp.single (0,1) 1,by intro w; simp only [Finsupp.single_apply]; split_ifs <;> norm_num,
+    by simp,by simpa only [Finsupp.support_single _ one_ne_zero] using stage_point_face G S⟩
+
+def stageIncl (S T : Shapes G) (h : S ⊆ T) : C(Simplicial.Space (stage G S),Simplicial.Space (stage G T)) :=
+  ⟨inclusion _ _ (fun _ hs => stage_mono G h hs),continuous_inclusion _ _ _⟩
+
+lemma stageIncl_point (S T : Shapes G) (h : S ⊆ T) : stageIncl G S T h (stagePoint G S) = stagePoint G T := rfl
+
+variable (N : Type v) [DecidableEq N] [Nonempty N]
+def stageHom (S T : Shapes G) (h : S ⊆ T) :
+    HomotopyGroup N (Simplicial.Space (stage G S)) (stagePoint G S) →*
+      HomotopyGroup N (Simplicial.Space (stage G T)) (stagePoint G T) :=
+  HomotopyFunctor.mapHom (stageIncl G S T h) rfl
+
+instance : DirectedSystem (fun S : Shapes G => HomotopyGroup N (Simplicial.Space (stage G S)) (stagePoint G S))
+    (fun S T h => stageHom G N S T h) where
+  map_self _ a := by
+    exact HomotopyFunctor.map_id a
+  map_map _ _ _ h₁ h₂ a := by
+    exact HomotopyFunctor.map_comp _ _ _ _ a
+
+end
+
+section
+open Set Metric Topology BigOperators GroupRingTopology.Simplicial
+open scoped Classical unitInterval
+universe u
+variable {G : Type u} [Group G]
+local instance (priority := 2000) (α : Type*) : DecidableEq (ℕ × α) := Classical.decEq (ℕ × α)
+
+instance : MulAction G (Space G) where
+  smul g x := map (g * ·) id Function.injective_id x
+  one_smul x := by
+    change map (1 * ·) id Function.injective_id x = x
+    apply Subtype.ext
+    change x.1.mapDomain (fun v => (v.1,1*v.2)) = x.1
+    rw [show (fun v : ℕ × G => (v.1,1*v.2)) = id from funext (fun v => Prod.ext rfl (one_mul v.2))]
+    exact Finsupp.mapDomain_id
+  mul_smul g h x := by
+    change map ((g*h) * ·) id Function.injective_id x = map (g * ·) id Function.injective_id (map (h * ·) id Function.injective_id x)
+    rw [map_comp]
+    have he : (fun a => (g*h)*a) = ((g * ·) ∘ (h * ·)) := funext (mul_assoc g h)
+    rw [he]
+    rfl
+
+instance : ContinuousConstSMul G (Space G) where
+  continuous_const_smul g := (map (g * ·) id Function.injective_id).continuous
+
+lemma smul_weight (g : G) (x : Space G) (v : ℕ × G) : (g • x).1 (v.1,g*v.2) = x.1 v := by
+  change (x.1.mapDomain (fun w => (w.1,g*w.2))) (v.1,g*v.2) = x.1 v
+  apply Finsupp.mapDomain_apply_of_injective (f := fun w : ℕ × G => (w.1,g*w.2))
+  intro a b hab
+  have hfst := congrArg (fun p : ℕ × G => p.1) hab
+  have hsnd := congrArg (fun p : ℕ × G => p.2) hab
+  exact Prod.ext hfst (mul_left_cancel hsnd)
+
+lemma smul_weight_inv (g : G) (x : Space G) (v : ℕ × G) : (g • x).1 v = x.1 (v.1,g⁻¹*v.2) := by
+  simpa only [mul_inv_cancel_left] using smul_weight g x (v.1,g⁻¹*v.2)
+
+lemma exists_disjoint_nhds (x : Space G) :
+    ∃ U ∈ 𝓝 x, ∀ g : G, ((g • ·) '' U ∩ U).Nonempty → g = 1 := by
+  obtain ⟨v,hv⟩ := Simplicial.support_nonempty x.2.2.1
+  let U : Set (Space G) := {y | 0 < y.1 v}
+  have hx : x ∈ U := lt_of_le_of_ne (x.2.1 v) (Ne.symm (Finsupp.mem_support_iff.mp hv))
+  have hU : IsOpen U := isOpen_lt continuous_const (continuous_eval (complex G) v)
+  refine ⟨U,hU.mem_nhds hx,?_⟩
+  intro g hg
+  obtain ⟨z,⟨y,hy,rfl⟩,hgy⟩ := hg
+  have h1 : v ∈ y.1.support := Finsupp.mem_support_iff.mpr (ne_of_gt hy)
+  have h2 : (v.1,g⁻¹*v.2) ∈ y.1.support := by
+    apply Finsupp.mem_support_iff.mpr
+    have hp : 0 < (g • y).1 v := hgy
+    rw [smul_weight_inv] at hp
+    exact ne_of_gt hp
+  have he := congrArg Prod.snd (y.2.2.2.2 h1 h2 rfl)
+  have hi : g⁻¹ = 1 := (mul_right_cancel (he.symm.trans (one_mul v.2).symm))
+  exact inv_eq_one.mp hi
+
+lemma quotientCovering : IsQuotientCoveringMap
+    (Quotient.mk (MulAction.orbitRel G (Space G))) G where
+  __ := isQuotientMap_quotient_mk'
+  continuous_const_smul g := continuous_const_smul g
+  apply_eq_iff_mem_orbit := Quotient.eq''
+  disjoint := exists_disjoint_nhds
+
+end
+open Set Metric Topology BigOperators GroupRingTopology.Simplicial
+open scoped Classical
+universe u v
+variable (G : Type u) [Group G]
+local instance (priority := 2000) (α : Type*) : DecidableEq (ℕ × α) := Classical.decEq (ℕ × α)
+
+abbrev Stage (S : Shapes G) := Simplicial.Space (stage G S)
+
+def stageFull (S : Shapes G) : C(Stage G S,Space G) :=
+  ⟨inclusion _ _ (fun _ h => orbitSpan_le _ h),continuous_inclusion _ _ _⟩
+lemma stageFull_embedding (S : Shapes G) : IsClosedEmbedding (stageFull G S) :=
+  inclusion_closedEmbedding _ _ (fun _ h => orbitSpan_le _ h)
+
+lemma stage_translate (S : Shapes G) (g : G) (s : Face (stage G S)) :
+    s.1.image (fun v => (v.1,g*v.2)) ∈ stage G S := orbitSpan_invariant _ g s.2
+
+def stageSmul (S : Shapes G) (g : G) : C(Stage G S,Stage G S) :=
+  Simplicial.mapC _ _ (fun v => (v.1,g*v.2)) (stage_translate G S g)
+
+instance stageAction (S : Shapes G) : MulAction G (Stage G S) where
+  smul g x := stageSmul G S g x
+  one_smul x := by
+    apply Subtype.ext
+    change x.1.mapDomain (fun v => (v.1,1*v.2)) = x.1
+    rw [show (fun v : ℕ × G => (v.1,1*v.2)) = id from funext (fun v => Prod.ext rfl (one_mul v.2))]
+    exact Finsupp.mapDomain_id
+  mul_smul g h x := by
+    apply Subtype.ext
+    change x.1.mapDomain (fun v => (v.1,(g*h)*v.2)) =
+      (x.1.mapDomain (fun v => (v.1,h*v.2))).mapDomain (fun v => (v.1,g*v.2))
+    rw [← Finsupp.mapDomain_comp]
+    congr 1
+    funext v
+    exact Prod.ext rfl (mul_assoc _ _ _)
+
+instance stageContinuousAction (S : Shapes G) : ContinuousConstSMul G (Stage G S) where
+  continuous_const_smul g := (stageSmul G S g).continuous
+
+lemma stageFull_smul (S : Shapes G) (g : G) (x : Stage G S) :
+    stageFull G S (g • x) = g • stageFull G S x := rfl
+lemma stageIncl_smul (S T : Shapes G) (h : S ⊆ T) (g : G) (x : Stage G S) :
+    stageIncl G S T h (g • x) = g • stageIncl G S T h x := rfl
+
+/-- Any one compact set is contained in a finite-orbit Milnor stage. -/
+lemma compact_controlled {K : Set (Space G)} (hK : IsCompact K) :
+    ∃ S : Shapes G, K ⊆ Set.range (stageFull G S) := by
+  obtain ⟨V,hV⟩ := Simplicial.compact_bounded_vertices (complex G) hK
+  refine ⟨V.powerset,?_⟩
+  intro x hx
+  have hm : x.1.support ∈ stage G V.powerset := by
+    apply orbitSpan_contains (basedShapes G V.powerset) x.2.2.2
+    exact ⟨x.1.support,Finset.mem_insert_of_mem (Finset.mem_powerset.mpr (hV x hx)),Finset.Subset.refl _⟩
+  exact ⟨⟨x.1,x.2.1,x.2.2.1,hm⟩,rfl⟩
+
+/-- Arbitrarily many translates of a compact set have ONE controlled target. -/
+lemma compact_orbit_controlled {K : Set (Space G)} (hK : IsCompact K) :
+    ∃ S : Shapes G, ∀ g : G, (g • ·) '' K ⊆ Set.range (stageFull G S) := by
+  obtain ⟨S,hS⟩ := compact_controlled G hK
+  refine ⟨S,?_⟩
+  intro g y hy
+  obtain ⟨x,hx,rfl⟩ := hy
+  obtain ⟨z,rfl⟩ := hS hx
+  exact ⟨g • z,stageFull_smul G S g z⟩
+
+variable {X : Type v} [TopologicalSpace X] [MulAction G X]
+/-- A compact fundamental set need not be disjoint or a strict domain. -/
+def CompactFundamentalSet : Prop :=
+  ∃ K : Set X, IsCompact K ∧ ∀ x : X, ∃ g : G, ∃ y ∈ K, x = g • y
+
+lemma equivariant_controlled (hX : CompactFundamentalSet G (X := X))
+    (f : C(X,Space G)) (hf : ∀ (g : G) x, f (g • x) = g • f x) :
+    ∃ S : Shapes G, Set.range f ⊆ Set.range (stageFull G S) := by
+  obtain ⟨K,hK,hcov⟩ := hX
+  obtain ⟨S,hS⟩ := compact_orbit_controlled G (hK.image f.continuous)
+  refine ⟨S,?_⟩
+  rintro _ ⟨x,rfl⟩
+  obtain ⟨g,y,hy,rfl⟩ := hcov x
+  rw [hf]
+  exact hS g ⟨f y,⟨y,hy,rfl⟩,rfl⟩
+
+/-- Factoring through a stage preserves topology and equivariance, rather than
+only factoring an underlying set map. -/
+def factorStage (f : C(X,Space G)) (S : Shapes G)
+    (hf : Set.range f ⊆ Set.range (stageFull G S)) : C(X,Stage G S) where
+  toFun x := (hf (Set.mem_range_self x)).choose
+  continuous_toFun := (stageFull_embedding G S).isEmbedding.continuous_iff.mpr (by
+    convert f.continuous using 1
+    funext x
+    exact (hf (Set.mem_range_self x)).choose_spec)
+omit [MulAction G X] in
+lemma factorStage_spec (f : C(X,Space G)) (S : Shapes G)
+    (hf : Set.range f ⊆ Set.range (stageFull G S)) (x : X) :
+    stageFull G S (factorStage G f S hf x) = f x := (hf (Set.mem_range_self x)).choose_spec
+lemma factorStage_smul (f : C(X,Space G)) (S : Shapes G)
+    (hf : Set.range f ⊆ Set.range (stageFull G S))
+    (he : ∀ (g : G) x, f (g • x) = g • f x) (g : G) (x : X) :
+    factorStage G f S hf (g • x) = g • factorStage G f S hf x := by
+  apply (stageFull_embedding G S).injective
+  rw [factorStage_spec,stageFull_smul,factorStage_spec,he]
+end GroupRingTopology.Milnor
+open Set Metric Topology
+namespace GroupRingTopology.Attachment
+universe u v w
+abbrev Disk (n : ℕ) := closedBall (0 : Fin n → ℝ) 1
+abbrev Sphere (n : ℕ) := sphere (0 : Fin n → ℝ) 1
+abbrev OpenDisk (n : ℕ) := ball (0 : Fin n → ℝ) 1
+
+def boundary (n : ℕ) : Sphere n → Disk n :=
+  fun x => ⟨x.1, sphere_subset_closedBall x.2⟩
+def interior (n : ℕ) : OpenDisk n → Disk n :=
+  fun x => ⟨x.1, ball_subset_closedBall x.2⟩
+lemma continuous_boundary (n : ℕ) : Continuous (boundary n) :=
+  continuous_subtype_val.subtype_mk _
+lemma continuous_interior (n : ℕ) : Continuous (interior n) :=
+  continuous_subtype_val.subtype_mk _
+lemma boundary_closedEmbedding (n : ℕ) : IsClosedEmbedding (boundary n) :=
+  (continuous_boundary n).isClosedEmbedding (fun _ _ h => Subtype.ext (congrArg (fun z : Disk n => z.1) h))
+
+variable {X : Type u} [TopologicalSpace X] {ι : Type v} {n : ℕ}
+variable (a : ι → C(Sphere n,X))
+
+/-- The points of an adjunction are the old points and the interiors of the new disks. -/
+def Space (_a : ι → C(Sphere n,X)) := X ⊕ (Σ _ : ι, OpenDisk n)
+
+noncomputable def quotient : (X ⊕ (Σ _ : ι, Disk n)) → Space a := by
+  classical
+  intro z
+  cases z with
+  | inl x => exact Sum.inl x
+  | inr p =>
+    exact if h : p.2.1 ∈ ball (0 : Fin n → ℝ) 1 then Sum.inr ⟨p.1,⟨p.2.1,h⟩⟩
+    else Sum.inl (a p.1 ⟨p.2.1,by
+      have hd := p.2.2
+      simp only [mem_closedBall,mem_ball,mem_sphere] at *
+      exact le_antisymm hd (le_of_not_gt h)⟩)
+
+instance : TopologicalSpace (Space a) := TopologicalSpace.coinduced (quotient a) inferInstance
+
+@[simp] lemma quotient_inl (x : X) : quotient a (Sum.inl x) = Sum.inl x := rfl
+
+@[simp] lemma quotient_interior (i : ι) (x : OpenDisk n) :
+    quotient a (Sum.inr ⟨i,interior n x⟩) = Sum.inr ⟨i,x⟩ := by
+  classical
+  dsimp only [quotient, interior]
+  erw [dite_eq_left x.2]
+
+@[simp] lemma quotient_boundary (i : ι) (x : Sphere n) :
+    quotient a (Sum.inr ⟨i,boundary n x⟩) = Sum.inl (a i x) := by
+  classical
+  have hx : x.1 ∉ ball (0 : Fin n → ℝ) 1 := by
+    simpa only [mem_ball,mem_sphere,x.2,lt_self_iff_false,not_false_eq_true] using
+      (sphere_disjoint_ball.notMem_of_mem_left x.2)
+  dsimp only [quotient, boundary]
+  erw [dite_eq_right hx]
+
+lemma quotient_surjective : Function.Surjective (quotient a) := by
+  intro z
+  cases z with
+  | inl x => exact ⟨Sum.inl x,rfl⟩
+  | inr p => exact ⟨Sum.inr ⟨p.1,interior n p.2⟩,quotient_interior a p.1 p.2⟩
+
+lemma continuous_quotient : Continuous (quotient a) := continuous_coinduced_rng
+
+/-- The old space embeds as a closed subspace of the adjunction. -/
+def base : X → Space a := Sum.inl
+noncomputable def cell (i : ι) : C(Disk n,Space a) :=
+  ⟨fun x => quotient a (Sum.inr ⟨i,x⟩),
+    (continuous_quotient a).comp (continuous_inr.comp continuous_sigmaMk)⟩
+lemma continuous_base : Continuous (base a) :=
+  (continuous_quotient a).comp continuous_inl
+
+@[simp] lemma cell_boundary (i : ι) (x : Sphere n) :
+    cell a i (boundary n x) = base a (a i x) := quotient_boundary a i x
+@[simp] lemma cell_interior (i : ι) (x : OpenDisk n) :
+    cell a i (interior n x) = Sum.inr ⟨i,x⟩ := quotient_interior a i x
+
+lemma continuous_iff {Y : Type w} [TopologicalSpace Y] (f : Space a → Y) :
+    Continuous f ↔ Continuous (f ∘ base a) ∧ ∀ i, Continuous (f ∘ cell a i) := by
+  change Continuous[TopologicalSpace.coinduced (quotient a) inferInstance,_] f ↔ _
+  rw [continuous_coinduced_dom,continuous_sum_dom,continuous_sigma_iff]
+  rfl
+
+lemma isClosed_iff (S : Set (Space a)) :
+    IsClosed S ↔ IsClosed (base a ⁻¹' S) ∧ ∀ i, IsClosed (cell a i ⁻¹' S) := by
+  change @IsClosed _ (TopologicalSpace.coinduced (quotient a) inferInstance) S ↔ _
+  rw [isClosed_coinduced,isClosed_sum_iff,isClosed_sigma_iff]
+  rfl
+
+lemma cell_preimage_base_image (i : ι) (S : Set X) :
+    cell a i ⁻¹' (base a '' S) = boundary n '' ((a i) ⁻¹' S) := by
+  classical
+  ext d
+  by_cases h : d.1 ∈ ball (0 : Fin n → ℝ) 1
+  · have hd : d = interior n ⟨d.1,h⟩ := rfl
+    rw [hd]
+    simp only [Set.mem_preimage,cell_interior,base,Set.mem_image]
+    constructor
+    · rintro ⟨x,_,hx⟩; cases hx
+    · rintro ⟨x,_,hx⟩
+      have heq := congrArg (fun d : Disk n => d.1) hx
+      have hh : x.1 ∈ ball (0 : Fin n → ℝ) 1 := heq ▸ h
+      exact False.elim ((sphere_disjoint_ball.notMem_of_mem_left x.2) hh)
+  · let x : Sphere n := ⟨d.1,by
+      have hd := d.2
+      simp only [mem_closedBall,mem_ball,mem_sphere] at *
+      exact le_antisymm hd (le_of_not_gt h)⟩
+    have hd : d = boundary n x := rfl
+    rw [hd]
+    simp only [Set.mem_preimage,cell_boundary,Set.mem_image]
+    constructor
+    · rintro ⟨y,hy,hyx⟩
+      have heq : y = a i x := Sum.inl_injective hyx
+      exact ⟨x,heq ▸ hy,rfl⟩
+    · rintro ⟨y,hy,hyx⟩
+      have heq : y = x := Subtype.ext (congrArg (fun d : Disk n => d.1) hyx)
+      subst y
+      exact ⟨a i x,hy,rfl⟩
+
+lemma base_isClosedMap : IsClosedMap (base a) := by
+  intro S hS
+  rw [isClosed_iff]
+  constructor
+  · change IsClosed ((Sum.inl : X → X ⊕ (Σ _ : ι, OpenDisk n)) ⁻¹' Sum.inl '' S)
+    simpa only [Set.preimage_image_eq _ Sum.inl_injective] using hS
+  · intro i
+    rw [cell_preimage_base_image]
+    exact (boundary_closedEmbedding n).isClosedMap _ (hS.preimage (a i).continuous)
+
+lemma base_closedEmbedding : IsClosedEmbedding (base a) :=
+  IsClosedEmbedding.of_continuous_injective_isClosedMap
+    (continuous_base a) Sum.inl_injective (base_isClosedMap a)
+
+/-- The universal mapping property, with all attaching equations explicit. -/
+noncomputable def lift {Y : Type w} [TopologicalSpace Y] (f : C(X,Y))
+    (g : ι → C(Disk n,Y)) (h : ∀ i x, g i (boundary n x) = f (a i x)) : C(Space a,Y) := by
+  classical
+  let F : Space a → Y := Sum.elim f (fun p => g p.1 (interior n p.2))
+  have hcell (i : ι) : F ∘ cell a i = g i := by
+    funext d
+    by_cases hd : d.1 ∈ ball (0 : Fin n → ℝ) 1
+    · have heq : d = interior n ⟨d.1,hd⟩ := rfl
+      rw [heq,Function.comp_apply,cell_interior]
+      rfl
+    · let x : Sphere n := ⟨d.1,by
+        have hm := d.2
+        simp only [mem_closedBall,mem_ball,mem_sphere] at *
+        exact le_antisymm hm (le_of_not_gt hd)⟩
+      have heq : d = boundary n x := rfl
+      rw [heq,Function.comp_apply,cell_boundary]
+      exact (h i x).symm
+  exact ⟨F,(continuous_iff a F).mpr ⟨f.continuous,fun i => by rw [hcell]; exact (g i).continuous⟩⟩
+
+@[simp] lemma lift_base {Y : Type w} [TopologicalSpace Y] (f : C(X,Y))
+    (g : ι → C(Disk n,Y)) (h : ∀ i x, g i (boundary n x) = f (a i x)) (x : X) :
+    lift a f g h (base a x) = f x := rfl
+
+@[simp] lemma lift_cell {Y : Type w} [TopologicalSpace Y] (f : C(X,Y))
+    (g : ι → C(Disk n,Y)) (h : ∀ i x, g i (boundary n x) = f (a i x))
+    (i : ι) (d : Disk n) : lift a f g h (cell a i d) = g i d := by
+  classical
+  by_cases hd : d.1 ∈ ball (0 : Fin n → ℝ) 1
+  · have heq : d = interior n ⟨d.1,hd⟩ := rfl
+    rw [heq,cell_interior]
+    rfl
+  · let x : Sphere n := ⟨d.1,by
+      have hm := d.2
+      simp only [mem_closedBall,mem_ball,mem_sphere] at *
+      exact le_antisymm hm (le_of_not_gt hd)⟩
+    have heq : d = boundary n x := rfl
+    rw [heq,cell_boundary,lift_base,h]
+
+lemma lift_unique {Y : Type w} [TopologicalSpace Y] (f g : C(Space a,Y))
+    (hb : ∀ x, f (base a x) = g (base a x))
+    (hc : ∀ i d, f (cell a i d) = g (cell a i d)) : f = g := by
+  ext z
+  obtain ⟨q,rfl⟩ := quotient_surjective a z
+  cases q with
+  | inl x => exact hb x
+  | inr p => exact hc p.1 p.2
+
+lemma interior_openEmbedding (n : ℕ) : IsOpenEmbedding (interior n) :=
+  .inclusion ball_subset_closedBall (isOpen_ball.preimage continuous_subtype_val)
+
+/-- Open disks are inserted as genuine open embeddings. -/
+def openCell (i : ι) : OpenDisk n → Space a := fun x => Sum.inr ⟨i,x⟩
+
+lemma openCell_eq (i : ι) : openCell a i = cell a i ∘ interior n := by
+  funext x
+  exact (cell_interior a i x).symm
+
+lemma quotient_preimage_openCell_image (i : ι) (S : Set (OpenDisk n)) :
+    quotient a ⁻¹' (openCell a i '' S) =
+      Sum.inr '' (Sigma.mk i '' (interior n '' S)) := by
+  classical
+  ext q
+  cases q with
+  | inl x =>
+    simp only [Set.mem_preimage,quotient_inl,Set.mem_image]
+    constructor
+    · rintro ⟨y,_,hy⟩; cases hy
+    · rintro ⟨y,_,hy⟩; cases hy
+  | inr p =>
+    by_cases hp : p.2.1 ∈ ball (0 : Fin n → ℝ) 1
+    · have heq : p.2 = interior n ⟨p.2.1,hp⟩ := rfl
+      change (∃ x ∈ S, openCell a i x = quotient a (Sum.inr ⟨p.1,p.2⟩)) ↔ _
+      rw [heq,quotient_interior]
+      constructor
+      · rintro ⟨x,hx,he⟩
+        have hh : (⟨i,x⟩ : Σ _ : ι, OpenDisk n) = ⟨p.1,⟨p.2.1,hp⟩⟩ := Sum.inr_injective he
+        have hh' : (⟨i,interior n x⟩ : Σ _ : ι, Disk n) = ⟨p.1,p.2⟩ :=
+          congrArg (fun p : Σ _ : ι, OpenDisk n => (⟨p.1,interior n p.2⟩ : Σ _ : ι, Disk n)) hh
+        exact ⟨⟨i,interior n x⟩,⟨interior n x,⟨x,hx,rfl⟩,rfl⟩,congrArg Sum.inr hh'⟩
+      · rintro ⟨y,⟨d,⟨x,hx,hxd⟩,hdy⟩,hy⟩
+        subst d; subst y
+        have hh := Sum.inr_injective hy
+        have hi : i = p.1 := congrArg Sigma.fst hh
+        subst i
+        have hh' : interior n x = interior n ⟨p.2.1,hp⟩ := eq_of_heq (Sigma.mk.inj_iff.mp hh).2
+        have he : x = ⟨p.2.1,hp⟩ := (interior_openEmbedding n).injective hh'
+        exact ⟨x,hx,by subst x; rfl⟩
+    · let x : Sphere n := ⟨p.2.1,by
+        have hm := p.2.2
+        simp only [mem_closedBall,mem_ball,mem_sphere] at *
+        exact le_antisymm hm (le_of_not_gt hp)⟩
+      have heq : p.2 = boundary n x := rfl
+      change (∃ y ∈ S, openCell a i y = quotient a (Sum.inr ⟨p.1,p.2⟩)) ↔ _
+      rw [heq,quotient_boundary]
+      constructor
+      · rintro ⟨y,_,hy⟩; cases hy
+      · rintro ⟨y,⟨d,⟨z,_,hzd⟩,hdy⟩,hy⟩
+        subst d; subst y
+        have hh := Sum.inr_injective hy
+        have hi : i = p.1 := congrArg Sigma.fst hh
+        subst i
+        have hh' : interior n z = boundary n x := eq_of_heq (Sigma.mk.inj_iff.mp hh).2
+        have hh'' := congrArg (fun d : Disk n => d.1) hh'
+        exact False.elim (hp (hh'' ▸ z.2))
+
+lemma openCell_openEmbedding (i : ι) : IsOpenEmbedding (openCell a i) := by
+  apply IsOpenEmbedding.of_continuous_injective_isOpenMap
+  · rw [openCell_eq]
+    exact (cell a i).continuous.comp (continuous_interior n)
+  · intro x y h
+    exact eq_of_heq (Sigma.mk.inj_iff.mp (Sum.inr_injective h)).2
+  · intro S hS
+    change @IsOpen _ (TopologicalSpace.coinduced (quotient a) inferInstance) _
+    rw [isOpen_coinduced,quotient_preimage_openCell_image]
+    exact isOpenMap_inr _ (isOpenMap_sigmaMk _ ((interior_openEmbedding n).isOpenMap S hS))
+
+/-- Real-valued maps on the old space extend over any family of attached disks. -/
+lemma exists_real_extension (f : C(X,ℝ)) :
+    ∃ F : C(Space a,ℝ), ∀ x, F (base a x) = f x := by
+  classical
+  have hi (i : ι) : ∃ g : C(Disk n,ℝ), ∀ x, g (boundary n x) = f (a i x) := by
+    obtain ⟨g,hg⟩ := (f.comp (a i)).exists_extension' (boundary_closedEmbedding n)
+    exact ⟨g,fun x => congrFun hg x⟩
+  choose g hg using hi
+  exact ⟨lift a f g hg,fun x => lift_base a f g hg x⟩
+
+/-- Functional Hausdorffness is convenient for iterated attachments: separating
+functions, unlike chosen open neighborhoods, extend across every new disk. -/
+def RealSeparated (Y : Type*) [TopologicalSpace Y] : Prop :=
+  ∀ x y : Y, x ≠ y → ∃ f : C(Y,ℝ), f x ≠ f y
+
+lemma RealSeparated.t2Space {Y : Type*} [TopologicalSpace Y] (h : RealSeparated Y) :
+    T2Space Y := by
+  constructor
+  intro x y hxy
+  obtain ⟨f,hf⟩ := h x y hxy
+  exact separated_by_continuous f.continuous hf
+
+lemma realSeparated_of_tychonoff {Y : Type*} [TopologicalSpace Y]
+    [T1Space Y] [CompletelyRegularSpace Y] : RealSeparated Y := by
+  intro x y hxy
+  obtain ⟨f,hf,hfx,hfy⟩ := CompletelyRegularSpace.completely_regular x {y} isClosed_singleton
+    (by simpa only [Set.mem_singleton_iff] using hxy)
+  refine ⟨⟨fun q => (f q : ℝ),continuous_subtype_val.comp hf⟩,?_⟩
+  change (f x : ℝ) ≠ (f y : ℝ)
+  rw [hfx,hfy (Set.mem_singleton y)]
+  norm_num
+
+lemma exists_interior_separator [T1Space X] (i : ι) (x : OpenDisk n) (z : Space a)
+    (hxz : openCell a i x ≠ z) :
+    ∃ F : C(Space a,ℝ), F (openCell a i x) = 1 ∧ F z = 0 := by
+  classical
+  let K : Set (Disk n) := Set.range (boundary n) ∪ cell a i ⁻¹' {z}
+  have hKc : IsClosed K := by
+    -- Only the part of the inverse image inside this disk is used; the point
+    -- set is closed directly, without presupposing Hausdorffness of the adjunction.
+    have hz : IsClosed (cell a i ⁻¹' {z}) := by
+      cases z with
+      | inl y =>
+        have heq : ({Sum.inl y} : Set (Space a)) = base a '' {y} := by
+          exact (Set.image_singleton (f := base a) (a := y)).symm
+        erw [heq,cell_preimage_base_image]
+        -- For base points this will follow from a T1 hypothesis below.
+        exact (boundary_closedEmbedding n).isClosedMap _
+          (isClosed_singleton.preimage (a i).continuous)
+      | inr p =>
+        have heq : ({Sum.inr p} : Set (Space a)) = openCell a p.1 '' {p.2} := by
+          exact (Set.image_singleton (f := openCell a p.1) (a := p.2)).symm
+        have hpre := quotient_preimage_openCell_image a p.1 ({p.2} : Set (OpenDisk n))
+        have hclosed : IsClosed (quotient a ⁻¹' {Sum.inr p}) := by
+          erw [heq,hpre]
+          exact isClosedMap_inr _ (isClosedMap_sigmaMk _
+            ((isCompact_singleton.image (continuous_interior n)).isClosed))
+        exact hclosed.preimage (continuous_inr.comp continuous_sigmaMk)
+    exact (boundary_closedEmbedding n).isClosed_range.union hz
+  have hxK : interior n x ∉ K := by
+    rintro (hx | hx)
+    · obtain ⟨s,hs⟩ := hx
+      have heq := congrArg (fun d : Disk n => d.1) hs
+      exact sphere_disjoint_ball.notMem_of_mem_left s.2 (heq ▸ x.2)
+    · apply hxz
+      change cell a i (interior n x) = z at hx
+      exact (cell_interior a i x).symm.trans hx
+  obtain ⟨f,hf0,hf1,_⟩ := exists_continuous_zero_one_of_isClosed hKc
+    (isClosed_singleton (x := interior n x)) (Set.disjoint_singleton_right.mpr hxK)
+  let g : ι → C(Disk n,ℝ) := fun j => if j = i then f else ContinuousMap.const _ 0
+  have hgb (j : ι) (s : Sphere n) : g j (boundary n s) = (0 : ℝ) := by
+    dsimp [g]
+    split_ifs with hji
+    · exact hf0 (Set.mem_union_left _ (Set.mem_range_self s))
+    · rfl
+  let F : C(Space a,ℝ) := lift a (ContinuousMap.const _ 0) g hgb
+  have hFcell (j : ι) (d : Disk n) : F (cell a j d) = g j d := lift_cell a _ _ _ j d
+  refine ⟨F,?_,?_⟩
+  · change F (Sum.inr ⟨i,x⟩) = 1
+    rw [← cell_interior a i x,hFcell]
+    simpa only [g,ite_eq_left rfl,Pi.one_apply] using hf1 (Set.mem_singleton _)
+  · cases z with
+    | inl y => exact lift_base a _ _ _ y
+    | inr p =>
+      rw [← cell_interior a p.1 p.2,hFcell]
+      by_cases hpi : p.1 = i
+      · have hm : interior n p.2 ∈ K := by
+          right
+          change cell a i (interior n p.2) = Sum.inr p
+          rw [cell_interior]
+          cases p with
+          | mk j y =>
+            dsimp only at hpi
+            subst j
+            rfl
+        simpa only [g,ite_eq_left hpi,Pi.zero_apply] using hf0 hm
+      · simp only [g,ite_eq_right hpi,ContinuousMap.const_apply]
+
+lemma realSeparated (hX : RealSeparated X) : RealSeparated (Space a) := by
+  classical
+  let : T2Space X := hX.t2Space
+  intro x y hxy
+  cases x with
+  | inl x =>
+    cases y with
+    | inl y =>
+      have hne : x ≠ y := fun heq => hxy (congrArg Sum.inl heq)
+      obtain ⟨f,hf⟩ := hX x y hne
+      obtain ⟨F,hF⟩ := exists_real_extension a f
+      refine ⟨F,?_⟩
+      change F (base a x) ≠ F (base a y)
+      rwa [hF,hF]
+    | inr p =>
+      obtain ⟨F,hF1,hF0⟩ := exists_interior_separator a p.1 p.2 (Sum.inl x)
+        (by exact fun h => hxy h.symm)
+      refine ⟨F,?_⟩
+      change F (Sum.inl x) ≠ F (openCell a p.1 p.2)
+      rw [hF0,hF1]
+      norm_num
+  | inr p =>
+    obtain ⟨F,hF1,hF0⟩ := exists_interior_separator a p.1 p.2 y hxy
+    refine ⟨F,?_⟩
+    change F (openCell a p.1 p.2) ≠ F y
+    rw [hF1,hF0]
+    norm_num
+
+lemma t2Space (hX : RealSeparated X) : T2Space (Space a) := (realSeparated a hX).t2Space
+
+variable [Nonempty X]
+
+/-- The characteristic map is defined on the entire parameter space, as required
+by Mathlib's classical CW definition, but only its closed-disk values matter. -/
+def characteristic (i : ι) (x : Fin n → ℝ) : Space a := by
+  classical
+  exact if hx : x ∈ closedBall 0 1 then cell a i ⟨x,hx⟩ else base a (Classical.choice ‹Nonempty X›)
+
+lemma characteristic_disk (i : ι) (d : Disk n) :
+    characteristic a i d.1 = cell a i d := by
+  simp only [characteristic,dite_eq_left d.2]
+
+lemma characteristic_open (i : ι) (x : OpenDisk n) :
+    characteristic a i x.1 = openCell a i x := by
+  exact (characteristic_disk a i (interior n x)).trans (cell_interior a i x)
+
+lemma characteristic_bijOn (i : ι) :
+    Set.BijOn (characteristic a i) (ball 0 1) (Set.range (openCell a i)) := by
+  constructor
+  · intro x hx
+    exact ⟨⟨x,hx⟩,(characteristic_open a i ⟨x,hx⟩).symm⟩
+  constructor
+  · intro x hx y hy hxy
+    have hxy' : openCell a i ⟨x,hx⟩ = openCell a i ⟨y,hy⟩ := by
+      rwa [characteristic_open a i ⟨x,hx⟩,characteristic_open a i ⟨y,hy⟩] at hxy
+    exact congrArg Subtype.val ((openCell_openEmbedding a i).injective hxy')
+  · rintro z ⟨x,rfl⟩
+    exact ⟨x.1,x.2,characteristic_open a i x⟩
+
+def characteristicPE (i : ι) : PartialEquiv (Fin n → ℝ) (Space a) :=
+  (characteristic_bijOn a i).toPartialEquiv _ _ _
+
+lemma characteristicPE_continuousOn (i : ι) :
+    ContinuousOn (characteristicPE a i) (closedBall 0 1) := by
+  rw [continuousOn_iff_continuous_domRestrict]
+  have heq : (closedBall (0:Fin n→ℝ) 1).domRestrict (characteristicPE a i) = cell a i := by
+    funext x
+    exact characteristic_disk a i x
+  rw [heq]
+  exact (cell a i).continuous
+
+lemma characteristicPE_continuousOn_symm (i : ι) :
+    ContinuousOn (characteristicPE a i).symm (characteristicPE a i).target := by
+  let e := characteristicPE a i
+  have he : IsEmbedding (e.source.domRestrict e) := by
+    have heq : e.source.domRestrict e = openCell a i := by
+      funext x
+      exact characteristic_open a i x
+    rw [heq]
+    exact (openCell_openEmbedding a i).isEmbedding
+  let H : e.source ≃ₜ e.target := e.toEquiv.toHomeomorphOfIsInducing
+    (he.isInducing.codRestrict (fun x => e.map_source x.2))
+  rw [continuousOn_iff_continuous_domRestrict]
+  exact continuous_subtype_val.comp H.symm.continuous
+
+lemma characteristicPE_image_ball (i : ι) :
+    characteristicPE a i '' ball 0 1 = Set.range (openCell a i) :=
+  (characteristic_bijOn a i).image_eq
+
+lemma characteristicPE_image_closedBall (i : ι) :
+    characteristicPE a i '' closedBall 0 1 = Set.range (cell a i) := by
+  ext z
+  constructor
+  · rintro ⟨x,hx,rfl⟩
+    exact ⟨⟨x,hx⟩,(characteristic_disk a i ⟨x,hx⟩).symm⟩
+  · rintro ⟨x,rfl⟩
+    exact ⟨x.1,x.2,characteristic_disk a i x⟩
+
+abbrev CellIndex (m n : ℕ) (ι : Type v) := ULift.{u} (PLift (m = n) × ι)
+
+def cellMap (m : ℕ) (i : CellIndex.{u,v} m n ι) :
+    PartialEquiv (Fin m → ℝ) (Space a) := by
+  obtain ⟨⟨⟨hm⟩,i⟩⟩ := i
+  subst m
+  exact characteristicPE a i
+
+/-- Attaching disks is a classical relative CW complex, not merely an abstract
+cell-complex object in a category. -/
+@[instance_reducible]
+def relCWComplex : RelCWComplex (Set.univ : Set (Space a)) (Set.range (base a)) where
+  cell m := CellIndex.{u,v} m n ι
+  map := cellMap a
+  source_eq := by
+    rintro m ⟨⟨⟨hm⟩,i⟩⟩
+    subst m
+    rfl
+  continuousOn := by
+    rintro m ⟨⟨⟨hm⟩,i⟩⟩
+    subst m
+    exact characteristicPE_continuousOn a i
+  continuousOn_symm := by
+    rintro m ⟨⟨⟨hm⟩,i⟩⟩
+    subst m
+    exact characteristicPE_continuousOn_symm a i
+  pairwiseDisjoint' := by
+    rintro ⟨m,⟨⟨⟨hm⟩,i⟩⟩⟩ _ ⟨k,⟨⟨⟨hk⟩,j⟩⟩⟩ _ hne
+    subst m; subst k
+    change Disjoint (characteristicPE a i '' ball 0 1) (characteristicPE a j '' ball 0 1)
+    rw [characteristicPE_image_ball,characteristicPE_image_ball]
+    apply Set.disjoint_left.mpr
+    rintro z ⟨x,rfl⟩ ⟨y,h⟩
+    have hij : j = i := congrArg Sigma.fst (Sum.inr_injective h)
+    subst j
+    exact hne rfl
+  disjointBase' := by
+    rintro m ⟨⟨⟨hm⟩,i⟩⟩
+    subst m
+    change Disjoint (characteristicPE a i '' ball 0 1) _
+    rw [characteristicPE_image_ball]
+    apply Set.disjoint_left.mpr
+    rintro z ⟨x,rfl⟩ ⟨y,h⟩
+    cases h
+  mapsTo := by
+    rintro m ⟨⟨⟨hm⟩,i⟩⟩
+    subst m
+    refine ⟨fun _ => ∅,?_⟩
+    intro x hx
+    left
+    refine ⟨a i ⟨x,hx⟩,?_⟩
+    change base a (a i ⟨x,hx⟩) = characteristic a i x
+    exact (cell_boundary a i ⟨x,hx⟩).symm.trans
+      (characteristic_disk a i (boundary n ⟨x,hx⟩)).symm
+  closed' := by
+    intro A _ hA
+    apply (isClosed_iff a A).mpr
+    constructor
+    · have h := hA.2.preimage (continuous_base a)
+      convert h using 1
+      ext x
+      simp only [Set.mem_preimage,Set.mem_inter_iff,Set.mem_range_self,and_true]
+    · intro i
+      have h := (hA.1 n ⟨⟨⟨rfl⟩,i⟩⟩).preimage (cell a i).continuous
+      change IsClosed ((cell a i) ⁻¹' (A ∩ characteristicPE a i '' closedBall 0 1)) at h
+      rw [characteristicPE_image_closedBall] at h
+      convert h using 1
+      ext x
+      simp only [Set.mem_preimage,Set.mem_inter_iff,Set.mem_range_self,and_true]
+  isClosedBase := (base_closedEmbedding a).isClosed_range
+  union' := by
+    apply Set.eq_univ_of_forall
+    intro z
+    cases z with
+    | inl x => exact Or.inl ⟨x,rfl⟩
+    | inr p =>
+      right
+      refine Set.mem_iUnion.mpr ⟨n,Set.mem_iUnion.mpr ⟨⟨⟨⟨rfl⟩,p.1⟩⟩,?_⟩⟩
+      change Sum.inr p ∈ characteristicPE a p.1 '' closedBall 0 1
+      rw [characteristicPE_image_closedBall]
+      exact ⟨interior n p.2,cell_interior a p.1 p.2⟩
+
+end GroupRingTopology.Attachment
+open Set Metric Topology
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/GroupRing/HomotopyTracks.lean b/lean/OAI/Algebra/GroupRing/HomotopyTracks.lean
new file mode 100644
index 0000000000000000000000000000000000000000..30b2724d0645789aee8e1b1bd50b6179aa1bc000
--- /dev/null
+++ b/lean/OAI/Algebra/GroupRing/HomotopyTracks.lean
@@ -0,0 +1,58 @@
+import Mathlib
+import OAI.Algebra.GroupRing.LoopTranspose
+
+namespace OAI
+
+
+
+section
+namespace TorsionFreeZeroDivisors.HomotopyTracks
+open scoped unitInterval
+noncomputable section
+universe u v
+variable {X : Type u} {Y : Type v} [TopologicalSpace X] [TopologicalSpace Y]
+variable {x : X} {y : Y} {f : C(X,Y)} (hx : f x=y)
+def mapped (p : Path x x) : Path y y := (p.map f.continuous).cast hx.symm hx.symm
+variable (H : f.Homotopy (.const _ y)) (hH : ∀t,H (t,x)=y)
+def track (p : Path x x) : Path (mapped hx p) (Path.refl y) where
+  toFun t := {
+    toFun s := H (t,p s)
+    continuous_toFun := H.continuous.comp (continuous_const.prodMk p.continuous)
+    source' := by rw [p.source];exact hH t
+    target' := by rw [p.target];exact hH t }
+  continuous_toFun := Path.continuous_uncurry_iff.mp
+    (H.continuous.comp (continuous_fst.prodMk (p.continuous.comp continuous_snd)))
+  source' := by ext s;exact H.apply_zero (p s)
+  target' := by ext s;exact H.apply_one (p s)
+variable (D : C(X,Path y y)) (hD : D x=Path.refl y)
+def run : (ContinuousMap.const X y).Homotopy (.const _ y) where
+  toFun z := D z.2 z.1
+  continuous_toFun := (Path.continuous_uncurry_iff.mpr D.continuous).comp continuous_swap
+  map_zero_left _z := Path.source _
+  map_one_left _z := Path.target _
+include hD in
+lemma run_base (t : unitInterval) : run D (t,x)=y := by
+  change D x t=y
+  rw [hD];rfl
+include hH hD in
+lemma trans_base (t : unitInterval) : (H.trans (run D)) (t,x)=y := by
+  rw [ContinuousMap.Homotopy.trans_apply]
+  split_ifs
+  · exact hH _
+  · exact run_base D hD _
+lemma track_trans (p : Path x x) :
+    track hx (H.trans (run D)) (trans_base H hH D hD) p=
+      (track hx H hH p).trans (LoopTranspose.turnPath y ((p.map D.continuous).cast hD.symm hD.symm)) := by
+  ext t s
+  change (H.trans (run D)) (t,p s)=((track hx H hH p).trans
+    (LoopTranspose.turnPath y ((p.map D.continuous).cast hD.symm hD.symm))) t s
+  rw [ContinuousMap.Homotopy.trans_apply,Path.trans_apply]
+  split_ifs <;> rfl
+end
+end TorsionFreeZeroDivisors.HomotopyTracks
+
+end
+
+
+
+end OAI
diff --git a/lean/OAI/Algebra/GroupRing/IndexedCells.lean b/lean/OAI/Algebra/GroupRing/IndexedCells.lean
new file mode 100644
index 0000000000000000000000000000000000000000..36d7cc8043ded0644e71de87016ccf6dda543b9c
--- /dev/null
+++ b/lean/OAI/Algebra/GroupRing/IndexedCells.lean
@@ -0,0 +1,69 @@
+import Mathlib
+import OAI.Algebra.GroupRing.GraphConeCW
+import OAI.Algebra.GroupRing.DiskHomotopy
+
+namespace OAI
+
+
+
+section
+namespace TorsionFreeZeroDivisors.IndexedCells
+open Set Topology GroupRingTopology GroupRingTopology.Attachment GroupRingTopology.PathExtension
+noncomputable section
+variable {G S Q : Type} [Group G] [TopologicalSpace G] [DiscreteTopology G]
+  (s : S→G) (w : Q→FreeGroup S) (hw : ∀i,FreeGroup.lift s (w i)=1)
+include hw in
+omit [TopologicalSpace G] [DiscreteTopology G] in
+lemma in_range (r : FreeGroup S) (hr : r∈Set.range w) : FreeGroup.lift s r=1 := by
+  rcases hr with ⟨i,rfl⟩;exact hw i
+def loop (i : Q) : Path (Cayley.vertex s 1) (Cayley.vertex s 1) :=
+  Cayley.relatorLoop s (Set.range w) (in_range s w hw) ⟨w i,⟨i,rfl⟩⟩
+lemma loop_equal (i : Q) : PathExtension.Q.Equal (Path.Homotopic.Quotient.mk (loop s w hw i)) (Cayley.wordLift s (w i)).2 :=
+  Cayley.relatorLoop_equal s (Set.range w) (in_range s w hw) ⟨w i,⟨i,rfl⟩⟩
+def attaching (i : Q) : C(Sphere 2,Cayley.Graph s) := LoopSphere.map (loop s w hw i)
+abbrev Cover := CellPresentation.Cover s (attaching s w hw)
+abbrev Base := CellPresentation.Base s (attaching s w hw)
+def inclusion : C(Cayley.Graph s,Cover s w hw) := CellPresentation.inclusion s (attaching s w hw)
+lemma mapped_loop (i : Q) : ((loop s w hw i).map (inclusion s w hw).continuous).Homotopic
+    (Path.refl (inclusion s w hw (Cayley.vertex s 1))) := by
+  apply LoopSphere.homotopic_map_of_fill _ _ (cell _ ((1:G),i))
+  intro z
+  change cell (equivariantFamily (G:=G) (attaching s w hw)) ((1:G),i) (boundary 2 z)=_
+  erw [cell_boundary]
+  simp only [equivariantFamily,ContinuousMap.coe_mk,one_smul]
+  rfl
+lemma wordLift_rel (i : Q) : CellPresentation.wordLift s (attaching s w hw) (w i)=1 := by
+  apply PathExtension.ext (a:=CellPresentation.wordLift s (attaching s w hw) (w i)) (b:=1)
+    ((Cayley.wordLift_fst s (w i)).trans (hw i))
+  apply PathExtension.Q.Equal.path
+  apply (PathExtension.mapFun_equal (inclusion s w hw) (CellPresentation.inclusion_smul s (attaching s w hw))
+    (Cayley.vertex s 1) (Cayley.wordLift s (w i))).trans
+  apply ((loop_equal s w hw i).map (inclusion s w hw)).symm.trans
+  apply (PathExtension.Q.Equal.ofEq (Quotient.sound (mapped_loop s w hw i))).trans
+  exact PathExtension.one_path_equal.symm
+variable (hs : Function.Surjective (FreeGroup.lift s))
+  (hker : (FreeGroup.lift s).ker=Subgroup.normalClosure (Set.range w))
+include hs hker in
+lemma cover_simplyConnected : SimplyConnectedSpace (Cover s w hw) :=
+  CellPresentation.cover_simplyConnected s (attaching s w hw) w (wordLift_rel s w hw) hs hker
+
+def translated (g : G) (i : Q) : Path (Cayley.vertex s g) (Cayley.vertex s g) :=
+  ((loop s w hw i).map (smulMap g).continuous).cast
+    (by simp only [smulMap,ContinuousMap.coe_mk,Cayley.smul_vertex,_root_.mul_one])
+    (by simp only [smulMap,ContinuousMap.coe_mk,Cayley.smul_vertex,_root_.mul_one])
+lemma translated_equal (g : G) (i : Q) : PathExtension.Q.Equal
+    (Path.Homotopic.Quotient.mk (translated s w hw g i)) ((Cayley.wordLift s (w i)).2.map (smulMap g)) :=
+  (PathExtension.Q.cast_equal _ _ _).trans ((loop_equal s w hw i).map _)
+lemma attaching_translated (g : G) (i : Q) (z : Sphere 2) :
+    equivariantFamily (G:=G) (attaching s w hw) (g,i) z=LoopSphere.map (translated s w hw g i) z := by
+  exact (ContinuousMap.congr_fun (HomotopyTracks.natural_cast
+    (f:=smulMap g) (by simp only [smulMap,ContinuousMap.coe_mk,Cayley.smul_vertex,_root_.mul_one])
+    (loop s w hw i)) z).symm
+end
+end TorsionFreeZeroDivisors.IndexedCells
+
+end
+
+
+
+end OAI
diff --git a/lean/OAI/Algebra/GroupRing/IntervalSelfLinks.lean b/lean/OAI/Algebra/GroupRing/IntervalSelfLinks.lean
new file mode 100644
index 0000000000000000000000000000000000000000..5cecaa0c232725dde200fa234ef6710f1c800091
--- /dev/null
+++ b/lean/OAI/Algebra/GroupRing/IntervalSelfLinks.lean
@@ -0,0 +1,419 @@
+import Mathlib
+import OAI.Algebra.GroupRing.MatchedLabels
+
+namespace OAI
+
+noncomputable section
+
+namespace TorsionFreeZeroDivisors.IntervalSelfLinks
+open scoped Classical
+
+/-- Integer positions of one actual comparison within a single block. -/
+def selfSlice (L U l u : ℤ) (rev : Bool) (a : ℤ) : Finset ℤ :=
+  (Finset.Ico L U ∩ Finset.Ico l u).filter
+    (fun q => (if rev then a-1-q else q+a) ∈ Finset.Ico L U)
+
+theorem reflection_slice (L U l u a : ℤ) :
+    selfSlice L U l u true a =
+      Finset.Ico (max L (max l (a-U))) (min U (min u (a-L))) := by
+  ext q
+  simp only [selfSlice,Finset.mem_filter,Finset.mem_inter,Finset.mem_Ico,
+    ite_true,max_le_iff,lt_min_iff]
+  omega
+
+theorem translation_slice (L U l u a : ℤ) :
+    selfSlice L U l u false a =
+      Finset.Ico (max L (max l (L-a))) (min U (min u (U-a))) := by
+  ext q
+  simp only [selfSlice,Finset.mem_filter,Finset.mem_inter,Finset.mem_Ico,
+    Bool.false_eq_true,ite_false,max_le_iff,lt_min_iff]
+  omega
+
+/-- No reversed self-link on a reduced word can cover more than half a block. -/
+theorem reflection_not_large {A : Type*} (bar : A → A)
+    (hbar : Function.Involutive bar) (hfree : ∀ x, bar x ≠ x)
+    (w : ℤ → A) (L U l u a : ℤ)
+    (hred : ∀ q, L ≤ q → q+1 < U → w (q+1) ≠ bar (w q))
+    (hcompare : ∀ q ∈ selfSlice L U l u true a, w q = bar (w (a-1-q))) :
+    2*(selfSlice L U l u true a).card ≤ (Finset.Ico L U).card := by
+  by_contra! hn
+  rw [reflection_slice,Int.card_Ico,Int.card_Ico] at hn
+  let l' := max L (max l (a-U))
+  let u' := min U (min u (a-L))
+  have hll : L ≤ l' := le_max_left _ _
+  have hlb : a-U ≤ l' := (le_max_right _ _).trans (le_max_right _ _)
+  have huU : u' ≤ U := min_le_left _ _
+  have hub : u' ≤ a-L := (min_le_right _ _).trans (min_le_right _ _)
+  have hne : l' < u' := by change _ < 2*(u'-l').toNat at hn; omega
+  have hmass : U-L < 2*(u'-l') := by change (U-L).toNat < 2*(u'-l').toNat at hn; omega
+  apply reflection_excluded bar hbar hfree w L U l' u' (a-1) hll huU hne
+    (by omega) (by omega) hmass hred
+  intro q hq hq'
+  apply hcompare
+  rw [reflection_slice]
+  exact Finset.mem_Ico.mpr ⟨hq,hq'⟩
+
+/-- The precise translation constraints retained by a self-link, with its
+literal compared-position cardinality and no additional independence premise. -/
+theorem translation_from_slice (L U l u a : ℤ) (ha : a ≠ 0) :
+    ∃ tr : BlockConstraints.Translation (U-L).toNat,
+      tr.domain.card = (selfSlice L U l u false a).card ∧
+      ∀ (A : Type*) (w : Fin (U-L).toNat → A),
+        (∀ q (hq : q ∈ selfSlice L U l u false a),
+          w (coordinate L U ⟨q+a,by simpa [selfSlice] using (Finset.mem_filter.mp hq).2⟩) =
+            w (coordinate L U ⟨q,(Finset.mem_inter.mp (Finset.mem_filter.mp hq).1).1⟩)) →
+          ∀ k : tr.domain, w (tr.target k) = w k.val := by
+  exact translation_representation L U a _ ha (by
+    intro q hq
+    refine ⟨(Finset.mem_inter.mp (Finset.mem_filter.mp hq).1).1,?_⟩
+    simpa [selfSlice] using (Finset.mem_filter.mp hq).2)
+
+/-- The same increasing coordinate, transported along the exact cardinality. -/
+def coordinateN (L U : ℤ) (n : ℕ) (hn : n = (U-L).toNat) :
+    Finset.Ico L U ≃ Fin n := (coordinate L U).trans (finCongr hn.symm)
+
+theorem coordinateN_val (L U : ℤ) (n : ℕ) (hn : n = (U-L).toNat)
+    (q : Finset.Ico L U) : ((coordinateN L U n hn q).val : ℤ) = q.val-L :=
+  coordinate_val q
+
+theorem translation_from_slice_at (L U l u a : ℤ) (ha : a ≠ 0)
+    (n : ℕ) (hn : n = (U-L).toNat) :
+    ∃ tr : BlockConstraints.Translation n,
+      tr.domain.card = (selfSlice L U l u false a).card ∧
+      ∀ (A : Type*) (w : Fin n → A),
+        (∀ q (hq : q ∈ selfSlice L U l u false a),
+          w (coordinateN L U n hn ⟨q+a,by simpa [selfSlice] using (Finset.mem_filter.mp hq).2⟩) =
+            w (coordinateN L U n hn ⟨q,(Finset.mem_inter.mp (Finset.mem_filter.mp hq).1).1⟩)) →
+          ∀ k : tr.domain, w (tr.target k) = w k.val := by
+  subst n
+  simpa [coordinateN] using translation_from_slice L U l u a ha
+
+end TorsionFreeZeroDivisors.IntervalSelfLinks
+
+/-!
+Finite combinatorial and numerical bounds: occurrence pairings,
+layer-cake stage counts and selection of one small stage. None of the graph
+existence, matching estimates or topological assertions is an assumption here.
+-/
+
+namespace TorsionFreeZeroDivisors.EntropyStages
+
+open scoped BigOperators
+
+namespace Pairing
+
+variable {O C : Type*} [Fintype O] [DecidableEq O] [DecidableEq C] (P : Pairing O)
+
+abbrev Unmatched := {o : O // P.partner o = o}
+
+/-- The exact link balance, including isolated blocks and multiple links.
+A self-link is excluded only in the component where the bound is used. -/
+theorem color_balance (color : O → C) (c : C)
+    (hcross : ∀ o, P.partner o ≠ o → color (P.partner o) ≠ color o) :
+    2 * Fintype.card {o : O // color o = c} ≤
+      Fintype.card O + Fintype.card P.Unmatched := by
+  classical
+  let f : {o : O // color o = c} →
+      {o : O // color o ≠ c} ⊕ P.Unmatched := fun o =>
+    if h : P.partner o.val = o.val then .inr ⟨o.val,h⟩
+    else .inl ⟨P.partner o.val, by simpa only [o.property] using hcross o.val h⟩
+  have hf : Function.Injective f := by
+    intro o p he
+    dsimp [f] at he
+    by_cases ho : P.partner o.val = o.val
+    · by_cases hp : P.partner p.val = p.val
+      · simp only [dite_eq_left ho, dite_eq_left hp] at he
+        exact Subtype.ext (congrArg (fun q : P.Unmatched => q.val) (Sum.inr.inj he))
+      · simp only [dite_eq_left ho, dite_eq_right hp, reduceCtorEq] at he
+    · by_cases hp : P.partner p.val = p.val
+      · simp only [dite_eq_right ho, dite_eq_left hp, reduceCtorEq] at he
+      · simp only [dite_eq_right ho, dite_eq_right hp] at he
+        exact Subtype.ext (P.involutive.injective
+          (congrArg (fun q : {o : O // color o ≠ c} => q.val) (Sum.inl.inj he)))
+  have hcard := Fintype.card_le_of_injective f hf
+  rw [Fintype.card_sum] at hcard
+  have htotal : Fintype.card {o : O // color o ≠ c} +
+      Fintype.card {o : O // color o = c} = Fintype.card O := by
+    rw [Fintype.card_subtype_compl]
+    have hle := Fintype.card_subtype_le (fun o : O => color o = c)
+    omega
+  omega
+
+end Pairing
+
+/-- Exact finite layer-cake identity. Stage j+1 is present precisely when
+j is smaller than the occurrence multiplicity. -/
+theorem stage_sum (M k : ℕ) (hk : k ≤ M) (a : ℝ) :
+    (∑ j ∈ Finset.range M, if j < k then a else 0) = k * a := by
+  rw [← Finset.sum_filter]
+  have he : (Finset.range M).filter (· < k) = Finset.range k := by
+    ext j
+    simp only [Finset.mem_filter, Finset.mem_range]
+    omega
+  rw [he]
+  simp
+
+/-- Multiplying the numerical stage bounds is equivalent to summing their
+logarithms; their shared edge/word costs are counted with multiplicity. -/
+theorem sum_stage_costs {I : Type*} [Fintype I]
+    (M : ℕ) (m : I → ℕ) (hm : ∀ i, m i ≤ M) (d : I → ℝ) :
+    (∑ j ∈ Finset.range M, ∑ i, if j < m i then d i else 0) =
+      ∑ i, (m i : ℝ) * d i := by
+  rw [Finset.sum_comm]
+  exact Finset.sum_congr rfl fun i _ => stage_sum M (m i) (hm i) (d i)
+
+/-- A bound for the product of numerical stage estimates selects one stage;
+no independence between the random variables at different stages is used. -/
+theorem select_stage (M : ℕ) (hM : 0 < M) (logB : Fin M → ℝ) (decay : ℝ)
+    (hprod : (∑ j, logB j) ≤ -decay) :
+    ∃ j, logB j ≤ -decay / M := by
+  by_contra! hn
+  have hs : (∑ _j : Fin M, -decay / M) < ∑ j, logB j := by
+    exact Finset.sum_lt_sum_of_nonempty ⟨⟨0,hM⟩,Finset.mem_univ _⟩ (fun j _ => hn j)
+  have hMr : (M : ℝ) ≠ 0 := Nat.cast_ne_zero.mpr (Nat.ne_of_gt hM)
+  have he : (∑ _j : Fin M, -decay / M) = -decay := by
+    simp only [Finset.sum_const, Finset.card_univ, Fintype.card_fin, nsmul_eq_mul]
+    field_simp
+  rw [he] at hs
+  linarith
+
+/-- Markov/union-bound conclusions can use this exponential version directly. -/
+theorem select_exponential_stage (M : ℕ) (hM : 0 < M) (logB : Fin M → ℝ)
+    (decay : ℝ) (hprod : (∑ j, logB j) ≤ -decay) :
+    ∃ j, Real.exp (logB j) ≤ Real.exp (-decay / M) := by
+  obtain ⟨j,hj⟩ := select_stage M hM logB decay hprod
+  exact ⟨j,Real.exp_le_exp.mpr hj⟩
+
+end TorsionFreeZeroDivisors.EntropyStages
+
+namespace TorsionFreeZeroDivisors
+open scoped BigOperators
+/-- The cost estimate for a component without a self-link, with the
+lower bin bound and unmatched-occurrence correction. -/
+theorem component_cost_bound {J : Type*} [Fintype J]
+    (m d : J → ℝ) (dmin δ s a₀ z b : ℝ)
+    (hm : ∀ i, 0 ≤ m i) (hmin : ∀ i, dmin ≤ d i)
+    (hlow : δ * s / 2 ≤ dmin) (hhigh : dmin ≤ a₀ * s)
+    (hδ : 0 ≤ δ) (hs : 0 ≤ s) (ha : 0 ≤ a₀) (hb : 0 ≤ b)
+    (hbalance : 2 * z ≤ (∑ i, m i) + b) :
+    -(∑ i, m i * d i) + 2 * z * dmin - δ * s * z ≤
+      a₀ * s * b - δ / 2 * s * (∑ i, m i) := by
+  have hsum : (∑ i, m i) * dmin ≤ ∑ i, m i * d i := by
+    rw [Finset.sum_mul]
+    exact Finset.sum_le_sum fun i _ ↦ mul_le_mul_of_nonneg_left (hmin i) (hm i)
+  have hds : 0 ≤ δ * s := mul_nonneg hδ hs
+  have hab : 0 ≤ a₀ * s * b := mul_nonneg (mul_nonneg ha hs) hb
+  by_cases h : 2 * z ≤ ∑ i, m i
+  · have hc : 0 ≤ (∑ i, m i) - 2 * z := sub_nonneg.mpr h
+    have hh := mul_le_mul_of_nonneg_left hlow hc
+    nlinarith
+  · have hc : 0 ≤ 2 * z - ∑ i, m i := by linarith
+    have hh := mul_le_mul_of_nonneg_left hhigh hc
+    have hz : (2 * z - ∑ i, m i) * (a₀ * s) ≤ b * (a₀ * s) := by
+      apply mul_le_mul_of_nonneg_right _ (mul_nonneg ha hs)
+      linarith
+    have hz' := mul_le_mul_of_nonneg_left hc hds
+    nlinarith
+
+/-- A self-link removes the root-word entropy. The remaining cost has the
+same decay term, with no unmatched-occurrence correction. -/
+theorem selflinked_component_cost_bound {J : Type*} [Fintype J]
+    (m d : J → ℝ) (δ s : ℝ) (hm : ∀ i, 0 ≤ m i)
+    (hlow : ∀ i, δ * s / 2 ≤ d i) :
+    -(∑ i, m i * d i) ≤ -δ / 2 * s * (∑ i, m i) := by
+  have hsum : (∑ i, m i) * (δ * s / 2) ≤ ∑ i, m i * d i := by
+    rw [Finset.sum_mul]
+    exact Finset.sum_le_sum fun i _ ↦ mul_le_mul_of_nonneg_left (hlow i) (hm i)
+  nlinarith
+
+end TorsionFreeZeroDivisors
+
+namespace TorsionFreeZeroDivisors.StageFusion
+
+section
+open scoped BigOperators
+open EntropyStages
+
+/-- Layer-cake identity in the `Fin M` indexing of the selected stages. -/
+theorem layers (M k : ℕ) (hk : k ≤ M) (a : ℝ) :
+    (∑ j : Fin M, if j.val < k then a else 0) = k*a := by
+  rw [Fin.sum_univ_eq_sum_range (fun j : ℕ => if j < k then a else 0)]
+  exact stage_sum M k hk a
+
+section Components
+variable {C : Type*} [Fintype C] {I : C → Type*} [∀ c, Fintype (I c)]
+
+def componentCost (self : C → Prop) [DecidablePred self]
+    (m : ∀ c, I c → ℕ) (d : ∀ c, I c → ℝ) (z : C → ℕ)
+    (dmin : C → ℝ) (δ s : ℝ) (c : C) : ℝ :=
+  -(∑ i, (m c i : ℝ)*d c i) + if self c then 0 else (2*dmin c - δ*s) * z c
+
+/-- The component costs added together. Every condition here is the
+local bin/link balance, not an assumed probability or conclusion. -/
+theorem total_component_cost (self : C → Prop) [DecidablePred self]
+    (m : ∀ c, I c → ℕ) (d : ∀ c, I c → ℝ) (z : C → ℕ)
+    (dmin b : C → ℝ) (δ s a : ℝ)
+    (hδ : 0 ≤ δ) (hs : 0 ≤ s) (ha : 0 ≤ a) (hb : ∀ c, 0 ≤ b c)
+    (hlow : ∀ c i, δ*s/2 ≤ d c i)
+    (hmin : ∀ c, ¬self c → ∀ i, dmin c ≤ d c i)
+    (hminlow : ∀ c, ¬self c → δ*s/2 ≤ dmin c)
+    (hminhigh : ∀ c, ¬self c → dmin c ≤ a*s)
+    (hbalance : ∀ c, ¬self c → 2*(z c : ℝ) ≤ (∑ i, (m c i : ℝ)) + b c) :
+    (∑ c, componentCost self m d z dmin δ s c) ≤
+      a*s*(∑ c, b c) - δ/2*s*(∑ c, ∑ i, (m c i : ℝ)) := by
+  rw [Finset.mul_sum,Finset.mul_sum,← Finset.sum_sub_distrib]
+  apply Finset.sum_le_sum
+  intro c _
+  dsimp [componentCost]
+  by_cases hc : self c
+  · rw [ite_eq_left hc,add_zero]
+    have h := selflinked_component_cost_bound (fun i => (m c i : ℝ)) (d c) δ s
+      (fun _ => Nat.cast_nonneg _) (hlow c)
+    have hh := mul_nonneg (mul_nonneg ha hs) (hb c)
+    linarith
+  · rw [ite_eq_right hc]
+    have h := component_cost_bound (fun i => (m c i : ℝ)) (d c) (dmin c) δ s a (z c) (b c)
+      (fun _ => Nat.cast_nonneg _) (hmin c hc) (hminlow c hc) (hminhigh c hc)
+      hδ hs ha (hb c) (hbalance c hc)
+    nlinarith
+
+/-- Exact logarithm of a numerical stage bound. `power` is V_j-E_j-k_j;
+`err` contains the independently controlled endpoint/block errors. -/
+def stageLog (M : ℕ) (self : C → Prop) [DecidablePred self]
+    (m : ∀ c, I c → ℕ) (d : ∀ c, I c → ℝ) (z : C → ℕ)
+    (dmin : C → ℝ) (δ s logn : ℝ) (power err : Fin M → ℝ) (j : Fin M) : ℝ :=
+  power j * logn - (∑ c, ∑ i, if j.val < m c i then d c i else 0) +
+    (∑ c, if j.val < z c then (if self c then 0 else 2*dmin c-δ*s) else 0) + err j
+
+/-- No multiplication of random variables: this is solely an identity between
+finite sums of logs of bounds and finite sums of local component costs. -/
+theorem sum_stageLog (M : ℕ) (self : C → Prop) [DecidablePred self]
+    (m : ∀ c, I c → ℕ) (d : ∀ c, I c → ℝ) (z : C → ℕ)
+    (hm : ∀ c i, m c i ≤ M) (hz : ∀ c, z c ≤ M)
+    (dmin : C → ℝ) (δ s logn : ℝ) (power err : Fin M → ℝ) :
+    (∑ j, stageLog M self m d z dmin δ s logn power err j) =
+      (∑ j, power j)*logn + (∑ c, componentCost self m d z dmin δ s c) + ∑ j, err j := by
+  simp only [stageLog,Finset.sum_add_distrib,Finset.sum_sub_distrib,← Finset.sum_mul]
+  have hm' : (∑ j : Fin M, ∑ c, ∑ i, if j.val < m c i then d c i else 0) =
+      ∑ c, ∑ i, (m c i : ℝ)*d c i := by
+    rw [Finset.sum_comm]
+    apply Finset.sum_congr rfl
+    intro c _
+    rw [Finset.sum_comm]
+    exact Finset.sum_congr rfl fun i _ => layers M (m c i) (hm c i) (d c i)
+  have hz' : (∑ j : Fin M, ∑ c, if j.val < z c then
+      (if self c then 0 else 2*dmin c-δ*s) else 0) =
+      ∑ c, if self c then 0 else (2*dmin c-δ*s)*(z c : ℝ) := by
+    rw [Finset.sum_comm]
+    apply Finset.sum_congr rfl
+    intro c _
+    rw [layers M (z c) (hz c)]
+    split_ifs <;> ring
+  rw [hm',hz']
+  simp only [componentCost,Finset.sum_add_distrib,Finset.sum_neg_distrib]
+  ring
+
+end Components
+
+/-- The error threshold is fixed using only the universal weight constants. -/
+def epsilon (δ a : ℝ) : ℝ := min (1/4) (δ/(16*(1+a)))
+
+theorem epsilon_pos {δ a : ℝ} (hδ : 0 < δ) (ha : 0 ≤ a) : 0 < epsilon δ a := by
+  apply lt_min (by norm_num)
+  exact div_pos hδ (by positivity)
+
+/-- Deterministic final absorption of the unmatched mass and sublinear errors. -/
+theorem absorb_errors {δ a H b e : ℝ} (hδ : 0 < δ) (ha : 0 ≤ a) (hH : 0 ≤ H)
+    (hb : b ≤ epsilon δ a * H) (he : e ≤ δ*H/8) :
+    -δ/2*H + a*b + e ≤ -δ*H/4 := by
+  have hd : 0 < 16*(1+a) := by positivity
+  have hε : epsilon δ a ≤ δ/(16*(1+a)) := min_le_right _ _
+  have hab : a*b ≤ a*(δ/(16*(1+a))*H) := by
+    exact mul_le_mul_of_nonneg_left (hb.trans (mul_le_mul_of_nonneg_right hε hH)) ha
+  have hratio : a*(δ/(16*(1+a))) ≤ δ/16 := by
+    apply (le_div_iff₀ (by norm_num : (0:ℝ)<16)).mpr
+    have hh : δ/(16*(1+a)) * (16*(1+a)) = δ := div_mul_cancel₀ _ (ne_of_gt hd)
+    have hp : 0 ≤ δ/(16*(1+a)) := div_nonneg hδ.le hd.le
+    nlinarith
+  have hab' := mul_le_mul_of_nonneg_right hratio hH
+  nlinarith
+
+end
+
+open scoped Classical BigOperators
+
+section FiniteProbability
+variable {Ω P : Type*} [Fintype P] (sample : Finset Ω) (hsample : sample.Nonempty)
+
+/-- Elementary finite Markov bound, including sample restriction. -/
+theorem markov_count (Bad : Ω → Prop) [DecidablePred Bad] (X : Ω → ℕ)
+    (hX : ∀ ω ∈ sample, Bad ω → 1 ≤ X ω) :
+    ((sample.filter Bad).card : ℝ) / sample.card ≤
+      ((∑ ω ∈ sample, X ω : ℕ) : ℝ) / sample.card := by
+  apply div_le_div_of_nonneg_right _ (Nat.cast_nonneg _)
+  exact_mod_cast (show (sample.filter Bad).card ≤ ∑ ω ∈ sample, X ω from by
+    calc
+      _ = ∑ ω ∈ sample, if Bad ω then 1 else 0 := by simp
+      _ ≤ _ := Finset.sum_le_sum fun ω hω => by
+        split_ifs with h
+        · exact hX ω hω h
+        · exact Nat.zero_le _)
+
+/-- Select a single numerical stage for each pattern. No independence is a
+premise, and the chosen stage can depend on the pattern. -/
+theorem one_pattern (M : ℕ) (hM : 0 < M) (Bad : Ω → Prop) [DecidablePred Bad]
+    (X : Fin M → Ω → ℕ) (logB : Fin M → ℝ) (decay : ℝ)
+    (hX : ∀ j ω, ω ∈ sample → Bad ω → 1 ≤ X j ω)
+    (hexpect : ∀ j, ((∑ ω ∈ sample, X j ω : ℕ) : ℝ) / sample.card ≤ Real.exp (logB j))
+    (hproduct : (∑ j, logB j) ≤ -decay) :
+    ((sample.filter Bad).card : ℝ) / sample.card ≤ Real.exp (-decay/M) := by
+  obtain ⟨j,hj⟩ := EntropyStages.select_exponential_stage M hM logB decay hproduct
+  exact (markov_count sample Bad (X j) (hX j)).trans ((hexpect j).trans hj)
+
+include hsample in
+/-- Union bound over the enlarged unlabelled patterns. -/
+theorem pattern_union (Bad : P → Ω → Prop) [∀ p, DecidablePred (Bad p)] (B : ℝ)
+    (hB : ∀ p, ((sample.filter (Bad p)).card : ℝ) / sample.card ≤ B) :
+    ((sample.filter (fun ω => ∃ p, Bad p ω)).card : ℝ) / sample.card ≤
+      (Fintype.card P : ℝ)*B := by
+  have ho : (0 : ℝ) < sample.card := Nat.cast_pos.mpr (Finset.card_pos.mpr hsample)
+  let e : Finset Ω := Finset.univ.biUnion (fun p : P => sample.filter (Bad p))
+  have he : sample.filter (fun ω => ∃ p, Bad p ω) = e := by
+    ext ω
+    simp only [e,Finset.mem_filter,Finset.mem_biUnion,Finset.mem_univ,true_and]
+    aesop
+  rw [he]
+  have hc : e.card ≤ ∑ p, (sample.filter (Bad p)).card := Finset.card_biUnion_le
+  have hc' : (e.card : ℝ) ≤ ∑ p, ((sample.filter (Bad p)).card : ℝ) := by
+    exact_mod_cast hc
+  calc
+    _ ≤ (∑ p, ((sample.filter (Bad p)).card : ℝ))/sample.card :=
+      div_le_div_of_nonneg_right hc' ho.le
+    _ = ∑ p, ((sample.filter (Bad p)).card : ℝ)/sample.card := Finset.sum_div _ _ _
+    _ ≤ ∑ _p : P, B := Finset.sum_le_sum (fun p _ => hB p)
+    _ = _ := by simp
+
+end FiniteProbability
+
+/-- Explicit finite version of exp(o(L)) times exponential decay. -/
+theorem subexponential_union {N : ℕ} {δ M L error : ℝ}
+    (_hM : 0 < M) (_hδ : 0 ≤ δ)
+    (hN : (N : ℝ) ≤ Real.exp error) (he : error ≤ δ*L/(8*M)) :
+    (N : ℝ)*Real.exp (-δ*L/(4*M)) ≤ Real.exp (-δ*L/(8*M)) := by
+  calc
+    _ ≤ Real.exp error * Real.exp (-δ*L/(4*M)) :=
+      mul_le_mul_of_nonneg_right hN (Real.exp_pos _).le
+    _ = Real.exp (error + -δ*L/(4*M)) := (Real.exp_add _ _).symm
+    _ ≤ _ := by
+      apply Real.exp_le_exp.mpr
+      have hid : -δ*L/(4*M) = 2*(-δ*L/(8*M)) := by ring
+      rw [hid]
+      have hn : -δ*L/(8*M) = -(δ*L/(8*M)) := by ring
+      rw [hn]
+      linarith
+
+end TorsionFreeZeroDivisors.StageFusion
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/GroupRing/Iso.lean b/lean/OAI/Algebra/GroupRing/Iso.lean
new file mode 100644
index 0000000000000000000000000000000000000000..4c8b032fd001393701c41b61d66ec588271f703d
--- /dev/null
+++ b/lean/OAI/Algebra/GroupRing/Iso.lean
@@ -0,0 +1,523 @@
+import Mathlib
+import OAI.Algebra.GroupRing.PatternUniform
+
+namespace OAI
+
+noncomputable section
+
+namespace TorsionFreeZeroDivisors.PortSubdivision.Iso
+open scoped Classical
+variable {V D V' D' T TV : Type*} [Fintype V] [Fintype D] [Fintype V'] [Fintype D']
+    [Fintype T] [Fintype TV] {Γ : PortGraph V D} {Γ' : PortGraph V' D'}
+    (f : Iso Γ Γ') (side : V → Bool) (side' : V' → Bool)
+    (hs : ∀ d,side (Γ.origin (Γ.reverse d))=side (Γ.origin d))
+    (hs' : ∀ d,side' (Γ'.origin (Γ'.reverse d))=side' (Γ'.origin d))
+    (hside : ∀ v,side v=side' (f.vertex v)) (b : Bool)
+    (root : Option V) (root' : Option V') (hroot : root.map f.vertex=root')
+    (label : D' → T) (outgoing : TV → Finset T) (target : TV) (bar : T → T)
+    (r : ConditionedMatchings.Matching (PatternEmbeddings.label outgoing) bar)
+
+/-- A side-preserving graph isomorphism transports the actual rooted embedding,
+not just its edge or vertex counts. -/
+def sideEmbedding (e : RealizationTransport.Embedding (SideRestriction.graph Γ' side' hs' b)
+    (fun d => label d.val) outgoing (RootPins.pin (SidePins.root side' root' b) target) bar r) :
+    RealizationTransport.Embedding (SideRestriction.graph Γ side hs b)
+      (fun d => label (f.dart d.val)) outgoing (RootPins.pin (SidePins.root side root b) target) bar r := by
+  let fv : SideRestriction.Vertex side b ↪ SideRestriction.Vertex side' b :=
+    ⟨fun v => ⟨f.vertex v.val,(hside v.val).symm.trans v.property⟩,
+      fun _ _ h => Subtype.ext (f.vertex.injective (congrArg Subtype.val h))⟩
+  let fd : SideRestriction.Dart Γ side b ↪ SideRestriction.Dart Γ' side' b :=
+    ⟨fun d => ⟨f.dart d.val,by rw [←f.origin_eq,←hside]; exact d.property⟩,
+      fun _ _ h => Subtype.ext (f.dart.injective (congrArg Subtype.val h))⟩
+  have ho d : fv ((SideRestriction.graph Γ side hs b).origin d)=
+      (SideRestriction.graph Γ' side' hs' b).origin (fd d) := Subtype.ext (f.origin_eq d.val)
+  have hr d : fd ((SideRestriction.graph Γ side hs b).reverse d)=
+      (SideRestriction.graph Γ' side' hs' b).reverse (fd d) := Subtype.ext (f.reverse_eq d.val)
+  have hp v y : RootPins.pin (SidePins.root side root b) target v=some y →
+      RootPins.pin (SidePins.root side' root' b) target (fv v)=some y := by
+    simp only [RootPins.pin_some_iff,SidePins.root_eq_some]
+    rintro ⟨hv,hy⟩
+    refine ⟨?_,hy⟩
+    rw [←hroot,hv]
+    rfl
+  exact RealizationTransport.restrict e _ fv fd ho hr _ hp
+
+end TorsionFreeZeroDivisors.PortSubdivision.Iso
+
+namespace TorsionFreeZeroDivisors.OriginalPatternIso
+open scoped Classical
+open PortSubdivision ChainSuppression DegreeTwoSuppression SuppressedMoore ChainPaths ChainIsomorphism
+open ChainChunkTransport ChunkComparisons FiniteChunking ComparedBlocks ActualPatternEvent
+variable {V D P E V' D' P' E' : Type} [Fintype V] [Fintype D] [Fintype P]
+    [Fintype V'] [Fintype D'] [Fintype P']
+    (Γ : PortGraph V D) (mark : V → Prop) (h2 : ∀ v,¬mark v → (out Γ.origin v).card=2)
+    (Γ' : PortGraph V' D') (mark' : V' → Prop) (h2' : ∀ v,¬mark' v → (out Γ'.origin v).card=2)
+    (paths : P → List {x : D // turn Γ.origin mark h2 x=x}) (hp : ∀ p,paths p≠[])
+    (paths' : P' → List {x : D' // turn Γ'.origin mark' h2' x=x}) (hp' : ∀ p,paths' p≠[])
+local notation "pl" => pathLength (chunks Γ mark h2 paths) (chunkLength Γ mark h2 paths)
+local notation "pl'" => pathLength (chunks Γ' mark' h2' paths') (chunkLength Γ' mark' h2' paths')
+variable (f : Iso Γ Γ') (eP : P ≃ P')
+    (hwords : ∀ p,((paths p).flatMap (word Γ mark h2)).map f.dart =
+      (paths' (eP p)).flatMap (word Γ' mark' h2'))
+
+include hwords in
+omit [Fintype V] [Fintype V'] [Fintype P] [Fintype P'] in
+lemma length_eq (p : P) : pl p=pl' (eP p) := by
+  rw [pathLength_eq,pathLength_eq,←hwords,List.length_map]
+
+include hwords in
+omit [Fintype V] [Fintype V'] [Fintype P] [Fintype P'] in
+lemma dart_eq (x : Position pl) (hlen : ∀ p,pl p=pl' (eP p)) :
+    f.dart (originalDart Γ mark h2 paths x)=
+      originalDart Γ' mark' h2' paths' (ComparisonGeometry.position eP hlen x) := by
+  apply Option.some.inj
+  have h := congrArg (fun l : List D' => l[x.2.val.toNat]?) (hwords x.1)
+  rw [List.getElem?_map,originalDart_get] at h
+  change some (f.dart (originalDart Γ mark h2 paths x))=_ at h
+  rw [←originalDart_get]
+  exact h
+
+variable (side : V → Bool) (side' : V' → Bool)
+    (hs : ∀ d,side (Γ.origin (Γ.reverse d))=side (Γ.origin d))
+    (hs' : ∀ d,side' (Γ'.origin (Γ'.reverse d))=side' (Γ'.origin d))
+    (hside : ∀ v,side v=side' (f.vertex v))
+    (root : Option P) (root' : Option P')
+    (hroot : (StageRoot.source Γ mark h2 paths hp root).map f.vertex=
+      StageRoot.source Γ' mark' h2' paths' hp' root')
+    (C : Comparisons (E:=E) (pathLength (chunks Γ mark h2 paths) (chunkLength Γ mark h2 paths)))
+    (C' : Comparisons (E:=E') (pathLength (chunks Γ' mark' h2' paths') (chunkLength Γ' mark' h2' paths')))
+    (g : ComparisonGeometry.Iso C C') (hg : g.path=eP)
+    (rep : ℕ) (a : Types.VertexA rep) (b : Types.VertexB rep)
+
+include hwords hside hroot hg in
+omit [Fintype V] [Fintype V'] [Fintype P] [Fintype P'] in
+/-- An unlabeled pattern isomorphism preserves the actual event in each fixed
+sample. No independence or expected-count assumption is used in this bridge. -/
+lemma realized (r : Match rep)
+    (he : OriginalPattern.Realized Γ' mark' h2' side' hs' paths' hp' root' rep a b C' r) :
+    OriginalPattern.Realized Γ mark h2 side hs paths hp root rep a b C r := by
+  subst eP
+  rcases he with ⟨label,hl,hi,hc,⟨ea⟩,⟨eb⟩⟩
+  refine ⟨label ∘ f.dart,?_,?_,?_,?_,?_⟩
+  · intro d
+    dsimp only [Function.comp_apply]
+    rw [f.reverse_eq,hl]
+  · intro d e ho he
+    apply f.dart.injective
+    apply hi _ _ _ he
+    rw [←f.origin_eq,←f.origin_eq,ho]
+  · intro x j hj
+    have hh := hc (ComparisonGeometry.position g.path g.length_eq x) (g.comparison j)
+      ((g.side_some x j).mpr hj)
+    dsimp only [Function.comp_apply]
+    rw [dart_eq Γ mark h2 Γ' mark' h2' paths paths' f g.path hwords x g.length_eq,
+      dart_eq Γ mark h2 Γ' mark' h2' paths paths' f g.path hwords (C.pairing.partner x) g.length_eq,
+      g.partner_eq,g.reverse_eq]
+    exact hh
+  · exact ⟨f.sideEmbedding side side' hs hs' hside true _ _ hroot label _ a Types.inverse r.1 ea⟩
+  · exact ⟨f.sideEmbedding side side' hs hs' hside false _ _ hroot label _ b Types.inverse r.2 eb⟩
+
+end TorsionFreeZeroDivisors.OriginalPatternIso
+
+/-!
+Finite names for the actual-image patterns in entropy.tex 126–138.  The bounds
+R,K,T,I are fixed before H grows.  No vertex names or letters are stored.  Raw
+codes include invalid multigraphs as an overcount; all validity conditions must
+still be checked when a code is used in a realization event.
+-/
+namespace TorsionFreeZeroDivisors.PatternCoding
+
+section
+open scoped BigOperators Classical
+
+/-- A list of at most T chain darts can be stored in T option-valued slots. -/
+def packList {A : Type*} (T : ℕ) (p : List A) : Fin T → Option A :=
+  fun i => p[i.val]?
+
+lemma packList_injective {A : Type*} (T : ℕ) :
+    Function.Injective (fun p : {p : List A // p.length ≤ T} => packList T p.val) := by
+  intro p q h
+  apply Subtype.ext
+  apply List.ext_getElem?
+  intro i
+  by_cases hi : i < T
+  · exact congrFun h ⟨i,hi⟩
+  · rw [List.getElem?_eq_none (by omega), List.getElem?_eq_none (by omega)]
+
+/-- One interval uses one path index and two integer endpoints. -/
+abbrev Interval (K H : ℕ) := Fin K × Fin (H+1) × Fin (H+1)
+
+/-- Two intervals and their comparison sign. Inactive comparison slots are absent. -/
+abbrev Comparison (K H : ℕ) := Option (Interval K H × Interval K H × Bool)
+
+/-- Bounded path sequences, marked graph incidence/reversal, lengths, sides,
+root designation and interval data. Unused graph indices may be padded.
+The use of oriented darts avoids choosing orientations of loop chains. -/
+abbrev Code (R K T I H : ℕ) :=
+  (Fin R → Fin R) × (Fin R → Fin R) × (Fin R → Bool) ×
+  (Fin R → Fin (H+1)) × (Fin K → Fin T → Option (Fin R)) ×
+  Option (Fin K × Bool) × (Fin I → Comparison K H)
+
+lemma card_comparison (K H : ℕ) :
+    Fintype.card (Comparison K H) = 1 + 2*K^2*(H+1)^4 := by
+  simp only [Comparison,Interval,Fintype.card_option,Fintype.card_prod,
+    Fintype.card_fin,Fintype.card_bool]
+  ring
+
+lemma card_code (R K T I H : ℕ) :
+    Fintype.card (Code R K T I H) =
+      R^(2*R) * 2^R * (H+1)^R * (R+1)^(T*K) * (1+2*K) *
+      (1+2*K^2*(H+1)^4)^I := by
+  simp only [Code,Fintype.card_prod,Fintype.card_fun,Fintype.card_fin,
+    Fintype.card_bool,Fintype.card_option]
+  simp only [pow_mul]
+  ring
+
+/-- The constant in the polynomial pattern bound depends only on fixed bounds. -/
+def coefficient (R K T I : ℕ) : ℕ :=
+  R^(2*R) * 2^R * (R+1)^(T*K) * (1+2*K) * (1+2*K^2)^I
+
+lemma card_code_polynomial (R K T I H : ℕ) :
+    Fintype.card (Code R K T I H) ≤ coefficient R K T I * (H+1)^(R+4*I) := by
+  rw [card_code]
+  have hp : 1 ≤ (H+1)^4 := Nat.one_le_pow _ _ (by omega)
+  have hh : 1+2*K^2*(H+1)^4 ≤ (1+2*K^2)*(H+1)^4 := by nlinarith
+  have he := Nat.pow_le_pow_left hh I
+  calc
+    _ ≤ R^(2*R)*2^R*(H+1)^R*(R+1)^(T*K)*(1+2*K)*
+        ((1+2*K^2)*(H+1)^4)^I := Nat.mul_le_mul_left _ he
+    _ = coefficient R K T I*(H+1)^(R+4*I) := by
+      simp only [coefficient,mul_pow,pow_add,pow_mul]
+      ring
+
+/-- The canonical renaming is independent of every target vertex name. -/
+def names {A : Type*} [Fintype A] (R : ℕ) (h : Fintype.card A ≤ R) : A ↪ Fin R :=
+  (Fintype.equivFin A).toEmbedding.trans (Fin.castLEEmb h)
+
+lemma names_injective {A : Type*} [Fintype A] {R : ℕ} (h : Fintype.card A ≤ R) :
+    Function.Injective (names R h) := (names R h).injective
+
+/-- Padding a finite table loses none of its entries. -/
+def pad {A B : Type*} [Fintype A] (R : ℕ) (_h : Fintype.card A ≤ R)
+    (default : B) (f : A → B) (i : Fin R) : B :=
+  if hi : i.val < Fintype.card A then f ((Fintype.equivFin A).symm ⟨i.val,hi⟩)
+  else default
+
+lemma pad_names {A B : Type*} [Fintype A] (R : ℕ) (h : Fintype.card A ≤ R)
+    (default : B) (f : A → B) (a : A) :
+    pad R h default f (names R h a) = f a := by
+  simp only [pad,names,Function.Embedding.trans_apply,Equiv.toEmbedding_apply,
+    Fin.castLEEmb_apply]
+  simp
+
+/-- Thus all the actual comparison endpoints with a ≤H bound fit literally. -/
+def endName (H : ℕ) (i : ℕ) (hi : i ≤ H) : Fin (H+1) := ⟨i,by omega⟩
+
+@[simp] lemma endName_val (H i : ℕ) (hi : i ≤ H) : (endName H i hi).val = i := rfl
+
+/-- An actual comparison endpoint. Its path and integer position are retained. -/
+structure ActualInterval (P : Type*) (H : ℕ) where
+  path : P
+  start : Fin (H+1)
+  stop : Fin (H+1)
+
+/-- The sign records translation versus reflection, not a chosen graph label. -/
+structure ActualComparison (P : Type*) (H : ℕ) where
+  left : ActualInterval P H
+  right : ActualInterval P H
+  sign : Bool
+
+def intervalName {P : Type*} [Fintype P] (K H : ℕ) (hP : Fintype.card P ≤ K)
+    (a : ActualInterval P H) : Interval K H :=
+  (names K hP a.path,a.start,a.stop)
+
+def comparisonName {P : Type*} [Fintype P] (K H : ℕ) (hP : Fintype.card P ≤ K)
+    (a : ActualComparison P H) : Comparison K H :=
+  some (intervalName K H hP a.left,intervalName K H hP a.right,a.sign)
+
+lemma intervalName_injective {P : Type*} [Fintype P] (K H : ℕ)
+    (hP : Fintype.card P ≤ K) : Function.Injective (intervalName K H hP) := by
+  intro a b h
+  cases a with | mk ap ast asp =>
+    cases b with | mk bp bst bsp =>
+      simp only [intervalName,Prod.mk.injEq] at h
+      obtain ⟨h1,h2,h3⟩ := h
+      have h1' := names_injective hP h1
+      cases h1'; cases h2; cases h3; rfl
+
+lemma comparisonName_injective {P : Type*} [Fintype P] (K H : ℕ)
+    (hP : Fintype.card P ≤ K) : Function.Injective (comparisonName K H hP) := by
+  intro a b h
+  cases a with | mk al ar asn =>
+    cases b with | mk bl br bsn =>
+      simp only [comparisonName,Option.some.injEq,Prod.mk.injEq] at h
+      obtain ⟨h1,h2,h3⟩ := h
+      have h1' := intervalName_injective K H hP h1
+      have h2' := intervalName_injective K H hP h2
+      cases h1'; cases h2'; cases h3; rfl
+
+/-- Explicit encoding of all source pattern data after suppression. The graph
+and path carriers can be arbitrary finite types: their old vertex names do
+not survive. Empty padding is not counted as an actual chain or path. -/
+def encode {D V P J : Type*} [Fintype D] [Fintype V] [Fintype P] [Fintype J]
+    (R K T I H : ℕ) (hR : 0<R)
+    (hD : Fintype.card D ≤ R) (hV : Fintype.card V ≤ R)
+    (hP : Fintype.card P ≤ K) (hJ : Fintype.card J ≤ I)
+    (rev : D → D) (origin : D → V) (side : D → Bool)
+    (length : D → Fin (H+1)) (paths : P → List D)
+    (root : Option (P × Bool)) (comparisons : J → ActualComparison P H) : Code R K T I H :=
+  (pad R hD ⟨0,hR⟩ (fun d => names R hD (rev d)),
+   pad R hD ⟨0,hR⟩ (fun d => names R hV (origin d)),
+   pad R hD false side,
+   pad R hD 0 length,
+   pad K hP (fun _ => none) (fun p => packList T ((paths p).map (names R hD))),
+   root.map (fun a => (names K hP a.1,a.2)),
+   pad I hJ none (fun j => comparisonName K H hP (comparisons j)))
+
+/-- Every finite marked multigraph, bounded list of chain traversals, rooted
+path designation and bounded set of signed comparisons is literally retained
+in one member of the polynomially counted family. -/
+theorem encode_preserves {D V P J : Type*} [Fintype D] [Fintype V] [Fintype P] [Fintype J]
+    (R K T I H : ℕ) (hR : 0<R)
+    (hD : Fintype.card D ≤ R) (hV : Fintype.card V ≤ R)
+    (hP : Fintype.card P ≤ K) (hJ : Fintype.card J ≤ I)
+    (rev : D → D) (origin : D → V) (side : D → Bool)
+    (length : D → Fin (H+1)) (paths : P → List D)
+    (root : Option (P × Bool)) (comparisons : J → ActualComparison P H) :
+    let c := encode R K T I H hR hD hV hP hJ rev origin side length paths root comparisons
+    (∀ d, c.1 (names R hD d) = names R hD (rev d)) ∧
+    (∀ d, c.2.1 (names R hD d) = names R hV (origin d)) ∧
+    (∀ d, c.2.2.1 (names R hD d) = side d) ∧
+    (∀ d, c.2.2.2.1 (names R hD d) = length d) ∧
+    (∀ p, c.2.2.2.2.1 (names K hP p) = packList T ((paths p).map (names R hD))) ∧
+    c.2.2.2.2.2.1 = root.map (fun a => (names K hP a.1,a.2)) ∧
+    (∀ j, c.2.2.2.2.2.2 (names I hJ j) = comparisonName K H hP (comparisons j)) := by
+  simp only [encode,pad_names]
+  simp
+
+/-- The bounded-list slots lose no traversal, even if darts are repeated. -/
+lemma encoded_paths_injective {D : Type*} [Fintype D] (R T : ℕ)
+    (hD : Fintype.card D ≤ R) :
+    Function.Injective (fun p : {p : List D // p.length ≤ T} =>
+      packList T (p.val.map (names R hD))) := by
+  intro p q h
+  have hm : p.val.map (names R hD) = q.val.map (names R hD) := by
+    exact congrArg Subtype.val (packList_injective T
+      (a₁ := ⟨p.val.map (names R hD),by simpa using p.property⟩)
+      (a₂ := ⟨q.val.map (names R hD),by simpa using q.property⟩) h)
+  apply Subtype.ext
+  exact (names_injective hD).list_map hm
+
+end
+
+open scoped Classical
+
+/-- Carrier counts distinguish inactive padding from actual graph indices.
+The four extra counts are uniformly bounded, independent of H and n. -/
+abbrev SizedCode (R K T I H : ℕ) :=
+  Fin (R+1) × Fin (R+1) × Fin (K+1) × Fin (I+1) × Code R K T I H
+
+theorem card_sizedCode (R K T I H : ℕ) :
+    Fintype.card (SizedCode R K T I H) ≤
+      (R+1)^2*(K+1)*(I+1)*coefficient R K T I*(H+1)^(R+4*I) := by
+  have hcard : Fintype.card (SizedCode R K T I H) =
+      (R+1)*(R+1)*(K+1)*(I+1)*Fintype.card (Code R K T I H) := by
+    simp only [SizedCode,Fintype.card_prod,Fintype.card_fin]
+    ring
+  rw [hcard]
+  have h := Nat.mul_le_mul_left ((R+1)*(R+1)*(K+1)*(I+1))
+    (card_code_polynomial R K T I H)
+  convert h using 1; ring
+
+variable {A B : Type*} [Fintype A] [Fintype B]
+
+def rename (h : Fintype.card A=Fintype.card B) : A ≃ B :=
+  (Fintype.equivFin A).trans ((finCongr h).trans (Fintype.equivFin B).symm)
+
+theorem rename_rank (h : Fintype.card A=Fintype.card B) (a : A) :
+    (Fintype.equivFin B (rename h a)).val = (Fintype.equivFin A a).val := by
+  simp [rename]
+
+theorem rename_names (R : ℕ) (hA : Fintype.card A ≤ R) (hB : Fintype.card B ≤ R)
+    (h : Fintype.card A=Fintype.card B) (a : A) : names R hB (rename h a)=names R hA a := by
+  apply Fin.ext
+  exact rename_rank h a
+
+theorem same_pad {X : Type*} (R : ℕ) (hA : Fintype.card A ≤ R) (hB : Fintype.card B ≤ R)
+    (h : Fintype.card A=Fintype.card B) (x : X) (f : A → X) (g : B → X)
+    (he : pad R hA x f=pad R hB x g) (a : A) : f a=g (rename h a) := by
+  have hh := congrFun he (names R hA a)
+  rw [pad_names,←rename_names R hA hB h,pad_names] at hh
+  exact hh
+
+/-- All non-label data of a bounded actual pattern. Proof fields are not
+encoded, while all data fields are. -/
+structure Data (D V P J : Type*) (T H : ℕ) where
+  reverse : D → D
+  origin : D → V
+  side : D → Bool
+  length : D → Fin (H+1)
+  paths : P → List D
+  path_bound : ∀ p,(paths p).length ≤ T
+  root : Option (P × Bool)
+  comparisons : J → ActualComparison P H
+
+variable {D V P J D' V' P' J' : Type*}
+  [Fintype D] [Fintype V] [Fintype P] [Fintype J]
+  [Fintype D'] [Fintype V'] [Fintype P'] [Fintype J']
+
+/-- Exact simultaneous equivalence of graph incidence, orientation, side,
+length, every path traversal, root path, and comparison intervals. -/
+structure Isomorphism {T H : ℕ} (a : Data D V P J T H) (b : Data D' V' P' J' T H) where
+  dart : D ≃ D'
+  vertex : V ≃ V'
+  path : P ≃ P'
+  comparison : J ≃ J'
+  reverse_eq : ∀ d,dart (a.reverse d)=b.reverse (dart d)
+  origin_eq : ∀ d,vertex (a.origin d)=b.origin (dart d)
+  side_eq : ∀ d,a.side d=b.side (dart d)
+  length_eq : ∀ d,a.length d=b.length (dart d)
+  paths_eq : ∀ p,(a.paths p).map dart=b.paths (path p)
+  root_eq : a.root.map (fun x => (path x.1,x.2))=b.root
+  comparison_left_path : ∀ j,path (a.comparisons j).left.path=(b.comparisons (comparison j)).left.path
+  comparison_left_start : ∀ j,(a.comparisons j).left.start=(b.comparisons (comparison j)).left.start
+  comparison_left_stop : ∀ j,(a.comparisons j).left.stop=(b.comparisons (comparison j)).left.stop
+  comparison_right_path : ∀ j,path (a.comparisons j).right.path=(b.comparisons (comparison j)).right.path
+  comparison_right_start : ∀ j,(a.comparisons j).right.start=(b.comparisons (comparison j)).right.start
+  comparison_right_stop : ∀ j,(a.comparisons j).right.stop=(b.comparisons (comparison j)).right.stop
+  comparison_sign : ∀ j,(a.comparisons j).sign=(b.comparisons (comparison j)).sign
+
+variable (R K T I H : ℕ) (hR : 0<R)
+  (hD : Fintype.card D ≤ R) (hV : Fintype.card V ≤ R)
+  (hP : Fintype.card P ≤ K) (hJ : Fintype.card J ≤ I)
+
+def encodeData (a : Data D V P J T H) : SizedCode R K T I H :=
+  (⟨Fintype.card D,by omega⟩,⟨Fintype.card V,by omega⟩,
+   ⟨Fintype.card P,by omega⟩,⟨Fintype.card J,by omega⟩,
+   encode R K T I H hR hD hV hP hJ a.reverse a.origin a.side a.length a.paths a.root a.comparisons)
+
+variable (hD' : Fintype.card D' ≤ R) (hV' : Fintype.card V' ≤ R)
+  (hP' : Fintype.card P' ≤ K) (hJ' : Fintype.card J' ≤ I)
+
+/-- Equality of the finite code loses no pattern information: the resulting
+isomorphism is valid for loops, repeated paths, and repeated comparisons. -/
+theorem same_code_canonical_isomorphism (a : Data D V P J T H) (b : Data D' V' P' J' T H)
+    (cD : Fintype.card D=Fintype.card D') (cV : Fintype.card V=Fintype.card V')
+    (cP : Fintype.card P=Fintype.card P') (cJ : Fintype.card J=Fintype.card J')
+    (he : encode R K T I H hR hD hV hP hJ a.reverse a.origin a.side a.length a.paths a.root a.comparisons =
+      encode R K T I H hR hD' hV' hP' hJ' b.reverse b.origin b.side b.length b.paths b.root b.comparisons) :
+    ∃ f : Isomorphism a b, f.dart=rename cD ∧ f.path=rename cP ∧ f.vertex=rename cV := by
+  simp only [encode,Prod.mk.injEq] at he
+  obtain ⟨hr,ho,hs,hl,hp,hroot,hcomp⟩ := he
+  have hrev (d : D) : rename cD (a.reverse d)=b.reverse (rename cD d) := by
+    apply names_injective hD'
+    rw [rename_names R hD hD']
+    exact same_pad R hD hD' cD (⟨0,hR⟩ : Fin R) _ _ hr d
+  have horig (d : D) : rename cV (a.origin d)=b.origin (rename cD d) := by
+    apply names_injective hV'
+    rw [rename_names R hV hV']
+    exact same_pad R hD hD' cD (⟨0,hR⟩ : Fin R) _ _ ho d
+  have hpath (p : P) : (a.paths p).map (rename cD)=b.paths (rename cP p) := by
+    have hh := same_pad K hP hP' cP (fun _ => none) _ _ hp p
+    have hn : (a.paths p).map (names R hD)=(b.paths (rename cP p)).map (names R hD') := by
+      exact congrArg Subtype.val (packList_injective T
+        (a₁ := ⟨_,by simpa using a.path_bound p⟩)
+        (a₂ := ⟨_,by simpa using b.path_bound (rename cP p)⟩) hh)
+    apply (names_injective hD').list_map
+    rw [List.map_map]
+    have hrn : (names R hD') ∘ (rename cD)=names R hD := by
+      funext d
+      exact rename_names R hD hD' cD d
+    rw [hrn]
+    exact hn
+  have hroot' : a.root.map (fun x => (rename cP x.1,x.2))=b.root := by
+    cases ha : a.root with
+    | none =>
+      cases hb : b.root with
+      | none => rfl
+      | some y => simp [ha,hb] at hroot
+    | some x =>
+      cases hb : b.root with
+      | none => simp [ha,hb] at hroot
+      | some y =>
+        have hh : names K hP x.1=names K hP' y.1 ∧ x.2=y.2 := by
+          simpa only [ha,hb,Option.map_some,Option.some.injEq,Prod.mk.injEq] using hroot
+        simp only [Option.map_some,Option.some.injEq]
+        apply Prod.ext
+        · apply names_injective hP'
+          rw [rename_names K hP hP']
+          exact hh.1
+        · exact hh.2
+  have hc (j : J) :
+      (rename cP (a.comparisons j).left.path=(b.comparisons (rename cJ j)).left.path) ∧
+      (a.comparisons j).left.start=(b.comparisons (rename cJ j)).left.start ∧
+      (a.comparisons j).left.stop=(b.comparisons (rename cJ j)).left.stop ∧
+      (rename cP (a.comparisons j).right.path=(b.comparisons (rename cJ j)).right.path) ∧
+      (a.comparisons j).right.start=(b.comparisons (rename cJ j)).right.start ∧
+      (a.comparisons j).right.stop=(b.comparisons (rename cJ j)).right.stop ∧
+      (a.comparisons j).sign=(b.comparisons (rename cJ j)).sign := by
+    have hh := same_pad I hJ hJ' cJ none _ _ hcomp j
+    simp only [comparisonName,intervalName,Option.some.injEq,Prod.mk.injEq] at hh
+    obtain ⟨⟨h1,h2,h3⟩,⟨h4,h5,h6⟩,h7⟩ := hh
+    refine ⟨?_,h2,h3,?_,h5,h6,h7⟩
+    · apply names_injective hP'
+      rw [rename_names K hP hP']
+      exact h1
+    · apply names_injective hP'
+      rw [rename_names K hP hP']
+      exact h4
+  exact ⟨⟨rename cD,rename cV,rename cP,rename cJ,hrev,horig,
+    same_pad R hD hD' cD false a.side b.side hs,
+    same_pad R hD hD' cD 0 a.length b.length hl,hpath,hroot',
+    (fun j => (hc j).1),(fun j => (hc j).2.1),(fun j => (hc j).2.2.1),
+    (fun j => (hc j).2.2.2.1),(fun j => (hc j).2.2.2.2.1),
+    (fun j => (hc j).2.2.2.2.2.1),(fun j => (hc j).2.2.2.2.2.2)⟩, rfl, rfl, rfl⟩
+
+theorem same_code_ranked_isomorphism (a : Data D V P J T H) (b : Data D' V' P' J' T H)
+    (cD : Fintype.card D=Fintype.card D') (cV : Fintype.card V=Fintype.card V')
+    (cP : Fintype.card P=Fintype.card P') (cJ : Fintype.card J=Fintype.card J')
+    (he : encode R K T I H hR hD hV hP hJ a.reverse a.origin a.side a.length a.paths a.root a.comparisons =
+      encode R K T I H hR hD' hV' hP' hJ' b.reverse b.origin b.side b.length b.paths b.root b.comparisons) :
+    ∃ f : Isomorphism a b, ∀ d,
+      (Fintype.equivFin D' (f.dart d)).val = (Fintype.equivFin D d).val := by
+  obtain ⟨f,hD,hP⟩ := same_code_canonical_isomorphism R K T I H hR hD hV hP hJ hD' hV' hP' hJ' a b cD cV cP cJ he
+  refine ⟨f,fun d => ?_⟩
+  rw [hD]
+  exact rename_rank cD d
+
+theorem same_code_isomorphism (a : Data D V P J T H) (b : Data D' V' P' J' T H)
+    (cD : Fintype.card D=Fintype.card D') (cV : Fintype.card V=Fintype.card V')
+    (cP : Fintype.card P=Fintype.card P') (cJ : Fintype.card J=Fintype.card J')
+    (he : encode R K T I H hR hD hV hP hJ a.reverse a.origin a.side a.length a.paths a.root a.comparisons =
+      encode R K T I H hR hD' hV' hP' hJ' b.reverse b.origin b.side b.length b.paths b.root b.comparisons) :
+    Nonempty (Isomorphism a b) := by
+  obtain ⟨f,_⟩ := same_code_ranked_isomorphism R K T I H hR hD hV hP hJ hD' hV' hP' hJ' a b cD cV cP cJ he
+  exact ⟨f⟩
+
+/-- Equal padded SIZED codes imply actual pattern equivalence, not merely
+similar numerical bounds or matching cardinalities. -/
+theorem encodeData_complete (a : Data D V P J T H) (b : Data D' V' P' J' T H)
+    (he : encodeData R K T I H hR hD hV hP hJ a =
+      encodeData R K T I H hR hD' hV' hP' hJ' b) : Nonempty (Isomorphism a b) := by
+  simp only [encodeData,Prod.mk.injEq] at he
+  obtain ⟨h1,h2,h3,h4,he⟩ := he
+  exact same_code_isomorphism R K T I H hR hD hV hP hJ hD' hV' hP' hJ' a b
+    (congrArg Fin.val h1) (congrArg Fin.val h2) (congrArg Fin.val h3) (congrArg Fin.val h4) he
+
+/-- Equal codes additionally preserve the literal rank orientation used in the
+subdivision realization. This is an output of encoding, not an extra assumption. -/
+theorem encodeData_ranked_complete (a : Data D V P J T H) (b : Data D' V' P' J' T H)
+    (he : encodeData R K T I H hR hD hV hP hJ a =
+      encodeData R K T I H hR hD' hV' hP' hJ' b) :
+    ∃ f : Isomorphism a b, ∀ d,
+      (Fintype.equivFin D' (f.dart d)).val = (Fintype.equivFin D d).val := by
+  simp only [encodeData,Prod.mk.injEq] at he
+  obtain ⟨h1,h2,h3,h4,he⟩ := he
+  exact same_code_ranked_isomorphism R K T I H hR hD hV hP hJ hD' hV' hP' hJ' a b
+    (congrArg Fin.val h1) (congrArg Fin.val h2) (congrArg Fin.val h3) (congrArg Fin.val h4) he
+
+end TorsionFreeZeroDivisors.PatternCoding
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/GroupRing/LinkComponents.lean b/lean/OAI/Algebra/GroupRing/LinkComponents.lean
new file mode 100644
index 0000000000000000000000000000000000000000..eeffc9917e6f5239b5bc1ac557bc13daa01875df
--- /dev/null
+++ b/lean/OAI/Algebra/GroupRing/LinkComponents.lean
@@ -0,0 +1,562 @@
+import Mathlib
+import OAI.Algebra.GroupRing.IntervalSelfLinks
+
+namespace OAI
+
+noncomputable section
+
+namespace TorsionFreeZeroDivisors.LinkComponents
+open scoped Classical BigOperators
+open EntropyStages
+variable {I : Type*} [Fintype I] (m : I → ℕ)
+abbrev Occurrence := (i : I) × Fin (m i)
+variable (P : Pairing (Occurrence m))
+
+def graph : SimpleGraph I where
+  Adj i j := i ≠ j ∧ ∃ o : Occurrence m, o.1 = i ∧ (P.partner o).1 = j
+  symm := ⟨by
+    rintro i j ⟨hne,o,hi,hj⟩
+    exact ⟨hne.symm,P.partner o,hj,by rw [P.involutive]; exact hi⟩⟩
+  loopless := ⟨fun i h => h.1 rfl⟩
+
+abbrev Component := (graph m P).ConnectedComponent
+
+def HasSelf (c : Component m P) : Prop :=
+  ∃ o : Occurrence m, (graph m P).connectedComponentMk o.1 = c ∧
+    P.partner o ≠ o ∧ (P.partner o).1 = o.1
+
+omit [Fintype I] in
+/-- Matched block occurrences always stay in their link component. -/
+theorem partner_component (o : Occurrence m) :
+    (graph m P).connectedComponentMk (P.partner o).1 = (graph m P).connectedComponentMk o.1 := by
+  by_cases he : (P.partner o).1 = o.1
+  · rw [he]
+  · apply SimpleGraph.ConnectedComponent.sound
+    apply SimpleGraph.Adj.reachable
+    exact ⟨he,P.partner o,rfl,by rw [P.involutive]⟩
+
+abbrev ComponentOccurrence (c : Component m P) :=
+  {o : Occurrence m // (graph m P).connectedComponentMk o.1 = c}
+
+def restrict (c : Component m P) : Pairing (ComponentOccurrence m P c) where
+  partner o := ⟨P.partner o.val,(partner_component m P o.val).trans o.property⟩
+  involutive o := Subtype.ext (P.involutive o.val)
+
+def unmatched (c : Component m P) : ℕ := Fintype.card (restrict m P c).Unmatched
+
+/-- Counting actual occurrences, including repeats, gives the sum of block
+multiplicities in the component. -/
+theorem card_occurrences (c : Component m P) :
+    Fintype.card (ComponentOccurrence m P c) = ∑ i : c, m i.val := by
+  let e : ComponentOccurrence m P c ≃ (i : c) × Fin (m i.val) :=
+    { toFun := fun o => ⟨⟨o.val.1,o.property⟩,o.val.2⟩
+      invFun := fun o => ⟨⟨o.1.val,o.2⟩,o.1.property⟩
+      left_inv := fun _ => rfl
+      right_inv := fun _ => rfl }
+  rw [Fintype.card_congr e,Fintype.card_sigma]
+  simp only [Fintype.card_fin]
+
+theorem card_block_occurrences (c : Component m P) (i : c) :
+    Fintype.card {o : ComponentOccurrence m P c // o.val.1 = i.val} = m i.val := by
+  let e : {o : ComponentOccurrence m P c // o.val.1 = i.val} ≃ Fin (m i.val) :=
+    { toFun := fun o => ⟨o.val.val.2.val,by simpa only [o.property] using o.val.val.2.isLt⟩
+      invFun := fun k => ⟨⟨⟨i.val,k⟩,i.property⟩,rfl⟩
+      left_inv := by
+        intro ⟨⟨⟨j,k⟩,hj⟩,hi⟩
+        dsimp at hi
+        subst j
+        rfl
+      right_inv := fun _ => rfl }
+  exact (Fintype.card_congr e).trans (Fintype.card_fin _)
+
+/-- Literal link balance in a component without a self-link. -/
+theorem balance (c : Component m P) (hn : ¬HasSelf m P c) (i : c) :
+    2*m i.val ≤ (∑ j : c, m j.val) + unmatched m P c := by
+  have hc : ∀ o : ComponentOccurrence m P c,
+      (restrict m P c).partner o ≠ o →
+        ((restrict m P c).partner o).val.1 ≠ o.val.1 := by
+    intro o hne he
+    apply hn
+    exact ⟨o.val,o.property,fun ho => hne (Subtype.ext ho),he⟩
+  have hh := (restrict m P c).color_balance (fun o => o.val.1) i.val hc
+  rw [card_block_occurrences m P c i,card_occurrences m P c] at hh
+  exact hh
+
+/-- The maximum multiplicity is present exactly in the active components. -/
+def maximum (c : Component m P) : ℕ :=
+  (Finset.univ.image (fun i : c => m i.val)).max'
+    (by obtain ⟨i⟩ := c.connected_toSimpleGraph.nonempty; exact ⟨m i.val,Finset.mem_image.mpr ⟨i,Finset.mem_univ _,rfl⟩⟩)
+
+theorem le_maximum (c : Component m P) (i : c) : m i.val ≤ maximum m P c :=
+  by
+    unfold maximum
+    exact Finset.le_max' (Finset.univ.image (fun j : c => m j.val)) (m i.val) (Finset.mem_image.mpr ⟨i,Finset.mem_univ _,rfl⟩)
+
+theorem maximum_mem (c : Component m P) : ∃ i : c, m i.val = maximum m P c := by
+  have hh := Finset.max'_mem (Finset.univ.image (fun i : c => m i.val))
+    (by obtain ⟨i⟩ := c.connected_toSimpleGraph.nonempty; exact ⟨m i.val,Finset.mem_image.mpr ⟨i,Finset.mem_univ _,rfl⟩⟩)
+  rcases Finset.mem_image.mp hh with ⟨i,_,hi⟩
+  exact ⟨i,hi⟩
+
+theorem maximum_balance (c : Component m P) (hn : ¬HasSelf m P c) :
+    2*maximum m P c ≤ (∑ j : c, m j.val) + unmatched m P c := by
+  obtain ⟨i,hi⟩ := maximum_mem m P c
+  rw [← hi]
+  exact balance m P c hn i
+
+theorem active_iff (c : Component m P) (j : ℕ) :
+    (∃ i : c, j < m i.val) ↔ j < maximum m P c := by
+  constructor
+  · rintro ⟨i,hi⟩
+    exact hi.trans_le (le_maximum m P c i)
+  · intro hj
+    obtain ⟨i,hi⟩ := maximum_mem m P c
+    exact ⟨i,hi ▸ hj⟩
+
+/-- Components partition the underlying blocks, including the isolated ones. -/
+theorem sum_components {R : Type*} [AddCommMonoid R] (a : I → R) :
+    (∑ c : Component m P, ∑ i : c, a i.val) = ∑ i, a i := by
+  let e := Equiv.sigmaFiberEquiv (graph m P).connectedComponentMk
+  calc
+    _ = ∑ x : (c : Component m P) × c, a x.2.val :=
+      (Fintype.sum_sigma (fun x : (c : Component m P) × c => a x.2.val)).symm
+    _ = _ := Fintype.sum_equiv e _ _ (fun _ => rfl)
+
+/-- Fixed occurrences are partitioned by precisely the same components. -/
+theorem sum_unmatched :
+    (∑ c : Component m P, unmatched m P c) = Fintype.card P.Unmatched := by
+  let f : P.Unmatched → Component m P := fun o => (graph m P).connectedComponentMk o.val.1
+  have hc (c : Component m P) :
+      unmatched m P c = Fintype.card {o : P.Unmatched // f o = c} := by
+    let e : (restrict m P c).Unmatched ≃ {o : P.Unmatched // f o = c} :=
+      { toFun := fun o => ⟨⟨o.val.val, congrArg Subtype.val o.property⟩, o.val.property⟩
+        invFun := fun o => ⟨⟨o.val.val, o.property⟩, Subtype.ext o.val.property⟩
+        left_inv := fun _ => rfl
+        right_inv := fun _ => rfl }
+    exact Fintype.card_congr e
+  simp_rw [hc]
+  rw [← Fintype.card_sigma]
+  exact Fintype.card_congr (Equiv.sigmaFiberEquiv f)
+
+/-- The bin-minimizing root need not be present at a given stage. -/
+def minimumRoot (d : I → ℝ) (c : Component m P) : c :=
+  Classical.choose (Finset.exists_min_image Finset.univ (fun i : c => d i.val)
+    (by obtain ⟨i⟩ := c.connected_toSimpleGraph.nonempty; exact ⟨i, Finset.mem_univ _⟩))
+
+theorem minimumRoot_le (d : I → ℝ) (c : Component m P) (i : c) :
+    d (minimumRoot m P d c).val ≤ d i.val :=
+  (Classical.choose_spec (Finset.exists_min_image Finset.univ (fun i : c => d i.val)
+    (by obtain ⟨i⟩ := c.connected_toSimpleGraph.nonempty; exact ⟨i, Finset.mem_univ _⟩))).2 i (Finset.mem_univ _)
+
+def componentLabelCost (d : I → ℝ) (δ s : ℝ) (c : Component m P) : ℝ :=
+  if HasSelf m P c then 0 else 2*d (minimumRoot m P d c).val-δ*s
+
+/-- The actual label/block part of the stage exponent, before embedding and
+uniform error terms are added. Stages are indexed from zero. -/
+def stageCost (M : ℕ) (d : I → ℝ) (δ s : ℝ) (j : Fin M) : ℝ :=
+  -(∑ i, if j.val < m i then d i else 0) +
+    ∑ c : Component m P, if j.val < maximum m P c then componentLabelCost m P d δ s c else 0
+
+/-- Summing the actual link-component exponents gives decay and
+only the globally counted unmatched correction. No coverage identity is assumed. -/
+theorem sum_stageCost (M : ℕ) (hm : ∀ i, m i ≤ M) (d : I → ℝ) (δ s a : ℝ)
+    (hδ : 0 ≤ δ) (hs : 0 ≤ s) (ha : 0 ≤ a)
+    (hlow : ∀ i, δ*s/2 ≤ d i) (hhigh : ∀ i, d i ≤ a*s) :
+    (∑ j : Fin M, stageCost m P M d δ s j) ≤
+      a*s*(Fintype.card P.Unmatched : ℝ) - δ/2*s*(∑ i, (m i : ℝ)) := by
+  have hz : ∀ c : Component m P, maximum m P c ≤ M := by
+    intro c
+    obtain ⟨i,hi⟩ := maximum_mem m P c
+    rw [← hi]
+    exact hm i.val
+  have hi : (∑ j : Fin M, ∑ i, if j.val < m i then d i else 0) =
+      ∑ i, (m i : ℝ)*d i := by
+    rw [Finset.sum_comm]
+    exact Finset.sum_congr rfl (fun i _ => StageFusion.layers M (m i) (hm i) (d i))
+  have hc : (∑ j : Fin M, ∑ c : Component m P,
+      if j.val < maximum m P c then componentLabelCost m P d δ s c else 0) =
+      ∑ c : Component m P, (maximum m P c : ℝ)*componentLabelCost m P d δ s c := by
+    rw [Finset.sum_comm]
+    exact Finset.sum_congr rfl (fun c _ => StageFusion.layers M (maximum m P c) (hz c) _)
+  have hid : (∑ j : Fin M, stageCost m P M d δ s j) =
+      ∑ c : Component m P, StageFusion.componentCost (HasSelf m P)
+        (fun (c : Component m P) (i : c) => m i.val) (fun (c : Component m P) (i : c) => d i.val) (maximum m P)
+        (fun c => d (minimumRoot m P d c).val) δ s c := by
+    simp only [stageCost,Finset.sum_add_distrib,Finset.sum_neg_distrib]
+    rw [hi,hc,← sum_components m P (fun i => (m i : ℝ)*d i)]
+    simp only [StageFusion.componentCost,Finset.sum_add_distrib,Finset.sum_neg_distrib]
+    congr 1
+    apply Finset.sum_congr rfl
+    intro c _
+    unfold componentLabelCost
+    split_ifs <;> ring
+  rw [hid]
+  have htotal := StageFusion.total_component_cost (HasSelf m P)
+    (fun (c : Component m P) (i : c) => m i.val) (fun (c : Component m P) (i : c) => d i.val) (maximum m P)
+    (fun c => d (minimumRoot m P d c).val) (fun c => (unmatched m P c : ℝ)) δ s a
+    hδ hs ha (fun _ => Nat.cast_nonneg _)
+    (fun _ i => hlow i.val) (fun c _ i => minimumRoot_le m P d c i)
+    (fun c _ => hlow (minimumRoot m P d c).val)
+    (fun c _ => hhigh (minimumRoot m P d c).val)
+    (fun c hc => by exact_mod_cast maximum_balance m P c hc)
+  have hu : (∑ c : Component m P, (unmatched m P c : ℝ)) = Fintype.card P.Unmatched := by
+    exact_mod_cast sum_unmatched m P
+  rw [hu,sum_components m P (fun i => (m i : ℝ))] at htotal
+  exact htotal
+
+/-- A numerical bound for actual stages: the Euler terms need only have
+nonpositive total, exactly as supplied by the immersed traversal argument. -/
+theorem sum_stageBound (M : ℕ) (hm : ∀ i, m i ≤ M) (d : I → ℝ) (δ s a logn : ℝ)
+    (power err : Fin M → ℝ)
+    (hδ : 0 ≤ δ) (hs : 0 ≤ s) (ha : 0 ≤ a) (hn : 0 ≤ logn)
+    (hlow : ∀ i, δ*s/2 ≤ d i) (hhigh : ∀ i, d i ≤ a*s)
+    (hpower : (∑ j : Fin M, power j) ≤ 0) :
+    (Finset.univ.sum (fun j : Fin M => power j*logn + stageCost m P M d δ s j + err j)) ≤
+      a*s*(Fintype.card P.Unmatched : ℝ) - δ/2*s*(∑ i, (m i : ℝ)) + (∑ j : Fin M, err j) := by
+  have hc := sum_stageCost m P M hm d δ s a hδ hs ha hlow hhigh
+  have hp := mul_nonpos_of_nonpos_of_nonneg hpower hn
+  simp only [Finset.sum_add_distrib,← Finset.sum_mul]
+  linarith
+
+end TorsionFreeZeroDivisors.LinkComponents
+
+namespace TorsionFreeZeroDivisors.OccurrenceMatching.Data
+open scoped Classical
+variable {Ω B B' E : Type*} (D : OccurrenceMatching.Data (Ω := Ω) (B := B) (E := E))
+
+def transport (r : B' ≃ B) : OccurrenceMatching.Data (Ω := Ω) (B := B') (E := E) where
+  error := D.error
+  positions b := D.positions (r b)
+  disjoint h := D.disjoint (r.injective.ne h)
+  pairing := D.pairing
+  side := D.side
+  flip := D.flip
+  flip_inv := D.flip_inv
+  flip_ne := D.flip_ne
+  side_partner := D.side_partner
+
+theorem transport_joined (r : B' ≃ B) (o p : B') :
+    (D.transport r).Joined o p ↔ D.Joined (r o) (r p) := Iff.rfl
+
+theorem transport_partner (r : B' ≃ B) (o : B') :
+    r ((D.transport r).matching.partner o) = D.matching.partner (r o) := by
+  by_cases h : D.matching.partner (r o) = r o
+  · have hh : (D.transport r).matching.partner o = o := by
+      apply ((D.transport r).unmatched_iff o).mpr
+      intro p hp
+      exact (D.unmatched_iff (r o)).mp h (r p) hp
+    rw [hh,h]
+  · obtain ⟨p,hp⟩ := (D.matched_iff (r o)).mp h
+    have hp' : (D.transport r).Joined o (r.symm p) := by
+      rw [transport_joined,r.apply_symm_apply]
+      exact hp
+    have he := (D.transport r).partner_spec hp'
+    have he' := D.partner_spec hp
+    change (D.transport r).matching.partner o = r.symm p at he
+    change D.matching.partner (r o) = p at he'
+    rw [he,he',r.apply_symm_apply]
+
+end TorsionFreeZeroDivisors.OccurrenceMatching.Data
+
+namespace TorsionFreeZeroDivisors.RepeatedBlocks
+open scoped Classical BigOperators
+open BlockAlignment ComparedBlocks
+variable {C E : Type*} (s : ℝ) (hs : 0 < s) (len m : C → ℕ)
+
+abbrev Traversal := (c : C) × Fin (m c)
+abbrev traversalLength : Traversal m → ℕ := fun t => len t.1
+abbrev Underlying := ComparedBlocks.Block s len
+abbrev Occurrence := ComparedBlocks.Block s (traversalLength len m)
+abbrev multiplicity (i : Underlying s len) : ℕ := m i.1
+
+/-- The occurrence index is retained separately from the common chain grid. -/
+def occurrenceEquiv : Occurrence s len m ≃ LinkComponents.Occurrence (multiplicity s len m) where
+  toFun b := ⟨⟨b.1.1,b.2⟩,b.1.2⟩
+  invFun b := ⟨⟨b.1.1,b.2⟩,b.1.2⟩
+  left_inv _ := rfl
+  right_inv _ := rfl
+
+def color (b : Occurrence s len m) : Underlying s len := (occurrenceEquiv s len m b).1
+
+def height (i : Underlying s len) : ℕ := (block s i.2.val).card
+
+def lower (i : Underlying s len) : ℤ := ⌈(i.2.val : ℝ)*s-1/2⌉
+def upper (i : Underlying s len) : ℤ := ⌈((i.2.val : ℝ)+1)*s-1/2⌉
+
+theorem block_interval (i : Underlying s len) : block s i.2.val = Finset.Ico (lower s len i) (upper s len i) := by
+  simp only [block,positions,lower,upper,Int.cast_natCast]
+
+/-- Literal increasing edge coordinates shared by every repetition. -/
+def wordCoordinate (i : Underlying s len) : block s i.2.val ≃ Fin (height s len i) :=
+  (Set.equivOfEq (congrArg (fun positions : Finset ℤ => (positions : Set ℤ)) (block_interval s len i))).trans
+    ((IntervalSelfLinks.coordinate (lower s len i) (upper s len i)).trans
+      (finCongr (by rw [height,block_interval,Int.card_Ico])))
+
+theorem wordCoordinate_val (i : Underlying s len) (q : block s i.2.val) :
+    ((wordCoordinate s len i q).val : ℤ) = q.val-lower s len i := by
+  exact IntervalSelfLinks.coordinate_val ⟨q.val,by rw [← block_interval]; exact q.property⟩
+
+def blockPositionEquiv (b : Occurrence s len m) :
+    blockPositions s hs (traversalLength len m) b ≃ block s b.2.val where
+  toFun x := ⟨x.val.2.val,((mem_blockPositions s hs (traversalLength len m)).mp x.property).2⟩
+  invFun q := ⟨includeBlock s hs (traversalLength len m) b q,
+    Finset.mem_map.mpr ⟨q,Finset.mem_attach _ _,rfl⟩⟩
+  left_inv x := by
+    apply Subtype.ext
+    have hh := ((mem_blockPositions s hs (traversalLength len m)).mp x.property).1
+    cases b with
+    | mk t k =>
+      rcases x with ⟨⟨u,q⟩,hx⟩
+      dsimp at hh
+      subst u
+      rfl
+  right_inv _ := rfl
+
+def coordinate (b : Occurrence s len m) :
+    blockPositions s hs (traversalLength len m) b ≃ Fin (height s len (color s len m b)) :=
+  (blockPositionEquiv s hs len m b).trans (wordCoordinate s len (color s len m b))
+
+theorem coordinate_val (b : Occurrence s len m)
+    (x : blockPositions s hs (traversalLength len m) b) :
+    ((coordinate s hs len m b x).val : ℤ) = x.val.2.val-lower s len (color s len m b) :=
+  wordCoordinate_val s len (color s len m b) (blockPositionEquiv s hs len m b x)
+
+variable (cmp : Comparisons (E := E) (traversalLength len m)) (err : ℕ)
+
+def data : OccurrenceMatching.Data (Ω := Position (traversalLength len m))
+    (B := LinkComponents.Occurrence (multiplicity s len m)) (E := E) :=
+  (cmp.matchingData s hs (traversalLength len m) err).transport (occurrenceEquiv s len m).symm
+
+def repeatedCoordinate (b : LinkComponents.Occurrence (multiplicity s len m)) :
+    (data s hs len m cmp err).positions b ≃ Fin (height s len b.1) :=
+  coordinate s hs len m ((occurrenceEquiv s len m).symm b)
+
+variable {A : Type*} (symbol : E → (A ≃ A))
+
+def links : StageLabels.Links (T := A) (height s len) :=
+  MatchedLabels.links (data s hs len m cmp err) Sigma.fst (height s len)
+    (repeatedCoordinate s hs len m cmp err) symbol
+
+theorem links_graph : (links s hs len m cmp err symbol).graph =
+    LinkComponents.graph (multiplicity s len m) (data s hs len m cmp err).matching := rfl
+
+theorem links_deficit (i j : Underlying s len)
+    (hadj : (links s hs len m cmp err symbol).graph.Adj i j) :
+    height s len i - ((links s hs len m cmp err symbol).known i j).card ≤ err :=
+  MatchedLabels.links_deficit _ _ _ _ _ hadj
+
+theorem links_consistent (letters : Position (traversalLength len m) → A)
+    (words : (i : Underlying s len) → Fin (height s len i) → A)
+    (hcompare : ∀ x e, cmp.side x = some e →
+      letters x = symbol e (letters (cmp.pairing.partner x)))
+    (hwords : ∀ b (x : blockPositions s hs (traversalLength len m) b),
+      words (color s len m b) (coordinate s hs len m b x) = letters x.val) :
+    (links s hs len m cmp err symbol).Consistent words := by
+  apply MatchedLabels.links_consistent _ _ _ _ _ letters words hcompare
+  intro b x
+  exact hwords ((occurrenceEquiv s len m).symm b) x
+
+theorem integerSlice_self (i : Underlying s len) (k t : Fin (m i.1)) (e : E) :
+    cmp.integerSlice s (traversalLength len m) e
+      ((occurrenceEquiv s len m).symm ⟨i,k⟩) ((occurrenceEquiv s len m).symm ⟨i,t⟩) =
+    IntervalSelfLinks.selfSlice (lower s len i) (upper s len i)
+      ⌈cmp.lo e-1/2⌉ ⌈cmp.hi e-1/2⌉ (cmp.reverse e) (cmp.offset e) := by
+  unfold Comparisons.integerSlice
+  change (block s i.2.val ∩ positions (cmp.lo e) (cmp.hi e)).filter
+    (fun q => affine (cmp.reverse e) (cmp.offset e) q ∈ block s i.2.val) = _
+  rw [block_interval s len i]
+  rfl
+
+ theorem self_slice_card (i : Underlying s len) (k t : Fin (m i.1)) (e : E)
+    (hsource : (⟨i.1,k⟩ : Traversal m) = cmp.source e)
+    (htarget : (⟨i.1,t⟩ : Traversal m) = cmp.source (cmp.flip e)) :
+    ((data s hs len m cmp err).slice e ⟨i,k⟩ ⟨i,t⟩).card =
+      (IntervalSelfLinks.selfSlice (lower s len i) (upper s len i)
+        ⌈cmp.lo e-1/2⌉ ⌈cmp.hi e-1/2⌉ (cmp.reverse e) (cmp.offset e)).card := by
+  change ((cmp.matchingData s hs (traversalLength len m) err).slice e
+    ((occurrenceEquiv s len m).symm ⟨i,k⟩) ((occurrenceEquiv s len m).symm ⟨i,t⟩)).card = _
+  rw [cmp.slice_integer_card s hs (traversalLength len m) err hsource htarget,
+    integerSlice_self]
+
+include hs in
+/-- The original letter comparison restricts to precisely this integer slice. -/
+theorem self_comparison {A : Type*} (bar : A → A) (w : C → ℤ → A)
+    (hcompare : ∀ x e, cmp.side x = some e →
+      w x.1.1 x.2.val = if cmp.reverse e then
+        bar (w (cmp.pairing.partner x).1.1 (cmp.pairing.partner x).2.val)
+      else w (cmp.pairing.partner x).1.1 (cmp.pairing.partner x).2.val)
+    (i : Underlying s len) (k t : Fin (m i.1)) (e : E)
+    (hsource : (⟨i.1,k⟩ : Traversal m) = cmp.source e)
+    (htarget : (⟨i.1,t⟩ : Traversal m) = cmp.source (cmp.flip e))
+    (q : ℤ) (hq : q ∈ IntervalSelfLinks.selfSlice (lower s len i) (upper s len i)
+      ⌈cmp.lo e-1/2⌉ ⌈cmp.hi e-1/2⌉ (cmp.reverse e) (cmp.offset e)) :
+    w i.1 q = if cmp.reverse e then bar (w i.1 (affine (cmp.reverse e) (cmp.offset e) q))
+      else w i.1 (affine (cmp.reverse e) (cmp.offset e) q) := by
+  have hh := (Finset.mem_inter.mp (Finset.mem_filter.mp hq).1)
+  have hb : q ∈ block s i.2.val := by rw [block_interval]; exact hh.1
+  let x : Position (traversalLength len m) :=
+    ⟨⟨i.1,k⟩,⟨q,full_subset s hs (len i.1) i.2 hb⟩⟩
+  have hx : cmp.side x = some e := (cmp.side_iff x e).mpr ⟨hsource,hh.2⟩
+  have hy : (cmp.pairing.partner x).1.1 = i.1 :=
+    congrArg Sigma.fst ((cmp.partner_source x e hx).trans htarget.symm)
+  have hc := hcompare x e hx
+  rw [hy,cmp.partner_coordinate x e hx] at hc
+  exact hc
+
+/-- Literal edge reduction rules out zero shift, rather than assuming that
+self-links are nontrivial translations. -/
+theorem self_shift_ne_zero
+    (hreduced : ∀ x e, cmp.side x = some e →
+      (x.1.1,x.2.val) ≠ ((cmp.pairing.partner x).1.1,(cmp.pairing.partner x).2.val))
+    (i : Underlying s len) (k t : Fin (m i.1)) (e : E)
+    (hne : ((data s hs len m cmp err).slice e ⟨i,k⟩ ⟨i,t⟩).Nonempty)
+    (hrev : cmp.reverse e = false) : cmp.offset e ≠ 0 := by
+  intro hz
+  obtain ⟨x,hx⟩ := hne
+  obtain ⟨hb,he,hp⟩ := (OccurrenceMatching.Data.slice_mem _).mp hx
+  have hb' := ((mem_blockPositions s hs (traversalLength len m)).mp hb).1
+  have hp' := ((mem_blockPositions s hs (traversalLength len m)).mp hp).1
+  apply hreduced x e he
+  apply Prod.ext
+  · exact (congrArg Sigma.fst hb').trans (congrArg Sigma.fst hp').symm
+  · rw [cmp.partner_coordinate x e he]
+    simp [affine,hrev,hz]
+
+/-- A near-full actual self-link is a nonzero translation. Reversed self-links
+are infeasible for an immersed block, by the midpoint obstruction. -/
+theorem self_link_translation {A : Type*} (bar : A → A)
+    (hbar : Function.Involutive bar) (hfree : ∀ a, bar a ≠ a)
+    (w : C → ℤ → A)
+    (hcompare : ∀ x e, cmp.side x = some e →
+      w x.1.1 x.2.val = if cmp.reverse e then
+        bar (w (cmp.pairing.partner x).1.1 (cmp.pairing.partner x).2.val)
+      else w (cmp.pairing.partner x).1.1 (cmp.pairing.partner x).2.val)
+    (hwordred : ∀ (i : Underlying s len) q,
+      lower s len i ≤ q → q+1 < upper s len i → w i.1 (q+1) ≠ bar (w i.1 q))
+    (hreduced : ∀ x e, cmp.side x = some e →
+      (x.1.1,x.2.val) ≠ ((cmp.pairing.partner x).1.1,(cmp.pairing.partner x).2.val))
+    (i : Underlying s len) (k t : Fin (m i.1)) (e : E)
+    (hmass : height s len i < 2*((data s hs len m cmp err).slice e ⟨i,k⟩ ⟨i,t⟩).card) :
+    cmp.reverse e = false ∧ cmp.offset e ≠ 0 := by
+  have hne : ((data s hs len m cmp err).slice e ⟨i,k⟩ ⟨i,t⟩).Nonempty :=
+    Finset.card_pos.mp (by omega)
+  have hne' : ((cmp.matchingData s hs (traversalLength len m) err).slice e
+    ((occurrenceEquiv s len m).symm ⟨i,k⟩) ((occurrenceEquiv s len m).symm ⟨i,t⟩)).Nonempty := hne
+  obtain ⟨hsrc,htgt⟩ := cmp.slice_sources s hs (traversalLength len m) err hne'
+  have hrev : cmp.reverse e = false := by
+    cases hr : cmp.reverse e with
+    | false => rfl
+    | true =>
+      have hh := IntervalSelfLinks.reflection_not_large bar hbar hfree (w i.1)
+        (lower s len i) (upper s len i) ⌈cmp.lo e-1/2⌉ ⌈cmp.hi e-1/2⌉ (cmp.offset e)
+        (hwordred i) (by
+          intro q hq
+          have hc := self_comparison s hs len m cmp bar w hcompare i k t e hsrc htgt q (by rwa [hr])
+          simpa [hr,affine] using hc)
+      rw [self_slice_card s hs len m cmp err i k t e hsrc htgt,hr] at hmass
+      change (block s i.2.val).card < _ at hmass
+      rw [block_interval] at hmass
+      omega
+  exact ⟨hrev,self_shift_ne_zero s hs len m cmp err hreduced i k t e hne hrev⟩
+
+theorem height_eq (i : Underlying s len) :
+    height s len i = (upper s len i-lower s len i).toNat := by
+  rw [height,block_interval,Int.card_Ico]
+
+/-- The actual word on an underlying block, in its chain orientation. -/
+def word (w : C → ℤ → A) (i : Underlying s len) (k : Fin (height s len i)) : A :=
+  w i.1 ((k.val : ℤ)+lower s len i)
+
+theorem word_at_coordinateN (w : C → ℤ → A) (i : Underlying s len)
+    (q : Finset.Ico (lower s len i) (upper s len i)) :
+    word s len w i (IntervalSelfLinks.coordinateN (lower s len i) (upper s len i)
+      (height s len i) (height_eq s len i) q) = w i.1 q.val := by
+  unfold word
+  rw [IntervalSelfLinks.coordinateN_val,sub_add_cancel]
+
+/-- A chosen literal self-comparison yields a fixed translation forest that
+works for all compatible words. Its cardinality is the original slice's, not
+an unrelated proxy for the number of constraints. -/
+theorem self_translation_constraints
+    (i : Underlying s len) (k t : Fin (m i.1)) (e : E)
+    (hsource : (⟨i.1,k⟩ : Traversal m) = cmp.source e)
+    (htarget : (⟨i.1,t⟩ : Traversal m) = cmp.source (cmp.flip e))
+    (hrev : cmp.reverse e = false) (hz : cmp.offset e ≠ 0) :
+    ∃ tr : BlockConstraints.Translation (height s len i),
+      tr.domain.card = ((data s hs len m cmp err).slice e ⟨i,k⟩ ⟨i,t⟩).card ∧
+      ∀ (A : Type*) (bar : A → A) (w : C → ℤ → A),
+        (∀ x e, cmp.side x = some e →
+          w x.1.1 x.2.val = if cmp.reverse e then
+            bar (w (cmp.pairing.partner x).1.1 (cmp.pairing.partner x).2.val)
+          else w (cmp.pairing.partner x).1.1 (cmp.pairing.partner x).2.val) →
+        ∀ q : tr.domain, word s len w i (tr.target q) = word s len w i q.val := by
+  obtain ⟨tr,hcard,htr⟩ := IntervalSelfLinks.translation_from_slice_at
+    (lower s len i) (upper s len i) ⌈cmp.lo e-1/2⌉ ⌈cmp.hi e-1/2⌉ (cmp.offset e) hz
+    (height s len i) (height_eq s len i)
+  refine ⟨tr,?_,?_⟩
+  · rw [hcard,self_slice_card s hs len m cmp err i k t e hsource htarget,hrev]
+  · intro A bar w hcompare
+    apply htr A (word s len w i)
+    intro q hq
+    rw [word_at_coordinateN,word_at_coordinateN]
+    have hc := self_comparison s hs len m cmp bar w hcompare i k t e hsource htarget q (by rwa [hrev])
+    simpa [hrev,affine] using hc.symm
+
+theorem positions_height (o : LinkComponents.Occurrence (multiplicity s len m)) :
+    ((data s hs len m cmp err).positions o).card = height s len o.1 := by
+  have hh := Fintype.card_congr (repeatedCoordinate s hs len m cmp err o)
+  simpa only [Fintype.card_coe,Fintype.card_fin] using hh
+
+/-- Every literal self-linked component has a root and a translation forest
+of the prescribed deficit. A single feasible immersed labeling rules out the
+reflection case; the resulting forest then constrains every feasible labeling. -/
+theorem self_component_translation [Fintype C]
+    {A : Type*} (bar : A → A) (hbar : Function.Involutive bar) (hfree : ∀ a, bar a ≠ a)
+    (w₀ : C → ℤ → A)
+    (hcompare₀ : ∀ x e, cmp.side x = some e →
+      w₀ x.1.1 x.2.val = if cmp.reverse e then
+        bar (w₀ (cmp.pairing.partner x).1.1 (cmp.pairing.partner x).2.val)
+      else w₀ (cmp.pairing.partner x).1.1 (cmp.pairing.partner x).2.val)
+    (hwordred : ∀ (i : Underlying s len) q,
+      lower s len i ≤ q → q+1 < upper s len i → w₀ i.1 (q+1) ≠ bar (w₀ i.1 q))
+    (hreduced : ∀ x e, cmp.side x = some e →
+      (x.1.1,x.2.val) ≠ ((cmp.pairing.partner x).1.1,(cmp.pairing.partner x).2.val))
+    (c : LinkComponents.Component (multiplicity s len m) (data s hs len m cmp err).matching)
+    (hc : LinkComponents.HasSelf (multiplicity s len m) (data s hs len m cmp err).matching c) :
+    ∃ (i : c) (tr : BlockConstraints.Translation (height s len i.val)),
+      height s len i.val-tr.domain.card ≤ err ∧
+      ∀ (A : Type*) (bar : A → A) (w : C → ℤ → A),
+        (∀ x e, cmp.side x = some e →
+          w x.1.1 x.2.val = if cmp.reverse e then
+            bar (w (cmp.pairing.partner x).1.1 (cmp.pairing.partner x).2.val)
+          else w (cmp.pairing.partner x).1.1 (cmp.pairing.partner x).2.val) →
+        ∀ q : tr.domain, word s len w i.val (tr.target q) = word s len w i.val q.val := by
+  obtain ⟨o,ho,hmatched,hself⟩ := hc
+  obtain ⟨p,hjoin⟩ := ((data s hs len m cmp err).matched_iff o).mp hmatched
+  have hp := (data s hs len m cmp err).partner_spec hjoin
+  change (data s hs len m cmp err).partner o = p at hp
+  change ((data s hs len m cmp err).partner o).1 = o.1 at hself
+  rw [hp] at hself
+  rcases o with ⟨i,k⟩
+  rcases p with ⟨j,t⟩
+  dsimp at hself
+  subst j
+  obtain ⟨e,hmass,_,hdef,_⟩ := hjoin
+  rw [positions_height] at hmass hdef
+  obtain ⟨hr,hz⟩ := self_link_translation s hs len m cmp err bar hbar hfree w₀
+    hcompare₀ hwordred hreduced i k t e hmass
+  have hne : ((cmp.matchingData s hs (traversalLength len m) err).slice e
+    ((occurrenceEquiv s len m).symm ⟨i,k⟩) ((occurrenceEquiv s len m).symm ⟨i,t⟩)).Nonempty :=
+    Finset.card_pos.mp (by change 0 < ((data s hs len m cmp err).slice e ⟨i,k⟩ ⟨i,t⟩).card; omega)
+  obtain ⟨hsrc,htgt⟩ := cmp.slice_sources s hs (traversalLength len m) err hne
+  obtain ⟨tr,hcard,htr⟩ := self_translation_constraints s hs len m cmp err i k t e hsrc htgt hr hz
+  refine ⟨⟨i,ho⟩,tr,?_,htr⟩
+  rw [hcard]
+  change height s len i ≤ ((data s hs len m cmp err).slice e ⟨i,k⟩ ⟨i,t⟩).card+err at hdef
+  exact Nat.sub_le_iff_le_add.mpr (by simpa only [Nat.add_comm] using hdef)
+
+end TorsionFreeZeroDivisors.RepeatedBlocks
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/GroupRing/ListPassages.lean b/lean/OAI/Algebra/GroupRing/ListPassages.lean
new file mode 100644
index 0000000000000000000000000000000000000000..c75b5272376c7c4f9d947d5d469ab82d4a25b132
--- /dev/null
+++ b/lean/OAI/Algebra/GroupRing/ListPassages.lean
@@ -0,0 +1,520 @@
+import Mathlib
+import OAI.Algebra.GroupRing.TypeWeights
+import OAI.Algebra.GroupRing.PathIncidences
+
+namespace OAI
+
+noncomputable section
+
+namespace TorsionFreeZeroDivisors.ListPassages
+open scoped Classical BigOperators
+
+lemma rotate_val {n : ℕ} (i : Fin n) :
+    (finRotate n i).val = if i.val+1=n then 0 else i.val+1 := by
+  cases n with
+  | zero => exact Fin.elim0 i
+  | succ n =>
+    rw [coe_finRotate]
+    have h : i=Fin.last n ↔ i.val+1=n+1 := by
+      constructor
+      · intro he; subst i; rfl
+      · intro he; apply Fin.ext; simp only [Fin.val_last]; omega
+    simp only [h]
+
+variable {D : Type*} (p : List D) (hp : p ≠ [])
+
+def start : Fin p.length := ⟨0,List.length_pos_iff.mpr hp⟩
+
+def cut (cyclic : Bool) : Option (Fin p.length) :=
+  if cyclic then none else some (start p hp)
+
+lemma last_mem (i : Fin p.length) (hi : i.val+1=p.length) :
+    p.get i ∈ p.getLast? := by
+  have hp : p≠[] := List.length_pos_iff.mp (Nat.zero_lt_of_lt i.isLt)
+  rw [List.getLast?_eq_some_getLast hp]
+  apply Option.mem_def.mpr
+  congr 1
+  rw [List.getLast_eq_getElem,List.get_eq_getElem]
+  congr 1
+  omega
+
+lemma first_mem (i : Fin p.length) (hi : i.val=0) : p.get i ∈ p.head? := by
+  cases p with
+  | nil => exact Fin.elim0 i
+  | cons a p =>
+    have he : i=⟨0,by simp⟩ := Fin.ext hi
+    subst i
+    rfl
+
+/-- The cyclic successor on actual list occurrences pairs exactly the internal
+passages, plus the closing passage precisely when the path is cyclic. -/
+theorem passage {R : D → D → Prop} (hc : p.IsChain R) (cyclic : Bool)
+    (hclose : cyclic=true → ∀ᵉ (x∈p.getLast?) (y∈p.head?),R x y)
+    (i : Fin p.length) (hcut : cut p hp cyclic ≠ some (finRotate p.length i)) :
+    R (p.get i) (p.get (finRotate p.length i)) := by
+  by_cases hi : i.val+1=p.length
+  · have hr : (finRotate p.length i).val=0 := by rw [rotate_val,ite_eq_left hi]
+    have hcyc : cyclic=true := by
+      cases cyclic
+      · exfalso
+        apply hcut
+        apply congrArg some
+        apply Fin.ext
+        exact hr.symm
+      · rfl
+    exact hclose hcyc _ (last_mem p i hi) _ (first_mem p _ hr)
+  · have hir : i.val+1<p.length := by omega
+    have hr : (finRotate p.length i).val=i.val+1 := by rw [rotate_val,ite_eq_right hi]
+    have h := (List.isChain_iff_getElem.mp hc) i.val hir
+    simpa only [List.get_eq_getElem,hr] using h
+
+end TorsionFreeZeroDivisors.ListPassages
+namespace TorsionFreeZeroDivisors.ChainPathTransport
+open Function PortSubdivision ChainSuppression DegreeTwoSuppression SuppressedMoore ChainPaths
+open WeightedMoore
+open scoped Classical BigOperators
+variable {V D : Type*} [Fintype D] (Γ : PortGraph V D)
+    (mark : V → Prop) (h2 : ∀ v, ¬mark v → (out Γ.origin v).card=2)
+local notation "τ" => turn Γ.origin mark h2
+local notation "B" => {d : D // τ d=d}
+local notation "S" => suppressed Γ mark h2
+local notation "w" => word Γ mark h2
+
+omit [Fintype D] in
+lemma outWord_head {k : ℕ} (p : WeightedMoore.Chain D k) :
+    (SuppressedMoore.outWord p).head?=some (WeightedMoore.head p) := by
+  cases k <;> rfl
+
+lemma word_head (d : B) : (w d).head?=some d.val := by
+  rw [word,outWord_head,head_iterChain]
+
+lemma word_last (d : B) : (w d).getLast?=some (Γ.reverse ((S).reverse d).val) := by
+  rw [word,outWord_last]
+  apply congrArg some
+  exact Γ.reverse_reverse.injective (by rw [chain_last,Γ.reverse_reverse])
+
+lemma word_ne_nil (d : B) : w d ≠ [] := by
+  intro he
+  have h := word_length Γ mark h2 d
+  rw [he,List.length_nil] at h
+  have hp := chainLength_pos Γ mark h2 d
+  omega
+
+/-- A genuine reduced original path transports to a genuine reduced path in
+its suppressed graph. Adjacency is read from the actual last/first darts;
+no graph path property is imposed on the decomposition as a hypothesis. -/
+theorem isChain (ds : List B)
+    (hp : (ds.flatMap w).IsChain (PortWalk.step Γ.origin Γ.reverse)) :
+    ds.IsChain (PortWalk.step (S).origin (S).reverse) := by
+  have hn : [] ∉ ds.map w := by
+    intro he
+    obtain ⟨d,_,hd⟩ := List.mem_map.mp he
+    exact word_ne_nil Γ mark h2 d hd
+  have hc := (List.isChain_flatten hn).mp hp
+  have hc' := (List.isChain_map w).mp hc.2
+  apply hc'.imp
+  intro a b hab
+  have he := hab _ (word_last Γ mark h2 a) _ (word_head Γ mark h2 b)
+  simp only [PortWalk.step] at he
+  rw [Γ.reverse_reverse] at he
+  refine ⟨he.1,?_⟩
+  intro hb
+  exact he.2 (congrArg Subtype.val hb)
+
+lemma flatMap_head (ds : List B) :
+    (ds.flatMap w).head? = ds.head?.map Subtype.val := by
+  cases ds with
+  | nil => rfl
+  | cons d ds =>
+    rw [List.flatMap_cons,List.head?_append_of_ne_nil _ (word_ne_nil Γ mark h2 d)]
+    exact word_head Γ mark h2 d
+
+lemma flatMap_last (ds : List B) :
+    (ds.flatMap w).getLast? = ds.getLast?.map (fun d => Γ.reverse ((S).reverse d).val) := by
+  induction ds using List.reverseRecOn with
+  | nil => rfl
+  | append_singleton ds d _ih =>
+    simp only [List.flatMap_append,List.flatMap_singleton]
+    rw [List.getLast?_append_of_ne_nil _ (word_ne_nil Γ mark h2 d)]
+    simp only [List.getLast?_concat,Option.map_some,word_last]
+
+/-- The closing passage of a cyclically immersed path survives suppression. -/
+theorem closing (ds : List B)
+    (hc : ∀ᵉ (x∈(ds.flatMap w).getLast?) (y∈(ds.flatMap w).head?),
+      PortWalk.step Γ.origin Γ.reverse x y) :
+    ∀ᵉ (a∈ds.getLast?) (b∈ds.head?),PortWalk.step (S).origin (S).reverse a b := by
+  intro a ha b hb
+  have hl : Γ.reverse ((S).reverse a).val ∈ (ds.flatMap w).getLast? := by
+    rw [flatMap_last]
+    exact Option.mem_map_of_mem _ ha
+  have hh : b.val ∈ (ds.flatMap w).head? := by
+    rw [flatMap_head]
+    exact Option.mem_map_of_mem _ hb
+  have he := hc _ hl _ hh
+  simp only [PortWalk.step] at he
+  rw [Γ.reverse_reverse] at he
+  exact ⟨he.1,fun h => he.2 (congrArg Subtype.val h)⟩
+
+/-- The decomposition retains all reduced passages and both geometric
+endpoints. Cyclic closing passages therefore also transport unchanged. -/
+theorem decomposes (p : List D)
+    (hp : p.IsChain (PortWalk.step Γ.origin Γ.reverse))
+    (hs : ∀ d∈p.head?,mark (Γ.origin d))
+    (ht : ∀ d∈p.getLast?,mark (Γ.origin (Γ.reverse d))) :
+    ∃ ds : List B, ds.flatMap w=p ∧
+      ds.IsChain (PortWalk.step (S).origin (S).reverse) ∧
+      ds.head?.map Subtype.val=p.head? ∧
+      ds.getLast?.map (fun d => Γ.reverse ((S).reverse d).val)=p.getLast? := by
+  obtain ⟨ds,hd⟩ := path_decomposes Γ mark h2 p hp hs ht
+  refine ⟨ds,hd,isChain Γ mark h2 ds (hd.symm ▸ hp),?_,?_⟩
+  · rw [←flatMap_head,hd]
+  · rw [←flatMap_last,hd]
+
+end TorsionFreeZeroDivisors.ChainPathTransport
+namespace TorsionFreeZeroDivisors.ListStageExponents
+open scoped Classical BigOperators
+open PortSubdivision WeightedMoore StageSubgraphs
+variable {V D I : Type*} [Fintype V] [Fintype D] [Fintype I]
+    (Γ : PortGraph V D) (p : I → List D) (hp : ∀ i,p i ≠ [])
+    (cyclic : I → Bool)
+    (hc : ∀ i,(p i).IsChain (PortWalk.step Γ.origin Γ.reverse))
+    (hclose : ∀ i,cyclic i=true → ∀ᵉ (x∈(p i).getLast?) (y∈(p i).head?),
+      PortWalk.step Γ.origin Γ.reverse x y)
+
+abbrev edge (i : I) : Fin (p i).length → D := (p i).get
+abbrev mult : D → ℕ := multiplicity Γ (edge p)
+
+omit [Fintype D] in
+theorem cut_count : (∑ i,if (ListPassages.cut (p i) (hp i) (cyclic i)).isSome then 1 else 0 : ℕ) =
+    Fintype.card {i : I // cyclic i=false} := by
+  rw [Fintype.card_subtype,Finset.card_filter]
+  apply Finset.sum_congr rfl
+  intro i _
+  cases cyclic i <;> simp [ListPassages.cut]
+
+include hp hc hclose in
+/-- The exact signed stage exponent of literal immersed paths, including a
+root saving for each noncyclic interval only at the first stage. -/
+theorem exponent_nonpos (M : ℕ) (hM : 0<M) (hm : ∀ d,mult Γ p d ≤ M) :
+    (∑ j : Fin M, ((Fintype.card (ActiveV Γ (mult Γ p) j.val):ℤ)-
+      (edges (stage Γ (mult Γ p) (multiplicity_reverse Γ (edge p)) j.val)).card-
+      if j.val=0 then Fintype.card {i : I // cyclic i=false} else 0)) ≤ 0 := by
+  have hv : ∀ i (e : Fin (p i).length),
+      ListPassages.cut (p i) (hp i) (cyclic i) ≠ some (finRotate (p i).length e) →
+      Γ.origin (edge p i (finRotate (p i).length e))=Γ.origin (Γ.reverse (edge p i e)) := by
+    intro i e he
+    exact (ListPassages.passage (p i) (hp i) (hc i) (cyclic i) (hclose i) e he).1.symm
+  have hr : ∀ i (e : Fin (p i).length),
+      ListPassages.cut (p i) (hp i) (cyclic i) ≠ some (finRotate (p i).length e) →
+      edge p i (finRotate (p i).length e)≠Γ.reverse (edge p i e) := by
+    intro i e he
+    exact (ListPassages.passage (p i) (hp i) (hc i) (cyclic i) (hclose i) e he).2
+  have h := family_exponent_nonpos Γ (edge p) (fun i => finRotate (p i).length)
+    (fun i => ListPassages.cut (p i) (hp i) (cyclic i)) hv hr M hM hm
+  rw [cut_count] at h
+  exact h
+
+end TorsionFreeZeroDivisors.ListStageExponents
+
+/-! A choice of one direction for each unoriented edge of a finite port graph.
+The reversal has no fixed points. No graph is assumed bipartite or loop-free. -/
+namespace TorsionFreeZeroDivisors.InvolutionOrientation
+open scoped Classical BigOperators
+variable {D : Type*} [Fintype D] (σ : D → D)
+
+def rank (d : D) : Fin (Fintype.card D) := Fintype.equivFin D d
+
+def Chosen (d : D) : Prop := rank d < rank (σ d)
+abbrev Representative := {d : D // Chosen σ d}
+
+variable (hσ : Function.Involutive σ) (hne : ∀d,σ d≠d)
+
+include hne in
+lemma rank_ne (d : D) : rank d ≠ rank (σ d) := by
+  intro h
+  exact hne d ((Fintype.equivFin D).injective h).symm
+
+include hσ hne
+
+lemma chosen_or_reverse (d : D) : Chosen σ d ∨ Chosen σ (σ d) := by
+  unfold Chosen
+  rw [hσ]
+  exact lt_or_gt_of_ne (rank_ne σ hne d)
+
+lemma chosen_reverse_iff (d : D) : Chosen σ (σ d) ↔ ¬Chosen σ d := by
+  unfold Chosen
+  rw [hσ]
+  exact ⟨fun h h' => (lt_asymm h h'),fun h => lt_of_le_of_ne (le_of_not_gt h) (rank_ne σ hne d).symm⟩
+
+def orient (x : Representative σ × Bool) : D := if x.2 then σ x.1.val else x.1.val
+
+lemma orient_injective : Function.Injective (orient σ) := by
+  rintro ⟨⟨a,ha⟩,i⟩ ⟨⟨b,hb⟩,j⟩ he
+  cases i <;> cases j
+  · simp only [orient,Bool.false_eq_true,ite_false] at he
+    cases he
+    rfl
+  · simp only [orient,Bool.false_eq_true,ite_false,ite_true] at he
+    have hna := (chosen_reverse_iff σ hσ hne b).mp (he ▸ ha)
+    exact (hna hb).elim
+  · simp only [orient,Bool.false_eq_true,ite_false,ite_true] at he
+    have hnb := (chosen_reverse_iff σ hσ hne a).mp (he.symm ▸ hb)
+    exact (hnb ha).elim
+  · simp only [orient,ite_true] at he
+    have hab := hσ.injective he
+    cases hab
+    rfl
+
+lemma orient_surjective : Function.Surjective (orient σ) := by
+  intro d
+  rcases chosen_or_reverse σ hσ hne d with hd|hd
+  · exact ⟨(⟨d,hd⟩,false),rfl⟩
+  · exact ⟨(⟨σ d,hd⟩,true),hσ d⟩
+
+def equiv : Representative σ × Bool ≃ D :=
+  Equiv.ofBijective (orient σ) ⟨orient_injective σ hσ hne,orient_surjective σ hσ hne⟩
+
+@[simp] lemma equiv_false (c : Representative σ) : equiv σ hσ hne (c,false) = c.val := rfl
+@[simp] lemma equiv_true (c : Representative σ) : equiv σ hσ hne (c,true) = σ c.val := rfl
+
+lemma rep_card : 2*Fintype.card (Representative σ) = Fintype.card D := by
+  have h := Fintype.card_congr (equiv σ hσ hne)
+  simpa only [Fintype.card_prod,Fintype.card_bool,mul_comm] using h
+
+lemma sum_invariant (f : D → ℕ) (hf : ∀d,f (σ d)=f d) :
+    ∑d,f d = 2*∑c : Representative σ,f c.val := by
+  rw [←Equiv.sum_comp (equiv σ hσ hne)]
+  simp only [Fintype.sum_prod_type,Fintype.sum_bool,equiv_true,equiv_false,hf]
+  rw [Finset.sum_add_distrib]
+  omega
+
+end TorsionFreeZeroDivisors.InvolutionOrientation
+namespace TorsionFreeZeroDivisors.ChainIsomorphism
+open Function PortSubdivision ChainSuppression DegreeTwoSuppression SuppressedMoore
+open scoped Classical BigOperators
+variable {V D : Type*} [Fintype D] (Γ : PortGraph V D)
+    (mark : V → Prop) (h2 : ∀ v, ¬mark v → (out Γ.origin v).card=2)
+local notation "τ" => turn Γ.origin mark h2
+local notation "F" => next Γ.reverse τ
+local notation "B" => {d : D // τ d=d}
+local notation "S" => suppressed Γ mark h2
+local notation "R" => InvolutionOrientation.Representative (PortGraph.reverse (suppressed Γ mark h2))
+local notation "len" => chainLength Γ mark h2
+
+abbrev Rep := R
+abbrev repLength (c : R) := len c.val
+abbrev Mark := {v : V // mark v}
+
+def first (c : R) : Mark mark :=
+  ⟨Γ.origin c.val.val,(turn_fixed_iff Γ.origin mark h2 _).mp c.val.property⟩
+def last (c : R) : Mark mark :=
+  ⟨Γ.origin ((S).reverse c.val).val,(turn_fixed_iff Γ.origin mark h2 _).mp ((S).reverse c.val).property⟩
+
+local notation "P" => ChainSubdivision.graph (repLength Γ mark h2) (first Γ mark h2) (last Γ mark h2)
+
+def dartMap (d : ChainSubdivision.Dart (repLength Γ mark h2)) : D :=
+  if d.2 then Γ.reverse (F^[d.1.2.val] d.1.1.val.val) else F^[d.1.2.val] d.1.1.val.val
+
+lemma forward_mem (c : R) (i : Fin (len c.val)) :
+    F^[i.val] c.val.val ∈ ChainPaths.word Γ mark h2 c.val :=
+  (ChainPaths.mem_word_iff Γ mark h2 _ _).mpr ⟨i,rfl⟩
+
+lemma dart_mem (d : ChainSubdivision.Dart (repLength Γ mark h2)) :
+    dartMap Γ mark h2 d ∈ ChainPaths.word Γ mark h2
+      (InvolutionOrientation.orient (S).reverse (d.1.1,d.2)) := by
+  cases hb : d.2
+  · simpa only [dartMap,InvolutionOrientation.orient,hb,Bool.false_eq_true,ite_false] using
+      forward_mem Γ mark h2 d.1.1 d.1.2
+  · simpa only [dartMap,InvolutionOrientation.orient,hb,ite_true] using
+      ChainPaths.reverse_mem_word Γ mark h2 _ _ (forward_mem Γ mark h2 d.1.1 d.1.2)
+
+lemma same_word {a b : B} {x : D} (ha : x∈ChainPaths.word Γ mark h2 a)
+    (hb : x∈ChainPaths.word Γ mark h2 b) : a=b := by
+  by_contra h
+  exact ChainPaths.words_disjoint Γ mark h2 h ha hb
+
+lemma dartMap_injective : Injective (dartMap Γ mark h2) := by
+  rintro ⟨⟨a,i⟩,u⟩ ⟨⟨b,j⟩,v⟩ he
+  have hw := same_word Γ mark h2 (dart_mem Γ mark h2 ((⟨a,i⟩),u))
+    (he.symm ▸ dart_mem Γ mark h2 ((⟨b,j⟩),v))
+  have hab := InvolutionOrientation.orient_injective (S).reverse (S).reverse_reverse (S).reverse_ne hw
+  obtain ⟨rfl,rfl⟩ := Prod.mk.inj hab
+  have hi : F^[i.val] a.val.val=F^[j.val] a.val.val := by
+    cases u
+    · exact he
+    · exact Γ.reverse_reverse.injective he
+  have hij := chain_dart_injective Γ.reverse τ Γ.reverse_reverse (turn_involutive Γ.origin mark h2)
+    (a₁ := ⟨a.val,i⟩) (a₂ := ⟨a.val,j⟩) hi
+  have hij' : i=j := Fin.ext (congrArg (fun z => z.2.val) hij)
+  cases hij'
+  rfl
+
+lemma dartMap_surjective (hcovered : ∀ d : D, ChainCoverage.Covered Γ.reverse (turn Γ.origin mark h2) Γ.reverse_reverse (turn_involutive Γ.origin mark h2) d) : Surjective (dartMap Γ mark h2) := by
+  intro x
+  rcases hcovered x with ⟨b,i,hi⟩
+  rcases InvolutionOrientation.chosen_or_reverse (S).reverse
+    (S).reverse_reverse (S).reverse_ne b with hb|hb
+  · exact ⟨(⟨⟨b,hb⟩,i⟩,false),hi⟩
+  · have hx : x∈ChainPaths.word Γ mark h2 b :=
+      (ChainPaths.mem_word_iff Γ mark h2 _ _).mpr ⟨i,hi⟩
+    have hr := ChainPaths.reverse_mem_word Γ mark h2 b x hx
+    rcases (ChainPaths.mem_word_iff Γ mark h2 _ _).mp hr with ⟨j,hj⟩
+    refine ⟨(⟨⟨(S).reverse b,hb⟩,j⟩,true),?_⟩
+    exact (congrArg Γ.reverse hj).trans (Γ.reverse_reverse x)
+
+def dartEquiv (hcovered : ∀ d : D, ChainCoverage.Covered Γ.reverse (turn Γ.origin mark h2) Γ.reverse_reverse (turn_involutive Γ.origin mark h2) d) : ChainSubdivision.Dart (repLength Γ mark h2) ≃ D :=
+  Equiv.ofBijective (dartMap Γ mark h2)
+    ⟨dartMap_injective Γ mark h2,dartMap_surjective Γ mark h2 hcovered⟩
+
+lemma dartMap_reverse (d : ChainSubdivision.Dart (repLength Γ mark h2)) :
+    dartMap Γ mark h2 ((P).reverse d)=Γ.reverse (dartMap Γ mark h2 d) := by
+  cases hb : d.2 <;> simp only [ChainSubdivision.reverse,dartMap,hb,Bool.not_false,Bool.not_true,
+    Bool.false_eq_true,ite_false,ite_true]
+  exact (Γ.reverse_reverse _).symm
+
+def vertexMap : ChainSubdivision.Vertex (repLength Γ mark h2) (V := Mark mark) → V
+  | .inl v => v.val
+  | .inr ⟨c,i⟩ => Γ.origin (F^[i.val+1] c.val.val)
+
+lemma internal_unmarked (v : ChainSubdivision.Interior (repLength Γ mark h2)) :
+    ¬mark (vertexMap Γ mark h2 (.inr v)) := by
+  intro hh
+  have hf := (turn_fixed_iff Γ.origin mark h2 _).mpr hh
+  have hi : v.2.val+1 < len v.1.val := by have h:=v.2.isLt; dsimp only [repLength] at h; omega
+  exact no_internal_mark Γ.reverse τ Γ.reverse_reverse (turn_involutive Γ.origin mark h2)
+    v.1.val.val v.1.val.property (by omega : 0<v.2.val+1) hi hf
+
+lemma origin_map (d : ChainSubdivision.Dart (repLength Γ mark h2)) :
+    vertexMap Γ mark h2 ((P).origin d) = Γ.origin (dartMap Γ mark h2 d) := by
+  rcases d with ⟨⟨c,i⟩,b⟩
+  cases b
+  · rw [ChainSubdivision.origin_forward]
+    by_cases hz : i.val=0
+    · simp only [ChainSubdivision.point,Fin.val_mk,hz,dite_eq_left,vertexMap,first,dartMap,
+        Bool.false_eq_true,ite_false]
+      rfl
+    · have hl : i.val≠repLength Γ mark h2 c := Nat.ne_of_lt i.isLt
+      simp only [ChainSubdivision.point,hz,hl,vertexMap,dartMap,
+        Bool.false_eq_true,ite_false]
+      change Γ.origin (F^[i.val-1+1] c.val.val) = Γ.origin (F^[i.val] c.val.val)
+      rw [Nat.sub_add_cancel (Nat.pos_of_ne_zero hz)]
+  · rw [ChainSubdivision.origin_backward]
+    have hz : i.val+1≠0 := by omega
+    by_cases hl : i.val+1=repLength Γ mark h2 c
+    · have hp : repLength Γ mark h2 c≠0 := Nat.ne_of_gt (chainLength_pos Γ mark h2 c.val)
+      simp only [ChainSubdivision.point,Fin.val_mk,hl,hp,dite_eq_left,vertexMap,last,
+        dartMap,ite_true]
+      have hi : i.val=len c.val-1 := by change i.val+1=len c.val at hl; omega
+      have he := chain_last Γ mark h2 c.val
+      rw [last_iterChain] at he
+      change Γ.origin ((S).reverse c.val).val = Γ.origin (Γ.reverse (F^[i.val] c.val.val))
+      rw [hi,he]
+    · simp only [ChainSubdivision.point,hz,hl,vertexMap,dartMap,ite_true]
+      change Γ.origin (F^[i.val+1-1+1] c.val.val) = Γ.origin (Γ.reverse (F^[i.val] c.val.val))
+      rw [Nat.add_sub_cancel,iterate_succ_apply']
+      exact turn_origin Γ.origin mark h2 _
+
+lemma original_two_ports (v : ChainSubdivision.Interior (repLength Γ mark h2))
+    (d : D) (hd : Γ.origin d=vertexMap Γ mark h2 (.inr v)) :
+    d=dartMap Γ mark h2 (ChainSubdivision.front (repLength Γ mark h2) v) ∨
+    d=dartMap Γ mark h2 (ChainSubdivision.back (repLength Γ mark h2) v) := by
+  let a := ChainSubdivision.front (repLength Γ mark h2) v
+  let b := ChainSubdivision.back (repLength Γ mark h2) v
+  have ha : Γ.origin (dartMap Γ mark h2 a)=vertexMap Γ mark h2 (.inr v) := by
+    rw [←origin_map,ChainSubdivision.front_origin]
+  have hb : Γ.origin (dartMap Γ mark h2 b)=vertexMap Γ mark h2 (.inr v) := by
+    rw [←origin_map,ChainSubdivision.back_origin]
+  by_cases hda : d=dartMap Γ mark h2 a
+  · exact Or.inl hda
+  · right
+    have hba : dartMap Γ mark h2 b≠dartMap Γ mark h2 a := by
+      intro hh
+      exact ChainSubdivision.back_ne_front _ v (dartMap_injective Γ mark h2 hh)
+    exact ((unique_other Γ.origin (dartMap Γ mark h2 a)
+      (h2 _ (ha ▸ internal_unmarked Γ mark h2 v))).unique
+        ⟨hd.trans ha.symm,hda⟩ ⟨hb.trans ha.symm,hba⟩)
+
+lemma vertexMap_injective : Injective (vertexMap Γ mark h2) := by
+  intro a b he
+  cases a with
+  | inl a =>
+    cases b with
+    | inl b => exact congrArg Sum.inl (Subtype.ext he)
+    | inr b => exact (internal_unmarked Γ mark h2 b (he ▸ a.property)).elim
+  | inr a =>
+    cases b with
+    | inl b => exact (internal_unmarked Γ mark h2 a (he.symm ▸ b.property)).elim
+    | inr b =>
+      have hb : Γ.origin (dartMap Γ mark h2 (ChainSubdivision.front (repLength Γ mark h2) b)) =
+          vertexMap Γ mark h2 (.inr a) := by
+        rw [←origin_map,ChainSubdivision.front_origin,he]
+      rcases original_two_ports Γ mark h2 a _ hb with h|h
+      · have hh := dartMap_injective Γ mark h2 h
+        have h' := congrArg (fun d => (P).origin d) hh
+        simpa only [ChainSubdivision.front_origin] using h'.symm
+      · have hh := dartMap_injective Γ mark h2 h
+        have h' := congrArg Prod.snd hh
+        cases h'
+
+lemma vertexMap_surjective (hcovered : ∀ d : D, ChainCoverage.Covered Γ.reverse (turn Γ.origin mark h2) Γ.reverse_reverse (turn_involutive Γ.origin mark h2) d) : Surjective (vertexMap Γ mark h2) := by
+  intro v
+  by_cases hv : mark v
+  · exact ⟨.inl ⟨v,hv⟩,rfl⟩
+  · have hp : (out Γ.origin v).Nonempty := Finset.card_pos.mp (by rw [h2 v hv]; decide)
+    obtain ⟨d,hd⟩ := hp
+    obtain ⟨a,ha⟩ := dartMap_surjective Γ mark h2 hcovered d
+    refine ⟨(P).origin a,?_⟩
+    rw [origin_map,ha]
+    exact (mem_out Γ.origin v d).mp hd
+
+def vertexEquiv (hcovered : ∀ d : D, ChainCoverage.Covered Γ.reverse (turn Γ.origin mark h2) Γ.reverse_reverse (turn_involutive Γ.origin mark h2) d) : ChainSubdivision.Vertex (repLength Γ mark h2) (V := Mark mark) ≃ V :=
+  Equiv.ofBijective (vertexMap Γ mark h2)
+    ⟨vertexMap_injective Γ mark h2,vertexMap_surjective Γ mark h2 hcovered⟩
+
+/-- Replacing each actual maximal marked chain by a coordinate interval loses no
+vertices, darts, loop chains, parallel chains or reversal information. -/
+theorem subdivision_isomorphic (hcovered : ∀ d : D, ChainCoverage.Covered Γ.reverse (turn Γ.origin mark h2) Γ.reverse_reverse (turn_involutive Γ.origin mark h2) d) :
+    ∃ (eV : ChainSubdivision.Vertex (repLength Γ mark h2) (V := Mark mark) ≃ V)
+      (eD : ChainSubdivision.Dart (repLength Γ mark h2) ≃ D),
+      (∀d,eV ((P).origin d)=Γ.origin (eD d)) ∧
+      (∀d,eD ((P).reverse d)=Γ.reverse (eD d)) :=
+  ⟨vertexEquiv Γ mark h2 hcovered,dartEquiv Γ mark h2 hcovered,
+    origin_map Γ mark h2,dartMap_reverse Γ mark h2⟩
+
+/-- Both orientations of every actual-image edge are retained exactly once. -/
+theorem total_length
+    (hcovered : ∀ d : D, ChainCoverage.Covered Γ.reverse (turn Γ.origin mark h2) Γ.reverse_reverse
+      (turn_involutive Γ.origin mark h2) d) :
+    2 * ∑ c : Rep Γ mark h2, repLength Γ mark h2 c = Fintype.card D := by
+  have he := Fintype.card_congr (dartEquiv Γ mark h2 hcovered)
+  simpa only [ChainSubdivision.card_darts] using he
+
+variable [Fintype V]
+/-- The marked/interior count gives the precise signed stage vertex exponent. -/
+theorem vertex_count
+    (hcovered : ∀ d : D, ChainCoverage.Covered Γ.reverse (turn Γ.origin mark h2) Γ.reverse_reverse
+      (turn_involutive Γ.origin mark h2) d) :
+    Fintype.card V + Fintype.card (Rep Γ mark h2) =
+      Fintype.card (Mark mark) + ∑ c : Rep Γ mark h2, repLength Γ mark h2 c := by
+  rw [←Fintype.card_congr (vertexEquiv Γ mark h2 hcovered)]
+  exact ChainSubdivision.card_vertices _ (fun c => chainLength_pos Γ mark h2 c.val)
+
+omit [Fintype V] in
+/-- The needed coverage is furnished by the actual immersed path system, not
+asserted as an additional structural property of a proposed pattern. -/
+theorem actual_image_isomorphic {J : Type*} (paths : J → List D)
+    (hpaths : ∀ j, (paths j).IsChain (WeightedMoore.PortWalk.step Γ.origin Γ.reverse))
+    (hstarts : ∀ j d, d∈(paths j).head? → mark (Γ.origin d))
+    (himage : ∀ d : D, ∃ j, d∈paths j ∨ Γ.reverse d∈paths j) :
+    ∃ (eV : ChainSubdivision.Vertex (repLength Γ mark h2) (V := Mark mark) ≃ V)
+      (eD : ChainSubdivision.Dart (repLength Γ mark h2) ≃ D),
+      (∀ d,eV ((P).origin d)=Γ.origin (eD d)) ∧
+      (∀ d,eD ((P).reverse d)=Γ.reverse (eD d)) :=
+  subdivision_isomorphic Γ mark h2
+    (ActualMarkedChains.actual_image_covered Γ mark h2 paths hpaths hstarts himage)
+
+end TorsionFreeZeroDivisors.ChainIsomorphism
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/GroupRing/LoopSphere.lean b/lean/OAI/Algebra/GroupRing/LoopSphere.lean
new file mode 100644
index 0000000000000000000000000000000000000000..fd24f995c0175b687dbef2e99c924a1e299343ab
--- /dev/null
+++ b/lean/OAI/Algebra/GroupRing/LoopSphere.lean
@@ -0,0 +1,424 @@
+import Mathlib
+import OAI.Algebra.GroupRing.Cayley
+
+namespace OAI
+
+noncomputable section
+
+open Set Metric Topology BigOperators
+open Set Metric Topology
+
+namespace GroupRingTopology.Cellular
+open Set Metric Topology
+variable {Y : Type*} [TopologicalSpace Y]
+
+/-- One cylinder boundary filling is enough for its path-space lift. -/
+theorem cylinderFill {n : ℕ} (a : C(Sphere n,C(unitInterval,Y))) (b : C(Disk n,Y × Y))
+    (h : ∀ x, pathEndpoint (a x) = b (boundary n x))
+    (F : C(Disk (n+1),Y)) (hF : ∀ x, F (boundary (n+1) x) = cylinderBoundaryMap a b h x) :
+    ∃ e : C(Disk n,C(unitInterval,Y)),
+      (∀ x, e (boundary n x) = a x) ∧ (∀ x, pathEndpoint (e x) = b x) := by
+  let e : C(Disk n,C(unitInterval,Y)) :=
+    (F.comp ⟨fun q : Disk n × unitInterval => diskCons q.1 q.2,continuous_diskCons⟩).curry
+  refine ⟨e,?_,?_⟩
+  · intro x
+    apply ContinuousMap.ext
+    intro t
+    let s : Sphere (n+1) := ⟨_,cons_mem_sphere_of_boundary x t⟩
+    have hs : s ∈ cylinderFace n none := by
+      change (diskTail (diskCons (boundary n x) t)).1 ∈ sphere 0 1
+      rw [diskTail_cons]
+      exact x.2
+    change F (diskCons (boundary n x) t) = a x t
+    rw [show diskCons (boundary n x) t = boundary (n+1) s from rfl,hF,
+      cylinderBoundaryMap_face a b h none ⟨s,hs⟩]
+    change a (faceSphere ⟨s,hs⟩) (diskTime (diskCons (boundary n x) t)) = a x t
+    rw [diskTime_cons]
+    congr 1
+  · intro x
+    apply Prod.ext
+    · let s : Sphere (n+1) := ⟨_,cons_zero_mem_sphere x⟩
+      have hs : s ∈ cylinderFace n (some false) := by
+        change (diskCons x 0).1 0 = -1
+        norm_num [diskCons]
+      change F (diskCons x 0) = (b x).1
+      rw [show diskCons x 0 = boundary (n+1) s from rfl,hF,
+        cylinderBoundaryMap_face a b h (some false) ⟨s,hs⟩]
+      change (b (diskTail (diskCons x 0))).1 = (b x).1
+      rw [diskTail_cons]
+    · let s : Sphere (n+1) := ⟨_,cons_one_mem_sphere x⟩
+      have hs : s ∈ cylinderFace n (some true) := by
+        change (diskCons x 1).1 0 = 1
+        norm_num [diskCons]
+      change F (diskCons x 1) = (b x).2
+      rw [show diskCons x 1 = boundary (n+1) s from rfl,hF,
+        cylinderBoundaryMap_face a b h (some true) ⟨s,hs⟩]
+      change (b (diskTail (diskCons x 1))).2 = (b x).2
+      rw [diskTail_cons]
+
+end GroupRingTopology.Cellular
+namespace GroupRingTopology.LoopSphere
+open Set Metric Topology Cellular
+open scoped unitInterval
+universe u v
+variable {X : Type u} [TopologicalSpace X] {x : X}
+
+def sides : C(Sphere 1,C(I,X)) := .const _ (.const _ x)
+def ends (p : Path x x) : C(Disk 1,X × X) :=
+  ⟨fun d => (p (Cayley.edgeTime d),x),
+    (p.continuous.comp Cayley.continuous_edgeTime).prodMk continuous_const⟩
+lemma ends_sides (p : Path x x) (z : Sphere 1) :
+    pathEndpoint (sides (x := x) z) = ends p (boundary 1 z) := by
+  obtain rfl|rfl := Cayley.sphere_one_eq z
+  · change (x,x) = (p (Cayley.edgeTime (Attachment.boundary 1 Cayley.minus)),x)
+    rw [Cayley.edgeTime_minus,p.source]
+  · change (x,x) = (p (Cayley.edgeTime (Attachment.boundary 1 Cayley.plus)),x)
+    rw [Cayley.edgeTime_plus,p.target]
+
+def map (p : Path x x) : C(Sphere 2,X) := cylinderBoundaryMap sides (ends p) (ends_sides p)
+
+/-- Attaching one ordinary 2-cell along this square boundary kills its loop. -/
+theorem homotopic_of_fill (p : Path x x) (F : C(Disk 2,X))
+    (hF : ∀ z, F (boundary 2 z) = map p z) : p.Homotopic (Path.refl x) := by
+  obtain ⟨e,he,hep⟩ := cylinderFill sides (ends p) (ends_sides p) F hF
+  refine ⟨{
+    toFun := fun z => e (Cayley.edgeParam z.2) z.1
+    continuous_toFun := e.uncurry.continuous.comp
+      ((Cayley.continuous_edgeParam.comp continuous_snd).prodMk continuous_fst)
+    map_zero_left := ?_
+    map_one_left := ?_
+    prop' := ?_ }⟩
+  · intro t
+    have h := congrArg Prod.fst (hep (Cayley.edgeParam t))
+    change e (Cayley.edgeParam t) 0 = p t
+    change e (Cayley.edgeParam t) 0 = p (Cayley.edgeTime (Cayley.edgeParam t)) at h
+    simpa only [Cayley.edgeTime_param] using h
+  · intro t
+    exact congrArg Prod.snd (hep (Cayley.edgeParam t))
+  · intro t q hq
+    obtain rfl|hq := hq
+    · change e (Cayley.edgeParam 0) t = p 0
+      rw [Cayley.edgeParam_zero,p.source]
+      exact ContinuousMap.congr_fun (he Cayley.minus) t
+    · obtain rfl := Set.mem_singleton_iff.mp hq
+      change e (Cayley.edgeParam 1) t = p 1
+      rw [Cayley.edgeParam_one,p.target]
+      exact ContinuousMap.congr_fun (he Cayley.plus) t
+
+variable {Y : Type v} [TopologicalSpace Y]
+lemma natural (p : Path x x) (f : C(X,Y)) : map (p.map f.continuous) = f.comp (map p) := by
+  apply ContinuousMap.ext; intro z
+  have hz : z ∈ ⋃ i, cylinderFace 1 i := by rw [cylinderFace_cover]; trivial
+  obtain ⟨i,hi⟩ := Set.mem_iUnion.mp hz
+  change cylinderBoundaryMap sides (ends (p.map f.continuous)) (ends_sides _) z =
+    f (cylinderBoundaryMap sides (ends p) (ends_sides p) z)
+  rw [cylinderBoundaryMap_face _ _ _ i ⟨z,hi⟩,cylinderBoundaryMap_face _ _ _ i ⟨z,hi⟩]
+  cases i with
+  | none => rfl
+  | some b => cases b <;> rfl
+
+lemma homotopic_map_of_fill (p : Path x x) (f : C(X,Y)) (F : C(Disk 2,Y))
+    (hF : ∀ z, F (boundary 2 z) = f (map p z)) :
+    (p.map f.continuous).Homotopic (Path.refl (f x)) := by
+  apply homotopic_of_fill _ F
+  intro z
+  rw [natural]
+  exact hF z
+end GroupRingTopology.LoopSphere
+
+/-! The path-class extension of an acting group. This is geometric support for
+the finite presentation Cayley cover, not an assumption of simple connectivity. -/
+
+namespace GroupRingTopology.PathExtension
+
+section
+open Path.Homotopic
+universe u v
+variable {X : Type u} [TopologicalSpace X]
+
+namespace Q
+variable {x y z : X}
+lemma trans_cast {x' y' z' : X} (p : Path.Homotopic.Quotient x y)
+    (q : Path.Homotopic.Quotient y z) (hx : x' = x) (hy : y' = y) (hz : z' = z) :
+    (p.cast hx hy).trans (q.cast hy hz) = (p.trans q).cast hx hz := by
+  subst x'; subst y'; subst z'; simp
+lemma map_trans {Y : Type*} [TopologicalSpace Y]
+    (p : Path.Homotopic.Quotient x y) (q : Path.Homotopic.Quotient y z) (f : C(X,Y)) :
+    (p.trans q).map f = (p.map f).trans (q.map f) := by
+  induction p using Path.Homotopic.Quotient.ind with | mk p =>
+  induction q using Path.Homotopic.Quotient.ind with | mk q =>
+  exact congrArg Path.Homotopic.Quotient.mk (p.map_trans q f.continuous)
+lemma map_refl {Y : Type*} [TopologicalSpace Y] (x : X) (f : C(X,Y)) :
+    (Path.Homotopic.Quotient.refl x).map f = Path.Homotopic.Quotient.refl (f x) := rfl
+lemma map_symm {Y : Type*} [TopologicalSpace Y] (p : Path.Homotopic.Quotient x y) (f : C(X,Y)) :
+    p.symm.map f = (p.map f).symm := by
+  induction p using Path.Homotopic.Quotient.ind with | mk p =>
+  exact congrArg Path.Homotopic.Quotient.mk (p.map_symm f.continuous)
+/-- Equality of path classes together with equality of both endpoint labels. -/
+structure Equal {x' y' : X} (p : Path.Homotopic.Quotient x y)
+    (q : Path.Homotopic.Quotient x' y') : Prop where
+  source : x = x'
+  target : y = y'
+  path : HEq p q
+
+namespace Equal
+lemma refl (p : Path.Homotopic.Quotient x y) : Equal p p := ⟨rfl,rfl,HEq.rfl⟩
+lemma ofEq {p q : Path.Homotopic.Quotient x y} (h : p = q) : Equal p q := ⟨rfl,rfl,heq_of_eq h⟩
+lemma symm {x' y' : X} {p : Path.Homotopic.Quotient x y}
+    {q : Path.Homotopic.Quotient x' y'} (h : Equal p q) : Equal q p :=
+  ⟨h.source.symm,h.target.symm,h.path.symm⟩
+lemma trans {x' y' x'' y'' : X} {p : Path.Homotopic.Quotient x y}
+    {q : Path.Homotopic.Quotient x' y'} {r : Path.Homotopic.Quotient x'' y''}
+    (h : Equal p q) (k : Equal q r) : Equal p r :=
+  ⟨h.source.trans k.source,h.target.trans k.target,h.path.trans k.path⟩
+lemma map {Y : Type*} [TopologicalSpace Y] {x' y' : X}
+    {p : Path.Homotopic.Quotient x y} {q : Path.Homotopic.Quotient x' y'}
+    (h : Equal p q) (f : C(X,Y)) : Equal (p.map f) (q.map f) := by
+  rcases h with ⟨hx,hy,hp⟩
+  subst x'; subst y'
+  cases eq_of_heq hp
+  exact .refl _
+lemma comp {x' y' z' : X} {p : Path.Homotopic.Quotient x y}
+    {q : Path.Homotopic.Quotient y z} {p' : Path.Homotopic.Quotient x' y'}
+    {q' : Path.Homotopic.Quotient y' z'} (hp : Equal p p') (hq : Equal q q') :
+    Equal (p.trans q) (p'.trans q') := by
+  rcases hp with ⟨hx,hy,hp⟩
+  rcases hq with ⟨_,hz,hq⟩
+  subst x'; subst y'; subst z'
+  cases eq_of_heq hp; cases eq_of_heq hq
+  exact .refl _
+end Equal
+lemma cast_equal {x' y' : X} (p : Path.Homotopic.Quotient x y) (hx : x' = x) (hy : y' = y) :
+    Equal (p.cast hx hy) p := ⟨hx,hy,Path.Homotopic.Quotient.cast_heq hx hy⟩
+lemma refl_equal {x y : X} (h : x = y) :
+    Equal (Path.Homotopic.Quotient.refl x) (Path.Homotopic.Quotient.refl y) := by
+  subst y
+  exact .refl _
+
+end Q
+
+variable {G : Type v} [Group G] [MulAction G X] [ContinuousConstSMul G X]
+
+def smulMap (g : G) : C(X,X) := ⟨fun x => g • x,continuous_const_smul g⟩
+
+lemma map_one_equal {x y : X} (p : Path.Homotopic.Quotient x y) :
+    Q.Equal (p.map (smulMap (1 : G))) p := by
+  refine ⟨one_smul G x,one_smul G y,?_⟩
+  induction p using Path.Homotopic.Quotient.ind with | mk p =>
+  exact Path.Homotopic.hpath_hext (fun t => one_smul G (p t))
+
+lemma map_mul_equal {x y : X} (p : Path.Homotopic.Quotient x y) (g h : G) :
+    Q.Equal ((p.map (smulMap h)).map (smulMap g)) (p.map (smulMap (g*h))) := by
+  refine ⟨(mul_smul g h x).symm,(mul_smul g h y).symm,?_⟩
+  induction p using Path.Homotopic.Quotient.ind with | mk p =>
+  exact Path.Homotopic.hpath_hext (fun t => (mul_smul g h (p t)).symm)
+
+variable (G) (x₀ : X)
+abbrev Extension := Σ g : G, Path.Homotopic.Quotient x₀ (g • x₀)
+variable {G x₀}
+
+omit [ContinuousConstSMul G X] in
+@[ext] lemma ext {a b : Extension G x₀} (hg : a.1 = b.1) (hp : HEq a.2 b.2) : a = b :=
+  Sigma.ext hg hp
+
+instance : One (Extension G x₀) :=
+  ⟨⟨1,(Path.Homotopic.Quotient.refl x₀).cast rfl (one_smul G x₀)⟩⟩
+instance : Mul (Extension G x₀) :=
+  ⟨fun a b => ⟨a.1*b.1,(a.2.trans (b.2.map (smulMap a.1))).cast rfl (mul_smul ..)⟩⟩
+instance : Inv (Extension G x₀) :=
+  ⟨fun a => ⟨a.1⁻¹,((a.2.map (smulMap a.1⁻¹)).symm).cast (inv_smul_smul a.1 x₀).symm rfl⟩⟩
+
+lemma mul_path_equal (a b : Extension G x₀) :
+    Q.Equal (a*b).2 (a.2.trans (b.2.map (smulMap a.1))) :=
+  Q.cast_equal _ _ _
+
+omit [ContinuousConstSMul G X] in
+lemma one_path_equal : Q.Equal (1 : Extension G x₀).2 (Path.Homotopic.Quotient.refl x₀) := by
+  change Q.Equal ((Path.Homotopic.Quotient.refl x₀).cast rfl (one_smul G x₀)) _
+  exact Q.cast_equal _ _ _
+
+lemma mul_assoc (a b c : Extension G x₀) : a*b*c = a*(b*c) := by
+  apply ext (_root_.mul_assoc _ _ _)
+  apply Q.Equal.path
+  apply Q.Equal.trans (mul_path_equal (a*b) c)
+  apply Q.Equal.trans (Q.Equal.comp (mul_path_equal a b) (map_mul_equal c.2 a.1 b.1).symm)
+  apply Q.Equal.trans (Q.Equal.ofEq (Path.Homotopic.Quotient.trans_assoc _ _ _))
+  apply Q.Equal.trans ?_ (mul_path_equal a (b*c)).symm
+  apply Q.Equal.comp (Q.Equal.refl _)
+  apply Q.Equal.trans ?_ ((mul_path_equal b c).map (smulMap a.1)).symm
+  exact Q.Equal.ofEq (Q.map_trans _ _ _).symm
+
+lemma one_mul (a : Extension G x₀) : 1*a = a := by
+  apply ext (_root_.one_mul _)
+  apply Q.Equal.path
+  exact (mul_path_equal 1 a).trans
+    ((Q.Equal.comp one_path_equal (map_one_equal a.2)).trans
+      (Q.Equal.ofEq (Path.Homotopic.Quotient.refl_trans a.2)))
+
+lemma mul_one (a : Extension G x₀) : a*1 = a := by
+  apply ext (_root_.mul_one _)
+  apply Q.Equal.path
+  apply Q.Equal.trans (mul_path_equal a 1)
+  apply Q.Equal.trans (Q.Equal.comp (Q.Equal.refl _) (one_path_equal.map (smulMap a.1)))
+  rw [Q.map_refl]
+  exact Q.Equal.ofEq (Path.Homotopic.Quotient.trans_refl a.2)
+
+lemma inv_mul_cancel (a : Extension G x₀) : a⁻¹*a = 1 := by
+  apply ext (_root_.inv_mul_cancel _)
+  apply Q.Equal.path
+  apply Q.Equal.trans (mul_path_equal a⁻¹ a)
+  have hi : Q.Equal (a⁻¹).2 (a.2.map (smulMap a.1⁻¹)).symm := Q.cast_equal _ _ _
+  exact (Q.Equal.comp hi (Q.Equal.refl _)).trans
+    ((Q.Equal.ofEq (Path.Homotopic.Quotient.symm_trans _)).trans
+      ((Q.refl_equal (inv_smul_smul a.1 x₀)).trans one_path_equal.symm))
+
+instance : Group (Extension G x₀) where
+  mul_assoc := mul_assoc
+  one_mul := one_mul
+  mul_one := mul_one
+  inv_mul_cancel := inv_mul_cancel
+
+/-- Endpoint projection of the genuine path-class extension. -/
+def projection : Extension G x₀ →* G where
+  toFun := Sigma.fst
+  map_one' := rfl
+  map_mul' _ _ := rfl
+
+end
+open Path.Homotopic
+universe u v w
+variable {G : Type u} [Group G]
+variable {X : Type v} [TopologicalSpace X] [MulAction G X] [ContinuousConstSMul G X]
+variable {Y : Type w} [TopologicalSpace Y] [MulAction G Y] [ContinuousConstSMul G Y]
+variable (f : C(X,Y)) (hf : ∀ (g : G) (x : X), f (g • x) = g • f x)
+
+include hf in
+lemma natural_smul_equal {x y : X} (p : Path.Homotopic.Quotient x y) (g : G) :
+    Q.Equal ((p.map (smulMap g)).map f) ((p.map f).map (smulMap g)) := by
+  refine ⟨hf g x,hf g y,?_⟩
+  induction p using Path.Homotopic.Quotient.ind with | mk p =>
+  exact Path.Homotopic.hpath_hext (fun t => hf g (p t))
+
+variable (x₀ : X)
+def mapFun (a : Extension G x₀) : Extension G (f x₀) :=
+  ⟨a.1,(a.2.map f).cast rfl (hf a.1 x₀).symm⟩
+omit [ContinuousConstSMul G X] [ContinuousConstSMul G Y] in
+lemma mapFun_equal (a : Extension G x₀) :
+    Q.Equal (mapFun f hf x₀ a).2 (a.2.map f) := Q.cast_equal _ _ _
+omit [ContinuousConstSMul G X] [ContinuousConstSMul G Y] in
+lemma mapFun_one : mapFun f hf x₀ 1 = 1 := by
+  apply ext rfl
+  apply Q.Equal.path
+  apply (mapFun_equal f hf x₀ 1).trans
+  apply (one_path_equal.map f).trans
+  rw [Q.map_refl]
+  exact one_path_equal.symm
+lemma mapFun_mul (a b : Extension G x₀) : mapFun f hf x₀ (a*b) = mapFun f hf x₀ a * mapFun f hf x₀ b := by
+  apply ext (a := mapFun f hf x₀ (a*b)) (b := mapFun f hf x₀ a * mapFun f hf x₀ b) (by rfl)
+  apply Q.Equal.path
+  apply (mapFun_equal f hf x₀ (a*b)).trans
+  apply ((mul_path_equal a b).map f).trans
+  apply (Q.Equal.ofEq (Q.map_trans _ _ _)).trans
+  apply Q.Equal.trans ?_ (mul_path_equal (mapFun f hf x₀ a) (mapFun f hf x₀ b)).symm
+  exact Q.Equal.comp (mapFun_equal f hf x₀ a).symm
+    ((natural_smul_equal f hf b.2 a.1).trans
+      ((mapFun_equal f hf x₀ b).map (smulMap a.1)).symm)
+
+def map : Extension G x₀ →* Extension G (f x₀) where
+  toFun := mapFun f hf x₀
+  map_one' := mapFun_one f hf x₀
+  map_mul' := mapFun_mul f hf x₀
+
+lemma projection_map : projection.comp (map f hf x₀) = projection := rfl
+end GroupRingTopology.PathExtension
+namespace GroupRingTopology.Cayley
+open Set Metric Topology Attachment PathExtension
+open scoped unitInterval
+universe u
+variable {G : Type u} [Group G] [TopologicalSpace G] [DiscreteTopology G]
+variable {S : Type u} (s : S → G)
+
+lemma smul_vertex (g h : G) : g • vertex s h = vertex s (g*h) := rfl
+
+def pathGenerator (i : S) : PathExtension.Extension G (vertex s 1) :=
+  ⟨s i,Path.Homotopic.Quotient.mk ((edge s 1 i).cast rfl (by
+    rw [smul_vertex]; simp only [_root_.mul_one,_root_.one_mul]))⟩
+def wordLift : FreeGroup S →* PathExtension.Extension G (vertex s 1) :=
+  FreeGroup.lift (pathGenerator s)
+lemma projection_wordLift : PathExtension.projection.comp (wordLift s) = FreeGroup.lift s := by
+  ext i
+  simp only [MonoidHom.comp_apply,wordLift,FreeGroup.lift_apply_of]
+  rfl
+lemma wordLift_fst (w : FreeGroup S) : (wordLift s w).1 = FreeGroup.lift s w :=
+  DFunLike.congr_fun (projection_wordLift s) w
+
+variable (rels : Set (FreeGroup S)) (hrel : ∀ r ∈ rels, FreeGroup.lift s r = 1)
+def relatorClass (r : rels) : Path.Homotopic.Quotient (vertex s 1) (vertex s 1) :=
+  (wordLift s r.1).2.cast rfl (by rw [wordLift_fst,hrel r.1 r.2,one_smul])
+def relatorLoop (r : rels) : Path (vertex s 1) (vertex s 1) :=
+  (Path.Homotopic.Quotient.mk_surjective (relatorClass s rels hrel r)).choose
+lemma relatorLoop_eq (r : rels) : Path.Homotopic.Quotient.mk (relatorLoop s rels hrel r) =
+    relatorClass s rels hrel r :=
+  (Path.Homotopic.Quotient.mk_surjective (relatorClass s rels hrel r)).choose_spec
+lemma relatorLoop_equal (r : rels) :
+    PathExtension.Q.Equal (Path.Homotopic.Quotient.mk (relatorLoop s rels hrel r))
+      (wordLift s r.1).2 :=
+  (PathExtension.Q.Equal.ofEq (relatorLoop_eq s rels hrel r)).trans (PathExtension.Q.cast_equal _ _ _)
+
+def relatorAttaching (r : rels) : C(Sphere 2,Graph s) := LoopSphere.map (relatorLoop s rels hrel r)
+abbrev PresentationCover := Space (equivariantFamily (G := G) (relatorAttaching s rels hrel))
+def presentationBase : C(Graph s,PresentationCover s rels hrel) := ⟨base _,continuous_base _⟩
+lemma presentationBase_smul (g : G) (x : Graph s) :
+    presentationBase s rels hrel (g • x) = g • presentationBase s rels hrel x := rfl
+
+def coverWordLift : FreeGroup S →* PathExtension.Extension G (presentationBase s rels hrel (vertex s 1)) :=
+  (PathExtension.map (presentationBase s rels hrel) (presentationBase_smul s rels hrel) (vertex s 1)).comp
+    (wordLift s)
+
+lemma mapped_relator_homotopic (r : rels) :
+    ((relatorLoop s rels hrel r).map (presentationBase s rels hrel).continuous).Homotopic
+      (Path.refl (presentationBase s rels hrel (vertex s 1))) := by
+  apply LoopSphere.homotopic_map_of_fill _ _ (cell _ ((1:G),r))
+  intro z
+  change cell (equivariantFamily (G := G) (relatorAttaching s rels hrel)) ((1:G),r)
+    (Attachment.boundary 2 z) = _
+  erw [cell_boundary]
+  simp only [equivariantFamily,ContinuousMap.coe_mk,one_smul]
+  rfl
+
+lemma coverWordLift_relator (r : rels) : coverWordLift s rels hrel r.1 = 1 := by
+  apply PathExtension.ext (a := coverWordLift s rels hrel r.1) (b := 1)
+    ((wordLift_fst s r.1).trans (hrel r.1 r.2))
+  apply PathExtension.Q.Equal.path
+  apply (PathExtension.mapFun_equal (presentationBase s rels hrel)
+    (presentationBase_smul s rels hrel) (vertex s 1) (wordLift s r.1)).trans
+  apply ((relatorLoop_equal s rels hrel r).map (presentationBase s rels hrel)).symm.trans
+  apply (PathExtension.Q.Equal.ofEq (Quotient.sound (mapped_relator_homotopic s rels hrel r))).trans
+  exact PathExtension.one_path_equal.symm
+
+lemma coverWordLift_ker (hker : (FreeGroup.lift s).ker = Subgroup.normalClosure rels) :
+    (FreeGroup.lift s).ker ≤ (coverWordLift s rels hrel).ker := by
+  rw [hker]
+  apply Subgroup.normalClosure_le_normal
+  intro r hr
+  exact coverWordLift_relator s rels hrel ⟨r,hr⟩
+
+def presentationSection (hs : Function.Surjective (FreeGroup.lift s))
+    (hker : (FreeGroup.lift s).ker = Subgroup.normalClosure rels) :
+    G →* PathExtension.Extension G (presentationBase s rels hrel (vertex s 1)) :=
+  (FreeGroup.lift s).liftOfSurjective hs ⟨coverWordLift s rels hrel,coverWordLift_ker s rels hrel hker⟩
+lemma presentationSection_lift (hs : Function.Surjective (FreeGroup.lift s))
+    (hker : (FreeGroup.lift s).ker = Subgroup.normalClosure rels) (w : FreeGroup S) :
+    presentationSection s rels hrel hs hker (FreeGroup.lift s w) = coverWordLift s rels hrel w :=
+  MonoidHom.liftOfRightInverse_comp_apply ..
+lemma presentationSection_fst (hs : Function.Surjective (FreeGroup.lift s))
+    (hker : (FreeGroup.lift s).ker = Subgroup.normalClosure rels) (g : G) :
+    (presentationSection s rels hrel hs hker g).1 = g := by
+  obtain ⟨w,rfl⟩ := hs g
+  rw [presentationSection_lift]
+  exact wordLift_fst s w
+end GroupRingTopology.Cayley
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/GroupRing/LoopTracks.lean b/lean/OAI/Algebra/GroupRing/LoopTracks.lean
new file mode 100644
index 0000000000000000000000000000000000000000..62754735c4f60f8a8ccc56daa394c53ae0845bc5
--- /dev/null
+++ b/lean/OAI/Algebra/GroupRing/LoopTracks.lean
@@ -0,0 +1,90 @@
+import Mathlib
+
+namespace OAI
+
+
+
+section
+namespace TorsionFreeZeroDivisors.LoopTracks
+open scoped Topology unitInterval
+noncomputable section
+universe u v
+variable {X : Type u} {Y : Type v} [TopologicalSpace X] [TopologicalSpace Y]
+variable {x y : X}
+/-- A genuine relative path homotopy is a path in the compact-open path space. -/
+def pathOfHomotopy {p q : Path x y} (H : p.Homotopy q) : Path p q where
+  toFun := H.eval
+  continuous_toFun := Path.continuous_uncurry_iff.mp H.continuous
+  source' := H.eval_zero
+  target' := H.eval_one
+/-- Conversely: no quotient or merely formal track is used here. -/
+def homotopyOfPath {p q : Path x y} (h : Path p q) : p.Homotopy q where
+  toFun z := h z.1 z.2
+  continuous_toFun := Path.continuous_uncurry_iff.mpr h.continuous
+  map_zero_left t := by rw [h.source];rfl
+  map_one_left t := by rw [h.target];rfl
+  prop' t z hz := by rcases hz with rfl|rfl <;> simp
+lemma homotopic_iff_joined (p q : Path x y) : p.Homotopic q ↔ Joined p q := by
+  constructor
+  · rintro ⟨h⟩;exact ⟨pathOfHomotopy h⟩
+  · rintro ⟨h⟩;exact ⟨homotopyOfPath h⟩
+
+def piOneHomeo (e : X≃ₜY) (x : X) : FundamentalGroup X x≃*FundamentalGroup Y (e x) where
+  toFun := Quotient.map (fun p : Path x x => p.map e.continuous)
+    (fun _ _ h => h.map ⟨e,e.continuous⟩)
+  invFun := Quotient.map (fun p : Path (e x) (e x) => (p.map e.symm.continuous).cast
+    (e.symm_apply_apply x).symm (e.symm_apply_apply x).symm) (fun _ _ h => h.map ⟨e.symm,e.symm.continuous⟩)
+  left_inv a := by
+    induction a using Quotient.inductionOn with | h p =>
+    apply congrArg Path.Homotopic.Quotient.mk
+    ext t
+    exact e.symm_apply_apply (p t)
+  right_inv a := by
+    induction a using Quotient.inductionOn with | h p =>
+    apply congrArg Path.Homotopic.Quotient.mk
+    ext t
+    exact e.apply_symm_apply (p t)
+  map_mul' a b := by
+    induction a using Quotient.inductionOn with | h p =>
+    induction b using Quotient.inductionOn with | h q =>
+    exact congrArg Path.Homotopic.Quotient.mk (q.map_trans p e.continuous)
+
+def uniqueLoopHomeo (N : Type*) [Unique N] (x : X) : GenLoop N X x≃ₜPath x x where
+  toEquiv := genLoopEquivOfUnique N
+  continuous_toFun := Path.continuous_uncurry_iff.mp (by
+    change Continuous (fun z : GenLoop N X x × unitInterval => z.1 (fun _ => z.2))
+    fun_prop)
+  continuous_invFun := by
+    apply Continuous.subtype_mk
+    apply ContinuousMap.continuous_of_continuous_uncurry
+    change Continuous (fun z : Path x x × (N→unitInterval) => z.1 (z.2 default))
+    fun_prop
+
+/-- The loop-space fundamental group is genuinely commutative (Eckmann-Hilton).
+This is the coefficient group of two-cell homotopy-extension obstructions. -/
+lemma loopGroup_comm (x : X) : ∀a b : FundamentalGroup (Path x x) (Path.refl x), a*b=b*a := by
+  let N := {j : Bool // j≠true}
+  let _ : Unique N := ⟨⟨false,by decide⟩,by intro a;rcases a with ⟨a,ha⟩;cases a <;> simp_all⟩
+  let e : HomotopyGroup Bool X x≃* FundamentalGroup (GenLoop N X x) GenLoop.const :=
+    { toEquiv := homotopyGroupEquivFundamentalGroup true
+      map_mul' := by
+        intro a b
+        have h := HomotopyGroup.auxGroup_indep (X:=X) (x:=x) (Classical.arbitrary Bool) true
+        apply Eq.trans (congrArg (fun i : Group (HomotopyGroup Bool X x) =>
+          (homotopyGroupEquivFundamentalGroup true) (@Mul.mul _ i.toMul a b)) h)
+        exact (homotopyGroupEquivFundamentalGroup true).apply_symm_apply _ }
+  let f := piOneHomeo (uniqueLoopHomeo N x) GenLoop.const
+  have hf : uniqueLoopHomeo N x GenLoop.const=Path.refl x := by ext t;rfl
+  rw [←hf]
+  intro a b
+  obtain ⟨a,rfl⟩ := (e.trans f).surjective a
+  obtain ⟨b,rfl⟩ := (e.trans f).surjective b
+  rw [←map_mul,←map_mul,mul_comm]
+end
+end TorsionFreeZeroDivisors.LoopTracks
+
+end
+
+
+
+end OAI
diff --git a/lean/OAI/Algebra/GroupRing/LoopTranspose.lean b/lean/OAI/Algebra/GroupRing/LoopTranspose.lean
new file mode 100644
index 0000000000000000000000000000000000000000..8b6025914f93950dfb2d4f872be60c6193567bfc
--- /dev/null
+++ b/lean/OAI/Algebra/GroupRing/LoopTranspose.lean
@@ -0,0 +1,117 @@
+import Mathlib
+import OAI.Algebra.GroupRing.LoopTracks
+
+namespace OAI
+
+
+
+section
+namespace TorsionFreeZeroDivisors.LoopTranspose
+open scoped Topology unitInterval
+noncomputable section
+universe u
+variable {X : Type u} [TopologicalSpace X] (x : X)
+abbrev Other (b : Bool) := {j : Bool // j≠b}
+instance (b : Bool) : Unique (Other b) where
+  default := ⟨!b,by cases b <;> decide⟩
+  uniq a := by rcases a with ⟨a,ha⟩;cases a <;> cases b <;> simp_all
+
+def groupEquiv (b : Bool) : HomotopyGroup Bool X x≃*
+    FundamentalGroup (GenLoop (Other b) X x) GenLoop.const where
+  toEquiv := homotopyGroupEquivFundamentalGroup b
+  map_mul' a c := by
+    have h := HomotopyGroup.auxGroup_indep (X:=X) (x:=x) (Classical.arbitrary Bool) b
+    apply Eq.trans (congrArg (fun i : Group (HomotopyGroup Bool X x) =>
+      (homotopyGroupEquivFundamentalGroup b) (@Mul.mul _ i.toMul a c)) h)
+    exact (homotopyGroupEquivFundamentalGroup b).apply_symm_apply _
+def equiv (b : Bool) : HomotopyGroup Bool X x≃*FundamentalGroup (Path x x) (Path.refl x) := by
+  let e := (groupEquiv x b).trans (LoopTracks.piOneHomeo (LoopTracks.uniqueLoopHomeo (Other b) x) GenLoop.const)
+  have he : LoopTracks.uniqueLoopHomeo (Other b) x GenLoop.const=Path.refl x := by ext t;rfl
+  rw [he] at e
+  exact e
+
+def turnPath (p : Path (Path.refl x) (Path.refl x)) : Path (Path.refl x) (Path.refl x) where
+  toFun t := {
+    toFun s := p s t
+    continuous_toFun := (Path.continuous_uncurry_iff.mpr p.continuous).comp (continuous_id.prodMk continuous_const)
+    source' := by rw [p.source];rfl
+    target' := by rw [p.target];rfl }
+  continuous_toFun := Path.continuous_uncurry_iff.mp
+    ((Path.continuous_uncurry_iff.mpr p.continuous).comp continuous_swap)
+  source' := by ext s;exact (p s).source
+  target' := by ext s;exact (p s).target
+lemma turnPath_turn (p : Path (Path.refl x) (Path.refl x)) : turnPath x (turnPath x p)=p := by
+  ext s t;rfl
+
+def turn : FundamentalGroup (Path x x) (Path.refl x)≃*FundamentalGroup (Path x x) (Path.refl x) :=
+  (equiv x true).symm.trans (equiv x false)
+
+lemma equiv_mk (b : Bool) (p : GenLoop Bool X x) :
+    equiv x b (Quotient.mk' p)=Path.Homotopic.Quotient.mk
+      (((GenLoop.toLoop b p).map (LoopTracks.uniqueLoopHomeo (Other b) x).continuous).cast
+        (by ext t;rfl) (by ext t;rfl)) := by
+  rfl
+lemma turn_equiv_mk (p : GenLoop Bool X x) :
+    turn x (equiv x true (Quotient.mk' p))=equiv x false (Quotient.mk' p) := by
+  change equiv x false ((equiv x true).symm ((equiv x true) (Quotient.mk' p)))=_
+  exact (equiv x false).congr_arg ((equiv x true).symm_apply_apply _)
+lemma turns_representative (p : GenLoop Bool X x) :
+    turnPath x (((GenLoop.toLoop true p).map (LoopTracks.uniqueLoopHomeo (Other true) x).continuous).cast
+        (by ext t;rfl) (by ext t;rfl))=
+      (((GenLoop.toLoop false p).map (LoopTracks.uniqueLoopHomeo (Other false) x).continuous).cast
+        (by ext t;rfl) (by ext t;rfl)) := by
+  ext s t
+  change p (Cube.insertAt true (t,fun _=>s))=p (Cube.insertAt false (s,fun _=>t))
+  apply congrArg p
+  funext b
+  cases b <;> simp [Cube.insertAt]
+
+lemma turn_mk (p : Path (Path.refl x) (Path.refl x)) :
+    turn x (Path.Homotopic.Quotient.mk p)=Path.Homotopic.Quotient.mk (turnPath x p) := by
+  obtain ⟨q,hq⟩ := (equiv x true).surjective (Path.Homotopic.Quotient.mk p)
+  induction q using Quotient.inductionOn with | h q=>
+  change equiv x true (Quotient.mk' q)=Path.Homotopic.Quotient.mk p at hq
+  rw [←hq,turn_equiv_mk,equiv_mk]
+  rw [equiv_mk] at hq
+  have h := Path.Homotopic.Quotient.eq.mp hq
+  have ht : (turnPath x (((GenLoop.toLoop true q).map (LoopTracks.uniqueLoopHomeo (Other true) x).continuous).cast
+      (by ext t;rfl) (by ext t;rfl))).Homotopic (turnPath x p) := by
+    obtain ⟨H⟩ := h
+    refine ⟨{
+      toFun := fun z=>{
+        toFun t:=H (z.1,t) z.2
+        continuous_toFun:=?_
+        source':=?_
+        target':=?_ }
+      continuous_toFun:=?_
+      map_zero_left:=?_
+      map_one_left:=?_
+      prop':=?_ }⟩
+    · exact (Path.continuous_uncurry_iff.mpr H.continuous).comp
+        ((continuous_const.prodMk continuous_id).prodMk continuous_const)
+    · rw [H.eq_fst z.1 (show (0:unitInterval)∈{0,1} from Or.inl rfl)]
+      simp only [Path.coe_toContinuousMap,Path.source,Path.refl_apply]
+    · rw [H.eq_fst z.1 (show (1:unitInterval)∈{0,1} from Or.inr rfl)]
+      simp only [Path.coe_toContinuousMap,Path.target,Path.refl_apply]
+    · apply Path.continuous_uncurry_iff.mp
+      exact (Path.continuous_uncurry_iff.mpr H.continuous).comp
+        (((continuous_fst.comp continuous_fst).prodMk continuous_snd).prodMk
+          (continuous_snd.comp continuous_fst))
+    · intro s;ext t;exact congrArg (fun r : Path x x=>r s) (H.apply_zero t)
+    · intro s;ext t;exact congrArg (fun r : Path x x=>r s) (H.apply_one t)
+    · intro s t ht;ext z
+      rcases ht with rfl|rfl
+      · change (H (s,z)) 0=_
+        simp only [Path.coe_toContinuousMap,Path.source,Path.refl_apply]
+      · change (H (s,z)) 1=_
+        simp only [Path.coe_toContinuousMap,Path.target,Path.refl_apply]
+  rw [turns_representative] at ht
+  exact Path.Homotopic.Quotient.eq.mpr ht
+end
+end TorsionFreeZeroDivisors.LoopTranspose
+
+end
+
+
+
+end OAI
diff --git a/lean/OAI/Algebra/GroupRing/Main.lean b/lean/OAI/Algebra/GroupRing/Main.lean
new file mode 100644
index 0000000000000000000000000000000000000000..0445881d0021c9e816c4656d2d7d779ac26c86ee
--- /dev/null
+++ b/lean/OAI/Algebra/GroupRing/Main.lean
@@ -0,0 +1,24 @@
+import Mathlib
+import OAI.Algebra.GroupRing.ConcreteModel
+
+namespace OAI
+
+section
+
+namespace TorsionFreeZeroDivisors
+noncomputable section
+/-- A torsion-free group with a finite 2-dimensional K(G,1) and zero divisors.
+Both zero-divisor factors are nonzero, and torsion-freeness is ordinary
+absence of all nontrivial finite-order elements. -/
+theorem main : MainTheorem := by
+  obtain ⟨rep,r,x,y,hr,hL,hd,ha,hx,hy,hz⟩ := SampleGraph.exists_nonzero_factors
+  exact ⟨ConcreteGroup.G rep r,inferInstance,inferInstance,
+    ConcreteTorsion.torsion_free rep r x y hL hd hr ha,
+    ConcreteModel.has_model rep r x y hL hd hr ha,
+    ConcreteFactors.alpha rep r x,ConcreteFactors.beta rep r y,hx,hy,hz⟩
+end
+end TorsionFreeZeroDivisors
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/GroupRing/MapEuler.lean b/lean/OAI/Algebra/GroupRing/MapEuler.lean
new file mode 100644
index 0000000000000000000000000000000000000000..dfab7e2d140329a430c4481207bab8181a100a58
--- /dev/null
+++ b/lean/OAI/Algebra/GroupRing/MapEuler.lean
@@ -0,0 +1,419 @@
+import Mathlib
+import OAI.Algebra.GroupRing.FullPairing
+
+namespace OAI
+
+noncomputable section
+
+namespace TorsionFreeZeroDivisors.MapEuler
+
+section
+open scoped Classical
+open PermutationCycles
+variable {O : Type} [Fintype O] (σ α : Equiv.Perm O) (ha : Function.Involutive α)
+
+lemma component_card_one_of_connected (hc : (graph σ α ha).Connected) :
+    Nat.card (Component σ α)=1 := by
+  rw [graphComponent_card σ α ha]
+  have : Nonempty (Cycle σ) := hc.nonempty
+  exact Nat.card_eq_one_iff_unique.mpr
+    ⟨hc.preconnected.subsingleton_connectedComponent,inferInstance⟩
+
+omit [Fintype O] in
+lemma connected_of_component_card_one (hc : Nat.card (Component σ α)=1) :
+    (graph σ α ha).Connected := by
+  obtain ⟨hs,hn⟩ := Nat.card_eq_one_iff_unique.mp hc
+  have : Subsingleton (Component σ α) := hs
+  obtain ⟨c⟩ := hn
+  obtain ⟨x,rfl⟩ := Quotient.mk_surjective c
+  have : Nonempty (Cycle σ) := ⟨cycle σ x⟩
+  refine ⟨?_⟩
+  intro v w
+  obtain ⟨y,rfl⟩ := cycle_surjective σ v
+  obtain ⟨z,rfl⟩ := cycle_surjective σ w
+  exact reachable_of_component σ α ha (Subsingleton.elim _ _)
+
+/-- Literal connectedness can be read from the map's component quotient. -/
+lemma connected_iff_component_card_one :
+    (graph σ α ha).Connected ↔ Nat.card (Component σ α)=1 :=
+  ⟨component_card_one_of_connected σ α ha,connected_of_component_card_one σ α ha⟩
+
+end
+
+section
+open scoped Classical
+open PermutationCycles
+variable {O : Type} (σ α β : Equiv.Perm O)
+    (ha : Function.Involutive α) (hb : Function.Involutive β)
+    (hsub : ∀ x,β x=x ∨ β x=α x)
+
+include ha hb hsub in
+lemma subpairing_commute : Commute α β := by
+  show α*β=β*α
+  ext x
+  change α (β x)=β (α x)
+  rcases hsub x with hx|hx
+  · rcases hsub (α x) with hy|hy
+    · rw [hx,hy]
+    · rw [ha x] at hy
+      have he : α x=x := β.injective (hy.trans hx.symm)
+      rw [hx,he,hx]
+  · have hy : β (α x)=x := by rw [←hx,hb x]
+    rw [hx,ha x,hy]
+
+include ha hb hsub in
+lemma complement_involutive : Function.Involutive (α*β) := by
+  have he : ∀ x, β (α x)=α (β x) := fun x=>
+    (congrArg (fun f : Equiv.Perm O => f x) (subpairing_commute α β ha hb hsub).eq).symm
+  intro x
+  change α (β (α (β x)))=x
+  rw [he,hb x,ha x]
+
+include ha hsub in
+lemma complement_subpairing : ∀ x,(α*β) x=x ∨ (α*β) x=α x := by
+  intro x
+  change α (β x)=x ∨ α (β x)=α x
+  rcases hsub x with hx|hx
+  · exact Or.inr (congrArg α hx)
+  · exact Or.inl ((congrArg α hx).trans (ha x))
+
+include ha hb hsub in
+lemma complement_face : (α*β)*(α*σ)=β*σ := by
+  ext x
+  change α (β (α (σ x)))=β (σ x)
+  have he : β (α (σ x))=α (β (σ x)) :=
+    (congrArg (fun f : Equiv.Perm O => f (σ x)) (subpairing_commute α β ha hb hsub).eq).symm
+  rw [he,ha]
+
+variable [Fintype O]
+include hsub in
+lemma subpairing_support_subset : β.support⊆α.support := by
+  intro x hx
+  rw [Equiv.Perm.mem_support] at hx ⊢
+  rcases hsub x with hh|hh
+  · exact (hx hh).elim
+  · rwa [←hh]
+
+include ha hsub in
+lemma complement_support : (α*β).support=α.support\β.support := by
+  ext x
+  simp only [Equiv.Perm.mem_support,Finset.mem_sdiff]
+  change α (β x)≠x ↔ α x≠x ∧ ¬β x≠x
+  rcases hsub x with hh|hh
+  · simp only [hh,ne_eq,not_true_eq_false,not_false_eq_true,and_true]
+  · simp only [hh,ha x,ne_eq,not_true_eq_false,not_not,false_iff]
+    exact fun h=>h.1 h.2
+
+include ha hsub in
+lemma complement_support_card : (α*β).support.card+β.support.card=α.support.card := by
+  rw [complement_support α β ha hsub,Finset.card_sdiff_of_subset (subpairing_support_subset α β hsub)]
+  exact Nat.sub_add_cancel (Finset.card_le_card (subpairing_support_subset α β hsub))
+
+include ha hb hsub in
+/-- Deleting a chosen set of primal edges is actual complementary-pair deletion
+in the dual map, not an assumed planar-minor interface. -/
+theorem genusZero_complement_dual (hz : GenusZero σ α) : GenusZero (α*σ) (α*β) :=
+  genusZero_subpairing (α*σ) α (α*β) ha (complement_involutive α β ha hb hsub)
+    (complement_subpairing α β ha hsub) ((genusZero_dual σ α ha).mp hz)
+
+end
+
+section
+open scoped Classical
+open PermutationCycles
+variable {O : Type} [Fintype O] (σ α : Equiv.Perm O) (ha : Function.Involutive α)
+    (T : SimpleGraph (Cycle σ)) (hT : T≤graph σ α ha)
+
+lemma subgraphPair_subpairing : ∀ x,subgraphPair σ α ha T hT x=x ∨
+    subgraphPair σ α ha T hT x=α x := by
+  intro x
+  rw [subgraphPair_apply]
+  split_ifs <;> simp only [true_or,or_true]
+
+lemma subgraphPair_support_tree (ht : T.IsTree) :
+    (subgraphPair σ α ha T hT).support.card+2=2*Nat.card (Cycle σ) := by
+  rw [subgraphPair_support_card]
+  have hc := (SimpleGraph.isTree_iff_connected_and_card.mp ht).2
+  omega
+
+/-- The literal contour permutation of a chosen spanning tree has one cycle. -/
+theorem tree_contour_card (hz : GenusZero σ α) (ht : T.IsTree) :
+    Nat.card (Cycle (subgraphPair σ α ha T hT*σ))=1 := by
+  have hc : (graph σ (subgraphPair σ α ha T hT) (subgraphPair_involutive σ α ha T hT)).Connected := by
+    rw [subgraphPair_graph]
+    exact ht.connected
+  have hcomp := component_card_one_of_connected σ _ (subgraphPair_involutive σ α ha T hT) hc
+  have hgen := genusZero_subgraphPair σ α ha T hT hz
+  change 2*Nat.card (Cycle σ)+2*Nat.card (Cycle (subgraphPair σ α ha T hT*σ))=
+    (subgraphPair σ α ha T hT).support.card+4*Nat.card (Component σ (subgraphPair σ α ha T hT)) at hgen
+  have hsup := subgraphPair_support_tree σ α ha T hT ht
+  omega
+
+/-- The complementary edge matching in the original dual rotation has exactly
+one fewer edge than dual vertices. -/
+lemma cotree_support (hz : GenusZero σ α) (ht : T.IsTree) :
+    (α*subgraphPair σ α ha T hT).support.card+2=2*Nat.card (Cycle (α*σ)) := by
+  have hconn : (graph σ α ha).Connected := ht.connected.mono hT
+  have hc := component_card_one_of_connected σ α ha hconn
+  have hp := subgraphPair_support_tree σ α ha T hT ht
+  have hs := complement_support_card α _ ha (subgraphPair_subpairing σ α ha T hT)
+  change 2*Nat.card (Cycle σ)+2*Nat.card (Cycle (α*σ))=α.support.card+4*Nat.card (Component σ α) at hz
+  omega
+
+/-- Tree--cotree duality proved from actual permutations and Euler equality.
+Loops and parallel edges in the original map are allowed. No embedding or
+planar-duality axiom is used. -/
+theorem spanning_cotree_isTree (hz : GenusZero σ α) (ht : T.IsTree) :
+    (graph (α*σ) (α*subgraphPair σ α ha T hT)
+      (complement_involutive α _ ha (subgraphPair_involutive σ α ha T hT)
+        (subgraphPair_subpairing σ α ha T hT))).IsTree := by
+  let β := subgraphPair σ α ha T hT
+  have hb := subgraphPair_involutive σ α ha T hT
+  have hsub := subgraphPair_subpairing σ α ha T hT
+  have hface := complement_face σ α β ha hb hsub
+  have hgen := genusZero_complement_dual σ α β ha hb hsub hz
+  have htface := tree_contour_card σ α ha T hT hz ht
+  have hs := cotree_support σ α ha T hT hz ht
+  change 2*Nat.card (Cycle (α*σ))+2*Nat.card (Cycle ((α*β)*(α*σ)))=
+    (α*β).support.card+4*Nat.card (Component (α*σ) (α*β)) at hgen
+  rw [hface] at hgen
+  have hcomp : Nat.card (Component (α*σ) (α*β))=1 := by
+    dsimp only [β] at hgen ⊢
+    omega
+  exact graph_isTree_of_support (α*σ) (α*β) (complement_involutive α β ha hb hsub)
+    (connected_of_component_card_one _ _ _ hcomp) hs
+
+end
+
+section
+open scoped Classical
+open PermutationCycles
+variable {O V : Type} [Fintype O]
+
+omit [Fintype O] in
+lemma sameCycle_of_card_one (θ : Equiv.Perm O) (hθ : Nat.card (Cycle θ)=1) (x y : O) :
+    θ.SameCycle x y := by
+  have : Subsingleton (Cycle θ) := (Nat.card_eq_one_iff_unique.mp hθ).1
+  exact (cycle_eq θ).mp (Subsingleton.elim _ _)
+
+/-- In a cyclic contour with at most one exit from S, the labels of all members
+of S are connected using only steps internal to S. This finite orbit argument
+replaces a geometric assertion that tree-subtree corners form an interval. -/
+theorem contour_interval_reachable (θ : Equiv.Perm O)
+    (hθ : ∀ x y,θ.SameCycle x y) (S : Set O) (p : O)
+    (hout : ∀ x∈S,θ x∉S → x=p) (H : SimpleGraph V) (label : O → V)
+    (hstep : ∀ x∈S,θ x∈S → H.Reachable (label x) (label (θ x)))
+    (x : O) (hx : x∈S) : H.Reachable (label p) (label x) := by
+  by_contra hn
+  have invariant (y : O) (hy : y∈S) (hn : ¬H.Reachable (label p) (label y)) :
+      θ y∈S ∧ ¬H.Reachable (label p) (label (θ y)) := by
+    have hy' : θ y∈S := by
+      by_contra h
+      have he := hout y hy h
+      subst y
+      exact hn (SimpleGraph.Reachable.refl _)
+    refine ⟨hy',fun h=>hn (h.trans (hstep y hy hy').symm)⟩
+  have hp (n : ℕ) : (θ^n) x∈S ∧ ¬H.Reachable (label p) (label ((θ^n) x)) := by
+    induction n with
+    | zero => exact ⟨hx,hn⟩
+    | succ n ih =>
+      rw [pow_succ',Equiv.Perm.mul_apply]
+      exact invariant _ ih.1 ih.2
+  obtain ⟨n,he⟩ := (hθ x p).exists_nat_pow_eq
+  have hh := (hp n).2
+  rw [he] at hh
+  exact hh (SimpleGraph.Reachable.refl _)
+
+end
+
+open scoped Classical
+open PermutationCycles
+variable {O : Type} [Fintype O] (σ α : Equiv.Perm O) (ha : Function.Involutive α)
+    (T : SimpleGraph (Cycle σ)) (hT : T≤graph σ α ha)
+
+omit [Fintype O] in
+lemma pairFinset_adj (e : T.edgeSet) {x : O} (hx : x∈pairFinset σ α ha T hT e) :
+    T.Adj (cycle σ x) (cycle σ (α x)) := by
+  change s(cycle σ x,cycle σ (α x))∈T.edgeSet
+  rw [pairFinset_edge σ α ha T hT e hx]
+  exact e.property
+
+omit [Fintype O] in
+lemma pairFinset_cycle_injective (e : T.edgeSet) {x y : O}
+    (hx : x∈pairFinset σ α ha T hT e) (hy : y∈pairFinset σ α ha T hT e)
+    (h : cycle σ x=cycle σ y) : x=y := by
+  have hadj := pairFinset_adj σ α ha T hT e hx
+  simp only [pairFinset,Finset.mem_insert,Finset.mem_singleton] at hx hy
+  rcases hx with rfl|rfl <;> rcases hy with rfl|rfl
+  · rfl
+  · exact (hadj.ne h).elim
+  · rw [ha] at hadj
+    exact (hadj.ne h).elim
+  · rfl
+
+lemma subgraphPair_nonfixed_mem {x : O} (hx : subgraphPair σ α ha T hT x≠x) :
+    x∈pickedDarts σ α ha T hT := by
+  have h := Equiv.Perm.mem_support.mpr hx
+  rwa [subgraphPair_support] at h
+
+lemma subgraphPair_nonfixed_apply {x : O} (hx : subgraphPair σ α ha T hT x≠x) :
+    subgraphPair σ α ha T hT x=α x := by
+  rw [subgraphPair_apply,ite_eq_left (subgraphPair_nonfixed_mem σ α ha T hT hx)]
+
+lemma subgraphPair_adj {x : O} (hx : subgraphPair σ α ha T hT x≠x) :
+    T.Adj (cycle σ x) (cycle σ (subgraphPair σ α ha T hT x)) := by
+  obtain ⟨e,he⟩ := (mem_pickedDarts σ α ha T hT x).mp
+    (subgraphPair_nonfixed_mem σ α ha T hT hx)
+  rw [subgraphPair_nonfixed_apply σ α ha T hT hx]
+  exact pairFinset_adj σ α ha T hT e he
+
+/-- A realized simple subgraph has exactly one dart per directed adjacency. -/
+theorem subgraphPair_dart_unique {x y : O}
+    (hx : subgraphPair σ α ha T hT x≠x) (hy : subgraphPair σ α ha T hT y≠y)
+    (h₁ : cycle σ x=cycle σ y)
+    (h₂ : cycle σ (subgraphPair σ α ha T hT x)=cycle σ (subgraphPair σ α ha T hT y)) : x=y := by
+  obtain ⟨e,he⟩ := (mem_pickedDarts σ α ha T hT x).mp
+    (subgraphPair_nonfixed_mem σ α ha T hT hx)
+  obtain ⟨f,hf⟩ := (mem_pickedDarts σ α ha T hT y).mp
+    (subgraphPair_nonfixed_mem σ α ha T hT hy)
+  rw [subgraphPair_nonfixed_apply σ α ha T hT hx,
+    subgraphPair_nonfixed_apply σ α ha T hT hy] at h₂
+  have hef : e=f := Subtype.ext (by
+    rw [←pairFinset_edge σ α ha T hT e he,←pairFinset_edge σ α ha T hT f hf,h₁,h₂])
+  subst f
+  exact pairFinset_cycle_injective σ α ha T hT e he hf h₁
+
+end TorsionFreeZeroDivisors.MapEuler
+
+/-! The weighted centroid needed by planar dual-tree separator constructions.
+This is an actual theorem for finite Mathlib trees, not a separator assumption. -/
+namespace TorsionFreeZeroDivisors.TreeCentroid
+open scoped Classical BigOperators
+open SimpleGraph
+variable {V : Type} {G : SimpleGraph V} (h : G.IsTree)
+
+def path (x y : V) : G.Walk x y := (h.connected.exists_path_of_dist x y).choose
+lemma path_isPath (x y : V) : ((path h) x y).IsPath :=
+  (h.connected.exists_path_of_dist x y).choose_spec.1
+lemma path_length (x y : V) : ((path h) x y).length=G.dist x y :=
+  (h.connected.exists_path_of_dist x y).choose_spec.2
+lemma eq_path {x y : V} {p : G.Walk x y} (hp : p.IsPath) : p=(path h) x y :=
+  Subtype.mk.inj (h.isAcyclic.subsingleton_path x y |>.elim ⟨p,hp⟩ ⟨_,(path_isPath h) x y⟩)
+include h in
+lemma path_dist {x y : V} {p : G.Walk x y} (hp : p.IsPath) : p.length=G.dist x y := by
+  rw [(eq_path h) hp,(path_length h)]
+
+def next (x y : V) : V := ((path h) x y).snd
+lemma next_adj {x y : V} (hne : x≠y) : G.Adj x ((next h) x y) :=
+  Walk.adj_snd (Walk.not_nil_of_ne hne)
+lemma next_ne {x y : V} (hne : x≠y) : (next h) x y≠x := ((next_adj h) hne).ne'
+
+lemma next_concat {c x y : V} {p : G.Walk c x} (hne : c≠x) (e : G.Adj x y) :
+    (p.concat e).snd=p.snd := by
+  cases p with
+  | nil => exact (hne rfl).elim
+  | cons _ _ => simp only [Walk.concat_eq_append,Walk.cons_append,Walk.snd_cons]
+
+lemma next_adjacent {c x y : V} (hx : c≠x) (hy : c≠y) (e : G.Adj x y) :
+    (next h) c x=(next h) c y := by
+  by_cases hm : x∈((path h) c y).support
+  · have hh := h.isAcyclic.path_concat ((path_isPath h) c x) ((path_isPath h) c y) e hm
+    unfold next
+    rw [hh,next_concat hx]
+  · have hm' := h.isAcyclic.mem_support_of_ne_mem_support_of_adj_of_isPath
+      ((path_isPath h) c x) ((path_isPath h) c y) e hm
+    have hh := h.isAcyclic.path_concat ((path_isPath h) c y) ((path_isPath h) c x) e.symm hm'
+    unfold next
+    rw [hh,next_concat hy]
+
+lemma next_walk {c x y : V} (p : G.Walk x y) (hc : c∉p.support) :
+    next h c x=next h c y := by
+  induction p with
+  | nil => rfl
+  | @cons x z y e p ih =>
+    simp only [Walk.support_cons,List.mem_cons,not_or] at hc
+    have hz : c≠z := fun he=>hc.2 (he ▸ p.start_mem_support)
+    exact (next_adjacent h hc.1 hz e).trans (ih hc.2)
+
+lemma dist_next {c z : V} (hz : c≠z) : G.dist c z=G.dist ((next h) c z) z+1 := by
+  have hl := (path_dist h) ((path_isPath h) c z).tail
+  rw [Walk.length_tail,(path_length h)] at hl
+  change G.dist c z-1=G.dist (next h c z) z at hl
+  have hd : 0<G.dist c z := Nat.pos_of_ne_zero (fun he=>hz (h.connected.dist_eq_zero_iff.mp he))
+  omega
+lemma dist_not_next {c n z : V} (e : G.Adj c n) (hn : (next h) c z≠n) :
+    G.dist n z=G.dist c z+1 := by
+  have hmem : n∉((path h) c z).support := by
+    intro hm
+    exact hn (h.isAcyclic.eq_snd_of_adj_start ((path_isPath h) c z) e hm).symm
+  have hp := ((path_isPath h) c z).cons (h := e.symm) hmem
+  have hl := (path_dist h) hp
+  simpa only [Walk.length_cons,(path_length h)] using hl.symm
+
+variable [Fintype V]
+
+def branch (c n : V) : Finset V := Finset.univ.filter (fun z=>z≠c ∧ (next h) c z=n)
+lemma mem_branch {c n z : V} : z∈(branch h) c n ↔ z≠c ∧ (next h) c z=n := by
+  simp only [branch,Finset.mem_filter,Finset.mem_univ,true_and]
+lemma branch_adj {c n z : V} (hz : z∈(branch h) c n) : G.Adj c n := by
+  obtain ⟨hz,hn⟩ := (mem_branch h).mp hz
+  simpa only [hn] using (next_adj h) hz.symm
+lemma branch_closed {c n x y : V} (hx : x∈(branch h) c n) (hy : y≠c) (e : G.Adj x y) :
+    y∈(branch h) c n := by
+  obtain ⟨hx,hn⟩ := (mem_branch h).mp hx
+  exact (mem_branch h).mpr ⟨hy,((next_adjacent h) hx.symm hy.symm e).symm.trans hn⟩
+lemma branch_disjoint {c n m : V} (hnm : n≠m) : Disjoint ((branch h) c n) ((branch h) c m) := by
+  apply Finset.disjoint_left.mpr
+  intro z hz hz'
+  exact hnm (((mem_branch h).mp hz).2.symm.trans ((mem_branch h).mp hz').2)
+
+lemma distance_step {c n z : V} (e : G.Adj c n) :
+    G.dist n z + (if z∈(branch h) c n then 2 else 0)=G.dist c z+1 := by
+  by_cases hb : z∈(branch h) c n
+  · rw [ite_eq_left hb]
+    obtain ⟨hz,hn⟩ := (mem_branch h).mp hb
+    have hd := (dist_next h) hz.symm
+    rw [hn] at hd
+    omega
+  · rw [ite_eq_right hb,Nat.add_zero]
+    by_cases hz : z=c
+    · subst z
+      rw [SimpleGraph.dist_self,dist_eq_one_iff_adj.mpr e.symm]
+    · apply (dist_not_next h) e
+      intro hn
+      exact hb ((mem_branch h).mpr ⟨hz,hn⟩)
+
+def potential (w : V → ℕ) (c : V) : ℕ := ∑ z,w z*G.dist c z
+lemma potential_step (w : V → ℕ) {c n : V} (e : G.Adj c n) :
+    (potential (G:=G)) w n+2*(∑ z∈(branch h) c n,w z)=(potential (G:=G)) w c+∑ z,w z := by
+  have hi (z : V) : w z*G.dist n z+(if z∈(branch h) c n then 2*w z else 0)=
+      w z*G.dist c z+w z := by
+    have hh := congrArg (fun t : ℕ=>w z*t) (distance_step h (z:=z) e)
+    split_ifs at hh ⊢ <;> nlinarith only [hh]
+  have hs := Finset.sum_congr (s₁:=Finset.univ) rfl (fun z _=>hi z)
+  simp only [Finset.sum_add_distrib] at hs
+  have hif : (∑ z,if z∈(branch h) c n then 2*w z else 0)=2*(∑ z∈(branch h) c n,w z) := by
+    rw [←Finset.sum_filter,Finset.filter_mem_eq_inter,Finset.univ_inter,Finset.mul_sum]
+  rw [hif] at hs
+  exact hs
+
+/-- A finite tree has a weighted centroid: every branch after its deletion
+has at most half of the total nonnegative integral weight. Zero weights allowed. -/
+theorem exists_centroid (w : V → ℕ) :
+    ∃ c : V,∀ n : V,2*(∑ z∈(branch h) c n,w z)≤∑ z,w z := by
+  have : Nonempty V := h.connected.nonempty
+  obtain ⟨c,_,hc⟩ := Finset.univ.exists_min_image ((potential (G:=G)) w) Finset.univ_nonempty
+  refine ⟨c,fun n=>?_⟩
+  by_cases he : G.Adj c n
+  · have hh := (potential_step h) w he
+    have hm := hc n (Finset.mem_univ n)
+    omega
+  · have hempty : (branch h) c n=∅ := Finset.eq_empty_iff_forall_notMem.mpr
+      (fun z hz=>he ((branch_adj h) hz))
+    simp only [hempty,Finset.sum_empty,Nat.mul_zero,Nat.zero_le]
+
+end TorsionFreeZeroDivisors.TreeCentroid
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/GroupRing/MapRestrict.lean b/lean/OAI/Algebra/GroupRing/MapRestrict.lean
new file mode 100644
index 0000000000000000000000000000000000000000..29778e2d649a6374fc25d40f5b238f02a316dcb4
--- /dev/null
+++ b/lean/OAI/Algebra/GroupRing/MapRestrict.lean
@@ -0,0 +1,370 @@
+import Mathlib
+import OAI.Algebra.GroupRing.BFSTree
+
+namespace OAI
+
+noncomputable section
+
+namespace TorsionFreeZeroDivisors.MapRestrict
+
+section
+open scoped Classical
+open PermutationCycles MapEuler
+variable {O : Type} [Fintype O] (σ α : Equiv.Perm O) (P : O→Prop)
+    (hs : ∀ x,P (σ x)↔P x) (ha : ∀ x,P (α x)↔P x)
+local notation "σP" => perm σ P hs
+local notation "αP" => perm α P ha
+local notation "σN" => perm σ (fun x=>¬P x) (not_invariant σ P hs)
+local notation "αN" => perm α (fun x=>¬P x) (not_invariant α P ha)
+
+def componentInclude : Component σP αP→ Component σ α :=
+  MapEuler.lift σP αP (fun x=>component σ α x.val)
+    (fun x=>component_rotation σ α x.val) (fun x=>component_partner σ α x.val)
+omit [Fintype O] in
+@[simp] lemma componentInclude_component (x : Subtype P) :
+    componentInclude σ α P hs ha (component σP αP x)=component σ α x.val := rfl
+
+def componentRaw (x : O) : Component σP αP ⊕ Component σN αN :=
+  if h:P x then .inl (component σP αP ⟨x,h⟩) else .inr (component σN αN ⟨x,h⟩)
+omit [Fintype O] in
+lemma componentRaw_rotation (x : O) : componentRaw σ α P hs ha (σ x)=componentRaw σ α P hs ha x := by
+  by_cases hx : P x
+  · rw [componentRaw,dite_eq_left ((hs x).mpr hx),componentRaw,dite_eq_left hx]
+    exact congrArg Sum.inl (component_rotation σP αP ⟨x,hx⟩)
+  · rw [componentRaw,dite_eq_right (fun h=>hx ((hs x).mp h)),componentRaw,dite_eq_right hx]
+    exact congrArg Sum.inr (component_rotation σN αN ⟨x,hx⟩)
+omit [Fintype O] in
+lemma componentRaw_partner (x : O) : componentRaw σ α P hs ha (α x)=componentRaw σ α P hs ha x := by
+  by_cases hx : P x
+  · rw [componentRaw,dite_eq_left ((ha x).mpr hx),componentRaw,dite_eq_left hx]
+    exact congrArg Sum.inl (component_partner σP αP ⟨x,hx⟩)
+  · rw [componentRaw,dite_eq_right (fun h=>hx ((ha x).mp h)),componentRaw,dite_eq_right hx]
+    exact congrArg Sum.inr (component_partner σN αN ⟨x,hx⟩)
+
+def componentEquiv : Component σ α≃Component σP αP ⊕ Component σN αN where
+  toFun := MapEuler.lift σ α (componentRaw σ α P hs ha)
+    (componentRaw_rotation σ α P hs ha) (componentRaw_partner σ α P hs ha)
+  invFun := Sum.elim (componentInclude σ α P hs ha)
+    (componentInclude σ α (fun x=>¬P x) (not_invariant σ P hs) (not_invariant α P ha))
+  left_inv := by
+    intro c
+    obtain ⟨x,rfl⟩ := Quotient.mk_surjective c
+    change (Sum.elim _ _) (componentRaw σ α P hs ha x)=component σ α x
+    unfold componentRaw
+    split_ifs <;> rfl
+  right_inv := by
+    intro c
+    rcases c with c|c
+    · obtain ⟨x,rfl⟩ := Quotient.mk_surjective c
+      change componentRaw σ α P hs ha x.val=Sum.inl (component σP αP x)
+      rw [componentRaw,dite_eq_left x.property]
+    · obtain ⟨x,rfl⟩ := Quotient.mk_surjective c
+      change componentRaw σ α P hs ha x.val=Sum.inr (component σN αN x)
+      rw [componentRaw,dite_eq_right x.property]
+
+lemma component_card : Nat.card (Component σ α)=Nat.card (Component σP αP)+Nat.card (Component σN αN) := by
+  rw [Nat.card_congr (componentEquiv σ α P hs ha),Nat.card_sum]
+
+omit [Fintype O] in
+include hs ha in
+lemma mul_invariant (x : O) : P ((α*σ) x)↔P x := (ha (σ x)).trans (hs x)
+omit [Fintype O] in
+lemma perm_mul : perm (α*σ) P (mul_invariant σ α P hs ha)=αP*σP := rfl
+
+/-- Restriction to any invariant union of map components preserves actual
+Euler genus zero. The proof uses decomposition and the universal Euler upper
+bound on BOTH complementary pieces. -/
+theorem genusZero (hi : Function.Involutive α) (hz : GenusZero σ α) : GenusZero σP αP := by
+  have hs' := cycle_card σ P hs
+  have hf' := cycle_card (α*σ) P (mul_invariant σ α P hs ha)
+  have ha' := support_card α P ha
+  have hc' := component_card σ α P hs ha
+  have hP := MapEuler.upper σP αP (perm_involutive α P ha hi)
+  have hN := MapEuler.upper σN αN (perm_involutive α (fun x=>¬P x) (not_invariant α P ha) hi)
+  have heN : perm (α*σ) (fun x=>¬P x) (not_invariant (α*σ) P (mul_invariant σ α P hs ha))=αN*σN := rfl
+  rw [perm_mul σ α P hs ha,heN] at hf'
+  unfold GenusZero at hz ⊢
+  simp only [ConedMap.support_card_nat] at ha' hP hN hz ⊢
+  omega
+
+end
+
+open scoped Classical
+open PermutationCycles MapEuler
+variable {O : Type} [Fintype O] (σ α : Equiv.Perm O) (hi : Function.Involutive α)
+    (S : Set (Cycle σ))
+
+lemma cycleInclude_injective (f : Equiv.Perm O) (P : O→Prop) (hf : ∀ x,P (f x)↔P x) :
+    Function.Injective (cycleInclude f P hf) := (cycleEquiv f P hf).symm.injective.comp Sum.inl_injective
+
+def internalPair : Equiv.Perm O := inducedPair α hi (fun x=>cycle σ x∈S)
+omit [Fintype O] in
+lemma internalPair_involutive : Function.Involutive (internalPair σ α hi S) :=
+  inducedPairFun_involutive α hi _
+omit [Fintype O] in
+lemma rotation_invariant (x : O) : (cycle σ (σ x)∈S)↔cycle σ x∈S := by rw [cycle_apply]
+omit [Fintype O] in
+lemma pairing_invariant (x : O) : (cycle σ (internalPair σ α hi S x)∈S)↔cycle σ x∈S := by
+  change (cycle σ (if cycle σ x∈S ∧ cycle σ (α x)∈S then α x else x)∈S)↔cycle σ x∈S
+  split_ifs with h
+  · exact iff_of_true h.2 h.1
+  · rfl
+
+def rotation := perm σ (fun x=>cycle σ x∈S) (rotation_invariant σ S)
+def pairing := perm (internalPair σ α hi S) (fun x=>cycle σ x∈S) (pairing_invariant σ α hi S)
+omit [Fintype O] in
+lemma pairing_involutive : Function.Involutive (pairing σ α hi S) :=
+  perm_involutive _ _ _ (internalPair_involutive σ α hi S)
+
+def vertexEquiv : Cycle (rotation σ S)≃S where
+  toFun c := ⟨cycleInclude σ (fun x=>cycle σ x∈S) (rotation_invariant σ S) c,by
+    obtain ⟨x,rfl⟩ := cycle_surjective (rotation σ S) c
+    exact x.property⟩
+  invFun v := cycle (rotation σ S) ⟨Quotient.out v.val,by rw [MapEuler.home_cycle];exact v.property⟩
+  left_inv := by
+    intro c
+    apply cycleInclude_injective
+    exact Quotient.out_eq _
+  right_inv := by intro v;exact Subtype.ext (Quotient.out_eq v.val)
+@[simp] lemma vertexEquiv_cycle (x : {x : O // cycle σ x∈S}) :
+    vertexEquiv σ S (cycle (rotation σ S) x)=⟨cycle σ x.val,x.property⟩ := rfl
+
+/-- The restricted dart system realizes precisely the induced simple graph. -/
+def graphIso : graph (rotation σ S) (pairing σ α hi S) (pairing_involutive σ α hi S) ≃g
+    (graph σ α hi).induce S where
+  toEquiv := vertexEquiv σ S
+  map_rel_iff' := by
+    intro v w
+    constructor
+    · intro he
+      change (graph σ α hi).Adj (vertexEquiv σ S v).val (vertexEquiv σ S w).val at he
+      obtain ⟨hne,x,hx,hy⟩ := he
+      have hxS : cycle σ x∈S := hx ▸ (vertexEquiv σ S v).property
+      have hyS : cycle σ (α x)∈S := hy ▸ (vertexEquiv σ S w).property
+      refine ⟨fun h=>hne (congrArg (fun c=>(vertexEquiv σ S c).val) h),⟨x,hxS⟩,?_,?_⟩
+      · apply (vertexEquiv σ S).injective
+        exact Subtype.ext hx
+      · apply (vertexEquiv σ S).injective
+        apply Subtype.ext
+        change cycle σ (internalPair σ α hi S x)=(vertexEquiv σ S w).val
+        rw [internalPair,inducedPair_apply,ite_eq_left ⟨hxS,hyS⟩]
+        exact hy
+    · rintro ⟨hne,x,hx,hy⟩
+      change (graph σ α hi).Adj (vertexEquiv σ S v).val (vertexEquiv σ S w).val
+      have hvw : (vertexEquiv σ S v).val≠(vertexEquiv σ S w).val :=
+        fun h=>hne ((vertexEquiv σ S).injective (Subtype.ext h))
+      have hx' := congrArg (fun c=>(vertexEquiv σ S c).val) hx
+      have hy' := congrArg (fun c=>(vertexEquiv σ S c).val) hy
+      change cycle σ x.val=(vertexEquiv σ S v).val at hx'
+      change cycle σ (internalPair σ α hi S x.val)=(vertexEquiv σ S w).val at hy'
+      have hh : cycle σ (α x.val)∈S := by
+        by_contra hn
+        rw [internalPair,inducedPair_apply,ite_eq_right (fun h=>hn h.2)] at hy'
+        exact hvw (hx'.symm.trans hy')
+      rw [internalPair,inducedPair_apply,ite_eq_left ⟨x.property,hh⟩] at hy'
+      exact ⟨hvw,x.val,hx',hy'⟩
+
+theorem induced_genusZero (hz : GenusZero σ α) : GenusZero (rotation σ S) (pairing σ α hi S) :=
+  genusZero σ (internalPair σ α hi S) (fun x=>cycle σ x∈S) (rotation_invariant σ S)
+    (pairing_invariant σ α hi S) (internalPair_involutive σ α hi S)
+    (genusZero_inducedPair σ α hi _ hz)
+
+end TorsionFreeZeroDivisors.MapRestrict
+
+namespace TorsionFreeZeroDivisors.MapContract
+open scoped Classical
+open PermutationCycles MapEuler
+variable {O : Type} [Fintype O] (σ α : Equiv.Perm O) (hi : Function.Involutive α)
+    (B : Set (Cycle σ))
+local notation "P" => fun x : O=>cycle σ x∈B
+local notation "s" => MapRestrict.rotation σ B
+local notation "a" => MapRestrict.pairing σ α hi B
+local notation "hai" => MapRestrict.pairing_involutive σ α hi B
+variable (T : SimpleGraph (Cycle (MapRestrict.rotation σ B)))
+  (hT : T≤graph (MapRestrict.rotation σ B) (MapRestrict.pairing σ α hi B) (MapRestrict.pairing_involutive σ α hi B))
+local notation "b" => subgraphPair s a hai T hT
+
+def treePair : Equiv.Perm O := Equiv.Perm.ofSubtype (p:=fun x : O=>cycle σ x∈B)
+  (subgraphPair (MapRestrict.rotation σ B) (MapRestrict.pairing σ α hi B)
+    (MapRestrict.pairing_involutive σ α hi B) T hT)
+local notation "β" => treePair σ α hi B T hT
+lemma treePair_inside (x : {x : O // P x}) : β x=(b x).val := Equiv.Perm.ofSubtype_apply_coe b x
+lemma treePair_outside (x : O) (hx : ¬P x) : β x=x := Equiv.Perm.ofSubtype_apply_of_not_mem b hx
+lemma treePair_invariant (x : O) : P (β x)↔P x := Equiv.Perm.ofSubtype_apply_mem_iff_mem b x
+lemma treePair_involutive : Function.Involutive β := by
+  intro x
+  by_cases hx : P x
+  · have h := congrArg Subtype.val (subgraphPair_involutive s a hai T hT ⟨x,hx⟩)
+    change β (β (⟨x,hx⟩ : {x : O // P x}))=x
+    rw [treePair_inside,treePair_inside]
+    exact h
+  · rw [treePair_outside σ α hi B T hT x hx,treePair_outside σ α hi B T hT x hx]
+lemma treePair_subpairing (x : O) : β x=x ∨ β x=α x := by
+  by_cases hx : P x
+  · have he := subgraphPair_subpairing s a hai T hT ⟨x,hx⟩
+    rcases he with he|he
+    · exact Or.inl ((treePair_inside σ α hi B T hT ⟨x,hx⟩).trans (congrArg Subtype.val he))
+    · have h := (treePair_inside σ α hi B T hT ⟨x,hx⟩).trans (congrArg Subtype.val he)
+      change β x=MapRestrict.internalPair σ α hi B x at h
+      rw [MapRestrict.internalPair,inducedPair_apply] at h
+      split_ifs at h
+      · exact Or.inr h
+      · exact Or.inl h
+  · exact Or.inl (treePair_outside σ α hi B T hT x hx)
+
+def rotation : Equiv.Perm O := β*σ
+def pairing : Equiv.Perm O := α*β
+local notation "ρ" => rotation σ α hi B T hT
+local notation "γ" => pairing σ α hi B T hT
+lemma pairing_involutive : Function.Involutive γ :=
+  complement_involutive α β hi (treePair_involutive σ α hi B T hT) (treePair_subpairing σ α hi B T hT)
+
+theorem genusZero (hz : GenusZero σ α) : GenusZero ρ γ := by
+  have h := (genusZero_dual (α*σ) γ (pairing_involutive σ α hi B T hT)).mp
+    (genusZero_complement_dual σ α β hi (treePair_involutive σ α hi B T hT)
+      (treePair_subpairing σ α hi B T hT) hz)
+  rw [show γ*(α*σ)=ρ from complement_face σ α β hi (treePair_involutive σ α hi B T hT)
+    (treePair_subpairing σ α hi B T hT)] at h
+  exact h
+
+lemma rotation_invariant (x : O) : P (ρ x)↔P x := by
+  change P (β (σ x))↔P x
+  simpa only [cycle_apply] using treePair_invariant σ α hi B T hT (σ x)
+lemma rotation_inside : MapRestrict.perm ρ P (rotation_invariant σ α hi B T hT)=b*s := by
+  ext x
+  exact treePair_inside σ α hi B T hT (s x)
+
+variable (hz : GenusZero σ α) (ht : T.IsTree)
+include hz ht in
+lemma inside_cycle_eq {x y : O} (hx : P x) (hy : P y) : cycle ρ x=cycle ρ y := by
+  have hn := tree_contour_card s a hai T hT (MapRestrict.induced_genusZero σ α hi B hz) ht
+  have hs : Subsingleton (Cycle (b*s)) := (Nat.card_eq_one_iff_unique.mp hn).1
+  have h := Subsingleton.elim (cycle (b*s) ⟨x,hx⟩) (cycle (b*s) ⟨y,hy⟩)
+  rw [←rotation_inside σ α hi B T hT] at h
+  exact congrArg (MapRestrict.cycleInclude ρ P (rotation_invariant σ α hi B T hT)) h
+
+include hz ht in
+lemma quotient_invariant (x : O) : cycle ρ (σ x)=cycle ρ x := by
+  by_cases hx : P x
+  · exact inside_cycle_eq σ α hi B T hT hz ht (by simpa only [cycle_apply] using hx) hx
+  · have h : ρ x=σ x := treePair_outside σ α hi B T hT (σ x) (by simpa only [cycle_apply] using hx)
+    rw [←h,cycle_apply]
+
+def quotient : Cycle σ→Cycle ρ :=
+  PermutationCycles.lift σ (fun x=>cycle ρ x) (quotient_invariant σ α hi B T hT hz ht)
+local notation "q" => quotient σ α hi B T hT hz ht
+@[simp] lemma quotient_cycle (x : O) : q (cycle σ x)=cycle ρ x := rfl
+lemma quotient_surjective : Function.Surjective q := by
+  intro v
+  obtain ⟨x,rfl⟩ := cycle_surjective ρ v
+  exact ⟨cycle σ x,rfl⟩
+
+def labelRaw (x : O) : Option (Cycle σ) := if P x then none else some (cycle σ x)
+lemma labelRaw_invariant (x : O) : labelRaw σ B (ρ x)=labelRaw σ B x := by
+  by_cases hx : P x
+  · rw [labelRaw,ite_eq_left ((rotation_invariant σ α hi B T hT x).mpr hx),labelRaw,ite_eq_left hx]
+  · have he : ρ x=σ x := treePair_outside σ α hi B T hT (σ x) (by simpa only [cycle_apply] using hx)
+    simp only [he,labelRaw,cycle_apply]
+def label : Cycle ρ→Option (Cycle σ) :=
+  PermutationCycles.lift ρ (labelRaw σ B) (labelRaw_invariant σ α hi B T hT)
+lemma label_quotient (v : Cycle σ) : label σ α hi B T hT (q v)=if v∈B then none else some v := by
+  obtain ⟨x,rfl⟩ := cycle_surjective σ v
+  rfl
+
+lemma quotient_eq_iff (v w : Cycle σ) : q v=q w ↔ v=w ∨ (v∈B ∧ w∈B) := by
+  constructor
+  · intro h
+    have he := congrArg (label σ α hi B T hT) h
+    rw [label_quotient,label_quotient] at he
+    by_cases hv : v∈B <;> by_cases hw : w∈B <;> simp only [hv,hw,ite_true,ite_false] at he
+    · exact Or.inr ⟨hv,hw⟩
+    · contradiction
+    · contradiction
+    · exact Or.inl (Option.some.inj he)
+  · rintro (rfl|⟨hv,hw⟩)
+    · rfl
+    · obtain ⟨x,rfl⟩ := cycle_surjective σ v
+      obtain ⟨y,rfl⟩ := cycle_surjective σ w
+      exact inside_cycle_eq σ α hi B T hT hz ht hv hw
+
+include hz ht in
+lemma cycle_treePair (x : O) : cycle ρ (β x)=cycle ρ x := by
+  by_cases hx : P x
+  · exact inside_cycle_eq σ α hi B T hT hz ht ((treePair_invariant σ α hi B T hT x).mpr hx) hx
+  · rw [treePair_outside σ α hi B T hT x hx]
+
+/-- Every original edge either contracts to a vertex or is an actual edge. -/
+lemma quotient_adj {v w : Cycle σ} (he : (graph σ α hi).Adj v w) :
+    q v=q w ∨ (graph ρ γ (pairing_involutive σ α hi B T hT)).Adj (q v) (q w) := by
+  by_cases h : q v=q w
+  · exact Or.inl h
+  · obtain ⟨_,x,rfl,rfl⟩ := he
+    refine Or.inr ⟨h,β x,cycle_treePair σ α hi B T hT hz ht x,?_⟩
+    change cycle ρ (α (β (β x)))=cycle ρ (α x)
+    rw [treePair_involutive σ α hi B T hT x]
+
+/-- No new nonloop adjacency is introduced by the literal contraction. -/
+lemma adj_lift {v w : Cycle ρ} (he : (graph ρ γ (pairing_involutive σ α hi B T hT)).Adj v w) :
+    ∃ x y,(graph σ α hi).Adj x y ∧ q x=v ∧ q y=w := by
+  obtain ⟨hne,x,rfl,rfl⟩ := he
+  have hb : β x=x := by
+    rcases treePair_subpairing σ α hi B T hT x with h|h
+    · exact h
+    · have hf : γ x=x := (congrArg α h).trans (hi x)
+      exact (hne (congrArg (cycle ρ) hf).symm).elim
+  have he : γ x=α x := congrArg α hb
+  refine ⟨cycle σ x,cycle σ (α x),⟨?_,x,rfl,rfl⟩,rfl,?_⟩
+  · intro h
+    exact hne ((congrArg q h).trans (congrArg (cycle ρ) he.symm))
+  · exact congrArg (cycle ρ) he.symm
+
+end TorsionFreeZeroDivisors.MapContract
+
+namespace TorsionFreeZeroDivisors.GraphBall
+open scoped Classical
+open SimpleGraph
+variable {V : Type} (G : SimpleGraph V) (hc : G.Connected) (root : V) (N : ℕ)
+def vertices : Set V := {v | G.dist v root≤N}
+def rootVertex : vertices G root N := ⟨root,by simp [vertices]⟩
+
+include hc
+lemma exists_walk (v : vertices G root N) :
+    ∃ p : (G.induce (vertices G root N)).Walk v (rootVertex G root N), p.length=G.dist v.val root := by
+  generalize hn : G.dist v.val root=n
+  induction n using Nat.strong_induction_on generalizing v with
+  | h n ih =>
+    by_cases hv : v.val=root
+    · have he : v=rootVertex G root N := Subtype.ext hv
+      subst v
+      exact ⟨Walk.nil,by simpa only [Walk.length_nil,rootVertex,dist_self] using hn⟩
+    · let u := BFSTree.parent G hc root v.val
+      have hd : G.dist u root+1=G.dist v.val root := BFSTree.parent_dist G hc root v.val hv
+      have hu : u∈vertices G root N := by have hh := v.property;change G.dist v.val root≤N at hh;exact by dsimp [vertices];omega
+      obtain ⟨p,hp⟩ := ih (G.dist u root) (by omega) ⟨u,hu⟩ rfl
+      have he : (G.induce (vertices G root N)).Adj v ⟨u,hu⟩ := BFSTree.parent_adj G hc root v.val hv
+      refine ⟨p.cons he,?_⟩
+      rw [Walk.length_cons,hp,hd,hn]
+
+lemma connected : (G.induce (vertices G root N)).Connected := by
+  apply (connected_iff_exists_forall_reachable (G.induce (vertices G root N))).mpr
+  refine ⟨rootVertex G root N,fun v=>?_⟩
+  obtain ⟨p,_⟩ := exists_walk G hc root N v
+  exact p.reverse.reachable
+
+lemma dist_root (v : vertices G root N) :
+    (G.induce (vertices G root N)).dist v (rootVertex G root N)=G.dist v.val root := by
+  apply Nat.le_antisymm
+  · obtain ⟨p,hp⟩ := exists_walk G hc root N v
+    rw [←hp]
+    exact (G.induce (vertices G root N)).dist_le p
+  · obtain ⟨p,hp⟩ := (connected G hc root N).exists_walk_length_eq_dist v (rootVertex G root N)
+    let f : G.induce (vertices G root N) →g G := ⟨Subtype.val,fun h=>h⟩
+    have h := G.dist_le (p.map f)
+    change G.dist v.val root≤(p.map f).length at h
+    simpa only [Walk.length_map,hp] using h
+
+end TorsionFreeZeroDivisors.GraphBall
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/GroupRing/MatchedLabels.lean b/lean/OAI/Algebra/GroupRing/MatchedLabels.lean
new file mode 100644
index 0000000000000000000000000000000000000000..2a4fba90af57c6bed586b6c44e868dbb4d882ffa
--- /dev/null
+++ b/lean/OAI/Algebra/GroupRing/MatchedLabels.lean
@@ -0,0 +1,450 @@
+import Mathlib
+import OAI.Algebra.GroupRing.EntropyStages
+import OAI.Algebra.GroupRing.BlockPropagation
+
+namespace OAI
+
+noncomputable section
+
+namespace TorsionFreeZeroDivisors.MatchedLabels
+open scoped Classical
+open OccurrenceMatching StageLabels
+variable {Ω B E I A : Type*}
+variable (D : Data (Ω := Ω) (B := B) (E := E)) (color : B → I)
+variable (h : I → ℕ) (coordinate : ∀ b, D.positions b ≃ Fin (h (color b)))
+variable (symbol : E → (A ≃ A))
+
+def graph : SimpleGraph I where
+  Adj i j := i ≠ j ∧ ∃ b, color b = i ∧ color (D.matching.partner b) = j
+  symm := ⟨by
+    rintro i j ⟨hne,b,hi,hj⟩
+    exact ⟨hne.symm,D.matching.partner b,hj,by rw [D.matching.involutive]; exact hi⟩⟩
+  loopless := ⟨fun i hh => hh.1 rfl⟩
+
+structure Witness (i j : I) where
+  origin : B
+  origin_color : color origin = i
+  target_color : color (D.matching.partner origin) = j
+  side : E
+  joined : (D.positions origin).card < 2*(D.slice side origin (D.matching.partner origin)).card ∧
+    (D.positions (D.matching.partner origin)).card < 2*(D.slice side origin (D.matching.partner origin)).card ∧
+    (D.positions origin).card ≤ (D.slice side origin (D.matching.partner origin)).card+D.error ∧
+    (D.positions (D.matching.partner origin)).card ≤
+      (D.slice side origin (D.matching.partner origin)).card+D.error
+
+theorem exists_witness {i j : I} (hadj : (graph D color).Adj i j) :
+    Nonempty (Witness D color i j) := by
+  obtain ⟨hne,b,hi,hj⟩ := hadj
+  have hb : D.matching.partner b ≠ b := by
+    intro he
+    apply hne
+    rw [he] at hj
+    exact hi.symm.trans hj
+  obtain ⟨p,hp⟩ := (D.matched_iff b).mp hb
+  have he := D.partner_spec hp
+  change D.matching.partner b = p at he
+  obtain ⟨e,he'⟩ := hp
+  exact ⟨⟨b,hi,hj,e,by simpa only [he] using he'⟩⟩
+
+namespace Witness
+variable {D color} {i j : I} (W : Witness D color i j)
+
+def domain : Finset Ω := D.slice W.side W.origin (D.matching.partner W.origin)
+
+def originCoordinate : D.positions W.origin ≃ Fin (h i) :=
+  (coordinate W.origin).trans (finCongr (congrArg h W.origin_color))
+
+def targetCoordinate : D.positions (D.matching.partner W.origin) ≃ Fin (h j) :=
+  (coordinate (D.matching.partner W.origin)).trans (finCongr (congrArg h W.target_color))
+
+def includeDomain : W.domain ↪ D.positions W.origin where
+  toFun x := ⟨x.val,(D.slice_mem.mp x.property).1⟩
+  inj' := by
+    intro u v he
+    apply Subtype.ext
+    exact congrArg (fun z : D.positions W.origin => z.val) he
+
+def compareTarget (x : W.domain) : D.positions (D.matching.partner W.origin) :=
+  ⟨D.pairing.partner x.val,(D.slice_mem.mp x.property).2.2⟩
+
+def known : Finset (Fin (h i)) :=
+  Finset.univ.map (W.includeDomain.trans (W.originCoordinate h coordinate).toEmbedding)
+
+theorem known_card : (W.known h coordinate).card = W.domain.card := by
+  simp [known]
+
+def recover (x : W.known h coordinate) : W.domain :=
+  Classical.choose (Finset.mem_map.mp x.property)
+
+theorem recover_spec (x : W.known h coordinate) :
+    W.originCoordinate h coordinate (W.includeDomain (W.recover h coordinate x)) = x.val :=
+  (Classical.choose_spec (Finset.mem_map.mp x.property)).2
+
+def source (x : W.known h coordinate) : Fin (h j) :=
+  W.targetCoordinate h coordinate (W.compareTarget (W.recover h coordinate x))
+
+theorem deficit : h i - (W.known h coordinate).card ≤ D.error := by
+  rw [W.known_card]
+  have hc : h i = (D.positions W.origin).card := by
+    simpa using (Fintype.card_congr (W.originCoordinate h coordinate)).symm
+  rw [hc]
+  exact Nat.sub_le_iff_le_add.mpr (by simpa [domain,Nat.add_comm] using W.joined.2.2.1)
+
+end Witness
+
+def chooseWitness {i j : I} (hadj : (graph D color).Adj i j) : Witness D color i j :=
+  Classical.choice (exists_witness D color hadj)
+
+def links : Links (T := A) h where
+  graph := graph D color
+  known i j := if hadj : (graph D color).Adj i j then
+    (chooseWitness D color hadj).known h coordinate else ∅
+  source i j x := if hadj : (graph D color).Adj i j then
+    (chooseWitness D color hadj).source h coordinate ⟨x.val,by simpa only [dite_eq_left hadj] using x.property⟩
+    else False.elim (by simpa only [dite_eq_right hadj,Finset.notMem_empty] using x.property)
+  symbol i j := if hadj : (graph D color).Adj i j then symbol (chooseWitness D color hadj).side
+    else Equiv.refl A
+
+theorem links_deficit {i j : I} (hadj : (links D color h coordinate symbol).graph.Adj i j) :
+    h i - ((links D color h coordinate symbol).known i j).card ≤ D.error := by
+  change (graph D color).Adj i j at hadj
+  simpa only [links,dite_eq_left hadj] using (chooseWitness D color hadj).deficit h coordinate
+
+/-- Any actual comparison-compatible labeling induces full feasible words on
+all blocks, including those not present at a chosen multiplicity stage. -/
+theorem links_consistent (letters : Ω → A) (words : (i : I) → Fin (h i) → A)
+    (hcompare : ∀ x e, D.side x = some e → letters x = symbol e (letters (D.pairing.partner x)))
+    (hwords : ∀ b (x : D.positions b), words (color b) (coordinate b x) = letters x.val) :
+    (links D color h coordinate symbol).Consistent words := by
+  intro i j hadj k
+  change (graph D color).Adj i j at hadj
+  let W := chooseWitness D color hadj
+  let k' : W.known h coordinate := ⟨k.val,by simpa only [links,dite_eq_left hadj] using k.property⟩
+  let x := W.recover h coordinate k'
+  have hx := (D.slice_mem.mp x.property).2.1
+  have hs := W.recover_spec h coordinate k'
+  have word_transport : ∀ b (i : I) (he : color b = i) (y : D.positions b),
+      words i ((coordinate b).trans (finCongr (congrArg h he)) y) = letters y.val := by
+    intro b i he y
+    subst i
+    exact hwords b y
+  have ho : words i (W.originCoordinate h coordinate (W.includeDomain x)) = letters x.val :=
+    word_transport W.origin i W.origin_color (W.includeDomain x)
+  have ht : words j (W.targetCoordinate h coordinate (W.compareTarget x)) =
+      letters (D.pairing.partner x.val) :=
+    word_transport (D.matching.partner W.origin) j W.target_color (W.compareTarget x)
+  simp only [links,dite_eq_left hadj]
+  change words i k'.val = symbol W.side (words j (W.source h coordinate k'))
+  rw [← hs,ho]
+  exact (hcompare x.val W.side hx).trans (congrArg (symbol W.side) ht.symm)
+
+end TorsionFreeZeroDivisors.MatchedLabels
+
+namespace TorsionFreeZeroDivisors.BlockConstraints
+
+open scoped BigOperators
+
+/-- A partial parent map strictly decreasing the position index. -/
+structure ParentMap (h : ℕ) where
+  parent : Fin h → Option (Fin h)
+  decreasing : ∀ j i, parent j = some i → i.val < j.val
+
+namespace ParentMap
+
+variable {h : ℕ} (P : ParentMap h) {T : Type*}
+
+/-- Roots are precisely the positions not constrained to earlier positions. -/
+def Root := {j : Fin h // P.parent j = none}
+
+def Consistent (w : Fin h → T) : Prop :=
+  ∀ j i, P.parent j = some i → w j = w i
+
+/-- The letters at roots determine every consistent word. -/
+theorem determined_by_roots {w v : Fin h → T}
+    (hw : P.Consistent w) (hv : P.Consistent v)
+    (hr : ∀ r : P.Root, w r.val = v r.val) : w = v := by
+  funext j
+  have aux : ∀ n : ℕ, ∀ j : Fin h, j.val = n → w j = v j := by
+    intro n
+    induction n using Nat.strong_induction_on with
+    | h n ih =>
+      intro j hj
+      cases hp : P.parent j with
+      | none => exact hr ⟨j, hp⟩
+      | some i =>
+        rw [hw j i hp, hv j i hp]
+        exact ih i.val (hj ▸ P.decreasing j i hp) i rfl
+  exact aux j.val j rfl
+
+/-- A forest of equality constraints costs one free letter per root. -/
+theorem card_consistent_le [Fintype T] :
+    Nat.card {w : Fin h → T // P.Consistent w} ≤
+      (Fintype.card T) ^ Nat.card P.Root := by
+  classical
+  let : Fintype P.Root := inferInstanceAs (Fintype {j : Fin h // P.parent j = none})
+  let restriction : {w : Fin h → T // P.Consistent w} → (P.Root → T) :=
+    fun w r => w.val r.val
+  have hinj : Function.Injective restriction := by
+    intro w v he
+    apply Subtype.ext
+    exact P.determined_by_roots w.property v.property (congrFun he)
+  simpa [Nat.card_eq_fintype_card, Fintype.card_fun] using
+    Fintype.card_le_of_injective restriction hinj
+
+end ParentMap
+
+/-- A set of translated positions; the integral shift is positive. -/
+structure Translation (h : ℕ) where
+  shift : ℕ
+  positive : 0 < shift
+  domain : Finset (Fin h)
+  bounded : ∀ i ∈ domain, i.val + shift < h
+
+namespace Translation
+
+variable {h : ℕ} (D : Translation h)
+
+/-- The image position of a prescribed comparison. -/
+def target (i : D.domain) : Fin h := ⟨i.val.val + D.shift, D.bounded i.val i.property⟩
+
+theorem target_injective : Function.Injective D.target := by
+  intro i j he
+  have hv := congrArg Fin.val he
+  dsimp [target] at hv
+  apply Subtype.ext
+  apply Fin.ext
+  omega
+
+noncomputable def parents : ParentMap h where
+  parent j := if hj : ∃ i : D.domain, D.target i = j then some hj.choose.val else none
+  decreasing j i hp := by
+    classical
+    split at hp
+    next hex =>
+      have hei : hex.choose.val = i := Option.some.inj hp
+      have he := congrArg Fin.val hex.choose_spec
+      dsimp [target] at he
+      have ht := D.positive
+      have hlt : hex.choose.val.val < j.val :=
+        lt_of_lt_of_eq (Nat.lt_add_of_pos_right ht) he
+      simpa only [hei] using hlt
+    next => simp at hp
+
+theorem root_iff (j : Fin h) :
+    D.parents.parent j = none ↔ j ∉ Set.range D.target := by
+  classical
+  simp [parents, Set.mem_range]
+
+/-- Each distinct translated edge removes exactly one root. -/
+theorem card_roots : Nat.card D.parents.Root = h - D.domain.card := by
+  classical
+  let e : D.parents.Root ≃ {j : Fin h // j ∉ Set.range D.target} :=
+    Equiv.subtypeEquivRight (D.root_iff)
+  rw [Nat.card_congr e, Nat.card_eq_fintype_card, Fintype.card_subtype_compl]
+  have hc : Fintype.card {j : Fin h // j ∈ Set.range D.target} = D.domain.card := by
+    change Fintype.card (Set.range D.target) = D.domain.card
+    rw [← Fintype.card_coe D.domain]
+    exact (Fintype.card_congr (Equiv.ofInjective D.target D.target_injective)).symm
+  simpa using congrArg (fun k => h - k) hc
+
+/-- Equalities along a nonzero translation form a forest, even without the
+additional contiguous-domain hypothesis in the manuscript. -/
+theorem word_count {T : Type*} [Fintype T] :
+    Nat.card {w : Fin h → T // ∀ i : D.domain, w (D.target i) = w i.val} ≤
+      (Fintype.card T) ^ (h - D.domain.card) := by
+  classical
+  have heq : (fun w : Fin h → T => ∀ i : D.domain, w (D.target i) = w i.val) =
+      D.parents.Consistent := by
+    funext w
+    apply propext
+    constructor
+    · intro hw j i hp
+      dsimp [parents] at hp
+      split at hp
+      next hex =>
+        have hi := Option.some.inj hp
+        exact (congrArg w hex.choose_spec.symm).trans ((hw hex.choose).trans (congrArg w hi))
+      next => simp at hp
+    · intro hw i
+      have hp : D.parents.parent (D.target i) = some i.val := by
+        dsimp [parents]
+        split
+        next hex =>
+          congr 1
+          exact congrArg Subtype.val (D.target_injective hex.choose_spec)
+        next hn => exact False.elim (hn ⟨i, rfl⟩)
+      exact hw _ _ hp
+  rw [heq]
+  simpa [D.card_roots] using D.parents.card_consistent_le (T := T)
+
+end Translation
+
+/-- A reflection self-link on an overlapping interval contradicts either
+fixed-point-freeness of inversion or the reduced-word condition. Indices are
+integers; half-integer manuscript positions have been shifted by 1/2. -/
+theorem reflection_impossible {T : Type*} (bar : T → T)
+    (hbar : Function.Involutive bar) (hfree : ∀ t, bar t ≠ t)
+    (w : ℤ → T) (h reducedLo reducedHi lo hi b : ℤ)
+    (hlo : 0 ≤ lo) (hhi : hi < h) (_hne : lo ≤ hi)
+    (himagelo : 0 ≤ b - hi) (himagehi : b - lo < h)
+    (hlarge : h < 2 * (hi - lo + 1))
+    (hredlo : reducedLo ≤ lo) (hredhi : hi ≤ reducedHi)
+    (hred : ∀ i : ℤ, reducedLo ≤ i → i + 1 ≤ reducedHi → w (i+1) ≠ bar (w i))
+    (hcompare : ∀ i : ℤ, lo ≤ i → i ≤ hi → w i = bar (w (b-i))) : False := by
+  have hleft : 2 * lo ≤ b := by omega
+  have hright : b ≤ 2 * hi := by omega
+  let i := b / 2
+  have hrem := Int.emod_nonneg b (by norm_num : (2 : ℤ) ≠ 0)
+  have hrem2 := Int.emod_lt_of_pos b (by norm_num : (0 : ℤ) < 2)
+  by_cases heven : b % 2 = 0
+  · have hiLo : lo ≤ i := by dsimp [i]; omega
+    have hiHi : i ≤ hi := by dsimp [i]; omega
+    have hcenter : b - i = i := by dsimp [i]; omega
+    have he := hcompare i hiLo hiHi
+    rw [hcenter] at he
+    exact hfree (w i) he.symm
+  · have hiLo : lo ≤ i := by dsimp [i]; omega
+    have hiHi : i + 1 ≤ hi := by dsimp [i]; omega
+    have hcenter : b - i = i + 1 := by dsimp [i]; omega
+    have he := hcompare i hiLo (by omega)
+    rw [hcenter] at he
+    have hv : w (i+1) = bar (w i) := by
+      rw [he, hbar]
+    exact hred i (by omega) (by omega) hv
+
+end TorsionFreeZeroDivisors.BlockConstraints
+
+namespace TorsionFreeZeroDivisors.IntervalSelfLinks
+open scoped Classical
+open BlockConstraints
+
+/-- The literal increasing coordinate on a contiguous block of integer edge
+indices (the manuscript's half-integer centers shifted by 1/2). -/
+def coordinate (lo hi : ℤ) : (Finset.Ico lo hi) ≃ Fin (hi-lo).toNat where
+  toFun q := ⟨(q.val-lo).toNat,by
+    have hq := Finset.mem_Ico.mp q.property
+    omega⟩
+  invFun k := ⟨lo+k.val,by
+    apply Finset.mem_Ico.mpr
+    have hk := k.isLt
+    omega⟩
+  left_inv q := by
+    apply Subtype.ext
+    have hq := Finset.mem_Ico.mp q.property
+    dsimp
+    omega
+  right_inv k := by
+    apply Fin.ext
+    dsimp
+    omega
+
+theorem coordinate_val {lo hi : ℤ} (q : Finset.Ico lo hi) :
+    ((coordinate lo hi q).val : ℤ) = q.val-lo := by
+  have hq := Finset.mem_Ico.mp q.property
+  dsimp [coordinate]
+  omega
+
+variable (lo hi a : ℤ) (D : Finset ℤ)
+variable (ha : 0 < a) (hD : ∀ q ∈ D, q ∈ Finset.Ico lo hi ∧ q+a ∈ Finset.Ico lo hi)
+
+def domainEmbedding : D ↪ Fin (hi-lo).toNat where
+  toFun q := coordinate lo hi ⟨q.val,(hD q.val q.property).1⟩
+  inj' := by
+    intro q r he
+    have hh := (coordinate lo hi).injective he
+    exact Subtype.ext (congrArg (fun z : Finset.Ico lo hi => z.val) hh)
+
+def positiveTranslation : Translation (hi-lo).toNat where
+  shift := a.toNat
+  positive := by omega
+  domain := Finset.univ.map (domainEmbedding lo hi a D hD)
+  bounded := by
+    intro k hk
+    obtain ⟨q,_,rfl⟩ := Finset.mem_map.mp hk
+    have hq := Finset.mem_Ico.mp (hD q.val q.property).1
+    have ht := Finset.mem_Ico.mp (hD q.val q.property).2
+    change (q.val-lo).toNat+a.toNat < (hi-lo).toNat
+    omega
+
+theorem positive_card : (positiveTranslation lo hi a D ha hD).domain.card = D.card := by
+  simp [positiveTranslation]
+
+theorem positive_consistent {A : Type*} (w : Fin (hi-lo).toNat → A)
+    (hcompare : ∀ q (hq : q ∈ D),
+      w (coordinate lo hi ⟨q+a,(hD q hq).2⟩) = w (coordinate lo hi ⟨q,(hD q hq).1⟩))
+    (k : (positiveTranslation lo hi a D ha hD).domain) :
+    w ((positiveTranslation lo hi a D ha hD).target k) = w k.val := by
+  obtain ⟨q,_,hk⟩ := Finset.mem_map.mp k.property
+  have ht : (positiveTranslation lo hi a D ha hD).target k =
+      coordinate lo hi ⟨q.val+a,(hD q.val q.property).2⟩ := by
+    apply Fin.ext
+    change k.val.val+a.toNat = (q.val+a-lo).toNat
+    rw [← hk]
+    change (q.val-lo).toNat+a.toNat = (q.val+a-lo).toNat
+    have hh := Finset.mem_Ico.mp (hD q.val q.property).1
+    omega
+  rw [ht,← hk]
+  exact hcompare q.val q.property
+
+/-- Either direction of a nonzero translation yields exactly |D| distinct
+forest constraints, without requiring a substring to contain the entire block. -/
+theorem translation_representation (a : ℤ) (D : Finset ℤ) (ha : a ≠ 0)
+    (hD : ∀ q ∈ D, q ∈ Finset.Ico lo hi ∧ q+a ∈ Finset.Ico lo hi) :
+    ∃ tr : Translation (hi-lo).toNat, tr.domain.card = D.card ∧
+      ∀ (A : Type*) (w : Fin (hi-lo).toNat → A),
+        (∀ q (hq : q ∈ D),
+          w (coordinate lo hi ⟨q+a,(hD q hq).2⟩) = w (coordinate lo hi ⟨q,(hD q hq).1⟩)) →
+          ∀ k : tr.domain, w (tr.target k) = w k.val := by
+  rcases lt_or_gt_of_ne ha with ha | ha
+  · let add : ℤ ↪ ℤ := ⟨fun q => q+a,fun _ _ hh => add_right_cancel hh⟩
+    let D' := D.map add
+    have hD' : ∀ q ∈ D', q ∈ Finset.Ico lo hi ∧ q+(-a) ∈ Finset.Ico lo hi := by
+      intro q hq
+      obtain ⟨r,hr,rfl⟩ := Finset.mem_map.mp hq
+      change r+a ∈ Finset.Ico lo hi ∧ r+a+(-a) ∈ Finset.Ico lo hi
+      simpa only [add_neg_cancel_right] using And.intro (hD r hr).2 (hD r hr).1
+    refine ⟨positiveTranslation lo hi (-a) D' (by omega) hD',?_,?_⟩
+    · rw [positive_card]
+      exact Finset.card_map _
+    · intro A w hw k
+      apply positive_consistent lo hi (-a) D' (by omega) hD' w ?_ k
+      intro q hq
+      obtain ⟨r,hr,rfl⟩ := Finset.mem_map.mp hq
+      change w (coordinate lo hi ⟨r+a+(-a),_⟩) = w (coordinate lo hi ⟨r+a,_⟩)
+      simpa only [add_neg_cancel_right] using (hw r hr).symm
+  · exact ⟨positiveTranslation lo hi a D ha hD,positive_card lo hi a D ha hD,
+      fun _ w hw => positive_consistent lo hi a D ha hD w hw⟩
+
+/-- Direct reflection obstruction on literal interval coordinates. The reduced
+word is the actual block word; no cyclic reduction or external extension is used. -/
+theorem reflection_excluded {A : Type*} (bar : A → A)
+    (hbar : Function.Involutive bar) (hfree : ∀ x, bar x ≠ x)
+    (w : ℤ → A) (L U l u b : ℤ)
+    (hl : L ≤ l) (hu : u ≤ U) (_hne : l < u)
+    (htl : L ≤ b-(u-1)) (htu : b-l < U)
+    (hmass : U-L < 2*(u-l))
+    (hred : ∀ q, L ≤ q → q+1 < U → w (q+1) ≠ bar (w q))
+    (hcompare : ∀ q, l ≤ q → q < u → w q = bar (w (b-q))) : False := by
+  have hleft : 2*l ≤ b := by omega
+  have hright : b ≤ 2*(u-1) := by omega
+  let i := b/2
+  have hrem := Int.emod_nonneg b (by norm_num : (2 : ℤ) ≠ 0)
+  have hrem2 := Int.emod_lt_of_pos b (by norm_num : (0 : ℤ) < 2)
+  by_cases heven : b%2 = 0
+  · have hi : l ≤ i ∧ i < u := by dsimp [i]; omega
+    have hb : b-i=i := by dsimp [i]; omega
+    have hh := hcompare i hi.1 hi.2
+    rw [hb] at hh
+    exact hfree (w i) hh.symm
+  · have hi : l ≤ i ∧ i+1 < u := by dsimp [i]; omega
+    have hb : b-i=i+1 := by dsimp [i]; omega
+    have hh := hcompare i hi.1 (by omega)
+    rw [hb] at hh
+    apply hred i (by omega) (by omega)
+    rw [hh,hbar]
+
+end TorsionFreeZeroDivisors.IntervalSelfLinks
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/GroupRing/MatchingGraphs.lean b/lean/OAI/Algebra/GroupRing/MatchingGraphs.lean
new file mode 100644
index 0000000000000000000000000000000000000000..18e972d9d03bdd262e91763e344ae51790ab4c88
--- /dev/null
+++ b/lean/OAI/Algebra/GroupRing/MatchingGraphs.lean
@@ -0,0 +1,456 @@
+import Mathlib
+import OAI.Algebra.GroupRing.BallCount
+import OAI.Algebra.GroupRing.PortSubdivision
+
+namespace OAI
+
+noncomputable section
+
+namespace TorsionFreeZeroDivisors.MatchingGraphs
+open PortSubdivision BallCount GirthSwitch
+variable {V D T : Type*} [Fintype V] [Fintype D] [DecidableEq D]
+
+omit [DecidableEq D] in
+/-- All degrees are controlled by the fixed port fibers. -/
+theorem subdivision_degree (Γ : PortGraph V D) (d : ℕ) (h2 : 2 ≤ d)
+    (hd : ∀ v, Nat.card {e : D // Γ.origin e = v} ≤ d) (a : V ⊕ D) :
+    (graphNeighbors Γ.subdivision a).card ≤ d := by
+  classical
+  rw [card_graphNeighbors]
+  cases a with
+  | inl v => rw [Γ.card_original_neighbors]; exact hd v
+  | inr e => rw [Γ.card_port_neighbors]; exact h2
+
+/-- Uniformly many ports of one label lie outside both endpoint neighborhoods. -/
+theorem exists_far_port (Γ : PortGraph V D) (label : D → T)
+    (d R : ℕ) (h2 : 2 ≤ d)
+    (hd : ∀ v, Nat.card {e : D // Γ.origin e = v} ≤ d)
+    (x : D) (hbig : 4*d^(R+1) < Nat.card {e : D // label e = label x}) :
+    ∃ e : D, label e = label x ∧
+      ∀ a ∈ ({Sum.inr x,Sum.inr (Γ.reverse x)} : Set (V ⊕ D)),
+      ∀ b ∈ ({Sum.inr e,Sum.inr (Γ.reverse e)} : Set (V ⊕ D)),
+      ∀ p : Γ.subdivision.Walk a b, R < p.length := by
+  classical
+  let X := {e : D // label e = label x}
+  let locX : X → V ⊕ D := fun e => .inr e.val
+  let locY : X → V ⊕ D := fun e => .inr (Γ.reverse e.val)
+  have hX : Function.Injective locX := by
+    intro a b h; exact Subtype.ext (Sum.inr.inj h)
+  have hY : Function.Injective locY := by
+    intro a b h
+    exact Subtype.ext (Γ.reverse_reverse.injective (Sum.inr.inj h))
+  let B := ball (graphNeighbors Γ.subdivision) (Sum.inr x) R ∪
+    ball (graphNeighbors Γ.subdivision) (Sum.inr (Γ.reverse x)) R
+  have hB : B.card ≤ 2*d^(R+1) := by
+    have ha := card_ball_le (graphNeighbors Γ.subdivision) d h2
+      (subdivision_degree Γ d h2 hd) (Sum.inr x) R
+    have hb := card_ball_le (graphNeighbors Γ.subdivision) d h2
+      (subdivision_degree Γ d h2 hd) (Sum.inr (Γ.reverse x)) R
+    exact (Finset.card_union_le _ _).trans (by omega)
+  have hbad := matching_bad_card (Equiv.refl X) locX locY hX hY B
+  have hlt : (Finset.univ.filter (fun e : X => locX e ∈ B ∨ locY e ∈ B)).card <
+      Fintype.card X := by
+    rw [Nat.card_eq_fintype_card] at hbig
+    change _ < Fintype.card X at hbig
+    exact lt_of_le_of_lt (hbad.trans (by omega)) hbig
+  obtain ⟨e,he,hebad⟩ := Finset.exists_mem_notMem_of_card_lt_card
+    (s := Finset.univ.filter (fun e : X => locX e ∈ B ∨ locY e ∈ B))
+    (t := (Finset.univ : Finset X)) (by simpa only [Finset.card_univ] using hlt)
+  have he' : locX e ∉ B ∧ locY e ∉ B := by simpa only [Finset.mem_filter,
+    Finset.mem_univ,true_and,not_or] using hebad
+  refine ⟨e.val,e.property,?_⟩
+  intro a ha b hb p
+  have hn : b ∉ ball (graphNeighbors Γ.subdivision) a R := by
+    simp only [Set.mem_insert_iff,Set.mem_singleton_iff] at ha hb
+    rcases ha with rfl | rfl <;> rcases hb with rfl | rfl
+    · exact fun h => he'.1 (Finset.mem_union_left _ h)
+    · exact fun h => he'.2 (Finset.mem_union_left _ h)
+    · exact fun h => he'.1 (Finset.mem_union_right _ h)
+    · exact fun h => he'.2 (Finset.mem_union_right _ h)
+  exact far_of_not_mem_ball Γ.subdivision R hn p
+
+omit [Fintype V] [Fintype D] in
+/-- The conjugation switch is exactly the graph two-switch used in girth repair. -/
+theorem subdivision_switch (Γ : PortGraph V D) (x e : D)
+    (hxe : x ≠ e) (hxr : x ≠ Γ.reverse e) :
+    (Γ.switch x e).subdivision =
+      addEdge (addEdge (Γ.subdivision.deleteEdges
+        {s(Sum.inr x,Sum.inr (Γ.reverse x)),s(Sum.inr e,Sum.inr (Γ.reverse e))})
+        (Sum.inr x) (Sum.inr (Γ.reverse e))) (Sum.inr e) (Sum.inr (Γ.reverse x)) := by
+  ext a b
+  rw [Γ.switch_adj x e hxe hxr]
+  simp only [addEdge_adj,SimpleGraph.deleteEdges_adj,Set.mem_insert_iff,
+    Set.mem_singleton_iff,not_or]
+  have her : e ≠ Γ.reverse x := by
+    intro h
+    apply hxr
+    rw [h,Γ.reverse_reverse]
+  have h1 : s(a,b) = s(Sum.inr x,Sum.inr (Γ.reverse e)) → a ≠ b := by
+    intro h
+    rcases Sym2.eq_iff.mp h with ⟨rfl,rfl⟩ | ⟨rfl,rfl⟩
+    · simpa using hxr
+    · simpa using Ne.symm hxr
+  have h2 : s(a,b) = s(Sum.inr e,Sum.inr (Γ.reverse x)) → a ≠ b := by
+    intro h
+    rcases Sym2.eq_iff.mp h with ⟨rfl,rfl⟩ | ⟨rfl,rfl⟩
+    · simpa using her
+    · simpa using Ne.symm her
+  tauto
+
+end TorsionFreeZeroDivisors.MatchingGraphs
+
+namespace TorsionFreeZeroDivisors.ConditionedMatchings
+open PortSubdivision BallCount GirthSwitch MatchingGraphs
+variable {V D T : Type*}
+
+/-- A matching on the signed labelled port set; inverse labels have no fixed
+points. Keeping the origin function separate fixes the vertex types. -/
+abbrev Matching (label : D → T) (bar : T → T) :=
+  {r : Equiv.Perm D // Function.Involutive r ∧
+    (∀ x, r x ≠ x) ∧ ∀ x, label (r x) = bar (label x)}
+
+namespace Matching
+variable {label : D → T} {bar : T → T}
+instance : CoeFun (Matching label bar) (fun _ => D → D) := ⟨fun r => r.val⟩
+instance [Fintype D] : Fintype (Matching label bar) := by
+  classical
+  unfold Matching
+  infer_instance
+instance : DecidableEq (Matching label bar) := Classical.decEq _
+
+def graph (r : Matching label bar) (origin : D → V) : PortGraph V D :=
+  ⟨origin,r,r.property.1,r.property.2.1⟩
+
+@[simp] theorem reverse_reverse (r : Matching label bar) (x : D) : r (r x) = x := r.property.1 x
+theorem label_reverse (r : Matching label bar) (x : D) :
+    label (r x) = bar (label x) := r.property.2.2 x
+
+@[ext] theorem ext {r s : Matching label bar} (h : ∀ x, r x = s x) : r = s :=
+  Subtype.ext (Equiv.ext h)
+
+variable [DecidableEq D]
+
+/-- Conjugating by the transposition of equally labelled ports. -/
+def switch (r : Matching label bar) (x e : D) (he : label x = label e) : Matching label bar :=
+  ⟨(Equiv.swap x e).trans (r.val.trans (Equiv.swap x e)),by
+    constructor
+    · intro f; simp
+    constructor
+    · intro f h
+      have h' := congrArg (Equiv.swap x e) h
+      simp only [Equiv.trans_apply,Equiv.swap_apply_self] at h'
+      exact r.property.2.1 ((Equiv.swap x e) f) h'
+    · intro f
+      change label ((Equiv.swap x e) (r ((Equiv.swap x e) f))) = bar (label f)
+      rw [PortGraph.label_swap label x e he, r.label_reverse,PortGraph.label_swap label x e he]⟩
+
+@[simp] theorem switch_apply (r : Matching label bar) (x e : D) (he : label x = label e) (f : D) :
+    r.switch x e he f = (Equiv.swap x e) (r ((Equiv.swap x e) f)) := rfl
+
+@[simp] theorem switch_switch (r : Matching label bar) (x e : D) (he : label x = label e) :
+    (r.switch x e he).switch x e he = r := by
+  ext f
+  simp
+
+theorem graph_switch (r : Matching label bar) (origin : D → V)
+    (x e : D) (he : label x = label e) :
+    (r.switch x e he).graph origin = (r.graph origin).switch x e := rfl
+
+/-- Given the new matching and the fixed old pair x,y, the auxiliary port
+is forced. This is the reconstructibility behind the conditional estimate. -/
+theorem switch_recover (r : Matching label bar) (x y e : D)
+    (he : label x = label e) (hxy : r x = y)
+    (hbar : ∀ t, bar t ≠ t) : r.switch x e he y = e := by
+  have hyx : y ≠ x := hxy ▸ r.property.2.1 x
+  have hye : y ≠ e := by
+    intro h
+    have hl := r.label_reverse x
+    rw [hxy,h,← he] at hl
+    exact hbar (label x) hl.symm
+  simp only [switch_apply,Equiv.swap_apply_of_ne_of_ne hyx hye]
+  rw [← hxy,r.reverse_reverse,Equiv.swap_apply_left]
+
+/-- Distinct input-matching/auxiliary-port pairs always give distinct outputs. -/
+theorem switch_injective (x y : D) (hbar : ∀ t, bar t ≠ t) :
+    Function.Injective (fun p : {r : Matching label bar // r x = y} ×
+      {e : D // label x = label e} => p.1.val.switch x p.2.val p.2.property) := by
+  rintro ⟨⟨r,hr⟩,⟨e,he⟩⟩ ⟨⟨s,hs⟩,⟨f,hf⟩⟩ h
+  have hef : e = f := by
+    simpa only [switch_recover r x y e he hr hbar,switch_recover s x y f hf hs hbar]
+      using congrArg (fun r : Matching label bar => r y) h
+  subst f
+  have hrs : r = s := by
+    simpa only [switch_switch] using congrArg (fun r : Matching label bar => r.switch x e he) h
+  subst s
+  rfl
+
+/-- Prior prescriptions are undirected matching edges, counted once. -/
+def Contains (r : Matching label bar) (C : Finset (Sym2 D)) : Prop :=
+  ∀ a b, s(a,b) ∈ C → r a = b
+
+omit [DecidableEq D] in
+/-- A signed label chooses a unique orientation of each matching edge. -/
+theorem edge_name_injective (r : Matching label bar) (x : D)
+    (hbar : ∀ t, bar t ≠ t) :
+    Function.Injective (fun e : {e : D // label e = label x} => s(e.val,r e.val)) := by
+  rintro ⟨e,he⟩ ⟨f,hf⟩ h
+  rcases Sym2.eq_iff.mp h with ⟨hef,_⟩ | ⟨hef,_⟩
+  · exact Subtype.ext hef
+  · have hh := congrArg label hef
+    rw [r.label_reverse,he,hf] at hh
+    exact False.elim (hbar (label x) hh.symm)
+
+/-- Switching two edges disjoint from the prior prescriptions preserves them. -/
+theorem switch_contains (r : Matching label bar) (C : Finset (Sym2 D))
+    (hC : r.Contains C) (x e : D) (he : label x = label e)
+    (hxC : s(x,r x) ∉ C) (heC : s(e,r e) ∉ C) : (r.switch x e he).Contains C := by
+  intro a b hab
+  have hr := hC a b hab
+  have hax : a ≠ x := by intro h; subst a; exact hxC (hr ▸ hab)
+  have hae : a ≠ e := by intro h; subst a; exact heC (hr ▸ hab)
+  have hbx : b ≠ x := by
+    intro h
+    have hra : r x = a := by rw [← h,← hr,r.reverse_reverse]
+    exact hxC (by simpa only [hra,h,Sym2.eq_swap] using hab)
+  have hbe : b ≠ e := by
+    intro h
+    have hra : r e = a := by rw [← h,← hr,r.reverse_reverse]
+    exact heC (by simpa only [hra,h,Sym2.eq_swap] using hab)
+  simp only [switch_apply,Equiv.swap_apply_of_ne_of_ne hax hae,hr,
+    Equiv.swap_apply_of_ne_of_ne hbx hbe]
+
+variable [Fintype V] [Fintype D]
+
+/-- All allowed transpositions for the distinguished port, omitting prior
+edges and both radius-R endpoint balls. -/
+def admissible (r : Matching label bar) (origin : D → V) (x : D)
+    (R : ℕ) (C : Finset (Sym2 D)) : Finset {e : D // label e = label x} := by
+  classical
+  let Γ := r.graph origin
+  let B := ball (graphNeighbors Γ.subdivision) (Sum.inr x) R ∪
+    ball (graphNeighbors Γ.subdivision) (Sum.inr (r x)) R
+  exact Finset.univ.filter fun e => s(e.val,r e.val) ∉ C ∧
+    Sum.inr e.val ∉ B ∧ Sum.inr (r e.val) ∉ B
+
+/-- The excluded prior set costs exactly one port per prior edge, not two. -/
+theorem admissible_card (r : Matching label bar) (origin : D → V)
+    (hbar : ∀ t, bar t ≠ t) (d : ℕ) (h2 : 2 ≤ d)
+    (hd : ∀ v, Nat.card {e : D // origin e = v} ≤ d)
+    (x : D) (R : ℕ) (C : Finset (Sym2 D)) :
+    Nat.card {e : D // label e = label x} - C.card - 4*d^(R+1) ≤
+      (r.admissible origin x R C).card := by
+  classical
+  let X := {e : D // label e = label x}
+  let P : Finset X := Finset.univ.filter fun e => s(e.val,r e.val) ∈ C
+  have hP : P.card ≤ C.card := by
+    apply Finset.card_le_card_of_injOn (fun e : X => s(e.val,r e.val))
+    · intro e he; exact (Finset.mem_filter.mp he).2
+    · exact (r.edge_name_injective x hbar).injOn
+  have hbound := BallCount.admissible_card (Equiv.refl X)
+    (fun e : X => (Sum.inr e.val : V ⊕ D)) (fun e : X => (Sum.inr (r e.val) : V ⊕ D))
+    (by intro a b h; exact Subtype.ext (Sum.inr.inj h))
+    (by intro a b h; exact Subtype.ext (r.val.injective (Sum.inr.inj h)))
+    (graphNeighbors (r.graph origin).subdivision) d h2
+    (subdivision_degree (r.graph origin) d h2 hd) (Sum.inr x) (Sum.inr (r x)) R P
+  have ht : Fintype.card X - P.card - 4*d^(R+1) ≤
+      (r.admissible origin x R C).card := by
+    convert hbound using 1
+    congr 1
+    ext e
+    simp [admissible,P]
+  rw [Nat.card_eq_fintype_card]
+  exact (Nat.sub_le_sub_right (Nat.sub_le_sub_left hP _) _).trans ht
+
+/-- The girth condition is preserved by each counted auxiliary port. -/
+theorem admissible_preserves (r : Matching label bar) (origin : D → V)
+    (x : D) (N : ℕ) (C : Finset (Sym2 D))
+    (hC : r.Contains C) (hxC : s(x,r x) ∉ C)
+    (hg : (N : ℕ∞) ≤ (r.graph origin).subdivision.egirth)
+    (e : {e : D // label e = label x}) (he : e ∈ r.admissible origin x (2*N) C) :
+    (r.switch x e.val e.property.symm).Contains C ∧
+      (N : ℕ∞) ≤ ((r.switch x e.val e.property.symm).graph origin).subdivision.egirth := by
+  classical
+  have he' := Finset.mem_filter.mp he |>.2
+  change s(e.val,r e.val) ∉ C ∧ _ at he'
+  have hfar : ∀ a ∈ ({Sum.inr x,Sum.inr (r x)} : Set (V ⊕ D)),
+      ∀ b ∈ ({Sum.inr e.val,Sum.inr (r e.val)} : Set (V ⊕ D)),
+      ∀ p : (r.graph origin).subdivision.Walk a b, 2*N < p.length := by
+    intro a ha b hb p
+    apply far_of_not_mem_ball (r.graph origin).subdivision (2*N) _ p
+    simp only [Set.mem_insert_iff,Set.mem_singleton_iff] at ha hb
+    rcases ha with rfl | rfl <;> rcases hb with rfl | rfl
+    · exact fun h => he'.2.1 (Finset.mem_union_left _ h)
+    · exact fun h => he'.2.2 (Finset.mem_union_left _ h)
+    · exact fun h => he'.2.1 (Finset.mem_union_right _ h)
+    · exact fun h => he'.2.2 (Finset.mem_union_right _ h)
+  have far_ne {a b : V ⊕ D}
+      (hf : ∀ p : (r.graph origin).subdivision.Walk a b, 2*N < p.length) : a ≠ b := by
+    intro h
+    subst b
+    have hh := hf SimpleGraph.Walk.nil
+    simp at hh
+  have hxe : x ≠ e.val := by
+    intro h
+    exact far_ne (hfar (.inr x) (by simp) (.inr e.val) (by simp)) (congrArg Sum.inr h)
+  have hxr : x ≠ r e.val := by
+    intro h
+    exact far_ne (hfar (.inr x) (by simp) (.inr (r e.val)) (by simp)) (congrArg Sum.inr h)
+  refine ⟨r.switch_contains C hC x e.val e.property.symm hxC he'.1,?_⟩
+  rw [graph_switch,subdivision_switch (r.graph origin) x e.val hxe hxr]
+  exact girth_switch N hg rfl hfar
+
+/-- The exact finite space conditioned on girth and prior prescriptions. -/
+def conditioned (origin : D → V) (N : ℕ) (C : Finset (Sym2 D)) :
+    Finset (Matching label bar) := by
+  classical
+  exact Finset.univ.filter fun r => r.Contains C ∧
+    (N : ℕ∞) ≤ (r.graph origin).subdivision.egirth
+
+/-- Direct double counting on the whole tuple space, with all other matchings
+retained in the output. No independence after conditioning is used. -/
+theorem conditioned_count (origin : D → V) (N : ℕ) (C : Finset (Sym2 D))
+    (hbar : ∀ t, bar t ≠ t) (d : ℕ) (h2 : 2 ≤ d)
+    (hd : ∀ v, Nat.card {e : D // origin e = v} ≤ d)
+    (x y : D) (hxy : s(x,y) ∉ C) :
+    ((conditioned (label := label) (bar := bar) origin N C).filter (fun r => r x = y)).card *
+      (Nat.card {e : D // label e = label x} - C.card - 4*d^(2*N+1)) ≤
+      (conditioned (label := label) (bar := bar) origin N C).card := by
+  classical
+  let Ω := conditioned (label := label) (bar := bar) origin N C
+  let r₀ := Nat.card {e : D // label e = label x} - C.card - 4*d^(2*N+1)
+  let F := {r : Matching label bar // r ∈ Ω ∧ r x = y}
+  let S := (r : F) × {e : {e : D // label e = label x} //
+    e ∈ r.val.admissible origin x (2*N) C}
+  have hm (r : F) : r.val.Contains C ∧
+      (N : ℕ∞) ≤ (r.val.graph origin).subdivision.egirth := by
+    have h := r.property.1
+    simpa only [Ω,conditioned,Finset.mem_filter,Finset.mem_univ,true_and] using h
+  let out : S → {r : Matching label bar // r ∈ Ω} := fun p =>
+    ⟨p.1.val.switch x p.2.val.val p.2.val.property.symm,by
+      have hh := p.1.val.admissible_preserves origin x N C (hm p.1).1
+        (by simpa only [p.1.property.2] using hxy) (hm p.1).2 p.2.val p.2.property
+      simpa only [Ω,conditioned,Finset.mem_filter,Finset.mem_univ,true_and] using hh⟩
+  have hout : Function.Injective out := by
+    intro p q h
+    have hs : p.1.val.switch x p.2.val.val p.2.val.property.symm =
+        q.1.val.switch x q.2.val.val q.2.val.property.symm := congrArg Subtype.val h
+    have hi := switch_injective (label := label) (bar := bar) x y hbar
+      (a₁ := (⟨p.1.val,p.1.property.2⟩,⟨p.2.val.val,p.2.val.property.symm⟩))
+      (a₂ := (⟨q.1.val,q.1.property.2⟩,⟨q.2.val.val,q.2.val.property.symm⟩)) hs
+    have hr : p.1 = q.1 := Subtype.ext (congrArg (fun z => z.1.val) hi)
+    cases p with
+    | mk r e =>
+      cases q with
+      | mk s f =>
+        dsimp at hr
+        subst s
+        have hef : e = f := Subtype.ext (Subtype.ext (congrArg (fun z => z.2.val) hi))
+        subst f
+        rfl
+  have hc := Fintype.card_le_of_injective out hout
+  have hsource : Fintype.card S = ∑ r : F, (r.val.admissible origin x (2*N) C).card := by
+    simp only [S,Fintype.card_sigma,Fintype.card_coe]
+  have htarget : Fintype.card {r : Matching label bar // r ∈ Ω} = Ω.card := Fintype.card_coe Ω
+  have hF : Fintype.card F = (Ω.filter (fun r => r x = y)).card := by
+    change Fintype.card {r : Matching label bar // r ∈ Ω ∧ r x = y} = _
+    rw [Fintype.card_subtype]
+    congr 1
+    ext r
+    simp
+  have hsum : Fintype.card F * r₀ ≤ ∑ r : F, (r.val.admissible origin x (2*N) C).card := by
+    calc
+      Fintype.card F * r₀ = ∑ _r : F, r₀ := by simp
+      _ ≤ ∑ r : F, (r.val.admissible origin x (2*N) C).card :=
+        Finset.sum_le_sum fun r _ => r.val.admissible_card origin hbar d h2 hd x (2*N) C
+  rw [hsource,htarget] at hc
+  rw [hF] at hsum
+  exact hsum.trans hc
+
+omit [Fintype D] in
+/-- Adding one undirected prescription is exactly one matching-coordinate
+condition; the reverse orientation is automatic, not an extra constraint. -/
+theorem contains_insert (r : Matching label bar) (C : Finset (Sym2 D)) (x y : D) :
+    r.Contains (insert s(x,y) C) ↔ r.Contains C ∧ r x = y := by
+  classical
+  constructor
+  · intro h
+    exact ⟨fun a b hab => h a b (Finset.mem_insert_of_mem hab),h x y (by simp)⟩
+  · rintro ⟨hC,hxy⟩ a b hab
+    rcases Finset.mem_insert.mp hab with h | h
+    · rcases Sym2.eq_iff.mp h with ⟨rfl,rfl⟩ | ⟨rfl,rfl⟩
+      · exact hxy
+      · rw [← hxy,r.reverse_reverse]
+    · exact hC a b h
+
+omit [Fintype V] in
+theorem conditioned_insert (origin : D → V) (N : ℕ) (C : Finset (Sym2 D))
+    (x y : D) :
+    conditioned (label := label) (bar := bar) origin N (insert s(x,y) C) =
+      (conditioned (label := label) (bar := bar) origin N C).filter (fun r => r x = y) := by
+  classical
+  ext r
+  simp only [conditioned,Finset.mem_filter,Finset.mem_univ,true_and,contains_insert]
+  tauto
+
+/-- The simultaneous-prescription bound obtained by successive conditioning.
+No independence is asserted, even for prescriptions on distinct labels. -/
+theorem prescriptions_count (origin : D → V) (N : ℕ)
+    (hbar : ∀ t, bar t ≠ t) (d : ℕ) (h2 : 2 ≤ d)
+    (hd : ∀ v, Nat.card {e : D // origin e = v} ≤ d)
+    (R : ℕ) (C : Finset (Sym2 D))
+    (hR : ∀ x, R + C.card + 4*d^(2*N+1) ≤ Nat.card {e : D // label e = label x}) :
+    (conditioned (label := label) (bar := bar) origin N C).card * R^C.card ≤
+      (conditioned (label := label) (bar := bar) origin N ∅).card := by
+  classical
+  induction C using Finset.induction with
+  | empty => simp
+  | @insert e C he ih =>
+    induction e using Sym2.inductionOn with
+    | hf x y =>
+      have hR' : ∀ z, R + C.card + 4*d^(2*N+1) ≤
+          Nat.card {e : D // label e = label z} := by
+        intro z
+        have hh := hR z
+        rw [Finset.card_insert_of_notMem he] at hh
+        omega
+      have hstep := conditioned_count (label := label) (bar := bar)
+        origin N C hbar d h2 hd x y he
+      have hsmall : R ≤ Nat.card {e : D // label e = label x} - C.card - 4*d^(2*N+1) := by
+        have := hR' x
+        omega
+      have hstep' : (conditioned (label := label) (bar := bar) origin N (insert s(x,y) C)).card * R ≤
+          (conditioned (label := label) (bar := bar) origin N C).card := by
+        rw [conditioned_insert]
+        exact (Nat.mul_le_mul_left _ hsmall).trans hstep
+      rw [Finset.card_insert_of_notMem he,pow_succ,← mul_assoc,mul_right_comm]
+      exact (Nat.mul_le_mul_right _ hstep').trans (ih hR')
+
+/-- The uniform one-prescription bound for the actual girth-conditioned model. -/
+theorem conditioned_probability (origin : D → V) (N : ℕ) (C : Finset (Sym2 D))
+    (hbar : ∀ t, bar t ≠ t) (d : ℕ) (h2 : 2 ≤ d)
+    (hd : ∀ v, Nat.card {e : D // origin e = v} ≤ d)
+    (x y : D) (hxy : s(x,y) ∉ C)
+    (hΩ : (conditioned (label := label) (bar := bar) origin N C).Nonempty)
+    (hr : 0 < Nat.card {e : D // label e = label x} - C.card - 4*d^(2*N+1)) :
+    (((conditioned (label := label) (bar := bar) origin N C).filter (fun r => r x = y)).card : ℝ) /
+        (conditioned (label := label) (bar := bar) origin N C).card ≤
+      1 / (Nat.card {e : D // label e = label x} - C.card - 4*d^(2*N+1) : ℕ) := by
+  have hc := conditioned_count (label := label) (bar := bar) origin N C hbar d h2 hd x y hxy
+  have hc' : (((conditioned (label := label) (bar := bar) origin N C).filter
+      (fun r => r x = y)).card : ℝ) *
+      (Nat.card {e : D // label e = label x} - C.card - 4*d^(2*N+1) : ℕ) ≤
+      (conditioned (label := label) (bar := bar) origin N C).card := by exact_mod_cast hc
+  have hΩ' : (0 : ℝ) < (conditioned (label := label) (bar := bar) origin N C).card :=
+    Nat.cast_pos.mpr (Finset.card_pos.mpr hΩ)
+  have hr' : (0 : ℝ) < (Nat.card {e : D // label e = label x} - C.card - 4*d^(2*N+1) : ℕ) :=
+    Nat.cast_pos.mpr hr
+  apply (div_le_iff₀ hΩ').mpr
+  rw [div_mul_eq_mul_div,one_mul]
+  exact (le_div_iff₀ hr').mpr hc'
+
+end Matching
+end TorsionFreeZeroDivisors.ConditionedMatchings
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/GroupRing/Milnor.lean b/lean/OAI/Algebra/GroupRing/Milnor.lean
new file mode 100644
index 0000000000000000000000000000000000000000..430b90a6173b1aab82294e4d636da14dc0591b4f
--- /dev/null
+++ b/lean/OAI/Algebra/GroupRing/Milnor.lean
@@ -0,0 +1,470 @@
+import Mathlib
+import OAI.Algebra.GroupRing.PartialLift
+
+namespace OAI
+
+noncomputable section
+
+open Set Metric Topology BigOperators
+open Set Metric Topology
+
+namespace GroupRingTopology.Milnor
+
+section
+open Set Metric Topology BigOperators GroupRingTopology.Simplicial
+open scoped Classical unitInterval
+universe u v
+variable {G : Type u}
+local instance (priority := 2000) (α : Type*) : DecidableEq (ℕ × α) := Classical.decEq (ℕ × α)
+
+def boundedInclusion (N : ℕ) : C(Simplicial.Space (bounded G N),Space G) :=
+  ⟨Simplicial.inclusion (bounded G N) (complex G) (fun _ h => bounded_le G N h),
+    Simplicial.continuous_inclusion _ _ _⟩
+
+def boundedContraction (N : ℕ) (g : G) :
+    (boundedInclusion (G := G) N).Homotopy (ContinuousMap.const _ (vertex (N,g))) := by
+  let H := Simplicial.straightHomotopy (bounded G N) (complex G) id (fun _ => (N,g))
+    (bounded_id_face N) (bounded_const_face N g) (bounded_contiguous N g)
+  exact H.cast (ContinuousMap.ext (fun x => bounded_map_id N x))
+    (ContinuousMap.ext (fun x => map_const_vertex (bounded G N) (N,g) (bounded_const_face N g) x))
+
+lemma compactMap_bounded {A : Type v} [TopologicalSpace A] [CompactSpace A] (f : C(A,Space G)) :
+    ∃ N : ℕ, ∃ F : C(A,Simplicial.Space (bounded G N)), (boundedInclusion N).comp F = f := by
+  obtain ⟨S,hS⟩ := Simplicial.compact_bounded_vertices (complex G) (isCompact_range f.continuous)
+  let N := S.sup Prod.fst + 1
+  have hN (a : A) (v : ℕ × G) (hv : v ∈ (f a).1.support) : v.1 < N := by
+    exact Nat.lt_succ_of_le (Finset.le_sup (f := Prod.fst) (hS (f a) (mem_range_self a) hv))
+  let F : A → Simplicial.Space (bounded G N) := fun a =>
+    ⟨(f a).1,(f a).2.1,(f a).2.2.1,(f a).2.2.2,hN a⟩
+  have hc : Continuous F :=
+    (Simplicial.inclusion_closedEmbedding (bounded G N) (complex G)
+      (fun _ h => bounded_le G N h)).isEmbedding.continuous_iff.mpr f.continuous
+  exact ⟨N,⟨F,hc⟩,rfl⟩
+
+lemma compactMap_nullhomotopic {A : Type v} [TopologicalSpace A] [CompactSpace A]
+    (g : G) (f : C(A,Space G)) : ∃ y, Nonempty (f.Homotopy (ContinuousMap.const _ y)) := by
+  obtain ⟨N,F,hF⟩ := compactMap_bounded f
+  exact ⟨vertex (N,g),⟨((boundedContraction N g).compContinuousMap F).cast hF rfl⟩⟩
+
+lemma sphereFillable (g : G) : Cellular.SphereFillable (Space G) := by
+  intro n f
+  cases n with
+  | zero =>
+    refine ⟨ContinuousMap.const _ (vertex (0,g)),?_⟩
+    intro x
+    have hx : False := by
+      have he := x.2
+      simp only [Metric.mem_sphere,Subsingleton.elim x.1 0,dist_self] at he
+      exact zero_ne_one he
+    exact hx.elim
+  | succ n =>
+    let := SphereTopology.sphere_nonempty n
+    obtain ⟨y,⟨H⟩⟩ := compactMap_nullhomotopic g f
+    obtain ⟨F,hF⟩ := SphereTopology.extends_of_nullhomotopic H.symm
+    exact ⟨F,fun x => ContinuousMap.congr_fun hF x⟩
+
+lemma contractible [Nonempty G] : ContractibleSpace (Space G) := by
+  let g : G := Classical.choice ‹Nonempty G›
+  let : Nonempty (Space G) := ⟨vertex (0,g)⟩
+  exact Cellular.contractible_of_sphereFillable (sphereFillable g)
+
+end
+
+section
+open Set Metric Topology BigOperators GroupRingTopology.Simplicial
+open scoped Classical
+universe u v
+variable {G : Type u} [Group G]
+local instance (priority := 2000) (α : Type*) : DecidableEq (ℕ × α) := Classical.decEq (ℕ × α)
+
+def translate (g : G) (s : Finset (ℕ × G)) : Finset (ℕ × G) := s.image (fun v => (v.1,g*v.2))
+
+lemma translate_one (s : Finset (ℕ × G)) : translate 1 s = s := by
+  simp only [translate,one_mul,Prod.mk.eta,Finset.image_id']
+lemma translate_mul (g h : G) (s : Finset (ℕ × G)) : translate g (translate h s) = translate (g*h) s := by
+  simp only [translate,Finset.image_image,Function.comp_def,mul_assoc]
+lemma translate_mono (g : G) {s t : Finset (ℕ × G)} (h : s ⊆ t) : translate g s ⊆ translate g t :=
+  Finset.image_subset_image h
+lemma translate_valid (g : G) {s : Finset (ℕ × G)} (hs : s ∈ complex G) : translate g s ∈ complex G :=
+  map_face (g * ·) id Function.injective_id ⟨s,hs⟩
+
+def orbitSpan (S : Finset (Finset (ℕ × G))) : PreAbstractSimplicialComplex (ℕ × G) where
+  faces := {t | t ∈ complex G ∧ ∃ g : G, ∃ s ∈ S, t ⊆ translate g s}
+  isRelLowerSet_faces := by
+    intro t ht
+    refine ⟨ht.1.1,?_⟩
+    intro u hut hu
+    obtain ⟨g,s,hs,hts⟩ := ht.2
+    exact ⟨(complex G).isRelLowerSet_faces.mem_of_le ht.1 hut hu,g,s,hs,hut.trans hts⟩
+
+lemma orbitSpan_le (S : Finset (Finset (ℕ × G))) : orbitSpan S ≤ complex G := fun _ h => h.1
+lemma orbitSpan_mono {S T : Finset (Finset (ℕ × G))} (h : S ⊆ T) : orbitSpan S ≤ orbitSpan T := by
+  intro t ht
+  obtain ⟨g,s,hs,hts⟩ := ht.2
+  exact ⟨ht.1,g,s,h hs,hts⟩
+lemma orbitSpan_contains (S : Finset (Finset (ℕ × G))) {t : Finset (ℕ × G)}
+    (ht : t ∈ complex G) (h : ∃ s ∈ S, t ⊆ s) : t ∈ orbitSpan S := by
+  obtain ⟨s,hs,hts⟩ := h
+  exact ⟨ht,1,s,hs,by rwa [translate_one]⟩
+lemma orbitSpan_invariant (S : Finset (Finset (ℕ × G))) (g : G)
+    {t : Finset (ℕ × G)} (ht : t ∈ orbitSpan S) : translate g t ∈ orbitSpan S := by
+  obtain ⟨h,s,hs,hts⟩ := ht.2
+  exact ⟨translate_valid g ht.1,g*h,s,hs,by rw [←translate_mul]; exact translate_mono g hts⟩
+
+lemma orbitSpan_bounded (S : Finset (Finset (ℕ × G))) :
+    orbitSpan S ≤ bounded G ((S.biUnion id).sup Prod.fst + 1) := by
+  intro t ht
+  refine ⟨ht.1,?_⟩
+  intro v hv
+  obtain ⟨g,s,hs,hts⟩ := ht.2
+  obtain ⟨w,hw,rfl⟩ := Finset.mem_image.mp (hts hv)
+  have hh : w.1 ≤ (S.biUnion id).sup Prod.fst := Finset.le_sup (f := Prod.fst) (Finset.mem_biUnion.mpr ⟨s,hs,hw⟩)
+  exact Nat.lt_succ_of_le hh
+
+/-- Uniform finite orbit control, not compactness of the infinite free orbit. -/
+def Controlled (K : PreAbstractSimplicialComplex (ℕ × G)) : Prop :=
+  ∃ S : Finset (Finset (ℕ × G)), K ≤ orbitSpan S
+
+lemma controlled_orbitSpan (S : Finset (Finset (ℕ × G))) : Controlled (orbitSpan S) := ⟨S,le_rfl⟩
+lemma controlled_bounded {K : PreAbstractSimplicialComplex (ℕ × G)} (hK : Controlled K) :
+    ∃ N, K ≤ bounded G N := by
+  obtain ⟨S,hS⟩ := hK
+  exact ⟨_,hS.trans (orbitSpan_bounded S)⟩
+
+lemma orbitSpan_finite_representatives (S : Finset (Finset (ℕ × G))) :
+    ∃ T : Finset (Finset (ℕ × G)), ∀ t ∈ orbitSpan S, ∃ s ∈ T, ∃ g : G, t = translate g s := by
+  refine ⟨S.biUnion Finset.powerset,?_⟩
+  intro t ht
+  obtain ⟨g,s,hs,hts⟩ := ht.2
+  have hh : translate g⁻¹ t ⊆ s := by
+    have hh := translate_mono g⁻¹ hts
+    simpa only [translate_mul,inv_mul_cancel,translate_one] using hh
+  refine ⟨translate g⁻¹ t,Finset.mem_biUnion.mpr ⟨s,hs,Finset.mem_powerset.mpr hh⟩,g,?_⟩
+  rw [translate_mul,mul_inv_cancel,translate_one]
+
+end
+section
+open Set Metric Topology BigOperators GroupRingTopology.Simplicial
+open scoped Classical
+universe u v
+variable {G : Type u} {H : Type v} [Group G] [Group H]
+local instance (priority := 2000) (α : Type*) : DecidableEq (ℕ × α) := Classical.decEq (ℕ × α)
+
+def vertexMap (φ : G →* H) (α : ℕ → ℕ) : ℕ × G → ℕ × H := fun v => (α v.1,φ v.2)
+def faceImage (φ : G →* H) (α : ℕ → ℕ) (s : Finset (ℕ × G)) : Finset (ℕ × H) := s.image (vertexMap φ α)
+def imageShapes (φ : G →* H) (α : ℕ → ℕ) (S : Finset (Finset (ℕ × G))) : Finset (Finset (ℕ × H)) := S.image (faceImage φ α)
+
+lemma faceImage_translate (φ : G →* H) (α : ℕ → ℕ) (a : G) (s : Finset (ℕ × G)) :
+    faceImage φ α (translate a s) = translate (φ a) (faceImage φ α s) := by
+  simp only [faceImage,translate,Finset.image_image,vertexMap,Function.comp_def,map_mul]
+
+lemma faceImage_valid (φ : G →* H) (α : ℕ → ℕ) (hα : Function.Injective α)
+    {s : Finset (ℕ × G)} (hs : s ∈ complex G) : faceImage φ α s ∈ complex H :=
+  map_face φ α hα ⟨s,hs⟩
+
+lemma faceImage_controlled (φ : G →* H) (α : ℕ → ℕ) (hα : Function.Injective α)
+    (S : Finset (Finset (ℕ × G))) (s : Face (orbitSpan S)) :
+    faceImage φ α s.1 ∈ orbitSpan (imageShapes φ α S) := by
+  obtain ⟨a,t,ht,hst⟩ := s.2.2
+  refine ⟨faceImage_valid φ α hα s.2.1,φ a,faceImage φ α t,
+    Finset.mem_image.mpr ⟨t,ht,rfl⟩,?_⟩
+  rw [← faceImage_translate]
+  exact Finset.image_subset_image hst
+
+lemma unionFace_valid (φ : G →* H) (α β : ℕ → ℕ)
+    (hα : Function.Injective α) (hβ : Function.Injective β)
+    {s : Finset (ℕ × G)} (hs : s ∈ complex G)
+    (hc : ∀ v ∈ s, ∀ w ∈ s, α v.1 = β w.1 → v.1 = w.1) :
+    faceImage φ α s ∪ faceImage φ β s ∈ complex H := by
+  refine ⟨(faceImage_valid φ α hα hs).1.mono Finset.subset_union_left,?_⟩
+  intro x hx y hy hxy
+  rcases Finset.mem_union.mp hx with hx | hx <;> rcases Finset.mem_union.mp hy with hy | hy
+  · exact (faceImage_valid φ α hα hs).2 hx hy hxy
+  · obtain ⟨v,hv,rfl⟩ := Finset.mem_image.mp hx
+    obtain ⟨w,hw,rfl⟩ := Finset.mem_image.mp hy
+    have hvw : v = w := hs.2 hv hw (hc v hv w hw hxy)
+    subst w
+    apply Prod.ext
+    · exact hxy
+    · rfl
+  · obtain ⟨v,hv,rfl⟩ := Finset.mem_image.mp hx
+    obtain ⟨w,hw,rfl⟩ := Finset.mem_image.mp hy
+    have hvw : w = v := hs.2 hw hv (hc w hw v hv hxy.symm)
+    subst w
+    apply Prod.ext
+    · exact hxy
+    · rfl
+  · exact (faceImage_valid φ β hβ hs).2 hx hy hxy
+
+def unionShapes (φ : G →* H) (α β : ℕ → ℕ) (S : Finset (Finset (ℕ × G))) :
+    Finset (Finset (ℕ × H)) := S.image (fun s => faceImage φ α s ∪ faceImage φ β s)
+
+lemma translate_union (a : H) (s t : Finset (ℕ × H)) : translate a (s ∪ t) = translate a s ∪ translate a t :=
+  Finset.image_union _ _
+
+lemma unionFace_controlled (φ : G →* H) (α β : ℕ → ℕ)
+    (hα : Function.Injective α) (hβ : Function.Injective β)
+    (S : Finset (Finset (ℕ × G))) (s : Face (orbitSpan S))
+    (hc : ∀ v ∈ s.1, ∀ w ∈ s.1, α v.1 = β w.1 → v.1 = w.1) :
+    faceImage φ α s.1 ∪ faceImage φ β s.1 ∈ orbitSpan (unionShapes φ α β S) := by
+  obtain ⟨a,t,ht,hst⟩ := s.2.2
+  refine ⟨unionFace_valid φ α β hα hβ s.2.1 hc,φ a,faceImage φ α t ∪ faceImage φ β t,
+    Finset.mem_image.mpr ⟨t,ht,rfl⟩,?_⟩
+  rw [translate_union,←faceImage_translate,←faceImage_translate]
+  exact Finset.union_subset_union (Finset.image_subset_image hst) (Finset.image_subset_image hst)
+
+/-- A fresh relayer fixes layer zero, so the ensuing straight homotopies are
+based. Positive layers move above every old layer under consideration. -/
+def fresh (N : ℕ) (i : ℕ) : ℕ := if i = 0 then 0 else N+i
+lemma fresh_zero (N : ℕ) : fresh N 0 = 0 := by simp [fresh]
+lemma fresh_injective (N : ℕ) : Function.Injective (fresh N) := by
+  intro i j h
+  unfold fresh at h
+  split_ifs at h with hi hj hj
+  · exact hi.trans hj.symm
+  · exfalso; omega
+  · exfalso; omega
+  · omega
+
+lemma fresh_cross (N : ℕ) (α : ℕ → ℕ) (hα : Function.Injective α) (hzero : α 0 = 0)
+    {i j : ℕ} (hi : α i < N) (h : α i = fresh N j) : i = j := by
+  by_cases hj : j = 0
+  · subst j
+    apply hα
+    simpa only [fresh_zero,hzero] using h
+  · have hh : N ≤ fresh N j := by simp only [fresh,ite_eq_right hj]; exact Nat.le_add_right _ _
+    omega
+end
+open Set Metric Topology BigOperators GroupRingTopology.Simplicial
+open scoped Classical unitInterval
+universe u v
+variable {G : Type u} {H : Type v} [Group G] [Group H]
+local instance (priority := 2000) (α : Type*) : DecidableEq (ℕ × α) := Classical.decEq (ℕ × α)
+
+def shapeBound (S : Finset (Finset (ℕ × G))) (α : ℕ → ℕ) : ℕ :=
+  (S.biUnion id).sup (fun v => α v.1) + 1
+lemma orbit_below_bound (S : Finset (Finset (ℕ × G))) (α : ℕ → ℕ)
+    (s : Face (orbitSpan S)) {v : ℕ × G} (hv : v ∈ s.1) : α v.1 < shapeBound S α := by
+  obtain ⟨a,t,ht,hst⟩ := s.2.2
+  obtain ⟨w,hw,rfl⟩ := Finset.mem_image.mp (hst hv)
+  have hh : α w.1 ≤ (S.biUnion id).sup (fun v => α v.1) :=
+    Finset.le_sup (f := fun v : ℕ × G => α v.1) (Finset.mem_biUnion.mpr ⟨t,ht,hw⟩)
+  exact Nat.lt_succ_of_le hh
+
+def relayerFresh (S : Finset (Finset (ℕ × G))) (α β : ℕ → ℕ) : ℕ → ℕ :=
+  fresh (max (shapeBound S α) (shapeBound S β))
+def relayerTarget (φ : G →* H) (S : Finset (Finset (ℕ × G))) (α β : ℕ → ℕ) :=
+  unionShapes φ α (relayerFresh S α β) S ∪ unionShapes φ β (relayerFresh S α β) S
+
+lemma relayerLeftValid (φ : G →* H) (S : Finset (Finset (ℕ × G)))
+    (α β : ℕ → ℕ) (hα : Function.Injective α) (hα0 : α 0 = 0) (s : Face (orbitSpan S)) :
+    faceImage φ α s.1 ∪ faceImage φ (relayerFresh S α β) s.1 ∈ orbitSpan (relayerTarget φ S α β) := by
+  apply orbitSpan_mono Finset.subset_union_left
+  apply unionFace_controlled φ α (relayerFresh S α β) hα (fresh_injective _) S s
+  intro v hv w _ h
+  exact fresh_cross _ α hα hα0 ((orbit_below_bound S α s hv).trans_le (le_max_left _ _)) h
+
+lemma relayerRightValid (φ : G →* H) (S : Finset (Finset (ℕ × G)))
+    (α β : ℕ → ℕ) (hβ : Function.Injective β) (hβ0 : β 0 = 0) (s : Face (orbitSpan S)) :
+    faceImage φ β s.1 ∪ faceImage φ (relayerFresh S α β) s.1 ∈ orbitSpan (relayerTarget φ S α β) := by
+  apply orbitSpan_mono Finset.subset_union_right
+  apply unionFace_controlled φ β (relayerFresh S α β) hβ (fresh_injective _) S s
+  intro v hv w _ h
+  exact fresh_cross _ β hβ hβ0 ((orbit_below_bound S β s hv).trans_le (le_max_right _ _)) h
+
+variable (φ : G →* H) (S : Finset (Finset (ℕ × G))) (α β : ℕ → ℕ)
+variable (hα : Function.Injective α) (hβ : Function.Injective β) (hα0 : α 0 = 0) (hβ0 : β 0 = 0)
+include hα hα0 in
+lemma relayerLeftMapValid (s : Face (orbitSpan S)) :
+    s.1.image (vertexMap φ α) ∈ orbitSpan (relayerTarget φ S α β) :=
+  (orbitSpan _).isRelLowerSet_faces.mem_of_le (relayerLeftValid φ S α β hα hα0 s)
+    Finset.subset_union_left (s.2.1.1.image _)
+include hβ hβ0 in
+lemma relayerRightMapValid (s : Face (orbitSpan S)) :
+    s.1.image (vertexMap φ β) ∈ orbitSpan (relayerTarget φ S α β) :=
+  (orbitSpan _).isRelLowerSet_faces.mem_of_le (relayerRightValid φ S α β hβ hβ0 s)
+    Finset.subset_union_left (s.2.1.1.image _)
+include hα hα0 in
+lemma relayerFreshMapValid (s : Face (orbitSpan S)) :
+    s.1.image (vertexMap φ (relayerFresh S α β)) ∈ orbitSpan (relayerTarget φ S α β) :=
+  (orbitSpan _).isRelLowerSet_faces.mem_of_le (relayerLeftValid φ S α β hα hα0 s)
+    Finset.subset_union_right (s.2.1.1.image _)
+
+def relayerLeftMap := mapC (orbitSpan S) (orbitSpan (relayerTarget φ S α β))
+  (vertexMap φ α) (relayerLeftMapValid φ S α β hα hα0)
+def relayerRightMap := mapC (orbitSpan S) (orbitSpan (relayerTarget φ S α β))
+  (vertexMap φ β) (relayerRightMapValid φ S α β hβ hβ0)
+def relayerFreshMap := mapC (orbitSpan S) (orbitSpan (relayerTarget φ S α β))
+  (vertexMap φ (relayerFresh S α β)) (relayerFreshMapValid φ S α β hα hα0)
+
+def relayerLeftHomotopy : (relayerLeftMap φ S α β hα hα0).Homotopy (relayerFreshMap φ S α β hα hα0) :=
+  straightHomotopy _ _ _ _ _ _ (relayerLeftValid φ S α β hα hα0)
+def relayerRightHomotopy : (relayerRightMap φ S α β hβ hβ0).Homotopy (relayerFreshMap φ S α β hα hα0) :=
+  straightHomotopy _ _ _ _ _ _ (relayerRightValid φ S α β hβ hβ0)
+
+def relayerHomotopy : (relayerLeftMap φ S α β hα hα0).Homotopy (relayerRightMap φ S α β hβ hβ0) :=
+  (relayerLeftHomotopy φ S α β hα hα0).trans (relayerRightHomotopy φ S α β hα hβ hα0 hβ0).symm
+
+lemma relayerLeftPure (x : Simplicial.Space (orbitSpan S)) (g : G) (hx : x.1 = Finsupp.single (0,g) 1) :
+    relayerLeftMap φ S α β hα hα0 x = relayerFreshMap φ S α β hα hα0 x := by
+  apply Subtype.ext
+  change x.1.mapDomain (vertexMap φ α) = x.1.mapDomain (vertexMap φ (relayerFresh S α β))
+  rw [hx,Finsupp.mapDomain_single,Finsupp.mapDomain_single]
+  congr 1
+  exact Prod.ext (hα0.trans (fresh_zero (max (shapeBound S α) (shapeBound S β))).symm) rfl
+lemma relayerRightPure (x : Simplicial.Space (orbitSpan S)) (g : G) (hx : x.1 = Finsupp.single (0,g) 1) :
+    relayerRightMap φ S α β hβ hβ0 x = relayerFreshMap φ S α β hα hα0 x := by
+  apply Subtype.ext
+  change x.1.mapDomain (vertexMap φ β) = x.1.mapDomain (vertexMap φ (relayerFresh S α β))
+  rw [hx,Finsupp.mapDomain_single,Finsupp.mapDomain_single]
+  congr 1
+  exact Prod.ext (hβ0.trans (fresh_zero (max (shapeBound S α) (shapeBound S β))).symm) rfl
+
+lemma relayerLeftHomotopy_fixed (x : Simplicial.Space (orbitSpan S)) (g : G)
+    (hx : x.1 = Finsupp.single (0,g) 1) (t : I) :
+    relayerLeftHomotopy φ S α β hα hα0 (t,x) = relayerLeftMap φ S α β hα hα0 x :=
+  straightHomotopy_fixed _ _ _ _ _ _ (relayerLeftValid φ S α β hα hα0) x
+    (relayerLeftPure φ S α β hα hα0 x g hx) t
+lemma relayerRightHomotopy_fixed (x : Simplicial.Space (orbitSpan S)) (g : G)
+    (hx : x.1 = Finsupp.single (0,g) 1) (t : I) :
+    relayerRightHomotopy φ S α β hα hβ hα0 hβ0 (t,x) = relayerRightMap φ S α β hβ hβ0 x :=
+  straightHomotopy_fixed _ _ _ _ _ _ (relayerRightValid φ S α β hβ hβ0) x
+    (relayerRightPure φ S α β hα hβ hα0 hβ0 x g hx) t
+
+/-- The controlled relayer comparison is stationary on all layer-zero points. -/
+theorem relayerHomotopy_fixed (x : Simplicial.Space (orbitSpan S)) (g : G)
+    (hx : x.1 = Finsupp.single (0,g) 1) (t : I) :
+    relayerHomotopy φ S α β hα hβ hα0 hβ0 (t,x) = relayerLeftMap φ S α β hα hα0 x := by
+  rw [relayerHomotopy,ContinuousMap.Homotopy.trans_apply]
+  split
+  · exact relayerLeftHomotopy_fixed φ S α β hα hα0 x g hx _
+  · rw [ContinuousMap.Homotopy.symm_apply]
+    exact (relayerRightHomotopy_fixed φ S α β hα hβ hα0 hβ0 x g hx _).trans
+      ((relayerRightPure φ S α β hα hβ hα0 hβ0 x g hx).trans
+        (relayerLeftPure φ S α β hα hα0 x g hx).symm)
+end GroupRingTopology.Milnor
+
+/-! Functoriality and product additivity on actual higher homotopy groups.
+This is geometric support for the literal finite idempotent diagrams. -/
+namespace GroupRingTopology.HomotopyFunctor
+open scoped Topology Topology.Homotopy
+universe u v w
+variable {N : Type u} {X : Type v} {Y : Type w} [TopologicalSpace X] [TopologicalSpace Y]
+variable {x : X} {y : Y}
+
+def loopMap (f : C(X,Y)) (hf : f x = y) (p : GenLoop N X x) : GenLoop N Y y :=
+  ⟨f.comp p.1,fun t ht => by change f (p t) = y; rw [GenLoop.boundary p t ht,hf]⟩
+
+lemma loopMap_homotopic (f : C(X,Y)) (hf : f x = y) {p q : GenLoop N X x}
+    (h : GenLoop.Homotopic p q) : GenLoop.Homotopic (loopMap f hf p) (loopMap f hf q) :=
+  h.comp_continuousMap f
+
+def map (f : C(X,Y)) (hf : f x = y) : HomotopyGroup N X x → HomotopyGroup N Y y :=
+  Quotient.map (loopMap f hf) (fun _ _ h => loopMap_homotopic f hf h)
+
+@[simp] lemma map_mk (f : C(X,Y)) (hf : f x = y) (p : GenLoop N X x) :
+    map f hf (Quotient.mk' p) = Quotient.mk' (loopMap f hf p) := rfl
+
+lemma loopMap_const (f : C(X,Y)) (hf : f x = y) :
+    loopMap (N := N) f hf GenLoop.const = GenLoop.const := by
+  ext t
+  exact hf
+
+lemma loopMap_transAt [DecidableEq N] (i : N) (f : C(X,Y)) (hf : f x = y)
+    (p q : GenLoop N X x) :
+    loopMap f hf (GenLoop.transAt i p q) = GenLoop.transAt i (loopMap f hf p) (loopMap f hf q) := by
+  ext t
+  change f (if (t i : ℝ) ≤ 1/2 then p _ else q _) =
+    if (t i : ℝ) ≤ 1/2 then f (p _) else f (q _)
+  split <;> rfl
+
+def mapHom [DecidableEq N] [Nonempty N] (f : C(X,Y)) (hf : f x = y) :
+    HomotopyGroup N X x →* HomotopyGroup N Y y where
+  toFun := map f hf
+  map_one' := by
+    change Quotient.mk' (loopMap f hf GenLoop.const) = Quotient.mk' GenLoop.const
+    exact congrArg Quotient.mk' (loopMap_const f hf)
+  map_mul' a b := Quotient.inductionOn₂ a b fun p q => by
+    have h₁ := HomotopyGroup.mul_spec (i := Classical.arbitrary N) (p := p) (q := q)
+    have h₂ := HomotopyGroup.mul_spec (i := Classical.arbitrary N)
+      (p := loopMap f hf p) (q := loopMap f hf q)
+    exact (congrArg (map f hf) h₁).trans
+      ((congrArg Quotient.mk' (loopMap_transAt (Classical.arbitrary N) f hf q p)).trans h₂.symm)
+
+lemma map_id (a : HomotopyGroup N X x) : map (y := x) (ContinuousMap.id X) rfl a = a := by
+  induction a using Quotient.inductionOn with | h p =>
+  exact congrArg Quotient.mk' (by ext t; rfl)
+
+lemma map_comp {Z : Type*} [TopologicalSpace Z] {z : Z}
+    (f : C(X,Y)) (hf : f x = y) (g : C(Y,Z)) (hg : g y = z)
+    (a : HomotopyGroup N X x) :
+    map g hg (map f hf a) = map (g.comp f) (by change g (f x) = z; rw [hf,hg]) a := by
+  induction a using Quotient.inductionOn with | h p =>
+  rfl
+
+lemma map_const [DecidableEq N] [Nonempty N] (a : HomotopyGroup N X x) :
+    map (ContinuousMap.const X y) rfl a = 1 := by
+  induction a using Quotient.inductionOn with | h p =>
+  rfl
+
+variable {Z : Type*} [TopologicalSpace Z] {z : Z}
+
+def loopPair (p : GenLoop N X x) (q : GenLoop N Y y) : GenLoop N (X × Y) (x,y) :=
+  ⟨p.1.prodMk q.1,fun t ht => Prod.ext (GenLoop.boundary p t ht) (GenLoop.boundary q t ht)⟩
+
+lemma pair_homotopic {p p' : GenLoop N X x} {q q' : GenLoop N Y y}
+    (h : GenLoop.Homotopic p p') (k : GenLoop.Homotopic q q') :
+    GenLoop.Homotopic (loopPair p q) (loopPair p' q') := by
+  rcases h with ⟨h⟩
+  rcases k with ⟨k⟩
+  refine ⟨{ toHomotopy := h.toHomotopy.prodMk k.toHomotopy,prop' := ?_ }⟩
+  intro t a ha
+  exact Prod.ext (h.eq_fst t ha) (k.eq_fst t ha)
+
+lemma product_ext (a b : HomotopyGroup N (X × Y) (x,y))
+    (h₁ : map ((ContinuousMap.fst : C(X × Y,X))) rfl a = map ((ContinuousMap.fst : C(X × Y,X))) rfl b)
+    (h₂ : map ((ContinuousMap.snd : C(X × Y,Y))) rfl a = map ((ContinuousMap.snd : C(X × Y,Y))) rfl b) : a = b := by
+  induction a using Quotient.inductionOn with | h p =>
+  induction b using Quotient.inductionOn with | h q =>
+  apply Quotient.sound
+  have hh := pair_homotopic (Quotient.exact h₁) (Quotient.exact h₂)
+  exact hh
+
+/-- The diagonal class in a product is the product of its two coordinate
+classes. This is a statement about genuine based homotopy groups. -/
+lemma diagonal_split [DecidableEq N] [Nonempty N] (a : HomotopyGroup N X x) :
+    map (y := (x,x)) ((ContinuousMap.id X).prodMk (ContinuousMap.id X)) rfl a =
+      (map (y := (x,x)) ((ContinuousMap.id X).prodMk (ContinuousMap.const X x)) rfl a) *
+      (map (y := (x,x)) ((ContinuousMap.const X x).prodMk (ContinuousMap.id X)) rfl a) := by
+  apply product_ext
+  · change mapHom ((ContinuousMap.fst : C(X × X,X))) rfl _ = mapHom ((ContinuousMap.fst : C(X × X,X))) rfl _
+    rw [map_mul]
+    change map (y := x) _ _ (map (y := (x,x)) _ _ a) =
+      map (y := x) _ _ (map (y := (x,x)) _ _ a) * map (y := x) _ _ (map (y := (x,x)) _ _ a)
+    erw [map_comp, map_comp, map_comp]
+    change map (y := x) (ContinuousMap.id X) rfl a = map (y := x) (ContinuousMap.id X) rfl a * map (y := x) (ContinuousMap.const X x) rfl a
+    erw [map_id,map_const,mul_one]
+  · change mapHom ((ContinuousMap.snd : C(X × X,X))) rfl _ = mapHom ((ContinuousMap.snd : C(X × X,X))) rfl _
+    rw [map_mul]
+    change map (y := x) _ _ (map (y := (x,x)) _ _ a) =
+      map (y := x) _ _ (map (y := (x,x)) _ _ a) * map (y := x) _ _ (map (y := (x,x)) _ _ a)
+    erw [map_comp, map_comp, map_comp]
+    change map (y := x) (ContinuousMap.id X) rfl a = map (y := x) (ContinuousMap.const X x) rfl a * map (y := x) (ContinuousMap.id X) rfl a
+    erw [map_id,map_const,one_mul]
+
+/-- Product additivity requires no homological comparison or Hurewicz theorem. -/
+theorem product_additivity [DecidableEq N] [Nonempty N] (F : C(X × X,Y))
+    (hF : F (x,x) = y) (a : HomotopyGroup N X x) :
+    map (F.comp ((ContinuousMap.id X).prodMk (ContinuousMap.id X))) hF a =
+      map (F.comp ((ContinuousMap.id X).prodMk (ContinuousMap.const X x))) hF a *
+      map (F.comp ((ContinuousMap.const X x).prodMk (ContinuousMap.id X))) hF a := by
+  have h := map_comp (y := (x,x)) ((ContinuousMap.id X).prodMk (ContinuousMap.id X)) rfl F hF a
+  rw [← h,diagonal_split]
+  change mapHom (N := N) F hF (_ * _) = _
+  rw [map_mul]
+  exact congrArg₂ (· * ·) (map_comp _ _ _ _ a) (map_comp _ _ _ _ a)
+end GroupRingTopology.HomotopyFunctor
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/GroupRing/MultiplicityBound.lean b/lean/OAI/Algebra/GroupRing/MultiplicityBound.lean
new file mode 100644
index 0000000000000000000000000000000000000000..c4f1723ccbfe816c4e7df668fb5a11b245741776
--- /dev/null
+++ b/lean/OAI/Algebra/GroupRing/MultiplicityBound.lean
@@ -0,0 +1,418 @@
+import Mathlib
+import OAI.Algebra.GroupRing.EntropyStages
+import OAI.Algebra.GroupRing.ChainCoverage
+import OAI.Algebra.GroupRing.IntervalSelfLinks
+
+namespace OAI
+
+noncomputable section
+
+namespace TorsionFreeZeroDivisors.MultiplicityBound
+open SimpleGraph WeightedCycles
+variable {V : Type*} {G : SimpleGraph V}
+
+/-- Every nonempty reduced closed walk pays at least the cycle girth, even
+when subdivision spokes have zero weight. -/
+theorem closed_weight (w : Sym2 V → ℝ) (hw : ∀ e, 0 ≤ w e)
+    (L : ℝ) (hg : ∀ a (c : G.Walk a a), c.IsCycle → L ≤ weight w c)
+    {a : V} (p : G.Walk a a) (hp : p.edges.IsChain (· ≠ ·)) (hne : ¬ p.Nil) :
+    L ≤ weight w p := by
+  have hn : ¬p.IsPath := fun h => hne (Walk.isPath_iff_nil.mp h)
+  obtain ⟨b,c,hc,hcp⟩ := reduced_not_path_cycle w hw p hp hn
+  exact (hg b c hc).trans hcp
+
+/-- Vertex visits in any reduced walk are uniformly bounded in terms of
+expanded length divided by girth. This counts occurrences, not just edges. -/
+theorem visit_bound [DecidableEq V] (w : Sym2 V → ℝ) (hw : ∀ e, 0 ≤ w e)
+    (L : ℝ) (hL : 0 ≤ L)
+    (hg : ∀ a (c : G.Walk a a), c.IsCycle → L ≤ weight w c)
+    {a b : V} (p : G.Walk a b) (hp : p.edges.IsChain (· ≠ ·)) (x : V) :
+    (p.support.count x : ℝ)*L ≤ weight w p + L := by
+  induction hn : p.length using Nat.strong_induction_on generalizing a b p with
+  | h n ih =>
+    cases p with
+    | nil =>
+      by_cases hx : a=x
+      · subst x; simp
+      · simpa [hx] using hL
+    | @cons a b c hab r =>
+      have hr : r.edges.IsChain (· ≠ ·) := (List.isChain_cons.mp hp).2
+      have il := ih r.length (by simp only [Walk.length_cons] at hn; omega)
+        r hr rfl
+      by_cases hax : a=x
+      · subst x
+        by_cases hmem : a ∈ r.support
+        · let pref : G.Walk a a := Walk.cons hab (r.takeUntil a hmem)
+          let suff := r.dropUntil a hmem
+          have hsplit : pref.append suff = Walk.cons hab r := by
+            simp only [pref,suff,Walk.cons_append,Walk.take_spec]
+          have hpref : pref.edges.IsChain (· ≠ ·) := hp.prefix (by
+            rw [← hsplit,Walk.edges_append]
+            exact List.prefix_append _ _)
+          have hsuff : suff.edges.IsChain (· ≠ ·) := hr.suffix (r.edges_dropUntil_suffix_edges hmem)
+          have hpw : L ≤ weight w pref := closed_weight w hw L hg pref hpref (by simp [pref])
+          have hsw := ih suff.length (by
+            have hlen := r.length_dropUntil_le_length hmem
+            simp only [Walk.length_cons] at hn
+            dsimp [suff]
+            omega) suff hsuff rfl
+          have hcount : (Walk.cons hab r).support.count a = suff.support.count a + 1 := by
+            have ht := r.count_support_takeUntil_eq_one hmem
+            have hstart : suff.support = a :: suff.support.tail := by
+              exact (List.cons_head_tail (by simp : suff.support ≠ [])).symm.trans (by simp)
+            have hrc : r.support.count a = suff.support.count a := by
+              conv_lhs => rw [← r.take_spec hmem]
+              simp only [Walk.support_append,List.count_append,ht]
+              change 1+suff.support.tail.count a=suff.support.count a
+              have hh := congrArg (fun xs : List V => xs.count a) hstart
+              simp only [List.count_cons_self] at hh
+              omega
+            simp [hrc,Nat.add_comm]
+          have hweight : weight w (Walk.cons hab r)=weight w pref+weight w suff := by
+            rw [← hsplit,weight_append]
+          rw [hcount,hweight]
+          push_cast
+          nlinarith
+        · have hz : r.support.count a=0 := List.count_eq_zero.mpr hmem
+          simp only [Walk.support_cons,List.count_cons_self,hz,Nat.zero_add,Nat.cast_one,one_mul]
+          linarith [weight_nonneg w hw (Walk.cons hab r)]
+      · have hc : (Walk.cons hab r).support.count x=r.support.count x := by
+          simp [hax]
+        rw [hc,weight_cons]
+        linarith [hw s(a,b)]
+
+end TorsionFreeZeroDivisors.MultiplicityBound
+
+namespace TorsionFreeZeroDivisors.PathMultiplicity
+open SimpleGraph WeightedCycles WeightedMoore WeightedPortMoore
+open PortSubdivision SuppressedMoore
+open scoped Classical
+variable {V D : Type*} (Γ : PortGraph V D)
+local instance : BEq (V ⊕ D) := instBEqOfDecidableEq
+
+/-- Convert a literal nonempty dart path to the dependent chain encoding. -/
+def pathChain (x : D) : (xs : List D) → Chain D xs.length
+  | [] => x
+  | y::ys => (x,pathChain y ys)
+
+@[simp] lemma pathChain_head (x : D) (xs : List D) : head (pathChain x xs)=x := by
+  cases xs <;> rfl
+
+@[simp] lemma pathChain_word (x : D) (xs : List D) : outWord (pathChain x xs)=x::xs := by
+  induction xs generalizing x with
+  | nil => rfl
+  | cons y ys ih => exact congrArg (List.cons x) (ih y)
+
+lemma pathChain_good (x : D) (xs : List D)
+    (hr : (x::xs).IsChain (PortWalk.step Γ.origin Γ.reverse)) : Good Γ (pathChain x xs) := by
+  induction xs generalizing x with
+  | nil => trivial
+  | cons y ys ih =>
+    exact ⟨by simpa only [pathChain,pathChain_head] using (List.isChain_cons_cons.mp hr).1, ih y hr.tail⟩
+
+/-- A port appears once per traversal of its undirected edge in the physical
+subdivision walk, in either direction. Spoke vertices do not add occurrences. -/
+lemma draw_count {k : ℕ} (p : Chain D k) (hp : Good Γ p) (x : D) :
+    (draw Γ p hp).support.count (Sum.inr x) =
+      (outWord p).count x + (outWord p).count (Γ.reverse x) := by
+  classical
+  induction k with
+  | zero =>
+    change ([Sum.inr p, Sum.inr (Γ.reverse p)] : List (V ⊕ D)).count (Sum.inr x) =
+      [p].count x + [p].count (Γ.reverse x)
+    have he : Γ.reverse p=x ↔ p=Γ.reverse x := by
+      constructor
+      · intro h; rw [←h,Γ.reverse_reverse]
+      · intro h; rw [h,Γ.reverse_reverse]
+    simp only [List.count_cons,List.count_nil,beq_iff_eq,Sum.inr.injEq,he]
+    omega
+  | succ k ih =>
+    change (Sum.inr p.1 :: Sum.inr (Γ.reverse p.1) ::
+      Sum.inl (Γ.origin (Γ.reverse p.1)) :: (draw Γ p.2 hp.2).support).count (Sum.inr x) =
+      (p.1 :: outWord p.2).count x + (p.1 :: outWord p.2).count (Γ.reverse x)
+    have he : Γ.reverse p.1=x ↔ p.1=Γ.reverse x := by
+      constructor
+      · intro h; rw [←h,Γ.reverse_reverse]
+      · intro h; rw [h,Γ.reverse_reverse]
+    simp only [List.count_cons,beq_iff_eq,Sum.inr.injEq,reduceCtorEq,he,ih]
+    simp only [ite_false]
+    omega
+
+lemma pathChain_cost (x : D) (xs : List D) :
+    cost (fun _ : D => (1:ℝ)) (pathChain x xs) = (x::xs).length := by
+  induction xs generalizing x with
+  | nil => simp [pathChain,cost]
+  | cons y ys ih =>
+    change 1+cost (fun _ : D => (1:ℝ)) (pathChain y ys) = ((x::y::ys).length:ℝ)
+    rw [ih]
+    simp only [List.length_cons,Nat.cast_add,Nat.cast_one]
+    ring
+
+/-- The undirected edge count for a literal port path bounds each orientation
+in particular. -/
+theorem path_edge_bound (L : ℝ) (hL : 0≤L)
+    (hg : ∀ a (c : Γ.subdivision.Walk a a), c.IsCycle →
+      L ≤ weight (edgeWeight (fun _ : D => 1)) c)
+    (p : List D) (hp : p.IsChain (PortWalk.step Γ.origin Γ.reverse)) (x : D) :
+    ((p.count x + p.count (Γ.reverse x):ℕ):ℝ)*L ≤ p.length + L := by
+  cases p with
+  | nil => simpa using hL
+  | cons y ys =>
+    let q := pathChain y ys
+    have hq : Good Γ q := pathChain_good Γ y ys hp
+    have h := MultiplicityBound.visit_bound (edgeWeight (fun _ : D => 1))
+      (edgeWeight_nonneg _ (by intro d; norm_num)) L hL hg
+      (draw Γ q hq) (draw_reduced Γ q hq) (Sum.inr x)
+    rw [draw_count Γ q hq x,draw_weight Γ _ (by intro d; rfl)] at h
+    simpa only [q,pathChain_word,pathChain_cost] using h
+
+end TorsionFreeZeroDivisors.PathMultiplicity
+
+namespace TorsionFreeZeroDivisors.ChainPaths
+open Function PortSubdivision ChainSuppression DegreeTwoSuppression
+open WeightedMoore WeightedPortMoore SuppressedMoore ActualMarkedChains
+open scoped Classical
+variable {V D : Type*} [Fintype D] (Γ : PortGraph V D)
+    (mark : V → Prop) (h2 : ∀ v, ¬mark v → (DegreeTwoSuppression.out Γ.origin v).card=2)
+local notation "τ" => turn Γ.origin mark h2
+local notation "F" => next Γ.reverse τ
+local notation "B" => {d : D // τ d=d}
+local notation "len" => chainLength Γ mark h2
+
+lemma reverse_mem_word (d : B) (x : D) (hx : x∈word Γ mark h2 d) :
+    Γ.reverse x∈word Γ mark h2 ((suppressed Γ mark h2).reverse d) := by
+  obtain ⟨i,rfl⟩ := (mem_word_iff Γ mark h2 d x).mp hx
+  let e := (suppressed Γ mark h2).reverse d
+  let k := len d
+  have hj : k-i.val-1 < len e := by
+    rw [chainLength_reverse]
+    have hi := i.isLt
+    change i.val < k at hi
+    omega
+  rw [mem_word_iff]
+  refine ⟨⟨k-i.val-1,hj⟩,?_⟩
+  have hf := endpoint_reverse Γ.reverse τ Γ.reverse_reverse
+    (turn_involutive Γ.origin mark h2) (x:=d) (i:=k-i.val) (by change k-i.val ≤ k; omega)
+  have he : k-(k-i.val)=i.val := by omega
+  have hs : k-i.val=(k-i.val-1)+1 := by have hi := i.isLt; change i.val < k at hi; omega
+  change F^[k-i.val] e.val = τ (F^[k-(k-i.val)] d.val) at hf
+  rw [he,hs,iterate_succ_apply'] at hf
+  have h := congrArg τ hf
+  change τ (τ (Γ.reverse (F^[k-i.val-1] e.val))) = τ (τ (F^[i.val] d.val)) at h
+  rw [turn_involutive Γ.origin mark h2,turn_involutive Γ.origin mark h2] at h
+  have hh := congrArg Γ.reverse h
+  rwa [Γ.reverse_reverse] at hh
+
+lemma undirected_multiplicity_constant (ds : List B) (d : B) (x : D)
+    (hx : x∈word Γ mark h2 d) :
+    (ds.flatMap (word Γ mark h2)).count x +
+      (ds.flatMap (word Γ mark h2)).count (Γ.reverse x) =
+      ds.count d + ds.count ((suppressed Γ mark h2).reverse d) := by
+  rw [multiplicity_constant Γ mark h2 ds d x hx,
+    multiplicity_constant Γ mark h2 ds _ _ (reverse_mem_word Γ mark h2 d x hx)]
+
+end TorsionFreeZeroDivisors.ChainPaths
+
+namespace TorsionFreeZeroDivisors.PathMultiplicity
+open PortSubdivision WeightedCycles WeightedPortMoore
+open scoped BigOperators Classical
+variable {V D I : Type*} (Γ : PortGraph V D) [Fintype I]
+
+/-- Summing the literal edge-multiplicity estimate over the given path system. -/
+theorem total_edge_bound (L : ℝ) (hL : 0≤L)
+    (hg : ∀ a (c : Γ.subdivision.Walk a a), c.IsCycle →
+      L ≤ weight (edgeWeight (fun _ : D => 1)) c)
+    (p : I → List D) (hp : ∀ i, (p i).IsChain (WeightedMoore.PortWalk.step Γ.origin Γ.reverse))
+    (x : D) :
+    (∑ i, ((p i).count x + (p i).count (Γ.reverse x)):ℕ)*L ≤
+      (∑ i, (p i).length : ℕ)+(Fintype.card I:ℝ)*L := by
+  have h := Finset.sum_le_sum (s := Finset.univ) (fun i _ => path_edge_bound Γ L hL hg (p i) (hp i) x)
+  rw [← Finset.sum_mul] at h
+  simpa only [Nat.cast_sum,Nat.cast_add,Finset.sum_add_distrib,Finset.sum_const,
+    Finset.card_univ,nsmul_eq_mul] using h
+
+end TorsionFreeZeroDivisors.PathMultiplicity
+
+namespace TorsionFreeZeroDivisors.ChainPaths
+open Function PortSubdivision ChainSuppression DegreeTwoSuppression
+open WeightedMoore WeightedPortMoore SuppressedMoore ActualMarkedChains WeightedCycles
+open scoped Classical BigOperators
+variable {V D : Type*} [Fintype D] (Γ : PortGraph V D)
+    (mark : V → Prop) (h2 : ∀ v, ¬mark v → (DegreeTwoSuppression.out Γ.origin v).card=2)
+local notation "τ" => turn Γ.origin mark h2
+local notation "B" => {d : D // τ d=d}
+
+lemma start_mem_word (d : B) : d.val∈word Γ mark h2 d := by
+  rw [mem_word_iff]
+  exact ⟨⟨0,chainLength_pos Γ mark h2 d⟩,rfl⟩
+
+omit [Fintype D] in
+lemma sum_count_eq_length {A : Type*} [Fintype A] [BEq A] [LawfulBEq A] (p : List A) :
+    ∑ a, p.count a = p.length := by
+  classical
+  induction p with
+  | nil => simp
+  | cons b p ih =>
+    simp only [List.count_cons,beq_iff_eq,Finset.sum_add_distrib,List.length_cons,ih]
+    simp
+
+/-- The number of chain traversals is bounded independently of their lengths. -/
+theorem total_chain_bound {I : Type*} [Fintype I]
+    (L : ℝ) (hL : 0≤L)
+    (hg : ∀ a (c : Γ.subdivision.Walk a a), c.IsCycle →
+      L ≤ weight (edgeWeight (fun _ : D => 1)) c)
+    (ds : I → List B)
+    (hp : ∀ i, ((ds i).flatMap (word Γ mark h2)).IsChain (PortWalk.step Γ.origin Γ.reverse)) :
+    (∑ i, (ds i).length : ℕ)*L ≤ (Fintype.card B:ℝ)*
+      ((∑ i, ((ds i).flatMap (word Γ mark h2)).length : ℕ)+(Fintype.card I:ℝ)*L) := by
+  let H : ℝ := (∑ i, ((ds i).flatMap (word Γ mark h2)).length : ℕ)
+  have hd (d : B) : (∑ i, (ds i).count d : ℕ)*L ≤ H+(Fintype.card I:ℝ)*L := by
+    have h := PathMultiplicity.total_edge_bound Γ L hL hg
+      (fun i => (ds i).flatMap (word Γ mark h2)) hp d.val
+    have he : (∑ i, (ds i).count d : ℕ) ≤
+        ∑ i, (((ds i).flatMap (word Γ mark h2)).count d.val +
+          ((ds i).flatMap (word Γ mark h2)).count (Γ.reverse d.val)) := by
+      apply Finset.sum_le_sum
+      intro i _
+      rw [multiplicity_constant Γ mark h2 _ d d.val (start_mem_word Γ mark h2 d)]
+      exact Nat.le_add_right _ _
+    exact (mul_le_mul_of_nonneg_right (by exact_mod_cast he) hL).trans h
+  have hs := Finset.sum_le_sum (s := Finset.univ) (fun d _ => hd d)
+  rw [← Finset.sum_mul] at hs
+  have he : ∑ d : B, (∑ i, (ds i).count d : ℕ) = ∑ i, (ds i).length := by
+    rw [Finset.sum_comm]
+    apply Finset.sum_congr rfl
+    intro i _
+    exact sum_count_eq_length (ds i)
+  simpa only [← Nat.cast_sum,he,Finset.sum_const,Finset.card_univ,nsmul_eq_mul,H] using hs
+
+/-- A uniform integer bound in terms of the length, path count, and chain count. -/
+theorem bounded_chain_traversals {I : Type*} [Fintype I]
+    (C : ℝ) (hC : 0≤C) (K R : ℕ) (hI : Fintype.card I≤K) (hB : Fintype.card B≤R)
+    (L : ℝ) (hL : 0<L)
+    (hg : ∀ a (c : Γ.subdivision.Walk a a), c.IsCycle →
+      L ≤ weight (edgeWeight (fun _ : D => 1)) c)
+    (ds : I → List B)
+    (hp : ∀ i, ((ds i).flatMap (word Γ mark h2)).IsChain (PortWalk.step Γ.origin Γ.reverse))
+    (hH : (∑ i, ((ds i).flatMap (word Γ mark h2)).length : ℕ) ≤ C*L) :
+    ∑ i, (ds i).length ≤ ⌈(R:ℝ)*(C+K)⌉₊ := by
+  have h := total_chain_bound Γ mark h2 L hL.le hg ds hp
+  have hib : (Fintype.card I:ℝ) ≤ K := by exact_mod_cast hI
+  have hbb : (Fintype.card B:ℝ) ≤ R := by exact_mod_cast hB
+  have hh : (∑ i, (ds i).length : ℕ)*L ≤ (R:ℝ)*(C+(K:ℝ))*L := by
+    calc
+      _ ≤ (Fintype.card B:ℝ)*((C:ℝ)*L+(K:ℝ)*L) :=
+        h.trans (mul_le_mul_of_nonneg_left
+          (add_le_add hH (mul_le_mul_of_nonneg_right hib hL.le)) (Nat.cast_nonneg _))
+      _ = (Fintype.card B:ℝ)*(C+K)*L := by ring
+      _ ≤ (R:ℝ)*(C+K)*L := mul_le_mul_of_nonneg_right
+        (mul_le_mul_of_nonneg_right hbb (by positivity)) hL.le
+  have he := (mul_le_mul_iff_left₀ hL).mp hh
+  exact_mod_cast he.trans (Nat.le_ceil _)
+
+end TorsionFreeZeroDivisors.ChainPaths
+
+namespace TorsionFreeZeroDivisors.IncidenceStages
+open scoped Classical BigOperators
+open EntropyStages
+variable {O D V : Type*} [Fintype O] [Fintype D] [Fintype V]
+
+/-- An incidence remembers its occurrence and which (oriented) half-edge it
+uses. Passages pair incidences at a vertex; path endpoints are fixed points. -/
+structure Passages (origin : D → V) (port : O → D) extends Pairing O where
+  location : ∀ o, origin (port (partner o)) = origin (port o)
+  reduced : ∀ o, partner o ≠ o → port (partner o) ≠ port o
+
+namespace Passages
+variable {origin : D → V} {port : O → D} (P : Passages origin port)
+
+abbrev AtVertex (v : V) := {o : O // origin (port o) = v}
+
+def localPairing (v : V) : Pairing (AtVertex (origin := origin) (port := port) v) where
+  partner o := ⟨P.partner o.val,(P.location o.val).trans o.property⟩
+  involutive o := Subtype.ext (P.involutive o.val)
+
+def multiplicity (d : D) : ℕ := Fintype.card {o : O // port o = d}
+def maxMultiplicity (v : V) : ℕ :=
+  (Finset.univ.filter (fun d => origin d = v)).sup (multiplicity (port := port))
+
+omit [Fintype V] [Fintype D] in
+theorem local_multiplicity (d : D) :
+    Fintype.card {o : AtVertex (origin := origin) (port := port) (origin d) // port o.val = d} =
+      multiplicity (port := port) d := by
+  let e : {o : AtVertex (origin := origin) (port := port) (origin d) // port o.val = d} ≃
+      {o : O // port o = d} :=
+    { toFun := fun o => ⟨o.val.val,o.property⟩
+      invFun := fun o => ⟨⟨o.val,congrArg origin o.property⟩,o.property⟩
+      left_inv := fun _ => rfl
+      right_inv := fun _ => rfl }
+  exact Fintype.card_congr e
+
+omit [Fintype V] in
+theorem local_balance (v : V) :
+    2 * maxMultiplicity (origin := origin) (port := port) v ≤
+      Fintype.card (AtVertex (origin := origin) (port := port) v) +
+        Fintype.card (P.localPairing v).Unmatched := by
+  by_cases hem : (Finset.univ.filter (fun d => origin d = v)).Nonempty
+  · obtain ⟨d,hd,he⟩ := Finset.exists_mem_eq_sup _ hem (multiplicity (port := port))
+    have hdv : origin d = v := (Finset.mem_filter.mp hd).2
+    have hb := (P.localPairing v).color_balance (fun o => port o.val) d (by
+      intro o ho
+      exact P.reduced o.val (by intro h; exact ho (Subtype.ext h)))
+    have hc : Fintype.card {o : AtVertex (origin := origin) (port := port) v // port o.val = d} =
+        multiplicity (port := port) d := by
+      subst v
+      exact local_multiplicity d
+    rw [hc] at hb
+    simpa only [maxMultiplicity,he] using hb
+  · have he : Finset.univ.filter (fun d => origin d = v) = ∅ := Finset.not_nonempty_iff_eq_empty.mp hem
+    simp [maxMultiplicity,he]
+
+omit [Fintype D] in
+theorem sum_vertex_cards :
+    (∑ v : V, Fintype.card (AtVertex (origin := origin) (port := port) v)) = Fintype.card O := by
+  simpa only [Finset.sum_const,Finset.card_univ,smul_eq_mul,mul_one] using
+    Fintype.sum_fiberwise (fun o => origin (port o)) (fun _ => (1 : ℕ))
+
+omit [Fintype D] in
+theorem sum_endpoint_cards :
+    (∑ v : V, Fintype.card (P.localPairing v).Unmatched) = Fintype.card P.toPairing.Unmatched := by
+  have hc (v : V) : Fintype.card (P.localPairing v).Unmatched =
+      Fintype.card {o : P.toPairing.Unmatched // origin (port o.val) = v} := by
+    let e : (P.localPairing v).Unmatched ≃
+        {o : P.toPairing.Unmatched // origin (port o.val) = v} :=
+      { toFun := fun o => ⟨⟨o.val.val,congrArg Subtype.val o.property⟩,o.val.property⟩
+        invFun := fun o => ⟨⟨o.val.val,o.property⟩,Subtype.ext o.val.property⟩
+        left_inv := fun _ => rfl
+        right_inv := fun _ => rfl }
+    exact Fintype.card_congr e
+  simp_rw [hc]
+  simpa only [Finset.sum_const,Finset.card_univ,smul_eq_mul,mul_one] using
+    Fintype.sum_fiberwise (fun o : P.toPairing.Unmatched => origin (port o.val)) (fun _ => (1 : ℕ))
+
+/-- Exact incidence balance before any probabilities or asymptotic estimates.
+It remains valid when a loop contributes two distinct half-edges at a vertex. -/
+theorem total_balance :
+    2 * (∑ v : V, maxMultiplicity (origin := origin) (port := port) v) ≤
+      Fintype.card O + Fintype.card P.toPairing.Unmatched := by
+  calc
+    _ = ∑ v : V, 2 * maxMultiplicity (origin := origin) (port := port) v := by rw [Finset.mul_sum]
+    _ ≤ ∑ v : V, (Fintype.card (AtVertex (origin := origin) (port := port) v) +
+      Fintype.card (P.localPairing v).Unmatched) := Finset.sum_le_sum (fun v _ => P.local_balance v)
+    _ = _ := by rw [Finset.sum_add_distrib,sum_vertex_cards,P.sum_endpoint_cards]
+
+/-- Each edge occurrence has two incidences, and zero or one interval
+contributes zero or two endpoints. -/
+theorem image_vertex_bound (H iota : ℕ) (hH : Fintype.card O = 2*H)
+    (hiota : Fintype.card P.toPairing.Unmatched = 2*iota) :
+    (∑ v : V, maxMultiplicity (origin := origin) (port := port) v) ≤ H+iota := by
+  have h := P.total_balance
+  rw [hH,hiota] at h
+  omega
+
+end Passages
+end TorsionFreeZeroDivisors.IncidenceStages
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/GroupRing/PartialLift.lean b/lean/OAI/Algebra/GroupRing/PartialLift.lean
new file mode 100644
index 0000000000000000000000000000000000000000..8690573e21abaf5784fe253827e83002bb482f98
--- /dev/null
+++ b/lean/OAI/Algebra/GroupRing/PartialLift.lean
@@ -0,0 +1,401 @@
+import Mathlib
+import OAI.Algebra.GroupRing.Cellular
+
+namespace OAI
+
+open Set Metric Topology BigOperators
+open Set Metric Topology
+namespace GroupRingTopology.Cellular
+universe u v w
+variable {X : Type u} [TopologicalSpace X] [T2Space X]
+variable {C : Set X} [CWComplex C]
+
+namespace PartialLift
+variable {E : Type v} {B : Type w} [TopologicalSpace E] [TopologicalSpace B]
+variable {p : C(E,B)} {f : C(X,B)} {n : ℕ}
+
+/-- The boundary lift for attaching an n-cell. -/
+def onSphere (a : PartialLift (C := C) p f n) (i : RelCWComplex.cell C n) :
+    C(Sphere n,E) :=
+  ⟨fun x => a.val (characteristic n i (boundary n x)),
+    a.continuousOn.comp_continuous
+      ((characteristic n i).continuous.comp (continuous_boundary n))
+      (sphere_mem_skeleton n i)⟩
+
+lemma exists_cell_extension (a : PartialLift (C := C) p f n) (hp : DiskRLP p)
+    (i : RelCWComplex.cell C n) :
+    ∃ e : C(Disk n,E),
+      (∀ x, e (boundary n x) = a.val (characteristic n i (boundary n x))) ∧
+      ∀ x, p (e x) = f (characteristic n i x) := by
+  apply hp n (a.onSphere i) (f.comp (characteristic n i))
+  intro x
+  exact a.fac _ (sphere_mem_skeleton n i x)
+
+/-- Extend a partial lift across all cells of the next dimension. -/
+noncomputable def next (a : PartialLift (C := C) p f n) (hp : DiskRLP p) :
+    PartialLift (C := C) p f (n+1) := by
+  choose e hb hf using fun i => a.exists_cell_extension hp i
+  refine ⟨attachValue a.val e,attachValue_continuous a.val a.continuousOn e hb,?_⟩
+  intro x hx
+  have hdecomp : Skeleton C (n+1) = Skeleton C n ∪
+      ⋃ i : RelCWComplex.cell C n, CWComplex.closedCell n i := by
+    simpa only [Skeleton,Nat.cast_add,Nat.cast_one] using
+      (CWComplex.skeletonLT_union_iUnion_closedCell_eq_skeletonLT_succ (C := C) n).symm
+  rw [hdecomp] at hx
+  rcases hx with hx | hx
+  · rw [attachValue_old a.val e hx]
+    exact a.fac x hx
+  · obtain ⟨i,y,hy,rfl⟩ := Set.mem_iUnion.mp hx
+    rw [show RelCWComplex.map n i y = characteristic n i ⟨y,hy⟩ from rfl,
+      attachValue_characteristic a.val e hb]
+    exact hf i ⟨y,hy⟩
+
+lemma next_eq (a : PartialLift (C := C) p f n) (hp : DiskRLP p)
+    {x : X} (hx : x ∈ Skeleton C n) : (a.next hp).val x = a.val x := by
+  dsimp only [next]
+  exact attachValue_old a.val _ hx
+
+noncomputable def zero [Nonempty E] : PartialLift (C := C) p f 0 where
+  val := fun _ => Classical.choice ‹Nonempty E›
+  continuousOn := continuous_const.continuousOn
+  fac := by
+    intro x hx
+    simp only [Skeleton,Nat.cast_zero,CWComplex.skeletonLT_zero_eq_empty,Set.mem_empty_iff_false] at hx
+
+end PartialLift
+
+section Lift
+variable {E : Type v} {B : Type w} [TopologicalSpace E] [TopologicalSpace B] [Nonempty E]
+variable {p : C(E,B)} (hp : DiskRLP p) (f : C(X,B))
+
+noncomputable def stages : ∀ n, PartialLift (C := C) p f n
+  | 0 => PartialLift.zero
+  | n+1 => (stages n).next hp
+
+lemma stages_agree {m n : ℕ} (h : m ≤ n) {x : X} (hx : x ∈ Skeleton C m) :
+    (stages (C := C) hp f n).val x = (stages (C := C) hp f m).val x := by
+  induction n,h using Nat.le_induction with
+  | base => rfl
+  | succ n hn ih =>
+    exact ((stages (C := C) hp f n).next_eq hp (skeleton_mono hn hx)).trans ih
+
+lemma exists_skeleton {x : X} (hx : x ∈ C) : ∃ n : ℕ, x ∈ Skeleton C n := by
+  rw [← CWComplex.iUnion_skeletonLT_eq_complex (C := C)] at hx
+  exact Set.mem_iUnion.mp hx
+
+noncomputable def liftValue (x : X) : E := by
+  classical
+  exact if hx : x ∈ C then (stages (C := C) hp f (exists_skeleton (C := C) hx).choose).val x
+    else Classical.choice ‹Nonempty E›
+
+lemma liftValue_eq {n : ℕ} {x : X} (hx : x ∈ Skeleton C n) :
+    liftValue (C := C) hp f x = (stages (C := C) hp f n).val x := by
+  classical
+  have hxC : x ∈ C := (CWComplex.skeletonLT C n).subset_complex hx
+  rw [liftValue,dite_eq_left hxC]
+  let m := (exists_skeleton (C := C) hxC).choose
+  have hm : x ∈ Skeleton C m := (exists_skeleton (C := C) hxC).choose_spec
+  exact (stages_agree hp f (Nat.le_max_left m n) hm).symm.trans
+    (stages_agree hp f (Nat.le_max_right m n) hx)
+
+lemma continuousOn_liftValue : ContinuousOn (liftValue (C := C) hp f) C := by
+  apply (continuousOn_iff_characteristic _).2
+  intro n i
+  have hEq : liftValue (C := C) hp f ∘ characteristic n i =
+      (stages (C := C) hp f (n+1)).val ∘ characteristic n i := by
+    funext x
+    exact liftValue_eq hp f (characteristic_mem_skeleton (Nat.lt_succ_self n) i x)
+  rw [hEq]
+  exact (stages (C := C) hp f (n+1)).continuousOn.comp_continuous (characteristic n i).continuous
+    (characteristic_mem_skeleton (Nat.lt_succ_self n) i)
+
+lemma liftValue_fac {x : X} (hx : x ∈ C) : p (liftValue (C := C) hp f x) = f x := by
+  obtain ⟨n,hn⟩ := exists_skeleton (C := C) hx
+  rw [liftValue_eq hp f hn]
+  exact (stages (C := C) hp f n).fac x hn
+
+include hp in
+theorem exists_lift [CWComplex (Set.univ : Set X)] :
+    ∃ g : C(X,E), ∀ x, p (g x) = f x := by
+  refine ⟨⟨liftValue (C := Set.univ) hp f,
+    continuousOn_univ.mp (continuousOn_liftValue (C := Set.univ) hp f)⟩,?_⟩
+  intro x
+  exact liftValue_fac hp f (Set.mem_univ x)
+
+end Lift
+
+noncomputable section
+/-- Extension property with respect to the actual sup-norm disks. -/
+def SphereFillable (Y : Type u) [TopologicalSpace Y] : Prop :=
+  ∀ n (a : C(Sphere n,Y)), ∃ e : C(Disk n,Y), ∀ x, e (boundary n x) = a x
+
+lemma disk_coord {n : ℕ} (x : Disk n) (i : Fin n) : |x.1 i| ≤ 1 := by
+  exact (pi_norm_le_iff_of_nonneg (by norm_num : (0:ℝ) ≤ 1)).mp
+    (mem_closedBall_zero_iff.mp x.2) i
+
+lemma disk_mem {n : ℕ} {x : Fin n → ℝ} (h : ∀ i, |x i| ≤ 1) :
+    x ∈ closedBall 0 1 := by
+  exact mem_closedBall_zero_iff.mpr
+    ((pi_norm_le_iff_of_nonneg (by norm_num : (0:ℝ) ≤ 1)).mpr h)
+
+def diskCons {n : ℕ} (x : Disk n) (t : unitInterval) : Disk (n+1) :=
+  ⟨Fin.cons (2*t.1-1) x.1, disk_mem (by
+    intro i
+    refine Fin.cases ?_ (fun j => ?_) i
+    · simp only [Fin.cons_zero,abs_le]
+      constructor <;> linarith [t.2.1,t.2.2]
+    · exact disk_coord x j)⟩
+
+lemma continuous_diskCons {n : ℕ} :
+    Continuous (fun q : Disk n × unitInterval => diskCons q.1 q.2) := by
+  apply Continuous.subtype_mk
+  apply continuous_pi
+  intro i
+  refine Fin.cases ?_ (fun j => ?_) i
+  · change Continuous (fun q : Disk n × unitInterval => 2*q.2.1-1)
+    fun_prop
+  · change Continuous (fun q : Disk n × unitInterval => q.1.1 j)
+    exact (continuous_apply j).comp (continuous_subtype_val.comp continuous_fst)
+
+def diskTail {n : ℕ} (x : Disk (n+1)) : Disk n :=
+  ⟨Fin.tail x.1,disk_mem (fun i => disk_coord x i.succ)⟩
+
+lemma continuous_diskTail {n : ℕ} : Continuous (@diskTail n) := by
+  apply Continuous.subtype_mk
+  exact continuous_pi (fun i => (continuous_apply i.succ).comp continuous_subtype_val)
+
+def diskTime {n : ℕ} (x : Disk (n+1)) : unitInterval :=
+  ⟨(x.1 0+1)/2,by have h := (abs_le.mp (disk_coord x 0)); constructor <;> linarith⟩
+
+lemma continuous_diskTime {n : ℕ} : Continuous (@diskTime n) := by
+  exact (((continuous_apply 0).comp continuous_subtype_val).add continuous_const).div_const 2 |>.subtype_mk _
+
+@[simp] lemma diskTail_cons {n : ℕ} (x : Disk n) (t : unitInterval) :
+    diskTail (diskCons x t) = x := by
+  apply Subtype.ext
+  simp only [diskTail,diskCons,Fin.tail_cons]
+
+@[simp] lemma diskTime_cons {n : ℕ} (x : Disk n) (t : unitInterval) :
+    diskTime (diskCons x t) = t := by
+  apply Subtype.ext
+  simp only [diskTime,diskCons,Fin.cons_zero]
+  ring
+
+lemma sphere_iff_coord {n : ℕ} (x : Disk n) :
+    x.1 ∈ sphere 0 1 ↔ ∃ i, |x.1 i| = 1 := by
+  rw [sphere_pi (0 : Fin n → ℝ) (Or.inl (by norm_num))]
+  simp only [Set.mem_inter_iff,Set.mem_iUnion,Set.mem_preimage,Function.eval,
+    Pi.zero_apply,mem_sphere_zero_iff_norm,Real.norm_eq_abs,and_iff_left x.2]
+
+lemma cons_mem_sphere_of_boundary {n : ℕ} (x : Sphere n) (t : unitInterval) :
+    (diskCons (boundary n x) t).1 ∈ sphere 0 1 := by
+  obtain ⟨i,hi⟩ := (sphere_iff_coord (boundary n x)).mp x.2
+  exact (sphere_iff_coord _).mpr ⟨i.succ,hi⟩
+
+lemma cons_zero_mem_sphere {n : ℕ} (x : Disk n) :
+    (diskCons x 0).1 ∈ sphere 0 1 := by
+  apply (sphere_iff_coord _).mpr
+  exact ⟨0,by norm_num [diskCons]⟩
+
+lemma cons_one_mem_sphere {n : ℕ} (x : Disk n) :
+    (diskCons x 1).1 ∈ sphere 0 1 := by
+  apply (sphere_iff_coord _).mpr
+  exact ⟨0,by norm_num [diskCons]⟩
+
+lemma sphere_split {n : ℕ} (x : Sphere (n+1)) :
+    x.1 0 = -1 ∨ x.1 0 = 1 ∨ (diskTail (boundary (n+1) x)).1 ∈ sphere 0 1 := by
+  obtain ⟨i,hi⟩ := (sphere_iff_coord (boundary (n+1) x)).mp x.2
+  refine Fin.cases ?_ (fun i hi => ?_) i hi
+  · intro h
+    rcases abs_eq (by norm_num : (0:ℝ) ≤ 1) |>.mp h with h | h
+    · exact Or.inr (Or.inl h)
+    · exact Or.inl h
+  · exact Or.inr (Or.inr ((sphere_iff_coord _).mpr ⟨i,hi⟩))
+
+/-- Finite closed pasting, in a form usable for the three cylinder faces. -/
+lemma continuous_liftCover {A : Type u} {Y : Type v} {ι : Type w}
+    [TopologicalSpace A] [TopologicalSpace Y] [Finite ι]
+    (S : ι → Set A) (f : ∀ i, C(S i,Y))
+    (hcompat : ∀ i j x (hi : x ∈ S i) (hj : x ∈ S j), f i ⟨x,hi⟩ = f j ⟨x,hj⟩)
+    (hcover : ⋃ i, S i = Set.univ) (hclosed : ∀ i, IsClosed (S i)) :
+    Continuous (Set.liftCover S (fun i => f i) hcompat hcover) := by
+  rw [continuous_iff_isClosed]
+  intro D hD
+  rw [Set.preimage_liftCover]
+  exact isClosed_iUnion_of_finite fun i => (hclosed i).isClosedMap_subtype_val _ (hD.preimage (f i).continuous)
+
+def cylinderFace (n : ℕ) : Option Bool → Set (Sphere (n+1))
+  | none => {x | (diskTail (boundary (n+1) x)).1 ∈ sphere 0 1}
+  | some false => {x | x.1 0 = -1}
+  | some true => {x | x.1 0 = 1}
+
+lemma cylinderFace_closed (n : ℕ) (i : Option Bool) : IsClosed (cylinderFace n i) := by
+  cases i with
+  | none =>
+    exact isClosed_sphere.preimage
+      (continuous_subtype_val.comp (continuous_diskTail.comp (continuous_boundary (n+1))))
+  | some b =>
+    cases b <;>
+      exact isClosed_eq ((continuous_apply 0).comp continuous_subtype_val) continuous_const
+
+lemma cylinderFace_cover (n : ℕ) : ⋃ i, cylinderFace n i = Set.univ := by
+  apply Set.eq_univ_of_forall
+  intro x
+  rcases sphere_split x with h | h | h
+  · exact Set.mem_iUnion.mpr ⟨some false,h⟩
+  · exact Set.mem_iUnion.mpr ⟨some true,h⟩
+  · exact Set.mem_iUnion.mpr ⟨none,h⟩
+
+variable {Y : Type u} [TopologicalSpace Y]
+
+def pathEndpoint : C(C(unitInterval,Y), Y × Y) :=
+  ⟨fun q => (q 0,q 1), (continuous_eval_const 0).prodMk (continuous_eval_const 1)⟩
+
+section CylinderMap
+variable {n : ℕ} (a : C(Sphere n,C(unitInterval,Y))) (b : C(Disk n,Y × Y))
+
+def faceTail (i : Option Bool) : C(cylinderFace n i,Disk n) :=
+  ⟨fun x => diskTail (boundary (n+1) x.1),
+    continuous_diskTail.comp ((continuous_boundary (n+1)).comp continuous_subtype_val)⟩
+
+def faceSphere : C(cylinderFace n none,Sphere n) :=
+  ⟨fun x => ⟨(faceTail none x).1,x.2⟩, (continuous_subtype_val.comp (faceTail none).continuous).subtype_mk _⟩
+
+def faceTime (i : Option Bool) : C(cylinderFace n i,unitInterval) :=
+  ⟨fun x => diskTime (boundary (n+1) x.1),
+    continuous_diskTime.comp ((continuous_boundary (n+1)).comp continuous_subtype_val)⟩
+
+def faceMap : ∀ i : Option Bool, C(cylinderFace n i,Y)
+  | none => ⟨fun x => a (faceSphere x) (faceTime none x),
+      continuous_eval.comp ((a.continuous.comp faceSphere.continuous).prodMk (faceTime none).continuous)⟩
+  | some false => ⟨fun x => (b (faceTail (some false) x)).1,
+      continuous_fst.comp (b.continuous.comp (faceTail (some false)).continuous)⟩
+  | some true => ⟨fun x => (b (faceTail (some true) x)).2,
+      continuous_snd.comp (b.continuous.comp (faceTail (some true)).continuous)⟩
+
+lemma faceTime_eq_zero (x : Sphere (n+1)) (h : x.1 0 = -1) :
+    diskTime (boundary (n+1) x) = 0 := by
+  apply Subtype.ext
+  change (x.1 0+1)/2 = 0
+  rw [h]
+  norm_num
+
+lemma faceTime_eq_one (x : Sphere (n+1)) (h : x.1 0 = 1) :
+    diskTime (boundary (n+1) x) = 1 := by
+  apply Subtype.ext
+  change (x.1 0+1)/2 = 1
+  rw [h]
+  norm_num
+
+variable (h : ∀ x, pathEndpoint (a x) = b (boundary n x))
+
+include h in
+lemma faceMap_compat (i j : Option Bool) (x : Sphere (n+1))
+    (hi : x ∈ cylinderFace n i) (hj : x ∈ cylinderFace n j) :
+    faceMap a b i ⟨x,hi⟩ = faceMap a b j ⟨x,hj⟩ := by
+  have left (hs : x ∈ cylinderFace n none) (h0 : x.1 0 = -1) :
+      faceMap a b none ⟨x,hs⟩ = (b (diskTail (boundary (n+1) x))).1 := by
+    change a (faceSphere ⟨x,hs⟩) (diskTime (boundary (n+1) x)) = _
+    rw [faceTime_eq_zero x h0]
+    exact congrArg Prod.fst (h (faceSphere ⟨x,hs⟩))
+  have right (hs : x ∈ cylinderFace n none) (h1 : x.1 0 = 1) :
+      faceMap a b none ⟨x,hs⟩ = (b (diskTail (boundary (n+1) x))).2 := by
+    change a (faceSphere ⟨x,hs⟩) (diskTime (boundary (n+1) x)) = _
+    rw [faceTime_eq_one x h1]
+    exact congrArg Prod.snd (h (faceSphere ⟨x,hs⟩))
+  cases i with
+  | none =>
+    cases j with
+    | none => rfl
+    | some c => cases c; exact left hi hj; exact right hi hj
+  | some c =>
+    cases c
+    · cases j with
+      | none => exact (left hj hi).symm
+      | some d =>
+        cases d
+        · rfl
+        · have := hi.symm.trans hj; norm_num at this
+    · cases j with
+      | none => exact (right hj hi).symm
+      | some d =>
+        cases d
+        · have := hi.symm.trans hj; norm_num at this
+        · rfl
+
+def cylinderBoundaryMap : C(Sphere (n+1),Y) :=
+  ⟨Set.liftCover (cylinderFace n) (fun i => faceMap a b i)
+    (faceMap_compat a b h) (cylinderFace_cover n),
+    continuous_liftCover _ _ _ _ (cylinderFace_closed n)⟩
+
+lemma cylinderBoundaryMap_face (i : Option Bool) (x : cylinderFace n i) :
+    cylinderBoundaryMap a b h x.1 = faceMap a b i x :=
+  by
+    apply Set.liftCover_coe (S := cylinderFace n) (f := fun i => faceMap a b i)
+      (hf := faceMap_compat a b h) (hS := cylinderFace_cover n)
+
+end CylinderMap
+
+/-- A disk filling extends the three compatible boundary faces of a cylinder. -/
+theorem pathEndpoint_RLP (hY : SphereFillable Y) : DiskRLP (@pathEndpoint Y _) := by
+  intro n a b h
+  obtain ⟨F,hF⟩ := hY (n+1) (cylinderBoundaryMap a b h)
+  let e : C(Disk n,C(unitInterval,Y)) :=
+    (F.comp ⟨fun q : Disk n × unitInterval => diskCons q.1 q.2,continuous_diskCons⟩).curry
+  refine ⟨e,?_,?_⟩
+  · intro x
+    apply ContinuousMap.ext
+    intro t
+    let s : Sphere (n+1) := ⟨_,cons_mem_sphere_of_boundary x t⟩
+    have hs : s ∈ cylinderFace n none := by
+      change (diskTail (diskCons (boundary n x) t)).1 ∈ sphere 0 1
+      rw [diskTail_cons]
+      exact x.2
+    change F (diskCons (boundary n x) t) = a x t
+    rw [show diskCons (boundary n x) t = boundary (n+1) s from rfl,hF,
+      cylinderBoundaryMap_face a b h none ⟨s,hs⟩]
+    change a (faceSphere ⟨s,hs⟩) (diskTime (diskCons (boundary n x) t)) = a x t
+    rw [diskTime_cons]
+    congr 1
+  · intro x
+    apply Prod.ext
+    · let s : Sphere (n+1) := ⟨_,cons_zero_mem_sphere x⟩
+      have hs : s ∈ cylinderFace n (some false) := by
+        change (diskCons x 0).1 0 = -1
+        norm_num [diskCons]
+      change F (diskCons x 0) = (b x).1
+      rw [show diskCons x 0 = boundary (n+1) s from rfl,hF,
+        cylinderBoundaryMap_face a b h (some false) ⟨s,hs⟩]
+      change (b (diskTail (diskCons x 0))).1 = (b x).1
+      rw [diskTail_cons]
+    · let s : Sphere (n+1) := ⟨_,cons_one_mem_sphere x⟩
+      have hs : s ∈ cylinderFace n (some true) := by
+        change (diskCons x 1).1 0 = 1
+        norm_num [diskCons]
+      change F (diskCons x 1) = (b x).2
+      rw [show diskCons x 1 = boundary (n+1) s from rfl,hF,
+        cylinderBoundaryMap_face a b h (some true) ⟨s,hs⟩]
+      change (b (diskTail (diskCons x 1))).2 = (b x).2
+      rw [diskTail_cons]
+
+theorem contractible_of_sphereFillable {Z : Type u} [TopologicalSpace Z] [T2Space Z]
+    [Nonempty Z] [CWComplex (Set.univ : Set Z)] (hZ : SphereFillable Z) :
+    ContractibleSpace Z := by
+  classical
+  let z₀ : Z := Classical.choice ‹Nonempty Z›
+  let : Nonempty C(unitInterval,Z) := ⟨ContinuousMap.const _ z₀⟩
+  let f : C(Z,Z × Z) := ⟨fun z => (z,z₀),continuous_id.prodMk continuous_const⟩
+  obtain ⟨g,hg⟩ := exists_lift (pathEndpoint_RLP hZ) f
+  apply (contractible_iff_id_nullhomotopic Z).mpr
+  refine ⟨z₀,⟨?_⟩⟩
+  refine ContinuousMap.Homotopy.mk ⟨fun q => g q.2 q.1,
+    continuous_eval.comp ((g.continuous.comp continuous_snd).prodMk continuous_fst)⟩ ?_ ?_
+  · intro z
+    exact congrArg Prod.fst (hg z)
+  · intro z
+    exact congrArg Prod.snd (hg z)
+
+end
+end GroupRingTopology.Cellular
+
+end OAI
diff --git a/lean/OAI/Algebra/GroupRing/PartitionEntropy.lean b/lean/OAI/Algebra/GroupRing/PartitionEntropy.lean
new file mode 100644
index 0000000000000000000000000000000000000000..b207d0119636f1ab76a63f472f81fd67bdb2a944
--- /dev/null
+++ b/lean/OAI/Algebra/GroupRing/PartitionEntropy.lean
@@ -0,0 +1,412 @@
+import Mathlib
+import OAI.Algebra.GroupRing.RealizationTransport
+
+namespace OAI
+
+noncomputable section
+
+namespace TorsionFreeZeroDivisors.PartitionEntropy
+open scoped Classical BigOperators
+open StageEntropy BlockAlignment ComparedBlocks RepeatedBlocks ChainStageLabels WordEstimate StagePartition
+local instance : DecidableEq Types.Letter := Classical.decEq _
+variable {C E VA VB TA TB : Type} [Fintype C] [Fintype VA] [Fintype VB]
+  [Fintype TA] [Fintype TB]
+variable (s : ℝ) (hs : 0<s) (len m : C → ℕ) (side : C → Bool) (j : ℕ)
+variable (firstA lastA : CA m side j → VA) (firstB lastB : CB m side j → VB)
+  (outA : TA → Finset Types.Letter) (outB : TB → Finset Types.Letter)
+  (pinA : VA → Option TA) (pinB : VB → Option TB)
+local notation "SA" => sideA len m side j firstA lastA outA pinA
+local notation "SB" => sideB len m side j firstB lastB outB pinB
+
+/-- A complete literal-stage first moment, with its signed vertex exponent
+and the source denominator, without stage independence. -/
+theorem mean_bound (cmp : Comparisons (E := E) (traversalLength len m))
+    (d : Underlying s len → ℤ) (err K Q rep : ℕ)
+    (hlarge : ∀ i, 3002 ≤ height s len i)
+    (hscale : ∀ i, s+1200 ≤ 2*(height s len i : ℝ))
+    (hreduced : ∀ x e, cmp.side x = some e →
+      (x.1.1,x.2.val) ≠ ((cmp.pairing.partner x).1.1,(cmp.pairing.partner x).2.val))
+    (hn : 0<TypedGraphs.size rep) (hr : 0<StageDenominator.denominator K rep)
+    (hA : TwoSideStage.Conditions SA (TypedGraphs.size rep) (129/16513)
+      (3*GirthAsymptotics.L (TypedGraphs.size rep)) 132 (StageDenominator.denominator K rep))
+    (hB : TwoSideStage.Conditions SB (TypedGraphs.size rep) (129/16513)
+      (3*GirthAsymptotics.L (TypedGraphs.size rep)) 132 (StageDenominator.denominator K rep))
+    (hlen : ∀ c,0<len c) (hQ : Fintype.card (CA m side j)+Fintype.card (CB m side j)≤Q)
+    (hE : (SA).edges+(SB).edges ≤ K*GirthAsymptotics.L (TypedGraphs.size rep)) :
+    TwoSideMean.mean (((SA).samples (3*GirthAsymptotics.L (TypedGraphs.size rep))) ×ˢ
+      ((SB).samples (3*GirthAsymptotics.L (TypedGraphs.size rep))))
+      (TwoSideStage.count SA SB (fullWords s len m j cmp d)
+        (restrictA len m side j) (restrictB len m side j)) ≤
+      Real.exp (((((SA).freeMarks+(SB).freeMarks:ℕ):ℝ)-
+        (Fintype.card (CA m side j)+Fintype.card (CB m side j):ℕ))*Real.log (TypedGraphs.size rep) +
+          labelCost s hs len m cmp err d j + looseCost s len err + StageDenominator.error K Q rep) := by
+  have hm := StagePartition.mean_bound s hs len m side j firstA lastA firstB lastB
+    outA outB pinA pinB cmp d err hlarge hscale hreduced
+    (TypedGraphs.size rep) (129/16513) _ 132 _ hA hB
+  have hc := StageDenominator.joint_cost_bound SA SB K Q rep hn hr
+    (fun c => hlen c.val) (fun c => hlen c.val) hQ hE
+  apply hm.trans
+  apply (mul_le_mul_of_nonneg_right hc (Real.exp_pos _).le).trans_eq
+  rw [← Real.exp_add]
+  congr 1
+  unfold labelCost looseCost
+  change (((((SA).freeMarks+(SB).freeMarks:ℕ):ℝ)-
+    (Fintype.card (CA m side j)+Fintype.card (CB m side j):ℕ))*Real.log (TypedGraphs.size rep)+
+      StageDenominator.error K Q rep) + _ = _
+  ring
+
+end TorsionFreeZeroDivisors.PartitionEntropy
+
+namespace TorsionFreeZeroDivisors.SideRestriction
+open scoped Classical
+open PortSubdivision
+variable {V D : Type*} (Γ : PortGraph V D) (side : V → Bool)
+    (hs : ∀ d,side (Γ.origin (Γ.reverse d))=side (Γ.origin d)) (b : Bool)
+
+abbrev Vertex := {v : V // side v=b}
+abbrev Dart := {d : D // side (Γ.origin d)=b}
+def graph : PortGraph (Vertex side b) (Dart Γ side b) where
+  origin d := ⟨Γ.origin d.val,d.property⟩
+  reverse d := ⟨Γ.reverse d.val,(hs d.val).trans d.property⟩
+  reverse_reverse d := Subtype.ext (Γ.reverse_reverse d.val)
+  reverse_ne d h := Γ.reverse_ne d.val (congrArg Subtype.val h)
+
+variable {QV QD : Type*} (Q : PortGraph QV QD) (fv : QV ↪ V) (fd : QD ↪ D)
+    (ho : ∀ d,fv (Q.origin d)=Γ.origin (fd d))
+    (hr : ∀ d,fd (Q.reverse d)=Γ.reverse (fd d))
+    (hf : ∀ v,side (fv v)=b)
+
+def vertex : QV ↪ Vertex side b := ⟨fun v => ⟨fv v,hf v⟩,fun _ _ h => fv.injective (congrArg Subtype.val h)⟩
+def dart : QD ↪ Dart Γ side b :=
+  ⟨fun d => ⟨fd d,by rw [←ho]; exact hf _⟩,fun _ _ h => fd.injective (congrArg Subtype.val h)⟩
+
+lemma origin_map (d : QD) : vertex side b fv hf (Q.origin d) =
+    (graph Γ side hs b).origin (dart Γ side b Q fv fd ho hf d) := by
+  exact Subtype.ext (ho d)
+include hr in
+lemma reverse_map (d : QD) : dart Γ side b Q fv fd ho hf (Q.reverse d) =
+    (graph Γ side hs b).reverse (dart Γ side b Q fv fd ho hf d) := by
+  exact Subtype.ext (hr d)
+
+variable [Fintype V] [Fintype D] [Fintype QV] [Fintype QD]
+    {TV T : Type*} [Fintype TV] [Fintype T]
+    (label : D → T) (outgoing : TV → Finset T) (pin : Vertex side b → Option TV)
+    (bar : T → T) (r : ConditionedMatchings.Matching (PatternEmbeddings.label outgoing) bar)
+
+/-- Restrict a realized prescribed side to an injectively immersed subgraph
+whose target vertices really lie on that side. -/
+def embedding (e : RealizationTransport.Embedding (graph Γ side hs b) (fun d => label d.val)
+    outgoing pin bar r) (pin' : QV → Option TV)
+    (hp : ∀ v y,pin' v=some y → pin (vertex side b fv hf v)=some y) :
+    RealizationTransport.Embedding Q (label ∘ fd) outgoing pin' bar r :=
+  RealizationTransport.restrict e Q (vertex side b fv hf) (dart Γ side b Q fv fd ho hf)
+    (origin_map Γ side hs b Q fv fd ho hf) (reverse_map Γ side hs b Q fv fd ho hr hf) pin' hp
+
+end TorsionFreeZeroDivisors.SideRestriction
+
+namespace TorsionFreeZeroDivisors.StageSideEmbedding
+open scoped Classical BigOperators
+open ChainSubdivision
+variable {C V : Type*} (len m : C → ℕ) (j : ℕ) (side : C → Bool) (vside : V → Bool)
+    (first last : {c // j < m c} → V)
+    (hf : ∀ c,vside (first c)=side c.val) (hl : ∀ c,vside (last c)=side c.val) (b : Bool)
+
+abbrev Chain := {c : C // j < m c ∧ side c=b}
+abbrev Vertex := {v : V // vside v=b}
+abbrev length : Chain m j side b → ℕ := fun c => len c.val
+
+def firstPoint (c : Chain m j side b) : Vertex vside b :=
+  ⟨first ⟨c.val,c.property.1⟩,(hf _).trans c.property.2⟩
+def lastPoint (c : Chain m j side b) : Vertex vside b :=
+  ⟨last ⟨c.val,c.property.1⟩,(hl _).trans c.property.2⟩
+abbrev graph := ChainSubdivision.graph (length len m j side b)
+  (firstPoint m j side vside first hf b) (lastPoint m j side vside last hl b)
+local notation "Q" => graph len m j side vside first last hf hl b
+local notation "P" => ChainSubdivision.graph (StageExpectation.activeLen len m j) first last
+
+def vertex : ChainSubdivision.Vertex (length len m j side b) (V := Vertex vside b) →
+    ChainSubdivision.Vertex (StageExpectation.activeLen len m j) (V := V)
+  | .inl v => .inl v.val
+  | .inr ⟨c,i⟩ => .inr ⟨⟨c.val,c.property.1⟩,i⟩
+def dart : ChainSubdivision.Dart (length len m j side b) →
+    ChainSubdivision.Dart (StageExpectation.activeLen len m j) :=
+  fun d => (⟨⟨d.1.1.val,d.1.1.property.1⟩,d.1.2⟩,d.2)
+
+lemma vertex_injective : Function.Injective (vertex len m j side vside b) := by
+  intro v w h
+  cases v with
+  | inl v =>
+    cases w with
+    | inl w => exact congrArg Sum.inl (Subtype.ext (Sum.inl.inj h))
+    | inr w => cases h
+  | inr v =>
+    cases w with
+    | inl w => cases h
+    | inr w =>
+      rcases v with ⟨c,i⟩
+      rcases w with ⟨d,k⟩
+      have h' := Sum.inr.inj h
+      have hcd : c=d := Subtype.ext (congrArg (fun x => x.1.val) h')
+      cases hcd
+      have hik : i=k := eq_of_heq (Sigma.mk.inj_iff.mp h').2
+      cases hik
+      rfl
+
+lemma dart_injective : Function.Injective (dart len m j side b) := by
+  rintro ⟨⟨c,i⟩,r⟩ ⟨⟨d,k⟩,s⟩ h
+  have hrs := congrArg Prod.snd h
+  cases hrs
+  have h' := congrArg Prod.fst h
+  have hcd : c=d := Subtype.ext (congrArg (fun x => x.1.val) h')
+  cases hcd
+  have hik : i=k := eq_of_heq (Sigma.mk.inj_iff.mp h').2
+  cases hik
+  rfl
+
+lemma point_map (c : Chain m j side b) (k : Fin (length len m j side b c+1)) :
+    vertex len m j side vside b
+      (point (length len m j side b) (firstPoint m j side vside first hf b)
+        (lastPoint m j side vside last hl b) c k) =
+    point (StageExpectation.activeLen len m j) first last ⟨c.val,c.property.1⟩ k := by
+  unfold point
+  split_ifs <;> rfl
+
+lemma origin_map (d : ChainSubdivision.Dart (length len m j side b)) :
+    vertex len m j side vside b ((Q).origin d) = (P).origin (dart len m j side b d) := by
+  rcases d with ⟨⟨c,i⟩,r⟩
+  cases r
+  · simpa only [dart,origin_forward] using
+      point_map len m j side vside first last hf hl b c ⟨i.val,by have h:=i.isLt; omega⟩
+  · simpa only [dart,origin_backward] using
+      point_map len m j side vside first last hf hl b c ⟨i.val+1,by have h:=i.isLt; omega⟩
+
+lemma reverse_map (d : ChainSubdivision.Dart (length len m j side b)) :
+    dart len m j side b ((Q).reverse d) = (P).reverse (dart len m j side b d) := rfl
+
+/-- Restriction of a full stage string to this prescribed side. -/
+def restrictWord (F : ComparedBlocks.Position (StageExpectation.activeLen len m j) → WordEstimate.Letter) :
+    ComparedBlocks.Position (length len m j side b) → WordEstimate.Letter :=
+  fun x => F ⟨⟨x.1.val,x.1.property.1⟩,x.2⟩
+
+lemma label_map (F : ComparedBlocks.Position (StageExpectation.activeLen len m j) → WordEstimate.Letter)
+    (d : ChainSubdivision.Dart (length len m j side b)) :
+    ChainRealization.label (length len m j side b)
+      (StageExpectation.readWord (length len m j side b) (restrictWord len m j side b F)) d =
+    ChainRealization.label (StageExpectation.activeLen len m j)
+      (StageExpectation.readWord (StageExpectation.activeLen len m j) F) (dart len m j side b d) := by
+  rcases d with ⟨⟨c,i⟩,r⟩
+  cases r <;> rfl
+
+variable [Fintype C] [Fintype V]
+
+/-- Exact partitions; no isolated vertices from inactive stages are introduced. -/
+lemma chain_card : Fintype.card (Chain m j side true)+Fintype.card (Chain m j side false)=
+    Fintype.card {c // j < m c} := by
+  let f : Chain m j side true ⊕ Chain m j side false → {c // j < m c} :=
+    Sum.elim (fun c => ⟨c.val,c.property.1⟩) (fun c => ⟨c.val,c.property.1⟩)
+  have h : Function.Bijective f := by
+    constructor
+    · intro x y hxy
+      cases x with
+      | inl x =>
+        cases y with
+        | inl y => exact congrArg Sum.inl (Subtype.ext (congrArg (fun z : {c // j < m c} => z.val) hxy))
+        | inr y =>
+          have hv : x.val=y.val := congrArg Subtype.val hxy
+          have ht := x.property.2
+          rw [hv,y.property.2] at ht
+          cases ht
+      | inr x =>
+        cases y with
+        | inl y =>
+          have hv : x.val=y.val := congrArg Subtype.val hxy
+          have ht := x.property.2
+          rw [hv,y.property.2] at ht
+          cases ht
+        | inr y => exact congrArg Sum.inr (Subtype.ext (congrArg (fun z : {c // j < m c} => z.val) hxy))
+    · rintro ⟨c,hc⟩
+      cases hh : side c with
+      | true => exact ⟨.inl ⟨c,hc,hh⟩,rfl⟩
+      | false => exact ⟨.inr ⟨c,hc,hh⟩,rfl⟩
+  simpa only [Fintype.card_sum] using Fintype.card_congr (Equiv.ofBijective f h)
+
+lemma vertex_card : Fintype.card (Vertex vside true)+Fintype.card (Vertex vside false)=Fintype.card V := by
+  have h := Fintype.card_subtype_compl (fun v : V => vside v=true)
+  have he : {v : V // ¬vside v=true} ≃ Vertex vside false :=
+    Equiv.subtypeEquivRight (fun v => by cases vside v <;> simp)
+  rw [Fintype.card_congr he] at h
+  have heq : Fintype.card {v : V // vside v=true}≤Fintype.card V := Fintype.card_le_of_injective Subtype.val Subtype.val_injective
+  change Fintype.card {v : V // vside v=true}+_= _
+  omega
+
+end TorsionFreeZeroDivisors.StageSideEmbedding
+
+namespace TorsionFreeZeroDivisors.ChainSide
+open scoped Classical
+open Function PortSubdivision ChainSuppression DegreeTwoSuppression SuppressedMoore ChainPaths ChainIsomorphism
+variable {V D : Type*} [Fintype D] (Γ : PortGraph V D)
+    (mark : V → Prop) (h2 : ∀ v, ¬mark v → (out Γ.origin v).card=2)
+    (side : V → Bool) (hs : ∀ d,side (Γ.origin (Γ.reverse d))=side (Γ.origin d))
+local notation "F" => next Γ.reverse (turn Γ.origin mark h2)
+local notation "S" => suppressed Γ mark h2
+local notation "R" => Rep Γ mark h2
+
+def chain (c : R) : Bool := side (Γ.origin c.val.val)
+
+include hs in
+lemma next_side (d : D) : side (Γ.origin (F d))=side (Γ.origin d) := by
+  change side (Γ.origin (turn Γ.origin mark h2 (Γ.reverse d)))=side (Γ.origin d)
+  rw [turn_origin Γ.origin mark h2]
+  exact hs d
+
+include hs in
+lemma iterate_side (d : D) (i : ℕ) : side (Γ.origin (F^[i] d))=side (Γ.origin d) := by
+  induction i with
+  | zero => rfl
+  | succ i ih => rw [iterate_succ_apply',next_side Γ mark h2 side hs,ih]
+
+include hs in
+lemma suppressed_side (d : {d : D // turn Γ.origin mark h2 d=d}) :
+    side ((S).origin ((S).reverse d))=side ((S).origin d) := by
+  change side (Γ.origin ((S).reverse d).val)=side (Γ.origin d.val)
+  have he := chain_last Γ mark h2 d
+  rw [last_iterChain] at he
+  rw [←he,hs]
+  exact iterate_side Γ mark h2 side hs d.val _
+
+lemma first_side (c : R) : side (ChainIsomorphism.first Γ mark h2 c).val=chain Γ mark h2 side c := rfl
+include hs in
+lemma last_side (c : R) : side (ChainIsomorphism.last Γ mark h2 c).val=chain Γ mark h2 side c :=
+  suppressed_side Γ mark h2 side hs c.val
+
+variable {P : Type*} [Fintype P]
+    (paths : P → List {d : D // turn Γ.origin mark h2 d=d}) (j : ℕ)
+local notation "W" => StageSubgraphs.ActiveV (S) (ListStageExponents.mult (S) paths) j
+local notation "A" => ChainActiveStages.ActiveChain Γ mark h2 paths j
+
+def vertex (w : W) : Bool := side w.val
+
+lemma active_first (c : A) : vertex Γ mark h2 side paths j (ChainActiveStages.first Γ mark h2 paths j c)=
+    chain Γ mark h2 side c.val := rfl
+include hs in
+lemma active_last (c : A) : vertex Γ mark h2 side paths j (ChainActiveStages.last Γ mark h2 paths j c)=
+    chain Γ mark h2 side c.val := last_side Γ mark h2 side hs c.val
+
+include hs in
+lemma stage_internal (c : A) (i : Fin (ChainStageEmbedding.length Γ mark h2 paths j c-1)) :
+    side (ChainStageEmbedding.vertexMap Γ mark h2 paths j (.inr ⟨c,i⟩))=chain Γ mark h2 side c.val := by
+  exact iterate_side Γ mark h2 side hs c.val.val.val (i.val+1)
+
+end TorsionFreeZeroDivisors.ChainSide
+
+namespace TorsionFreeZeroDivisors.ActualSideRealization
+open scoped Classical
+open Function PortSubdivision ChainSuppression DegreeTwoSuppression SuppressedMoore ChainPaths
+open ChainIsomorphism ChainChunkTransport ChainMultiplicity ChunkComparisons StageSubgraphs
+variable {V D : Type} [Fintype D] (Γ : PortGraph V D)
+    (mark : V → Prop) (h2 : ∀ v, ¬mark v → (out Γ.origin v).card=2)
+    (side : V → Bool) (hs : ∀ d,side (Γ.origin (Γ.reverse d))=side (Γ.origin d))
+    {P : Type} [Fintype P] (paths : P → List {d : D // turn Γ.origin mark h2 d=d}) (j : ℕ) (b : Bool)
+local notation "S" => suppressed Γ mark h2
+local notation "R" => Rep Γ mark h2
+local notation "m" => ChunkComparisons.multiplicity (color Γ mark h2 paths)
+local notation "len" => repLength Γ mark h2
+local notation "cs" => ChainSide.chain Γ mark h2 side
+local notation "vs" => ChainSide.vertex Γ mark h2 side paths j
+local notation "first" => ChainActiveStages.first Γ mark h2 paths j
+local notation "last" => ChainActiveStages.last Γ mark h2 paths j
+local notation "hf" => ChainSide.active_first Γ mark h2 side paths j
+local notation "hl" => ChainSide.active_last Γ mark h2 side hs paths j
+local notation "W" => ActiveV (S) (ListStageExponents.mult (S) paths) j
+
+abbrev length := StageSideEmbedding.length len m j cs b
+abbrev Marked := StageSideEmbedding.Vertex vs b
+abbrev graph := StageSideEmbedding.graph len m j cs vs first last hf hl b
+local notation "Q" => graph Γ mark h2 side hs paths j b
+local notation "l" => length Γ mark h2 side paths j b
+
+def vertexMap : ChainSubdivision.Vertex l (V := Marked Γ mark h2 side paths j b) → V :=
+  ChainStageEmbedding.vertexMap Γ mark h2 paths j ∘ StageSideEmbedding.vertex len m j cs vs b
+
+def dartMap : ChainSubdivision.Dart l → D :=
+  ChainStageEmbedding.dartMap Γ mark h2 paths j ∘ StageSideEmbedding.dart len m j cs b
+
+lemma vertex_injective : Injective (vertexMap Γ mark h2 side paths j b) :=
+  (ChainStageEmbedding.vertexMap_injective Γ mark h2 paths j).comp
+    (StageSideEmbedding.vertex_injective len m j cs vs b)
+lemma dart_injective : Injective (dartMap Γ mark h2 side paths j b) :=
+  (ChainStageEmbedding.dartMap_injective Γ mark h2 paths j).comp
+    (StageSideEmbedding.dart_injective len m j cs b)
+
+lemma origin_map (d : ChainSubdivision.Dart l) :
+    vertexMap Γ mark h2 side paths j b ((Q).origin d)=Γ.origin (dartMap Γ mark h2 side paths j b d) := by
+  unfold vertexMap dartMap
+  dsimp only [Function.comp_apply]
+  rw [StageSideEmbedding.origin_map len m j cs vs first last hf hl b]
+  exact ChainStageEmbedding.origin_map Γ mark h2 paths j _
+
+lemma reverse_map (d : ChainSubdivision.Dart l) :
+    dartMap Γ mark h2 side paths j b ((Q).reverse d)=Γ.reverse (dartMap Γ mark h2 side paths j b d) := by
+  unfold dartMap
+  dsimp only [Function.comp_apply]
+  rw [StageSideEmbedding.reverse_map len m j cs vs first last hf hl b]
+  exact ChainStageEmbedding.reverse_map Γ mark h2 paths j _
+
+include hs in
+lemma vertex_side (v : ChainSubdivision.Vertex l (V := Marked Γ mark h2 side paths j b)) :
+    side (vertexMap Γ mark h2 side paths j b v)=b := by
+  cases v with
+  | inl v => exact v.property
+  | inr v =>
+    rcases v with ⟨c,i⟩
+    exact (ChainSide.stage_internal Γ mark h2 side hs paths j ⟨c.val,c.property.1⟩ i).trans c.property.2
+
+def word (label : D → Types.Letter) : ComparedBlocks.Position l → WordEstimate.Letter :=
+  StageSideEmbedding.restrictWord len m j cs b (ActualStageRealization.word Γ mark h2 paths j label)
+
+lemma label_eq (label : D → Types.Letter) (hlabel : ∀ d,label (Γ.reverse d)=Types.inverse (label d))
+    (d : ChainSubdivision.Dart l) :
+    ChainRealization.label l (StageExpectation.readWord l (word Γ mark h2 side paths j b label)) d =
+      label (dartMap Γ mark h2 side paths j b d) := by
+  rw [show word Γ mark h2 side paths j b label = StageSideEmbedding.restrictWord len m j cs b
+    (ActualStageRealization.word Γ mark h2 paths j label) from rfl,
+    StageSideEmbedding.label_map]
+  exact ActualStageRealization.label_eq Γ mark h2 paths j label hlabel _
+
+variable [Fintype V] {TV : Type} [Fintype TV]
+    (label : D → Types.Letter) (outgoing : TV → Finset Types.Letter)
+    (pin : SideRestriction.Vertex side b → Option TV)
+    (r : ConditionedMatchings.Matching (PatternEmbeddings.label outgoing) Types.inverse)
+
+/-- The literal realization of this prescribed-side active stage follows from
+an actual embedding of the original prescribed side. All labels stay the
+restrictions of ONE global word. -/
+def embedding (e : RealizationTransport.Embedding (SideRestriction.graph Γ side hs b)
+      (fun d => label d.val) outgoing pin Types.inverse r)
+    (hlabel : ∀ d,label (Γ.reverse d)=Types.inverse (label d))
+    (pin' : Marked Γ mark h2 side paths j b → Option TV)
+    (hp : ∀ v y,pin' v=some y → pin ⟨v.val.val,v.property⟩=some y) :
+    RealizationTransport.Embedding (Q)
+      (ChainRealization.label l (StageExpectation.readWord l (word Γ mark h2 side paths j b label)))
+      outgoing (ChainRealization.pin l pin') Types.inverse r := by
+  let fv : ChainSubdivision.Vertex l ↪ V :=
+    ⟨vertexMap Γ mark h2 side paths j b,vertex_injective Γ mark h2 side paths j b⟩
+  let fd : ChainSubdivision.Dart l ↪ D :=
+    ⟨dartMap Γ mark h2 side paths j b,dart_injective Γ mark h2 side paths j b⟩
+  have hp' : ∀ v y, ChainRealization.pin l pin' v=some y →
+      pin (SideRestriction.vertex side b fv (vertex_side Γ mark h2 side hs paths j b) v)=some y := by
+    intro v y hy
+    cases v with
+    | inl v => exact hp v y hy
+    | inr v => cases hy
+  exact RealizationTransport.congrLabel
+    (SideRestriction.embedding Γ side hs b (Q) fv fd
+      (origin_map Γ mark h2 side hs paths j b) (reverse_map Γ mark h2 side hs paths j b)
+      (vertex_side Γ mark h2 side hs paths j b) label outgoing pin Types.inverse r e _ hp') _
+    (label_eq Γ mark h2 side paths j b label hlabel)
+
+end TorsionFreeZeroDivisors.ActualSideRealization
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/GroupRing/Path.lean b/lean/OAI/Algebra/GroupRing/Path.lean
new file mode 100644
index 0000000000000000000000000000000000000000..b45a8b41e358e63d2ba9c65f49d1fcad7c4fa60d
--- /dev/null
+++ b/lean/OAI/Algebra/GroupRing/Path.lean
@@ -0,0 +1,380 @@
+import Mathlib
+import OAI.Algebra.GroupRing.AlgebraicPictures
+
+namespace OAI
+
+noncomputable section
+
+namespace TorsionFreeZeroDivisors.GraphPresentation.Path
+open PortSubdivision
+variable {V D : Type} {Γ : PortGraph V D} {a b : V}
+lemma join_rotation (p : Path Γ a b) (i : Fin p.darts.length)
+    (hn : (finRotate p.darts.length i).val≠0) :
+    Γ.origin (Γ.reverse (p.darts.get i))=Γ.origin (p.darts.get (finRotate p.darts.length i)) := by
+  have hi : i.val+1≠p.darts.length := by
+    intro he
+    apply hn
+    rw [ContiguousSplit.rotate_val,ite_eq_left he]
+  have hin : i.val+1<p.darts.length := by omega
+  have hj := (List.isChain_iff_getElem.mp p.chain) i.val hin
+  simpa only [List.get_eq_getElem,ContiguousSplit.rotate_val,ite_eq_right hi] using hj
+lemma end_rotation (p : Path Γ a b) (i : Fin p.darts.length)
+    (hz : (finRotate p.darts.length i).val=0) :
+    Γ.origin (Γ.reverse (p.darts.get i))=b := by
+  have hi : i.val+1=p.darts.length := by
+    rw [ContiguousSplit.rotate_val] at hz
+    split_ifs at hz with h
+    exact h
+  have hn : p.darts≠[] := List.length_pos_iff.mp (by omega)
+  have he : i.val=p.darts.length-1 := by omega
+  simpa only [List.getLast_eq_getElem,List.get_eq_getElem,he] using p.last_origin hn
+lemma first_get (p : Path Γ a b) (hn : 0<p.darts.length) : Γ.origin (p.darts.get ⟨0,hn⟩)=a := by
+  simpa only [List.head_eq_getElem,List.get_eq_getElem] using p.first_origin (List.length_pos_iff.mp hn)
+lemma closed_rotation (p : Path Γ a a) (i : Fin p.darts.length) :
+    Γ.origin (Γ.reverse (p.darts.get i))=Γ.origin (p.darts.get (finRotate p.darts.length i)) := by
+  by_cases hi : (finRotate p.darts.length i).val=0
+  · rw [p.end_rotation i hi]
+    have he : finRotate p.darts.length i=⟨0,by omega⟩ := Fin.ext hi
+    rw [he]
+    exact (p.first_get _).symm
+  · exact p.join_rotation i hi
+
+end TorsionFreeZeroDivisors.GraphPresentation.Path
+namespace TorsionFreeZeroDivisors.WordBlocks
+open scoped Classical
+open PortSubdivision GraphPresentation
+variable {V D A : Type} (Γ : PortGraph V D) (label : D→A) (inv : A→A)
+def AllClosed (ws : List (List D)) : Prop := ∀w∈ws,∃v,∃p : Path Γ v v,p.darts=w
+lemma closed_consistent (ws : List (List D)) (hc : AllClosed Γ ws) (i : Occ ws) :
+    Γ.origin (Γ.reverse (letter ws i))=Γ.origin (letter ws (BlockBoundary.rotation (lengths ws) i)) := by
+  induction ws with
+  | nil=>exact Empty.elim i
+  | cons w ws ih=>
+    cases i with
+    | inl i=>
+      obtain ⟨v,p,rfl⟩ := hc w (List.mem_cons_self)
+      exact p.closed_rotation i
+    | inr i=>exact ih (fun w hw=>hc w (List.mem_cons_of_mem _ hw)) i
+variable {x y : V} (p : Path Γ x y) (hxy : x≠y) (ws : List (List D))
+def root : Occ (p.darts::ws) := .inl ⟨0,List.length_pos_iff.mpr (fun h=>hxy (p.empty_ends h))⟩
+lemma root_begin : Γ.origin (letter (p.darts::ws) (root Γ p hxy ws))=x := p.first_get _
+lemma boundary_join (hc : AllClosed Γ ws) (i : Occ (p.darts::ws))
+    (hi : BlockBoundary.rotation (lengths (p.darts::ws)) i≠root Γ p hxy ws) :
+    Γ.origin (Γ.reverse (letter (p.darts::ws) i))=
+      Γ.origin (letter (p.darts::ws) (BlockBoundary.rotation (lengths (p.darts::ws)) i)) := by
+  cases i with
+  | inl i=>
+    exact p.join_rotation i (fun h=>hi (congrArg Sum.inl (Fin.ext h)))
+  | inr i=>exact closed_consistent Γ ws hc i
+lemma boundary_end (i : Occ (p.darts::ws))
+    (hi : BlockBoundary.rotation (lengths (p.darts::ws)) i=root Γ p hxy ws) :
+    Γ.origin (Γ.reverse (letter (p.darts::ws) i))=y := by
+  cases i with
+  | inl i=>exact p.end_rotation i (congrArg Fin.val (Sum.inl.inj hi))
+  | inr i=>cases hi
+/-- All endpoints are furnished by literal graph paths, not by equality of
+labels. Inserting the single exterior marker gives an actual finite picture. -/
+def LiftedMatching.picture (d : LiftedMatching label inv (p.darts::ws)) (hc : AllClosed Γ ws) :
+    FinitePicture.Data (O:=Option (Occ (p.darts::ws))) Γ label inv x y :=
+  FinitePicture.ofBoundary Γ label inv x y (BlockBoundary.rotation (lengths (p.darts::ws)))
+    d.partner d.involutive d.fixed_free (letter (p.darts::ws)) (root Γ p hxy ws)
+    d.compatible (boundary_join Γ p hxy ws hc) (root_begin Γ p hxy ws)
+    (boundary_end Γ p hxy ws) d.genusZero
+
+end TorsionFreeZeroDivisors.WordBlocks
+namespace TorsionFreeZeroDivisors.AlgebraicPictures
+variable {A I : Type*} (rel : I→List (A×Bool))
+open FreeGroup
+lemma quotient_direct_matching (outer : List (A×Bool))
+    (h : PresentedGroup.mk (relations rel) (mk outer)=1) :
+    ∃ts : List (Term (A:=A) (I:=I)),
+      Nonempty (WordBlocks.Matching WordPairing.inverseLetter (outer::coreWords rel ts)) := by
+  have hh : PresentedGroup.mk (relations rel) (mk (invRev outer))=1 := by
+    rw [←inv_mk,_root_.map_inv,h,inv_one]
+  obtain ⟨ts,⟨d⟩⟩ := quotient_core_matching rel (invRev outer) hh
+  exact ⟨ts,⟨by simpa only [invRev_invRev] using d⟩⟩
+end TorsionFreeZeroDivisors.AlgebraicPictures
+namespace TorsionFreeZeroDivisors.InitialPicture
+open scoped Classical
+open PortSubdivision GraphPresentation AlgebraicPictures
+variable {V D A I : Type} (Γ : PortGraph V D) (label : D→A×Bool)
+  (hl : ∀d,label (Γ.reverse d)=WordPairing.inverseLetter (label d))
+abbrev Loop := Σv,Path Γ v v
+variable (rel : I→Loop Γ)
+def relWords (i : I) : List (A×Bool) := (rel i).2.letters label
+def signedLoop (t : Term (A:=A) (I:=I)) : Loop Γ :=
+  if t.positive then rel t.index else ⟨(rel t.index).1,(rel t.index).2.reverse⟩
+include hl in
+lemma signedLoop_letters (t : Term (A:=A) (I:=I)) :
+    (signedLoop Γ rel t).2.letters label=t.core (relWords Γ label rel) := by
+  rcases t with ⟨i,b,c⟩
+  cases b
+  · exact Path.letters_reverse label hl _
+  · rfl
+def innerWords (ts : List (Term (A:=A) (I:=I))) : List (List D) :=
+  ts.map (fun t=>(signedLoop Γ rel t).2.darts)
+include hl in
+lemma innerWords_labels (ts : List (Term (A:=A) (I:=I))) :
+    (innerWords Γ rel ts).map (List.map label)=coreWords (relWords Γ label rel) ts := by
+  simp only [innerWords,coreWords,List.map_map]
+  apply List.map_congr_left
+  intro t _
+  exact signedLoop_letters Γ label hl rel t
+lemma innerWords_closed (ts : List (Term (A:=A) (I:=I))) :
+    WordBlocks.AllClosed Γ (innerWords Γ rel ts) := by
+  intro w hw
+  obtain ⟨t,_,rfl⟩ := List.mem_map.mp hw
+  exact ⟨(signedLoop Γ rel t).1,(signedLoop Γ rel t).2,rfl⟩
+variable {x y : V} (p : Path Γ x y)
+include hl in
+/-- Algebraic nullity produces an actual lifted full matching on the given
+outer path and literal signed closed relators. Empty relators are allowed. -/
+theorem lifted_matching (h : PresentedGroup.mk (relations (relWords Γ label rel))
+      (FreeGroup.mk (p.letters label))=1) :
+    ∃ts : List (Term (A:=A) (I:=I)),Nonempty
+      (WordBlocks.LiftedMatching label WordPairing.inverseLetter (p.darts::innerWords Γ rel ts)) := by
+  obtain ⟨ts,⟨d⟩⟩ := quotient_direct_matching (relWords Γ label rel) (p.letters label) h
+  refine ⟨ts,⟨WordBlocks.Matching.lift label ?_⟩⟩
+  simpa only [List.map_cons,innerWords_labels Γ label hl rel,Path.letters] using d
+include hl in
+/-- The initial finite marked certificate is derived from nullity in the
+literal graph-loop presentation. No preexisting picture, surface map, or
+asphericity hypothesis is assumed. -/
+theorem exists_picture (hxy : x≠y)
+    (h : PresentedGroup.mk (relations (relWords Γ label rel)) (FreeGroup.mk (p.letters label))=1) :
+    ∃(O : Type) (_ : Fintype O),Nonempty
+      (FinitePicture.Data (O:=O) Γ label WordPairing.inverseLetter x y) := by
+  obtain ⟨ts,⟨d⟩⟩ := lifted_matching Γ label hl rel p h
+  exact ⟨Option (WordBlocks.Occ (p.darts::innerWords Γ rel ts)),inferInstance,
+    ⟨d.picture Γ label WordPairing.inverseLetter p hxy _ (innerWords_closed Γ rel ts)⟩⟩
+
+end TorsionFreeZeroDivisors.InitialPicture
+
+namespace TorsionFreeZeroDivisors.GraphPresentation
+
+section
+open PortSubdivision
+open scoped Classical
+variable {V D : Type} (Γ : PortGraph V D)
+/-- A finite choice of routes from the same base on each graph component. -/
+structure Routes where
+  base : V→V
+  same : ∀ d,base (Γ.origin d)=base (Γ.origin (Γ.reverse d))
+  path : ∀ v,Path Γ (base v) v
+
+variable {S : Type*} (letters : D→FreeGroup S) (R : Routes Γ)
+def word (v : V) : FreeGroup S := (R.path v).eval letters
+def relator (d : D) : FreeGroup S :=
+  word Γ letters R (Γ.origin d)*letters d*(word Γ letters R (Γ.origin (Γ.reverse d)))⁻¹
+def relations : Set (FreeGroup S) := Set.range (relator Γ letters R)
+abbrev Group := PresentedGroup (relations Γ letters R)
+def value (v : V) : Group Γ letters R := PresentedGroup.mk _ (word Γ letters R v)
+def letter (d : D) : Group Γ letters R := PresentedGroup.mk _ (letters d)
+lemma edge (d : D) : value Γ letters R (Γ.origin (Γ.reverse d))=
+    value Γ letters R (Γ.origin d)*letter Γ letters R d := by
+  have h := PresentedGroup.mk_eq_mk_of_mul_inv_mem (show relator Γ letters R d∈relations Γ letters R from ⟨d,rfl⟩)
+  simpa only [value,letter,map_mul] using h.symm
+
+/-- Every literal path has the source's path-order value, independently of
+which route was chosen to define the finite fundamental-cycle presentation. -/
+lemma path_value {a b : V} (p : Path Γ a b) :
+    p.eval (letter Γ letters R)=(value Γ letters R a)⁻¹*value Γ letters R b := by
+  induction p with
+  | nil v => simp
+  | cons d p ih =>
+    rw [Path.eval_cons,ih,edge]
+    group
+lemma closed_value (a : V) (p : Path Γ a a) : p.eval (letter Γ letters R)=1 := by
+  rw [path_value]
+  simp
+
+/-- Labels of all closed walks, exactly as in the cone presentation. -/
+def loopLabels : Set (FreeGroup S) := {w | ∃ a,∃ p : Path Γ a a,p.eval letters=w}
+lemma loopLabels_subset_closure :
+    loopLabels Γ letters ⊆ Subgroup.normalClosure (relations Γ letters R) := by
+  rintro w ⟨a,p,rfl⟩
+  apply PresentedGroup.mk_eq_one_iff.mp
+  rw [← Path.eval_map]
+  exact closed_value Γ letters R a p
+
+lemma relator_mem_loopLabels
+    (hl : ∀ d,letters (Γ.reverse d)=(letters d)⁻¹) (d : D) :
+    relator Γ letters R d∈loopLabels Γ letters := by
+  let p := ((R.path (Γ.origin d)).append (Path.single (Γ:=Γ) d)).append
+    (R.path (Γ.origin (Γ.reverse d))).reverse
+  refine ⟨R.base (Γ.origin d),p.cast rfl (R.same d).symm,?_⟩
+  simp only [Path.eval_cast,p,Path.eval_append,Path.eval_single,Path.eval_reverse letters hl]
+  rfl
+
+/-- The finite edge-route presentation has precisely the normal closure of
+all labels of graph loops, not merely some chosen graph relations. -/
+theorem normalClosure_eq_loops
+    (hl : ∀ d,letters (Γ.reverse d)=(letters d)⁻¹) :
+    Subgroup.normalClosure (relations Γ letters R)=Subgroup.normalClosure (loopLabels Γ letters) := by
+  apply le_antisymm
+  · apply Subgroup.normalClosure_mono
+    rintro w ⟨d,rfl⟩
+    exact relator_mem_loopLabels Γ letters R hl d
+  · exact Subgroup.normalClosure_le_normal (loopLabels_subset_closure Γ letters R)
+
+instance [Finite S] [Finite D] : _root_.Group.IsFinitelyPresented (Group Γ letters R) := by
+  have : Finite (relations Γ letters R) := Set.finite_range (relator Γ letters R) |>.to_subtype
+  infer_instance
+
+end
+
+open scoped Classical
+open PortSubdivision
+variable {V D A : Type} (Γ : PortGraph V D) (label : D→A×Bool)
+  (hl : ∀d,label (Γ.reverse d)=WordPairing.inverseLetter (label d)) (R : Routes Γ)
+def loopPath (d : D) : InitialPicture.Loop Γ :=
+  ⟨R.base (Γ.origin d),(((R.path (Γ.origin d)).append (Path.single (Γ:=Γ) d)).append
+    (R.path (Γ.origin (Γ.reverse d))).reverse).cast rfl (R.same d).symm⟩
+def roseLabel (d : D) : FreeGroup A := FreeGroup.mk [label d]
+include hl in
+lemma roseLabel_reverse (d : D) : roseLabel label (Γ.reverse d)=(roseLabel label d)⁻¹ := by
+  simp only [roseLabel,hl,FreeGroup.inv_mk]
+  rfl
+include hl in
+lemma loopPath_word (d : D) :
+    FreeGroup.mk ((loopPath Γ R d).2.letters label)=relator Γ (roseLabel label) R d := by
+  rw [Path.letters_mk]
+  change (loopPath Γ R d).2.eval (roseLabel label)=_
+  simp only [loopPath,Path.eval_cast,Path.eval_append,Path.eval_single,
+    Path.eval_reverse (roseLabel label) (roseLabel_reverse Γ label hl)]
+  rfl
+include hl in
+lemma loopPath_relations : AlgebraicPictures.relations (InitialPicture.relWords Γ label (loopPath Γ R))=
+    relations Γ (roseLabel label) R := by
+  unfold AlgebraicPictures.relations relations
+  congr 1
+  funext d
+  exact loopPath_word Γ label hl R d
+include hl in
+/-- A null word in the finite EDGE-ROUTE presentation used for the main
+construction has an initial literal lifted picture; no relators were enlarged
+or replaced by assumed graph-loop relations. -/
+theorem route_picture {x y : V} (p : Path Γ x y) (hxy : x≠y)
+    (h : p.eval (letter Γ (roseLabel label) R)=1) :
+    ∃(O : Type) (_ : Fintype O),Nonempty
+      (FinitePicture.Data (O:=O) Γ label WordPairing.inverseLetter x y) := by
+  apply InitialPicture.exists_picture Γ label hl (loopPath Γ R) p hxy
+  rw [loopPath_relations Γ label hl R,Path.letters_mk]
+  change PresentedGroup.mk (relations Γ (roseLabel label) R) (p.eval (roseLabel label))=1
+  rw [←Path.eval_map]
+  exact h
+
+end TorsionFreeZeroDivisors.GraphPresentation
+namespace TorsionFreeZeroDivisors.FinitePicture.Data
+open scoped Classical
+variable {V D A B O : Type} [Fintype O] {Γ : PortSubdivision.PortGraph V D}
+  {label : D→A} {inv : A→A} {x y : V} (a : Data (O:=O) Γ label inv x y)
+  (f : A→B) (label' : D→B) (inv' : B→B)
+  (hl : ∀d,label' d=f (label d)) (hf : ∀t,f (inv t)=inv' (f t))
+/-- Relabel the alphabet, retaining the actual graph dart and endpoint data.
+This does not change the path, partner, rotation, or exterior marker. -/
+def relabel : Data (O:=O) Γ label' inv' x y := {a with
+  compatible := by
+    intro i
+    have h1 : label'=f∘label := funext hl
+    have h2 : inv'∘label'=f∘(inv∘label) := by
+      funext d
+      simp only [Function.comp_apply,hl,hf]
+    rw [h2,h1]
+    simpa only [Option.map_map] using congrArg (Option.map f) (a.compatible i) }
+
+end TorsionFreeZeroDivisors.FinitePicture.Data
+namespace TorsionFreeZeroDivisors.GraphPresentation
+open PortSubdivision
+open scoped Classical
+variable {V D : Type} (Γ : PortGraph V D)
+namespace Path
+variable {Γ}
+def ofWalk : {a b : V} → (ShortClosure.simpleGraph Γ).Walk a b→Path Γ a b
+  | _,_,.nil => .nil _
+  | _,_,.cons h p =>
+    ((Path.single (Γ:=Γ) (ShortClosure.edgeDart Γ h)).cast
+      (ShortClosure.edgeDart_start Γ h) (ShortClosure.edgeDart_end Γ h)).append (ofWalk p)
+end Path
+def routes : Routes Γ where
+  base v := (ShortClosure.simpleGraph Γ).connectedComponentMk v |>.out
+  same d := congrArg Quot.out (SimpleGraph.ConnectedComponent.sound (ShortClosure.dart_reachable Γ d))
+  path v := Path.ofWalk (Classical.choice (SimpleGraph.ConnectedComponent.eq.mp
+    ((ShortClosure.simpleGraph Γ).connectedComponentMk v).out_eq))
+
+end TorsionFreeZeroDivisors.GraphPresentation
+namespace TorsionFreeZeroDivisors.ConcreteGroup
+
+section
+open scoped Classical BigOperators
+open PortSubdivision TypedGraphs ConditionedMatchings SampleGraph
+/-- The literal rose letters, with the fixed source inverse pairing. -/
+def freeLetter (t : Types.Letter) : FreeGroup Types.Generator :=
+  if (Types.signedLetter.symm t).2 then FreeGroup.of (Types.signedLetter.symm t).1
+  else (FreeGroup.of (Types.signedLetter.symm t).1)⁻¹
+lemma freeLetter_inverse (t : Types.Letter) :
+    freeLetter (Types.inverse t)=(freeLetter t)⁻¹ := by
+  obtain ⟨⟨g,b⟩,rfl⟩ := Types.signedLetter.surjective t
+  cases b <;> simp [freeLetter]
+variable (rep : ℕ) (r : ActualPatternEvent.Match rep)
+abbrev Γ := SampleGraph.graph rep r
+def labels : DA rep⊕DB rep → FreeGroup Types.Generator := freeLetter ∘ SampleGraph.label rep
+lemma labels_reverse (d : DA rep⊕DB rep) : labels rep ((Γ rep r).reverse d)=(labels rep d)⁻¹ := by
+  simp only [labels,Function.comp_apply,SampleGraph.label_reverse,freeLetter_inverse]
+def routes := GraphPresentation.routes (Γ rep r)
+abbrev G := GraphPresentation.Group (Γ rep r) (labels rep) (routes rep r)
+def value : VA rep⊕VB rep → G rep r := GraphPresentation.value (Γ rep r) (labels rep) (routes rep r)
+def letter (t : Types.Letter) : G rep r := PresentedGroup.mk _ (freeLetter t)
+instance : Group.IsFinitelyPresented (G rep r) := inferInstance
+lemma presentation_exact :
+    Subgroup.normalClosure (GraphPresentation.relations (Γ rep r) (labels rep) (routes rep r))=
+      Subgroup.normalClosure (GraphPresentation.loopLabels (Γ rep r) (labels rep)) :=
+  GraphPresentation.normalClosure_eq_loops _ _ _ (labels_reverse rep r)
+lemma edge (d : DA rep⊕DB rep) : value rep r ((Γ rep r).origin ((Γ rep r).reverse d))=
+    value rep r ((Γ rep r).origin d)*letter rep r (SampleGraph.label rep d) :=
+  GraphPresentation.edge _ _ _ d
+lemma path_value {a b : VA rep⊕VB rep} (p : GraphPresentation.Path (Γ rep r) a b) :
+    p.eval (letter rep r ∘ SampleGraph.label rep)=(value rep r a)⁻¹*value rep r b :=
+  GraphPresentation.path_value _ _ _ p
+end
+
+open scoped Classical
+open SampleGraph
+lemma freeLetter_mk (t : Types.Letter) : freeLetter t=FreeGroup.mk [Types.signedLetter.symm t] := by
+  obtain ⟨⟨g,b⟩,rfl⟩ := Types.signedLetter.surjective t
+  cases b <;> simp [freeLetter, FreeGroup.of, FreeGroup.inv_mk, FreeGroup.invRev]
+variable {rep : ℕ} (r : ActualPatternEvent.Match rep)
+lemma signed_label_reverse (d : DA rep⊕DB rep) :
+    Types.signedLetter.symm (SampleGraph.label rep ((Γ rep r).reverse d))=
+      WordPairing.inverseLetter (Types.signedLetter.symm (SampleGraph.label rep d)) := by
+  rw [SampleGraph.label_reverse]
+  simp [Types.inverse,WordPairing.inverseLetter]
+lemma letter_signed (d : DA rep⊕DB rep) :
+    GraphPresentation.roseLabel (Types.signedLetter.symm ∘ SampleGraph.label rep) d=labels rep d := by
+  exact (freeLetter_mk _).symm
+/-- A literal path null in the exact constructed group yields a reduced
+finite marked disk picture on the original source alphabet and graph darts. -/
+theorem reduced_picture {z w : VA rep⊕VB rep} (p : GraphPresentation.Path (Γ rep r) z w)
+    (hzw : z≠w) (h : p.eval (letter rep r ∘ SampleGraph.label rep)=1) :
+    ∃n,∃a : FinitePicture.Data (O:=Fin n) (Γ rep r) (SampleGraph.label rep) Types.inverse z w,
+      a.Reduced := by
+  have hlabels : GraphPresentation.roseLabel (Types.signedLetter.symm ∘ SampleGraph.label rep)=labels rep :=
+    funext (letter_signed (rep:=rep))
+  obtain ⟨O,hO,⟨a⟩⟩ := GraphPresentation.route_picture (Γ rep r)
+    (Types.signedLetter.symm ∘ SampleGraph.label rep) (signed_label_reverse r) (routes rep r) p hzw (by
+      rw [hlabels]
+      exact h)
+  let _ := hO
+  let b := a.relabel Types.signedLetter (SampleGraph.label rep) Types.inverse
+    (fun d=> (Types.signedLetter.apply_symm_apply _).symm) (by
+      intro t
+      exact (Types.inverse_signed t.1 t.2).symm)
+  obtain ⟨n,_,c,hc⟩ := b.exists_reduced (by intro t; exact Types.inverse_inverse t)
+    (SampleGraph.label_reverse rep r)
+  exact ⟨n,c,hc⟩
+
+end TorsionFreeZeroDivisors.ConcreteGroup
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/GroupRing/PathCharges.lean b/lean/OAI/Algebra/GroupRing/PathCharges.lean
new file mode 100644
index 0000000000000000000000000000000000000000..da245ac943513a610d50fbea17be2050b3a3a138
--- /dev/null
+++ b/lean/OAI/Algebra/GroupRing/PathCharges.lean
@@ -0,0 +1,78 @@
+import Mathlib
+import OAI.Algebra.GroupRing.WordFrames
+
+namespace OAI
+
+
+
+section
+namespace TorsionFreeZeroDivisors.PathCharges
+open scoped Classical BigOperators
+open WordCursor WordFrames WordBlocks
+noncomputable section
+variable {D G M : Type} [Group G] [AddCommGroup M] (v : D→G) (c : G→D→M)
+def charge (g : G) : List D→M
+  | []=>0
+  | d::w=>c g d+charge (g*v d) w
+@[simp] lemma charge_nil (g : G) : charge v c g []=0 := rfl
+@[simp] lemma charge_cons (g : G) (d : D) (w : List D) :
+    charge v c g (d::w)=c g d+charge v c (g*v d) w := rfl
+lemma charge_append (g : G) (w u : List D) :
+    charge v c g (w++u)=charge v c g w+charge v c (g*value v w) u := by
+  induction w generalizing g with
+  | nil=>simp
+  | cons d w ih=>
+    rw [List.cons_append,charge_cons,ih,charge_cons,value_cons,mul_assoc,add_assoc]
+lemma charge_sum (g : G) (w : List D) :
+    (∑i : Fin w.length,c (g*cursor v w i.val) (w.get i))=charge v c g w := by
+  induction w generalizing g with
+  | nil=>simp
+  | cons d w ih=>
+    change (∑i : Fin (w.length+1),c (g*cursor v (d::w) i.val) ((d::w).get i))=_
+    rw [Fin.sum_univ_succ,charge_cons]
+    change c (g*1) d+(∑i : Fin w.length,c (g*(v d*cursor v w i.val)) (w.get i))=_
+    simp only [mul_one,←mul_assoc]
+    rw [ih]
+lemma frames_sum (bs : List (G×List D)) :
+    (∑i : Occ (words bs),c (WordFrames.position v bs i) (letter (words bs) i))=
+    (bs.map (fun b=>charge v c b.1 b.2)).sum := by
+  induction bs with
+  | nil=>
+    change (∑i : Empty,c (WordFrames.position v [] i) (letter (words []) i))=0
+    simp only [Finset.univ_eq_empty,Finset.sum_empty]
+  | cons b bs ih=>
+    change (∑i : Fin b.2.length⊕Occ (words bs),c (WordFrames.position v (b::bs) i) (letter (words (b::bs)) i))=_
+    rw [Fintype.sum_sum_type]
+    cases b with
+    | mk g w=>
+      change (∑i : Fin w.length,c (g*cursor v w i.val) (w.get i))+
+        (∑i : Occ (words bs),c (WordFrames.position v bs i) (letter (words bs) i))=_
+      rw [charge_sum,ih]
+      rfl
+variable (rev : D→D) (hv : ∀d,v (rev d)=(v d)⁻¹)
+  (hc : ∀g d,c (g*v d) (rev d)=-c g d)
+include hv in
+lemma value_reverse (w : List D) : value v (w.reverse.map rev)=(value v w)⁻¹ := by
+  induction w with
+  | nil=>simp
+  | cons d w ih=>simp only [List.reverse_cons,List.map_append,List.map_singleton,
+      value_append,value_cons,value_nil,mul_one,ih,hv,mul_inv_rev]
+include hv hc in
+lemma charge_reverse (g : G) (w : List D) :
+    charge v c (g*value v w) (w.reverse.map rev)=-charge v c g w := by
+  induction w generalizing g with
+  | nil=>simp
+  | cons d w ih=>
+    rw [List.reverse_cons,List.map_append,List.map_singleton,value_cons,←mul_assoc,charge_append,ih]
+    rw [value_reverse v rev hv]
+    simp only [charge_cons,charge_nil,add_zero,mul_inv_cancel_right]
+    rw [hc,neg_add]
+    exact add_comm _ _
+end
+end TorsionFreeZeroDivisors.PathCharges
+
+end
+
+
+
+end OAI
diff --git a/lean/OAI/Algebra/GroupRing/PathIncidences.lean b/lean/OAI/Algebra/GroupRing/PathIncidences.lean
new file mode 100644
index 0000000000000000000000000000000000000000..c7761c38c859c380adbf4d97359c4ef73454faba
--- /dev/null
+++ b/lean/OAI/Algebra/GroupRing/PathIncidences.lean
@@ -0,0 +1,418 @@
+import Mathlib
+import OAI.Algebra.GroupRing.MultiplicityBound
+
+namespace OAI
+
+noncomputable section
+
+namespace TorsionFreeZeroDivisors.PathIncidences
+
+section
+open scoped Classical BigOperators
+open EntropyStages IncidenceStages
+
+namespace Opened
+variable {O : Type*} (P : EntropyStages.Pairing O)
+
+/-- Open one cyclic passage into two interval endpoints. -/
+def openAt (c : O) : EntropyStages.Pairing O where
+  partner o := if o = c ∨ o = P.partner c then o else P.partner o
+  involutive o := by
+    by_cases h : o = c ∨ o = P.partner c
+    · simp only [ite_eq_left h]
+    · have h' : ¬ (P.partner o = c ∨ P.partner o = P.partner c) := by
+        rintro (he|he)
+        · exact h (Or.inr (by rw [← he,P.involutive]))
+        · exact h (Or.inl (P.involutive.injective he))
+      simp only [ite_eq_right h,ite_eq_right h']
+      exact P.involutive o
+
+theorem openAt_fixed_iff (hfree : ∀ o, P.partner o ≠ o) (c o : O) :
+    (openAt P c).partner o = o ↔ o = c ∨ o = P.partner c := by
+  dsimp [openAt]
+  split_ifs with h
+  · simp only [h]
+  · exact iff_of_false (hfree o) h
+
+theorem openAt_unmatched_card [Fintype O] [DecidableEq O] (hfree : ∀ o, P.partner o ≠ o) (c : O) :
+    Fintype.card (openAt P c).Unmatched = 2 := by
+  let e : (openAt P c).Unmatched ≃ Bool :=
+    { toFun := fun o => if o.val = c then false else true
+      invFun := fun b => if b then
+        ⟨P.partner c,by rw [openAt_fixed_iff P hfree]; exact Or.inr rfl⟩ else
+        ⟨c,by rw [openAt_fixed_iff P hfree]; exact Or.inl rfl⟩
+      left_inv := by
+        intro o
+        apply Subtype.ext
+        obtain h|h := (openAt_fixed_iff P hfree c o.val).mp o.property
+        · simp [h]
+        · simp [h,hfree c]
+      right_inv := by
+        intro b
+        cases b <;> simp [hfree c] }
+  exact (Fintype.card_congr e).trans Fintype.card_bool
+end Opened
+
+/-- Cyclic consecutive edge incidences. `succ` is the permutation of edge
+positions; opening its passage at one position handles an interval path. -/
+def cyclePairing {E : Type*} (succ : Equiv.Perm E) : EntropyStages.Pairing (E × Bool) where
+  partner x := if x.2 then (succ x.1,false) else (succ.symm x.1,true)
+  involutive x := by
+    rcases x with ⟨i,b⟩
+    cases b <;> simp
+
+theorem cyclePairing_free {E : Type*} (succ : Equiv.Perm E) (x : E × Bool) :
+    (cyclePairing succ).partner x ≠ x := by
+  rcases x with ⟨i,b⟩
+  cases b <;> simp [cyclePairing]
+
+def pathPairing {E : Type*} (succ : Equiv.Perm E) (cut : Option E) : EntropyStages.Pairing (E × Bool) :=
+  match cut with
+  | none => cyclePairing succ
+  | some c => Opened.openAt (cyclePairing succ) (c,false)
+
+theorem pathPairing_card {E : Type*} [Fintype E] (succ : Equiv.Perm E) (cut : Option E) :
+    Fintype.card (pathPairing succ cut).Unmatched = if cut.isSome then 2 else 0 := by
+  cases cut with
+  | none =>
+    have : IsEmpty (pathPairing succ none).Unmatched :=
+      ⟨fun o => cyclePairing_free succ o.val o.property⟩
+    simp only [Option.isSome_none, Bool.false_eq_true, ↓reduceIte, Fintype.card_of_isEmpty]
+  | some c =>
+    have h := Opened.openAt_unmatched_card _ (cyclePairing_free succ) (c,false)
+    rw [← Nat.card_eq_fintype_card] at h ⊢
+    exact h
+
+variable {E D V : Type*} (origin : D → V) (reverse : D → D)
+  (edge : E → D)
+  (succ : Equiv.Perm E) (cut : Option E)
+
+/-- Initial and terminal half-edge of an occurrence, respectively. -/
+def port (x : E × Bool) : D := if x.2 then reverse (edge x.1) else edge x.1
+
+theorem partner_turn {x : E × Bool}
+    (hne : (pathPairing succ cut).partner x ≠ x) :
+    (pathPairing succ cut).partner x = (cyclePairing succ).partner x ∧
+    if x.2 then cut ≠ some (succ x.1) else cut ≠ some x.1 := by
+  cases cut with
+  | none => simp [pathPairing]
+  | some c =>
+    have hx : ¬ (x = (c,false) ∨ x = (cyclePairing succ).partner (c,false)) := by
+      intro hh
+      exact hne (by dsimp [pathPairing,Opened.openAt]; rw [ite_eq_left hh])
+    refine ⟨by dsimp [pathPairing,Opened.openAt]; rw [ite_eq_right hx],?_⟩
+    rcases x with ⟨i,b⟩
+    cases b
+    · simp only [Bool.false_eq_true,↓reduceIte,ne_eq,Option.some.injEq]
+      intro he
+      exact hx (Or.inl (Prod.ext he.symm rfl))
+    · simp only [↓reduceIte,ne_eq,Option.some.injEq]
+      intro he
+      exact hx (Or.inr (by
+        simp only [cyclePairing,Bool.false_eq_true,↓reduceIte]
+        exact Prod.ext (by rw [he,Equiv.symm_apply_apply]) rfl))
+
+/-- The incidence passage data is derived from the actual adjacency and
+nonbacktracking conditions, not assumed as an extra vertex-count estimate. -/
+def passages
+    (hvertex : ∀ i, cut ≠ some (succ i) → origin (edge (succ i)) = origin (reverse (edge i)))
+    (hreduced : ∀ i, cut ≠ some (succ i) → edge (succ i) ≠ reverse (edge i)) :
+    IncidenceStages.Passages origin (port reverse edge) where
+  toPairing := pathPairing succ cut
+  location x := by
+    by_cases he : (pathPairing succ cut).partner x = x
+    · rw [he]
+    obtain ⟨hp,hc⟩ := partner_turn succ cut he
+    rw [hp]
+    rcases x with ⟨i,b⟩
+    cases b
+    · have ht := hvertex (succ.symm i) (by simpa using hc)
+      simpa [cyclePairing,port] using ht.symm
+    · simpa [cyclePairing,port] using hvertex i hc
+  reduced x he := by
+    obtain ⟨hp,hc⟩ := partner_turn succ cut he
+    rw [hp]
+    rcases x with ⟨i,b⟩
+    cases b
+    · have ht := hreduced (succ.symm i) (by simpa using hc)
+      simpa [cyclePairing,port] using ht.symm
+    · simpa [cyclePairing,port] using hreduced i hc
+
+end
+
+open scoped Classical BigOperators
+open EntropyStages IncidenceStages
+
+theorem card_toNat {A : Type*} (inst : Fintype A) : @Fintype.card A inst = Nat.card A :=
+  (@Nat.card_eq_fintype_card A inst).symm
+
+/-- Disjoint union of the passages of the individual path components. -/
+def familyPairing {I : Type*} {O : I → Type*} (P : ∀ i, EntropyStages.Pairing (O i)) :
+    EntropyStages.Pairing (Sigma O) where
+  partner x := ⟨x.1,(P x.1).partner x.2⟩
+  involutive x := by
+    rcases x with ⟨i,o⟩
+    exact congrArg (Sigma.mk i) ((P i).involutive o)
+
+def unmatchedEquiv {I : Type*} {O : I → Type*} (P : ∀ i, EntropyStages.Pairing (O i)) :
+    (familyPairing P).Unmatched ≃ (Σ i, (P i).Unmatched) where
+  toFun x := ⟨x.val.1,⟨x.val.2,by
+    have h := x.property
+    exact eq_of_heq (Sigma.mk.inj_iff.mp h).2⟩⟩
+  invFun x := ⟨⟨x.1,x.2.val⟩,congrArg (Sigma.mk x.1) x.2.property⟩
+  left_inv _ := rfl
+  right_inv _ := rfl
+
+theorem family_unmatched_card {I : Type*} [Fintype I] {O : I → Type*}
+    [∀ i, Fintype (O i)] (P : ∀ i, EntropyStages.Pairing (O i)) :
+    Fintype.card (familyPairing P).Unmatched = ∑ i, Fintype.card (P i).Unmatched := by
+  rw [Fintype.card_congr (unmatchedEquiv P), Fintype.card_sigma]
+
+variable {I D V : Type*} [Fintype I] [Fintype D] [Fintype V] {E : I → Type*}
+  [∀ i, Fintype (E i)] (origin : D → V) (reverse : D → D)
+  (edge : ∀ i, E i → D) (succ : ∀ i, Equiv.Perm (E i)) (cut : ∀ i, Option (E i))
+  (hvertex : ∀ i e, cut i ≠ some (succ i e) →
+    origin (edge i (succ i e)) = origin (reverse (edge i e)))
+  (hreduced : ∀ i e, cut i ≠ some (succ i e) →
+    edge i (succ i e) ≠ reverse (edge i e))
+
+def familyPort (x : Σ i, E i × Bool) : D := port reverse (edge x.1) x.2
+
+def familyPassages : IncidenceStages.Passages origin (familyPort reverse edge) where
+  toPairing := familyPairing (fun i => pathPairing (succ i) (cut i))
+  location x := (passages origin reverse (edge x.1) (succ x.1) (cut x.1)
+    (hvertex x.1) (hreduced x.1)).location x.2
+  reduced x he := (passages origin reverse (edge x.1) (succ x.1) (cut x.1)
+    (hvertex x.1) (hreduced x.1)).reduced x.2 (fun h => he (congrArg (Sigma.mk x.1) h))
+
+include succ hvertex hreduced in
+/-- The exact occurrence balance for any union of immersed circles and
+intervals. -/
+theorem family_vertex_bound :
+    (∑ v : V, IncidenceStages.Passages.maxMultiplicity
+      (origin := origin) (port := familyPort reverse edge) v) ≤
+      (∑ i, Fintype.card (E i)) + ∑ i, if (cut i).isSome then 1 else 0 := by
+  apply (familyPassages origin reverse edge succ cut hvertex hreduced).image_vertex_bound
+  · simp only [Fintype.card_sigma,Fintype.card_prod,Fintype.card_bool,
+      ← Finset.sum_mul,mul_comm]
+  · have h := family_unmatched_card (fun i => pathPairing (succ i) (cut i))
+    rw [card_toNat] at h ⊢
+    change Nat.card (familyPairing (fun i => pathPairing (succ i) (cut i))).Unmatched = _
+    rw [h]
+    have hp (i : I) : Fintype.card (pathPairing (succ i) (cut i)).Unmatched =
+        if (cut i).isSome then 2 else 0 := pathPairing_card (succ i) (cut i)
+    simp_rw [card_toNat] at hp ⊢
+    simp_rw [hp]
+    rw [Finset.mul_sum]
+    apply Finset.sum_congr rfl
+    intro i _
+    split_ifs <;> norm_num
+
+end TorsionFreeZeroDivisors.PathIncidences
+
+namespace TorsionFreeZeroDivisors.StageSubgraphs
+open scoped Classical BigOperators
+open PortSubdivision
+variable {V D : Type*} [Fintype V] [Fintype D] (Γ : PortGraph V D)
+
+abbrev ActiveD (m : D → ℕ) (j : ℕ) := {d : D // j < m d}
+abbrev ActiveV (m : D → ℕ) (j : ℕ) := {v : V // ∃ d, Γ.origin d = v ∧ j < m d}
+
+/-- The actual multiplicity stage has precisely its incident vertices.
+No inactive vertices are counted or forced to embed. -/
+def stage (m : D → ℕ) (hm : ∀ d, m (Γ.reverse d) = m d) (j : ℕ) :
+    PortGraph (ActiveV Γ m j) (ActiveD m j) where
+  origin d := ⟨Γ.origin d.val, d.val,rfl,d.property⟩
+  reverse d := ⟨Γ.reverse d.val, (hm d.val).symm ▸ d.property⟩
+  reverse_reverse d := Subtype.ext (Γ.reverse_reverse d.val)
+  reverse_ne d he := Γ.reverse_ne d.val (congrArg Subtype.val he)
+
+def maxAt (m : D → ℕ) (v : V) : ℕ :=
+  (Finset.univ.filter fun d => Γ.origin d = v).sup m
+
+omit [Fintype V] in
+theorem active_iff (m : D → ℕ) (j : ℕ) (v : V) :
+    (∃ d, Γ.origin d = v ∧ j < m d) ↔ j < maxAt Γ m v := by
+  simp [maxAt,Finset.lt_sup_iff]
+
+theorem vertex_card (m : D → ℕ) (j : ℕ) :
+    Fintype.card (ActiveV Γ m j) = ∑ v : V, if j < maxAt Γ m v then 1 else 0 := by
+  rw [Fintype.card_congr (Equiv.subtypeEquivRight (active_iff Γ m j))]
+  simp only [Fintype.card_subtype,Finset.card_filter]
+
+theorem sum_vertex_card (m : D → ℕ) (M : ℕ) (hm : ∀ d, m d ≤ M) :
+    (∑ j : Fin M, Fintype.card (ActiveV Γ m j.val)) = ∑ v : V, maxAt Γ m v := by
+  simp_rw [vertex_card]
+  rw [Finset.sum_comm]
+  apply Finset.sum_congr rfl
+  intro v _
+  have hv : maxAt Γ m v ≤ M := Finset.sup_le (fun d _ => hm d)
+  rw [← Finset.card_filter]
+  have he : (Finset.univ.filter fun j : Fin M => j.val < maxAt Γ m v) =
+      Finset.univ.filter fun j => j.val ∈ Finset.range (maxAt Γ m v) := by simp
+  rw [he]
+  rw [← Fintype.card_subtype]
+  let e : {j : Fin M // j.val ∈ Finset.range (maxAt Γ m v)} ≃ Fin (maxAt Γ m v) :=
+    { toFun := fun j => ⟨j.val.val,Finset.mem_range.mp j.property⟩
+      invFun := fun j => ⟨⟨j.val,lt_of_lt_of_le j.isLt hv⟩,Finset.mem_range.mpr j.isLt⟩
+      left_inv := fun _ => rfl
+      right_inv := fun _ => rfl }
+  exact (Fintype.card_congr e).trans (Fintype.card_fin _)
+
+/-- Literal undirected stage edges; both orientations name a single edge. -/
+def edges : Finset (Sym2 D) := Finset.univ.image (fun d => s(d,Γ.reverse d))
+def edgeName (d : D) : edges Γ := ⟨s(d,Γ.reverse d),Finset.mem_image.mpr ⟨d,Finset.mem_univ _,rfl⟩⟩
+
+omit [Fintype V] in
+theorem fiber_card (e : edges Γ) : Fintype.card {d : D // edgeName Γ d = e} = 2 := by
+  obtain ⟨d,_,hd⟩ := Finset.mem_image.mp e.property
+  have he : e = edgeName Γ d := Subtype.ext hd.symm
+  subst e
+  rw [Fintype.card_subtype]
+  have hf : (Finset.univ.filter fun x => edgeName Γ x = edgeName Γ d) = {d,Γ.reverse d} := by
+    apply Finset.ext
+    intro x
+    simp only [Finset.mem_filter,Finset.mem_univ,true_and,Finset.mem_insert,Finset.mem_singleton]
+    rw [Subtype.ext_iff]
+    change s(x,Γ.reverse x) = s(d,Γ.reverse d) ↔ x = d ∨ x = Γ.reverse d
+    rw [Sym2.eq_iff]
+    constructor
+    · rintro (⟨h,_⟩|⟨h,_⟩)
+      · exact Or.inl h
+      · exact Or.inr h
+    · rintro (rfl|rfl)
+      · exact Or.inl ⟨rfl,rfl⟩
+      · exact Or.inr ⟨rfl,Γ.reverse_reverse d⟩
+  rw [hf,Finset.card_pair (Ne.symm (Γ.reverse_ne d))]
+
+omit [Fintype V] in
+/-- A fixed-point-free port involution has exactly two darts per edge. -/
+theorem two_edges : 2*(edges Γ).card = Fintype.card D := by
+  have h := Fintype.card_sigma (α := fun e : edges Γ => {d : D // edgeName Γ d = e})
+  simp_rw [fiber_card] at h
+  have he : (Σ e : edges Γ, {d : D // edgeName Γ d = e}) ≃ D :=
+    Equiv.sigmaFiberEquiv (edgeName Γ)
+  rw [Fintype.card_congr he] at h
+  simpa [mul_comm] using h.symm
+
+omit [Fintype V] in
+theorem sum_dart_card (m : D → ℕ) (M : ℕ) (hm : ∀ d, m d ≤ M) :
+    (∑ j : Fin M, Fintype.card (ActiveD m j.val)) = ∑ d : D, m d := by
+  simp only [ActiveD,Fintype.card_subtype,Finset.card_filter]
+  rw [Finset.sum_comm]
+  apply Finset.sum_congr rfl
+  intro d _
+  rw [← Finset.card_filter,← Fintype.card_subtype]
+  let e : {j : Fin M // j.val < m d} ≃ Fin (m d) :=
+    { toFun := fun j => ⟨j.val.val,j.property⟩
+      invFun := fun j => ⟨⟨j.val,lt_of_lt_of_le j.isLt (hm d)⟩,j.isLt⟩
+      left_inv := fun _ => rfl
+      right_inv := fun _ => rfl }
+  exact (Fintype.card_congr e).trans (Fintype.card_fin _)
+
+omit [Fintype V] in
+/-- Counting actual stage edges with multiplicity, not expected edges. -/
+theorem sum_edge_card (m : D → ℕ) (hr : ∀ d, m (Γ.reverse d) = m d)
+    (M H : ℕ) (hm : ∀ d, m d ≤ M) (hH : ∑ d, m d = 2*H) :
+    (∑ j : Fin M, (edges (stage Γ m hr j.val)).card) = H := by
+  have h2 : 2*(∑ j : Fin M, (edges (stage Γ m hr j.val)).card) = 2*H := by
+    rw [Finset.mul_sum]
+    simp_rw [two_edges]
+    rw [sum_dart_card m M hm,hH]
+  omega
+
+variable {I : Type*} [Fintype I] {E : I → Type*} [∀ i, Fintype (E i)]
+  (edge : ∀ i, E i → D)
+
+def multiplicity (d : D) : ℕ := IncidenceStages.Passages.multiplicity
+  (port := PathIncidences.familyPort Γ.reverse edge) d
+
+omit [Fintype V] [Fintype D] in
+/-- Source traversal multiplicity agrees on the two orientations. -/
+theorem multiplicity_reverse (d : D) :
+    multiplicity Γ edge (Γ.reverse d) = multiplicity Γ edge d := by
+  let flip : (Σ i, E i × Bool) ≃ (Σ i, E i × Bool) :=
+    { toFun := fun x => ⟨x.1,x.2.1,!x.2.2⟩
+      invFun := fun x => ⟨x.1,x.2.1,!x.2.2⟩
+      left_inv := by rintro ⟨i,e,b⟩; cases b <;> rfl
+      right_inv := by rintro ⟨i,e,b⟩; cases b <;> rfl }
+  have hf (x : Σ i, E i × Bool) :
+      PathIncidences.familyPort Γ.reverse edge (flip x) =
+        Γ.reverse (PathIncidences.familyPort Γ.reverse edge x) := by
+    rcases x with ⟨i,e,b⟩
+    cases b
+    · rfl
+    · exact (Γ.reverse_reverse (edge i e)).symm
+  apply Fintype.card_congr
+  exact Equiv.subtypeEquiv flip (fun o => by
+    rw [hf]
+    constructor
+    · intro h
+      rw [h,Γ.reverse_reverse]
+    · intro h
+      exact Γ.reverse_reverse.injective ((Γ.reverse_reverse d).symm ▸ h))
+
+omit [Fintype V] in
+/-- Each edge occurrence contributes one incidence in each orientation. -/
+theorem sum_multiplicity : (∑ d : D, multiplicity Γ edge d) =
+    2*(∑ i, Fintype.card (E i)) := by
+  have h := Fintype.card_sigma (α := fun d : D =>
+    {o : Σ i, E i × Bool // PathIncidences.familyPort Γ.reverse edge o = d})
+  have e := Equiv.sigmaFiberEquiv (PathIncidences.familyPort Γ.reverse edge)
+  rw [Fintype.card_congr e] at h
+  simpa only [multiplicity,IncidenceStages.Passages.multiplicity,Fintype.card_sigma,
+    Fintype.card_prod,Fintype.card_bool,← Finset.sum_mul,mul_comm] using h.symm
+
+variable (succ : ∀ i, Equiv.Perm (E i)) (cut : ∀ i, Option (E i))
+  (hvertex : ∀ i e, cut i ≠ some (succ i e) →
+    Γ.origin (edge i (succ i e)) = Γ.origin (Γ.reverse (edge i e)))
+  (hreduced : ∀ i e, cut i ≠ some (succ i e) →
+    edge i (succ i e) ≠ Γ.reverse (edge i e))
+
+include succ hvertex hreduced in
+/-- Exact vertex inequality for the actual stages
+of the immersed family, derived from the literal consecutive passages. -/
+theorem family_vertex_total (M : ℕ) (hm : ∀ d, multiplicity Γ edge d ≤ M) :
+    (∑ j : Fin M, Fintype.card (ActiveV Γ (multiplicity Γ edge) j.val)) ≤
+      (∑ i, Fintype.card (E i)) + ∑ i, if (cut i).isSome then 1 else 0 := by
+  rw [sum_vertex_card Γ _ M hm]
+  exact PathIncidences.family_vertex_bound Γ.origin Γ.reverse edge succ cut hvertex hreduced
+
+omit [Fintype V] in
+/-- Every traversal contributes exactly one undirected edge over all stages. -/
+theorem family_edge_total (M : ℕ) (hm : ∀ d, multiplicity Γ edge d ≤ M) :
+    (∑ j : Fin M, (edges (stage Γ (multiplicity Γ edge)
+      (multiplicity_reverse Γ edge) j.val)).card) = ∑ i, Fintype.card (E i) :=
+  sum_edge_card Γ _ (multiplicity_reverse Γ edge) M _ hm (sum_multiplicity Γ edge)
+
+include succ hvertex hreduced in
+/-- The n-exponent of actual stage embeddings is nonpositive; the initial
+vertex saving is claimed only at the first stage of every rooted interval. -/
+theorem family_exponent_nonpos (M : ℕ) (hM : 0 < M)
+    (hm : ∀ d, multiplicity Γ edge d ≤ M) :
+    (∑ j : Fin M, ((Fintype.card (ActiveV Γ (multiplicity Γ edge) j.val) : ℤ) -
+      (edges (stage Γ (multiplicity Γ edge) (multiplicity_reverse Γ edge) j.val)).card -
+      if j.val = 0 then (∑ i, if (cut i).isSome then 1 else 0 : ℕ) else 0)) ≤ 0 := by
+  have hv := family_vertex_total Γ edge succ cut hvertex hreduced M hm
+  have he := family_edge_total Γ edge M hm
+  have hp : (∑ j : Fin M, if j.val = 0 then
+      ((∑ i, if (cut i).isSome then 1 else 0 : ℕ) : ℤ) else 0) =
+      ((∑ i, if (cut i).isSome then 1 else 0 : ℕ) : ℤ) := by
+    rw [Finset.sum_eq_single (⟨0,hM⟩ : Fin M)]
+    · simp
+    · intro b _ hb
+      have hb0 : b.val ≠ 0 := fun h => hb (Fin.ext h)
+      simp [hb0]
+    · simp
+  simp only [Finset.sum_sub_distrib, Nat.cast_ite, Nat.cast_zero]
+  rw [hp,← Nat.cast_sum,← Nat.cast_sum,he]
+  have hv' : ((∑ j : Fin M, Fintype.card (ActiveV Γ (multiplicity Γ edge) j.val)) : ℤ) ≤
+      ((∑ i, Fintype.card (E i)) : ℤ) +
+      ((∑ i, if (cut i).isSome then 1 else 0 : ℕ) : ℤ) := by exact_mod_cast hv
+  omega
+
+end TorsionFreeZeroDivisors.StageSubgraphs
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/GroupRing/PatternCount.lean b/lean/OAI/Algebra/GroupRing/PatternCount.lean
new file mode 100644
index 0000000000000000000000000000000000000000..406dcfe1a0ccb51b6568664de2e546d4429a19f9
--- /dev/null
+++ b/lean/OAI/Algebra/GroupRing/PatternCount.lean
@@ -0,0 +1,653 @@
+import Mathlib
+import OAI.Algebra.GroupRing.MatchingGraphs
+
+namespace OAI
+
+noncomputable section
+
+namespace TorsionFreeZeroDivisors.PatternCount
+open scoped Classical
+open ConditionedMatchings
+variable {V D T F E A : Type*} [Fintype V] [Fintype D] [Fintype F] [Fintype E]
+variable (label : D → T) (bar : T → T)
+
+omit [Fintype D] in
+/-- A prescribed undirected edge can be read in either orientation. -/
+theorem contains_prescriptions (r : Matching label bar) (ports : E → D × D) :
+    r.Contains (Finset.univ.image (fun e => s((ports e).1,(ports e).2))) ↔
+      ∀ e, r (ports e).1 = (ports e).2 := by
+  classical
+  constructor
+  · intro h e
+    exact h _ _ (Finset.mem_image_of_mem _ (Finset.mem_univ e))
+  · intro h a b hab
+    obtain ⟨e,_,he⟩ := Finset.mem_image.mp hab
+    rcases Sym2.eq_iff.mp he with ⟨ha,hb⟩ | ⟨ha,hb⟩
+    · rw [← ha,← hb,h]
+    · rw [← ha,← hb,← h e,r.reverse_reverse]
+
+omit [Fintype V] in
+/-- The expectation numerator counts each vertex realization in each matching
+exactly once; prescriptions retain every edge, rather than path occurrences. -/
+theorem sum_realizations_eq (origin : D → V) (N : ℕ) (C : F → Finset (Sym2 D)) :
+    (∑ r ∈ Matching.conditioned (label := label) (bar := bar) origin N ∅,
+      (Finset.univ.filter (fun f : F => r.Contains (C f))).card) =
+    ∑ f : F, (Matching.conditioned (label := label) (bar := bar) origin N (C f)).card := by
+  classical
+  let Ω := Matching.conditioned (label := label) (bar := bar) origin N ∅
+  have hcf (f : F) : Matching.conditioned (label := label) (bar := bar) origin N (C f) =
+      Ω.filter (fun r => r.Contains (C f)) := by
+    ext r
+    simp only [Matching.conditioned,Ω,Finset.mem_filter,Finset.mem_univ,true_and]
+    have hemp : r.Contains (∅ : Finset (Sym2 D)) := by intro a b h; simp at h
+    tauto
+  simp_rw [hcf,Finset.card_eq_sum_ones,Finset.sum_filter]
+  exact Finset.sum_comm
+
+/-- Finite first-moment bound for a fixed labelled actual-image pattern.
+Distinct edges, not occurrences, supply the power of the matching denominator. -/
+theorem expectation_bound [DecidableEq D] (origin : D → V) (N : ℕ)
+    (hbar : ∀ t, bar t ≠ t) (d : ℕ) (h2 : 2 ≤ d)
+    (hd : ∀ v, Nat.card {e : D // origin e = v} ≤ d)
+    (C : F → Finset (Sym2 D)) (E R : ℕ) (hcard : ∀ f, (C f).card = E)
+    (hR : 0 < R)
+    (hsize : ∀ x, R + E + 4*d^(2*N+1) ≤ Nat.card {e : D // label e = label x})
+    (hΩ : (Matching.conditioned (label := label) (bar := bar) origin N ∅).Nonempty) :
+    ((∑ r ∈ Matching.conditioned (label := label) (bar := bar) origin N ∅,
+        (Finset.univ.filter (fun f : F => r.Contains (C f))).card : ℕ) : ℝ) /
+      (Matching.conditioned (label := label) (bar := bar) origin N ∅).card ≤
+      (Fintype.card F : ℝ) / (R : ℝ)^E := by
+  classical
+  let Ω := Matching.conditioned (label := label) (bar := bar) origin N ∅
+  have hcount (f : F) : (Matching.conditioned (label := label) (bar := bar)
+      origin N (C f)).card * R^E ≤ Ω.card := by
+    have h := Matching.prescriptions_count (label := label) (bar := bar)
+      origin N hbar d h2 hd R (C f) (by intro x; rw [hcard]; exact hsize x)
+    simpa only [hcard] using h
+  have hs : (∑ f : F, (Matching.conditioned (label := label) (bar := bar)
+      origin N (C f)).card) * R^E ≤ Fintype.card F * Ω.card := by
+    rw [Finset.sum_mul]
+    calc
+      _ ≤ ∑ _f : F, Ω.card := Finset.sum_le_sum (fun f _ => hcount f)
+      _ = _ := by simp
+  rw [sum_realizations_eq]
+  have hs' : ((∑ f : F, (Matching.conditioned (label := label) (bar := bar)
+      origin N (C f)).card : ℕ) : ℝ) * (R : ℝ)^E ≤ (Fintype.card F : ℝ) * Ω.card := by
+    exact_mod_cast hs
+  have hp : (0 : ℝ) < (R : ℝ)^E := pow_pos (Nat.cast_pos.mpr hR) _
+  have ho : (0 : ℝ) < Ω.card := Nat.cast_pos.mpr (Finset.card_pos.mpr hΩ)
+  exact (div_le_div_iff₀ ho hp).mpr hs'
+
+/-- Independent vertex carrier restrictions count by an exact product. This
+is an upper bound for injective vertex maps, without assuming independence
+of sampled edges. -/
+theorem vertex_assignments_card [Fintype A]
+    (allowed : A → Finset V) :
+    Fintype.card {f : A → V // ∀ a, f a ∈ allowed a} =
+      ∏ a : A, (allowed a).card := by
+  classical
+  let e : {f : A → V // ∀ a, f a ∈ allowed a} ≃ ((a : A) → {v : V // v ∈ allowed a}) :=
+    { toFun := fun f a => ⟨f.val a,f.property a⟩
+      invFun := fun f => ⟨fun a => (f a).val,fun a => (f a).property⟩
+      left_inv := fun _ => rfl
+      right_inv := fun _ => rfl }
+  rw [Fintype.card_congr e,Fintype.card_pi]
+  simp only [Fintype.card_coe]
+
+end TorsionFreeZeroDivisors.PatternCount
+
+namespace TorsionFreeZeroDivisors.PatternEmbeddings
+open scoped BigOperators Classical
+open PortSubdivision ConditionedMatchings
+variable {PV PD TV T : Type*} [Fintype PV] [Fintype PD] [Fintype TV] [Fintype T]
+
+abbrev Dart (outgoing : TV → Finset T) := {x : TV × T // x.2 ∈ outgoing x.1}
+def origin (outgoing : TV → Finset T) (e : Dart outgoing) : TV := e.val.1
+def label (outgoing : TV → Finset T) (e : Dart outgoing) : T := e.val.2
+
+def edges (Γ : PortGraph PV PD) : Finset (Sym2 PD) :=
+  Finset.univ.image (fun d => s(d,Γ.reverse d))
+
+abbrev VertexMap (allowed : PV → Finset TV) :=
+  {f : PV → TV // Function.Injective f ∧ ∀ v, f v ∈ allowed v}
+
+variable (Γ : PortGraph PV PD) (plabel : PD → T) (outgoing : TV → Finset T)
+  (allowed : PV → Finset TV)
+  (hallowed : ∀ v x, x ∈ allowed v → ∀ d, Γ.origin d = v → plabel d ∈ outgoing x)
+
+/-- Every candidate is injective on actual-image vertices; the letters uniquely
+specify the target ports before the random matching is chosen. -/
+def dartMap (f : VertexMap allowed) (d : PD) : Dart outgoing :=
+  ⟨(f.val (Γ.origin d),plabel d),hallowed _ _ (f.property.2 _) d rfl⟩
+
+omit [Fintype PV] [Fintype PD] [Fintype TV] [Fintype T] in
+theorem dartMap_injective
+    (himm : Function.Injective (fun d => (Γ.origin d,plabel d)))
+    (f : VertexMap allowed) : Function.Injective (dartMap Γ plabel outgoing allowed hallowed f) := by
+  intro d e he
+  have hp := congrArg Subtype.val he
+  have hv : Γ.origin d = Γ.origin e := f.property.1 (congrArg Prod.fst hp)
+  have hl : plabel d = plabel e := congrArg Prod.snd hp
+  exact himm (Prod.ext hv hl)
+
+/-- Each undirected actual edge is prescribed once, regardless of its number
+of occurrences in the paths. This prevents the independence fallacy. -/
+def prescriptions (f : VertexMap allowed) : Finset (Sym2 (Dart outgoing)) :=
+  (edges Γ).image (Sym2.map (dartMap Γ plabel outgoing allowed hallowed f))
+
+omit [Fintype PV] [Fintype TV] [Fintype T] in
+theorem prescriptions_card
+    (himm : Function.Injective (fun d => (Γ.origin d,plabel d)))
+    (f : VertexMap allowed) :
+    (prescriptions Γ plabel outgoing allowed hallowed f).card = (edges Γ).card := by
+  exact Finset.card_image_of_injective _ (Sym2.map.injective
+    (dartMap_injective Γ plabel outgoing allowed hallowed himm f))
+
+omit [Fintype PV] [Fintype TV] [Fintype T] in
+/-- A matching contains the prescriptions precisely when the vertex map is
+an edge-respecting labelled graph embedding. -/
+theorem contains_iff (bar : T → T) (f : VertexMap allowed)
+    (r : Matching (label outgoing) bar) :
+    r.Contains (prescriptions Γ plabel outgoing allowed hallowed f) ↔
+      ∀ d, r.val (dartMap Γ plabel outgoing allowed hallowed f d) =
+        dartMap Γ plabel outgoing allowed hallowed f (Γ.reverse d) := by
+  have he : prescriptions Γ plabel outgoing allowed hallowed f =
+      Finset.univ.image (fun d => s(dartMap Γ plabel outgoing allowed hallowed f d,
+        dartMap Γ plabel outgoing allowed hallowed f (Γ.reverse d))) := by
+    rw [prescriptions,edges,Finset.image_image]
+    rfl
+  rw [he]
+  convert PatternCount.contains_prescriptions (label outgoing) bar r
+    (fun d => (dartMap Γ plabel outgoing allowed hallowed f d,
+      dartMap Γ plabel outgoing allowed hallowed f (Γ.reverse d))) using 1
+  simp only [Matching.Contains,Finset.mem_image]
+
+omit [Fintype PD] [Fintype T] in
+theorem vertexMap_card : Fintype.card (VertexMap allowed) ≤ ∏ v, (allowed v).card := by
+  let forget : VertexMap allowed → {f : PV → TV // ∀ v, f v ∈ allowed v} :=
+    fun f => ⟨f.val,f.property.2⟩
+  calc
+    _ ≤ Fintype.card {f : PV → TV // ∀ v, f v ∈ allowed v} :=
+      Fintype.card_le_of_injective forget (by
+        intro a b h
+        apply Subtype.ext
+        exact congrArg (fun z : {f : PV → TV // ∀ v, f v ∈ allowed v} => z.val) h)
+    _ = _ := PatternCount.vertex_assignments_card allowed
+
+/-- Fixed-label stage first moment with all graph-embedding hypotheses
+explicit. The only counting input on vertices is their literal carrier sets. -/
+theorem expectation_bound (bar : T → T) (hbar : ∀ t, bar t ≠ t)
+    (himm : Function.Injective (fun d => (Γ.origin d,plabel d)))
+    (N d R : ℕ) (h2 : 2 ≤ d) (hR : 0 < R)
+    (hd : ∀ v, Nat.card {e : Dart outgoing // origin outgoing e = v} ≤ d)
+    (hsize : ∀ x : Dart outgoing,
+      R + (edges Γ).card + 4*d^(2*N+1) ≤
+        Nat.card {e : Dart outgoing // label outgoing e = label outgoing x})
+    (hΩ : (Matching.conditioned (label := label outgoing) (bar := bar)
+      (origin outgoing) N ∅).Nonempty) :
+    ((∑ r ∈ Matching.conditioned (label := label outgoing) (bar := bar) (origin outgoing) N ∅,
+      (Finset.univ.filter (fun f : VertexMap allowed =>
+        ∀ e, r.val (dartMap Γ plabel outgoing allowed hallowed f e) =
+          dartMap Γ plabel outgoing allowed hallowed f (Γ.reverse e))).card : ℕ) : ℝ) /
+      (Matching.conditioned (label := label outgoing) (bar := bar) (origin outgoing) N ∅).card ≤
+        (∏ v, ((allowed v).card : ℝ)) / (R : ℝ) ^ (edges Γ).card := by
+  have hc := PatternCount.expectation_bound (label outgoing) bar (origin outgoing) N hbar d h2 hd
+    (prescriptions Γ plabel outgoing allowed hallowed) (edges Γ).card R
+    (prescriptions_card Γ plabel outgoing allowed hallowed himm) hR hsize hΩ
+  simp_rw [contains_iff] at hc
+  refine hc.trans (div_le_div_of_nonneg_right ?_ (by positivity))
+  exact_mod_cast vertexMap_card allowed
+
+end TorsionFreeZeroDivisors.PatternEmbeddings
+
+/-!
+Exact finite geometry and type system over the field with 128 elements.
+-/
+
+namespace TorsionFreeZeroDivisors
+namespace Types
+
+open scoped LinearAlgebra.Projectivization
+open Configuration
+
+abbrev Field128 := GaloisField 2 7
+
+instance : Fintype Field128 := Fintype.ofFinite _
+instance : DecidableEq Field128 := Classical.decEq _
+
+abbrev Point := ℙ Field128 (Fin 3 → Field128)
+abbrev Line := Point
+
+instance : Fintype Point := Fintype.ofFinite _
+instance : DecidableEq Point := Classical.decEq _
+
+instance (p : Point) (l : Line) : Decidable (p ∈ l) := Classical.propDecidable _
+
+theorem field_card : Nat.card Field128 = 128 := by
+  simpa using GaloisField.card 2 7 (by decide)
+
+theorem point_card : Fintype.card Point = 16513 := by
+  have h := Projectivization.card' Field128 (Fin 3 → Field128)
+  rw [Nat.card_fun, Nat.card_fin, field_card] at h
+  change 128 ^ 3 = Nat.card Point * (128 - 1) + 1 at h
+  norm_num at h
+  omega
+
+theorem order_eq : ProjectivePlane.order Point Line = 128 := by
+  have h := ProjectivePlane.card_points Point Line
+  rw [point_card] at h
+  have hi : (16513 : ℤ) = (ProjectivePlane.order Point Line : ℤ) ^ 2 +
+      (ProjectivePlane.order Point Line : ℤ) + 1 := by exact_mod_cast h
+  have hf : ((ProjectivePlane.order Point Line : ℤ) - 128) *
+      ((ProjectivePlane.order Point Line : ℤ) + 129) = 0 := by nlinarith
+  rcases mul_eq_zero.mp hf with h1 | h1 <;> omega
+
+/-- Ordinary labels carried by a line type. -/
+def pointsOn (l : Line) : Finset Point := Finset.univ.filter (· ∈ l)
+
+def linesOn (p : Point) : Finset Line := Finset.univ.filter (p ∈ ·)
+
+@[simp] theorem mem_pointsOn {p : Point} {l : Line} : p ∈ pointsOn l ↔ p ∈ l := by
+  simp [pointsOn]
+
+@[simp] theorem mem_linesOn {p : Point} {l : Line} : l ∈ linesOn p ↔ p ∈ l := by
+  simp [linesOn]
+
+theorem pointsOn_card (l : Line) : (pointsOn l).card = 129 := by
+  have h := ProjectivePlane.pointCount_eq Point l
+  rw [order_eq] at h
+  simpa [pointCount, Nat.card_eq_fintype_card, Fintype.card_subtype, pointsOn] using h
+
+theorem linesOn_card (p : Point) : (linesOn p).card = 129 := by
+  have h := ProjectivePlane.lineCount_eq Line p
+  rw [order_eq] at h
+  simpa [lineCount, Nat.card_eq_fintype_card, Fintype.card_subtype, linesOn] using h
+
+theorem pointsOn_inter_card {l m : Line} (hlm : l ≠ m) :
+    (pointsOn l ∩ pointsOn m).card = 1 := by
+  obtain ⟨p, hp, hu⟩ := HasPoints.existsUnique_point Point Line l m hlm
+  have heq : pointsOn l ∩ pointsOn m = {p} := by
+    ext q
+    simp only [Finset.mem_inter, mem_pointsOn, Finset.mem_singleton]
+    exact ⟨fun hq => hu q hq, fun hq => hq ▸ hp⟩
+  rw [heq, Finset.card_singleton]
+
+theorem linesOn_inter_card {p q : Point} (hpq : p ≠ q) :
+    (linesOn p ∩ linesOn q).card = 1 := by
+  obtain ⟨l, hl, hu⟩ := HasLines.existsUnique_line Point Line p q hpq
+  have heq : linesOn p ∩ linesOn q = {l} := by
+    ext m
+    simp only [Finset.mem_inter, mem_linesOn, Finset.mem_singleton]
+    exact ⟨fun hm => hu m hm, fun hm => hm ▸ hl⟩
+  rw [heq, Finset.card_singleton]
+
+/-- Counting a predicate depending only on the first coordinate. -/
+theorem card_prod_fst {U V : Type*} [Fintype U] [Fintype V]
+    (p : U → Prop) [DecidablePred p] :
+    Fintype.card {x : U × V // p x.1} = Fintype.card {u : U // p u} * Fintype.card V := by
+  let e : {x : U × V // p x.1} ≃ {u : U // p u} × V :=
+    { toFun := fun x => (⟨x.val.1, x.property⟩, x.val.2)
+      invFun := fun x => ⟨(x.1.val, x.2), x.1.property⟩
+      left_inv := fun _ => rfl
+      right_inv := fun _ => rfl }
+  rw [Fintype.card_congr e, Fintype.card_prod]
+
+theorem card_prod_snd {U V : Type*} [Fintype U] [Fintype V]
+    (p : V → Prop) [DecidablePred p] :
+    Fintype.card {x : U × V // p x.2} = Fintype.card U * Fintype.card {v : V // p v} := by
+  let e : {x : U × V // p x.2} ≃ U × {v : V // p v} :=
+    { toFun := fun x => (x.val.1, ⟨x.val.2, x.property⟩)
+      invFun := fun x => ⟨(x.1, x.2.val), x.2.property⟩
+      left_inv := fun _ => rfl
+      right_inv := fun _ => rfl }
+  rw [Fintype.card_congr e, Fintype.card_prod]
+
+/-! The empirical type slots. Each line has exactly 33026 slots on each
+side, before the admissible replication parameter is applied. -/
+abbrev SlotA := (Fin 3 × Fin 129) ⊕ Fin 32639
+abbrev SlotB := Fin 258 ⊕ Fin 32768
+abbrev VertexA (N : ℕ) := Line × SlotA × Fin N
+abbrev VertexB (N : ℕ) := Line × SlotB × Fin N
+abbrev Letter := Point ⊕ Fin 3
+
+def extrasA : SlotA → Finset (Fin 3)
+  | .inl (i, _) => Finset.univ.erase i
+  | .inr _ => ∅
+
+def extrasB : SlotB → Finset (Fin 3)
+  | .inl _ => Finset.univ
+  | .inr _ => ∅
+
+def outgoingA {N : ℕ} (x : VertexA N) : Finset Letter :=
+  (pointsOn x.1).disjSum (extrasA x.2.1)
+
+def outgoingB {N : ℕ} (y : VertexB N) : Finset Letter :=
+  (pointsOn y.1).disjSum (extrasB y.2.1)
+
+theorem card_slotA : Fintype.card SlotA = 33026 := by
+  simp [SlotA]
+
+theorem card_slotB : Fintype.card SlotB = 33026 := by
+  simp [SlotB]
+
+theorem card_vertexA (N : ℕ) : Fintype.card (VertexA N) = 2 * 16513 ^ 2 * N := by
+  simp only [Fintype.card_prod, card_slotA, Fintype.card_fin, point_card]
+  ring
+
+theorem card_vertexB (N : ℕ) : Fintype.card (VertexB N) = 2 * 16513 ^ 2 * N := by
+  simp only [Fintype.card_prod, card_slotB, Fintype.card_fin, point_card]
+  ring
+
+theorem disjSum_inter {P E : Type*} [DecidableEq P] [DecidableEq E]
+    (a b : Finset P) (c d : Finset E) :
+    a.disjSum c ∩ b.disjSum d = (a ∩ b).disjSum (c ∩ d) := by
+  ext x
+  cases x <;> simp
+
+theorem ordinary_inter_odd (l m : Line) : Odd ((pointsOn l ∩ pointsOn m).card) := by
+  by_cases h : l = m
+  · subst m
+    simp only [Finset.inter_self,pointsOn_card]
+    decide
+  · rw [pointsOn_inter_card h]
+    decide
+
+theorem extras_inter_even (a : SlotA) (b : SlotB) :
+    Even ((extrasA a ∩ extrasB b).card) := by
+  rcases a with ⟨i,j⟩ | k <;> cases b <;>
+    simp [extrasA, extrasB, Finset.card_erase_of_mem]
+
+/-- The parity condition holds on every admissible size, independently of
+all edge matchings, exactly as in equation odd-intersections. -/
+theorem odd_cross_intersections {N : ℕ} (x : VertexA N) (y : VertexB N) :
+    Odd ((outgoingA x ∩ outgoingB y).card) := by
+  rw [outgoingA, outgoingB, disjSum_inter, Finset.card_disjSum]
+  exact (ordinary_inter_odd x.1 y.1).add_even (extras_inter_even x.2.1 y.2.1)
+
+theorem degreeA_bounds {N : ℕ} (x : VertexA N) :
+    129 ≤ (outgoingA x).card ∧ (outgoingA x).card ≤ 132 := by
+  rw [outgoingA, Finset.card_disjSum, pointsOn_card]
+  rcases x.2.1 with ⟨i,j⟩ | k <;> simp [extrasA, Finset.card_erase_of_mem]
+
+theorem degreeB_bounds {N : ℕ} (y : VertexB N) :
+    129 ≤ (outgoingB y).card ∧ (outgoingB y).card ≤ 132 := by
+  rw [outgoingB, Finset.card_disjSum, pointsOn_card]
+  cases y.2.1 <;> simp [extrasB]
+
+theorem slotA_extra_frequency (e : Fin 3) :
+    Fintype.card {a : SlotA // e ∈ extrasA a} = 258 := by
+  rw [Fintype.card_subtype, Finset.card_filter, Fintype.sum_sum_type]
+  have hz : (∑ a : Fin 32639, if e ∈ extrasA (.inr a) then 1 else 0) = 0 := by
+    simp [extrasA]
+  rw [hz, add_zero, Fintype.sum_prod_type]
+  have hi (i : Fin 3) :
+      (∑ j : Fin 129, if e ∈ extrasA (.inl (i,j)) then 1 else 0) =
+        129 * (if e ≠ i then 1 else 0) := by
+    by_cases h : e = i <;> simp [extrasA, h]
+  simp_rw [hi]
+  rw [← Finset.mul_sum, Finset.sum_boole]
+  have hc : (Finset.univ.filter fun i : Fin 3 => e ≠ i) = Finset.univ.erase e := by ext i; simp [ne_comm]
+  rw [hc]
+  simp
+
+theorem slotB_extra_frequency (e : Fin 3) :
+    Fintype.card {b : SlotB // e ∈ extrasB b} = 258 := by
+  rw [Fintype.card_subtype, Finset.card_filter, Fintype.sum_sum_type]
+  simp [extrasB]
+
+/-- Each of the 16516 letters has exactly np carriers on each side. -/
+theorem letter_frequencyA (N : ℕ) (t : Letter) :
+    Fintype.card {x : VertexA N // t ∈ outgoingA x} = 4260354 * N := by
+  cases t with
+  | inl p =>
+    have he : (fun x : VertexA N => Sum.inl p ∈ outgoingA x) =
+        (fun x => p ∈ x.1) := by funext x; simp [outgoingA]
+    rw [Fintype.card_congr (Equiv.subtypeEquivRight (fun x => iff_of_eq (congrFun he x))),
+      card_prod_fst (V := SlotA × Fin N) (fun l : Line => p ∈ l), Fintype.card_prod, card_slotA, Fintype.card_fin]
+    have hc : Fintype.card {l : Line // p ∈ l} = 129 := by
+      rw [Fintype.card_subtype]
+      exact linesOn_card p
+    rw [hc]
+    ring
+  | inr e =>
+    have he : (fun x : VertexA N => Sum.inr e ∈ outgoingA x) =
+        (fun x => e ∈ extrasA x.2.1) := by funext x; simp [outgoingA]
+    rw [Fintype.card_congr (Equiv.subtypeEquivRight (fun x => iff_of_eq (congrFun he x))),
+      card_prod_snd (U := Line) (fun x : SlotA × Fin N => e ∈ extrasA x.1),
+      card_prod_fst (V := Fin N) (fun a : SlotA => e ∈ extrasA a),
+      point_card, slotA_extra_frequency,
+      Fintype.card_fin]
+    ring
+
+theorem letter_frequencyB (N : ℕ) (t : Letter) :
+    Fintype.card {x : VertexB N // t ∈ outgoingB x} = 4260354 * N := by
+  cases t with
+  | inl p =>
+    have he : (fun x : VertexB N => Sum.inl p ∈ outgoingB x) =
+        (fun x => p ∈ x.1) := by funext x; simp [outgoingB]
+    rw [Fintype.card_congr (Equiv.subtypeEquivRight (fun x => iff_of_eq (congrFun he x))),
+      card_prod_fst (V := SlotB × Fin N) (fun l : Line => p ∈ l), Fintype.card_prod, card_slotB, Fintype.card_fin]
+    have hc : Fintype.card {l : Line // p ∈ l} = 129 := by
+      rw [Fintype.card_subtype]
+      exact linesOn_card p
+    rw [hc]
+    ring
+  | inr e =>
+    have he : (fun x : VertexB N => Sum.inr e ∈ outgoingB x) =
+        (fun x => e ∈ extrasB x.2.1) := by funext x; simp [outgoingB]
+    rw [Fintype.card_congr (Equiv.subtypeEquivRight (fun x => iff_of_eq (congrFun he x))),
+      card_prod_snd (U := Line) (fun x : SlotB × Fin N => e ∈ extrasB x.1),
+      card_prod_fst (V := Fin N) (fun b : SlotB => e ∈ extrasB b),
+      point_card, slotB_extra_frequency,
+      Fintype.card_fin]
+    ring
+
+/-! ### The fixed inverse pairing and the actual space of graph matchings -/
+
+abbrev OrdinaryCode := Fin 3 ⊕ (Fin 8255 × Bool)
+abbrev Generator := Fin 3 ⊕ Fin 8255
+abbrev Signed := Generator × Bool
+
+/-- The arbitrary pairing of the remaining ordinary letters is fixed once,
+using a cardinality equivalence; the first three partner the extras. -/
+def pointCode : Point ≃ OrdinaryCode := Fintype.equivOfCardEq (by
+  rw [point_card]
+  simp [OrdinaryCode])
+
+def signedLetter : Signed ≃ Letter where
+  toFun
+    | (.inl i, true) => .inr i
+    | (.inl i, false) => .inl (pointCode.symm (.inl i))
+    | (.inr j, b) => .inl (pointCode.symm (.inr (j,b)))
+  invFun
+    | .inr i => (.inl i, true)
+    | .inl p => match pointCode p with
+      | .inl i => (.inl i, false)
+      | .inr (j,b) => (.inr j, b)
+  left_inv := by
+    rintro ⟨i | j,b⟩ <;> cases b <;> simp
+  right_inv := by
+    rintro (p | i)
+    · cases hc : pointCode p with
+      | inl j =>
+        simp only [hc]
+        exact congrArg Sum.inl (pointCode.symm_apply_eq.mpr hc.symm)
+      | inr jb =>
+        simp only [hc]
+        exact congrArg Sum.inl (pointCode.symm_apply_eq.mpr hc.symm)
+    · rfl
+
+def inverse (t : Letter) : Letter :=
+  signedLetter ( (signedLetter.symm t).1, !(signedLetter.symm t).2 )
+
+@[simp] theorem inverse_signed (g : Generator) (b : Bool) :
+    inverse (signedLetter (g,b)) = signedLetter (g,!b) := by simp [inverse]
+
+@[simp] theorem inverse_inverse (t : Letter) : inverse (inverse t) = t := by
+  obtain ⟨⟨g,b⟩, rfl⟩ := signedLetter.surjective t
+  simp
+
+theorem inverse_ne (t : Letter) : inverse t ≠ t := by
+  obtain ⟨⟨g,b⟩, rfl⟩ := signedLetter.surjective t
+  intro he
+  cases b <;> simp only [inverse_signed, Bool.not_true, Bool.not_false] at he <;>
+    cases signedLetter.injective he
+
+variable {V : Type*} (outgoing : V → Finset Letter)
+
+/-- Each inverse pair receives a bijection between its two carrier sets. -/
+def MatchingTuple := (g : Generator) →
+  {x : V // signedLetter (g,true) ∈ outgoing x} ≃
+    {x : V // signedLetter (g,false) ∈ outgoing x}
+
+/-- Exact empirical balance ensures the finite matching space is nonempty. -/
+theorem matchingTuple_nonempty [Fintype V]
+    (hfreq : ∀ t u, Fintype.card {x : V // t ∈ outgoing x} =
+      Fintype.card {x : V // u ∈ outgoing x}) : Nonempty (MatchingTuple outgoing) := by
+  exact ⟨fun g => Fintype.equivOfCardEq (hfreq _ _)⟩
+
+/-- The direction of a step is given by the signed letter. Non-carrier
+values are immaterial and are defined to fix the vertex. -/
+def nextSigned (M : MatchingTuple outgoing) (x : V) : Signed → V
+  | (g,true) => if hx : signedLetter (g,true) ∈ outgoing x then (M g ⟨x,hx⟩).val else x
+  | (g,false) => if hx : signedLetter (g,false) ∈ outgoing x then ((M g).symm ⟨x,hx⟩).val else x
+
+def next (M : MatchingTuple outgoing) (x : V) (t : Letter) : V :=
+  nextSigned outgoing M x (signedLetter.symm t)
+
+@[simp] theorem next_signed (M : MatchingTuple outgoing) (x : V) (g : Generator) (b : Bool) :
+    next outgoing M x (signedLetter (g,b)) = nextSigned outgoing M x (g,b) := by
+  simp [next]
+
+theorem next_reverse_mem (M : MatchingTuple outgoing) (x : V) (t : Letter)
+    (ht : t ∈ outgoing x) : inverse t ∈ outgoing (next outgoing M x t) := by
+  obtain ⟨⟨g,b⟩, rfl⟩ := signedLetter.surjective t
+  cases b <;> simp only [inverse_signed, Bool.not_true, Bool.not_false, next_signed]
+  · simpa [nextSigned, ht] using ((M g).symm ⟨x,ht⟩).property
+  · simpa [nextSigned, ht] using (M g ⟨x,ht⟩).property
+
+theorem next_reverse_next (M : MatchingTuple outgoing) (x : V) (t : Letter)
+    (ht : t ∈ outgoing x) : next outgoing M (next outgoing M x t) (inverse t) = x := by
+  obtain ⟨⟨g,b⟩, rfl⟩ := signedLetter.surjective t
+  cases b <;> simp only [inverse_signed, Bool.not_true, Bool.not_false, next_signed]
+  · simp only [nextSigned, dite_eq_left ht]
+    have hc := ((M g).symm ⟨x,ht⟩).property
+    rw [dite_eq_left hc]
+    exact congrArg Subtype.val ((M g).apply_symm_apply ⟨x,ht⟩)
+  · simp only [nextSigned, dite_eq_left ht]
+    have hc := (M g ⟨x,ht⟩).property
+    rw [dite_eq_left hc]
+    exact congrArg Subtype.val ((M g).symm_apply_apply ⟨x,ht⟩)
+
+/-- In particular both source sides have an actual matching space. This
+makes no girth or arrangement claim about a chosen point in that space. -/
+theorem matchingA_nonempty (N : ℕ) : Nonempty (MatchingTuple (@outgoingA N)) :=
+  matchingTuple_nonempty _ (fun t u => (letter_frequencyA N t).trans (letter_frequencyA N u).symm)
+
+theorem matchingB_nonempty (N : ℕ) : Nonempty (MatchingTuple (@outgoingB N)) :=
+  matchingTuple_nonempty _ (fun t u => (letter_frequencyB N t).trans (letter_frequencyB N u).symm)
+
+/-! Joint type incidences for internal-chain vertex counts.
+These derive the turn weights from the actual prescribed types. -/
+
+theorem card_prod_both {U V : Type*} [Fintype U] [Fintype V]
+    (p : U → Prop) (q : V → Prop) [DecidablePred p] [DecidablePred q] :
+    Fintype.card {x : U × V // p x.1 ∧ q x.2} =
+      Fintype.card {u : U // p u} * Fintype.card {v : V // q v} := by
+  let e : {x : U × V // p x.1 ∧ q x.2} ≃ {u : U // p u} × {v : V // q v} :=
+    { toFun := fun x => (⟨x.val.1,x.property.1⟩,⟨x.val.2,x.property.2⟩)
+      invFun := fun x => ⟨(x.1.val,x.2.val),⟨x.1.property,x.2.property⟩⟩
+      left_inv := fun _ => rfl
+      right_inv := fun _ => rfl }
+  rw [Fintype.card_congr e, Fintype.card_prod]
+
+theorem slotA_extra_joint (e f : Fin 3) (hef : e ≠ f) :
+    Fintype.card {a : SlotA // e ∈ extrasA a ∧ f ∈ extrasA a} = 129 := by
+  rw [Fintype.card_subtype, Finset.card_filter, Fintype.sum_sum_type]
+  have hz : (∑ a : Fin 32639, if e ∈ extrasA (.inr a) ∧ f ∈ extrasA (.inr a)
+      then 1 else 0) = 0 := by simp [extrasA]
+  rw [hz, add_zero, Fintype.sum_prod_type]
+  have hi (i : Fin 3) :
+      (∑ j : Fin 129, if e ∈ extrasA (.inl (i,j)) ∧ f ∈ extrasA (.inl (i,j))
+        then 1 else 0) = 129 * (if e ≠ i ∧ f ≠ i then 1 else 0) := by
+    by_cases he : e = i <;> by_cases hf : f = i <;> simp [extrasA, he, hf]
+  simp_rw [hi]
+  rw [← Finset.mul_sum, Finset.sum_boole]
+  have hc : (Finset.univ.filter fun i : Fin 3 => e ≠ i ∧ f ≠ i).card = 1 := by
+    have he : (Finset.univ.filter fun i : Fin 3 => e ≠ i ∧ f ≠ i) =
+        (Finset.univ.erase e).erase f := by
+      ext i
+      simp [and_comm, ne_comm]
+    rw [he, Finset.card_erase_of_mem (by simp [hef.symm]),
+      Finset.card_erase_of_mem (Finset.mem_univ e)]
+    simp
+  rw [hc]
+  norm_num
+
+theorem slotB_extra_joint (e f : Fin 3) :
+    Fintype.card {b : SlotB // e ∈ extrasB b ∧ f ∈ extrasB b} = 258 := by
+  rw [Fintype.card_subtype, Finset.card_filter, Fintype.sum_sum_type]
+  simp [extrasB]
+
+theorem line_single_card (p : Point) : Fintype.card {l : Line // p ∈ l} = 129 := by
+  rw [Fintype.card_subtype]
+  exact linesOn_card p
+
+theorem line_joint_card (p q : Point) (hpq : p ≠ q) :
+    Fintype.card {l : Line // p ∈ l ∧ q ∈ l} = 1 := by
+  rw [Fintype.card_subtype]
+  have he : (Finset.univ.filter fun l : Line => p ∈ l ∧ q ∈ l) =
+      linesOn p ∩ linesOn q := by ext l; simp [linesOn]
+  rw [he, linesOn_inter_card hpq]
+
+/-- Counts of joint carriers can be computed in a general independent
+line-slot-replica type, so both sides use literally the same geometry. -/
+theorem joint_ordinary {S : Type*} [Fintype S] (extra : S → Finset (Fin 3))
+    (N : ℕ) (p q : Point) (hpq : p ≠ q) :
+    Fintype.card {x : Line × S × Fin N //
+      Sum.inl p ∈ (pointsOn x.1).disjSum (extra x.2.1) ∧
+      Sum.inl q ∈ (pointsOn x.1).disjSum (extra x.2.1)} = Fintype.card S * N := by
+  have he (x : Line × S × Fin N) :
+      (Sum.inl p ∈ (pointsOn x.1).disjSum (extra x.2.1) ∧
+       Sum.inl q ∈ (pointsOn x.1).disjSum (extra x.2.1)) ↔ (p ∈ x.1 ∧ q ∈ x.1) := by
+    simp
+  rw [Fintype.card_congr (Equiv.subtypeEquivRight he),
+    card_prod_fst (V := S × Fin N) (fun l : Line => p ∈ l ∧ q ∈ l),
+    line_joint_card p q hpq, Fintype.card_prod, Fintype.card_fin, one_mul]
+
+theorem joint_mixed {S : Type*} [Fintype S] (extra : S → Finset (Fin 3))
+    (N : ℕ) (p : Point) (e : Fin 3) :
+    Fintype.card {x : Line × S × Fin N //
+      Sum.inl p ∈ (pointsOn x.1).disjSum (extra x.2.1) ∧
+      Sum.inr e ∈ (pointsOn x.1).disjSum (extra x.2.1)} =
+      129 * Fintype.card {s : S // e ∈ extra s} * N := by
+  have he (x : Line × S × Fin N) :
+      (Sum.inl p ∈ (pointsOn x.1).disjSum (extra x.2.1) ∧
+       Sum.inr e ∈ (pointsOn x.1).disjSum (extra x.2.1)) ↔
+      (p ∈ x.1 ∧ e ∈ extra x.2.1) := by simp
+  rw [Fintype.card_congr (Equiv.subtypeEquivRight he),
+    card_prod_both (fun l : Line => p ∈ l) (fun x : S × Fin N => e ∈ extra x.1),
+    card_prod_fst (V := Fin N) (fun s : S => e ∈ extra s), line_single_card p, Fintype.card_fin]
+  ring
+
+theorem joint_extras {S : Type*} [Fintype S] (extra : S → Finset (Fin 3))
+    (N : ℕ) (e f : Fin 3) :
+    Fintype.card {x : Line × S × Fin N //
+      Sum.inr e ∈ (pointsOn x.1).disjSum (extra x.2.1) ∧
+      Sum.inr f ∈ (pointsOn x.1).disjSum (extra x.2.1)} =
+      16513 * Fintype.card {s : S // e ∈ extra s ∧ f ∈ extra s} * N := by
+  have he (x : Line × S × Fin N) :
+      (Sum.inr e ∈ (pointsOn x.1).disjSum (extra x.2.1) ∧
+       Sum.inr f ∈ (pointsOn x.1).disjSum (extra x.2.1)) ↔
+      (e ∈ extra x.2.1 ∧ f ∈ extra x.2.1) := by simp
+  rw [Fintype.card_congr (Equiv.subtypeEquivRight he),
+    card_prod_snd (U := Line) (fun x : S × Fin N => e ∈ extra x.1 ∧ f ∈ extra x.1),
+    card_prod_fst (V := Fin N) (fun s : S => e ∈ extra s ∧ f ∈ extra s), point_card, Fintype.card_fin]
+  ring
+
+end Types
+end TorsionFreeZeroDivisors
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/GroupRing/PatternTotalCoding.lean b/lean/OAI/Algebra/GroupRing/PatternTotalCoding.lean
new file mode 100644
index 0000000000000000000000000000000000000000..a75bdac4bb149d50eb8c239f85173fcdc800b13d
--- /dev/null
+++ b/lean/OAI/Algebra/GroupRing/PatternTotalCoding.lean
@@ -0,0 +1,499 @@
+import Mathlib
+import OAI.Algebra.GroupRing.ComparisonCoding
+
+namespace OAI
+
+noncomputable section
+
+namespace TorsionFreeZeroDivisors.PatternTotalCoding
+open scoped Classical
+open PatternCoding
+
+abbrev Code (R K T I H : ℕ) := SizedCode R K T 0 H ×
+  (Fin R → Bool) × Fin (I+1) × ComparisonCoding.Code K I H
+
+def coefficient (R K T I : ℕ) :=
+  (R+1)^2*(K+1)*PatternCoding.coefficient R K T 0*2^R*(I+1)*ComparisonCoding.coefficient K I
+
+lemma card_code_bound (R K T I H : ℕ) : Fintype.card (Code R K T I H) ≤
+    coefficient R K T I*(H+1)^(R+3*I) := by
+  have h1 := card_sizedCode R K T 0 H
+  have h2 := ComparisonCoding.card_code_bound K I H
+  simp only [Nat.mul_zero,Nat.add_zero,Nat.zero_add,Nat.mul_one] at h1
+  have h := Nat.mul_le_mul (Nat.mul_le_mul_right (2^R*(I+1)) h1) h2
+  have he : Fintype.card (Code R K T I H)=Fintype.card (SizedCode R K T 0 H)*(2^R*((I+1)*Fintype.card (ComparisonCoding.Code K I H))) := by
+    simp only [Code,Fintype.card_prod,Fintype.card_fun,Fintype.card_fin,Fintype.card_bool]
+  rw [he]
+  simp only [coefficient,pow_add]
+  convert h using 1 <;> ring
+
+variable {D V P E D' V' P' E' : Type*}
+    [Fintype D] [Fintype V] [Fintype P] [Fintype E]
+    [Fintype D'] [Fintype V'] [Fintype P'] [Fintype E']
+    (R K T I H : ℕ) (hR : 0<R) (hK : 0<K) (hI : 0<I)
+    (hD : Fintype.card D≤R) (hV : Fintype.card V≤R)
+    (hP : Fintype.card P≤K) (hE : Fintype.card E≤I)
+
+def encode (a : Data D V P (Fin 0) T H) (side : V → Bool)
+    (c : ComparisonCoding.Data P E H) : Code R K T I H :=
+  (encodeData R K T 0 H hR hD hV hP (by simp) a,
+   pad R hV false side,⟨Fintype.card E,by omega⟩,ComparisonCoding.encode K I H hK hI hP hE c)
+
+variable (hD' : Fintype.card D'≤R) (hV' : Fintype.card V'≤R)
+    (hP' : Fintype.card P'≤K) (hE' : Fintype.card E'≤I)
+
+/-- Complete simultaneous code equivalence for graph, every marked vertex side,
+path words, root and the full affine interval geometry. Padding loses no data. -/
+theorem complete (a : Data D V P (Fin 0) T H) (side : V → Bool)
+    (c : ComparisonCoding.Data P E H)
+    (a' : Data D' V' P' (Fin 0) T H) (side' : V' → Bool)
+    (c' : ComparisonCoding.Data P' E' H)
+    (he : encode R K T I H hR hK hI hD hV hP hE a side c=
+      encode R K T I H hR hK hI hD' hV' hP' hE' a' side' c') :
+    ∃ f : PatternCoding.Isomorphism a a', ∃ g : ComparisonCoding.Isomorphism H c c',
+      f.path=g.path ∧ (∀ d,(Fintype.equivFin D' (f.dart d)).val=(Fintype.equivFin D d).val) ∧
+      ∀ v,side v=side' (f.vertex v) := by
+  simp only [encode,encodeData,Prod.mk.injEq] at he
+  obtain ⟨⟨cd,cv,cp,_,ha⟩,hs,ce,hc⟩ := he
+  have cD : Fintype.card D=Fintype.card D' := congrArg Fin.val cd
+  have cV : Fintype.card V=Fintype.card V' := congrArg Fin.val cv
+  have cP : Fintype.card P=Fintype.card P' := congrArg Fin.val cp
+  have cE : Fintype.card E=Fintype.card E' := congrArg Fin.val ce
+  obtain ⟨f,fd,fp,fv⟩ := same_code_canonical_isomorphism R K T 0 H hR hD hV hP (by simp)
+    hD' hV' hP' (by simp) a a' cD cV cP rfl ha
+  obtain ⟨g,gp,_⟩ := ComparisonCoding.encode_complete K I H hK hI hP hE hP' hE' c c' cP cE hc
+  refine ⟨f,g,fp.trans gp.symm,?_,?_⟩
+  · intro d
+    rw [fd]
+    exact rename_rank cD d
+  · intro v
+    rw [fv]
+    exact same_pad R hV hV' cV false side side' hs v
+
+end TorsionFreeZeroDivisors.PatternTotalCoding
+
+namespace TorsionFreeZeroDivisors.BoundedPattern
+open scoped Classical
+open PortSubdivision ChainSuppression DegreeTwoSuppression SuppressedMoore ChainPaths ChainIsomorphism
+open ChainChunkTransport ChunkComparisons FiniteChunking ComparedBlocks RankedSuppressionIso
+
+/-- The literal finite pattern data. These are only combinatorial encoding
+bounds; none of the probability or realizability conclusions is a field. -/
+structure Data (R K T I H : ℕ) where
+  V : Type
+  D : Type
+  P : Type
+  E : Type
+  [fV : Fintype V]
+  [fD : Fintype D]
+  [fP : Fintype P]
+  [fE : Fintype E]
+  graph : PortGraph V D
+  mark : V → Prop
+  degree_two : ∀ v,¬mark v → (out graph.origin v).card=2
+  covered : ∀ d,ChainCoverage.Covered graph.reverse (turn graph.origin mark degree_two)
+    graph.reverse_reverse (turn_involutive graph.origin mark degree_two) d
+  side : V → Bool
+  side_edge : ∀ d,side (graph.origin (graph.reverse d))=side (graph.origin d)
+  paths : P → List {d : D // turn graph.origin mark degree_two d=d}
+  nonempty : ∀ p,paths p≠[]
+  root : Option P
+  comparisons : Comparisons (E:=E) (pathLength (chunks graph mark degree_two paths)
+    (chunkLength graph mark degree_two paths))
+  lower : E → Fin (H+1)
+  upper : E → Fin (H+1)
+  offset : E → Fin (4*H+1)
+  lower_eq : ∀ e,comparisons.lo e=(lower e).val
+  upper_eq : ∀ e,comparisons.hi e=(upper e).val
+  offset_eq : ∀ e,comparisons.offset e=((offset e).val:ℤ)-2*H
+  dart_bound : Fintype.card {d : D // turn graph.origin mark degree_two d=d}≤R
+  vertex_bound : Fintype.card (Mark mark)≤R
+  path_bound : Fintype.card P≤K
+  comparison_bound : Fintype.card E≤I
+  chain_length_bound : ∀ d,chainLength graph mark degree_two d≤H
+  traversal_bound : ∀ p,(paths p).length≤T
+
+attribute [instance] Data.fV Data.fD Data.fP Data.fE
+
+namespace Data
+variable {R K T I H : ℕ} (a : Data R K T I H)
+
+abbrev Seeds := {d : a.D // turn a.graph.origin a.mark a.degree_two d=d}
+abbrev Marks := Mark a.mark
+abbrev lengths : a.P → ℕ := pathLength (chunks a.graph a.mark a.degree_two a.paths)
+  (chunkLength a.graph a.mark a.degree_two a.paths)
+
+def graphData : PatternCoding.Data a.Seeds a.Marks a.P (Fin 0) T H where
+  reverse := (skeleton a.graph a.mark a.degree_two).reverse
+  origin := (skeleton a.graph a.mark a.degree_two).origin
+  side d := a.side (a.graph.origin d.val)
+  length d := ⟨chainLength a.graph a.mark a.degree_two d,by have := a.chain_length_bound d; omega⟩
+  paths := a.paths
+  path_bound := a.traversal_bound
+  root := a.root.map (fun p => (p,true))
+  comparisons := Fin.elim0
+
+def geometryData : ComparisonCoding.Data a.P a.E H where
+  flip := a.comparisons.flip
+  source := a.comparisons.source
+  lower := a.lower
+  upper := a.upper
+  reverse := a.comparisons.reverse
+  offset := a.offset
+
+def encode (hR : 0<R) (hK : 0<K) (hI : 0<I) : PatternTotalCoding.Code R K T I H :=
+  PatternTotalCoding.encode R K T I H hR hK hI a.dart_bound a.vertex_bound
+    a.path_bound a.comparison_bound a.graphData (fun v => a.side v.val) a.geometryData
+
+end Data
+end TorsionFreeZeroDivisors.BoundedPattern
+
+namespace TorsionFreeZeroDivisors.PatternFiniteUnion
+open scoped Classical
+
+/-- Quotient-free finite union over a possibly large class of finite graphs.
+Representatives are chosen only for used codes, and encode equality must preserve
+the literal sample event. -/
+theorem bound {P : Type*} {C Ω : Type*} [Fintype C]
+    (sample : Finset Ω) (hs : sample.Nonempty) (code : P → C) (good : P → Prop)
+    (event : P → Ω → Prop) (B : ℝ) (hB : 0≤B)
+    (hinv : ∀ p q, code p=code q → ∀ ω,event p ω → event q ω)
+    (hp : ∀ p,good p → ((sample.filter (event p)).card:ℝ)/sample.card≤B) :
+    ((sample.filter (fun ω => ∃ p,good p ∧ event p ω)).card:ℝ)/sample.card≤
+      (Fintype.card C:ℝ)*B := by
+  let Used := {c : C // ∃ p,good p ∧ code p=c}
+  let representative (c : Used) : P := Classical.choose c.property
+  have hr (c : Used) : good (representative c) ∧ code (representative c)=c.val :=
+    Classical.choose_spec c.property
+  have hc : sample.filter (fun ω => ∃ p,good p ∧ event p ω)⊆
+      sample.filter (fun ω => ∃ c : Used,event (representative c) ω) := by
+    intro ω hω
+    obtain ⟨hω,p,hp,he⟩ := Finset.mem_filter.mp hω
+    refine Finset.mem_filter.mpr ⟨hω,?_,?_⟩
+    · exact ⟨code p,p,hp,rfl⟩
+    · exact hinv p (representative ⟨code p,p,hp,rfl⟩) (hr (⟨code p,p,hp,rfl⟩ : Used)).2.symm ω he
+  calc
+    _ ≤ ((sample.filter (fun ω => ∃ c : Used,event (representative c) ω)).card:ℝ)/sample.card :=
+      div_le_div_of_nonneg_right (Nat.cast_le.mpr (Finset.card_le_card hc)) (Nat.cast_nonneg _)
+    _ ≤ (Fintype.card Used:ℝ)*B :=
+      StageFusion.pattern_union sample hs _ B (fun c => hp _ (hr c).1)
+    _ ≤ _ := mul_le_mul_of_nonneg_right (Nat.cast_le.mpr (Fintype.card_subtype_le _)) hB
+
+end TorsionFreeZeroDivisors.PatternFiniteUnion
+
+namespace TorsionFreeZeroDivisors.BoundedPattern.Data
+
+section
+open scoped Classical
+open PortSubdivision ChainSuppression DegreeTwoSuppression SuppressedMoore ChainPaths ChainIsomorphism
+open ChainChunkTransport ChunkComparisons FiniteChunking ComparedBlocks RankedSuppressionIso
+variable {R K T I H : ℕ} (a b : Data R K T I H)
+
+def event (rep : ℕ) (x : Types.VertexA rep) (y : Types.VertexB rep) (r : ActualPatternEvent.Match rep) : Prop :=
+  OriginalPattern.Realized a.graph a.mark a.degree_two a.side a.side_edge a.paths a.nonempty
+    a.root rep x y a.comparisons r
+
+/-- Equal finite codes transport every fixed matching event, including both
+pinned source sides. The code does not contain any graph labels. -/
+theorem event_of_encode_eq (hR : 0<R) (hK : 0<K) (hI : 0<I)
+    (he : a.encode hR hK hI=b.encode hR hK hI)
+    (rep : ℕ) (x : Types.VertexA rep) (y : Types.VertexB rep) (r : ActualPatternEvent.Match rep)
+    (hb : b.event rep x y r) : a.event rep x y r := by
+  obtain ⟨f,g,hpg,hrank,hside⟩ := PatternTotalCoding.complete R K T I H hR hK hI
+    a.dart_bound a.vertex_bound a.path_bound a.comparison_bound
+    b.dart_bound b.vertex_bound b.path_bound b.comparison_bound
+    a.graphData (fun v => a.side v.val) a.geometryData
+    b.graphData (fun v => b.side v.val) b.geometryData he
+  let f₀ : PortSubdivision.Iso (skeleton a.graph a.mark a.degree_two)
+      (skeleton b.graph b.mark b.degree_two) :=
+    ⟨f.vertex,f.dart,f.origin_eq,f.reverse_eq⟩
+  have hlen (d : a.Seeds) : chainLength a.graph a.mark a.degree_two d=
+      chainLength b.graph b.mark b.degree_two (f₀.dart d) := congrArg Fin.val (f.length_eq d)
+  let F := full a.graph a.mark a.degree_two b.graph b.mark b.degree_two a.covered b.covered f₀ hrank hlen
+  have words (p : a.P) : ((a.paths p).flatMap (word a.graph a.mark a.degree_two)).map F.dart=
+      (b.paths (f.path p)).flatMap (word b.graph b.mark b.degree_two) :=
+    full_words a.graph a.mark a.degree_two b.graph b.mark b.degree_two a.covered b.covered
+      f₀ hrank hlen a.paths b.paths f.path f.paths_eq p
+  have hroot : a.root.map f.path=b.root := by
+    have hh := congrArg (Option.map Prod.fst) f.root_eq
+    simpa [graphData,Option.map_map,Function.comp_def] using hh
+  have sides (v : a.V) : a.side v=b.side (F.vertex v) :=
+    full_side a.graph a.mark a.degree_two b.graph b.mark b.degree_two a.covered b.covered f₀ hrank hlen
+      a.side b.side a.side_edge b.side_edge hside v
+  have roots : (StageRoot.source a.graph a.mark a.degree_two a.paths a.nonempty a.root).map F.vertex=
+      StageRoot.source b.graph b.mark b.degree_two b.paths b.nonempty b.root :=
+    full_source a.graph a.mark a.degree_two b.graph b.mark b.degree_two a.covered b.covered f₀ hrank hlen
+      a.paths b.paths f.path f.paths_eq a.nonempty b.nonempty a.root b.root hroot
+  let geometry : ComparisonGeometry.Iso a.comparisons b.comparisons := {
+    path := f.path
+    comparison := g.comparison
+    length_eq := OriginalPatternIso.length_eq a.graph a.mark a.degree_two b.graph b.mark b.degree_two
+      a.paths b.paths F f.path words
+    flip_eq := g.flip_eq
+    source_eq := by intro e; rw [hpg]; exact g.source_eq e
+    lo_eq := by
+      intro e
+      rw [a.lower_eq,b.lower_eq]
+      exact_mod_cast congrArg Fin.val (g.lower_eq e)
+    hi_eq := by
+      intro e
+      rw [a.upper_eq,b.upper_eq]
+      exact_mod_cast congrArg Fin.val (g.upper_eq e)
+    reverse_eq := g.reverse_eq
+    offset_eq := by
+      intro e
+      rw [a.offset_eq,b.offset_eq]
+      have ho := congrArg Fin.val (g.offset_eq e)
+      exact congrArg (fun n : ℕ => (n:ℤ)-2*H) ho }
+  exact OriginalPatternIso.realized a.graph a.mark a.degree_two b.graph b.mark b.degree_two
+    a.paths a.nonempty b.paths b.nonempty F f.path words a.side b.side a.side_edge b.side_edge
+    sides a.root b.root roots a.comparisons b.comparisons geometry rfl rep x y r hb
+
+end
+
+open scoped Classical BigOperators
+open PortSubdivision ChainSuppression DegreeTwoSuppression SuppressedMoore ChainPaths ChainIsomorphism
+open ChainChunkTransport ChunkComparisons FiniteChunking ComparedBlocks ActualPatternEvent
+open GridAsymptotics GirthAsymptotics TypedGraphs
+variable {R K T I H : ℕ} (a : Data R K T I H)
+
+abbrev multiplicity := ChunkComparisons.multiplicity (color a.graph a.mark a.degree_two a.paths)
+abbrev totalLength : ℝ := ∑ p, (((a.paths p).flatMap (word a.graph a.mark a.degree_two)).length:ℝ)
+
+/-- The manuscript's deterministic hypotheses for the bounded first moment.
+Every condition concerns only the unlabeled graph, paths or comparisons. -/
+structure Good (B Q M J rep : ℕ) : Prop where
+  multiplicity_le : ∀ c,a.multiplicity c≤M
+  multiplicity_pos : ∀ c,1≤a.multiplicity c
+  path_chain : ∀ p,List.IsChain (WeightedMoore.PortWalk.step
+    (suppressed a.graph a.mark a.degree_two).origin (suppressed a.graph a.mark a.degree_two).reverse) (a.paths p)
+  cyclic_chain : ∀ p,StageRoot.cyclic a.root p=true →
+    ∀ᵉ (x∈(a.paths p).getLast?) (y∈(a.paths p).head?),
+      WeightedMoore.PortWalk.step (suppressed a.graph a.mark a.degree_two).origin
+        (suppressed a.graph a.mark a.degree_two).reverse x y
+  reduced : ∀ x e,a.comparisons.side x=some e →
+    originalDart a.graph a.mark a.degree_two a.paths x≠
+      originalDart a.graph a.mark a.degree_two a.paths (a.comparisons.pairing.partner x) ∧
+    originalDart a.graph a.mark a.degree_two a.paths x≠a.graph.reverse
+      (originalDart a.graph a.mark a.degree_two a.paths (a.comparisons.pairing.partner x))
+  chains_le : Fintype.card (Rep a.graph a.mark a.degree_two)≤Q
+  cut_comparisons_le : Fintype.card a.E*(Fintype.card (RepeatedBlocks.Traversal a.multiplicity))^2≤J
+  length_le : a.totalLength≤B*(L (size rep):ℝ)
+  length_ge : (L (size rep):ℝ)≤a.totalLength
+  unpaired_le : ((Finset.univ.filter (fun x => a.comparisons.pairing.partner x=x)).card:ℝ)≤
+    StageFusion.epsilon (1/600) 256*a.totalLength
+
+lemma probability_bound (B Q M J rep : ℕ) (hM : 0<M) (hready : PatternUniform.Ready B M Q J rep)
+    (hg : a.Good B Q M J rep) (x : Types.VertexA rep) (y : Types.VertexB rep) :
+    (((samples rep).filter (a.event rep x y)).card:ℝ)/(samples rep).card≤
+      Real.exp (-(L (size rep):ℝ)/(4800*M)) := by
+  exact OriginalPattern.probability_bound a.graph a.mark a.degree_two a.side a.side_edge a.paths a.nonempty
+    a.root rep x y a.comparisons (fun e => (a.lower e).val) (fun e => (a.upper e).val)
+    (by simpa only [Int.cast_natCast] using a.lower_eq)
+    (by simpa only [Int.cast_natCast] using a.upper_eq)
+    B Q M J hM hready hg.multiplicity_le hg.multiplicity_pos hg.path_chain hg.cyclic_chain
+    hg.reduced hg.chains_le hg.cut_comparisons_le hg.length_le hg.length_ge hg.unpaired_le
+
+end TorsionFreeZeroDivisors.BoundedPattern.Data
+
+namespace TorsionFreeZeroDivisors.BoundedPattern
+open scoped Classical
+open ActualPatternEvent GirthAsymptotics TypedGraphs
+
+/-- Uniform first-moment union over every actual-carrier pattern, not over a
+postulated finite list of realizations. -/
+theorem probability_union (R K T I H B Q M J rep : ℕ)
+    (hR : 0<R) (hK : 0<K) (hI : 0<I) (hM : 0<M)
+    (hs : (samples rep).Nonempty) (hready : PatternUniform.Ready B M Q J rep)
+    (x : Types.VertexA rep) (y : Types.VertexB rep) :
+    (((samples rep).filter (fun r => ∃ a : Data R K T I H,a.Good B Q M J rep ∧ a.event rep x y r)).card:ℝ)/
+      (samples rep).card≤
+      (PatternTotalCoding.coefficient R K T I:ℝ)*(H+1:ℕ)^(R+3*I)*
+        Real.exp (-(L (size rep):ℝ)/(4800*M)) := by
+  have he := PatternFiniteUnion.bound (samples rep) hs (fun a : Data R K T I H => a.encode hR hK hI)
+    (fun a => a.Good B Q M J rep) (fun a => a.event rep x y) _ (Real.exp_pos _).le
+    (fun a b hab r ha => b.event_of_encode_eq a hR hK hI hab.symm rep x y r ha)
+    (fun a ha => a.probability_bound B Q M J rep hM hready ha x y)
+  apply he.trans
+  apply mul_le_mul_of_nonneg_right _ (Real.exp_pos _).le
+  exact_mod_cast PatternTotalCoding.card_code_bound R K T I H
+
+end TorsionFreeZeroDivisors.BoundedPattern
+
+namespace TorsionFreeZeroDivisors.ActualComplexity
+open scoped Classical BigOperators
+open PortSubdivision DegreeTwoSuppression CoreStripping ImageComplexity
+open ChainSuppression SuppressedMoore ChainPaths ChainIsomorphism ChainChunkTransport
+variable {V D P : Type} [Fintype V] [Fintype D] [Fintype P] (Γ : PortGraph V D)
+
+omit [Fintype V] in
+lemma leaf_unique {v : V} (hv : degree Γ Finset.univ v=1) {a b : D}
+    (ha : Γ.origin a=v) (hb : Γ.origin b=v) : a=b := by
+  obtain ⟨d,hd⟩ := Finset.card_eq_one.mp hv
+  have hma : a∈Finset.univ.filter (fun d => Γ.origin d=v) := by simp [ha]
+  have hmb : b∈Finset.univ.filter (fun d => Γ.origin d=v) := by simp [hb]
+  change Finset.univ.filter (fun d => Γ.origin d=v)={d} at hd
+  rw [hd] at hma hmb
+  exact (Finset.mem_singleton.mp hma).trans (Finset.mem_singleton.mp hmb).symm
+
+omit [Fintype V] in
+lemma step_not_leaf {a b : D} (h : WeightedMoore.PortWalk.step Γ.origin Γ.reverse a b) :
+    degree Γ Finset.univ (Γ.origin b)≠1 ∧ degree Γ Finset.univ (Γ.origin (Γ.reverse a))≠1 := by
+  constructor <;> intro he
+  · exact h.2 (leaf_unique Γ he rfl h.1)
+  · exact h.2 (leaf_unique Γ he h.1.symm rfl)
+
+omit [Fintype V] in
+lemma origin_leaf_head (p : List D)
+    (hp : p.IsChain (WeightedMoore.PortWalk.step Γ.origin Γ.reverse))
+    {d : D} (hd : d∈p) (hv : degree Γ Finset.univ (Γ.origin d)=1) : d∈p.head? := by
+  induction p with
+  | nil => simp at hd
+  | cons a p ih =>
+    rcases List.mem_cons.mp hd with rfl|hd
+    · simp
+    · have hh := ih hp.tail hd
+      cases p with
+      | nil => simp at hd
+      | cons b p =>
+        have he : b=d := by simpa using hh
+        subst d
+        exact ((step_not_leaf Γ (List.isChain_cons_cons.mp hp).1).1 hv).elim
+
+omit [Fintype V] in
+lemma target_leaf_last (p : List D)
+    (hp : p.IsChain (WeightedMoore.PortWalk.step Γ.origin Γ.reverse))
+    {d : D} (hd : d∈p) (hv : degree Γ Finset.univ (Γ.origin (Γ.reverse d))=1) :
+    d∈p.getLast? := by
+  induction p with
+  | nil => simp at hd
+  | cons a p ih =>
+    cases p with
+    | nil => simpa only [List.getLast?_singleton,Option.mem_some_iff] using (List.mem_singleton.mp hd).symm
+    | cons b p =>
+      rcases List.mem_cons.mp hd with rfl|hd
+      · exact ((step_not_leaf Γ (List.isChain_cons_cons.mp hp).1).2 hv).elim
+      · simpa only [List.getLast?_cons_cons] using ih hp.tail hd
+
+variable (paths : P → List D) (hp : ∀ p,paths p≠[])
+def start (p : P) : D := (paths p).head (hp p)
+def finish (p : P) : D := (paths p).getLast (hp p)
+def endpoints : Finset V :=
+  (Finset.univ.image fun p => Γ.origin (start paths hp p)) ∪
+    (Finset.univ.image fun p => Γ.origin (Γ.reverse (finish paths hp p)))
+
+omit [Fintype V] [Fintype D] in
+lemma endpoints_card : (endpoints Γ paths hp).card≤2*Fintype.card P := by
+  exact (Finset.card_union_le _ _).trans (by
+    have ha := Finset.card_image_le (s:=Finset.univ) (f:=fun p => Γ.origin (start paths hp p))
+    have hb := Finset.card_image_le (s:=Finset.univ) (f:=fun p => Γ.origin (Γ.reverse (finish paths hp p)))
+    rw [Finset.card_univ] at ha hb
+    omega)
+
+omit [Fintype V] [Fintype D] in
+lemma start_mem (p : P) {d : D} (hd : d∈(paths p).head?) : Γ.origin d∈endpoints Γ paths hp := by
+  have he : start paths hp p=d := by
+    simpa only [start,List.head?_eq_some_head (hp p),Option.mem_some_iff] using hd
+  apply Finset.mem_union_left
+  exact Finset.mem_image.mpr ⟨p,Finset.mem_univ _,congrArg Γ.origin he⟩
+
+omit [Fintype V] [Fintype D] in
+lemma finish_mem (p : P) {d : D} (hd : d∈(paths p).getLast?) :
+    Γ.origin (Γ.reverse d)∈endpoints Γ paths hp := by
+  have he : finish paths hp p=d := by
+    simpa only [finish,List.getLast?_eq_some_getLast (hp p),Option.mem_some_iff] using hd
+  apply Finset.mem_union_right
+  exact Finset.mem_image.mpr ⟨p,Finset.mem_univ _,congrArg (fun d => Γ.origin (Γ.reverse d)) he⟩
+
+include hp in
+lemma leaf_bound
+    (hc : ∀ p,(paths p).IsChain (WeightedMoore.PortWalk.step Γ.origin Γ.reverse))
+    (hi : ∀ d,∃ p,d∈paths p ∨ Γ.reverse d∈paths p) :
+    (Finset.univ.filter (fun v => degree Γ Finset.univ v=1)).card≤2*Fintype.card P := by
+  apply (Finset.card_le_card ?_).trans (endpoints_card Γ paths hp)
+  intro v hv
+  have hv := (Finset.mem_filter.mp hv).2
+  obtain ⟨d,hd⟩ := Finset.card_pos.mp (show 0<(Finset.univ.filter (fun d => Γ.origin d=v)).card by
+    change 0<degree Γ Finset.univ v
+    omega)
+  have ho := (Finset.mem_filter.mp hd).2
+  obtain ⟨p,hp'⟩ := hi d
+  rcases hp' with hm|hm
+  · exact ho ▸ start_mem Γ paths hp p (origin_leaf_head Γ _ (hc p) hm (ho ▸ hv))
+  · have he : degree Γ Finset.univ (Γ.origin (Γ.reverse (Γ.reverse d)))=1 := by simpa [ho] using hv
+    have ht := finish_mem Γ paths hp p (target_leaf_last Γ _ (hc p) hm he)
+    rw [Γ.reverse_reverse d,ho] at ht
+    exact ht
+
+omit [Fintype V] in
+lemma dart_count (hi : ∀ d,∃ p,d∈paths p ∨ Γ.reverse d∈paths p) :
+    Fintype.card D≤2*∑ p,(paths p).length := by
+  let f : ((p : P) × Fin (paths p).length) × Bool → D := fun o =>
+    if o.2 then Γ.reverse ((paths o.1.1).get o.1.2) else (paths o.1.1).get o.1.2
+  have hs : Function.Surjective f := by
+    intro d
+    obtain ⟨p,hp⟩ := hi d
+    rcases hp with hp|hp
+    · obtain ⟨i,hi⟩ := List.mem_iff_get.mp hp
+      exact ⟨(⟨p,i⟩,false),hi⟩
+    · obtain ⟨i,hi⟩ := List.mem_iff_get.mp hp
+      refine ⟨(⟨p,i⟩,true),?_⟩
+      change Γ.reverse ((paths p).get i)=d
+      rw [hi,Γ.reverse_reverse]
+  have hh := Fintype.card_le_of_surjective f hs
+  simpa only [Fintype.card_prod,Fintype.card_bool,Fintype.card_sigma,Fintype.card_fin,Nat.mul_comm] using hh
+
+lemma marked_vertices_le (mark : V → Prop)
+    (h2 : ∀ v,¬mark v → (out Γ.origin v).card=2)
+    (hv : Function.Surjective Γ.origin) :
+    Fintype.card (Mark mark)≤Fintype.card {d : D // turn Γ.origin mark h2 d=d} := by
+  let f : {d : D // turn Γ.origin mark h2 d=d} → Mark mark := fun d =>
+    ⟨Γ.origin d.val,(turn_fixed_iff Γ.origin mark h2 d.val).mp d.property⟩
+  apply Fintype.card_le_of_surjective f
+  intro v
+  obtain ⟨d,hd⟩ := hv v.val
+  refine ⟨⟨d,turn_of_mark Γ.origin mark h2 d (hd ▸ v.property)⟩,?_⟩
+  exact Subtype.ext hd
+
+/-- Complexity is uniform before choosing any finite actual image. The coarser
+2K leaf bound suffices and does not assume any of the image complexity estimates. -/
+theorem bounded_suppression (B K : ℕ) : ∃ R : ℕ,0<R ∧
+    ∀ {V D P : Type} [Fintype V] [Fintype D] [Fintype P]
+      (Γ : PortGraph V D) (paths : P → List D) (hp : ∀ p,paths p≠[])
+      (_ : Fintype.card P≤K) (_ : Function.Surjective Γ.origin)
+      (_ : ∀ p,(paths p).IsChain (WeightedMoore.PortWalk.step Γ.origin Γ.reverse))
+      (_ : ∀ d,∃ p,d∈paths p ∨ Γ.reverse d∈paths p)
+      (L : ℝ) (_ : 0<L) (_ : (∑ p,(paths p).length:ℕ)≤(B:ℝ)*L)
+      (_ : ∀ a (c : Γ.subdivision.Walk a a),c.IsCycle →
+        L≤WeightedCycles.weight (WeightedPortMoore.edgeWeight (fun _ : D => (1:ℝ))) c),
+      let M := endpoints Γ paths hp
+      let mark := MarkedChainBound.marks Γ M
+      let h2 := MarkedChainBound.marks_degree_two Γ M
+      Fintype.card {d : D // turn Γ.origin mark h2 d=d}≤R ∧
+        Fintype.card (Mark mark)≤R := by
+  obtain ⟨R,hR⟩ := bounded_image_branches (B:ℝ) (Nat.cast_nonneg _) (2*K)
+  refine ⟨R+6*K+1,by omega,?_⟩
+  intro V D P _ _ _ Γ paths hp hP hv hc hi L hL hH hg
+  dsimp only
+  have hleaf := leaf_bound Γ paths hp hc hi
+  have hdc := dart_count Γ paths hi
+  have hdc' : (Fintype.card D:ℝ)≤2*(B:ℝ)*L := by
+    have hdc' : (Fintype.card D:ℝ)≤2*(∑ p,(paths p).length:ℕ) := by exact_mod_cast hdc
+    nlinarith
+  have hleaf' : (Finset.univ.filter (fun v => degree Γ Finset.univ v=1)).card≤2*K :=
+    hleaf.trans (Nat.mul_le_mul_left _ hP)
+  have hb := hR Γ L hL hdc' hg hleaf'
+  have hm := endpoints_card Γ paths hp
+  have hd := MarkedChainBound.marked_dart_bound Γ (endpoints Γ paths hp)
+  have hseed : Fintype.card {d : D //
+      turn Γ.origin (MarkedChainBound.marks Γ (endpoints Γ paths hp))
+        (MarkedChainBound.marks_degree_two Γ (endpoints Γ paths hp)) d=d}≤R+6*K+1 := by
+    rw [MarkedChainBound.chain_dart_card]
+    omega
+  exact ⟨hseed,(marked_vertices_le Γ _ _ hv).trans hseed⟩
+
+end TorsionFreeZeroDivisors.ActualComplexity
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/GroupRing/PatternUniform.lean b/lean/OAI/Algebra/GroupRing/PatternUniform.lean
new file mode 100644
index 0000000000000000000000000000000000000000..6bfebbcb6d184119ddc51fa60563f6c74bde2011
--- /dev/null
+++ b/lean/OAI/Algebra/GroupRing/PatternUniform.lean
@@ -0,0 +1,363 @@
+import Mathlib
+import OAI.Algebra.GroupRing.SidePins
+
+namespace OAI
+
+noncomputable section
+
+namespace TorsionFreeZeroDivisors.PatternUniform
+open scoped Classical Topology BigOperators
+open Filter GridAsymptotics GirthAsymptotics TypedGraphs
+
+/-- Numerical conditions shared by every bounded pattern, with the threshold
+chosen before its carrier types, lengths, offsets, words or bin profile. -/
+def Ready (K M Q J rep : ℕ) : Prop :=
+  1 ≤ (L (size rep):ℝ) ∧ 0<size rep ∧
+  K*L (size rep)+exclusion (size rep)<StageDenominator.carrier rep ∧
+  GridUniform.binRate (L (size rep))≤1/(4800*M:ℝ) ∧
+  ∀ d≤J,
+    StageUniform.coefficient d K M Q*GridUniform.rate d (L (size rep))+
+      M*StageDenominator.error K Q rep/(L (size rep):ℝ) ≤ 1/4800 ∧
+    ∀ offset : Fin d → ℤ,3003≤chosenScale d (L (size rep)) offset ∧
+      2*(letterError d (L (size rep)) offset:ℝ)<chosenScale d (L (size rep)) offset-1
+
+theorem eventually_ready (K M Q J : ℕ) (hM : 0<M) :
+    ∀ᶠ rep in atTop,Ready K M Q J rep := by
+  have hL : Tendsto (fun rep => (L (size rep):ℝ)) atTop atTop :=
+    tendsto_natCast_atTop_atTop.comp (L_tendsto.comp size_tendsto)
+  have hb := (GridUniform.binRate_tendsto.comp hL).eventually_lt_const
+    (show (0:ℝ)<1/(4800*M:ℝ) by positivity)
+  have hd (d : Fin (J+1)) : ∀ᶠ rep in atTop,
+      StageUniform.coefficient d.val K M Q*GridUniform.rate d.val (L (size rep))+
+        M*StageDenominator.error K Q rep/(L (size rep):ℝ) ≤ 1/4800 ∧
+      ∀ offset : Fin d.val → ℤ,3003≤chosenScale d.val (L (size rep)) offset ∧
+        2*(letterError d.val (L (size rep)) offset:ℝ)<chosenScale d.val (L (size rep)) offset-1 := by
+    have hr := ((GridUniform.rate_tendsto d.val).comp hL).const_mul
+      (StageUniform.coefficient d.val K M Q)
+    have he := (StageDenominator.error_ratio K Q).const_mul (M:ℝ)
+    have ht := hr.add he
+    simp only [mul_zero,add_zero] at ht
+    have hevent := ht.eventually_lt_const (by norm_num : (0:ℝ)<1/4800)
+    filter_upwards [hevent,hL.eventually (GridUniform.eventually_geometry d.val)] with rep hr hg
+    refine ⟨?_,hg⟩
+    simpa only [Function.comp_def,mul_div_assoc] using hr.le
+  filter_upwards [eventually_all.mpr hd,hb,StageDenominator.eventually_room K,
+    hL.eventually (eventually_ge_atTop (1:ℝ)),size_tendsto.eventually (eventually_ge_atTop 1)]
+    with rep hd hb hr hL hn
+  exact ⟨hL,by omega,hr,hb.le,fun d hd' => hd ⟨d,by omega⟩⟩
+
+variable {C E : Type*} [Fintype C] [Fintype E]
+
+theorem Ready.residual {K M Q J rep : ℕ} (h : Ready K M Q J rep)
+    (hE : Fintype.card E≤J) (offset : Fin (Fintype.card E) → ℤ)
+    (len m : C → ℕ) (hQ : Fintype.card C≤Q)
+    (hH : StageMass.totalLength len m≤K*(L (size rep):ℝ))
+    (hlo : (L (size rep):ℝ)≤StageMass.totalLength len m) (hpos : ∀ c,1≤ m c) :
+    StageMass.residual (E:=E) (chosenScale (Fintype.card E) (L (size rep)) offset) len m
+      (letterError (Fintype.card E) (L (size rep)) offset) M Q
+      (StageDenominator.error K Q rep)≤StageMass.totalLength len m/4800 := by
+  have hh := StageUniform.residual_bound K M Q (L (size rep)) h.1 offset len m hQ hH hpos
+    (StageDenominator.error K Q rep)
+  have hb := (div_le_iff₀ (show (0:ℝ)<L (size rep) by linarith [h.1])).mp
+    (hh.trans (h.2.2.2.2 (Fintype.card E) hE).1)
+  linarith
+
+end TorsionFreeZeroDivisors.PatternUniform
+
+namespace TorsionFreeZeroDivisors.ActualPatternEvent
+open scoped Classical BigOperators
+open PortSubdivision ChainSuppression DegreeTwoSuppression SuppressedMoore ChainPaths ChainIsomorphism
+open ChainChunkTransport ChunkComparisons FiniteChunking StageSubgraphs StageSideEmbedding
+open ComparedBlocks RepeatedBlocks GridAsymptotics GirthAsymptotics TypedGraphs
+variable {V D P E : Type} [Fintype V] [Fintype D] [Fintype P]
+    (Γ : PortGraph V D) (mark : V → Prop) (h2 : ∀ v,¬mark v → (out Γ.origin v).card=2)
+    (side : V → Bool) (hsid : ∀ x,side (Γ.origin (Γ.reverse x))=side (Γ.origin x))
+    (paths : P → List {x : D // turn Γ.origin mark h2 x=x}) (hp : ∀ p,paths p≠[])
+    (root : Option P) (rep : ℕ) (a : Types.VertexA rep) (b : Types.VertexB rep)
+local notation "R" => Rep Γ mark h2
+local notation "m" => ChunkComparisons.multiplicity (color Γ mark h2 paths)
+local notation "len" => repLength Γ mark h2
+
+/-- The fixed-pattern event before any scale or bins are chosen. -/
+def Realized (cmp : Comparisons (E:=E) (traversalLength len m)) (r : Match rep) : Prop :=
+  ∃ label : D → Types.Letter,
+    (∀ x,label (Γ.reverse x)=Types.inverse (label x)) ∧
+    (∀ x y,Γ.origin x=Γ.origin y → label x=label y → x=y) ∧
+    ActualStageLabels.Comparing len m cmp (ActualStageFeasibility.globalWord Γ mark h2 label) ∧
+    Nonempty (RealizationTransport.Embedding (SideRestriction.graph Γ side hsid true)
+      (fun x => label x.val) (@Types.outgoingA rep)
+      (sourcePinA Γ mark h2 side paths hp root rep a) Types.inverse r.1) ∧
+    Nonempty (RealizationTransport.Embedding (SideRestriction.graph Γ side hsid false)
+      (fun x => label x.val) (@Types.outgoingB rep)
+      (sourcePinB Γ mark h2 side paths hp root rep b) Types.inverse r.2)
+
+omit [Fintype V] in
+lemma unbinned_iff (s : ℝ) (cmp : Comparisons (E:=E) (traversalLength len m)) (r : Match rep) :
+    Unbinned Γ mark h2 side hsid paths hp root rep a b s cmp r ↔
+      Realized Γ mark h2 side hsid paths hp root rep a b cmp r := by
+  constructor
+  · rintro ⟨d,label,hl,hi,hc,_,ha,hb⟩
+    exact ⟨label,hl,hi,hc,ha,hb⟩
+  · rintro ⟨label,hl,hi,hc,ha,hb⟩
+    exact ⟨_,label,hl,hi,hc,rfl,ha,hb⟩
+
+variable [Fintype E]
+
+def defect (cmp : Comparisons (E:=E) (traversalLength len m)) : ℕ :=
+  (Finset.univ.filter (fun x => cmp.pairing.partner x=x)).card
+
+omit [Fintype V] [Fintype E] in
+lemma uncovered_eq (s : ℝ) (hs : 0<s)
+    (cmp : Comparisons (E:=E) (traversalLength len m)) (err : ℕ) :
+    StageMass.uncovered s hs len m cmp err=defect Γ mark h2 paths cmp := by
+  unfold StageMass.uncovered defect OccurrenceMatching.Data.unpairedPositions
+  apply congrArg Finset.card
+  exact Finset.filter_congr_decidable _ _ _
+
+/-- Uniform probability bound with no entropy, moment or scale hypothesis.
+The ready threshold is independent of all carrier types and pattern data. -/
+theorem uniform_probability_bound (K Q M J : ℕ) (hM : 0<M)
+    (hready : PatternUniform.Ready K M Q J rep)
+    (cmp : Comparisons (E:=E) (traversalLength len m))
+    (hm : ∀ c,m c≤M) (hpositive : ∀ c,1≤ m c)
+    (hc : ∀ i, List.IsChain (WeightedMoore.PortWalk.step
+      (suppressed Γ mark h2).origin (suppressed Γ mark h2).reverse) (paths i))
+    (hclose : ∀ i,StageRoot.cyclic root i=true →
+      ∀ᵉ (x∈(paths i).getLast?) (y∈(paths i).head?),
+      WeightedMoore.PortWalk.step (suppressed Γ mark h2).origin (suppressed Γ mark h2).reverse x y)
+    (hreduced : ∀ x e,cmp.side x=some e →
+      (x.1.1,x.2.val)≠((cmp.pairing.partner x).1.1,(cmp.pairing.partner x).2.val))
+    (hQ : Fintype.card R≤Q) (hE : Fintype.card E≤J)
+    (hH : StageMass.totalLength len m ≤ K*(L (size rep):ℝ))
+    (hlo : (L (size rep):ℝ)≤StageMass.totalLength len m)
+    (hb : (defect Γ mark h2 paths cmp:ℝ)≤
+      StageFusion.epsilon (1/600) 256*StageMass.totalLength len m) :
+    (((samples rep).filter (Realized Γ mark h2 side hsid paths hp root rep a b cmp)).card:ℝ)/
+      (samples rep).card ≤ Real.exp (-(L (size rep):ℝ)/(4800*M)) := by
+  let eqv := Fintype.equivFin E
+  let off : Fin (Fintype.card E) → ℤ := fun i => cmp.offset (eqv.symm i)
+  let s := chosenScale (Fintype.card E) (L (size rep)) off
+  let err := letterError (Fintype.card E) (L (size rep)) off
+  have hs : 0<s := chosenScale_pos _ hready.1 off
+  obtain ⟨hl,he⟩ := (hready.2.2.2.2 (Fintype.card E) hE).2 off
+  obtain ⟨ν,hν⟩ := uniform_alignment (Fintype.card E) hready.1 off
+  have hν' (e : E) : 2*|(cmp.offset e:ℝ)-(ν (eqv e):ℝ)*s|+4≤err := by
+    simpa only [off,Equiv.symm_apply_apply] using hν (eqv e)
+  have hh (i : Underlying s len) := BinProfiles.height_bounds s hs.le len i
+  have hlarge (i : Underlying s len) : 3002≤height s len i := by
+    have h : (3002:ℝ)≤height s len i := by linarith [hh i]
+    exact_mod_cast h
+  have hres := hready.residual hE off len m hQ hH hlo hpositive
+  have hu := unbinned_probability_bound Γ mark h2 side hsid paths hp root rep a b s hs hl cmp
+    err K Q M hM hm hc hclose hlarge (fun i => by linarith [hh i])
+    (fun i => by linarith [hh i]) hreduced hready.2.1 hready.2.2.1 hQ hH
+    (fun e => ν (eqv e)) he hν' (by simpa only [uncovered_eq] using hb) hres hpositive
+    ((GridUniform.bin_bound (Fintype.card E) hready.1 off).trans hready.2.2.2.1)
+  have heq : (samples rep).filter (Realized Γ mark h2 side hsid paths hp root rep a b cmp)=
+      (samples rep).filter (Unbinned Γ mark h2 side hsid paths hp root rep a b s cmp) := by
+    ext r
+    simp only [Finset.mem_filter]
+    exact and_congr_right (fun _ => (unbinned_iff Γ mark h2 side hsid paths hp root rep a b s cmp r).symm)
+  rw [heq]
+  apply hu.trans
+  apply Real.exp_le_exp.mpr
+  exact div_le_div_of_nonneg_right (neg_le_neg hlo) (by positivity)
+
+end TorsionFreeZeroDivisors.ActualPatternEvent
+
+namespace TorsionFreeZeroDivisors.OriginalPattern
+open scoped Classical BigOperators
+open PortSubdivision ChainSuppression DegreeTwoSuppression SuppressedMoore ChainPaths ChainIsomorphism
+open ChainChunkTransport ChunkComparisons FiniteChunking StageSubgraphs StageSideEmbedding
+open ComparedBlocks RepeatedBlocks GridAsymptotics GirthAsymptotics TypedGraphs ActualPatternEvent
+variable {V D P E : Type} [Fintype V] [Fintype D] [Fintype P]
+    (Γ : PortGraph V D) (mark : V → Prop) (h2 : ∀ v,¬mark v → (out Γ.origin v).card=2)
+    (side : V → Bool) (hsid : ∀ x,side (Γ.origin (Γ.reverse x))=side (Γ.origin x))
+    (paths : P → List {x : D // turn Γ.origin mark h2 x=x}) (hp : ∀ p,paths p≠[])
+    (root : Option P) (rep : ℕ) (a : Types.VertexA rep) (b : Types.VertexB rep)
+local notation "R" => Rep Γ mark h2
+local notation "m" => ChunkComparisons.multiplicity (color Γ mark h2 paths)
+local notation "len" => repLength Γ mark h2
+local notation "pl" => pathLength (chunks Γ mark h2 paths) (chunkLength Γ mark h2 paths)
+
+/-- Literal whole-path comparisons, before cutting at the marked vertices. -/
+def Realized (patCmp : Comparisons (E:=E) pl) (r : Match rep) : Prop :=
+  ∃ label : D → Types.Letter,
+    (∀ x,label (Γ.reverse x)=Types.inverse (label x)) ∧
+    (∀ x y,Γ.origin x=Γ.origin y → label x=label y → x=y) ∧
+    (∀ x e,patCmp.side x=some e → label (originalDart Γ mark h2 paths x)=
+      if patCmp.reverse e then Types.inverse (label (originalDart Γ mark h2 paths (patCmp.pairing.partner x)))
+      else label (originalDart Γ mark h2 paths (patCmp.pairing.partner x))) ∧
+    Nonempty (RealizationTransport.Embedding (SideRestriction.graph Γ side hsid true)
+      (fun x => label x.val) (@Types.outgoingA rep)
+      (sourcePinA Γ mark h2 side paths hp root rep a) Types.inverse r.1) ∧
+    Nonempty (RealizationTransport.Embedding (SideRestriction.graph Γ side hsid false)
+      (fun x => label x.val) (@Types.outgoingB rep)
+      (sourcePinB Γ mark h2 side paths hp root rep b) Types.inverse r.2)
+
+/-- The actual cut comparison data, with its carrier exposed once. -/
+def cut (patCmp : Comparisons (E:=E) pl) (lo hi : E → ℤ)
+    (hlo : ∀ e,patCmp.lo e=(lo e:ℝ)) (hhi : ∀ e,patCmp.hi e=(hi e:ℝ)) : Comparisons (E:=E × RepeatedBlocks.Traversal m × RepeatedBlocks.Traversal m)
+    (RepeatedBlocks.traversalLength len m) :=
+  (repeatedChunks Γ mark h2 paths).comparisons patCmp lo hi hlo hhi
+
+omit [Fintype V] in
+lemma normalized (patCmp : Comparisons (E:=E) pl) (lo hi : E → ℤ)
+    (hlo : ∀ e,patCmp.lo e=(lo e:ℝ)) (hhi : ∀ e,patCmp.hi e=(hi e:ℝ)) {r : Match rep}
+    (h : Realized Γ mark h2 side hsid paths hp root rep a b patCmp r) :
+    ActualPatternEvent.Realized Γ mark h2 side hsid paths hp root rep a b
+      (cut Γ mark h2 paths patCmp lo hi hlo hhi) r := by
+  rcases h with ⟨label,hl,hn,hc,ha,hb⟩
+  exact ⟨label,hl,hn,ActualStageFeasibility.comparing Γ mark h2 paths patCmp lo hi hlo hhi label hl hc,ha,hb⟩
+
+omit [Fintype V] in
+lemma totalLength_eq : StageMass.totalLength len m =
+    ∑ p, (((paths p).flatMap (word Γ mark h2)).length:ℝ) := by
+  have he := Fintype.card_congr (repeatedChunks Γ mark h2 paths).equiv
+  rw [position_card,position_card] at he
+  change (∑ t : RepeatedBlocks.Traversal m,(len t.1:ℝ))=_
+  have hh : (∑ t : RepeatedBlocks.Traversal m,len t.1)=∑ p,pl p := he
+  exact_mod_cast hh.trans (Finset.sum_congr rfl (fun p _ => pathLength_eq Γ mark h2 paths p))
+
+omit [Fintype V] in
+lemma defect_eq (patCmp : Comparisons (E:=E) pl) (lo hi : E → ℤ)
+    (hlo : ∀ e,patCmp.lo e=(lo e:ℝ)) (hhi : ∀ e,patCmp.hi e=(hi e:ℝ)) :
+    ActualPatternEvent.defect Γ mark h2 paths
+      (cut Γ mark h2 paths patCmp lo hi hlo hhi) =
+    (Finset.univ.filter (fun x => patCmp.pairing.partner x=x)).card := by
+  unfold ActualPatternEvent.defect
+  rw [←Fintype.card_subtype,←Fintype.card_subtype]
+  exact Fintype.card_congr ((repeatedChunks Γ mark h2 paths).unpairedEquiv patCmp)
+
+variable [Fintype E]
+
+/-- The fixed original-path event has the source exponential bound; cuts and
+orientations are deterministic and do not add any probability factor. -/
+theorem probability_bound (patCmp : Comparisons (E:=E) pl) (lo hi : E → ℤ)
+    (hlo : ∀ e,patCmp.lo e=(lo e:ℝ)) (hhi : ∀ e,patCmp.hi e=(hi e:ℝ)) (K Q M J : ℕ) (hM : 0<M)
+    (hready : PatternUniform.Ready K M Q J rep)
+    (hm : ∀ c,m c≤M) (hpositive : ∀ c,1≤ m c)
+    (hc : ∀ i, List.IsChain (WeightedMoore.PortWalk.step
+      (suppressed Γ mark h2).origin (suppressed Γ mark h2).reverse) (paths i))
+    (hclose : ∀ i,StageRoot.cyclic root i=true →
+      ∀ᵉ (x∈(paths i).getLast?) (y∈(paths i).head?),
+      WeightedMoore.PortWalk.step (suppressed Γ mark h2).origin (suppressed Γ mark h2).reverse x y)
+    (hreduced : ∀ x e,patCmp.side x=some e →
+      originalDart Γ mark h2 paths x≠originalDart Γ mark h2 paths (patCmp.pairing.partner x) ∧
+      originalDart Γ mark h2 paths x≠Γ.reverse (originalDart Γ mark h2 paths (patCmp.pairing.partner x)))
+    (hQ : Fintype.card R≤Q)
+    (hE : Fintype.card E*(Fintype.card (RepeatedBlocks.Traversal m))^2≤J)
+    (hH : (∑ p, (((paths p).flatMap (word Γ mark h2)).length:ℝ)) ≤ K*(L (size rep):ℝ))
+    (hlength : (L (size rep):ℝ)≤∑ p, (((paths p).flatMap (word Γ mark h2)).length:ℝ))
+    (hb : ((Finset.univ.filter (fun x => patCmp.pairing.partner x=x)).card:ℝ)≤
+      StageFusion.epsilon (1/600) 256*∑ p, (((paths p).flatMap (word Γ mark h2)).length:ℝ)) :
+    (((samples rep).filter (Realized Γ mark h2 side hsid paths hp root rep a b patCmp)).card:ℝ)/
+      (samples rep).card ≤ Real.exp (-(L (size rep):ℝ)/(4800*M)) := by
+  have he : Fintype.card (E × RepeatedBlocks.Traversal m × RepeatedBlocks.Traversal m)≤J := by
+    simpa only [Fintype.card_prod,pow_two,mul_assoc] using hE
+  have h := ActualPatternEvent.uniform_probability_bound Γ mark h2 side hsid paths hp root rep a b
+    K Q M J hM hready (cut Γ mark h2 paths patCmp lo hi hlo hhi)
+    hm hpositive hc hclose (normalized_reduced Γ mark h2 paths patCmp lo hi hlo hhi hreduced) hQ he
+    (by rwa [totalLength_eq]) (by rwa [totalLength_eq])
+    (by simpa only [defect_eq,totalLength_eq] using hb)
+  apply le_trans (b:=(((samples rep).filter (ActualPatternEvent.Realized Γ mark h2 side hsid paths hp root rep a b
+      (cut Γ mark h2 paths patCmp lo hi hlo hhi))).card:ℝ)/(samples rep).card) _ h
+  apply div_le_div_of_nonneg_right _ (Nat.cast_nonneg _)
+  apply Nat.cast_le.mpr
+  apply Finset.card_le_card
+  intro r hr
+  obtain ⟨hs,he⟩ := Finset.mem_filter.mp hr
+  exact Finset.mem_filter.mpr ⟨hs,normalized Γ mark h2 side hsid paths hp root rep a b patCmp lo hi hlo hhi he⟩
+
+end TorsionFreeZeroDivisors.OriginalPattern
+
+namespace TorsionFreeZeroDivisors.ComparisonGeometry
+open scoped Classical
+open BlockAlignment ComparedBlocks ChunkComparisons
+variable {P P' E E' : Type*} {len : P → ℕ} {len' : P' → ℕ}
+
+def position (e : P ≃ P') (hl : ∀ p,len p=len' (e p)) : Position len ≃ Position len' :=
+  Equiv.sigmaCongr e (fun p => Equiv.subtypeEquivRight (fun q => by rw [hl p]))
+
+structure Iso (C : Comparisons (E:=E) len) (C' : Comparisons (E:=E') len') where
+  path : P ≃ P'
+  comparison : E ≃ E'
+  length_eq : ∀ p,len p=len' (path p)
+  flip_eq : ∀ j,comparison (C.flip j)=C'.flip (comparison j)
+  source_eq : ∀ j,path (C.source j)=C'.source (comparison j)
+  lo_eq : ∀ j,C.lo j=C'.lo (comparison j)
+  hi_eq : ∀ j,C.hi j=C'.hi (comparison j)
+  reverse_eq : ∀ j,C.reverse j=C'.reverse (comparison j)
+  offset_eq : ∀ j,C.offset j=C'.offset (comparison j)
+
+namespace Iso
+variable {C : Comparisons (E:=E) len} {C' : Comparisons (E:=E') len'} (f : Iso C C')
+
+lemma side_some (x : Position len) (j : E) :
+    C'.side ((position f.path f.length_eq) x)=some (f.comparison j) ↔ C.side x=some j := by
+  rw [C'.side_iff,C.side_iff]
+  change (f.path x.1=C'.source (f.comparison j) ∧ x.2.val∈positions (C'.lo (f.comparison j)) (C'.hi (f.comparison j))) ↔ _
+  rw [←f.source_eq,←f.lo_eq,←f.hi_eq,f.path.injective.eq_iff]
+
+lemma side_eq (x : Position len) :
+    C'.side ((position f.path f.length_eq) x)=(C.side x).map f.comparison := by
+  cases h : C.side x with
+  | some j => simpa only [Option.map_some] using (f.side_some x j).mpr h
+  | none =>
+    simp only [Option.map_none]
+    cases h' : C'.side ((position f.path f.length_eq) x) with
+    | none => rfl
+    | some j =>
+      have hh := (f.side_some x (f.comparison.symm j)).mp (by simpa only [Equiv.apply_symm_apply] using h')
+      rw [h] at hh
+      contradiction
+
+lemma partner_eq (x : Position len) :
+    position f.path f.length_eq (C.pairing.partner x)=
+      C'.pairing.partner (position f.path f.length_eq x) := by
+  cases h : C.side x with
+  | none =>
+    have h' : C'.side (position f.path f.length_eq x)=none := by rw [f.side_eq,h]; rfl
+    rw [(C.none_iff x).mp h,(C'.none_iff _).mp h']
+  | some j =>
+    have h' := (f.side_some x j).mpr h
+    apply position_ext
+    · change f.path (C.pairing.partner x).1=_
+      rw [C.partner_source _ _ h,C'.partner_source _ _ h',←f.flip_eq,f.source_eq]
+    · change (C.pairing.partner x).2.val=_
+      rw [C.partner_coordinate _ _ h,C'.partner_coordinate _ _ h',f.reverse_eq,f.offset_eq]
+      rfl
+
+end Iso
+end TorsionFreeZeroDivisors.ComparisonGeometry
+
+namespace TorsionFreeZeroDivisors.PortSubdivision
+structure Iso {V D V' D' : Type*} (Γ : PortGraph V D) (Γ' : PortGraph V' D') where
+  vertex : V ≃ V'
+  dart : D ≃ D'
+  origin_eq : ∀ d,vertex (Γ.origin d)=Γ'.origin (dart d)
+  reverse_eq : ∀ d,dart (Γ.reverse d)=Γ'.reverse (dart d)
+
+namespace Iso
+variable {V D V' D' V'' D'' : Type*} {Γ : PortGraph V D} {Γ' : PortGraph V' D'} {Γ'' : PortGraph V'' D''}
+def symm (f : Iso Γ Γ') : Iso Γ' Γ where
+  vertex := f.vertex.symm
+  dart := f.dart.symm
+  origin_eq d := by
+    apply f.vertex.injective
+    simp only [Equiv.apply_symm_apply,f.origin_eq]
+  reverse_eq d := by
+    apply f.dart.injective
+    simp only [Equiv.apply_symm_apply,f.reverse_eq]
+
+def trans (f : Iso Γ Γ') (g : Iso Γ' Γ'') : Iso Γ Γ'' where
+  vertex := f.vertex.trans g.vertex
+  dart := f.dart.trans g.dart
+  origin_eq d := by simp only [Equiv.trans_apply,f.origin_eq,g.origin_eq]
+  reverse_eq d := by simp only [Equiv.trans_apply,f.reverse_eq,g.reverse_eq]
+end Iso
+end TorsionFreeZeroDivisors.PortSubdivision
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/GroupRing/PictureChains.lean b/lean/OAI/Algebra/GroupRing/PictureChains.lean
new file mode 100644
index 0000000000000000000000000000000000000000..a2266f33991569d8da6cda9ea36a96e8f28f6d01
--- /dev/null
+++ b/lean/OAI/Algebra/GroupRing/PictureChains.lean
@@ -0,0 +1,131 @@
+import Mathlib
+import OAI.Algebra.GroupRing.ConePicture
+
+namespace OAI
+
+
+
+section
+namespace TorsionFreeZeroDivisors.PictureChains
+open scoped Classical BigOperators
+open SphericalPicture PortSubdivision
+noncomputable section
+variable {V D A G M : Type} [Group G] [AddCommGroup M]
+  (Γ : PortGraph V D) (label : D→A) (inv : A→A) (eval : A→G)
+  (heval : ∀a,eval (inv a)=(eval a)⁻¹)
+  (hlabel : ∀d,label (Γ.reverse d)=inv (label d))
+variable {O : Type} [Fintype O] (a : Data (O:=O) Γ label inv)
+/-- The actual group-coordinate lift of every boundary occurrence. Rotation
+and paired sides share the prescribed endpoint in the Cayley one-skeleton. -/
+structure Lift where
+  position : O→G
+  next : ∀i,position (a.rotation i)=position i*eval (label (a.dart i))
+  pair : ∀i,position (a.partner i)=position i*eval (label (a.dart i))
+variable {Γ label inv eval} (l : Lift Γ label inv eval a)
+include heval hlabel in
+lemma reverse_value (d : D) : eval (label (Γ.reverse d))=(eval (label d))⁻¹ := by
+  rw [hlabel,heval]
+include heval hlabel in
+lemma inverse_segment {p q : O} (hpos : l.position q=l.position p*eval (label (a.dart p)))
+    (he : a.dart q=Γ.reverse (a.dart p)) :
+    l.position q*eval (label (a.dart q))=l.position p := by
+  rw [hpos,he,reverse_value heval hlabel,mul_inv_cancel_right]
+variable (p q : O) (hpq : p≠q)
+def band (hpair : a.partner p=q) (he : a.dart q=Γ.reverse (a.dart p)) :
+    Lift Γ label inv eval (a.band p q hpq hpair he) where
+  position i := l.position (BandEuler.val p q hpq i)
+  next i := (BoundarySurgery.consistent a.rotation l.position
+    (fun j=>l.position j*eval (label (a.dart j))) p q hpq
+    (fun i=>(l.next i).symm)
+    (by rw [←l.pair,hpair])
+    (inverse_segment heval hlabel a l (by rw [←hpair,l.pair]) he) i).symm
+  pair i := by
+    change l.position (BandEuler.val p q hpq (BandEuler.partner a.partner a.involutive p q hpq hpair i))=_
+    rw [BandEuler.partner_val]
+    exact l.pair _
+def tighten (hinv : Function.Involutive inv) (hsp : a.rotation p=q)
+    (he : a.dart q=Γ.reverse (a.dart p)) :
+    Lift Γ label inv eval (a.tighten p q hpq hinv hlabel hsp he) where
+  position i := l.position i
+  next i := (Tightening.consistent a.rotation p q hpq hsp l.position
+    (fun j=>l.position j*eval (label (a.dart j))) (fun i=>(l.next i).symm)
+    (inverse_segment heval hlabel a l (by rw [←hsp,l.next]) he) i).symm
+  pair i := by
+    change l.position (PartialMatchingSurgery.splice a.partner p q i)=_
+    by_cases h1 : a.partner i=p
+    · rw [PartialMatchingSurgery.splice,ite_eq_left h1,l.pair]
+      exact (inverse_segment heval hlabel a l (by rw [←hsp,l.next]) he).trans
+        ((congrArg l.position h1).symm.trans (l.pair i))
+    · by_cases h2 : a.partner i=q
+      · rw [PartialMatchingSurgery.splice,ite_eq_right h1,ite_eq_left h2,l.pair]
+        exact (l.next p).symm.trans ((congrArg l.position hsp).trans
+          ((congrArg l.position h2).symm.trans (l.pair i)))
+      · rw [PartialMatchingSurgery.splice,ite_eq_right h1,ite_eq_right h2]
+        exact l.pair i
+
+variable (c : G→D→M)
+  (hc : ∀g d,c (g*eval (label d)) (Γ.reverse d)=-c g d)
+def chain : M := ∑i,c (l.position i) (a.dart i)
+include hc in
+lemma cancel_pair {p q : O} (hpos : l.position q=l.position p*eval (label (a.dart p)))
+    (he : a.dart q=Γ.reverse (a.dart p)) :
+    c (l.position p) (a.dart p)+c (l.position q) (a.dart q)=0 := by
+  rw [hpos,he,hc,add_neg_cancel]
+
+lemma sum_remaining {B : Type*} [AddCommGroup B] {O : Type*} [Fintype O]
+    (p q : O) (hpq : p≠q) (f : O→B) (hf : f p+f q=0) :
+    (∑i : PartialMatchingSurgery.Remaining p q,f i)=∑i,f i := by
+  classical
+  have hs : (∑i∈Finset.univ.erase p |>.erase q,f i)+f q+f p=∑i,f i := by
+    rw [Finset.sum_erase_add _ _ (by simp [hpq.symm]),Finset.sum_erase_add _ _ (Finset.mem_univ _)]
+  have hsum : (∑i : PartialMatchingSurgery.Remaining p q,f i)=
+      ∑i∈Finset.univ.erase p |>.erase q,f i := by
+    apply Finset.sum_bij (fun i _=>i.1)
+    · intro i _;simp only [Finset.mem_erase,Finset.mem_univ,and_true];exact ⟨i.2.2,i.2.1⟩
+    · intro i _ j _ hij;exact Subtype.ext hij
+    · intro j hj
+      simp only [Finset.mem_erase,Finset.mem_univ,and_true] at hj
+      exact ⟨⟨j,hj.2,hj.1⟩,Finset.mem_univ _,rfl⟩
+    · intro i _;rfl
+  rw [hsum]
+  have hh : f q+f p=0 := by rwa [add_comm] at hf
+  simpa only [add_assoc,hh,add_zero] using hs
+
+include hc in
+lemma band_chain (hpair : a.partner p=q) (he : a.dart q=Γ.reverse (a.dart p)) :
+    chain (a.band p q hpq hpair he) (band heval hlabel a l p q hpq hpair he) c=chain a l c := by
+  change (∑i : BandEuler.Residual p q hpq,c (l.position (BandEuler.val p q hpq i)) (a.dart (BandEuler.val p q hpq i)))=_
+  exact ((Data.deletionCoordinates p q hpq).sum_comp
+    (fun i : PartialMatchingSurgery.Remaining p q=>c (l.position i) (a.dart i))).trans
+    (sum_remaining p q hpq (fun i=>c (l.position i) (a.dart i))
+      (cancel_pair a l c hc (by rw [←hpair,l.pair]) he))
+include hc in
+lemma tighten_chain (hinv : Function.Involutive inv) (hsp : a.rotation p=q)
+    (he : a.dart q=Γ.reverse (a.dart p)) :
+    chain (a.tighten p q hpq hinv hlabel hsp he) (tighten heval hlabel a l p q hpq hinv hsp he) c=chain a l c := by
+  change (∑i : PartialMatchingSurgery.Remaining p q,c (l.position i) (a.dart i))=_
+  exact sum_remaining p q hpq (fun i=>c (l.position i) (a.dart i))
+    (cancel_pair a l c hc (by rw [←hsp,l.next]) he)
+
+include heval hlabel hc in
+/-- Every actual lifted genus-zero spherical boundary picture which reduces as
+proved by the sharp arrangement exclusion has ZERO integral cell-chain charge.
+Only an antisymmetric physical cone-edge contribution is needed. -/
+theorem chain_eq_zero (h : ReducesToEmpty Γ label inv a) : chain a l c=0 := by
+  induction h with
+  | empty a h =>
+    let := h
+    simp only [chain, Finset.univ_eq_empty, Finset.sum_empty]
+  | band a p q hpq hpair he next ih =>
+    rw [←band_chain heval hlabel a l p q hpq c hc hpair he]
+    exact ih (band heval hlabel a l p q hpq hpair he)
+  | tighten a p q hpq hinv hl hsp he next ih =>
+    rw [←tighten_chain heval hl a l p q hpq c hc hinv hsp he]
+    exact ih (tighten heval hl a l p q hpq hinv hsp he)
+end
+end TorsionFreeZeroDivisors.PictureChains
+
+end
+
+
+end OAI
diff --git a/lean/OAI/Algebra/GroupRing/PlanarMap.lean b/lean/OAI/Algebra/GroupRing/PlanarMap.lean
new file mode 100644
index 0000000000000000000000000000000000000000..0f1f3565654890b6bb347d7ae96e22716dcbe15a
--- /dev/null
+++ b/lean/OAI/Algebra/GroupRing/PlanarMap.lean
@@ -0,0 +1,374 @@
+import Mathlib
+import OAI.Algebra.GroupRing.SeparatorLevels
+
+namespace OAI
+
+noncomputable section
+
+namespace TorsionFreeZeroDivisors.PlanarMap
+
+section
+open scoped Classical
+open SimpleGraph RecursiveSeparator
+variable {V : Type} [Fintype V] {G : SimpleGraph V}
+
+def componentVertices (G : SimpleGraph V) (c : G.ConnectedComponent) : Finset V :=
+  Finset.univ.filter (fun v=>G.connectedComponentMk v=c)
+lemma mem_componentVertices (c : G.ConnectedComponent) (v : V) :
+    v∈componentVertices G c↔G.connectedComponentMk v=c := by simp only [componentVertices,Finset.mem_filter,Finset.mem_univ,true_and]
+lemma componentVertices_disjoint (c d : G.ConnectedComponent) (h : c≠d) :
+    Disjoint (componentVertices G c) (componentVertices G d) := by
+  apply Finset.disjoint_left.mpr
+  intro v hv hd
+  exact h (((mem_componentVertices c v).mp hv).symm.trans ((mem_componentVertices d v).mp hd))
+
+/-- Add the untouched small components to a separator of the unique large
+component. The original deletion set and hence its sharp cost are retained. -/
+def extendComponent (c : G.ConnectedComponent)
+    (P : Split G.Adj (componentVertices G c))
+    (hsmall : ∀ d : G.ConnectedComponent,d≠c→3*(componentVertices G d).card≤2*Fintype.card V) :
+    Split G.Adj Finset.univ := by
+  let : Fintype G.ConnectedComponent := Fintype.ofFinite _
+  let others := (Finset.univ.erase c).image (componentVertices G)
+  have hother {b : Finset V} : b∈others↔∃d,d≠c ∧ b=componentVertices G d := by
+    simp only [others,Finset.mem_image,Finset.mem_erase,Finset.mem_univ,and_true]
+    constructor
+    · rintro ⟨d,hd,rfl⟩;exact ⟨d,hd,rfl⟩
+    · rintro ⟨d,hd,rfl⟩;exact ⟨d,hd,rfl⟩
+  have hdisj {b : Finset V} (hb : b∈P.parts) {d : G.ConnectedComponent} (hd : d≠c) :
+      Disjoint b (componentVertices G d) :=
+    (componentVertices_disjoint c d hd.symm).mono_left ((P.subset hb).trans Finset.sdiff_subset)
+  refine {
+    remove := P.remove
+    parts := P.parts∪others
+    remove_subset := Finset.subset_univ _
+    cover := ?_
+    disjoint := ?_
+    closed := ?_
+    size := ?_
+    cost := ?_ }
+  · ext v
+    constructor
+    · intro hv
+      obtain ⟨b,hb,hv⟩ := Finset.mem_biUnion.mp hv
+      refine Finset.mem_sdiff.mpr ⟨Finset.mem_univ _,?_⟩
+      rcases Finset.mem_union.mp hb with hb|hb
+      · exact (Finset.mem_sdiff.mp (P.subset hb hv)).2
+      · obtain ⟨d,hd,rfl⟩ := hother.mp hb
+        intro hr
+        exact Finset.disjoint_left.mp (componentVertices_disjoint c d hd.symm) (P.remove_subset hr) hv
+    · intro hv
+      have hnr := (Finset.mem_sdiff.mp hv).2
+      by_cases hc : G.connectedComponentMk v=c
+      · have hc' := (mem_componentVertices c v).mpr hc
+        have he := Finset.mem_sdiff.mpr ⟨hc',hnr⟩
+        rw [←P.cover] at he
+        obtain ⟨b,hb,hv⟩ := Finset.mem_biUnion.mp he
+        exact Finset.mem_biUnion.mpr ⟨b,Finset.mem_union_left _ hb,hv⟩
+      · exact Finset.mem_biUnion.mpr ⟨componentVertices G (G.connectedComponentMk v),
+          Finset.mem_union_right _ (hother.mpr ⟨_,hc,rfl⟩),(mem_componentVertices _ _).mpr rfl⟩
+  · intro b hb d hd hbd
+    rcases Finset.mem_union.mp hb with hb|hb <;> rcases Finset.mem_union.mp hd with hd|hd
+    · exact P.disjoint hb hd hbd
+    · obtain ⟨e,he,rfl⟩ := hother.mp hd
+      exact hdisj hb he
+    · obtain ⟨e,he,rfl⟩ := hother.mp hb
+      exact (hdisj hd he).symm
+    · obtain ⟨e,_,rfl⟩ := hother.mp hb
+      obtain ⟨f,_,rfl⟩ := hother.mp hd
+      exact componentVertices_disjoint e f (fun h=>hbd (congrArg (componentVertices G) h))
+  · intro b hb v hv w hw he
+    rcases Finset.mem_union.mp hb with hb|hb
+    · have hvc := (mem_componentVertices c v).mp (Finset.sdiff_subset (P.subset hb hv))
+      have hwc : w∈componentVertices G c := (mem_componentVertices c w).mpr
+        ((ConnectedComponent.connectedComponentMk_eq_of_adj he).symm.trans hvc)
+      exact P.closed b hb v hv w (Finset.mem_sdiff.mpr ⟨hwc,(Finset.mem_sdiff.mp hw).2⟩) he
+    · obtain ⟨d,_,rfl⟩ := hother.mp hb
+      exact (mem_componentVertices d w).mpr
+        ((ConnectedComponent.connectedComponentMk_eq_of_adj he).symm.trans ((mem_componentVertices d v).mp hv))
+  · intro b hb
+    rw [Finset.card_univ]
+    rcases Finset.mem_union.mp hb with hb|hb
+    · exact (P.size b hb).trans (Nat.mul_le_mul_left 2 (Finset.card_le_univ _))
+    · obtain ⟨d,hd,rfl⟩ := hother.mp hb
+      exact hsmall d hd
+  · rw [Finset.card_univ]
+    exact P.cost.trans (mul_le_mul_of_nonneg_left
+      (Real.sqrt_le_sqrt (by exact_mod_cast Finset.card_le_univ (componentVertices G c)))
+      (mul_nonneg (by norm_num) (Real.sqrt_nonneg _)))
+
+/-- Sharp separator for any finite genus-zero rotation map, including empty
+and disconnected graphs. -/
+theorem Model.univ_split (M : Model G) : Nonempty (Split G.Adj Finset.univ) := by
+  let : Fintype G.ConnectedComponent := Fintype.ofFinite _
+  by_cases hbig : ∃c : G.ConnectedComponent,2*Fintype.card V<3*(componentVertices G c).card
+  · obtain ⟨c,hc⟩ := hbig
+    let : DecidableEq c.supp := Classical.decEq _
+    obtain ⟨P⟩ := (M.induced c.supp).connected_split c.connected_toSimpleGraph
+    let f : c.supp ↪ V := ⟨Subtype.val,Subtype.val_injective⟩
+    have he : (Finset.univ : Finset c.supp).map f=componentVertices G c := by
+      ext v
+      simp only [Finset.mem_map,Finset.mem_univ,true_and,mem_componentVertices]
+      constructor
+      · rintro ⟨x,rfl⟩;exact x.property
+      · intro hv;exact ⟨⟨v,hv⟩,rfl⟩
+    have PP : Nonempty (Split G.Adj (componentVertices G c)) := by
+      rw [←he]
+      exact ⟨P.map f (fun _ _ h=>h)⟩
+    obtain ⟨P⟩ := PP
+    refine ⟨extendComponent c P ?_⟩
+    intro d hd
+    have hadd : (componentVertices G c).card+(componentVertices G d).card≤Fintype.card V := by
+      rw [←Finset.card_union_of_disjoint (componentVertices_disjoint c d hd.symm)]
+      exact Finset.card_le_univ _
+    omega
+  · push Not at hbig
+    refine ⟨Split.of_fibers G.Adj Finset.univ ∅ G.connectedComponentMk (Finset.empty_subset _)
+      (fun _ _ _ _ h=>ConnectedComponent.connectedComponentMk_eq_of_adj h) ?_ ?_⟩
+    · intro c
+      simpa only [Finset.sdiff_empty,Finset.card_univ,componentVertices] using hbig c
+    · simp only [Finset.card_empty,Nat.cast_zero]
+      positivity
+
+end
+
+open scoped Classical
+open RecursiveSeparator
+variable {V : Type} [Fintype V] {G : SimpleGraph V}
+omit [Fintype V] in
+/-- The exact sharp separator on every induced vertex set. -/
+theorem Model.split (M : Model G) (S : Finset V) : Nonempty (Split G.Adj S) := by
+  let : DecidableEq S := Classical.decEq _
+  obtain ⟨P⟩ := (M.induced (S : Set V)).univ_split
+  let f : S ↪ V := ⟨Subtype.val,Subtype.val_injective⟩
+  have he : (Finset.univ : Finset S).map f=S := by
+    ext v
+    simp only [Finset.mem_map,Finset.mem_univ,true_and]
+    constructor
+    · rintro ⟨x,rfl⟩;exact x.property
+    · intro hv;exact ⟨⟨v,hv⟩,rfl⟩
+  rw [←he]
+  exact ⟨P.map f (fun _ _ h=>h)⟩
+end TorsionFreeZeroDivisors.PlanarMap
+
+namespace TorsionFreeZeroDivisors.BoundaryRotation
+open scoped Classical
+open BlockAlignment ComparedBlocks PermutationCycles
+variable {T : Type} [Fintype T] (len : T→ℕ) (hpos : ∀t,0<len t)
+/-- Actual boundary cycles are exactly the nonempty boundary words. -/
+def cyclesEquiv : Cycle (perm len) ≃ T :=
+  Equiv.ofBijective (PermutationCycles.lift (perm len) (fun p=>p.1) (first len)) ⟨by
+    intro a b he
+    obtain ⟨x,rfl⟩ := cycle_surjective (perm len) a
+    obtain ⟨y,rfl⟩ := cycle_surjective (perm len) b
+    exact (cycle_eq (perm len)).mpr (same_first len he),by
+    intro t
+    exact ⟨cycle (perm len) ((WordPositions.fin len).symm ⟨t,⟨0,hpos t⟩⟩),rfl⟩⟩
+@[simp] lemma cyclesEquiv_cycle (p : Position len) :
+    cyclesEquiv len hpos (cycle (perm len) p)=p.1 := rfl
+
+def interaction (α : Equiv.Perm (Position len)) (ha : Function.Involutive α) : SimpleGraph T where
+  Adj p q := p≠q ∧ PairingClusters.Rel (fun x=>x.1) α p q
+  symm := ⟨by
+    rintro p q ⟨hpq,x,hx,hy⟩
+    exact ⟨hpq.symm,α x,hy,by rw [ha x];exact hx⟩⟩
+  loopless := ⟨fun _ h=>h.1 rfl⟩
+
+def graphIso (α : Equiv.Perm (Position len)) (ha : Function.Involutive α) :
+    MapEuler.graph (perm len) α ha ≃g interaction len α ha where
+  toEquiv := cyclesEquiv len hpos
+  map_rel_iff' := by
+    intro a b
+    change ((cyclesEquiv len hpos a≠cyclesEquiv len hpos b) ∧
+      ∃x,x.1=cyclesEquiv len hpos a ∧ (α x).1=cyclesEquiv len hpos b) ↔
+      (a≠b ∧ ∃x,cycle (perm len) x=a ∧ cycle (perm len) (α x)=b)
+    constructor
+    · rintro ⟨hn,x,hx,hy⟩
+      exact ⟨fun h=>hn (congrArg (cyclesEquiv len hpos) h),x,
+        (cyclesEquiv len hpos).injective hx,(cyclesEquiv len hpos).injective hy⟩
+    · rintro ⟨hn,x,hx,hy⟩
+      exact ⟨fun h=>hn ((cyclesEquiv len hpos).injective h),x,
+        congrArg (cyclesEquiv len hpos) hx,congrArg (cyclesEquiv len hpos) hy⟩
+
+def model (α : Equiv.Perm (Position len)) (ha : Function.Involutive α)
+    (hz : MapEuler.GenusZero (perm len) α) : PlanarMap.Model (interaction len α ha) where
+  Dart := Position len
+  rotation := perm len
+  pairing := α
+  involutive := ha
+  genus := hz
+  iso := graphIso len hpos α ha
+
+include hpos in
+/-- The sharp separator for the literal interaction relation, retaining loops
+as required by the existing recursive charging theorem. -/
+theorem split (α : Equiv.Perm (Position len)) (ha : Function.Involutive α)
+    (hz : MapEuler.GenusZero (perm len) α) (S : Finset T) :
+    Nonempty (RecursiveSeparator.Split (PairingClusters.Rel (fun x=>x.1) α) S) := by
+  obtain ⟨P⟩ := (model len hpos α ha hz).split S
+  exact ⟨RecursiveSeparator.Split.of_off_diagonal (fun p q hpq=>by
+    change (p≠q ∧ _)↔_
+    exact and_iff_right hpq) P⟩
+end TorsionFreeZeroDivisors.BoundaryRotation
+
+namespace TorsionFreeZeroDivisors.SampleGraph.Picture
+open scoped Classical
+open BlockAlignment ComparedBlocks
+variable {rep : ℕ} (r : ActualPatternEvent.Match rep) (x : VA rep) (y : VB rep)
+  (hL : 2≤GirthAsymptotics.L (TypedGraphs.size rep)) (hd : GraphSample.Diameters rep r)
+/-- Discharge the former sharp planar-separator obligation of every reduced
+disk picture, using its actual genus-zero segmented interaction map. -/
+theorem separator_obligation : SeparatorObligation r x y hL hd := by
+  intro z w n a hzw hr hz S _
+  let s := system a hzw hr hz
+  let cap := FullPairing.U₀*GirthAsymptotics.L (TypedGraphs.size rep)
+  let hc : 0<cap := FullPairing.cap_positive hL
+  have hp : ∀p,0<BalancedRotation.len s.paths cap hc p := fun p=>
+    List.length_pos_iff.mpr (BalancedWords.segment_nonempty s.paths cap hc s.nonempty p)
+  obtain ⟨P⟩ := BoundaryRotation.split (BalancedRotation.len s.paths cap hc) hp
+    ((pairing a hzw hr hz).α cap hc) ((pairing a hzw hr hz).α_involutive cap hc)
+    (segmented_genusZero a hzw hr hz cap hc) S
+  exact ⟨(pairing a hzw hr hz).closed_split cap hc (by omega) hd _ S P⟩
+end TorsionFreeZeroDivisors.SampleGraph.Picture
+
+/-! The parity argument in source sections/factors.tex. We count reversible
+flags, retaining parallel edges instead of identifying them in a simple graph. -/
+namespace TorsionFreeZeroDivisors.Factors
+open scoped BigOperators Classical
+
+lemma odd_nsmul {R : Type*} [AddCommMonoid R] (h2 : ∀ x : R,x+x=0) {n : ℕ}
+    (hn : Odd n) (x : R) : n • x=x := by
+  obtain ⟨k,rfl⟩ := hn
+  simp only [add_nsmul,mul_nsmul,two_nsmul,one_nsmul]
+  rw [h2,nsmul_zero,zero_add]
+
+/-- Odd fibres allow an invariant sum over vertices to be computed over flags.
+The fixed-point-free involution of flags then cancels it in characteristic two. -/
+theorem odd_fibre_cancellation {P F R : Type*} [Fintype P] [Fintype F]
+    [AddCommMonoid R] (h2 : ∀ x : R,x+x=0) (proj : F → P) (rev : F → F)
+    (hr : Function.Involutive rev) (hne : ∀ e,rev e≠e)
+    (hodd : ∀ p,Odd (Finset.univ.filter (fun e => proj e=p)).card)
+    (f : P → R) (hf : ∀ e,f (proj (rev e))=f (proj e)) :
+    ∑ p,f p=0 := by
+  have hs : ∑ e : F,f (proj e)=∑ p : P,f p := by
+    rw [← Finset.sum_fiberwise_of_maps_to' (fun e (_ : e∈(Finset.univ : Finset F)) =>
+      Finset.mem_univ (proj e)) f]
+    apply Finset.sum_congr rfl
+    intro p _
+    rw [Finset.sum_const]
+    exact odd_nsmul h2 (hodd p) (f p)
+  rw [← hs]
+  exact Finset.sum_ninvolution rev
+    (fun e => by rw [hf]; exact h2 _)
+    (fun e _ => hne e) (fun _ => Finset.mem_univ _) hr
+
+variable {A B T G : Type*} [Fintype A] [Fintype B] [Fintype T] [Group G]
+variable (outA : A → Finset T) (outB : B → Finset T)
+abbrev DartA := {p : A×T // p.2∈outA p.1}
+abbrev DartB := {p : B×T // p.2∈outB p.1}
+abbrev Flag := {p : DartA outA×DartB outB // p.1.val.2=p.2.val.2}
+def base (e : Flag outA outB) : A×B := (e.val.1.val.1,e.val.2.val.1)
+
+/-- The entire common outgoing set, not a quotient of its parallel steps. -/
+def fibreEquiv (p : A×B) : {e : Flag outA outB // base outA outB e=p} ≃
+    {t : T // t∈outA p.1∩outB p.2} where
+  toFun e := ⟨e.val.val.1.val.2,by
+    have ha := e.val.val.1.property
+    have hb := e.val.val.2.property
+    have h1 := congrArg Prod.fst e.property
+    have h2 := congrArg Prod.snd e.property
+    change e.val.val.1.val.1=p.1 at h1
+    change e.val.val.2.val.1=p.2 at h2
+    exact Finset.mem_inter.mpr ⟨by simpa only [h1] using ha,
+      by simpa only [h2,← e.val.property] using hb⟩⟩
+  invFun t := ⟨⟨(⟨(p.1,t.val),(Finset.mem_inter.mp t.property).1⟩,
+      ⟨(p.2,t.val),(Finset.mem_inter.mp t.property).2⟩),rfl⟩,rfl⟩
+  left_inv e := by
+    apply Subtype.ext
+    apply Subtype.ext
+    apply Prod.ext
+    · apply Subtype.ext
+      exact Prod.ext (congrArg Prod.fst e.property).symm rfl
+    · apply Subtype.ext
+      exact Prod.ext (congrArg Prod.snd e.property).symm e.val.property
+  right_inv _ := rfl
+
+lemma fibre_card (p : A×B) :
+    (Finset.univ.filter (fun e : Flag outA outB => base outA outB e=p)).card=
+      (outA p.1∩outB p.2).card := by
+  have h := Fintype.card_congr (fibreEquiv outA outB p)
+  simpa only [Fintype.card_subtype,Finset.filter_mem_eq_inter,Finset.univ_inter] using h
+
+variable (bar : T→T) (rA : DartA outA→DartA outA) (rB : DartB outB→DartB outB)
+  (hA : ∀ d,(rA d).val.2=bar d.val.2) (hB : ∀ d,(rB d).val.2=bar d.val.2)
+def reverse (e : Flag outA outB) : Flag outA outB :=
+  ⟨(rA e.val.1,rB e.val.2),by rw [hA,hB,e.property]⟩
+omit [Fintype A] [Fintype B] [Fintype T] in
+lemma reverse_involutive (hrA : Function.Involutive rA) (hrB : Function.Involutive rB) :
+    Function.Involutive (reverse outA outB bar rA rB hA hB) := by
+  intro e
+  apply Subtype.ext
+  exact Prod.ext (hrA e.val.1) (hrB e.val.2)
+omit [Fintype A] [Fintype B] [Fintype T] in
+lemma reverse_ne (hbar : ∀ t,bar t≠t) (e : Flag outA outB) :
+    reverse outA outB bar rA rB hA hB e≠e := by
+  intro he
+  have h := congrArg (fun z : Flag outA outB => z.val.1.val.2) he
+  exact hbar e.val.1.val.2 ((hA e.val.1).symm.trans h)
+
+include hA hB in
+/-- The source factors on full components; compatibility is the literal
+path-order rule along every outgoing edge. -/
+theorem product_zero
+    (hrA : Function.Involutive rA) (hrB : Function.Involutive rB)
+    (hbar : ∀ t,bar t≠t) (hodd : ∀ a b,Odd (outA a∩outB b).card)
+    (letter : T→G) (g : A→G) (h : B→G)
+    (hg : ∀ d : DartA outA,g (rA d).val.1=g d.val.1*letter d.val.2)
+    (hh : ∀ d : DartB outB,h (rB d).val.1=h d.val.1*letter d.val.2) :
+    (∑ a,MonoidAlgebra.single (g a) (1 : ZMod 2)) *
+      (∑ b,MonoidAlgebra.single ((h b)⁻¹) (1 : ZMod 2))=0 := by
+  have h2 (x : MonoidAlgebra (ZMod 2) G) : x+x=0 := by
+    ext z
+    exact CharTwo.add_self_eq_zero (x.coeff z)
+  have hz := odd_fibre_cancellation h2 (base outA outB)
+    (reverse outA outB bar rA rB hA hB)
+    (reverse_involutive outA outB bar rA rB hA hB hrA hrB)
+    (reverse_ne outA outB bar rA rB hA hB hbar)
+    (fun p => by
+      convert hodd p.1 p.2 using 1
+      convert fibre_card outA outB p using 1
+      congr 1
+      ext e
+      simp)
+    (fun p : A×B => MonoidAlgebra.single (g p.1*(h p.2)⁻¹) (1 : ZMod 2)) (by
+      intro e
+      change MonoidAlgebra.single (g (rA e.val.1).val.1*(h (rB e.val.2).val.1)⁻¹) _ = _
+      rw [hg,hh,e.property]
+      congr 1
+      dsimp only [base]
+      group)
+  rw [Finset.sum_mul]
+  simp_rw [Finset.mul_sum,MonoidAlgebra.single_mul_single,one_mul]
+  simpa only [Fintype.sum_prod_type] using hz
+
+/-- Only the root must have a unique label; no non-root injectivity is needed. -/
+theorem sum_nonzero (root : A) (g : A→G) (hroot : g root=1)
+    (hunique : ∀ a,g a=1 → a=root) :
+    (∑ a,MonoidAlgebra.single (g a) (1 : ZMod 2))≠0 := by
+  have hv : (∑ a,MonoidAlgebra.single (g a) (1 : ZMod 2)).coeff (1:G)=1 := by
+    rw [MonoidAlgebra.coeff_sum,Finsupp.finsetSum_apply]
+    rw [Finset.sum_eq_single root]
+    · simp [hroot]
+    · intro a _ ha
+      simp only [MonoidAlgebra.coeff_single,Finsupp.single_apply]
+      exact ite_eq_right (fun h => ha (hunique a h))
+    · simp
+  intro hz
+  rw [hz] at hv
+  exact zero_ne_one hv
+
+end TorsionFreeZeroDivisors.Factors
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/GroupRing/PortSubdivision.lean b/lean/OAI/Algebra/GroupRing/PortSubdivision.lean
new file mode 100644
index 0000000000000000000000000000000000000000..c46e11876b0d8136236f3758e75f0de3ef96d8ec
--- /dev/null
+++ b/lean/OAI/Algebra/GroupRing/PortSubdivision.lean
@@ -0,0 +1,774 @@
+import Mathlib
+
+namespace OAI
+
+noncomputable section
+
+namespace TorsionFreeZeroDivisors.PortSubdivision
+
+structure PortGraph (V D : Type*) where
+  origin : D → V
+  reverse : D → D
+  reverse_reverse : Function.Involutive reverse
+  reverse_ne : ∀ d, reverse d ≠ d
+
+namespace PortGraph
+variable {V D : Type*} (Γ : PortGraph V D)
+
+@[simp] theorem reverse_reverse_apply (d : D) : Γ.reverse (Γ.reverse d) = d :=
+  Γ.reverse_reverse d
+
+/-- The canonical threefold subdivision, including loops and parallel edges. -/
+def subdivision : SimpleGraph (V ⊕ D) where
+  Adj a b := match a,b with
+    | .inl _, .inl _ => False
+    | .inl v, .inr d => Γ.origin d = v
+    | .inr d, .inl v => Γ.origin d = v
+    | .inr d, .inr e => Γ.reverse d = e
+  symm := ⟨by
+    intro a b h
+    cases a with
+    | inl v => cases b <;> exact h
+    | inr d =>
+      cases b with
+      | inl v => exact h
+      | inr e =>
+        change Γ.reverse e = d
+        change Γ.reverse d = e at h
+        rw [← h,Γ.reverse_reverse]⟩
+  loopless := ⟨by
+    intro a h
+    cases a with
+    | inl v => exact h
+    | inr d => exact Γ.reverse_ne d h⟩
+
+@[simp] theorem adj_original (v w : V) : ¬ Γ.subdivision.Adj (.inl v) (.inl w) := id
+@[simp] theorem adj_original_port (v : V) (d : D) :
+    Γ.subdivision.Adj (.inl v) (.inr d) ↔ Γ.origin d = v := Iff.rfl
+@[simp] theorem adj_port_original (v : V) (d : D) :
+    Γ.subdivision.Adj (.inr d) (.inl v) ↔ Γ.origin d = v := Iff.rfl
+@[simp] theorem adj_ports (d e : D) :
+    Γ.subdivision.Adj (.inr d) (.inr e) ↔ Γ.reverse d = e := Iff.rfl
+
+theorem port_adj_iff (d : D) (a : V ⊕ D) :
+    Γ.subdivision.Adj (.inr d) a ↔ a = .inl (Γ.origin d) ∨ a = .inr (Γ.reverse d) := by
+  cases a <;> simp [eq_comm]
+
+/-- Every cycle through a port uses its middle edge, since the other port
+neighbor is unique and the cycle cannot immediately backtrack. -/
+theorem cycle_middle_at_port (d : D) (p : Γ.subdivision.Walk (.inr d) (.inr d))
+    (hp : p.IsCycle) : s(Sum.inr d,Sum.inr (Γ.reverse d)) ∈ p.edges := by
+  have ha := (Γ.port_adj_iff d p.snd).mp (p.adj_snd hp.not_nil)
+  have hb := (Γ.port_adj_iff d p.penultimate).mp (p.adj_penultimate hp.not_nil).symm
+  rcases ha with ha | ha
+  · rcases hb with hb | hb
+    · exact False.elim (hp.snd_ne_penultimate (ha.trans hb.symm))
+    · have he := p.mk_penultimate_end_mem_edges hp.not_nil
+      rw [hb,Sym2.eq_swap] at he
+      exact he
+  · simpa only [ha] using p.mk_start_snd_mem_edges hp.not_nil
+
+/-- No cycle lives entirely in the spokes; a short cycle always gives a
+middle edge eligible for a matching transposition. -/
+theorem cycle_has_middle [DecidableEq V] [DecidableEq D] {a : V ⊕ D}
+    (p : Γ.subdivision.Walk a a) (hp : p.IsCycle) :
+    ∃ d, s(Sum.inr d,Sum.inr (Γ.reverse d)) ∈ p.edges := by
+  have hex : ∃ d, Sum.inr d ∈ p.support := by
+    cases a with
+    | inr d => exact ⟨d,p.start_mem_support⟩
+    | inl v =>
+      have ha := p.adj_snd hp.not_nil
+      cases hs : p.snd with
+      | inl w => rw [hs] at ha; exact False.elim ha
+      | inr d => exact ⟨d,hs ▸ p.snd_mem_support_of_mem_edges (p.mk_start_snd_mem_edges hp.not_nil)⟩
+  obtain ⟨d,hd⟩ := hex
+  refine ⟨d,?_⟩
+  have he := Γ.cycle_middle_at_port d (p.rotate (.inr d) hd) (hp.rotate hd)
+  exact (p.rotate_edges (.inr d) hd).mem_iff.mp he
+
+/-- The neighbor fiber at an original vertex is exactly its port fiber. -/
+def originalNeighborEquiv (v : V) :
+    Γ.subdivision.neighborSet (.inl v) ≃ {d : D // Γ.origin d = v} where
+  toFun n := match n with
+    | ⟨.inl _,h⟩ => False.elim h
+    | ⟨.inr d,h⟩ => ⟨d,h⟩
+  invFun d := ⟨.inr d.val,d.property⟩
+  left_inv n := by rcases n with ⟨v|d,h⟩; exact False.elim h; rfl
+  right_inv _ := rfl
+
+/-- A port has exactly two neighbors: its original vertex and its reverse port.
+They lie in disjoint summands even when the original edge is a graph loop. -/
+def portNeighborEquiv (d : D) : Γ.subdivision.neighborSet (.inr d) ≃ Bool where
+  toFun n := match n.val with | .inl _ => false | .inr _ => true
+  invFun b := if b then ⟨.inr (Γ.reverse d),rfl⟩ else ⟨.inl (Γ.origin d),rfl⟩
+  left_inv n := by
+    rcases n with ⟨v|e,h⟩
+    · apply Subtype.ext
+      exact congrArg Sum.inl h
+    · apply Subtype.ext
+      exact congrArg Sum.inr h
+  right_inv b := by cases b <;> rfl
+
+theorem card_original_neighbors (v : V) :
+    Nat.card (Γ.subdivision.neighborSet (.inl v)) =
+      Nat.card {d : D // Γ.origin d = v} := Nat.card_congr (Γ.originalNeighborEquiv v)
+
+theorem card_port_neighbors (d : D) : Nat.card (Γ.subdivision.neighborSet (.inr d)) = 2 := by
+  rw [Nat.card_congr (Γ.portNeighborEquiv d)]
+  simp
+
+/-- Conjugating the reversal while keeping port origins fixed is a
+matching switch, not a relabeling of the original graph. -/
+def moveMatches (σ : Equiv.Perm D) : PortGraph V D where
+  origin := Γ.origin
+  reverse d := σ (Γ.reverse (σ.symm d))
+  reverse_reverse d := by simp
+  reverse_ne d := by
+    intro h
+    have h' := congrArg σ.symm h
+    simp only [Equiv.symm_apply_apply] at h'
+    exact Γ.reverse_ne (σ.symm d) h'
+
+section Switching
+variable [DecidableEq D]
+
+/-- Transpose two equally oriented ports. Their reverse ports are not moved. -/
+def switch (d e : D) : PortGraph V D := Γ.moveMatches (Equiv.swap d e)
+
+@[simp] theorem switch_origin (d e f : D) : (Γ.switch d e).origin f = Γ.origin f := rfl
+
+theorem switch_reverse_left (d e : D) (hde : Γ.reverse e ≠ d)
+    (hee : Γ.reverse e ≠ e) : (Γ.switch d e).reverse d = Γ.reverse e := by
+  simp [switch,moveMatches,Equiv.swap_apply_of_ne_of_ne hde hee]
+
+theorem switch_reverse_right (d e : D) (hdd : Γ.reverse d ≠ d)
+    (hde : Γ.reverse d ≠ e) : (Γ.switch d e).reverse e = Γ.reverse d := by
+  simp [switch,moveMatches,Equiv.swap_apply_of_ne_of_ne hdd hde]
+
+theorem switch_reverse_unchanged (d e f : D) (hfd : f ≠ d) (hfe : f ≠ e)
+    (hrd : Γ.reverse f ≠ d) (hre : Γ.reverse f ≠ e) :
+    (Γ.switch d e).reverse f = Γ.reverse f := by
+  simp [switch,moveMatches,Equiv.swap_apply_of_ne_of_ne hfd hfe,
+    Equiv.swap_apply_of_ne_of_ne hrd hre]
+
+/-- The subdivision changes exactly the two middle edges, preserving every
+origin-port incidence, including incidences belonging to original loops. -/
+theorem switch_adj (d e : D) (hde : d ≠ e) (hdr : d ≠ Γ.reverse e)
+    (a b : V ⊕ D) :
+    (Γ.switch d e).subdivision.Adj a b ↔
+      (Γ.subdivision.Adj a b ∧ s(a,b) ≠ s(Sum.inr d,Sum.inr (Γ.reverse d)) ∧
+        s(a,b) ≠ s(Sum.inr e,Sum.inr (Γ.reverse e))) ∨
+      s(a,b) = s(Sum.inr d,Sum.inr (Γ.reverse e)) ∨
+      s(a,b) = s(Sum.inr e,Sum.inr (Γ.reverse d)) := by
+  have hrd : Γ.reverse d ≠ d := Γ.reverse_ne d
+  have hre : Γ.reverse e ≠ e := Γ.reverse_ne e
+  have hrd_e : Γ.reverse d ≠ e := by
+    intro h
+    apply hdr
+    rw [← h,Γ.reverse_reverse]
+  have hrev : Γ.reverse d ≠ Γ.reverse e := fun h => hde (Γ.reverse_reverse.injective h)
+  cases a with
+  | inl a =>
+    cases b <;> simp [subdivision,switch_origin]
+  | inr f =>
+    cases b with
+    | inl b => simp [subdivision,switch_origin]
+    | inr g =>
+      change (Equiv.swap d e) (Γ.reverse ((Equiv.swap d e) f)) = g ↔ _
+      simp only [adj_ports,Sym2.eq_iff,Sum.inr.injEq]
+      by_cases hfd : f = d
+      · subst f
+        simp only [Equiv.swap_apply_left,Equiv.swap_apply_of_ne_of_ne hdr.symm hre]
+        grind
+      · by_cases hfe : f = e
+        · subst f
+          simp only [Equiv.swap_apply_right,Equiv.swap_apply_of_ne_of_ne hrd hrd_e]
+          grind
+        · by_cases hfrd : f = Γ.reverse d
+          · subst f
+            simp only [Equiv.swap_apply_of_ne_of_ne hrd hrd_e,reverse_reverse_apply,
+              Equiv.swap_apply_left]
+            grind
+          · by_cases hfre : f = Γ.reverse e
+            · subst f
+              simp only [Equiv.swap_apply_of_ne_of_ne hdr.symm hre,reverse_reverse_apply,
+                Equiv.swap_apply_right]
+              grind
+            · have hrfd : Γ.reverse f ≠ d := by
+                intro h
+                apply hfrd
+                rw [← h,Γ.reverse_reverse]
+              have hrfe : Γ.reverse f ≠ e := by
+                intro h
+                apply hfre
+                rw [← h,Γ.reverse_reverse]
+              simp [Equiv.swap_apply_of_ne_of_ne hfd hfe,
+                Equiv.swap_apply_of_ne_of_ne hrfd hrfe,hfd,hfe,hfrd,hfre]
+
+/-- Transposing two occurrences of the same label preserves every port label. -/
+theorem label_swap {T : Type*} (label : D → T) (d e : D) (h : label d = label e)
+    (f : D) : label ((Equiv.swap d e) f) = label f := by
+  by_cases hfd : f = d
+  · subst f; simpa using h.symm
+  · by_cases hfe : f = e
+    · subst f; simpa using h
+    · rw [Equiv.swap_apply_of_ne_of_ne hfd hfe]
+
+theorem switch_preserves_labels {T : Type*} (label : D → T) (bar : T → T)
+    (hlabel : ∀ f, label (Γ.reverse f) = bar (label f))
+    (d e : D) (h : label d = label e) (f : D) :
+    label ((Γ.switch d e).reverse f) = bar (label f) := by
+  change label ((Equiv.swap d e) (Γ.reverse ((Equiv.swap d e) f))) = bar (label f)
+  rw [label_swap label d e h, hlabel, label_swap label d e h]
+
+end Switching
+
+/-- Multigraph walks remember the traversed port, not just endpoint vertices. -/
+inductive Walk : V → V → Type _
+  | nil (v : V) : Walk v v
+  | cons {v w : V} (d : D) (hd : Γ.origin d = v)
+      (p : Walk (Γ.origin (Γ.reverse d)) w) : Walk v w
+
+namespace Walk
+variable {Γ} {a b c : V}
+
+def length {a b : V} : Γ.Walk a b → ℕ
+  | .nil _ => 0
+  | .cons _ _ p => p.length + 1
+
+def darts {a b : V} : Γ.Walk a b → List D
+  | .nil _ => []
+  | .cons d _ p => d :: p.darts
+
+def append {a b c : V} : Γ.Walk a b → Γ.Walk b c → Γ.Walk a c
+  | .nil _,q => q
+  | .cons d hd p,q => .cons d hd (p.append q)
+
+@[simp] theorem length_darts (p : Γ.Walk a b) : p.darts.length = p.length := by
+  induction p <;> simp_all [darts,length]
+
+@[simp] theorem length_append (p : Γ.Walk a b) (q : Γ.Walk b c) :
+    (p.append q).length = p.length + q.length := by
+  induction p with
+  | nil => simp [append,length]
+  | cons d hd p ih => simp only [append,length,ih]; omega
+
+/-- Source immersion is exactly nonbacktracking of consecutive ports. -/
+def IsReduced (p : Γ.Walk a b) : Prop :=
+  p.darts.IsChain (fun d e => e ≠ Γ.reverse d)
+
+/-- No changes to endpoints or to the original multigraph are made by subdividing. -/
+def toSubdivision {a b : V} : Γ.Walk a b → Γ.subdivision.Walk (.inl a) (.inl b)
+  | .nil a => .nil
+  | .cons d hd p =>
+    .cons (show Γ.subdivision.Adj (.inl a) (.inr d) from hd)
+      (.cons (show Γ.subdivision.Adj (.inr d) (.inr (Γ.reverse d)) from rfl)
+        (.cons (show Γ.subdivision.Adj (.inr (Γ.reverse d)) (.inl (Γ.origin (Γ.reverse d))) from rfl) p.toSubdivision))
+
+@[simp] theorem length_toSubdivision (p : Γ.Walk a b) :
+    p.toSubdivision.length = 3 * p.length := by
+  induction p with
+  | nil => rfl
+  | cons d hd p ih => simp only [toSubdivision,SimpleGraph.Walk.length_cons,length,ih]; omega
+
+@[simp] theorem toSubdivision_append (p : Γ.Walk a b) (q : Γ.Walk b c) :
+    (p.append q).toSubdivision = p.toSubdivision.append q.toSubdivision := by
+  induction p with
+  | nil => rfl
+  | cons d hd p ih => simp only [append,toSubdivision,SimpleGraph.Walk.cons_append,ih]
+
+/-- Immersion of the original port path is preserved by the subdivision.
+In particular the encoding does not spuriously remove a short circuit. -/
+theorem reduced_toSubdivision (p : Γ.Walk a b) (hp : p.IsReduced) :
+    p.toSubdivision.edges.IsChain (· ≠ ·) := by
+  induction p with
+  | nil => simp [toSubdivision]
+  | @cons a b d hd p ih =>
+    cases p with
+    | nil =>
+      simp [toSubdivision, SimpleGraph.Walk.edges_cons, List.isChain_cons_cons]
+    | cons e he q =>
+      have hp' : (Walk.cons e he q).IsReduced := by
+        exact (List.isChain_cons.mp hp).2
+      have hde : e ≠ Γ.reverse d := by
+        exact (List.isChain_cons_cons.mp hp).1
+      have hi := ih hp'
+      simp only [toSubdivision, SimpleGraph.Walk.edges_cons] at hi ⊢
+      simp only [List.isChain_cons_cons] at hi ⊢
+      refine ⟨?_, ?_, ?_, hi⟩
+      · simp
+      · simp
+      · simpa using Ne.symm hde
+
+end Walk
+end PortGraph
+end TorsionFreeZeroDivisors.PortSubdivision
+
+/-!
+Quantitative edge switching for the girth conditioning in types.tex 116–147.
+The simple-graph lemmas are also applicable to the canonical threefold
+subdivision of a port multigraph (loops become triangles). No random-graph
+existence or cone-topology conclusion is assumed in these lemmas.
+-/
+
+namespace TorsionFreeZeroDivisors.GirthSwitch
+
+open SimpleGraph
+open scoped ENNReal
+
+variable {V : Type*} {G H : SimpleGraph V} {a b x y : V}
+
+/-- Decompose at a specified edge occurrence, with its actual orientation. -/
+theorem split_at_edge (p : G.Walk a b) (e : Sym2 V) (he : e ∈ p.edges) :
+    ∃ (x y : V) (hxy : G.Adj x y) (p₁ : G.Walk a x) (p₂ : G.Walk y b),
+      s(x,y) = e ∧ p = p₁.append (.cons hxy p₂) := by
+  induction p with
+  | nil => simp at he
+  | @cons u v w huv p ih =>
+    simp only [Walk.edges_cons, List.mem_cons] at he
+    rcases he with he | he
+    · exact ⟨u,v,huv,.nil,p,he.symm,rfl⟩
+    · obtain ⟨x,y,hxy,p₁,p₂,hxe,hp⟩ := ih he
+      exact ⟨x,y,hxy,.cons huv p₁,p₂,hxe,by rw [hp]; rfl⟩
+
+/-- Removing an edge of a closed trail leaves an alternate walk one shorter,
+without using the removed edge. -/
+theorem alternate_walk (p : G.Walk a a) (hp : p.IsTrail)
+    (e : Sym2 V) (he : e ∈ p.edges) :
+    ∃ (x y : V) (q : G.Walk x y),
+      s(x,y) = e ∧ e ∉ q.edges ∧ q.length + 1 = p.length := by
+  obtain ⟨x,y,hxy,p₁,p₂,hxe,hpdecomp⟩ := split_at_edge p e he
+  subst p
+  have hn := hp.edges_nodup
+  simp only [Walk.edges_append, Walk.edges_cons, List.nodup_append,
+    List.nodup_cons] at hn
+  have hleft : e ∉ p₁.edges := by
+    intro ht
+    exact hn.2.2 e ht e (by simp [hxe]) rfl
+  have hright : e ∉ p₂.edges := by simpa only [hxe] using hn.2.1.1
+  refine ⟨y,x,p₂.append p₁,?_,?_,?_⟩
+  · simpa only [Sym2.eq_swap] using hxe
+  · simp only [Walk.edges_append, List.mem_append, not_or]
+    exact ⟨hright,hleft⟩
+  · simp only [Walk.length_append, Walk.length_cons]
+    omega
+
+/-- Adjoining one new edge. -/
+def addEdge (G : SimpleGraph V) (x y : V) : SimpleGraph V :=
+  G ⊔ SimpleGraph.fromEdgeSet {s(x,y)}
+
+@[simp] theorem addEdge_adj (u v : V) :
+    (addEdge G x y).Adj u v ↔ G.Adj u v ∨ (s(u,v) = s(x,y) ∧ u ≠ v) := by
+  simp [addEdge, SimpleGraph.fromEdgeSet_adj]
+
+/-- A walk avoiding the newly adjoined edge lies in the old graph. -/
+theorem transfer_addEdge (p : (addEdge G x y).Walk a b)
+    (hp : s(x,y) ∉ p.edges) :
+    ∃ q : G.Walk a b, q.length = p.length := by
+  refine ⟨p.transfer G ?_,Walk.length_transfer ..⟩
+  intro e he
+  have hg := p.edges_subset_edgeSet he
+  simp only [addEdge, SimpleGraph.edgeSet_sup, SimpleGraph.edgeSet_fromEdgeSet,
+    Set.mem_union, Set.mem_sdiff, Set.mem_singleton_iff] at hg
+  rcases hg with hg | ⟨rfl,_⟩
+  · exact hg
+  · exact False.elim (hp he)
+
+/-- Adding an edge whose endpoints have no short old connecting path preserves
+the lower girth bound. The path hypothesis includes either orientation. -/
+theorem girth_addEdge (L : ℕ) (hG : (L : ℕ∞) ≤ G.egirth)
+    (hx : ∀ p : G.Walk x y, L ≤ p.length + 1) :
+    (L : ℕ∞) ≤ (addEdge G x y).egirth := by
+  classical
+  rw [SimpleGraph.le_egirth]
+  intro a p hp
+  by_cases he : s(x,y) ∈ p.edges
+  · obtain ⟨u,v,q,huv,hqe,hql⟩ := alternate_walk p hp.isTrail _ he
+    obtain ⟨q',hq'⟩ := transfer_addEdge q hqe
+    have ho : (u = x ∧ v = y) ∨ (u = y ∧ v = x) := by
+      simpa only [Sym2.eq_iff] using huv
+    have hl : L ≤ q'.length + 1 := by
+      rcases ho with ⟨rfl,rfl⟩ | ⟨rfl,rfl⟩
+      · exact hx q'
+      · simpa only [Walk.length_reverse] using hx q'.reverse
+    rw [hq',hql] at hl
+    exact_mod_cast hl
+  · have htransfer : ∀ e, e ∈ p.edges → e ∈ G.edgeSet := by
+      intro e he'
+      have hg := p.edges_subset_edgeSet he'
+      simp only [addEdge, SimpleGraph.edgeSet_sup, SimpleGraph.edgeSet_fromEdgeSet,
+        Set.mem_union, Set.mem_sdiff, Set.mem_singleton_iff] at hg
+      rcases hg with hg | ⟨rfl,_⟩
+      · exact hg
+      · exact False.elim (he he')
+    have hh := SimpleGraph.le_egirth.mp hG a (p.transfer G htransfer) (hp.transfer htransfer)
+    simpa only [Walk.length_transfer] using hh
+
+/-- Before the first occurrence of a new edge, a walk lies wholly in G.
+No simplicity assumption is required for this decomposition. -/
+theorem first_new_edge (p : (addEdge G x y).Walk a b) :
+    (∃ q : G.Walk a b, q.length ≤ p.length) ∨
+    (∃ q : G.Walk a x, q.length + 1 ≤ p.length) ∨
+    (∃ q : G.Walk a y, q.length + 1 ≤ p.length) := by
+  induction p with
+  | nil => exact Or.inl ⟨.nil,le_rfl⟩
+  | @cons u v w huv p ih =>
+    rcases (addEdge_adj u v).mp huv with hold | ⟨he,_⟩
+    · rcases ih with ⟨q,hq⟩ | ⟨q,hq⟩ | ⟨q,hq⟩
+      · exact Or.inl ⟨.cons hold q, by simpa only [Walk.length_cons] using Nat.add_le_add_right hq 1⟩
+      · exact Or.inr (Or.inl ⟨.cons hold q, by simp only [Walk.length_cons]; omega⟩)
+      · exact Or.inr (Or.inr ⟨.cons hold q, by simp only [Walk.length_cons]; omega⟩)
+    · have ho : (u = x ∧ v = y) ∨ (u = y ∧ v = x) := by
+        simpa only [Sym2.eq_iff] using he
+      rcases ho with ⟨rfl,rfl⟩ | ⟨rfl,rfl⟩
+      · exact Or.inr (Or.inl ⟨.nil,by simp⟩)
+      · exact Or.inr (Or.inr ⟨.nil,by simp⟩)
+
+/-- A lower path-length bound is stable under a new edge if both of its
+endpoints are sufficiently far from the starting vertex. -/
+theorem length_lower_addEdge (N : ℕ)
+    (hab : ∀ q : G.Walk a b, N ≤ q.length)
+    (hax : ∀ q : G.Walk a x, N ≤ q.length + 1)
+    (hay : ∀ q : G.Walk a y, N ≤ q.length + 1)
+    (p : (addEdge G x y).Walk a b) : N ≤ p.length := by
+  rcases first_new_edge p with ⟨q,hq⟩ | ⟨q,hq⟩ | ⟨q,hq⟩
+  · exact (hab q).trans hq
+  · exact (hax q).trans hq
+  · exact (hay q).trans hq
+
+/-- In a graph of girth at least L, an alternate path across an old edge
+has length at least L-1. This is precisely the nonbad-edge input to the
+matching transposition argument. -/
+theorem girth_alternate_lower (L : ℕ) (hG : (L : ℕ∞) ≤ G.egirth)
+    (hxy : G.Adj x y) (p : (G.deleteEdges {s(x,y)}).Walk x y) :
+    L ≤ p.length + 1 := by
+  classical
+  let hp := p.mapLe (SimpleGraph.deleteEdges_le {s(x,y)})
+  have he : s(x,y) ∉ hp.edges := by
+    intro he
+    have hmem : s(x,y) ∈ p.edges := by simpa only [hp,Walk.edges_mapLe_eq_edges] using he
+    have hg := p.edges_subset_edgeSet hmem
+    simp at hg
+  have hc := hp.toPath.cons_isCycle hxy.symm (by
+    rw [Sym2.eq_swap]
+    exact fun h => he (Walk.edges_toPath_subset_edges hp h))
+  have hh := SimpleGraph.le_egirth.mp hG y (.cons hxy.symm hp.toPath) hc
+  have hlen := hp.length_bypass_le_length
+  have hh' : L ≤ hp.bypass.length + 1 := by exact_mod_cast hh
+  simpa only [hp,Walk.length_mapLe] using hh'.trans (Nat.add_le_add_right hlen 1)
+
+/-- Two-switching in a simple graph: delete xy and uz, then add xz and uy.
+The distance condition is the manuscript's separation of the two endpoint
+sets. All previous prescribed edges survive provided neither deleted edge
+was among those prescriptions. -/
+theorem girth_switch (L : ℕ) {x y u z : V}
+    (hG : (L : ℕ∞) ≤ G.egirth) (huz : G.Adj u z)
+    (hfar : ∀ a ∈ ({x,y} : Set V), ∀ b ∈ ({u,z} : Set V),
+      ∀ p : G.Walk a b, 2 * L < p.length) :
+    (L : ℕ∞) ≤
+      (addEdge (addEdge (G.deleteEdges {s(x,y),s(u,z)}) x z) u y).egirth := by
+  let H := G.deleteEdges {s(x,y),s(u,z)}
+  have hHG : H ≤ G := SimpleGraph.deleteEdges_le _
+  have hH : (L : ℕ∞) ≤ H.egirth := hG.trans (SimpleGraph.egirth_anti hHG)
+  have hxz (p : H.Walk x z) : L ≤ p.length + 1 := by
+    have hf := hfar x (by simp) z (by simp) (p.mapLe hHG)
+    simp only [Walk.length_mapLe] at hf
+    omega
+  have hg1 := girth_addEdge L hH hxz
+  apply girth_addEdge L hg1
+  intro p
+  rcases first_new_edge p with ⟨q,hq⟩ | ⟨q,hq⟩ | ⟨q,hq⟩
+  · have hf := hfar y (by simp) u (by simp) ((q.mapLe hHG).reverse)
+    simp only [Walk.length_reverse,Walk.length_mapLe] at hf
+    omega
+  · have hf := hfar x (by simp) u (by simp) ((q.mapLe hHG).reverse)
+    simp only [Walk.length_reverse,Walk.length_mapLe] at hf
+    omega
+  · have hdel : H ≤ G.deleteEdges {s(u,z)} := by
+      apply SimpleGraph.deleteEdges_anti
+      simp only [Set.singleton_subset_iff,Set.mem_insert_iff,Set.mem_singleton_iff]
+      simp
+    have hl := girth_alternate_lower L hG huz (q.mapLe hdel)
+    simp only [Walk.length_mapLe] at hl
+    omega
+
+/-- Short cycles in an edge-adjoined graph descend to the old graph whenever
+there is no short alternate path. This needs no girth assumption on the old
+graph, and so also applies during the initial bad-edge repair algorithm. -/
+theorem short_cycle_descends_add (L : ℕ)
+    (hx : ∀ p : G.Walk x y, L ≤ p.length + 1)
+    (p : (addEdge G x y).Walk a a) (hp : p.IsCycle) (hlen : p.length < L) :
+    ∃ q : G.Walk a a, q.IsCycle ∧ q.edges = p.edges ∧ q.length = p.length := by
+  classical
+  have he : s(x,y) ∉ p.edges := by
+    intro he
+    obtain ⟨u,v,q,huv,hqe,hql⟩ := alternate_walk p hp.isTrail _ he
+    obtain ⟨q',hq'⟩ := transfer_addEdge q hqe
+    have ho : (u = x ∧ v = y) ∨ (u = y ∧ v = x) := by
+      simpa only [Sym2.eq_iff] using huv
+    have hl : L ≤ q'.length + 1 := by
+      rcases ho with ⟨rfl,rfl⟩ | ⟨rfl,rfl⟩
+      · exact hx q'
+      · simpa only [Walk.length_reverse] using hx q'.reverse
+    omega
+  have ht : ∀ e, e ∈ p.edges → e ∈ G.edgeSet := by
+    intro e he'
+    have hg := p.edges_subset_edgeSet he'
+    simp only [addEdge, SimpleGraph.edgeSet_sup, SimpleGraph.edgeSet_fromEdgeSet,
+      Set.mem_union, Set.mem_sdiff, Set.mem_singleton_iff] at hg
+    rcases hg with hg | ⟨rfl,_⟩
+    · exact hg
+    · exact False.elim (he he')
+  exact ⟨p.transfer G ht,hp.transfer ht,Walk.edges_transfer ..,Walk.length_transfer ..⟩
+
+/-- Local nonbadness of one edge suffices for the alternate-path estimate. -/
+theorem nonbad_alternate_lower (L : ℕ) (hxy : G.Adj x y)
+    (hnonbad : ∀ a (c : G.Walk a a), c.IsCycle → c.length < L → s(x,y) ∉ c.edges)
+    (p : (G.deleteEdges {s(x,y)}).Walk x y) : L ≤ p.length + 1 := by
+  classical
+  let hp := p.mapLe (SimpleGraph.deleteEdges_le {s(x,y)})
+  have he : s(x,y) ∉ hp.edges := by
+    intro he
+    have hmem : s(x,y) ∈ p.edges := by simpa only [hp,Walk.edges_mapLe_eq_edges] using he
+    have hg := p.edges_subset_edgeSet hmem
+    simp at hg
+  have hc := hp.toPath.cons_isCycle hxy.symm (by
+    rw [Sym2.eq_swap]
+    exact fun h => he (Walk.edges_toPath_subset_edges hp h))
+  by_contra hl
+  have hlen : (Walk.cons hxy.symm (hp.toPath : G.Walk x y)).length < L := by
+    have hh := hp.length_bypass_le_length
+    simp only [Walk.length_cons]
+    change hp.bypass.length + 1 < L
+    have hhp : hp.length = p.length := Walk.length_mapLe _ _
+    omega
+  apply hnonbad y _ hc hlen
+  simp only [Walk.edges_cons,List.mem_cons]
+  exact Or.inl (Sym2.eq_swap)
+
+/-- The repair two-switch creates no short cycle, even before girth has been
+repaired everywhere. Deleting a bad edge therefore strictly reduces the bad
+edge set; this local assertion is the core of the repair argument. -/
+theorem short_cycle_descends_switch (L : ℕ) {x y u z : V}
+    (huz : G.Adj u z)
+    (hnonbad : ∀ a (c : G.Walk a a), c.IsCycle → c.length < L → s(u,z) ∉ c.edges)
+    (hfar : ∀ a ∈ ({x,y} : Set V), ∀ b ∈ ({u,z} : Set V),
+      ∀ p : G.Walk a b, 2 * L < p.length)
+    (p : (addEdge (addEdge (G.deleteEdges {s(x,y),s(u,z)}) x z) u y).Walk a a)
+    (hp : p.IsCycle) (hlen : p.length < L) :
+    ∃ q : (G.deleteEdges {s(x,y),s(u,z)}).Walk a a,
+      q.IsCycle ∧ q.edges = p.edges ∧ q.length = p.length := by
+  let H := G.deleteEdges {s(x,y),s(u,z)}
+  have hHG : H ≤ G := SimpleGraph.deleteEdges_le _
+  have hxz (p : H.Walk x z) : L ≤ p.length + 1 := by
+    have hf := hfar x (by simp) z (by simp) (p.mapLe hHG)
+    simp only [Walk.length_mapLe] at hf
+    omega
+  have huy (p : (addEdge H x z).Walk u y) : L ≤ p.length + 1 := by
+    rcases first_new_edge p with ⟨q,hq⟩ | ⟨q,hq⟩ | ⟨q,hq⟩
+    · have hf := hfar y (by simp) u (by simp) ((q.mapLe hHG).reverse)
+      simp only [Walk.length_reverse,Walk.length_mapLe] at hf
+      omega
+    · have hf := hfar x (by simp) u (by simp) ((q.mapLe hHG).reverse)
+      simp only [Walk.length_reverse,Walk.length_mapLe] at hf
+      omega
+    · have hdel : H ≤ G.deleteEdges {s(u,z)} := by
+        apply SimpleGraph.deleteEdges_anti
+        simp
+      have hl := nonbad_alternate_lower L huz hnonbad (q.mapLe hdel)
+      simp only [Walk.length_mapLe] at hl
+      omega
+  obtain ⟨q,hq,hqe,hql⟩ := short_cycle_descends_add L huy p hp hlen
+  obtain ⟨q',hq',hq'e,hq'l⟩ := short_cycle_descends_add L hxz q hq (by omega)
+  exact ⟨q',hq',hq'e.trans hqe,hq'l.trans hql⟩
+
+/-- At the shortest-cycle threshold, no nonbadness requirement is needed
+on the auxiliary edge: a new cycle using both new edges is strictly longer
+than the old girth. This permits deterministic girth repair. -/
+theorem shortest_cycle_descends_switch (L : ℕ) {x y u z : V}
+    (hG : (L : ℕ∞) ≤ G.egirth) (huz : G.Adj u z)
+    (hfar : ∀ a ∈ ({x,y} : Set V), ∀ b ∈ ({u,z} : Set V),
+      ∀ p : G.Walk a b, 2 * (L+1) < p.length)
+    (p : (addEdge (addEdge (G.deleteEdges {s(x,y),s(u,z)}) x z) u y).Walk a a)
+    (hp : p.IsCycle) (hlen : p.length < L+1) :
+    ∃ q : (G.deleteEdges {s(x,y),s(u,z)}).Walk a a,
+      q.IsCycle ∧ q.edges = p.edges ∧ q.length = p.length := by
+  let H := G.deleteEdges {s(x,y),s(u,z)}
+  have hHG : H ≤ G := SimpleGraph.deleteEdges_le _
+  have hxz (p : H.Walk x z) : L+1 ≤ p.length + 1 := by
+    have hf := hfar x (by simp) z (by simp) (p.mapLe hHG)
+    simp only [Walk.length_mapLe] at hf
+    omega
+  have huy (p : (addEdge H x z).Walk u y) : L+1 ≤ p.length + 1 := by
+    rcases first_new_edge p with ⟨q,hq⟩ | ⟨q,hq⟩ | ⟨q,hq⟩
+    · have hf := hfar y (by simp) u (by simp) ((q.mapLe hHG).reverse)
+      simp only [Walk.length_reverse,Walk.length_mapLe] at hf
+      omega
+    · have hf := hfar x (by simp) u (by simp) ((q.mapLe hHG).reverse)
+      simp only [Walk.length_reverse,Walk.length_mapLe] at hf
+      omega
+    · have hdel : H ≤ G.deleteEdges {s(u,z)} := by
+        apply SimpleGraph.deleteEdges_anti
+        simp
+      have hl := girth_alternate_lower L hG huz (q.mapLe hdel)
+      simp only [Walk.length_mapLe] at hl
+      omega
+  obtain ⟨q,hq,hqe,hql⟩ := short_cycle_descends_add (L+1) huy p hp hlen
+  obtain ⟨q',hq',hq'e,hq'l⟩ := short_cycle_descends_add (L+1) hxz q hq (by omega)
+  exact ⟨q',hq',hq'e.trans hqe,hq'l.trans hql⟩
+
+/-- The exact set minimized by the finite repair argument. -/
+def badEdges (G : SimpleGraph V) (L : ℕ) : Set (Sym2 V) :=
+  {e | ∃ (a : V) (p : G.Walk a a), p.IsCycle ∧ p.length < L ∧ e ∈ p.edges}
+
+theorem badEdges_subset {L : ℕ} : badEdges G L ⊆ G.edgeSet := by
+  rintro e ⟨a,p,hp,hl,he⟩
+  exact p.edges_subset_edgeSet he
+
+/-- Edgewise transfer of short cycles strictly reduces the bad edge set
+as soon as a specified old bad edge has been deleted. -/
+theorem badEdges_strict {L : ℕ} [Fintype V] (e : Sym2 V) (he : e ∈ badEdges G L)
+    (hdesc : ∀ a (p : H.Walk a a), p.IsCycle → p.length < L →
+      ∃ q : G.Walk a a, q.IsCycle ∧ q.edges = p.edges ∧ q.length = p.length)
+    (hdel : e ∉ badEdges H L) :
+    (badEdges H L).toFinite.toFinset.card < (badEdges G L).toFinite.toFinset.card := by
+  classical
+  apply Finset.card_lt_card
+  apply Finset.ssubset_iff_subset_ne.mpr
+  refine ⟨?_,?_⟩
+  · intro f hf
+    have hf' : f ∈ badEdges H L := by simpa using hf
+    obtain ⟨a,p,hp,hl,hf'⟩ := hf'
+    obtain ⟨q,hq,hqe,hql⟩ := hdesc a p hp hl
+    simpa using (show f ∈ badEdges G L from ⟨a,q,hq,by omega,hqe ▸ hf'⟩)
+  · intro heq
+    have heH : e ∈ (badEdges H L).toFinite.toFinset := by
+      rw [heq]
+      simpa using he
+    have heH' : e ∈ badEdges H L := by simpa using heH
+    exact hdel heH'
+
+/-- Finite extremal repair raises the girth by one. Unlike the manuscript's
+probabilistic initialization, this argument only needs the uniform far-edge
+supply; all objects and the final girth condition are unchanged. -/
+theorem girth_improve_one [Fintype V] (L : ℕ) (P : SimpleGraph V → Prop)
+    (hne : ∃ G, P G ∧ (L : ℕ∞) ≤ G.egirth)
+    (hswitch : ∀ G, P G → ∀ a (p : G.Walk a a), p.IsCycle →
+      ∃ x y u z, s(x,y) ∈ p.edges ∧ G.Adj u z ∧
+        (∀ a ∈ ({x,y} : Set V), ∀ b ∈ ({u,z} : Set V),
+          ∀ p : G.Walk a b, 2 * (L+1) < p.length) ∧
+        P (addEdge (addEdge (G.deleteEdges {s(x,y),s(u,z)}) x z) u y)) :
+    ∃ G, P G ∧ ((L+1 : ℕ) : ℕ∞) ≤ G.egirth := by
+  classical
+  let S : Set (SimpleGraph V) := {G | P G ∧ (L : ℕ∞) ≤ G.egirth}
+  obtain ⟨G,hGP,hmin⟩ := S.exists_min_image
+    (fun G => (badEdges G (L+1)).toFinite.toFinset.card) S.toFinite hne
+  refine ⟨G,hGP.1,?_⟩
+  by_contra hn
+  rw [SimpleGraph.le_egirth] at hn
+  push Not at hn
+  obtain ⟨a,p,hp,hl⟩ := hn
+  have hlen : p.length < L+1 := by exact_mod_cast hl
+  obtain ⟨x,y,u,z,he,huz,hfar,hP⟩ := hswitch G hGP.1 a p hp
+  let e := s(x,y)
+  let H := addEdge (addEdge (G.deleteEdges {s(x,y),s(u,z)}) x z) u y
+  have hdesc (a : V) (q : H.Walk a a) (hq : q.IsCycle) (hl : q.length < L+1) :=
+    shortest_cycle_descends_switch L hGP.2 huz hfar q hq hl
+  have hstrict : (badEdges H (L+1)).toFinite.toFinset.card <
+      (badEdges G (L+1)).toFinite.toFinset.card := by
+    apply badEdges_strict e ⟨a,p,hp,hlen,he⟩
+    · intro a q hq hl
+      obtain ⟨q',hq',hqe,hql⟩ := hdesc a q hq hl
+      exact ⟨q'.mapLe (SimpleGraph.deleteEdges_le _), hq'.mapLe _,
+        (Walk.edges_mapLe_eq_edges ..).trans hqe,(Walk.length_mapLe ..).trans hql⟩
+    · rintro ⟨a,q,hq,hl,heq⟩
+      obtain ⟨q',hq',hqe,hql⟩ := hdesc a q hq hl
+      have hg := q'.edges_subset_edgeSet (hqe ▸ heq)
+      change s(x,y) ∈ (G.deleteEdges {s(x,y),s(u,z)}).edgeSet at hg
+      simp at hg
+  have hHg : (L : ℕ∞) ≤ H.egirth := girth_switch L hGP.2 huz (by
+    intro a ha b hb q
+    have hh := hfar a ha b hb q
+    omega)
+  exact (not_lt_of_ge (hmin H ⟨hP,hHg⟩)) hstrict
+
+/-- Arbitrarily specified finite girth follows by finitely many exact
+transpositions if the family has a uniform distant auxiliary edge supply. -/
+theorem exists_large_girth [Fintype V] (N : ℕ) (P : SimpleGraph V → Prop)
+    (hne : ∃ G, P G)
+    (hswitch : ∀ G, P G → ∀ a (p : G.Walk a a), p.IsCycle →
+      ∃ x y u z, s(x,y) ∈ p.edges ∧ G.Adj u z ∧
+        (∀ a ∈ ({x,y} : Set V), ∀ b ∈ ({u,z} : Set V),
+          ∀ p : G.Walk a b, 2 * N < p.length) ∧
+        P (addEdge (addEdge (G.deleteEdges {s(x,y),s(u,z)}) x z) u y)) :
+    ∃ G, P G ∧ (N : ℕ∞) ≤ G.egirth := by
+  have hstep : ∀ k ≤ N, ∃ G, P G ∧ (k : ℕ∞) ≤ G.egirth := by
+    intro k
+    induction k with
+    | zero =>
+      intro _
+      obtain ⟨G,hG⟩ := hne
+      exact ⟨G,hG,zero_le⟩
+    | succ k ih =>
+      intro hk
+      apply girth_improve_one k P (ih (by omega))
+      intro G hG a p hp
+      obtain ⟨x,y,u,z,he,huz,hfar,hP⟩ := hswitch G hG a p hp
+      refine ⟨x,y,u,z,he,huz,?_,hP⟩
+      intro a ha b hb p
+      have hf := hfar a ha b hb p
+      omega
+  exact hstep N le_rfl
+
+/-- Below the girth, a nonbacktracking walk cannot repeat a vertex.
+This is the quantitative version of Mathlib's forest lemma. -/
+theorem short_reduced_isPath (L : ℕ) (hG : L ≤ G.egirth)
+    (p : G.Walk a b) (hlen : p.length < L)
+    (h : p.edges.IsChain (· ≠ ·)) : p.IsPath := by
+  classical
+  induction p with
+  | nil => simp
+  | @cons u v w head tail ih =>
+    have hcc := List.isChain_cons.mp (Walk.edges_cons _ _ ▸ h)
+    have hi : tail.IsPath := ih (by simpa only [Walk.length_cons] using
+      (show tail.length + 1 < L from hlen) |> fun h => by omega) hcc.2
+    refine Walk.cons_isPath_iff head tail |>.mpr ⟨hi, ?_⟩
+    rcases tail.length.eq_zero_or_pos with hz | hz
+    · simp [Walk.nil_iff_support_eq.mp (Walk.length_eq_zero_iff.mp hz), head.ne]
+    · by_contra hh
+      have hc : (Walk.cons head (tail.takeUntil u hh)).IsCycle := by
+        simp only [Walk.isCycle_def, Walk.isTrail_def, Walk.edges_cons, List.nodup_cons,
+          ne_eq, reduceCtorEq, not_false_eq_true, Walk.support_cons, List.tail_cons, true_and]
+        have ht : (Walk.cons head (tail.takeUntil u hh)).support.tail.Nodup :=
+          tail.isPath_def.mp hi |>.sublist <| List.IsInfix.sublist
+            ⟨[], (tail.dropUntil u hh).support.tail, by simp [← Walk.support_append]⟩
+        refine ⟨⟨?_, Walk.edges_nodup_of_support_nodup ht⟩, ht⟩
+        by_contra he
+        refine hcc.1 s(u,v) ?_ rfl
+        rw [← tail.cons_tail_eq (by simp [Walk.not_nil_iff_lt_length, hz])]
+        have hh' := Walk.IsPath.mk' ht |>.eq_snd_of_mem_edges (Sym2.eq_swap ▸ he)
+        simp [hh', Walk.snd_takeUntil head.ne]
+      have hg := hc.egirth_le_length
+      have ht := tail.length_takeUntil_le_length hh
+      have hn : L ≤ (Walk.cons head (tail.takeUntil u hh)).length :=
+        ENat.natCast_le_natCast.mp (hG.trans hg)
+      simp only [Walk.length_cons] at hn hlen
+      omega
+
+/-- Every nonempty immersed circuit has at least the graph's girth. -/
+theorem reduced_closed_length (L : ℕ) (hG : L ≤ G.egirth)
+    (p : G.Walk a a) (hne : 0 < p.length)
+    (h : p.edges.IsChain (· ≠ ·)) : L ≤ p.length := by
+  by_contra hn
+  have hp := short_reduced_isPath L hG p (by omega) h
+  have he := (Walk.isPath_iff_nil.mp hp).eq_nil
+  have hl : p.length = 0 := by rw [he]; rfl
+  omega
+
+end TorsionFreeZeroDivisors.GirthSwitch
+
+/-! ### Typed matching families have nonempty large-girth spaces. -/
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/GroupRing/RawDecomposition.lean b/lean/OAI/Algebra/GroupRing/RawDecomposition.lean
new file mode 100644
index 0000000000000000000000000000000000000000..a823adaf3e83483f10ce48c4e8f3e0721dfa3dfe
--- /dev/null
+++ b/lean/OAI/Algebra/GroupRing/RawDecomposition.lean
@@ -0,0 +1,495 @@
+import Mathlib
+import OAI.Algebra.GroupRing.ChainUsage
+
+namespace OAI
+
+noncomputable section
+
+namespace TorsionFreeZeroDivisors.RawDecomposition
+open scoped Classical BigOperators
+open PortSubdivision MarkedChainBound DegreeTwoSuppression ChainSuppression SuppressedMoore ChainPaths
+open ChainIsomorphism ChainChunkTransport ChunkComparisons FiniteChunking ComparedBlocks
+open ActualComplexity CoreStripping ImageComplexity GirthAsymptotics TypedGraphs
+variable {V D P : Type} [Fintype V] [Fintype D] [Fintype P]
+    (Γ : PortGraph V D) (raw : P → List D) (hp : ∀ p,raw p≠[])
+    (hc : ∀ p,(raw p).IsChain (WeightedMoore.PortWalk.step Γ.origin Γ.reverse))
+
+abbrev marks := ActualComplexity.endpoints Γ raw hp
+abbrev mark := MarkedChainBound.marks Γ (marks Γ raw hp)
+abbrev degree_two := marks_degree_two Γ (marks Γ raw hp)
+abbrev Seeds := SourcePattern.Seeds Γ (marks Γ raw hp)
+
+include hc in
+omit [Fintype V] in
+lemma decomposition (p : P) : ∃ ds : List (Seeds Γ raw hp),
+    ds.flatMap (word Γ (mark Γ raw hp) (degree_two Γ raw hp))=raw p := by
+  obtain ⟨ds,hd,_⟩ := ChainPathTransport.decomposes Γ (mark Γ raw hp) (degree_two Γ raw hp)
+    (raw p) (hc p) (fun d hd => Or.inr (start_mem Γ raw hp p hd))
+    (fun d hd => Or.inr (finish_mem Γ raw hp p hd))
+  exact ⟨ds,hd⟩
+
+def paths (p : P) : List (Seeds Γ raw hp) := (decomposition Γ raw hp hc p).choose
+omit [Fintype V] in
+lemma expands (p : P) : (paths Γ raw hp hc p).flatMap (word Γ (mark Γ raw hp) (degree_two Γ raw hp))=raw p :=
+  (decomposition Γ raw hp hc p).choose_spec
+omit [Fintype V] in
+lemma nonempty (p : P) : paths Γ raw hp hc p≠[] := by
+  intro he
+  have hx := expands Γ raw hp hc p
+  rw [he,List.flatMap_nil] at hx
+  exact hp p hx.symm
+
+abbrev lengths := pathLength (chunks Γ (mark Γ raw hp) (degree_two Γ raw hp) (paths Γ raw hp hc))
+  (chunkLength Γ (mark Γ raw hp) (degree_two Γ raw hp) (paths Γ raw hp hc))
+omit [Fintype V] in
+lemma length_eq (p : P) : lengths Γ raw hp hc p=(raw p).length := by
+  rw [lengths,pathLength_eq,expands]
+omit [Fintype V] in
+lemma lengths_eq : lengths Γ raw hp hc=(fun p => (raw p).length) := funext (length_eq Γ raw hp hc)
+
+/-- Positions remember their literal original dart, without a choice of orientation. -/
+def dart (x : Position (fun p => (raw p).length)) : D := (raw x.1).get ⟨x.2.val.toNat,by
+  have hx := x.2.property
+  have hz : 0≤x.2.val ∧ x.2.val<(raw x.1).length := by
+    simpa only [AffineIntervals.nat_positions,Finset.mem_Ico] using hx
+  omega⟩
+omit [Fintype D] [Fintype P] in
+lemma dart_get (x : Position (fun p => (raw p).length)) :
+    (raw x.1)[x.2.val.toNat]?=some (dart raw x) := List.getElem?_eq_getElem _
+
+def position : Position (lengths Γ raw hp hc) ≃ Position (fun p => (raw p).length) :=
+  ComparisonGeometry.position (Equiv.refl P) (length_eq Γ raw hp hc)
+omit [Fintype V] in
+lemma dart_eq (x : Position (lengths Γ raw hp hc)) :
+    originalDart Γ (mark Γ raw hp) (degree_two Γ raw hp) (paths Γ raw hp hc) x=
+      dart raw (position Γ raw hp hc x) := by
+  apply Option.some.inj
+  rw [←originalDart_get,expands,←dart_get]
+  rfl
+
+omit [Fintype V] in
+lemma source_eq (root : Option P) :
+    StageRoot.source Γ (mark Γ raw hp) (degree_two Γ raw hp) (paths Γ raw hp hc)
+      (nonempty Γ raw hp hc) root = root.map (fun p => Γ.origin ((raw p).head (hp p))) := by
+  cases root with
+  | none => rfl
+  | some p =>
+    change some (Γ.origin ((paths Γ raw hp hc p).head (nonempty Γ raw hp hc p)).val)=_
+    have he := ChainPathTransport.flatMap_head Γ (mark Γ raw hp) (degree_two Γ raw hp) (paths Γ raw hp hc p)
+    rw [expands,List.head?_eq_some_head (hp p),
+      List.head?_eq_some_head (nonempty Γ raw hp hc p),Option.map_some] at he
+    exact congrArg (fun d => some (Γ.origin d)) (Option.some.inj he).symm
+
+end TorsionFreeZeroDivisors.RawDecomposition
+
+namespace TorsionFreeZeroDivisors.ComparisonGeometry
+
+section
+open scoped Classical
+open ComparedBlocks ChunkComparisons
+variable {P E : Type} {l l' : P → ℕ}
+
+def cast (h : l=l') (c : Comparisons (E:=E) l) : Comparisons (E:=E) l' := h ▸ c
+def castIso (h : l=l') (c : Comparisons (E:=E) l) : Iso c (cast h c) := by
+  subst l'
+  exact ⟨Equiv.refl P,Equiv.refl E,fun _ => rfl,fun _ => rfl,fun _ => rfl,
+    fun _ => rfl,fun _ => rfl,fun _ => rfl,fun _ => rfl⟩
+
+variable [Fintype P]
+lemma Iso.unpaired {c : Comparisons (E:=E) l} {c' : Comparisons (E:=E) l'} (f : Iso c c') :
+    (Finset.univ.filter (fun x => c.pairing.partner x=x)).card=
+    (Finset.univ.filter (fun x => c'.pairing.partner x=x)).card := by
+  rw [←Fintype.card_subtype,←Fintype.card_subtype]
+  apply Fintype.card_congr
+  exact (position f.path f.length_eq).subtypeEquiv (fun x => by
+    rw [←f.partner_eq,(position f.path f.length_eq).injective.eq_iff])
+end
+open scoped Classical
+open ComparedBlocks ChunkComparisons
+variable {P E : Type} {l l' : P → ℕ}
+def castBackIso (h : l'=l) (c : Comparisons (E:=E) l) : Iso (cast h.symm c) c where
+  path := Equiv.refl P
+  comparison := Equiv.refl E
+  length_eq p := congrFun h p
+  flip_eq := by cases h; exact fun _ => rfl
+  source_eq := by cases h; exact fun _ => rfl
+  lo_eq := by cases h; exact fun _ => rfl
+  hi_eq := by cases h; exact fun _ => rfl
+  reverse_eq := by cases h; exact fun _ => rfl
+  offset_eq := by cases h; exact fun _ => rfl
+end TorsionFreeZeroDivisors.ComparisonGeometry
+
+namespace TorsionFreeZeroDivisors.RawSourcePattern
+
+section
+open scoped Classical BigOperators
+open PortSubdivision MarkedChainBound DegreeTwoSuppression ChainSuppression SuppressedMoore ChainPaths
+open ChainIsomorphism ChainChunkTransport ChunkComparisons FiniteChunking ComparedBlocks
+open ActualComplexity CoreStripping ImageComplexity GirthAsymptotics TypedGraphs ActualPatternEvent
+
+/-- The data of a literal bounded family of immersed graph paths. The finite
+image graph is arbitrary; only the source's bounds on path and comparison
+counts, total length and proportion of unpaired letters are stated here. -/
+structure Data (B K I rep : ℕ) where
+  V : Type
+  D : Type
+  P : Type
+  E : Type
+  [fV : Fintype V]
+  [fD : Fintype D]
+  [fP : Fintype P]
+  [fE : Fintype E]
+  graph : PortGraph V D
+  no_isolated : Function.Surjective graph.origin
+  side : V → Bool
+  side_edge : ∀ d,side (graph.origin (graph.reverse d))=side (graph.origin d)
+  paths : P → List D
+  nonempty : ∀ p,paths p≠[]
+  root : Option P
+  path_bound : Fintype.card P≤K
+  comparison_bound : Fintype.card E≤I
+  image : ∀ d,∃ p,d∈paths p ∨ graph.reverse d∈paths p
+  path_chain : ∀ p,(paths p).IsChain (WeightedMoore.PortWalk.step graph.origin graph.reverse)
+  cyclic_chain : ∀ p,StageRoot.cyclic root p=true →
+    ∀ᵉ (x∈(paths p).getLast?) (y∈(paths p).head?),
+      WeightedMoore.PortWalk.step graph.origin graph.reverse x y
+  girth : ∀ a (c : graph.subdivision.Walk a a),c.IsCycle →
+    (L (size rep):ℝ)≤WeightedCycles.weight (WeightedPortMoore.edgeWeight (fun _ : D => (1:ℝ))) c
+  length_le : (∑p,(paths p).length:ℕ)≤B*L (size rep)
+  length_ge : L (size rep)≤(∑p,(paths p).length:ℕ)
+  comparisons : Comparisons (E:=E) (fun p => (paths p).length)
+  lower : E → ℕ
+  upper : E → ℕ
+  lower_eq : ∀ e,comparisons.lo e=lower e
+  upper_eq : ∀ e,comparisons.hi e=upper e
+  lower_le : ∀ e,lower e≤upper e
+  upper_le : ∀ e,upper e≤(paths (comparisons.source e)).length
+  reduced : ∀ x e,comparisons.side x=some e →
+    RawDecomposition.dart paths x≠RawDecomposition.dart paths (comparisons.pairing.partner x) ∧
+    RawDecomposition.dart paths x≠graph.reverse (RawDecomposition.dart paths (comparisons.pairing.partner x))
+  unpaired_le : ((Finset.univ.filter (fun x => comparisons.pairing.partner x=x)).card:ℝ)≤
+    StageFusion.epsilon (1/600) 256*(∑p,(paths p).length:ℕ)
+attribute [instance] Data.fV Data.fD Data.fP Data.fE
+
+namespace Data
+variable {B K I rep : ℕ} (a : Data B K I rep)
+abbrev vertices := ActualComplexity.endpoints a.graph a.paths a.nonempty
+abbrev mark := MarkedChainBound.marks a.graph a.vertices
+abbrev degree_two := marks_degree_two a.graph a.vertices
+abbrev decomposed := RawDecomposition.paths a.graph a.paths a.nonempty a.path_chain
+abbrev decomposed_nonempty := RawDecomposition.nonempty a.graph a.paths a.nonempty a.path_chain
+abbrev lengths_eq := RawDecomposition.lengths_eq a.graph a.paths a.nonempty a.path_chain
+abbrev comparison := ComparisonGeometry.cast a.lengths_eq.symm a.comparisons
+abbrev iso := ComparisonGeometry.castBackIso a.lengths_eq a.comparisons
+abbrev position := RawDecomposition.position a.graph a.paths a.nonempty a.path_chain
+
+lemma expands (p : a.P) : (a.decomposed p).flatMap (word a.graph a.mark a.degree_two)=a.paths p :=
+  RawDecomposition.expands a.graph a.paths a.nonempty a.path_chain p
+lemma length_eq (p : a.P) : pathLength (chunks a.graph a.mark a.degree_two a.decomposed)
+    (chunkLength a.graph a.mark a.degree_two a.decomposed) p=(a.paths p).length :=
+  RawDecomposition.length_eq a.graph a.paths a.nonempty a.path_chain p
+lemma dart_eq (x : Position (pathLength (chunks a.graph a.mark a.degree_two a.decomposed)
+    (chunkLength a.graph a.mark a.degree_two a.decomposed))) :
+    originalDart a.graph a.mark a.degree_two a.decomposed x=RawDecomposition.dart a.paths (a.position x) :=
+  RawDecomposition.dart_eq a.graph a.paths a.nonempty a.path_chain x
+lemma position_iso : a.position=ComparisonGeometry.position a.iso.path a.iso.length_eq := rfl
+
+/-- All suppression data is constructed from the literal paths, with no bounds
+on a suppressed skeleton included among the raw data. -/
+def suppressed : SourcePattern.Data B K I rep where
+  V := a.V
+  D := a.D
+  P := a.P
+  E := a.E
+  graph := a.graph
+  vertices := a.vertices
+  vertices_bound := (ActualComplexity.endpoints_card a.graph a.paths a.nonempty).trans
+    (Nat.mul_le_mul_left 2 a.path_bound)
+  no_isolated := a.no_isolated
+  side := a.side
+  side_edge := a.side_edge
+  paths := a.decomposed
+  nonempty := a.decomposed_nonempty
+  root := a.root
+  path_bound := a.path_bound
+  comparison_bound := a.comparison_bound
+  image := by
+    intro d
+    simpa only [expands] using a.image d
+  path_chain := by simpa only [expands] using a.path_chain
+  cyclic_chain := by simpa only [expands] using a.cyclic_chain
+  girth := a.girth
+  length_le := by simpa only [expands] using a.length_le
+  length_ge := by simpa only [expands] using a.length_ge
+  comparisons := a.comparison
+  lower := a.lower
+  upper := a.upper
+  lower_eq e := (a.iso.lo_eq e).trans (a.lower_eq e)
+  upper_eq e := (a.iso.hi_eq e).trans (a.upper_eq e)
+  lower_le := a.lower_le
+  upper_le e := by
+    rw [a.length_eq]
+    have hs : a.comparison.source e=a.comparisons.source e := a.iso.source_eq e
+    rw [hs]
+    exact a.upper_le e
+  reduced := by
+    intro x e he
+    have hh := a.reduced (a.position x) e ((a.iso.side_some x e).mpr he)
+    rw [a.dart_eq,a.dart_eq,position_iso,a.iso.partner_eq]
+    exact hh
+  unpaired_le := by
+    rw [a.iso.unpaired]
+    simpa only [expands] using a.unpaired_le
+
+/-- The event reads the literal original path label, and pins the actual initial
+vertex of the exceptional interval on its prescribed side. -/
+def event (x : Types.VertexA rep) (y : Types.VertexB rep) (r : Match rep) : Prop :=
+  ∃ label : a.D → Types.Letter,
+    (∀ d,label (a.graph.reverse d)=Types.inverse (label d)) ∧
+    (∀ d e,a.graph.origin d=a.graph.origin e → label d=label e → d=e) ∧
+    (∀ p e,a.comparisons.side p=some e → label (RawDecomposition.dart a.paths p)=
+      if a.comparisons.reverse e then Types.inverse (label (RawDecomposition.dart a.paths (a.comparisons.pairing.partner p)))
+      else label (RawDecomposition.dart a.paths (a.comparisons.pairing.partner p))) ∧
+    Nonempty (RealizationTransport.Embedding (SideRestriction.graph a.graph a.side a.side_edge true)
+      (fun d => label d.val) (@Types.outgoingA rep)
+      (RootPins.pin (SidePins.root a.side (a.root.map fun p => a.graph.origin ((a.paths p).head (a.nonempty p))) true) x)
+      Types.inverse r.1) ∧
+    Nonempty (RealizationTransport.Embedding (SideRestriction.graph a.graph a.side a.side_edge false)
+      (fun d => label d.val) (@Types.outgoingB rep)
+      (RootPins.pin (SidePins.root a.side (a.root.map fun p => a.graph.origin ((a.paths p).head (a.nonempty p))) false) y)
+      Types.inverse r.2)
+
+lemma suppressed_event (x : Types.VertexA rep) (y : Types.VertexB rep) (r : Match rep)
+    (h : a.event x y r) :
+    OriginalPattern.Realized a.graph a.mark a.degree_two a.side a.side_edge a.decomposed
+      a.decomposed_nonempty a.root rep x y a.comparison r := by
+  rcases h with ⟨label,hl,hn,hc,ha,hb⟩
+  refine ⟨label,hl,hn,?_,?_,?_⟩
+  · intro p e he
+    have hh := hc (a.position p) e ((a.iso.side_some p e).mpr he)
+    rw [a.dart_eq,a.dart_eq,position_iso,a.iso.partner_eq,a.iso.reverse_eq]
+    exact hh
+  · simpa only [sourcePinA,RawDecomposition.source_eq] using ha
+  · simpa only [sourcePinB,RawDecomposition.source_eq] using hb
+
+end Data
+end
+open scoped Classical
+open GirthAsymptotics TypedGraphs ActualPatternEvent Filter
+
+/-- Literal immersed source paths, not assumed to come with a suppression or
+finite encoding, are avoided by an actual pair of high-girth typed graphs. -/
+theorem eventually_avoids (B K I : ℕ) (hK : 0<K) (hI : 0<I) :
+    ∀ᶠ rep in atTop,∀ (x : Types.VertexA rep) (y : Types.VertexB rep),
+      ∃ r∈samples rep,∀ a : Data B K I rep,¬a.event x y r := by
+  have hT : 0<SourcePattern.T B K := Nat.mul_pos (SourcePattern.R_pos B K)
+    (by omega)
+  filter_upwards [BoundedPattern.eventually_avoids (SourcePattern.R B K) K (SourcePattern.T B K)
+    I B (SourcePattern.R B K) (SourcePattern.T B K) (I*(SourcePattern.T B K)^2)
+    (SourcePattern.R_pos B K) hK hI hT,
+    (L_tendsto.comp size_tendsto).eventually (eventually_ge_atTop 1)] with rep hr hL
+  change 1≤L (size rep) at hL
+  intro x y
+  obtain ⟨r,hs,ha⟩ := hr x y
+  refine ⟨r,hs,fun a he => ?_⟩
+  exact ha (a.suppressed.bounded (by omega)) (a.suppressed.bounded_good (by omega))
+    (a.suppressed_event x y r he)
+
+end TorsionFreeZeroDivisors.RawSourcePattern
+namespace TorsionFreeZeroDivisors.DiameterCounting
+open scoped BigOperators Classical
+open ConditionedMatchings
+variable {V D T : Type*} [Fintype V] [Fintype D]
+variable (origin : D → V)
+
+def ports (S : Finset V) : Finset D := Finset.univ.filter (fun e => origin e ∈ S)
+
+omit [Fintype V] in
+@[simp] lemma mem_ports (S : Finset V) (e : D) : e ∈ ports origin S ↔ origin e ∈ S := by
+  simp [ports]
+
+omit [Fintype V] in
+lemma card_ports (S : Finset V) :
+    (ports origin S).card = ∑ v ∈ S, Nat.card {e : D // origin e=v} := by
+  classical
+  rw [Finset.card_eq_sum_card_fiberwise (f := origin) (t := S)]
+  · apply Finset.sum_congr rfl
+    intro v hv
+    rw [Nat.card_eq_fintype_card,Fintype.card_subtype]
+    congr 1
+    ext e
+    simp only [Finset.mem_filter,mem_ports,Finset.mem_univ,true_and]
+    exact ⟨fun h => h.2,fun h => ⟨h ▸ hv,h⟩⟩
+  · intro e he
+    exact (mem_ports origin S e).mp he
+
+omit [Fintype V] in
+lemma card_ports_le (d : ℕ) (hd : ∀ v, Nat.card {e : D // origin e=v} ≤ d)
+    (S : Finset V) : (ports origin S).card ≤ S.card*d := by
+  rw [card_ports]
+  calc
+    _ ≤ ∑ _v ∈ S, d := Finset.sum_le_sum fun v _ => hd v
+    _ = _ := by simp
+
+omit [Fintype V] in
+lemma card_ports_ge (d : ℕ) (hd : ∀ v, d ≤ Nat.card {e : D // origin e=v})
+    (S : Finset V) : S.card*d ≤ (ports origin S).card := by
+  rw [card_ports]
+  calc
+    _ = ∑ _v ∈ S, d := by simp
+    _ ≤ _ := Finset.sum_le_sum fun v _ => hd v
+
+/-- All potential unordered prescribed matching pairs within a vertex set.
+Keeping infeasible ones is a harmless overcount. -/
+def possible (S : Finset V) : Finset (Sym2 D) :=
+  ((ports origin S) ×ˢ (ports origin S)).image fun p => s(p.1,p.2)
+
+omit [Fintype V] in
+lemma mk_mem_possible {S : Finset V} {a b : D}
+    (ha : origin a ∈ S) (hb : origin b ∈ S) : s(a,b) ∈ possible origin S := by
+  exact Finset.mem_image.mpr ⟨(a,b),by simpa using And.intro ha hb,rfl⟩
+
+omit [Fintype V] in
+lemma possible_card (d : ℕ) (hd : ∀ v, Nat.card {e : D // origin e=v} ≤ d)
+    (S : Finset V) : (possible origin S).card ≤ (S.card*d)^2 := by
+  calc
+    _ ≤ ((ports origin S) ×ˢ (ports origin S)).card := Finset.card_image_le
+    _ = (ports origin S).card^2 := by rw [Finset.card_product]; ring
+    _ ≤ _ := Nat.pow_le_pow_left (card_ports_le origin d hd S) _
+
+variable {label : D → T} {bar : T → T}
+
+def closedNeighbors (r : Matching label bar) (S : Finset V) : Finset V :=
+  S ∪ (ports origin S).image (fun e => origin (r e))
+
+def incidentEdges (r : Matching label bar) (S : Finset V) : Finset (Sym2 D) :=
+  (ports origin S).image (fun e => s(e,r e))
+
+omit [Fintype V] in
+lemma incident_possible (r : Matching label bar) (S U : Finset V)
+    (hU : closedNeighbors origin r S ⊆ U) : incidentEdges origin r S ⊆ possible origin U := by
+  intro p hp
+  obtain ⟨e,he,rfl⟩ := Finset.mem_image.mp hp
+  have hs : origin e ∈ S := (mem_ports origin S e).mp he
+  apply mk_mem_possible origin
+  · exact hU (Finset.mem_union_left _ hs)
+  · exact hU (Finset.mem_union_right _ (Finset.mem_image_of_mem _ he))
+
+omit [Fintype V] in
+lemma contains_incident (r : Matching label bar) (S : Finset V) :
+    r.Contains (incidentEdges origin r S) := by
+  intro a b hab
+  obtain ⟨e,_,he⟩ := Finset.mem_image.mp hab
+  rcases Sym2.eq_iff.mp he with ⟨h1,h2⟩ | ⟨h1,h2⟩
+  · rw [← h1,← h2]
+  · rw [← h1,← h2,r.reverse_reverse]
+
+omit [Fintype V] in
+lemma twice_incident (r : Matching label bar) (S : Finset V) :
+    (ports origin S).card ≤ 2*(incidentEdges origin r S).card := by
+  apply Finset.card_le_mul_card_image
+  intro p hp
+  obtain ⟨e,_,rfl⟩ := Finset.mem_image.mp hp
+  have hsub : ((ports origin S).filter (fun a => s(a,r a)=s(e,r e))) ⊆ {e,r e} := by
+    intro a ha
+    have he := (Finset.mem_filter.mp ha).2
+    rcases Sym2.eq_iff.mp he with ⟨h,_⟩ | ⟨h,_⟩
+    · exact Finset.mem_insert.mpr (Or.inl h)
+    · exact Finset.mem_insert.mpr (Or.inr (Finset.mem_singleton.mpr h))
+  have hp : ({e,r e} : Finset D).card ≤ 2 := by
+    calc
+      _ ≤ ({r e} : Finset D).card+1 := Finset.card_insert_le _ _
+      _ = 2 := by simp
+  exact (Finset.card_le_card hsub).trans hp
+
+/-- The literal dense set forced by a failure of the required doubling.
+It keeps distinct matching prescriptions rather than counting occurrences. -/
+theorem dense_witness (r : Matching label bar) (k d₀ : ℕ)
+    (hd₀ : ∀ v, d₀ ≤ Nat.card {e : D // origin e=v})
+    (hk : 2*k ≤ Fintype.card V) (S : Finset V) (hS : S.card=k)
+    (hfail : (closedNeighbors origin r S).card ≤ 2*k) :
+    ∃ U : Finset V, U.card=2*k ∧
+      ∃ C : Finset (Sym2 D), C ⊆ possible origin U ∧
+        C.card=(d₀*k+1)/2 ∧ r.Contains C := by
+  obtain ⟨U,hU,hUc⟩ := Finset.exists_superset_card_eq hfail hk
+  have he : (d₀*k+1)/2 ≤ (incidentEdges origin r S).card := by
+    have h := (card_ports_ge origin d₀ hd₀ S).trans (twice_incident origin r S)
+    rw [hS,Nat.mul_comm k d₀] at h
+    omega
+  obtain ⟨C,hC,hCc⟩ := Finset.exists_subset_card_eq he
+  refine ⟨U,hUc,C,hC.trans (incident_possible origin r S U hU),hCc,?_⟩
+  intro a b hab
+  exact contains_incident origin r S a b (hC hab)
+
+/-- Union of all dense witnesses of a fixed vertex and prescription size. -/
+def denseEvent (N m t : ℕ) : Finset (Matching label bar) :=
+  (Finset.univ.powersetCard m).biUnion fun U =>
+    ((possible origin U).powersetCard t).biUnion fun C =>
+      Matching.conditioned (label := label) (bar := bar) origin N C
+
+/-- The exact finite union bound in the girth-conditioned space. The two
+binomial factors count sets, avoiding the spurious extra power of k that
+would arise if one counted ordered lists of edge prescriptions. -/
+theorem dense_count (N m t d R : ℕ) (hbar : ∀ t, bar t ≠ t) (h2 : 2≤d)
+    (hd : ∀ v, Nat.card {e : D // origin e=v} ≤ d)
+    (hR : ∀ x, R+t+4*d^(2*N+1) ≤ Nat.card {e : D // label e=label x}) :
+    (denseEvent (label := label) (bar := bar) origin N m t).card * R^t ≤
+      (Fintype.card V).choose m * ((m*d)^2).choose t *
+        (Matching.conditioned (label := label) (bar := bar) origin N ∅).card := by
+  let Ω := Matching.conditioned (label := label) (bar := bar) origin N ∅
+  let Us : Finset (Finset V) := Finset.univ.powersetCard m
+  have hU (U : Finset V) (hu : U∈Us) :
+      (((possible origin U).powersetCard t).biUnion fun C =>
+        Matching.conditioned (label := label) (bar := bar) origin N C).card * R^t ≤
+      ((m*d)^2).choose t * Ω.card := by
+    have hcU : U.card=m := (Finset.mem_powersetCard.mp hu).2
+    calc
+      _ ≤ (∑ C ∈ (possible origin U).powersetCard t,
+          (Matching.conditioned (label := label) (bar := bar) origin N C).card) * R^t :=
+        Nat.mul_le_mul_right _ Finset.card_biUnion_le
+      _ = ∑ C ∈ (possible origin U).powersetCard t,
+          (Matching.conditioned (label := label) (bar := bar) origin N C).card * R^t :=
+        Finset.sum_mul _ _ _
+      _ ≤ ∑ _C ∈ (possible origin U).powersetCard t, Ω.card := by
+        apply Finset.sum_le_sum
+        intro C hC
+        have hc : C.card=t := (Finset.mem_powersetCard.mp hC).2
+        have h := Matching.prescriptions_count (label := label) (bar := bar)
+          origin N hbar d h2 hd R C (by intro x; rw [hc]; exact hR x)
+        simpa only [hc] using h
+      _ = (possible origin U).card.choose t * Ω.card := by simp
+      _ ≤ ((m*d)^2).choose t * Ω.card := by
+        apply Nat.mul_le_mul_right
+        apply Nat.choose_le_choose
+        simpa only [hcU] using possible_card origin d hd U
+  calc
+    _ ≤ (∑ U ∈ Us, (((possible origin U).powersetCard t).biUnion fun C =>
+        Matching.conditioned (label := label) (bar := bar) origin N C).card) * R^t :=
+      Nat.mul_le_mul_right _ Finset.card_biUnion_le
+    _ = ∑ U ∈ Us, (((possible origin U).powersetCard t).biUnion fun C =>
+        Matching.conditioned (label := label) (bar := bar) origin N C).card * R^t :=
+      Finset.sum_mul _ _ _
+    _ ≤ ∑ _U ∈ Us, ((m*d)^2).choose t * Ω.card := Finset.sum_le_sum hU
+    _ = _ := by simp [Us,Ω,Nat.mul_assoc]
+
+/-- A failing set in an actual girth-conditioned sample occurs in the counted
+union. No labels, vertex names or repeated traversals have been discarded. -/
+theorem mem_dense_of_failure (N k d₀ : ℕ) (r : Matching label bar)
+    (hr : r∈Matching.conditioned (label := label) (bar := bar) origin N ∅)
+    (hd₀ : ∀ v, d₀ ≤ Nat.card {e : D // origin e=v})
+    (hk : 2*k ≤ Fintype.card V) (S : Finset V) (hS : S.card=k)
+    (hfail : (closedNeighbors origin r S).card ≤ 2*k) :
+    r∈denseEvent (label := label) (bar := bar) origin N (2*k) ((d₀*k+1)/2) := by
+  obtain ⟨U,hUc,C,hC,hCc,hrC⟩ := dense_witness origin r k d₀ hd₀ hk S hS hfail
+  apply Finset.mem_biUnion.mpr
+  refine ⟨U,Finset.mem_powersetCard.mpr ⟨Finset.subset_univ _,hUc⟩,?_⟩
+  apply Finset.mem_biUnion.mpr
+  refine ⟨C,Finset.mem_powersetCard.mpr ⟨hC,hCc⟩,?_⟩
+  simp only [Matching.conditioned,Finset.mem_filter,Finset.mem_univ,true_and] at hr ⊢
+  exact ⟨hrC,hr.2⟩
+
+end TorsionFreeZeroDivisors.DiameterCounting
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/GroupRing/RealizationTransport.lean b/lean/OAI/Algebra/GroupRing/RealizationTransport.lean
new file mode 100644
index 0000000000000000000000000000000000000000..af5ecb3d43d5aad9c09412d16e80f4e876cf5564
--- /dev/null
+++ b/lean/OAI/Algebra/GroupRing/RealizationTransport.lean
@@ -0,0 +1,420 @@
+import Mathlib
+import OAI.Algebra.GroupRing.GridUniform
+import OAI.Algebra.GroupRing.ChainActiveStages
+
+namespace OAI
+
+noncomputable section
+
+namespace TorsionFreeZeroDivisors.RealizationTransport
+open scoped Classical
+open PortSubdivision ConditionedMatchings PatternEmbeddings
+variable {PV PD TV T QV QD : Type*} [Fintype PV] [Fintype PD] [Fintype TV] [Fintype T]
+    [Fintype QV] [Fintype QD]
+variable {Γ : PortGraph PV PD} {plabel : PD → T} {outgoing : TV → Finset T}
+    {pin : PV → Option TV} {bar : T → T} {r : Matching (label outgoing) bar}
+    (e : Embedding Γ plabel outgoing pin bar r)
+
+/-- Restriction needs only injectivity, not a bijection onto the whole image.
+In particular, inactive marked vertices are never carried into a stage. -/
+def restrict (Q : PortGraph QV QD) (fv : QV ↪ PV) (fd : QD ↪ PD)
+    (ho : ∀ d,fv (Q.origin d)=Γ.origin (fd d))
+    (hr : ∀ d,fd (Q.reverse d)=Γ.reverse (fd d)) (pin' : QV → Option TV)
+    (hp : ∀ v y,pin' v=some y → pin (fv v)=some y) :
+    Embedding Q (plabel ∘ fd) outgoing pin' bar r where
+  vertex := fv.trans e.vertex
+  port := fd.trans e.port
+  origin_eq d := by simpa only [Function.Embedding.trans_apply,ho] using e.origin_eq (fd d)
+  label_eq d := e.label_eq (fd d)
+  reverse_eq d := by simpa only [Function.Embedding.trans_apply,hr] using e.reverse_eq (fd d)
+  pin_eq v y hy := e.pin_eq (fv v) y (hp v y hy)
+
+/-- Change the displayed port labeling by a literal pointwise equality. -/
+def congrLabel (label' : PD → T) (hl : ∀ d,label' d=plabel d) :
+    Embedding Γ label' outgoing pin bar r where
+  vertex := e.vertex
+  port := e.port
+  origin_eq := e.origin_eq
+  label_eq d := (e.label_eq d).trans (hl d).symm
+  reverse_eq := e.reverse_eq
+  pin_eq := e.pin_eq
+
+end TorsionFreeZeroDivisors.RealizationTransport
+
+namespace TorsionFreeZeroDivisors.ActualStageRealization
+open scoped Classical
+open Function PortSubdivision ChainSuppression DegreeTwoSuppression SuppressedMoore ChainPaths
+open ChainIsomorphism ChainChunkTransport ChainMultiplicity ChunkComparisons FiniteChunking
+open StageSubgraphs
+variable {V D : Type*} [Fintype D] (Γ : PortGraph V D)
+    (mark : V → Prop) (h2 : ∀ v, ¬mark v → (out Γ.origin v).card=2)
+    {P : Type*} [Fintype P] (paths : P → List {d : D // turn Γ.origin mark h2 d=d}) (j : ℕ)
+local notation "S" => suppressed Γ mark h2
+local notation "len" => ChainStageEmbedding.length Γ mark h2 paths j
+local notation "Q" => ChainStageEmbedding.graph Γ mark h2 paths j
+local notation "F" => next Γ.reverse (turn Γ.origin mark h2)
+
+/-- The actual signed labels, at every position of every active chain. -/
+def word (label : D → Types.Letter) : ComparedBlocks.Position len → WordEstimate.Letter :=
+  fun x => Types.signedLetter.symm (label (F^[x.2.val.toNat] x.1.val.val.val))
+
+lemma index_mem (c : ChainActiveStages.ActiveChain Γ mark h2 paths j) (i : Fin (len c)) :
+    (i.val:ℤ)∈BlockAlignment.positions 0 (len c) := by
+  rw [AffineIntervals.nat_positions]
+  simp only [Finset.mem_Ico]
+  constructor
+  · omega
+  · exact_mod_cast i.isLt
+
+lemma label_eq (label : D → Types.Letter) (hl : ∀ d,label (Γ.reverse d)=Types.inverse (label d))
+    (d : ChainSubdivision.Dart len) :
+    ChainRealization.label len (StageExpectation.readWord len (word Γ mark h2 paths j label)) d =
+      label (ChainStageEmbedding.dartMap Γ mark h2 paths j d) := by
+  rcases d with ⟨⟨c,i⟩,b⟩
+  have hi := index_mem Γ mark h2 paths j c i
+  cases b <;>
+    simp only [ChainRealization.label,Bool.false_eq_true,ite_false,ite_true,StageExpectation.readWord,
+      dite_eq_left hi,word,Int.toNat_natCast,Types.signedLetter.apply_symm_apply,
+      ChainStageEmbedding.dartMap,Function.comp_apply,SubdivisionRestriction.dart,ChainIsomorphism.dartMap,hl]
+
+variable [Fintype V] {TV : Type} [Fintype TV]
+    {outgoing : TV → Finset Types.Letter} {pin : V → Option TV}
+    {r : ConditionedMatchings.Matching (PatternEmbeddings.label outgoing) Types.inverse}
+
+/-- An actual sampled graph embedding yields the exact stage realization
+counted by the conditional-matching first moment. -/
+def embedding (label : D → Types.Letter)
+    (hl : ∀ d,label (Γ.reverse d)=Types.inverse (label d))
+    (e : RealizationTransport.Embedding Γ label outgoing pin Types.inverse r)
+    (pin' : StageSubgraphs.ActiveV (S) (ListStageExponents.mult (S) paths) j → Option TV)
+    (hp : ∀ v y,pin' v=some y → pin v.val=some y) :
+    RealizationTransport.Embedding (Q)
+      (ChainRealization.label len (StageExpectation.readWord len (word Γ mark h2 paths j label)))
+      outgoing (ChainRealization.pin len pin') Types.inverse r := by
+  let fv : ChainSubdivision.Vertex len ↪ V :=
+    ⟨ChainStageEmbedding.vertexMap Γ mark h2 paths j,ChainStageEmbedding.vertexMap_injective Γ mark h2 paths j⟩
+  let fd : ChainSubdivision.Dart len ↪ D :=
+    ⟨ChainStageEmbedding.dartMap Γ mark h2 paths j,ChainStageEmbedding.dartMap_injective Γ mark h2 paths j⟩
+  have hp' : ∀ v y,ChainRealization.pin len pin' v=some y → pin (fv v)=some y := by
+    intro v y hy
+    cases v with
+    | inl v => exact hp v y hy
+    | inr v => cases hy
+  exact RealizationTransport.congrLabel (RealizationTransport.restrict e (Q) fv fd
+    (ChainStageEmbedding.origin_map Γ mark h2 paths j)
+    (ChainStageEmbedding.reverse_map Γ mark h2 paths j) _ hp') _
+      (label_eq Γ mark h2 paths j label hl)
+
+end TorsionFreeZeroDivisors.ActualStageRealization
+
+namespace TorsionFreeZeroDivisors.ActualStageFeasibility
+open scoped Classical BigOperators
+open Function PortSubdivision ChainSuppression DegreeTwoSuppression SuppressedMoore ChainPaths
+open ChainIsomorphism ChainChunkTransport ChainMultiplicity ChunkComparisons FiniteChunking
+open BlockAlignment ComparedBlocks RepeatedBlocks WordEstimate
+
+lemma signed_inverse (t : Types.Letter) :
+    Types.signedLetter.symm (Types.inverse t)=inverse (Types.signedLetter.symm t) := by
+  simp [Types.inverse,inverse]
+
+lemma signed_choice (b : Bool) (t : Types.Letter) :
+    Types.signedLetter.symm (if b then Types.inverse t else t)=
+      if b then inverse (Types.signedLetter.symm t) else Types.signedLetter.symm t := by
+  cases b <;> simp only [Bool.false_eq_true,ite_false,ite_true,signed_inverse]
+
+lemma weight_pos {t u : Letter} (h : u≠inverse t) : 0 < weight t u := by
+  unfold weight baseWeight p
+  simp only [ite_eq_right h]
+  split_ifs <;> norm_num
+
+variable {C : Type*} [Fintype C] (s : ℝ) (len : C → ℕ)
+
+omit [Fintype C] in
+lemma block_weight_pos (w : C → ℤ → Letter) (hw : ActualStageLabels.Immersed s len w)
+    (i : Underlying s len) : 0 < wordWeight (height s len i) (RepeatedBlocks.word s len w i) := by
+  rw [ChainWeights.wordWeight_pred]
+  apply Finset.prod_pos
+  intro k _
+  apply weight_pos
+  have hq := (ChainWeights.firstCoordinate s len i k).property
+  have hq' := (ChainWeights.nextCoordinate s len i k).property
+  simp only [ChainWeights.firstCoordinate_val,block_interval,Finset.mem_Ico] at hq
+  simp only [ChainWeights.nextCoordinate_val,block_interval,Finset.mem_Ico] at hq'
+  have hh := hw i ((k.val:ℤ)+lower s len i) hq.1 (by omega)
+  simpa only [RepeatedBlocks.word,Nat.cast_add,Nat.cast_one,add_assoc,add_comm,add_left_comm] using hh
+
+def bins (w : C → ℤ → Letter) (i : Underlying s len) : ℤ :=
+  ⌊-Real.log (wordWeight (height s len i) (RepeatedBlocks.word s len w i))⌋
+
+omit [Fintype C] in
+lemma mem_bin (w : C → ℤ → Letter) (hw : ActualStageLabels.Immersed s len w)
+    (i : Underlying s len) : RepeatedBlocks.word s len w i ∈ binWords (height s len i) (bins s len w i) := by
+  apply Finset.mem_filter.mpr
+  exact ⟨Finset.mem_univ _,block_weight_pos s len w hw i,rfl⟩
+
+lemma fullWords_of_comparing {E : Type*} (m : C → ℕ)
+    (cmp : Comparisons (E:=E) (RepeatedBlocks.traversalLength len m))
+    (j : ℕ) (w : C → ℤ → Letter) (hw : ActualStageLabels.Comparing len m cmp w)
+    (hr : ActualStageLabels.Immersed s len w) :
+    (fun x : ChainStageLabels.StagePosition len m j => w x.1.val x.2.val) ∈
+      ChainStageLabels.fullWords s len m j cmp (bins s len w) := by
+  apply Finset.mem_filter.mpr
+  exact ⟨Finset.mem_univ _,w,hw,hr,mem_bin s len w hr,rfl⟩
+
+variable {V D : Type*} [Fintype D] (Γ : PortGraph V D)
+    (mark : V → Prop) (h2 : ∀ v, ¬mark v → (out Γ.origin v).card=2)
+    {P : Type*} [Fintype P] (paths : P → List {d : D // turn Γ.origin mark h2 d=d})
+local notation "R" => ChainIsomorphism.Rep Γ mark h2
+local notation "F" => next Γ.reverse (turn Γ.origin mark h2)
+local notation "lenR" => repLength Γ mark h2
+local notation "m" => ChunkComparisons.multiplicity (ChainChunkTransport.color Γ mark h2 paths)
+
+def globalWord (label : D → Types.Letter) (c : R) (q : ℤ) : Letter :=
+  Types.signedLetter.symm (label (F^[q.toNat] c.val.val))
+
+lemma immersed (hs : 0<s) (label : D → Types.Letter)
+    (hl : ∀ d,label (Γ.reverse d)=Types.inverse (label d))
+    (hinj : ∀ d e,Γ.origin d=Γ.origin e → label d=label e → d=e) :
+    ActualStageLabels.Immersed s (lenR) (globalWord Γ mark h2 label) := by
+  intro i q hq hq'
+  have hb : q∈block s i.2.val := by rw [block_interval s (lenR) i]; simp only [Finset.mem_Ico]; omega
+  have hb' : q+1∈block s i.2.val := by rw [block_interval s (lenR) i]; simp only [Finset.mem_Ico]; omega
+  have ht := full_subset s hs (lenR i.1) i.2 hb
+  have ht' := full_subset s hs (lenR i.1) i.2 hb'
+  rw [AffineIntervals.nat_positions,Finset.mem_Ico] at ht ht'
+  have hn := normalized_immersed Γ mark h2 Types.inverse label hl hinj i.1 q ht.1 ht'.2
+  intro he
+  apply hn
+  apply Types.signedLetter.symm.injective
+  rw [signed_inverse]
+  exact he
+
+variable {E : Type*}
+    (cmp : Comparisons (E:=E) (pathLength (chunks Γ mark h2 paths) (chunkLength Γ mark h2 paths)))
+    (lo hi : E → ℤ) (hlo : ∀ e,cmp.lo e=(lo e:ℝ)) (hhi : ∀ e,cmp.hi e=(hi e:ℝ))
+
+lemma comparing (label : D → Types.Letter)
+    (hl : ∀ d,label (Γ.reverse d)=Types.inverse (label d))
+    (hc : ∀ x e,cmp.side x=some e → label (originalDart Γ mark h2 paths x)=
+      if cmp.reverse e then Types.inverse (label (originalDart Γ mark h2 paths (cmp.pairing.partner x)))
+      else label (originalDart Γ mark h2 paths (cmp.pairing.partner x))) :
+    ActualStageLabels.Comparing (lenR) (m)
+      ((repeatedChunks Γ mark h2 paths).comparisons cmp lo hi hlo hhi) (globalWord Γ mark h2 label) := by
+  intro x a ha
+  have hh := normalized_compatible Γ mark h2 paths cmp lo hi hlo hhi Types.inverse
+    Types.inverse_inverse label hl hc x a ha
+  apply_fun Types.signedLetter.symm at hh
+  rw [signed_choice] at hh
+  have hp : ((repeatedChunks Γ mark h2 paths).comparisons cmp lo hi hlo hhi).pairing=
+      (repeatedChunks Γ mark h2 paths).pairing cmp := rfl
+  rw [hp]
+  exact hh
+
+lemma feasible (hs : 0<s) (label : D → Types.Letter)
+    (hl : ∀ d,label (Γ.reverse d)=Types.inverse (label d))
+    (hinj : ∀ d e,Γ.origin d=Γ.origin e → label d=label e → d=e)
+    (hc : ∀ x e,cmp.side x=some e → label (originalDart Γ mark h2 paths x)=
+      if cmp.reverse e then Types.inverse (label (originalDart Γ mark h2 paths (cmp.pairing.partner x)))
+      else label (originalDart Γ mark h2 paths (cmp.pairing.partner x))) :
+    ActualStageLabels.Feasible s (lenR) (m)
+      ((repeatedChunks Γ mark h2 paths).comparisons cmp lo hi hlo hhi)
+      (bins s (lenR) (globalWord Γ mark h2 label))
+      (RepeatedBlocks.word s (lenR) (globalWord Γ mark h2 label)) := by
+  have hr := immersed s Γ mark h2 hs label hl hinj
+  exact ⟨mem_bin s (lenR) _ hr,_,comparing Γ mark h2 paths cmp lo hi hlo hhi label hl hc,hr,rfl⟩
+
+lemma fullWords_mem (hs : 0<s) (j : ℕ) (label : D → Types.Letter)
+    (hl : ∀ d,label (Γ.reverse d)=Types.inverse (label d))
+    (hinj : ∀ d e,Γ.origin d=Γ.origin e → label d=label e → d=e)
+    (hc : ∀ x e,cmp.side x=some e → label (originalDart Γ mark h2 paths x)=
+      if cmp.reverse e then Types.inverse (label (originalDart Γ mark h2 paths (cmp.pairing.partner x)))
+      else label (originalDart Γ mark h2 paths (cmp.pairing.partner x))) :
+    (fun x : ChainStageLabels.StagePosition (lenR) (m) j => globalWord Γ mark h2 label x.1.val x.2.val) ∈
+      ChainStageLabels.fullWords s (lenR) (m) j
+        ((repeatedChunks Γ mark h2 paths).comparisons cmp lo hi hlo hhi)
+        (bins s (lenR) (globalWord Γ mark h2 label)) := by
+  exact fullWords_of_comparing s (lenR) (m) _ j _
+    (comparing Γ mark h2 paths cmp lo hi hlo hhi label hl hc)
+    (immersed s Γ mark h2 hs label hl hinj)
+
+end TorsionFreeZeroDivisors.ActualStageFeasibility
+
+namespace TorsionFreeZeroDivisors.StagePartition
+open scoped Classical BigOperators
+open RepeatedBlocks BlockAlignment ComparedBlocks ChainStageLabels WordEstimate
+local instance : DecidableEq Types.Letter := Classical.decEq _
+variable {C E VA VB TA TB : Type} [Fintype C] [Fintype VA] [Fintype VB]
+  [Fintype TA] [Fintype TB]
+variable (s : ℝ) (hs : 0<s) (len m : C → ℕ) (side : C → Bool) (j : ℕ)
+
+abbrev CA := {a : C // j < m a ∧ side a=true}
+abbrev CB := {b : C // j < m b ∧ side b=false}
+abbrev lenA : CA m side j → ℕ := fun a => len a.val
+abbrev lenB : CB m side j → ℕ := fun b => len b.val
+
+def restrictA (F : StagePosition len m j → Letter) : Position (lenA len m side j) → Letter :=
+  fun x => F ⟨⟨x.1.val,x.1.property.1⟩,x.2⟩
+def restrictB (F : StagePosition len m j → Letter) : Position (lenB len m side j) → Letter :=
+  fun x => F ⟨⟨x.1.val,x.1.property.1⟩,x.2⟩
+
+def indexA (i : Underlying s (lenA len m side j)) : Underlying s len := ⟨i.1.val,i.2⟩
+def indexB (i : Underlying s (lenB len m side j)) : Underlying s len := ⟨i.1.val,i.2⟩
+
+include hs in
+theorem binsA (cmp : Comparisons (E := E) (traversalLength len m))
+    (d : Underlying s len → ℤ) (F : StagePosition len m j → Letter)
+    (hF : F ∈ fullWords s len m j cmp d) :
+    ∀ i, word s (lenA len m side j) (StageExpectation.readWord (lenA len m side j)
+      (restrictA len m side j F)) i ∈ binWords (height s (lenA len m side j) i) (d (indexA s len m side j i)) := by
+  obtain ⟨w,_,_,hb,rfl⟩ := (Finset.mem_filter.mp hF).2
+  intro i
+  have he : word s (lenA len m side j) (StageExpectation.readWord (lenA len m side j)
+      (restrictA len m side j (fun x => w x.1.val x.2.val))) i =
+      word s len w (indexA s len m side j i) := by
+    funext k
+    dsimp only [word,StageExpectation.readWord]
+    rw [dite_eq_left (StageExpectation.word_position s hs (lenA len m side j) i k)]
+    rfl
+  rw [he]
+  exact hb (indexA s len m side j i)
+
+include hs in
+theorem binsB (cmp : Comparisons (E := E) (traversalLength len m))
+    (d : Underlying s len → ℤ) (F : StagePosition len m j → Letter)
+    (hF : F ∈ fullWords s len m j cmp d) :
+    ∀ i, word s (lenB len m side j) (StageExpectation.readWord (lenB len m side j)
+      (restrictB len m side j F)) i ∈ binWords (height s (lenB len m side j) i) (d (indexB s len m side j i)) := by
+  obtain ⟨w,_,_,hb,rfl⟩ := (Finset.mem_filter.mp hF).2
+  intro i
+  have he : word s (lenB len m side j) (StageExpectation.readWord (lenB len m side j)
+      (restrictB len m side j (fun x => w x.1.val x.2.val))) i =
+      word s len w (indexB s len m side j i) := by
+    funext k
+    dsimp only [word,StageExpectation.readWord]
+    rw [dite_eq_left (StageExpectation.word_position s hs (lenB len m side j) i k)]
+    rfl
+  rw [he]
+  exact hb (indexB s len m side j i)
+
+def joinBlock : Underlying s (lenA len m side j) ⊕ Underlying s (lenB len m side j) →
+    Underlying s (StageExpectation.activeLen len m j)
+  | .inl i => ⟨⟨i.1.val,i.1.property.1⟩,i.2⟩
+  | .inr i => ⟨⟨i.1.val,i.1.property.1⟩,i.2⟩
+
+omit [Fintype C] in
+theorem joinBlock_bijective : Function.Bijective (joinBlock s len m side j) := by
+  constructor
+  · intro x y he
+    cases x with
+    | inl x =>
+      cases y with
+      | inl y =>
+        rcases x with ⟨⟨a,ha⟩,ix⟩
+        rcases y with ⟨⟨b,hb⟩,iy⟩
+        have hab : a=b := congrArg (fun z => z.1.val) he
+        subst b
+        have hii : ix=iy := Fin.ext (congrArg (fun z => z.2.val) he)
+        subst iy
+        rfl
+      | inr y =>
+        have h := congrArg (fun z => side z.1.val) he
+        change side x.1.val=side y.1.val at h
+        rw [x.1.property.2,y.1.property.2] at h
+        cases h
+    | inr x =>
+      cases y with
+      | inl y =>
+        have h := congrArg (fun z => side z.1.val) he
+        change side x.1.val=side y.1.val at h
+        rw [x.1.property.2,y.1.property.2] at h
+        cases h
+      | inr y =>
+        rcases x with ⟨⟨a,ha⟩,ix⟩
+        rcases y with ⟨⟨b,hb⟩,iy⟩
+        have hab : a=b := congrArg (fun z => z.1.val) he
+        subst b
+        have hii : ix=iy := Fin.ext (congrArg (fun z => z.2.val) he)
+        subst iy
+        rfl
+  · rintro ⟨⟨c,hc⟩,b⟩
+    cases hh : side c with
+    | true => exact ⟨.inl ⟨⟨c,hc,hh⟩,b⟩,rfl⟩
+    | false => exact ⟨.inr ⟨⟨c,hc,hh⟩,b⟩,rfl⟩
+
+def blockEquiv := Equiv.ofBijective (joinBlock s len m side j) (joinBlock_bijective s len m side j)
+
+theorem bin_sum (d : Underlying s len → ℤ) :
+    (∑ i, (d (indexA s len m side j i) : ℝ)) + (∑ i, (d (indexB s len m side j i) : ℝ)) =
+      ∑ i ∈ activeBlocks s len m j, (d i : ℝ) := by
+  rw [← StageExpectation.active_bin_sum s len m j d]
+  calc
+    _ = ∑ i : Underlying s (lenA len m side j) ⊕ Underlying s (lenB len m side j),
+        (d (StageExpectation.activeIndex s len m j (joinBlock s len m side j i)) : ℝ) := by
+      rw [Fintype.sum_sum_type]
+      rfl
+    _ = _ := Fintype.sum_equiv (blockEquiv s len m side j) _ _ (fun _ => rfl)
+
+variable (firstA lastA : CA m side j → VA) (firstB lastB : CB m side j → VB)
+  (outA : TA → Finset Types.Letter) (outB : TB → Finset Types.Letter)
+  (pinA : VA → Option TA) (pinB : VB → Option TB)
+
+def sideA : TwoSideStage.Side where
+  C := CA m side j; V := VA; TV := TA
+  fC := inferInstance; fV := inferInstance; fTV := inferInstance
+  len := lenA len m side j
+  first := firstA; last := lastA; outgoing := outA; pin := pinA
+
+def sideB : TwoSideStage.Side where
+  C := CB m side j; V := VB; TV := TB
+  fC := inferInstance; fV := inferInstance; fTV := inferInstance
+  len := lenB len m side j
+  first := firstB; last := lastB; outgoing := outB; pin := pinB
+
+local notation "SA" => sideA len m side j firstA lastA outA pinA
+local notation "SB" => sideB len m side j firstB lastB outB pinB
+
+theorem exponential_fusion (u v k x y z : ℝ) (hz : x+y=z) :
+    Real.exp (u+v)*(k*Real.exp (-x-y)) = k*Real.exp (u-z+v) := by
+  rw [← hz]
+  simp only [sub_eq_add_neg,Real.exp_add,Real.exp_neg]
+  ring
+
+include hs in
+/-- The joint matching expectation applied to the actual fullWords projection,
+including cross-side comparisons. All entropy and bin costs are computed on
+that one global pattern. -/
+theorem mean_bound (cmp : Comparisons (E := E) (traversalLength len m))
+    (d : Underlying s len → ℤ) (err : ℕ)
+    (hlarge : ∀ i, 3002 ≤ height s len i)
+    (hscale : ∀ i, s+1200 ≤ 2*(height s len i : ℝ))
+    (hreduced : ∀ x e, cmp.side x = some e →
+      (x.1.1,x.2.val) ≠ ((cmp.pairing.partner x).1.1,(cmp.pairing.partner x).2.val))
+    (n p : ℝ) (N D R : ℕ) (hA : TwoSideStage.Conditions SA n p N D R)
+    (hB : TwoSideStage.Conditions SB n p N D R) :
+    TwoSideMean.mean (((SA).samples N) ×ˢ ((SB).samples N))
+      (TwoSideStage.count SA SB (fullWords s len m j cmp d)
+        (restrictA len m side j) (restrictB len m side j)) ≤
+      ((SA).cost n p R * (SB).cost n p R) *
+        Real.exp ((∑ c : StageLabels.activeComponents
+          (ActualStageLabels.L s hs len m cmp err).graph.connectedComponentMk (activeBlocks s len m j),
+          ActualStageLabels.cost s hs len m cmp err d c.val) -
+          (∑ i ∈ activeBlocks s len m j, (d i : ℝ)) +
+          (2*(err : ℝ)*Fintype.card (Underlying s len)+(s+1)*Fintype.card C)*
+            Real.log (Fintype.card Letter)) := by
+  have h := TwoSideStage.mean_bound s hs SA SB (fullWords s len m j cmp d)
+    (restrictA len m side j) (restrictB len m side j) n p N D R hA hB
+    (fun i => d (indexA s len m side j i)) (fun i => d (indexB s len m side j i))
+    (binsA s hs len m side j cmp d) (binsB s hs len m side j cmp d)
+  have hc := full_stage_count s hs len m j cmp d err hlarge hscale hreduced
+  have hn : 0 ≤ n := (Nat.cast_nonneg (Fintype.card TA)).trans hA.vertices
+  have hp := hA.nonneg
+  have hcost : 0 ≤ (SA).cost n p R * (SB).cost n p R := by unfold TwoSideStage.Side.cost; positivity
+  have h' := h.trans (mul_le_mul_of_nonneg_right hc
+    (mul_nonneg hcost (Real.exp_pos _).le))
+  exact h'.trans_eq (exponential_fusion _ _ _ _ _ _ (bin_sum s len m side j d))
+
+end TorsionFreeZeroDivisors.StagePartition
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/GroupRing/RelationArea.lean b/lean/OAI/Algebra/GroupRing/RelationArea.lean
new file mode 100644
index 0000000000000000000000000000000000000000..d75f78ce1001755a9eaf5c236b339cacff074dc2
--- /dev/null
+++ b/lean/OAI/Algebra/GroupRing/RelationArea.lean
@@ -0,0 +1,134 @@
+import Mathlib
+import OAI.Algebra.GroupRing.CellModule
+import OAI.Algebra.GroupRing.ContiguousSplit
+
+namespace OAI
+
+
+
+section
+namespace TorsionFreeZeroDivisors.RelationArea
+open scoped Classical BigOperators
+open AlgebraicPictures CellModule
+noncomputable section
+variable {A I : Type} (rel : I→List (A×Bool))
+abbrev G := PresentedGroup (relations rel)
+abbrev N := Subgroup.normalClosure (relations rel)
+abbrev q : FreeGroup A→*G rel := PresentedGroup.mk (relations rel)
+def term (t : Term (A:=A) (I:=I)) : CellModule.Module (G rel) I :=
+  if t.positive then Finsupp.single (q rel (FreeGroup.mk t.connector),t.index) 1
+  else -Finsupp.single (q rel (FreeGroup.mk t.connector),t.index) 1
+def total (ts : List (Term (A:=A) (I:=I))) : CellModule.Module (G rel) I := (ts.map (term rel)).sum
+lemma total_append (s t : List (Term (A:=A) (I:=I))) : total rel (s++t)=total rel s+total rel t := by
+  simp only [total,List.map_append,List.sum_append]
+lemma total_reverse_flip (s : List (Term (A:=A) (I:=I))) : total rel (s.reverse.map Term.flip)= -total rel s := by
+  have hf (t : Term (A:=A) (I:=I)) : term rel t.flip= -term rel t := by
+    obtain ⟨i,b,c⟩ := t
+    cases b <;> simp [term,Term.flip]
+  simp only [total,List.map_map,Function.comp_def,hf,List.map_reverse,List.sum_reverse,List.sum_neg]
+variable (hz : ∀ts : List (Term (A:=A) (I:=I)),FreeGroup.mk (word rel ts)=1→total rel ts=0)
+include hz in
+lemma total_eq {s t : List (Term (A:=A) (I:=I))}
+    (hst : FreeGroup.mk (word rel s)=FreeGroup.mk (word rel t)) : total rel s=total rel t := by
+  have hword : FreeGroup.mk (word rel (s++t.reverse.map Term.flip))=1 := by
+    rw [word_append,word_reverse_flip,←FreeGroup.mul_mk,←FreeGroup.inv_mk,hst,mul_inv_cancel]
+  have h := hz _ hword
+  rw [total_append,total_reverse_flip] at h
+  exact eq_of_sub_eq_zero (by simpa only [sub_eq_add_neg] using h)
+
+def area (x : N rel) : CellModule.Module (G rel) I := total rel (Classical.choose (expansion rel x.property))
+include hz in
+lemma area_eq (x : N rel) (ts : List (Term (A:=A) (I:=I)))
+    (hts : FreeGroup.mk (word rel ts)=x.val) : area rel x=total rel ts := by
+  exact total_eq rel hz ((Classical.choose_spec (expansion rel x.property)).trans hts.symm)
+include hz in
+lemma area_mul (x y : N rel) : area rel (x*y)=area rel x+area rel y := by
+  obtain ⟨s,hs⟩ := expansion rel x.property
+  obtain ⟨t,ht⟩ := expansion rel y.property
+  rw [area_eq rel hz x s hs,area_eq rel hz y t ht,area_eq rel hz (x*y) (s++t) (by
+    rw [word_append,←FreeGroup.mul_mk,hs,ht];rfl),total_append]
+include hz in
+lemma area_one : area rel 1=0 := by
+  exact (area_eq rel hz 1 [] rfl).trans rfl
+
+def conjugate (w : FreeGroup A) (x : N rel) : N rel :=
+  ⟨w*x.val*w⁻¹,(Subgroup.normalClosure_normal (s:=relations rel)).conj_mem _ x.property w⟩
+def move (w : FreeGroup A) (t : Term (A:=A) (I:=I)) : Term (A:=A) (I:=I) :=
+  ⟨t.index,t.positive,w.toWord++t.connector⟩
+lemma move_mk (w : FreeGroup A) (t : Term (A:=A) (I:=I)) :
+    FreeGroup.mk ((move w t).word rel)=w*FreeGroup.mk (t.word rel)*w⁻¹ := by
+  simp only [move,Term.word,Term.core,←FreeGroup.mul_mk,←FreeGroup.inv_mk,FreeGroup.mk_toWord,mul_inv_rev]
+  group
+  rfl
+lemma move_word (w : FreeGroup A) (ts : List (Term (A:=A) (I:=I))) :
+    FreeGroup.mk (word rel (ts.map (move w)))=w*FreeGroup.mk (word rel ts)*w⁻¹ := by
+  induction ts with
+  | nil=>change (1 : FreeGroup A)=w*1*w⁻¹; simp
+  | cons t ts ih=>
+    change FreeGroup.mk ((move w t).word rel++word rel (ts.map (move w)))=
+      w*FreeGroup.mk (t.word rel++word rel ts)*w⁻¹
+    rw [←FreeGroup.mul_mk,move_mk,ih,←FreeGroup.mul_mk]
+    group
+lemma move_term (w : FreeGroup A) (t : Term (A:=A) (I:=I)) :
+    term rel (move w t)=translate (q rel w) (term rel t) := by
+  simp only [term,move,←FreeGroup.mul_mk,FreeGroup.mk_toWord,map_mul]
+  split <;> simp only [translate_single,map_neg]
+lemma move_total (w : FreeGroup A) (ts : List (Term (A:=A) (I:=I))) :
+    total rel (ts.map (move w))=translate (q rel w) (total rel ts) := by
+  simp only [total,List.map_map,Function.comp_def,move_term,map_list_sum]
+include hz in
+lemma area_conjugate (w : FreeGroup A) (x : N rel) :
+    area rel (conjugate rel w x)=translate (q rel w) (area rel x) := by
+  obtain ⟨s,hs⟩ := expansion rel x.property
+  rw [area_eq rel hz x s hs,area_eq rel hz (conjugate rel w x) (s.map (move w)) (by
+    rw [move_word,hs];rfl),move_total]
+
+def d₂ : CellModule.Module (G rel) I→+CellModule.Module (G rel) A :=
+  Finsupp.liftAddHom (fun p=>zmultiplesHom _ (translate p.1 (fox (q rel) (FreeGroup.mk (rel p.2)))))
+@[simp] lemma d₂_single (p : G rel×I) (z : ℤ) :
+    d₂ rel (Finsupp.single p z)=z • translate p.1 (fox (q rel) (FreeGroup.mk (rel p.2))) := by
+  simp [d₂]
+lemma d₂_translate (g : G rel) (x : CellModule.Module (G rel) I) :
+    d₂ rel (translate g x)=translate g (d₂ rel x) := by
+  induction x using Finsupp.induction_linear with
+  | zero=>simp
+  | add a b ha hb=>simp only [map_add,ha,hb]
+  | single p z=>simp only [translate_single,d₂_single,map_zsmul,translate_mul]
+lemma q_rel (i : I) : q rel (FreeGroup.mk (rel i))=1 := PresentedGroup.one_of_mem ⟨i,rfl⟩
+lemma q_word (ts : List (Term (A:=A) (I:=I))) : q rel (FreeGroup.mk (word rel ts))=1 :=
+  PresentedGroup.mk_eq_one_iff.mpr (word_mem rel ts)
+lemma fox_conjugate (w r : FreeGroup A) (hr : q rel r=1) :
+    fox (q rel) (w*r*w⁻¹)=translate (q rel w) (fox (q rel) r) := by
+  rw [fox_mul,fox_mul,fox_inv,map_mul,hr,mul_one,map_neg,←translate_mul,mul_inv_cancel,translate_one]
+  abel
+lemma d₂_term (t : Term (A:=A) (I:=I)) : d₂ rel (term rel t)=fox (q rel) (FreeGroup.mk (t.word rel)) := by
+  have hc : q rel (FreeGroup.mk (t.core rel))=1 := by
+    cases hb : t.positive <;> simp only [Term.core,hb,Bool.false_eq_true,ite_false,ite_true,←FreeGroup.inv_mk,map_inv,q_rel,inv_one]
+  rw [Term.word,←FreeGroup.mul_mk,←FreeGroup.mul_mk,←FreeGroup.inv_mk,fox_conjugate rel _ _ hc]
+  cases hb : t.positive <;>
+    simp only [term,Term.core,hb,Bool.false_eq_true,ite_false,ite_true,map_neg,d₂_single,one_zsmul,←FreeGroup.inv_mk,fox_inv,q_rel,inv_one,translate_one,map_neg]
+lemma d₂_total (ts : List (Term (A:=A) (I:=I))) :
+    d₂ rel (total rel ts)=fox (q rel) (FreeGroup.mk (word rel ts)) := by
+  induction ts with
+  | nil=>rfl
+  | cons t ts ih=>
+    change d₂ rel (term rel t+total rel ts)=fox (q rel) (FreeGroup.mk (t.word rel++word rel ts))
+    rw [map_add,d₂_term,ih,←FreeGroup.mul_mk,fox_mul]
+    have ht : q rel (FreeGroup.mk (t.word rel))=1 := by
+      exact PresentedGroup.mk_eq_one_iff.mpr (term_mem rel t)
+    rw [ht,translate_one]
+lemma d₂_area (x : N rel) : d₂ rel (area rel x)=fox (q rel) x.val := by
+  rw [area,d₂_total,Classical.choose_spec (expansion rel x.property)]
+lemma boundary_d₂ (x : CellModule.Module (G rel) I) : boundary (q rel) (d₂ rel x)=0 := by
+  induction x using Finsupp.induction_linear with
+  | zero=>simp
+  | add a b ha hb=>simp only [map_add,ha,hb,add_zero]
+  | single p z=>rw [d₂_single,map_zsmul,boundary_translate,boundary_fox,q_rel,sub_self,map_zero,zsmul_zero]
+end
+end TorsionFreeZeroDivisors.RelationArea
+
+
+end
+
+
+end OAI
diff --git a/lean/OAI/Algebra/GroupRing/RelationSplit.lean b/lean/OAI/Algebra/GroupRing/RelationSplit.lean
new file mode 100644
index 0000000000000000000000000000000000000000..2b9fc540860af3b722d3fa2fce4ed3605f4134d1
--- /dev/null
+++ b/lean/OAI/Algebra/GroupRing/RelationSplit.lean
@@ -0,0 +1,92 @@
+import Mathlib
+import OAI.Algebra.GroupRing.RelationArea
+
+namespace OAI
+
+
+
+section
+namespace TorsionFreeZeroDivisors.RelationSplit
+open scoped Classical BigOperators
+open AlgebraicPictures CellModule RelationArea
+noncomputable section
+variable {A I : Type} (rel : I→List (A×Bool))
+variable (hz : ∀ts : List (Term (A:=A) (I:=I)),FreeGroup.mk (word rel ts)=1→total rel ts=0)
+def sectionWord (g : G rel) : FreeGroup A := Classical.choose (PresentedGroup.mk_surjective (relations rel) g)
+lemma sectionWord_q (g : G rel) : q rel (sectionWord rel g)=g :=
+  Classical.choose_spec (PresentedGroup.mk_surjective (relations rel) g)
+def loop (g : G rel) (w : FreeGroup A) : N rel :=
+  ⟨sectionWord rel g*w*(sectionWord rel (g*q rel w))⁻¹,PresentedGroup.mk_eq_one_iff.mp (by
+    simp only [map_mul,map_inv,sectionWord_q,mul_inv_cancel])⟩
+lemma loop_one (g : G rel) : loop rel g 1=1 := by
+  apply Subtype.ext
+  simp [loop]
+lemma loop_mul (g : G rel) (w u : FreeGroup A) :
+    loop rel g (w*u)=loop rel g w*loop rel (g*q rel w) u := by
+  apply Subtype.ext
+  simp only [loop,Subgroup.coe_mul,map_mul,mul_assoc]
+  group
+include hz in
+lemma area_loop_mul (g : G rel) (w u : FreeGroup A) :
+    area rel (loop rel g (w*u))=area rel (loop rel g w)+area rel (loop rel (g*q rel w) u) := by
+  rw [loop_mul,area_mul rel hz]
+include hz in
+lemma area_loop_inv (g : G rel) (w : FreeGroup A) :
+    area rel (loop rel g w⁻¹)= -area rel (loop rel (g*(q rel w)⁻¹) w) := by
+  have h := area_loop_mul rel hz g w⁻¹ w
+  rw [inv_mul_cancel,loop_one,area_one rel hz,map_inv] at h
+  exact eq_neg_of_add_eq_zero_left h.symm
+
+def retract : CellModule.Module (G rel) A→+CellModule.Module (G rel) I :=
+  Finsupp.liftAddHom (fun p=>zmultiplesHom _ (area rel (loop rel p.1 (FreeGroup.of p.2))))
+@[simp] lemma retract_single (p : G rel×A) (z : ℤ) :
+    retract rel (Finsupp.single p z)=z • area rel (loop rel p.1 (FreeGroup.of p.2)) := by
+  simp [retract]
+include hz in
+lemma retract_fox (w : FreeGroup A) (g : G rel) :
+    retract rel (translate g (fox (q rel) w))=area rel (loop rel g w) := by
+  induction w using FreeGroup.induction_on generalizing g with
+  | one=>rw [fox_one,map_zero,map_zero,loop_one,area_one rel hz]
+  | of a=>simp only [fox_of,translate_single,mul_one,retract_single,one_zsmul]
+  | inv_of a ih=>
+    rw [fox_inv,map_neg,map_neg,←translate_mul,ih,area_loop_inv rel hz]
+  | mul w u hw hu=>
+    rw [fox_mul,map_add,map_add,←translate_mul,hw,hu,area_loop_mul rel hz]
+include hz in
+lemma area_rel (i : I) : area rel ⟨FreeGroup.mk (rel i),Subgroup.subset_normalClosure ⟨i,rfl⟩⟩=
+    Finsupp.single (1,i) 1 := by
+  let t : Term (A:=A) (I:=I) := ⟨i,true,[]⟩
+  have ht : FreeGroup.mk (word rel [t])=FreeGroup.mk (rel i) := by
+    simp [word,Term.word,Term.core,t]
+  rw [area_eq rel hz _ [t] ht]
+  simp [total,term,t,←FreeGroup.one_eq_mk]
+include hz in
+lemma retract_d₂_single (g : G rel) (i : I) :
+    retract rel (d₂ rel (Finsupp.single (g,i) 1))=Finsupp.single (g,i) 1 := by
+  rw [d₂_single,one_zsmul,retract_fox rel hz]
+  have he : loop rel g (FreeGroup.mk (rel i))=
+      conjugate rel (sectionWord rel g) ⟨FreeGroup.mk (rel i),Subgroup.subset_normalClosure ⟨i,rfl⟩⟩ := by
+    apply Subtype.ext
+    simp only [loop,conjugate,q_rel,mul_one]
+  rw [he,area_conjugate rel hz,area_rel rel hz,sectionWord_q,translate_single,mul_one]
+include hz in
+/-- The actual integral physical-cell boundary is a split injection as an
+abelian-group map. The splitting uses genuine normal-closure expansions,
+not a hypothesis of cellular acyclicity. -/
+lemma retract_d₂ (x : CellModule.Module (G rel) I) : retract rel (d₂ rel x)=x := by
+  induction x using Finsupp.induction_linear with
+  | zero=>simp
+  | add a b ha hb=>simp only [map_add,ha,hb]
+  | single p z=>
+    have hs : Finsupp.single p z=z • Finsupp.single p (1:ℤ) := by simp
+    rw [hs,map_zsmul,map_zsmul,retract_d₂_single rel hz p.1 p.2]
+include hz in
+lemma d₂_injective : Function.Injective (d₂ rel) :=
+  Function.LeftInverse.injective (retract_d₂ rel hz)
+end
+end TorsionFreeZeroDivisors.RelationSplit
+
+end
+
+
+end OAI
diff --git a/lean/OAI/Algebra/GroupRing/RelationTorsion.lean b/lean/OAI/Algebra/GroupRing/RelationTorsion.lean
new file mode 100644
index 0000000000000000000000000000000000000000..c6d4a7fccf31e0a273410790e0c55f3962760c48
--- /dev/null
+++ b/lean/OAI/Algebra/GroupRing/RelationTorsion.lean
@@ -0,0 +1,91 @@
+import Mathlib
+import OAI.Algebra.GroupRing.RelationArea
+import OAI.Algebra.GroupRing.CellNorm
+
+namespace OAI
+
+
+
+section
+namespace TorsionFreeZeroDivisors.RelationTorsion
+open scoped Classical BigOperators
+open AlgebraicPictures CellModule RelationArea
+noncomputable section
+variable {A I : Type} (rel : I→List (A×Bool))
+lemma fox_pow (w : FreeGroup A) (n : ℕ) : fox (q rel) (w^n)=
+    ∑k∈Finset.range n,translate (q rel w^k) (fox (q rel) w) := by
+  induction n with
+  | zero=>simp [fox_one]
+  | succ n ih=>rw [pow_succ,fox_mul,ih,Finset.sum_range_succ,map_pow]
+local instance zpowersCommGroup (g : G rel) : CommGroup (Subgroup.zpowers g) := IsCyclic.commGroup
+lemma norm_zpowers {J : Type} (g : G rel) (hg : IsOfFinOrder g)
+    [Fintype (Subgroup.zpowers g)] (x : CellModule.Module (G rel) J) :
+    CellNorm.norm (Subgroup.zpowers g).subtype x=
+      ∑k∈Finset.range (orderOf g),translate (g^k) x := by
+  rw [CellNorm.norm,←(finEquivZPowers hg).sum_comp]
+  simp only [finEquivZPowers_apply,Subgroup.subtype_apply]
+  exact Fin.sum_univ_eq_sum_range (fun k : ℕ=>translate (g^k) x) (orderOf g)
+
+/-- The translated integral relation-area identity rules out actual finite-order
+quotient elements, via the exact cyclic norm complex on free integral modules. -/
+theorem torsion_free
+    (hz : ∀ts : List (Term (A:=A) (I:=I)),FreeGroup.mk (word rel ts)=1→total rel ts=0) :
+    ∀ (g : G rel) (n : ℕ), 0 < n → g ^ n = 1 → g = 1 := by
+  intro g n hn hgn
+  by_contra hgne
+  have hfin : IsOfFinOrder g := isOfFinOrder_iff_pow_eq_one.mpr ⟨n,hn,hgn⟩
+  let H := Subgroup.zpowers g
+  let : Fintype H := Fintype.ofEquiv (Fin (orderOf g)) (finEquivZPowers hfin)
+  let : CommGroup H := IsCyclic.commGroup
+  let a : H := ⟨g,Subgroup.mem_zpowers g⟩
+  have ha : ∀x : H,x∈Subgroup.zpowers a := by
+    intro x
+    obtain ⟨z,hz⟩ := x.property
+    exact ⟨z,Subtype.ext hz⟩
+  have hcard : 1<Fintype.card H := by
+    rw [Fintype.card_congr (finEquivZPowers hfin).symm,Fintype.card_fin]
+    have hp := hfin.orderOf_pos
+    have he : orderOf g≠1 := fun h=>hgne (orderOf_eq_one_iff.mp h)
+    omega
+  obtain ⟨w,hw⟩ := QuotientGroup.mk'_surjective (N rel) g
+  change q rel w=g at hw
+  let r : N rel := ⟨w^orderOf g,PresentedGroup.mk_eq_one_iff.mp (by rw [map_pow,hw,pow_orderOf_eq_one])⟩
+  have hr : conjugate rel w r=r := by
+    apply Subtype.ext
+    change w*w^orderOf g*w⁻¹=w^orderOf g
+    rw [←pow_succ',pow_succ,mul_inv_cancel_right]
+  have hinv : translate g (area rel r)=area rel r := by
+    rw [←hw,←area_conjugate rel hz,hr]
+  obtain ⟨E,hE⟩ := CellNorm.invariant_norm H.subtype Subtype.val_injective a ha (area rel r) hinv
+  have hnorm : CellNorm.norm H.subtype (fox (q rel) w-d₂ rel E)=0 := by
+    rw [CellNorm.norm_sub,←CellNorm.equivariance H.subtype A (d₂ rel) (d₂_translate rel),hE,d₂_area]
+    change CellNorm.norm H.subtype (fox (q rel) w)-fox (q rel) (w^orderOf g)=0
+    rw [norm_zpowers rel g hfin,fox_pow,hw,sub_self]
+  obtain ⟨F,hF⟩ := CellNorm.kernel_norm H.subtype Subtype.val_injective a ha _ hnorm
+  have hbd : translate g (boundary (q rel) F)-boundary (q rel) F=
+      Finsupp.single (g,PUnit.unit) 1-Finsupp.single (1,PUnit.unit) 1 := by
+    change translate g F-F=fox (q rel) w-d₂ rel E at hF
+    have h := congrArg (boundary (q rel)) hF
+    simpa only [map_sub,boundary_translate,boundary_fox,hw,boundary_d₂,sub_zero] using h
+  let x : CellModule.Module (G rel) PUnit := Finsupp.single (1,PUnit.unit) 1-boundary (q rel) F
+  have hx : translate g x=x := by
+    dsimp only [x]
+    rw [map_sub,translate_single,mul_one]
+    apply sub_eq_sub_iff_add_eq_add.mpr
+    have he := sub_eq_sub_iff_add_eq_add.mp hbd
+    simpa only [add_comm] using he.symm
+  have hdvd := CellNorm.invariant_augmentation H.subtype Subtype.val_injective a ha x hx
+  have haug : CellNorm.augmentation x=1 := by
+    dsimp only [x]
+    rw [map_sub,CellNorm.augmentation_single,CellNorm.augmentation_boundary,sub_zero]
+  rw [haug] at hdvd
+  have hc : Fintype.card H∣1 := Int.natCast_dvd_natCast.mp hdvd
+  have := Nat.eq_one_of_dvd_one hc
+  omega
+end
+end TorsionFreeZeroDivisors.RelationTorsion
+
+end
+
+
+end OAI
diff --git a/lean/OAI/Algebra/GroupRing/SeparatorLevels.lean b/lean/OAI/Algebra/GroupRing/SeparatorLevels.lean
new file mode 100644
index 0000000000000000000000000000000000000000..2ee333e1ed3ff5cbd652c024dfc1841a98757519
--- /dev/null
+++ b/lean/OAI/Algebra/GroupRing/SeparatorLevels.lean
@@ -0,0 +1,358 @@
+import Mathlib
+import OAI.Algebra.GroupRing.GraphQuotient
+
+namespace OAI
+
+noncomputable section
+
+namespace TorsionFreeZeroDivisors.SeparatorLevels
+
+section
+open scoped BigOperators
+variable {V : Type*} [Fintype V]
+
+/-- Canonical finite vertex level profile; its mass is not an extra assumption. -/
+def profile (level : V → ℤ) (z : ℤ) : ℕ :=
+  (Finset.univ.filter (fun v=>level v=z)).card
+
+theorem profile_mass (level : V → ℤ) (s : Finset ℤ) :
+    ∑ z ∈ s,profile level z ≤ Fintype.card V := by
+  classical
+  unfold profile
+  rw [Finset.sum_card_fiberwise_eq_card_filter]
+  exact (Finset.card_filter_le _ _).trans_eq (Finset.card_univ)
+
+theorem select_vertices (level : V → ℤ) (center : ℤ) :
+    ∃ kL kR : ℕ,
+      (profile level (center-kL) + profile level (center+kR) + 2*(kL+kR) : ℝ) ≤
+        2*Real.sqrt 2*Real.sqrt (Fintype.card V) :=
+  select (profile level) _ center (profile_mass level)
+
+/-- A median genuine BFS level, including the empty graph and repeated levels. -/
+theorem exists_median (level : V → ℕ) :
+    ∃ center : ℕ,
+      2*(Finset.univ.filter (fun v=>level v<center)).card ≤ Fintype.card V ∧
+      2*(Finset.univ.filter (fun v=>center<level v)).card ≤ Fintype.card V := by
+  classical
+  let P := fun k => Fintype.card V ≤
+    2*(Finset.univ.filter (fun v=>level v≤k)).card
+  have hex : ∃ k,P k := by
+    refine ⟨Finset.univ.sup level,?_⟩
+    have hh : ∀ v,level v ≤ Finset.univ.sup level :=
+      fun v=>Finset.le_sup (Finset.mem_univ v)
+    simp only [P,Finset.filter_true_of_mem (fun v _ => hh v),Finset.card_univ]
+    omega
+  let center := Nat.find hex
+  have hc : P center := Nat.find_spec hex
+  refine ⟨center,?_,?_⟩
+  · cases he : center with
+    | zero => simp only [Nat.not_lt_zero,Finset.filter_false,Finset.card_empty,mul_zero]
+              exact Nat.zero_le _
+    | succ k =>
+      have hk : k < Nat.find hex := by change k<center;omega
+      have hp := Nat.find_min hex hk
+      change ¬ P k at hp
+      simp only [Nat.lt_succ_iff]
+      dsimp [P] at hp
+      omega
+  · have hparts : (Finset.univ.filter (fun v=>level v≤center)).card+
+        (Finset.univ.filter (fun v=>center<level v)).card=Fintype.card V := by
+      have hh := Finset.card_filter_add_card_filter_not
+        (s:=Finset.univ) (p:=fun v=>level v≤center)
+      simpa only [not_le,Finset.card_univ] using hh
+    dsimp [P] at hc
+    omega
+
+/-- The selected levels are literal finite graph levels, and both exterior
+regions already satisfy the stronger half-size bound. -/
+theorem selected_levels (level : V → ℕ) :
+    ∃ center kL kR : ℕ,
+      (profile (fun v=>(level v:ℤ)) ((center:ℤ)-kL) +
+       profile (fun v=>(level v:ℤ)) ((center:ℤ)+kR) + 2*(kL+kR) : ℝ) ≤
+        2*Real.sqrt 2*Real.sqrt (Fintype.card V) ∧
+      2*(Finset.univ.filter (fun v=>(level v:ℤ)<(center:ℤ)-kL)).card ≤ Fintype.card V ∧
+      2*(Finset.univ.filter (fun v=>(center:ℤ)+kR<(level v:ℤ))).card ≤ Fintype.card V := by
+  classical
+  obtain ⟨center,hcl,hcr⟩ := exists_median level
+  obtain ⟨kL,kR,hk⟩ := select_vertices (fun v=>(level v:ℤ)) center
+  refine ⟨center,kL,kR,hk,?_,?_⟩
+  · have hs : (Finset.univ.filter (fun v=>(level v:ℤ)<(center:ℤ)-kL))⊆
+        (Finset.univ.filter (fun v=>level v<center)) := by
+      intro v hv
+      simp only [Finset.mem_filter,Finset.mem_univ,true_and] at hv ⊢
+      omega
+    have hh := Finset.card_le_card hs
+    omega
+  · have hs : (Finset.univ.filter (fun v=>(center:ℤ)+kR<(level v:ℤ)))⊆
+        (Finset.univ.filter (fun v=>center<level v)) := by
+      intro v hv
+      simp only [Finset.mem_filter,Finset.mem_univ,true_and] at hv ⊢
+      omega
+    have hh := Finset.card_le_card hs
+    omega
+
+omit [Fintype V] in
+/-- A single removed level prevents an edge from passing across it. -/
+theorem below_closed {R : V → V → Prop} (level : V → ℤ)
+    (hstep : ∀ x y,R x y → level y ≤ level x+1) {b : ℤ} {x y : V}
+    (hx : level x<b) (hy : level y≠b) (hxy : R x y) : level y<b := by
+  have hh := hstep x y hxy
+  omega
+
+omit [Fintype V] in
+theorem above_closed {R : V → V → Prop} (level : V → ℤ)
+    (hstep : ∀ x y,R x y → level x ≤ level y+1) {b : ℤ} {x y : V}
+    (hx : b<level x) (hy : level y≠b) (hxy : R x y) : b<level y := by
+  have hh := hstep x y hxy
+  omega
+
+omit [Fintype V] in
+theorem band_closed {R : V → V → Prop} (level : V → ℤ)
+    (hstep : ∀ x y,R x y → level y ≤ level x+1 ∧ level x ≤ level y+1)
+    {lo hi : ℤ} {x y : V} (hx : lo<level x ∧ level x<hi)
+    (hyl : level y≠lo) (hyh : level y≠hi) (hxy : R x y) :
+    lo<level y ∧ level y<hi :=
+  ⟨above_closed level (fun x y h=>(hstep x y h).2) hx.1 hyl hxy,
+   below_closed level (fun x y h=>(hstep x y h).1) hx.2 hyh hxy⟩
+
+end
+
+variable {V : Type*} (G : SimpleGraph V) (root : V)
+
+theorem bfs_step (hconn : G.Connected) {x y : V} (hxy : G.Adj x y) :
+    (G.dist root y:ℤ) ≤ (G.dist root x:ℤ)+1 ∧
+    (G.dist root x:ℤ) ≤ (G.dist root y:ℤ)+1 := by
+  have h₁ := hconn.dist_triangle (u:=root) (v:=x) (w:=y)
+  have h₂ := hconn.dist_triangle (u:=root) (v:=y) (w:=x)
+  rw [G.dist_eq_one_iff_adj.mpr hxy] at h₁
+  rw [G.dist_eq_one_iff_adj.mpr hxy.symm] at h₂
+  exact ⟨by exact_mod_cast h₁,by exact_mod_cast h₂⟩
+
+end TorsionFreeZeroDivisors.SeparatorLevels
+
+namespace TorsionFreeZeroDivisors.RecursiveSeparator
+open scoped Classical
+variable {V I : Type} [DecidableEq V] [Fintype I] [DecidableEq I]
+    (R : V→V→Prop) (S remove : Finset V) (label : V→I)
+
+def Split.of_fibers (hsub : remove⊆S)
+    (hclosed : ∀ x∈S\remove,∀ y∈S\remove,R x y→label x=label y)
+    (hsize : ∀ i,3*((S\remove).filter (fun x=>label x=i)).card≤2*S.card)
+    (hcost : (remove.card:ℝ)≤2*Real.sqrt 2*Real.sqrt S.card) : Split R S where
+  remove := remove
+  parts := Finset.univ.image (fun i=>(S\remove).filter (fun x=>label x=i))
+  remove_subset := hsub
+  cover := by
+    ext x
+    simp only [Finset.mem_biUnion,Finset.mem_image,Finset.mem_univ,true_and,id_eq]
+    constructor
+    · rintro ⟨b,⟨i,rfl⟩,hx⟩
+      exact (Finset.mem_filter.mp hx).1
+    · intro hx
+      exact ⟨(S\remove).filter (fun y=>label y=label x),⟨label x,rfl⟩,Finset.mem_filter.mpr ⟨hx,rfl⟩⟩
+  disjoint := by
+    intro b hb c hc hbc
+    obtain ⟨i,_,rfl⟩ := Finset.mem_image.mp hb
+    obtain ⟨j,_,rfl⟩ := Finset.mem_image.mp hc
+    apply Finset.disjoint_left.mpr
+    intro x hx hy
+    have hi := (Finset.mem_filter.mp hx).2
+    have hj := (Finset.mem_filter.mp hy).2
+    have he : i=j := hi.symm.trans hj
+    exact hbc (by rw [he])
+  closed := by
+    intro b hb x hx y hy hxy
+    obtain ⟨i,_,rfl⟩ := Finset.mem_image.mp hb
+    obtain ⟨hx,hi⟩ := Finset.mem_filter.mp hx
+    exact Finset.mem_filter.mpr ⟨hy,(hclosed x hx y hy hxy).symm.trans hi⟩
+  size := by
+    intro b hb
+    obtain ⟨i,_,rfl⟩ := Finset.mem_image.mp hb
+    exact hsize i
+  cost := hcost
+end TorsionFreeZeroDivisors.RecursiveSeparator
+
+namespace TorsionFreeZeroDivisors.PlanarMap
+open scoped Classical
+open SeparatorLevels
+variable {V : Type} [Fintype V] {G : SimpleGraph V}
+
+theorem Model.connected_split (M : Model G) (hc : G.Connected) :
+    Nonempty (RecursiveSeparator.Split G.Adj Finset.univ) := by
+  classical
+  have : Nonempty V := hc.nonempty
+  let root := Classical.ofNonempty (α:=V)
+  let level : V→ℕ := fun v=>G.dist v root
+  obtain ⟨center,kL,kR,hcost,hbelow,habove⟩ := selected_levels level
+  let L : ℤ := (center:ℤ)-kL
+  let U : ℤ := (center:ℤ)+kR
+  have hLU : L≤U := by dsimp [L,U];omega
+  let A := Finset.univ.filter (fun v=>L<(level v:ℤ) ∧ (level v:ℤ)<U)
+  have hA (v : V) : v∈A↔L<(level v:ℤ) ∧ (level v:ℤ)<U := by simp only [A,Finset.mem_filter,Finset.mem_univ,true_and]
+  have hex : ∃ cut side : Finset V,cut⊆A ∧ cut.card≤2*(kL+kR) ∧
+      3*(A.filter (fun v=>v∉cut ∧ v∈side)).card≤2*A.card ∧
+      3*(A.filter (fun v=>v∉cut ∧ v∉side)).card≤2*A.card ∧
+      ∀ v∈A,∀ w∈A,v∉cut→w∉cut→G.Adj v w→(v∈side↔w∈side) := by
+    by_cases hk : kL≤center
+    · obtain ⟨C,D,hs,hcC,h₁,h₂,hsep⟩ := M.annular_separator hc root (center-kL) (center+kR) A (by
+        intro v hv
+        have hh := (hA v).mp hv
+        change center-kL<level v ∧ level v≤center+kR
+        dsimp [L,U] at hh
+        omega)
+      refine ⟨C,D,hs,?_,h₁,h₂,hsep⟩
+      have he : center+kR-(center-kL)=kL+kR := by omega
+      rwa [he] at hcC
+    · obtain ⟨C,D,hs,hcC,h₁,h₂,hsep⟩ := M.ball_separator hc root (center+kR) A (by
+        intro v hv
+        have hh := (hA v).mp hv
+        change level v≤center+kR
+        dsimp [U] at hh
+        omega)
+      exact ⟨C,D,hs,by omega,h₁,h₂,hsep⟩
+  obtain ⟨C,D,hCA,hC,h₁,h₂,hsep⟩ := hex
+  let low := Finset.univ.filter (fun v=>(level v:ℤ)<L)
+  let high := Finset.univ.filter (fun v=>U<(level v:ℤ))
+  let eL := Finset.univ.filter (fun v=>(level v:ℤ)=L)
+  let eU := Finset.univ.filter (fun v=>(level v:ℤ)=U)
+  let remove := eL∪eU∪C
+  have hremove (v : V) : v∈remove↔(level v:ℤ)=L ∨ (level v:ℤ)=U ∨ v∈C := by
+    simp only [remove,eL,eU,Finset.mem_union,Finset.mem_filter,Finset.mem_univ,true_and,or_assoc]
+  have hnone {v : V} (hv : v∈Finset.univ\remove) : (level v:ℤ)≠L ∧ (level v:ℤ)≠U ∧ v∉C := by
+    have hh := (Finset.mem_sdiff.mp hv).2
+    simpa only [hremove,not_or] using hh
+  let label : V→Fin 4 := fun v=>if (level v:ℤ)<L then 0 else if U<(level v:ℤ) then 1 else if v∈D then 2 else 3
+  have hl0 {v : V} (hv : label v=0) : (level v:ℤ)<L := by
+    dsimp [label] at hv
+    split_ifs at hv with h₀ h₁ h₂ <;> simp_all
+  have hl1 {v : V} (hv : label v=1) : U<(level v:ℤ) := by
+    dsimp [label] at hv
+    split_ifs at hv with h₀ h₁ h₂ <;> simp_all
+  have hl2 {v : V} (hv : label v=2) : ¬(level v:ℤ)<L ∧ ¬U<(level v:ℤ) ∧ v∈D := by
+    dsimp [label] at hv
+    split_ifs at hv with h₀ h₁ h₂ <;> simp_all
+  have hl3 {v : V} (hv : label v=3) : ¬(level v:ℤ)<L ∧ ¬U<(level v:ℤ) ∧ v∉D := by
+    dsimp [label] at hv
+    split_ifs at hv with h₀ h₁ h₂ <;> simp_all
+  have hglobal : A.card≤Fintype.card V := Finset.card_le_univ _
+  have hsize (i : Fin 4) : 3*((Finset.univ\remove).filter (fun v=>label v=i)).card≤2*(Finset.univ : Finset V).card := by
+    rw [Finset.card_univ]
+    fin_cases i
+    · change 3*((Finset.univ\remove).filter (fun v=>label v=(0:Fin 4))).card≤2*Fintype.card V
+      have hs : (Finset.univ\remove).filter (fun v=>label v=0)⊆low := by
+        intro v hv
+        exact Finset.mem_filter.mpr ⟨Finset.mem_univ _,hl0 (Finset.mem_filter.mp hv).2⟩
+      have hh := Finset.card_le_card hs
+      change 2*low.card≤Fintype.card V at hbelow
+      omega
+    · change 3*((Finset.univ\remove).filter (fun v=>label v=(1:Fin 4))).card≤2*Fintype.card V
+      have hs : (Finset.univ\remove).filter (fun v=>label v=1)⊆high := by
+        intro v hv
+        exact Finset.mem_filter.mpr ⟨Finset.mem_univ _,hl1 (Finset.mem_filter.mp hv).2⟩
+      have hh := Finset.card_le_card hs
+      change 2*high.card≤Fintype.card V at habove
+      omega
+    · change 3*((Finset.univ\remove).filter (fun v=>label v=(2:Fin 4))).card≤2*Fintype.card V
+      have hs : (Finset.univ\remove).filter (fun v=>label v=2)⊆A.filter (fun v=>v∉C ∧ v∈D) := by
+        intro v hv
+        obtain ⟨hr,he⟩ := Finset.mem_filter.mp hv
+        have hn := hnone hr
+        have hd := hl2 he
+        exact Finset.mem_filter.mpr ⟨(hA v).mpr (by omega),hn.2.2,hd.2.2⟩
+      have hh := Finset.card_le_card hs
+      omega
+    · change 3*((Finset.univ\remove).filter (fun v=>label v=(3:Fin 4))).card≤2*Fintype.card V
+      have hs : (Finset.univ\remove).filter (fun v=>label v=3)⊆A.filter (fun v=>v∉C ∧ v∉D) := by
+        intro v hv
+        obtain ⟨hr,he⟩ := Finset.mem_filter.mp hv
+        have hn := hnone hr
+        have hd := hl3 he
+        exact Finset.mem_filter.mpr ⟨(hA v).mpr (by omega),hn.2.2,hd.2.2⟩
+      have hh := Finset.card_le_card hs
+      omega
+  have hclosed : ∀ v∈Finset.univ\remove,∀ w∈Finset.univ\remove,G.Adj v w→label v=label w := by
+    intro v hv w hw he
+    have hnV := hnone hv
+    have hnW := hnone hw
+    have hstep : (level w:ℤ)≤(level v:ℤ)+1 ∧ (level v:ℤ)≤(level w:ℤ)+1 := by
+      have h := bfs_step G root hc he
+      simpa only [SimpleGraph.dist_comm,level] using h
+    by_cases hL : (level v:ℤ)<L
+    · have hwL : (level w:ℤ)<L := by omega
+      simp only [label,ite_eq_left hL,ite_eq_left hwL]
+    · by_cases hU : U<(level v:ℤ)
+      · have hwU : U<(level w:ℤ) := by omega
+        have hwL : ¬(level w:ℤ)<L := by omega
+        simp only [label,ite_eq_right hL,ite_eq_right hwL,ite_eq_left hU,ite_eq_left hwU]
+      · have hvA : v∈A := (hA v).mpr (by omega)
+        have hwA : w∈A := (hA w).mpr (by omega)
+        have hwL : ¬(level w:ℤ)<L := by have := (hA w).mp hwA;omega
+        have hwU : ¬U<(level w:ℤ) := by have := (hA w).mp hwA;omega
+        have hd := hsep v hvA w hwA hnV.2.2 hnW.2.2 he
+        simp only [label,ite_eq_right hL,ite_eq_right hU,ite_eq_right hwL,ite_eq_right hwU,hd]
+  have hrCost : (remove.card:ℝ)≤2*Real.sqrt 2*Real.sqrt (Finset.univ : Finset V).card := by
+    have hcn : remove.card≤eL.card+eU.card+C.card :=
+      (Finset.card_union_le (eL∪eU) C).trans (Nat.add_le_add_right (Finset.card_union_le eL eU) _)
+    have hbound : remove.card≤eL.card+eU.card+2*(kL+kR) := by omega
+    have hre : (remove.card:ℝ)≤(eL.card:ℝ)+eU.card+2*(kL+kR) := by exact_mod_cast hbound
+    rw [Finset.card_univ]
+    exact hre.trans hcost
+  exact ⟨RecursiveSeparator.Split.of_fibers G.Adj Finset.univ remove label
+    (Finset.subset_univ _) hclosed hsize hrCost⟩
+
+end TorsionFreeZeroDivisors.PlanarMap
+
+namespace TorsionFreeZeroDivisors.RecursiveSeparator.Split
+open scoped Classical
+variable {V W : Type} [DecidableEq V] [DecidableEq W]
+    {R : V→V→Prop} {Q : W→W→Prop} {S : Finset V}
+
+def map (P : Split R S) (f : V ↪ W) (hR : ∀ v w,Q (f v) (f w)→R v w) :
+    Split Q (S.map f) where
+  remove := P.remove.map f
+  parts := P.parts.image (fun b=>b.map f)
+  remove_subset := Finset.map_subset_map.mpr P.remove_subset
+  cover := by
+    rw [←Finset.map_sdiff]
+    ext x
+    constructor
+    · intro hx
+      obtain ⟨b,hb,hx⟩ := Finset.mem_biUnion.mp hx
+      obtain ⟨c,hc,he⟩ := Finset.mem_image.mp hb
+      subst b
+      obtain ⟨v,hv,rfl⟩ := Finset.mem_map.mp hx
+      refine Finset.mem_map.mpr ⟨v,?_,rfl⟩
+      rw [←P.cover]
+      exact Finset.mem_biUnion.mpr ⟨c,hc,hv⟩
+    · intro hx
+      obtain ⟨v,hv,rfl⟩ := Finset.mem_map.mp hx
+      rw [←P.cover] at hv
+      obtain ⟨b,hb,hv⟩ := Finset.mem_biUnion.mp hv
+      exact Finset.mem_biUnion.mpr ⟨b.map f,Finset.mem_image.mpr ⟨b,hb,rfl⟩,
+        Finset.mem_map.mpr ⟨v,hv,rfl⟩⟩
+  disjoint := by
+    intro b hb c hc hbc
+    obtain ⟨d,hd,he⟩ := Finset.mem_image.mp hb
+    subst b
+    obtain ⟨e,he,hf⟩ := Finset.mem_image.mp hc
+    subst c
+    exact (Finset.disjoint_map f).mpr (P.disjoint hd he (fun h=>hbc (congrArg (fun b=>b.map f) h)))
+  closed := by
+    intro b hb x hx y hy hxy
+    obtain ⟨c,hc,he⟩ := Finset.mem_image.mp hb
+    subst b
+    obtain ⟨v,hv,rfl⟩ := Finset.mem_map.mp hx
+    rw [←Finset.map_sdiff] at hy
+    obtain ⟨w,hw,rfl⟩ := Finset.mem_map.mp hy
+    exact Finset.mem_map.mpr ⟨w,P.closed c hc v hv w hw (hR v w hxy),rfl⟩
+  size := by
+    intro b hb
+    obtain ⟨c,hc,he⟩ := Finset.mem_image.mp hb
+    subst b
+    simpa only [Finset.card_map] using P.size c hc
+  cost := by simpa only [Finset.card_map] using P.cost
+end TorsionFreeZeroDivisors.RecursiveSeparator.Split
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/GroupRing/ShortClosure.lean b/lean/OAI/Algebra/GroupRing/ShortClosure.lean
new file mode 100644
index 0000000000000000000000000000000000000000..39ead68254d752d608bf36a1607fc40e2dfb0c5f
--- /dev/null
+++ b/lean/OAI/Algebra/GroupRing/ShortClosure.lean
@@ -0,0 +1,435 @@
+import Mathlib
+import OAI.Algebra.GroupRing.BoundedSystem
+
+namespace OAI
+
+noncomputable section
+
+namespace TorsionFreeZeroDivisors.ShortClosure
+open scoped Classical
+open PortSubdivision WeightedMoore
+variable {V D : Type} (Γ : PortGraph V D)
+
+/-- Forgetting loops and multiplicities, only for measuring component distances. -/
+def simpleGraph : SimpleGraph V where
+  Adj a b := a≠b ∧ ∃ d,Γ.origin d=a ∧ Γ.origin (Γ.reverse d)=b
+  symm := ⟨by
+    rintro a b ⟨hab,d,ha,hb⟩
+    exact ⟨hab.symm,Γ.reverse d,hb,by simpa⟩⟩
+  loopless := ⟨fun _ h => h.1 rfl⟩
+
+def edgeDart {a b : V} (h : (simpleGraph Γ).Adj a b) : D := h.2.choose
+lemma edgeDart_start {a b : V} (h : (simpleGraph Γ).Adj a b) : Γ.origin (edgeDart Γ h)=a :=
+  h.2.choose_spec.1
+lemma edgeDart_end {a b : V} (h : (simpleGraph Γ).Adj a b) : Γ.origin (Γ.reverse (edgeDart Γ h))=b :=
+  h.2.choose_spec.2
+
+def liftWalk {a b : V} : (simpleGraph Γ).Walk a b → List D
+  | .nil => []
+  | .cons h p => edgeDart Γ h::liftWalk p
+
+lemma liftWalk_length {a b : V} (p : (simpleGraph Γ).Walk a b) : (liftWalk Γ p).length=p.length := by
+  induction p with
+  | nil => rfl
+  | cons h p ih => simp only [liftWalk,List.length_cons,SimpleGraph.Walk.length_cons,ih]
+
+lemma liftWalk_start {a b : V} (p : (simpleGraph Γ).Walk a b) :
+    ∀ d∈(liftWalk Γ p).head?,Γ.origin d=a := by
+  cases p with
+  | nil => simp [liftWalk]
+  | cons h p =>
+    intro d hd
+    have hd : d=edgeDart Γ h := by simpa only [liftWalk,List.head?_cons,Option.some.injEq] using hd.symm
+    subst d
+    exact edgeDart_start Γ h
+
+lemma liftWalk_head_target {a b : V} (p : (simpleGraph Γ).Walk a b) :
+    ∀ d∈(liftWalk Γ p).head?,Γ.origin (Γ.reverse d)∈p.support := by
+  cases p with
+  | nil => simp [liftWalk]
+  | @cons a b c h p =>
+    intro d hd
+    have hd : d=edgeDart Γ h := by simpa only [liftWalk,List.head?_cons,Option.some.injEq] using hd.symm
+    subst d
+    rw [edgeDart_end]
+    exact List.mem_cons_of_mem a (SimpleGraph.Walk.start_mem_support p)
+
+lemma liftWalk_finish {a b : V} (p : (simpleGraph Γ).Walk a b) : endpoint Γ a (liftWalk Γ p)=b := by
+  induction p with
+  | nil => rfl
+  | cons h p ih =>
+    change endpoint Γ _ ([edgeDart Γ h]++liftWalk Γ p)=_
+    rw [endpoint_append_list]
+    change endpoint Γ (Γ.origin (Γ.reverse (edgeDart Γ h))) (liftWalk Γ p)=_
+    rw [edgeDart_end]
+    exact ih
+
+lemma liftWalk_reduced {a b : V} (p : (simpleGraph Γ).Walk a b) (hp : p.IsPath) :
+    ReducedPath Γ a b (liftWalk Γ p) := by
+  refine ⟨?_,liftWalk_start Γ p,liftWalk_finish Γ p⟩
+  induction p with
+  | nil => simp [liftWalk]
+  | @cons a b c h p ih =>
+    apply (ih hp.of_cons).cons
+    intro y hy
+    refine ⟨(edgeDart_end Γ h).trans (liftWalk_start Γ p y hy).symm,?_⟩
+    intro he
+    have hu : a∉p.support := (List.nodup_cons.mp hp.support_nodup).1
+    apply hu
+    have hm := liftWalk_head_target Γ p y hy
+    simpa only [he,PortGraph.reverse_reverse_apply,edgeDart_start] using hm
+
+lemma dart_reachable (d : D) : (simpleGraph Γ).Reachable (Γ.origin d) (Γ.origin (Γ.reverse d)) := by
+  by_cases h : Γ.origin d=Γ.origin (Γ.reverse d)
+  · exact h ▸ SimpleGraph.Reachable.refl (G:=simpleGraph Γ) (Γ.origin d)
+  · exact (show (simpleGraph Γ).Adj _ _ from ⟨h,d,rfl,rfl⟩).reachable
+
+/-- A literal reduced segment stays in one connected component, including when
+loops or parallel darts were present in the original port graph. -/
+lemma ReducedPath.reachable {a b : V} {l : List D} (hp : ReducedPath Γ a b l) :
+    (simpleGraph Γ).Reachable a b := by
+  induction l generalizing a with
+  | nil => rw [←hp.finish]; exact .refl _
+  | cons d l ih =>
+    have hs : Γ.origin d=a := hp.start d (by simp)
+    have ht : ReducedPath Γ (Γ.origin (Γ.reverse d)) b l := by
+      refine ⟨hp.chain.tail,?_,?_⟩
+      · intro e he
+        exact (hp.chain.rel_head? he).1.symm
+      · have he := hp.finish
+        change endpoint Γ a ([d]++l)=b at he
+        rw [endpoint_append_list] at he
+        exact he
+    rw [←hs]
+    exact (dart_reachable Γ d).trans (ih ht)
+
+/-- Geodesics of the simple shadow lift without backtracking to the actual
+multigraph. Thus the previously proved component diameter is the needed one. -/
+lemma reduced_return {a b : V} {p : List D} (hp : ReducedPath Γ a b p) :
+    ∃ q : List D,ReducedPath Γ b a q ∧ q.length=(simpleGraph Γ).dist b a := by
+  obtain ⟨w,hw⟩ := (hp.reachable Γ).symm.exists_walk_length_eq_dist
+  exact ⟨liftWalk Γ w,liftWalk_reduced Γ w (w.isPath_of_length_eq_dist hw),(liftWalk_length Γ w).trans hw⟩
+
+variable [Fintype V] [Fintype D]
+/-- The entire deterministic closure lemma, with an explicit logarithmic
+additive loss. No graph embedding theorem or cyclic cancellation is assumed. -/
+theorem short_closure (B : ℕ)
+    (hdiam : ∀ a b,(simpleGraph Γ).Reachable a b → (simpleGraph Γ).dist a b≤B)
+    (hdeg : ∀ v,7≤(Finset.univ.filter (fun x : D => Γ.origin x=v)).card)
+    {a b : V} {p : List D} (hp : ReducedPath Γ a b p) (hpn : p≠[]) :
+    ∃ t : List D,t.length≤B+4*(Nat.log 2 (Fintype.card V)+1) ∧
+      ReducedPath Γ a a (p++t) ∧
+      ∀ᵉ (x∈(p++t).getLast?) (y∈(p++t).head?),PortWalk.step Γ.origin Γ.reverse x y := by
+  obtain ⟨q,hq,hql⟩ := reduced_return Γ hp
+  obtain ⟨t,ht,hp',hc⟩ := extend_of_return Γ hp hpn hq hdeg
+  refine ⟨t,?_,hp',hc⟩
+  have hb := hdiam b a (hp.reachable Γ).symm
+  omega
+
+end TorsionFreeZeroDivisors.ShortClosure
+namespace TorsionFreeZeroDivisors.SumPort
+open PortSubdivision
+open scoped Classical BigOperators
+variable {VA VB DA DB : Type} (A : PortGraph VA DA) (B : PortGraph VB DB)
+lemma simple_eq : ShortClosure.simpleGraph (graph A B)=
+    ShortClosure.simpleGraph A⊕g ShortClosure.simpleGraph B := by
+  ext a b
+  rcases a with a|a <;> rcases b with b|b <;>
+    simp [ShortClosure.simpleGraph,graph,SimpleGraph.sum,Sum.exists]
+variable [Fintype DA] [Fintype DB]
+lemma degree_left (v : VA) :
+    (Finset.univ.filter (fun d : DA⊕DB => (graph A B).origin d=Sum.inl v)).card=
+      (Finset.univ.filter (fun d : DA => A.origin d=v)).card := by
+  simp only [Finset.card_filter]
+  rw [Fintype.sum_sum_type]
+  simp [graph, -Finset.sum_boole]
+lemma degree_right (v : VB) :
+    (Finset.univ.filter (fun d : DA⊕DB => (graph A B).origin d=Sum.inr v)).card=
+      (Finset.univ.filter (fun d : DB => B.origin d=v)).card := by
+  simp only [Finset.card_filter]
+  rw [Fintype.sum_sum_type]
+  simp [graph, -Finset.sum_boole]
+lemma typed_degree {V : Type} [Fintype V] (outgoing : V → Finset Types.Letter) (v : V) :
+    (Finset.univ.filter (fun d : TypedGraphs.Dart outgoing => TypedGraphs.origin outgoing d=v)).card=(outgoing v).card := by
+  have h := Fintype.card_congr (TypedGraphs.originFiber outgoing v)
+  simpa [Fintype.card_subtype] using h
+end TorsionFreeZeroDivisors.SumPort
+namespace TorsionFreeZeroDivisors.SampleGraph
+open scoped Classical BigOperators
+open PortSubdivision ConditionedMatchings ActualPatternEvent TypedGraphs GirthAsymptotics
+variable (rep : ℕ) (r : Match rep)
+lemma simple_eq : ShortClosure.simpleGraph (graph rep r)=
+    ShortClosure.simpleGraph (A rep r)⊕g ShortClosure.simpleGraph (B rep r) :=
+  SumPort.simple_eq (A rep r) (B rep r)
+lemma degreeA (v : VA rep) :
+    (Finset.univ.filter (fun d : DA rep⊕DB rep => (graph rep r).origin d=Sum.inl v)).card=
+      (Types.outgoingA v).card := by
+  unfold graph
+  have h := (SumPort.degree_left (A rep r) (B rep r) v).trans (SumPort.typed_degree (@Types.outgoingA rep) v)
+  convert h using 1
+  congr 1
+  ext d
+  simp
+lemma degreeB (v : VB rep) :
+    (Finset.univ.filter (fun d : DA rep⊕DB rep => (graph rep r).origin d=Sum.inr v)).card=
+      (Types.outgoingB v).card := by
+  unfold graph
+  have h := (SumPort.degree_right (A rep r) (B rep r) v).trans (SumPort.typed_degree (@Types.outgoingB rep) v)
+  convert h using 1
+  congr 1
+  ext d
+  simp
+lemma degree (v : VA rep⊕VB rep) :
+    129≤(Finset.univ.filter (fun d : DA rep⊕DB rep => (graph rep r).origin d=v)).card := by
+  cases v with
+  | inl v => rw [degreeA]; exact (Types.degreeA_bounds v).1
+  | inr v => rw [degreeB]; exact (Types.degreeB_bounds v).1
+lemma diameter (hd : GraphSample.Diameters rep r) :
+    ∀ a b,(ShortClosure.simpleGraph (graph rep r)).Reachable a b →
+      (ShortClosure.simpleGraph (graph rep r)).dist a b≤TypedDiameter.D₀*L (size rep) := by
+  rw [simple_eq]
+  exact SumGirth.diameter _ _ _ hd.1 hd.2
+lemma card_vertices : Fintype.card (VA rep⊕VB rep)=2*size rep := by
+  rw [Fintype.card_sum,Types.card_vertexA,Types.card_vertexB]
+  unfold size
+  omega
+lemma closure_log_bound (n : ℕ) (hL : 1≤L n) :
+    4*(Nat.log 2 (2*n)+1)≤1608*L n := by
+  have h := TypedDiameter.log_radius_bound n hL
+  by_cases hn : n=0
+  · subst n; simp only [Nat.mul_zero,Nat.log_zero_right,zero_add]; omega
+  · rw [Nat.mul_comm 2 n,Nat.log_mul_base (by omega) hn]
+    omega
+/-- The short-closure conclusion on the actual sampled two-side graph,
+with one uniform fixed constant independent of the segment and n. -/
+theorem short_closure (hL : 1≤L (size rep)) (hd : GraphSample.Diameters rep r)
+    {a b : VA rep⊕VB rep} {p : List (DA rep⊕DB rep)}
+    (hp : ShortClosure.ReducedPath (graph rep r) a b p) (hpn : p≠[]) :
+    ∃ t : List (DA rep⊕DB rep),t.length≤(TypedDiameter.D₀+1608)*L (size rep) ∧
+      ShortClosure.ReducedPath (graph rep r) a a (p++t) ∧
+      ∀ᵉ (x∈(p++t).getLast?) (y∈(p++t).head?),
+        WeightedMoore.PortWalk.step (graph rep r).origin (graph rep r).reverse x y := by
+  obtain ⟨t,ht,hp',hc⟩ := ShortClosure.short_closure (graph rep r) (TypedDiameter.D₀*L (size rep))
+    (diameter rep r hd) (fun v => (by norm_num : 7≤129).trans (degree rep r v)) hp hpn
+  refine ⟨t,?_,hp',hc⟩
+  rw [card_vertices] at ht
+  have hb := closure_log_bound (size rep) hL
+  nlinarith
+end TorsionFreeZeroDivisors.SampleGraph
+
+namespace TorsionFreeZeroDivisors.RestrictComparisons
+open scoped Classical BigOperators
+open BlockAlignment ComparedBlocks
+variable {T E : Type} {len : T → ℕ} (C : Comparisons (E:=E) len) (keep : T → Prop)
+
+abbrev Length : {t // keep t} → ℕ := fun t => len t.val
+
+def embed (x : Position (Length keep (len:=len))) : Position len := ⟨x.1.val,x.2⟩
+def liftPosition (x : Position len) (h : keep x.1) : Position (Length keep (len:=len)) := ⟨⟨x.1,h⟩,x.2⟩
+lemma embed_local (x : Position len) (h : keep x.1) : embed keep (liftPosition keep x h)=x := by cases x; rfl
+lemma local_embed (x : Position (Length keep (len:=len))) : liftPosition keep (embed keep x) x.1.property=x := by cases x; rfl
+lemma embed_injective : Function.Injective (embed keep (len:=len)) := by
+  rintro ⟨⟨t,ht⟩,q⟩ ⟨⟨u,hu⟩,r⟩ h
+  cases h
+  rfl
+
+abbrev Active (e : E) : Prop := keep (C.source e) ∧ keep (C.source (C.flip e))
+lemma active_flip (e : E) : Active C keep (C.flip e) ↔ Active C keep e := by
+  simp only [Active,C.flip_inv e,and_comm]
+def flip (e : {e // Active C keep e}) : {e // Active C keep e} :=
+  ⟨C.flip e.val,(active_flip C keep e.val).mpr e.property⟩
+lemma flip_inv : Function.Involutive (flip C keep) := by
+  intro e
+  apply Subtype.ext
+  exact C.flip_inv e.val
+lemma flip_ne (e : {e // Active C keep e}) : flip C keep e≠e := by
+  intro h
+  exact C.flip_ne e.val (congrArg Subtype.val h)
+
+def partner (x : Position (Length keep (len:=len))) : Position (Length keep (len:=len)) :=
+  if h : keep (C.pairing.partner (embed keep x)).1 then
+    liftPosition keep (C.pairing.partner (embed keep x)) h else x
+lemma partner_image_yes (x : Position (Length keep (len:=len)))
+    (h : keep (C.pairing.partner (embed keep x)).1) :
+    embed keep (partner C keep x)=C.pairing.partner (embed keep x) := by
+  simp only [partner,dite_eq_left h,embed_local]
+lemma partner_no (x : Position (Length keep (len:=len)))
+    (h : ¬keep (C.pairing.partner (embed keep x)).1) : partner C keep x=x := by
+  simp only [partner,dite_eq_right h]
+lemma partner_inv : Function.Involutive (partner C keep) := by
+  intro x
+  by_cases h : keep (C.pairing.partner (embed keep x)).1
+  · have hh : keep (C.pairing.partner (embed keep (partner C keep x))).1 := by
+      rw [partner_image_yes C keep x h,C.pairing.involutive]
+      exact x.1.property
+    apply embed_injective keep
+    rw [partner_image_yes C keep _ hh,partner_image_yes C keep x h,C.pairing.involutive]
+  · rw [partner_no C keep x h,partner_no C keep x h]
+
+/-- Drop comparisons exactly when either whole path has been deleted. -/
+def side (x : Position (Length keep (len:=len))) : Option {e // Active C keep e} :=
+  match C.side (embed keep x) with
+  | none => none
+  | some e => if h : Active C keep e then some ⟨e,h⟩ else none
+lemma side_some (x : Position (Length keep (len:=len))) (e : {e // Active C keep e}) :
+    side C keep x=some e ↔ C.side (embed keep x)=some e.val := by
+  unfold side
+  cases h : C.side (embed keep x) with
+  | none => simp
+  | some f =>
+    by_cases hf : Active C keep f
+    · simp only [dite_eq_left hf,Option.some.injEq,Subtype.ext_iff]
+    · simp only [dite_eq_right hf,reduceCtorEq,false_iff,Option.some.injEq]
+      intro he; subst f; exact hf e.property
+lemma partner_image_of_side {x : Position (Length keep (len:=len))} {e : {e // Active C keep e}}
+    (he : side C keep x=some e) : embed keep (partner C keep x)=C.pairing.partner (embed keep x) := by
+  apply partner_image_yes
+  rw [C.partner_source _ _ ((side_some C keep x e).mp he)]
+  exact e.property.2
+lemma side_none (x : Position (Length keep (len:=len))) : side C keep x=none ↔ partner C keep x=x := by
+  constructor
+  · intro hs
+    by_cases hk : keep (C.pairing.partner (embed keep x)).1
+    · apply embed_injective keep
+      rw [partner_image_yes C keep x hk]
+      apply (C.none_iff _).mp
+      cases he : C.side (embed keep x) with
+      | none => rfl
+      | some e =>
+        have ha : Active C keep e := by
+          constructor
+          · rw [←((C.side_iff _ _).mp he).1]; exact x.1.property
+          · rwa [←C.partner_source _ _ he]
+        have hh := (side_some C keep x ⟨e,ha⟩).mpr he
+        rw [hs] at hh
+        cases hh
+    · exact partner_no C keep x hk
+  · intro hp
+    cases hs : side C keep x with
+    | none => rfl
+    | some e =>
+      have hh := partner_image_of_side C keep hs
+      rw [hp] at hh
+      have hn := (C.none_iff _).mpr hh.symm
+      have he := (side_some C keep x e).mp hs
+      rw [hn] at he
+      cases he
+
+def comparisons : Comparisons (E:={e // Active C keep e}) (Length keep (len:=len)) where
+  pairing := ⟨partner C keep,partner_inv C keep⟩
+  side := side C keep
+  flip := flip C keep
+  flip_inv := flip_inv C keep
+  flip_ne := flip_ne C keep
+  side_partner := by
+    intro x e he
+    apply (side_some C keep _ _).mpr
+    rw [partner_image_of_side C keep he]
+    exact C.side_partner _ _ ((side_some C keep x e).mp he)
+  none_iff := side_none C keep
+  source e := ⟨C.source e.val,e.property.1⟩
+  lo e := C.lo e.val
+  hi e := C.hi e.val
+  reverse e := C.reverse e.val
+  offset e := C.offset e.val
+  side_iff := by
+    intro x e
+    rw [side_some,C.side_iff]
+    simp only [Subtype.ext_iff]
+    rfl
+  partner_source := by
+    intro x e he
+    apply Subtype.ext
+    have hh := congrArg Sigma.fst (partner_image_of_side C keep he)
+    exact hh.trans (C.partner_source _ _ ((side_some C keep x e).mp he))
+  partner_coordinate := by
+    intro x e he
+    have hh := congrArg (fun x : Position len => x.2.val) (partner_image_of_side C keep he)
+    exact hh.trans (C.partner_coordinate _ _ ((side_some C keep x e).mp he))
+  target_range e := C.target_range e.val
+
+/-- A new fixed position was either already fixed or points to a deleted path.
+This is an exact dichotomy of literal occurrence indices. -/
+lemma fixed_iff (x : Position (Length keep (len:=len))) :
+    partner C keep x=x ↔ C.pairing.partner (embed keep x)=embed keep x ∨
+      ¬keep (C.pairing.partner (embed keep x)).1 := by
+  constructor
+  · intro hx
+    by_cases h : keep (C.pairing.partner (embed keep x)).1
+    · left
+      have hh := partner_image_yes C keep x h
+      rw [hx] at hh
+      exact hh.symm
+    · exact Or.inr h
+  · rintro (h|h)
+    · apply embed_injective keep
+      have hk : keep (C.pairing.partner (embed keep x)).1 := by rw [h]; exact x.1.property
+      rw [partner_image_yes C keep x hk,h]
+    · exact partner_no C keep x h
+
+variable [Fintype T]
+lemma deleted_partner_card :
+    (Finset.univ.filter (fun x : Position (Length keep (len:=len)) =>
+      ¬keep (C.pairing.partner (embed keep x)).1)).card ≤
+      (Finset.univ.filter (fun x : Position len => ¬keep x.1)).card := by
+  apply Finset.card_le_card_of_injOn (fun x => C.pairing.partner (embed keep x))
+  · intro x hx
+    exact Finset.mem_filter.mpr ⟨Finset.mem_univ _,(Finset.mem_filter.mp hx).2⟩
+  · intro x _ y _ h
+    apply embed_injective keep
+    have hi : Function.Injective C.pairing.partner := C.pairing.involutive.injective
+    exact hi h
+lemma old_fixed_card :
+    (Finset.univ.filter (fun x : Position (Length keep (len:=len)) =>
+      C.pairing.partner (embed keep x)=embed keep x)).card ≤
+      (Finset.univ.filter (fun x : Position len => C.pairing.partner x=x)).card := by
+  apply Finset.card_le_card_of_injOn (embed keep)
+  · intro x hx
+    exact Finset.mem_filter.mpr ⟨Finset.mem_univ _,(Finset.mem_filter.mp hx).2⟩
+  · intro x _ y _ h
+    exact embed_injective keep h
+lemma fixed_card :
+    (Finset.univ.filter (fun x : Position (Length keep (len:=len)) =>
+      partner C keep x=x)).card ≤
+      (Finset.univ.filter (fun x : Position len => C.pairing.partner x=x)).card+
+      (Finset.univ.filter (fun x : Position len => ¬keep x.1)).card := by
+  have he : (Finset.univ.filter (fun x : Position (Length keep (len:=len)) => partner C keep x=x))=
+      (Finset.univ.filter (fun x : Position (Length keep (len:=len)) => C.pairing.partner (embed keep x)=embed keep x)) ∪
+      (Finset.univ.filter (fun x : Position (Length keep (len:=len)) => ¬keep (C.pairing.partner (embed keep x)).1)) := by
+    ext x
+    simp only [Finset.mem_filter,Finset.mem_univ,true_and,Finset.mem_union,fixed_iff]
+  rw [he]
+  exact (Finset.card_union_le _ _).trans (add_le_add (old_fixed_card C keep) (deleted_partner_card C keep))
+lemma deleted_nonfixed_partner_card :
+    (Finset.univ.filter (fun x : Position (Length keep (len:=len)) =>
+      ¬keep (C.pairing.partner (embed keep x)).1)).card ≤
+      (Finset.univ.filter (fun x : Position len => ¬keep x.1 ∧ C.pairing.partner x≠x)).card := by
+  apply Finset.card_le_card_of_injOn (fun x => C.pairing.partner (embed keep x))
+  · intro x hx
+    have hd := (Finset.mem_filter.mp hx).2
+    refine Finset.mem_filter.mpr ⟨Finset.mem_univ _,hd,?_⟩
+    intro hf
+    rw [C.pairing.involutive] at hf
+    change embed keep x=C.pairing.partner (embed keep x) at hf
+    rw [←hf] at hd
+    exact hd x.1.property
+  · intro x _ y _ h
+    apply embed_injective keep
+    exact C.pairing.involutive.injective h
+lemma fixed_card_sharp :
+    (Finset.univ.filter (fun x : Position (Length keep (len:=len)) =>
+      partner C keep x=x)).card ≤
+      (Finset.univ.filter (fun x : Position len => C.pairing.partner x=x)).card+
+      (Finset.univ.filter (fun x : Position len => ¬keep x.1 ∧ C.pairing.partner x≠x)).card := by
+  have he : (Finset.univ.filter (fun x : Position (Length keep (len:=len)) => partner C keep x=x))=
+      (Finset.univ.filter (fun x : Position (Length keep (len:=len)) => C.pairing.partner (embed keep x)=embed keep x)) ∪
+      (Finset.univ.filter (fun x : Position (Length keep (len:=len)) => ¬keep (C.pairing.partner (embed keep x)).1)) := by
+    ext x
+    simp only [Finset.mem_filter,Finset.mem_univ,true_and,Finset.mem_union,fixed_iff]
+  rw [he]
+  exact (Finset.card_union_le _ _).trans (add_le_add (old_fixed_card C keep) (deleted_nonfixed_partner_card C keep))
+end TorsionFreeZeroDivisors.RestrictComparisons
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/GroupRing/SidePins.lean b/lean/OAI/Algebra/GroupRing/SidePins.lean
new file mode 100644
index 0000000000000000000000000000000000000000..db0f3dc38c4d0eed73ad7ae95a73ecd757ffd6d5
--- /dev/null
+++ b/lean/OAI/Algebra/GroupRing/SidePins.lean
@@ -0,0 +1,631 @@
+import Mathlib
+import OAI.Algebra.GroupRing.PartitionEntropy
+
+namespace OAI
+
+noncomputable section
+
+namespace TorsionFreeZeroDivisors.SidePins
+open scoped Classical BigOperators
+variable {V TA TB : Type*} [Fintype V] (side : V → Bool)
+
+/-- The optional first-stage root split by prescribed side. -/
+def root (r : Option V) (b : Bool) : Option {v : V // side v=b} :=
+  r.bind fun v => if h : side v=b then some ⟨v,h⟩ else none
+
+omit [Fintype V] in
+lemma root_none (b : Bool) : root side none b=none := rfl
+omit [Fintype V] in
+lemma root_some (v : V) : root side (some v) (side v)=some ⟨v,rfl⟩ := by
+  simp [root]
+
+omit [Fintype V] in
+lemma root_save (r : Option V) :
+    (if (root side r true).isSome then (1:ℤ) else 0) +
+      (if (root side r false).isSome then (1:ℤ) else 0) = if r.isSome then 1 else 0 := by
+  cases r with
+  | none => rfl
+  | some v => cases hs : side v <;> simp [root,hs]
+
+lemma free_total (r : Option V) (a : TA) (b : TB) :
+    (RootPins.free (root side r true) a : ℤ) + (RootPins.free (root side r false) b : ℤ) =
+      Fintype.card V - if r.isSome then 1 else 0 := by
+  rw [RootPins.free_cast,RootPins.free_cast]
+  have hc := StageSideEmbedding.vertex_card side
+  change Fintype.card {v : V // side v=true}+Fintype.card {v : V // side v=false}=Fintype.card V at hc
+  have hc' := congrArg (fun n : ℕ => (n:ℤ)) hc
+  simp only [Nat.cast_add] at hc'
+  have hr := root_save side r
+  omega
+
+omit [Fintype V] in
+lemma respects {r : Option V} {a : TA} (b : Bool) (f : V → TA)
+    (h : ∀ v,r=some v → f v=a) :
+    ∀ v y,RootPins.pin (root side r b) a v=some y → f v.val=y := by
+  apply RootPins.respects
+  intro v hv
+  cases r with
+  | none => cases hv
+  | some w =>
+    dsimp only [root,Option.bind_some] at hv
+    split_ifs at hv with hw
+    · have hval : w=v.val := congrArg Subtype.val (Option.some.inj hv)
+      exact h v.val (by rw [←hval])
+
+end TorsionFreeZeroDivisors.SidePins
+
+namespace TorsionFreeZeroDivisors.StageRoot
+open scoped Classical BigOperators
+open PortSubdivision ChainSuppression DegreeTwoSuppression SuppressedMoore ChainPaths
+open ChainIsomorphism ChainChunkTransport ChainMultiplicity ChunkComparisons FiniteChunking StageSubgraphs
+variable {V D P : Type} [Fintype V] [Fintype D] [Fintype P]
+    (Γ : PortGraph V D) (mark : V → Prop) (h2 : ∀ v,¬mark v → (out Γ.origin v).card=2)
+    (paths : P → List {d : D // turn Γ.origin mark h2 d=d}) (hp : ∀ p,paths p≠[])
+local notation "S" => suppressed Γ mark h2
+local notation "mult" => ListStageExponents.mult (S) paths
+local notation "R" => ChainIsomorphism.Rep Γ mark h2
+local notation "m" => ChunkComparisons.multiplicity (color Γ mark h2 paths)
+
+/-- The possible interval is designated once, not independently at each stage. -/
+def cyclic (root : Option P) (p : P) : Bool := decide (root≠some p)
+
+omit [Fintype V] [Fintype D] in
+lemma intervals_card (root : Option P) :
+    (Fintype.card {p : P // cyclic root p=false}:ℤ) = if root.isSome then 1 else 0 := by
+  cases root with
+  | none => simp [cyclic]
+  | some p => simp [cyclic]
+
+/-- Only the first stage fixes the marked initial vertex. -/
+def vertex (root : Option P) (j : ℕ) : Option (ActiveV (S) mult j) :=
+  if h : j=0 then by
+    subst j
+    exact root.map (ActiveRoot.vertex (S) paths hp)
+  else none
+
+omit [Fintype V] in
+lemma vertex_isSome (root : Option P) (j : ℕ) :
+    (vertex Γ mark h2 paths hp root j).isSome = if j=0 then root.isSome else false := by
+  unfold vertex
+  split_ifs with hj
+  · subst j
+    simp
+  · rfl
+
+/-- The root split over the two prescribed sides has exactly the source saving. -/
+def power (side : ∀ j, ActiveV (S) mult j → Bool) (root : Option P)
+    {TA TB : Type} (a : TA) (b : TB) (j : ℕ) : ℤ :=
+  (RootPins.free (SidePins.root (side j) (vertex Γ mark h2 paths hp root j) true) a : ℤ)+
+  (RootPins.free (SidePins.root (side j) (vertex Γ mark h2 paths hp root j) false) b : ℤ)-
+    Fintype.card (ChainActiveStages.ActiveChain Γ mark h2 paths j)
+
+lemma power_eq (side : ∀ j, ActiveV (S) mult j → Bool) (root : Option P)
+    {TA TB : Type} (a : TA) (b : TB) (j : ℕ) :
+    power Γ mark h2 paths hp side root a b j =
+      (Fintype.card (ActiveV (S) mult j):ℤ)-Fintype.card (ChainActiveStages.ActiveChain Γ mark h2 paths j)-
+        if j=0 then (Fintype.card {p : P // cyclic root p=false}:ℤ) else 0 := by
+  unfold power
+  rw [SidePins.free_total,vertex_isSome]
+  by_cases hj : j=0
+  · simp only [hj,ite_true,intervals_card]
+    ring
+  · simp [hj]
+
+theorem power_nonpos (side : ∀ j, ActiveV (S) mult j → Bool) (root : Option P)
+    {TA TB : Type} (a : TA) (b : TB)
+    (hc : ∀ i,(paths i).IsChain (WeightedMoore.PortWalk.step (S).origin (S).reverse))
+    (hclose : ∀ i,cyclic root i=true → ∀ᵉ (x∈(paths i).getLast?) (y∈(paths i).head?),
+      WeightedMoore.PortWalk.step (S).origin (S).reverse x y)
+    (M : ℕ) (hM : 0<M) (hm : ∀ c : R,m c≤M) :
+    (∑ j : Fin M, (power Γ mark h2 paths hp side root a b j.val : ℝ)) ≤ 0 := by
+  have hz := ChainActiveStages.exponent_nonpos Γ mark h2 paths hp (cyclic root) hc hclose M hM hm
+  have he : (∑ j : Fin M,power Γ mark h2 paths hp side root a b j.val) ≤ 0 := by
+    simpa [power_eq,ListStageExponents.mult] using hz
+  exact_mod_cast he
+
+end TorsionFreeZeroDivisors.StageRoot
+
+namespace TorsionFreeZeroDivisors.RootPins
+open scoped Classical
+variable {V T : Type*}
+lemma pin_some_iff (root : Option V) (target : T) (v : V) (y : T) :
+    pin root target v=some y ↔ root=some v ∧ target=y := by
+  unfold pin
+  split_ifs with h <;> simp [h]
+end TorsionFreeZeroDivisors.RootPins
+
+namespace TorsionFreeZeroDivisors.SidePins
+open scoped Classical
+variable {V : Type*} (side : V → Bool)
+lemma root_eq_some (r : Option V) (b : Bool) (v : {v : V // side v=b}) :
+    root side r b=some v ↔ r=some v.val := by
+  cases r with
+  | none => simp [root]
+  | some w =>
+    dsimp only [root,Option.bind_some]
+    split_ifs with hw
+    · simp only [Option.some.injEq]
+      exact Subtype.ext_iff
+    · simp only [false_iff,Option.some.injEq]
+      intro h
+      subst w
+      exact hw v.property
+end TorsionFreeZeroDivisors.SidePins
+
+namespace TorsionFreeZeroDivisors.StageRoot
+open scoped Classical
+open PortSubdivision ChainSuppression DegreeTwoSuppression SuppressedMoore ChainPaths
+open ChainIsomorphism ChainChunkTransport ChainMultiplicity ChunkComparisons FiniteChunking StageSubgraphs
+variable {V D P : Type} [Fintype D] [Fintype P]
+    (Γ : PortGraph V D) (mark : V → Prop) (h2 : ∀ v,¬mark v → (out Γ.origin v).card=2)
+    (paths : P → List {d : D // turn Γ.origin mark h2 d=d}) (hp : ∀ p,paths p≠[])
+local notation "S" => suppressed Γ mark h2
+local notation "mult" => ListStageExponents.mult (S) paths
+
+/-- The actual marked initial vertex of the designated interval, if any. -/
+def source (r : Option P) : Option V := r.map fun p => (S).origin ((paths p).head (hp p))
+
+lemma vertex_source (r : Option P) (j : ℕ) (v : ActiveV (S) mult j)
+    (h : vertex Γ mark h2 paths hp r j=some v) : source Γ mark h2 paths hp r=some v.val := by
+  unfold vertex at h
+  split_ifs at h with hj
+  subst j
+  rcases Option.map_eq_some_iff.mp h with ⟨p,hp',hv⟩
+  subst r
+  dsimp only [source,Option.map_some]
+  have hval := congrArg Subtype.val hv
+  rw [ActiveRoot.vertex_val] at hval
+  exact congrArg some hval
+
+variable (side : V → Bool)
+lemma pin_compatible (r : Option P) {T : Type} (target : T) (b : Bool) (j : ℕ)
+    (v : {v : ActiveV (S) mult j // ChainSide.vertex Γ mark h2 side paths j v=b}) (y : T)
+    (h : RootPins.pin
+      (SidePins.root (ChainSide.vertex Γ mark h2 side paths j) (vertex Γ mark h2 paths hp r j) b)
+      target v=some y) :
+    RootPins.pin (SidePins.root side (source Γ mark h2 paths hp r) b) target
+      ⟨v.val.val,v.property⟩=some y := by
+  rw [RootPins.pin_some_iff] at h ⊢
+  refine ⟨?_,h.2⟩
+  rw [SidePins.root_eq_some] at h
+  rw [SidePins.root_eq_some]
+  exact vertex_source Γ mark h2 paths hp r j v.val h.1
+
+end TorsionFreeZeroDivisors.StageRoot
+
+namespace TorsionFreeZeroDivisors.ActualStagePair
+open scoped Classical BigOperators
+open PortSubdivision ChainSuppression DegreeTwoSuppression SuppressedMoore ChainPaths ChainIsomorphism
+open ChainChunkTransport ChunkComparisons FiniteChunking StageSubgraphs StageSideEmbedding
+open ComparedBlocks RepeatedBlocks
+local instance : DecidableEq Types.Letter := Classical.decEq _
+variable {V D P : Type} [Fintype V] [Fintype D] [Fintype P]
+    (Γ : PortGraph V D) (mark : V → Prop) (h2 : ∀ v,¬mark v → (out Γ.origin v).card=2)
+    (side : V → Bool) (hsid : ∀ d,side (Γ.origin (Γ.reverse d))=side (Γ.origin d))
+    (paths : P → List {d : D // turn Γ.origin mark h2 d=d}) (hp : ∀ p,paths p≠[])
+    (root : Option P) (rep : ℕ) (a : Types.VertexA rep) (b : Types.VertexB rep)
+local notation "R" => Rep Γ mark h2
+local notation "m" => ChunkComparisons.multiplicity (color Γ mark h2 paths)
+local notation "len" => repLength Γ mark h2
+local notation "cs" => ChainSide.chain Γ mark h2 side
+local notation "vs" => ChainSide.vertex Γ mark h2 side paths
+local notation "first" => ChainActiveStages.first Γ mark h2 paths
+local notation "last" => ChainActiveStages.last Γ mark h2 paths
+local notation "hf" => ChainSide.active_first Γ mark h2 side paths
+local notation "hl" => ChainSide.active_last Γ mark h2 side hsid paths
+
+abbrev pinA (j : ℕ) := RootPins.pin (SidePins.root (vs j) (StageRoot.vertex Γ mark h2 paths hp root j) true) a
+abbrev pinB (j : ℕ) := RootPins.pin (SidePins.root (vs j) (StageRoot.vertex Γ mark h2 paths hp root j) false) b
+
+abbrev A (j : ℕ) : TwoSideStage.Side :=
+  StagePartition.sideA len m cs j
+    (firstPoint m j cs (vs j) (first j) (hf j) true)
+    (lastPoint m j cs (vs j) (last j) (hl j) true)
+    (@Types.outgoingA rep) (pinA Γ mark h2 side paths hp root rep a j)
+
+abbrev B (j : ℕ) : TwoSideStage.Side :=
+  StagePartition.sideB len m cs j
+    (firstPoint m j cs (vs j) (first j) (hf j) false)
+    (lastPoint m j cs (vs j) (last j) (hl j) false)
+    (@Types.outgoingB rep) (pinB Γ mark h2 side paths hp root rep b j)
+local notation "SA" => A Γ mark h2 side hsid paths hp root rep a
+local notation "SB" => B Γ mark h2 side hsid paths hp root rep b
+
+lemma power_eq (j : ℕ) :
+    (((SA j).freeMarks+(SB j).freeMarks:ℕ):ℝ)-
+      (Fintype.card (SA j).C+Fintype.card (SB j).C:ℕ) =
+        (StageRoot.power Γ mark h2 paths hp vs root a b j:ℝ) := by
+  have hc := StageSideEmbedding.chain_card m j cs
+  unfold StageRoot.power
+  dsimp only [TwoSideStage.Side.freeMarks,A,B,StagePartition.sideA,StagePartition.sideB]
+  rw [Int.cast_sub,Int.cast_add,Int.cast_natCast,Int.cast_natCast,Int.cast_natCast,
+    Nat.cast_add,←hc]
+  rfl
+
+lemma edges_eq (j : ℕ) : (SA j).edges+(SB j).edges =
+    ∑ c : {c : R // j < m c},len c.val := by
+  change (∑ c : {c : R // j < m c ∧ cs c=true},len c.val)+
+    (∑ c : {c : R // j < m c ∧ cs c=false},len c.val)=_
+  rw [← Finset.sum_subtype (Finset.univ.filter fun c => j < m c ∧ cs c=true) (by simp),
+    ← Finset.sum_subtype (Finset.univ.filter fun c => j < m c ∧ cs c=false) (by simp),
+    ← Finset.sum_subtype (Finset.univ.filter fun c => j < m c) (by simp)]
+  simp only [Finset.sum_filter]
+  rw [← Finset.sum_add_distrib]
+  apply Finset.sum_congr rfl
+  intro c _
+  cases cs c <;> simp
+
+lemma edges_bound (j : ℕ) : ((SA j).edges+(SB j).edges:ℝ) ≤ StageMass.totalLength len m := by
+  rw [← Nat.cast_add,edges_eq,StageMass.totalLength_eq]
+  rw [← Finset.sum_subtype (Finset.univ.filter fun c => j < m c) (by simp)]
+  push_cast
+  rw [Finset.sum_filter]
+  apply Finset.sum_le_sum
+  intro c _
+  split_ifs with hc
+  · have h : (1:ℝ) ≤ m c := by exact_mod_cast (show 1 ≤ m c by omega)
+    nlinarith [show (0:ℝ) ≤ len c from Nat.cast_nonneg (len c)]
+  · positivity
+
+variable {E : Type}
+
+def count (s : ℝ) (cmp : Comparisons (E:=E) (traversalLength len m))
+    (d : Underlying s len → ℤ) (j : ℕ) : (SA j).Match × (SB j).Match → ℕ :=
+  TwoSideStage.count (SA j) (SB j) (ChainStageLabels.fullWords s len m j cmp d)
+    (StagePartition.restrictA len m cs j) (StagePartition.restrictB len m cs j)
+
+/-- Restricting actual embeddings on the two prescribed sides witnesses the
+joint stage count, with a SINGLE global label projection. -/
+theorem count_pos (s : ℝ) (cmp : Comparisons (E:=E) (traversalLength len m))
+    (d : Underlying s len → ℤ) (j : ℕ) (label : D → Types.Letter)
+    (hlabel : ∀ x,label (Γ.reverse x)=Types.inverse (label x))
+    (pinA' : SideRestriction.Vertex side true → Option (Types.VertexA rep))
+    (pinB' : SideRestriction.Vertex side false → Option (Types.VertexB rep))
+    (r : (SA j).Match × (SB j).Match)
+    (eA : RealizationTransport.Embedding (SideRestriction.graph Γ side hsid true)
+      (fun x => label x.val) (@Types.outgoingA rep) pinA' Types.inverse r.1)
+    (eB : RealizationTransport.Embedding (SideRestriction.graph Γ side hsid false)
+      (fun x => label x.val) (@Types.outgoingB rep) pinB' Types.inverse r.2)
+    (hpa : ∀ v y,pinA Γ mark h2 side paths hp root rep a j v=some y → pinA' ⟨v.val.val,v.property⟩=some y)
+    (hpb : ∀ v y,pinB Γ mark h2 side paths hp root rep b j v=some y → pinB' ⟨v.val.val,v.property⟩=some y)
+    (hw : ActualStageRealization.word Γ mark h2 paths j label ∈ ChainStageLabels.fullWords s len m j cmp d) :
+    0<count Γ mark h2 side hsid paths hp root rep a b s cmp d j r := by
+  exact TwoSideStage.count_pos (SA j) (SB j) _ _ _ r _ hw
+    (ActualSideRealization.embedding Γ mark h2 side hsid paths j true label _ pinA' r.1 eA hlabel _ hpa)
+    (ActualSideRealization.embedding Γ mark h2 side hsid paths j false label _ pinB' r.2 eB hlabel _ hpb)
+
+/-- The actual rooted, mixed-side stage first moment, with its exact signed
+vertex exponent and the source's common denominator loss. -/
+theorem mean_bound (s : ℝ) (cmp : Comparisons (E:=E) (traversalLength len m))
+    (d : Underlying s len → ℤ) (hs : 0<s) (j err K Q : ℕ)
+    (hlarge : ∀ i,3002≤height s len i)
+    (hscale : ∀ i,s+1200≤2*(height s len i:ℝ))
+    (hreduced : ∀ x e,cmp.side x=some e →
+      (x.1.1,x.2.val)≠((cmp.pairing.partner x).1.1,(cmp.pairing.partner x).2.val))
+    (hn : 0<TypedGraphs.size rep)
+    (hr : K*GirthAsymptotics.L (TypedGraphs.size rep)+GirthAsymptotics.exclusion (TypedGraphs.size rep)<
+      StageDenominator.carrier rep)
+    (hQ : Fintype.card R≤Q)
+    (hH : StageMass.totalLength len m ≤ K*(GirthAsymptotics.L (TypedGraphs.size rep):ℝ)) :
+    TwoSideMean.mean (((SA j).samples (3*GirthAsymptotics.L (TypedGraphs.size rep))) ×ˢ
+      ((SB j).samples (3*GirthAsymptotics.L (TypedGraphs.size rep))))
+      (count Γ mark h2 side hsid paths hp root rep a b s cmp d j) ≤
+    Real.exp ((StageRoot.power Γ mark h2 paths hp vs root a b j:ℝ)*Real.log (TypedGraphs.size rep)+
+      StageEntropy.labelCost s hs len m cmp err d j+StageEntropy.looseCost s len err+
+        StageDenominator.error K Q rep) := by
+  have hE : (SA j).edges+(SB j).edges ≤ K*GirthAsymptotics.L (TypedGraphs.size rep) := by
+    exact_mod_cast (edges_bound Γ mark h2 side hsid paths hp root rep a b j).trans hH
+  have hA := StageDenominator.conditionsA K rep hr (SA j).len (SA j).first (SA j).last (SA j).pin
+    ((Nat.le_add_right _ _).trans hE)
+  have hB := StageDenominator.conditionsB K rep hr (SB j).len (SB j).first (SB j).last (SB j).pin
+    ((Nat.le_add_left _ _).trans hE)
+  have hq : Fintype.card (StagePartition.CA m cs j)+Fintype.card (StagePartition.CB m cs j)≤Q := by
+    rw [StageSideEmbedding.chain_card]
+    apply le_trans _ hQ
+    exact Fintype.card_le_of_injective Subtype.val Subtype.val_injective
+  have h := PartitionEntropy.mean_bound s hs len m cs j
+    (SA j).first (SA j).last (SB j).first (SB j).last
+    (@Types.outgoingA rep) (@Types.outgoingB rep) (SA j).pin (SB j).pin cmp d err K Q rep
+    hlarge hscale hreduced hn (Nat.sub_pos_of_lt hr) hA hB
+    (fun c => chainLength_pos Γ mark h2 c.val) hq hE
+  change TwoSideMean.mean _ (count Γ mark h2 side hsid paths hp root rep a b s cmp d j) ≤
+    Real.exp (((((SA j).freeMarks+(SB j).freeMarks:ℕ):ℝ)-
+      (Fintype.card (SA j).C+Fintype.card (SB j).C:ℕ))*Real.log (TypedGraphs.size rep)+
+      StageEntropy.labelCost s hs len m cmp err d j+StageEntropy.looseCost s len err+
+        StageDenominator.error K Q rep) at h
+  rw [power_eq] at h
+  exact h
+
+end TorsionFreeZeroDivisors.ActualStagePair
+
+namespace TorsionFreeZeroDivisors.ActualPatternEvent
+open scoped Classical BigOperators
+open PortSubdivision ChainSuppression DegreeTwoSuppression SuppressedMoore ChainPaths ChainIsomorphism
+open ChainChunkTransport ChunkComparisons FiniteChunking StageSubgraphs StageSideEmbedding
+open ComparedBlocks RepeatedBlocks
+local instance : DecidableEq Types.Letter := Classical.decEq _
+private lemma mem_profiles_iff {C : Type*} [Fintype C] (s : ℝ) (len : C → ℕ)
+    (d : Underlying s len → ℤ) :
+    d∈BinProfiles.profiles s len ↔ ∀ i,d i∈BinProfiles.values s := by
+  unfold BinProfiles.profiles
+  exact Fintype.mem_piFinset
+
+variable {V D P E : Type} [Fintype V] [Fintype D] [Fintype P]
+    (Γ : PortGraph V D) (mark : V → Prop) (h2 : ∀ v,¬mark v → (out Γ.origin v).card=2)
+    (side : V → Bool) (hsid : ∀ x,side (Γ.origin (Γ.reverse x))=side (Γ.origin x))
+    (paths : P → List {x : D // turn Γ.origin mark h2 x=x}) (hp : ∀ p,paths p≠[])
+    (root : Option P) (rep : ℕ) (a : Types.VertexA rep) (b : Types.VertexB rep)
+local notation "R" => Rep Γ mark h2
+local notation "m" => ChunkComparisons.multiplicity (color Γ mark h2 paths)
+local notation "len" => repLength Γ mark h2
+local notation "vs" => ChainSide.vertex Γ mark h2 side paths
+local notation "SA" => ActualStagePair.A Γ mark h2 side hsid paths hp root rep a
+local notation "SB" => ActualStagePair.B Γ mark h2 side hsid paths hp root rep b
+
+abbrev Match (rep : ℕ) :=
+  ConditionedMatchings.Matching (PatternEmbeddings.label (@Types.outgoingA rep)) Types.inverse ×
+  ConditionedMatchings.Matching (PatternEmbeddings.label (@Types.outgoingB rep)) Types.inverse
+
+def samples (rep : ℕ) : Finset (Match rep) :=
+  ConditionedMatchings.Matching.conditioned (label:=PatternEmbeddings.label (@Types.outgoingA rep))
+    (bar:=Types.inverse) (PatternEmbeddings.origin (@Types.outgoingA rep))
+    (3*GirthAsymptotics.L (TypedGraphs.size rep)) ∅ ×ˢ
+  ConditionedMatchings.Matching.conditioned (label:=PatternEmbeddings.label (@Types.outgoingB rep))
+    (bar:=Types.inverse) (PatternEmbeddings.origin (@Types.outgoingB rep))
+    (3*GirthAsymptotics.L (TypedGraphs.size rep)) ∅
+
+lemma samples_eq (j : ℕ) : samples rep =
+    (SA j).samples (3*GirthAsymptotics.L (TypedGraphs.size rep)) ×ˢ
+      (SB j).samples (3*GirthAsymptotics.L (TypedGraphs.size rep)) := by
+  ext r
+  dsimp only [ActualStagePair.A,ActualStagePair.B,StagePartition.sideA,StagePartition.sideB,
+    TwoSideStage.Side.samples]
+  simp only [samples,ConditionedMatchings.Matching.conditioned,
+    Finset.mem_product,Finset.mem_filter,Finset.mem_univ,true_and]
+  erw [Finset.mem_product]
+  simp only [Finset.mem_filter,Finset.mem_univ,true_and]
+
+abbrev sourcePinA := RootPins.pin
+  (SidePins.root side (StageRoot.source Γ mark h2 paths hp root) true) a
+abbrev sourcePinB := RootPins.pin
+  (SidePins.root side (StageRoot.source Γ mark h2 paths hp root) false) b
+
+/-- Literal realization of an enlarged fixed pattern and its bin profile.
+The prescribed-side embeddings are into the actual two independent matchings.
+The comparisons refer to normalized traversals of the same suppressed graph. -/
+def Occurs (s : ℝ) (cmp : Comparisons (E:=E) (traversalLength len m))
+    (d : Underlying s len → ℤ) (r : Match rep) : Prop :=
+  ∃ label : D → Types.Letter,
+    (∀ x,label (Γ.reverse x)=Types.inverse (label x)) ∧
+    (∀ x y,Γ.origin x=Γ.origin y → label x=label y → x=y) ∧
+    ActualStageLabels.Comparing len m cmp (ActualStageFeasibility.globalWord Γ mark h2 label) ∧
+    ActualStageFeasibility.bins s len (ActualStageFeasibility.globalWord Γ mark h2 label)=d ∧
+    Nonempty (RealizationTransport.Embedding (SideRestriction.graph Γ side hsid true)
+      (fun x => label x.val) (@Types.outgoingA rep)
+      (sourcePinA Γ mark h2 side paths hp root rep a) Types.inverse r.1) ∧
+    Nonempty (RealizationTransport.Embedding (SideRestriction.graph Γ side hsid false)
+      (fun x => label x.val) (@Types.outgoingB rep)
+      (sourcePinB Γ mark h2 side paths hp root rep b) Types.inverse r.2)
+
+/-- Existence of the actual pattern witnesses every stage count. This does
+not posit simultaneous independence of the chain-multiplicity stages. -/
+theorem count_pos (s : ℝ) (hs : 0<s) (cmp : Comparisons (E:=E) (traversalLength len m))
+    (d : Underlying s len → ℤ) (r : Match rep)
+    (hr : Occurs Γ mark h2 side hsid paths hp root rep a b s cmp d r) (j : ℕ) :
+    0<ActualStagePair.count Γ mark h2 side hsid paths hp root rep a b s cmp d j r := by
+  rcases hr with ⟨label,hl,hi,hc,hd,⟨eA⟩,⟨eB⟩⟩
+  apply ActualStagePair.count_pos Γ mark h2 side hsid paths hp root rep a b s cmp d j label hl
+    _ _ r eA eB
+    (StageRoot.pin_compatible Γ mark h2 paths hp side root a true j)
+    (StageRoot.pin_compatible Γ mark h2 paths hp side root b false j)
+  have hw := ActualStageFeasibility.fullWords_of_comparing s len m cmp j
+    (ActualStageFeasibility.globalWord Γ mark h2 label) hc
+    (ActualStageFeasibility.immersed s Γ mark h2 hs label hl hi)
+  rw [hd] at hw
+  exact hw
+
+omit [Fintype V] in
+/-- A realizable bin profile automatically has the universal lower and upper
+weight bounds; those numerical bounds are not extra assumptions on an event. -/
+theorem bin_bounds (s : ℝ) (hs : 0<s) (cmp : Comparisons (E:=E) (traversalLength len m))
+    (d : Underlying s len → ℤ) (r : Match rep)
+    (hr : Occurs Γ mark h2 side hsid paths hp root rep a b s cmp d r)
+    (hlarge : ∀ i,3002≤height s len i)
+    (hscale : ∀ i,s+1200≤2*(height s len i:ℝ))
+    (hscale' : ∀ i,(height s len i:ℝ)≤2*s) :
+    (∀ i,(1/600:ℝ)*s/2≤d i) ∧ (∀ i,(d i:ℝ)≤256*s) := by
+  rcases hr with ⟨label,hl,hi,_hc,hd,_⟩
+  have hb := ActualStageFeasibility.mem_bin s len (ActualStageFeasibility.globalWord Γ mark h2 label)
+    (ActualStageFeasibility.immersed s Γ mark h2 hs label hl hi)
+  rw [hd] at hb
+  have h i := WordEstimate.bin_full_bounds (height s len i) (hlarge i) s (hscale i) (hscale' i)
+    (d i) _ (hb i)
+  exact ⟨fun i => (h i).1,fun i => (h i).2.1⟩
+
+/-- The unbinned event quantifies no artificial stage data: the bin witness is
+forced by the literal label words. -/
+def Unbinned (s : ℝ) (cmp : Comparisons (E:=E) (traversalLength len m))
+    (r : Match rep) : Prop :=
+  ∃ d,Occurs Γ mark h2 side hsid paths hp root rep a b s cmp d r
+
+omit [Fintype V] in
+lemma occurs_profile (s : ℝ) (hs : 3003≤ s)
+    (cmp : Comparisons (E:=E) (traversalLength len m)) (d : Underlying s len → ℤ)
+    (r : Match rep) (hr : Occurs Γ mark h2 side hsid paths hp root rep a b s cmp d r) :
+    d∈BinProfiles.profiles s len := by
+  classical
+  have hh (i : Underlying s len) := BinProfiles.height_bounds s (by linarith) len i
+  have hl (i : Underlying s len) : 3002≤height s len i := by
+    have h : (3002:ℝ)≤height s len i := by linarith [hh i]
+    exact_mod_cast h
+  obtain ⟨hlo,hhi⟩ := bin_bounds Γ mark h2 side hsid paths hp root rep a b s (by linarith)
+    cmp d r hr hl (fun i => by linarith [hh i]) (fun i => by linarith [hh i])
+  apply (mem_profiles_iff s len d).mpr
+  intro i
+  exact Finset.mem_Icc.mpr ⟨by
+    have h : (0:ℝ)≤d i := (by positivity : (0:ℝ)≤(1/600:ℝ)*s/2).trans (hlo i)
+    exact_mod_cast h,Int.le_floor.mpr (hhi i)⟩
+
+omit [Fintype V] in
+lemma unbinned_iff_profile (s : ℝ) (hs : 3003≤ s)
+    (cmp : Comparisons (E:=E) (traversalLength len m)) (r : Match rep) :
+    Unbinned Γ mark h2 side hsid paths hp root rep a b s cmp r ↔
+      ∃ d : {d // d∈BinProfiles.profiles s len},
+        Occurs Γ mark h2 side hsid paths hp root rep a b s cmp d.val r := by
+  constructor
+  · rintro ⟨d,hd⟩
+    exact ⟨⟨d,occurs_profile Γ mark h2 side hsid paths hp root rep a b s hs cmp d r hd⟩,hd⟩
+  · rintro ⟨d,hd⟩
+    exact ⟨d.val,hd⟩
+
+variable [Fintype E]
+
+/-- One genuinely realized fixed-bin pattern is exponentially unlikely.
+All numerical stage bounds are derived from its two literal matching means;
+no independence between multiplicity stages is asserted. -/
+theorem probability_bound (s : ℝ) (hs : 0<s)
+    (cmp : Comparisons (E:=E) (traversalLength len m)) (d : Underlying s len → ℤ)
+    (err K Q M : ℕ) (hM : 0<M) (hm : ∀ c,m c≤M)
+    (hc : ∀ i,(paths i).IsChain (WeightedMoore.PortWalk.step
+      (suppressed Γ mark h2).origin (suppressed Γ mark h2).reverse))
+    (hclose : ∀ i,StageRoot.cyclic root i=true →
+      ∀ᵉ (x∈(paths i).getLast?) (y∈(paths i).head?),
+      WeightedMoore.PortWalk.step (suppressed Γ mark h2).origin (suppressed Γ mark h2).reverse x y)
+    (hlarge : ∀ i,3002≤height s len i)
+    (hscale : ∀ i,s+1200≤2*(height s len i:ℝ))
+    (hscale' : ∀ i,(height s len i:ℝ)≤2*s)
+    (hreduced : ∀ x e,cmp.side x=some e →
+      (x.1.1,x.2.val)≠((cmp.pairing.partner x).1.1,(cmp.pairing.partner x).2.val))
+    (hn : 0<TypedGraphs.size rep)
+    (hr : K*GirthAsymptotics.L (TypedGraphs.size rep)+GirthAsymptotics.exclusion (TypedGraphs.size rep)<
+      StageDenominator.carrier rep)
+    (hQ : Fintype.card R≤Q)
+    (hH : StageMass.totalLength len m ≤ K*(GirthAsymptotics.L (TypedGraphs.size rep):ℝ))
+    (ν : E → ℤ) (hsmall : 2*(err:ℝ)<s-1)
+    (herr : ∀ e,2*|(cmp.offset e:ℝ)-(ν e:ℝ)*s|+4≤err)
+    (hb : (StageMass.uncovered s hs len m cmp err:ℝ) ≤
+      StageFusion.epsilon (1/600) 256*StageMass.totalLength len m)
+    (he : StageMass.residual (E:=E) s len m err M Q (StageDenominator.error K Q rep) ≤
+      StageMass.totalLength len m/4800) :
+    (((samples rep).filter (Occurs Γ mark h2 side hsid paths hp root rep a b s cmp d)).card:ℝ)/
+      (samples rep).card ≤ Real.exp (-StageMass.totalLength len m/(2400*M)) := by
+  by_cases hex : ∃ r,Occurs Γ mark h2 side hsid paths hp root rep a b s cmp d r
+  · rcases hex with ⟨r,hr'⟩
+    obtain ⟨hlow,hhigh⟩ := bin_bounds Γ mark h2 side hsid paths hp root rep a b s hs cmp d
+      r hr' hlarge hscale hscale'
+    have hpw := StageRoot.power_nonpos Γ mark h2 paths hp vs root a b hc hclose M hM hm
+    have hlgn : 0≤Real.log (TypedGraphs.size rep) :=
+      Real.log_nonneg (by exact_mod_cast (show 1≤TypedGraphs.size rep by omega))
+    have hprod := StageMass.decay s hs len m cmp err M Q hm hQ ν hsmall herr d hlow hhigh
+      (Real.log (TypedGraphs.size rep)) (StageDenominator.error K Q rep) hlgn
+      (fun j : Fin M => (StageRoot.power Γ mark h2 paths hp vs root a b j.val:ℝ)) hpw hb he
+    have h := StageFusion.one_pattern (samples rep) M hM
+      (Occurs Γ mark h2 side hsid paths hp root rep a b s cmp d)
+      (fun j : Fin M => ActualStagePair.count Γ mark h2 side hsid paths hp root rep a b s cmp d j.val)
+      (fun j : Fin M => (StageRoot.power Γ mark h2 paths hp vs root a b j.val:ℝ)*
+        Real.log (TypedGraphs.size rep)+StageEntropy.labelCost s hs len m cmp err d j.val+
+          (StageEntropy.looseCost s len err+StageDenominator.error K Q rep))
+      (StageMass.totalLength len m/2400)
+      (fun j r _hr hr' => count_pos Γ mark h2 side hsid paths hp root rep a b s hs cmp d r hr' j.val)
+      (fun j => by
+        have hmom := ActualStagePair.mean_bound Γ mark h2 side hsid paths hp root rep a b
+          s cmp d hs j err K Q hlarge hscale hreduced hn hr hQ hH
+        rw [← samples_eq Γ mark h2 side hsid paths hp root rep a b j] at hmom
+        convert hmom using 1
+        · unfold TwoSideMean.mean
+          congr 1
+        · congr 1; ring)
+      (by simpa only [neg_div] using hprod)
+    convert h using 1
+    congr 1
+    ring
+  · have hf : (samples rep).filter (Occurs Γ mark h2 side hsid paths hp root rep a b s cmp d)=∅ := by
+      ext r
+      simp only [Finset.mem_filter,Finset.notMem_empty,iff_false,not_and]
+      exact fun _ => fun hr' => hex ⟨r,hr'⟩
+    rw [hf,Finset.card_empty,Nat.cast_zero,zero_div]
+    exact (Real.exp_pos _).le
+
+/-- Union over all canonical weight bins of an actual pattern. -/
+theorem unbinned_probability_bound (s : ℝ) (hs : 0<s) (hslarge : 3003≤ s)
+    (cmp : Comparisons (E:=E) (traversalLength len m))
+    (err K Q M : ℕ) (hM : 0<M) (hm : ∀ c,m c≤M)
+    (hc : ∀ i,(paths i).IsChain (WeightedMoore.PortWalk.step
+      (suppressed Γ mark h2).origin (suppressed Γ mark h2).reverse))
+    (hclose : ∀ i,StageRoot.cyclic root i=true →
+      ∀ᵉ (x∈(paths i).getLast?) (y∈(paths i).head?),
+      WeightedMoore.PortWalk.step (suppressed Γ mark h2).origin (suppressed Γ mark h2).reverse x y)
+    (hlarge : ∀ i,3002≤height s len i)
+    (hscale : ∀ i,s+1200≤2*(height s len i:ℝ))
+    (hscale' : ∀ i,(height s len i:ℝ)≤2*s)
+    (hreduced : ∀ x e,cmp.side x=some e →
+      (x.1.1,x.2.val)≠((cmp.pairing.partner x).1.1,(cmp.pairing.partner x).2.val))
+    (hn : 0<TypedGraphs.size rep)
+    (hr : K*GirthAsymptotics.L (TypedGraphs.size rep)+GirthAsymptotics.exclusion (TypedGraphs.size rep)<
+      StageDenominator.carrier rep)
+    (hQ : Fintype.card R≤Q)
+    (hH : StageMass.totalLength len m ≤ K*(GirthAsymptotics.L (TypedGraphs.size rep):ℝ))
+    (ν : E → ℤ) (hsmall : 2*(err:ℝ)<s-1)
+    (herr : ∀ e,2*|(cmp.offset e:ℝ)-(ν e:ℝ)*s|+4≤err)
+    (hb : (StageMass.uncovered s hs len m cmp err:ℝ) ≤
+      StageFusion.epsilon (1/600) 256*StageMass.totalLength len m)
+    (he : StageMass.residual (E:=E) s len m err M Q (StageDenominator.error K Q rep) ≤
+      StageMass.totalLength len m/4800)
+    (hpositive : ∀ c,1≤ m c)
+    (hbins : Real.log (256*s+1)/s≤1/(4800*M:ℝ)) :
+    (((samples rep).filter (Unbinned Γ mark h2 side hsid paths hp root rep a b s cmp)).card:ℝ)/
+      (samples rep).card ≤ Real.exp (-StageMass.totalLength len m/(4800*M)) := by
+  let H := StageMass.totalLength len m
+  have hH0 : 0≤H := Finset.sum_nonneg (fun _ _ => Nat.cast_nonneg _)
+  have hsum : (∑ c : R,(len c:ℝ))≤H := by
+    unfold H
+    rw [StageMass.totalLength_eq]
+    apply Finset.sum_le_sum
+    intro c _
+    have hp : (1:ℝ)≤ m c := by exact_mod_cast hpositive c
+    simpa only [one_mul] using mul_le_mul_of_nonneg_right hp (Nat.cast_nonneg (len c): (0:ℝ)≤len c)
+  have hcard : ((BinProfiles.profiles s len).card:ℝ)≤Real.exp (H/(4800*M)) := by
+    apply (BinProfiles.cardinal_bound s hs len).trans
+    apply Real.exp_le_exp.mpr
+    calc
+      _ ≤ (H/s)*Real.log (256*s+1) := mul_le_mul_of_nonneg_right
+        (div_le_div_of_nonneg_right hsum hs.le) (Real.log_nonneg (by linarith))
+      _ = H*(Real.log (256*s+1)/s) := by ring
+      _ ≤ H*(1/(4800*M)) := mul_le_mul_of_nonneg_left hbins hH0
+      _ = H/(4800*M) := by ring
+  let Profiles := {d // d∈BinProfiles.profiles s len}
+  have hB (d : Profiles) := probability_bound Γ mark h2 side hsid paths hp root rep a b
+    s hs cmp d.val err K Q M hM hm hc hclose hlarge hscale hscale' hreduced hn hr hQ hH
+    ν hsmall herr hb he
+  have hu : (((samples rep).filter
+      (Unbinned Γ mark h2 side hsid paths hp root rep a b s cmp)).card:ℝ)/(samples rep).card ≤
+        ((BinProfiles.profiles s len).card:ℝ)*Real.exp (-H/(2400*M)) := by
+    by_cases hsamp : (samples rep).Nonempty
+    · have h := StageFusion.pattern_union (samples rep) hsamp
+        (fun d : Profiles => Occurs Γ mark h2 side hsid paths hp root rep a b s cmp d.val)
+        (Real.exp (-H/(2400*M))) hB
+      have heq : (samples rep).filter (Unbinned Γ mark h2 side hsid paths hp root rep a b s cmp)=
+          (samples rep).filter (fun r => ∃ d : Profiles,
+            Occurs Γ mark h2 side hsid paths hp root rep a b s cmp d.val r) := by
+        ext r
+        simp only [Finset.mem_filter]
+        exact and_congr_right (fun _ => unbinned_iff_profile Γ mark h2 side hsid paths hp root rep a b
+          s hslarge cmp r)
+      rw [heq]
+      convert h using 1
+      congr 1
+      exact_mod_cast (Fintype.card_coe (BinProfiles.profiles s len)).symm
+    · have heq := Finset.not_nonempty_iff_eq_empty.mp hsamp
+      rw [heq,Finset.filter_empty,Finset.card_empty,Nat.cast_zero,zero_div]
+      positivity
+  calc
+    _ ≤ ((BinProfiles.profiles s len).card:ℝ)*Real.exp (-H/(2400*M)) := hu
+    _ ≤ Real.exp (H/(4800*M))*Real.exp (-H/(2400*M)) :=
+      mul_le_mul_of_nonneg_right hcard (Real.exp_pos _).le
+    _ = Real.exp (-H/(4800*M)) := by rw [←Real.exp_add]; congr 1; ring
+
+end TorsionFreeZeroDivisors.ActualPatternEvent
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/GroupRing/SimplexTopology.lean b/lean/OAI/Algebra/GroupRing/SimplexTopology.lean
new file mode 100644
index 0000000000000000000000000000000000000000..fc8250d89e7b46b74e648bdc606a7efeed74c809
--- /dev/null
+++ b/lean/OAI/Algebra/GroupRing/SimplexTopology.lean
@@ -0,0 +1,472 @@
+import Mathlib
+
+namespace OAI
+
+noncomputable section
+
+namespace GroupRingTopology
+
+def simplexSet (Scalar : Type*) (Vertex : Type*) [Semiring Scalar] [PartialOrder Scalar]
+    [Fintype Vertex] : Set (Vertex → Scalar) :=
+  {coordinates | (∀ vertex, 0 ≤ coordinates vertex) ∧ ∑ vertex, coordinates vertex = 1}
+
+instance (Vertex : Type*) [Fintype Vertex] : CompactSpace (simplexSet ℝ Vertex) := by
+  apply isCompact_iff_compactSpace.mp
+  have range_eq : Set.range (fun point : Convexity.StdSimplex ℝ Vertex =>
+      (point.weights : Vertex → ℝ)) = simplexSet ℝ Vertex := by
+    rw [Convexity.StdSimplex.range_toFun_comp_weights]
+    ext coordinates
+    simp [simplexSet]
+  rw [← range_eq]
+  exact isCompact_range (continuous_pi fun vertex =>
+    Convexity.StdSimplex.continuous_weights_apply ℝ vertex)
+
+end GroupRingTopology
+
+open Set Metric Topology BigOperators
+namespace GroupRingTopology.SimplexDisk
+
+def Truncated (n : ℕ) : Set (Fin n → ℝ) :=
+  {x | (∀ i, 0 ≤ x i) ∧ ∑ i, x i ≤ 1}
+def Positive (n : ℕ) : Set (Fin n → ℝ) :=
+  {x | (∀ i, 0 < x i) ∧ ∑ i, x i < 1}
+def sumCLM (n : ℕ) : (Fin n → ℝ) →L[ℝ] ℝ :=
+  ∑ i, ContinuousLinearMap.proj i
+@[simp] lemma sumCLM_apply (n : ℕ) (x : Fin n → ℝ) : sumCLM n x = ∑ i, x i := by
+  simp [sumCLM]
+
+lemma truncated_closed (n : ℕ) : IsClosed (Truncated n) := by
+  have h : Truncated n = (⋂ i, {x | (0:ℝ) ≤ x i}) ∩ {x | ∑ i, x i ≤ 1} := by
+    ext x; simp [Truncated]
+  rw [h]
+  exact (isClosed_iInter fun i => isClosed_le continuous_const (continuous_apply i)).inter
+    (isClosed_le (continuous_finsetSum _ fun i _ => continuous_apply i) continuous_const)
+
+lemma positive_open (n : ℕ) : IsOpen (Positive n) := by
+  have h : Positive n = (⋂ i, {x | (0:ℝ) < x i}) ∩ {x | ∑ i, x i < 1} := by
+    ext x; simp [Positive]
+  rw [h]
+  exact (isOpen_iInter_of_finite fun i => isOpen_lt continuous_const (continuous_apply i)).inter
+    (isOpen_lt (continuous_finsetSum _ fun i _ => continuous_apply i) continuous_const)
+
+lemma interior_truncated (n : ℕ) : interior (Truncated n) = Positive n := by
+  apply Subset.antisymm
+  · intro x hx
+    have hc : ∀ i, 0 < x i := by
+      intro i
+      have hh := interior_mono (show Truncated n ⊆ (Function.eval i) ⁻¹' Ici (0:ℝ) from fun _ h => h.1 i) hx
+      rw [← (isOpenMap_eval i).preimage_interior_eq_interior_preimage (continuous_apply i),interior_Ici] at hh
+      exact hh
+    refine ⟨hc,?_⟩
+    cases n with
+    | zero => simp
+    | succ n =>
+      have hs : Function.Surjective (sumCLM (n+1)) := by
+        intro r
+        refine ⟨Pi.single 0 r,?_⟩
+        simp
+      have hh := interior_mono (show Truncated (n+1) ⊆ (sumCLM (n+1)) ⁻¹' Iic (1:ℝ) from fun _ h => by simpa using h.2) hx
+      rw [← ((sumCLM (n+1)).isOpenMap hs).preimage_interior_eq_interior_preimage (sumCLM (n+1)).continuous,interior_Iic] at hh
+      simpa only [mem_preimage,mem_Iio,sumCLM_apply] using hh
+  · apply (positive_open n).subset_interior_iff.mpr
+    exact fun _ h => ⟨fun i => (h.1 i).le,h.2.le⟩
+
+lemma truncated_convex (n : ℕ) : Convex ℝ (Truncated n) := by
+  have h : Truncated n = (⋂ i, ((LinearMap.proj i : (Fin n → ℝ) →ₗ[ℝ] ℝ) ⁻¹' Ici 0)) ∩
+      (sumCLM n) ⁻¹' Iic 1 := by ext x; simp [Truncated]
+  rw [h]
+  exact (convex_iInter fun i => (convex_Ici (0:ℝ)).linear_preimage (LinearMap.proj i)).inter
+    ((convex_Iic (1:ℝ)).linear_preimage (sumCLM n).toLinearMap)
+
+lemma truncated_bounded (n : ℕ) : Bornology.IsBounded (Truncated n) := by
+  apply (isBounded_Icc (a := (0 : Fin n → ℝ)) (b := 1)).subset
+  intro x hx
+  refine ⟨hx.1,fun i => ?_⟩
+  exact (Finset.single_le_sum (fun j _ => hx.1 j) (Finset.mem_univ i)).trans hx.2
+
+lemma positive_nonempty (n : ℕ) : (Positive n).Nonempty := by
+  refine ⟨fun _ => 1 / (n+1 : ℝ),fun _ => by positivity,?_⟩
+  simp only [Finset.sum_const,Finset.card_univ,Fintype.card_fin,nsmul_eq_mul]
+  have hn : (0:ℝ) < n+1 := by positivity
+  rw [mul_one_div,div_lt_one hn]
+  linarith
+
+noncomputable def ambient (n : ℕ) : (Fin n → ℝ) ≃ₜ (Fin n → ℝ) :=
+  Classical.choose (exists_homeomorph_image_interior_closure_frontier_eq_unitBall
+    (truncated_convex n) (by rw [interior_truncated]; exact positive_nonempty n) (truncated_bounded n))
+
+lemma ambient_positive (n : ℕ) : ambient n '' Positive n = ball 0 1 := by
+  simpa only [ambient,interior_truncated] using
+    (Classical.choose_spec (exists_homeomorph_image_interior_closure_frontier_eq_unitBall
+      (truncated_convex n) (by rw [interior_truncated]; exact positive_nonempty n) (truncated_bounded n))).1
+lemma ambient_truncated (n : ℕ) : ambient n '' Truncated n = closedBall 0 1 := by
+  simpa only [ambient,(truncated_closed n).closure_eq] using
+    (Classical.choose_spec (exists_homeomorph_image_interior_closure_frontier_eq_unitBall
+      (truncated_convex n) (by rw [interior_truncated]; exact positive_nonempty n) (truncated_bounded n))).2.1
+
+noncomputable def truncatedDisk (n : ℕ) : Truncated n ≃ₜ closedBall (0 : Fin n → ℝ) 1 :=
+  ((ambient n).image (Truncated n)).trans (Homeomorph.setCongr (ambient_truncated n))
+
+noncomputable def simplexTruncated (n : ℕ) : simplexSet ℝ (Fin (n+1)) ≃ₜ Truncated n where
+  toFun x := ⟨fun i => x.1 i.succ,fun i => x.2.1 _,by
+    have h := x.2.2
+    rw [Fin.sum_univ_succ] at h
+    linarith [x.2.1 0]⟩
+  invFun x := ⟨Fin.cons (1 - ∑ i, x.1 i) x.1,by
+    constructor
+    · intro i
+      refine Fin.cases ?_ (fun j => ?_) i
+      · exact sub_nonneg.mpr x.2.2
+      · exact x.2.1 j
+    · simp [Fin.sum_univ_succ]⟩
+  left_inv x := by
+    apply Subtype.ext
+    funext i
+    refine Fin.cases ?_ (fun j => rfl) i
+    have h := x.2.2
+    rw [Fin.sum_univ_succ] at h
+    change 1 - ∑ i : Fin n, x.1 i.succ = x.1 0
+    linarith
+  right_inv x := by rfl
+  continuous_toFun := (continuous_pi fun i => (continuous_apply i.succ).comp continuous_subtype_val).subtype_mk _
+  continuous_invFun := by
+    apply Continuous.subtype_mk
+    apply continuous_pi
+    intro i
+    refine Fin.cases ?_ (fun j => ?_) i
+    · exact continuous_const.sub (continuous_finsetSum _ fun j _ => (continuous_apply j).comp continuous_subtype_val)
+    · exact (continuous_apply j).comp continuous_subtype_val
+
+noncomputable def simplexDisk (n : ℕ) : simplexSet ℝ (Fin (n+1)) ≃ₜ closedBall (0 : Fin n → ℝ) 1 :=
+  (simplexTruncated n).trans (truncatedDisk n)
+
+lemma simplexTruncated_positive (n : ℕ) (x : simplexSet ℝ (Fin (n+1))) :
+    (simplexTruncated n x).1 ∈ Positive n ↔ ∀ i, 0 < x.1 i := by
+  have h := x.2.2
+  rw [Fin.sum_univ_succ] at h
+  constructor
+  · rintro ⟨hc,hs⟩ i
+    refine Fin.cases ?_ (fun j => hc j) i
+    change ∑ i : Fin n, x.1 i.succ < 1 at hs
+    linarith
+  · intro hc
+    refine ⟨fun j => hc _,?_⟩
+    change ∑ i : Fin n, x.1 i.succ < 1
+    linarith [hc 0]
+
+lemma simplexDisk_open (n : ℕ) (x : simplexSet ℝ (Fin (n+1))) :
+    (simplexDisk n x).1 ∈ ball 0 1 ↔ ∀ i, 0 < x.1 i := by
+  rw [← simplexTruncated_positive]
+  change ambient n (simplexTruncated n x).1 ∈ ball 0 1 ↔ _
+  rw [← ambient_positive]
+  exact (ambient n).injective.mem_set_image
+
+lemma simplexDisk_boundary (n : ℕ) (x : simplexSet ℝ (Fin (n+1))) :
+    (simplexDisk n x).1 ∈ sphere 0 1 ↔ ∃ i, x.1 i = 0 := by
+  have h := (simplexDisk n x).2
+  rw [mem_sphere,mem_closedBall] at *
+  have ho := simplexDisk_open n x
+  simp only [mem_ball] at ho
+  constructor
+  · intro he
+    have hn : ¬ ∀ i, 0 < x.1 i := by rw [←ho,he]; exact lt_irrefl _
+    push Not at hn
+    obtain ⟨i,hi⟩ := hn
+    exact ⟨i,le_antisymm hi (x.2.1 i)⟩
+  · rintro ⟨i,hi⟩
+    apply le_antisymm h
+    by_contra hn
+    have hp := ho.mp (lt_of_not_ge hn)
+    linarith [hp i]
+
+noncomputable def reindex {A B : Type*} [Fintype A] [Fintype B] (e : A ≃ B) :
+    simplexSet ℝ A ≃ₜ simplexSet ℝ B where
+  toFun x := ⟨fun b => x.1 (e.symm b),fun b => x.2.1 _,(e.symm.sum_comp x.1).trans x.2.2⟩
+  invFun x := ⟨fun a => x.1 (e a),fun a => x.2.1 _,(e.sum_comp x.1).trans x.2.2⟩
+  left_inv x := by ext a; simp
+  right_inv x := by ext b; simp
+  continuous_toFun := (continuous_pi fun b => ((continuous_apply (e.symm b)).comp continuous_subtype_val : Continuous (fun x : simplexSet ℝ A => x.1 (e.symm b)))).subtype_mk _
+  continuous_invFun := (continuous_pi fun a => ((continuous_apply (e a)).comp continuous_subtype_val : Continuous (fun x : simplexSet ℝ B => x.1 (e a)))).subtype_mk _
+
+lemma reindex_positive {A B : Type*} [Fintype A] [Fintype B] (e : A ≃ B) (x : simplexSet ℝ A) :
+    (∀ b, 0 < (reindex e x).1 b) ↔ ∀ a, 0 < x.1 a := by
+  constructor
+  · intro h a
+    change ∀ b, 0 < x.1 (e.symm b) at h
+    simpa only [e.symm_apply_apply] using h (e a)
+  · intro h b
+    change 0 < x.1 (e.symm b)
+    exact h _
+
+end GroupRingTopology.SimplexDisk
+open Set Metric Topology BigOperators
+namespace GroupRingTopology.Simplicial
+
+section
+universe u v
+variable {V : Type u} (K : PreAbstractSimplicialComplex V)
+
+/-- Finitely supported probability weights on a face, with the weak topology. -/
+def Space := {w : V →₀ ℝ | (∀ v, 0 ≤ w v) ∧ w.sum (fun _ r => r) = 1 ∧ w.support ∈ K}
+abbrev Face := {s : Finset V // s ∈ K}
+
+lemma support_nonempty {w : V →₀ ℝ} (h : w.sum (fun _ r => r) = 1) : w.support.Nonempty := by
+  classical
+  by_contra hn
+  have hz : w = 0 := by
+    apply Finsupp.support_eq_empty.mp
+    exact Finset.not_nonempty_iff_eq_empty.mp hn
+  simp [hz] at h
+
+lemma face_nonempty (s : Face K) : s.1.Nonempty := (K.isRelLowerSet_faces s.2).1
+
+noncomputable def weight (s : Finset V) (x : simplexSet ℝ s) : V →₀ ℝ :=
+  Finsupp.embDomain (Function.Embedding.subtype (· ∈ s)) (Finsupp.equivFunOnFinite.symm x.1)
+
+lemma weight_apply (s : Finset V) (x : simplexSet ℝ s) (v : s) :
+    weight s x v = x.1 v := by
+  exact Finsupp.embDomain_apply_self _ _ _
+
+lemma weight_apply_not (s : Finset V) (x : simplexSet ℝ s) {v : V} (hv : v ∉ s) :
+    weight s x v = 0 := by
+  apply Finsupp.embDomain_of_notMem_range
+  rintro ⟨w,hw⟩
+  exact hv (hw ▸ w.2)
+
+lemma weight_nonneg (s : Finset V) (x : simplexSet ℝ s) (v : V) : 0 ≤ weight s x v := by
+  classical
+  by_cases hv : v ∈ s
+  · exact (weight_apply s x ⟨v,hv⟩) ▸ x.2.1 ⟨v,hv⟩
+  · rw [weight_apply_not _ _ hv]
+
+lemma weight_sum (s : Finset V) (x : simplexSet ℝ s) : (weight s x).sum (fun _ r => r) = 1 := by
+  rw [weight,Finsupp.sum_embDomain,Finsupp.sum_fintype _ _ (fun _ => rfl)]
+  exact x.2.2
+
+lemma weight_support_subset (s : Finset V) (x : simplexSet ℝ s) : (weight s x).support ⊆ s := by
+  classical
+  intro v hv
+  by_contra hn
+  exact Finsupp.mem_support_iff.mp hv (weight_apply_not _ _ hn)
+
+noncomputable def faceMap (s : Face K) (x : simplexSet ℝ s.1) : Space K :=
+  ⟨weight s.1 x,weight_nonneg _ _,weight_sum _ _,
+    K.isRelLowerSet_faces.mem_of_le s.2 (weight_support_subset _ _) (support_nonempty (weight_sum _ _))⟩
+
+noncomputable def quotient (x : Σ s : Face K, simplexSet ℝ s.1) : Space K := faceMap K x.1 x.2
+
+instance : TopologicalSpace (Space K) := TopologicalSpace.coinduced (quotient K) inferInstance
+
+lemma continuous_iff {Y : Type v} [TopologicalSpace Y] (f : Space K → Y) :
+    Continuous f ↔ ∀ s : Face K, Continuous (f ∘ faceMap K s) := by
+  rw [continuous_coinduced_dom]
+  exact continuous_sigma_iff
+
+lemma continuous_faceMap (s : Face K) : Continuous (faceMap K s) :=
+  (continuous_coinduced_rng : Continuous (quotient K)).comp (continuous_sigmaMk (i := s))
+
+lemma continuous_eval (v : V) : Continuous (fun x : Space K => x.1 v) := by
+  classical
+  rw [continuous_iff]
+  intro s
+  by_cases hv : v ∈ s.1
+  · have he : (fun x : Space K => x.1 v) ∘ faceMap K s = (fun x : simplexSet ℝ s.1 => x.1 ⟨v,hv⟩) := by
+      funext x
+      exact weight_apply s.1 x ⟨v,hv⟩
+    rw [he]
+    exact (continuous_apply (⟨v,hv⟩ : s.1)).comp continuous_subtype_val
+  · have he : (fun x : Space K => x.1 v) ∘ faceMap K s = (fun _ => (0:ℝ)) := by
+      funext x
+      exact weight_apply_not _ _ hv
+    rw [he]
+    exact continuous_const
+
+instance : T2Space (Space K) :=
+  T2Space.of_injective_continuous (f := fun x : Space K => (x.1 : V → ℝ))
+    (fun _ _ h => Subtype.ext (Finsupp.ext fun v => congrFun h v))
+    (continuous_pi fun v => continuous_eval K v)
+
+lemma faceMap_injective (s : Face K) : Function.Injective (faceMap K s) := by
+  intro x y h
+  apply Subtype.ext
+  funext v
+  have hh := congrArg (fun p : Space K => p.1 v) h
+  exact (weight_apply _ _ _).symm.trans (hh.trans (weight_apply _ _ _))
+
+lemma faceMap_closedEmbedding (s : Face K) : IsClosedEmbedding (faceMap K s) :=
+  (continuous_faceMap K s).isClosedEmbedding (faceMap_injective K s)
+
+noncomputable def coordinates (s : Finset V) (x : Space K) (h : x.1.support ⊆ s) : simplexSet ℝ s := by
+  refine ⟨fun v => x.1 v,fun v => x.2.1 _,?_⟩
+  rw [Finset.sum_coe_sort]
+  exact (x.1.sum_of_support_subset h _ (fun _ _ => rfl)).symm.trans x.2.2.1
+
+lemma faceMap_coordinates (s : Face K) (x : Space K) (h : x.1.support ⊆ s.1) :
+    faceMap K s (coordinates K s.1 x h) = x := by
+  classical
+  apply Subtype.ext
+  ext v
+  by_cases hv : v ∈ s.1
+  · exact weight_apply _ _ ⟨v,hv⟩
+  · change weight s.1 _ v = x.1 v
+    rw [weight_apply_not _ _ hv,Finsupp.notMem_support_iff.mp (fun hh => hv (h hh))]
+
+lemma range_faceMap (s : Face K) : Set.range (faceMap K s) = {x | x.1.support ⊆ s.1} := by
+  ext x
+  constructor
+  · rintro ⟨y,rfl⟩
+    exact weight_support_subset _ _
+  · intro h
+    exact ⟨coordinates K s.1 x h,faceMap_coordinates K s x h⟩
+
+lemma quotient_surjective : Function.Surjective (quotient K) := by
+  intro x
+  exact ⟨⟨⟨x.1.support,x.2.2.2⟩,coordinates K x.1.support x (subset_refl _)⟩,
+    faceMap_coordinates K ⟨x.1.support,x.2.2.2⟩ x (subset_refl _)⟩
+
+lemma isClosed_iff (A : Set (Space K)) :
+    IsClosed A ↔ ∀ s : Face K, IsClosed ((faceMap K s) ⁻¹' A) := by
+  rw [isClosed_coinduced]
+  exact isClosed_sigma_iff
+
+lemma support_eq_iff (s : Face K) (x : simplexSet ℝ s.1) :
+    (faceMap K s x).1.support = s.1 ↔ ∀ v, 0 < x.1 v := by
+  classical
+  constructor
+  · intro he v
+    have hn : weight s.1 x v ≠ 0 := by
+      apply Finsupp.mem_support_iff.mp
+      change v.1 ∈ (faceMap K s x).1.support
+      rw [he]
+      exact v.2
+    rw [weight_apply] at hn
+    exact lt_of_le_of_ne (x.2.1 v) (Ne.symm hn)
+  · intro hp
+    apply Finset.Subset.antisymm (weight_support_subset _ _)
+    intro v hv
+    apply Finsupp.mem_support_iff.mpr
+    rw [weight_apply _ _ ⟨v,hv⟩]
+    exact ne_of_gt (hp ⟨v,hv⟩)
+
+end
+
+open Set Metric Topology BigOperators
+open scoped Classical
+universe u v w
+variable {V : Type u} {W : Type v} {T : Type w}
+variable (K : PreAbstractSimplicialComplex V) (L : PreAbstractSimplicialComplex W)
+
+lemma continuous_of_support_subset [TopologicalSpace T] (f : T → Space K) (s : Face K)
+    (hs : ∀ x, (f x).1.support ⊆ s.1) (hc : ∀ v, Continuous fun x => (f x).1 v) : Continuous f := by
+  let c : T → simplexSet ℝ s.1 := fun x => coordinates K s.1 (f x) (hs x)
+  have hcc : Continuous c := (continuous_pi fun v : s.1 => hc v.1).subtype_mk _
+  have he : f = (faceMap K s) ∘ c := by
+    funext x
+    exact (faceMap_coordinates K s (f x) (hs x)).symm
+  rw [he]
+  exact (continuous_faceMap K s).comp hcc
+
+lemma push_apply (f : V → W) (w : V →₀ ℝ) (s : Finset V) (hs : w.support ⊆ s) (b : W) :
+    (w.mapDomain f) b = ∑ a ∈ s, if f a = b then w a else 0 := by
+  classical
+  rw [Finsupp.mapDomain,Finsupp.sum_apply]
+  rw [w.sum_of_support_subset hs]
+  · apply Finset.sum_congr rfl
+    intro a _
+    simp only [Finsupp.single_apply]
+  · intro a _
+    simp
+
+lemma push_nonneg (f : V → W) (w : V →₀ ℝ) (hw : ∀ v, 0 ≤ w v) (b : W) :
+    0 ≤ (w.mapDomain f) b := by
+  classical
+  rw [push_apply f w w.support (Finset.Subset.refl _) b]
+  exact Finset.sum_nonneg fun a _ => by split; exact hw a; exact le_rfl
+
+lemma push_sum (f : V → W) (w : V →₀ ℝ) :
+    (w.mapDomain f).sum (fun _ r => r) = w.sum (fun _ r => r) :=
+  Finsupp.sum_mapDomain_index (fun _ => rfl) (fun _ _ _ => rfl)
+
+def map (f : V → W) (hf : ∀ s : Face K, s.1.image f ∈ L) (x : Space K) : Space L := by
+  classical
+  refine ⟨x.1.mapDomain f,push_nonneg f x.1 x.2.1,?_,?_⟩
+  · rw [push_sum]; exact x.2.2.1
+  · exact L.isRelLowerSet_faces.mem_of_le (hf ⟨x.1.support,x.2.2.2⟩) Finsupp.mapDomain_support
+      (support_nonempty (by rw [push_sum]; exact x.2.2.1))
+
+lemma map_support (f : V → W) (hf : ∀ s : Face K, s.1.image f ∈ L) (x : Space K) :
+    (map K L f hf x).1.support ⊆ x.1.support.image f := by
+  classical
+  exact Finsupp.mapDomain_support
+
+lemma continuous_map (f : V → W) (hf : ∀ s : Face K, s.1.image f ∈ L) : Continuous (map K L f hf) := by
+  classical
+  rw [continuous_iff]
+  intro s
+  apply continuous_of_support_subset L _ ⟨s.1.image f,hf s⟩
+  · intro x
+    exact (map_support K L f hf _).trans (Finset.image_subset_image (weight_support_subset _ _))
+  · intro b
+    have he : (fun x : simplexSet ℝ s.1 => ((map K L f hf ∘ faceMap K s) x).1 b) =
+        fun x => ∑ a : s.1, if f a.1 = b then x.1 a else 0 := by
+      funext x
+      change (Finsupp.mapDomain f (weight s.1 x)) b = _
+      rw [push_apply f _ s.1 (weight_support_subset _ _) b,← Finset.sum_coe_sort]
+      apply Finset.sum_congr rfl
+      intro a _
+      rw [weight_apply]
+    rw [he]
+    apply continuous_finsetSum
+    intro a _
+    split_ifs
+    · exact (continuous_apply a).comp continuous_subtype_val
+    · exact continuous_const
+
+def mapC (f : V → W) (hf : ∀ s : Face K, s.1.image f ∈ L) : C(Space K,Space L) :=
+  ⟨map K L f hf,continuous_map K L f hf⟩
+
+lemma map_id (hf : ∀ s : Face K, s.1.image id ∈ K) (x : Space K) : map K K id hf x = x := by
+  apply Subtype.ext
+  exact Finsupp.mapDomain_id
+
+lemma map_comp {U : Type*} (M : PreAbstractSimplicialComplex U)
+    (f : V → W) (hf : ∀ s : Face K, s.1.image f ∈ L)
+    (g : W → U) (hg : ∀ s : Face L, s.1.image g ∈ M)
+    (hgf : ∀ s : Face K, s.1.image (g ∘ f) ∈ M) (x : Space K) :
+    map L M g hg (map K L f hf x) = map K M (g ∘ f) hgf x := by
+  apply Subtype.ext
+  exact Finsupp.mapDomain_comp.symm
+
+lemma quotient_quotientMap : IsQuotientMap (quotient K) :=
+  ⟨⟨rfl⟩,quotient_surjective K⟩
+
+lemma continuous_prod_iff [TopologicalSpace T] [LocallyCompactSpace T]
+    {Y : Type*} [TopologicalSpace Y] (f : T × Space K → Y) :
+    Continuous f ↔ ∀ s : Face K, Continuous (fun p : T × simplexSet ℝ s.1 => f (p.1,faceMap K s p.2)) := by
+  constructor
+  · intro hf s
+    exact hf.comp (continuous_fst.prodMk ((continuous_faceMap K s).comp continuous_snd))
+  · intro hf
+    apply (quotient_quotientMap K).continuous_lift_prod_right
+    rw [continuous_def]
+    intro O hO
+    have hp : (fun p : T × (Σ s : Face K, simplexSet ℝ s.1) => f (p.1,quotient K p.2)) ⁻¹' O =
+      ⋃ s : Face K, (fun p : T × simplexSet ℝ s.1 => (p.1,⟨s,p.2⟩)) ''
+        ((fun p : T × simplexSet ℝ s.1 => f (p.1,faceMap K s p.2)) ⁻¹' O) := by
+      ext p
+      simp only [mem_preimage,mem_iUnion,mem_image]
+      constructor
+      · intro h
+        exact ⟨p.2.1,⟨p.1,p.2.2⟩,h,rfl⟩
+      · rintro ⟨s,p,h,rfl⟩
+        exact h
+    rw [hp]
+    apply isOpen_iUnion
+    intro s
+    exact (IsOpenMap.id.prodMap isOpenMap_sigmaMk) _ ((hf s).isOpen_preimage O hO)
+
+end GroupRingTopology.Simplicial
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/GroupRing/Simplicial.lean b/lean/OAI/Algebra/GroupRing/Simplicial.lean
new file mode 100644
index 0000000000000000000000000000000000000000..8a840e78cf03108a44845ac60498a1457a861b3f
--- /dev/null
+++ b/lean/OAI/Algebra/GroupRing/Simplicial.lean
@@ -0,0 +1,433 @@
+import Mathlib
+import OAI.Algebra.GroupRing.SimplexTopology
+
+namespace OAI
+
+noncomputable section
+
+open Set Metric Topology BigOperators
+
+namespace GroupRingTopology.Simplicial
+
+section
+open Set Metric Topology BigOperators
+open scoped Classical unitInterval
+universe u v
+variable {V : Type u} {W : Type v}
+variable (K : PreAbstractSimplicialComplex V) (L : PreAbstractSimplicialComplex W)
+
+def mass : (V →₀ ℝ) →ₗ[ℝ] ℝ := Finsupp.lsum ℝ fun _ => LinearMap.id
+lemma mass_apply (w : V →₀ ℝ) : mass w = w.sum (fun _ r => r) := rfl
+
+lemma blend_support (x y : V →₀ ℝ) (t : I) :
+    ((1-(t:ℝ)) • x + (t:ℝ) • y).support ⊆ x.support ∪ y.support :=
+  Finsupp.support_add.trans (Finset.union_subset_union Finsupp.support_smul Finsupp.support_smul)
+
+def blend (s : Face K) (x y : Space K) (hx : x.1.support ⊆ s.1) (hy : y.1.support ⊆ s.1) (t : I) : Space K := by
+  let w := (1-(t:ℝ)) • x.1 + (t:ℝ) • y.1
+  have hw : w.sum (fun _ r => r) = 1 := by
+    rw [← mass_apply]
+    simp only [w,map_add,map_smul,mass_apply,x.2.2.1,y.2.2.1,smul_eq_mul,mul_one]
+    ring
+  refine ⟨w,?_,hw,?_⟩
+  · intro v
+    exact add_nonneg (mul_nonneg (sub_nonneg.mpr t.2.2) (x.2.1 v)) (mul_nonneg t.2.1 (y.2.1 v))
+  · exact K.isRelLowerSet_faces.mem_of_le s.2
+      ((blend_support x.1 y.1 t).trans (Finset.union_subset hx hy)) (support_nonempty hw)
+
+lemma blend_zero (s : Face K) (x y : Space K) (hx : x.1.support ⊆ s.1) (hy : y.1.support ⊆ s.1) :
+    blend K s x y hx hy 0 = x := by
+  apply Subtype.ext
+  simp [blend]
+lemma blend_one (s : Face K) (x y : Space K) (hx : x.1.support ⊆ s.1) (hy : y.1.support ⊆ s.1) :
+    blend K s x y hx hy 1 = y := by
+  apply Subtype.ext
+  simp [blend]
+lemma blend_self (s : Face K) (x : Space K) (hx : x.1.support ⊆ s.1) (t : I) :
+    blend K s x x hx hx t = x := by
+  apply Subtype.ext
+  change (1-(t:ℝ)) • x.1 + (t:ℝ) • x.1 = x.1
+  rw [← add_smul,sub_add_cancel,one_smul]
+
+variable (f g : V → W) (hf : ∀ s : Face K, s.1.image f ∈ L) (hg : ∀ s : Face K, s.1.image g ∈ L)
+variable (hfg : ∀ s : Face K, s.1.image f ∪ s.1.image g ∈ L)
+
+def straight (t : I) (x : Space K) : Space L :=
+  blend L ⟨x.1.support.image f ∪ x.1.support.image g,hfg ⟨x.1.support,x.2.2.2⟩⟩
+    (map K L f hf x) (map K L g hg x)
+    ((map_support K L f hf x).trans Finset.subset_union_left)
+    ((map_support K L g hg x).trans Finset.subset_union_right) t
+
+lemma continuous_straight : Continuous (fun p : I × Space K => straight K L f g hf hg hfg p.1 p.2) := by
+  rw [continuous_prod_iff]
+  intro s
+  apply continuous_of_support_subset L _ ⟨s.1.image f ∪ s.1.image g,hfg s⟩
+  · intro p
+    exact (blend_support _ _ p.1).trans (Finset.union_subset_union
+      ((map_support K L f hf _).trans (Finset.image_subset_image (weight_support_subset _ _)))
+      ((map_support K L g hg _).trans (Finset.image_subset_image (weight_support_subset _ _))))
+  · intro b
+    change Continuous (fun p : I × simplexSet ℝ s.1 =>
+      (1-(p.1:ℝ)) * (map K L f hf (faceMap K s p.2)).1 b +
+        (p.1:ℝ) * (map K L g hg (faceMap K s p.2)).1 b)
+    exact ((continuous_const.sub (continuous_subtype_val.comp continuous_fst)).mul
+      ((continuous_eval L b).comp ((continuous_map K L f hf).comp ((continuous_faceMap K s).comp continuous_snd)))).add
+      ((continuous_subtype_val.comp continuous_fst).mul
+        ((continuous_eval L b).comp ((continuous_map K L g hg).comp ((continuous_faceMap K s).comp continuous_snd))))
+
+def straightHomotopy : (mapC K L f hf).Homotopy (mapC K L g hg) where
+  toFun p := straight K L f g hf hg hfg p.1 p.2
+  continuous_toFun := continuous_straight K L f g hf hg hfg
+  map_zero_left _ := blend_zero L _ _ _ _ _
+  map_one_left _ := blend_one L _ _ _ _ _
+
+lemma straightHomotopy_fixed (x : Space K) (h : map K L f hf x = map K L g hg x) (t : I) :
+    straightHomotopy K L f g hf hg hfg (t,x) = map K L f hf x := by
+  apply Subtype.ext
+  change (1-(t:ℝ)) • (map K L f hf x).1 + (t:ℝ) • (map K L g hg x).1 = (map K L f hf x).1
+  rw [←h,←add_smul,sub_add_cancel,one_smul]
+end
+open Set Metric Topology BigOperators
+open scoped Classical
+universe u
+variable {V : Type u} (K L : PreAbstractSimplicialComplex V) (hKL : ∀ s ∈ K, s ∈ L)
+
+def inclusion (x : Space K) : Space L := ⟨x.1,x.2.1,x.2.2.1,hKL _ x.2.2.2⟩
+
+lemma inclusion_injective : Function.Injective (inclusion K L hKL) :=
+  fun _ _ h => Subtype.ext (congrArg (fun z : Space L => z.1) h)
+
+lemma inclusion_faceMap (s : Face K) (x : simplexSet ℝ s.1) :
+    inclusion K L hKL (faceMap K s x) = faceMap L ⟨s.1,hKL _ s.2⟩ x := rfl
+
+lemma continuous_inclusion : Continuous (inclusion K L hKL) := by
+  rw [continuous_iff]
+  intro s
+  exact continuous_faceMap L ⟨s.1,hKL _ s.2⟩
+
+lemma inclusion_isClosedMap : IsClosedMap (inclusion K L hKL) := by
+  intro A hA
+  rw [isClosed_iff]
+  intro s
+  let T : Set (Face K) := {t | t.1 ⊆ s.1}
+  have hT : T.Finite := by
+    have hf := s.1.powerset.finite_toSet.preimage (Subtype.val_injective : Function.Injective (Subtype.val : Face K → Finset V)).injOn
+    convert hf using 1
+    ext t
+    simp only [T,mem_ofPred_eq,mem_preimage,Finset.mem_coe,Finset.mem_powerset]
+  have hc : IsClosed (⋃ t ∈ T, inclusion K L hKL '' (A ∩ Set.range (faceMap K t))) := by
+    apply hT.isClosed_biUnion
+    intro t _
+    exact (((isCompact_range (continuous_faceMap K t)).inter_left hA).image
+      (continuous_inclusion K L hKL)).isClosed
+  have he : inclusion K L hKL '' A ∩ Set.range (faceMap L s) =
+      ⋃ t ∈ T, inclusion K L hKL '' (A ∩ Set.range (faceMap K t)) := by
+    ext x
+    simp only [mem_inter_iff,mem_image,mem_iUnion]
+    constructor
+    · rintro ⟨⟨y,hy,rfl⟩,hs⟩
+      rw [range_faceMap] at hs
+      let t : Face K := ⟨y.1.support,y.2.2.2⟩
+      refine ⟨t,hs,y,⟨hy,?_⟩,rfl⟩
+      rw [range_faceMap]
+      exact Finset.Subset.refl _
+    · rintro ⟨t,ht,y,⟨hy,hyt⟩,rfl⟩
+      refine ⟨⟨y,hy,rfl⟩,?_⟩
+      rw [range_faceMap] at hyt ⊢
+      exact hyt.trans (show t.1 ⊆ s.1 from ht)
+  rw [←he] at hc
+  have hp := hc.preimage (continuous_faceMap L s)
+  simpa only [preimage_inter,preimage_range,inter_univ] using hp
+
+lemma inclusion_closedEmbedding : IsClosedEmbedding (inclusion K L hKL) :=
+  .of_continuous_injective_isClosedMap (continuous_inclusion K L hKL)
+    (inclusion_injective K L hKL) (inclusion_isClosedMap K L hKL)
+end GroupRingTopology.Simplicial
+namespace GroupRingTopology.Milnor
+open Set Metric Topology BigOperators GroupRingTopology.Simplicial
+open scoped Classical unitInterval
+universe u v
+local instance (priority := 2000) (α : Type*) : DecidableEq α := Classical.decEq α
+variable (G : Type u)
+
+def complex : PreAbstractSimplicialComplex (ℕ × G) where
+  faces := {s | s.Nonempty ∧ Set.InjOn Prod.fst (s : Set (ℕ × G))}
+  isRelLowerSet_faces := by
+    intro s hs
+    exact ⟨hs.1,fun t hts ht => ⟨ht,hs.2.mono hts⟩⟩
+
+abbrev Space := Simplicial.Space (complex G)
+
+lemma mem_complex (s : Finset (ℕ × G)) : s ∈ complex G ↔
+    s.Nonempty ∧ Set.InjOn Prod.fst (s : Set (ℕ × G)) := Iff.rfl
+
+def bounded (N : ℕ) : PreAbstractSimplicialComplex (ℕ × G) where
+  faces := {s | s ∈ complex G ∧ ∀ v ∈ s, v.1 < N}
+  isRelLowerSet_faces := by
+    intro s hs
+    exact ⟨hs.1.1,fun t hts ht => ⟨(complex G).isRelLowerSet_faces.mem_of_le hs.1 hts ht,
+      fun v hv => hs.2 v (hts hv)⟩⟩
+
+lemma bounded_le (N : ℕ) : bounded G N ≤ complex G := fun _ hs => hs.1
+lemma bounded_mono {N M : ℕ} (h : N ≤ M) : bounded G N ≤ bounded G M :=
+  fun _ hs => ⟨hs.1,fun v hv => lt_of_lt_of_le (hs.2 v hv) h⟩
+
+variable {G} {H : Type v}
+lemma map_face (φ : G → H) (ρ : ℕ → ℕ) (hρ : Function.Injective ρ)
+    (s : Face (complex G)) : s.1.image (fun v => (ρ v.1,φ v.2)) ∈ complex H := by
+  refine ⟨s.2.1.image _,?_⟩
+  rintro a ha b hb hab
+  obtain ⟨x,hx,rfl⟩ := Finset.mem_image.mp ha
+  obtain ⟨y,hy,rfl⟩ := Finset.mem_image.mp hb
+  exact congrArg (fun v : ℕ × G => (ρ v.1,φ v.2)) (s.2.2 hx hy (hρ hab))
+
+def map (φ : G → H) (ρ : ℕ → ℕ) (hρ : Function.Injective ρ) : C(Space G,Space H) :=
+  Simplicial.mapC (complex G) (complex H) (fun v => (ρ v.1,φ v.2)) (map_face φ ρ hρ)
+
+lemma map_comp {J : Type*} (φ : G → H) (ψ : H → J)
+    (ρ τ : ℕ → ℕ) (hρ : Function.Injective ρ) (hτ : Function.Injective τ) (x : Space G) :
+    map ψ τ hτ (map φ ρ hρ x) = map (ψ ∘ φ) (τ ∘ ρ) (hτ.comp hρ) x :=
+by
+  apply Subtype.ext
+  exact Finsupp.mapDomain_comp.symm
+
+lemma map_id (x : Space G) : map id id Function.injective_id x = x := by
+  apply Subtype.ext
+  exact Finsupp.mapDomain_id
+
+def vertex (v : ℕ × G) : Space G :=
+  ⟨Finsupp.single v 1,by intro w; simp only [Finsupp.single_apply]; split_ifs <;> norm_num,
+    by simp,by
+      simp only [Finsupp.support_single _ one_ne_zero]
+      exact ⟨Finset.singleton_nonempty v,by simpa only [Finset.coe_singleton] using Set.injOn_singleton Prod.fst v⟩⟩
+
+lemma bounded_union_apex (N : ℕ) (g : G) (s : Face (bounded G N)) :
+    s.1 ∪ {(N,g)} ∈ complex G := by
+  refine ⟨s.2.1.1.mono Finset.subset_union_left,?_⟩
+  intro x hx y hy hxy
+  rcases Finset.mem_union.mp hx with hx | hx <;> rcases Finset.mem_union.mp hy with hy | hy
+  · exact s.2.1.2 hx hy hxy
+  · have hyy := Finset.mem_singleton.mp hy
+    subst y
+    exact False.elim ((Nat.ne_of_lt (s.2.2 x hx)) hxy)
+  · have hxx := Finset.mem_singleton.mp hx
+    subst x
+    exact False.elim ((Nat.ne_of_lt (s.2.2 y hy)) hxy.symm)
+  · exact (Finset.mem_singleton.mp hx).trans (Finset.mem_singleton.mp hy).symm
+
+lemma bounded_id_face (N : ℕ) (s : Face (bounded G N)) : s.1.image id ∈ complex G := by
+  simpa only [Finset.image_id] using s.2.1
+lemma bounded_const_face (N : ℕ) (g : G) (s : Face (bounded G N)) :
+    s.1.image (fun _ => (N,g)) ∈ complex G := by
+  rw [Finset.image_const s.2.1.1]
+  exact ⟨Finset.singleton_nonempty _,by simpa only [Finset.coe_singleton] using Set.injOn_singleton Prod.fst (N,g)⟩
+lemma bounded_contiguous (N : ℕ) (g : G) (s : Face (bounded G N)) :
+    s.1.image id ∪ s.1.image (fun _ => (N,g)) ∈ complex G := by
+  rw [Finset.image_id,Finset.image_const s.2.1.1]
+  exact bounded_union_apex N g s
+
+lemma bounded_map_id (N : ℕ) (x : Simplicial.Space (bounded G N)) :
+    Simplicial.map (bounded G N) (complex G) id (bounded_id_face N) x =
+      Simplicial.inclusion (bounded G N) (complex G) (fun _ h => bounded_le G N h) x := by
+  apply Subtype.ext
+  exact Finsupp.mapDomain_id
+
+lemma map_const_vertex (K : PreAbstractSimplicialComplex (ℕ × G)) (v : ℕ × G)
+    (hf : ∀ s : Face K, s.1.image (fun _ => v) ∈ complex G) (x : Simplicial.Space K) :
+    Simplicial.map K (complex G) (fun _ => v) hf x = vertex v := by
+  apply Subtype.ext
+  change x.1.mapDomain (fun _ => v) = Finsupp.single v 1
+  rw [Finsupp.mapDomain,← Finsupp.single_sum]
+  exact congrArg (Finsupp.single v) x.2.2.1
+
+end GroupRingTopology.Milnor
+
+namespace GroupRingTopology.Simplicial
+open Set Metric Topology BigOperators
+universe u
+variable {V : Type u} (K : PreAbstractSimplicialComplex V)
+
+abbrev Cell (n : ℕ) := {s : Face K // s.1.card = n+1}
+
+def cellOfFace (s : Face K) : Cell K (s.1.card-1) :=
+  ⟨s,by have := Finset.card_pos.mpr (face_nonempty K s); omega⟩
+
+def cellEquiv {n : ℕ} (s : Cell K n) : s.1.1 ≃ Fin (n+1) :=
+  Fintype.equivFinOfCardEq (by simpa only [Fintype.card_coe] using s.2)
+
+def faceDisk {n : ℕ} (s : Cell K n) : simplexSet ℝ s.1.1 ≃ₜ closedBall (0 : Fin n → ℝ) 1 :=
+  (SimplexDisk.reindex (cellEquiv K s)).trans (SimplexDisk.simplexDisk n)
+
+lemma faceDisk_open {n : ℕ} (s : Cell K n) (x : simplexSet ℝ s.1.1) :
+    (faceDisk K s x).1 ∈ ball 0 1 ↔ (faceMap K s.1 x).1.support = s.1.1 := by
+  rw [support_eq_iff]
+  exact (SimplexDisk.simplexDisk_open n _).trans (SimplexDisk.reindex_positive _ _)
+
+def diskMap {n : ℕ} (s : Cell K n) : C(closedBall (0 : Fin n → ℝ) 1, Space K) :=
+  ⟨(faceMap K s.1) ∘ (faceDisk K s).symm,(continuous_faceMap K s.1).comp (faceDisk K s).symm.continuous⟩
+
+lemma diskMap_injective {n : ℕ} (s : Cell K n) : Function.Injective (diskMap K s) :=
+  (faceMap_injective K s.1).comp (faceDisk K s).symm.injective
+
+lemma diskMap_range {n : ℕ} (s : Cell K n) : Set.range (diskMap K s) = Set.range (faceMap K s.1) :=
+  (faceDisk K s).symm.surjective.range_comp (faceMap K s.1)
+
+def characteristic {n : ℕ} (s : Cell K n) (x : Fin n → ℝ) : Space K := by
+  classical
+  exact if hx : x ∈ closedBall 0 1 then diskMap K s ⟨x,hx⟩ else diskMap K s ⟨0,by simp⟩
+
+lemma characteristic_disk {n : ℕ} (s : Cell K n) (x : closedBall (0 : Fin n → ℝ) 1) :
+    characteristic K s x.1 = diskMap K s x := by simp only [characteristic,dite_eq_left x.2]
+
+lemma characteristic_bijOn {n : ℕ} (s : Cell K n) :
+    Set.BijOn (characteristic K s) (ball 0 1) {x | x.1.support = s.1.1} := by
+  constructor
+  · intro x hx
+    let d : closedBall (0 : Fin n → ℝ) 1 := ⟨x,ball_subset_closedBall hx⟩
+    rw [show characteristic K s x = diskMap K s d from characteristic_disk K s d]
+    exact (faceDisk_open K s ((faceDisk K s).symm d)).mp (by simpa using hx)
+  constructor
+  · intro x hx y hy hxy
+    have hxy' : diskMap K s ⟨x,ball_subset_closedBall hx⟩ = diskMap K s ⟨y,ball_subset_closedBall hy⟩ := by
+      simpa only [← characteristic_disk] using hxy
+    exact congrArg Subtype.val (diskMap_injective K s hxy')
+  · intro x hx
+    let z := coordinates K s.1.1 x (by rw [hx])
+    let d := faceDisk K s z
+    have hd : d.1 ∈ ball 0 1 := (faceDisk_open K s z).mpr (by rwa [faceMap_coordinates])
+    exact ⟨d.1,hd,(characteristic_disk K s d).trans (by
+      change faceMap K s.1 ((faceDisk K s).symm (faceDisk K s z)) = x
+      rw [Homeomorph.symm_apply_apply]
+      exact faceMap_coordinates K s.1 x _)⟩
+
+def characteristicPE {n : ℕ} (s : Cell K n) : PartialEquiv (Fin n → ℝ) (Space K) :=
+  (characteristic_bijOn K s).toPartialEquiv _ _ _
+
+lemma characteristicPE_open {n : ℕ} (s : Cell K n) :
+    characteristicPE K s '' ball 0 1 = {x | x.1.support = s.1.1} :=
+  (characteristic_bijOn K s).image_eq
+
+lemma characteristicPE_closed {n : ℕ} (s : Cell K n) :
+    characteristicPE K s '' closedBall 0 1 = Set.range (faceMap K s.1) := by
+  rw [← diskMap_range]
+  ext x
+  constructor
+  · rintro ⟨z,hz,rfl⟩
+    exact ⟨⟨z,hz⟩,(characteristic_disk K s ⟨z,hz⟩).symm⟩
+  · rintro ⟨z,rfl⟩
+    exact ⟨z.1,z.2,characteristic_disk K s z⟩
+
+lemma characteristicPE_continuous {n : ℕ} (s : Cell K n) :
+    ContinuousOn (characteristicPE K s) (closedBall 0 1) := by
+  rw [continuousOn_iff_continuous_domRestrict]
+  have he : (closedBall (0:Fin n→ℝ) 1).domRestrict (characteristicPE K s) = diskMap K s := by
+    funext x
+    exact characteristic_disk K s x
+  rw [he]
+  exact (diskMap K s).continuous
+
+lemma characteristicPE_continuous_symm {n : ℕ} (s : Cell K n) :
+    ContinuousOn (characteristicPE K s).symm (characteristicPE K s).target := by
+  let e := characteristicPE K s
+  have he : IsEmbedding (e.source.domRestrict e) := by
+    let inc : ball (0:Fin n→ℝ) 1 → closedBall (0:Fin n→ℝ) 1 := fun x => ⟨x.1,ball_subset_closedBall x.2⟩
+    have hi : IsEmbedding inc := IsEmbedding.subtypeVal.codRestrict _ (fun x => ball_subset_closedBall x.2)
+    have heq : e.source.domRestrict e = (diskMap K s) ∘ inc := by
+      funext x
+      exact characteristic_disk K s (inc x)
+    rw [heq]
+    exact ((diskMap K s).continuous.isClosedEmbedding (diskMap_injective K s)).isEmbedding.comp hi
+  let H : e.source ≃ₜ e.target := e.toEquiv.toHomeomorphOfIsInducing
+    (he.isInducing.codRestrict (fun x => e.map_source x.2))
+  rw [continuousOn_iff_continuous_domRestrict]
+  exact continuous_subtype_val.comp H.symm.continuous
+
+lemma support_lt_of_sphere {n : ℕ} (s : Cell K n) (x : Fin n → ℝ) (hx : x ∈ sphere 0 1) :
+    (characteristicPE K s x).1.support.card < s.1.1.card := by
+  have hd := characteristic_disk K s ⟨x,sphere_subset_closedBall hx⟩
+  have hs : (characteristicPE K s x).1.support ⊆ s.1.1 := by
+    rw [show characteristicPE K s x = diskMap K s ⟨x,sphere_subset_closedBall hx⟩ from hd]
+    exact weight_support_subset _ _
+  apply Finset.card_lt_card
+  refine Finset.ssubset_iff_subset_ne.mpr ⟨hs,?_⟩
+  intro he
+  have ho : x ∈ ball (0:Fin n→ℝ) 1 := by
+    have hh := (faceDisk_open K s ((faceDisk K s).symm ⟨x,sphere_subset_closedBall hx⟩)).mpr (by
+      change (characteristic K s x).1.support = s.1.1 at he
+      rwa [hd] at he)
+    simpa only [Homeomorph.apply_symm_apply] using hh
+  exact sphere_disjoint_ball.notMem_of_mem_left hx ho
+
+lemma subcells_finite (s : Face K) (n : ℕ) : Set.Finite {c : Cell K n | c.1.1 ⊆ s.1} := by
+  classical
+  have hinj : Function.Injective (fun c : Cell K n => c.1.1) := Subtype.val_injective.comp Subtype.val_injective
+  have hfin := (s.1.powerset.finite_toSet).preimage hinj.injOn
+  convert hfin using 1
+  ext c
+  simp only [mem_ofPred_eq,mem_preimage,Finset.mem_coe,Finset.mem_powerset]
+
+noncomputable def subcells (s : Face K) (n : ℕ) : Finset (Cell K n) := (subcells_finite K s n).toFinset
+
+lemma characteristic_boundary {n : ℕ} (s : Cell K n) :
+    MapsTo (characteristicPE K s) (sphere 0 1)
+      (⋃ (m < n) (j ∈ subcells K s.1 m), characteristicPE K j '' closedBall 0 1) := by
+  intro x hx
+  let y := characteristicPE K s x
+  let t : Face K := ⟨y.1.support,y.2.2.2⟩
+  let m := y.1.support.card-1
+  let c : Cell K m := cellOfFace K t
+  have hpos : 0 < y.1.support.card := Finset.card_pos.mpr (support_nonempty y.2.2.1)
+  have hlt : y.1.support.card < s.1.1.card := support_lt_of_sphere K s x hx
+  have hmn : m < n := by dsimp [m]; rw [s.2] at hlt; omega
+  have hcs : c ∈ subcells K s.1 m := by
+    rw [subcells,Set.Finite.mem_toFinset]
+    change y.1.support ⊆ s.1.1
+    rw [show y = diskMap K s ⟨x,sphere_subset_closedBall hx⟩ from characteristic_disk K s ⟨x,sphere_subset_closedBall hx⟩]
+    exact weight_support_subset _ _
+  refine mem_iUnion.mpr ⟨m,mem_iUnion.mpr ⟨hmn,mem_iUnion.mpr ⟨c,mem_iUnion.mpr ⟨hcs,?_⟩⟩⟩⟩
+  rw [characteristicPE_closed,range_faceMap]
+  exact Finset.Subset.refl _
+
+instance cwComplex : Topology.CWComplex (Set.univ : Set (Space K)) where
+  cell := Cell K
+  map _ := characteristicPE K
+  source_eq _ _ := rfl
+  continuousOn _ := characteristicPE_continuous K
+  continuousOn_symm _ := characteristicPE_continuous_symm K
+  pairwiseDisjoint' := by
+    intro a _ b _ hab
+    change Disjoint (characteristicPE K a.2 '' ball 0 1) (characteristicPE K b.2 '' ball 0 1)
+    rw [characteristicPE_open,characteristicPE_open]
+    apply Set.disjoint_left.mpr
+    intro x hx hy
+    have he : a.2.1.1 = b.2.1.1 := hx.symm.trans hy
+    have hn : a.1 = b.1 := by have hc := congrArg Finset.card he; rw [a.2.2,b.2.2] at hc; omega
+    apply hab
+    rcases a with ⟨n,a⟩
+    rcases b with ⟨m,b⟩
+    dsimp at hn
+    subst m
+    exact congrArg (Sigma.mk n) (Subtype.ext (Subtype.ext he))
+  mapsTo' _ s := ⟨subcells K s.1,characteristic_boundary K s⟩
+  closed' A _ hA := by
+    rw [isClosed_iff]
+    intro s
+    have hc := hA _ (cellOfFace K s)
+    rw [characteristicPE_closed] at hc
+    have hp := hc.preimage (continuous_faceMap K s)
+    have he : (faceMap K s) ⁻¹' (A ∩ Set.range (faceMap K (cellOfFace K s).1)) = (faceMap K s) ⁻¹' A := by
+      ext z; simp only [mem_preimage,mem_inter_iff]; exact and_iff_left (mem_range_self z)
+    rwa [he] at hp
+  union' := by
+    apply Set.Subset.antisymm (subset_univ _)
+    intro x _
+    let s : Face K := ⟨x.1.support,x.2.2.2⟩
+    refine mem_iUnion.mpr ⟨s.1.card-1,mem_iUnion.mpr ⟨cellOfFace K s,?_⟩⟩
+    rw [characteristicPE_closed,range_faceMap]
+    exact Finset.Subset.refl _
+end GroupRingTopology.Simplicial
+open Set Metric Topology
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/GroupRing/SphereTopology.lean b/lean/OAI/Algebra/GroupRing/SphereTopology.lean
new file mode 100644
index 0000000000000000000000000000000000000000..2f01fe64aa6a7fbeb1528a0d629d7521c9dfcb4e
--- /dev/null
+++ b/lean/OAI/Algebra/GroupRing/SphereTopology.lean
@@ -0,0 +1,433 @@
+import Mathlib
+import OAI.Algebra.GroupRing.AttachmentFurther
+import OAI.Algebra.GroupRing.CellularFurther2
+
+namespace OAI
+
+noncomputable section
+
+open Set Metric Topology BigOperators
+open Set Metric Topology
+open Set Topology
+open Set Metric Topology
+open scoped NNReal
+open Set Metric Topology
+open scoped NNReal ENNReal
+open Set Metric Topology
+
+namespace GroupRingTopology.Cellular
+open Set Metric Topology
+universe u v
+variable {X : Type u} [TopologicalSpace X] [T2Space X]
+variable {C : Set X} [CWComplex C]
+variable {K : Type v} [MetricSpace K] [CompactSpace K]
+
+def skeletonInclusion (n : ℕ) : C(Skeleton C n,X) := ⟨Subtype.val,continuous_subtype_val⟩
+
+/-- One step of the classical cellular approximation theorem, without any
+local finiteness assumption on the target CW complex. -/
+lemma deform_skeleton_succ (n : ℕ) (f : C(K,Skeleton C (n+1)))
+    (hdim : dimH (Set.univ : Set K) < n) :
+    ∃ (g : C(K,Skeleton C n))
+      (H : f.Homotopy ((skeletonBase n).comp g)),
+      ∀ t x, (f x).1 ∈ Skeleton C n → H (t,x) = f x := by
+  let e := skeletonHomeomorph (C := C) n
+  let : T2Space (Attachment.Space (skeletonBoundary (C := C) n)) := e.symm.t2Space
+  let f' : C(K,Attachment.Space (skeletonBoundary (C := C) n)) := (⟨e.symm,e.symm.continuous⟩ : C(_, _)).comp f
+  obtain ⟨g,H,hH⟩ := Attachment.exists_deformation_into_base (skeletonBoundary (C := C) n) f' hdim
+  have h0 : (⟨e,e.continuous⟩ : C(_, _)).comp f' = f := by apply ContinuousMap.ext; intro x; exact e.apply_symm_apply (f x)
+  have h1 : (⟨e,e.continuous⟩ : C(_, _)).comp
+      ((⟨Attachment.base _,Attachment.continuous_base _⟩ : C(_, _)).comp g) =
+      (skeletonBase n).comp g := by apply ContinuousMap.ext; intro x; exact skeletonAssembly_base n (g x)
+  let J := (ContinuousMap.Homotopy.refl (⟨e,e.continuous⟩ : C(_, _))).comp H
+  refine ⟨g,J.cast h0 h1,?_⟩
+  intro t x hx
+  change e (H (t,x)) = f x
+  have hr : f' x ∈ Set.range (Attachment.base (skeletonBoundary (C := C) n)) := by
+    refine ⟨⟨(f x).1,hx⟩,?_⟩
+    apply e.injective
+    change skeletonAssembly n (Attachment.base _ _) = e (e.symm (f x))
+    rw [skeletonAssembly_base,e.apply_symm_apply]
+    rfl
+  rw [hH t x hr]
+  exact e.apply_symm_apply (f x)
+
+/-- Bounded-skeleton cellular approximation with a stationary relative set:
+all points initially in the target skeleton remain fixed. -/
+lemma deform_bounded_skeleton (d m : ℕ) (f : C(K,Skeleton C m))
+    (hdim : dimH (Set.univ : Set K) < d) :
+    ∃ (g : C(K,Skeleton C d))
+      (H : ((skeletonInclusion m).comp f).Homotopy ((skeletonInclusion d).comp g)),
+      ∀ t x, (f x).1 ∈ Skeleton C d → H (t,x) = (f x).1 := by
+  induction m with
+  | zero =>
+    let g : C(K,Skeleton C d) := ⟨fun x => ⟨(f x).1,skeleton_mono (Nat.zero_le d) (f x).2⟩,
+      f.continuous.subtype_val.subtype_mk _⟩
+    exact ⟨g,.refl _,fun _ _ _ => rfl⟩
+  | succ m ih =>
+    by_cases hmd : m+1 ≤ d
+    · let g : C(K,Skeleton C d) := ⟨fun x => ⟨(f x).1,skeleton_mono hmd (f x).2⟩,
+        f.continuous.subtype_val.subtype_mk _⟩
+      exact ⟨g,.refl _,fun _ _ _ => rfl⟩
+    · have hdm : d ≤ m := by omega
+      obtain ⟨g,H,hH⟩ := deform_skeleton_succ m f (hdim.trans_le (by exact_mod_cast hdm))
+      obtain ⟨g',J,hJ⟩ := ih g
+      let H' := (ContinuousMap.Homotopy.refl (skeletonInclusion (C := C) (m+1))).comp H
+      refine ⟨g',H'.trans J,?_⟩
+      intro t x hx
+      have hh (s : unitInterval) : H' (s,x) = (f x).1 := by
+        exact congrArg Subtype.val (hH s x (skeleton_mono hdm hx))
+      have hg : (g x).1 = (f x).1 := by
+        have he := hh 1
+        rw [ContinuousMap.Homotopy.apply_one] at he
+        exact he
+      have hj (s : unitInterval) : J (s,x) = (f x).1 := by
+        rw [hJ s x (hg.symm ▸ hx),hg]
+      erw [ContinuousMap.Homotopy.trans_apply]
+      split_ifs
+      · exact hh _
+      · exact hj _
+
+/-- Cellular approximation for arbitrary compact finite-Hausdorff-dimensional
+sources. Compactness bounds the traversed dimensions, not the number of cells
+of the whole CW complex. -/
+theorem exists_cellular_approximation (d : ℕ) (f : C(K,X)) (hf : ∀ x,f x ∈ C)
+    (hdim : dimH (Set.univ : Set K) < d) :
+    ∃ (g : C(K,Skeleton C d)) (H : f.Homotopy ((skeletonInclusion d).comp g)),
+      ∀ t x, f x ∈ Skeleton C d → H (t,x) = f x := by
+  obtain ⟨m,hm⟩ := compactMap_bounded_skeleton f hf
+  let f' : C(K,Skeleton C m) := ⟨fun x => ⟨f x,hm x⟩,f.continuous.subtype_mk _⟩
+  exact deform_bounded_skeleton d m f' hdim
+end GroupRingTopology.Cellular
+namespace GroupRingTopology.SphereTopology
+open Set Metric Topology
+universe u
+variable {Y : Type u} [TopologicalSpace Y]
+lemma fill_zero [Nonempty Y] (a : C(Cellular.Sphere 0,Y)) :
+    ∃ e : C(Cellular.Disk 0,Y), ∀ x, e (Cellular.boundary 0 x) = a x := by
+  refine ⟨.const _ (Classical.choice ‹Nonempty Y›),?_⟩
+  intro x
+  have hx := x.2
+  have hz : x.1 = 0 := Subsingleton.elim _ _
+  simp only [hz,mem_sphere,dist_self] at hx
+  exact False.elim (zero_ne_one hx)
+lemma fill_one [PathConnectedSpace Y] (a : C(Cellular.Sphere 1,Y)) :
+    ∃ e : C(Cellular.Disk 1,Y), ∀ x, e (Cellular.boundary 1 x) = a x := by
+  let p := (PathConnectedSpace.joined (a Cayley.minus) (a Cayley.plus)).somePath
+  let e : C(Cellular.Disk 1,Y) := p.toContinuousMap.comp ⟨Cayley.edgeTime,Cayley.continuous_edgeTime⟩
+  refine ⟨e,?_⟩
+  intro x
+  obtain rfl|rfl := Cayley.sphere_one_eq x
+  · change p (Cayley.edgeTime (Attachment.boundary 1 Cayley.minus)) = _
+    rw [Cayley.edgeTime_minus,p.source]
+  · change p (Cayley.edgeTime (Attachment.boundary 1 Cayley.plus)) = _
+    rw [Cayley.edgeTime_plus,p.target]
+end GroupRingTopology.SphereTopology
+namespace GroupRingTopology.Cellular
+open Set Metric Topology
+universe u v w
+variable {Y : Type v} {Z : Type w} [TopologicalSpace Y] [TopologicalSpace Z]
+
+/-- A ghost map in one geometric degree, including unbased spheres. -/
+def KillsSpheres (q : C(Y,Z)) (n : ℕ) : Prop :=
+  ∀ a : C(Sphere n,Y), ∃ F : C(Disk n,Z), ∀ x, F (boundary n x) = q (a x)
+
+lemma cylinder_filling_after {n : ℕ} (q : C(Y,Z)) (hq : KillsSpheres q (n+1))
+    (a : C(Sphere n,C(unitInterval,Y))) (b : C(Disk n,Y × Y))
+    (h : ∀ x, pathEndpoint (a x) = b (boundary n x)) :
+    ∃ e : C(Disk n,C(unitInterval,Z)),
+      (∀ x t, e (boundary n x) t = q (a x t)) ∧
+      ∀ x, pathEndpoint (e x) = (q (b x).1,q (b x).2) := by
+  obtain ⟨F,hF⟩ := hq (cylinderBoundaryMap a b h)
+  let e : C(Disk n,C(unitInterval,Z)) :=
+    (F.comp ⟨fun p : Disk n × unitInterval => diskCons p.1 p.2,continuous_diskCons⟩).curry
+  refine ⟨e,?_,?_⟩
+  · intro x t
+    let s : Sphere (n+1) := ⟨_,cons_mem_sphere_of_boundary x t⟩
+    have hs : s ∈ cylinderFace n none := by
+      change (diskTail (diskCons (boundary n x) t)).1 ∈ sphere 0 1
+      rw [diskTail_cons]
+      exact x.2
+    change F (diskCons (boundary n x) t) = q (a x t)
+    rw [show diskCons (boundary n x) t = boundary (n+1) s from rfl,hF,
+      cylinderBoundaryMap_face a b h none ⟨s,hs⟩]
+    change q (a (faceSphere ⟨s,hs⟩) (diskTime (diskCons (boundary n x) t))) = q (a x t)
+    rw [diskTime_cons]
+    congr 2
+  · intro x
+    apply Prod.ext
+    · let s : Sphere (n+1) := ⟨_,cons_zero_mem_sphere x⟩
+      have hs : s ∈ cylinderFace n (some false) := by
+        change (diskCons x 0).1 0 = -1
+        norm_num [diskCons]
+      change F (diskCons x 0) = q (b x).1
+      rw [show diskCons x 0 = boundary (n+1) s from rfl,hF,
+        cylinderBoundaryMap_face a b h (some false) ⟨s,hs⟩]
+      change q (b (diskTail (diskCons x 0))).1 = q (b x).1
+      rw [diskTail_cons]
+    · let s : Sphere (n+1) := ⟨_,cons_one_mem_sphere x⟩
+      have hs : s ∈ cylinderFace n (some true) := by
+        change (diskCons x 1).1 0 = 1
+        norm_num [diskCons]
+      change F (diskCons x 1) = q (b x).2
+      rw [show diskCons x 1 = boundary (n+1) s from rfl,hF,
+        cylinderBoundaryMap_face a b h (some true) ⟨s,hs⟩]
+      change q (b (diskTail (diskCons x 1))).2 = q (b x).2
+      rw [diskTail_cons]
+
+variable {X : Type u} [TopologicalSpace X] [T2Space X]
+variable {C : Set X} [CWComplex C]
+
+structure PartialHomotopy (f g : C(X,Y)) (n : ℕ) where
+  val : X → C(unitInterval,Y)
+  continuousOn : ContinuousOn val (Skeleton C n)
+  zero : ∀ x ∈ Skeleton C n, val x 0 = f x
+  one : ∀ x ∈ Skeleton C n, val x 1 = g x
+
+namespace PartialHomotopy
+variable {f g : C(X,Y)} {n : ℕ}
+
+def onSphere (a : PartialHomotopy (C := C) f g n) (i : RelCWComplex.cell C n) :
+    C(Sphere n,C(unitInterval,Y)) :=
+  ⟨fun x => a.val (characteristic n i (boundary n x)),
+    a.continuousOn.comp_continuous ((characteristic n i).continuous.comp (continuous_boundary n))
+      (sphere_mem_skeleton n i)⟩
+
+def endpoints (i : RelCWComplex.cell C n) : C(Disk n,Y × Y) :=
+  ⟨fun x => (f (characteristic n i x),g (characteristic n i x)),
+    (f.continuous.comp (characteristic n i).continuous).prodMk
+      (g.continuous.comp (characteristic n i).continuous)⟩
+
+lemma endpoints_compatible (a : PartialHomotopy (C := C) f g n)
+    (i : RelCWComplex.cell C n) (x : Sphere n) :
+    pathEndpoint (a.onSphere i x) = endpoints (f := f) (g := g) i (boundary n x) :=
+  Prod.ext (a.zero _ (sphere_mem_skeleton n i x)) (a.one _ (sphere_mem_skeleton n i x))
+
+lemma cell_extension_after (a : PartialHomotopy (C := C) f g n)
+    (q : C(Y,Z)) (hq : KillsSpheres q (n+1)) (i : RelCWComplex.cell C n) :
+    ∃ e : C(Disk n,C(unitInterval,Z)),
+      (∀ x, e (boundary n x) = q.comp (a.val (characteristic n i (boundary n x)))) ∧
+      (∀ x, e x 0 = q (f (characteristic n i x))) ∧
+      (∀ x, e x 1 = q (g (characteristic n i x))) := by
+  obtain ⟨e,he,hp⟩ := cylinder_filling_after q hq (a.onSphere i) (endpoints i)
+    (a.endpoints_compatible i)
+  exact ⟨e,fun x => ContinuousMap.ext (he x),fun x => congrArg Prod.fst (hp x),
+    fun x => congrArg Prod.snd (hp x)⟩
+
+/-- A single uniform ghost extends every partially constructed homotopy by a
+whole CW dimension, even if there are infinitely many cells in that dimension. -/
+def next (a : PartialHomotopy (C := C) f g n)
+    (q : C(Y,Z)) (hq : KillsSpheres q (n+1)) :
+    PartialHomotopy (C := C) (q.comp f) (q.comp g) (n+1) := by
+  let e := fun i => (a.cell_extension_after q hq i).choose
+  have hb : ∀ i x, e i (boundary n x) =
+      q.comp (a.val (characteristic n i (boundary n x))) :=
+    fun i => (a.cell_extension_after q hq i).choose_spec.1
+  have hz := fun i => (a.cell_extension_after q hq i).choose_spec.2.1
+  have ho := fun i => (a.cell_extension_after q hq i).choose_spec.2.2
+  let v : X → C(unitInterval,Z) := fun x => q.comp (a.val x)
+  have hv : ContinuousOn v (Skeleton C n) :=
+    (ContinuousMap.continuous_postcomp q).comp_continuousOn a.continuousOn
+  refine ⟨attachValue v e,attachValue_continuous v hv e hb,?_,?_⟩
+  all_goals
+    intro x hx
+    have heq : Skeleton C (n+1) = Skeleton C n ∪
+        ⋃ i : RelCWComplex.cell C n, CWComplex.closedCell n i := by
+      simpa only [Skeleton,Nat.cast_add,Nat.cast_one] using
+        (CWComplex.skeletonLT_union_iUnion_closedCell_eq_skeletonLT_succ (C := C) n).symm
+    rw [heq] at hx
+    rcases hx with hx | hx
+    · rw [attachValue_old v e hx]
+      first
+      | exact congrArg q (a.zero x hx)
+      | exact congrArg q (a.one x hx)
+    · obtain ⟨i,y,hy,rfl⟩ := Set.mem_iUnion.mp hx
+      rw [show RelCWComplex.map n i y = characteristic n i ⟨y,hy⟩ from rfl,
+        attachValue_characteristic v e hb]
+      first | exact hz i ⟨y,hy⟩ | exact ho i ⟨y,hy⟩
+
+def start (f g : C(X,Y)) : PartialHomotopy (C := C) f g 0 where
+  val := fun x => ContinuousMap.const _ (f x)
+  continuousOn := by
+    rw [Skeleton,Nat.cast_zero,CWComplex.skeletonLT_zero_eq_empty]
+    exact continuousOn_empty _
+  zero := by intro x _; rfl
+  one := by
+    intro x hx
+    simp only [Skeleton,Nat.cast_zero,CWComplex.skeletonLT_zero_eq_empty,Set.mem_empty_iff_false] at hx
+
+/-- On a whole finite-dimensional complex the final partial homotopy is an
+ordinary continuous homotopy, not merely cellwise data. -/
+def toHomotopy [CWComplex (Set.univ : Set X)] (a : PartialHomotopy (C := (Set.univ : Set X)) f g n)
+    (hdim : Skeleton (Set.univ : Set X) n = Set.univ) : f.Homotopy g where
+  toFun p := a.val p.2 p.1
+  continuous_toFun := by
+    have hv : Continuous a.val := by
+      have hh := a.continuousOn
+      rw [hdim] at hh
+      exact continuousOn_univ.mp hh
+    exact continuous_eval.comp ((hv.comp continuous_snd).prodMk continuous_fst)
+  map_zero_left x := a.zero x (hdim.symm ▸ Set.mem_univ x)
+  map_one_left x := a.one x (hdim.symm ▸ Set.mem_univ x)
+
+end PartialHomotopy
+end GroupRingTopology.Cellular
+
+namespace TorsionFreeZeroDivisors.FiniteDimensionalCW
+open Set Metric Topology GroupRingTopology GroupRingTopology.Cellular
+universe u
+variable {X : Type u} [TopologicalSpace X] [T2Space X]
+  [CWComplex (Set.univ : Set X)]
+/-- No higher cells really means that the indicated finite skeleton is the
+whole space; no replacement by homology or a resolution is involved. -/
+lemma skeleton_eq_univ (N : ℕ)
+    (hdim : ∀ m : ℕ, N ≤ m → IsEmpty (RelCWComplex.cell (Set.univ : Set X) m)) :
+    Skeleton (Set.univ : Set X) N=Set.univ := by
+  apply Set.eq_univ_iff_forall.mpr
+  intro x
+  have hx : x ∈ ⋃m,⋃i : RelCWComplex.cell (Set.univ : Set X) m,CWComplex.openCell m i := by
+    rw [CWComplex.iUnion_openCell_eq_complex]
+    trivial
+  obtain ⟨m,hx⟩ := Set.mem_iUnion.mp hx
+  obtain ⟨i,hi⟩ := Set.mem_iUnion.mp hx
+  have hm : m<N := by
+    by_contra h
+    exact (hdim m (by omega)).false i
+  exact CWComplex.mem_skeletonLT_iff.mpr ⟨m,by exact_mod_cast hm,i,hi⟩
+
+/-- A two-dimensional CW contraction uses only fillings of circles and
+2-spheres: extend the contraction over actual 0-, 1-, and 2-cells. This is the
+needed special case of Whitehead, proved directly using cellular homotopy
+extension from the supplied checked support. -/
+theorem contractible_of_two_dimensional_fills [PathConnectedSpace X]
+    (hdim : ∀ m : ℕ, 2 < m → IsEmpty (RelCWComplex.cell (Set.univ : Set X) m))
+    (hcircle : ∀ a : C(SphereTopology.Sphere 2,X),SphereTopology.Extends a)
+    (hsphere : ∀ a : C(SphereTopology.Sphere 3,X),SphereTopology.Extends a) :
+    ContractibleSpace X := by
+  let x₀ : X := Classical.choice (inferInstance : Nonempty X)
+  let f : C(X,X) := ContinuousMap.id X
+  let g : C(X,X) := ContinuousMap.const X x₀
+  have h1 : KillsSpheres (ContinuousMap.id X) 1 := fun a=>SphereTopology.fill_one a
+  have h2 : KillsSpheres (ContinuousMap.id X) 2 := by
+    intro a
+    obtain ⟨F,hF⟩ := hcircle a
+    exact ⟨F,fun x=>ContinuousMap.congr_fun hF x⟩
+  have h3 : KillsSpheres (ContinuousMap.id X) 3 := by
+    intro a
+    obtain ⟨F,hF⟩ := hsphere a
+    exact ⟨F,fun x=>ContinuousMap.congr_fun hF x⟩
+  let A := PartialHomotopy.start (C:=Set.univ) f g
+  let B := A.next (ContinuousMap.id X) h1
+  let C := B.next (ContinuousMap.id X) h2
+  let D := C.next (ContinuousMap.id X) h3
+  have hsk : Skeleton (Set.univ : Set X) 3=Set.univ :=
+    skeleton_eq_univ 3 (fun m hm=>hdim m (by omega))
+  have H : f.Homotopy g := D.toHomotopy hsk
+  exact (contractible_iff_id_nullhomotopic X).mpr ⟨x₀,⟨H⟩⟩
+end TorsionFreeZeroDivisors.FiniteDimensionalCW
+
+namespace TorsionFreeZeroDivisors.PresentationTopology
+open Set Metric Topology GroupRingTopology GroupRingTopology.Attachment
+variable {G S : Type} [Group G] [TopologicalSpace G] [DiscreteTopology G]
+
+def pointCover : C(G,PUnit) := .const _ PUnit.unit
+lemma pointCover_quotient : IsQuotientCoveringMap (pointCover (G := G)) G where
+  __ := show IsQuotientMap (pointCover (G := G)) from
+    (show IsOpenMap (pointCover (G := G)) from fun _ _ => isOpen_discrete _).isQuotientMap
+      (by fun_prop) (fun _ => ⟨1,rfl⟩)
+  __ := (inferInstance : ContinuousConstSMul G G)
+  apply_eq_iff_mem_orbit := by
+    intro x y
+    constructor
+    · intro _; exact ⟨x*y⁻¹,by simp [smul_eq_mul]⟩
+    · intro _; rfl
+  disjoint x := by
+    refine ⟨{x},(isOpen_discrete _).mem_nhds (Set.mem_singleton x),?_⟩
+    rintro g ⟨z,⟨y,hy,rfl⟩,h⟩
+    simp only [Set.mem_singleton_iff] at hy h
+    rw [hy] at h
+    exact mul_right_cancel (show g*x=1*x by simpa only [smul_eq_mul,one_mul] using h)
+
+variable (s : S → G)
+def roseAttaching : S → C(Sphere 1,PUnit) := fun i=>(pointCover (G:=G)).comp (Cayley.attaching s i)
+abbrev Rose := Space (roseAttaching s)
+def graphProjection : C(Cayley.Graph s,Rose s) :=
+  coverMap (Cayley.attaching s) pointCover pointCover_quotient (roseAttaching s) (fun _ _=>rfl)
+lemma graphProjection_quotient : IsQuotientCoveringMap (graphProjection s) G :=
+  coverMap_isQuotientCovering _ _ _ _ _
+instance roseT2 : T2Space (Rose s) := t2Space _ realSeparated_of_tychonoff
+instance roseCW : CWComplex (Set.univ : Set (Rose s)) :=
+  layerCW _ Cayley.discrete_dimension
+omit [DiscreteTopology G] in
+lemma rose_dimension (m : ℕ) (i : RelCWComplex.cell (Set.univ : Set (Rose s)) m) : m<2 :=
+  layerCW_dimensions _ Cayley.discrete_dimension m i
+omit [DiscreteTopology G] in
+lemma rose_finite [Finite S] (m : ℕ) : Finite (RelCWComplex.cell (Set.univ : Set (Rose s)) m) := by
+  apply layerCW_finite_cells
+  intro n
+  cases n with
+  | zero => change Finite (Set.univ : Set PUnit); infer_instance
+  | succ n => change Finite PEmpty; infer_instance
+instance rosePathConnected : PathConnectedSpace (Rose s) := by
+  let := SphereTopology.sphere_nonempty 0
+  exact Attachment.pathConnectedSpace _
+
+variable (rels : Set (FreeGroup S)) (hrel : ∀ r ∈ rels, FreeGroup.lift s r=1)
+def diskAttaching : rels → C(Sphere 2,Rose s) := fun r=>
+  (graphProjection s).comp (Cayley.relatorAttaching s rels hrel r)
+abbrev Base := Space (diskAttaching s rels hrel)
+def projection : C(Cayley.PresentationCover s rels hrel,Base s rels hrel) :=
+  coverMap (Cayley.relatorAttaching s rels hrel) (graphProjection s)
+    (graphProjection_quotient s) (diskAttaching s rels hrel) (fun _ _=>rfl)
+lemma projection_quotient : IsQuotientCoveringMap (projection s rels hrel) G :=
+  coverMap_isQuotientCovering _ _ _ _ _
+instance baseT2 : T2Space (Base s rels hrel) :=
+  t2Space _ (realSeparated _ realSeparated_of_tychonoff)
+instance baseCW : CWComplex (Set.univ : Set (Base s rels hrel)) :=
+  layerCW _ (rose_dimension s)
+lemma base_dimension (m : ℕ) (i : RelCWComplex.cell (Set.univ : Set (Base s rels hrel)) m) : m<3 :=
+  layerCW_dimensions _ (rose_dimension s) m i
+lemma base_no_higher (m : ℕ) (hm : 2 < m) :
+    IsEmpty (RelCWComplex.cell (Set.univ : Set (Base s rels hrel)) m) :=
+  ⟨fun i=>by have := base_dimension s rels hrel m i; omega⟩
+lemma base_finite [Finite S] [Finite rels] : CWComplex.Finite (Set.univ : Set (Base s rels hrel)) where
+  eventually_isEmpty_cell := Filter.eventually_atTop.mpr ⟨3,fun m hm=>base_no_higher s rels hrel m (by omega)⟩
+  finite_cell m := layerCW_finite_cells _ (rose_finite s) (rose_dimension s) m
+lemma base_two_cell (hr : rels.Nonempty) :
+    Nonempty (RelCWComplex.cell (Set.univ : Set (Base s rels hrel)) 2) := by
+  obtain ⟨r,hr⟩ := hr
+  exact ⟨Sum.inr ⟨⟨⟨rfl⟩,⟨r,hr⟩⟩⟩⟩
+instance basePathConnected : PathConnectedSpace (Base s rels hrel) := by
+  let := SphereTopology.sphere_nonempty 1
+  exact Attachment.pathConnectedSpace _
+def coverPoint : Cayley.PresentationCover s rels hrel :=
+  Cayley.presentationBase s rels hrel (Cayley.vertex s 1)
+def basePoint : Base s rels hrel := projection s rels hrel (coverPoint s rels hrel)
+lemma cover_no_higher (m : ℕ) (hm : 2 < m) :
+    IsEmpty (RelCWComplex.cell (Set.univ : Set (Cayley.PresentationCover s rels hrel)) m) := by
+  refine ⟨fun i=>?_⟩
+  have := layerCW_dimensions (equivariantFamily (G:=G) (Cayley.relatorAttaching s rels hrel))
+    (Cayley.graph_dimension s) m i
+  omega
+
+variable (hs : Function.Surjective (FreeGroup.lift s))
+  (hker : (FreeGroup.lift s).ker=Subgroup.normalClosure rels)
+def fundamentalEquiv : G ≃* FundamentalGroup (Base s rels hrel) (basePoint s rels hrel) := by
+  let := Cayley.presentationCover_simplyConnected s rels hrel hs hker
+  exact (MulEquiv.inv' G).trans
+    ((projection_quotient s rels hrel).fundamentalGroupEquiv
+      ⟨coverPoint s rels hrel,rfl⟩).symm
+
+include hs hker in
+lemma contractible_cover
+    (hfill : ∀ a : C(Sphere 3,Cayley.PresentationCover s rels hrel),SphereTopology.Extends a) :
+    ContractibleSpace (Cayley.PresentationCover s rels hrel) := by
+  let := Cayley.presentationCover_pathConnected s rels hrel hs
+  exact FiniteDimensionalCW.contractible_of_two_dimensional_fills
+    (cover_no_higher s rels hrel) (Cayley.presentationCover_sphereFill s rels hrel hs hker) hfill
+
+end TorsionFreeZeroDivisors.PresentationTopology
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/GroupRing/SplitModel.lean b/lean/OAI/Algebra/GroupRing/SplitModel.lean
new file mode 100644
index 0000000000000000000000000000000000000000..ed638897a8fe2570242c210b4bc7073b5f03c1a9
--- /dev/null
+++ b/lean/OAI/Algebra/GroupRing/SplitModel.lean
@@ -0,0 +1,66 @@
+import Mathlib
+import OAI.Algebra.GroupRing.Basic
+import OAI.Algebra.GroupRing.AbsorbCells
+import OAI.Algebra.GroupRing.VertexCollapse
+import OAI.Algebra.GroupRing.RelationSplit
+
+namespace OAI
+
+noncomputable section
+
+namespace TorsionFreeZeroDivisors.SplitModel
+open Set Topology GroupRingTopology GroupRingTopology.Attachment
+variable {G S Q : Type} [Group G] [TopologicalSpace G] [DiscreteTopology G]
+  (s : S→G) (w : Q→FreeGroup S) (hw : ∀i,FreeGroup.lift s (w i)=1)
+  (hs : Function.Surjective (FreeGroup.lift s))
+  (hker : (FreeGroup.lift s).ker=Subgroup.normalClosure (Set.range w))
+  (L : CellModule.Module G S→+CellModule.Module G Q)
+  (hL : ∀g i,L (CellModule.translate g (CellModule.fox (FreeGroup.lift s) (w i)))=Finsupp.single (g,i) 1)
+include hs hker hL in
+theorem contractible : ContractibleSpace (IndexedCells.Cover s w hw) := by
+  let := IndexedCells.cover_simplyConnected s w hw hs hker
+  let a := IndexedCells.attaching s w hw
+  let f : C(IndexedCells.Cover s w hw,IndexedCells.Cover s w hw) := .id _
+  let y := IndexedCells.inclusion s w hw (Cayley.vertex s 1)
+  let f' := VertexCollapse.map s a f y
+  have hv : ∀g,f' (IndexedCells.inclusion s w hw (Cayley.vertex s g))=y :=
+    VertexCollapse.map_vertex s a f y
+  apply (contractible_iff_id_nullhomotopic _).mpr
+  exact ⟨y,⟨(VertexCollapse.homotopy s a f y).trans (AbsorbCells.homotopy s w hw L hL f' y hv)⟩⟩
+include hw hs hker hL in
+theorem has_model [Finite S] [Finite Q] [Nonempty Q] : HasFiniteTwoDimensionalClassifyingSpace G := by
+  let a := IndexedCells.attaching s w hw
+  refine ⟨IndexedCells.Base s w hw,inferInstance,inferInstance,inferInstance,inferInstance,
+    CellPresentation.base_finite s a,CellPresentation.base_no_higher s a,
+    CellPresentation.base_two_cell s a,CellPresentation.basePoint s a,
+    ⟨CellPresentation.fundamentalEquiv s a w (IndexedCells.wordLift_rel s w hw) hs hker⟩,
+    IndexedCells.Cover s w hw,inferInstance,contractible s w hw hs hker L hL,
+    CellPresentation.projection s a,?_,?_⟩
+  · exact (CellPresentation.projection_quotient s a).isCoveringMap
+  · exact (CellPresentation.projection_quotient s a).surjective
+end TorsionFreeZeroDivisors.SplitModel
+
+namespace TorsionFreeZeroDivisors.RelationModel
+open AlgebraicPictures RelationArea
+variable {A I : Type} (rel : I→List (A×Bool))
+  (hz : ∀ts : List (Term (A:=A) (I:=I)),FreeGroup.mk (word rel ts)=1→total rel ts=0)
+local instance : TopologicalSpace (G rel) := ⊥
+local instance : DiscreteTopology (G rel) := ⟨rfl⟩
+def generators : A→G rel := PresentedGroup.of
+lemma lift_generators : FreeGroup.lift (generators rel)=q rel := by ext a;rfl
+include hz in
+theorem has_model [Finite A] [Finite I] [Nonempty I] : HasFiniteTwoDimensionalClassifyingSpace (G rel) := by
+  apply SplitModel.has_model (generators rel) (fun i=>FreeGroup.mk (rel i))
+    (fun i=>by rw [lift_generators];exact q_rel rel i)
+    (by rw [lift_generators];exact PresentedGroup.mk_surjective _)
+    (by rw [lift_generators];exact QuotientGroup.ker_mk' _)
+    (RelationSplit.retract rel)
+  intro g i
+  rw [lift_generators]
+  have h:=RelationSplit.retract_d₂_single rel hz g i
+  simpa only [RelationArea.d₂_single,one_zsmul] using h
+end TorsionFreeZeroDivisors.RelationModel
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/GroupRing/StageBlocks.lean b/lean/OAI/Algebra/GroupRing/StageBlocks.lean
new file mode 100644
index 0000000000000000000000000000000000000000..c5cfa4674b5d086669a9ae2468ada56d43628c1c
--- /dev/null
+++ b/lean/OAI/Algebra/GroupRing/StageBlocks.lean
@@ -0,0 +1,477 @@
+import Mathlib
+import OAI.Algebra.GroupRing.LinkComponents
+import OAI.Algebra.GroupRing.WordEstimate
+
+namespace OAI
+
+noncomputable section
+
+namespace TorsionFreeZeroDivisors.StageBlocks
+open scoped BigOperators Classical
+open StageLabels WordEstimate
+variable {I : Type*} [Fintype I] {h : I → ℕ}
+variable (L : Links (T := Letter) h)
+
+abbrev Component := L.graph.ConnectedComponent
+
+def translationWords {n : ℕ} (D : BlockConstraints.Translation n) : Finset (Fin n → Letter) :=
+  Finset.univ.filter (fun W => ∀ i : D.domain, W (D.target i) = W i.val)
+
+theorem translation_card {n : ℕ} (D : BlockConstraints.Translation n) :
+    (translationWords D).card ≤ (Fintype.card Letter)^(n-D.domain.card) := by
+  have he : {W : Fin n → Letter // W ∈ translationWords D} ≃
+      {W : Fin n → Letter // ∀ i : D.domain, W (D.target i) = W i.val} :=
+    Equiv.subtypeEquivRight (fun W => by simp [translationWords])
+  have hh := D.word_count (T := Letter)
+  rw [← Nat.card_congr he,Nat.card_eq_fintype_card,Fintype.card_coe] at hh
+  exact hh
+
+variable (r : (c : Component L) → c)
+variable (D : (c : Component L) → Option (BlockConstraints.Translation (h (r c).val)))
+variable (d : I → ℤ)
+
+def rootWords (c : Component L) : Finset (Fin (h (r c).val) → Letter) :=
+  match D c with
+  | none => binWords _ (d (r c).val)
+  | some tr => translationWords tr
+
+def basicCost (s : ℝ) (c : Component L) : ℝ :=
+  match D c with
+  | none => 2*(d (r c).val : ℝ) - (1/600 : ℝ)*s
+  | some _ => 0
+
+def Feasible (W : (i : I) → Fin (h i) → Letter) : Prop :=
+  L.Consistent W ∧ (∀ i, W i ∈ binWords (h i) (d i)) ∧
+    ∀ c tr, D c = some tr → ∀ k : tr.domain, W (r c).val (tr.target k) = W (r c).val k.val
+
+omit [Fintype I] in
+theorem feasible_root {W : (i : I) → Fin (h i) → Letter}
+    (hw : Feasible L r D d W) (c : Component L) : W (r c).val ∈ rootWords L r D d c := by
+  unfold rootWords
+  cases hc : D c with
+  | none => exact hw.2.1 _
+  | some tr => exact Finset.mem_filter.mpr ⟨Finset.mem_univ _,hw.2.2 c tr hc⟩
+
+omit [Fintype I] in
+theorem root_bound (s : ℝ) (e : ℕ)
+    (hlarge : ∀ i, 3002 ≤ h i) (hscale : ∀ i, s+1200 ≤ 2*(h i : ℝ))
+    (hself : ∀ c tr, D c = some tr → h (r c).val-tr.domain.card ≤ e)
+    (c : Component L) :
+    ((rootWords L r D d c).card : ℝ) ≤
+      Real.exp (basicCost L r D d s c + (e : ℝ)*Real.log (Fintype.card Letter)) := by
+  have halog : 0 ≤ Real.log (Fintype.card Letter) :=
+    Real.log_nonneg (by exact_mod_cast Fintype.card_pos (α := Letter))
+  have ha : 0 < (Fintype.card Letter : ℝ) := by exact_mod_cast Fintype.card_pos
+  unfold rootWords basicCost
+  cases hc : D c with
+  | none =>
+    have hh := bin_card_bound (h (r c).val) (hlarge _) (d (r c).val)
+    apply hh.trans
+    apply Real.exp_le_exp.mpr
+    have hs := hscale (r c).val
+    have he := mul_nonneg (Nat.cast_nonneg e : (0:ℝ) ≤ e) halog
+    linarith
+  | some tr =>
+    have hh : ((translationWords tr).card : ℝ) ≤
+        (Fintype.card Letter : ℝ)^(h (r c).val-tr.domain.card) := by
+      exact_mod_cast translation_card tr
+    calc
+      _ ≤ (Fintype.card Letter : ℝ)^(h (r c).val-tr.domain.card) := hh
+      _ ≤ (Fintype.card Letter : ℝ)^e := pow_le_pow_right₀ (by exact_mod_cast Fintype.card_pos (α := Letter))
+        (hself c tr hc)
+      _ = Real.exp (0 + (e : ℝ)*Real.log (Fintype.card Letter)) := by
+        rw [zero_add,Real.exp_nat_mul,Real.exp_log ha]
+
+/-- Count the actual active projections with bin or self-translation roots.
+The error exponent is explicit: twice the missing substring size per block. -/
+theorem stage_count (A : Finset I) (s : ℝ) (e : ℕ)
+    (hlarge : ∀ i, 3002 ≤ h i) (hscale : ∀ i, s+1200 ≤ 2*(h i : ℝ))
+    (hlinks : ∀ i j, L.graph.Adj i j → h i - (L.known i j).card ≤ e)
+    (hself : ∀ c tr, D c = some tr → h (r c).val-tr.domain.card ≤ e) :
+    ((StageLabels.stageWords h A (Feasible L r D d)).card : ℝ) ≤
+      Real.exp ((∑ c : StageLabels.activeComponents L.graph.connectedComponentMk A,
+        basicCost L r D d s c.val) + 2*(e : ℝ)*Fintype.card I*Real.log (Fintype.card Letter)) := by
+  have hh := L.stage_exp A r (rootWords L r D d) (Feasible L r D d)
+    (fun _ hw => hw.1) (fun _ hw c => feasible_root L r D d hw c) e hlinks
+    (fun c => basicCost L r D d s c + (e : ℝ)*Real.log (Fintype.card Letter))
+    (root_bound L r D d s e hlarge hscale hself)
+  apply hh.trans
+  apply Real.exp_le_exp.mpr
+  rw [Finset.sum_add_distrib,Finset.sum_const,Finset.card_univ,nsmul_eq_mul]
+  have hcomp : Fintype.card (StageLabels.activeComponents L.graph.connectedComponentMk A) ≤ Fintype.card I := by
+    rw [Fintype.card_coe]
+    exact (Finset.card_image_le).trans (Finset.card_le_univ _)
+  have hall : (Fintype.card (StageLabels.activeComponents L.graph.connectedComponentMk A) : ℝ) ≤ Fintype.card I :=
+    by exact_mod_cast hcomp
+  have ha : 0 ≤ Real.log (Fintype.card Letter) :=
+    Real.log_nonneg (by exact_mod_cast Fintype.card_pos (α := Letter))
+  have he := mul_le_mul_of_nonneg_right hall (mul_nonneg (Nat.cast_nonneg e : (0:ℝ) ≤ e) ha)
+  nlinarith
+
+end TorsionFreeZeroDivisors.StageBlocks
+
+namespace TorsionFreeZeroDivisors.ActualStageLabels
+
+open scoped Classical BigOperators
+section
+/-- An infeasible complete word has no active projection. -/
+theorem projection_empty {I T : Type*} [Fintype I] [Fintype T]
+    (h : I → ℕ) (A : Finset I) (P : ((i : I) → Fin (h i) → T) → Prop)
+    (hn : ¬∃ W, P W) : StageLabels.stageWords h A P = ∅ := by
+  unfold StageLabels.stageWords
+  have he : Finset.univ.filter P = ∅ := by
+    exact Finset.filter_eq_empty_iff.mpr (fun W _ hW => hn ⟨W,hW⟩)
+  rw [he,Finset.image_empty]
+
+/-- Uniform root errors and propagation errors together cost at most twice
+one missing substring per underlying block. -/
+theorem projection_bound {I T : Type*} [Fintype I] [Fintype T] [Nonempty T]
+    {h : I → ℕ} (L : StageLabels.Links (T := T) h) (A : Finset I)
+    (r : (c : L.graph.ConnectedComponent) → c)
+    (R : (c : L.graph.ConnectedComponent) → Finset (Fin (h (r c).val) → T))
+    (P : ((i : I) → Fin (h i) → T) → Prop)
+    (hP : ∀ w, P w → L.Consistent w)
+    (hroot : ∀ w, P w → ∀ c, w (r c).val ∈ R c)
+    (e : ℕ) (he : ∀ i j, L.graph.Adj i j → h i - (L.known i j).card ≤ e)
+    (cost : L.graph.ConnectedComponent → ℝ)
+    (hcost : ∀ c, ((R c).card : ℝ) ≤ Real.exp (cost c+(e : ℝ)*Real.log (Fintype.card T))) :
+    ((StageLabels.stageWords h A P).card : ℝ) ≤
+      Real.exp ((∑ c : StageLabels.activeComponents L.graph.connectedComponentMk A, cost c.val) +
+        2*(e : ℝ)*Fintype.card I*Real.log (Fintype.card T)) := by
+  have hh := L.stage_exp A r R P hP hroot e he
+    (fun c => cost c+(e : ℝ)*Real.log (Fintype.card T)) hcost
+  apply hh.trans
+  apply Real.exp_le_exp.mpr
+  rw [Finset.sum_add_distrib,Finset.sum_const,Finset.card_univ,nsmul_eq_mul]
+  have hcomp : Fintype.card (StageLabels.activeComponents L.graph.connectedComponentMk A) ≤ Fintype.card I := by
+    rw [Fintype.card_coe]
+    exact (Finset.card_image_le).trans (Finset.card_le_univ _)
+  have hall : (Fintype.card (StageLabels.activeComponents L.graph.connectedComponentMk A) : ℝ) ≤ Fintype.card I :=
+    by exact_mod_cast hcomp
+  have ha : 0 ≤ Real.log (Fintype.card T) :=
+    Real.log_nonneg (by exact_mod_cast Fintype.card_pos (α := T))
+  have hel := mul_le_mul_of_nonneg_right hall (mul_nonneg (Nat.cast_nonneg e : (0:ℝ) ≤ e) ha)
+  nlinarith
+end
+open scoped Classical BigOperators
+open ComparedBlocks RepeatedBlocks WordEstimate
+variable {C E : Type*} [Fintype C] (s : ℝ) (hs : 0 < s) (len m : C → ℕ)
+variable (cmp : Comparisons (E := E) (traversalLength len m)) (err : ℕ)
+
+def symbol (e : E) : Letter ≃ Letter :=
+  if cmp.reverse e then ⟨inverse,inverse,inverse_inverse,inverse_inverse⟩ else Equiv.refl _
+
+abbrev L := links s hs len m cmp err (symbol len m cmp)
+abbrev P := (data s hs len m cmp err).matching
+abbrev Component := LinkComponents.Component (multiplicity s len m) (P s hs len m cmp err)
+
+def Comparing (w : C → ℤ → Letter) : Prop :=
+  ∀ x e, cmp.side x = some e →
+    w x.1.1 x.2.val = if cmp.reverse e then
+      inverse (w (cmp.pairing.partner x).1.1 (cmp.pairing.partner x).2.val)
+    else w (cmp.pairing.partner x).1.1 (cmp.pairing.partner x).2.val
+
+def Immersed (w : C → ℤ → Letter) : Prop :=
+  ∀ (i : Underlying s len) q,
+    lower s len i ≤ q → q+1 < upper s len i → w i.1 (q+1) ≠ inverse (w i.1 q)
+
+variable (d : Underlying s len → ℤ)
+
+def Feasible (W : (i : Underlying s len) → Fin (height s len i) → Letter) : Prop :=
+  (∀ i, W i ∈ binWords (height s len i) (d i)) ∧
+    ∃ w : C → ℤ → Letter, Comparing len m cmp w ∧ Immersed s len w ∧ W = word s len w
+
+omit [Fintype C] in
+theorem feasible_consistent {W : (i : Underlying s len) → Fin (height s len i) → Letter}
+    (hW : Feasible s len m cmp d W) : (L s hs len m cmp err).Consistent W := by
+  obtain ⟨_,w,hw,_,rfl⟩ := hW
+  apply links_consistent s hs len m cmp err (symbol len m cmp) (fun x => w x.1.1 x.2.val)
+  · intro x e he
+    have hh := hw x e he
+    unfold symbol
+    split_ifs with h
+    · simpa [h] using hh
+    · simpa [h] using hh
+  · intro b x
+    unfold word
+    rw [coordinate_val,sub_add_cancel]
+    have ht := ((mem_blockPositions s hs (traversalLength len m)).mp x.property).1
+    exact congrArg (fun t : Traversal m => w t.1 x.val.2.val) ht.symm
+
+/-- The source component cost with the actual occurrence matching and its
+actual self-links, not a supplied abstract component partition. -/
+def cost (c : Component s hs len m cmp err) : ℝ :=
+  LinkComponents.componentLabelCost (multiplicity s len m) (P s hs len m cmp err)
+    (fun i => (d i : ℝ)) (1/600) s c
+
+theorem root_count
+    (hlarge : ∀ i, 3002 ≤ height s len i)
+    (hscale : ∀ i, s+1200 ≤ 2*(height s len i : ℝ))
+    (hreduced : ∀ x e, cmp.side x = some e →
+      (x.1.1,x.2.val) ≠ ((cmp.pairing.partner x).1.1,(cmp.pairing.partner x).2.val))
+    (w₀ : C → ℤ → Letter) (hcompare₀ : Comparing len m cmp w₀) (hred₀ : Immersed s len w₀)
+    (c : Component s hs len m cmp err) :
+    ∃ (r : c) (R : Finset (Fin (height s len r.val) → Letter)),
+      (R.card : ℝ) ≤ Real.exp (cost s hs len m cmp err d c + (err : ℝ)*Real.log (Fintype.card Letter)) ∧
+      ∀ W, Feasible s len m cmp d W → W r.val ∈ R := by
+  have halog : 0 ≤ Real.log (Fintype.card Letter) :=
+    Real.log_nonneg (by exact_mod_cast Fintype.card_pos (α := Letter))
+  by_cases hc : LinkComponents.HasSelf (multiplicity s len m) (P s hs len m cmp err) c
+  · obtain ⟨r,tr,hdef,htr⟩ := self_component_translation s hs len m cmp err inverse
+      inverse_inverse inverse_ne w₀ hcompare₀ hred₀ hreduced c hc
+    refine ⟨r,StageBlocks.translationWords tr,?_,?_⟩
+    · have hb : ((StageBlocks.translationWords tr).card : ℝ) ≤
+          (Fintype.card Letter : ℝ)^(height s len r.val-tr.domain.card) := by
+        exact_mod_cast StageBlocks.translation_card tr
+      have ha : 0 < (Fintype.card Letter : ℝ) := by exact_mod_cast Fintype.card_pos
+      calc
+        _ ≤ (Fintype.card Letter : ℝ)^(height s len r.val-tr.domain.card) := hb
+        _ ≤ (Fintype.card Letter : ℝ)^err :=
+          pow_le_pow_right₀ (by exact_mod_cast Fintype.card_pos (α := Letter)) hdef
+        _ = _ := by
+          simp only [cost,LinkComponents.componentLabelCost,ite_eq_left hc,zero_add]
+          rw [Real.exp_nat_mul,Real.exp_log ha]
+    · intro W hW
+      obtain ⟨_,w,hw,_,rfl⟩ := hW
+      exact Finset.mem_filter.mpr ⟨Finset.mem_univ _,htr Letter inverse w hw⟩
+  · let r := LinkComponents.minimumRoot (multiplicity s len m) (P s hs len m cmp err)
+      (fun i => (d i : ℝ)) c
+    refine ⟨r,binWords (height s len r.val) (d r.val),?_,?_⟩
+    · have hb := bin_card_bound (height s len r.val) (hlarge r.val) (d r.val)
+      apply hb.trans
+      apply Real.exp_le_exp.mpr
+      have hh := hscale r.val
+      have he := mul_nonneg (Nat.cast_nonneg err : (0:ℝ) ≤ err) halog
+      simp only [cost,LinkComponents.componentLabelCost,ite_eq_right hc]
+      change 2*(d r.val : ℝ)+2-2*(1/600 : ℝ)*(height s len r.val : ℝ) ≤ _
+      linarith
+    · intro W hW
+      exact hW.1 r.val
+
+/-- Counting the actual stage projection. Self-link roots are selected from
+one feasible realization; if none exists, the projection is empty. -/
+theorem stage_count (A : Finset (Underlying s len))
+    (hlarge : ∀ i, 3002 ≤ height s len i)
+    (hscale : ∀ i, s+1200 ≤ 2*(height s len i : ℝ))
+    (hreduced : ∀ x e, cmp.side x = some e →
+      (x.1.1,x.2.val) ≠ ((cmp.pairing.partner x).1.1,(cmp.pairing.partner x).2.val)) :
+    ((StageLabels.stageWords (height s len) A (Feasible s len m cmp d)).card : ℝ) ≤
+      Real.exp ((∑ c : StageLabels.activeComponents (L s hs len m cmp err).graph.connectedComponentMk A,
+        cost s hs len m cmp err d c.val) +
+        2*(err : ℝ)*Fintype.card (Underlying s len)*Real.log (Fintype.card Letter)) := by
+  by_cases hex : ∃ W, Feasible s len m cmp d W
+  · obtain ⟨W,_,w₀,hw₀,hr₀,_⟩ := hex
+    have hroot := root_count s hs len m cmp err d hlarge hscale hreduced w₀ hw₀ hr₀
+    choose r R hR hmem using hroot
+    exact projection_bound (L s hs len m cmp err) A r R (Feasible s len m cmp d)
+      (fun _ hw => feasible_consistent s hs len m cmp err d hw)
+      (fun W hw c => hmem c W hw) err
+      (links_deficit s hs len m cmp err (symbol len m cmp))
+      (cost s hs len m cmp err d) hR
+  · rw [projection_empty _ _ _ hex,Finset.card_empty,Nat.cast_zero]
+    exact (Real.exp_pos _).le
+
+/-- Stage components are precisely those whose maximum multiplicity exceeds
+the zero-based stage number. -/
+theorem active_iff (j : ℕ) (c : Component s hs len m cmp err) :
+    c ∈ StageLabels.activeComponents (L s hs len m cmp err).graph.connectedComponentMk
+      (Finset.univ.filter (fun i => j < multiplicity s len m i)) ↔
+      j < LinkComponents.maximum (multiplicity s len m) (P s hs len m cmp err) c := by
+  rw [← LinkComponents.active_iff]
+  constructor
+  · intro hc
+    obtain ⟨i,hi,hc⟩ := Finset.mem_image.mp hc
+    exact ⟨⟨i,hc⟩,(Finset.mem_filter.mp hi).2⟩
+  · rintro ⟨i,hi⟩
+    exact Finset.mem_image.mpr ⟨i.val,Finset.mem_filter.mpr ⟨Finset.mem_univ _,hi⟩,i.property⟩
+
+/-- Literal source component sum, now in the form used by stage-cost summation. -/
+theorem cost_sum (j : ℕ) :
+    (∑ c : StageLabels.activeComponents (L s hs len m cmp err).graph.connectedComponentMk
+      (Finset.univ.filter (fun i => j < multiplicity s len m i)), cost s hs len m cmp err d c.val) =
+    ∑ c : Component s hs len m cmp err,
+      if j < LinkComponents.maximum (multiplicity s len m) (P s hs len m cmp err) c then
+        cost s hs len m cmp err d c else 0 := by
+  change (∑ c : StageLabels.activeComponents
+    (LinkComponents.graph (multiplicity s len m) (P s hs len m cmp err)).connectedComponentMk
+    (Finset.univ.filter (fun i => j < multiplicity s len m i)), cost s hs len m cmp err d c.val) = _
+  rw [Finset.sum_coe_sort]
+  have hset : StageLabels.activeComponents
+      (LinkComponents.graph (multiplicity s len m) (P s hs len m cmp err)).connectedComponentMk
+      (Finset.univ.filter (fun i => j < multiplicity s len m i)) =
+      Finset.univ.filter (fun c : Component s hs len m cmp err =>
+        j < LinkComponents.maximum (multiplicity s len m) (P s hs len m cmp err) c) := by
+    ext c
+    exact (active_iff s hs len m cmp err j c).trans (by simp)
+  rw [hset,Finset.sum_filter]
+
+end TorsionFreeZeroDivisors.ActualStageLabels
+
+namespace TorsionFreeZeroDivisors.ChainStageLabels
+open scoped Classical BigOperators
+section
+/-- Direct membership in a finite active projection, with the generic index
+instances retained rather than recomputed after specializing the sigma type. -/
+theorem stageWords_mem {I T : Type*} [Fintype I] [Fintype T] (h : I → ℕ)
+    (A : Finset I) (P : ((i : I) → Fin (h i) → T) → Prop)
+    (W : (i : I) → Fin (h i) → T) (hW : P W) :
+    (fun i : A => W i.val) ∈ StageLabels.stageWords h A P := by
+  apply Finset.mem_image.mpr
+  refine ⟨W,?_,rfl⟩
+  simp only [Finset.mem_filter,Finset.mem_univ,true_and]
+  exact hW
+end
+open scoped Classical BigOperators
+open BlockAlignment ComparedBlocks RepeatedBlocks WordEstimate
+variable {C E : Type*} [Fintype C] (s : ℝ) (hs : 0 < s) (len m : C → ℕ) (j : ℕ)
+
+abbrev ActiveChain := {c : C // j < m c}
+abbrev StagePosition := (c : ActiveChain m j) × positions 0 (len c.val)
+abbrev StageTail := (c : ActiveChain m j) × tail s (len c.val)
+def activeBlocks : Finset (Underlying s len) := Finset.univ.filter (fun i => j < m i.1)
+
+omit [Fintype C] in
+include hs in
+theorem tail_subset (ell : ℕ) : tail s ell ⊆ positions 0 ell := by
+  intro q hq
+  obtain ⟨hlo,hhi⟩ := mem_positions.mp hq
+  apply mem_positions.mpr
+  exact ⟨le_trans (by positivity : (0:ℝ) ≤ (blockCount s ell : ℝ)*s) hlo,hhi⟩
+
+def blockPoint (i : activeBlocks s len m j) (k : Fin (height s len i.val)) :
+    StagePosition len m j :=
+  ⟨⟨i.val.1,(Finset.mem_filter.mp i.property).2⟩,
+    ⟨((wordCoordinate s len i.val).symm k).val,
+      full_subset s hs (len i.val.1) i.val.2 ((wordCoordinate s len i.val).symm k).property⟩⟩
+
+def tailPoint (x : StageTail s len m j) : StagePosition len m j :=
+  ⟨x.1,⟨x.2.val,tail_subset s hs (len x.1.val) x.2.property⟩⟩
+
+def blockRestrict (F : StagePosition len m j → Letter) :
+    (i : activeBlocks s len m j) → Fin (height s len i.val) → Letter :=
+  fun i k => F (blockPoint s hs len m j i k)
+def tailRestrict (F : StagePosition len m j → Letter) : StageTail s len m j → Letter :=
+  fun x => F (tailPoint s hs len m j x)
+
+def encode (F : StagePosition len m j → Letter) :=
+  (blockRestrict s hs len m j F,tailRestrict s hs len m j F)
+
+/-- Full blocks and the literal end fragments determine every active chain
+letter, without choosing values on inactive chains. -/
+theorem encode_injective : Function.Injective (encode s hs len m j) := by
+  intro F G he
+  have hb := congrArg Prod.fst he
+  have ht := congrArg Prod.snd he
+  funext x
+  rcases x with ⟨⟨c,hc⟩,q⟩
+  obtain ⟨k,hk⟩ | htq := full_or_tail s hs (len c) q.property
+  · let i : activeBlocks s len m j := ⟨⟨c,k⟩,by simp [activeBlocks,hc]⟩
+    let z : Fin (height s len i.val) := wordCoordinate s len i.val ⟨q.val,hk⟩
+    have h := congr_fun (congr_fun hb i) z
+    simpa [encode,blockRestrict,blockPoint,z,i] using h
+  · have h := congr_fun ht ⟨⟨c,hc⟩,⟨q.val,htq⟩⟩
+    exact h
+
+/-- The exact finite extension factor contributed by arbitrary tail letters. -/
+theorem extension_count (X : Finset (StagePosition len m j → Letter))
+    (Y : Finset ((i : activeBlocks s len m j) → Fin (height s len i.val) → Letter))
+    (hX : ∀ F ∈ X, blockRestrict s hs len m j F ∈ Y) :
+    X.card ≤ Y.card * (Fintype.card Letter)^Fintype.card (StageTail s len m j) := by
+  calc
+    X.card = (X.image (encode s hs len m j)).card :=
+      (Finset.card_image_of_injective X (encode_injective s hs len m j)).symm
+    _ ≤ (Y ×ˢ Finset.univ).card := by
+      apply Finset.card_le_card
+      intro x hx
+      obtain ⟨F,hF,rfl⟩ := Finset.mem_image.mp hx
+      exact Finset.mem_product.mpr ⟨hX F hF,Finset.mem_univ _⟩
+    _ = _ := by simp
+
+include hs in
+/-- The fragment loss is O(s) per marked chain, with a literal uniform bound. -/
+theorem tail_count : (Fintype.card (StageTail s len m j) : ℝ) ≤
+    (s+1)*Fintype.card C := by
+  simp only [StageTail,Fintype.card_sigma,Fintype.card_coe,Nat.cast_sum]
+  calc
+    (∑ c : ActiveChain m j, ((tail s (len c.val)).card : ℝ)) ≤
+        ∑ _c : ActiveChain m j, (s+1) :=
+      Finset.sum_le_sum (fun c _ => tail_bound s hs (len c.val))
+    _ = (s+1)*Fintype.card (ActiveChain m j) := by simp only [Finset.sum_const, Finset.card_univ, nsmul_eq_mul]; ring
+    _ ≤ _ := mul_le_mul_of_nonneg_left (by exact_mod_cast Fintype.card_subtype_le (fun c : C => j < m c))
+      (by positivity)
+
+variable (cmp : Comparisons (E := E) (traversalLength len m)) (d : Underlying s len → ℤ)
+
+def fullWords : Finset (StagePosition len m j → Letter) :=
+  Finset.univ.filter (fun F => ∃ w : C → ℤ → Letter,
+    ActualStageLabels.Comparing len m cmp w ∧ ActualStageLabels.Immersed s len w ∧
+    (∀ i, word s len w i ∈ binWords (height s len i) (d i)) ∧
+    F = fun x => w x.1.val x.2.val)
+
+theorem blockRestrict_word (w : C → ℤ → Letter) :
+    blockRestrict s hs len m j (fun x => w x.1.val x.2.val) =
+      fun i k => word s len w i.val k := by
+  funext i k
+  have hv := wordCoordinate_val s len i.val ((wordCoordinate s len i.val).symm k)
+  rw [Equiv.apply_symm_apply] at hv
+  change w i.val.1 ((wordCoordinate s len i.val).symm k).val =
+    w i.val.1 ((k.val : ℤ)+lower s len i.val)
+  congr 1
+  omega
+
+/-- Every literal feasible full-chain assignment projects to feasible blocks. -/
+theorem restrict_mem (F : StagePosition len m j → Letter)
+    (hF : F ∈ fullWords s len m j cmp d) :
+    blockRestrict s hs len m j F ∈ StageLabels.stageWords (height s len)
+      (activeBlocks s len m j) (ActualStageLabels.Feasible s len m cmp d) := by
+  have hF' : ∃ w : C → ℤ → Letter,
+      ActualStageLabels.Comparing len m cmp w ∧ ActualStageLabels.Immersed s len w ∧
+      (∀ i, word s len w i ∈ binWords (height s len i) (d i)) ∧
+      F = fun x => w x.1.val x.2.val := (Finset.mem_filter.mp hF).2
+  obtain ⟨w,hw,hr,hd,rfl⟩ := hF'
+  rw [blockRestrict_word]
+  have hW : ActualStageLabels.Feasible s len m cmp d (word s len w) := ⟨hd,w,hw,hr,rfl⟩
+  exact stageWords_mem (height s len) (activeBlocks s len m j)
+    (ActualStageLabels.Feasible s len m cmp d) (word s len w) hW
+
+/-- Numerical extension bound factored independently of the graph types. -/
+theorem count_extension_exp (x y k z : ℕ) (cost error bound : ℝ)
+    (hxy : x ≤ y*k^z) (hy : (y : ℝ) ≤ Real.exp (cost+error*Real.log k))
+    (hz : (z : ℝ) ≤ bound) (hk : 0 < k) :
+    (x : ℝ) ≤ Real.exp (cost+(error+bound)*Real.log k) := by
+  have hlog : 0 ≤ Real.log (k : ℝ) := Real.log_nonneg (by exact_mod_cast hk)
+  have hpow : (k : ℝ)^z = Real.exp ((z : ℝ)*Real.log k) := by
+    rw [Real.exp_nat_mul,Real.exp_log (by exact_mod_cast hk)]
+  have hxy' : (x : ℝ) ≤ (y : ℝ)*(k : ℝ)^z := by exact_mod_cast hxy
+  calc
+    (x : ℝ) ≤ (y : ℝ)*(k : ℝ)^z := hxy'
+    _ ≤ Real.exp (cost+error*Real.log k) * (k : ℝ)^z :=
+      mul_le_mul_of_nonneg_right hy (by positivity)
+    _ = Real.exp (cost+error*Real.log k+(z : ℝ)*Real.log k) := by simp only [hpow,Real.exp_add]
+    _ ≤ _ := Real.exp_le_exp.mpr (by nlinarith [mul_le_mul_of_nonneg_right hz hlog])
+
+/-- Source stage-label estimate including every tail, not just full blocks. -/
+theorem full_stage_count (err : ℕ)
+    (hlarge : ∀ i, 3002 ≤ height s len i)
+    (hscale : ∀ i, s+1200 ≤ 2*(height s len i : ℝ))
+    (hreduced : ∀ x e, cmp.side x = some e →
+      (x.1.1,x.2.val) ≠ ((cmp.pairing.partner x).1.1,(cmp.pairing.partner x).2.val)) :
+    ((fullWords s len m j cmp d).card : ℝ) ≤
+      Real.exp ((∑ c : StageLabels.activeComponents
+        (ActualStageLabels.L s hs len m cmp err).graph.connectedComponentMk (activeBlocks s len m j),
+        ActualStageLabels.cost s hs len m cmp err d c.val) +
+        (2*(err : ℝ)*Fintype.card (Underlying s len)+(s+1)*Fintype.card C)*
+          Real.log (Fintype.card Letter)) := by
+  have he := extension_count s hs len m j (fullWords s len m j cmp d)
+    (StageLabels.stageWords (height s len) (activeBlocks s len m j)
+      (ActualStageLabels.Feasible s len m cmp d)) (restrict_mem s hs len m j cmp d)
+  have hcard := ActualStageLabels.stage_count s hs len m cmp err d
+    (activeBlocks s len m j) hlarge hscale hreduced
+  exact count_extension_exp _ _ _ _ _ _ _ he hcard (tail_count s hs len m j)
+    (Fintype.card_pos (α := Letter))
+
+end TorsionFreeZeroDivisors.ChainStageLabels
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/GroupRing/StageEntropy.lean b/lean/OAI/Algebra/GroupRing/StageEntropy.lean
new file mode 100644
index 0000000000000000000000000000000000000000..d42e166a491d280db68538984fa3a23df34b531a
--- /dev/null
+++ b/lean/OAI/Algebra/GroupRing/StageEntropy.lean
@@ -0,0 +1,533 @@
+import Mathlib
+import OAI.Algebra.GroupRing.TypedGraphs
+
+namespace OAI
+
+noncomputable section
+
+namespace TorsionFreeZeroDivisors.StageEntropy
+
+section
+open scoped Classical BigOperators
+open BlockAlignment ComparedBlocks RepeatedBlocks ChainStageLabels WordEstimate
+variable {C E : Type*} [Fintype C] (s : ℝ) (hs : 0<s) (len m : C → ℕ)
+    (cmp : Comparisons (E := E) (traversalLength len m)) (err : ℕ)
+    (d : Underlying s len → ℤ)
+
+/-- The literal label/bin exponent, in the stage bound. -/
+def labelCost (j : ℕ) : ℝ :=
+  (∑ c : StageLabels.activeComponents
+    (ActualStageLabels.L s hs len m cmp err).graph.connectedComponentMk (activeBlocks s len m j),
+      ActualStageLabels.cost s hs len m cmp err d c.val) -
+    ∑ i ∈ activeBlocks s len m j, (d i : ℝ)
+
+theorem labelCost_eq (M : ℕ) (j : Fin M) :
+    labelCost s hs len m cmp err d j =
+      LinkComponents.stageCost (multiplicity s len m) (ActualStageLabels.P s hs len m cmp err)
+        M (fun i => (d i : ℝ)) (1/600) s j := by
+  unfold labelCost
+  change (∑ c : StageLabels.activeComponents
+    (ActualStageLabels.L s hs len m cmp err).graph.connectedComponentMk
+    (Finset.univ.filter (fun i => j.val < multiplicity s len m i)),
+      ActualStageLabels.cost s hs len m cmp err d c.val) - _ = _
+  rw [ActualStageLabels.cost_sum]
+  simp only [activeBlocks,Finset.sum_filter,LinkComponents.stageCost,
+    ActualStageLabels.cost,RepeatedBlocks.multiplicity]
+  rw [sub_eq_add_neg]
+  rw [add_comm]
+  congr! 3
+
+/-- The source uniform block-propagation and chain-tail error, before taking
+limits. All blocks and both sides are counted only once. -/
+def looseCost : ℝ :=
+  (2*(err : ℝ)*Fintype.card (Underlying s len)+(s+1)*Fintype.card C)*
+    Real.log (Fintype.card Letter)
+
+/-- Literal component costs dispatched through proven unmatched-incidence
+and layer-cake estimates. The power hypothesis is the (separate) actual
+immersed-path vertex/edge inequality, not a first-moment assumption. -/
+theorem sum_exponents (M : ℕ) (hm : ∀ c, m c ≤ M) (a logn : ℝ)
+    (power error : Fin M → ℝ) (ha : 0≤a) (hn : 0≤logn)
+    (hlow : ∀ i, (1/600:ℝ)*s/2 ≤ d i) (hhigh : ∀ i, (d i : ℝ) ≤ a*s)
+    (hpower : ∑ j, power j ≤ 0) :
+    (Finset.univ.sum (fun j : Fin M => power j*logn + labelCost s hs len m cmp err d j.val + error j)) ≤
+      a*s*Fintype.card (ActualStageLabels.P s hs len m cmp err).Unmatched -
+        (1/1200:ℝ)*s*(∑ i : Underlying s len, (multiplicity s len m i : ℝ)) +
+          ∑ j : Fin M, error j := by
+  simp_rw [labelCost_eq]
+  convert LinkComponents.sum_stageBound (multiplicity s len m)
+    (ActualStageLabels.P s hs len m cmp err) M (fun i => hm i.1)
+    (fun i => (d i : ℝ)) (1/600) s a logn power error
+    (by norm_num) hs.le ha hn hlow hhigh hpower using 1
+  norm_num
+  left
+  congr! 3
+
+end
+
+open scoped Classical BigOperators
+open BlockAlignment ComparedBlocks RepeatedBlocks ChainStageLabels WordEstimate TwoSideFullStage
+local instance : DecidableEq Types.Letter := Classical.decEq _
+variable {A B E VA VB TA TB : Type} [Fintype A] [Fintype B] [Fintype VA] [Fintype VB]
+  [Fintype TA] [Fintype TB]
+variable (s : ℝ) (hs : 0<s) (len m : A ⊕ B → ℕ) (j : ℕ)
+variable (firstA lastA : CA m j → VA) (firstB lastB : CB m j → VB)
+  (outA : TA → Finset Types.Letter) (outB : TB → Finset Types.Letter)
+  (pinA : VA → Option TA) (pinB : VB → Option TB)
+local notation "SA" => sideA len m j firstA lastA outA pinA
+local notation "SB" => sideB len m j firstB lastB outB pinB
+
+/-- A complete literal-stage first moment, with its signed vertex exponent
+and the source denominator, without stage independence. -/
+theorem mean_bound (cmp : Comparisons (E := E) (traversalLength len m))
+    (d : Underlying s len → ℤ) (err K Q rep : ℕ)
+    (hlarge : ∀ i, 3002 ≤ height s len i)
+    (hscale : ∀ i, s+1200 ≤ 2*(height s len i : ℝ))
+    (hreduced : ∀ x e, cmp.side x = some e →
+      (x.1.1,x.2.val) ≠ ((cmp.pairing.partner x).1.1,(cmp.pairing.partner x).2.val))
+    (hn : 0<TypedGraphs.size rep) (hr : 0<StageDenominator.denominator K rep)
+    (hA : TwoSideStage.Conditions SA (TypedGraphs.size rep) (129/16513)
+      (3*GirthAsymptotics.L (TypedGraphs.size rep)) 132 (StageDenominator.denominator K rep))
+    (hB : TwoSideStage.Conditions SB (TypedGraphs.size rep) (129/16513)
+      (3*GirthAsymptotics.L (TypedGraphs.size rep)) 132 (StageDenominator.denominator K rep))
+    (hlen : ∀ c,0<len c) (hQ : Fintype.card (CA m j)+Fintype.card (CB m j)≤Q)
+    (hE : (SA).edges+(SB).edges ≤ K*GirthAsymptotics.L (TypedGraphs.size rep)) :
+    TwoSideMean.mean (((SA).samples (3*GirthAsymptotics.L (TypedGraphs.size rep))) ×ˢ
+      ((SB).samples (3*GirthAsymptotics.L (TypedGraphs.size rep))))
+      (TwoSideStage.count SA SB (fullWords s len m j cmp d)
+        (restrictA len m j) (restrictB len m j)) ≤
+      Real.exp (((((SA).freeMarks+(SB).freeMarks:ℕ):ℝ)-
+        (Fintype.card (CA m j)+Fintype.card (CB m j):ℕ))*Real.log (TypedGraphs.size rep) +
+          labelCost s hs len m cmp err d j + looseCost s len err + StageDenominator.error K Q rep) := by
+  have hm := TwoSideFullStage.mean_bound s hs len m j firstA lastA firstB lastB
+    outA outB pinA pinB cmp d err hlarge hscale hreduced
+    (TypedGraphs.size rep) (129/16513) _ 132 _ hA hB
+  have hc := StageDenominator.joint_cost_bound SA SB K Q rep hn hr
+    (fun c => hlen (.inl c.val)) (fun c => hlen (.inr c.val)) hQ hE
+  apply hm.trans
+  apply (mul_le_mul_of_nonneg_right hc (Real.exp_pos _).le).trans_eq
+  rw [← Real.exp_add]
+  congr 1
+  unfold labelCost looseCost
+  change (((((SA).freeMarks+(SB).freeMarks:ℕ):ℝ)-
+    (Fintype.card (CA m j)+Fintype.card (CB m j):ℕ))*Real.log (TypedGraphs.size rep)+
+      StageDenominator.error K Q rep) + _ = _
+  ring
+
+end TorsionFreeZeroDivisors.StageEntropy
+
+namespace TorsionFreeZeroDivisors.OccurrenceMatching.Data
+open scoped Classical
+variable {Ω B B' E : Type*} (D : OccurrenceMatching.Data (Ω := Ω) (B := B) (E := E))
+
+def transportUnmatched (r : B' ≃ B) : (D.transport r).matching.Unmatched ≃ D.matching.Unmatched where
+  toFun o := ⟨r o.val,by
+    rw [← D.transport_partner r o.val,o.property]⟩
+  invFun o := ⟨r.symm o.val,by
+    apply r.injective
+    rw [D.transport_partner,r.apply_symm_apply,o.property]⟩
+  left_inv o := Subtype.ext (r.symm_apply_apply o.val)
+  right_inv o := Subtype.ext (r.apply_symm_apply o.val)
+
+variable [Fintype B]
+theorem card_unmatched : Fintype.card D.matching.Unmatched = D.unmatchedBlocks.card := by
+  change Fintype.card {o : B // D.matching.partner o = o} = _
+  rw [Fintype.card_subtype]
+  rfl
+end TorsionFreeZeroDivisors.OccurrenceMatching.Data
+
+namespace TorsionFreeZeroDivisors.StageMass
+
+section
+open scoped Classical BigOperators
+open BlockAlignment ComparedBlocks RepeatedBlocks
+variable {C E : Type*} [Fintype C] (s : ℝ) (hs : 0<s) (len m : C → ℕ)
+  (cmp : Comparisons (E := E) (traversalLength len m)) (err : ℕ)
+
+def totalLength : ℝ := ∑ t : Traversal m, (traversalLength len m t : ℝ)
+def uncovered : ℕ := (cmp.matchingData s hs (traversalLength len m) err).unpairedPositions.card
+
+theorem unmatched_card : Fintype.card (ActualStageLabels.P s hs len m cmp err).Unmatched =
+    (cmp.matchingData s hs (traversalLength len m) err).unmatchedBlocks.card := by
+  rw [← OccurrenceMatching.Data.card_unmatched]
+  convert Fintype.card_congr
+    ((cmp.matchingData s hs (traversalLength len m) err).transportUnmatched (occurrenceEquiv s len m).symm) using 1 <;> congr! 3
+
+variable [Fintype E]
+/-- The occurrence involution used by the entropy components has exactly the
+unmatched mass of the literal half-integer comparisons. -/
+theorem unmatched_bound (ν : E → ℤ) (hsmall : 2*(err:ℝ)<s-1)
+    (herr : ∀ e,2*|(cmp.offset e:ℝ)-(ν e:ℝ)*s|+4≤err) :
+    s*Fintype.card (ActualStageLabels.P s hs len m cmp err).Unmatched ≤
+      uncovered s hs len m cmp err + 22*s*Fintype.card E + totalLength len m/s := by
+  rw [unmatched_card]
+  exact cmp.unmatched_bound s hs (traversalLength len m) err ν hsmall herr
+
+omit [Fintype E] in
+/-- Repeated traversal length is counted with its actual multiplicity. -/
+theorem totalLength_eq : totalLength len m = ∑ c, (m c:ℝ)*len c := by
+  simp only [totalLength,Fintype.sum_sigma,traversalLength,Finset.sum_const,
+    Finset.card_univ,Fintype.card_fin,nsmul_eq_mul]
+
+omit [Fintype E] in
+theorem fullMass_eq : (∑ i : Underlying s len, (multiplicity s len m i:ℝ)) =
+    ∑ c, (blockCount s (len c):ℝ)*m c := by
+  simp only [Underlying,Block,Fintype.sum_sigma,RepeatedBlocks.multiplicity,Finset.sum_const,
+    Finset.card_univ,Fintype.card_fin,nsmul_eq_mul]
+
+omit [Fintype E] in
+include hs in
+/-- The only mass lost from full blocks is at the ends of actual chain
+traversals. In particular repeated paths do not reduce this loss count. -/
+theorem fullMass_lower : totalLength len m ≤
+    s*(∑ i : Underlying s len, (multiplicity s len m i:ℝ)) + s*(∑ c,(m c:ℝ)) := by
+  rw [totalLength_eq,fullMass_eq,Finset.mul_sum,Finset.mul_sum,← Finset.sum_add_distrib]
+  apply Finset.sum_le_sum
+  intro c _
+  have h := mul_le_mul_of_nonneg_left (count_bound s hs (len c)).2.le (Nat.cast_nonneg (m c): (0:ℝ) ≤ m c)
+  nlinarith
+
+omit [Fintype E] in
+include hs in
+theorem fullMass_lower_bounded (M Q : ℕ) (hm : ∀ c,m c≤M) (hQ : Fintype.card C≤Q) :
+    totalLength len m ≤ s*(∑ i : Underlying s len, (multiplicity s len m i:ℝ)) + s*(M:ℝ)*Q := by
+  have hm' : (∑ c,(m c:ℝ)) ≤ (M:ℝ)*Q := by
+    calc
+      _ ≤ ∑ _c : C,(M:ℝ) := Finset.sum_le_sum (fun c _ => by exact_mod_cast hm c)
+      _ = (M:ℝ)*Fintype.card C := by simp; ring
+      _ ≤ _ := mul_le_mul_of_nonneg_left (by exact_mod_cast hQ) (Nat.cast_nonneg _)
+  have h := mul_le_mul_of_nonneg_left hm' hs.le
+  have hmass := fullMass_lower s hs len m
+  nlinarith
+
+end
+
+open scoped Classical BigOperators
+open BlockAlignment ComparedBlocks RepeatedBlocks
+variable {C E : Type*} [Fintype C] [Fintype E]
+  (s : ℝ) (hs : 0<s) (len m : C → ℕ)
+  (cmp : Comparisons (E := E) (traversalLength len m)) (err : ℕ)
+
+def residual (M Q : ℕ) (denError : ℝ) : ℝ :=
+  256*(22*s*Fintype.card E+totalLength len m/s) +
+    (1/1200:ℝ)*s*M*Q + M*(StageEntropy.looseCost s len err+denError)
+
+/-- All explicit finite stage losses, before the common-scale limit. -/
+theorem exponent_sum_bound (M Q : ℕ) (hm : ∀ c,m c≤M) (hQ : Fintype.card C≤Q)
+    (ν : E → ℤ) (hsmall : 2*(err:ℝ)<s-1)
+    (herr : ∀ e,2*|(cmp.offset e:ℝ)-(ν e:ℝ)*s|+4≤err)
+    (d : Underlying s len → ℤ) (hlow : ∀ i,(1/600:ℝ)*s/2≤d i)
+    (hhigh : ∀ i,(d i:ℝ)≤256*s)
+    (logn denError : ℝ) (hn : 0≤logn) (power : Fin M → ℝ)
+    (hpower : ∑ j,power j≤0) :
+    (Finset.univ.sum (fun j : Fin M => power j*logn+
+      StageEntropy.labelCost s hs len m cmp err d j.val+
+      (StageEntropy.looseCost s len err+denError))) ≤
+        -(1/1200:ℝ)*totalLength len m + 256*uncovered s hs len m cmp err+
+          residual (E := E) s len m err M Q denError := by
+  have h := StageEntropy.sum_exponents s hs len m cmp err d M hm 256 logn power
+    (fun _ => StageEntropy.looseCost s len err+denError) (by norm_num) hn hlow hhigh hpower
+  have hu := unmatched_bound s hs len m cmp err ν hsmall herr
+  have hf := fullMass_lower_bounded s hs len m M Q hm hQ
+  simp only [Finset.sum_const,Finset.card_univ,Fintype.card_fin,nsmul_eq_mul] at h
+  unfold residual
+  linarith
+
+/-- Concrete finite selection input: only an actual uncovered-length bound
+and the independently controlled remainder are needed. -/
+theorem decay (M Q : ℕ) (hm : ∀ c,m c≤M) (hQ : Fintype.card C≤Q)
+    (ν : E → ℤ) (hsmall : 2*(err:ℝ)<s-1)
+    (herr : ∀ e,2*|(cmp.offset e:ℝ)-(ν e:ℝ)*s|+4≤err)
+    (d : Underlying s len → ℤ) (hlow : ∀ i,(1/600:ℝ)*s/2≤d i)
+    (hhigh : ∀ i,(d i:ℝ)≤256*s)
+    (logn denError : ℝ) (hn : 0≤logn) (power : Fin M → ℝ)
+    (hpower : ∑ j,power j≤0)
+    (hb : (uncovered s hs len m cmp err:ℝ) ≤ StageFusion.epsilon (1/600) 256*totalLength len m)
+    (he : residual (E := E) s len m err M Q denError ≤ totalLength len m/4800) :
+    (Finset.univ.sum (fun j : Fin M => power j*logn+
+      StageEntropy.labelCost s hs len m cmp err d j.val+
+      (StageEntropy.looseCost s len err+denError))) ≤ -totalLength len m/2400 := by
+  have h := exponent_sum_bound s hs len m cmp err M Q hm hQ ν hsmall herr
+    d hlow hhigh logn denError hn power hpower
+  have hH : 0≤totalLength len m := Finset.sum_nonneg (fun _ _ => Nat.cast_nonneg _)
+  have ha := StageFusion.absorb_errors (δ := 1/600) (a := 256) (by norm_num) (by norm_num) hH hb
+    (by linarith : residual (E := E) s len m err M Q denError ≤ (1/600:ℝ)*totalLength len m/8)
+  linarith
+end TorsionFreeZeroDivisors.StageMass
+
+namespace TorsionFreeZeroDivisors.BinProfiles
+open scoped Classical BigOperators
+open BlockAlignment ComparedBlocks RepeatedBlocks WordEstimate
+
+def values (s : ℝ) : Finset ℤ := Finset.Icc 0 ⌊256*s⌋
+def profiles {C : Type*} [Fintype C] (s : ℝ) (len : C → ℕ) : Finset (Underlying s len → ℤ) :=
+  Fintype.piFinset (fun _ => values s)
+
+theorem mem_values {h : ℕ} (hh : 3002 ≤ h) (s : ℝ) (hs : 0 ≤ s)
+    (hscale : s+1200 ≤ 2*h) (hscale' : (h:ℝ) ≤ 2*s)
+    (d : ℤ) (W : Fin h → Letter) (hW : W∈binWords h d) : d∈values s := by
+  obtain ⟨hl,hu,_⟩ := bin_full_bounds h hh s hscale hscale' d W hW
+  have hd : (0:ℝ)≤d := (by positivity : (0:ℝ) ≤ (1/600:ℝ)*s/2).trans hl
+  exact Finset.mem_Icc.mpr ⟨by exact_mod_cast hd,Int.le_floor.mpr hu⟩
+
+theorem card_values (s : ℝ) (hs : 0 ≤ s) : ((values s).card:ℝ) ≤ 256*s+1 := by
+  have hf : (0:ℤ)≤⌊256*s⌋ := Int.floor_nonneg.mpr (by positivity)
+  have hcast : ((⌊256*s⌋+1).toNat:ℝ) = (⌊256*s⌋:ℝ)+1 := by
+    rw [← Int.cast_natCast,Int.toNat_of_nonneg (by omega),Int.cast_add,Int.cast_one]
+  simp only [values,Int.card_Icc,sub_zero]
+  rw [hcast]
+  linarith [Int.floor_le (256*s)]
+
+variable {C : Type*} [Fintype C]
+theorem card_profiles (s : ℝ) (len : C → ℕ) (hs : 0 ≤ s) :
+    ((profiles s len).card:ℝ) ≤ Real.exp (Fintype.card (Underlying s len)*Real.log (256*s+1)) := by
+  have hp : 0<256*s+1 := by positivity
+  rw [profiles,Fintype.card_piFinset,Finset.prod_const,Finset.card_univ,Nat.cast_pow]
+  apply (pow_le_pow_left₀ (Nat.cast_nonneg _) (card_values s hs) _).trans_eq
+  rw [Real.exp_nat_mul,Real.exp_log hp]
+
+/-- The number of all integer bin assignments is exponentially bounded by the
+actual full-block mass. There is no independence assumption between bins. -/
+theorem cardinal_bound (s : ℝ) (hs : 0<s) (len : C → ℕ) :
+    ((profiles s len).card:ℝ) ≤ Real.exp
+      (((∑ c,(len c:ℝ))/s)*Real.log (256*s+1)) := by
+  apply (card_profiles s len hs.le).trans
+  apply Real.exp_le_exp.mpr
+  apply mul_le_mul_of_nonneg_right
+  · exact (le_div_iff₀ hs).mpr (by simpa [mul_comm] using Comparisons.block_mass s hs len)
+  · exact Real.log_nonneg (by linarith)
+end TorsionFreeZeroDivisors.BinProfiles
+
+namespace TorsionFreeZeroDivisors.GridAsymptotics
+open Filter Topology
+open scoped Classical
+
+def exponent (d : ℕ) : ℝ := 1 / (2*((d : ℝ)+1))
+def N (d : ℕ) (L : ℝ) : ℕ := ⌊L ^ exponent d⌋₊
+def R (d : ℕ) (L : ℝ) : ℕ := ⌊Real.sqrt (N d L)⌋₊
+
+theorem exponent_pos (d : ℕ) : 0 < exponent d := by unfold exponent; positivity
+
+theorem N_pos (d : ℕ) {L : ℝ} (hL : 1 ≤ L) : 0 < N d L := by
+  apply Nat.floor_pos.mpr
+  exact Real.one_le_rpow hL (exponent_pos d).le
+
+theorem R_pos (d : ℕ) {L : ℝ} (hL : 1 ≤ L) : 0 < R d L := by
+  apply Nat.floor_pos.mpr
+  apply Real.le_sqrt_of_sq_le
+  norm_num
+  exact_mod_cast N_pos d hL
+
+theorem R_le_N (d : ℕ) {L : ℝ} (hL : 1 ≤ L) : R d L ≤ N d L := by
+  apply Nat.floor_le_of_le
+  apply Real.sqrt_le_iff.mpr
+  have hn : (1 : ℝ) ≤ N d L := by exact_mod_cast N_pos d hL
+  constructor <;> nlinarith
+
+theorem denominator_le_sqrt (d : ℕ) {L : ℝ} (hL : 1 ≤ L) :
+    ((N d L : ℝ)^d * R d L) ≤ Real.sqrt L := by
+  have hn : (N d L : ℝ) ≤ L ^ exponent d := Nat.floor_le (Real.rpow_nonneg (by linarith) _)
+  have hr : (R d L : ℝ) ≤ N d L := by exact_mod_cast R_le_N d hL
+  calc
+    _ ≤ (N d L : ℝ)^d * N d L := mul_le_mul_of_nonneg_left hr (by positivity)
+    _ = (N d L : ℝ)^(d+1) := (pow_succ _ _).symm
+    _ ≤ (L ^ exponent d)^(d+1) := pow_le_pow_left₀ (by positivity) hn _
+    _ = L ^ ((1:ℝ)/2) := by
+      rw [← Real.rpow_natCast,← Real.rpow_mul (by linarith : 0 ≤ L)]
+      congr 1
+      push_cast
+      unfold exponent
+      field_simp
+    _ = Real.sqrt L := (Real.sqrt_eq_rpow _).symm
+
+def scale (d : ℕ) (L : ℝ) (u : ℕ) : ℝ := L / ((u : ℝ)*R d L)
+
+theorem scale_bounds (d : ℕ) {L : ℝ} (hL : 1 ≤ L) {u : ℕ}
+    (hu : 1 ≤ u) (hub : u ≤ (N d L)^d) :
+    Real.sqrt L ≤ scale d L u ∧ scale d L u / L ≤ 1/(R d L : ℝ) := by
+  have hLp : 0 < L := by linarith
+  have hRp : (0 : ℝ) < R d L := by exact_mod_cast R_pos d hL
+  have hup : (0 : ℝ) < u := by exact_mod_cast hu
+  have huR : ((u : ℝ)*R d L) ≤ Real.sqrt L := by
+    have hubr : (u : ℝ) ≤ (N d L : ℝ)^d := by exact_mod_cast hub
+    apply le_trans (mul_le_mul_of_nonneg_right hubr hRp.le)
+    simpa using denominator_le_sqrt d hL
+  constructor
+  · unfold scale
+    apply (le_div_iff₀ (mul_pos hup hRp)).mpr
+    have hs := Real.sq_sqrt hLp.le
+    have ht := mul_le_mul_of_nonneg_left huR (Real.sqrt_nonneg L)
+    nlinarith
+  · have hs : scale d L u ≤ L / (R d L : ℝ) := by
+      unfold scale
+      apply div_le_div_of_nonneg_left hLp.le hRp
+      have hu1 : (1 : ℝ) ≤ u := by exact_mod_cast hu
+      nlinarith
+    apply (div_le_iff₀ hLp).mpr
+    simpa [div_eq_mul_inv,mul_comm] using hs
+
+theorem N_tendsto (d : ℕ) : Tendsto (fun L : ℝ => (N d L : ℝ)) atTop atTop := by
+  exact (tendsto_natCast_atTop_atTop.comp tendsto_nat_floor_atTop).comp
+    (tendsto_rpow_atTop (exponent_pos d))
+
+theorem R_tendsto (d : ℕ) : Tendsto (fun L : ℝ => (R d L : ℝ)) atTop atTop := by
+  exact (tendsto_natCast_atTop_atTop.comp tendsto_nat_floor_atTop).comp
+    (Real.tendsto_sqrt_atTop.comp (N_tendsto d))
+
+theorem alignment_error_tendsto (d : ℕ) :
+    Tendsto (fun L : ℝ => (R d L : ℝ)/(N d L : ℝ)) atTop (𝓝 0) := by
+  have hupper : Tendsto (fun L : ℝ => 1 / Real.sqrt (N d L)) atTop (𝓝 0) :=
+    tendsto_const_nhds.div_atTop (Real.tendsto_sqrt_atTop.comp (N_tendsto d))
+  apply squeeze_zero' (Eventually.of_forall (fun _ => div_nonneg (Nat.cast_nonneg _) (Nat.cast_nonneg _)))
+    (eventually_atTop.mpr ⟨1,fun L hL => ?_⟩) hupper
+  have hn : (0 : ℝ) < N d L := by exact_mod_cast N_pos d hL
+  have hs := Real.sqrt_pos.mpr hn
+  have hr : (R d L : ℝ) ≤ Real.sqrt (N d L) := Nat.floor_le (Real.sqrt_nonneg _)
+  apply (div_le_div_iff₀ hn hs).mpr
+  have ht := mul_le_mul_of_nonneg_right hr hs.le
+  have he := Real.sq_sqrt hn.le
+  nlinarith
+
+/-- Exactly the source compatibility test, before choosing the least u. -/
+def Compatible (d : ℕ) (L : ℝ) (offset : Fin d → ℤ) (u : ℕ) : Prop :=
+  1 ≤ u ∧ ∃ z : Fin d → ℤ, ∀ i,
+    |(u : ℝ)*((offset i : ℝ)/L)-(z i : ℝ)| < 1/(N d L : ℝ)
+
+theorem compatible_exists (d : ℕ) {L : ℝ} (hL : 1 ≤ L) (offset : Fin d → ℤ) :
+    ∃ u, Compatible d L offset u := by
+  obtain ⟨u,hu,_,z,hz⟩ := BlockGrid.simultaneous (N_pos d hL) (fun i => (offset i : ℝ)/L)
+  exact ⟨u,hu,z,hz⟩
+
+def chosenU (d : ℕ) (L : ℝ) (offset : Fin d → ℤ) : ℕ :=
+  if hL : 1 ≤ L then Nat.find (compatible_exists d hL offset) else 1
+
+theorem chosen_spec (d : ℕ) {L : ℝ} (hL : 1 ≤ L) (offset : Fin d → ℤ) :
+    Compatible d L offset (chosenU d L offset) := by
+  unfold chosenU
+  rw [dite_eq_left hL]
+  exact Nat.find_spec _
+
+theorem chosen_min (d : ℕ) {L : ℝ} (hL : 1 ≤ L) (offset : Fin d → ℤ) {v : ℕ}
+    (hv : Compatible d L offset v) : chosenU d L offset ≤ v := by
+  unfold chosenU
+  rw [dite_eq_left hL]
+  exact Nat.find_min' _ hv
+
+theorem chosen_bound (d : ℕ) {L : ℝ} (hL : 1 ≤ L) (offset : Fin d → ℤ) :
+    chosenU d L offset ≤ (N d L)^d := by
+  obtain ⟨u,hu,hub,z,hz⟩ := BlockGrid.simultaneous (N_pos d hL) (fun i => (offset i : ℝ)/L)
+  exact (chosen_min d hL offset ⟨hu,z,hz⟩).trans hub
+
+def chosenScale (d : ℕ) (L : ℝ) (offset : Fin d → ℤ) : ℝ :=
+  scale d L (chosenU d L offset)
+
+theorem chosen_alignment (d : ℕ) {L : ℝ} (hL : 1 ≤ L) (offset : Fin d → ℤ) :
+    ∃ ν : Fin d → ℤ, ∀ i,
+      |(offset i : ℝ)/chosenScale d L offset-(ν i : ℝ)| < (R d L : ℝ)/(N d L) := by
+  obtain ⟨hu,z,hz⟩ := chosen_spec d hL offset
+  refine ⟨fun i => (R d L : ℤ)*z i,fun i => ?_⟩
+  have hLp : L ≠ 0 := ne_of_gt (by linarith : 0 < L)
+  have hR : (0 : ℝ) < R d L := by exact_mod_cast R_pos d hL
+  have hh := mul_lt_mul_of_pos_left (hz i) hR
+  have he : (offset i : ℝ)/chosenScale d L offset-((R d L : ℤ)*z i : ℤ) =
+      (R d L : ℝ)*((chosenU d L offset : ℝ)*((offset i : ℝ)/L)-(z i : ℝ)) := by
+    simp only [chosenScale,scale,Int.cast_mul,Int.cast_natCast]
+    field_simp
+  rw [he,abs_mul,abs_of_pos hR]
+  simpa [div_eq_mul_inv,mul_assoc] using hh
+
+/-- Uniformly over arbitrary schedules of all prescribed offsets. -/
+theorem scale_tendsto (d : ℕ) (offset : ℝ → Fin d → ℤ) :
+    Tendsto (fun L => chosenScale d L (offset L)) atTop atTop := by
+  apply tendsto_atTop_mono' atTop ?_ Real.tendsto_sqrt_atTop
+  filter_upwards [eventually_ge_atTop (1 : ℝ)] with L hL
+  exact (scale_bounds d hL (chosen_spec d hL (offset L)).1 (chosen_bound d hL (offset L))).1
+
+theorem relative_scale_tendsto (d : ℕ) (offset : ℝ → Fin d → ℤ) :
+    Tendsto (fun L => chosenScale d L (offset L)/L) atTop (𝓝 0) := by
+  have hu : Tendsto (fun L : ℝ => 1/(R d L : ℝ)) atTop (𝓝 0) :=
+    tendsto_const_nhds.div_atTop (R_tendsto d)
+  apply squeeze_zero' ?_ ?_ hu
+  · filter_upwards [eventually_ge_atTop (1 : ℝ)] with L hL
+    exact div_nonneg (div_nonneg (by linarith) (mul_nonneg (Nat.cast_nonneg _) (Nat.cast_nonneg _)))
+      (by linarith)
+  · filter_upwards [eventually_ge_atTop (1 : ℝ)] with L hL
+    exact (scale_bounds d hL (chosen_spec d hL (offset L)).1 (chosen_bound d hL (offset L))).2
+
+/-- Relative errors for lost cut blocks plus rounded block lengths. -/
+theorem grid_loss_tendsto (d : ℕ) (offset : ℝ → Fin d → ℤ) :
+    Tendsto (fun L => chosenScale d L (offset L)/L + 1/chosenScale d L (offset L)) atTop (𝓝 0) := by
+  have hi : Tendsto (fun L => (1 : ℝ)/chosenScale d L (offset L)) atTop (𝓝 0) :=
+    tendsto_const_nhds.div_atTop (scale_tendsto d offset)
+  simpa using (relative_scale_tendsto d offset).add hi
+
+/-- A fixed integer loss shared by all comparison sides. -/
+def letterError (d : ℕ) (L : ℝ) (offset : Fin d → ℤ) : ℕ :=
+  ⌈2*((R d L : ℝ)/(N d L))*chosenScale d L offset+4⌉₊
+
+theorem chosenScale_pos (d : ℕ) {L : ℝ} (hL : 1 ≤ L) (offset : Fin d → ℤ) :
+    0 < chosenScale d L offset := by
+  exact lt_of_lt_of_le (Real.sqrt_pos.mpr (by linarith))
+    (scale_bounds d hL (chosen_spec d hL offset).1 (chosen_bound d hL offset)).1
+
+theorem letterError_bounds (d : ℕ) {L : ℝ} (hL : 1 ≤ L) (offset : Fin d → ℤ) :
+    2*((R d L : ℝ)/(N d L))*chosenScale d L offset+4 ≤ letterError d L offset ∧
+    (letterError d L offset : ℝ) ≤
+      2*((R d L : ℝ)/(N d L))*chosenScale d L offset+5 := by
+  constructor
+  · exact Nat.le_ceil _
+  · have hs := chosenScale_pos d hL offset
+    have hh := Nat.ceil_lt_add_one (show 0 ≤
+        2*((R d L : ℝ)/(N d L))*chosenScale d L offset+4 by
+        positivity)
+    dsimp only [letterError]
+    linarith
+
+theorem uniform_alignment (d : ℕ) {L : ℝ} (hL : 1 ≤ L) (offset : Fin d → ℤ) :
+    ∃ ν : Fin d → ℤ, ∀ i,
+      2*|(offset i : ℝ)-(ν i : ℝ)*chosenScale d L offset|+4 ≤ letterError d L offset := by
+  obtain ⟨ν,hν⟩ := chosen_alignment d hL offset
+  refine ⟨ν,fun i => ?_⟩
+  have hs := chosenScale_pos d hL offset
+  have hh := (mul_lt_mul_of_pos_right (hν i) hs).le
+  have he : |(offset i : ℝ)/chosenScale d L offset-(ν i : ℝ)| *chosenScale d L offset =
+      |(offset i : ℝ)-(ν i : ℝ)*chosenScale d L offset| := by
+    rw [← abs_of_pos hs,← abs_mul]
+    congr 1
+    rw [abs_of_pos hs]
+    field_simp
+  rw [he] at hh
+  have hr := (letterError_bounds d hL offset).1
+  nlinarith
+
+theorem relative_error_tendsto (d : ℕ) (offset : ℝ → Fin d → ℤ) :
+    Tendsto (fun L => (letterError d L (offset L) : ℝ)/chosenScale d L (offset L)) atTop (𝓝 0) := by
+  have hi : Tendsto (fun L => (5 : ℝ)/chosenScale d L (offset L)) atTop (𝓝 0) :=
+    tendsto_const_nhds.div_atTop (scale_tendsto d offset)
+  have hu : Tendsto (fun L => 2*((R d L : ℝ)/(N d L))+5/chosenScale d L (offset L)) atTop (𝓝 0) := by
+    simpa using ((alignment_error_tendsto d).const_mul 2).add hi
+  apply squeeze_zero' ?_ ?_ hu
+  · filter_upwards [eventually_ge_atTop (1 : ℝ)] with L hL
+    exact div_nonneg (Nat.cast_nonneg _) (chosenScale_pos d hL (offset L)).le
+  · filter_upwards [eventually_ge_atTop (1 : ℝ)] with L hL
+    have hs := chosenScale_pos d hL (offset L)
+    apply (div_le_iff₀ hs).mpr
+    have hh := (letterError_bounds d hL (offset L)).2
+    have he : (2*((R d L : ℝ)/(N d L))+5/chosenScale d L (offset L))*chosenScale d L (offset L) =
+        2*((R d L : ℝ)/(N d L))*chosenScale d L (offset L)+5 := by
+      field_simp
+    rwa [he]
+
+theorem eventually_small_error (d : ℕ) (offset : ℝ → Fin d → ℤ) :
+    ∀ᶠ L in atTop, 2*(letterError d L (offset L) : ℝ) < chosenScale d L (offset L)-1 := by
+  have hfrac := (relative_error_tendsto d offset).eventually (gt_mem_nhds (show (0 : ℝ) < 1/4 by norm_num))
+  have hlarge := (scale_tendsto d offset).eventually (eventually_gt_atTop (2 : ℝ))
+  filter_upwards [hfrac,hlarge] with L hL hs
+  have hh := (div_lt_iff₀ (show 0 < chosenScale d L (offset L) by linarith)).mp hL
+  linarith
+
+end TorsionFreeZeroDivisors.GridAsymptotics
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/GroupRing/StageExpectation.lean b/lean/OAI/Algebra/GroupRing/StageExpectation.lean
new file mode 100644
index 0000000000000000000000000000000000000000..c86de66a81b1ea53b96af7f0267513b08fc64a66
--- /dev/null
+++ b/lean/OAI/Algebra/GroupRing/StageExpectation.lean
@@ -0,0 +1,408 @@
+import Mathlib
+import OAI.Algebra.GroupRing.StageBlocks
+import OAI.Algebra.GroupRing.StageRealization
+
+namespace OAI
+
+noncomputable section
+
+namespace TorsionFreeZeroDivisors.StageExpectation
+open scoped Classical BigOperators
+open ChainSubdivision BlockAlignment ComparedBlocks RepeatedBlocks WordEstimate
+section
+local instance : DecidableEq Types.Letter := Classical.decEq _
+variable {C V TV : Type*} [Fintype C] [Fintype V] [Fintype TV]
+variable (s : ℝ) (hs : 0 < s) (len : C → ℕ) (first last : C → V)
+
+include hs in
+/-- The retained full-block bins bound the actual turn product of the
+subdivided graph, not a separate abstract word process. -/
+theorem turnProduct_bin (w : C → ℤ → Letter) (d : Underlying s len → ℤ)
+    (hbin : ∀ i, word s len w i ∈ binWords (height s len i) (d i)) :
+    ChainRealization.turnProduct len w ≤ Real.exp (-∑ i, (d i : ℝ)) := by
+  rw [ChainRealization.turnProduct,← ChainWeights.chainProduct_eq len w]
+  exact ChainWeights.chain_bin_bound s hs len w d hbin
+
+include hs in
+/-- Source equation (entropy-fixed-label-expectation), in its exact finite
+form before the uniform asymptotic prescription and marked-vertex errors. -/
+theorem fixed_label_bin_bound (outgoing : TV → Finset Types.Letter)
+    (pp : V → Option TV) (n p : ℝ) (hp : 0 ≤ p)
+    (w : C → ℤ → Letter) (d : Underlying s len → ℤ)
+    (hbin : ∀ i, word s len w i ∈ binWords (height s len i) (d i))
+    (himm : Function.Injective (fun a =>
+      ((graph len first last).origin a, ChainRealization.label len w a)))
+    (hn : (Fintype.card TV : ℝ) ≤ n)
+    (htable : ∀ t u, t ≠ u →
+      (Fintype.card {x : TV // t ∈ outgoing x ∧ u ∈ outgoing x} : ℝ) ≤
+        n*p*TypeWeights.jointWeight t u)
+    (N D R : ℕ) (hD : 2 ≤ D) (hR : 0 < R)
+    (hdegree : ∀ v, Nat.card {a : PatternEmbeddings.Dart outgoing //
+      PatternEmbeddings.origin outgoing a = v} ≤ D)
+    (hsize : ∀ x : PatternEmbeddings.Dart outgoing,
+      R + (∑ c, len c) + 4*D^(2*N+1) ≤
+        Nat.card {a : PatternEmbeddings.Dart outgoing //
+          PatternEmbeddings.label outgoing a = PatternEmbeddings.label outgoing x})
+    (hΩ : (ConditionedMatchings.Matching.conditioned
+      (label := PatternEmbeddings.label outgoing) (bar := Types.inverse)
+      (PatternEmbeddings.origin outgoing) N ∅).Nonempty) :
+    ((∑ r ∈ ConditionedMatchings.Matching.conditioned
+      (label := PatternEmbeddings.label outgoing) (bar := Types.inverse)
+      (PatternEmbeddings.origin outgoing) N ∅,
+        StageRealization.realizations (graph len first last) (ChainRealization.label len w)
+          outgoing (ChainRealization.pin len pp) Types.inverse r : ℕ) : ℝ) /
+      (ConditionedMatchings.Matching.conditioned
+        (label := PatternEmbeddings.label outgoing) (bar := Types.inverse)
+        (PatternEmbeddings.origin outgoing) N ∅).card ≤
+      (n^((Finset.univ.filter fun v => pp v = none).card+∑ c, (len c-1)) *
+        p^(∑ c, (len c-1))) / (R : ℝ)^(∑ c, len c) *
+        Real.exp (-∑ i, (d i : ℝ)) := by
+  have hn0 : 0 ≤ n := (Nat.cast_nonneg (Fintype.card TV)).trans hn
+  refine (ChainRealization.fixed_label_bound len first last outgoing pp n p w
+    himm hn htable N D R hD hR hdegree hsize hΩ).trans ?_
+  rw [div_mul_eq_mul_div]
+  apply div_le_div_of_nonneg_right _ (by positivity)
+  exact mul_le_mul_of_nonneg_left (turnProduct_bin s hs len w d hbin) (by positivity)
+
+/-- Finite Fubini for the actual permitted-label union. We count only
+immersed template labels and do not assume independence of repeated edges. -/
+theorem label_union_mean {Ω W : Type*} (sample : Finset Ω) (labels : Finset W)
+    (X : W → Ω → ℕ) (B : ℝ)
+    (hX : ∀ w ∈ labels, ((∑ r ∈ sample, X w r : ℕ) : ℝ)/sample.card ≤ B) :
+    ((∑ r ∈ sample, ∑ w ∈ labels, X w r : ℕ) : ℝ)/sample.card ≤
+      (labels.card : ℝ)*B := by
+  rw [Finset.sum_comm,Nat.cast_sum,Finset.sum_div]
+  calc
+    _ ≤ ∑ _w ∈ labels, B := Finset.sum_le_sum hX
+    _ = _ := by simp
+
+/-- Finite letters on a chain, extended only to make the integer indexing
+convenient. The fallback is never used at an edge of the pattern. -/
+def readWord (F : ComparedBlocks.Position len → Letter) (c : C) (q : ℤ) : Letter :=
+  if h : q ∈ positions 0 (len c) then F ⟨c,⟨q,h⟩⟩ else default
+
+omit [Fintype C] in
+@[simp] theorem readWord_on (F : ComparedBlocks.Position len → Letter) (c : C)
+    (q : positions 0 (len c)) : readWord len F c q.val = F ⟨c,q⟩ := by
+  simp [readWord,q.property]
+
+omit [Fintype C] in
+include hs in
+theorem word_position (i : Underlying s len) (k : Fin (height s len i)) :
+    (k.val : ℤ)+lower s len i ∈ positions 0 (len i.1) := by
+  let q := (wordCoordinate s len i).symm k
+  have hv := wordCoordinate_val s len i q
+  rw [show (wordCoordinate s len i) q = k from Equiv.apply_symm_apply _ _] at hv
+  have he : (k.val : ℤ)+lower s len i = q.val := by omega
+  rw [he]
+  exact full_subset s hs (len i.1) i.2 q.property
+
+end
+
+section Active
+open ChainStageLabels
+variable {C E : Type*} [Fintype C] (s : ℝ) (hs : 0 < s) (len m : C → ℕ) (j : ℕ)
+
+abbrev activeLen : ActiveChain m j → ℕ := fun c => len c.val
+
+def activeIndex (i : Underlying s (activeLen len m j)) : Underlying s len := ⟨i.1.val,i.2⟩
+
+/-- The active-block subtype counts exactly the full blocks of the active
+chains; no inactive full block is inserted into this stage. -/
+def activeBlockEquiv : Underlying s (activeLen len m j) ≃ activeBlocks s len m j where
+  toFun i := ⟨activeIndex s len m j i,by
+    exact Finset.mem_filter.mpr ⟨Finset.mem_univ _,i.1.property⟩⟩
+  invFun i := ⟨⟨i.val.1,(Finset.mem_filter.mp i.property).2⟩,i.val.2⟩
+  left_inv i := by cases i; rfl
+  right_inv i := by cases i; rfl
+
+include hs in
+/-- A permitted full-stage assignment really has the prescribed bins on
+every active chain, under the literal integer coordinates. -/
+theorem active_bins (cmp : Comparisons (E := E) (traversalLength len m))
+    (d : Underlying s len → ℤ) (F : StagePosition len m j → Letter)
+    (hF : F ∈ fullWords s len m j cmp d) :
+    ∀ i, word s (activeLen len m j) (readWord (activeLen len m j) F) i ∈
+      binWords (height s (activeLen len m j) i) (d (activeIndex s len m j i)) := by
+  obtain ⟨w,_,_,hb,rfl⟩ := (Finset.mem_filter.mp hF).2
+  intro i
+  have he : word s (activeLen len m j)
+      (readWord (activeLen len m j) (fun x => w x.1.val x.2.val)) i =
+      word s len w (activeIndex s len m j i) := by
+    funext k
+    dsimp only [word,readWord]
+    rw [dite_eq_left (word_position s hs (activeLen len m j) i k)]
+    rfl
+  rw [he]
+  exact hb (activeIndex s len m j i)
+
+/-- Equality of the literal active bin sum and the filtered global bin sum. -/
+theorem active_bin_sum (d : Underlying s len → ℤ) :
+    (∑ i : Underlying s (activeLen len m j), (d (activeIndex s len m j i) : ℝ)) =
+      ∑ i ∈ activeBlocks s len m j, (d i : ℝ) := by
+  calc
+    _ = ∑ i : activeBlocks s len m j, (d i.val : ℝ) :=
+      Fintype.sum_equiv (activeBlockEquiv s len m j) _ _ (fun _ => rfl)
+    _ = _ := Finset.sum_coe_sort (activeBlocks s len m j) (fun i => (d i : ℝ))
+
+end Active
+variable {C V TV : Type*} [Fintype C] [Fintype V] [Fintype TV]
+variable (s : ℝ) (hs : 0 < s) (len : C → ℕ) (first last : C → V)
+local instance : DecidableEq Types.Letter := Classical.decEq _
+
+def immersedWords (X : Finset (ComparedBlocks.Position len → Letter)) :
+    Finset (ComparedBlocks.Position len → Letter) :=
+  X.filter (fun F => Function.Injective (fun a =>
+    ((graph len first last).origin a,ChainRealization.label len (readWord len F) a)))
+
+/-- The stage random variable is a literal sum of feasible injective graph
+realizations, restricted to the full-word projection and to immersed labels. -/
+def count (outgoing : TV → Finset Types.Letter) (pp : V → Option TV)
+    (X : Finset (ComparedBlocks.Position len → Letter))
+    (r : ConditionedMatchings.Matching (PatternEmbeddings.label outgoing) Types.inverse) : ℕ :=
+  ∑ F ∈ immersedWords len first last X,
+    StageRealization.realizations (graph len first last)
+      (ChainRealization.label len (readWord len F)) outgoing (ChainRealization.pin len pp)
+      Types.inverse r
+
+include hs in
+/-- The exact stage expectation, including the full prescribed matching
+model and all dependencies among repeated edge occurrences. -/
+theorem mean_bound (outgoing : TV → Finset Types.Letter) (pp : V → Option TV)
+    (X : Finset (ComparedBlocks.Position len → Letter))
+    (n p : ℝ) (hp : 0 ≤ p) (d : Underlying s len → ℤ)
+    (hbin : ∀ F ∈ X, ∀ i, word s len (readWord len F) i ∈
+      binWords (height s len i) (d i))
+    (hn : (Fintype.card TV : ℝ) ≤ n)
+    (htable : ∀ t u, t ≠ u →
+      (Fintype.card {x : TV // t ∈ outgoing x ∧ u ∈ outgoing x} : ℝ) ≤
+        n*p*TypeWeights.jointWeight t u)
+    (N D R : ℕ) (hD : 2 ≤ D) (hR : 0 < R)
+    (hdegree : ∀ v, Nat.card {a : PatternEmbeddings.Dart outgoing //
+      PatternEmbeddings.origin outgoing a = v} ≤ D)
+    (hsize : ∀ x : PatternEmbeddings.Dart outgoing,
+      R + (∑ c, len c) + 4*D^(2*N+1) ≤
+        Nat.card {a : PatternEmbeddings.Dart outgoing //
+          PatternEmbeddings.label outgoing a = PatternEmbeddings.label outgoing x})
+    (hΩ : (ConditionedMatchings.Matching.conditioned
+      (label := PatternEmbeddings.label outgoing) (bar := Types.inverse)
+      (PatternEmbeddings.origin outgoing) N ∅).Nonempty) :
+    ((∑ r ∈ ConditionedMatchings.Matching.conditioned
+      (label := PatternEmbeddings.label outgoing) (bar := Types.inverse)
+      (PatternEmbeddings.origin outgoing) N ∅,
+        count len first last outgoing pp X r : ℕ) : ℝ) /
+      (ConditionedMatchings.Matching.conditioned
+        (label := PatternEmbeddings.label outgoing) (bar := Types.inverse)
+        (PatternEmbeddings.origin outgoing) N ∅).card ≤
+      (X.card : ℝ)*((n^((Finset.univ.filter fun v => pp v = none).card+∑ c, (len c-1)) *
+        p^(∑ c, (len c-1))) / (R : ℝ)^(∑ c, len c) *
+        Real.exp (-∑ i, (d i : ℝ))) := by
+  have hn0 : 0 ≤ n := (Nat.cast_nonneg (Fintype.card TV)).trans hn
+  refine (label_union_mean _ (immersedWords len first last X) _
+    (((n^((Finset.univ.filter fun v => pp v = none).card+∑ c, (len c-1)) *
+      p^(∑ c, (len c-1))) / (R : ℝ)^(∑ c, len c)) *
+      Real.exp (-∑ i, (d i : ℝ))) ?_).trans ?_
+  · intro F hF
+    obtain ⟨hx,hi⟩ := (Finset.mem_filter.mp hF)
+    exact fixed_label_bin_bound s hs len first last outgoing pp n p hp (readWord len F) d
+      (hbin F hx) hi hn htable N D R hD hR hdegree hsize hΩ
+  · exact mul_le_mul_of_nonneg_right
+      (Nat.cast_le.mpr (Finset.card_filter_le ..)) (by positivity)
+
+end TorsionFreeZeroDivisors.StageExpectation
+
+/-! Finite Fubini for the product of the separately girth-conditioned sides.
+The label set here is global: it is not replaced by the product of its two
+projections. This is the independence actually used in entropy.tex 396–435. -/
+namespace TorsionFreeZeroDivisors.TwoSideMean
+open scoped BigOperators Classical
+
+variable {A B W : Type*}
+
+def mean (Ω : Finset A) (X : A → ℕ) : ℝ := (∑ r ∈ Ω, X r : ℕ) / (Ω.card : ℝ)
+
+theorem mean_nonneg (Ω : Finset A) (X : A → ℕ) : 0 ≤ mean Ω X := by
+  unfold mean
+  positivity
+
+theorem mean_product (ΩA : Finset A) (ΩB : Finset B) (X : A → ℕ) (Y : B → ℕ) :
+    mean (ΩA ×ˢ ΩB) (fun r => X r.1 * Y r.2) = mean ΩA X * mean ΩB Y := by
+  unfold mean
+  rw [Finset.sum_product]
+  simp_rw [← Finset.mul_sum]
+  rw [← Finset.sum_mul, Finset.card_product, Nat.cast_mul, Nat.cast_mul]
+  ring
+
+/-- The product model factors only after a whole global label assignment is
+fixed. No assertion that the allowed labels on the two sides are independent. -/
+theorem fixed_mean_bound (ΩA : Finset A) (ΩB : Finset B)
+    (X : A → ℕ) (Y : B → ℕ) {a b : ℝ}
+    (ha : mean ΩA X ≤ a) (hb : mean ΩB Y ≤ b) :
+    mean (ΩA ×ˢ ΩB) (fun r => X r.1 * Y r.2) ≤ a*b := by
+  rw [mean_product]
+  exact mul_le_mul ha hb (mean_nonneg ΩB Y) ((mean_nonneg ΩA X).trans ha)
+
+/-- A finite union bound keeps the exact number of global label assignments,
+not a product of the sizes of projection sets (which could lose the entropy). -/
+theorem label_union (Ω : Finset A) (labels : Finset W) (X : W → A → ℕ)
+    {b : ℝ} (hX : ∀ w ∈ labels, mean Ω (X w) ≤ b) :
+    mean Ω (fun r => ∑ w ∈ labels, X w r) ≤ (labels.card : ℝ)*b := by
+  unfold mean at *
+  rw [Finset.sum_comm, Nat.cast_sum, Finset.sum_div]
+  calc
+    _ ≤ ∑ _w ∈ labels, b := Finset.sum_le_sum hX
+    _ = _ := by simp
+
+theorem global_mean_bound (ΩA : Finset A) (ΩB : Finset B) (labels : Finset W)
+    (X : W → A → ℕ) (Y : W → B → ℕ) {a b : ℝ}
+    (ha : ∀ w ∈ labels, mean ΩA (X w) ≤ a)
+    (hb : ∀ w ∈ labels, mean ΩB (Y w) ≤ b) :
+    mean (ΩA ×ˢ ΩB) (fun r => ∑ w ∈ labels, X w r.1 * Y w r.2) ≤
+      (labels.card : ℝ)*(a*b) := by
+  exact label_union _ _ _ fun w hw => fixed_mean_bound _ _ _ _ (ha w hw) (hb w hw)
+
+/-- Product conditioning is literally a product when the girth restriction
+is imposed separately on the disjoint sides. -/
+theorem filter_product (ΩA : Finset A) (ΩB : Finset B) (PA : A → Prop) (PB : B → Prop) :
+    (ΩA ×ˢ ΩB).filter (fun r => PA r.1 ∧ PB r.2) =
+      (ΩA.filter PA) ×ˢ (ΩB.filter PB) := by
+  ext r
+  simp only [Finset.mem_filter, Finset.mem_product]
+  tauto
+
+end TorsionFreeZeroDivisors.TwoSideMean
+
+namespace TorsionFreeZeroDivisors.TwoSideStage
+open scoped Classical BigOperators
+open ChainSubdivision PatternEmbeddings ConditionedMatchings BlockAlignment ComparedBlocks RepeatedBlocks
+local instance : DecidableEq Types.Letter := Classical.decEq _
+
+/-- A stage on one prescribed side. Its marked vertices do not include any
+isolated vertices of inactive chains. The source number of available vertices
+is n on EACH side, not the cardinality 2n of their disjoint union. -/
+structure Side where
+  C : Type
+  V : Type
+  TV : Type
+  fC : Fintype C
+  fV : Fintype V
+  fTV : Fintype TV
+  len : C → ℕ
+  first : C → V
+  last : C → V
+  outgoing : TV → Finset Types.Letter
+  pin : V → Option TV
+attribute [instance] Side.fC Side.fV Side.fTV
+
+abbrev Side.Word (S : Side) := ComparedBlocks.Position S.len → WordEstimate.Letter
+abbrev Side.Match (S : Side) := Matching (label S.outgoing) Types.inverse
+
+def Side.samples (S : Side) (N : ℕ) : Finset S.Match :=
+  Matching.conditioned (label := label S.outgoing) (bar := Types.inverse)
+    (origin S.outgoing) N ∅
+
+def Side.immersed (S : Side) (F : S.Word) : Prop :=
+  Function.Injective (fun a => ((graph S.len S.first S.last).origin a,
+    ChainRealization.label S.len (StageExpectation.readWord S.len F) a))
+
+def Side.realizations (S : Side) (F : S.Word) (r : S.Match) : ℕ :=
+  StageRealization.realizations (graph S.len S.first S.last)
+    (ChainRealization.label S.len (StageExpectation.readWord S.len F))
+    S.outgoing (ChainRealization.pin S.len S.pin) Types.inverse r
+
+def Side.internal (S : Side) : ℕ := ∑ c, (S.len c-1)
+def Side.edges (S : Side) : ℕ := ∑ c, S.len c
+def Side.freeMarks (S : Side) : ℕ := (Finset.univ.filter fun v => S.pin v = none).card
+
+def Side.cost (S : Side) (n p : ℝ) (R : ℕ) : ℝ :=
+  (n^(S.freeMarks+S.internal)*p^S.internal)/(R : ℝ)^S.edges
+
+/-- All probability hypotheses are the literal finite matching conditions.
+No expected count or entropy estimate is a field of this certificate. -/
+structure Conditions (S : Side) (n p : ℝ) (N D R : ℕ) : Prop where
+  nonneg : 0 ≤ p
+  vertices : (Fintype.card S.TV : ℝ) ≤ n
+  table : ∀ t u, t ≠ u →
+    (Fintype.card {x : S.TV // t ∈ S.outgoing x ∧ u ∈ S.outgoing x} : ℝ) ≤
+      n*p*TypeWeights.jointWeight t u
+  degree_lower : 2 ≤ D
+  denominator_pos : 0 < R
+  degree : ∀ v, Nat.card {a : PatternEmbeddings.Dart S.outgoing // origin S.outgoing a = v} ≤ D
+  room : ∀ x : PatternEmbeddings.Dart S.outgoing,
+    R+S.edges+4*D^(2*N+1) ≤
+      Nat.card {a : PatternEmbeddings.Dart S.outgoing // label S.outgoing a = label S.outgoing x}
+  nonempty : (S.samples N).Nonempty
+
+variable (s : ℝ) (hs : 0 < s)
+
+def Side.bins (S : Side) (d : Underlying s S.len → ℤ) (F : S.Word) : Prop :=
+  ∀ i, RepeatedBlocks.word s S.len (StageExpectation.readWord S.len F) i ∈
+    WordEstimate.binWords (RepeatedBlocks.height s S.len i) (d i)
+
+include hs in
+/-- Exact single-side specialization reused at each fixed GLOBAL label. -/
+theorem fixed_mean (S : Side) (n p : ℝ) (N D R : ℕ) (h : Conditions S n p N D R)
+    (F : S.Word) (hF : S.immersed F) (d : Underlying s S.len → ℤ)
+    (hd : S.bins s d F) :
+    TwoSideMean.mean (S.samples N) (S.realizations F) ≤
+      S.cost n p R * Real.exp (-∑ i, (d i : ℝ)) := by
+  exact StageExpectation.fixed_label_bin_bound s hs S.len S.first S.last S.outgoing S.pin
+    n p h.nonneg (StageExpectation.readWord S.len F) d hd hF h.vertices h.table
+    N D R h.degree_lower h.denominator_pos h.degree h.room h.nonempty
+
+variable {W : Type*}
+
+/-- Only one filter of the global string set; it does not discard comparisons
+between sides or enlarge that set to the product of projections. -/
+def immersedLabels (A B : Side) (X : Finset W) (WA : W → A.Word) (WB : W → B.Word) : Finset W :=
+  X.filter fun w => A.immersed (WA w) ∧ B.immersed (WB w)
+
+def count (A B : Side) (X : Finset W) (WA : W → A.Word) (WB : W → B.Word)
+    (r : A.Match × B.Match) : ℕ :=
+  ∑ w ∈ immersedLabels A B X WA WB, A.realizations (WA w) r.1 * B.realizations (WB w) r.2
+
+include hs in
+/-- Literal two-side stage first moment. Conditioning factors into the product
+of the girth restrictions; repeated-edge dependencies stay inside each matching. -/
+theorem mean_bound (A B : Side) (X : Finset W) (WA : W → A.Word) (WB : W → B.Word)
+    (n p : ℝ) (N D R : ℕ) (hA : Conditions A n p N D R) (hB : Conditions B n p N D R)
+    (dA : Underlying s A.len → ℤ) (dB : Underlying s B.len → ℤ)
+    (hdA : ∀ w ∈ X, A.bins s dA (WA w)) (hdB : ∀ w ∈ X, B.bins s dB (WB w)) :
+    TwoSideMean.mean ((A.samples N) ×ˢ (B.samples N)) (count A B X WA WB) ≤
+      (X.card : ℝ)*((A.cost n p R * B.cost n p R) *
+        Real.exp (-(∑ i, (dA i : ℝ))-(∑ i, (dB i : ℝ)))) := by
+  have hn : 0 ≤ n := (Nat.cast_nonneg (Fintype.card A.TV)).trans hA.vertices
+  have hp := hA.nonneg
+  have hcost : 0 ≤ (A.cost n p R * B.cost n p R) *
+      Real.exp (-(∑ i, (dA i : ℝ))-(∑ i, (dB i : ℝ))) := by
+    unfold Side.cost
+    positivity
+  have he := TwoSideMean.global_mean_bound (A.samples N) (B.samples N)
+    (immersedLabels A B X WA WB) (fun w => A.realizations (WA w)) (fun w => B.realizations (WB w))
+    (fun w hw => fixed_mean s hs A n p N D R hA (WA w)
+      (Finset.mem_filter.mp hw).2.1 dA (hdA w (Finset.mem_filter.mp hw).1))
+    (fun w hw => fixed_mean s hs B n p N D R hB (WB w)
+      (Finset.mem_filter.mp hw).2.2 dB (hdB w (Finset.mem_filter.mp hw).1))
+  have eq : (A.cost n p R * Real.exp (-∑ i, (dA i : ℝ))) *
+      (B.cost n p R * Real.exp (-∑ i, (dB i : ℝ))) =
+      (A.cost n p R * B.cost n p R)*
+        Real.exp (-(∑ i, (dA i : ℝ))-(∑ i, (dB i : ℝ))) := by
+    rw [sub_eq_add_neg, Real.exp_add]
+    ring
+  rw [eq] at he
+  exact he.trans (mul_le_mul_of_nonneg_right
+    (Nat.cast_le.mpr (Finset.card_filter_le ..)) hcost)
+
+/-- No entropy factor 2 is introduced when the two sides are combined. -/
+theorem cost_product (A B : Side) (n p : ℝ) (R : ℕ) :
+    A.cost n p R * B.cost n p R =
+      (n^(A.freeMarks+A.internal+B.freeMarks+B.internal) * p^(A.internal+B.internal)) /
+        (R : ℝ)^(A.edges+B.edges) := by
+  simp only [Side.cost, pow_add]
+  ring
+
+end TorsionFreeZeroDivisors.TwoSideStage
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/GroupRing/StageRealization.lean b/lean/OAI/Algebra/GroupRing/StageRealization.lean
new file mode 100644
index 0000000000000000000000000000000000000000..f9867eb6091fb4b9225c3b4e583f89f46045472f
--- /dev/null
+++ b/lean/OAI/Algebra/GroupRing/StageRealization.lean
@@ -0,0 +1,397 @@
+import Mathlib
+import OAI.Algebra.GroupRing.LinkComponents
+import OAI.Algebra.GroupRing.TypeWeights
+
+namespace OAI
+
+noncomputable section
+
+namespace TorsionFreeZeroDivisors.StageRealization
+open scoped Classical
+open PortSubdivision
+/-- Generic table application avoids reducing the concrete projective-plane
+alphabet while composing the elementary cardinality bounds. -/
+theorem allowed_turn_table {PV PD TV T : Type*} [Fintype PD] [Fintype TV]
+    (Γ : PortGraph PV PD) (plabel : PD → T) (outgoing : TV → Finset T)
+    (pin : PV → Option TV) (v : PV) (a b : PD)
+    (ha : Γ.origin a = v) (hb : Γ.origin b = v)
+    (hab : plabel a ≠ plabel b) (f : T → T → ℝ)
+    (htable : ∀ t u, t ≠ u →
+      (Fintype.card {x : TV // t ∈ outgoing x ∧ u ∈ outgoing x} : ℝ) ≤ f t u) :
+    ((allowed Γ plabel outgoing pin v).card : ℝ) ≤ f (plabel a) (plabel b) :=
+  (Nat.cast_le.mpr (allowed_turn_le Γ plabel outgoing pin v a b ha hb)).trans
+    (htable _ _ hab)
+end TorsionFreeZeroDivisors.StageRealization
+
+namespace TorsionFreeZeroDivisors.ChainRealization
+open scoped Classical BigOperators
+open ChainSubdivision TorsionFreeZeroDivisors.Types
+local instance : DecidableEq Types.Letter := Classical.decEq _
+variable {C V : Type*} [Fintype C] [Fintype V]
+variable (len : C → ℕ) (first last : C → V)
+
+/-- A choice of orientation for each actual edge; only this choice, not an
+independent matching event for its reverse, is counted. -/
+def edgePair (e : Edge len) : Sym2 (Dart len) := s((e,false),(e,true))
+
+omit [Fintype C] [Fintype V] in
+theorem edgePair_injective : Function.Injective (edgePair len) := by
+  intro e f h
+  rw [edgePair,edgePair,Sym2.eq_iff] at h
+  rcases h with h | h
+  · exact congrArg Prod.fst h.1
+  · have hh := congrArg Prod.snd h.1
+    cases hh
+
+omit [Fintype V] in
+theorem edges_eq : PatternEmbeddings.edges (graph len first last) =
+    Finset.univ.image (edgePair len) := by
+  ext x
+  simp only [PatternEmbeddings.edges,Finset.mem_image,Finset.mem_univ,true_and]
+  constructor
+  · rintro ⟨⟨e,b⟩,rfl⟩
+    refine ⟨e,?_⟩
+    cases b
+    · rfl
+    · exact Sym2.eq_swap
+  · rintro ⟨e,rfl⟩
+    exact ⟨(e,false),rfl⟩
+
+omit [Fintype V] in
+theorem edges_card : (PatternEmbeddings.edges (graph len first last)).card = ∑ c, len c := by
+  rw [edges_eq,Finset.card_image_of_injective _ (edgePair_injective len),Finset.card_univ,card_edges]
+
+def label (w : C → ℤ → WordEstimate.Letter) (d : Dart len) : Types.Letter :=
+  if d.2 then Types.inverse (signedLetter (w d.1.1 d.1.2.val))
+  else signedLetter (w d.1.1 d.1.2.val)
+
+omit [Fintype C] [Fintype V] in
+@[simp] theorem label_reverse (w : C → ℤ → WordEstimate.Letter) (d : Dart len) :
+    label len w ((graph len first last).reverse d) = Types.inverse (label len w d) := by
+  rcases d with ⟨e,b⟩
+  cases b <;> simp [label,Types.inverse_inverse]
+
+omit [Fintype C] [Fintype V] in
+@[simp] theorem label_back (w : C → ℤ → WordEstimate.Letter) (v : Interior len) :
+    label len w (back len v) = Types.inverse (signedLetter (w v.1 v.2.val)) := rfl
+omit [Fintype C] [Fintype V] in
+@[simp] theorem label_front (w : C → ℤ → WordEstimate.Letter) (v : Interior len) :
+    label len w (front len v) = signedLetter (w v.1 ((v.2.val : ℤ)+1)) := by
+  simp [label,front,Nat.cast_add]
+
+omit [Fintype C] [Fintype V] in
+/-- Literal internal turn weight, not an independent-letter approximation. -/
+theorem internal_weight (w : C → ℤ → WordEstimate.Letter)
+    (himm : Function.Injective (fun d => ((graph len first last).origin d,label len w d)))
+    (v : Interior len) :
+    TypeWeights.jointWeight (label len w (back len v)) (label len w (front len v)) =
+      WordEstimate.weight (w v.1 v.2.val) (w v.1 ((v.2.val : ℤ)+1)) := by
+  have hn : label len w (back len v) ≠ label len w (front len v) := by
+    intro he
+    exact back_ne_front len v (himm (Prod.ext (by simp) he))
+  rw [label_back,label_front] at hn ⊢
+  rw [TypeWeights.jointWeight_signed]
+  unfold WordEstimate.weight
+  split_ifs with he
+  · exfalso
+    apply hn
+    rw [he]
+    rcases w v.1 v.2.val with ⟨g,b⟩
+    exact Types.inverse_signed g b
+  · rfl
+
+def turnProduct (w : C → ℤ → WordEstimate.Letter) : ℝ :=
+  ∏ v : Interior len, WordEstimate.weight (w v.1 v.2.val) (w v.1 ((v.2.val : ℤ)+1))
+
+omit [Fintype V] in
+/-- Exact product of the type-table factors at all unmarked vertices. -/
+theorem internal_product (w : C → ℤ → WordEstimate.Letter)
+    (himm : Function.Injective (fun d => ((graph len first last).origin d,label len w d))) :
+    (∏ v : Interior len,
+      TypeWeights.jointWeight (label len w (back len v)) (label len w (front len v))) =
+      turnProduct len w := by
+  apply Finset.prod_congr rfl
+  intro v _
+  exact internal_weight len first last w himm v
+
+/-- Marked vertices carry the optional prescribed root. Internal vertices
+never gain spurious pins. -/
+def pin {TV : Type*} (p : V → Option TV) : Vertex len (V := V) → Option TV
+  | .inl v => p v
+  | .inr _ => none
+
+omit [Fintype C] [Fintype V] in
+@[simp] theorem pin_internal {TV : Type*} (p : V → Option TV) (v : Interior len) :
+    pin len p (.inr v) = none := rfl
+
+/-- Source vertex-assignment cost, separating the finitely many marked vertices. -/
+def cost {TV : Type*} (pp : V → Option TV) (n p : ℝ)
+    (w : C → ℤ → WordEstimate.Letter) : Vertex len (V := V) → ℝ
+  | .inl v => if pp v = none then n else 1
+  | .inr v => n*p*WordEstimate.weight (w v.1 v.2.val) (w v.1 ((v.2.val : ℤ)+1))
+
+theorem cost_product {TV : Type*} (pp : V → Option TV) (n p : ℝ)
+    (w : C → ℤ → WordEstimate.Letter) :
+    (∏ v, cost len pp n p w v) =
+      n^((Finset.univ.filter fun v => pp v = none).card+∑ c, (len c-1)) *
+        p^(∑ c, (len c-1)) * turnProduct len w := by
+  rw [Fintype.prod_sum_type]
+  simp only [cost,Finset.prod_mul_distrib,Finset.prod_const,Finset.card_univ,
+    card_interiors,Finset.prod_ite,Finset.prod_const,one_pow,mul_one,pow_add,
+    turnProduct]
+  ring
+
+omit [Fintype V] in
+theorem allowed_cost {TV : Type*} [Fintype TV]
+    (outgoing : TV → Finset Types.Letter) (pp : V → Option TV)
+    (n p : ℝ) (w : C → ℤ → WordEstimate.Letter)
+    (himm : Function.Injective (fun d => ((graph len first last).origin d,label len w d)))
+    (hn : (Fintype.card TV : ℝ) ≤ n)
+    (htable : ∀ t u, t ≠ u →
+      (Fintype.card {x : TV // t ∈ outgoing x ∧ u ∈ outgoing x} : ℝ) ≤
+        n*p*TypeWeights.jointWeight t u) :
+    ∀ v, ((StageRealization.allowed (graph len first last) (label len w)
+      outgoing (pin len pp) v).card : ℝ) ≤ cost len pp n p w v := by
+  intro v
+  cases v with
+  | inl v =>
+    dsimp [cost]
+    split_ifs with hp
+    · exact (Nat.cast_le.mpr (StageRealization.allowed_card_le _ _ _ _ _)).trans hn
+    · obtain ⟨x,hx⟩ := Option.ne_none_iff_exists'.mp hp
+      exact_mod_cast StageRealization.pinned_card_le (graph len first last)
+        (label len w) outgoing (pin len pp) (.inl v) x hx
+  | inr v =>
+
+    have hn' : label len w (back len v) ≠ label len w (front len v) := by
+      intro he
+      exact back_ne_front len v (himm (Prod.ext (by simp) he))
+    have h := StageRealization.allowed_turn_table (graph len first last) (label len w)
+      outgoing (pin len pp) (.inr v) (back len v) (front len v)
+      (back_origin len first last v) (front_origin len first last v) hn'
+      (fun t u => n*p*TypeWeights.jointWeight t u) (by
+        intro t u htu
+        simpa only [← Nat.card_eq_fintype_card] using htable t u htu)
+    rwa [internal_weight len first last w himm] at h
+
+/-- Exact finite first moment for an actually subdivided chain pattern. The
+fixed root costs one instead of n; all unmarked vertices use the type table. -/
+theorem fixed_label_bound {TV : Type*} [Fintype TV]
+    (outgoing : TV → Finset Types.Letter) (pp : V → Option TV)
+    (n p : ℝ) (w : C → ℤ → WordEstimate.Letter)
+    (himm : Function.Injective (fun d => ((graph len first last).origin d,label len w d)))
+    (hn : (Fintype.card TV : ℝ) ≤ n)
+    (htable : ∀ t u, t ≠ u →
+      (Fintype.card {x : TV // t ∈ outgoing x ∧ u ∈ outgoing x} : ℝ) ≤
+        n*p*TypeWeights.jointWeight t u)
+    (N d R : ℕ) (h2 : 2 ≤ d) (hR : 0 < R)
+    (hd : ∀ v, Nat.card {e : PatternEmbeddings.Dart outgoing //
+      PatternEmbeddings.origin outgoing e = v} ≤ d)
+    (hsize : ∀ x : PatternEmbeddings.Dart outgoing,
+      R + (∑ c, len c) + 4*d^(2*N+1) ≤
+        Nat.card {e : PatternEmbeddings.Dart outgoing //
+          PatternEmbeddings.label outgoing e = PatternEmbeddings.label outgoing x})
+    (hΩ : (ConditionedMatchings.Matching.conditioned
+      (label := PatternEmbeddings.label outgoing) (bar := Types.inverse)
+      (PatternEmbeddings.origin outgoing) N ∅).Nonempty) :
+    ((∑ r ∈ ConditionedMatchings.Matching.conditioned
+      (label := PatternEmbeddings.label outgoing) (bar := Types.inverse)
+      (PatternEmbeddings.origin outgoing) N ∅,
+        StageRealization.realizations (graph len first last) (label len w) outgoing
+          (pin len pp) Types.inverse r : ℕ) : ℝ) /
+        (ConditionedMatchings.Matching.conditioned
+          (label := PatternEmbeddings.label outgoing) (bar := Types.inverse)
+          (PatternEmbeddings.origin outgoing) N ∅).card ≤
+      (n^((Finset.univ.filter fun v => pp v = none).card+∑ c, (len c-1)) *
+        p^(∑ c, (len c-1)) * turnProduct len w) / (R : ℝ)^(∑ c, len c) := by
+  have h := StageRealization.fixed_label_bound (graph len first last) (label len w)
+    outgoing (pin len pp) Types.inverse Types.inverse_ne himm N d R h2 hR hd
+    (by intro x; rw [edges_card]; exact hsize x) hΩ (cost len pp n p w)
+    (allowed_cost len first last outgoing pp n p w himm hn htable)
+  rwa [cost_product,edges_card] at h
+
+end TorsionFreeZeroDivisors.ChainRealization
+
+namespace TorsionFreeZeroDivisors.ChainWeights
+open scoped Classical BigOperators
+open BlockAlignment ComparedBlocks RepeatedBlocks WordEstimate
+variable {C : Type*} [Fintype C] (s : ℝ) (hs : 0 < s) (len : C → ℕ)
+
+abbrev BlockTurn := (i : Underlying s len) × Fin (height s len i-1)
+
+def firstCoordinate (i : Underlying s len) (k : Fin (height s len i-1)) : block s i.2.val :=
+  (wordCoordinate s len i).symm ⟨k.val,by omega⟩
+def nextCoordinate (i : Underlying s len) (k : Fin (height s len i-1)) : block s i.2.val :=
+  (wordCoordinate s len i).symm ⟨k.val+1,by omega⟩
+
+omit [Fintype C] in
+@[simp] theorem firstCoordinate_val (i : Underlying s len) (k : Fin (height s len i-1)) :
+    (firstCoordinate s len i k).val = (k.val : ℤ)+lower s len i := by
+  have h := wordCoordinate_val s len i (firstCoordinate s len i k)
+  simp only [firstCoordinate,Equiv.apply_symm_apply] at h
+  dsimp only [firstCoordinate]
+  omega
+omit [Fintype C] in
+@[simp] theorem nextCoordinate_val (i : Underlying s len) (k : Fin (height s len i-1)) :
+    (nextCoordinate s len i k).val = (k.val : ℤ)+lower s len i+1 := by
+  have h := wordCoordinate_val s len i (nextCoordinate s len i k)
+  simp only [nextCoordinate,Equiv.apply_symm_apply,Nat.cast_add,Nat.cast_one] at h
+  dsimp only [nextCoordinate]
+  omega
+
+def turnPoint (x : BlockTurn s len) : Position len :=
+  includeBlock s hs len x.1 (firstCoordinate s len x.1 x.2)
+
+def turns : Finset (Position len) := Finset.univ.filter (fun x => x.2.val+1 ∈ positions 0 (len x.1))
+
+theorem turnPoint_mem (x : BlockTurn s len) : turnPoint s hs len x ∈ turns len := by
+  apply Finset.mem_filter.mpr
+  refine ⟨Finset.mem_univ _,?_⟩
+  have ht := full_subset s hs (len x.1.1) x.1.2 (nextCoordinate s len x.1 x.2).property
+  change (firstCoordinate s len x.1 x.2).val+1 ∈ positions 0 (len x.1.1)
+  simpa only [firstCoordinate_val,nextCoordinate_val] using ht
+
+omit [Fintype C] in
+theorem turnPoint_block (x : BlockTurn s len) :
+    turnPoint s hs len x ∈ blockPositions s hs len x.1 := by
+  exact Finset.mem_map.mpr ⟨firstCoordinate s len x.1 x.2,Finset.mem_attach _ _,rfl⟩
+
+omit [Fintype C] in
+/-- Different block turns are different turns of the actual chain subdivision. -/
+theorem turnPoint_injective : Function.Injective (turnPoint s hs len) := by
+  intro x y he
+  have hc : x.1 = y.1 := by
+    by_contra hn
+    exact Finset.disjoint_left.mp (blockPositions_disjoint s hs len hn)
+      (turnPoint_block s hs len x) (he ▸ turnPoint_block s hs len y)
+  rcases x with ⟨i,k⟩
+  rcases y with ⟨i',l⟩
+  dsimp at hc
+  subst i'
+  have hv := congrArg (fun x : Position len => x.2.val) he
+  change (firstCoordinate s len i k).val = (firstCoordinate s len i l).val at hv
+  rw [firstCoordinate_val,firstCoordinate_val] at hv
+  have hk : k = l := Fin.ext (by omega)
+  cases hk
+  rfl
+
+def atTurn (w : C → ℤ → Letter) (x : Position len) : ℝ :=
+  weight (w x.1 x.2.val) (w x.1 (x.2.val+1))
+def chainProduct (w : C → ℤ → Letter) : ℝ := ∏ x ∈ turns len, atTurn len w x
+
+omit [Fintype C] in
+theorem wordWeight_pred (h : ℕ) (W : Fin h → Letter) :
+    wordWeight h W = ∏ k : Fin (h-1), weight (W ⟨k.val,by omega⟩) (W ⟨k.val+1,by omega⟩) := by
+  cases h with
+  | zero => simp [wordWeight]
+  | succ h => exact wordWeight_eq_product h W
+
+theorem turn_product (w : C → ℤ → Letter) :
+    (∏ x : BlockTurn s len, atTurn len w (turnPoint s hs len x)) =
+      ∏ i : Underlying s len, wordWeight (height s len i) (word s len w i) := by
+  rw [Fintype.prod_sigma]
+  apply Finset.prod_congr rfl
+  intro i _
+  rw [wordWeight_pred]
+  apply Finset.prod_congr rfl
+  intro k _
+  change weight (w i.1 (firstCoordinate s len i k).val)
+    (w i.1 ((firstCoordinate s len i k).val+1)) =
+    weight (w i.1 ((k.val : ℤ)+lower s len i))
+      (w i.1 (((k.val+1 : ℕ) : ℤ)+lower s len i))
+  rw [firstCoordinate_val]
+  simp only [Nat.cast_add,Nat.cast_one]
+  congr 2; ring
+
+include hs in
+/-- Discarding only nonnegative factors at most one can increase a chain's
+turn product. This accounts for cross-block turns and all end fragments. -/
+theorem chain_le_blocks (w : C → ℤ → Letter) :
+    chainProduct len w ≤ ∏ i : Underlying s len, wordWeight (height s len i) (word s len w i) := by
+  let S := Finset.univ.image (turnPoint s hs len)
+  have hS : S ⊆ turns len := by
+    intro x hx
+    obtain ⟨y,_,rfl⟩ := Finset.mem_image.mp hx
+    exact turnPoint_mem s hs len y
+  calc
+    chainProduct len w ≤ ∏ x ∈ S, atTurn len w x :=
+      Finset.prod_le_prod_of_subset_of_le_one₀ hS (fun x _ => weight_nonneg _ _)
+        (fun x _ _ => weight_le_one _ _)
+    _ = ∏ x : BlockTurn s len, atTurn len w (turnPoint s hs len x) := by
+      exact Finset.prod_image (fun _ _ _ _ he => turnPoint_injective s hs len he)
+    _ = _ := turn_product s hs len w
+
+/-- A literal bin contributes its upper endpoint to the fixed-label exponent. -/
+theorem bin_weight_upper {h : ℕ} {d : ℤ} {W : Fin h → Letter}
+    (hW : W ∈ binWords h d) : wordWeight h W ≤ Real.exp (-(d : ℝ)) := by
+  obtain ⟨hp,he⟩ := (Finset.mem_filter.mp hW).2
+  have hf := Int.floor_le (-Real.log (wordWeight h W))
+  rw [he] at hf
+  calc
+    wordWeight h W = Real.exp (Real.log (wordWeight h W)) := (Real.exp_log hp).symm
+    _ ≤ _ := Real.exp_le_exp.mpr (by linarith)
+
+include hs in
+/-- Fixed-label loss from all active full blocks. The stage instance is
+obtained by taking C to be the active-chain subtype itself. -/
+theorem chain_bin_bound (w : C → ℤ → Letter) (d : Underlying s len → ℤ)
+    (hbin : ∀ i, word s len w i ∈ binWords (height s len i) (d i)) :
+    chainProduct len w ≤ Real.exp (-∑ i, (d i : ℝ)) := by
+  refine (chain_le_blocks s hs len w).trans ?_
+  calc
+    (∏ i, wordWeight (height s len i) (word s len w i)) ≤ ∏ i, Real.exp (-(d i : ℝ)) :=
+      Finset.prod_le_prod₀ (fun i _ => wordWeight_nonneg _ _) (fun i _ => bin_weight_upper (hbin i))
+    _ = _ := by rw [← Real.exp_sum,Finset.sum_neg_distrib]
+
+omit [Fintype C] in
+theorem mem_positions_nat (n : ℕ) (q : ℤ) :
+    q ∈ positions 0 n ↔ 0 ≤ q ∧ q < n := by
+  have hlo : ⌈(0 : ℝ)-1/2⌉ = (0 : ℤ) := by norm_num
+  have hhi : ⌈(n : ℝ)-1/2⌉ = (n : ℤ) := by
+    apply Int.ceil_eq_iff.mpr
+    push_cast
+    constructor <;> linarith
+  simp only [positions,hlo,hhi,Finset.mem_Ico]
+
+/-- Literal indexing equivalence from internal subdivision vertices to the
+half-integer-grid turn positions. -/
+def turnEquiv : ((c : C) × Fin (len c-1)) ≃ (turns len) where
+  toFun v := ⟨⟨v.1,⟨(v.2.val : ℤ),(mem_positions_nat (len v.1) v.2.val).mpr
+      ⟨by omega,by omega⟩⟩⟩,by
+    apply Finset.mem_filter.mpr
+    exact ⟨Finset.mem_univ _, (mem_positions_nat (len v.1) (v.2.val+1)).mpr
+      ⟨by omega,by omega⟩⟩⟩
+  invFun x := ⟨x.val.1,⟨x.val.2.val.toNat,by
+    have h0 := (mem_positions_nat (len x.val.1) x.val.2.val).mp x.val.2.property
+    have h1 := (mem_positions_nat (len x.val.1) (x.val.2.val+1)).mp
+      (Finset.mem_filter.mp x.property).2
+    omega⟩⟩
+  left_inv v := by
+    rcases v with ⟨c,k⟩
+    apply Sigma.ext rfl
+    apply heq_of_eq
+    apply Fin.ext
+    exact Int.toNat_natCast k.val
+  right_inv x := by
+    rcases x with ⟨⟨c,q,hq⟩,hx⟩
+    apply Subtype.ext
+    dsimp only
+    refine Sigma.ext rfl ?_
+    apply heq_of_eq
+    apply Subtype.ext
+    exact Int.toNat_of_nonneg ((mem_positions_nat _ _).mp hq).1
+
+/-- The full-chain product is exactly the product over the actual internal
+vertices used in the matching first moment. -/
+theorem chainProduct_eq (w : C → ℤ → Letter) :
+    chainProduct len w = ∏ v : ((c : C) × Fin (len c-1)),
+      weight (w v.1 v.2.val) (w v.1 ((v.2.val : ℤ)+1)) := by
+  rw [chainProduct,← Finset.prod_coe_sort]
+  symm
+  exact Fintype.prod_equiv (turnEquiv len) _ _ (fun _ => rfl)
+
+end TorsionFreeZeroDivisors.ChainWeights
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/GroupRing/SupportedImage.lean b/lean/OAI/Algebra/GroupRing/SupportedImage.lean
new file mode 100644
index 0000000000000000000000000000000000000000..79e0a2c248bc81fada2bf2927ea3b95c123fe34e
--- /dev/null
+++ b/lean/OAI/Algebra/GroupRing/SupportedImage.lean
@@ -0,0 +1,387 @@
+import Mathlib
+import OAI.Algebra.GroupRing.TypedDiameter
+
+namespace OAI
+
+noncomputable section
+
+namespace TorsionFreeZeroDivisors.SupportedImage
+open scoped Classical BigOperators
+open PortSubdivision WeightedPortMoore WeightedCycles CoreStripping
+variable {V D : Type} (Γ : PortGraph V D) (Q : Finset D) (hQ : Symmetric Γ Q)
+
+/-- Discard isolated ambient vertices as well as unused darts. -/
+def vertices : Finset V := Q.image Γ.origin
+
+def graph : PortGraph (vertices Γ Q) Q where
+  origin d := ⟨Γ.origin d,Finset.mem_image.mpr ⟨d,d.property,rfl⟩⟩
+  reverse d := ⟨Γ.reverse d,hQ d d.property⟩
+  reverse_reverse d := Subtype.ext (Γ.reverse_reverse d)
+  reverse_ne d h := Γ.reverse_ne d (congrArg Subtype.val h)
+
+lemma no_isolated : Function.Surjective (graph Γ Q hQ).origin := by
+  intro v
+  obtain ⟨d,hd,he⟩ := Finset.mem_image.mp v.property
+  exact ⟨⟨d,hd⟩,Subtype.ext he⟩
+
+/-- Literal inclusion into the actual source graph subdivision. -/
+def inclusion : (graph Γ Q hQ).subdivision →g Γ.subdivision where
+  toFun := Sum.map Subtype.val Subtype.val
+  map_rel' := by
+    intro a b h
+    rcases a with a|a <;> rcases b with b|b
+    · exact h
+    · exact congrArg Subtype.val h
+    · exact congrArg Subtype.val h
+    · exact congrArg Subtype.val h
+lemma inclusion_injective : Function.Injective (inclusion Γ Q hQ) :=
+  Sum.map_injective.mpr ⟨Subtype.val_injective,Subtype.val_injective⟩
+lemma inclusion_weight {a b : (vertices Γ Q) ⊕ Q}
+    (p : (graph Γ Q hQ).subdivision.Walk a b) :
+    weight (edgeWeight (fun _ : D => (1:ℝ))) (p.map (inclusion Γ Q hQ)) =
+      weight (edgeWeight (fun _ : Q => (1:ℝ))) p := by
+  induction p with
+  | nil => rfl
+  | @cons a b c h p ih =>
+    rw [SimpleGraph.Walk.map_cons,weight_cons,weight_cons,ih]
+    congr 1
+    cases a <;> cases b <;> rfl
+
+lemma girth (L : ℝ)
+    (hL : ∀ a (p : Γ.subdivision.Walk a a),p.IsCycle →
+      L≤weight (edgeWeight (fun _ : D => (1:ℝ))) p) :
+    ∀ a (p : (graph Γ Q hQ).subdivision.Walk a a),p.IsCycle →
+      L≤weight (edgeWeight (fun _ : Q => (1:ℝ))) p := by
+  intro a p hp
+  have hm := hp.map (inclusion_injective Γ Q hQ)
+  simpa only [inclusion_weight] using hL _ (p.map (inclusion Γ Q hQ)) hm
+
+variable {P : Type} (paths : P → List D) (hpaths : ∀ p d,d∈paths p → d∈Q)
+def path (p : P) : List Q := (paths p).attach.map (fun d => ⟨d.val,hpaths p d.val d.property⟩)
+lemma path_val (p : P) : (path Q paths hpaths p).map Subtype.val=paths p := by
+  simp only [path,List.map_map,Function.comp_def]
+  simpa only [List.map_id,id_eq] using (List.attach_map_val (f:=id) (l:=paths p))
+lemma length (p : P) : (path Q paths hpaths p).length=(paths p).length := by
+  simp [path]
+lemma nonempty (p : P) (hp : paths p≠[]) : path Q paths hpaths p≠[] := by
+  intro hn
+  apply hp
+  rw [←path_val Q paths hpaths p,hn]
+  rfl
+lemma chain (p : P) (hp : (paths p).IsChain (WeightedMoore.PortWalk.step Γ.origin Γ.reverse)) :
+    (path Q paths hpaths p).IsChain (WeightedMoore.PortWalk.step (graph Γ Q hQ).origin (graph Γ Q hQ).reverse) := by
+  have hh : ((path Q paths hpaths p).map Subtype.val).IsChain
+      (WeightedMoore.PortWalk.step Γ.origin Γ.reverse) := by rw [path_val]; exact hp
+  rw [List.isChain_map] at hh
+  apply hh.imp
+  intro a b hab
+  exact ⟨Subtype.ext hab.1,fun h => hab.2 (congrArg Subtype.val h)⟩
+lemma mem_path (p : P) (d : Q) : d∈path Q paths hpaths p ↔ d.val∈paths p := by
+  rw [←path_val Q paths hpaths p,List.mem_map]
+  constructor
+  · intro hd
+    exact ⟨d,hd,rfl⟩
+  · rintro ⟨e,he,hed⟩
+    exact (Subtype.ext hed : e=d) ▸ he
+lemma head_value (p : P) (hp : paths p≠[]) :
+    ((path Q paths hpaths p).head (nonempty Q paths hpaths p hp)).val=(paths p).head hp := by
+  have hh := congrArg List.head? (path_val Q paths hpaths p)
+  rw [List.head?_map,List.head?_eq_some_head (nonempty Q paths hpaths p hp),
+    List.head?_eq_some_head hp] at hh
+  exact Option.some.inj hh
+lemma cyclic (p : P)
+    (hp : ∀ᵉ (x∈(paths p).getLast?) (y∈(paths p).head?),
+      WeightedMoore.PortWalk.step Γ.origin Γ.reverse x y) :
+    ∀ᵉ (x∈(path Q paths hpaths p).getLast?) (y∈(path Q paths hpaths p).head?),
+      WeightedMoore.PortWalk.step (graph Γ Q hQ).origin (graph Γ Q hQ).reverse x y := by
+  intro x hx y hy
+  have hxv : x.val∈(paths p).getLast? := by
+    rw [←path_val Q paths hpaths p,List.getLast?_map]
+    change ((path Q paths hpaths p).getLast?).map Subtype.val=some x.val
+    rw [show (path Q paths hpaths p).getLast?=some x from hx]
+    rfl
+  have hyv : y.val∈(paths p).head? := by
+    rw [←path_val Q paths hpaths p,List.head?_map]
+    change ((path Q paths hpaths p).head?).map Subtype.val=some y.val
+    rw [show (path Q paths hpaths p).head?=some y from hy]
+    rfl
+  have hh := hp x hxv y hyv
+  exact ⟨Subtype.ext hh.1,fun he => hh.2 (congrArg Subtype.val he)⟩
+lemma covered (hc : ∀ d∈Q,∃ p,d∈paths p ∨ Γ.reverse d∈paths p) :
+    ∀ d : Q,∃ p,d∈path Q paths hpaths p ∨ (graph Γ Q hQ).reverse d∈path Q paths hpaths p := by
+  intro d
+  obtain ⟨p,hp⟩ := hc d d.property
+  refine ⟨p,?_⟩
+  simpa only [mem_path, graph] using hp
+
+/-- The symmetric set of precisely the darts used by the actual paths. -/
+def used [Fintype P] (paths : P → List D) : Finset D :=
+  Finset.univ.biUnion fun p => (paths p).toFinset ∪ (paths p).toFinset.image Γ.reverse
+lemma mem_used [Fintype P] (paths : P → List D) (d : D) :
+    d∈used Γ paths ↔ ∃ p,d∈paths p ∨ Γ.reverse d∈paths p := by
+  simp only [used,Finset.mem_biUnion,Finset.mem_univ,true_and,Finset.mem_union,List.mem_toFinset,Finset.mem_image]
+  apply exists_congr
+  intro p
+  constructor
+  · rintro (h|⟨e,he,hed⟩)
+    · exact Or.inl h
+    · right
+      have heq : e=Γ.reverse d := by simpa using congrArg Γ.reverse hed
+      exact heq ▸ he
+  · rintro (h|h)
+    · exact Or.inl h
+    · exact Or.inr ⟨Γ.reverse d,h,Γ.reverse_reverse d⟩
+lemma used_symmetric [Fintype P] (paths : P → List D) : Symmetric Γ (used Γ paths) := by
+  intro d hd
+  obtain ⟨p,hp⟩ := (mem_used Γ paths d).mp hd
+  apply (mem_used Γ paths (Γ.reverse d)).mpr
+  refine ⟨p,?_⟩
+  simpa only [PortGraph.reverse_reverse_apply] using hp.symm
+lemma path_in_used [Fintype P] (paths : P → List D) (p : P) (d : D) (hd : d∈paths p) :
+    d∈used Γ paths := (mem_used Γ paths d).mpr ⟨p,Or.inl hd⟩
+
+end TorsionFreeZeroDivisors.SupportedImage
+
+namespace TorsionFreeZeroDivisors.RootPins
+open scoped Classical
+lemma pin_map {V W T : Type*} (f : V ↪ W) (r : Option V) (t : T) (v : V) :
+    pin (r.map f) t (f v)=pin r t v := by
+  cases r with
+  | none => simp [pin]
+  | some w => simp [pin,f.injective.eq_iff]
+end TorsionFreeZeroDivisors.RootPins
+
+namespace TorsionFreeZeroDivisors.SupportedImage
+open scoped Classical
+open PortSubdivision
+variable {V D : Type} (Γ : PortGraph V D) (Q : Finset D) (hQ : CoreStripping.Symmetric Γ Q)
+    (side : V → Bool) (hs : ∀ d,side (Γ.origin (Γ.reverse d))=side (Γ.origin d)) (b : Bool)
+def sideVertex : SideRestriction.Vertex (fun v : vertices Γ Q => side v.val) b ↪ SideRestriction.Vertex side b :=
+  ⟨fun v => ⟨v.val.val,v.property⟩,fun _ _ h => Subtype.ext (Subtype.ext (congrArg (fun x => x.val) h))⟩
+def sideDart : SideRestriction.Dart (graph Γ Q hQ) (fun v => side v.val) b ↪ SideRestriction.Dart Γ side b :=
+  ⟨fun d => ⟨d.val.val,d.property⟩,fun _ _ h => Subtype.ext (Subtype.ext (congrArg (fun x => x.val) h))⟩
+lemma side_root (r : Option (vertices Γ Q)) :
+    (SidePins.root (fun v : vertices Γ Q => side v.val) r b).map (sideVertex Γ Q side b)=
+      SidePins.root side (r.map Subtype.val) b := by
+  cases r with
+  | none => rfl
+  | some v =>
+    by_cases hv : side v.val=b
+    · simp only [SidePins.root,Option.map_some,Option.bind_some,hv,dite_eq_left]
+      rfl
+    · simp [SidePins.root,hv]
+
+variable [Fintype V] [Fintype D] {T TV : Type} [Fintype T] [Fintype TV]
+    (label : D → T) (outgoing : TV → Finset T) (bar : T → T)
+    (r : ConditionedMatchings.Matching (PatternEmbeddings.label outgoing) bar)
+    (root : Option (vertices Γ Q)) (target : TV)
+/-- Actual embeddings restrict to the used image, with the exact side/root pin. -/
+def embedding
+    (e : RealizationTransport.Embedding (SideRestriction.graph Γ side hs b) (fun d => label d.val)
+      outgoing (RootPins.pin (SidePins.root side (root.map Subtype.val) b) target) bar r) :
+    RealizationTransport.Embedding
+      (SideRestriction.graph (graph Γ Q hQ) (fun v => side v.val) (fun d => hs d.val) b)
+      (fun d => label d.val.val) outgoing
+      (RootPins.pin (SidePins.root (fun v : vertices Γ Q => side v.val) root b) target) bar r :=
+  RealizationTransport.restrict e _ (sideVertex Γ Q side b) (sideDart Γ Q hQ side b)
+    (fun _ => rfl) (fun _ => rfl) _ (by
+      intro v y hy
+      rw [←side_root Γ Q side b root,RootPins.pin_map]
+      exact hy)
+end TorsionFreeZeroDivisors.SupportedImage
+namespace TorsionFreeZeroDivisors.AmbientPattern
+open scoped Classical BigOperators
+open PortSubdivision ComparedBlocks ComparisonGeometry GirthAsymptotics TypedGraphs ActualPatternEvent
+/-- A path system in an ambient finite graph. The graph need not be the union
+of the paths; taking its literal supported image constructs the raw data. -/
+structure Data (B K I rep : ℕ) where
+  V : Type
+  D : Type
+  P : Type
+  E : Type
+  [fV : Fintype V]
+  [fD : Fintype D]
+  [fP : Fintype P]
+  [fE : Fintype E]
+  graph : PortGraph V D
+  side : V → Bool
+  side_edge : ∀ d,side (graph.origin (graph.reverse d))=side (graph.origin d)
+  paths : P → List D
+  nonempty : ∀ p,paths p≠[]
+  root : Option P
+  path_bound : Fintype.card P≤K
+  comparison_bound : Fintype.card E≤I
+  path_chain : ∀ p,(paths p).IsChain (WeightedMoore.PortWalk.step graph.origin graph.reverse)
+  cyclic_chain : ∀ p,StageRoot.cyclic root p=true →
+    ∀ᵉ (x∈(paths p).getLast?) (y∈(paths p).head?),
+      WeightedMoore.PortWalk.step graph.origin graph.reverse x y
+  girth : ∀ a (c : graph.subdivision.Walk a a),c.IsCycle →
+    (L (size rep):ℝ)≤WeightedCycles.weight (WeightedPortMoore.edgeWeight (fun _ : D => (1:ℝ))) c
+  length_le : (∑p,(paths p).length:ℕ)≤B*L (size rep)
+  length_ge : L (size rep)≤(∑p,(paths p).length:ℕ)
+  comparisons : Comparisons (E:=E) (fun p => (paths p).length)
+  lower : E → ℕ
+  upper : E → ℕ
+  lower_eq : ∀ e,comparisons.lo e=lower e
+  upper_eq : ∀ e,comparisons.hi e=upper e
+  lower_le : ∀ e,lower e≤upper e
+  upper_le : ∀ e,upper e≤(paths (comparisons.source e)).length
+  reduced : ∀ x e,comparisons.side x=some e →
+    RawDecomposition.dart paths x≠RawDecomposition.dart paths (comparisons.pairing.partner x) ∧
+    RawDecomposition.dart paths x≠graph.reverse (RawDecomposition.dart paths (comparisons.pairing.partner x))
+  unpaired_le : ((Finset.univ.filter (fun x => comparisons.pairing.partner x=x)).card:ℝ)≤
+    StageFusion.epsilon (1/600) 256*(∑p,(paths p).length:ℕ)
+attribute [instance] Data.fV Data.fD Data.fP Data.fE
+
+namespace Data
+variable {B K I rep : ℕ} (a : Data B K I rep)
+abbrev used := SupportedImage.used a.graph a.paths
+abbrev symmetric := SupportedImage.used_symmetric a.graph a.paths
+abbrev supportedGraph := SupportedImage.graph a.graph a.used a.symmetric
+abbrev vertices := SupportedImage.vertices a.graph a.used
+abbrev pathUsed := SupportedImage.path_in_used a.graph a.paths
+abbrev supportedPaths := SupportedImage.path a.used a.paths a.pathUsed
+lemma lengths_eq : (fun p => (a.supportedPaths p).length)=(fun p => (a.paths p).length) :=
+  funext (SupportedImage.length a.used a.paths a.pathUsed)
+abbrev comparison := ComparisonGeometry.cast a.lengths_eq.symm a.comparisons
+abbrev iso := ComparisonGeometry.castBackIso a.lengths_eq a.comparisons
+abbrev position : Position (fun p => (a.supportedPaths p).length) ≃ Position (fun p => (a.paths p).length) :=
+  ComparisonGeometry.position a.iso.path a.iso.length_eq
+lemma dart_eq (x : Position (fun p => (a.supportedPaths p).length)) :
+    (RawDecomposition.dart a.supportedPaths x).val=RawDecomposition.dart a.paths (a.position x) := by
+  apply Option.some.inj
+  rw [←Option.map_some (f:=Subtype.val),←RawDecomposition.dart_get,←List.getElem?_map,
+    SupportedImage.path_val,←RawDecomposition.dart_get]
+  rfl
+
+/-- Restrict to actual used darts and their incident vertices. Every original
+length, comparison and counting hypothesis is transported verbatim. -/
+def supported : RawSourcePattern.Data B K I rep where
+  V := a.vertices
+  D := a.used
+  P := a.P
+  E := a.E
+  graph := a.supportedGraph
+  no_isolated := SupportedImage.no_isolated a.graph a.used a.symmetric
+  side := fun v => a.side v.val
+  side_edge d := a.side_edge d.val
+  paths := a.supportedPaths
+  nonempty p := SupportedImage.nonempty a.used a.paths a.pathUsed p (a.nonempty p)
+  root := a.root
+  path_bound := a.path_bound
+  comparison_bound := a.comparison_bound
+  image := SupportedImage.covered a.graph a.used a.symmetric a.paths a.pathUsed
+    (fun d hd => (SupportedImage.mem_used a.graph a.paths d).mp hd)
+  path_chain p := SupportedImage.chain a.graph a.used a.symmetric a.paths a.pathUsed p (a.path_chain p)
+  cyclic_chain p hp := SupportedImage.cyclic a.graph a.used a.symmetric a.paths a.pathUsed p (a.cyclic_chain p hp)
+  girth := SupportedImage.girth a.graph a.used a.symmetric (L (size rep)) a.girth
+  length_le := by simpa only [SupportedImage.length] using a.length_le
+  length_ge := by simpa only [SupportedImage.length] using a.length_ge
+  comparisons := a.comparison
+  lower := a.lower
+  upper := a.upper
+  lower_eq e := (a.iso.lo_eq e).trans (a.lower_eq e)
+  upper_eq e := (a.iso.hi_eq e).trans (a.upper_eq e)
+  lower_le := a.lower_le
+  upper_le e := by
+    rw [SupportedImage.length]
+    have hs : a.comparison.source e=a.comparisons.source e := a.iso.source_eq e
+    rw [hs]
+    exact a.upper_le e
+  reduced := by
+    intro x e he
+    have hh := a.reduced (a.position x) e ((a.iso.side_some x e).mpr he)
+    constructor
+    · intro h
+      apply hh.1
+      have hv := congrArg Subtype.val h
+      rw [a.dart_eq,a.dart_eq,a.iso.partner_eq] at hv
+      exact hv
+    · intro h
+      apply hh.2
+      have hv := congrArg Subtype.val h
+      change (RawDecomposition.dart a.supportedPaths x).val=a.graph.reverse
+        (RawDecomposition.dart a.supportedPaths (a.comparison.pairing.partner x)).val at hv
+      rw [a.dart_eq,a.dart_eq,a.iso.partner_eq] at hv
+      exact hv
+  unpaired_le := by
+    rw [a.iso.unpaired]
+    simpa only [SupportedImage.length] using a.unpaired_le
+abbrev supportedRoot : Option a.vertices := a.root.map fun p =>
+  a.supportedGraph.origin ((a.supportedPaths p).head (a.supported.nonempty p))
+lemma supported_root : a.supportedRoot.map Subtype.val=
+    a.root.map (fun p => a.graph.origin ((a.paths p).head (a.nonempty p))) := by
+  cases h : a.root with
+  | none => simp only [supportedRoot,h,Option.map_none]
+  | some p =>
+    simp only [supportedRoot,h,Option.map_some]
+    change some (a.graph.origin (((a.supportedPaths p).head (a.supported.nonempty p)).val))=_
+    rw [SupportedImage.head_value]
+
+def event (x : Types.VertexA rep) (y : Types.VertexB rep) (r : Match rep) : Prop :=
+  ∃ label : a.D → Types.Letter,
+    (∀ d,label (a.graph.reverse d)=Types.inverse (label d)) ∧
+    (∀ d e,a.graph.origin d=a.graph.origin e → label d=label e → d=e) ∧
+    (∀ p e,a.comparisons.side p=some e → label (RawDecomposition.dart a.paths p)=
+      if a.comparisons.reverse e then Types.inverse (label (RawDecomposition.dart a.paths (a.comparisons.pairing.partner p)))
+      else label (RawDecomposition.dart a.paths (a.comparisons.pairing.partner p))) ∧
+    Nonempty (RealizationTransport.Embedding (SideRestriction.graph a.graph a.side a.side_edge true)
+      (fun d => label d.val) (@Types.outgoingA rep)
+      (RootPins.pin (SidePins.root a.side (a.root.map fun p => a.graph.origin ((a.paths p).head (a.nonempty p))) true) x)
+      Types.inverse r.1) ∧
+    Nonempty (RealizationTransport.Embedding (SideRestriction.graph a.graph a.side a.side_edge false)
+      (fun d => label d.val) (@Types.outgoingB rep)
+      (RootPins.pin (SidePins.root a.side (a.root.map fun p => a.graph.origin ((a.paths p).head (a.nonempty p))) false) y)
+      Types.inverse r.2)
+
+lemma comparing (label : a.D → Types.Letter)
+    (hc : ∀ p e,a.comparisons.side p=some e → label (RawDecomposition.dart a.paths p)=
+      if a.comparisons.reverse e then Types.inverse (label (RawDecomposition.dart a.paths (a.comparisons.pairing.partner p)))
+      else label (RawDecomposition.dart a.paths (a.comparisons.pairing.partner p))) :
+    ∀ (p : Position (fun p => (a.supportedPaths p).length)) (e : a.E),a.comparison.side p=some e →
+      label (RawDecomposition.dart a.supportedPaths p).val=
+      if a.comparison.reverse e then Types.inverse
+        (label (RawDecomposition.dart a.supportedPaths (a.comparison.pairing.partner p)).val)
+      else label (RawDecomposition.dart a.supportedPaths (a.comparison.pairing.partner p)).val := by
+  intro p e he
+  have hh := hc (a.position p) e ((a.iso.side_some p e).mpr he)
+  have hr : a.comparison.reverse e=a.comparisons.reverse e := a.iso.reverse_eq e
+  have hp : a.position (a.comparison.pairing.partner p)=a.comparisons.pairing.partner (a.position p) :=
+    a.iso.partner_eq p
+  simp only [a.dart_eq]
+  rw [hr,hp]
+  exact hh
+
+/-- Restrict the literal realization, including its exact root and labels,
+to the supported raw source pattern. -/
+lemma supported_event (x : Types.VertexA rep) (y : Types.VertexB rep) (r : Match rep)
+    (h : a.event x y r) : a.supported.event x y r := by
+  rcases h with ⟨label,hl,hn,hc,ha,hb⟩
+  refine ⟨(fun d => label d.val),?_,?_,?_,?_,?_⟩
+  · exact fun d => hl d.val
+  · intro d e ho he
+    exact Subtype.ext (hn d.val e.val (congrArg Subtype.val ho) he)
+  · exact a.comparing label hc
+  · refine ⟨SupportedImage.embedding a.graph a.used a.symmetric a.side a.side_edge true label
+      (@Types.outgoingA rep) Types.inverse r.1 a.supportedRoot x ?_⟩
+    simpa only [a.supported_root] using ha.some
+  · refine ⟨SupportedImage.embedding a.graph a.used a.symmetric a.side a.side_edge false label
+      (@Types.outgoingB rep) Types.inverse r.2 a.supportedRoot y ?_⟩
+    simpa only [a.supported_root] using hb.some
+
+end Data
+
+/-- The fixed-sample bounded pattern conclusion applies to every original
+ambient path system, not only to a presupposed image or suppression. -/
+theorem with_diameter (B K I : ℕ) (hK : 0<K) (hI : 0<I) :
+    ∀ᶠ rep in Filter.atTop,∀ (x : Types.VertexA rep) (y : Types.VertexB rep),
+      ∃ r∈samples rep,GraphSample.Diameters rep r ∧ ∀ a : Data B K I rep,¬a.event x y r := by
+  filter_upwards [GraphSample.raw_with_diameter B K I hK hI] with rep hr
+  intro x y
+  obtain ⟨r,hr,hd,ha⟩ := hr x y
+  exact ⟨r,hr,hd,fun a he => ha a.supported (a.supported_event x y r he)⟩
+end TorsionFreeZeroDivisors.AmbientPattern
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/GroupRing/TreeCentroid.lean b/lean/OAI/Algebra/GroupRing/TreeCentroid.lean
new file mode 100644
index 0000000000000000000000000000000000000000..82249951b94a9a9aed49e06b974327132e7d5a25
--- /dev/null
+++ b/lean/OAI/Algebra/GroupRing/TreeCentroid.lean
@@ -0,0 +1,370 @@
+import Mathlib
+import OAI.Algebra.GroupRing.MapEuler
+
+namespace OAI
+
+noncomputable section
+
+namespace TorsionFreeZeroDivisors.TreeCentroid
+open scoped Classical
+open SimpleGraph
+variable {V : Type} [Fintype V] {G : SimpleGraph V} (h : G.IsTree)
+
+omit [Fintype V] in
+lemma next_of_adj {c n : V} (he : G.Adj c n) : next h c n=n := by
+  exact (h.isAcyclic.eq_snd_of_adj_start (path_isPath h c n) he (path h c n).end_mem_support).symm
+
+lemma branch_head {c n : V} (he : G.Adj c n) : n∈branch h c n :=
+  (mem_branch h).mpr ⟨he.ne',next_of_adj h he⟩
+
+/-- A tree branch has exactly one possible directed edge leaving it. -/
+lemma branch_boundary {c n x y : V} (hx : x∈branch h c n) (hy : y∉branch h c n)
+    (he : G.Adj x y) : x=n ∧ y=c := by
+  have hyc : y=c := by
+    by_contra hn
+    exact hy (branch_closed h hx hn he)
+  subst y
+  have hn := (mem_branch h).mp hx
+  have heq := next_of_adj h he.symm
+  exact ⟨heq.symm.trans hn.2,rfl⟩
+
+lemma branch_walk_boundary {c n x y : V} (hx : x∉branch h c n) (hy : y∈branch h c n)
+    (p : G.Walk x y) : n∈p.support := by
+  induction p with
+  | nil => exact (hx hy).elim
+  | @cons x z y e p ih =>
+    by_cases hz : z∈branch h c n
+    · have he := branch_boundary h hz hx e.symm
+      simp only [Walk.support_cons,List.mem_cons]
+      exact Or.inr (he.1 ▸ p.start_mem_support)
+    · simp only [Walk.support_cons,List.mem_cons]
+      exact Or.inr (ih hz hy)
+
+/-- Descendants are defined by the actual branch beyond the parent edge. -/
+def descendants (root v : V) : Finset V := branch h (next h v root) v
+
+lemma root_not_descendants {root v : V} (hv : v≠root) : root∉descendants h root v := by
+  intro hr
+  obtain ⟨hr,hn⟩ := (mem_branch h).mp hr
+  have hd := dist_next h hv
+  have hd' := dist_next h hr.symm
+  rw [hn] at hd'
+  omega
+
+lemma self_mem_descendants {root v : V} (hv : v≠root) : v∈descendants h root v :=
+  branch_head h (next_adj h hv).symm
+
+lemma descendant_mem_root_path {root v w : V} (hv : v≠root) (hw : w∈descendants h root v) :
+    v∈(path h root w).support :=
+  branch_walk_boundary h (root_not_descendants h hv) hw (path h root w)
+
+def rootPath (root v : V) : Finset V := (path h root v).support.toFinset
+omit [Fintype V] in
+lemma root_mem_rootPath (root v : V) : root∈rootPath h root v :=
+  List.mem_toFinset.mpr (path h root v).start_mem_support
+omit [Fintype V] in
+lemma self_mem_rootPath (root v : V) : v∈rootPath h root v :=
+  List.mem_toFinset.mpr (path h root v).end_mem_support
+omit [Fintype V] in
+lemma rootPath_card (root v : V) : (rootPath h root v).card=G.dist root v+1 := by
+  rw [rootPath,List.toFinset_card_of_nodup (path_isPath h root v).support_nodup,
+    Walk.length_support,path_length]
+
+omit [Fintype V] in
+/-- Two root paths share the root, yielding the sharp 2r+1 count rather than
+an erroneous 2r+2 or a three-path 3r+1 bound. -/
+theorem two_root_paths_card (root v w : V) (r : ℕ)
+    (hv : G.dist root v≤r) (hw : G.dist root w≤r) :
+    (rootPath h root v∪rootPath h root w).card≤2*r+1 := by
+  have he := Finset.card_union_add_card_inter (rootPath h root v) (rootPath h root w)
+  have hp : 0<(rootPath h root v∩rootPath h root w).card :=
+    Finset.card_pos.mpr ⟨root,Finset.mem_inter.mpr ⟨root_mem_rootPath h _ _,root_mem_rootPath h _ _⟩⟩
+  rw [rootPath_card,rootPath_card] at he
+  omega
+
+end TorsionFreeZeroDivisors.TreeCentroid
+
+namespace TorsionFreeZeroDivisors.MapEuler
+
+section
+open scoped Classical
+open PermutationCycles
+variable {O : Type} (σ φ γ : Equiv.Perm O) (hγ : Function.Involutive γ)
+
+/-- Dual edges incident to a specified set of primal vertices. -/
+def touchGraph (S : Set (Cycle σ)) : SimpleGraph (Cycle φ) where
+  Adj f g := f≠g ∧ ∃ x,cycle φ x=f ∧ cycle φ (γ x)=g ∧
+    (cycle σ x∈S ∨ cycle σ (γ x)∈S)
+  symm := ⟨by
+    rintro f g ⟨hne,x,hx,hy,hS⟩
+    refine ⟨hne.symm,γ x,hy,?_,?_⟩
+    · rwa [hγ]
+    · rw [hγ]
+      exact hS.symm⟩
+  loopless := ⟨fun _ h=>h.1 rfl⟩
+
+lemma touchGraph_le (S : Set (Cycle σ)) : touchGraph σ φ γ hγ S≤graph φ γ hγ := by
+  rintro f g ⟨hne,x,hx,hy,_⟩
+  exact ⟨hne,x,hx,hy⟩
+
+lemma touchGraph_contour_step (θ : Equiv.Perm O) (hθ : γ*θ=φ)
+    (S : Set (Cycle σ)) (x : O) (hx : cycle σ (θ x)∈S) :
+    (touchGraph σ φ γ hγ S).Reachable (cycle φ x) (cycle φ (θ x)) := by
+  by_cases he : cycle φ x=cycle φ (θ x)
+  · rw [he]
+  · have hp : γ (θ x)=φ x := congrArg (fun f : Equiv.Perm O=>f x) hθ
+    apply SimpleGraph.Reachable.symm
+    apply SimpleGraph.Adj.reachable
+    exact ⟨Ne.symm he,θ x,rfl,by rw [hp,cycle_apply],Or.inl hx⟩
+
+variable [Fintype O]
+/-- A subtree interval in the primal contour gives actual connectivity through
+only those dual edges incident to the subtree. -/
+theorem touchGraph_connected_of_contour (θ : Equiv.Perm O) (hθ : γ*θ=φ)
+    (hc : Nat.card (Cycle θ)=1) (S : Set (Cycle σ)) (p : O)
+    (hout : ∀ x,cycle σ x∈S → cycle σ (θ x)∉S → x=p)
+    {x y : O} (hx : cycle σ x∈S) (hy : cycle σ y∈S) :
+    (touchGraph σ φ γ hγ S).Reachable (cycle φ x) (cycle φ y) := by
+  have hh (z : O) (hz : cycle σ z∈S) := contour_interval_reachable θ
+    (sameCycle_of_card_one θ hc) {x | cycle σ x∈S} p hout
+    (touchGraph σ φ γ hγ S) (cycle φ)
+    (fun x _ h=>touchGraph_contour_step σ φ γ hγ θ hθ S x h) z hz
+  exact (hh x hx).symm.trans (hh y hy)
+
+end
+
+section
+open scoped Classical
+open PermutationCycles
+variable {O : Type} [Fintype O] (σ α : Equiv.Perm O) (ha : Function.Involutive α)
+    (T : SimpleGraph (Cycle σ)) (hT : T≤graph σ α ha) (ht : T.IsTree)
+
+/-- Every rooted tree branch has a unique possible exit in the actual contour. -/
+theorem branch_contour_exit {c n : Cycle σ} (he : T.Adj n c) :
+    ∃ p : O,∀ x,cycle σ x∈TreeCentroid.branch ht c n →
+      cycle σ ((subgraphPair σ α ha T hT*σ) x)∉TreeCentroid.branch ht c n → x=p := by
+  have he' : (graph σ (subgraphPair σ α ha T hT)
+      (subgraphPair_involutive σ α ha T hT)).Adj n c := by
+    rwa [subgraphPair_graph]
+  obtain ⟨hne,p,hp,hq⟩ := he'
+  have hpn : subgraphPair σ α ha T hT p≠p := fun h=>hne (hp.symm.trans (h ▸ hq))
+  refine ⟨σ.symm p,fun x hx hy=>?_⟩
+  have hx' : cycle σ (σ x)∈TreeCentroid.branch ht c n := by rwa [cycle_apply]
+  have hxn : subgraphPair σ α ha T hT (σ x)≠σ x := by
+    intro h
+    exact hy (h.symm ▸ hx')
+  have hb := TreeCentroid.branch_boundary ht hx' hy
+    (subgraphPair_adj σ α ha T hT hxn)
+  have heq := subgraphPair_dart_unique σ α ha T hT hxn hpn
+    (hb.1.trans hp.symm) (hb.2.trans hq.symm)
+  exact σ.injective (heq.trans (σ.apply_symm_apply p).symm)
+
+/-- Literal face connectivity around a primal tree branch in a genus-zero
+map, using only cotree edges touching that branch. -/
+theorem branch_dual_touch_connected (hz : GenusZero σ α) {c n : Cycle σ}
+    (he : T.Adj n c) {x y : O}
+    (hx : cycle σ x∈TreeCentroid.branch ht c n)
+    (hy : cycle σ y∈TreeCentroid.branch ht c n) :
+    (touchGraph σ (α*σ) (α*subgraphPair σ α ha T hT)
+      (complement_involutive α _ ha (subgraphPair_involutive σ α ha T hT)
+        (subgraphPair_subpairing σ α ha T hT))
+      (↑(TreeCentroid.branch ht c n) : Set (Cycle σ))).Reachable
+      (cycle (α*σ) x) (cycle (α*σ) y) := by
+  obtain ⟨p,hp⟩ := branch_contour_exit σ α ha T hT ht he
+  apply touchGraph_connected_of_contour σ (α*σ) (α*subgraphPair σ α ha T hT) _
+    (subgraphPair σ α ha T hT*σ) _ (tree_contour_card σ α ha T hT hz ht) _ p hp hx hy
+  ext z
+  change α (subgraphPair σ α ha T hT (subgraphPair σ α ha T hT (σ z)))=α (σ z)
+  rw [subgraphPair_involutive σ α ha T hT]
+
+end
+
+open scoped Classical
+open PermutationCycles
+variable {O : Type} [Fintype O] (σ α : Equiv.Perm O) (ha : Function.Involutive α)
+
+def supportedRealize (d : (graph σ α ha).Dart) : {x // x∈α.support} :=
+  ⟨realizeDart σ α ha d,realizeDart_mem σ α ha d⟩
+lemma supportedRealize_injective : Function.Injective (supportedRealize σ α ha) :=
+  fun _ _ h=>realizeDart_injective σ α ha (congrArg Subtype.val h)
+
+lemma supportedRealize_surjective (he : 2*Nat.card (graph σ α ha).edgeSet=α.support.card) :
+    Function.Surjective (supportedRealize σ α ha) := by
+  apply ((Fintype.bijective_iff_injective_and_card (supportedRealize σ α ha)).mpr
+    ⟨supportedRealize_injective σ α ha,?_⟩).surjective
+  rw [Fintype.card_coe,SimpleGraph.dart_card_eq_twice_card_edges,
+    SimpleGraph.edgeFinset_card,←Nat.card_eq_fintype_card]
+  exact he
+
+/-- When there are as many support darts as graph darts, no nonfixed dart is a
+loop and no two different paired edges can realize the same simple edge. -/
+lemma nonfixed_adj_of_edge_count
+    (he : 2*Nat.card (graph σ α ha).edgeSet=α.support.card) {x : O} (hx : α x≠x) :
+    (graph σ α ha).Adj (cycle σ x) (cycle σ (α x)) := by
+  obtain ⟨d,hd⟩ := supportedRealize_surjective σ α ha he ⟨x,Equiv.Perm.mem_support.mpr hx⟩
+  have hh : realizeDart σ α ha d=x := congrArg Subtype.val hd
+  rw [←hh,realizeDart_fst,realizeDart_snd]
+  exact d.adj
+
+lemma dart_unique_of_edge_count (he : 2*Nat.card (graph σ α ha).edgeSet=α.support.card)
+    {x y : O} (hx : α x≠x) (hy : α y≠y)
+    (h₁ : cycle σ x=cycle σ y) (h₂ : cycle σ (α x)=cycle σ (α y)) : x=y := by
+  obtain ⟨d,hd⟩ := supportedRealize_surjective σ α ha he ⟨x,Equiv.Perm.mem_support.mpr hx⟩
+  obtain ⟨e,he'⟩ := supportedRealize_surjective σ α ha he ⟨y,Equiv.Perm.mem_support.mpr hy⟩
+  have hh : realizeDart σ α ha d=x := congrArg Subtype.val hd
+  have hq : realizeDart σ α ha e=y := congrArg Subtype.val he'
+  have hde : d=e := by
+    apply SimpleGraph.Dart.ext
+    apply Prod.ext
+    · rw [←realizeDart_fst σ α ha d,←realizeDart_fst σ α ha e,hh,hq]
+      exact h₁
+    · rw [←realizeDart_snd σ α ha d,←realizeDart_snd σ α ha e,hh,hq]
+      exact h₂
+  exact hh.symm.trans ((congrArg (realizeDart σ α ha) hde).trans hq)
+
+lemma edge_count_of_tree_support (ht : (graph σ α ha).IsTree)
+    (hs : α.support.card+2=2*Nat.card (Cycle σ)) :
+    2*Nat.card (graph σ α ha).edgeSet=α.support.card := by
+  have he := (SimpleGraph.isTree_iff_connected_and_card.mp ht).2
+  omega
+
+end TorsionFreeZeroDivisors.MapEuler
+
+namespace TorsionFreeZeroDivisors.TreeCentroid
+open scoped Classical
+open SimpleGraph
+variable {V : Type} [Fintype V] {T : SimpleGraph V} (ht : T.IsTree)
+    (H : SimpleGraph V) (hH : H≤T) (c n : V) (hn : ¬H.Adj c n)
+
+include hH hn in
+lemma branch_mem_iff_adj_of_avoid {x y : V} (he : H.Adj x y) :
+    x∈branch ht c n ↔ y∈branch ht c n := by
+  constructor
+  · intro hx
+    by_contra hy
+    obtain ⟨rfl,rfl⟩ := branch_boundary ht hx hy (hH he)
+    exact hn he.symm
+  · intro hy
+    by_contra hx
+    obtain ⟨rfl,rfl⟩ := branch_boundary ht hy hx (hH he.symm)
+    exact hn he
+
+include hH hn in
+lemma branch_mem_iff_reachable_of_avoid {x y : V} (hr : H.Reachable x y) :
+    x∈branch ht c n ↔ y∈branch ht c n := by
+  obtain ⟨p⟩ := hr
+  induction p with
+  | nil => rfl
+  | cons e p ih => exact (branch_mem_iff_adj_of_avoid ht H hH c n hn e).trans ih
+
+end TorsionFreeZeroDivisors.TreeCentroid
+
+namespace TorsionFreeZeroDivisors.MapEuler
+open scoped Classical
+open PermutationCycles
+variable {O : Type} [Fintype O]
+
+lemma touchGraph_avoids_edge (σ φ γ : Equiv.Perm O) (hγ : Function.Involutive γ)
+    (he : 2*Nat.card (graph φ γ hγ).edgeSet=γ.support.card)
+    (S : Set (Cycle σ)) (d : O)
+    (hd : cycle σ d∉S) (hd' : cycle σ (γ d)∉S) :
+    ¬(touchGraph σ φ γ hγ S).Adj (cycle φ d) (cycle φ (γ d)) := by
+  rintro ⟨hne,x,hx,hy,hS⟩
+  have hdn : γ d≠d := fun h=>hne (by rw [h])
+  have hxn : γ x≠x := fun h=>hne (hx.symm.trans (by rwa [h] at hy))
+  have hxd := dart_unique_of_edge_count φ γ hγ he hxn hdn hx hy
+  subst x
+  exact hS.elim hd hd'
+
+variable (σ α : Equiv.Perm O) (ha : Function.Involutive α)
+    (T : SimpleGraph (Cycle σ)) (hT : T≤graph σ α ha)
+    (hz : GenusZero σ α) (ht : T.IsTree)
+local notation "β" => subgraphPair σ α ha T hT
+local notation "γ" => α*β
+local notation "φ" => α*σ
+local notation "hγ" => complement_involutive α β ha (subgraphPair_involutive σ α ha T hT)
+  (subgraphPair_subpairing σ α ha T hT)
+local notation "D" => graph φ γ hγ
+local notation "htD" => spanning_cotree_isTree σ α ha T hT hz ht
+
+def cotreeSide (d : O) : Finset (Cycle φ) :=
+  TreeCentroid.branch htD (cycle φ d) (cycle φ (γ d))
+
+def fundamentalVertices (root : Cycle σ) (d : O) : Finset (Cycle σ) :=
+  TreeCentroid.rootPath ht root (cycle σ d) ∪ TreeCentroid.rootPath ht root (cycle σ (α d))
+
+omit [Fintype O] in
+lemma root_mem_fundamentalVertices (root : Cycle σ) (d : O) :
+    root∈fundamentalVertices σ α T ht root d :=
+  Finset.mem_union_left _ (TreeCentroid.root_mem_rootPath ht _ _)
+
+lemma endpoints_not_descendants {root v : Cycle σ} {d : O}
+    (hv : v∉fundamentalVertices σ α T ht root d) :
+    cycle σ d∉TreeCentroid.descendants ht root v ∧
+    cycle σ (γ d)∉TreeCentroid.descendants ht root v := by
+  have hvr : v≠root := fun he=>hv (he ▸ root_mem_fundamentalVertices σ α T ht root d)
+  have h₁ : cycle σ d∉TreeCentroid.descendants ht root v := by
+    intro h
+    apply hv
+    apply Finset.mem_union_left
+    simpa only [TreeCentroid.rootPath,List.mem_toFinset] using
+      (TreeCentroid.descendant_mem_root_path ht hvr h)
+  have h₂ : cycle σ (α d)∉TreeCentroid.descendants ht root v := by
+    intro h
+    apply hv
+    apply Finset.mem_union_right
+    simpa only [TreeCentroid.rootPath,List.mem_toFinset] using
+      (TreeCentroid.descendant_mem_root_path ht hvr h)
+  refine ⟨h₁,?_⟩
+  rcases complement_subpairing α β ha (subgraphPair_subpairing σ α ha T hT) d with h|h
+  · rwa [h]
+  · rwa [h]
+
+/-- Outside the two actual root paths, all incident faces of a primal vertex
+lie on the same side of the deleted cotree edge. -/
+theorem outside_fundamental_sameSide {root v : Cycle σ} {d x y : O}
+    (hv : v∉fundamentalVertices σ α T ht root d)
+    (hx : cycle σ x=v) (hy : cycle σ y=v) :
+    cycle φ x∈cotreeSide σ α ha T hT hz ht d ↔
+    cycle φ y∈cotreeSide σ α ha T hT hz ht d := by
+  have hvr : v≠root := fun he=>hv (he ▸ root_mem_fundamentalVertices σ α T ht root d)
+  let S : Set (Cycle σ) := ↑(TreeCentroid.descendants ht root v)
+  have hs : v∈S := TreeCentroid.self_mem_descendants ht hvr
+  have hh := branch_dual_touch_connected σ α ha T hT ht hz
+    (TreeCentroid.next_adj ht hvr) (hx ▸ hs) (hy ▸ hs)
+  have he := edge_count_of_tree_support φ γ hγ htD (cotree_support σ α ha T hT hz ht)
+  obtain ⟨hd,hd'⟩ := endpoints_not_descendants σ α ha T hT ht hv
+  exact TreeCentroid.branch_mem_iff_reachable_of_avoid htD
+    (touchGraph σ φ γ hγ S) (touchGraph_le σ φ γ hγ S)
+    (cycle φ d) (cycle φ (γ d))
+    (touchGraph_avoids_edge σ φ γ hγ he S d hd hd') hh
+
+omit [Fintype O] in
+/-- Endpoints of a primal edge have incident occurrences on a common face. -/
+lemma edge_common_face (x : O) : cycle φ (σ.symm x)=cycle φ (α x) := by
+  have hf := cycle_apply φ (σ.symm x)
+  simpa only [Equiv.Perm.mul_apply,Equiv.apply_symm_apply] using hf.symm
+
+/-- The two-root-path vertex set really separates the corresponding dual sides,
+including original loops, parallel edges, and tree edges. -/
+theorem fundamental_no_crossing {root : Cycle σ} {d : O} {v w : Cycle σ}
+    (hv : v∉fundamentalVertices σ α T ht root d)
+    (hw : w∉fundamentalVertices σ α T ht root d)
+    (he : (graph σ α ha).Adj v w) {x y : O}
+    (hx : cycle σ x=v) (hy : cycle σ y=w) :
+    cycle φ x∈cotreeSide σ α ha T hT hz ht d ↔
+    cycle φ y∈cotreeSide σ α ha T hT hz ht d := by
+  obtain ⟨_,z,hzv,hzw⟩ := he
+  have hzv' : cycle σ (σ.symm z)=v := by
+    rw [←cycle_apply σ (σ.symm z),σ.apply_symm_apply]
+    exact hzv
+  have h₁ := outside_fundamental_sameSide σ α ha T hT hz ht hv hx hzv'
+  have h₂ := outside_fundamental_sameSide σ α ha T hT hz ht hw hzw hy
+  rw [edge_common_face σ α z] at h₁
+  exact h₁.trans h₂
+
+end TorsionFreeZeroDivisors.MapEuler
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/GroupRing/TwoSideFullStage.lean b/lean/OAI/Algebra/GroupRing/TwoSideFullStage.lean
new file mode 100644
index 0000000000000000000000000000000000000000..e7ddca924d063c8e9d8094d0b0ce99205ef0c138
--- /dev/null
+++ b/lean/OAI/Algebra/GroupRing/TwoSideFullStage.lean
@@ -0,0 +1,414 @@
+import Mathlib
+import OAI.Algebra.GroupRing.StageExpectation
+
+namespace OAI
+
+noncomputable section
+
+namespace TorsionFreeZeroDivisors.TwoSideFullStage
+open scoped Classical BigOperators
+open RepeatedBlocks BlockAlignment ComparedBlocks ChainStageLabels WordEstimate
+local instance : DecidableEq Types.Letter := Classical.decEq _
+variable {A B E VA VB TA TB : Type} [Fintype A] [Fintype B] [Fintype VA] [Fintype VB]
+  [Fintype TA] [Fintype TB]
+variable (s : ℝ) (hs : 0<s) (len m : A ⊕ B → ℕ) (j : ℕ)
+
+abbrev CA := {a : A // j < m (.inl a)}
+abbrev CB := {b : B // j < m (.inr b)}
+abbrev lenA : CA m j → ℕ := fun a => len (.inl a.val)
+abbrev lenB : CB m j → ℕ := fun b => len (.inr b.val)
+
+def restrictA (F : StagePosition len m j → Letter) : Position (lenA len m j) → Letter :=
+  fun x => F ⟨⟨.inl x.1.val,x.1.property⟩,x.2⟩
+def restrictB (F : StagePosition len m j → Letter) : Position (lenB len m j) → Letter :=
+  fun x => F ⟨⟨.inr x.1.val,x.1.property⟩,x.2⟩
+
+def indexA (i : Underlying s (lenA len m j)) : Underlying s len := ⟨.inl i.1.val,i.2⟩
+def indexB (i : Underlying s (lenB len m j)) : Underlying s len := ⟨.inr i.1.val,i.2⟩
+
+include hs in
+theorem binsA (cmp : Comparisons (E := E) (traversalLength len m))
+    (d : Underlying s len → ℤ) (F : StagePosition len m j → Letter)
+    (hF : F ∈ fullWords s len m j cmp d) :
+    ∀ i, word s (lenA len m j) (StageExpectation.readWord (lenA len m j)
+      (restrictA len m j F)) i ∈ binWords (height s (lenA len m j) i) (d (indexA s len m j i)) := by
+  obtain ⟨w,_,_,hb,rfl⟩ := (Finset.mem_filter.mp hF).2
+  intro i
+  have he : word s (lenA len m j) (StageExpectation.readWord (lenA len m j)
+      (restrictA len m j (fun x => w x.1.val x.2.val))) i =
+      word s len w (indexA s len m j i) := by
+    funext k
+    dsimp only [word,StageExpectation.readWord]
+    rw [dite_eq_left (StageExpectation.word_position s hs (lenA len m j) i k)]
+    rfl
+  rw [he]
+  exact hb (indexA s len m j i)
+
+include hs in
+theorem binsB (cmp : Comparisons (E := E) (traversalLength len m))
+    (d : Underlying s len → ℤ) (F : StagePosition len m j → Letter)
+    (hF : F ∈ fullWords s len m j cmp d) :
+    ∀ i, word s (lenB len m j) (StageExpectation.readWord (lenB len m j)
+      (restrictB len m j F)) i ∈ binWords (height s (lenB len m j) i) (d (indexB s len m j i)) := by
+  obtain ⟨w,_,_,hb,rfl⟩ := (Finset.mem_filter.mp hF).2
+  intro i
+  have he : word s (lenB len m j) (StageExpectation.readWord (lenB len m j)
+      (restrictB len m j (fun x => w x.1.val x.2.val))) i =
+      word s len w (indexB s len m j i) := by
+    funext k
+    dsimp only [word,StageExpectation.readWord]
+    rw [dite_eq_left (StageExpectation.word_position s hs (lenB len m j) i k)]
+    rfl
+  rw [he]
+  exact hb (indexB s len m j i)
+
+def joinBlock : Underlying s (lenA len m j) ⊕ Underlying s (lenB len m j) →
+    Underlying s (StageExpectation.activeLen len m j)
+  | .inl i => ⟨⟨.inl i.1.val,i.1.property⟩,i.2⟩
+  | .inr i => ⟨⟨.inr i.1.val,i.1.property⟩,i.2⟩
+
+omit [Fintype A] [Fintype B] in
+theorem joinBlock_bijective : Function.Bijective (joinBlock s len m j) := by
+  constructor
+  · intro x y he
+    cases x with
+    | inl x =>
+      cases y with
+      | inl y =>
+        rcases x with ⟨⟨a,ha⟩,ix⟩
+        rcases y with ⟨⟨b,hb⟩,iy⟩
+        have hab : a=b := Sum.inl.inj (congrArg (fun z => z.1.val) he)
+        subst b
+        have hii : ix=iy := Fin.ext (congrArg (fun z => z.2.val) he)
+        subst iy
+        rfl
+      | inr y => have h := congrArg (fun z => z.1.val) he; cases h
+    | inr x =>
+      cases y with
+      | inl y => have h := congrArg (fun z => z.1.val) he; cases h
+      | inr y =>
+        rcases x with ⟨⟨a,ha⟩,ix⟩
+        rcases y with ⟨⟨b,hb⟩,iy⟩
+        have hab : a=b := Sum.inr.inj (congrArg (fun z => z.1.val) he)
+        subst b
+        have hii : ix=iy := Fin.ext (congrArg (fun z => z.2.val) he)
+        subst iy
+        rfl
+  · rintro ⟨⟨c,hc⟩,b⟩
+    cases c with
+    | inl a => exact ⟨.inl ⟨⟨a,hc⟩,b⟩,rfl⟩
+    | inr b' => exact ⟨.inr ⟨⟨b',hc⟩,b⟩,rfl⟩
+
+def blockEquiv := Equiv.ofBijective (joinBlock s len m j) (joinBlock_bijective s len m j)
+
+theorem bin_sum (d : Underlying s len → ℤ) :
+    (∑ i, (d (indexA s len m j i) : ℝ)) + (∑ i, (d (indexB s len m j i) : ℝ)) =
+      ∑ i ∈ activeBlocks s len m j, (d i : ℝ) := by
+  rw [← StageExpectation.active_bin_sum s len m j d]
+  calc
+    _ = ∑ i : Underlying s (lenA len m j) ⊕ Underlying s (lenB len m j),
+        (d (StageExpectation.activeIndex s len m j (joinBlock s len m j i)) : ℝ) := by
+      rw [Fintype.sum_sum_type]
+      rfl
+    _ = _ := Fintype.sum_equiv (blockEquiv s len m j) _ _ (fun _ => rfl)
+
+variable (firstA lastA : CA m j → VA) (firstB lastB : CB m j → VB)
+  (outA : TA → Finset Types.Letter) (outB : TB → Finset Types.Letter)
+  (pinA : VA → Option TA) (pinB : VB → Option TB)
+
+def sideA : TwoSideStage.Side where
+  C := CA m j; V := VA; TV := TA
+  fC := inferInstance; fV := inferInstance; fTV := inferInstance
+  len := lenA len m j
+  first := firstA; last := lastA; outgoing := outA; pin := pinA
+
+def sideB : TwoSideStage.Side where
+  C := CB m j; V := VB; TV := TB
+  fC := inferInstance; fV := inferInstance; fTV := inferInstance
+  len := lenB len m j
+  first := firstB; last := lastB; outgoing := outB; pin := pinB
+
+local notation "SA" => sideA len m j firstA lastA outA pinA
+local notation "SB" => sideB len m j firstB lastB outB pinB
+
+theorem exponential_fusion (u v k x y z : ℝ) (hz : x+y=z) :
+    Real.exp (u+v)*(k*Real.exp (-x-y)) = k*Real.exp (u-z+v) := by
+  rw [← hz]
+  simp only [sub_eq_add_neg,Real.exp_add,Real.exp_neg]
+  ring
+
+include hs in
+/-- The joint matching expectation applied to the actual fullWords projection,
+including cross-side comparisons. All entropy and bin costs are computed on
+that one global pattern. -/
+theorem mean_bound (cmp : Comparisons (E := E) (traversalLength len m))
+    (d : Underlying s len → ℤ) (err : ℕ)
+    (hlarge : ∀ i, 3002 ≤ height s len i)
+    (hscale : ∀ i, s+1200 ≤ 2*(height s len i : ℝ))
+    (hreduced : ∀ x e, cmp.side x = some e →
+      (x.1.1,x.2.val) ≠ ((cmp.pairing.partner x).1.1,(cmp.pairing.partner x).2.val))
+    (n p : ℝ) (N D R : ℕ) (hA : TwoSideStage.Conditions SA n p N D R)
+    (hB : TwoSideStage.Conditions SB n p N D R) :
+    TwoSideMean.mean (((SA).samples N) ×ˢ ((SB).samples N))
+      (TwoSideStage.count SA SB (fullWords s len m j cmp d)
+        (restrictA len m j) (restrictB len m j)) ≤
+      ((SA).cost n p R * (SB).cost n p R) *
+        Real.exp ((∑ c : StageLabels.activeComponents
+          (ActualStageLabels.L s hs len m cmp err).graph.connectedComponentMk (activeBlocks s len m j),
+          ActualStageLabels.cost s hs len m cmp err d c.val) -
+          (∑ i ∈ activeBlocks s len m j, (d i : ℝ)) +
+          (2*(err : ℝ)*Fintype.card (Underlying s len)+(s+1)*Fintype.card (A ⊕ B))*
+            Real.log (Fintype.card Letter)) := by
+  have h := TwoSideStage.mean_bound s hs SA SB (fullWords s len m j cmp d)
+    (restrictA len m j) (restrictB len m j) n p N D R hA hB
+    (fun i => d (indexA s len m j i)) (fun i => d (indexB s len m j i))
+    (binsA s hs len m j cmp d) (binsB s hs len m j cmp d)
+  have hc := full_stage_count s hs len m j cmp d err hlarge hscale hreduced
+  have hn : 0 ≤ n := (Nat.cast_nonneg (Fintype.card TA)).trans hA.vertices
+  have hp := hA.nonneg
+  have hcost : 0 ≤ (SA).cost n p R * (SB).cost n p R := by unfold TwoSideStage.Side.cost; positivity
+  have h' := h.trans (mul_le_mul_of_nonneg_right hc
+    (mul_nonneg hcost (Real.exp_pos _).le))
+  exact h'.trans_eq (exponential_fusion _ _ _ _ _ _ (bin_sum s len m j d))
+
+end TorsionFreeZeroDivisors.TwoSideFullStage
+
+namespace TorsionFreeZeroDivisors.MatchingGraphs
+open PortSubdivision BallCount GirthSwitch
+variable {V D T : Type*} [Fintype V] [Fintype D] [DecidableEq D]
+
+/-- Nonemptiness of the exact typed matching family conditioned on girth.
+The numerical hypothesis is an explicit finite-size bound, not a new standing
+hypothesis for the main existential theorem. -/
+theorem exists_typed_large_girth (origin : D → V) (label : D → T) (bar : T → T)
+    (Γ₀ : PortGraph V D) (ho : Γ₀.origin = origin)
+    (hlabel : ∀ f, label (Γ₀.reverse f) = bar (label f))
+    (d N : ℕ) (h2 : 2 ≤ d)
+    (hd : ∀ v, Nat.card {e : D // origin e = v} ≤ d)
+    (hbig : ∀ x, 4*d^(2*N+1) < Nat.card {e : D // label e = label x}) :
+    ∃ Γ : PortGraph V D, Γ.origin = origin ∧
+      (∀ f, label (Γ.reverse f) = bar (label f)) ∧
+      (N : ℕ∞) ≤ Γ.subdivision.egirth := by
+  classical
+  let P : SimpleGraph (V ⊕ D) → Prop := fun G =>
+    ∃ Γ : PortGraph V D, Γ.origin = origin ∧
+      (∀ f, label (Γ.reverse f) = bar (label f)) ∧ G = Γ.subdivision
+  have hne : ∃ G, P G := ⟨Γ₀.subdivision,Γ₀,ho,hlabel,rfl⟩
+  have hsw : ∀ G, P G → ∀ a (p : G.Walk a a), p.IsCycle →
+      ∃ x y u z, s(x,y) ∈ p.edges ∧ G.Adj u z ∧
+        (∀ a ∈ ({x,y} : Set (V ⊕ D)), ∀ b ∈ ({u,z} : Set (V ⊕ D)),
+          ∀ p : G.Walk a b, 2*N < p.length) ∧
+        P (addEdge (addEdge (G.deleteEdges {s(x,y),s(u,z)}) x z) u y) := by
+    rintro G ⟨Γ,hΓo,hΓl,rfl⟩ a p hp
+    obtain ⟨x,hx⟩ := Γ.cycle_has_middle p hp
+    have hd' : ∀ v, Nat.card {e : D // Γ.origin e = v} ≤ d := by rw [hΓo]; exact hd
+    obtain ⟨e,hel,hfar⟩ := exists_far_port Γ label d (2*N) h2 hd' x (hbig x)
+    have hxe : x ≠ e := by
+      intro h
+      have hf := hfar (.inr x) (by simp) (.inr e) (by simp)
+      subst e
+      have hh := hf SimpleGraph.Walk.nil
+      simp at hh
+    have hxr : x ≠ Γ.reverse e := by
+      intro h
+      have hf := hfar (.inr x) (by simp) (.inr (Γ.reverse e)) (by simp)
+      rw [h] at hf
+      have hh := hf SimpleGraph.Walk.nil
+      simp at hh
+    refine ⟨.inr x,.inr (Γ.reverse x),.inr e,.inr (Γ.reverse e),hx,rfl,hfar,?_⟩
+    refine ⟨Γ.switch x e,hΓo,Γ.switch_preserves_labels label bar hΓl x e hel.symm,?_⟩
+    exact (subdivision_switch Γ x e hxe hxr).symm
+  obtain ⟨G,⟨Γ,hΓo,hΓl,hG⟩,hg⟩ := exists_large_girth N P hne hsw
+  exact ⟨Γ,hΓo,hΓl,hG ▸ hg⟩
+
+end TorsionFreeZeroDivisors.MatchingGraphs
+
+namespace TorsionFreeZeroDivisors.TypedGraphs
+open TorsionFreeZeroDivisors.Types PortSubdivision ConditionedMatchings MatchingGraphs
+variable {V : Type*} (outgoing : V → Finset Letter)
+
+/-- The source's outgoing half-edges, preserving their basepoints and letters. -/
+abbrev Dart := {e : V × Letter // e.2 ∈ outgoing e.1}
+def origin (e : Dart outgoing) : V := e.val.1
+def label (e : Dart outgoing) : Letter := e.val.2
+
+def reverse (M : MatchingTuple outgoing) (e : Dart outgoing) : Dart outgoing :=
+  ⟨(next outgoing M e.val.1 e.val.2,inverse e.val.2),
+    next_reverse_mem outgoing M e.val.1 e.val.2 e.property⟩
+
+theorem reverse_involutive (M : MatchingTuple outgoing) :
+    Function.Involutive (reverse outgoing M) := by
+  intro e
+  apply Subtype.ext
+  exact Prod.ext (next_reverse_next outgoing M e.val.1 e.val.2 e.property)
+    (inverse_inverse e.val.2)
+
+def matching (M : MatchingTuple outgoing) : Matching (label outgoing) inverse :=
+  ⟨(reverse_involutive outgoing M).toPerm (reverse outgoing M),
+    reverse_involutive outgoing M,by
+      intro e he
+      exact inverse_ne e.val.2 (congrArg (label outgoing) he),fun _ => rfl⟩
+
+/-- An origin fibre is exactly the prescribed outgoing type. -/
+def originFiber (v : V) : {e : Dart outgoing // origin outgoing e = v} ≃
+    {t : Letter // t ∈ outgoing v} where
+  toFun e := ⟨e.val.val.2,by
+    have h := e.val.property
+    simpa only [← e.property,origin,label] using h⟩
+  invFun t := ⟨⟨(v,t.val),t.property⟩,rfl⟩
+  left_inv e := by
+    apply Subtype.ext
+    apply Subtype.ext
+    exact Prod.ext e.property.symm rfl
+  right_inv _ := rfl
+
+/-- A letter fibre is exactly its empirical carrier set on this side. -/
+def labelFiber (t : Letter) : {e : Dart outgoing // label outgoing e = t} ≃
+    {v : V // t ∈ outgoing v} where
+  toFun e := ⟨e.val.val.1,by
+    have h := e.val.property
+    simpa only [← e.property,origin,label] using h⟩
+  invFun v := ⟨⟨(v.val,t),v.property⟩,rfl⟩
+  left_inv e := by
+    apply Subtype.ext
+    apply Subtype.ext
+    exact Prod.ext rfl e.property.symm
+  right_inv _ := rfl
+
+theorem origin_card (v : V) :
+    Nat.card {e : Dart outgoing // origin outgoing e = v} = (outgoing v).card := by
+  rw [Nat.card_congr (originFiber outgoing v), Nat.card_eq_fintype_card]
+  exact Fintype.card_coe _
+
+theorem label_card [Fintype V] (t : Letter) :
+    Nat.card {e : Dart outgoing // label outgoing e = t} =
+      Fintype.card {v : V // t ∈ outgoing v} := by
+  rw [Nat.card_congr (labelFiber outgoing t),Nat.card_eq_fintype_card]
+
+/-- No label can leave its basepoint twice: this is literally the immersion
+into the rose, not a simplicity assumption on the graph. -/
+theorem origin_label_injective : Function.Injective
+    (fun e : Dart outgoing => (origin outgoing e,label outgoing e)) := by
+  intro e f h
+  exact Subtype.ext h
+
+theorem exists_conditioned [Fintype V] (M : MatchingTuple outgoing) (N : ℕ)
+    (hd : ∀ v, (outgoing v).card ≤ 132)
+    (hsize : ∀ t, 4*132^(2*N+1) < Fintype.card {v : V // t ∈ outgoing v}) :
+    (Matching.conditioned (label := label outgoing) (bar := inverse)
+      (origin outgoing) N ∅).Nonempty := by
+  classical
+  let r := matching outgoing M
+  obtain ⟨Γ,hΓo,hΓl,hg⟩ := exists_typed_large_girth
+    (origin outgoing) (label outgoing) inverse (r.graph (origin outgoing)) rfl
+    (fun e => r.label_reverse e) 132 N (by norm_num)
+    (fun v => by rw [origin_card]; exact hd v)
+    (fun e => by rw [label_card]; exact hsize _)
+  let r' : Matching (label outgoing) inverse :=
+    ⟨Γ.reverse_reverse.toPerm Γ.reverse,Γ.reverse_reverse,Γ.reverse_ne,hΓl⟩
+  refine ⟨r',Finset.mem_filter.mpr ⟨Finset.mem_univ _,?_,?_⟩⟩
+  · intro a b h
+    exact False.elim (Finset.notMem_empty _ h)
+  · have he : r'.graph (origin outgoing) = Γ := by
+      cases Γ
+      simp_all only [Matching.graph]
+      rfl
+    rw [he]
+    exact hg
+
+/-- The actual prescribed A-side graph space has nonzero cardinality. -/
+theorem conditionedA_nonempty (rep N : ℕ) (hsize : 4*132^(2*N+1) < 4260354*rep) :
+    (Matching.conditioned (label := label (@outgoingA rep)) (bar := inverse)
+      (origin (@outgoingA rep)) N ∅).Nonempty := by
+  classical
+  exact exists_conditioned _ (Classical.choice (matchingA_nonempty rep)) N
+    (fun v => (degreeA_bounds v).2)
+    (fun t => by rw [letter_frequencyA]; exact hsize)
+
+theorem conditionedB_nonempty (rep N : ℕ) (hsize : 4*132^(2*N+1) < 4260354*rep) :
+    (Matching.conditioned (label := label (@outgoingB rep)) (bar := inverse)
+      (origin (@outgoingB rep)) N ∅).Nonempty := by
+  classical
+  exact exists_conditioned _ (Classical.choice (matchingB_nonempty rep)) N
+    (fun v => (degreeB_bounds v).2)
+    (fun t => by rw [letter_frequencyB]; exact hsize)
+
+end TorsionFreeZeroDivisors.TypedGraphs
+
+namespace TorsionFreeZeroDivisors.GirthAsymptotics
+open Filter
+open scoped Topology
+
+/-- The source logarithmic girth, including its specified constant c=1/100. -/
+def L (n : ℕ) : ℕ := ⌊Real.log n / 100⌋₊
+/-- Exclusion cost for the faithful threefold port subdivision. -/
+def exclusion (n : ℕ) : ℕ := 4 * 132 ^ (6 * L n + 1)
+
+theorem log132_lt : Real.log 132 < 8 := by
+  apply (Real.log_lt_iff_lt_exp (by norm_num)).mpr
+  have h : (2 : ℝ) < Real.exp 1 := by linarith [Real.exp_one_gt_d9]
+  have hp := pow_lt_pow_left₀ h (by norm_num : (0 : ℝ) ≤ 2) (by decide : 8 ≠ 0)
+  have he : Real.exp (8 : ℝ) = Real.exp 1 ^ 8 := by
+    simp [← Real.exp_nat_mul]
+  rw [he]
+  norm_num at hp ⊢
+  linarith
+
+theorem exclusion_bound (n : ℕ) (hn : 1 ≤ n) :
+    (exclusion n : ℝ) ≤ 4 * Real.exp 8 * (n : ℝ) ^ (1/2 : ℝ) := by
+  have hn' : (1 : ℝ) ≤ n := by exact_mod_cast hn
+  have hn0 : (0 : ℝ) < n := by positivity
+  have hl : 0 ≤ Real.log n := Real.log_nonneg hn'
+  have hf : (L n : ℝ) ≤ Real.log n / 100 := Nat.floor_le (by positivity)
+  have he : ((6 * L n + 1 : ℕ) : ℝ) * Real.log 132 ≤ Real.log n / 2 + 8 := by
+    push_cast
+    have hmul := mul_le_mul_of_nonneg_left (le_of_lt log132_lt)
+      (show 0 ≤ 6 * (L n : ℝ) + 1 by positivity)
+    nlinarith
+  rw [exclusion, Nat.cast_mul, Nat.cast_pow, Nat.cast_ofNat, Nat.cast_ofNat]
+  have hpow : (132 : ℝ) ^ (6 * L n + 1) =
+      Real.exp (((6 * L n + 1 : ℕ) : ℝ) * Real.log 132) := by
+    rw [Real.exp_nat_mul,Real.exp_log (by norm_num : (0 : ℝ) < 132)]
+  rw [hpow,Real.rpow_def_of_pos hn0]
+  calc
+    4 * Real.exp (↑(6 * L n + 1) * Real.log 132) ≤
+        4 * Real.exp (Real.log n / 2 + 8) :=
+      mul_le_mul_of_nonneg_left (Real.exp_le_exp.mpr he) (by norm_num)
+    _ = 4 * Real.exp 8 * Real.exp (Real.log n * (1/2)) := by
+      rw [Real.exp_add]
+      rw [div_eq_mul_inv]
+      ring_nf
+
+theorem exclusion_ratio : Tendsto (fun n : ℕ => (exclusion n : ℝ) / n) atTop (𝓝 0) := by
+  have ht : Tendsto (fun n : ℕ => (n : ℝ) ^ (-(1/2 : ℝ))) atTop (𝓝 0) :=
+    (tendsto_rpow_neg_atTop (by norm_num : (0 : ℝ) < 1/2)).comp tendsto_natCast_atTop_atTop
+  have ht' := ht.const_mul (4 * Real.exp 8)
+  simp only [mul_zero] at ht'
+  apply squeeze_zero' (Filter.Eventually.of_forall (fun n => by positivity)) _ ht'
+  filter_upwards [eventually_ge_atTop 1] with n hn
+  have hn0 : (0 : ℝ) < n := by exact_mod_cast (show 0 < n by omega)
+  calc
+    (exclusion n : ℝ) / n ≤ (4 * Real.exp 8 * (n : ℝ) ^ (1/2 : ℝ)) / n :=
+      div_le_div_of_nonneg_right (exclusion_bound n hn) (le_of_lt hn0)
+    _ = 4 * Real.exp 8 * (n : ℝ) ^ (-(1/2 : ℝ)) := by
+      rw [show -(1/2 : ℝ) = 1/2-1 by norm_num,Real.rpow_sub hn0,Real.rpow_one]
+      ring
+
+theorem L_tendsto : Tendsto L atTop atTop := by
+  have hl : Tendsto (fun n : ℕ => Real.log (n : ℝ) / 100) atTop atTop := by
+    simpa only [div_eq_mul_inv, Function.comp_apply] using
+      (Real.tendsto_log_atTop.comp (tendsto_natCast_atTop_atTop (R := ℝ))).atTop_mul_const
+        (by norm_num : (0 : ℝ) < (100 : ℝ)⁻¹)
+  exact tendsto_nat_floor_atTop.comp hl
+
+theorem eventual_small (p : ℝ) (hp : 0 < p) :
+    ∀ᶠ n : ℕ in atTop, (exclusion n : ℝ) < p * n := by
+  filter_upwards [exclusion_ratio.eventually_lt_const hp,eventually_ge_atTop 1] with n h hn
+  have hn0 : (0 : ℝ) < n := by exact_mod_cast (show 0 < n by omega)
+  exact (div_lt_iff₀ hn0).mp h
+
+end TorsionFreeZeroDivisors.GirthAsymptotics
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/GroupRing/TypeWeights.lean b/lean/OAI/Algebra/GroupRing/TypeWeights.lean
new file mode 100644
index 0000000000000000000000000000000000000000..9c52bc5c0905cfc614698a597e1e26ff7d474be6
--- /dev/null
+++ b/lean/OAI/Algebra/GroupRing/TypeWeights.lean
@@ -0,0 +1,476 @@
+import Mathlib
+import OAI.Algebra.GroupRing.PatternCount
+import OAI.Algebra.GroupRing.WordEstimate
+
+namespace OAI
+
+noncomputable section
+
+namespace TorsionFreeZeroDivisors.TypeWeights
+open TorsionFreeZeroDivisors.Types
+
+/-- The conditional joint-incidence table in the manuscript, before excluding
+cancellation. Arguments here are the two outgoing letters at the vertex. -/
+def jointWeight : Letter → Letter → ℝ
+  | .inl _, .inl _ => 1/129
+  | .inl _, .inr _ => 129/16513
+  | .inr _, .inl _ => 129/16513
+  | .inr _, .inr _ => 1
+
+def turnWeight (t u : Letter) : ℝ := if u = inverse t then 0 else jointWeight (inverse t) u
+
+/-- The finite geometric incidence table equals the analytic table, without
+changing the given inverse pairing or field. -/
+theorem jointWeight_signed (t u : Signed) :
+    jointWeight (inverse (signedLetter t)) (signedLetter u) = WordEstimate.baseWeight t u := by
+  rw [show inverse (signedLetter t) = signedLetter (WordEstimate.inverse t) by
+    rcases t with ⟨g,b⟩; exact inverse_signed g b]
+  rcases t with ⟨i | i,b⟩ <;> rcases u with ⟨j | j,c⟩ <;>
+    cases b <;> cases c <;>
+    simp [signedLetter,jointWeight,WordEstimate.baseWeight,
+      WordEstimate.inverse,WordEstimate.p]
+
+theorem turnWeight_signed (t u : Signed) :
+    turnWeight (signedLetter t) (signedLetter u) = WordEstimate.weight t u := by
+  unfold turnWeight
+  rw [jointWeight_signed]
+  rw [show inverse (signedLetter t) = signedLetter (WordEstimate.inverse t) by
+    rcases t with ⟨g,b⟩; exact inverse_signed g b]
+  simp only [Equiv.apply_eq_iff_eq]
+  rfl
+
+theorem jointWeight_comm (t u : Letter) : jointWeight t u = jointWeight u t := by
+  cases t <;> cases u <;> rfl
+
+/-- At an internal chain vertex of side B this is an exact count. -/
+theorem joint_countB (rep : ℕ) (a b : Letter) (hab : a ≠ b) :
+    (Fintype.card {v : VertexB rep // a ∈ outgoingB v ∧ b ∈ outgoingB v} : ℝ) =
+      (Fintype.card (VertexB rep) : ℝ) * (129/16513) * jointWeight a b := by
+  rw [card_vertexB]
+  rcases a with p | e <;> rcases b with q | f
+  · have hpq : p ≠ q := fun h => hab (congrArg Sum.inl h)
+    rw [show Fintype.card {v : VertexB rep // Sum.inl p ∈ outgoingB v ∧ Sum.inl q ∈ outgoingB v} =
+      33026*rep by simpa [outgoingB,card_slotB] using joint_ordinary extrasB rep p q hpq]
+    simp only [Nat.cast_mul,Nat.cast_ofNat,Nat.cast_pow,jointWeight]
+    ring
+  · rw [show Fintype.card {v : VertexB rep // Sum.inl p ∈ outgoingB v ∧ Sum.inr f ∈ outgoingB v} =
+      129*258*rep by simpa [outgoingB,slotB_extra_frequency] using joint_mixed extrasB rep p f]
+    simp only [Nat.cast_mul,Nat.cast_ofNat,Nat.cast_pow,jointWeight]
+    ring
+  · have he' : Fintype.card {v : VertexB rep // Sum.inr e ∈ outgoingB v ∧ Sum.inl q ∈ outgoingB v} =
+        Fintype.card {v : VertexB rep // Sum.inl q ∈ outgoingB v ∧ Sum.inr e ∈ outgoingB v} := by
+      exact Fintype.card_congr (Equiv.subtypeEquivRight (fun _ => and_comm))
+    rw [he',show Fintype.card {v : VertexB rep // Sum.inl q ∈ outgoingB v ∧ Sum.inr e ∈ outgoingB v} =
+      129*258*rep by simpa [outgoingB,slotB_extra_frequency] using joint_mixed extrasB rep q e]
+    simp only [Nat.cast_mul,Nat.cast_ofNat,Nat.cast_pow,jointWeight]
+    ring
+  · rw [show Fintype.card {v : VertexB rep // Sum.inr e ∈ outgoingB v ∧ Sum.inr f ∈ outgoingB v} =
+      16513*258*rep by simpa [outgoingB,slotB_extra_joint] using joint_extras extrasB rep e f]
+    simp only [Nat.cast_mul,Nat.cast_ofNat,Nat.cast_pow,jointWeight]
+    ring
+
+/-- The A-side conditional table is dominated by the B-side table, with the
+source's factor 1/2 for distinct extras. -/
+theorem joint_countA_le (rep : ℕ) (a b : Letter) (hab : a ≠ b) :
+    (Fintype.card {v : VertexA rep // a ∈ outgoingA v ∧ b ∈ outgoingA v} : ℝ) ≤
+      (Fintype.card (VertexA rep) : ℝ) * (129/16513) * jointWeight a b := by
+  rw [card_vertexA]
+  rcases a with p | e <;> rcases b with q | f
+  · have hpq : p ≠ q := fun h => hab (congrArg Sum.inl h)
+    rw [show Fintype.card {v : VertexA rep // Sum.inl p ∈ outgoingA v ∧ Sum.inl q ∈ outgoingA v} =
+      33026*rep by simpa [outgoingA,card_slotA] using joint_ordinary extrasA rep p q hpq]
+    push_cast
+    simp only [jointWeight]
+    nlinarith [Nat.cast_nonneg (α := ℝ) rep]
+  · rw [show Fintype.card {v : VertexA rep // Sum.inl p ∈ outgoingA v ∧ Sum.inr f ∈ outgoingA v} =
+      129*258*rep by simpa [outgoingA,slotA_extra_frequency] using joint_mixed extrasA rep p f]
+    push_cast
+    simp only [jointWeight]
+    nlinarith [Nat.cast_nonneg (α := ℝ) rep]
+  · rw [show Fintype.card {v : VertexA rep // Sum.inr e ∈ outgoingA v ∧ Sum.inl q ∈ outgoingA v} =
+        Fintype.card {v : VertexA rep // Sum.inl q ∈ outgoingA v ∧ Sum.inr e ∈ outgoingA v} by
+      exact Fintype.card_congr (Equiv.subtypeEquivRight (fun _ => and_comm))]
+    rw [show Fintype.card {v : VertexA rep // Sum.inl q ∈ outgoingA v ∧ Sum.inr e ∈ outgoingA v} =
+      129*258*rep by simpa [outgoingA,slotA_extra_frequency] using joint_mixed extrasA rep q e]
+    push_cast
+    simp only [jointWeight]
+    nlinarith [Nat.cast_nonneg (α := ℝ) rep]
+  · have hef : e ≠ f := fun h => hab (congrArg Sum.inr h)
+    rw [show Fintype.card {v : VertexA rep // Sum.inr e ∈ outgoingA v ∧ Sum.inr f ∈ outgoingA v} =
+      16513*129*rep by simpa [outgoingA,slotA_extra_joint e f hef] using joint_extras extrasA rep e f]
+    push_cast
+    simp only [jointWeight]
+    nlinarith [Nat.cast_nonneg (α := ℝ) rep]
+
+theorem internal_countB (rep : ℕ) (t u : Letter) (h : u ≠ inverse t) :
+    (Fintype.card {v : VertexB rep // inverse t ∈ outgoingB v ∧ u ∈ outgoingB v} : ℝ) =
+      (Fintype.card (VertexB rep) : ℝ) * (129/16513) * turnWeight t u := by
+  simpa only [turnWeight,ite_eq_right h] using joint_countB rep (inverse t) u h.symm
+
+theorem internal_countA (rep : ℕ) (t u : Letter) (h : u ≠ inverse t) :
+    (Fintype.card {v : VertexA rep // inverse t ∈ outgoingA v ∧ u ∈ outgoingA v} : ℝ) ≤
+      (Fintype.card (VertexA rep) : ℝ) * (129/16513) * turnWeight t u := by
+  simpa only [turnWeight,ite_eq_right h] using joint_countA_le rep (inverse t) u h.symm
+
+end TorsionFreeZeroDivisors.TypeWeights
+
+namespace TorsionFreeZeroDivisors.StageRealization
+open scoped Classical BigOperators
+open PortSubdivision ConditionedMatchings PatternEmbeddings
+variable {PV PD TV T : Type*} [Fintype PV] [Fintype PD] [Fintype TV] [Fintype T]
+
+/-- Actual vertex carriers: all outgoing template ports must be available;
+`pin` imposes exactly the prescribed images, not extra random conditions. -/
+def allowed (Γ : PortGraph PV PD) (plabel : PD → T) (outgoing : TV → Finset T)
+    (pin : PV → Option TV) (v : PV) : Finset TV :=
+  Finset.univ.filter fun x => (∀ d, Γ.origin d = v → plabel d ∈ outgoing x) ∧
+    ∀ y, pin v = some y → x = y
+
+omit [Fintype PV] [Fintype T] in
+theorem allowed_ports (Γ : PortGraph PV PD) (plabel : PD → T)
+    (outgoing : TV → Finset T) (pin : PV → Option TV) :
+    ∀ v x, x ∈ allowed Γ plabel outgoing pin v →
+      ∀ d, Γ.origin d = v → plabel d ∈ outgoing x := by
+  intro v x hx
+  exact (Finset.mem_filter.mp hx).2.1
+
+omit [Fintype PV] [Fintype T] in
+theorem allowed_card_le (Γ : PortGraph PV PD) (plabel : PD → T)
+    (outgoing : TV → Finset T) (pin : PV → Option TV) (v : PV) :
+    (allowed Γ plabel outgoing pin v).card ≤ Fintype.card TV :=
+  Finset.card_le_univ _
+
+omit [Fintype PV] [Fintype T] in
+theorem pinned_card_le (Γ : PortGraph PV PD) (plabel : PD → T)
+    (outgoing : TV → Finset T) (pin : PV → Option TV) (v : PV) (y : TV)
+    (hp : pin v = some y) : (allowed Γ plabel outgoing pin v).card ≤ 1 := by
+  apply Finset.card_le_one.mpr
+  intro a ha b hb
+  exact ((Finset.mem_filter.mp ha).2.2 y hp).trans
+    ((Finset.mem_filter.mp hb).2.2 y hp).symm
+
+omit [Fintype PV] [Fintype T] in
+/-- A turn at an internal chain vertex restricts its image to the *joint*
+carrier. This does not assume independence of consecutive turns. -/
+theorem allowed_turn_le (Γ : PortGraph PV PD) (plabel : PD → T)
+    (outgoing : TV → Finset T) (pin : PV → Option TV) (v : PV) (a b : PD)
+    (ha : Γ.origin a = v) (hb : Γ.origin b = v) :
+    (allowed Γ plabel outgoing pin v).card ≤
+      Fintype.card {x : TV // plabel a ∈ outgoing x ∧ plabel b ∈ outgoing x} := by
+  rw [Fintype.card_subtype]
+  apply Finset.card_le_card
+  intro x hx
+  exact Finset.mem_filter.mpr ⟨Finset.mem_univ _,
+    allowed_ports Γ plabel outgoing pin v x hx a ha,
+    allowed_ports Γ plabel outgoing pin v x hx b hb⟩
+
+/-- Concrete realization count for one fixed immersed labeling. -/
+def realizations (Γ : PortGraph PV PD) (plabel : PD → T)
+    (outgoing : TV → Finset T) (pin : PV → Option TV) (bar : T → T)
+    (r : Matching (label outgoing) bar) : ℕ :=
+  (Finset.univ.filter fun f : VertexMap (allowed Γ plabel outgoing pin) =>
+    ∀ d, r.val (dartMap Γ plabel outgoing _ (allowed_ports Γ plabel outgoing pin) f d) =
+      dartMap Γ plabel outgoing _ (allowed_ports Γ plabel outgoing pin) f (Γ.reverse d)).card
+
+/-- Finite, exact form of the source fixed-label first moment. `cost v` is a
+literal upper bound for carrier size; the matching estimate is proved above. -/
+theorem fixed_label_bound (Γ : PortGraph PV PD) (plabel : PD → T)
+    (outgoing : TV → Finset T) (pin : PV → Option TV) (bar : T → T)
+    (hbar : ∀ t, bar t ≠ t) (himm : Function.Injective (fun d => (Γ.origin d,plabel d)))
+    (N d R : ℕ) (h2 : 2 ≤ d) (hR : 0 < R)
+    (hd : ∀ v, Nat.card {e : Dart outgoing // origin outgoing e = v} ≤ d)
+    (hsize : ∀ x : Dart outgoing,
+      R + (edges Γ).card + 4*d^(2*N+1) ≤
+        Nat.card {e : Dart outgoing // label outgoing e = label outgoing x})
+    (hΩ : (Matching.conditioned (label := label outgoing) (bar := bar)
+      (origin outgoing) N ∅).Nonempty)
+    (cost : PV → ℝ) (hcost : ∀ v, ((allowed Γ plabel outgoing pin v).card : ℝ) ≤ cost v) :
+    ((∑ r ∈ Matching.conditioned (label := label outgoing) (bar := bar)
+      (origin outgoing) N ∅, realizations Γ plabel outgoing pin bar r : ℕ) : ℝ) /
+      (Matching.conditioned (label := label outgoing) (bar := bar) (origin outgoing) N ∅).card ≤
+      (∏ v, cost v) / (R : ℝ)^(edges Γ).card := by
+  exact (PatternEmbeddings.expectation_bound Γ plabel outgoing
+    (allowed Γ plabel outgoing pin) (allowed_ports Γ plabel outgoing pin)
+    bar hbar himm N d R h2 hR hd hsize hΩ).trans
+      (div_le_div_of_nonneg_right (Finset.prod_le_prod₀ (fun _ _ => Nat.cast_nonneg _)
+        (fun v _ => hcost v)) (by positivity))
+
+/-- Source internal-turn product, retaining a finite, explicit matching
+error denominator instead of hiding it in o(L). -/
+def vertexCost (n p : ℝ) (J : Finset PV) (w : T → T → ℝ)
+    (a b : PV → T) (pin : PV → Option TV) (v : PV) : ℝ :=
+  if pin v = none then (if v ∈ J then n*p*w (a v) (b v) else n) else 1
+
+omit [Fintype TV] [Fintype T] in
+theorem product_vertexCost (n p : ℝ) (J : Finset PV) (w : T → T → ℝ)
+    (a b : PV → T) (pin : PV → Option TV) (hJ : ∀ v ∈ J, pin v = none) :
+    (∏ v, vertexCost n p J w a b pin v) =
+      n^((Finset.univ.filter fun v => pin v = none).card) * p^J.card *
+        ∏ v ∈ J, w (a v) (b v) := by
+  have he (v : PV) : vertexCost n p J w a b pin v =
+      (if pin v = none then n else 1) *
+        (if v ∈ J then p*w (a v) (b v) else 1) := by
+    by_cases hj : v ∈ J
+    · simp [vertexCost,hJ v hj,hj,mul_assoc]
+    · simp [vertexCost,hj]
+  simp_rw [he,Finset.prod_mul_distrib]
+  rw [← Finset.prod_filter,← Finset.prod_filter]
+  simp only [Finset.filter_mem_eq_inter, Finset.univ_inter, Finset.prod_const,
+    Finset.prod_mul_distrib]
+  ring
+
+omit [Fintype PV] [Fintype T] in
+/-- Every eligible local carrier is bounded by its actual type-table cost. -/
+theorem allowed_cost (Γ : PortGraph PV PD) (plabel : PD → T)
+    (outgoing : TV → Finset T) (pin : PV → Option TV)
+    (J : Finset PV) (a b : PV → PD)
+    (ha : ∀ v ∈ J, Γ.origin (a v) = v) (hb : ∀ v ∈ J, Γ.origin (b v) = v)
+    (hab : ∀ v ∈ J, a v ≠ b v)
+    (himm : Function.Injective (fun d => (Γ.origin d,plabel d)))
+    (n p : ℝ) (w : T → T → ℝ)
+    (hn : (Fintype.card TV : ℝ) ≤ n)
+    (htable : ∀ t u, t ≠ u →
+      (Fintype.card {x : TV // t ∈ outgoing x ∧ u ∈ outgoing x} : ℝ) ≤ n*p*w t u) :
+    ∀ v, ((allowed Γ plabel outgoing pin v).card : ℝ) ≤
+      vertexCost n p J w (plabel ∘ a) (plabel ∘ b) pin v := by
+  intro v
+  by_cases hp : pin v = none
+  · simp only [vertexCost,hp,ite_true,Function.comp_apply]
+    by_cases hj : v ∈ J
+    · rw [ite_eq_left hj]
+      have hne : plabel (a v) ≠ plabel (b v) := by
+        intro he
+        exact hab v hj (himm (Prod.ext ((ha v hj).trans (hb v hj).symm) he))
+      exact (Nat.cast_le.mpr (allowed_turn_le Γ plabel outgoing pin v (a v) (b v)
+        (ha v hj) (hb v hj))).trans (htable _ _ hne)
+    · rw [ite_eq_right hj]
+      exact (Nat.cast_le.mpr (allowed_card_le Γ plabel outgoing pin v)).trans hn
+  · simp only [vertexCost,hp,ite_false]
+    cases he : pin v with
+    | none => exact False.elim (hp he)
+    | some x => exact_mod_cast pinned_card_le Γ plabel outgoing pin v x he
+
+/-- Literal fixed-label bound with actual internal turns and fixed vertices,
+before taking logarithms or asymptotics. -/
+theorem turn_product_bound (Γ : PortGraph PV PD) (plabel : PD → T)
+    (outgoing : TV → Finset T) (pin : PV → Option TV) (bar : T → T)
+    (hbar : ∀ t, bar t ≠ t) (himm : Function.Injective (fun d => (Γ.origin d,plabel d)))
+    (N d R : ℕ) (h2 : 2 ≤ d) (hR : 0 < R)
+    (hd : ∀ v, Nat.card {e : Dart outgoing // origin outgoing e = v} ≤ d)
+    (hsize : ∀ x : Dart outgoing,
+      R + (edges Γ).card + 4*d^(2*N+1) ≤
+        Nat.card {e : Dart outgoing // label outgoing e = label outgoing x})
+    (hΩ : (Matching.conditioned (label := label outgoing) (bar := bar)
+      (origin outgoing) N ∅).Nonempty)
+    (J : Finset PV) (a b : PV → PD)
+    (ha : ∀ v ∈ J, Γ.origin (a v) = v) (hb : ∀ v ∈ J, Γ.origin (b v) = v)
+    (hab : ∀ v ∈ J, a v ≠ b v) (hJ : ∀ v ∈ J, pin v = none)
+    (n p : ℝ) (w : T → T → ℝ)
+    (hn : (Fintype.card TV : ℝ) ≤ n)
+    (htable : ∀ t u, t ≠ u →
+      (Fintype.card {x : TV // t ∈ outgoing x ∧ u ∈ outgoing x} : ℝ) ≤ n*p*w t u) :
+    ((∑ r ∈ Matching.conditioned (label := label outgoing) (bar := bar)
+      (origin outgoing) N ∅, realizations Γ plabel outgoing pin bar r : ℕ) : ℝ) /
+      (Matching.conditioned (label := label outgoing) (bar := bar) (origin outgoing) N ∅).card ≤
+      (n^((Finset.univ.filter fun v => pin v = none).card) * p^J.card *
+        ∏ v ∈ J, w (plabel (a v)) (plabel (b v))) / (R : ℝ)^(edges Γ).card := by
+  have h := fixed_label_bound Γ plabel outgoing pin bar hbar himm N d R h2 hR hd hsize hΩ
+    (vertexCost n p J w (plabel ∘ a) (plabel ∘ b) pin)
+    (allowed_cost Γ plabel outgoing pin J a b ha hb hab himm n p w hn htable)
+  rwa [product_vertexCost n p J w (plabel ∘ a) (plabel ∘ b) pin hJ] at h
+
+section Typed
+open TorsionFreeZeroDivisors.Types
+variable (rep : ℕ) (Γ : PortGraph PV PD) (plabel : PD → Letter)
+  (himm : Function.Injective (fun d => (Γ.origin d,plabel d)))
+  (J : Finset PV) (a b : PV → PD)
+  (ha : ∀ v ∈ J, Γ.origin (a v) = v) (hb : ∀ v ∈ J, Γ.origin (b v) = v)
+  (hab : ∀ v ∈ J, a v ≠ b v)
+
+include himm ha hb hab
+omit [Fintype PV] [Fintype TV] [Fintype T] in
+/-- The exact source A-side empirical counts instantiate the local estimate. -/
+theorem allowed_costA (pin : PV → Option (VertexA rep)) :
+    ∀ v, ((allowed Γ plabel (@outgoingA rep) pin v).card : ℝ) ≤
+      vertexCost (Fintype.card (VertexA rep)) (129/16513) J TypeWeights.jointWeight
+        (plabel ∘ a) (plabel ∘ b) pin v :=
+  allowed_cost Γ plabel (@outgoingA rep) pin J a b ha hb hab himm _ _ _ le_rfl
+    (fun t u h => by simpa only [← Nat.card_eq_fintype_card] using
+      TypeWeights.joint_countA_le rep t u h)
+
+omit [Fintype PV] [Fintype TV] [Fintype T] in
+/-- The B-side count uses its own types, not independent coordinates. -/
+theorem allowed_costB (pin : PV → Option (VertexB rep)) :
+    ∀ v, ((allowed Γ plabel (@outgoingB rep) pin v).card : ℝ) ≤
+      vertexCost (Fintype.card (VertexB rep)) (129/16513) J TypeWeights.jointWeight
+        (plabel ∘ a) (plabel ∘ b) pin v :=
+  allowed_cost Γ plabel (@outgoingB rep) pin J a b ha hb hab himm _ _ _ le_rfl
+    (fun t u h => by simpa only [← Nat.card_eq_fintype_card] using
+      (TypeWeights.joint_countB rep t u h).le)
+
+end Typed
+
+/-- Exact expectation factorization for the two independently chosen side
+matchings. No independence of edges *within* either matching is used. -/
+theorem mean_product {A B : Type*} (S : Finset A) (U : Finset B)
+    (f : A → ℝ) (g : B → ℝ) :
+    (∑ x ∈ S, ∑ y ∈ U, f x*g y) / ((S.card : ℝ)*U.card) =
+      ((∑ x ∈ S, f x)/S.card) * ((∑ y ∈ U, g y)/U.card) := by
+  rw [← Finset.sum_mul_sum, mul_div_mul_comm]
+
+/-- Combining the side bounds correctly counts a mixed-side stage. -/
+theorem mean_product_le {A B : Type*} (S : Finset A) (U : Finset B)
+    (f : A → ℝ) (g : B → ℝ) (hf : ∀ x ∈ S, 0 ≤ f x) (hg : ∀ y ∈ U, 0 ≤ g y)
+    (a b : ℝ) (ha : (∑ x ∈ S, f x)/S.card ≤ a)
+    (hb : (∑ y ∈ U, g y)/U.card ≤ b) :
+    (∑ x ∈ S, ∑ y ∈ U, f x*g y) / ((S.card : ℝ)*U.card) ≤ a*b := by
+  rw [mean_product]
+  exact mul_le_mul ha hb (div_nonneg (Finset.sum_nonneg hg) (Nat.cast_nonneg _))
+    ((div_nonneg (Finset.sum_nonneg hf) (Nat.cast_nonneg _)).trans ha)
+
+end TorsionFreeZeroDivisors.StageRealization
+
+namespace TorsionFreeZeroDivisors.ChainSubdivision
+open scoped Classical BigOperators
+variable {C V : Type*} (len : C → ℕ) (first last : C → V)
+abbrev Interior := (c : C) × Fin (len c-1)
+abbrev Vertex := V ⊕ Interior len
+abbrev Edge := (c : C) × Fin (len c)
+abbrev Dart := Edge len × Bool
+
+def point (c : C) (k : Fin (len c+1)) : Vertex len (V := V) :=
+  if h0 : k.val=0 then .inl (first c) else if h1 : k.val=len c then .inl (last c)
+  else .inr ⟨c,⟨k.val-1,by omega⟩⟩
+
+def graph : PortSubdivision.PortGraph (Vertex len (V := V)) (Dart len) where
+  origin d := point len first last d.1.1 ⟨d.1.2.val+(if d.2 then 1 else 0),by
+    cases d.2 <;> simp only [Bool.false_eq_true,ite_false,ite_true] <;> omega⟩
+  reverse d := (d.1,!d.2)
+  reverse_reverse d := by simp
+  reverse_ne d := by
+    intro h
+    have hh := congrArg Prod.snd h
+    cases hb : d.2 <;> simp [hb] at hh
+
+@[simp] theorem reverse (d : Dart len) : (graph len first last).reverse d = (d.1,!d.2) := rfl
+@[simp] theorem origin_forward (e : Edge len) :
+    (graph len first last).origin (e,false) = point len first last e.1 ⟨e.2.val,by omega⟩ := rfl
+@[simp] theorem origin_backward (e : Edge len) :
+    (graph len first last).origin (e,true) = point len first last e.1 ⟨e.2.val+1,by omega⟩ := rfl
+
+@[simp] theorem at_zero (c : C) : point len first last c ⟨0,by omega⟩ = .inl (first c) := by
+  simp [point]
+
+theorem at_last (hpos : ∀ c, 0 < len c) (c : C) :
+    point len first last c ⟨len c,by omega⟩ = .inl (last c) := by
+  simp [point,Nat.ne_of_gt (hpos c)]
+
+@[simp] theorem at_interior (c : C) (k : Fin (len c-1)) :
+    point len first last c ⟨k.val+1,by omega⟩ = .inr ⟨c,k⟩ := by
+  have hk : k.val+1 ≠ len c := by omega
+  simp [point,hk]
+
+/-- Outgoing darts at an internal vertex: the preceding edge backwards and
+following edge forwards, with no arbitrary choices. -/
+def back (v : Interior len) : Dart len := (⟨v.1,⟨v.2.val,by omega⟩⟩,true)
+def front (v : Interior len) : Dart len := (⟨v.1,⟨v.2.val+1,by omega⟩⟩,false)
+
+@[simp] theorem back_origin (v : Interior len) :
+    (graph len first last).origin (back len v) = .inr v := by
+  simpa only [back,origin_backward] using at_interior len first last v.1 v.2
+@[simp] theorem front_origin (v : Interior len) :
+    (graph len first last).origin (front len v) = .inr v := by
+  simpa only [front,origin_forward] using at_interior len first last v.1 v.2
+
+theorem back_ne_front (v : Interior len) : back len v ≠ front len v := by
+  intro h
+  have hh := congrArg Prod.snd h
+  cases hh
+
+theorem at_eq_interior {c : C} {k : Fin (len c+1)} {v : Interior len}
+    (hk : point len first last c k = .inr v) :
+    c = v.1 ∧ k.val = v.2.val+1 := by
+  unfold point at hk
+  split_ifs at hk with h0 h1
+  have he := Sum.inr.inj hk
+  have hc := congrArg Sigma.fst he
+  have hh := congrArg (fun v : Interior len => v.2.val) he
+  dsimp at hc hh
+  exact ⟨hc,by omega⟩
+
+/-- Each internal vertex has precisely the two prescribed outgoing darts. -/
+theorem internal_ports (v : Interior len) (d : Dart len) :
+    (graph len first last).origin d = .inr v ↔ d = back len v ∨ d = front len v := by
+  constructor
+  · rcases d with ⟨⟨c,k⟩,b⟩
+    cases b
+    · intro h
+      have hh := at_eq_interior len first last h
+      rcases v with ⟨c',l⟩
+      dsimp at hh
+      obtain ⟨rfl,hk⟩ := hh
+      right
+      apply congrArg (fun t : Fin (len c) => ((⟨c,t⟩ : Edge len),false))
+      exact Fin.ext hk
+    · intro h
+      simp only [origin_backward] at h
+      have hh := at_eq_interior len first last h
+      rcases v with ⟨c',l⟩
+      dsimp at hh
+      obtain ⟨rfl,hk⟩ := hh
+      left
+      apply congrArg (fun t : Fin (len c) => ((⟨c,t⟩ : Edge len),true))
+      apply Fin.ext
+      change k.val = l.val
+      omega
+  · rintro (rfl|rfl)
+    · exact back_origin len first last v
+    · exact front_origin len first last v
+
+variable [Fintype C] [Fintype V]
+
+@[simp] theorem card_edges : Fintype.card (Edge len) = ∑ c, len c := by
+  simp [Edge,Fintype.card_sigma]
+
+@[simp] theorem card_darts : Fintype.card (Dart len) = 2*∑ c, len c := by
+  simp [Dart,Fintype.card_prod,Nat.mul_comm]
+
+@[simp] theorem card_interiors : Fintype.card (Interior len) = ∑ c, (len c-1) := by
+  simp [Interior,Fintype.card_sigma]
+
+/-- Interior and endpoint counts are kept separate, including loop chains. -/
+theorem card_vertices (hpos : ∀ c, 0 < len c) :
+    Fintype.card (Vertex len (V := V)) + Fintype.card C = Fintype.card V + ∑ c, len c := by
+  simp only [Vertex,Fintype.card_sum,card_interiors]
+  have hh : (∑ c, (len c-1)) + Fintype.card C = ∑ c, len c := by
+    have hone : Fintype.card C = ∑ _c : C, (1 : ℕ) := by simp
+    rw [hone, ← Finset.sum_add_distrib]
+    apply Finset.sum_congr rfl
+    intro c _
+    have hc := hpos c
+    omega
+  omega
+
+/-- The complete set of unmarked internal vertices. -/
+def internal : Finset (Vertex len (V := V)) := Finset.univ.image Sum.inr
+
+omit [Fintype V] in
+@[simp] theorem mem_internal (v : Vertex len (V := V)) :
+    v ∈ internal len (V := V) ↔ ∃ x, v = Sum.inr x := by
+  simp [internal,eq_comm]
+
+omit [Fintype V] in
+@[simp] theorem card_internal : (internal len (V := V)).card = ∑ c, (len c-1) := by
+  rw [internal,Finset.card_image_of_injective _ Sum.inr_injective,Finset.card_univ,card_interiors]
+
+/-- Constant traversal multiplicity on each original marked chain. -/
+def multiplicity (m : C → ℕ) (d : Dart len) := m d.1.1
+omit [Fintype C] [Fintype V] in
+@[simp] theorem multiplicity_reverse (m : C → ℕ) (d : Dart len) :
+    multiplicity len m ((graph len first last).reverse d) = multiplicity len m d := rfl
+
+end TorsionFreeZeroDivisors.ChainSubdivision
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/GroupRing/TypedComponent.lean b/lean/OAI/Algebra/GroupRing/TypedComponent.lean
new file mode 100644
index 0000000000000000000000000000000000000000..1ce83e639d7ff7ebae9d1bc2df8b059ec3bd1439
--- /dev/null
+++ b/lean/OAI/Algebra/GroupRing/TypedComponent.lean
@@ -0,0 +1,260 @@
+import Mathlib
+import OAI.Algebra.GroupRing.PlanarMap
+
+namespace OAI
+
+noncomputable section
+
+namespace TorsionFreeZeroDivisors.TypedComponent
+open scoped Classical BigOperators
+open PortSubdivision ConditionedMatchings TypedGraphs
+variable {V : Type} (outgoing : V→Finset Types.Letter)
+    (r : Matching (label outgoing) Types.inverse) (root : V)
+abbrev graph := r.graph (origin outgoing)
+abbrev Vertex := {v : V // (ShortClosure.simpleGraph (graph outgoing r)).Reachable root v}
+def out (v : Vertex outgoing r root) : Finset Types.Letter := outgoing v.val
+abbrev Dart := Factors.DartA (out outgoing r root)
+def lift (d : Dart outgoing r root) : TypedGraphs.Dart outgoing :=
+  ⟨(d.val.1.val,d.val.2),d.property⟩
+lemma lift_injective : Function.Injective (lift outgoing r root) := by
+  intro d e h
+  apply Subtype.ext
+  apply Prod.ext
+  · apply Subtype.ext
+    exact congrArg (fun z : TypedGraphs.Dart outgoing => z.val.1) h
+  · exact congrArg (fun z : TypedGraphs.Dart outgoing => z.val.2) h
+
+def reverse (d : Dart outgoing r root) : Dart outgoing r root :=
+  ⟨(⟨(r (lift outgoing r root d)).val.1,
+    d.val.1.property.trans (ShortClosure.dart_reachable (graph outgoing r) (lift outgoing r root d))⟩,
+    (r (lift outgoing r root d)).val.2),(r (lift outgoing r root d)).property⟩
+lemma lift_reverse (d : Dart outgoing r root) :
+    lift outgoing r root (reverse outgoing r root d)=r (lift outgoing r root d) := rfl
+lemma reverse_reverse : Function.Involutive (reverse outgoing r root) := by
+  intro d
+  apply lift_injective outgoing r root
+  rw [lift_reverse,lift_reverse,r.reverse_reverse]
+lemma label_reverse (d : Dart outgoing r root) :
+    (reverse outgoing r root d).val.2=Types.inverse d.val.2 :=
+  r.label_reverse (lift outgoing r root d)
+def base : Vertex outgoing r root := ⟨root,.refl _⟩
+end TorsionFreeZeroDivisors.TypedComponent
+
+namespace TorsionFreeZeroDivisors.ComponentFactors
+open scoped Classical BigOperators
+open ConditionedMatchings TypedGraphs TypedComponent SampleGraph
+variable {G : Type} [Group G] (rep : ℕ) (r : ActualPatternEvent.Match rep)
+  (x : SampleGraph.VA rep) (y : SampleGraph.VB rep)
+abbrev CA := TypedComponent.Vertex (@Types.outgoingA rep) r.1 x
+abbrev CB := TypedComponent.Vertex (@Types.outgoingB rep) r.2 y
+/-- Actual full components in the chosen sample, with every outgoing edge
+retained. Parallel simultaneous steps cancel as distinct signed flags. -/
+theorem product_zero (letter : Types.Letter→G) (g : CA rep r x→G) (h : CB rep r y→G)
+    (hg : ∀ d : TypedComponent.Dart (@Types.outgoingA rep) r.1 x,
+      g (TypedComponent.reverse _ r.1 x d).val.1=g d.val.1*letter d.val.2)
+    (hh : ∀ d : TypedComponent.Dart (@Types.outgoingB rep) r.2 y,
+      h (TypedComponent.reverse _ r.2 y d).val.1=h d.val.1*letter d.val.2) :
+    (∑ a,MonoidAlgebra.single (g a) (1 : ZMod 2)) *
+      (∑ b,MonoidAlgebra.single ((h b)⁻¹) (1 : ZMod 2))=0 := by
+  exact Factors.product_zero (TypedComponent.out _ r.1 x) (TypedComponent.out _ r.2 y)
+    Types.inverse (TypedComponent.reverse _ r.1 x) (TypedComponent.reverse _ r.2 y)
+    (TypedComponent.label_reverse _ r.1 x) (TypedComponent.label_reverse _ r.2 y)
+    (TypedComponent.reverse_reverse _ r.1 x) (TypedComponent.reverse_reverse _ r.2 y)
+    Types.inverse_ne (fun leftVertex rightVertex => by
+      convert Types.odd_cross_intersections leftVertex.val rightVertex.val using 1
+      congr 1
+      ext letterType
+      simp [TypedComponent.out]) letter g h hg hh
+
+/-- Given the source's root nontriviality endpoint, these very sums are the
+nonzero factors. No pairwise distinctness of the other vertex labels is used. -/
+theorem nonzero_factors
+    (letter : Types.Letter→G) (g : CA rep r x→G) (h : CB rep r y→G)
+    (hg : ∀ d : TypedComponent.Dart (@Types.outgoingA rep) r.1 x,
+      g (TypedComponent.reverse _ r.1 x d).val.1=g d.val.1*letter d.val.2)
+    (hh : ∀ d : TypedComponent.Dart (@Types.outgoingB rep) r.2 y,
+      h (TypedComponent.reverse _ r.2 y d).val.1=h d.val.1*letter d.val.2)
+    (hx : g (TypedComponent.base _ r.1 x)=1) (hy : h (TypedComponent.base _ r.2 y)=1)
+    (hux : ∀ a,g a=1 → a=TypedComponent.base _ r.1 x)
+    (huy : ∀ b,h b=1 → b=TypedComponent.base _ r.2 y) :
+    ∃ α β : MonoidAlgebra (ZMod 2) G,α≠0 ∧ β≠0 ∧ α*β=0 := by
+  refine ⟨∑ a,MonoidAlgebra.single (g a) 1,∑ b,MonoidAlgebra.single ((h b)⁻¹) 1,
+    Factors.sum_nonzero _ g hx hux,?_,product_zero rep r x y letter g h hg hh⟩
+  apply Factors.sum_nonzero (TypedComponent.base _ r.2 y) (fun b => (h b)⁻¹)
+  · simp only [hy,inv_one]
+  · intro b hb
+    exact huy b (inv_eq_one.mp hb)
+end TorsionFreeZeroDivisors.ComponentFactors
+
+namespace TorsionFreeZeroDivisors.ConcreteFactors
+open scoped Classical BigOperators
+open TypedGraphs ConditionedMatchings SampleGraph ConcreteGroup TypedComponent
+variable (rep : ℕ) (r : ActualPatternEvent.Match rep) (x : VA rep) (y : VB rep)
+def leftValue (a : ComponentFactors.CA rep r x) : G rep r :=
+  (value rep r (Sum.inl x))⁻¹*value rep r (Sum.inl a.val)
+def rightValue (b : ComponentFactors.CB rep r y) : G rep r :=
+  (value rep r (Sum.inr y))⁻¹*value rep r (Sum.inr b.val)
+lemma left_edge (d : TypedComponent.Dart (@Types.outgoingA rep) r.1 x) :
+    leftValue rep r x (TypedComponent.reverse _ r.1 x d).val.1=
+      leftValue rep r x d.val.1*letter rep r d.val.2 := by
+  have h := ConcreteGroup.edge rep r (Sum.inl (TypedComponent.lift _ r.1 x d))
+  change value rep r (Sum.inl (r.1 (TypedComponent.lift _ r.1 x d)).val.1)=
+    value rep r (Sum.inl d.val.1.val)*letter rep r d.val.2 at h
+  change (value rep r (Sum.inl x))⁻¹*value rep r (Sum.inl (r.1 (TypedComponent.lift _ r.1 x d)).val.1)=_
+  rw [h]
+  exact (mul_assoc _ _ _).symm
+lemma right_edge (d : TypedComponent.Dart (@Types.outgoingB rep) r.2 y) :
+    rightValue rep r y (TypedComponent.reverse _ r.2 y d).val.1=
+      rightValue rep r y d.val.1*letter rep r d.val.2 := by
+  have h := ConcreteGroup.edge rep r (Sum.inr (TypedComponent.lift _ r.2 y d))
+  change value rep r (Sum.inr (r.2 (TypedComponent.lift _ r.2 y d)).val.1)=
+    value rep r (Sum.inr d.val.1.val)*letter rep r d.val.2 at h
+  change (value rep r (Sum.inr y))⁻¹*value rep r (Sum.inr (r.2 (TypedComponent.lift _ r.2 y d)).val.1)=_
+  rw [h]
+  exact (mul_assoc _ _ _).symm
+@[simp] lemma left_root : leftValue rep r x (TypedComponent.base _ r.1 x)=1 := by
+  simp [leftValue,TypedComponent.base]
+@[simp] lemma right_root : rightValue rep r y (TypedComponent.base _ r.2 y)=1 := by
+  simp [rightValue,TypedComponent.base]
+def alpha : MonoidAlgebra (ZMod 2) (G rep r) :=
+  ∑ a,MonoidAlgebra.single (leftValue rep r x a) 1
+def beta : MonoidAlgebra (ZMod 2) (G rep r) :=
+  ∑ b,MonoidAlgebra.single ((rightValue rep r y b)⁻¹) 1
+/-- The author's factors multiply to zero in the exact finite graph presentation,
+for every matching sample. Nonvanishing is a separate geometric obligation. -/
+theorem product_zero : alpha rep r x*beta rep r y=0 :=
+  ComponentFactors.product_zero rep r x y (letter rep r) (leftValue rep r x) (rightValue rep r y)
+    (left_edge rep r x) (right_edge rep r y)
+lemma alpha_nonzero
+    (hroot : ∀ a,leftValue rep r x a=1 → a=TypedComponent.base _ r.1 x) :
+    alpha rep r x≠0 :=
+  Factors.sum_nonzero _ (leftValue rep r x) (left_root rep r x) hroot
+lemma beta_nonzero
+    (hroot : ∀ b,rightValue rep r y b=1 → b=TypedComponent.base _ r.2 y) :
+    beta rep r y≠0 := by
+  apply Factors.sum_nonzero (TypedComponent.base _ r.2 y) (fun b => (rightValue rep r y b)⁻¹)
+  · simp
+  · intro b hb
+    exact hroot b (inv_eq_one.mp hb)
+end TorsionFreeZeroDivisors.ConcreteFactors
+
+namespace TorsionFreeZeroDivisors.SumPort
+open scoped Classical
+open PortSubdivision
+variable {VA VB DA DB : Type} (A : PortGraph VA DA) (B : PortGraph VB DB)
+def leftHom : ShortClosure.simpleGraph A →g ShortClosure.simpleGraph (graph A B) where
+  toFun := Sum.inl
+  map_rel' := by
+    rintro a b ⟨hab,d,ha,hb⟩
+    exact ⟨fun h=>hab (Sum.inl.inj h),Sum.inl d,congrArg Sum.inl ha,congrArg Sum.inl hb⟩
+def rightHom : ShortClosure.simpleGraph B →g ShortClosure.simpleGraph (graph A B) where
+  toFun := Sum.inr
+  map_rel' := by
+    rintro a b ⟨hab,d,ha,hb⟩
+    exact ⟨fun h=>hab (Sum.inr.inj h),Sum.inr d,congrArg Sum.inr ha,congrArg Sum.inr hb⟩
+end TorsionFreeZeroDivisors.SumPort
+namespace TorsionFreeZeroDivisors.ConcreteFactors
+
+section
+open scoped Classical
+open SampleGraph ConcreteGroup
+variable {rep : ℕ} (r : ActualPatternEvent.Match rep) (x : VA rep) (y : VB rep)
+  (hL : 2≤GirthAsymptotics.L (TypedGraphs.size rep)) (hd : GraphSample.Diameters rep r)
+  (hsample : r∈ActualPatternEvent.samples rep)
+  (hsep : Picture.SeparatorObligation r x y hL hd)
+  (havoid : IsEmpty (BoundedSystem (PlanarParameters.C PathSystem.ε ClosedWords.D)
+    (PlanarParameters.K PathSystem.ε ClosedWords.D) (PlanarParameters.sides PathSystem.ε ClosedWords.D) rep r x y))
+include hsample hsep havoid
+/-- Source disk nontriviality suffices for the literal left factor, without
+assuming distinctness of the other vertex values. The sharp separator is the
+explicit still-unclosed premise, not an axiom or a claim of the main theorem. -/
+theorem alpha_nonzero_of_separator : alpha rep r x≠0 := by
+  apply alpha_nonzero rep r x
+  intro a ha
+  apply Subtype.ext
+  by_contra hn
+  have hp := a.property.map (SumPort.leftHom (A rep r) (B rep r))
+  have he : value rep r (Sum.inl x)=value rep r (Sum.inl a.val) := by
+    have ha' : (value rep r (Sum.inl x))⁻¹*value rep r (Sum.inl a.val)=1 := ha
+    exact inv_mul_eq_one.mp ha'
+  obtain ⟨n,b,hb⟩ := equal_value_picture r hp
+    (fun he=>hn (Sum.inl.inj he).symm) he
+  exact Picture.excluded b (fun he=>hn (Sum.inl.inj he).symm) hb (Or.inl rfl)
+    hL hd hsample (hsep _ _ n b _ hb (Or.inl rfl)) havoid
+/-- The right factor's identity coefficient is likewise exactly one; its
+inversion does not require a global component embedding theorem. -/
+theorem beta_nonzero_of_separator : beta rep r y≠0 := by
+  apply beta_nonzero rep r y
+  intro a ha
+  apply Subtype.ext
+  by_contra hn
+  have hp := a.property.map (SumPort.rightHom (A rep r) (B rep r))
+  have he : value rep r (Sum.inr y)=value rep r (Sum.inr a.val) := by
+    have ha' : (value rep r (Sum.inr y))⁻¹*value rep r (Sum.inr a.val)=1 := ha
+    exact inv_mul_eq_one.mp ha'
+  obtain ⟨n,b,hb⟩ := equal_value_picture r hp
+    (fun he=>hn (Sum.inr.inj he).symm) he
+  exact Picture.excluded b (fun he=>hn (Sum.inr.inj he).symm) hb (Or.inr rfl)
+    hL hd hsample (hsep _ _ n b _ hb (Or.inr rfl)) havoid
+
+end
+open scoped Classical
+open SampleGraph
+variable {rep : ℕ} (r : ActualPatternEvent.Match rep) (x : VA rep) (y : VB rep)
+  (hL : 2≤GirthAsymptotics.L (TypedGraphs.size rep)) (hd : GraphSample.Diameters rep r)
+  (hsample : r∈ActualPatternEvent.samples rep)
+  (havoid : IsEmpty (BoundedSystem (PlanarParameters.C PathSystem.ε ClosedWords.D)
+    (PlanarParameters.K PathSystem.ε ClosedWords.D) (PlanarParameters.sides PathSystem.ε ClosedWords.D) rep r x y))
+include hL hd hsample havoid
+/-- Both original factors are now unconditionally nonzero for the sampled
+no-arrangement graphs. The literal sharp separator is proved, not assumed. -/
+theorem both_nonzero : alpha rep r x≠0 ∧ beta rep r y≠0 := by
+  have hs := Picture.separator_obligation r x y hL hd
+  exact ⟨alpha_nonzero_of_separator r x y hL hd hsample hs havoid,
+    beta_nonzero_of_separator r x y hL hd hsample hs havoid⟩
+end TorsionFreeZeroDivisors.ConcreteFactors
+
+namespace TorsionFreeZeroDivisors.SampleGraph
+open scoped Classical
+open Filter GirthAsymptotics TypedGraphs
+/-- An actual sample with both nonzero factors in its exact finitely presented
+group. Torsion-freeness and the topological classifying-space clause are NOT
+asserted here; they remain obligations for the main theorem. -/
+theorem exists_nonzero_factors :
+    ∃ (rep : ℕ) (r : ActualPatternEvent.Match rep) (x : VA rep) (y : VB rep),
+      r∈ActualPatternEvent.samples rep ∧ 2≤L (size rep) ∧
+      GraphSample.Diameters rep r ∧
+      IsEmpty (BoundedSystem (PlanarParameters.C PathSystem.ε ClosedWords.D)
+        (PlanarParameters.K PathSystem.ε ClosedWords.D)
+        (PlanarParameters.sides PathSystem.ε ClosedWords.D) rep r x y) ∧
+      ConcreteFactors.alpha rep r x≠0 ∧ ConcreteFactors.beta rep r y≠0 ∧
+      ConcreteFactors.alpha rep r x*ConcreteFactors.beta rep r y=0 := by
+  have he := exists_avoiding (PlanarParameters.C PathSystem.ε ClosedWords.D)
+    (PlanarParameters.K PathSystem.ε ClosedWords.D)
+    (PlanarParameters.sides PathSystem.ε ClosedWords.D)
+    (PlanarParameters.K_pos _ _) (PlanarParameters.sides_pos _ _)
+  have hL := (L_tendsto.comp size_tendsto).eventually (eventually_ge_atTop 2)
+  obtain ⟨rep,hrep,hL,hpos⟩ := (he.and (hL.and (eventually_ge_atTop 1))).exists
+  let : NeZero rep := ⟨by omega⟩
+  let x : VA rep := Classical.choice inferInstance
+  let y : VB rep := Classical.choice inferInstance
+  obtain ⟨r,hr,hd,ha⟩ := hrep x y
+  obtain ⟨hx,hy⟩ := ConcreteFactors.both_nonzero r x y hL hd hr ha
+  exact ⟨rep,r,x,y,hr,hL,hd,ha,hx,hy,ConcreteFactors.product_zero rep r x y⟩
+end TorsionFreeZeroDivisors.SampleGraph
+
+namespace TorsionFreeZeroDivisors
+/-- Complete algebraic zero-divisor part of the construction, without the
+still-missing ordinary torsion-free and finite K(G,1) conclusions. -/
+theorem finitely_presented_zero_divisors :
+    ∃ (G : Type) (inst : Group G), letI : Group G := inst
+      Group.IsFinitelyPresented G ∧
+      ∃ α β : MonoidAlgebra (ZMod 2) G, α≠0 ∧ β≠0 ∧ α*β=0 := by
+  obtain ⟨rep,r,x,y,_,_,_,_,hx,hy,hz⟩ := SampleGraph.exists_nonzero_factors
+  exact ⟨ConcreteGroup.G rep r,inferInstance,inferInstance,
+    ConcreteFactors.alpha rep r x,ConcreteFactors.beta rep r y,hx,hy,hz⟩
+end TorsionFreeZeroDivisors
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/GroupRing/TypedDiameter.lean b/lean/OAI/Algebra/GroupRing/TypedDiameter.lean
new file mode 100644
index 0000000000000000000000000000000000000000..af1e3f9546d7aaeadfd2baafc3fee0a590757ac9
--- /dev/null
+++ b/lean/OAI/Algebra/GroupRing/TypedDiameter.lean
@@ -0,0 +1,379 @@
+import Mathlib
+import OAI.Algebra.GroupRing.ExpansionDiameter
+
+namespace OAI
+
+noncomputable section
+
+namespace TorsionFreeZeroDivisors.TypedDiameter
+open Filter ConditionedMatchings MatchingDiameter DiameterProbability
+open GirthAsymptotics TypedGraphs TorsionFreeZeroDivisors.Types
+open scoped Topology Classical BigOperators
+
+/-- A conservative effective prescription coefficient, for the diameter
+union bound only. The empirical letter density remains 129/16513. -/
+def p₀ : ℝ := 129/(4*16513)
+def C₀ : ℝ := 9*(12*(132:ℝ)^2/p₀)^65
+def ρ : ℝ := min (1/4) (min (p₀/65) (1/(2*C₀+2)))
+def B (n : ℕ) : ℕ := ⌊ρ*n⌋₊
+def R (rep : ℕ) : ℕ := 2130177*rep
+
+theorem p₀_pos : 0<p₀ := by norm_num [p₀]
+theorem p₀_le_one : p₀ ≤ 1 := by norm_num [p₀]
+theorem C₀_pos : 0<C₀ := by unfold C₀; have := p₀_pos; positivity
+
+theorem ρ_pos : 0<ρ := by
+  unfold ρ
+  exact lt_min (by norm_num) (lt_min (div_pos p₀_pos (by norm_num))
+    (div_pos (by norm_num) (by have := C₀_pos; positivity)))
+
+theorem ρ_le_quarter : ρ ≤ 1/4 := min_le_left _ _
+theorem ρ_le_one : ρ ≤ 1 := ρ_le_quarter.trans (by norm_num)
+theorem ρ_small : C₀*ρ^62 ≤ 1/2 := by
+  have hle : ρ ≤ 1/(2*C₀+2) := (min_le_right _ _).trans (min_le_right _ _)
+  have hmul : C₀*ρ ≤ 1/2 := by
+    have hx := (le_div_iff₀ (show 0<2*C₀+2 by have := C₀_pos; positivity)).mp hle
+    have := ρ_pos
+    nlinarith
+  have hpow : ρ^62 ≤ ρ := by
+    simpa only [pow_one] using (pow_le_pow_of_le_one (le_of_lt ρ_pos) ρ_le_one (by norm_num : 1 ≤ 62))
+  exact (mul_le_mul_of_nonneg_left hpow (le_of_lt C₀_pos)).trans hmul
+
+theorem B_le (n : ℕ) : (B n:ℝ) ≤ ρ*n := Nat.floor_le (by have := ρ_pos; positivity)
+
+theorem twice_B_le (n : ℕ) : 2*B n ≤ n := by
+  have h := B_le n
+  have hg := mul_le_mul_of_nonneg_right ρ_le_quarter (Nat.cast_nonneg n)
+  have : (2:ℝ)*B n ≤ n := by linarith
+  exact_mod_cast this
+
+theorem sixtyfive_B_le (n : ℕ) : (65*B n:ℝ) ≤ p₀*n := by
+  have hρ : ρ ≤ p₀/65 := (min_le_right _ _).trans (min_le_left _ _)
+  have h := B_le n
+  have hg := mul_le_mul_of_nonneg_right hρ (Nat.cast_nonneg n)
+  linarith
+
+theorem R_eq (rep : ℕ) : (R rep:ℝ) = 2*p₀*size rep := by
+  unfold R p₀ size
+  push_cast
+  ring
+
+theorem carrier_eq (rep : ℕ) : (4260354*rep:ℝ) = 4*p₀*size rep := by
+  unfold p₀ size
+  push_cast
+  ring
+
+theorem eventual_denom : ∀ᶠ rep : ℕ in atTop,
+    R rep+65*B (size rep)+4*132^(2*(3*L (size rep))+1) ≤ 4260354*rep := by
+  filter_upwards [size_tendsto.eventually (eventual_small p₀ p₀_pos)] with rep h
+  have he : (4*132^(2*(3*L (size rep))+1):ℝ) < p₀*size rep := by
+    simpa only [exclusion,Nat.cast_mul,Nat.cast_pow,Nat.cast_ofNat,
+      show 2*(3*L (size rep))=6*L (size rep) by omega] using h
+  have hr := R_eq rep
+  have hc := carrier_eq rep
+  have hb := sixtyfive_B_le (size rep)
+  have hh : (R rep:ℝ)+65*B (size rep)+4*132^(2*(3*L (size rep))+1) ≤
+      4260354*rep := by linarith
+  exact_mod_cast hh
+
+theorem witness_summable (n : ℕ) (hn : 0<n) :
+    Summable (fun k : ℕ => witnessTerm C₀ ρ n k) := by
+  apply Summable.of_norm_bounded (summable_geometric_of_abs_lt_one (by norm_num : |(1/2:ℝ)|<1))
+  intro k
+  exact witnessTerm_majorant (le_of_lt C₀_pos) ρ_small n k hn
+
+/-- The exact empirical A-side conditioned sample space. -/
+abbrev ΩA (rep : ℕ) := Matching.conditioned
+  (label:=TypedGraphs.label (@outgoingA rep)) (bar:=inverse)
+  (TypedGraphs.origin (@outgoingA rep)) (3*L (size rep)) ∅
+abbrev ΩB (rep : ℕ) := Matching.conditioned
+  (label:=TypedGraphs.label (@outgoingB rep)) (bar:=inverse)
+  (TypedGraphs.origin (@outgoingB rep)) (3*L (size rep)) ∅
+
+def badA (rep : ℕ) := failure
+  (label:=TypedGraphs.label (@outgoingA rep)) (bar:=inverse)
+  (TypedGraphs.origin (@outgoingA rep)) (B (size rep)) (3*L (size rep))
+def badB (rep : ℕ) := failure
+  (label:=TypedGraphs.label (@outgoingB rep)) (bar:=inverse)
+  (TypedGraphs.origin (@outgoingB rep)) (B (size rep)) (3*L (size rep))
+
+/-- Instantiation retains the actual vertex types, degree range, letter
+carriers and prescribed girth conditioning. -/
+theorem typed_bound {V : Type*} [Fintype V] (outgoing : V → Finset Letter)
+    (rep : ℕ) (hrep : 0<rep) (hc : Fintype.card V=size rep)
+    (hd : ∀ v, 129 ≤ (outgoing v).card ∧ (outgoing v).card ≤ 132)
+    (hl : ∀ t, Fintype.card {v : V // t∈outgoing v}=4260354*rep)
+    (hden : R rep+65*B (size rep)+4*132^(2*(3*L (size rep))+1) ≤ 4260354*rep)
+    (hΩ : (Matching.conditioned (label:=TypedGraphs.label outgoing) (bar:=inverse)
+      (TypedGraphs.origin outgoing) (3*L (size rep)) ∅).Nonempty) :
+    (failure (label:=TypedGraphs.label outgoing) (bar:=inverse)
+      (TypedGraphs.origin outgoing) (B (size rep)) (3*L (size rep))).card /
+      ((Matching.conditioned (label:=TypedGraphs.label outgoing) (bar:=inverse)
+        (TypedGraphs.origin outgoing) (3*L (size rep)) ∅).card:ℝ) ≤
+      ∑' k : ℕ, witnessTerm C₀ ρ (size rep) k := by
+  have hn : 0<size rep := by unfold size; positivity
+  have hh := failure_probability_bound (TypedGraphs.origin outgoing)
+    (B (size rep)) (3*L (size rep)) 132 (R rep) p₀ ρ
+    inverse_ne (by norm_num)
+    (fun v => by rw [origin_card]; exact (hd v).1)
+    (fun v => by rw [origin_card]; exact (hd v).2)
+    (by rw [hc]; exact twice_B_le _)
+    (by rw [hc]; exact B_le _)
+    p₀_pos p₀_le_one ρ_le_one
+    (by rw [hc,R_eq]; have := p₀_pos; nlinarith [Nat.cast_nonneg (α:=ℝ) (size rep)])
+    (by unfold R; positivity)
+    (fun x => by rw [label_card,hl]; exact hden)
+    hΩ (by rw [hc]; exact witness_summable _ hn)
+  simpa only [hc,C₀,Nat.cast_ofNat] using hh
+
+theorem eventual_bound : ∀ᶠ rep : ℕ in atTop,
+    (badA rep).card/((ΩA rep).card:ℝ) ≤ ∑' k : ℕ, witnessTerm C₀ ρ (size rep) k ∧
+    (badB rep).card/((ΩB rep).card:ℝ) ≤ ∑' k : ℕ, witnessTerm C₀ ρ (size rep) k := by
+  filter_upwards [eventual_denom,eventual_nonempty,eventually_gt_atTop 0] with rep hd hΩ hr
+  exact ⟨typed_bound _ rep hr (card_vertexA rep) degreeA_bounds (letter_frequencyA rep) hd hΩ.1,
+    typed_bound _ rep hr (card_vertexB rep) degreeB_bounds (letter_frequencyB rep) hd hΩ.2⟩
+
+theorem failureA_tendsto : Tendsto (fun rep : ℕ => (badA rep).card/((ΩA rep).card:ℝ))
+    atTop (𝓝 0) := by
+  apply squeeze_zero' (Filter.Eventually.of_forall (by intro rep; positivity))
+    (eventual_bound.mono (fun _ h => h.1))
+  exact (witness_sum_tendsto (le_of_lt C₀_pos) ρ_small).comp size_tendsto
+
+theorem failureB_tendsto : Tendsto (fun rep : ℕ => (badB rep).card/((ΩB rep).card:ℝ))
+    atTop (𝓝 0) := by
+  apply squeeze_zero' (Filter.Eventually.of_forall (by intro rep; positivity))
+    (eventual_bound.mono (fun _ h => h.2))
+  exact (witness_sum_tendsto (le_of_lt C₀_pos) ρ_small).comp size_tendsto
+
+/-- The deterministic constant in the manifestation of the diameter lemma. -/
+def A₀ : ℕ := ⌈1/ρ⌉₊
+def D₀ : ℕ := (A₀+1)*803
+
+theorem packing_bound (n : ℕ) : n/(B n+1) ≤ A₀ := by
+  have hfloor : ρ*n ≤ (B n:ℝ)+1 := (Nat.lt_floor_add_one (ρ*n)).le
+  have hceil : 1/ρ ≤ (A₀:ℝ) := Nat.le_ceil _
+  have hi : 1 ≤ ρ*(A₀:ℝ) := by
+    have := (div_le_iff₀ ρ_pos).mp hceil
+    nlinarith
+  have h1 := mul_le_mul_of_nonneg_right hi (Nat.cast_nonneg (α:=ℝ) n)
+  have h2 := mul_le_mul_of_nonneg_right hfloor (Nat.cast_nonneg (α:=ℝ) A₀)
+  have h3 : (n:ℝ) ≤ ((B n:ℝ)+1)*A₀ := by nlinarith
+  apply Nat.div_le_of_le_mul
+  exact_mod_cast h3
+
+theorem log_radius_bound (n : ℕ) (hL : 1 ≤ L n) :
+    2*(Nat.log 2 n+1)+1 ≤ 803*L n := by
+  have hlog : (Nat.log 2 n:ℝ)*Real.log 2 ≤ Real.log n := by
+    have := Real.natLog_le_logb n 2
+    rw [Real.logb] at this
+    norm_num only [Nat.cast_ofNat] at this
+    exact (le_div_iff₀ (by linarith [Real.log_two_gt_d9])).mp this
+  have hg := mul_le_mul_of_nonneg_left
+    (show (1/2:ℝ) ≤ Real.log 2 by linarith [Real.log_two_gt_d9])
+    (Nat.cast_nonneg (α:=ℝ) (Nat.log 2 n))
+  have hl : Real.log n/100 < (L n:ℝ)+1 := Nat.lt_floor_add_one _
+  have hL' : (1:ℝ) ≤ L n := by exact_mod_cast hL
+  have hr : (Nat.log 2 n:ℝ) ≤ 400*L n := by nlinarith
+  have hr' : Nat.log 2 n ≤ 400*L n := by exact_mod_cast hr
+  omega
+
+/-- This is the precise fixed-constant O(L) conclusion on the expansion
+complement, with no degree or matching independence assumption. -/
+theorem component_diameter {V D T : Type*} [Fintype V] [Fintype D]
+    (origin : D → V) {label : D → T} {bar : T → T} (n N : ℕ)
+    (hc : Fintype.card V=n) (hL : 1 ≤ L n) (r : Matching label bar)
+    (hr : r∈Matching.conditioned (label:=label) (bar:=bar) origin N ∅)
+    (hf : r∉failure (label:=label) (bar:=bar) origin (B n) N)
+    {u v : V} (huv : (simpleGraph origin r).Reachable u v) :
+    (simpleGraph origin r).dist u v ≤ D₀*L n := by
+  have hpow : B n < 2^(Nat.log 2 n+1) :=
+    (show B n ≤ n by have := twice_B_le n; omega).trans_lt
+      (Nat.lt_pow_succ_log_self (by norm_num) n)
+  have hh := diameter_of_not_failure origin (B n) N (Nat.log 2 n+1) r hr hf hpow huv
+  rw [hc] at hh
+  have hm := Nat.mul_le_mul (Nat.add_le_add_right (packing_bound n) 1)
+    (log_radius_bound n hL)
+  unfold D₀
+  calc
+    _ ≤ (n/(B n+1)+1)*(2*(Nat.log 2 n+1)+1) := hh.le
+    _ ≤ (A₀+1)*(803*L n) := hm
+    _ = _ := by ring
+
+/-- The A-side actual diameter-failure event, still conditioned on girth. -/
+def diameterBadA (rep : ℕ) := (ΩA rep).filter fun r =>
+  ∃ u v, (simpleGraph (TypedGraphs.origin (@outgoingA rep)) r).Reachable u v ∧
+    D₀*L (size rep) < (simpleGraph (TypedGraphs.origin (@outgoingA rep)) r).dist u v
+def diameterBadB (rep : ℕ) := (ΩB rep).filter fun r =>
+  ∃ u v, (simpleGraph (TypedGraphs.origin (@outgoingB rep)) r).Reachable u v ∧
+    D₀*L (size rep) < (simpleGraph (TypedGraphs.origin (@outgoingB rep)) r).dist u v
+
+theorem diameterBadA_subset (rep : ℕ) (hL : 1 ≤ L (size rep)) :
+    diameterBadA rep ⊆ badA rep := by
+  intro r hr
+  obtain ⟨hr,u,v,huv,hlt⟩ := Finset.mem_filter.mp hr
+  by_contra hf
+  exact (not_lt_of_ge (component_diameter _ _ _ (card_vertexA rep) hL r hr hf huv)) hlt
+
+theorem diameterBadB_subset (rep : ℕ) (hL : 1 ≤ L (size rep)) :
+    diameterBadB rep ⊆ badB rep := by
+  intro r hr
+  obtain ⟨hr,u,v,huv,hlt⟩ := Finset.mem_filter.mp hr
+  by_contra hf
+  exact (not_lt_of_ge (component_diameter _ _ _ (card_vertexB rep) hL r hr hf huv)) hlt
+
+/-- Diameter bound for the literal A empirical type table. -/
+theorem diameterA_tendsto :
+    Tendsto (fun rep : ℕ => (diameterBadA rep).card/((ΩA rep).card:ℝ)) atTop (𝓝 0) := by
+  apply squeeze_zero' (Filter.Eventually.of_forall (by intro rep; positivity)) _ failureA_tendsto
+  filter_upwards [(L_tendsto.comp size_tendsto).eventually_ge_atTop 1] with rep hL
+  apply div_le_div_of_nonneg_right _ (by positivity)
+  exact_mod_cast Finset.card_le_card (diameterBadA_subset rep hL)
+
+/-- Diameter bound for the literal B empirical type table. -/
+theorem diameterB_tendsto :
+    Tendsto (fun rep : ℕ => (diameterBadB rep).card/((ΩB rep).card:ℝ)) atTop (𝓝 0) := by
+  apply squeeze_zero' (Filter.Eventually.of_forall (by intro rep; positivity)) _ failureB_tendsto
+  filter_upwards [(L_tendsto.comp size_tendsto).eventually_ge_atTop 1] with rep hL
+  apply div_le_div_of_nonneg_right _ (by positivity)
+  exact_mod_cast Finset.card_le_card (diameterBadB_subset rep hL)
+
+end TorsionFreeZeroDivisors.TypedDiameter
+namespace TorsionFreeZeroDivisors.FiniteJointAvoidance
+open scoped Classical
+lemma exists_outside {A B : Type} (s : Finset A) (t : Finset B) (a : Finset A) (b : Finset B)
+    (P : A×B → Prop) (hs : s.Nonempty) (ht : t.Nonempty)
+    (hp : (((s×ˢt).filter P).card:ℝ)/(s.card*t.card:ℕ)<1/3)
+    (ha : (a.card:ℝ)/s.card<1/3) (hb : (b.card:ℝ)/t.card<1/3) :
+    ∃ r∈s×ˢt,r.1∉a ∧ r.2∉b ∧ ¬P r := by
+  by_contra hn
+  push Not at hn
+  have hsub : s×ˢt ⊆ ((s×ˢt).filter P) ∪ ((a×ˢt) ∪ (s×ˢb)) := by
+    intro r hr
+    by_cases hp : P r
+    · exact Finset.mem_union_left _ (Finset.mem_filter.mpr ⟨hr,hp⟩)
+    apply Finset.mem_union_right
+    have hh := hn r hr
+    have hm := Finset.mem_product.mp hr
+    by_cases he : r.1∈a
+    · exact Finset.mem_union_left _ (Finset.mem_product.mpr ⟨he,hm.2⟩)
+    · have hf : r.2∈b := by by_contra hb; exact hp (hh he hb)
+      exact Finset.mem_union_right _ (Finset.mem_product.mpr ⟨hm.1,hf⟩)
+  have hc := (Finset.card_le_card hsub).trans (Finset.card_union_le _ _)
+  have hc' := Finset.card_union_le (a×ˢt) (s×ˢb)
+  rw [Finset.card_product] at hc
+  simp only [Finset.card_product] at hc'
+  have hc'' : s.card*t.card≤((s×ˢt).filter P).card+a.card*t.card+s.card*b.card := by omega
+  have hsr : (0:ℝ)<s.card := by exact_mod_cast Finset.card_pos.mpr hs
+  have htr : (0:ℝ)<t.card := by exact_mod_cast Finset.card_pos.mpr ht
+  have hpr := (div_lt_iff₀ (mul_pos hsr htr)).mp (by simpa only [Nat.cast_mul] using hp)
+  have har := mul_lt_mul_of_pos_right ((div_lt_iff₀ hsr).mp ha) htr
+  have hbr := mul_lt_mul_of_pos_left ((div_lt_iff₀ htr).mp hb) hsr
+  have hcr : (s.card:ℝ)*t.card≤((s×ˢt).filter P).card+a.card*t.card+s.card*b.card := by exact_mod_cast hc''
+  nlinarith
+end TorsionFreeZeroDivisors.FiniteJointAvoidance
+
+namespace TorsionFreeZeroDivisors.MatchingAlias
+open scoped Classical
+lemma conditioned_eq {V : Type} [Fintype V] (outgoing : V → Finset Types.Letter) (N : ℕ) :
+    ConditionedMatchings.Matching.conditioned (label:=TypedGraphs.label outgoing)
+      (bar:=Types.inverse) (TypedGraphs.origin outgoing) N ∅ =
+    ConditionedMatchings.Matching.conditioned (label:=PatternEmbeddings.label outgoing)
+      (bar:=Types.inverse) (PatternEmbeddings.origin outgoing) N ∅ := by
+  unfold TypedGraphs.label TypedGraphs.origin PatternEmbeddings.label PatternEmbeddings.origin
+  ext r
+  simp only [ConditionedMatchings.Matching.conditioned,Finset.mem_filter,Finset.mem_univ,true_and]
+end TorsionFreeZeroDivisors.MatchingAlias
+
+namespace TorsionFreeZeroDivisors.GraphSample
+open scoped Classical
+open GirthAsymptotics TypedGraphs ActualPatternEvent Filter
+
+lemma samples_eq (rep : ℕ) : samples rep = TypedDiameter.ΩA rep ×ˢ TypedDiameter.ΩB rep := by
+  apply Finset.ext
+  intro r
+  rw [BoundedPattern.mem_samples]
+  erw [Finset.mem_product]
+  simp only [TypedDiameter.ΩA,TypedDiameter.ΩB,
+    ConditionedMatchings.Matching.conditioned,Finset.mem_filter,Finset.mem_univ,true_and]
+  rfl
+
+/-- Both exact component diameter conclusions, including disconnected graphs. -/
+def Diameters (rep : ℕ) (r : Match rep) : Prop :=
+  (∀ u v,(MatchingDiameter.simpleGraph (TypedGraphs.origin (@Types.outgoingA rep)) r.1).Reachable u v →
+    (MatchingDiameter.simpleGraph (TypedGraphs.origin (@Types.outgoingA rep)) r.1).dist u v≤TypedDiameter.D₀*L (size rep)) ∧
+  (∀ u v,(MatchingDiameter.simpleGraph (TypedGraphs.origin (@Types.outgoingB rep)) r.2).Reachable u v →
+    (MatchingDiameter.simpleGraph (TypedGraphs.origin (@Types.outgoingB rep)) r.2).dist u v≤TypedDiameter.D₀*L (size rep))
+
+lemma diameters_of_not_bad (rep : ℕ) (r : Match rep) (hr : r∈samples rep)
+    (ha : r.1∉TypedDiameter.diameterBadA rep) (hb : r.2∉TypedDiameter.diameterBadB rep) :
+    Diameters rep r := by
+  have hm : r.1∈TypedDiameter.ΩA rep ∧ r.2∈TypedDiameter.ΩB rep := by
+    rw [samples_eq] at hr
+    exact Finset.mem_product.mp hr
+  constructor
+  · intro u v huv
+    by_contra h
+    exact ha (Finset.mem_filter.mpr ⟨hm.1,u,v,huv,Nat.lt_of_not_ge h⟩)
+  · intro u v huv
+    by_contra h
+    exact hb (Finset.mem_filter.mpr ⟨hm.2,u,v,huv,Nat.lt_of_not_ge h⟩)
+
+/-- The diameter event and the entire bounded-pattern avoidance event occur
+simultaneously in the literal conditional product sample. -/
+theorem bounded_with_diameter (R K T I B Q M J : ℕ)
+    (hR : 0<R) (hK : 0<K) (hI : 0<I) (hM : 0<M) :
+    ∀ᶠ rep in atTop,∀ (x : Types.VertexA rep) (y : Types.VertexB rep),
+      ∃ r∈samples rep,Diameters rep r ∧ ∀ a : BoundedPattern.Data R K T I (B*L (size rep)),
+        a.Good B Q M J rep → ¬a.event rep x y r := by
+  have hp := (BoundedPattern.polynomial_exp_tendsto (PatternTotalCoding.coefficient R K T I)
+    B (R+3*I) M hM).eventually_lt_const (by norm_num : (0:ℝ)<1/3)
+  have ha := TypedDiameter.diameterA_tendsto.eventually_lt_const (by norm_num : (0:ℝ)<1/3)
+  have hb := TypedDiameter.diameterB_tendsto.eventually_lt_const (by norm_num : (0:ℝ)<1/3)
+  filter_upwards [hp,ha,hb,BoundedPattern.samples_eventually_nonempty,
+    PatternUniform.eventually_ready B M Q J hM] with rep hp ha hb hs hu
+  intro x y
+  have hprob := (BoundedPattern.probability_union R K T I (B*L (size rep)) B Q M J rep
+    hR hK hI hM hs hu x y).trans_lt hp
+  rw [samples_eq] at hs hprob
+  have hn := Finset.nonempty_product.mp hs
+  have hprob' :
+      (((TypedDiameter.ΩA rep ×ˢ TypedDiameter.ΩB rep).filter
+        (fun r => ∃ a : BoundedPattern.Data R K T I (B*L (size rep)),a.Good B Q M J rep ∧ a.event rep x y r)).card:ℝ) /
+        ((TypedDiameter.ΩA rep).card*(TypedDiameter.ΩB rep).card:ℕ)<1/3 :=
+    Eq.mp (congrArg (fun n : ℕ =>
+      (((TypedDiameter.ΩA rep ×ˢ TypedDiameter.ΩB rep).filter
+        (fun r => ∃ a : BoundedPattern.Data R K T I (B*L (size rep)),a.Good B Q M J rep ∧ a.event rep x y r)).card:ℝ) /
+        (n:ℝ)<1/3) (Finset.card_product (TypedDiameter.ΩA rep) (TypedDiameter.ΩB rep))) hprob
+  obtain ⟨r,hr,hra,hrb,hrp⟩ := FiniteJointAvoidance.exists_outside
+    (TypedDiameter.ΩA rep) (TypedDiameter.ΩB rep)
+    (TypedDiameter.diameterBadA rep) (TypedDiameter.diameterBadB rep)
+    (fun r => ∃ a : BoundedPattern.Data R K T I (B*L (size rep)),a.Good B Q M J rep ∧ a.event rep x y r)
+    hn.1 hn.2 hprob' ha hb
+  have hr' : r∈samples rep := by
+    rw [samples_eq]
+    exact hr
+  refine ⟨r,hr',diameters_of_not_bad rep r hr' hra hrb,?_⟩
+  exact fun a hg he => hrp ⟨a,hg,he⟩
+
+/-- Source entropy proposition for arbitrary literal immersed path systems,
+with the independent short-closure diameter event included. -/
+theorem raw_with_diameter (B K I : ℕ) (hK : 0<K) (hI : 0<I) :
+    ∀ᶠ rep in atTop,∀ (x : Types.VertexA rep) (y : Types.VertexB rep),
+      ∃ r∈samples rep,Diameters rep r ∧ ∀ a : RawSourcePattern.Data B K I rep,¬a.event x y r := by
+  have hT : 0<SourcePattern.T B K := Nat.mul_pos (SourcePattern.R_pos B K) (by omega)
+  filter_upwards [bounded_with_diameter (SourcePattern.R B K) K (SourcePattern.T B K)
+    I B (SourcePattern.R B K) (SourcePattern.T B K) (I*(SourcePattern.T B K)^2)
+    (SourcePattern.R_pos B K) hK hI hT,
+    (L_tendsto.comp size_tendsto).eventually (eventually_ge_atTop 1)] with rep hr hL
+  change 1≤L (size rep) at hL
+  intro x y
+  obtain ⟨r,hs,hd,ha⟩ := hr x y
+  refine ⟨r,hs,hd,fun a he => ?_⟩
+  exact ha (a.suppressed.bounded (by omega)) (a.suppressed.bounded_good (by omega))
+    (a.suppressed_event x y r he)
+
+end TorsionFreeZeroDivisors.GraphSample
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/GroupRing/TypedGraphs.lean b/lean/OAI/Algebra/GroupRing/TypedGraphs.lean
new file mode 100644
index 0000000000000000000000000000000000000000..4b7d5059663cdcdaaf866a55179e060c29e37f67
--- /dev/null
+++ b/lean/OAI/Algebra/GroupRing/TypedGraphs.lean
@@ -0,0 +1,370 @@
+import Mathlib
+import OAI.Algebra.GroupRing.TwoSideFullStage
+
+namespace OAI
+
+noncomputable section
+
+namespace TorsionFreeZeroDivisors.TypedGraphs
+open Filter GirthAsymptotics TorsionFreeZeroDivisors.Types ConditionedMatchings PortSubdivision
+open scoped Topology
+
+/-- Admissible sizes are exactly the multiplicities of the empirical table. -/
+def size (rep : ℕ) : ℕ := 2 * 16513 ^ 2 * rep
+
+theorem size_tendsto : Tendsto size atTop atTop := by
+  apply tendsto_atTop_mono (f := fun n : ℕ => n) _ tendsto_id
+  intro n
+  dsimp [size]
+  omega
+
+theorem eventual_carrier : ∀ᶠ rep : ℕ in atTop,
+    4 * 132 ^ (2 * (3 * L (size rep)) + 1) < 4260354 * rep := by
+  have h := size_tendsto.eventually (eventual_small (4260354 / (2 * 16513^2)) (by norm_num))
+  filter_upwards [h] with rep hr
+  have he : (4260354 / (2 * 16513^2) : ℝ) * (size rep : ℝ) = 4260354 * rep := by
+    simp only [size,Nat.cast_mul,Nat.cast_pow,Nat.cast_ofNat]
+    ring
+  rw [he] at hr
+  have hr' : exclusion (size rep) < 4260354 * rep := by exact_mod_cast hr
+  simpa only [exclusion, show 2 * (3 * L (size rep)) = 6 * L (size rep) by omega] using hr'
+
+/-- Both jointly conditioned graph spaces really exist for all sufficiently
+large admissible sizes; no high-girth existence is a standing assumption. -/
+theorem eventual_nonempty : ∀ᶠ rep : ℕ in atTop,
+    (Matching.conditioned (label := label (@outgoingA rep)) (bar := inverse)
+      (origin (@outgoingA rep)) (3 * L (size rep)) ∅).Nonempty ∧
+    (Matching.conditioned (label := label (@outgoingB rep)) (bar := inverse)
+      (origin (@outgoingB rep)) (3 * L (size rep)) ∅).Nonempty := by
+  filter_upwards [eventual_carrier] with rep hr
+  exact ⟨conditionedA_nonempty _ _ hr,conditionedB_nonempty _ _ hr⟩
+
+/-- The simple-graph girth says exactly what is required of the original
+multigraph's immersed closed paths. Loops and parallel edges were not discarded. -/
+theorem reduced_circuit_length {V D : Type*} (Γ : PortGraph V D) (L : ℕ)
+    (hg : (3 * L : ℕ) ≤ Γ.subdivision.egirth) {v : V}
+    (p : Γ.Walk v v) (hp : p.IsReduced) (hne : 0 < p.length) : L ≤ p.length := by
+  have h := GirthSwitch.reduced_closed_length (3*L) hg p.toSubdivision
+    (by rw [p.length_toSubdivision]; omega) (p.reduced_toSubdivision hp)
+  rw [p.length_toSubdivision] at h
+  omega
+
+end TorsionFreeZeroDivisors.TypedGraphs
+
+namespace TorsionFreeZeroDivisors.TypedStage
+open scoped Classical BigOperators Topology
+open TorsionFreeZeroDivisors.Types TwoSideStage GirthAsymptotics Filter
+local instance : DecidableEq Types.Letter := Classical.decEq _
+
+variable {C V : Type} [Fintype C] [Fintype V]
+variable (rep : ℕ) (len : C → ℕ) (first last : C → V)
+
+abbrev sideA (pin : V → Option (VertexA rep)) : TwoSideStage.Side where
+  C := C
+  V := V
+  TV := VertexA rep
+  fC := inferInstance
+  fV := inferInstance
+  fTV := inferInstance
+  len := len
+  first := first
+  last := last
+  outgoing := @outgoingA rep
+  pin := pin
+
+abbrev sideB (pin : V → Option (VertexB rep)) : TwoSideStage.Side where
+  C := C
+  V := V
+  TV := VertexB rep
+  fC := inferInstance
+  fV := inferInstance
+  fTV := inferInstance
+  len := len
+  first := first
+  last := last
+  outgoing := @outgoingB rep
+  pin := pin
+
+theorem conditionsA (pin : V → Option (VertexA rep)) (N R : ℕ) (hR : 0 < R)
+    (hroom : R + ∑ c, len c + 4*132^(2*N+1) ≤ 4260354*rep) :
+    Conditions (sideA rep len first last pin) (TypedGraphs.size rep) (129/16513) N 132 R := by
+  refine ⟨by norm_num,?_,?_,by norm_num,hR,?_,?_,?_⟩
+  · change (Fintype.card (VertexA rep) : ℝ) ≤ (TypedGraphs.size rep : ℝ)
+    simp only [← Nat.card_eq_fintype_card]
+    rw [Nat.card_eq_fintype_card,card_vertexA]
+    exact le_rfl
+  · intro t u h
+    dsimp only [sideA]
+    rw [← Nat.card_eq_fintype_card]
+    simpa only [← Nat.card_eq_fintype_card, show Nat.card (VertexA rep) = TypedGraphs.size rep by
+      rw [Nat.card_eq_fintype_card,card_vertexA]; rfl] using TypeWeights.joint_countA_le rep t u h
+  · intro v
+    exact (TypedGraphs.origin_card (@outgoingA rep) v).le.trans (degreeA_bounds v).2
+  · intro x
+    change R + ∑ c, len c + 4*132^(2*N+1) ≤
+      Nat.card {a : TypedGraphs.Dart (@outgoingA rep) // TypedGraphs.label _ a = TypedGraphs.label _ x}
+    rw [TypedGraphs.label_card,letter_frequencyA]
+    exact hroom
+  · obtain ⟨r,hr⟩ := TypedGraphs.conditionedA_nonempty rep N (by omega)
+    refine ⟨r,?_⟩
+    dsimp only [sideA,Side.samples,ConditionedMatchings.Matching.conditioned]
+    apply Finset.mem_filter.mpr
+    refine ⟨Finset.mem_univ _,?_⟩
+    exact (Finset.mem_filter.mp hr).2
+
+theorem conditionsB (pin : V → Option (VertexB rep)) (N R : ℕ) (hR : 0 < R)
+    (hroom : R + ∑ c, len c + 4*132^(2*N+1) ≤ 4260354*rep) :
+    Conditions (sideB rep len first last pin) (TypedGraphs.size rep) (129/16513) N 132 R := by
+  refine ⟨by norm_num,?_,?_,by norm_num,hR,?_,?_,?_⟩
+  · change (Fintype.card (VertexB rep) : ℝ) ≤ (TypedGraphs.size rep : ℝ)
+    simp only [← Nat.card_eq_fintype_card]
+    rw [Nat.card_eq_fintype_card,card_vertexB]
+    exact le_rfl
+  · intro t u h
+    dsimp only [sideB]
+    rw [← Nat.card_eq_fintype_card]
+    simpa only [← Nat.card_eq_fintype_card, show Nat.card (VertexB rep) = TypedGraphs.size rep by
+      rw [Nat.card_eq_fintype_card,card_vertexB]; rfl] using (TypeWeights.joint_countB rep t u h).le
+  · intro v
+    exact (TypedGraphs.origin_card (@outgoingB rep) v).le.trans (degreeB_bounds v).2
+  · intro x
+    change R + ∑ c, len c + 4*132^(2*N+1) ≤
+      Nat.card {a : TypedGraphs.Dart (@outgoingB rep) // TypedGraphs.label _ a = TypedGraphs.label _ x}
+    rw [TypedGraphs.label_card,letter_frequencyB]
+    exact hroom
+  · obtain ⟨r,hr⟩ := TypedGraphs.conditionedB_nonempty rep N (by omega)
+    refine ⟨r,?_⟩
+    dsimp only [sideB,Side.samples,ConditionedMatchings.Matching.conditioned]
+    apply Finset.mem_filter.mpr
+    refine ⟨Finset.mem_univ _,?_⟩
+    exact (Finset.mem_filter.mp hr).2
+
+end TorsionFreeZeroDivisors.TypedStage
+
+namespace TorsionFreeZeroDivisors.StageCost
+open scoped BigOperators
+
+/-- The exact vertex/table/prescription factor, before the retained turn cost. -/
+def cost (n p r : ℝ) (f i e : ℕ) : ℝ := n^(f+i)*p^i/r^e
+
+theorem cost_exp (n p r : ℝ) (hn : 0<n) (hp : 0<p) (hr : 0<r) (f i e : ℕ) :
+    cost n p r f i e = Real.exp
+      ((((f:ℝ)+i-e)*Real.log n) + (((i:ℝ)-e)*Real.log p) +
+        e*Real.log (n*p/r)) := by
+  rw [Real.log_div (ne_of_gt (mul_pos hn hp)) (ne_of_gt hr),
+    Real.log_mul (ne_of_gt hn) (ne_of_gt hp)]
+  have he : (((f:ℝ)+i-e)*Real.log n) + (((i:ℝ)-e)*Real.log p) +
+      e*(Real.log n+Real.log p-Real.log r) =
+      (f+i:ℕ)*Real.log n + (i:ℝ)*Real.log p - (e:ℝ)*Real.log r := by
+    push_cast; ring
+  rw [he,Real.exp_sub,Real.exp_add,Real.exp_nat_mul,Real.exp_nat_mul,Real.exp_nat_mul,
+    Real.exp_log hn,Real.exp_log hp,Real.exp_log hr]
+  rfl
+
+theorem cost_chain_exp (n p r : ℝ) (hn : 0<n) (hp : 0<p) (hr : 0<r)
+    (f i e q : ℕ) (he : i+q=e) :
+    cost n p r f i e = Real.exp
+      (((f:ℝ)-q)*Real.log n - (q:ℝ)*Real.log p + e*Real.log (n*p/r)) := by
+  rw [cost_exp n p r hn hp hr]
+  congr 1
+  have he' : (i:ℝ)+q=e := by exact_mod_cast he
+  rw [←he']
+  ring
+
+/-- Uniform error bound, with a bounded number q of chains and e ≤ k L edges.
+It keeps the exact exponent f-q, including negative and zero cases. -/
+theorem uniform_bound (n p r : ℝ) (hn : 0<n) (hp : 0<p) (hp1 : p≤1)
+    (hr : 0<r) (hrnp : r≤n*p) (f i e q Q : ℕ) (he : i+q=e) (hq : q≤Q)
+    (k L : ℝ) (heL : (e:ℝ)≤k*L) :
+    cost n p r f i e ≤ Real.exp
+      (((f:ℝ)-q)*Real.log n + (Q:ℝ)*(-Real.log p) + k*L*Real.log (n*p/r)) := by
+  rw [cost_chain_exp n p r hn hp hr f i e q he]
+  apply Real.exp_le_exp.mpr
+  have hp' : 0 ≤ -Real.log p := neg_nonneg.mpr (Real.log_nonpos hp.le hp1)
+  have hr' : 0 ≤ Real.log (n*p/r) := Real.log_nonneg ((le_div_iff₀ hr).mpr (by simpa using hrnp))
+  have hq' := mul_le_mul_of_nonneg_right (show (q:ℝ)≤Q by exact_mod_cast hq) hp'
+  have he' := mul_le_mul_of_nonneg_right heL hr'
+  linarith
+
+theorem internal_add_chains {C : Type*} [Fintype C] (len : C → ℕ) (hpos : ∀c,0<len c) :
+    (∑c, (len c-1))+Fintype.card C=∑c,len c := by
+  classical
+  have h : (∑c : C, ((len c-1)+1)) = ∑c : C,len c := by
+    apply Finset.sum_congr rfl
+    intro c _
+    exact Nat.sub_add_cancel (hpos c)
+  simpa only [Finset.sum_add_distrib,Finset.sum_const,Finset.card_univ,smul_eq_mul,mul_one] using h
+
+end TorsionFreeZeroDivisors.StageCost
+
+namespace TorsionFreeZeroDivisors.StageDenominator
+
+section
+open scoped Topology
+open Filter GirthAsymptotics TypedGraphs
+
+def carrier (rep : ℕ) : ℕ := 4260354*rep
+def denominator (K rep : ℕ) : ℕ :=
+  carrier rep - (K*L (size rep)+exclusion (size rep))
+
+theorem carrier_eq (rep : ℕ) : (carrier rep : ℝ) = (size rep : ℝ)*(129/16513) := by
+  simp only [carrier,size,Nat.cast_mul,Nat.cast_pow,Nat.cast_ofNat]
+  ring
+
+theorem L_ratio : Tendsto (fun n : ℕ => (L n : ℝ)/n) atTop (𝓝 0) := by
+  have hlog : Tendsto (fun n : ℕ => Real.log (n:ℝ)/(n:ℝ)) atTop (𝓝 0) := by
+    simpa only [pow_one,one_mul,add_zero,Function.comp_def] using
+      (Real.tendsto_pow_log_div_mul_add_atTop 1 0 1 one_ne_zero).comp tendsto_natCast_atTop_atTop
+  have h := hlog.div_const 100
+  simp only [zero_div] at h
+  apply squeeze_zero' (Eventually.of_forall (fun _ => by positivity)) _ h
+  filter_upwards [eventually_ge_atTop 1] with n hn
+  have hn' : (1:ℝ)≤n := by exact_mod_cast hn
+  have hL : (L n:ℝ)≤Real.log (n:ℝ)/100 := Nat.floor_le (by positivity [Real.log_nonneg hn'])
+  calc
+    (L n:ℝ)/n ≤ (Real.log (n:ℝ)/100)/n := div_le_div_of_nonneg_right hL (by positivity)
+    _ = (Real.log (n:ℝ)/n)/100 := by ring
+
+theorem spent_ratio (K : ℕ) : Tendsto
+    (fun rep => ((K*L (size rep)+exclusion (size rep):ℕ):ℝ)/(size rep)) atTop (𝓝 0) := by
+  have h := ((L_ratio.comp size_tendsto).const_mul (K:ℝ)).add (exclusion_ratio.comp size_tendsto)
+  simpa only [mul_zero,add_zero,Nat.cast_add,Nat.cast_mul,add_div,mul_div_assoc,Function.comp_def] using h
+
+theorem eventually_room (K : ℕ) : ∀ᶠ rep in atTop,
+    K*L (size rep)+exclusion (size rep)<carrier rep := by
+  have h := (spent_ratio K).eventually_lt_const (by norm_num : (0:ℝ)<129/16513)
+  filter_upwards [h,size_tendsto.eventually (eventually_ge_atTop 1)] with rep hh hn
+  have hn0 : (0:ℝ)<size rep := by exact_mod_cast (show 0<size rep by omega)
+  have hh' := (div_lt_iff₀ hn0).mp hh
+  rw [mul_comm (129/16513:ℝ) (size rep),← carrier_eq] at hh'
+  exact_mod_cast hh'
+
+theorem eventually_pos (K : ℕ) : ∀ᶠ rep in atTop, 0<denominator K rep := by
+  filter_upwards [eventually_room K] with rep hr
+  exact Nat.sub_pos_of_lt hr
+
+theorem denominator_ratio (K : ℕ) : Tendsto
+    (fun rep => (denominator K rep:ℝ)/(size rep)) atTop (𝓝 (129/16513)) := by
+  have h := (tendsto_const_nhds (x := (129/16513:ℝ))).sub (spent_ratio K)
+  simp only [sub_zero] at h
+  apply h.congr'
+  filter_upwards [eventually_room K,size_tendsto.eventually (eventually_ge_atTop 1)] with rep hr hn
+  have hn0 : (size rep:ℝ)≠0 := by exact_mod_cast (show size rep≠0 by omega)
+  change (129/16513:ℝ) - _ = _
+  rw [denominator,Nat.cast_sub hr.le,sub_div,carrier_eq,mul_div_cancel_left₀ _ hn0]
+
+theorem relative_ratio (K : ℕ) : Tendsto
+    (fun rep => ((size rep:ℝ)*(129/16513))/(denominator K rep)) atTop (𝓝 1) := by
+  have h := (tendsto_const_nhds (x := (129/16513:ℝ))).div (denominator_ratio K) (by norm_num)
+  norm_num only [div_self (by norm_num : (129/16513:ℝ)≠0)] at h
+  apply h.congr'
+  apply Eventually.of_forall
+  intro rep
+  change (129/16513:ℝ) / ((denominator K rep:ℝ)/(size rep)) = _
+  rw [div_div_eq_mul_div]
+  ring
+
+def penalty (K rep : ℕ) : ℝ := Real.log ((size rep:ℝ)*(129/16513)/(denominator K rep))
+
+theorem penalty_tendsto (K : ℕ) : Tendsto (penalty K) atTop (𝓝 0) := by
+  change Tendsto (fun rep => Real.log ((size rep:ℝ)*(129/16513)/(denominator K rep))) _ _
+  have h := (Real.continuousAt_log one_ne_zero).tendsto.comp (relative_ratio K)
+  simpa only [Real.log_one,Function.comp_def] using h
+
+theorem penalty_nonneg (K rep : ℕ) (hr : 0 < denominator K rep) : 0 ≤ penalty K rep := by
+  apply Real.log_nonneg
+  apply (le_div_iff₀ (show (0:ℝ)<denominator K rep by exact_mod_cast hr)).mpr
+  simpa only [one_mul,←carrier_eq] using
+    (show (denominator K rep:ℝ)≤carrier rep from Nat.cast_le.mpr (Nat.sub_le ..))
+
+def error (K Q rep : ℕ) : ℝ :=
+  Q*(-Real.log (129/16513)) + (K:ℝ)*L (size rep)*penalty K rep
+
+theorem error_ratio (K Q : ℕ) : Tendsto
+    (fun rep => error K Q rep / (L (size rep):ℝ)) atTop (𝓝 0) := by
+  have hL : Tendsto (fun rep => (L (size rep):ℝ)) atTop atTop :=
+    tendsto_natCast_atTop_atTop.comp (L_tendsto.comp size_tendsto)
+  have hconst := (tendsto_inv_atTop_zero.comp hL).const_mul ((Q:ℝ)*(-Real.log (129/16513)))
+  have hpen := (penalty_tendsto K).const_mul (K:ℝ)
+  have h := hconst.add hpen
+  simp only [mul_zero,add_zero] at h
+  apply h.congr'
+  filter_upwards [(L_tendsto.comp size_tendsto).eventually (eventually_ge_atTop 1)] with rep hn
+  change 1≤L (size rep) at hn
+  have hn0 : (L (size rep):ℝ)≠0 := by exact_mod_cast (show L (size rep)≠0 by omega)
+  simp only [error,Function.comp_def]
+  field_simp
+
+end
+
+open scoped BigOperators Topology
+open Filter GirthAsymptotics TypedGraphs TwoSideStage
+
+/-- Each side has the SAME empirical carrier denominator, not the sum of the
+sizes of the two disjoint graphs. This bound is uniform in every stage. -/
+theorem room (K rep e : ℕ) (hr : K*L (size rep)+exclusion (size rep) ≤ carrier rep)
+    (he : e ≤ K*L (size rep)) :
+    denominator K rep+e+4*132^(2*(3*L (size rep))+1) ≤ 4260354*rep := by
+  have hh : 2*(3*L (size rep))=6*L (size rep) := by omega
+  rw [hh]
+  change denominator K rep+e+exclusion (size rep) ≤ carrier rep
+  dsimp only [denominator]
+  omega
+
+variable {C V : Type} [Fintype C] [Fintype V]
+
+theorem conditionsA (K rep : ℕ) (hr : K*L (size rep)+exclusion (size rep)<carrier rep)
+    (len : C → ℕ) (first last : C → V) (pin : V → Option (Types.VertexA rep))
+    (he : ∑c,len c ≤ K*L (size rep)) :
+    Conditions (TypedStage.sideA rep len first last pin) (size rep) (129/16513)
+      (3*L (size rep)) 132 (denominator K rep) :=
+  TypedStage.conditionsA rep len first last pin _ _ (Nat.sub_pos_of_lt hr)
+    (room K rep _ hr.le he)
+
+theorem conditionsB (K rep : ℕ) (hr : K*L (size rep)+exclusion (size rep)<carrier rep)
+    (len : C → ℕ) (first last : C → V) (pin : V → Option (Types.VertexB rep))
+    (he : ∑c,len c ≤ K*L (size rep)) :
+    Conditions (TypedStage.sideB rep len first last pin) (size rep) (129/16513)
+      (3*L (size rep)) 132 (denominator K rep) :=
+  TypedStage.conditionsB rep len first last pin _ _ (Nat.sub_pos_of_lt hr)
+    (room K rep _ hr.le he)
+
+/-- The edge/table cost is an exponential of f-q log n plus a uniform o(L),
+for two sides jointly. The signed value f-q is NOT replaced by its positive part. -/
+theorem joint_cost_bound (A B : Side) (K Q rep : ℕ) (hn : 0<size rep)
+    (hr : 0<denominator K rep) (ha : ∀c,0<A.len c) (hb : ∀c,0<B.len c)
+    (hQ : Fintype.card A.C+Fintype.card B.C ≤ Q)
+    (hE : A.edges+B.edges ≤ K*L (size rep)) :
+    A.cost (size rep) (129/16513) (denominator K rep) *
+      B.cost (size rep) (129/16513) (denominator K rep) ≤
+      Real.exp ((((A.freeMarks+B.freeMarks:ℕ):ℝ)-
+        (Fintype.card A.C+Fintype.card B.C:ℕ))*Real.log (size rep)+error K Q rep) := by
+  have hAI := StageCost.internal_add_chains A.len ha
+  have hBI := StageCost.internal_add_chains B.len hb
+  have he : A.internal+B.internal+(Fintype.card A.C+Fintype.card B.C)=A.edges+B.edges := by
+    dsimp only [Side.internal,Side.edges] at *
+    omega
+  have hrnp : (denominator K rep:ℝ) ≤ (size rep:ℝ)*(129/16513) := by
+    rw [←carrier_eq]
+    exact Nat.cast_le.mpr (Nat.sub_le ..)
+  have h := StageCost.uniform_bound (size rep) (129/16513) (denominator K rep)
+    (by exact_mod_cast hn) (by norm_num) (by norm_num) (by exact_mod_cast hr) hrnp
+    (A.freeMarks+B.freeMarks) (A.internal+B.internal) (A.edges+B.edges)
+    (Fintype.card A.C+Fintype.card B.C) Q he hQ K (L (size rep)) (by exact_mod_cast hE)
+  have hc : A.cost (size rep) (129/16513) (denominator K rep)*
+      B.cost (size rep) (129/16513) (denominator K rep) =
+      StageCost.cost (size rep) (129/16513) (denominator K rep)
+        (A.freeMarks+B.freeMarks) (A.internal+B.internal) (A.edges+B.edges) := by
+    rw [cost_product]
+    unfold StageCost.cost
+    have hex : A.freeMarks+A.internal+B.freeMarks+B.internal =
+        (A.freeMarks+B.freeMarks)+(A.internal+B.internal) := by omega
+    rw [hex]
+  rw [hc]
+  simpa only [error,penalty,add_assoc] using h
+
+end TorsionFreeZeroDivisors.StageDenominator
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/GroupRing/VertexCollapse.lean b/lean/OAI/Algebra/GroupRing/VertexCollapse.lean
new file mode 100644
index 0000000000000000000000000000000000000000..6d92c59583f2c71a8dc641603ef6db31b3ec6731
--- /dev/null
+++ b/lean/OAI/Algebra/GroupRing/VertexCollapse.lean
@@ -0,0 +1,48 @@
+import Mathlib
+import OAI.Algebra.GroupRing.GraphConeCW
+import OAI.Algebra.GroupRing.AttachmentHEP
+
+namespace OAI
+
+
+
+section
+namespace TorsionFreeZeroDivisors.VertexCollapse
+open Set Metric Topology GroupRingTopology GroupRingTopology.Attachment
+open scoped unitInterval
+noncomputable section
+variable {G S Q Y : Type} [Group G] [TopologicalSpace G] [DiscreteTopology G]
+  [TopologicalSpace Y] [PathConnectedSpace Y]
+variable (s : S→G) (a : Q→C(Sphere 2,Cayley.Graph s)) (f : C(CellPresentation.Cover s a,Y)) (y : Y)
+def vertexPath (g : G) : Path (f (CellPresentation.inclusion s a (Cayley.vertex s g))) y :=
+  PathConnectedSpace.somePath _ _
+def vertices : C(unitInterval × G,Y) :=
+  ((⟨fun g=>(vertexPath s a f y g).toContinuousMap,continuous_of_discreteTopology⟩ :
+    C(G,C(unitInterval,Y))).uncurry).comp ⟨Prod.swap,continuous_swap⟩
+lemma vertices_zero (g : G) : vertices s a f y (0,g)=f (CellPresentation.inclusion s a (Cayley.vertex s g)) :=
+  Path.source _
+lemma vertices_one (g : G) : vertices s a f y (1,g)=y := Path.target _
+def graph : C(unitInterval × Cayley.Graph s,Y) :=
+  AttachmentHEP.extend (equivariantFamily (G:=G) (Cayley.attaching s))
+    (f.comp (CellPresentation.inclusion s a)) (vertices s a f y) (vertices_zero s a f y)
+lemma graph_zero (z : Cayley.Graph s) : graph s a f y (0,z)=f (CellPresentation.inclusion s a z) :=
+  AttachmentHEP.extend_zero _ _ _ _ z
+lemma graph_vertex (t : unitInterval) (g : G) : graph s a f y (t,Cayley.vertex s g)=vertices s a f y (t,g) := rfl
+/-- Homotope an actual map on the whole presentation complex so that EVERY
+vertex goes to one basepoint. Both cell layers are extended, not collapsed by
+an unproved quotient/homotopy-equivalence assertion. -/
+def map : C(CellPresentation.Cover s a,Y) :=
+  AttachmentHEP.endpoint (equivariantFamily (G:=G) a) f (graph s a f y) (graph_zero s a f y)
+def homotopy : f.Homotopy (map s a f y) :=
+  AttachmentHEP.homotopy (equivariantFamily (G:=G) a) f (graph s a f y) (graph_zero s a f y)
+lemma map_vertex (g : G) : map s a f y (CellPresentation.inclusion s a (Cayley.vertex s g))=y :=
+  vertices_one s a f y g
+end
+end TorsionFreeZeroDivisors.VertexCollapse
+
+
+end
+
+
+
+end OAI
diff --git a/lean/OAI/Algebra/GroupRing/WeightedCycles.lean b/lean/OAI/Algebra/GroupRing/WeightedCycles.lean
new file mode 100644
index 0000000000000000000000000000000000000000..d7cdc2b1c661af26563ea1aeb83a18b974a78345
--- /dev/null
+++ b/lean/OAI/Algebra/GroupRing/WeightedCycles.lean
@@ -0,0 +1,431 @@
+import Mathlib
+
+namespace OAI
+
+noncomputable section
+
+namespace TorsionFreeZeroDivisors.WeightedCycles
+open SimpleGraph
+variable {V : Type*} {G : SimpleGraph V} {u v : V}
+
+/-- Expanded length, attached to undirected edges. -/
+def weight (w : Sym2 V → ℝ) (p : G.Walk u v) : ℝ := (p.edges.map w).sum
+
+@[simp] theorem weight_nil (w : Sym2 V → ℝ) (u : V) : weight w (G := G) (Walk.nil : G.Walk u u) = 0 := rfl
+@[simp] theorem weight_cons (w : Sym2 V → ℝ) {a b c : V} (h : G.Adj a b)
+    (p : G.Walk b c) : weight w (Walk.cons h p) = w s(a,b) + weight w p := rfl
+@[simp] theorem weight_append (w : Sym2 V → ℝ) {a b c : V}
+    (p : G.Walk a b) (q : G.Walk b c) : weight w (p.append q) = weight w p + weight w q := by
+  simp [weight]
+@[simp] theorem weight_reverse (w : Sym2 V → ℝ) (p : G.Walk u v) :
+    weight w p.reverse = weight w p := by simp [weight]
+
+theorem weight_nonneg (w : Sym2 V → ℝ) (hw : ∀ e, 0 ≤ w e) (p : G.Walk u v) :
+    0 ≤ weight w p := by
+  induction p with
+  | nil => simp
+  | cons h p ih => exact add_nonneg (hw _) ih
+
+theorem weight_le_of_subwalk (w : Sym2 V → ℝ) (hw : ∀ e, 0 ≤ w e)
+    {a b : V} {p : G.Walk u v} {q : G.Walk a b} (h : p.IsSubwalk q) :
+    weight w p ≤ weight w q := by
+  obtain ⟨l,r,rfl⟩ := h
+  simp only [weight_append]
+  linarith [weight_nonneg w hw l,weight_nonneg w hw r]
+
+/-- A nonbacktracking walk with a repeated vertex contains a cycle of no
+greater weight. Zero weights are permitted. -/
+theorem reduced_not_path_cycle (w : Sym2 V → ℝ) (hw : ∀ e, 0 ≤ w e)
+    (r : G.Walk u v) (hrr : r.edges.IsChain (· ≠ ·)) (hn : ¬r.IsPath) :
+    ∃ (a : V) (c : G.Walk a a), c.IsCycle ∧ weight w c ≤ weight w r := by
+  classical
+  induction r with
+  | nil => exact False.elim (hn (by simp))
+  | @cons a b c h r ih =>
+    have hcc := List.isChain_cons.mp (Walk.edges_cons _ _ ▸ hrr)
+    by_cases hpath : r.IsPath
+    · have hh : a ∈ r.support := by
+        by_contra hh
+        exact hn (Walk.cons_isPath_iff h r |>.mpr ⟨hpath,hh⟩)
+      have hz : 0 < r.length := by
+        by_contra hz
+        have hrnil := Walk.length_eq_zero_iff.mp (by omega : r.length = 0)
+        have he : a = b := by simpa [Walk.nil_iff_support_eq.mp hrnil] using hh
+        exact h.ne he
+      have hc : (Walk.cons h (r.takeUntil a hh)).IsCycle := by
+        simp only [Walk.isCycle_def,Walk.isTrail_def,Walk.edges_cons,List.nodup_cons,
+          ne_eq,reduceCtorEq,not_false_eq_true,Walk.support_cons,List.tail_cons,true_and]
+        have ht : (Walk.cons h (r.takeUntil a hh)).support.tail.Nodup :=
+          r.isPath_def.mp hpath |>.sublist <| List.IsInfix.sublist
+            ⟨[],(r.dropUntil a hh).support.tail,by simp [← Walk.support_append]⟩
+        refine ⟨⟨?_,Walk.edges_nodup_of_support_nodup ht⟩,ht⟩
+        by_contra he
+        refine hcc.1 s(a,b) ?_ rfl
+        rw [← r.cons_tail_eq (by simp [Walk.not_nil_iff_lt_length,hz])]
+        have hh' := Walk.IsPath.mk' ht |>.eq_snd_of_mem_edges (Sym2.eq_swap ▸ he)
+        simp [hh',Walk.snd_takeUntil h.ne]
+      refine ⟨a,_,hc,?_⟩
+      simpa only [weight_cons] using
+        (add_le_add (le_refl (w s(a,b))) (weight_le_of_subwalk w hw (r.isSubwalk_takeUntil hh)))
+    · obtain ⟨a',c',hc',hle⟩ := ih hcc.2 hpath
+      exact ⟨a',c',hc',by rw [weight_cons]; linarith [hw s(a,b)]⟩
+  
+/-- A nonbacktracking walk lighter than every cycle has no repeated vertex. -/
+theorem reduced_isPath_of_weight_lt (w : Sym2 V → ℝ) (hw : ∀ e, 0 ≤ w e)
+    (L : ℝ) (hG : ∀ a (c : G.Walk a a), c.IsCycle → L ≤ weight w c)
+    (p : G.Walk u v) (hp : weight w p < L) (hred : p.edges.IsChain (· ≠ ·)) :
+    p.IsPath := by
+  by_contra hn
+  obtain ⟨a,c,hc,hle⟩ := reduced_not_path_cycle w hw p hred hn
+  exact hp.not_ge ((hG a c hc).trans hle)
+
+/-- Two distinct immersed walks having the same endpoints contain a cycle
+whose expanded length is no greater than their combined expanded length. -/
+theorem distinct_reduced_cycle (w : Sym2 V → ℝ) (hw : ∀ e, 0 ≤ w e)
+    (p q : G.Walk u v) (hne : p ≠ q)
+    (hp : p.edges.IsChain (· ≠ ·)) (hq : q.edges.IsChain (· ≠ ·)) :
+    ∃ (a : V) (c : G.Walk a a), c.IsCycle ∧ weight w c ≤ weight w p + weight w q := by
+  classical
+  by_cases hpp : p.IsPath
+  · by_cases hqq : q.IsPath
+    · obtain ⟨a,b,p',q',hsubp,hsubq,hc⟩ := hpp.exists_isCycle_of_ne hqq hne
+      exact ⟨a,p'.append q'.reverse,hc,by
+        simp only [weight_append,weight_reverse]
+        exact add_le_add (weight_le_of_subwalk w hw hsubp) (weight_le_of_subwalk w hw hsubq)⟩
+    · obtain ⟨a,c,hc,hle⟩ := reduced_not_path_cycle w hw q hq hqq
+      exact ⟨a,c,hc,by linarith [weight_nonneg w hw p]⟩
+  · obtain ⟨a,c,hc,hle⟩ := reduced_not_path_cycle w hw p hp hpp
+    exact ⟨a,c,hc,by linarith [weight_nonneg w hw q]⟩
+
+end TorsionFreeZeroDivisors.WeightedCycles
+namespace TorsionFreeZeroDivisors.WeightedMoore
+open scoped BigOperators
+
+/-- A chain of `k+1` directed edges, including chains of zero probability. -/
+@[reducible] def Chain (D : Type*) : ℕ → Type _
+  | 0 => D
+  | k+1 => D × Chain D k
+
+instance {D : Type*} [Fintype D] (k : ℕ) : Fintype (Chain D k) := by
+  induction k with
+  | zero => exact inferInstanceAs (Fintype D)
+  | succ k ih => exact inferInstanceAs (Fintype (D × Chain D k))
+
+def head {D : Type*} : {k : ℕ} → Chain D k → D
+  | 0, p => p
+  | _+1, p => p.1
+
+def last {D : Type*} : {k : ℕ} → Chain D k → D
+  | 0, p => p
+  | _+1, p => last p.2
+
+def cost {D : Type*} (len : D → ℝ) : {k : ℕ} → Chain D k → ℝ
+  | 0, p => len p
+  | _+1, p => len p.1 + cost len p.2
+
+def mass {D : Type*} [Fintype D] (T : D → D → ℝ) : {k : ℕ} → Chain D k → ℝ
+  | 0, _ => 1 / Fintype.card D
+  | _+1, p => T p.1 (head p.2) * mass T p.2
+
+variable {D : Type*} [Fintype D] (T : D → D → ℝ)
+
+/-- A doubly stochastic transition rule, with no entry exceeding one half. -/
+structure Transition : Prop where
+  nonneg : ∀ d e, 0 ≤ T d e
+  row_sum : ∀ d, ∑ e, T d e = 1
+  col_sum : ∀ e, ∑ d, T d e = 1
+  half : ∀ d e, T d e ≤ 1/2
+
+variable {T}
+
+theorem mass_nonneg (ht : Transition T) {k : ℕ} (p : Chain D k) :
+    0 ≤ mass T p := by
+  induction k with
+  | zero => exact one_div_nonneg.mpr (Nat.cast_nonneg _)
+  | succ k ih => exact mul_nonneg (ht.nonneg _ _) (ih p.2)
+
+/-- Stationarity of uniform directed-edge measure, proved by finite summation. -/
+theorem head_expectation (ht : Transition T) (k : ℕ) (f : D → ℝ) :
+    ∑ p : Chain D k, mass T p * f (head p) = (∑ d, f d) / Fintype.card D := by
+  induction k generalizing f with
+  | zero =>
+    change (∑ p : D, (1 / Fintype.card D) * f p) = _
+    rw [← Finset.mul_sum]
+    ring
+  | succ k ih =>
+    change (∑ p : D × Chain D k, T p.1 (head p.2) * mass T p.2 * f p.1) = _
+    rw [Fintype.sum_prod_type]
+    have he (d : D) :
+        (∑ q : Chain D k, T d (head q) * mass T q * f d) = f d / Fintype.card D := by
+      have hi := ih (fun e => T d e)
+      rw [ht.row_sum] at hi
+      calc
+        _ = (∑ q : Chain D k, mass T q * T d (head q)) * f d := by
+          rw [Finset.sum_mul]
+          apply Finset.sum_congr rfl
+          intro q _
+          ring
+        _ = _ := by rw [hi]; ring
+    simp_rw [he]
+    exact (Finset.sum_div _ _ _).symm
+
+theorem mass_sum [Nonempty D] (ht : Transition T) (k : ℕ) :
+    ∑ p : Chain D k, mass T p = 1 := by
+  simpa [Fintype.card_ne_zero] using head_expectation ht k (fun _ => (1:ℝ))
+
+theorem cost_expectation (ht : Transition T) (k : ℕ) (len : D → ℝ) :
+    ∑ p : Chain D k, mass T p * cost len p =
+      (k+1:ℝ) * (∑ d, len d) / Fintype.card D := by
+  induction k with
+  | zero => simpa [cost,head] using head_expectation ht 0 len
+  | succ k ih =>
+    change (∑ p : D × Chain D k,
+      (T p.1 (head p.2)*mass T p.2)*(len p.1+cost len p.2)) = _
+    simp_rw [mul_add]
+    rw [Finset.sum_add_distrib]
+    have hf := head_expectation ht (k+1) len
+    change (∑ p : D × Chain D k,
+      T p.1 (head p.2)*mass T p.2*len p.1) = _ at hf
+    rw [hf]
+    have hs : (∑ p : D × Chain D k,
+        T p.1 (head p.2)*mass T p.2*cost len p.2) =
+        ∑ q : Chain D k, mass T q * cost len q := by
+      rw [Fintype.sum_prod_type, Finset.sum_comm]
+      apply Finset.sum_congr rfl
+      intro q _
+      calc
+        _ = (∑ d, T d (head q)) * (mass T q * cost len q) := by
+          rw [Finset.sum_mul]
+          apply Finset.sum_congr rfl
+          intro d _
+          ring
+        _ = _ := by rw [ht.col_sum]; ring
+    rw [hs,ih]
+    push_cast
+    ring
+
+theorem mass_upper (ht : Transition T) {k : ℕ} (p : Chain D k) :
+    mass T p ≤ (1 / Fintype.card D) * (1/2:ℝ)^k := by
+  induction k with
+  | zero => simp [mass]
+  | succ k ih =>
+    change T p.1 (head p.2)*mass T p.2 ≤ _
+    calc
+      _ ≤ (1/2:ℝ)*((1 / Fintype.card D)*(1/2:ℝ)^k) :=
+        mul_le_mul (ht.half _ _) (ih p.2) (mass_nonneg ht p.2) (by norm_num)
+      _ = _ := by rw [pow_succ]; ring
+
+/-- Finite Markov without probability-space infrastructure: at least half the
+mass has cost at most twice the expectation; zero-mass chains are irrelevant. -/
+theorem short_mass {P : Type*} [Fintype P] (w c : P → ℝ)
+    (hw : ∀ p, 0 ≤ w p) (hc : ∀ p, 0 ≤ c p)
+    (hs : ∑ p, w p = 1) (B : ℝ) (hB : 0 < B)
+    (hm : ∑ p, w p*c p ≤ B) :
+    1/2 ≤ ∑ p ∈ Finset.univ.filter (fun p => c p ≤ 2*B ∧ 0 < w p), w p := by
+  classical
+  let S := Finset.univ.filter (fun p => c p ≤ 2*B ∧ 0 < w p)
+  have hl : 2*B * (1 - ∑ p ∈ S, w p) ≤ B := by
+    have hp : ∑ p ∈ Finset.univ \ S, w p = 1 - ∑ p ∈ S, w p := by
+      have ht := Finset.sum_sdiff (f := w) (Finset.subset_univ S)
+      rw [hs] at ht
+      linarith
+    rw [← hp, Finset.mul_sum]
+    calc
+      _ ≤ ∑ p ∈ Finset.univ \ S, w p*c p := by
+        apply Finset.sum_le_sum
+        intro p hp
+        have hnot : ¬(c p ≤ 2*B ∧ 0 < w p) := by
+          simpa [S] using (Finset.mem_sdiff.mp hp).2
+        by_cases hz : w p = 0
+        · simp [hz]
+        · have hpos : 0 < w p := lt_of_le_of_ne (hw p) (Ne.symm hz)
+          have hcp : 2*B < c p := lt_of_not_ge (fun h => hnot ⟨h,hpos⟩)
+          nlinarith [mul_nonneg (hw p) (sub_nonneg.mpr hcp.le)]
+      _ ≤ ∑ p, w p*c p := Finset.sum_le_sum_of_subset_of_nonneg
+        (Finset.sdiff_subset) (fun p _ _ => mul_nonneg (hw p) (hc p))
+      _ ≤ B := hm
+  change 1/2 ≤ ∑ p ∈ S, w p
+  nlinarith
+
+omit [Fintype D] in
+theorem cost_nonneg (len : D → ℝ) (hlen : ∀ d, 0 ≤ len d) {k : ℕ}
+    (p : Chain D k) : 0 ≤ cost len p := by
+  induction k with
+  | zero => exact hlen p
+  | succ k ih => exact add_nonneg (hlen p.1) (ih p.2)
+
+/-- Entropy forces many short nonzero-probability nonbacktracking chains. -/
+theorem many_short_chains [Nonempty D] (ht : Transition T) (k : ℕ)
+    (len : D → ℝ) (hlen : ∀ d, 0 < len d) :
+    ∃ S : Finset (Chain D k),
+      (∀ p ∈ S, cost len p ≤ 2*(k+1:ℝ)*(∑ d, len d)/Fintype.card D ∧
+        0 < mass T p) ∧
+      (Fintype.card D : ℝ)*(2:ℝ)^k ≤ 2*S.card := by
+  classical
+  let B : ℝ := (k+1:ℝ)*(∑ d, len d)/Fintype.card D
+  have hD : (0:ℝ) < Fintype.card D := Nat.cast_pos.mpr Fintype.card_pos
+  have hs : 0 < ∑ d, len d := Finset.sum_pos (fun d _ => hlen d) Finset.univ_nonempty
+  have hB : 0 < B := div_pos (mul_pos (by positivity) hs) hD
+  have hc : ∀ p : Chain D k, 0 ≤ cost len p := cost_nonneg len (fun d => (hlen d).le)
+  let S := Finset.univ.filter (fun p : Chain D k => cost len p ≤ 2*B ∧ 0 < mass T p)
+  have hm : 1/2 ≤ ∑ p ∈ S, mass T p :=
+    short_mass (mass T) (cost len) (mass_nonneg ht) hc (mass_sum ht k) B hB
+      (cost_expectation ht k len).le
+  refine ⟨S,?_,?_⟩
+  · intro p hp
+    have hp' := (Finset.mem_filter.mp hp).2
+    refine ⟨?_,hp'.2⟩
+    calc
+      _ ≤ 2*B := hp'.1
+      _ = _ := by dsimp [B]; ring
+  · have hm' : (∑ p ∈ S, mass T p) ≤
+        S.card*((1/Fintype.card D)*(1/2:ℝ)^k) := by
+      calc
+        _ ≤ ∑ _p ∈ S, (1/Fintype.card D)*(1/2:ℝ)^k :=
+          Finset.sum_le_sum (fun p _ => mass_upper ht p)
+        _ = _ := by simp
+    have powpos : 0 < (2:ℝ)^k := pow_pos (by norm_num) _
+    have hp : (1/2:ℝ)^k = 1/(2:ℝ)^k := by rw [one_div_pow]
+    rw [hp] at hm'
+    have he : (S.card:ℝ)*((1/Fintype.card D)*(1/(2:ℝ)^k)) =
+        S.card/((Fintype.card D:ℝ)*(2:ℝ)^k) := by ring
+    rw [he] at hm'
+    have h := (le_div_iff₀ (mul_pos hD powpos)).mp (hm.trans hm')
+    linarith
+
+/-- More short chains than ordered endpoint pairs forces a collision. This uses
+actual chains and their probabilities, not a hypothesis asserting path growth. -/
+theorem short_collision [Nonempty D] (ht : Transition T) (k : ℕ)
+    (len : D → ℝ) (hlen : ∀ d, 0 < len d)
+    (hbig : 2*(Fintype.card D : ℝ) < (2:ℝ)^k) :
+    ∃ p q : Chain D k, p ≠ q ∧ head p = head q ∧ last p = last q ∧
+      0 < mass T p ∧ 0 < mass T q ∧
+      cost len p + cost len q ≤ 4*(k+1:ℝ)*(∑ d, len d)/Fintype.card D := by
+  classical
+  obtain ⟨S,hS,hcard⟩ := many_short_chains ht k len hlen
+  have hD : (0:ℝ) < Fintype.card D := Nat.cast_pos.mpr Fintype.card_pos
+  have hlt : (Fintype.card D : ℝ)^2 < S.card := by
+    have hmul := mul_lt_mul_of_pos_left hbig hD
+    nlinarith
+  have hn : (Finset.univ : Finset (D × D)).card < S.card := by
+    simp only [Finset.card_univ,Fintype.card_prod]
+    rw [pow_two] at hlt
+    exact_mod_cast hlt
+  obtain ⟨p,hp,q,hq,hne,he⟩ := Finset.exists_ne_map_eq_of_card_lt_of_maps_to hn
+    (f := fun p : Chain D k => (head p,last p)) (fun _ _ => Finset.mem_univ _)
+  refine ⟨p,q,hne,(Prod.mk.inj he).1,(Prod.mk.inj he).2,(hS p hp).2,(hS q hq).2,?_⟩
+  have hp' := (hS p hp).1
+  have hq' := (hS q hq).1
+  calc
+    _ ≤ _ := add_le_add hp' hq'
+    _ = _ := by ring
+
+/-- An explicit logarithmic number of transitions suffices. -/
+theorem logarithmic_short_collision [Nonempty D] (ht : Transition T)
+    (len : D → ℝ) (hlen : ∀ d, 0 < len d) :
+    let k := Nat.log 2 (Fintype.card D) + 2
+    ∃ p q : Chain D k, p ≠ q ∧ head p = head q ∧ last p = last q ∧
+      0 < mass T p ∧ 0 < mass T q ∧
+      cost len p + cost len q ≤ 4*(k+1:ℝ)*(∑ d, len d)/Fintype.card D := by
+  apply short_collision ht _ len hlen
+  have hn := Nat.lt_pow_succ_log_self (by decide : 1 < 2) (Fintype.card D)
+  have hn' : (Fintype.card D : ℝ) < (2:ℝ)^(Nat.log 2 (Fintype.card D)+1) := by
+    exact_mod_cast hn
+  rw [show Nat.log 2 (Fintype.card D)+2 = (Nat.log 2 (Fintype.card D)+1)+1 by omega,
+    pow_succ]
+  linarith
+
+namespace PortWalk
+
+variable {V : Type*} (origin : D → V) (rev : D → D)
+    (hinv : Function.Involutive rev)
+
+open scoped Classical
+
+def out (v : V) : Finset D := Finset.univ.filter (fun d => origin d = v)
+def choices (v : V) : ℕ := (out origin v).card - 1
+
+def step (d e : D) : Prop := origin (rev d) = origin e ∧ e ≠ rev d
+
+def transition (d e : D) : ℝ :=
+  if step origin rev d e then 1 / (choices origin (origin e) : ℝ) else 0
+
+theorem succ_eq (d : D) :
+    Finset.univ.filter (step origin rev d) = (out origin (origin (rev d))).erase (rev d) := by
+  ext e
+  simp [step,out,and_comm,eq_comm]
+
+theorem succ_card (d : D) :
+    (Finset.univ.filter (step origin rev d)).card = choices origin (origin (rev d)) := by
+  rw [succ_eq,Finset.card_erase_of_mem (by simp [out])]
+  rfl
+
+include hinv
+
+theorem pred_eq (e : D) :
+    Finset.univ.filter (fun d => step origin rev d e) =
+      ((out origin (origin e)).erase e).image rev := by
+  ext d
+  simp only [Finset.mem_filter,Finset.mem_univ,true_and,
+    Finset.mem_image,Finset.mem_erase]
+  constructor
+  · intro h
+    refine ⟨rev d,⟨Ne.symm h.2,?_⟩,hinv d⟩
+    simpa [out] using h.1
+  · rintro ⟨a,⟨ha,hoa⟩,rfl⟩
+    change origin (rev (rev a)) = origin e ∧ e ≠ rev (rev a)
+    rw [hinv a]
+    refine ⟨?_,Ne.symm ha⟩
+    simpa [out] using hoa
+
+theorem pred_card (e : D) :
+    (Finset.univ.filter (fun d => step origin rev d e)).card = choices origin (origin e) := by
+  rw [pred_eq origin rev hinv, Finset.card_image_of_injective _ hinv.injective,
+    Finset.card_erase_of_mem (by simp [out])]
+  rfl
+
+/-- The actual nonbacktracking chain on ports of a multigraph is stationary
+on uniformly chosen darts, including loops and parallel edges. -/
+theorem transition_law (hdeg : ∀ d, 3 ≤ (out origin (origin d)).card) :
+    Transition (transition origin rev) := by
+  have hchoice (d : D) : (2:ℝ) ≤ choices origin (origin d) := by
+    have h := hdeg d
+    have : 2 ≤ choices origin (origin d) := by dsimp [choices]; omega
+    exact_mod_cast this
+  have hpos (d : D) : (0:ℝ) < choices origin (origin d) := lt_of_lt_of_le (by norm_num) (hchoice d)
+  refine ⟨?_,?_,?_,?_⟩
+  · intro d e
+    unfold transition
+    split <;> positivity
+  · intro d
+    have he : (∑ e, transition origin rev d e) =
+        ∑ e ∈ Finset.univ.filter (step origin rev d),
+          1 / (choices origin (origin (rev d)) : ℝ) := by
+      rw [Finset.sum_filter]
+      apply Finset.sum_congr rfl
+      intro e _
+      unfold transition
+      split_ifs with h
+      · rw [h.1]
+      · rfl
+    rw [he]
+    simp only [Finset.sum_const, nsmul_eq_mul, succ_card]
+    exact mul_one_div_cancel (ne_of_gt (hpos (rev d)))
+  · intro e
+    change (∑ d, if step origin rev d e then _ else 0) = 1
+    rw [← Finset.sum_filter]
+    simp only [Finset.sum_const,nsmul_eq_mul,pred_card origin rev hinv]
+    exact mul_one_div_cancel (ne_of_gt (hpos e))
+  · intro d e
+    unfold transition
+    split
+    · exact one_div_le_one_div_of_le (by norm_num) (hchoice e)
+    · norm_num
+
+end PortWalk
+
+end TorsionFreeZeroDivisors.WeightedMoore
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/GroupRing/WeightedGirth.lean b/lean/OAI/Algebra/GroupRing/WeightedGirth.lean
new file mode 100644
index 0000000000000000000000000000000000000000..8f45777beba34faa8bd0608d4f53f4b33766734a
--- /dev/null
+++ b/lean/OAI/Algebra/GroupRing/WeightedGirth.lean
@@ -0,0 +1,385 @@
+import Mathlib
+import OAI.Algebra.GroupRing.RawDecomposition
+
+namespace OAI
+
+noncomputable section
+
+namespace TorsionFreeZeroDivisors.WeightedGirth
+open scoped Classical BigOperators
+open PortSubdivision WeightedPortMoore WeightedCycles
+variable {V D : Type} (Γ : PortGraph V D)
+
+def middle : Sym2 (V ⊕ D) → Bool :=
+  Sym2.lift ⟨fun a b => match a,b with
+    | .inr _,.inr _ => true
+    | _,_ => false,by intro a b; cases a <;> cases b <;> rfl⟩
+def bundle : Sym2 (V ⊕ D) → Finset (Sym2 (V ⊕ D)) :=
+  Sym2.lift ⟨fun a b => match a,b with
+    | .inr d,.inr e => {s(a,b),s(Sum.inl (Γ.origin d),a),s(Sum.inl (Γ.origin e),b)}
+    | _,_ => {s(a,b)},by
+      intro a b
+      cases a <;> cases b
+      all_goals simp only [Sym2.eq_swap]
+      exact congrArg (fun t : Finset (Sym2 (V⊕D)) => insert _ t) (Finset.pair_comm _ _)⟩
+lemma bundle_card (e : Sym2 (V ⊕ D)) : (bundle Γ e).card≤3 := by
+  induction e using Sym2.inductionOn with
+  | _ a b =>
+    cases a with
+    | inl v => cases b <;> simp [bundle]
+    | inr d =>
+      cases b with
+      | inl v => simp [bundle]
+      | inr f =>
+        change ({_,_,_} : Finset (Sym2 (V⊕D))).card ≤ 3
+        have h₁ := Finset.card_insert_le s(Sum.inr d,Sum.inr f)
+          ({s(Sum.inl (Γ.origin d),Sum.inr d),s(Sum.inl (Γ.origin f),Sum.inr f)} : Finset (Sym2 (V⊕D)))
+        have h₂ := Finset.card_insert_le s(Sum.inl (Γ.origin d),Sum.inr d)
+          ({s(Sum.inl (Γ.origin f),Sum.inr f)} : Finset (Sym2 (V⊕D)))
+        simp only [Finset.card_singleton] at h₂
+        dsimp only at *
+        omega
+lemma self_mem_bundle (e : Sym2 (V ⊕ D)) : e∈bundle Γ e := by
+  induction e using Sym2.inductionOn with
+  | _ a b => cases a <;> cases b <;> simp [bundle]
+lemma weight_eq_indicator (e : Sym2 (V ⊕ D)) :
+    edgeWeight (fun _ : D => (1:ℝ)) e=if middle e then 1 else 0 := by
+  induction e using Sym2.inductionOn with
+  | _ a b => cases a <;> cases b <;> norm_num [edgeWeight,middle]
+
+lemma edges_covered {a : V⊕D} (p : Γ.subdivision.Walk a a) (hp : p.IsCycle) :
+    p.edges.toFinset⊆(p.edges.toFinset.filter (fun e => middle e)).biUnion (bundle Γ) := by
+  intro e he
+  have hep : e∈p.edges := List.mem_toFinset.mp he
+  induction e using Sym2.inductionOn with
+  | _ x y =>
+    have hadj := p.adj_of_mem_edges hep
+    cases x with
+    | inl v =>
+      cases y with
+      | inl w => exact False.elim hadj
+      | inr d =>
+        change Γ.origin d=v at hadj
+        subst v
+        have hd : Sum.inr d∈p.support := p.snd_mem_support_of_mem_edges hep
+        have hm := Γ.cycle_middle_at_port d (p.rotate (.inr d) hd) (hp.rotate hd)
+        have hm' : s(Sum.inr d,Sum.inr (Γ.reverse d))∈p.edges := (p.rotate_edges _ hd).mem_iff.mp hm
+        apply Finset.mem_biUnion.mpr
+        refine ⟨s(Sum.inr d,Sum.inr (Γ.reverse d)),Finset.mem_filter.mpr ⟨List.mem_toFinset.mpr hm',rfl⟩,?_⟩
+        simp [bundle]
+    | inr d =>
+      cases y with
+      | inl v =>
+        change Γ.origin d=v at hadj
+        subst v
+        have hd : Sum.inr d∈p.support := p.fst_mem_support_of_mem_edges hep
+        have hm := Γ.cycle_middle_at_port d (p.rotate (.inr d) hd) (hp.rotate hd)
+        have hm' : s(Sum.inr d,Sum.inr (Γ.reverse d))∈p.edges := (p.rotate_edges _ hd).mem_iff.mp hm
+        apply Finset.mem_biUnion.mpr
+        refine ⟨s(Sum.inr d,Sum.inr (Γ.reverse d)),Finset.mem_filter.mpr ⟨List.mem_toFinset.mpr hm',rfl⟩,?_⟩
+        simp [bundle,Sym2.eq_swap]
+      | inr f =>
+        exact Finset.mem_biUnion.mpr ⟨_,Finset.mem_filter.mpr ⟨he,rfl⟩,self_mem_bundle Γ _⟩
+
+/-- In a genuine subdivision cycle every middle edge supports at most two
+spokes. Thus girth measured in three-edge subdivisions implies the literal
+unit macro-edge weighted girth used by the pattern theorem. -/
+lemma length_le_three_weight {a : V⊕D} (p : Γ.subdivision.Walk a a) (hp : p.IsCycle) :
+    (p.length:ℝ)≤3*weight (edgeWeight (fun _ : D => (1:ℝ))) p := by
+  have hn := hp.isTrail.edges_nodup
+  have hc : p.edges.toFinset.card≤3*(p.edges.toFinset.filter (fun e => middle e)).card := calc
+    _≤((p.edges.toFinset.filter (fun e => middle e)).biUnion (bundle Γ)).card := Finset.card_le_card (edges_covered Γ p hp)
+    _≤∑e∈p.edges.toFinset.filter (fun e => middle e),(bundle Γ e).card := Finset.card_biUnion_le
+    _≤∑_e∈p.edges.toFinset.filter (fun e => middle e),3 := Finset.sum_le_sum (fun e _ => bundle_card Γ e)
+    _=3*(p.edges.toFinset.filter (fun e => middle e)).card := by simp [Nat.mul_comm]
+  have hw : weight (edgeWeight (fun _ : D => (1:ℝ))) p=
+      (p.edges.toFinset.filter (fun e => middle e)).card := by
+    rw [weight,←List.sum_toFinset _ hn]
+    simp only [weight_eq_indicator,←Finset.sum_filter]
+    simp
+  rw [hw]
+  have hl : p.edges.toFinset.card=p.length := by rw [List.toFinset_card_of_nodup hn,SimpleGraph.Walk.length_edges]
+  rw [hl] at hc
+  exact_mod_cast hc
+lemma weighted_girth (L : ℕ) (hg : (3*L:ℕ)≤Γ.subdivision.egirth) :
+    ∀ a (p : Γ.subdivision.Walk a a),p.IsCycle → (L:ℝ)≤weight (edgeWeight (fun _ : D => (1:ℝ))) p := by
+  intro a p hp
+  have hl : 3*L≤p.length := by exact_mod_cast SimpleGraph.le_egirth.mp hg a p hp
+  have hl' : (3:ℝ)*L≤p.length := by exact_mod_cast hl
+  have hw := length_le_three_weight Γ p hp
+  linarith
+end TorsionFreeZeroDivisors.WeightedGirth
+namespace TorsionFreeZeroDivisors.SumGirth
+open SimpleGraph
+variable {V W : Type*} (G : SimpleGraph V) (H : SimpleGraph W)
+def inlWalk {a b : V} : (G⊕g H).Walk (.inl a) (.inl b) → G.Walk a b
+  | .nil => .nil
+  | .cons (v:=.inl c) h p => .cons h (inlWalk p)
+  | .cons (v:=.inr _) h _ => by cases h
+lemma map_inlWalk {a b : V} (p : (G⊕g H).Walk (.inl a) (.inl b)) :
+    (inlWalk G H p).map Embedding.sumInl.toHom=p := by
+  fun_induction inlWalk G H p
+  · rfl
+  · rename_i a b c h p ih
+    change SimpleGraph.Walk.cons _ ((inlWalk G H p).map Embedding.sumInl.toHom) = _
+    rw [ih]
+    rfl
+  · contradiction
+lemma inlWalk_length {a b : V} (p : (G⊕g H).Walk (.inl a) (.inl b)) :
+    (inlWalk G H p).length=p.length := by
+  calc
+    _ = ((inlWalk G H p).map Embedding.sumInl.toHom).length := (SimpleGraph.Walk.length_map _ _).symm
+    _ = p.length := congrArg SimpleGraph.Walk.length (map_inlWalk G H p)
+lemma inlWalk_cycle {a : V} (p : (G⊕g H).Walk (.inl a) (.inl a)) (hp : p.IsCycle) :
+    (inlWalk G H p).IsCycle := by
+  rw [←map_inlWalk G H p] at hp
+  exact hp.of_map
+lemma le_egirth (n : ℕ∞) (hG : n≤G.egirth) (hH : n≤H.egirth) :
+    n≤(G⊕g H).egirth := by
+  apply SimpleGraph.le_egirth.mpr
+  intro a p hp
+  cases a with
+  | inl a =>
+    have h := SimpleGraph.le_egirth.mp hG a (inlWalk G H p) (inlWalk_cycle G H p hp)
+    simpa only [inlWalk_length] using h
+  | inr b =>
+    let q : (H⊕g G).Walk (.inl b) (.inl b) := p.map Iso.sumComm.toHom
+    have hq : q.IsCycle := hp.map Iso.sumComm.injective
+    have h := SimpleGraph.le_egirth.mp hH b (inlWalk H G q) (inlWalk_cycle H G q hq)
+    have hl : (inlWalk H G q).length=p.length := (inlWalk_length H G q).trans (p.length_map Iso.sumComm.toHom)
+    rw [hl] at h
+    exact h
+lemma walk_side {a b : V⊕W} (p : (G⊕g H).Walk a b) : a.isLeft=b.isLeft := by
+  induction p with
+  | nil => rfl
+  | @cons a b c h p ih =>
+    have hs : a.isLeft=b.isLeft := by cases a <;> cases b <;> first | rfl | cases h
+    exact hs.trans ih
+lemma diameter (B : ℕ)
+    (hG : ∀ a b,G.Reachable a b → G.dist a b≤B)
+    (hH : ∀ a b,H.Reachable a b → H.dist a b≤B) :
+    ∀ a b,(G⊕g H).Reachable a b → (G⊕g H).dist a b≤B := by
+  intro a b ⟨p⟩
+  have hs := walk_side G H p
+  cases a with
+  | inl a =>
+    cases b with
+    | inr b => cases hs
+    | inl b =>
+      have hab : G.Reachable a b := ⟨inlWalk G H p⟩
+      obtain ⟨q,hq⟩ := hab.exists_walk_length_eq_dist
+      exact (SimpleGraph.dist_le (q.map (Embedding.sumInl (H:=H)).toHom)).trans (by
+        simpa only [SimpleGraph.Walk.length_map,hq] using hG a b hab)
+  | inr a =>
+    cases b with
+    | inl b => cases hs
+    | inr b =>
+      let p' : (H⊕g G).Walk (.inl a) (.inl b) := p.map Iso.sumComm.toHom
+      have hab : H.Reachable a b := ⟨inlWalk H G p'⟩
+      obtain ⟨q,hq⟩ := hab.exists_walk_length_eq_dist
+      exact (SimpleGraph.dist_le (q.map (Embedding.sumInr (G:=G)).toHom)).trans (by
+        simpa only [SimpleGraph.Walk.length_map,hq] using hH a b hab)
+end TorsionFreeZeroDivisors.SumGirth
+namespace TorsionFreeZeroDivisors.SumPort
+
+section
+open PortSubdivision SimpleGraph
+variable {VA VB DA DB : Type} (A : PortGraph VA DA) (B : PortGraph VB DB)
+def graph : PortGraph (VA⊕VB) (DA⊕DB) where
+  origin := Sum.map A.origin B.origin
+  reverse := Sum.map A.reverse B.reverse
+  reverse_reverse := by intro d; cases d <;> simp
+  reverse_ne := by
+    intro dart equality
+    cases dart with
+    | inl dart => exact A.reverse_ne dart (Sum.inl.inj equality)
+    | inr dart => exact B.reverse_ne dart (Sum.inr.inj equality)
+def subdivisionIso : (graph A B).subdivision ≃g A.subdivision⊕g B.subdivision where
+  toEquiv := Equiv.sumSumSumComm VA VB DA DB
+  map_rel_iff' := by
+    intro a b
+    rcases a with (a|a)|(a|a) <;> rcases b with (b|b)|(b|b) <;>
+      simp [graph,PortGraph.subdivision,Equiv.sumSumSumComm]
+lemma girth (n : ℕ∞) (hA : n≤A.subdivision.egirth) (hB : n≤B.subdivision.egirth) :
+    n≤(graph A B).subdivision.egirth := by
+  rw [(subdivisionIso A B).egirth_eq]
+  exact SumGirth.le_egirth _ _ _ hA hB
+
+def side : VA⊕VB → Bool | .inl _ => true | .inr _ => false
+lemma side_edge (d : DA⊕DB) : side ((graph A B).origin ((graph A B).reverse d))=side ((graph A B).origin d) := by
+  cases d <;> rfl
+
+def leftV (v : SideRestriction.Vertex (@side VA VB) true) : VA :=
+  match v with
+  | ⟨.inl a,_⟩ => a
+  | ⟨.inr _,h⟩ => by cases h
+def rightV (v : SideRestriction.Vertex (@side VA VB) false) : VB :=
+  match v with
+  | ⟨.inr b,_⟩ => b
+  | ⟨.inl _,h⟩ => by cases h
+lemma leftV_injective : Function.Injective (@leftV VA VB) := by
+  rintro ⟨a,ha⟩ ⟨b,hb⟩ h
+  cases a <;> cases b
+  · exact Subtype.ext (congrArg Sum.inl h)
+  · cases hb
+  · cases ha
+  · cases ha
+lemma rightV_injective : Function.Injective (@rightV VA VB) := by
+  rintro ⟨a,ha⟩ ⟨b,hb⟩ h
+  cases a <;> cases b
+  · cases ha
+  · cases ha
+  · cases hb
+  · exact Subtype.ext (congrArg Sum.inr h)
+end
+open PortSubdivision
+variable {VA VB DA DB : Type} (A : PortGraph VA DA) (B : PortGraph VB DB)
+def leftD (d : SideRestriction.Dart (graph A B) side true) : DA :=
+  match d with
+  | ⟨.inl a,_⟩ => a
+  | ⟨.inr _,h⟩ => by cases h
+def rightD (d : SideRestriction.Dart (graph A B) side false) : DB :=
+  match d with
+  | ⟨.inr b,_⟩ => b
+  | ⟨.inl _,h⟩ => by cases h
+lemma leftD_injective : Function.Injective (leftD A B) := by
+  rintro ⟨a,ha⟩ ⟨b,hb⟩ h
+  cases a <;> cases b
+  · exact Subtype.ext (congrArg Sum.inl h)
+  · cases hb
+  · cases ha
+  · cases ha
+lemma rightD_injective : Function.Injective (rightD A B) := by
+  rintro ⟨a,ha⟩ ⟨b,hb⟩ h
+  cases a <;> cases b
+  · cases ha
+  · cases ha
+  · cases hb
+  · exact Subtype.ext (congrArg Sum.inr h)
+lemma root_value {V : Type*} (s : V → Bool) (r : Option V) (b : Bool)
+    (v : SideRestriction.Vertex s b) (h : SidePins.root s r b=some v) : r=some v.val := by
+  cases r with
+  | none => cases h
+  | some w =>
+    dsimp only [SidePins.root,Option.bind_some] at h
+    split_ifs at h with hw
+    have hv : w=v.val := congrArg Subtype.val (Option.some.inj h)
+    rw [hv]
+end TorsionFreeZeroDivisors.SumPort
+namespace TorsionFreeZeroDivisors.SampleGraph
+
+section
+open scoped Classical BigOperators
+open PortSubdivision ConditionedMatchings ActualPatternEvent TypedGraphs GirthAsymptotics
+variable (rep : ℕ) (r : Match rep)
+abbrev VA := Types.VertexA rep
+abbrev VB := Types.VertexB rep
+abbrev DA := TypedGraphs.Dart (@Types.outgoingA rep)
+abbrev DB := TypedGraphs.Dart (@Types.outgoingB rep)
+def A : PortGraph (VA rep) (DA rep) := r.1.graph (TypedGraphs.origin (@Types.outgoingA rep))
+def B : PortGraph (VB rep) (DB rep) := r.2.graph (TypedGraphs.origin (@Types.outgoingB rep))
+def graph := SumPort.graph (A rep r) (B rep r)
+def label : DA rep⊕DB rep → Types.Letter := Sum.elim (TypedGraphs.label _) (TypedGraphs.label _)
+lemma label_reverse (d : DA rep⊕DB rep) : label rep ((graph rep r).reverse d)=Types.inverse (label rep d) := by
+  cases d with
+  | inl d => exact r.1.label_reverse d
+  | inr d => exact r.2.label_reverse d
+lemma immersed (d e : DA rep⊕DB rep)
+    (ho : (graph rep r).origin d=(graph rep r).origin e) (hl : label rep d=label rep e) : d=e := by
+  cases d with
+  | inl d =>
+    cases e with
+    | inl e => exact congrArg Sum.inl (Subtype.ext (Prod.ext (Sum.inl.inj ho) hl))
+    | inr e => cases ho
+  | inr d =>
+    cases e with
+    | inl e => cases ho
+    | inr e => exact congrArg Sum.inr (Subtype.ext (Prod.ext (Sum.inr.inj ho) hl))
+lemma girth (hr : r∈samples rep) : (3*L (size rep):ℕ)≤(graph rep r).subdivision.egirth := by
+  have hm := Finset.mem_product.mp hr
+  have hA := (Finset.mem_filter.mp hm.1).2.2
+  have hB := (Finset.mem_filter.mp hm.2).2.2
+  exact SumPort.girth _ _ _ hA hB
+lemma weighted_girth (hr : r∈samples rep) :
+    ∀ a (p : (graph rep r).subdivision.Walk a a),p.IsCycle →
+      (L (size rep):ℝ)≤WeightedCycles.weight (WeightedPortMoore.edgeWeight (fun _ : DA rep⊕DB rep => (1:ℝ))) p :=
+  WeightedGirth.weighted_girth _ _ (girth rep r hr)
+
+def embeddingA (root : Option (VA rep⊕VB rep)) (x : VA rep)
+    (hr : ∀ z,root=some (.inl z) → z=x) :
+    RealizationTransport.Embedding
+      (SideRestriction.graph (graph rep r) SumPort.side (SumPort.side_edge _ _) true)
+      (fun d => label rep d.val) (@Types.outgoingA rep)
+      (RootPins.pin (SidePins.root SumPort.side root true) x) Types.inverse r.1 where
+  vertex := ⟨SumPort.leftV,SumPort.leftV_injective⟩
+  port := ⟨SumPort.leftD _ _,SumPort.leftD_injective _ _⟩
+  origin_eq := by rintro ⟨d,hd⟩; cases d with | inl d => rfl | inr d => cases hd
+  label_eq := by rintro ⟨d,hd⟩; cases d with | inl d => rfl | inr d => cases hd
+  reverse_eq := by rintro ⟨d,hd⟩; cases d with | inl d => rfl | inr d => cases hd
+  pin_eq := by
+    apply RootPins.respects
+    rintro ⟨v,hv⟩ h
+    cases v with
+    | inl v => exact hr v (SumPort.root_value SumPort.side root true _ h)
+    | inr v => cases hv
+
+def embeddingB (root : Option (VA rep⊕VB rep)) (y : VB rep)
+    (hr : ∀ z,root=some (.inr z) → z=y) :
+    RealizationTransport.Embedding
+      (SideRestriction.graph (graph rep r) SumPort.side (SumPort.side_edge _ _) false)
+      (fun d => label rep d.val) (@Types.outgoingB rep)
+      (RootPins.pin (SidePins.root SumPort.side root false) y) Types.inverse r.2 where
+  vertex := ⟨SumPort.rightV,SumPort.rightV_injective⟩
+  port := ⟨SumPort.rightD _ _,SumPort.rightD_injective _ _⟩
+  origin_eq := by rintro ⟨d,hd⟩; cases d with | inl d => cases hd | inr d => rfl
+  label_eq := by rintro ⟨d,hd⟩; cases d with | inl d => cases hd | inr d => rfl
+  reverse_eq := by rintro ⟨d,hd⟩; cases d with | inl d => cases hd | inr d => rfl
+  pin_eq := by
+    apply RootPins.respects
+    rintro ⟨v,hv⟩ h
+    cases v with
+    | inl v => cases hv
+    | inr v => exact hr v (SumPort.root_value SumPort.side root false _ h)
+end
+open scoped Classical BigOperators
+open PortSubdivision ComparedBlocks ComparisonGeometry GirthAsymptotics TypedGraphs ActualPatternEvent
+structure BoundedSystem (Bnd K I rep : ℕ) (r : Match rep) (x : VA rep) (y : VB rep) where
+  P : Type
+  E : Type
+  [fP : Fintype P]
+  [fE : Fintype E]
+  paths : P → List (DA rep⊕DB rep)
+  nonempty : ∀ p,paths p≠[]
+  root : Option P
+  path_bound : Fintype.card P≤K
+  comparison_bound : Fintype.card E≤I
+  path_chain : ∀ p,(paths p).IsChain (WeightedMoore.PortWalk.step (graph rep r).origin (graph rep r).reverse)
+  cyclic_chain : ∀ p,StageRoot.cyclic root p=true →
+    ∀ᵉ (x∈(paths p).getLast?) (y∈(paths p).head?),
+      WeightedMoore.PortWalk.step (graph rep r).origin (graph rep r).reverse x y
+  length_le : (∑p,(paths p).length:ℕ)≤Bnd*L (size rep)
+  length_ge : L (size rep)≤(∑p,(paths p).length:ℕ)
+  comparisons : Comparisons (E:=E) (fun p => (paths p).length)
+  lower : E → ℕ
+  upper : E → ℕ
+  lower_eq : ∀ e,comparisons.lo e=lower e
+  upper_eq : ∀ e,comparisons.hi e=upper e
+  lower_le : ∀ e,lower e≤upper e
+  upper_le : ∀ e,upper e≤(paths (comparisons.source e)).length
+  reduced : ∀ x e,comparisons.side x=some e →
+    RawDecomposition.dart paths x≠RawDecomposition.dart paths (comparisons.pairing.partner x) ∧
+    RawDecomposition.dart paths x≠(graph rep r).reverse (RawDecomposition.dart paths (comparisons.pairing.partner x))
+  unpaired_le : ((Finset.univ.filter (fun x => comparisons.pairing.partner x=x)).card:ℝ)≤
+    StageFusion.epsilon (1/600) 256*(∑p,(paths p).length:ℕ)
+  rootA : ∀ z,root.map (fun p => (graph rep r).origin ((paths p).head (nonempty p)))=some (.inl z) → z=x
+  rootB : ∀ z,root.map (fun p => (graph rep r).origin ((paths p).head (nonempty p)))=some (.inr z) → z=y
+  compatible : ∀ p e,comparisons.side p=some e → label rep (RawDecomposition.dart paths p)=
+    if comparisons.reverse e then Types.inverse (label rep (RawDecomposition.dart paths (comparisons.pairing.partner p)))
+    else label rep (RawDecomposition.dart paths (comparisons.pairing.partner p))
+attribute [instance] BoundedSystem.fP BoundedSystem.fE
+
+end TorsionFreeZeroDivisors.SampleGraph
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/GroupRing/WeightedPortMoore.lean b/lean/OAI/Algebra/GroupRing/WeightedPortMoore.lean
new file mode 100644
index 0000000000000000000000000000000000000000..e8c396e7de317d46571d6dcb5a1836e475ce995f
--- /dev/null
+++ b/lean/OAI/Algebra/GroupRing/WeightedPortMoore.lean
@@ -0,0 +1,415 @@
+import Mathlib
+import OAI.Algebra.GroupRing.PortSubdivision
+import OAI.Algebra.GroupRing.WeightedCycles
+
+namespace OAI
+
+noncomputable section
+
+namespace TorsionFreeZeroDivisors.WeightedPortMoore
+open SimpleGraph WeightedMoore PortSubdivision WeightedCycles
+variable {V D : Type*} (Γ : PortGraph V D)
+
+/-- Validity as a chain of actual nonbacktracking directed edges. -/
+def Good : {k : ℕ} → Chain D k → Prop
+  | 0, _ => True
+  | _+1, p => PortWalk.step Γ.origin Γ.reverse p.1 (head p.2) ∧ Good p.2
+
+/-- The physical port walk, starting and ending at the first/last ports.
+It has one middle edge per macro-edge, and two spokes between them. -/
+def draw : {k : ℕ} → (p : Chain D k) → Good Γ p →
+    Γ.subdivision.Walk (.inr (head p)) (.inr (Γ.reverse (last p)))
+  | 0, d, _ => Walk.cons (show Γ.subdivision.Adj (.inr d) (.inr (Γ.reverse d)) from rfl) Walk.nil
+  | _+1, p, h =>
+    Walk.cons (show Γ.subdivision.Adj (.inr p.1) (.inr (Γ.reverse p.1)) from rfl)
+      (Walk.cons (show Γ.subdivision.Adj (.inr (Γ.reverse p.1)) (.inl (Γ.origin (Γ.reverse p.1))) from rfl)
+        (Walk.cons (show Γ.subdivision.Adj (.inl (Γ.origin (Γ.reverse p.1))) (.inr (head p.2)) from h.1.1.symm)
+          (draw p.2 h.2)))
+
+@[simp] theorem draw_head_edge {k : ℕ} (p : Chain D k) (hp : Good Γ p) :
+    (draw Γ p hp).edges.head? = some s(Sum.inr (head p),Sum.inr (Γ.reverse (head p))) := by
+  cases k <;> rfl
+
+theorem middle_spoke_ne (d e : D) (v : V) :
+    (s(Sum.inr d,Sum.inr (Γ.reverse d)) : Sym2 (V ⊕ D)) ≠ s(Sum.inr e,Sum.inl v) := by
+  simp
+
+theorem draw_reduced {k : ℕ} (p : Chain D k) (hp : Good Γ p) :
+    (draw Γ p hp).edges.IsChain (· ≠ ·) := by
+  induction k with
+  | zero =>
+    change ([s(Sum.inr p,Sum.inr (Γ.reverse p))] : List (Sym2 (V ⊕ D))).IsChain (· ≠ ·)
+    exact List.IsChain.singleton _
+  | succ k ih =>
+    change ((s(Sum.inr p.1,Sum.inr (Γ.reverse p.1))) ::
+      s(Sum.inr (Γ.reverse p.1),Sum.inl (Γ.origin (Γ.reverse p.1))) ::
+      s(Sum.inl (Γ.origin (Γ.reverse p.1)),Sum.inr (head p.2)) ::
+      (draw Γ p.2 hp.2).edges).IsChain (· ≠ ·)
+    apply List.IsChain.cons_cons (middle_spoke_ne Γ _ _ _)
+    apply List.IsChain.cons_cons
+    · intro he
+      have h := Sym2.eq_iff.mp he
+      simp only [Sum.inr.injEq,reduceCtorEq,and_false,false_or] at h
+      exact hp.1.2 h.1.symm
+    · apply (ih p.2 hp.2).cons
+      intro y hy
+      rw [draw_head_edge] at hy
+      have he : y = s(Sum.inr (head p.2),Sum.inr (Γ.reverse (head p.2))) := (Option.mem_some_iff.mp hy).symm
+      subst y
+      intro h
+      exact middle_spoke_ne Γ (head p.2) (head p.2) (Γ.origin (Γ.reverse p.1))
+        (h.symm.trans Sym2.eq_swap)
+
+/-- Recording ports from the physical walk recovers each directed macro-edge. -/
+def portWord : {k : ℕ} → Chain D k → List D
+  | 0, d => [d,Γ.reverse d]
+  | _+1, p => p.1 :: Γ.reverse p.1 :: portWord p.2
+
+def onlyPort : V ⊕ D → Option D
+  | .inl _ => none
+  | .inr d => some d
+
+theorem draw_portWord {k : ℕ} (p : Chain D k) (hp : Good Γ p) :
+    (draw Γ p hp).support.filterMap onlyPort = portWord Γ p := by
+  induction k with
+  | zero => rfl
+  | succ k ih =>
+    change p.1 :: Γ.reverse p.1 :: (draw Γ p.2 hp.2).support.filterMap onlyPort =
+      p.1 :: Γ.reverse p.1 :: portWord Γ p.2
+    rw [ih p.2 hp.2]
+
+theorem portWord_injective (k : ℕ) : Function.Injective (@portWord V D Γ k) := by
+  induction k with
+  | zero => intro p q h; exact (List.cons.inj h).1
+  | succ k ih =>
+    intro p q h
+    have he := List.cons.inj h
+    exact Prod.ext he.1 (ih (List.cons.inj he.2).2)
+
+/-- Nonnegative symmetric length on the subdivision; spokes cost zero. -/
+def edgeWeight (len : D → ℝ) : Sym2 (V ⊕ D) → ℝ :=
+  Sym2.lift ⟨fun a b => match a,b with
+    | .inr d,.inr e => (len d+len e)/2
+    | _,_ => 0, by intro a b; cases a <;> cases b <;> simp [add_comm]⟩
+
+theorem edgeWeight_nonneg (len : D → ℝ) (hlen : ∀ d, 0 ≤ len d) :
+    ∀ e, 0 ≤ edgeWeight (V := V) len e := by
+  intro e
+  induction e using Sym2.inductionOn with
+  | _ a b =>
+    cases a with
+    | inl v => cases b <;> exact le_rfl
+    | inr d =>
+      cases b with
+      | inl v => exact le_rfl
+      | inr e => exact div_nonneg (add_nonneg (hlen d) (hlen e)) (by norm_num)
+
+@[simp] theorem edgeWeight_spoke (len : D → ℝ) (v : V) (d : D) :
+    edgeWeight len s(Sum.inl v,Sum.inr d) = 0 := rfl
+
+@[simp] theorem edgeWeight_middle (len : D → ℝ) (hsym : ∀ d, len (Γ.reverse d) = len d) (d : D) :
+    edgeWeight (V := V) len s(Sum.inr d,Sum.inr (Γ.reverse d)) = len d := by
+  change (len d+len (Γ.reverse d))/2 = len d
+  rw [hsym]; ring
+
+theorem draw_weight (len : D → ℝ) (hsym : ∀ d, len (Γ.reverse d) = len d)
+    {k : ℕ} (p : Chain D k) (hp : Good Γ p) :
+    weight (edgeWeight len) (draw Γ p hp) = cost len p := by
+  induction k with
+  | zero =>
+    change (len p+len (Γ.reverse p))/2+0 = len p
+    rw [hsym]; ring
+  | succ k ih =>
+    change (len p.1+len (Γ.reverse p.1))/2 +
+      (0+(0+weight (edgeWeight len) (draw Γ p.2 hp.2))) = len p.1+cost len p.2
+    rw [hsym,ih p.2 hp.2]
+    ring
+
+/-- Positive chain mass certifies every actual allowed transition. -/
+theorem positive_good [Fintype D]
+    (ht : Transition (PortWalk.transition Γ.origin Γ.reverse))
+    {k : ℕ} (p : Chain D k)
+    (hp : 0 < mass (PortWalk.transition Γ.origin Γ.reverse) p) : Good Γ p := by
+  induction k with
+  | zero => trivial
+  | succ k ih =>
+    have hs : PortWalk.step Γ.origin Γ.reverse p.1 (head p.2) := by
+      by_contra hn
+      simp only [mass,PortWalk.transition,ite_eq_right hn,zero_mul] at hp
+      exact lt_irrefl _ hp
+    have hne : mass (PortWalk.transition Γ.origin Γ.reverse) p.2 ≠ 0 := by
+      intro he
+      simp only [mass,he,mul_zero] at hp
+      exact lt_irrefl _ hp
+    exact ⟨hs,ih p.2 (lt_of_le_of_ne (mass_nonneg ht p.2) hne.symm)⟩
+
+/-- The weighted Moore collision in an actual port multigraph gives an actual
+simple cycle in its faithful subdivision, with exactly the expanded cost bound. -/
+theorem short_cycle [Fintype D] [Nonempty D]
+    (hdeg : ∀ d, 3 ≤ (PortWalk.out Γ.origin (Γ.origin d)).card)
+    (len : D → ℝ) (hlen : ∀ d, 0 < len d)
+    (hsym : ∀ d, len (Γ.reverse d) = len d) :
+    let k := Nat.log 2 (Fintype.card D) + 2
+    ∃ (a : V ⊕ D) (c : Γ.subdivision.Walk a a), c.IsCycle ∧
+      weight (edgeWeight len) c ≤ 4*(k+1:ℝ)*(∑ d, len d)/Fintype.card D := by
+  classical
+  let T := PortWalk.transition Γ.origin Γ.reverse
+  have ht : Transition T := PortWalk.transition_law Γ.origin Γ.reverse Γ.reverse_reverse hdeg
+  obtain ⟨p,q,hne,hh,hl,hp,hq,hcost⟩ := logarithmic_short_collision ht len hlen
+  have hgp : Good Γ p := positive_good Γ ht p hp
+  have hgq : Good Γ q := positive_good Γ ht q hq
+  let qp : Γ.subdivision.Walk (.inr (head p)) (.inr (Γ.reverse (last p))) :=
+    (draw Γ q hgq).copy (congrArg Sum.inr hh.symm)
+      (congrArg (fun d => Sum.inr (Γ.reverse d)) hl.symm)
+  have hqp : (draw Γ p hgp) ≠ qp := by
+    intro he
+    have hr := congrArg (fun r => r.support.filterMap onlyPort) he
+    simp only [qp,Walk.support_copy,draw_portWord] at hr
+    exact hne (portWord_injective Γ _ hr)
+  have hqred : qp.edges.IsChain (· ≠ ·) := by
+    simpa only [qp,Walk.edges_copy] using draw_reduced Γ q hgq
+  have hwq : weight (edgeWeight len) qp = cost len q := by
+    simpa only [qp,weight,Walk.edges_copy] using draw_weight Γ len hsym q hgq
+  obtain ⟨a,c,hc,hwc⟩ := distinct_reduced_cycle (edgeWeight len)
+    (edgeWeight_nonneg len (fun d => (hlen d).le)) (draw Γ p hgp) qp hqp
+    (draw_reduced Γ p hgp) hqred
+  refine ⟨a,c,hc,?_⟩
+  rw [draw_weight Γ len hsym p hgp,hwq] at hwc
+  exact hwc.trans hcost
+
+/-- Consequence used after suppressing degree-two core chains in the manuscript.
+No bound on cycle rank or on the number of chains is assumed in this theorem. -/
+theorem dart_count_inequality [Fintype D] [Nonempty D]
+    (hdeg : ∀ d, 3 ≤ (PortWalk.out Γ.origin (Γ.origin d)).card)
+    (len : D → ℝ) (hlen : ∀ d, 0 < len d)
+    (hsym : ∀ d, len (Γ.reverse d) = len d)
+    (L C : ℝ) (hL : 0 < L) (_hC : 0 ≤ C)
+    (htotal : ∑ d, len d ≤ 2*C*L)
+    (hgirth : ∀ a (c : Γ.subdivision.Walk a a), c.IsCycle → L ≤ weight (edgeWeight len) c) :
+    (Fintype.card D : ℝ) ≤ 8*C*(Nat.log 2 (Fintype.card D)+3:ℝ) := by
+  obtain ⟨a,c,hc,hbound⟩ := short_cycle Γ hdeg len hlen hsym
+  have hD : (0:ℝ) < Fintype.card D := Nat.cast_pos.mpr Fintype.card_pos
+  have hge := hgirth a c hc
+  have he := (le_div_iff₀ hD).mp (hge.trans hbound)
+  have hn : (0:ℝ) ≤ 4*((Nat.log 2 (Fintype.card D)+2:ℕ)+1:ℝ) := by positivity
+  have hm := mul_le_mul_of_nonneg_left htotal hn
+  push_cast at he hm
+  nlinarith
+
+/-- The logarithmic Moore inequality bounds the number of darts uniformly in
+all positive edge lengths and in the girth scale. -/
+theorem logarithmic_inequality_bounded (A : ℝ) (hA : 0 ≤ A) :
+    ∃ R : ℕ, ∀ n : ℕ, (n : ℝ) ≤ A*((Nat.log 2 n:ℝ)+3) → n ≤ R := by
+  have ht : Filter.Tendsto (fun n : ℕ => A*(Real.logb 2 n+3)/(n:ℝ))
+      Filter.atTop (nhds 0) := by
+    have hlog : Filter.Tendsto (fun n : ℕ => Real.logb 2 n/(n:ℝ))
+        Filter.atTop (nhds 0) := by
+      simpa [Function.comp_def] using (Real.tendsto_pow_logb_div_mul_add_atTop (b := 2) 1 0 1
+        one_ne_zero).comp (tendsto_natCast_atTop_atTop (R := ℝ))
+    have hinv : Filter.Tendsto (fun n : ℕ => (3:ℝ)/(n:ℝ)) Filter.atTop (nhds 0) :=
+      tendsto_const_div_atTop_nhds_zero_nat 3
+    convert (hlog.add hinv).const_mul A using 1 <;> simp [add_div,mul_div_assoc]
+  obtain ⟨R,hR⟩ := Filter.eventually_atTop.mp (ht.eventually_lt_const (by norm_num : (0:ℝ)<1))
+  refine ⟨max R 1,fun n hn => ?_⟩
+  by_contra hnR
+  have hn0 : (0:ℝ) < n := by exact_mod_cast (show 0<n by omega)
+  have hl := hR n (by omega)
+  have hb := mul_le_mul_of_nonneg_left (Real.natLog_le_logb n 2) hA
+  norm_num only [Nat.cast_ofNat] at hb
+  have hc : (n:ℝ) ≤ A*(Real.logb 2 n+3) := by nlinarith
+  have hd := (div_lt_iff₀ hn0).mp hl
+  linarith
+
+/-- Fully uniform form of the weighted Moore bound needed by the actual-image
+complexity argument; the bound is independent of L and of the multigraph. -/
+theorem uniform_dart_bound (C : ℝ) (hC : 0 ≤ C) :
+    ∃ R : ℕ, ∀ {V' D' : Type} [Fintype D'] [Nonempty D']
+      (Γ' : PortGraph V' D')
+      (_ : ∀ d, 3 ≤ (PortWalk.out Γ'.origin (Γ'.origin d)).card)
+      (len : D' → ℝ) (_ : ∀ d, 0 < len d)
+      (_ : ∀ d, len ((Γ').reverse d) = len d)
+      (L : ℝ) (_ : 0 < L)
+      (_ : ∑ d, len d ≤ 2*C*L)
+      (_ : ∀ a (c : Γ'.subdivision.Walk a a), c.IsCycle →
+        L ≤ weight (edgeWeight len) c), Fintype.card D' ≤ R := by
+  obtain ⟨R,hR⟩ := logarithmic_inequality_bounded (8*C) (by positivity)
+  refine ⟨R,?_⟩
+  intro V' D' _ _ Γ' hdeg len hlen hsym L hL htotal hgirth
+  exact hR _ (dart_count_inequality Γ' hdeg len hlen hsym L C hL hC htotal hgirth)
+
+end TorsionFreeZeroDivisors.WeightedPortMoore
+
+namespace TorsionFreeZeroDivisors.ChainSuppression
+open Function
+open scoped Classical
+
+variable {D : Type*} (σ τ : D → D)
+    (hσ : Involutive σ) (hτ : Involutive τ)
+
+/-- The edge reversal followed by the unique turn at an unmarked degree-two
+vertex. At marked vertices the turn fixes all outgoing darts. -/
+def next : D → D := τ ∘ σ
+
+include hσ hτ
+
+lemma next_injective : Injective (next σ τ) := hτ.injective.comp hσ.injective
+
+lemma folded_step (x : D) : next σ τ (τ (next σ τ x)) = τ x := by
+  change τ (σ (τ (τ (σ x)))) = τ x
+  rw [hτ (σ x),hσ x]
+
+lemma folded_iterate (n : ℕ) (x : D) :
+    (next σ τ)^[n] (τ ((next σ τ)^[n] x)) = τ x := by
+  induction n generalizing x with
+  | zero => rfl
+  | succ n ih =>
+    rw [iterate_succ_apply',iterate_succ_apply,ih,folded_step σ τ hσ hτ]
+
+lemma reverse_segment {k i : ℕ} (hi : i ≤ k) (x : D) :
+    (next σ τ)^[i] (τ ((next σ τ)^[k] x)) =
+      τ ((next σ τ)^[k-i] x) := by
+  have hk : k=i+(k-i) := by omega
+  conv_lhs => rw [hk]
+  rw [iterate_add_apply,folded_iterate σ τ hσ hτ]
+
+variable [Finite D]
+
+lemma exists_positive_return (x : D) (hx : τ x=x) :
+    ∃ n : ℕ, 0<n ∧ τ ((next σ τ)^[n] x) = (next σ τ)^[n] x := by
+  obtain ⟨n,hn,hp⟩ := (next_injective σ τ hσ hτ).mem_periodicPts x
+  exact ⟨n,hn,by simpa only [hp.eq] using hx⟩
+
+def length (x : D) (hx : τ x=x) : ℕ :=
+  Nat.find (exists_positive_return σ τ hσ hτ x hx)
+
+lemma length_pos (x : D) (hx : τ x=x) : 0 < length σ τ hσ hτ x hx :=
+  (Nat.find_spec (exists_positive_return σ τ hσ hτ x hx)).1
+
+lemma length_fixed (x : D) (hx : τ x=x) :
+    τ ((next σ τ)^[length σ τ hσ hτ x hx] x) =
+      (next σ τ)^[length σ τ hσ hτ x hx] x :=
+  (Nat.find_spec (exists_positive_return σ τ hσ hτ x hx)).2
+
+lemma no_internal_mark (x : D) (hx : τ x=x) {i : ℕ}
+    (hi : 0 < i) (hik : i < length σ τ hσ hτ x hx) :
+    τ ((next σ τ)^[i] x) ≠ (next σ τ)^[i] x := by
+  intro he
+  exact (not_lt_of_ge (Nat.find_min' (exists_positive_return σ τ hσ hτ x hx)
+    ⟨hi,he⟩)) hik
+
+/-- The opposite end of the maximal chain, given as its outgoing port. -/
+def endpoint (x : {x : D // τ x=x}) : {x : D // τ x=x} :=
+  ⟨(next σ τ)^[length σ τ hσ hτ x x.property] x,
+    length_fixed σ τ hσ hτ x x.property⟩
+
+lemma endpoint_reverse {x : {x : D // τ x=x}} {i : ℕ}
+    (hi : i ≤ length σ τ hσ hτ x x.property) :
+    (next σ τ)^[i] (endpoint σ τ hσ hτ x).val =
+      τ ((next σ τ)^[length σ τ hσ hτ x x.property-i] x.val) := by
+  have h := reverse_segment σ τ hσ hτ hi x.val
+  rw [length_fixed σ τ hσ hτ x x.property] at h
+  exact h
+
+lemma endpoint_return (x : {x : D // τ x=x}) :
+    (next σ τ)^[length σ τ hσ hτ x.val x.property] (endpoint σ τ hσ hτ x).val = x.val := by
+  simpa only [Nat.sub_self,iterate_zero,id_eq,x.property] using
+    (endpoint_reverse σ τ hσ hτ (x := x) (i := length σ τ hσ hτ x x.property) le_rfl)
+
+lemma length_endpoint (x : {x : D // τ x=x}) :
+    length σ τ hσ hτ (endpoint σ τ hσ hτ x).val (endpoint σ τ hσ hτ x).property =
+      length σ τ hσ hτ x.val x.property := by
+  let e := endpoint σ τ hσ hτ x
+  let k := length σ τ hσ hτ x.val x.property
+  let l := length σ τ hσ hτ e.val e.property
+  have hk : 0<k := length_pos σ τ hσ hτ x.val x.property
+  have hl : 0<l := length_pos σ τ hσ hτ e.val e.property
+  have hret : (next σ τ)^[k] e.val=x.val := endpoint_return σ τ hσ hτ x
+  have hle : l ≤ k := Nat.find_min' (exists_positive_return σ τ hσ hτ e.val e.property)
+    ⟨hk,by rw [hret]; exact x.property⟩
+  have heq : l=k := by
+    by_contra he
+    have hlt : l<k := lt_of_le_of_ne hle he
+    have hr := endpoint_reverse σ τ hσ hτ (x := x) (i := l) hle
+    have hef := length_fixed σ τ hσ hτ e.val e.property
+    change τ ((next σ τ)^[l] e.val) = (next σ τ)^[l] e.val at hef
+    rw [hr,hτ] at hef
+    exact no_internal_mark σ τ hσ hτ x.val x.property (by omega : 0<k-l)
+      (by omega : k-l<k) hef.symm
+  exact heq
+
+lemma endpoint_involutive : Involutive (endpoint σ τ hσ hτ) := by
+  intro x
+  apply Subtype.ext
+  change (next σ τ)^[length σ τ hσ hτ (endpoint σ τ hσ hτ x).val
+    (endpoint σ τ hσ hτ x).property] (endpoint σ τ hσ hτ x).val=x.val
+  rw [length_endpoint]
+  exact endpoint_return σ τ hσ hτ x
+
+lemma endpoint_ne (hσne : ∀ d, σ d≠d) (x : {x : D // τ x=x}) :
+    endpoint σ τ hσ hτ x ≠ x := by
+  intro he
+  let k := length σ τ hσ hτ x.val x.property
+  have hk : 0<k := length_pos σ τ hσ hτ x.val x.property
+  have hr (i : ℕ) (hi : i ≤ k) :
+      (next σ τ)^[i] x.val=τ ((next σ τ)^[k-i] x.val) := by
+    simpa only [he] using endpoint_reverse σ τ hσ hτ (x := x) hi
+  rcases Nat.mod_two_eq_zero_or_one k with hp | hp
+  · have hd : k-k/2=k/2 := by omega
+    have hi : 0<k/2 := by omega
+    have hit : k/2<k := by omega
+    have hm := hr (k/2) (by omega)
+    rw [hd] at hm
+    exact no_internal_mark σ τ hσ hτ x.val x.property hi hit hm.symm
+  · have hd : k-k/2=k/2+1 := by omega
+    have hm := hr (k/2) (by omega)
+    rw [hd,iterate_succ_apply'] at hm
+    change (next σ τ)^[k/2] x.val = τ (τ (σ ((next σ τ)^[k/2] x.val))) at hm
+    rw [hτ] at hm
+    exact hσne _ hm.symm
+
+/-- Each directed edge can be traversed at most once among all oriented
+maximal chains. This is the exact disjoint-interior count, not a bound supplied
+as an extra hypothesis. -/
+lemma chain_dart_injective :
+    Injective (fun p : (x : {x : D // τ x=x}) × Fin (length σ τ hσ hτ x.val x.property) =>
+      (next σ τ)^[p.2.val] p.1.val) := by
+  intro ⟨x,i⟩ ⟨y,j⟩ he
+  have hone (x y : {x : D // τ x=x})
+      (i : Fin (length σ τ hσ hτ x.val x.property))
+      (j : Fin (length σ τ hσ hτ y.val y.property))
+      (hij : i.val ≤ j.val)
+      (he : (next σ τ)^[i.val] x.val=(next σ τ)^[j.val] y.val) :
+      x=y ∧ i.val=j.val := by
+    have hji : j.val=i.val+(j.val-i.val) := by omega
+    rw [hji,iterate_add_apply] at he
+    have hr := ((next_injective σ τ hσ hτ).iterate i.val) he
+    have hzero : j.val-i.val=0 := by
+      by_contra hz
+      have hf : τ ((next σ τ)^[j.val-i.val] y.val)=(next σ τ)^[j.val-i.val] y.val := by
+        rw [← hr]; exact x.property
+      exact no_internal_mark σ τ hσ hτ y.val y.property (Nat.pos_of_ne_zero hz)
+        (by omega) hf
+    have hexy : x=y := by
+      apply Subtype.ext
+      simpa only [hzero,iterate_zero,id_eq] using hr
+    exact ⟨hexy,by omega⟩
+  have hxy : x=y ∧ i.val=j.val := by
+    rcases le_total i.val j.val with hij | hji
+    · exact hone x y i j hij he
+    · obtain ⟨hexy,hij⟩ := hone y x j i hji he.symm
+      exact ⟨hexy.symm,hij.symm⟩
+  obtain ⟨rfl,hij⟩ := hxy
+  congr 1
+  exact Fin.ext hij
+
+lemma total_length_le [Fintype D] :
+    ∑ x : {x : D // τ x=x}, length σ τ hσ hτ x.val x.property ≤ Fintype.card D := by
+  classical
+  simpa only [Fintype.card_sigma,Fintype.card_fin] using Fintype.card_le_of_injective _
+    (chain_dart_injective σ τ hσ hτ)
+
+end TorsionFreeZeroDivisors.ChainSuppression
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/GroupRing/WordBlocks.lean b/lean/OAI/Algebra/GroupRing/WordBlocks.lean
new file mode 100644
index 0000000000000000000000000000000000000000..8e28996a4405b52107bfb424170f18c5fb8d2a85
--- /dev/null
+++ b/lean/OAI/Algebra/GroupRing/WordBlocks.lean
@@ -0,0 +1,391 @@
+import Mathlib
+import OAI.Algebra.GroupRing.ContiguousSplit
+
+namespace OAI
+
+noncomputable section
+
+namespace TorsionFreeZeroDivisors.WordBlocks
+open scoped Classical
+open BlockBoundary
+variable {A : Type*}
+abbrev lengths (ws : List (List A)) : List ℕ := ws.map List.length
+abbrev Occ (ws : List (List A)) := BlockBoundary.Occ (lengths ws)
+lemma total_length (ws : List (List A)) : (lengths ws).sum=ws.flatten.length := by
+  induction ws with
+  | nil=>rfl
+  | cons w ws ih=>simpa only [lengths,List.map_cons,List.sum_cons,List.flatten_cons,List.length_append] using congrArg (w.length+·) ih
+def coordinates (ws : List (List A)) : Occ ws≃Fin ws.flatten.length :=
+  (BlockBoundary.coordinates (lengths ws)).trans (finCongr (total_length ws))
+def letter : (ws : List (List A))→Occ ws→A
+  | [],x=>Empty.elim x
+  | w::ws,x=>Sum.elim w.get (letter ws) x
+lemma coordinates_inl (w : List A) (ws : List (List A)) (x : Fin w.length) :
+    (coordinates (w::ws) (.inl x)).val=x.val := rfl
+lemma coordinates_inr (w : List A) (ws : List (List A)) (x : Occ ws) :
+    (coordinates (w::ws) (.inr x)).val=w.length+(coordinates ws x).val := rfl
+lemma letter_eq (ws : List (List A)) (x : Occ ws) :
+    letter ws x=ws.flatten.get (coordinates ws x) := by
+  induction ws with
+  | nil=>exact Empty.elim x
+  | cons w ws ih=>
+    cases x with
+    | inl x=>
+      change w[x.val]=((w++ws.flatten).get _)
+      simp only [List.get_eq_getElem,coordinates_inl]
+      rw [List.getElem_append_left x.isLt]
+    | inr x=>
+      rw [show letter (w::ws) (.inr x)=letter ws x from rfl,ih]
+      change ws.flatten[(coordinates ws x).val]=
+        (w++ws.flatten)[w.length+(coordinates ws x).val]'(by
+          simpa only [List.length_append] using Nat.add_lt_add_left (coordinates ws x).isLt w.length)
+      simpa only [Nat.add_comm] using List.getElem_append_right' w (coordinates ws x).isLt
+lemma finRotate_congr {n m : ℕ} (h : n=m) :
+    (finCongr h).symm.permCongr (finRotate m)=finRotate n := by subst m;rfl
+lemma full_eq (ws : List (List A)) :
+    (coordinates ws).symm.permCongr (finRotate ws.flatten.length)=
+      BlockBoundary.full (lengths ws) := by
+  change (BlockBoundary.coordinates (lengths ws)).symm.permCongr
+    ((finCongr (total_length ws)).symm.permCongr (finRotate ws.flatten.length))=_
+  rw [finRotate_congr]
+  rfl
+/-- A full inverse-letter matching on the separate literal word boundaries,
+with actual combinatorial genus zero. This is not a PL-picture assertion. -/
+structure Matching (inv : A→A) (ws : List (List A)) where
+  partner : Equiv.Perm (Occ ws)
+  involutive : Function.Involutive partner
+  fixed_free : ∀x,partner x≠x
+  compatible : ∀x,letter ws (partner x)=inv (letter ws x)
+  genusZero : MapEuler.GenusZero (BlockBoundary.rotation (lengths ws)) partner
+
+def ofDisk {inv : A→A} (ws : List (List A))
+    (d : WordPairing.Data inv ws.flatten.get) : Matching inv ws where
+  partner := (coordinates ws).symm.permCongr d.partner
+  involutive := PermutationTransport.involutive _ _ d.involutive
+  fixed_free := PermutationTransport.fixed_free _ _ d.distinct
+  compatible x := by
+    simp only [letter_eq,Equiv.permCongr_apply,Equiv.symm_symm,Equiv.apply_symm_apply]
+    exact d.compatible _
+  genusZero := by
+    have hh := MapConjugation.genusZero (coordinates ws).symm _ _ d.genusZero
+    rw [full_eq] at hh
+    exact BoundaryRefinement.preserves (BlockBoundary.refinement (lengths ws)) _
+      (PermutationTransport.involutive _ _ d.involutive) hh
+/-- The literal free identity has a planar matching on its blocks, even if
+some of the blocks are empty. No nonempty-relator premise is added. -/
+theorem of_identity {B : Type*} (ws : List (List (B×Bool)))
+    (h : FreeGroup.mk ws.flatten=1) : Nonempty (Matching WordPairing.inverseLetter ws) := by
+  obtain ⟨d⟩ := WordPairing.of_identity h
+  exact ⟨ofDisk ws d⟩
+
+end TorsionFreeZeroDivisors.WordBlocks
+namespace TorsionFreeZeroDivisors.AlgebraicPictures
+open FreeGroup
+variable {A I : Type*} (rel : I→List (A×Bool)) (outer : List (A×Bool))
+def blockWords (ts : List (Term (A:=A) (I:=I))) : List (List (A×Bool)) :=
+  invRev outer::ts.map (Term.word rel)
+lemma blockWords_flatten (ts : List (Term (A:=A) (I:=I))) :
+    (blockWords rel outer ts).flatten=cutWord rel outer ts := by
+  simp only [blockWords,List.flatten_cons,←List.flatMap_def,cutWord,word]
+/-- The algebraic null word yields a literal genus-zero matching after
+separating the outer word and every conjugated relator into distinct cyclic
+boundaries. Conjugator suppression and graph lifts are not assumed here. -/
+theorem quotient_block_matching (h : PresentedGroup.mk (relations rel) (mk outer)=1) :
+    ∃ts : List (Term (A:=A) (I:=I)),
+      Nonempty (WordBlocks.Matching WordPairing.inverseLetter (blockWords rel outer ts)) := by
+  obtain ⟨ts,ht⟩ := expansion rel (PresentedGroup.mk_eq_one_iff.mp h)
+  refine ⟨ts,WordBlocks.of_identity _ ?_⟩
+  rw [blockWords_flatten,cutWord,←mul_mk,←inv_mk,ht,inv_mul_cancel]
+
+end TorsionFreeZeroDivisors.AlgebraicPictures
+
+namespace TorsionFreeZeroDivisors.CyclicCaps
+open scoped Classical
+variable {R : Type} (n : ℕ)
+abbrev O := Fin (n+2)⊕R
+abbrev p : O (R:=R) n := .inl (Fin.last (n+1))
+abbrev q : O (R:=R) n := .inl 0
+lemma distinct : p (R:=R) n≠q n := by
+  intro h
+  have he := congrArg (fun x : Fin (n+2)=>x.val) (Sum.inl.inj h)
+  simp only [Fin.val_last,Fin.val_zero] at he
+  omega
+def raise (i : Fin n) : Fin (n+2) := ⟨i.val+1,by omega⟩
+def embed : Fin n⊕R→MatchingSurgery.Remaining (p (R:=R) n) (q n)
+  | .inl i=>⟨.inl (raise n i),by
+      constructor <;> intro h
+      · have hh := congrArg Fin.val (Sum.inl.inj h)
+        simp only [raise,Fin.val_last] at hh
+        omega
+      · have hh := congrArg Fin.val (Sum.inl.inj h)
+        simp only [raise,Fin.val_zero] at hh
+        omega⟩
+  | .inr r=>⟨.inr r,by simp [p,q]⟩
+lemma embed_injective : Function.Injective (embed (R:=R) n) := by
+  intro x y he
+  have hh := congrArg Subtype.val he
+  cases x <;> cases y
+  · apply congrArg Sum.inl
+    apply Fin.ext
+    have hh := congrArg Fin.val (Sum.inl.inj hh)
+    simpa only [raise,embed,Nat.add_right_cancel_iff] using hh
+  · cases hh
+  · cases hh
+  · exact congrArg Sum.inr (Sum.inr.inj hh)
+lemma embed_surjective : Function.Surjective (embed (R:=R) n) := by
+  rintro ⟨x,hp,hq⟩
+  cases x with
+  | inl i=>
+    have hi0 : i.val≠0 := fun h=>hq (congrArg Sum.inl (Fin.ext h))
+    have hilast : i.val≠n+1 := fun h=>hp (congrArg Sum.inl (Fin.ext h))
+    let j : Fin n := ⟨i.val-1,by omega⟩
+    refine ⟨.inl j,?_⟩
+    apply Subtype.ext
+    apply congrArg Sum.inl
+    apply Fin.ext
+    change (i.val-1)+1=i.val
+    omega
+  | inr r=>exact ⟨.inr r,rfl⟩
+def coordinates : (Fin n⊕R)≃MatchingSurgery.Remaining (p (R:=R) n) (q n) :=
+  Equiv.ofBijective (embed n) ⟨embed_injective n,embed_surjective n⟩
+variable (ρ : Equiv.Perm R)
+def rotation : Equiv.Perm (O (R:=R) n) := Equiv.sumCongr (finRotate (n+2)) ρ
+lemma next : rotation n ρ (p n)=q n := by simp [rotation,p,q]
+lemma rotation_commutes (x : Fin n⊕R) :
+    Tightening.rotation (rotation n ρ) (p n) (q n) (distinct n) (next n ρ) (coordinates n x)=
+      coordinates n (Equiv.sumCongr (finRotate n) ρ x) := by
+  let : DecidableEq (O (R:=R) n) := fun _ _=>Classical.propDecidable _
+  apply Subtype.ext
+  change Equiv.swap (p n) (rotation n ρ (q n))
+    (rotation n ρ (embed n x))=(embed n (Equiv.sumCongr (finRotate n) ρ x)).val
+  cases x with
+  | inr r=>simp [rotation,embed,p,q,Equiv.swap_apply_def]
+  | inl i=>
+    have hr : (finRotate (n+2) (raise n i)).val=i.val+2 := by
+      rw [ContiguousSplit.rotate_val]
+      split_ifs with h
+      all_goals dsimp only [raise] at *
+      all_goals omega
+    have hz : (finRotate (n+2) (0 : Fin (n+2))).val=1 := by
+      rw [ContiguousSplit.rotate_val,ite_eq_right (by simp only [Fin.val_zero];omega)]
+      rfl
+    by_cases hi : i.val+1=n
+    · have hp : rotation n ρ (embed (R:=R) n (.inl i)).val=p n := by
+        apply congrArg Sum.inl
+        apply Fin.ext
+        exact hr.trans (by simp only [Fin.val_last];omega)
+      rw [hp,Equiv.swap_apply_left]
+      apply congrArg Sum.inl
+      apply Fin.ext
+      change (finRotate (n+2) (0 : Fin (n+2))).val=(finRotate n i).val+1
+      rw [hz,ContiguousSplit.rotate_val,ite_eq_left hi]
+    · have hp : rotation n ρ (embed (R:=R) n (.inl i)).val≠p n := by
+        intro hh
+        have hh := congrArg Fin.val (Sum.inl.inj hh)
+        change (finRotate (n+2) (raise n i)).val=n+1 at hh
+        rw [hr] at hh
+        omega
+      have hq : rotation n ρ (embed (R:=R) n (.inl i)).val≠rotation n ρ (q n) := by
+        intro hh
+        have hh := (rotation n ρ).injective hh
+        exact (embed (R:=R) n (.inl i)).property.2 hh
+      rw [Equiv.swap_apply_of_ne_of_ne hp hq]
+      apply congrArg Sum.inl
+      apply Fin.ext
+      change (finRotate (n+2) (raise n i)).val=(finRotate n i).val+1
+      rw [hr,ContiguousSplit.rotate_val,ite_eq_right hi]
+lemma rotation_conjugate :
+    Tightening.rotation (rotation n ρ) (p n) (q n) (distinct n) (next n ρ)=
+      (coordinates n).permCongr (Equiv.sumCongr (finRotate n) ρ) := by
+  apply Equiv.ext
+  intro x
+  obtain ⟨x,rfl⟩ := (coordinates n).surjective x
+  rw [rotation_commutes]
+  simp only [Equiv.permCongr_apply,Equiv.symm_apply_apply]
+variable [Fintype R]
+variable (α : Equiv.Perm (O (R:=R) n)) (hi : Function.Involutive α) (hf : ∀x,α x≠x)
+def partner : Equiv.Perm (Fin n⊕R) :=
+  (coordinates n).symm.permCongr (MatchingSurgery.partner α hi hf (p n) (q n) (distinct n))
+omit [Fintype R] in
+lemma involutive : Function.Involutive (partner n α hi hf) :=
+  PermutationTransport.involutive _ _ (MatchingSurgery.involutive α hi hf (p n) (q n) (distinct n))
+omit [Fintype R] in
+lemma fixed_free (x : Fin n⊕R) : partner n α hi hf x≠x :=
+  PermutationTransport.fixed_free _ _ (MatchingSurgery.distinct α hi hf (p n) (q n) (distinct n)) x
+/-- Removing the two literal end letters of a cyclic block preserves genus
+zero with the forced matching splice. The enclosed block may be empty. -/
+theorem genusZero (hz : MapEuler.GenusZero (rotation n ρ) α) :
+    MapEuler.GenusZero (Equiv.sumCongr (finRotate n) ρ) (partner n α hi hf) := by
+  let : DecidableEq (O (R:=R) n) := fun _ _=>Classical.propDecidable _
+  have hh := Tightening.genusZero (rotation n ρ) (p n) (q n) (distinct n) (next n ρ) α hi hf hz
+  rw [rotation_conjugate] at hh
+  have ht := MapConjugation.genusZero (coordinates n).symm _ _ hh
+  have he : (coordinates n).symm.permCongr
+      ((coordinates n).permCongr (Equiv.sumCongr (finRotate n) ρ))=
+      Equiv.sumCongr (finRotate n) ρ := by
+    apply Equiv.ext
+    intro x
+    simp only [Equiv.permCongr_apply,Equiv.symm_symm,Equiv.symm_apply_apply]
+  rw [he] at ht
+  exact ht
+variable {A : Type*} (inv : A→A) (hinv : Function.Involutive inv) (label : O (R:=R) n→A)
+  (hc : ∀x,label (α x)=inv (label x)) (hl : label (q n)=inv (label (p n)))
+include hinv hc hl in
+omit [Fintype R] in
+lemma compatible (x : Fin n⊕R) :
+    label (embed n (partner n α hi hf x))=inv (label (embed n x)) := by
+  have hh := MatchingSurgery.compatible α hi hf (p n) (q n) (distinct n) inv hinv label hc hl (coordinates n x)
+  convert hh using 1
+  change label ((coordinates n) ((coordinates n).symm ((MatchingSurgery.partner α hi hf (p n) (q n) (distinct n))
+    (coordinates n x))))=_
+  rw [Equiv.apply_symm_apply]
+  all_goals rfl
+
+end TorsionFreeZeroDivisors.CyclicCaps
+namespace TorsionFreeZeroDivisors.WordBlocks
+
+section
+open scoped Classical
+variable {A : Type*} {inv : A→A} {ws vs : List (List A)}
+def Matching.rename (d : Matching inv ws) (e : Occ ws≃Occ vs)
+    (hl : ∀x,letter vs (e x)=letter ws x)
+    (hr : ∀x,e (BlockBoundary.rotation (lengths ws) x)=BlockBoundary.rotation (lengths vs) (e x)) :
+    Matching inv vs where
+  partner := e.permCongr d.partner
+  involutive := PermutationTransport.involutive _ _ d.involutive
+  fixed_free := PermutationTransport.fixed_free _ _ d.fixed_free
+  compatible x := by
+    obtain ⟨x,rfl⟩ := e.surjective x
+    simp only [Equiv.permCongr_apply,Equiv.symm_apply_apply,hl]
+    exact d.compatible x
+  genusZero := by
+    have hh := MapConjugation.genusZero e _ _ d.genusZero
+    have he : e.permCongr (BlockBoundary.rotation (lengths ws))=BlockBoundary.rotation (lengths vs) := by
+      apply Equiv.ext
+      intro x
+      obtain ⟨x,rfl⟩ := e.surjective x
+      simpa only [Equiv.permCongr_apply,Equiv.symm_apply_apply] using hr x
+    rwa [he] at hh
+
+def exchange {X Y Z : Type} : (X⊕(Y⊕Z))≃(Y⊕(X⊕Z)) where
+  toFun
+    | .inl x=>.inr (.inl x)
+    | .inr (.inl y)=>.inl y
+    | .inr (.inr z)=>.inr (.inr z)
+  invFun
+    | .inl y=>.inr (.inl y)
+    | .inr (.inl x)=>.inl x
+    | .inr (.inr z)=>.inr (.inr z)
+  left_inv x := by rcases x with x|y|z <;> rfl
+  right_inv x := by rcases x with x|y|z <;> rfl
+lemma exchange_rotation {X Y Z : Type} (f : Equiv.Perm X) (g : Equiv.Perm Y) (h : Equiv.Perm Z)
+    (x : X⊕(Y⊕Z)) :
+    exchange (Equiv.sumCongr f (Equiv.sumCongr g h) x)=
+      Equiv.sumCongr g (Equiv.sumCongr f h) (exchange x) := by
+  rcases x with x|y|z <;> rfl
+lemma exchange_letter {X Y Z : Type} (f : X→A) (g : Y→A) (h : Z→A) (x : X⊕(Y⊕Z)) :
+    Sum.elim g (Sum.elim f h) (exchange x)=Sum.elim f (Sum.elim g h) x := by
+  rcases x with x|y|z <;> rfl
+/-- Expose any literal word block while retaining all other blocks, in order. -/
+def focus (pre : List (List A)) (w : List A) (suffix : List (List A)) :
+    Occ (pre++w::suffix)≃Occ (w::(pre++suffix)) := match pre with
+  | []=>Equiv.refl _
+  | v::pre=>(Equiv.sumCongr (Equiv.refl (Fin v.length)) (focus pre w suffix)).trans exchange
+lemma focus_letter (pre : List (List A)) (w : List A) (suffix : List (List A))
+    (x : Occ (pre++w::suffix)) :
+    letter (w::(pre++suffix)) (focus pre w suffix x)=letter (pre++w::suffix) x := by
+  induction pre with
+  | nil=>rfl
+  | cons v pre ih=>
+    cases x with
+    | inl x=>rfl
+    | inr x=>
+      change Sum.elim w.get (Sum.elim v.get (letter (pre++suffix)))
+        (exchange (.inr (focus pre w suffix x)))=letter (pre++w::suffix) x
+      rw [exchange_letter]
+      exact ih x
+lemma focus_rotation (pre : List (List A)) (w : List A) (suffix : List (List A))
+    (x : Occ (pre++w::suffix)) :
+    focus pre w suffix (BlockBoundary.rotation (lengths (pre++w::suffix)) x)=
+      BlockBoundary.rotation (lengths (w::(pre++suffix))) (focus pre w suffix x) := by
+  induction pre with
+  | nil=>rfl
+  | cons v pre ih=>
+    cases x with
+    | inl x=>rfl
+    | inr x=>
+      change exchange (.inr (focus pre w suffix (BlockBoundary.rotation (lengths (pre++w::suffix)) x)))=
+        Equiv.sumCongr (finRotate w.length)
+          (Equiv.sumCongr (finRotate v.length) (BlockBoundary.rotation (lengths (pre++suffix))))
+            (exchange (.inr (focus pre w suffix x)))
+      rw [ih]
+      exact exchange_rotation (finRotate v.length) (finRotate w.length)
+        (BlockBoundary.rotation (lengths (pre++suffix))) (.inr (focus pre w suffix x))
+variable {w : List A}
+def Matching.focus (d : Matching inv (ws++w::vs)) : Matching inv (w::(ws++vs)) :=
+  d.rename (WordBlocks.focus ws w vs) (focus_letter ws w vs) (focus_rotation ws w vs)
+def Matching.unfocus (d : Matching inv (w::(ws++vs))) : Matching inv (ws++w::vs) :=
+  d.rename (WordBlocks.focus ws w vs).symm
+    (fun x=>by simpa using (focus_letter ws w vs ((WordBlocks.focus ws w vs).symm x)).symm)
+    (fun x=>by
+      apply (WordBlocks.focus ws w vs).injective
+      simpa only [Equiv.apply_symm_apply] using (focus_rotation ws w vs ((WordBlocks.focus ws w vs).symm x)).symm)
+
+end
+open scoped Classical
+variable {A : Type*} {inv : A→A} (hinv : Function.Involutive inv)
+variable (a : A) (w : List A) (ws : List (List A))
+def capCoordinates : Occ ((a::(w++[inv a]))::ws)≃CyclicCaps.O (R:=Occ ws) w.length :=
+  Equiv.sumCongr (finCongr (by simp)) (Equiv.refl _)
+lemma capRotation : (capCoordinates (inv:=inv) a w ws).permCongr
+    (BlockBoundary.rotation (lengths ((a::(w++[inv a]))::ws)))=
+      CyclicCaps.rotation w.length (BlockBoundary.rotation (lengths ws)) := by
+  apply Equiv.ext
+  intro x
+  cases x with
+  | inl i=>
+    apply congrArg Sum.inl
+    have h : (a::(w++[inv a])).length=w.length+2 := by simp
+    exact Equiv.congr_fun (finRotate_congr h.symm) i
+  | inr i=>rfl
+abbrev capLabel := fun x:CyclicCaps.O (R:=Occ ws) w.length=>
+  letter ((a::(w++[inv a]))::ws) ((capCoordinates (inv:=inv) a w ws).symm x)
+lemma capLabel_q : capLabel (inv:=inv) a w ws (CyclicCaps.q w.length)=a := by rfl
+lemma capLabel_p : capLabel (inv:=inv) a w ws (CyclicCaps.p w.length)=inv a := by
+  change (a::(w++[inv a]))[w.length+1]=inv a
+  simp
+lemma capLabel_embed (x : Occ (w::ws)) :
+    capLabel (inv:=inv) a w ws (CyclicCaps.embed w.length x)=letter (w::ws) x := by
+  cases x with
+  | inl i=>
+    change (a::(w++[inv a]))[i.val+1]=w[i.val]
+    simp only [List.getElem_cons_succ,List.getElem_append_left i.isLt]
+  | inr i=>rfl
+/-- Tighten inverse end caps of one literal word boundary. The matching is
+spliced, and its genuine genus zero remains valid even for an empty interior. -/
+def Matching.removeCaps (d : Matching inv ((a::(w++[inv a]))::ws)) : Matching inv (w::ws) := by
+  let e := capCoordinates (inv:=inv) a w ws
+  let α := e.permCongr d.partner
+  have hi : Function.Involutive α := PermutationTransport.involutive e d.partner d.involutive
+  have hf : ∀x,α x≠x := PermutationTransport.fixed_free e d.partner d.fixed_free
+  have hz : MapEuler.GenusZero (CyclicCaps.rotation w.length (BlockBoundary.rotation (lengths ws))) α := by
+    have ht := MapConjugation.genusZero e _ _ d.genusZero
+    rwa [show e.permCongr (BlockBoundary.rotation (lengths ((a::(w++[inv a]))::ws)))=
+      CyclicCaps.rotation w.length (BlockBoundary.rotation (lengths ws)) from capRotation a w ws] at ht
+  have hc : ∀x,capLabel (inv:=inv) a w ws (α x)=inv (capLabel (inv:=inv) a w ws x) := by
+    intro x
+    simpa only [capLabel,α,e,Equiv.permCongr_apply,Equiv.symm_apply_apply] using d.compatible (e.symm x)
+  refine ⟨CyclicCaps.partner w.length α hi hf,
+    CyclicCaps.involutive w.length α hi hf,
+    CyclicCaps.fixed_free w.length α hi hf,?_,CyclicCaps.genusZero w.length _ α hi hf hz⟩
+  intro x
+  have hh := CyclicCaps.compatible w.length α hi hf inv hinv (capLabel (inv:=inv) a w ws) hc
+    (by rw [capLabel_q,capLabel_p,hinv]) x
+  rw [capLabel_embed a w ws (CyclicCaps.partner w.length α hi hf x),capLabel_embed a w ws x] at hh
+  exact hh
+
+end TorsionFreeZeroDivisors.WordBlocks
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/GroupRing/WordBlocksFurther.lean b/lean/OAI/Algebra/GroupRing/WordBlocksFurther.lean
new file mode 100644
index 0000000000000000000000000000000000000000..c58ec5fa5aad313c44b9badcf6fdaba7c4e5821e
--- /dev/null
+++ b/lean/OAI/Algebra/GroupRing/WordBlocksFurther.lean
@@ -0,0 +1,78 @@
+import Mathlib
+import OAI.Algebra.GroupRing.WordBlocks
+import OAI.Algebra.GroupRing.WordCursor
+
+namespace OAI
+
+section
+
+namespace TorsionFreeZeroDivisors.WordBlocks
+open scoped Classical
+noncomputable section
+variable {A G : Type*} [Group G] (v : A→G) {inv : A→A} {ws : List (List A)}
+structure Lift (d : Matching inv ws) where
+  position : Occ ws→G
+  next : ∀i,position (BlockBoundary.rotation (lengths ws) i)=position i*v (letter ws i)
+  pair : ∀i,position (d.partner i)=position i*v (letter ws i)
+variable {v}
+lemma cursor_rotation (w : List A) (hw : WordCursor.value v w=1) (i : Fin w.length) :
+    WordCursor.cursor v w (finRotate w.length i).val=WordCursor.cursor v w i.val*v (w.get i) := by
+  by_cases hi : i.val+1<w.length
+  · have hh : (finRotate w.length i).val=i.val+1 := by
+      obtain ⟨n,hn⟩ := Nat.exists_eq_succ_of_ne_zero (by omega : w.length≠0)
+      have aux : ∀j : Fin w.length,j.val+1<w.length→(finRotate w.length j).val=j.val+1 := by
+        rw [hn]
+        rintro ⟨j,hj⟩ hjj
+        change j+1<n+1 at hjj
+        exact congrArg Fin.val (finRotate_of_lt (by omega : j<n))
+      exact aux i hi
+    rw [hh]
+    exact WordCursor.cursor_succ v w i
+  · have he : i.val+1=w.length := by omega
+    have h := WordCursor.cursor_succ v w i
+    rw [he,WordCursor.cursor_length,hw] at h
+    have hh : (finRotate w.length i).val=0 := by
+      obtain ⟨n,hn⟩ := Nat.exists_eq_succ_of_ne_zero (by omega : w.length≠0)
+      have aux : ∀j : Fin w.length,j.val+1=w.length→(finRotate w.length j).val=0 := by
+        rw [hn]
+        intro j hj
+        have hjj : j=Fin.last n := by apply Fin.ext; simp only [Fin.val_last];omega
+        rw [hjj,finRotate_last]
+        rfl
+      exact aux i he
+    rw [hh]
+    exact h
+lemma flat_rotation (ws : List (List A)) (h : ∀w∈ws,WordCursor.value v w=1) (i : Occ ws) :
+    WordCursor.cursor v ws.flatten (coordinates ws (BlockBoundary.rotation (lengths ws) i)).val=
+      WordCursor.cursor v ws.flatten (coordinates ws i).val*v (letter ws i) := by
+  induction ws with
+  | nil=>exact Empty.elim i
+  | cons w ws ih=>
+    cases i with
+    | inl i=>
+      change WordCursor.cursor v (w++ws.flatten) (finRotate w.length i).val=
+        WordCursor.cursor v (w++ws.flatten) i.val*v (w.get i)
+      rw [WordCursor.cursor_append_left v _ _ _ (finRotate _ i).isLt.le,
+        WordCursor.cursor_append_left v _ _ _ i.isLt.le]
+      exact cursor_rotation w (h w (List.mem_cons_self)) i
+    | inr i=>
+      change WordCursor.cursor v (w++ws.flatten) (w.length+(coordinates ws (BlockBoundary.rotation (lengths ws) i)).val)=
+        WordCursor.cursor v (w++ws.flatten) (w.length+(coordinates ws i).val)*v (letter ws i)
+      rw [WordCursor.cursor_append_right,WordCursor.cursor_append_right,
+        ih (fun w hw=>h w (List.mem_cons_of_mem _ hw)),mul_assoc]
+def liftOfDisk (d : WordPairing.Data inv ws.flatten.get) (hd : WordCursor.Paired v inv d)
+    (h : ∀w∈ws,WordCursor.value v w=1) : Lift v (ofDisk ws d) where
+  position i := WordCursor.cursor v ws.flatten (coordinates ws i).val
+  next := flat_rotation ws h
+  pair i := by
+    change WordCursor.cursor v ws.flatten (coordinates ws ((coordinates ws).symm.permCongr d.partner i)).val=_
+    simp only [Equiv.permCongr_apply,Equiv.symm_symm,Equiv.apply_symm_apply,letter_eq]
+    exact hd _
+end
+end TorsionFreeZeroDivisors.WordBlocks
+
+end
+
+
+
+end OAI
diff --git a/lean/OAI/Algebra/GroupRing/WordCursor.lean b/lean/OAI/Algebra/GroupRing/WordCursor.lean
new file mode 100644
index 0000000000000000000000000000000000000000..94822d851124a040027391c7ffb72498f69527ce
--- /dev/null
+++ b/lean/OAI/Algebra/GroupRing/WordCursor.lean
@@ -0,0 +1,114 @@
+import Mathlib
+import OAI.Algebra.GroupRing.ClosedWords
+
+namespace OAI
+
+noncomputable section
+
+namespace TorsionFreeZeroDivisors.WordCursor
+
+section
+open scoped Classical
+variable {A G : Type*} [Group G] (v : A→G)
+def value (w : List A) : G := (w.map v).prod
+def cursor (w : List A) (n : ℕ) : G := value v (w.take n)
+@[simp] lemma value_nil : value v []=1 := rfl
+@[simp] lemma value_cons (a : A) (w : List A) : value v (a::w)=v a*value v w := rfl
+@[simp] lemma value_append (x y : List A) : value v (x++y)=value v x*value v y := by simp [value]
+@[simp] lemma cursor_zero (w : List A) : cursor v w 0=1 := rfl
+@[simp] lemma cursor_length (w : List A) : cursor v w w.length=value v w := by simp [cursor]
+lemma cursor_succ (w : List A) (i : Fin w.length) :
+    cursor v w (i.val+1)=cursor v w i.val*v (w.get i) := by
+  rw [cursor,List.take_succ_eq_append_getElem i.isLt,value_append]
+  simp only [value_cons,value_nil,mul_one]
+  rfl
+lemma cursor_append_left (x y : List A) (n : ℕ) (hn : n≤x.length) :
+    cursor v (x++y) n=cursor v x n := by
+  rw [cursor,List.take_append_of_le_length hn]
+  rfl
+lemma cursor_append_right (x y : List A) (n : ℕ) :
+    cursor v (x++y) (x.length+n)=value v x*cursor v y n := by
+  simp only [cursor,List.take_append,List.take_of_length_le (by omega : x.length≤x.length+n),
+    Nat.add_sub_cancel_left,value_append]
+lemma cursor_cons_succ (a : A) (w : List A) (n : ℕ) :
+    cursor v (a::w) (n+1)=v a*cursor v w n := rfl
+lemma insert_old (u w : List A) (a b : A) (hb : v a*v b=1) (i : ℕ) :
+    cursor v (u++a::b::w) (if i<u.length then i else i+2)=cursor v (u++w) i := by
+  by_cases hi : i<u.length
+  · rw [ite_eq_left hi,cursor_append_left v u (a::b::w) i hi.le,cursor_append_left v u w i hi.le]
+  · rw [ite_eq_right hi]
+    have hs : i=u.length+(i-u.length) := by omega
+    rw [hs,show u.length+(i-u.length)+2=u.length+((i-u.length)+2) by omega,
+      cursor_append_right,cursor_append_right]
+    rw [show (i-u.length)+2=((i-u.length)+1)+1 by omega,cursor_cons_succ,cursor_cons_succ]
+    calc
+      _=value v u*((v a*v b)*cursor v w (i-u.length)) := by simp only [mul_assoc]
+      _=_ := by rw [hb,one_mul]
+lemma insert_first (u w : List A) (a b : A) : cursor v (u++a::b::w) u.length=value v u := by
+  rw [cursor_append_left v u _ _ le_rfl,cursor_length]
+lemma insert_second (u w : List A) (a b : A) : cursor v (u++a::b::w) (u.length+1)=value v u*v a := by
+  rw [cursor_append_right,cursor_cons_succ,cursor_zero,mul_one]
+variable (inv : A→A) (hv : ∀a,v (inv a)=(v a)⁻¹)
+def Paired {w : List A} (d : WordPairing.Data inv w.get) : Prop :=
+  ∀i,cursor v w (d.partner i).val=cursor v w i.val*v (w.get i)
+include hv in
+lemma inserted (u w : List A) (a : A) (d : WordPairing.Data inv (u++w).get)
+    (ha : inv (inv a)=a) (hd : Paired v inv d) :
+    Paired v inv (WordPairing.ListInsert.data u w inv a d ha) := by
+  intro i
+  let hk : u.length≤(u++w).length := by simp only [List.length_append];omega
+  let e := WordPairing.Ear.equiv u.length hk
+  obtain ⟨i,rfl⟩ := (WordPairing.ListInsert.orderIso u w inv a).surjective i
+  obtain ⟨i,rfl⟩ := e.surjective i
+  change cursor v (u++a::inv a::w)
+    (((WordPairing.ListInsert.orderIso u w inv a).toEquiv.permCongr
+      (WordPairing.Ear.partner u.length d hk)) ((WordPairing.ListInsert.orderIso u w inv a) (e i))).val=_
+  simp only [Equiv.permCongr_apply]
+  change cursor v (u++a::inv a::w) (WordPairing.Ear.partner u.length d hk (e i)).val=_
+  rw [WordPairing.Ear.partner_apply]
+  cases i with
+  | inl i =>
+    change cursor v (u++a::inv a::w) (if (d.partner i).val<u.length then (d.partner i).val else (d.partner i).val+2)=
+      cursor v (u++a::inv a::w) (if i.val<u.length then i.val else i.val+2)*
+      v ((u++a::inv a::w).get ((WordPairing.ListInsert.orderIso u w inv a) (e (.inl i))))
+    rw [insert_old v u w a (inv a) (by rw [hv,mul_inv_cancel]),
+      insert_old v u w a (inv a) (by rw [hv,mul_inv_cancel])]
+    rw [WordPairing.ListInsert.labels_eq,WordPairing.Ear.labels_left]
+    exact hd i
+  | inr b =>
+    cases b
+    · change cursor v (u++a::inv a::w) (u.length+1)=cursor v (u++a::inv a::w) u.length*
+        v ((u++a::inv a::w).get ((WordPairing.ListInsert.orderIso u w inv a) (e (.inr false))))
+      rw [insert_first,insert_second,WordPairing.ListInsert.labels_eq,WordPairing.Ear.labels_false]
+    · change cursor v (u++a::inv a::w) u.length=cursor v (u++a::inv a::w) (u.length+1)*
+        v ((u++a::inv a::w).get ((WordPairing.ListInsert.orderIso u w inv a) (e (.inr true))))
+      rw [insert_first,insert_second,WordPairing.ListInsert.labels_eq,WordPairing.Ear.labels_true,hv,
+        mul_inv_cancel_right]
+end
+open scoped Classical
+variable {A G : Type*} [Group G] (v : A×Bool→G)
+  (hv : ∀a,v (WordPairing.inverseLetter a)=(v a)⁻¹)
+include hv in
+lemma of_reduction {w : List (A×Bool)} (h : FreeGroup.Red w []) :
+    ∃d : WordPairing.Data WordPairing.inverseLetter w.get,Paired v _ d := by
+  induction h using Relation.ReflTransGen.head_induction_on with
+  | refl => exact ⟨WordPairing.emptyData,fun i=>Fin.elim0 i⟩
+  | @head x y hxy hy ih =>
+    cases hxy with
+    | @not u w a b =>
+      obtain ⟨d,hd⟩ := ih
+      exact ⟨WordPairing.ListInsert.data u w WordPairing.inverseLetter (a,b) d
+        (WordPairing.inverseLetter_involutive _),inserted v _ hv u w (a,b) d
+        (WordPairing.inverseLetter_involutive _) hd⟩
+include hv in
+lemma of_identity {w : List (A×Bool)} (h : FreeGroup.mk w=1) :
+    ∃d : WordPairing.Data WordPairing.inverseLetter w.get,Paired v _ d := by
+  apply of_reduction v hv
+  have hh : FreeGroup.reduce w=[] := FreeGroup.reduce.sound h
+  rw [←hh]
+  exact FreeGroup.reduce.red
+end TorsionFreeZeroDivisors.WordCursor
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/GroupRing/WordEstimate.lean b/lean/OAI/Algebra/GroupRing/WordEstimate.lean
new file mode 100644
index 0000000000000000000000000000000000000000..f9627f5a95c68b06b02dc3f2ddd779a8b624c581
--- /dev/null
+++ b/lean/OAI/Algebra/GroupRing/WordEstimate.lean
@@ -0,0 +1,386 @@
+import Mathlib
+
+namespace OAI
+
+noncomputable section
+
+namespace TorsionFreeZeroDivisors
+namespace WordEstimate
+
+open scoped BigOperators
+
+abbrev Letter := (Fin 3 ⊕ Fin 8255) × Bool
+
+def inverse (t : Letter) : Letter := (t.1, !t.2)
+
+def IsExtra (t : Letter) : Prop := ∃ i : Fin 3, t = (Sum.inl i, true)
+
+instance (t : Letter) : Decidable (IsExtra t) := inferInstanceAs (Decidable (∃ _, _))
+
+@[simp] theorem isExtra_inl (i : Fin 3) (b : Bool) :
+    IsExtra (Sum.inl i, b) ↔ b = true := by simp [IsExtra, Prod.mk.injEq]
+
+@[simp] theorem not_isExtra_inr (i : Fin 8255) (b : Bool) :
+    ¬IsExtra (Sum.inr i, b) := by simp [IsExtra]
+
+@[simp] theorem inverse_inverse (t : Letter) : inverse (inverse t) = t := by
+  simp [inverse]
+
+theorem inverse_ne (t : Letter) : inverse t ≠ t := by
+  rcases t with ⟨i, b⟩
+  cases b <;> simp [inverse]
+
+theorem extra_inverse_not_extra (t : Letter) (h : IsExtra t) : ¬IsExtra (inverse t) := by
+  obtain ⟨i, rfl⟩ := h
+  simp [inverse]
+
+/-- The exact marginal letter frequency `p=129/16513`. -/
+def p : ℝ := 129 / 16513
+
+/-- Conditional turn weights on side B before setting cancelling turns to zero. -/
+def baseWeight (t u : Letter) : ℝ :=
+  if IsExtra (inverse t) then (if IsExtra u then 1 else p)
+  else (if IsExtra u then p else 1 / 129)
+
+/-- Source `w(t,u)`, including zero on cancelling turns. -/
+def weight (t u : Letter) : ℝ := if u = inverse t then 0 else baseWeight t u
+
+/-- The positive test vector in the manuscript's matrix argument. -/
+def f (t : Letter) : ℝ := if IsExtra (inverse t) then 5 else 1
+
+theorem one_le_f (t : Letter) : 1 ≤ f t := by
+  unfold f
+  split_ifs <;> norm_num
+
+theorem f_extra (t : Letter) (h : IsExtra t) : f t = 1 := by
+  simp [f, extra_inverse_not_extra t h]
+
+theorem sum_f : (∑ t : Letter, f t) = 16528 := by
+  simp [Letter, Fintype.sum_prod_type, Fintype.sum_sum_type,
+    f, inverse]
+  norm_num
+
+/-- The two row types have the exact untruncated mass given by the source. -/
+theorem base_row_mass (t : Letter) :
+    (∑ u : Letter, baseWeight t u ^ 2 * f u) =
+      if IsExtra (inverse t) then 3 + 16525 * p ^ 2
+      else 3 * p ^ 2 + 16525 / 129 ^ 2 := by
+  unfold baseWeight
+  split_ifs with h
+  · simp [Letter, Fintype.sum_prod_type, Fintype.sum_sum_type,
+      f, inverse]
+    ring
+  · simp [Letter, Fintype.sum_prod_type, Fintype.sum_sum_type,
+      f, inverse]
+    ring
+
+/-- Removing the cancelling turn removes precisely its diagonal summand. -/
+theorem row_mass (t : Letter) :
+    (∑ u : Letter, weight t u ^ 2 * f u) =
+      (∑ u : Letter, baseWeight t u ^ 2 * f u) -
+        baseWeight t (inverse t) ^ 2 * f (inverse t) := by
+  classical
+  have h (u : Letter) : weight t u ^ 2 * f u =
+      baseWeight t u ^ 2 * f u -
+        if u = inverse t then baseWeight t u ^ 2 * f u else 0 := by
+    by_cases hu : u = inverse t <;> simp [weight, hu]
+  simp_rw [h, Finset.sum_sub_distrib]
+  simp
+
+/-- `Mf ≤ (149/150)f`, with the exact alphabet, weights and constants. -/
+theorem matrix_contraction (t : Letter) :
+    (∑ u : Letter, weight t u ^ 2 * f u) ≤ (149 / 150 : ℝ) * f t := by
+  rw [row_mass, base_row_mass]
+  by_cases h : IsExtra (inverse t)
+  · have hfi : f (inverse t) = 1 := f_extra _ h
+    have hft : f t = 5 := by simp [f, h]
+    simp only [h, ite_true, baseWeight, hfi, hft]
+    norm_num [p]
+  · have hf := one_le_f (inverse t)
+    have hft : f t = 1 := by simp [f, h]
+    simp only [h, ite_false, baseWeight, hft]
+    norm_num [p]
+    nlinarith
+
+/-- Product of the turn weights from a starting letter through a tail. -/
+def continuation : (n : ℕ) → Letter → (Fin n → Letter) → ℝ
+  | 0, _, _ => 1
+  | n + 1, t, W => weight t (W 0) * continuation n (W 0) (Fin.tail W)
+
+/-- Source `P(W)`, with empty products equal to one. -/
+def wordWeight : (h : ℕ) → (Fin h → Letter) → ℝ
+  | 0, _ => 1
+  | h + 1, W => continuation h (W 0) (Fin.tail W)
+
+theorem sum_cons {n : ℕ} (F : (Fin (n + 1) → Letter) → ℝ) :
+    (∑ W, F W) = ∑ t, ∑ W, F (Fin.cons t W) := by
+  rw [← (Fin.consEquiv (fun _ : Fin (n + 1) => Letter)).sum_comp F]
+  rw [Fintype.sum_prod_type]
+  rfl
+
+/-- Iterating the exact matrix contraction controls all tails simultaneously. -/
+theorem continuation_mass (n : ℕ) (t : Letter) :
+    (∑ W : Fin n → Letter, continuation n t W ^ 2) ≤
+      (149 / 150 : ℝ) ^ n * f t := by
+  induction n generalizing t with
+  | zero => simpa [continuation] using one_le_f t
+  | succ n ih =>
+    rw [sum_cons]
+    simp only [continuation, Fin.cons_zero, Fin.tail_cons, mul_pow]
+    simp_rw [← Finset.mul_sum]
+    calc
+      ∑ u, weight t u ^ 2 * ∑ W : Fin n → Letter, continuation n u W ^ 2
+          ≤ ∑ u, weight t u ^ 2 * ((149 / 150 : ℝ) ^ n * f u) := by
+            apply Finset.sum_le_sum
+            intro u _
+            exact mul_le_mul_of_nonneg_left (ih u) (sq_nonneg _)
+      _ = (149 / 150 : ℝ) ^ n * ∑ u, weight t u ^ 2 * f u := by
+            rw [Finset.mul_sum]
+            apply Finset.sum_congr rfl
+            intro u _
+            ring
+      _ ≤ (149 / 150 : ℝ) ^ n * ((149 / 150 : ℝ) * f t) := by
+            apply mul_le_mul_of_nonneg_left (matrix_contraction t)
+            positivity
+      _ = (149 / 150 : ℝ) ^ (n + 1) * f t := by ring
+
+/-- The matrix form of the squared-word estimate, before exponent conversion. -/
+theorem squared_word_geometric_bound (h : ℕ) :
+    (∑ W : Fin (h + 1) → Letter, wordWeight (h + 1) W ^ 2) ≤
+      16528 * (149 / 150 : ℝ) ^ h := by
+  rw [sum_cons]
+  simp only [wordWeight, Fin.cons_zero, Fin.tail_cons]
+  calc
+    ∑ t, ∑ W : Fin h → Letter, continuation h t W ^ 2
+        ≤ ∑ t, (149 / 150 : ℝ) ^ h * f t := by
+          exact Finset.sum_le_sum fun t _ ↦ continuation_mass h t
+    _ = 16528 * (149 / 150 : ℝ) ^ h := by
+          rw [← Finset.mul_sum, sum_f]
+          ring
+
+theorem continuation_eq_product (n : ℕ) (t : Letter) (W : Fin n → Letter) :
+    continuation n t W =
+      ∏ i : Fin n, weight ((Fin.cons t W : Fin (n + 1) → Letter) i.castSucc)
+        ((Fin.cons t W : Fin (n + 1) → Letter) i.succ) := by
+  induction n generalizing t with
+  | zero => simp [continuation]
+  | succ n ih =>
+    rw [Fin.prod_univ_succ]
+    simp only [continuation, Fin.castSucc_zero, Fin.cons_zero, Fin.cons_succ,
+      ih]
+    simp only [Fin.cons_self_tail, Fin.castSucc_succ, Fin.cons_succ, Fin.tail]
+
+theorem wordWeight_eq_product (h : ℕ) (W : Fin (h + 1) → Letter) :
+    wordWeight (h + 1) W = ∏ i : Fin h, weight (W i.castSucc) (W i.succ) := by
+  rw [wordWeight, continuation_eq_product]
+  simp only [Fin.cons_self_tail]
+
+theorem constant_le_exp : (16528 : ℝ) ≤ Real.exp 10 := by
+  calc
+    (16528 : ℝ) ≤ (27 / 10 : ℝ) ^ 10 := by norm_num
+    _ ≤ Real.exp 1 ^ 10 := by
+      gcongr
+      exact le_of_lt (lt_trans (by norm_num) Real.exp_one_gt_d9)
+    _ = Real.exp 10 := by rw [← Real.exp_nat_mul]; norm_num
+
+theorem ratio_le_exp : (149 / 150 : ℝ) ≤ Real.exp (-1 / 150) := by
+  have h := Real.add_one_le_exp (-1 / 150)
+  linarith
+
+/-- The manuscript's exact numerical cutoff, without asymptotic weakening. -/
+theorem geometric_exponential_bound (n : ℕ) (hn : 3001 ≤ n) :
+    16528 * (149 / 150 : ℝ) ^ n ≤ Real.exp (-((n : ℝ) + 1) / 300) := by
+  calc
+    16528 * (149 / 150 : ℝ) ^ n
+        ≤ Real.exp 10 * Real.exp (-1 / 150) ^ n := by
+            apply mul_le_mul constant_le_exp
+            · gcongr; exact ratio_le_exp
+            · positivity
+            · positivity
+    _ = Real.exp (10 + (n : ℝ) * (-1 / 150)) := by
+          rw [← Real.exp_nat_mul, Real.exp_add]
+    _ ≤ Real.exp (-((n : ℝ) + 1) / 300) := by
+          apply Real.exp_le_exp.mpr
+          have hn' : (3001 : ℝ) ≤ n := by exact_mod_cast hn
+          linarith
+
+/-- Source lemma `lem:squared-words`, with its exhibited delta=1/600. -/
+theorem squared_word_estimate (h : ℕ) (hh : 3002 ≤ h) :
+    (∑ W : Fin h → Letter, wordWeight h W ^ 2) ≤
+      Real.exp (-2 * (1 / 600 : ℝ) * h) := by
+  obtain ⟨n, rfl⟩ := Nat.exists_eq_succ_of_ne_zero (by omega : h ≠ 0)
+  have hn : 3001 ≤ n := by omega
+  have hbound := le_trans (squared_word_geometric_bound n)
+    (geometric_exponential_bound n hn)
+  apply hbound.trans_eq
+  congr 1
+  simp only [Nat.cast_succ]
+  ring
+
+/-! Binning the weights: entropy.tex, equation (entropy-bins). -/
+
+theorem weight_nonneg (t u : Letter) : 0 ≤ weight t u := by
+  unfold weight baseWeight p
+  split_ifs <;> norm_num
+
+theorem weight_le_one (t u : Letter) : weight t u ≤ 1 := by
+  unfold weight baseWeight p
+  split_ifs <;> norm_num
+
+theorem weight_pos_lower (t u : Letter) (h : 0 < weight t u) :
+    (1 / 129 : ℝ) ≤ weight t u := by
+  unfold weight baseWeight p at *
+  split_ifs at * <;> norm_num at *
+
+theorem continuation_nonneg (n : ℕ) (t : Letter) (W : Fin n → Letter) :
+    0 ≤ continuation n t W := by
+  rw [continuation_eq_product]
+  exact Finset.prod_nonneg fun _ _ => weight_nonneg _ _
+
+theorem wordWeight_nonneg (h : ℕ) (W : Fin h → Letter) : 0 ≤ wordWeight h W := by
+  cases h with
+  | zero => norm_num [wordWeight]
+  | succ h => exact continuation_nonneg _ _ _
+
+theorem wordWeight_upper (h : ℕ) (hh : 3002 ≤ h) (W : Fin h → Letter) :
+    wordWeight h W ≤ Real.exp (-(1 / 600 : ℝ) * h) := by
+  have hsingle : wordWeight h W ^ 2 ≤
+      ∑ V : Fin h → Letter, wordWeight h V ^ 2 :=
+    Finset.single_le_sum (fun V _ => sq_nonneg (wordWeight h V)) (Finset.mem_univ W)
+  have he := hsingle.trans (squared_word_estimate h hh)
+  have hexp : Real.exp (-2 * (1 / 600 : ℝ) * h) =
+      Real.exp (-(1 / 600 : ℝ) * h) ^ 2 := by
+    rw [← Real.exp_nat_mul]
+    congr 1
+    ring
+  rw [hexp] at he
+  nlinarith [Real.exp_pos (-(1 / 600 : ℝ) * h)]
+
+/-- Exact logarithmic bins, excluding zero weights just as in the source. -/
+def binWords (h : ℕ) (d : ℤ) : Finset (Fin h → Letter) :=
+  Finset.univ.filter fun W => 0 < wordWeight h W ∧ ⌊-Real.log (wordWeight h W)⌋ = d
+
+theorem bin_sq_lower {h : ℕ} {d : ℤ} {W : Fin h → Letter}
+    (hW : W ∈ binWords h d) :
+    Real.exp (-2 * (d : ℝ) - 2) ≤ wordWeight h W ^ 2 := by
+  obtain ⟨hp, hd⟩ := (Finset.mem_filter.mp hW).2
+  have hfloor := Int.lt_floor_add_one (-Real.log (wordWeight h W))
+  rw [hd] at hfloor
+  have hlog : -2 * (d : ℝ) - 2 ≤ 2 * Real.log (wordWeight h W) := by linarith
+  have he := Real.exp_le_exp.mpr hlog
+  have hpow : Real.exp (2 * Real.log (wordWeight h W)) = wordWeight h W ^ 2 := by
+    rw [show (2 : ℝ) * Real.log (wordWeight h W) =
+      (2 : ℕ) * Real.log (wordWeight h W) by norm_num, Real.exp_nat_mul, Real.exp_log hp]
+  rwa [hpow] at he
+
+/-- The exact finite bin-count bound before replacing h by its common scale. -/
+theorem bin_card_bound (h : ℕ) (hh : 3002 ≤ h) (d : ℤ) :
+    ((binWords h d).card : ℝ) ≤
+      Real.exp (2 * (d : ℝ) + 2 - 2 * (1 / 600 : ℝ) * h) := by
+  have hlo : ((binWords h d).card : ℝ) * Real.exp (-2 * (d : ℝ) - 2) ≤
+      ∑ W ∈ binWords h d, wordWeight h W ^ 2 := by
+    simpa only [Finset.sum_const, nsmul_eq_mul] using
+      (Finset.sum_le_sum fun W hW => bin_sq_lower hW)
+  have hsum : (∑ W ∈ binWords h d, wordWeight h W ^ 2) ≤
+      ∑ W : Fin h → Letter, wordWeight h W ^ 2 := by
+    exact Finset.sum_le_sum_of_subset_of_nonneg (Finset.subset_univ _)
+      (fun W _ _ => sq_nonneg _)
+  have he := hlo.trans (hsum.trans (squared_word_estimate h hh))
+  apply (le_div_iff₀ (Real.exp_pos _)).mpr at he
+  apply he.trans_eq
+  rw [← Real.exp_sub]
+  congr 1
+  ring
+
+/-- Both the lower bin cutoff and the counting bound at the scalar block
+scale s. The displayed threshold absorbs the manuscript's rounding errors. -/
+theorem bin_scale_bounds (h : ℕ) (hh : 3002 ≤ h) (s : ℝ)
+    (hscale : s + 1200 ≤ 2 * h) (d : ℤ) (W : Fin h → Letter)
+    (hW : W ∈ binWords h d) :
+    (1 / 600 : ℝ) * s / 2 ≤ (d : ℝ) ∧
+      ((binWords h d).card : ℝ) ≤ Real.exp (2 * d - (1 / 600 : ℝ) * s) := by
+  obtain ⟨hp, hd⟩ := (Finset.mem_filter.mp hW).2
+  have hw := wordWeight_upper h hh W
+  have hlog : Real.log (wordWeight h W) ≤ -(1 / 600 : ℝ) * h := by
+    have he := Real.log_le_log hp hw
+    simpa only [Real.log_exp] using he
+  have hfloor := Int.lt_floor_add_one (-Real.log (wordWeight h W))
+  rw [hd] at hfloor
+  constructor
+  · linarith
+  · apply (bin_card_bound h hh d).trans
+    apply Real.exp_le_exp.mpr
+    linarith
+
+end WordEstimate
+end TorsionFreeZeroDivisors
+
+namespace TorsionFreeZeroDivisors.WordEstimate
+open scoped BigOperators
+
+/-- Every positive continuation has the uniform lower product bound from
+its smallest allowed turn weight. -/
+theorem continuation_lower (n : ℕ) (t : Letter) (W : Fin n → Letter)
+    (hp : 0 < continuation n t W) :
+    (1/129 : ℝ)^n ≤ continuation n t W := by
+  induction n generalizing t with
+  | zero => simp [continuation]
+  | succ n ih =>
+    dsimp [continuation] at hp ⊢
+    have ht : 0 < weight t (W 0) := (mul_pos_iff.mp hp).elim (fun h => h.1)
+      (fun h => False.elim (not_lt_of_ge (weight_nonneg _ _) h.1))
+    have hu : 0 < continuation n (W 0) (fun i => W i.succ) :=
+      (mul_pos_iff.mp hp).elim (fun h => h.2)
+        (fun h => False.elim (not_lt_of_ge (weight_nonneg _ _) h.1))
+    rw [pow_succ]
+    exact mul_le_mul (ih _ _ hu) (weight_pos_lower _ _ ht) (by positivity)
+      (continuation_nonneg _ _ _) |>.trans_eq (mul_comm _ _)
+
+theorem wordWeight_lower (h : ℕ) (W : Fin h → Letter) (hp : 0 < wordWeight h W) :
+    (1/129 : ℝ)^h ≤ wordWeight h W := by
+  cases h with
+  | zero => simp [wordWeight]
+  | succ n =>
+    have ht := continuation_lower n (W 0) (fun i => W i.succ) hp
+    have hb : (1/129 : ℝ)^(n+1) ≤ (1/129 : ℝ)^n := by
+      rw [pow_succ]
+      exact mul_le_of_le_one_right (by positivity) (by norm_num)
+    exact hb.trans ht
+
+/-- A coarse fixed upper bin constant; the manuscript leaves a₀ unspecified.
+We choose a₀=256, avoiding any numerical transcendental oracle. -/
+theorem bin_upper_bound (h : ℕ) (s : ℝ) (hscale : (h : ℝ) ≤ 2*s)
+    (d : ℤ) (W : Fin h → Letter) (hW : W ∈ binWords h d) : (d : ℝ) ≤ 256*s := by
+  obtain ⟨hp,hd⟩ := (Finset.mem_filter.mp hW).2
+  have ht := wordWeight_lower h W hp
+  have hl := Real.log_le_log (by positivity : (0 : ℝ) < (1/129 : ℝ)^h) ht
+  rw [Real.log_pow,Real.log_div (by norm_num) (by norm_num),Real.log_one,zero_sub] at hl
+  have hlog : Real.log (129 : ℝ) ≤ 128 := by
+    have hh := Real.log_le_sub_one_of_pos (by norm_num : (0:ℝ)<129)
+    norm_num at hh ⊢
+    exact hh
+  have hb := Int.floor_le (-Real.log (wordWeight h W))
+  rw [hd] at hb
+  have hm := mul_le_mul_of_nonneg_left hlog (Nat.cast_nonneg h : (0:ℝ)≤h)
+  nlinarith
+
+/-- Both bin cutoffs and the squared-word count with literal δ=1/600 and
+one universal upper constant. -/
+theorem bin_full_bounds (h : ℕ) (hh : 3002 ≤ h) (s : ℝ)
+    (hscale : s+1200 ≤ 2*h) (hscale' : (h : ℝ) ≤ 2*s)
+    (d : ℤ) (W : Fin h → Letter) (hW : W ∈ binWords h d) :
+    (1/600 : ℝ)*s/2 ≤ d ∧ (d : ℝ) ≤ 256*s ∧
+      ((binWords h d).card : ℝ) ≤ Real.exp (2*d-(1/600 : ℝ)*s) := by
+  obtain ⟨hl,hc⟩ := bin_scale_bounds h hh s hscale d W hW
+  exact ⟨hl,bin_upper_bound h s hscale' d W hW,hc⟩
+
+end TorsionFreeZeroDivisors.WordEstimate
+
+/-! Source entropy.tex 300--458, with all local root counts evaluated rather
+than assumed. A translation self-link saves the root; a component without one
+uses its selected bin-minimizing root. Reflection self-links are ruled out by
+`BlockConstraints.reflection_impossible` before this count is applied. -/
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/GroupRing/WordFrames.lean b/lean/OAI/Algebra/GroupRing/WordFrames.lean
new file mode 100644
index 0000000000000000000000000000000000000000..ea3a18b515fecdf2fbb57dea0dfc3022d7c980f2
--- /dev/null
+++ b/lean/OAI/Algebra/GroupRing/WordFrames.lean
@@ -0,0 +1,120 @@
+import Mathlib
+import OAI.Algebra.GroupRing.WordLiftSurgery
+
+namespace OAI
+
+
+
+section
+namespace TorsionFreeZeroDivisors.WordFrames
+open scoped Classical
+open WordBlocks WordCursor
+noncomputable section
+variable {A G : Type} [Group G] (v : A→G) (inv : A→A)
+abbrev words (bs : List (G×List A)) : List (List A) := bs.map Prod.snd
+def position : (bs : List (G×List A))→Occ (words bs)→G
+  | [],i=>Empty.elim i
+  | (g,w)::_bs,.inl i=>g*cursor v w i.val
+  | (_g,_w)::bs,.inr i=>position bs i
+structure Data (bs : List (G×List A)) where
+  matching : Matching inv (words bs)
+  lifted : Lift v matching
+  framed : ∀i,lifted.position i=position v bs i
+variable {v inv}
+def Data.rename {bs cs : List (G×List A)} (d : Data v inv bs)
+    (e : Occ (words bs)≃Occ (words cs))
+    (hl : ∀i,letter (words cs) (e i)=letter (words bs) i)
+    (hr : ∀i,e (BlockBoundary.rotation (lengths (words bs)) i)=BlockBoundary.rotation (lengths (words cs)) (e i))
+    (hp : ∀i,position v cs (e i)=position v bs i) : Data v inv cs where
+  matching := d.matching.rename e hl hr
+  lifted := d.lifted.rename e hl hr
+  framed i := by
+    change d.lifted.position (e.symm i)=_
+    rw [d.framed,←hp,Equiv.apply_symm_apply]
+variable (hv : ∀a,v (inv a)=(v a)⁻¹) (hi : Function.Involutive inv)
+def Data.removeCaps (g : G) (a : A) (w : List A) (bs : List (G×List A))
+    (d : Data v inv ((g,a::(w++[inv a]))::bs)) : Data v inv ((g*v a,w)::bs) where
+  matching := d.matching.removeCaps hi a w (words bs)
+  lifted := d.lifted.removeCaps hv hi
+  framed i := by
+    change d.lifted.position (capEmbedding a w (words bs) i)=_
+    rw [d.framed]
+    cases i with
+    | inl i=>
+      change g*cursor v (a::(w++[inv a])) (i.val+1)=(g*v a)*cursor v w i.val
+      rw [cursor_cons_succ,cursor_append_left v w [inv a] i.val i.isLt.le,mul_assoc]
+    | inr i=>rfl
+def focus : (pre : List (G×List A))→(g : G)→(w : List A)→(post : List (G×List A))→
+    Occ (words (pre++(g,w)::post))≃Occ (words ((g,w)::(pre++post)))
+  | [],_,_,_=>Equiv.refl _
+  | t::pre,g,w,post=>(Equiv.sumCongr (Equiv.refl (Fin t.2.length)) (focus pre g w post)).trans exchange
+omit [Group G] in
+lemma focus_letter (pre : List (G×List A)) (g : G) (w : List A) (post : List (G×List A))
+    (i : Occ (words (pre++(g,w)::post))) :
+    letter (words ((g,w)::(pre++post))) (focus pre g w post i)=letter (words (pre++(g,w)::post)) i := by
+  induction pre with
+  | nil=>rfl
+  | cons t pre ih=>
+    cases i with
+    | inl i=>rfl
+    | inr i=>
+      change Sum.elim w.get (Sum.elim t.2.get (letter (words (pre++post))))
+        (exchange (.inr (focus pre g w post i)))=letter (words (pre++(g,w)::post)) i
+      rw [exchange_letter]
+      exact ih i
+omit [Group G] in
+lemma focus_rotation (pre : List (G×List A)) (g : G) (w : List A) (post : List (G×List A))
+    (i : Occ (words (pre++(g,w)::post))) :
+    focus pre g w post (BlockBoundary.rotation (lengths (words (pre++(g,w)::post))) i)=
+      BlockBoundary.rotation (lengths (words ((g,w)::(pre++post)))) (focus pre g w post i) := by
+  induction pre with
+  | nil=>rfl
+  | cons t pre ih=>
+    cases i with
+    | inl i=>rfl
+    | inr i=>
+      change exchange (.inr (focus pre g w post (BlockBoundary.rotation (lengths (words (pre++(g,w)::post))) i)))=
+        Equiv.sumCongr (finRotate w.length)
+          (Equiv.sumCongr (finRotate t.2.length) (BlockBoundary.rotation (lengths (words (pre++post)))))
+          (exchange (.inr (focus pre g w post i)))
+      rw [ih]
+      exact exchange_rotation (finRotate t.2.length) (finRotate w.length) (BlockBoundary.rotation (lengths (words (pre++post)))) (.inr (focus pre g w post i))
+lemma focus_position (pre : List (G×List A)) (g : G) (w : List A) (post : List (G×List A))
+    (i : Occ (words (pre++(g,w)::post))) :
+    position v ((g,w)::(pre++post)) (WordFrames.focus pre g w post i)=position v (pre++(g,w)::post) i := by
+  induction pre with
+  | nil=>rfl
+  | cons t pre ih=>
+    cases t with
+    | mk g' w'=>
+      cases i with
+      | inl i=>rfl
+      | inr i=>
+        have hh := ih i
+        change position v ((g,w)::(g',w')::(pre++post))
+          (exchange (.inr (WordFrames.focus pre g w post i)))=position v (pre++(g,w)::post) i
+        cases he : WordFrames.focus pre g w post i with
+        | inl j=>rw [he] at hh; exact hh
+        | inr j=>rw [he] at hh; exact hh
+variable (v)
+def Data.focus (pre : List (G×List A)) (g : G) (w : List A) (post : List (G×List A))
+    (d : Data v inv (pre++(g,w)::post)) : Data v inv ((g,w)::(pre++post)) :=
+  d.rename (WordFrames.focus pre g w post)
+    (WordFrames.focus_letter _ _ _ _) (WordFrames.focus_rotation _ _ _ _) (focus_position pre g w post)
+def Data.unfocus (pre : List (G×List A)) (g : G) (w : List A) (post : List (G×List A))
+    (d : Data v inv ((g,w)::(pre++post))) : Data v inv (pre++(g,w)::post) :=
+  d.rename (WordFrames.focus pre g w post).symm
+    (fun x=>by simpa using (WordFrames.focus_letter pre g w post ((WordFrames.focus pre g w post).symm x)).symm)
+    (fun x=>by
+      apply (WordFrames.focus pre g w post).injective
+      simpa only [Equiv.apply_symm_apply] using (WordFrames.focus_rotation pre g w post ((WordFrames.focus pre g w post).symm x)).symm)
+    (fun x=>by simpa only [Equiv.apply_symm_apply] using
+      (focus_position (v:=v) pre g w post ((WordFrames.focus pre g w post).symm x)).symm)
+end
+end TorsionFreeZeroDivisors.WordFrames
+
+end
+
+
+
+end OAI
diff --git a/lean/OAI/Algebra/GroupRing/WordLiftSurgery.lean b/lean/OAI/Algebra/GroupRing/WordLiftSurgery.lean
new file mode 100644
index 0000000000000000000000000000000000000000..1d71465116f6594f951ed8c28595be9c6c0da03f
--- /dev/null
+++ b/lean/OAI/Algebra/GroupRing/WordLiftSurgery.lean
@@ -0,0 +1,101 @@
+import Mathlib
+import OAI.Algebra.GroupRing.WordBlocksFurther
+
+namespace OAI
+
+
+
+section
+namespace TorsionFreeZeroDivisors.WordBlocks
+open scoped Classical
+noncomputable section
+variable {A G : Type} [Group G] {v : A→G} {inv : A→A} {ws vs : List (List A)}
+def Lift.rename {d : Matching inv ws} (l : Lift v d) (e : Occ ws≃Occ vs)
+    (hl : ∀x,letter vs (e x)=letter ws x)
+    (hr : ∀x,e (BlockBoundary.rotation (lengths ws) x)=BlockBoundary.rotation (lengths vs) (e x)) :
+    Lift v (d.rename e hl hr) where
+  position i := l.position (e.symm i)
+  next i := by
+    obtain ⟨i,rfl⟩ := e.surjective i
+    rw [←hr,Equiv.symm_apply_apply,Equiv.symm_apply_apply,hl]
+    exact l.next i
+  pair i := by
+    obtain ⟨i,rfl⟩ := e.surjective i
+    change l.position (e.symm (e.permCongr d.partner (e i)))=_
+    simp only [Equiv.permCongr_apply,Equiv.symm_apply_apply,hl]
+    exact l.pair i
+variable (hv : ∀a,v (inv a)=(v a)⁻¹) (hinv : Function.Involutive inv)
+variable (a : A) (w : List A) (ws : List (List A))
+def capEmbedding (x : Occ (w::ws)) : Occ ((a::(w++[inv a]))::ws) :=
+  (capCoordinates (inv:=inv) a w ws).symm (CyclicCaps.embed w.length x)
+lemma capEmbedding_letter (x : Occ (w::ws)) :
+    letter ((a::(w++[inv a]))::ws) (capEmbedding a w ws x)=letter (w::ws) x :=
+  capLabel_embed a w ws x
+variable {a w ws}
+def Lift.removeCaps {d : Matching inv ((a::(w++[inv a]))::ws)} (l : Lift v d) :
+    Lift v (d.removeCaps hinv a w ws) := by
+  let e := capCoordinates (inv:=inv) a w ws
+  let α := e.permCongr d.partner
+  let σ := CyclicCaps.rotation w.length (BlockBoundary.rotation (lengths ws))
+  let pos := fun x=>l.position (e.symm x)
+  let lab := capLabel (inv:=inv) a w ws
+  have hi : Function.Involutive α := PermutationTransport.involutive e d.partner d.involutive
+  have hf : ∀x,α x≠x := PermutationTransport.fixed_free e d.partner d.fixed_free
+  have hpos : ∀x,pos (σ x)=pos x*v (lab x) := by
+    intro x
+    have hs := capRotation (inv:=inv) a w ws
+    change e.permCongr (BlockBoundary.rotation (lengths ((a::(w++[inv a]))::ws)))=σ at hs
+    rw [←hs]
+    change l.position (e.symm (e.permCongr _ x))=_
+    simp only [Equiv.permCongr_apply,Equiv.symm_apply_apply]
+    exact l.next _
+  have hpair : ∀x,pos (α x)=pos x*v (lab x) := by
+    intro x
+    change l.position (e.symm (e.permCongr d.partner x))=_
+    simp only [Equiv.permCongr_apply,Equiv.symm_apply_apply]
+    exact l.pair _
+  have hp : pos (CyclicCaps.q w.length)=pos (CyclicCaps.p w.length)*v (lab (CyclicCaps.p w.length)) := by
+    rw [←CyclicCaps.next w.length (BlockBoundary.rotation (lengths ws))]
+    exact hpos _
+  have hq : pos (CyclicCaps.q w.length)*v (lab (CyclicCaps.q w.length))=pos (CyclicCaps.p w.length) := by
+    rw [hp]
+    dsimp only [lab]
+    rw [capLabel_p,capLabel_q,hv,inv_mul_cancel_right]
+  refine ⟨fun i=>l.position (capEmbedding a w ws i),?_,?_⟩
+  · intro i
+    have hh := Tightening.consistent σ (CyclicCaps.p w.length) (CyclicCaps.q w.length)
+      (CyclicCaps.distinct w.length) (CyclicCaps.next _ _) pos (fun x=>pos x*v (lab x))
+      (fun x=>(hpos x).symm) hq (CyclicCaps.coordinates w.length i)
+    change pos (CyclicCaps.coordinates w.length i)*v (lab (CyclicCaps.coordinates w.length i))=
+      pos (Tightening.rotation σ _ _ _ _ (CyclicCaps.coordinates w.length i)) at hh
+    have rot := congrArg (fun x : MatchingSurgery.Remaining (CyclicCaps.p (R:=Occ ws) w.length)
+      (CyclicCaps.q w.length)=>pos x)
+      (CyclicCaps.rotation_commutes w.length (BlockBoundary.rotation (lengths ws)) i)
+    have hh := rot.symm.trans hh.symm
+    exact hh.trans (congrArg (pos (CyclicCaps.coordinates w.length i)*·)
+      (congrArg v (capLabel_embed a w ws i)))
+  · intro i
+    change pos (CyclicCaps.coordinates w.length (CyclicCaps.partner w.length α hi hf i))=_
+    change pos ((CyclicCaps.coordinates w.length) ((CyclicCaps.coordinates w.length).symm
+      ((MatchingSurgery.partner α hi hf (CyclicCaps.p w.length) (CyclicCaps.q w.length)
+        (CyclicCaps.distinct w.length)) (CyclicCaps.coordinates w.length i))))=_
+    rw [Equiv.apply_symm_apply]
+    change pos (PartialMatchingSurgery.splice α (CyclicCaps.p w.length) (CyclicCaps.q w.length)
+      (CyclicCaps.coordinates w.length i))=_
+    let x := CyclicCaps.coordinates w.length i
+    have hh : pos (PartialMatchingSurgery.splice α (CyclicCaps.p w.length) (CyclicCaps.q w.length) x)=pos x*v (lab x) := by
+      by_cases h1 : α x=CyclicCaps.p w.length
+      · rw [PartialMatchingSurgery.splice,ite_eq_left h1,hpair,hq]
+        exact (congrArg pos h1).symm.trans (hpair x)
+      · by_cases h2 : α x=CyclicCaps.q w.length
+        · rw [PartialMatchingSurgery.splice,ite_eq_right h1,ite_eq_left h2,hpair,←hp]
+          exact (congrArg pos h2).symm.trans (hpair x)
+        · rw [PartialMatchingSurgery.splice,ite_eq_right h1,ite_eq_right h2,hpair]
+    exact hh.trans (congrArg (pos x*·) (congrArg v (capLabel_embed a w ws i)))
+end
+end TorsionFreeZeroDivisors.WordBlocks
+
+end
+
+
+end OAI
diff --git a/lean/OAI/Algebra/GroupRing/WordResponse.lean b/lean/OAI/Algebra/GroupRing/WordResponse.lean
new file mode 100644
index 0000000000000000000000000000000000000000..33f8dcd0613deb7333e677badae98b0bf62f3948
--- /dev/null
+++ b/lean/OAI/Algebra/GroupRing/WordResponse.lean
@@ -0,0 +1,111 @@
+import Mathlib
+import OAI.Algebra.GroupRing.LoopSphere
+import OAI.Algebra.GroupRing.CellModule
+
+namespace OAI
+
+
+
+section
+namespace TorsionFreeZeroDivisors.WordResponse
+open GroupRingTopology GroupRingTopology.PathExtension
+open Path.Homotopic
+noncomputable section
+universe u
+variable {X : Type u} [TopologicalSpace X] {x : X}
+def basedClass {a b : X} (p : Path.Homotopic.Quotient a b) {Y : Type*} [TopologicalSpace Y]
+    (f : C(X,Y)) (y : Y) (ha : f a=y) (hb : f b=y) : FundamentalGroup Y y :=
+  (p.map f).cast ha.symm hb.symm
+lemma basedClass_equal {a b c d : X} {p : Path.Homotopic.Quotient a b}
+    {q : Path.Homotopic.Quotient c d} (h : Q.Equal p q) {Y : Type*} [TopologicalSpace Y]
+    (f : C(X,Y)) (y : Y) (ha : f a=y) (hb : f b=y) (hc : f c=y) (hd : f d=y) :
+    basedClass p f y ha hb=basedClass q f y hc hd := by
+  rcases h with ⟨h1,h2,h3⟩
+  subst c;subst d;cases eq_of_heq h3;rfl
+lemma basedClass_trans {a b c : X} (p : Path.Homotopic.Quotient a b)
+    (q : Path.Homotopic.Quotient b c) {Y : Type*} [TopologicalSpace Y]
+    (f : C(X,Y)) (y : Y) (ha : f a=y) (hb : f b=y) (hc : f c=y) :
+    basedClass (p.trans q) f y ha hc=basedClass q f y hb hc * basedClass p f y ha hb := by
+  unfold basedClass
+  rw [Q.map_trans,←Q.trans_cast _ _ ha.symm hb.symm hc.symm]
+  rfl
+lemma basedClass_map {a b : X} (p : Path.Homotopic.Quotient a b)
+    {Z Y : Type*} [TopologicalSpace Y] [TopologicalSpace Z]
+    (f : C(X,Y)) (k : C(Y,Z)) (z : Z) (ha : k (f a)=z) (hb : k (f b)=z) :
+    basedClass (p.map f) k z ha hb=basedClass p (k.comp f) z ha hb := by
+  unfold basedClass
+  congr 1
+  induction p using Path.Homotopic.Quotient.ind with | mk p=>rfl
+variable {G S Y : Type} [Group G] [TopologicalSpace G] [DiscreteTopology G]
+  [TopologicalSpace Y] (s : S→G) (f : C(Cayley.Graph s,Y)) (y : Y)
+  (hv : ∀g,f (Cayley.vertex s g)=y)
+include hv in
+lemma source_eq (g : G) : f (g • Cayley.vertex s 1)=y := by rw [Cayley.smul_vertex,_root_.mul_one,hv]
+include hv in
+lemma target_eq (g : G) (w : FreeGroup S) : f (g • ((Cayley.wordLift s w).1 • Cayley.vertex s 1))=y := by
+  rw [Cayley.smul_vertex,Cayley.smul_vertex,_root_.mul_one,hv]
+def response (g : G) (w : FreeGroup S) : Additive (FundamentalGroup Y y) :=
+  Additive.ofMul (basedClass ((Cayley.wordLift s w).2.map (smulMap g)) f y
+    (source_eq s f y hv g) (target_eq s f y hv g w))
+variable [IsMulCommutative (FundamentalGroup Y y)]
+local instance : CommGroup (FundamentalGroup Y y) :=
+  { (inferInstance : Group (FundamentalGroup Y y)) with mul_comm:=isMulCommutative_iff.mp inferInstance }
+lemma response_mul (g : G) (w v : FreeGroup S) :
+    response s f y hv g (w*v)=response s f y hv g w+
+      response s f y hv (g*FreeGroup.lift s w) v := by
+  let a:=Cayley.wordLift s w
+  let b:=Cayley.wordLift s v
+  have h := ((mul_path_equal a b).map (smulMap g)).trans
+    (Q.Equal.ofEq (Q.map_trans a.2 (b.2.map (smulMap a.1)) (smulMap g)))
+  have h2 := map_mul_equal b.2 g a.1
+  have he : Q.Equal ((Cayley.wordLift s (w*v)).2.map (smulMap g)) ((a*b).2.map (smulMap g)) := by
+    rw [show Cayley.wordLift s (w*v)=a*b from map_mul _ _ _]
+    exact .refl _
+  change basedClass ((Cayley.wordLift s (w*v)).2.map (smulMap g)) f y
+    (source_eq s f y hv g) (target_eq s f y hv g (w*v))= _ * _
+  rw [basedClass_equal (he.trans h) f y (source_eq s f y hv g)
+    (target_eq s f y hv g (w*v)) (source_eq s f y hv g) (by
+      change f (g • (a.1 • (b.1 • Cayley.vertex s 1)))=y
+      simp only [Cayley.smul_vertex,hv])]
+  erw [basedClass_trans _ _ f y (source_eq s f y hv g) (by
+    change f (g • (a.1 • Cayley.vertex s 1))=y
+    simp only [Cayley.smul_vertex,hv]) (by
+      change f (g • (a.1 • (b.1 • Cayley.vertex s 1)))=y
+      simp only [Cayley.smul_vertex,hv])]
+  rw [mul_comm]
+  congr 1
+  have hh:= basedClass_equal h2 f y (by
+    simp only [smulMap,ContinuousMap.coe_mk,Cayley.smul_vertex,hv]) (by
+    simp only [smulMap,ContinuousMap.coe_mk,Cayley.smul_vertex,hv])
+    (by simp only [smulMap,ContinuousMap.coe_mk,Cayley.smul_vertex,hv]) (by
+      simp only [smulMap,ContinuousMap.coe_mk,Cayley.smul_vertex,hv])
+  refine hh.trans ?_
+  change (response s f y hv (g*a.1) v).toMul=(response s f y hv (g*FreeGroup.lift s w) v).toMul
+  exact congrArg (fun h : G=>(response s f y hv (g*h) v).toMul) (Cayley.wordLift_fst s w)
+lemma response_one (g : G) : response s f y hv g 1=0 := by
+  have h:=response_mul s f y hv g 1 1
+  simpa only [_root_.one_mul,map_one,_root_.mul_one] using (add_eq_left.mp h.symm)
+lemma response_inv (g : G) (w : FreeGroup S) :
+    response s f y hv g w⁻¹= -response s f y hv (g*(FreeGroup.lift s w)⁻¹) w := by
+  have h:=response_mul s f y hv g w⁻¹ w
+  rw [_root_.inv_mul_cancel,response_one s f y hv,map_inv] at h
+  exact eq_neg_of_add_eq_zero_left h.symm
+
+def edges : CellModule.Module G S→+ Additive (FundamentalGroup Y y) :=
+  Finsupp.liftAddHom (fun z : G×S=>zmultiplesHom _ (response s f y hv z.1 (FreeGroup.of z.2)))
+lemma edges_fox (g : G) (w : FreeGroup S) :
+    edges s f y hv (CellModule.translate g (CellModule.fox (FreeGroup.lift s) w))=response s f y hv g w := by
+  induction w using FreeGroup.induction_on generalizing g with
+  | one=>rw [CellModule.fox_one,map_zero,map_zero,response_one s f y hv]
+  | of a=>simp [CellModule.fox_of,CellModule.translate_single,edges]
+  | inv_of a ih=>
+    rw [CellModule.fox_inv,map_neg,map_neg,←CellModule.translate_mul,ih,response_inv s f y hv]
+  | mul w v hw hv'=>
+    rw [CellModule.fox_mul,map_add,map_add,←CellModule.translate_mul,hw,hv',response_mul s f y hv]
+end
+end TorsionFreeZeroDivisors.WordResponse
+
+end
+
+
+end OAI
diff --git a/lean/OAI/Algebra/MarkedTensor/AdjointCoordinates.lean b/lean/OAI/Algebra/MarkedTensor/AdjointCoordinates.lean
new file mode 100644
index 0000000000000000000000000000000000000000..1830b6b6e1e24cf27423641b70f0ae69b8af8a21
--- /dev/null
+++ b/lean/OAI/Algebra/MarkedTensor/AdjointCoordinates.lean
@@ -0,0 +1,181 @@
+import Mathlib
+import OAI.Algebra.MarkedTensor.MatrixIdeals
+
+namespace OAI
+
+/-! Traceless matrix coordinates, adjoint actions and base change of spanning families. -/
+
+noncomputable section
+open scoped BigOperators commutatorElement
+open Matrix
+
+namespace BoundaryOnly.Holonomy
+open Matrix
+open scoped BigOperators commutatorElement
+variable {R : Type*} [CommRing R]
+abbrev Mat₂ (R : Type*) := Matrix (Fin 2) (Fin 2) R
+abbrev Vec₃ (R : Type*) := Fin 3 → R
+
+noncomputable def half [Algebra ℚ R] : R := algebraMap ℚ R (1/2)
+lemma two_half [Algebra ℚ R] : (2:R)*half = 1 := by
+  simpa only [half, map_mul, map_ofNat, map_one] using
+    congrArg (algebraMap ℚ R) (show (2:ℚ)*(1/2)=1 by norm_num)
+noncomputable def traceless (v : Vec₃ R) : Mat₂ R := !![v 1, v 0; v 2, -v 1]
+noncomputable def coordinates [Algebra ℚ R] (A : Mat₂ R) : Vec₃ R :=
+  ![A 0 1, (A 0 0-A 1 1)*half, A 1 0]
+
+def extract (A : Mat₂ R) : Vec₃ R := ![A 0 1,A 0 0,A 1 0]
+
+lemma scalar_lie (A B : Mat₂ R) (a b : R) :
+    lie (A-scalar (Fin 2) a) (B-scalar (Fin 2) b) = lie A B := by
+  ext i j
+  fin_cases i <;> fin_cases j <;>
+    simp [lie, Matrix.mul_apply, Fin.sum_univ_two, Matrix.scalar, Matrix.diagonal] <;> ring
+
+lemma scalar_lie_left (A B : Mat₂ R) (a : R) :
+    lie (A-scalar (Fin 2) a) B = lie A B := by
+  simpa only [map_zero, sub_zero] using scalar_lie A B a 0
+
+lemma traceless_coordinates [Algebra ℚ R] (A : Mat₂ R) :
+    traceless (coordinates A) = A-scalar (Fin 2) (Matrix.trace A*half) := by
+  ext i j
+  fin_cases i <;> fin_cases j <;>
+    simp [traceless, coordinates, Matrix.trace, Fin.sum_univ_two, Matrix.scalar,
+      Matrix.diagonal]
+  · linear_combination A 0 0 * two_half (R := R)
+  · linear_combination A 1 1 * two_half (R := R)
+
+lemma traceless_extract (v : Vec₃ R) : extract (traceless v) = v := by
+  ext i; fin_cases i <;> simp [extract, traceless]
+
+lemma extract_traceless (A : Mat₂ R) (hA : Matrix.trace A=0) :
+    traceless (extract A) = A := by
+  have hdiag : A 0 0+A 1 1=0 := by simpa [Matrix.trace, Fin.sum_univ_two] using hA
+  ext i j; fin_cases i <;> fin_cases j <;> simp [traceless,extract]
+  exact neg_eq_of_add_eq_zero_right hdiag
+
+noncomputable def tracelessLM : Vec₃ R →ₗ[R] Mat₂ R where
+  toFun := traceless
+  map_add' x y := by ext i j; fin_cases i <;> fin_cases j <;> simp [traceless, add_comm]
+  map_smul' c x := by ext i j; fin_cases i <;> fin_cases j <;> simp [traceless]
+
+def extractLM : Mat₂ R →ₗ[R] Vec₃ R where
+  toFun := extract
+  map_add' x y := by ext i; fin_cases i <;> simp [extract]
+  map_smul' c x := by ext i; fin_cases i <;> simp [extract]
+
+noncomputable def conjugationLM (g : SpecialLinearGroup (Fin 2) R) : Mat₂ R →ₗ[R] Mat₂ R where
+  toFun A := mat g*A*mat g⁻¹
+  map_add' A B := by simp only [mul_add,add_mul]
+  map_smul' c A := by simp only [mul_smul_comm,smul_mul_assoc, RingHom.id_apply]
+
+noncomputable def adjoint (g : SpecialLinearGroup (Fin 2) R) :
+    Vec₃ R →ₗ[R] Vec₃ R := extractLM ∘ₗ conjugationLM g ∘ₗ tracelessLM
+
+lemma traceless_adjoint (g : SpecialLinearGroup (Fin 2) R) (v : Vec₃ R) :
+    traceless (adjoint g v) = mat g*traceless v*mat g⁻¹ := by
+  apply extract_traceless
+  change Matrix.trace (mat g*traceless v*mat g⁻¹)=0
+  rw [Matrix.trace_mul_cycle]
+  simp only [← mat_mul, inv_mul_cancel, mat_one, one_mul]
+  simp [Matrix.trace, Fin.sum_univ_two, traceless]
+
+lemma conjugate_scalar (g : SpecialLinearGroup (Fin 2) R) (A : Mat₂ R) (a : R) :
+    mat g*(A-scalar (Fin 2) a)*mat g⁻¹ =
+      mat g*A*mat g⁻¹-scalar (Fin 2) a := by
+  rw [mul_sub,sub_mul]
+  have hs : mat g*scalar (Fin 2) a*mat g⁻¹ = scalar (Fin 2) a := by
+    have hsc : mat g*scalar (Fin 2) a = a • mat g := by
+      ext i j
+      simp [Matrix.scalar, Matrix.mul_diagonal, mul_comm]
+    rw [hsc, smul_mul_assoc, ← mat_mul, mul_inv_cancel, mat_one]
+    ext i j
+    simp [Matrix.scalar, Matrix.diagonal, Matrix.one_apply]
+  rw [hs]
+
+lemma reference_traceless_triple [Algebra ℚ R] {m N : Ideal R} (hNm : N ≤ m)
+    {u v w U V W z t s : SpecialLinearGroup (Fin 2) R}
+    (hu : mat u-mat U ∈ m.matrix (Fin 2)) (hv : mat v-mat V ∈ m.matrix (Fin 2))
+    (hw : mat w-mat W ∈ m.matrix (Fin 2))
+    (hz : mat z-1 ∈ N.matrix (Fin 2)) (ht : mat t-1 ∈ N.matrix (Fin 2))
+    (hs : mat s-1 ∈ N.matrix (Fin 2))
+    (hrel : ⁅u*z*u⁻¹,⁅v*t*v⁻¹,w*s*w⁻¹⁆⁆=1) :
+    lie (traceless (adjoint U (coordinates (mat z-1))))
+      (lie (traceless (adjoint V (coordinates (mat t-1))))
+        (traceless (adjoint W (coordinates (mat s-1))))) ∈ (m*N^3).matrix (Fin 2) := by
+  rw [traceless_adjoint, traceless_adjoint, traceless_adjoint,
+    traceless_coordinates, traceless_coordinates, traceless_coordinates,
+    conjugate_scalar, conjugate_scalar, conjugate_scalar, scalar_lie, scalar_lie_left]
+  exact reference_triple_mem hNm hu hv hw hz ht hs hrel
+
+end BoundaryOnly.Holonomy
+
+namespace BoundaryOnly.Holonomy
+open Matrix
+open scoped BigOperators
+variable {K R H : Type*} [CommRing K] [CommRing R] [Algebra K R]
+
+lemma matrix_span_base_change (A : H → Matrix (Fin 3) (Fin 3) K)
+    (hA : Submodule.span K (Set.range A) = ⊤) :
+    Submodule.span R (Set.range (fun h ↦ (A h).map (algebraMap K R))) = ⊤ := by
+  let S := Submodule.span R (Set.range (fun h ↦ (A h).map (algebraMap K R)))
+  have hmap (B : Matrix (Fin 3) (Fin 3) K) : B.map (algebraMap K R) ∈ S := by
+    have hB : B ∈ Submodule.span K (Set.range A) := by rw [hA]; trivial
+    induction hB using Submodule.span_induction with
+    | mem B hB =>
+        obtain ⟨h,rfl⟩ := hB
+        exact Submodule.subset_span ⟨h,rfl⟩
+    | zero => simp
+    | add B C hB hC ihB ihC =>
+        simpa only [Matrix.map_add _ (map_add (algebraMap K R))] using S.add_mem ihB ihC
+    | smul c B hB ih =>
+        have he : (c • B).map (algebraMap K R) =
+            algebraMap K R c • B.map (algebraMap K R) := by
+          ext i j; simp [smul_eq_mul]
+        rw [he]
+        exact S.smul_mem _ ih
+  have hsingle (i j : Fin 3) : Matrix.single i j (1:R) ∈ S := by
+    simpa using hmap (Matrix.single i j (1:K))
+  apply top_unique
+  intro B _
+  rw [Matrix.matrix_eq_sum_single B]
+  apply S.sum_mem; intro i _
+  apply S.sum_mem; intro j _
+  simpa only [Matrix.smul_single, smul_eq_mul, mul_one] using S.smul_mem (B i j) (hsingle i j)
+
+lemma adjoint_matrix_map (g : SpecialLinearGroup (Fin 2) K) :
+    LinearMap.toMatrix' (adjoint (SpecialLinearGroup.map (algebraMap K R) g)) =
+      (LinearMap.toMatrix' (adjoint g)).map (algebraMap K R) := by
+  have hinv : mat ((SpecialLinearGroup.map (algebraMap K R) g)⁻¹) =
+      (mat g⁻¹).map (algebraMap K R) := by rw [← map_inv]; rfl
+  have hmat : mat (SpecialLinearGroup.map (algebraMap K R) g) =
+      (mat g).map (algebraMap K R) := rfl
+  ext i j
+  change extract (mat (SpecialLinearGroup.map (algebraMap K R) g) *
+      traceless (Pi.single j 1) * mat ((SpecialLinearGroup.map (algebraMap K R) g)⁻¹)) i =
+      algebraMap K R (extract (mat g * traceless (Pi.single j 1) * mat g⁻¹) i)
+  rw [hmat, hinv]
+  fin_cases i <;> fin_cases j <;>
+    simp [extract, traceless, Matrix.mul_apply, Fin.sum_univ_two]
+
+ 
+
+lemma adjoint_span_base_change (G : H → SpecialLinearGroup (Fin 2) K)
+    (hG : Submodule.span K (Set.range (fun h ↦ adjoint (G h))) = ⊤) :
+    Submodule.span R (Set.range (fun h ↦ adjoint
+      (SpecialLinearGroup.map (algebraMap K R) (G h)))) = ⊤ := by
+  have hM : Submodule.span K (Set.range (fun h ↦ LinearMap.toMatrix' (adjoint (G h)))) = ⊤ := by
+    have h := congrArg (Submodule.map LinearMap.toMatrix'.toLinearMap) hG
+    simpa only [Submodule.map_span, ← Set.range_comp, Submodule.map_top,
+      LinearEquiv.range, Function.comp_def, LinearEquiv.coe_coe] using h
+  have h := matrix_span_base_change (R := R) _ hM
+  have h' := congrArg (Submodule.map Matrix.toLin'.toLinearMap) h
+  simpa only [Submodule.map_span, ← Set.range_comp, Submodule.map_top,
+    LinearEquiv.range, ← adjoint_matrix_map, LinearMap.toMatrix'_symm,
+    LinearEquiv.symm_apply_apply, Function.comp_def, LinearEquiv.coe_coe,
+    Matrix.toLin'_toMatrix'] using h'
+
+end BoundaryOnly.Holonomy
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/MarkedTensor/Holonomy.lean b/lean/OAI/Algebra/MarkedTensor/Holonomy.lean
new file mode 100644
index 0000000000000000000000000000000000000000..07f655b287f5a204c9247e58a7508626f84f919e
--- /dev/null
+++ b/lean/OAI/Algebra/MarkedTensor/Holonomy.lean
@@ -0,0 +1,147 @@
+import Mathlib
+import OAI.Algebra.MarkedTensor.ReferenceWords
+import OAI.Algebra.MarkedTensor.TripleProducts
+
+namespace OAI
+
+/-! Cubic nilpotence for reference holonomies and quotient ideals. -/
+
+noncomputable section
+open scoped BigOperators commutatorElement
+open Matrix
+
+namespace BoundaryOnly.Holonomy
+open Matrix
+open scoped BigOperators commutatorElement
+variable {R E : Type*} [CommRing R] [Algebra ℚ R]
+
+noncomputable def referenceOver (R : Type*) [CommRing R] [Algebra ℚ R]
+    (c : shortWords) : SpecialLinearGroup (Fin 2) R :=
+  SpecialLinearGroup.map (algebraMap ℚ R) (referenceRho c)
+
+ 
+
+theorem cubic_nilpotence_reference [IsNoetherianRing R] [IsLocalRing R]
+    (z : E → SpecialLinearGroup (Fin 2) R)
+    (u : shortWords → SpecialLinearGroup (Fin 2) R)
+    (hz : ∀ e, mat (z e)-1 ∈ (IsLocalRing.maximalIdeal R).matrix (Fin 2))
+    (hu : ∀ c, mat (u c)-mat (referenceOver R c) ∈
+      (IsLocalRing.maximalIdeal R).matrix (Fin 2))
+    (hrel : ∀ e f g a b c,
+      ⁅u a*z e*(u a)⁻¹,⁅u b*z f*(u b)⁻¹,u c*z g*(u c)⁻¹⁆⁆ = 1) :
+    deviationIdeal z^3 = ⊥ := by
+  apply cubic_nilpotence_local z u (referenceOver R) hz hu _ hrel
+  exact adjoint_span_base_change (fun c : shortWords ↦ referenceRho c)
+    finite_reference_adjoint_span
+
+ 
+
+omit [Algebra ℚ R] in
+lemma cube_sum_pullback {S T : Type*} [CommRing S] (r : Ideal S)
+    (q : S →+* R) (hq : RingHom.ker q = r)
+    (N : Ideal R) (hcube : N^3 = ⊥) (W : T → Ideal S)
+    (hW : ∀ i, (W i).map q ≤ N) : (⨆ i, W i)^3 ≤ r := by
+  have hm : (⨆ i, W i).map q ≤ N := by
+    rw [Ideal.map_iSup]
+    exact iSup_le hW
+  have hp : ((⨆ i, W i)^3).map q ≤ ⊥ := by
+    rw [Ideal.map_pow, ← hcube]
+    exact pow_le_pow_left' hm 3
+  have h := (Ideal.map_le_iff_le_comap).mp hp
+  simpa only [← RingHom.ker_eq_comap_bot, hq] using h
+
+ 
+
+omit [Algebra ℚ R] in
+lemma slope_deviation_mem (z : E → SpecialLinearGroup (Fin 2) R)
+    (e : E) (c : SpecialLinearGroup (Fin 2) R) (invert : Bool) :
+    mat (c*(if invert then (z e)⁻¹ else z e)*c⁻¹)-1 ∈
+      (deviationIdeal z).matrix (Fin 2) := by
+  have h : mat (if invert then (z e)⁻¹ else z e)-1 ∈
+      (deviationIdeal z).matrix (Fin 2) := by
+    cases invert
+    · exact deviation_mem z e
+    · exact inv_deviation (deviation_mem z e)
+  rw [conjugate_deviation]
+  exact matrix_mul_right ((deviationIdeal z).matrix (Fin 2) |>.mul_mem_left _ h) _
+
+end BoundaryOnly.Holonomy
+namespace BoundaryOnly.Holonomy
+open Matrix
+open scoped commutatorElement
+variable {R S E : Type*} [CommRing R] [CommRing S]
+
+lemma map_deviation_entry (f : R →+* S) (v : SpecialLinearGroup (Fin 2) R)
+    (i j : Fin 2) :
+    (mat (SpecialLinearGroup.map f v)-1) i j = f ((mat v-1) i j) := by
+  simp only [Matrix.sub_apply, map_sub]
+  change f (mat v i j) - (1 : Matrix (Fin 2) (Fin 2) S) i j =
+    f (mat v i j) - f ((1 : Matrix (Fin 2) (Fin 2) R) i j)
+  simp [Matrix.one_apply]
+
+ 
+
+theorem cubic_nilpotence_mod_ideal [Algebra ℚ R] [IsNoetherianRing R] [IsLocalRing R]
+    (r : Ideal R) (hr : r ≤ IsLocalRing.maximalIdeal R)
+    (z : E → SpecialLinearGroup (Fin 2) R)
+    (u : shortWords → SpecialLinearGroup (Fin 2) R)
+    (hz : ∀ e, mat (z e)-1 ∈ (IsLocalRing.maximalIdeal R).matrix (Fin 2))
+    (hu : ∀ c, mat (u c)-mat (referenceOver R c) ∈
+      (IsLocalRing.maximalIdeal R).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 ∈
+        r.matrix (Fin 2)) :
+    deviationIdeal z^3 ≤ r := by
+  have hr' : r ≠ ⊤ := ne_top_of_le_ne_top (IsLocalRing.maximalIdeal.isMaximal R).ne_top hr
+  let : Nontrivial (R ⧸ r) := Ideal.Quotient.nontrivial_iff.mpr hr'
+  let q : R →+* R ⧸ r := Ideal.Quotient.mk r
+  let : IsLocalRing (R ⧸ r) := IsLocalRing.of_surjective' q Ideal.Quotient.mk_surjective
+  let : IsLocalHom q := IsLocalHom.of_surjective q Ideal.Quotient.mk_surjective
+  let z' : E → SpecialLinearGroup (Fin 2) (R ⧸ r) := fun e ↦ SpecialLinearGroup.map q (z e)
+  let u' : shortWords → SpecialLinearGroup (Fin 2) (R ⧸ r) := fun c ↦ SpecialLinearGroup.map q (u c)
+  have hm {x : R} (hx : x ∈ IsLocalRing.maximalIdeal R) :
+      q x ∈ IsLocalRing.maximalIdeal (R ⧸ r) :=
+    IsLocalRing.map_maximalIdeal_le q (Ideal.mem_map_of_mem q hx)
+  have hz' (e) : mat (z' e)-1 ∈ (IsLocalRing.maximalIdeal (R ⧸ r)).matrix (Fin 2) := by
+    intro i j
+    rw [show z' e = SpecialLinearGroup.map q (z e) from rfl, map_deviation_entry]
+    exact hm (hz e i j)
+  have href (c) : referenceOver (R ⧸ r) c = SpecialLinearGroup.map q (referenceOver R c) := by
+    apply Matrix.SpecialLinearGroup.ext
+    intro i j
+    rfl
+  have hu' (c) : mat (u' c)-mat (referenceOver (R ⧸ r) c) ∈
+      (IsLocalRing.maximalIdeal (R ⧸ r)).matrix (Fin 2) := by
+    intro i j
+    rw [href]
+    change q (mat (u c) i j) - q (mat (referenceOver R c) i j) ∈ _
+    rw [← map_sub]
+    exact hm (hu c i j)
+  have hrel' (e f g a b c) :
+      ⁅u' a*z' e*(u' a)⁻¹,⁅u' b*z' f*(u' b)⁻¹,u' c*z' g*(u' c)⁻¹⁆⁆ = 1 := by
+    have hh : SpecialLinearGroup.map q
+        ⁅u a*z e*(u a)⁻¹,⁅u b*z f*(u b)⁻¹,u c*z g*(u c)⁻¹⁆⁆ = 1 := by
+      apply Matrix.SpecialLinearGroup.ext
+      intro i j
+      apply sub_eq_zero.mp
+      change (mat (SpecialLinearGroup.map q _)-1) i j = 0
+      rw [map_deviation_entry]
+      exact Ideal.Quotient.eq_zero_iff_mem.mpr (hrel e f g a b c i j)
+    simpa only [map_commutatorElement, map_mul, map_inv] using hh
+  have hc := cubic_nilpotence_reference z' u' hz' hu' hrel'
+  have hd : (deviationIdeal z).map q ≤ deviationIdeal z' := by
+    apply Ideal.map_le_iff_le_comap.mpr
+    apply Ideal.span_le.mpr
+    rintro x ⟨⟨e,i,j⟩,rfl⟩
+    change q ((mat (z e)-1) i j) ∈ deviationIdeal z'
+    rw [← map_deviation_entry]
+    exact deviation_mem z' e i j
+  have hpow : ((deviationIdeal z)^3).map q ≤ ⊥ := by
+    rw [Ideal.map_pow, ← hc]
+    exact pow_le_pow_left' hd 3
+  simpa only [← RingHom.ker_eq_comap_bot, q, Ideal.mk_ker] using
+    (Ideal.map_le_iff_le_comap.mp hpow)
+end BoundaryOnly.Holonomy
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/MarkedTensor/Main.lean b/lean/OAI/Algebra/MarkedTensor/Main.lean
new file mode 100644
index 0000000000000000000000000000000000000000..d4fe7c15b50cf88876f7f6916fd005ddfe915114
--- /dev/null
+++ b/lean/OAI/Algebra/MarkedTensor/Main.lean
@@ -0,0 +1,3 @@
+import OAI.Algebra.MarkedTensor.Holonomy
+import OAI.Algebra.MarkedTensor.PolynomialAdjoint
+import OAI.Algebra.FrobeniusObstruction.Obstruction
diff --git a/lean/OAI/Algebra/MarkedTensor/MatrixIdeals.lean b/lean/OAI/Algebra/MarkedTensor/MatrixIdeals.lean
new file mode 100644
index 0000000000000000000000000000000000000000..397cba4046c6eca3e8b7b2dff911a32fb2fd91a1
--- /dev/null
+++ b/lean/OAI/Algebra/MarkedTensor/MatrixIdeals.lean
@@ -0,0 +1,214 @@
+import Mathlib
+
+namespace OAI
+
+/-! Matrix ideal arithmetic, conjugation errors and triple commutator congruences. -/
+
+noncomputable section
+open scoped BigOperators commutatorElement
+open Matrix
+
+namespace BoundaryOnly.Holonomy
+open Matrix
+open scoped BigOperators commutatorElement
+variable {R ι : Type*} [CommRing R] [Fintype ι] [DecidableEq ι]
+
+lemma matrix_mul_mem {I J : Ideal R} {A B : Matrix ι ι R}
+    (hA : A ∈ I.matrix ι) (hB : B ∈ J.matrix ι) :
+    A * B ∈ (I * J).matrix ι := by
+  intro i j
+  apply Ideal.sum_mem
+  intro k _
+  exact Ideal.mul_mem_mul (hA i k) (hB k j)
+
+lemma matrix_mul_right {I : Ideal R} {A : Matrix ι ι R}
+    (hA : A ∈ I.matrix ι) (B : Matrix ι ι R) : A * B ∈ I.matrix ι := by
+  intro i j
+  apply Ideal.sum_mem
+  intro k _
+  exact I.mul_mem_right _ (hA i k)
+
+abbrev mat (u : SpecialLinearGroup ι R) : Matrix ι ι R := u
+
+@[simp] lemma mat_mul (u v : SpecialLinearGroup ι R) : mat (u*v) = mat u * mat v := rfl
+@[simp] lemma mat_one : mat (1 : SpecialLinearGroup ι R) = 1 := rfl
+
+lemma inv_deviation {I : Ideal R} {u : SpecialLinearGroup ι R}
+    (hu : mat u - 1 ∈ I.matrix ι) : mat u⁻¹ - 1 ∈ I.matrix ι := by
+  have heq : mat u⁻¹ - 1 = -(mat u⁻¹ * (mat u - 1)) := by
+    simp only [mul_sub, ← mat_mul, inv_mul_cancel,
+      mat_one, mul_one, neg_sub]
+  rw [heq]
+  exact (I.matrix ι).neg_mem ((I.matrix ι).mul_mem_left _ hu)
+
+lemma product_deviation {I : Ideal R} {u v : SpecialLinearGroup ι R}
+    (hu : mat u - 1 ∈ I.matrix ι) (hv : mat v - 1 ∈ I.matrix ι) :
+    mat (u*v) - 1 ∈ I.matrix ι := by
+  have heq : mat (u*v) - 1 = mat u * (mat v - 1) + (mat u - 1) := by
+    simp only [mat_mul, mul_sub, mul_one]
+    abel
+  rw [heq]
+  exact (I.matrix ι).add_mem ((I.matrix ι).mul_mem_left _ hv) hu
+
+ 
+
+lemma commutator_error {I : Ideal R} {v w : SpecialLinearGroup ι R}
+    (hv : mat v - 1 ∈ I.matrix ι) (hw : mat w - 1 ∈ I.matrix ι) :
+    (mat ⁅v,w⁆ - 1) -
+      ((mat v-1)*(mat w-1) - (mat w-1)*(mat v-1)) ∈ (I^3).matrix ι := by
+  let D := (mat v-1)*(mat w-1) - (mat w-1)*(mat v-1)
+  have hD : D ∈ (I^2).matrix ι := by
+    simpa only [pow_two] using ((I*I).matrix ι).sub_mem
+      (matrix_mul_mem hv hw) (matrix_mul_mem hw hv)
+  have hD' : D = mat v * mat w - mat w * mat v := by
+    dsimp [D]
+    noncomm_ring
+  have heq : (mat ⁅v,w⁆ - 1)-D = D * (mat (v⁻¹*w⁻¹)-1) := by
+    rw [hD']
+    simp only [commutatorElement_def, mat_mul]
+    have hc : mat w * mat v * mat v⁻¹ * mat w⁻¹ = (1 : Matrix ι ι R) := by
+      simp only [← mat_mul, mul_assoc, mul_inv_cancel, one_mul, mat_one]
+    calc
+      _ = (mat v*mat w-mat w*mat v)*(mat v⁻¹*mat w⁻¹) -
+          (mat v*mat w-mat w*mat v) := by rw [sub_mul]; rw [← mul_assoc, ← mul_assoc, hc]
+      _ = _ := by noncomm_ring
+  rw [heq]
+  simpa only [← pow_succ] using matrix_mul_mem hD
+    (product_deviation (inv_deviation hv) (inv_deviation hw))
+
+ 
+
+lemma nested_lie_mem_four {I : Ideal R} {u v w : SpecialLinearGroup ι R}
+    (hu : mat u-1 ∈ I.matrix ι) (hv : mat v-1 ∈ I.matrix ι)
+    (hw : mat w-1 ∈ I.matrix ι) (hrel : ⁅u,⁅v,w⁆⁆ = 1) :
+    (mat u-1)*((mat v-1)*(mat w-1)-(mat w-1)*(mat v-1)) -
+      ((mat v-1)*(mat w-1)-(mat w-1)*(mat v-1))*(mat u-1) ∈
+      (I^4).matrix ι := by
+  let D := (mat v-1)*(mat w-1)-(mat w-1)*(mat v-1)
+  let C := mat ⁅v,w⁆ - 1
+  have he : C-D ∈ (I^3).matrix ι := commutator_error hv hw
+  have hc : (mat u-1)*C-C*(mat u-1) = 0 := by
+    have h := congrArg (mat (R := R)) (commutatorElement_eq_one_iff_mul_comm.mp hrel)
+    simp only [mat_mul] at h
+    dsimp [C]
+    noncomm_ring [h]
+  have hm₁ : (mat u-1)*(C-D) ∈ (I^4).matrix ι := by
+    simpa only [← pow_succ', show 3+1=4 by rfl] using matrix_mul_mem hu he
+  have hm₂ : (C-D)*(mat u-1) ∈ (I^4).matrix ι := by
+    simpa only [← pow_succ, show 3+1=4 by rfl] using matrix_mul_mem he hu
+  have heq : (mat u-1)*D-D*(mat u-1) =
+      -((mat u-1)*(C-D)-(C-D)*(mat u-1)) := by
+    have hh : (mat u-1)*D-D*(mat u-1) +
+        ((mat u-1)*(C-D)-(C-D)*(mat u-1)) = 0 := by
+      calc
+        _ = (mat u-1)*C-C*(mat u-1) := by noncomm_ring
+        _ = 0 := hc
+    exact eq_neg_of_add_eq_zero_left hh
+  change (mat u-1)*D-D*(mat u-1) ∈ (I^4).matrix ι
+  rw [heq]
+  exact ((I^4).matrix ι).neg_mem (((I^4).matrix ι).sub_mem hm₁ hm₂)
+
+end BoundaryOnly.Holonomy
+namespace BoundaryOnly.Holonomy
+open Matrix
+open scoped BigOperators commutatorElement
+variable {R ι : Type*} [CommRing R] [Fintype ι] [DecidableEq ι]
+
+abbrev lie (A B : Matrix ι ι R) := A * B - B * A
+
+lemma lie_mem {I J : Ideal R} {A B : Matrix ι ι R}
+    (hA : A ∈ I.matrix ι) (hB : B ∈ J.matrix ι) :
+    lie A B ∈ (I*J).matrix ι := by
+  apply ((I*J).matrix ι).sub_mem (matrix_mul_mem hA hB)
+  simpa only [mul_comm J I] using matrix_mul_mem hB hA
+
+lemma inverse_difference {I : Ideal R} {u v : SpecialLinearGroup ι R}
+    (h : mat u - mat v ∈ I.matrix ι) :
+    mat u⁻¹ - mat v⁻¹ ∈ I.matrix ι := by
+  have he : mat u⁻¹ - mat v⁻¹ = -(mat u⁻¹ * (mat u - mat v) * mat v⁻¹) := by
+    simp only [mul_sub, sub_mul, ← mat_mul, inv_mul_cancel,
+      mat_one, one_mul, mul_inv_cancel_right, neg_sub]
+  rw [he]
+  exact (I.matrix ι).neg_mem (matrix_mul_right
+    ((I.matrix ι).mul_mem_left _ h) _)
+
+lemma conjugate_deviation (u v : SpecialLinearGroup ι R) :
+    mat (u*v*u⁻¹)-1 = mat u*(mat v-1)*mat u⁻¹ := by
+  simp only [mul_sub, sub_mul, mul_one, ← mat_mul, mul_inv_cancel, mat_one]
+
+lemma conjugate_error {m N : Ideal R} {u U z : SpecialLinearGroup ι R}
+    (hu : mat u-mat U ∈ m.matrix ι) (hz : mat z-1 ∈ N.matrix ι) :
+    (mat (u*z*u⁻¹)-1) - mat U*(mat z-1)*mat U⁻¹ ∈ (m*N).matrix ι := by
+  rw [conjugate_deviation]
+  have he : mat u*(mat z-1)*mat u⁻¹ - mat U*(mat z-1)*mat U⁻¹ =
+      (mat u-mat U)*(mat z-1)*mat u⁻¹ +
+        mat U*(mat z-1)*(mat u⁻¹-mat U⁻¹) := by noncomm_ring
+  rw [he]
+  apply ((m*N).matrix ι).add_mem
+  · exact matrix_mul_right (matrix_mul_mem hu hz) _
+  · simpa only [mul_comm N m] using matrix_mul_mem
+      ((N.matrix ι).mul_mem_left _ hz) (inverse_difference hu)
+
+lemma lie_congruence {m N : Ideal R} {a b A B : Matrix ι ι R}
+    (ha : a ∈ N.matrix ι) (hB : B ∈ N.matrix ι)
+    (h₁ : a-A ∈ (m*N).matrix ι) (h₂ : b-B ∈ (m*N).matrix ι) :
+    lie a b - lie A B ∈ (m*N^2).matrix ι := by
+  have he : lie a b-lie A B = lie a (b-B)+lie (a-A) B := by
+    dsimp [lie]; noncomm_ring
+  rw [he]
+  apply ((m*N^2).matrix ι).add_mem
+  · simpa only [pow_two, mul_left_comm N m N, mul_assoc] using lie_mem ha h₂
+  · simpa only [pow_two, mul_assoc] using lie_mem h₁ hB
+
+lemma triple_congruence {m N : Ideal R} {a b c A B C : Matrix ι ι R}
+    (ha : a ∈ N.matrix ι) (hB : B ∈ N.matrix ι) (hC : C ∈ N.matrix ι)
+    (hb : b ∈ N.matrix ι)
+    (h₁ : a-A ∈ (m*N).matrix ι) (h₂ : b-B ∈ (m*N).matrix ι)
+    (h₃ : c-C ∈ (m*N).matrix ι) :
+    lie a (lie b c)-lie A (lie B C) ∈ (m*N^3).matrix ι := by
+  have he : lie a (lie b c)-lie A (lie B C) =
+      lie a (lie b c-lie B C)+lie (a-A) (lie B C) := by
+    dsimp [lie]; noncomm_ring
+  rw [he]
+  apply ((m*N^3).matrix ι).add_mem
+  · have h := lie_mem ha (lie_congruence hb hC h₂ h₃)
+    simpa only [mul_left_comm N m (N^2), ← pow_succ'] using h
+  · have h := lie_mem h₁ (lie_mem hB hC)
+    simpa only [← pow_two, mul_assoc, ← pow_succ'] using h
+
+ 
+
+lemma reference_triple_mem {m N : Ideal R} (hNm : N ≤ m)
+    {u v w U V W z t s : SpecialLinearGroup ι R}
+    (hu : mat u-mat U ∈ m.matrix ι) (hv : mat v-mat V ∈ m.matrix ι)
+    (hw : mat w-mat W ∈ m.matrix ι)
+    (hz : mat z-1 ∈ N.matrix ι) (ht : mat t-1 ∈ N.matrix ι)
+    (hs : mat s-1 ∈ N.matrix ι)
+    (hrel : ⁅u*z*u⁻¹,⁅v*t*v⁻¹,w*s*w⁻¹⁆⁆=1) :
+    lie (mat U*(mat z-1)*mat U⁻¹)
+      (lie (mat V*(mat t-1)*mat V⁻¹) (mat W*(mat s-1)*mat W⁻¹)) ∈
+        (m*N^3).matrix ι := by
+  have hconj (a b : SpecialLinearGroup ι R) (hb : mat b-1 ∈ N.matrix ι) :
+      mat (a*b*a⁻¹)-1 ∈ N.matrix ι := by
+    rw [conjugate_deviation]
+    exact matrix_mul_right ((N.matrix ι).mul_mem_left _ hb) _
+  have hfour := nested_lie_mem_four (hconj u z hz) (hconj v t ht)
+    (hconj w s hs) hrel
+  have hp : N^4 ≤ m*N^3 := by
+    rw [show 4=3+1 by rfl, pow_succ']
+    exact Ideal.mul_mono hNm le_rfl
+  have htop : lie (mat (u*z*u⁻¹)-1)
+      (lie (mat (v*t*v⁻¹)-1) (mat (w*s*w⁻¹)-1)) ∈ (m*N^3).matrix ι :=
+    fun i j ↦ hp (hfour i j)
+  have herr := triple_congruence (hconj u z hz)
+    (matrix_mul_right ((N.matrix ι).mul_mem_left (mat V) ht) (mat V⁻¹))
+    (matrix_mul_right ((N.matrix ι).mul_mem_left (mat W) hs) (mat W⁻¹))
+    (hconj v t ht) (conjugate_error hu hz) (conjugate_error hv ht)
+    (conjugate_error hw hs)
+  have h := ((m*N^3).matrix ι).sub_mem htop herr
+  simpa only [sub_sub_cancel] using h
+
+end BoundaryOnly.Holonomy
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/MarkedTensor/PolynomialAdjoint.lean b/lean/OAI/Algebra/MarkedTensor/PolynomialAdjoint.lean
new file mode 100644
index 0000000000000000000000000000000000000000..8dfaa4f21e5b477c2ad67165340d111e252d4b8b
--- /dev/null
+++ b/lean/OAI/Algebra/MarkedTensor/PolynomialAdjoint.lean
@@ -0,0 +1,241 @@
+import Mathlib
+import OAI.Algebra.MarkedTensor.AdjointCoordinates
+
+namespace OAI
+
+/-! Nine polynomial conjugators spanning every adjoint-coordinate endomorphism. -/
+
+noncomputable section
+open scoped BigOperators commutatorElement
+open Matrix
+
+namespace MarkedTensor
+namespace Adjoint
+
+variable {K : Type*} [Field K]
+
+abbrev Mat₂ (K : Type*) := Matrix (Fin 2) (Fin 2) K
+abbrev Mat₃ (K : Type*) := Matrix (Fin 3) (Fin 3) K
+abbrev Vec₃ (K : Type*) := Fin 3 → K
+
+abbrev mat (g : SpecialLinearGroup (Fin 2) K) : Mat₂ K := g
+
+ 
+def traceless (v : Vec₃ K) : Mat₂ K := !![v 1, v 0; v 2, -v 1]
+
+def extract (A : Mat₂ K) : Vec₃ K := ![A 0 1, A 0 0, A 1 0]
+
+def tracelessLM : Vec₃ K →ₗ[K] Mat₂ K where
+  toFun := traceless
+  map_add' x y := by ext i j; fin_cases i <;> fin_cases j <;> simp [traceless, add_comm]
+  map_smul' c x := by ext i j; fin_cases i <;> fin_cases j <;> simp [traceless]
+
+def extractLM : Mat₂ K →ₗ[K] Vec₃ K where
+  toFun := extract
+  map_add' x y := by ext i; fin_cases i <;> simp [extract]
+  map_smul' c x := by ext i; fin_cases i <;> simp [extract]
+
+def conjugationLM (g : SpecialLinearGroup (Fin 2) K) : Mat₂ K →ₗ[K] Mat₂ K where
+  toFun A := mat g * A * mat g⁻¹
+  map_add' A B := by simp only [mul_add, add_mul]
+  map_smul' c A := by simp only [mul_smul_comm, smul_mul_assoc, RingHom.id_apply]
+
+ 
+def adjoint (g : SpecialLinearGroup (Fin 2) K) : Vec₃ K →ₗ[K] Vec₃ K :=
+  extractLM ∘ₗ conjugationLM g ∘ₗ tracelessLM
+
+lemma traceless_extract (v : Vec₃ K) : extract (traceless v) = v := by
+  ext i; fin_cases i <;> simp [extract, traceless]
+
+lemma extract_traceless (A : Mat₂ K) (hA : Matrix.trace A = 0) :
+    traceless (extract A) = A := by
+  have hdiag : A 0 0 + A 1 1 = 0 := by simpa [Matrix.trace, Fin.sum_univ_two] using hA
+  ext i j; fin_cases i <;> fin_cases j <;> simp [traceless, extract]
+  exact neg_eq_of_add_eq_zero_right hdiag
+
+lemma traceless_adjoint (g : SpecialLinearGroup (Fin 2) K) (v : Vec₃ K) :
+    traceless (adjoint g v) = mat g * traceless v * mat g⁻¹ := by
+  apply extract_traceless
+  change Matrix.trace (mat g * traceless v * mat g⁻¹) = 0
+  rw [Matrix.trace_mul_cycle]
+  have hi : mat g⁻¹ * mat g = 1 :=
+    congrArg mat (inv_mul_cancel g)
+  rw [hi, one_mul]
+  simp [Matrix.trace, Fin.sum_univ_two, traceless]
+
+ 
+def conjugator (x y : K) : SpecialLinearGroup (Fin 2) K :=
+  ⟨!![1 + x*y, x; y, 1], by simp [Matrix.det_fin_two]⟩
+
+lemma conjugator_inv (x y : K) :
+    mat (conjugator x y)⁻¹ =
+      !![1, -x; -y, 1 + x*y] := by
+  change Matrix.adjugate (!![1 + x*y, x; y, 1] : Mat₂ K) = _
+  rw [Matrix.adjugate_fin_two]
+  rfl
+
+ 
+def adjointMatrix (x y : K) : Mat₃ K :=
+  !![(1 + x*y)^2, -2*x*(1 + x*y), -x^2;
+     -y*(1 + x*y), 1 + 2*x*y, x;
+     -y^2, 2*y, 1]
+
+lemma toMatrix_adjoint (x y : K) :
+    LinearMap.toMatrix' (adjoint (conjugator x y)) = adjointMatrix x y := by
+  ext i j
+  change extract (mat (conjugator x y) * traceless (Pi.single j 1) *
+    mat (conjugator x y)⁻¹) i = adjointMatrix x y i j
+  rw [conjugator_inv]
+  fin_cases i <;> fin_cases j <;>
+    simp [extract, traceless, mat, conjugator, adjointMatrix,
+      Matrix.mul_apply, Fin.sum_univ_two] <;> ring
+
+ 
+def coefficient : Fin 3 → Fin 3 → Mat₃ K := ![
+  ![1, !![0,0,0; -1,0,0; 0,2,0], !![0,0,0; 0,0,0; -1,0,0]],
+  ![!![0,-2,0; 0,0,1; 0,0,0], !![2,0,0; 0,2,0; 0,0,0],
+    !![0,0,0; -1,0,0; 0,0,0]],
+  ![!![0,0,-1; 0,0,0; 0,0,0], !![0,-2,0; 0,0,0; 0,0,0],
+    !![1,0,0; 0,0,0; 0,0,0]]]
+
+@[simp] lemma coefficient00 : coefficient (K := K) 0 0 = 1 := rfl
+@[simp] lemma coefficient01 : coefficient (K := K) 0 1 =
+    !![0,0,0; -1,0,0; 0,2,0] := rfl
+@[simp] lemma coefficient02 : coefficient (K := K) 0 2 =
+    !![0,0,0; 0,0,0; -1,0,0] := rfl
+@[simp] lemma coefficient10 : coefficient (K := K) 1 0 =
+    !![0,-2,0; 0,0,1; 0,0,0] := rfl
+@[simp] lemma coefficient11 : coefficient (K := K) 1 1 =
+    !![2,0,0; 0,2,0; 0,0,0] := rfl
+@[simp] lemma coefficient12 : coefficient (K := K) 1 2 =
+    !![0,0,0; -1,0,0; 0,0,0] := rfl
+@[simp] lemma coefficient20 : coefficient (K := K) 2 0 =
+    !![0,0,-1; 0,0,0; 0,0,0] := rfl
+@[simp] lemma coefficient21 : coefficient (K := K) 2 1 =
+    !![0,-2,0; 0,0,0; 0,0,0] := rfl
+@[simp] lemma coefficient22 : coefficient (K := K) 2 2 =
+    !![1,0,0; 0,0,0; 0,0,0] := rfl
+
+def quadratic {V : Type*} [AddCommGroup V] [Module K V] (a b c : V) (t : K) : V :=
+  a + t • b + t^2 • c
+
+lemma quadratic_coefficients_mem [CharZero K] {V : Type*} [AddCommGroup V] [Module K V]
+    (W : Submodule K V) (a b c : V) {s : K} (hs : s ≠ 0)
+    (h0 : quadratic a b c (0 : K) ∈ W) (h1 : quadratic a b c s ∈ W)
+    (h2 : quadratic a b c (2*s) ∈ W) : a ∈ W ∧ b ∈ W ∧ c ∈ W := by
+  have ha : a ∈ W := by simpa [quadratic] using h0
+  have he : quadratic a b c (2*s) - (2 : K) • quadratic a b c s + a =
+      (2*s^2) • c := by unfold quadratic; module
+  have hc' : (2*s^2) • c ∈ W := he ▸ W.add_mem (W.sub_mem h2 (W.smul_mem 2 h1)) ha
+  have hc : c ∈ W := by
+    have h := W.smul_mem (2*s^2)⁻¹ hc'
+    simpa only [smul_smul, inv_mul_cancel₀ (mul_ne_zero (by norm_num : (2 : K) ≠ 0)
+      (pow_ne_zero 2 hs)), one_smul] using h
+  have hb' : s • b ∈ W := by
+    convert W.sub_mem (W.sub_mem h1 ha) (W.smul_mem (s^2) hc) using 1
+    unfold quadratic
+    module
+  have hb : b ∈ W := by
+    have h := W.smul_mem s⁻¹ hb'
+    simpa only [smul_smul, inv_mul_cancel₀ hs, one_smul] using h
+  exact ⟨ha, hb, hc⟩
+
+def rowPolynomial (p : Fin 3) (y : K) : Mat₃ K :=
+  quadratic (coefficient p 0) (coefficient p 1) (coefficient p 2) y
+
+lemma expansion (x y : K) : adjointMatrix x y =
+    quadratic (rowPolynomial 0 y) (rowPolynomial 1 y) (rowPolynomial 2 y) x := by
+  ext i j; fin_cases i <;> fin_cases j <;>
+    simp [adjointMatrix, quadratic, rowPolynomial, coefficient] <;> ring
+
+variable [CharZero K]
+
+lemma coefficients_mem {W : Submodule K (Mat₃ K)} {s : K} (hs : s ≠ 0)
+    (h : ∀ a b : Fin 3, adjointMatrix ((a : K)*s) ((b : K)*s) ∈ W)
+    (p q : Fin 3) : coefficient (K := K) p q ∈ W := by
+  have hr (b : Fin 3) : ∀ p : Fin 3, rowPolynomial p ((b : K)*s) ∈ W := by
+    have hh := quadratic_coefficients_mem W
+      (rowPolynomial 0 ((b : K)*s)) (rowPolynomial 1 ((b : K)*s))
+      (rowPolynomial 2 ((b : K)*s)) hs
+      (by simpa only [← expansion, Fin.val_zero, Nat.cast_zero, zero_mul] using h 0 b)
+      (by simpa only [← expansion, Fin.val_one, Nat.cast_one, one_mul] using h 1 b)
+      (by simpa only [← expansion, Fin.val_two, Nat.cast_ofNat] using h 2 b)
+    intro p; fin_cases p
+    · exact hh.1
+    · exact hh.2.1
+    · exact hh.2.2
+  have hh := quadratic_coefficients_mem W (coefficient p 0) (coefficient p 1)
+    (coefficient p 2) hs
+    (by simpa only [rowPolynomial, Fin.val_zero, Nat.cast_zero, zero_mul] using hr 0 p)
+    (by simpa only [rowPolynomial, Fin.val_one, Nat.cast_one, one_mul] using hr 1 p)
+    (by simpa only [rowPolynomial, Fin.val_two, Nat.cast_ofNat] using hr 2 p)
+  fin_cases q
+  · exact hh.1
+  · exact hh.2.1
+  · exact hh.2.2
+
+lemma span_eq_top_of_coefficients {W : Submodule K (Mat₃ K)}
+    (h : ∀ p q : Fin 3, coefficient p q ∈ W) : W = ⊤ := by
+  have hu (i j : Fin 3) : Matrix.single i j (1 : K) ∈ W := by
+    fin_cases i <;> fin_cases j
+    · convert h 2 2 using 1
+      ext row column
+      fin_cases row <;> fin_cases column <;> norm_num [Matrix.single]
+    · convert W.smul_mem (-1/2 : K) (h 2 1) using 1
+      ext row column
+      fin_cases row <;> fin_cases column <;> norm_num [Matrix.single]
+    · convert W.neg_mem (h 2 0) using 1
+      ext row column
+      fin_cases row <;> fin_cases column <;> norm_num [Matrix.single]
+    · convert W.neg_mem (h 1 2) using 1
+      ext row column
+      fin_cases row <;> fin_cases column <;> norm_num [Matrix.single]
+    · convert W.sub_mem (W.smul_mem (1/2 : K) (h 1 1)) (h 2 2) using 1
+      ext row column
+      fin_cases row <;> fin_cases column <;> norm_num [Matrix.single]
+    · convert W.sub_mem (h 1 0) (h 2 1) using 1
+      ext row column
+      fin_cases row <;> fin_cases column <;> norm_num [Matrix.single]
+    · convert W.neg_mem (h 0 2) using 1
+      ext row column
+      fin_cases row <;> fin_cases column <;> norm_num [Matrix.single]
+    · convert W.smul_mem (1/2 : K) (W.sub_mem (h 0 1) (h 1 2)) using 1
+      ext row column
+      fin_cases row <;> fin_cases column <;> norm_num [Matrix.single]
+    · convert W.sub_mem (h 0 0) (W.smul_mem (1/2 : K) (h 1 1)) using 1
+      ext row column
+      fin_cases row <;> fin_cases column <;> norm_num [Matrix.single]
+  apply top_unique
+  intro B _
+  rw [Matrix.matrix_eq_sum_single B]
+  apply W.sum_mem; intro i _
+  apply W.sum_mem; intro j _
+  simpa only [Matrix.smul_single, smul_eq_mul, mul_one] using W.smul_mem (B i j) (hu i j)
+
+ 
+lemma nine_matrix_span {s : K} (hs : s ≠ 0) :
+    Submodule.span K (Set.range (fun ab : Fin 3 × Fin 3 =>
+      adjointMatrix ((ab.1 : K)*s) ((ab.2 : K)*s))) = ⊤ := by
+  apply span_eq_top_of_coefficients
+  apply coefficients_mem hs
+  intro a b
+  exact Submodule.subset_span ⟨(a,b), rfl⟩
+
+ 
+
+theorem vertex_adjoint_span {s : K} (hs : s ≠ 0) :
+    Submodule.span K (Set.range (fun ab : Fin 3 × Fin 3 =>
+      adjoint (conjugator ((ab.1 : K)*s) ((ab.2 : K)*s)))) = ⊤ := by
+  have ht : Submodule.span K (Set.range (fun ab : Fin 3 × Fin 3 =>
+      LinearMap.toMatrix' (adjoint (conjugator ((ab.1 : K)*s) ((ab.2 : K)*s))))) = ⊤ := by
+    simpa only [toMatrix_adjoint] using nine_matrix_span hs
+  have hh := congrArg (Submodule.map Matrix.toLin'.toLinearMap) ht
+  simpa only [Submodule.map_span, ← Set.range_comp, Submodule.map_top,
+    LinearEquiv.range, Function.comp_def, LinearEquiv.coe_coe,
+    Matrix.toLin'_toMatrix'] using hh
+
+end Adjoint
+end MarkedTensor
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/MarkedTensor/ReferenceWords.lean b/lean/OAI/Algebra/MarkedTensor/ReferenceWords.lean
new file mode 100644
index 0000000000000000000000000000000000000000..cccb4a359895c7a97877f5c34efe0a127485862c
--- /dev/null
+++ b/lean/OAI/Algebra/MarkedTensor/ReferenceWords.lean
@@ -0,0 +1,334 @@
+import Mathlib
+import OAI.Algebra.MarkedTensor.AdjointCoordinates
+
+namespace OAI
+
+/-! Finite rational reference words whose adjoint actions span all endomorphisms. -/
+
+noncomputable section
+open scoped BigOperators commutatorElement
+open Matrix
+
+namespace BoundaryOnly.Holonomy
+open Matrix
+open scoped BigOperators
+
+ 
+def referenceGenerator : Fin 3 → SpecialLinearGroup (Fin 2) ℚ := ![
+  ⟨!![2,0;0,1/2], by norm_num [Matrix.det_fin_two]⟩,
+  ⟨!![1,1;0,1], by norm_num [Matrix.det_fin_two]⟩,
+  ⟨!![1,0;1,1], by norm_num [Matrix.det_fin_two]⟩]
+
+def referenceRho : FreeGroup (Fin 3) →* SpecialLinearGroup (Fin 2) ℚ :=
+  FreeGroup.lift referenceGenerator
+
+def shortWords : Set (FreeGroup (Fin 3)) := {g | FreeGroup.norm g ≤ 5}
+
+def spanningWord : Fin 9 → FreeGroup (Fin 3) := ![1,FreeGroup.of 0,
+  FreeGroup.of 0 * FreeGroup.of 0,FreeGroup.of 1,FreeGroup.of 2,
+  FreeGroup.of 1 * FreeGroup.of 0,FreeGroup.of 2 * FreeGroup.of 0,
+  FreeGroup.of 0 * FreeGroup.of 1,FreeGroup.of 0 * FreeGroup.of 2]
+
+lemma spanningWord_mem (i : Fin 9) : spanningWord i ∈ shortWords := by
+  have hm (i j : Fin 3) : FreeGroup.norm (FreeGroup.of i * FreeGroup.of j) ≤ 5 :=
+    (FreeGroup.norm_mul_le _ _).trans (by simp)
+  fin_cases i <;> simp [spanningWord, shortWords,hm]
+
+def spanningMatrix : Fin 9 → Matrix (Fin 3) (Fin 3) ℚ := ![
+!![1,0,0; 0,1,0; 0,0,1],
+!![4,0,0; 0,1,0; 0,0,(1/4)],
+!![16,0,0; 0,1,0; 0,0,(1/16)],
+!![1,-2,-1; 0,1,1; 0,0,1],
+!![1,0,0; -1,1,0; -1,2,1],
+!![4,-2,(-1/4); 0,1,(1/4); 0,0,(1/4)],
+!![4,0,0; -4,1,0; -4,2,(1/4)],
+!![4,-8,-4; 0,1,1; 0,0,(1/4)],
+!![4,0,0; -1,1,0; (-1/4),(1/2),(1/4)]]
+
+@[simp] lemma spanningMatrix_at_0 : spanningMatrix 0 = !![1,0,0; 0,1,0; 0,0,1] := rfl
+@[simp] lemma spanningWord_at_0 : spanningWord 0 = 1 := rfl
+@[simp] lemma spanningMatrix_at_1 : spanningMatrix 1 = !![4,0,0; 0,1,0; 0,0,(1/4)] := rfl
+@[simp] lemma spanningWord_at_1 : spanningWord 1 = FreeGroup.of 0 := rfl
+@[simp] lemma spanningMatrix_at_2 : spanningMatrix 2 = !![16,0,0; 0,1,0; 0,0,(1/16)] := rfl
+@[simp] lemma spanningWord_at_2 : spanningWord 2 = FreeGroup.of 0 * FreeGroup.of 0 := rfl
+@[simp] lemma spanningMatrix_at_3 : spanningMatrix 3 = !![1,-2,-1; 0,1,1; 0,0,1] := rfl
+@[simp] lemma spanningWord_at_3 : spanningWord 3 = FreeGroup.of 1 := rfl
+@[simp] lemma spanningMatrix_at_4 : spanningMatrix 4 = !![1,0,0; -1,1,0; -1,2,1] := rfl
+@[simp] lemma spanningWord_at_4 : spanningWord 4 = FreeGroup.of 2 := rfl
+@[simp] lemma spanningMatrix_at_5 : spanningMatrix 5 = !![4,-2,(-1/4); 0,1,(1/4); 0,0,(1/4)] := rfl
+@[simp] lemma spanningWord_at_5 : spanningWord 5 = FreeGroup.of 1 * FreeGroup.of 0 := rfl
+@[simp] lemma spanningMatrix_at_6 : spanningMatrix 6 = !![4,0,0; -4,1,0; -4,2,(1/4)] := rfl
+@[simp] lemma spanningWord_at_6 : spanningWord 6 = FreeGroup.of 2 * FreeGroup.of 0 := rfl
+@[simp] lemma spanningMatrix_at_7 : spanningMatrix 7 = !![4,-8,-4; 0,1,1; 0,0,(1/4)] := rfl
+@[simp] lemma spanningWord_at_7 : spanningWord 7 = FreeGroup.of 0 * FreeGroup.of 1 := rfl
+@[simp] lemma spanningMatrix_at_8 : spanningMatrix 8 = !![4,0,0; -1,1,0; (-1/4),(1/2),(1/4)] := rfl
+@[simp] lemma spanningWord_at_8 : spanningWord 8 = FreeGroup.of 0 * FreeGroup.of 2 := rfl
+
+@[simp] lemma referenceRho_of (i : Fin 3) : referenceRho (FreeGroup.of i) = referenceGenerator i := by simp [referenceRho]
+
+@[simp] lemma reference_mat_0 : mat (referenceGenerator 0) = !![(2:ℚ),0;0,1/2] := rfl
+@[simp] lemma reference_mat_1 : mat (referenceGenerator 1) = !![(1:ℚ),1;0,1] := rfl
+@[simp] lemma reference_mat_2 : mat (referenceGenerator 2) = !![(1:ℚ),0;1,1] := rfl
+lemma reference_mat_inv (g : SpecialLinearGroup (Fin 2) ℚ) :
+    mat g⁻¹ = Matrix.adjugate (mat g) := rfl
+lemma spanningMatrix_0 : LinearMap.toMatrix' (adjoint (referenceRho (spanningWord 0))) =
+    spanningMatrix 0 := by
+  ext i j
+  change extract (mat (referenceRho (spanningWord 0)) * traceless (Pi.single j 1) *
+    mat ((referenceRho (spanningWord 0))⁻¹)) i = spanningMatrix 0 i j
+  simp only [spanningWord_at_0, map_one, inv_one, mat_one, one_mul, mul_one,
+    traceless_extract, spanningMatrix_at_0]
+  fin_cases i <;> fin_cases j <;> norm_num [Pi.single_apply]
+
+lemma spanningMatrix_1 : LinearMap.toMatrix' (adjoint (referenceRho (spanningWord 1))) =
+    spanningMatrix 1 := by
+  ext i j
+  change extract (mat (referenceRho (spanningWord 1)) * traceless (Pi.single j 1) *
+    mat ((referenceRho (spanningWord 1))⁻¹)) i = spanningMatrix 1 i j
+  simp only [spanningWord_at_1, referenceRho_of, reference_mat_inv, reference_mat_0]
+  fin_cases i <;> fin_cases j <;>
+    norm_num [extract, traceless, Matrix.mul_apply,
+      Matrix.adjugate_fin_two, Fin.sum_univ_two, Pi.single_apply, Fin.ext_iff]
+
+lemma spanningMatrix_2 : LinearMap.toMatrix' (adjoint (referenceRho (spanningWord 2))) =
+    spanningMatrix 2 := by
+  ext i j
+  change extract (mat (referenceRho (spanningWord 2)) * traceless (Pi.single j 1) *
+    mat ((referenceRho (spanningWord 2))⁻¹)) i = spanningMatrix 2 i j
+  simp only [spanningWord_at_2, map_mul, referenceRho_of,
+    reference_mat_inv, mat_mul, reference_mat_0]
+  fin_cases i <;> fin_cases j <;>
+    norm_num [extract, traceless, Matrix.mul_apply,
+      Matrix.adjugate_fin_two, Fin.sum_univ_two, Pi.single_apply, Fin.ext_iff]
+
+lemma spanningMatrix_3 : LinearMap.toMatrix' (adjoint (referenceRho (spanningWord 3))) =
+    spanningMatrix 3 := by
+  ext i j
+  change extract (mat (referenceRho (spanningWord 3)) * traceless (Pi.single j 1) *
+    mat ((referenceRho (spanningWord 3))⁻¹)) i = spanningMatrix 3 i j
+  simp only [spanningWord_at_3, referenceRho_of, reference_mat_inv, reference_mat_1]
+  fin_cases i <;> fin_cases j <;>
+    norm_num [extract, traceless, Matrix.mul_apply,
+      Matrix.adjugate_fin_two, Fin.sum_univ_two, Pi.single_apply, Fin.ext_iff]
+
+lemma spanningMatrix_4 : LinearMap.toMatrix' (adjoint (referenceRho (spanningWord 4))) =
+    spanningMatrix 4 := by
+  ext i j
+  change extract (mat (referenceRho (spanningWord 4)) * traceless (Pi.single j 1) *
+    mat ((referenceRho (spanningWord 4))⁻¹)) i = spanningMatrix 4 i j
+  simp only [spanningWord_at_4, referenceRho_of, reference_mat_inv, reference_mat_2]
+  fin_cases i <;> fin_cases j <;>
+    norm_num [extract, traceless, Matrix.mul_apply,
+      Matrix.adjugate_fin_two, Fin.sum_univ_two, Pi.single_apply, Fin.ext_iff]
+
+lemma spanningMatrix_5 : LinearMap.toMatrix' (adjoint (referenceRho (spanningWord 5))) =
+    spanningMatrix 5 := by
+  ext i j
+  change extract (mat (referenceRho (spanningWord 5)) * traceless (Pi.single j 1) *
+    mat ((referenceRho (spanningWord 5))⁻¹)) i = spanningMatrix 5 i j
+  simp only [spanningWord_at_5, map_mul, referenceRho_of,
+    reference_mat_inv, mat_mul, reference_mat_0, reference_mat_1]
+  fin_cases i <;> fin_cases j <;>
+    norm_num [extract, traceless, Matrix.mul_apply,
+      Matrix.adjugate_fin_two, Fin.sum_univ_two, Pi.single_apply, Fin.ext_iff]
+
+lemma spanningMatrix_6 : LinearMap.toMatrix' (adjoint (referenceRho (spanningWord 6))) =
+    spanningMatrix 6 := by
+  ext i j
+  change extract (mat (referenceRho (spanningWord 6)) * traceless (Pi.single j 1) *
+    mat ((referenceRho (spanningWord 6))⁻¹)) i = spanningMatrix 6 i j
+  simp only [spanningWord_at_6, map_mul, referenceRho_of,
+    reference_mat_inv, mat_mul, reference_mat_0, reference_mat_2]
+  fin_cases i <;> fin_cases j <;>
+    norm_num [extract, traceless, Matrix.mul_apply,
+      Matrix.adjugate_fin_two, Fin.sum_univ_two, Pi.single_apply, Fin.ext_iff]
+
+lemma spanningMatrix_7 : LinearMap.toMatrix' (adjoint (referenceRho (spanningWord 7))) =
+    spanningMatrix 7 := by
+  ext i j
+  change extract (mat (referenceRho (spanningWord 7)) * traceless (Pi.single j 1) *
+    mat ((referenceRho (spanningWord 7))⁻¹)) i = spanningMatrix 7 i j
+  simp only [spanningWord_at_7, map_mul, referenceRho_of,
+    reference_mat_inv, mat_mul, reference_mat_0, reference_mat_1]
+  fin_cases i <;> fin_cases j <;>
+    norm_num [extract, traceless, Matrix.mul_apply,
+      Matrix.adjugate_fin_two, Fin.sum_univ_two, Pi.single_apply, Fin.ext_iff]
+
+lemma spanningMatrix_8 : LinearMap.toMatrix' (adjoint (referenceRho (spanningWord 8))) =
+    spanningMatrix 8 := by
+  ext i j
+  change extract (mat (referenceRho (spanningWord 8)) * traceless (Pi.single j 1) *
+    mat ((referenceRho (spanningWord 8))⁻¹)) i = spanningMatrix 8 i j
+  simp only [spanningWord_at_8, map_mul, referenceRho_of,
+    reference_mat_inv, mat_mul, reference_mat_0, reference_mat_2]
+  fin_cases i <;> fin_cases j <;>
+    norm_num [extract, traceless, Matrix.mul_apply,
+      Matrix.adjugate_fin_two, Fin.sum_univ_two, Pi.single_apply, Fin.ext_iff]
+
+lemma spanningMatrix_eq (i : Fin 9) : LinearMap.toMatrix' (adjoint (referenceRho (spanningWord i))) =
+    spanningMatrix i := by
+  fin_cases i
+  · exact spanningMatrix_0
+  · exact spanningMatrix_1
+  · exact spanningMatrix_2
+  · exact spanningMatrix_3
+  · exact spanningMatrix_4
+  · exact spanningMatrix_5
+  · exact spanningMatrix_6
+  · exact spanningMatrix_7
+  · exact spanningMatrix_8
+
+lemma matrixUnit_00 : Matrix.single 0 0 (1:ℚ) =
+    ((1/45) : ℚ) • spanningMatrix 0 +
+    ((-1/9) : ℚ) • spanningMatrix 1 +
+    ((4/45) : ℚ) • spanningMatrix 2 := by
+  ext i j
+  fin_cases i <;> fin_cases j <;> norm_num [Matrix.single_apply, Matrix.smul_apply, Matrix.add_apply]
+
+lemma matrixUnit_01 : Matrix.single 0 1 (1:ℚ) =
+    ((-1/6) : ℚ) • spanningMatrix 0 +
+    ((2/3) : ℚ) • spanningMatrix 1 +
+    ((1/6) : ℚ) • spanningMatrix 3 +
+    ((-2/3) : ℚ) • spanningMatrix 5 := by
+  ext i j
+  fin_cases i <;> fin_cases j <;> norm_num [Matrix.single_apply, Matrix.smul_apply, Matrix.add_apply]
+
+lemma matrixUnit_02 : Matrix.single 0 2 (1:ℚ) =
+    (-1 : ℚ) • spanningMatrix 1 +
+    ((4/3) : ℚ) • spanningMatrix 5 +
+    ((-1/3) : ℚ) • spanningMatrix 7 := by
+  ext i j
+  fin_cases i <;> fin_cases j <;> norm_num [Matrix.single_apply, Matrix.smul_apply, Matrix.add_apply]
+
+lemma matrixUnit_10 : Matrix.single 1 0 (1:ℚ) =
+    ((-1/3) : ℚ) • spanningMatrix 0 +
+    ((4/3) : ℚ) • spanningMatrix 1 +
+    ((1/3) : ℚ) • spanningMatrix 4 +
+    ((-4/3) : ℚ) • spanningMatrix 8 := by
+  ext i j
+  fin_cases i <;> fin_cases j <;> norm_num [Matrix.single_apply, Matrix.smul_apply, Matrix.add_apply]
+
+lemma matrixUnit_11 : Matrix.single 1 1 (1:ℚ) =
+    ((-4/9) : ℚ) • spanningMatrix 0 +
+    ((17/9) : ℚ) • spanningMatrix 1 +
+    ((-4/9) : ℚ) • spanningMatrix 2 := by
+  ext i j
+  fin_cases i <;> fin_cases j <;> norm_num [Matrix.single_apply, Matrix.smul_apply, Matrix.add_apply]
+
+lemma matrixUnit_12 : Matrix.single 1 2 (1:ℚ) =
+    ((-4/3) : ℚ) • spanningMatrix 0 +
+    ((1/3) : ℚ) • spanningMatrix 1 +
+    ((4/3) : ℚ) • spanningMatrix 3 +
+    ((-1/3) : ℚ) • spanningMatrix 7 := by
+  ext i j
+  fin_cases i <;> fin_cases j <;> norm_num [Matrix.single_apply, Matrix.smul_apply, Matrix.add_apply]
+
+lemma matrixUnit_20 : Matrix.single 2 0 (1:ℚ) =
+    (-1 : ℚ) • spanningMatrix 1 +
+    ((-1/3) : ℚ) • spanningMatrix 6 +
+    ((4/3) : ℚ) • spanningMatrix 8 := by
+  ext i j
+  fin_cases i <;> fin_cases j <;> norm_num [Matrix.single_apply, Matrix.smul_apply, Matrix.add_apply]
+
+lemma matrixUnit_21 : Matrix.single 2 1 (1:ℚ) =
+    ((-2/3) : ℚ) • spanningMatrix 0 +
+    ((1/6) : ℚ) • spanningMatrix 1 +
+    ((2/3) : ℚ) • spanningMatrix 4 +
+    ((-1/6) : ℚ) • spanningMatrix 6 := by
+  ext i j
+  fin_cases i <;> fin_cases j <;> norm_num [Matrix.single_apply, Matrix.smul_apply, Matrix.add_apply]
+
+lemma matrixUnit_22 : Matrix.single 2 2 (1:ℚ) =
+    ((64/45) : ℚ) • spanningMatrix 0 +
+    ((-16/9) : ℚ) • spanningMatrix 1 +
+    ((16/45) : ℚ) • spanningMatrix 2 := by
+  ext i j
+  fin_cases i <;> fin_cases j <;> norm_num [Matrix.single_apply, Matrix.smul_apply, Matrix.add_apply]
+
+ 
+
+lemma shortWords_finite : shortWords.Finite := by
+  let f : (Σ n : Fin 6, Fin n.val → Fin 3 × Bool) → shortWords := fun w ↦
+    ⟨FreeGroup.mk (List.ofFn w.2),
+      FreeGroup.norm_mk_le.trans (by simpa only [List.length_ofFn] using Nat.le_of_lt_succ w.1.isLt)⟩
+  have hf : Function.Surjective f := by
+    rintro ⟨g,hg⟩
+    refine ⟨⟨⟨FreeGroup.norm g, Nat.lt_succ_of_le hg⟩,g.toWord.get⟩, ?_⟩
+    apply Subtype.ext
+    change FreeGroup.mk (List.ofFn g.toWord.get) = g
+    simpa only [List.ofFn_get] using (FreeGroup.mk_toWord (x := g))
+  let : Finite shortWords := Finite.of_surjective f hf
+  exact Set.toFinite _
+
+lemma one_mem_shortWords : (1 : FreeGroup (Fin 3)) ∈ shortWords := by
+  simp [shortWords]
+
+lemma inv_mem_shortWords {g : FreeGroup (Fin 3)} (hg : g ∈ shortWords) :
+    g⁻¹ ∈ shortWords := by simpa only [shortWords, Set.mem_ofPred_eq, FreeGroup.norm_inv_eq] using hg
+
+ 
+
+def reverseWord (g : FreeGroup (Fin 3)) : FreeGroup (Fin 3) :=
+  FreeGroup.mk g.toWord.reverse
+
+lemma reverse_mem_shortWords {g : FreeGroup (Fin 3)} (hg : g ∈ shortWords) :
+    reverseWord g ∈ shortWords := by
+  change FreeGroup.norm (FreeGroup.mk g.toWord.reverse) ≤ 5
+  change g.toWord.length ≤ 5 at hg
+  apply FreeGroup.norm_mk_le.trans
+  simpa only [List.length_reverse] using hg
+
+lemma reference_matrix_span : Submodule.span ℚ
+    (Set.range (fun c : shortWords ↦ LinearMap.toMatrix' (adjoint (referenceRho c)))) = ⊤ := by
+  let S := Submodule.span ℚ
+    (Set.range (fun c : shortWords ↦ LinearMap.toMatrix' (adjoint (referenceRho c))))
+  have hm (i : Fin 9) : spanningMatrix i ∈ S := by
+    rw [← spanningMatrix_eq]
+    exact Submodule.subset_span ⟨⟨spanningWord i,spanningWord_mem i⟩,rfl⟩
+  have hs (i j : Fin 3) : Matrix.single i j (1:ℚ) ∈ S := by
+    fin_cases i <;> fin_cases j
+    · change Matrix.single 0 0 (1:ℚ) ∈ S
+      rw [matrixUnit_00]
+      repeat' first | exact hm _ | apply S.add_mem | apply S.smul_mem
+    · change Matrix.single 0 1 (1:ℚ) ∈ S
+      rw [matrixUnit_01]
+      repeat' first | exact hm _ | apply S.add_mem | apply S.smul_mem
+    · change Matrix.single 0 2 (1:ℚ) ∈ S
+      rw [matrixUnit_02]
+      repeat' first | exact hm _ | apply S.add_mem | apply S.smul_mem
+    · change Matrix.single 1 0 (1:ℚ) ∈ S
+      rw [matrixUnit_10]
+      repeat' first | exact hm _ | apply S.add_mem | apply S.smul_mem
+    · change Matrix.single 1 1 (1:ℚ) ∈ S
+      rw [matrixUnit_11]
+      repeat' first | exact hm _ | apply S.add_mem | apply S.smul_mem
+    · change Matrix.single 1 2 (1:ℚ) ∈ S
+      rw [matrixUnit_12]
+      repeat' first | exact hm _ | apply S.add_mem | apply S.smul_mem
+    · change Matrix.single 2 0 (1:ℚ) ∈ S
+      rw [matrixUnit_20]
+      repeat' first | exact hm _ | apply S.add_mem | apply S.smul_mem
+    · change Matrix.single 2 1 (1:ℚ) ∈ S
+      rw [matrixUnit_21]
+      repeat' first | exact hm _ | apply S.add_mem | apply S.smul_mem
+    · change Matrix.single 2 2 (1:ℚ) ∈ S
+      rw [matrixUnit_22]
+      repeat' first | exact hm _ | apply S.add_mem | apply S.smul_mem
+  apply top_unique
+  intro B _
+  rw [Matrix.matrix_eq_sum_single B]
+  apply S.sum_mem; intro i _
+  apply S.sum_mem; intro j _
+  simpa only [Matrix.smul_single, smul_eq_mul, mul_one] using S.smul_mem (B i j) (hs i j)
+
+theorem finite_reference_adjoint_span : Submodule.span ℚ
+    (Set.range (fun c : shortWords ↦ adjoint (referenceRho c))) = ⊤ := by
+  have h := congrArg (Submodule.map Matrix.toLin'.toLinearMap) reference_matrix_span
+  simpa only [Submodule.map_span, ← Set.range_comp, Submodule.map_top,
+    LinearEquiv.range, Function.comp_def, LinearEquiv.coe_coe,
+    Matrix.toLin'_toMatrix'] using h
+
+end BoundaryOnly.Holonomy
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/MarkedTensor/TripleProducts.lean b/lean/OAI/Algebra/MarkedTensor/TripleProducts.lean
new file mode 100644
index 0000000000000000000000000000000000000000..bd10eae841680ec5f91ecdb2012caecdb3d64e1e
--- /dev/null
+++ b/lean/OAI/Algebra/MarkedTensor/TripleProducts.lean
@@ -0,0 +1,275 @@
+import Mathlib
+import OAI.Algebra.MarkedTensor.AdjointCoordinates
+
+namespace OAI
+
+/-! Triple coordinate products and cubic nilpotence of local holonomy ideals. -/
+
+noncomputable section
+open scoped BigOperators commutatorElement
+open Matrix
+
+namespace BoundaryOnly.Holonomy
+open Matrix
+open scoped BigOperators
+variable {R : Type*} [CommRing R] [Algebra ℚ R]
+
+noncomputable def tripleEvaluation (x y z : Vec₃ R) :
+    (Vec₃ R →ₗ[R] Vec₃ R) →ₗ[R]
+      (Vec₃ R →ₗ[R] Vec₃ R) →ₗ[R]
+        (Vec₃ R →ₗ[R] Vec₃ R) →ₗ[R] Mat₂ R where
+  toFun A :=
+    { toFun := fun B ↦
+        { toFun := fun C ↦ lie (tracelessLM (A x))
+            (lie (tracelessLM (B y)) (tracelessLM (C z)))
+          map_add' := by
+            intro C D
+            simp only [LinearMap.add_apply, map_add, lie, mul_add,add_mul]
+            noncomm_ring
+          map_smul' := by
+            intro c C
+            simp only [LinearMap.smul_apply, map_smul, lie, mul_smul_comm,
+              smul_mul_assoc, ← smul_sub, RingHom.id_apply] }
+      map_add' := by
+        intro B C; apply LinearMap.ext; intro D
+        change lie (tracelessLM (A x))
+          (lie (tracelessLM ((B+C) y)) (tracelessLM (D z))) =
+          lie (tracelessLM (A x)) (lie (tracelessLM (B y)) (tracelessLM (D z))) +
+          lie (tracelessLM (A x)) (lie (tracelessLM (C y)) (tracelessLM (D z)))
+        simp only [LinearMap.add_apply, map_add, lie, mul_add,add_mul]
+        noncomm_ring
+      map_smul' := by
+        intro c B; apply LinearMap.ext; intro D
+        change lie (tracelessLM (A x))
+          (lie (tracelessLM ((c • B) y)) (tracelessLM (D z))) =
+          c • lie (tracelessLM (A x)) (lie (tracelessLM (B y)) (tracelessLM (D z)))
+        simp only [LinearMap.smul_apply, map_smul, lie, mul_smul_comm,
+          smul_mul_assoc, ← smul_sub] }
+  map_add' := by
+    intro A B; apply LinearMap.ext; intro C; apply LinearMap.ext; intro D
+    change lie (tracelessLM ((A+B) x))
+      (lie (tracelessLM (C y)) (tracelessLM (D z))) =
+      lie (tracelessLM (A x)) (lie (tracelessLM (C y)) (tracelessLM (D z))) +
+      lie (tracelessLM (B x)) (lie (tracelessLM (C y)) (tracelessLM (D z)))
+    simp only [LinearMap.add_apply, map_add, lie, mul_add,add_mul]
+    noncomm_ring
+  map_smul' := by
+    intro c A; apply LinearMap.ext; intro B; apply LinearMap.ext; intro C
+    change lie (tracelessLM ((c • A) x))
+      (lie (tracelessLM (B y)) (tracelessLM (C z))) =
+      c • lie (tracelessLM (A x)) (lie (tracelessLM (B y)) (tracelessLM (C z)))
+    simp only [LinearMap.smul_apply, map_smul, lie, mul_smul_comm,
+      smul_mul_assoc, ← smul_sub]
+
+def entriesSubmodule (I : Ideal R) : Submodule R (Mat₂ R) where
+  carrier := {A | A ∈ I.matrix (Fin 2)}
+  zero_mem' := (I.matrix _).zero_mem
+  add_mem' := fun h h' ↦ (I.matrix _).add_mem h h'
+  smul_mem' := by
+    intro c A h i j
+    exact I.mul_mem_left c (h i j)
+
+omit [Algebra ℚ R] in
+lemma span_map_mem {V M : Type*} [AddCommGroup V] [Module R V]
+    [AddCommGroup M] [Module R M] (W : Submodule R M)
+    (f : V →ₗ[R] M) {s : Set V} (h : ∀ x ∈ s, f x ∈ W) :
+    ∀ x ∈ Submodule.span R s, f x ∈ W := by
+  exact fun x hx ↦ (Submodule.span_le.mpr h : Submodule.span R s ≤ W.comap f) hx
+
+omit [Algebra ℚ R] in
+lemma span_three_mem {V M : Type*} [AddCommGroup V] [Module R V]
+    [AddCommGroup M] [Module R M] (W : Submodule R M)
+    (f : V →ₗ[R] V →ₗ[R] V →ₗ[R] M) {s : Set V}
+    (h : ∀ a ∈ s, ∀ b ∈ s, ∀ c ∈ s, f a b c ∈ W)
+    {a b c : V} (ha : a ∈ Submodule.span R s) (hb : b ∈ Submodule.span R s)
+    (hc : c ∈ Submodule.span R s) : f a b c ∈ W := by
+  apply span_map_mem W ((f.flip b).flip c) (fun a ha ↦ ?_) a ha
+  apply span_map_mem W ((f a).flip c) (fun b hb ↦ ?_) b hb
+  exact span_map_mem W (f a b) (h a ha b hb) c hc
+
+noncomputable def rankMap (i j : Fin 3) : Vec₃ R →ₗ[R] Vec₃ R where
+  toFun v := v j • Pi.single i 1
+  map_add' v w := by simp only [Pi.add_apply,add_smul]
+  map_smul' c v := by simp only [Pi.smul_apply,smul_smul,RingHom.id_apply,smul_eq_mul]
+
+ 
+
+lemma coordinate_product_mem {H : Type*} (G : H → SpecialLinearGroup (Fin 2) R)
+    (hspan : Submodule.span R (Set.range (fun h ↦ adjoint (G h))) = ⊤)
+    {J : Ideal R} (x y z : Vec₃ R)
+    (h : ∀ a b c, lie (traceless (adjoint (G a) x))
+      (lie (traceless (adjoint (G b) y)) (traceless (adjoint (G c) z))) ∈
+        J.matrix (Fin 2)) (i j k : Fin 3) : x i*y j*z k ∈ J := by
+  have hgen : ∀ A ∈ Set.range (fun h ↦ adjoint (G h)),
+      ∀ B ∈ Set.range (fun h ↦ adjoint (G h)),
+      ∀ C ∈ Set.range (fun h ↦ adjoint (G h)),
+        tripleEvaluation x y z A B C ∈ entriesSubmodule J := by
+    rintro A ⟨a,rfl⟩ B ⟨b,rfl⟩ C ⟨c,rfl⟩
+    exact h a b c
+  have hp (A : Vec₃ R →ₗ[R] Vec₃ R) :
+      A ∈ Submodule.span R (Set.range (fun h ↦ adjoint (G h))) := by
+    rw [hspan]; trivial
+  have hh := span_three_mem (entriesSubmodule J) (tripleEvaluation x y z) hgen
+    (hp (rankMap 0 i)) (hp (rankMap 1 j)) (hp (rankMap 2 k))
+  have hentry := hh 0 0
+  have he : tripleEvaluation x y z (rankMap 0 i) (rankMap 1 j) (rankMap 2 k) 0 0 =
+      -2*(x i*y j*z k) := by
+    simp [tripleEvaluation,rankMap,tracelessLM,traceless,lie]
+    ring
+  rw [he] at hentry
+  have hmul := J.mul_mem_left (-half (R := R)) hentry
+  have heq : (-half (R := R))*(-2*(x i*y j*z k)) = x i*y j*z k := by
+    linear_combination (x i*y j*z k)*two_half (R := R)
+  rwa [heq] at hmul
+
+end BoundaryOnly.Holonomy
+namespace BoundaryOnly.Holonomy
+open Matrix
+open scoped BigOperators Pointwise
+variable {R E : Type*} [CommRing R] [Algebra ℚ R]
+
+def deviationIdeal (z : E → SpecialLinearGroup (Fin 2) R) : Ideal R :=
+  Ideal.span (Set.range (fun p : E × Fin 2 × Fin 2 ↦ (mat (z p.1)-1) p.2.1 p.2.2))
+noncomputable def coordinateIdeal (z : E → SpecialLinearGroup (Fin 2) R) : Ideal R :=
+  Ideal.span (Set.range (fun p : E × Fin 3 ↦ coordinates (mat (z p.1)-1) p.2))
+
+omit [Algebra ℚ R] in
+lemma deviation_mem (z : E → SpecialLinearGroup (Fin 2) R) (e : E) :
+    mat (z e)-1 ∈ (deviationIdeal z).matrix (Fin 2) :=
+  fun i j ↦ Ideal.subset_span ⟨(e,i,j),rfl⟩
+
+lemma coordinates_mem {N : Ideal R} {A : Mat₂ R} (hA : A ∈ N.matrix (Fin 2)) (i : Fin 3) :
+    coordinates A i ∈ N := by
+  fin_cases i
+  · exact hA 0 1
+  · exact N.mul_mem_right _ (N.sub_mem (hA 0 0) (hA 1 1))
+  · exact hA 1 0
+
+lemma coordinateIdeal_le (z : E → SpecialLinearGroup (Fin 2) R) :
+    coordinateIdeal z ≤ deviationIdeal z := by
+  apply Ideal.span_le.mpr
+  rintro a ⟨⟨e,i⟩,rfl⟩
+  exact coordinates_mem (deviation_mem z e) i
+
+omit [Algebra ℚ R] in
+lemma trace_deviation_mem {N : Ideal R} (z : SpecialLinearGroup (Fin 2) R)
+    (hz : mat z-1 ∈ N.matrix (Fin 2)) : Matrix.trace (mat z-1) ∈ N^2 := by
+  have hd := z.property
+  change Matrix.det (mat z)=1 at hd
+  rw [Matrix.det_fin_two] at hd
+  have he : Matrix.trace (mat z-1) =
+      -((mat z-1) 0 0*(mat z-1) 1 1-(mat z-1) 0 1*(mat z-1) 1 0) := by
+    simp only [Matrix.trace, Fin.sum_univ_two, Matrix.diag_apply, Matrix.sub_apply,
+      Matrix.one_apply, ite_true, show (0:Fin 2) ≠ 1 by decide,
+      show (1:Fin 2) ≠ 0 by decide, ite_false, sub_zero]
+    linear_combination hd
+  rw [he,pow_two]
+  exact (N*N).neg_mem ((N*N).sub_mem (Ideal.mul_mem_mul (hz 0 0) (hz 1 1))
+    (Ideal.mul_mem_mul (hz 0 1) (hz 1 0)))
+
+omit [Algebra ℚ R] in
+lemma scalar_mem {I : Ideal R} {r : R} (hr : r ∈ I) :
+    scalar (Fin 2) r ∈ I.matrix (Fin 2) := by
+  intro i j
+  change (if i=j then r else 0) ∈ I
+  split_ifs
+  · exact hr
+  · exact I.zero_mem
+
+omit [Algebra ℚ R] in
+lemma traceless_mem {I : Ideal R} {v : Vec₃ R} (hv : ∀ i, v i ∈ I) :
+    traceless v ∈ I.matrix (Fin 2) := by
+  intro i j
+  fin_cases i <;> fin_cases j
+  · exact hv 1
+  · exact hv 0
+  · exact hv 2
+  · exact I.neg_mem (hv 1)
+
+lemma deviation_le_coordinates (z : E → SpecialLinearGroup (Fin 2) R) :
+    deviationIdeal z ≤ coordinateIdeal z ⊔ deviationIdeal z^2 := by
+  apply Ideal.span_le.mpr
+  rintro a ⟨⟨e,i,j⟩,rfl⟩
+  let A := mat (z e)-1
+  have hT : traceless (coordinates A) ∈ (coordinateIdeal z).matrix (Fin 2) := by
+    apply traceless_mem
+    exact fun k ↦ Ideal.subset_span ⟨(e,k),rfl⟩
+  have hS : scalar (Fin 2) (Matrix.trace A*half) ∈
+      (deviationIdeal z^2).matrix (Fin 2) :=
+    scalar_mem ((deviationIdeal z^2).mul_mem_right _
+      (trace_deviation_mem (z e) (deviation_mem z e)))
+  have he : A = traceless (coordinates A)+scalar (Fin 2) (Matrix.trace A*half) := by
+    rw [traceless_coordinates]; abel
+  change A i j ∈ coordinateIdeal z ⊔ deviationIdeal z^2
+  rw [he, Matrix.add_apply]
+  exact Submodule.add_mem_sup (hT i j) (hS i j)
+
+ 
+
+lemma deviationIdeal_eq_coordinates [IsNoetherianRing R] [IsLocalRing R]
+    (z : E → SpecialLinearGroup (Fin 2) R)
+    (hz : deviationIdeal z ≤ IsLocalRing.maximalIdeal R) :
+    deviationIdeal z = coordinateIdeal z := by
+  apply le_antisymm _ (coordinateIdeal_le z)
+  apply Submodule.le_of_le_smul_of_le_jacobson_bot
+    (IsNoetherian.noetherian (deviationIdeal z))
+    (IsLocalRing.maximalIdeal_le_jacobson ⊥)
+  apply (deviation_le_coordinates z).trans
+  apply sup_le_sup_left
+  change deviationIdeal z^2 ≤ IsLocalRing.maximalIdeal R * deviationIdeal z
+  rw [pow_two]
+  exact Ideal.mul_mono hz le_rfl
+
+lemma coordinate_cube_le (z : E → SpecialLinearGroup (Fin 2) R) (J : Ideal R)
+    (h : ∀ e f g i j k, coordinates (mat (z e)-1) i *
+      coordinates (mat (z f)-1) j*coordinates (mat (z g)-1) k ∈ J) :
+    coordinateIdeal z^3 ≤ J := by
+  rw [show (3:ℕ)=2+1 by rfl, pow_succ, pow_two]
+  simp only [coordinateIdeal, Ideal.span_mul_span]
+  apply Ideal.span_le.mpr
+  rintro a ⟨b,⟨c,⟨⟨e,i⟩,rfl⟩,d,⟨⟨f,j⟩,rfl⟩,rfl⟩,
+    e',⟨⟨g,k⟩,rfl⟩,rfl⟩
+  exact h e f g i j k
+
+end BoundaryOnly.Holonomy
+namespace BoundaryOnly.Holonomy
+open Matrix
+open scoped BigOperators commutatorElement
+variable {R E H : Type*} [CommRing R] [Algebra ℚ R]
+
+ 
+
+theorem cubic_nilpotence_local [IsNoetherianRing R] [IsLocalRing R]
+    (z : E → SpecialLinearGroup (Fin 2) R)
+    (u G : H → SpecialLinearGroup (Fin 2) R)
+    (hz : ∀ e, mat (z e)-1 ∈ (IsLocalRing.maximalIdeal R).matrix (Fin 2))
+    (hu : ∀ c, mat (u c)-mat (G c) ∈ (IsLocalRing.maximalIdeal R).matrix (Fin 2))
+    (hspan : Submodule.span R (Set.range (fun h ↦ adjoint (G h))) = ⊤)
+    (hrel : ∀ e f g a b c,
+      ⁅u a*z e*(u a)⁻¹,⁅u b*z f*(u b)⁻¹,u c*z g*(u c)⁻¹⁆⁆ = 1) :
+    deviationIdeal z^3 = ⊥ := by
+  let m := IsLocalRing.maximalIdeal R
+  let N := deviationIdeal z
+  have hNm : N ≤ m := by
+    apply Ideal.span_le.mpr
+    rintro x ⟨⟨e,i,j⟩,rfl⟩
+    exact hz e i j
+  have hNT := deviationIdeal_eq_coordinates z hNm
+  have hproducts (e f g : E) (i j k : Fin 3) :
+      coordinates (mat (z e)-1) i*coordinates (mat (z f)-1) j*
+        coordinates (mat (z g)-1) k ∈ m*N^3 := by
+    apply coordinate_product_mem G hspan
+    intro a b c
+    exact reference_traceless_triple hNm (hu a) (hu b) (hu c)
+      (deviation_mem z e) (deviation_mem z f) (deviation_mem z g) (hrel e f g a b c)
+  have hle : N^3 ≤ m*N^3 := by
+    change deviationIdeal z^3 ≤ m*N^3
+    rw [hNT]
+    exact coordinate_cube_le z (m*N^3) hproducts
+  exact Submodule.eq_bot_of_le_smul_of_le_jacobson_bot m (N^3)
+    (IsNoetherian.noetherian _) hle (IsLocalRing.maximalIdeal_le_jacobson ⊥)
+
+end BoundaryOnly.Holonomy
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/Module/CompactPadic.lean b/lean/OAI/Algebra/Module/CompactPadic.lean
new file mode 100644
index 0000000000000000000000000000000000000000..016fcd74c8478a50cc13e9f2d22262896827e76b
--- /dev/null
+++ b/lean/OAI/Algebra/Module/CompactPadic.lean
@@ -0,0 +1,181 @@
+import Mathlib
+
+namespace OAI
+
+/-!
+# Compact p-adic modules
+
+The map `1 - shift` is surjective on the product of a tower of finite abelian groups,
+without any surjectivity assumption on the transition maps. A compact Hausdorff module
+vanishes if a topologically nilpotent scalar acts surjectively. This implies compact
+p-adic Nakayama: a compact Hausdorff `ℤ_[p]`-module with continuous operations is finitely
+generated exactly when its quotient modulo `p` is finite. Finitely generated
+`ℤ_[p]`-modules also have finite `p`-torsion.
+
+These are algebraic support results. The `K(n)`-local sphere, its homotopy groups,
+their p-adic topology and module structure, and their ranks are not constructed here.
+-/
+
+open Filter Topology CategoryTheory
+open scoped Pointwise
+
+namespace KnLocalSphere.IntegralRecovery
+
+universe u v
+
+/-- The map `1 - shift` is surjective for any tower of finite abelian groups. -/
+theorem one_sub_shift_surjective (A : ℕ → Type u)
+    [∀ n, AddCommGroup (A n)] [∀ n, Finite (A n)]
+    (f : ∀ n, A (n + 1) →+ A n) :
+    Function.Surjective (fun x : (n : ℕ) → A n => fun n => x n - f n (x (n + 1))) := by
+  intro y
+  let D : ℕᵒᵖ ⥤ Type u := CategoryTheory.Functor.ofOpSequence
+    (X := A) (fun n => ↾(fun z => y n + f n z))
+  have : ∀ n, Finite (D.obj n) := fun n => inferInstanceAs (Finite (A n.unop))
+  have : ∀ n, Nonempty (D.obj n) := fun n => ⟨(0 : A n.unop)⟩
+  obtain ⟨x, hx⟩ := nonempty_sections_of_finite_inverse_system D
+  refine ⟨fun n => x (Opposite.op n), ?_⟩
+  funext n
+  apply sub_eq_iff_eq_add.mpr
+  have h := hx (CategoryTheory.homOfLE (Nat.le_add_right n 1)).op
+  simp only [D, CategoryTheory.Functor.ofOpSequence_map_homOfLE_succ] at h
+  change y n + f n (x (Opposite.op (n + 1))) = x (Opposite.op n) at h
+  exact h.symm
+
+/-- A surjective topologically nilpotent scalar annihilates a compact Hausdorff module. -/
+theorem eq_zero_of_surjective_smul {R : Type u} {M : Type v}
+    [Semiring R] [TopologicalSpace R] [AddCommMonoid M] [Module R M]
+    [TopologicalSpace M] [CompactSpace M] [T2Space M] [ContinuousSMul R M]
+    (a : R) (ha : Tendsto (fun n : ℕ => a ^ n) atTop (𝓝 0))
+    (hs : Function.Surjective (fun x : M => a • x)) (x : M) : x = 0 := by
+  have hpow : ∀ n : ℕ, Function.Surjective (fun y : M => a ^ n • y) := by
+    intro n
+    induction n with
+    | zero =>
+      intro z
+      exact ⟨z, by change a ^ 0 • z = z; simp⟩
+    | succ n ih =>
+      intro z
+      obtain ⟨w, hw⟩ := hs z
+      obtain ⟨y, hy⟩ := ih w
+      refine ⟨y, ?_⟩
+      change a ^ (n + 1) • y = z
+      change a • w = z at hw
+      change a ^ n • y = w at hy
+      rw [pow_succ', mul_smul, hy, hw]
+  have hx : Tendsto (fun _ : ℕ => x) atTop (𝓝 (0 : M)) := by
+    intro U hU
+    have hV : ∀ᶠ r in 𝓝 (0 : R), ∀ y : M, r • y ∈ U := by
+      have h := (isCompact_univ : IsCompact (Set.univ : Set M)).eventually_forall_of_forall_eventually (x₀ := (0 : R))
+        (P := fun r y => r • y ∈ U) (fun y _ => by
+          have hy : Tendsto (fun z : R × M => z.1 • z.2) (𝓝 (0, y)) (𝓝 (0 : M)) := by
+            simpa only [ContinuousAt, zero_smul] using
+              (continuous_smul : Continuous (fun z : R × M => z.1 • z.2)).continuousAt (x := (0, y))
+          exact hy hU)
+      simpa only [Set.mem_univ, forall_true_left] using h
+    obtain ⟨n, hn⟩ := (ha.eventually hV).exists
+    obtain ⟨y, hy⟩ := hpow n x
+    change a ^ n • y = x at hy
+    have hxu : x ∈ U := by rw [← hy]; exact hn y
+    change ∀ᶠ _ : ℕ in atTop, x ∈ U
+    exact Filter.Eventually.of_forall (fun _ => hxu)
+  exact tendsto_nhds_unique tendsto_const_nhds hx
+
+/-- Compact p-adic Nakayama: finiteness modulo `p` implies finite generation over `ℤ_[p]`. -/
+theorem finite_of_finite_mod_p (p : ℕ) [Fact p.Prime]
+    (M : Type u) [AddCommGroup M] [Module ℤ_[p] M]
+    [TopologicalSpace M] [IsTopologicalAddGroup M] [ContinuousSMul ℤ_[p] M]
+    [CompactSpace M] [T2Space M]
+    [Finite (M ⧸ LinearMap.range (LinearMap.lsmul ℤ_[p] M (p : ℤ_[p])))] :
+    Module.Finite ℤ_[p] M := by
+  classical
+  let P := LinearMap.range (LinearMap.lsmul ℤ_[p] M (p : ℤ_[p]))
+  let r : M ⧸ P → M := Function.surjInv P.mkQ_surjective
+  have hr : ∀ z, P.mkQ (r z) = z := Function.surjInv_eq P.mkQ_surjective
+  let N : Submodule ℤ_[p] M := Submodule.span ℤ_[p] (Set.range r)
+  have hN : N.FG := Submodule.fg_span (Set.finite_range r)
+  have : CompactSpace (M ⧸ N) := N.mkQ_surjective.compactSpace N.continuous_mkQ
+  have : IsClosed (N : Set M) := (Submodule.isCompact_of_fg hN).isClosed
+  have hsurj : Function.Surjective (fun x : M ⧸ N => (p : ℤ_[p]) • x) := by
+    intro z
+    obtain ⟨x, rfl⟩ := N.mkQ_surjective z
+    have hmem : x - r (P.mkQ x) ∈ P := by
+      apply (Submodule.Quotient.mk_eq_zero _).mp
+      change P.mkQ (x - r (P.mkQ x)) = 0
+      rw [map_sub, hr, sub_self]
+    obtain ⟨y, hy⟩ := hmem
+    refine ⟨N.mkQ y, ?_⟩
+    have hn : N.mkQ (r (P.mkQ x)) = 0 := by
+      apply (Submodule.Quotient.mk_eq_zero _).mpr
+      exact Submodule.subset_span (Set.mem_range_self _)
+    change (p : ℤ_[p]) • y = x - r (P.mkQ x) at hy
+    change (p : ℤ_[p]) • N.mkQ y = N.mkQ x
+    rw [← map_smul, hy, map_sub, hn, sub_zero]
+  have hp : Tendsto (fun n : ℕ => (p : ℤ_[p]) ^ n) atTop (𝓝 0) := by
+    apply tendsto_pow_atTop_nhds_zero_of_norm_lt_one
+    rw [PadicInt.norm_p]
+    apply inv_lt_one_of_one_lt₀
+    exact_mod_cast (Fact.out : p.Prime).one_lt
+  have htop : N = ⊤ := by
+    apply Submodule.eq_top_iff'.mpr
+    intro x
+    apply (Submodule.Quotient.mk_eq_zero _).mp
+    exact eq_zero_of_surjective_smul (p : ℤ_[p]) hp hsurj (N.mkQ x)
+  exact ⟨htop ▸ hN⟩
+
+/-- A finitely generated `ℤ_[p]`-module has finite quotient modulo `p`. -/
+theorem finite_mod_p_of_finite_module (p : ℕ) [Fact p.Prime]
+    (M : Type u) [AddCommGroup M] [Module ℤ_[p] M] [Module.Finite ℤ_[p] M] :
+    Finite (M ⧸ LinearMap.range (LinearMap.lsmul ℤ_[p] M (p : ℤ_[p]))) := by
+  have : Finite (ℤ_[p] ⧸ Ideal.span {(p : ℤ_[p])}) := by
+    rw [← PadicInt.maximalIdeal_eq_span_p]
+    exact Finite.of_injective PadicInt.residueField PadicInt.residueField.injective
+  have h := Submodule.finite_quotient_smul (M := M) (Ideal.span {(p : ℤ_[p])})
+    (N := ⊤) (Module.Finite.fg_top (R := ℤ_[p]) (M := M))
+  have heq : Ideal.span {(p : ℤ_[p])} • (⊤ : Submodule ℤ_[p] M) =
+      LinearMap.range (LinearMap.lsmul ℤ_[p] M (p : ℤ_[p])) := by
+    rw [Submodule.ideal_span_singleton_smul]
+    ext x
+    simp [Submodule.mem_smul_pointwise_iff_exists, LinearMap.mem_range]
+  exact heq ▸ h
+
+/-- A finitely generated `ℤ_[p]`-module killed by `p` is finite. -/
+theorem finite_of_finite_module_killed_by_p (p : ℕ) [Fact p.Prime]
+    (M : Type u) [AddCommGroup M] [Module ℤ_[p] M] [Module.Finite ℤ_[p] M]
+    (hp : ∀ x : M, (p : ℤ_[p]) • x = 0) : Finite M := by
+  let P := LinearMap.range (LinearMap.lsmul ℤ_[p] M (p : ℤ_[p]))
+  have : Finite (M ⧸ P) := finite_mod_p_of_finite_module p M
+  apply Finite.of_injective P.mkQ
+  apply LinearMap.ker_eq_bot.mp
+  rw [Submodule.ker_mkQ]
+  apply LinearMap.range_eq_bot.mpr
+  ext x
+  exact hp x
+
+/-- The `p`-torsion of a finitely generated `ℤ_[p]`-module is finite. -/
+theorem finite_p_torsion (p : ℕ) [Fact p.Prime]
+    (M : Type u) [AddCommGroup M] [Module ℤ_[p] M] [Module.Finite ℤ_[p] M] :
+    Finite (LinearMap.ker (LinearMap.lsmul ℤ_[p] M (p : ℤ_[p]))) := by
+  let T := LinearMap.ker (LinearMap.lsmul ℤ_[p] M (p : ℤ_[p]))
+  have : Module.Finite ℤ_[p] T := inferInstance
+  apply finite_of_finite_module_killed_by_p p T
+  intro x
+  apply Subtype.ext
+  exact x.property
+
+/-- A compact Hausdorff `ℤ_[p]`-module is finitely generated iff it is finite modulo `p`. -/
+theorem module_finite_iff_finite_mod_p (p : ℕ) [Fact p.Prime]
+    (M : Type u) [AddCommGroup M] [Module ℤ_[p] M]
+    [TopologicalSpace M] [IsTopologicalAddGroup M] [ContinuousSMul ℤ_[p] M]
+    [CompactSpace M] [T2Space M] :
+    Module.Finite ℤ_[p] M ↔
+      Finite (M ⧸ LinearMap.range (LinearMap.lsmul ℤ_[p] M (p : ℤ_[p]))) := by
+  constructor
+  · intro _
+    exact finite_mod_p_of_finite_module p M
+  · intro _
+    exact finite_of_finite_mod_p p M
+
+end KnLocalSphere.IntegralRecovery
+
+end OAI
diff --git a/lean/OAI/Algebra/OddKaplansky/AdmissibleCount.lean b/lean/OAI/Algebra/OddKaplansky/AdmissibleCount.lean
new file mode 100644
index 0000000000000000000000000000000000000000..6d7495465726ad6b4ec378226383c14504d84779
--- /dev/null
+++ b/lean/OAI/Algebra/OddKaplansky/AdmissibleCount.lean
@@ -0,0 +1,128 @@
+import OAI.Algebra.OddKaplansky.PolynomialGrid
+
+namespace OAI
+
+universe contextUniverse1 contextUniverse2
+
+universe portUniverse1 portUniverse2 portUniverse3
+
+section
+
+namespace OddKaplansky.WreathFourier
+noncomputable section
+open scoped Classical BigOperators
+variable {K : Type portUniverse1} {H : Type portUniverse2} {I : Type portUniverse3} [Field K] [Fintype K] [Group H] [sectionInstance22 : Fintype H] [Fintype I]
+variable (M : ℕ) [NeZero M] {ζ : K} (hζ : IsPrimitiveRoot ζ M)
+variable (hM : Fintype.card Kˣ = M)
+
+def weight (lmb : Base (H := H) M) (x : H) : Kˣ :=
+  (Fourier.cyclicCharacter M hζ (lmb x⁻¹))⁻¹
+
+lemma weight_bijective
+    {K : Type contextUniverse1}
+    {H : Type contextUniverse2}
+    [contextInstance2 : Field.{contextUniverse1} K]
+    [contextInstance3 : Fintype.{contextUniverse1} K]
+    [Group.{contextUniverse2} H]
+    [Fintype.{contextUniverse2} H]
+    (M : Nat)
+    [@NeZero.{0} Nat (@MulZeroClass.toZero.{0} Nat Nat.instMulZeroClass) M]
+    {ζ : K}
+    (hζ : @IsPrimitiveRoot.{contextUniverse1} K (@CommRing.toCommMonoid.{contextUniverse1} K (@Field.toCommRing.{contextUniverse1} K contextInstance2)) ζ M)
+    (hM : @Eq.{1} Nat
+  (@Fintype.card.{contextUniverse1}
+    (@Units.{contextUniverse1} K
+      (@Semiring.toMonoid.{contextUniverse1} K
+        (@CommSemiring.toSemiring.{contextUniverse1} K
+          (@Semifield.toCommSemiring.{contextUniverse1} K (@Field.toSemifield.{contextUniverse1} K contextInstance2)))))
+    (@instFintypeUnitsOfDecidableEq.{contextUniverse1} K
+      (@Semiring.toMonoid.{contextUniverse1} K
+        (@CommSemiring.toSemiring.{contextUniverse1} K
+          (@Semifield.toCommSemiring.{contextUniverse1} K (@Field.toSemifield.{contextUniverse1} K contextInstance2))))
+      contextInstance3 fun a b => Classical.propDecidable (@Eq.{contextUniverse1 + 1} K a b)))
+  M) : Function.Bijective (weight (H := H) M hζ) := by
+  have hχ : Function.Bijective (Fourier.cyclicCharacter M hζ) := by
+    apply (Fintype.bijective_iff_injective_and_card _).mpr
+    constructor
+    · exact Fourier.cyclicCharacter_injective M hζ
+    · simpa only [Fourier.C,Fintype.card_multiplicative,ZMod.card] using hM.symm
+  constructor
+  · intro lmb μ he
+    funext x
+    apply hχ.injective
+    have hh := congrFun he x⁻¹
+    simpa only [weight,inv_inv] using congrArg Inv.inv hh
+  · intro f
+    choose a ha using fun x => hχ.surjective ((f x⁻¹)⁻¹)
+    refine ⟨a,?_⟩
+    funext x
+    simp only [weight,ha,inv_inv]
+
+variable [DecidableEq H] [DecidableEq I]
+def Admissible (B : Matrix H I K) (lmb : Base (H := H) M) : Prop :=
+  FreeShiftCount.Free lmb ∧ (B.transpose * Matrix.diagonal (fun x => (weight M hζ lmb x : K)) * B).det ≠ 0
+
+include hM in
+lemma card_singular (B : Matrix H I K) (hB : LinearIndependent K B.col) :
+    Fintype.card {lmb : Base (H := H) M // (B.transpose * Matrix.diagonal (fun x => (weight M hζ lmb x : K)) * B).det = 0} * M ≤
+      Fintype.card I * M ^ Fintype.card H := by
+  let E := Equiv.ofBijective (weight (H := H) M hζ) (weight_bijective M hζ hM)
+  let E' : {lmb : Base (H := H) M // (B.transpose * Matrix.diagonal (fun x => (weight M hζ lmb x : K)) * B).det = 0} ≃
+      {f : H → Kˣ // MvPolynomial.eval (fun x => (f x : K)) (WeightedGram.polynomial B) = 0} :=
+    E.subtypeEquiv (fun lmb => by rw [WeightedGram.eval_polynomial]; rfl)
+  have hz := PolynomialGrid.card_units_zero_le_general (WeightedGram.polynomial B) (WeightedGram.nonzero B hB)
+  have he := Fintype.card_congr E'
+  simp only [Fintype.card_eq_nat_card] at he hz ⊢
+  have hM' := hM
+  simp only [Fintype.card_eq_nat_card] at hM'
+  rw [← he,hM'] at hz
+  have hd := WeightedGram.totalDegree B
+  simp only [Fintype.card_eq_nat_card] at hd
+  exact hz.trans (Nat.mul_le_mul_right _ hd)
+
+include hM in
+lemma cardinality (B : Matrix H I K) (hB : LinearIndependent K B.col)
+    (hI : 4*Fintype.card I < M) (hH : 4*(Fintype.card H-1) < M) :
+    Fintype.card (Base (H := H) M) < 2 * Fintype.card {lmb : Base (H := H) M // Admissible M hζ B lmb} := by
+  let A := Base (H := H) M
+  have hc : Fintype.card (Fourier.C M) = M := by simp [Fourier.C]
+  have h0 : 0 < M ^ Fintype.card H := pow_pos (Nat.pos_of_ne_zero (NeZero.ne M)) _
+  have hn := FreeShiftCount.card_not_free (H := H) (C := Fourier.C M)
+  rw [hc] at hn
+  have hs := card_singular M hζ hM B hB
+  have hu : Fintype.card {lmb : A // ¬ Admissible M hζ B lmb} ≤
+      Fintype.card {lmb : A // ¬ FreeShiftCount.Free lmb} +
+      Fintype.card {lmb : A // (B.transpose * Matrix.diagonal (fun x => (weight M hζ lmb x : K)) * B).det = 0} := by
+    let f : {lmb : A // ¬ Admissible M hζ B lmb} →
+        {lmb : A // ¬ FreeShiftCount.Free lmb} ⊕
+        {lmb : A // (B.transpose * Matrix.diagonal (fun x => (weight M hζ lmb x : K)) * B).det = 0} :=
+      fun lmb => if h : FreeShiftCount.Free lmb.val then Sum.inr ⟨lmb.val,by simpa only [Admissible,h,true_and,not_not] using lmb.property⟩
+      else Sum.inl ⟨lmb.val,h⟩
+    have hf : Function.Injective f := by
+      intro a b he
+      apply Subtype.ext
+      have h := congrArg (Sum.elim Subtype.val Subtype.val) he
+      simpa only [f,apply_dite,Sum.elim_inl,Sum.elim_inr,dite_eq_ite,ite_self] using h
+    simpa only [Fintype.card_sum] using Fintype.card_le_of_injective f hf
+  have hc' : Fintype.card {lmb : A // Admissible M hζ B lmb} +
+      Fintype.card {lmb : A // ¬ Admissible M hζ B lmb} = M ^ Fintype.card H := by
+    rw [Fintype.card_subtype_compl, Nat.add_sub_of_le (Fintype.card_subtype_le _)]
+    simp only [A,Base,Fintype.card_fun,hc]
+  have hsum : 2*(Fintype.card I+(Fintype.card H-1)) < M := by omega
+  have hmul := Nat.mul_lt_mul_of_pos_right hsum h0
+  have hub := Nat.mul_le_mul_right M hu
+  have hh : 2*Fintype.card {lmb : A // ¬ Admissible M hζ B lmb} < M ^ Fintype.card H := by
+    have hp : 0 < M := Nat.pos_of_ne_zero (NeZero.ne M)
+    simp only [A, Fintype.card_eq_nat_card] at hn hs hub hmul ⊢
+    nlinarith
+  change Fintype.card A < _
+  have hca : Fintype.card A = M ^ Fintype.card H := by simp only [A,Base,Fintype.card_fun,hc]
+  rw [hca]
+  simp only [A, Fintype.card_eq_nat_card] at hc' hh ⊢
+  omega
+end
+end OddKaplansky.WreathFourier
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/OddKaplansky/Amalgam.lean b/lean/OAI/Algebra/OddKaplansky/Amalgam.lean
new file mode 100644
index 0000000000000000000000000000000000000000..e47a1a7dcdf551641ad3842dca49eecedfec37ed
--- /dev/null
+++ b/lean/OAI/Algebra/OddKaplansky/Amalgam.lean
@@ -0,0 +1,244 @@
+import OAI.Algebra.OddKaplansky.Diagrams
+
+namespace OAI
+
+universe portUniverse1 portUniverse2 portUniverse3 portUniverse4 portUniverse5 portUniverse6
+
+section
+noncomputable section
+open scoped Classical
+open Monoid Function
+namespace OddKaplansky.MultipleHNN
+
+universe u v
+variable {H : Type u} [Group H] {I : Type v}
+variable (A B : I → Subgroup H) (φ : ∀ i, A i ≃* B i)
+
+def con : Con (Monoid.Coprod H (FreeGroup I)) := conGen fun x y =>
+  ∃ (i : I) (a : A i), x = Coprod.inr (FreeGroup.of i) * Coprod.inl (a : H) ∧
+    y = Coprod.inl (φ i a : H) * Coprod.inr (FreeGroup.of i)
+
+def Extension := (con A B φ).Quotient
+
+instance : Group (Extension A B φ) := by delta Extension; infer_instance
+
+def of : H →* Extension A B φ := (con A B φ).mk'.comp Coprod.inl
+
+def letter (i : I) : Extension A B φ := (con A B φ).mk' (Coprod.inr (FreeGroup.of i))
+
+lemma letter_mul_of (i : I) (a : A i) :
+    letter A B φ i * of A B φ a = of A B φ (φ i a) * letter A B φ i :=
+  (Con.eq _).mpr <| ConGen.Rel.of _ _ ⟨i, a, rfl, rfl⟩
+
+def lift {G : Type portUniverse1} [Group G] (f : H →* G) (t : I → G)
+    (ht : ∀ i (a : A i), t i * f a = f (φ i a) * t i) : Extension A B φ →* G :=
+  Con.lift _ (Coprod.lift f (FreeGroup.lift t)) (Con.conGen_le.mpr (by
+    rintro _ _ ⟨i, a, rfl, rfl⟩
+    simp [ht]))
+
+@[simp] lemma lift_of {G : Type portUniverse2} [Group G] (f : H →* G) (t : I → G)
+    (ht : ∀ i (a : A i), t i * f a = f (φ i a) * t i) (h : H) :
+    lift A B φ f t ht (of A B φ h) = f h := by
+  change Coprod.lift f (FreeGroup.lift t) (Coprod.inl h) = f h
+  simp
+
+@[simp] lemma lift_letter {G : Type portUniverse3} [Group G] (f : H →* G) (t : I → G)
+    (ht : ∀ i (a : A i), t i * f a = f (φ i a) * t i) (i : I) :
+    lift A B φ f t ht (letter A B φ i) = t i := by
+  change Coprod.lift f (FreeGroup.lift t) (Coprod.inr (FreeGroup.of i)) = t i
+  simp
+
+theorem finite_partial_realization (S : Finset I) :
+    ∃ (G : Type (max u v)) (_ : Group G) (f : H →* G),
+      Function.Injective f ∧ ∃ t : I → G,
+        ∀ i ∈ S, ∀ a : A i, t i * f a = f (φ i a) * t i := by
+  induction S using Finset.induction_on with
+  | empty =>
+    refine ⟨ULift.{v} H, inferInstance, (MulEquiv.ulift : ULift.{v} H ≃* H).symm.toMonoidHom,
+      (MulEquiv.ulift : ULift.{v} H ≃* H).symm.injective, fun _ => 1, ?_⟩
+    simp
+  | @insert i S hi ih =>
+    obtain ⟨G, hG, f, hf, t, ht⟩ := ih
+    let fA := (A i).equivMapOfInjective f hf
+    let fB := (B i).equivMapOfInjective f hf
+    let ψ : (A i).map f ≃* (B i).map f := fA.symm.trans ((φ i).trans fB)
+    let E := HNNExtension G ((A i).map f) ((B i).map f) ψ
+    let emb : G →* E := HNNExtension.of
+    let t' : I → E := fun j => if j = i then HNNExtension.t else emb (t j)
+    refine ⟨E, inferInstance, emb.comp f,
+      (HNNExtension.of_injective ψ).comp hf, t', ?_⟩
+    intro j hj a
+    rcases Finset.mem_insert.mp hj with rfl | hj
+    · have h := HNNExtension.t_mul_of (φ := ψ) (fA a)
+      simpa [t', fA, fB, ψ, emb] using h
+    · by_cases hji : j = i
+      · subst j
+        have h := HNNExtension.t_mul_of (φ := ψ) (fA a)
+        simpa [t', fA, fB, ψ, emb] using h
+      · simpa [t', hji, ← map_mul] using congrArg emb (ht j hj a)
+
+theorem of_injective [Fintype I] : Function.Injective (of A B φ) := by
+  obtain ⟨G, hG, f, hf, t, ht⟩ := finite_partial_realization A B φ Finset.univ
+  intro x y h
+  apply hf
+  have h' := congrArg (lift A B φ f t (fun i a => ht i (Finset.mem_univ i) a)) h
+  simpa using h'
+
+@[elab_as_elim]
+theorem induction_on {P : Extension A B φ → Prop} (x : Extension A B φ)
+    (hof : ∀ h, P (of A B φ h)) (ht : ∀ i, P (letter A B φ i))
+    (hmul : ∀ x y, P x → P y → P (x * y)) (hinv : ∀ x, P x → P x⁻¹) : P x := by
+  change ∀ left right : (con A B φ).Quotient, P left → P right → P (left * right) at hmul
+  change ∀ element : (con A B φ).Quotient, P element → P element⁻¹ at hinv
+  change ∀ element : H, P ((con A B φ).mk' (Coprod.inl element)) at hof
+  obtain ⟨w, rfl⟩ := (Con.mk'_surjective (c := con A B φ)) x
+  induction w using Coprod.induction_on with
+  | inl h => exact hof h
+  | inr w =>
+    induction w using FreeGroup.induction_on with
+    | one => simpa only [map_one] using hof 1
+    | of i => exact ht i
+    | inv_of i ih =>
+      change P ((con A B φ).mk' (Coprod.inr ((FreeGroup.of i)⁻¹)))
+      rw [map_inv, map_inv]
+      exact hinv _ ih
+    | mul a b ha hb => simpa only [map_mul] using hmul _ _ ha hb
+  | mul a b ha hb => simpa only [map_mul] using hmul _ _ ha hb
+
+theorem of_central (z : H) (hz : ∀ h : H, Commute h z)
+    (ha : ∀ i, z ∈ A i) (hφ : ∀ i, (φ i ⟨z, ha i⟩ : H) = z) :
+    ∀ x : Extension A B φ, Commute x (of A B φ z) := by
+  intro x
+  induction x using induction_on A B φ with
+  | hof h => exact (hz h).map (of A B φ)
+  | ht i =>
+    have h := letter_mul_of A B φ i ⟨z, ha i⟩
+    rw [hφ i] at h
+    exact h
+  | hmul x y hx hy => exact hx.mul_left hy
+  | hinv x hx => exact hx.inv_left
+
+instance [Finite I] [Group.FG H] : Group.FG (Extension A B φ) := by
+  obtain ⟨S, hS, hfin⟩ := Group.fg_iff.mp (inferInstance : Group.FG H)
+  let T : Set (Extension A B φ) := of A B φ '' S ∪ Set.range (letter A B φ)
+  apply Group.fg_iff.mpr
+  refine ⟨T, ?_, (hfin.image _).union (Set.finite_range _)⟩
+  apply top_unique
+  intro x hxTop
+  clear hxTop
+  induction x using induction_on A B φ with
+  | hof h =>
+    have hh : h ∈ Subgroup.closure S := hS ▸ Subgroup.mem_top h
+    induction hh using Subgroup.closure_induction with
+    | mem h hh => exact Subgroup.subset_closure (Or.inl ⟨h, hh, rfl⟩)
+    | one => simp
+    | mul h k _ _ hh hk => simpa using (Subgroup.closure T).mul_mem hh hk
+    | inv h _ hh => simpa using (Subgroup.closure T).inv_mem hh
+  | ht i => exact Subgroup.subset_closure (Or.inr ⟨i, rfl⟩)
+  | hmul x y hx hy => exact (Subgroup.closure T).mul_mem hx hy
+  | hinv x hx => exact (Subgroup.closure T).inv_mem hx
+
+end OddKaplansky.MultipleHNN
+
+namespace OddKaplansky.StarAmalgam
+open Monoid
+variable {I G : Type} [Group G] {D S : I → Type}
+variable [∀ i, Group (D i)] [∀ i, Group (S i)]
+variable (f : ∀ i, S i →* G) (g : ∀ i, S i →* D i)
+
+abbrev Free := Coprod G (CoprodI D)
+
+def con : Con (Free (G := G) (D := D)) := conGen fun x y =>
+  ∃ (i : I) (s : S i), x = Coprod.inl (f i s) ∧ y = Coprod.inr (CoprodI.of (g i s))
+
+def Amalgam := (con f g).Quotient
+instance : _root_.Group (Amalgam f g) := by delta Amalgam; infer_instance
+
+def ofBase : G →* Amalgam f g := (con f g).mk'.comp Coprod.inl
+
+def ofFactor (i : I) : D i →* Amalgam f g :=
+  (con f g).mk'.comp (Coprod.inr.comp CoprodI.of)
+
+lemma identify (i : I) (s : S i) : ofBase f g (f i s) = ofFactor f g i (g i s) :=
+  (Con.eq _).mpr <| ConGen.Rel.of _ _ ⟨i, s, rfl, rfl⟩
+
+def lift {E : Type portUniverse4} [_root_.Group E] (b : G →* E) (d : ∀ i, D i →* E)
+    (h : ∀ i s, b (f i s) = d i (g i s)) : Amalgam f g →* E :=
+  Con.lift _ (Coprod.lift b (CoprodI.lift d)) (Con.conGen_le.mpr (by
+    rintro _ _ ⟨i, s, rfl, rfl⟩
+    simp [h]))
+
+@[simp] lemma lift_base {E : Type portUniverse5} [_root_.Group E] (b : G →* E) (d : ∀ i, D i →* E)
+    (h : ∀ i s, b (f i s) = d i (g i s)) (x : G) :
+    lift f g b d h (ofBase f g x) = b x := by
+  change Coprod.lift b (CoprodI.lift d) (Coprod.inl x) = b x
+  simp
+
+@[simp] lemma lift_factor {E : Type portUniverse6} [_root_.Group E] (b : G →* E) (d : ∀ i, D i →* E)
+    (h : ∀ i s, b (f i s) = d i (g i s)) (i : I) (x : D i) :
+    lift f g b d h (ofFactor f g i x) = d i x := by
+  change Coprod.lift b (CoprodI.lift d) (Coprod.inr (CoprodI.of x)) = d i x
+  simp
+
+theorem faithful_realization [Fintype I]
+    (hf : ∀ i, Function.Injective (f i)) (hg : ∀ i, Function.Injective (g i)) :
+    ∃ (E : Type) (_ : _root_.Group E) (b : G →* E) (d : ∀ i, D i →* E),
+      Function.Injective b ∧ (∀ i, Function.Injective (d i)) ∧
+      ∀ i s, b (f i s) = d i (g i s) := by
+  let a : ∀ i, S i →* Free (G := G) (D := D) := fun i =>
+    Coprod.inr.comp (CoprodI.of.comp (g i))
+  let b₀ : ∀ i, S i →* Free (G := G) (D := D) := fun i => Coprod.inl.comp (f i)
+  have ha : ∀ i, Function.Injective (a i) := fun i =>
+    Coprod.inr_injective.comp ((CoprodI.of_injective i).comp (hg i))
+  have hb : ∀ i, Function.Injective (b₀ i) := fun i => Coprod.inl_injective.comp (hf i)
+  let ea : ∀ i, S i ≃* (a i).range := fun i =>
+    MulEquiv.ofBijective (a i).rangeRestrict
+      ⟨MonoidHom.rangeRestrict_injective_iff.mpr (ha i), (a i).rangeRestrict_surjective⟩
+  let eb : ∀ i, S i ≃* (b₀ i).range := fun i =>
+    MulEquiv.ofBijective (b₀ i).rangeRestrict
+      ⟨MonoidHom.rangeRestrict_injective_iff.mpr (hb i), (b₀ i).rangeRestrict_surjective⟩
+  let A := fun i => (a i).range
+  let B := fun i => (b₀ i).range
+  let φ : ∀ i, A i ≃* B i := fun i => (ea i).symm.trans (eb i)
+  let E := MultipleHNN.Extension A B φ
+  let emb : Free (G := G) (D := D) →* E := MultipleHNN.of A B φ
+  have hemb : Function.Injective emb := MultipleHNN.of_injective A B φ
+  let b : G →* E := emb.comp Coprod.inl
+  let d : ∀ i, D i →* E := fun i =>
+    (MulAut.conj (MultipleHNN.letter A B φ i)).toMonoidHom.comp
+      (emb.comp (Coprod.inr.comp CoprodI.of))
+  refine ⟨E, inferInstance, b, d, hemb.comp Coprod.inl_injective, ?_, ?_⟩
+  · intro i
+    exact (MulAut.conj _).injective.comp
+      (hemb.comp (Coprod.inr_injective.comp (CoprodI.of_injective i)))
+  · intro i s
+    have h := MultipleHNN.letter_mul_of A B φ i (ea i s)
+    have hφ : φ i (ea i s) = eb i s := by simp [φ]
+    rw [hφ] at h
+    change MultipleHNN.letter A B φ i * emb (a i s) =
+      emb (b₀ i s) * MultipleHNN.letter A B φ i at h
+    have hh := congrArg (fun x => x * (MultipleHNN.letter A B φ i)⁻¹) h
+    simpa [b, d, a, b₀, mul_assoc] using hh.symm
+
+variable [Fintype I]
+
+theorem ofBase_injective (hf : ∀ i, Function.Injective (f i))
+    (hg : ∀ i, Function.Injective (g i)) : Function.Injective (ofBase f g) := by
+  obtain ⟨E, hE, b, d, hb, hd, h⟩ := faithful_realization f g hf hg
+  intro x y hxy
+  apply hb
+  simpa using congrArg (lift f g b d h) hxy
+
+theorem ofFactor_injective (hf : ∀ i, Function.Injective (f i))
+    (hg : ∀ i, Function.Injective (g i)) (i : I) : Function.Injective (ofFactor f g i) := by
+  obtain ⟨E, hE, b, d, hb, hd, h⟩ := faithful_realization f g hf hg
+  intro x y hxy
+  apply hd i
+  simpa using congrArg (lift f g b d h) hxy
+
+end OddKaplansky.StarAmalgam
+
+end
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/OddKaplansky/AmalgamExtras.lean b/lean/OAI/Algebra/OddKaplansky/AmalgamExtras.lean
new file mode 100644
index 0000000000000000000000000000000000000000..ad87c3914cacd358077bad42e672be3f581b88ba
--- /dev/null
+++ b/lean/OAI/Algebra/OddKaplansky/AmalgamExtras.lean
@@ -0,0 +1,61 @@
+import OAI.Algebra.OddKaplansky.PrescribedInverse
+
+namespace OAI
+
+section
+namespace OddKaplansky.StarAmalgam
+noncomputable section
+open Monoid
+open scoped Classical
+variable {I G : Type} [Group G] {D S : I → Type}
+variable [∀ i, Group (D i)] [∀ i, Group (S i)]
+variable (f : ∀ i, S i →* G) (g : ∀ i, S i →* D i)
+@[elab_as_elim]
+theorem induction_on {P : Amalgam f g → Prop} (x : Amalgam f g)
+    (hb : ∀ h, P (ofBase f g h)) (hd : ∀ i h, P (ofFactor f g i h))
+    (hmul : ∀ x y, P x → P y → P (x*y)) : P x := by
+  change ∀ left right : (con f g).Quotient, P left → P right → P (left * right) at hmul
+  change ∀ element : G, P ((con f g).mk' (Coprod.inl element)) at hb
+  obtain ⟨w,rfl⟩ := (Con.mk'_surjective (c := con f g)) x
+  induction w using Coprod.induction_on with
+  | inl h => exact hb h
+  | inr w =>
+    induction w using CoprodI.induction_on with
+    | one => simpa only [map_one] using hb 1
+    | of i h => exact hd i h
+    | mul a b ha hb => simpa only [map_mul] using hmul _ _ ha hb
+  | mul a b ha hb => simpa only [map_mul] using hmul _ _ ha hb
+lemma base_central (z : G) (hz : ∀ h, Commute z h)
+    (a : ∀ i, S i) (ha : ∀ i, f i (a i)=z) (hc : ∀ i h, Commute (g i (a i)) h) :
+    ∀ x : Amalgam f g, Commute (ofBase f g z) x := by
+  intro x
+  induction x using induction_on f g with
+  | hb h => exact (hz h).map (ofBase f g)
+  | hd i h =>
+    rw [← ha i,identify]
+    exact (hc i h).map (ofFactor f g i)
+  | hmul x y hx hy => exact hx.mul_right hy
+instance [Finite I] [∀ i, Finite (D i)] [Group.FG G] : Group.FG (Amalgam f g) := by
+  obtain ⟨B,hB,hfin⟩ := Group.fg_iff.mp (inferInstance : Group.FG G)
+  let C : Set (Amalgam f g) := ofBase f g '' B ∪ Set.range (fun z : (i : I) × D i => ofFactor f g z.1 z.2)
+  apply Group.fg_iff.mpr
+  refine ⟨C,?_,(hfin.image _).union (Set.finite_range _)⟩
+  apply top_unique
+  intro x hxTop
+  clear hxTop
+  induction x using induction_on f g with
+  | hb h =>
+    have hh : h ∈ Subgroup.closure B := hB ▸ Subgroup.mem_top h
+    induction hh using Subgroup.closure_induction with
+    | mem h hh => exact Subgroup.subset_closure (Or.inl ⟨h,hh,rfl⟩)
+    | one => simp
+    | mul h k _ _ hh hk => simpa only [map_mul] using (Subgroup.closure C).mul_mem hh hk
+    | inv h _ hh => simpa only [map_inv] using (Subgroup.closure C).inv_mem hh
+  | hd i h => exact Subgroup.subset_closure (Or.inr ⟨⟨i,h⟩,rfl⟩)
+  | hmul x y hx hy => exact (Subgroup.closure C).mul_mem hx hy
+end
+end OddKaplansky.StarAmalgam
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/OddKaplansky/AugmentBound.lean b/lean/OAI/Algebra/OddKaplansky/AugmentBound.lean
new file mode 100644
index 0000000000000000000000000000000000000000..bc8509f49869f56ab276f700b63496314a59ac06
--- /dev/null
+++ b/lean/OAI/Algebra/OddKaplansky/AugmentBound.lean
@@ -0,0 +1,171 @@
+import OAI.Algebra.OddKaplansky.LocalAlgebra
+
+namespace OAI
+
+universe contextUniverse1 contextUniverse2 contextUniverse3
+
+universe portUniverse1 portUniverse2 portUniverse3 portUniverse4 portUniverse5 portUniverse6 portUniverse7 portUniverse8
+
+section
+namespace OddKaplansky.LocalAlgebra
+noncomputable section
+open scoped Classical BigOperators
+variable {K : Type portUniverse1} {T : Type portUniverse2} [Field K] [CommGroup T]
+variable (p : ℕ) [Fact p.Prime] [sectionInstance47 : CharP K p] (hT : ∀ t : T, t^p=1)
+def X (t : T) : (MonoidAlgebra K T) := MonoidAlgebra.single t 1-1
+include hT in
+lemma X_nil (t : T) : X (K := K) t^p=0 := by
+  rw [power_scalar p hT]
+  simp [X,augment_single,(Fact.out : p.Prime).ne_zero]
+@[instance_reducible]
+def exponentModule : Module (ZMod p) (Additive T) :=
+  AddCommGroup.zmodModule (fun t : Additive T => congrArg Additive.ofMul (hT t.toMul))
+variable [Module (ZMod p) (Additive T)]
+
+def differenceSubgroup (I : Ideal ((MonoidAlgebra K T))) : Subgroup T where
+  carrier := {t | X t∈I}
+  one_mem' := by simp [X,← MonoidAlgebra.one_def]
+  mul_mem' {a b} ha hb := by
+    have hh : X (K := K) (a*b)=X a*MonoidAlgebra.single b 1+X b := by
+      simp only [X,sub_mul,MonoidAlgebra.single_mul_single,one_mul]
+      abel
+    change X (a*b)∈I
+    rw [hh]
+    exact I.add_mem (I.mul_mem_right _ ha) hb
+  inv_mem' {a} ha := by
+    have hh : X (K := K) a⁻¹=(-MonoidAlgebra.single a⁻¹ 1)*X a := by
+      simp only [X,mul_sub,neg_mul,MonoidAlgebra.single_mul_single,inv_mul_cancel,mul_one,← MonoidAlgebra.one_def]
+      abel
+    change X a⁻¹∈I
+    rw [hh]
+    exact I.mul_mem_left _ ha
+
+variable {ι : Type portUniverse3} [Fintype ι]
+def generatorIdeal (b : Module.Basis ι (ZMod p) (Additive T)) : Ideal ((MonoidAlgebra K T)) :=
+  ∑ i, Ideal.span {X (K := K) (b i).toMul}
+lemma generator_mem
+    {K : Type contextUniverse1}
+    {T : Type contextUniverse2}
+    [contextInstance2 : Field.{contextUniverse1} K]
+    [contextInstance3 : CommGroup.{contextUniverse2} T]
+    (p : Nat)
+    [contextInstance5 : Fact (Nat.Prime p)]
+    [@CharP.{contextUniverse1} K
+  (@AddGroupWithOne.toAddMonoidWithOne.{contextUniverse1} K
+    (@Ring.toAddGroupWithOne.{contextUniverse1} K (@DivisionRing.toRing.{contextUniverse1} K (@Field.toDivisionRing.{contextUniverse1} K contextInstance2))))
+  p]
+    [@Module.{0, contextUniverse2} (ZMod p) (Additive.{contextUniverse2} T)
+  (@CommSemiring.toSemiring.{0} (ZMod p)
+    (@Semifield.toCommSemiring.{0} (ZMod p) (@Field.toSemifield.{0} (ZMod p) (@ZMod.instField p contextInstance5))))
+  (@Additive.addCommMonoid.{contextUniverse2} T (@CommGroup.toCommMonoid.{contextUniverse2} T contextInstance3))]
+    {ι : Type contextUniverse3}
+    [Fintype.{contextUniverse3} ι] (b : Module.Basis ι (ZMod p) (Additive T)) (i : ι) :
+    X (K := K) (b i).toMul ∈ generatorIdeal p b := by
+  have hh : Ideal.span {X (K := K) (b i).toMul} ≤ generatorIdeal p b :=
+by
+    change Ideal.span {X (K := K) (b i).toMul} ≤ ∑ j, Ideal.span {X (K := K) (b j).toMul}
+    exact Finset.single_le_sum (f := fun j => Ideal.span {X (K := K) (b j).toMul}) (fun _ _ => bot_le) (Finset.mem_univ i)
+  exact hh (Ideal.subset_span (by simp))
+lemma difference_mem (b : Module.Basis ι (ZMod p) (Additive T)) (t : T) :
+    X (K := K) t ∈ generatorIdeal p b := by
+  let S := differenceSubgroup (generatorIdeal (K := K) p b)
+  let V := AddSubgroup.toZModSubmodule p S.toAddSubgroup
+  have hv : V=⊤ := by
+    apply top_unique
+    rw [← b.span_eq]
+    apply Submodule.span_le.mpr
+    rintro x ⟨i,rfl⟩
+    exact generator_mem p b i
+  have ht : Additive.ofMul t∈V := by rw [hv]; exact Submodule.mem_top
+  exact ht
+lemma scalar_difference_mem (I : Ideal ((MonoidAlgebra K T))) (hI : ∀ t, X t∈I) (a : (MonoidAlgebra K T)) :
+    a-algebraMap K (MonoidAlgebra K T) (augment a)∈I := by
+  induction a using MonoidAlgebra.induction_on with
+  | of t => simpa only [X,MonoidAlgebra.of_apply,augment_single,map_one] using hI t
+  | add a b ha hb =>
+    rw [map_add,map_add]
+    have hh : a+b-(algebraMap K (MonoidAlgebra K T) (augment a)+algebraMap K (MonoidAlgebra K T) (augment b)) =
+        (a-algebraMap K (MonoidAlgebra K T) (augment a))+(b-algebraMap K (MonoidAlgebra K T) (augment b)) := by abel
+    rw [hh]
+    exact I.add_mem ha hb
+  | smul c a ha =>
+    have hh := I.mul_mem_left (algebraMap K (MonoidAlgebra K T) c) ha
+    simpa only [map_smul,Algebra.smul_def,map_mul,AlgHom.commutes,Algebra.algebraMap_self,RingHom.id_apply,mul_sub] using hh
+lemma ker_le_generator (b : Module.Basis ι (ZMod p) (Additive T)) :
+    RingHom.ker (augment (K := K) (T := T)).toRingHom ≤ generatorIdeal p b := by
+  intro a ha
+  have hh := scalar_difference_mem (generatorIdeal (K := K) p b) (difference_mem p b) a
+  change augment a=0 at ha
+  simpa only [ha,map_zero,sub_zero] using hh
+end
+end OddKaplansky.LocalAlgebra
+
+namespace OddKaplansky.NilpotentSum
+noncomputable section
+open scoped Classical BigOperators
+variable {R : Type portUniverse4} {ι : Type portUniverse5} [CommSemiring R]
+lemma bounded (p : ℕ) (hp : 0<p) (s : Finset ι) (f : ι → R) (hf : ∀ i∈s, f i^p=0) :
+    (∑ i∈s, f i)^(s.card*(p-1)+1)=0 := by
+  induction s using Finset.induction with
+  | empty => simp
+  | @insert a s ha ih =>
+    rw [Finset.sum_insert ha,Finset.card_insert_of_notMem ha]
+    apply (Commute.all _ _).add_pow_eq_zero_of_add_le_succ_of_pow_eq_zero (hf a (by simp)) (ih fun i hi => hf i (by simp [hi]))
+    rw [Nat.add_mul]
+    omega
+end
+end OddKaplansky.NilpotentSum
+
+namespace OddKaplansky.LocalAlgebra
+noncomputable section
+open scoped Classical BigOperators
+variable {K : Type portUniverse6} {T : Type portUniverse7} [Field K] [CommGroup T]
+variable (p : ℕ) [Fact p.Prime] [CharP K p] (hT : ∀ t : T, t^p=1)
+variable [Module (ZMod p) (Additive T)]
+variable {ι : Type portUniverse8} [Fintype ι]
+include hT in
+lemma generator_nil (b : Module.Basis ι (ZMod p) (Additive T)) :
+    generatorIdeal (K := K) p b ^(Fintype.card ι*(p-1)+1)=0 := by
+  apply NilpotentSum.bounded p (Fact.out : p.Prime).pos Finset.univ
+  intro i _
+  rw [Ideal.span_singleton_pow,X_nil p hT]
+  simp
+include hT in
+lemma kernel_nil_of_basis (b : Module.Basis ι (ZMod p) (Additive T)) :
+    RingHom.ker (augment (K := K) (T := T)).toRingHom ^(Fintype.card ι*(p-1)+1)=0 := by
+  apply le_antisymm
+  · apply le_trans (pow_le_pow_left' (ker_le_generator p b) _)
+    rw [generator_nil p hT b]
+  · exact bot_le
+variable [sectionInstance48 : Fintype T]
+lemma dimension_le_three
+    {T : Type contextUniverse1}
+    [contextInstance1 : CommGroup.{contextUniverse1} T]
+    (p : Nat)
+    [contextInstance3 : Fact (Nat.Prime p)]
+    [@Module.{0, contextUniverse1} (ZMod p) (Additive.{contextUniverse1} T)
+  (@CommSemiring.toSemiring.{0} (ZMod p)
+    (@Semifield.toCommSemiring.{0} (ZMod p) (@Field.toSemifield.{0} (ZMod p) (@ZMod.instField p contextInstance3))))
+  (@Additive.addCommMonoid.{contextUniverse1} T (@CommGroup.toCommMonoid.{contextUniverse1} T contextInstance1))]
+    [Fintype.{contextUniverse1} T] (j : T →* Multiplicative (Fin 3 → ZMod p)) (hj : Function.Injective j) :
+    Module.finrank (ZMod p) (Additive T)≤3 := by
+  let L : Additive T →ₗ[ZMod p] (Fin 3 → ZMod p) := j.toAdditiveLeft.toZModLinearMap p
+  have hl : Function.Injective L := by
+    intro x y h
+    exact hj h
+  simpa using LinearMap.finrank_le_finrank_of_injective hl
+omit [Module (ZMod p) (Additive T)] in
+include hT in
+lemma kernel_nil_three (j : T →* Multiplicative (Fin 3 → ZMod p)) (hj : Function.Injective j) :
+    RingHom.ker (augment (K := K) (T := T)).toRingHom ^(3*(p-1)+1)=0 := by
+  let : Module (ZMod p) (Additive T) := exponentModule p hT
+  let b := Module.finBasis (ZMod p) (Additive T)
+  have hh := kernel_nil_of_basis (K := K) p hT b
+  simp only [Fintype.card_fin] at hh
+  exact pow_eq_zero_of_le (Nat.add_le_add_right (Nat.mul_le_mul_right (p-1) (dimension_le_three p j hj)) 1) hh
+end
+end OddKaplansky.LocalAlgebra
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/OddKaplansky/AugmentInverse.lean b/lean/OAI/Algebra/OddKaplansky/AugmentInverse.lean
new file mode 100644
index 0000000000000000000000000000000000000000..ecc1c6372e407520e090bc6448c4e0f5185dc414
--- /dev/null
+++ b/lean/OAI/Algebra/OddKaplansky/AugmentInverse.lean
@@ -0,0 +1,73 @@
+import OAI.Algebra.OddKaplansky.FiniteInverse
+
+namespace OAI
+
+universe contextUniverse1 contextUniverse2 contextUniverse3
+
+universe portUniverse1 portUniverse2 portUniverse3
+
+section
+namespace OddKaplansky.LocalAlgebra
+noncomputable section
+open scoped Classical BigOperators Matrix
+variable {K : Type portUniverse1} {T : Type portUniverse2} {S : Type portUniverse3} [Field K] [CommGroup T] [sectionInstance49 : Fintype T] [sectionInstance50 : Fintype S] [sectionInstance51 : DecidableEq S]
+variable (p : ℕ) [Fact p.Prime] [CharP K p] (hT : ∀ t : T, t^p=1)
+variable (j : T →* Multiplicative (Fin 3 → ZMod p)) (hj : Function.Injective j)
+
+def scalarMatrix (Q : Matrix S S (MonoidAlgebra K T)) : Matrix S S (MonoidAlgebra K T) :=
+  (Q.map augment).map (algebraMap K (MonoidAlgebra K T))
+
+def scalarInverse (Q : Matrix S S (MonoidAlgebra K T)) : Matrix S S (MonoidAlgebra K T) :=
+  (Q.map augment)⁻¹.map (algebraMap K (MonoidAlgebra K T))
+lemma scalar_map
+    {K : Type contextUniverse1}
+    {T : Type contextUniverse2}
+    {S : Type contextUniverse3}
+    [Field.{contextUniverse1} K]
+    [CommGroup.{contextUniverse2} T]
+    [Fintype.{contextUniverse2} T]
+    [Fintype.{contextUniverse3} S]
+    [DecidableEq.{contextUniverse3 + 1} S] (A : Matrix S S K) :
+    (A.map (algebraMap K (MonoidAlgebra K T))).map augment=A := by
+  ext s t
+  exact (augment (K := K) (T := T)).commutes (A s t)
+lemma scalar_products
+    {K : Type contextUniverse1}
+    {T : Type contextUniverse2}
+    {S : Type contextUniverse3}
+    [Field.{contextUniverse1} K]
+    [CommGroup.{contextUniverse2} T]
+    [Fintype.{contextUniverse2} T]
+    [Fintype.{contextUniverse3} S]
+    [DecidableEq.{contextUniverse3 + 1} S] (Q : Matrix S S (MonoidAlgebra K T)) (hQ : (Q.map augment).det ≠ 0) :
+    scalarMatrix Q*scalarInverse Q=1 ∧ scalarInverse Q*scalarMatrix Q=1 := by
+  have hu : IsUnit (Q.map augment).det := isUnit_iff_ne_zero.mpr hQ
+  constructor
+  · rw [scalarMatrix,scalarInverse,← Matrix.map_mul,Matrix.mul_nonsing_inv _ hu,Matrix.map_one] <;> simp only [map_zero,map_one]
+  · rw [scalarMatrix,scalarInverse,← Matrix.map_mul,Matrix.nonsing_inv_mul _ hu,Matrix.map_one] <;> simp only [map_zero,map_one]
+lemma error_entry_mem (Q : Matrix S S (MonoidAlgebra K T)) :
+    ∀ s t, (scalarInverse Q*(Q-scalarMatrix Q)) s t∈RingHom.ker (augment (K := K) (T := T)).toRingHom := by
+  have hh : (scalarInverse Q*(Q-scalarMatrix Q)).map augment=0 := by
+    rw [Matrix.map_mul,Matrix.map_sub,scalarMatrix,scalar_map,sub_self,mul_zero] ; simp
+  intro s t
+  exact congrFun (congrFun hh s) t
+include hT hj in
+lemma error_nil (Q : Matrix S S (MonoidAlgebra K T)) :
+    (scalarInverse Q*(Q-scalarMatrix Q))^(3*(p-1)+1)=0 := by
+  funext s t
+  have hm := FiniteMatrixInverse.pow_entry_mem (RingHom.ker (augment (K := K) (T := T)).toRingHom)
+    (scalarInverse Q*(Q-scalarMatrix Q)) (error_entry_mem Q) (3*(p-1)+1) s t
+  rw [kernel_nil_three p hT j hj] at hm
+  exact hm
+include hT hj in
+
+lemma matrix_inverse_formula (Q : Matrix S S (MonoidAlgebra K T)) (hQ : (Q.map augment).det≠0) :
+    Q⁻¹=FiniteMatrixInverse.series (scalarInverse Q*(Q-scalarMatrix Q)) (3*(p-1)+1)*scalarInverse Q :=
+  FiniteMatrixInverse.inverse_formula Q (scalarMatrix Q) (scalarInverse Q)
+    (scalar_products Q hQ).1 (scalar_products Q hQ).2 _ (error_nil p hT j hj Q)
+end
+end OddKaplansky.LocalAlgebra
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/OddKaplansky/Augmentation.lean b/lean/OAI/Algebra/OddKaplansky/Augmentation.lean
new file mode 100644
index 0000000000000000000000000000000000000000..908f8270987183bbe94cd3201a16b28021845d93
--- /dev/null
+++ b/lean/OAI/Algebra/OddKaplansky/Augmentation.lean
@@ -0,0 +1,277 @@
+import OAI.Algebra.OddKaplansky.ModularGeneric
+
+namespace OAI
+
+universe contextUniverse1 contextUniverse2
+
+universe portUniverse1 portUniverse2 portUniverse3 portUniverse4 portUniverse5 portUniverse6
+
+section
+namespace OddKaplansky.Augmentation
+noncomputable section
+open scoped Classical BigOperators
+variable {K : Type portUniverse1} {E : Type portUniverse2} [Field K] [sectionInstance28 : Fintype E] [DecidableEq E]
+variable (p : ℕ) [sectionInstance30 : Fact p.Prime] [sectionInstance29 : CharP K p]
+abbrev C := Multiplicative (E → ZMod p)
+abbrev R := MonoidAlgebra K (C (E := E) p)
+
+def coordinate (i : E) : C (E := E) p := Multiplicative.ofAdd (Pi.single i 1)
+def delta (x : E → ZMod p) : R (K := K) (E := E) p := MonoidAlgebra.single (Multiplicative.ofAdd x) 1
+def X (i : E) : R (K := K) (E := E) p := delta p (Pi.single i 1) - 1
+
+lemma coordinate_pow
+    {E : Type contextUniverse1}
+    [Fintype.{contextUniverse1} E]
+    [DecidableEq.{contextUniverse1 + 1} E]
+    (p : Nat)
+    [Fact (Nat.Prime p)] (i : E) : coordinate p i ^ p = 1 := by
+  apply Multiplicative.toAdd.injective
+  ext j
+  simp [coordinate, Pi.single_apply, apply_ite]
+
+instance : CharP (R (K := K) (E := E) p) p :=
+  CharP.of_ringHom_of_ne_zero (algebraMap K _) p (Fact.out : p.Prime).ne_zero
+
+lemma X_pow (i : E) : X (K := K) p i ^ p = 0 := by
+  rw [X, sub_pow_char, one_pow]
+  have he : delta (K := K) p (Pi.single i (1 : ZMod p)) ^ p = 1 := by
+    change (MonoidAlgebra.of K (C (E := E) p) (coordinate p i)) ^ p = 1
+    rw [← map_pow, coordinate_pow, map_one]
+  rw [he, sub_self]
+
+lemma delta_product
+    {K : Type contextUniverse1}
+    {E : Type contextUniverse2}
+    [contextInstance2 : Field.{contextUniverse1} K]
+    [Fintype.{contextUniverse2} E]
+    [DecidableEq.{contextUniverse2 + 1} E]
+    (p : Nat)
+    [Fact (Nat.Prime p)]
+    [@CharP.{contextUniverse1} K
+  (@AddGroupWithOne.toAddMonoidWithOne.{contextUniverse1} K
+    (@Ring.toAddGroupWithOne.{contextUniverse1} K (@DivisionRing.toRing.{contextUniverse1} K (@Field.toDivisionRing.{contextUniverse1} K contextInstance2))))
+  p] (x : E → ZMod p) :
+    delta (K := K) p x = ∏ i, (1 + X p i) ^ (x i).val := by
+  have he : Multiplicative.ofAdd x = ∏ i, coordinate p i ^ (x i).val := by
+    apply Multiplicative.toAdd.injective
+    ext j
+    simp only [toAdd_prod, toAdd_pow, coordinate, toAdd_ofAdd,
+      Finset.sum_apply, nsmul_eq_mul, Pi.mul_apply, Pi.natCast_apply, Pi.single_apply,
+      mul_ite, mul_one, mul_zero]
+    simp only [Finset.sum_ite_eq, Finset.mem_univ, ite_true, ZMod.natCast_zmod_val]
+  calc
+    delta p x = MonoidAlgebra.of K _ (∏ i, coordinate p i ^ (x i).val) := congrArg _ he
+    _ = ∏ i, (MonoidAlgebra.of K _ (coordinate p i)) ^ (x i).val := by simp only [map_prod, map_pow]
+    _ = _ := by apply Finset.prod_congr rfl; intro i _; congr 1; simp [X, delta, coordinate]
+
+open MvPolynomial in
+def shiftPolynomial (x : E → ZMod p) : MvPolynomial E K := ∏ i : E, (1 + MvPolynomial.X i) ^ (x i).val
+
+def eval : MvPolynomial E K →ₐ[K] R (K := K) (E := E) p := MvPolynomial.aeval (X p)
+
+lemma eval_shiftPolynomial (x : E → ZMod p) : eval p (shiftPolynomial (K := K) p x) = delta p x := by
+  rw [shiftPolynomial, map_prod]
+  simp only [map_pow, map_add, map_one, eval, MvPolynomial.aeval_X]
+  exact (delta_product p x).symm
+
+lemma degreeOf_shiftPolynomial
+    {K : Type contextUniverse1}
+    {E : Type contextUniverse2}
+    [contextInstance2 : Field.{contextUniverse1} K]
+    [Fintype.{contextUniverse2} E]
+    [DecidableEq.{contextUniverse2 + 1} E]
+    (p : Nat)
+    [Fact (Nat.Prime p)]
+    [@CharP.{contextUniverse1} K
+  (@AddGroupWithOne.toAddMonoidWithOne.{contextUniverse1} K
+    (@Ring.toAddGroupWithOne.{contextUniverse1} K (@DivisionRing.toRing.{contextUniverse1} K (@Field.toDivisionRing.{contextUniverse1} K contextInstance2))))
+  p] (x : E → ZMod p) (i : E) :
+    (shiftPolynomial (K := K) p x).degreeOf i ≤ (x i).val := by
+  unfold shiftPolynomial
+  apply (MvPolynomial.degreeOf_prod_le _ _ _).trans
+  calc
+    _ ≤ ∑ j : E, (if i = j then 1 else 0) * (x j).val := by
+      apply Finset.sum_le_sum
+      intro j _
+      apply (MvPolynomial.degreeOf_pow_le _ _ _).trans
+      rw [Nat.mul_comm (x j).val]
+      apply Nat.mul_le_mul_right
+      apply (MvPolynomial.degreeOf_add_le _ _ _).trans
+      by_cases hij : i = j <;> simp [hij, MvPolynomial.degreeOf_X_of_ne]
+    _ = (x i).val := by simp
+
+def monomial (n : E → Fin p) : R (K := K) (E := E) p := ∏ i, X p i ^ (n i).val
+
+def monomialSpan : Submodule K (R (K := K) (E := E) p) := Submodule.span K (Set.range (monomial p))
+
+lemma eval_mem_span
+    {K : Type contextUniverse1}
+    {E : Type contextUniverse2}
+    [contextInstance2 : Field.{contextUniverse1} K]
+    [Fintype.{contextUniverse2} E]
+    [DecidableEq.{contextUniverse2 + 1} E]
+    (p : Nat)
+    [Fact (Nat.Prime p)]
+    [@CharP.{contextUniverse1} K
+  (@AddGroupWithOne.toAddMonoidWithOne.{contextUniverse1} K
+    (@Ring.toAddGroupWithOne.{contextUniverse1} K (@DivisionRing.toRing.{contextUniverse1} K (@Field.toDivisionRing.{contextUniverse1} K contextInstance2))))
+  p] (f : MvPolynomial E K) (hf : ∀ i, f.degreeOf i < p) :
+    eval p f ∈ monomialSpan (K := K) p := by
+  rw [f.as_sum, map_sum]
+  apply Submodule.sum_mem
+  intro d hd
+  have hb (i : E) : d i < p := (MvPolynomial.monomial_le_degreeOf i hd).trans_lt (hf i)
+  let n : E → Fin p := fun i => ⟨d i, hb i⟩
+  have he : eval p (MvPolynomial.monomial d (f.coeff d)) = f.coeff d • monomial p n := by
+    simp only [eval, MvPolynomial.aeval_monomial, monomial, n, Algebra.smul_def]
+    congr 1
+    exact Finsupp.prod_fintype _ _ (by simp)
+  rw [he]
+  exact Submodule.smul_mem _ _ (Submodule.subset_span ⟨n,rfl⟩)
+
+lemma span_eq_top : monomialSpan (K := K) (E := E) p = ⊤ := by
+  apply top_unique
+  intro z hz
+  clear hz
+  induction z using MonoidAlgebra.induction_on with
+  | of g =>
+    change delta p g.toAdd ∈ _
+    rw [← eval_shiftPolynomial]
+    apply eval_mem_span
+    intro i
+    exact (degreeOf_shiftPolynomial p g.toAdd i).trans_lt (ZMod.val_lt _)
+  | add x y hx hy => exact Submodule.add_mem _ hx hy
+  | smul c x hx => exact Submodule.smul_mem _ c hx
+
+end
+end OddKaplansky.Augmentation
+
+namespace OddKaplansky.Augmentation
+noncomputable section
+open scoped Classical BigOperators
+variable {K : Type portUniverse3} {E : Type portUniverse4} [Field K] [Fintype E] [DecidableEq E]
+variable (p : ℕ) [Fact p.Prime] [CharP K p]
+
+lemma monomial_independent : LinearIndependent K (monomial (K := K) (E := E) p) := by
+  apply linearIndependent_of_top_le_span_of_card_eq_finrank
+  · exact (span_eq_top p).ge
+  · rw [Module.finrank_eq_card_basis (MonoidAlgebra.basis (C (E := E) p) K)]
+    simp [C]
+
+def gridBasis : Module.Basis (E → Fin p) K (R (K := K) (E := E) p) :=
+  Module.Basis.mk (monomial_independent p) (span_eq_top p).ge
+@[simp] lemma gridBasis_apply (n : E → Fin p) : gridBasis (K := K) p n = monomial p n :=
+  Module.Basis.mk_apply _ _ _
+
+lemma eval_zero_of_high_degree (f : MvPolynomial E K)
+    (hf : ∀ d ∈ f.support, Fintype.card E * (p-1) < Finsupp.degree d) :
+    eval p f = 0 := by
+  rw [f.as_sum, map_sum]
+  apply Finset.sum_eq_zero
+  intro d hd
+  have hi : ∃ i : E, p ≤ d i := by
+    by_contra! hn
+    have hle : Finsupp.degree d ≤ Fintype.card E * (p-1) := by
+      change d.sum (fun _ n => n) ≤ _
+      rw [Finsupp.sum_fintype _ _ (by simp)]
+      calc
+        _ ≤ ∑ _i : E, (p-1) := Finset.sum_le_sum (fun i _ => by have := hn i; omega)
+        _ = _ := by simp []
+    exact (hf d hd).not_ge hle
+  obtain ⟨i,hi⟩ := hi
+  rw [eval, MvPolynomial.aeval_monomial]
+  have hz : d.prod (fun i k => X (K := K) p i ^ k) = 0 := by
+    rw [Finsupp.prod_fintype _ _ (by simp)]
+    apply Finset.prod_eq_zero (Finset.mem_univ i)
+    exact pow_eq_zero_of_le hi (X_pow p i)
+  rw [hz, mul_zero]
+
+lemma eval_ideal_power (n : ℕ) (hn : Fintype.card E * (p-1) < n)
+    (f : MvPolynomial E K) (hf : f ∈ MvPolynomial.idealOfVars E K ^ n) : eval p f = 0 := by
+  apply eval_zero_of_high_degree
+  intro d hd
+  exact hn.trans_le ((MvPolynomial.mem_pow_idealOfVars_iff n f).mp hf d hd)
+
+end
+end OddKaplansky.Augmentation
+
+namespace OddKaplansky.Augmentation
+noncomputable section
+open scoped Classical BigOperators
+variable {K : Type portUniverse5} {E : Type portUniverse6} [Field K] [Fintype E] [sectionInstance31 : DecidableEq E]
+variable (p : ℕ) [sectionInstance32 : Fact p.Prime] [sectionInstance33 : CharP K p]
+
+def exponents (n : E → Fin p) : E →₀ ℕ := Finsupp.equivFunOnFinite.symm (fun i => (n i).val)
+@[simp] lemma exponents_apply
+    {E : Type contextUniverse1}
+    [Fintype.{contextUniverse1} E]
+    [DecidableEq.{contextUniverse1 + 1} E]
+    (p : Nat)
+    [Fact (Nat.Prime p)] (n : E → Fin p) (i : E) : exponents p n i = (n i).val := rfl
+lemma degree_exponents
+    {E : Type contextUniverse1}
+    [Fintype.{contextUniverse1} E]
+    [DecidableEq.{contextUniverse1 + 1} E]
+    (p : Nat)
+    [Fact (Nat.Prime p)] (n : E → Fin p) : Finsupp.degree (exponents p n) = ∑ i, (n i).val := by
+  change (exponents p n).sum (fun _ a => a) = _
+  rw [Finsupp.sum_fintype _ _ (by simp)]
+  rfl
+lemma eval_monomial
+    {K : Type contextUniverse1}
+    {E : Type contextUniverse2}
+    [contextInstance2 : Field.{contextUniverse1} K]
+    [Fintype.{contextUniverse2} E]
+    [DecidableEq.{contextUniverse2 + 1} E]
+    (p : Nat)
+    [Fact (Nat.Prime p)]
+    [@CharP.{contextUniverse1} K
+  (@AddGroupWithOne.toAddMonoidWithOne.{contextUniverse1} K
+    (@Ring.toAddGroupWithOne.{contextUniverse1} K (@DivisionRing.toRing.{contextUniverse1} K (@Field.toDivisionRing.{contextUniverse1} K contextInstance2))))
+  p] (n : E → Fin p) :
+    eval (K := K) p (MvPolynomial.monomial (exponents p n) 1) = monomial p n := by
+  rw [eval, MvPolynomial.aeval_monomial, map_one, one_mul]
+  exact Finsupp.prod_fintype _ _ (by simp)
+
+lemma shiftPolynomial_sub_one_mem
+    {K : Type contextUniverse1}
+    {E : Type contextUniverse2}
+    [contextInstance2 : Field.{contextUniverse1} K]
+    [Fintype.{contextUniverse2} E]
+    [DecidableEq.{contextUniverse2 + 1} E]
+    (p : Nat)
+    [Fact (Nat.Prime p)]
+    [@CharP.{contextUniverse1} K
+  (@AddGroupWithOne.toAddMonoidWithOne.{contextUniverse1} K
+    (@Ring.toAddGroupWithOne.{contextUniverse1} K (@DivisionRing.toRing.{contextUniverse1} K (@Field.toDivisionRing.{contextUniverse1} K contextInstance2))))
+  p] (x : E → ZMod p) :
+    shiftPolynomial (K := K) p x - 1 ∈ MvPolynomial.idealOfVars E K := by
+  let I := MvPolynomial.idealOfVars E K
+  apply (Ideal.Quotient.eq_zero_iff_mem).mp
+  change Ideal.Quotient.mk I (_ - 1) = 0
+  rw [map_sub, map_one, shiftPolynomial, map_prod]
+  have hx (i : E) : Ideal.Quotient.mk I (MvPolynomial.X i) = 0 :=
+    Ideal.Quotient.eq_zero_iff_mem.mpr (Ideal.subset_span ⟨i,rfl⟩)
+  simp [map_pow, map_add, hx]
+
+lemma annihilates_monomial (x : E → ZMod p) (n : E → Fin p) (ell : ℕ)
+    (hn : Fintype.card E * (p-1) < ell + ∑ i, (n i).val) :
+    (delta (K := K) p x - 1)^ell * monomial p n = 0 := by
+  have hpow := Ideal.pow_mem_pow (shiftPolynomial_sub_one_mem (K := K) p x) ell
+  have hmon : MvPolynomial.monomial (exponents p n) (1 : K) ∈
+      MvPolynomial.idealOfVars E K ^ (∑ i, (n i).val) := by
+    apply (MvPolynomial.monomial_mem_pow_idealOfVars_iff _ _ one_ne_zero).mpr
+    rw [degree_exponents]
+  have hmul : (shiftPolynomial (K := K) p x - 1)^ell * MvPolynomial.monomial (exponents p n) 1 ∈
+      MvPolynomial.idealOfVars E K ^ (ell + ∑ i, (n i).val) := by
+    rw [pow_add]
+    exact Ideal.mul_mem_mul hpow hmon
+  have he := eval_ideal_power p _ hn _ hmul
+  simpa only [map_mul, map_pow, map_sub, map_one, eval_shiftPolynomial, eval_monomial] using he
+
+end
+end OddKaplansky.Augmentation
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/OddKaplansky/AugmentationMatrices.lean b/lean/OAI/Algebra/OddKaplansky/AugmentationMatrices.lean
new file mode 100644
index 0000000000000000000000000000000000000000..02736c59580cb53e9d0cecef958760fb81a5b508
--- /dev/null
+++ b/lean/OAI/Algebra/OddKaplansky/AugmentationMatrices.lean
@@ -0,0 +1,110 @@
+import OAI.Algebra.OddKaplansky.Augmentation
+
+namespace OAI
+
+universe contextUniverse1 contextUniverse2
+
+universe portUniverse1 portUniverse2
+
+section
+
+namespace OddKaplansky.Augmentation
+noncomputable section
+open scoped Classical BigOperators Matrix
+variable {K : Type portUniverse1} {E : Type portUniverse2} [Field K] [sectionInstance34 : Fintype E] [sectionInstance35 : DecidableEq E]
+variable (p : ℕ) [sectionInstance36 : Fact p.Prime] [sectionInstance37 : CharP K p]
+
+abbrev High (ell : ℕ) := {n : E → Fin p // Fintype.card E * (p-1) < ell + ∑ i, (n i).val}
+
+def columns (ell : ℕ) : Matrix (C (E := E) p) (High (E := E) p ell) K :=
+  fun x n => (monomial p n.val).coeff x
+
+def regular : R (K := K) (E := E) p →ₐ[K] Matrix (C (E := E) p) (C (E := E) p) K :=
+  Algebra.leftMulMatrix (MonoidAlgebra.basis _ K)
+
+lemma basis_repr
+    {K : Type contextUniverse1}
+    {E : Type contextUniverse2}
+    [contextInstance2 : Field.{contextUniverse1} K]
+    [Fintype.{contextUniverse2} E]
+    [DecidableEq.{contextUniverse2 + 1} E]
+    (p : Nat)
+    [Fact (Nat.Prime p)]
+    [@CharP.{contextUniverse1} K
+  (@AddGroupWithOne.toAddMonoidWithOne.{contextUniverse1} K
+    (@Ring.toAddGroupWithOne.{contextUniverse1} K (@DivisionRing.toRing.{contextUniverse1} K (@Field.toDivisionRing.{contextUniverse1} K contextInstance2))))
+  p] (z : R (K := K) (E := E) p) :
+    (MonoidAlgebra.basis (C (E := E) p) K).repr z = z.coeff := rfl
+
+lemma regular_delta
+    {K : Type contextUniverse1}
+    {E : Type contextUniverse2}
+    [contextInstance2 : Field.{contextUniverse1} K]
+    [Fintype.{contextUniverse2} E]
+    [DecidableEq.{contextUniverse2 + 1} E]
+    (p : Nat)
+    [Fact (Nat.Prime p)]
+    [@CharP.{contextUniverse1} K
+  (@AddGroupWithOne.toAddMonoidWithOne.{contextUniverse1} K
+    (@Ring.toAddGroupWithOne.{contextUniverse1} K (@DivisionRing.toRing.{contextUniverse1} K (@Field.toDivisionRing.{contextUniverse1} K contextInstance2))))
+  p] (s : E → ZMod p) (x y : C (E := E) p) :
+    regular (K := K) p (delta p s) x y = if x.toAdd = s + y.toAdd then 1 else 0 := by
+  rw [regular, Algebra.leftMulMatrix_eq_repr_mul]
+  simp only [MonoidAlgebra.basis_apply, delta, MonoidAlgebra.single_mul_single, one_mul,
+    basis_repr, MonoidAlgebra.coeff_single]
+  simp only [Finsupp.single_apply, eq_comm]
+  rfl
+
+lemma regular_mul_vec
+    {K : Type contextUniverse1}
+    {E : Type contextUniverse2}
+    [contextInstance2 : Field.{contextUniverse1} K]
+    [Fintype.{contextUniverse2} E]
+    [DecidableEq.{contextUniverse2 + 1} E]
+    (p : Nat)
+    [Fact (Nat.Prime p)]
+    [@CharP.{contextUniverse1} K
+  (@AddGroupWithOne.toAddMonoidWithOne.{contextUniverse1} K
+    (@Ring.toAddGroupWithOne.{contextUniverse1} K (@DivisionRing.toRing.{contextUniverse1} K (@Field.toDivisionRing.{contextUniverse1} K contextInstance2))))
+  p] (z t : R (K := K) (E := E) p) :
+    regular p z *ᵥ (fun x => t.coeff x) = fun x => (z*t).coeff x := by
+  have h := Algebra.leftMulMatrix_mulVec_repr (MonoidAlgebra.basis (C (E := E) p) K) z t
+  simpa only [regular, basis_repr] using h
+
+lemma columns_independent (ell : ℕ) : LinearIndependent K (columns (K := K) (E := E) p ell).col := by
+  let L : R (K := K) (E := E) p ≃ₗ[K] (C (E := E) p → K) :=
+    (MonoidAlgebra.coeffLinearEquiv K).trans (Finsupp.linearEquivFunOnFinite K K (C p))
+  have h := ((monomial_independent (K := K) (E := E) p).comp (fun n : High (E := E) p ell => n.val) Subtype.val_injective).map' L.toLinearMap L.ker
+  exact h
+
+lemma columns_annihilated (ell : ℕ) (s : E → ZMod p) :
+    (regular (K := K) p (delta p s) - 1)^ell * columns (K := K) (E := E) p ell = 0 := by
+  have he : (regular (K := K) p (delta p s) - 1)^ell = regular p ((delta p s - 1)^ell) := by simp
+  rw [he]
+  ext x n
+  change (regular p ((delta p s - 1)^ell) *ᵥ (fun x => (monomial p n.val).coeff x)) x = 0
+  rw [regular_mul_vec, annihilates_monomial p s n.val ell n.property]
+  rfl
+
+lemma regular_delta_transpose (s : E → ZMod p) :
+    (regular (K := K) p (delta p s)).transpose = regular p (delta p (-s)) := by
+  ext x y
+  simp only [Matrix.transpose_apply,regular_delta]
+  congr 1
+  apply propext
+  constructor
+  · intro h; rw [h]; simp
+  · intro h; rw [h]; simp
+
+lemma columns_transpose_annihilated (ell : ℕ) (s : E → ZMod p) :
+    (columns (K := K) (E := E) p ell).transpose * (regular (K := K) (E := E) p (delta p s)-(1 : Matrix (C p) (C p) K))^ell = 0 := by
+  have h := congrArg Matrix.transpose (columns_annihilated (K := K) (E := E) p ell (-s))
+  simpa only [Matrix.transpose_mul, Matrix.transpose_pow, Matrix.transpose_sub,
+    Matrix.transpose_one, regular_delta_transpose, neg_neg, Matrix.transpose_zero] using h
+
+end
+end OddKaplansky.Augmentation
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/OddKaplansky/BooleanPolynomial.lean b/lean/OAI/Algebra/OddKaplansky/BooleanPolynomial.lean
new file mode 100644
index 0000000000000000000000000000000000000000..dfffe94b2fd3800c7706da1ddbfa3c4e4ca42cae
--- /dev/null
+++ b/lean/OAI/Algebra/OddKaplansky/BooleanPolynomial.lean
@@ -0,0 +1,146 @@
+import OAI.Algebra.OddKaplansky.SourceGluing
+
+namespace OAI
+
+universe contextUniverse1 contextUniverse2
+
+universe portUniverse1 portUniverse2 portUniverse3 portUniverse4
+
+section
+namespace OddKaplansky.BooleanPolynomial
+noncomputable section
+open scoped Classical BigOperators
+open MvPolynomial
+variable {σ : Type portUniverse1} {K : Type portUniverse2} [sectionInstance4 : Fintype σ] [sectionInstance5 : DecidableEq σ] [CommRing K]
+
+def value (S : Finset σ) (i : σ) : K := if i ∈ S then 1 else 0
+
+def coefficient (f : MvPolynomial σ K) (T : Finset σ) : K :=
+  ∑ d ∈ f.support, if d.support = T then f.coeff d else 0
+
+lemma support_card_le
+    {σ : Type contextUniverse1}
+    {K : Type contextUniverse2}
+    [Fintype.{contextUniverse1} σ]
+    [DecidableEq.{contextUniverse1 + 1} σ]
+    [CommRing.{contextUniverse2} K] {f : MvPolynomial σ K} {d : σ →₀ ℕ} (hd : d ∈ f.support) :
+    d.support.card ≤ f.totalDegree := by
+  apply le_trans _ (le_totalDegree hd)
+  change d.support.card ≤ ∑ i ∈ d.support, d i
+  calc
+    d.support.card = ∑ _i ∈ d.support, (1 : ℕ) := by simp
+    _ ≤ _ := Finset.sum_le_sum (fun i hi => Nat.one_le_iff_ne_zero.mpr (Finsupp.mem_support_iff.mp hi))
+
+lemma bool_power_product
+    {σ : Type contextUniverse1}
+    {K : Type contextUniverse2}
+    [Fintype.{contextUniverse1} σ]
+    [DecidableEq.{contextUniverse1 + 1} σ]
+    [CommRing.{contextUniverse2} K] (S : Finset σ) (d : σ →₀ ℕ) :
+    d.prod (fun i e => value (K := K) S i ^ e) = if d.support ⊆ S then 1 else 0 := by
+  change (∏ i ∈ d.support, value S i ^ d i) = _
+  by_cases hs : d.support ⊆ S
+  · rw [ite_eq_left hs]
+    exact Finset.prod_eq_one (fun i hi => by simp [value, hs hi])
+  · rw [ite_eq_right hs]
+    obtain ⟨i, hi, hni⟩ := Finset.not_subset.mp hs
+    apply Finset.prod_eq_zero hi
+    simp [value, hni, Finsupp.mem_support_iff.mp hi]
+
+lemma evaluate (f : MvPolynomial σ K) (S : Finset σ) (n : ℕ) [Fintype {T : Finset σ // T.card ≤ n}] (hf : f.totalDegree ≤ n) :
+    eval (value S) f = ∑ T : {T : Finset σ // T.card ≤ n},
+      (if T.val ⊆ S then (1 : K) else 0) * coefficient f T.val := by
+  rw [eval_eq]
+  change (∑ d ∈ f.support, f.coeff d * d.prod (fun i e => value S i ^ e)) = _
+  simp_rw [bool_power_product, coefficient, Finset.mul_sum]
+  rw [Finset.sum_comm]
+  apply Finset.sum_congr rfl
+  intro d hd
+  have hdc : d.support.card ≤ n := (support_card_le hd).trans hf
+  let T : {T : Finset σ // T.card ≤ n} := ⟨d.support, hdc⟩
+  rw [Finset.sum_eq_single T]
+  · simp [T, mul_comm]
+  · intro U _ hUT
+    have hne : d.support ≠ U.val := by
+      intro h
+      apply hUT
+      exact Subtype.ext h.symm
+    simp [hne]
+  · simp
+
+end
+end OddKaplansky.BooleanPolynomial
+
+namespace OddKaplansky.GraphPolynomial
+noncomputable section
+open scoped Classical BigOperators
+open MvPolynomial
+variable {σ : Type portUniverse3} {K : Type portUniverse4} [sectionInstance6 : Fintype σ] [sectionInstance7 : DecidableEq σ] [Field K]
+
+def factor (S : Finset σ) (r k : ℕ) : MvPolynomial σ K :=
+  C ((r - k : ℕ) : K)⁻¹ * ((∑ i ∈ S, X i) + C (-(k : K)))
+
+def polynomial (S : Finset σ) (r lo hi : ℕ) : MvPolynomial σ K :=
+  ∏ k ∈ Finset.Ico lo hi, factor S r k
+
+lemma degree_factor
+    {σ : Type contextUniverse1}
+    {K : Type contextUniverse2}
+    [Fintype.{contextUniverse1} σ]
+    [DecidableEq.{contextUniverse1 + 1} σ]
+    [Field.{contextUniverse2} K] (S : Finset σ) (r k : ℕ) : (factor (K := K) S r k).totalDegree ≤ 1 := by
+  apply (totalDegree_mul _ _).trans
+  rw [totalDegree_C, zero_add]
+  apply (totalDegree_add _ _).trans
+  apply max_le
+  · exact totalDegree_finsetSum_le (fun i _ => (totalDegree_X i).le)
+  · rw [totalDegree_C]
+    omega
+
+lemma degree_polynomial (S : Finset σ) (r lo hi : ℕ) :
+    (polynomial (K := K) S r lo hi).totalDegree ≤ hi - lo := by
+  apply (totalDegree_finsetProd _ _).trans
+  calc
+    _ ≤ ∑ _k ∈ Finset.Ico lo hi, (1 : ℕ) := Finset.sum_le_sum (fun k _ => degree_factor S r k)
+    _ = _ := by simp
+
+lemma eval_variables
+    {σ : Type contextUniverse1}
+    {K : Type contextUniverse2}
+    [Fintype.{contextUniverse1} σ]
+    [DecidableEq.{contextUniverse1 + 1} σ]
+    [Field.{contextUniverse2} K] (S T : Finset σ) :
+    eval (BooleanPolynomial.value (K := K) T) (∑ i ∈ S, X i) = ((S ∩ T).card : K) := by
+  simp only [eval_sum, eval_X, BooleanPolynomial.value]
+  rw [Finset.sum_boole]
+  congr 1
+
+lemma eval_polynomial (S T : Finset σ) (r lo hi : ℕ) :
+    eval (BooleanPolynomial.value (K := K) T) (polynomial S r lo hi) =
+      ∏ k ∈ Finset.Ico lo hi, (((S ∩ T).card : K) - (k : K)) / ((r-k : ℕ) : K) := by
+  simp only [polynomial, map_prod, factor, eval_mul, eval_add, eval_C, eval_variables,
+    sub_eq_add_neg, div_eq_mul_inv, mul_comm]
+
+lemma diagonal (S : Finset σ) (r lo hi : ℕ) (hS : S.card = r) (hhi : hi ≤ r)
+    (hden : ∀ k ∈ Finset.Ico lo hi, ((r-k : ℕ) : K) ≠ 0) :
+    eval (BooleanPolynomial.value (K := K) S) (polynomial S r lo hi) = 1 := by
+  rw [eval_polynomial]
+  apply Finset.prod_eq_one
+  intro k hk
+  have hk' : k ≤ r := Nat.le_of_lt ((Finset.mem_Ico.mp hk).2.trans_le hhi)
+  simp only [Finset.inter_self, hS, ← Nat.cast_sub hk']
+  exact div_self (hden k hk)
+
+lemma vanishes (S T : Finset σ) (r lo hi : ℕ)
+    (ha : lo ≤ (S ∩ T).card) (hb : (S ∩ T).card < hi) :
+    eval (BooleanPolynomial.value (K := K) T) (polynomial S r lo hi) = 0 := by
+  rw [eval_polynomial]
+  apply Finset.prod_eq_zero (Finset.mem_Ico.mpr ⟨ha,hb⟩)
+  simp
+
+end
+end OddKaplansky.GraphPolynomial
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/OddKaplansky/Cellular.lean b/lean/OAI/Algebra/OddKaplansky/Cellular.lean
new file mode 100644
index 0000000000000000000000000000000000000000..8a51137d04d773a5a417e97eb1e1ef219b635d44
--- /dev/null
+++ b/lean/OAI/Algebra/OddKaplansky/Cellular.lean
@@ -0,0 +1,87 @@
+import OAI.Algebra.OddKaplansky.Transfer
+
+namespace OAI
+
+universe portUniverse1 portUniverse2
+
+section
+namespace OddKaplansky.Cellular
+noncomputable section
+open scoped Classical BigOperators
+variable {K : Type portUniverse1} {G : Type portUniverse2} [Field K] [Group G]
+def rightShift (u : G) : Module.End K (G → K) where
+  toFun x g := x (g*u)
+  map_add' _ _ := rfl
+  map_smul' _ _ := rfl
+def shift : G →* Module.End K (G → K) where
+  toFun := rightShift
+  map_one' := by ext x g; simp [rightShift]
+  map_mul' u v := by ext x g; simp [rightShift,mul_assoc]
+def operator : MonoidAlgebra K G →ₐ[K] Module.End K (G → K) := MonoidAlgebra.lift K _ _ shift
+lemma operator_single (u : G) (c : K) (x : G → K) (g : G) : operator (MonoidAlgebra.single u c) x g=c*x (g*u) := by
+  rw [operator,MonoidAlgebra.lift_single]
+  rfl
+lemma operator_formula (a : MonoidAlgebra K G) (x : G → K) (g : G) : operator a x g=∑ u ∈ a.coeff.support, a.coeff u*x (g*u) := by
+  conv_lhs => rw [← MonoidAlgebra.sum_coeff_single a]
+  simp only [Finsupp.sum,map_sum,LinearMap.sum_apply,Finset.sum_apply,operator_single]
+lemma operator_mul (a b : MonoidAlgebra K G) (x : G → K) : operator (a*b) x=operator a (operator b x) := by rw [map_mul]; rfl
+lemma operator_one (x : G → K) : operator (1 : MonoidAlgebra K G) x=x := by rw [map_one]; rfl
+lemma indicator_eval (a : MonoidAlgebra K G) (h : G) : operator a (Pi.single h 1) 1=a.coeff h := by
+  rw [operator_formula]
+  simp only [one_mul,Pi.single_apply,mul_ite,mul_one,mul_zero]
+  rw [Finset.sum_ite_eq']
+  split_ifs with hh
+  · rfl
+  · exact (Finsupp.notMem_support_iff.mp hh).symm
+lemma operator_injective : Function.Injective (operator (K := K) (G := G)) := by
+  intro a b he
+  ext h
+  simpa only [indicator_eval] using congrArg (fun T : Module.End K (G → K) => T (Pi.single h 1) 1) he
+
+def IsCellular (F : (G → K) → (G → K)) : Prop :=
+  ∃ S : Finset G, ∃ rule : (S → K) → K, ∀ x g, F x g=rule (fun u => x (g*u))
+lemma operator_cellular (a : MonoidAlgebra K G) : IsCellular (operator a) := by
+  refine ⟨a.coeff.support,fun z => ∑ u : a.coeff.support, a.coeff u*z u,?_⟩
+  intro x g
+  rw [operator_formula]
+  exact (Finset.sum_attach a.coeff.support (fun u => a.coeff u*x (g*u))).symm
+lemma left_inverse (a b : MonoidAlgebra K G) (hab : a*b=1) : Function.LeftInverse (operator a) (operator b) := by
+  intro x
+  rw [← operator_mul,hab,operator_one]
+lemma range_eq (a b : MonoidAlgebra K G) (hab : a*b=1) : Set.range (operator b)={y | operator (b*a) y=y} := by
+  ext y
+  constructor
+  · rintro ⟨x,rfl⟩
+    change operator (b*a) (operator b x)=operator b x
+    rw [operator_mul,left_inverse a b hab x]
+  · intro hy
+    exact ⟨operator a y,by rw [← operator_mul]; exact hy⟩
+lemma missing_indicator (a b : MonoidAlgebra K G) (hab : a*b=1) (h : G) (hh : (b*a-1).coeff h ≠ 0) :
+    Pi.single h 1 ∉ Set.range (operator b) := by
+  rw [range_eq a b hab]
+  intro he
+  have hv := congrFun he 1
+  rw [indicator_eval] at hv
+  apply hh
+  change (b*a).coeff h-(1 : MonoidAlgebra K G).coeff h=0
+  rw [← indicator_eval (1 : MonoidAlgebra K G),operator_one,hv,sub_self]
+lemma theorem_all_configurations (a b : MonoidAlgebra K G) (hab : a*b=1) (hba : b*a≠1) :
+    IsCellular (operator b) ∧ Function.Injective (operator b) ∧ ¬Function.Surjective (operator b) ∧
+    Set.range (operator b)={y | operator (b*a) y=y} ∧
+    ∃ h : G, (b*a-1).coeff h ≠ 0 ∧ Pi.single h 1 ∉ Set.range (operator b) := by
+  have hex : ∃ h : G, (b*a-1).coeff h≠0 := by
+    by_contra! hh
+    apply hba
+    apply sub_eq_zero.mp
+    ext h
+    exact hh h
+  obtain ⟨h,hh⟩ := hex
+  have hm := missing_indicator a b hab h hh
+  exact ⟨operator_cellular b,(left_inverse a b hab).injective,
+    fun hs => hm (hs (Pi.single h 1)),range_eq a b hab,h,hh,hm⟩
+end
+end OddKaplansky.Cellular
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/OddKaplansky/CoefficientOrder.lean b/lean/OAI/Algebra/OddKaplansky/CoefficientOrder.lean
new file mode 100644
index 0000000000000000000000000000000000000000..21d9b86cfac7397e28573479ef8c6d0a5697fdf3
--- /dev/null
+++ b/lean/OAI/Algebra/OddKaplansky/CoefficientOrder.lean
@@ -0,0 +1,40 @@
+import OAI.Algebra.OddKaplansky.FiniteChoice
+
+namespace OAI
+
+section
+namespace OddKaplansky.QuadraticTower
+noncomputable section
+open scoped Classical
+variable (p : ℕ) [Fact p.Prime] (hp : p≠2)
+def firstCoordinates : FirstField p hp ≃ₗ[ZMod p] (Fin 2 → ZMod p) :=
+  ((basis (eta p hp)).basis.reindex (finCongr (basis_dim (eta p hp)))).equivFun
+def secondCoordinates : CoeffField p hp ≃ₗ[FirstField p hp] (Fin 2 → FirstField p hp) :=
+  ((basis (xi p hp)).basis.reindex (finCongr (basis_dim (xi p hp)))).equivFun
+
+def coefficientTuple (z : CoeffField p hp) : Fin 4 → ZMod p :=
+  ![firstCoordinates p hp (secondCoordinates p hp z 0) 0,
+    firstCoordinates p hp (secondCoordinates p hp z 0) 1,
+    firstCoordinates p hp (secondCoordinates p hp z 1) 0,
+    firstCoordinates p hp (secondCoordinates p hp z 1) 1]
+lemma coefficientTuple_injective : Function.Injective (coefficientTuple p hp) := by
+  intro a b he
+  apply (secondCoordinates p hp).injective
+  funext i
+  apply (firstCoordinates p hp).injective
+  funext j
+  fin_cases i <;> fin_cases j
+  · exact congrFun he 0
+  · exact congrFun he 1
+  · exact congrFun he 2
+  · exact congrFun he 3
+@[instance_reducible]
+def fieldOrder : LinearOrder (CoeffField p hp) :=
+  @LinearOrder.lift' _ _ (@FiniteChoice.functionOrder (Fin 4) (ZMod p) inferInstance inferInstance (FiniteChoice.residueOrder p))
+    (coefficientTuple p hp) (coefficientTuple_injective p hp)
+end
+end OddKaplansky.QuadraticTower
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/OddKaplansky/Compression.lean b/lean/OAI/Algebra/OddKaplansky/Compression.lean
new file mode 100644
index 0000000000000000000000000000000000000000..2ebe75c45f6b1b83c6fa95ad69b644909809e38d
--- /dev/null
+++ b/lean/OAI/Algebra/OddKaplansky/Compression.lean
@@ -0,0 +1,250 @@
+import OAI.Algebra.OddKaplansky.OrderedZero
+
+namespace OAI
+
+universe contextUniverse1 contextUniverse2 contextUniverse3 contextUniverse4 contextUniverse5 contextUniverse6
+
+universe portUniverse1 portUniverse2 portUniverse3 portUniverse4 portUniverse5 portUniverse6 portUniverse7 portUniverse8 portUniverse9 portUniverse10 portUniverse11 portUniverse12
+
+section
+namespace OddKaplansky.Compression
+noncomputable section
+open scoped Classical BigOperators Matrix
+variable {K : Type portUniverse1} {R : Type portUniverse2} {I : Type portUniverse3} {T : Type portUniverse4} {W : Type portUniverse5} {N : Type portUniverse6} [Field K] [Ring R] [Algebra K R]
+variable [sectionInstance71 : Fintype I] [sectionInstance72 : Fintype T] [sectionInstance74 : Fintype W] [sectionInstance73 : Fintype N]
+lemma nilpotent_lower {S : Type portUniverse7} [Ring S] {n : ℕ} (ix : I → Fin n)
+    (A : Matrix I I S) (hA : ∀ i j, (ix i).val ≤ (ix j).val → A i j=0) : A^n=0 := by
+  have hp (k : ℕ) : ∀ i j, (ix i).val < (ix j).val+k → (A^k) i j=0 := by
+    induction k with
+    | zero =>
+      intro i j h
+      have hij : i≠j := by intro he; subst j; omega
+      simp [hij]
+    | succ k ih =>
+      intro i j h
+      rw [pow_succ',Matrix.mul_apply]
+      apply Finset.sum_eq_zero
+      intro a _
+      by_cases ha : (ix a).val < (ix j).val+k
+      · rw [ih a j ha,mul_zero]
+      · rw [hA i a (by omega),zero_mul]
+  funext i j
+  exact hp n i j (by have := (ix i).isLt; omega)
+
+def C₀ (P : I → R) (β : I → T → K) : Matrix T I R := fun t i => β i t • P i
+def D₀ (P : I → R) (α : I → T → K) : Matrix I T R := fun i t => α i t • P i
+lemma D₀C₀
+    {K : Type contextUniverse1}
+    {R : Type contextUniverse2}
+    {I : Type contextUniverse3}
+    {T : Type contextUniverse4}
+    [contextInstance4 : Field.{contextUniverse1} K]
+    [contextInstance5 : Ring.{contextUniverse2} R]
+    [@Algebra.{contextUniverse1, contextUniverse2} K R (@Semifield.toCommSemiring.{contextUniverse1} K (@Field.toSemifield.{contextUniverse1} K contextInstance4))
+  (@Ring.toSemiring.{contextUniverse2} R contextInstance5)]
+    [Fintype.{contextUniverse3} I]
+    [Fintype.{contextUniverse4} T] (P : I → R) (α β : I → T → K) (i j : I) :
+    (D₀ P α * C₀ P β) i j = (∑ t, α i t*β j t) • (P i*P j) := by
+  simp only [Matrix.mul_apply,D₀,C₀,smul_mul_assoc,mul_smul_comm,smul_smul,Finset.sum_smul,mul_comm]
+lemma diag_idempotent (P : I → R) (hP : ∀ i, P i*P i=P i) :
+    Matrix.diagonal P * Matrix.diagonal P = Matrix.diagonal P := by
+  rw [Matrix.diagonal_mul_diagonal]
+  congr 1
+  funext i
+  exact hP i
+lemma C₀_diag
+    {K : Type contextUniverse1}
+    {R : Type contextUniverse2}
+    {I : Type contextUniverse3}
+    {T : Type contextUniverse4}
+    [contextInstance4 : Field.{contextUniverse1} K]
+    [contextInstance5 : Ring.{contextUniverse2} R]
+    [@Algebra.{contextUniverse1, contextUniverse2} K R (@Semifield.toCommSemiring.{contextUniverse1} K (@Field.toSemifield.{contextUniverse1} K contextInstance4))
+  (@Ring.toSemiring.{contextUniverse2} R contextInstance5)]
+    [Fintype.{contextUniverse3} I]
+    [Fintype.{contextUniverse4} T] (P : I → R) (hP : ∀ i, P i*P i=P i) (β : I → T → K) :
+    C₀ P β * Matrix.diagonal P = C₀ P β := by
+  funext t i
+  simp only [Matrix.mul_diagonal,C₀,smul_mul_assoc,hP]
+lemma diag_D₀
+    {K : Type contextUniverse1}
+    {R : Type contextUniverse2}
+    {I : Type contextUniverse3}
+    {T : Type contextUniverse4}
+    [contextInstance4 : Field.{contextUniverse1} K]
+    [contextInstance5 : Ring.{contextUniverse2} R]
+    [@Algebra.{contextUniverse1, contextUniverse2} K R (@Semifield.toCommSemiring.{contextUniverse1} K (@Field.toSemifield.{contextUniverse1} K contextInstance4))
+  (@Ring.toSemiring.{contextUniverse2} R contextInstance5)]
+    [Fintype.{contextUniverse3} I]
+    [Fintype.{contextUniverse4} T] (P : I → R) (hP : ∀ i, P i*P i=P i) (α : I → T → K) :
+    Matrix.diagonal P * D₀ P α = D₀ P α := by
+  funext i t
+  simp only [Matrix.diagonal_mul,D₀,mul_smul_comm,hP]
+
+def error (P : I → R) (α β : I → T → K) : Matrix I I R := D₀ P α * C₀ P β - Matrix.diagonal P
+def correction (P : I → R) (α β : I → T → K) : Matrix I I R :=
+  (∑ k ∈ Finset.range (Fintype.card I), (-error P α β)^k) * Matrix.diagonal P
+def D₁ (P : I → R) (α β : I → T → K) : Matrix I T R := correction P α β * D₀ P α
+lemma corrected (P : I → R) (hP : ∀ i, P i*P i=P i) (α β : I → T → K)
+    (ix : I → Fin (Fintype.card I)) (hix : Function.Injective ix)
+    (hdiag : ∀ i, ∑ t, α i t*β i t=1)
+    (hupper : ∀ i j, (ix i).val < (ix j).val → (∑ t, α i t*β j t) • (P i*P j)=0) :
+    D₁ P α β * C₀ P β = Matrix.diagonal P := by
+  let E := error P α β
+  let Q := Matrix.diagonal P
+  have hQ : Q*Q=Q := diag_idempotent P hP
+  have hEQ : E*Q=E := by
+    dsimp [E,Q,error]
+    rw [sub_mul,Matrix.mul_assoc,C₀_diag P hP,diag_idempotent P hP]
+  have hQE : Q*E=E := by
+    dsimp [E,Q,error]
+    rw [mul_sub,← Matrix.mul_assoc,diag_D₀ P hP,diag_idempotent P hP]
+  have hnil : E^(Fintype.card I)=0 := by
+    apply nilpotent_lower ix E
+    intro i j hij
+    dsimp [E,error]
+    rw [D₀C₀]
+    by_cases he : i=j
+    · subst j
+      simp [hdiag,hP]
+    · rw [Matrix.diagonal_apply_ne _ he,sub_zero]
+      apply hupper i j
+      have hne : (ix i).val ≠ (ix j).val := fun h => he (hix (Fin.ext h))
+      omega
+  have hgeom : (∑ k ∈ Finset.range (Fintype.card I), (-E)^k) * (1+E)=1 := by
+    have hh := geom_sum_mul (-E) (Fintype.card I)
+    have hn : (-E)^(Fintype.card I)=0 := by rw [neg_pow,hnil,mul_zero]
+    rw [hn] at hh
+    have hm : -(1+E)= -E-1 := by noncomm_ring
+    rw [← hm,mul_neg] at hh
+    have := congrArg Neg.neg hh
+    simpa only [neg_neg,zero_sub,neg_neg] using this
+  unfold D₁ correction
+  change ((∑ k ∈ Finset.range (Fintype.card I), (-E)^k)*Q*D₀ P α)*C₀ P β=Q
+  rw [Matrix.mul_assoc,show D₀ P α*C₀ P β=Q+E by dsimp [E,Q,error]; abel]
+  have hh : Q*(Q+E)=(1+E)*Q := by rw [mul_add,hQ,hQE,add_mul,one_mul,hEQ]
+  rw [mul_assoc,hh,← mul_assoc,hgeom,one_mul]
+
+def rep {A : Type portUniverse8} {B : Type portUniverse9} (X : Matrix A B R) : Matrix (W×A) (W×B) R := fun a b => if a.1=b.1 then X a.2 b.2 else 0
+lemma rep_mul {A : Type portUniverse10} {B : Type portUniverse11} {C : Type portUniverse12} [Fintype B] (X : Matrix A B R) (Y : Matrix B C R) :
+    rep (W := W) (X*Y)=
+      (rep X : Matrix (W×A) (W×B) R) * (rep Y : Matrix (W×B) (W×C) R) := by
+  funext a c
+  simp only [rep,Matrix.mul_apply,Fintype.sum_prod_type]
+  by_cases he : a.1=c.1
+  · simp [he]
+  · simp [he]
+def blockJ (J : I → Matrix W N R) : Matrix (W×I) (I×N) R := fun a b => if a.2=b.1 then J a.2 a.1 b.2 else 0
+def blockY (Y : I → Matrix N W R) : Matrix (I×N) (W×I) R := fun a b => if a.1=b.2 then Y a.1 a.2 b.1 else 0
+lemma blockYJ
+    {R : Type contextUniverse1}
+    {I : Type contextUniverse2}
+    {W : Type contextUniverse3}
+    {N : Type contextUniverse4}
+    [Ring.{contextUniverse1} R]
+    [Fintype.{contextUniverse2} I]
+    [Fintype.{contextUniverse3} W]
+    [Fintype.{contextUniverse4} N] (f : R) (J : I → Matrix W N R) (Y : I → Matrix N W R)
+    (hYJ : ∀ i, Y i*J i=Matrix.diagonal (fun _ => f)) : blockY Y*blockJ J=Matrix.diagonal (fun _ => f) := by
+  funext a b
+  simp only [Matrix.mul_apply,blockY,blockJ,Fintype.sum_prod_type]
+  by_cases he : a.1=b.1
+  · simp only [← he,ite_mul,zero_mul,mul_ite,mul_zero,]
+    have hh := congrFun (congrFun (hYJ a.1) a.2) b.2
+    simpa [Matrix.mul_apply,Matrix.diagonal_apply,Prod.ext_iff,he] using hh
+  · simp [he,Prod.ext_iff]
+lemma blockJY
+    {R : Type contextUniverse1}
+    {I : Type contextUniverse2}
+    {W : Type contextUniverse3}
+    {N : Type contextUniverse4}
+    [Ring.{contextUniverse1} R]
+    [Fintype.{contextUniverse2} I]
+    [Fintype.{contextUniverse3} W]
+    [Fintype.{contextUniverse4} N] (P : I → R) (J : I → Matrix W N R) (Y : I → Matrix N W R)
+    (hJY : ∀ i, J i*Y i=Matrix.diagonal (fun _ => P i)) : blockJ J*blockY Y=rep (Matrix.diagonal P) := by
+  funext a b
+  simp only [Matrix.mul_apply,blockY,blockJ,Fintype.sum_prod_type,rep]
+  by_cases he : a.2=b.2
+  · simp only [← he,ite_mul,zero_mul,mul_ite,mul_zero,Finset.sum_ite_irrel,]
+    have hh := congrFun (congrFun (hJY a.2) a.1) b.1
+    simpa [Matrix.mul_apply,Matrix.diagonal_apply] using hh
+  · simp [he]
+def Csharp (P : I → R) (β : I → T → K) (J : I → Matrix W N R) : Matrix (W×T) (I×N) R :=
+  (rep (C₀ P β) : Matrix (W×T) (W×I) R) * (blockJ J : Matrix (W×I) (I×N) R)
+def Dsharp (P : I → R) (α β : I → T → K) (Y : I → Matrix N W R) : Matrix (I×N) (W×T) R :=
+  (blockY Y : Matrix (I×N) (W×I) R) * (rep (D₁ P α β) : Matrix (W×I) (W×T) R)
+lemma compressed (f : R) (hf : f*f=f)
+    (P : I → R) (hP : ∀ i, P i*P i=P i) (α β : I → T → K)
+    (ix : I → Fin (Fintype.card I)) (hix : Function.Injective ix)
+    (hdiag : ∀ i, ∑ t, α i t*β i t=1)
+    (hupper : ∀ i j, (ix i).val < (ix j).val → (∑ t, α i t*β j t) • (P i*P j)=0)
+    (J : I → Matrix W N R) (Y : I → Matrix N W R)
+    (hYJ : ∀ i, Y i*J i=Matrix.diagonal (fun _ => f))
+    (hJY : ∀ i, J i*Y i=Matrix.diagonal (fun _ => P i)) :
+    Dsharp P α β Y * Csharp P β J = Matrix.diagonal (fun _ => f) := by
+  unfold Dsharp Csharp
+  rw [Matrix.mul_assoc,← Matrix.mul_assoc (rep (D₁ P α β)),← rep_mul,corrected P hP α β ix hix hdiag hupper]
+  rw [← blockJY P J Y hJY]
+  calc
+    blockY Y * ((blockJ J*blockY Y)*blockJ J) = (blockY Y*blockJ J)*(blockY Y*blockJ J) := by simp only [Matrix.mul_assoc]
+    _ = _ := by
+      rw [blockYJ f J Y hYJ,Matrix.diagonal_mul_diagonal]
+      congr 1
+      funext i
+      exact hf
+
+lemma Csharp_sector
+    {K : Type contextUniverse1}
+    {R : Type contextUniverse2}
+    {I : Type contextUniverse3}
+    {T : Type contextUniverse4}
+    {W : Type contextUniverse5}
+    {N : Type contextUniverse6}
+    [contextInstance6 : Field.{contextUniverse1} K]
+    [contextInstance7 : Ring.{contextUniverse2} R]
+    [@Algebra.{contextUniverse1, contextUniverse2} K R (@Semifield.toCommSemiring.{contextUniverse1} K (@Field.toSemifield.{contextUniverse1} K contextInstance6))
+  (@Ring.toSemiring.{contextUniverse2} R contextInstance7)]
+    [Fintype.{contextUniverse3} I]
+    [Fintype.{contextUniverse4} T]
+    [Fintype.{contextUniverse5} W]
+    [Fintype.{contextUniverse6} N] (f : R) (P : I → R) (hP : ∀ i, f*P i=P i) (β : I → T → K) (J : I → Matrix W N R) :
+    ∀ a b, f*Csharp P β J a b=Csharp P β J a b := by
+  intro a b
+  simp only [Csharp,Matrix.mul_apply,Finset.mul_sum]
+  apply Finset.sum_congr rfl
+  intro c _
+  rw [← mul_assoc]
+  congr 1
+  simp only [rep,C₀]
+  split_ifs <;> simp [hP]
+lemma Dsharp_sector
+    {K : Type contextUniverse1}
+    {R : Type contextUniverse2}
+    {I : Type contextUniverse3}
+    {T : Type contextUniverse4}
+    {W : Type contextUniverse5}
+    {N : Type contextUniverse6}
+    [contextInstance6 : Field.{contextUniverse1} K]
+    [contextInstance7 : Ring.{contextUniverse2} R]
+    [@Algebra.{contextUniverse1, contextUniverse2} K R (@Semifield.toCommSemiring.{contextUniverse1} K (@Field.toSemifield.{contextUniverse1} K contextInstance6))
+  (@Ring.toSemiring.{contextUniverse2} R contextInstance7)]
+    [Fintype.{contextUniverse3} I]
+    [Fintype.{contextUniverse4} T]
+    [Fintype.{contextUniverse5} W]
+    [Fintype.{contextUniverse6} N] (f : R) (P : I → R) (α β : I → T → K) (Y : I → Matrix N W R)
+    (hY : ∀ i n w, f*Y i n w=Y i n w) : ∀ a b, f*Dsharp P α β Y a b=Dsharp P α β Y a b := by
+  intro a b
+  simp only [Dsharp,Matrix.mul_apply,Finset.mul_sum]
+  apply Finset.sum_congr rfl
+  intro c _
+  rw [← mul_assoc]
+  congr 1
+  simp only [blockY]
+  split_ifs <;> simp [hY]
+end
+end OddKaplansky.Compression
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/OddKaplansky/Construction.lean b/lean/OAI/Algebra/OddKaplansky/Construction.lean
new file mode 100644
index 0000000000000000000000000000000000000000..88be39b237a2e6b5a7298e9146e3bfc558303880
--- /dev/null
+++ b/lean/OAI/Algebra/OddKaplansky/Construction.lean
@@ -0,0 +1,136 @@
+import OAI.Algebra.OddKaplansky.IndexCut
+
+namespace OAI
+
+universe portUniverse1
+
+section
+namespace OddKaplansky.Construction
+noncomputable section
+local instance constructionDecidableEq (α : Type portUniverse1) : DecidableEq α := Classical.decEq α
+open scoped Classical BigOperators Matrix
+open SourceGluing SourceGraph
+local notation "M" => SourceGluing.modulus
+local notation "p" => SourceGluing.p
+local notation "HH" => SourceGluing.H
+local notation "G₀" => SourceGluing.G₀
+lemma prime_large : 1200<p := sourceM_large.trans_lt p_gt
+lemma p_ne_two : p≠2 := by have := prime_large; omega
+lemma p_odd : Odd p := by rw [SourceGluing.p_def]; exact sourcePrime_odd
+lemma minus_square : IsSquare (-1 : ZMod p) := by
+  have hd : p∣(Nat.factorial sourceM)^2+1 := by rw [SourceGluing.p_def]; exact sourcePrime_dvd
+  exact neg_one_isSquare_of_dvd p (Nat.factorial sourceM) hd
+lemma modulus_eq : M+1=p^4 := by
+  unfold SourceGluing.modulus
+  have hp : 1≤p^4 := Nat.one_le_pow 4 p (by have := prime_large; omega)
+  omega
+def ell := (p-1)/2
+lemma pell : p=2*ell+1 := by
+  obtain ⟨k,hk⟩ := p_odd
+  unfold ell
+  omega
+lemma ell_le : ell≤p-ell := by have := pell; omega
+
+variable {K : Type} [Field K] [sectionInstance78 : Fintype K] [sectionInstance79 : CharP K p]
+lemma modulus_cast
+    {K : Type}
+    [contextInstance1 : Field.{0} K]
+    [Fintype.{0} K]
+    [@CharP.{0} K
+  (@AddGroupWithOne.toAddMonoidWithOne.{0} K
+    (@Ring.toAddGroupWithOne.{0} K (@DivisionRing.toRing.{0} K (@Field.toDivisionRing.{0} K contextInstance1))))
+  OddKaplansky.SourceGluing.p] : (M : K) ≠ 0 := by
+  have hc := congrArg (fun n : ℕ => (n : K)) modulus_eq
+  simp only [Nat.cast_add,Nat.cast_one,Nat.cast_pow,CharP.cast_eq_zero K p,zero_pow (by decide : 4≠0)] at hc
+  intro hz
+  rw [hz,zero_add] at hc
+  exact one_ne_zero hc
+lemma cyclic_card : (Fintype.card (Fourier.C M) : K)≠0 := by simpa [Fourier.C] using modulus_cast (K := K)
+lemma sector_base_card : (Fintype.card (WreathFourier.Base (H := HH) M) : K)≠0 := by
+  simp only [WreathFourier.Base,Fintype.card_fun,Fourier.C,Fintype.card_multiplicative,ZMod.card,Nat.cast_pow]
+  exact pow_ne_zero _ (modulus_cast (K := K))
+lemma field_units_card
+    {K : Type}
+    [contextInstance1 : Field.{0} K]
+    [Fintype.{0} K]
+    [@CharP.{0} K
+  (@AddGroupWithOne.toAddMonoidWithOne.{0} K
+    (@Ring.toAddGroupWithOne.{0} K (@DivisionRing.toRing.{0} K (@Field.toDivisionRing.{0} K contextInstance1))))
+  OddKaplansky.SourceGluing.p] (hK : Fintype.card K=p^4) : Fintype.card Kˣ=M := by
+  rw [Fintype.card_units,hK]
+  unfold SourceGluing.modulus
+  rfl
+lemma local_lamp : WreathFourier.base M (WreathFourier.lamp (H := ModularSource.P p) M)=LocalGroup.c p M := by
+  ext x
+  · by_cases hx : x=1
+    · subst x; simp [WreathFourier.base,WreathFourier.lamp,LocalGroup.c]
+    · have hx' : x.toAdd ≠ 0 := hx
+      simp [WreathFourier.base,WreathFourier.lamp,LocalGroup.c,hx]
+  · rfl
+lemma local_conjugate
+    {K : Type}
+    [contextInstance1 : Field.{0} K]
+    [Fintype.{0} K]
+    [@CharP.{0} K
+  (@AddGroupWithOne.toAddMonoidWithOne.{0} K
+    (@Ring.toAddGroupWithOne.{0} K (@DivisionRing.toRing.{0} K (@Field.toDivisionRing.{0} K contextInstance1))))
+  OddKaplansky.SourceGluing.p] (s : ModularSource.P p) :
+    WreathFourier.baseElt (K := K) M (WreathFourier.lamp (H := ModularSource.P p) M)*WreathFourier.topElt M s*WreathFourier.baseElt M (WreathFourier.lamp (H := ModularSource.P p) M)⁻¹=
+      MonoidAlgebra.single (LocalGroup.v p M s) 1 := by
+  simp only [WreathFourier.baseElt,WreathFourier.topElt,MonoidAlgebra.single_mul_single,one_mul,map_inv,local_lamp]
+  rfl
+
+structure LocalDatum where
+  e : MonoidAlgebra K HH
+  idem : e*e=e
+  leftAnn : ∀ s : ModularSource.P p, (MonoidAlgebra.single (LocalGroup.u p M s) 1-1)^ell*e=0
+  rightAnn : ∀ s : ModularSource.P p, e*(MonoidAlgebra.single (LocalGroup.v p M s) 1-1)^ell=0
+  rank : Fintype.card HH<96*Module.finrank K (LinearMap.range (Algebra.lmul K _ e))
+lemma localDatum_exists {ζ : K} (hζ : IsPrimitiveRoot ζ M) (hK : Fintype.card K=p^4) : Nonempty (LocalDatum (K := K)) := by
+  obtain ⟨e,he,hann,hrank⟩ := ModularSource.exists_idempotent (K := K) p M ell hζ
+    (by have := prime_large; omega) pell modulus_eq (field_units_card hK)
+  refine ⟨⟨e,he,?_,?_,?_⟩⟩
+  · intro s
+    exact (hann s).1
+  · intro s
+    simpa only [local_conjugate] using (hann s).2
+  · convert hrank using 1
+
+def prescribedLocalDatum {ζ : K} (hζ : IsPrimitiveRoot ζ M) (hK : Fintype.card K=p^4) : LocalDatum (K := K) where
+  e := ModularSource.explicitElement p M ell hζ
+  idem := (ModularSource.explicit_properties p M ell hζ (by have := prime_large; omega) pell modulus_eq (field_units_card hK)).1
+  leftAnn s := (ModularSource.explicit_properties p M ell hζ (by have := prime_large; omega) pell modulus_eq (field_units_card hK)).2.1 s |>.1
+  rightAnn s := by
+    simpa only [local_conjugate] using (ModularSource.explicit_properties p M ell hζ (by have := prime_large; omega) pell modulus_eq (field_units_card hK)).2.1 s |>.2
+  rank := by
+    exact (ModularSource.explicit_properties p M ell hζ (by have := prime_large; omega) pell modulus_eq (field_units_card hK)).2.2
+
+def push (v : Vertex) : MonoidAlgebra K HH →ₐ[K] MonoidAlgebra K G₀ := MonoidAlgebra.mapDomainAlgHom K K (SourceGluing.vertex v)
+lemma ordered_zero
+    {K : Type}
+    [contextInstance1 : Field.{0} K]
+    [Fintype.{0} K]
+    [@CharP.{0} K
+  (@AddGroupWithOne.toAddMonoidWithOne.{0} K
+    (@Ring.toAddGroupWithOne.{0} K (@DivisionRing.toRing.{0} K (@Field.toDivisionRing.{0} K contextInstance1))))
+  OddKaplansky.SourceGluing.p] (d : LocalDatum (K := K)) (v w : Vertex) (hvw : v<w) (hvwadj : graph.Adj v w) : push v d.e*push w d.e=0 := by
+  let edge : SourceGraph.Edge := ⟨(v,w),hvw,hvwadj⟩
+  have hleft : SourceGluing.edgeHom v edge=LocalGroup.edgeHom p M true (index w) := by
+    simp [SourceGluing.edgeHom,SourceGraph.neighbor,GraphEdges.neighbor,edge]
+  have hright : SourceGluing.edgeHom w edge=LocalGroup.edgeHom p M false (index v) := by
+    have hne : w≠v := ne_of_gt hvw
+    simp [SourceGluing.edgeHom,SourceGraph.neighbor,GraphEdges.neighbor,edge,hne]
+  apply OrderedZero.product_zero p ell ell_le
+    (SourceGluing.edgeHom v edge) (by rw [hleft]; exact LocalGroup.edgeHom_injective p M true _) (SourceGluing.edgeHom w edge)
+    (SourceGluing.vertex v) (SourceGluing.vertex w)
+  · exact Gluing.edge_eq SourceGraph.Inc SourceGluing.edgeHom edge v w (CyclicAlgebra.gen p) (Or.inl rfl) (Or.inr rfl)
+  · rw [hleft]
+    exact d.rightAnn ((LocalGroup.line p (index w)).toMultiplicative (CyclicAlgebra.gen p))
+  · rw [hright]
+    exact d.leftAnn ((LocalGroup.line p (index v)).toMultiplicative (CyclicAlgebra.gen p))
+end
+end OddKaplansky.Construction
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/OddKaplansky/CosetCoordinates.lean b/lean/OAI/Algebra/OddKaplansky/CosetCoordinates.lean
new file mode 100644
index 0000000000000000000000000000000000000000..1336fdcf76ffe0ca9785f8dd6d412ca216a4528e
--- /dev/null
+++ b/lean/OAI/Algebra/OddKaplansky/CosetCoordinates.lean
@@ -0,0 +1,70 @@
+import OAI.Algebra.OddKaplansky.OrderedModular
+
+namespace OAI
+
+universe portUniverse1 portUniverse2 portUniverse3
+
+section
+namespace OddKaplansky.CosetCoordinates
+noncomputable section
+open scoped Classical BigOperators
+variable {G : Type portUniverse1} [Group G] (S : Subgroup G)
+def rep (q : G ⧸ S) : G := q.out
+lemma rep_mk (q : G ⧸ S) : ((rep S q : G) : G ⧸ S) = q := Quotient.out_eq' q
+lemma residue_mem (g : G) : (rep S (g : G ⧸ S))⁻¹*g ∈ S :=
+  QuotientGroup.eq.mp (rep_mk S (g : G ⧸ S))
+def residue (g : G) : S := ⟨_,residue_mem S g⟩
+lemma reconstruct (g : G) : rep S (g : G ⧸ S) * residue S g = g := by simp [residue]
+lemma mk_rep_mul (q : G ⧸ S) (s : S) : ((rep S q * (s : G) : G) : G ⧸ S) = q := by
+  rw [QuotientGroup.mk_mul_of_mem _ s.property,rep_mk]
+lemma residue_rep_mul (q : G ⧸ S) (s : S) : residue S (rep S q * s) = s := by
+  apply Subtype.ext
+  simp only [residue,mk_rep_mul]
+  exact inv_mul_cancel_left _ _
+def equiv : G ≃ (G ⧸ S) × S where
+  toFun g := ((g : G ⧸ S),residue S g)
+  invFun z := rep S z.1 * z.2
+  left_inv := reconstruct S
+  right_inv z := by ext <;> simp only [mk_rep_mul,residue_rep_mul]
+lemma equiv_symm_apply (q : G ⧸ S) (s : S) : (equiv S).symm (q,s) = rep S q * s := rfl
+
+variable [Fintype G]
+lemma sum_right_invariant {A : Type portUniverse2} [AddCommMonoid A] (a : G → A)
+    (ha : ∀ (s : S) (g : G), a (g*s) = a g) :
+    ∑ g : G, a g = Fintype.card S • ∑ q : G ⧸ S, a (rep S q) := by
+  rw [← Equiv.sum_comp (equiv S).symm a]
+  simp only [Fintype.sum_prod_type,equiv_symm_apply,ha,Finset.sum_const,Finset.card_univ,← Finset.smul_sum]
+lemma sum_left_invariant {A : Type portUniverse3} [AddCommMonoid A] (a : G → A)
+    (ha : ∀ (s : S) (g : G), a (s*g) = a g) :
+    ∑ g : G, a g = Fintype.card S • ∑ q : G ⧸ S, a (rep S q)⁻¹ := by
+  have hh := sum_right_invariant S (fun g => a g⁻¹) (fun s g => by simpa only [mul_inv_rev,Subgroup.coe_inv] using ha s⁻¹ g⁻¹)
+  have hi : (∑ g : G, a g⁻¹) = ∑ g : G, a g := Equiv.sum_comp (Equiv.inv G) a
+  rw [hi] at hh
+  exact hh
+lemma coprime_order_of_sum (M : ℕ) (a : G → ZMod M) (hsum : ∑ g, a g = 1)
+    (g : G) (hfix : ∀ x, a (g*x) = a x) : Nat.Coprime (orderOf g) M := by
+  have hf : ∀ (s : Subgroup.zpowers g) (x : G), a (s*x) = a x := by
+    intro s x
+    obtain ⟨n,hn⟩ := s.property
+    rw [← hn]
+    have hnat (n : ℕ) : ∀ x, a (g^n*x)=a x := by
+      induction n with
+      | zero => intro x; simp
+      | succ n ih => intro x; rw [pow_succ',mul_assoc,hfix,ih]
+    cases n with
+    | ofNat n => simpa only [Int.ofNat_eq_natCast,zpow_natCast] using hnat n x
+    | negSucc n =>
+      have h := hnat (n+1) ((g^(n+1))⁻¹ * x)
+      simpa only [zpow_negSucc,← mul_assoc,mul_inv_cancel,one_mul] using h.symm
+  have h := sum_left_invariant (Subgroup.zpowers g) a hf
+  rw [hsum,Fintype.card_zpowers,nsmul_eq_mul] at h
+  exact (ZMod.isUnit_iff_coprime _ _).mp (IsUnit.of_mul_eq_one _ h.symm)
+lemma eq_one_of_power_and_sum (M : ℕ) (a : G → ZMod M) (hsum : ∑ g, a g = 1)
+    (g : G) (hfix : ∀ x, a (g*x) = a x) (hpow : g^M=1) : g=1 :=
+  orderOf_eq_one_iff.mp ((coprime_order_of_sum M a hsum g hfix).eq_one_of_dvd (orderOf_dvd_of_pow_eq_one hpow))
+end
+end OddKaplansky.CosetCoordinates
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/OddKaplansky/CosetGreedy.lean b/lean/OAI/Algebra/OddKaplansky/CosetGreedy.lean
new file mode 100644
index 0000000000000000000000000000000000000000..38a82c61348c23fbcbdaa9a499e589f0ed836e86
--- /dev/null
+++ b/lean/OAI/Algebra/OddKaplansky/CosetGreedy.lean
@@ -0,0 +1,175 @@
+import OAI.Algebra.OddKaplansky.PrescribedSector
+
+namespace OAI
+
+universe contextUniverse1 contextUniverse2
+
+universe portUniverse1 portUniverse2 portUniverse3 portUniverse4
+
+section
+namespace OddKaplansky.OrderedCosetMatrix
+noncomputable section
+open scoped Classical BigOperators Matrix
+variable {K : Type portUniverse1} {G : Type portUniverse2} [Field K] [Group G] [sectionInstance63 : Fintype G] [sectionInstance64 : LinearOrder G] (T : Subgroup G)
+local instance orderedGreedyGroupDecidableEq : DecidableEq G := Classical.decEq G
+variable [sectionInstance65 : IsMulCommutative T]
+local instance orderedGreedyCommGroup : CommGroup T := { (inferInstance : Group T) with mul_comm := mul_comm' }
+local instance orderedGreedyQuotientOrder : LinearOrder (G ⧸ T) := OrderedCosetCoordinates.quotientOrder T
+local instance orderedGreedyQuotientDecidableEq : DecidableEq (G ⧸ T) := Classical.decEq _
+variable (p : ℕ) [Fact p.Prime] [CharP K p] (hexp : ∀ t : T, t^p=1)
+def augmentation : D (K := K) T →+* K := LocalAlgebra.augment.toRingHom
+lemma augmentation_unit
+    {K : Type contextUniverse1}
+    {G : Type contextUniverse2}
+    [contextInstance2 : Field.{contextUniverse1} K]
+    [contextInstance3 : Group.{contextUniverse2} G]
+    [Fintype.{contextUniverse2} G]
+    [LinearOrder.{contextUniverse2} G]
+    (T : @Subgroup.{contextUniverse2} G contextInstance3)
+    [@IsMulCommutative.{contextUniverse2}
+  (@Subtype.{contextUniverse2 + 1} G fun x =>
+    @Membership.mem.{contextUniverse2, contextUniverse2} G (@Subgroup.{contextUniverse2} G contextInstance3)
+      (@SetLike.instMembership.{contextUniverse2, contextUniverse2} (@Subgroup.{contextUniverse2} G contextInstance3) G
+        (@Subgroup.instSetLike.{contextUniverse2} G contextInstance3))
+      T x)
+  (@Subgroup.mul.{contextUniverse2} G contextInstance3 T)]
+    (p : Nat)
+    [Fact (Nat.Prime p)]
+    [@CharP.{contextUniverse1} K
+  (@AddGroupWithOne.toAddMonoidWithOne.{contextUniverse1} K
+    (@Ring.toAddGroupWithOne.{contextUniverse1} K (@DivisionRing.toRing.{contextUniverse1} K (@Field.toDivisionRing.{contextUniverse1} K contextInstance2))))
+  p]
+    (hexp : ∀
+  (t :
+    @Subtype.{contextUniverse2 + 1} G fun x =>
+      @Membership.mem.{contextUniverse2, contextUniverse2} G (@Subgroup.{contextUniverse2} G contextInstance3)
+        (@SetLike.instMembership.{contextUniverse2, contextUniverse2} (@Subgroup.{contextUniverse2} G contextInstance3) G
+          (@Subgroup.instSetLike.{contextUniverse2} G contextInstance3))
+        T x),
+  @Eq.{contextUniverse2 + 1}
+    (@Subtype.{contextUniverse2 + 1} G fun x =>
+      @Membership.mem.{contextUniverse2, contextUniverse2} G (@Subgroup.{contextUniverse2} G contextInstance3)
+        (@SetLike.instMembership.{contextUniverse2, contextUniverse2} (@Subgroup.{contextUniverse2} G contextInstance3) G
+          (@Subgroup.instSetLike.{contextUniverse2} G contextInstance3))
+        T x)
+    (@HPow.hPow.{contextUniverse2, 0, contextUniverse2}
+      (@Subtype.{contextUniverse2 + 1} G fun x =>
+        @Membership.mem.{contextUniverse2, contextUniverse2} G (@Subgroup.{contextUniverse2} G contextInstance3)
+          (@SetLike.instMembership.{contextUniverse2, contextUniverse2} (@Subgroup.{contextUniverse2} G contextInstance3) G
+            (@Subgroup.instSetLike.{contextUniverse2} G contextInstance3))
+          T x)
+      Nat
+      (@Subtype.{contextUniverse2 + 1} G fun x =>
+        @Membership.mem.{contextUniverse2, contextUniverse2} G (@Subgroup.{contextUniverse2} G contextInstance3)
+          (@SetLike.instMembership.{contextUniverse2, contextUniverse2} (@Subgroup.{contextUniverse2} G contextInstance3) G
+            (@Subgroup.instSetLike.{contextUniverse2} G contextInstance3))
+          T x)
+      (@instHPow.{contextUniverse2, 0}
+        (@Subtype.{contextUniverse2 + 1} G fun x =>
+          @Membership.mem.{contextUniverse2, contextUniverse2} G (@Subgroup.{contextUniverse2} G contextInstance3)
+            (@SetLike.instMembership.{contextUniverse2, contextUniverse2} (@Subgroup.{contextUniverse2} G contextInstance3) G
+              (@Subgroup.instSetLike.{contextUniverse2} G contextInstance3))
+            T x)
+        Nat (@Subgroup.npow.{contextUniverse2} G contextInstance3 T))
+      t p)
+    (@OfNat.ofNat.{contextUniverse2}
+      (@Subtype.{contextUniverse2 + 1} G fun x =>
+        @Membership.mem.{contextUniverse2, contextUniverse2} G (@Subgroup.{contextUniverse2} G contextInstance3)
+          (@SetLike.instMembership.{contextUniverse2, contextUniverse2} (@Subgroup.{contextUniverse2} G contextInstance3) G
+            (@Subgroup.instSetLike.{contextUniverse2} G contextInstance3))
+          T x)
+      (nat_lit 1)
+      (@One.toOfNat1.{contextUniverse2}
+        (@Subtype.{contextUniverse2 + 1} G fun x =>
+          @Membership.mem.{contextUniverse2, contextUniverse2} G (@Subgroup.{contextUniverse2} G contextInstance3)
+            (@SetLike.instMembership.{contextUniverse2, contextUniverse2} (@Subgroup.{contextUniverse2} G contextInstance3) G
+              (@Subgroup.instSetLike.{contextUniverse2} G contextInstance3))
+            T x)
+        (@Subgroup.one.{contextUniverse2} G contextInstance3 T)))) (x : D (K := K) T) (hx : augmentation T x≠0) : IsUnit x :=
+  (LocalAlgebra.isUnit_iff p hexp x).mpr hx
+variable (e : MonoidAlgebra K G) (he : e*e=e)
+lemma representation_idempotent
+    {K : Type contextUniverse1}
+    {G : Type contextUniverse2}
+    [contextInstance2 : Field.{contextUniverse1} K]
+    [contextInstance3 : Group.{contextUniverse2} G]
+    [Fintype.{contextUniverse2} G]
+    [LinearOrder.{contextUniverse2} G]
+    (T : @Subgroup.{contextUniverse2} G contextInstance3)
+    [@IsMulCommutative.{contextUniverse2}
+  (@Subtype.{contextUniverse2 + 1} G fun x =>
+    @Membership.mem.{contextUniverse2, contextUniverse2} G (@Subgroup.{contextUniverse2} G contextInstance3)
+      (@SetLike.instMembership.{contextUniverse2, contextUniverse2} (@Subgroup.{contextUniverse2} G contextInstance3) G
+        (@Subgroup.instSetLike.{contextUniverse2} G contextInstance3))
+      T x)
+  (@Subgroup.mul.{contextUniverse2} G contextInstance3 T)]
+    (e : @MonoidAlgebra.{contextUniverse1, contextUniverse2} K G
+  (@CommSemiring.toSemiring.{contextUniverse1} K (@Semifield.toCommSemiring.{contextUniverse1} K (@Field.toSemifield.{contextUniverse1} K contextInstance2))))
+    (he : @Eq.{max (contextUniverse1 + 1) (contextUniverse2 + 1)}
+  (@MonoidAlgebra.{contextUniverse1, contextUniverse2} K G
+    (@CommSemiring.toSemiring.{contextUniverse1} K
+      (@Semifield.toCommSemiring.{contextUniverse1} K (@Field.toSemifield.{contextUniverse1} K contextInstance2))))
+  (@HMul.hMul.{max contextUniverse1 contextUniverse2, max contextUniverse1 contextUniverse2, max contextUniverse1 contextUniverse2}
+    (@MonoidAlgebra.{contextUniverse1, contextUniverse2} K G
+      (@CommSemiring.toSemiring.{contextUniverse1} K
+        (@Semifield.toCommSemiring.{contextUniverse1} K (@Field.toSemifield.{contextUniverse1} K contextInstance2))))
+    (@MonoidAlgebra.{contextUniverse1, contextUniverse2} K G
+      (@CommSemiring.toSemiring.{contextUniverse1} K
+        (@Semifield.toCommSemiring.{contextUniverse1} K (@Field.toSemifield.{contextUniverse1} K contextInstance2))))
+    (@MonoidAlgebra.{contextUniverse1, contextUniverse2} K G
+      (@CommSemiring.toSemiring.{contextUniverse1} K
+        (@Semifield.toCommSemiring.{contextUniverse1} K (@Field.toSemifield.{contextUniverse1} K contextInstance2))))
+    (@instHMul.{max contextUniverse1 contextUniverse2}
+      (@MonoidAlgebra.{contextUniverse1, contextUniverse2} K G
+        (@CommSemiring.toSemiring.{contextUniverse1} K
+          (@Semifield.toCommSemiring.{contextUniverse1} K (@Field.toSemifield.{contextUniverse1} K contextInstance2))))
+      (@MonoidAlgebra.instMul.{contextUniverse1, contextUniverse2} K G
+        (@CommSemiring.toSemiring.{contextUniverse1} K
+          (@Semifield.toCommSemiring.{contextUniverse1} K (@Field.toSemifield.{contextUniverse1} K contextInstance2)))
+        (@MulOne.toMul.{contextUniverse2} G
+          (@MulOneClass.toMulOne.{contextUniverse2} G
+            (@Monoid.toMulOneClass.{contextUniverse2} G
+              (@DivInvMonoid.toMonoid.{contextUniverse2} G (@Group.toDivInvMonoid.{contextUniverse2} G contextInstance3)))))))
+    e e)
+  e) : representation T e*representation T e=representation T e := by
+  exact ((representation T).map_mul e e).symm.trans (congrArg (representation T) he)
+variable {W : Type portUniverse3} {N : Type portUniverse4} [Fintype W] [LinearOrder W] [Fintype N] [LinearOrder N]
+variable (hw : Fintype.card W=Fintype.card G)
+variable (hn : Fintype.card N=Module.finrank K (LinearMap.range (Algebra.lmul K (MonoidAlgebra K G) e)))
+include hexp he hw hn in
+lemma greedy_pair : Fintype.card N*Fintype.card (G ⧸ T)=Fintype.card W*Fintype.card (GreedyRing.I (augmentation T) (representation T e)) := by
+  apply GreedyRing.pair_dimension (augmentation T) (augmentation_unit T p hexp) (representation T e) (representation_idempotent T e he)
+  · rw [(unpack (K := K) T).finrank_eq,Module.finrank_eq_card_basis (MonoidAlgebra.basis G K)]
+    exact hw
+  · change Fintype.card N=Module.finrank K (LinearMap.range (endomorphism T e))
+    rw [endomorphism_rank]
+    exact hn
+
+def explicitJ : Matrix W N (Matrix (G ⧸ T) (G ⧸ T) (D (K := K) T)) := fun w n =>
+  (Matrix.toLinAlgEquiv' (R := D (K := K) T) (n := G ⧸ T)).symm
+    (GreedyRing.rectangleJ (augmentation T) (augmentation_unit T p hexp) (representation T e) (representation_idempotent T e he) (greedy_pair T p hexp e he hw hn) w n)
+def explicitY : Matrix N W (Matrix (G ⧸ T) (G ⧸ T) (D (K := K) T)) := fun n w =>
+  (Matrix.toLinAlgEquiv' (R := D (K := K) T) (n := G ⧸ T)).symm
+    (GreedyRing.rectangleY (augmentation T) (augmentation_unit T p hexp) (representation T e) (representation_idempotent T e he) (greedy_pair T p hexp e he hw hn) n w)
+lemma explicit_products :
+    explicitY T p hexp e he hw hn*explicitJ T p hexp e he hw hn=1 ∧
+    explicitJ T p hexp e he hw hn*explicitY T p hexp e he hw hn=Matrix.diagonal (fun _ : W => representation T e) := by
+  let φ := (Matrix.toLinAlgEquiv' (R := D (K := K) T) (n := G ⧸ T)).symm
+  have hYJ := GreedyRing.rectangleYJ (augmentation T) (augmentation_unit T p hexp) (representation T e) (representation_idempotent T e he) (greedy_pair T p hexp e he hw hn)
+  have hJY := GreedyRing.rectangleJY (augmentation T) (augmentation_unit T p hexp) (representation T e) (representation_idempotent T e he) (greedy_pair T p hexp e he hw hn)
+  constructor
+  · funext n n'
+    have hh := congrArg (fun F => φ (F n n')) hYJ
+    simpa only [explicitY,explicitJ,Matrix.mul_apply,map_sum,map_mul,Matrix.one_apply,apply_ite,map_one,map_zero] using hh
+  · funext w w'
+    have hh := congrArg (fun F => φ (F w w')) hJY
+    have hφ : φ (Matrix.toLin' (representation T e))=representation T e :=
+      (Matrix.toLinAlgEquiv' (R := D (K := K) T) (n := G ⧸ T)).symm_apply_apply _
+    simp only [Matrix.toLin'_apply'] at hh hφ
+    simpa only [explicitJ,explicitY,Matrix.mul_apply,map_sum,map_mul,Matrix.diagonal_apply,apply_ite,map_zero,hφ] using hh
+end
+end OddKaplansky.OrderedCosetMatrix
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/OddKaplansky/CosetMatrix.lean b/lean/OAI/Algebra/OddKaplansky/CosetMatrix.lean
new file mode 100644
index 0000000000000000000000000000000000000000..d45a84b2889a8d4955e47bf06f9375ca12f95506
--- /dev/null
+++ b/lean/OAI/Algebra/OddKaplansky/CosetMatrix.lean
@@ -0,0 +1,148 @@
+import OAI.Algebra.OddKaplansky.CosetCoordinates
+
+namespace OAI
+
+universe contextUniverse1
+
+universe portUniverse1 portUniverse2 portUniverse3
+
+section
+namespace OddKaplansky.CosetMatrix
+noncomputable section
+open scoped Classical BigOperators Matrix
+variable {K : Type portUniverse1} {G : Type portUniverse2} [Field K] [Group G] [sectionInstance43 : Fintype G] (T : Subgroup G)
+abbrev Q := G ⧸ T
+abbrev D := MonoidAlgebra K T
+open CosetCoordinates
+lemma mk_left
+    {G : Type contextUniverse1}
+    [contextInstance1 : Group.{contextUniverse1} G]
+    [Fintype.{contextUniverse1} G]
+    (T : @Subgroup.{contextUniverse1} G contextInstance1) (g h : G) : ((g*h : G) : G ⧸ T) = g • (h : G ⧸ T) := rfl
+lemma mk_mul_rep (g : G) (q : G ⧸ T) : ((g*rep T q : G) : G ⧸ T) = g • q := by rw [mk_left,rep_mk]
+def cocycle (g : G) (q : G ⧸ T) : T := residue T (g * rep T q)
+lemma cocycle_reconstruct (g : G) (q : G ⧸ T) : rep T (g • q) * (cocycle T g q : G) = g*rep T q := by
+  simpa only [cocycle,mk_mul_rep] using reconstruct T (g*rep T q)
+lemma cocycle_one
+    {G : Type contextUniverse1}
+    [contextInstance1 : Group.{contextUniverse1} G]
+    [Fintype.{contextUniverse1} G]
+    (T : @Subgroup.{contextUniverse1} G contextInstance1) (q : G ⧸ T) : cocycle T 1 q = 1 := by
+  apply Subtype.ext
+  simp [cocycle,residue,rep_mk]
+lemma cocycle_mul (g h : G) (q : G ⧸ T) : cocycle T (g*h) q = cocycle T g (h • q) * cocycle T h q := by
+  apply Subtype.ext
+  apply mul_left_cancel (a := rep T ((g*h) • q))
+  rw [cocycle_reconstruct,Subgroup.coe_mul,mul_smul,← mul_assoc,cocycle_reconstruct]
+  simp only [mul_assoc,cocycle_reconstruct]
+
+def groupMatrix (g : G) : Matrix (G ⧸ T) (G ⧸ T) (D (K := K) T) := fun q r =>
+  if q = g • r then MonoidAlgebra.single (cocycle T g r) 1 else 0
+lemma groupMatrix_one : groupMatrix (K := K) T 1 = 1 := by
+  funext q r
+  simp [groupMatrix,Matrix.one_apply,cocycle_one,MonoidAlgebra.one_def]
+lemma groupMatrix_mul (g h : G) : groupMatrix (K := K) T (g*h) = groupMatrix T g * groupMatrix T h := by
+  ext q r
+  rw [Matrix.mul_apply,Finset.sum_eq_single (h • r)]
+  · simp only [groupMatrix,ite_true,ite_mul,zero_mul,      MonoidAlgebra.single_mul_single,one_mul,cocycle_mul,mul_smul]
+  · intro z _ hz
+    simp [groupMatrix,hz]
+  · simp
+def representation : MonoidAlgebra K G →ₐ[K] Matrix (G ⧸ T) (G ⧸ T) (D (K := K) T) :=
+  MonoidAlgebra.lift K _ G { toFun := groupMatrix T, map_one' := groupMatrix_one T, map_mul' := groupMatrix_mul T }
+lemma representation_single (g : G) (c : K) : representation T (MonoidAlgebra.single g c) = c • groupMatrix T g := by
+  simp [representation]
+
+def coefficients {X : Type portUniverse3} [Finite X] : MonoidAlgebra K X ≃ₗ[K] (X → K) :=
+  (MonoidAlgebra.coeffLinearEquiv K).trans (Finsupp.linearEquivFunOnFinite K K X)
+def unpack : ((G ⧸ T) → D (K := K) T) ≃ₗ[K] MonoidAlgebra K G :=
+  (LinearEquiv.piCongrRight (fun _ : G ⧸ T => coefficients)).trans
+    ((LinearEquiv.curry K K (G ⧸ T) T).symm.trans
+      ((LinearEquiv.piCongrLeft K (fun _ : (G ⧸ T) × T => K) (equiv T)).symm.trans coefficients.symm))
+lemma unpack_coeff (v : (G ⧸ T) → D (K := K) T) (g : G) :
+    (unpack T v).coeff g = (v (g : G ⧸ T)).coeff (residue T g) := rfl
+lemma unpack_symm_coeff (v : MonoidAlgebra K G) (q : G ⧸ T) (t : T) :
+    ((unpack T).symm v q).coeff t = v.coeff (rep T q * t) := by
+  have h := unpack_coeff T ((unpack T).symm v) (rep T q * t)
+  rw [LinearEquiv.apply_symm_apply,mk_rep_mul,residue_rep_mul] at h
+  exact h.symm
+lemma unpack_basis (q : G ⧸ T) (t : T) :
+    unpack (K := K) T (Pi.single q (MonoidAlgebra.single t 1)) = MonoidAlgebra.single (rep T q * t) 1 := by
+  apply (unpack T).symm.injective
+  rw [LinearEquiv.symm_apply_apply]
+  funext r
+  apply MonoidAlgebra.coeff_injective
+  ext s
+  rw [unpack_symm_coeff]
+  by_cases h : r=q
+  · subst r
+    simp [MonoidAlgebra.coeff_single,Finsupp.single_apply]
+  · have hn : rep T r*(s : G) ≠ rep T q*(t : G) := by
+      intro he
+      have hq := congrArg (fun g : G => (g : G ⧸ T)) he
+      rw [mk_rep_mul,mk_rep_mul] at hq
+      exact h hq
+    simp [Pi.single_eq_of_ne h,MonoidAlgebra.coeff_single,hn]
+lemma residue_left (g x : G) : residue T (g*x) = cocycle T g (x : G ⧸ T) * residue T x := by
+  apply Subtype.ext
+  apply mul_left_cancel (a := rep T ((g*x : G) : G ⧸ T))
+  rw [reconstruct,Subgroup.coe_mul,mk_left,← mul_assoc,cocycle_reconstruct,mul_assoc,reconstruct]
+lemma groupMatrix_mulVec (g : G) (v : (G ⧸ T) → D (K := K) T) (q : G ⧸ T) :
+    (groupMatrix T g).mulVec v q = MonoidAlgebra.single (cocycle T g (g⁻¹ • q)) 1 * v (g⁻¹ • q) := by
+  rw [Matrix.mulVec, dotProduct,Finset.sum_eq_single (g⁻¹ • q)]
+  · simp [groupMatrix]
+  · intro r _ hr
+    have hne : q ≠ g • r := by
+      intro he
+      apply hr
+      rw [he,inv_smul_smul]
+    simp [groupMatrix,hne]
+  · simp
+lemma unpack_group (g : G) (v : (G ⧸ T) → D (K := K) T) :
+    unpack T ((groupMatrix T g).mulVec v) = MonoidAlgebra.single g 1 * unpack T v := by
+  apply MonoidAlgebra.coeff_injective
+  ext x
+  rw [unpack_coeff,groupMatrix_mulVec,MonoidAlgebra.coeff_single_mul_apply,
+    MonoidAlgebra.coeff_single_mul_apply,unpack_coeff,one_mul,one_mul]
+  have hq : ((g⁻¹*x : G) : G ⧸ T) = g⁻¹ • (x : G ⧸ T) := rfl
+  have hr := residue_left T g (g⁻¹*x)
+  simp only [mul_inv_cancel_left,hq] at hr
+  rw [hq,hr,inv_mul_cancel_left]
+lemma unpack_representation (e : MonoidAlgebra K G) (v : (G ⧸ T) → D (K := K) T) :
+    unpack T ((representation T e).mulVec v) = e * unpack T v := by
+  induction e using MonoidAlgebra.induction_on with
+  | of g => simpa only [MonoidAlgebra.of_apply,representation_single,one_smul] using unpack_group T g v
+  | add e f he hf => simp only [map_add,Matrix.add_mulVec,he,hf,add_mul]
+  | smul c e he => simp only [map_smul,Matrix.smul_mulVec,map_smul,he,smul_mul_assoc]
+
+section Commutative
+variable [IsMulCommutative T]
+local instance cosetMatrixCommGroup : CommGroup T := { (inferInstance : Group T) with mul_comm := mul_comm' }
+def endomorphism (e : MonoidAlgebra K G) : Module.End (D (K := K) T) ((G ⧸ T) → D (K := K) T) :=
+  Matrix.toLin' (representation T e)
+lemma endomorphism_idempotent (e : MonoidAlgebra K G) (he : e*e=e) :
+    endomorphism T e * endomorphism T e = endomorphism T e := by
+  change (Matrix.toLin' (representation T e)).comp (Matrix.toLin' (representation T e)) = Matrix.toLin' (representation T e)
+  rw [← Matrix.toLin'_mul,← map_mul,he]
+lemma endomorphism_rank (e : MonoidAlgebra K G) :
+    Module.finrank K (LinearMap.range (endomorphism T e)) =
+      Module.finrank K (LinearMap.range (Algebra.lmul K (MonoidAlgebra K G) e)) := by
+  have ht : (unpack (K := K) T).toLinearMap.comp ((endomorphism T e).restrictScalars K) =
+      (Algebra.lmul K (MonoidAlgebra K G) e).comp (unpack T).toLinearMap := by
+    apply LinearMap.ext
+    intro v
+    exact unpack_representation T e v
+  have hr := congrArg LinearMap.range ht
+  rw [LinearMap.range_comp,LinearMap.range_comp,LinearEquiv.range,Submodule.map_top] at hr
+  have hd := LinearEquiv.finrank_map_eq (unpack (K := K) T) (LinearMap.range ((endomorphism T e).restrictScalars K))
+  rw [hr] at hd
+  rw [LinearMap.range_restrictScalars] at hd
+  have hx := ((Submodule.restrictScalarsEquiv K (D (K := K) T) _ (LinearMap.range (endomorphism T e))).restrictScalars K).finrank_eq
+  exact hx.symm.trans hd.symm
+end Commutative
+end
+end OddKaplansky.CosetMatrix
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/OddKaplansky/CosetRectangles.lean b/lean/OAI/Algebra/OddKaplansky/CosetRectangles.lean
new file mode 100644
index 0000000000000000000000000000000000000000..3cf865acc2d570bbac65bab266a4d5a7042990d9
--- /dev/null
+++ b/lean/OAI/Algebra/OddKaplansky/CosetRectangles.lean
@@ -0,0 +1,45 @@
+import OAI.Algebra.OddKaplansky.IdempotentFree
+
+namespace OAI
+
+universe portUniverse1 portUniverse2 portUniverse3 portUniverse4
+
+section
+namespace OddKaplansky.CosetMatrix
+noncomputable section
+open scoped Classical BigOperators Matrix
+variable {K : Type portUniverse1} {G : Type portUniverse2} [Field K] [Group G] [Fintype G] (T : Subgroup G)
+variable [IsMulCommutative T]
+local instance cosetRectangularCommGroup : CommGroup T := { (inferInstance : Group T) with mul_comm := mul_comm' }
+variable (p : ℕ) [Fact p.Prime] [CharP K p] (hexp : ∀ t : T, t^p=1)
+include hexp in
+lemma representation_rectangular (e : MonoidAlgebra K G) (he : e*e=e)
+    {W : Type portUniverse3} {N : Type portUniverse4} [Fintype W] [Fintype N]
+    (hw : Fintype.card W = Fintype.card G)
+    (hn : Fintype.card N = Module.finrank K (LinearMap.range (Algebra.lmul K (MonoidAlgebra K G) e))) :
+    ∃ (J : Matrix W N (Matrix (G ⧸ T) (G ⧸ T) (D (K := K) T)))
+      (Y : Matrix N W (Matrix (G ⧸ T) (G ⧸ T) (D (K := K) T))),
+      Y*J=1 ∧ J*Y=Matrix.diagonal (fun _ : W => representation T e) := by
+  let : IsLocalRing (D (K := K) T) := LocalAlgebra.isLocal p hexp
+  have hv : Module.finrank K ((G ⧸ T) → D (K := K) T) = Fintype.card G := by
+    rw [(unpack (K := K) T).finrank_eq,Module.finrank_eq_card_basis (MonoidAlgebra.basis G K)]
+  obtain ⟨J,Y,hYJ,hJY⟩ := IdempotentFree.rectangular (K := K) (endomorphism T e)
+    (endomorphism_idempotent T e he) (hw.trans hv.symm) (hn.trans (endomorphism_rank T e).symm)
+  let φ := (Matrix.toLinAlgEquiv' (R := D (K := K) T) (n := G ⧸ T)).symm
+  refine ⟨fun w n => φ (J w n),fun n w => φ (Y n w),?_,?_⟩
+  · funext n n'
+    change (∑ x, φ (Y n x) * φ (J x n')) = (1 : Matrix N N (Matrix (G ⧸ T) (G ⧸ T) (D (K := K) T))) n n'
+    have hh := congrArg (fun F => φ (F n n')) hYJ
+    simpa only [Matrix.mul_apply,map_sum,map_mul,Matrix.one_apply,apply_ite,map_one,map_zero] using hh
+  · funext w w'
+    change (∑ x, φ (J w x) * φ (Y x w')) = (Matrix.diagonal (fun _ : W => representation T e)) w w'
+    have hh := congrArg (fun F => φ (F w w')) hJY
+    have hφ : φ (endomorphism T e) = representation T e := by
+      exact (Matrix.toLinAlgEquiv' (R := D (K := K) T) (n := G ⧸ T)).symm_apply_apply _
+    simpa only [Matrix.mul_apply,map_sum,map_mul,Matrix.diagonal_apply,apply_ite,map_zero,hφ] using hh
+end
+end OddKaplansky.CosetMatrix
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/OddKaplansky/CyclicCoset.lean b/lean/OAI/Algebra/OddKaplansky/CyclicCoset.lean
new file mode 100644
index 0000000000000000000000000000000000000000..dc791c89c4e730408e7f605c0bb6f8c2d434db7b
--- /dev/null
+++ b/lean/OAI/Algebra/OddKaplansky/CyclicCoset.lean
@@ -0,0 +1,92 @@
+import OAI.Algebra.OddKaplansky.NilpotentBasis
+
+namespace OAI
+
+universe contextUniverse1
+
+universe portUniverse1 portUniverse2 portUniverse3 portUniverse4
+
+section
+namespace OddKaplansky.CosetMatrix
+noncomputable section
+open scoped Classical BigOperators
+open CosetCoordinates
+variable {K : Type portUniverse1} {G : Type portUniverse2} [Field K] [Group G] [sectionInstance70 : Fintype G] (T : Subgroup G)
+lemma mk_right
+    {G : Type contextUniverse1}
+    [contextInstance1 : Group.{contextUniverse1} G]
+    [Fintype.{contextUniverse1} G]
+    (T : @Subgroup.{contextUniverse1} G contextInstance1) (g : G) (t : T) : ((g*t : G) : G ⧸ T) = (g : G ⧸ T) :=
+  QuotientGroup.mk_mul_of_mem _ t.property
+lemma residue_right (g : G) (t : T) : residue T (g*t) = residue T g * t := by
+  apply Subtype.ext
+  simp only [residue,mk_right,Subgroup.coe_mul,mul_assoc]
+lemma unpack_right_single (v : (G ⧸ T) → D (K := K) T) (t : T) :
+    unpack T (fun q => v q * MonoidAlgebra.single t 1) =
+      unpack T v * MonoidAlgebra.single (t : G) 1 := by
+  apply MonoidAlgebra.coeff_injective
+  ext g
+  rw [unpack_coeff,MonoidAlgebra.coeff_mul_single_apply,MonoidAlgebra.coeff_mul_single_apply,
+    unpack_coeff,mul_one,mul_one]
+  simp only [← Subgroup.coe_inv,mk_right,residue_right]
+lemma unpack_right (v : (G ⧸ T) → D (K := K) T) (b : D (K := K) T) :
+    unpack T (fun q => v q * b) = unpack T v * MonoidAlgebra.mapDomainAlgHom K K T.subtype b := by
+  induction b using MonoidAlgebra.induction_on with
+  | of t =>
+    convert unpack_right_single T v t using 1 <;> simp [MonoidAlgebra.of_apply]
+  | add b c hb hc =>
+    simp only [mul_add,map_add]
+    change unpack T ((fun q => v q*b)+(fun q => v q*c)) = _
+    rw [map_add,hb,hc]
+  | smul c b hb =>
+    simp only [mul_smul_comm,map_smul]
+    change unpack T (c • (fun q => v q*b)) = _
+    rw [map_smul,hb]
+lemma right_divisible (X : D (K := K) T) (n k : ℕ)
+    (hdiv : ∀ a : D (K := K) T, a*X^n=0 → ∃ b, a=b*X^k)
+    (a : MonoidAlgebra K G) (ha : a*(MonoidAlgebra.mapDomainAlgHom K K T.subtype X)^n=0) :
+    ∃ b, a=b*(MonoidAlgebra.mapDomainAlgHom K K T.subtype X)^k := by
+  let v := (unpack (K := K) T).symm a
+  have hv : ∀ q, v q * X^n=0 := by
+    have hh : unpack T (fun q => v q*X^n)=0 := by
+      rw [unpack_right,map_pow,LinearEquiv.apply_symm_apply,ha]
+    have hz := (unpack T).injective (hh.trans (map_zero (unpack T)).symm)
+    exact fun q => congrFun hz q
+  choose w hw using fun q => hdiv (v q) (hv q)
+  refine ⟨unpack T w,?_⟩
+  rw [← map_pow,← unpack_right]
+  exact (LinearEquiv.apply_symm_apply (unpack T) a).symm.trans (congrArg (unpack T) (funext hw))
+end
+end OddKaplansky.CosetMatrix
+
+namespace OddKaplansky.CyclicAlgebra
+noncomputable section
+open scoped Classical BigOperators
+variable {K : Type portUniverse3} {G : Type portUniverse4} [Field K] [Group G] [Fintype G]
+variable (p : ℕ) [Fact p.Prime] [CharP K p]
+lemma embedded_right_divisible (i : C p →* G) (hi : Function.Injective i)
+    (ell : ℕ) (hell : ell≤p) (a : MonoidAlgebra K G)
+    (ha : a*(MonoidAlgebra.single (i (gen p)) 1-1)^ell=0) :
+    ∃ b, a=b*(MonoidAlgebra.single (i (gen p)) 1-1)^(p-ell) := by
+  let φ := MonoidAlgebra.domCongr K K (MonoidHom.ofInjective hi)
+  let Xi := φ (X (K := K) p)
+  have hXi : MonoidAlgebra.mapDomainAlgHom K K i.range.subtype Xi =
+      MonoidAlgebra.single (i (gen p)) (1 : K)-1 := by
+    simp only [Xi,φ,X,map_sub,map_one,MonoidAlgebra.domCongr_single]
+    simp only [MonoidAlgebra.mapDomainAlgHom_apply,MonoidAlgebra.mapDomain_single]
+    rfl
+  apply CosetMatrix.right_divisible i.range Xi ell (p-ell) _ a (by rwa [hXi]) |>.imp (fun b hb => by rwa [hXi] at hb)
+  intro c hc
+  have hcz : φ.symm c * X p^ell=0 := by
+    apply φ.injective
+    simpa only [map_mul,map_pow,AlgEquiv.apply_symm_apply,map_zero] using hc
+  obtain ⟨b,hb⟩ := right_divisible p ell hell (φ.symm c) hcz
+  refine ⟨φ b,?_⟩
+  have hh := congrArg φ hb
+  simpa only [map_mul,map_pow,AlgEquiv.apply_symm_apply] using hh
+end
+end OddKaplansky.CyclicAlgebra
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/OddKaplansky/Diagrams.lean b/lean/OAI/Algebra/OddKaplansky/Diagrams.lean
new file mode 100644
index 0000000000000000000000000000000000000000..a959269586ee8c7a3fa195e6ce39c9b89008ce26
--- /dev/null
+++ b/lean/OAI/Algebra/OddKaplansky/Diagrams.lean
@@ -0,0 +1,3839 @@
+import OAI.Algebra.OddKaplansky.CoefficientOrder
+import OAI.RingTheory.DirectFiniteness.ReducedWalks
+
+namespace OAI
+
+universe contextUniverse1 contextUniverse2
+
+universe portUniverse1 portUniverse2 portUniverse3 portUniverse4 portUniverse5 portUniverse6 portUniverse7 portUniverse8 portUniverse9 portUniverse10 portUniverse11 portUniverse12 portUniverse13 portUniverse14 portUniverse15 portUniverse16 portUniverse17 portUniverse18 portUniverse19 portUniverse20 portUniverse21 portUniverse22 portUniverse23 portUniverse24 portUniverse25 portUniverse26 portUniverse27 portUniverse28 portUniverse29 portUniverse30 portUniverse31 portUniverse32 portUniverse33 portUniverse34 portUniverse35 portUniverse36 portUniverse37 portUniverse38 portUniverse39 portUniverse40 portUniverse41 portUniverse42 portUniverse43 portUniverse44 portUniverse45 portUniverse46 portUniverse47 portUniverse48 portUniverse49 portUniverse50 portUniverse51 portUniverse52 portUniverse53 portUniverse54 portUniverse55 portUniverse56 portUniverse57 portUniverse58 portUniverse59 portUniverse60 portUniverse61 portUniverse62 portUniverse63 portUniverse64 portUniverse65 portUniverse66 portUniverse67 portUniverse68 portUniverse69 portUniverse70 portUniverse71 portUniverse72 portUniverse73 portUniverse74 portUniverse75 portUniverse76
+
+section
+
+noncomputable section
+open scoped Classical
+
+noncomputable section
+open scoped Classical BigOperators
+open Equiv Equiv.Perm
+namespace OddKaplansky.Planar
+attribute [local simp] SameCycle.rfl
+
+variable {α : Type portUniverse1} [Fintype α]
+
+abbrev Cycles (p : Perm α) := Quotient (SameCycle.setoid p)
+
+def cycleClass (p : Perm α) (x : α) : Cycles p := Quotient.mk _ x
+
+def cycleSet (p : Perm α) (c : Cycles p) : Finset α :=
+  Finset.univ.filter fun x => cycleClass p x = c
+
+lemma mem_cycleSet (p : Perm α) (c : Cycles p) (x : α) :
+    x ∈ cycleSet p c ↔ cycleClass p x = c := by simp [cycleSet]
+
+omit [Fintype α] in
+lemma cycleClass_eq (p : Perm α) (x y : α) :
+    cycleClass p x = cycleClass p y ↔ p.SameCycle x y := Quotient.eq
+
+lemma cycleSet_nonempty (p : Perm α) (c : Cycles p) : (cycleSet p c).Nonempty := by
+  induction c using Quotient.inductionOn with
+  | h x => exact ⟨x, (mem_cycleSet p _ x).mpr rfl⟩
+
+lemma cycles_sum_card (p : Perm α) :
+    ∑ c : Cycles p, (cycleSet p c).card = Fintype.card α := by
+  classical
+  simpa [cycleSet] using Finset.sum_card_fiberwise_eq_card_filter
+    (s := Finset.univ) (t := Finset.univ) (g := cycleClass p)
+
+structure Ribbon (α : Type portUniverse2) where
+  black : Perm α
+  white : Perm α
+
+def Ribbon.face (R : Ribbon α) : Perm α := R.white * R.black
+
+def Ribbon.Spherical (R : Ribbon α) : Prop :=
+  Nat.card (Cycles R.black) + Nat.card (Cycles R.white) +
+    Nat.card (Cycles R.face) = Fintype.card α + 2
+
+def Ribbon.mergeWhite (R : Ribbon α) (e : α) : Ribbon α where
+  black := R.black
+  white := swap e (R.face e) * R.white
+
+omit [Fintype α] in
+lemma mergeWhite_face (R : Ribbon α) (e : α) :
+    (R.mergeWhite e).face = swap e (R.face e) * R.face := by
+  simp [Ribbon.mergeWhite, Ribbon.face, mul_assoc]
+
+omit [Fintype α] in
+lemma mergeWhite_face_fixed (R : Ribbon α) (e : α) : (R.mergeWhite e).face e = e := by
+  rw [mergeWhite_face]
+  simp
+
+lemma sameCycle_map {β : Type portUniverse3} (p : Perm α) (q : Perm β) (f : α → β)
+    (hstep : ∀ x, q.SameCycle (f x) (f (p x))) {x y : α}
+    (hxy : p.SameCycle x y) : q.SameCycle (f x) (f y) := by
+  obtain ⟨n, rfl⟩ := hxy.exists_nat_pow_eq
+  clear hxy
+  induction n with
+  | zero => simp
+  | succ n ih =>
+    rw [pow_succ', Perm.mul_apply]
+    exact ih.trans (hstep _)
+
+def unplug (p : Perm α) (a : α) : Perm α := swap a (p a) * p
+
+def bypass (p : Perm α) (a x : α) : α := if x = a then p a else x
+
+omit [Fintype α] in
+lemma unplug_fixed (p : Perm α) (a : α) : unplug p a a = a := by
+  simp [unplug]
+
+lemma unplug_sameCycle (p : Perm α) (a : α) {x y : α}
+    (h : (unplug p a).SameCycle x y) : p.SameCycle x y := by
+  apply sameCycle_map (unplug p a) p id _ h
+  intro x
+  change p.SameCycle x (swap a (p a) (p x))
+  by_cases hx : x = a
+  · subst x
+    simp
+  · by_cases hxa : p x = a
+    · simp only [hxa, swap_apply_left]
+      exact (show p.SameCycle x a by rw [← hxa]; simp).trans (by simp)
+    · have hxp : p x ≠ p a := p.injective.ne hx
+      rw [swap_apply_of_ne_of_ne hxa hxp]
+      simp
+
+lemma sameCycle_bypass (p : Perm α) (a : α) (ha : p a ≠ a) {x y : α}
+    (h : p.SameCycle x y) :
+    (unplug p a).SameCycle (bypass p a x) (bypass p a y) := by
+  apply sameCycle_map p (unplug p a) (bypass p a) _ h
+  intro x
+  by_cases hx : x = a
+  · subst x
+    simp [bypass, ha]
+  · by_cases hxa : p x = a
+    · have hq : unplug p a x = p a := by simp [unplug, hxa]
+      simp only [bypass, hx, hxa, ite_false, ite_true]
+      rw [← hq]
+      simp
+    · have hxp : p x ≠ p a := p.injective.ne hx
+      have hq : unplug p a x = p x := by
+        simp only [unplug, Perm.mul_apply]
+        exact swap_apply_of_ne_of_ne hxa hxp
+      simp only [bypass, hx, hxa, ite_false]
+      rw [← hq]
+      simp
+
+lemma unplug_sameCycle_iff (p : Perm α) (a : α) (ha : p a ≠ a)
+    {x y : α} (hx : x ≠ a) (hy : y ≠ a) :
+    (unplug p a).SameCycle x y ↔ p.SameCycle x y := by
+  refine ⟨unplug_sameCycle p a, fun h => ?_⟩
+  simpa [bypass, hx, hy] using sameCycle_bypass p a ha h
+
+omit [Fintype α] in
+lemma bypass_ne (p : Perm α) (a : α) (ha : p a ≠ a) (x : α) :
+    bypass p a x ≠ a := by
+  by_cases hx : x = a <;> simp [bypass, hx, ha]
+
+def unplugCycleEquiv (p : Perm α) (a : α) (ha : p a ≠ a) :
+    Cycles p ≃ {c : Cycles (unplug p a) // c ≠ cycleClass (unplug p a) a} where
+  toFun := Quotient.lift (fun x =>
+    ⟨cycleClass (unplug p a) (bypass p a x), by
+      intro h
+      have he := (cycleClass_eq _ _ _).mp h
+      exact bypass_ne p a ha x (he.eq_of_right (unplug_fixed p a))⟩)
+    (fun x y h => Subtype.ext ((cycleClass_eq _ _ _).mpr (sameCycle_bypass p a ha h)))
+  invFun c := Quotient.map' id (fun _ _ h => unplug_sameCycle p a h) c.val
+  left_inv c := by
+    induction c using Quotient.inductionOn with
+    | h x =>
+      change cycleClass p (bypass p a x) = cycleClass p x
+      apply (cycleClass_eq _ _ _).mpr
+      by_cases hx : x = a <;> simp [bypass, hx]
+  right_inv c := by
+    rcases c with ⟨c, hc⟩
+    apply Subtype.ext
+    induction c using Quotient.inductionOn with
+    | h x =>
+      have hx : x ≠ a := by
+        intro h
+        apply hc
+        exact congrArg (cycleClass _) h
+      change cycleClass (unplug p a) (bypass p a x) = cycleClass (unplug p a) x
+      simp [bypass, hx]
+
+lemma unplug_cycles_card (p : Perm α) (a : α) (ha : p a ≠ a) :
+    Nat.card (Cycles (unplug p a)) = Nat.card (Cycles p) + 1 := by
+  have h := Fintype.card_congr (unplugCycleEquiv p a ha)
+  rw [Fintype.card_subtype_compl, Fintype.card_subtype_eq] at h
+  have hp : 0 < Fintype.card (Cycles (unplug p a)) :=
+    Fintype.card_pos_iff.mpr ⟨cycleClass (unplug p a) a⟩
+  simp only [Nat.card_eq_fintype_card]
+  omega
+
+lemma swap_mul_sameCycle (p : Perm α) (a b : α) (hab : ¬ p.SameCycle a b) :
+    (swap a b * p).SameCycle a b := by
+  have hret : ∃ n : ℕ, 0 < n ∧ (p ^ n) b = b := by
+    exact ⟨orderOf p, orderOf_pos p, by simp⟩
+  let n := Nat.find hret
+  have hn : 0 < n ∧ (p ^ n) b = b := Nat.find_spec hret
+  have hmin : ∀ k, 0 < k → k < n → (p ^ k) b ≠ b := by
+    intro k hk hkn heq
+    exact Nat.find_min hret hkn ⟨hk, heq⟩
+  have hneq : ∀ k : ℕ, (p ^ k) b ≠ a := by
+    intro k heq
+    apply hab
+    exact (show p.SameCycle b a from ⟨k, by simpa using heq⟩).symm
+  have hiter : ∀ k, k < n → ((swap a b * p) ^ k) b = (p ^ k) b := by
+    intro k
+    induction k with
+    | zero => simp
+    | succ k ih =>
+      intro hk
+      rw [pow_succ', Perm.mul_apply, ih (by omega), Perm.mul_apply]
+      have heq : p ((p ^ k) b) = (p ^ (k + 1)) b := by
+        rw [pow_succ', Perm.mul_apply]
+      rw [heq, swap_apply_of_ne_of_ne (hneq _) (hmin _ (by omega) hk)]
+  have hn' : n - 1 + 1 = n := by omega
+  have hstep : ((swap a b * p) ^ n) b = a := by
+    rw [← hn', pow_succ', Perm.mul_apply, hiter _ (by omega), Perm.mul_apply]
+    have heq : p ((p ^ (n - 1)) b) = b := by
+      calc
+        p ((p ^ (n - 1)) b) = (p ^ (n - 1 + 1)) b := by rw [pow_succ', Perm.mul_apply]
+        _ = b := by rw [hn']; exact hn.2
+    rw [heq, swap_apply_right]
+  exact (show (swap a b * p).SameCycle b a from ⟨n, by simpa using hstep⟩).symm
+
+lemma sameCycle_swap_mul (p : Perm α) (a b : α) (hab : ¬ p.SameCycle a b)
+    {x y : α} (hxy : p.SameCycle x y) : (swap a b * p).SameCycle x y := by
+  have hlink := swap_mul_sameCycle p a b hab
+  apply sameCycle_map p (swap a b * p) id _ hxy
+  intro x
+  have hx : (swap a b * p).SameCycle x (swap a b (p x)) := by
+    change (swap a b * p).SameCycle x ((swap a b * p) x)
+    exact SameCycle.apply_right SameCycle.rfl
+  by_cases hxa : p x = a
+  · rw [hxa, swap_apply_left] at hx
+    exact hx.trans (hxa ▸ hlink.symm)
+  · by_cases hxb : p x = b
+    · rw [hxb, swap_apply_right] at hx
+      exact hx.trans (hxb ▸ hlink)
+    · rwa [swap_apply_of_ne_of_ne hxa hxb] at hx
+
+def mergedClass (p : Perm α) (a b : α) (x : α) : Cycles p :=
+  if cycleClass p x = cycleClass p b then cycleClass p a else cycleClass p x
+
+omit [Fintype α] in
+lemma cycleClass_apply (p : Perm α) (x : α) : cycleClass p (p x) = cycleClass p x := by
+  apply (cycleClass_eq _ _ _).mpr
+  exact SameCycle.apply_left SameCycle.rfl
+
+omit [Fintype α] in
+lemma mergedClass_step (p : Perm α) (a b : α) (hab : ¬ p.SameCycle a b) (x : α) :
+    mergedClass p a b ((swap a b * p) x) = mergedClass p a b x := by
+  have hne : cycleClass p a ≠ cycleClass p b := mt (cycleClass_eq p a b).mp hab
+  change mergedClass p a b (swap a b (p x)) = _
+  by_cases hxa : p x = a
+  · have hx : cycleClass p x = cycleClass p a := by
+      rw [← cycleClass_apply, hxa]
+    simp [mergedClass, hxa, hx, hne]
+  · by_cases hxb : p x = b
+    · have hx : cycleClass p x = cycleClass p b := by
+        rw [← cycleClass_apply, hxb]
+      simp [mergedClass, hxb, hx, hne]
+    · simp [swap_apply_of_ne_of_ne hxa hxb, mergedClass, cycleClass_apply]
+
+lemma mergedClass_cycle (p : Perm α) (a b : α) (hab : ¬ p.SameCycle a b)
+    {x y : α} (hxy : (swap a b * p).SameCycle x y) :
+    mergedClass p a b x = mergedClass p a b y := by
+  obtain ⟨n, rfl⟩ := hxy.exists_nat_pow_eq
+  clear hxy
+  induction n with
+  | zero => rfl
+  | succ n ih =>
+    rw [pow_succ', Perm.mul_apply, mergedClass_step p a b hab]
+    exact ih
+
+def mergeCycleEquiv (p : Perm α) (a b : α) (hab : ¬ p.SameCycle a b) :
+    Cycles (swap a b * p) ≃ {c : Cycles p // c ≠ cycleClass p b} where
+  toFun := Quotient.lift (fun x => ⟨mergedClass p a b x, by
+    have hne : cycleClass p a ≠ cycleClass p b := mt (cycleClass_eq p a b).mp hab
+    simp only [mergedClass]
+    split_ifs with h <;> assumption⟩)
+    (fun _ _ h => Subtype.ext (mergedClass_cycle p a b hab h))
+  invFun c := Quotient.map' id (fun _ _ h => sameCycle_swap_mul p a b hab h) c.val
+  left_inv c := by
+    induction c using Quotient.inductionOn with
+    | h x =>
+      change Quotient.map' id _ (mergedClass p a b x) = cycleClass (swap a b * p) x
+      unfold mergedClass
+      split_ifs with hx
+      · apply (cycleClass_eq _ _ _).mpr
+        exact (swap_mul_sameCycle p a b hab).trans
+          (sameCycle_swap_mul p a b hab ((cycleClass_eq _ _ _).mp hx).symm)
+      · rfl
+  right_inv c := by
+    apply Subtype.ext
+    rcases c with ⟨c, hc⟩
+    induction c using Quotient.inductionOn with
+    | h x =>
+      change mergedClass p a b x = cycleClass p x
+      change cycleClass p x ≠ cycleClass p b at hc
+      simp [mergedClass, hc]
+
+lemma swap_mul_cycles_card (p : Perm α) (a b : α) (hab : ¬ p.SameCycle a b) :
+    Nat.card (Cycles (swap a b * p)) + 1 = Nat.card (Cycles p) := by
+  have h := Fintype.card_congr (mergeCycleEquiv p a b hab)
+  rw [Fintype.card_subtype_compl, Fintype.card_subtype_eq] at h
+  have hp : 0 < Fintype.card (Cycles p) := Fintype.card_pos_iff.mpr ⟨cycleClass p a⟩
+  simp only [Nat.card_eq_fintype_card]
+  omega
+
+lemma mergeWhite_spherical (R : Ribbon α) (hR : R.Spherical) (e : α)
+    (he : ¬ R.white.SameCycle e (R.black e)) : (R.mergeWhite e).Spherical := by
+  have hn : ¬ R.white.SameCycle e (R.face e) := by
+    simpa [Ribbon.face] using he
+  have hne : R.face e ≠ e := by
+    intro h
+    apply hn
+    rw [h]
+  have hw := swap_mul_cycles_card R.white e (R.face e) hn
+  have hf := unplug_cycles_card R.face e hne
+  unfold Ribbon.Spherical at *
+  change Nat.card (Cycles R.black) +
+    Nat.card (Cycles (swap e (R.face e) * R.white)) + _ = _
+  rw [mergeWhite_face]
+  change Nat.card (Cycles R.black) +
+    Nat.card (Cycles (swap e (R.face e) * R.white)) +
+    Nat.card (Cycles (unplug R.face e)) = Fintype.card α + 2
+  omega
+
+theorem euler_contradiction (R : Ribbon α) (hR : R.Spherical)
+    (w : Cycles R.white) (f : Cycles R.face)
+    (hb : ∀ c : Cycles R.black, 3 ≤ (cycleSet R.black c).card)
+    (hw : ∀ c : Cycles R.white, 2 ≤ (cycleSet R.white c).card + if c = w then 1 else 0)
+    (hf : ∀ c : Cycles R.face, 6 ≤ (cycleSet R.face c).card + if c = f then 6 else 0) :
+    False := by
+  have hb' := Finset.sum_le_sum (fun c (_ : c ∈ (Finset.univ : Finset (Cycles R.black))) => hb c)
+  have hw' := Finset.sum_le_sum (fun c (_ : c ∈ (Finset.univ : Finset (Cycles R.white))) => hw c)
+  have hf' := Finset.sum_le_sum (fun c (_ : c ∈ (Finset.univ : Finset (Cycles R.face))) => hf c)
+  simp only [Finset.sum_const, Finset.card_univ, smul_eq_mul, cycles_sum_card] at hb'
+  simp only [Finset.sum_const, Finset.card_univ, smul_eq_mul, Finset.sum_add_distrib,
+    cycles_sum_card, Finset.sum_ite_eq', Finset.mem_univ, ite_true] at hw' hf'
+  unfold Ribbon.Spherical at hR
+  simp only [Nat.card_eq_fintype_card] at hR
+  omega
+
+end OddKaplansky.Planar
+
+namespace OddKaplansky.Planar
+open Equiv Equiv.Perm
+attribute [local simp] SameCycle.rfl
+variable {α : Type portUniverse4} [Fintype α]
+
+lemma sameCycle_map_quotient {p q : Perm α}
+    (h : ∀ {x y}, p.SameCycle x y → q.SameCycle x y) :
+    Nat.card (Cycles q) ≤ Nat.card (Cycles p) := by
+  exact Nat.card_le_card_of_surjective (Quotient.map id (fun _ _ hxy => h hxy))
+    (Quotient.map_surjective _ Function.surjective_id)
+
+lemma swap_cycles_card_le (p : Perm α) (a b : α) :
+    Nat.card (Cycles (swap a b * p)) ≤ Nat.card (Cycles p) + 1 := by
+  let q := swap a b * p
+  have hrev : swap a b * q = p := by simp [q, ← mul_assoc]
+  by_cases hab : q.SameCycle a b
+  · have href : ∀ {x y}, p.SameCycle x y → q.SameCycle x y := by
+      intro x y h
+      apply sameCycle_map p q id _ h
+      intro x
+      have hx : q.SameCycle x (q x) := by simp
+      have hp : p x = swap a b (q x) := by
+        rw [← Perm.mul_apply, hrev]
+      rw [hp]
+      by_cases hxa : q x = a
+      · rw [hxa] at hx
+        simpa [hxa] using hx.trans hab
+      · by_cases hxb : q x = b
+        · rw [hxb] at hx
+          simpa [hxb] using hx.trans hab.symm
+        · rwa [swap_apply_of_ne_of_ne hxa hxb]
+    exact (sameCycle_map_quotient href).trans (Nat.le_succ _)
+  · have h := swap_mul_cycles_card q a b hab
+    rw [hrev] at h
+    change Nat.card (Cycles q) ≤ _
+    omega
+
+lemma cycles_card_le (p : Perm α) : Nat.card (Cycles p) ≤ Fintype.card α := by
+  simpa using Nat.card_le_card_of_surjective (cycleClass p) Quotient.mk_surjective
+
+lemma cycles_one_card : Nat.card (Cycles (1 : Perm α)) = Fintype.card α := by
+  have heq : SameCycle.setoid (1 : Perm α) = ⊥ := by
+    ext x y
+    exact sameCycle_one
+  rw [Cycles, heq]
+  exact (Nat.card_congr Setoid.quotientBotEquiv).trans (Nat.card_eq_fintype_card)
+
+lemma exists_cycle_factorization (p : Perm α) :
+    ∃ l : List (α × α),
+      (l.map fun ab => swap ab.1 ab.2).prod = p ∧
+      l.length + Nat.card (Cycles p) = Fintype.card α ∧
+      ∀ ab ∈ l, ab.1 ≠ ab.2 ∧ p.SameCycle ab.1 ab.2 := by
+  have hmain : ∀ n : ℕ, ∀ p : Perm α,
+      Fintype.card α - Nat.card (Cycles p) = n →
+      ∃ l : List (α × α),
+        (l.map fun ab => swap ab.1 ab.2).prod = p ∧
+        l.length + Nat.card (Cycles p) = Fintype.card α ∧
+        ∀ ab ∈ l, ab.1 ≠ ab.2 ∧ p.SameCycle ab.1 ab.2 := by
+    intro n
+    induction n using Nat.strong_induction_on with
+    | h n ih =>
+      intro p hn
+      by_cases hp : p = 1
+      · subst p
+        exact ⟨[], by simp, by simpa using cycles_one_card (α := α), by simp⟩
+      · have hex : ∃ a, p a ≠ a := by
+          by_contra! h
+          exact hp (Equiv.ext h)
+        obtain ⟨a, ha⟩ := hex
+        have hc := unplug_cycles_card p a ha
+        have hle := cycles_card_le (unplug p a)
+        have hlt : Fintype.card α - Nat.card (Cycles (unplug p a)) < n := by omega
+        obtain ⟨l, hl, hlen, hmem⟩ := ih _ hlt (unplug p a) rfl
+        refine ⟨(a, p a) :: l, ?_, ?_, ?_⟩
+        · simp only [List.map_cons, List.prod_cons, hl]
+          simp [unplug, ← mul_assoc]
+        · simp only [List.length_cons]
+          omega
+        · intro ab hab
+          rcases List.mem_cons.mp hab with rfl | hab
+          · exact ⟨Ne.symm ha, by simp⟩
+          · exact ⟨(hmem ab hab).1, unplug_sameCycle p a (hmem ab hab).2⟩
+  exact hmain _ p rfl
+
+end OddKaplansky.Planar
+
+namespace OddKaplansky.Planar
+open Equiv Equiv.Perm
+variable {α : Type portUniverse5}
+
+def mergeClass (s : Setoid α) (a b x : α) : Quotient s :=
+  if Quotient.mk s x = Quotient.mk s b then Quotient.mk s a else Quotient.mk s x
+
+def joinPair (s : Setoid α) (a b : α) : Setoid α := Setoid.ker (mergeClass s a b)
+
+lemma le_joinPair (s : Setoid α) (a b : α) : s ≤ joinPair s a b := by
+  intro x y hxy
+  change mergeClass s a b x = mergeClass s a b y
+  simp only [mergeClass, Quotient.sound hxy]
+
+lemma joinPair_related (s : Setoid α) (a b : α) : (joinPair s a b).r a b := by
+  change mergeClass s a b a = mergeClass s a b b
+  simp [mergeClass]
+
+lemma joinPair_eq_of_related (s : Setoid α) {a b : α} (hab : s.r a b) :
+    joinPair s a b = s := by
+  ext x y
+  have h : ∀ x, mergeClass s a b x = Quotient.mk s x := by
+    intro x
+    simp only [mergeClass, ← Quotient.sound hab]
+    split_ifs with hx
+    · exact hx.symm
+    · rfl
+  change mergeClass s a b x = mergeClass s a b y ↔ s.r x y
+  rw [h, h, Quotient.eq]
+
+lemma joinPair_le (s t : Setoid α) (a b : α) (hst : s ≤ t) (hab : t.r a b) :
+    joinPair s a b ≤ t := by
+  intro x y hxy
+  change mergeClass s a b x = mergeClass s a b y at hxy
+  by_cases hx : Quotient.mk s x = Quotient.mk s b
+  · by_cases hy : Quotient.mk s y = Quotient.mk s b
+    · exact t.iseqv.trans (hst (Quotient.exact hx)) (t.iseqv.symm (hst (Quotient.exact hy)))
+    · simp only [mergeClass, hx, hy, ite_true, ite_false] at hxy
+      exact t.iseqv.trans (t.iseqv.trans (hst (Quotient.exact hx)) (t.iseqv.symm hab)) (hst (Quotient.exact hxy))
+  · by_cases hy : Quotient.mk s y = Quotient.mk s b
+    · simp only [mergeClass, hx, hy, ite_true, ite_false] at hxy
+      exact t.iseqv.trans (t.iseqv.trans (hst (Quotient.exact hxy)) hab) (t.iseqv.symm (hst (Quotient.exact hy)))
+    · simp only [mergeClass, hx, hy, ite_false] at hxy
+      exact hst (Quotient.exact hxy)
+
+def joinPairEquiv (s : Setoid α) (a b : α) (hab : ¬ s.r a b) :
+    Quotient (joinPair s a b) ≃ {c : Quotient s // c ≠ Quotient.mk s b} where
+  toFun := Quotient.lift (fun x => ⟨mergeClass s a b x, by
+    have hne : Quotient.mk s a ≠ Quotient.mk s b := fun h => hab (Quotient.exact h)
+    simp only [mergeClass]
+    split_ifs with hx <;> assumption⟩) (fun _ _ h => Subtype.ext h)
+  invFun c := Quotient.map id (fun _ _ h => le_joinPair s a b h) c.val
+  left_inv c := by
+    induction c using Quotient.inductionOn with
+    | h x =>
+      change Quotient.map id _ (mergeClass s a b x) = Quotient.mk _ x
+      unfold mergeClass
+      split_ifs with hx
+      · apply Quotient.sound
+        exact (joinPair s a b).iseqv.trans (joinPair_related s a b) (le_joinPair s a b (s.iseqv.symm (Quotient.exact hx)))
+      · rfl
+  right_inv c := by
+    rcases c with ⟨c, hc⟩
+    apply Subtype.ext
+    induction c using Quotient.inductionOn with
+    | h x =>
+      change mergeClass s a b x = Quotient.mk s x
+      simp [mergeClass, hc]
+
+lemma joinPair_card [Fintype α] (s : Setoid α) (a b : α) (hab : ¬ s.r a b) :
+    Nat.card (Quotient (joinPair s a b)) + 1 = Nat.card (Quotient s) := by
+  have h := Fintype.card_congr (joinPairEquiv s a b hab)
+  rw [Fintype.card_subtype_compl, Fintype.card_subtype_eq] at h
+  have hp : 0 < Fintype.card (Quotient s) := Fintype.card_pos_iff.mpr ⟨Quotient.mk s a⟩
+  simp only [Nat.card_eq_fintype_card]
+  omega
+
+lemma setoid_swap_related (s : Setoid α) {a b : α} (hab : s.r a b) (x : α) :
+    s.r x (swap a b x) := by
+  by_cases ha : x = a
+  · subst x
+    simpa using hab
+  · by_cases hb : x = b
+    · subst x
+      simpa using s.iseqv.symm hab
+    · rw [swap_apply_of_ne_of_ne ha hb]
+
+lemma setoid_sameCycle_of_step [Fintype α] (s : Setoid α) (p : Perm α)
+    (hstep : ∀ x, s.r x (p x)) {x y : α} (hxy : p.SameCycle x y) : s.r x y := by
+  obtain ⟨n, rfl⟩ := hxy.exists_nat_pow_eq
+  clear hxy
+  induction n with
+  | zero => exact s.iseqv.refl _
+  | succ n ih =>
+    rw [pow_succ', Perm.mul_apply]
+    exact s.iseqv.trans ih (hstep _)
+
+def edgePartition : List (α × α) → Setoid α
+  | [] => ⊥
+  | (a, b) :: l => joinPair (edgePartition l) a b
+
+lemma edgePartition_le {l : List (α × α)} {s : Setoid α}
+    (h : ∀ ab ∈ l, s.r ab.1 ab.2) : edgePartition l ≤ s := by
+  induction l with
+  | nil => exact bot_le
+  | cons ab l ih =>
+    exact joinPair_le _ _ _ _ (ih fun ab hab => h ab (List.mem_cons_of_mem _ hab))
+      (h ab List.mem_cons_self)
+
+lemma edgePartition_pair {l : List (α × α)} {ab : α × α} (h : ab ∈ l) :
+    (edgePartition l).r ab.1 ab.2 := by
+  induction l with
+  | nil => simp at h
+  | cons cd l ih =>
+    rcases List.mem_cons.mp h with rfl | h
+    · exact joinPair_related _ _ _
+    · exact le_joinPair _ _ _ (ih h)
+
+lemma edgePartition_prod (l : List (α × α)) (x : α) :
+    (edgePartition l).r x ((l.map fun ab => swap ab.1 ab.2).prod x) := by
+  induction l with
+  | nil => exact (⊥ : Setoid α).iseqv.refl x
+  | cons ab l ih =>
+    simp only [List.map_cons, List.prod_cons, Perm.mul_apply]
+    exact (edgePartition (ab :: l)).iseqv.trans (le_joinPair _ _ _ ih)
+      (setoid_swap_related (edgePartition (ab :: l)) (joinPair_related _ _ _) _)
+
+lemma transposition_euler_bound [Fintype α] (l : List (α × α)) :
+    Fintype.card α + Nat.card (Cycles (l.map fun ab => swap ab.1 ab.2).prod) ≤
+      l.length + 2 * Nat.card (Quotient (edgePartition l)) := by
+  induction l with
+  | nil =>
+    change Fintype.card α + Nat.card (Cycles (1 : Perm α)) ≤
+      0 + 2 * Nat.card (Quotient (⊥ : Setoid α))
+    rw [cycles_one_card, Nat.card_congr Setoid.quotientBotEquiv, Nat.card_eq_fintype_card]
+    omega
+  | cons ab l ih =>
+    let p := (l.map fun ab => swap ab.1 ab.2).prod
+    change Fintype.card α + Nat.card (Cycles (swap ab.1 ab.2 * p)) ≤
+      (l.length + 1) + 2 * Nat.card (Quotient (joinPair (edgePartition l) ab.1 ab.2))
+    by_cases h : (edgePartition l).r ab.1 ab.2
+    · rw [joinPair_eq_of_related _ h]
+      have hc := swap_cycles_card_le p ab.1 ab.2
+      change Fintype.card α + Nat.card (Cycles p) ≤ _ at ih
+      omega
+    · have hab : ¬ p.SameCycle ab.1 ab.2 := by
+        intro hc
+        exact h (setoid_sameCycle_of_step (edgePartition l) p (edgePartition_prod l) hc)
+      have hc := swap_mul_cycles_card p ab.1 ab.2 hab
+      have hs := joinPair_card (edgePartition l) ab.1 ab.2 h
+      change Fintype.card α + Nat.card (Cycles p) ≤ _ at ih
+      omega
+
+end OddKaplansky.Planar
+
+namespace OddKaplansky.Planar
+open Equiv Equiv.Perm
+variable {α : Type portUniverse6} [Fintype α]
+
+lemma quotient_card_antitone {s t : Setoid α} (h : s ≤ t) :
+    Nat.card (Quotient t) ≤ Nat.card (Quotient s) := by
+  exact Nat.card_le_card_of_surjective (Quotient.map id (fun _ _ hxy => h hxy))
+    (Quotient.map_surjective _ Function.surjective_id)
+
+def Ribbon.components (R : Ribbon α) : Setoid α :=
+  SameCycle.setoid R.black ⊔ SameCycle.setoid R.white
+
+omit [Fintype α] in
+lemma cycles_inv_card (p : Perm α) : Nat.card (Cycles p⁻¹) = Nat.card (Cycles p) := by
+  have h : SameCycle.setoid p⁻¹ = SameCycle.setoid p := by
+    ext a b
+    exact sameCycle_inv
+  unfold Cycles
+  rw [h]
+
+theorem Ribbon.euler_le (R : Ribbon α) :
+    Nat.card (Cycles R.black) + Nat.card (Cycles R.white) + Nat.card (Cycles R.face) ≤
+      Fintype.card α + 2 * Nat.card (Quotient R.components) := by
+  obtain ⟨lb, hb, hblen, _⟩ := exists_cycle_factorization R.black
+  obtain ⟨lw, hw, hwlen, _⟩ := exists_cycle_factorization R.white
+  obtain ⟨lf, hf, hflen, _⟩ := exists_cycle_factorization R.face⁻¹
+  rw [cycles_inv_card] at hflen
+  let l := lw ++ lb ++ lf
+  have hl : (l.map fun ab => swap ab.1 ab.2).prod = 1 := by
+    simp only [l, List.map_append, List.prod_append, hb, hw, hf]
+    change R.face * R.face⁻¹ = 1
+    exact mul_inv_cancel _
+  have hbl : edgePartition lb ≤ edgePartition l := by
+    apply edgePartition_le
+    intro ab hab
+    apply edgePartition_pair
+    simp [l, hab]
+  have hwl : edgePartition lw ≤ edgePartition l := by
+    apply edgePartition_le
+    intro ab hab
+    apply edgePartition_pair
+    simp [l, hab]
+  have hcomp : R.components ≤ edgePartition l := by
+    apply sup_le
+    · intro x y hxy
+      apply setoid_sameCycle_of_step (edgePartition l) R.black _ hxy
+      intro x
+      rw [← hb]
+      exact hbl (edgePartition_prod lb x)
+    · intro x y hxy
+      apply setoid_sameCycle_of_step (edgePartition l) R.white _ hxy
+      intro x
+      rw [← hw]
+      exact hwl (edgePartition_prod lw x)
+  have hc := quotient_card_antitone hcomp
+  have hbound := transposition_euler_bound l
+  rw [hl, cycles_one_card] at hbound
+  have hlen : l.length = lw.length + lb.length + lf.length := by simp [l, Nat.add_assoc]
+  omega
+
+end OddKaplansky.Planar
+
+namespace OddKaplansky.Planar
+open Equiv Equiv.Perm
+variable {α : Type portUniverse7}
+
+def restrictQuotient (s : Setoid α) (P : α → Prop) :
+    Quotient (s.comap (Subtype.val : {x // P x} → α)) → Quotient s :=
+  Quotient.map Subtype.val (fun _ _ h => h)
+
+lemma restrictQuotient_injective (s : Setoid α) (P : α → Prop) :
+    Function.Injective (restrictQuotient s P) := by
+  intro x y
+  induction x, y using Quotient.inductionOn₂ with
+  | h x y =>
+    intro h
+    change Quotient.mk s x.val = Quotient.mk s y.val at h
+    apply Quotient.sound
+    change s.r x.val y.val
+    exact Quotient.exact h
+
+def quotientRestrictSumEquiv (s : Setoid α) (P : α → Prop)
+    (hP : ∀ {x y}, s.r x y → (P x ↔ P y)) :
+    (Quotient (s.comap (Subtype.val : {x // P x} → α)) ⊕
+      Quotient (s.comap (Subtype.val : {x // ¬ P x} → α))) ≃ Quotient s :=
+  Equiv.ofBijective (Sum.elim (restrictQuotient s P) (restrictQuotient s (fun x => ¬ P x))) (by
+    constructor
+    · intro a b hab
+      cases a with
+      | inl a =>
+        cases b with
+        | inl b => exact congrArg Sum.inl (restrictQuotient_injective s P hab)
+        | inr b =>
+          induction a, b using Quotient.inductionOn₂ with
+          | h a b => exact (b.prop ((hP (Quotient.exact hab)).mp a.prop)).elim
+      | inr a =>
+        cases b with
+        | inl b =>
+          induction a, b using Quotient.inductionOn₂ with
+          | h a b => exact (a.prop ((hP (Quotient.exact hab)).mpr b.prop)).elim
+        | inr b => exact congrArg Sum.inr (restrictQuotient_injective s _ hab)
+    · intro c
+      induction c using Quotient.inductionOn with
+      | h x =>
+        by_cases hx : P x
+        · exact ⟨Sum.inl (Quotient.mk _ ⟨x, hx⟩), rfl⟩
+        · exact ⟨Sum.inr (Quotient.mk _ ⟨x, hx⟩), rfl⟩)
+
+lemma quotient_restrict_card_split [Fintype α] (s : Setoid α) (P : α → Prop)
+    (hP : ∀ {x y}, s.r x y → (P x ↔ P y)) :
+    Nat.card (Quotient (s.comap (Subtype.val : {x // P x} → α))) +
+      Nat.card (Quotient (s.comap (Subtype.val : {x // ¬ P x} → α))) =
+      Nat.card (Quotient s) := by
+  simpa only [Nat.card_sum] using Nat.card_congr (quotientRestrictSumEquiv s P hP)
+
+variable [Fintype α]
+
+lemma perm_invariant_cycle (p : Perm α) (P : α → Prop) (hP : ∀ x, P (p x) ↔ P x)
+    {x y : α} (hxy : p.SameCycle x y) : P x ↔ P y := by
+  exact Iff.of_eq (setoid_sameCycle_of_step (Setoid.ker P) p
+    (fun x => propext (hP x).symm) hxy)
+
+omit [Fintype α] in
+lemma subtype_cycles_setoid (p : Perm α) (P : α → Prop) (hP : ∀ x, P (p x) ↔ P x) :
+    SameCycle.setoid (p.subtypePerm hP) =
+      (SameCycle.setoid p).comap (Subtype.val : {x // P x} → α) := by
+  ext x y
+  exact sameCycle_subtypePerm
+
+lemma cycles_restrict_card_split (p : Perm α) (P : α → Prop) (hP : ∀ x, P (p x) ↔ P x) :
+    Nat.card (Cycles (p.subtypePerm hP)) +
+      Nat.card (Cycles (p.subtypePerm (p := fun x => ¬ P x) fun x => not_congr (hP x))) = Nat.card (Cycles p) := by
+  unfold Cycles
+  rw [subtype_cycles_setoid, subtype_cycles_setoid]
+  exact quotient_restrict_card_split _ P (perm_invariant_cycle p P hP)
+
+def Ribbon.restrict (R : Ribbon α) (P : α → Prop)
+    (hb : ∀ x, P (R.black x) ↔ P x) (hw : ∀ x, P (R.white x) ↔ P x) :
+    Ribbon {x // P x} where
+  black := R.black.subtypePerm hb
+  white := R.white.subtypePerm hw
+
+omit [Fintype α] in
+lemma Ribbon.restrict_face (R : Ribbon α) (P : α → Prop) (hb hw) :
+    (R.restrict P hb hw).face = R.face.subtypePerm (fun x => (hw _).trans (hb x)) := rfl
+
+lemma Ribbon.invariant_components (R : Ribbon α) (P : α → Prop)
+    (hb : ∀ x, P (R.black x) ↔ P x) (hw : ∀ x, P (R.white x) ↔ P x)
+    {x y : α} (hxy : R.components.r x y) : P x ↔ P y := by
+  have h : R.components ≤ Setoid.ker P := by
+    apply sup_le
+    · exact fun _ _ h => propext (perm_invariant_cycle R.black P hb h)
+    · exact fun _ _ h => propext (perm_invariant_cycle R.white P hw h)
+  exact Iff.of_eq (h hxy)
+
+lemma Ribbon.restrict_components (R : Ribbon α) (P : α → Prop) (hb hw) :
+    (R.restrict P hb hw).components =
+      R.components.comap (Subtype.val : {x // P x} → α) := by
+  apply le_antisymm
+  · apply sup_le
+    · intro x y h
+      exact (show SameCycle.setoid R.black ≤ R.components from le_sup_left) ((sameCycle_subtypePerm (h := hb)).mp h)
+    · intro x y h
+      exact (show SameCycle.setoid R.white ≤ R.components from le_sup_right) ((sameCycle_subtypePerm (h := hw)).mp h)
+  · intro x y hxy
+    change R.components.r x.val y.val at hxy
+    have hmain : ∀ {a b : α}, R.components.r a b → ∀ (ha : P a) (hb' : P b),
+        (R.restrict P hb hw).components.r ⟨a, ha⟩ ⟨b, hb'⟩ := by
+      intro a b h
+      rw [Ribbon.components, Setoid.sup_def] at h
+      change Relation.EqvGen (fun a b => R.black.SameCycle a b ∨ R.white.SameCycle a b) a b at h
+      induction h with
+      | rel a b hab =>
+        intro ha hb'
+        rcases hab with hab | hab
+        · exact (show SameCycle.setoid (R.restrict P hb hw).black ≤ (R.restrict P hb hw).components from le_sup_left) ((sameCycle_subtypePerm (h := hb)).mpr hab)
+        · exact (show SameCycle.setoid (R.restrict P hb hw).white ≤ (R.restrict P hb hw).components from le_sup_right) ((sameCycle_subtypePerm (h := hw)).mpr hab)
+      | refl a => exact fun _ _ => (R.restrict P hb hw).components.iseqv.refl _
+      | symm a b hab ih =>
+        intro ha hb'
+        exact (R.restrict P hb hw).components.iseqv.symm (ih hb' ha)
+      | trans a b c hab hbc ihab ihbc =>
+        intro ha hc
+        have hab' : R.components.r a b := by
+          rw [Ribbon.components, Setoid.sup_def]
+          exact hab
+        have hb' : P b := (R.invariant_components P hb hw hab').mp ha
+        exact (R.restrict P hb hw).components.iseqv.trans (ihab ha hb') (ihbc hb' hc)
+    exact hmain hxy x.prop y.prop
+
+def Ribbon.GenusZero (R : Ribbon α) : Prop :=
+  Nat.card (Cycles R.black) + Nat.card (Cycles R.white) + Nat.card (Cycles R.face) =
+    Fintype.card α + 2 * Nat.card (Quotient R.components)
+
+lemma Ribbon.planar_restrict (R : Ribbon α) (hR : R.GenusZero) (P : α → Prop) (hb hw) :
+    (R.restrict P hb hw).GenusZero := by
+  let S := R.restrict P hb hw
+  let T := R.restrict (fun x => ¬ P x) (fun x => not_congr (hb x)) (fun x => not_congr (hw x))
+  have hs := S.euler_le
+  have ht := T.euler_le
+  have hbc := cycles_restrict_card_split R.black P hb
+  have hwc := cycles_restrict_card_split R.white P hw
+  have hfc := cycles_restrict_card_split R.face P (fun x => (hw _).trans (hb x))
+  have hcc := quotient_restrict_card_split R.components P (R.invariant_components P hb hw)
+  rw [← R.restrict_components P hb hw,
+    ← R.restrict_components (fun x => ¬ P x) (fun x => not_congr (hb x))
+      (fun x => not_congr (hw x))] at hcc
+  have hec : Fintype.card {x // P x} + Fintype.card {x // ¬ P x} = Fintype.card α := by
+    have h := Fintype.card_subtype_compl P
+    have hle := Fintype.card_subtype_le P
+    omega
+  change Nat.card (Cycles S.black) + Nat.card (Cycles T.black) = _ at hbc
+  change Nat.card (Cycles S.white) + Nat.card (Cycles T.white) = _ at hwc
+  change Nat.card (Cycles S.face) + Nat.card (Cycles T.face) = _ at hfc
+  change Nat.card (Quotient S.components) + Nat.card (Quotient T.components) = _ at hcc
+  unfold Ribbon.GenusZero at hR ⊢
+  change Nat.card (Cycles S.black) + Nat.card (Cycles S.white) + Nat.card (Cycles S.face) =
+    Fintype.card {x // P x} + 2 * Nat.card (Quotient S.components)
+  omega
+
+end OddKaplansky.Planar
+
+namespace OddKaplansky.Planar
+open Equiv Equiv.Perm
+attribute [local simp] SameCycle.rfl
+variable {α : Type portUniverse8} [Fintype α]
+
+omit [Fintype α] in
+lemma Ribbon.black_step (R : Ribbon α) (x : α) : R.components.r x (R.black x) :=
+  (show SameCycle.setoid R.black ≤ R.components from le_sup_left) (show R.black.SameCycle x (R.black x) from SameCycle.apply_right SameCycle.rfl)
+
+omit [Fintype α] in
+lemma Ribbon.white_step (R : Ribbon α) (x : α) : R.components.r x (R.white x) :=
+  (show SameCycle.setoid R.white ≤ R.components from le_sup_right) (show R.white.SameCycle x (R.white x) from SameCycle.apply_right SameCycle.rfl)
+
+lemma Ribbon.components_le_of_steps (R : Ribbon α) (s : Setoid α)
+    (hb : ∀ x, s.r x (R.black x)) (hw : ∀ x, s.r x (R.white x)) : R.components ≤ s := by
+  exact sup_le (fun _ _ h => setoid_sameCycle_of_step s R.black hb h)
+    (fun _ _ h => setoid_sameCycle_of_step s R.white hw h)
+
+omit [Fintype α] in
+lemma Ribbon.black_component_invariant (R : Ribbon α) (a x : α) :
+    R.components.r (R.black x) a ↔ R.components.r x a := by
+  constructor
+  · exact R.components.iseqv.trans (R.black_step x)
+  · exact R.components.iseqv.trans (R.components.iseqv.symm (R.black_step x))
+
+omit [Fintype α] in
+lemma Ribbon.white_component_invariant (R : Ribbon α) (a x : α) :
+    R.components.r (R.white x) a ↔ R.components.r x a := by
+  constructor
+  · exact R.components.iseqv.trans (R.white_step x)
+  · exact R.components.iseqv.trans (R.components.iseqv.symm (R.white_step x))
+
+def Ribbon.keepComponent (R : Ribbon α) (a : α) : Ribbon {x // R.components.r x a} :=
+  R.restrict (fun x => R.components.r x a) (R.black_component_invariant a)
+    (R.white_component_invariant a)
+
+lemma Ribbon.keepComponent_card (R : Ribbon α) (a : α) :
+    Nat.card (Quotient (R.keepComponent a).components) = 1 := by
+  apply Nat.card_eq_one_iff_exists.mpr
+  refine ⟨Quotient.mk _ ⟨a, R.components.iseqv.refl a⟩, ?_⟩
+  intro c
+  induction c using Quotient.inductionOn with
+  | h x =>
+    apply Quotient.sound
+    change (R.restrict _ _ _).components.r x ⟨a, _⟩
+    rw [R.restrict_components]
+    exact x.prop
+
+lemma Ribbon.spherical_keepComponent (R : Ribbon α) (hR : R.GenusZero) (a : α) :
+    (R.keepComponent a).Spherical := by
+  have h := R.planar_restrict hR (fun x => R.components.r x a)
+    (R.black_component_invariant a) (R.white_component_invariant a)
+  change (R.keepComponent a).GenusZero at h
+  unfold Ribbon.GenusZero at h
+  rw [R.keepComponent_card] at h
+  exact h
+
+omit [Fintype α] in
+lemma joinPair_left_iff (s : Setoid α) (a b y : α) :
+    (joinPair s a b).r a y ↔ s.r a y ∨ s.r b y := by
+  change mergeClass s a b a = mergeClass s a b y ↔ _
+  have ha : mergeClass s a b a = Quotient.mk s a := by simp [mergeClass]
+  rw [ha]
+  by_cases hy : Quotient.mk s y = Quotient.mk s b
+  · simp only [mergeClass, hy, ite_true, true_iff]
+    exact Or.inr (s.iseqv.symm (Quotient.exact hy))
+  · simp only [mergeClass, hy, ite_false, Quotient.eq]
+    exact or_iff_left (fun h => hy (Quotient.sound (s.iseqv.symm h))) |>.symm
+
+def Ribbon.detach (R : Ribbon α) (a : α) : Ribbon α where
+  black := unplug R.black a
+  white := unplug R.white a
+
+omit [Fintype α] in
+lemma Ribbon.detach_fixed_black (R : Ribbon α) (a : α) : (R.detach a).black a = a :=
+  unplug_fixed _ _
+omit [Fintype α] in
+lemma Ribbon.detach_fixed_white (R : Ribbon α) (a : α) : (R.detach a).white a = a :=
+  unplug_fixed _ _
+
+lemma Ribbon.detach_isolated (R : Ribbon α) (a : α) {x : α}
+    (h : (R.detach a).components.r a x) : x = a := by
+  have hb : ∀ x, (R.detach a).black x = a ↔ x = a := by
+    intro x
+    constructor
+    · intro h
+      apply (R.detach a).black.injective
+      simpa only [R.detach_fixed_black] using h
+    · intro hx
+      simpa only [hx] using R.detach_fixed_black a
+  have hw : ∀ x, (R.detach a).white x = a ↔ x = a := by
+    intro x
+    constructor
+    · intro h
+      apply (R.detach a).white.injective
+      simpa only [R.detach_fixed_white] using h
+    · intro hx
+      simpa only [hx] using R.detach_fixed_white a
+  exact ((R.detach a).invariant_components (fun x => x = a) hb hw h).mp rfl
+
+lemma Ribbon.detach_components_le (R : Ribbon α) (a : α) :
+    (R.detach a).components ≤ R.components := by
+  apply sup_le
+  · exact fun _ _ h => (show SameCycle.setoid R.black ≤ R.components from le_sup_left)
+      (unplug_sameCycle R.black a h)
+  · exact fun _ _ h => (show SameCycle.setoid R.white ≤ R.components from le_sup_right)
+      (unplug_sameCycle R.white a h)
+
+lemma Ribbon.components_detach (R : Ribbon α) (a : α) :
+    R.components = joinPair (joinPair (R.detach a).components a (R.black a)) a (R.white a) := by
+  let s := (R.detach a).components
+  let t := joinPair (joinPair s a (R.black a)) a (R.white a)
+  apply le_antisymm
+  · apply R.components_le_of_steps t
+    · intro x
+      have hstep : t.r x ((R.detach a).black x) :=
+        le_joinPair _ _ _ (le_joinPair _ _ _ ((R.detach a).black_step x))
+      have hab : t.r a (R.black a) := le_joinPair _ _ _ (joinPair_related _ _ _)
+      have hback : swap a (R.black a) ((R.detach a).black x) = R.black x := by
+        simp [Ribbon.detach, unplug]
+      rw [← hback]
+      exact t.iseqv.trans hstep (setoid_swap_related t hab _)
+    · intro x
+      have hstep : t.r x ((R.detach a).white x) :=
+        le_joinPair _ _ _ (le_joinPair _ _ _ ((R.detach a).white_step x))
+      have hab : t.r a (R.white a) := joinPair_related _ _ _
+      have hback : swap a (R.white a) ((R.detach a).white x) = R.white x := by
+        simp [Ribbon.detach, unplug]
+      rw [← hback]
+      exact t.iseqv.trans hstep (setoid_swap_related t hab _)
+  · apply joinPair_le
+    · exact joinPair_le _ _ _ _ (R.detach_components_le a) (R.black_step a)
+    · exact R.white_step a
+
+omit [Fintype α] in
+lemma Ribbon.detach_face (R : Ribbon α) (a : α) :
+    (R.detach a).face = swap a (R.white a) * swap (R.white a) (R.face a) * R.face := by
+  simp only [Ribbon.detach, Ribbon.face, unplug, mul_assoc]
+  rw [← mul_assoc R.white (swap a (R.black a)), mul_swap_eq_swap_mul]
+  simp only [Perm.mul_apply, mul_assoc]
+
+omit [Fintype α] in
+lemma Ribbon.detach_face_of_face_fixed (R : Ribbon α) (a : α) (ha : R.face a = a) :
+    (R.detach a).face = R.face := by
+  rw [R.detach_face, ha, swap_comm (R.white a) a]
+  simp
+
+omit [Fintype α] in
+lemma Ribbon.detach_face_unplug (R : Ribbon α) (a : α)
+    (hw : R.white a ≠ a) (hf : R.face a ≠ a) :
+    (R.detach a).face = swap (R.white a) (R.face a) * unplug R.face a := by
+  rw [R.detach_face, swap_mul_eq_mul_swap]
+  have ha : swap (R.white a) (R.face a) a = a := swap_apply_of_ne_of_ne hw.symm hf.symm
+  simp only [swap_inv, ha, swap_apply_left, unplug, mul_assoc]
+
+lemma Ribbon.detach_face_card_le (R : Ribbon α) (a : α) (hw : R.white a ≠ a) :
+    Nat.card (Cycles R.face) ≤ Nat.card (Cycles (R.detach a).face) := by
+  by_cases hf : R.face a = a
+  · rw [R.detach_face_of_face_fixed a hf]
+  · have h := swap_cycles_card_le (R.detach a).face (R.white a) (R.face a)
+    rw [R.detach_face_unplug a hw hf] at h
+    simp only [← mul_assoc, swap_mul_self, one_mul] at h
+    have hc := unplug_cycles_card R.face a hf
+    rw [R.detach_face_unplug a hw hf]
+    omega
+
+end OddKaplansky.Planar
+
+namespace OddKaplansky.Planar
+open Equiv Equiv.Perm
+variable {α : Type portUniverse9} [Fintype α]
+
+omit [Fintype α] in
+lemma Ribbon.face_step (R : Ribbon α) (x : α) : R.components.r x (R.face x) :=
+  R.components.iseqv.trans (R.black_step x) (R.white_step (R.black x))
+
+lemma Ribbon.sameCycle_face_components (R : Ribbon α) {x y : α} (h : R.face.SameCycle x y) :
+    R.components.r x y := setoid_sameCycle_of_step R.components R.face R.face_step h
+
+lemma Ribbon.detach_components_card (R : Ribbon α) (a : α)
+    (hb : R.black a ≠ a) (hw : R.white a ≠ a) :
+    Nat.card (Quotient (R.detach a).components) = Nat.card (Quotient R.components) +
+      if (R.detach a).components.r (R.black a) (R.white a) then 1 else 2 := by
+  let s := (R.detach a).components
+  let t := joinPair s a (R.black a)
+  have hb' : ¬ s.r a (R.black a) := fun h => hb (R.detach_isolated a h)
+  have hw' : ¬ s.r a (R.white a) := fun h => hw (R.detach_isolated a h)
+  have ht : Nat.card (Quotient t) + 1 = Nat.card (Quotient s) := joinPair_card s _ _ hb'
+  have heq : R.components = joinPair t a (R.white a) := R.components_detach a
+  by_cases h : s.r (R.black a) (R.white a)
+  · have h' : t.r a (R.white a) := (joinPair_left_iff s _ _ _).mpr (Or.inr h)
+    rw [joinPair_eq_of_related _ h'] at heq
+    change Nat.card (Quotient s) = Nat.card (Quotient R.components) + if s.r (R.black a) (R.white a) then 1 else 2
+    simp only [h, ite_true, heq]
+    omega
+  · have h' : ¬ t.r a (R.white a) := by
+      rw [joinPair_left_iff]
+      exact not_or.mpr ⟨hw', h⟩
+    have ht' := joinPair_card t a (R.white a) h'
+    rw [← heq] at ht'
+    change Nat.card (Quotient s) = Nat.card (Quotient R.components) + if s.r (R.black a) (R.white a) then 1 else 2
+    simp only [h, ite_false]
+    omega
+
+lemma Ribbon.detach_components_card_black_fixed (R : Ribbon α) (a : α)
+    (hb : R.black a = a) (hw : R.white a ≠ a) :
+    Nat.card (Quotient (R.detach a).components) = Nat.card (Quotient R.components) + 1 := by
+  have hn : ¬ (R.detach a).components.r a (R.white a) := fun h => hw (R.detach_isolated a h)
+  have heq := R.components_detach a
+  rw [hb, joinPair_eq_of_related _ ((R.detach a).components.iseqv.refl a)] at heq
+  have hc := joinPair_card (R.detach a).components a (R.white a) hn
+  rw [← heq] at hc
+  omega
+
+lemma Ribbon.detach_components_card_white_fixed (R : Ribbon α) (a : α)
+    (hb : R.black a ≠ a) (hw : R.white a = a) :
+    Nat.card (Quotient (R.detach a).components) = Nat.card (Quotient R.components) + 1 := by
+  have hn : ¬ (R.detach a).components.r a (R.black a) := fun h => hb (R.detach_isolated a h)
+  have heq := R.components_detach a
+  rw [hw, joinPair_eq_of_related _ ((joinPair (R.detach a).components a (R.black a)).iseqv.refl a)] at heq
+  have hc := joinPair_card (R.detach a).components a (R.black a) hn
+  rw [← heq] at hc
+  omega
+
+omit [Fintype α] in
+lemma Ribbon.detach_face_black_fixed (R : Ribbon α) (a : α) (hb : R.black a = a) :
+    (R.detach a).face = unplug R.face a := by
+  rw [R.detach_face]
+  have hf : R.face a = R.white a := by simp [Ribbon.face, hb]
+  simp [hf, unplug]
+  rfl
+
+omit [Fintype α] in
+lemma Ribbon.detach_face_white_fixed (R : Ribbon α) (a : α) (hw : R.white a = a) :
+    (R.detach a).face = unplug R.face a := by
+  rw [R.detach_face, hw]
+  simp [unplug]
+  rfl
+
+lemma Ribbon.detach_face_card_separating (R : Ribbon α) (a : α)
+    (hb : R.black a ≠ a) (hw : R.white a ≠ a)
+    (hsep : ¬ (R.detach a).components.r (R.black a) (R.white a)) :
+    Nat.card (Cycles (R.detach a).face) = Nat.card (Cycles R.face) + 2 := by
+  have hf : R.face a ≠ a := by
+    intro hf
+    have hs : (R.detach a).white (R.black a) = R.white a := by
+      change swap a (R.white a) (R.face a) = R.white a
+      simp [hf]
+    exact hsep (hs ▸ (R.detach a).white_step (R.black a))
+  have hs : (R.detach a).white (R.black a) = R.face a := by
+    change swap a (R.white a) (R.face a) = R.face a
+    exact swap_apply_of_ne_of_ne hf (R.white.injective.ne hb)
+  have hnot : ¬ (R.detach a).face.SameCycle (R.white a) (R.face a) := by
+    intro h
+    have hc := (R.detach a).sameCycle_face_components h
+    have hs' := (R.detach a).white_step (R.black a)
+    rw [hs] at hs'
+    exact hsep ((R.detach a).components.iseqv.trans hs'
+      ((R.detach a).components.iseqv.symm hc))
+  have hcard := swap_mul_cycles_card (R.detach a).face (R.white a) (R.face a) hnot
+  have heq : swap (R.white a) (R.face a) * (R.detach a).face = unplug R.face a := by
+    rw [R.detach_face_unplug a hw hf]
+    simp [← mul_assoc]
+  rw [heq, unplug_cycles_card R.face a hf] at hcard
+  omega
+
+theorem Ribbon.genusZero_detach (R : Ribbon α) (hR : R.GenusZero) (a : α) :
+    (R.detach a).GenusZero := by
+  by_cases hb : R.black a = a
+  · have hblack : (R.detach a).black = R.black := by
+      simp [Ribbon.detach, unplug, hb]
+      rfl
+    by_cases hw : R.white a = a
+    · have heq : R.detach a = R := by
+        cases R
+        simp_all [Ribbon.detach, unplug]
+      rwa [heq]
+    · have hwc := unplug_cycles_card R.white a hw
+      have hcc := R.detach_components_card_black_fixed a hb hw
+      have hf : R.face a ≠ a := by simpa [Ribbon.face, hb] using hw
+      have hfc := unplug_cycles_card R.face a hf
+      rw [← R.detach_face_black_fixed a hb] at hfc
+      change Nat.card (Cycles (R.detach a).white) = _ at hwc
+      unfold Ribbon.GenusZero at hR ⊢
+      rw [hblack]
+      omega
+  · have hbc := unplug_cycles_card R.black a hb
+    change Nat.card (Cycles (R.detach a).black) = _ at hbc
+    by_cases hw : R.white a = a
+    · have hwhite : (R.detach a).white = R.white := by
+        simp [Ribbon.detach, unplug, hw]
+        rfl
+      have hcc := R.detach_components_card_white_fixed a hb hw
+      have hf : R.face a ≠ a := by
+        intro hf
+        apply hb
+        apply R.white.injective
+        simpa [Ribbon.face, hw] using hf
+      have hfc := unplug_cycles_card R.face a hf
+      rw [← R.detach_face_white_fixed a hw] at hfc
+      unfold Ribbon.GenusZero at hR ⊢
+      rw [hwhite]
+      omega
+    · have hwc := unplug_cycles_card R.white a hw
+      change Nat.card (Cycles (R.detach a).white) = _ at hwc
+      have hcc := R.detach_components_card a hb hw
+      by_cases hs : (R.detach a).components.r (R.black a) (R.white a)
+      · rw [ite_eq_left hs] at hcc
+        have hfc := R.detach_face_card_le a hw
+        have hbound := (R.detach a).euler_le
+        unfold Ribbon.GenusZero at hR ⊢
+        omega
+      · rw [ite_eq_right hs] at hcc
+        have hfc := R.detach_face_card_separating a hb hw hs
+        unfold Ribbon.GenusZero at hR ⊢
+        omega
+
+end OddKaplansky.Planar
+
+namespace OddKaplansky.Planar
+open Equiv Equiv.Perm
+attribute [local simp] SameCycle.rfl
+variable {α : Type portUniverse10} {V : Type portUniverse11} [Fintype α]
+
+lemma Ribbon.mergeWhite_components (R : Ribbon α) (a : α)
+    (ha : ¬ R.white.SameCycle a (R.black a)) : (R.mergeWhite a).components = R.components := by
+  have hn : ¬ R.white.SameCycle a (R.face a) := by simpa [Ribbon.face] using ha
+  apply le_antisymm
+  · apply (R.mergeWhite a).components_le_of_steps
+    · exact R.black_step
+    · intro x
+      exact R.components.iseqv.trans (R.white_step x)
+        (setoid_swap_related R.components (R.face_step a) (R.white x))
+  · apply sup_le
+    · exact le_sup_left
+    · intro x y h
+      exact (show SameCycle.setoid (R.mergeWhite a).white ≤ (R.mergeWhite a).components
+        from le_sup_right) (sameCycle_swap_mul R.white a (R.face a) hn h)
+
+lemma Ribbon.genusZero_mergeWhite (R : Ribbon α) (hR : R.GenusZero) (a : α)
+    (ha : ¬ R.white.SameCycle a (R.black a)) : (R.mergeWhite a).GenusZero := by
+  have hn : ¬ R.white.SameCycle a (R.face a) := by simpa [Ribbon.face] using ha
+  have hne : R.face a ≠ a := by intro h; exact hn (by rw [h])
+  have hw := swap_mul_cycles_card R.white a (R.face a) hn
+  have hf := unplug_cycles_card R.face a hne
+  unfold Ribbon.GenusZero at *
+  rw [R.mergeWhite_components a ha, mergeWhite_face]
+  change Nat.card (Cycles R.black) + Nat.card (Cycles (swap a (R.face a) * R.white)) +
+    Nat.card (Cycles (unplug R.face a)) = _
+  omega
+
+def Ribbon.mergeBlack (R : Ribbon α) (a : α) : Ribbon α where
+  black := swap a (R.black (R.white a)) * R.black
+  white := R.white
+
+omit [Fintype α] in
+lemma Ribbon.mergeBlack_face (R : Ribbon α) (a : α) :
+    (R.mergeBlack a).face = unplug R.face (R.white a) := by
+  simp only [Ribbon.mergeBlack, Ribbon.face, unplug, ← mul_assoc]
+  rw [mul_swap_eq_swap_mul]
+  rfl
+
+lemma Ribbon.mergeBlack_components (R : Ribbon α) (a : α)
+    (ha : ¬ R.black.SameCycle a (R.white a)) : (R.mergeBlack a).components = R.components := by
+  have hn : ¬ R.black.SameCycle a (R.black (R.white a)) := by simpa using ha
+  apply le_antisymm
+  · apply (R.mergeBlack a).components_le_of_steps
+    · intro x
+      exact R.components.iseqv.trans (R.black_step x)
+        (setoid_swap_related R.components
+          (R.components.iseqv.trans (R.white_step a) (R.black_step (R.white a))) (R.black x))
+    · exact R.white_step
+  · apply sup_le
+    · intro x y h
+      exact (show SameCycle.setoid (R.mergeBlack a).black ≤ (R.mergeBlack a).components
+        from le_sup_left) (sameCycle_swap_mul R.black a (R.black (R.white a)) hn h)
+    · exact le_sup_right
+
+lemma Ribbon.genusZero_mergeBlack (R : Ribbon α) (hR : R.GenusZero) (a : α)
+    (ha : ¬ R.black.SameCycle a (R.white a)) : (R.mergeBlack a).GenusZero := by
+  have hn : ¬ R.black.SameCycle a (R.black (R.white a)) := by simpa using ha
+  have hne : R.face (R.white a) ≠ R.white a := by
+    intro h
+    have h' : R.black (R.white a) = a := R.white.injective h
+    exact hn (by rw [h'])
+  have hb := swap_mul_cycles_card R.black a (R.black (R.white a)) hn
+  have hf := unplug_cycles_card R.face (R.white a) hne
+  unfold Ribbon.GenusZero at *
+  rw [R.mergeBlack_components a ha, R.mergeBlack_face]
+  change Nat.card (Cycles (swap a (R.black (R.white a)) * R.black)) +
+    Nat.card (Cycles R.white) + Nat.card (Cycles (unplug R.face (R.white a))) = _
+  omega
+
+omit [Fintype α] in
+lemma label_swap (f : α → V) (a b : α) (hab : f a = f b) (x : α) :
+    f (swap a b x) = f x := by
+  by_cases hxa : x = a
+  · subst x
+    simpa using hab.symm
+  · by_cases hxb : x = b
+    · subst x
+      simpa using hab
+    · rw [swap_apply_of_ne_of_ne hxa hxb]
+
+end OddKaplansky.Planar
+
+namespace OddKaplansky.Planar
+open Equiv Equiv.Perm
+variable {α : Type portUniverse12} [Fintype α]
+
+lemma sameCycle_after_swap {p : Perm α} {a b x y : α} (hab : p.SameCycle a b)
+    (hxy : (swap a b * p).SameCycle x y) : p.SameCycle x y := by
+  apply setoid_sameCycle_of_step (SameCycle.setoid p) (swap a b * p) _ hxy
+  intro z
+  exact (SameCycle.apply_right SameCycle.rfl).trans
+    (setoid_swap_related (SameCycle.setoid p) hab (p z))
+
+lemma sign_eq_cycles (p : Perm α) :
+    sign p = (-1 : ℤˣ) ^ (Fintype.card α - Nat.card (Cycles p)) := by
+  classical
+  obtain ⟨l, hl, hlen, hmem⟩ := exists_cycle_factorization p
+  have hs := sign_prod_list_swap (l := l.map fun ab => swap ab.1 ab.2) (by
+    intro g hg
+    obtain ⟨ab, hab, rfl⟩ := List.mem_map.mp hg
+    exact ⟨ab.1, ab.2, (hmem ab hab).1, rfl⟩)
+  rw [hl, List.length_map] at hs
+  have hn : Fintype.card α - Nat.card (Cycles p) = l.length := by omega
+  rwa [hn]
+
+lemma not_sameCycle_swap_of_sameCycle (p : Perm α) (a b : α)
+    (hne : a ≠ b) (hab : p.SameCycle a b) : ¬ (swap a b * p).SameCycle a b := by
+  classical
+  intro hq
+  let q := swap a b * p
+  have hrev : swap a b * q = p := by simp [q, ← mul_assoc]
+  have heq : SameCycle.setoid p = SameCycle.setoid q := by
+    ext x y
+    constructor
+    · intro h
+      apply sameCycle_after_swap hq
+      rwa [hrev]
+    · exact sameCycle_after_swap hab
+  have hc : Nat.card (Cycles p) = Nat.card (Cycles q) := by rw [Cycles, heq]
+  have hs : sign p = sign q := by rw [sign_eq_cycles, sign_eq_cycles, hc]
+  have hsign : (-1 : ℤˣ) = 1 := by
+    have := hs
+    change sign p = sign (swap a b * p) at this
+    rw [Perm.sign_mul, sign_swap hne] at this
+    exact mul_right_cancel (b := sign p) (by simpa using this.symm)
+  norm_num at hsign
+
+lemma swap_mul_cycles_card_split (p : Perm α) (a b : α)
+    (hne : a ≠ b) (hab : p.SameCycle a b) :
+    Nat.card (Cycles (swap a b * p)) = Nat.card (Cycles p) + 1 := by
+  have h := swap_mul_cycles_card (swap a b * p) a b
+    (not_sameCycle_swap_of_sameCycle p a b hne hab)
+  simpa [← mul_assoc] using h.symm
+
+end OddKaplansky.Planar
+
+namespace OddKaplansky.Planar
+open Equiv Equiv.Perm
+variable {α : Type portUniverse13} [Fintype α]
+
+def Ribbon.swapBlack (R : Ribbon α) (a b : α) : Ribbon α :=
+  ⟨swap a b * R.black, R.white⟩
+
+omit [Fintype α] in
+lemma Ribbon.swapBlack_twice (R : Ribbon α) (a b : α) :
+    (R.swapBlack a b).swapBlack a b = R := by
+  cases R
+  simp [Ribbon.swapBlack, ← mul_assoc]
+
+omit [Fintype α] in
+lemma Ribbon.swapBlack_face (R : Ribbon α) (a b : α) :
+    (R.swapBlack a b).face = swap (R.white a) (R.white b) * R.face := by
+  simp only [Ribbon.face, Ribbon.swapBlack, ← mul_assoc]
+  rw [mul_swap_eq_swap_mul]
+
+lemma Ribbon.swapBlack_components_merge (R : Ribbon α) (a b : α)
+    (hab : ¬ R.black.SameCycle a b) :
+    (R.swapBlack a b).components = joinPair R.components a b := by
+  apply le_antisymm
+  · apply (R.swapBlack a b).components_le_of_steps
+    · intro x
+      exact (joinPair R.components a b).iseqv.trans
+        (le_joinPair _ _ _ (R.black_step x))
+        (setoid_swap_related _ (joinPair_related _ _ _) _)
+    · intro x
+      exact le_joinPair _ _ _ (R.white_step x)
+  · apply joinPair_le
+    · apply sup_le
+      · intro x y hxy
+        exact (show SameCycle.setoid (R.swapBlack a b).black ≤
+            (R.swapBlack a b).components from le_sup_left)
+          (sameCycle_swap_mul R.black a b hab hxy)
+      · exact le_sup_right
+    · exact (show SameCycle.setoid (R.swapBlack a b).black ≤
+          (R.swapBlack a b).components from le_sup_left)
+        (swap_mul_sameCycle R.black a b hab)
+
+omit [Fintype α] in
+lemma Ribbon.not_blackCycle_of_not_component (R : Ribbon α) {a b : α}
+    (h : ¬ R.components.r a b) : ¬ R.black.SameCycle a b :=
+  fun hab => h ((show SameCycle.setoid R.black ≤ R.components from le_sup_left) hab)
+
+lemma Ribbon.not_white_faceCycle_of_not_component (R : Ribbon α) {a b : α}
+    (h : ¬ R.components.r a b) : ¬ R.face.SameCycle (R.white a) (R.white b) := by
+  intro hab
+  exact h (R.components.iseqv.trans (R.white_step a)
+    (R.components.iseqv.trans (R.sameCycle_face_components hab)
+      (R.components.iseqv.symm (R.white_step b))))
+
+lemma Ribbon.genusZero_swapBlack_merge (R : Ribbon α) (hR : R.GenusZero) (a b : α)
+    (hab : ¬ R.components.r a b) : (R.swapBlack a b).GenusZero := by
+  have hb := R.not_blackCycle_of_not_component hab
+  have hbc := swap_mul_cycles_card R.black a b hb
+  have hfc := swap_mul_cycles_card R.face (R.white a) (R.white b)
+    (R.not_white_faceCycle_of_not_component hab)
+  have hcc := joinPair_card R.components a b hab
+  rw [← R.swapBlack_components_merge a b hb] at hcc
+  rw [← R.swapBlack_face a b] at hfc
+  change Nat.card (Cycles (R.swapBlack a b).black) + 1 = _ at hbc
+  have hw : (R.swapBlack a b).white = R.white := rfl
+  unfold Ribbon.GenusZero at hR ⊢
+  rw [hw]
+  omega
+
+lemma Ribbon.genusZero_swapBlack_split (R : Ribbon α) (hR : R.GenusZero) (a b : α)
+    (hne : a ≠ b) (hab : R.black.SameCycle a b) : (R.swapBlack a b).GenusZero := by
+  let S := R.swapBlack a b
+  have hback : S.swapBlack a b = R := R.swapBlack_twice a b
+  have hn : ¬ S.black.SameCycle a b := not_sameCycle_swap_of_sameCycle R.black a b hne hab
+  have hbc := swap_mul_cycles_card_split R.black a b hne hab
+  change Nat.card (Cycles S.black) = Nat.card (Cycles R.black) + 1 at hbc
+  have hw : S.white = R.white := rfl
+  have hcomp := S.swapBlack_components_merge a b hn
+  rw [hback] at hcomp
+  by_cases hc : S.components.r a b
+  · rw [joinPair_eq_of_related S.components hc] at hcomp
+    have hfc := swap_cycles_card_le S.face (S.white a) (S.white b)
+    rw [← S.swapBlack_face a b, hback] at hfc
+    have hbnd := S.euler_le
+    unfold Ribbon.GenusZero at hR ⊢
+    change Nat.card (Cycles S.black) + Nat.card (Cycles S.white) +
+      Nat.card (Cycles S.face) = Fintype.card α + 2 * Nat.card (Quotient S.components)
+    rw [hw] at hbnd ⊢
+    rw [hcomp] at hR
+    omega
+  · have hcc := joinPair_card S.components a b hc
+    rw [← hcomp] at hcc
+    have hfc := swap_mul_cycles_card S.face (S.white a) (S.white b)
+      (S.not_white_faceCycle_of_not_component hc)
+    rw [← S.swapBlack_face a b, hback] at hfc
+    unfold Ribbon.GenusZero at hR ⊢
+    change Nat.card (Cycles S.black) + Nat.card (Cycles S.white) +
+      Nat.card (Cycles S.face) = Fintype.card α + 2 * Nat.card (Quotient S.components)
+    rw [hw]
+    omega
+
+end OddKaplansky.Planar
+
+namespace OddKaplansky.Planar
+open Equiv Equiv.Perm
+variable {α : Type portUniverse14} {V : Type portUniverse15} {F : Type portUniverse16} {A : Type portUniverse17} {B : Type portUniverse18} [sectionInstance2 : Fintype α] [CommGroup A] [Group B]
+
+structure NoncommBalanced (R : Ribbon α) (Inc : V → F → Prop)
+    (ι : V → F → (A →* B)) where
+  blackLabel : α → V
+  whiteLabel : α → F
+  blackLabel_rot : ∀ a, blackLabel (R.black a) = blackLabel a
+  whiteLabel_rot : ∀ a, whiteLabel (R.white a) = whiteLabel a
+  incident : ∀ a, Inc (blackLabel a) (whiteLabel a)
+  weight : α → A
+  white_prod : ∀ c : Cycles R.white, ∏ a ∈ cycleSet R.white c, weight a = 1
+  potential : α → B
+  exception : α
+  black_balance : ∀ a, a ≠ exception →
+    potential (R.black a) = potential a * ι (blackLabel a) (whiteLabel a) (weight a)
+  black_defect : potential (R.black exception) ≠ potential exception *
+    ι (blackLabel exception) (whiteLabel exception) (weight exception)
+
+def NoncommBalanced.Reduced {R : Ribbon α} {Inc : V → F → Prop}
+    {ι : V → F → (A →* B)} (D : NoncommBalanced R Inc ι) : Prop :=
+  (∀ a, D.weight a ≠ 1) ∧
+  (∀ a, R.black a ≠ a → D.whiteLabel (R.black a) ≠ D.whiteLabel a) ∧
+  (∀ a, R.white a ≠ a → D.blackLabel (R.white a) ≠ D.blackLabel a)
+
+lemma cycleClass_perm
+    {α : Type contextUniverse1}
+    [Fintype.{contextUniverse1} α] (p : Perm α) (a : α) : cycleClass p (p a) = cycleClass p a := by
+  apply (cycleClass_eq p _ _).mpr
+  exact (SameCycle.refl p a).apply_left
+
+lemma cycleSet_singleton_of_fixed (p : Perm α) (a : α) (h : p a = a) :
+    cycleSet p (cycleClass p a) = {a} := by
+  classical
+  ext b
+  rw [mem_cycleSet, cycleClass_eq, Finset.mem_singleton]
+  exact ⟨fun hb => hb.eq_of_right h, fun hb => hb ▸ SameCycle.refl p a⟩
+
+lemma cycleSet_card_pow (p : Perm α) (a : α) :
+    (p ^ (cycleSet p (cycleClass p a)).card) a = a := by
+  classical
+  by_cases h : p a = a
+  · rw [cycleSet_singleton_of_fixed p a h, Finset.card_singleton, pow_one, h]
+  · have heq : cycleSet p (cycleClass p a) = (p.cycleOf a).support := by
+      ext b
+      rw [mem_cycleSet, cycleClass_eq, mem_support_cycleOf_iff' h, sameCycle_comm]
+    rw [heq, ← p.pow_mod_card_support_cycleOf_self_apply]
+    simp
+
+variable {R : Ribbon α} {Inc : V → F → Prop} {ι : V → F → (A →* B)}
+
+lemma NoncommBalanced.exception_weight_fixed (D : NoncommBalanced R Inc ι)
+    (h : R.black D.exception = D.exception) : D.weight D.exception ≠ 1 := by
+  intro hw
+  apply D.black_defect
+  rw [h, hw, map_one, mul_one]
+
+lemma NoncommBalanced.white_not_fixed (D : NoncommBalanced R Inc ι)
+    (hw : ∀ a, D.weight a ≠ 1) (a : α) : R.white a ≠ a := by
+  intro h
+  have hp := D.white_prod (cycleClass R.white a)
+  rw [cycleSet_singleton_of_fixed R.white a h, Finset.prod_singleton] at hp
+  exact hw a hp
+
+lemma NoncommBalanced.black_iterate (D : NoncommBalanced R Inc ι)
+    (a : α) (ha : ¬ R.black.SameCycle a D.exception) (n : ℕ) :
+    D.potential ((R.black^n) a) = D.potential a *
+      ((List.range n).map fun k =>
+        ι (D.blackLabel ((R.black^k) a)) (D.whiteLabel ((R.black^k) a))
+          (D.weight ((R.black^k) a))).prod := by
+  induction n with
+  | zero => simp
+  | succ n ih =>
+    rw [pow_succ', Perm.mul_apply, D.black_balance, ih, List.range_succ,
+      List.map_append, List.prod_append, List.map_singleton, List.prod_singleton, mul_assoc]
+    intro he
+    apply ha
+    rw [← he]
+    exact (SameCycle.refl R.black a).pow_right (n := n)
+
+end OddKaplansky.Planar
+
+namespace OddKaplansky.Holonomy
+open Equiv Equiv.Perm
+variable {α : Type portUniverse19} {B : Type portUniverse20} [Group B]
+
+structure Defect (p : Perm α) (w : α → B) where
+  potential : α → B
+  exception : α
+  balance : ∀ x, x ≠ exception → potential (p x) = potential x * w x
+  defective : potential (p exception) ≠ potential exception * w exception
+
+noncomputable def combineWeight (w : α → B) (a b x : α) : B :=
+  if x = a then 1 else if x = b then w a * w b else w x
+noncomputable def combinePotential (t : α → B) (a b x : α) : B :=
+  if x = b then t a else t x
+
+def Defect.combine {p : Perm α} {w : α → B} (D : Defect p w)
+    (a b : α) (hab : a ≠ b) (hpa : p a = b) :
+    Defect p (combineWeight w a b) := by
+  classical
+  let t := combinePotential D.potential a b
+  have hpb : p b ≠ b := by
+    intro h
+    exact hab (p.injective (hpa.trans h.symm))
+  have ht (x : α) (hx : x ≠ b) : t x = D.potential x :=
+    ite_eq_right hx
+  have hta : t a = D.potential a := ht a hab
+  have htb : t b = D.potential a := ite_eq_left rfl
+  have hxa (x : α) (hx : x ≠ a) : p x ≠ b := by
+    intro h
+    exact hx (p.injective (h.trans hpa.symm))
+  have hbalance_a : t (p a) = t a * combineWeight w a b a := by
+    rw [hpa, htb, hta]
+    simp [combineWeight]
+  have hbalance_b (ha : a ≠ D.exception) (hb : b ≠ D.exception) :
+      t (p b) = t b * combineWeight w a b b := by
+    rw [ht _ hpb, htb, D.balance b hb, ← hpa, D.balance a ha, hpa]
+    simp [combineWeight, hab.symm, mul_assoc]
+  have hbalance_other (x : α) (hxa' : x ≠ a) (hxb : x ≠ b)
+      (hxe : x ≠ D.exception) : t (p x) = t x * combineWeight w a b x := by
+    rw [ht _ (hxa x hxa'), ht _ hxb, D.balance x hxe]
+    simp [combineWeight, hxa', hxb]
+  by_cases hea : D.exception = a
+  · refine ⟨t, b, ?_, ?_⟩
+    · intro x hxb
+      by_cases hxa' : x = a
+      · subst x; exact hbalance_a
+      · exact hbalance_other x hxa' hxb (by simpa [hea] using hxa')
+    · intro h
+      have he := D.defective
+      rw [hea, hpa] at he
+      apply he
+      rw [ht _ hpb, htb, D.balance b (by simpa [hea] using hab.symm)] at h
+      simp [combineWeight, hab.symm, ← mul_assoc] at h
+      exact h
+  · refine ⟨t, D.exception, ?_, ?_⟩
+    · intro x hxe
+      by_cases hxa' : x = a
+      · subst x; exact hbalance_a
+      · by_cases hxb : x = b
+        · subst x; exact hbalance_b (Ne.symm hea) hxe
+        · exact hbalance_other x hxa' hxb hxe
+    · intro h
+      apply D.defective
+      by_cases heb : D.exception = b
+      · rw [heb, ht _ hpb, htb, show combineWeight w a b b = w a * w b by
+          simp [combineWeight, hab.symm]] at h
+        rw [heb]
+        have htba := D.balance a (Ne.symm hea)
+        rw [hpa] at htba
+        rw [htba, mul_assoc]
+        exact h
+      · rw [ht _ (hxa _ hea), ht _ heb] at h
+        simpa [combineWeight, hea, heb] using h
+
+def Defect.merge {p : Perm α} {w : α → B} (D : Defect p w)
+    (a b : α) (hab : ¬ p.SameCycle a b) : Defect (swap a b * p) w := by
+  classical
+  let u : B := D.potential a * (D.potential b)⁻¹
+  let k (x : α) : B := if p.SameCycle b x then u else 1
+  let t (x : α) : B := k x * D.potential x
+  have hba : ¬ p.SameCycle b a := fun h => hab h.symm
+  have hka : k a = 1 := ite_eq_right hba
+  have hkb : k b = u := ite_eq_left (SameCycle.refl p b)
+  have hkp (x : α) : k (p x) = k x := by simp only [k, sameCycle_apply_right]
+  have htarget (x : α) : t ((swap a b * p) x) = k x * D.potential (p x) := by
+    by_cases hxa : p x = a
+    · have hkx : k x = 1 := by rw [← hkp, hxa, hka]
+      simp [Perm.mul_apply, hxa, t, hkb, hkx, u]
+    · by_cases hxb : p x = b
+      · have hkx : k x = u := by rw [← hkp, hxb, hkb]
+        simp [Perm.mul_apply, hxb, t, hka, hkx, u]
+      · rw [Perm.mul_apply, swap_apply_of_ne_of_ne hxa hxb]
+        change k (p x) * D.potential (p x) = _
+        rw [hkp]
+  refine ⟨t, D.exception, ?_, ?_⟩
+  · intro x hx
+    rw [htarget, D.balance x hx, ← mul_assoc]
+  · intro h
+    apply D.defective
+    rw [htarget] at h
+    change k D.exception * D.potential (p D.exception) =
+      k D.exception * D.potential D.exception * w D.exception at h
+    rw [mul_assoc] at h
+    exact mul_left_cancel h
+
+def Defect.swapEqual {p : Perm α} {w : α → B} (D : Defect p w)
+    (a b : α) (hab : D.potential a = D.potential b) :
+    Defect (swap a b * p) w := by
+  classical
+  have ht (x : α) : D.potential ((swap a b * p) x) = D.potential (p x) := by
+    apply OddKaplansky.Planar.label_swap
+    exact hab
+  refine ⟨D.potential, D.exception, ?_, ?_⟩
+  · intro x hx
+    rw [ht]
+    exact D.balance x hx
+  · rw [ht]
+    exact D.defective
+
+def Defect.restrict {p : Perm α} {w : α → B} (D : Defect p w)
+    (P : α → Prop) (hP : ∀ x, P (p x) ↔ P x) (he : P D.exception) :
+    Defect (p.subtypePerm hP) (fun x => w x.val) where
+  potential x := D.potential x.val
+  exception := ⟨D.exception, he⟩
+  balance x hx := D.balance x (fun h => hx (Subtype.ext h))
+  defective := D.defective
+
+def Defect.splitRestrict {p : Perm α} {w : α → B} (D : Defect p w)
+    (a b : α) (hab : D.potential a ≠ D.potential b)
+    (P : α → Prop) (hP : ∀ x, P ((swap a b * p) x) ↔ P x)
+    (ha : P a) (hb : ¬ P b) (he : ¬ P D.exception) :
+    Defect ((swap a b * p).subtypePerm hP) (fun x => w x.val) := by
+  classical
+  have hab' : a ≠ b := fun h => hab (congrArg D.potential h)
+  have hq : (swap a b * p) (p.symm b) = a := by simp
+  have hd : P (p.symm b) := (hP _).mp (by rw [hq]; exact ha)
+  refine ⟨(fun x => D.potential x.val), ⟨p.symm b, hd⟩, ?_, ?_⟩
+  · intro x hx
+    have hxe : x.val ≠ D.exception := fun h => he (h ▸ x.prop)
+    have hxb : p x.val ≠ b := by
+      intro h
+      apply hx
+      apply Subtype.ext
+      exact p.injective (h.trans (p.apply_symm_apply b).symm)
+    have hxa : p x.val ≠ a := by
+      intro h
+      have hqx : (swap a b * p) x.val = b := by simp [Perm.mul_apply, h]
+      exact hb (hqx ▸ (hP x).mpr x.prop)
+    change D.potential ((swap a b * p) x.val) = D.potential x.val * w x.val
+    rw [Perm.mul_apply, swap_apply_of_ne_of_ne hxa hxb]
+    exact D.balance x hxe
+  · change D.potential ((swap a b * p) (p.symm b)) ≠
+      D.potential (p.symm b) * w (p.symm b)
+    rw [hq, ← D.balance (p.symm b) (fun h => he (h ▸ hd)), p.apply_symm_apply]
+    exact hab
+
+def Defect.unplug {p : Perm α} {w : α → B} (D : Defect p w)
+    (a : α) (hwa : w a = 1) : Defect (OddKaplansky.Planar.unplug p a) w := by
+  classical
+  by_cases hpa : p a = a
+  · have hq : OddKaplansky.Planar.unplug p a = p := by
+      ext x
+      simp [OddKaplansky.Planar.unplug, hpa]
+    rw [hq]
+    exact D
+  let b := p.symm a
+  have hpb : p b = a := p.apply_symm_apply a
+  have hba : b ≠ a := by
+    intro h
+    apply hpa
+    rwa [h] at hpb
+  let q := OddKaplansky.Planar.unplug p a
+  have hqa : q a = a := OddKaplansky.Planar.unplug_fixed p a
+  have hqb : q b = p a := by simp [q, OddKaplansky.Planar.unplug, hpb]
+  have hqx (x : α) (hxa : x ≠ a) (hxb : x ≠ b) : q x = p x := by
+    have hpxa : p x ≠ a := fun h => hxb (p.injective (h.trans hpb.symm))
+    have hpxpa : p x ≠ p a := fun h => hxa (p.injective h)
+    exact swap_apply_of_ne_of_ne hpxa hpxpa
+  have hbalance_a : D.potential (q a) = D.potential a * w a := by rw [hqa, hwa, mul_one]
+  by_cases hea : D.exception = a
+  · refine ⟨D.potential, b, ?_, ?_⟩
+    · intro x hxb
+      by_cases hxa : x = a
+      · subst x; exact hbalance_a
+      · rw [hqx x hxa hxb]
+        exact D.balance x (by simpa [hea] using hxa)
+    · intro h
+      apply D.defective
+      have hh := D.balance b (by simpa [hea] using hba)
+      rw [hpb] at hh
+      change D.potential (q b) = D.potential b * w b at h
+      rw [hqb, ← hh] at h
+      simpa [hea, hwa] using h
+  · have ha : D.potential (p a) = D.potential a := by
+      simpa [hwa] using D.balance a (Ne.symm hea)
+    refine ⟨D.potential, D.exception, ?_, ?_⟩
+    · intro x hxe
+      by_cases hxa : x = a
+      · subst x; exact hbalance_a
+      · by_cases hxb : x = b
+        · subst x
+          rw [hqb, ha, ← hpb]
+          exact D.balance b hxe
+        · rw [hqx x hxa hxb]
+          exact D.balance x hxe
+    · intro h
+      apply D.defective
+      by_cases heb : D.exception = b
+      · change D.potential (q D.exception) = _ at h
+        rw [heb, hqb, ha] at h
+        simpa [heb, hpb] using h
+      · rw [hqx D.exception hea heb] at h
+        exact h
+
+end OddKaplansky.Holonomy
+
+namespace OddKaplansky.Planar
+open Equiv Equiv.Perm OddKaplansky.Holonomy
+variable {α : Type portUniverse21} {β : Type portUniverse22} {V : Type portUniverse23} {F : Type portUniverse24} {A : Type portUniverse25} {B : Type portUniverse26} [sectionInstance3 : Fintype α] [CommGroup A] [Group B]
+
+def cycleMap {p q : Perm α} (h : ∀ {x y}, p.SameCycle x y → q.SameCycle x y) :
+    Cycles p → Cycles q := Quotient.map id (fun _ _ hxy => h hxy)
+
+omit [Fintype α] in
+lemma cycleMap_class {p q : Perm α} (h : ∀ {x y}, p.SameCycle x y → q.SameCycle x y)
+    (a : α) : cycleMap h (cycleClass p a) = cycleClass q a := rfl
+
+lemma prod_cycle_coarsen {p q : Perm α}
+    (h : ∀ {x y}, p.SameCycle x y → q.SameCycle x y) (c : Cycles q) (f : α → A) :
+    ∏ a ∈ cycleSet q c, f a =
+      ∏ d ∈ Finset.univ.filter (fun d : Cycles p => cycleMap h d = c),
+        ∏ a ∈ cycleSet p d, f a := by
+  classical
+  have hh := Finset.prod_fiberwise_eq_prod_filter (Finset.univ : Finset α)
+    (Finset.univ.filter (fun d : Cycles p => cycleMap h d = c)) (cycleClass p) f
+  simpa only [Finset.mem_filter, Finset.mem_univ, true_and, cycleMap_class, cycleSet]
+    using hh.symm
+
+lemma prod_cycle_coarsen_one {p q : Perm α}
+    (h : ∀ {x y}, p.SameCycle x y → q.SameCycle x y) (f : α → A)
+    (hf : ∀ c : Cycles p, ∏ a ∈ cycleSet p c, f a = 1) (c : Cycles q) :
+    ∏ a ∈ cycleSet q c, f a = 1 := by
+  rw [prod_cycle_coarsen h]
+  simp only [hf, Finset.prod_const_one]
+
+lemma label_sameCycle (p : Perm α) (f : α → β) (hf : ∀ a, f (p a) = f a)
+    {x y : α} (hxy : p.SameCycle x y) : f x = f y :=
+  setoid_sameCycle_of_step (Setoid.ker f) p (fun x => (hf x).symm) hxy
+
+lemma label_unplug (p : Perm α) (f : α → β) (hf : ∀ a, f (p a) = f a) (a x : α) :
+    f (unplug p a x) = f x :=
+  (label_sameCycle p f hf (unplug_sameCycle p a ((SameCycle.refl _ x).apply_right))).symm
+
+lemma sameCycle_unplug_iff_of_ne (p : Perm α) (a : α) {x y : α}
+    (hx : x ≠ a) (hy : y ≠ a) : (unplug p a).SameCycle x y ↔ p.SameCycle x y := by
+  by_cases ha : p a = a
+  · simp only [unplug, ha, swap_self]
+    rfl
+  · exact unplug_sameCycle_iff p a ha hx hy
+
+lemma cycleSet_unplug (p : Perm α) (a x : α) (hx : x ≠ a) :
+    cycleSet (unplug p a) (cycleClass (unplug p a) x) =
+      (cycleSet p (cycleClass p x)).erase a := by
+  classical
+  ext y
+  rw [mem_cycleSet, cycleClass_eq, Finset.mem_erase, mem_cycleSet, cycleClass_eq]
+  constructor
+  · intro hy
+    refine ⟨?_, unplug_sameCycle p a hy⟩
+    intro hya
+    subst y
+    exact hx (hy.symm.eq_of_right (unplug_fixed p a))
+  · rintro ⟨hya, hy⟩
+    exact (sameCycle_unplug_iff_of_ne p a hya hx).mpr hy
+
+omit [Fintype α] in
+lemma prod_erase_of_one (s : Finset α) (a : α) (f : α → A) (ha : f a = 1) :
+    ∏ x ∈ s.erase a, f x = ∏ x ∈ s, f x := by
+  classical
+  apply Finset.prod_subset (Finset.erase_subset _ _)
+  intro x hx hxa
+  have : x = a := by simpa [hx] using hxa
+  simpa [this] using ha
+
+lemma prod_cycle_unplug (p : Perm α) (a x : α) (hx : x ≠ a)
+    (f : α → A) (ha : f a = 1) :
+    ∏ y ∈ cycleSet (unplug p a) (cycleClass (unplug p a) x), f y =
+      ∏ y ∈ cycleSet p (cycleClass p x), f y := by
+  rw [cycleSet_unplug p a x hx]
+  exact prod_erase_of_one _ a f ha
+
+def cycleSubtypeMap (p : Perm α) (P : α → Prop) (hP : ∀ x, P (p x) ↔ P x) :
+    Cycles (p.subtypePerm hP) → Cycles p :=
+  Quotient.map Subtype.val (fun _ _ h => (sameCycle_subtypePerm (h := hP)).mp h)
+
+omit [Fintype α] in
+lemma cycleSubtypeMap_injective (p : Perm α) (P : α → Prop) (hP : ∀ x, P (p x) ↔ P x) :
+    Function.Injective (cycleSubtypeMap p P hP) := by
+  intro c d
+  induction c using Quotient.inductionOn with
+  | h x =>
+    induction d using Quotient.inductionOn with
+    | h y =>
+      intro h
+      exact Quotient.sound ((sameCycle_subtypePerm (h := hP)).mpr (Quotient.exact h))
+
+lemma prod_cycle_subtype (p : Perm α) (P : α → Prop) (hP : ∀ x, P (p x) ↔ P x)
+    (c : Cycles (p.subtypePerm hP)) (f : α → A) :
+    ∏ a ∈ cycleSet (p.subtypePerm hP) c, f a.val =
+      ∏ a ∈ cycleSet p (cycleSubtypeMap p P hP c), f a := by
+  classical
+  induction c using Quotient.inductionOn with
+  | h x =>
+    apply Finset.prod_bij (fun y _ => y.val)
+    · intro y hy
+      apply (mem_cycleSet _ _ _).mpr
+      exact Quotient.sound ((sameCycle_subtypePerm (h := hP)).mp
+        (Quotient.exact ((mem_cycleSet _ _ _).mp hy)))
+    · intro y _ z _ h
+      exact Subtype.ext h
+    · intro y hy
+      have hcycle : p.SameCycle y x.val := (cycleClass_eq _ _ _).mp ((mem_cycleSet _ _ _).mp hy)
+      have hPy : P y := (perm_invariant_cycle p P hP hcycle).mpr x.property
+      refine ⟨⟨y, hPy⟩, ?_, rfl⟩
+      apply (mem_cycleSet _ _ _).mpr
+      exact Quotient.sound ((sameCycle_subtypePerm (h := hP)).mpr hcycle)
+    · intro _ _
+      rfl
+
+lemma prod_combineWeight
+    {α : Type contextUniverse1}
+    {A : Type contextUniverse2}
+    [Fintype.{contextUniverse1} α]
+    [CommGroup.{contextUniverse2} A] (s : Finset α) (w : α → A) (a b : α) (hab : a ≠ b)
+    (hmem : a ∈ s ↔ b ∈ s) : ∏ x ∈ s, combineWeight w a b x = ∏ x ∈ s, w x := by
+  classical
+  have heq (x : α) : combineWeight w a b x =
+      w x * (if x = b then w a else 1) / (if x = a then w a else 1) := by
+    by_cases hxa : x = a
+    · subst x; simp [combineWeight, hab]
+    · by_cases hxb : x = b
+      · subst x; simp [combineWeight, hab.symm, mul_comm]
+      · simp [combineWeight, hxa, hxb]
+  simp only [heq, Finset.prod_div_distrib, Finset.prod_mul_distrib, Finset.prod_ite_eq']
+  simp only [hmem, mul_div_cancel_right]
+
+variable {R : Ribbon α} {Inc : V → F → Prop} {ι : V → F → (A →* B)}
+
+def NoncommBalanced.localWeight (D : NoncommBalanced R Inc ι) (x : α) : B :=
+  ι (D.blackLabel x) (D.whiteLabel x) (D.weight x)
+
+def NoncommBalanced.defect (D : NoncommBalanced R Inc ι) : Defect R.black D.localWeight :=
+  ⟨D.potential, D.exception, D.black_balance, D.black_defect⟩
+
+def NoncommBalanced.withDefect (D : NoncommBalanced R Inc ι) (w : α → A)
+    (hw : ∀ c : Cycles R.white, ∏ x ∈ cycleSet R.white c, w x = 1)
+    (E : Defect R.black (fun x => ι (D.blackLabel x) (D.whiteLabel x) (w x))) :
+    NoncommBalanced R Inc ι :=
+  { D with
+    weight := w
+    white_prod := hw
+    potential := E.potential
+    exception := E.exception
+    black_balance := E.balance
+    black_defect := E.defective }
+
+def NoncommBalanced.combine (D : NoncommBalanced R Inc ι) (a b : α)
+    (hab : a ≠ b) (hpa : R.black a = b) (hw : R.white.SameCycle a b) :
+    NoncommBalanced R Inc ι := by
+  have hbl : D.blackLabel b = D.blackLabel a := by rw [← hpa, D.blackLabel_rot]
+  have hwl : D.whiteLabel b = D.whiteLabel a :=
+    (label_sameCycle R.white D.whiteLabel D.whiteLabel_rot hw).symm
+  have hm : (fun x => ι (D.blackLabel x) (D.whiteLabel x) (combineWeight D.weight a b x)) =
+      combineWeight D.localWeight a b := by
+    funext x
+    by_cases hxa : x = a
+    · subst x; simp [combineWeight]
+    · by_cases hxb : x = b
+      · subst x; simp [combineWeight, hab.symm, NoncommBalanced.localWeight, hbl, hwl]
+      · simp [combineWeight, hxa, hxb, NoncommBalanced.localWeight]
+  refine D.withDefect (combineWeight D.weight a b) ?_ ?_
+  · intro c
+    rw [prod_combineWeight _ _ _ _ hab]
+    · exact D.white_prod c
+    · rw [mem_cycleSet, mem_cycleSet, (cycleClass_eq R.white a b).mpr hw]
+  · rw [hm]
+    exact D.defect.combine a b hab hpa
+
+def NoncommBalanced.restrict (D : NoncommBalanced R Inc ι) (P : α → Prop)
+    (hb : ∀ x, P (R.black x) ↔ P x) (hw : ∀ x, P (R.white x) ↔ P x)
+    (he : P D.exception) : NoncommBalanced (R.restrict P hb hw) Inc ι where
+  blackLabel x := D.blackLabel x.val
+  whiteLabel x := D.whiteLabel x.val
+  blackLabel_rot x := D.blackLabel_rot x.val
+  whiteLabel_rot x := D.whiteLabel_rot x.val
+  incident x := D.incident x.val
+  weight x := D.weight x.val
+  white_prod c := by
+    dsimp only [Ribbon.restrict] at c ⊢
+    rw [prod_cycle_subtype R.white P hw c D.weight]
+    exact D.white_prod _
+  potential x := D.potential x.val
+  exception := ⟨D.exception, he⟩
+  black_balance x hx := D.black_balance x.val (fun h => hx (Subtype.ext h))
+  black_defect := D.black_defect
+
+def NoncommBalanced.detach (D : NoncommBalanced R Inc ι) (a : α) (ha : D.weight a = 1) :
+    NoncommBalanced (R.detach a) Inc ι := by
+  let E := D.defect.unplug a (by simp [NoncommBalanced.localWeight, ha])
+  refine { D with
+    blackLabel_rot := label_unplug R.black D.blackLabel D.blackLabel_rot a
+    whiteLabel_rot := label_unplug R.white D.whiteLabel D.whiteLabel_rot a
+    potential := E.potential
+    exception := E.exception
+    white_prod := ?_
+    black_balance := E.balance
+    black_defect := E.defective }
+  intro c
+  induction c using Quotient.inductionOn with
+  | h x =>
+    change (∏ y ∈ cycleSet (unplug R.white a) (cycleClass (unplug R.white a) x), D.weight y) = 1
+    by_cases hx : x = a
+    · subst x
+      rw [cycleSet_singleton_of_fixed _ _ (unplug_fixed R.white a), Finset.prod_singleton, ha]
+    · rw [prod_cycle_unplug R.white a x hx D.weight ha]
+      exact D.white_prod _
+
+end OddKaplansky.Planar
+
+namespace OddKaplansky.Planar
+open Equiv Equiv.Perm OddKaplansky.Holonomy
+universe u
+variable {α : Type u} {V : Type portUniverse27} {F : Type portUniverse28} {A : Type portUniverse29} {B : Type portUniverse30} [Fintype α] [CommGroup A] [Group B]
+variable {R : Ribbon α} {Inc : V → F → Prop} {ι : V → F → (A →* B)}
+
+def NoncommBalanced.mergeWhite (D : NoncommBalanced R Inc ι) (a : α)
+    (ha : ¬ R.white.SameCycle a (R.black a))
+    (hl : D.whiteLabel (R.black a) = D.whiteLabel a) :
+    NoncommBalanced (R.mergeWhite a) Inc ι := by
+  have hn : ¬ R.white.SameCycle a (R.face a) := by simpa [Ribbon.face] using ha
+  have hlabel : D.whiteLabel a = D.whiteLabel (R.face a) := by
+    rw [Ribbon.face, Perm.mul_apply, D.whiteLabel_rot, hl]
+  refine { D with whiteLabel_rot := ?_, white_prod := ?_ }
+  · intro x
+    change D.whiteLabel (swap a (R.face a) (R.white x)) = D.whiteLabel x
+    rw [label_swap D.whiteLabel a (R.face a) hlabel, D.whiteLabel_rot]
+  · intro c
+    exact prod_cycle_coarsen_one (sameCycle_swap_mul R.white a (R.face a) hn)
+      D.weight D.white_prod c
+
+def NoncommBalanced.spliceBlack (D : NoncommBalanced R Inc ι) (a b : α)
+    (hl : D.blackLabel a = D.blackLabel b)
+    (E : Defect (swap a b * R.black) D.localWeight) :
+    NoncommBalanced (R.swapBlack a b) Inc ι := by
+  refine { D with
+    blackLabel_rot := ?_
+    potential := E.potential
+    exception := E.exception
+    black_balance := E.balance
+    black_defect := E.defective }
+  intro x
+  change D.blackLabel (swap a b (R.black x)) = D.blackLabel x
+  rw [label_swap D.blackLabel a b hl, D.blackLabel_rot]
+
+omit [Fintype α] in
+lemma fixed_compl_invariant (p : Perm α) (a : α) (ha : p a = a) (x : α) :
+    p x ≠ a ↔ x ≠ a := by
+  constructor
+  · intro h hxa; subst x; exact h ha
+  · intro h hpx; exact h (p.injective (hpx.trans ha.symm))
+
+lemma NoncommBalanced.exists_smaller (D : NoncommBalanced R Inc ι) (hR : R.GenusZero)
+    (a : α) (ha : D.weight a = 1) :
+    ∃ (β : Type u) (iβ : Fintype β) (S : Ribbon β),
+      @Fintype.card β iβ < Fintype.card α ∧ @Ribbon.GenusZero β iβ S ∧
+        Nonempty (@NoncommBalanced β V F A B iβ _ _ S Inc ι) := by
+  classical
+  let D' := D.detach a ha
+  have hea : D'.exception ≠ a := by
+    intro he
+    apply D'.black_defect
+    rw [he]
+    change D'.potential ((R.detach a).black a) =
+      D'.potential a * ι (D.blackLabel a) (D.whiteLabel a) (D.weight a)
+    rw [R.detach_fixed_black a, ha, map_one, mul_one]
+  let hb := fixed_compl_invariant (R.detach a).black a (R.detach_fixed_black a)
+  let hw := fixed_compl_invariant (R.detach a).white a (R.detach_fixed_white a)
+  let S := (R.detach a).restrict (fun x => x ≠ a) hb hw
+  have hcard : Fintype.card {x : α // x ≠ a} < Fintype.card α :=
+    Fintype.card_subtype_lt (x := a) (by simp)
+  refine ⟨{x : α // x ≠ a}, _, S, ?_,
+    (R.detach a).planar_restrict (R.genusZero_detach hR a) (fun x : α => x ≠ a) hb hw, ?_⟩
+  · convert hcard
+  · exact ⟨D'.restrict (fun x => x ≠ a) hb hw hea⟩
+
+lemma Ribbon.mergeBlack_separates (R : Ribbon α) (hR : R.GenusZero) (a : α)
+    (hne : a ≠ R.black (R.white a))
+    (hs : R.black.SameCycle a (R.black (R.white a))) :
+    ¬ (R.mergeBlack a).components.r a (R.black (R.white a)) := by
+  let b := R.black (R.white a)
+  let S := R.swapBlack a b
+  have hback : S.swapBlack a b = R := R.swapBlack_twice a b
+  have hn : ¬ S.black.SameCycle a b := not_sameCycle_swap_of_sameCycle R.black a b hne hs
+  have hbc := swap_mul_cycles_card_split R.black a b hne hs
+  have hf : R.face (R.white a) ≠ R.white a := by
+    intro h
+    exact hne (R.white.injective h).symm
+  have hfc := unplug_cycles_card R.face (R.white a) hf
+  rw [← R.mergeBlack_face a] at hfc
+  have hcomp := S.swapBlack_components_merge a b hn
+  rw [hback] at hcomp
+  intro hc
+  change S.components.r a b at hc
+  rw [joinPair_eq_of_related S.components hc] at hcomp
+  have hbnd := S.euler_le
+  change Nat.card (Cycles S.black) = Nat.card (Cycles R.black) + 1 at hbc
+  change Nat.card (Cycles S.face) = Nat.card (Cycles R.face) + 1 at hfc
+  have hw : S.white = R.white := rfl
+  rw [hw, ← hcomp] at hbnd
+  unfold Ribbon.GenusZero at hR
+  omega
+
+end OddKaplansky.Planar
+
+namespace OddKaplansky.Planar
+open Equiv Equiv.Perm
+variable {α : Type portUniverse31} {V : Type portUniverse32} {F : Type portUniverse33} {A : Type portUniverse34} {B : Type portUniverse35} [Fintype α] [CommGroup A] [Group B]
+
+structure ShortWords (Inc : V → F → Prop) (ι : V → F → (A →* B)) : Prop where
+  one : ∀ v f, Inc v f → ∀ a, a ≠ 1 → ι v f a ≠ 1
+  two : ∀ v f g, Inc v f → Inc v g → f ≠ g →
+    ∀ a b, a ≠ 1 → b ≠ 1 → ι v f a * ι v g b ≠ 1
+  three : ∀ v f g h, Inc v f → Inc v g → Inc v h →
+    f ≠ g → g ≠ h → h ≠ f →
+    ∀ a b c, a ≠ 1 → b ≠ 1 → c ≠ 1 → ι v f a * ι v g b * ι v h c ≠ 1
+
+variable {R : Ribbon α} {Inc : V → F → Prop} {ι : V → F → (A →* B)}
+
+lemma NoncommBalanced.black_fixed_exception (D : NoncommBalanced R Inc ι)
+    (hred : D.Reduced) (hshort : ShortWords Inc ι) (a : α) (ha : R.black a = a) :
+    a = D.exception := by
+  by_contra hn
+  have h := D.black_balance a hn
+  rw [ha] at h
+  apply hshort.one _ _ (D.incident a) _ (hred.1 a)
+  exact mul_left_cancel (h.symm.trans (mul_one _).symm)
+
+lemma NoncommBalanced.cycle_product_eq_one (D : NoncommBalanced R Inc ι)
+    (a : α) (ha : ¬ R.black.SameCycle a D.exception) (n : ℕ)
+    (hn : (R.black^n) a = a) :
+    ((List.range n).map fun k =>
+      ι (D.blackLabel ((R.black^k) a)) (D.whiteLabel ((R.black^k) a))
+        (D.weight ((R.black^k) a))).prod = 1 := by
+  have h := D.black_iterate a ha n
+  rw [hn] at h
+  exact mul_left_cancel (h.symm.trans (mul_one _).symm)
+
+lemma NoncommBalanced.black_degree (D : NoncommBalanced R Inc ι) (hred : D.Reduced)
+    (hshort : ShortWords Inc ι) (c : Cycles R.black) :
+    4 ≤ (cycleSet R.black c).card + if c = cycleClass R.black D.exception then 3 else 0 := by
+  classical
+  have hpos := (cycleSet_nonempty R.black c).card_pos
+  by_cases hc : c = cycleClass R.black D.exception
+  · rw [ite_eq_left hc]; omega
+  rw [ite_eq_right hc, add_zero]
+  obtain ⟨a, ha⟩ := cycleSet_nonempty R.black c
+  have hac : cycleClass R.black a = c := (mem_cycleSet _ _ _).mp ha
+  have hae : ¬ R.black.SameCycle a D.exception := by
+    intro h
+    exact hc (hac.symm.trans ((cycleClass_eq _ _ _).mpr h))
+  have hb : D.blackLabel (R.black a) = D.blackLabel a := D.blackLabel_rot a
+  have hbb : D.blackLabel ((R.black^2) a) = D.blackLabel a := by
+    simp only [pow_two, Perm.mul_apply, D.blackLabel_rot]
+  have hp (n : ℕ) (hn : (cycleSet R.black c).card = n) : (R.black^n) a = a := by
+    rw [← hn, ← hac]
+    exact cycleSet_card_pow R.black a
+  have hnf (hcard : 1 < (cycleSet R.black c).card) : R.black a ≠ a := by
+    intro h
+    rw [← hac, cycleSet_singleton_of_fixed R.black a h, Finset.card_singleton] at hcard
+    omega
+  by_contra! hcard
+  have hs : (cycleSet R.black c).card = 1 ∨ (cycleSet R.black c).card = 2 ∨
+      (cycleSet R.black c).card = 3 := by omega
+  rcases hs with h1 | h2 | h3
+  · have hz := D.cycle_product_eq_one a hae 1 (hp 1 h1)
+    simp at hz
+    exact hshort.one _ _ (D.incident a) _ (hred.1 a) hz
+  · have hz := D.cycle_product_eq_one a hae 2 (hp 2 h2)
+    simp [List.range_succ, hb] at hz
+    have hi : Inc (D.blackLabel a) (D.whiteLabel (R.black a)) := by
+      rw [← hb]; exact D.incident _
+    exact hshort.two _ _ _ (D.incident a) hi
+      (hred.2.1 a (hnf (by omega))).symm _ _ (hred.1 a) (hred.1 _) hz
+  · have hz := D.cycle_product_eq_one a hae 3 (hp 3 h3)
+    simp [List.range_succ, hb, hbb] at hz
+    have hi : Inc (D.blackLabel a) (D.whiteLabel (R.black a)) := by
+      rw [← hb]; exact D.incident _
+    have hj : Inc (D.blackLabel a) (D.whiteLabel ((R.black^2) a)) := by
+      rw [← hbb]; exact D.incident _
+    have hnf₀ := hnf (by omega)
+    have hnf₁ : R.black (R.black a) ≠ R.black a := fun h => hnf₀ (R.black.injective h)
+    have hnf₂ : R.black ((R.black^2) a) ≠ (R.black^2) a := by
+      intro h
+      exact hnf₀ (((SameCycle.refl R.black a).pow_right (n := 2)).apply_eq_self_iff.mpr h)
+    have h01 := (hred.2.1 a hnf₀).symm
+    have h12 : D.whiteLabel (R.black a) ≠ D.whiteLabel ((R.black^2) a) := by
+      simpa only [pow_two, Perm.mul_apply] using (hred.2.1 (R.black a) hnf₁).symm
+    have h20 : D.whiteLabel ((R.black^2) a) ≠ D.whiteLabel a := by
+      have hh := (hred.2.1 ((R.black^2) a) hnf₂).symm
+      have hh' : R.black ((R.black^2) a) = a := by
+        simpa only [show 3 = 2+1 from rfl, pow_succ', Perm.mul_apply] using hp 3 h3
+      rwa [hh'] at hh
+    apply hshort.three _ _ _ _ (D.incident a) hi hj h01 h12 h20 _ _ _
+      (hred.1 a) (hred.1 _) (hred.1 _)
+    simpa only [mul_assoc] using hz
+
+lemma NoncommBalanced.white_degree (D : NoncommBalanced R Inc ι) (hred : D.Reduced)
+    (c : Cycles R.white) : 2 ≤ (cycleSet R.white c).card := by
+  have hpos := (cycleSet_nonempty R.white c).card_pos
+  by_contra! h
+  have hc : (cycleSet R.white c).card = 1 := by omega
+  obtain ⟨a, ha⟩ := Finset.card_eq_one.mp hc
+  have hz := D.white_prod c
+  rw [ha, Finset.prod_singleton] at hz
+  exact hred.1 a hz
+
+end OddKaplansky.Planar
+
+namespace OddKaplansky.Planar
+open Equiv Equiv.Perm
+variable {α : Type portUniverse36} {V : Type portUniverse37} {F : Type portUniverse38} {A : Type portUniverse39} {B : Type portUniverse40} [Fintype α] [CommGroup A] [Group B]
+
+def incidenceGraph (Inc : V → F → Prop) : SimpleGraph (Sum V F) where
+  Adj x y := match x, y with
+    | .inl v, .inr f => Inc v f
+    | .inr f, .inl v => Inc v f
+    | _, _ => False
+  symm := ⟨by intro x y; cases x <;> cases y <;> simp⟩
+  loopless := ⟨by intro x; cases x <;> simp⟩
+
+variable {R : Ribbon α} {Inc : V → F → Prop} {ι : V → F → (A →* B)}
+
+def NoncommBalanced.exceptionFace (D : NoncommBalanced R Inc ι) : Cycles R.face :=
+  cycleClass R.face D.exception
+
+lemma NoncommBalanced.black_not_fixed_on_other_face (D : NoncommBalanced R Inc ι)
+    (hred : D.Reduced) (hshort : ShortWords Inc ι) {a : α}
+    (ha : cycleClass R.face a ≠ D.exceptionFace) : R.black a ≠ a := by
+  intro h
+  apply ha
+  rw [D.black_fixed_exception hred hshort a h]
+  rfl
+
+def NoncommBalanced.halfStep (D : NoncommBalanced R Inc ι) (a : α) :
+    (incidenceGraph Inc).Walk (.inr (D.whiteLabel a)) (.inr (D.whiteLabel (R.face a))) :=
+  .cons (v := .inl (D.blackLabel a)) (by exact D.incident a) (.cons (by
+    change Inc (D.blackLabel a) (D.whiteLabel (R.white (R.black a)))
+    rw [D.whiteLabel_rot, ← D.blackLabel_rot a]
+    exact D.incident (R.black a)) .nil)
+
+lemma NoncommBalanced.halfStep_length (D : NoncommBalanced R Inc ι) (a : α) :
+    (D.halfStep a).length = 2 := rfl
+
+def NoncommBalanced.boundary (D : NoncommBalanced R Inc ι) (a : α) : (n : ℕ) →
+    (incidenceGraph Inc).Walk (.inr (D.whiteLabel a))
+      (.inr (D.whiteLabel ((R.face ^ n) a)))
+  | 0 => .nil
+  | n + 1 => (D.halfStep a).append ((D.boundary (R.face a) n).copy rfl (by
+      simp only [pow_succ, Perm.mul_apply]))
+
+lemma NoncommBalanced.boundary_length (D : NoncommBalanced R Inc ι) (a : α) (n : ℕ) :
+    (D.boundary a n).length = 2 * n := by
+  induction n generalizing a with
+  | zero => rfl
+  | succ n ih =>
+    simp only [NoncommBalanced.boundary, SimpleGraph.Walk.length_append,
+      SimpleGraph.Walk.length_copy, NoncommBalanced.halfStep_length, ih]
+    omega
+
+lemma NoncommBalanced.boundary_getVert_even (D : NoncommBalanced R Inc ι) (n k : ℕ) (hk : k ≤ n)
+    (a : α) : (D.boundary a n).getVert (2 * k) =
+      .inr (D.whiteLabel ((R.face ^ k) a)) := by
+  induction n generalizing a k with
+  | zero => have : k = 0 := Nat.le_zero.mp hk
+            subst k
+            rfl
+  | succ n ih =>
+    cases k with
+    | zero => simp
+    | succ k =>
+      simp only [NoncommBalanced.boundary, SimpleGraph.Walk.getVert_append]
+      rw [ite_eq_right (by simp only [NoncommBalanced.halfStep_length]; omega),
+        SimpleGraph.Walk.getVert_copy, NoncommBalanced.halfStep_length]
+      have heq : 2 * (k + 1) - 2 = 2 * k := by omega
+      rw [heq, ih k (by omega)]
+      simp only [pow_succ, Perm.mul_apply]
+
+lemma NoncommBalanced.boundary_getVert_odd (D : NoncommBalanced R Inc ι) (n k : ℕ) (hk : k < n)
+    (a : α) : (D.boundary a n).getVert (2 * k + 1) =
+      .inl (D.blackLabel ((R.face ^ k) a)) := by
+  induction n generalizing a k with
+  | zero => omega
+  | succ n ih =>
+    cases k with
+    | zero => rfl
+    | succ k =>
+      simp only [NoncommBalanced.boundary, SimpleGraph.Walk.getVert_append]
+      rw [ite_eq_right (by simp only [NoncommBalanced.halfStep_length]; omega),
+        SimpleGraph.Walk.getVert_copy, NoncommBalanced.halfStep_length]
+      have heq : 2 * (k + 1) + 1 - 2 = 2 * k + 1 := by omega
+      rw [heq, ih k (by omega)]
+      simp only [pow_succ, Perm.mul_apply]
+
+omit [Fintype α] in
+lemma cycleClass_pow (p : Perm α) (a : α) (n : ℕ) :
+    cycleClass p ((p ^ n) a) = cycleClass p a :=
+  (cycleClass_eq _ _ _).mpr ((SameCycle.refl p a).pow_left)
+
+lemma NoncommBalanced.boundary_reduced (D : NoncommBalanced R Inc ι) (hred : D.Reduced)
+    (hshort : ShortWords Inc ι) {a : α}
+    (ha : cycleClass R.face a ≠ D.exceptionFace) (n : ℕ) :
+    _root_.OAI.SimpleGraph.Walk.Reduced (D.boundary a n) := by
+  apply SimpleGraph.Walk.reduced_of_getVert
+  intro i hi
+  rw [D.boundary_length] at hi
+  have he : i = 2 * (i / 2) ∨ i = 2 * (i / 2) + 1 := by omega
+  rcases he with he | he
+  · rw [he, D.boundary_getVert_even n (i / 2) (by omega)]
+    have hk : 2 * (i / 2) + 2 = 2 * (i / 2 + 1) := by omega
+    rw [hk, D.boundary_getVert_even n (i / 2 + 1) (by omega)]
+    intro h
+    have hh := Sum.inr.inj h
+    rw [pow_succ', Perm.mul_apply] at hh
+    change D.whiteLabel ((R.face ^ (i / 2)) a) =
+      D.whiteLabel (R.white (R.black ((R.face ^ (i / 2)) a))) at hh
+    rw [D.whiteLabel_rot] at hh
+    exact hred.2.1 _ (D.black_not_fixed_on_other_face hred hshort (by rwa [cycleClass_pow])) hh.symm
+  · rw [he, D.boundary_getVert_odd n (i / 2) (by omega)]
+    have hk : 2 * (i / 2) + 1 + 2 = 2 * (i / 2 + 1) + 1 := by omega
+    rw [hk, D.boundary_getVert_odd n (i / 2 + 1) (by omega)]
+    intro h
+    have hh := Sum.inl.inj h
+    rw [pow_succ', Perm.mul_apply] at hh
+    change D.blackLabel ((R.face ^ (i / 2)) a) =
+      D.blackLabel (R.white (R.black ((R.face ^ (i / 2)) a))) at hh
+    have hn : R.white (R.black ((R.face ^ (i / 2)) a)) ≠
+        R.black ((R.face ^ (i / 2)) a) :=
+      D.white_not_fixed hred.1 _
+    exact hred.2.2 _ hn (hh.symm.trans (D.blackLabel_rot _).symm)
+
+lemma NoncommBalanced.face_degree (D : NoncommBalanced R Inc ι) (hred : D.Reduced)
+    (hshort : ShortWords Inc ι)
+    (hgirth : 8 ≤ (incidenceGraph Inc).egirth) (c : Cycles R.face) :
+    4 ≤ (cycleSet R.face c).card + if c = D.exceptionFace then 4 else 0 := by
+  classical
+  by_cases hc : c = D.exceptionFace
+  · rw [ite_eq_left hc]; omega
+  rw [ite_eq_right hc, add_zero]
+  obtain ⟨a, ha⟩ := cycleSet_nonempty R.face c
+  have hac : cycleClass R.face a = c := (mem_cycleSet _ _ _).mp ha
+  let n := (cycleSet R.face c).card
+  have hpa : (R.face ^ n) a = a := by
+    change (R.face ^ (cycleSet R.face c).card) a = a
+    rw [← hac]
+    exact cycleSet_card_pow R.face a
+  let p : (incidenceGraph Inc).Walk (.inr (D.whiteLabel a)) (.inr (D.whiteLabel a)) :=
+    (D.boundary a n).copy rfl (by rw [hpa])
+  have hp : _root_.OAI.SimpleGraph.Walk.Reduced p := by
+    exact (D.boundary_reduced hred hshort (by rwa [hac]) n).copy _ _
+  have hlen : p.length = 2 * n := by simp only [p, SimpleGraph.Walk.length_copy,
+    D.boundary_length]
+  have hne : ¬ p.Nil := by
+    intro h
+    have := SimpleGraph.Walk.Nil.length_eq_zero h
+    have hn : 0 < n := (cycleSet_nonempty R.face c).card_pos
+    omega
+  have hg := hgirth.trans (hp.egirth_le hne)
+  rw [hlen] at hg
+  have hnat : 8 ≤ 2 * n := by exact_mod_cast hg
+  change 4 ≤ n
+  omega
+
+theorem NoncommBalanced.reduced_not_genusZero (D : NoncommBalanced R Inc ι)
+    (hred : D.Reduced) (hshort : ShortWords Inc ι)
+    (hgirth : 8 ≤ (incidenceGraph Inc).egirth) : ¬ R.GenusZero := by
+  classical
+  intro hR
+  have hb := D.black_degree hred hshort
+  have hw := D.white_degree hred
+  have hf := D.face_degree hred hshort hgirth
+  have hb' := Finset.sum_le_sum (fun c (_ : c ∈ (Finset.univ : Finset (Cycles R.black))) => hb c)
+  have hw' := Finset.sum_le_sum (fun c (_ : c ∈ (Finset.univ : Finset (Cycles R.white))) => hw c)
+  have hf' := Finset.sum_le_sum (fun c (_ : c ∈ (Finset.univ : Finset (Cycles R.face))) => hf c)
+  simp only [Finset.sum_const, Finset.card_univ, smul_eq_mul, cycles_sum_card] at hw'
+  simp only [Finset.sum_const, Finset.card_univ, smul_eq_mul, Finset.sum_add_distrib,
+    cycles_sum_card, Finset.sum_ite_eq', Finset.mem_univ, ite_true] at hb' hf'
+  have hc : 0 < Nat.card (Quotient R.components) := by
+    have : Nonempty (Quotient R.components) := ⟨Quotient.mk _ D.exception⟩
+    exact Nat.card_pos
+  unfold Ribbon.GenusZero at hR
+  simp only [Nat.card_eq_fintype_card] at hR hc
+  omega
+
+end OddKaplansky.Planar
+
+namespace OddKaplansky.Planar
+open Equiv Equiv.Perm OddKaplansky.Holonomy
+universe u
+variable {α : Type u} {V : Type portUniverse41} {F : Type portUniverse42} {A : Type portUniverse43} {B : Type portUniverse44} [Fintype α] [CommGroup A] [Group B]
+variable {R : Ribbon α} {Inc : V → F → Prop} {ι : V → F → (A →* B)}
+
+def NoncommBalanced.spliceRestrict (D : NoncommBalanced R Inc ι) (a b : α)
+    (hl : D.blackLabel a = D.blackLabel b) (P : α → Prop)
+    (hb : ∀ x, P ((R.swapBlack a b).black x) ↔ P x)
+    (hw : ∀ x, P (R.white x) ↔ P x)
+    (E : Defect ((R.swapBlack a b).black.subtypePerm hb) (fun x => D.localWeight x.val)) :
+    NoncommBalanced ((R.swapBlack a b).restrict P hb hw) Inc ι where
+  blackLabel x := D.blackLabel x.val
+  whiteLabel x := D.whiteLabel x.val
+  blackLabel_rot x := by
+    change D.blackLabel (swap a b (R.black x.val)) = D.blackLabel x.val
+    rw [label_swap D.blackLabel a b hl, D.blackLabel_rot]
+  whiteLabel_rot x := D.whiteLabel_rot x.val
+  incident x := D.incident x.val
+  weight x := D.weight x.val
+  white_prod c := by
+    dsimp only [Ribbon.restrict, Ribbon.swapBlack] at c ⊢
+    rw [prod_cycle_subtype R.white P hw c D.weight]
+    exact D.white_prod _
+  potential := E.potential
+  exception := E.exception
+  black_balance := E.balance
+  black_defect := E.defective
+
+lemma NoncommBalanced.exists_smaller_of_split (D : NoncommBalanced R Inc ι) (a b : α)
+    (hl : D.blackLabel a = D.blackLabel b)
+    (hS : (R.swapBlack a b).GenusZero)
+    (hsep : ¬ (R.swapBlack a b).components.r a b)
+    (hne : D.potential a ≠ D.potential b) :
+    ∃ (β : Type u) (iβ : Fintype β) (S : Ribbon β),
+      @Fintype.card β iβ < Fintype.card α ∧ @Ribbon.GenusZero β iβ S ∧
+        Nonempty (@NoncommBalanced β V F A B iβ _ _ S Inc ι) := by
+  classical
+  have side (a b : α) (hl : D.blackLabel a = D.blackLabel b)
+      (hS : (R.swapBlack a b).GenusZero)
+      (hab : ¬ (R.swapBlack a b).components.r b a)
+      (he : ¬ (R.swapBlack a b).components.r D.exception a)
+      (hne : D.potential a ≠ D.potential b) :
+      ∃ (β : Type u) (iβ : Fintype β) (S : Ribbon β),
+        @Fintype.card β iβ < Fintype.card α ∧ @Ribbon.GenusZero β iβ S ∧
+          Nonempty (@NoncommBalanced β V F A B iβ _ _ S Inc ι) := by
+    let S := R.swapBlack a b
+    let P := fun x => S.components.r x a
+    let hb := S.black_component_invariant a
+    let hw := S.white_component_invariant a
+    let E := D.defect.splitRestrict a b hne P hb (S.components.iseqv.refl a) hab he
+    refine ⟨{x // P x}, _, S.restrict P hb hw, ?_, S.planar_restrict hS P hb hw, ?_⟩
+    · exact Fintype.card_subtype_lt (x := b) hab
+    · exact ⟨D.spliceRestrict a b hl P hb hw E⟩
+  have hswap : R.swapBlack b a = R.swapBlack a b := by
+    simp only [Ribbon.swapBlack, swap_comm]
+  by_cases he : (R.swapBlack a b).components.r D.exception a
+  · apply side b a hl.symm
+    · rwa [hswap]
+    · rwa [hswap]
+    · intro hb
+      have hb' : (R.swapBlack a b).components.r D.exception b := by
+        rwa [hswap] at hb
+      exact hsep ((R.swapBlack a b).components.iseqv.trans
+        ((R.swapBlack a b).components.iseqv.symm he) hb')
+    · exact Ne.symm hne
+  · exact side a b hl hS (fun h => hsep ((R.swapBlack a b).components.iseqv.symm h)) he hne
+
+def NoncommBalanced.Minimal (_D : NoncommBalanced R Inc ι) : Prop :=
+  ∀ (β : Type u) (iβ : Fintype β) (S : Ribbon β), @Ribbon.GenusZero β iβ S →
+    Nonempty (@NoncommBalanced β V F A B iβ _ _ S Inc ι) →
+    Fintype.card α ≤ @Fintype.card β iβ
+
+lemma NoncommBalanced.minimal_no_one (D : NoncommBalanced R Inc ι) (hR : R.GenusZero)
+    (hm : D.Minimal) (a : α) : D.weight a ≠ 1 := by
+  intro ha
+  obtain ⟨β, iβ, S, hc, hS, hD⟩ := D.exists_smaller hR a ha
+  exact (not_lt_of_ge (hm β iβ S hS hD)) hc
+
+lemma NoncommBalanced.minimal_black_reduced (D : NoncommBalanced R Inc ι)
+    (hR : R.GenusZero) (hm : D.Minimal) (a : α) (ha : R.black a ≠ a) :
+    D.whiteLabel (R.black a) ≠ D.whiteLabel a := by
+  intro hl
+  by_cases hw : R.white.SameCycle a (R.black a)
+  · let E := D.combine a (R.black a) ha.symm rfl hw
+    have hEm : E.Minimal := hm
+    exact E.minimal_no_one hR hEm a (by simp [E, NoncommBalanced.combine,
+      NoncommBalanced.withDefect, combineWeight])
+  · let E := D.mergeWhite a hw hl
+    have hER := R.genusZero_mergeWhite hR a hw
+    have hab : (R.mergeWhite a).white.SameCycle a (R.black a) := by
+      have h := swap_mul_sameCycle R.white a (R.face a) (by simpa [Ribbon.face] using hw)
+      exact h.trans ((sameCycle_swap_mul R.white a (R.face a)
+        (by simpa [Ribbon.face] using hw)) ((SameCycle.refl R.white (R.black a)).apply_left))
+    let E' := E.combine a (R.black a) ha.symm rfl hab
+    have hEm : E'.Minimal := hm
+    exact E'.minimal_no_one hER hEm a (by simp [E', NoncommBalanced.combine,
+      NoncommBalanced.withDefect, combineWeight])
+
+lemma NoncommBalanced.minimal_white_reduced (D : NoncommBalanced R Inc ι)
+    (hR : R.GenusZero) (hm : D.Minimal) (a : α) (ha : R.white a ≠ a) :
+    D.blackLabel (R.white a) ≠ D.blackLabel a := by
+  classical
+  intro hl
+  let b := R.white a
+  have hba : b ≠ a := ha
+  have hw : R.white.SameCycle b a := (SameCycle.refl R.white a).apply_left
+  by_cases hp : R.black b = a
+  · let E := D.combine b a hba hp hw
+    have hEm : E.Minimal := hm
+    exact E.minimal_no_one hR hEm b (by simp [E, NoncommBalanced.combine,
+      NoncommBalanced.withDefect, combineWeight])
+  have hl' : D.blackLabel a = D.blackLabel (R.black b) := by rw [D.blackLabel_rot, hl]
+  have hpa : a ≠ R.black b := Ne.symm hp
+  have finish (E : Holonomy.Defect (swap a (R.black b) * R.black) D.localWeight)
+      (hS : (R.swapBlack a (R.black b)).GenusZero) : False := by
+    let D' := D.spliceBlack a (R.black b) hl' E
+    have hrot : (R.swapBlack a (R.black b)).black b = a := by simp [Ribbon.swapBlack]
+    let D'' := D'.combine b a hba hrot hw
+    have hDm : D''.Minimal := hm
+    exact D''.minimal_no_one hS hDm b (by simp [D'', NoncommBalanced.combine,
+      NoncommBalanced.withDefect, combineWeight])
+  by_cases hs : R.black.SameCycle a (R.black b)
+  · have hS := R.genusZero_swapBlack_split hR a (R.black b) hpa hs
+    by_cases ht : D.potential a = D.potential (R.black b)
+    · exact finish (D.defect.swapEqual a (R.black b) ht) hS
+    · have hsep := R.mergeBlack_separates hR a hpa hs
+      obtain ⟨β, iβ, S, hc, hS', hD⟩ := D.exists_smaller_of_split a (R.black b) hl' hS hsep ht
+      exact (not_lt_of_ge (hm β iβ S hS' hD)) hc
+  · have hS : (R.swapBlack a (R.black b)).GenusZero :=
+      R.genusZero_mergeBlack hR a (by simpa only [sameCycle_apply_right] using hs)
+    exact finish (D.defect.merge a (R.black b) hs) hS
+
+lemma NoncommBalanced.minimal_reduced (D : NoncommBalanced R Inc ι)
+    (hR : R.GenusZero) (hm : D.Minimal) : D.Reduced :=
+  ⟨D.minimal_no_one hR hm, D.minimal_black_reduced hR hm, D.minimal_white_reduced hR hm⟩
+
+theorem NoncommBalanced.not_genusZero (D : NoncommBalanced R Inc ι)
+    (hshort : ShortWords Inc ι) (hgirth : 8 ≤ (incidenceGraph Inc).egirth) :
+    ¬ R.GenusZero := by
+  intro hR
+  let P : ℕ → Prop := fun n => ∃ (β : Type u) (iβ : Fintype β) (S : Ribbon β),
+    @Fintype.card β iβ = n ∧ @Ribbon.GenusZero β iβ S ∧
+      Nonempty (@NoncommBalanced β V F A B iβ _ _ S Inc ι)
+  have hex : ∃ n, P n := ⟨Fintype.card α, α, inferInstance, R, rfl, hR, ⟨D⟩⟩
+  classical
+  obtain ⟨β, iβ, S, hcard, hS, ⟨E⟩⟩ := Nat.find_spec hex
+  let := iβ
+  have hm : E.Minimal := by
+    intro γ iγ T hT hE
+    rw [hcard]
+    exact Nat.find_min' hex ⟨γ, iγ, T, rfl, hT, hE⟩
+  exact E.reduced_not_genusZero (E.minimal_reduced hS hm) hshort hgirth hS
+
+end OddKaplansky.Planar
+
+namespace OddKaplansky.Planar
+open Equiv Equiv.Perm
+variable {α : Type portUniverse45} {β : Type portUniverse46}
+
+def sumSetoid (s : Setoid α) (t : Setoid β) : Setoid (α ⊕ β) :=
+  Setoid.ker (Sum.map (Quotient.mk s) (Quotient.mk t))
+
+@[simp] lemma sumSetoid_inl (s : Setoid α) (t : Setoid β) (x y : α) :
+    (sumSetoid s t).r (.inl x) (.inl y) ↔ s.r x y := by
+  change (Sum.inl (Quotient.mk s x) : Quotient s ⊕ Quotient t) = .inl (Quotient.mk s y) ↔ _
+  simp only [Sum.inl.injEq, Quotient.eq]
+
+@[simp] lemma sumSetoid_inr (s : Setoid α) (t : Setoid β) (x y : β) :
+    (sumSetoid s t).r (.inr x) (.inr y) ↔ t.r x y := by
+  change (Sum.inr (Quotient.mk t x) : Quotient s ⊕ Quotient t) = .inr (Quotient.mk t y) ↔ _
+  simp only [Sum.inr.injEq, Quotient.eq]
+
+@[simp] lemma sumSetoid_cross (s : Setoid α) (t : Setoid β) (x : α) (y : β) :
+    ¬ (sumSetoid s t).r (.inl x) (.inr y) := by
+  change ¬ (Sum.inl (Quotient.mk s x) : Quotient s ⊕ Quotient t) = .inr (Quotient.mk t y)
+  simp
+
+def sumSetoidEquiv (s : Setoid α) (t : Setoid β) :
+    Quotient (sumSetoid s t) ≃ Quotient s ⊕ Quotient t :=
+  Setoid.quotientKerEquivOfSurjective (Sum.map (Quotient.mk s) (Quotient.mk t)) (by
+    rintro (x | y)
+    · induction x using Quotient.inductionOn with
+      | h x => exact ⟨.inl x, rfl⟩
+    · induction y using Quotient.inductionOn with
+      | h y => exact ⟨.inr y, rfl⟩)
+
+lemma sumSetoid_card [Fintype α] [Fintype β] (s : Setoid α) (t : Setoid β) :
+    Nat.card (Quotient (sumSetoid s t)) = Nat.card (Quotient s) + Nat.card (Quotient t) := by
+  rw [Nat.card_congr (sumSetoidEquiv s t), Nat.card_sum]
+
+lemma sumSetoid_le {s : Setoid α} {t : Setoid β} {r : Setoid (α ⊕ β)}
+    (hl : ∀ x y, s.r x y → r.r (.inl x) (.inl y))
+    (hr : ∀ x y, t.r x y → r.r (.inr x) (.inr y)) : sumSetoid s t ≤ r := by
+  rintro (x | x) (y | y) h
+  · exact hl x y ((sumSetoid_inl _ _ _ _).mp h)
+  · exact False.elim (sumSetoid_cross _ _ _ _ h)
+  · exact False.elim (sumSetoid_cross _ _ _ _ ((sumSetoid s t).iseqv.symm h))
+  · exact hr x y ((sumSetoid_inr _ _ _ _).mp h)
+
+variable [Fintype α] [Fintype β]
+
+lemma sumCongr_cycles_setoid (p : Perm α) (q : Perm β) :
+    SameCycle.setoid (Equiv.sumCongr p q) = sumSetoid (SameCycle.setoid p) (SameCycle.setoid q) := by
+  apply le_antisymm
+  · intro x y h
+    apply setoid_sameCycle_of_step _ (Equiv.sumCongr p q) _ h
+    rintro (z | z) <;> simp only [Equiv.sumCongr_apply, Sum.map_inl, Sum.map_inr,
+      sumSetoid_inl, sumSetoid_inr]
+    · exact SameCycle.apply_right SameCycle.rfl
+    · exact SameCycle.apply_right SameCycle.rfl
+  · apply sumSetoid_le
+    · intro x y h
+      exact sameCycle_map p (Equiv.sumCongr p q) Sum.inl
+        (fun z => SameCycle.apply_right SameCycle.rfl) h
+    · intro x y h
+      exact sameCycle_map q (Equiv.sumCongr p q) Sum.inr
+        (fun z => SameCycle.apply_right SameCycle.rfl) h
+
+lemma sumCongr_cycles_card (p : Perm α) (q : Perm β) :
+    Nat.card (Cycles (Equiv.sumCongr p q)) = Nat.card (Cycles p) + Nat.card (Cycles q) := by
+  rw [Cycles, sumCongr_cycles_setoid]
+  exact sumSetoid_card _ _
+
+def Ribbon.sum (R : Ribbon α) (S : Ribbon β) : Ribbon (α ⊕ β) :=
+  ⟨Equiv.sumCongr R.black S.black, Equiv.sumCongr R.white S.white⟩
+
+omit [Fintype α] [Fintype β] in
+lemma Ribbon.sum_face (R : Ribbon α) (S : Ribbon β) :
+    (R.sum S).face = Equiv.sumCongr R.face S.face := by
+  ext x
+  cases x <;> rfl
+
+lemma Ribbon.sum_components (R : Ribbon α) (S : Ribbon β) :
+    (R.sum S).components = sumSetoid R.components S.components := by
+  apply le_antisymm
+  · apply (R.sum S).components_le_of_steps
+    · rintro (x | x)
+      · exact (sumSetoid_inl _ _ _ _).mpr (R.black_step x)
+      · exact (sumSetoid_inr _ _ _ _).mpr (S.black_step x)
+    · rintro (x | x)
+      · exact (sumSetoid_inl _ _ _ _).mpr (R.white_step x)
+      · exact (sumSetoid_inr _ _ _ _).mpr (S.white_step x)
+  · apply sumSetoid_le
+    · have h := R.components_le_of_steps ((R.sum S).components.comap Sum.inl)
+        (fun x => (R.sum S).black_step (.inl x))
+        (fun x => (R.sum S).white_step (.inl x))
+      exact fun x y hxy => h hxy
+    · have h := S.components_le_of_steps ((R.sum S).components.comap Sum.inr)
+        (fun x => (R.sum S).black_step (.inr x))
+        (fun x => (R.sum S).white_step (.inr x))
+      exact fun x y hxy => h hxy
+
+lemma Ribbon.genusZero_sum (R : Ribbon α) (S : Ribbon β)
+    (hR : R.GenusZero) (hS : S.GenusZero) : (R.sum S).GenusZero := by
+  unfold Ribbon.GenusZero at *
+  rw [R.sum_face, R.sum_components, sumSetoid_card, Fintype.card_sum]
+  change Nat.card (Cycles (Equiv.sumCongr R.black S.black)) +
+    Nat.card (Cycles (Equiv.sumCongr R.white S.white)) + _ = _
+  rw [sumCongr_cycles_card, sumCongr_cycles_card, sumCongr_cycles_card]
+  omega
+
+omit [Fintype α] [Fintype β] in
+lemma formPerm_append_nonempty [DecidableEq α] (a b : α) (l m : List α)
+    (hb : b ∉ a :: l) :
+    ((a :: l) ++ (b :: m)).formPerm = swap a b * (a :: l).formPerm * (b :: m).formPerm := by
+  induction l generalizing a with
+  | nil => simp
+  | cons c l ih =>
+    have hba : b ≠ a := fun h => hb (by simp [h])
+    have hbc : b ≠ c := fun h => hb (by simp [h])
+    have hc : b ∉ c :: l := fun h => hb (List.mem_cons_of_mem _ h)
+    have hs : swap a c * swap c b = swap a b * swap a c := by
+      rw [mul_swap_eq_swap_mul]
+      simp [swap_apply_of_ne_of_ne hba hbc]
+    simp only [List.cons_append, List.formPerm_cons_cons]
+    rw [show c :: (l ++ b :: m) = (c :: l) ++ (b :: m) from rfl, ih c hc]
+    simp only [← mul_assoc, hs]
+
+end OddKaplansky.Planar
+
+namespace OddKaplansky.Planar
+open Equiv Equiv.Perm
+variable {α : Type portUniverse47} [Fintype α]
+
+def Ribbon.wheel (p : Perm α) : Ribbon (α ⊕ α) :=
+  ⟨Equiv.sumCongr p p⁻¹, Equiv.sumComm α α⟩
+
+def sumIndex : α ⊕ α → α := Sum.elim id id
+
+def wheelFaceIndex (p : Perm α) : α ⊕ α → α := Sum.elim id (fun x => p⁻¹ x)
+
+omit [Fintype α] in
+@[simp] lemma wheel_white_index (p : Perm α) (x : α ⊕ α) :
+    sumIndex ((Ribbon.wheel p).white x) = sumIndex x := by cases x <;> rfl
+
+omit [Fintype α] in
+@[simp] lemma wheel_face_index (p : Perm α) (x : α ⊕ α) :
+    wheelFaceIndex p ((Ribbon.wheel p).face x) = wheelFaceIndex p x := by
+  cases x <;> simp [Ribbon.wheel, Ribbon.face, wheelFaceIndex]
+
+lemma wheel_white_setoid (p : Perm α) :
+    SameCycle.setoid (Ribbon.wheel p).white = Setoid.ker sumIndex := by
+  apply le_antisymm
+  · intro x y h
+    apply setoid_sameCycle_of_step _ (Ribbon.wheel p).white _ h
+    exact fun z => (wheel_white_index p z).symm
+  · rintro (x | x) (y | y) h <;> change x = y at h <;> subst y
+    · exact SameCycle.rfl
+    · exact SameCycle.apply_right SameCycle.rfl
+    · exact SameCycle.apply_right SameCycle.rfl
+    · exact SameCycle.rfl
+
+lemma wheel_face_setoid (p : Perm α) :
+    SameCycle.setoid (Ribbon.wheel p).face = Setoid.ker (wheelFaceIndex p) := by
+  apply le_antisymm
+  · intro x y h
+    apply setoid_sameCycle_of_step _ (Ribbon.wheel p).face _ h
+    exact fun z => (wheel_face_index p z).symm
+  · rintro (x | x) (y | y) h
+    · change x = y at h
+      subst y
+      exact SameCycle.rfl
+    · change x = p⁻¹ y at h
+      subst x
+      change (Ribbon.wheel p).face.SameCycle (.inl (p⁻¹ y)) (.inr y)
+      convert (SameCycle.apply_right
+        (SameCycle.rfl (f := (Ribbon.wheel p).face) (x := Sum.inl (p⁻¹ y)))) using 1
+      simp [Ribbon.wheel, Ribbon.face]
+    · change p⁻¹ x = y at h
+      subst y
+      exact SameCycle.apply_right SameCycle.rfl
+    · change p⁻¹ x = p⁻¹ y at h
+      have := p.symm.injective h
+      subst y
+      exact SameCycle.rfl
+
+lemma wheel_component_index (p : Perm α) :
+    (Ribbon.wheel p).components = Setoid.ker (cycleClass p ∘ sumIndex) := by
+  let R := Ribbon.wheel p
+  apply le_antisymm
+  · apply R.components_le_of_steps
+    · rintro (x | x)
+      · exact (cycleClass_apply p x).symm
+      · change cycleClass p x = cycleClass p (p⁻¹ x)
+        exact (cycleClass_eq _ _ _).mpr (by simp [SameCycle.rfl])
+    · intro x
+      change cycleClass p (sumIndex x) = cycleClass p (sumIndex (R.white x))
+      rw [wheel_white_index]
+  · intro x y h
+    have hx : R.components.r x (.inl (sumIndex x)) := by
+      cases x with
+      | inl x => exact R.components.iseqv.refl _
+      | inr x => exact R.white_step (.inr x)
+    have hy : R.components.r y (.inl (sumIndex y)) := by
+      cases y with
+      | inl y => exact R.components.iseqv.refl _
+      | inr y => exact R.white_step (.inr y)
+    have hxy : p.SameCycle (sumIndex x) (sumIndex y) := (cycleClass_eq _ _ _).mp h
+    have hp : R.black.SameCycle (.inl (sumIndex x)) (.inl (sumIndex y)) :=
+      sameCycle_map p R.black Sum.inl (fun z => SameCycle.apply_right SameCycle.rfl) hxy
+    exact R.components.iseqv.trans hx (R.components.iseqv.trans
+      ((show SameCycle.setoid R.black ≤ R.components from le_sup_left) hp)
+      (R.components.iseqv.symm hy))
+
+lemma wheel_white_card (p : Perm α) :
+    Nat.card (Cycles (Ribbon.wheel p).white) = Fintype.card α := by
+  rw [Cycles, wheel_white_setoid]
+  exact (Nat.card_congr (Setoid.quotientKerEquivOfSurjective sumIndex
+    (fun x => ⟨.inl x, rfl⟩))).trans Nat.card_eq_fintype_card
+
+lemma wheel_face_card (p : Perm α) :
+    Nat.card (Cycles (Ribbon.wheel p).face) = Fintype.card α := by
+  rw [Cycles, wheel_face_setoid]
+  exact (Nat.card_congr (Setoid.quotientKerEquivOfSurjective (wheelFaceIndex p)
+    (fun x => ⟨.inl x, rfl⟩))).trans Nat.card_eq_fintype_card
+
+lemma wheel_component_card (p : Perm α) :
+    Nat.card (Quotient (Ribbon.wheel p).components) = Nat.card (Cycles p) := by
+  rw [wheel_component_index]
+  apply Nat.card_congr
+  apply Setoid.quotientKerEquivOfSurjective
+  intro c
+  induction c using Quotient.inductionOn with
+  | h x => exact ⟨.inl x, rfl⟩
+
+lemma Ribbon.genusZero_wheel (p : Perm α) : (Ribbon.wheel p).GenusZero := by
+  unfold Ribbon.GenusZero
+  rw [wheel_white_card, wheel_face_card, wheel_component_card, Fintype.card_sum]
+  change Nat.card (Cycles (Equiv.sumCongr p p⁻¹)) + _ + _ = _
+  rw [sumCongr_cycles_card, cycles_inv_card]
+  omega
+
+end OddKaplansky.Planar
+
+namespace OddKaplansky.Planar
+open Equiv Equiv.Perm
+variable {α : Type portUniverse48} {β : Type portUniverse49} {A : Type portUniverse50} [Fintype α]
+
+def Follows (p : Perm α) (l : List α) : Prop := ∀ x ∈ l, p x = l.formPerm x
+
+omit [Fintype α] in
+lemma Follows.invariant {p : Perm α} {l : List α} (h : Follows p l) (x : α) :
+    p x ∈ l ↔ x ∈ l := by
+  classical
+  constructor
+  · intro hx
+    let y := l.formPerm⁻¹ (p x)
+    have hy : y ∈ l := by
+      apply l.mem_of_formPerm_apply_mem
+      simpa [y] using hx
+    have he : p y = p x := by rw [h y hy]; simp [y]
+    simpa [p.injective he] using hy
+  · intro hx
+    rw [h x hx]
+    exact l.formPerm_apply_mem_of_mem hx
+
+lemma Follows.sameCycle {p : Perm α} {l : List α} (h : Follows p l)
+    (hd : l.Nodup) {x y : α} (hx : x ∈ l) (hy : y ∈ l) : p.SameCycle x y := by
+  apply sameCycle_map l.formPerm p id _ (hd.isCycleOn_formPerm.2 hx hy)
+  intro z
+  by_cases hz : z ∈ l
+  · change p.SameCycle z (l.formPerm z)
+    rw [← h z hz]
+    exact SameCycle.apply_right SameCycle.rfl
+  · simp only [id_eq, List.formPerm_apply_of_notMem hz]
+    exact SameCycle.rfl
+
+lemma Follows.cycleSet {p : Perm α} {l : List α} (h : Follows p l)
+    (hd : l.Nodup) {x : α} (hx : x ∈ l) :
+    cycleSet p (cycleClass p x) = l.toFinset := by
+  classical
+  ext y
+  rw [mem_cycleSet, cycleClass_eq, List.mem_toFinset]
+  constructor
+  · intro hy
+    exact (perm_invariant_cycle p (fun z => z ∈ l) h.invariant hy).mpr hx
+  · exact fun hy => h.sameCycle hd hy hx
+
+lemma sameCycle_iff_of_eqOn_cycle (p q : Perm α) (x : α)
+    (heq : ∀ z, p.SameCycle x z → q z = p z) (y : α) :
+    q.SameCycle x y ↔ p.SameCycle x y := by
+  have hp : ∀ n : ℕ, (q ^ n) x = (p ^ n) x := by
+    intro n
+    induction n with
+    | zero => rfl
+    | succ n ih =>
+      rw [pow_succ', pow_succ', Perm.mul_apply, Perm.mul_apply, ih]
+      exact heq _ (by simp [SameCycle.rfl])
+  constructor
+  · intro h
+    obtain ⟨n, hn⟩ := h.exists_nat_pow_eq
+    rw [hp] at hn
+    exact ⟨n, by simpa using hn⟩
+  · intro h
+    obtain ⟨n, hn⟩ := h.exists_nat_pow_eq
+    exact ⟨n, by simpa [hp n] using hn⟩
+
+lemma cycleSet_eq_of_eqOn_cycle (p q : Perm α) (x : α)
+    (heq : ∀ z, p.SameCycle x z → q z = p z) :
+    cycleSet q (cycleClass q x) = cycleSet p (cycleClass p x) := by
+  ext y
+  simp only [mem_cycleSet, cycleClass_eq, sameCycle_comm (x := y)]
+  exact sameCycle_iff_of_eqOn_cycle p q x heq y
+
+omit [Fintype α] in
+lemma formPerm_map_apply [DecidableEq α] [DecidableEq β] (f : α → β)
+    (hf : Function.Injective f) (l : List α) (x : α) :
+    (l.map f).formPerm (f x) = f (l.formPerm x) := by
+  induction l with
+  | nil => simp
+  | cons a l ih =>
+    cases l with
+    | nil => simp
+    | cons b l =>
+      change swap (f a) (f b) (((b :: l).map f).formPerm (f x)) =
+        f (swap a b ((b :: l).formPerm x))
+      rw [ih]
+      exact (hf.map_swap a b _).symm
+
+omit [Fintype α] in
+lemma Follows.map_sum_left {p : Perm α} {q : Perm β} {l : List α}
+    (h : Follows p l) : Follows (Equiv.sumCongr p q) (l.map Sum.inl) := by
+  classical
+  intro y hy
+  obtain ⟨x, hx, rfl⟩ := List.mem_map.mp hy
+  simpa only [Equiv.sumCongr_apply, Sum.map_inl,
+    formPerm_map_apply Sum.inl Sum.inl_injective] using congrArg Sum.inl (h x hx)
+
+end OddKaplansky.Planar
+
+namespace OddKaplansky.Planar
+open Equiv Equiv.Perm
+variable {α : Type portUniverse51} {β : Type portUniverse52} {A : Type portUniverse53} [Fintype α] [Fintype β] [CommGroup A]
+
+@[simp] lemma sumCongr_sameCycle_inl (p : Perm α) (q : Perm β) (x y : α) :
+    SameCycle (Equiv.sumCongr p q) (.inl x) (.inl y) ↔ p.SameCycle x y := by
+  change (SameCycle.setoid (Equiv.sumCongr p q)).r _ _ ↔ _
+  rw [sumCongr_cycles_setoid]
+  exact sumSetoid_inl _ _ _ _
+
+@[simp] lemma sumCongr_sameCycle_inr (p : Perm α) (q : Perm β) (x y : β) :
+    SameCycle (Equiv.sumCongr p q) (.inr x) (.inr y) ↔ q.SameCycle x y := by
+  change (SameCycle.setoid (Equiv.sumCongr p q)).r _ _ ↔ _
+  rw [sumCongr_cycles_setoid]
+  exact sumSetoid_inr _ _ _ _
+
+@[simp] lemma sumCongr_not_sameCycle (p : Perm α) (q : Perm β) (x : α) (y : β) :
+    ¬ SameCycle (Equiv.sumCongr p q) (.inl x) (.inr y) := by
+  change ¬ (SameCycle.setoid (Equiv.sumCongr p q)).r _ _
+  rw [sumCongr_cycles_setoid]
+  exact sumSetoid_cross _ _ _ _
+
+lemma prod_cycle_sum_left (p : Perm α) (q : Perm β) (x : α) (f : α ⊕ β → A) :
+    ∏ y ∈ cycleSet (Equiv.sumCongr p q) (cycleClass _ (.inl x)), f y =
+      ∏ y ∈ cycleSet p (cycleClass p x), f (.inl y) := by
+  simp only [cycleSet, Finset.prod_filter, cycleClass_eq, Fintype.prod_sum_type,
+    sumCongr_sameCycle_inl, sameCycle_comm (x := Sum.inr _), sumCongr_not_sameCycle,
+    ↓reduceIte, Finset.prod_const_one, mul_one]
+
+lemma prod_cycle_sum_right (p : Perm α) (q : Perm β) (x : β) (f : α ⊕ β → A) :
+    ∏ y ∈ cycleSet (Equiv.sumCongr p q) (cycleClass _ (.inr x)), f y =
+      ∏ y ∈ cycleSet q (cycleClass q x), f (.inr y) := by
+  simp only [cycleSet, Finset.prod_filter, cycleClass_eq, Fintype.prod_sum_type,
+    sumCongr_sameCycle_inr, sumCongr_not_sameCycle,
+    ↓reduceIte, Finset.prod_const_one, one_mul]
+
+def cycleInl (p : Perm α) (q : Perm β) : Cycles p → Cycles (Equiv.sumCongr p q) :=
+  Quotient.map Sum.inl (fun _ _ h => (sumCongr_sameCycle_inl p q _ _).mpr h)
+
+@[simp] lemma cycleInl_class (p : Perm α) (q : Perm β) (x : α) :
+    cycleInl p q (cycleClass p x) = cycleClass _ (.inl x) := rfl
+
+lemma cycleInl_injective (p : Perm α) (q : Perm β) :
+    Function.Injective (cycleInl p q) := by
+  intro x y
+  induction x using Quotient.inductionOn with
+  | h x =>
+    induction y using Quotient.inductionOn with
+    | h y =>
+      change cycleClass (Equiv.sumCongr p q) (.inl x) = cycleClass _ (.inl y) →
+        cycleClass p x = cycleClass p y
+      simp only [cycleClass_eq, sumCongr_sameCycle_inl, imp_self]
+
+lemma cycleInl_ne_inr (p : Perm α) (q : Perm β) (c : Cycles p) (y : β) :
+    cycleInl p q c ≠ cycleClass _ (.inr y) := by
+  induction c using Quotient.inductionOn with
+  | h x =>
+    change cycleClass (Equiv.sumCongr p q) (.inl x) ≠ cycleClass _ (.inr y)
+    simp only [ne_eq, cycleClass_eq, sumCongr_not_sameCycle, not_false_eq_true]
+
+end OddKaplansky.Planar
+
+namespace OddKaplansky.Planar
+open Equiv Equiv.Perm
+variable {α : Type portUniverse54}
+
+lemma Follows.append_rotate {p : Perm α} {l m : List α} (h : Follows p (l ++ m))
+    (hd : (l ++ m).Nodup) : Follows p (m ++ l) := by
+  intro x hx
+  have hx' : x ∈ l ++ m := by simpa only [List.mem_append, or_comm] using hx
+  rw [h x hx', List.formPerm_eq_of_isRotated hd List.isRotated_append]
+
+lemma Follows.split {p : Perm α} {a b : α} {l m : List α}
+    (h : Follows p ((a :: l) ++ (b :: m))) (hd : ((a :: l) ++ (b :: m)).Nodup) :
+    Follows (swap a b * p) (a :: l) ∧ Follows (swap a b * p) (b :: m) := by
+  classical
+  have hdis : List.Disjoint (a :: l) (b :: m) := by
+    intro x hx hy
+    exact (List.nodup_append.mp hd).2.2 x hx x hy rfl
+  have hb : b ∉ a :: l := fun hb => hdis hb (by simp)
+  have heq (x : α) (hx : x ∈ (a :: l) ++ (b :: m)) :
+      (swap a b * p) x = (a :: l).formPerm ((b :: m).formPerm x) := by
+    rw [Perm.mul_apply, h x hx, formPerm_append_nonempty a b l m hb]
+    simp only [Perm.mul_apply, swap_apply_self]
+  constructor
+  · intro x hx
+    have hx' : x ∉ b :: m := fun hx' => hdis hx hx'
+    rw [heq x (List.mem_append_left _ hx), List.formPerm_apply_of_notMem hx']
+  · intro x hx
+    rw [heq x (List.mem_append_right _ hx)]
+    apply List.formPerm_apply_of_notMem
+    exact fun hx' => hdis hx' ((b :: m).formPerm_apply_mem_of_mem hx)
+
+end OddKaplansky.Planar
+
+namespace OddKaplansky.Planar
+open Equiv Equiv.Perm
+variable {α : Type portUniverse55} {β : Type portUniverse56}
+
+lemma Follows.map_sum_right {p : Perm α} {q : Perm β} {l : List β}
+    (h : Follows q l) : Follows (Equiv.sumCongr p q) (l.map Sum.inr) := by
+  classical
+  intro y hy
+  obtain ⟨x, hx, rfl⟩ := List.mem_map.mp hy
+  simpa only [Equiv.sumCongr_apply, Sum.map_inr,
+    formPerm_map_apply Sum.inr Sum.inr_injective] using congrArg Sum.inr (h x hx)
+
+lemma Follows.merge {p : Perm α} {a b : α} {l m : List α}
+    (hl : Follows p (a :: l)) (hm : Follows p (b :: m))
+    (hdis : List.Disjoint (a :: l) (b :: m)) :
+    Follows (swap a b * p) ((a :: l) ++ (b :: m)) := by
+  classical
+  have hb : b ∉ a :: l := fun hb => hdis hb (by simp)
+  intro x hx
+  rw [formPerm_append_nonempty a b l m hb]
+  simp only [Perm.mul_apply]
+  apply congrArg (swap a b)
+  rcases List.mem_append.mp hx with hx | hx
+  · rw [List.formPerm_apply_of_notMem (fun h => hdis hx h)]
+    exact hl x hx
+  · rw [List.formPerm_apply_of_notMem (fun h => hdis h ((b :: m).formPerm_apply_mem_of_mem hx))]
+    exact hm x hx
+
+end OddKaplansky.Planar
+namespace OddKaplansky.Planar
+open Equiv Equiv.Perm
+variable {α : Type portUniverse57}
+
+lemma follows_formPerm [DecidableEq α] (l : List α) : Follows l.formPerm l := by
+  intro x _
+  exact congrArg (fun d : DecidableEq α => @List.formPerm α d l x)
+    (Subsingleton.elim _ _)
+
+end OddKaplansky.Planar
+
+namespace OddKaplansky.Planar
+open Equiv Equiv.Perm
+variable {α : Type portUniverse58} {B : Type portUniverse59} [Group B]
+
+noncomputable def listPotential [DecidableEq α] (l : List α) (w : α → B) (x : α) : B :=
+  ((l.take (l.idxOf x)).map w).prod
+
+lemma listPotential_get [DecidableEq α] (l : List α) (hd : l.Nodup) (w : α → B)
+    (i : ℕ) (hi : i < l.length) :
+    listPotential l w l[i] = ((l.take i).map w).prod := by
+  simp only [listPotential, hd.idxOf_getElem i hi]
+
+lemma listPrefix_succ (l : List α) (w : α → B) (i : ℕ) (hi : i < l.length) :
+    ((l.take (i+1)).map w).prod = ((l.take i).map w).prod * w l[i] := by
+  rw [List.take_succ_eq_append_getElem hi, List.map_append, List.prod_append,
+    List.map_singleton, List.prod_singleton]
+
+lemma listPotential_balance_at [DecidableEq α] (l : List α) (hd : l.Nodup)
+    (w : α → B) (i : ℕ) (hi : i + 1 < l.length) :
+    listPotential l w (l.formPerm l[i]) = listPotential l w l[i] * w l[i] := by
+  rw [List.formPerm_apply_lt_getElem l hd i hi, listPotential_get l hd w (i+1),
+    listPotential_get l hd w i, listPrefix_succ]
+
+lemma listPotential_end_at [DecidableEq α] (l : List α) (hd : l.Nodup)
+    (w : α → B) (i : ℕ) (hi : i < l.length) (hend : i+1 = l.length) :
+    listPotential l w (l.formPerm l[i]) = 1 ∧
+      listPotential l w l[i] * w l[i] = (l.map w).prod := by
+  constructor
+  · rw [List.formPerm_apply_getElem l hd i hi]
+    have hm : (i+1) % l.length = 0 := by rw [hend, Nat.mod_self]
+    simp only [hm]
+    rw [listPotential_get l hd w 0]
+    rfl
+  · rw [listPotential_get l hd w i, ← listPrefix_succ l w i hi, hend, List.take_length]
+
+lemma listPotential_balance [DecidableEq α] (l : List α) (hd : l.Nodup)
+    (w : α → B) (hprod : (l.map w).prod = 1) (x : α) (hx : x ∈ l) :
+    listPotential l w (l.formPerm x) = listPotential l w x * w x := by
+  obtain ⟨i, hi, rfl⟩ := List.getElem_of_mem hx
+  by_cases hn : i+1 < l.length
+  · exact listPotential_balance_at l hd w i hn
+  · have he := listPotential_end_at l hd w i hi (by omega)
+    rw [he.1, he.2, hprod]
+
+def listDefect [Fintype α] [DecidableEq α] (l : List α) (hd : l.Nodup) (hall : ∀ x, x ∈ l)
+    (w : α → B) (hprod : (l.map w).prod ≠ 1) : Holonomy.Defect l.formPerm w := by
+  have hn : 0 < l.length := by
+    by_contra h
+    have he : l = [] := List.length_eq_zero_iff.mp (by omega)
+    simp [he] at hprod
+  let e := l[l.length-1]'(by omega)
+  refine ⟨listPotential l w, e, ?_, ?_⟩
+  · intro x hx
+    obtain ⟨i, hi, rfl⟩ := List.getElem_of_mem (hall x)
+    apply listPotential_balance_at l hd w i
+    by_contra h
+    have he : i = l.length-1 := by omega
+    exact hx (by simp only [he, e])
+  · have he := listPotential_end_at l hd w (l.length-1) (by omega) (by omega)
+    change listPotential l w (l.formPerm e) ≠ listPotential l w e * w e
+    rw [show listPotential l w (l.formPerm e) = 1 from he.1,
+      show listPotential l w e * w e = (l.map w).prod from he.2]
+    exact Ne.symm hprod
+
+end OddKaplansky.Planar
+
+namespace OddKaplansky.Planar
+open Equiv Equiv.Perm
+variable {α : Type portUniverse60} {β : Type portUniverse61} {V : Type portUniverse62} {F : Type portUniverse63} {A : Type portUniverse64} {B : Type portUniverse65} [Fintype α] [Fintype β] [CommGroup A] [Group B]
+
+def augInc (Inc : V → F → Prop) : Option V → F → Prop
+  | none, _ => True
+  | some v, f => Inc v f
+
+def augMap (ι : V → F → (A →* B)) : Option V → F → (A →* B)
+  | none, _ => 1
+  | some v, f => ι v f
+
+structure OpenBalanced (R : Ribbon α) (Inc : V → F → Prop) (ι : V → F → (A →* B))
+    extends NoncommBalanced R (augInc Inc) (augMap ι) where
+  potential_none : ∀ x, blackLabel x = none → potential x = 1
+  exception_some : blackLabel exception ≠ none
+
+structure FlatOpenBalanced (R : Ribbon α) (Inc : V → F → Prop) (ι : V → F → (A →* B)) where
+  blackLabel : α → Option V
+  whiteLabel : α → F
+  blackLabel_rot : ∀ a, blackLabel (R.black a) = blackLabel a
+  whiteLabel_rot : ∀ a, whiteLabel (R.white a) = whiteLabel a
+  incident : ∀ a, augInc Inc (blackLabel a) (whiteLabel a)
+  weight : α → A
+  white_prod : ∀ c : Cycles R.white, ∏ a ∈ cycleSet R.white c, weight a = 1
+  potential : α → B
+  black_balance : ∀ a,
+    potential (R.black a) = potential a * augMap ι (blackLabel a) (whiteLabel a) (weight a)
+  potential_none : ∀ x, blackLabel x = none → potential x = 1
+
+variable {R : Ribbon α} {S : Ribbon β} {Inc : V → F → Prop} {ι : V → F → (A →* B)}
+
+def OpenBalanced.sumZero (D : OpenBalanced R Inc ι) (E : FlatOpenBalanced S Inc ι) :
+    OpenBalanced (R.sum S) Inc ι where
+  blackLabel := Sum.elim D.blackLabel E.blackLabel
+  whiteLabel := Sum.elim D.whiteLabel E.whiteLabel
+  blackLabel_rot := by rintro (x | x); exact D.blackLabel_rot x; exact E.blackLabel_rot x
+  whiteLabel_rot := by rintro (x | x); exact D.whiteLabel_rot x; exact E.whiteLabel_rot x
+  incident := by rintro (x | x); exact D.incident x; exact E.incident x
+  weight := Sum.elim D.weight E.weight
+  white_prod c := by
+    dsimp only [Ribbon.sum] at c ⊢
+    induction c using Quotient.inductionOn with
+    | h x =>
+      cases x with
+      | inl x =>
+        change (∏ a ∈ cycleSet (Equiv.sumCongr R.white S.white) (cycleClass _ (.inl x)), Sum.elim D.weight E.weight a) = 1
+        rw [prod_cycle_sum_left]
+        exact D.white_prod _
+      | inr x =>
+        change (∏ a ∈ cycleSet (Equiv.sumCongr R.white S.white) (cycleClass _ (.inr x)), Sum.elim D.weight E.weight a) = 1
+        rw [prod_cycle_sum_right]
+        exact E.white_prod _
+  potential := Sum.elim D.potential E.potential
+  exception := .inl D.exception
+  black_balance := by
+    rintro (x | x) hx
+    · exact D.black_balance x (fun h => hx (congrArg Sum.inl h))
+    · exact E.black_balance x
+  black_defect := D.black_defect
+  potential_none := by rintro (x | x); exact D.potential_none x; exact E.potential_none x
+  exception_some := D.exception_some
+
+def OpenBalanced.joinNone (D : OpenBalanced R Inc ι) (a b : α)
+    (ha : D.blackLabel a = none) (hb : D.blackLabel b = none) :
+    OpenBalanced (R.swapBlack a b) Inc ι where
+  toNoncommBalanced := D.toNoncommBalanced.spliceBlack a b (ha.trans hb.symm)
+    (D.toNoncommBalanced.defect.swapEqual a b
+      ((D.potential_none a ha).trans (D.potential_none b hb).symm))
+  potential_none := D.potential_none
+  exception_some := D.exception_some
+
+def OpenBalanced.fill (D : OpenBalanced R Inc ι)
+    (l : List α) (hd : l.Nodup) (hrot : Follows R.black l)
+    (hnone : ∀ x ∈ l, D.blackLabel x = none) (v : V)
+    (hinc : ∀ x ∈ l, Inc v (D.whiteLabel x))
+    (hprod : (l.map fun x => ι v (D.whiteLabel x) (D.weight x)).prod = 1) :
+    OpenBalanced R Inc ι := by
+  classical
+  let w := fun x => ι v (D.whiteLabel x) (D.weight x)
+  have he : D.exception ∉ l := fun h => D.exception_some (hnone _ h)
+  have hep : R.black D.exception ∉ l := by simpa only [hrot.invariant] using he
+  refine {
+    blackLabel := fun x => if x ∈ l then some v else D.blackLabel x
+    whiteLabel := D.whiteLabel
+    blackLabel_rot := ?_
+    whiteLabel_rot := D.whiteLabel_rot
+    incident := ?_
+    weight := D.weight
+    white_prod := D.white_prod
+    potential := fun x => if x ∈ l then listPotential l w x else D.potential x
+    exception := D.exception
+    black_balance := ?_
+    black_defect := ?_
+    potential_none := ?_
+    exception_some := ?_ }
+  · intro x; simp only [hrot.invariant, D.blackLabel_rot]
+  · intro x
+    by_cases hx : x ∈ l
+    · simpa only [ite_eq_left hx, augInc] using hinc x hx
+    · simpa only [ite_eq_right hx] using D.incident x
+  · intro x hx
+    by_cases hxl : x ∈ l
+    · simp only [hrot.invariant, hxl, ite_true, augMap]
+      rw [hrot x hxl]
+      exact listPotential_balance l hd w hprod x hxl
+    · simp only [hrot.invariant, hxl, ite_false]
+      exact D.black_balance x hx
+  · simpa only [ite_eq_right he, ite_eq_right hep] using D.black_defect
+  · intro x hx
+    by_cases hxl : x ∈ l
+    · simp only [ite_eq_left hxl] at hx
+      exact (Option.some_ne_none v hx).elim
+    · simp only [ite_eq_right hxl] at hx ⊢
+      exact D.potential_none x hx
+  · simpa only [ite_eq_right he] using D.exception_some
+
+structure OpenDiagram (Inc : V → F → Prop) (ι : V → F → (A →* B))
+    (f₀ : F) (w : List (F × A)) where
+  Edge : Type
+  fintype : Fintype Edge
+  ribbon : Ribbon Edge
+  balanced : @OpenBalanced Edge V F A B fintype _ _ ribbon Inc ι
+  planar : @Ribbon.GenusZero Edge fintype ribbon
+  anchor : Edge
+  boundary : List Edge
+  nodup : (anchor :: boundary).Nodup
+  rotation : Follows ribbon.black (anchor :: boundary)
+  exposed : ∀ x, balanced.blackLabel x = none ↔ x ∈ anchor :: boundary
+  anchor_weight : balanced.weight anchor = 1
+  anchor_label : balanced.whiteLabel anchor = f₀
+  word : boundary.map (fun x => (balanced.whiteLabel x, balanced.weight x)) = w
+
+attribute [instance] OpenDiagram.fintype
+
+omit [Fintype α] [Fintype β] in
+ def OpenDiagram.close (f₀ : F) (D : OpenDiagram Inc ι f₀ [])
+    (v₀ : V) (hv : Inc v₀ f₀) : NoncommBalanced D.ribbon Inc ι := by
+  have hb : D.boundary = [] := List.map_eq_nil_iff.mp D.word
+  have hn (x : D.Edge) : D.balanced.blackLabel x = none ↔ x = D.anchor := by
+    simpa only [hb, List.mem_cons, List.not_mem_nil, or_false] using D.exposed x
+  let bl : D.Edge → V := fun x => (D.balanced.blackLabel x).getD v₀
+  have heval (x : D.Edge) : ι (bl x) (D.balanced.whiteLabel x) (D.balanced.weight x) =
+      augMap ι (D.balanced.blackLabel x) (D.balanced.whiteLabel x) (D.balanced.weight x) := by
+    cases h : D.balanced.blackLabel x with
+    | none =>
+      have hx := (hn x).mp h
+      rw [hx, D.anchor_weight]
+      simp
+    | some v => simp [bl, h, augMap]
+  exact {
+    blackLabel := bl
+    whiteLabel := D.balanced.whiteLabel
+    blackLabel_rot := fun x => congrArg (fun v => v.getD v₀) (D.balanced.blackLabel_rot x)
+    whiteLabel_rot := D.balanced.whiteLabel_rot
+    incident := fun x => by
+      cases h : D.balanced.blackLabel x with
+      | none =>
+        have hx := (hn x).mp h
+        have hanc := (hn D.anchor).mpr rfl
+        simpa [bl, hx, hanc, D.anchor_label] using hv
+      | some v =>
+        have hi := D.balanced.incident x
+        simpa [augInc, bl, h] using hi
+    weight := D.balanced.weight
+    white_prod := D.balanced.white_prod
+    potential := D.balanced.potential
+    exception := D.balanced.exception
+    black_balance := fun x hx => by simpa only [heval] using D.balanced.black_balance x hx
+    black_defect := by simpa only [heval] using D.balanced.black_defect }
+
+omit [Fintype α] [Fintype β] in
+ theorem OpenDiagram.not_empty (f₀ : F) (D : OpenDiagram Inc ι f₀ [])
+    (v₀ : V) (hv : Inc v₀ f₀) (hshort : ShortWords Inc ι)
+    (hgirth : 8 ≤ (incidenceGraph Inc).egirth) : False :=
+  (D.close f₀ v₀ hv).not_genusZero hshort hgirth D.planar
+
+end OddKaplansky.Planar
+
+namespace OddKaplansky.Planar
+open Equiv Equiv.Perm
+variable {α : Type portUniverse66} {V : Type portUniverse67} {F : Type portUniverse68} {A : Type portUniverse69} {B : Type portUniverse70} [Fintype α] [CommGroup A] [Group B]
+
+lemma cycleSet_wheel_white (p : Perm α) (x : α ⊕ α) :
+    cycleSet (Ribbon.wheel p).white (cycleClass _ x) =
+      {Sum.inl (sumIndex x), Sum.inr (sumIndex x)} := by
+  ext y
+  rw [mem_cycleSet, cycleClass_eq]
+  change (SameCycle.setoid (Ribbon.wheel p).white).r y x ↔ _
+  rw [wheel_white_setoid]
+  cases x <;> cases y <;> simp [sumIndex]
+
+variable {Inc : V → F → Prop} {ι : V → F → (A →* B)}
+
+def FlatOpenBalanced.wheel (p : Perm α) (v : V) (fl : α → F) (w : α → A)
+    (hinc : ∀ x, Inc v (fl x)) (t : α → B)
+    (ht : ∀ x, t (p x) = t x * ι v (fl x) (w x)) :
+    FlatOpenBalanced (Ribbon.wheel p) Inc ι where
+  blackLabel := Sum.elim (fun _ => none) (fun _ => some v)
+  whiteLabel := Sum.elim fl fl
+  blackLabel_rot := by rintro (x | x) <;> rfl
+  whiteLabel_rot := by rintro (x | x) <;> rfl
+  incident := by rintro (x | x); trivial; exact hinc x
+  weight := Sum.elim w (fun x => (w x)⁻¹)
+  white_prod c := by
+    induction c using Quotient.inductionOn with
+    | h x =>
+      change (∏ y ∈ cycleSet (Ribbon.wheel p).white (cycleClass _ x), Sum.elim w (fun x => (w x)⁻¹) y) = 1
+      rw [cycleSet_wheel_white, Finset.prod_pair (by simp)]
+      simp only [Sum.elim_inl, Sum.elim_inr, mul_inv_cancel]
+  potential := Sum.elim (fun _ => 1) (fun x => t (p x))
+  black_balance := by
+    rintro (x | x)
+    · simp [Ribbon.wheel, augMap]
+    · change t (p (p⁻¹ x)) = t (p x) * ι v (fl x) ((w x)⁻¹)
+      simp [ht x, mul_assoc]
+  potential_none := by rintro (x | x) hx; rfl; exact (Option.some_ne_none v hx).elim
+
+def OpenBalanced.wheel (p : Perm α) (v : V) (fl : α → F) (w : α → A)
+    (hinc : ∀ x, Inc v (fl x)) (D : Holonomy.Defect p (fun x => ι v (fl x) (w x))) :
+    OpenBalanced (Ribbon.wheel p) Inc ι where
+  blackLabel := Sum.elim (fun _ => none) (fun _ => some v)
+  whiteLabel := Sum.elim fl fl
+  blackLabel_rot := by rintro (x | x) <;> rfl
+  whiteLabel_rot := by rintro (x | x) <;> rfl
+  incident := by rintro (x | x); trivial; exact hinc x
+  weight := Sum.elim w (fun x => (w x)⁻¹)
+  white_prod c := by
+    induction c using Quotient.inductionOn with
+    | h x =>
+      change (∏ y ∈ cycleSet (Ribbon.wheel p).white (cycleClass _ x), Sum.elim w (fun x => (w x)⁻¹) y) = 1
+      rw [cycleSet_wheel_white, Finset.prod_pair (by simp)]
+      simp only [Sum.elim_inl, Sum.elim_inr, mul_inv_cancel]
+  potential := Sum.elim (fun _ => 1) (fun x => D.potential (p x))
+  exception := .inr D.exception
+  black_balance := by
+    rintro (x | x) hx
+    · simp [Ribbon.wheel, augMap]
+    · have hx' : x ≠ D.exception := fun h => hx (congrArg Sum.inr h)
+      change D.potential (p (p⁻¹ x)) = D.potential (p x) * ι v (fl x) ((w x)⁻¹)
+      simp [D.balance x hx', mul_assoc]
+  black_defect := by
+    change D.potential (p (p⁻¹ D.exception)) ≠ D.potential (p D.exception) *
+      ι v (fl D.exception) ((w D.exception)⁻¹)
+    simp only [show p (p⁻¹ D.exception) = D.exception from p.apply_symm_apply _, map_inv]
+    intro h
+    apply D.defective
+    have hh := congrArg (fun g => g * ι v (fl D.exception) (w D.exception)) h
+    simpa only [mul_assoc, inv_mul_cancel, mul_one] using hh.symm
+  potential_none := by rintro (x | x) hx; rfl; exact (Option.some_ne_none v hx).elim
+  exception_some := Option.some_ne_none v
+
+omit [Fintype α] in
+ def wordWheel (r : List (F × A)) (v : V)
+    (hinc : ∀ t ∈ r, Inc v t.1)
+    (hprod : (r.map (fun t => ι v t.1 t.2)).prod = 1) :
+    FlatOpenBalanced (Ribbon.wheel (List.finRange r.length).formPerm) Inc ι :=
+  FlatOpenBalanced.wheel _ v (fun i => (r.get i).1) (fun i => (r.get i).2)
+    (fun i => hinc _ (List.get_mem r i))
+    (listPotential (List.finRange r.length) (fun i => ι v (r.get i).1 (r.get i).2))
+    (fun i => listPotential_balance _ (List.nodup_finRange _) _ (by
+      change ((List.finRange r.length).map ((fun t : F × A => ι v t.1 t.2) ∘ r.get)).prod = 1
+      rw [← List.map_map, List.map_get_finRange]
+      exact hprod) i (by simp))
+
+omit [Fintype α] in
+ def OpenDiagram.initial (f₀ : F) (v : V) (hf₀ : Inc v f₀) (w : List (F × A))
+    (hinc : ∀ t ∈ w, Inc v t.1)
+    (hprod : (w.map (fun t => ι v t.1 t.2)).prod ≠ 1) :
+    OpenDiagram Inc ι f₀ w := by
+  classical
+  let r := (f₀, (1 : A)) :: w
+  let n := w.length + 1
+  let p := (List.finRange n).formPerm
+  let fl := fun i : Fin n => (r.get i).1
+  let wt := fun i : Fin n => (r.get i).2
+  have hr : ∀ i : Fin n, Inc v (fl i) := by
+    intro i
+    have hm := List.get_mem r i
+    rcases List.mem_cons.mp hm with h | h
+    · simpa only [fl, h] using hf₀
+    · exact hinc _ h
+  have hp : ((List.finRange n).map (fun i => ι v (fl i) (wt i))).prod ≠ 1 := by
+    change ((List.finRange r.length).map (fun i => ι v (r.get i).1 (r.get i).2)).prod ≠ 1
+    change ((List.finRange r.length).map ((fun t : F × A => ι v t.1 t.2) ∘ r.get)).prod ≠ 1
+    rw [← List.map_map, List.map_get_finRange]
+    simpa only [r, List.map_cons, List.prod_cons, map_one, one_mul] using hprod
+  let E := listDefect (List.finRange n) (List.nodup_finRange n) (fun i => by simp)
+    (fun i => ι v (fl i) (wt i)) hp
+  let D := OpenBalanced.wheel (ι := ι) p v fl wt hr E
+  let bd : List (Fin n ⊕ Fin n) := (List.finRange w.length).map (Sum.inl ∘ Fin.succ)
+  have heq : Sum.inl (0 : Fin n) :: bd = (List.finRange n).map Sum.inl := by
+    change Sum.inl (0 : Fin (w.length+1)) :: bd = (List.finRange (w.length+1)).map Sum.inl
+    rw [List.finRange_succ, List.map_cons, List.map_map]
+  refine {
+    Edge := Fin n ⊕ Fin n
+    fintype := inferInstance
+    ribbon := Ribbon.wheel p
+    balanced := D
+    planar := Ribbon.genusZero_wheel p
+    anchor := Sum.inl (0 : Fin n)
+    boundary := bd
+    nodup := ?_
+    rotation := ?_
+    exposed := ?_
+    anchor_weight := rfl
+    anchor_label := rfl
+    word := ?_ }
+  · rw [heq]
+    exact (List.nodup_finRange n).map Sum.inl_injective
+  · rw [heq]
+    exact (follows_formPerm (List.finRange n)).map_sum_left
+  · intro x
+    rw [heq]
+    cases x <;> simp [D, OpenBalanced.wheel]
+  · change bd.map (fun x => (D.whiteLabel x, D.weight x)) = w
+    dsimp only [bd]
+    rw [List.map_map]
+    change ((List.finRange w.length).map (fun i => w.get i)) = w
+    exact List.map_get_finRange w
+
+end OddKaplansky.Planar
+
+namespace OddKaplansky.Planar
+open Equiv Equiv.Perm
+variable {V : Type portUniverse71} {F : Type portUniverse72} {A : Type portUniverse73} {B : Type portUniverse74} [CommGroup A] [Group B]
+variable {Inc : V → F → Prop} {ι : V → F → (A →* B)} {f₀ : F} {w : List (F × A)}
+
+theorem OpenDiagram.deleteBlock (D : OpenDiagram Inc ι f₀ w)
+    (pre r post : List D.Edge) (hboundary : D.boundary = pre ++ r ++ post)
+    (v : V) (hinc : ∀ x ∈ r, Inc v (D.balanced.whiteLabel x))
+    (hprod : (r.map fun x => ι v (D.balanced.whiteLabel x) (D.balanced.weight x)).prod = 1) :
+    Nonempty (OpenDiagram Inc ι f₀ ((pre ++ post).map
+      (fun x => (D.balanced.whiteLabel x, D.balanced.weight x)))) := by
+  classical
+  cases r with
+  | nil =>
+    have hw : w = (pre ++ post).map (fun x => (D.balanced.whiteLabel x, D.balanced.weight x)) := by
+      exact D.word.symm.trans (congrArg _ (by simpa only [List.append_nil] using hboundary))
+    exact ⟨hw ▸ D⟩
+  | cons a r =>
+    let M := post ++ D.anchor :: pre
+    have hM : M ≠ [] := by simp [M]
+    obtain ⟨b, m, hbm⟩ := List.exists_cons_of_ne_nil hM
+    have hrot : Follows D.ribbon.black ((D.anchor :: pre) ++ ((a :: r) ++ post)) := by
+      simpa only [hboundary, List.cons_append, List.append_assoc] using D.rotation
+    have hnd : (((D.anchor :: pre) ++ ((a :: r) ++ post))).Nodup := by
+      simpa only [hboundary, List.cons_append, List.append_assoc] using D.nodup
+    have hrot' : Follows D.ribbon.black ((a :: r) ++ (b :: m)) := by
+      simpa only [List.append_assoc, ← hbm] using hrot.append_rotate hnd
+    have hnd' : ((a :: r) ++ (b :: m)).Nodup := by
+      have hn := (List.nodup_append_comm).mp hnd
+      simpa only [List.append_assoc, ← hbm] using hn
+    have hmem (x : D.Edge) : x ∈ D.anchor :: D.boundary ↔ x ∈ (a :: r) ++ (b :: m) := by
+      simp only [hboundary, ← hbm, M, List.mem_cons, List.mem_append]
+      tauto
+    have hab : D.ribbon.black.SameCycle a b := hrot'.sameCycle hnd'
+      (by simp) (by simp)
+    have habne : a ≠ b := by
+      intro h
+      exact (List.nodup_append.mp hnd').2.2 a (by simp) b (by simp) h
+    have ha : D.balanced.blackLabel a = none :=
+      (D.exposed a).mpr ((hmem a).mpr (by simp))
+    have hb : D.balanced.blackLabel b = none :=
+      (D.exposed b).mpr ((hmem b).mpr (by simp))
+    let S := D.ribbon.swapBlack a b
+    have hsplit := hrot'.split hnd'
+    have hnone : ∀ x ∈ a :: r, D.balanced.blackLabel x = none := by
+      intro x hx
+      exact (D.exposed x).mpr ((hmem x).mpr (List.mem_append_left _ hx))
+    let E := (D.balanced.joinNone a b ha hb).fill (a :: r)
+      (List.nodup_append.mp hnd').1 hsplit.1 hnone v hinc hprod
+    have hmrot : Follows S.black (D.anchor :: (pre ++ post)) := by
+      have hh : Follows S.black (post ++ (D.anchor :: pre)) := by
+        simpa only [← hbm, S, Ribbon.swapBlack, M] using hsplit.2
+      have hn : (post ++ (D.anchor :: pre)).Nodup := by
+        simpa only [← hbm] using (List.nodup_append.mp hnd').2.1
+      simpa only [List.cons_append] using hh.append_rotate hn
+    have hmnd : (D.anchor :: (pre ++ post)).Nodup := by
+      have hn : (post ++ (D.anchor :: pre)).Nodup := by
+        simpa only [← hbm] using (List.nodup_append.mp hnd').2.1
+      simpa only [List.cons_append] using List.nodup_append_comm.mp hn
+    have hrem (x : D.Edge) : x ∈ b :: m ↔ x ∈ D.anchor :: (pre ++ post) := by
+      simp only [← hbm, M, List.mem_append, List.mem_cons]
+      tauto
+    exact ⟨{
+      Edge := D.Edge
+      fintype := inferInstance
+      ribbon := S
+      balanced := E
+      planar := D.ribbon.genusZero_swapBlack_split D.planar a b habne hab
+      anchor := D.anchor
+      boundary := pre ++ post
+      nodup := hmnd
+      rotation := hmrot
+      exposed := fun x => by
+        change (if x ∈ a :: r then some v else D.balanced.blackLabel x) = none ↔ _
+        by_cases hx : x ∈ a :: r
+        · simp only [ite_eq_left hx, Option.some_ne_none, false_iff]
+          exact fun h => (List.nodup_append.mp hnd').2.2 x hx x ((hrem x).mpr h) rfl
+        · rw [ite_eq_right hx, D.exposed, hmem, List.mem_append]
+          simpa only [hx, false_or] using hrem x
+      anchor_weight := D.anchor_weight
+      anchor_label := D.anchor_label
+      word := rfl }⟩
+
+end OddKaplansky.Planar
+
+namespace OddKaplansky.Planar
+open Equiv Equiv.Perm
+variable {V F A B : Type} [CommGroup A] [Group B]
+variable {Inc : V → F → Prop} {ι : V → F → (A →* B)}
+variable {f₀ : F} {w : List (F × A)}
+
+theorem OpenDiagram.insertBlock (D : OpenDiagram Inc ι f₀ w)
+    (pre post : List D.Edge) (hboundary : D.boundary = pre ++ post)
+    (r : List (F × A)) (v : V) (hinc : ∀ t ∈ r, Inc v t.1)
+    (hprod : (r.map (fun t => ι v t.1 t.2)).prod = 1) :
+    Nonempty (OpenDiagram Inc ι f₀
+      (pre.map (fun x => (D.balanced.whiteLabel x, D.balanced.weight x)) ++ r ++
+        post.map (fun x => (D.balanced.whiteLabel x, D.balanced.weight x)))) := by
+  classical
+  by_cases hr : r = []
+  · subst r
+    have hw : w = pre.map (fun x => (D.balanced.whiteLabel x, D.balanced.weight x)) ++
+        [] ++ post.map (fun x => (D.balanced.whiteLabel x, D.balanced.weight x)) := by
+      exact D.word.symm.trans (by rw [hboundary, List.map_append, List.append_nil])
+    exact ⟨hw ▸ D⟩
+  let p := (List.finRange r.length).formPerm
+  let W := wordWheel r v hinc hprod
+  let T := D.ribbon.sum (Ribbon.wheel p)
+  let E := D.balanced.sumZero W
+  let f : D.Edge → D.Edge ⊕ (Fin r.length ⊕ Fin r.length) := Sum.inl
+  let g : Fin r.length → D.Edge ⊕ (Fin r.length ⊕ Fin r.length) := Sum.inr ∘ Sum.inl
+  let Q := (List.finRange r.length).map g
+  let M := (post ++ D.anchor :: pre).map f
+  have hqn : Q ≠ [] := by
+    intro he
+    have hh : r.length = 0 := by simpa only [Q, List.length_map, List.length_finRange, List.length_nil] using congrArg List.length he
+    exact hr (List.length_eq_zero_iff.mp hh)
+  have hmn : M ≠ [] := by simp [M]
+  obtain ⟨a, l, hqa⟩ := List.exists_cons_of_ne_nil hqn
+  obtain ⟨b, m, hmb⟩ := List.exists_cons_of_ne_nil hmn
+  have hnd₀ : ((D.anchor :: pre) ++ post).Nodup := by
+    simpa only [hboundary, List.cons_append] using D.nodup
+  have hrot₀ : Follows D.ribbon.black ((D.anchor :: pre) ++ post) := by
+    simpa only [hboundary, List.cons_append] using D.rotation
+  have hndM : M.Nodup := (List.nodup_append_comm.mp hnd₀).map Sum.inl_injective
+  have hndQ : Q.Nodup := (List.nodup_finRange _).map (Sum.inr_injective.comp Sum.inl_injective)
+  have hM : Follows T.black M := by
+    exact (hrot₀.append_rotate hnd₀).map_sum_left
+  have hQ : Follows T.black Q := by
+    have h : Follows (Ribbon.wheel p).black ((List.finRange r.length).map Sum.inl) :=
+      (follows_formPerm (List.finRange r.length)).map_sum_left
+    simpa only [List.map_map, T, Ribbon.sum, Q, g] using h.map_sum_right (p := D.ribbon.black)
+  have hdis : List.Disjoint Q M := by
+    intro x hx hy
+    obtain ⟨i, _, rfl⟩ := List.mem_map.mp hx
+    obtain ⟨j, _, hj⟩ := List.mem_map.mp hy
+    exact Sum.inl_ne_inr (show (Sum.inl j : D.Edge ⊕ (Fin r.length ⊕ Fin r.length)) = Sum.inr (Sum.inl i) from hj)
+  have hnd : (Q ++ M).Nodup := List.Nodup.append hndQ hndM hdis
+  have hac : a ∈ Q := by rw [hqa]; simp
+  have hbc : b ∈ M := by rw [hmb]; simp
+  have hcomp : ¬ T.components.r a b := by
+    obtain ⟨i, _, rfl⟩ := List.mem_map.mp hac
+    obtain ⟨j, _, rfl⟩ := List.mem_map.mp hbc
+    rw [Ribbon.sum_components]
+    exact fun h => sumSetoid_cross _ _ j (Sum.inl i)
+      ((sumSetoid D.ribbon.components (Ribbon.wheel p).components).iseqv.symm h)
+  have hal : E.blackLabel a = none := by
+    obtain ⟨i, _, rfl⟩ := List.mem_map.mp hac
+    rfl
+  have hbl : E.blackLabel b = none := by
+    obtain ⟨j, hj, rfl⟩ := List.mem_map.mp hbc
+    apply (D.exposed j).mpr
+    simpa only [hboundary, List.mem_append, List.mem_cons, or_assoc, or_left_comm, or_comm] using hj
+  let S := T.swapBlack a b
+  let Z := E.joinNone a b hal hbl
+  have hrot : Follows S.black (Q ++ M) := by
+    simp only [hqa, hmb] at hQ hM hdis ⊢
+    exact hQ.merge hM hdis
+  have hrot' : Follows S.black (f D.anchor :: (pre.map f ++ Q ++ post.map f)) := by
+    have hh : Follows S.black ((Q ++ post.map f) ++ (f D.anchor :: pre.map f)) := by
+      simpa only [M, List.map_append, List.map_cons, List.append_assoc] using hrot
+    have hn : ((Q ++ post.map f) ++ (f D.anchor :: pre.map f)).Nodup := by
+      simpa only [M, List.map_append, List.map_cons, List.append_assoc] using hnd
+    simpa only [List.cons_append, List.append_assoc] using hh.append_rotate hn
+  have hnd' : (f D.anchor :: (pre.map f ++ Q ++ post.map f)).Nodup := by
+    have hn : ((Q ++ post.map f) ++ (f D.anchor :: pre.map f)).Nodup := by
+      simpa only [M, List.map_append, List.map_cons, List.append_assoc] using hnd
+    simpa only [List.cons_append, List.append_assoc] using List.nodup_append_comm.mp hn
+  refine ⟨{
+    Edge := D.Edge ⊕ (Fin r.length ⊕ Fin r.length)
+    fintype := inferInstance
+    ribbon := S
+    balanced := Z
+    planar := T.genusZero_swapBlack_merge (D.ribbon.genusZero_sum (Ribbon.wheel p) D.planar
+      (Ribbon.genusZero_wheel p)) a b hcomp
+    anchor := f D.anchor
+    boundary := pre.map f ++ Q ++ post.map f
+    nodup := hnd'
+    rotation := hrot'
+    exposed := ?_
+    anchor_weight := D.anchor_weight
+    anchor_label := D.anchor_label
+    word := ?_ }⟩
+  · rintro (x | (i | i))
+    · change D.balanced.blackLabel x = none ↔ _
+      rw [D.exposed, hboundary]
+      simp [f, Q, g, List.mem_map, Function.comp_def, List.mem_append, List.mem_cons]
+    · change (none : Option V) = none ↔ _
+      simp [f, Q, g, List.mem_map, Function.comp_def]
+    · change (some v : Option V) = none ↔ _
+      simp [f, Q, g, List.mem_map, Function.comp_def]
+  · change (pre.map f ++ Q ++ post.map f).map
+        (fun x => (E.whiteLabel x, E.weight x)) = _
+    simp only [List.map_append, List.map_map]
+    congr 2
+    dsimp only [Q]
+    rw [List.map_map]
+    change ((List.finRange r.length).map (fun i => r.get i)) = r
+    exact List.map_get_finRange r
+
+end OddKaplansky.Planar
+
+namespace OddKaplansky.Planar
+variable {V F A B : Type} [CommGroup A] [Group B]
+variable {Inc : V → F → Prop} {ι : V → F → (A →* B)} {f₀ : F}
+
+theorem OpenDiagram.deleteWordBlock (pre r post : List (F × A))
+    (v : V) (hinc : ∀ t ∈ r, Inc v t.1)
+    (hprod : (r.map (fun t => ι v t.1 t.2)).prod = 1)
+    (D : OpenDiagram Inc ι f₀ (pre ++ r ++ post)) :
+    Nonempty (OpenDiagram Inc ι f₀ (pre ++ post)) := by
+  classical
+  obtain ⟨p, q, hpq, hp, hq⟩ := List.map_eq_append_iff.mp
+    (D.word.trans (List.append_assoc pre r post))
+  obtain ⟨s, t, hst, hs, ht⟩ := List.map_eq_append_iff.mp hq
+  have hboundary : D.boundary = p ++ s ++ t := by
+    exact hpq.trans ((congrArg (p ++ ·) hst).trans (List.append_assoc p s t).symm)
+  have hnd : s.Nodup := by
+    have hh := D.nodup.tail
+    rw [hboundary] at hh
+    exact (List.nodup_append.mp (List.nodup_append.mp hh).1).2.1
+  have hinc' : ∀ x ∈ s, Inc v (D.balanced.whiteLabel x) := by
+    intro x hx
+    apply hinc (D.balanced.whiteLabel x, D.balanced.weight x)
+    simpa only [hs] using (List.mem_map_of_mem (f := fun x =>
+      (D.balanced.whiteLabel x, D.balanced.weight x)) hx)
+  have hprod' : (s.map fun x =>
+      ι v (D.balanced.whiteLabel x) (D.balanced.weight x)).prod = 1 := by
+    have hh := hprod
+    rw [← hs, List.map_map] at hh
+    exact hh
+  obtain ⟨E⟩ := D.deleteBlock p s t hboundary v hinc' hprod'
+  have he : (p ++ t).map (fun x => (D.balanced.whiteLabel x, D.balanced.weight x)) =
+      pre ++ post := by rw [List.map_append, hp, ht]
+  exact ⟨he ▸ E⟩
+
+theorem OpenDiagram.insertWordBlock (pre r post : List (F × A))
+    (v : V) (hinc : ∀ t ∈ r, Inc v t.1)
+    (hprod : (r.map (fun t => ι v t.1 t.2)).prod = 1)
+    (D : OpenDiagram Inc ι f₀ (pre ++ post)) :
+    Nonempty (OpenDiagram Inc ι f₀ (pre ++ r ++ post)) := by
+  obtain ⟨p, q, hpq, hp, hq⟩ := List.map_eq_append_iff.mp D.word
+  obtain ⟨E⟩ := D.insertBlock p q hpq r v hinc hprod
+  rw [hp, hq] at E
+  exact ⟨E⟩
+
+end OddKaplansky.Planar
+
+namespace OddKaplansky.WordReduction
+variable {α : Type portUniverse75}
+abbrev Word (α : Type portUniverse76) := List (α × Bool)
+
+inductive Delete (Allowed : Word α → Prop) : Word α → Word α → Prop
+  | block (pre r post : Word α) (hr : Allowed r) :
+      Delete Allowed (pre ++ r ++ post) (pre ++ post)
+
+abbrev Related (Allowed : Word α → Prop) := Relation.EqvGen (Delete Allowed)
+
+variable {Allowed : Word α → Prop}
+
+lemma rel_trans {u v w : Word α} (h₁ : Related Allowed u v) (h₂ : Related Allowed v w) :
+    Related Allowed u w := Relation.EqvGen.trans _ _ _ h₁ h₂
+
+lemma rel_symm {u v : Word α} (h : Related Allowed u v) :
+    Related Allowed v u := Relation.EqvGen.symm _ _ h
+
+lemma Related.append_left {u v : Word α} (h : Related Allowed u v) (w : Word α) :
+    Related Allowed (w ++ u) (w ++ v) := by
+  induction h with
+  | rel x y h =>
+    cases h with
+    | block pre r post hr =>
+      simpa only [List.append_assoc] using Relation.EqvGen.rel _ _ (Delete.block (w ++ pre) r post hr)
+  | refl x => exact .refl _
+  | symm _ _ _ ih => exact rel_symm ih
+  | trans _ _ _ _ _ ih₁ ih₂ => exact rel_trans ih₁ ih₂
+
+lemma Related.append_right {u v : Word α} (h : Related Allowed u v) (w : Word α) :
+    Related Allowed (u ++ w) (v ++ w) := by
+  induction h with
+  | rel x y h =>
+    cases h with
+    | block pre r post hr =>
+      simpa only [List.append_assoc] using Relation.EqvGen.rel _ _ (Delete.block pre r (post ++ w) hr)
+  | refl x => exact .refl _
+  | symm _ _ _ ih => exact rel_symm ih
+  | trans _ _ _ _ _ ih₁ ih₂ => exact rel_trans ih₁ ih₂
+
+lemma Related.inv (hinv : ∀ w, Allowed w → Allowed (FreeGroup.invRev w))
+    {u v : Word α} (h : Related Allowed u v) :
+    Related Allowed (FreeGroup.invRev u) (FreeGroup.invRev v) := by
+  induction h with
+  | rel x y h =>
+    cases h with
+    | block pre r post hr =>
+      simpa only [FreeGroup.invRev_append, List.append_assoc] using
+        Relation.EqvGen.rel _ _ (Delete.block (FreeGroup.invRev post) (FreeGroup.invRev r)
+          (FreeGroup.invRev pre) (hinv r hr))
+  | refl x => exact .refl _
+  | symm _ _ _ ih => exact rel_symm ih
+  | trans _ _ _ _ _ ih₁ ih₂ => exact rel_trans ih₁ ih₂
+
+lemma related_of_red_step
+    (hcancel : ∀ a b, Allowed [(a, b), (a, !b)])
+    {u v : Word α} (h : FreeGroup.Red.Step u v) : Related Allowed u v := by
+  cases h with
+  | @not pre post a b =>
+    simpa using Relation.EqvGen.rel _ _ (Delete.block pre [(a, b), (a, !b)] post (hcancel a b))
+
+lemma related_of_red
+    (hcancel : ∀ a b, Allowed [(a, b), (a, !b)])
+    {u v : Word α} (h : FreeGroup.Red u v) : Related Allowed u v := by
+  induction h with
+  | refl => exact .refl _
+  | tail h hstep ih => exact rel_trans ih (related_of_red_step hcancel hstep)
+
+lemma related_of_mk_eq
+    (hcancel : ∀ a b, Allowed [(a, b), (a, !b)])
+    {u v : Word α} (h : FreeGroup.mk u = FreeGroup.mk v) : Related Allowed u v := by
+  obtain ⟨w, huw, hvw⟩ := FreeGroup.Red.exact.mp h
+  exact rel_trans (related_of_red hcancel huw) (rel_symm (related_of_red hcancel hvw))
+
+lemma related_append_null {u v : Word α} (hu : Related Allowed u [])
+    (hv : Related Allowed v []) : Related Allowed (u ++ v) [] := by
+  exact rel_trans (hu.append_right v) (by simpa using hv)
+
+def nullSubgroup (Allowed : Word α → Prop)
+    (hinv : ∀ w, Allowed w → Allowed (FreeGroup.invRev w)) : Subgroup (FreeGroup α) where
+  carrier g := ∃ w : Word α, FreeGroup.mk w = g ∧ Related Allowed w []
+  one_mem' := ⟨[], rfl, .refl _⟩
+  mul_mem' := by
+    rintro _ _ ⟨u, rfl, hu⟩ ⟨v, rfl, hv⟩
+    exact ⟨u ++ v, FreeGroup.mul_mk.symm, related_append_null hu hv⟩
+  inv_mem' := by
+    rintro _ ⟨w, rfl, hw⟩
+    exact ⟨FreeGroup.invRev w, FreeGroup.inv_mk.symm, by simpa using hw.inv hinv⟩
+
+lemma nullSubgroup_normal
+    (hinv : ∀ w, Allowed w → Allowed (FreeGroup.invRev w))
+    (hcancel : ∀ a b, Allowed [(a, b), (a, !b)]) :
+    (nullSubgroup Allowed hinv).Normal := by
+  constructor
+  rintro g ⟨w, rfl, hw⟩ u
+  induction u using Quot.inductionOn with
+  | h v =>
+    change ∃ z, FreeGroup.mk z = FreeGroup.mk v * FreeGroup.mk w * (FreeGroup.mk v)⁻¹ ∧ _
+    refine ⟨v ++ w ++ FreeGroup.invRev v, ?_, ?_⟩
+    · rw [← FreeGroup.mul_mk, ← FreeGroup.mul_mk, ← FreeGroup.inv_mk]
+    · have h₁ := (hw.append_left v).append_right (FreeGroup.invRev v)
+      simp only [List.append_nil] at h₁
+      apply rel_trans h₁
+      apply related_of_mk_eq hcancel
+      rw [← FreeGroup.mul_mk, ← FreeGroup.inv_mk]
+      simp only [mul_inv_cancel, ← FreeGroup.one_eq_mk]
+
+theorem of_presented_eq_one (rels : Set (FreeGroup α))
+    (hinv : ∀ w, Allowed w → Allowed (FreeGroup.invRev w))
+    (hcancel : ∀ a b, Allowed [(a, b), (a, !b)])
+    (hrels : ∀ g ∈ rels, ∃ w : Word α, FreeGroup.mk w = g ∧ Allowed w)
+    (w : Word α) (hw : PresentedGroup.mk rels (FreeGroup.mk w) = 1) :
+    Related Allowed w [] := by
+  let H := nullSubgroup Allowed hinv
+  let : H.Normal := nullSubgroup_normal hinv hcancel
+  have hle : Subgroup.normalClosure rels ≤ H := by
+    apply Subgroup.normalClosure_le_normal
+    intro g hg
+    obtain ⟨v, hv, hA⟩ := hrels g hg
+    refine ⟨v, hv, ?_⟩
+    simpa using Relation.EqvGen.rel _ _ (Delete.block [] v [] hA)
+  obtain ⟨v, hv, hnull⟩ := hle (PresentedGroup.mk_eq_one_iff.mp hw)
+  exact rel_trans (related_of_mk_eq hcancel hv.symm) hnull
+
+end OddKaplansky.WordReduction
+
+namespace OddKaplansky.Planar
+variable {V F A B X : Type} [CommGroup A] [Group B]
+variable {Inc : V → F → Prop} {ι : V → F → (A →* B)} {f₀ : F}
+
+theorem OpenDiagram.related_iff (token : X × Bool → F × A)
+    (Allowed : List (X × Bool) → Prop)
+    (hA : ∀ r, Allowed r → ∃ v, (∀ t ∈ r.map token, Inc v t.1) ∧
+      ((r.map token).map (fun t => ι v t.1 t.2)).prod = 1)
+    {u w : List (X × Bool)} (h : WordReduction.Related Allowed u w) :
+    Nonempty (OpenDiagram Inc ι f₀ (u.map token)) ↔
+      Nonempty (OpenDiagram Inc ι f₀ (w.map token)) := by
+  induction h with
+  | rel u w h =>
+    cases h with
+    | block pre r post hr =>
+      obtain ⟨v, hi, hs⟩ := hA r hr
+      simp only [List.map_append]
+      constructor
+      · rintro ⟨D⟩
+        exact D.deleteWordBlock _ _ _ v hi hs
+      · rintro ⟨D⟩
+        exact D.insertWordBlock _ _ _ v hi hs
+  | refl => rfl
+  | symm _ _ _ ih => exact ih.symm
+  | trans _ _ _ _ _ ih₁ ih₂ => exact ih₁.trans ih₂
+
+end OddKaplansky.Planar
+
+namespace OddKaplansky.GluedGroup
+noncomputable section
+open scoped Classical
+variable {V F A B : Type} [CommGroup A] [Group B]
+variable (Inc : V → F → Prop) (ι : V → F → (A →* B))
+
+abbrev Generator := F × A
+abbrev LocalGenerator (v : V) := {s : Generator (F := F) (A := A) // Inc v s.1}
+
+def includeLocal (v : V) : FreeGroup (LocalGenerator (A := A) Inc v) →*
+    FreeGroup (Generator (F := F) (A := A)) := FreeGroup.map Subtype.val
+
+def localEvaluation (v : V) : FreeGroup (LocalGenerator (A := A) Inc v) →* B :=
+  FreeGroup.lift (fun s => ι v s.val.1 s.val.2)
+
+def relators : Set (FreeGroup (Generator (F := F) (A := A))) :=
+  {g | ∃ (v : V) (w : FreeGroup (LocalGenerator (A := A) Inc v)),
+    localEvaluation Inc ι v w = 1 ∧ includeLocal Inc v w = g}
+
+abbrev N := PresentedGroup (relators Inc ι)
+
+def fromLocal (v : V) : FreeGroup (LocalGenerator (A := A) Inc v) →* N Inc ι :=
+  (PresentedGroup.mk (relators Inc ι)).comp (includeLocal Inc v)
+
+lemma local_kernel_le (v : V) : (localEvaluation Inc ι v).ker ≤ (fromLocal Inc ι v).ker := by
+  intro w hw
+  exact PresentedGroup.mk_eq_one_iff.mpr (Subgroup.subset_normalClosure ⟨v, w, hw, rfl⟩)
+
+def signedToken (s : Generator (F := F) (A := A) × Bool) : F × A :=
+  (s.1.1, if s.2 then s.1.2 else s.1.2⁻¹)
+
+def Allowed (w : List (Generator (F := F) (A := A) × Bool)) : Prop :=
+  ∃ v : V, (∀ t ∈ w.map signedToken, Inc v t.1) ∧
+    ((w.map signedToken).map (fun t => ι v t.1 t.2)).prod = 1
+
+lemma signedToken_inv (s : Generator (F := F) (A := A) × Bool) :
+    signedToken (s.1, !s.2) = ((signedToken s).1, (signedToken s).2⁻¹) := by
+  rcases s with ⟨s, b⟩
+  cases b <;> simp [signedToken]
+
+lemma allowed_inv (w : List (Generator (F := F) (A := A) × Bool))
+    (h : Allowed Inc ι w) : Allowed Inc ι (FreeGroup.invRev w) := by
+  obtain ⟨v, hi, hp⟩ := h
+  refine ⟨v, ?_, ?_⟩
+  · intro t ht
+    simp only [FreeGroup.invRev, List.map_reverse, List.map_map, List.mem_reverse,
+      List.mem_map] at ht
+    obtain ⟨s, hs, rfl⟩ := ht
+    change Inc v (signedToken (s.1, !s.2)).1
+    rw [signedToken_inv]
+    exact hi (signedToken s) (List.mem_map_of_mem hs)
+  · simp only [FreeGroup.invRev, List.map_reverse, List.map_map, Function.comp_def,
+      signedToken_inv, map_inv]
+    have hinv : ((w.map (fun s => (ι v (signedToken s).1 (signedToken s).2)⁻¹)).reverse).prod =
+        ((w.map (fun s => ι v (signedToken s).1 (signedToken s).2)).prod)⁻¹ := by
+      clear hi hp
+      induction w with
+      | nil => simp
+      | cons a w ih => simp [ih, mul_inv_rev]
+    rw [hinv]
+    simpa only [List.map_map, Function.comp_def, inv_eq_one] using hp
+
+lemma allowed_cancel (hInc : ∀ f, ∃ v, Inc v f)
+    (g : Generator (F := F) (A := A)) (b : Bool) :
+    Allowed Inc ι [(g, b), (g, !b)] := by
+  obtain ⟨v, hv⟩ := hInc g.1
+  refine ⟨v, ?_, ?_⟩
+  · intro t ht
+    simp only [List.map_cons, List.map_nil, List.mem_cons, List.not_mem_nil, or_false] at ht
+    rcases ht with rfl | rfl <;> exact hv
+  · cases b <;> simp [signedToken]
+
+lemma localEvaluation_word (v : V) (w : List (LocalGenerator (A := A) Inc v × Bool)) :
+    localEvaluation Inc ι v (FreeGroup.mk w) =
+      ((w.map (fun s => (s.1.val, s.2))).map (fun s =>
+        ι v (signedToken s).1 (signedToken s).2)).prod := by
+  rw [localEvaluation, FreeGroup.lift_mk, List.map_map]
+  congr 1
+  apply List.map_congr_left
+  intro s _
+  rcases s with ⟨s, b⟩
+  cases b <;> simp [signedToken]
+
+lemma relators_allowed (g : FreeGroup (Generator (F := F) (A := A)))
+    (hg : g ∈ relators Inc ι) :
+    ∃ w, FreeGroup.mk w = g ∧ Allowed Inc ι w := by
+  obtain ⟨v, r, he, rfl⟩ := hg
+  induction r using Quot.inductionOn with
+  | h w =>
+    refine ⟨w.map (fun s => (s.1.val, s.2)), rfl, v, ?_, ?_⟩
+    · intro t ht
+      simp only [List.map_map, List.mem_map] at ht
+      obtain ⟨s, _, rfl⟩ := ht
+      exact s.1.property
+    · change localEvaluation Inc ι v (FreeGroup.mk w) = 1 at he
+      simpa only [localEvaluation_word, List.map_map, Function.comp_def] using he
+
+theorem fromLocal_eq_one_iff (hInc : ∀ f, ∃ v, Inc v f)
+    (hshort : Planar.ShortWords Inc ι)
+    (hgirth : 8 ≤ (Planar.incidenceGraph Inc).egirth)
+    (v : V) (w : FreeGroup (LocalGenerator (A := A) Inc v)) :
+    fromLocal Inc ι v w = 1 ↔ localEvaluation Inc ι v w = 1 := by
+  refine ⟨?_, fun h => local_kernel_le Inc ι v h⟩
+  intro hw
+  by_contra he
+  induction w using Quot.inductionOn with
+  | h w =>
+    have hp : ((w.map (fun s => (s.1.val, s.2))).map
+        (fun s => ι v (signedToken s).1 (signedToken s).2)).prod ≠ 1 := by
+      change localEvaluation Inc ι v (FreeGroup.mk w) ≠ 1 at he
+      simpa only [localEvaluation_word] using he
+    have hne : w ≠ [] := by rintro rfl; simp at hp
+    obtain ⟨s, z, rfl⟩ := List.exists_cons_of_ne_nil hne
+    let q := (s :: z).map (fun s => (s.1.val, s.2))
+    have hq : WordReduction.Related (Allowed Inc ι) q [] :=
+      WordReduction.of_presented_eq_one (relators Inc ι)
+        (allowed_inv Inc ι) (allowed_cancel Inc ι hInc)
+        (relators_allowed Inc ι) q hw
+    have hi : Nonempty (Planar.OpenDiagram Inc ι s.1.val.1 (q.map signedToken)) := by
+      refine ⟨Planar.OpenDiagram.initial _ v s.1.property _ ?_ ?_⟩
+      · intro t ht
+        simp only [q, List.map_map, List.mem_map] at ht
+        obtain ⟨a, _, rfl⟩ := ht
+        exact a.1.property
+      · simpa only [q, List.map_map, Function.comp_def] using hp
+    obtain ⟨D⟩ := (Planar.OpenDiagram.related_iff (Inc := Inc) (ι := ι)
+      (f₀ := s.1.val.1) signedToken (Allowed Inc ι) (fun _ h => h) hq).mp hi
+    exact D.not_empty _ v s.1.property hshort hgirth
+
+abbrev Local (v : V) := (localEvaluation Inc ι v).range
+
+def theta (v : V) : Local Inc ι v →* N Inc ι :=
+  (localEvaluation Inc ι v).rangeRestrict.liftOfSurjective
+    (localEvaluation Inc ι v).rangeRestrict_surjective
+    ⟨fromLocal Inc ι v, by
+      intro w hw
+      apply local_kernel_le Inc ι v
+      exact congrArg Subtype.val hw⟩
+
+lemma theta_evaluation (v : V) (w : FreeGroup (LocalGenerator (A := A) Inc v)) :
+    theta Inc ι v ((localEvaluation Inc ι v).rangeRestrict w) = fromLocal Inc ι v w := by
+  simp [theta]
+
+theorem theta_injective (hInc : ∀ f, ∃ v, Inc v f)
+    (hshort : Planar.ShortWords Inc ι) (hgirth : 8 ≤ (Planar.incidenceGraph Inc).egirth)
+    (v : V) : Function.Injective (theta Inc ι v) := by
+  apply (theta Inc ι v).ker_eq_bot_iff.mp
+  apply bot_unique
+  intro a ha
+  change a = 1
+  obtain ⟨w, rfl⟩ := (localEvaluation Inc ι v).rangeRestrict_surjective a
+  apply Subtype.ext
+  apply (fromLocal_eq_one_iff Inc ι hInc hshort hgirth v w).mp
+  simpa only [MonoidHom.mem_ker, theta_evaluation] using ha
+
+end
+end OddKaplansky.GluedGroup
+
+namespace OddKaplansky.GluedGroup
+open scoped Classical
+variable {V F A B : Type} [CommGroup A] [Group B]
+variable (Inc : V → F → Prop) (ι : V → F → (A →* B))
+
+noncomputable def localEdge (v : V) (f : F) (hf : Inc v f) (a : A) : Local Inc ι v :=
+  (localEvaluation Inc ι v).rangeRestrict (FreeGroup.of ⟨(f, a), hf⟩)
+
+@[simp] lemma localEdge_val (v : V) (f : F) (hf : Inc v f) (a : A) :
+    (localEdge Inc ι v f hf a : B) = ι v f a := by
+  change localEvaluation Inc ι v (FreeGroup.of ⟨(f, a), hf⟩) = ι v f a
+  simp [localEvaluation]
+
+@[simp] lemma theta_localEdge (v : V) (f : F) (hf : Inc v f) (a : A) :
+    theta Inc ι v (localEdge Inc ι v f hf a) = PresentedGroup.of (f, a) := by
+  rw [localEdge, theta_evaluation]
+  simp [fromLocal, includeLocal, PresentedGroup.of]
+end OddKaplansky.GluedGroup
+
+end
+end
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/OddKaplansky/FiniteChoice.lean b/lean/OAI/Algebra/OddKaplansky/FiniteChoice.lean
new file mode 100644
index 0000000000000000000000000000000000000000..b2f9c773a4f5b19c5a53d188874e51fadf454857
--- /dev/null
+++ b/lean/OAI/Algebra/OddKaplansky/FiniteChoice.lean
@@ -0,0 +1,66 @@
+import OAI.Algebra.OddKaplansky.QuadraticTower
+
+namespace OAI
+
+universe contextUniverse1
+
+universe portUniverse1 portUniverse2 portUniverse3 portUniverse4 portUniverse5 portUniverse6 portUniverse7 portUniverse8 portUniverse9
+
+section
+namespace OddKaplansky.FiniteChoice
+noncomputable section
+open scoped Classical
+variable {A : Type portUniverse1} {B : Type portUniverse2}
+def orderedIndex (A : Type portUniverse3) [LinearOrder A] [Fintype A] : A ≃ Fin (Fintype.card A) :=
+  (Fintype.orderIsoFinOfCardEq A rfl).symm.toEquiv
+def table [LinearOrder A] [Fintype A] (f : A → B) : List B :=
+  List.ofFn (fun i => f ((orderedIndex A).symm i))
+lemma table_injective [LinearOrder A] [Fintype A] : Function.Injective (table (A := A) (B := B)) := by
+  intro f g he
+  have hh := List.ofFn_injective he
+  funext a
+  simpa only [Equiv.symm_apply_apply] using congrFun hh (orderedIndex A a)
+@[instance_reducible]
+def functionOrder (A : Type portUniverse4) (B : Type portUniverse5) [Fintype A] [LinearOrder A] [LinearOrder B] : LinearOrder (A → B) :=
+  LinearOrder.lift' table table_injective
+@[instance_reducible]
+def tupleOrder (A : Type portUniverse6) (B : Type portUniverse7) [LinearOrder A] [LinearOrder B] : LinearOrder (A×B) :=
+  LinearOrder.lift' (fun a : A×B => toLex a) (fun _ _ h => h)
+@[instance_reducible]
+def residueOrder (n : ℕ) [NeZero n] : LinearOrder (ZMod n) :=
+  LinearOrder.lift' ZMod.val (ZMod.val_injective n)
+@[instance_reducible]
+def multiplicativeOrder [LinearOrder A] : LinearOrder (Multiplicative A) :=
+  LinearOrder.lift' Multiplicative.toAdd Multiplicative.toAdd.injective
+lemma exists_primitive (F : Type portUniverse8) [Field F] [Fintype F] : ∃ ζ : F, IsPrimitiveRoot ζ (Fintype.card F-1) := by
+  obtain ⟨u,hu⟩ := IsCyclic.exists_ofOrder_eq_natCard (α := Fˣ)
+  refine ⟨u,?_⟩
+  rw [← Fintype.card_units F,← Nat.card_eq_fintype_card,← hu]
+  simpa only [orderOf_units] using IsPrimitiveRoot.orderOf (u : F)
+variable [Fintype A] [sectionInstance1 : LinearOrder A] (P : A → Prop) (hP : ∃ a, P a)
+def candidates : Finset A := Finset.univ.filter P
+lemma candidates_nonempty
+    {A : Type contextUniverse1}
+    [Fintype.{contextUniverse1} A]
+    [LinearOrder.{contextUniverse1} A]
+    (P : A → Prop)
+    (hP : @Exists.{contextUniverse1 + 1} A fun a => P a) : (candidates P).Nonempty := by
+  obtain ⟨a,ha⟩ := hP
+  exact ⟨a,by simp [candidates,ha]⟩
+def first : A := (candidates P).min' (candidates_nonempty P hP)
+lemma first_spec : P (first P hP) := by
+  have h := Finset.min'_mem (candidates P) (candidates_nonempty P hP)
+  simpa only [first,candidates,Finset.mem_filter,Finset.mem_univ,true_and] using h
+lemma first_le (a : A) (ha : P a) : first P hP ≤ a :=
+  Finset.min'_le _ _ (by simp [candidates,ha])
+variable (F : Type portUniverse9) [Field F] [Fintype F] [LinearOrder F]
+def primitive : F := first (fun ζ : F => IsPrimitiveRoot ζ (Fintype.card F-1)) (exists_primitive F)
+lemma primitive_spec : IsPrimitiveRoot (primitive F) (Fintype.card F-1) := by unfold primitive; exact first_spec (fun ζ : F => IsPrimitiveRoot ζ (Fintype.card F-1)) (exists_primitive F)
+lemma primitive_le (ζ : F) (hζ : IsPrimitiveRoot ζ (Fintype.card F-1)) : primitive F≤ζ := by unfold primitive; exact first_le (fun ζ : F => IsPrimitiveRoot ζ (Fintype.card F-1)) (exists_primitive F) ζ hζ
+
+end
+end OddKaplansky.FiniteChoice
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/OddKaplansky/FiniteInverse.lean b/lean/OAI/Algebra/OddKaplansky/FiniteInverse.lean
new file mode 100644
index 0000000000000000000000000000000000000000..e0899151b7e111bef746a5bde0f54398c0ec2547
--- /dev/null
+++ b/lean/OAI/Algebra/OddKaplansky/FiniteInverse.lean
@@ -0,0 +1,54 @@
+import OAI.Algebra.OddKaplansky.AugmentBound
+
+namespace OAI
+
+universe portUniverse1 portUniverse2
+
+section
+namespace OddKaplansky.FiniteMatrixInverse
+noncomputable section
+open scoped Classical BigOperators Matrix
+variable {D : Type portUniverse1} {S : Type portUniverse2} [CommRing D] [Fintype S] [DecidableEq S]
+lemma pow_entry_mem (I : Ideal D) (A : Matrix S S D) (hA : ∀ i j, A i j∈I) (n : ℕ) :
+    ∀ i j, (A^n) i j∈I^n := by
+  induction n with
+  | zero => intro i j; simp
+  | succ n ih =>
+    intro i j
+    rw [pow_succ A n,Matrix.mul_apply,pow_succ I n]
+    apply Ideal.sum_mem
+    intro k _
+    exact Ideal.mul_mem_mul (ih i k) (hA k j)
+lemma nilpotent_of_entries (I : Ideal D) (hI : IsNilpotent I)
+    (A : Matrix S S D) (hA : ∀ i j, A i j∈I) : IsNilpotent A := by
+  obtain ⟨n,hn⟩ := hI
+  refine ⟨n,?_⟩
+  funext i j
+  have hh := pow_entry_mem I A hA n i j
+  rw [hn] at hh
+  exact hh
+
+def series (N : Matrix S S D) (n : ℕ) := ∑ k ∈ Finset.range n, (-N)^k
+lemma series_mul (N : Matrix S S D) (n : ℕ) (hN : N^n=0) : series N n*(1+N)=1 := by
+  have hn : (-N)^n=0 := by rw [neg_pow,hN,mul_zero]
+  simpa only [series,sub_neg_eq_add,hn,sub_zero] using geom_sum_mul_neg (-N) n
+
+lemma inverse_formula (Q Q₀ R₀ : Matrix S S D) (hQR : Q₀*R₀=1) (hRQ : R₀*Q₀=1)
+    (n : ℕ) (hN : (R₀*(Q-Q₀))^n=0) : Q⁻¹=series (R₀*(Q-Q₀)) n*R₀ := by
+  let N := R₀*(Q-Q₀)
+  have hfac : Q=Q₀*(1+N) := by
+    dsimp [N]
+    rw [mul_add,mul_one,← mul_assoc,hQR,one_mul]
+    abel
+  apply Matrix.inv_eq_left_inv
+  calc
+    _ = series N n*(R₀*Q) := mul_assoc _ _ _
+    _ = series N n*(R₀*(Q₀*(1+N))) := by rw [hfac]
+    _ = series N n*(1+N) := by rw [← mul_assoc R₀ Q₀ (1+N),hRQ,one_mul]
+    _ = 1 := series_mul N n hN
+end
+end OddKaplansky.FiniteMatrixInverse
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/OddKaplansky/Fourier.lean b/lean/OAI/Algebra/OddKaplansky/Fourier.lean
new file mode 100644
index 0000000000000000000000000000000000000000..e1abfb7a52efcb8f46094fc6ccddb0c39e3eea23
--- /dev/null
+++ b/lean/OAI/Algebra/OddKaplansky/Fourier.lean
@@ -0,0 +1,245 @@
+import OAI.Algebra.OddKaplansky.SourceFit
+
+namespace OAI
+
+universe portUniverse1 portUniverse2 portUniverse3 portUniverse4 portUniverse5
+
+section
+noncomputable section
+open scoped Classical BigOperators
+namespace OddKaplansky.CharacterIdempotents
+variable {K : Type portUniverse1} {A : Type portUniverse2} {G : Type portUniverse3} [Field K] [Group A] [Fintype A] [Group G]
+
+def projector (χ : A →* Kˣ) : MonoidAlgebra K A :=
+  (Fintype.card A : K)⁻¹ • ∑ a : A, MonoidAlgebra.single a ((χ a : K)⁻¹)
+
+lemma sum_character_eq_zero (χ : A →* Kˣ) (hχ : χ ≠ 1) :
+    ∑ a : A, (χ a : K) = 0 := by
+  have hn : ∃ b : A, (χ b : K) ≠ 1 := by
+    by_contra! h
+    apply hχ
+    ext b
+    exact h b
+  obtain ⟨b, hb⟩ := hn
+  have hh : (χ b : K) * ∑ a : A, (χ a : K) = ∑ a : A, (χ a : K) := by
+    rw [Finset.mul_sum]
+    simp only [← Units.val_mul, ← map_mul]
+    exact Equiv.sum_comp (Equiv.mulLeft b) (fun a => (χ a : K))
+  by_contra hs
+  exact hb ((mul_eq_right₀ hs).mp hh)
+
+lemma projector_mul_single (χ : A →* Kˣ) (b : A) :
+    projector χ * MonoidAlgebra.single b 1 = (χ b : K) • projector χ := by
+  unfold projector
+  rw [smul_mul_assoc, Finset.sum_mul, smul_smul]
+  rw [mul_comm (χ b : K), ← smul_smul]
+  congr 1
+  rw [Finset.smul_sum]
+  calc
+    (∑ a : A, MonoidAlgebra.single a ((χ a : K)⁻¹) * MonoidAlgebra.single b 1) =
+        ∑ a : A, (χ b : K) • MonoidAlgebra.single (a * b) ((χ (a * b) : K)⁻¹) := by
+      apply Finset.sum_congr rfl
+      intro a _
+      simp [MonoidAlgebra.single_mul_single, mul_comm]
+    _ = _ := Equiv.sum_comp (Equiv.mulRight b)
+      (fun a : A => (χ b : K) • MonoidAlgebra.single a ((χ a : K)⁻¹))
+
+lemma projector_mul (χ ψ : A →* Kˣ) :
+    projector χ * projector ψ =
+      ((Fintype.card A : K)⁻¹ * ∑ b : A, ((χ b : K) * (ψ b : K)⁻¹)) •
+        projector χ := by
+  conv_lhs => rhs; unfold projector
+  rw [mul_smul_comm, Finset.mul_sum]
+  have hh (b : A) : projector χ * MonoidAlgebra.single b ((ψ b : K)⁻¹) =
+      ((χ b : K) * (ψ b : K)⁻¹) • projector χ := by
+    rw [show MonoidAlgebra.single b ((ψ b : K)⁻¹) =
+      (ψ b : K)⁻¹ • MonoidAlgebra.single b 1 by simp]
+    rw [mul_smul_comm, projector_mul_single, smul_smul, mul_comm]
+  simp_rw [hh]
+  rw [← Finset.sum_smul, smul_smul]
+
+lemma projector_idempotent (χ : A →* Kˣ) (hcard : (Fintype.card A : K) ≠ 0) :
+    IsIdempotentElem (projector χ) := by
+  change projector χ * projector χ = projector χ
+  rw [projector_mul]
+  simp [hcard]
+
+lemma projector_orthogonal (χ ψ : A →* Kˣ) (hne : χ ≠ ψ) :
+    projector χ * projector ψ = 0 := by
+  rw [projector_mul]
+  have hn : χ * ψ⁻¹ ≠ 1 := by
+    intro h
+    apply hne
+    apply MonoidHom.ext
+    intro a
+    have hh := congrArg (fun f : A →* Kˣ => f a) h
+    exact mul_inv_eq_one.mp hh
+  have h := sum_character_eq_zero (χ * ψ⁻¹) hn
+  simpa using congrArg (fun c : K => ((Fintype.card A : K)⁻¹ * c) • projector χ) h
+
+lemma projector_one_coeff (χ : A →* Kˣ) :
+    (projector χ).coeff 1 = (Fintype.card A : K)⁻¹ := by
+  simp [projector, MonoidAlgebra.coeff_sum, MonoidAlgebra.coeff_smul, Finsupp.single_apply]
+
+lemma projector_ne_zero (χ : A →* Kˣ) (hcard : (Fintype.card A : K) ≠ 0) :
+    projector χ ≠ 0 := by
+  intro h
+  have := congrArg (fun p : MonoidAlgebra K A => p.coeff 1) h
+  rw [projector_one_coeff] at this
+  exact (inv_ne_zero hcard) this
+
+def pushed (f : A →* G) (χ : A →* Kˣ) : MonoidAlgebra K G :=
+  MonoidAlgebra.mapDomainAlgHom K K f (projector χ)
+
+lemma pushed_eq_sum (f : A →* G) (χ : A →* Kˣ) :
+    pushed f χ = (Fintype.card A : K)⁻¹ •
+      ∑ a : A, MonoidAlgebra.single (f a) ((χ a : K)⁻¹) := by
+  simp [pushed, projector, map_sum]
+
+lemma pushed_idempotent (f : A →* G) (χ : A →* Kˣ)
+    (hc : (Fintype.card A : K) ≠ 0) :
+    pushed f χ * pushed f χ = pushed f χ := by
+  unfold pushed
+  rw [← map_mul, projector_idempotent χ hc]
+
+lemma pushed_orthogonal (f : A →* G) (χ ψ : A →* Kˣ) (hne : χ ≠ ψ) :
+    pushed f χ * pushed f ψ = 0 := by
+  unfold pushed
+  rw [← map_mul, projector_orthogonal χ ψ hne, map_zero]
+
+lemma pushed_ne_zero (f : A →* G) (hf : Function.Injective f) (χ : A →* Kˣ)
+    (hc : (Fintype.card A : K) ≠ 0) : pushed f χ ≠ 0 := by
+  intro h
+  exact projector_ne_zero χ hc ((MonoidAlgebra.mapDomain_injective hf) (h.trans (MonoidAlgebra.mapDomain_zero f).symm))
+
+lemma pushed_mul_single (f : A →* G) (χ : A →* Kˣ) (b : A) :
+    pushed f χ * MonoidAlgebra.single (f b) 1 = (χ b : K) • pushed f χ := by
+  have h := congrArg (MonoidAlgebra.mapDomainAlgHom K K f) (projector_mul_single χ b)
+  rw [map_mul, map_smul] at h
+  simpa only [pushed, MonoidAlgebra.mapDomainAlgHom_apply, MonoidAlgebra.mapDomain_single] using h
+
+lemma pushed_central (f : A →* G) (χ : A →* Kˣ)
+    (hf : ∀ a g, Commute (f a) g) (x : MonoidAlgebra K G) :
+    Commute (pushed f χ) x := by
+  induction x using MonoidAlgebra.induction_on with
+  | of g =>
+    change pushed f χ * MonoidAlgebra.single g 1 = _
+    rw [pushed_eq_sum, smul_mul_assoc, mul_smul_comm]
+    congr 1
+    rw [Finset.sum_mul, Finset.mul_sum]
+    apply Finset.sum_congr rfl
+    intro a _
+    simp only [MonoidAlgebra.of_apply, MonoidAlgebra.single_mul_single, mul_one, one_mul,
+      (hf a g).eq]
+  | add x y hx hy => exact hx.add_right hy
+  | smul r x hx => exact hx.smul_right r
+
+lemma lift_pushed (f : A →* G) (χ : A →* Kˣ) (ρ : G →* K)
+    (hρ : ∀ a, ρ (f a) = (χ a : K)) (hc : (Fintype.card A : K) ≠ 0) :
+    MonoidAlgebra.lift K K G ρ (pushed f χ) = 1 := by
+  rw [pushed_eq_sum]
+  simp [map_sum, MonoidAlgebra.lift_single, hρ, hc]
+
+end OddKaplansky.CharacterIdempotents
+
+namespace OddKaplansky.Fourier
+noncomputable section
+open scoped Classical BigOperators
+variable {K : Type portUniverse4} {E : Type portUniverse5} [Field K] [Fintype E] (M : ℕ) [NeZero M]
+variable {ζ : K} (hζ : IsPrimitiveRoot ζ M)
+
+abbrev C := Multiplicative (ZMod M)
+abbrev A := E → C M
+
+def cyclicCharacter : C M →* Kˣ :=
+  (AddChar.zmodChar M hζ.pow_eq_one).toMonoidHom.toHomUnits
+lemma cyclicCharacter_injective : Function.Injective (cyclicCharacter M hζ) := by
+  intro a b hab
+  apply Multiplicative.toAdd.injective
+  apply ZMod.val_injective M
+  apply hζ.pow_inj (ZMod.val_lt _) (ZMod.val_lt _)
+  exact congrArg (fun u : Kˣ => (u : K)) hab
+
+def character (lmb : A (E := E) M) : A (E := E) M →* Kˣ :=
+  (cyclicCharacter M hζ).comp (show A (E := E) M →* C M from
+    { toFun := fun a => Multiplicative.ofAdd (∑ e, (lmb e).toAdd * (a e).toAdd)
+      map_one' := by simp
+      map_mul' := by intro a b; simp [mul_add, Finset.sum_add_distrib] })
+
+lemma character_apply (lmb a : A (E := E) M) :
+    character M hζ lmb a = cyclicCharacter M hζ (Multiplicative.ofAdd
+      (∑ e, (lmb e).toAdd * (a e).toAdd)) := rfl
+
+lemma character_symm (lmb a : A (E := E) M) : character M hζ lmb a = character M hζ a lmb := by
+  simp only [character_apply, mul_comm]
+
+lemma character_mul (lmb μ : A (E := E) M) :
+    character M hζ (lmb * μ) = character M hζ lmb * character M hζ μ := by
+  apply MonoidHom.ext
+  intro a
+  simp only [MonoidHom.mul_apply, character_apply, Pi.mul_apply, toAdd_mul,
+    add_mul, Finset.sum_add_distrib, ofAdd_add, map_mul]
+
+lemma character_mulSingle (lmb : A (E := E) M) (i : E) :
+    character M hζ lmb (Pi.mulSingle i (Multiplicative.ofAdd (1 : ZMod M))) =
+      cyclicCharacter M hζ (lmb i) := by
+  rw [character_apply]
+  have hs : (∑ e, (lmb e).toAdd *
+      ((Pi.mulSingle i (Multiplicative.ofAdd (1 : ZMod M)) : A (E := E) M) e).toAdd) = (lmb i).toAdd := by
+    simp [Pi.mulSingle_apply, apply_ite]
+  rw [hs, ofAdd_toAdd]
+
+lemma character_injective : Function.Injective (character (E := E) M hζ) := by
+  intro lmb μ he
+  funext i
+  apply cyclicCharacter_injective M hζ
+  have h := congrArg (fun χ : A (E := E) M →* Kˣ =>
+    χ (Pi.mulSingle i (Multiplicative.ofAdd (1 : ZMod M)))) he
+  simpa only [character_mulSingle] using h
+
+@[simp] lemma character_one : character (E := E) M hζ 1 = 1 := by
+  ext a
+  simp [character_apply]
+
+lemma character_ne_one (a : A (E := E) M) (ha : a ≠ 1) : character M hζ a ≠ 1 := by
+  intro hh
+  exact ha (character_injective M hζ (hh.trans (character_one M hζ).symm))
+
+lemma sum_inverse_characters (a : A (E := E) M) (ha : a ≠ 1) :
+    ∑ lmb : A (E := E) M, ((character M hζ lmb a : K)⁻¹) = 0 := by
+  have hχ : (character M hζ a)⁻¹ ≠ 1 := by
+    intro h
+    apply character_ne_one M hζ a ha
+    apply MonoidHom.ext
+    intro b
+    have hh := congrArg (fun χ : A (E := E) M →* Kˣ => (χ b)⁻¹) h
+    simpa using hh
+  simpa only [MonoidHom.inv_apply, Units.val_inv_eq_inv_val, character_symm] using
+    CharacterIdempotents.sum_character_eq_zero ((character M hζ a)⁻¹) hχ
+
+lemma sum_projector (hc : (Fintype.card (A (E := E) M) : K) ≠ 0) :
+    ∑ lmb : A (E := E) M, CharacterIdempotents.projector (character M hζ lmb) = 1 := by
+  have hp (lmb a : A (E := E) M) :
+      (CharacterIdempotents.projector (character M hζ lmb)).coeff a =
+        (Fintype.card (A (E := E) M) : K)⁻¹ * ((character M hζ lmb a : K)⁻¹) := by
+    simp [CharacterIdempotents.projector, MonoidAlgebra.coeff_sum,
+      MonoidAlgebra.coeff_smul, Finsupp.single_apply]
+  ext a
+  rw [MonoidAlgebra.coeff_sum, Finset.sum_apply']
+  simp_rw [hp]
+  rw [← Finset.mul_sum]
+  by_cases ha : a = 1
+  · subst a
+    simp only [map_one, Units.val_one, inv_one, Finset.sum_const, Finset.card_univ,
+      nsmul_eq_mul, mul_one, MonoidAlgebra.coeff_one_one]
+    exact inv_mul_cancel₀ hc
+  · rw [sum_inverse_characters M hζ a ha]
+    simp [MonoidAlgebra.one_def, ha]
+
+end
+end OddKaplansky.Fourier
+
+end
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/OddKaplansky/FreeBlocks.lean b/lean/OAI/Algebra/OddKaplansky/FreeBlocks.lean
new file mode 100644
index 0000000000000000000000000000000000000000..0a049c0bae2a671575eb7df63fea7727c4d1943a
--- /dev/null
+++ b/lean/OAI/Algebra/OddKaplansky/FreeBlocks.lean
@@ -0,0 +1,297 @@
+import OAI.Algebra.OddKaplansky.WreathMultiply
+
+namespace OAI
+
+universe contextUniverse1 contextUniverse2 contextUniverse3
+
+universe portUniverse1 portUniverse2 portUniverse3
+
+section
+
+namespace OddKaplansky.WreathFourier
+noncomputable section
+open scoped Classical BigOperators Matrix
+variable {K : Type portUniverse1} {H : Type portUniverse2} {R : Type portUniverse3} [Field K] [Group H] [Fintype H] [sectionInstance16 : Fintype R]
+variable (M : ℕ) [NeZero M] {ζ : K} (hζ : IsPrimitiveRoot ζ M)
+variable (hc : (Fintype.card (Base (H := H) M) : K) ≠ 0)
+variable (lmb : R → Base (H := H) M)
+variable (hinj : Function.Injective (fun a : R × H => shift M a.2 (lmb a.1)))
+
+def freeUnit (a : R × H × H) : MonoidAlgebra K (Wreath (H := H) M) :=
+  normal M hζ (shift M a.2.1 (lmb a.1)) (a.2.1*a.2.2⁻¹)
+
+lemma freeUnit_mul
+    {K : Type contextUniverse1}
+    {H : Type contextUniverse2}
+    {R : Type contextUniverse3}
+    [contextInstance3 : Field.{contextUniverse1} K]
+    [contextInstance4 : Group.{contextUniverse2} H]
+    [contextInstance5 : Fintype.{contextUniverse2} H]
+    [Fintype.{contextUniverse3} R]
+    (M : Nat)
+    [contextInstance8 : @NeZero.{0} Nat (@MulZeroClass.toZero.{0} Nat Nat.instMulZeroClass) M]
+    {ζ : K}
+    (hζ : @IsPrimitiveRoot.{contextUniverse1} K (@CommRing.toCommMonoid.{contextUniverse1} K (@Field.toCommRing.{contextUniverse1} K contextInstance3)) ζ M)
+    (hc : @Ne.{contextUniverse1 + 1} K
+  (@Nat.cast.{contextUniverse1} K
+    (@AddMonoidWithOne.toNatCast.{contextUniverse1} K
+      (@AddGroupWithOne.toAddMonoidWithOne.{contextUniverse1} K
+        (@Ring.toAddGroupWithOne.{contextUniverse1} K
+          (@DivisionRing.toRing.{contextUniverse1} K (@Field.toDivisionRing.{contextUniverse1} K contextInstance3)))))
+    (@Fintype.card.{contextUniverse2} (@OddKaplansky.WreathFourier.Base.{contextUniverse2} H M)
+      (@Pi.instFintype.{contextUniverse2, 0} H (fun _ => OddKaplansky.Fourier.C M)
+        (fun a b => Classical.propDecidable (@Eq.{contextUniverse2 + 1} H a b)) contextInstance5 fun _ =>
+        @Multiplicative.fintype.{0} (ZMod M) (@ZMod.fintype M contextInstance8))))
+  (@OfNat.ofNat.{contextUniverse1} K (nat_lit 0)
+    (@Zero.toOfNat0.{contextUniverse1} K
+      (@MulZeroClass.toZero.{contextUniverse1} K
+        (@instMulZeroClassOfSemiring.{contextUniverse1} K
+          (@CommSemiring.toSemiring.{contextUniverse1} K
+            (@Semifield.toCommSemiring.{contextUniverse1} K (@Field.toSemifield.{contextUniverse1} K contextInstance3))))))))
+    (lmb : R → @OddKaplansky.WreathFourier.Base.{contextUniverse2} H M)
+    (hinj : @Function.Injective.{max (contextUniverse2 + 1) (contextUniverse3 + 1), contextUniverse2 + 1} (Prod.{contextUniverse3, contextUniverse2} R H)
+  (@OddKaplansky.WreathFourier.Base.{contextUniverse2} H M) fun a =>
+  @DFunLike.coe.{contextUniverse2 + 1, contextUniverse2 + 1, contextUniverse2 + 1}
+    (@MulEquiv.{contextUniverse2, contextUniverse2} (@OddKaplansky.WreathFourier.Base.{contextUniverse2} H M) (@OddKaplansky.WreathFourier.Base.{contextUniverse2} H M)
+      (@Pi.instMul.{contextUniverse2, 0} H (fun _ => OddKaplansky.Fourier.C M) fun _ =>
+        @Multiplicative.mul.{0} (ZMod M)
+          (@Distrib.toAdd.{0} (ZMod M)
+            (@instDistribOfSemiring.{0} (ZMod M)
+              (@CommSemiring.toSemiring.{0} (ZMod M) (@CommRing.toCommSemiring.{0} (ZMod M) (ZMod.commRing M))))))
+      (@Pi.instMul.{contextUniverse2, 0} H (fun _ => OddKaplansky.Fourier.C M) fun _ =>
+        @Multiplicative.mul.{0} (ZMod M)
+          (@Distrib.toAdd.{0} (ZMod M)
+            (@instDistribOfSemiring.{0} (ZMod M)
+              (@CommSemiring.toSemiring.{0} (ZMod M) (@CommRing.toCommSemiring.{0} (ZMod M) (ZMod.commRing M)))))))
+    (@OddKaplansky.WreathFourier.Base.{contextUniverse2} H M) (fun _ => @OddKaplansky.WreathFourier.Base.{contextUniverse2} H M)
+    (@EquivLike.toFunLike.{contextUniverse2 + 1, contextUniverse2 + 1, contextUniverse2 + 1}
+      (@MulEquiv.{contextUniverse2, contextUniverse2} (@OddKaplansky.WreathFourier.Base.{contextUniverse2} H M) (@OddKaplansky.WreathFourier.Base.{contextUniverse2} H M)
+        (@Pi.instMul.{contextUniverse2, 0} H (fun _ => OddKaplansky.Fourier.C M) fun _ =>
+          @Multiplicative.mul.{0} (ZMod M)
+            (@Distrib.toAdd.{0} (ZMod M)
+              (@instDistribOfSemiring.{0} (ZMod M)
+                (@CommSemiring.toSemiring.{0} (ZMod M) (@CommRing.toCommSemiring.{0} (ZMod M) (ZMod.commRing M))))))
+        (@Pi.instMul.{contextUniverse2, 0} H (fun _ => OddKaplansky.Fourier.C M) fun _ =>
+          @Multiplicative.mul.{0} (ZMod M)
+            (@Distrib.toAdd.{0} (ZMod M)
+              (@instDistribOfSemiring.{0} (ZMod M)
+                (@CommSemiring.toSemiring.{0} (ZMod M) (@CommRing.toCommSemiring.{0} (ZMod M) (ZMod.commRing M)))))))
+      (@OddKaplansky.WreathFourier.Base.{contextUniverse2} H M) (@OddKaplansky.WreathFourier.Base.{contextUniverse2} H M)
+      (@MulEquiv.instEquivLike.{contextUniverse2, contextUniverse2} (@OddKaplansky.WreathFourier.Base.{contextUniverse2} H M)
+        (@OddKaplansky.WreathFourier.Base.{contextUniverse2} H M)
+        (@Pi.instMul.{contextUniverse2, 0} H (fun _ => OddKaplansky.Fourier.C M) fun _ =>
+          @Multiplicative.mul.{0} (ZMod M)
+            (@Distrib.toAdd.{0} (ZMod M)
+              (@instDistribOfSemiring.{0} (ZMod M)
+                (@CommSemiring.toSemiring.{0} (ZMod M) (@CommRing.toCommSemiring.{0} (ZMod M) (ZMod.commRing M))))))
+        (@Pi.instMul.{contextUniverse2, 0} H (fun _ => OddKaplansky.Fourier.C M) fun _ =>
+          @Multiplicative.mul.{0} (ZMod M)
+            (@Distrib.toAdd.{0} (ZMod M)
+              (@instDistribOfSemiring.{0} (ZMod M)
+                (@CommSemiring.toSemiring.{0} (ZMod M) (@CommRing.toCommSemiring.{0} (ZMod M) (ZMod.commRing M))))))))
+    (@OddKaplansky.WreathFourier.shift.{contextUniverse2} H contextInstance4 M (@Prod.snd.{contextUniverse3, contextUniverse2} R H a))
+    (lmb (@Prod.fst.{contextUniverse3, contextUniverse2} R H a))) (r s : R) (x y z t : H) :
+    freeUnit M hζ lmb (r,x,y) * freeUnit M hζ lmb (s,z,t) =
+      if r = s ∧ y = z then freeUnit M hζ lmb (r,x,t) else 0 := by
+  have he : shift M x (lmb r) = shift M (x*y⁻¹) (shift M z (lmb s)) ↔ r = s ∧ y = z := by
+    constructor
+    · intro h
+      have hh := @hinj (r,x) (s,x*y⁻¹*z) (show shift M x (lmb r) = shift M (x*y⁻¹*z) (lmb s) by simpa only [shift_mul] using h)
+      have hr : r = s := congrArg Prod.fst hh
+      have hx : x = x*y⁻¹*z := congrArg Prod.snd hh
+      refine ⟨hr,?_⟩
+      have hy : 1 = y⁻¹*z := mul_left_cancel (by simpa only [mul_assoc,mul_one] using hx)
+      exact inv_mul_eq_one.mp hy.symm
+    · rintro ⟨rfl,rfl⟩
+      rw [← shift_mul]
+      simp only [mul_assoc,inv_mul_cancel,mul_one]
+  simp only [freeUnit,normal_mul M hζ hc,he]
+  split_ifs with h
+  · rcases h with ⟨rfl,rfl⟩
+    simp only [mul_assoc,inv_mul_cancel_left]
+  · rfl
+
+lemma freeUnit_independent
+    {K : Type contextUniverse1}
+    {H : Type contextUniverse2}
+    {R : Type contextUniverse3}
+    [contextInstance3 : Field.{contextUniverse1} K]
+    [contextInstance4 : Group.{contextUniverse2} H]
+    [contextInstance5 : Fintype.{contextUniverse2} H]
+    [Fintype.{contextUniverse3} R]
+    (M : Nat)
+    [contextInstance8 : @NeZero.{0} Nat (@MulZeroClass.toZero.{0} Nat Nat.instMulZeroClass) M]
+    {ζ : K}
+    (hζ : @IsPrimitiveRoot.{contextUniverse1} K (@CommRing.toCommMonoid.{contextUniverse1} K (@Field.toCommRing.{contextUniverse1} K contextInstance3)) ζ M)
+    (hc : @Ne.{contextUniverse1 + 1} K
+  (@Nat.cast.{contextUniverse1} K
+    (@AddMonoidWithOne.toNatCast.{contextUniverse1} K
+      (@AddGroupWithOne.toAddMonoidWithOne.{contextUniverse1} K
+        (@Ring.toAddGroupWithOne.{contextUniverse1} K
+          (@DivisionRing.toRing.{contextUniverse1} K (@Field.toDivisionRing.{contextUniverse1} K contextInstance3)))))
+    (@Fintype.card.{contextUniverse2} (@OddKaplansky.WreathFourier.Base.{contextUniverse2} H M)
+      (@Pi.instFintype.{contextUniverse2, 0} H (fun _ => OddKaplansky.Fourier.C M)
+        (fun a b => Classical.propDecidable (@Eq.{contextUniverse2 + 1} H a b)) contextInstance5 fun _ =>
+        @Multiplicative.fintype.{0} (ZMod M) (@ZMod.fintype M contextInstance8))))
+  (@OfNat.ofNat.{contextUniverse1} K (nat_lit 0)
+    (@Zero.toOfNat0.{contextUniverse1} K
+      (@MulZeroClass.toZero.{contextUniverse1} K
+        (@instMulZeroClassOfSemiring.{contextUniverse1} K
+          (@CommSemiring.toSemiring.{contextUniverse1} K
+            (@Semifield.toCommSemiring.{contextUniverse1} K (@Field.toSemifield.{contextUniverse1} K contextInstance3))))))))
+    (lmb : R → @OddKaplansky.WreathFourier.Base.{contextUniverse2} H M)
+    (hinj : @Function.Injective.{max (contextUniverse2 + 1) (contextUniverse3 + 1), contextUniverse2 + 1} (Prod.{contextUniverse3, contextUniverse2} R H)
+  (@OddKaplansky.WreathFourier.Base.{contextUniverse2} H M) fun a =>
+  @DFunLike.coe.{contextUniverse2 + 1, contextUniverse2 + 1, contextUniverse2 + 1}
+    (@MulEquiv.{contextUniverse2, contextUniverse2} (@OddKaplansky.WreathFourier.Base.{contextUniverse2} H M) (@OddKaplansky.WreathFourier.Base.{contextUniverse2} H M)
+      (@Pi.instMul.{contextUniverse2, 0} H (fun _ => OddKaplansky.Fourier.C M) fun _ =>
+        @Multiplicative.mul.{0} (ZMod M)
+          (@Distrib.toAdd.{0} (ZMod M)
+            (@instDistribOfSemiring.{0} (ZMod M)
+              (@CommSemiring.toSemiring.{0} (ZMod M) (@CommRing.toCommSemiring.{0} (ZMod M) (ZMod.commRing M))))))
+      (@Pi.instMul.{contextUniverse2, 0} H (fun _ => OddKaplansky.Fourier.C M) fun _ =>
+        @Multiplicative.mul.{0} (ZMod M)
+          (@Distrib.toAdd.{0} (ZMod M)
+            (@instDistribOfSemiring.{0} (ZMod M)
+              (@CommSemiring.toSemiring.{0} (ZMod M) (@CommRing.toCommSemiring.{0} (ZMod M) (ZMod.commRing M)))))))
+    (@OddKaplansky.WreathFourier.Base.{contextUniverse2} H M) (fun _ => @OddKaplansky.WreathFourier.Base.{contextUniverse2} H M)
+    (@EquivLike.toFunLike.{contextUniverse2 + 1, contextUniverse2 + 1, contextUniverse2 + 1}
+      (@MulEquiv.{contextUniverse2, contextUniverse2} (@OddKaplansky.WreathFourier.Base.{contextUniverse2} H M) (@OddKaplansky.WreathFourier.Base.{contextUniverse2} H M)
+        (@Pi.instMul.{contextUniverse2, 0} H (fun _ => OddKaplansky.Fourier.C M) fun _ =>
+          @Multiplicative.mul.{0} (ZMod M)
+            (@Distrib.toAdd.{0} (ZMod M)
+              (@instDistribOfSemiring.{0} (ZMod M)
+                (@CommSemiring.toSemiring.{0} (ZMod M) (@CommRing.toCommSemiring.{0} (ZMod M) (ZMod.commRing M))))))
+        (@Pi.instMul.{contextUniverse2, 0} H (fun _ => OddKaplansky.Fourier.C M) fun _ =>
+          @Multiplicative.mul.{0} (ZMod M)
+            (@Distrib.toAdd.{0} (ZMod M)
+              (@instDistribOfSemiring.{0} (ZMod M)
+                (@CommSemiring.toSemiring.{0} (ZMod M) (@CommRing.toCommSemiring.{0} (ZMod M) (ZMod.commRing M)))))))
+      (@OddKaplansky.WreathFourier.Base.{contextUniverse2} H M) (@OddKaplansky.WreathFourier.Base.{contextUniverse2} H M)
+      (@MulEquiv.instEquivLike.{contextUniverse2, contextUniverse2} (@OddKaplansky.WreathFourier.Base.{contextUniverse2} H M)
+        (@OddKaplansky.WreathFourier.Base.{contextUniverse2} H M)
+        (@Pi.instMul.{contextUniverse2, 0} H (fun _ => OddKaplansky.Fourier.C M) fun _ =>
+          @Multiplicative.mul.{0} (ZMod M)
+            (@Distrib.toAdd.{0} (ZMod M)
+              (@instDistribOfSemiring.{0} (ZMod M)
+                (@CommSemiring.toSemiring.{0} (ZMod M) (@CommRing.toCommSemiring.{0} (ZMod M) (ZMod.commRing M))))))
+        (@Pi.instMul.{contextUniverse2, 0} H (fun _ => OddKaplansky.Fourier.C M) fun _ =>
+          @Multiplicative.mul.{0} (ZMod M)
+            (@Distrib.toAdd.{0} (ZMod M)
+              (@instDistribOfSemiring.{0} (ZMod M)
+                (@CommSemiring.toSemiring.{0} (ZMod M) (@CommRing.toCommSemiring.{0} (ZMod M) (ZMod.commRing M))))))))
+    (@OddKaplansky.WreathFourier.shift.{contextUniverse2} H contextInstance4 M (@Prod.snd.{contextUniverse3, contextUniverse2} R H a))
+    (lmb (@Prod.fst.{contextUniverse3, contextUniverse2} R H a))) : LinearIndependent K (freeUnit M hζ lmb) := by
+  let f : R × H × H → Base (H := H) M × H := fun a => (shift M a.2.1 (lmb a.1), a.2.1*a.2.2⁻¹)
+  have hf : Function.Injective f := by
+    rintro ⟨r,x,y⟩ ⟨s,z,t⟩ he
+    have hrs := @hinj (r,x) (s,z) (congrArg Prod.fst he)
+    have hr : r = s := congrArg Prod.fst hrs
+    have hx : x = z := congrArg Prod.snd hrs
+    subst s
+    subst z
+    have hy : y = t := inv_injective (mul_left_cancel (congrArg Prod.snd he))
+    subst t
+    rfl
+  exact (normal_independent M hζ hc).comp f hf
+
+lemma topElt_normal (h g : H) (μ : Base (H := H) M) :
+    topElt M h * normal M hζ μ g = normal M hζ (shift M h μ) (h*g) := by
+  unfold normal
+  rw [← mul_assoc,topElt_projector,mul_assoc,topElt_mul]
+
+lemma topElt_freeUnit
+    {K : Type contextUniverse1}
+    {H : Type contextUniverse2}
+    {R : Type contextUniverse3}
+    [contextInstance3 : Field.{contextUniverse1} K]
+    [Group.{contextUniverse2} H]
+    [Fintype.{contextUniverse2} H]
+    [Fintype.{contextUniverse3} R]
+    (M : Nat)
+    [@NeZero.{0} Nat (@MulZeroClass.toZero.{0} Nat Nat.instMulZeroClass) M]
+    {ζ : K}
+    (hζ : @IsPrimitiveRoot.{contextUniverse1} K (@CommRing.toCommMonoid.{contextUniverse1} K (@Field.toCommRing.{contextUniverse1} K contextInstance3)) ζ M)
+    (lmb : R → @OddKaplansky.WreathFourier.Base.{contextUniverse2} H M) (h : H) (r : R) (x y : H) :
+    topElt M h * freeUnit M hζ lmb (r,x,y) = freeUnit M hζ lmb (r,h*x,y) := by
+  simp only [freeUnit,topElt_normal,shift_mul,mul_assoc]
+
+lemma freeUnit_topElt
+    {K : Type contextUniverse1}
+    {H : Type contextUniverse2}
+    {R : Type contextUniverse3}
+    [contextInstance3 : Field.{contextUniverse1} K]
+    [Group.{contextUniverse2} H]
+    [Fintype.{contextUniverse2} H]
+    [Fintype.{contextUniverse3} R]
+    (M : Nat)
+    [@NeZero.{0} Nat (@MulZeroClass.toZero.{0} Nat Nat.instMulZeroClass) M]
+    {ζ : K}
+    (hζ : @IsPrimitiveRoot.{contextUniverse1} K (@CommRing.toCommMonoid.{contextUniverse1} K (@Field.toCommRing.{contextUniverse1} K contextInstance3)) ζ M)
+    (lmb : R → @OddKaplansky.WreathFourier.Base.{contextUniverse2} H M) (h : H) (r : R) (x y : H) :
+    freeUnit M hζ lmb (r,x,y) * topElt M h = freeUnit M hζ lmb (r,x,h⁻¹*y) := by
+  simp only [freeUnit,normal,mul_assoc,topElt_mul,mul_inv_rev,inv_inv]
+
+def baseElt (a : Base (H := H) M) : MonoidAlgebra K (Wreath (H := H) M) := MonoidAlgebra.single (base M a) 1
+
+lemma projector_baseElt (a μ : Base (H := H) M) :
+    projector M hζ μ * baseElt M a = (Fourier.character M hζ μ a : K) • projector M hζ μ :=
+  CharacterIdempotents.pushed_mul_single _ _ _
+
+lemma baseElt_projector (a μ : Base (H := H) M) :
+    baseElt M a * projector M hζ μ = (Fourier.character M hζ μ a : K) • projector M hζ μ := by
+  let f := MonoidAlgebra.mapDomainAlgHom K K (base (H := H) M)
+  have hh := congrArg f (mul_comm (MonoidAlgebra.single a (1 : K)) (CharacterIdempotents.projector (Fourier.character M hζ μ)))
+  have hf : f (MonoidAlgebra.single a 1) = baseElt M a := by simp [f,baseElt]
+  rw [map_mul,map_mul,hf] at hh
+  exact hh.trans (projector_baseElt M hζ a μ)
+
+lemma topElt_baseElt (h : H) (a : Base (H := H) M) :
+    topElt (K := K) M h * baseElt M a = baseElt M (shift M h a) * topElt M h := by
+  have hg := top_conjugate M h a
+  have he := congrArg (fun g : Wreath (H := H) M => g * top M h) hg
+  simp only [mul_assoc,inv_mul_cancel,mul_one] at he
+  simp only [topElt,baseElt,MonoidAlgebra.single_mul_single,one_mul,he]
+
+lemma baseElt_freeUnit
+    {K : Type contextUniverse1}
+    {H : Type contextUniverse2}
+    {R : Type contextUniverse3}
+    [contextInstance3 : Field.{contextUniverse1} K]
+    [Group.{contextUniverse2} H]
+    [Fintype.{contextUniverse2} H]
+    [Fintype.{contextUniverse3} R]
+    (M : Nat)
+    [@NeZero.{0} Nat (@MulZeroClass.toZero.{0} Nat Nat.instMulZeroClass) M]
+    {ζ : K}
+    (hζ : @IsPrimitiveRoot.{contextUniverse1} K (@CommRing.toCommMonoid.{contextUniverse1} K (@Field.toCommRing.{contextUniverse1} K contextInstance3)) ζ M)
+    (lmb : R → @OddKaplansky.WreathFourier.Base.{contextUniverse2} H M) (a : Base (H := H) M) (r : R) (x y : H) :
+    baseElt M a * freeUnit M hζ lmb (r,x,y) =
+      (Fourier.character M hζ (shift M x (lmb r)) a : K) • freeUnit M hζ lmb (r,x,y) := by
+  simp only [freeUnit,normal,← mul_assoc,baseElt_projector,smul_mul_assoc]
+
+lemma freeUnit_baseElt
+    {K : Type contextUniverse1}
+    {H : Type contextUniverse2}
+    {R : Type contextUniverse3}
+    [contextInstance3 : Field.{contextUniverse1} K]
+    [Group.{contextUniverse2} H]
+    [Fintype.{contextUniverse2} H]
+    [Fintype.{contextUniverse3} R]
+    (M : Nat)
+    [@NeZero.{0} Nat (@MulZeroClass.toZero.{0} Nat Nat.instMulZeroClass) M]
+    {ζ : K}
+    (hζ : @IsPrimitiveRoot.{contextUniverse1} K (@CommRing.toCommMonoid.{contextUniverse1} K (@Field.toCommRing.{contextUniverse1} K contextInstance3)) ζ M)
+    (lmb : R → @OddKaplansky.WreathFourier.Base.{contextUniverse2} H M) (a : Base (H := H) M) (r : R) (x y : H) :
+    freeUnit M hζ lmb (r,x,y) * baseElt M a =
+      (Fourier.character M hζ (shift M y (lmb r)) a : K) • freeUnit M hζ lmb (r,x,y) := by
+  simp only [freeUnit,normal,mul_assoc,topElt_baseElt]
+  rw [← mul_assoc,projector_baseElt]
+  rw [character_shift_right,← shift_mul]
+  simp only [mul_inv_rev,inv_inv,mul_assoc,inv_mul_cancel,mul_one,smul_mul_assoc]
+end
+end OddKaplansky.WreathFourier
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/OddKaplansky/FreeShiftCount.lean b/lean/OAI/Algebra/OddKaplansky/FreeShiftCount.lean
new file mode 100644
index 0000000000000000000000000000000000000000..c4f953afb99bb530c8cb7c20126a29d280874a8e
--- /dev/null
+++ b/lean/OAI/Algebra/OddKaplansky/FreeShiftCount.lean
@@ -0,0 +1,72 @@
+import OAI.Algebra.OddKaplansky.WreathActions
+
+namespace OAI
+
+universe portUniverse1 portUniverse2 portUniverse3
+
+section
+namespace OddKaplansky.FreeShiftCount
+noncomputable section
+open scoped Classical BigOperators
+variable {X : Type portUniverse1} {C : Type portUniverse2} [Fintype X] [Fintype C]
+
+lemma card_equal_coordinate (a b : X) (hab : a ≠ b) :
+    Fintype.card {f : X → C // f a = f b} * Fintype.card C ≤ Fintype.card C ^ Fintype.card X := by
+  let r : {f : X → C // f a = f b} → ({x : X // x ≠ a} → C) := fun f x => f.val x.val
+  have hr : Function.Injective r := by
+    intro f g he
+    apply Subtype.ext
+    funext x
+    by_cases hx : x = a
+    · subst x
+      have he' : f.val b = g.val b := congrFun he ⟨b,Ne.symm hab⟩
+      exact f.property.trans (he'.trans g.property.symm)
+    · exact congrFun he ⟨x,hx⟩
+  have hh := Fintype.card_le_of_injective r hr
+  rw [Fintype.card_fun] at hh
+  have hc := Fintype.card_congr (Equiv.optionSubtypeNe a)
+  rw [Fintype.card_option] at hc
+  calc
+    _ ≤ Fintype.card C ^ Fintype.card {x : X // x ≠ a} * Fintype.card C := Nat.mul_le_mul_right _ hh
+    _ = _ := by rw [← pow_succ,hc]
+
+variable {H : Type portUniverse3} [Group H] [Fintype H]
+def Free (f : H → C) : Prop := ∀ g : H, (∀ x, f (g⁻¹*x) = f x) → g = 1
+
+lemma card_not_free :
+    Fintype.card {f : H → C // ¬ Free f} * Fintype.card C ≤
+      (Fintype.card H - 1) * Fintype.card C ^ Fintype.card H := by
+  let F (g : H) := {f : H → C | ∀ x, f (g⁻¹*x) = f x}
+  have hFg (g : H) (hg : g ≠ 1) : Fintype.card (F g) * Fintype.card C ≤ Fintype.card C ^ Fintype.card H := by
+    have hi : Fintype.card (F g) ≤ Fintype.card {f : H → C // f 1 = f g⁻¹} := by
+      apply Fintype.card_le_of_injective (fun f => ⟨f.val,by simpa using (f.property 1).symm⟩)
+      intro f t he
+      exact Subtype.ext (congrArg (fun q : {f : H → C // f 1 = f g⁻¹} => q.val) he)
+    apply (Nat.mul_le_mul_right _ hi).trans
+    exact card_equal_coordinate 1 g⁻¹ (by simpa using hg)
+  let U := (Finset.univ.erase (1 : H)).biUnion (fun g => Finset.univ.filter (fun f : H → C => f ∈ F g))
+  have hU : U = Finset.univ.filter (fun f : H → C => ¬ Free f) := by
+    ext f
+    simp only [U, Finset.mem_biUnion, Finset.mem_erase, Finset.mem_univ, and_true, Finset.mem_filter,true_and,F,Set.mem_ofPred_eq,Free]
+    simp only [not_forall]
+    aesop
+  have hcard : Fintype.card {f : H → C // ¬ Free f} = U.card := by
+    rw [hU]
+    exact Fintype.card_subtype _
+  rw [hcard]
+  calc
+    U.card * Fintype.card C ≤ (∑ g ∈ Finset.univ.erase (1 : H), (Finset.univ.filter (fun f : H → C => f ∈ F g)).card) * Fintype.card C :=
+      Nat.mul_le_mul_right _ (Finset.card_biUnion_le)
+    _ = ∑ g ∈ Finset.univ.erase (1 : H), (Finset.univ.filter (fun f : H → C => f ∈ F g)).card * Fintype.card C := by rw [Finset.sum_mul]
+    _ ≤ ∑ _g ∈ Finset.univ.erase (1 : H), Fintype.card C ^ Fintype.card H := by
+      apply Finset.sum_le_sum
+      intro g hg
+      rw [← Fintype.card_subtype]
+      exact hFg g (Finset.mem_erase.mp hg).1
+    _ = _ := by simp [Finset.card_erase_of_mem (Finset.mem_univ (1 : H))]
+end
+end OddKaplansky.FreeShiftCount
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/OddKaplansky/GeneralTransfer.lean b/lean/OAI/Algebra/OddKaplansky/GeneralTransfer.lean
new file mode 100644
index 0000000000000000000000000000000000000000..16495e9bac693485d10b3a13a052ea049c430d89
--- /dev/null
+++ b/lean/OAI/Algebra/OddKaplansky/GeneralTransfer.lean
@@ -0,0 +1,33 @@
+import OAI.Algebra.OddKaplansky.Main
+
+namespace OAI
+
+section
+namespace OddKaplansky
+noncomputable section
+open scoped Classical
+
+theorem fixed_field_transfer_general (K L : Type) [Field K] [Group L]
+    (M : ℕ) (hM : 2≤M) {ζ : K} (hζ : IsPrimitiveRoot ζ M) (hc : (M : K)≠0)
+    (r : ℕ) (_hr : 0<r) (A B : Matrix (Fin r) (Fin r) (MonoidAlgebra K L))
+    (hAB : A*B=1) (hBA : B*A≠1) :
+    ∃ q : ℕ, (r≤M^q ∧ ∀ q'<q, M^q'<r) ∧
+      ∃ (Λ : Type) (_ : Group Λ) (_ : Fintype Λ),
+        Fintype.card Λ=M*(M^q)^2 ∧
+          ∃ a b : MonoidAlgebra K (L×Λ), a*b=1 ∧ b*a≠1 := by
+  let : NeZero M := ⟨by omega⟩
+  let q := FixedField.leastQ M hM r
+  refine ⟨q,⟨FixedField.leastQ_spec M hM r,?_⟩,
+    Heisenberg.GroupData M q,inferInstance,inferInstance,Heisenberg.card M q,
+    FixedField.output M hM r hζ A,FixedField.output M hM r hζ B,?_⟩
+  · intro q' hq'
+    by_contra hn
+    have hh := FixedField.leastQ_min M hM r (Nat.le_of_not_gt hn)
+    exact (not_lt_of_ge hh) hq'
+  · exact FixedField.output_products M hM r hζ hc A B hAB hBA
+end
+end OddKaplansky
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/OddKaplansky/Gluing.lean b/lean/OAI/Algebra/OddKaplansky/Gluing.lean
new file mode 100644
index 0000000000000000000000000000000000000000..1ec91485db892645ed9768c0ec68b1ed8c3b6af7
--- /dev/null
+++ b/lean/OAI/Algebra/OddKaplansky/Gluing.lean
@@ -0,0 +1,81 @@
+import OAI.Algebra.OddKaplansky.Amalgam
+
+namespace OAI
+
+universe portUniverse1 portUniverse2
+
+section
+
+namespace OddKaplansky.Gluing
+noncomputable section
+open scoped Classical
+open Monoid
+variable {V F A B : Type} [CommGroup A] [Group B]
+variable (Inc : V → F → Prop) (ι : V → F → (A →* B))
+
+def con : Con (CoprodI (fun _ : V => B)) := conGen fun x y =>
+  ∃ (f : F) (v w : V) (a : A), Inc v f ∧ Inc w f ∧
+    x = CoprodI.of (i := v) (ι v f a) ∧ y = CoprodI.of (i := w) (ι w f a)
+
+def Q := (con Inc ι).Quotient
+instance : Group (Q Inc ι) := by delta Q; infer_instance
+
+def vertex (v : V) : B →* Q Inc ι := (con Inc ι).mk'.comp (CoprodI.of (M := fun _ : V => B) (i := v))
+
+lemma edge_eq (f : F) (v w : V) (a : A) (hv : Inc v f) (hw : Inc w f) :
+    vertex Inc ι v (ι v f a) = vertex Inc ι w (ι w f a) :=
+  (Con.eq _).mpr <| ConGen.Rel.of _ _ ⟨f, v, w, a, hv, hw, rfl, rfl⟩
+
+def lift {E : Type portUniverse1} [Group E] (d : V → B →* E)
+    (hd : ∀ f v w a, Inc v f → Inc w f → d v (ι v f a) = d w (ι w f a)) : Q Inc ι →* E :=
+  Con.lift _ (CoprodI.lift d) (Con.conGen_le.mpr (by
+    rintro _ _ ⟨f, v, w, a, hv, hw, rfl, rfl⟩
+    simpa using hd f v w a hv hw))
+
+@[simp] lemma lift_vertex {E : Type portUniverse2} [Group E] (d : V → B →* E)
+    (hd : ∀ f v w a, Inc v f → Inc w f → d v (ι v f a) = d w (ι w f a)) (v : V) (b : B) :
+    lift Inc ι d hd (vertex Inc ι v b) = d v b := by
+  change CoprodI.lift d (CoprodI.of (i := v) b) = d v b
+  simp
+
+theorem vertex_injective [Fintype V] (hInc : ∀ f, ∃ v, Inc v f)
+    (hshort : Planar.ShortWords Inc ι) (hgirth : 8 ≤ (Planar.incidenceGraph Inc).egirth)
+    (v : V) : Function.Injective (vertex Inc ι v) := by
+  let S := fun v => GluedGroup.Local Inc ι v
+  let f : ∀ v, S v →* GluedGroup.N Inc ι := GluedGroup.theta Inc ι
+  let g : ∀ v, S v →* B := fun v => (GluedGroup.localEvaluation Inc ι v).range.subtype
+  obtain ⟨E, hE, b, d, hb, hd, he⟩ := StarAmalgam.faithful_realization f g
+    (GluedGroup.theta_injective Inc ι hInc hshort hgirth) (fun _ => Subtype.val_injective)
+  have heq : ∀ e v w a, Inc v e → Inc w e → d v (ι v e a) = d w (ι w e a) := by
+    intro e v w a hv hw
+    have hv' := he v (GluedGroup.localEdge Inc ι v e hv a)
+    have hw' := he w (GluedGroup.localEdge Inc ι w e hw a)
+    change b (GluedGroup.theta Inc ι v (GluedGroup.localEdge Inc ι v e hv a)) =
+      d v (GluedGroup.localEdge Inc ι v e hv a : B) at hv'
+    change b (GluedGroup.theta Inc ι w (GluedGroup.localEdge Inc ι w e hw a)) =
+      d w (GluedGroup.localEdge Inc ι w e hw a : B) at hw'
+    rw [GluedGroup.theta_localEdge, GluedGroup.localEdge_val] at hv' hw'
+    exact hv'.symm.trans hw'
+  intro x y hxy
+  apply hd v
+  simpa using congrArg (lift Inc ι d heq) hxy
+
+instance [Finite V] [Finite B] : Group.FG (Q Inc ι) := by
+  let T : Set (Q Inc ι) := Set.range (fun x : V × B => vertex Inc ι x.1 x.2)
+  apply Group.fg_iff.mpr
+  refine ⟨T, ?_, Set.finite_range _⟩
+  apply top_unique
+  intro x hx
+  clear hx
+  obtain ⟨w, rfl⟩ := (con Inc ι).mk'_surjective x
+  induction w using CoprodI.induction_on with
+  | one => rw [map_one]; exact (Subgroup.closure T).one_mem
+  | of v b => exact Subgroup.subset_closure ⟨(v, b), rfl⟩
+  | mul x y hx hy => rw [map_mul]; exact (Subgroup.closure T).mul_mem hx hy
+
+end
+end OddKaplansky.Gluing
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/OddKaplansky/GraphEdges.lean b/lean/OAI/Algebra/OddKaplansky/GraphEdges.lean
new file mode 100644
index 0000000000000000000000000000000000000000..88da05fad179ee9f4928d51d0c0c8674706eebe1
--- /dev/null
+++ b/lean/OAI/Algebra/OddKaplansky/GraphEdges.lean
@@ -0,0 +1,180 @@
+import OAI.Algebra.OddKaplansky.IncidenceCycles
+
+namespace OAI
+
+section
+
+namespace OddKaplansky.GraphEdges
+noncomputable section
+open scoped Classical
+variable {V : Type} [LinearOrder V] (Γ : SimpleGraph V)
+
+abbrev Edge := {e : V × V // e.1 < e.2 ∧ Γ.Adj e.1 e.2}
+def Inc (v : V) (e : Edge Γ) : Prop := v = e.val.1 ∨ v = e.val.2
+
+def neighbor (v : V) (e : Edge Γ) : V := if v = e.val.1 then e.val.2 else e.val.1
+
+lemma incident_exists (e : Edge Γ) : ∃ v, Inc Γ v e := ⟨e.val.1, Or.inl rfl⟩
+lemma endpoints_ne (e : Edge Γ) : e.val.1 ≠ e.val.2 := (ne_of_lt e.property.1)
+
+lemma neighbor_incident (v : V) (e : Edge Γ) (_hv : Inc Γ v e) : Inc Γ (neighbor Γ v e) e := by
+  simp only [neighbor, Inc]
+  split_ifs <;> simp
+
+lemma neighbor_ne (v : V) (e : Edge Γ) (hv : Inc Γ v e) : neighbor Γ v e ≠ v := by
+  rcases hv with rfl | rfl <;> simp [neighbor, endpoints_ne Γ e, (endpoints_ne Γ e).symm]
+
+lemma neighbor_of_other {v w : V} {e : Edge Γ} (hv : Inc Γ v e) (hw : Inc Γ w e)
+    (hne : w ≠ v) : neighbor Γ v e = w := by
+  rcases hv with rfl | rfl <;> rcases hw with rfl | rfl <;>
+    simp_all [neighbor, endpoints_ne Γ e, (endpoints_ne Γ e).symm]
+
+lemma endpoints_of_inc {v w : V} {e : Edge Γ} (hv : Inc Γ v e) (hw : Inc Γ w e)
+    (hne : v ≠ w) : e.val = (v, w) ∨ e.val = (w, v) := by
+  rcases hv with rfl | rfl <;> rcases hw with rfl | rfl
+  · exact (hne rfl).elim
+  · exact Or.inl (Prod.eta _).symm
+  · exact Or.inr (Prod.eta _).symm
+  · exact (hne rfl).elim
+
+lemma edge_eq_of_inc {v w : V} {e f : Edge Γ}
+    (hev : Inc Γ v e) (hew : Inc Γ w e) (hfv : Inc Γ v f) (hfw : Inc Γ w f)
+    (hne : v ≠ w) : e = f := by
+  have he := endpoints_of_inc Γ hev hew hne
+  have hf := endpoints_of_inc Γ hfv hfw hne
+  rcases he with he | he <;> rcases hf with hf | hf
+  · exact Subtype.ext (he.trans hf.symm)
+  · have h₁ := e.property.1
+    have h₂ := f.property.1
+    rw [he] at h₁
+    rw [hf] at h₂
+    exact (lt_asymm h₁ h₂).elim
+  · have h₁ := e.property.1
+    have h₂ := f.property.1
+    rw [he] at h₁
+    rw [hf] at h₂
+    exact (lt_asymm h₁ h₂).elim
+  · exact Subtype.ext (he.trans hf.symm)
+
+lemma neighbor_injective (v : V) : Function.Injective (fun e : {e : Edge Γ // Inc Γ v e} =>
+    neighbor Γ v e.val) := by
+  intro e f h
+  change neighbor Γ v e.val = neighbor Γ v f.val at h
+  apply Subtype.ext
+  apply edge_eq_of_inc Γ e.property (neighbor_incident Γ v e.val e.property) f.property
+  · rw [h]
+    exact neighbor_incident Γ v f.val f.property
+  · exact (neighbor_ne Γ v e.val e.property).symm
+
+lemma adj_of_inc {v w : V} {e : Edge Γ} (hv : Inc Γ v e) (hw : Inc Γ w e) (hne : v ≠ w) :
+    Γ.Adj v w := by
+  have he := endpoints_of_inc Γ hv hw hne
+  rcases he with he | he
+  · simpa only [he] using e.property.2
+  · exact (show Γ.Adj w v by simpa only [he] using e.property.2).symm
+
+theorem incidence_girth (htri : ∀ a b c, Γ.Adj a b → Γ.Adj b c → Γ.Adj c a → False) :
+    8 ≤ (Planar.incidenceGraph (Inc Γ)).egirth := by
+  apply SimpleGraph.le_egirth.mpr
+  intro z w hw
+  obtain ⟨k, hk, hk2, point, line, hp, hl, hi, hn⟩ := Planar.cycle_polygon (Inc Γ) w hw
+  have hk4 : 4 ≤ k := by
+    by_contra hh
+    have hk' : k = 2 ∨ k = 3 := by omega
+    rcases hk' with rfl | rfl
+    · have hv0 : Inc Γ (point 1) (line 0) := by simpa using hn (0 : Fin 2)
+      have hv1 : Inc Γ (point 0) (line 1) := by simpa using hn (1 : Fin 2)
+      have he := edge_eq_of_inc Γ (hi 0) hv0 hv1 (hi 1) (fun h => by have := hp h; simp at this)
+      have hh := hl he
+      exact (by decide : (0 : Fin 2) ≠ 1) hh
+    · have h01 : Γ.Adj (point 0) (point 1) :=
+        adj_of_inc Γ (hi 0) (by simpa using hn (0 : Fin 3)) (fun h => by have := hp h; simp at this)
+      have h12 : Γ.Adj (point 1) (point 2) :=
+        adj_of_inc Γ (hi 1) (by simpa using hn (1 : Fin 3)) (fun h => by have := hp h; simp at this)
+      have h20 : Γ.Adj (point 2) (point 0) :=
+        adj_of_inc Γ (hi 2) (by simpa using hn (2 : Fin 3)) (fun h => by have := hp h; simp at this)
+      exact htri _ _ _ h01 h12 h20
+  exact_mod_cast (show 8 ≤ w.length by omega)
+
+end
+end OddKaplansky.GraphEdges
+
+namespace OddKaplansky.SourceGraph
+noncomputable section
+open scoped Classical
+
+@[ext] structure Vertex where
+  val : Finset (Fin 1200)
+  property : val.card = 600
+
+def vertexEquiv : Vertex ≃ {s : Finset (Fin 1200) // s.card = 600} where
+  toFun v := ⟨v.val, v.property⟩
+  invFun s := ⟨s.val, s.property⟩
+  left_inv _ := rfl
+  right_inv _ := rfl
+
+instance : Fintype Vertex := Fintype.ofEquiv _ vertexEquiv.symm
+instance : LinearOrder Vertex := LinearOrder.lift' (fun s => s.val.sort) (by
+  intro s t h
+  apply Vertex.ext
+  simpa using congrArg List.toFinset h)
+
+lemma card_vertices : Fintype.card Vertex = sourceM := by
+  unfold sourceM
+  have h := Fintype.card_finset_len (α := Fin 1200) 600
+  rw [Fintype.card_fin] at h
+  exact (Fintype.card_congr vertexEquiv).trans h
+
+def index (v : Vertex) : ℕ :=
+  ((Fintype.orderIsoFinOfCardEq Vertex card_vertices).symm v).val + 1
+
+lemma index_pos (v : Vertex) : 0 < index v := Nat.succ_pos _
+lemma index_le (v : Vertex) : index v ≤ sourceM :=
+  Nat.succ_le_of_lt ((Fintype.orderIsoFinOfCardEq Vertex card_vertices).symm v).isLt
+lemma index_injective : Function.Injective index := by
+  intro x y h
+  apply (Fintype.orderIsoFinOfCardEq Vertex card_vertices).symm.injective
+  apply Fin.ext
+  exact Nat.add_right_cancel h
+
+lemma index_strictMono : StrictMono index := by
+  intro x y h
+  exact Nat.add_lt_add_right ((Fintype.orderIsoFinOfCardEq Vertex card_vertices).symm.strictMono h) 1
+
+def graph : SimpleGraph Vertex where
+  Adj i j := i ≠ j ∧ (i.val ∩ j.val).card < 200
+  symm := ⟨by intro i j h; exact ⟨h.1.symm, by simpa only [Finset.inter_comm] using h.2⟩⟩
+  loopless := ⟨by intro i h; exact h.1 rfl⟩
+
+theorem no_triangle (a b c : Vertex) (hab : graph.Adj a b) (hbc : graph.Adj b c)
+    (hca : graph.Adj c a) : False := by
+  have hAB := Finset.card_union_add_card_inter a.val b.val
+  have hABC := Finset.card_union_add_card_inter (a.val ∪ b.val) c.val
+  have hI : ((a.val ∪ b.val) ∩ c.val).card ≤
+      (a.val ∩ c.val).card + (b.val ∩ c.val).card := by
+    rw [Finset.union_inter_distrib_right]
+    exact Finset.card_union_le _ _
+  have hU : (a.val ∪ b.val ∪ c.val).card ≤ 1200 := by
+    simpa only [Finset.card_univ, Fintype.card_fin] using
+      Finset.card_le_card (Finset.subset_univ (a.val ∪ b.val ∪ c.val))
+  have ha := a.property
+  have hb := b.property
+  have hc := c.property
+  have h₁ := hab.2
+  have h₂ := hbc.2
+  have h₃ : (a.val ∩ c.val).card < 200 := by simpa only [Finset.inter_comm] using hca.2
+  omega
+
+abbrev Edge := GraphEdges.Edge graph
+abbrev Inc := GraphEdges.Inc graph
+abbrev neighbor := GraphEdges.neighbor graph
+
+lemma incidence_girth : 8 ≤ (Planar.incidenceGraph Inc).egirth :=
+  GraphEdges.incidence_girth graph no_triangle
+
+end
+end OddKaplansky.SourceGraph
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/OddKaplansky/GraphNumerics.lean b/lean/OAI/Algebra/OddKaplansky/GraphNumerics.lean
new file mode 100644
index 0000000000000000000000000000000000000000..cc1663f7584b9db189cf677ec2580e8e07278fea
--- /dev/null
+++ b/lean/OAI/Algebra/OddKaplansky/GraphNumerics.lean
@@ -0,0 +1,103 @@
+import OAI.Algebra.OddKaplansky.BooleanPolynomial
+
+namespace OAI
+
+universe portUniverse1
+
+section
+noncomputable section
+open scoped Classical BigOperators
+namespace OddKaplansky.GraphNumerics
+
+def binomDefinition (k : ℕ) : ℕ := Nat.choose 1200 k
+opaque binomWrapped : Subtype (Eq binomDefinition) := ⟨_, rfl⟩
+
+def binom : (k : ℕ) → ℕ := binomWrapped.1
+theorem binom_def (k : ℕ) : binom k = Nat.choose 1200 k := by
+  delta binom
+  rw [show binomWrapped = ⟨binomDefinition, rfl⟩ from Subtype.ext binomWrapped.2.symm]
+  rfl
+attribute [irreducible] binom binomDefinition
+attribute [eqns binom_def] binom
+
+lemma choose_mono_small {a b : ℕ} (hab : a ≤ b) (hb : b ≤ 600) :
+    binom a ≤ binom b := by
+  induction hab with
+  | refl => exact le_rfl
+  | @step b hab ih =>
+    apply (ih (by omega)).trans
+    rw [binom_def, binom_def]
+    apply Nat.choose_le_succ_of_lt_half_left
+    omega
+
+lemma choose_step (k : ℕ) (hk : k ≤ 499) :
+    7 * binom k ≤ 5 * binom (k+1) := by
+  have he := Nat.choose_succ_right_eq 1200 k
+  rw [← binom_def (k+1), ← binom_def k] at he
+  have hc : 7 * (k+1) ≤ 5 * (1200-k) := by omega
+  have hh := Nat.mul_le_mul_left (binom k) hc
+  apply Nat.le_of_mul_le_mul_right (c := k+1)
+  · nlinarith only [he, hh]
+  · omega
+
+lemma choose_growth (n : ℕ) (hn : n ≤ 100) :
+    7^n * binom 400 ≤ 5^n * binom (400+n) := by
+  induction n with
+  | zero => simp
+  | succ n ih =>
+    have hi := ih (by omega)
+    have hs := choose_step (400+n) (by omega)
+    calc
+      _ = 7 * (7^n * binom 400) := by ring
+      _ ≤ 7 * (5^n * binom (400+n)) := Nat.mul_le_mul_left _ hi
+      _ = 5^n * (7 * binom (400+n)) := by ring
+      _ ≤ 5^n * (5 * binom (400+n+1)) := Nat.mul_le_mul_left _ hs
+      _ = _ := by simp only [pow_succ, Nat.add_assoc]; ring
+
+lemma sum_small_bound : (∑ j ∈ Finset.range 401, binom j) ≤ 401 * binom 400 := by
+  calc
+    _ ≤ ∑ _j ∈ Finset.range 401, binom 400 :=
+      Finset.sum_le_sum (fun j hj => choose_mono_small (by have := Finset.mem_range.mp hj; omega) (by omega))
+    _ = _ := by simp
+
+lemma ratio_bound : 100 * (∑ j ∈ Finset.range 401, binom j) < binom 600 := by
+  have hg := choose_growth 100 (by omega)
+  have hm := choose_mono_small (a := 500) (b := 600) (by omega) (by omega)
+  have hp : 0 < binom 400 := by rw [binom_def]; exact Nat.choose_pos (by omega)
+  have hc : 40100 * 5^100 < 7^100 := by norm_num
+  have hsmall := sum_small_bound
+  have ht := Nat.mul_le_mul_left (5^100) (Nat.mul_le_mul_left 100 hsmall)
+  have hstrict := Nat.mul_lt_mul_of_pos_right hc hp
+  have hlast := Nat.mul_le_mul_left (5^100) hm
+  apply Nat.lt_of_mul_lt_mul_left (a := 5^100)
+  nlinarith only [ht,hstrict,hg,hlast]
+
+lemma source_ratio_bound :
+    100 * (∑ j ∈ Finset.range 401, Nat.choose 1200 j) < Nat.choose 1200 600 := by
+  simpa only [binom_def] using ratio_bound
+
+variable (E : Type portUniverse1) [Fintype E]
+def smallSetEquiv (n : ℕ) :
+    {T : Finset E // T.card ≤ n} ≃ (Σ k : Fin (n+1), {T : Finset E // T.card = k.val}) where
+  toFun T := ⟨⟨T.val.card, by omega⟩, ⟨T.val,rfl⟩⟩
+  invFun v := ⟨v.2.val, by have := v.1.isLt; rw [v.2.property]; omega⟩
+  left_inv _ := rfl
+  right_inv v := by
+    rcases v with ⟨⟨k,hk⟩,⟨T,hT⟩⟩
+    change T.card = k at hT
+    dsimp
+    subst k
+    rfl
+
+lemma card_small_sets (n : ℕ) :
+    Fintype.card {T : Finset E // T.card ≤ n} = ∑ j ∈ Finset.range (n+1), Nat.choose (Fintype.card E) j := by
+  rw [Fintype.card_congr (smallSetEquiv E n), Fintype.card_sigma]
+  simp only [Fintype.card_finset_len]
+  exact Fin.sum_univ_eq_sum_range _ _
+
+end OddKaplansky.GraphNumerics
+
+end
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/OddKaplansky/GreedyColumns.lean b/lean/OAI/Algebra/OddKaplansky/GreedyColumns.lean
new file mode 100644
index 0000000000000000000000000000000000000000..4af35b88a1b203e1bd8561bfa99561cf0b1c3460
--- /dev/null
+++ b/lean/OAI/Algebra/OddKaplansky/GreedyColumns.lean
@@ -0,0 +1,60 @@
+import OAI.Algebra.OddKaplansky.SourceSector
+
+namespace OAI
+
+universe portUniverse1 portUniverse2 portUniverse3
+
+section
+namespace OddKaplansky.GreedyColumns
+noncomputable section
+open scoped Classical BigOperators
+open Submodule
+variable {K : Type portUniverse1} {S : Type portUniverse2} {V : Type portUniverse3} [Field K] [Fintype S] [LinearOrder S]
+variable [AddCommGroup V] [Module K V]
+variable (v : S → V)
+
+def Selected : Set S := {i | v i ∉ span K (v '' Set.Iio i)}
+abbrev Index := {i // Selected (K := K) v i}
+instance : Fintype (Index (K := K) v) :=
+  @Fintype.ofFinite _ (@Subtype.finite S (Finite.of_fintype S) (Selected (K := K) v))
+lemma independent : LinearIndependent K (fun i : Index (K := K) v => v i.val) := by
+  classical
+  have aux (s : Finset S) : (↑s : Set S) ⊆ Selected (K := K) v → LinearIndepOn K v (↑s : Set S) := by
+    induction s using Finset.induction_on_max with
+    | empty => intro _; simpa only [Finset.coe_empty] using linearIndepOn_empty K v
+    | insert a s hlt ih =>
+      intro hs
+      rw [Finset.coe_insert]
+      apply (ih (fun x hx => hs (by simp [hx]))).insert
+      intro ha
+      apply hs (show a ∈ (↑(insert a s) : Set S) by simp)
+      exact span_mono (Set.image_mono (fun x hx => hlt x hx)) ha
+  have h := aux (Finset.univ.filter (fun i => i ∈ Selected (K := K) v)) (by simp)
+  change LinearIndepOn K v (Selected (K := K) v)
+  convert h using 1
+  ext i
+  simp
+lemma span_selected : span K (Set.range (fun i : Index (K := K) v => v i.val)) = span K (Set.range v) := by
+  classical
+  apply le_antisymm
+  · apply span_mono
+    rintro x ⟨i,rfl⟩
+    exact ⟨i.val,rfl⟩
+  · apply span_le.mpr
+    rintro x ⟨i,rfl⟩
+    refine @WellFounded.induction S (· < ·) wellFounded_lt (fun i => v i ∈ span K (Set.range (fun i : Index (K := K) v => v i.val))) i ?_
+    intro i ih
+    by_cases hi : Selected (K := K) v i
+    · exact subset_span ⟨⟨i,hi⟩,rfl⟩
+    · have hm : v i ∈ span K (v '' Set.Iio i) := by
+        change ¬ (v i ∉ span K (v '' Set.Iio i)) at hi
+        exact not_not.mp hi
+      apply (span_le.mpr ?_ : span K (v '' Set.Iio i) ≤ span K (Set.range (fun i : Index (K := K) v => v i.val))) hm
+      rintro x ⟨j,hj,rfl⟩
+      exact ih j (by exact hj)
+end
+end OddKaplansky.GreedyColumns
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/OddKaplansky/GreedyFormula.lean b/lean/OAI/Algebra/OddKaplansky/GreedyFormula.lean
new file mode 100644
index 0000000000000000000000000000000000000000..7cbf05dd08f5d2ef50ea506fbbe5452b88fa50ad
--- /dev/null
+++ b/lean/OAI/Algebra/OddKaplansky/GreedyFormula.lean
@@ -0,0 +1,99 @@
+import OAI.Algebra.OddKaplansky.GreedyRectangle
+
+namespace OAI
+
+universe portUniverse1 portUniverse2 portUniverse3 portUniverse4 portUniverse5
+
+section
+namespace OddKaplansky.GreedyRing
+noncomputable section
+open scoped Classical BigOperators Matrix
+variable {K : Type portUniverse1} {D : Type portUniverse2} {S : Type portUniverse3} [Field K] [CommRing D] [Fintype S] [LinearOrder S]
+variable (ε : D →+* K) (unitLift : ∀ d : D, ε d ≠ 0 → IsUnit d)
+variable (E : Matrix S S D) (hE : E*E=E)
+lemma inverse_basis (i : I ε E ⊕ J ε E) :
+    (equiv ε unitLift E hE).symm (basis ε unitLift E hE i)=Pi.single ((indices ε E hE).symm i) 1 := by
+  rw [basis,Module.Basis.reindex_apply,Module.Basis.map_apply,LinearEquiv.symm_apply_apply,Pi.basisFun_apply]
+
+lemma imageBasis_coordinate (i : I ε E) (x : LinearMap.range (Matrix.toLin' E)) :
+    (imageBasis ε unitLift E hE).equivFun x i =
+      (equiv ε unitLift E hE).symm (x : S → D) ((indices ε E hE).symm (Sum.inl i)) := by
+  let F : LinearMap.range (Matrix.toLin' E) →ₗ[D] D :=
+    LinearMap.proj i ∘ₗ (imageBasis ε unitLift E hE).equivFun.toLinearMap
+  let G : LinearMap.range (Matrix.toLin' E) →ₗ[D] D :=
+    LinearMap.proj ((indices ε E hE).symm (Sum.inl i)) ∘ₗ
+      (equiv ε unitLift E hE).symm.toLinearMap ∘ₗ (LinearMap.range (Matrix.toLin' E)).subtype
+  have hh : F=G := by
+    apply (imageBasis ε unitLift E hE).ext
+    intro j
+    change (imageBasis ε unitLift E hE).equivFun (imageBasis ε unitLift E hE j) i =
+      (equiv ε unitLift E hE).symm (imageBasis ε unitLift E hE j : S → D) ((indices ε E hE).symm (Sum.inl i))
+    rw [imageBasis_apply,← basis_inl ε unitLift E hE j,inverse_basis]
+    simp [Pi.single_apply,eq_comm]
+  exact congrArg (fun L => L x) hh
+
+lemma inverse_first_projection (i : I ε E) (x : S → D) :
+    (equiv ε unitLift E hE).symm (Matrix.toLin' E x) ((indices ε E hE).symm (Sum.inl i))=
+      (equiv ε unitLift E hE).symm x ((indices ε E hE).symm (Sum.inl i)) := by
+  let F : (S → D) →ₗ[D] D := LinearMap.proj ((indices ε E hE).symm (Sum.inl i)) ∘ₗ
+    (equiv ε unitLift E hE).symm.toLinearMap ∘ₗ Matrix.toLin' E
+  let G : (S → D) →ₗ[D] D := LinearMap.proj ((indices ε E hE).symm (Sum.inl i)) ∘ₗ
+    (equiv ε unitLift E hE).symm.toLinearMap
+  have hh : F=G := by
+    apply (basis ε unitLift E hE).ext
+    intro a
+    cases a with
+    | inl j => simp only [F,G,LinearMap.comp_apply,fixed_inl]
+    | inr j =>
+      change (equiv ε unitLift E hE).symm (Matrix.toLin' E (basis ε unitLift E hE (Sum.inr j))) _ = _
+      rw [killed_inr,map_zero]
+      change 0=(equiv ε unitLift E hE).symm (basis ε unitLift E hE (Sum.inr j)) _
+      rw [inverse_basis]
+      simp
+  exact congrArg (fun L => L x) hh
+variable {W : Type portUniverse4} {N : Type portUniverse5} [Fintype W] [LinearOrder W] [Fintype N] [LinearOrder N]
+variable (hpair : Fintype.card N*Fintype.card S=Fintype.card W*Fintype.card (I ε E))
+lemma coordinateEquiv_symm_formula (y : W → LinearMap.range (Matrix.toLin' E)) (n : N) (s : S) :
+    (coordinateEquiv ε unitLift E hE hpair).symm y n s =
+      (imageBasis ε unitLift E hE).equivFun (y (pairing ε E hpair (n,s)).1) (pairing ε E hpair (n,s)).2 := rfl
+lemma rectangleY_formula (n : N) (w : W) (v : S → D) (s : S) :
+    rectangleY ε unitLift E hE hpair n w v s =
+      if (pairing ε E hpair (n,s)).1=w then
+        (Q ε E hE)⁻¹.mulVec v ((indices ε E hE).symm (Sum.inl (pairing ε E hpair (n,s)).2)) else 0 := by
+  let : DecidableEq W := Classical.decEq W
+  let : DecidableEq N := Classical.decEq N
+  change (coordinateEquiv ε unitLift E hE hpair).symm (Pi.single w ((Matrix.toLin' E).rangeRestrict v)) n s = _
+  rw [coordinateEquiv_symm_formula]
+  by_cases hw : (pairing ε E hpair (n,s)).1=w
+  · rw [ite_eq_left hw,Pi.single_apply,ite_eq_left hw,imageBasis_coordinate]
+    change (equiv ε unitLift E hE).symm (Matrix.toLin' E v) _ = _
+    exact (inverse_first_projection ε unitLift E hE (pairing ε E hpair (n,s)).2 v).trans
+      (congrFun (equiv_symm_apply ε unitLift E hE v) ((indices ε E hE).symm (Sum.inl (pairing ε E hpair (n,s)).2)))
+  · rw [ite_eq_right hw,Pi.single_apply,ite_eq_right hw,map_zero]
+    rfl
+lemma coordinateEquiv_formula (x : N → S → D) (w : W) :
+    (coordinateEquiv ε unitLift E hE hpair x w : S → D) =
+      ∑ i : I ε E, x ((pairing ε E hpair).symm (w,i)).1 ((pairing ε E hpair).symm (w,i)).2 • E.col i.val := by
+  change ((imageBasis ε unitLift E hE).equivFun.symm
+    (fun i => x ((pairing ε E hpair).symm (w,i)).1 ((pairing ε E hpair).symm (w,i)).2) : S → D) = _
+  rw [Module.Basis.equivFun_symm_apply]
+  simp only [Submodule.coe_sum,Submodule.coe_smul,imageBasis_apply]
+
+lemma rectangleJ_formula (w : W) (n : N) (v : S → D) (s : S) :
+    rectangleJ ε unitLift E hE hpair w n v s =
+      ∑ i : I ε E, if ((pairing ε E hpair).symm (w,i)).1=n then
+        v ((pairing ε E hpair).symm (w,i)).2 * E s i.val else 0 := by
+  let : DecidableEq W := Classical.decEq W
+  let : DecidableEq N := Classical.decEq N
+  change (coordinateEquiv ε unitLift E hE hpair (Pi.single n v) w : S → D) s = _
+  rw [coordinateEquiv_formula]
+  simp only [Finset.sum_apply,Pi.smul_apply,smul_eq_mul]
+  apply Finset.sum_congr rfl
+  intro i _
+  by_cases hn : ((pairing ε E hpair).symm (w,i)).1=n <;> simp [hn]
+end
+end OddKaplansky.GreedyRing
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/OddKaplansky/GreedyInverse.lean b/lean/OAI/Algebra/OddKaplansky/GreedyInverse.lean
new file mode 100644
index 0000000000000000000000000000000000000000..e2c7e4946d260c4c02ec016dd7943ef22540aa31
--- /dev/null
+++ b/lean/OAI/Algebra/OddKaplansky/GreedyInverse.lean
@@ -0,0 +1,32 @@
+import OAI.Algebra.OddKaplansky.GreedyRing
+
+namespace OAI
+
+universe portUniverse1 portUniverse2 portUniverse3
+
+section
+namespace OddKaplansky.GreedyRing
+noncomputable section
+open scoped Classical BigOperators Matrix
+variable {K : Type portUniverse1} {T : Type portUniverse2} {S : Type portUniverse3} [Field K] [CommGroup T] [Fintype T] [Fintype S] [LinearOrder S]
+variable (p : ℕ) [Fact p.Prime] [CharP K p] (hT : ∀ t : T, t^p=1)
+variable (j : T →* Multiplicative (Fin 3 → ZMod p)) (hj : Function.Injective j)
+variable (E : Matrix S S (MonoidAlgebra K T)) (hE : E*E=E)
+include hT hj in
+
+lemma prescribed_inverse_formula :
+    (Q LocalAlgebra.augment.toRingHom E hE)⁻¹ =
+      FiniteMatrixInverse.series
+        (LocalAlgebra.scalarInverse (Q LocalAlgebra.augment.toRingHom E hE) *
+          (Q LocalAlgebra.augment.toRingHom E hE-LocalAlgebra.scalarMatrix (Q LocalAlgebra.augment.toRingHom E hE)))
+        (3*(p-1)+1)*LocalAlgebra.scalarInverse (Q LocalAlgebra.augment.toRingHom E hE) := by
+  apply LocalAlgebra.matrix_inverse_formula p hT j hj
+  change ((Q LocalAlgebra.augment.toRingHom E hE).map LocalAlgebra.augment.toRingHom).det≠0
+  rw [Q_map]
+  exact GreedyLift.matrix_det _ _
+end
+end OddKaplansky.GreedyRing
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/OddKaplansky/GreedyLift.lean b/lean/OAI/Algebra/OddKaplansky/GreedyLift.lean
new file mode 100644
index 0000000000000000000000000000000000000000..01cea2cb6dc9cfddad2fb99f5603289808a87519
--- /dev/null
+++ b/lean/OAI/Algebra/OddKaplansky/GreedyLift.lean
@@ -0,0 +1,57 @@
+import OAI.Algebra.OddKaplansky.GreedyColumns
+
+namespace OAI
+
+universe portUniverse1 portUniverse2
+
+section
+namespace OddKaplansky.GreedyLift
+noncomputable section
+open scoped Classical BigOperators Matrix
+open Submodule
+variable {K : Type portUniverse1} {S : Type portUniverse2} [Field K] [Fintype S] [LinearOrder S]
+variable (E : Matrix S S K) (hE : E*E=E)
+abbrev I := GreedyColumns.Index (K := K) E.col
+abbrev J := GreedyColumns.Index (K := K) (1-E).col
+def columns : I E ⊕ J E → (S → K) := Sum.elim (fun i => E.col i.val) (fun j => (1-E).col j.val)
+include hE in
+lemma complement : IsCompl (span K (Set.range E.col)) (span K (Set.range (1-E).col)) := by
+  let L := Matrix.toLinAlgEquiv' (R := K) (n := S)
+  have hi : IsIdempotentElem (L E) := by change L E*L E=L E; rw [← map_mul,hE]
+  have hc := LinearMap.IsIdempotentElem.isCompl hi
+  rw [LinearMap.IsIdempotentElem.ker_eq_range_one_sub hi] at hc
+  have hm : L (1-E)=1-L E := by rw [map_sub,map_one]
+  rw [← hm] at hc
+  change IsCompl (LinearMap.range (Matrix.toLin' E)) (LinearMap.range (Matrix.toLin' (1-E))) at hc
+  simpa only [Matrix.range_toLin'] using hc
+include hE in
+lemma independent : LinearIndependent K (columns E) := by
+  apply (GreedyColumns.independent E.col).sum_type (GreedyColumns.independent (1-E).col)
+  rw [GreedyColumns.span_selected,GreedyColumns.span_selected]
+  exact (complement E hE).disjoint
+include hE in
+lemma spanning : span K (Set.range (columns E))=⊤ := by
+  rw [columns,Set.Sum.elim_range,span_union,GreedyColumns.span_selected,GreedyColumns.span_selected]
+  exact (complement E hE).sup_eq_top
+
+def basis : Module.Basis (I E ⊕ J E) K (S → K) :=
+  Module.Basis.mk (independent E hE) (spanning E hE).ge
+include hE in
+lemma card_indices : Fintype.card (I E) + Fintype.card (J E)=Fintype.card S := by
+  have hh := Module.finrank_eq_card_basis (basis E hE)
+  simpa using hh.symm
+
+def indices : S ≃ I E ⊕ J E :=
+  (FiniteChoice.orderedIndex S).trans ((finCongr (card_indices E hE).symm).trans
+    (finSumFinEquiv.symm.trans ((FiniteChoice.orderedIndex (I E)).symm.sumCongr (FiniteChoice.orderedIndex (J E)).symm)))
+def matrix : Matrix S S K := fun s t => columns E (indices E hE t) s
+lemma matrix_independent : LinearIndependent K (matrix E hE).col :=
+  (independent E hE).comp (indices E hE) (indices E hE).injective
+lemma matrix_det : (matrix E hE).det ≠ 0 :=
+  Matrix.nonsingular_iff_det_ne_zero.mp (Matrix.linearIndependent_col_iff.mp (matrix_independent E hE))
+end
+end OddKaplansky.GreedyLift
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/OddKaplansky/GreedyRectangle.lean b/lean/OAI/Algebra/OddKaplansky/GreedyRectangle.lean
new file mode 100644
index 0000000000000000000000000000000000000000..35e8a88d45691b7f97d0915fe38d8708d7fc3cd7
--- /dev/null
+++ b/lean/OAI/Algebra/OddKaplansky/GreedyRectangle.lean
@@ -0,0 +1,120 @@
+import OAI.Algebra.OddKaplansky.GreedyInverse
+
+namespace OAI
+
+universe contextUniverse1 contextUniverse2 contextUniverse3 contextUniverse4 contextUniverse5
+
+universe portUniverse1 portUniverse2 portUniverse3 portUniverse4 portUniverse5
+
+section
+namespace OddKaplansky.GreedyRing
+noncomputable section
+open scoped Classical BigOperators Matrix
+variable {K : Type portUniverse1} {D : Type portUniverse2} {S : Type portUniverse3} [Field K] [CommRing D] [Fintype S] [LinearOrder S]
+variable (ε : D →+* K) (unitLift : ∀ d : D, ε d ≠ 0 → IsUnit d)
+variable (E : Matrix S S D) (hE : E*E=E)
+variable {W : Type portUniverse4} {N : Type portUniverse5} [Fintype W] [sectionInstance58 : LinearOrder W] [Fintype N] [sectionInstance59 : LinearOrder N]
+variable (hpair : Fintype.card N*Fintype.card S=Fintype.card W*Fintype.card (I ε E))
+
+def pairing : (N×S) ≃ (W×I ε E) :=
+  (@FiniteChoice.orderedIndex (N×S) (FiniteChoice.tupleOrder N S) inferInstance).trans
+    ((finCongr (by simpa only [Fintype.card_prod] using hpair)).trans
+      (@FiniteChoice.orderedIndex (W×I ε E) (FiniteChoice.tupleOrder W (I ε E)) inferInstance).symm)
+
+def coordinateEquiv : (N → S → D) ≃ₗ[D] (W → LinearMap.range (Matrix.toLin' E)) :=
+  (LinearEquiv.curry D D N S).symm.trans
+    ((LinearEquiv.funCongrLeft D D (pairing ε E hpair).symm).trans
+      ((LinearEquiv.curry D D W (I ε E)).trans
+        (LinearEquiv.piCongrRight (fun _ : W => (imageBasis ε unitLift E hE).equivFun.symm))))
+def rectangleJ : Matrix W N (Module.End D (S → D)) :=
+  IdempotentFree.J (Matrix.toLin' E) (coordinateEquiv ε unitLift E hE hpair)
+def rectangleY : Matrix N W (Module.End D (S → D)) :=
+  IdempotentFree.Y (Matrix.toLin' E) (coordinateEquiv ε unitLift E hE hpair)
+lemma rectangleYJ : rectangleY ε unitLift E hE hpair*rectangleJ ε unitLift E hE hpair=1 := by
+  have hi : Matrix.toLin' E ∘ₗ Matrix.toLin' E=Matrix.toLin' E := by rw [← Matrix.toLin'_mul,hE]
+  convert IdempotentFree.YJ (Matrix.toLin' E) hi (coordinateEquiv ε unitLift E hE hpair) using 1 <;> congr ; exact Subsingleton.elim _ _
+lemma rectangleJY : rectangleJ ε unitLift E hE hpair*rectangleY ε unitLift E hE hpair=Matrix.diagonal (fun _ : W => Matrix.toLin' E) := by
+  convert IdempotentFree.JY (Matrix.toLin' E) (coordinateEquiv ε unitLift E hE hpair) using 1 <;> congr ; exact Subsingleton.elim _ _
+variable [Algebra K D] [Module.Finite K D]
+include unitLift hE in
+lemma image_dimension : Module.finrank K (LinearMap.range (Matrix.toLin' E))=Fintype.card (I ε E)*Module.finrank K D := by
+  have hh := ((imageBasis ε unitLift E hE).equivFun.restrictScalars K).finrank_eq
+  simpa only [Module.finrank_pi_fintype,Finset.sum_const,Finset.card_univ,nsmul_eq_mul,Nat.cast_id] using hh
+lemma pair_dimension
+    {K : Type contextUniverse1}
+    {D : Type contextUniverse2}
+    {S : Type contextUniverse3}
+    [contextInstance3 : Field.{contextUniverse1} K]
+    [contextInstance4 : CommRing.{contextUniverse2} D]
+    [contextInstance5 : Fintype.{contextUniverse3} S]
+    [LinearOrder.{contextUniverse3} S]
+    (ε : @RingHom.{contextUniverse2, contextUniverse1} D K
+  (@Semiring.toNonAssocSemiring.{contextUniverse2} D
+    (@CommSemiring.toSemiring.{contextUniverse2} D (@CommRing.toCommSemiring.{contextUniverse2} D contextInstance4)))
+  (@Semiring.toNonAssocSemiring.{contextUniverse1} K
+    (@CommSemiring.toSemiring.{contextUniverse1} K
+      (@Semifield.toCommSemiring.{contextUniverse1} K (@Field.toSemifield.{contextUniverse1} K contextInstance3)))))
+    (unitLift : ∀ (d : D),
+  @Ne.{contextUniverse1 + 1} K
+      (@DFunLike.coe.{max (contextUniverse1 + 1) (contextUniverse2 + 1), contextUniverse2 + 1, contextUniverse1 + 1}
+        (@RingHom.{contextUniverse2, contextUniverse1} D K
+          (@Semiring.toNonAssocSemiring.{contextUniverse2} D
+            (@CommSemiring.toSemiring.{contextUniverse2} D (@CommRing.toCommSemiring.{contextUniverse2} D contextInstance4)))
+          (@Semiring.toNonAssocSemiring.{contextUniverse1} K
+            (@CommSemiring.toSemiring.{contextUniverse1} K
+              (@Semifield.toCommSemiring.{contextUniverse1} K (@Field.toSemifield.{contextUniverse1} K contextInstance3)))))
+        D (fun _ => K)
+        (@RingHom.instFunLike.{contextUniverse2, contextUniverse1} D K
+          (@Semiring.toNonAssocSemiring.{contextUniverse2} D
+            (@CommSemiring.toSemiring.{contextUniverse2} D (@CommRing.toCommSemiring.{contextUniverse2} D contextInstance4)))
+          (@Semiring.toNonAssocSemiring.{contextUniverse1} K
+            (@CommSemiring.toSemiring.{contextUniverse1} K
+              (@Semifield.toCommSemiring.{contextUniverse1} K (@Field.toSemifield.{contextUniverse1} K contextInstance3)))))
+        ε d)
+      (@OfNat.ofNat.{contextUniverse1} K (nat_lit 0)
+        (@Zero.toOfNat0.{contextUniverse1} K
+          (@MulZeroClass.toZero.{contextUniverse1} K
+            (@instMulZeroClassOfSemiring.{contextUniverse1} K
+              (@CommSemiring.toSemiring.{contextUniverse1} K
+                (@Semifield.toCommSemiring.{contextUniverse1} K (@Field.toSemifield.{contextUniverse1} K contextInstance3))))))) →
+    @IsUnit.{contextUniverse2} D
+      (@Semiring.toMonoid.{contextUniverse2} D
+        (@CommSemiring.toSemiring.{contextUniverse2} D (@CommRing.toCommSemiring.{contextUniverse2} D contextInstance4)))
+      d)
+    (E : Matrix.{contextUniverse3, contextUniverse3, contextUniverse2} S S D)
+    (hE : @Eq.{max (contextUniverse2 + 1) (contextUniverse3 + 1)} (Matrix.{contextUniverse3, contextUniverse3, contextUniverse2} S S D)
+  (@HMul.hMul.{max contextUniverse2 contextUniverse3, max contextUniverse2 contextUniverse3, max contextUniverse2 contextUniverse3} (Matrix.{contextUniverse3, contextUniverse3, contextUniverse2} S S D) (Matrix.{contextUniverse3, contextUniverse3, contextUniverse2} S S D)
+    (Matrix.{contextUniverse3, contextUniverse3, contextUniverse2} S S D)
+    (@Matrix.instHMulOfFintypeOfMulOfAddCommMonoid.{contextUniverse2, contextUniverse3, contextUniverse3, contextUniverse3} S S S D contextInstance5
+      (@Distrib.toMul.{contextUniverse2} D
+        (@instDistribOfSemiring.{contextUniverse2} D
+          (@CommSemiring.toSemiring.{contextUniverse2} D (@CommRing.toCommSemiring.{contextUniverse2} D contextInstance4))))
+      (@Semiring.toAddCommMonoid.{contextUniverse2} D
+        (@CommSemiring.toSemiring.{contextUniverse2} D (@CommRing.toCommSemiring.{contextUniverse2} D contextInstance4))))
+    E E)
+  E)
+    {W : Type contextUniverse4}
+    {N : Type contextUniverse5}
+    [Fintype.{contextUniverse4} W]
+    [LinearOrder.{contextUniverse4} W]
+    [Fintype.{contextUniverse5} N]
+    [LinearOrder.{contextUniverse5} N]
+    [contextInstance17 : @Algebra.{contextUniverse1, contextUniverse2} K D (@Semifield.toCommSemiring.{contextUniverse1} K (@Field.toSemifield.{contextUniverse1} K contextInstance3))
+  (@CommSemiring.toSemiring.{contextUniverse2} D (@CommRing.toCommSemiring.{contextUniverse2} D contextInstance4))]
+    [@Module.Finite.{contextUniverse1, contextUniverse2} K D
+  (@CommSemiring.toSemiring.{contextUniverse1} K (@Semifield.toCommSemiring.{contextUniverse1} K (@Field.toSemifield.{contextUniverse1} K contextInstance3)))
+  (@Semiring.toAddCommMonoid.{contextUniverse2} D
+    (@CommSemiring.toSemiring.{contextUniverse2} D (@CommRing.toCommSemiring.{contextUniverse2} D contextInstance4)))
+  (@Algebra.toModule.{contextUniverse1, contextUniverse2} K D (@Semifield.toCommSemiring.{contextUniverse1} K (@Field.toSemifield.{contextUniverse1} K contextInstance3))
+    (@CommSemiring.toSemiring.{contextUniverse2} D (@CommRing.toCommSemiring.{contextUniverse2} D contextInstance4)) contextInstance17)] (hw : Fintype.card W=Module.finrank K (S → D))
+    (hn : Fintype.card N=Module.finrank K (LinearMap.range (Matrix.toLin' E))) :
+    Fintype.card N*Fintype.card S=Fintype.card W*Fintype.card (I ε E) := by
+  rw [hn,hw,image_dimension ε unitLift E hE]
+  simp only [Module.finrank_pi_fintype,Finset.sum_const,Finset.card_univ,nsmul_eq_mul,Nat.cast_id]
+  ring
+end
+end OddKaplansky.GreedyRing
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/OddKaplansky/GreedyRing.lean b/lean/OAI/Algebra/OddKaplansky/GreedyRing.lean
new file mode 100644
index 0000000000000000000000000000000000000000..9c8af85a67e36452223eda237fef94644e3295fc
--- /dev/null
+++ b/lean/OAI/Algebra/OddKaplansky/GreedyRing.lean
@@ -0,0 +1,116 @@
+import OAI.Algebra.OddKaplansky.GreedyLift
+
+namespace OAI
+
+universe contextUniverse1 contextUniverse2 contextUniverse3
+
+universe portUniverse1 portUniverse2 portUniverse3
+
+section
+namespace OddKaplansky.GreedyRing
+noncomputable section
+open scoped Classical BigOperators Matrix
+open Submodule
+variable {K : Type portUniverse1} {D : Type portUniverse2} {S : Type portUniverse3} [Field K] [CommRing D] [Fintype S] [sectionInstance57 : LinearOrder S]
+variable (ε : D →+* K) (unitLift : ∀ d : D, ε d ≠ 0 → IsUnit d)
+variable (E : Matrix S S D) (hE : E*E=E)
+def E₀ : Matrix S S K := E.map ε
+lemma E₀_idem
+    {K : Type contextUniverse1}
+    {D : Type contextUniverse2}
+    {S : Type contextUniverse3}
+    [contextInstance3 : Field.{contextUniverse1} K]
+    [contextInstance4 : CommRing.{contextUniverse2} D]
+    [contextInstance5 : Fintype.{contextUniverse3} S]
+    [LinearOrder.{contextUniverse3} S]
+    (ε : @RingHom.{contextUniverse2, contextUniverse1} D K
+  (@Semiring.toNonAssocSemiring.{contextUniverse2} D
+    (@CommSemiring.toSemiring.{contextUniverse2} D (@CommRing.toCommSemiring.{contextUniverse2} D contextInstance4)))
+  (@Semiring.toNonAssocSemiring.{contextUniverse1} K
+    (@CommSemiring.toSemiring.{contextUniverse1} K
+      (@Semifield.toCommSemiring.{contextUniverse1} K (@Field.toSemifield.{contextUniverse1} K contextInstance3)))))
+    (E : Matrix.{contextUniverse3, contextUniverse3, contextUniverse2} S S D)
+    (hE : @Eq.{max (contextUniverse2 + 1) (contextUniverse3 + 1)} (Matrix.{contextUniverse3, contextUniverse3, contextUniverse2} S S D)
+  (@HMul.hMul.{max contextUniverse2 contextUniverse3, max contextUniverse2 contextUniverse3, max contextUniverse2 contextUniverse3} (Matrix.{contextUniverse3, contextUniverse3, contextUniverse2} S S D) (Matrix.{contextUniverse3, contextUniverse3, contextUniverse2} S S D)
+    (Matrix.{contextUniverse3, contextUniverse3, contextUniverse2} S S D)
+    (@Matrix.instHMulOfFintypeOfMulOfAddCommMonoid.{contextUniverse2, contextUniverse3, contextUniverse3, contextUniverse3} S S S D contextInstance5
+      (@Distrib.toMul.{contextUniverse2} D
+        (@instDistribOfSemiring.{contextUniverse2} D
+          (@CommSemiring.toSemiring.{contextUniverse2} D (@CommRing.toCommSemiring.{contextUniverse2} D contextInstance4))))
+      (@Semiring.toAddCommMonoid.{contextUniverse2} D
+        (@CommSemiring.toSemiring.{contextUniverse2} D (@CommRing.toCommSemiring.{contextUniverse2} D contextInstance4))))
+    E E)
+  E) : E₀ ε E*E₀ ε E=E₀ ε E := by
+  change E.map ε*E.map ε=E.map ε
+  rw [← Matrix.map_mul,hE]
+abbrev I := GreedyLift.I (E₀ ε E)
+abbrev J := GreedyLift.J (E₀ ε E)
+def columns : I ε E ⊕ J ε E → (S → D) := Sum.elim (fun i => E.col i.val) (fun j => (1-E).col j.val)
+def indices : S ≃ I ε E ⊕ J ε E := GreedyLift.indices (E₀ ε E) (E₀_idem ε E hE)
+
+def Q : Matrix S S D := fun s t => columns ε E (indices ε E hE t) s
+lemma Q_map : (Q ε E hE).map ε=GreedyLift.matrix (E₀ ε E) (E₀_idem ε E hE) := by
+  funext s t
+  change ε (columns ε E (indices ε E hE t) s) = GreedyLift.columns (E₀ ε E) (indices ε E hE t) s
+  cases hi : indices ε E hE t with
+  | inl i => rfl
+  | inr j =>
+    change ε ((1-E) s j.val)=(1-E₀ ε E) s j.val
+    simp only [Matrix.sub_apply,map_sub,E₀,Matrix.map_apply,Matrix.one_apply]
+    by_cases h : s=j.val <;> simp [h]
+include unitLift in
+lemma Q_det_unit : IsUnit (Q ε E hE).det := by
+  apply unitLift
+  rw [RingHom.map_det]
+  change ((Q ε E hE).map ε).det ≠ 0
+  rw [Q_map]
+  exact GreedyLift.matrix_det _ _
+def equiv : (S → D) ≃ₗ[D] (S → D) :=
+  Matrix.toLin'OfInv (Matrix.nonsing_inv_mul (Q ε E hE) (Q_det_unit ε unitLift E hE))
+    (Matrix.mul_nonsing_inv (Q ε E hE) (Q_det_unit ε unitLift E hE))
+lemma equiv_apply (x : S → D) : equiv ε unitLift E hE x=(Q ε E hE).mulVec x := rfl
+lemma equiv_symm_apply (x : S → D) : (equiv ε unitLift E hE).symm x=(Q ε E hE)⁻¹.mulVec x := rfl
+
+def basis : Module.Basis (I ε E ⊕ J ε E) D (S → D) :=
+  ((Pi.basisFun D S).map (equiv ε unitLift E hE)).reindex (indices ε E hE)
+lemma basis_apply (i : I ε E ⊕ J ε E) : basis ε unitLift E hE i=columns ε E i := by
+  rw [basis,Module.Basis.reindex_apply,Module.Basis.map_apply,Pi.basisFun_apply,equiv_apply,Matrix.mulVec_single_one]
+  funext s
+  change columns ε E (indices ε E hE ((indices ε E hE).symm i)) s=columns ε E i s
+  rw [Equiv.apply_symm_apply]
+lemma basis_inl (i : I ε E) : basis ε unitLift E hE (Sum.inl i)=E.col i.val := basis_apply ε unitLift E hE _
+lemma basis_inr (j : J ε E) : basis ε unitLift E hE (Sum.inr j)=(1-E).col j.val := basis_apply ε unitLift E hE _
+lemma fixed_inl (i : I ε E) : Matrix.toLin' E (basis ε unitLift E hE (Sum.inl i))=basis ε unitLift E hE (Sum.inl i) := by
+  rw [basis_inl]
+  change (E*E).col i.val=E.col i.val
+  rw [hE]
+lemma killed_inr (j : J ε E) : Matrix.toLin' E (basis ε unitLift E hE (Sum.inr j))=0 := by
+  rw [basis_inr]
+  change (E*(1-E)).col j.val=0
+  rw [mul_sub,mul_one,hE,sub_self]
+  rfl
+lemma image_independent : LinearIndependent D (fun i : I ε E => basis ε unitLift E hE (Sum.inl i)) :=
+  (basis ε unitLift E hE).linearIndependent.comp Sum.inl Sum.inl_injective
+lemma image_span : span D (Set.range (fun i : I ε E => basis ε unitLift E hE (Sum.inl i)))=LinearMap.range (Matrix.toLin' E) := by
+  apply le_antisymm
+  · apply span_le.mpr
+    rintro x ⟨i,rfl⟩
+    exact ⟨basis ε unitLift E hE (Sum.inl i),fixed_inl ε unitLift E hE i⟩
+  · rintro x ⟨y,rfl⟩
+    have hy := congrArg (fun z : S → D => Matrix.toLin' E z) ((basis ε unitLift E hE).sum_repr y)
+    rw [← hy,map_sum,Fintype.sum_sum_type]
+    simp only [map_smul,fixed_inl,killed_inr,smul_zero,Finset.sum_const_zero,add_zero]
+    apply Submodule.sum_mem
+    intro i _
+    exact smul_mem _ _ (subset_span ⟨i,rfl⟩)
+def imageBasis : Module.Basis (I ε E) D (LinearMap.range (Matrix.toLin' E)) :=
+  (Module.Basis.span (image_independent ε unitLift E hE)).map (LinearEquiv.ofEq _ _ (image_span ε unitLift E hE))
+lemma imageBasis_apply (i : I ε E) : (imageBasis ε unitLift E hE i : S → D)=E.col i.val := by
+  simp only [imageBasis,Module.Basis.map_apply,LinearEquiv.ofEq,Module.Basis.span_apply,basis_inl]
+  rfl
+end
+end OddKaplansky.GreedyRing
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/OddKaplansky/Heisenberg.lean b/lean/OAI/Algebra/OddKaplansky/Heisenberg.lean
new file mode 100644
index 0000000000000000000000000000000000000000..738e1e092544af25e74e32d4577769a372cb13ea
--- /dev/null
+++ b/lean/OAI/Algebra/OddKaplansky/Heisenberg.lean
@@ -0,0 +1,85 @@
+import OAI.Algebra.OddKaplansky.SquareCertificate
+
+namespace OAI
+
+section
+namespace OddKaplansky.Heisenberg
+noncomputable section
+open scoped Classical BigOperators
+variable (M q : ℕ)
+abbrev Z := Fin q → Fourier.C M
+def dot (y x : Z M q) : Fourier.C M := Multiplicative.ofAdd (∑ j, (y j).toAdd * (x j).toAdd)
+lemma dot_one_left (x : Z M q) : dot M q 1 x=1 := by simp [dot]
+lemma dot_one_right (y : Z M q) : dot M q y 1=1 := by simp [dot]
+lemma dot_mul_left (y t x : Z M q) : dot M q (y*t) x = dot M q y x * dot M q t x := by
+  apply Multiplicative.toAdd.injective
+  simp [dot,add_mul,Finset.sum_add_distrib]
+lemma dot_mul_right (y x s : Z M q) : dot M q y (x*s) = dot M q y x * dot M q y s := by
+  apply Multiplicative.toAdd.injective
+  simp [dot,mul_add,Finset.sum_add_distrib]
+lemma dot_inv_left (y x : Z M q) : dot M q y⁻¹ x = (dot M q y x)⁻¹ := by
+  apply Multiplicative.toAdd.injective
+  simp [dot,Finset.sum_neg_distrib]
+lemma dot_inv_right (y x : Z M q) : dot M q y x⁻¹ = (dot M q y x)⁻¹ := by
+  apply Multiplicative.toAdd.injective
+  simp [dot,Finset.sum_neg_distrib]
+lemma dot_symm (y x : Z M q) : dot M q y x=dot M q x y := by simp [dot,mul_comm]
+structure GroupData where
+  x : Z M q
+  y : Z M q
+  k : Fourier.C M
+@[ext] lemma GroupData.ext {a b : GroupData M q} (hx : a.x=b.x) (hy : a.y=b.y) (hk : a.k=b.k) : a=b := by
+  cases a; cases b; simp_all
+instance : One (GroupData M q) := ⟨⟨1,1,1⟩⟩
+instance : Mul (GroupData M q) := ⟨fun a b => ⟨a.x*b.x,a.y*b.y,a.k*b.k*dot M q a.y b.x⟩⟩
+instance : Inv (GroupData M q) := ⟨fun a => ⟨a.x⁻¹,a.y⁻¹,a.k⁻¹*dot M q a.y a.x⟩⟩
+@[simp] lemma one_x : (1 : GroupData M q).x=1 := rfl
+@[simp] lemma one_y : (1 : GroupData M q).y=1 := rfl
+@[simp] lemma one_k : (1 : GroupData M q).k=1 := rfl
+@[simp] lemma mul_x (a b : GroupData M q) : (a*b).x=a.x*b.x := rfl
+@[simp] lemma mul_y (a b : GroupData M q) : (a*b).y=a.y*b.y := rfl
+@[simp] lemma mul_k (a b : GroupData M q) : (a*b).k=a.k*b.k*dot M q a.y b.x := rfl
+@[simp] lemma inv_x (a : GroupData M q) : a⁻¹.x=a.x⁻¹ := rfl
+@[simp] lemma inv_y (a : GroupData M q) : a⁻¹.y=a.y⁻¹ := rfl
+@[simp] lemma inv_k (a : GroupData M q) : a⁻¹.k=a.k⁻¹*dot M q a.y a.x := rfl
+instance : Group (GroupData M q) where
+  mul_assoc a b c := by ext <;> simp only [mul_x,mul_y,mul_k,dot_mul_left,dot_mul_right,mul_assoc]; ac_rfl
+  one_mul a := by ext <;> simp [dot_one_left]
+  mul_one a := by ext <;> simp [dot_one_right]
+  inv_mul_cancel a := by ext <;> simp [dot_inv_left,mul_comm]
+def coordinates : GroupData M q ≃ Z M q × Z M q × Fourier.C M where
+  toFun a := (a.x,a.y,a.k)
+  invFun a := ⟨a.1,a.2.1,a.2.2⟩
+  left_inv _ := rfl
+  right_inv _ := rfl
+instance [NeZero M] : Fintype (GroupData M q) := Fintype.ofEquiv _ (coordinates M q).symm
+lemma card [NeZero M] : Fintype.card (GroupData M q)=M*(M^q)^2 := by
+  rw [Fintype.card_congr (coordinates M q)]
+  simp only [Fintype.card_prod,Fintype.card_fun,Fintype.card_fin,Fintype.card_multiplicative,ZMod.card]
+  ring
+def central : Fourier.C M →* GroupData M q where
+  toFun k := ⟨1,1,k⟩
+  map_one' := rfl
+  map_mul' a b := by ext <;> simp [dot_one_left]
+def X : Z M q →* GroupData M q where
+  toFun x := ⟨x,1,1⟩
+  map_one' := rfl
+  map_mul' a b := by ext <;> simp [dot_one_left]
+def Y : Z M q →* GroupData M q where
+  toFun y := ⟨1,y,1⟩
+  map_one' := rfl
+  map_mul' a b := by ext <;> simp [dot_one_right]
+lemma central_injective : Function.Injective (central M q) := fun _ _ he => congrArg GroupData.k he
+lemma central_commute (c : Fourier.C M) (g : GroupData M q) : Commute (central M q c) g := by
+  change central M q c*g=g*central M q c
+  ext <;> simp [central,dot_one_left,dot_one_right,mul_comm]
+lemma YX (y x : Z M q) : Y M q y * X M q x = central M q (dot M q y x) * (X M q x * Y M q y) := by
+  ext <;> simp [central,X,Y,dot_one_left,dot_one_right]
+lemma normal (g : GroupData M q) : g=central M q g.k * (X M q g.x * Y M q g.y) := by
+  ext <;> simp [central,X,Y,dot_one_left,dot_one_right]
+end
+end OddKaplansky.Heisenberg
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/OddKaplansky/HeisenbergRepresentation.lean b/lean/OAI/Algebra/OddKaplansky/HeisenbergRepresentation.lean
new file mode 100644
index 0000000000000000000000000000000000000000..d93232e57a40c02da9b8e970d8c0ee06cdfb9548
--- /dev/null
+++ b/lean/OAI/Algebra/OddKaplansky/HeisenbergRepresentation.lean
@@ -0,0 +1,99 @@
+import OAI.Algebra.OddKaplansky.Heisenberg
+
+namespace OAI
+
+universe portUniverse1
+
+section
+namespace OddKaplansky.Heisenberg
+noncomputable section
+open scoped Classical BigOperators Matrix
+variable (M q : ℕ) [NeZero M] {K : Type portUniverse1} [Field K] {ζ : K} (hζ : IsPrimitiveRoot ζ M)
+lemma character_dot (s y : Z M q) : Fourier.character M hζ s y = Fourier.cyclicCharacter M hζ (dot M q y s) := by
+  rw [dot_symm]; rfl
+
+def ρGroup : GroupData M q →* Matrix (Z M q) (Z M q) K where
+  toFun g := Matrix.of fun u s => if u=s*g.x then (Fourier.cyclicCharacter M hζ g.k : K)*(Fourier.character M hζ s g.y : K) else 0
+  map_one' := by ext u s; simp [Matrix.of_apply, Matrix.one_apply]
+  map_mul' g h := by
+    ext u s
+    rw [Matrix.mul_apply,Finset.sum_eq_single (s*h.x)]
+    · simp only [Matrix.of_apply,mul_x,mul_y,mul_k,map_mul,Units.val_mul]
+      by_cases he : u=s*h.x*g.x
+      · rw [show s*(g.x*h.x)=s*h.x*g.x by ac_rfl,ite_eq_left he,ite_eq_left he,ite_true]
+        rw [Fourier.character_mul,MonoidHom.mul_apply,Units.val_mul]
+        simp only [character_dot]
+        ring
+      · simp only [show s*(g.x*h.x)=s*h.x*g.x by ac_rfl,ite_eq_right he,zero_mul]
+    · intro b _ hb
+      simp only [Matrix.of_apply,ite_eq_right hb,mul_zero]
+    · simp
+
+def ρ : MonoidAlgebra K (GroupData M q) →ₐ[K] Matrix (Z M q) (Z M q) K := MonoidAlgebra.lift K _ _ (ρGroup M q hζ)
+lemma ρ_single (g : GroupData M q) (c : K) (u s : Z M q) :
+    ρ M q hζ (MonoidAlgebra.single g c) u s =
+      if u=s*g.x then c*(Fourier.cyclicCharacter M hζ g.k : K)*(Fourier.character M hζ s g.y : K) else 0 := by
+  rw [ρ,MonoidAlgebra.lift_single]
+  change c*(if u=s*g.x then _ else 0)=_
+  split_ifs <;> simp [mul_assoc]
+def f : MonoidAlgebra K (GroupData M q) := CharacterIdempotents.pushed (central M q) (Fourier.cyclicCharacter M hζ)
+lemma f_idempotent (hc : (Fintype.card (Fourier.C M) : K) ≠ 0) : f M q hζ*f M q hζ=f M q hζ := CharacterIdempotents.pushed_idempotent _ _ hc
+lemma f_ne_zero (hc : (Fintype.card (Fourier.C M) : K) ≠ 0) : f M q hζ ≠ 0 := CharacterIdempotents.pushed_ne_zero _ (central_injective M q) _ hc
+lemma f_central (a : MonoidAlgebra K (GroupData M q)) : Commute (f M q hζ) a := CharacterIdempotents.pushed_central _ _ (central_commute M q) a
+lemma ρ_f (hc : (Fintype.card (Fourier.C M) : K) ≠ 0) : ρ M q hζ (f M q hζ)=1 := by
+  ext u s
+  rw [f,CharacterIdempotents.pushed_eq_sum,map_smul,map_sum]
+  simp only [Matrix.smul_apply,Matrix.sum_apply,ρ_single,central,MonoidHom.coe_mk,OneHom.coe_mk,mul_one,map_one,Units.val_one,mul_one,Matrix.one_apply]
+  by_cases he : u=s
+  · subst u
+    simp only [ite_true,inv_mul_cancel₀ (Units.ne_zero _),Finset.sum_const,Finset.card_univ,nsmul_eq_mul,mul_one,smul_eq_mul]
+    exact inv_mul_cancel₀ hc
+  · simp [he]
+def p (v : Z M q) : MonoidAlgebra K (GroupData M q) := CharacterIdempotents.pushed (Y M q) (Fourier.character M hζ v)
+def D (v : Z M q) : MonoidAlgebra K (GroupData M q) := f M q hζ * p M q hζ v
+lemma ρ_p (hc : (Fintype.card (Z M q) : K) ≠ 0) (v : Z M q) :
+    ρ M q hζ (p M q hζ v) = Matrix.single v v 1 := by
+  ext u s
+  rw [p,CharacterIdempotents.pushed_eq_sum,map_smul,map_sum]
+  simp only [Matrix.smul_apply,Matrix.sum_apply,ρ_single,Y,MonoidHom.coe_mk,OneHom.coe_mk,mul_one,map_one,Units.val_one]
+  by_cases he : u=s
+  · subst u
+    simp only [ite_true,smul_eq_mul]
+    have hs : ∑ a : Z M q, (Fourier.character M hζ v a : K)⁻¹ * (Fourier.character M hζ s a : K) = if s=v then (Fintype.card (Z M q) : K) else 0 := by
+      by_cases hsv : s=v
+      · subst s; simp
+      · rw [ite_eq_right hsv]
+        have hh := CharacterIdempotents.sum_character_eq_zero ((Fourier.character M hζ s)*(Fourier.character M hζ v)⁻¹) (by
+          intro h
+          apply hsv
+          apply Fourier.character_injective M hζ
+          apply MonoidHom.ext
+          intro a
+          exact mul_inv_eq_one.mp (congrArg (fun f : Z M q →* Kˣ => f a) h))
+        simpa [mul_comm] using hh
+    rw [hs]
+    by_cases hsv : s=v
+    · subst s
+      simpa only [Matrix.single_apply,ite_true,and_self] using inv_mul_cancel₀ hc
+    · simp [hsv,Ne.symm hsv,Matrix.single]
+  · simp [he,Matrix.single]; aesop
+lemma ρ_D (hc : (Fintype.card (Fourier.C M) : K) ≠ 0) (hz : (Fintype.card (Z M q) : K) ≠ 0) (v : Z M q) :
+    ρ M q hζ (D M q hζ v)=Matrix.single v v 1 := by rw [D,map_mul,ρ_f M q hζ hc,one_mul,ρ_p M q hζ hz]
+def xElt (u : Z M q) : MonoidAlgebra K (GroupData M q) := MonoidAlgebra.single (X M q u) 1
+def Ω (u v : Z M q) : MonoidAlgebra K (GroupData M q) := xElt M q (u*v⁻¹) * D M q hζ v
+lemma ρ_Ω (hc : (Fintype.card (Fourier.C M) : K) ≠ 0) (hz : (Fintype.card (Z M q) : K) ≠ 0) (u v : Z M q) :
+    ρ M q hζ (Ω M q hζ u v)=Matrix.single u v 1 := by
+  rw [Ω,map_mul,ρ_D M q hζ hc hz]
+  ext a b
+  simp only [Matrix.mul_apply,xElt,ρ_single,X,MonoidHom.coe_mk,OneHom.coe_mk,map_one,Units.val_one,mul_one,Matrix.single]
+  by_cases hb : b=v
+  · subst b
+    simp only [Matrix.of_apply,ite_and,mul_ite,mul_zero,ite_mul,zero_mul,Finset.sum_ite_eq,Finset.mem_univ,ite_true]
+    simp [eq_comm]
+  · simp [Ne.symm hb,Matrix.of_apply]
+end
+end OddKaplansky.Heisenberg
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/OddKaplansky/HeisenbergSector.lean b/lean/OAI/Algebra/OddKaplansky/HeisenbergSector.lean
new file mode 100644
index 0000000000000000000000000000000000000000..0cd1aef5b70d42d157b47806c8a66ee6cb1b4a95
--- /dev/null
+++ b/lean/OAI/Algebra/OddKaplansky/HeisenbergSector.lean
@@ -0,0 +1,125 @@
+import OAI.Algebra.OddKaplansky.HeisenbergRepresentation
+
+namespace OAI
+
+universe portUniverse1
+
+section
+namespace OddKaplansky.Heisenberg
+noncomputable section
+open scoped Classical BigOperators Matrix
+variable (M q : ℕ) [NeZero M] {K : Type portUniverse1} [Field K] {ζ : K} (hζ : IsPrimitiveRoot ζ M)
+variable (hc : (Fintype.card (Fourier.C M) : K) ≠ 0) (hz : (Fintype.card (Z M q) : K) ≠ 0)
+abbrev Sector := LinearMap.range (Algebra.lmul K (MonoidAlgebra K (GroupData M q)) (f M q hζ))
+lemma mem_sector_of_fixed {a : MonoidAlgebra K (GroupData M q)} (ha : f M q hζ*a=a) : a ∈ Sector M q hζ := ⟨a,ha⟩
+include hc in
+lemma fixed_of_mem_sector {a : MonoidAlgebra K (GroupData M q)} (ha : a ∈ Sector M q hζ) : f M q hζ*a=a := by
+  obtain ⟨a,rfl⟩ := ha
+  change f M q hζ*(f M q hζ*a)=f M q hζ*a
+  rw [← mul_assoc,f_idempotent M q hζ hc]
+include hc in
+lemma Ω_fixed (u v : Z M q) : f M q hζ*Ω M q hζ u v=Ω M q hζ u v := by
+  unfold Ω D
+  rw [← mul_assoc,(f_central M q hζ _).eq,mul_assoc,← mul_assoc (f M q hζ),f_idempotent M q hζ hc]
+def frame (xy : Z M q × Z M q) : MonoidAlgebra K (GroupData M q) := f M q hζ * MonoidAlgebra.single ⟨xy.1,xy.2,1⟩ 1
+lemma f_single (g : GroupData M q) : f M q hζ*MonoidAlgebra.single g 1 = (Fourier.cyclicCharacter M hζ g.k : K) • frame M q hζ (g.x,g.y) := by
+  have hg : central M q g.k * (⟨g.x,g.y,1⟩ : GroupData M q)=g := by ext <;> simp [central,dot_one_left]
+  have hs : MonoidAlgebra.single g (1 : K)=MonoidAlgebra.single (central M q g.k) 1*MonoidAlgebra.single (⟨g.x,g.y,1⟩ : GroupData M q) 1 := by rw [MonoidAlgebra.single_mul_single,one_mul,hg]
+  rw [hs,← mul_assoc]
+  have hh := CharacterIdempotents.pushed_mul_single (central M q) (Fourier.cyclicCharacter M hζ) g.k
+  change f M q hζ*MonoidAlgebra.single (central M q g.k) 1=(Fourier.cyclicCharacter M hζ g.k : K) • f M q hζ at hh
+  rw [hh,smul_mul_assoc]
+  rfl
+lemma span_frame : Submodule.span K (Set.range (frame M q hζ))=Sector M q hζ := by
+  apply le_antisymm
+  · apply Submodule.span_le.mpr
+    rintro _ ⟨xy,rfl⟩
+    exact ⟨_,rfl⟩
+  · rintro _ ⟨a,rfl⟩
+    change f M q hζ*a ∈ _
+    induction a using MonoidAlgebra.induction_on with
+    | of g =>
+      rw [MonoidAlgebra.of_apply,f_single]
+      exact Submodule.smul_mem _ _ (Submodule.subset_span ⟨(g.x,g.y),rfl⟩)
+    | add a b ha hb => rw [mul_add]; exact Submodule.add_mem _ ha hb
+    | smul c a ha => rw [mul_smul_comm]; exact Submodule.smul_mem _ c ha
+lemma sector_dim_le : Module.finrank K (Sector M q hζ) ≤ Fintype.card (Z M q)*Fintype.card (Z M q) := by
+  rw [← span_frame]
+  simpa only [Set.finrank,Fintype.card_prod] using finrank_range_le_card (R := K) (frame M q hζ)
+
+def encode : Matrix (Z M q) (Z M q) K →ₗ[K] MonoidAlgebra K (GroupData M q) where
+  toFun T := ∑ u,∑ v,T u v • Ω M q hζ u v
+  map_add' T S := by simp only [Matrix.add_apply,add_smul,Finset.sum_add_distrib]
+  map_smul' c T := by simp only [Matrix.smul_apply,smul_smul,smul_eq_mul,Finset.smul_sum,RingHom.id_apply]
+lemma encode_apply (T : Matrix (Z M q) (Z M q) K) : encode M q hζ T=∑ u,∑ v,T u v • Ω M q hζ u v := rfl
+include hc in
+lemma encode_fixed (T : Matrix (Z M q) (Z M q) K) : f M q hζ*encode M q hζ T = encode M q hζ T := by
+  simp only [encode_apply,Finset.mul_sum,mul_smul_comm,Ω_fixed M q hζ hc]
+include hc hz in
+lemma ρ_encode (T : Matrix (Z M q) (Z M q) K) : ρ M q hζ (encode M q hζ T)=T := by
+  simp only [encode_apply,map_sum,map_smul,ρ_Ω M q hζ hc hz]
+  ext u v
+  simp [Matrix.sum_apply,Matrix.single_apply,ite_and]
+include hc hz in
+lemma encode_injective : Function.Injective (encode M q hζ) := by
+  intro T S he
+  have hh := congrArg (ρ M q hζ) he
+  simpa only [ρ_encode M q hζ hc hz] using hh
+include hc hz in
+lemma encode_range : LinearMap.range (encode M q hζ)=Sector M q hζ := by
+  apply Submodule.eq_of_le_of_finrank_le
+  · rintro _ ⟨T,rfl⟩
+    exact mem_sector_of_fixed _ _ _ (encode_fixed M q hζ hc T)
+  · rw [LinearMap.finrank_range_of_inj (encode_injective M q hζ hc hz)]
+    simpa only [Module.finrank_matrix,Module.finrank_self,mul_one] using sector_dim_le M q hζ
+include hc hz in
+lemma ρ_injective_on_sector {a b : MonoidAlgebra K (GroupData M q)}
+    (ha : a ∈ Sector M q hζ) (hb : b ∈ Sector M q hζ) (he : ρ M q hζ a=ρ M q hζ b) : a=b := by
+  rw [← encode_range M q hζ hc hz] at ha hb
+  obtain ⟨T,rfl⟩ := ha
+  obtain ⟨S,rfl⟩ := hb
+  rw [ρ_encode M q hζ hc hz,ρ_encode M q hζ hc hz] at he
+  rw [he]
+include hc hz in
+lemma Ω_mul (u v s t : Z M q) : Ω M q hζ u v*Ω M q hζ s t=if v=s then Ω M q hζ u t else 0 := by
+  apply ρ_injective_on_sector M q hζ hc hz
+  · apply mem_sector_of_fixed
+    rw [← mul_assoc,Ω_fixed M q hζ hc]
+  · split_ifs
+    · exact mem_sector_of_fixed _ _ _ (Ω_fixed M q hζ hc _ _)
+    · exact Submodule.zero_mem _
+  · rw [map_mul,ρ_Ω M q hζ hc hz,ρ_Ω M q hζ hc hz]
+    split_ifs with hv <;> simp only [ρ_Ω M q hζ hc hz,map_zero]
+    all_goals
+      ext a b
+      simp [Matrix.mul_apply,Matrix.single_apply,ite_and,mul_ite,hv] <;> split_ifs <;> rfl
+include hc hz in
+lemma Ω_sum : ∑ u : Z M q, Ω M q hζ u u=f M q hζ := by
+  apply ρ_injective_on_sector M q hζ hc hz
+  · apply mem_sector_of_fixed
+    simp only [Finset.mul_sum,Ω_fixed M q hζ hc]
+  · exact ⟨1,by simp⟩
+  · rw [map_sum,ρ_f M q hζ hc]
+    simp only [ρ_Ω M q hζ hc hz]
+    ext a b
+    simp [Matrix.sum_apply,Matrix.single_apply,Matrix.one_apply,ite_and,eq_comm]
+include hc hz in
+lemma Ω_ne_zero (u v : Z M q) : Ω M q hζ u v≠0 := by
+  intro he
+  have hh := congrArg (fun a => ρ M q hζ a u v) he
+  rw [ρ_Ω M q hζ hc hz,map_zero] at hh
+  simp at hh
+include hc hz in
+lemma encode_mul (T S : Matrix (Z M q) (Z M q) K) : encode M q hζ (T*S)=encode M q hζ T*encode M q hζ S := by
+  apply ρ_injective_on_sector M q hζ hc hz
+  · exact mem_sector_of_fixed _ _ _ (encode_fixed M q hζ hc _)
+  · apply mem_sector_of_fixed
+    rw [← mul_assoc,encode_fixed M q hζ hc]
+  · have hh : ρ M q hζ (encode M q hζ T*encode M q hζ S)=ρ M q hζ (encode M q hζ T)*ρ M q hζ (encode M q hζ S) := map_mul (ρ M q hζ) _ _
+    rw [hh,ρ_encode M q hζ hc hz,ρ_encode M q hζ hc hz,ρ_encode M q hζ hc hz]
+end
+end OddKaplansky.Heisenberg
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/OddKaplansky/HighCount.lean b/lean/OAI/Algebra/OddKaplansky/HighCount.lean
new file mode 100644
index 0000000000000000000000000000000000000000..ed952a20d7858d5d27eab5e123907ef17ded85a7
--- /dev/null
+++ b/lean/OAI/Algebra/OddKaplansky/HighCount.lean
@@ -0,0 +1,57 @@
+import OAI.Algebra.OddKaplansky.SimplexCount
+
+namespace OAI
+
+section
+
+namespace OddKaplansky.Augmentation
+noncomputable section
+open scoped Classical BigOperators
+variable (p ell : ℕ) [sectionInstance38 : Fact p.Prime]
+
+lemma complement_lt
+    (p : Nat)
+    [Fact (Nat.Prime p)] (n : Fin p) : p-1-n.val < p := by have := n.isLt; omega
+lemma complement_complement
+    (p : Nat)
+    [Fact (Nat.Prime p)] (n : Fin p) : p-1-(p-1-n.val) = n.val := by have := n.isLt; omega
+
+def highEquivDeficit : High (E := Fin 3) p ell ≃ SimplexCount.Deficit p ell where
+  toFun n := ⟨fun i => ⟨p-1-(n.val i).val, complement_lt p (n.val i)⟩,by
+    have hn := n.property
+    have h0 := (n.val 0).isLt; have h1 := (n.val 1).isLt; have h2 := (n.val 2).isLt
+    simp [Fin.sum_univ_succ] at hn ⊢
+    omega⟩
+  invFun n := ⟨fun i => ⟨p-1-(n.val i).val, complement_lt p (n.val i)⟩,by
+    have hn := n.property
+    have h0 := (n.val 0).isLt; have h1 := (n.val 1).isLt; have h2 := (n.val 2).isLt
+    simp [Fin.sum_univ_succ] at hn ⊢
+    omega⟩
+  left_inv n := by ext i; exact complement_complement p (n.val i)
+  right_inv n := by ext i; exact complement_complement p (n.val i)
+
+lemma card_high (hl : ell ≤ p) : Fintype.card (High (E := Fin 3) p ell) = (ell+2).choose 3 := by
+  rw [Fintype.card_congr (highEquivDeficit p ell),SimplexCount.card_deficit p ell hl]
+
+lemma card_high_le
+    (p : Nat)
+    (ell : Nat)
+    [Fact (Nat.Prime p)] : Fintype.card (High (E := Fin 3) p ell) ≤ p^3 := by
+  calc
+    _ ≤ Fintype.card (Fin 3 → Fin p) := Fintype.card_le_of_injective Subtype.val Subtype.val_injective
+    _ = _ := by simp
+
+lemma high_ratio (hp : p = 2*ell+1) (hl : 1 ≤ ell) :
+    p^3 < 48*Fintype.card (High (E := Fin 3) p ell) := by
+  have he : ell ≤ p := by omega
+  rw [card_high p ell he, ← SimplexCount.card_tetrahedron]
+  have hc := SimplexCount.six_tetrahedron ell
+  rw [hp]
+  nlinarith
+
+end
+end OddKaplansky.Augmentation
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/OddKaplansky/IdempotentFree.lean b/lean/OAI/Algebra/OddKaplansky/IdempotentFree.lean
new file mode 100644
index 0000000000000000000000000000000000000000..2ef5c8fa5251af0e062c4985e5b6b420eb0eb03e
--- /dev/null
+++ b/lean/OAI/Algebra/OddKaplansky/IdempotentFree.lean
@@ -0,0 +1,120 @@
+import OAI.Algebra.OddKaplansky.AugmentInverse
+
+namespace OAI
+
+universe contextUniverse1 contextUniverse2 contextUniverse3 contextUniverse4
+
+universe portUniverse1 portUniverse2 portUniverse3 portUniverse4 portUniverse5 portUniverse6 portUniverse7
+
+section
+namespace OddKaplansky.IdempotentFree
+noncomputable section
+open scoped Classical BigOperators
+variable {D : Type portUniverse1} {V : Type portUniverse2} [CommRing D] [sectionInstance52 : IsLocalRing D] [AddCommGroup V] [Module D V]
+variable (E : V →ₗ[D] V) (hE : E ∘ₗ E = E)
+include hE in
+omit [IsLocalRing D] in
+lemma range_fixed (x : LinearMap.range E) : E x = x := by
+  obtain ⟨v,hv⟩ := x.property
+  have h := LinearMap.congr_fun hE v
+  simpa only [LinearMap.comp_apply,hv] using h
+lemma split
+    {D : Type contextUniverse1} {V : Type contextUniverse2}
+    [CommRing D] [IsLocalRing D] [AddCommGroup V] [Module D V]
+    (E : V →ₗ[D] V) (hE : E ∘ₗ E = E) : E.rangeRestrict.comp (LinearMap.range E).subtype = LinearMap.id := by
+  ext x
+  exact range_fixed E hE x
+include hE in
+lemma projective [Module.Free D V] : Module.Projective D (LinearMap.range E) :=
+  Module.Projective.of_split (LinearMap.range E).subtype E.rangeRestrict (split E hE)
+include hE in
+lemma free [Module.Free D V] [Module.Finite D V] : Module.Free D (LinearMap.range E) := by
+  let := projective E hE
+  exact Module.free_of_flat_of_isLocalRing
+
+section Rectangular
+variable {W : Type portUniverse3} {N : Type portUniverse4} [sectionInstance54 : Fintype W] [sectionInstance53 : Fintype N]
+variable (q : (N → V) ≃ₗ[D] (W → LinearMap.range E))
+def J : Matrix W N (Module.End D V) := fun w n =>
+  (LinearMap.range E).subtype ∘ₗ LinearMap.proj w ∘ₗ q.toLinearMap ∘ₗ LinearMap.single D (fun _ : N => V) n
+def Y : Matrix N W (Module.End D V) := fun n w =>
+  LinearMap.proj n ∘ₗ q.symm.toLinearMap ∘ₗ LinearMap.single D (fun _ : W => LinearMap.range E) w ∘ₗ E.rangeRestrict
+omit [IsLocalRing D] in
+lemma single_sum (x : N → V) : ∑ n : N, (LinearMap.single D (fun _ : N => V) n) (x n) = x := by
+  ext n
+  simp
+omit [IsLocalRing D] in
+lemma YJ
+    {D : Type contextUniverse1} {V : Type contextUniverse2}
+    [CommRing D] [AddCommGroup V] [Module D V]
+    (E : V →ₗ[D] V) (hE : E ∘ₗ E = E)
+    {W : Type contextUniverse3} {N : Type contextUniverse4} [Fintype W] [Fintype N]
+    (q : (N → V) ≃ₗ[D] (W → LinearMap.range E)) : Y E q * J E q = 1 := by
+  funext n n'
+  apply LinearMap.ext
+  intro v
+  let x := q (Pi.single n' v)
+  have hs : ∑ w : W, Pi.single w (x w) = x := single_sum (D := D) x
+  calc
+    (Y E q * J E q) n n' v = ∑ w : W, (q.symm (Pi.single w (x w))) n := by
+      simp only [Matrix.mul_apply,Module.End.mul_apply,LinearMap.sum_apply,Y,J,LinearMap.comp_apply]
+      apply Finset.sum_congr rfl
+      intro w _
+      change (q.symm (Pi.single w (E.rangeRestrict (x w : V)))) n = (q.symm (Pi.single w (x w))) n
+      have hr : E.rangeRestrict (x w : V) = x w := Subtype.ext (range_fixed E hE (x w))
+      rw [hr]
+    _ = (q.symm (∑ w : W, Pi.single w (x w))) n := by simp only [map_sum,Finset.sum_apply]
+    _ = (Pi.single n' v : N → V) n := by rw [hs]; exact congrFun (q.symm_apply_apply (Pi.single n' v)) n
+    _ = (1 : Matrix N N (Module.End D V)) n n' v := by
+      by_cases h : n=n'
+      · subst n'; simp
+      · simp [h]
+omit [IsLocalRing D] in
+lemma JY
+    {D : Type contextUniverse1} {V : Type contextUniverse2}
+    [CommRing D] [AddCommGroup V] [Module D V]
+    (E : V →ₗ[D] V)
+    {W : Type contextUniverse3} {N : Type contextUniverse4} [Fintype W] [Fintype N]
+    (q : (N → V) ≃ₗ[D] (W → LinearMap.range E)) : J E q * Y E q = Matrix.diagonal (fun _ : W => E) := by
+  funext w w'
+  apply LinearMap.ext
+  intro v
+  let x := q.symm (Pi.single w' (E.rangeRestrict v))
+  have hs : ∑ n : N, Pi.single n (x n) = x := single_sum (D := D) x
+  calc
+    (J E q * Y E q) w w' v = ∑ n : N, ((q (Pi.single n (x n))) w : V) := by
+      simp only [Matrix.mul_apply,Module.End.mul_apply,LinearMap.sum_apply,Y,J,LinearMap.comp_apply]
+      rfl
+    _ = ((q (∑ n : N, Pi.single n (x n))) w : V) := by simp only [map_sum,Finset.sum_apply,Submodule.coe_sum]
+    _ = (((Pi.single w' (E.rangeRestrict v) : W → LinearMap.range E)) w : V) := by rw [hs]; exact congrArg (fun f : W → LinearMap.range E => (f w : V)) (q.apply_symm_apply (Pi.single w' (E.rangeRestrict v)))
+    _ = (Matrix.diagonal (fun _ : W => E)) w w' v := by
+      by_cases h : w=w'
+      · subst w'; simp
+      · simp [h]
+end Rectangular
+
+section Dimension
+variable {K : Type portUniverse5} [Field K] [Algebra K D] [Module K V] [IsScalarTower K D V]
+variable [Module.Free D V] [Module.Finite D V] [Module.Finite K D]
+variable {W : Type portUniverse6} {N : Type portUniverse7} [Fintype W] [Fintype N]
+include hE in
+lemma rectangular (hw : Fintype.card W = Module.finrank K V)
+    (hn : Fintype.card N = Module.finrank K (LinearMap.range E)) :
+    ∃ (J : Matrix W N (Module.End D V)) (Y : Matrix N W (Module.End D V)),
+      Y*J=1 ∧ J*Y=Matrix.diagonal (fun _ : W => E) := by
+  let := free E hE
+  have hv := Module.finrank_mul_finrank K D V
+  have he := Module.finrank_mul_finrank K D (LinearMap.range E)
+  have heq : Module.finrank D (N → V) = Module.finrank D (W → LinearMap.range E) := by
+    simp only [Module.finrank_pi_fintype,Finset.sum_const,Finset.card_univ,nsmul_eq_mul]
+    rw [hw,hn]
+    nlinarith
+  let q := LinearEquiv.ofFinrankEq (R := D) (N → V) (W → LinearMap.range E) heq
+  exact ⟨J E q,Y E q,YJ E hE q,JY E q⟩
+end Dimension
+end
+end OddKaplansky.IdempotentFree
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/OddKaplansky/IncidenceCycles.lean b/lean/OAI/Algebra/OddKaplansky/IncidenceCycles.lean
new file mode 100644
index 0000000000000000000000000000000000000000..cc8f95a6d9b6acb5c6ec6ac43db0e508e95deac6
--- /dev/null
+++ b/lean/OAI/Algebra/OddKaplansky/IncidenceCycles.lean
@@ -0,0 +1,115 @@
+import OAI.Algebra.OddKaplansky.Gluing
+
+namespace OAI
+
+universe portUniverse1 portUniverse2
+
+section
+noncomputable section
+open scoped Classical
+namespace OddKaplansky.Planar
+variable {V : Type portUniverse1} {F : Type portUniverse2} (Inc : V → F → Prop)
+
+def incidenceColoring : (incidenceGraph Inc).Coloring Bool :=
+  SimpleGraph.Coloring.mk Sum.isLeft (by
+    intro x y h
+    cases x <;> cases y <;> simp_all [incidenceGraph])
+
+lemma incidence_walk_even {u : V ⊕ F} (w : (incidenceGraph Inc).Walk u u) : Even w.length := by
+  exact ((incidenceColoring Inc).even_length_iff_congr w).mpr Iff.rfl
+
+lemma getVert_even_left {v : V} {z : V ⊕ F} (w : (incidenceGraph Inc).Walk (.inl v) z)
+    (i : ℕ) (hi : 2*i ≤ w.length) : ∃ x : V, w.getVert (2*i)=.inl x := by
+  have he : Even (w.take (2*i)).length := by rw [SimpleGraph.Walk.take_length,inf_eq_left.mpr hi]; exact even_two_mul i
+  have hc := ((incidenceColoring Inc).even_length_iff_congr (w.take (2*i))).mp he
+  cases hx : w.getVert (2*i) with
+  | inl x => exact ⟨x,rfl⟩
+  | inr f =>
+    change (true = true ↔ Sum.isLeft (w.getVert (2*i)) = true) at hc
+    rw [hx] at hc
+    exact False.elim (Bool.noConfusion (hc.mp rfl))
+
+lemma getVert_odd_right {v : V} {z : V ⊕ F} (w : (incidenceGraph Inc).Walk (.inl v) z)
+    (i : ℕ) (hi : 2*i+1 ≤ w.length) : ∃ f : F, w.getVert (2*i+1)=.inr f := by
+  obtain ⟨x,hx⟩ := getVert_even_left Inc w i (by omega)
+  have ha := w.adj_getVert_succ (by omega : 2*i < w.length)
+  rw [hx] at ha
+  cases hf : w.getVert (2*i+1) with
+  | inl y =>
+    rw [hf] at ha
+    exact False.elim ha
+  | inr f => exact ⟨f,rfl⟩
+
+lemma cycle_polygon_left {v : V} (w : (incidenceGraph Inc).Walk (.inl v) (.inl v))
+    (hw : w.IsCycle) {k : ℕ} (hk : w.length=2*k) :
+    ∃ (point : Fin k → V) (line : Fin k → F), Function.Injective point ∧ Function.Injective line ∧
+      (∀ i, Inc (point i) (line i)) ∧ (∀ i, Inc (point (finRotate k i)) (line i)) := by
+  have hkp : 0 < k := by have := hw.three_le_length; omega
+  have hp (i : Fin k) := getVert_even_left Inc w i.val (by omega)
+  have hl (i : Fin k) := getVert_odd_right Inc w i.val (by omega)
+  let point (i : Fin k) := (hp i).choose
+  let line (i : Fin k) := (hl i).choose
+  have hpoint (i : Fin k) : w.getVert (2*i.val)=.inl (point i) := (hp i).choose_spec
+  have hline (i : Fin k) : w.getVert (2*i.val+1)=.inr (line i) := (hl i).choose_spec
+  have hnext (i : Fin k) : w.getVert (2*i.val+2)=.inl (point (finRotate k i)) := by
+    have hk2 : 2 ≤ k := by have := hw.three_le_length; omega
+    by_cases hi : i.val+1 < k
+    · have hh : (finRotate k i).val=i.val+1 := by
+        rw [finRotate_apply]
+        exact Fin.val_add_one_of_lt' hi
+      rw [show 2*i.val+2=2*(finRotate k i).val by omega]
+      exact hpoint _
+    · have hi' : i.val=k-1 := by omega
+      have hrot : finRotate k i=⟨0,hkp⟩ := by
+        apply Fin.ext
+        rw [finRotate_apply,Fin.val_add]
+        simp [hi',Nat.sub_add_cancel (by omega : 1 ≤ k)]
+      rw [show 2*i.val+2=w.length by omega,SimpleGraph.Walk.getVert_length,hrot]
+      simpa using (hpoint ⟨0,hkp⟩)
+  refine ⟨point,line,?_,?_,?_,?_⟩
+  · intro i j hij
+    apply Fin.ext
+    have he := hw.getVert_injOn' (show 2*i.val ≤ w.length-1 by omega)
+      (show 2*j.val ≤ w.length-1 by omega) ((hpoint i).trans ((congrArg Sum.inl hij).trans (hpoint j).symm))
+    omega
+  · intro i j hij
+    apply Fin.ext
+    have he := hw.getVert_injOn' (show 2*i.val+1 ≤ w.length-1 by omega)
+      (show 2*j.val+1 ≤ w.length-1 by omega) ((hline i).trans ((congrArg Sum.inr hij).trans (hline j).symm))
+    omega
+  · intro i
+    have ha := w.adj_getVert_succ (by omega : 2*i.val < w.length)
+    rw [hpoint,hline] at ha
+    exact ha
+  · intro i
+    have ha := w.adj_getVert_succ (by omega : 2*i.val+1 < w.length)
+    rw [hline,show 2*i.val+1+1=2*i.val+2 by omega,hnext] at ha
+    exact ha
+
+lemma cycle_polygon {z : V ⊕ F} (w : (incidenceGraph Inc).Walk z z) (hw : w.IsCycle) :
+    ∃ k, w.length=2*k ∧ 2 ≤ k ∧ ∃ (point : Fin k → V) (line : Fin k → F),
+      Function.Injective point ∧ Function.Injective line ∧
+      (∀ i, Inc (point i) (line i)) ∧ (∀ i, Inc (point (finRotate k i)) (line i)) := by
+  obtain ⟨k,hk⟩ := incidence_walk_even Inc w
+  have hk' : w.length=2*k := by omega
+  refine ⟨k,hk',by have := hw.three_le_length; omega,?_⟩
+  cases z with
+  | inl v => exact cycle_polygon_left Inc w hw hk'
+  | inr f =>
+    have ha := w.adj_getVert_succ (by have := hw.three_le_length; omega : 0 < w.length)
+    simp only [SimpleGraph.Walk.getVert_zero,zero_add] at ha
+    cases hz : w.getVert 1 with
+    | inr g =>
+      rw [hz] at ha
+      exact False.elim ha
+    | inl v =>
+      have hm : (.inl v : V ⊕ F) ∈ w.support := hz ▸ w.getVert_mem_support 1
+      exact cycle_polygon_left Inc (w.rotate (.inl v) hm) (hw.rotate hm)
+        ((w.length_rotate _ _).trans hk')
+
+end OddKaplansky.Planar
+
+end
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/OddKaplansky/IndexCut.lean b/lean/OAI/Algebra/OddKaplansky/IndexCut.lean
new file mode 100644
index 0000000000000000000000000000000000000000..44dd4c0c51546ef4a1001ef564eef2fb061007a2
--- /dev/null
+++ b/lean/OAI/Algebra/OddKaplansky/IndexCut.lean
@@ -0,0 +1,28 @@
+import OAI.Algebra.OddKaplansky.Cellular
+
+namespace OAI
+
+universe portUniverse1 portUniverse2
+
+section
+namespace OddKaplansky.IndexCut
+variable {S : Type portUniverse1} {L : Type portUniverse2} {r n : ℕ} (s : S ≃ Fin r) (l : L ≃ Fin n) (hn : r < n)
+def inclusion (i : S) : L := l.symm (Fin.castLE hn.le (s i))
+lemma injective : Function.Injective (inclusion s l hn) := by
+  intro i j he
+  apply s.injective
+  apply Fin.ext
+  have hh := congrArg (fun x => (l x).val) he
+  simpa only [inclusion,Equiv.apply_symm_apply,Fin.val_castLE] using hh
+def extra : L := l.symm ⟨n-1,by omega⟩
+lemma misses (i : S) : inclusion s l hn i ≠ extra l hn := by
+  intro he
+  have hh := congrArg (fun x => (l x).val) he
+  simp only [inclusion,extra,Equiv.apply_symm_apply,Fin.val_castLE] at hh
+  have hi := (s i).isLt
+  omega
+end OddKaplansky.IndexCut
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/OddKaplansky/LocalAlgebra.lean b/lean/OAI/Algebra/OddKaplansky/LocalAlgebra.lean
new file mode 100644
index 0000000000000000000000000000000000000000..a9424486fa7d5c8a570cc02290cc77e5799410d2
--- /dev/null
+++ b/lean/OAI/Algebra/OddKaplansky/LocalAlgebra.lean
@@ -0,0 +1,48 @@
+import OAI.Algebra.OddKaplansky.SectorOrbit
+
+namespace OAI
+
+universe portUniverse1 portUniverse2
+
+section
+namespace OddKaplansky.LocalAlgebra
+noncomputable section
+open scoped Classical BigOperators
+variable {K : Type portUniverse1} {T : Type portUniverse2} [Field K] [CommGroup T]
+variable (p : ℕ) [Fact p.Prime] [CharP K p]
+variable (hT : ∀ t : T, t^p=1)
+def augment : MonoidAlgebra K T →ₐ[K] K := MonoidAlgebra.lift K K T 1
+lemma augment_single (t : T) (c : K) : augment (MonoidAlgebra.single t c) = c := by simp [augment]
+
+include hT in
+lemma power_scalar (a : MonoidAlgebra K T) : a^p = algebraMap K (MonoidAlgebra K T) ((augment a)^p) := by
+  let : CharP (MonoidAlgebra K T) p := CharP.of_ringHom_of_ne_zero (algebraMap K _) p (Fact.out : p.Prime).ne_zero
+  induction a using MonoidAlgebra.induction_on with
+  | of t => simp [MonoidAlgebra.of_apply,MonoidAlgebra.single_pow,hT,augment_single]
+  | add a b ha hb => rw [add_pow_char,ha,hb,map_add,add_pow_char,map_add]
+  | smul c a ha =>
+    rw [smul_pow,ha,map_smul]
+    simp only [smul_eq_mul,mul_pow,map_mul,Algebra.smul_def]
+
+include hT in
+lemma isUnit_iff (a : MonoidAlgebra K T) : IsUnit a ↔ augment a ≠ 0 := by
+  constructor
+  · intro h; exact isUnit_iff_ne_zero.mp (h.map (augment (K := K) (T := T)))
+  · intro h
+    have hp : IsUnit (a^p) := by
+      rw [power_scalar p hT]
+      exact (isUnit_iff_ne_zero.mpr (pow_ne_zero _ h)).map (algebraMap K (MonoidAlgebra K T))
+    exact (isUnit_pow_iff (Fact.out : p.Prime).ne_zero).mp hp
+
+include hT in
+lemma isLocal : IsLocalRing (MonoidAlgebra K T) := by
+  apply IsLocalRing.of_nonunits_add
+  intro a b ha hb
+  simp only [mem_nonunits_iff, isUnit_iff p hT,not_not] at ha hb ⊢
+  rw [map_add,ha,hb,add_zero]
+end
+end OddKaplansky.LocalAlgebra
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/OddKaplansky/LocalGroup.lean b/lean/OAI/Algebra/OddKaplansky/LocalGroup.lean
new file mode 100644
index 0000000000000000000000000000000000000000..c5aa0a4d2aebe037c1b79f35fb015d7ea266bba8
--- /dev/null
+++ b/lean/OAI/Algebra/OddKaplansky/LocalGroup.lean
@@ -0,0 +1,140 @@
+import OAI.Algebra.OddKaplansky.GraphEdges
+
+namespace OAI
+
+section
+noncomputable section
+open scoped Classical
+namespace OddKaplansky
+
+abbrev LocalGroup (p M : ℕ) :=
+  RegularWreathProduct (Multiplicative (ZMod M)) (Multiplicative (Fin 3 → ZMod p))
+
+namespace LocalGroup
+variable (p M : ℕ)
+abbrev Point := Fin 3 → ZMod p
+
+instance [NeZero p] [NeZero M] : Fintype (LocalGroup p M) :=
+  Fintype.ofFinite _
+
+def u : Multiplicative (Point p) →* LocalGroup p M := RegularWreathProduct.inl
+
+def c : LocalGroup p M :=
+  ⟨fun x => Multiplicative.ofAdd (if x.toAdd = 0 then 1 else 0), 1⟩
+
+def v : Multiplicative (Point p) →* LocalGroup p M :=
+  (MulAut.conj (c p M)).toMonoidHom.comp (u p M)
+
+lemma u_injective : Function.Injective (u p M) := by
+  intro x y h
+  exact congrArg RegularWreathProduct.right h
+
+lemma v_injective : Function.Injective (v p M) :=
+  (MulAut.conj (c p M)).injective.comp (u_injective p M)
+
+@[simp] lemma u_right (x : Multiplicative (Point p)) :
+    (u p M x).right = x := rfl
+@[simp] lemma v_right (x : Multiplicative (Point p)) :
+    (v p M x).right = x := by
+  simp [v, MulAut.conj_apply, c]
+
+lemma v_left_zero (x : Multiplicative (Point p)) (hx : x ≠ 1) :
+    ((v p M x).left 1).toAdd = 1 := by
+  simp [v, MulAut.conj_apply, c, u, RegularWreathProduct.inl, hx]
+
+lemma v_eq_u [NeZero M] (hM : 1 < M) (x y : Multiplicative (Point p))
+    (h : v p M x = u p M y) : x = 1 ∧ y = 1 := by
+  have hxy : x = y := by
+    have hh := congrArg RegularWreathProduct.right h
+    simpa only [v_right, u_right] using hh
+  have hx : x = 1 := by
+    by_contra hx
+    have hh := congrArg (fun z : LocalGroup p M => (z.left 1).toAdd) h
+    rw [v_left_zero p M x hx] at hh
+    change (1 : ZMod M) = 0 at hh
+    have hcast : M ∣ 1 := (ZMod.natCast_eq_zero_iff 1 M).mp (by simpa only [Nat.cast_one] using hh)
+    exact (ne_of_gt hM) (Nat.dvd_one.mp hcast)
+  exact ⟨hx, hxy.symm.trans hx⟩
+
+def direction (j : ZMod p) : Point p := ![1, j, j^2]
+
+def line (j : ZMod p) : ZMod p →+ Point p where
+  toFun a := a • direction p j
+  map_zero' := zero_smul _ _
+  map_add' _ _ := add_smul _ _ _
+
+lemma line_injective (j : ZMod p) : Function.Injective (line p j) := by
+  intro a b h
+  have hh := congrFun h 0
+  simpa [line, direction] using hh
+
+def edgeHom (outgoing : Bool) (j : ZMod p) :
+    Multiplicative (ZMod p) →* LocalGroup p M :=
+  (if outgoing then v p M else u p M).comp (line p j).toMultiplicative
+
+lemma edgeHom_injective (outgoing : Bool) (j : ZMod p) :
+    Function.Injective (edgeHom p M outgoing j) := by
+  have hline : Function.Injective (line p j).toMultiplicative := line_injective p j
+  cases outgoing with
+  | false => exact (u_injective p M).comp hline
+  | true => exact (v_injective p M).comp hline
+
+@[simp] lemma edgeHom_right (outgoing : Bool) (j : ZMod p)
+    (a : Multiplicative (ZMod p)) :
+    (edgeHom p M outgoing j a).right = Multiplicative.ofAdd (line p j a.toAdd) := by
+  cases outgoing <;> simp [edgeHom]
+
+section Independence
+variable [Fact p.Prime]
+
+lemma two_directions {x y a b : ZMod p} (hxy : x ≠ y)
+    (h : line p x a + line p y b = 0) : a = 0 := by
+  have h0 := congrFun h 0
+  have h1 := congrFun h 1
+  simp [line, direction] at h0 h1
+  have hz : a * (x-y) = 0 := by linear_combination h1 - y * h0
+  exact (mul_eq_zero.mp hz).resolve_right (sub_ne_zero.mpr hxy)
+
+lemma three_directions {x y z a b c : ZMod p} (hxy : x ≠ y) (hxz : x ≠ z)
+    (h : line p x a + line p y b + line p z c = 0) : a = 0 := by
+  have h0 := congrFun h 0
+  have h1 := congrFun h 1
+  have h2 := congrFun h 2
+  simp [line, direction] at h0 h1 h2
+  have hz : a * ((x-y)*(x-z)) = 0 := by
+    linear_combination h2 - (y+z) * h1 + y*z * h0
+  exact (mul_eq_zero.mp hz).resolve_right
+    (mul_ne_zero (sub_ne_zero.mpr hxy) (sub_ne_zero.mpr hxz))
+
+lemma edge_word_one (o : Bool) (j : ZMod p) (a : Multiplicative (ZMod p))
+    (ha : a ≠ 1) : edgeHom p M o j a ≠ 1 := by
+  intro h
+  exact ha (edgeHom_injective p M o j (h.trans (map_one _).symm))
+
+lemma edge_word_two (o₁ o₂ : Bool) (j₁ j₂ : ZMod p)
+    (a₁ a₂ : Multiplicative (ZMod p)) (ha : a₁ ≠ 1) (hj : j₁ ≠ j₂) :
+    edgeHom p M o₁ j₁ a₁ * edgeHom p M o₂ j₂ a₂ ≠ 1 := by
+  intro h
+  have hr := congrArg (fun q : LocalGroup p M => q.right.toAdd) h
+  simp only [RegularWreathProduct.mul_right, edgeHom_right, RegularWreathProduct.one_right] at hr
+  change line p j₁ a₁.toAdd + line p j₂ a₂.toAdd = 0 at hr
+  exact ha (congrArg Multiplicative.ofAdd (two_directions p hj hr))
+
+lemma edge_word_three (o₁ o₂ o₃ : Bool) (j₁ j₂ j₃ : ZMod p)
+    (a₁ a₂ a₃ : Multiplicative (ZMod p)) (ha : a₁ ≠ 1)
+    (h₁₂ : j₁ ≠ j₂) (h₁₃ : j₁ ≠ j₃) :
+    edgeHom p M o₁ j₁ a₁ * edgeHom p M o₂ j₂ a₂ * edgeHom p M o₃ j₃ a₃ ≠ 1 := by
+  intro h
+  have hr := congrArg (fun q : LocalGroup p M => q.right.toAdd) h
+  simp only [RegularWreathProduct.mul_right, edgeHom_right, RegularWreathProduct.one_right] at hr
+  change line p j₁ a₁.toAdd + line p j₂ a₂.toAdd + line p j₃ a₃.toAdd = 0 at hr
+  exact ha (congrArg Multiplicative.ofAdd (three_directions p h₁₂ h₁₃ hr))
+
+end Independence
+end LocalGroup
+end OddKaplansky
+
+end
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/OddKaplansky/Main.lean b/lean/OAI/Algebra/OddKaplansky/Main.lean
new file mode 100644
index 0000000000000000000000000000000000000000..2c7a4d935a390a27d8ffc3062673cfa19344ce71
--- /dev/null
+++ b/lean/OAI/Algebra/OddKaplansky/Main.lean
@@ -0,0 +1,110 @@
+import OAI.Algebra.OddKaplansky.SquareConstruction
+
+namespace OAI
+
+universe portUniverse1 portUniverse2
+
+section
+namespace OddKaplansky.Prescribed
+noncomputable section
+local instance prescribedDecidableEq (α : Type portUniverse1) : DecidableEq α := Classical.decEq α
+open scoped Classical BigOperators
+local notation "p" => SourceGluing.p
+local notation "M" => SourceGluing.modulus
+abbrev K := QuadraticTower.CoeffField p Construction.p_ne_two
+instance : Fact (Irreducible (QuadraticTower.polynomial (QuadraticTower.xi p Construction.p_ne_two))) :=
+  ⟨QuadraticTower.second_irreducible p Construction.p_ne_two Construction.minus_square⟩
+instance : Field K := inferInstance
+instance : Fintype K := inferInstance
+instance : CharP K p :=
+  charP_of_injective_ringHom ((algebraMap (QuadraticTower.FirstField p Construction.p_ne_two) K).comp
+    (algebraMap (ZMod p) (QuadraticTower.FirstField p Construction.p_ne_two))).injective p
+lemma card_field : Fintype.card K=p^4 := QuadraticTower.tower_card p Construction.p_ne_two
+
+def zeta : K := @FiniteChoice.primitive K inferInstance inferInstance (QuadraticTower.fieldOrder p Construction.p_ne_two)
+lemma zeta_primitive : IsPrimitiveRoot zeta M := by
+  have h := @FiniteChoice.primitive_spec K inferInstance inferInstance (QuadraticTower.fieldOrder p Construction.p_ne_two)
+  change IsPrimitiveRoot zeta (Fintype.card K-1) at h
+  rw [card_field] at h
+  simpa only [SourceGluing.modulus] using h
+lemma zeta_le (z : K) (hz : IsPrimitiveRoot z M) :
+    @LE.le K (QuadraticTower.fieldOrder p Construction.p_ne_two).toLE zeta z := by
+  apply @FiniteChoice.primitive_le K inferInstance inferInstance (QuadraticTower.fieldOrder p Construction.p_ne_two) z
+  rw [card_field]
+  simpa only [SourceGluing.modulus] using hz
+
+def localDatum : Construction.LocalDatum (K := K) := Construction.prescribedLocalDatum zeta_primitive card_field
+def rectangles : Construction.Rectangular zeta_primitive localDatum := Construction.prescribedRectangles zeta_primitive localDatum
+abbrev G := Construction.G
+def a : MonoidAlgebra K G := Construction.a zeta_primitive localDatum rectangles
+def b : MonoidAlgebra K G := Construction.b zeta_primitive localDatum rectangles
+lemma products : a*b=1 ∧ b*a≠1 := Construction.scalar_products zeta_primitive localDatum rectangles
+lemma torsion : ∃ g : G, g≠1 ∧ IsOfFinOrder g := Construction.torsion
+lemma cellular_consequences :
+    Cellular.IsCellular (Cellular.operator b) ∧ Function.Injective (Cellular.operator b) ∧
+    ¬Function.Surjective (Cellular.operator b) ∧
+    Set.range (Cellular.operator b)={y | Cellular.operator (b*a) y=y} ∧
+    ∃ h : G, (b*a-1).coeff h ≠ 0 ∧ Pi.single h 1 ∉ Set.range (Cellular.operator b) := by
+  obtain ⟨hcell,hinj,hnonsurj,hrange,h,hh,hm⟩ := Cellular.theorem_all_configurations a b products.1 products.2
+  refine ⟨hcell,hinj,hnonsurj,hrange,h,hh,?_⟩
+  have hdelta : @Pi.single G (fun _ => K) (fun _ => inferInstance) (Classical.decEq G) h 1 = (Pi.single h 1 : G → K) := by
+    funext g
+    by_cases hg : g=h <;> simp [hg]
+  rw [← hdelta]
+  exact hm
+end
+end OddKaplansky.Prescribed
+
+namespace OddKaplansky
+noncomputable section
+local instance mainEndpointDecidableEq (α : Type portUniverse2) : DecidableEq α := Classical.decEq α
+open scoped Classical
+
+def cellular {K G : Type} [Field K] [Group G]
+    (d : MonoidAlgebra K G) (x : G → K) (g : G) : K :=
+  d.coeff.sum fun u c => c * x (g * u)
+lemma cellular_eq_operator {K G : Type} [Field K] [Group G] (d : MonoidAlgebra K G) :
+    cellular d=Cellular.operator d := by
+  funext x g
+  exact (Cellular.operator_formula d x g).symm
+
+def MainClaim : Prop :=
+  sourcePrime.Prime ∧ Odd sourcePrime ∧
+  ∃ (K : Type) (_ : Field K) (_ : Fintype K) (_ : CharP K sourcePrime),
+    Fintype.card K = sourcePrime^4 ∧
+    ∃ (G : Type) (_ : Group G) (_ : Group.FG G),
+      (∃ g : G, g ≠ 1 ∧ IsOfFinOrder g) ∧
+      ∃ a b : MonoidAlgebra K G,
+        a * b = 1 ∧ b * a ≠ 1 ∧
+        Function.Injective (cellular b) ∧ ¬ Function.Surjective (cellular b)
+
+theorem main_theorem : MainClaim := by
+  let : CharP Prescribed.K sourcePrime := by rw [← SourceGluing.p_def]; infer_instance
+  refine ⟨sourcePrime_prime,sourcePrime_odd,Prescribed.K,inferInstance,inferInstance,inferInstance,?_,
+    Prescribed.G,inferInstance,inferInstance,Prescribed.torsion,Prescribed.a,Prescribed.b,
+    Prescribed.products.1,Prescribed.products.2,?_,?_⟩
+  · rw [Prescribed.card_field,SourceGluing.p_def]
+  · rw [cellular_eq_operator]
+    exact Prescribed.cellular_consequences.2.1
+  · rw [cellular_eq_operator]
+    exact Prescribed.cellular_consequences.2.2.1
+
+theorem fixed_field_transfer (K L : Type) [Field K] [Fintype K]
+    [Group L] (hK : 3 ≤ Fintype.card K) (r : ℕ) (_hr : 0 < r)
+    (A B : Matrix (Fin r) (Fin r) (MonoidAlgebra K L))
+    (hAB : A * B = 1) (hBA : B * A ≠ 1) :
+    ∃ (Λ : Type) (_ : Group Λ) (_ : Fintype Λ),
+      ∃ a b : MonoidAlgebra K (L × Λ), a * b = 1 ∧ b * a ≠ 1 := by
+  let M := Fintype.card K-1
+  have hM : 2≤M := by dsimp [M]; omega
+  let : NeZero M := ⟨by omega⟩
+  obtain ⟨ζ,hζ,hc⟩ := FixedField.finite_field_data K hK
+  refine ⟨Heisenberg.GroupData M (FixedField.leastQ M hM r),inferInstance,inferInstance,
+    FixedField.output M hM r hζ A,FixedField.output M hM r hζ B,?_⟩
+  exact FixedField.output_products M hM r hζ hc A B hAB hBA
+end
+end OddKaplansky
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/OddKaplansky/MatrixActions.lean b/lean/OAI/Algebra/OddKaplansky/MatrixActions.lean
new file mode 100644
index 0000000000000000000000000000000000000000..fb2bdb664f137de77e9728e3360f261d4098d630
--- /dev/null
+++ b/lean/OAI/Algebra/OddKaplansky/MatrixActions.lean
@@ -0,0 +1,74 @@
+import OAI.Algebra.OddKaplansky.MatrixUnits
+
+namespace OAI
+
+universe contextUniverse1 contextUniverse2
+
+universe portUniverse1 portUniverse2 portUniverse3 portUniverse4 portUniverse5 portUniverse6 portUniverse7
+
+section
+namespace OddKaplansky.MatrixActions
+noncomputable section
+open scoped Classical BigOperators Matrix
+variable {K : Type portUniverse1} {A : Type portUniverse2} {S : Type portUniverse3} [CommRing K] [Ring A] [Ring S] [Algebra K A] [Algebra K S]
+variable (φ : S →ₗ[K] A)
+def Represents (a : A) (s : S) : Prop := ∀ F : S, a * φ F = φ (s*F) ∧ φ F * a = φ (F*s)
+lemma represents_one : Represents φ 1 1 := by intro F; simp
+lemma represents_sub {a b : A} {s t : S} (ha : Represents φ a s) (hb : Represents φ b t) :
+    Represents φ (a-b) (s-t) := by
+  intro F
+  constructor
+  · rw [sub_mul,(ha F).1,(hb F).1,sub_mul,map_sub]
+  · rw [mul_sub,(ha F).2,(hb F).2,mul_sub,map_sub]
+lemma represents_mul {a b : A} {s t : S} (ha : Represents φ a s) (hb : Represents φ b t) :
+    Represents φ (a*b) (s*t) := by
+  intro F
+  constructor
+  · rw [mul_assoc,(hb F).1,(ha (t*F)).1,mul_assoc]
+  · rw [← mul_assoc,(ha F).2,(hb (F*s)).2,mul_assoc]
+lemma represents_pow {a : A} {s : S} (ha : Represents φ a s) (n : ℕ) : Represents φ (a^n) (s^n) := by
+  induction n with
+  | zero => simpa only [pow_zero] using represents_one φ
+  | succ n ih => simpa only [pow_succ] using represents_mul φ ih ha
+lemma annihilates_left {a : A} {s F : S} (ha : Represents φ a s) (hs : s*F=0) : a*φ F=0 := by rw [(ha F).1,hs,map_zero]
+lemma annihilates_right {a : A} {s F : S} (ha : Represents φ a s) (hs : F*s=0) : φ F*a=0 := by rw [(ha F).2,hs,map_zero]
+end
+end OddKaplansky.MatrixActions
+
+namespace OddKaplansky.TranslationMatrix
+noncomputable section
+open scoped Classical BigOperators Matrix
+variable {K : Type portUniverse4} {H : Type portUniverse5} [CommRing K] [Group H] [sectionInstance17 : Fintype H]
+def matrix (h : H) : Matrix H H K := fun x y => if x=h*y then 1 else 0
+lemma mul_apply (h : H) {J : Type portUniverse6} (A : Matrix H J K) (x : H) (y : J) : (matrix (K := K) h * A) x y = A (h⁻¹*x) y := by
+  rw [Matrix.mul_apply,Finset.sum_eq_single (h⁻¹*x)]
+  · simp [matrix]
+  · intro b _ hb
+    have he : x ≠ h*b := by intro he; apply hb; rw [he,inv_mul_cancel_left]
+    simp [matrix,he]
+  · simp
+lemma right_mul_apply (h : H) {J : Type portUniverse7} [Fintype J] (A : Matrix J H K) (x : J) (y : H) :
+    (A * matrix (K := K) h) x y = A x (h*y) := by simp [Matrix.mul_apply,matrix]
+lemma one
+    {K : Type contextUniverse1}
+    {H : Type contextUniverse2}
+    [CommRing.{contextUniverse1} K]
+    [Group.{contextUniverse2} H]
+    [Fintype.{contextUniverse2} H] : matrix (K := K) (H := H) 1 = 1 := by ext x y; simp [matrix,Matrix.one_apply]
+lemma mul (h g : H) : matrix (K := K) (h*g) = matrix (K := K) h * matrix (K := K) g := by
+  ext x y
+  rw [mul_apply]
+  have he : x = (h*g)*y ↔ h⁻¹*x = g*y := by
+    constructor
+    · intro hh; rw [hh]; simp only [mul_assoc,inv_mul_cancel_left]
+    · intro hh
+      calc
+        x = h*(h⁻¹*x) := (mul_inv_cancel_left h x).symm
+        _ = (h*g)*y := by rw [hh,mul_assoc]
+  simp only [matrix,he]
+end
+end OddKaplansky.TranslationMatrix
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/OddKaplansky/MatrixUnits.lean b/lean/OAI/Algebra/OddKaplansky/MatrixUnits.lean
new file mode 100644
index 0000000000000000000000000000000000000000..9ea8d2164939f2b32144ae711726c0a0a142d211
--- /dev/null
+++ b/lean/OAI/Algebra/OddKaplansky/MatrixUnits.lean
@@ -0,0 +1,82 @@
+import OAI.Algebra.OddKaplansky.FreeBlocks
+
+namespace OAI
+
+universe portUniverse1 portUniverse2 portUniverse3 portUniverse4 portUniverse5
+
+section
+namespace OddKaplansky.MatrixUnits
+noncomputable section
+open scoped Classical BigOperators Matrix
+variable {K : Type portUniverse1} {A : Type portUniverse2} {R : Type portUniverse3} {X : Type portUniverse4} {I : Type portUniverse5} [Field K] [Ring A] [Algebra K A]
+variable [Fintype R] [Fintype X] [Fintype I]
+variable (u : R × X × X → A)
+
+def lift : (R → Matrix X X K) →ₗ[K] A where
+  toFun F := ∑ a : R × X × X, F a.1 a.2.1 a.2.2 • u a
+  map_add' F G := by simp [add_smul,Finset.sum_add_distrib]
+  map_smul' c F := by simp [mul_smul,Finset.smul_sum]
+lemma lift_apply (F : R → Matrix X X K) : lift u F = ∑ r, ∑ x, ∑ y, F r x y • u (r,x,y) := by
+  simp only [lift,LinearMap.coe_mk,AddHom.coe_mk,Fintype.sum_prod_type]
+
+lemma lift_injective (hu : LinearIndependent K u) : Function.Injective (lift (K := K) u) := by
+  intro F G he
+  funext r x y
+  exact hu.eq_coords_of_eq he (r,x,y)
+
+variable (hprod : ∀ r s x y z t, u (r,x,y) * u (s,z,t) = if r = s ∧ y = z then u (r,x,t) else 0)
+include hprod in
+lemma lift_mul (F G : R → Matrix X X K) : lift u F * lift u G = lift u (fun r => F r * G r) := by
+  have hG (r : R) (x y : X) : u (r,x,y) * lift u G = ∑ t : X, G r y t • u (r,x,t) := by
+    simp [lift_apply,Finset.mul_sum,hprod,ite_and]
+  rw [lift_apply]
+  simp only [Finset.sum_mul,smul_mul_assoc,hG]
+  rw [lift_apply]
+  simp only [Finset.smul_sum,smul_smul,Matrix.mul_apply,Finset.sum_smul]
+  apply Finset.sum_congr rfl
+  intro r _
+  apply Finset.sum_congr rfl
+  intro x _
+  exact Finset.sum_comm
+
+include hprod in
+
+lemma regular_rank_bound [FiniteDimensional K A] (hu : LinearIndependent K u)
+    (B : Matrix X I K) (C : R → Matrix I X K) (hCB : ∀ r, C r * B = 1) :
+    Fintype.card R * Fintype.card I * Fintype.card X ≤
+      Module.finrank K (LinearMap.range (Algebra.lmul K A (lift u (fun r => B * C r)))) := by
+  let V : (R → Matrix I X K) →ₗ[K] A := {
+    toFun F := lift u (fun r => B * F r)
+    map_add' F G := by simp only [Pi.add_apply,Matrix.mul_add,← map_add]; rfl
+    map_smul' c F := by simp only [Pi.smul_apply,Matrix.mul_smul,← map_smul]; rfl }
+  have hV : Function.Injective V := by
+    intro F G he
+    change lift u (fun r => B*F r) = lift u (fun r => B*G r) at he
+    have hh := lift_injective u hu he
+    funext r
+    have hr := congrArg (fun f : R → Matrix X X K => C r * f r) hh
+    simpa only [← Matrix.mul_assoc,hCB,Matrix.one_mul] using hr
+  have hsub : LinearMap.range V ≤ LinearMap.range (Algebra.lmul K A (lift u (fun r => B*C r))) := by
+    rintro a ⟨F,rfl⟩
+    refine ⟨V F,?_⟩
+    change lift u (fun r => B*C r) * lift u (fun r => B*F r) = lift u (fun r => B*F r)
+    rw [lift_mul u hprod]
+    congr 1
+    funext r
+    calc
+      B*C r*(B*F r) = B*(C r*B)*F r := by simp only [Matrix.mul_assoc]
+      _ = B*F r := by rw [hCB,Matrix.mul_one]
+  have hfin := Submodule.finrank_mono hsub
+  rw [LinearMap.finrank_range_of_inj hV] at hfin
+  simpa only [Module.finrank_pi_fintype,Module.finrank_matrix,Module.finrank_self,Finset.sum_const,Finset.card_univ,nsmul_eq_mul,Nat.cast_id,mul_one,← mul_assoc] using hfin
+
+include hprod in
+lemma lift_idempotent (T : R → Matrix X X K) (hT : ∀ r, T r * T r = T r) :
+    lift u T * lift u T = lift u T := by rw [lift_mul u hprod]; congr 1; funext r; exact hT r
+
+end
+end OddKaplansky.MatrixUnits
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/OddKaplansky/ModularGeneric.lean b/lean/OAI/Algebra/OddKaplansky/ModularGeneric.lean
new file mode 100644
index 0000000000000000000000000000000000000000..21f195fe0ba11021fe0e30070745b13181838069
--- /dev/null
+++ b/lean/OAI/Algebra/OddKaplansky/ModularGeneric.lean
@@ -0,0 +1,171 @@
+import OAI.Algebra.OddKaplansky.OrbitSelection
+
+namespace OAI
+
+universe contextUniverse1 contextUniverse2 contextUniverse3 contextUniverse4
+
+universe portUniverse1 portUniverse2 portUniverse3 portUniverse4 portUniverse5
+
+section
+
+namespace OddKaplansky.WreathFourier
+noncomputable section
+open scoped Classical BigOperators Matrix
+variable {K : Type portUniverse1} {H : Type portUniverse2} {I : Type portUniverse3} [Field K] [sectionInstance27 : Fintype K] [Group H] [Fintype H] [Fintype I]
+variable (M : ℕ) [NeZero M] {ζ : K} (hζ : IsPrimitiveRoot ζ M)
+
+@[instance_reducible]
+def shiftAction : MulAction H (Base (H := H) M) where
+  smul h a := shift M h a
+  one_smul a := by change shift M 1 a = a; rw [shift_one]; rfl
+  mul_smul h g a := shift_mul M h g a
+
+def lamp : Base (H := H) M := Pi.mulSingle 1 (Multiplicative.ofAdd (1 : ZMod M))
+lemma weight_diagonal
+    {K : Type contextUniverse1}
+    {H : Type contextUniverse2}
+    [contextInstance2 : Field.{contextUniverse1} K]
+    [Fintype.{contextUniverse1} K]
+    [Group.{contextUniverse2} H]
+    [Fintype.{contextUniverse2} H]
+    (M : Nat)
+    [@NeZero.{0} Nat (@MulZeroClass.toZero.{0} Nat Nat.instMulZeroClass) M]
+    {ζ : K}
+    (hζ : @IsPrimitiveRoot.{contextUniverse1} K (@CommRing.toCommMonoid.{contextUniverse1} K (@Field.toCommRing.{contextUniverse1} K contextInstance2)) ζ M) {J : Type portUniverse4} [Fintype J] (lmb : J → Base (H := H) M) (r : J) :
+    diagonal M hζ lmb (lamp (H := H) M)⁻¹ r = Matrix.diagonal (fun x => (weight M hζ (lmb r) x : K)) := by
+  unfold diagonal
+  congr 1
+  funext x
+  simp only [map_inv,Units.val_inv_eq_inv_val,lamp,Fourier.character_mulSingle,shift_apply,mul_one,weight,Units.val_inv_eq_inv_val]
+
+namespace Blocks
+variable {R : Type portUniverse5} [Fintype R] (B : Matrix H I K) (lmb : R → Base (H := H) M)
+def weights (r : R) (x : H) : K := weight M hζ (lmb r) x
+def projection (r : R) := WeightedProjection.projection B (weights M hζ lmb r)
+def element := MatrixUnits.lift (K := K) (freeUnit M hζ lmb) (projection M hζ B lmb)
+lemma idempotent
+    {K : Type contextUniverse1}
+    {H : Type contextUniverse2}
+    {I : Type contextUniverse3}
+    [contextInstance3 : Field.{contextUniverse1} K]
+    [Fintype.{contextUniverse1} K]
+    [Group.{contextUniverse2} H]
+    [Fintype.{contextUniverse2} H]
+    [Fintype.{contextUniverse3} I]
+    (M : Nat)
+    [@NeZero.{0} Nat (@MulZeroClass.toZero.{0} Nat Nat.instMulZeroClass) M]
+    {ζ : K}
+    (hζ : @IsPrimitiveRoot.{contextUniverse1} K (@CommRing.toCommMonoid.{contextUniverse1} K (@Field.toCommRing.{contextUniverse1} K contextInstance3)) ζ M)
+    {R : Type contextUniverse4}
+    [Fintype.{contextUniverse4} R]
+    (B : Matrix.{contextUniverse2, contextUniverse3, contextUniverse1} H I K)
+    (lmb : R → @OddKaplansky.WreathFourier.Base.{contextUniverse2} H M) (hc : (Fintype.card (Base (H := H) M) : K) ≠ 0)
+    (hinj : Function.Injective (fun a : R × H => shift M a.2 (lmb a.1)))
+    (hN : ∀ r, (WeightedProjection.gram B (weights M hζ lmb r)).det ≠ 0) :
+    element M hζ B lmb * element M hζ B lmb = element M hζ B lmb := by
+  unfold element
+  apply MatrixUnits.lift_idempotent (freeUnit M hζ lmb) (freeUnit_mul M hζ hc lmb hinj) (projection M hζ B lmb)
+  intro r
+  exact WeightedProjection.idempotent B (weights M hζ lmb r) (hN r)
+lemma annihilate (ell : ℕ) (hleft : ∀ s : H, (TranslationMatrix.matrix (K := K) s - 1)^ell * B = 0)
+    (hright : ∀ s : H, B.transpose * (TranslationMatrix.matrix (K := K) s - 1)^ell = 0) (s : H) :
+    (topElt M s-1)^ell*element M hζ B lmb=0 ∧
+    element M hζ B lmb*(baseElt M (lamp (H := H) M)*topElt M s*baseElt M (lamp (H := H) M)⁻¹-1)^ell=0 := by
+  let φ := MatrixUnits.lift (K := K) (freeUnit M hζ lmb)
+  have hu := MatrixActions.represents_pow φ (MatrixActions.represents_sub φ (top_represents M hζ lmb s) (MatrixActions.represents_one φ)) ell
+  have hv := MatrixActions.represents_pow φ (MatrixActions.represents_sub φ (conjugate_represents M hζ lmb (lamp (H := H) M) s) (MatrixActions.represents_one φ)) ell
+  constructor
+  · apply MatrixActions.annihilates_left φ hu
+    funext r
+    exact WeightedProjection.annihilate_left B (weights M hζ lmb r) _ (hleft s)
+  · apply MatrixActions.annihilates_right φ hv
+    funext r
+    apply WeightedProjection.annihilate_right B (weights M hζ lmb r)
+    change B.transpose * Matrix.diagonal (fun x => (weight M hζ (lmb r) x : K)) * _ = 0
+    rw [← weight_diagonal M hζ lmb r]
+    exact WeightedProjection.conjugate_annihilate B _ _ _
+      (diagonal_inv M hζ lmb (lamp (H := H) M) r) (diagonal_inv' M hζ lmb (lamp (H := H) M) r) ell (hright s)
+lemma rank_bound
+    {K : Type contextUniverse1}
+    {H : Type contextUniverse2}
+    {I : Type contextUniverse3}
+    [contextInstance3 : Field.{contextUniverse1} K]
+    [Fintype.{contextUniverse1} K]
+    [Group.{contextUniverse2} H]
+    [Fintype.{contextUniverse2} H]
+    [Fintype.{contextUniverse3} I]
+    (M : Nat)
+    [@NeZero.{0} Nat (@MulZeroClass.toZero.{0} Nat Nat.instMulZeroClass) M]
+    {ζ : K}
+    (hζ : @IsPrimitiveRoot.{contextUniverse1} K (@CommRing.toCommMonoid.{contextUniverse1} K (@Field.toCommRing.{contextUniverse1} K contextInstance3)) ζ M)
+    {R : Type contextUniverse4}
+    [Fintype.{contextUniverse4} R]
+    (B : Matrix.{contextUniverse2, contextUniverse3, contextUniverse1} H I K)
+    (lmb : R → @OddKaplansky.WreathFourier.Base.{contextUniverse2} H M) (hc : (Fintype.card (Base (H := H) M) : K) ≠ 0)
+    (hinj : Function.Injective (fun a : R × H => shift M a.2 (lmb a.1)))
+    (hN : ∀ r, (WeightedProjection.gram B (weights M hζ lmb r)).det ≠ 0) :
+    Fintype.card R * Fintype.card I * Fintype.card H ≤
+      Module.finrank K (LinearMap.range (Algebra.lmul K _ (element M hζ B lmb))) := by
+  let C (r : R) := (WeightedProjection.gram B (weights M hζ lmb r))⁻¹ * B.transpose * Matrix.diagonal (weights M hζ lmb r)
+  have hCB (r : R) : C r * B = 1 := by
+    change (WeightedProjection.gram B _)⁻¹ * B.transpose * Matrix.diagonal _ * B = 1
+    simpa only [WeightedProjection.gram,Matrix.mul_assoc] using
+      Matrix.nonsing_inv_mul (WeightedProjection.gram B (weights M hζ lmb r)) (isUnit_iff_ne_zero.mpr (hN r))
+  have hd := MatrixUnits.regular_rank_bound (freeUnit M hζ lmb) (freeUnit_mul M hζ hc lmb hinj)
+    (freeUnit_independent M hζ hc lmb hinj) B C hCB
+  have heq : (fun r => B*C r) = projection M hζ B lmb := by
+    funext r
+    simp only [C,projection,WeightedProjection.projection,Matrix.mul_assoc]
+  rw [heq] at hd
+  exact hd
+end Blocks
+
+include hζ in
+lemma modular_idempotent (hM : Fintype.card Kˣ = M)
+    (hc : (Fintype.card (Base (H := H) M) : K) ≠ 0)
+    (B : Matrix H I K) (hB : LinearIndependent K B.col)
+    (ell : ℕ) (hleft : ∀ s : H, (TranslationMatrix.matrix (K := K) s - 1)^ell * B = 0)
+    (hright : ∀ s : H, B.transpose * (TranslationMatrix.matrix (K := K) s - 1)^ell = 0)
+    (hI : 4 * Fintype.card I < M) (hH : 4 * (Fintype.card H - 1) < M)
+    (hlarge : Fintype.card H < 48 * Fintype.card I) :
+    ∃ e : MonoidAlgebra K (Wreath (H := H) M), e*e=e ∧
+      (∀ s : H, (topElt M s-1)^ell*e=0 ∧
+        e*(baseElt M (lamp (H := H) M)*topElt M s*baseElt M (lamp (H := H) M)⁻¹-1)^ell=0) ∧
+      Fintype.card (Wreath (H := H) M) < 96 * Module.finrank K (LinearMap.range (Algebra.lmul K _ e)) := by
+  let : MulAction H (Base (H := H) M) := shiftAction M
+  let R := OrbitSelection.Rep (H := H) (Admissible M hζ B)
+  let lmb : R → Base (H := H) M := OrbitSelection.representative (Admissible M hζ B)
+  have hlmb (r : R) : Admissible M hζ B (lmb r) := (OrbitSelection.representative_spec (Admissible M hζ B) r).2
+  have hinj : Function.Injective (fun a : R × H => shift M a.2 (lmb a.1)) := by
+    apply OrbitSelection.orbit_injective (Admissible M hζ B)
+    intro a ha g hga
+    exact ha.1 g (congrFun hga)
+  have hN (r : R) : (WeightedProjection.gram B (Blocks.weights M hζ lmb r)).det ≠ 0 := (hlmb r).2
+  refine ⟨Blocks.element M hζ B lmb,Blocks.idempotent M hζ B lmb hc hinj hN,
+    Blocks.annihilate M hζ B lmb ell hleft hright,?_⟩
+  have hd := Blocks.rank_bound M hζ B lmb hc hinj hN
+  have ha := cardinality M hζ hM B hB hI hH
+  have hb := OrbitSelection.card_good (H := H) (Admissible M hζ B)
+  change Fintype.card {a // Admissible M hζ B a} ≤ Fintype.card R * Fintype.card H at hb
+  have hbase : 0 < Fintype.card (Base (H := H) M) := Fintype.card_pos
+  have hR : 0 < Fintype.card R := by nlinarith
+  have hsmall : Fintype.card (Base (H := H) M) < 96 * Fintype.card R * Fintype.card I := by
+    have hh := Nat.mul_lt_mul_of_pos_left hlarge hR
+    nlinarith
+  have hn : 0 < Fintype.card H := Fintype.card_pos
+  have hw := Nat.mul_lt_mul_of_pos_right hsmall hn
+  have hcard : Fintype.card (Wreath (H := H) M) = Fintype.card (Base (H := H) M) * Fintype.card H := by
+    rw [← Fintype.card_prod]
+    apply Fintype.card_congr
+    exact { toFun := fun g => (g.left,g.right)
+            invFun := fun z => ⟨z.1,z.2⟩
+            left_inv := fun _ => rfl
+            right_inv := fun _ => rfl }
+  rw [hcard]
+  nlinarith
+end
+end OddKaplansky.WreathFourier
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/OddKaplansky/ModularSource.lean b/lean/OAI/Algebra/OddKaplansky/ModularSource.lean
new file mode 100644
index 0000000000000000000000000000000000000000..2f9fd0ac2aa22614d6b0f644e9115d227f9d105a
--- /dev/null
+++ b/lean/OAI/Algebra/OddKaplansky/ModularSource.lean
@@ -0,0 +1,123 @@
+import OAI.Algebra.OddKaplansky.HighCount
+
+namespace OAI
+
+universe contextUniverse1
+
+universe portUniverse1 portUniverse2 portUniverse3
+
+section
+namespace OddKaplansky.Augmentation
+noncomputable section
+open scoped Classical BigOperators
+variable {K : Type portUniverse1} {E : Type portUniverse2} [Field K] [Fintype E] [DecidableEq E]
+variable (p : ℕ) [Fact p.Prime] [CharP K p]
+lemma regular_translation (s : C (E := E) p) :
+    regular (K := K) p (delta p s.toAdd) = TranslationMatrix.matrix s := by
+  ext x y
+  simp only [regular_delta,TranslationMatrix.matrix]
+  congr 1
+end
+end OddKaplansky.Augmentation
+
+namespace OddKaplansky.ModularSource
+noncomputable section
+open scoped Classical BigOperators Matrix
+variable {K : Type portUniverse3} [Field K] [sectionInstance39 : Fintype K]
+variable (p M ell : ℕ) [sectionInstance40 : Fact p.Prime] [sectionInstance41 : NeZero M] [CharP K p]
+variable {ζ : K} (hζ : IsPrimitiveRoot ζ M)
+abbrev P := Multiplicative (Fin 3 → ZMod p)
+lemma card_P : Fintype.card (P p) = p^3 := by simp [P]
+lemma base_nonzero
+    {K : Type contextUniverse1}
+    [contextInstance1 : Field.{contextUniverse1} K]
+    [Fintype.{contextUniverse1} K]
+    (p : Nat)
+    (M : Nat)
+    [Fact (Nat.Prime p)]
+    [@NeZero.{0} Nat (@MulZeroClass.toZero.{0} Nat Nat.instMulZeroClass) M]
+    [@CharP.{contextUniverse1} K
+  (@AddGroupWithOne.toAddMonoidWithOne.{contextUniverse1} K
+    (@Ring.toAddGroupWithOne.{contextUniverse1} K (@DivisionRing.toRing.{contextUniverse1} K (@Field.toDivisionRing.{contextUniverse1} K contextInstance1))))
+  p] (hM : M+1=p^4) : (Fintype.card (WreathFourier.Base (H := P p) M) : K) ≠ 0 := by
+  have hm : (M : K) ≠ 0 := by
+    have hc := congrArg (fun n : ℕ => (n : K)) hM
+    simp only [Nat.cast_add,Nat.cast_one,Nat.cast_pow,CharP.cast_eq_zero K p,zero_pow (by omega : 4≠0)] at hc
+    intro hz
+    rw [hz,zero_add] at hc
+    exact one_ne_zero hc
+  have hcard : Fintype.card (WreathFourier.Base (H := P p) M) = M^(p^3) := by simp [WreathFourier.Base,Fourier.C]
+  rw [hcard,Nat.cast_pow]
+  exact pow_ne_zero _ hm
+lemma quartic_large
+    (p : Nat)
+    (M : Nat)
+    [Fact (Nat.Prime p)]
+    [@NeZero.{0} Nat (@MulZeroClass.toZero.{0} Nat Nat.instMulZeroClass) M] (hp : 5 ≤ p) (hM : M+1=p^4) : 4*p^3 < M := by
+  have h1 : 2 ≤ p^3 := by have hh := Nat.pow_le_pow_left hp 3; norm_num at hh; omega
+  have h2 := Nat.mul_le_mul_right (p^3) hp
+  nlinarith [show p^4=p*p^3 by ring]
+lemma left_ann
+    {K : Type contextUniverse1}
+    [contextInstance1 : Field.{contextUniverse1} K]
+    [Fintype.{contextUniverse1} K]
+    (p : Nat)
+    (ell : Nat)
+    [Fact (Nat.Prime p)]
+    [@CharP.{contextUniverse1} K
+  (@AddGroupWithOne.toAddMonoidWithOne.{contextUniverse1} K
+    (@Ring.toAddGroupWithOne.{contextUniverse1} K (@DivisionRing.toRing.{contextUniverse1} K (@Field.toDivisionRing.{contextUniverse1} K contextInstance1))))
+  p]
+    : ∀ s : P p, (TranslationMatrix.matrix (K := K) s - 1)^ell * Augmentation.columns (K := K) (E := Fin 3) p ell = 0 := by
+  intro s
+  rw [← Augmentation.regular_translation (K := K) p s]
+  exact Augmentation.columns_annihilated p ell s.toAdd
+lemma right_ann
+    {K : Type contextUniverse1}
+    [contextInstance1 : Field.{contextUniverse1} K]
+    [Fintype.{contextUniverse1} K]
+    (p : Nat)
+    (ell : Nat)
+    [Fact (Nat.Prime p)]
+    [@CharP.{contextUniverse1} K
+  (@AddGroupWithOne.toAddMonoidWithOne.{contextUniverse1} K
+    (@Ring.toAddGroupWithOne.{contextUniverse1} K (@DivisionRing.toRing.{contextUniverse1} K (@Field.toDivisionRing.{contextUniverse1} K contextInstance1))))
+  p]
+    : ∀ s : P p, (Augmentation.columns (K := K) (E := Fin 3) p ell).transpose * (TranslationMatrix.matrix (K := K) s - 1)^ell = 0 := by
+  intro s
+  rw [← Augmentation.regular_translation (K := K) p s]
+  exact Augmentation.columns_transpose_annihilated p ell s.toAdd
+lemma high_small (hp : 5≤p) (hM : M+1=p^4) : 4*Fintype.card (Augmentation.High (E := Fin 3) p ell) < M := by
+  have hh := Augmentation.card_high_le p ell
+  have hm := quartic_large p M hp hM
+  omega
+lemma point_small (hp : 5≤p) (hM : M+1=p^4) : 4*(Fintype.card (P p)-1)<M := by
+  rw [card_P]
+  have hm := quartic_large p M hp hM
+  omega
+lemma high_large (hp : 5≤p) (he : p=2*ell+1) : Fintype.card (P p) < 48*Fintype.card (Augmentation.High (E := Fin 3) p ell) := by
+  rw [card_P]
+  exact Augmentation.high_ratio p ell he (by omega)
+include hζ in
+lemma exists_idempotent (hp : 5 ≤ p) (hpell : p=2*ell+1) (hM : M+1=p^4)
+    (hK : Fintype.card Kˣ = M) :
+    ∃ e : MonoidAlgebra K (WreathFourier.Wreath (H := P p) M), e*e=e ∧
+      (∀ s : P p, (WreathFourier.topElt M s-1)^ell*e=0 ∧
+        e*(WreathFourier.baseElt M (WreathFourier.lamp (H := P p) M)*WreathFourier.topElt M s*WreathFourier.baseElt M (WreathFourier.lamp (H := P p) M)⁻¹-1)^ell=0) ∧
+      Fintype.card (WreathFourier.Wreath (H := P p) M) < 96 * Module.finrank K (LinearMap.range (Algebra.lmul K _ e)) := by
+  have h := WreathFourier.modular_idempotent (K := K) (H := P p) (I := Augmentation.High (E := Fin 3) p ell) M hζ hK
+    (by simpa only [Fintype.card_eq_nat_card] using base_nonzero (K := K) p M hM)
+    (Augmentation.columns (K := K) (E := Fin 3) p ell)
+    (Augmentation.columns_independent (K := K) (E := Fin 3) p ell) ell
+    (by intro s; convert left_ann (K := K) p ell s using 1 ; congr <;> exact Subsingleton.elim _ _)
+    (by intro s; convert right_ann (K := K) p ell s using 1 ; congr <;> exact Subsingleton.elim _ _)
+    (by simpa only [Fintype.card_eq_nat_card] using high_small p M ell hp hM)
+    (by simpa only [Fintype.card_eq_nat_card] using point_small p M hp hM)
+    (by simpa only [Fintype.card_eq_nat_card] using high_large p ell hp hpell)
+  exact h
+end
+end OddKaplansky.ModularSource
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/OddKaplansky/NilpotentBasis.lean b/lean/OAI/Algebra/OddKaplansky/NilpotentBasis.lean
new file mode 100644
index 0000000000000000000000000000000000000000..6d4f95d5513f69dfa46f8501fccb6b7c023d8e96
--- /dev/null
+++ b/lean/OAI/Algebra/OddKaplansky/NilpotentBasis.lean
@@ -0,0 +1,105 @@
+import OAI.Algebra.OddKaplansky.SectorGroup
+
+namespace OAI
+
+universe contextUniverse1
+
+universe portUniverse1 portUniverse2 portUniverse3
+
+section
+namespace OddKaplansky.NilpotentBasis
+noncomputable section
+open scoped Classical BigOperators
+variable {K : Type portUniverse1} {R : Type portUniverse2} [Field K] [Ring R] [Algebra K R]
+variable (p : ℕ) (X : R) (b : Module.Basis (Fin p) K R)
+variable (hb : ∀ i : Fin p, b i = X^i.val) (hX : X^p=0)
+include hb hX in
+lemma coeff_power (n : ℕ) (j : Fin p) : b.repr (X^n) j = if n=j.val then 1 else 0 := by
+  by_cases hn : n<p
+  · rw [← hb ⟨n,hn⟩]
+    simp only [Module.Basis.repr_self,Finsupp.single_apply]
+    congr 1
+    exact propext Fin.ext_iff
+  · rw [pow_eq_zero_of_le (by omega : p≤n) hX,map_zero,Finsupp.zero_apply,ite_eq_right (by omega)]
+include hb hX in
+lemma low_coefficient (ell : ℕ) (a : R) (ha : a*X^ell=0) (i : Fin p) (hi : i.val+ell<p) :
+    b.repr a i=0 := by
+  have hh := congrArg (fun v : R => b.repr v ⟨i.val+ell,hi⟩) ha
+  rw [← b.sum_repr a,Finset.sum_mul] at hh
+  have hstep (j : Fin p) : b.repr ((b.repr a j • b j) * X^ell) ⟨i.val+ell,hi⟩ =
+      if j=i then b.repr a j else 0 := by
+    rw [hb,smul_mul_assoc,← pow_add,map_smul,Finsupp.smul_apply,coeff_power p X b hb hX]
+    simp only [Nat.add_right_cancel_iff,Fin.val_inj,smul_eq_mul,mul_ite,mul_one,mul_zero]
+  simp only [map_sum,Finset.sum_apply',hstep,map_zero,Finsupp.zero_apply,Finset.sum_ite_eq',Finset.mem_univ,ite_true] at hh
+  exact hh
+include hb hX in
+lemma right_divisible (ell : ℕ) (hell : ell≤p) (a : R) (ha : a*X^ell=0) :
+    ∃ q : R, a=q*X^(p-ell) := by
+  refine ⟨∑ i : Fin p, b.repr a i • X^(i.val-(p-ell)),?_⟩
+  rw [Finset.sum_mul]
+  conv_lhs => rw [← b.sum_repr a]
+  apply Finset.sum_congr rfl
+  intro i _
+  by_cases hi : p - ell ≤ i.val
+  · rw [smul_mul_assoc,← pow_add,Nat.sub_add_cancel hi,← hb]
+  · have hz := low_coefficient p X b hb hX ell a ha i (by omega)
+    rw [hz,zero_smul,zero_smul,zero_mul]
+end
+end OddKaplansky.NilpotentBasis
+
+namespace OddKaplansky.CyclicAlgebra
+noncomputable section
+open scoped Classical BigOperators
+variable {K : Type portUniverse3} [Field K]
+variable (p : ℕ) [Fact p.Prime] [sectionInstance69 : CharP K p]
+abbrev C := Multiplicative (ZMod p)
+abbrev R := MonoidAlgebra K (C p)
+def gen : C p := Multiplicative.ofAdd 1
+def X : R (K := K) p := MonoidAlgebra.single (gen p) 1-1
+instance : CharP (R (K := K) p) p := CharP.of_ringHom_of_ne_zero (algebraMap K _) p (Fact.out : p.Prime).ne_zero
+lemma gen_pow : gen p ^ p =1 := by apply Multiplicative.toAdd.injective; simp [gen]
+lemma nilpotent : X (K := K) p ^ p=0 := by
+  rw [X,sub_pow_char,MonoidAlgebra.single_pow,gen_pow,one_pow,one_pow,← MonoidAlgebra.one_def,sub_self]
+lemma gen_val (g : C p) : gen p ^ g.toAdd.val = g := by
+  apply Multiplicative.toAdd.injective
+  simp [gen]
+lemma delta_binomial
+    {K : Type contextUniverse1}
+    [contextInstance1 : Field.{contextUniverse1} K]
+    (p : Nat)
+    [Fact (Nat.Prime p)]
+    [@CharP.{contextUniverse1} K
+  (@AddGroupWithOne.toAddMonoidWithOne.{contextUniverse1} K
+    (@Ring.toAddGroupWithOne.{contextUniverse1} K (@DivisionRing.toRing.{contextUniverse1} K (@Field.toDivisionRing.{contextUniverse1} K contextInstance1))))
+  p] (g : C p) : MonoidAlgebra.single g (1 : K) = (X p+1)^g.toAdd.val := by
+  rw [X,sub_add_cancel,MonoidAlgebra.single_pow,one_pow,gen_val]
+lemma spanning : ⊤ ≤ Submodule.span K (Set.range (fun i : Fin p => X (K := K) p ^ i.val)) := by
+  intro a
+  have hi : a ∈ Submodule.span K (Set.range (fun i : Fin p => X (K := K) p ^ i.val)) := by
+    induction a using MonoidAlgebra.induction_on with
+    | of g =>
+      rw [MonoidAlgebra.of_apply,delta_binomial,add_pow]
+      apply Submodule.sum_mem
+      intro k hk
+      simp only [one_pow,mul_one]
+      rw [mul_comm,← nsmul_eq_mul]
+      apply (Submodule.span K (Set.range (fun i : Fin p => X (K := K) p ^ i.val))).toAddSubmonoid.nsmul_mem
+      apply Submodule.subset_span
+      exact ⟨⟨k,lt_of_le_of_lt (Nat.le_of_lt_succ (Finset.mem_range.mp hk)) (ZMod.val_lt g.toAdd)⟩,rfl⟩
+    | add a b ha hb => exact Submodule.add_mem _ ha hb
+    | smul c a ha => exact Submodule.smul_mem _ c ha
+  exact fun _ => hi
+lemma independent : LinearIndependent K (fun i : Fin p => X (K := K) p ^ i.val) := by
+  apply linearIndependent_of_top_le_span_of_card_eq_finrank (spanning p)
+  rw [Module.finrank_eq_card_basis (MonoidAlgebra.basis (C p) K)]
+  simp [C]
+def basis : Module.Basis (Fin p) K (R (K := K) p) := Module.Basis.mk (independent p) (spanning p)
+lemma basis_apply (i : Fin p) : basis (K := K) p i = X p^i.val := Module.Basis.mk_apply _ _ _
+lemma right_divisible (ell : ℕ) (hell : ell≤p) (a : R (K := K) p) (ha : a*X p^ell=0) :
+    ∃ q, a=q*X p^(p-ell) := NilpotentBasis.right_divisible p (X p) (basis p) (basis_apply p) (nilpotent p) ell hell a ha
+end
+end OddKaplansky.CyclicAlgebra
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/OddKaplansky/OrbitBlock.lean b/lean/OAI/Algebra/OddKaplansky/OrbitBlock.lean
new file mode 100644
index 0000000000000000000000000000000000000000..9f0f58e34df103ebeba3c09ae57fd1031b890101
--- /dev/null
+++ b/lean/OAI/Algebra/OddKaplansky/OrbitBlock.lean
@@ -0,0 +1,158 @@
+import OAI.Algebra.OddKaplansky.CosetMatrix
+
+namespace OAI
+
+universe portUniverse1 portUniverse2
+
+section
+namespace OddKaplansky.OrbitBlock
+noncomputable section
+open scoped Classical BigOperators Matrix
+open WreathFourier CosetCoordinates
+variable {K : Type portUniverse1} {H : Type portUniverse2} [Field K] [Group H] [Fintype H]
+variable (M : ℕ) [NeZero M] {ζ : K} (hζ : IsPrimitiveRoot ζ M)
+variable (hc : (Fintype.card (Base (H := H) M) : K) ≠ 0)
+variable (lmb : Base (H := H) M) (T : Subgroup H)
+variable (hT : ∀ g : H, g ∈ T ↔ shift M g lmb = lmb)
+include hT in
+lemma shift_eq_iff (g h : H) : shift M g lmb = shift M h lmb ↔ (g : H ⧸ T) = h := by
+  rw [QuotientGroup.eq,hT]
+  constructor
+  · intro he
+    rw [shift_mul,← he,← shift_mul,inv_mul_cancel,shift_one]
+    rfl
+  · intro he
+    have hh := congrArg (shift M g) he
+    simpa only [← shift_mul,mul_inv_cancel_left] using hh.symm
+include hT in
+lemma coset_shift (q : H ⧸ T) (t : T) : shift M (rep T q * t) lmb = shift M (rep T q) lmb := by
+  apply (shift_eq_iff M lmb T hT _ _).mpr
+  simp only [mk_rep_mul,rep_mk]
+def unit (q r : H ⧸ T) (t : T) : MonoidAlgebra K (Wreath (H := H) M) :=
+  normal M hζ (shift M (rep T q) lmb) (rep T q * t * (rep T r)⁻¹)
+include hT hc in
+lemma unit_mul (q r s z : H ⧸ T) (t u : T) :
+    unit M hζ lmb T q r t * unit M hζ lmb T s z u =
+      if r=s then unit M hζ lmb T q z (t*u) else 0 := by
+  rw [unit,unit,normal_mul M hζ hc]
+  have he : shift M (rep T q) lmb = shift M (rep T q * t * (rep T r)⁻¹) (shift M (rep T s) lmb) ↔ r=s := by
+    rw [← shift_mul,shift_eq_iff M lmb T hT]
+    constructor
+    · intro hh
+      have hm : (rep T q)⁻¹ * (rep T q * t * (rep T r)⁻¹ * rep T s) ∈ T := QuotientGroup.eq.mp hh
+      have hr : (rep T r)⁻¹ * rep T s ∈ T := by
+        have hmul := T.mul_mem (T.inv_mem t.property) hm
+        simpa only [mul_assoc,inv_mul_cancel_left,inv_mul_cancel_left] using hmul
+      have hf := QuotientGroup.eq.mpr hr
+      simpa only [rep_mk] using hf
+    · intro hrs
+      subst s
+      simp only [mul_assoc,inv_mul_cancel,mul_one,mk_rep_mul,rep_mk]
+  by_cases h : r=s
+  · rw [ite_eq_left (he.mpr h),ite_eq_left h]
+    subst s
+    simp only [unit,Subgroup.coe_mul,mul_assoc,inv_mul_cancel_left]
+  · rw [ite_eq_right (fun hh => h (he.mp hh)),ite_eq_right h]
+
+def entry (q r : H ⧸ T) : MonoidAlgebra K T →ₗ[K] MonoidAlgebra K (Wreath (H := H) M) where
+  toFun a := ∑ t : T, a.coeff t • unit M hζ lmb T q r t
+  map_add' a b := by simp [add_smul,Finset.sum_add_distrib]
+  map_smul' c a := by simp [Finset.smul_sum,smul_smul]
+lemma entry_apply (q r : H ⧸ T) (a : MonoidAlgebra K T) :
+    entry M hζ lmb T q r a = ∑ t : T, a.coeff t • unit M hζ lmb T q r t := rfl
+lemma entry_single (q r : H ⧸ T) (t : T) (c : K) :
+    entry M hζ lmb T q r (MonoidAlgebra.single t c) = c • unit M hζ lmb T q r t := by
+  rw [entry_apply]
+  simp [MonoidAlgebra.coeff_single,Finsupp.single_apply,ite_smul]
+include hT hc in
+lemma entry_mul (q r s z : H ⧸ T) (a b : MonoidAlgebra K T) :
+    entry M hζ lmb T q r a * entry M hζ lmb T s z b =
+      if r=s then entry M hζ lmb T q z (a*b) else 0 := by
+  induction a using MonoidAlgebra.induction_on with
+  | of t =>
+    induction b using MonoidAlgebra.induction_on with
+    | of u => simp only [MonoidAlgebra.of_apply,entry_single,one_smul,MonoidAlgebra.single_mul_single,one_mul,unit_mul M hζ hc lmb T hT]
+    | add b c hb hc => simp only [map_add,mul_add,hb,hc]; split_ifs <;> simp
+    | smul c b hb => simp only [map_smul,mul_smul_comm,hb]; split_ifs <;> simp
+  | add a c ha hc => simp only [map_add,add_mul,ha,hc]; split_ifs <;> simp
+  | smul c a ha => simp only [map_smul,smul_mul_assoc,ha]; split_ifs <;> simp
+
+def lift : Matrix (H ⧸ T) (H ⧸ T) (MonoidAlgebra K T) →ₗ[K] MonoidAlgebra K (Wreath (H := H) M) where
+  toFun F := ∑ q, ∑ r, entry M hζ lmb T q r (F q r)
+  map_add' F G := by simp [Finset.sum_add_distrib]
+  map_smul' c F := by simp [Finset.smul_sum]
+lemma lift_apply (F : Matrix (H ⧸ T) (H ⧸ T) (MonoidAlgebra K T)) :
+    lift M hζ lmb T F = ∑ q, ∑ r, entry M hζ lmb T q r (F q r) := rfl
+include hT hc in
+lemma entry_lift (q r : H ⧸ T) (a : MonoidAlgebra K T)
+    (G : Matrix (H ⧸ T) (H ⧸ T) (MonoidAlgebra K T)) :
+    entry M hζ lmb T q r a * lift M hζ lmb T G =
+      ∑ z, entry M hζ lmb T q z (a * G r z) := by
+  simp only [lift_apply,Finset.mul_sum,entry_mul M hζ hc lmb T hT,Finset.sum_ite_irrel,
+    Finset.sum_const_zero,Finset.sum_ite_eq,Finset.mem_univ,ite_true]
+include hT hc in
+lemma lift_mul (F G : Matrix (H ⧸ T) (H ⧸ T) (MonoidAlgebra K T)) :
+    lift M hζ lmb T F * lift M hζ lmb T G = lift M hζ lmb T (F*G) := by
+  rw [lift_apply]
+  simp only [Finset.sum_mul,entry_lift M hζ hc lmb T hT]
+  rw [lift_apply]
+  simp only [Matrix.mul_apply,map_sum]
+  apply Finset.sum_congr rfl
+  intro q _
+  exact Finset.sum_comm
+
+def identity : MonoidAlgebra K (Wreath (H := H) M) := ∑ q : H ⧸ T, projector M hζ (shift M (rep T q) lmb)
+lemma entry_one (q r : H ⧸ T) : entry M hζ lmb T q r 1 = unit M hζ lmb T q r 1 := by
+  rw [MonoidAlgebra.one_def,entry_single,one_smul]
+lemma lift_one : lift M hζ lmb T 1 = identity M hζ lmb T := by
+  simp [lift_apply,Matrix.one_apply,apply_ite,entry_one,unit,normal,identity]
+lemma unit_cocycle (g : H) (r : H ⧸ T) :
+    unit M hζ lmb T (g • r) r (CosetMatrix.cocycle T g r) =
+      normal M hζ (shift M (rep T (g • r)) lmb) g := by
+  rw [unit,CosetMatrix.cocycle_reconstruct,mul_inv_cancel_right]
+lemma lift_groupMatrix (g : H) :
+    lift M hζ lmb T (CosetMatrix.groupMatrix T g) = identity M hζ lmb T * topElt M g := by
+  rw [lift_apply,Finset.sum_comm]
+  simp only [CosetMatrix.groupMatrix,apply_ite,map_zero,Finset.sum_ite_eq',Finset.mem_univ,ite_true,
+    entry_single,one_smul,unit_cocycle]
+  rw [identity,Finset.sum_mul]
+  exact Equiv.sum_comp (MulAction.toPerm g) (fun q : H ⧸ T => normal M hζ (shift M (rep T q) lmb) g)
+lemma lift_representation (e : MonoidAlgebra K H) :
+    lift M hζ lmb T (CosetMatrix.representation T e) =
+      identity M hζ lmb T * MonoidAlgebra.mapDomainAlgHom K K (top M) e := by
+  induction e using MonoidAlgebra.induction_on with
+  | of g => simpa only [MonoidAlgebra.of_apply,CosetMatrix.representation_single,one_smul,
+      MonoidAlgebra.mapDomainAlgHom_apply,MonoidAlgebra.mapDomain_single,topElt] using lift_groupMatrix M hζ lmb T g
+  | add a b ha hb => simp only [map_add,mul_add,ha,hb]
+  | smul c a ha => simp only [map_smul,mul_smul_comm,ha]
+section Cross
+variable (mu : Base (H := H) M) (U : Subgroup H)
+variable (hsep : ∀ g : H, lmb ≠ shift M g mu)
+include hc hsep in
+lemma unit_cross (q r : H ⧸ T) (s z : H ⧸ U) (t : T) (u : U) :
+    unit M hζ lmb T q r t * unit M hζ mu U s z u = 0 := by
+  rw [unit,unit,normal_mul M hζ hc]
+  apply ite_eq_right
+  intro he
+  apply hsep ((rep T q)⁻¹ * (rep T q * t * (rep T r)⁻¹) * rep U s)
+  have hh := congrArg (shift M (rep T q)⁻¹) he
+  simpa only [← shift_mul,inv_mul_cancel,shift_one,MulEquiv.refl_apply,mul_assoc] using hh
+include hc hsep in
+lemma entry_cross (q r : H ⧸ T) (s z : H ⧸ U) (a : MonoidAlgebra K T) (b : MonoidAlgebra K U) :
+    entry M hζ lmb T q r a * entry M hζ mu U s z b = 0 := by
+  rw [entry_apply,entry_apply]
+  simp only [Finset.sum_mul,Finset.mul_sum,smul_mul_assoc,mul_smul_comm,
+    unit_cross M hζ hc lmb T mu U hsep,smul_zero,Finset.sum_const_zero]
+include hc hsep in
+lemma lift_cross (F : Matrix (H ⧸ T) (H ⧸ T) (MonoidAlgebra K T))
+    (G : Matrix (H ⧸ U) (H ⧸ U) (MonoidAlgebra K U)) :
+    lift M hζ lmb T F * lift M hζ mu U G = 0 := by
+  rw [lift_apply,lift_apply]
+  simp only [Finset.sum_mul,Finset.mul_sum,entry_cross M hζ hc lmb T mu U hsep,Finset.sum_const_zero]
+end Cross
+end
+end OddKaplansky.OrbitBlock
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/OddKaplansky/OrbitSelection.lean b/lean/OAI/Algebra/OddKaplansky/OrbitSelection.lean
new file mode 100644
index 0000000000000000000000000000000000000000..b731329eb18c18cb3cf5373b539569c8fe8f47fa
--- /dev/null
+++ b/lean/OAI/Algebra/OddKaplansky/OrbitSelection.lean
@@ -0,0 +1,64 @@
+import OAI.Algebra.OddKaplansky.WeightedProjection
+
+namespace OAI
+
+universe contextUniverse1 contextUniverse2
+
+universe portUniverse1 portUniverse2
+
+section
+namespace OddKaplansky.OrbitSelection
+noncomputable section
+open scoped Classical BigOperators
+variable {H : Type portUniverse1} {A : Type portUniverse2} [Group H] [sectionInstance25 : Fintype H] [sectionInstance26 : Fintype A] [MulAction H A]
+variable (good : A → Prop)
+abbrev Rep := {q : MulAction.orbitRel.Quotient H A // ∃ a : A, (Quotient.mk'' a : MulAction.orbitRel.Quotient H A) = q ∧ good a}
+instance : Fintype (Rep (H := H) good) := Fintype.ofFinite _
+
+def representative (r : Rep (H := H) good) : A := r.property.choose
+lemma representative_spec
+    {H : Type contextUniverse1}
+    {A : Type contextUniverse2}
+    [contextInstance2 : Group.{contextUniverse1} H]
+    [Fintype.{contextUniverse1} H]
+    [Fintype.{contextUniverse2} A]
+    [@MulAction.{contextUniverse1, contextUniverse2} H A (@DivInvMonoid.toMonoid.{contextUniverse1} H (@Group.toDivInvMonoid.{contextUniverse1} H contextInstance2))]
+    (good : A → Prop) (r : Rep (H := H) good) :
+    (Quotient.mk'' (representative good r) : MulAction.orbitRel.Quotient H A) = r.val ∧ good (representative good r) := r.property.choose_spec
+
+lemma cover (a : A) (ha : good a) : ∃ r : Rep (H := H) good, ∃ h : H, h • representative good r = a := by
+  let r : Rep (H := H) good := ⟨Quotient.mk'' a,⟨a,rfl,ha⟩⟩
+  refine ⟨r,?_⟩
+  have hh : (Quotient.mk'' a : MulAction.orbitRel.Quotient H A) = Quotient.mk'' (representative good r) :=
+    (representative_spec good r).1.symm
+  exact Quotient.exact hh
+
+lemma card_good : Fintype.card {a : A // good a} ≤ Fintype.card (Rep (H := H) good) * Fintype.card H := by
+  choose r h he using fun a : {a : A // good a} => cover (H := H) good a.val a.property
+  have hi : Function.Injective (fun a => (r a,h a)) := by
+    intro a b hab
+    apply Subtype.ext
+    rw [← he a,← he b]
+    exact congrArg (fun z : Rep (H := H) good × H => z.2 • representative good z.1) hab
+  simpa only [Fintype.card_prod] using Fintype.card_le_of_injective _ hi
+
+lemma orbit_injective (hfree : ∀ a, good a → ∀ g : H, g • a = a → g = 1) :
+    Function.Injective (fun r : Rep (H := H) good × H => r.2 • representative good r.1) := by
+  rintro ⟨r,g⟩ ⟨s,h⟩ he
+  have hrs : r = s := by
+    apply Subtype.ext
+    have hh := congrArg (Quotient.mk'' : A → MulAction.orbitRel.Quotient H A) he
+    simpa only [MulAction.orbitRel.Quotient.quotient_smul_eq,(representative_spec good r).1,(representative_spec good s).1] using hh
+  subst s
+  have hh : h⁻¹*g = 1 := by
+    apply hfree (representative good r) (representative_spec good r).2
+    simpa only [mul_smul,inv_smul_smul] using congrArg (fun a : A => h⁻¹ • a) he
+  have hgh : g = h := (inv_mul_eq_one.mp hh).symm
+  subst g
+  rfl
+end
+end OddKaplansky.OrbitSelection
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/OddKaplansky/OrderedBlocks.lean b/lean/OAI/Algebra/OddKaplansky/OrderedBlocks.lean
new file mode 100644
index 0000000000000000000000000000000000000000..3f43fc81ec83f81cee6af59cf16c04b91e26d8cd
--- /dev/null
+++ b/lean/OAI/Algebra/OddKaplansky/OrderedBlocks.lean
@@ -0,0 +1,218 @@
+import OAI.Algebra.OddKaplansky.OrderedMatrices
+
+namespace OAI
+
+universe contextUniverse1
+
+universe portUniverse1 portUniverse2
+
+section
+namespace OddKaplansky.OrderedOrbitBlock
+noncomputable section
+open scoped Classical BigOperators Matrix
+open WreathFourier OrderedCosetCoordinates
+variable {K : Type portUniverse1} {H : Type portUniverse2} [Field K] [Group H] [Fintype H] [sectionInstance62 : LinearOrder H]
+local instance orderedOrbitBlockDecidableEq : DecidableEq H := Classical.decEq H
+variable (M : ℕ) [NeZero M] {ζ : K} (hζ : IsPrimitiveRoot ζ M)
+variable (hc : (Fintype.card (Base (H := H) M) : K) ≠ 0)
+variable (lmb : Base (H := H) M) (T : Subgroup H)
+variable (hT : ∀ g : H, g ∈ T ↔ shift M g lmb = lmb)
+lemma shift_eq_iff
+    {H : Type contextUniverse1}
+    [contextInstance1 : Group.{contextUniverse1} H]
+    [Fintype.{contextUniverse1} H]
+    [LinearOrder.{contextUniverse1} H]
+    (M : Nat)
+    [@NeZero.{0} Nat (@MulZeroClass.toZero.{0} Nat Nat.instMulZeroClass) M]
+    (lmb : @OddKaplansky.WreathFourier.Base.{contextUniverse1} H M)
+    (T : @Subgroup.{contextUniverse1} H contextInstance1)
+    (hT : ∀ (g : H),
+  Iff
+    (@Membership.mem.{contextUniverse1, contextUniverse1} H (@Subgroup.{contextUniverse1} H contextInstance1)
+      (@SetLike.instMembership.{contextUniverse1, contextUniverse1} (@Subgroup.{contextUniverse1} H contextInstance1) H
+        (@Subgroup.instSetLike.{contextUniverse1} H contextInstance1))
+      T g)
+    (@Eq.{contextUniverse1 + 1} (@OddKaplansky.WreathFourier.Base.{contextUniverse1} H M)
+      (@DFunLike.coe.{contextUniverse1 + 1, contextUniverse1 + 1, contextUniverse1 + 1}
+        (@MulEquiv.{contextUniverse1, contextUniverse1} (@OddKaplansky.WreathFourier.Base.{contextUniverse1} H M) (@OddKaplansky.WreathFourier.Base.{contextUniverse1} H M)
+          (@Pi.instMul.{contextUniverse1, 0} H (fun _ => OddKaplansky.Fourier.C M) fun _ =>
+            @Multiplicative.mul.{0} (ZMod M)
+              (@Distrib.toAdd.{0} (ZMod M)
+                (@instDistribOfSemiring.{0} (ZMod M)
+                  (@CommSemiring.toSemiring.{0} (ZMod M) (@CommRing.toCommSemiring.{0} (ZMod M) (ZMod.commRing M))))))
+          (@Pi.instMul.{contextUniverse1, 0} H (fun _ => OddKaplansky.Fourier.C M) fun _ =>
+            @Multiplicative.mul.{0} (ZMod M)
+              (@Distrib.toAdd.{0} (ZMod M)
+                (@instDistribOfSemiring.{0} (ZMod M)
+                  (@CommSemiring.toSemiring.{0} (ZMod M) (@CommRing.toCommSemiring.{0} (ZMod M) (ZMod.commRing M)))))))
+        (@OddKaplansky.WreathFourier.Base.{contextUniverse1} H M) (fun _ => @OddKaplansky.WreathFourier.Base.{contextUniverse1} H M)
+        (@EquivLike.toFunLike.{contextUniverse1 + 1, contextUniverse1 + 1, contextUniverse1 + 1}
+          (@MulEquiv.{contextUniverse1, contextUniverse1} (@OddKaplansky.WreathFourier.Base.{contextUniverse1} H M)
+            (@OddKaplansky.WreathFourier.Base.{contextUniverse1} H M)
+            (@Pi.instMul.{contextUniverse1, 0} H (fun _ => OddKaplansky.Fourier.C M) fun _ =>
+              @Multiplicative.mul.{0} (ZMod M)
+                (@Distrib.toAdd.{0} (ZMod M)
+                  (@instDistribOfSemiring.{0} (ZMod M)
+                    (@CommSemiring.toSemiring.{0} (ZMod M) (@CommRing.toCommSemiring.{0} (ZMod M) (ZMod.commRing M))))))
+            (@Pi.instMul.{contextUniverse1, 0} H (fun _ => OddKaplansky.Fourier.C M) fun _ =>
+              @Multiplicative.mul.{0} (ZMod M)
+                (@Distrib.toAdd.{0} (ZMod M)
+                  (@instDistribOfSemiring.{0} (ZMod M)
+                    (@CommSemiring.toSemiring.{0} (ZMod M)
+                      (@CommRing.toCommSemiring.{0} (ZMod M) (ZMod.commRing M)))))))
+          (@OddKaplansky.WreathFourier.Base.{contextUniverse1} H M) (@OddKaplansky.WreathFourier.Base.{contextUniverse1} H M)
+          (@MulEquiv.instEquivLike.{contextUniverse1, contextUniverse1} (@OddKaplansky.WreathFourier.Base.{contextUniverse1} H M)
+            (@OddKaplansky.WreathFourier.Base.{contextUniverse1} H M)
+            (@Pi.instMul.{contextUniverse1, 0} H (fun _ => OddKaplansky.Fourier.C M) fun _ =>
+              @Multiplicative.mul.{0} (ZMod M)
+                (@Distrib.toAdd.{0} (ZMod M)
+                  (@instDistribOfSemiring.{0} (ZMod M)
+                    (@CommSemiring.toSemiring.{0} (ZMod M) (@CommRing.toCommSemiring.{0} (ZMod M) (ZMod.commRing M))))))
+            (@Pi.instMul.{contextUniverse1, 0} H (fun _ => OddKaplansky.Fourier.C M) fun _ =>
+              @Multiplicative.mul.{0} (ZMod M)
+                (@Distrib.toAdd.{0} (ZMod M)
+                  (@instDistribOfSemiring.{0} (ZMod M)
+                    (@CommSemiring.toSemiring.{0} (ZMod M)
+                      (@CommRing.toCommSemiring.{0} (ZMod M) (ZMod.commRing M))))))))
+        (@OddKaplansky.WreathFourier.shift.{contextUniverse1} H contextInstance1 M g) lmb)
+      lmb)) (g h : H) : shift M g lmb = shift M h lmb ↔ (g : H ⧸ T) = h := by
+  rw [QuotientGroup.eq,hT]
+  constructor
+  · intro he
+    rw [shift_mul,← he,← shift_mul,inv_mul_cancel,shift_one]
+    rfl
+  · intro he
+    have hh := congrArg (shift M g) he
+    simpa only [← shift_mul,mul_inv_cancel_left] using hh.symm
+include hT in
+lemma coset_shift (q : H ⧸ T) (t : T) : shift M (rep T q * t) lmb = shift M (rep T q) lmb := by
+  apply (shift_eq_iff M lmb T hT _ _).mpr
+  simp only [mk_rep_mul,rep_mk]
+def unit (q r : H ⧸ T) (t : T) : MonoidAlgebra K (Wreath (H := H) M) :=
+  normal M hζ (shift M (rep T q) lmb) (rep T q * t * (rep T r)⁻¹)
+include hT hc in
+lemma unit_mul (q r s z : H ⧸ T) (t u : T) :
+    unit M hζ lmb T q r t * unit M hζ lmb T s z u =
+      if r=s then unit M hζ lmb T q z (t*u) else 0 := by
+  rw [unit,unit,normal_mul M hζ hc]
+  have he : shift M (rep T q) lmb = shift M (rep T q * t * (rep T r)⁻¹) (shift M (rep T s) lmb) ↔ r=s := by
+    rw [← shift_mul,shift_eq_iff M lmb T hT]
+    constructor
+    · intro hh
+      have hm : (rep T q)⁻¹ * (rep T q * t * (rep T r)⁻¹ * rep T s) ∈ T := QuotientGroup.eq.mp hh
+      have hr : (rep T r)⁻¹ * rep T s ∈ T := by
+        have hmul := T.mul_mem (T.inv_mem t.property) hm
+        simpa only [mul_assoc,inv_mul_cancel_left,inv_mul_cancel_left] using hmul
+      have hf := QuotientGroup.eq.mpr hr
+      simpa only [rep_mk] using hf
+    · intro hrs
+      subst s
+      simp only [mul_assoc,inv_mul_cancel,mul_one,mk_rep_mul,rep_mk]
+  by_cases h : r=s
+  · rw [ite_eq_left (he.mpr h),ite_eq_left h]
+    subst s
+    simp only [unit,Subgroup.coe_mul,mul_assoc,inv_mul_cancel_left]
+  · rw [ite_eq_right (fun hh => h (he.mp hh)),ite_eq_right h]
+
+def entry (q r : H ⧸ T) : MonoidAlgebra K T →ₗ[K] MonoidAlgebra K (Wreath (H := H) M) where
+  toFun a := ∑ t : T, a.coeff t • unit M hζ lmb T q r t
+  map_add' a b := by simp [add_smul,Finset.sum_add_distrib]
+  map_smul' c a := by simp [Finset.smul_sum,smul_smul]
+lemma entry_apply (q r : H ⧸ T) (a : MonoidAlgebra K T) :
+    entry M hζ lmb T q r a = ∑ t : T, a.coeff t • unit M hζ lmb T q r t := rfl
+lemma entry_single (q r : H ⧸ T) (t : T) (c : K) :
+    entry M hζ lmb T q r (MonoidAlgebra.single t c) = c • unit M hζ lmb T q r t := by
+  rw [entry_apply]
+  simp [MonoidAlgebra.coeff_single,Finsupp.single_apply,ite_smul]
+include hT hc in
+lemma entry_mul (q r s z : H ⧸ T) (a b : MonoidAlgebra K T) :
+    entry M hζ lmb T q r a * entry M hζ lmb T s z b =
+      if r=s then entry M hζ lmb T q z (a*b) else 0 := by
+  induction a using MonoidAlgebra.induction_on with
+  | of t =>
+    induction b using MonoidAlgebra.induction_on with
+    | of u => simp only [MonoidAlgebra.of_apply,entry_single,one_smul,MonoidAlgebra.single_mul_single,one_mul,unit_mul M hζ hc lmb T hT]
+    | add b c hb hc => simp only [map_add,mul_add,hb,hc]; split_ifs <;> simp
+    | smul c b hb => simp only [map_smul,mul_smul_comm,hb]; split_ifs <;> simp
+  | add a c ha hc => simp only [map_add,add_mul,ha,hc]; split_ifs <;> simp
+  | smul c a ha => simp only [map_smul,smul_mul_assoc,ha]; split_ifs <;> simp
+
+def lift : Matrix (H ⧸ T) (H ⧸ T) (MonoidAlgebra K T) →ₗ[K] MonoidAlgebra K (Wreath (H := H) M) where
+  toFun F := ∑ q, ∑ r, entry M hζ lmb T q r (F q r)
+  map_add' F G := by simp [Finset.sum_add_distrib]
+  map_smul' c F := by simp [Finset.smul_sum]
+lemma lift_apply (F : Matrix (H ⧸ T) (H ⧸ T) (MonoidAlgebra K T)) :
+    lift M hζ lmb T F = ∑ q, ∑ r, entry M hζ lmb T q r (F q r) := rfl
+include hT hc in
+lemma entry_lift (q r : H ⧸ T) (a : MonoidAlgebra K T)
+    (G : Matrix (H ⧸ T) (H ⧸ T) (MonoidAlgebra K T)) :
+    entry M hζ lmb T q r a * lift M hζ lmb T G =
+      ∑ z, entry M hζ lmb T q z (a * G r z) := by
+  simp only [lift_apply,Finset.mul_sum,entry_mul M hζ hc lmb T hT,Finset.sum_ite_irrel,
+    Finset.sum_const_zero,Finset.sum_ite_eq,Finset.mem_univ,ite_true]
+include hT hc in
+lemma lift_mul (F G : Matrix (H ⧸ T) (H ⧸ T) (MonoidAlgebra K T)) :
+    lift M hζ lmb T F * lift M hζ lmb T G = lift M hζ lmb T (F*G) := by
+  rw [lift_apply]
+  simp only [Finset.sum_mul,entry_lift M hζ hc lmb T hT]
+  rw [lift_apply]
+  simp only [Matrix.mul_apply,map_sum]
+  apply Finset.sum_congr rfl
+  intro q _
+  exact Finset.sum_comm
+
+def identity : MonoidAlgebra K (Wreath (H := H) M) := ∑ q : H ⧸ T, projector M hζ (shift M (rep T q) lmb)
+lemma entry_one (q r : H ⧸ T) : entry M hζ lmb T q r 1 = unit M hζ lmb T q r 1 := by
+  rw [MonoidAlgebra.one_def,entry_single,one_smul]
+lemma lift_one : lift M hζ lmb T 1 = identity M hζ lmb T := by
+  simp [lift_apply,Matrix.one_apply,apply_ite,entry_one,unit,normal,identity]
+lemma unit_cocycle (g : H) (r : H ⧸ T) :
+    unit M hζ lmb T (g • r) r (OrderedCosetMatrix.cocycle T g r) =
+      normal M hζ (shift M (rep T (g • r)) lmb) g := by
+  rw [unit,OrderedCosetMatrix.cocycle_reconstruct,mul_inv_cancel_right]
+lemma lift_groupMatrix (g : H) :
+    lift M hζ lmb T (OrderedCosetMatrix.groupMatrix T g) = identity M hζ lmb T * topElt M g := by
+  rw [lift_apply,Finset.sum_comm]
+  simp only [OrderedCosetMatrix.groupMatrix,apply_ite,map_zero,Finset.sum_ite_eq',Finset.mem_univ,ite_true,
+    entry_single,one_smul,unit_cocycle]
+  rw [identity,Finset.sum_mul]
+  exact Equiv.sum_comp (MulAction.toPerm g) (fun q : H ⧸ T => normal M hζ (shift M (rep T q) lmb) g)
+lemma lift_representation (e : MonoidAlgebra K H) :
+    lift M hζ lmb T (OrderedCosetMatrix.representation T e) =
+      identity M hζ lmb T * MonoidAlgebra.mapDomainAlgHom K K (top M) e := by
+  induction e using MonoidAlgebra.induction_on with
+  | of g => simpa only [MonoidAlgebra.of_apply,OrderedCosetMatrix.representation_single,one_smul,
+      MonoidAlgebra.mapDomainAlgHom_apply,MonoidAlgebra.mapDomain_single,topElt] using lift_groupMatrix M hζ lmb T g
+  | add a b ha hb => simp only [map_add,mul_add,ha,hb]
+  | smul c a ha => simp only [map_smul,mul_smul_comm,ha]
+section Cross
+variable (mu : Base (H := H) M) (U : Subgroup H)
+variable (hsep : ∀ g : H, lmb ≠ shift M g mu)
+include hc hsep in
+lemma unit_cross (q r : H ⧸ T) (s z : H ⧸ U) (t : T) (u : U) :
+    unit M hζ lmb T q r t * unit M hζ mu U s z u = 0 := by
+  rw [unit,unit,normal_mul M hζ hc]
+  apply ite_eq_right
+  intro he
+  apply hsep ((rep T q)⁻¹ * (rep T q * t * (rep T r)⁻¹) * rep U s)
+  have hh := congrArg (shift M (rep T q)⁻¹) he
+  simpa only [← shift_mul,inv_mul_cancel,shift_one,MulEquiv.refl_apply,mul_assoc] using hh
+include hc hsep in
+lemma entry_cross (q r : H ⧸ T) (s z : H ⧸ U) (a : MonoidAlgebra K T) (b : MonoidAlgebra K U) :
+    entry M hζ lmb T q r a * entry M hζ mu U s z b = 0 := by
+  rw [entry_apply,entry_apply]
+  simp only [Finset.sum_mul,Finset.mul_sum,smul_mul_assoc,mul_smul_comm,
+    unit_cross M hζ hc lmb T mu U hsep,smul_zero,Finset.sum_const_zero]
+include hc hsep in
+lemma lift_cross (F : Matrix (H ⧸ T) (H ⧸ T) (MonoidAlgebra K T))
+    (G : Matrix (H ⧸ U) (H ⧸ U) (MonoidAlgebra K U)) :
+    lift M hζ lmb T F * lift M hζ mu U G = 0 := by
+  rw [lift_apply,lift_apply]
+  simp only [Finset.sum_mul,Finset.mul_sum,entry_cross M hζ hc lmb T mu U hsep,Finset.sum_const_zero]
+end Cross
+end
+end OddKaplansky.OrderedOrbitBlock
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/OddKaplansky/OrderedCoordinates.lean b/lean/OAI/Algebra/OddKaplansky/OrderedCoordinates.lean
new file mode 100644
index 0000000000000000000000000000000000000000..d8de0bdba50d2e6d02abc7aac3ef2c7a40b71540
--- /dev/null
+++ b/lean/OAI/Algebra/OddKaplansky/OrderedCoordinates.lean
@@ -0,0 +1,78 @@
+import OAI.Algebra.OddKaplansky.OrderedGroup
+
+namespace OAI
+
+universe portUniverse1 portUniverse2 portUniverse3
+
+section
+namespace OddKaplansky.OrderedCosetCoordinates
+noncomputable section
+open scoped Classical BigOperators
+variable {G : Type portUniverse1} [Group G] [Fintype G] [LinearOrder G] (S : Subgroup G)
+local instance orderedCoordinatesDecidableEq : DecidableEq G := Classical.decEq G
+def rep (q : G ⧸ S) : G := FiniteChoice.first (fun g : G => (g : G ⧸ S)=q) ⟨q.out,Quotient.out_eq' q⟩
+lemma rep_mk (q : G ⧸ S) : ((rep S q : G) : G ⧸ S) = q := by
+  unfold rep
+  exact FiniteChoice.first_spec (fun g : G => (g : G ⧸ S)=q) ⟨q.out,Quotient.out_eq' q⟩
+lemma rep_le (q : G ⧸ S) (g : G) (hg : (g : G ⧸ S)=q) : rep S q ≤ g := FiniteChoice.first_le _ _ g hg
+lemma rep_injective : Function.Injective (rep S) := by
+  intro q r h
+  simpa only [rep_mk] using congrArg (fun g : G => (g : G ⧸ S)) h
+@[instance_reducible]
+def quotientOrder : LinearOrder (G ⧸ S) := LinearOrder.lift' (rep S) (rep_injective S)
+lemma residue_mem (g : G) : (rep S (g : G ⧸ S))⁻¹*g ∈ S :=
+  QuotientGroup.eq.mp (rep_mk S (g : G ⧸ S))
+def residue (g : G) : S := ⟨_,residue_mem S g⟩
+lemma reconstruct (g : G) : rep S (g : G ⧸ S) * residue S g = g := by simp [residue]
+lemma mk_rep_mul (q : G ⧸ S) (s : S) : ((rep S q * (s : G) : G) : G ⧸ S) = q := by
+  rw [QuotientGroup.mk_mul_of_mem _ s.property,rep_mk]
+lemma residue_rep_mul (q : G ⧸ S) (s : S) : residue S (rep S q * s) = s := by
+  apply Subtype.ext
+  simp only [residue,mk_rep_mul]
+  exact inv_mul_cancel_left _ _
+def equiv : G ≃ (G ⧸ S) × S where
+  toFun g := ((g : G ⧸ S),residue S g)
+  invFun z := rep S z.1 * z.2
+  left_inv := reconstruct S
+  right_inv z := by ext <;> simp only [mk_rep_mul,residue_rep_mul]
+lemma equiv_symm_apply (q : G ⧸ S) (s : S) : (equiv S).symm (q,s) = rep S q * s := rfl
+
+lemma sum_right_invariant {A : Type portUniverse2} [AddCommMonoid A] (a : G → A)
+    (ha : ∀ (s : S) (g : G), a (g*s) = a g) :
+    ∑ g : G, a g = Fintype.card S • ∑ q : G ⧸ S, a (rep S q) := by
+  rw [← Equiv.sum_comp (equiv S).symm a]
+  simp only [Fintype.sum_prod_type,equiv_symm_apply,ha,Finset.sum_const,Finset.card_univ,← Finset.smul_sum]
+lemma sum_left_invariant {A : Type portUniverse3} [AddCommMonoid A] (a : G → A)
+    (ha : ∀ (s : S) (g : G), a (s*g) = a g) :
+    ∑ g : G, a g = Fintype.card S • ∑ q : G ⧸ S, a (rep S q)⁻¹ := by
+  have hh := sum_right_invariant S (fun g => a g⁻¹) (fun s g => by simpa only [mul_inv_rev,Subgroup.coe_inv] using ha s⁻¹ g⁻¹)
+  have hi : (∑ g : G, a g⁻¹) = ∑ g : G, a g := Equiv.sum_comp (Equiv.inv G) a
+  rw [hi] at hh
+  exact hh
+lemma coprime_order_of_sum (M : ℕ) (a : G → ZMod M) (hsum : ∑ g, a g = 1)
+    (g : G) (hfix : ∀ x, a (g*x) = a x) : Nat.Coprime (orderOf g) M := by
+  have hf : ∀ (s : Subgroup.zpowers g) (x : G), a (s*x) = a x := by
+    intro s x
+    obtain ⟨n,hn⟩ := s.property
+    rw [← hn]
+    have hnat (n : ℕ) : ∀ x, a (g^n*x)=a x := by
+      induction n with
+      | zero => intro x; simp
+      | succ n ih => intro x; rw [pow_succ',mul_assoc,hfix,ih]
+    cases n with
+    | ofNat n => simpa only [Int.ofNat_eq_natCast,zpow_natCast] using hnat n x
+    | negSucc n =>
+      have h := hnat (n+1) ((g^(n+1))⁻¹ * x)
+      simpa only [zpow_negSucc,← mul_assoc,mul_inv_cancel,one_mul] using h.symm
+  have h := sum_left_invariant (Subgroup.zpowers g) a hf
+  rw [hsum,Fintype.card_zpowers,nsmul_eq_mul] at h
+  exact (ZMod.isUnit_iff_coprime _ _).mp (IsUnit.of_mul_eq_one _ h.symm)
+lemma eq_one_of_power_and_sum (M : ℕ) (a : G → ZMod M) (hsum : ∑ g, a g = 1)
+    (g : G) (hfix : ∀ x, a (g*x) = a x) (hpow : g^M=1) : g=1 :=
+  orderOf_eq_one_iff.mp ((coprime_order_of_sum M a hsum g hfix).eq_one_of_dvd (orderOf_dvd_of_pow_eq_one hpow))
+end
+end OddKaplansky.OrderedCosetCoordinates
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/OddKaplansky/OrderedGroup.lean b/lean/OAI/Algebra/OddKaplansky/OrderedGroup.lean
new file mode 100644
index 0000000000000000000000000000000000000000..331042d176ef7d82f19601bdfb5118a502ef0696
--- /dev/null
+++ b/lean/OAI/Algebra/OddKaplansky/OrderedGroup.lean
@@ -0,0 +1,29 @@
+import OAI.Algebra.OddKaplansky.GreedyFormula
+
+namespace OAI
+
+universe portUniverse1
+
+section
+namespace OddKaplansky.SourceOrders
+noncomputable section
+open scoped Classical
+variable {H : Type portUniverse1} [Group H] [Fintype H] [LinearOrder H]
+@[instance_reducible]
+def wreathOrder (M : ℕ) [NeZero M] : LinearOrder (WreathFourier.Wreath (H := H) M) := by
+  letI : LinearOrder (Fourier.C M) := cyclic M
+  letI : LinearOrder (WreathFourier.Base (H := H) M) := FiniteChoice.functionOrder H (Fourier.C M)
+  exact LinearOrder.lift' (fun g : WreathFourier.Wreath (H := H) M => toLex (g.left,g.right)) (by
+    intro a b h
+    have h' : (a.left,a.right)=(b.left,b.right) := h
+    exact RegularWreathProduct.ext (congrArg Prod.fst h') (congrArg Prod.snd h'))
+instance localGroupOrder (p M : ℕ) [NeZero p] [NeZero M] : LinearOrder (RegularWreathProduct (Fourier.C M) (Multiplicative (Fin 3 → ZMod p))) :=
+  by
+    letI : LinearOrder (Multiplicative (Fin 3 → ZMod p)) := point p
+    exact wreathOrder M
+end
+end OddKaplansky.SourceOrders
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/OddKaplansky/OrderedMatrices.lean b/lean/OAI/Algebra/OddKaplansky/OrderedMatrices.lean
new file mode 100644
index 0000000000000000000000000000000000000000..023f910643c9cd811e87ed0226ae983db8bb2503
--- /dev/null
+++ b/lean/OAI/Algebra/OddKaplansky/OrderedMatrices.lean
@@ -0,0 +1,146 @@
+import OAI.Algebra.OddKaplansky.OrderedCoordinates
+
+namespace OAI
+
+universe contextUniverse1
+
+universe portUniverse1 portUniverse2 portUniverse3
+
+section
+namespace OddKaplansky.OrderedCosetMatrix
+noncomputable section
+open scoped Classical BigOperators Matrix
+variable {K : Type portUniverse1} {G : Type portUniverse2} [Field K] [Group G] [sectionInstance60 : Fintype G] [sectionInstance61 : LinearOrder G] (T : Subgroup G)
+local instance orderedMatrixDecidableEq : DecidableEq G := Classical.decEq G
+abbrev Q := G ⧸ T
+abbrev D := MonoidAlgebra K T
+open OrderedCosetCoordinates
+lemma mk_left
+    {G : Type contextUniverse1}
+    [contextInstance1 : Group.{contextUniverse1} G]
+    [Fintype.{contextUniverse1} G]
+    [LinearOrder.{contextUniverse1} G]
+    (T : @Subgroup.{contextUniverse1} G contextInstance1) (g h : G) : ((g*h : G) : G ⧸ T) = g • (h : G ⧸ T) := rfl
+lemma mk_mul_rep (g : G) (q : G ⧸ T) : ((g*rep T q : G) : G ⧸ T) = g • q := by rw [mk_left,rep_mk]
+def cocycle (g : G) (q : G ⧸ T) : T := residue T (g * rep T q)
+lemma cocycle_reconstruct (g : G) (q : G ⧸ T) : rep T (g • q) * (cocycle T g q : G) = g*rep T q := by
+  simpa only [cocycle,mk_mul_rep] using reconstruct T (g*rep T q)
+lemma cocycle_one (q : G ⧸ T) : cocycle T 1 q = 1 := by
+  apply Subtype.ext
+  simp [cocycle,residue,rep_mk]
+lemma cocycle_mul (g h : G) (q : G ⧸ T) : cocycle T (g*h) q = cocycle T g (h • q) * cocycle T h q := by
+  apply Subtype.ext
+  apply mul_left_cancel (a := rep T ((g*h) • q))
+  rw [cocycle_reconstruct,Subgroup.coe_mul,mul_smul,← mul_assoc,cocycle_reconstruct]
+  simp only [mul_assoc,cocycle_reconstruct]
+
+def groupMatrix (g : G) : Matrix (G ⧸ T) (G ⧸ T) (D (K := K) T) := fun q r =>
+  if q = g • r then MonoidAlgebra.single (cocycle T g r) 1 else 0
+lemma groupMatrix_one : groupMatrix (K := K) T 1 = 1 := by
+  funext q r
+  simp [groupMatrix,Matrix.one_apply,cocycle_one,MonoidAlgebra.one_def]
+lemma groupMatrix_mul (g h : G) : groupMatrix (K := K) T (g*h) = groupMatrix T g * groupMatrix T h := by
+  ext q r
+  rw [Matrix.mul_apply,Finset.sum_eq_single (h • r)]
+  · simp only [groupMatrix,ite_true,ite_mul,zero_mul,      MonoidAlgebra.single_mul_single,one_mul,cocycle_mul,mul_smul]
+  · intro z _ hz
+    simp [groupMatrix,hz]
+  · simp
+def representation : MonoidAlgebra K G →ₐ[K] Matrix (G ⧸ T) (G ⧸ T) (D (K := K) T) :=
+  MonoidAlgebra.lift K _ G { toFun := groupMatrix T, map_one' := groupMatrix_one T, map_mul' := groupMatrix_mul T }
+lemma representation_single (g : G) (c : K) : representation T (MonoidAlgebra.single g c) = c • groupMatrix T g := by
+  simp [representation]
+
+def coefficients {X : Type portUniverse3} [Finite X] : MonoidAlgebra K X ≃ₗ[K] (X → K) :=
+  (MonoidAlgebra.coeffLinearEquiv K).trans (Finsupp.linearEquivFunOnFinite K K X)
+def unpack : ((G ⧸ T) → D (K := K) T) ≃ₗ[K] MonoidAlgebra K G :=
+  (LinearEquiv.piCongrRight (fun _ : G ⧸ T => coefficients)).trans
+    ((LinearEquiv.curry K K (G ⧸ T) T).symm.trans
+      ((LinearEquiv.piCongrLeft K (fun _ : (G ⧸ T) × T => K) (equiv T)).symm.trans coefficients.symm))
+lemma unpack_coeff (v : (G ⧸ T) → D (K := K) T) (g : G) :
+    (unpack T v).coeff g = (v (g : G ⧸ T)).coeff (residue T g) := rfl
+lemma unpack_symm_coeff (v : MonoidAlgebra K G) (q : G ⧸ T) (t : T) :
+    ((unpack T).symm v q).coeff t = v.coeff (rep T q * t) := by
+  have h := unpack_coeff T ((unpack T).symm v) (rep T q * t)
+  rw [LinearEquiv.apply_symm_apply,mk_rep_mul,residue_rep_mul] at h
+  exact h.symm
+lemma unpack_basis (q : G ⧸ T) (t : T) :
+    unpack (K := K) T (Pi.single q (MonoidAlgebra.single t 1)) = MonoidAlgebra.single (rep T q * t) 1 := by
+  apply (unpack T).symm.injective
+  rw [LinearEquiv.symm_apply_apply]
+  funext r
+  apply MonoidAlgebra.coeff_injective
+  ext s
+  rw [unpack_symm_coeff]
+  by_cases h : r=q
+  · subst r
+    simp [MonoidAlgebra.coeff_single,Finsupp.single_apply]
+  · have hn : rep T r*(s : G) ≠ rep T q*(t : G) := by
+      intro he
+      have hq := congrArg (fun g : G => (g : G ⧸ T)) he
+      rw [mk_rep_mul,mk_rep_mul] at hq
+      exact h hq
+    simp [Pi.single_eq_of_ne h,MonoidAlgebra.coeff_single,hn]
+lemma residue_left (g x : G) : residue T (g*x) = cocycle T g (x : G ⧸ T) * residue T x := by
+  apply Subtype.ext
+  apply mul_left_cancel (a := rep T ((g*x : G) : G ⧸ T))
+  rw [reconstruct,Subgroup.coe_mul,mk_left,← mul_assoc,cocycle_reconstruct,mul_assoc,reconstruct]
+lemma groupMatrix_mulVec (g : G) (v : (G ⧸ T) → D (K := K) T) (q : G ⧸ T) :
+    (groupMatrix T g).mulVec v q = MonoidAlgebra.single (cocycle T g (g⁻¹ • q)) 1 * v (g⁻¹ • q) := by
+  rw [Matrix.mulVec, dotProduct,Finset.sum_eq_single (g⁻¹ • q)]
+  · simp [groupMatrix]
+  · intro r _ hr
+    have hne : q ≠ g • r := by
+      intro he
+      apply hr
+      rw [he,inv_smul_smul]
+    simp [groupMatrix,hne]
+  · simp
+lemma unpack_group (g : G) (v : (G ⧸ T) → D (K := K) T) :
+    unpack T ((groupMatrix T g).mulVec v) = MonoidAlgebra.single g 1 * unpack T v := by
+  apply MonoidAlgebra.coeff_injective
+  ext x
+  rw [unpack_coeff,groupMatrix_mulVec,MonoidAlgebra.coeff_single_mul_apply,
+    MonoidAlgebra.coeff_single_mul_apply,unpack_coeff,one_mul,one_mul]
+  have hq : ((g⁻¹*x : G) : G ⧸ T) = g⁻¹ • (x : G ⧸ T) := rfl
+  have hr := residue_left T g (g⁻¹*x)
+  simp only [mul_inv_cancel_left,hq] at hr
+  rw [hq,hr,inv_mul_cancel_left]
+lemma unpack_representation (e : MonoidAlgebra K G) (v : (G ⧸ T) → D (K := K) T) :
+    unpack T ((representation T e).mulVec v) = e * unpack T v := by
+  induction e using MonoidAlgebra.induction_on with
+  | of g => simpa only [MonoidAlgebra.of_apply,representation_single,one_smul] using unpack_group T g v
+  | add e f he hf => simp only [map_add,Matrix.add_mulVec,he,hf,add_mul]
+  | smul c e he => simp only [map_smul,Matrix.smul_mulVec,map_smul,he,smul_mul_assoc]
+
+section Commutative
+variable [IsMulCommutative T]
+local instance orderedMatrixCommGroup : CommGroup T := { (inferInstance : Group T) with mul_comm := mul_comm' }
+def endomorphism (e : MonoidAlgebra K G) : Module.End (D (K := K) T) ((G ⧸ T) → D (K := K) T) :=
+  Matrix.toLin' (representation T e)
+lemma endomorphism_idempotent (e : MonoidAlgebra K G) (he : e*e=e) :
+    endomorphism T e * endomorphism T e = endomorphism T e := by
+  change (Matrix.toLin' (representation T e)).comp (Matrix.toLin' (representation T e)) = Matrix.toLin' (representation T e)
+  rw [← Matrix.toLin'_mul,← map_mul,he]
+lemma endomorphism_rank (e : MonoidAlgebra K G) :
+    Module.finrank K (LinearMap.range (endomorphism T e)) =
+      Module.finrank K (LinearMap.range (Algebra.lmul K (MonoidAlgebra K G) e)) := by
+  have ht : (unpack (K := K) T).toLinearMap.comp ((endomorphism T e).restrictScalars K) =
+      (Algebra.lmul K (MonoidAlgebra K G) e).comp (unpack T).toLinearMap := by
+    apply LinearMap.ext
+    intro v
+    exact unpack_representation T e v
+  have hr := congrArg LinearMap.range ht
+  rw [LinearMap.range_comp,LinearMap.range_comp,LinearEquiv.range,Submodule.map_top] at hr
+  have hd := LinearEquiv.finrank_map_eq (unpack (K := K) T) (LinearMap.range ((endomorphism T e).restrictScalars K))
+  rw [hr] at hd
+  rw [LinearMap.range_restrictScalars] at hd
+  have hx := ((Submodule.restrictScalarsEquiv K (D (K := K) T) _ (LinearMap.range (endomorphism T e))).restrictScalars K).finrank_eq
+  exact hx.symm.trans hd.symm
+end Commutative
+end
+end OddKaplansky.OrderedCosetMatrix
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/OddKaplansky/OrderedModular.lean b/lean/OAI/Algebra/OddKaplansky/OrderedModular.lean
new file mode 100644
index 0000000000000000000000000000000000000000..113c88b643a9d08e6ee40519d9923762827d3d8b
--- /dev/null
+++ b/lean/OAI/Algebra/OddKaplansky/OrderedModular.lean
@@ -0,0 +1,159 @@
+import OAI.Algebra.OddKaplansky.ModularSource
+
+namespace OAI
+
+universe contextUniverse1 contextUniverse2
+
+universe portUniverse1 portUniverse2 portUniverse3 portUniverse4 portUniverse5 portUniverse6
+
+section
+namespace OddKaplansky.SourceOrders
+noncomputable section
+open scoped Classical
+@[instance_reducible]
+def cyclic (M : ℕ) [NeZero M] : LinearOrder (Fourier.C M) :=
+  @FiniteChoice.multiplicativeOrder (ZMod M) (FiniteChoice.residueOrder M)
+@[instance_reducible]
+def point (p : ℕ) [NeZero p] : LinearOrder (Multiplicative (Fin 3 → ZMod p)) :=
+  @FiniteChoice.multiplicativeOrder (Fin 3 → ZMod p)
+    (@FiniteChoice.functionOrder (Fin 3) (ZMod p) inferInstance inferInstance (FiniteChoice.residueOrder p))
+@[instance_reducible]
+def character (p M : ℕ) [NeZero p] [NeZero M] :
+    LinearOrder (WreathFourier.Base (H := Multiplicative (Fin 3 → ZMod p)) M) :=
+  @FiniteChoice.functionOrder _ _ inferInstance (point p) (cyclic M)
+end
+end OddKaplansky.SourceOrders
+
+namespace OddKaplansky.OrbitSelection.Ordered
+noncomputable section
+open scoped Classical BigOperators
+variable {H : Type portUniverse1} {A : Type portUniverse2} [Group H] [sectionInstance42 : Fintype H] [Fintype A] [MulAction H A]
+variable (order : LinearOrder A) (good : A → Prop)
+def representative (r : Rep (H := H) good) : A :=
+  @FiniteChoice.first A inferInstance order
+    (fun a : A => (Quotient.mk'' a : MulAction.orbitRel.Quotient H A)=r.val ∧ good a) r.property
+lemma representative_spec
+    {H : Type contextUniverse1}
+    {A : Type contextUniverse2}
+    [contextInstance2 : Group.{contextUniverse1} H]
+    [Fintype.{contextUniverse1} H]
+    [Fintype.{contextUniverse2} A]
+    [@MulAction.{contextUniverse1, contextUniverse2} H A (@DivInvMonoid.toMonoid.{contextUniverse1} H (@Group.toDivInvMonoid.{contextUniverse1} H contextInstance2))]
+    (order : LinearOrder.{contextUniverse2} A)
+    (good : A → Prop) (r : Rep (H := H) good) :
+    (Quotient.mk'' (representative order good r) : MulAction.orbitRel.Quotient H A) = r.val ∧ good (representative order good r) := by
+  exact @FiniteChoice.first_spec A inferInstance order
+    (fun a : A => (Quotient.mk'' a : MulAction.orbitRel.Quotient H A)=r.val ∧ good a) r.property
+lemma representative_le
+    {H : Type contextUniverse1}
+    {A : Type contextUniverse2}
+    [contextInstance2 : Group.{contextUniverse1} H]
+    [Fintype.{contextUniverse1} H]
+    [Fintype.{contextUniverse2} A]
+    [@MulAction.{contextUniverse1, contextUniverse2} H A (@DivInvMonoid.toMonoid.{contextUniverse1} H (@Group.toDivInvMonoid.{contextUniverse1} H contextInstance2))]
+    (order : LinearOrder.{contextUniverse2} A)
+    (good : A → Prop) (r : Rep (H := H) good) (a : A)
+    (he : (Quotient.mk'' a : MulAction.orbitRel.Quotient H A)=r.val) (ha : good a) :
+    @LE.le A order.toLE (representative order good r) a :=
+  @FiniteChoice.first_le A inferInstance order _ r.property a ⟨he,ha⟩
+lemma orbit_injective (hfree : ∀ a, good a → ∀ g : H, g • a = a → g = 1) :
+    Function.Injective (fun r : Rep (H := H) good × H => r.2 • representative order good r.1) := by
+  rintro ⟨r,g⟩ ⟨s,h⟩ he
+  have hrs : r = s := by
+    apply Subtype.ext
+    have hh := congrArg (Quotient.mk'' : A → MulAction.orbitRel.Quotient H A) he
+    simpa only [MulAction.orbitRel.Quotient.quotient_smul_eq,(representative_spec order good r).1,(representative_spec order good s).1] using hh
+  subst s
+  have hh : h⁻¹*g = 1 := by
+    apply hfree (representative order good r) (representative_spec order good r).2
+    simpa only [mul_smul,inv_smul_smul] using congrArg (fun a : A => h⁻¹ • a) he
+  have hgh : g = h := (inv_mul_eq_one.mp hh).symm
+  subst g
+  rfl
+end
+end OddKaplansky.OrbitSelection.Ordered
+
+namespace OddKaplansky.WreathFourier
+noncomputable section
+open scoped Classical BigOperators Matrix
+variable {K : Type portUniverse3} {H : Type portUniverse4} {I : Type portUniverse5} [Field K] [Fintype K] [Group H] [Fintype H] [Fintype I]
+variable (M : ℕ) [NeZero M] {ζ : K} (hζ : IsPrimitiveRoot ζ M)
+variable (order : LinearOrder (Base (H := H) M)) (B : Matrix H I K)
+
+def modularElement : MonoidAlgebra K (Wreath (H := H) M) := by
+  letI : MulAction H (Base (H := H) M) := shiftAction M
+  exact Blocks.element M hζ B (OrbitSelection.Ordered.representative (H := H) order (Admissible M hζ B))
+lemma modularElement_properties (hM : Fintype.card Kˣ = M)
+    (hc : (Fintype.card (Base (H := H) M) : K) ≠ 0) (hB : LinearIndependent K B.col)
+    (ell : ℕ) (hleft : ∀ s : H, (TranslationMatrix.matrix (K := K) s - 1)^ell * B = 0)
+    (hright : ∀ s : H, B.transpose * (TranslationMatrix.matrix (K := K) s - 1)^ell = 0)
+    (hI : 4 * Fintype.card I < M) (hH : 4 * (Fintype.card H - 1) < M)
+    (hlarge : Fintype.card H < 48 * Fintype.card I) :
+    modularElement M hζ order B*modularElement M hζ order B=modularElement M hζ order B ∧
+      (∀ s : H, (topElt M s-1)^ell*modularElement M hζ order B=0 ∧
+        modularElement M hζ order B*(baseElt M (lamp (H := H) M)*topElt M s*baseElt M (lamp (H := H) M)⁻¹-1)^ell=0) ∧
+      Fintype.card (Wreath (H := H) M) < 96 * Module.finrank K (LinearMap.range (Algebra.lmul K _ (modularElement M hζ order B))) := by
+  let : MulAction H (Base (H := H) M) := shiftAction M
+  let R := OrbitSelection.Rep (H := H) (Admissible M hζ B)
+  let lmb : R → Base (H := H) M := OrbitSelection.Ordered.representative (H := H) order (Admissible M hζ B)
+  have hlmb (r : R) : Admissible M hζ B (lmb r) := (OrbitSelection.Ordered.representative_spec order (Admissible M hζ B) r).2
+  have hinj : Function.Injective (fun a : R × H => shift M a.2 (lmb a.1)) := by
+    apply OrbitSelection.Ordered.orbit_injective order (Admissible M hζ B)
+    intro a ha g hga
+    exact ha.1 g (congrFun hga)
+  have hN (r : R) : (WeightedProjection.gram B (Blocks.weights M hζ lmb r)).det ≠ 0 := (hlmb r).2
+  change Blocks.element M hζ B lmb*Blocks.element M hζ B lmb=Blocks.element M hζ B lmb ∧ _
+  refine ⟨Blocks.idempotent M hζ B lmb hc hinj hN,Blocks.annihilate M hζ B lmb ell hleft hright,?_⟩
+  have hd := Blocks.rank_bound M hζ B lmb hc hinj hN
+  have ha := cardinality M hζ hM B hB hI hH
+  have hb := OrbitSelection.card_good (H := H) (Admissible M hζ B)
+  change Fintype.card {a // Admissible M hζ B a} ≤ Fintype.card R * Fintype.card H at hb
+  have hbase : 0 < Fintype.card (Base (H := H) M) := Fintype.card_pos
+  have hR : 0 < Fintype.card R := by nlinarith
+  have hsmall : Fintype.card (Base (H := H) M) < 96 * Fintype.card R * Fintype.card I := by
+    have hh := Nat.mul_lt_mul_of_pos_left hlarge hR
+    nlinarith
+  have hn : 0 < Fintype.card H := Fintype.card_pos
+  have hw := Nat.mul_lt_mul_of_pos_right hsmall hn
+  have hcard : Fintype.card (Wreath (H := H) M) = Fintype.card (Base (H := H) M) * Fintype.card H := by
+    rw [← Fintype.card_prod]
+    apply Fintype.card_congr
+    exact { toFun := fun g => (g.left,g.right)
+            invFun := fun z => ⟨z.1,z.2⟩
+            left_inv := fun _ => rfl
+            right_inv := fun _ => rfl }
+  rw [hcard]
+  change Fintype.card (Base (H := H) M)*Fintype.card H<96*Module.finrank K (LinearMap.range (Algebra.lmul K _ (Blocks.element M hζ B lmb)))
+  nlinarith
+end
+end OddKaplansky.WreathFourier
+
+namespace OddKaplansky.ModularSource
+noncomputable section
+open scoped Classical BigOperators Matrix
+variable {K : Type portUniverse6} [Field K] [Fintype K]
+variable (p M ell : ℕ) [Fact p.Prime] [NeZero M] [CharP K p]
+variable {ζ : K} (hζ : IsPrimitiveRoot ζ M)
+def explicitElement : MonoidAlgebra K (WreathFourier.Wreath (H := P p) M) :=
+  WreathFourier.modularElement M hζ (SourceOrders.character p M) (Augmentation.columns (K := K) (E := Fin 3) p ell)
+lemma explicit_properties (hp : 5 ≤ p) (hpell : p=2*ell+1) (hM : M+1=p^4)
+    (hK : Fintype.card Kˣ = M) :
+    explicitElement p M ell hζ*explicitElement p M ell hζ=explicitElement p M ell hζ ∧
+      (∀ s : P p, (WreathFourier.topElt M s-1)^ell*explicitElement p M ell hζ=0 ∧
+        explicitElement p M ell hζ*(WreathFourier.baseElt M (WreathFourier.lamp (H := P p) M)*WreathFourier.topElt M s*WreathFourier.baseElt M (WreathFourier.lamp (H := P p) M)⁻¹-1)^ell=0) ∧
+      Fintype.card (WreathFourier.Wreath (H := P p) M) < 96 * Module.finrank K (LinearMap.range (Algebra.lmul K _ (explicitElement p M ell hζ))) := by
+  apply WreathFourier.modularElement_properties M hζ (SourceOrders.character p M)
+    (Augmentation.columns (K := K) (E := Fin 3) p ell) hK
+    (by simpa only [Fintype.card_eq_nat_card] using base_nonzero (K := K) p M hM)
+    (Augmentation.columns_independent (K := K) (E := Fin 3) p ell) ell
+    (by intro s; convert left_ann (K := K) p ell s using 1 ; congr <;> exact Subsingleton.elim _ _)
+    (by intro s; convert right_ann (K := K) p ell s using 1 ; congr <;> exact Subsingleton.elim _ _)
+    (by simpa only [Fintype.card_eq_nat_card] using high_small p M ell hp hM)
+    (by simpa only [Fintype.card_eq_nat_card] using point_small p M hp hM)
+    (by simpa only [Fintype.card_eq_nat_card] using high_large p ell hp hpell)
+end
+end OddKaplansky.ModularSource
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/OddKaplansky/OrderedOrbits.lean b/lean/OAI/Algebra/OddKaplansky/OrderedOrbits.lean
new file mode 100644
index 0000000000000000000000000000000000000000..450deca3f745ea4ef2a853f388af773ce78aae65
--- /dev/null
+++ b/lean/OAI/Algebra/OddKaplansky/OrderedOrbits.lean
@@ -0,0 +1,112 @@
+import OAI.Algebra.OddKaplansky.OrderedBlocks
+
+namespace OAI
+
+universe portUniverse1 portUniverse2
+
+section
+namespace OddKaplansky.OrderedSectorOrbit
+noncomputable section
+open scoped Classical BigOperators Matrix
+open WreathFourier OrderedCosetCoordinates
+variable {K : Type portUniverse1} {H : Type portUniverse2} [Field K] [Group H] [Fintype H] [LinearOrder H]
+local instance orderedOrbitDecidableEq : DecidableEq H := Classical.decEq H
+variable (M : ℕ) [NeZero M] {ζ : K} (hζ : IsPrimitiveRoot ζ M)
+@[instance_reducible]
+def action : MulAction H (Base (H := H) M) where
+  smul g a := shift M g a
+  one_smul a := by change shift M 1 a=a; rw [shift_one]; rfl
+  mul_smul g h a := shift_mul M g h a
+local instance : MulAction H (Base (H := H) M) := action M
+abbrev Rep := OrbitSelection.Rep (H := H) (fun a : Base (H := H) M => SectorFourier.weight M a=1)
+@[instance_reducible]
+def characterOrder : LinearOrder (Base (H := H) M) := @FiniteChoice.functionOrder H (Fourier.C M) inferInstance inferInstance (SourceOrders.cyclic M)
+def lmb (r : Rep (H := H) M) : Base (H := H) M := OrbitSelection.Ordered.representative (H := H) (characterOrder M) _ r
+lemma lmb_spec (r : Rep (H := H) M) :
+    (Quotient.mk'' (lmb M r) : MulAction.orbitRel.Quotient H (Base (H := H) M))=r.val ∧ SectorFourier.weight M (lmb M r)=1 :=
+  OrbitSelection.Ordered.representative_spec (characterOrder M) _ r
+lemma cover (a : Base (H := H) M) (ha : SectorFourier.weight M a=1) : ∃ r : Rep (H := H) M, ∃ h : H, shift M h (lmb M r)=a := by
+  let r : Rep (H := H) M := ⟨Quotient.mk'' a,⟨a,rfl,ha⟩⟩
+  refine ⟨r,?_⟩
+  have hh : (Quotient.mk'' a : MulAction.orbitRel.Quotient H (Base (H := H) M))=Quotient.mk'' (lmb M r) := (lmb_spec M r).1.symm
+  exact Quotient.exact hh
+lemma lmb_weight (r : Rep (H := H) M) : SectorFourier.weight M (lmb M r)=1 := (lmb_spec M r).2
+def T (r : Rep (H := H) M) : Subgroup H := MulAction.stabilizer H (lmb M r)
+lemma mem_T (r : Rep (H := H) M) (g : H) : g ∈ T M r ↔ shift M g (lmb M r)=lmb M r := Iff.rfl
+lemma separate {r s : Rep (H := H) M} (hrs : r≠s) (g : H) : lmb M r ≠ shift M g (lmb M s) := by
+  intro he
+  apply hrs
+  apply Subtype.ext
+  have hh : (Quotient.mk'' (lmb M r) : MulAction.orbitRel.Quotient H (Base (H := H) M)) = Quotient.mk'' (lmb M s) :=
+    Quotient.sound ⟨g,he.symm⟩
+  exact (lmb_spec M r).1.symm.trans (hh.trans (lmb_spec M s).1)
+def orbitMap (z : (r : Rep (H := H) M) × (H ⧸ T M r)) :
+    {a : Base (H := H) M // SectorFourier.weight M a=1} :=
+  ⟨shift M (rep (T M z.1) z.2) (lmb M z.1), (SectorFourier.weight_shift M _ _).trans (lmb_weight M _)⟩
+lemma orbitMap_injective : Function.Injective (orbitMap (H := H) M) := by
+  rintro ⟨r,q⟩ ⟨s,t⟩ he
+  have hv := congrArg Subtype.val he
+  have hrs : r=s := by
+    by_contra hn
+    apply separate M hn ((rep (T M r) q)⁻¹ * rep (T M s) t)
+    have hh := congrArg (shift M (rep (T M r) q)⁻¹) hv
+    simpa only [orbitMap,← shift_mul,inv_mul_cancel,shift_one,MulEquiv.refl_apply] using hh
+  subst s
+  have hqt := (OrderedOrbitBlock.shift_eq_iff M (lmb M r) (T M r) (mem_T M r) _ _).mp hv
+  rw [rep_mk,rep_mk] at hqt
+  exact Sigma.mk.inj_iff.mpr ⟨rfl,heq_of_eq hqt⟩
+lemma orbitMap_surjective : Function.Surjective (orbitMap (H := H) M) := by
+  intro a
+  obtain ⟨r,g,hg⟩ := cover M a.val a.property
+  have hg' : shift M g (lmb M r)=a.val := hg
+  refine ⟨⟨r,(g : H ⧸ T M r)⟩,?_⟩
+  apply Subtype.ext
+  change shift M (rep (T M r) (g : H ⧸ T M r)) (lmb M r)=a.val
+  rw [← hg']
+  exact (OrderedOrbitBlock.shift_eq_iff M (lmb M r) (T M r) (mem_T M r) _ _).mpr (rep_mk _ _)
+def orbitEquiv : ((r : Rep (H := H) M) × (H ⧸ T M r)) ≃
+    {a : Base (H := H) M // SectorFourier.weight M a=1} :=
+  Equiv.ofBijective (orbitMap M) ⟨orbitMap_injective M,orbitMap_surjective M⟩
+lemma identity_sum (hc : (Fintype.card (Base (H := H) M) : K) ≠ 0)
+    (hm : (Fintype.card (Fourier.C M) : K) ≠ 0) :
+    ∑ r : Rep (H := H) M, OrderedOrbitBlock.identity M hζ (lmb M r) (T M r) = SectorFourier.f M hζ := by
+  apply Eq.trans ?_ (SectorFourier.f_eq_packet (H := H) M hζ hc hm).symm
+  have hh := Equiv.sum_comp (orbitEquiv (H := H) M) (fun a => projector M hζ a.val)
+  change (∑ z : (r : Rep (H := H) M) × (H ⧸ T M r), projector M hζ (shift M (rep (T M z.1) z.2) (lmb M z.1))) = _ at hh
+  simpa only [Fintype.sum_sigma,OrderedOrbitBlock.identity] using hh
+
+variable (hc : (Fintype.card (Base (H := H) M) : K) ≠ 0)
+abbrev Block (r : Rep (H := H) M) := Matrix (H ⧸ T M r) (H ⧸ T M r) (MonoidAlgebra K (T M r))
+def pack : ((r : Rep (H := H) M) → Block (K := K) M r) →ₗ[K] MonoidAlgebra K (Wreath (H := H) M) where
+  toFun F := ∑ r, OrderedOrbitBlock.lift M hζ (lmb M r) (T M r) (F r)
+  map_add' F G := by simp only [Pi.add_apply,map_add,Finset.sum_add_distrib]
+  map_smul' c F := by simp only [Pi.smul_apply,map_smul,RingHom.id_apply,Finset.smul_sum]
+lemma pack_apply (F : (r : Rep (H := H) M) → Block (K := K) M r) :
+    pack M hζ F = ∑ r, OrderedOrbitBlock.lift M hζ (lmb M r) (T M r) (F r) := rfl
+include hc in
+lemma pack_mul (F G : (r : Rep (H := H) M) → Block (K := K) M r) :
+    pack M hζ F * pack M hζ G = pack M hζ (fun r => F r*G r) := by
+  rw [pack_apply,pack_apply,Finset.sum_mul,pack_apply]
+  apply Finset.sum_congr rfl
+  intro r _
+  rw [Finset.mul_sum,Finset.sum_eq_single r]
+  · exact OrderedOrbitBlock.lift_mul M hζ hc (lmb M r) (T M r) (mem_T M r) (F r) (G r)
+  · intro s _ hsr
+    exact OrderedOrbitBlock.lift_cross M hζ hc (lmb M r) (T M r) (lmb M s) (T M s) (separate M hsr.symm) (F r) (G s)
+  · simp
+include hc in
+lemma pack_one (hm : (Fintype.card (Fourier.C M) : K) ≠ 0) :
+    pack (H := H) M hζ (fun _ => 1) = SectorFourier.f M hζ := by
+  simp only [pack_apply,OrderedOrbitBlock.lift_one]
+  exact identity_sum M hζ hc hm
+include hc in
+lemma pack_representation (e : MonoidAlgebra K H) (hm : (Fintype.card (Fourier.C M) : K) ≠ 0) :
+    pack M hζ (fun r => OrderedCosetMatrix.representation (T M r) e) =
+      SectorFourier.f M hζ * MonoidAlgebra.mapDomainAlgHom K K (top M) e := by
+  simp only [pack_apply,OrderedOrbitBlock.lift_representation,← Finset.sum_mul,identity_sum M hζ hc hm]
+end
+end OddKaplansky.OrderedSectorOrbit
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/OddKaplansky/OrderedRectangles.lean b/lean/OAI/Algebra/OddKaplansky/OrderedRectangles.lean
new file mode 100644
index 0000000000000000000000000000000000000000..ffc6ff7555cac1b6152bd10a92ddf340fa1a5731
--- /dev/null
+++ b/lean/OAI/Algebra/OddKaplansky/OrderedRectangles.lean
@@ -0,0 +1,49 @@
+import OAI.Algebra.OddKaplansky.OrderedOrbits
+
+namespace OAI
+
+universe portUniverse1 portUniverse2 portUniverse3 portUniverse4 portUniverse5 portUniverse6 portUniverse7 portUniverse8
+
+section
+namespace OddKaplansky.OrderedSectorOrbit
+noncomputable section
+open scoped Classical BigOperators Matrix
+open WreathFourier
+variable {K : Type portUniverse1} {H : Type portUniverse2} [Field K] [Group H] [Fintype H] [LinearOrder H]
+local instance orderedSectorRectangularDecidableEq : DecidableEq H := Classical.decEq H
+variable (M : ℕ) [NeZero M] {ζ : K} (hζ : IsPrimitiveRoot ζ M)
+variable (hc : (Fintype.card (Base (H := H) M) : K) ≠ 0)
+variable (hm : (Fintype.card (Fourier.C M) : K) ≠ 0)
+def matrixPack {W : Type portUniverse3} {N : Type portUniverse4} (F : (r : Rep (H := H) M) → Matrix W N (Block (K := K) M r)) :
+    Matrix W N (MonoidAlgebra K (Wreath (H := H) M)) := fun w n => pack M hζ (fun r => F r w n)
+include hc in
+lemma matrixPack_mul {W : Type portUniverse5} {N : Type portUniverse6} {V : Type portUniverse7} [Fintype N]
+    (F : (r : Rep (H := H) M) → Matrix W N (Block (K := K) M r))
+    (G : (r : Rep (H := H) M) → Matrix N V (Block (K := K) M r)) :
+    matrixPack M hζ F * matrixPack M hζ G = matrixPack M hζ (fun r => F r*G r) := by
+  funext w v
+  simp only [Matrix.mul_apply,matrixPack,pack_mul M hζ hc]
+  rw [← map_sum]
+  congr 1
+  funext r
+  simp only [Finset.sum_apply,]
+include hc hm in
+lemma matrixPack_one {N : Type portUniverse8} [DecidableEq N] :
+    matrixPack (H := H) M hζ (fun _ => (1 : Matrix N N _)) = Matrix.diagonal (fun _ : N => SectorFourier.f M hζ) := by
+  funext n n'
+  simp only [matrixPack,Matrix.one_apply,Matrix.diagonal_apply]
+  by_cases h : n=n'
+  · simp only [h,ite_true,pack_one M hζ hc hm]
+  · simp only [ite_eq_right h]
+    exact map_zero _
+include hc hm in
+lemma pack_left_sector (F : (r : Rep (H := H) M) → Block (K := K) M r) :
+    SectorFourier.f M hζ * pack M hζ F = pack M hζ F := by
+  rw [← pack_one M hζ hc hm,pack_mul M hζ hc]
+  simp only [one_mul]
+end
+end OddKaplansky.OrderedSectorOrbit
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/OddKaplansky/OrderedZero.lean b/lean/OAI/Algebra/OddKaplansky/OrderedZero.lean
new file mode 100644
index 0000000000000000000000000000000000000000..e48d4a4e784363ec0f9ffddfb3e6e34af0f4c38f
--- /dev/null
+++ b/lean/OAI/Algebra/OddKaplansky/OrderedZero.lean
@@ -0,0 +1,39 @@
+import OAI.Algebra.OddKaplansky.CyclicCoset
+
+namespace OAI
+
+universe portUniverse1 portUniverse2 portUniverse3 portUniverse4
+
+section
+namespace OddKaplansky.OrderedZero
+noncomputable section
+open scoped Classical BigOperators
+variable {K : Type portUniverse1} {A : Type portUniverse2} {B : Type portUniverse3} {G : Type portUniverse4} [Field K] [Group A] [Group B] [Group G] [Fintype A]
+variable (p ell : ℕ) [Fact p.Prime] [CharP K p]
+lemma product_zero (hell : ell ≤ p-ell)
+    (i : CyclicAlgebra.C p →* A) (hi : Function.Injective i)
+    (j : CyclicAlgebra.C p →* B) (φ : A →* G) (ψ : B →* G)
+    (hij : φ (i (CyclicAlgebra.gen p)) = ψ (j (CyclicAlgebra.gen p)))
+    (a : MonoidAlgebra K A) (b : MonoidAlgebra K B)
+    (ha : a*(MonoidAlgebra.single (i (CyclicAlgebra.gen p)) 1-1)^ell=0)
+    (hb : (MonoidAlgebra.single (j (CyclicAlgebra.gen p)) 1-1)^ell*b=0) :
+    MonoidAlgebra.mapDomainAlgHom K K φ a * MonoidAlgebra.mapDomainAlgHom K K ψ b=0 := by
+  let Φ := MonoidAlgebra.mapDomainAlgHom K K φ
+  let Ψ := MonoidAlgebra.mapDomainAlgHom K K ψ
+  let X : MonoidAlgebra K G := MonoidAlgebra.single (φ (i (CyclicAlgebra.gen p))) 1-1
+  obtain ⟨c,hc⟩ := CyclicAlgebra.embedded_right_divisible p i hi ell (by omega) a ha
+  have hm : Φ (MonoidAlgebra.single (i (CyclicAlgebra.gen p)) 1-1)=X := by rw [map_sub,map_one]; simp only [Φ,X,MonoidAlgebra.mapDomainAlgHom_apply,MonoidAlgebra.mapDomain_single]
+  have hn : Ψ (MonoidAlgebra.single (j (CyclicAlgebra.gen p)) 1-1)=X := by rw [map_sub,map_one]; simp only [Ψ,X,MonoidAlgebra.mapDomainAlgHom_apply,MonoidAlgebra.mapDomain_single,hij]
+  have hb' : X^ell*Ψ b=0 := by
+    have hh := congrArg Ψ hb
+    simpa only [map_mul,map_pow,hn,map_zero] using hh
+  change Φ a*Ψ b=0
+  rw [hc,map_mul,map_pow,hm,mul_assoc]
+  have hp : p-ell = (p-ell-ell)+ell := by omega
+  rw [hp,pow_add,mul_assoc,hb',mul_zero,mul_zero]
+end
+end OddKaplansky.OrderedZero
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/OddKaplansky/Parameters.lean b/lean/OAI/Algebra/OddKaplansky/Parameters.lean
new file mode 100644
index 0000000000000000000000000000000000000000..eab3ad75c261ca49767483bce2e99e4b3cb9edcf
--- /dev/null
+++ b/lean/OAI/Algebra/OddKaplansky/Parameters.lean
@@ -0,0 +1,59 @@
+import Mathlib
+
+namespace OAI
+
+section
+namespace OddKaplansky
+
+@[irreducible] def sourceM : ℕ := Nat.choose 1200 600
+@[irreducible] def sourcePrime : ℕ := Nat.minFac ((Nat.factorial sourceM)^2 + 1)
+
+lemma sourceM_large : 1200 ≤ sourceM := by
+  have h := Nat.choose_le_middle 1 1200
+  rw [Nat.choose_one_right, show 1200 / 2 = 600 from rfl] at h
+  unfold sourceM
+  exact h
+
+lemma sourcePrime_prime : sourcePrime.Prime := by
+  unfold sourcePrime
+  apply Nat.minFac_prime
+  have := Nat.factorial_pos sourceM
+  have := pow_pos this 2
+  omega
+
+lemma sourcePrime_dvd : sourcePrime ∣ (Nat.factorial sourceM)^2 + 1 :=
+  by unfold sourcePrime; exact Nat.minFac_dvd _
+
+lemma sourcePrime_gt : sourceM < sourcePrime := by
+  by_contra h
+  have hd := Nat.dvd_factorial sourcePrime_prime.pos (Nat.le_of_not_gt h)
+  have hsq : sourcePrime ∣ (Nat.factorial sourceM)^2 :=
+    dvd_pow hd (by decide : 2 ≠ 0)
+  have : sourcePrime ∣ 1 := (Nat.dvd_add_iff_right hsq).mpr sourcePrime_dvd
+  exact sourcePrime_prime.not_dvd_one this
+
+lemma sourcePrime_odd : Odd sourcePrime :=
+  sourcePrime_prime.odd_of_ne_two (by have := sourcePrime_gt; have := sourceM_large; omega)
+
+lemma sourcePrime_minimal (n : ℕ) (hn : 1 < n)
+    (hd : n ∣ (Nat.factorial sourceM)^2 + 1) : sourcePrime ≤ n :=
+  by unfold sourcePrime; exact Nat.minFac_le_of_dvd hn hd
+
+instance sourcePrime_fact : Fact sourcePrime.Prime := ⟨sourcePrime_prime⟩
+
+lemma neg_one_isSquare_of_dvd (p n : ℕ) [Fact p.Prime] (h : p ∣ n^2+1) :
+    IsSquare (-1 : ZMod p) := by
+  refine ⟨(n : ZMod p), ?_⟩
+  have hz : (((n^2+1 : ℕ) : ZMod p)) = 0 :=
+    (ZMod.natCast_eq_zero_iff _ _).mpr h
+  push_cast at hz
+  linear_combination -hz
+
+lemma neg_one_isSquare : IsSquare (-1 : ZMod sourcePrime) :=
+  neg_one_isSquare_of_dvd sourcePrime (Nat.factorial sourceM) sourcePrime_dvd
+
+end OddKaplansky
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/OddKaplansky/PolynomialGrid.lean b/lean/OAI/Algebra/OddKaplansky/PolynomialGrid.lean
new file mode 100644
index 0000000000000000000000000000000000000000..1881f8c3c0e1d5d2dc2ea44a62912115c4a83938
--- /dev/null
+++ b/lean/OAI/Algebra/OddKaplansky/PolynomialGrid.lean
@@ -0,0 +1,71 @@
+import OAI.Algebra.OddKaplansky.WeightedGram
+
+namespace OAI
+
+universe portUniverse1 portUniverse2
+
+section
+namespace OddKaplansky.PolynomialGrid
+noncomputable section
+open scoped Classical BigOperators
+variable {K : Type portUniverse1} [Field K] [Fintype K] [DecidableEq K]
+
+lemma card_units_zero_le (n : ℕ) (P : MvPolynomial (Fin n) K) (hP : P ≠ 0) :
+    Fintype.card {f : Fin n → Kˣ // MvPolynomial.eval (fun i => (f i : K)) P = 0} * Fintype.card Kˣ ≤
+      P.totalDegree * Fintype.card Kˣ ^ n := by
+  let S : Finset K := Finset.univ.erase 0
+  let Z := {f ∈ Fintype.piFinset (fun _ : Fin n => S) | MvPolynomial.eval f P = 0}
+  have hS : S.card = Fintype.card Kˣ := by
+    simp only [S,Finset.card_erase_of_mem (Finset.mem_univ (0 : K)),Finset.card_univ]
+    exact (Fintype.card_units (α := K)).symm
+  let e : {f : Fin n → Kˣ // MvPolynomial.eval (fun i => (f i : K)) P = 0} ≃ Z := {
+    toFun := fun f => ⟨fun i => (f.val i : K), by
+      apply Finset.mem_filter.mpr
+      constructor
+      · apply Fintype.mem_piFinset.mpr
+        intro i
+        simp only [S, Finset.mem_erase,Finset.mem_univ,and_true]
+        exact Units.ne_zero _
+      · exact f.property⟩
+    invFun := fun f => ⟨fun i => Units.mk0 (f.val i) (by
+      have h := (Fintype.mem_piFinset.mp (Finset.mem_filter.mp f.property).1) i
+      exact (Finset.mem_erase.mp h).1), (Finset.mem_filter.mp f.property).2⟩
+    left_inv := fun f => by ext i; rfl
+    right_inv := fun f => rfl }
+  have hz : Fintype.card {f : Fin n → Kˣ // MvPolynomial.eval (fun i => (f i : K)) P = 0} = Z.card :=
+    (Fintype.card_congr e).trans (Fintype.card_coe Z)
+  have hs := MvPolynomial.schwartz_zippel_totalDegree hP S
+  change (Z.card : ℚ≥0)/(S.card : ℚ≥0)^n ≤ (P.totalDegree : ℚ≥0)/S.card at hs
+  have hp : (0 : ℚ≥0) < S.card := by rw [hS]; exact_mod_cast Fintype.card_pos (α := Kˣ)
+  have hm := (div_le_div_iff₀ (pow_pos hp n) hp).mp hs
+  rw [hz,← hS]
+  exact_mod_cast hm
+
+lemma card_units_zero_le_general {X : Type portUniverse2} [Fintype X] (P : MvPolynomial X K) (hP : P ≠ 0) :
+    Fintype.card {f : X → Kˣ // MvPolynomial.eval (fun i => (f i : K)) P = 0} * Fintype.card Kˣ ≤
+      P.totalDegree * Fintype.card Kˣ ^ Fintype.card X := by
+  let e := Fintype.equivFin X
+  let Q := MvPolynomial.rename e P
+  have hQ : Q ≠ 0 := by
+    intro h
+    apply hP
+    apply MvPolynomial.rename_injective e e.injective
+    simpa only [map_zero] using h
+  let E : {f : X → Kˣ // MvPolynomial.eval (fun i => (f i : K)) P = 0} ≃
+      {f : Fin (Fintype.card X) → Kˣ // MvPolynomial.eval (fun i => (f i : K)) Q = 0} := {
+    toFun := fun f => ⟨fun i => f.val (e.symm i),by
+      simpa only [Q,MvPolynomial.eval_rename,Function.comp_def,Equiv.symm_apply_apply] using f.property⟩
+    invFun := fun f => ⟨fun i => f.val (e i),by
+      simpa only [Q,MvPolynomial.eval_rename,Function.comp_def] using f.property⟩
+    left_inv := fun f => by ext i; simp only [Equiv.symm_apply_apply]
+    right_inv := fun f => by ext i; simp only [Equiv.apply_symm_apply] }
+  have h := card_units_zero_le (Fintype.card X) Q hQ
+  rw [← Fintype.card_congr E] at h
+  exact h.trans (Nat.mul_le_mul_right _ (MvPolynomial.totalDegree_rename_le e P))
+
+end
+end OddKaplansky.PolynomialGrid
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/OddKaplansky/PrescribedGreedy.lean b/lean/OAI/Algebra/OddKaplansky/PrescribedGreedy.lean
new file mode 100644
index 0000000000000000000000000000000000000000..9a09886fc4ba9a369a45fe2bf7df055e90fe96d0
--- /dev/null
+++ b/lean/OAI/Algebra/OddKaplansky/PrescribedGreedy.lean
@@ -0,0 +1,40 @@
+import OAI.Algebra.OddKaplansky.SectorGreedy
+
+namespace OAI
+
+universe portUniverse1 portUniverse2 portUniverse3
+
+section
+namespace OddKaplansky.OrderedSourceSector
+noncomputable section
+local instance orderedSourceDecidableEq (α : Type portUniverse1) : DecidableEq α := Classical.decEq α
+open scoped Classical BigOperators Matrix
+open WreathFourier OrderedSectorOrbit
+variable {K : Type} [Field K] (M p : ℕ) [NeZero M] [Fact p.Prime] [CharP K p]
+local instance : DecidableEq (SectorStabilizer.H M p) := Classical.decEq _
+variable {ζ : K} (hζ : IsPrimitiveRoot ζ M)
+lemma stabilizer_comm (r : Rep (H := SectorStabilizer.H M p) M) : ∀ s t : T M r, s*t=t*s := by
+  rw [T_leftFixed]
+  exact SectorStabilizer.commutative M p (fun x => (lmb M r x).toAdd) (lmb_weight M r)
+lemma stabilizer_exp (r : Rep (H := SectorStabilizer.H M p) M) : ∀ t : T M r, t^p=1 := by
+  rw [T_leftFixed]
+  exact SectorStabilizer.exponent M p (fun x => (lmb M r x).toAdd) (lmb_weight M r)
+variable (e : MonoidAlgebra K (SectorStabilizer.H M p)) (he : e*e=e)
+variable {W : Type portUniverse2} {N : Type portUniverse3} [Fintype W] [LinearOrder W] [Fintype N] [LinearOrder N]
+variable (hw : Fintype.card W=Fintype.card (SectorStabilizer.H M p))
+variable (hn : Fintype.card N=Module.finrank K (LinearMap.range (Algebra.lmul K _ e)))
+def explicitJ := OrderedSectorOrbit.explicitJ M hζ p (stabilizer_comm M p) (stabilizer_exp M p) e he hw hn
+def explicitY := OrderedSectorOrbit.explicitY M hζ p (stabilizer_comm M p) (stabilizer_exp M p) e he hw hn
+lemma explicit_properties (hc : (Fintype.card (Base (H := SectorStabilizer.H M p) M) : K) ≠ 0)
+    (hm : (Fintype.card (Fourier.C M) : K) ≠ 0) :
+    explicitY M p hζ e he hw hn*explicitJ M p hζ e he hw hn=Matrix.diagonal (fun _ => SectorFourier.f M hζ) ∧
+    explicitJ M p hζ e he hw hn*explicitY M p hζ e he hw hn=Matrix.diagonal (fun _ => SectorFourier.f M hζ * MonoidAlgebra.mapDomainAlgHom K K (top M) e) ∧
+    (∀ w n, SectorFourier.f M hζ * explicitJ M p hζ e he hw hn w n=explicitJ M p hζ e he hw hn w n) ∧
+    (∀ n w, SectorFourier.f M hζ * explicitY M p hζ e he hw hn n w=explicitY M p hζ e he hw hn n w) :=
+  OrderedSectorOrbit.explicit_properties M hζ p (stabilizer_comm M p) (stabilizer_exp M p) e he hw hn hc hm
+end
+end OddKaplansky.OrderedSourceSector
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/OddKaplansky/PrescribedInverse.lean b/lean/OAI/Algebra/OddKaplansky/PrescribedInverse.lean
new file mode 100644
index 0000000000000000000000000000000000000000..18f66f3c58a27df5a848c5069108c4e867606d00
--- /dev/null
+++ b/lean/OAI/Algebra/OddKaplansky/PrescribedInverse.lean
@@ -0,0 +1,44 @@
+import OAI.Algebra.OddKaplansky.PrescribedGreedy
+
+namespace OAI
+
+universe portUniverse1 portUniverse2
+
+section
+namespace OddKaplansky.OrderedSourceSector
+noncomputable section
+open scoped Classical BigOperators Matrix
+open WreathFourier OrderedSectorOrbit
+variable (M p : ℕ) [NeZero M] [Fact p.Prime]
+variable (r : Rep (H := SectorStabilizer.H M p) M)
+def stabilizerPoint : T M r →* SectorStabilizer.Point p :=
+  RegularWreathProduct.rightHom.comp (T M r).subtype
+lemma stabilizerPoint_injective : Function.Injective (stabilizerPoint M p r) := by
+  change Function.Injective (RegularWreathProduct.rightHom.comp (T M r).subtype)
+  rw [T_leftFixed]
+  exact SectorStabilizer.toPoint_injective M p (fun x => (lmb M r x).toAdd) (lmb_weight M r)
+local instance : CommGroup (T M r) :=
+  { (inferInstance : Group (T M r)) with mul_comm := stabilizer_comm M p r }
+variable {K : Type portUniverse1} [Field K] [CharP K p]
+
+lemma augmentation_bound :
+    RingHom.ker (LocalAlgebra.augment (K := K) (T := T M r)).toRingHom ^(3*(p-1)+1)=0 :=
+  LocalAlgebra.kernel_nil_three p (stabilizer_exp M p r)
+    (stabilizerPoint M p r) (stabilizerPoint_injective M p r)
+variable {S : Type portUniverse2} [Fintype S] [LinearOrder S]
+variable (E : Matrix S S (MonoidAlgebra K (T M r)))
+variable (hE : E*E=E)
+lemma inverse_formula :
+    (GreedyRing.Q LocalAlgebra.augment.toRingHom E hE)⁻¹ =
+      FiniteMatrixInverse.series
+        (LocalAlgebra.scalarInverse (GreedyRing.Q LocalAlgebra.augment.toRingHom E hE) *
+          (GreedyRing.Q LocalAlgebra.augment.toRingHom E hE-LocalAlgebra.scalarMatrix (GreedyRing.Q LocalAlgebra.augment.toRingHom E hE)))
+        (3*(p-1)+1)*LocalAlgebra.scalarInverse (GreedyRing.Q LocalAlgebra.augment.toRingHom E hE) :=
+  GreedyRing.prescribed_inverse_formula p (stabilizer_exp M p r)
+    (stabilizerPoint M p r) (stabilizerPoint_injective M p r) E hE
+end
+end OddKaplansky.OrderedSourceSector
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/OddKaplansky/PrescribedSector.lean b/lean/OAI/Algebra/OddKaplansky/PrescribedSector.lean
new file mode 100644
index 0000000000000000000000000000000000000000..9aed260958624d0446004f5c435c33cbc02a43a4
--- /dev/null
+++ b/lean/OAI/Algebra/OddKaplansky/PrescribedSector.lean
@@ -0,0 +1,30 @@
+import OAI.Algebra.OddKaplansky.OrderedRectangles
+
+namespace OAI
+
+universe portUniverse1
+
+section
+namespace OddKaplansky.OrderedSourceSector
+noncomputable section
+open scoped Classical BigOperators Matrix
+open WreathFourier OrderedSectorOrbit
+lemma T_leftFixed {H : Type portUniverse1} [Group H] [Fintype H] [LinearOrder H] (M : ℕ) [NeZero M] (r : Rep (H := H) M) :
+    T M r = SectorStabilizer.stabilizer M (fun x => (lmb M r x).toAdd) := by
+  ext g
+  rw [mem_T]
+  constructor
+  · intro he x
+    have hh := congrArg (fun a : Base (H := H) M => (a (g*x)).toAdd) he
+    simpa only [shift_apply,inv_mul_cancel_left] using hh.symm
+  · intro hg
+    funext x
+    apply Multiplicative.toAdd.injective
+    have hh := hg (g⁻¹*x)
+    simpa only [shift_apply,mul_inv_cancel_left] using hh.symm
+end
+end OddKaplansky.OrderedSourceSector
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/OddKaplansky/QuadraticTower.lean b/lean/OAI/Algebra/OddKaplansky/QuadraticTower.lean
new file mode 100644
index 0000000000000000000000000000000000000000..f9fa01ae1833cc79c6449510460e8dc614af961a
--- /dev/null
+++ b/lean/OAI/Algebra/OddKaplansky/QuadraticTower.lean
@@ -0,0 +1,124 @@
+import OAI.Algebra.OddKaplansky.Parameters
+
+namespace OAI
+
+universe portUniverse1
+
+section
+noncomputable section
+open scoped Classical
+open Polynomial
+namespace OddKaplansky.QuadraticTower
+
+variable {F : Type portUniverse1} [Field F]
+
+def polynomial (a : F) : F[X] := X^2 - C a
+
+lemma polynomial_monic (a : F) : (polynomial a).Monic :=
+  monic_X_pow_sub_C a (by decide : 2 ≠ 0)
+
+lemma polynomial_degree (a : F) : (polynomial a).natDegree = 2 :=
+  natDegree_X_pow_sub_C
+
+lemma polynomial_irreducible {a : F} (ha : ¬ IsSquare a) :
+    Irreducible (polynomial a) := by
+  apply X_pow_sub_C_irreducible_of_prime Nat.prime_two
+  intro b hb
+  exact ha ⟨b, by simpa only [pow_two] using hb.symm⟩
+
+def basis (a : F) : PowerBasis F (AdjoinRoot (polynomial a)) :=
+  AdjoinRoot.powerBasis (polynomial_monic a).ne_zero
+
+lemma basis_dim (a : F) : (basis a).dim = 2 := polynomial_degree a
+lemma basis_gen (a : F) : (basis a).gen = AdjoinRoot.root (polynomial a) := rfl
+
+instance finiteDimensional (a : F) : FiniteDimensional F (AdjoinRoot (polynomial a)) :=
+  (basis a).finite
+
+lemma finrank (a : F) : Module.finrank F (AdjoinRoot (polynomial a)) = 2 := by
+  rw [(basis a).finrank, basis_dim]
+
+lemma root_sq (a : F) : AdjoinRoot.root (polynomial a)^2 =
+    algebraMap F (AdjoinRoot (polynomial a)) a := by
+  have h := AdjoinRoot.mk_self (f := polynomial a)
+  change AdjoinRoot.mk (polynomial a) (X^2 - C a) = 0 at h
+  rw [map_sub, map_pow, AdjoinRoot.mk_X, AdjoinRoot.mk_C, sub_eq_zero] at h
+  exact h
+
+lemma norm_root (a : F) :
+    Algebra.norm F (AdjoinRoot.root (polynomial a)) = -a := by
+  rw [← basis_gen a, Algebra.PowerBasis.norm_gen_eq_coeff_zero_minpoly, basis_dim]
+  have hm := AdjoinRoot.minpoly_powerBasis_gen_of_monic (polynomial_monic a)
+  change minpoly F (basis a).gen = polynomial a at hm
+  rw [hm]
+  simp [polynomial]
+
+lemma root_not_isSquare {a : F} (ha : ¬ IsSquare a) (hminus : IsSquare (-1 : F)) :
+    ¬ IsSquare (AdjoinRoot.root (polynomial a)) := by
+  intro hr
+  have hn : IsSquare (-a) := by
+    rw [← norm_root a]
+    exact hr.map (Algebra.norm F)
+  exact ha (by simpa only [neg_one_mul, neg_neg] using hminus.mul hn)
+
+instance finite [Finite F] (a : F) : Finite (AdjoinRoot (polynomial a)) :=
+  Module.finite_of_finite F
+
+lemma card [Fintype F] (a : F) [Fintype (AdjoinRoot (polynomial a))] :
+    Fintype.card (AdjoinRoot (polynomial a)) = (Fintype.card F)^2 := by
+  rw [Module.card_eq_pow_finrank (K := F), finrank]
+
+section PrimeField
+variable (p : ℕ) [Fact p.Prime]
+
+lemma exists_nonsquare_representative (hp : p ≠ 2) :
+    ∃ n : ℕ, n < p ∧ ¬ IsSquare (n : ZMod p) := by
+  obtain ⟨a, ha⟩ := FiniteField.exists_nonsquare (F := ZMod p) (by rw [ringChar.eq (ZMod p) p]; exact hp)
+  exact ⟨a.val, a.val_lt, by simpa using ha⟩
+
+def nonsquareIndex (hp : p ≠ 2) : ℕ := Nat.find (exists_nonsquare_representative p hp)
+def eta (hp : p ≠ 2) : ZMod p := (nonsquareIndex p hp : ZMod p)
+
+lemma eta_not_isSquare (hp : p ≠ 2) : ¬ IsSquare (eta p hp) :=
+  (Nat.find_spec (exists_nonsquare_representative p hp)).2
+lemma eta_ne_zero (hp : p ≠ 2) : eta p hp ≠ 0 := by
+  intro h
+  exact eta_not_isSquare p hp (h ▸ IsSquare.zero)
+lemma nonsquareIndex_lt (hp : p ≠ 2) : nonsquareIndex p hp < p :=
+  (Nat.find_spec (exists_nonsquare_representative p hp)).1
+lemma nonsquareIndex_min (hp : p ≠ 2) (n : ℕ) (hn : n < nonsquareIndex p hp) :
+    n < p → IsSquare (n : ZMod p) := by
+  intro hnp
+  by_contra h
+  exact Nat.find_min (exists_nonsquare_representative p hp) hn ⟨hnp, h⟩
+
+abbrev FirstField (hp : p ≠ 2) := AdjoinRoot (polynomial (eta p hp))
+instance first_irreducible (hp : p ≠ 2) : Fact (Irreducible (polynomial (eta p hp))) :=
+  ⟨polynomial_irreducible (eta_not_isSquare p hp)⟩
+instance first_fintype (hp : p ≠ 2) : Fintype (FirstField p hp) := Fintype.ofFinite _
+
+def xi (hp : p ≠ 2) : FirstField p hp := AdjoinRoot.root (polynomial (eta p hp))
+
+abbrev CoeffField (hp : p ≠ 2) := AdjoinRoot (polynomial (xi p hp))
+theorem second_irreducible (hp : p ≠ 2) (hminus : IsSquare (-1 : ZMod p)) :
+    Irreducible (polynomial (xi p hp)) :=
+  polynomial_irreducible (root_not_isSquare (eta_not_isSquare p hp) hminus)
+
+@[instance_reducible]
+def coeffField (hp : p ≠ 2) (hminus : IsSquare (-1 : ZMod p)) : Field (CoeffField p hp) := by
+  letI : Fact (Irreducible (polynomial (xi p hp))) := ⟨second_irreducible p hp hminus⟩
+  infer_instance
+instance tower_fintype (hp : p ≠ 2) : Fintype (CoeffField p hp) := Fintype.ofFinite _
+
+lemma first_card (hp : p ≠ 2) : Fintype.card (FirstField p hp) = p^2 := by
+  rw [card, ZMod.card]
+lemma tower_card (hp : p ≠ 2) : Fintype.card (CoeffField p hp) = p^4 := by
+  rw [card, first_card, ← pow_mul]
+
+end PrimeField
+end OddKaplansky.QuadraticTower
+
+end
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/OddKaplansky/ScalarAlgebra.lean b/lean/OAI/Algebra/OddKaplansky/ScalarAlgebra.lean
new file mode 100644
index 0000000000000000000000000000000000000000..f679dbedc2d3d56621580d6ba3ca2eb764ea215e
--- /dev/null
+++ b/lean/OAI/Algebra/OddKaplansky/ScalarAlgebra.lean
@@ -0,0 +1,223 @@
+import OAI.Algebra.OddKaplansky.HeisenbergSector
+
+namespace OAI
+
+universe portUniverse1 portUniverse2 portUniverse3 portUniverse4 portUniverse5 portUniverse6 portUniverse7 portUniverse8 portUniverse9
+
+section
+
+noncomputable section
+open scoped Classical BigOperators
+namespace OddKaplansky.MatrixBlock
+variable {S : Type portUniverse1} {R : Type portUniverse2} {m : Type portUniverse3} [Ring S] [Ring R] [Fintype m]
+variable (f : S →+* R) (q : m → m → R)
+
+def block (X : Matrix m m S) : R := ∑ i, ∑ j, f (X i j) * q i j
+
+lemma block_zero : block f q 0 = 0 := by simp [block]
+lemma block_add (X Y : Matrix m m S) : block f q (X + Y) = block f q X + block f q Y := by
+  simp [block, add_mul, Finset.sum_add_distrib]
+lemma block_sub (X Y : Matrix m m S) : block f q (X - Y) = block f q X - block f q Y := by
+  simp [block, sub_mul, Finset.sum_sub_distrib]
+lemma block_one : block f q 1 = ∑ i, q i i := by
+  simp [block, Matrix.one_apply, apply_ite]
+
+variable (hqq : ∀ i j k r, q i j * q k r = if j = k then q i r else 0)
+variable (hcomm : ∀ x i j, Commute (f x) (q i j))
+include hqq hcomm
+
+lemma block_mul (X Y : Matrix m m S) : block f q (X * Y) = block f q X * block f q Y := by
+  have hterm (i j k r : m) :
+      (f (X i j) * q i j) * (f (Y k r) * q k r) =
+        if j = k then f (X i j * Y k r) * q i r else 0 := by
+    calc
+      _ = f (X i j * Y k r) * (q i j * q k r) := by
+        rw [map_mul, ← mul_assoc, mul_assoc (f (X i j)),
+          (hcomm (Y k r) i j).eq.symm]
+        simp only [mul_assoc]
+      _ = _ := by rw [hqq]; split_ifs <;> simp
+  have hmulij (i j : m) : (f (X i j) * q i j) * block f q Y =
+      ∑ r, f (X i j * Y j r) * q i r := by
+    simp only [block, Finset.mul_sum, hterm]
+    rw [Finset.sum_comm]
+    simp
+  symm
+  calc
+    block f q X * block f q Y = ∑ i, ∑ j, (f (X i j) * q i j) * block f q Y := by
+      change (∑ i, ∑ j, f (X i j) * q i j) * block f q Y = _
+      simp only [Finset.sum_mul]
+    _ = ∑ i, ∑ j, ∑ r, f (X i j * Y j r) * q i r := by simp_rw [hmulij]
+    _ = block f q (X * Y) := by
+      simp only [block, Matrix.mul_apply, map_sum, Finset.sum_mul]
+      apply Finset.sum_congr rfl
+      intro i _
+      exact Finset.sum_comm
+
+lemma block_sandwich (X : Matrix m m S) (i j : m) :
+    q i i * block f q X * q j j = f (X i j) * q i j := by
+  have hterm (k r : m) : q i i * (f (X k r) * q k r) * q j j =
+      if i = k then if r = j then f (X k r) * q i j else 0 else 0 := by
+    calc
+      _ = f (X k r) * (q i i * q k r * q j j) := by
+        rw [← mul_assoc, (hcomm (X k r) i i).eq.symm]
+        simp only [mul_assoc]
+      _ = _ := by
+        by_cases hik : i = k <;> by_cases hrj : r = j <;>
+          simp [hqq, hik, hrj]
+
+  simp only [block, Finset.mul_sum, Finset.sum_mul, hterm]
+  simp
+
+lemma block_injective (hpure : ∀ x i j, f x * q i j = 0 → x = 0) :
+    Function.Injective (block f q) := by
+  intro X Y h
+  have hz : block f q (X - Y) = 0 := by rw [block_sub, h, sub_self]
+  have hXY : X - Y = 0 := by
+    ext i j
+    apply hpure _ i j
+    rw [← block_sandwich f q hqq hcomm, hz, mul_zero, zero_mul]
+  exact sub_eq_zero.mp hXY
+
+theorem scalar_witnesses
+    (hpure : ∀ x i j, f x * q i j = 0 → x = 0)
+    (a b : Matrix m m S) (hab : a * b = 1) (hba : b * a ≠ 1) :
+    ∃ a' b' : R, a' * b' = 1 ∧ b' * a' ≠ 1 := by
+  let e := block f q 1
+  let a' := 1 - e + block f q a
+  let b' := 1 - e + block f q b
+  have he : e * e = e := by rw [← block_mul f q hqq hcomm, mul_one]
+  have hea : e * block f q a = block f q a := by rw [← block_mul f q hqq hcomm, one_mul]
+  have hae : block f q a * e = block f q a := by rw [← block_mul f q hqq hcomm, mul_one]
+  have heb : e * block f q b = block f q b := by rw [← block_mul f q hqq hcomm, one_mul]
+  have hbe : block f q b * e = block f q b := by rw [← block_mul f q hqq hcomm, mul_one]
+  have hab' : block f q a * block f q b = e := by rw [← block_mul f q hqq hcomm, hab]
+  refine ⟨a',b',?_,?_⟩
+  · dsimp [a',b']
+    noncomm_ring [he, hea, hae, heb, hbe, hab']
+  · intro h
+    have h' : block f q b * block f q a = e := by
+      apply add_left_cancel (a := 1 - e)
+      calc
+        1 - e + block f q b * block f q a =
+            (1 - e + block f q b) * (1 - e + block f q a) := by
+          noncomm_ring [he, hea, hae, heb, hbe]
+        _ = 1 := h
+        _ = 1 - e + e := by abel
+    apply hba
+    apply block_injective f q hqq hcomm hpure
+    rw [block_mul f q hqq hcomm]
+    exact h'
+
+end OddKaplansky.MatrixBlock
+namespace OddKaplansky.ProductAlgebras
+variable {K : Type portUniverse4} {G : Type portUniverse5} {H : Type portUniverse6} [Field K] [Group G] [Group H]
+
+def leftMap : MonoidAlgebra K G →ₐ[K] MonoidAlgebra K (G × H) :=
+  MonoidAlgebra.mapDomainAlgHom K K (MonoidHom.inl G H)
+def rightMap : MonoidAlgebra K H →ₐ[K] MonoidAlgebra K (G × H) :=
+  MonoidAlgebra.mapDomainAlgHom K K (MonoidHom.inr G H)
+
+lemma left_right_commute (x : MonoidAlgebra K G) (y : MonoidAlgebra K H) :
+    Commute (leftMap x) (rightMap y) := by
+  induction x using MonoidAlgebra.induction_on with
+  | of g =>
+    induction y using MonoidAlgebra.induction_on with
+    | of h =>
+      change _ * _ = _ * _
+      simp [leftMap, rightMap, MonoidAlgebra.of_apply, MonoidAlgebra.single_mul_single]
+    | add y z hy hz => simpa only [map_add] using hy.add_right hz
+    | smul c y hy => simpa only [map_smul] using hy.smul_right c
+  | add x z hx hz => simpa only [map_add] using hx.add_left hz
+  | smul c x hx => simpa only [map_smul] using hx.smul_left c
+
+lemma product_coeff (x : MonoidAlgebra K G) (y : MonoidAlgebra K H) (g : G) (h : H) :
+    (leftMap x * rightMap y).coeff (g,h) = x.coeff g * y.coeff h := by
+  induction x using MonoidAlgebra.induction_on with
+  | of a =>
+    induction y using MonoidAlgebra.induction_on with
+    | of b =>
+      by_cases hag : a = g <;> by_cases hbh : b = h <;>
+        simp [leftMap, rightMap, MonoidAlgebra.of_apply, MonoidAlgebra.single_mul_single,
+          hag, hbh, Prod.ext_iff]
+    | add y z hy hz =>
+      simp only [map_add, mul_add, MonoidAlgebra.coeff_add, Finsupp.add_apply, hy, hz]
+    | smul c y hy =>
+      simp only [map_smul, mul_smul_comm, MonoidAlgebra.coeff_smul, Finsupp.smul_apply,
+        smul_eq_mul, hy]
+      ring
+  | add x z hx hz =>
+    simp only [map_add, add_mul, MonoidAlgebra.coeff_add, Finsupp.add_apply, hx, hz]
+  | smul c x hx =>
+    simp only [map_smul, smul_mul_assoc, MonoidAlgebra.coeff_smul, Finsupp.smul_apply,
+      smul_eq_mul, hx]
+    ring
+
+lemma product_ne_zero {x : MonoidAlgebra K G} {y : MonoidAlgebra K H}
+    (hx : x ≠ 0) (hy : y ≠ 0) : leftMap x * rightMap y ≠ 0 := by
+  obtain ⟨g,hg⟩ : ∃ g, x.coeff g ≠ 0 := by
+    by_contra! h
+    apply hx
+    ext g
+    exact h g
+  obtain ⟨h,hh⟩ : ∃ h, y.coeff h ≠ 0 := by
+    by_contra! h
+    apply hy
+    ext a
+    exact h a
+  intro he
+  have he' := congrArg (fun z : MonoidAlgebra K (G × H) => z.coeff (g,h)) he
+  rw [product_coeff] at he'
+  exact mul_ne_zero hg hh he'
+
+end OddKaplansky.ProductAlgebras
+namespace OddKaplansky.MatrixBlock
+variable {S : Type portUniverse7} {R : Type portUniverse8} {m : Type portUniverse9} [Ring S] [Ring R] [Fintype m]
+variable (f : S →+* R) (q : m → m → R)
+
+def output (X : Matrix m m S) : R := 1 - block f q 1 + block f q X
+
+lemma output_formula (X : Matrix m m S) :
+    output f q X = 1 - ∑ i, q i i + ∑ i, ∑ j, f (X i j)*q i j := by
+  rw [output,block_one,block]
+
+variable (hqq : ∀ i j k r, q i j * q k r = if j = k then q i r else 0)
+variable (hcomm : ∀ x i j, Commute (f x) (q i j))
+
+include hqq hcomm in
+theorem prescribed_scalar_products
+    (hpure : ∀ x i j, f x * q i j = 0 → x = 0)
+    (a b : Matrix m m S) (hab : a * b = 1) (hba : b * a ≠ 1) :
+    output f q a * output f q b = 1 ∧ output f q b * output f q a ≠ 1 := by
+  let e := block f q 1
+  let a' := 1 - e + block f q a
+  let b' := 1 - e + block f q b
+  have he : e * e = e := by rw [← block_mul f q hqq hcomm, mul_one]
+  have hea : e * block f q a = block f q a := by rw [← block_mul f q hqq hcomm, one_mul]
+  have hae : block f q a * e = block f q a := by rw [← block_mul f q hqq hcomm, mul_one]
+  have heb : e * block f q b = block f q b := by rw [← block_mul f q hqq hcomm, one_mul]
+  have hbe : block f q b * e = block f q b := by rw [← block_mul f q hqq hcomm, mul_one]
+  have hab' : block f q a * block f q b = e := by rw [← block_mul f q hqq hcomm, hab]
+  change a' * b' = 1 ∧ b' * a' ≠ 1
+  refine ⟨?_,?_⟩
+  · dsimp [a',b']
+    noncomm_ring [he, hea, hae, heb, hbe, hab']
+  · intro h
+    have h' : block f q b * block f q a = e := by
+      apply add_left_cancel (a := 1 - e)
+      calc
+        1 - e + block f q b * block f q a =
+            (1 - e + block f q b) * (1 - e + block f q a) := by
+          noncomm_ring [he, hea, hae, heb, hbe]
+        _ = 1 := h
+        _ = 1 - e + e := by abel
+    apply hba
+    apply block_injective f q hqq hcomm hpure
+    rw [block_mul f q hqq hcomm]
+    exact h'
+
+end OddKaplansky.MatrixBlock
+end
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/OddKaplansky/SectorConstruction.lean b/lean/OAI/Algebra/OddKaplansky/SectorConstruction.lean
new file mode 100644
index 0000000000000000000000000000000000000000..e8f96e130596a83039b47daa44585ede3e079c2c
--- /dev/null
+++ b/lean/OAI/Algebra/OddKaplansky/SectorConstruction.lean
@@ -0,0 +1,193 @@
+import OAI.Algebra.OddKaplansky.Construction
+
+namespace OAI
+
+universe portUniverse1
+
+section
+namespace OddKaplansky.Construction
+noncomputable section
+local instance sectorConstructionDecidableEq (α : Type portUniverse1) : DecidableEq α := Classical.decEq α
+open scoped Classical BigOperators Matrix
+open SourceGluing SourceGraph
+local notation "M" => SourceGluing.modulus
+local notation "p" => SourceGluing.p
+local notation "HH" => SourceGluing.H
+abbrev G₁ := SectorGroup.G₁ M SourceGluing.vertex
+instance : Group.FG G₁ := inferInstance
+variable {K : Type} [Field K] [sectionInstance80 : Fintype K] [sectionInstance81 : CharP K p]
+variable {ζ : K} (hζ : IsPrimitiveRoot ζ M)
+abbrev R := MonoidAlgebra K G₁
+def f : R (K := K) := SectorGroup.f M SourceGluing.vertex hζ
+lemma f_idem : f hζ*f hζ=f hζ := SectorGroup.f_idempotent M SourceGluing.vertex hζ cyclic_card
+lemma f_nonzero : f hζ≠0 := SectorGroup.f_ne_zero M SourceGluing.vertex hζ SourceGluing.vertex_injective cyclic_card
+lemma f_commute
+    {K : Type}
+    [contextInstance1 : Field.{0} K]
+    [Fintype.{0} K]
+    [@CharP.{0} K
+  (@AddGroupWithOne.toAddMonoidWithOne.{0} K
+    (@Ring.toAddGroupWithOne.{0} K (@DivisionRing.toRing.{0} K (@Field.toDivisionRing.{0} K contextInstance1))))
+  OddKaplansky.SourceGluing.p]
+    {ζ : K}
+    (hζ : @IsPrimitiveRoot.{0} K (@CommRing.toCommMonoid.{0} K (@Field.toCommRing.{0} K contextInstance1)) ζ
+  OddKaplansky.SourceGluing.modulus) (a : R (K := K)) : Commute (f hζ) a := SectorGroup.f_central M SourceGluing.vertex hζ a
+def original : MonoidAlgebra K SourceGluing.G₀ →ₐ[K] R (K := K) := MonoidAlgebra.mapDomainAlgHom K K (SectorGroup.original M SourceGluing.vertex)
+def attached (v : Vertex) : MonoidAlgebra K (WreathFourier.Wreath (H := HH) M) →ₐ[K] R (K := K) :=
+  MonoidAlgebra.mapDomainAlgHom K K (SectorGroup.factor M SourceGluing.vertex v)
+def P (d : LocalDatum (K := K)) (v : Vertex) : R (K := K) := f hζ*original (push v d.e)
+lemma f_mul_product (x y : R (K := K)) : (f hζ*x)*(f hζ*y)=f hζ*(x*y) := by
+  calc
+    _ = f hζ*(x*f hζ)*y := by simp only [mul_assoc]
+    _ = f hζ*(f hζ*x)*y := by rw [← (f_commute hζ x).eq]
+    _ = (f hζ*f hζ)*(x*y) := by simp only [mul_assoc]
+    _ = _ := by rw [f_idem]
+lemma P_idem (d : LocalDatum (K := K)) (v : Vertex) : P hζ d v*P hζ d v=P hζ d v := by
+  rw [P,f_mul_product,← map_mul,← map_mul,d.idem]
+lemma P_sector (d : LocalDatum (K := K)) (v : Vertex) : f hζ*P hζ d v=P hζ d v := by rw [P,← mul_assoc,f_idem]
+lemma P_ordered (d : LocalDatum (K := K)) (v w : Vertex) (hvw : v<w) (hadj : graph.Adj v w) : P hζ d v*P hζ d w=0 := by
+  rw [P,P,f_mul_product,← map_mul,ordered_zero d v w hvw hadj,map_zero,mul_zero]
+lemma fit_upper (d : LocalDatum (K := K)) (v w : Vertex) (hvw : v<w) :
+    (∑ T : SourceFit.Slot, SourceFit.alpha (K := K) v T*SourceFit.beta w T) • (P hζ d v*P hζ d w)=0 := by
+  by_cases ha : graph.Adj v w
+  · rw [P_ordered hζ d v w hvw ha,smul_zero]
+  · change SourceFit.fitting v w • _=0
+    rw [SourceFit.fitting_nonedge v w (ne_of_lt hvw) ha,zero_smul]
+
+abbrev W := Fin (Fintype.card HH)
+abbrev N (d : LocalDatum (K := K)) := Fin (Module.finrank K (LinearMap.range (Algebra.lmul K _ d.e)))
+structure Rectangular (d : LocalDatum (K := K)) where
+  J : Vertex → Matrix W (N d) (R (K := K))
+  Y : Vertex → Matrix (N d) W (R (K := K))
+  YJ : ∀ v, Y v*J v=Matrix.diagonal (fun _ => f hζ)
+  JY : ∀ v, J v*Y v=Matrix.diagonal (fun _ => P hζ d v)
+  sectorJ : ∀ v w n, f hζ*J v w n=J v w n
+  sectorY : ∀ v n w, f hζ*Y v n w=Y v n w
+lemma rectangular_exists (d : LocalDatum (K := K)) : Nonempty (Rectangular hζ d) := by
+  obtain ⟨J,Y,hYJ,hJY,hJ,hY⟩ := SourceSector.rectangular M p hζ sector_base_card cyclic_card d.e d.idem
+    (W := W) (N := N d) (Fintype.card_fin _) (Fintype.card_fin _)
+  let Js (v : Vertex) := J.map (attached (K := K) v)
+  let Ys (v : Vertex) := Y.map (attached (K := K) v)
+  have hff (v : Vertex) : attached (K := K) v (SectorFourier.f M hζ)=f hζ := SectorGroup.factor_f M SourceGluing.vertex hζ v
+  have hee (v : Vertex) : attached (K := K) v (MonoidAlgebra.mapDomainAlgHom K K (WreathFourier.top M) d.e)=original (push v d.e) :=
+    SectorGroup.factor_original M SourceGluing.vertex v d.e
+  refine ⟨⟨Js,Ys,?_,?_,?_,?_⟩⟩
+  · intro v
+    dsimp [Js,Ys]
+    rw [← Matrix.map_mul,hYJ]
+    funext i j
+    by_cases he : i=j <;> simp [Matrix.map_apply,he,hff]
+  · intro v
+    dsimp [Js,Ys]
+    rw [← Matrix.map_mul,hJY]
+    funext i j
+    by_cases he : i=j
+    · subst j
+      simp only [Matrix.map_apply,Matrix.diagonal_apply_eq,map_mul,hff,hee,P]
+    · simp [Matrix.map_apply,he]
+  · intro v w n
+    change f hζ*attached v (J w n)=attached v (J w n)
+    rw [← hff,← map_mul,hJ]
+  · intro v n w
+    change f hζ*attached v (Y n w)=attached v (Y n w)
+    rw [← hff,← map_mul,hY]
+
+def prescribedRectangles (d : LocalDatum (K := K)) : Rectangular hζ d := by
+  let J := OrderedSourceSector.explicitJ M p hζ d.e d.idem (W := W) (N := N d) (Fintype.card_fin _) (Fintype.card_fin _)
+  let Y := OrderedSourceSector.explicitY M p hζ d.e d.idem (W := W) (N := N d) (Fintype.card_fin _) (Fintype.card_fin _)
+  have hs := OrderedSourceSector.explicit_properties M p hζ d.e d.idem (W := W) (N := N d) (Fintype.card_fin _) (Fintype.card_fin _) sector_base_card cyclic_card
+  obtain ⟨hYJ,hJY,hJ,hY⟩ := hs
+  let Js (v : Vertex) := J.map (attached (K := K) v)
+  let Ys (v : Vertex) := Y.map (attached (K := K) v)
+  have hff (v : Vertex) : attached (K := K) v (SectorFourier.f M hζ)=f hζ := SectorGroup.factor_f M SourceGluing.vertex hζ v
+  have hee (v : Vertex) : attached (K := K) v (MonoidAlgebra.mapDomainAlgHom K K (WreathFourier.top M) d.e)=original (push v d.e) :=
+    SectorGroup.factor_original M SourceGluing.vertex v d.e
+  refine ⟨Js,Ys,?_,?_,?_,?_⟩
+  · intro v
+    dsimp [Js,Ys]
+    rw [← Matrix.map_mul,hYJ]
+    funext i j
+    by_cases he : i=j <;> simp [Matrix.map_apply,he,hff]
+  · intro v
+    dsimp [Js,Ys]
+    rw [← Matrix.map_mul,hJY]
+    funext i j
+    by_cases he : i=j
+    · subst j
+      simp only [Matrix.map_apply,Matrix.diagonal_apply_eq,map_mul,hff,hee,P]
+    · simp [Matrix.map_apply,he]
+  · intro v w n
+    change f hζ*attached v (J w n)=attached v (J w n)
+    rw [← hff,← map_mul,hJ]
+  · intro v n w
+    change f hζ*attached v (Y n w)=attached v (Y n w)
+    rw [← hff,← map_mul,hY]
+
+def ix : Vertex ≃o Fin (Fintype.card Vertex) := (Fintype.orderIsoFinOfCardEq Vertex rfl).symm
+abbrev Small := W×SourceFit.Slot
+abbrev Large (d : LocalDatum (K := K)) := Vertex×N d
+def C (d : LocalDatum (K := K)) (rect : Rectangular hζ d) : Matrix Small (Large d) (R (K := K)) :=
+  Compression.Csharp (K := K) (P hζ d) SourceFit.beta rect.J
+def D (d : LocalDatum (K := K)) (rect : Rectangular hζ d) : Matrix (Large d) Small (R (K := K)) :=
+  Compression.Dsharp (K := K) (P hζ d) SourceFit.alpha SourceFit.beta rect.Y
+lemma DC (d : LocalDatum (K := K)) (rect : Rectangular hζ d) : D hζ d rect*C hζ d rect=Matrix.diagonal (fun _ => f hζ) := by
+  have hdiag (v : Vertex) : ∑ t, SourceFit.alpha (K := K) v t*SourceFit.beta v t=1 := SourceFit.fitting_diagonal p prime_large v
+  have hu (v w : Vertex) (hvw : (ix v).val < (ix w).val) :
+      (∑ t, SourceFit.alpha (K := K) v t*SourceFit.beta w t) • (P hζ d v*P hζ d w)=0 :=
+    fit_upper hζ d v w (ix.lt_iff_lt.mp hvw)
+  have hyj : ∀ v, rect.Y v*rect.J v= @Matrix.diagonal (N d) (R (K := K)) (Classical.decEq _) _ (fun _ => f hζ) := by
+    intro v
+    convert rect.YJ v using 1 ; congr ; exact Subsingleton.elim _ _
+  have hjy : ∀ v, rect.J v*rect.Y v= @Matrix.diagonal W (R (K := K)) (Classical.decEq _) _ (fun _ => P hζ d v) := by
+    intro v
+    convert rect.JY v using 1 ; congr ; exact Subsingleton.elim _ _
+  convert Compression.compressed (K := K) (f hζ) (f_idem hζ) (P hζ d) (P_idem hζ d)
+    SourceFit.alpha SourceFit.beta ix ix.injective hdiag hu rect.J rect.Y hyj hjy using 1 <;> congr ; exact Subsingleton.elim _ _
+lemma DC_classical (d : LocalDatum (K := K)) (rect : Rectangular hζ d) :
+    D hζ d rect*C hζ d rect= @Matrix.diagonal (Large d) (R (K := K)) (Classical.decEq _) _ (fun _ => f hζ) := by
+  convert DC hζ d rect using 1 ; congr ; exact Subsingleton.elim _ _
+lemma C_sector (d : LocalDatum (K := K)) (rect : Rectangular hζ d) : ∀ a b, f hζ*C hζ d rect a b=C hζ d rect a b :=
+  Compression.Csharp_sector (K := K) (f hζ) (P hζ d) (P_sector hζ d) SourceFit.beta rect.J
+lemma D_sector
+    {K : Type}
+    [contextInstance1 : Field.{0} K]
+    [Fintype.{0} K]
+    [@CharP.{0} K
+  (@AddGroupWithOne.toAddMonoidWithOne.{0} K
+    (@Ring.toAddGroupWithOne.{0} K (@DivisionRing.toRing.{0} K (@Field.toDivisionRing.{0} K contextInstance1))))
+  OddKaplansky.SourceGluing.p]
+    {ζ : K}
+    (hζ : @IsPrimitiveRoot.{0} K (@CommRing.toCommMonoid.{0} K (@Field.toCommRing.{0} K contextInstance1)) ζ
+  OddKaplansky.SourceGluing.modulus) (d : LocalDatum (K := K)) (rect : Rectangular hζ d) : ∀ a b, f hζ*D hζ d rect a b=D hζ d rect a b :=
+  Compression.Dsharp_sector (K := K) (f hζ) (P hζ d) SourceFit.alpha SourceFit.beta rect.Y rect.sectorY
+lemma d_positive
+    {K : Type}
+    [contextInstance1 : Field.{0} K]
+    [Fintype.{0} K]
+    [@CharP.{0} K
+  (@AddGroupWithOne.toAddMonoidWithOne.{0} K
+    (@Ring.toAddGroupWithOne.{0} K (@DivisionRing.toRing.{0} K (@Field.toDivisionRing.{0} K contextInstance1))))
+  OddKaplansky.SourceGluing.p] (d : LocalDatum (K := K)) : 0<Fintype.card (N d) := by
+  rw [Fintype.card_fin]
+  have := d.rank
+  omega
+lemma sizes (d : LocalDatum (K := K)) : Fintype.card Small<Fintype.card (Large d) := by
+  have ht := SourceFit.ratio_bound
+  have hd := d.rank
+  have hdpos := d_positive d
+  simp only [N,Fintype.card_fin] at hdpos
+  have hh := Nat.mul_le_mul_right (Fintype.card SourceFit.Slot) hd.le
+  have hhh := Nat.mul_lt_mul_of_pos_right ht hdpos
+  simp only [Small,Large,W,N,Fintype.card_prod,Fintype.card_fin,SourceGraph.card_vertices]
+  nlinarith
+lemma small_positive : 0<Fintype.card Small := by
+  have ht : Nonempty SourceFit.Slot := ⟨⟨∅,by simp⟩⟩
+  have hw : 0<Fintype.card HH := Fintype.card_pos
+  simp only [Small,W,Fintype.card_prod,Fintype.card_fin]
+  exact Nat.mul_pos hw (Fintype.card_pos_iff.mpr ht)
+end
+end OddKaplansky.Construction
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/OddKaplansky/SectorFourier.lean b/lean/OAI/Algebra/OddKaplansky/SectorFourier.lean
new file mode 100644
index 0000000000000000000000000000000000000000..0b31df3979a2d88c4b7a838efbb8a2bfd37cb27e
--- /dev/null
+++ b/lean/OAI/Algebra/OddKaplansky/SectorFourier.lean
@@ -0,0 +1,138 @@
+import OAI.Algebra.OddKaplansky.OrbitBlock
+
+namespace OAI
+
+universe contextUniverse1 contextUniverse2
+
+universe portUniverse1 portUniverse2 portUniverse3 portUniverse4 portUniverse5
+
+section
+namespace OddKaplansky.CharacterIdempotents
+noncomputable section
+open scoped Classical BigOperators
+variable {K : Type portUniverse1} {A : Type portUniverse2} {B : Type portUniverse3} [Field K] [Group A] [Fintype A] [Group B] [Fintype B]
+lemma projector_pushed (χ : A →* Kˣ) (j : B →* A) (ψ : B →* Kˣ)
+    (hc : (Fintype.card B : K) ≠ 0) :
+    projector χ * pushed j ψ = if χ.comp j = ψ then projector χ else 0 := by
+  rw [pushed_eq_sum,mul_smul_comm,Finset.mul_sum]
+  have hh (b : B) : projector χ * MonoidAlgebra.single (j b) ((ψ b : K)⁻¹) =
+      ((χ (j b) : K) * (ψ b : K)⁻¹) • projector χ := by
+    rw [show MonoidAlgebra.single (j b) ((ψ b : K)⁻¹) = (ψ b : K)⁻¹ • MonoidAlgebra.single (j b) 1 by simp]
+    rw [mul_smul_comm,projector_mul_single,smul_smul,mul_comm]
+  simp_rw [hh]
+  rw [← Finset.sum_smul,smul_smul]
+  by_cases he : χ.comp j = ψ
+  · rw [ite_eq_left he]
+    have hv (b : B) : χ (j b)=ψ b := DFunLike.congr_fun he b
+    simp [hv,hc]
+  · rw [ite_eq_right he]
+    have hn : χ.comp j * ψ⁻¹ ≠ 1 := by
+      intro h
+      apply he
+      exact mul_inv_eq_one.mp h
+    have hz := sum_character_eq_zero (χ.comp j * ψ⁻¹) hn
+    simpa using congrArg (fun c : K => ((Fintype.card B : K)⁻¹*c) • projector χ) hz
+end
+end OddKaplansky.CharacterIdempotents
+
+namespace OddKaplansky.SectorFourier
+noncomputable section
+open scoped Classical BigOperators
+open WreathFourier
+variable {K : Type portUniverse4} {H : Type portUniverse5} [Field K] [sectionInstance45 : Group H] [sectionInstance46 : Fintype H]
+variable (M : ℕ) [sectionInstance44 : NeZero M] {ζ : K} (hζ : IsPrimitiveRoot ζ M)
+def constant : Fourier.C M →* Base (H := H) M where
+  toFun c := fun _ => c
+  map_one' := rfl
+  map_mul' _ _ := rfl
+def diagonal : Fourier.C M →* Wreath (H := H) M := (base M).comp (constant M)
+def weight (lmb : Base (H := H) M) : ZMod M := ∑ x, (lmb x).toAdd
+lemma weight_shift
+    {H : Type contextUniverse1}
+    [Group.{contextUniverse1} H]
+    [Fintype.{contextUniverse1} H]
+    (M : Nat)
+    [@NeZero.{0} Nat (@MulZeroClass.toZero.{0} Nat Nat.instMulZeroClass) M] (g : H) (lmb : Base (H := H) M) : weight M (shift M g lmb) = weight M lmb :=
+  Equiv.sum_comp (Equiv.mulLeft g⁻¹) (fun x : H => (lmb x).toAdd)
+lemma character_constant
+    {K : Type contextUniverse1}
+    {H : Type contextUniverse2}
+    [contextInstance2 : Field.{contextUniverse1} K]
+    [Group.{contextUniverse2} H]
+    [Fintype.{contextUniverse2} H]
+    (M : Nat)
+    [@NeZero.{0} Nat (@MulZeroClass.toZero.{0} Nat Nat.instMulZeroClass) M]
+    {ζ : K}
+    (hζ : @IsPrimitiveRoot.{contextUniverse1} K (@CommRing.toCommMonoid.{contextUniverse1} K (@Field.toCommRing.{contextUniverse1} K contextInstance2)) ζ M) (lmb : Base (H := H) M) :
+    (Fourier.character M hζ lmb).comp (constant M) = Fourier.cyclicCharacter M hζ ↔ weight M lmb=1 := by
+  constructor
+  · intro he
+    have hh := DFunLike.congr_fun he (Multiplicative.ofAdd (1 : ZMod M))
+    have hh' := Fourier.cyclicCharacter_injective M hζ hh
+    have hh'' := congrArg Multiplicative.toAdd hh'
+    simpa [Fourier.character_apply,constant,weight] using hh''
+  · intro hw
+    apply MonoidHom.ext
+    intro c
+    simp only [MonoidHom.comp_apply,Fourier.character_apply,constant,MonoidHom.coe_mk,OneHom.coe_mk,← Finset.sum_mul]
+    rw [show (∑ x : H, (lmb x).toAdd)=1 from hw,one_mul,ofAdd_toAdd]
+def f : MonoidAlgebra K (Wreath (H := H) M) := CharacterIdempotents.pushed (diagonal M) (Fourier.cyclicCharacter M hζ)
+lemma f_eq_packet (hc : (Fintype.card (Base (H := H) M) : K) ≠ 0)
+    (hm : (Fintype.card (Fourier.C M) : K) ≠ 0) :
+    f (H := H) M hζ = ∑ lmb : {lmb : Base (H := H) M // weight M lmb=1}, projector M hζ lmb.val := by
+  have hp : ∀ lmb : Base (H := H) M, projector M hζ lmb * f M hζ =
+      if weight M lmb=1 then projector M hζ lmb else 0 := by
+    intro lmb
+    have hh := congrArg (MonoidAlgebra.mapDomainAlgHom K K (base (H := H) M))
+      (CharacterIdempotents.projector_pushed (Fourier.character M hζ lmb) (constant M) (Fourier.cyclicCharacter M hζ) hm)
+    have hf : MonoidAlgebra.mapDomainAlgHom K K (base (H := H) M)
+        (CharacterIdempotents.pushed (constant M) (Fourier.cyclicCharacter M hζ)) = f M hζ := by
+      simp only [CharacterIdempotents.pushed,f,diagonal,MonoidAlgebra.mapDomainAlgHom_comp,AlgHom.comp_apply]
+    simp only [map_mul,apply_ite,map_zero,hf,character_constant] at hh
+    by_cases hw : weight M lmb=1
+    · simpa only [ite_eq_left hw,projector,CharacterIdempotents.pushed] using hh
+    · simpa only [ite_eq_right hw,projector,CharacterIdempotents.pushed] using hh
+  calc
+    f (H := H) M hζ = (∑ lmb : Base (H := H) M, projector M hζ lmb) * f M hζ := by rw [sum_projector M hζ hc,one_mul]
+    _ = ∑ lmb : Base (H := H) M, if weight M lmb=1 then projector M hζ lmb else 0 := by simp only [Finset.sum_mul,hp]
+    _ = _ := by
+      rw [← Finset.sum_filter]
+      exact Finset.sum_subtype _ (by simp) _
+lemma diagonal_injective
+    {H : Type contextUniverse1}
+    [Group.{contextUniverse1} H]
+    [Fintype.{contextUniverse1} H]
+    (M : Nat)
+    [@NeZero.{0} Nat (@MulZeroClass.toZero.{0} Nat Nat.instMulZeroClass) M] : Function.Injective (diagonal (H := H) M) := by
+  intro a b he
+  have hh := congrArg (fun g : Wreath (H := H) M => g.left 1) he
+  exact hh
+lemma diagonal_central
+    {H : Type contextUniverse1}
+    [Group.{contextUniverse1} H]
+    [Fintype.{contextUniverse1} H]
+    (M : Nat)
+    [@NeZero.{0} Nat (@MulZeroClass.toZero.{0} Nat Nat.instMulZeroClass) M] (c : Fourier.C M) (g : Wreath (H := H) M) : Commute (diagonal M c) g := by
+  change diagonal M c * g = g * diagonal M c
+  ext x <;> simp [diagonal,constant,base,mul_comm]
+lemma f_idempotent
+    {K : Type contextUniverse1}
+    {H : Type contextUniverse2}
+    [contextInstance2 : Field.{contextUniverse1} K]
+    [Group.{contextUniverse2} H]
+    [Fintype.{contextUniverse2} H]
+    (M : Nat)
+    [@NeZero.{0} Nat (@MulZeroClass.toZero.{0} Nat Nat.instMulZeroClass) M]
+    {ζ : K}
+    (hζ : @IsPrimitiveRoot.{contextUniverse1} K (@CommRing.toCommMonoid.{contextUniverse1} K (@Field.toCommRing.{contextUniverse1} K contextInstance2)) ζ M) (hm : (Fintype.card (Fourier.C M) : K) ≠ 0) : f (H := H) M hζ * f M hζ=f M hζ :=
+  CharacterIdempotents.pushed_idempotent _ _ hm
+lemma f_ne_zero (hm : (Fintype.card (Fourier.C M) : K) ≠ 0) : f (H := H) M hζ ≠ 0 :=
+  CharacterIdempotents.pushed_ne_zero _ (diagonal_injective M) _ hm
+lemma f_central (a : MonoidAlgebra K (Wreath (H := H) M)) : Commute (f M hζ) a :=
+  CharacterIdempotents.pushed_central _ _ (diagonal_central M) a
+end
+end OddKaplansky.SectorFourier
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/OddKaplansky/SectorGreedy.lean b/lean/OAI/Algebra/OddKaplansky/SectorGreedy.lean
new file mode 100644
index 0000000000000000000000000000000000000000..ad6bbb90a278ba1a257a0723005442a244c5e18e
--- /dev/null
+++ b/lean/OAI/Algebra/OddKaplansky/SectorGreedy.lean
@@ -0,0 +1,69 @@
+import OAI.Algebra.OddKaplansky.CosetGreedy
+
+namespace OAI
+
+universe portUniverse1 portUniverse2 portUniverse3 portUniverse4
+
+section
+namespace OddKaplansky.OrderedSectorOrbit
+noncomputable section
+open scoped Classical BigOperators Matrix
+open WreathFourier
+variable {K : Type portUniverse1} {H : Type portUniverse2} [Field K] [Group H] [Fintype H] [LinearOrder H]
+local instance orderedSectorGreedyDecidableEq : DecidableEq H := Classical.decEq H
+variable (M : ℕ) [NeZero M] {ζ : K} (hζ : IsPrimitiveRoot ζ M)
+variable (p : ℕ) [Fact p.Prime] [CharP K p]
+variable (hcomm : ∀ r : Rep (H := H) M, ∀ s t : T M r, s*t=t*s)
+variable (hexp : ∀ r : Rep (H := H) M, ∀ t : T M r, t^p=1)
+variable (e : MonoidAlgebra K H) (he : e*e=e)
+variable {W : Type portUniverse3} {N : Type portUniverse4} [Fintype W] [LinearOrder W] [Fintype N] [LinearOrder N]
+variable (hw : Fintype.card W = Fintype.card H)
+variable (hn : Fintype.card N = Module.finrank K (LinearMap.range (Algebra.lmul K (MonoidAlgebra K H) e)))
+def blockJ (r : Rep (H := H) M) : Matrix W N (Block (K := K) M r) := by
+  letI : IsMulCommutative (T M r) := ⟨⟨hcomm r⟩⟩
+  exact OrderedCosetMatrix.explicitJ (T M r) p (hexp r) e he hw hn
+def blockY (r : Rep (H := H) M) : Matrix N W (Block (K := K) M r) := by
+  letI : IsMulCommutative (T M r) := ⟨⟨hcomm r⟩⟩
+  exact OrderedCosetMatrix.explicitY (T M r) p (hexp r) e he hw hn
+lemma block_products (r : Rep (H := H) M) :
+    blockY M p hcomm hexp e he hw hn r*blockJ M p hcomm hexp e he hw hn r=1 ∧
+    blockJ M p hcomm hexp e he hw hn r*blockY M p hcomm hexp e he hw hn r=Matrix.diagonal (fun _ : W => OrderedCosetMatrix.representation (T M r) e) := by
+  let : IsMulCommutative (T M r) := ⟨⟨hcomm r⟩⟩
+  have hs := OrderedCosetMatrix.explicit_products (T M r) p (hexp r) e he hw hn
+  constructor
+  · convert hs.1 using 1 <;> congr ; exact Subsingleton.elim _ _
+  · exact hs.2
+def explicitJ : Matrix W N (MonoidAlgebra K (Wreath (H := H) M)) := matrixPack M hζ (blockJ M p hcomm hexp e he hw hn)
+def explicitY : Matrix N W (MonoidAlgebra K (Wreath (H := H) M)) := matrixPack M hζ (blockY M p hcomm hexp e he hw hn)
+variable (hc : (Fintype.card (Base (H := H) M) : K) ≠ 0)
+variable (hm : (Fintype.card (Fourier.C M) : K) ≠ 0)
+include hc hm in
+lemma explicit_properties :
+    explicitY M hζ p hcomm hexp e he hw hn*explicitJ M hζ p hcomm hexp e he hw hn=Matrix.diagonal (fun _ => SectorFourier.f M hζ) ∧
+    explicitJ M hζ p hcomm hexp e he hw hn*explicitY M hζ p hcomm hexp e he hw hn=Matrix.diagonal (fun _ => SectorFourier.f M hζ * MonoidAlgebra.mapDomainAlgHom K K (top M) e) ∧
+    (∀ w n, SectorFourier.f M hζ * explicitJ M hζ p hcomm hexp e he hw hn w n=explicitJ M hζ p hcomm hexp e he hw hn w n) ∧
+    (∀ n w, SectorFourier.f M hζ * explicitY M hζ p hcomm hexp e he hw hn n w=explicitY M hζ p hcomm hexp e he hw hn n w) := by
+  have hYJ (r : Rep (H := H) M) := (block_products M p hcomm hexp e he hw hn r).1
+  have hJY (r : Rep (H := H) M) := (block_products M p hcomm hexp e he hw hn r).2
+  refine ⟨?_,?_,?_,?_⟩
+  · rw [explicitY,explicitJ,matrixPack_mul M hζ hc]
+    simp only [hYJ]
+    convert matrixPack_one M hζ hc hm using 1
+  · rw [explicitJ,explicitY,matrixPack_mul M hζ hc]
+    simp only [hJY]
+    funext w w'
+    simp only [matrixPack,Matrix.diagonal_apply]
+    by_cases h : w=w'
+    · simp only [h,ite_true,pack_representation M hζ hc e hm]
+    · simp only [ite_eq_right h]
+      exact map_zero _
+  · intro w n
+    exact pack_left_sector M hζ hc hm _
+  · intro n w
+    exact pack_left_sector M hζ hc hm _
+end
+end OddKaplansky.OrderedSectorOrbit
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/OddKaplansky/SectorGroup.lean b/lean/OAI/Algebra/OddKaplansky/SectorGroup.lean
new file mode 100644
index 0000000000000000000000000000000000000000..83d4d307aa7d0c2ae639f1ba8db0f53796e96318
--- /dev/null
+++ b/lean/OAI/Algebra/OddKaplansky/SectorGroup.lean
@@ -0,0 +1,160 @@
+import OAI.Algebra.OddKaplansky.AmalgamExtras
+
+namespace OAI
+
+section
+namespace OddKaplansky.SectorGroup
+noncomputable section
+open scoped Classical BigOperators
+open WreathFourier
+variable {I G₀ H : Type} [sectionInstance66 : Fintype I] [Group G₀] [Group H] [sectionInstance67 : Fintype H]
+variable (M : ℕ) [sectionInstance68 : NeZero M] (i : I → (H →* G₀))
+abbrev Attached := Wreath (H := H) M
+abbrev Common := Fourier.C M × H
+def toBase (j : I) : Common (H := H) M →* (Fourier.C M × G₀) :=
+  (MonoidHom.id (Fourier.C M)).prodMap (i j)
+def toAttached (_j : I) : Common (H := H) M →* Attached (H := H) M where
+  toFun a := ⟨fun _ => a.1,a.2⟩
+  map_one' := rfl
+  map_mul' a b := by ext <;> simp
+lemma toBase_injective
+    {I : Type}
+    {G₀ : Type}
+    {H : Type}
+    [Fintype.{0} I]
+    [contextInstance4 : Group.{0} G₀]
+    [contextInstance5 : Group.{0} H]
+    [Fintype.{0} H]
+    (M : Nat)
+    [@NeZero.{0} Nat (@MulZeroClass.toZero.{0} Nat Nat.instMulZeroClass) M]
+    (i : I →
+  @MonoidHom.{0, 0} H G₀
+    (@MulOneClass.toMulOne.{0} H
+      (@Monoid.toMulOneClass.{0} H (@DivInvMonoid.toMonoid.{0} H (@Group.toDivInvMonoid.{0} H contextInstance5))))
+    (@MulOneClass.toMulOne.{0} G₀
+      (@Monoid.toMulOneClass.{0} G₀ (@DivInvMonoid.toMonoid.{0} G₀ (@Group.toDivInvMonoid.{0} G₀ contextInstance4))))) (hi : ∀ j, Function.Injective (i j)) (j : I) : Function.Injective (toBase M i j) := by
+  intro a b he
+  change (a.1,i j a.2)=(b.1,i j b.2) at he
+  exact Prod.ext (congrArg (fun x : Fourier.C M × G₀ => x.1) he) (hi j (congrArg (fun x : Fourier.C M × G₀ => x.2) he))
+lemma toAttached_injective
+    {I : Type}
+    {H : Type}
+    [Fintype.{0} I]
+    [Group.{0} H]
+    [Fintype.{0} H]
+    (M : Nat)
+    [@NeZero.{0} Nat (@MulZeroClass.toZero.{0} Nat Nat.instMulZeroClass) M] (j : I) : Function.Injective (toAttached (H := H) M j) := by
+  intro a b he
+  exact Prod.ext (congrArg (fun g : Attached (H := H) M => g.left 1) he) (congrArg RegularWreathProduct.right he)
+abbrev G₁ := StarAmalgam.Amalgam (toBase M i) (toAttached (H := H) M)
+def base : (Fourier.C M × G₀) →* G₁ M i := StarAmalgam.ofBase (toBase M i) (toAttached (H := H) M)
+def factor (j : I) : Attached (H := H) M →* G₁ M i := StarAmalgam.ofFactor (toBase M i) (toAttached (H := H) M) j
+def original : G₀ →* G₁ M i := (base M i).comp (MonoidHom.inr _ _)
+def central : Fourier.C M →* G₁ M i := (base M i).comp (MonoidHom.inl _ _)
+lemma base_injective (hi : ∀ j, Function.Injective (i j)) : Function.Injective (base M i) :=
+  StarAmalgam.ofBase_injective _ _ (toBase_injective M i hi) (toAttached_injective M)
+lemma factor_injective (hi : ∀ j, Function.Injective (i j)) (j : I) : Function.Injective (factor M i j) :=
+  StarAmalgam.ofFactor_injective _ _ (toBase_injective M i hi) (toAttached_injective M) j
+lemma original_injective (hi : ∀ j, Function.Injective (i j)) : Function.Injective (original M i) := by
+  intro a b he
+  exact congrArg Prod.snd (base_injective M i hi he)
+lemma central_injective (hi : ∀ j, Function.Injective (i j)) : Function.Injective (central M i) := by
+  intro a b he
+  exact congrArg Prod.fst (base_injective M i hi he)
+lemma identify_top
+    {I : Type}
+    {G₀ : Type}
+    {H : Type}
+    [Fintype.{0} I]
+    [contextInstance4 : Group.{0} G₀]
+    [contextInstance5 : Group.{0} H]
+    [Fintype.{0} H]
+    (M : Nat)
+    [@NeZero.{0} Nat (@MulZeroClass.toZero.{0} Nat Nat.instMulZeroClass) M]
+    (i : I →
+  @MonoidHom.{0, 0} H G₀
+    (@MulOneClass.toMulOne.{0} H
+      (@Monoid.toMulOneClass.{0} H (@DivInvMonoid.toMonoid.{0} H (@Group.toDivInvMonoid.{0} H contextInstance5))))
+    (@MulOneClass.toMulOne.{0} G₀
+      (@Monoid.toMulOneClass.{0} G₀ (@DivInvMonoid.toMonoid.{0} G₀ (@Group.toDivInvMonoid.{0} G₀ contextInstance4))))) (j : I) (h : H) : original M i (i j h) = factor M i j (top M h) := by
+  convert StarAmalgam.identify (toBase M i) (toAttached (H := H) M) j (1,h) using 1 <;> rfl
+lemma identify_diagonal
+    {I : Type}
+    {G₀ : Type}
+    {H : Type}
+    [Fintype.{0} I]
+    [contextInstance4 : Group.{0} G₀]
+    [contextInstance5 : Group.{0} H]
+    [Fintype.{0} H]
+    (M : Nat)
+    [@NeZero.{0} Nat (@MulZeroClass.toZero.{0} Nat Nat.instMulZeroClass) M]
+    (i : I →
+  @MonoidHom.{0, 0} H G₀
+    (@MulOneClass.toMulOne.{0} H
+      (@Monoid.toMulOneClass.{0} H (@DivInvMonoid.toMonoid.{0} H (@Group.toDivInvMonoid.{0} H contextInstance5))))
+    (@MulOneClass.toMulOne.{0} G₀
+      (@Monoid.toMulOneClass.{0} G₀ (@DivInvMonoid.toMonoid.{0} G₀ (@Group.toDivInvMonoid.{0} G₀ contextInstance4))))) (j : I) (c : Fourier.C M) : central M i c = factor M i j (SectorFourier.diagonal M c) := by
+  simpa [central,base,factor,toBase,toAttached,SectorFourier.diagonal,SectorFourier.constant,WreathFourier.base] using StarAmalgam.identify (toBase M i) (toAttached (H := H) M) j (c,1)
+lemma central_commute
+    {I : Type}
+    {G₀ : Type}
+    {H : Type}
+    [Fintype.{0} I]
+    [contextInstance4 : Group.{0} G₀]
+    [contextInstance5 : Group.{0} H]
+    [Fintype.{0} H]
+    (M : Nat)
+    [@NeZero.{0} Nat (@MulZeroClass.toZero.{0} Nat Nat.instMulZeroClass) M]
+    (i : I →
+  @MonoidHom.{0, 0} H G₀
+    (@MulOneClass.toMulOne.{0} H
+      (@Monoid.toMulOneClass.{0} H (@DivInvMonoid.toMonoid.{0} H (@Group.toDivInvMonoid.{0} H contextInstance5))))
+    (@MulOneClass.toMulOne.{0} G₀
+      (@Monoid.toMulOneClass.{0} G₀ (@DivInvMonoid.toMonoid.{0} G₀ (@Group.toDivInvMonoid.{0} G₀ contextInstance4))))) (c : Fourier.C M) (g : G₁ M i) : Commute (central M i c) g := by
+  exact StarAmalgam.base_central (toBase M i) (toAttached (H := H) M) (c,1)
+    (fun h => by change (c,1)*h=h*(c,1); ext <;> simp [mul_comm])
+    (fun _ => (c,1)) (fun j => by simp [toBase])
+    (fun j h => SectorFourier.diagonal_central M c h) g
+instance [Group.FG G₀] : Group.FG (G₁ M i) := inferInstance
+variable {K : Type} [Field K] {ζ : K} (hζ : IsPrimitiveRoot ζ M)
+def f : MonoidAlgebra K (G₁ M i) := CharacterIdempotents.pushed (central M i) (Fourier.cyclicCharacter M hζ)
+lemma f_idempotent
+    {I : Type}
+    {G₀ : Type}
+    {H : Type}
+    [Fintype.{0} I]
+    [contextInstance4 : Group.{0} G₀]
+    [contextInstance5 : Group.{0} H]
+    [Fintype.{0} H]
+    (M : Nat)
+    [@NeZero.{0} Nat (@MulZeroClass.toZero.{0} Nat Nat.instMulZeroClass) M]
+    (i : I →
+  @MonoidHom.{0, 0} H G₀
+    (@MulOneClass.toMulOne.{0} H
+      (@Monoid.toMulOneClass.{0} H (@DivInvMonoid.toMonoid.{0} H (@Group.toDivInvMonoid.{0} H contextInstance5))))
+    (@MulOneClass.toMulOne.{0} G₀
+      (@Monoid.toMulOneClass.{0} G₀ (@DivInvMonoid.toMonoid.{0} G₀ (@Group.toDivInvMonoid.{0} G₀ contextInstance4)))))
+    {K : Type}
+    [contextInstance11 : Field.{0} K]
+    {ζ : K}
+    (hζ : @IsPrimitiveRoot.{0} K (@CommRing.toCommMonoid.{0} K (@Field.toCommRing.{0} K contextInstance11)) ζ M) (hm : (Fintype.card (Fourier.C M) : K) ≠ 0) : f M i hζ * f M i hζ=f M i hζ :=
+  CharacterIdempotents.pushed_idempotent _ _ hm
+lemma f_ne_zero (hi : ∀ j, Function.Injective (i j)) (hm : (Fintype.card (Fourier.C M) : K) ≠ 0) : f M i hζ ≠ 0 :=
+  CharacterIdempotents.pushed_ne_zero _ (central_injective M i hi) _ hm
+lemma f_central (a : MonoidAlgebra K (G₁ M i)) : Commute (f M i hζ) a :=
+  CharacterIdempotents.pushed_central _ _ (central_commute M i) a
+lemma factor_f (j : I) : MonoidAlgebra.mapDomainAlgHom K K (factor M i j) (SectorFourier.f M hζ) = f M i hζ := by
+  have he : (factor M i j).comp (SectorFourier.diagonal M) = central M i := MonoidHom.ext (fun c => (identify_diagonal M i j c).symm)
+  simp only [SectorFourier.f,f,CharacterIdempotents.pushed,] at *
+  rw [← AlgHom.comp_apply,← MonoidAlgebra.mapDomainAlgHom_comp,he]
+lemma factor_original (j : I) (e : MonoidAlgebra K H) :
+    MonoidAlgebra.mapDomainAlgHom K K (factor M i j) (MonoidAlgebra.mapDomainAlgHom K K (top M) e) =
+      MonoidAlgebra.mapDomainAlgHom K K (original M i) (MonoidAlgebra.mapDomainAlgHom K K (i j) e) := by
+  have he : (factor M i j).comp (top M) = (original M i).comp (i j) := MonoidHom.ext (fun h => (identify_top M i j h).symm)
+  rw [← AlgHom.comp_apply,← MonoidAlgebra.mapDomainAlgHom_comp,he,MonoidAlgebra.mapDomainAlgHom_comp,AlgHom.comp_apply]
+end
+end OddKaplansky.SectorGroup
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/OddKaplansky/SectorOrbit.lean b/lean/OAI/Algebra/OddKaplansky/SectorOrbit.lean
new file mode 100644
index 0000000000000000000000000000000000000000..41511adb2a9edc1b4d2d9788dd8e76c63498da2c
--- /dev/null
+++ b/lean/OAI/Algebra/OddKaplansky/SectorOrbit.lean
@@ -0,0 +1,101 @@
+import OAI.Algebra.OddKaplansky.SectorFourier
+
+namespace OAI
+
+universe portUniverse1 portUniverse2
+
+section
+namespace OddKaplansky.SectorOrbit
+noncomputable section
+open scoped Classical BigOperators Matrix
+open WreathFourier CosetCoordinates
+variable {K : Type portUniverse1} {H : Type portUniverse2} [Field K] [Group H] [Fintype H]
+variable (M : ℕ) [NeZero M] {ζ : K} (hζ : IsPrimitiveRoot ζ M)
+@[instance_reducible]
+def action : MulAction H (Base (H := H) M) where
+  smul g a := shift M g a
+  one_smul a := by change shift M 1 a=a; rw [shift_one]; rfl
+  mul_smul g h a := shift_mul M g h a
+local instance : MulAction H (Base (H := H) M) := action M
+abbrev Rep := OrbitSelection.Rep (H := H) (fun a : Base (H := H) M => SectorFourier.weight M a=1)
+def lmb (r : Rep (H := H) M) : Base (H := H) M := OrbitSelection.representative _ r
+lemma lmb_weight (r : Rep (H := H) M) : SectorFourier.weight M (lmb M r)=1 := (OrbitSelection.representative_spec _ r).2
+def T (r : Rep (H := H) M) : Subgroup H := MulAction.stabilizer H (lmb M r)
+lemma mem_T (r : Rep (H := H) M) (g : H) : g ∈ T M r ↔ shift M g (lmb M r)=lmb M r := Iff.rfl
+lemma separate {r s : Rep (H := H) M} (hrs : r≠s) (g : H) : lmb M r ≠ shift M g (lmb M s) := by
+  intro he
+  apply hrs
+  apply Subtype.ext
+  have hh : (Quotient.mk'' (lmb M r) : MulAction.orbitRel.Quotient H (Base (H := H) M)) = Quotient.mk'' (lmb M s) :=
+    Quotient.sound ⟨g,he.symm⟩
+  exact (OrbitSelection.representative_spec _ r).1.symm.trans (hh.trans (OrbitSelection.representative_spec _ s).1)
+def orbitMap (z : (r : Rep (H := H) M) × (H ⧸ T M r)) :
+    {a : Base (H := H) M // SectorFourier.weight M a=1} :=
+  ⟨shift M (rep (T M z.1) z.2) (lmb M z.1), (SectorFourier.weight_shift M _ _).trans (lmb_weight M _)⟩
+lemma orbitMap_injective : Function.Injective (orbitMap (H := H) M) := by
+  rintro ⟨r,q⟩ ⟨s,t⟩ he
+  have hv := congrArg Subtype.val he
+  have hrs : r=s := by
+    by_contra hn
+    apply separate M hn ((rep (T M r) q)⁻¹ * rep (T M s) t)
+    have hh := congrArg (shift M (rep (T M r) q)⁻¹) hv
+    simpa only [orbitMap,← shift_mul,inv_mul_cancel,shift_one,MulEquiv.refl_apply] using hh
+  subst s
+  have hqt := (OrbitBlock.shift_eq_iff M (lmb M r) (T M r) (mem_T M r) _ _).mp hv
+  rw [rep_mk,rep_mk] at hqt
+  exact Sigma.mk.inj_iff.mpr ⟨rfl,heq_of_eq hqt⟩
+lemma orbitMap_surjective : Function.Surjective (orbitMap (H := H) M) := by
+  intro a
+  obtain ⟨r,g,hg⟩ := OrbitSelection.cover (H := H) (fun a : Base (H := H) M => SectorFourier.weight M a=1) a.val a.property
+  have hg' : shift M g (lmb M r)=a.val := hg
+  refine ⟨⟨r,(g : H ⧸ T M r)⟩,?_⟩
+  apply Subtype.ext
+  change shift M (rep (T M r) (g : H ⧸ T M r)) (lmb M r)=a.val
+  rw [← hg']
+  exact (OrbitBlock.shift_eq_iff M (lmb M r) (T M r) (mem_T M r) _ _).mpr (rep_mk _ _)
+def orbitEquiv : ((r : Rep (H := H) M) × (H ⧸ T M r)) ≃
+    {a : Base (H := H) M // SectorFourier.weight M a=1} :=
+  Equiv.ofBijective (orbitMap M) ⟨orbitMap_injective M,orbitMap_surjective M⟩
+lemma identity_sum (hc : (Fintype.card (Base (H := H) M) : K) ≠ 0)
+    (hm : (Fintype.card (Fourier.C M) : K) ≠ 0) :
+    ∑ r : Rep (H := H) M, OrbitBlock.identity M hζ (lmb M r) (T M r) = SectorFourier.f M hζ := by
+  rw [SectorFourier.f_eq_packet M hζ hc hm]
+  have hh := Equiv.sum_comp (orbitEquiv (H := H) M) (fun a => projector M hζ a.val)
+  change (∑ z : (r : Rep (H := H) M) × (H ⧸ T M r), projector M hζ (shift M (rep (T M z.1) z.2) (lmb M z.1))) = _ at hh
+  simpa only [Fintype.sum_sigma,OrbitBlock.identity] using hh
+
+variable (hc : (Fintype.card (Base (H := H) M) : K) ≠ 0)
+abbrev Block (r : Rep (H := H) M) := Matrix (H ⧸ T M r) (H ⧸ T M r) (MonoidAlgebra K (T M r))
+def pack : ((r : Rep (H := H) M) → Block (K := K) M r) →ₗ[K] MonoidAlgebra K (Wreath (H := H) M) where
+  toFun F := ∑ r, OrbitBlock.lift M hζ (lmb M r) (T M r) (F r)
+  map_add' F G := by simp only [Pi.add_apply,map_add,Finset.sum_add_distrib]
+  map_smul' c F := by simp only [Pi.smul_apply,map_smul,RingHom.id_apply,Finset.smul_sum]
+lemma pack_apply (F : (r : Rep (H := H) M) → Block (K := K) M r) :
+    pack M hζ F = ∑ r, OrbitBlock.lift M hζ (lmb M r) (T M r) (F r) := rfl
+include hc in
+lemma pack_mul (F G : (r : Rep (H := H) M) → Block (K := K) M r) :
+    pack M hζ F * pack M hζ G = pack M hζ (fun r => F r*G r) := by
+  rw [pack_apply,pack_apply,Finset.sum_mul,pack_apply]
+  apply Finset.sum_congr rfl
+  intro r _
+  rw [Finset.mul_sum,Finset.sum_eq_single r]
+  · exact OrbitBlock.lift_mul M hζ hc (lmb M r) (T M r) (mem_T M r) (F r) (G r)
+  · intro s _ hsr
+    exact OrbitBlock.lift_cross M hζ hc (lmb M r) (T M r) (lmb M s) (T M s) (separate M hsr.symm) (F r) (G s)
+  · simp
+include hc in
+lemma pack_one (hm : (Fintype.card (Fourier.C M) : K) ≠ 0) :
+    pack (H := H) M hζ (fun _ => 1) = SectorFourier.f M hζ := by
+  simp only [pack_apply,OrbitBlock.lift_one]
+  exact identity_sum M hζ hc hm
+include hc in
+lemma pack_representation (e : MonoidAlgebra K H) (hm : (Fintype.card (Fourier.C M) : K) ≠ 0) :
+    pack M hζ (fun r => CosetMatrix.representation (T M r) e) =
+      SectorFourier.f M hζ * MonoidAlgebra.mapDomainAlgHom K K (top M) e := by
+  simp only [pack_apply,OrbitBlock.lift_representation,← Finset.sum_mul,identity_sum M hζ hc hm]
+end
+end OddKaplansky.SectorOrbit
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/OddKaplansky/SectorRectangles.lean b/lean/OAI/Algebra/OddKaplansky/SectorRectangles.lean
new file mode 100644
index 0000000000000000000000000000000000000000..fc915158c86c123a26db9fd05b4c8c546a373f7f
--- /dev/null
+++ b/lean/OAI/Algebra/OddKaplansky/SectorRectangles.lean
@@ -0,0 +1,83 @@
+import OAI.Algebra.OddKaplansky.CosetRectangles
+
+namespace OAI
+
+universe portUniverse1 portUniverse2 portUniverse3 portUniverse4 portUniverse5 portUniverse6 portUniverse7 portUniverse8 portUniverse9 portUniverse10
+
+section
+namespace OddKaplansky.SectorOrbit
+noncomputable section
+open scoped Classical BigOperators Matrix
+open WreathFourier
+variable {K : Type portUniverse1} {H : Type portUniverse2} [Field K] [Group H] [Fintype H]
+variable (M : ℕ) [NeZero M] {ζ : K} (hζ : IsPrimitiveRoot ζ M)
+variable (hc : (Fintype.card (Base (H := H) M) : K) ≠ 0)
+variable (hm : (Fintype.card (Fourier.C M) : K) ≠ 0)
+def matrixPack {W : Type portUniverse3} {N : Type portUniverse4} (F : (r : Rep (H := H) M) → Matrix W N (Block (K := K) M r)) :
+    Matrix W N (MonoidAlgebra K (Wreath (H := H) M)) := fun w n => pack M hζ (fun r => F r w n)
+include hc in
+lemma matrixPack_mul {W : Type portUniverse5} {N : Type portUniverse6} {V : Type portUniverse7} [Fintype N]
+    (F : (r : Rep (H := H) M) → Matrix W N (Block (K := K) M r))
+    (G : (r : Rep (H := H) M) → Matrix N V (Block (K := K) M r)) :
+    matrixPack M hζ F * matrixPack M hζ G = matrixPack M hζ (fun r => F r*G r) := by
+  funext w v
+  simp only [Matrix.mul_apply,matrixPack,pack_mul M hζ hc]
+  rw [← map_sum]
+  congr 1
+  funext r
+  simp only [Finset.sum_apply,]
+include hc hm in
+lemma matrixPack_one {N : Type portUniverse8} [DecidableEq N] :
+    matrixPack (H := H) M hζ (fun _ => (1 : Matrix N N _)) = Matrix.diagonal (fun _ : N => SectorFourier.f M hζ) := by
+  funext n n'
+  simp only [matrixPack,Matrix.one_apply,Matrix.diagonal_apply]
+  by_cases h : n=n'
+  · simp only [h,ite_true,pack_one M hζ hc hm]
+  · simp only [ite_eq_right h]
+    exact map_zero _
+include hc hm in
+lemma pack_left_sector (F : (r : Rep (H := H) M) → Block (K := K) M r) :
+    SectorFourier.f M hζ * pack M hζ F = pack M hζ F := by
+  rw [← pack_one M hζ hc hm,pack_mul M hζ hc]
+  simp only [one_mul]
+include hc hm in
+lemma rectangular (p : ℕ) [Fact p.Prime] [CharP K p]
+    (hcomm : ∀ r : Rep (H := H) M, ∀ s t : T M r, s*t=t*s)
+    (hexp : ∀ r : Rep (H := H) M, ∀ t : T M r, t^p=1)
+    (e : MonoidAlgebra K H) (he : e*e=e)
+    {W : Type portUniverse9} {N : Type portUniverse10} [Fintype W] [Fintype N]
+    (hw : Fintype.card W = Fintype.card H)
+    (hn : Fintype.card N = Module.finrank K (LinearMap.range (Algebra.lmul K (MonoidAlgebra K H) e))) :
+    ∃ (J : Matrix W N (MonoidAlgebra K (Wreath (H := H) M)))
+      (Y : Matrix N W (MonoidAlgebra K (Wreath (H := H) M))),
+      Y*J=Matrix.diagonal (fun _ => SectorFourier.f M hζ) ∧
+      J*Y=Matrix.diagonal (fun _ => SectorFourier.f M hζ * MonoidAlgebra.mapDomainAlgHom K K (top M) e) ∧
+      (∀ w n, SectorFourier.f M hζ * J w n=J w n) ∧
+      (∀ n w, SectorFourier.f M hζ * Y n w=Y n w) := by
+  have hall (r : Rep (H := H) M) : ∃ (J : Matrix W N (Block (K := K) M r)) (Y : Matrix N W (Block (K := K) M r)),
+      Y*J=1 ∧ J*Y=Matrix.diagonal (fun _ => CosetMatrix.representation (T M r) e) := by
+    let : IsMulCommutative (T M r) := ⟨⟨hcomm r⟩⟩
+    exact CosetMatrix.representation_rectangular (T M r) p (hexp r) e he hw hn
+  choose J Y hYJ hJY using hall
+  refine ⟨matrixPack M hζ J,matrixPack M hζ Y,?_,?_,?_,?_⟩
+  · rw [matrixPack_mul M hζ hc]
+    simp only [hYJ]
+    exact matrixPack_one M hζ hc hm
+  · rw [matrixPack_mul M hζ hc]
+    simp only [hJY]
+    funext w w'
+    simp only [matrixPack,Matrix.diagonal_apply]
+    by_cases h : w=w'
+    · simp only [h,ite_true,pack_representation M hζ hc e hm]
+    · simp only [ite_eq_right h]
+      exact map_zero _
+  · intro w n
+    exact pack_left_sector M hζ hc hm _
+  · intro n w
+    exact pack_left_sector M hζ hc hm _
+end
+end OddKaplansky.SectorOrbit
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/OddKaplansky/SectorStabilizer.lean b/lean/OAI/Algebra/OddKaplansky/SectorStabilizer.lean
new file mode 100644
index 0000000000000000000000000000000000000000..44392a086420900ea0eeb984bc62890c41005905
--- /dev/null
+++ b/lean/OAI/Algebra/OddKaplansky/SectorStabilizer.lean
@@ -0,0 +1,66 @@
+import OAI.Algebra.OddKaplansky.SectorRectangles
+
+namespace OAI
+
+universe portUniverse1
+
+section
+namespace OddKaplansky.SectorStabilizer
+noncomputable section
+open scoped Classical BigOperators
+variable {G : Type portUniverse1} [Group G] (M : ℕ)
+def stabilizer (a : G → ZMod M) : Subgroup G where
+  carrier := {g | ∀ x, a (g*x)=a x}
+  one_mem' x := by simp
+  mul_mem' hg hh x := by rw [mul_assoc,hg,hh]
+  inv_mem' {g} hg x := by have h := hg (g⁻¹*x); simpa only [mul_inv_cancel_left] using h.symm
+variable (p : ℕ) [sectionInstance55 : NeZero p] [sectionInstance56 : NeZero M]
+abbrev Point := Multiplicative (Fin 3 → ZMod p)
+abbrev H := RegularWreathProduct (Multiplicative (ZMod M)) (Point p)
+instance : Fintype (H M p) := Fintype.ofFinite _
+def baseHom : (Point p → Multiplicative (ZMod M)) →* H M p where
+  toFun a := ⟨a,1⟩
+  map_one' := rfl
+  map_mul' a b := by ext x <;> simp
+lemma base_pow
+    (M : Nat)
+    (p : Nat)
+    [@NeZero.{0} Nat (@MulZeroClass.toZero.{0} Nat Nat.instMulZeroClass) p]
+    [@NeZero.{0} Nat (@MulZeroClass.toZero.{0} Nat Nat.instMulZeroClass) M] (a : Point p → Multiplicative (ZMod M)) : a^M=1 := by
+  funext x
+  apply Multiplicative.toAdd.injective
+  simp
+lemma pow_of_right (g : H M p) (h : g.right=1) : g^M=1 := by
+  have hg : g=baseHom M p g.left := by ext <;> simp [baseHom,h]
+  rw [hg,← map_pow,base_pow,map_one]
+variable (a : H M p → ZMod M) (ha : ∑ g, a g = 1)
+def toPoint : stabilizer M a →* Point p := RegularWreathProduct.rightHom.comp (stabilizer M a).subtype
+include ha in
+lemma toPoint_kernel (g : stabilizer M a) (hg : toPoint M p a g = 1) : g=1 := by
+  apply Subtype.ext
+  exact CosetCoordinates.eq_one_of_power_and_sum M a ha g g.property (pow_of_right M p g hg)
+include ha in
+lemma toPoint_injective : Function.Injective (toPoint M p a) := by
+  intro x y h
+  have hxy : toPoint M p a (x*y⁻¹)=1 := by rw [map_mul,map_inv,h,mul_inv_cancel]
+  exact mul_inv_eq_one.mp (toPoint_kernel M p a ha _ hxy)
+include ha in
+lemma commutative (x y : stabilizer M a) : x*y=y*x := by
+  apply toPoint_injective M p a ha
+  rw [map_mul,map_mul,mul_comm]
+@[instance_reducible]
+def commGroup (ha : ∑ g, a g=1) : CommGroup (stabilizer M a) :=
+  { (inferInstance : Group (stabilizer M a)) with mul_comm := commutative M p a ha }
+include ha in
+lemma exponent (x : stabilizer M a) : x^p=1 := by
+  apply toPoint_injective M p a ha
+  rw [map_pow,map_one]
+  apply Multiplicative.toAdd.injective
+  funext i
+  simp
+end
+end OddKaplansky.SectorStabilizer
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/OddKaplansky/SimplexCount.lean b/lean/OAI/Algebra/OddKaplansky/SimplexCount.lean
new file mode 100644
index 0000000000000000000000000000000000000000..31d7714852bb57ec7bc61a52bd787309fd1d7c60
--- /dev/null
+++ b/lean/OAI/Algebra/OddKaplansky/SimplexCount.lean
@@ -0,0 +1,78 @@
+import OAI.Algebra.OddKaplansky.AugmentationMatrices
+
+namespace OAI
+
+section
+namespace OddKaplansky.SimplexCount
+noncomputable section
+open scoped Classical BigOperators
+
+abbrev Triangle (ell : ℕ) := Σ a : Fin ell, Fin (ell-a.val)
+abbrev Tetrahedron (ell : ℕ) := Σ a : Fin ell, Triangle (ell-a.val)
+
+lemma card_triangle_succ (ell : ℕ) : Fintype.card (Triangle (ell+1)) = ell+1+Fintype.card (Triangle ell) := by
+  simp only [Triangle, Fintype.card_sigma, Fintype.card_fin, Fin.sum_univ_succ,
+    Fin.val_zero, Nat.sub_zero, Fin.val_succ, Nat.add_sub_add_right]
+lemma card_tetrahedron_succ (ell : ℕ) : Fintype.card (Tetrahedron (ell+1)) =
+    Fintype.card (Triangle (ell+1))+Fintype.card (Tetrahedron ell) := by
+  conv_lhs => rw [Fintype.card_sigma]
+  conv_rhs => arg 2; rw [Fintype.card_sigma]
+  rw [Fin.sum_univ_succ]
+  simp only [Fin.val_zero, Nat.sub_zero, Fin.val_succ, Nat.add_sub_add_right]
+  rfl
+
+lemma card_triangle (ell : ℕ) : Fintype.card (Triangle ell) = (ell+1).choose 2 := by
+  induction ell with
+  | zero => simp [Triangle]
+  | succ ell ih =>
+    rw [card_triangle_succ,ih]
+    simpa [Nat.choose_one_right,add_comm] using (Nat.choose_succ_succ (ell+1) 1).symm
+lemma card_tetrahedron (ell : ℕ) : Fintype.card (Tetrahedron ell) = (ell+2).choose 3 := by
+  induction ell with
+  | zero => simp [Tetrahedron]
+  | succ ell ih =>
+    rw [card_tetrahedron_succ,card_triangle,ih]
+    simpa [add_comm,add_left_comm,add_assoc] using (Nat.choose_succ_succ (ell+2) 2).symm
+
+abbrev Deficit (p ell : ℕ) := {a : Fin 3 → Fin p // ∑ i, (a i).val < ell}
+
+def deficitEquiv (p ell : ℕ) (hl : ell ≤ p) : Deficit p ell ≃ Tetrahedron ell where
+  toFun a := by
+    have ha := a.property
+    simp [Fin.sum_univ_succ] at ha
+    refine ⟨⟨(a.val 0).val, by omega⟩, ⟨⟨(a.val 1).val, ?_⟩, ⟨(a.val 2).val, ?_⟩⟩⟩
+    · change (a.val 1).val < ell - (a.val 0).val
+      omega
+    · change (a.val 2).val < ell - (a.val 0).val - (a.val 1).val
+      omega
+  invFun a := ⟨![⟨a.1.val, a.1.isLt.trans_le hl⟩,
+    ⟨a.2.1.val, by have := a.2.1.isLt; omega⟩,
+    ⟨a.2.2.val, by have := a.2.2.isLt; omega⟩],by
+      have := a.1.isLt; have := a.2.1.isLt; have := a.2.2.isLt
+      simp only [Fin.sum_univ_succ,Matrix.cons_val_zero,Matrix.cons_val_succ,
+        Matrix.cons_val_fin_one,Finset.univ_eq_empty,Finset.sum_empty,add_zero]
+      omega⟩
+  left_inv a := by ext i; fin_cases i <;> rfl
+  right_inv a := by rcases a with ⟨a,b,c⟩; rfl
+
+lemma card_deficit (p ell : ℕ) (hl : ell ≤ p) : Fintype.card (Deficit p ell) = (ell+2).choose 3 := by
+  rw [Fintype.card_congr (deficitEquiv p ell hl),card_tetrahedron]
+
+lemma twice_triangle (ell : ℕ) : 2*Fintype.card (Triangle ell) = ell*(ell+1) := by
+  induction ell with
+  | zero => simp [Triangle]
+  | succ ell ih => rw [card_triangle_succ]; nlinarith
+lemma six_tetrahedron (ell : ℕ) : 6*Fintype.card (Tetrahedron ell) = ell*(ell+1)*(ell+2) := by
+  induction ell with
+  | zero => simp [Tetrahedron]
+  | succ ell ih =>
+    rw [card_tetrahedron_succ]
+    have h := twice_triangle (ell+1)
+    nlinarith
+
+end
+end OddKaplansky.SimplexCount
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/OddKaplansky/SourceFit.lean b/lean/OAI/Algebra/OddKaplansky/SourceFit.lean
new file mode 100644
index 0000000000000000000000000000000000000000..e998160abc463f21f5181b86a6de093ec4a81fcb
--- /dev/null
+++ b/lean/OAI/Algebra/OddKaplansky/SourceFit.lean
@@ -0,0 +1,96 @@
+import OAI.Algebra.OddKaplansky.GraphNumerics
+
+namespace OAI
+
+universe contextUniverse1
+
+universe portUniverse1
+
+section
+
+namespace OddKaplansky.SourceFit
+noncomputable section
+open scoped Classical BigOperators
+open SourceGraph
+variable {K : Type portUniverse1} [Field K]
+variable (p : ℕ) [sectionInstance8 : Fact p.Prime] [CharP K p] (hp : 1200 < p)
+
+abbrev Slot := {T : Finset (Fin 1200) // T.card ≤ 400}
+def polynomial (j : Vertex) : MvPolynomial (Fin 1200) K :=
+  GraphPolynomial.polynomial j.val 600 200 600
+
+def alpha (i : Vertex) (T : Slot) : K := if T.val ⊆ i.val then 1 else 0
+def beta (j : Vertex) (T : Slot) : K := BooleanPolynomial.coefficient (polynomial j) T.val
+
+def fitting (i j : Vertex) : K := ∑ T : Slot, alpha i T * beta j T
+
+lemma fitting_eq (i j : Vertex) : fitting (K := K) i j =
+    ∏ k ∈ Finset.Ico (200 : ℕ) 600, (((i.val ∩ j.val).card : K) - (k : K)) / ((600-k : ℕ) : K) := by
+  simp only [fitting, alpha, beta]
+  have hdeg : (polynomial (K := K) j).totalDegree ≤ 400 := GraphPolynomial.degree_polynomial _ _ _ _
+  trans MvPolynomial.eval (BooleanPolynomial.value i.val) (polynomial (K := K) j)
+  · exact (BooleanPolynomial.evaluate (polynomial j) i.val 400 hdeg).symm
+  rw [polynomial, GraphPolynomial.eval_polynomial]
+  simp only [Finset.inter_comm]
+
+lemma denominator
+    {K : Type contextUniverse1}
+    [contextInstance1 : Field.{contextUniverse1} K]
+    (p : Nat)
+    [Fact (Nat.Prime p)]
+    [@CharP.{contextUniverse1} K
+  (@AddGroupWithOne.toAddMonoidWithOne.{contextUniverse1} K
+    (@Ring.toAddGroupWithOne.{contextUniverse1} K (@DivisionRing.toRing.{contextUniverse1} K (@Field.toDivisionRing.{contextUniverse1} K contextInstance1))))
+  p]
+    (hp : @LT.lt.{0} Nat instLTNat (@OfNat.ofNat.{0} Nat (nat_lit 1200) (instOfNatNat (nat_lit 1200))) p) (k : ℕ) (hk : k ∈ Finset.Ico 200 600) : ((600-k : ℕ) : K) ≠ 0 := by
+  have hk₁ : 0 < 600-k := by have := Finset.mem_Ico.mp hk; omega
+  have hk₂ : 600-k < p := by omega
+  exact (CharP.cast_eq_zero_iff K p (600-k)).not.mpr (Nat.not_dvd_of_pos_of_lt hk₁ hk₂)
+
+include hp in
+lemma fitting_diagonal (i : Vertex) : fitting (K := K) i i = 1 := by
+  have hdeg : (polynomial (K := K) i).totalDegree ≤ 400 := GraphPolynomial.degree_polynomial _ _ _ _
+  simp only [fitting, alpha, beta]
+  trans MvPolynomial.eval (BooleanPolynomial.value i.val) (polynomial (K := K) i)
+  · exact (BooleanPolynomial.evaluate (polynomial i) i.val 400 hdeg).symm
+  exact GraphPolynomial.diagonal i.val 600 200 600 i.property (by omega) (denominator p hp)
+
+lemma intersection_lt (i j : Vertex) (hij : i ≠ j) : (i.val ∩ j.val).card < 600 := by
+  have hle : (i.val ∩ j.val).card ≤ 600 := by
+    rw [← i.property]
+    exact Finset.card_le_card Finset.inter_subset_left
+  by_contra hn
+  have hecard : (i.val ∩ j.val).card = i.val.card := by rw [i.property]; omega
+  have he : i.val ∩ j.val = i.val := Finset.eq_of_subset_of_card_le Finset.inter_subset_left hecard.ge
+  have hij' : i.val ⊆ j.val := by rw [← he]; exact Finset.inter_subset_right
+  exact hij (Vertex.ext (Finset.eq_of_subset_of_card_le hij' (by rw [i.property,j.property])))
+
+lemma fitting_nonedge (i j : Vertex) (hij : i ≠ j) (hn : ¬ graph.Adj i j) :
+    fitting (K := K) i j = 0 := by
+  have hlo : 200 ≤ (j.val ∩ i.val).card := by
+    rw [Finset.inter_comm]
+    by_contra hh
+    apply hn
+    exact ⟨hij,by omega⟩
+  have hhi : (j.val ∩ i.val).card < 600 := intersection_lt j i hij.symm
+  have hdeg : (polynomial (K := K) j).totalDegree ≤ 400 := GraphPolynomial.degree_polynomial _ _ _ _
+  simp only [fitting, alpha, beta]
+  trans MvPolynomial.eval (BooleanPolynomial.value i.val) (polynomial (K := K) j)
+  · exact (BooleanPolynomial.evaluate (polynomial j) i.val 400 hdeg).symm
+  exact GraphPolynomial.vanishes j.val i.val 600 200 600 hlo hhi
+
+lemma card_slots : Fintype.card Slot = ∑ k ∈ Finset.range 401, Nat.choose 1200 k := by
+  have he := GraphNumerics.card_small_sets (Fin 1200) 400
+  simpa only [Fintype.card_fin] using he
+
+lemma ratio_bound : 100 * Fintype.card Slot < sourceM := by
+  rw [card_slots]
+  unfold sourceM
+  exact GraphNumerics.source_ratio_bound
+
+end
+end OddKaplansky.SourceFit
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/OddKaplansky/SourceGluing.lean b/lean/OAI/Algebra/OddKaplansky/SourceGluing.lean
new file mode 100644
index 0000000000000000000000000000000000000000..a7d5a4da08a5c25a70f681b4d65b15afb61d0c4c
--- /dev/null
+++ b/lean/OAI/Algebra/OddKaplansky/SourceGluing.lean
@@ -0,0 +1,78 @@
+import OAI.Algebra.OddKaplansky.LocalGroup
+
+namespace OAI
+
+section
+
+namespace OddKaplansky.SourceGluing
+noncomputable section
+open scoped Classical
+open SourceGraph
+
+def pDefinition : ℕ := sourcePrime
+opaque pWrapped : Subtype (Eq pDefinition) := ⟨_, rfl⟩
+
+def p : ℕ := pWrapped.1
+theorem p_def : p = sourcePrime := by
+  delta p
+  rw [show pWrapped = ⟨pDefinition, rfl⟩ from Subtype.ext pWrapped.2.symm]
+  rfl
+attribute [irreducible] p pDefinition
+attribute [eqns p_def] p
+lemma p_prime : p.Prime := by rw [p_def]; exact sourcePrime_prime
+lemma p_gt : sourceM < p := by rw [p_def]; exact sourcePrime_gt
+
+instance : Fact p.Prime := ⟨p_prime⟩
+instance : NeZero p := ⟨p_prime.ne_zero⟩
+@[irreducible] def modulus : ℕ := p ^ 4 - 1
+lemma modulus_gt : 1 < modulus := by
+  have hp : 3 ≤ p := by have := p_gt; have := sourceM_large; omega
+  have h : 81 ≤ p ^ 4 := Nat.pow_le_pow_left hp 4
+  unfold modulus
+  omega
+instance : NeZero modulus := ⟨by have := modulus_gt; omega⟩
+abbrev H := LocalGroup p modulus
+
+def edgeHom (v : Vertex) (e : Edge) : Multiplicative (ZMod p) →* H :=
+  LocalGroup.edgeHom p modulus (decide (v = e.val.1)) (index (neighbor v e))
+
+lemma neighbor_cast_injective (v : Vertex) : Function.Injective (fun e : {e : Edge // Inc v e} =>
+    (index (neighbor v e.val) : ZMod p)) := by
+  intro e f hef
+  apply GraphEdges.neighbor_injective graph v
+  apply index_injective
+  have h₁ : index (neighbor v e.val) < p := (index_le _).trans_lt p_gt
+  have h₂ : index (neighbor v f.val) < p := (index_le _).trans_lt p_gt
+  have hh := congrArg ZMod.val hef
+  simpa only [ZMod.val_natCast, Nat.mod_eq_of_lt h₁, Nat.mod_eq_of_lt h₂] using hh
+
+lemma shortWords : Planar.ShortWords Inc edgeHom where
+  one v f _ a ha := LocalGroup.edge_word_one _ _ _ _ _ ha
+  two v f g hf hg hfg a b ha _ := by
+    apply LocalGroup.edge_word_two _ _ _ _ _ _ _ _ ha
+    intro h
+    exact hfg (congrArg Subtype.val (neighbor_cast_injective v (a₁ := ⟨f,hf⟩) (a₂ := ⟨g,hg⟩) h))
+  three v f g h hf hg hh hfg _ hhf a b c ha _ _ := by
+    have h₁ : (index (neighbor v f) : ZMod p) ≠ index (neighbor v g) := by
+      intro he
+      exact hfg (congrArg Subtype.val (neighbor_cast_injective v (a₁ := ⟨f,hf⟩)
+        (a₂ := ⟨g,hg⟩) he))
+    have h₂ : (index (neighbor v f) : ZMod p) ≠ index (neighbor v h) := by
+      intro he
+      exact hhf (congrArg Subtype.val (neighbor_cast_injective v (a₁ := ⟨f,hf⟩)
+        (a₂ := ⟨h,hh⟩) he)).symm
+    exact LocalGroup.edge_word_three _ _ _ _ _ _ _ _ _ _ _ ha h₁ h₂
+
+abbrev G₀ := Gluing.Q Inc edgeHom
+def vertex (v : Vertex) : H →* G₀ := Gluing.vertex Inc edgeHom v
+lemma vertex_injective (v : Vertex) : Function.Injective (vertex v) :=
+  Gluing.vertex_injective Inc edgeHom (GraphEdges.incident_exists graph) shortWords incidence_girth v
+
+instance : Group.FG G₀ := inferInstance
+
+end
+end OddKaplansky.SourceGluing
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/OddKaplansky/SourceSector.lean b/lean/OAI/Algebra/OddKaplansky/SourceSector.lean
new file mode 100644
index 0000000000000000000000000000000000000000..ab1c2022568c114c7061f0b3910c6bec55c19f06
--- /dev/null
+++ b/lean/OAI/Algebra/OddKaplansky/SourceSector.lean
@@ -0,0 +1,52 @@
+import OAI.Algebra.OddKaplansky.SectorStabilizer
+
+namespace OAI
+
+universe portUniverse1 portUniverse2 portUniverse3
+
+section
+namespace OddKaplansky.SourceSector
+noncomputable section
+open scoped Classical BigOperators Matrix
+open WreathFourier SectorOrbit
+lemma T_leftFixed {H : Type portUniverse1} [Group H] [Fintype H] (M : ℕ) [NeZero M] (r : Rep (H := H) M) :
+    T M r = SectorStabilizer.stabilizer M (fun x => (lmb M r x).toAdd) := by
+  ext g
+  rw [mem_T]
+  constructor
+  · intro he x
+    have hh := congrArg (fun a : Base (H := H) M => (a (g*x)).toAdd) he
+    simpa only [shift_apply,inv_mul_cancel_left] using hh.symm
+  · intro hg
+    funext x
+    apply Multiplicative.toAdd.injective
+    have hh := hg (g⁻¹*x)
+    simpa only [shift_apply,mul_inv_cancel_left] using hh.symm
+variable {K : Type} [Field K] (M p : ℕ) [NeZero M] [Fact p.Prime] [CharP K p]
+variable {ζ : K} (hζ : IsPrimitiveRoot ζ M)
+include hζ in
+lemma rectangular (hc : (Fintype.card (Base (H := SectorStabilizer.H M p) M) : K) ≠ 0)
+    (hm : (Fintype.card (Fourier.C M) : K) ≠ 0)
+    (e : MonoidAlgebra K (SectorStabilizer.H M p)) (he : e*e=e)
+    {W : Type portUniverse2} {N : Type portUniverse3} [Fintype W] [Fintype N]
+    (hw : Fintype.card W = Fintype.card (SectorStabilizer.H M p))
+    (hn : Fintype.card N = Module.finrank K (LinearMap.range (Algebra.lmul K _ e))) :
+    ∃ (J : Matrix W N (MonoidAlgebra K (Wreath (H := SectorStabilizer.H M p) M)))
+      (Y : Matrix N W (MonoidAlgebra K (Wreath (H := SectorStabilizer.H M p) M))),
+      Y*J=Matrix.diagonal (fun _ => SectorFourier.f M hζ) ∧
+      J*Y=Matrix.diagonal (fun _ => SectorFourier.f M hζ * MonoidAlgebra.mapDomainAlgHom K K (top M) e) ∧
+      (∀ w n, SectorFourier.f M hζ * J w n=J w n) ∧
+      (∀ n w, SectorFourier.f M hζ * Y n w=Y n w) := by
+  apply SectorOrbit.rectangular M hζ hc hm p _ _ e he hw hn
+  · intro r
+    rw [T_leftFixed]
+    exact SectorStabilizer.commutative M p (fun x => (lmb M r x).toAdd) (lmb_weight M r)
+  · intro r
+    rw [T_leftFixed]
+    exact SectorStabilizer.exponent M p (fun x => (lmb M r x).toAdd) (lmb_weight M r)
+end
+end OddKaplansky.SourceSector
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/OddKaplansky/SquareCertificate.lean b/lean/OAI/Algebra/OddKaplansky/SquareCertificate.lean
new file mode 100644
index 0000000000000000000000000000000000000000..c4971d7e7c6ebf86751a85ad759faf7068b3344b
--- /dev/null
+++ b/lean/OAI/Algebra/OddKaplansky/SquareCertificate.lean
@@ -0,0 +1,107 @@
+import OAI.Algebra.OddKaplansky.Compression
+
+namespace OAI
+
+universe contextUniverse1 contextUniverse2 contextUniverse3
+
+universe portUniverse1 portUniverse2 portUniverse3
+
+section
+namespace OddKaplansky.SquareCertificate
+noncomputable section
+open scoped Classical BigOperators Matrix
+variable {S : Type portUniverse1} {R : Type portUniverse2} {N : Type portUniverse3} [Ring S] [Fintype R] [sectionInstance75 : Fintype N]
+def cutD (σ : R → N) (D : Matrix N R S) : Matrix R R S := fun i j => D (σ i) j
+def cutC (σ : R → N) (C : Matrix R N S) : Matrix R R S := fun i j => C i (σ j)
+def A (f : S) (σ : R → N) (D : Matrix N R S) : Matrix R R S := cutD σ D + Matrix.diagonal (fun _ => 1-f)
+def B (f : S) (σ : R → N) (C : Matrix R N S) : Matrix R R S := cutC σ C + Matrix.diagonal (fun _ => 1-f)
+lemma sector_right (f x : S) (hc : Commute f x) (hx : f*x=x) : x*f=x := hc.eq.symm.trans hx
+lemma complement_left (f x : S) (hx : f*x=x) : (1-f)*x=0 := by rw [sub_mul,one_mul,hx,sub_self]
+lemma complement_right (f x : S) (hx : x*f=x) : x*(1-f)=0 := by rw [mul_sub,mul_one,hx,sub_self]
+lemma products
+    {S : Type contextUniverse1}
+    {R : Type contextUniverse2}
+    {N : Type contextUniverse3}
+    [Ring.{contextUniverse1} S]
+    [Fintype.{contextUniverse2} R]
+    [Fintype.{contextUniverse3} N] (f : S) (hf : f*f=f) (hc : ∀ x, Commute f x)
+    (σ : R → N) (hσ : Function.Injective σ) (C : Matrix R N S) (D : Matrix N R S)
+    (hC : ∀ i j, f*C i j=C i j) (hD : ∀ i j, f*D i j=D i j)
+    (hDC : D*C=Matrix.diagonal (fun _ => f)) : A f σ D * B f σ C=1 := by
+  have hDC' : cutD σ D*cutC σ C=Matrix.diagonal (fun _ => f) := by
+    funext i j
+    change (D*C) (σ i) (σ j)=_
+    rw [hDC]
+    simp [Matrix.diagonal_apply,hσ.eq_iff]
+  have hleft : Matrix.diagonal (fun _ : R => 1-f)*cutC σ C=0 := by
+    funext i j
+    rw [Matrix.diagonal_mul]
+    exact complement_left f _ (hC i (σ j))
+  have hright : cutD σ D*Matrix.diagonal (fun _ : R => 1-f)=0 := by
+    funext i j
+    rw [Matrix.mul_diagonal]
+    exact complement_right f _ (sector_right f _ (hc _) (hD (σ i) j))
+  have hcomp : Matrix.diagonal (fun _ : R => 1-f)*Matrix.diagonal (fun _ : R => 1-f)=Matrix.diagonal (fun _ : R => 1-f) := by
+    rw [Matrix.diagonal_mul_diagonal]
+    congr 1
+    funext i
+    noncomm_ring [hf]
+  rw [A,B,add_mul,mul_add,mul_add,hDC',hleft,hright,hcomp]
+  funext i j
+  by_cases he : i=j <;> simp [he,Matrix.one_apply]
+
+def u (f : S) (a : N) : N → S := Pi.single a f
+def v (f : S) (C : Matrix R N S) (a : N) : R → S := C *ᵥ u f a
+lemma certificate (f : S) (hf : f*f=f) (hf0 : f ≠ 0) (_hc : ∀ x, Commute f x)
+    (σ : R → N) (C : Matrix R N S) (D : Matrix N R S)
+    (hC : ∀ i j, f*C i j=C i j)
+    (hDC : D*C=Matrix.diagonal (fun _ => f)) (a : N) (ha : ∀ i, σ i ≠ a) :
+    v f C a ≠ 0 ∧ D *ᵥ v f C a=u f a ∧ A f σ D *ᵥ v f C a=0 ∧ (B f σ C*A f σ D-1)*ᵥ v f C a = -v f C a := by
+  have hDu : D *ᵥ v f C a=u f a := by
+    rw [v,Matrix.mulVec_mulVec,hDC]
+    funext i
+    simp only [Matrix.mulVec_diagonal,u]
+    by_cases hi : i=a
+    · subst i; simp [hf]
+    · simp [hi]
+  have hu : u f a ≠ 0 := by
+    intro he
+    have hh := congrFun he a
+    exact hf0 (by simpa [u] using hh)
+  have hv : v f C a ≠ 0 := by
+    intro he
+    rw [he,Matrix.mulVec_zero] at hDu
+    exact hu hDu.symm
+  have hvs (i : R) : f*v f C a i=v f C a i := by
+    simp only [v,Matrix.mulVec,dotProduct,Finset.mul_sum]
+    apply Finset.sum_congr rfl
+    intro j _
+    rw [← mul_assoc,hC]
+  have hAv : A f σ D *ᵥ v f C a=0 := by
+    rw [A,Matrix.add_mulVec]
+    have hcut : cutD σ D *ᵥ v f C a=0 := by
+      funext i
+      change (D *ᵥ v f C a) (σ i)=0
+      rw [hDu]
+      simp [u,ha i]
+    rw [hcut,zero_add]
+    funext i
+    rw [Matrix.mulVec_diagonal]
+    exact complement_left f _ (hvs i)
+  refine ⟨hv,hDu,hAv,?_⟩
+  rw [Matrix.sub_mulVec,← Matrix.mulVec_mulVec,hAv,Matrix.mulVec_zero,Matrix.one_mulVec,zero_sub]
+lemma reverse_ne (f : S) (hf : f*f=f) (hf0 : f ≠ 0) (hc : ∀ x, Commute f x)
+    (σ : R → N) (C : Matrix R N S) (D : Matrix N R S)
+    (hC : ∀ i j, f*C i j=C i j)
+    (hDC : D*C=Matrix.diagonal (fun _ => f)) (a : N) (ha : ∀ i, σ i ≠ a) : B f σ C*A f σ D ≠ 1 := by
+  obtain ⟨hv,_,hAv,_⟩ := certificate f hf hf0 hc σ C D hC hDC a ha
+  intro he
+  have hh := congrArg (fun E => E *ᵥ v f C a) he
+  rw [← Matrix.mulVec_mulVec,hAv,Matrix.mulVec_zero,Matrix.one_mulVec] at hh
+  exact hv hh.symm
+end
+end OddKaplansky.SquareCertificate
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/OddKaplansky/SquareConstruction.lean b/lean/OAI/Algebra/OddKaplansky/SquareConstruction.lean
new file mode 100644
index 0000000000000000000000000000000000000000..3b6a1afb182b72350bdb4a86156b8519d849b08c
--- /dev/null
+++ b/lean/OAI/Algebra/OddKaplansky/SquareConstruction.lean
@@ -0,0 +1,111 @@
+import OAI.Algebra.OddKaplansky.SectorConstruction
+
+namespace OAI
+
+universe portUniverse1 portUniverse2 portUniverse3 portUniverse4
+
+section
+namespace OddKaplansky.Construction
+noncomputable section
+local instance squareConstructionDecidableEq (α : Type portUniverse1) : DecidableEq α := Classical.decEq α
+open scoped Classical BigOperators Matrix
+open SourceGluing SourceGraph
+local notation "M" => SourceGluing.modulus
+local notation "p" => SourceGluing.p
+variable {K : Type} [Field K] [Fintype K] [CharP K p]
+variable {ζ : K} (hζ : IsPrimitiveRoot ζ M)
+@[instance_reducible]
+
+def slotOrder : LinearOrder SourceFit.Slot := LinearOrder.lift' (fun s => s.val.sort) (by
+  intro s t h
+  apply Subtype.ext
+  simpa using congrArg List.toFinset h)
+@[instance_reducible]
+def lexOrder (α : Type portUniverse2) (β : Type portUniverse3) [LinearOrder α] [LinearOrder β] : LinearOrder (α×β) :=
+  LinearOrder.lift' (fun a : α×β => toLex a) (fun _ _ h => h)
+def orderedIndex (α : Type portUniverse4) [LinearOrder α] [Fintype α] : α ≃ Fin (Fintype.card α) :=
+  (Fintype.orderIsoFinOfCardEq α rfl).symm.toEquiv
+def smallIndex : Small ≃ Fin (Fintype.card Small) := @orderedIndex Small (@lexOrder W SourceFit.Slot inferInstance slotOrder) inferInstance
+def largeIndex (d : LocalDatum (K := K)) : Large d ≃ Fin (Fintype.card (Large d)) :=
+  @orderedIndex (Large d) (@lexOrder Vertex (N d) inferInstance inferInstance) inferInstance
+def inclusion (d : LocalDatum (K := K)) : Small → Large d := IndexCut.inclusion smallIndex (largeIndex d) (sizes d)
+lemma inclusion_injective (d : LocalDatum (K := K)) : Function.Injective (inclusion d) := IndexCut.injective smallIndex (largeIndex d) (sizes d)
+def extra (d : LocalDatum (K := K)) : Large d := IndexCut.extra (largeIndex d) (sizes d)
+lemma inclusion_ne_extra (d : LocalDatum (K := K)) (i : Small) : inclusion d i≠extra d :=
+  IndexCut.misses smallIndex (largeIndex d) (sizes d) i
+
+def squareA (d : LocalDatum (K := K)) (rect : Rectangular hζ d) : Matrix Small Small (R (K := K)) :=
+  SquareCertificate.A (f hζ) (inclusion d) (D hζ d rect)
+def squareB (d : LocalDatum (K := K)) (rect : Rectangular hζ d) : Matrix Small Small (R (K := K)) :=
+  SquareCertificate.B (f hζ) (inclusion d) (C hζ d rect)
+lemma square_products (d : LocalDatum (K := K)) (rect : Rectangular hζ d) :
+    squareA hζ d rect*squareB hζ d rect=1 ∧ squareB hζ d rect*squareA hζ d rect≠1 := by
+  constructor
+  · convert SquareCertificate.products (f hζ) (f_idem hζ) (f_commute hζ) (inclusion d) (inclusion_injective d)
+      (C hζ d rect) (D hζ d rect) (C_sector hζ d rect) (D_sector hζ d rect) (DC_classical hζ d rect) using 1 <;> congr ; exact Subsingleton.elim _ _
+  · convert SquareCertificate.reverse_ne (f hζ) (f_idem hζ) (f_nonzero hζ) (f_commute hζ) (inclusion d)
+      (C hζ d rect) (D hζ d rect) (C_sector hζ d rect) (DC_classical hζ d rect) (extra d) (inclusion_ne_extra d) using 1 <;> congr ; exact Subsingleton.elim _ _
+lemma visible_certificate (d : LocalDatum (K := K)) (rect : Rectangular hζ d) :
+    SquareCertificate.v (f hζ) (C hζ d rect) (extra d)≠0 ∧
+    D hζ d rect *ᵥ SquareCertificate.v (f hζ) (C hζ d rect) (extra d)=SquareCertificate.u (f hζ) (extra d) ∧
+    squareA hζ d rect *ᵥ SquareCertificate.v (f hζ) (C hζ d rect) (extra d)=0 ∧
+    (squareB hζ d rect*squareA hζ d rect-1) *ᵥ SquareCertificate.v (f hζ) (C hζ d rect) (extra d)= -SquareCertificate.v (f hζ) (C hζ d rect) (extra d) := by
+  obtain ⟨hv,hDv,hAv,hdef⟩ := SquareCertificate.certificate (f hζ) (f_idem hζ) (f_nonzero hζ) (f_commute hζ) (inclusion d)
+    (C hζ d rect) (D hζ d rect) (C_sector hζ d rect) (DC_classical hζ d rect) (extra d) (inclusion_ne_extra d)
+  refine ⟨hv,hDv,hAv,?_⟩
+  simpa only [squareA,squareB,Matrix.sub_mulVec,Matrix.one_mulVec] using hdef
+
+def A (d : LocalDatum (K := K)) (rect : Rectangular hζ d) : Matrix (Fin (Fintype.card Small)) (Fin (Fintype.card Small)) (R (K := K)) :=
+  Matrix.reindexAlgEquiv K (R (K := K)) smallIndex (squareA hζ d rect)
+def B (d : LocalDatum (K := K)) (rect : Rectangular hζ d) : Matrix (Fin (Fintype.card Small)) (Fin (Fintype.card Small)) (R (K := K)) :=
+  Matrix.reindexAlgEquiv K (R (K := K)) smallIndex (squareB hζ d rect)
+lemma products (d : LocalDatum (K := K)) (rect : Rectangular hζ d) : A hζ d rect*B hζ d rect=1 ∧ B hζ d rect*A hζ d rect≠1 := by
+  let E := Matrix.reindexAlgEquiv K (R (K := K)) smallIndex
+  have hone : E 1=1 := map_one E
+  have hmul : ∀ X Y, E (X*Y)=E X*E Y := fun X Y => map_mul E X Y
+  constructor
+  · change E (squareA hζ d rect)*E (squareB hζ d rect)=1
+    rw [← hmul,(square_products hζ d rect).1,hone]
+  · intro he
+    apply (square_products hζ d rect).2
+    apply E.injective
+    rw [hmul,hone]
+    exact he
+lemma modulus_ge_two : 2≤M := by have := SourceGluing.modulus_gt; omega
+def q : ℕ := FixedField.leastQ M modulus_ge_two (Fintype.card Small)
+abbrev Λ := Heisenberg.GroupData M q
+abbrev G := G₁×Λ
+instance : Group.FG G := inferInstance
+
+def a (d : LocalDatum (K := K)) (rect : Rectangular hζ d) : MonoidAlgebra K G :=
+  FixedField.output M modulus_ge_two (Fintype.card Small) hζ (A hζ d rect)
+def b (d : LocalDatum (K := K)) (rect : Rectangular hζ d) : MonoidAlgebra K G :=
+  FixedField.output M modulus_ge_two (Fintype.card Small) hζ (B hζ d rect)
+lemma scalar_products (d : LocalDatum (K := K)) (rect : Rectangular hζ d) : a hζ d rect*b hζ d rect=1 ∧ b hζ d rect*a hζ d rect≠1 := by
+  exact FixedField.output_products M modulus_ge_two (Fintype.card Small) hζ (modulus_cast (K := K))
+    (A hζ d rect) (B hζ d rect) (products hζ d rect).1 (products hζ d rect).2
+lemma torsion : ∃ g : G, g≠1 ∧ IsOfFinOrder g := by
+  let c : Fourier.C M := Multiplicative.ofAdd (1 : ZMod M)
+  have hc : c≠1 := by
+    intro h
+    have he : (1 : ZMod M)=0 := congrArg Multiplicative.toAdd h
+    have hd : M∣1 := (ZMod.natCast_eq_zero_iff 1 M).mp (by simpa only [Nat.cast_one] using he)
+    have := Nat.dvd_one.mp hd
+    have := SourceGluing.modulus_gt
+    omega
+  let z : Λ := Heisenberg.central M q c
+  have hz : z≠1 := by
+    intro h
+    apply hc
+    apply Heisenberg.central_injective M q
+    simpa only [map_one] using h
+  refine ⟨(1,z),?_,?_⟩
+  · intro he
+    exact hz (congrArg Prod.snd he)
+  · exact (MonoidHom.inr G₁ Λ).isOfFinOrder (isOfFinOrder_of_finite z)
+end
+end OddKaplansky.Construction
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/OddKaplansky/Transfer.lean b/lean/OAI/Algebra/OddKaplansky/Transfer.lean
new file mode 100644
index 0000000000000000000000000000000000000000..1b04c20294134338e6a3d50038429ae3bc6f244f
--- /dev/null
+++ b/lean/OAI/Algebra/OddKaplansky/Transfer.lean
@@ -0,0 +1,144 @@
+import OAI.Algebra.OddKaplansky.ScalarAlgebra
+
+namespace OAI
+
+universe contextUniverse1 contextUniverse2 contextUniverse3
+
+universe portUniverse1 portUniverse2 portUniverse3 portUniverse4 portUniverse5 portUniverse6 portUniverse7 portUniverse8 portUniverse9 portUniverse10 portUniverse11 portUniverse12
+
+section
+namespace OddKaplansky.Heisenberg
+noncomputable section
+open scoped Classical BigOperators Matrix
+variable (M q : ℕ) [NeZero M] {K : Type portUniverse1} [Field K] {ζ : K} (hζ : IsPrimitiveRoot ζ M)
+variable (hc : (Fintype.card (Fourier.C M) : K) ≠ 0) (hz : (Fintype.card (Z M q) : K) ≠ 0)
+def matrixEquiv : Matrix (Z M q) (Z M q) K ≃ₗ[K] Sector M q hζ :=
+  (LinearEquiv.ofInjective (encode M q hζ) (encode_injective M q hζ hc hz)).trans
+    (LinearEquiv.ofEq _ _ (encode_range M q hζ hc hz))
+lemma matrixEquiv_mul (T S : Matrix (Z M q) (Z M q) K) :
+    (matrixEquiv M q hζ hc hz (T*S)).val=(matrixEquiv M q hζ hc hz T).val*(matrixEquiv M q hζ hc hz S).val := encode_mul M q hζ hc hz T S
+
+def scalar {L : Type portUniverse2} [Group L] (T : Matrix (Z M q) (Z M q) (MonoidAlgebra K L)) : MonoidAlgebra K (L×GroupData M q) :=
+  MatrixBlock.output (ProductAlgebras.leftMap (K := K) (G := L) (H := GroupData M q)).toRingHom
+    (fun u v => ProductAlgebras.rightMap (G := L) (Ω M q hζ u v)) T
+include hc hz in
+lemma scalar_products {L : Type portUniverse3} [Group L] (A B : Matrix (Z M q) (Z M q) (MonoidAlgebra K L))
+    (hAB : A*B=1) (hBA : B*A≠1) : scalar M q hζ A*scalar M q hζ B=1 ∧ scalar M q hζ B*scalar M q hζ A≠1 := by
+  apply MatrixBlock.prescribed_scalar_products
+  · intro u v s t
+    rw [← map_mul,Ω_mul M q hζ hc hz]
+    split_ifs <;> simp
+  · intro x u v
+    exact ProductAlgebras.left_right_commute x (Ω M q hζ u v)
+  · intro x u v he
+    by_contra hx
+    exact ProductAlgebras.product_ne_zero hx (Ω_ne_zero M q hζ hc hz u v) he
+  · convert hAB using 1 ; congr ; exact Subsingleton.elim _ _
+  · convert hBA using 1 ; congr ; exact Subsingleton.elim _ _
+include hc hz in
+lemma scalar_formula {L : Type portUniverse4} [Group L] (T : Matrix (Z M q) (Z M q) (MonoidAlgebra K L)) :
+    scalar M q hζ T=ProductAlgebras.rightMap (G := L) (1-f M q hζ)+
+      ∑ u,∑ v,ProductAlgebras.leftMap (T u v)*ProductAlgebras.rightMap (Ω M q hζ u v) := by
+  rw [scalar,MatrixBlock.output_formula,← map_sum,Ω_sum M q hζ hc hz,map_sub,map_one]
+  rfl
+end
+end OddKaplansky.Heisenberg
+
+namespace OddKaplansky.Padding
+noncomputable section
+open scoped Classical BigOperators Matrix
+variable {R : Type portUniverse5} {I : Type portUniverse6} {J : Type portUniverse7} [Ring R] [sectionInstance76 : Fintype I] [sectionInstance77 : Fintype J]
+def pad (T : Matrix I I R) : Matrix (I⊕J) (I⊕J) R := Matrix.fromBlocks T 0 0 1
+lemma pad_mul (A B : Matrix I I R) : pad (J := J) (A*B)=pad A*pad B := by simp [pad,Matrix.fromBlocks_multiply]
+lemma pad_one
+    {R : Type contextUniverse1}
+    {I : Type contextUniverse2}
+    {J : Type contextUniverse3}
+    [Ring.{contextUniverse1} R]
+    [Fintype.{contextUniverse2} I]
+    [Fintype.{contextUniverse3} J] : pad (R := R) (I := I) (J := J) 1=1 := Matrix.fromBlocks_one
+lemma pad_ne_one
+    {R : Type contextUniverse1}
+    {I : Type contextUniverse2}
+    {J : Type contextUniverse3}
+    [Ring.{contextUniverse1} R]
+    [Fintype.{contextUniverse2} I]
+    [Fintype.{contextUniverse3} J] {T : Matrix I I R} (h : T≠1) : pad (J := J) T≠1 := by
+  intro he
+  apply h
+  funext i j
+  have hh := congrFun (congrFun he (Sum.inl i)) (Sum.inl j)
+  simpa [pad,Matrix.one_apply] using hh
+lemma products (A B : Matrix I I R) (hAB : A*B=1) (hBA : B*A≠1) :
+    pad (J := J) A*pad B=1 ∧ pad (J := J) B*pad A≠1 := by
+  rw [← pad_mul,← pad_mul,hAB,pad_one]
+  exact ⟨rfl,pad_ne_one hBA⟩
+end
+end OddKaplansky.Padding
+
+namespace OddKaplansky.FixedField
+noncomputable section
+open scoped Classical BigOperators Matrix
+variable (M : ℕ) (hM : 2≤M) (r : ℕ)
+include hM in
+lemma power_search : ∃ q, r≤M^q := by
+  refine ⟨r,?_⟩
+  exact (Nat.le_of_lt (Nat.lt_two_pow_self (n := r))).trans (Nat.pow_le_pow_left hM r)
+def leastQ : ℕ := Nat.find (power_search M hM r)
+lemma leastQ_spec : r≤M^(leastQ M hM r) := Nat.find_spec (power_search M hM r)
+lemma leastQ_min {q : ℕ} (hq : r≤M^q) : leastQ M hM r≤q := Nat.find_min' (power_search M hM r) hq
+variable [NeZero M] {K : Type portUniverse8} [Field K] {ζ : K} (hζ : IsPrimitiveRoot ζ M)
+variable (hc : (M : K)≠0)
+@[instance_reducible]
+def coordinateOrder : LinearOrder (Heisenberg.Z M (leastQ M hM r)) :=
+  @FiniteChoice.functionOrder (Fin (leastQ M hM r)) (Fourier.C M) inferInstance inferInstance (SourceOrders.cyclic M)
+def indices : (Fin r⊕Fin (M^(leastQ M hM r)-r)) ≃ Heisenberg.Z M (leastQ M hM r) :=
+  finSumFinEquiv.trans ((finCongr (by
+    have hh := leastQ_spec M hM r
+    simp only [Heisenberg.Z,Fintype.card_fun,Fintype.card_fin,Fourier.C,Fintype.card_multiplicative,ZMod.card]
+    omega)).trans (@FiniteChoice.orderedIndex _ (coordinateOrder M hM r) inferInstance).symm)
+def pad {L : Type portUniverse9} [Group L] (A : Matrix (Fin r) (Fin r) (MonoidAlgebra K L)) :
+    Matrix (Heisenberg.Z M (leastQ M hM r)) (Heisenberg.Z M (leastQ M hM r)) (MonoidAlgebra K L) :=
+  Matrix.reindexAlgEquiv K (MonoidAlgebra K L) (indices M hM r) (Padding.pad A)
+def output {L : Type portUniverse10} [Group L] (A : Matrix (Fin r) (Fin r) (MonoidAlgebra K L)) :
+    MonoidAlgebra K (L×Heisenberg.GroupData M (leastQ M hM r)) := Heisenberg.scalar M (leastQ M hM r) hζ (pad M hM r A)
+include hc in
+lemma output_products {L : Type portUniverse11} [Group L] (A B : Matrix (Fin r) (Fin r) (MonoidAlgebra K L))
+    (hAB : A*B=1) (hBA : B*A≠1) : output M hM r hζ A*output M hM r hζ B=1 ∧ output M hM r hζ B*output M hM r hζ A≠1 := by
+  have hcc : (Fintype.card (Fourier.C M) : K)≠0 := by simpa [Fourier.C] using hc
+  have hzz : (Fintype.card (Heisenberg.Z M (leastQ M hM r)) : K)≠0 := by
+    simpa [Heisenberg.Z,Fourier.C] using pow_ne_zero (leastQ M hM r) hc
+  have hpad := Padding.products (J := Fin (M^(leastQ M hM r)-r)) A B
+    (by convert hAB using 1 ; congr ; exact Subsingleton.elim _ _)
+    (by convert hBA using 1 ; congr ; exact Subsingleton.elim _ _)
+  let E := Matrix.reindexAlgEquiv K (MonoidAlgebra K L) (indices M hM r)
+  have hone : E 1=1 := map_one E
+  have hmul : ∀ X Y, E (X*Y)=E X*E Y := fun X Y => map_mul E X Y
+  apply Heisenberg.scalar_products M (leastQ M hM r) hζ hcc hzz
+  · change E (Padding.pad A)*E (Padding.pad B)=1
+    rw [← hmul]
+    have hh : E (Padding.pad A*Padding.pad B)=E 1 := by apply congrArg E; convert hpad.1 using 1 ; congr ; exact Subsingleton.elim _ _
+    exact hh.trans hone
+  · intro he
+    apply hpad.2
+    have hh : E (Padding.pad B*Padding.pad A)=E 1 := by
+      rw [hmul,hone]
+      exact he
+    convert E.injective hh using 1 ; congr ; exact Subsingleton.elim _ _
+
+lemma finite_field_data (K : Type portUniverse12) [Field K] [Fintype K] (hK : 3≤Fintype.card K) :
+    ∃ ζ : K, IsPrimitiveRoot ζ (Fintype.card K-1) ∧ ((Fintype.card K-1 : ℕ) : K)≠0 := by
+  obtain ⟨u,hu⟩ := IsCyclic.exists_ofOrder_eq_natCard (α := Kˣ)
+  refine ⟨u,?_,?_⟩
+  · rw [← Fintype.card_units K,← Nat.card_eq_fintype_card,← hu]
+    simpa only [orderOf_units] using IsPrimitiveRoot.orderOf (u : K)
+  · have hq : (Fintype.card K : K)=0 := by exact FiniteField.cast_card_eq_zero K
+    have hsub : ((Fintype.card K-1 : ℕ) : K)=(Fintype.card K : K)-1 := by simpa only [Nat.cast_one] using (Nat.cast_sub (R := K) (show 1≤Fintype.card K by omega))
+    rw [hsub,hq,zero_sub]
+    exact neg_ne_zero.mpr one_ne_zero
+end
+end OddKaplansky.FixedField
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/OddKaplansky/WeightedGram.lean b/lean/OAI/Algebra/OddKaplansky/WeightedGram.lean
new file mode 100644
index 0000000000000000000000000000000000000000..51fbc42e874ddd0b9db6ff9a4675740b37e72410
--- /dev/null
+++ b/lean/OAI/Algebra/OddKaplansky/WeightedGram.lean
@@ -0,0 +1,122 @@
+import OAI.Algebra.OddKaplansky.FreeShiftCount
+
+namespace OAI
+
+universe contextUniverse1 contextUniverse2 contextUniverse3
+
+universe portUniverse1 portUniverse2 portUniverse3 portUniverse4
+
+section
+namespace OddKaplansky.WeightedGram
+noncomputable section
+open scoped Classical BigOperators
+variable {K : Type portUniverse1} {X : Type portUniverse2} {I : Type portUniverse3} [Field K] [Fintype X] [sectionInstance20 : Fintype I] [sectionInstance19 : DecidableEq X] [sectionInstance21 : DecidableEq I]
+
+lemma exists_minor
+    {K : Type contextUniverse1}
+    {X : Type contextUniverse2}
+    {I : Type contextUniverse3}
+    [Field.{contextUniverse1} K]
+    [Fintype.{contextUniverse2} X]
+    [Fintype.{contextUniverse3} I]
+    [DecidableEq.{contextUniverse2 + 1} X]
+    [DecidableEq.{contextUniverse3 + 1} I] (B : Matrix X I K) (hB : LinearIndependent K B.col) :
+    ∃ f : I ↪ X, (B.submatrix f id).det ≠ 0 := by
+  have hr : B.rank = Fintype.card I := by
+    rw [← B.rank_transpose]
+    exact hB.rank_matrix
+  have ht : Submodule.span K (Set.range B.row) = ⊤ := by
+    apply Submodule.eq_top_of_finrank_eq
+    rw [← B.rank_eq_finrank_span_row, hr, Module.finrank_pi]
+  let b := Module.Basis.ofSpan ht.ge
+  let e := b.indexEquiv (Pi.basisFun K I)
+  let b' := b.reindex e
+  have hb (i : I) : ∃ x, B.row x = b' i := by
+    exact Module.Basis.ofSpan_subset ht.ge ⟨e.symm i, (Module.Basis.reindex_apply b e i).symm⟩
+  choose f hf using hb
+  have hfi : Function.Injective f := by
+    intro i j hij
+    apply b'.injective
+    rw [← hf, ← hf, hij]
+  refine ⟨⟨f,hfi⟩, Matrix.nonsingular_iff_det_ne_zero.mp (Matrix.linearIndependent_row_iff.mp ?_)⟩
+  change LinearIndependent K (fun i => B.row (f i))
+  have he : (fun i => B.row (f i)) = b' := funext hf
+  rw [he]
+  exact b'.linearIndependent
+
+lemma gram_entry
+    {X : Type contextUniverse1}
+    {I : Type contextUniverse2}
+    [Fintype.{contextUniverse1} X]
+    [Fintype.{contextUniverse2} I]
+    [DecidableEq.{contextUniverse1 + 1} X]
+    [DecidableEq.{contextUniverse2 + 1} I] {A : Type portUniverse4} [CommRing A] (B : Matrix X I A) (τ : X → A) (i j : I) :
+    (B.transpose * Matrix.diagonal τ * B) i j = ∑ x : X, B x i * τ x * B x j := by
+  simp [Matrix.mul_apply, Matrix.diagonal_apply]
+
+def polynomial (B : Matrix X I K) : MvPolynomial X K :=
+  ((B.transpose.map (MvPolynomial.C : K →+* MvPolynomial X K)) * Matrix.diagonal (fun x => (MvPolynomial.X x : MvPolynomial X K)) *
+    B.map (MvPolynomial.C : K →+* MvPolynomial X K)).det
+
+lemma eval_polynomial (B : Matrix X I K) (τ : X → K) :
+    MvPolynomial.eval τ (polynomial B) = (B.transpose * Matrix.diagonal τ * B).det := by
+  rw [polynomial, (MvPolynomial.eval τ).map_det]
+  congr 1
+  apply Matrix.ext
+  intro i j
+  simp [RingHom.mapMatrix_apply, Matrix.map_apply, Matrix.mul_apply, Matrix.diagonal_apply]
+
+lemma nonzero (B : Matrix X I K) (hB : LinearIndependent K B.col) : polynomial B ≠ 0 := by
+  obtain ⟨f,hf⟩ := exists_minor B hB
+  let τ : X → K := fun x => if x ∈ Set.range f then 1 else 0
+  have he : B.transpose * Matrix.diagonal τ * B = (B.submatrix f id).transpose * (B.submatrix f id) := by
+    apply Matrix.ext
+    intro i j
+    rw [gram_entry]
+    simp only [Matrix.mul_apply, Matrix.transpose_apply, Matrix.submatrix_apply, id_eq]
+    calc
+      _ = ∑ x ∈ Finset.univ.image f, B x i * τ x * B x j := by
+        symm
+        apply Finset.sum_subset (Finset.subset_univ _)
+        intro x _ hx
+        have hx' : x ∉ Set.range f := by simpa using hx
+        simp only [τ, ite_eq_right hx', mul_zero, zero_mul]
+      _ = ∑ k : I, B (f k) i * B (f k) j := by
+        rw [Finset.sum_image f.injective.injOn]
+        simp [τ]
+  intro hz
+  have hh := eval_polynomial B τ
+  rw [hz,map_zero,he,Matrix.det_mul,Matrix.det_transpose] at hh
+  exact (mul_ne_zero hf hf) hh.symm
+
+lemma totalDegree (B : Matrix X I K) : (polynomial B).totalDegree ≤ Fintype.card I := by
+  unfold polynomial
+  rw [Matrix.det_apply']
+  apply MvPolynomial.totalDegree_finsetSum_le
+  intro σ _
+  apply (MvPolynomial.totalDegree_mul _ _).trans
+  have hc : (↑(Equiv.Perm.sign σ) : MvPolynomial X K).totalDegree = 0 := by
+    simpa using (MvPolynomial.totalDegree_C (Equiv.Perm.sign σ : K))
+  rw [hc,zero_add]
+  apply (MvPolynomial.totalDegree_finsetProd _ _).trans
+  calc
+    _ ≤ ∑ _i : I, 1 := by
+      apply Finset.sum_le_sum
+      intro i _
+      change (( (B.map (MvPolynomial.C : K →+* MvPolynomial X K)).transpose *
+        Matrix.diagonal (fun x => (MvPolynomial.X x : MvPolynomial X K)) * B.map (MvPolynomial.C : K →+* MvPolynomial X K)) (σ i) i).totalDegree ≤ 1
+      rw [gram_entry]
+      simp only [Matrix.map_apply]
+      apply MvPolynomial.totalDegree_finsetSum_le
+      intro x _
+      exact (MvPolynomial.totalDegree_mul _ _).trans (by
+        have h := MvPolynomial.totalDegree_mul (MvPolynomial.C (B x (σ i))) (MvPolynomial.X x : MvPolynomial X K)
+        simpa using h)
+    _ = Fintype.card I := by simp
+
+end
+end OddKaplansky.WeightedGram
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/OddKaplansky/WeightedProjection.lean b/lean/OAI/Algebra/OddKaplansky/WeightedProjection.lean
new file mode 100644
index 0000000000000000000000000000000000000000..a91f37338d687f22c494afa8c6ae74e1ac841246
--- /dev/null
+++ b/lean/OAI/Algebra/OddKaplansky/WeightedProjection.lean
@@ -0,0 +1,77 @@
+import OAI.Algebra.OddKaplansky.AdmissibleCount
+
+namespace OAI
+
+universe contextUniverse1 contextUniverse2 contextUniverse3
+
+universe portUniverse1 portUniverse2 portUniverse3
+
+section
+namespace OddKaplansky.WeightedProjection
+noncomputable section
+open scoped Classical BigOperators Matrix
+variable {K : Type portUniverse1} {X : Type portUniverse2} {I : Type portUniverse3} [Field K] [Fintype X] [sectionInstance23 : Fintype I] [DecidableEq X] [sectionInstance24 : DecidableEq I]
+def gram (B : Matrix X I K) (τ : X → K) := B.transpose * Matrix.diagonal τ * B
+def projection (B : Matrix X I K) (τ : X → K) := B * (gram B τ)⁻¹ * B.transpose * Matrix.diagonal τ
+
+lemma fixes (B : Matrix X I K) (τ : X → K) (h : (gram B τ).det ≠ 0) : projection B τ * B = B := by
+  have hi := Matrix.nonsing_inv_mul (gram B τ) (isUnit_iff_ne_zero.mpr h)
+  simpa only [projection,gram,Matrix.mul_assoc,Matrix.mul_one] using congrArg (fun A => B * A) hi
+
+lemma idempotent (B : Matrix X I K) (τ : X → K) (h : (gram B τ).det ≠ 0) :
+    projection B τ * projection B τ = projection B τ := by
+  calc
+    _ = (projection B τ * B) * (gram B τ)⁻¹ * B.transpose * Matrix.diagonal τ := by simp only [projection, Matrix.mul_assoc]
+    _ = _ := by rw [fixes B τ h]; rfl
+
+lemma rank (B : Matrix X I K) (τ : X → K) (h : (gram B τ).det ≠ 0) : (projection B τ).rank = B.rank := by
+  apply le_antisymm
+  · unfold projection
+    exact (Matrix.rank_mul_le_left _ _).trans ((Matrix.rank_mul_le_left _ _).trans (Matrix.rank_mul_le_left _ _))
+  · calc
+      B.rank = (projection B τ * B).rank := congrArg Matrix.rank (fixes B τ h).symm
+      _ ≤ _ := Matrix.rank_mul_le_left _ _
+
+lemma annihilate_left (B : Matrix X I K) (τ : X → K) (A : Matrix X X K) (h : A * B = 0) :
+    A * projection B τ = 0 := by
+  simp only [projection,← Matrix.mul_assoc,h,Matrix.zero_mul]
+
+lemma annihilate_right (B : Matrix X I K) (τ : X → K) (A : Matrix X X K)
+    (h : B.transpose * Matrix.diagonal τ * A = 0) : projection B τ * A = 0 := by
+  calc
+    _ = (B * (gram B τ)⁻¹) * (B.transpose * Matrix.diagonal τ * A) := by simp only [Matrix.mul_assoc,projection]
+    _ = 0 := by rw [h,Matrix.mul_zero]
+
+lemma conjugate_sub_pow (D D' A : Matrix X X K) (hD : D * D' = 1) (hD' : D' * D = 1) (ell : ℕ) :
+    (D*A*D' - 1)^ell = D*(A-1)^ell*D' := by
+  induction ell with
+  | zero => simpa using hD.symm
+  | succ n ih =>
+    rw [pow_succ,ih,pow_succ]
+    have hs : D*A*D'-1 = D*(A-1)*D' := by simp only [Matrix.sub_mul,Matrix.mul_sub,Matrix.mul_one,hD]
+    rw [hs]
+    calc
+      _ = D * (A-1)^n * (D'*D) * (A-1) * D' := by simp only [Matrix.mul_assoc]
+      _ = _ := by rw [hD',Matrix.mul_one]; simp only [Matrix.mul_assoc]
+
+lemma conjugate_annihilate
+    {K : Type contextUniverse1}
+    {X : Type contextUniverse2}
+    {I : Type contextUniverse3}
+    [Field.{contextUniverse1} K]
+    [Fintype.{contextUniverse2} X]
+    [Fintype.{contextUniverse3} I]
+    [DecidableEq.{contextUniverse2 + 1} X]
+    [DecidableEq.{contextUniverse3 + 1} I] (B : Matrix X I K) (D D' A : Matrix X X K)
+    (hD : D * D' = 1) (hD' : D' * D = 1) (ell : ℕ) (hB : B.transpose * (A-1)^ell = 0) :
+    B.transpose * D' * (D*A*D'-1)^ell = 0 := by
+  rw [conjugate_sub_pow D D' A hD hD']
+  calc
+    _ = B.transpose * (D'*D) * (A-1)^ell * D' := by simp only [Matrix.mul_assoc]
+    _ = 0 := by rw [hD',Matrix.mul_one,hB,Matrix.zero_mul]
+end
+end OddKaplansky.WeightedProjection
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/OddKaplansky/WreathActions.lean b/lean/OAI/Algebra/OddKaplansky/WreathActions.lean
new file mode 100644
index 0000000000000000000000000000000000000000..6e683199e90e0077edb6c4ed5ea640b2e6dd0645
--- /dev/null
+++ b/lean/OAI/Algebra/OddKaplansky/WreathActions.lean
@@ -0,0 +1,77 @@
+import OAI.Algebra.OddKaplansky.MatrixActions
+
+namespace OAI
+
+universe contextUniverse1 contextUniverse2 contextUniverse3
+
+universe portUniverse1 portUniverse2 portUniverse3
+
+section
+
+namespace OddKaplansky.WreathFourier
+noncomputable section
+open scoped Classical BigOperators Matrix
+variable {K : Type portUniverse1} {H : Type portUniverse2} {R : Type portUniverse3} [Field K] [Group H] [Fintype H] [sectionInstance18 : Fintype R]
+variable (M : ℕ) [NeZero M] {ζ : K} (hζ : IsPrimitiveRoot ζ M)
+variable (lmb : R → Base (H := H) M)
+local notation "φ" => MatrixUnits.lift (K := K) (freeUnit M hζ lmb)
+
+def diagonal (a : Base (H := H) M) (r : R) : Matrix H H K :=
+  Matrix.diagonal (fun x => (Fourier.character M hζ (shift M x (lmb r)) a : K))
+
+lemma top_represents (h : H) : MatrixActions.Represents φ (topElt M h) (fun _ : R => TranslationMatrix.matrix (K := K) h) := by
+  intro F
+  constructor
+  · rw [MatrixUnits.lift_apply,MatrixUnits.lift_apply]
+    simp only [Finset.mul_sum,mul_smul_comm,topElt_freeUnit]
+    apply Finset.sum_congr rfl
+    intro r _
+    simp only [Pi.mul_apply,TranslationMatrix.mul_apply]
+    have he := Equiv.sum_comp (Equiv.mulLeft h) (fun x : H => ∑ y : H, F r (h⁻¹*x) y • freeUnit M hζ lmb (r,x,y))
+    simpa only [Equiv.coe_mulLeft,inv_mul_cancel_left] using he
+  · rw [MatrixUnits.lift_apply,MatrixUnits.lift_apply]
+    simp only [Finset.sum_mul,smul_mul_assoc,freeUnit_topElt]
+    apply Finset.sum_congr rfl
+    intro r _
+    apply Finset.sum_congr rfl
+    intro x _
+    simp only [Pi.mul_apply,TranslationMatrix.right_mul_apply]
+    have he := Equiv.sum_comp (Equiv.mulLeft h⁻¹) (fun y : H => F r x (h*y) • freeUnit M hζ lmb (r,x,y))
+    simpa only [Equiv.coe_mulLeft,mul_inv_cancel_left] using he
+
+lemma base_represents (a : Base (H := H) M) : MatrixActions.Represents φ (baseElt M a) (diagonal M hζ lmb a) := by
+  intro F
+  constructor
+  · simp only [MatrixUnits.lift_apply,Finset.mul_sum,mul_smul_comm,baseElt_freeUnit,smul_smul,Pi.mul_apply,diagonal,Matrix.diagonal_mul,mul_comm]
+  · simp only [MatrixUnits.lift_apply,Finset.sum_mul,smul_mul_assoc,freeUnit_baseElt,smul_smul,Pi.mul_apply,diagonal,Matrix.mul_diagonal]
+
+lemma diagonal_inv
+    {K : Type contextUniverse1}
+    {H : Type contextUniverse2}
+    {R : Type contextUniverse3}
+    [contextInstance3 : Field.{contextUniverse1} K]
+    [Group.{contextUniverse2} H]
+    [Fintype.{contextUniverse2} H]
+    [Fintype.{contextUniverse3} R]
+    (M : Nat)
+    [@NeZero.{0} Nat (@MulZeroClass.toZero.{0} Nat Nat.instMulZeroClass) M]
+    {ζ : K}
+    (hζ : @IsPrimitiveRoot.{contextUniverse1} K (@CommRing.toCommMonoid.{contextUniverse1} K (@Field.toCommRing.{contextUniverse1} K contextInstance3)) ζ M)
+    (lmb : R → @OddKaplansky.WreathFourier.Base.{contextUniverse2} H M) (a : Base (H := H) M) (r : R) :
+    diagonal M hζ lmb a r * diagonal M hζ lmb a⁻¹ r = 1 := by
+  rw [diagonal,diagonal,Matrix.diagonal_mul_diagonal]
+  simp only [map_inv,Units.val_inv_eq_inv_val,mul_inv_cancel₀ (Units.ne_zero _),Matrix.diagonal_one]
+
+lemma diagonal_inv' (a : Base (H := H) M) (r : R) :
+    diagonal M hζ lmb a⁻¹ r * diagonal M hζ lmb a r = 1 := by simpa only [inv_inv] using diagonal_inv M hζ lmb a⁻¹ r
+
+lemma conjugate_represents (a : Base (H := H) M) (h : H) :
+    MatrixActions.Represents φ (baseElt M a * topElt M h * baseElt M a⁻¹)
+      (fun r => diagonal M hζ lmb a r * TranslationMatrix.matrix h * diagonal M hζ lmb a⁻¹ r) :=
+  MatrixActions.represents_mul φ (MatrixActions.represents_mul φ (base_represents M hζ lmb a) (top_represents M hζ lmb h)) (base_represents M hζ lmb a⁻¹)
+end
+end OddKaplansky.WreathFourier
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/OddKaplansky/WreathBasis.lean b/lean/OAI/Algebra/OddKaplansky/WreathBasis.lean
new file mode 100644
index 0000000000000000000000000000000000000000..7634fe9b881eb83a53543eed1111134fae2c0bc1
--- /dev/null
+++ b/lean/OAI/Algebra/OddKaplansky/WreathBasis.lean
@@ -0,0 +1,94 @@
+import OAI.Algebra.OddKaplansky.WreathRepresentation
+
+namespace OAI
+
+universe portUniverse1 portUniverse2 portUniverse3 portUniverse4
+
+section
+
+namespace OddKaplansky.CharacterIdempotents
+noncomputable section
+open scoped Classical BigOperators
+variable {K : Type portUniverse1} {A : Type portUniverse2} [Field K] [Group A] [Fintype A]
+lemma character_pairing (χ ψ : A →* Kˣ) :
+    (∑ a : A, (χ a : K) * (ψ a : K)⁻¹) = if χ = ψ then (Fintype.card A : K) else 0 := by
+  by_cases he : χ = ψ
+  · subst ψ; simp
+  · rw [ite_eq_right he]
+    have hn : χ * ψ⁻¹ ≠ 1 := by
+      intro h
+      apply he
+      apply MonoidHom.ext
+      intro a
+      exact mul_inv_eq_one.mp (congrArg (fun f : A →* Kˣ => f a) h)
+    simpa using sum_character_eq_zero (χ * ψ⁻¹) hn
+
+def evaluate (χ : A →* Kˣ) : MonoidAlgebra K A →ₐ[K] K :=
+  MonoidAlgebra.lift K K A ((Units.coeHom K).comp χ)
+lemma evaluate_projector (χ ψ : A →* Kˣ) (hc : (Fintype.card A : K) ≠ 0) :
+    evaluate χ (projector ψ) = if χ = ψ then 1 else 0 := by
+  simp only [evaluate, projector, map_smul, map_sum, MonoidAlgebra.lift_single,
+    MonoidHom.comp_apply, Units.coeHom_apply, smul_eq_mul]
+  rw [show (∑ a : A, (ψ a : K)⁻¹ * (χ a : K)) =
+        ∑ a : A, (χ a : K) * (ψ a : K)⁻¹ by apply Finset.sum_congr rfl; intros; exact mul_comm _ _]
+  rw [character_pairing]
+  split_ifs <;> simp [hc]
+end
+end OddKaplansky.CharacterIdempotents
+
+namespace OddKaplansky.WreathFourier
+noncomputable section
+open scoped Classical BigOperators
+variable {K : Type portUniverse3} {H : Type portUniverse4} [Field K] [Group H] [Fintype H]
+variable (M : ℕ) [NeZero M] {ζ : K} (hζ : IsPrimitiveRoot ζ M)
+
+lemma rho_projector (hc : (Fintype.card (Base (H := H) M) : K) ≠ 0)
+    (lmb x y : Base (H := H) M) :
+    rho M hζ (projector M hζ lmb) x y = if x = y ∧ x = lmb then 1 else 0 := by
+  unfold projector
+  rw [CharacterIdempotents.pushed_eq_sum, map_smul, map_sum]
+  simp only [Matrix.smul_apply, Matrix.sum_apply, rho_single, base_left, base_right, shift_one,
+    MulEquiv.refl_apply]
+  by_cases hxy : x = y
+  · subst y
+    simp only [ite_true,       true_and]
+    have hs (f : Base (H := H) M → K) : (∑ a, MonoidAlgebra.single (1 : H) (f a)) =
+        MonoidAlgebra.single 1 (∑ a, f a) :=
+      (map_sum (MonoidAlgebra.singleAddHom (1 : H)) f Finset.univ).symm
+    rw [hs]
+    have he := CharacterIdempotents.character_pairing
+      (Fourier.character M hζ x) (Fourier.character M hζ lmb)
+    have hi : Fourier.character M hζ x = Fourier.character M hζ lmb ↔ x = lmb :=
+      (Fourier.character_injective M hζ).eq_iff
+    simp only [hi] at he
+    simp_rw [mul_comm ((Fourier.character M hζ lmb _ : K)⁻¹)]
+    rw [he]
+    split_ifs
+    · rw [MonoidAlgebra.smul_single, smul_eq_mul]
+      change MonoidAlgebra.single (1 : H) ((Fintype.card (Base (H := H) M) : K)⁻¹ *
+        (Fintype.card (Base (H := H) M) : K)) = MonoidAlgebra.single 1 1
+      rw [inv_mul_cancel₀ hc]
+    · simp
+  · simp [hxy]
+
+def normal (lmb : Base (H := H) M) (h : H) : MonoidAlgebra K (Wreath (H := H) M) :=
+  projector M hζ lmb * topElt M h
+
+lemma rho_normal (hc : (Fintype.card (Base (H := H) M) : K) ≠ 0)
+    (lmb : Base (H := H) M) (h : H) (x y : Base (H := H) M) :
+    rho M hζ (normal M hζ lmb h) x y =
+      if x = lmb ∧ x = shift M h y then MonoidAlgebra.single h 1 else 0 := by
+  rw [normal, map_mul, Matrix.mul_apply, Finset.sum_eq_single x]
+  · rw [rho_projector M hζ hc, rho_top]
+    by_cases hxl : x = lmb <;> by_cases hxy : x = shift M h y <;> simp [hxl, hxy]
+  · intro z _ hzx
+    rw [rho_projector M hζ hc]
+    simp [Ne.symm hzx]
+  · simp
+
+end
+end OddKaplansky.WreathFourier
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/OddKaplansky/WreathFourier.lean b/lean/OAI/Algebra/OddKaplansky/WreathFourier.lean
new file mode 100644
index 0000000000000000000000000000000000000000..75809463051e388e0e0a14d89708baee15682f73
--- /dev/null
+++ b/lean/OAI/Algebra/OddKaplansky/WreathFourier.lean
@@ -0,0 +1,140 @@
+import OAI.Algebra.OddKaplansky.Fourier
+
+namespace OAI
+
+universe contextUniverse1
+
+universe portUniverse1 portUniverse2 portUniverse3 portUniverse4 portUniverse5
+
+section
+
+namespace OddKaplansky.CharacterIdempotents
+noncomputable section
+open scoped Classical BigOperators
+variable {K : Type portUniverse1} {A : Type portUniverse2} {G : Type portUniverse3} [Field K] [Group A] [Fintype A] [Group G]
+lemma pushed_conjugate (f : A →* G) (χ ψ : A →* Kˣ) (σ : A ≃* A) (g : G)
+    (hg : ∀ a, g * f a * g⁻¹ = f (σ a)) (hχ : ∀ a, ψ (σ a) = χ a) :
+    MonoidAlgebra.single g 1 * pushed f χ * MonoidAlgebra.single g⁻¹ 1 = pushed f ψ := by
+  rw [pushed_eq_sum, pushed_eq_sum]
+  simp only [mul_smul_comm, smul_mul_assoc, Finset.mul_sum, Finset.sum_mul]
+  congr 1
+  calc
+    _ = ∑ a : A, MonoidAlgebra.single (f (σ a)) ((ψ (σ a) : K)⁻¹) := by
+      apply Finset.sum_congr rfl
+      intro a _
+      simp only [MonoidAlgebra.single_mul_single, one_mul, mul_one, hg, hχ]
+    _ = _ := Equiv.sum_comp σ.toEquiv (fun a : A =>
+      (MonoidAlgebra.single (f a) ((ψ a : K)⁻¹) : MonoidAlgebra K G))
+end
+end OddKaplansky.CharacterIdempotents
+
+namespace OddKaplansky.WreathFourier
+noncomputable section
+open scoped Classical BigOperators
+variable {K : Type portUniverse4} {H : Type portUniverse5} [Field K] [Group H] [sectionInstance9 : Fintype H]
+variable (M : ℕ) [sectionInstance10 : NeZero M] {ζ : K} (hζ : IsPrimitiveRoot ζ M)
+abbrev Base := H → Fourier.C M
+abbrev Wreath := RegularWreathProduct (Fourier.C M) H
+
+def shift (h : H) : Base (H := H) M ≃* Base (H := H) M where
+  toFun a x := a (h⁻¹ * x)
+  invFun a x := a (h * x)
+  left_inv a := by funext x; simp
+  right_inv a := by funext x; simp
+  map_mul' _ _ := rfl
+@[simp] lemma shift_apply
+    {H : Type contextUniverse1}
+    [Group.{contextUniverse1} H]
+    [Fintype.{contextUniverse1} H]
+    (M : Nat)
+    [@NeZero.{0} Nat (@MulZeroClass.toZero.{0} Nat Nat.instMulZeroClass) M] (h : H) (a : Base (H := H) M) (x : H) : shift M h a x = a (h⁻¹*x) := rfl
+@[simp] lemma shift_one
+    {H : Type contextUniverse1}
+    [Group.{contextUniverse1} H]
+    [Fintype.{contextUniverse1} H]
+    (M : Nat)
+    [@NeZero.{0} Nat (@MulZeroClass.toZero.{0} Nat Nat.instMulZeroClass) M] : shift (H := H) M 1 = MulEquiv.refl _ := by ext a x; simp
+@[simp] lemma shift_mul
+    {H : Type contextUniverse1}
+    [Group.{contextUniverse1} H]
+    [Fintype.{contextUniverse1} H]
+    (M : Nat)
+    [@NeZero.{0} Nat (@MulZeroClass.toZero.{0} Nat Nat.instMulZeroClass) M] (h g : H) (a : Base (H := H) M) : shift M (h*g) a = shift M h (shift M g a) := by
+  funext x
+  simp [mul_assoc]
+lemma character_shift (h : H) (lmb a : Base (H := H) M) :
+    Fourier.character M hζ (shift M h lmb) (shift M h a) = Fourier.character M hζ lmb a := by
+  simp only [Fourier.character_apply, shift_apply]
+  congr 1
+  apply congrArg Multiplicative.ofAdd
+  exact Equiv.sum_comp (Equiv.mulLeft h⁻¹) (fun x : H => (lmb x).toAdd * (a x).toAdd)
+def base : Base (H := H) M →* Wreath (H := H) M where
+  toFun a := ⟨a,1⟩
+  map_one' := rfl
+  map_mul' a b := by ext <;> simp
+@[simp] lemma base_left
+    {H : Type contextUniverse1}
+    [Group.{contextUniverse1} H]
+    [Fintype.{contextUniverse1} H]
+    (M : Nat)
+    [@NeZero.{0} Nat (@MulZeroClass.toZero.{0} Nat Nat.instMulZeroClass) M] (a : Base (H := H) M) : (base M a).left = a := rfl
+@[simp] lemma base_right
+    {H : Type contextUniverse1}
+    [Group.{contextUniverse1} H]
+    [Fintype.{contextUniverse1} H]
+    (M : Nat)
+    [@NeZero.{0} Nat (@MulZeroClass.toZero.{0} Nat Nat.instMulZeroClass) M] (a : Base (H := H) M) : (base M a).right = 1 := rfl
+def top : H →* Wreath (H := H) M := RegularWreathProduct.inl
+lemma base_injective
+    {H : Type contextUniverse1}
+    [Group.{contextUniverse1} H]
+    [Fintype.{contextUniverse1} H]
+    (M : Nat)
+    [@NeZero.{0} Nat (@MulZeroClass.toZero.{0} Nat Nat.instMulZeroClass) M] : Function.Injective (base (H := H) M) := by intro a b he; exact congrArg RegularWreathProduct.left he
+lemma top_injective
+    {H : Type contextUniverse1}
+    [Group.{contextUniverse1} H]
+    [Fintype.{contextUniverse1} H]
+    (M : Nat)
+    [@NeZero.{0} Nat (@MulZeroClass.toZero.{0} Nat Nat.instMulZeroClass) M] : Function.Injective (top (H := H) M) := by intro a b he; exact congrArg RegularWreathProduct.right he
+lemma top_conjugate
+    {H : Type contextUniverse1}
+    [Group.{contextUniverse1} H]
+    [Fintype.{contextUniverse1} H]
+    (M : Nat)
+    [@NeZero.{0} Nat (@MulZeroClass.toZero.{0} Nat Nat.instMulZeroClass) M] (h : H) (a : Base (H := H) M) :
+    top M h * base M a * (top M h)⁻¹ = base M (shift M h a) := by
+  ext <;> simp [top, base]
+lemma normal_form
+    {H : Type contextUniverse1}
+    [Group.{contextUniverse1} H]
+    [Fintype.{contextUniverse1} H]
+    (M : Nat)
+    [@NeZero.{0} Nat (@MulZeroClass.toZero.{0} Nat Nat.instMulZeroClass) M] (g : Wreath (H := H) M) : g = base M g.left * top M g.right := by
+  ext <;> simp [base, top]
+def projector (lmb : Base (H := H) M) : MonoidAlgebra K (Wreath (H := H) M) :=
+  CharacterIdempotents.pushed (base M) (Fourier.character M hζ lmb)
+def topElt (h : H) : MonoidAlgebra K (Wreath (H := H) M) := MonoidAlgebra.single (top M h) 1
+lemma projector_idempotent (hc : (Fintype.card (Base (H := H) M) : K) ≠ 0) (lmb : Base (H := H) M) :
+    projector M hζ lmb * projector M hζ lmb = projector M hζ lmb :=
+  CharacterIdempotents.pushed_idempotent _ _ hc
+lemma projector_orthogonal (lmb μ : Base (H := H) M) (hne : lmb ≠ μ) :
+    projector M hζ lmb * projector M hζ μ = 0 :=
+  CharacterIdempotents.pushed_orthogonal _ _ _ (fun he => hne (Fourier.character_injective M hζ he))
+lemma projector_ne_zero (hc : (Fintype.card (Base (H := H) M) : K) ≠ 0) (lmb : Base (H := H) M) :
+    projector M hζ lmb ≠ 0 := CharacterIdempotents.pushed_ne_zero _ (base_injective M) _ hc
+lemma translated (h : H) (lmb : Base (H := H) M) :
+    topElt M h * projector M hζ lmb * topElt M h⁻¹ = projector M hζ (shift M h lmb) := by
+  simp only [topElt, map_inv]
+  exact CharacterIdempotents.pushed_conjugate _ _ _ (shift M h) _ (top_conjugate M h)
+    (character_shift M hζ h lmb)
+lemma sum_projector (hc : (Fintype.card (Base (H := H) M) : K) ≠ 0) :
+    ∑ lmb : Base (H := H) M, projector M hζ lmb = 1 := by
+  have he := congrArg (MonoidAlgebra.mapDomainAlgHom K K (base (H := H) M)) (Fourier.sum_projector M hζ hc)
+  simpa only [map_sum, map_one, projector, CharacterIdempotents.pushed] using he
+end
+end OddKaplansky.WreathFourier
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/OddKaplansky/WreathLinear.lean b/lean/OAI/Algebra/OddKaplansky/WreathLinear.lean
new file mode 100644
index 0000000000000000000000000000000000000000..54cec53881173c8b1bd7898a914b67004cc6c65e
--- /dev/null
+++ b/lean/OAI/Algebra/OddKaplansky/WreathLinear.lean
@@ -0,0 +1,73 @@
+import OAI.Algebra.OddKaplansky.WreathBasis
+
+namespace OAI
+
+universe contextUniverse1 contextUniverse2
+
+universe portUniverse1 portUniverse2
+
+section
+
+namespace OddKaplansky.WreathFourier
+noncomputable section
+open scoped Classical BigOperators
+variable {K : Type portUniverse1} {H : Type portUniverse2} [Field K] [sectionInstance13 : Group H] [Fintype H]
+variable (M : ℕ) [NeZero M] {ζ : K} (hζ : IsPrimitiveRoot ζ M)
+variable (hc : (Fintype.card (Base (H := H) M) : K) ≠ 0)
+
+include hc in
+lemma normal_coordinate (lmb μ : Base (H := H) M) (h g : H) :
+    (rho M hζ (normal M hζ μ g) lmb (shift M h⁻¹ lmb)).coeff h =
+      if μ = lmb ∧ g = h then 1 else 0 := by
+  rw [rho_normal M hζ hc]
+  by_cases hgh : g = h
+  · subst g
+    simp only [shift_shift_inverse, and_true]
+    by_cases hml : μ = lmb
+    · subst μ; simp
+    · simp [hml, Ne.symm hml]
+  · simp only [hgh, and_false, ite_false]
+    split_ifs <;> simp [hgh]
+
+include hc in
+lemma normal_independent : LinearIndependent K (fun a : Base (H := H) M × H => normal M hζ a.1 a.2) := by
+  rw [linearIndependent_iff']
+  intro s c hs a ha
+  have he := congrArg (fun z => (rho M hζ z a.1 (shift M a.2⁻¹ a.1)).coeff a.2) hs
+  simp only [map_sum, map_smul, Matrix.sum_apply, Matrix.smul_apply,
+    MonoidAlgebra.coeff_sum, MonoidAlgebra.coeff_smul, Finset.sum_apply',
+    Finsupp.smul_apply, Finsupp.zero_apply, smul_eq_mul, map_zero, Matrix.zero_apply, MonoidAlgebra.coeff_zero] at he
+  simp_rw [normal_coordinate M hζ hc] at he
+  have hh (b : Base (H := H) M × H) : b.1 = a.1 ∧ b.2 = a.2 ↔ b = a := Prod.ext_iff.symm
+  simpa only [hh, mul_ite, mul_one, mul_zero, Finset.sum_ite_eq', ite_eq_left ha] using he
+
+instance : Fintype (Wreath (H := H) M) := Fintype.ofFinite _
+
+lemma normal_card
+    {K : Type contextUniverse1}
+    {H : Type contextUniverse2}
+    [Field.{contextUniverse1} K]
+    [Group.{contextUniverse2} H]
+    [Fintype.{contextUniverse2} H]
+    (M : Nat)
+    [@NeZero.{0} Nat (@MulZeroClass.toZero.{0} Nat Nat.instMulZeroClass) M] : Fintype.card (Base (H := H) M × H) =
+    Module.finrank K (MonoidAlgebra K (Wreath (H := H) M)) := by
+  rw [Module.finrank_eq_card_basis (MonoidAlgebra.basis _ K)]
+  apply Fintype.card_congr
+  exact { toFun := fun a => ⟨a.1,a.2⟩
+          invFun := fun g => (g.left,g.right)
+          left_inv := fun _ => rfl
+          right_inv := fun _ => rfl }
+
+def normalBasis : Module.Basis (Base (H := H) M × H) K (MonoidAlgebra K (Wreath (H := H) M)) :=
+  Module.Basis.mk (normal_independent M hζ hc)
+    ((normal_independent M hζ hc).span_eq_top_of_card_eq_finrank' (normal_card (K := K) M)).ge
+@[simp] lemma normalBasis_apply (a : Base (H := H) M × H) :
+    normalBasis M hζ hc a = normal M hζ a.1 a.2 := Module.Basis.mk_apply _ _ _
+
+end
+end OddKaplansky.WreathFourier
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/OddKaplansky/WreathMultiply.lean b/lean/OAI/Algebra/OddKaplansky/WreathMultiply.lean
new file mode 100644
index 0000000000000000000000000000000000000000..a545112b091f301cd01850d37b90040e57579e95
--- /dev/null
+++ b/lean/OAI/Algebra/OddKaplansky/WreathMultiply.lean
@@ -0,0 +1,84 @@
+import OAI.Algebra.OddKaplansky.WreathLinear
+
+namespace OAI
+
+universe contextUniverse1 contextUniverse2
+
+universe portUniverse1 portUniverse2
+
+section
+
+namespace OddKaplansky.WreathFourier
+noncomputable section
+open scoped Classical BigOperators
+variable {K : Type portUniverse1} {H : Type portUniverse2} [Field K] [Group H] [sectionInstance14 : Fintype H]
+variable (M : ℕ) [sectionInstance15 : NeZero M] {ζ : K} (hζ : IsPrimitiveRoot ζ M)
+variable (hc : (Fintype.card (Base (H := H) M) : K) ≠ 0)
+
+@[simp] lemma topElt_mul
+    {K : Type contextUniverse1}
+    {H : Type contextUniverse2}
+    [Field.{contextUniverse1} K]
+    [Group.{contextUniverse2} H]
+    [Fintype.{contextUniverse2} H]
+    (M : Nat)
+    [@NeZero.{0} Nat (@MulZeroClass.toZero.{0} Nat Nat.instMulZeroClass) M] (h g : H) : topElt (K := K) M h * topElt M g = topElt M (h*g) := by
+  simp [topElt,MonoidAlgebra.single_mul_single, ← map_mul]
+@[simp] lemma topElt_one
+    {K : Type contextUniverse1}
+    {H : Type contextUniverse2}
+    [Field.{contextUniverse1} K]
+    [Group.{contextUniverse2} H]
+    [Fintype.{contextUniverse2} H]
+    (M : Nat)
+    [@NeZero.{0} Nat (@MulZeroClass.toZero.{0} Nat Nat.instMulZeroClass) M] : topElt (K := K) (H := H) M 1 = 1 := by rw [topElt,map_one]; rfl
+
+lemma topElt_projector (h : H) (lmb : Base (H := H) M) :
+    topElt M h * projector M hζ lmb = projector M hζ (shift M h lmb) * topElt M h := by
+  calc
+    _ = (topElt M h * projector M hζ lmb * topElt M h⁻¹) * topElt M h := by
+      rw [mul_assoc _ (topElt M h⁻¹),topElt_mul,inv_mul_cancel,topElt_one,mul_one]
+    _ = _ := by rw [translated]
+
+include hc in
+lemma normal_mul (lmb μ : Base (H := H) M) (h g : H) :
+    normal M hζ lmb h * normal M hζ μ g =
+      if lmb = shift M h μ then normal M hζ lmb (h*g) else 0 := by
+  unfold normal
+  have heq : (projector M hζ lmb * topElt M h) * (projector M hζ μ * topElt M g) =
+      (projector M hζ lmb * projector M hζ (shift M h μ)) * (topElt M h * topElt M g) := by
+    rw [mul_assoc, ← mul_assoc (topElt M h), topElt_projector]
+    simp only [mul_assoc]
+  rw [heq,topElt_mul]
+  by_cases he : lmb = shift M h μ
+  · rw [← he,projector_idempotent M hζ hc,ite_eq_left rfl]
+  · rw [projector_orthogonal M hζ _ _ he,zero_mul,ite_eq_right he]
+
+lemma normal_expansion (z : MonoidAlgebra K (Wreath (H := H) M)) :
+    ∑ a : Base (H := H) M × H, (normalBasis M hζ hc).repr z a • normal M hζ a.1 a.2 = z := by
+  simpa only [normalBasis_apply] using (normalBasis M hζ hc).sum_repr z
+
+lemma normal_repr (z : MonoidAlgebra K (Wreath (H := H) M)) (a : Base (H := H) M × H) :
+    (normalBasis M hζ hc).repr z a = (rho M hζ z a.1 (shift M a.2⁻¹ a.1)).coeff a.2 := by
+  have he := congrArg (fun z => (rho M hζ z a.1 (shift M a.2⁻¹ a.1)).coeff a.2)
+    (normal_expansion M hζ hc z)
+  simp only [map_sum, map_smul, Matrix.sum_apply, Matrix.smul_apply,
+    MonoidAlgebra.coeff_sum, MonoidAlgebra.coeff_smul, Finset.sum_apply',
+    Finsupp.smul_apply, smul_eq_mul] at he
+  simp_rw [normal_coordinate M hζ hc] at he
+  have hh (b : Base (H := H) M × H) : b.1 = a.1 ∧ b.2 = a.2 ↔ b = a := Prod.ext_iff.symm
+  simpa only [hh,mul_ite,mul_one,mul_zero,Finset.sum_ite_eq',Finset.mem_univ,ite_true] using he
+
+include hc in
+lemma rho_injective : Function.Injective (rho (K := K) (H := H) M hζ) := by
+  intro z t he
+  apply (normalBasis M hζ hc).repr.injective
+  ext a
+  rw [normal_repr,normal_repr,he]
+
+end
+end OddKaplansky.WreathFourier
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/OddKaplansky/WreathRepresentation.lean b/lean/OAI/Algebra/OddKaplansky/WreathRepresentation.lean
new file mode 100644
index 0000000000000000000000000000000000000000..5f80d3363755384230397cf17eae67044fd698d3
--- /dev/null
+++ b/lean/OAI/Algebra/OddKaplansky/WreathRepresentation.lean
@@ -0,0 +1,86 @@
+import OAI.Algebra.OddKaplansky.WreathFourier
+
+namespace OAI
+
+universe contextUniverse1
+
+universe portUniverse1 portUniverse2
+
+section
+
+namespace OddKaplansky.WreathFourier
+noncomputable section
+open scoped Classical BigOperators
+variable {K : Type portUniverse1} {H : Type portUniverse2} [Field K] [Group H] [sectionInstance11 : Fintype H]
+variable (M : ℕ) [sectionInstance12 : NeZero M] {ζ : K} (hζ : IsPrimitiveRoot ζ M)
+
+@[simp] lemma shift_inverse_shift
+    {H : Type contextUniverse1}
+    [Group.{contextUniverse1} H]
+    [Fintype.{contextUniverse1} H]
+    (M : Nat)
+    [@NeZero.{0} Nat (@MulZeroClass.toZero.{0} Nat Nat.instMulZeroClass) M] (h : H) (a : Base (H := H) M) :
+    shift M h⁻¹ (shift M h a) = a := by funext x; simp
+@[simp] lemma shift_shift_inverse
+    {H : Type contextUniverse1}
+    [Group.{contextUniverse1} H]
+    [Fintype.{contextUniverse1} H]
+    (M : Nat)
+    [@NeZero.{0} Nat (@MulZeroClass.toZero.{0} Nat Nat.instMulZeroClass) M] (h : H) (a : Base (H := H) M) :
+    shift M h (shift M h⁻¹ a) = a := by funext x; simp
+
+lemma character_shift_right (h : H) (lmb a : Base (H := H) M) :
+    Fourier.character M hζ lmb (shift M h a) = Fourier.character M hζ (shift M h⁻¹ lmb) a := by
+  have he := character_shift M hζ h (shift M h⁻¹ lmb) a
+  simpa only [shift_shift_inverse] using he
+
+def rhoGroup : Wreath (H := H) M →*
+    Matrix (Base (H := H) M) (Base (H := H) M) (MonoidAlgebra K H) where
+  toFun g := Matrix.of fun x y => if x = shift M g.right y then
+    MonoidAlgebra.single g.right (Fourier.character M hζ x g.left : K) else 0
+  map_one' := by
+    apply Matrix.ext
+    intro x y
+    simp [Matrix.one_apply, MonoidAlgebra.one_def]
+  map_mul' g k := by
+    apply Matrix.ext
+    intro x y
+    rw [Matrix.mul_apply, Finset.sum_eq_single (shift M k.right y)]
+    · simp only [Matrix.of_apply, RegularWreathProduct.mul_left,
+        RegularWreathProduct.mul_right, shift_mul, ite_true]
+      change (if x = shift M g.right (shift M k.right y) then
+        MonoidAlgebra.single (g.right*k.right)
+          (Fourier.character M hζ x (g.left * shift M g.right k.left) : K) else 0) = _
+      by_cases he : x = shift M g.right (shift M k.right y)
+      · rw [ite_eq_left he, ite_eq_left he, MonoidAlgebra.single_mul_single]
+        congr 1
+        rw [map_mul, Units.val_mul, character_shift_right, he, shift_inverse_shift]
+      · simp [he]
+    · intro z _ hzy
+      simp [hzy]
+    · simp
+
+def rho : MonoidAlgebra K (Wreath (H := H) M) →ₐ[K]
+    Matrix (Base (H := H) M) (Base (H := H) M) (MonoidAlgebra K H) :=
+  MonoidAlgebra.lift K _ _ (rhoGroup M hζ)
+
+lemma rho_single (g : Wreath (H := H) M) (c : K) (x y : Base (H := H) M) :
+    rho M hζ (MonoidAlgebra.single g c) x y =
+    if x = shift M g.right y then MonoidAlgebra.single g.right
+      (c * (Fourier.character M hζ x g.left : K)) else 0 := by
+  rw [rho, MonoidAlgebra.lift_single]
+  change c • (if x = shift M g.right y then
+    MonoidAlgebra.single g.right (Fourier.character M hζ x g.left : K) else 0) = _
+  split_ifs <;> simp
+
+lemma rho_top (h : H) (x y : Base (H := H) M) : rho M hζ (topElt M h) x y =
+    if x = shift M h y then MonoidAlgebra.single h 1 else 0 := by
+  rw [topElt, rho_single]
+  simp [top]
+
+end
+end OddKaplansky.WreathFourier
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/OrderedStates/RationalCone.lean b/lean/OAI/Algebra/OrderedStates/RationalCone.lean
new file mode 100644
index 0000000000000000000000000000000000000000..44cc0525823384b13182b8a084c546bb840059c0
--- /dev/null
+++ b/lean/OAI/Algebra/OrderedStates/RationalCone.lean
@@ -0,0 +1,255 @@
+/-
+Portions of this file have been adapted from an external source.
+The source copyright header and license information are preserved below.
+-/
+
+import Mathlib.Algebra.Algebra.Rat
+import Mathlib.Algebra.Order.Group.Unbundled.Basic
+import Mathlib.Algebra.Order.Module.Rat
+import Mathlib.Analysis.Convex.Cone.Extension
+import Mathlib.Geometry.Convex.Cone.Pointed
+import Mathlib.GroupTheory.DivisibleHull
+
+namespace OAI
+
+noncomputable section
+
+/-! Rational cones and extension of positive states on ordered groups. -/
+
+namespace Kaplansky
+
+section
+variable {G : Type*} [AddCommGroup G] [PartialOrder G] [IsOrderedAddMonoid G]
+
+/-- Positive fractions in the rational hull. A positive numerator may be
+chosen after multiplying numerator and denominator; no unperforation of G
+is assumed. -/
+def orderedGroupRationalCone : PointedCone ℚ (DivisibleHull G) where
+  carrier := {x | ∃ g : G, ∃ d : ℕ+, 0 ≤ g ∧ DivisibleHull.mk g d = x}
+  zero_mem' := ⟨0,1,le_rfl,by simp⟩
+  add_mem' := by
+    rintro _ _ ⟨g,d,hg,rfl⟩ ⟨h,e,hh,rfl⟩
+    exact ⟨e.val • g+d.val • h,d*e,
+      add_nonneg (nsmul_nonneg hg _) (nsmul_nonneg hh _),DivisibleHull.mk_add_mk.symm⟩
+  smul_mem' := by
+    rintro ⟨q,hq⟩ _ ⟨g,d,hg,rfl⟩
+    refine ⟨q.num • g,⟨q.den,q.den_pos⟩*d,?_,?_⟩
+    · exact zsmul_nonneg hg (Rat.num_nonneg.mpr hq)
+    · exact (DivisibleHull.qsmul_mk q g d).symm
+
+theorem orderedGroupRationalCone_coe {g : G} (hg : 0 ≤ g) :
+    (g : DivisibleHull G) ∈ orderedGroupRationalCone := ⟨g,1,hg,rfl⟩
+
+/-- A unit with no nonpositive positive multiple stays outside the
+negative of the rational cone, even if the group has torsion elsewhere. -/
+theorem orderedGroupRationalCone_neg_unit (u : G)
+    (hu : ∀ n : ℕ, 0 < n → ¬ n • u ≤ 0) :
+    -(u : DivisibleHull G) ∉ orderedGroupRationalCone := by
+  rintro ⟨g,d,hg,he⟩
+  change DivisibleHull.mk g d = -DivisibleHull.mk u 1 at he
+  rw [DivisibleHull.neg_mk] at he
+  obtain ⟨k,hk⟩ := DivisibleHull.mk_eq_mk.mp he
+  simp only [PNat.val_ofNat, one_nsmul, smul_neg, smul_smul] at hk
+  have hp : 0 ≤ -((k.val*d.val) • u) := by
+    rw [← hk]
+    exact nsmul_nonneg hg _
+  exact hu (k.val*d.val) (Nat.mul_pos k.pos d.pos) (neg_nonneg.mp hp)
+
+theorem orderedGroupRationalCone_unit_ne_zero (u : G)
+    (hu : ∀ n : ℕ, 0 < n → ¬ n • u ≤ 0) : (u : DivisibleHull G) ≠ 0 := by
+  intro h
+  apply orderedGroupRationalCone_neg_unit u hu
+  rw [h, neg_zero]
+  exact (orderedGroupRationalCone (G := G)).zero_mem
+
+/-- Nonnegativity along the rational unit ray is reflected in its scalar. -/
+theorem orderedGroupRationalCone_unit_scalar (u : G)
+    (hu : ∀ n : ℕ, 0 < n → ¬ n • u ≤ 0) {q : ℚ}
+    (hq : q • (u : DivisibleHull G) ∈ orderedGroupRationalCone) : 0 ≤ q := by
+  by_contra h
+  have hn : q < 0 := lt_of_not_ge h
+  have hp : 0 < -q⁻¹ := neg_pos.mpr (inv_neg''.mpr hn)
+  have hc := (orderedGroupRationalCone (G := G)).smul_mem hp.le hq
+  rw [smul_smul, neg_mul, inv_mul_cancel₀ hn.ne, neg_one_smul] at hc
+  exact orderedGroupRationalCone_neg_unit u hu hc
+
+/-- An order unit in G dominates every rational fraction after passage
+to the cone. The dominating vector is an integer multiple of the unit. -/
+theorem orderedGroupRationalCone_cofinal (u : G) (hu : 0 ≤ u)
+    (hb : ∀ g : G, ∃ N : ℕ, -(N • u) ≤ g) (x : DivisibleHull G) :
+    ∃ N : ℕ, (N : ℚ) • (u : DivisibleHull G) + x ∈ orderedGroupRationalCone := by
+  induction x using DivisibleHull.ind with | mk g d =>
+  obtain ⟨N,hN⟩ := hb g
+  refine ⟨N, ?_⟩
+  have hunit : N • u ≤ d.val • (N • u) := by
+    simpa only [one_nsmul] using
+      nsmul_le_nsmul_left (nsmul_nonneg hu N) (Nat.one_le_iff_ne_zero.mpr d.ne_zero)
+  have hnon : 0 ≤ d.val • (N • u)+g := by
+    have h := (neg_le_neg hunit).trans hN
+    simpa only [add_comm] using neg_le_iff_add_nonneg.mp h
+  refine ⟨d.val • (N • u)+g,d,hnon,?_⟩
+  rw [Nat.cast_smul_eq_nsmul ℚ N, DivisibleHull.coe, DivisibleHull.nsmul_mk,
+    DivisibleHull.mk_add_mk]
+  simp
+
+end
+
+section
+open Set LinearMap
+variable {E : Type*} [AddCommGroup E] [Module ℚ E]
+
+/-
+Copyright (c) 2020 Yury Kudryashov. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Yury Kudryashov, Frédéric Dupuis
+
+The Riesz extension declarations below are adapted from Mathlib.Analysis.Convex.Cone.Extension.
+Source: https://github.com/leanprover-community/mathlib4/blob/d13f23b723b8a846827a245b89c10fc7d3f11612/Mathlib/Analysis/Convex/Cone/Extension.lean
+
+This code has been modified.
+-/
+
+namespace RationalRieszExtension
+
+open Submodule
+
+variable (s : PointedCone ℚ E) (f : E →ₗ.[ℚ] ℝ)
+
+/-- Induction step in M. Riesz extension theorem. Given a convex cone `s` in a vector space `E`,
+a partially defined linear map `f : f.domain → ℝ`, assume that `f` is nonnegative on `f.domain ∩ p`
+and `p + s = E`. If `f` is not defined on the whole `E`, then we can extend it to a larger
+submodule without breaking the non-negativity condition. -/
+theorem step (nonneg : ∀ x : f.domain, (x : E) ∈ s → 0 ≤ f x)
+    (dense : ∀ y, ∃ x : f.domain, (x : E) + y ∈ s) (hdom : f.domain ≠ ⊤) :
+    ∃ g, f < g ∧ ∀ x : g.domain, (x : E) ∈ s → 0 ≤ g x := by
+  obtain ⟨y, -, hy⟩ : ∃ y ∈ ⊤, y ∉ f.domain := SetLike.exists_of_lt (lt_top_iff_ne_top.2 hdom)
+  obtain ⟨c, le_c, c_le⟩ :
+      ∃ c, (∀ x : f.domain, -(x : E) - y ∈ s → f x ≤ c) ∧
+        ∀ x : f.domain, (x : E) + y ∈ s → c ≤ f x := by
+    set Sp := f '' { x : f.domain | (x : E) + y ∈ s }
+    set Sn := f '' { x : f.domain | -(x : E) - y ∈ s }
+    suffices (upperBounds Sn ∩ lowerBounds Sp).Nonempty by
+      simpa only [Sp, Sn, Set.Nonempty, upperBounds, lowerBounds, forall_mem_image] using! this
+    refine exists_between_of_forall_le (Nonempty.image f ?_) (Nonempty.image f (dense y)) ?_
+    · rcases dense (-y) with ⟨x, hx⟩
+      rw [← neg_neg x, NegMemClass.coe_neg, ← sub_eq_add_neg] at hx
+      exact ⟨_, hx⟩
+    rintro a ⟨xn, hxn, rfl⟩ b ⟨xp, hxp, rfl⟩
+    have := s.add_mem hxp hxn
+    rw [add_assoc, add_sub_cancel, ← sub_eq_add_neg, ← AddSubgroupClass.coe_sub] at this
+    replace := nonneg _ this
+    rwa [f.map_sub, sub_nonneg] at this
+  refine ⟨f.supSpanSingleton y (-c) hy, ?_, ?_⟩
+  · refine lt_iff_le_not_ge.2 ⟨f.left_le_sup _ _, fun H => ?_⟩
+    replace H := LinearPMap.domain_mono.monotone H
+    rw [LinearPMap.domain_supSpanSingleton, sup_le_iff, span_le, singleton_subset_iff] at H
+    exact hy H.2
+  · rintro ⟨z, hz⟩ hzs
+    rcases mem_sup.1 hz with ⟨x, hx, y', hy', rfl⟩
+    rcases mem_span_singleton.1 hy' with ⟨r, rfl⟩
+    simp only at hzs
+    rw [LinearPMap.supSpanSingleton_apply_mk _ _ _ _ _ hx, smul_neg, ← sub_eq_add_neg, sub_nonneg]
+    rcases lt_trichotomy r 0 with (hr | hr | hr)
+    · have : -(r⁻¹ • x) - y ∈ s := by
+        rwa [← s.smul_mem_iff (neg_pos.2 hr), smul_sub, smul_neg, neg_smul, neg_neg, smul_smul,
+          mul_inv_cancel₀ hr.ne, one_smul, sub_eq_add_neg, neg_smul, neg_neg]
+      replace := le_c (r⁻¹ • ⟨x, hx⟩) this
+      have hm := smul_le_smul_of_nonpos_left this hr.le
+      simpa only [f.map_smul, RingHom.id_apply, smul_smul, mul_inv_cancel₀ hr.ne, one_smul] using hm
+    · subst r
+      simp only [zero_smul, add_zero] at hzs ⊢
+      rw [RingHom.id_apply, zero_smul]
+      apply nonneg
+      exact hzs
+    · have : r⁻¹ • x + y ∈ s := by
+        rwa [← s.smul_mem_iff hr, smul_add, smul_smul, mul_inv_cancel₀ hr.ne', one_smul]
+      replace := c_le (r⁻¹ • ⟨x, hx⟩) this
+      have hm := smul_le_smul_of_nonneg_left this hr.le
+      simpa only [f.map_smul, RingHom.id_apply, smul_smul, mul_inv_cancel₀ hr.ne', one_smul] using hm
+
+theorem exists_top (p : E →ₗ.[ℚ] ℝ) (hp_nonneg : ∀ x : p.domain, (x : E) ∈ s → 0 ≤ p x)
+    (hp_dense : ∀ y, ∃ x : p.domain, (x : E) + y ∈ s) :
+    ∃ q ≥ p, q.domain = ⊤ ∧ ∀ x : q.domain, (x : E) ∈ s → 0 ≤ q x := by
+  set S := { p : E →ₗ.[ℚ] ℝ | ∀ x : p.domain, (x : E) ∈ s → 0 ≤ p x }
+  have hSc : ∀ c, c ⊆ S → IsChain (· ≤ ·) c → ∀ y ∈ c, ∃ ub ∈ S, ∀ z ∈ c, z ≤ ub := by
+    intro c hcs c_chain y hy
+    clear hp_nonneg hp_dense p
+    have cne : c.Nonempty := ⟨y, hy⟩
+    have hcd : DirectedOn (· ≤ ·) c := c_chain.directedOn
+    refine ⟨LinearPMap.sSup c hcd, ?_, fun _ ↦ LinearPMap.le_sSup hcd⟩
+    rintro ⟨x, hx⟩ hxs
+    have hdir : DirectedOn (· ≤ ·) (LinearPMap.domain '' c) :=
+      directedOn_image.2 (hcd.mono LinearPMap.domain_mono.monotone)
+    rcases (mem_sSup_of_directed (cne.image _) hdir).1 hx with ⟨_, ⟨f, hfc, rfl⟩, hfx⟩
+    have : f ≤ LinearPMap.sSup c hcd := LinearPMap.le_sSup _ hfc
+    convert! ← hcs hfc ⟨x, hfx⟩ hxs using 1
+    exact this.2 rfl
+  obtain ⟨q, hpq, hqs, hq⟩ := zorn_le_nonempty₀ S hSc p hp_nonneg
+  refine ⟨q, hpq, ?_, hqs⟩
+  contrapose! hq
+  have hqd : ∀ y, ∃ x : q.domain, (x : E) + y ∈ s := fun y ↦
+    let ⟨x, hx⟩ := hp_dense y
+    ⟨Submodule.inclusion hpq.left x, hx⟩
+  rcases step s q hqs hqd hq with ⟨r, hqr, hr⟩
+  exact ⟨r, hr, hqr.le, fun hrq ↦ hqr.ne' <| hrq.antisymm hqr.le⟩
+
+end RationalRieszExtension
+
+/-- M. **Riesz extension theorem**: given a convex cone `s` in a vector space `E`, a submodule `p`,
+and a linear `f : p → ℝ`, assume that `f` is nonnegative on `p ∩ s` and `p + s = E`. Then
+there exists a globally defined linear function `g : E → ℝ` that agrees with `f` on `p`,
+and is nonnegative on `s`. -/
+theorem rational_riesz_extension (s : PointedCone ℚ E) (f : E →ₗ.[ℚ] ℝ)
+    (nonneg : ∀ x : f.domain, (x : E) ∈ s → 0 ≤ f x)
+    (dense : ∀ y, ∃ x : f.domain, (x : E) + y ∈ s) :
+    ∃ g : E →ₗ[ℚ] ℝ, (∀ x : f.domain, g x = f x) ∧ ∀ x ∈ s, 0 ≤ g x := by
+  rcases RationalRieszExtension.exists_top s f nonneg dense
+    with ⟨⟨g_dom, g⟩, ⟨-, hfg⟩, rfl : g_dom = ⊤, hgs⟩
+  refine ⟨g.comp (LinearMap.id.codRestrict ⊤ fun _ ↦ trivial), ?_, ?_⟩
+  · exact fun x => (hfg rfl).symm
+  · exact fun x hx => hgs ⟨x, _⟩ hx
+
+end
+
+variable {G : Type*} [AddCommGroup G] [PartialOrder G] [IsOrderedAddMonoid G]
+
+/-- A normalized monotone real-valued additive state on an ordered group
+with an order unit. Positive unit multiples must not be nonpositive.
+Neither linear order nor unperforation of the group is assumed. -/
+theorem orderedGroup_normalized_state (u : G) (hu : 0 ≤ u)
+    (hn : ∀ n : ℕ, 0 < n → ¬ n • u ≤ 0)
+    (hb : ∀ g : G, ∃ N : ℕ, -(N • u) ≤ g) :
+    ∃ f : G →+ ℝ, Monotone f ∧ f u = 1 := by
+  let v : DivisibleHull G := u
+  have hv : v ≠ 0 := orderedGroupRationalCone_unit_ne_zero u hn
+  let p : DivisibleHull G →ₗ.[ℚ] ℝ := LinearPMap.mkSpanSingleton v 1 hv
+  have hp : ∀ x : p.domain, (x : DivisibleHull G) ∈ orderedGroupRationalCone → 0 ≤ p x := by
+    rintro ⟨x,hx⟩ hxc
+    obtain ⟨q,rfl⟩ := Submodule.mem_span_singleton.mp hx
+    have hq : 0 ≤ q := orderedGroupRationalCone_unit_scalar u hn hxc
+    change 0 ≤ LinearPMap.mkSpanSingleton' v (1 : ℝ) _ ⟨q • v, _⟩
+    rw [LinearPMap.mkSpanSingleton'_apply]
+    simpa using (smul_nonneg hq (zero_le_one : (0 : ℝ) ≤ 1))
+  have hd : ∀ y : DivisibleHull G, ∃ x : p.domain, (x : DivisibleHull G)+y ∈ orderedGroupRationalCone := by
+    intro y
+    obtain ⟨N,hN⟩ := orderedGroupRationalCone_cofinal u hu hb y
+    exact ⟨⟨(N : ℚ) • v, Submodule.smul_mem _ _ (Submodule.mem_span_singleton_self v)⟩,hN⟩
+  obtain ⟨g,hg,hpos⟩ := rational_riesz_extension orderedGroupRationalCone p hp hd
+  let f : G →+ ℝ := g.toAddMonoidHom.comp (DivisibleHull.coeAddMonoidHom G)
+  have hfpos : ∀ x : G, 0 ≤ x → 0 ≤ f x := by
+    intro x hx
+    exact hpos _ (orderedGroupRationalCone_coe hx)
+  refine ⟨f,?_,?_⟩
+  · intro a b hab
+    have h := hfpos (b-a) (sub_nonneg.mpr hab)
+    rwa [map_sub,sub_nonneg] at h
+  · have he := hg ⟨v,Submodule.mem_span_singleton_self v⟩
+    change g v = 1
+    rw [he]
+    exact LinearPMap.mkSpanSingleton_apply ℚ ℚ hv (1 : ℝ)
+
+end Kaplansky
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/OrderedStates/Semigroup.lean b/lean/OAI/Algebra/OrderedStates/Semigroup.lean
new file mode 100644
index 0000000000000000000000000000000000000000..082481fe80d49f5183dc3fc45b2b877ff6aa2acb
--- /dev/null
+++ b/lean/OAI/Algebra/OrderedStates/Semigroup.lean
@@ -0,0 +1,498 @@
+import OAI.Algebra.OrderedStates.RationalCone
+import Lean.Elab.Tactic.Omega
+import Mathlib.Algebra.Group.Hom.Defs
+import Mathlib.Algebra.Group.Prod
+import Mathlib.Algebra.Group.Submonoid.Basic
+import Mathlib.Algebra.Order.Group.Defs
+import Mathlib.Algebra.Order.Monoid.Defs
+import Mathlib.Algebra.Order.Monoid.Unbundled.Pow
+import Mathlib.Basic.Real.Basic
+import Mathlib.Order.Antisymmetrization
+import Mathlib.Tactic.Abel
+
+namespace OAI
+
+noncomputable section
+
+/-! Catalytic orders, ordered group completion, and normalized semigroup states. -/
+
+namespace Kaplansky
+
+section
+variable {S : Type*} [AddCommMonoid S] [PartialOrder S] [IsOrderedAddMonoid S]
+
+/-- An order compression of successive multiples iterates without any
+cancellation assumption. -/
+theorem nsmul_compression_iterate (u : S) (m : ℕ)
+    (h : (m+1) • u ≤ m • u) : ∀ k : ℕ, (m+k) • u ≤ m • u := by
+  intro k
+  induction k with
+  | zero => simp
+  | succ k ih =>
+      calc
+        (m+(k+1)) • u = (m+k) • u + u := by simp only [← Nat.add_assoc, add_nsmul, one_nsmul]
+        _ ≤ m • u + u := add_le_add ih le_rfl
+        _ = (m+1) • u := by simp only [add_nsmul, one_nsmul]
+        _ ≤ m • u := h
+
+/-- The ordered-semigroup arithmetic used in MR Theorem 2.3: if a larger
+multiple of the unit is below a smaller one, some positive multiple is
+properly infinite in the semigroup sense. No Cuntz correspondence is assumed. -/
+theorem nsmul_compression_doubles (u : S) (hu : 0 ≤ u) {m n : ℕ}
+    (hmn : m < n) (h : n • u ≤ m • u) :
+    ∃ k : ℕ, 0 < k ∧ (2*k) • u ≤ k • u := by
+  have hstep : (m+1) • u ≤ m • u :=
+    (nsmul_le_nsmul_left hu (by omega)).trans h
+  by_cases hm : m = 0
+  · subst m
+    have hu0 : u ≤ 0 := by simpa only [Nat.zero_add, one_nsmul, zero_nsmul] using hstep
+    refine ⟨1,by omega,?_⟩
+    simpa only [Nat.mul_one, two_nsmul, one_nsmul, add_zero] using add_le_add le_rfl hu0
+  · refine ⟨m,by omega,?_⟩
+    simpa [Nat.two_mul] using nsmul_compression_iterate u m hstep m
+
+/-- Absence of a properly infinite positive multiple makes the ordinary
+natural multiples of the unit order-reflecting. This is the first
+semigroup step toward quasitrace existence, not that existence theorem. -/
+theorem nsmul_unit_order_iff (u : S) (hu : 0 ≤ u)
+    (hfinite : ∀ k : ℕ, 0 < k → ¬ (2*k) • u ≤ k • u) (m n : ℕ) :
+    m • u ≤ n • u ↔ m ≤ n := by
+  constructor
+  · intro h
+    by_contra hmn
+    obtain ⟨k,hk,hk'⟩ := nsmul_compression_doubles u hu (by omega : n < m) h
+    exact hfinite k hk hk'
+  · exact nsmul_le_nsmul_left hu
+
+/-- The ordinary cyclic additive submonoid generated by the order unit. -/
+def unitCyclicMonoid (u : S) : AddSubmonoid S where
+  carrier := Set.range (fun n : ℕ => n • u)
+  zero_mem' := ⟨0,zero_nsmul u⟩
+  add_mem' := by
+    rintro a b ⟨m,rfl⟩ ⟨n,rfl⟩
+    exact ⟨m+n,add_nsmul u m n⟩
+
+def cyclicIndex (u : S) (v : unitCyclicMonoid u) : ℕ := v.property.choose
+
+omit [PartialOrder S] [IsOrderedAddMonoid S] in
+theorem cyclicIndex_spec (u : S) (v : unitCyclicMonoid u) :
+    cyclicIndex u v • u = v.val := v.property.choose_spec
+
+theorem unit_nsmul_injective (u : S) (hu : 0 ≤ u)
+    (hf : ∀ k : ℕ, 0 < k → ¬ (2*k) • u ≤ k • u) :
+    Function.Injective (fun n : ℕ => n • u) := by
+  intro m n h
+  apply Nat.le_antisymm
+  · exact (nsmul_unit_order_iff u hu hf m n).mp h.le
+  · exact (nsmul_unit_order_iff u hu hf n m).mp h.symm.le
+
+def cyclicUnitState (u : S) (hu : 0 ≤ u)
+    (hf : ∀ k : ℕ, 0 < k → ¬ (2*k) • u ≤ k • u) : unitCyclicMonoid u →+ ℝ where
+  toFun v := (cyclicIndex u v : ℝ)
+  map_zero' := by
+    have hz : cyclicIndex u 0 = 0 := unit_nsmul_injective u hu hf
+      (by simpa using cyclicIndex_spec u 0)
+    simp [hz]
+  map_add' a b := by
+    have he : cyclicIndex u (a+b) = cyclicIndex u a + cyclicIndex u b := by
+      apply unit_nsmul_injective u hu hf
+      change cyclicIndex u (a+b) • u = (cyclicIndex u a + cyclicIndex u b) • u
+      rw [cyclicIndex_spec, add_nsmul, cyclicIndex_spec, cyclicIndex_spec]
+      rfl
+    simp [he]
+
+theorem cyclicUnitState_nsmul (u : S) (hu : 0 ≤ u)
+    (hf : ∀ k : ℕ, 0 < k → ¬ (2*k) • u ≤ k • u) (n : ℕ) :
+    cyclicUnitState u hu hf ⟨n • u,⟨n,rfl⟩⟩ = (n : ℝ) := by
+  change (cyclicIndex u ⟨n • u,⟨n,rfl⟩⟩ : ℝ) = n
+  exact congrArg Nat.cast (unit_nsmul_injective u hu hf (cyclicIndex_spec u _))
+
+theorem cyclicUnitState_monotone (u : S) (hu : 0 ≤ u)
+    (hf : ∀ k : ℕ, 0 < k → ¬ (2*k) • u ≤ k • u) :
+    Monotone (cyclicUnitState u hu hf) := by
+  intro a b hab
+  change (cyclicIndex u a : ℝ) ≤ (cyclicIndex u b : ℝ)
+  apply Nat.cast_le.mpr
+  apply (nsmul_unit_order_iff u hu hf _ _).mp
+  rw [cyclicIndex_spec, cyclicIndex_spec]
+  exact hab
+
+end
+
+section
+variable {S : Type*} [AddCommMonoid S] [PartialOrder S] [IsOrderedAddMonoid S]
+
+/-- A common summand can be retained while a comparison is iterated.
+There is no cancellation assumption on the monoid. -/
+theorem catalytic_nsmul_le {a b c : S} (h : a + c ≤ b + c) (k : ℕ) :
+    k • a + c ≤ k • b + c := by
+  induction k with
+  | zero => simp
+  | succ k ih =>
+    calc
+      (k+1) • a + c = a + (k • a + c) := by simp only [add_nsmul, one_nsmul]; ac_rfl
+      _ ≤ a + (k • b + c) := add_le_add le_rfl ih
+      _ = k • b + (a + c) := by ac_rfl
+      _ ≤ k • b + (b + c) := add_le_add le_rfl h
+      _ = (k+1) • b + c := by simp only [add_nsmul, one_nsmul, add_assoc]
+
+/-- A bounded nonnegative common summand cannot hide a compression of
+unit multiples when every positive multiple fails to be properly infinite. -/
+theorem catalytic_unit_order_iff (u : S) (hu : 0 ≤ u)
+    (hf : ∀ k : ℕ, 0 < k → ¬ (2*k) • u ≤ k • u)
+    {c : S} (hc : 0 ≤ c) (hcu : ∃ N : ℕ, c ≤ N • u) (m n : ℕ) :
+    m • u + c ≤ n • u + c ↔ m ≤ n := by
+  constructor
+  · intro h
+    obtain ⟨N, hN⟩ := hcu
+    have hi := catalytic_nsmul_le h (N+1)
+    have hcomp : ((N+1)*m) • u ≤ ((N+1)*n+N) • u := by
+      calc
+        ((N+1)*m) • u ≤ ((N+1)*m) • u + c := le_add_of_nonneg_right hc
+        _ ≤ ((N+1)*n) • u + c := by simpa only [← mul_nsmul, Nat.mul_comm] using hi
+        _ ≤ ((N+1)*n) • u + N • u := add_le_add le_rfl hN
+        _ = ((N+1)*n+N) • u := (add_nsmul _ _ _).symm
+    have hn := (nsmul_unit_order_iff u hu hf _ _).mp hcomp
+    by_contra hmn
+    have hmn' : n+1 ≤ m := by omega
+    have hmul := Nat.mul_le_mul_left (N+1) hmn'
+    simp only [Nat.mul_add, Nat.mul_one] at hmul
+    omega
+  · intro h
+    exact add_le_add (nsmul_le_nsmul_left hu h) le_rfl
+
+/-- Stabilization by an arbitrary common summand preserves the natural
+order on the unit if every element is nonnegative and bounded by a unit multiple. -/
+theorem stabilized_unit_order_iff (u : S) (hu : 0 ≤ u)
+    (hf : ∀ k : ℕ, 0 < k → ¬ (2*k) • u ≤ k • u)
+    (hpos : ∀ c : S, 0 ≤ c) (hbound : ∀ c : S, ∃ N : ℕ, c ≤ N • u)
+    (m n : ℕ) :
+    (∃ c : S, m • u + c ≤ n • u + c) ↔ m ≤ n := by
+  constructor
+  · rintro ⟨c, hc⟩
+    exact (catalytic_unit_order_iff u hu hf (hpos c) (hbound c) m n).mp hc
+  · intro h
+    exact ⟨0, by simpa using nsmul_le_nsmul_left hu h⟩
+
+end
+
+section
+variable (S : Type*) [AddCommMonoid S] [PartialOrder S] [IsOrderedAddMonoid S]
+
+/-- Formal differences, before identifying order-equivalent pairs. -/
+def SemigroupDifference := S × S
+
+instance : AddCommMonoid (SemigroupDifference S) :=
+  inferInstanceAs (AddCommMonoid (S × S))
+
+variable {S}
+
+/-- The stabilizing summand records the cancellation which is unavailable
+in the original monoid. -/
+def SemigroupDifference.Rel (a b : SemigroupDifference S) : Prop :=
+  ∃ c : S, a.1 + b.2 + c ≤ b.1 + a.2 + c
+
+omit [IsOrderedAddMonoid S] in
+theorem SemigroupDifference.rel_refl (a : SemigroupDifference S) : Rel a a := ⟨0, le_rfl⟩
+
+theorem SemigroupDifference.rel_trans {a b c : SemigroupDifference S}
+    (hab : Rel a b) (hbc : Rel b c) : Rel a c := by
+  obtain ⟨x, hx⟩ := hab
+  obtain ⟨y, hy⟩ := hbc
+  refine ⟨x+y+b.1+b.2, ?_⟩
+  convert add_le_add hx hy using 1 <;> ac_rfl
+
+instance : Preorder (SemigroupDifference S) where
+  le := SemigroupDifference.Rel
+  le_refl := SemigroupDifference.rel_refl
+  le_trans _ _ _ := SemigroupDifference.rel_trans
+
+theorem SemigroupDifference.add_le_add {a b c d : SemigroupDifference S}
+    (hab : a ≤ b) (hcd : c ≤ d) : a+c ≤ b+d := by
+  obtain ⟨x, hx⟩ := hab
+  obtain ⟨y, hy⟩ := hcd
+  refine ⟨x+y, ?_⟩
+  change (a.1+c.1)+(b.2+d.2)+(x+y) ≤ (b.1+d.1)+(a.2+c.2)+(x+y)
+  convert _root_.add_le_add hx hy using 1 <;> ac_rfl
+
+def SemigroupDifference.flip (a : SemigroupDifference S) : SemigroupDifference S := (a.2,a.1)
+
+theorem SemigroupDifference.flip_le_flip {a b : SemigroupDifference S} (h : a ≤ b) :
+    flip b ≤ flip a := by
+  obtain ⟨x, hx⟩ := h
+  refine ⟨x, ?_⟩
+  change b.2+a.1+x ≤ a.2+b.1+x
+  simpa only [add_comm] using hx
+
+/-- Ordered group completion: order-equivalent differences are identified.
+This need not embed the original noncancellative monoid injectively. -/
+abbrev SemigroupOrderedGroup (S : Type*) [AddCommMonoid S] [PartialOrder S]
+    [IsOrderedAddMonoid S] := Antisymmetrization (SemigroupDifference S) (· ≤ ·)
+
+def semigroupDifferenceClass (a : SemigroupDifference S) : SemigroupOrderedGroup S :=
+  toAntisymmetrization (· ≤ ·) a
+
+theorem semigroupDifferenceClass_le (a b : SemigroupDifference S) :
+    semigroupDifferenceClass a ≤ semigroupDifferenceClass b ↔
+      ∃ c : S, a.1+b.2+c ≤ b.1+a.2+c :=
+  toAntisymmetrization_le_toAntisymmetrization_iff
+
+instance : Zero (SemigroupOrderedGroup S) := ⟨semigroupDifferenceClass 0⟩
+
+instance : Add (SemigroupOrderedGroup S) where
+  add := Quotient.map₂ (· + ·) (fun _ _ ha _ _ hb =>
+    ⟨SemigroupDifference.add_le_add ha.1 hb.1,
+      SemigroupDifference.add_le_add ha.2 hb.2⟩)
+
+instance : Neg (SemigroupOrderedGroup S) where
+  neg := Quotient.map SemigroupDifference.flip (fun _ _ h =>
+    ⟨SemigroupDifference.flip_le_flip h.2, SemigroupDifference.flip_le_flip h.1⟩)
+
+@[simp] theorem semigroupDifferenceClass_add (a b : SemigroupDifference S) :
+    semigroupDifferenceClass (a+b) = semigroupDifferenceClass a + semigroupDifferenceClass b := rfl
+
+@[simp] theorem semigroupDifferenceClass_zero :
+    semigroupDifferenceClass (0 : SemigroupDifference S) = 0 := rfl
+
+@[simp] theorem semigroupDifferenceClass_flip (a : SemigroupDifference S) :
+    semigroupDifferenceClass a.flip = -semigroupDifferenceClass a := rfl
+
+instance : AddCommGroup (SemigroupOrderedGroup S) where
+  add_assoc a b c := by
+    induction a using Quotient.inductionOn with | h a =>
+    induction b using Quotient.inductionOn with | h b =>
+    induction c using Quotient.inductionOn with | h c =>
+    exact congrArg semigroupDifferenceClass (add_assoc a b c)
+  zero_add a := by
+    induction a using Quotient.inductionOn with | h a =>
+    exact congrArg semigroupDifferenceClass (zero_add a)
+  add_zero a := by
+    induction a using Quotient.inductionOn with | h a =>
+    exact congrArg semigroupDifferenceClass (add_zero a)
+  add_comm a b := by
+    induction a using Quotient.inductionOn with | h a =>
+    induction b using Quotient.inductionOn with | h b =>
+    exact congrArg semigroupDifferenceClass (add_comm a b)
+  neg_add_cancel a := by
+    induction a using Quotient.inductionOn with | h a =>
+    apply Quotient.sound
+    constructor
+    · refine ⟨0, ?_⟩
+      change a.2+a.1+0+0 ≤ 0+(a.1+a.2)+0
+      simp [add_comm]
+    · refine ⟨0, ?_⟩
+      change 0+(a.1+a.2)+0 ≤ a.2+a.1+0+0
+      simp [add_comm]
+  nsmul := nsmulRec
+  zsmul := zsmulRec
+
+instance : IsOrderedAddMonoid (SemigroupOrderedGroup S) where
+  add_le_add_left a b h c := by
+    induction a using Quotient.inductionOn with | h a =>
+    induction b using Quotient.inductionOn with | h b =>
+    induction c using Quotient.inductionOn with | h c =>
+    exact (semigroupDifferenceClass_le _ _).mpr
+      (SemigroupDifference.add_le_add ((semigroupDifferenceClass_le _ _).mp h) (le_refl c))
+
+/-- The actual additive map from the monoid into its ordered completion. -/
+def semigroupToOrderedGroup : S →+ SemigroupOrderedGroup S where
+  toFun a := semigroupDifferenceClass (a,0)
+  map_zero' := rfl
+  map_add' a b := by
+    change semigroupDifferenceClass (a+b,0) = semigroupDifferenceClass ((a,0)+(b,0))
+    congr 1
+    exact Prod.ext rfl (zero_add 0).symm
+
+theorem semigroupToOrderedGroup_le_iff (a b : S) :
+    semigroupToOrderedGroup a ≤ semigroupToOrderedGroup b ↔ ∃ c : S, a+c ≤ b+c := by
+  change semigroupDifferenceClass (a,0) ≤ semigroupDifferenceClass (b,0) ↔ _
+  simpa only [add_zero] using semigroupDifferenceClass_le (a,0) (b,0)
+
+theorem semigroupToOrderedGroup_monotone : Monotone (semigroupToOrderedGroup (S := S)) := by
+  intro a b hab
+  exact (semigroupToOrderedGroup_le_iff a b).mpr ⟨0, by simpa using hab⟩
+
+end
+
+section
+variable {S : Type*} [AddCommMonoid S] [PartialOrder S] [IsOrderedAddMonoid S]
+
+theorem semigroupDifferenceClass_eq_sub (a b : S) :
+    semigroupDifferenceClass (a,b) = semigroupToOrderedGroup a - semigroupToOrderedGroup b := by
+  change semigroupDifferenceClass (a,b) = semigroupDifferenceClass ((a,0)+(0,b))
+  congr 1
+  exact Prod.ext (add_zero a).symm (zero_add b).symm
+
+theorem semigroupOrderedGroup_exists_difference (x : SemigroupOrderedGroup S) :
+    ∃ a b : S, x = semigroupToOrderedGroup a - semigroupToOrderedGroup b := by
+  induction x using Quotient.inductionOn with | h x =>
+  exact ⟨x.1,x.2,semigroupDifferenceClass_eq_sub _ _⟩
+
+/-- The image of the unit remains order-reflecting on all natural multiples,
+including after passage to the ordered group quotient. -/
+theorem semigroupOrderedGroup_unit_order (u : S)
+    (hf : ∀ k : ℕ, 0 < k → ¬ (2*k) • u ≤ k • u)
+    (hpos : ∀ c : S, 0 ≤ c) (hbound : ∀ c : S, ∃ N : ℕ, c ≤ N • u)
+    (m n : ℕ) :
+    m • semigroupToOrderedGroup u ≤ n • semigroupToOrderedGroup u ↔ m ≤ n := by
+  rw [← map_nsmul, ← map_nsmul, semigroupToOrderedGroup_le_iff]
+  exact stabilized_unit_order_iff u (hpos u) hf hpos hbound m n
+
+theorem semigroupOrderedGroup_unit_nonneg (u : S) (hu : 0 ≤ u) :
+    0 ≤ semigroupToOrderedGroup u := by
+  simpa using semigroupToOrderedGroup_monotone hu
+
+theorem semigroupOrderedGroup_unit_ne_zero (u : S)
+    (hf : ∀ k : ℕ, 0 < k → ¬ (2*k) • u ≤ k • u)
+    (hpos : ∀ c : S, 0 ≤ c) (hbound : ∀ c : S, ∃ N : ℕ, c ≤ N • u) :
+    semigroupToOrderedGroup u ≠ 0 := by
+  intro he
+  have h := semigroupOrderedGroup_unit_order u hf hpos hbound 1 0
+  simp [he] at h
+
+/-- The original order-unit bound becomes a two-sided bound on every
+element of the ordered group. No finite generation is needed. -/
+theorem semigroupOrderedGroup_order_unit (u : S)
+    (hpos : ∀ c : S, 0 ≤ c) (hbound : ∀ c : S, ∃ N : ℕ, c ≤ N • u)
+    (x : SemigroupOrderedGroup S) :
+    ∃ N : ℕ, -(N • semigroupToOrderedGroup u) ≤ x ∧
+      x ≤ N • semigroupToOrderedGroup u := by
+  obtain ⟨a,b,rfl⟩ := semigroupOrderedGroup_exists_difference x
+  obtain ⟨m,hm⟩ := hbound a
+  obtain ⟨n,hn⟩ := hbound b
+  have ha := semigroupToOrderedGroup_monotone hm
+  have hb := semigroupToOrderedGroup_monotone hn
+  rw [map_nsmul] at ha hb
+  have hza := semigroupOrderedGroup_unit_nonneg a (hpos a)
+  have hzb := semigroupOrderedGroup_unit_nonneg b (hpos b)
+  have hu := semigroupOrderedGroup_unit_nonneg u (hpos u)
+  refine ⟨m+n, ?_, ?_⟩
+  · have hb' : semigroupToOrderedGroup b ≤ (m+n) • semigroupToOrderedGroup u :=
+      hb.trans (nsmul_le_nsmul_left hu (Nat.le_add_left n m))
+    exact (neg_le_neg hb').trans (neg_le_sub_iff_le_add.mpr (by simpa using hza))
+  · have ha' : semigroupToOrderedGroup a ≤ (m+n) • semigroupToOrderedGroup u :=
+      ha.trans (nsmul_le_nsmul_left hu (Nat.le_add_right m n))
+    exact (sub_le_self _ hzb).trans ha'
+
+variable {G : Type*} [AddCommGroup G] [PartialOrder G] [IsOrderedAddMonoid G]
+
+theorem semigroupDifference_value_mono (f : S →+ G) (hf : Monotone f)
+    {a b : SemigroupDifference S} (h : a ≤ b) :
+    f a.1 - f a.2 ≤ f b.1 - f b.2 := by
+  obtain ⟨c,hc⟩ := h
+  have hh := hf hc
+  simp only [map_add] at hh
+  have hh' := (add_le_add_iff_right (f c)).mp hh
+  exact sub_le_sub_iff.mpr hh'
+
+/-- Every monotone additive map to an ordered group descends to the
+ordered completion. This constructs the map; it does not postulate a state. -/
+def semigroupOrderedGroupLift (f : S →+ G) (hf : Monotone f) : SemigroupOrderedGroup S →+ G where
+  toFun := Quotient.lift (fun a : SemigroupDifference S => f a.1-f a.2)
+    (fun _ _ h => le_antisymm (semigroupDifference_value_mono f hf h.1)
+      (semigroupDifference_value_mono f hf h.2))
+  map_zero' := by change f 0-f 0=0; simp
+  map_add' a b := by
+    induction a using Quotient.inductionOn with | h a =>
+    induction b using Quotient.inductionOn with | h b =>
+    change f (a.1+b.1)-f (a.2+b.2) = (f a.1-f a.2)+(f b.1-f b.2)
+    simp only [map_add]
+    abel
+
+@[simp] theorem semigroupOrderedGroupLift_apply (f : S →+ G) (hf : Monotone f) (a b : S) :
+    semigroupOrderedGroupLift f hf (semigroupDifferenceClass (a,b)) = f a-f b := rfl
+
+@[simp] theorem semigroupOrderedGroupLift_unit (f : S →+ G) (hf : Monotone f) (a : S) :
+    semigroupOrderedGroupLift f hf (semigroupToOrderedGroup a) = f a := by
+  change f a-f 0=f a
+  simp
+
+theorem semigroupOrderedGroupLift_monotone (f : S →+ G) (hf : Monotone f) :
+    Monotone (semigroupOrderedGroupLift f hf) := by
+  intro a b hab
+  induction a using Quotient.inductionOn with | h a =>
+  induction b using Quotient.inductionOn with | h b =>
+  exact semigroupDifference_value_mono f hf ((semigroupDifferenceClass_le _ _).mp hab)
+
+theorem semigroup_state_iff_orderedGroup_state (u : S) :
+    (∃ f : S →+ ℝ, Monotone f ∧ f u = 1) ↔
+      ∃ g : SemigroupOrderedGroup S →+ ℝ, Monotone g ∧ g (semigroupToOrderedGroup u) = 1 := by
+  constructor
+  · rintro ⟨f,hf,hu⟩
+    exact ⟨semigroupOrderedGroupLift f hf,semigroupOrderedGroupLift_monotone f hf,by simpa⟩
+  · rintro ⟨g,hg,hu⟩
+    exact ⟨g.comp semigroupToOrderedGroup,hg.comp semigroupToOrderedGroup_monotone,hu⟩
+
+end
+
+variable {S : Type*} [AddCommMonoid S] [PartialOrder S] [IsOrderedAddMonoid S]
+
+/-- State construction on a positive ordered commutative monoid with an
+order unit and no properly infinite positive unit multiple. Cancellation
+and unperforation are not hypotheses. This is an abstract semigroup theorem,
+not yet a quasitrace on an algebra. -/
+theorem positive_orderUnit_normalized_state (u : S)
+    (hpos : ∀ c : S, 0 ≤ c) (hbound : ∀ c : S, ∃ N : ℕ, c ≤ N • u)
+    (hf : ∀ k : ℕ, 0 < k → ¬ (2*k) • u ≤ k • u) :
+    ∃ f : S →+ ℝ, Monotone f ∧ f u = 1 := by
+  apply (semigroup_state_iff_orderedGroup_state u).mpr
+  apply orderedGroup_normalized_state (semigroupToOrderedGroup u)
+    (semigroupOrderedGroup_unit_nonneg u (hpos u))
+  · intro n hn h
+    have h' : n • semigroupToOrderedGroup u ≤ 0 • semigroupToOrderedGroup u := by simpa using h
+    have hle := (semigroupOrderedGroup_unit_order u hf hpos hbound n 0).mp h'
+    omega
+  · intro x
+    obtain ⟨N,hl,_⟩ := semigroupOrderedGroup_order_unit u hpos hbound x
+    exact ⟨N,hl⟩
+
+omit [PartialOrder S] [IsOrderedAddMonoid S] in
+/-- Every normalized state has the prescribed cyclic values. -/
+theorem normalized_semigroup_state_nsmul (u : S) (f : S →+ ℝ) (hu : f u = 1) (n : ℕ) :
+    f (n • u) = (n : ℝ) := by simp [hu]
+
+omit [IsOrderedAddMonoid S] in
+/-- Conversely a normalized monotone state rules out every properly
+infinite positive multiple. -/
+theorem normalized_semigroup_state_no_compression (u : S) (f : S →+ ℝ)
+    (hm : Monotone f) (hu : f u = 1) :
+    ∀ k : ℕ, 0 < k → ¬ (2*k) • u ≤ k • u := by
+  intro k hk h
+  have h' := hm h
+  rw [normalized_semigroup_state_nsmul u f hu,
+    normalized_semigroup_state_nsmul u f hu] at h'
+  have hn : 2*k ≤ k := by exact_mod_cast h'
+  omega
+
+/-- Exact abstract state criterion. Applying it to a C*-algebra still
+requires its actual positive ordered Cuntz semigroup and the analytic
+dimension-function/quasitrace correspondence. -/
+theorem positive_orderUnit_state_iff (u : S)
+    (hpos : ∀ c : S, 0 ≤ c) (hbound : ∀ c : S, ∃ N : ℕ, c ≤ N • u) :
+    (∃ f : S →+ ℝ, Monotone f ∧ f u = 1) ↔
+      ∀ k : ℕ, 0 < k → ¬ (2*k) • u ≤ k • u := by
+  constructor
+  · rintro ⟨f,hm,hu⟩
+    exact normalized_semigroup_state_no_compression u f hm hu
+  · exact positive_orderUnit_normalized_state u hpos hbound
+
+/-- The constructed full state extends the already verified initial
+cyclic state. This explicitly closes the abstract extension step. -/
+theorem positive_orderUnit_state_extends_cyclic (u : S)
+    (hpos : ∀ c : S, 0 ≤ c) (hbound : ∀ c : S, ∃ N : ℕ, c ≤ N • u)
+    (hf : ∀ k : ℕ, 0 < k → ¬ (2*k) • u ≤ k • u) :
+    ∃ f : S →+ ℝ, Monotone f ∧ f u = 1 ∧
+      ∀ v : unitCyclicMonoid u, f v = cyclicUnitState u (hpos u) hf v := by
+  obtain ⟨f,hm,hu⟩ := positive_orderUnit_normalized_state u hpos hbound hf
+  refine ⟨f,hm,hu,?_⟩
+  intro v
+  obtain ⟨n,hn⟩ := v.property
+  have hv : v = ⟨n • u,⟨n,rfl⟩⟩ := Subtype.ext hn.symm
+  rw [hv,cyclicUnitState_nsmul]
+  exact normalized_semigroup_state_nsmul u f hu n
+
+end Kaplansky
+
+end
+
+end OAI
diff --git a/lean/OAI/Algebra/PolynomialChains/Real.lean b/lean/OAI/Algebra/PolynomialChains/Real.lean
new file mode 100644
index 0000000000000000000000000000000000000000..4939cc4c5b4672b420a82df9b3342bfe10be956e
--- /dev/null
+++ b/lean/OAI/Algebra/PolynomialChains/Real.lean
@@ -0,0 +1,400 @@
+import Mathlib
+
+namespace OAI
+
+/-! Real weighted chains and pure-power squarefreeness. -/
+
+
+
+namespace MultiplicityCounterexample
+noncomputable section
+
+abbrev ComplexAffine (N : ℕ) := Fin N → ℂ
+abbrev RealPolynomial (N : ℕ) := MvPolynomial (Fin N) ℝ
+
+def complexEval {N : ℕ} (f : RealPolynomial N) (z : ComplexAffine N) : ℂ :=
+  MvPolynomial.eval₂ (algebraMap ℝ ℂ) z f
+
+def hypersurface {N : ℕ} (f : RealPolynomial N) : Set (ComplexAffine N) :=
+  {z | complexEval f z = 0}
+
+def IsReduced {N : ℕ} (f : RealPolynomial N) : Prop :=
+  Squarefree (MvPolynomial.map (algebraMap ℝ ℂ) f)
+
+def orderAtOrigin {N : ℕ} (f : RealPolynomial N) : WithTop ℕ :=
+  f.support.inf fun m => ((m.sum fun _ e => e : ℕ) : WithTop ℕ)
+
+def IsPositivelyWeightedHomogeneous {N : ℕ} (f : RealPolynomial N) : Prop :=
+  ∃ (a : Fin N → ℕ) (d : ℕ),
+    0 < d ∧ (∀ i, 0 < a i) ∧
+    ∀ (t : ℂ) (z : ComplexAffine N),
+      complexEval f (fun i => t ^ a i * z i) = t ^ d * complexEval f z
+
+def IsCriticalPoint {N : ℕ} (f : RealPolynomial N) (z : ComplexAffine N) : Prop :=
+  ∀ i : Fin N, complexEval (MvPolynomial.pderiv i f) z = 0
+
+def HasIsolatedCriticalPointAtOrigin {N : ℕ} (f : RealPolynomial N) : Prop :=
+  IsCriticalPoint f 0 ∧
+    ∃ U : Set (ComplexAffine N), IsOpen U ∧ (0 : ComplexAffine N) ∈ U ∧
+      ∀ z ∈ U, IsCriticalPoint f z → z = 0
+
+def AmbientlyHomeomorphicAtOrigin {N : ℕ} (f g : RealPolynomial N) : Prop :=
+  ∃ U V : Set (ComplexAffine N), IsOpen U ∧ IsOpen V ∧
+    ∃ (hU : (0 : ComplexAffine N) ∈ U) (hV : (0 : ComplexAffine N) ∈ V)
+      (h : U ≃ₜ V),
+      h ⟨0, hU⟩ = ⟨0, hV⟩ ∧
+      ∀ z : U, (z : ComplexAffine N) ∈ hypersurface f ↔
+        (h z : ComplexAffine N) ∈ hypersurface g
+
+end
+end MultiplicityCounterexample
+
+namespace MultiplicityCounterexample.Chains
+noncomputable section
+open MvPolynomial
+open scoped BigOperators
+
+def polynomial {n : ℕ} (R : Type*) [CommSemiring R] (a : Fin (n + 1) → ℕ) :
+    MvPolynomial (Fin (n + 1)) R :=
+  (∑ i : Fin n, X i.castSucc ^ a i.castSucc * X i.succ) +
+    X (Fin.last n) ^ a (Fin.last n)
+
+@[simp] lemma map_polynomial {n : ℕ} {R S : Type*}
+    [CommSemiring R] [CommSemiring S] (φ : R →+* S) (a : Fin (n + 1) → ℕ) :
+    map φ (polynomial R a) = polynomial S a := by
+  classical
+  simp [polynomial]
+
+lemma tail_decomposition {n : ℕ} (R : Type*) [CommSemiring R]
+    (a : Fin (n + 2) → ℕ) :
+    polynomial R a = X 0 ^ a 0 * X (Fin.succ 0) +
+      rename Fin.succ (polynomial R (fun i : Fin (n + 1) => a i.succ)) := by
+  classical
+  simp only [polynomial, map_add, map_sum, map_mul, map_pow, rename_X,
+    Fin.sum_univ_succ, Fin.castSucc_zero, Fin.castSucc_succ]
+  simp only [add_assoc, Fin.succ_last]
+
+variable {n : ℕ} {K : Type*} [Field K]
+
+def next (z : Fin (n + 1) → K) : Fin (n + 1) → K :=
+  Fin.snoc (fun i : Fin n => z i.succ) 1
+
+def previous (a : Fin (n + 1) → ℕ) (z : Fin (n + 1) → K) : Fin (n + 1) → K :=
+  Fin.cons 0 (fun i : Fin n => z i.castSucc ^ a i.castSucc)
+
+@[simp] lemma next_castSucc (z : Fin (n + 1) → K) (i : Fin n) :
+    next z i.castSucc = z i.succ := by simp [next]
+@[simp] lemma next_last (z : Fin (n + 1) → K) :
+    next z (Fin.last n) = 1 := by simp [next]
+@[simp] lemma previous_zero (a : Fin (n + 1) → ℕ) (z : Fin (n + 1) → K) :
+    previous a z 0 = 0 := by simp [previous]
+@[simp] lemma previous_succ (a : Fin (n + 1) → ℕ) (z : Fin (n + 1) → K)
+    (i : Fin n) : previous a z i.succ = z i.castSucc ^ a i.castSucc := by
+  simp [previous]
+
+lemma eval_pderiv (a : Fin (n + 1) → ℕ) (z : Fin (n + 1) → K)
+    (j : Fin (n + 1)) :
+    eval z (pderiv j (polynomial K a)) =
+      (a j : K) * z j ^ (a j - 1) * next z j + previous a z j := by
+  classical
+  have own :
+      (∑ i : Fin n, if i.castSucc = j then
+        (a i.castSucc : K) * z i.castSucc ^ (a i.castSucc - 1) * z i.succ else 0) +
+      (if Fin.last n = j then
+        (a (Fin.last n) : K) * z (Fin.last n) ^ (a (Fin.last n) - 1) else 0) =
+      (a j : K) * z j ^ (a j - 1) * next z j := by
+    have h := Finset.sum_ite_eq' (Finset.univ : Finset (Fin (n + 1))) j
+      (fun i => (a i : K) * z i ^ (a i - 1) * next z i)
+    simpa only [Finset.mem_univ, ite_true, Fin.sum_univ_castSucc,
+      next_castSucc, next_last, mul_one] using h
+  have prev :
+      (∑ i : Fin n, if i.succ = j then z i.castSucc ^ a i.castSucc else 0) =
+        previous a z j := by
+    have h := Finset.sum_ite_eq' (Finset.univ : Finset (Fin (n + 1))) j
+      (previous a z)
+    simpa only [Finset.mem_univ, ite_true, Fin.sum_univ_succ,
+      previous_zero, ite_self, zero_add, previous_succ] using h
+  calc
+    eval z (pderiv j (polynomial K a)) =
+        (∑ i : Fin n, ((if i.castSucc = j then
+          (a i.castSucc : K) * z i.castSucc ^ (a i.castSucc - 1) * z i.succ else 0) +
+          (if i.succ = j then z i.castSucc ^ a i.castSucc else 0))) +
+        (if Fin.last n = j then
+          (a (Fin.last n) : K) * z (Fin.last n) ^ (a (Fin.last n) - 1) else 0) := by
+      simp only [polynomial, map_add, map_sum, pderiv_mul, pderiv_pow, pderiv_X,
+        eval_mul, eval_pow, map_natCast, eval_X]
+      congr 1
+      · apply Finset.sum_congr rfl
+        intro i _
+        by_cases h : i.castSucc = j <;> by_cases h' : i.succ = j <;>
+          simp [h, h']
+      · by_cases h : Fin.last n = j <;> simp [h]
+    _ = _ := by rw [Finset.sum_add_distrib]; rw [add_right_comm, own, prev]
+
+lemma previous_eq_zero_of_first (a : Fin (n + 1) → ℕ)
+    (ha : ∀ i, 0 < a i) (z : Fin (n + 1) → K) (j : Fin (n + 1))
+    (hz : ∀ i < j, z i = 0) : previous a z j = 0 := by
+  revert hz
+  refine Fin.cases ?_ ?_ j
+  · intro _
+    exact previous_zero a z
+  · intro i hz
+    rw [previous_succ, hz i.castSucc Fin.castSucc_lt_succ,
+      zero_pow (ha i.castSucc).ne']
+
+section Critical
+variable [CharZero K]
+
+theorem critical_locus (a : Fin (n + 1) → ℕ) (ha : ∀ i, 2 ≤ a i)
+    (z : Fin (n + 1) → K) :
+    (∀ j, eval z (pderiv j (polynomial K a)) = 0) ↔ z = 0 := by
+  classical
+  constructor
+  · intro hz
+    by_contra hne
+    have hex : ∃ j, z j ≠ 0 := by
+      by_contra hn
+      apply hne
+      funext j
+      simpa using not_exists.mp hn j
+    let j := Fin.find (fun j => z j ≠ 0) hex
+    have hj : z j ≠ 0 := Fin.find_spec hex
+    have hfirst : ∀ i < j, z i = 0 := by
+      intro i hi
+      exact not_not.mp (Fin.find_min hex hi)
+    have hprev : previous a z j = 0 :=
+      previous_eq_zero_of_first a (fun i => lt_of_lt_of_le (by decide) (ha i)) z j hfirst
+    have hnext : next z j = 0 := by
+      have hpow : (a j : K) * z j ^ (a j - 1) ≠ 0 :=
+        mul_ne_zero (Nat.cast_ne_zero.mpr (by have := ha j; omega)) (pow_ne_zero _ hj)
+      have h := hz j
+      rw [eval_pderiv, hprev, add_zero] at h
+      exact (mul_eq_zero.mp h).resolve_left hpow
+    have hjlast : j ≠ Fin.last n := by
+      intro h
+      rw [h, next_last] at hnext
+      exact one_ne_zero hnext
+    obtain ⟨i, hi⟩ := Fin.eq_castSucc_of_ne_last hjlast
+    have hznext : z i.succ = 0 := by simpa only [← hi, next_castSucc] using hnext
+    have hcrit := hz i.succ
+    have hapos : a i.succ - 1 ≠ 0 := by have := ha i.succ; omega
+    rw [eval_pderiv, hznext, zero_pow hapos, mul_zero, zero_mul, zero_add,
+      previous_succ] at hcrit
+    exact pow_ne_zero _ (hi ▸ hj) hcrit
+  · rintro rfl j
+    have hn : a j - 1 ≠ 0 := by have := ha j; omega
+    rw [eval_pderiv]
+    simp only [Pi.zero_apply, zero_pow hn, mul_zero, zero_mul, zero_add]
+    apply previous_eq_zero_of_first a (fun i => lt_of_lt_of_le (by decide) (ha i))
+    intro _ _
+    rfl
+
+end Critical
+
+lemma eval_scale (a w : Fin (n + 1) → ℕ) (D : ℕ)
+    (hw : ∀ i : Fin n, a i.castSucc * w i.castSucc + w i.succ = D)
+    (hlast : a (Fin.last n) * w (Fin.last n) = D) (t : K)
+    (z : Fin (n + 1) → K) :
+    eval (fun i => t ^ w i * z i) (polynomial K a) =
+      t ^ D * eval z (polynomial K a) := by
+  classical
+  simp only [polynomial, eval_add, eval_sum, eval_mul, eval_pow, eval_X]
+  rw [mul_add, Finset.mul_sum]
+  congr 1
+  · apply Finset.sum_congr rfl
+    intro i _
+    rw [mul_pow, ← pow_mul, Nat.mul_comm (w i.castSucc) (a i.castSucc),
+      ← hw i, pow_add]
+    ring
+  · rw [mul_pow, ← pow_mul, Nat.mul_comm (w (Fin.last n)) (a (Fin.last n)), hlast]
+
+lemma monomial_degrees (a : Fin (n + 1) → ℕ) (ha : ∀ i, 2 ≤ a i)
+    (hlast : 3 ≤ a (Fin.last n)) (m : Fin (n + 1) →₀ ℕ)
+    (hm : m ∈ (polynomial K a).support) : 3 ≤ m.sum (fun _ e => e) := by
+  classical
+  rcases Finset.mem_union.mp (support_add hm) with hm | hm
+  · obtain ⟨i, _, hi⟩ := Finset.mem_biUnion.mp (support_sum hm)
+    have h : a i.castSucc + 1 = m.sum (fun _ e => e) :=
+      ((isHomogeneous_X_pow i.castSucc (a i.castSucc)).mul
+        (isHomogeneous_X K i.succ)).degree_eq_sum_deg_support hi
+    have := ha i.castSucc
+    omega
+  · have h : a (Fin.last n) = m.sum (fun _ e => e) :=
+      (isHomogeneous_X_pow (Fin.last n) (a (Fin.last n))).degree_eq_sum_deg_support hm
+    omega
+
+theorem exists_chain_data (D c : ℕ) (hc : 0 < c) (hD : 2 * c < D) :
+    ∃ (n : ℕ) (a w : Fin (n + 1) → ℕ),
+      w 0 = c ∧
+      (∀ i, 0 < w i ∧ 2 * w i < D ∧ 2 ≤ a i) ∧
+      3 ≤ a (Fin.last n) ∧
+      (∀ i : Fin n, a i.castSucc * w i.castSucc + w i.succ = D) ∧
+      a (Fin.last n) * w (Fin.last n) = D := by
+  induction c using Nat.strong_induction_on with
+  | h c ih =>
+    have hq : 2 ≤ D / c := (Nat.le_div_iff_mul_le hc).2 (by omega)
+    have hdiv : D / c * c + D % c = D := by
+      simpa only [Nat.mul_comm c (D / c)] using Nat.div_add_mod D c
+    by_cases hr : D % c = 0
+    · refine ⟨0, fun _ => D / c, fun _ => c, rfl,
+        (fun _ => ⟨hc, hD, hq⟩), ?_, (fun i => Fin.elim0 i), ?_⟩
+      · simp only at *
+        nlinarith
+      · simpa only [hr, add_zero] using hdiv
+    · have hrc : D % c < c := Nat.mod_lt D hc
+      have hrpos : 0 < D % c := Nat.pos_of_ne_zero hr
+      have hrD : 2 * (D % c) < D := by omega
+      obtain ⟨n, a, w, hw0, hw, ha, heq, hlast⟩ := ih (D % c) hrc hrpos hrD
+      refine ⟨n + 1, Fin.cons (D / c) a, Fin.cons c w, rfl, ?_, ?_, ?_, ?_⟩
+      · intro i
+        refine Fin.cases ?_ (fun i => ?_) i
+        · exact ⟨hc, hD, hq⟩
+        · simpa only [Fin.cons_succ] using hw i
+      · simpa using ha
+      · intro i
+        refine Fin.cases ?_ (fun i => ?_) i
+        · simpa only [Fin.castSucc_zero, Fin.cons_zero, Fin.cons_succ, hw0] using hdiv
+        · simpa only [Fin.castSucc_succ, Fin.cons_succ] using heq i
+      · simpa using hlast
+
+end
+end MultiplicityCounterexample.Chains
+
+namespace MultiplicityCounterexample
+noncomputable section
+open MvPolynomial
+
+lemma complexEval_chain {n : ℕ} (a : Fin (n + 1) → ℕ)
+    (z : ComplexAffine (n + 1)) :
+    complexEval (Chains.polynomial ℝ a) z = eval z (Chains.polynomial ℂ a) := by
+  rw [complexEval, ← eval_map, Chains.map_polynomial]
+
+lemma complexEval_pderiv_chain {n : ℕ} (a : Fin (n + 1) → ℕ)
+    (i : Fin (n + 1)) (z : ComplexAffine (n + 1)) :
+    complexEval (pderiv i (Chains.polynomial ℝ a)) z =
+      eval z (pderiv i (Chains.polynomial ℂ a)) := by
+  rw [complexEval, ← eval_map, ← pderiv_map, Chains.map_polynomial]
+
+theorem real_chain_critical_iff {n : ℕ} (a : Fin (n + 1) → ℕ)
+    (ha : ∀ i, 2 ≤ a i) (z : ComplexAffine (n + 1)) :
+    IsCriticalPoint (Chains.polynomial ℝ a) z ↔ z = 0 := by
+  simp only [IsCriticalPoint, complexEval_pderiv_chain]
+  exact Chains.critical_locus a ha z
+
+theorem real_chain_isolated {n : ℕ} (a : Fin (n + 1) → ℕ) (ha : ∀ i, 2 ≤ a i) :
+    HasIsolatedCriticalPointAtOrigin (Chains.polynomial ℝ a) := by
+  refine ⟨(real_chain_critical_iff a ha 0).2 rfl, Set.univ, isOpen_univ,
+    Set.mem_univ _, ?_⟩
+  intro z _ hz
+  exact (real_chain_critical_iff a ha z).1 hz
+
+theorem real_chain_weighted {n : ℕ} (a w : Fin (n + 1) → ℕ) (D : ℕ)
+    (hD : 0 < D) (hwpos : ∀ i, 0 < w i)
+    (hw : ∀ i : Fin n, a i.castSucc * w i.castSucc + w i.succ = D)
+    (ht : a (Fin.last n) * w (Fin.last n) = D) :
+    IsPositivelyWeightedHomogeneous (Chains.polynomial ℝ a) := by
+  refine ⟨w, D, hD, hwpos, ?_⟩
+  intro t z
+  simp only [complexEval_chain]
+  exact Chains.eval_scale a w D hw ht t z
+
+theorem real_chain_order_ge_three {n : ℕ} (a : Fin (n + 1) → ℕ)
+    (ha : ∀ i, 2 ≤ a i) (ht : 3 ≤ a (Fin.last n)) :
+    3 ≤ orderAtOrigin (Chains.polynomial ℝ a) := by
+  apply Finset.le_inf
+  intro m hm
+  exact_mod_cast Chains.monomial_degrees a ha ht m hm
+
+theorem exists_real_chain (D c : ℕ) (hc : 0 < c) (hD : 2 * c < D) :
+    ∃ (n : ℕ) (a w : Fin (n + 1) → ℕ),
+      w 0 = c ∧
+      (∀ i, 0 < (w i : ℚ) / D ∧ (w i : ℚ) / D < 1 / 2) ∧
+      (∀ (t : ℂ) (z : ComplexAffine (n + 1)),
+        complexEval (Chains.polynomial ℝ a) (fun i => t ^ w i * z i) =
+          t ^ D * complexEval (Chains.polynomial ℝ a) z) ∧
+      IsPositivelyWeightedHomogeneous (Chains.polynomial ℝ a) ∧
+      (∀ m ∈ (Chains.polynomial ℝ a).support, 3 ≤ m.sum (fun _ e => e)) ∧
+      3 ≤ orderAtOrigin (Chains.polynomial ℝ a) ∧
+      HasIsolatedCriticalPointAtOrigin (Chains.polynomial ℝ a) := by
+  obtain ⟨n, a, w, hw0, hw, ha, hrel, ht⟩ := Chains.exists_chain_data D c hc hD
+  have hDpos : 0 < D := by omega
+  have ha2 : ∀ i, 2 ≤ a i := fun i => (hw i).2.2
+  refine ⟨n, a, w, hw0, ?_, ?_, real_chain_weighted a w D hDpos
+    (fun i => (hw i).1) hrel ht, ?_, real_chain_order_ge_three a ha2 ha,
+    real_chain_isolated a ha2⟩
+  · intro i
+    have hpos : (0 : ℚ) < D := by exact_mod_cast hDpos
+    constructor
+    · exact div_pos (by exact_mod_cast (hw i).1) hpos
+    · apply (div_lt_iff₀ hpos).2
+      have hlt : (2 : ℚ) * w i < D := by exact_mod_cast (hw i).2.1
+      linarith
+  · intro t z
+    simp only [complexEval_chain]
+    exact Chains.eval_scale a w D hrel ht t z
+  · intro m hm
+    exact Chains.monomial_degrees a ha2 ha m hm
+
+end
+end MultiplicityCounterexample
+
+namespace MultiplicityCounterexample
+noncomputable section
+open MvPolynomial
+
+variable {σ K : Type*} [Field K]
+
+lemma squarefree_of_pderiv_power (f : MvPolynomial σ K) (i : σ) (m : ℕ)
+    (c : K) (hc : c ≠ 0) (hd : pderiv i f = C c * X i ^ m)
+    (hX : ¬ (X i : MvPolynomial σ K) ∣ f) : Squarefree f := by
+  classical
+  have hrel : IsRelPrime f (X i) :=
+    ((X_prime (R := K) (i := i)).irreducible.isRelPrime_iff_not_dvd.2 hX).symm
+  intro g hg
+  have hgf : g ∣ f := dvd_trans (dvd_mul_right g g) hg
+  obtain ⟨b, hb⟩ := hg
+  have hgd : g ∣ pderiv i f := by
+    refine ⟨2 * pderiv i g * b + g * pderiv i b, ?_⟩
+    rw [hb]
+    simp only [pderiv_mul]
+    ring
+  rw [hd] at hgd
+  have hunit : IsUnit (C c : MvPolynomial σ K) :=
+    IsUnit.map C (isUnit_iff_ne_zero.2 hc)
+  exact hrel.pow_right hgf (hunit.dvd_mul_left.1 hgd)
+
+lemma squarefree_add_pure_power [CharZero K] (g : MvPolynomial σ K)
+    (i : σ) (r : ℕ) (hr : 0 < r) (hg : pderiv i g = 0)
+    (z : σ → K) (hzi : z i = 0) (hgz : eval z g ≠ 0) :
+    Squarefree (g + X i ^ r) := by
+  classical
+  apply squarefree_of_pderiv_power (g + X i ^ r) i (r - 1) (r : K)
+    (Nat.cast_ne_zero.2 hr.ne')
+  · simp [hg]
+  · intro hdvd
+    have hh := map_dvd (eval z) hdvd
+    simp only [eval_X, hzi, eval_add, eval_pow, zero_pow hr.ne', add_zero,
+      zero_dvd_iff] at hh
+    exact hgz hh
+
+end
+end MultiplicityCounterexample
+
+namespace MultiplicityCounterexample
+noncomputable section
+open MvPolynomial
+
+theorem isReduced_add_pure_power {N : ℕ} (g : RealPolynomial N)
+    (i : Fin N) (r : ℕ) (hr : 0 < r) (hg : pderiv i g = 0)
+    (z : ComplexAffine N) (hzi : z i = 0) (hgz : complexEval g z ≠ 0) :
+    IsReduced (g + X i ^ r) := by
+  unfold IsReduced
+  rw [map_add, map_pow, map_X]
+  refine squarefree_add_pure_power _ i r hr ?_ z hzi ?_
+  · rw [pderiv_map, hg, map_zero]
+  · rwa [eval_map]
+
+end
+end MultiplicityCounterexample
+
+end OAI
diff --git a/lean/OAI/Algebra/Universal/Congruence.lean b/lean/OAI/Algebra/Universal/Congruence.lean
new file mode 100644
index 0000000000000000000000000000000000000000..ca97a3bf6ebc2028ef25f8b52b70d6895a00f4a7
--- /dev/null
+++ b/lean/OAI/Algebra/Universal/Congruence.lean
@@ -0,0 +1,167 @@
+import Mathlib.Data.Fin.Tuple.Basic
+import Mathlib.Data.Setoid.Basic
+import Mathlib.Order.Hom.Basic
+
+namespace OAI
+
+/-!
+# Congruences of finite-signature algebras
+
+An algebra has finitely many total operations of finite arity, including possibly nullary
+operations. Its congruences are ordered by inclusion. Compatibility with every operation is
+equivalent to stability under the unary translations obtained by fixing all but one input.
+-/
+
+namespace FiniteCongruence
+
+/-- A finite list of total finite-arity operations. Arity zero is allowed. -/
+structure Algebra (Carrier : Type) where
+  numOps : ℕ
+  arity : Fin numOps → ℕ
+  op : (index : Fin numOps) → (Fin (arity index) → Carrier) → Carrier
+
+/-- Compatibility with all operations of an algebra. -/
+def Compatible {Carrier : Type} (alg : Algebra Carrier) (rel : Setoid Carrier) : Prop :=
+  ∀ (index : Fin alg.numOps) (left right : Fin (alg.arity index) → Carrier),
+    (∀ coord, rel (left coord) (right coord)) → rel (alg.op index left) (alg.op index right)
+
+/-- The full ordered set of congruences, ordered by inclusion of relations. -/
+def Congruence {Carrier : Type} (alg : Algebra Carrier) :=
+  {rel : Setoid Carrier // Compatible alg rel}
+
+instance {Carrier : Type} (alg : Algebra Carrier) : PartialOrder (Congruence alg) :=
+  inferInstanceAs (PartialOrder {rel : Setoid Carrier // Compatible alg rel})
+
+/-- Order-isomorphism with the entire congruence lattice of a nonempty finite algebra. -/
+def Representable (Lat : Type) [PartialOrder Lat] : Prop :=
+  ∃ size : ℕ, 0 < size ∧ ∃ alg : Algebra (Fin size), Nonempty (Lat ≃o Congruence alg)
+
+instance {Carrier : Type} {alg : Algebra Carrier} :
+    CoeFun (Congruence alg) (fun _ => Carrier → Carrier → Prop) :=
+  ⟨fun rel => rel.1⟩
+
+namespace Congruence
+
+variable {Carrier : Type} {alg : Algebra Carrier}
+
+@[ext] theorem ext {rel other : Congruence alg}
+    (equal : ∀ left right, rel left right ↔ other left right) : rel = other :=
+  Subtype.ext (Setoid.ext equal)
+
+theorem refl (rel : Congruence alg) (point : Carrier) : rel point point := rel.1.refl' point
+
+theorem symm (rel : Congruence alg) {left right : Carrier} (related : rel left right) :
+    rel right left := rel.1.symm' related
+
+theorem trans (rel : Congruence alg) {left middle right : Carrier}
+    (first : rel left middle) (second : rel middle right) : rel left right :=
+  rel.1.trans' first second
+
+theorem compatible (rel : Congruence alg) (index : Fin alg.numOps)
+    (left right : Fin (alg.arity index) → Carrier) (related : ∀ coord, rel (left coord) (right coord)) :
+    rel (alg.op index left) (alg.op index right) := rel.2 index left right related
+
+/-- Equality is the least congruence. -/
+def equality (alg : Algebra Carrier) : Congruence alg :=
+  ⟨⊥, by
+    intro index left right related
+    have : left = right := funext related
+    subst right
+    rfl⟩
+
+@[simp] theorem equality_apply (left right : Carrier) :
+    equality alg left right ↔ left = right := Iff.rfl
+
+theorem equality_le (rel : Congruence alg) : equality alg ≤ rel := by
+  intro left right equal
+  cases equal
+  exact rel.refl left
+
+/-- The intersection of all congruences containing the generating pair. -/
+def principal (alg : Algebra Carrier) (left right : Carrier) : Congruence alg :=
+  ⟨⟨fun first second => ∀ rel : Congruence alg, rel left right → rel first second,
+     ⟨fun point rel _ => rel.refl point,
+       fun related rel contains => rel.symm (related rel contains),
+       fun first second rel contains => rel.trans (first rel contains) (second rel contains)⟩⟩,
+   by
+    intro index first second related rel contains
+    exact rel.compatible index first second (fun coord => related coord rel contains)⟩
+
+theorem principal_pair (left right : Carrier) : principal alg left right left right :=
+  fun _ related => related
+
+theorem principal_le {left right : Carrier} {rel : Congruence alg} :
+    principal alg left right ≤ rel ↔ rel left right := by
+  constructor
+  · intro below
+    exact below (principal_pair left right)
+  · intro contains first second related
+    exact related rel contains
+
+theorem principal_comm (left right : Carrier) :
+    principal alg left right = principal alg right left := by
+  apply le_antisymm
+  · exact principal_le.mpr ((principal alg right left).symm (principal_pair right left))
+  · exact principal_le.mpr ((principal alg left right).symm (principal_pair left right))
+
+end Congruence
+
+/-- Stability under all single-coordinate changes entails compatibility with a total operation.
+For nullary operations the two input tuples are equal. -/
+theorem relation_map_of_updates {Carrier : Type} (rel : Setoid Carrier) {arity : ℕ}
+    (operation : (Fin arity → Carrier) → Carrier)
+    (stable : ∀ (coord : Fin arity) (inputs : Fin arity → Carrier) (left right : Carrier),
+      rel left right →
+      rel (operation (Function.update inputs coord left))
+        (operation (Function.update inputs coord right)))
+    (left right : Fin arity → Carrier) (related : ∀ coord, rel (left coord) (right coord)) :
+    rel (operation left) (operation right) := by
+  induction arity with
+  | zero =>
+    have : left = right := Subsingleton.elim _ _
+    simp [this]
+  | succ arity inductionHyp =>
+    have headStep : rel (operation (Fin.cons (left 0) (Fin.tail left)))
+        (operation (Fin.cons (right 0) (Fin.tail left))) := by
+      simpa only [Fin.update_cons_zero] using
+        stable 0 (Fin.cons (left 0) (Fin.tail left)) (left 0) (right 0) (related 0)
+    have tailStep : rel (operation (Fin.cons (right 0) (Fin.tail left)))
+        (operation (Fin.cons (right 0) (Fin.tail right))) := by
+      apply inductionHyp (fun inputs => operation (Fin.cons (right 0) inputs))
+          (fun coord inputs first second pairRelated => ?_) (Fin.tail left) (Fin.tail right)
+          (fun coord => related coord.succ)
+      simpa only [Fin.cons_update] using
+        stable coord.succ (Fin.cons (right 0) inputs) first second pairRelated
+    simpa only [Fin.cons_self_tail] using rel.trans' headStep tailStep
+
+/-- A one-variable translation is obtained by fixing all but one input of an operation. -/
+def translation {Carrier : Type} (alg : Algebra Carrier) (index : Fin alg.numOps)
+    (coord : Fin (alg.arity index)) (inputs : Fin (alg.arity index) → Carrier)
+    (point : Carrier) : Carrier :=
+  alg.op index (Function.update inputs coord point)
+
+theorem translation_preserves {Carrier : Type} {alg : Algebra Carrier} (rel : Congruence alg)
+    (index : Fin alg.numOps) (coord : Fin (alg.arity index))
+    (inputs : Fin (alg.arity index) → Carrier) {left right : Carrier} (related : rel left right) :
+    rel (translation alg index coord inputs left) (translation alg index coord inputs right) := by
+  apply rel.compatible
+  intro other
+  by_cases equal : other = coord
+  · subst other
+    simpa only [Function.update_self] using related
+  · simpa only [Function.update_of_ne equal] using rel.refl (inputs other)
+
+theorem compatible_iff_translations {Carrier : Type} (alg : Algebra Carrier)
+    (rel : Setoid Carrier) :
+    Compatible alg rel ↔ ∀ (index : Fin alg.numOps) (coord : Fin (alg.arity index))
+      (inputs : Fin (alg.arity index) → Carrier) (left right : Carrier), rel left right →
+      rel (translation alg index coord inputs left) (translation alg index coord inputs right) := by
+  constructor
+  · intro compatible index coord inputs left right related
+    exact translation_preserves ⟨rel, compatible⟩ index coord inputs related
+  · intro stable index left right related
+    exact relation_map_of_updates rel (alg.op index) (stable index) left right related
+
+end FiniteCongruence
+
+end OAI
diff --git a/lean/OAI/Algebra/Universal/Coset.lean b/lean/OAI/Algebra/Universal/Coset.lean
new file mode 100644
index 0000000000000000000000000000000000000000..2c77f13a8494e61ab4f9ac4c83d4d8115ce6cac6
--- /dev/null
+++ b/lean/OAI/Algebra/Universal/Coset.lean
@@ -0,0 +1,148 @@
+import OAI.Algebra.Universal.Congruence
+import Mathlib.GroupTheory.GroupAction.Quotient
+import Mathlib.Data.Fintype.EquivFin
+import Mathlib.Data.Setoid.Basic
+
+namespace OAI
+
+/-!
+# Congruences of coset actions
+
+The full congruence lattice of the left action on a finite group's cosets is the
+subgroup interval above the stabilizer. No normality assumption is needed.
+-/
+
+namespace FiniteCongruence
+
+noncomputable section
+variable {G : Type} [Group G] [Fintype G] (H : Subgroup G)
+
+/-- One unary operation for each element of G; no omitted operations. -/
+def cosetAlgebra : Algebra (G ⧸ H) where
+  numOps := Fintype.card G
+  arity := fun _ => 1
+  op := fun i x => (Fintype.equivFin G).symm i • x 0
+
+lemma compatible_iff_invariant (r : Setoid (G ⧸ H)) :
+    Compatible (cosetAlgebra H) r ↔
+      ∀ g : G, ∀ x y : G ⧸ H, r x y → r (g • x) (g • y) := by
+  constructor
+  · intro hr g x y hxy
+    have h := hr ((Fintype.equivFin G) g) (fun _ => x) (fun _ => y) (fun _ => hxy)
+    simpa [cosetAlgebra] using h
+  · intro hr i x y hxy
+    change Fin 1 → G ⧸ H at x y
+    change ∀ j : Fin 1, r (x j) (y j) at hxy
+    exact hr ((Fintype.equivFin G).symm i) (x 0) (y 0) (hxy 0)
+
+abbrev base : G ⧸ H := (1 : G)
+
+/-- The subgroup determined by the class of the identity coset. -/
+def subgroupOf (r : Congruence (cosetAlgebra H)) : Subgroup G where
+  carrier := {g | r.val (base H) (g • base H)}
+  one_mem' := by
+    change r.val (base H) ((1 : G) • base H)
+    rw [one_smul]
+  mul_mem' := by
+    intro a b ha hb
+    have hab := (compatible_iff_invariant H r.val).mp r.property a _ _ hb
+    simpa [mul_smul] using r.val.trans ha hab
+  inv_mem' := by
+    intro a ha
+    have h := (compatible_iff_invariant H r.val).mp r.property a⁻¹ _ _ ha
+    simpa using r.val.symm h
+
+lemma le_subgroupOf (r : Congruence (cosetAlgebra H)) : H ≤ subgroupOf H r := by
+  intro g hg
+  have heq : (g : G ⧸ H) = (1 : G) := QuotientGroup.eq.mpr (by simpa using H.inv_mem hg)
+  change r.val (base H) (g • base H)
+  have hbase : g • base H = base H := by simpa [base] using heq
+  rw [hbase]
+
+/-- The canonical quotient-set map exists without a normality assumption. -/
+def quotientMap (K : Subgroup G) (h : H ≤ K) : G ⧸ H → G ⧸ K :=
+  Quotient.map' id (fun _ _ hxy => QuotientGroup.leftRel_apply.mpr
+    (h (QuotientGroup.leftRel_apply.mp hxy)))
+
+omit [Fintype G] in
+lemma quotientMap_mk (K : Subgroup G) (h : H ≤ K) (g : G) :
+    quotientMap H K h (g : G ⧸ H) = (g : G ⧸ K) := rfl
+
+omit [Fintype G] in
+lemma quotientMap_smul (K : Subgroup G) (h : H ≤ K) (g : G) (x : G ⧸ H) :
+    quotientMap H K h (g • x) = g • quotientMap H K h x := by
+  induction x using Quotient.inductionOn' with
+  | h a => rfl
+
+/-- Pullback of equality on G/K, hence an actual equivalence relation on G/H. -/
+def congruenceOf (K : Subgroup G) (h : H ≤ K) : Congruence (cosetAlgebra H) :=
+  ⟨Setoid.ker (quotientMap H K h), (compatible_iff_invariant H _).mpr (by
+    intro g x y hxy
+    change quotientMap H K h (g • x) = quotientMap H K h (g • y)
+    rw [quotientMap_smul, quotientMap_smul]
+    exact congrArg (fun q : G ⧸ K => g • q) hxy)⟩
+
+lemma congruenceOf_mk (K : Subgroup G) (h : H ≤ K) (a b : G) :
+    (congruenceOf H K h).val (a : G ⧸ H) (b : G ⧸ H) ↔ a⁻¹ * b ∈ K := by
+  change ((a : G ⧸ K) = (b : G ⧸ K)) ↔ _
+  exact QuotientGroup.eq
+
+lemma invariant_mk_iff (r : Congruence (cosetAlgebra H)) (a b : G) :
+    r.val (a : G ⧸ H) (b : G ⧸ H) ↔ a⁻¹ * b ∈ subgroupOf H r := by
+  have inv := (compatible_iff_invariant H r.val).mp r.property
+  constructor
+  · intro hab
+    have h := inv a⁻¹ _ _ hab
+    change r.val (base H) ((a⁻¹ * b) • base H)
+    simpa [base, MulAction.Quotient.smul_coe, smul_eq_mul] using h
+  · intro hab
+    change r.val (base H) ((a⁻¹ * b) • base H) at hab
+    have h := inv a _ _ hab
+    simpa [base, mul_smul, MulAction.Quotient.smul_coe, smul_eq_mul] using h
+
+lemma subgroupOf_congruenceOf (K : Subgroup G) (h : H ≤ K) :
+    subgroupOf H (congruenceOf H K h) = K := by
+  ext g
+  change (congruenceOf H K h).val (base H) (g • base H) ↔ g ∈ K
+  simpa [base, MulAction.Quotient.smul_coe, smul_eq_mul] using congruenceOf_mk H K h 1 g
+
+lemma congruenceOf_subgroupOf (r : Congruence (cosetAlgebra H)) :
+    congruenceOf H (subgroupOf H r) (le_subgroupOf H r) = r := by
+  apply Subtype.ext
+  ext x y
+  induction x using Quotient.inductionOn' with
+  | h a =>
+    induction y using Quotient.inductionOn' with
+    | h b =>
+      exact (congruenceOf_mk H _ _ a b).trans (invariant_mk_iff H r a b).symm
+
+/-- The full congruence lattice of the coset algebra is order-isomorphic to the subgroup interval. -/
+def coset_action_correspondence :
+    Congruence (cosetAlgebra H) ≃o Set.Icc H (⊤ : Subgroup G) where
+  toFun r := ⟨subgroupOf H r, le_subgroupOf H r, le_top⟩
+  invFun K := congruenceOf H K.val K.property.1
+  left_inv r := congruenceOf_subgroupOf H r
+  right_inv K := by
+    apply Subtype.ext
+    exact subgroupOf_congruenceOf H K.val K.property.1
+  map_rel_iff' := by
+    intro r s
+    change subgroupOf H r ≤ subgroupOf H s ↔ r.val ≤ s.val
+    constructor
+    · intro h x y hxy
+      induction x using Quotient.inductionOn' with
+      | h a =>
+        induction y using Quotient.inductionOn' with
+        | h b => exact (invariant_mk_iff H s a b).mpr (h ((invariant_mk_iff H r a b).mp hxy))
+    · intro h g hg
+      exact h hg
+
+/-- The finite coset algebra realizes the full subgroup interval. -/
+theorem coset_action_correspondence_exists :
+    Nonempty (Congruence (cosetAlgebra H) ≃o Set.Icc H (⊤ : Subgroup G)) :=
+  ⟨coset_action_correspondence H⟩
+
+end
+end FiniteCongruence
+
+end OAI
diff --git a/lean/OAI/Algebra/Universal/GraphCriterion.lean b/lean/OAI/Algebra/Universal/GraphCriterion.lean
new file mode 100644
index 0000000000000000000000000000000000000000..05cf6ad1cfee35a14417a28941df4ca1598a8d16
--- /dev/null
+++ b/lean/OAI/Algebra/Universal/GraphCriterion.lean
@@ -0,0 +1,302 @@
+import OAI.Algebra.Universal.Congruence
+import Mathlib.Data.Finset.Lattice.Fold
+import Mathlib.Data.Fintype.EquivFin
+import Mathlib.Data.Fintype.Pi
+import Mathlib.Data.Fintype.Prod
+
+namespace OAI
+
+/-!
+# Graph characterization of finite congruence lattices
+
+A finite lattice is the full congruence lattice of a nonempty finite algebra if and only if
+it admits a finite nonempty lattice-colored graph satisfying `IsGraphWitness`. Principal
+congruences supply the colors in one direction; all label-decreasing self-maps supply the
+unary operations in the other.
+-/
+
+namespace FiniteCongruence
+
+/-- A label-decreasing self-map; collapsed edges are permitted. -/
+def Admissible {Lat Carrier : Type} [LE Lat] (color : Carrier → Carrier → Lat)
+    (placement : Carrier → Carrier) : Prop :=
+  ∀ left right, color (placement left) (placement right) ≤ color left right
+
+/-- An oriented image of a seed edge under an admissible map. -/
+def Marked {Lat Carrier : Type} [LE Lat] (color : Carrier → Carrier → Lat)
+    (seeds : Finset (Carrier × Carrier)) (left right : Carrier) : Prop :=
+  ∃ placement : Carrier → Carrier, Admissible color placement ∧
+    ∃ edge ∈ seeds, placement edge.1 = left ∧ placement edge.2 = right
+
+/-- Finite paths in the undirected marked graph, including paths of length zero. -/
+def Connected {Lat Carrier : Type} [LE Lat] (color : Carrier → Carrier → Lat)
+    (seeds : Finset (Carrier × Carrier)) (left right : Carrier) : Prop :=
+  Relation.EqvGen (Marked color seeds) left right
+
+/-- Symmetric colors separate vertices, satisfy the join triangle inequality, detect order,
+and connect every pair below the join of any nonempty finite set of seed colors. -/
+def IsGraphWitness {Lat Carrier : Type} [Lattice Lat] [OrderBot Lat]
+    (color : Carrier → Carrier → Lat) : Prop :=
+  (∀ left right, color left right = color right left) ∧
+  (∀ left right, color left right = ⊥ ↔ left = right) ∧
+  (∀ left right middle, color left right ≤ color left middle ⊔ color middle right) ∧
+  (∀ lower upper : Lat, ¬ lower ≤ upper →
+    ∃ left right, color left right ≤ lower ∧ ¬ color left right ≤ upper) ∧
+  (∀ seeds : Finset (Carrier × Carrier), seeds.Nonempty → ∀ left right,
+    color left right ≤ seeds.sup (fun edge => color edge.1 edge.2) →
+      Connected color seeds left right)
+
+/-- The graph size is unbounded, but each individual witness is finite and nonempty. -/
+def HasGraphWitness (Lat : Type) [Lattice Lat] [OrderBot Lat] : Prop :=
+  ∃ size : ℕ, 0 < size ∧ ∃ color : Fin size → Fin size → Lat, IsGraphWitness color
+
+section PrincipalColors
+
+variable {Lat Carrier : Type} [Lattice Lat] [OrderBot Lat] {alg : Algebra Carrier}
+
+/-- Color a pair by its principal congruence, transported to the lattice. -/
+noncomputable def principalColor (equiv : Lat ≃o Congruence alg) (left right : Carrier) : Lat :=
+  equiv.symm (Congruence.principal alg left right)
+
+omit [OrderBot Lat] in
+theorem principalColor_le (equiv : Lat ≃o Congruence alg) {left right : Carrier} {bound : Lat} :
+    principalColor equiv left right ≤ bound ↔ equiv bound left right := by
+  change equiv.symm (Congruence.principal alg left right) ≤ bound ↔ _
+  rw [equiv.symm_apply_le]
+  exact Congruence.principal_le
+
+theorem map_bot_equality (equiv : Lat ≃o Congruence alg) :
+    equiv ⊥ = Congruence.equality alg := by
+  apply le_antisymm
+  · have : (⊥ : Lat) ≤ equiv.symm (Congruence.equality alg) := bot_le
+    simpa using equiv.monotone this
+  · exact Congruence.equality_le _
+
+theorem principalColor_eq_bot (equiv : Lat ≃o Congruence alg) (left right : Carrier) :
+    principalColor equiv left right = ⊥ ↔ left = right := by
+  rw [← le_bot_iff, principalColor_le, map_bot_equality, Congruence.equality_apply]
+
+omit [OrderBot Lat] in
+theorem principalColor_triangle (equiv : Lat ≃o Congruence alg) (left right middle : Carrier) :
+    principalColor equiv left right ≤
+      principalColor equiv left middle ⊔ principalColor equiv middle right := by
+  apply (principalColor_le equiv).mpr
+  apply (equiv _).trans
+  · exact (principalColor_le equiv).mp le_sup_left
+  · exact (principalColor_le equiv).mp le_sup_right
+
+omit [OrderBot Lat] in
+theorem principalColor_reflect (equiv : Lat ≃o Congruence alg) (lower upper : Lat)
+    (notBelow : ¬ lower ≤ upper) :
+    ∃ left right, principalColor equiv left right ≤ lower ∧
+      ¬ principalColor equiv left right ≤ upper := by
+  classical
+  by_contra noPair
+  apply notBelow
+  apply equiv.le_iff_le.mp
+  intro left right related
+  by_contra notRelated
+  exact noPair ⟨left, right, (principalColor_le equiv).mpr related,
+    by simpa [principalColor_le] using notRelated⟩
+
+end PrincipalColors
+
+theorem admissible_id {Lat Carrier : Type} [Preorder Lat] (color : Carrier → Carrier → Lat) :
+    Admissible color id := fun _ _ => le_rfl
+
+theorem Admissible.comp {Lat Carrier : Type} [Preorder Lat]
+    {color : Carrier → Carrier → Lat} {outer inner : Carrier → Carrier}
+    (outerAdmissible : Admissible color outer) (innerAdmissible : Admissible color inner) :
+    Admissible color (outer ∘ inner) :=
+  fun left right => le_trans (outerAdmissible _ _) (innerAdmissible left right)
+
+theorem marked_map {Lat Carrier : Type} [Preorder Lat] {color : Carrier → Carrier → Lat}
+    {seeds : Finset (Carrier × Carrier)} {placement : Carrier → Carrier}
+    (admissible : Admissible color placement) {left right : Carrier}
+    (marked : Marked color seeds left right) :
+    Marked color seeds (placement left) (placement right) := by
+  rcases marked with ⟨inner, innerAdmissible, edge, member, rfl, rfl⟩
+  exact ⟨placement ∘ inner, admissible.comp innerAdmissible, edge, member, rfl, rfl⟩
+
+theorem connected_map {Lat Carrier : Type} [Preorder Lat] {color : Carrier → Carrier → Lat}
+    {seeds : Finset (Carrier × Carrier)} {placement : Carrier → Carrier}
+    (admissible : Admissible color placement) {left right : Carrier}
+    (connected : Connected color seeds left right) :
+    Connected color seeds (placement left) (placement right) := by
+  induction connected with
+  | rel left right marked => exact Relation.EqvGen.rel _ _ (marked_map admissible marked)
+  | refl point => exact Relation.EqvGen.refl _
+  | symm left right _ inductionHyp => exact Relation.EqvGen.symm _ _ inductionHyp
+  | trans left middle right _ _ first second => exact Relation.EqvGen.trans _ _ _ first second
+
+section Forward
+
+variable {Lat Carrier : Type} [Lattice Lat] [OrderBot Lat] {alg : Algebra Carrier}
+
+omit [OrderBot Lat] in
+theorem translation_admissible (equiv : Lat ≃o Congruence alg) (index : Fin alg.numOps)
+    (coord : Fin (alg.arity index)) (inputs : Fin (alg.arity index) → Carrier) :
+    Admissible (principalColor equiv) (translation alg index coord inputs) := by
+  intro left right
+  apply (principalColor_le equiv).mpr
+  exact translation_preserves (equiv (principalColor equiv left right)) index coord inputs
+    ((principalColor_le equiv).mp le_rfl)
+
+/-- Connectivity in the marked graph is a congruence of the original algebra, not just
+of its admissible unary maps. -/
+noncomputable def pathCongruence (equiv : Lat ≃o Congruence alg)
+    (seeds : Finset (Carrier × Carrier)) : Congruence alg :=
+  ⟨Relation.EqvGen.setoid (Marked (principalColor equiv) seeds), by
+    apply (compatible_iff_translations alg _).mpr
+    intro index coord inputs left right related
+    exact connected_map (translation_admissible equiv index coord inputs) related⟩
+
+theorem principalColor_connected (equiv : Lat ≃o Congruence alg)
+    (seeds : Finset (Carrier × Carrier)) (left right : Carrier)
+    (below : principalColor equiv left right ≤
+      seeds.sup (fun edge => principalColor equiv edge.1 edge.2)) :
+    Connected (principalColor equiv) seeds left right := by
+  have supBelow : seeds.sup (fun edge => principalColor equiv edge.1 edge.2) ≤
+      equiv.symm (pathCongruence equiv seeds) := by
+    apply Finset.sup_le
+    intro edge member
+    change equiv.symm (Congruence.principal alg edge.1 edge.2) ≤
+      equiv.symm (pathCongruence equiv seeds)
+    apply equiv.symm.monotone
+    apply Congruence.principal_le.mpr
+    exact Relation.EqvGen.rel _ _ ⟨id, admissible_id _, edge, member, rfl, rfl⟩
+  have principalBelow : Congruence.principal alg left right ≤ pathCongruence equiv seeds :=
+    equiv.symm.le_iff_le.mp (below.trans supBelow)
+  exact Congruence.principal_le.mp principalBelow
+
+theorem principalColor_isGraphWitness (equiv : Lat ≃o Congruence alg) :
+    IsGraphWitness (principalColor equiv) := by
+  refine ⟨?_, principalColor_eq_bot equiv, principalColor_triangle equiv,
+    principalColor_reflect equiv, ?_⟩
+  · intro left right
+    simp only [principalColor, Congruence.principal_comm left right]
+  · intro seeds _ left right below
+    exact principalColor_connected equiv seeds left right below
+
+end Forward
+
+section Backward
+
+variable {Lat Carrier : Type} [Lattice Lat] [OrderBot Lat] [Fintype Carrier]
+
+/-- All label-decreasing maps, made into a finite list of unary total operations. -/
+noncomputable def graphAlgebra (color : Carrier → Carrier → Lat) : Algebra Carrier := by
+  classical
+  let Maps := {placement : Carrier → Carrier // Admissible color placement}
+  exact {
+    numOps := Fintype.card Maps
+    arity := fun _ => 1
+    op := fun index inputs => ((Fintype.equivFin Maps).symm index).1 (inputs 0)
+  }
+
+omit [OrderBot Lat] in
+/-- Every admissible map is one of the basic unary operations. -/
+theorem graphAlgebra_preserves (color : Carrier → Carrier → Lat)
+    (rel : Congruence (graphAlgebra color)) {placement : Carrier → Carrier}
+    (admissible : Admissible color placement) {left right : Carrier} (related : rel left right) :
+    rel (placement left) (placement right) := by
+  classical
+  let Maps := {placement : Carrier → Carrier // Admissible color placement}
+  have preserved := rel.compatible ((Fintype.equivFin Maps) ⟨placement, admissible⟩)
+    (fun _ => left) (fun _ => right) (fun _ => related)
+  simpa only [graphAlgebra, Maps, Equiv.symm_apply_apply] using preserved
+
+/-- Each lattice element defines the equivalence relation of edges below its color. -/
+noncomputable def labelCongruence (color : Carrier → Carrier → Lat)
+    (witness : IsGraphWitness color) (bound : Lat) : Congruence (graphAlgebra color) := by
+  classical
+  refine ⟨⟨fun left right => color left right ≤ bound, ⟨?_, ?_, ?_⟩⟩, ?_⟩
+  · intro point
+    rw [(witness.2.1 point point).mpr rfl]
+    exact bot_le
+  · intro left right below
+    rwa [witness.1 right left]
+  · intro left middle right first second
+    exact (witness.2.2.1 left right middle).trans (sup_le first second)
+  · intro index left right below
+    exact ((((Fintype.equivFin
+      {placement : Carrier → Carrier // Admissible color placement}).symm index).2) _ _).trans
+        (below ⟨0, by change 0 < 1; decide⟩)
+
+@[simp] theorem labelCongruence_apply (color : Carrier → Carrier → Lat)
+    (witness : IsGraphWitness color) (bound : Lat) (left right : Carrier) :
+    labelCongruence color witness bound left right ↔ color left right ≤ bound := Iff.rfl
+
+theorem labelCongruence_le_iff (color : Carrier → Carrier → Lat)
+    (witness : IsGraphWitness color) (lower upper : Lat) :
+    labelCongruence color witness lower ≤ labelCongruence color witness upper ↔ lower ≤ upper := by
+  constructor
+  · intro below
+    by_contra notBelow
+    obtain ⟨left, right, belowLower, notBelowUpper⟩ := witness.2.2.2.1 lower upper notBelow
+    exact notBelowUpper (below belowLower)
+  · intro below left right belowLower
+    exact belowLower.trans below
+
+omit [OrderBot Lat] in
+/-- Equivalence closure of marked edges lies in every congruence containing the seed edges. -/
+theorem connected_below_congruence (color : Carrier → Carrier → Lat)
+    (rel : Congruence (graphAlgebra color)) (seeds : Finset (Carrier × Carrier))
+    (contains : ∀ edge ∈ seeds, rel edge.1 edge.2) {left right : Carrier}
+    (connected : Connected color seeds left right) : rel left right := by
+  induction connected with
+  | rel left right marked =>
+    obtain ⟨placement, admissible, edge, member, rfl, rfl⟩ := marked
+    exact graphAlgebra_preserves color rel admissible (contains edge member)
+  | refl point => exact rel.refl point
+  | symm left right _ inductionHyp => exact rel.symm inductionHyp
+  | trans left middle right _ _ first second => exact rel.trans first second
+
+/-- Every congruence is recovered using all its related pairs. -/
+theorem labelCongruence_surjective [Nonempty Carrier] (color : Carrier → Carrier → Lat)
+    (witness : IsGraphWitness color) : Function.Surjective (labelCongruence color witness) := by
+  classical
+  intro rel
+  let seeds : Finset (Carrier × Carrier) := Finset.univ.filter (fun edge => rel edge.1 edge.2)
+  have membership : ∀ edge, edge ∈ seeds ↔ rel edge.1 edge.2 := by simp [seeds]
+  have nonempty : seeds.Nonempty := by
+    obtain ⟨point⟩ := ‹Nonempty Carrier›
+    exact ⟨(point, point), (membership _).mpr (rel.refl point)⟩
+  refine ⟨seeds.sup (fun edge => color edge.1 edge.2), ?_⟩
+  apply Congruence.ext
+  intro left right
+  constructor
+  · intro below
+    exact connected_below_congruence color rel seeds (fun edge member => (membership edge).mp member)
+      (witness.2.2.2.2 seeds nonempty left right below)
+  · intro related
+    change color left right ≤ seeds.sup (fun edge => color edge.1 edge.2)
+    exact Finset.le_sup (f := fun edge : Carrier × Carrier => color edge.1 edge.2)
+      ((membership (left, right)).mpr related)
+
+/-- The lattice is isomorphic to the full congruence lattice of the graph algebra. -/
+noncomputable def graphOrderIso [Nonempty Carrier] (color : Carrier → Carrier → Lat)
+    (witness : IsGraphWitness color) : Lat ≃o Congruence (graphAlgebra color) :=
+  { Equiv.ofBijective (labelCongruence color witness)
+      ⟨fun lower upper equal => le_antisymm
+        ((labelCongruence_le_iff color witness lower upper).mp equal.le)
+        ((labelCongruence_le_iff color witness upper lower).mp equal.ge),
+        labelCongruence_surjective color witness⟩ with
+    map_rel_iff' := fun {lower upper} => labelCongruence_le_iff color witness lower upper }
+
+end Backward
+
+/-- A finite lattice is representable as the full congruence lattice of a nonempty finite
+algebra exactly when it has a finite nonempty colored-graph witness. -/
+theorem graph_criterion (Lat : Type) [Fintype Lat] [Lattice Lat] [OrderBot Lat] :
+    Representable Lat ↔ HasGraphWitness Lat := by
+  constructor
+  · rintro ⟨size, positive, alg, ⟨equiv⟩⟩
+    exact ⟨size, positive, principalColor equiv, principalColor_isGraphWitness equiv⟩
+  · rintro ⟨size, positive, color, witness⟩
+    have : Nonempty (Fin size) := ⟨⟨0, positive⟩⟩
+    exact ⟨size, positive, graphAlgebra color, ⟨graphOrderIso color witness⟩⟩
+
+end FiniteCongruence
+
+end OAI
diff --git a/lean/OAI/Algebra/Universal/GraphDecidability.lean b/lean/OAI/Algebra/Universal/GraphDecidability.lean
new file mode 100644
index 0000000000000000000000000000000000000000..71813ebe68d8f1d95074d50b4f8d686e9f903d7f
--- /dev/null
+++ b/lean/OAI/Algebra/Universal/GraphDecidability.lean
@@ -0,0 +1,112 @@
+import OAI.Algebra.Universal.GraphCriterion
+import Mathlib.Data.Fintype.Powerset
+
+namespace OAI
+
+/-!
+# Decidability of fixed-size graph witnesses
+
+Connectivity is characterized by containment in every Boolean equivalence relation containing
+the marked edges. On a finite carrier this gives an executable decision procedure, and hence
+a decision procedure for the existence of a graph witness at each fixed size. The size of a
+witness in `HasGraphWitness` is not bounded by these results.
+-/
+
+namespace FiniteCongruence
+
+/-- A Boolean relation is closed if it is an equivalence containing every marked edge. -/
+def ClosedMarking {Lat Carrier : Type} [LE Lat] (color : Carrier → Carrier → Lat)
+    (seeds : Finset (Carrier × Carrier)) (rel : Carrier → Carrier → Bool) : Prop :=
+  (∀ point, rel point point = true) ∧
+  (∀ left right, rel left right = true → rel right left = true) ∧
+  (∀ left middle right, rel left middle = true → rel middle right = true → rel left right = true) ∧
+  (∀ left right, Marked color seeds left right → rel left right = true)
+
+/-- Connectivity is the intersection of the Boolean equivalence relations containing all
+marked edges. This characterization uses classical logic but allows finite enumeration. -/
+theorem connected_iff_closedMarkings {Lat Carrier : Type} [LE Lat]
+    (color : Carrier → Carrier → Lat) (seeds : Finset (Carrier × Carrier)) (left right : Carrier) :
+    Connected color seeds left right ↔
+      ∀ rel : Carrier → Carrier → Bool, ClosedMarking color seeds rel → rel left right = true := by
+  constructor
+  · intro connected rel closed
+    induction connected with
+    | rel first second marked => exact closed.2.2.2 first second marked
+    | refl point => exact closed.1 point
+    | symm first second _ inductionHyp => exact closed.2.1 first second inductionHyp
+    | trans first middle last _ _ firstHyp secondHyp =>
+      exact closed.2.2.1 first middle last firstHyp secondHyp
+  · classical
+    intro contained
+    let rel : Carrier → Carrier → Bool := fun first second =>
+      decide (Connected color seeds first second)
+    have closed : ClosedMarking color seeds rel := by
+      refine ⟨?_, ?_, ?_, ?_⟩
+      · intro point
+        exact decide_eq_true (Relation.EqvGen.refl point)
+      · intro first second related
+        exact decide_eq_true (Relation.EqvGen.symm first second (of_decide_eq_true related))
+      · intro first middle last firstRelated secondRelated
+        exact decide_eq_true (Relation.EqvGen.trans first middle last
+          (of_decide_eq_true firstRelated) (of_decide_eq_true secondRelated))
+      · intro first second marked
+        exact decide_eq_true (Relation.EqvGen.rel first second marked)
+    exact of_decide_eq_true (contained rel closed)
+
+instance decidableAdmissible {Lat Carrier : Type} [LE Lat] [DecidableLE Lat] [Fintype Carrier]
+    (color : Carrier → Carrier → Lat) (placement : Carrier → Carrier) :
+    Decidable (Admissible color placement) :=
+  inferInstanceAs (Decidable
+    (∀ left right, color (placement left) (placement right) ≤ color left right))
+
+instance decidableMarked {Lat Carrier : Type} [LE Lat] [DecidableLE Lat]
+    [Fintype Carrier] [DecidableEq Carrier] (color : Carrier → Carrier → Lat)
+    (seeds : Finset (Carrier × Carrier)) (left right : Carrier) :
+    Decidable (Marked color seeds left right) :=
+  inferInstanceAs (Decidable
+    (∃ placement : Carrier → Carrier, Admissible color placement ∧
+      ∃ edge ∈ seeds, placement edge.1 = left ∧ placement edge.2 = right))
+
+instance decidableClosedMarking {Lat Carrier : Type} [LE Lat] [DecidableLE Lat]
+    [Fintype Carrier] [DecidableEq Carrier] (color : Carrier → Carrier → Lat)
+    (seeds : Finset (Carrier × Carrier)) (rel : Carrier → Carrier → Bool) :
+    Decidable (ClosedMarking color seeds rel) :=
+  inferInstanceAs (Decidable
+    ((∀ point, rel point point = true) ∧
+    (∀ left right, rel left right = true → rel right left = true) ∧
+    (∀ left middle right, rel left middle = true → rel middle right = true → rel left right = true) ∧
+    (∀ left right, Marked color seeds left right → rel left right = true)))
+
+instance decidableConnected {Lat Carrier : Type} [LE Lat] [DecidableLE Lat]
+    [Fintype Carrier] [DecidableEq Carrier] (color : Carrier → Carrier → Lat)
+    (seeds : Finset (Carrier × Carrier)) (left right : Carrier) :
+    Decidable (Connected color seeds left right) :=
+  decidable_of_iff
+    (∀ rel : Carrier → Carrier → Bool, ClosedMarking color seeds rel → rel left right = true)
+    (connected_iff_closedMarkings color seeds left right).symm
+
+/-- An executable fixed-size test, with no classical choice in its computational content. -/
+def graphWitnessDecidable (Lat Carrier : Type) [Fintype Lat] [Lattice Lat] [OrderBot Lat]
+    [DecidableEq Lat] [DecidableLE Lat] [Fintype Carrier] [DecidableEq Carrier]
+    (color : Carrier → Carrier → Lat) : Decidable (IsGraphWitness color) :=
+  inferInstanceAs (Decidable
+    ((∀ left right, color left right = color right left) ∧
+    (∀ left right, color left right = ⊥ ↔ left = right) ∧
+    (∀ left right middle, color left right ≤ color left middle ⊔ color middle right) ∧
+    (∀ lower upper : Lat, ¬ lower ≤ upper →
+      ∃ left right, color left right ≤ lower ∧ ¬ color left right ≤ upper) ∧
+    (∀ seeds : Finset (Carrier × Carrier), seeds.Nonempty → ∀ left right,
+      color left right ≤ seeds.sup (fun edge => color edge.1 edge.2) →
+        Connected color seeds left right)))
+
+/-- Existence of a colored-graph witness at a fixed candidate size is decidable. -/
+def graphSizeDecidable (Lat : Type) [Fintype Lat] [Lattice Lat] [OrderBot Lat]
+    [DecidableEq Lat] [DecidableLE Lat] (size : ℕ) :
+    Decidable (0 < size ∧ ∃ color : Fin size → Fin size → Lat, IsGraphWitness color) := by
+  letI : DecidablePred (fun color : Fin size → Fin size → Lat => IsGraphWitness color) :=
+    graphWitnessDecidable Lat (Fin size)
+  infer_instance
+
+end FiniteCongruence
+
+end OAI
diff --git a/lean/OAI/AlgebraicGeometry/AbhyankarSathaye/Counterexample.lean b/lean/OAI/AlgebraicGeometry/AbhyankarSathaye/Counterexample.lean
new file mode 100644
index 0000000000000000000000000000000000000000..10a76c4cd4828cad0e2bef5b1eaee47d006bc5bf
--- /dev/null
+++ b/lean/OAI/AlgebraicGeometry/AbhyankarSathaye/Counterexample.lean
@@ -0,0 +1,45 @@
+import OAI.AlgebraicGeometry.AbhyankarSathaye.FiberFormulas
+import OAI.AlgebraicGeometry.AbhyankarSathaye.LinearPresentation
+import OAI.AlgebraicGeometry.AbhyankarSathaye.Stabilization
+
+namespace OAI
+
+/-!
+# A polynomial hypersurface with a non-coordinate equation
+
+The explicit polynomial `F` has zero fiber isomorphic to affine three-space,
+but has a critical point on the fiber of value `-1`, obstructing its being a
+polynomial coordinate. Both conclusions persist after adjoining any number
+of unused variables.
+-/
+
+namespace AbhyankarSathaye
+
+/-- The explicit hypersurface has a polynomial coordinate ring but its defining
+polynomial is not a coordinate, in every ambient dimension at least four. -/
+theorem counterexample :
+    Nonempty ((R ⧸ Ideal.span {F}) ≃ₐ[ℂ] MvPolynomial (Fin 3) ℂ) ∧
+    (∀ index : Fin 4, MvPolynomial.eval criticalPoint (MvPolynomial.pderiv index F) = 0) ∧
+    MvPolynomial.eval criticalPoint F = -1 ∧
+    (¬ ∃ (equiv : R ≃ₐ[ℂ] R) (index : Fin 4), equiv (MvPolynomial.X index) = F) ∧
+    ∀ (dimension : ℕ) (bound : 4 ≤ dimension),
+      Nonempty ((MvPolynomial (Fin dimension) ℂ ⧸ Ideal.span {extendedF bound}) ≃ₐ[ℂ]
+        MvPolynomial (Fin (dimension - 1)) ℂ) ∧
+      ¬ ∃ (equiv : MvPolynomial (Fin dimension) ℂ ≃ₐ[ℂ] MvPolynomial (Fin dimension) ℂ)
+        (index : Fin dimension), equiv (MvPolynomial.X index) = extendedF bound :=
+  ⟨⟨fiberEquiv⟩, critical_derivatives, eval_F, F_not_coordinate,
+    fun _ bound => ⟨⟨extendedFiberEquiv bound⟩, extendedF_not_coordinate bound⟩⟩
+
+/-- In every dimension at least four, a polynomial can define affine space
+without being a coordinate of the ambient polynomial ring. -/
+theorem exists_noncoordinate_polynomial (n : ℕ) (hn : 4 ≤ n) :
+    ∃ F : MvPolynomial (Fin n) ℂ,
+      Nonempty ((MvPolynomial (Fin n) ℂ ⧸ Ideal.span {F}) ≃ₐ[ℂ]
+        MvPolynomial (Fin (n - 1)) ℂ) ∧
+      ¬ ∃ (equiv : MvPolynomial (Fin n) ℂ ≃ₐ[ℂ] MvPolynomial (Fin n) ℂ)
+        (index : Fin n), equiv (MvPolynomial.X index) = F :=
+  ⟨extendedF hn, counterexample.2.2.2.2 n hn⟩
+
+end AbhyankarSathaye
+
+end OAI
diff --git a/lean/OAI/AlgebraicGeometry/AbhyankarSathaye/CriticalPoint.lean b/lean/OAI/AlgebraicGeometry/AbhyankarSathaye/CriticalPoint.lean
new file mode 100644
index 0000000000000000000000000000000000000000..1339cb360f9d30eef5791d00eba0561d59d79116
--- /dev/null
+++ b/lean/OAI/AlgebraicGeometry/AbhyankarSathaye/CriticalPoint.lean
@@ -0,0 +1,65 @@
+import OAI.AlgebraicGeometry.AbhyankarSathaye.Identities
+import Mathlib.Algebra.MvPolynomial.PDeriv
+import Mathlib.Tactic.NormNum
+
+namespace OAI
+
+/-!
+# An explicit critical point away from the zero fiber
+
+At `(h,u,v,w) = (2,0,-1/2,1/2)`, the value of `F` is `-1` and every
+partial derivative vanishes. Differentiating the ambient polynomial identity
+proves the latter without expanding `F`.
+-/
+
+noncomputable section
+namespace AbhyankarSathaye
+open MvPolynomial
+
+def criticalPoint (i : Fin 4) : ℂ :=
+  if i = 0 then 2 else if i = 1 then 0 else if i = 2 then -1/2 else 1/2
+
+@[simp] theorem criticalPoint_h : criticalPoint 0 = 2 := rfl
+@[simp] theorem criticalPoint_u : criticalPoint 1 = 0 := rfl
+@[simp] theorem criticalPoint_v : criticalPoint 2 = -1/2 := rfl
+@[simp] theorem criticalPoint_w : criticalPoint 3 = 1/2 := rfl
+
+theorem eval_x : eval criticalPoint x = -1 := by
+  norm_num [x, u, h, v]
+
+theorem eval_y : eval criticalPoint y = 1 := by
+  norm_num [y, u, h, w]
+
+theorem eval_s : eval criticalPoint s = 1 := by
+  norm_num [s, S, u, h, v, w]
+
+theorem eval_p : eval criticalPoint p = 2 := by
+  norm_num [p, P, eval_x, eval_y, eval_s]
+
+theorem eval_F : eval criticalPoint F = -1 := by
+  norm_num [F, h, eval_p]
+
+theorem eval_shiftX : eval criticalPoint shiftX = 0 := by
+  norm_num [shiftX, eval_x, eval_s]
+
+theorem eval_shiftY : eval criticalPoint shiftY = 0 := by
+  norm_num [shiftY, eval_y, eval_s]
+
+theorem critical_of_ambient_identity {σ B : Type*} [CommRing B]
+    (A D E f : MvPolynomial σ B) (point : σ → B)
+    (hid : A^2 + D^3 = E*(1+f))
+    (hA : eval point A = 0) (hD : eval point D = 0)
+    (hE : eval point E = 1) (hf : eval point f = -1) (i : σ) :
+    eval point (pderiv i f) = 0 := by
+  have hd := congrArg (fun z => eval point (pderiv i z)) hid
+  simpa [pderiv_pow, pderiv_mul, hA, hD, hE, hf] using hd.symm
+
+theorem critical_derivatives (i : Fin 4) : eval criticalPoint (pderiv i F) = 0 :=
+  critical_of_ambient_identity shiftX shiftY s F criticalPoint ambient
+    eval_shiftX eval_shiftY eval_s eval_F i
+
+end AbhyankarSathaye
+
+end
+
+end OAI
diff --git a/lean/OAI/AlgebraicGeometry/AbhyankarSathaye/Fiber.lean b/lean/OAI/AlgebraicGeometry/AbhyankarSathaye/Fiber.lean
new file mode 100644
index 0000000000000000000000000000000000000000..ca60b14bfc778651c8cec6d19b697dec840d7c76
--- /dev/null
+++ b/lean/OAI/AlgebraicGeometry/AbhyankarSathaye/Fiber.lean
@@ -0,0 +1,66 @@
+import OAI.AlgebraicGeometry.AbhyankarSathaye.Presentation
+import Mathlib.Algebra.MvPolynomial.Equiv
+
+namespace OAI
+
+/-!
+# The polynomial algebra structure of the zero fiber
+
+Composing elimination, lifting, the plane parametrization, and a permutation
+of variables gives the complex algebra isomorphism with `ℂ[X,Y,T]`.
+-/
+
+noncomputable section
+namespace AbhyankarSathaye
+open MvPolynomial Presentation
+
+def variableOrder : Fin 3 ≃ Fin 3 where
+  toFun := ![2,0,1]
+  invFun := ![1,2,0]
+  left_inv := by intro i; fin_cases i <;> rfl
+  right_inv := by intro i; fin_cases i <;> rfl
+
+def flattenPlane : Polynomial (MvPolynomial (Fin 2) ℂ) ≃ₐ[ℂ] MvPolynomial (Fin 3) ℂ :=
+  (MvPolynomial.finSuccEquiv ℂ 2).symm.trans (renameEquiv ℂ variableOrder)
+
+@[simp] theorem flattenPlane_symm_X0 : flattenPlane.symm (X 0) = Polynomial.C (X 0) := by
+  change MvPolynomial.finSuccEquiv ℂ 2 (rename variableOrder.symm (X 0)) = _
+  rw [rename_X]
+  exact finSuccEquiv_X_succ (j := (0 : Fin 2))
+
+@[simp] theorem flattenPlane_symm_X1 : flattenPlane.symm (X 1) = Polynomial.C (X 1) := by
+  change MvPolynomial.finSuccEquiv ℂ 2 (rename variableOrder.symm (X 1)) = _
+  rw [rename_X]
+  exact finSuccEquiv_X_succ (j := (1 : Fin 2))
+
+@[simp] theorem flattenPlane_symm_X2 : flattenPlane.symm (X 2) = Polynomial.X := by
+  change MvPolynomial.finSuccEquiv ℂ 2 (rename variableOrder.symm (X 2)) = _
+  rw [rename_X]
+  exact finSuccEquiv_X_zero
+
+@[simp] theorem flattenPlane_C_X0 : flattenPlane (Polynomial.C (X 0)) = X 0 := by
+  apply flattenPlane.symm.injective
+  simp
+@[simp] theorem flattenPlane_C_X1 : flattenPlane (Polynomial.C (X 1)) = X 1 := by
+  apply flattenPlane.symm.injective
+  simp
+@[simp] theorem flattenPlane_X : flattenPlane Polynomial.X = X 2 := by
+  apply flattenPlane.symm.injective
+  simp
+
+def liftedEquiv : L ≃ₐ[ℂ] Polynomial B :=
+  (Lifting.equivalence hB xB yB sB (Alpha xB sB) (Beta xB yB sB)
+    (Plane.relation_cusp ℂ) (Plane.bezout ℂ)).restrictScalars ℂ
+
+def planeExtensionEquiv : Polynomial B ≃ₐ[ℂ] Polynomial (MvPolynomial (Fin 2) ℂ) :=
+  Polynomial.mapAlgEquiv (Plane.equivalence ℂ)
+
+def fiberEquiv : (R ⧸ Ideal.span {F}) ≃ₐ[ℂ] MvPolynomial (Fin 3) ℂ :=
+  Presentation.eliminationEquiv.symm.trans
+    (liftedEquiv.trans (planeExtensionEquiv.trans flattenPlane))
+
+end AbhyankarSathaye
+
+end
+
+end OAI
diff --git a/lean/OAI/AlgebraicGeometry/AbhyankarSathaye/FiberFormulas.lean b/lean/OAI/AlgebraicGeometry/AbhyankarSathaye/FiberFormulas.lean
new file mode 100644
index 0000000000000000000000000000000000000000..ca172ceb0eafd3a33c869d3995e77466e8901539
--- /dev/null
+++ b/lean/OAI/AlgebraicGeometry/AbhyankarSathaye/FiberFormulas.lean
@@ -0,0 +1,112 @@
+import OAI.AlgebraicGeometry.AbhyankarSathaye.Fiber
+
+namespace OAI
+
+/-!
+# Explicit coordinates on the zero fiber
+
+The inverse isomorphism sends `X`, `Y`, and `T` to `x + s³`, `y - s²`,
+and `α * u + β * (v + u * w)`. The forward isomorphism is given by the
+polynomials `freeH`, `freeU`, `freeV`, and `freeW`, with variables ordered `X, Y, T`.
+-/
+
+noncomputable section
+namespace AbhyankarSathaye
+open MvPolynomial Presentation
+
+def fiberParameter : R := parameter (Alpha x s) (Beta x y s) u v w
+
+theorem fiberEquiv_symm_X0 : fiberEquiv.symm (X 0) = dmap shiftX := by
+  change toOriginal (Lifting.backward hB xB yB sB (Alpha xB sB) (Beta xB yB sB)
+    (Polynomial.map (Plane.backward ℂ).toRingHom (flattenPlane.symm (X 0)))) = _
+  rw [flattenPlane_symm_X0, Polynomial.map_C]
+  have he : (Plane.backward ℂ).toRingHom (X 0) = xB+sB^3 := by simp [Plane.backward]
+  rw [he]
+  simp only [Lifting.backward, Polynomial.aeval_C]
+  change toOriginal (lcoef (xB+sB^3)) = _
+  simp [auxValues, shiftX]
+
+theorem fiberEquiv_symm_X1 : fiberEquiv.symm (X 1) = dmap shiftY := by
+  change toOriginal (Lifting.backward hB xB yB sB (Alpha xB sB) (Beta xB yB sB)
+    (Polynomial.map (Plane.backward ℂ).toRingHom (flattenPlane.symm (X 1)))) = _
+  rw [flattenPlane_symm_X1, Polynomial.map_C]
+  have he : (Plane.backward ℂ).toRingHom (X 1) = yB-sB^2 := by simp [Plane.backward]
+  rw [he]
+  simp only [Lifting.backward, Polynomial.aeval_C]
+  change toOriginal (lcoef (yB-sB^2)) = _
+  simp [auxValues, shiftY]
+
+theorem fiberEquiv_symm_X2 : fiberEquiv.symm (X 2) = dmap fiberParameter := by
+  change toOriginal (Lifting.backward hB xB yB sB (Alpha xB sB) (Beta xB yB sB)
+    (Polynomial.map (Plane.backward ℂ).toRingHom (flattenPlane.symm (X 2)))) = _
+  rw [flattenPlane_symm_X2, Polynomial.map_X]
+  simp only [Lifting.backward, Polynomial.aeval_X]
+  change toOriginal (parameter (lcoef (Alpha xB sB)) (lcoef (Beta xB yB sB))
+    (lvar 0) (lvar 1) (lvar 2)) = _
+  simp [fiberParameter, auxValues, liftValues]
+
+def freeS : MvPolynomial (Fin 3) ℂ := X 0^2+X 1^3
+def freeX : MvPolynomial (Fin 3) ℂ := X 0-freeS^3
+def freeY : MvPolynomial (Fin 3) ℂ := X 1+freeS^2
+def freeH : MvPolynomial (Fin 3) ℂ := 1+P freeX freeY freeS
+def freeAlpha : MvPolynomial (Fin 3) ℂ := Alpha freeX freeS
+def freeBeta : MvPolynomial (Fin 3) ℂ := Beta freeX freeY freeS
+def freeU : MvPolynomial (Fin 3) ℂ := inverseU freeH freeX freeBeta (X 2)
+def freeG : MvPolynomial (Fin 3) ℂ := inverseG freeX freeY freeAlpha (X 2)
+def freeW : MvPolynomial (Fin 3) ℂ := inverseW freeH freeY freeS freeAlpha freeBeta freeU freeG
+def freeV : MvPolynomial (Fin 3) ℂ := inverseV freeU freeG freeW
+
+@[simp] theorem symm_freeS : fiberEquiv.symm freeS = dmap s := by
+  have ha := congrArg dmap ambient
+  simp only [map_add, map_pow, map_mul, map_one, dmap_F, add_zero, mul_one] at ha
+  simpa [freeS, fiberEquiv_symm_X0, fiberEquiv_symm_X1] using ha
+
+@[simp] theorem symm_freeX : fiberEquiv.symm freeX = dmap x := by
+  simp [freeX, fiberEquiv_symm_X0, shiftX]
+
+@[simp] theorem symm_freeY : fiberEquiv.symm freeY = dmap y := by
+  simp [freeY, fiberEquiv_symm_X1, shiftY]
+
+@[simp] theorem symm_freeH : fiberEquiv.symm freeH = dmap h := by
+  have hf : dmap h-dmap p-1 = 0 := by simpa [F] using dmap_F
+  have hh : 1+dmap p = dmap h := by
+    calc
+      _ = dmap h-(dmap h-dmap p-1) := by ring
+      _ = dmap h := by rw [hf, sub_zero]
+  simpa [freeH, p] using hh
+
+@[simp] theorem symm_freeAlpha : fiberEquiv.symm freeAlpha = dmap (Alpha x s) := by
+  simp [freeAlpha]
+@[simp] theorem symm_freeBeta : fiberEquiv.symm freeBeta = dmap (Beta x y s) := by
+  simp [freeBeta]
+
+theorem inverse_formulas_in_quotient : fiberEquiv.symm freeU = dmap u ∧
+    fiberEquiv.symm freeV = dmap v ∧ fiberEquiv.symm freeW = dmap w := by
+  have hc : x^2+y^3-s*h = 0 := by rw [cusp]; ring
+  have hh : h-1-P x y s = F := by unfold F p; ring
+  have hb : dmap (Alpha x s)*dmap h+dmap (Beta x y s)*dmap y = 1 := by
+    have he := congrArg dmap (bezout_certificate h x y s)
+    rw [hc, hh] at he
+    simpa [p, dmap_F, ← sub_eq_zero] using he
+  have hx : (dmap u)^3+dmap h*dmap v = dmap x := by simp [x]
+  have hy : -(dmap u)^2+dmap h*dmap w = dmap y := by simp [y]
+  have hs : S (dmap h) (dmap u) (dmap v) (dmap w) = dmap s := by simp [s]
+  have hr := original_reconstruction (dmap h) (dmap x) (dmap y) (dmap s)
+    (dmap (Alpha x s)) (dmap (Beta x y s)) (dmap u) (dmap v) (dmap w) hb hx hy hs
+  simpa [freeU, freeV, freeW, freeG, fiberEquiv_symm_X2, fiberParameter] using hr
+
+theorem explicit_inverse_formulas :
+    fiberEquiv (dmap h) = freeH ∧ fiberEquiv (dmap u) = freeU ∧
+    fiberEquiv (dmap v) = freeV ∧ fiberEquiv (dmap w) = freeW := by
+  obtain ⟨hu, hv, hw⟩ := inverse_formulas_in_quotient
+  refine ⟨?_, ?_, ?_, ?_⟩
+  · exact (fiberEquiv.apply_symm_apply freeH) ▸ congrArg fiberEquiv symm_freeH.symm
+  · exact (fiberEquiv.apply_symm_apply freeU) ▸ congrArg fiberEquiv hu.symm
+  · exact (fiberEquiv.apply_symm_apply freeV) ▸ congrArg fiberEquiv hv.symm
+  · exact (fiberEquiv.apply_symm_apply freeW) ▸ congrArg fiberEquiv hw.symm
+
+end AbhyankarSathaye
+
+end
+
+end OAI
diff --git a/lean/OAI/AlgebraicGeometry/AbhyankarSathaye/Identities.lean b/lean/OAI/AlgebraicGeometry/AbhyankarSathaye/Identities.lean
new file mode 100644
index 0000000000000000000000000000000000000000..16673c7a19fa8b66c1c0f37edf5fd220964fe0f0
--- /dev/null
+++ b/lean/OAI/AlgebraicGeometry/AbhyankarSathaye/Identities.lean
@@ -0,0 +1,75 @@
+import Mathlib.Algebra.MvPolynomial.CommRing
+import Mathlib.Basic.Complex.Basic
+import Mathlib.Tactic.Ring
+
+namespace OAI
+
+/-!
+# Polynomial identities for the cusp and the explicit hypersurface
+
+The polynomials `S` and `P` give the identity
+`(x + s³)² + (y - s²)³ = s * (1 + F)`. The Bézout certificate is valid over
+every commutative ring. In the ambient complex polynomial ring, the variables
+are ordered as `h, u, v, w`.
+-/
+
+noncomputable section
+namespace AbhyankarSathaye
+
+def S {B : Type*} [CommRing B] (h u v w : B) : B :=
+  2*u^3*v + 3*u^4*w + h*(v^2 - 3*u^2*w^2) + h^2*w^3
+
+def P {B : Type*} [CommRing B] (x y s : B) : B :=
+  -2*s^2*x + 3*s*y^2 - 3*s^3*y
+
+def Alpha {B : Type*} [CommRing B] (x s : B) : B :=
+  1 + 2*s^2*x + 4*s^5
+
+def Beta {B : Type*} [CommRing B] (x y s : B) : B :=
+  (3*s^3 - 3*s*y)*(1 + 2*s^2*x) - 4*s^4*y^2
+
+theorem cusp_universal {B : Type*} [CommRing B] (h u v w : B) :
+    (u^3 + h*v)^2 + (-u^2 + h*w)^3 = h*S h u v w := by
+  unfold S
+  ring
+
+theorem shift_universal {B : Type*} [CommRing B] (x y s : B) :
+    (x + s^3)^2 + (y - s^2)^3 = x^2 + y^3 - s*P x y s := by
+  unfold P
+  ring
+
+theorem bezout_certificate {B : Type*} [CommRing B] (h x y s : B) :
+    Alpha x s*h + Beta x y s*y - 1 =
+      (1 + 2*s^2*x)*(h - 1 - P x y s) - 4*s^4*(x^2 + y^3 - s*h) := by
+  unfold Alpha Beta P
+  ring
+
+abbrev R := MvPolynomial (Fin 4) ℂ
+
+def h : R := MvPolynomial.X 0
+def u : R := MvPolynomial.X 1
+def v : R := MvPolynomial.X 2
+def w : R := MvPolynomial.X 3
+def x : R := u^3 + h*v
+def y : R := -u^2 + h*w
+def s : R := S h u v w
+def p : R := P x y s
+def F : R := h - p - 1
+def shiftX : R := x + s^3
+def shiftY : R := y - s^2
+
+theorem cusp : x^2 + y^3 = h*s := cusp_universal h u v w
+
+theorem shift : shiftX^2 + shiftY^3 = x^2 + y^3 - s*p :=
+  shift_universal x y s
+
+theorem ambient : shiftX^2 + shiftY^3 = s*(1 + F) := by
+  rw [shift, cusp]
+  unfold F
+  ring
+
+end AbhyankarSathaye
+
+end
+
+end OAI
diff --git a/lean/OAI/AlgebraicGeometry/AbhyankarSathaye/Lifting.lean b/lean/OAI/AlgebraicGeometry/AbhyankarSathaye/Lifting.lean
new file mode 100644
index 0000000000000000000000000000000000000000..eac5ee032b036a9277b228e584d166fe5129135b
--- /dev/null
+++ b/lean/OAI/AlgebraicGeometry/AbhyankarSathaye/Lifting.lean
@@ -0,0 +1,142 @@
+import OAI.AlgebraicGeometry.AbhyankarSathaye.Quotient
+import OAI.AlgebraicGeometry.AbhyankarSathaye.Reconstruction
+import Mathlib.Algebra.Polynomial.AlgebraMap
+import Mathlib.Data.Fin.VecNotation
+import Mathlib.Tactic.FinCases
+
+namespace OAI
+
+/-!
+# Lifting a cusp relation
+
+If `x² + y³ = h * s` and `α * h + β * y = 1`, the quotient defined by
+`U³ + h * V = x`, `-U² + h * W = y`, and `S h U V W = s` is a polynomial
+algebra in one variable. This includes the zero ring and rings with zero divisors.
+-/
+
+noncomputable section
+namespace AbhyankarSathaye.Lifting
+open MvPolynomial
+
+variable {B : Type*} [CommRing B]
+
+def relX (h x : B) : MvPolynomial (Fin 3) B := X 0^3+C h*X 1-C x
+def relY (h y : B) : MvPolynomial (Fin 3) B := -X 0^2+C h*X 2-C y
+def relS (h s : B) : MvPolynomial (Fin 3) B := S (C h) (X 0) (X 1) (X 2)-C s
+def ideal (h x y s : B) : Ideal (MvPolynomial (Fin 3) B) :=
+  Ideal.span {relX h x, relY h y, relS h s}
+abbrev Q (h x y s : B) := MvPolynomial (Fin 3) B ⧸ ideal h x y s
+def qmap (h x y s : B) : MvPolynomial (Fin 3) B →ₐ[B] Q h x y s :=
+  Ideal.Quotient.mkₐ B (ideal h x y s)
+def qvar (h x y s : B) (i : Fin 3) : Q h x y s := qmap h x y s (X i)
+
+theorem quotient_relations (h x y s : B) :
+    let c := algebraMap B (Q h x y s)
+    let U := qvar h x y s 0
+    let V := qvar h x y s 1
+    let W := qvar h x y s 2
+    U^3+c h*V = c x ∧ -U^2+c h*W = c y ∧ S (c h) U V W = c s := by
+  dsimp only
+  have hx : qmap h x y s (relX h x) = 0 :=
+    quotient_triple_first (relX h x) (relY h y) (relS h s)
+  have hy : qmap h x y s (relY h y) = 0 :=
+    quotient_triple_second (relX h x) (relY h y) (relS h s)
+  have hs : qmap h x y s (relS h s) = 0 :=
+    quotient_triple_third (relX h x) (relY h y) (relS h s)
+  refine ⟨?_, ?_, ?_⟩
+  · apply sub_eq_zero.mp
+    simpa [relX, qvar] using hx
+  · apply sub_eq_zero.mp
+    simpa [relY, qvar] using hy
+  · apply sub_eq_zero.mp
+    simpa [relS, qvar] using hs
+
+def polyU (h x β : B) : Polynomial B := inverseU (Polynomial.C h) (Polynomial.C x)
+  (Polynomial.C β) Polynomial.X
+def polyG (x y α : B) : Polynomial B := inverseG (Polynomial.C x) (Polynomial.C y)
+  (Polynomial.C α) Polynomial.X
+def polyW (h x y s α β : B) : Polynomial B :=
+  inverseW (Polynomial.C h) (Polynomial.C y) (Polynomial.C s) (Polynomial.C α)
+    (Polynomial.C β) (polyU h x β) (polyG x y α)
+def polyV (h x y s α β : B) : Polynomial B :=
+  inverseV (polyU h x β) (polyG x y α) (polyW h x y s α β)
+def values (h x y s α β : B) : Fin 3 → Polynomial B :=
+  ![polyU h x β, polyV h x y s α β, polyW h x y s α β]
+
+theorem values_relations (h x y s α β : B)
+    (hc : x^2+y^3 = h*s) (hb : α*h+β*y = 1) :
+    (aeval (values h x y s α β)) (relX h x) = 0 ∧
+    (aeval (values h x y s α β)) (relY h y) = 0 ∧
+    (aeval (values h x y s α β)) (relS h s) = 0 := by
+  have hc' : (Polynomial.C x)^2+(Polynomial.C y)^3 = Polynomial.C h*Polynomial.C s := by
+    simpa using congrArg (Polynomial.C : B →+* Polynomial B) hc
+  have hb' : Polynomial.C α*Polynomial.C h+Polynomial.C β*Polynomial.C y = 1 := by
+    simpa using congrArg (Polynomial.C : B →+* Polynomial B) hb
+  have hr := inverse_relations (Polynomial.C h) (Polynomial.C x) (Polynomial.C y)
+    (Polynomial.C s) (Polynomial.C α) (Polynomial.C β) Polynomial.X hc' hb'
+  dsimp only at hr
+  refine ⟨?_, ?_, ?_⟩
+  · simpa [relX, values, polyU, polyV, polyG, polyW, Polynomial.algebraMap_eq]
+      using sub_eq_zero.mpr hr.1
+  · simpa [relY, values, polyU, polyV, polyG, polyW, Polynomial.algebraMap_eq]
+      using sub_eq_zero.mpr hr.2.1
+  · simpa [relS, values, polyU, polyV, polyG, polyW, Polynomial.algebraMap_eq]
+      using sub_eq_zero.mpr hr.2.2
+
+def forward (h x y s α β : B) (hc : x^2+y^3 = h*s) (hb : α*h+β*y = 1) :
+    Q h x y s →ₐ[B] Polynomial B :=
+  lift_triple (relX h x) (relY h y) (relS h s) (aeval (values h x y s α β))
+    (values_relations h x y s α β hc hb).1
+    (values_relations h x y s α β hc hb).2.1
+    (values_relations h x y s α β hc hb).2.2
+
+@[simp] theorem forward_qvar (h x y s α β : B) (hc hb) (i : Fin 3) :
+    forward h x y s α β hc hb (qvar h x y s i) = values h x y s α β i := by
+  change aeval (values h x y s α β) (X i) = values h x y s α β i
+  exact aeval_X _ _
+
+def backward (h x y s α β : B) : Polynomial B →ₐ[B] Q h x y s :=
+  Polynomial.aeval (parameter (algebraMap B _ α) (algebraMap B _ β)
+    (qvar h x y s 0) (qvar h x y s 1) (qvar h x y s 2))
+
+theorem forward_backward (h x y s α β : B) (hc hb) :
+    (forward h x y s α β hc hb).comp (backward h x y s α β) = AlgHom.id B _ := by
+  apply Polynomial.algHom_ext
+  have hb' : Polynomial.C α*Polynomial.C h+Polynomial.C β*Polynomial.C y = 1 := by
+    simpa using congrArg (Polynomial.C : B →+* Polynomial B) hb
+  simpa [backward, values, polyU, polyV, polyW, polyG, Polynomial.algebraMap_eq]
+    using inverse_parameter (Polynomial.C h) (Polynomial.C x) (Polynomial.C y)
+      (Polynomial.C s) (Polynomial.C α) (Polynomial.C β) Polynomial.X hb'
+
+theorem backward_forward (h x y s α β : B) (hc hb) :
+    (backward h x y s α β).comp (forward h x y s α β hc hb) = AlgHom.id B _ := by
+  apply Ideal.Quotient.algHom_ext
+  apply MvPolynomial.algHom_ext
+  intro i
+  have hb' : algebraMap B (Q h x y s) α*algebraMap B _ h+
+      algebraMap B _ β*algebraMap B _ y = 1 := by
+    simpa using congrArg (algebraMap B (Q h x y s)) hb
+  obtain ⟨hx, hy, hs⟩ := quotient_relations h x y s
+  have hr := original_reconstruction (algebraMap B (Q h x y s) h)
+    (algebraMap B _ x) (algebraMap B _ y) (algebraMap B _ s)
+    (algebraMap B _ α) (algebraMap B _ β)
+    (qvar h x y s 0) (qvar h x y s 1) (qvar h x y s 2) hb' hx hy hs
+  dsimp only at hr
+  change backward h x y s α β (forward h x y s α β hc hb (qvar h x y s i)) =
+    qvar h x y s i
+  rw [forward_qvar]
+  fin_cases i
+  · simpa [values, polyU, backward] using hr.1
+  · simpa [values, polyU, polyV, polyG, polyW, backward] using hr.2.1
+  · simpa [values, polyU, polyV, polyG, polyW, backward] using hr.2.2
+
+def equivalence (h x y s α β : B) (hc : x^2+y^3 = h*s) (hb : α*h+β*y = 1) :
+    Q h x y s ≃ₐ[B] Polynomial B :=
+  AlgEquiv.ofAlgHom (forward h x y s α β hc hb) (backward h x y s α β)
+    (forward_backward h x y s α β hc hb) (backward_forward h x y s α β hc hb)
+
+end AbhyankarSathaye.Lifting
+
+end
+
+end OAI
diff --git a/lean/OAI/AlgebraicGeometry/AbhyankarSathaye/LiftingIdentities.lean b/lean/OAI/AlgebraicGeometry/AbhyankarSathaye/LiftingIdentities.lean
new file mode 100644
index 0000000000000000000000000000000000000000..cdff2621809a2d9455b6200529b045b77dc8620b
--- /dev/null
+++ b/lean/OAI/AlgebraicGeometry/AbhyankarSathaye/LiftingIdentities.lean
@@ -0,0 +1,118 @@
+import OAI.AlgebraicGeometry.AbhyankarSathaye.Identities
+
+namespace OAI
+
+/-!
+# Linear equations for the lifting construction
+
+The substitution `G = V + U * W` makes the equations linear in `W`.
+A Bézout relation gives existence and uniqueness without cancellation.
+-/
+
+namespace AbhyankarSathaye
+section
+variable {B : Type*} [CommRing B]
+
+theorem substitute_S (h U G W : B) :
+    S h U (G-U*W) W =
+      h*G^2 - 2*U*(h*W-U^2)*G + (h*W-U^2)^2*W := by
+  unfold S
+  ring
+
+theorem compatibility_identity (h y s U G : B) :
+    y^2*(y+U^2) - h*(s-h*G^2+2*U*y*G) =
+      (h*G-y*U)^2 + y^3 - h*s := by ring
+
+theorem compatibility (h x y s U G : B)
+    (hc : x^2+y^3 = h*s) (hl : h*G-y*U = x) :
+    y^2*(y+U^2) = h*(s-h*G^2+2*U*y*G) := by
+  apply sub_eq_zero.mp
+  rw [compatibility_identity, hl, hc, sub_self]
+
+theorem squared_bezout (h y α β : B) (hb : α*h+β*y = 1) :
+    α*(1+β*y)*h + β^2*y^2 = 1 := by
+  calc
+    _ = (α*h+β*y-1)*(1+β*y)+1 := by ring
+    _ = 1 := by rw [hb]; ring
+
+theorem solve_h (h c a b r q : B) (hc : c*a = h*b) (hb : r*h+q*c = 1) :
+    h*(r*a+q*b) = a := by
+  calc
+    _ = r*h*a+q*(h*b) := by ring
+    _ = (r*h+q*c)*a := by rw [← hc]; ring
+    _ = a := by rw [hb, one_mul]
+
+theorem solve_c (h c a b r q : B) (hc : c*a = h*b) (hb : r*h+q*c = 1) :
+    c*(r*a+q*b) = b := by
+  calc
+    _ = r*(c*a)+q*c*b := by ring
+    _ = (r*h+q*c)*b := by rw [hc]; ring
+    _ = b := by rw [hb, one_mul]
+
+theorem solve_unique (h c a b r q W : B) (hb : r*h+q*c = 1)
+    (hh : h*W = a) (hy : c*W = b) : W = r*a+q*b := by
+  calc
+    W = (r*h+q*c)*W := by rw [hb, one_mul]
+    _ = r*(h*W)+q*(c*W) := by ring
+    _ = r*a+q*b := by rw [hh, hy]
+
+theorem linear_parameter_relation (h x y α β T : B) (hb : α*h+β*y = 1) :
+    h*(y*T+α*x)-y*(h*T-β*x) = x := by
+  calc
+    _ = (α*h+β*y)*x := by ring
+    _ = x := by rw [hb, one_mul]
+
+theorem linear_parameter_inverse (h x y α β T : B) (hb : α*h+β*y = 1) :
+    α*(h*T-β*x)+β*(y*T+α*x) = T := by
+  calc
+    _ = (α*h+β*y)*T := by ring
+    _ = T := by rw [hb, one_mul]
+
+theorem recover_U (h x y α β U G : B)
+    (hb : α*h+β*y = 1) (hl : h*G-y*U = x) :
+    h*(α*U+β*G)-β*x = U := by
+  calc
+    _ = (α*h+β*y)*U+β*(h*G-y*U-x) := by ring
+    _ = U := by rw [hb, hl]; ring
+
+theorem recover_G (h x y α β U G : B)
+    (hb : α*h+β*y = 1) (hl : h*G-y*U = x) :
+    y*(α*U+β*G)+α*x = G := by
+  calc
+    _ = (α*h+β*y)*G-α*(h*G-y*U-x) := by ring
+    _ = G := by rw [hb, hl]; ring
+
+theorem original_to_linear (h x y s U V W : B)
+    (hx : U^3+h*V = x) (hy : -U^2+h*W = y) (hs : S h U V W = s) :
+    h*(V+U*W)-y*U = x ∧ h*W = y+U^2 ∧
+      y^2*W = s-h*(V+U*W)^2+2*U*y*(V+U*W) := by
+  have hw : h*W-U^2 = y := by rw [← hy]; ring
+  have hS : S h U V W =
+      h*(V+U*W)^2-2*U*y*(V+U*W)+y^2*W := by
+    have hh := substitute_S h U (V+U*W) W
+    have hv : V+U*W-U*W = V := by ring
+    rw [hv, hw] at hh
+    exact hh
+  refine ⟨?_, ?_, ?_⟩
+  · calc
+      _ = U^3+h*V+U*(h*W-U^2-y) := by ring
+      _ = x := by rw [hw, hx]; ring
+  · rw [← hw]; ring
+  · rw [← hs, hS]; ring
+
+theorem linear_to_original (h x y s U G W : B)
+    (hl : h*G-y*U = x) (hw : h*W = y+U^2)
+    (hs : y^2*W = s-h*G^2+2*U*y*G) :
+    U^3+h*(G-U*W) = x ∧ -U^2+h*W = y ∧ S h U (G-U*W) W = s := by
+  have hh : h*W-U^2 = y := by rw [hw]; ring
+  refine ⟨?_, ?_, ?_⟩
+  · calc
+      _ = h*G-y*U-U*(h*W-U^2-y) := by ring
+      _ = x := by rw [hl, hh]; ring
+  · rw [hw]; ring
+  · rw [substitute_S, hh, hs]; ring
+
+end
+end AbhyankarSathaye
+
+end OAI
diff --git a/lean/OAI/AlgebraicGeometry/AbhyankarSathaye/LinearElimination.lean b/lean/OAI/AlgebraicGeometry/AbhyankarSathaye/LinearElimination.lean
new file mode 100644
index 0000000000000000000000000000000000000000..ea68104e99f960f271a4046286b28eb1de7b4a4b
--- /dev/null
+++ b/lean/OAI/AlgebraicGeometry/AbhyankarSathaye/LinearElimination.lean
@@ -0,0 +1,64 @@
+import OAI.AlgebraicGeometry.AbhyankarSathaye.LiftingIdentities
+import Mathlib.RingTheory.Polynomial.Quotient
+
+namespace OAI
+
+/-!
+# Elimination of compatible linear equations
+
+A Bézout relation identifies the ideal of two compatible linear equations
+with a single evaluation relation, over any commutative ring.
+-/
+
+noncomputable section
+namespace AbhyankarSathaye
+
+theorem linear_ideal {B : Type*} [CommRing B] (h c a b r q W : B)
+    (hc : c*a = h*b) (hb : r*h+q*c = 1) :
+    Ideal.span ({h*W-a, c*W-b} : Set B) = Ideal.span {W-(r*a+q*b)} := by
+  have hh := solve_h h c a b r q hc hb
+  have hy := solve_c h c a b r q hc hb
+  apply le_antisymm
+  · apply Ideal.span_le.mpr
+    intro z hz
+    simp only [Set.mem_insert_iff, Set.mem_singleton_iff] at hz
+    rcases hz with rfl | rfl
+    · have he : h*W-a = h*(W-(r*a+q*b)) := by rw [mul_sub, hh]
+      rw [he]
+      exact Ideal.mul_mem_left _ _ (Ideal.subset_span (by simp))
+    · have he : c*W-b = c*(W-(r*a+q*b)) := by rw [mul_sub, hy]
+      rw [he]
+      exact Ideal.mul_mem_left _ _ (Ideal.subset_span (by simp))
+  · apply Ideal.span_le.mpr
+    intro z hz
+    simp only [Set.mem_singleton_iff] at hz
+    subst z
+    have he : W-(r*a+q*b) = r*(h*W-a)+q*(c*W-b) := by
+      calc
+        _ = (r*h+q*c)*W-(r*a+q*b) := by rw [hb, one_mul]
+        _ = _ := by ring
+    rw [he]
+    exact Ideal.add_mem _
+      (Ideal.mul_mem_left _ _ (Ideal.subset_span (by simp)))
+      (Ideal.mul_mem_left _ _ (Ideal.subset_span (by simp)))
+
+def linear_equations_quotient_equiv {B : Type*} [CommRing B]
+    (h c a b r q : B) (hc : c*a = h*b) (hb : r*h+q*c = 1) :
+    (Polynomial B ⧸ Ideal.span
+      {Polynomial.C h*Polynomial.X-Polynomial.C a,
+       Polynomial.C c*Polynomial.X-Polynomial.C b}) ≃ₐ[B] B := by
+  have hc' : Polynomial.C c*Polynomial.C a = Polynomial.C h*Polynomial.C b := by
+    simpa using congrArg (Polynomial.C : B →+* Polynomial B) hc
+  have hb' : Polynomial.C r*Polynomial.C h+Polynomial.C q*Polynomial.C c = 1 := by
+    simpa using congrArg (Polynomial.C : B →+* Polynomial B) hb
+  have hi := linear_ideal (Polynomial.C h) (Polynomial.C c) (Polynomial.C a)
+    (Polynomial.C b) (Polynomial.C r) (Polynomial.C q) Polynomial.X hc' hb'
+  simp only [← map_mul, ← map_add] at hi
+  exact (Ideal.quotientEquivAlgOfEq B hi).trans
+    (Polynomial.quotientSpanXSubCAlgEquiv (r*a+q*b))
+
+end AbhyankarSathaye
+
+end
+
+end OAI
diff --git a/lean/OAI/AlgebraicGeometry/AbhyankarSathaye/LinearPresentation.lean b/lean/OAI/AlgebraicGeometry/AbhyankarSathaye/LinearPresentation.lean
new file mode 100644
index 0000000000000000000000000000000000000000..6d39a114741116efb48124fad61305eaf52d6ca4
--- /dev/null
+++ b/lean/OAI/AlgebraicGeometry/AbhyankarSathaye/LinearPresentation.lean
@@ -0,0 +1,130 @@
+import OAI.AlgebraicGeometry.AbhyankarSathaye.Lifting
+import OAI.AlgebraicGeometry.AbhyankarSathaye.LinearElimination
+
+namespace OAI
+
+/-!
+# The intermediate linear presentation
+
+The relation `h * G - y * U = x` has parameter `α * U + β * G`.
+The remaining compatible equations generate the principal ideal `(W - W₀)`.
+-/
+
+noncomputable section
+namespace AbhyankarSathaye.LinearPresentation
+open MvPolynomial
+
+variable {B : Type*} [CommRing B]
+
+def relation (h x y : B) : MvPolynomial (Fin 2) B := C h*X 1-C y*X 0-C x
+def ideal (h x y : B) : Ideal (MvPolynomial (Fin 2) B) := Ideal.span {relation h x y}
+abbrev A (h x y : B) := MvPolynomial (Fin 2) B ⧸ ideal h x y
+def qmap (h x y : B) : MvPolynomial (Fin 2) B →ₐ[B] A h x y :=
+  Ideal.Quotient.mkₐ B (ideal h x y)
+def qvar (h x y : B) (i : Fin 2) : A h x y := qmap h x y (X i)
+def coeff (h x y : B) : B →+* A h x y := algebraMap B _
+
+theorem linear_relation (h x y : B) :
+    coeff h x y h*qvar h x y 1-coeff h x y y*qvar h x y 0 = coeff h x y x := by
+  have hz : qmap h x y (relation h x y) = 0 :=
+    Ideal.Quotient.eq_zero_iff_mem.mpr (Ideal.subset_span (by simp))
+  apply sub_eq_zero.mp
+  simpa [relation, qvar, coeff] using hz
+
+def values (h x y α β : B) : Fin 2 → Polynomial B :=
+  ![Lifting.polyU h x β, Lifting.polyG x y α]
+
+def forward (h x y α β : B) (hb : α*h+β*y = 1) : A h x y →ₐ[B] Polynomial B := by
+  let ev : MvPolynomial (Fin 2) B →ₐ[B] Polynomial B := aeval (values h x y α β)
+  have hb' : Polynomial.C α*Polynomial.C h+Polynomial.C β*Polynomial.C y = 1 := by
+    simpa using congrArg (Polynomial.C : B →+* Polynomial B) hb
+  have he : ev (relation h x y) = 0 := by
+    simpa [ev, values, relation, Lifting.polyU, Lifting.polyG,
+      Polynomial.algebraMap_eq, inverseU, inverseG] using
+      sub_eq_zero.mpr (linear_parameter_relation (Polynomial.C h) (Polynomial.C x)
+        (Polynomial.C y) (Polynomial.C α) (Polynomial.C β) Polynomial.X hb')
+  have hi : ideal h x y ≤ RingHom.ker ev := by
+    apply Ideal.span_le.mpr
+    intro z hz
+    simp only [Set.mem_singleton_iff] at hz
+    subst z
+    exact he
+  exact Ideal.Quotient.liftₐ _ ev (fun z hz => hi hz)
+
+@[simp] theorem forward_qvar (h x y α β : B) (hb) (i : Fin 2) :
+    forward h x y α β hb (qvar h x y i) = values h x y α β i := by
+  change (aeval (values h x y α β) : MvPolynomial (Fin 2) B →ₐ[B] Polynomial B) (X i) = _
+  exact aeval_X _ _
+
+def backward (h x y α β : B) : Polynomial B →ₐ[B] A h x y :=
+  Polynomial.aeval (coeff h x y α*qvar h x y 0+coeff h x y β*qvar h x y 1)
+
+theorem forward_backward (h x y α β : B) (hb) :
+    (forward h x y α β hb).comp (backward h x y α β) = AlgHom.id B _ := by
+  apply Polynomial.algHom_ext
+  have hb' : Polynomial.C α*Polynomial.C h+Polynomial.C β*Polynomial.C y = 1 := by
+    simpa using congrArg (Polynomial.C : B →+* Polynomial B) hb
+  simpa [backward, coeff, values, Lifting.polyU, Lifting.polyG, inverseU, inverseG,
+    Polynomial.algebraMap_eq] using
+    linear_parameter_inverse (Polynomial.C h) (Polynomial.C x) (Polynomial.C y)
+      (Polynomial.C α) (Polynomial.C β) Polynomial.X hb'
+
+theorem backward_forward (h x y α β : B) (hb) :
+    (backward h x y α β).comp (forward h x y α β hb) = AlgHom.id B _ := by
+  apply Ideal.Quotient.algHom_ext
+  apply MvPolynomial.algHom_ext
+  intro i
+  have hb' : coeff h x y α*coeff h x y h+coeff h x y β*coeff h x y y = 1 := by
+    simpa using congrArg (coeff h x y) hb
+  change backward h x y α β (forward h x y α β hb (qvar h x y i)) = qvar h x y i
+  rw [forward_qvar]
+  fin_cases i
+  · simpa [backward, values, Lifting.polyU, inverseU, coeff] using
+      recover_U (coeff h x y h) (coeff h x y x) (coeff h x y y)
+        (coeff h x y α) (coeff h x y β) (qvar h x y 0) (qvar h x y 1)
+        hb' (linear_relation h x y)
+  · simpa [backward, values, Lifting.polyG, inverseG, coeff] using
+      recover_G (coeff h x y h) (coeff h x y x) (coeff h x y y)
+        (coeff h x y α) (coeff h x y β) (qvar h x y 0) (qvar h x y 1)
+        hb' (linear_relation h x y)
+
+def equivalence (h x y α β : B) (hb : α*h+β*y = 1) : A h x y ≃ₐ[B] Polynomial B :=
+  AlgEquiv.ofAlgHom (forward h x y α β hb) (backward h x y α β)
+    (forward_backward h x y α β hb) (backward_forward h x y α β hb)
+
+def a (h x y : B) : A h x y := coeff h x y y+(qvar h x y 0)^2
+def b (h x y s : B) : A h x y := coeff h x y s-coeff h x y h*(qvar h x y 1)^2+
+  2*qvar h x y 0*coeff h x y y*qvar h x y 1
+def r (h x y α β : B) : A h x y := coeff h x y α*(1+coeff h x y β*coeff h x y y)
+def q (h x y β : B) : A h x y := (coeff h x y β)^2
+def W0 (h x y s α β : B) : A h x y := r h x y α β*a h x y+q h x y β*b h x y s
+
+theorem compatible (h x y s : B) (hc : x^2+y^3 = h*s) :
+    (coeff h x y y)^2*a h x y = coeff h x y h*b h x y s := by
+  have hc' : (coeff h x y x)^2+(coeff h x y y)^3 = coeff h x y h*coeff h x y s := by
+    simpa using congrArg (coeff h x y) hc
+  exact compatibility _ _ _ _ _ _ hc' (linear_relation h x y)
+
+theorem bezout_squared (h x y α β : B) (hb : α*h+β*y = 1) :
+    r h x y α β*coeff h x y h+q h x y β*(coeff h x y y)^2 = 1 := by
+  have hb' : coeff h x y α*coeff h x y h+coeff h x y β*coeff h x y y = 1 := by
+    simpa using congrArg (coeff h x y) hb
+  exact squared_bezout _ _ _ _ hb'
+
+theorem W_ideal (h x y s α β : B) (hc : x^2+y^3 = h*s) (hb : α*h+β*y = 1) :
+    Ideal.span ({Polynomial.C (coeff h x y h)*Polynomial.X-Polynomial.C (a h x y),
+      Polynomial.C ((coeff h x y y)^2)*Polynomial.X-Polynomial.C (b h x y s)} :
+      Set (Polynomial (A h x y))) = Ideal.span {Polynomial.X-Polynomial.C (W0 h x y s α β)} := by
+  have hc' := congrArg (Polynomial.C : A h x y →+* Polynomial (A h x y)) (compatible h x y s hc)
+  have hb' := congrArg (Polynomial.C : A h x y →+* Polynomial (A h x y)) (bezout_squared h x y α β hb)
+  simp only [map_mul, map_add, map_one] at hc' hb'
+  simpa only [W0, map_add, map_mul] using
+    linear_ideal (Polynomial.C (coeff h x y h)) (Polynomial.C ((coeff h x y y)^2))
+      (Polynomial.C (a h x y)) (Polynomial.C (b h x y s))
+      (Polynomial.C (r h x y α β)) (Polynomial.C (q h x y β)) Polynomial.X hc' hb'
+
+end AbhyankarSathaye.LinearPresentation
+
+end
+
+end OAI
diff --git a/lean/OAI/AlgebraicGeometry/AbhyankarSathaye/NonCoordinate.lean b/lean/OAI/AlgebraicGeometry/AbhyankarSathaye/NonCoordinate.lean
new file mode 100644
index 0000000000000000000000000000000000000000..ab265001616b26061befcd1a1c3c75b9d71c7bd4
--- /dev/null
+++ b/lean/OAI/AlgebraicGeometry/AbhyankarSathaye/NonCoordinate.lean
@@ -0,0 +1,55 @@
+import OAI.AlgebraicGeometry.AbhyankarSathaye.CriticalPoint
+
+namespace OAI
+
+/-!
+# Critical points obstruct polynomial coordinates
+
+The polynomial chain rule shows that a coordinate polynomial over a nontrivial
+commutative ring cannot have a point where every partial derivative vanishes.
+-/
+
+noncomputable section
+namespace AbhyankarSathaye
+open MvPolynomial
+
+theorem polynomial_chain_rule {σ τ B : Type*} [Fintype σ] [CommRing B]
+    (φ : MvPolynomial σ B →ₐ[B] MvPolynomial τ B)
+    (f : MvPolynomial σ B) (j : τ) :
+    pderiv j (φ f) = ∑ i, φ (pderiv i f) * pderiv j (φ (X i)) := by
+  classical
+  induction f using MvPolynomial.induction_on with
+  | C a => simp [algHom_C]
+  | add f g hf hg =>
+      simp only [map_add, hf, hg, add_mul, Finset.sum_add_distrib]
+  | mul_X f a hf =>
+      have hite (p : Prop) [Decidable p] (A D : MvPolynomial τ B) :
+          (if p then A+D else A) = A+(if p then D else 0) := by
+        split_ifs <;> simp
+      simp only [map_mul, pderiv_mul, map_add, hf]
+      simp [pderiv_X, Pi.single_apply, apply_ite, add_mul,
+        Finset.mul_sum, mul_comm, mul_assoc]
+      simp only [hite, Finset.sum_add_distrib]
+      simp
+
+theorem no_coordinate_of_critical {σ B : Type*} [Fintype σ] [CommRing B]
+    [Nontrivial B] (f : MvPolynomial σ B) (point : σ → B)
+    (hc : ∀ i, eval point (pderiv i f) = 0) :
+    ¬ ∃ (e : MvPolynomial σ B ≃ₐ[B] MvPolynomial σ B) (i : σ), e (X i) = f := by
+  rintro ⟨e, i, he⟩
+  have hchain := polynomial_chain_rule e.symm.toAlgHom f i
+  change pderiv i (e.symm f) =
+    ∑ j, e.symm (pderiv j f) * pderiv i (e.symm (X j)) at hchain
+  have hinv : e.symm f = X i := by rw [← he, e.symm_apply_apply]
+  rw [hinv, pderiv_X_self] at hchain
+  have hz := congrArg (fun q => eval point (e q)) hchain
+  simp [map_sum, hc] at hz
+
+theorem F_not_coordinate : ¬ ∃ (e : R ≃ₐ[ℂ] R) (i : Fin 4), e (X i) = F :=
+  no_coordinate_of_critical F criticalPoint critical_derivatives
+
+end AbhyankarSathaye
+
+end
+
+end OAI
diff --git a/lean/OAI/AlgebraicGeometry/AbhyankarSathaye/Plane.lean b/lean/OAI/AlgebraicGeometry/AbhyankarSathaye/Plane.lean
new file mode 100644
index 0000000000000000000000000000000000000000..859dc5579ad2bf066de6ce71064e2d369fc88ab7
--- /dev/null
+++ b/lean/OAI/AlgebraicGeometry/AbhyankarSathaye/Plane.lean
@@ -0,0 +1,121 @@
+import OAI.AlgebraicGeometry.AbhyankarSathaye.Quotient
+import Mathlib.Data.Fin.VecNotation
+import Mathlib.Tactic.FinCases
+
+namespace OAI
+
+/-!
+# A polynomial presentation of the affine plane
+
+The relations `h = 1 + P x y s` and `x² + y³ = h * s` give a polynomial
+algebra with coordinates `x + s³` and `y - s²`. The auxiliary variables are
+ordered as `h, x, y, s`.
+-/
+
+noncomputable section
+namespace AbhyankarSathaye.Plane
+open MvPolynomial
+
+variable (K : Type*) [CommRing K]
+
+def relH : MvPolynomial (Fin 4) K := X 0-1-P (X 1) (X 2) (X 3)
+def relCusp : MvPolynomial (Fin 4) K := X 1^2+X 2^3-X 3*X 0
+def ideal : Ideal (MvPolynomial (Fin 4) K) := Ideal.span {relH K, relCusp K}
+abbrev Q := MvPolynomial (Fin 4) K ⧸ ideal K
+def qmap : MvPolynomial (Fin 4) K →ₐ[K] Q K := Ideal.Quotient.mkₐ K (ideal K)
+def qvar (i : Fin 4) : Q K := qmap K (X i)
+
+theorem relation_h : qvar K 0 = 1+P (qvar K 1) (qvar K 2) (qvar K 3) := by
+  have hz : qmap K (relH K) = 0 := quotient_pair_left (relH K) (relCusp K)
+  have hh : qvar K 0-1-P (qvar K 1) (qvar K 2) (qvar K 3) = 0 := by
+    simpa [relH, qvar] using hz
+  calc
+    _ = (qvar K 0-1-P (qvar K 1) (qvar K 2) (qvar K 3))+
+        (1+P (qvar K 1) (qvar K 2) (qvar K 3)) := by ring
+    _ = _ := by rw [hh, zero_add]
+
+theorem relation_cusp : (qvar K 1)^2+(qvar K 2)^3 = qvar K 0*qvar K 3 := by
+  have hz : qmap K (relCusp K) = 0 := quotient_pair_right (relH K) (relCusp K)
+  have hh : (qvar K 1)^2+(qvar K 2)^3-qvar K 3*qvar K 0 = 0 := by
+    simpa [relCusp, qvar] using hz
+  simpa [mul_comm] using sub_eq_zero.mp hh
+
+theorem shift_s : (qvar K 1+(qvar K 3)^3)^2+(qvar K 2-(qvar K 3)^2)^3 = qvar K 3 := by
+  rw [shift_universal, relation_cusp, relation_h]
+  ring
+
+theorem bezout : Alpha (qvar K 1) (qvar K 3)*qvar K 0+
+    Beta (qvar K 1) (qvar K 2) (qvar K 3)*qvar K 2 = 1 := by
+  have he := bezout_certificate (qvar K 0) (qvar K 1) (qvar K 2) (qvar K 3)
+  have hh : qvar K 0-1-P (qvar K 1) (qvar K 2) (qvar K 3) = 0 := by
+    rw [relation_h]; ring
+  have hc : (qvar K 1)^2+(qvar K 2)^3-qvar K 3*qvar K 0 = 0 := by
+    rw [relation_cusp]; ring
+  rw [hh, hc, mul_zero, mul_zero, sub_zero] at he
+  exact sub_eq_zero.mp he
+
+def planeS : MvPolynomial (Fin 2) K := X 0^2+X 1^3
+def planeX : MvPolynomial (Fin 2) K := X 0-(planeS K)^3
+def planeY : MvPolynomial (Fin 2) K := X 1+(planeS K)^2
+def planeH : MvPolynomial (Fin 2) K := 1+P (planeX K) (planeY K) (planeS K)
+def values : Fin 4 → MvPolynomial (Fin 2) K :=
+  ![planeH K, planeX K, planeY K, planeS K]
+
+theorem plane_cusp : (planeX K)^2+(planeY K)^3 = planeH K*planeS K := by
+  have he := shift_universal (planeX K) (planeY K) (planeS K)
+  have hx : planeX K+(planeS K)^3 = X 0 := by unfold planeX; ring
+  have hy : planeY K-(planeS K)^2 = X 1 := by unfold planeY; ring
+  rw [hx, hy] at he
+  change planeS K = (planeX K)^2+(planeY K)^3-planeS K*P (planeX K) (planeY K) (planeS K) at he
+  calc
+    _ = (planeS K)+planeS K*P (planeX K) (planeY K) (planeS K) := by
+      exact (eq_sub_iff_add_eq.mp he).symm
+    _ = _ := by unfold planeH; ring
+
+def forward : Q K →ₐ[K] MvPolynomial (Fin 2) K :=
+  lift_pair (relH K) (relCusp K) (aeval (values K))
+    (by simp [relH, values, planeH])
+    (by simp [relCusp, values, plane_cusp, mul_comm])
+
+@[simp] theorem forward_qvar (i : Fin 4) : forward K (qvar K i) = values K i := by
+  change aeval (values K) (X i) = values K i
+  exact aeval_X _ _
+
+def backward : MvPolynomial (Fin 2) K →ₐ[K] Q K :=
+  aeval ![qvar K 1+(qvar K 3)^3, qvar K 2-(qvar K 3)^2]
+
+@[simp] theorem backward_planeS : backward K (planeS K) = qvar K 3 := by
+  simpa [backward, planeS] using shift_s K
+
+@[simp] theorem backward_planeX : backward K (planeX K) = qvar K 1 := by
+  simp only [planeX, map_sub, map_pow, backward_planeS]
+  simp [backward]
+
+@[simp] theorem backward_planeY : backward K (planeY K) = qvar K 2 := by
+  simp only [planeY, map_add, map_pow, backward_planeS]
+  simp [backward]
+
+@[simp] theorem backward_planeH : backward K (planeH K) = qvar K 0 := by
+  simpa [planeH] using (relation_h K).symm
+
+theorem forward_backward : (forward K).comp (backward K) = AlgHom.id K _ := by
+  apply MvPolynomial.algHom_ext
+  intro i
+  fin_cases i <;> simp [backward, values, planeX, planeY]
+
+theorem backward_forward : (backward K).comp (forward K) = AlgHom.id K _ := by
+  apply Ideal.Quotient.algHom_ext
+  apply MvPolynomial.algHom_ext
+  intro i
+  change backward K (forward K (qvar K i)) = qvar K i
+  rw [forward_qvar]
+  fin_cases i <;> simp [values]
+
+def equivalence : Q K ≃ₐ[K] MvPolynomial (Fin 2) K :=
+  AlgEquiv.ofAlgHom (forward K) (backward K) (forward_backward K) (backward_forward K)
+
+end AbhyankarSathaye.Plane
+
+end
+
+end OAI
diff --git a/lean/OAI/AlgebraicGeometry/AbhyankarSathaye/Presentation.lean b/lean/OAI/AlgebraicGeometry/AbhyankarSathaye/Presentation.lean
new file mode 100644
index 0000000000000000000000000000000000000000..2a2a8cdd21a2f26bde63d5ca085033df4b8e53e7
--- /dev/null
+++ b/lean/OAI/AlgebraicGeometry/AbhyankarSathaye/Presentation.lean
@@ -0,0 +1,149 @@
+import OAI.AlgebraicGeometry.AbhyankarSathaye.Lifting
+import OAI.AlgebraicGeometry.AbhyankarSathaye.Plane
+import Mathlib.Algebra.Algebra.Tower
+
+namespace OAI
+
+/-!
+# Elimination of auxiliary variables
+
+Explicit mutually inverse complex algebra maps identify the lifting presentation
+with the quotient of the original polynomial ring by `(F)`.
+-/
+
+noncomputable section
+namespace AbhyankarSathaye.Presentation
+open MvPolynomial
+
+abbrev B := Plane.Q ℂ
+abbrev hB : B := Plane.qvar ℂ 0
+abbrev xB : B := Plane.qvar ℂ 1
+abbrev yB : B := Plane.qvar ℂ 2
+abbrev sB : B := Plane.qvar ℂ 3
+abbrev L := Lifting.Q hB xB yB sB
+abbrev D := R ⧸ Ideal.span {F}
+
+def dmap : R →ₐ[ℂ] D := Ideal.Quotient.mkₐ ℂ (Ideal.span {F})
+def lcoef : B →ₐ[ℂ] L := IsScalarTower.toAlgHom ℂ B L
+def lvar (i : Fin 3) : L := Lifting.qvar hB xB yB sB i
+
+theorem dmap_F : dmap F = 0 :=
+  Ideal.Quotient.eq_zero_iff_mem.mpr (Ideal.subset_span (by simp))
+
+def auxValues : Fin 4 → D := ![dmap h, dmap x, dmap y, dmap s]
+def auxEval : MvPolynomial (Fin 4) ℂ →ₐ[ℂ] D := aeval auxValues
+
+theorem auxEval_h : auxEval (Plane.relH ℂ) = 0 := by
+  calc
+    _ = dmap (h-1-p) := by simp [Plane.relH, auxEval, auxValues, p]
+    _ = dmap F := by congr 1; unfold F; ring
+    _ = 0 := dmap_F
+
+theorem auxEval_cusp : auxEval (Plane.relCusp ℂ) = 0 := by
+  calc
+    _ = dmap (x^2+y^3-s*h) := by simp [Plane.relCusp, auxEval, auxValues]
+    _ = 0 := by rw [cusp]; simp [mul_comm]
+
+def auxToD : B →ₐ[ℂ] D :=
+  lift_pair (Plane.relH ℂ) (Plane.relCusp ℂ) auxEval auxEval_h auxEval_cusp
+
+@[simp] theorem auxToD_qvar (i : Fin 4) : auxToD (Plane.qvar ℂ i) = auxValues i := by
+  change aeval auxValues (X i) = auxValues i
+  exact aeval_X _ _
+
+def liftValues : Fin 3 → D := ![dmap u, dmap v, dmap w]
+def liftEval : MvPolynomial (Fin 3) B →ₐ[ℂ] D := aevalTower auxToD liftValues
+
+theorem liftEval_x : liftEval (Lifting.relX hB xB) = 0 := by
+  simp [liftEval, Lifting.relX, liftValues, auxValues, x]
+
+theorem liftEval_y : liftEval (Lifting.relY hB yB) = 0 := by
+  simp [liftEval, Lifting.relY, liftValues, auxValues, y]
+
+theorem liftEval_s : liftEval (Lifting.relS hB sB) = 0 := by
+  simp [liftEval, Lifting.relS, liftValues, auxValues, s]
+
+def toOriginal : L →ₐ[ℂ] D :=
+  lift_triple (Lifting.relX hB xB) (Lifting.relY hB yB) (Lifting.relS hB sB)
+    liftEval liftEval_x liftEval_y liftEval_s
+
+@[simp] theorem toOriginal_lvar (i : Fin 3) : toOriginal (lvar i) = liftValues i := by
+  change aevalTower auxToD liftValues (X i) = liftValues i
+  exact aevalTower_X _ _ _
+
+@[simp] theorem toOriginal_lcoef (b : B) : toOriginal (lcoef b) = auxToD b := by
+  change aevalTower auxToD liftValues (C b) = auxToD b
+  simp
+
+def originalValues : Fin 4 → L := ![lcoef hB, lvar 0, lvar 1, lvar 2]
+def originalEval : R →ₐ[ℂ] L := aeval originalValues
+
+@[simp] theorem originalEval_h : originalEval h = lcoef hB := by
+  simp [originalEval, originalValues, h]
+@[simp] theorem originalEval_u : originalEval u = lvar 0 := by
+  simp [originalEval, originalValues, u]
+@[simp] theorem originalEval_v : originalEval v = lvar 1 := by
+  simp [originalEval, originalValues, v]
+@[simp] theorem originalEval_w : originalEval w = lvar 2 := by
+  simp [originalEval, originalValues, w]
+
+@[simp] theorem originalEval_x : originalEval x = lcoef xB := by
+  simpa [x, lcoef, lvar] using (Lifting.quotient_relations hB xB yB sB).1
+@[simp] theorem originalEval_y : originalEval y = lcoef yB := by
+  simpa [y, lcoef, lvar] using (Lifting.quotient_relations hB xB yB sB).2.1
+@[simp] theorem originalEval_s : originalEval s = lcoef sB := by
+  simpa [s, lcoef, lvar] using (Lifting.quotient_relations hB xB yB sB).2.2
+
+theorem originalEval_F : originalEval F = 0 := by
+  have hh : hB = 1+P xB yB sB := Plane.relation_h ℂ
+  have he : hB-P xB yB sB-1 = 0 := by rw [hh]; ring
+  simpa [F, p] using congrArg lcoef he
+
+def fromOriginal : D →ₐ[ℂ] L := by
+  have hi : Ideal.span {F} ≤ RingHom.ker originalEval := by
+    apply Ideal.span_le.mpr
+    intro z hz
+    simp only [Set.mem_singleton_iff] at hz
+    subst z
+    exact originalEval_F
+  exact Ideal.Quotient.liftₐ _ originalEval (fun z hz => hi hz)
+
+@[simp] theorem fromOriginal_dmap (f : R) : fromOriginal (dmap f) = originalEval f := rfl
+
+theorem to_from : toOriginal.comp fromOriginal = AlgHom.id ℂ D := by
+  apply Ideal.Quotient.algHom_ext
+  apply MvPolynomial.algHom_ext
+  intro i
+  change toOriginal (fromOriginal (dmap (X i))) = dmap (X i)
+  rw [fromOriginal_dmap]
+  fin_cases i <;> simp [originalEval, originalValues, auxValues, liftValues, h, u, v, w]
+
+theorem from_auxToD : fromOriginal.comp auxToD = lcoef := by
+  apply Ideal.Quotient.algHom_ext
+  apply MvPolynomial.algHom_ext
+  intro i
+  change fromOriginal (auxToD (Plane.qvar ℂ i)) = lcoef (Plane.qvar ℂ i)
+  rw [auxToD_qvar]
+  fin_cases i <;> simp [auxValues]
+
+theorem from_to : fromOriginal.comp toOriginal = AlgHom.id ℂ L := by
+  apply Ideal.Quotient.algHom_ext
+  apply MvPolynomial.algHom_ext'
+  · apply AlgHom.ext
+    intro b
+    change fromOriginal (toOriginal (lcoef b)) = lcoef b
+    rw [toOriginal_lcoef]
+    exact AlgHom.congr_fun from_auxToD b
+  · intro i
+    change fromOriginal (toOriginal (lvar i)) = lvar i
+    rw [toOriginal_lvar]
+    fin_cases i <;> simp [liftValues]
+
+def eliminationEquiv : L ≃ₐ[ℂ] D :=
+  AlgEquiv.ofAlgHom toOriginal fromOriginal to_from from_to
+
+end AbhyankarSathaye.Presentation
+
+end
+
+end OAI
diff --git a/lean/OAI/AlgebraicGeometry/AbhyankarSathaye/Quotient.lean b/lean/OAI/AlgebraicGeometry/AbhyankarSathaye/Quotient.lean
new file mode 100644
index 0000000000000000000000000000000000000000..c55cbef5efd92594bc12ac0396d8ecfa69a550f0
--- /dev/null
+++ b/lean/OAI/AlgebraicGeometry/AbhyankarSathaye/Quotient.lean
@@ -0,0 +1,91 @@
+import OAI.AlgebraicGeometry.AbhyankarSathaye.Identities
+import Mathlib.RingTheory.Ideal.Quotient.Operations
+
+namespace OAI
+
+/-!
+# Polynomial maps and finitely presented quotients
+
+Ring homomorphisms preserve the defining polynomial expressions. Algebra maps
+annihilating two or three relations descend to the corresponding quotient.
+-/
+
+noncomputable section
+namespace AbhyankarSathaye
+
+section Maps
+variable {B D H : Type*} [CommRing B] [CommRing D]
+variable [FunLike H B D] [RingHomClass H B D]
+
+@[simp] theorem map_S (f : H) (h u v w : B) :
+    f (S h u v w) = S (f h) (f u) (f v) (f w) := by simp [S, map_ofNat]
+
+@[simp] theorem map_P (f : H) (x y s : B) :
+    f (P x y s) = P (f x) (f y) (f s) := by simp [P, map_ofNat]
+
+@[simp] theorem map_Alpha (f : H) (x s : B) :
+    f (Alpha x s) = Alpha (f x) (f s) := by simp [Alpha, map_ofNat]
+
+@[simp] theorem map_Beta (f : H) (x y s : B) :
+    f (Beta x y s) = Beta (f x) (f y) (f s) := by simp [Beta, map_ofNat]
+
+end Maps
+
+section Presentations
+variable {B A D : Type*} [CommRing B] [CommRing A] [CommRing D]
+variable [Algebra B A] [Algebra B D]
+
+def lift_pair (a b : A) (f : A →ₐ[B] D) (ha : f a = 0) (hb : f b = 0) :
+    (A ⧸ Ideal.span {a,b}) →ₐ[B] D := by
+  have hi : Ideal.span {a,b} ≤ RingHom.ker f := by
+    apply Ideal.span_le.mpr
+    intro z hz
+    simp only [Set.mem_insert_iff, Set.mem_singleton_iff] at hz
+    rcases hz with rfl | rfl
+    · exact ha
+    · exact hb
+  exact Ideal.Quotient.liftₐ _ f (fun z hz => hi hz)
+
+@[simp] theorem lift_pair_mk (a b : A) (f : A →ₐ[B] D) (ha hb) (z : A) :
+    lift_pair a b f ha hb (Ideal.Quotient.mk _ z) = f z := rfl
+
+def lift_triple (a b c : A) (f : A →ₐ[B] D)
+    (ha : f a = 0) (hb : f b = 0) (hc : f c = 0) :
+    (A ⧸ Ideal.span {a,b,c}) →ₐ[B] D := by
+  have hi : Ideal.span {a,b,c} ≤ RingHom.ker f := by
+    apply Ideal.span_le.mpr
+    intro z hz
+    simp only [Set.mem_insert_iff, Set.mem_singleton_iff] at hz
+    rcases hz with rfl | rfl | rfl
+    · exact ha
+    · exact hb
+    · exact hc
+  exact Ideal.Quotient.liftₐ _ f (fun z hz => hi hz)
+
+@[simp] theorem lift_triple_mk (a b c : A) (f : A →ₐ[B] D) (ha hb hc) (z : A) :
+    lift_triple a b c f ha hb hc (Ideal.Quotient.mk _ z) = f z := rfl
+
+theorem quotient_pair_left (a b : A) : Ideal.Quotient.mk (Ideal.span {a,b}) a = 0 :=
+  Ideal.Quotient.eq_zero_iff_mem.mpr (Ideal.subset_span (by simp))
+
+theorem quotient_pair_right (a b : A) : Ideal.Quotient.mk (Ideal.span {a,b}) b = 0 :=
+  Ideal.Quotient.eq_zero_iff_mem.mpr (Ideal.subset_span (by simp))
+
+theorem quotient_triple_first (a b c : A) :
+    Ideal.Quotient.mk (Ideal.span {a,b,c}) a = 0 :=
+  Ideal.Quotient.eq_zero_iff_mem.mpr (Ideal.subset_span (by simp))
+
+theorem quotient_triple_second (a b c : A) :
+    Ideal.Quotient.mk (Ideal.span {a,b,c}) b = 0 :=
+  Ideal.Quotient.eq_zero_iff_mem.mpr (Ideal.subset_span (by simp))
+
+theorem quotient_triple_third (a b c : A) :
+    Ideal.Quotient.mk (Ideal.span {a,b,c}) c = 0 :=
+  Ideal.Quotient.eq_zero_iff_mem.mpr (Ideal.subset_span (by simp))
+
+end Presentations
+end AbhyankarSathaye
+
+end
+
+end OAI
diff --git a/lean/OAI/AlgebraicGeometry/AbhyankarSathaye/Reconstruction.lean b/lean/OAI/AlgebraicGeometry/AbhyankarSathaye/Reconstruction.lean
new file mode 100644
index 0000000000000000000000000000000000000000..a2f8b144a2bfc89aa7a322a14be5998e4f36acb5
--- /dev/null
+++ b/lean/OAI/AlgebraicGeometry/AbhyankarSathaye/Reconstruction.lean
@@ -0,0 +1,97 @@
+import OAI.AlgebraicGeometry.AbhyankarSathaye.LiftingIdentities
+
+namespace OAI
+
+/-!
+# Mutually inverse polynomial formulas
+
+The parameter `T = α * U + β * (V + U * W)` and the formulas `inverseU`,
+`inverseV`, and `inverseW` reconstruct each other over arbitrary commutative rings.
+-/
+
+namespace AbhyankarSathaye
+section
+variable {B : Type*} [CommRing B]
+
+def inverseU (h x β T : B) : B := h*T-β*x
+def inverseG (x y α T : B) : B := y*T+α*x
+def inverseW (h y s α β U G : B) : B :=
+  α*(1+β*y)*(y+U^2)+β^2*(s-h*G^2+2*U*y*G)
+def inverseV (U G W : B) : B := G-U*W
+def parameter (α β U V W : B) : B := α*U+β*(V+U*W)
+
+theorem inverse_relations (h x y s α β T : B)
+    (hc : x^2+y^3 = h*s) (hb : α*h+β*y = 1) :
+    let U := inverseU h x β T
+    let G := inverseG x y α T
+    let W := inverseW h y s α β U G
+    U^3+h*inverseV U G W = x ∧ -U^2+h*W = y ∧ S h U (inverseV U G W) W = s := by
+  dsimp only
+  have hl := linear_parameter_relation h x y α β T hb
+  have hcompat := compatibility h x y s (inverseU h x β T) (inverseG x y α T) hc hl
+  have hb2 := squared_bezout h y α β hb
+  have hw := solve_h h (y^2) (y+(inverseU h x β T)^2)
+    (s-h*(inverseG x y α T)^2+2*(inverseU h x β T)*y*(inverseG x y α T))
+    (α*(1+β*y)) (β^2) hcompat hb2
+  have hs := solve_c h (y^2) (y+(inverseU h x β T)^2)
+    (s-h*(inverseG x y α T)^2+2*(inverseU h x β T)*y*(inverseG x y α T))
+    (α*(1+β*y)) (β^2) hcompat hb2
+  exact linear_to_original h x y s _ _ _ hl hw hs
+
+theorem inverse_parameter (h x y s α β T : B) (hb : α*h+β*y = 1) :
+    let U := inverseU h x β T
+    let G := inverseG x y α T
+    let W := inverseW h y s α β U G
+    parameter α β U (inverseV U G W) W = T := by
+  dsimp only [parameter, inverseV]
+  have he := linear_parameter_inverse h x y α β T hb
+  dsimp [inverseU, inverseG]
+  convert he using 1
+  ring
+
+theorem original_reconstruction (h x y s α β U V W : B)
+    (hb : α*h+β*y = 1) (hx : U^3+h*V = x)
+    (hy : -U^2+h*W = y) (hs : S h U V W = s) :
+    let T := parameter α β U V W
+    let U' := inverseU h x β T
+    let G' := inverseG x y α T
+    let W' := inverseW h y s α β U' G'
+    U' = U ∧ inverseV U' G' W' = V ∧ W' = W := by
+  dsimp only
+  obtain ⟨hl, hw, hs'⟩ := original_to_linear h x y s U V W hx hy hs
+  have hu : inverseU h x β (parameter α β U V W) = U :=
+    recover_U h x y α β U (V+U*W) hb hl
+  have hg : inverseG x y α (parameter α β U V W) = V+U*W :=
+    recover_G h x y α β U (V+U*W) hb hl
+  rw [hu, hg]
+  have hww : inverseW h y s α β U (V+U*W) = W :=
+    (solve_unique h (y^2) (y+U^2) (s-h*(V+U*W)^2+2*U*y*(V+U*W))
+      (α*(1+β*y)) (β^2) W (squared_bezout h y α β hb) hw hs').symm
+  rw [hww]
+  refine ⟨rfl, ?_, rfl⟩
+  unfold inverseV
+  ring
+
+end
+
+section Maps
+variable {B D H : Type*} [CommRing B] [CommRing D]
+variable [FunLike H B D] [RingHomClass H B D]
+
+@[simp] theorem map_inverseU (f : H) (h x β T : B) :
+    f (inverseU h x β T) = inverseU (f h) (f x) (f β) (f T) := by simp [inverseU]
+@[simp] theorem map_inverseG (f : H) (x y α T : B) :
+    f (inverseG x y α T) = inverseG (f x) (f y) (f α) (f T) := by simp [inverseG]
+@[simp] theorem map_inverseW (f : H) (h y s α β U G : B) :
+    f (inverseW h y s α β U G) =
+      inverseW (f h) (f y) (f s) (f α) (f β) (f U) (f G) := by simp [inverseW, map_ofNat]
+@[simp] theorem map_inverseV (f : H) (U G W : B) :
+    f (inverseV U G W) = inverseV (f U) (f G) (f W) := by simp [inverseV]
+@[simp] theorem map_parameter (f : H) (α β U V W : B) :
+    f (parameter α β U V W) = parameter (f α) (f β) (f U) (f V) (f W) := by
+  simp [parameter]
+
+end Maps
+end AbhyankarSathaye
+
+end OAI
diff --git a/lean/OAI/AlgebraicGeometry/AbhyankarSathaye/Stabilization.lean b/lean/OAI/AlgebraicGeometry/AbhyankarSathaye/Stabilization.lean
new file mode 100644
index 0000000000000000000000000000000000000000..2fc6a73e342edbcebcfb26d50a0e330cd0394b36
--- /dev/null
+++ b/lean/OAI/AlgebraicGeometry/AbhyankarSathaye/Stabilization.lean
@@ -0,0 +1,115 @@
+import OAI.AlgebraicGeometry.AbhyankarSathaye.Fiber
+import OAI.AlgebraicGeometry.AbhyankarSathaye.NonCoordinate
+import Mathlib.Logic.Equiv.Fin.Basic
+import Mathlib.RingTheory.Polynomial.Quotient
+
+namespace OAI
+
+/-!
+# Adjoining unused variables
+
+For every `n ≥ 4`, renaming `F` into the first four variables gives a quotient
+isomorphic to a polynomial algebra in `n - 1` variables. The extended critical
+point still has value `-1` and zero gradient, so the polynomial is not a coordinate.
+-/
+
+noncomputable section
+namespace AbhyankarSathaye
+open MvPolynomial
+
+def fourInclusion {n : ℕ} (hn : 4 ≤ n) (i : Fin 4) : Fin n :=
+  ⟨i.val, lt_of_lt_of_le i.isLt hn⟩
+
+def extendedF {n : ℕ} (hn : 4 ≤ n) : MvPolynomial (Fin n) ℂ :=
+  MvPolynomial.rename (fourInclusion hn) F
+
+def blocksToAmbient {n : ℕ} (hn : 4 ≤ n) : Fin (n-4) ⊕ Fin 4 ≃ Fin n :=
+  (Equiv.sumComm _ _).trans (finSumFinEquiv.trans (finCongr (by omega)))
+
+theorem blocksToAmbient_original {n : ℕ} (hn : 4 ≤ n) (i : Fin 4) :
+    blocksToAmbient hn (Sum.inr i) = fourInclusion hn i := by
+  apply Fin.ext
+  rfl
+
+theorem blocksToAmbient_symm_original {n : ℕ} (hn : 4 ≤ n) (i : Fin 4) :
+    (blocksToAmbient hn).symm (fourInclusion hn i) = Sum.inr i := by
+  rw [← blocksToAmbient_original hn i, Equiv.symm_apply_apply]
+
+def splitAmbient {n : ℕ} (hn : 4 ≤ n) :
+    MvPolynomial (Fin n) ℂ ≃ₐ[ℂ] MvPolynomial (Fin (n-4)) R :=
+  (renameEquiv ℂ (blocksToAmbient hn).symm).trans
+    (sumAlgEquiv ℂ (Fin (n-4)) (Fin 4))
+
+theorem splitAmbient_comp_original {n : ℕ} (hn : 4 ≤ n) :
+    (splitAmbient hn).toAlgHom.comp (rename (fourInclusion hn)) =
+      IsScalarTower.toAlgHom ℂ R (MvPolynomial (Fin (n-4)) R) := by
+  apply MvPolynomial.algHom_ext
+  intro i
+  change sumAlgEquiv ℂ (Fin (n-4)) (Fin 4)
+    (rename (blocksToAmbient hn).symm (rename (fourInclusion hn) (X i))) = C (X i)
+  rw [rename_X, rename_X, blocksToAmbient_symm_original]
+  exact sumAlgEquiv_X_inr ℂ (Fin (n-4)) (Fin 4) i
+
+theorem splitAmbient_F {n : ℕ} (hn : 4 ≤ n) : splitAmbient hn (extendedF hn) = C F :=
+  AlgHom.congr_fun (splitAmbient_comp_original hn) F
+
+def blocksToOutput {n : ℕ} (hn : 4 ≤ n) : Fin (n-4) ⊕ Fin 3 ≃ Fin (n-1) :=
+  (Equiv.sumComm _ _).trans (finSumFinEquiv.trans (finCongr (by omega)))
+
+def extendedFiberEquiv {n : ℕ} (hn : 4 ≤ n) :
+    (MvPolynomial (Fin n) ℂ ⧸ Ideal.span {extendedF hn}) ≃ₐ[ℂ]
+      MvPolynomial (Fin (n-1)) ℂ := by
+  let J : Ideal (MvPolynomial (Fin (n-4)) R) := (Ideal.span {F}).map C
+  have hi : J = (Ideal.span {extendedF hn}).map (splitAmbient hn : _ →+* _) := by
+    simp [J, Ideal.map_span, splitAmbient_F]
+  exact (Ideal.quotientEquivAlg (Ideal.span {extendedF hn}) J (splitAmbient hn) hi).trans
+    (((MvPolynomial.quotientEquivQuotientMvPolynomial (σ := Fin (n-4))
+      (Ideal.span {F})).restrictScalars ℂ).symm.trans
+      ((MvPolynomial.mapAlgEquiv (Fin (n-4)) fiberEquiv).trans
+        ((sumAlgEquiv ℂ (Fin (n-4)) (Fin 3)).symm.trans
+          (renameEquiv ℂ (blocksToOutput hn)))))
+
+def extendedPoint {n : ℕ} (_hn : 4 ≤ n) (i : Fin n) : ℂ :=
+  if hi : i.val < 4 then criticalPoint ⟨i.val, hi⟩ else 0
+
+theorem extendedPoint_original {n : ℕ} (hn : 4 ≤ n) (i : Fin 4) :
+    extendedPoint hn (fourInclusion hn i) = criticalPoint i := by
+  simp [extendedPoint, fourInclusion, i.isLt]
+
+theorem extendedPoint_unused {n : ℕ} (hn : 4 ≤ n) (i : Fin n) (hi : 4 ≤ i.val) :
+    extendedPoint hn i = 0 := by
+  simp [extendedPoint, Nat.not_lt.mpr hi]
+
+theorem extended_eval {n : ℕ} (hn : 4 ≤ n) (f : R) :
+    eval (extendedPoint hn) (rename (fourInclusion hn) f) = eval criticalPoint f := by
+  rw [eval_rename]
+  have he : extendedPoint hn ∘ fourInclusion hn = criticalPoint := by
+    funext i
+    exact extendedPoint_original hn i
+  rw [he]
+
+theorem extendedF_eval {n : ℕ} (hn : 4 ≤ n) : eval (extendedPoint hn) (extendedF hn) = -1 := by
+  rw [extendedF, extended_eval, eval_F]
+
+theorem extendedF_critical {n : ℕ} (hn : 4 ≤ n) (i : Fin n) :
+    eval (extendedPoint hn) (pderiv i (extendedF hn)) = 0 := by
+  apply critical_of_ambient_identity
+    (rename (fourInclusion hn) shiftX) (rename (fourInclusion hn) shiftY)
+    (rename (fourInclusion hn) s) (extendedF hn) (extendedPoint hn)
+  · simpa only [extendedF, map_add, map_pow, map_mul, map_one] using
+      congrArg (rename (fourInclusion hn)) ambient
+  · rw [extended_eval, eval_shiftX]
+  · rw [extended_eval, eval_shiftY]
+  · rw [extended_eval, eval_s]
+  · exact extendedF_eval hn
+
+theorem extendedF_not_coordinate {n : ℕ} (hn : 4 ≤ n) :
+    ¬ ∃ (e : MvPolynomial (Fin n) ℂ ≃ₐ[ℂ] MvPolynomial (Fin n) ℂ) (i : Fin n),
+      e (X i) = extendedF hn :=
+  no_coordinate_of_critical (extendedF hn) (extendedPoint hn) (extendedF_critical hn)
+
+end AbhyankarSathaye
+
+end
+
+end OAI
diff --git a/lean/OAI/AlgebraicGeometry/CartierSections/ChartCompactness.lean b/lean/OAI/AlgebraicGeometry/CartierSections/ChartCompactness.lean
new file mode 100644
index 0000000000000000000000000000000000000000..85e2dc9c5d0ac1a8fcba25e59c5731f4c25ea3e7
--- /dev/null
+++ b/lean/OAI/AlgebraicGeometry/CartierSections/ChartCompactness.lean
@@ -0,0 +1,61 @@
+/-
+Copyright (c) 2026 OpenAI. All rights reserved.
+Released under Apache 2.0 license.
+Authors: OpenAI
+-/
+import OAI.AlgebraicGeometry.CartierSections.FieldTopology
+import OAI.AlgebraicGeometry.CartierSections.FieldRetraction
+
+namespace OAI
+
+/-!
+# Compactness of monomial retractions on a closed étale chart
+
+Local algebra for uniform Cartier sections.
+-/
+
+noncomputable section
+open scoped BigOperators NNReal ENNReal
+
+namespace CartierSections
+section ClosedChartFieldTopology
+universe u
+local instance polynomialOrigin_isMaximal_topology {σ k : Type u} [Fintype σ] [Field k] :
+    (MvPolynomial.idealOfVars σ k).IsMaximal :=
+  polynomialOrigin_isMaximal
+
+variable {σ k R A K : Type u} [Fintype σ] [Field k] [IsAlgClosed k]
+  [CommRing R] [CommRing A] [IsLocalRing R] [IsLocalRing A] [IsNoetherianRing A]
+  [IsDomain A] [Field K] [Algebra A K] [IsFractionRing A K]
+  [Algebra (MvPolynomial σ k) R] [Algebra (MvPolynomial σ k) A]
+  [Algebra k A] [IsScalarTower k (MvPolynomial σ k) A]
+  [Algebra R A] [IsScalarTower (MvPolynomial σ k) R A]
+  [IsLocalization.AtPrime R (MvPolynomial.idealOfVars σ k)]
+  [IsLocalHom (algebraMap R A)] [Algebra.FormallyUnramified R A]
+  [Algebra.EssFiniteType R A] [Algebra.FormallyEtale (MvPolynomial σ k) A]
+
+/-- Monomial retractions of a closed étale chart vary continuously with the weights. -/
+lemma continuous_closedChartFieldRetraction_evaluations :
+    Continuous (fun w : σ → NNReal => fun x : K =>
+      closedChartFieldRetraction (σ := σ) (k := k) (R := R) (A := A) w x) :=
+  continuous_expandedFractionValuation_evaluations
+    (closedChartExpansion (σ := σ) (k := k) (R := R) (A := A))
+    (closedChartExpansion_injective (σ := σ) (k := k) (R := R) (A := A))
+
+/-- The normalized monomial retractions on the fraction field of a closed étale
+chart form a compact set in the topology of pointwise evaluation. -/
+lemma isCompact_closedChartFieldRetraction_cone
+    (a : σ → NNReal) (ha : ∀ i, 0 < a i) :
+    IsCompact ((fun w : σ → NNReal => fun x : K =>
+      closedChartFieldRetraction (σ := σ) (k := k) (R := R) (A := A) w x) ''
+      normalizedWeights a) :=
+  (isCompact_normalizedWeights a ha).image
+    (continuous_closedChartFieldRetraction_evaluations
+      (σ := σ) (k := k) (R := R) (A := A) (K := K))
+
+end ClosedChartFieldTopology
+end CartierSections
+
+end
+
+end OAI
diff --git a/lean/OAI/AlgebraicGeometry/CartierSections/ChartCompletion.lean b/lean/OAI/AlgebraicGeometry/CartierSections/ChartCompletion.lean
new file mode 100644
index 0000000000000000000000000000000000000000..e5a349919d5524996c5d48e3e1091bb699597844
--- /dev/null
+++ b/lean/OAI/AlgebraicGeometry/CartierSections/ChartCompletion.lean
@@ -0,0 +1,190 @@
+/-
+Copyright (c) 2026 OpenAI. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: OpenAI
+-/
+import OAI.AlgebraicGeometry.CartierSections.InfinitesimalCharts
+import Mathlib.RingTheory.AdicCompletion.AsTensorProduct
+import Mathlib.RingTheory.AdicCompletion.LocalRing
+import Mathlib.RingTheory.Flat.FaithfullyFlat.Algebra
+import Mathlib.RingTheory.MvPowerSeries.Equiv
+
+namespace OAI
+
+/-!
+# Completion coordinates for étale charts
+
+Compatible infinitesimal isomorphisms identify an étale chart completion with a
+power-series ring. Expansion through a Noetherian local completion is faithfully flat.
+-/
+
+namespace CartierSections
+
+attribute [local instance 10001] scalarTower_self
+section CompletionIsomorphism
+variable {R A : Type*} [CommRing R] [CommRing A] [Algebra R A]
+
+/-- Evaluation of an adic completion commutes with reduction to a lower ideal power. -/
+theorem completion_eval_factor (I : Ideal R) {m n : ℕ} (h : m ≤ n)
+    (x : AdicCompletion I R) :
+    Ideal.Quotient.factorₐ R (Ideal.pow_le_pow_right h) (AdicCompletion.evalₐ I n x) =
+      AdicCompletion.evalₐ I m x := by
+  have hx := congrArg (Ideal.Quotient.factor (show (I^m • ⊤ : Ideal R) ≤ I^m
+    from le_of_eq (Ideal.mul_top _))) (x.property h)
+  simpa [AdicCompletion.evalₐ, AdicCompletion.eval,
+    AdicCompletion.transitionMap, Submodule.factorPow] using hx
+
+/-- Evaluation on infinitesimal neighbourhoods is compatible with the maps induced
+by an algebra map. -/
+theorem quotientPowerMap_eval_compatible (I : Ideal R) {m n : ℕ} (h : m ≤ n) :
+    (Ideal.Quotient.factorₐ R
+      (Ideal.pow_le_pow_right (I := I.map (algebraMap R A)) h)).comp
+      ((quotientPowerMap I n).comp (AdicCompletion.evalₐ I n)) =
+        (quotientPowerMap I m).comp (AdicCompletion.evalₐ I m) := by
+  rw [← AlgHom.comp_assoc, quotientPowerMap_factor I h, AlgHom.comp_assoc]
+  congr 1
+  ext x
+  exact completion_eval_factor I h x
+
+/-- The completion map induced by an algebra map. -/
+noncomputable def chartCompletionMap (I : Ideal R) :
+    AdicCompletion I R →ₐ[R] AdicCompletion (I.map (algebraMap R A)) A :=
+  AdicCompletion.liftAlgHom _
+    (fun n => (quotientPowerMap I n).comp (AdicCompletion.evalₐ I n))
+    (quotientPowerMap_eval_compatible I)
+
+@[simp] theorem chartCompletionMap_eval (I : Ideal R) (n : ℕ) (x : AdicCompletion I R) :
+    AdicCompletion.evalₐ (I.map (algebraMap R A)) n (chartCompletionMap I x) =
+      quotientPowerMap I n (AdicCompletion.evalₐ I n x) :=
+  AdicCompletion.evalₐ_liftAlgHom _ _ (quotientPowerMap_eval_compatible I) n x
+
+/-- Étale charts with trivial residue extension have the same completion.
+This is derived from formal lifting and uniqueness at every order. -/
+theorem chartCompletionMap_bijective [Algebra.FormallyEtale R A]
+    (I : Ideal R) (hI : Function.Bijective (quotientBaseMap (A := A) I)) :
+    Function.Bijective (chartCompletionMap (A := A) I) := by
+  classical
+  let J := I.map (algebraMap R A)
+  let e (n : ℕ) := AlgEquiv.ofBijective (quotientPowerMap (A := A) I n)
+    (etale_quotient_power_bijective I hI n)
+  let g (n : ℕ) : AdicCompletion J A →ₐ[R] R ⧸ I^n :=
+    (e n).symm.toAlgHom.comp ((AdicCompletion.evalₐ J n).restrictScalars R)
+  have hg {m n : ℕ} (h : m ≤ n) :
+      (Ideal.Quotient.factorₐ R (Ideal.pow_le_pow_right h)).comp (g n) = g m := by
+    ext x
+    apply (e m).injective
+    change quotientPowerMap I m
+      (Ideal.Quotient.factorₐ R (Ideal.pow_le_pow_right h) ((e n).symm (AdicCompletion.evalₐ J n x))) = _
+    have hfac := AlgHom.congr_fun (quotientPowerMap_factor (A := A) I h)
+      ((e n).symm (AdicCompletion.evalₐ J n x))
+    simp only [AlgHom.comp_apply] at hfac
+    rw [← hfac]
+    change Ideal.Quotient.factorₐ R (Ideal.pow_le_pow_right h)
+      (e n ((e n).symm (AdicCompletion.evalₐ J n x))) = e m ((e m).symm (AdicCompletion.evalₐ J m x))
+    rw [(e n).apply_symm_apply, (e m).apply_symm_apply]
+    exact completion_eval_factor J h x
+  let inv : AdicCompletion J A →ₐ[R] AdicCompletion I R :=
+    AdicCompletion.liftAlgHom I g (fun h => hg h)
+  have hleft : Function.LeftInverse inv (chartCompletionMap (A := A) I) := by
+    intro x
+    apply AdicCompletion.ext_evalₐ
+    intro n
+    rw [AdicCompletion.evalₐ_liftAlgHom]
+    change (e n).symm (AdicCompletion.evalₐ J n (chartCompletionMap I x)) = _
+    rw [chartCompletionMap_eval]
+    exact (e n).symm_apply_apply _
+  have hright : Function.RightInverse inv (chartCompletionMap (A := A) I) := by
+    intro x
+    apply AdicCompletion.ext_evalₐ
+    intro n
+    rw [chartCompletionMap_eval, AdicCompletion.evalₐ_liftAlgHom]
+    exact (e n).apply_symm_apply _
+  exact ⟨hleft.injective, hright.surjective⟩
+
+noncomputable def chartCompletionEquiv [Algebra.FormallyEtale R A]
+    (I : Ideal R) (hI : Function.Bijective (quotientBaseMap (A := A) I)) :
+    AdicCompletion I R ≃ₐ[R] AdicCompletion (I.map (algebraMap R A)) A :=
+  AlgEquiv.ofBijective (chartCompletionMap I) (chartCompletionMap_bijective I hI)
+end CompletionIsomorphism
+/-- Formal coordinates on the completion of an étale polynomial chart. -/
+noncomputable def polynomialChartSeriesEquiv
+    {σ k A : Type*} [Finite σ] [CommRing k] [CommRing A]
+    [Algebra (MvPolynomial σ k) A] [Algebra.FormallyEtale (MvPolynomial σ k) A]
+    (hI : Function.Bijective
+      (quotientBaseMap (A := A) (MvPolynomial.idealOfVars σ k))) :
+    MvPowerSeries σ k ≃ₐ[MvPolynomial σ k]
+      AdicCompletion ((MvPolynomial.idealOfVars σ k).map (algebraMap (MvPolynomial σ k) A)) A :=
+  (MvPowerSeries.toAdicCompletionAlgEquiv σ k).trans
+    (chartCompletionEquiv (MvPolynomial.idealOfVars σ k) hI)
+
+@[simp] theorem polynomialChartSeriesEquiv_coe
+    {σ k A : Type*} [Finite σ] [CommRing k] [CommRing A]
+    [Algebra (MvPolynomial σ k) A] [Algebra.FormallyEtale (MvPolynomial σ k) A]
+    (hI : Function.Bijective
+      (quotientBaseMap (A := A) (MvPolynomial.idealOfVars σ k))) (p : MvPolynomial σ k) :
+    polynomialChartSeriesEquiv hI (p : MvPowerSeries σ k) =
+      algebraMap A _ (algebraMap (MvPolynomial σ k) A p) := by
+  exact (polynomialChartSeriesEquiv hI).commutes p
+/-- The expansion map attached to an isomorphism with the maximal-ideal completion. -/
+noncomputable def completionExpansion
+    {A S : Type*} [CommRing A] [IsLocalRing A] [CommRing S]
+    (e : S ≃+* AdicCompletion (IsLocalRing.maximalIdeal A) A) : A →+* S :=
+  e.symm.toRingHom.comp (algebraMap A _)
+
+/-- Formal expansion through a Noetherian completion is faithfully flat. -/
+theorem completionExpansion_faithfullyFlat
+    {A S : Type*} [CommRing A] [IsLocalRing A] [IsNoetherianRing A] [CommRing S]
+    (e : S ≃+* AdicCompletion (IsLocalRing.maximalIdeal A) A) :
+    letI : Algebra A S := (completionExpansion e).toAlgebra
+    Module.FaithfullyFlat A S := by
+  let : Algebra A S := (completionExpansion e).toAlgebra
+  have : Module.FaithfullyFlat A (AdicCompletion (IsLocalRing.maximalIdeal A) A) :=
+    Module.FaithfullyFlat.of_flat_of_isLocalHom
+  let eA : S ≃ₐ[A] AdicCompletion (IsLocalRing.maximalIdeal A) A :=
+    { e with commutes' := fun a => e.apply_symm_apply (algebraMap A _ a) }
+  exact Module.FaithfullyFlat.of_linearEquiv A _ eA.toLinearEquiv
+
+/-- A formal expansion through a Noetherian local completion reflects units. -/
+theorem completionExpansion_isLocalHom
+    {A S : Type*} [CommRing A] [IsLocalRing A] [IsNoetherianRing A] [CommRing S]
+    (e : S ≃+* AdicCompletion (IsLocalRing.maximalIdeal A) A) :
+    IsLocalHom (completionExpansion e) := by
+  constructor
+  intro a ha
+  apply (isUnit_map_iff (algebraMap A (AdicCompletion (IsLocalRing.maximalIdeal A) A)) a).mp
+  have h := ha.map e.toMonoidHom
+  simpa [completionExpansion] using h
+section ChartExpansion
+variable {k A σ : Type*} [CommRing k] [CommRing A] [IsLocalRing A]
+  [Algebra k A] [Algebra (MvPolynomial σ k) A] [IsScalarTower k (MvPolynomial σ k) A]
+
+/-- Expansion in completion coordinates as an algebra map over the coefficient ring. -/
+noncomputable def chartSeriesExpansion
+    (e : MvPowerSeries σ k ≃ₐ[MvPolynomial σ k]
+      AdicCompletion (IsLocalRing.maximalIdeal A) A) : A →ₐ[k] MvPowerSeries σ k :=
+  (e.symm.restrictScalars k).toAlgHom.comp
+    (IsScalarTower.toAlgHom k A (AdicCompletion (IsLocalRing.maximalIdeal A) A))
+
+@[simp] theorem chartSeriesExpansion_toRingHom
+    (e : MvPowerSeries σ k ≃ₐ[MvPolynomial σ k]
+      AdicCompletion (IsLocalRing.maximalIdeal A) A) :
+    (chartSeriesExpansion e).toRingHom = completionExpansion e.toRingEquiv := rfl
+
+@[simp] theorem chartSeriesExpansion_coordinate
+    (e : MvPowerSeries σ k ≃ₐ[MvPolynomial σ k]
+      AdicCompletion (IsLocalRing.maximalIdeal A) A) (i : σ) :
+    chartSeriesExpansion e (algebraMap (MvPolynomial σ k) A (MvPolynomial.X i)) =
+      MvPowerSeries.X i := by
+  apply e.injective
+  change e (e.symm (algebraMap A _ (algebraMap (MvPolynomial σ k) A (MvPolynomial.X i)))) = _
+  rw [e.apply_symm_apply]
+  have he : e ((MvPolynomial.X i : MvPolynomial σ k) : MvPowerSeries σ k) =
+      algebraMap (MvPolynomial σ k) _ (MvPolynomial.X i) := by
+    simpa only [MvPowerSeries.algebraMap_apply', Algebra.algebraMap_self,
+      MvPowerSeries.map_id, RingHom.id_apply] using e.commutes (MvPolynomial.X i)
+  simpa only [MvPolynomial.coe_X,
+    IsScalarTower.algebraMap_apply (MvPolynomial σ k) A (AdicCompletion (IsLocalRing.maximalIdeal A) A)] using he.symm
+end ChartExpansion
+end CartierSections
+
+end OAI