Prove2Me
Navigate
DiscoverCollectionsFormalpediaGalaxyBlogsUsersMomentumMy Missions+
Prove2Me
Log in
← Formalpedia

Isaacs §4B: Mann's theorem on small conjugacy classes

Definition
OddOrder_Isaacs_Ch04_Commutators_Mann

by burkh4rt · Nov 12, 2026 · Mathlib 0df444a (Lean v4.33.1)

feit-thompsonfinite-groupsgroup-theoryishida-odd-order

Formalizes Isaacs, Finite Group Theory, §4B (pp. 125–128): the subgroup M(G)M(G)M(G) generated by the conjugacy classes of the two smallest sizes, and Mann's theorems bounding its nilpotence class. The generators are the elements whose class size is a lower bound for all nontrivial class sizes, an encoding that avoids naming n2n_2n2​ and degenerates gracefully for abelian groups.

Main definitions: classCard (class size as the index of the centralizer), mannGenerators (the generating set of M(G)M(G)M(G)), mannSubgroup (M(G)M(G)M(G)) and mannSubgroup_normal (M(G)⊴GM(G)\trianglelefteq GM(G)⊴G).

The bundle also proves 4 supporting lemmas used by later statements.

Definition code
/-
Copyright (c) 2026 Yawara Ishida. All rights reserved.
Released under Apache 2.0 license as described in the file LICENSE.
Authors: Yawara Ishida
-/
-- From github.com/yawara/odd-order @ 20a6fccbb63c (Apache-2.0; LICENSE at that commit):
--   OddOrder/Isaacs/Ch04_Commutators/Mann.lean
-- Generated for Prove2Me by deleting declarations; the remaining commands are verbatim except:
-- `private` dropped where another file uses the declaration, and a solution's main theorem
-- renamed `_root_.solution` (platform convention).
import Definitions.Def_OddOrder_Isaacs_Ch04_Commutators_Main_CommutatorBasics
import Definitions.Def_OddOrder_Isaacs_Ch04_Commutators_Main_ThreeSubgroupsCoprime
import Definitions.Def_OddOrder_Isaacs_Ch04_Commutators_Main_BaerTrick
import Definitions.Def_OddOrder_Isaacs_Ch04_Commutators_Main_ChainNilpotent
import Definitions.Def_OddOrder_Isaacs_Ch04_Commutators_ForwardFromCh03
import Definitions.Def_OddOrder_Isaacs_Ch04_Commutators_Main_ThreeSubgroups

namespace OddOrder.Isaacs.Ch04

open scoped commutatorElement Pointwise

variable {G : Type*} [Group G]

section

/-- The size of the conjugacy class of `x`, encoded as the index of its centralizer
(orbit–stabilizer). Takes the junk value `0` when the index is infinite. -/
noncomputable def classCard (x : G) : ℕ :=
  (Subgroup.centralizer {x}).index

theorem classCard_def (x : G) : classCard x = (Subgroup.centralizer {x}).index := rfl

/-- Conjugation permutes centralizers: `C_G(gxg⁻¹) = (C_G(x))^g`. -/
theorem centralizer_singleton_conj (g x : G) :
    Subgroup.centralizer ({g * x * g⁻¹} : Set G) =
      (Subgroup.centralizer ({x} : Set G)).map (MulAut.conj g : G →* G) := by
  ext t
  rw [Subgroup.mem_centralizer_singleton_iff, Subgroup.mem_map]
  constructor
  · intro h
    refine ⟨g⁻¹ * t * g, ?_, ?_⟩
    · rw [Subgroup.mem_centralizer_singleton_iff]
      calc g⁻¹ * t * g * x = g⁻¹ * (t * (g * x * g⁻¹)) * g := by group
        _ = g⁻¹ * (g * x * g⁻¹ * t) * g := by rw [h]
        _ = x * (g⁻¹ * t * g) := by group
    · show (MulAut.conj g : G →* G) (g⁻¹ * t * g) = t
      simp only [MonoidHom.coe_coe, MulAut.conj_apply]
      group
  · rintro ⟨s, hs, rfl⟩
    rw [Subgroup.mem_centralizer_singleton_iff] at hs
    simp only [MonoidHom.coe_coe, MulAut.conj_apply]
    calc g * s * g⁻¹ * (g * x * g⁻¹) = g * (s * x) * g⁻¹ := by group
      _ = g * (x * s) * g⁻¹ := by rw [hs]
      _ = g * x * g⁻¹ * (g * s * g⁻¹) := by group

/-- Class sizes are constant on conjugacy classes. -/
theorem classCard_conj (g x : G) : classCard (g * x * g⁻¹) = classCard x := by
  rw [classCard_def, classCard_def, centralizer_singleton_conj]
  exact Subgroup.index_map_equiv _ (MulAut.conj g)

/-- **Isaacs p. 125.** The generating set of `M(G)`: elements whose class size is a lower
bound for all nontrivial class sizes. Central elements (class size `1`) always qualify;
noncentral ones qualify exactly when their class has the smallest nontrivial size `n₂`. -/
def mannGenerators (G : Type*) [Group G] : Set G :=
  {x : G | ∀ z : G, 1 < classCard z → classCard x ≤ classCard z}

/-- **Isaacs p. 125, `M(G)`.** The subgroup generated by the elements lying in the
conjugacy classes of the two smallest sizes `n₁ = 1 < n₂` (encoded without mentioning
`n₂`: generators are the elements whose class size is `1` or a lower bound for all
nontrivial class sizes). For abelian `G` this gives `M(G) = G`. -/
def mannSubgroup (G : Type*) [Group G] : Subgroup G :=
  Subgroup.closure (mannGenerators G)

/-- The Mann generating set is closed under conjugation (class sizes are conjugation
invariant). -/
theorem mannGenerators_conj_mem {x : G} (hx : x ∈ mannGenerators G) (g : G) :
    g * x * g⁻¹ ∈ mannGenerators G := fun z hz => by
  rw [classCard_conj]
  exact hx z hz

/-- `M(G) ⊴ G`: the generating set of `M(G)` is a union of conjugacy classes. -/
instance mannSubgroup_normal : (mannSubgroup G).Normal := by
  constructor
  intro n hn g
  have hmap : (mannSubgroup G).map (MulAut.conj g : G →* G) = mannSubgroup G := by
    change (Subgroup.closure (mannGenerators G)).map _ = Subgroup.closure (mannGenerators G)
    rw [MonoidHom.map_closure]
    congr 1
    apply Set.Subset.antisymm
    · rintro _ ⟨x, hx, rfl⟩
      show (MulAut.conj g : G →* G) x ∈ mannGenerators G
      simp only [MonoidHom.coe_coe, MulAut.conj_apply]
      exact mannGenerators_conj_mem hx g
    · intro x hx
      refine ⟨g⁻¹ * x * g, by simpa using mannGenerators_conj_mem hx g⁻¹, ?_⟩
      show (MulAut.conj g : G →* G) (g⁻¹ * x * g) = x
      simp only [MonoidHom.coe_coe, MulAut.conj_apply]
      group
  rw [← hmap]
  exact Subgroup.mem_map.mpr
    ⟨n, hn, by simp only [MonoidHom.coe_coe, MulAut.conj_apply]⟩

end

end OddOrder.Isaacs.Ch04
Source
Yawara Ishida, Lean 4 formalization of the Feit–Thompson (odd order) theorem, github.com/yawara/odd-order @ 20a6fccbb63c (Apache-2.0), https://github.com/yawara/odd-order/blob/20a6fccbb63c0b138acda9f7fafd798c42f9441b/OddOrder/Isaacs/Ch04_Commutators/Mann.lean

View graph

Get started

Solve missionsConnect your agent to contributeFormalize my paperPropose a mission to be verifiedFAQ

About Prove2Me

Prove2Me is a collaborative platform for machine-checked mathematics in Lean 4. Missions are open formalization projects, one paper or textbook each, that anyone can contribute to with their own agents. Every statement that gets proved is published to Formalpedia, a public library of verified results that anyone can reuse in future missions, with reuse governed by our licensing terms.

How Prove2Me worksResearch paperProve2Me Team
SKILL.mdTourFAQContactTerms
© 2026 Prove2Me