Add lean source and binary files (part 83)

lean/OAI/GroupTheory/PolycyclicRecognition/Geometry/WordLieProjection.lean

@@ -0,0 +1,69 @@
+import Mathlib.Algebra.MonoidAlgebra.Module
+import Mathlib.Algebra.FreeMonoid.Basic
+import Mathlib.LinearAlgebra.Finsupp.LinearCombination
+import Mathlib.Algebra.Algebra.Rat
+import Mathlib.Tactic.Abel
+
+namespace OAI
+
+/-! # The right-nested commutator projection of rational words -/
+
+noncomputable section
+namespace PolycyclicRecognition
+
+abbrev RationalWords (n : ℕ) := MonoidAlgebra ℚ (FreeMonoid (Fin n))
+
+variable {A : Type*} [Ring A] [Algebra ℚ A] {n : ℕ} (X : Fin n → A)
+
+def wordRightLie : List (Fin n) → A
+  | [] => 0
+  | [i] => X i
+  | i :: j :: l => X i * wordRightLie (j :: l) - wordRightLie (j :: l) * X i
+
+def wordLieProjection : RationalWords n →ₗ[ℚ] A :=
+  (Finsupp.linearCombination ℚ (fun w : FreeMonoid (Fin n) => wordRightLie X w.toList)).comp
+    (MonoidAlgebra.coeffLinearEquiv ℚ).toLinearMap
+
+theorem wordLieProjection_single (w : FreeMonoid (Fin n)) (q : ℚ) :
+    wordLieProjection X (MonoidAlgebra.single w q) = q • wordRightLie X w.toList := by
+  change Finsupp.linearCombination ℚ _ (Finsupp.single w q) = _
+  exact Finsupp.linearCombination_single (R := ℚ)
+    (v := fun w : FreeMonoid (Fin n) => wordRightLie X w.toList) q w
+
+def rationalWordLetter (i : Fin n) : RationalWords n :=
+  MonoidAlgebra.single (FreeMonoid.of i) 1
+
+theorem wordLieProjection_letter_mul (i : Fin n) (p : RationalWords n) :
+    wordLieProjection X (rationalWordLetter i * p) =
+      X i * wordLieProjection X p - wordLieProjection X p * X i + p.coeff 1 • X i := by
+  induction p using MonoidAlgebra.induction_on with
+  | of w =>
+    change wordLieProjection X (rationalWordLetter i * MonoidAlgebra.single w 1) =
+      X i * wordLieProjection X (MonoidAlgebra.single w 1) -
+        wordLieProjection X (MonoidAlgebra.single w 1) * X i +
+        (MonoidAlgebra.single w (1 : ℚ)).coeff 1 • X i
+    rw [rationalWordLetter, MonoidAlgebra.single_mul_single, one_mul,
+      wordLieProjection_single, wordLieProjection_single, one_smul, one_smul]
+    cases hw : w.toList with
+    | nil =>
+      have hw1 : w = 1 := FreeMonoid.toList.injective hw
+      subst w
+      simp [wordRightLie, MonoidAlgebra.coeff_single]
+    | cons j l =>
+      have hw1 : w ≠ 1 := by
+        intro h
+        simp [h] at hw
+      simp [wordRightLie, hw, MonoidAlgebra.coeff_single, hw1]
+  | add p q hp hq =>
+    simp only [mul_add, map_add, hp, hq, add_mul, MonoidAlgebra.coeff_add,
+      Finsupp.add_apply, add_smul]
+    abel
+  | smul r p hp =>
+    simp only [mul_smul_comm, map_smul, hp, smul_mul_assoc, MonoidAlgebra.coeff_smul,
+      Finsupp.smul_apply, smul_sub, smul_add, smul_smul, Algebra.mul_smul_comm, smul_eq_mul]
+
+end PolycyclicRecognition
+
+end
+
+end OAI

lean/OAI/GroupTheory/PolycyclicRecognition/Geometry/WordProjectionAdjoint.lean

@@ -0,0 +1,50 @@
+import OAI.GroupTheory.PolycyclicRecognition.Algebra.RationalWordEvaluation
+import Mathlib.Algebra.Lie.OfAssociative
+
+namespace OAI
+
+/-! # The adjoint action on the right-nested word projection -/
+
+noncomputable section
+namespace PolycyclicRecognition
+
+attribute [local instance 100] LieRing.ofAssociativeRing
+
+variable {A : Type*} [Ring A] [Algebra ℚ A] {n : ℕ} (X : Fin n → A)
+
+def rationalWordAdjoint : RationalWords n →ₐ[ℚ] Module.End ℚ A :=
+  rationalWordEvaluation (fun i => LieAlgebra.ad ℚ A (X i))
+
+theorem wordLieProjection_word_mul (w : FreeMonoid (Fin n)) (q : RationalWords n)
+    (hq : q.coeff 1 = 0) :
+    wordLieProjection X (MonoidAlgebra.single w 1 * q) =
+      FreeMonoid.lift (fun i => LieAlgebra.ad ℚ A (X i)) w (wordLieProjection X q) := by
+  induction w using FreeMonoid.recOn with
+  | one => simp [← MonoidAlgebra.one_def]
+  | of_mul i w ih =>
+    have heq : MonoidAlgebra.single (FreeMonoid.of i * w) (1 : ℚ) =
+        rationalWordLetter i * MonoidAlgebra.single w 1 := by
+      rw [rationalWordLetter, MonoidAlgebra.single_mul_single, one_mul]
+    rw [heq, mul_assoc, wordLieProjection_letter_mul, rationalWord_emptyCoeff_mul,
+      hq, mul_zero, zero_smul, add_zero, ih, map_mul]
+    rw [show FreeMonoid.lift (fun i => LieAlgebra.ad ℚ A (X i)) (FreeMonoid.of i) =
+      LieAlgebra.ad ℚ A (X i) from rfl]
+    rfl
+
+theorem wordLieProjection_mul (p q : RationalWords n) (hq : q.coeff 1 = 0) :
+    wordLieProjection X (p * q) = rationalWordAdjoint X p (wordLieProjection X q) := by
+  induction p using MonoidAlgebra.induction_on with
+  | of w =>
+    change wordLieProjection X (MonoidAlgebra.single w 1 * q) = _
+    rw [wordLieProjection_word_mul X w q hq]
+    change _ = rationalWordEvaluation (fun i => LieAlgebra.ad ℚ A (X i))
+      (MonoidAlgebra.single w 1) (wordLieProjection X q)
+    rw [rationalWordEvaluation_single, one_smul, ← FreeMonoid.lift_apply]
+  | add p r hp hr => simp only [add_mul, map_add, hp, hr, LinearMap.add_apply]
+  | smul r p hp => simp only [smul_mul_assoc, map_smul, hp, LinearMap.smul_apply]
+
+end PolycyclicRecognition
+
+end
+
+end OAI

lean/OAI/GroupTheory/PolycyclicRecognition/GromovImport.lean

@@ -0,0 +1,19 @@
+import OAI.GroupTheory.PolycyclicRecognition.Algebra.GromovGrowthBridge
+import Gromov.FormalConjecturesCheck
+
+namespace OAI
+
+/-! # Gromov’s polynomial-growth theorem in arbitrary universes. -/
+namespace PolycyclicRecognition
+universe u
+variable {J : Type u} [Group J] [DecidableEq J]
+
+/-- Polynomial word growth implies virtual nilpotence in every universe. -/
+theorem gromovPolynomialGrowthInput : GromovPolynomialGrowthInput J := by
+  intro T hT hgen hgrowth
+  exact FormalConjecturesCheck.gromov_forward J
+    (hasPolynomialGrowth_of_wordBall T hT hgen hgrowth)
+
+end PolycyclicRecognition
+
+end OAI

lean/OAI/GroupTheory/PolycyclicRecognition/Lattices/AbelianCyclicFiniteIndexLattice.lean

@@ -0,0 +1,45 @@
+import OAI.GroupTheory.PolycyclicRecognition.Algebra.RealMatrixSquareLogarithm
+import OAI.GroupTheory.PolycyclicRecognition.Algebra.AbelianCyclicSquareLog
+
+namespace OAI
+
+/-! # Free-abelian-by-cyclic groups are virtually solvable Lie lattices
+
+No nilpotence assumption is required. Squaring the integral automorphism
+permits a real logarithm, and its exponential supplies the real action.
+-/
+
+noncomputable section
+namespace PolycyclicRecognition
+variable {d : ℕ}
+
+theorem realIntegralLinearEquiv_square (a : MulAut (Multiplicative (Fin d → ℤ))) :
+    (realIntegralLinearEquiv (a ^ 2).toAdditive.toIntLinearEquiv).toLinearMap =
+      (realIntegralLinearEquiv a.toAdditive.toIntLinearEquiv).toLinearMap ^ 2 := by
+  let f : (Fin d → ℤ) →ₗ[ℤ] (Fin d → ℤ) := a.toAdditive.toIntLinearEquiv.toLinearMap
+  let g : (Fin d → ℤ) →ₗ[ℤ] (Fin d → ℤ) := (a ^ 2).toAdditive.toIntLinearEquiv.toLinearMap
+  change realLinearExtension g = realLinearExtension f ^ 2
+  apply (Pi.basisFun ℝ (Fin d)).ext
+  intro i
+  change realLinearExtension g ((Pi.basisFun ℝ (Fin d)) i) =
+    realLinearExtension f (realLinearExtension f ((Pi.basisFun ℝ (Fin d)) i))
+  rw [realLinearExtension_basis, realLinearExtension_basis, realLinearExtension_cast]
+  rfl
+
+theorem freeAbelian_cyclic_finiteIndex_lattice
+    (a : MulAut (Multiplicative (Fin d → ℤ))) :
+    ∃ Γ : Subgroup (Multiplicative (Fin d → ℤ) ⋊[integerPowerAction a] Multiplicative ℤ),
+      Γ.FiniteIndex ∧
+      ∃ (S : SimplyConnectedSolvableLieModel) (Λ : Subgroup S.carrier),
+        IsUniformLattice Λ ∧ Nonempty (Γ ≃* Λ) := by
+  let A := realIntegralLinearEquiv a.toAdditive.toIntLinearEquiv
+  have hA : IsUnit A.toLinearMap := (Module.End.isUnit_iff _).mpr A.bijective
+  obtain ⟨D, hD⟩ := real_linear_square_has_log A.toLinearMap hA
+  apply freeAbelian_cyclic_finiteIndex_lattice_of_square_log a D
+  exact hD.trans (congrArg LinearMap.toContinuousLinearMap (realIntegralLinearEquiv_square a).symm)
+
+end PolycyclicRecognition
+
+end
+
+end OAI

lean/OAI/GroupTheory/PolycyclicRecognition/Lattices/AbelianCyclicLattice.lean

@@ -0,0 +1,59 @@
+import OAI.GroupTheory.PolycyclicRecognition.Lattices.FreeAbelianCyclicLattice
+import OAI.GroupTheory.PolycyclicRecognition.Algebra.CyclicKernelSplitting
+import OAI.GroupTheory.PolycyclicRecognition.Algebra.PolycyclicTorsionFree
+
+namespace OAI
+
+/-! # Lattice realization for torsion-free nilpotent groups with abelian cyclic kernel
+
+The nilpotency class is unrestricted. An abstract abelian kernel is identified
+with its integral basis before applying the constructed real flow.
+-/
+
+noncomputable section
+namespace PolycyclicRecognition
+open scoped IsMulCommutative
+
+theorem abelian_cyclic_nilpotent_lattice {H : Type} [CommGroup H] [Group.FG H]
+    (htf : HasNoNontrivialTorsion H) (a : MulAut H)
+    [Group.IsNilpotent (H ⋊[integerPowerAction a] Multiplicative ℤ)] :
+    ∃ (S : SimplyConnectedSolvableLieModel) (Γ : Subgroup S.carrier),
+      IsUniformLattice Γ ∧ Nonempty ((H ⋊[integerPowerAction a] Multiplicative ℤ) ≃* Γ) := by
+  obtain ⟨d, ⟨e⟩⟩ := exists_integralLattice_equiv htf
+  let aZ : MulAut (IntegralLatticeGroup d) := e.trans (a.trans e.symm)
+  have he (x : IntegralLatticeGroup d) : e (aZ x) = a (e x) := by
+    change e (e.symm (a (e x))) = _
+    exact e.apply_symm_apply _
+  let E : (IntegralLatticeGroup d ⋊[integerPowerAction aZ] Multiplicative ℤ) ≃*
+      (H ⋊[integerPowerAction a] Multiplicative ℤ) :=
+    SemidirectProduct.congr e (MulEquiv.refl _) (by
+      intro n
+      ext x
+      exact mulAut_zpow_semiconj aZ a e he n.toAdd x)
+  let : Group.IsNilpotent
+      (IntegralLatticeGroup d ⋊[integerPowerAction aZ] Multiplicative ℤ) :=
+    Group.nilpotent_of_mulEquiv E.symm
+  obtain ⟨S, Γ, hΓ, ⟨f⟩⟩ := freeAbelian_cyclic_nilpotent_lattice aZ
+  exact ⟨S, Γ, hΓ, ⟨E.symm.trans f⟩⟩
+
+theorem nilpotent_abelian_kernel_cyclic_lattice {G : Type} [Group G]
+    [Group.FG G] [Group.IsNilpotent G] (htf : HasNoNontrivialTorsion G)
+    (q : G →* Multiplicative ℤ) (hq : Function.Surjective q)
+    [IsMulCommutative q.ker] :
+    ∃ (S : SimplyConnectedSolvableLieModel) (Γ : Subgroup S.carrier),
+      IsUniformLattice Γ ∧ Nonempty (G ≃* Γ) := by
+  obtain ⟨t, ht⟩ := hq (Multiplicative.ofAdd 1)
+  let E := cyclicKernelEquiv q t ht
+  let : Group.FG q.ker := CriticalPercolation.nilpotent_subgroup_fg G q.ker
+  let : Group.IsNilpotent
+      (q.ker ⋊[integerPowerAction (MulAut.conjNormal t)] Multiplicative ℤ) :=
+    Group.nilpotent_of_mulEquiv E.symm
+  obtain ⟨S, Γ, hΓ, ⟨f⟩⟩ := abelian_cyclic_nilpotent_lattice
+    (htf.of_injective q.ker.subtype Subtype.val_injective) (MulAut.conjNormal t)
+  exact ⟨S, Γ, hΓ, ⟨E.symm.trans f⟩⟩
+
+end PolycyclicRecognition
+
+end
+
+end OAI

lean/OAI/GroupTheory/PolycyclicRecognition/Lattices/AbelianCyclicLogarithmLattice.lean

@@ -0,0 +1,36 @@
+import OAI.GroupTheory.PolycyclicRecognition.Geometry.LinearExponentialAction
+import OAI.GroupTheory.PolycyclicRecognition.Lattices.SmoothRealActionLattice
+import OAI.GroupTheory.PolycyclicRecognition.Lattices.FreeAbelianCyclicLattice
+
+namespace OAI
+
+/-! # The abelian cyclic lattice step from a real matrix logarithm
+
+The real logarithm is a separate, explicit linear algebra obligation. Once
+it is provided, the actual Lie model and compact lattice cover are constructed.
+-/
+
+noncomputable section
+namespace PolycyclicRecognition
+variable {d : ℕ}
+
+theorem freeAbelian_cyclic_lattice_of_linear_log
+    (a : MulAut (Multiplicative (Fin d → ℤ)))
+    (D : AbelianRealSpace d →L[ℝ] AbelianRealSpace d)
+    (hD : NormedSpace.exp D =
+      (realIntegralLinearEquiv a.toAdditive.toIntLinearEquiv).toContinuousLinearEquiv.toContinuousLinearMap) :
+    ∃ (S : SimplyConnectedSolvableLieModel) (Γ : Subgroup S.carrier),
+      IsUniformLattice Γ ∧
+        Nonempty ((Multiplicative (Fin d → ℤ) ⋊[integerPowerAction a] Multiplicative ℤ) ≃* Γ) := by
+  apply smooth_realAction_cyclic_lattice (linearExponentialAction D)
+    (linearExponentialAction_smooth D) a (abelianRealLattice d)
+    (abelianRealLattice_uniform d) (abelianRealLatticeEquiv d)
+  intro x
+  rw [linearExponentialAction_apply, one_smul, hD]
+  exact (realIntegralGroupAut_lattice a x).symm
+
+end PolycyclicRecognition
+
+end
+
+end OAI

lean/OAI/GroupTheory/PolycyclicRecognition/Lattices/AbelianLatticeKernel.lean

@@ -0,0 +1,41 @@
+import OAI.GroupTheory.PolycyclicRecognition.Lattices.NilpotentLatticeInnerAdjoint
+
+namespace OAI
+
+/-! # Commutativity passes to the actual nilpotent lattice completion -/
+
+noncomputable section
+namespace PolycyclicRecognition.NilpotentLatticeCoordinates
+open scoped IsMulCommutative
+variable {N : Type} [Group N] [IsMulCommutative N] (C : NilpotentLatticeCoordinates N)
+
+theorem completed_kernel_mul_comm (u v : C.carrier) : u * v = v * u := by
+  have hl (n : N) (x : C.carrier) : (C.equiv n : C.carrier) * x * (C.equiv n : C.carrier)⁻¹ = x := by
+    rw [← C.automorphism_inner_apply]
+    have hn : MulAut.conj n = 1 := by
+      apply DFunLike.ext
+      intro y
+      change n * y * n⁻¹ = y
+      rw [mul_comm n y, mul_inv_cancel_right]
+    rw [hn, C.automorphism_one]
+    rfl
+  have hp : IsPolynomialInBasis C.basis C.basis
+      (fun x : C.carrier => u * x * u⁻¹) := by
+    have he : (fun x : C.carrier => u * x * u⁻¹) = adjointLinearMap (E := C.carrier) u :=
+      funext (fun x => (polynomial_adjoint_apply u x).symm)
+    rw [he]
+    exact IsPolynomialInBasis.linear (adjointLinearMap (E := C.carrier) u).toLinearMap
+  have he : (fun x : C.carrier => u * x * u⁻¹) = id :=
+    C.ext_polynomial hp (IsPolynomialInBasis.linear (LinearMap.id)) (by
+      intro n
+      have hn := hl n u
+      rw [mul_inv_eq_iff_eq_mul] at hn
+      change u * (C.equiv n : C.carrier) * u⁻¹ = C.equiv n
+      rw [← hn, mul_inv_cancel_right])
+  exact mul_inv_eq_iff_eq_mul.mp (congrFun he v)
+
+end PolycyclicRecognition.NilpotentLatticeCoordinates
+
+end
+
+end OAI

lean/OAI/GroupTheory/PolycyclicRecognition/Lattices/AbelianLatticeRealization.lean

@@ -0,0 +1,50 @@
+import OAI.GroupTheory.PolycyclicRecognition.Lattices.VectorLatticeModel
+import OAI.GroupTheory.PolycyclicRecognition.Algebra.PolycyclicTorsionFree
+
+namespace OAI
+
+/-! # Solvable lattice realization for virtually abelian groups
+
+The finite-index torsion-free subgroup is an integral lattice. Its embedding
+into the actual additive vector Lie group has a compact fundamental cover.
+This discharges the virtually abelian case of Dekimpe's realization input.
+-/
+
+noncomputable section
+namespace PolycyclicRecognition
+open scoped IsMulCommutative Manifold
+variable {P : Type} [Group P] [Group.FG P]
+
+theorem solvable_lattice_realization_of_finiteIndex_abelian
+    (H : Subgroup P) [H.FiniteIndex] [IsMulCommutative H] :
+    ∃ Γ : Subgroup P, Γ.FiniteIndex ∧
+      ∃ (S : SimplyConnectedSolvableLieModel) (Λ : Subgroup S.carrier),
+        IsUniformLattice Λ ∧ Nonempty (Γ ≃* Λ) := by
+  have hH : IsPolycyclic H := isPolycyclic_of_finitelyGenerated_commGroup H
+  obtain ⟨K, hKi, hKtf⟩ := hH.exists_torsionFree_finiteIndex
+  let := hKi
+  obtain ⟨n, ⟨e⟩⟩ := exists_integralLattice_equiv hKtf
+  let Γ := K.map H.subtype
+  have hΓi : Γ.FiniteIndex := ⟨by
+    change (K.map H.subtype).index ≠ 0
+    rw [Subgroup.index_map_subtype]
+    exact mul_ne_zero hKi.index_ne_zero (inferInstance : H.FiniteIndex).index_ne_zero⟩
+  let eK : K ≃* Γ := K.equivMapOfInjective H.subtype H.subtype_injective
+  exact ⟨Γ, hΓi, vectorSolvableLieModel n, standardVectorLattice n,
+    standardVectorLattice_uniform n,
+    ⟨(eK.symm.trans e.symm).trans (standardVectorLatticeEquiv n)⟩⟩
+
+theorem dekimpe_realization_of_finiteIndex_abelian
+    (H : Subgroup P) [H.FiniteIndex] [IsMulCommutative H] :
+    ∃ Γ : Subgroup P, Γ.FiniteIndex ∧
+      ∃ (S : SimplyConnectedSolvableLieModel) (Λ : Subgroup S.carrier),
+        DiscreteTopology Λ ∧ CompactSpace (S.carrier ⧸ Λ) ∧ Nonempty (Γ ≃* Λ) := by
+  obtain ⟨Γ, hΓ, S, Λ, hΛ, e⟩ := solvable_lattice_realization_of_finiteIndex_abelian H
+  let : IsTopologicalGroup S.carrier := topologicalGroup_of_lieGroup (𝓘(ℝ, S.modelSpace)) ⊤
+  exact ⟨Γ, hΓ, S, Λ, hΛ.1, hΛ.compactSpace_quotient, e⟩
+
+end PolycyclicRecognition
+
+end
+
+end OAI

lean/OAI/GroupTheory/PolycyclicRecognition/Lattices/BilinearCentralLattice.lean

@@ -0,0 +1,80 @@
+import OAI.GroupTheory.PolycyclicRecognition.Geometry.BilinearCentralLieModel
+
+namespace OAI
+
+/-! # Uniform lattices for integral bilinear central extensions
+
+The central coordinate of a fundamental-domain representative is reduced
+after subtracting the bilinear correction from the first coordinate.
+-/
+
+noncomputable section
+namespace PolycyclicRecognition
+open Set Module
+
+variable {V W : Type} [NormedAddCommGroup V] [NormedAddCommGroup W]
+  [NormedSpace ℝ V] [NormedSpace ℝ W] [FiniteDimensional ℝ V] [FiniteDimensional ℝ W]
+  {d e : ℕ} (b : Basis (Fin d) ℝ V) (c : Basis (Fin e) ℝ W)
+  (B : V →L[ℝ] V →L[ℝ] W)
+  (hB : ∀ x ∈ Submodule.span ℤ (range b), ∀ y ∈ Submodule.span ℤ (range b),
+    B x y ∈ Submodule.span ℤ (range c))
+
+def bilinearCentralLattice : Subgroup (bilinearCentralLieModel B).carrier where
+  carrier := {x | x.1 ∈ Submodule.span ℤ (range b) ∧
+    x.2 ∈ Submodule.span ℤ (range c)}
+  one_mem' := ⟨Submodule.zero_mem _, Submodule.zero_mem _⟩
+  mul_mem' := by
+    intro x y hx hy
+    exact ⟨Submodule.add_mem _ hx.1 hy.1,
+      Submodule.add_mem _ (Submodule.add_mem _ hx.2 hy.2) (hB _ hx.1 _ hy.1)⟩
+  inv_mem' := by
+    intro x hx
+    exact ⟨Submodule.neg_mem _ hx.1,
+      Submodule.add_mem _ (Submodule.neg_mem _ hx.2) (hB _ hx.1 _ hx.1)⟩
+
+theorem bilinearCentralLattice_discrete :
+    DiscreteTopology (bilinearCentralLattice b c B hB) := by
+  let L := Submodule.span ℤ (range b)
+  let M := Submodule.span ℤ (range c)
+  let f : bilinearCentralLattice b c B hB → L × M :=
+    fun x => (⟨x.val.1, x.property.1⟩, ⟨x.val.2, x.property.2⟩)
+  have hval : Continuous (fun x : bilinearCentralLattice b c B hB => (x.val : V × W)) :=
+    continuous_subtype_val
+  have hf : Continuous f := by
+    exact (hval.fst.subtype_mk _).prodMk (hval.snd.subtype_mk _)
+  apply DiscreteTopology.of_continuous_injective hf
+  intro x y h
+  apply Subtype.ext
+  exact Prod.ext (congrArg (fun z : L × M => z.1.val) h)
+    (congrArg (fun z : L × M => z.2.val) h)
+
+theorem bilinearCentralLattice_uniform :
+    IsUniformLattice (bilinearCentralLattice b c B hB) := by
+  refine ⟨bilinearCentralLattice_discrete b c B hB, ?_⟩
+  let K : Set (V × W) := parallelepiped b ×ˢ parallelepiped c
+  have hK : IsCompact K := b.parallelepiped.isCompact.prod c.parallelepiped.isCompact
+  refine ⟨K, hK, ?_⟩
+  intro g
+  let a := ZSpan.floor b g.1
+  let u := ZSpan.fract b g.1
+  let z := g.2 - B a u
+  let q := ZSpan.floor c z
+  let v := ZSpan.fract c z
+  refine ⟨⟨((a : V), (q : W)), a.property, q.property⟩, (u, v), ?_, ?_⟩
+  · exact ⟨ZSpan.fundamentalDomain_subset_parallelepiped b
+        (ZSpan.fract_mem_fundamentalDomain b g.1),
+      ZSpan.fundamentalDomain_subset_parallelepiped c
+        (ZSpan.fract_mem_fundamentalDomain c z)⟩
+  · apply Prod.ext
+    · change (a : V) + u = g.1
+      dsimp only [a, u, ZSpan.fract]
+      abel
+    · change (q : W) + v + B a u = g.2
+      dsimp only [q, v, ZSpan.fract, z]
+      abel
+
+end PolycyclicRecognition
+
+end
+
+end OAI

lean/OAI/GroupTheory/PolycyclicRecognition/Lattices/CartanNilshadow.lean

@@ -0,0 +1,124 @@
+import OAI.GroupTheory.PolycyclicRecognition.Geometry.CartanJordanDecomposition
+import Mathlib.Algebra.Lie.SemiDirect
+
+namespace OAI
+
+/-! # The nilpotent Lie algebra attached to the Cartan height action
+
+The graph of minus the semisimple height action is a Lie subalgebra of the
+affine derivation algebra. Its first coordinate is linearly the original Lie
+algebra, while its bracket has the semisimple action removed.
+-/
+
+noncomputable section
+namespace PolycyclicRecognition
+
+open LieAlgebra Module
+
+variable {L : Type*} [LieRing L] [LieAlgebra ℝ L] [FiniteDimensional ℝ L]
+  {n : ℕ} (T : TriangularAdjoint L n)
+  (H : LieSubalgebra ℝ L) [H.IsCartanSubalgebra]
+
+def cartanNilshadowSubalgebra :
+    LieSubalgebra ℝ (L ⋊⁅(LieHom.id : LieDerivation ℝ L L →ₗ⁅ℝ⁆ LieDerivation ℝ L L)⁆
+      LieDerivation ℝ L L) where
+  carrier := {p | p.right = -heightSemisimpleAction T H p.left}
+  zero_mem' := by simp
+  add_mem' {p q} hp hq := by
+    change p.right + q.right = -heightSemisimpleAction T H (p.left + q.left)
+    rw [hp, hq, map_add, neg_add]
+  smul_mem' r {p} hp := by
+    change r • p.right = -heightSemisimpleAction T H (r • p.left)
+    rw [hp, map_smul, smul_neg]
+  lie_mem' {p q} hp hq := by
+    change ⁅p.right, q.right⁆ = -heightSemisimpleAction T H
+      (⁅p.left, q.left⁆ + p.right q.left - q.right p.left)
+    rw [hp, hq]
+    simp only [neg_lie, lie_neg, heightSemisimpleAction_commute,
+      LieDerivation.neg_apply, map_add, map_sub, map_neg,
+      heightSemisimpleAction_lie, heightSemisimpleAction_annihilate, neg_zero,
+      add_zero, sub_zero]
+
+abbrev CartanNilshadow := cartanNilshadowSubalgebra T H
+
+def cartanNilshadowEquiv : L ≃ₗ[ℝ] CartanNilshadow T H where
+  toFun x := ⟨⟨x, -heightSemisimpleAction T H x⟩, rfl⟩
+  invFun p := p.val.left
+  left_inv _ := rfl
+  right_inv p := by
+    apply Subtype.ext
+    apply SemiDirectSum.ext
+    · rfl
+    · exact p.property.symm
+  map_add' x y := by
+    apply Subtype.ext
+    apply SemiDirectSum.ext
+    · rfl
+    · change -heightSemisimpleAction T H (x + y) =
+        -heightSemisimpleAction T H x + -heightSemisimpleAction T H y
+      rw [map_add, neg_add]
+  map_smul' r x := by
+    apply Subtype.ext
+    apply SemiDirectSum.ext
+    · rfl
+    · change -heightSemisimpleAction T H (r • x) = r • -heightSemisimpleAction T H x
+      rw [map_smul, smul_neg]
+
+instance : FiniteDimensional ℝ (CartanNilshadow T H) :=
+  (cartanNilshadowEquiv T H).finiteDimensional
+
+theorem cartanNilshadow_bracket (x y : L) :
+    (cartanNilshadowEquiv T H).symm ⁅cartanNilshadowEquiv T H x,
+      cartanNilshadowEquiv T H y⁆ =
+      ⁅x, y⁆ - heightSemisimpleAction T H x y + heightSemisimpleAction T H y x := by
+  change ⁅x, y⁆ + (-heightSemisimpleAction T H x) y -
+    (-heightSemisimpleAction T H y) x = _
+  simp only [LieDerivation.neg_apply]
+  abel
+
+private theorem nilpotent_of_square_eq_mul {V : Type*} [AddCommGroup V] [Module ℝ V]
+    {A F : Module.End ℝ V} (hA : IsNilpotent A) (hFF : F * F = A * F) : IsNilpotent F := by
+  have hp (k : ℕ) : F ^ (k + 1) = A ^ k * F := by
+    induction k with
+    | zero => simp
+    | succ k hk =>
+      calc
+        F ^ (k + 1 + 1) = F ^ (k + 1) * F := pow_succ _ _
+        _ = A ^ k * (F * F) := by rw [hk, mul_assoc]
+        _ = A ^ (k + 1) * F := by rw [hFF, ← mul_assoc, pow_succ]
+  obtain ⟨k, hk⟩ := hA
+  exact ⟨k + 1, by rw [hp, hk, zero_mul]⟩
+
+/-- The Cartan graph is nilpotent; no nilshadow theorem is assumed. -/
+theorem cartanNilshadow_nilpotent : LieRing.IsNilpotent (CartanNilshadow T H) := by
+  let e := cartanNilshadowEquiv T H
+  apply (LieAlgebra.isNilpotent_iff_forall (R := ℝ)).mpr
+  intro p
+  obtain ⟨x, rfl⟩ := e.surjective p
+  let F : Module.End ℝ L := e.symm.conjRingEquiv (ad ℝ (CartanNilshadow T H) (e x))
+  let A : Module.End ℝ L := ad ℝ L x - (heightSemisimpleAction T H x).toLinearMap
+  have hF (y : L) : F y = ⁅x, y⁆ - heightSemisimpleAction T H x y +
+      heightSemisimpleAction T H y x := cartanNilshadow_bracket T H x y
+  have hFh (y : L) : heightProjection T.character (F y) = 0 := by
+    rw [hF, map_add, map_sub, T.height_lie, heightSemisimpleAction_height_zero,
+      heightSemisimpleAction_height_zero, sub_self, add_zero]
+  have hFr (y : L) (hy : heightProjection T.character y = 0) : F y = A y := by
+    have hs : heightSemisimpleAction T H y = 0 := by
+      change cartanWeightDerivationLinear T H
+        (cartanHeightSection T H (heightProjection T.character y)) = 0
+      rw [hy, map_zero, map_zero]
+    rw [hF, hs, LieDerivation.zero_apply, add_zero]
+    rfl
+  have hFF : F * F = A * F := by
+    ext y
+    exact hFr (F y) (hFh y)
+  obtain ⟨k, hk⟩ := nilpotent_of_square_eq_mul (heightReducedAdjoint_nilpotent T H x) hFF
+  refine ⟨k, e.symm.conjRingEquiv.injective ?_⟩
+  rw [map_pow, map_zero]
+  exact hk
+
+end PolycyclicRecognition
+
+end
+
+end OAI

lean/OAI/GroupTheory/PolycyclicRecognition/Lattices/CompletedExtensionCentralizer.lean

@@ -0,0 +1,49 @@
+import OAI.GroupTheory.PolycyclicRecognition.Algebra.NilpotentExtensionLangSplitting
+import OAI.GroupTheory.PolycyclicRecognition.Algebra.ExtensionCentralizerKernel
+
+namespace OAI
+
+/-! # Semisimple centralizer reduction for the completed lattice extension -/
+
+noncomputable section
+namespace PolycyclicRecognition.NilpotentLatticeCoordinates
+open scoped Manifold ContDiff IsMulCommutative
+variable {N G Q : Type} [Group N] [Group G] [Group Q]
+  (C : NilpotentLatticeCoordinates N) (S : GroupExtension N G Q)
+  (σ : S.Section) (hσ : σ 1 = 1)
+
+theorem completedExtension_conjugation_smooth
+    (g : FactorExtension (C.extensionFactorSystem S σ hσ)) :
+    ContMDiff (𝓘(ℝ, C.carrier)) (𝓘(ℝ, C.carrier)) ∞
+      ((FactorExtension.groupExtension (C.extensionFactorSystem S σ hσ)).conjAct g) := by
+  rw [FactorExtension.conjugation_eq]
+  exact ((contMDiff_conjugation g.left).of_le (by simp)).comp
+    (C.extensionFactorSystem_smooth S σ hσ g.right)
+
+/-- No fixed-point-free condition: the actual centralizer surjects onto the
+whole original quotient, and its intersection with the kernel is explicit. -/
+theorem completedExtension_semisimple_centralizer [IsMulCommutative Q] (q : Q) :
+    ∃ T : C.carrier ≃ₗ⁅ℝ⁆ C.carrier, Module.End.IsSemisimple T.toLinearMap ∧
+      Function.Surjective
+        ((FactorExtension.groupExtension (C.extensionFactorSystem S σ hσ)).rightHom.comp
+          (semisimpleActionCentralizer
+            (FactorExtension.groupExtension (C.extensionFactorSystem S σ hσ)) T).subtype) ∧
+      ∀ x : C.carrier,
+        (FactorExtension.groupExtension (C.extensionFactorSystem S σ hσ)).inl x ∈
+          semisimpleActionCentralizer
+            (FactorExtension.groupExtension (C.extensionFactorSystem S σ hσ)) T ↔
+        ∃ z y : C.carrier, z ∈ Subgroup.center C.carrier ∧ T y = y ∧ x = z * y := by
+  let E := FactorExtension.groupExtension (C.extensionFactorSystem S σ hσ)
+  let t : FactorExtension (C.extensionFactorSystem S σ hσ) := ⟨1, q⟩
+  let hs := C.completedExtension_conjugation_smooth S σ hσ
+  let A := polynomialModelLieEquiv (E.conjAct t) (hs t)
+  obtain ⟨T, U, hT, hU, hTU, hA⟩ := real_lie_jordan_decomposition A
+  refine ⟨T, hT, extension_semisimple_centralizer_surjective E hs t T U hT hU hTU hA, ?_⟩
+  intro x
+  exact extension_semisimple_centralizer_kernel E T hT x
+
+end PolycyclicRecognition.NilpotentLatticeCoordinates
+
+end
+
+end OAI

lean/OAI/GroupTheory/PolycyclicRecognition/Lattices/CyclicCompletionHomUniqueness.lean

@@ -0,0 +1,64 @@
+import OAI.GroupTheory.PolycyclicRecognition.Geometry.NilpotentSemidirectGroup
+import OAI.GroupTheory.PolycyclicRecognition.Algebra.PolynomialOneParameterUniqueness
+
+namespace OAI
+
+/-! # Uniqueness of smooth homomorphisms from a real cyclic completion -/
+
+noncomputable section
+namespace PolycyclicRecognition
+open scoped Manifold ContDiff
+variable {L M : Type} [RealNormedLieAlgebra L] [FiniteDimensional ℝ L]
+  [RealNormedLieAlgebra M] [FiniteDimensional ℝ M]
+  [P : PolynomialExponentialCoordinates L] [Q : PolynomialExponentialCoordinates M]
+
+theorem cyclicCompletionHom_ext (D : LieDerivation ℝ L L) (hD : IsNilpotent D.toLinearMap) :
+    letI := derivationSemidirectGroup D hD
+    letI : MulOneClass (L × ℝ) := (derivationSemidirectGroup D hD).toMulOneClass
+    ∀ (φ ψ : (L × ℝ) →* M),
+      ContMDiff (𝓘(ℝ, L × ℝ)) (𝓘(ℝ, M)) ∞ φ →
+      ContMDiff (𝓘(ℝ, L × ℝ)) (𝓘(ℝ, M)) ∞ ψ →
+      (∀ x : L, φ (x, 0) = ψ (x, 0)) →
+      φ (0, 1) = ψ (0, 1) → φ = ψ := by
+  let := derivationSemidirectGroup D hD
+  let : Mul (L × ℝ) := (derivationSemidirectGroup D hD).toMul
+  let : One (L × ℝ) := (derivationSemidirectGroup D hD).toOne
+  let : Monoid (L × ℝ) := (derivationSemidirectGroup D hD).toMonoid
+  let : MulOneClass (L × ℝ) := (derivationSemidirectGroup D hD).toMulOneClass
+  intro φ ψ hφ hψ hk ht
+  have haxis (s t : ℝ) : ((0, s + t) : L × ℝ) =
+      (derivationSemidirectGroup D hD).mul (0, s) (0, t) := by
+    rw [derivationSemidirect_mul]
+    change (0, s + t) = (0 * nilpotentDerivationFlow D hD s 0, s + t)
+    rw [map_zero]
+    have hz : (0 : L) * 0 = 0 := by rw [← P.one_eq_zero, mul_one]
+    rw [hz]
+  have hφ0 : φ (0, 0) = 1 :=
+    (congrArg φ (derivationSemidirect_one D hD).symm).trans φ.map_one
+  have hψ0 : ψ (0, 0) = 1 :=
+    (congrArg ψ (derivationSemidirect_one D hD).symm).trans ψ.map_one
+  have htime (t : ℝ) : φ (0, t) = ψ (0, t) := by
+    rw [polynomial_oneParameter_eq_smul (fun r => φ (0, r)) hφ0
+      (fun s t => (congrArg φ (haxis s t)).trans (φ.map_mul _ _))
+      (hφ.contDiff.comp (contDiff_const.prodMk contDiff_id)),
+      polynomial_oneParameter_eq_smul (fun r => ψ (0, r)) hψ0
+      (fun s t => (congrArg ψ (haxis s t)).trans (ψ.map_mul _ _))
+      (hψ.contDiff.comp (contDiff_const.prodMk contDiff_id)), ht]
+  apply MonoidHom.ext
+  intro p
+  have hp : p = (derivationSemidirectGroup D hD).mul (p.1, 0) (0, p.2) := by
+    rw [derivationSemidirect_mul, map_zero]
+    change p = (p.1 * (0 : L), 0 + p.2)
+    rw [← P.one_eq_zero, mul_one, zero_add]
+  calc
+    φ p = φ ((derivationSemidirectGroup D hD).mul (p.1, 0) (0, p.2)) := congrArg φ hp
+    _ = φ (p.1, 0) * φ (0, p.2) := φ.map_mul _ _
+    _ = ψ (p.1, 0) * ψ (0, p.2) := by rw [hk, htime]
+    _ = ψ ((derivationSemidirectGroup D hD).mul (p.1, 0) (0, p.2)) := (ψ.map_mul _ _).symm
+    _ = ψ p := congrArg ψ hp.symm
+
+end PolycyclicRecognition
+
+end
+
+end OAI

lean/OAI/GroupTheory/PolycyclicRecognition/Lattices/DerivationSolvableModel.lean

@@ -0,0 +1,66 @@
+import OAI.GroupTheory.PolycyclicRecognition.Geometry.NilpotentSemidirectGroup
+import OAI.GroupTheory.PolycyclicRecognition.Lattices.SolvableLatticeModel
+import OAI.GroupTheory.PolycyclicRecognition.Geometry.CompactSemidirectModel
+import OAI.GroupTheory.PolycyclicRecognition.Lattices.UniformLatticeTransport
+import OAI.GroupTheory.PolycyclicRecognition.Lattices.SemidirectUniformLattice
+import Mathlib.Analysis.Convex.Contractible
+
+namespace OAI
+
+/-! # The solvable real model of a nilpotent derivation extension -/
+
+noncomputable section
+namespace PolycyclicRecognition
+open scoped Manifold
+variable {L : Type} [RealNormedLieAlgebra L] [FiniteDimensional ℝ L]
+  [P : PolynomialExponentialCoordinates L] [Group.IsSolvable L]
+  (D : LieDerivation ℝ L L) (hD : IsNilpotent D.toLinearMap)
+
+def derivationSolvableLieModel : SimplyConnectedSolvableLieModel := by
+  let g : Group (L × ℝ) := derivationSemidirectGroup D hD
+  let : Mul (L × ℝ) := g.toMul
+  let : One (L × ℝ) := g.toOne
+  let : Monoid (L × ℝ) := g.toMonoid
+  let : MulOneClass (L × ℝ) := g.toMulOneClass
+  let : Group (L × ℝ) := g
+  let : LieGroup (𝓘(ℝ, L × ℝ)) ⊤ (L × ℝ) := derivationSemidirectLieGroup D hD
+  let e : (L × ℝ) ≃* (L ⋊[P.derivationAction D hD] Multiplicative ℝ) :=
+    { derivationSemidirectEquiv D hD with map_mul' := fun _ _ => rfl }
+  let : Group.IsSolvable (L ⋊[P.derivationAction D hD] Multiplicative ℝ) :=
+    semidirect_solvable _
+  let : Group.IsSolvable (L × ℝ) :=
+    @Group.isSolvable_of_isSolvable_injective (L × ℝ)
+      (L ⋊[P.derivationAction D hD] Multiplicative ℝ)
+      g inferInstance e.toMonoidHom e.injective inferInstance
+  exact { modelSpace := L × ℝ, carrier := L × ℝ }
+
+def derivationModelEquiv : (derivationSolvableLieModel D hD).carrier ≃*
+    (L ⋊[P.derivationAction D hD] Multiplicative ℝ) :=
+  { derivationSemidirectEquiv D hD with map_mul' := fun _ _ => rfl }
+
+attribute [local instance] semidirectProductTopology
+
+theorem continuous_derivationModelEquiv : Continuous (derivationModelEquiv D hD) := by
+  change Continuous ((semidirectProductHomeomorph (P.derivationAction D hD)).symm ∘
+    (fun p : L × ℝ => (p.1, Multiplicative.ofAdd p.2)))
+  exact (semidirectProductHomeomorph _).symm.continuous.comp continuous_id
+
+theorem continuous_derivationModelEquiv_symm : Continuous (derivationModelEquiv D hD).symm := by
+  change Continuous ((fun p : L × Multiplicative ℝ => (p.1, p.2.toAdd)) ∘
+    (semidirectProductHomeomorph (P.derivationAction D hD)))
+  exact continuous_id.comp (semidirectProductHomeomorph _).continuous
+
+theorem derivationModel_lattice (Λ : Subgroup L) (Δ : Subgroup (Multiplicative ℝ))
+    (hstable : ∀ t ∈ Δ, ∀ x ∈ Λ, P.derivationAction D hD t x ∈ Λ)
+    (hΛ : IsUniformLattice Λ) (hΔ : IsUniformLattice Δ) :
+    IsUniformLattice ((semidirectLattice (P.derivationAction D hD) Λ Δ hstable).comap
+      (derivationModelEquiv D hD).toMonoidHom) := by
+  exact (semidirectLattice_uniform _ _ _ hstable hΛ hΔ).comap_mulEquiv
+    (derivationModelEquiv D hD) (continuous_derivationModelEquiv D hD)
+    (continuous_derivationModelEquiv_symm D hD)
+
+end PolycyclicRecognition
+
+end
+
+end OAI

lean/OAI/GroupTheory/PolycyclicRecognition/Lattices/ExtensionFixedCocycleSection.lean

@@ -0,0 +1,80 @@
+import OAI.GroupTheory.PolycyclicRecognition.Geometry.CentralizerLiftJordanFactor
+import OAI.GroupTheory.PolycyclicRecognition.Algebra.SemisimpleCocycleReduction
+import OAI.GroupTheory.PolycyclicRecognition.Algebra.GaugeExtensionSection
+
+namespace OAI
+
+/-! # A section with semisimple-fixed factors in the original extension
+
+Starting with an actual quotient lift, the semisimple centralizer still maps
+onto the quotient. Its moving central cocycle is removed by the constructed
+Lang correction, and the resulting section is returned in the original group.
+-/
+
+noncomputable section
+namespace PolycyclicRecognition
+open scoped Manifold ContDiff IsMulCommutative
+attribute [local instance] polynomialSubalgebraGroup
+variable {L G Q : Type} [RealNormedLieAlgebra L] [FiniteDimensional ℝ L]
+  [P : PolynomialExponentialCoordinates L] [LieRing.IsNilpotent L]
+  [Group G] [Group Q] [IsMulCommutative Q]
+
+theorem extension_exists_semisimple_fixed_cocycle_section (E : GroupExtension L G Q)
+    (hsmooth : ∀ g : G, ContMDiff (𝓘(ℝ, L)) (𝓘(ℝ, L)) ∞ (E.conjAct g))
+    (t : G) (S U : L ≃ₗ⁅ℝ⁆ L)
+    (hS : Module.End.IsSemisimple S.toLinearMap)
+    (hU : IsNilpotent (U.toLinearMap - 1))
+    (hSU : Commute S.toLinearMap U.toLinearMap)
+    (hA : (polynomialModelLieEquiv (E.conjAct t) (hsmooth t)).toLinearMap =
+      S.toLinearMap * U.toLinearMap) :
+    ∃ σ : E.Section, σ 1 = 1 ∧
+      (∀ q, σ q ∈ semisimpleActionCentralizer E S) ∧
+      ∀ q r, S (GroupExtensionSection.factor E σ q r) = GroupExtensionSection.factor E σ q r := by
+  have hsurj := extension_semisimple_centralizer_surjective E hsmooth t S U hS hU hSU hA
+  let D := semisimpleCentralizerExtension E S hsurj
+  let σ := normalizedExtensionSection D
+  have hσ : σ 1 = 1 := normalizedExtensionSection_one D
+  let F := GroupExtensionSection.factorSystem D σ hσ
+  let A := fun q => polynomialModelLieEquiv (E.conjAct (σ q : G)) (hsmooth (σ q))
+  have hSA : ∀ q, Commute S.toLinearMap (A q).toLinearMap := by
+    intro q
+    exact (mem_semisimpleActionCentralizer_iff E S (σ q) (hsmooth (σ q))).mp (σ q).property
+  have hact : ∀ q x, (F.action q x : L) = A q x := by
+    intro q x
+    change (D.conjAct (σ q) x : L) = A q x
+    rw [semisimpleCentralizerExtension_conjAct]
+    exact (polynomialModelLieEquiv_apply _ _ _).symm
+  have ht : t ∈ semisimpleActionCentralizer E S := by
+    apply (mem_semisimpleActionCentralizer_iff E S t (hsmooth t)).mpr
+    rw [hA]
+    exact (Commute.refl _).mul_right hSU
+  obtain ⟨W, hW, hSW, he⟩ := centralizer_same_fiber_jordan_factor E hsmooth S U t
+    (σ (E.rightHom t)) ht (σ _).property
+    (σ.rightHom_section (E.rightHom t)) hU hSU hA
+  obtain ⟨b, hb, hfixed⟩ := semisimple_cocycle_reduction S hS F A hSA hact
+    (E.rightHom t) W hW hSW he
+  let σb := GroupExtensionSection.gaugeSection D σ b
+  let θ : E.Section :=
+    { toFun q := (σb q : G)
+      rightInverse_rightHom q := σb.rightHom_section q }
+  refine ⟨θ, ?_, fun q => (σb q).property, ?_⟩
+  · exact congrArg Subtype.val (GroupExtensionSection.gaugeSection_one D σ hσ b hb)
+  · intro q r
+    have hfactor : ((GroupExtensionSection.factor D σb q r : innerCentralizerLieSubalgebra S) : L) =
+        GroupExtensionSection.factor E θ q r := by
+      apply E.inl_injective
+      have hh := congrArg Subtype.val (GroupExtensionSection.inl_factor D σb q r)
+      change E.inl ((GroupExtensionSection.factor D σb q r : innerCentralizerLieSubalgebra S) : L) =
+        (σb q : G) * (σb r : G) * (σb (q * r) : G)⁻¹ at hh
+      exact hh.trans (GroupExtensionSection.inl_factor E θ q r).symm
+    rw [← hfactor]
+    have heq := GroupExtensionSection.factor_gaugeSection D σ hσ b hb q r
+    change GroupExtensionSection.factor D σb q r = (F.gauge b hb).factor q r at heq
+    rw [heq]
+    exact hfixed q r
+
+end PolycyclicRecognition
+
+end
+
+end OAI

lean/OAI/GroupTheory/PolycyclicRecognition/Lattices/FiniteFixedCocycleSection.lean

@@ -0,0 +1,113 @@
+import OAI.GroupTheory.PolycyclicRecognition.Algebra.FiniteSemisimpleCocycleReduction
+import OAI.GroupTheory.PolycyclicRecognition.Lattices.ExtensionFixedCocycleSection
+import OAI.GroupTheory.PolycyclicRecognition.Algebra.SubgroupExtensionSection
+
+namespace OAI
+
+/-! # Simultaneously fixed section factors for finitely many quotient lifts
+
+The original extension has a normalized section centralizing a finite
+commuting semisimple family. All its factors are fixed by that entire family,
+and the specified quotient elements retain their semisimple Jordan factors.
+-/
+
+noncomputable section
+namespace PolycyclicRecognition
+open scoped Manifold ContDiff IsMulCommutative
+variable {L G Q : Type} [RealNormedLieAlgebra L] [FiniteDimensional ℝ L]
+  [P : PolynomialExponentialCoordinates L] [LieRing.IsNilpotent L]
+  [Group G] [Group Q] [IsMulCommutative Q]
+
+omit [LieRing.IsNilpotent L] [IsMulCommutative Q] in
+theorem inl_mem_semisimpleCentralizer_of_center (E : GroupExtension L G Q)
+    (S : L ≃ₗ⁅ℝ⁆ L) (x : L) (hx : x ∈ Subgroup.center L) :
+    E.inl x ∈ semisimpleActionCentralizer E S := by
+  have hi : MulAut.conj x = 1 := by
+    apply DFunLike.ext
+    intro y
+    change x * y * x⁻¹ = y
+    rw [← Subgroup.mem_center_iff.mp hx y]
+    group
+  change E.conjAct (E.inl x) ∈
+    Subgroup.centralizer {PolynomialExponentialCoordinates.groupAutomorphism (P := P) S}
+  rw [extension_conjAct_inl, hi]
+  exact Subgroup.one_mem _
+
+theorem exists_finite_fixed_cocycle_section (E : GroupExtension L G Q)
+    (hsmooth : ∀ g : G, ContMDiff (𝓘(ℝ, L)) (𝓘(ℝ, L)) ∞ (E.conjAct g)) (qs : List Q) :
+    ∃ ss : List (L ≃ₗ⁅ℝ⁆ L),
+      (∀ S ∈ ss, Module.End.IsSemisimple S.toLinearMap) ∧
+      (∀ S ∈ ss, ∀ T ∈ ss, Commute S.toLinearMap T.toLinearMap) ∧
+      ∃ σ : E.Section, σ 1 = 1 ∧
+        (∀ S ∈ ss, ∀ q, σ q ∈ semisimpleActionCentralizer E S) ∧
+        (∀ S ∈ ss, ∀ q r, S (GroupExtensionSection.factor E σ q r) =
+          GroupExtensionSection.factor E σ q r) ∧
+        ∀ q ∈ qs, ∃ S ∈ ss, ∃ U : L ≃ₗ⁅ℝ⁆ L,
+          IsNilpotent (U.toLinearMap - 1) ∧ Commute S.toLinearMap U.toLinearMap ∧
+          (polynomialModelLieEquiv (E.conjAct (σ q)) (hsmooth (σ q))).toLinearMap =
+            S.toLinearMap * U.toLinearMap := by
+  classical
+  obtain ⟨ss₀, hss₀, hpair₀, hsurj, hlifts⟩ := exists_finite_semisimple_lift_family E hsmooth qs
+  have hh : ∀ q : {q : Q // q ∈ qs}, ∃ g : G,
+      g ∈ commonSemisimpleCentralizer E ss₀ ∧ E.rightHom g = (q : Q) ∧
+      ∃ S ∈ ss₀, ∃ U : L ≃ₗ⁅ℝ⁆ L, IsNilpotent (U.toLinearMap - 1) ∧
+        Commute S.toLinearMap U.toLinearMap ∧
+        (polynomialModelLieEquiv (E.conjAct g) (hsmooth g)).toLinearMap =
+          S.toLinearMap * U.toLinearMap := fun q => hlifts q q.property
+  choose g hg hgq s hs u hu hsu hgu using hh
+  let ss := qs.attach.map s
+  have hmem (S : L ≃ₗ⁅ℝ⁆ L) (hS : S ∈ ss) : S ∈ ss₀ := by
+    obtain ⟨q, _, hq⟩ := List.mem_map.mp hS
+    rw [← hq]
+    exact hs q
+  obtain ⟨σ, hσ, hσH⟩ := exists_normalized_section_in_subgroup E
+    (commonSemisimpleCentralizer E ss₀) hsurj
+  have hσS : ∀ S ∈ ss₀, ∀ q, σ q ∈ semisimpleActionCentralizer E S :=
+    fun S hS q => (mem_commonSemisimpleCentralizer E ss₀ (σ q)).mp (hσH q) S hS
+  let F := GroupExtensionSection.factorSystem E σ hσ
+  let A := fun q => polynomialModelLieEquiv (E.conjAct (σ q)) (hsmooth (σ q))
+  have hact : ∀ q x, F.action q x = A q x :=
+    fun _ _ => (polynomialModelLieEquiv_apply _ _ _).symm
+  have hcomm : ∀ S ∈ ss, ∀ q, Commute S.toLinearMap (A q).toLinearMap := by
+    intro S hS q
+    exact (mem_semisimpleActionCentralizer_iff E S (σ q) (hsmooth (σ q))).mp
+      (hσS S (hmem S hS) q)
+  have hpair : ∀ S ∈ ss, ∀ T ∈ ss, Commute S.toLinearMap T.toLinearMap :=
+    fun S hS T hT => hpair₀ S (hmem S hS) T (hmem T hT)
+  have hsemisimple : ∀ S ∈ ss, Module.End.IsSemisimple S.toLinearMap :=
+    fun S hS => hss₀ S (hmem S hS)
+  have hlift : ∀ S ∈ ss, ∃ q₀ : Q, ∃ U : L ≃ₗ⁅ℝ⁆ L,
+      IsNilpotent (U.toLinearMap - 1) ∧ Commute S.toLinearMap U.toLinearMap ∧
+      (A q₀).toLinearMap = S.toLinearMap * U.toLinearMap := by
+    intro S hS
+    obtain ⟨q, _, hq⟩ := List.mem_map.mp hS
+    subst S
+    obtain ⟨W, hW, hsW, he⟩ := centralizer_same_fiber_jordan_factor E hsmooth (s q) (u q)
+      (g q) (σ q) ((mem_commonSemisimpleCentralizer E ss₀ _).mp (hg q) _ (hs q))
+      (hσS _ (hs q) q) ((σ.rightHom_section q).trans (hgq q).symm) (hu q) (hsu q) (hgu q)
+    exact ⟨q, W, hW, hsW, he⟩
+  obtain ⟨b, hb, hbZ, _, hfixed⟩ := finite_semisimple_cocycle_reduction F A hact ss
+    hsemisimple hpair hcomm hlift
+  let θ := GroupExtensionSection.gaugeSection E σ b
+  have hθS : ∀ S ∈ ss, ∀ q, θ q ∈ semisimpleActionCentralizer E S := by
+    intro S hS q
+    exact (semisimpleActionCentralizer E S).mul_mem
+      (inl_mem_semisimpleCentralizer_of_center E S (b q) (hbZ q)) (hσS S (hmem S hS) q)
+  refine ⟨ss, hsemisimple, hpair, θ, GroupExtensionSection.gaugeSection_one E σ hσ b hb,
+    hθS, ?_, ?_⟩
+  · intro S hS q r
+    rw [GroupExtensionSection.factor_gaugeSection E σ hσ b hb]
+    exact hfixed S hS q r
+  · intro q hq
+    let i : {q : Q // q ∈ qs} := ⟨q, hq⟩
+    have hi : s i ∈ ss := List.mem_map.mpr ⟨i, List.mem_attach _ _, rfl⟩
+    obtain ⟨W, hW, hsW, he⟩ := centralizer_same_fiber_jordan_factor E hsmooth (s i) (u i)
+      (g i) (θ q) ((mem_commonSemisimpleCentralizer E ss₀ _).mp (hg i) _ (hs i))
+      (hθS _ hi q) ((θ.rightHom_section q).trans (hgq i).symm) (hu i) (hsu i) (hgu i)
+    exact ⟨s i, hi, W, hW, hsW, he⟩
+
+end PolycyclicRecognition
+
+end
+
+end OAI

lean/OAI/GroupTheory/PolycyclicRecognition/Lattices/FreeAbelianCyclicLattice.lean

@@ -0,0 +1,57 @@
+import OAI.GroupTheory.PolycyclicRecognition.Algebra.AbelianRealSpace
+import OAI.GroupTheory.PolycyclicRecognition.Lattices.NilpotentCyclicLatticeExtension
+import Mathlib.Algebra.Group.Equiv.TypeTags
+
+namespace OAI
+
+/-! # Realizing nilpotent integral abelian-by-cyclic groups as Lie lattices
+
+The nilpotency class is unrestricted. The real action is constructed by the
+finite logarithm of the extended integral automorphism.
+-/
+
+noncomputable section
+namespace PolycyclicRecognition
+open scoped Manifold ContDiff
+variable {d : ℕ}
+
+def realIntegralGroupAut (a : MulAut (Multiplicative (Fin d → ℤ))) :
+    MulAut (AbelianRealSpace d) :=
+  { (realIntegralLinearEquiv a.toAdditive.toIntLinearEquiv).toEquiv with
+    map_mul' := fun x y => (realIntegralLinearEquiv a.toAdditive.toIntLinearEquiv).map_add x y }
+
+theorem contMDiff_realIntegralGroupAut (a : MulAut (Multiplicative (Fin d → ℤ))) :
+    ContMDiff (𝓘(ℝ, AbelianRealSpace d)) (𝓘(ℝ, AbelianRealSpace d)) ∞ (realIntegralGroupAut a) :=
+  (realIntegralLinearEquiv a.toAdditive.toIntLinearEquiv).toContinuousLinearEquiv.contDiff.contMDiff
+
+theorem realIntegralGroupAut_lattice (a : MulAut (Multiplicative (Fin d → ℤ)))
+    (x : Multiplicative (Fin d → ℤ)) :
+    realIntegralGroupAut a (abelianRealLatticeEquiv d x) =
+      (abelianRealLatticeEquiv d (a x) : AbelianRealSpace d) := by
+  rw [abelianRealLatticeEquiv_apply, abelianRealLatticeEquiv_apply]
+  exact realIntegralLinearEquiv_cast a.toAdditive.toIntLinearEquiv x.toAdd
+
+theorem freeAbelian_cyclic_nilpotent_lattice
+    (a : MulAut (Multiplicative (Fin d → ℤ)))
+    [Group.IsNilpotent (Multiplicative (Fin d → ℤ) ⋊[integerPowerAction a] Multiplicative ℤ)] :
+    ∃ (S : SimplyConnectedSolvableLieModel) (Γ : Subgroup S.carrier),
+      IsUniformLattice Γ ∧
+        Nonempty ((Multiplicative (Fin d → ℤ) ⋊[integerPowerAction a] Multiplicative ℤ) ≃* Γ) := by
+  let b : Module.Basis (Fin d) ℝ (AbelianRealSpace d) := Pi.basisFun ℝ (Fin d)
+  refine nilpotent_cyclic_lattice_extension a b id
+    (IsPolynomialInBasis.linear (LinearMap.id : AbelianRealSpace d →ₗ[ℝ] AbelianRealSpace d))
+    Function.surjective_id (abelianRealLattice d) (abelianRealLattice_uniform d)
+    (abelianRealLatticeEquiv d) ?_ (realIntegralGroupAut a)
+    (contMDiff_realIntegralGroupAut a) (realIntegralGroupAut_lattice a)
+  intro z
+  refine ⟨Multiplicative.ofAdd z, ?_⟩
+  rw [abelianRealLatticeEquiv_apply]
+  change (fun i => (z i : ℝ)) = (Pi.basisFun ℝ (Fin d)).equivFun.symm (fun i => (z i : ℝ))
+  rw [Pi.basisFun_equivFun]
+  rfl
+
+end PolycyclicRecognition
+
+end
+
+end OAI

lean/OAI/GroupTheory/PolycyclicRecognition/Lattices/IntegerCyclicHomExtension.lean

@@ -0,0 +1,63 @@
+import OAI.GroupTheory.PolycyclicRecognition.Lattices.NilpotentCyclicHomExtension
+import OAI.GroupTheory.PolycyclicRecognition.Algebra.UnipotentCyclicEmbedding
+import OAI.GroupTheory.PolycyclicRecognition.Algebra.PolynomialModelHom
+import OAI.GroupTheory.PolycyclicRecognition.Algebra.PolynomialModelWords
+
+namespace OAI
+
+/-! # The real cyclic completion extends the given integral homomorphism -/
+
+noncomputable section
+namespace PolycyclicRecognition
+open scoped Manifold ContDiff
+variable {L M : Type} [RealNormedLieAlgebra L] [FiniteDimensional ℝ L]
+  [RealNormedLieAlgebra M] [FiniteDimensional ℝ M]
+  [P : PolynomialExponentialCoordinates L] [Q : PolynomialExponentialCoordinates M]
+  [LieRing.IsNilpotent L] [LieRing.IsNilpotent M]
+
+theorem integer_cyclic_hom_extension (A : L ≃ₗ⁅ℝ⁆ L)
+    (hA : IsNilpotent (A.toLinearMap - 1)) (F : PolynomialCyclicGroup A →* M)
+    (hF : ContMDiff (𝓘(ℝ, L)) (𝓘(ℝ, M)) ∞ (F.comp SemidirectProduct.inl)) :
+    let D := unipotentLieLogarithm A hA
+    let hD := unipotentLieLogarithm_nilpotent A hA
+    letI := derivationSemidirectGroup D hD
+    letI : MulOneClass (L × ℝ) := (derivationSemidirectGroup D hD).toMulOneClass
+    ∃ φ : (L × ℝ) →* M, ContMDiff (𝓘(ℝ, L × ℝ)) (𝓘(ℝ, M)) ∞ φ ∧
+      ∀ z, φ (unipotentCyclicEmbedding A hA z) = F z := by
+  let k := F.comp SemidirectProduct.inl
+  let f := polynomialModelLieHom k hF
+  let t : PolynomialCyclicGroup A := SemidirectProduct.inr (Multiplicative.ofAdd (1 : ℤ))
+  let u := F t
+  have hf (x : L) : f x = F (SemidirectProduct.inl x) := polynomialModelLieHom_apply k hF x
+  have hconj (x : L) : f (A x) = u * f x * u⁻¹ := by
+    rw [hf, hf]
+    have hh := SemidirectProduct.inl_aut
+      (φ := integerPowerAction (PolynomialExponentialCoordinates.groupAutomorphism A))
+      (Multiplicative.ofAdd (1 : ℤ)) x
+    rw [map_inv] at hh
+    change SemidirectProduct.inl
+      (((PolynomialExponentialCoordinates.groupAutomorphism A) ^ (1 : ℤ)) x) =
+        t * SemidirectProduct.inl x * t⁻¹ at hh
+    have hh' := congrArg F hh
+    simpa only [zpow_one, PolynomialExponentialCoordinates.groupAutomorphism_apply,
+      map_mul, map_inv] using hh'
+  obtain ⟨φ, hφ, hφx⟩ := nilpotent_cyclic_hom_extension A hA f u hconj
+  refine ⟨φ, hφ, ?_⟩
+  intro z
+  rw [unipotentCyclicEmbedding_apply, hφx, hf]
+  have hz : (SemidirectProduct.inr z.right : PolynomialCyclicGroup A) = t ^ z.right.toAdd := by
+    rw [← map_zpow]
+    congr 1
+    apply Multiplicative.ext
+    change z.right.toAdd = z.right.toAdd • (1 : ℤ)
+    simp
+  rw [← model_zpow, ← map_zpow, ← hz]
+  rw [← map_mul]
+  congr 1
+  exact (SemidirectProduct.mk_eq_inl_mul_inr z.right z.left).symm
+
+end PolycyclicRecognition
+
+end
+
+end OAI

lean/OAI/GroupTheory/PolycyclicRecognition/Lattices/IntegerSemidirectLattice.lean

@@ -0,0 +1,129 @@
+import OAI.GroupTheory.PolycyclicRecognition.Lattices.RealActionIntegerLattice
+
+namespace OAI
+
+/-! # The integral semidirect product is the lattice in its real extension -/
+
+noncomputable section
+namespace PolycyclicRecognition
+variable {H N : Type*} [Group H] [Group N]
+
+def integerPowerAction (a : MulAut H) : Multiplicative ℤ →* MulAut H where
+  toFun n := a ^ n.toAdd
+  map_one' := zpow_zero a
+  map_mul' n m := zpow_add a n.toAdd m.toAdd
+
+def integerTimeHom : Multiplicative ℤ →* Multiplicative ℝ where
+  toFun n := Multiplicative.ofAdd (n.toAdd : ℝ)
+  map_one' := by apply Multiplicative.ext; exact Int.cast_zero
+  map_mul' n m := by apply Multiplicative.ext; exact Int.cast_add _ _
+
+theorem integerTimeHom_injective : Function.Injective integerTimeHom := by
+  intro n m h
+  apply Multiplicative.ext
+  have he : (n.toAdd : ℝ) = (m.toAdd : ℝ) := congrArg Multiplicative.toAdd h
+  exact_mod_cast he
+
+theorem realAction_int (φ : Multiplicative ℝ →* MulAut N) (n : ℤ) :
+    φ (Multiplicative.ofAdd (n : ℝ)) = φ (Multiplicative.ofAdd 1) ^ n := by
+  have he : (Multiplicative.ofAdd (1 : ℝ)) ^ n = Multiplicative.ofAdd (n : ℝ) := by
+    apply Multiplicative.ext
+    change n • (1 : ℝ) = (n : ℝ)
+    simp
+  rw [← he, map_zpow]
+
+theorem mulAut_zpow_semiconj (a : MulAut H) (b : MulAut N) (e : H → N)
+    (he : ∀ x, e (a x) = b (e x)) (n : ℤ) (x : H) :
+    e ((a ^ n) x) = (b ^ n) (e x) := by
+  have hi (y : H) : e (a.symm y) = b.symm (e y) := by
+    apply b.injective
+    rw [← he, a.apply_symm_apply, b.apply_symm_apply]
+  have hp (a' : MulAut H) (b' : MulAut N) (h : ∀ y, e (a' y) = b' (e y)) (k : ℕ) :
+      ∀ y, e ((a' ^ k) y) = (b' ^ k) (e y) := by
+    induction k with
+    | zero => exact fun _ => rfl
+    | succ k ih =>
+      intro y
+      rw [pow_succ', pow_succ']
+      change e (a' ((a' ^ k) y)) = b' ((b' ^ k) (e y))
+      rw [h, ih]
+  cases n with
+  | ofNat n => exact hp a b he n x
+  | negSucc n =>
+    change e ((a ^ (-((n + 1 : ℕ) : ℤ))) x) = (b ^ (-((n + 1 : ℕ) : ℤ))) (e x)
+    rw [zpow_neg, zpow_neg, zpow_natCast, zpow_natCast, ← inv_pow, ← inv_pow]
+    exact hp a.symm b.symm hi (n + 1) x
+
+def realIntegerSemidirectMap (φ : Multiplicative ℝ →* MulAut N) (a : MulAut H)
+    (e : H →* N) (he : ∀ x, e (a x) = φ (Multiplicative.ofAdd 1) (e x)) :
+    (H ⋊[integerPowerAction a] Multiplicative ℤ) →* (N ⋊[φ] Multiplicative ℝ) :=
+  SemidirectProduct.map e integerTimeHom (by
+    intro n
+    ext x
+    change e ((a ^ n.toAdd) x) = φ (Multiplicative.ofAdd (n.toAdd : ℝ)) (e x)
+    rw [realAction_int]
+    exact mulAut_zpow_semiconj a _ e he n.toAdd x)
+
+theorem realIntegerSemidirectMap_injective
+    (φ : Multiplicative ℝ →* MulAut N) (a : MulAut H)
+    (e : H →* N) (he : ∀ x, e (a x) = φ (Multiplicative.ofAdd 1) (e x))
+    (hej : Function.Injective e) : Function.Injective (realIntegerSemidirectMap φ a e he) := by
+  intro x y h
+  apply SemidirectProduct.ext
+  · exact hej (congrArg SemidirectProduct.left h)
+  · exact integerTimeHom_injective (congrArg SemidirectProduct.right h)
+
+variable [TopologicalSpace N]
+attribute [local instance] semidirectProductTopology
+
+theorem integer_semidirect_lattice_realization_with_coordinates
+    (φ : Multiplicative ℝ →* MulAut N) (a : MulAut H)
+    (Λ : Subgroup N) (hΛ : IsUniformLattice Λ) (e : H ≃* Λ)
+    (he : ∀ x, (e (a x) : N) = φ (Multiplicative.ofAdd 1) (e x)) :
+    ∃ Γ : Subgroup (N ⋊[φ] Multiplicative ℝ), IsUniformLattice Γ ∧
+      ∃ f : (H ⋊[integerPowerAction a] Multiplicative ℤ) ≃* Γ,
+        ∀ x, (f x : N ⋊[φ] Multiplicative ℝ) =
+          realIntegerSemidirectMap φ a (Λ.subtype.comp e.toMonoidHom) he x := by
+  let j : H →* N := Λ.subtype.comp e.toMonoidHom
+  have hstable : ∀ t ∈ integerTimeLattice, ∀ x ∈ Λ, φ t x ∈ Λ := by
+    intro t ht x hx
+    obtain ⟨n, rfl⟩ := integerTimeLattice_exists ht
+    obtain ⟨y, hy⟩ := e.surjective ⟨x, hx⟩
+    have hj : j y = x := congrArg Subtype.val hy
+    rw [← hj, realAction_int, ← mulAut_zpow_semiconj a _ j he]
+    exact (e ((a ^ n) y)).property
+  let Γ := semidirectLattice φ Λ integerTimeLattice hstable
+  let f := realIntegerSemidirectMap φ a j he
+  have hf (x) : f x ∈ Γ := ⟨(e x.left).property, integerTimeLattice_mem x.right.toAdd⟩
+  let f' : (H ⋊[integerPowerAction a] Multiplicative ℤ) →* Γ := f.codRestrict Γ hf
+  have hinj : Function.Injective f' := by
+    intro x y h
+    exact realIntegerSemidirectMap_injective φ a j he
+      (Λ.subtype_injective.comp e.injective) (congrArg Subtype.val h)
+  have hsurj : Function.Surjective f' := by
+    intro z
+    obtain ⟨x, hx⟩ := e.surjective ⟨z.val.left, z.property.1⟩
+    obtain ⟨n, hn⟩ := integerTimeLattice_exists z.property.2
+    refine ⟨⟨x, Multiplicative.ofAdd n⟩, ?_⟩
+    apply Subtype.ext
+    apply SemidirectProduct.ext
+    · exact congrArg Subtype.val hx
+    · exact hn.symm
+  exact ⟨Γ, semidirectLattice_uniform φ Λ integerTimeLattice hstable hΛ
+    integerTimeLattice_uniform, MulEquiv.ofBijective f' ⟨hinj, hsurj⟩, fun _ => rfl⟩
+
+theorem integer_semidirect_lattice_realization
+    (φ : Multiplicative ℝ →* MulAut N) (a : MulAut H)
+    (Λ : Subgroup N) (hΛ : IsUniformLattice Λ) (e : H ≃* Λ)
+    (he : ∀ x, (e (a x) : N) = φ (Multiplicative.ofAdd 1) (e x)) :
+    ∃ Γ : Subgroup (N ⋊[φ] Multiplicative ℝ), IsUniformLattice Γ ∧
+      Nonempty ((H ⋊[integerPowerAction a] Multiplicative ℤ) ≃* Γ) := by
+  obtain ⟨Γ, hΓ, f, _⟩ :=
+    integer_semidirect_lattice_realization_with_coordinates φ a Λ hΛ e he
+  exact ⟨Γ, hΓ, ⟨f⟩⟩
+
+end PolycyclicRecognition
+
+end
+
+end OAI

lean/OAI/GroupTheory/PolycyclicRecognition/Lattices/IntegerTimeLattice.lean

@@ -0,0 +1,48 @@
+import OAI.GroupTheory.PolycyclicRecognition.Lattices.UniformLatticeMetric
+import Mathlib.Topology.Instances.ZMultiples
+import Mathlib.Algebra.Group.TypeTags.Basic
+
+namespace OAI
+
+/-! # The integer time lattice in the real one-parameter group -/
+
+noncomputable section
+namespace PolycyclicRecognition
+open Set
+
+def integerTimeLattice : Subgroup (Multiplicative ℝ) :=
+  (AddSubgroup.zmultiples (1 : ℝ)).toSubgroup
+
+theorem integerTimeLattice_mem (n : ℤ) :
+    Multiplicative.ofAdd (n : ℝ) ∈ integerTimeLattice := by
+  change (n : ℝ) ∈ AddSubgroup.zmultiples (1 : ℝ)
+  exact AddSubgroup.mem_zmultiples_iff.mpr ⟨n, by simp⟩
+
+theorem integerTimeLattice_exists {x : Multiplicative ℝ} (hx : x ∈ integerTimeLattice) :
+    ∃ n : ℤ, x = Multiplicative.ofAdd (n : ℝ) := by
+  change x.toAdd ∈ AddSubgroup.zmultiples (1 : ℝ) at hx
+  obtain ⟨n, hn⟩ := AddSubgroup.mem_zmultiples_iff.mp hx
+  refine ⟨n, ?_⟩
+  apply Multiplicative.ext
+  simpa using hn.symm
+
+theorem integerTimeLattice_uniform : IsUniformLattice integerTimeLattice := by
+  have hd : DiscreteTopology integerTimeLattice := by
+    change DiscreteTopology (AddSubgroup.zmultiples (1 : ℝ))
+    infer_instance
+  refine ⟨hd, Multiplicative.ofAdd '' Icc (0 : ℝ) 1,
+    isCompact_Icc.image (show Continuous (Multiplicative.ofAdd : ℝ → Multiplicative ℝ)
+      from continuous_id), ?_⟩
+  intro x
+  refine ⟨⟨Multiplicative.ofAdd (⌊x.toAdd⌋ : ℝ), integerTimeLattice_mem _⟩,
+    Multiplicative.ofAdd (Int.fract x.toAdd), ?_, ?_⟩
+  · exact ⟨Int.fract x.toAdd, ⟨Int.fract_nonneg _, (Int.fract_lt_one _).le⟩, rfl⟩
+  · apply Multiplicative.ext
+    change (⌊x.toAdd⌋ : ℝ) + (x.toAdd - (⌊x.toAdd⌋ : ℝ)) = x.toAdd
+    abel
+
+end PolycyclicRecognition
+
+end
+
+end OAI

lean/OAI/GroupTheory/PolycyclicRecognition/Lattices/IntegralBilinearLattice.lean

@@ -0,0 +1,63 @@
+import OAI.GroupTheory.PolycyclicRecognition.Analysis.IntegralBilinearExtension
+
+namespace OAI
+
+/-! # The Lie lattice attached to an integral bilinear group law -/
+
+noncomputable section
+namespace PolycyclicRecognition
+
+variable {d e : ℕ} (a : Fin e → Fin d → Fin d → ℤ)
+
+def integralBilinearEmbedding : BilinearCentralGroup (coefficientBilinear a) →*
+    (bilinearCentralLieModel (realCoefficientBilinear a)).carrier where
+  toFun x := (integerVectorMap d x.1, integerVectorMap e x.2)
+  map_one' := by apply Prod.ext <;> exact map_zero _
+  map_mul' x y := by
+    apply Prod.ext
+    · exact map_add _ _ _
+    · change integerVectorMap e (x.2 + y.2 + coefficientBilinear a x.1 y.1) =
+        integerVectorMap e x.2 + integerVectorMap e y.2 +
+          realCoefficientBilinear a (integerVectorMap d x.1) (integerVectorMap d y.1)
+      rw [map_add, map_add, realCoefficientBilinear_cast]
+
+theorem integralBilinearEmbedding_injective : Function.Injective (integralBilinearEmbedding a) := by
+  intro x y h
+  exact Prod.ext (integerVectorMap_injective d (congrArg Prod.fst h))
+    (integerVectorMap_injective e (congrArg Prod.snd h))
+
+def integralBilinearLattice :
+    Subgroup (bilinearCentralLieModel (realCoefficientBilinear a)).carrier :=
+  bilinearCentralLattice (Pi.basisFun ℝ (Fin d)) (Pi.basisFun ℝ (Fin e))
+    (realCoefficientBilinear a) (realCoefficientBilinear_integral a)
+
+theorem integralBilinearLattice_uniform : IsUniformLattice (integralBilinearLattice a) :=
+  bilinearCentralLattice_uniform _ _ _ _
+
+def integralBilinearLatticeEquiv :
+    BilinearCentralGroup (coefficientBilinear a) ≃* integralBilinearLattice a := by
+  let f : BilinearCentralGroup (coefficientBilinear a) →* integralBilinearLattice a :=
+    (integralBilinearEmbedding a).codRestrict _ (fun x =>
+      ⟨integerVectorMap_mem d x.1, integerVectorMap_mem e x.2⟩)
+  apply MulEquiv.ofBijective f
+  constructor
+  · intro x y h
+    exact integralBilinearEmbedding_injective a (congrArg Subtype.val h)
+  · intro x
+    obtain ⟨u, hu⟩ := exists_integerVectorMap_of_mem d x.val.1 x.property.1
+    obtain ⟨v, hv⟩ := exists_integerVectorMap_of_mem e x.val.2 x.property.2
+    refine ⟨(u, v), ?_⟩
+    apply Subtype.ext
+    exact Prod.ext hu hv
+
+theorem integralBilinear_solvable_realization :
+    ∃ (S : SimplyConnectedSolvableLieModel) (Λ : Subgroup S.carrier),
+      IsUniformLattice Λ ∧ Nonempty (BilinearCentralGroup (coefficientBilinear a) ≃* Λ) :=
+  ⟨bilinearCentralLieModel (realCoefficientBilinear a), integralBilinearLattice a,
+    integralBilinearLattice_uniform a, ⟨integralBilinearLatticeEquiv a⟩⟩
+
+end PolycyclicRecognition
+
+end
+
+end OAI

lean/OAI/GroupTheory/PolycyclicRecognition/Lattices/IntegralLatticeGenerators.lean

@@ -0,0 +1,69 @@
+import OAI.GroupTheory.PolycyclicRecognition.Analysis.IntegralLinearExtension
+
+namespace OAI
+
+/-! # Coordinate generators and the standard embedding of the integral lattice -/
+
+noncomputable section
+namespace PolycyclicRecognition
+
+def integralLatticeGenerator (n : ℕ) (i : Fin n) : IntegralLatticeGroup n :=
+  Multiplicative.ofAdd ((Pi.basisFun ℤ (Fin n)) i)
+
+theorem integralLatticeGenerator_prod (n : ℕ) (z : IntegralLatticeGroup n) :
+    (∏ i, integralLatticeGenerator n i ^ z.toAdd i) = z := by
+  apply Multiplicative.toAdd.injective
+  simpa only [toAdd_prod, toAdd_zpow, integralLatticeGenerator, toAdd_ofAdd,
+    Pi.basisFun_equivFun, LinearEquiv.refl_apply] using
+    (Pi.basisFun ℤ (Fin n)).sum_equivFun z.toAdd
+
+theorem integralLatticeGenerator_closure (n : ℕ) :
+    Subgroup.closure (Set.range (integralLatticeGenerator n)) = ⊤ := by
+  apply top_unique
+  intro z _
+  rw [← integralLatticeGenerator_prod n z]
+  exact Subgroup.prod_mem _ fun i _ => Subgroup.zpow_mem _
+    (Subgroup.subset_closure (Set.mem_range_self i)) _
+
+theorem integralLattice_hom_ext {n : ℕ} {K : Type*} [Group K]
+    {f g : IntegralLatticeGroup n →* K}
+    (h : ∀ i, f (integralLatticeGenerator n i) = g (integralLatticeGenerator n i)) : f = g := by
+  apply MonoidHom.eq_of_eqOn_dense (integralLatticeGenerator_closure n)
+  rintro _ ⟨i, rfl⟩
+  exact h i
+
+def integerVectorHom (n : ℕ) : IntegralLatticeGroup n →* Multiplicative (Fin n → ℝ) where
+  toFun z := Multiplicative.ofAdd (integerVectorMap n z.toAdd)
+  map_one' := by apply Multiplicative.ext; exact (integerVectorMap n).map_zero
+  map_mul' z w := by apply Multiplicative.ext; exact (integerVectorMap n).map_add z.toAdd w.toAdd
+
+theorem integerVectorHom_injective (n : ℕ) : Function.Injective (integerVectorHom n) := by
+  intro z w h
+  exact Multiplicative.ext (integerVectorMap_injective n (congrArg Multiplicative.toAdd h))
+
+def integerVectorRangeEquiv (n : ℕ) : IntegralLatticeGroup n ≃* (integerVectorHom n).range :=
+  MulEquiv.ofBijective (integerVectorHom n).rangeRestrict
+    ⟨fun _ _ h => integerVectorHom_injective n (congrArg Subtype.val h),
+      (integerVectorHom n).rangeRestrict_surjective⟩
+
+theorem integerVectorHom_range (n : ℕ) : (integerVectorHom n).range = standardVectorLattice n := by
+  ext x
+  change (∃ z : IntegralLatticeGroup n,
+    Multiplicative.ofAdd (integerVectorMap n z.toAdd) = x) ↔
+      x.toAdd ∈ Submodule.span ℤ (Set.range (Pi.basisFun ℝ (Fin n)))
+  constructor
+  · rintro ⟨z, rfl⟩
+    exact integerVectorMap_mem n z.toAdd
+  · intro hx
+    obtain ⟨z, hz⟩ := exists_integerVectorMap_of_mem n x.toAdd hx
+    exact ⟨Multiplicative.ofAdd z, Multiplicative.ext hz⟩
+
+theorem integerVectorHom_uniform (n : ℕ) : IsUniformLattice (integerVectorHom n).range := by
+  rw [integerVectorHom_range]
+  exact standardVectorLattice_uniform n
+
+end PolycyclicRecognition
+
+end
+
+end OAI

lean/OAI/GroupTheory/PolycyclicRecognition/Lattices/IntegralLatticePowerIndex.lean

@@ -0,0 +1,91 @@
+import OAI.GroupTheory.PolycyclicRecognition.Lattices.IntegralLatticeGenerators
+import OAI.GroupTheory.PolycyclicRecognition.Algebra.CyclicPowerIndex
+
+namespace OAI
+
+/-! # Finite-index powers in an integral vector lattice -/
+
+noncomputable section
+namespace PolycyclicRecognition
+
+def latticePowerHom (n m : ℕ) : IntegralLatticeGroup n →* IntegralLatticeGroup n where
+  toFun z := z ^ m
+  map_one' := one_pow m
+  map_mul' z w := (Commute.all z w).mul_pow m
+
+def latticeCoordinateHom (n : ℕ) (i : Fin n) : IntegralLatticeGroup n →* Multiplicative ℤ where
+  toFun z := Multiplicative.ofAdd (z.toAdd i)
+  map_one' := rfl
+  map_mul' _ _ := rfl
+
+theorem latticePowerHom_injective (n : ℕ) {m : ℕ} (hm : 0 < m) :
+    Function.Injective (latticePowerHom n m) := by
+  intro z w h
+  apply Multiplicative.ext
+  funext i
+  have hi := congrArg (fun a : IntegralLatticeGroup n => a.toAdd i) h
+  change (m : ℤ) * z.toAdd i = (m : ℤ) * w.toAdd i at hi
+  exact mul_left_cancel₀ (by exact_mod_cast Nat.ne_of_gt hm) hi
+
+theorem latticePowerHom_range (n m : ℕ) :
+    (latticePowerHom n m).range =
+      ⨅ i, (integerScaleHom m).range.comap (latticeCoordinateHom n i) := by
+  ext z
+  simp only [Subgroup.mem_iInf, Subgroup.mem_comap, MonoidHom.mem_range]
+  constructor
+  · rintro ⟨w, rfl⟩ i
+    exact ⟨Multiplicative.ofAdd (w.toAdd i), rfl⟩
+  · intro h
+    choose w hw using h
+    refine ⟨Multiplicative.ofAdd (fun i => (w i).toAdd), ?_⟩
+    apply Multiplicative.ext
+    funext i
+    exact congrArg Multiplicative.toAdd (hw i)
+
+theorem latticePowerHom_finiteIndex (n : ℕ) {m : ℕ} (hm : 0 < m) :
+    (latticePowerHom n m).range.FiniteIndex := by
+  let := integerScaleHom_range_finiteIndex hm
+  rw [latticePowerHom_range]
+  apply Subgroup.finiteIndex_iInf
+  intro i
+  infer_instance
+
+variable {H : Type} [Group H]
+
+def integralSemidirectPowerMap {n : ℕ} (ρ : IntegralLatticeGroup n →* MulAut H) (m : ℕ) :
+    (H ⋊[ρ.comp (latticePowerHom n m)] IntegralLatticeGroup n) →*
+      (H ⋊[ρ] IntegralLatticeGroup n) :=
+  SemidirectProduct.map (MonoidHom.id H) (latticePowerHom n m) (by intros; rfl)
+
+theorem integralSemidirectPowerMap_injective {n m : ℕ} (ρ : IntegralLatticeGroup n →* MulAut H)
+    (hm : 0 < m) : Function.Injective (integralSemidirectPowerMap ρ m) := by
+  intro x y h
+  apply SemidirectProduct.ext
+  · exact congrArg (fun z : H ⋊[ρ] IntegralLatticeGroup n => z.left) h
+  · exact latticePowerHom_injective n hm
+      (congrArg (fun z : H ⋊[ρ] IntegralLatticeGroup n => z.right) h)
+
+theorem integralSemidirectPowerMap_range {n : ℕ} (ρ : IntegralLatticeGroup n →* MulAut H) (m : ℕ) :
+    (integralSemidirectPowerMap ρ m).range =
+      (latticePowerHom n m).range.comap SemidirectProduct.rightHom := by
+  ext g
+  constructor
+  · rintro ⟨x, rfl⟩
+    exact ⟨x.right, rfl⟩
+  · rintro ⟨v, hv⟩
+    refine ⟨⟨g.left, v⟩, ?_⟩
+    apply SemidirectProduct.ext
+    · rfl
+    · exact hv
+
+theorem integralSemidirectPowerMap_finiteIndex {n m : ℕ} (ρ : IntegralLatticeGroup n →* MulAut H)
+    (hm : 0 < m) : (integralSemidirectPowerMap ρ m).range.FiniteIndex := by
+  let := latticePowerHom_finiteIndex n hm
+  rw [integralSemidirectPowerMap_range]
+  infer_instance
+
+end PolycyclicRecognition
+
+end
+
+end OAI

lean/OAI/GroupTheory/PolycyclicRecognition/Lattices/IntegralNilshadow.lean

@@ -0,0 +1,113 @@
+import OAI.GroupTheory.PolycyclicRecognition.Analysis.IntegralSemisimpleTwist
+import OAI.GroupTheory.PolycyclicRecognition.Algebra.UnipotentFactorSystem
+import OAI.GroupTheory.PolycyclicRecognition.Lattices.KernelCompletionAction
+import OAI.GroupTheory.PolycyclicRecognition.Algebra.FactorSystemTwistAction
+
+namespace OAI
+
+/-! # Constructing the nilshadow of an integral abelian extension
+
+Both the section and the removed action are constructed from the original
+extension. The twisted group has a nilpotent real completion of the correct
+dimension. Its removed action extends, and the original group embeds faithfully
+in the corresponding semidirect product. The quotient here is still integral.
+-/
+
+noncomputable section
+namespace PolycyclicRecognition
+open scoped Manifold ContDiff
+variable {L G : Type} [RealNormedLieAlgebra L] [FiniteDimensional ℝ L]
+  [P : PolynomialExponentialCoordinates L] [LieRing.IsNilpotent L] [Group G] {n : ℕ}
+
+structure IntegralNilshadowData (E : GroupExtension L G (IntegralLatticeGroup n)) where
+  sectionMap : E.Section
+  normalized : sectionMap 1 = 1
+  removed : IntegralLatticeGroup n →* MulAut L
+  commutes : ∀ q r, Commute
+    ((GroupExtensionSection.factorSystem E sectionMap normalized).action q) (removed r)
+  fixes : ∀ q r s, removed q
+    ((GroupExtensionSection.factorSystem E sectionMap normalized).factor r s) =
+      (GroupExtensionSection.factorSystem E sectionMap normalized).factor r s
+  smooth : ∀ q, ContMDiff (𝓘(ℝ, L)) (𝓘(ℝ, L)) ∞ (removed q)
+  twist_smooth : ∀ q, ContMDiff (𝓘(ℝ, L)) (𝓘(ℝ, L)) ∞
+    (((GroupExtensionSection.factorSystem E sectionMap normalized).twist removed commutes fixes).action q)
+  twist_nilpotent : Group.IsNilpotent (FactorExtension
+    ((GroupExtensionSection.factorSystem E sectionMap normalized).twist removed commutes fixes))
+  completion : NilpotentKernelCompletion (FactorExtension.inl
+    ((GroupExtensionSection.factorSystem E sectionMap normalized).twist removed commutes fixes))
+  dimension : completion.dimension = Module.finrank ℝ L + n
+
+theorem exists_integralNilshadowData (E : GroupExtension L G (IntegralLatticeGroup n))
+    (hsmooth : ∀ g : G, ContMDiff (𝓘(ℝ, L)) (𝓘(ℝ, L)) ∞ (E.conjAct g)) :
+    Nonempty (IntegralNilshadowData E) := by
+  obtain ⟨σ, hσ, χ, hc, hf, hχ, hT, hu⟩ := integral_semisimple_twist E hsmooth
+  let R := GroupExtensionSection.factorSystem E σ hσ
+  let T := R.twist χ hc hf
+  let qs := List.ofFn (integralLatticeGenerator n)
+  have hgen : Subgroup.closure {q | q ∈ qs} = ⊤ := by
+    convert integralLatticeGenerator_closure n using 2
+    ext q
+    exact List.mem_ofFn
+  have hnil : Group.IsNilpotent (FactorExtension T) :=
+    factorSystem_nilpotent_of_unipotent T hT qs hgen (by
+      intro q hq
+      obtain ⟨i, rfl⟩ := List.mem_ofFn.mp hq
+      exact hu i)
+  let := hnil
+  obtain ⟨C, hC⟩ := nilpotent_integral_kernel_completion_with_dimension
+    (FactorExtension.groupExtension T) (factorSystem_conjugation_smooth T hT)
+  exact ⟨⟨σ, hσ, χ, hc, hf, hχ, hT, hnil, C, hC⟩⟩
+
+namespace IntegralNilshadowData
+variable {E : GroupExtension L G (IntegralLatticeGroup n)} (D : IntegralNilshadowData E)
+omit [LieRing.IsNilpotent L]
+
+abbrev system := GroupExtensionSection.factorSystem E D.sectionMap D.normalized
+abbrev twistedSystem := D.system.twist D.removed D.commutes D.fixes
+abbrev integralAction := factorTwistAction D.system D.removed D.commutes D.fixes
+
+theorem integralAction_kernel_smooth (q : IntegralLatticeGroup n) :
+    ContMDiff (𝓘(ℝ, L)) (𝓘(ℝ, D.completion.carrier)) ∞
+      ((D.completion.embed.comp (D.integralAction q).toMonoidHom).comp
+        (FactorExtension.inl D.twistedSystem)) := by
+  exact D.completion.kernel_smooth.comp (D.smooth q)
+
+def completedAction : IntegralLatticeGroup n →* MulAut D.completion.carrier :=
+  D.completion.extendedAction D.integralAction D.integralAction_kernel_smooth
+
+theorem completedAction_smooth (q : IntegralLatticeGroup n) :
+    ContMDiff (𝓘(ℝ, D.completion.carrier)) (𝓘(ℝ, D.completion.carrier)) ∞ (D.completedAction q) :=
+  D.completion.extendedAction_smooth D.integralAction D.integralAction_kernel_smooth q
+
+def completionSemidirectMap :
+    (FactorExtension D.twistedSystem ⋊[D.integralAction] IntegralLatticeGroup n) →*
+      (D.completion.carrier ⋊[D.completedAction] IntegralLatticeGroup n) :=
+  SemidirectProduct.map D.completion.embed (MonoidHom.id _) (by
+    intro q
+    apply MonoidHom.ext
+    intro x
+    exact (D.completion.extendedAction_embed D.integralAction
+      D.integralAction_kernel_smooth q x).symm)
+
+def originalEmbedding : G →*
+    (D.completion.carrier ⋊[D.completedAction] IntegralLatticeGroup n) :=
+  D.completionSemidirectMap.comp
+    ((factorTwistGraph D.system D.removed D.commutes D.fixes).comp
+      (GroupExtensionSection.mulEquiv E D.sectionMap D.normalized).toMonoidHom)
+
+theorem originalEmbedding_injective : Function.Injective D.originalEmbedding := by
+  have hC : Function.Injective D.completionSemidirectMap := by
+    intro a b h
+    apply SemidirectProduct.ext
+    · apply D.completion.injective
+      exact congrArg (fun z => z.left) h
+    · exact congrArg (fun z => z.right) h
+  exact hC.comp ((factorTwistGraph_injective D.system D.removed D.commutes D.fixes).comp
+    (GroupExtensionSection.mulEquiv E D.sectionMap D.normalized).injective)
+
+end IntegralNilshadowData
+end PolycyclicRecognition
+
+end
+
+end OAI

lean/OAI/GroupTheory/PolycyclicRecognition/Lattices/JointFixedActionFiltration.lean

@@ -0,0 +1,60 @@
+import OAI.GroupTheory.PolycyclicRecognition.Lattices.JointFixedReductionData
+import OAI.GroupTheory.PolycyclicRecognition.Algebra.PolynomialSubalgebraFiltration
+
+namespace OAI
+
+/-! # The residual quotient actions commute on lower-central factors
+
+The two orders of quotient lifts differ by inner automorphisms. Intrinsic BCH
+commutator estimates make both inner corrections disappear on the next Lie
+lower-central quotient.
+-/
+
+noncomputable section
+namespace PolycyclicRecognition
+open LieModule
+open scoped IsMulCommutative
+attribute [local instance] polynomialSubalgebraGroup
+variable {L Q : Type} [RealNormedLieAlgebra L] [FiniteDimensional ℝ L]
+  [P : PolynomialExponentialCoordinates L] [Group Q] [IsMulCommutative Q]
+
+theorem jointFixed_action_preserves_lowerCentral (ss : List (L ≃ₗ⁅ℝ⁆ L))
+    (T : L ≃ₗ⁅ℝ⁆ L) (hT : ∀ S ∈ ss, Commute S.toLinearMap T.toLinearMap)
+    (k : ℕ) (x : jointFixedLieSubalgebra ss)
+    (hx : x ∈ lowerCentralSeries ℝ (jointFixedLieSubalgebra ss) (jointFixedLieSubalgebra ss) k) :
+    jointFixedGroupAction ss T hT x ∈
+      lowerCentralSeries ℝ (jointFixedLieSubalgebra ss) (jointFixedLieSubalgebra ss) k :=
+  LieIdeal.map_lowerCentralSeries_le k (LieIdeal.mem_map (f := (jointFixedLieAction ss T hT).toLieHom) hx)
+
+theorem jointFixed_actions_commute_mod_lowerCentral (F : NonabelianFactorSystem L Q)
+    (A : Q → L ≃ₗ⁅ℝ⁆ L) (hact : ∀ q x, F.action q x = A q x)
+    (ss : List (L ≃ₗ⁅ℝ⁆ L))
+    (hcomm : ∀ S ∈ ss, ∀ q, Commute S.toLinearMap (A q).toLinearMap)
+    (hfixed : ∀ S ∈ ss, ∀ q r, S (F.factor q r) = F.factor q r)
+    (q r : Q) (k : ℕ) (x : jointFixedLieSubalgebra ss)
+    (hx : x ∈ lowerCentralSeries ℝ (jointFixedLieSubalgebra ss) (jointFixedLieSubalgebra ss) k) :
+    jointFixedLinearAction ss (A q) (fun S hS => hcomm S hS q)
+        (jointFixedLinearAction ss (A r) (fun S hS => hcomm S hS r) x) -
+      jointFixedLinearAction ss (A r) (fun S hS => hcomm S hS r)
+        (jointFixedLinearAction ss (A q) (fun S hS => hcomm S hS q) x) ∈
+      lowerCentralSeries ℝ (jointFixedLieSubalgebra ss) (jointFixedLieSubalgebra ss) (k + 1) := by
+  let R := jointFixedFactorSystem F A hact ss hcomm hfixed
+  let K := jointFixedLieSubalgebra ss
+  have hy : R.action (q * r) x ∈ lowerCentralSeries ℝ K K k :=
+    jointFixed_action_preserves_lowerCentral ss (A (q * r)) (fun S hS => hcomm S hS _) k x hx
+  have hq := polynomialSubalgebra_inner_difference K (R.factor q r) k (R.action (q * r) x) hy
+  have hr := polynomialSubalgebra_inner_difference K (R.factor r q) k (R.action (q * r) x) hy
+  rw [← R.action_mul_apply] at hq
+  rw [show q * r = r * q from mul_comm q r, ← R.action_mul_apply] at hr
+  rw [mul_comm r q] at hr
+  have hh := (lowerCentralSeries ℝ K K (k + 1)).sub_mem hq hr
+  change R.action q (R.action r x) - R.action r (R.action q x) ∈
+    (lowerCentralSeries ℝ K K (k + 1)).toSubmodule
+  convert hh using 1
+  abel
+
+end PolycyclicRecognition
+
+end
+
+end OAI

lean/OAI/GroupTheory/PolycyclicRecognition/Lattices/JointFixedFactorSystem.lean

@@ -0,0 +1,96 @@
+import OAI.GroupTheory.PolycyclicRecognition.Lattices.JointFixedSubalgebra
+import OAI.GroupTheory.PolycyclicRecognition.Algebra.FactorExtensionMap
+import OAI.GroupTheory.PolycyclicRecognition.Algebra.GroupExtensionFactorSystem
+
+namespace OAI
+
+/-! # The actual extension on the joint fixed kernel
+
+Once the section factors are fixed by the family, the joint fixed subgroup
+supports the same nonabelian cocycle. Its factor extension embeds faithfully
+in the original group.
+-/
+
+noncomputable section
+namespace PolycyclicRecognition
+attribute [local instance] polynomialSubalgebraGroup
+variable {L Q : Type} [RealNormedLieAlgebra L] [FiniteDimensional ℝ L]
+  [P : PolynomialExponentialCoordinates L] [Group Q]
+
+def jointFixedFactorSystem (F : NonabelianFactorSystem L Q)
+    (A : Q → L ≃ₗ⁅ℝ⁆ L) (hact : ∀ q x, F.action q x = A q x)
+    (ss : List (L ≃ₗ⁅ℝ⁆ L))
+    (hcomm : ∀ S ∈ ss, ∀ q, Commute S.toLinearMap (A q).toLinearMap)
+    (hfixed : ∀ S ∈ ss, ∀ q r, S (F.factor q r) = F.factor q r) :
+    NonabelianFactorSystem (jointFixedLieSubalgebra ss) Q where
+  action q := jointFixedGroupAction ss (A q) (fun S hS => hcomm S hS q)
+  factor q r := ⟨F.factor q r, (mem_jointFixedLieSubalgebra ss _).mpr
+    (fun S hS => hfixed S hS q r)⟩
+  action_one := by
+    apply DFunLike.ext
+    intro x
+    apply Subtype.ext
+    change A 1 x = x
+    rw [← hact, F.action_one]
+    rfl
+  factor_one_left q := Subtype.ext (F.factor_one_left q)
+  factor_one_right q := Subtype.ext (F.factor_one_right q)
+  action_mul q r := by
+    apply DFunLike.ext
+    intro x
+    apply Subtype.ext
+    change A q (A r x) = F.factor q r * A (q * r) x * (F.factor q r)⁻¹
+    rw [← hact, ← hact, ← hact, F.action_mul_apply]
+  cocycle q r s := by
+    apply Subtype.ext
+    change F.factor q r * F.factor (q * r) s = A q (F.factor r s) * F.factor q (r * s)
+    rw [← hact]
+    exact F.cocycle q r s
+
+def jointFixedFactorInclusion (F : NonabelianFactorSystem L Q)
+    (A : Q → L ≃ₗ⁅ℝ⁆ L) (hact : ∀ q x, F.action q x = A q x)
+    (ss : List (L ≃ₗ⁅ℝ⁆ L))
+    (hcomm : ∀ S ∈ ss, ∀ q, Commute S.toLinearMap (A q).toLinearMap)
+    (hfixed : ∀ S ∈ ss, ∀ q r, S (F.factor q r) = F.factor q r) :
+    FactorExtension (jointFixedFactorSystem F A hact ss hcomm hfixed) →* FactorExtension F :=
+  FactorExtension.map _ _
+    (polynomialSubalgebraHom _ (jointFixedLieSubalgebra ss).incl)
+    (fun q x => (hact q x).symm) (fun _ _ => rfl)
+
+theorem jointFixedFactorInclusion_injective (F : NonabelianFactorSystem L Q)
+    (A : Q → L ≃ₗ⁅ℝ⁆ L) (hact : ∀ q x, F.action q x = A q x)
+    (ss : List (L ≃ₗ⁅ℝ⁆ L))
+    (hcomm : ∀ S ∈ ss, ∀ q, Commute S.toLinearMap (A q).toLinearMap)
+    (hfixed : ∀ S ∈ ss, ∀ q r, S (F.factor q r) = F.factor q r) :
+    Function.Injective (jointFixedFactorInclusion F A hact ss hcomm hfixed) :=
+  FactorExtension.map_injective _ _ _ _ _ Subtype.val_injective
+
+variable {G : Type} [Group G]
+
+def jointFixedExtensionEmbedding (E : GroupExtension L G Q) (σ : E.Section) (hσ : σ 1 = 1)
+    (A : Q → L ≃ₗ⁅ℝ⁆ L) (hact : ∀ q x, E.conjAct (σ q) x = A q x)
+    (ss : List (L ≃ₗ⁅ℝ⁆ L))
+    (hcomm : ∀ S ∈ ss, ∀ q, Commute S.toLinearMap (A q).toLinearMap)
+    (hfixed : ∀ S ∈ ss, ∀ q r, S (GroupExtensionSection.factor E σ q r) =
+      GroupExtensionSection.factor E σ q r) :
+    FactorExtension (jointFixedFactorSystem (GroupExtensionSection.factorSystem E σ hσ)
+      A hact ss hcomm hfixed) →* G :=
+  (GroupExtensionSection.mulEquiv E σ hσ).symm.toMonoidHom.comp
+    (jointFixedFactorInclusion _ A hact ss hcomm hfixed)
+
+theorem jointFixedExtensionEmbedding_injective (E : GroupExtension L G Q)
+    (σ : E.Section) (hσ : σ 1 = 1)
+    (A : Q → L ≃ₗ⁅ℝ⁆ L) (hact : ∀ q x, E.conjAct (σ q) x = A q x)
+    (ss : List (L ≃ₗ⁅ℝ⁆ L))
+    (hcomm : ∀ S ∈ ss, ∀ q, Commute S.toLinearMap (A q).toLinearMap)
+    (hfixed : ∀ S ∈ ss, ∀ q r, S (GroupExtensionSection.factor E σ q r) =
+      GroupExtensionSection.factor E σ q r) :
+    Function.Injective (jointFixedExtensionEmbedding E σ hσ A hact ss hcomm hfixed) :=
+  (GroupExtensionSection.mulEquiv E σ hσ).symm.injective.comp
+    (jointFixedFactorInclusion_injective _ A hact ss hcomm hfixed)
+
+end PolycyclicRecognition
+
+end
+
+end OAI

lean/OAI/GroupTheory/PolycyclicRecognition/Lattices/JointFixedLayerAction.lean

@@ -0,0 +1,91 @@
+import OAI.GroupTheory.PolycyclicRecognition.Lattices.JointFixedActionFiltration
+import OAI.GroupTheory.PolycyclicRecognition.Algebra.InvariantLinearLayer
+import OAI.GroupTheory.PolycyclicRecognition.Algebra.GeneratedUnipotentAction
+
+namespace OAI
+
+/-! # The abelian quotient acts on the residual lower-central layers
+
+Inner section factors disappear on these layers, so this is an actual linear
+representation of the quotient. Its selected generators are unipotent.
+-/
+
+noncomputable section
+namespace PolycyclicRecognition
+open LieModule
+open scoped Manifold ContDiff IsMulCommutative
+attribute [local instance] polynomialSubalgebraGroup
+variable {L G Q : Type} [RealNormedLieAlgebra L] [FiniteDimensional ℝ L]
+  [P : PolynomialExponentialCoordinates L] [LieRing.IsNilpotent L]
+  [Group G] [Group Q]
+  {E : GroupExtension L G Q}
+  {hsmooth : ∀ g : G, ContMDiff (𝓘(ℝ, L)) (𝓘(ℝ, L)) ∞ (E.conjAct g)} {qs : List Q}
+
+namespace JointFixedReductionData
+variable (D : JointFixedReductionData E hsmooth qs)
+
+abbrev lowerCentralLayer (k : ℕ) := InvariantLinearLayer
+  (lowerCentralSeries ℝ (jointFixedLieSubalgebra D.operators) (jointFixedLieSubalgebra D.operators) k).toSubmodule
+  (lowerCentralSeries ℝ (jointFixedLieSubalgebra D.operators) (jointFixedLieSubalgebra D.operators) (k + 1)).toSubmodule
+
+def layerEnd (k : ℕ) (q : Q) : Module.End ℝ (D.lowerCentralLayer k) :=
+  invariantLayerEnd _ _ (jointFixedLinearAction D.operators (D.action q)
+    (fun S hS => D.action_commutes S hS q))
+    (jointFixed_action_preserves_lowerCentral D.operators (D.action q)
+      (fun S hS => D.action_commutes S hS q) k)
+    (jointFixed_action_preserves_lowerCentral D.operators (D.action q)
+      (fun S hS => D.action_commutes S hS q) (k + 1))
+
+def layerAction (k : ℕ) : Q →* Module.End ℝ (D.lowerCentralLayer k) where
+  toFun := D.layerEnd k
+  map_one' := by
+    apply LinearMap.ext
+    intro y
+    refine Quotient.inductionOn' y ?_
+    intro x
+    apply congrArg Submodule.Quotient.mk
+    apply Subtype.ext
+    apply Subtype.ext
+    change D.action 1 (x : jointFixedLieSubalgebra D.operators) = (x : L)
+    rw [action, polynomialModelLieEquiv_apply, D.normalized, map_one]
+    rfl
+  map_mul' q r := by
+    apply LinearMap.ext
+    intro y
+    refine Quotient.inductionOn' y ?_
+    intro x
+    let K := jointFixedLieSubalgebra D.operators
+    let R := D.residualSystem
+    have hx : (x : K) ∈ lowerCentralSeries ℝ K K k := x.property
+    have hy : R.action (q * r) x ∈ lowerCentralSeries ℝ K K k :=
+      jointFixed_action_preserves_lowerCentral D.operators (D.action (q * r))
+        (fun S hS => D.action_commutes S hS _) k x hx
+    have hh := polynomialSubalgebra_inner_difference K (R.factor q r) k (R.action (q * r) x) hy
+    rw [← R.action_mul_apply] at hh
+    symm
+    apply (Submodule.Quotient.eq _).mpr
+    exact hh
+
+omit [LieRing.IsNilpotent L] in
+theorem layer_generator_unipotent (k : ℕ) (q : Q) (hq : q ∈ qs) :
+    IsNilpotent (D.layerAction k q - 1) :=
+  invariantLayerEnd_unipotent _ _ _
+    (jointFixed_action_preserves_lowerCentral D.operators (D.action q)
+      (fun S hS => D.action_commutes S hS q) k)
+    (jointFixed_action_preserves_lowerCentral D.operators (D.action q)
+      (fun S hS => D.action_commutes S hS q) (k + 1))
+    (D.residual_generator_unipotent q hq)
+
+omit [LieRing.IsNilpotent L] in
+theorem layer_action_filtration [IsMulCommutative Q]
+    (hgen : Subgroup.closure {q | q ∈ qs} = ⊤) (k : ℕ) :
+    ∃ c, linearActionFiltration (fun q => D.layerAction k q - 1) c = ⊥ :=
+  unipotent_generated_abelian_action_filtration (D.layerAction k) qs hgen
+    (D.layer_generator_unipotent k)
+
+end JointFixedReductionData
+end PolycyclicRecognition
+
+end
+
+end OAI

lean/OAI/GroupTheory/PolycyclicRecognition/Lattices/JointFixedReductionData.lean

@@ -0,0 +1,92 @@
+import OAI.GroupTheory.PolycyclicRecognition.Lattices.JointFixedFactorSystem
+import OAI.GroupTheory.PolycyclicRecognition.Lattices.FiniteFixedCocycleSection
+import OAI.GroupTheory.PolycyclicRecognition.Algebra.PolynomialSubalgebraNilpotence
+
+namespace OAI
+
+/-! # Constructed joint-fixed residual data for an actual extension
+
+The residual group is defined by the actual section factors and embeds in the
+original extension. The prescribed quotient lifts act unipotently on its
+kernel Lie algebra.
+-/
+
+noncomputable section
+namespace PolycyclicRecognition
+open scoped Manifold ContDiff IsMulCommutative
+attribute [local instance] polynomialSubalgebraGroup
+variable {L G Q : Type} [RealNormedLieAlgebra L] [FiniteDimensional ℝ L]
+  [P : PolynomialExponentialCoordinates L] [LieRing.IsNilpotent L]
+  [Group G] [Group Q]
+
+structure JointFixedReductionData (E : GroupExtension L G Q)
+    (hsmooth : ∀ g : G, ContMDiff (𝓘(ℝ, L)) (𝓘(ℝ, L)) ∞ (E.conjAct g)) (qs : List Q) where
+  operators : List (L ≃ₗ⁅ℝ⁆ L)
+  semisimple : ∀ S ∈ operators, Module.End.IsSemisimple S.toLinearMap
+  commute : ∀ S ∈ operators, ∀ T ∈ operators, Commute S.toLinearMap T.toLinearMap
+  sectionMap : E.Section
+  normalized : sectionMap 1 = 1
+  centralizes : ∀ S ∈ operators, ∀ q, sectionMap q ∈ semisimpleActionCentralizer E S
+  factorsFixed : ∀ S ∈ operators, ∀ q r, S (GroupExtensionSection.factor E sectionMap q r) =
+    GroupExtensionSection.factor E sectionMap q r
+  jordanLifts : ∀ q ∈ qs, ∃ S ∈ operators, ∃ U : L ≃ₗ⁅ℝ⁆ L,
+    IsNilpotent (U.toLinearMap - 1) ∧ Commute S.toLinearMap U.toLinearMap ∧
+    (polynomialModelLieEquiv (E.conjAct (sectionMap q)) (hsmooth (sectionMap q))).toLinearMap =
+      S.toLinearMap * U.toLinearMap
+
+theorem exists_jointFixedReductionData [IsMulCommutative Q] (E : GroupExtension L G Q)
+    (hsmooth : ∀ g : G, ContMDiff (𝓘(ℝ, L)) (𝓘(ℝ, L)) ∞ (E.conjAct g)) (qs : List Q) :
+    Nonempty (JointFixedReductionData E hsmooth qs) := by
+  obtain ⟨ss, hss, hpair, σ, hσ, hcent, hfixed, hlifts⟩ :=
+    exists_finite_fixed_cocycle_section E hsmooth qs
+  exact ⟨⟨ss, hss, hpair, σ, hσ, hcent, hfixed, hlifts⟩⟩
+
+namespace JointFixedReductionData
+variable {E : GroupExtension L G Q}
+  {hsmooth : ∀ g : G, ContMDiff (𝓘(ℝ, L)) (𝓘(ℝ, L)) ∞ (E.conjAct g)} {qs : List Q}
+  (D : JointFixedReductionData E hsmooth qs)
+
+def action (q : Q) : L ≃ₗ⁅ℝ⁆ L :=
+  polynomialModelLieEquiv (E.conjAct (D.sectionMap q)) (hsmooth (D.sectionMap q))
+
+omit [LieRing.IsNilpotent L] in
+theorem action_commutes (S : L ≃ₗ⁅ℝ⁆ L) (hS : S ∈ D.operators) (q : Q) :
+    Commute S.toLinearMap (D.action q).toLinearMap :=
+  (mem_semisimpleActionCentralizer_iff E S _ _).mp (D.centralizes S hS q)
+
+def residualSystem : NonabelianFactorSystem (jointFixedLieSubalgebra D.operators) Q :=
+  jointFixedFactorSystem (GroupExtensionSection.factorSystem E D.sectionMap D.normalized)
+    D.action (fun _ _ => (polynomialModelLieEquiv_apply _ _ _).symm)
+    D.operators D.action_commutes D.factorsFixed
+
+def residualEmbedding : FactorExtension D.residualSystem →* G :=
+  jointFixedExtensionEmbedding E D.sectionMap D.normalized D.action
+    (fun _ _ => (polynomialModelLieEquiv_apply _ _ _).symm)
+    D.operators D.action_commutes D.factorsFixed
+
+omit [LieRing.IsNilpotent L] in
+theorem residualEmbedding_injective : Function.Injective D.residualEmbedding :=
+  jointFixedExtensionEmbedding_injective E D.sectionMap D.normalized D.action
+    (fun _ _ => (polynomialModelLieEquiv_apply _ _ _).symm)
+    D.operators D.action_commutes D.factorsFixed
+
+omit [LieRing.IsNilpotent L] in
+theorem residual_generator_unipotent (q : Q) (hq : q ∈ qs) :
+    IsNilpotent (jointFixedLinearAction D.operators (D.action q)
+      (fun S hS => D.action_commutes S hS q) - 1) := by
+  obtain ⟨S, hS, U, hU, hSU, hA⟩ := D.jordanLifts q hq
+  exact jointFixedLinearAction_unipotent D.operators S U (D.action q) hS
+    (fun T hT => D.action_commutes T hT q) hU hSU hA
+
+theorem residual_kernel_nilpotent : Group.IsNilpotent (jointFixedLieSubalgebra D.operators) := by
+  let K := jointFixedLieSubalgebra D.operators
+  let : LieRing.IsNilpotent K := Function.Injective.lieAlgebra_isNilpotent
+    (f := K.incl) Subtype.val_injective
+  exact polynomialSubalgebra_group_nilpotent K
+
+end JointFixedReductionData
+end PolycyclicRecognition
+
+end
+
+end OAI

lean/OAI/GroupTheory/PolycyclicRecognition/Lattices/JointFixedResidualNilpotent.lean

@@ -0,0 +1,62 @@
+import OAI.GroupTheory.PolycyclicRecognition.Algebra.ResidualLowerCentralLayers
+import OAI.GroupTheory.PolycyclicRecognition.Algebra.RelativeNilpotentExtension
+
+namespace OAI
+
+/-! # The actual joint-fixed residual extension is nilpotent
+
+The quotient need not split. Its unipotent action has finite length on every
+intrinsic Lie lower-central layer, and the cocycle disappears on those layers.
+-/
+
+noncomputable section
+namespace PolycyclicRecognition
+open LieModule
+open scoped Manifold ContDiff IsMulCommutative
+attribute [local instance] polynomialSubalgebraGroup
+variable {L G Q : Type} [RealNormedLieAlgebra L] [FiniteDimensional ℝ L]
+  [P : PolynomialExponentialCoordinates L] [LieRing.IsNilpotent L]
+  [Group G] [Group Q] [IsMulCommutative Q]
+  {E : GroupExtension L G Q}
+  {hsmooth : ∀ g : G, ContMDiff (𝓘(ℝ, L)) (𝓘(ℝ, L)) ∞ (E.conjAct g)} {qs : List Q}
+
+namespace JointFixedReductionData
+variable (D : JointFixedReductionData E hsmooth qs)
+
+theorem residual_nilpotent (hgen : Subgroup.closure {q | q ∈ qs} = ⊤) :
+    Group.IsNilpotent (FactorExtension D.residualSystem) := by
+  let K := jointFixedLieSubalgebra D.operators
+  let : LieRing.IsNilpotent K := Function.Injective.lieAlgebra_isNilpotent
+    (f := K.incl) Subtype.val_injective
+  obtain ⟨d, hd⟩ := (LieModule.isNilpotent_iff ℝ K K).mp
+    (inferInstance : LieModule.IsNilpotent K K)
+  have hbot : D.residualLayer d = ⊥ := by
+    have hk : D.residualKernelLayer d = ⊥ := by
+      apply eq_bot_iff.mpr
+      intro x hx
+      change x ∈ lowerCentralSeries ℝ K K d at hx
+      rw [hd] at hx
+      change x = 1
+      exact hx.trans (Subtype.ext P.one_eq_zero).symm
+    rw [residualLayer, hk, Subgroup.map_bot]
+  have hzero : D.residualLayer 0 =
+      (FactorExtension.groupExtension D.residualSystem).inl.range := by
+    have hk : D.residualKernelLayer 0 = ⊤ := by
+      ext x
+      simp only [Subgroup.mem_top, iff_true]
+      change x ∈ lowerCentralSeries ℝ K K 0
+      simp
+    rw [residualLayer, hk, Subgroup.map_top]
+    rfl
+  obtain ⟨c, hc⟩ := relative_series_descends_finite_layers ⊤ D.residualLayer
+    (D.residualLayer_commutator_bound hgen) d
+  apply nilpotent_of_relative_kernel_series (FactorExtension.groupExtension D.residualSystem) c
+  rw [← hzero]
+  exact eq_bot_iff.mpr (hbot ▸ hc)
+
+end JointFixedReductionData
+end PolycyclicRecognition
+
+end
+
+end OAI

lean/OAI/GroupTheory/PolycyclicRecognition/Lattices/JointFixedSubalgebra.lean

@@ -0,0 +1,98 @@
+import OAI.GroupTheory.PolycyclicRecognition.Algebra.SemisimpleMovingAction
+import Mathlib.RingTheory.Nilpotent.Lemmas
+
+namespace OAI
+
+/-! # The joint fixed algebra and its unipotent quotient-lift actions -/
+
+noncomputable section
+namespace PolycyclicRecognition
+attribute [local instance] polynomialSubalgebraGroup
+variable {L : Type} [RealNormedLieAlgebra L] [FiniteDimensional ℝ L]
+
+def jointFixedLieSubalgebra (ss : List (L ≃ₗ⁅ℝ⁆ L)) : LieSubalgebra ℝ L where
+  toSubmodule :=
+    { carrier := {x | ∀ S ∈ ss, S x = x}
+      zero_mem' := by intro S _; exact map_zero S
+      add_mem' := by
+        intro x y hx hy S hS
+        rw [map_add, hx S hS, hy S hS]
+      smul_mem' := by
+        intro r x hx S hS
+        rw [map_smul, hx S hS] }
+  lie_mem' := by
+    intro x y hx hy S hS
+    rw [S.map_lie, hx S hS, hy S hS]
+
+omit [FiniteDimensional ℝ L] in
+theorem mem_jointFixedLieSubalgebra (ss : List (L ≃ₗ⁅ℝ⁆ L)) (x : L) :
+    x ∈ jointFixedLieSubalgebra ss ↔ ∀ S ∈ ss, S x = x := Iff.rfl
+
+omit [FiniteDimensional ℝ L] in
+theorem commuting_lieEquiv_preserves_jointFixed (ss : List (L ≃ₗ⁅ℝ⁆ L))
+    (T : L ≃ₗ⁅ℝ⁆ L) (hT : ∀ S ∈ ss, Commute S.toLinearMap T.toLinearMap)
+    (x : L) (hx : x ∈ jointFixedLieSubalgebra ss) : T x ∈ jointFixedLieSubalgebra ss := by
+  apply (mem_jointFixedLieSubalgebra ss _).mpr
+  intro S hS
+  have hh : S (T x) = T (S x) := LinearMap.congr_fun (hT S hS).eq x
+  rw [hh, (mem_jointFixedLieSubalgebra ss x).mp hx S hS]
+
+def jointFixedLinearAction (ss : List (L ≃ₗ⁅ℝ⁆ L))
+    (T : L ≃ₗ⁅ℝ⁆ L) (hT : ∀ S ∈ ss, Commute S.toLinearMap T.toLinearMap) :
+    Module.End ℝ (jointFixedLieSubalgebra ss) :=
+  T.toLinearMap.restrict (commuting_lieEquiv_preserves_jointFixed ss T hT)
+
+def jointFixedLieAction (ss : List (L ≃ₗ⁅ℝ⁆ L))
+    (T : L ≃ₗ⁅ℝ⁆ L) (hT : ∀ S ∈ ss, Commute S.toLinearMap T.toLinearMap) :
+    jointFixedLieSubalgebra ss ≃ₗ⁅ℝ⁆ jointFixedLieSubalgebra ss where
+  toFun x := ⟨T x, commuting_lieEquiv_preserves_jointFixed ss T hT x x.property⟩
+  invFun x := ⟨T.symm x, commuting_lieEquiv_preserves_jointFixed ss T.symm
+    (fun S hS => linear_commute_symm T.toLinearEquiv S.toLinearMap (hT S hS)) x x.property⟩
+  left_inv x := Subtype.ext (T.symm_apply_apply x)
+  right_inv x := Subtype.ext (T.apply_symm_apply x)
+  map_add' x y := Subtype.ext (T.map_add x y)
+  map_smul' r x := Subtype.ext (T.map_smul r x)
+  map_lie' {x y} := Subtype.ext (T.map_lie x y)
+
+omit [FiniteDimensional ℝ L] in
+theorem jointFixedLinearAction_unipotent (ss : List (L ≃ₗ⁅ℝ⁆ L))
+    (S U T : L ≃ₗ⁅ℝ⁆ L) (hS : S ∈ ss)
+    (hT : ∀ R ∈ ss, Commute R.toLinearMap T.toLinearMap)
+    (hU : IsNilpotent (U.toLinearMap - 1)) (hSU : Commute S.toLinearMap U.toLinearMap)
+    (hTU : T.toLinearMap = S.toLinearMap * U.toLinearMap) :
+    IsNilpotent (jointFixedLinearAction ss T hT - 1) := by
+  have hUx (x : L) (hx : x ∈ jointFixedLieSubalgebra ss) : T x = U x := by
+    have hh : T x = S (U x) := LinearMap.congr_fun hTU x
+    have hc : S (U x) = U (S x) := LinearMap.congr_fun hSU.eq x
+    rw [hh, hc, (mem_jointFixedLieSubalgebra ss x).mp hx S hS]
+  have hUp : ∀ x ∈ (jointFixedLieSubalgebra ss).toSubmodule, U x ∈ jointFixedLieSubalgebra ss := by
+    intro x hx
+    rw [← hUx x hx]
+    exact commuting_lieEquiv_preserves_jointFixed ss T hT x hx
+  have hdiffp : ∀ x ∈ (jointFixedLieSubalgebra ss).toSubmodule,
+      (U.toLinearMap - 1) x ∈ jointFixedLieSubalgebra ss := by
+    intro x hx
+    exact (jointFixedLieSubalgebra ss).sub_mem (hUp x hx) hx
+  have hn := Module.End.isNilpotent.restrict hdiffp hU
+  have he : jointFixedLinearAction ss T hT - 1 = (U.toLinearMap - 1).restrict hdiffp := by
+    apply LinearMap.ext
+    intro x
+    apply Subtype.ext
+    change T x - (x : L) = U x - (x : L)
+    rw [hUx x x.property]
+  rwa [he]
+
+variable [P : PolynomialExponentialCoordinates L]
+
+def jointFixedGroupAction (ss : List (L ≃ₗ⁅ℝ⁆ L))
+    (T : L ≃ₗ⁅ℝ⁆ L) (hT : ∀ S ∈ ss, Commute S.toLinearMap T.toLinearMap) :
+    MulAut (jointFixedLieSubalgebra ss) :=
+  polynomialSubalgebraEquiv _ _ T (commuting_lieEquiv_preserves_jointFixed ss T hT)
+    (commuting_lieEquiv_preserves_jointFixed ss T.symm
+      (fun S hS => linear_commute_symm T.toLinearEquiv S.toLinearMap (hT S hS)))
+
+end PolycyclicRecognition
+
+end
+
+end OAI

lean/OAI/GroupTheory/PolycyclicRecognition/Lattices/KernelCompletionAction.lean

@@ -0,0 +1,95 @@
+import OAI.GroupTheory.PolycyclicRecognition.Lattices.KernelCompletionHeight
+
+namespace OAI
+
+/-! # Extending an action to the nilpotent completion
+
+Existence comes from the constructed homomorphism extension. Uniqueness on
+the integer grid forces the extensions to satisfy the action law.
+-/
+
+noncomputable section
+namespace PolycyclicRecognition
+open scoped Manifold ContDiff
+variable {K G Q : Type} [RealNormedLieAlgebra K] [FiniteDimensional ℝ K]
+  [PK : PolynomialExponentialCoordinates K] [Group G] [Group Q]
+  {i : K →* G} (C : NilpotentKernelCompletion i) (ρ : Q →* MulAut G)
+  (hρ : ∀ q, ContMDiff (𝓘(ℝ, K)) (𝓘(ℝ, C.carrier)) ∞
+    ((C.embed.comp (ρ q).toMonoidHom).comp i))
+
+namespace NilpotentKernelCompletion
+
+include hρ in
+theorem action_extension_exists (q : Q) :
+    ∃ A : MulAut C.carrier, ContMDiff (𝓘(ℝ, C.carrier)) (𝓘(ℝ, C.carrier)) ∞ A ∧
+      ContMDiff (𝓘(ℝ, C.carrier)) (𝓘(ℝ, C.carrier)) ∞ A.symm ∧
+      ∀ g, A (C.embed g) = C.embed (ρ q g) := by
+  apply C.automorphism_extension (ρ q) (hρ q)
+  have hi : (ρ q).symm = ρ q⁻¹ := (map_inv ρ q).symm
+  rw [hi]
+  exact hρ q⁻¹
+
+def extendedAutomorphism (q : Q) : MulAut C.carrier :=
+  (C.action_extension_exists ρ hρ q).choose
+
+theorem extendedAutomorphism_smooth (q : Q) :
+    ContMDiff (𝓘(ℝ, C.carrier)) (𝓘(ℝ, C.carrier)) ∞
+      (C.extendedAutomorphism ρ hρ q) :=
+  (C.action_extension_exists ρ hρ q).choose_spec.1
+
+theorem extendedAutomorphism_embed (q : Q) (g : G) :
+    C.extendedAutomorphism ρ hρ q (C.embed g) = C.embed (ρ q g) :=
+  (C.action_extension_exists ρ hρ q).choose_spec.2.2 g
+
+def extendedAction : Q →* MulAut C.carrier where
+  toFun := C.extendedAutomorphism ρ hρ
+  map_one' := by
+    apply MulEquiv.toMonoidHom_injective
+    apply C.hom_ext C.carrier _ _ (C.extendedAutomorphism_smooth ρ hρ 1) contMDiff_id
+    intro g
+    rw [MulEquiv.coe_toMonoidHom, C.extendedAutomorphism_embed]
+    simp only [map_one, MulAut.one_apply]
+    rfl
+  map_mul' q r := by
+    apply MulEquiv.toMonoidHom_injective
+    apply C.hom_ext C.carrier
+      (C.extendedAutomorphism ρ hρ (q * r)).toMonoidHom
+      ((C.extendedAutomorphism ρ hρ q) * (C.extendedAutomorphism ρ hρ r)).toMonoidHom
+      (C.extendedAutomorphism_smooth ρ hρ (q * r))
+      ((C.extendedAutomorphism_smooth ρ hρ q).comp
+        (C.extendedAutomorphism_smooth ρ hρ r))
+    intro g
+    change C.extendedAutomorphism ρ hρ (q * r) (C.embed g) =
+      C.extendedAutomorphism ρ hρ q (C.extendedAutomorphism ρ hρ r (C.embed g))
+    rw [C.extendedAutomorphism_embed, C.extendedAutomorphism_embed,
+      C.extendedAutomorphism_embed, map_mul]
+    rfl
+
+@[simp] theorem extendedAction_embed (q : Q) (g : G) :
+    C.extendedAction ρ hρ q (C.embed g) = C.embed (ρ q g) :=
+  C.extendedAutomorphism_embed ρ hρ q g
+
+theorem extendedAction_smooth (q : Q) :
+    ContMDiff (𝓘(ℝ, C.carrier)) (𝓘(ℝ, C.carrier)) ∞ (C.extendedAction ρ hρ q) :=
+  C.extendedAutomorphism_smooth ρ hρ q
+
+theorem extendedAction_preserves_hom {M : Type} [RealNormedLieAlgebra M]
+    [FiniteDimensional ℝ M] [PM : PolynomialExponentialCoordinates M]
+    (π : C.carrier →* M) (hπ : ContMDiff (𝓘(ℝ, C.carrier)) (𝓘(ℝ, M)) ∞ π)
+    (hinv : ∀ q g, π (C.embed (ρ q g)) = π (C.embed g)) (q : Q) (x : C.carrier) :
+    π (C.extendedAction ρ hρ q x) = π x := by
+  have he : π.comp (C.extendedAction ρ hρ q).toMonoidHom = π := by
+    apply C.hom_ext M (π.comp (C.extendedAction ρ hρ q).toMonoidHom) π
+      (hπ.comp (C.extendedAction_smooth ρ hρ q)) hπ
+    intro g
+    change π (C.extendedAction ρ hρ q (C.embed g)) = π (C.embed g)
+    rw [extendedAction_embed]
+    exact hinv q g
+  exact DFunLike.congr_fun he x
+
+end NilpotentKernelCompletion
+end PolycyclicRecognition
+
+end
+
+end OAI

lean/OAI/GroupTheory/PolycyclicRecognition/Lattices/KernelCompletionCyclicHom.lean

@@ -0,0 +1,76 @@
+import OAI.GroupTheory.PolycyclicRecognition.Lattices.NilpotentKernelCompletion
+import OAI.GroupTheory.PolycyclicRecognition.Lattices.NilpotentCyclicHomExtension
+import OAI.GroupTheory.PolycyclicRecognition.Lattices.IntegerSemidirectLattice
+
+namespace OAI
+
+/-! # Extending homomorphisms after one cyclic completion step -/
+
+noncomputable section
+namespace PolycyclicRecognition
+open scoped Manifold ContDiff
+variable {K H M : Type} [RealNormedLieAlgebra K] [FiniteDimensional ℝ K]
+  [PK : PolynomialExponentialCoordinates K] [Group H]
+  [RealNormedLieAlgebra M] [FiniteDimensional ℝ M]
+  [PM : PolynomialExponentialCoordinates M] [LieRing.IsNilpotent M]
+  {i : K →* H} (C : NilpotentKernelCompletion i)
+
+theorem kernelCompletion_cyclic_hom (a : MulAut H)
+    (A : C.carrier ≃ₗ⁅ℝ⁆ C.carrier) (hA : IsNilpotent (A.toLinearMap - 1))
+    (hAe : ∀ h, A (C.embed h) = C.embed (a h))
+    (F : (H ⋊[integerPowerAction a] Multiplicative ℤ) →* M)
+    (hF : ContMDiff (𝓘(ℝ, K)) (𝓘(ℝ, M)) ∞ ((F.comp SemidirectProduct.inl).comp i)) :
+    let D := unipotentLieLogarithm A hA
+    let hD := unipotentLieLogarithm_nilpotent A hA
+    letI := derivationSemidirectGroup D hD
+    letI : MulOneClass (C.carrier × ℝ) := (derivationSemidirectGroup D hD).toMulOneClass
+    ∃ φ : (C.carrier × ℝ) →* M,
+      ContMDiff (𝓘(ℝ, C.carrier × ℝ)) (𝓘(ℝ, M)) ∞ φ ∧
+      ∀ (h : H) (n : ℤ), φ (C.embed h, (n : ℝ)) = F ⟨h, Multiplicative.ofAdd n⟩ := by
+  obtain ⟨f, hf, hfe⟩ := C.extend M (F.comp SemidirectProduct.inl) hF
+  simp only [MonoidHom.comp_apply] at hfe
+  let t : H ⋊[integerPowerAction a] Multiplicative ℤ :=
+    SemidirectProduct.inr (Multiplicative.ofAdd (1 : ℤ))
+  let u := F t
+  have hconj (h : H) : F (SemidirectProduct.inl (a h)) =
+      u * F (SemidirectProduct.inl h) * u⁻¹ := by
+    have hh := SemidirectProduct.inl_aut (φ := integerPowerAction a)
+      (Multiplicative.ofAdd (1 : ℤ)) h
+    rw [map_inv] at hh
+    change SemidirectProduct.inl ((a ^ (1 : ℤ)) h) = t * SemidirectProduct.inl h * t⁻¹ at hh
+    simpa only [zpow_one, map_mul, map_inv] using congrArg F hh
+  let B := PolynomialExponentialCoordinates.groupAutomorphism A
+  have hb : ContMDiff (𝓘(ℝ, C.carrier)) (𝓘(ℝ, C.carrier)) ∞ B :=
+    A.toLinearMap.toContinuousLinearMap.contDiff.contMDiff
+  have hu : ContMDiff (𝓘(ℝ, M)) (𝓘(ℝ, M)) ∞ (MulAut.conj u) :=
+    (contMDiff_conjugation u).of_le (by simp)
+  have heq : f.comp B.toMonoidHom = (MulAut.conj u).toMonoidHom.comp f := by
+    apply C.hom_ext M (f.comp B.toMonoidHom) ((MulAut.conj u).toMonoidHom.comp f)
+      (hf.comp hb) (hu.comp hf)
+    intro h
+    change f (A (C.embed h)) = u * f (C.embed h) * u⁻¹
+    rw [hAe, hfe, hfe]
+    exact hconj h
+  let fL := polynomialModelLieHom f hf
+  have hL (x : C.carrier) : fL (A x) = u * fL x * u⁻¹ := by
+    rw [polynomialModelLieHom_apply, polynomialModelLieHom_apply]
+    exact DFunLike.congr_fun heq x
+  obtain ⟨φ, hφ, hφx⟩ := nilpotent_cyclic_hom_extension A hA fL u hL
+  refine ⟨φ, hφ, ?_⟩
+  intro h n
+  rw [hφx, polynomialModelLieHom_apply, hfe, ← model_zpow, ← map_zpow, ← map_mul]
+  congr 1
+  have ht : t ^ n = SemidirectProduct.inr (Multiplicative.ofAdd n) := by
+    rw [← map_zpow]
+    congr 1
+    apply Multiplicative.ext
+    change n • (1 : ℤ) = n
+    simp
+  rw [ht]
+  exact (SemidirectProduct.mk_eq_inl_mul_inr _ _).symm
+
+end PolycyclicRecognition
+
+end
+
+end OAI

lean/OAI/GroupTheory/PolycyclicRecognition/Lattices/KernelCompletionCyclicStep.lean

@@ -0,0 +1,123 @@
+import OAI.GroupTheory.PolycyclicRecognition.Lattices.KernelCompletionCyclicHom
+import OAI.GroupTheory.PolycyclicRecognition.Algebra.CyclicParameterBasis
+import OAI.GroupTheory.PolycyclicRecognition.Geometry.SemidirectExponentialCoordinates
+
+namespace OAI
+
+/-! # A cyclic step in completing a nilpotent extension with a real kernel
+
+This constructs the next polynomial model, its faithful embedding, its integer
+grid and its homomorphism extension property. No lattice in the kernel is
+required.
+-/
+
+noncomputable section
+namespace PolycyclicRecognition
+open scoped Manifold ContDiff
+variable {K H : Type} [RealNormedLieAlgebra K] [FiniteDimensional ℝ K]
+  [PK : PolynomialExponentialCoordinates K] [Group H]
+  {i : K →* H} (C : NilpotentKernelCompletion i)
+
+namespace NilpotentKernelCompletion
+
+theorem cyclic_step_with_dimension (a : MulAut H) (A : C.carrier ≃ₗ⁅ℝ⁆ C.carrier)
+    (hA : IsNilpotent (A.toLinearMap - 1))
+    (hAe : ∀ h, A (C.embed h) = C.embed (a h)) :
+    ∃ C' : NilpotentKernelCompletion
+      ((SemidirectProduct.inl : H →* H ⋊[integerPowerAction a] Multiplicative ℤ).comp i),
+      C'.dimension = C.dimension + 1 := by
+  let L := C.carrier
+  let D := unipotentLieLogarithm A hA
+  let hD := unipotentLieLogarithm_nilpotent A hA
+  let φ := PolynomialExponentialCoordinates.derivationAction D hD
+  have hstep (h : H) : C.embed (a h) = φ (Multiplicative.ofAdd 1) (C.embed h) := by
+    change C.embed (a h) = unipotentLieFlow A hA 1 (C.embed h)
+    rw [unipotentLieFlow_one, hAe]
+  let I := realIntegerSemidirectMap φ a C.embed hstep
+  have hI : Function.Injective I := realIntegerSemidirectMap_injective φ a C.embed hstep C.injective
+  let := derivationSemidirectGroup D hD
+  let : Mul (L × ℝ) := (derivationSemidirectGroup D hD).toMul
+  let : MulOneClass (L × ℝ) := (derivationSemidirectGroup D hD).toMulOneClass
+  let e : (L × ℝ) ≃* (L ⋊[φ] Multiplicative ℝ) :=
+    { derivationSemidirectEquiv D hD with map_mul' := fun _ _ => rfl }
+  let jR := e.symm.toMonoidHom.comp I
+  have hjR (z : H ⋊[integerPowerAction a] Multiplicative ℤ) :
+      jR z = (C.embed z.left, (z.right.toAdd : ℝ)) := rfl
+  obtain ⟨Q, E, hE⟩ := exists_semidirect_polynomial_exponential_coordinates D hD
+  let := Q
+  let T := DerivationLieSpace D hD
+  let : Group T := Q.group
+  let : Mul T := Q.group.toMul
+  let j := E.symm.toMonoidHom.comp jR
+  have hj (z : H ⋊[integerPowerAction a] Multiplicative ℤ) :
+      E (j z) = (C.embed z.left, (z.right.toAdd : ℝ)) := by
+    change E (E.symm (jR z)) = _
+    rw [E.apply_symm_apply, hjR]
+  let s := derivationLieSpaceSplit D hD
+  let b := cyclicParameterBasis C.basis s
+  let c := Module.finBasis ℝ (L × ℝ)
+  let p := transportedProductParameter C.parameter s E.toEquiv
+  have hp := polynomial_transported_product_parameter C.basis c b
+    C.parameter s E.toEquiv C.polynomial C.polynomial_symm (hE b c).1 (hE b c).2
+  have hEinv : ContMDiff (𝓘(ℝ, L × ℝ)) (𝓘(ℝ, T)) ∞ E.symm :=
+    ((hE b c).2.contDiff.of_le le_top).contMDiff
+  have hEfor : ContMDiff (𝓘(ℝ, T)) (𝓘(ℝ, L × ℝ)) ∞ E :=
+    ((hE b c).1.contDiff.of_le le_top).contMDiff
+  refine ⟨{
+    carrier := T
+    nilpotent := derivationLieSpace_nilpotent D hD
+    embed := j
+    injective := E.symm.injective.comp (e.symm.injective.comp hI)
+    kernel_smooth := ?_
+    dimension := C.dimension + 1
+    basis := b
+    parameter := p
+    polynomial := hp.1
+    polynomial_symm := hp.2
+    integer_grid := ?_
+    extend := ?_ }, rfl⟩
+  · have heq : (j.comp ((SemidirectProduct.inl : H →*
+        H ⋊[integerPowerAction a] Multiplicative ℤ).comp i) : K → T) =
+        fun x => E.symm (C.embed (i x), 0) := by
+      funext x
+      apply E.injective
+      rw [E.apply_symm_apply]
+      change E (j (SemidirectProduct.inl (i x))) = (C.embed (i x), 0)
+      rw [hj]
+      simp
+    rw [heq]
+    exact hEinv.comp (C.kernel_smooth.prodMk_space contMDiff_const)
+  · intro z
+    obtain ⟨h, hh⟩ := C.integer_grid (fun k => z k.castSucc)
+    refine ⟨⟨h, Multiplicative.ofAdd (z (Fin.last C.dimension))⟩, ?_⟩
+    apply E.injective
+    rw [hj]
+    have hparam := transportedProductParameter_integer C.basis C.parameter s E.toEquiv z
+    change E (p (b.equivFun.symm (fun k => (z k : ℝ)))) =
+      (C.parameter (C.basis.equivFun.symm (fun k => (z k.castSucc : ℝ))),
+        (z (Fin.last C.dimension) : ℝ)) at hparam
+    rw [hparam, hh]
+    rfl
+  · intro M _ _ PM hnil F hF
+    obtain ⟨r, hr, hre⟩ := kernelCompletion_cyclic_hom C a A hA hAe F hF
+    let f := r.comp E.toMonoidHom
+    refine ⟨f, hr.comp hEfor, ?_⟩
+    intro z
+    change r (E (j z)) = F z
+    rw [hj]
+    exact hre z.left z.right.toAdd
+
+theorem cyclic_step (a : MulAut H) (A : C.carrier ≃ₗ⁅ℝ⁆ C.carrier)
+    (hA : IsNilpotent (A.toLinearMap - 1))
+    (hAe : ∀ h, A (C.embed h) = C.embed (a h)) :
+    Nonempty (NilpotentKernelCompletion
+      ((SemidirectProduct.inl : H →* H ⋊[integerPowerAction a] Multiplicative ℤ).comp i)) := by
+  obtain ⟨C', _⟩ := C.cyclic_step_with_dimension a A hA hAe
+  exact ⟨C'⟩
+
+end NilpotentKernelCompletion
+end PolycyclicRecognition
+
+end
+
+end OAI

lean/OAI/GroupTheory/PolycyclicRecognition/Lattices/KernelCompletionEmbedding.lean

@@ -0,0 +1,102 @@
+import OAI.GroupTheory.PolycyclicRecognition.Lattices.KernelCompletionHeight
+import OAI.GroupTheory.PolycyclicRecognition.Algebra.FactorExtensionTopology
+import Mathlib.LinearAlgebra.Basis.VectorSpace
+
+namespace OAI
+
+/-! # The completion embeds the original topology
+
+The integer quotient is recovered continuously from the real height. On each
+fiber a continuous linear left inverse recovers the original kernel coordinate.
+-/
+
+noncomputable section
+namespace PolycyclicRecognition
+open scoped Manifold ContDiff
+attribute [local instance] factorExtensionTopology
+variable {L : Type} [RealNormedLieAlgebra L] [FiniteDimensional ℝ L]
+  [P : PolynomialExponentialCoordinates L] {n : ℕ}
+  (R : NonabelianFactorSystem L (IntegralLatticeGroup n))
+  (C : NilpotentKernelCompletion (FactorExtension.inl R))
+  (π : C.carrier →* AbelianRealSpace n)
+  (hπ : ContMDiff (𝓘(ℝ, C.carrier)) (𝓘(ℝ, AbelianRealSpace n)) ∞ π)
+  (he : ∀ a, π (C.embed a) = integralRealHeight a.right)
+
+local instance completionEmbeddingTopologicalGroup : IsTopologicalGroup C.carrier :=
+  topologicalGroup_of_lieGroup (𝓘(ℝ, C.carrier)) ⊤
+
+theorem completion_factorization (a : FactorExtension R) :
+    C.embed a = C.embed (FactorExtension.inl R a.left) *
+      C.embed (⟨1, a.right⟩ : FactorExtension R) := by
+  rw [← map_mul]
+  apply congrArg C.embed
+  apply FactorExtension.ext
+  · change a.left = a.left * R.action 1 1 * R.factor 1 a.right
+    rw [map_one, R.factor_one_left, mul_one, mul_one]
+  · exact (one_mul _).symm
+
+theorem kernelCompletion_continuous : Continuous C.embed := by
+  have hs : Continuous (fun q : IntegralLatticeGroup n => C.embed (⟨1, q⟩ : FactorExtension R)) :=
+    continuous_of_discreteTopology
+  have hc := (C.kernel_smooth.continuous.comp (continuous_factor_left R)).mul
+    (hs.comp (continuous_factor_right R))
+  exact hc.congr (fun a => (completion_factorization R C a).symm)
+
+include hπ he in
+theorem kernelCompletion_isEmbedding : Topology.IsEmbedding C.embed := by
+  let j := (polynomialModelLieHom (C.embed.comp (FactorExtension.inl R)) C.kernel_smooth).toLinearMap
+  have hj (x : L) : j x = C.embed (FactorExtension.inl R x) :=
+    polynomialModelLieHom_apply _ C.kernel_smooth x
+  have hji : Function.Injective j := by
+    intro x y h
+    apply FactorExtension.inl_injective R
+    apply C.injective
+    exact (hj x).symm.trans (h.trans (hj y))
+  obtain ⟨l, hl⟩ := j.exists_leftInverse_of_injective (LinearMap.ker_eq_bot.mpr hji)
+  let e : FactorExtension R ≃* C.embed.range := MonoidHom.ofInjective C.injective
+  have hlat (x : C.embed.range) : π x.val ∈ abelianRealLattice n := by
+    obtain ⟨a, ha⟩ := x.property
+    rw [← ha, he]
+    exact integerVectorMap_mem n a.right.toAdd
+  let q : C.embed.range → IntegralLatticeGroup n := fun x =>
+    (abelianRealLatticeEquiv n).symm ⟨π x.val, hlat x⟩
+  have hq (a : FactorExtension R) : q (e a) = a.right := by
+    apply (abelianRealLatticeEquiv n).injective
+    apply Subtype.ext
+    change ((abelianRealLatticeEquiv n) ((abelianRealLatticeEquiv n).symm
+      ⟨π (C.embed a), hlat (e a)⟩) : AbelianRealSpace n) = _
+    rw [MulEquiv.apply_symm_apply]
+    exact he a
+  have hqc : Continuous q := by
+    let := (abelianRealLattice_uniform n).1
+    exact (continuous_of_discreteTopology : Continuous (abelianRealLatticeEquiv n).symm).comp
+      ((hπ.continuous.comp continuous_subtype_val).subtype_mk hlat)
+  let r : C.embed.range → L := fun x => l
+    (x.val * (C.embed (⟨1, q x⟩ : FactorExtension R))⁻¹)
+  have hr (a : FactorExtension R) : r (e a) = a.left := by
+    change l (C.embed a * (C.embed (⟨1, q (e a)⟩ : FactorExtension R))⁻¹) = a.left
+    rw [hq, completion_factorization R C a, mul_inv_cancel_right, ← hj]
+    exact LinearMap.congr_fun hl a.left
+  have hrc : Continuous r := by
+    have hs : Continuous (fun q : IntegralLatticeGroup n => C.embed (⟨1, q⟩ : FactorExtension R)) :=
+      continuous_of_discreteTopology
+    exact l.toContinuousLinearMap.continuous.comp
+      (continuous_subtype_val.mul (hs.comp hqc).inv)
+  have hinv : (e.symm : C.embed.range → FactorExtension R) = fun x => ⟨r x, q x⟩ := by
+    funext x
+    obtain ⟨a, rfl⟩ := e.surjective x
+    rw [e.symm_apply_apply, hr, hq]
+  have hei : Continuous e.symm := by
+    rw [hinv]
+    exact (factorExtensionHomeomorph R).symm.continuous.comp (hrc.prodMk hqc)
+  let homeo : FactorExtension R ≃ₜ C.embed.range :=
+    { e.toEquiv with
+      continuous_toFun := (kernelCompletion_continuous R C).subtype_mk _
+      continuous_invFun := hei }
+  exact Topology.IsEmbedding.subtypeVal.comp homeo.isEmbedding
+
+end PolycyclicRecognition
+
+end
+
+end OAI

lean/OAI/GroupTheory/PolycyclicRecognition/Lattices/KernelCompletionHeight.lean

@@ -0,0 +1,154 @@
+import OAI.GroupTheory.PolycyclicRecognition.Lattices.NilpotentIntegralKernelCompletion
+import OAI.GroupTheory.PolycyclicRecognition.Algebra.AbelianRealSpace
+import OAI.GroupTheory.PolycyclicRecognition.Lattices.IntegralLatticeGenerators
+import Mathlib.LinearAlgebra.FiniteDimensional.Lemmas
+
+namespace OAI
+
+/-! # The real quotient of a nilpotent kernel completion
+
+The quotient homomorphism extends to the constructed completion. Its kernel
+is exactly the original real kernel, by the dimension retained in the cyclic
+construction. No exactness property is postulated for the completion.
+-/
+
+noncomputable section
+namespace PolycyclicRecognition
+open scoped Manifold ContDiff
+variable {K G : Type} [RealNormedLieAlgebra K] [FiniteDimensional ℝ K]
+  [PK : PolynomialExponentialCoordinates K] [Group G] {n : ℕ}
+
+def integralRealHeight : IntegralLatticeGroup n →* AbelianRealSpace n where
+  toFun z := integerVectorMap n z.toAdd
+  map_one' := (integerVectorMap n).map_zero
+  map_mul' z w := (integerVectorMap n).map_add z.toAdd w.toAdd
+
+theorem integralRealHeight_injective : Function.Injective (integralRealHeight (n := n)) := by
+  intro z w h
+  exact Multiplicative.ext (integerVectorMap_injective n h)
+
+theorem integralRealHeight_range :
+    (integralRealHeight (n := n)).range = abelianRealLattice n := by
+  ext x
+  constructor
+  · rintro ⟨z, rfl⟩
+    exact integerVectorMap_mem n z.toAdd
+  · intro hx
+    obtain ⟨z, hz⟩ := (abelianRealLatticeEquiv n).surjective ⟨x, hx⟩
+    exact ⟨z, congrArg Subtype.val hz⟩
+
+namespace NilpotentKernelCompletion
+variable (E : GroupExtension K G (IntegralLatticeGroup n))
+  (C : NilpotentKernelCompletion E.inl)
+
+theorem exists_height :
+    ∃ π : C.carrier →* AbelianRealSpace n,
+      ContMDiff (𝓘(ℝ, C.carrier)) (𝓘(ℝ, AbelianRealSpace n)) ∞ π ∧
+      ∀ g, π (C.embed g) = integralRealHeight (E.rightHom g) := by
+  apply C.extend (AbelianRealSpace n) (integralRealHeight.comp E.rightHom)
+  have he : (integralRealHeight.comp E.rightHom).comp E.inl =
+      (1 : K →* AbelianRealSpace n) := by
+    ext x
+    simp only [MonoidHom.comp_apply, E.rightHom_inl, map_one, MonoidHom.one_apply]
+  rw [he]
+  exact contMDiff_const
+
+variable (π : C.carrier →* AbelianRealSpace n)
+  (hπ : ContMDiff (𝓘(ℝ, C.carrier)) (𝓘(ℝ, AbelianRealSpace n)) ∞ π)
+  (he : ∀ g, π (C.embed g) = integralRealHeight (E.rightHom g))
+
+include hπ he in
+theorem height_surjective : Function.Surjective π := by
+  let f := (polynomialModelLieHom π hπ).toLinearMap
+  have hr : LinearMap.range f = ⊤ := by
+    apply top_unique
+    have hb : Submodule.span ℝ (Set.range (Pi.basisFun ℝ (Fin n))) =
+        (⊤ : Submodule ℝ (AbelianRealSpace n)) := (Pi.basisFun ℝ (Fin n)).span_eq
+    rw [← hb]
+    apply Submodule.span_le.mpr
+    rintro _ ⟨j, rfl⟩
+    obtain ⟨g, hg⟩ := E.rightHom_surjective (integralLatticeGenerator n j)
+    refine ⟨C.embed g, ?_⟩
+    change polynomialModelLieHom π hπ (C.embed g) = _
+    rw [polynomialModelLieHom_apply, he, hg]
+    exact integerVectorMap_basis j
+  intro x
+  obtain ⟨y, hy⟩ := (LinearMap.range_eq_top.mp hr) x
+  exact ⟨y, (polynomialModelLieHom_apply π hπ y).symm.trans hy⟩
+
+include hπ he in
+theorem height_kernel_eq
+    (hdim : C.dimension = Module.finrank ℝ K + n) :
+    π.ker = (C.embed.comp E.inl).range := by
+  let f := (polynomialModelLieHom π hπ).toLinearMap
+  let k := (polynomialModelLieHom (C.embed.comp E.inl) C.kernel_smooth).toLinearMap
+  have hk : Function.Injective k := by
+    intro x y h
+    apply E.inl_injective
+    apply C.injective
+    exact (polynomialModelLieHom_apply _ C.kernel_smooth x).symm.trans
+      (h.trans (polynomialModelLieHom_apply _ C.kernel_smooth y))
+  have hle : LinearMap.range k ≤ LinearMap.ker f := by
+    rintro _ ⟨x, rfl⟩
+    change polynomialModelLieHom π hπ (polynomialModelLieHom _ C.kernel_smooth x) = 0
+    rw [polynomialModelLieHom_apply, polynomialModelLieHom_apply]
+    change π (C.embed (E.inl x)) = 0
+    rw [he, E.rightHom_inl, map_one]
+    rfl
+  have hfdim : Module.finrank ℝ (LinearMap.ker f) = Module.finrank ℝ K := by
+    have hsurj : Function.Surjective f := by
+      intro x
+      obtain ⟨y, hy⟩ := C.height_surjective E π hπ he x
+      exact ⟨y, (polynomialModelLieHom_apply π hπ y).trans hy⟩
+    have hr := LinearMap.finrank_range_add_finrank_ker f
+    rw [LinearMap.range_eq_top.mpr hsurj, finrank_top] at hr
+    have hn : Module.finrank ℝ (AbelianRealSpace n) = n := by
+      change Module.finrank ℝ (Fin n → ℝ) = n
+      simp
+    have hc : Module.finrank ℝ C.carrier = C.dimension := by
+      simpa only [Fintype.card_fin] using Module.finrank_eq_card_basis C.basis
+    rw [hn, hc, hdim] at hr
+    omega
+  have hkr : LinearMap.range k = LinearMap.ker f :=
+    Submodule.eq_of_le_of_finrank_eq hle
+      ((LinearMap.finrank_range_of_inj hk).trans hfdim.symm)
+  ext y
+  change π y = 1 ↔ ∃ x, C.embed (E.inl x) = y
+  constructor
+  �� intro hy
+    have hy' : y ∈ LinearMap.ker f := by
+      change polynomialModelLieHom π hπ y = 0
+      rw [polynomialModelLieHom_apply, hy]
+      rfl
+    rw [← hkr] at hy'
+    obtain ⟨x, hx⟩ := hy'
+    exact ⟨x, (polynomialModelLieHom_apply _ C.kernel_smooth x).symm.trans hx⟩
+  · rintro ⟨x, rfl⟩
+    rw [he, E.rightHom_inl, map_one]
+
+include hπ he in
+theorem embed_range_eq_height_lattice
+    (hdim : C.dimension = Module.finrank ℝ K + n) :
+    C.embed.range = (abelianRealLattice n).comap π := by
+  rw [← integralRealHeight_range]
+  ext x
+  constructor
+  · rintro ⟨g, rfl⟩
+    exact ⟨E.rightHom g, (he g).symm⟩
+  · rintro ⟨q, hq⟩
+    obtain ⟨g, hg⟩ := E.rightHom_surjective q
+    have hk : x * (C.embed g)⁻¹ ∈ π.ker := by
+      change π (x * (C.embed g)⁻¹) = 1
+      rw [map_mul, map_inv, he, hg, ← hq, mul_inv_cancel]
+    rw [C.height_kernel_eq E π hπ he hdim] at hk
+    obtain ⟨k, hk⟩ := hk
+    refine ⟨E.inl k * g, ?_⟩
+    rw [map_mul, show C.embed (E.inl k) = x * (C.embed g)⁻¹ from hk]
+    exact inv_mul_cancel_right x (C.embed g)
+
+end NilpotentKernelCompletion
+end PolycyclicRecognition
+
+end
+
+end OAI

lean/OAI/GroupTheory/PolycyclicRecognition/Lattices/KernelCompletionTransport.lean

@@ -0,0 +1,58 @@
+import OAI.GroupTheory.PolycyclicRecognition.Lattices.NilpotentKernelCompletion
+
+namespace OAI
+
+/-! # Transporting a constructed completion across an exact group isomorphism -/
+
+noncomputable section
+namespace PolycyclicRecognition
+open scoped Manifold ContDiff
+variable {K H J : Type} [RealNormedLieAlgebra K] [FiniteDimensional ℝ K]
+  [PK : PolynomialExponentialCoordinates K] [Group H] [Group J]
+  {i : K →* H}
+
+namespace NilpotentKernelCompletion
+
+def of_equiv (C : NilpotentKernelCompletion i) (e : H ≃* J) :
+    NilpotentKernelCompletion (e.toMonoidHom.comp i) where
+  carrier := C.carrier
+  embed := C.embed.comp e.symm.toMonoidHom
+  injective := C.injective.comp e.symm.injective
+  kernel_smooth := by
+    convert C.kernel_smooth using 1
+    ext x
+    exact congrArg C.embed (e.symm_apply_apply (i x))
+  dimension := C.dimension
+  basis := C.basis
+  parameter := C.parameter
+  polynomial := C.polynomial
+  polynomial_symm := C.polynomial_symm
+  integer_grid z := by
+    obtain ⟨h, hh⟩ := C.integer_grid z
+    refine ⟨e h, ?_⟩
+    simpa only [MonoidHom.comp_apply, MulEquiv.coe_toMonoidHom, e.symm_apply_apply] using hh
+  extend M _ _ _ _ f hf := by
+    obtain ⟨φ, hφ, he⟩ := C.extend M (f.comp e.toMonoidHom) hf
+    refine ⟨φ, hφ, ?_⟩
+    intro j
+    exact (he (e.symm j)).trans (congrArg f (e.apply_symm_apply j))
+
+theorem exists_of_bijective_kernel_with_dimension [LieRing.IsNilpotent K]
+    (i : K →* H) (hi : Function.Bijective i) :
+    ∃ C : NilpotentKernelCompletion i, C.dimension = Module.finrank ℝ K := by
+  let e := MulEquiv.ofBijective i hi
+  have he : e.toMonoidHom.comp (MonoidHom.id K) = i := by ext x; rfl
+  rw [← he]
+  exact ⟨of_equiv of_polynomial_kernel e, rfl⟩
+
+theorem exists_of_bijective_kernel [LieRing.IsNilpotent K]
+    (i : K →* H) (hi : Function.Bijective i) : Nonempty (NilpotentKernelCompletion i) := by
+  obtain ⟨C, _⟩ := exists_of_bijective_kernel_with_dimension i hi
+  exact ⟨C⟩
+
+end NilpotentKernelCompletion
+end PolycyclicRecognition
+
+end
+
+end OAI

lean/OAI/GroupTheory/PolycyclicRecognition/Lattices/KernelCompletionUnipotentLift.lean

@@ -0,0 +1,39 @@
+import OAI.GroupTheory.PolycyclicRecognition.Lattices.NilpotentKernelCompletion
+import OAI.GroupTheory.PolycyclicRecognition.Lattices.LatticeAutomorphismUnipotent
+
+namespace OAI
+
+/-! # Nilpotent ambient conjugations extend as unipotent Lie automorphisms -/
+
+noncomputable section
+namespace PolycyclicRecognition
+open scoped Manifold ContDiff
+variable {K H G : Type} [RealNormedLieAlgebra K] [FiniteDimensional ℝ K]
+  [PK : PolynomialExponentialCoordinates K] [Group H] [Group G] [Group.IsNilpotent G]
+  {i : K →* H} (C : NilpotentKernelCompletion i)
+
+namespace NilpotentKernelCompletion
+
+theorem unipotent_conjugation_extension (j : H →* G) (hj : Function.Injective j)
+    (a : MulAut H) (t : G) (hconj : ∀ h, j (a h) = t * j h * t⁻¹)
+    (ha : ContMDiff (𝓘(ℝ, K)) (𝓘(ℝ, C.carrier)) ∞
+      ((C.embed.comp a.toMonoidHom).comp i))
+    (hai : ContMDiff (𝓘(ℝ, K)) (𝓘(ℝ, C.carrier)) ∞
+      ((C.embed.comp a.symm.toMonoidHom).comp i)) :
+    ∃ A : C.carrier ≃ₗ⁅ℝ⁆ C.carrier,
+      IsNilpotent (A.toLinearMap - 1) ∧ ∀ h, A (C.embed h) = C.embed (a h) := by
+  obtain ⟨B, hB, _, hBe⟩ := C.automorphism_extension a ha hai
+  let A := polynomialModelLieEquiv B hB
+  have hAe (h : H) : A (C.embed h) = C.embed (a h) := by
+    rw [polynomialModelLieEquiv_apply]
+    exact hBe h
+  refine ⟨A, ?_, hAe⟩
+  exact lattice_automorphism_unipotent C.basis C.parameter C.polynomial
+    C.parameter.surjective C.embed C.integer_grid j hj a t hconj A.toLinearMap hAe
+
+end NilpotentKernelCompletion
+end PolycyclicRecognition
+
+end
+
+end OAI

lean/OAI/GroupTheory/PolycyclicRecognition/Lattices/LatticeAutomorphismFlow.lean

@@ -0,0 +1,40 @@
+import OAI.GroupTheory.PolycyclicRecognition.Lattices.LatticeAutomorphismUnipotent
+import OAI.GroupTheory.PolycyclicRecognition.Algebra.PolynomialModelHom
+import OAI.GroupTheory.PolycyclicRecognition.Geometry.UnipotentLieFlow
+
+namespace OAI
+
+/-! # Extending nilpotent lattice conjugation to a real automorphism flow -/
+
+noncomputable section
+namespace PolycyclicRecognition
+open Module
+open scoped Manifold ContDiff
+variable {L G H : Type*} [RealNormedLieAlgebra L] [FiniteDimensional ℝ L]
+  [P : PolynomialExponentialCoordinates L] [Group G] [Group H] [Group.IsNilpotent G]
+
+theorem exists_nilpotent_lattice_automorphism_log {d : ℕ} (b : Basis (Fin d) ℝ L)
+    (p : L → L) (hp : IsPolynomialInBasis b b p) (hsurj : Function.Surjective p)
+    (e : H →* L)
+    (hgrid : ∀ z : Fin d → ℤ, ∃ x : H,
+      e x = p (b.equivFun.symm (fun i => (z i : ℝ))))
+    (j : H →* G) (hj : Function.Injective j)
+    (a : H ≃* H) (t : G) (ha : ∀ x, j (a x) = t * j x * t⁻¹)
+    (F : L ≃* L) (hF : ContMDiff (𝓘(ℝ, L)) (𝓘(ℝ, L)) ∞ F)
+    (he : ∀ x, F (e x) = e (a x)) :
+    ∃ D : LieDerivation ℝ L L, ∃ hD : IsNilpotent D.toLinearMap,
+      ∀ x, nilpotentDerivationFlow D hD 1 x = F x := by
+  let A := polynomialModelLieEquiv F hF
+  have hA : IsNilpotent (A.toLinearMap - 1) :=
+    lattice_automorphism_unipotent b p hp hsurj e hgrid j hj a t ha A.toLinearMap
+      (by intro x; change A (e x) = e (a x); rw [polynomialModelLieEquiv_apply]; exact he x)
+  refine ⟨unipotentLieLogarithm A hA, unipotentLieLogarithm_nilpotent A hA, ?_⟩
+  intro x
+  change unipotentLieFlow A hA 1 x = F x
+  rw [unipotentLieFlow_one, polynomialModelLieEquiv_apply]
+
+end PolycyclicRecognition
+
+end
+
+end OAI

lean/OAI/GroupTheory/PolycyclicRecognition/Lattices/LatticeAutomorphismUnipotent.lean

@@ -0,0 +1,57 @@
+import OAI.GroupTheory.PolycyclicRecognition.Algebra.PolynomialModelDifference
+import OAI.GroupTheory.PolycyclicRecognition.Algebra.NilpotentAutomorphismDifference
+
+namespace OAI
+
+/-! # Unipotence of a lattice automorphism induced by nilpotent conjugation
+
+A polynomial surjective coordinate parameter suffices. Its integral grid
+only has to land in the lattice; no additive description of that lattice is
+assumed.
+-/
+
+noncomputable section
+namespace PolycyclicRecognition
+open Module
+variable {L G H : Type*} [RealNormedLieAlgebra L] [FiniteDimensional ℝ L]
+  [P : PolynomialExponentialCoordinates L] [Group G] [Group H] [Group.IsNilpotent G]
+
+theorem lattice_automorphism_unipotent {d : ℕ} (b : Basis (Fin d) ℝ L)
+    (p : L → L) (hp : IsPolynomialInBasis b b p) (hsurj : Function.Surjective p)
+    (e : H →* L)
+    (hgrid : ∀ z : Fin d → ℤ, ∃ x : H,
+      e x = p (b.equivFun.symm (fun i => (z i : ℝ))))
+    (j : H →* G) (hj : Function.Injective j)
+    (a : H ≃* H) (t : G) (ha : ∀ x, j (a x) = t * j x * t⁻¹)
+    (A : L →ₗ[ℝ] L) (hA : ∀ x, A (e x) = e (a x)) :
+    IsNilpotent (A - 1) := by
+  let f : L → L := fun x => A x * (-x)
+  let n := Group.nilpotencyClass G
+  have hf : IsPolynomialInBasis b b f := polynomial_model_difference A b
+  have hs : Function.Semiconj e (fun y => a y * y⁻¹) f := by
+    intro x
+    change e (a x * x⁻¹) = A (e x) * (-e x)
+    rw [map_mul, map_inv, hA, P.inv_eq_neg]
+  have hezero (x : H) : f^[n] (e x) = 0 := by
+    rw [← hs.iterate_right n x, automorphism_difference_iterate_one j hj a t ha,
+      map_one, P.one_eq_zero]
+  have hz : IsPolynomialInBasis b b (fun _ : L => (0 : L)) := by
+    simpa only [IsPolynomialInBasis, map_zero] using
+      (IsCoordinatePolynomial.const (I := Fin d) (0 : Fin d → ℝ))
+  have heq : f^[n] ∘ p = fun _ => (0 : L) :=
+    ((hf.iterate n).comp hp).ext_integer_grid hz (by
+      intro z
+      obtain ⟨x, hx⟩ := hgrid z
+      change f^[n] (p (b.equivFun.symm (fun i => (z i : ℝ)))) = 0
+      rw [← hx]
+      exact hezero x)
+  apply nilpotent_linear_of_group_difference A n
+  intro y
+  obtain ⟨x, rfl⟩ := hsurj y
+  exact congrFun heq x
+
+end PolycyclicRecognition
+
+end
+
+end OAI

lean/OAI/GroupTheory/PolycyclicRecognition/Lattices/LatticeCharacterGeometry.lean

@@ -0,0 +1,62 @@
+import OAI.GroupTheory.PolycyclicRecognition.Geometry.CharacterHemisphereContraction
+import Mathlib.Algebra.Module.ZLattice.Basic
+
+namespace OAI
+
+/-! # The actual vector lattice for the character criterion -/
+
+noncomputable section
+namespace PolycyclicRecognition
+open Module
+variable {E ι : Type} [NormedAddCommGroup E] [InnerProductSpace ℝ E]
+  [ProperSpace E] [Finite ι] (b : Basis ι ℝ E)
+
+def basisLatticeEmbedding :
+    Multiplicative (Submodule.span ℤ (Set.range b)) →* Multiplicative E :=
+  (Submodule.span ℤ (Set.range b)).subtype.toAddMonoidHom.toMultiplicative
+
+omit [ProperSpace E] [Finite ι] in
+theorem basisLatticeEmbedding_span :
+    Submodule.span ℝ (Set.range (fun q => (basisLatticeEmbedding b q).toAdd)) = ⊤ := by
+  have he : Set.range (fun q => (basisLatticeEmbedding b q).toAdd) =
+      (Submodule.span ℤ (Set.range b) : Set E) := by
+    ext x
+    constructor
+    · rintro ⟨q, rfl⟩
+      exact q.toAdd.property
+    · intro hx
+      exact ⟨Multiplicative.ofAdd ⟨x, hx⟩, rfl⟩
+  rw [he]
+  exact ZSpan.span_top b
+
+theorem basisLatticeEmbedding_bounded (R : ℝ) :
+    Set.Finite {q | ‖(basisLatticeEmbedding b q).toAdd‖ ≤ R} := by
+  let L := Submodule.span ℤ (Set.range b)
+  have h := ZSpan.setFinite_inter b (Metric.isBounded_closedBall (x := (0 : E)) (r := R))
+  have hi : Function.Injective (fun q : Multiplicative L => ((q.toAdd : L) : E)) := by
+    intro q r hqr
+    apply Multiplicative.toAdd.injective
+    exact Subtype.ext hqr
+  have hp := Set.Finite.preimage hi.injOn h
+  apply hp.subset
+  intro q hq
+  change ‖((q.toAdd : L) : E)‖ ≤ R at hq
+  exact ⟨by simpa only [Metric.mem_closedBall, dist_zero_right] using hq, q.toAdd.property⟩
+
+omit [ProperSpace E] in
+theorem basisLatticeEmbedding_coarseCover :
+    ∃ R : ℝ, ∀ x : E, ∃ q, ‖(basisLatticeEmbedding b q).toAdd - x‖ ≤ R := by
+  let := Fintype.ofFinite ι
+  obtain ⟨R, hR⟩ := b.parallelepiped.isCompact.isBounded.subset_closedBall (0 : E)
+  refine ⟨R, fun x => ⟨Multiplicative.ofAdd (ZSpan.floor b x), ?_⟩⟩
+  have hf := hR (ZSpan.fundamentalDomain_subset_parallelepiped b
+    (ZSpan.fract_mem_fundamentalDomain b x))
+  change ‖(ZSpan.floor b x : E) - x‖ ≤ R
+  rw [norm_sub_rev]
+  simpa only [dist_zero_right, ZSpan.fract_apply] using (Metric.mem_closedBall.mp hf)
+
+end PolycyclicRecognition
+
+end
+
+end OAI

lean/OAI/GroupTheory/PolycyclicRecognition/Lattices/LatticeCharacterSeparation.lean

@@ -0,0 +1,40 @@
+import OAI.GroupTheory.PolycyclicRecognition.Analysis.CompactCharacterSeparation
+import OAI.GroupTheory.PolycyclicRecognition.Algebra.InwardVectorCharacters
+
+namespace OAI
+
+/-! # An integral separating direction from a compact character set -/
+
+noncomputable section
+namespace PolycyclicRecognition
+open scoped InnerProductSpace
+variable {Q E : Type} [CommGroup Q] [NormedAddCommGroup E]
+  [InnerProductSpace ℝ E] [FiniteDimensional ℝ E]
+
+theorem exists_lattice_character_separator (e : Q →* Multiplicative E)
+    (hcover : ∃ R : ℝ, ∀ x : E, ∃ q, ‖(e q).toAdd - x‖ ≤ R)
+    {C : Set E} (hC : IsCompact C) (hunit : ∀ v ∈ C, ‖v‖ = 1)
+    (hzero : (0 : E) ∉ convexHull ℝ C) :
+    ∃ t : Q, ∀ v ∈ C, 0 < (inwardVectorCharacter e v t).toAdd := by
+  obtain ⟨w, δ, hδ, hw⟩ := exists_inner_separator_of_compact_no_convex_zero hC hzero
+  obtain ⟨R, hR⟩ := hcover
+  obtain ⟨n, hn⟩ := exists_nat_gt (R / δ)
+  have hnR : R < (n : ℝ) * δ := (div_lt_iff₀ hδ).mp hn
+  obtain ⟨t, ht⟩ := hR (-((n : ℝ) • w))
+  refine ⟨t, ?_⟩
+  intro v hv
+  have herror : ⟪v, (e t).toAdd + (n : ℝ) • w⟫_ℝ ≤ R := by
+    have hb := real_inner_le_norm v ((e t).toAdd + (n : ℝ) • w)
+    rw [hunit v hv, one_mul] at hb
+    exact hb.trans (by simpa only [sub_neg_eq_add] using ht)
+  rw [inner_add_right, real_inner_smul_right, ← real_inner_comm v w] at herror
+  have hn0 : 0 ≤ (n : ℝ) := Nat.cast_nonneg n
+  have hmul := mul_le_mul_of_nonneg_left (hw v hv).le hn0
+  change 0 < -⟪v, (e t).toAdd⟫_ℝ
+  linarith
+
+end PolycyclicRecognition
+
+end
+
+end OAI

lean/OAI/GroupTheory/PolycyclicRecognition/Lattices/LatticeCharacterization.lean

@@ -0,0 +1,40 @@
+import OAI.GroupTheory.PolycyclicRecognition.Lattices.SolvableLatticeRecognition
+
+namespace OAI
+
+/-!
+# Virtual polycyclicity and finite-index solvable lattices
+
+Dekimpe's realization and polycyclicity of solvable Lie lattices identify
+virtual polycyclicity with a finite-index solvable-lattice realization.
+-/
+
+namespace PolycyclicRecognition
+
+/-- A group with a finite-index subgroup isomorphic to a uniform solvable Lie
+lattice is virtually polycyclic. -/
+theorem virtuallyPolycyclic_of_finiteIndex_solvableLattice
+    (fw : FarbWeinbergerLatticeInput) {H : Type} [Group H]
+    (Γ : Subgroup H) (hΓ : Γ.FiniteIndex)
+    (S : SimplyConnectedSolvableLieModel) (Λ : Subgroup S.carrier)
+    (hΛ : IsUniformLattice Λ) (e : Γ ≃* Λ) :
+    IsVirtuallyPolycyclic H :=
+  ⟨Γ, hΓ, (fw S Λ hΛ).of_injective e.toMonoidHom e.injective⟩
+
+/-- Virtual polycyclicity is equivalent to finite-index realization as a
+discrete uniform lattice in a simply connected solvable Lie group. -/
+theorem virtuallyPolycyclic_iff_finiteIndex_solvableLattice
+    (dekimpe : DekimpeLatticeRealizationInput) (fw : FarbWeinbergerLatticeInput)
+    (H : Type) [Group H] :
+    IsVirtuallyPolycyclic H ↔
+      ∃ Γ : Subgroup H, Γ.FiniteIndex ∧
+        ∃ (S : SimplyConnectedSolvableLieModel) (Λ : Subgroup S.carrier),
+          IsUniformLattice Λ ∧ Nonempty (Γ ≃* Λ) := by
+  constructor
+  · exact exists_uniform_solvable_lattice_of_virtuallyPolycyclic dekimpe H
+  · rintro ⟨Γ, hΓ, S, Λ, hΛ, ⟨e⟩⟩
+    exact virtuallyPolycyclic_of_finiteIndex_solvableLattice fw Γ hΓ S Λ hΛ e
+
+end PolycyclicRecognition
+
+end OAI

lean/OAI/GroupTheory/PolycyclicRecognition/Lattices/LatticeKernelTail.lean

@@ -0,0 +1,53 @@
+import OAI.GroupTheory.PolycyclicRecognition.Finiteness.FreeAbelianDuality
+
+namespace OAI
+
+/-! # Removing the first coordinate of a free abelian quotient -/
+
+noncomputable section
+namespace PolycyclicRecognition
+
+def latticeTail (n : ℕ) : IntegralLatticeGroup (n + 1) →* IntegralLatticeGroup n where
+  toFun a := Multiplicative.ofAdd (fun i => a.toAdd i.succ)
+  map_one' := rfl
+  map_mul' _ _ := rfl
+
+variable {G : Type} [Group G] {n : ℕ} (q : G →* IntegralLatticeGroup (n + 1))
+
+def latticeKernelTail : ( (latticeCoordinate n).comp q).ker →* IntegralLatticeGroup n :=
+  (latticeTail n).comp (q.comp ((latticeCoordinate n).comp q).ker.subtype)
+
+theorem latticeKernelTail_surjective (hq : Function.Surjective q) :
+    Function.Surjective (latticeKernelTail q) := by
+  intro a
+  obtain ⟨g, hg⟩ := hq (Multiplicative.ofAdd (Fin.cases 0 a.toAdd))
+  have hg0 : g ∈ ((latticeCoordinate n).comp q).ker := by
+    change latticeCoordinate n (q g) = 1
+    rw [hg]
+    rfl
+  refine ⟨⟨g, hg0⟩, ?_⟩
+  change latticeTail n (q g) = a
+  rw [hg]
+  rfl
+
+def latticeKernelTailEquiv : q.ker ≃* (latticeKernelTail q).ker where
+  toFun a := ⟨⟨a, by
+    change latticeCoordinate n (q a) = 1
+    rw [a.property, map_one]⟩, by
+    change latticeTail n (q a) = 1
+    rw [a.property, map_one]⟩
+  invFun a := ⟨a.val.val, by
+    apply Multiplicative.toAdd.injective
+    funext i
+    refine Fin.cases ?_ (fun j => ?_) i
+    · exact congrArg Multiplicative.toAdd a.val.property
+    · exact congrFun (congrArg Multiplicative.toAdd a.property) j⟩
+  left_inv _ := rfl
+  right_inv _ := rfl
+  map_mul' _ _ := rfl
+
+end PolycyclicRecognition
+
+end
+
+end OAI

lean/OAI/GroupTheory/PolycyclicRecognition/Lattices/LatticeMetricChains.lean

@@ -0,0 +1,71 @@
+import OAI.GroupTheory.PolycyclicRecognition.Lattices.UniformLatticeMetric
+import OAI.GroupTheory.PolycyclicRecognition.Analysis.LinearMetricChains
+import OAI.GroupTheory.PolycyclicRecognition.Analysis.MetricQuasiEquivalence
+
+namespace OAI
+
+/-! # Linear metric chains on a uniform lattice -/
+
+noncomputable section
+namespace PolycyclicRecognition
+
+variable {G : Type*} [Group G] [MetricSpace G] [IsTopologicalGroup G]
+  [IsIsometricSMul G G] {Λ : Subgroup G}
+
+omit [IsTopologicalGroup G] in
+/-- Rounding an ambient chain to a uniformly close lattice section keeps
+the linear length bound and enlarges only the step size. -/
+theorem IsUniformLattice.nonempty_linearMetricChains
+    (hΛ : IsUniformLattice Λ) (C : LinearMetricChains G) :
+    Nonempty (LinearMetricChains Λ) := by
+  classical
+  obtain ⟨r, R, hR, hr, _⟩ := hΛ.exists_metric_section
+  let s : G → Λ := fun x => if h : x ∈ Λ then ⟨x, h⟩ else r x
+  have hs (x : G) : dist x (s x : G) ≤ R := by
+    dsimp [s]
+    split
+    · simpa using hR
+    · exact hr x
+  have hfix (x : Λ) : s x = x := by simp [s]
+  refine ⟨{
+    step := C.step + (R + R)
+    step_pos := by linarith [C.step_pos]
+    slope := C.slope
+    slope_nonneg := C.slope_nonneg
+    error := C.error
+    error_nonneg := C.error_nonneg
+    chain := ?_ }⟩
+  intro x y
+  obtain ⟨n, p, h0, hn, hlen, hstep⟩ := C.chain (x : G) (y : G)
+  refine ⟨n, s ∘ p, by simpa only [Function.comp_apply, h0] using hfix x,
+    by simpa only [Function.comp_apply, hn] using hfix y, hlen, ?_⟩
+  intro i hi
+  change dist (s (p i) : G) (s (p (i + 1)) : G) ≤ _
+  calc
+    _ ≤ dist (s (p i) : G) (p i) + dist (p i) (p (i + 1)) +
+        dist (p (i + 1)) (s (p (i + 1)) : G) := dist_triangle4 _ _ _ _
+    _ ≤ R + C.step + R := add_le_add (add_le_add
+      ((dist_comm _ _).trans_le (hs _)) (hstep i hi)) (hs _)
+    _ = C.step + (R + R) := by ring
+
+omit [IsTopologicalGroup G] in
+/-- Inclusion and a bounded section are metric quasi-inverses. -/
+theorem IsUniformLattice.nonempty_metricQuasiEquivalence
+    (hΛ : IsUniformLattice Λ) : Nonempty (MetricQuasiEquivalence Λ G) := by
+  obtain ⟨r, R, hR, hr, hrlip⟩ := hΛ.exists_metric_section
+  refine ⟨{
+    toFun := Subtype.val
+    invFun := r
+    toFun_control := ⟨1, 0, by norm_num, by norm_num, fun x y => by
+      change dist (x : G) (y : G) ≤ 1 * dist (x : G) (y : G) + 0
+      simp⟩
+    invFun_control := ⟨1, R + R, by norm_num, add_nonneg hR hR,
+      fun x y => by simpa using hrlip x y⟩
+    left_close := ⟨R, hR, fun x => hr x⟩
+    right_close := ⟨R, hR, hr⟩ }⟩
+
+end PolycyclicRecognition
+
+end
+
+end OAI

lean/OAI/GroupTheory/PolycyclicRecognition/Lattices/LatticeNormalFlag.lean

@@ -0,0 +1,98 @@
+import OAI.GroupTheory.PolycyclicRecognition.Finiteness.FreeAbelianDuality
+
+namespace OAI
+
+/-! # The normal cyclic flag of a lattice quotient -/
+
+noncomputable section
+namespace PolycyclicRecognition
+variable {G : Type} [Group G] {r : ℕ} (q : G →* IntegralLatticeGroup r)
+
+def latticeNormalFlag (i : ℕ) : Subgroup G where
+  carrier := {g | ∀ j : Fin r, i ≤ j.val → (q g).toAdd j = 0}
+  one_mem' := by intro j _; rw [q.map_one]; rfl
+  mul_mem' := by
+    intro a b ha hb j hj
+    rw [map_mul]
+    change (q a).toAdd j + (q b).toAdd j = 0
+    rw [ha j hj, hb j hj, add_zero]
+  inv_mem' := by
+    intro a ha j hj
+    rw [map_inv]
+    change -(q a).toAdd j = 0
+    rw [ha j hj, neg_zero]
+
+instance latticeNormalFlag_normal (i : ℕ) : (latticeNormalFlag q i).Normal where
+  conj_mem x hx g := by
+    intro j hj
+    rw [q.map_mul, q.map_mul, q.map_inv]
+    change (q g).toAdd j + (q x).toAdd j + -(q g).toAdd j = 0
+    rw [hx j hj]
+    abel
+
+theorem latticeNormalFlag_mono {i j : ℕ} (hij : i ≤ j) :
+    latticeNormalFlag q i ≤ latticeNormalFlag q j :=
+  fun _ hx k hk => hx k (hij.trans hk)
+
+theorem latticeNormalFlag_zero : latticeNormalFlag q 0 = q.ker := by
+  ext g
+  constructor
+  · intro hg
+    change q g = 1
+    apply Multiplicative.toAdd.injective
+    funext j
+    exact hg j (Nat.zero_le _)
+  · intro hg j _
+    change q g = 1 at hg
+    rw [hg]
+    rfl
+
+theorem latticeNormalFlag_top : latticeNormalFlag q r = ⊤ := by
+  apply top_unique
+  intro g _ j hj
+  exact False.elim (Nat.not_le_of_gt j.isLt hj)
+
+def latticeNormalFlagStep (i : Fin r) :
+    latticeNormalFlag q (i.val + 1) →* Multiplicative ℤ where
+  toFun g := Multiplicative.ofAdd ((q (g : G)).toAdd i)
+  map_one' := by change Multiplicative.ofAdd ((q 1).toAdd i) = 1; rw [q.map_one]; rfl
+  map_mul' a b := by
+    apply Multiplicative.toAdd.injective
+    change (q ((a : G) * (b : G))).toAdd i = (q (a : G)).toAdd i + (q (b : G)).toAdd i
+    rw [map_mul]
+    rfl
+
+theorem latticeNormalFlagStep_ker (i : Fin r) :
+    (latticeNormalFlagStep q i).ker =
+      (latticeNormalFlag q i.val).subgroupOf (latticeNormalFlag q (i.val + 1)) := by
+  ext g
+  constructor
+  · intro hg j hj
+    have hh := congrArg Multiplicative.toAdd hg
+    change (q (g : G)).toAdd i = 0 at hh
+    by_cases hji : j = i
+    · subst j; exact hh
+    · exact g.property j (by have hne : j.val ≠ i.val := fun h => hji (Fin.ext h); omega)
+  · intro hg
+    exact congrArg Multiplicative.ofAdd (hg i (le_refl _))
+
+theorem latticeNormalFlagStep_generator (hq : Function.Surjective q) (i : Fin r) :
+    ∃ t : latticeNormalFlag q (i.val + 1), latticeNormalFlagStep q i t = Multiplicative.ofAdd 1 := by
+  classical
+  obtain ⟨g, hg⟩ := hq (Multiplicative.ofAdd (Pi.single i 1))
+  have hmem : g ∈ latticeNormalFlag q (i.val + 1) := by
+    intro j hj
+    rw [hg]
+    change (Pi.single i 1 : Fin r → ℤ) j = 0
+    have hji : j ≠ i := by intro h; subst j; omega
+    simp [hji]
+  refine ⟨⟨g, hmem⟩, ?_⟩
+  change Multiplicative.ofAdd ((q g).toAdd i) = _
+  rw [hg]
+  simp
+
+end PolycyclicRecognition
+
+end
+
+end OAI

lean/OAI/GroupTheory/PolycyclicRecognition/Lattices/LatticeQuotientDimension.lean

@@ -0,0 +1,42 @@
+import OAI.GroupTheory.PolycyclicRecognition.Algebra.CyclicQuotientDimension
+import OAI.GroupTheory.PolycyclicRecognition.Analysis.GroupDimensionTransport
+import OAI.GroupTheory.PolycyclicRecognition.Lattices.LatticeKernelTail
+
+namespace OAI
+
+/-! # Integral dimension through a free abelian quotient -/
+
+noncomputable section
+namespace PolycyclicRecognition
+open CategoryTheory
+
+theorem cohomologicalDimension_le_of_lattice_quotient (r : ℕ)
+    {G : Type} [Group G] (q : G →* IntegralLatticeGroup r)
+    (hq : Function.Surjective q) (d : ℕ)
+    [HasProjectiveDimensionLE (trivialIntegral q.ker) d] :
+    HasProjectiveDimensionLE (trivialIntegral G) (d + r) := by
+  induction r generalizing G with
+  | zero =>
+    have hker : q.ker = ⊤ := by
+      ext g
+      exact iff_of_true (Subsingleton.elim (q g) 1) (Subgroup.mem_top g)
+    let e := (MulEquiv.subgroupCongr hker).trans Subgroup.topEquiv
+    simpa only [Nat.add_zero] using cohomologicalDimension_le_of_equiv e d
+  | succ r ih =>
+    let p := (latticeCoordinate r).comp q
+    obtain ⟨t, ht⟩ := hq (latticeCoordinateSection r)
+    have hpt : p t = Multiplicative.ofAdd 1 := by
+      change latticeCoordinate r (q t) = _
+      rw [ht, latticeCoordinate_section]
+    let := integerQuotient_isCyclic p t hpt
+    let := integerQuotient_infinite p t hpt
+    let := cohomologicalDimension_le_of_equiv (latticeKernelTailEquiv q) d
+    let := ih (latticeKernelTail q) (latticeKernelTail_surjective q hq)
+    simpa only [Nat.add_assoc] using
+      cohomologicalDimension_le_of_infiniteCyclicQuotient p.ker (d + r)
+
+end PolycyclicRecognition
+
+end
+
+end OAI

lean/OAI/GroupTheory/PolycyclicRecognition/Lattices/LatticeRealizationFiniteIndex.lean

@@ -0,0 +1,42 @@
+import OAI.GroupTheory.PolycyclicRecognition.Algebra.NilpotentExtensionRealization
+import OAI.GroupTheory.PolycyclicRecognition.Lattices.NilpotentLatticeInduction
+
+namespace OAI
+
+/-! # Finite-index transport and integral-quotient realization -/
+
+noncomputable section
+namespace PolycyclicRecognition
+variable {G : Type} [Group G]
+
+theorem uniform_lattice_realization_of_finiteIndex (H : Subgroup G) [H.FiniteIndex]
+    (hH : ∃ K : Subgroup H, K.FiniteIndex ∧ ∃ (S : SimplyConnectedSolvableLieModel)
+      (Λ : Subgroup S.carrier), IsUniformLattice Λ ∧ Nonempty (K ≃* Λ)) :
+    ∃ K : Subgroup G, K.FiniteIndex ∧ ∃ (S : SimplyConnectedSolvableLieModel)
+      (Λ : Subgroup S.carrier), IsUniformLattice Λ ∧ Nonempty (K ≃* Λ) := by
+  obtain ⟨K, hK, S, Λ, hΛ, ⟨e⟩⟩ := hH
+  have hi : (K.map H.subtype).FiniteIndex := ⟨by
+    rw [Subgroup.index_map_subtype]
+    exact mul_ne_zero hK.index_ne_zero (Subgroup.FiniteIndex.index_ne_zero (H := H))⟩
+  let eK := K.equivMapOfInjective H.subtype H.subtype_injective
+  exact ⟨K.map H.subtype, hi, S, Λ, hΛ, ⟨eK.symm.trans e⟩⟩
+
+theorem nilpotent_integer_extension_realization {n : ℕ}
+    (q : G →* IntegralLatticeGroup n) (hq : Function.Surjective q)
+    [Group.FG q.ker] [Group.IsNilpotent q.ker] (ht : HasNoNontrivialTorsion q.ker) :
+    ∃ K : Subgroup G, K.FiniteIndex ∧ ∃ (S : SimplyConnectedSolvableLieModel)
+      (Λ : Subgroup S.carrier), IsUniformLattice Λ ∧ Nonempty (K ≃* Λ) := by
+  let E : GroupExtension q.ker G (IntegralLatticeGroup n) :=
+    { inl := q.ker.subtype
+      rightHom := q
+      inl_injective := Subtype.val_injective
+      range_inl_eq_ker_rightHom := Subgroup.range_subtype _
+      rightHom_surjective := hq }
+  obtain ⟨C⟩ := nilpotent_lattice_coordinates ht
+  exact C.extension_realization E (normalizedExtensionSection E) (normalizedExtensionSection_one E)
+
+end PolycyclicRecognition
+
+end
+
+end OAI

lean/OAI/GroupTheory/PolycyclicRecognition/Lattices/LatticeTopLine.lean

@@ -0,0 +1,93 @@
+import OAI.GroupTheory.PolycyclicRecognition.Lattices.LatticeNormalFlag
+import OAI.GroupTheory.PolycyclicRecognition.Algebra.NormalCyclicTopStep
+import OAI.GroupTheory.PolycyclicRecognition.Finiteness.IntegerExtensionHomologyBound
+import OAI.GroupTheory.PolycyclicRecognition.Algebra.RationalInvariantTopClass
+
+namespace OAI
+
+/-! # A nonzero top class above a free abelian quotient -/
+
+noncomputable section
+namespace PolycyclicRecognition
+open CategoryTheory CategoryTheory.Limits
+attribute [local instance 2000] Rep.hV2 Rep.instLinear ModuleCat.isModule
+variable {G : Type} [Group G] {r : ℕ}
+
+theorem invariantTopLine_of_subgroup_eq (N M : Subgroup G) [N.Normal] [M.Normal]
+    (h : N = M) (d : ℕ)
+    (hN : ∃ A : Rep ℤ G,
+      Nonempty (groupHomology (Rep.res N.subtype A) d ≃ₗ[ℤ] ℚ) ∧
+      ∀ g, normalHomologyMap ℤ N A d g = 𝟙 _) :
+    ∃ A : Rep ℤ G,
+      Nonempty (groupHomology (Rep.res M.subtype A) d ≃ₗ[ℤ] ℚ) ∧
+      ∀ g, normalHomologyMap ℤ M A d g = 𝟙 _ := by
+  subst M
+  exact hN
+
+theorem exists_latticeTopLine_of_kernelLine
+    (q : G →* IntegralLatticeGroup r) (hq : Function.Surjective q) (d : ℕ)
+    (hbound : ∀ R : Rep ℤ q.ker, ∀ j, d < j → IsZero (groupHomology R j))
+    (A : Rep ℤ G) (eA : groupHomology (Rep.res q.ker.subtype A) d ≃ₗ[ℤ] ℚ)
+    (hA : ∀ g, normalHomologyMap ℤ q.ker A d g = 𝟙 _) :
+    ∃ B : Rep ℤ G, Nonempty (groupHomology B (d + r) ≃ₗ[ℤ] ℚ) := by
+  have H : ∀ i, i ≤ r →
+      (∀ R : Rep ℤ (latticeNormalFlag q i), ∀ j, d + i < j → IsZero (groupHomology R j)) ∧
+      ∃ B : Rep ℤ G,
+        Nonempty (groupHomology (Rep.res (latticeNormalFlag q i).subtype B) (d + i) ≃ₗ[ℤ] ℚ) ∧
+        ∀ g, normalHomologyMap ℤ (latticeNormalFlag q i) B (d + i) g = 𝟙 _ := by
+    intro i
+    induction i with
+    | zero =>
+      intro _
+      let e := MulEquiv.subgroupCongr (latticeNormalFlag_zero q).symm
+      exact ⟨homology_bound_of_equiv e d hbound,
+        invariantTopLine_of_subgroup_eq q.ker (latticeNormalFlag q 0)
+          (latticeNormalFlag_zero q).symm d ⟨A, ⟨eA⟩, hA⟩⟩
+
+    | succ i ih =>
+      intro hi
+      obtain ⟨hb, B, ⟨eB⟩, hB⟩ := ih (by omega)
+      let j : Fin r := ⟨i, by omega⟩
+      let p := latticeNormalFlagStep q j
+      obtain ⟨t, ht⟩ := latticeNormalFlagStep_generator q hq j
+      have hker : p.ker = (latticeNormalFlag q i).subgroupOf (latticeNormalFlag q (i + 1)) :=
+        latticeNormalFlagStep_ker q j
+      have hle : latticeNormalFlag q i ≤ latticeNormalFlag q (i + 1) :=
+        latticeNormalFlag_mono q (Nat.le_succ i)
+      let e : p.ker ≃* latticeNormalFlag q i :=
+        (MulEquiv.subgroupCongr hker).trans (Subgroup.subgroupOfEquivOfLe hle)
+      have hbker := homology_bound_of_equiv e.symm (d + i) hb
+      have hbnext := homology_bound_of_integer_quotient p t ht (d + i) hbker
+      have hnext := exists_normalCyclicTopStep (latticeNormalFlag q i)
+        (latticeNormalFlag q (i + 1)) hle p t ht hker (d + i) hb B eB hB
+      have hdim : d + i + 1 = d + (i + 1) := Nat.add_assoc d i 1
+      rw [hdim] at hbnext hnext
+      exact ⟨hbnext, hnext⟩
+  obtain ⟨_, B, ⟨eB⟩, _⟩ := H r (le_refl r)
+  have eTop : groupHomology (Rep.res (⊤ : Subgroup G).subtype B) (d + r) ≃ₗ[ℤ] ℚ := by
+    rw [latticeNormalFlag_top] at eB
+    exact eB
+  let E := groupHomology.mapIso (A := Rep.res (⊤ : Subgroup G).subtype B) (B := B)
+    Subgroup.topEquiv (LinearEquiv.refl ℤ B.V) (by intro g; rfl) (d + r)
+  exact ⟨B, ⟨E.symm.toLinearEquiv.trans eTop⟩⟩
+
+theorem exists_latticeTopLine
+    (q : G →* IntegralLatticeGroup r) (hq : Function.Surjective q) (d : ℕ)
+    (hbound : ∀ A : Rep ℤ q.ker, ∀ j, d < j → IsZero (groupHomology A j))
+    (R : Rep ℤ q.ker) (eR : R.V ≃ₗ[ℤ] ℤ)
+    (x : groupHomology R d) (hx : x ≠ 0)
+    (htor : ∀ (a : ℤ) (y : groupHomology R d), a • y = 0 → a = 0 ∨ y = 0)
+    (hcomm : ∀ y z : groupHomology R d, y ≠ 0 → z ≠ 0 →
+      ∃ a b : ℤ, a ≠ 0 ∧ b ≠ 0 ∧ a • y = b • z)
+    (hdetect : ∀ A : Rep ℤ q.ker, Nonempty (A.V ≃ₗ[ℤ] ℤ) →
+      (∃ y : groupHomology A d, y ≠ 0) → Nonempty (R ≅ A)) :
+    ∃ B : Rep ℤ G, Nonempty (groupHomology B (d + r) ≃ₗ[ℤ] ℚ) := by
+  obtain ⟨χ, _, hχ, _, hact⟩ := exists_rationalInvariantTopClass q.ker R eR d x hx htor hcomm hdetect
+  obtain ⟨eA⟩ := rationalOrientation_topLine q.ker R eR d χ hχ x hx htor hcomm
+  exact exists_latticeTopLine_of_kernelLine q hq d hbound (rationalCharacterRep χ) eA hact
+
+end PolycyclicRecognition
+
+end
+
+end OAI

lean/OAI/GroupTheory/PolycyclicRecognition/Lattices/LatticeWordExtension.lean

@@ -0,0 +1,91 @@
+import OAI.GroupTheory.PolycyclicRecognition.Algebra.PolynomialModelWords
+import OAI.GroupTheory.PolycyclicRecognition.Algebra.PolynomialParameterExtension
+
+namespace OAI
+
+/-! # Extending lattice automorphisms through ordered polynomial coordinates
+
+The extension is constructed by replacing each integral generator power by
+the corresponding real one-parameter subgroup. Polynomial identities prove
+both multiplicativity and the inverse identities.
+-/
+
+noncomputable section
+namespace PolycyclicRecognition
+open Module
+open scoped Manifold ContDiff
+variable {L H : Type*} [RealNormedLieAlgebra L] [FiniteDimensional ℝ L]
+  [P : PolynomialExponentialCoordinates L] [Group H] {d : ℕ}
+  (b : Basis (Fin d) ℝ L) (p : L ≃ L) (e : H →* L) (X : Fin d → H)
+
+def latticeWordMap (a : H →* H) : L → L :=
+  fun x => orderedRealWord b (fun i => e (a (X i))) (p.symm x)
+
+theorem latticeWordMap_polynomial (hq : IsPolynomialInBasis b b p.symm) (a : H →* H) :
+    IsPolynomialInBasis b b (latticeWordMap b p e X a) :=
+  (orderedRealWord_polynomial b _).comp hq
+
+theorem latticeWordMap_on_lattice
+    (hparam : ∀ z : Fin d → ℤ,
+      p (b.equivFun.symm (fun i => (z i : ℝ))) = e (orderedWord X z))
+    (hX : Function.Surjective (orderedWord X)) (a : H →* H) (x : H) :
+    latticeWordMap b p e X a (e x) = e (a x) := by
+  obtain ⟨z, rfl⟩ := hX x
+  rw [← hparam z]
+  change orderedRealWord b (fun i => e (a (X i)))
+    (p.symm (p (b.equivFun.symm (fun i => (z i : ℝ))))) = _
+  rw [p.symm_apply_apply, orderedRealWord_integer]
+  exact orderedWord_map (e.comp a) X z
+
+def latticeWordAut (hp : IsPolynomialInBasis b b p) (hq : IsPolynomialInBasis b b p.symm)
+    (hparam : ∀ z : Fin d → ℤ,
+      p (b.equivFun.symm (fun i => (z i : ℝ))) = e (orderedWord X z))
+    (hX : Function.Surjective (orderedWord X)) (a : MulAut H) : MulAut L := by
+  let f := latticeWordMap b p e X a.toMonoidHom
+  let g := latticeWordMap b p e X a.symm.toMonoidHom
+  have hf := latticeWordMap_polynomial b p e X hq a.toMonoidHom
+  have hg := latticeWordMap_polynomial b p e X hq a.symm.toMonoidHom
+  have hF (x : H) : f (e x) = e (a x) :=
+    latticeWordMap_on_lattice b p e X hparam hX a.toMonoidHom x
+  have hG (x : H) : g (e x) = e (a.symm x) :=
+    latticeWordMap_on_lattice b p e X hparam hX a.symm.toMonoidHom x
+  refine polynomialGroupEquivFromParameter b hf hg hp p.surjective ?_ ?_ ?_
+  · intro z w
+    rw [hparam z, hparam w]
+    calc
+      f (e (orderedWord X z) * e (orderedWord X w)) =
+          e (a (orderedWord X z * orderedWord X w)) := by rw [← map_mul, hF]
+      _ = e (a (orderedWord X z)) * e (a (orderedWord X w)) := by rw [map_mul, map_mul]
+      _ = f (e (orderedWord X z)) * f (e (orderedWord X w)) := by rw [hF, hF]
+  · intro z
+    change g (f (p (b.equivFun.symm (fun i => (z i : ℝ))))) =
+      p (b.equivFun.symm (fun i => (z i : ℝ)))
+    rw [hparam z, hF, hG, a.symm_apply_apply]
+  · intro z
+    change f (g (p (b.equivFun.symm (fun i => (z i : ℝ))))) =
+      p (b.equivFun.symm (fun i => (z i : ℝ)))
+    rw [hparam z, hG, hF, a.apply_symm_apply]
+
+theorem latticeWordAut_on_lattice (hp : IsPolynomialInBasis b b p)
+    (hq : IsPolynomialInBasis b b p.symm)
+    (hparam : ∀ z : Fin d → ℤ,
+      p (b.equivFun.symm (fun i => (z i : ℝ))) = e (orderedWord X z))
+    (hX : Function.Surjective (orderedWord X)) (a : MulAut H) (x : H) :
+    latticeWordAut b p e X hp hq hparam hX a (e x) = e (a x) :=
+  latticeWordMap_on_lattice b p e X hparam hX a.toMonoidHom x
+
+theorem contMDiff_latticeWordAut (hp : IsPolynomialInBasis b b p)
+    (hq : IsPolynomialInBasis b b p.symm)
+    (hparam : ∀ z : Fin d → ℤ,
+      p (b.equivFun.symm (fun i => (z i : ℝ))) = e (orderedWord X z))
+    (hX : Function.Surjective (orderedWord X)) (a : MulAut H) :
+    ContMDiff (𝓘(ℝ, L)) (𝓘(ℝ, L)) ∞ (latticeWordAut b p e X hp hq hparam hX a) := by
+  have h : ContDiff ℝ ∞ (latticeWordMap b p e X a.toMonoidHom) :=
+    (latticeWordMap_polynomial b p e X hq a.toMonoidHom).contDiff.of_le le_top
+  exact h.contMDiff
+
+end PolycyclicRecognition
+
+end
+
+end OAI

lean/OAI/GroupTheory/PolycyclicRecognition/Lattices/NilpotentCyclicFiniteIndexLattice.lean

@@ -0,0 +1,30 @@
+import OAI.GroupTheory.PolycyclicRecognition.Lattices.NilpotentLatticeDerivationLog
+import OAI.GroupTheory.PolycyclicRecognition.Geometry.RealLieAutomorphismPowerLog
+
+namespace OAI
+
+/-! # Cyclic extensions of the constructed nilpotent lattice model -/
+
+noncomputable section
+namespace PolycyclicRecognition.NilpotentLatticeCoordinates
+variable {H : Type} [Group H] (C : NilpotentLatticeCoordinates H)
+include C
+
+theorem cyclic_finiteIndex_lattice (a : MulAut H) :
+    ∃ Γ : Subgroup (H ⋊[integerPowerAction a] Multiplicative ℤ), Γ.FiniteIndex ∧
+      ∃ (S : SimplyConnectedSolvableLieModel) (Λ : Subgroup S.carrier),
+        IsUniformLattice Λ ∧ Nonempty (Γ ≃* Λ) := by
+  obtain ⟨m, hm, D, hD⟩ := real_lie_automorphism_has_power_log (C.automorphismLieEquiv a)
+  apply C.cyclic_finiteIndex_lattice_of_derivation_log a hm D
+  apply ContinuousLinearMap.ext
+  intro x
+  have h := congrArg (fun T : Module.End ℝ C.carrier => T x) hD
+  change _ = (C.automorphismLinear (a ^ m)) x
+  rw [map_pow]
+  exact h
+
+end PolycyclicRecognition.NilpotentLatticeCoordinates
+
+end
+
+end OAI