Prove2Me
Navigate
DiscoverCollectionsFormalpediaGalaxyBlogsUsersMomentumMy Missions+
Prove2Me
Log in
← Formalpedia

BG Proposition 1.16: coprime-action generation by cocyclic centralizers

Definition
OddOrder_BG_Ch1_Preliminary_S01b_Prop116

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

feit-thompsonfinite-groupsgroup-theoryishida-odd-order

Bender–Glauberman, Local Analysis for the Odd Order Theorem, §1, Proposition 1.16: let AAA be a noncyclic abelian group acting coprimely on a finite group GGG. Then (1) G=⟨CG(x)∣x∈A#⟩G=\langle C_G(x)\mid x\in A^\#\rangleG=⟨CG​(x)∣x∈A#⟩ and (2) G=⟨CG(Y)∣Y≤A,A/Y cyclic⟩G=\langle C_G(Y)\mid Y\le A,A/Y\text{ cyclic}\rangleG=⟨CG​(Y)∣Y≤A,A/Y cyclic⟩. The first assertion is Gorenstein, Finite Groups, Theorem 6.2.4.

Main definitions: cocyclicFixedByClosure (the subgroup ⟨CG(Y)∣Y≤A,A/Y cyclic⟩\langle C_G(Y)\mid Y\le A,A/Y\text{ cyclic}\rangle⟨CG​(Y)∣Y≤A,A/Y cyclic⟩) and quotAction (the induced action of A/⟨a⟩A/\langle a\rangleA/⟨a⟩ on CG(a)C_G(a)CG​(a)).

The bundle also proves 6 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/BG/Ch1_Preliminary/S01b_Prop116.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_Ch06_FrobeniusActions_FrobeniusGroup

namespace OddOrder.BG.Ch1.S01

open OddOrder.Isaacs.Ch06

variable {A G : Type*} [Group A] [Group G]

/-- **BG `⟨ C_G(Y) | Y ≤ A, A/Y cyclic ⟩`** (Prop 1.16(2)): the subgroup of `G` generated by
the fixed-point subgroups `C_G(Y)` of all subgroups `Y ≤ A` with cyclic quotient `A/Y`.

`A/Y` cyclic is encoded as `∃ a : A, Y ⊔ Subgroup.zpowers a = ⊤` (`A` is generated by `Y`
together with one element), avoiding the quotient type in the definition. -/
def cocyclicFixedByClosure (φ : A →* MulAut G) : Subgroup G :=
  Subgroup.closure {g | ∃ Y : Subgroup A, (∃ a : A, Y ⊔ Subgroup.zpowers a = ⊤) ∧
    ∀ y ∈ Y, φ y g = g}

/-- A single-element fixed subgroup `C_G(a)` lies in the cocyclic closure whenever `A/⟨a⟩`
is cyclic. -/
theorem actionFixedBy_le_cocyclicFixedByClosure {φ : A →* MulAut G} {a : A}
    (ha : ∃ b : A, Subgroup.zpowers a ⊔ Subgroup.zpowers b = ⊤) :
    actionFixedBy φ a ≤ cocyclicFixedByClosure φ := by
  intro g hg
  rw [actionFixedBy_eq_actionFixedPoints_zpowers, mem_actionFixedPoints] at hg
  exact Subgroup.subset_closure ⟨Subgroup.zpowers a, ha, fun y hy => hg ⟨y, hy⟩⟩

/-- `C_G(Y)` for a subgroup `Y ≤ A` with `A/Y` cyclic lies in the cocyclic closure. -/
theorem subgroupFixed_le_cocyclicFixedByClosure {φ : A →* MulAut G} {Y : Subgroup A}
    (hY : ∃ a : A, Y ⊔ Subgroup.zpowers a = ⊤) {g : G} (hg : ∀ y ∈ Y, φ y g = g) :
    g ∈ cocyclicFixedByClosure φ :=
  Subgroup.subset_closure ⟨Y, hY, hg⟩

/-- **BG Prop 1.16(1) / Gorenstein 6.2.4 / Isaacs 6.21**, restated for an explicit operator
homomorphism `φ : A →* MulAut G`: `⟨ C_G(x) | x ∈ A^# ⟩ = G`. Interface adaptation of
`OddOrder.Isaacs.Ch06.nontrivialActionFixedByClosure_eq_top_of_not_isCyclic` via `compHom`. -/
theorem nontrivialActionFixedByClosure_eq_top_of_not_isCyclic' [Finite A] [IsMulCommutative A]
    [Finite G] (φ : A →* MulAut G) (hCop : Nat.Coprime (Nat.card A) (Nat.card G))
    (hNC : ¬ IsCyclic A) :
    nontrivialActionFixedByClosure φ = ⊤ := by
  let : MulDistribMulAction A G := MulDistribMulAction.compHom G φ
  have hφ : MulDistribMulAction.toMulAut A G = φ := by ext a g; rfl
  rw [← hφ]
  exact nontrivialActionFixedByClosure_eq_top_of_not_isCyclic hCop hNC

/-- `C_G(a) = actionFixedBy φ a` is `A`-invariant when `A` is abelian. -/
theorem isAInvariant_actionFixedBy [IsMulCommutative A] (φ : A →* MulAut G) (a : A) :
    OddOrder.Isaacs.Ch03.IsAInvariant φ (actionFixedBy φ a) := by
  rw [OddOrder.Isaacs.Ch03.isAInvariant_iff_smul_mem]
  intro b g hg
  rw [mem_actionFixedBy] at hg ⊢
  calc (φ a) ((φ b) g) = (φ (a * b)) g := by rw [map_mul, MulAut.mul_apply]
    _ = (φ (b * a)) g := by rw [mul_comm' a b]
    _ = (φ b) ((φ a) g) := by rw [map_mul, MulAut.mul_apply]
    _ = (φ b) g := by rw [hg]

/-- Every element of `zpowers a` acts trivially on `C_G(a)`. -/
theorem zpowers_mem_ker_restrict [IsMulCommutative A] (φ : A →* MulAut G) (a : A)
    {x : A} (hx : x ∈ Subgroup.zpowers a) :
    (isAInvariant_actionFixedBy φ a).restrict x = 1 := by
  ext g
  change ((isAInvariant_actionFixedBy φ a).restrict x g : G) = (g : G)
  rw [OddOrder.Isaacs.Ch03.IsAInvariant.restrict_apply_val]
  have hg : (g : G) ∈ actionFixedPoints φ (Subgroup.zpowers a) := by
    rw [← actionFixedBy_eq_actionFixedPoints_zpowers]; exact g.2
  exact (mem_actionFixedPoints.mp hg) ⟨x, hx⟩

/-- The induced action of `A ⧸ ⟨a⟩` on `C_G(a) = actionFixedBy φ a`. -/
noncomputable def quotAction [IsMulCommutative A] (φ : A →* MulAut G) (a : A) :
    (A ⧸ Subgroup.zpowers a) →* MulAut ↥(actionFixedBy φ a) :=
  QuotientGroup.lift (Subgroup.zpowers a) (isAInvariant_actionFixedBy φ a).restrict
    (fun _x hx => zpowers_mem_ker_restrict φ a hx)

set_option backward.isDefEq.respectTransparency false in
/-- Compatibility: the `A ⧸ ⟨a⟩`-action on `C_G(a)`, evaluated at `mk z`, agrees with `φ z`. -/
theorem quotAction_mk_apply_val [IsMulCommutative A] (φ : A →* MulAut G) (a : A) (z : A)
    (g : ↥(actionFixedBy φ a)) :
    ((quotAction φ a (QuotientGroup.mk z) g : ↥(actionFixedBy φ a)) : G) = φ z (g : G) := by
  rw [quotAction, QuotientGroup.lift_mk]
  exact OddOrder.Isaacs.Ch03.IsAInvariant.restrict_apply_val _ z g

universe uA uG

/-- **BG Proposition 1.16(2)** (mmd L501): if a noncyclic abelian group `A` acts coprimely on a
finite group `G`, then the fixed-point subgroups `C_G(Y)` of subgroups `Y ≤ A` with cyclic
quotient `A/Y` generate `G`:

`G = ⟨ C_G(Y) | Y ≤ A, A/Y cyclic ⟩`.

The first assertion `G = ⟨C_G(x) | x ∈ A^#⟩` is Isaacs 6.21 / Gorenstein 6.2.4
(`nontrivialActionFixedByClosure_eq_top_of_not_isCyclic'`). This second, stronger assertion is
proved by strong induction on `|A|`: writing `G = ⟨C_G(a) | a ≠ 1⟩`, each `C_G(a)` is handled
directly when `A/⟨a⟩` is cyclic, and otherwise by applying the inductive hypothesis to the
smaller group `A/⟨a⟩` acting on `C_G(a)`. -/
theorem cocyclicFixedByClosure_eq_top_of_not_isCyclic
    {A : Type uA} {G : Type uG} [Group A] [Finite A] [IsMulCommutative A]
    [Group G] [Finite G] (φ : A →* MulAut G)
    (hCop : Nat.Coprime (Nat.card A) (Nat.card G)) (hNC : ¬ IsCyclic A) :
    cocyclicFixedByClosure φ = ⊤ := by
  classical
  suffices Key : ∀ n : ℕ, ∀ (A : Type uA) [Group A] [Finite A] [IsMulCommutative A]
      (G : Type uG) [Group G] [Finite G] (φ : A →* MulAut G),
      Nat.card A = n → Nat.Coprime (Nat.card A) (Nat.card G) → ¬ IsCyclic A →
      cocyclicFixedByClosure φ = ⊤ by
    exact Key (Nat.card A) A G φ rfl hCop hNC
  intro n
  induction n using Nat.strong_induction_on with
  | _ n ih =>
    intro A _ _ _ G _ _ φ hcard hCop hNC
    rw [eq_top_iff]
    calc (⊤ : Subgroup G)
        = nontrivialActionFixedByClosure φ :=
          (nontrivialActionFixedByClosure_eq_top_of_not_isCyclic' φ hCop hNC).symm
      _ ≤ cocyclicFixedByClosure φ := by
          rw [nontrivialActionFixedByClosure_le_iff]
          intro a ha
          by_cases hcyc : ∃ b : A, Subgroup.zpowers a ⊔ Subgroup.zpowers b = ⊤
          · exact actionFixedBy_le_cocyclicFixedByClosure hcyc
          · -- `A/⟨a⟩` noncyclic: recurse on the `A/⟨a⟩`-action on `C_G(a)`.
            have ha_bot : Subgroup.zpowers a ≠ ⊥ := by
              intro h; exact ha (by simpa [h] using Subgroup.mem_zpowers a)
            have hcomm_quot : IsMulCommutative (A ⧸ Subgroup.zpowers a) :=
              IsMulCommutative.of_comm (by
                intro x y
                induction x using QuotientGroup.induction_on with | _ x =>
                induction y using QuotientGroup.induction_on with | _ y =>
                rw [← QuotientGroup.mk_mul, ← QuotientGroup.mk_mul, mul_comm'])
            have hcard_quot : Nat.card (A ⧸ Subgroup.zpowers a) < n := by
              rw [← hcard]; exact Subgroup.card_quotient_lt_of_ne_bot ha_bot
            have hNC_quot : ¬ IsCyclic (A ⧸ Subgroup.zpowers a) := by
              intro hc
              obtain ⟨gbar, hgbar⟩ := hc.exists_generator
              obtain ⟨b, rfl⟩ := QuotientGroup.mk'_surjective (Subgroup.zpowers a) gbar
              apply hcyc
              refine ⟨b, eq_top_iff.mpr (fun x _ => ?_)⟩
              obtain ⟨k, hk⟩ :=
                Subgroup.mem_zpowers_iff.mp (hgbar (QuotientGroup.mk' (Subgroup.zpowers a) x))
              have hmem : x * (b ^ k)⁻¹ ∈ Subgroup.zpowers a := by
                rw [← QuotientGroup.ker_mk' (Subgroup.zpowers a), MonoidHom.mem_ker, map_mul,
                  map_inv, map_zpow, hk, mul_inv_cancel]
              obtain ⟨m, hm⟩ := Subgroup.mem_zpowers_iff.mp hmem
              have hx_eq : x = a ^ m * b ^ k := by rw [hm]; group
              rw [hx_eq]
              exact Subgroup.mul_mem _
                (Subgroup.mem_sup_left (Subgroup.mem_zpowers_iff.mpr ⟨m, rfl⟩))
                (Subgroup.mem_sup_right (Subgroup.mem_zpowers_iff.mpr ⟨k, rfl⟩))
            have hCop_quot : Nat.Coprime (Nat.card (A ⧸ Subgroup.zpowers a))
                (Nat.card ↥(actionFixedBy φ a)) :=
              (hCop.coprime_dvd_left (Subgroup.card_quotient_dvd_card _)).coprime_dvd_right
                (Subgroup.card_subgroup_dvd_card _)
            have hIH := ih (Nat.card (A ⧸ Subgroup.zpowers a)) hcard_quot
              (A ⧸ Subgroup.zpowers a) ↥(actionFixedBy φ a) (quotAction φ a) rfl hCop_quot hNC_quot
            -- translate `cocyclicFixedByClosure (quotAction φ a) = ⊤` back to `G`.
            have hMmap : actionFixedBy φ a
                = (cocyclicFixedByClosure (quotAction φ a)).map (actionFixedBy φ a).subtype := by
              rw [hIH, ← MonoidHom.range_eq_map, Subgroup.range_subtype]
            rw [hMmap, cocyclicFixedByClosure, MonoidHom.map_closure, Subgroup.closure_le]
            rintro _ ⟨m, ⟨Zbar, ⟨bbar, hbbar⟩, hZfix⟩, rfl⟩
            refine subgroupFixed_le_cocyclicFixedByClosure
              (Y := Zbar.comap (QuotientGroup.mk' (Subgroup.zpowers a))) ?_ ?_
            · -- `Y = mk'⁻¹(Z̄)` is cocyclic in `A`.
              obtain ⟨c, rfl⟩ := QuotientGroup.mk'_surjective (Subgroup.zpowers a) bbar
              refine ⟨c, ?_⟩
              have hmap_eq :
                  (Zbar.comap (QuotientGroup.mk' (Subgroup.zpowers a)) ⊔ Subgroup.zpowers c).map
                    (QuotientGroup.mk' (Subgroup.zpowers a)) = ⊤ := by
                rw [Subgroup.map_sup,
                  Subgroup.map_comap_eq_self_of_surjective
                    (QuotientGroup.mk'_surjective (Subgroup.zpowers a)),
                  MonoidHom.map_zpowers]
                exact hbbar
              have hker_le : Subgroup.zpowers a
                  ≤ Zbar.comap (QuotientGroup.mk' (Subgroup.zpowers a)) ⊔ Subgroup.zpowers c := by
                have hkc : (QuotientGroup.mk' (Subgroup.zpowers a)).ker
                    ≤ Zbar.comap (QuotientGroup.mk' (Subgroup.zpowers a)) :=
                  Subgroup.ker_le_comap _ _
                rw [QuotientGroup.ker_mk'] at hkc
                exact le_sup_of_le_left hkc
              have hcm := Subgroup.comap_map_eq (QuotientGroup.mk' (Subgroup.zpowers a))
                (Zbar.comap (QuotientGroup.mk' (Subgroup.zpowers a)) ⊔ Subgroup.zpowers c)
              rw [hmap_eq, Subgroup.comap_top, QuotientGroup.ker_mk',
                sup_of_le_left hker_le] at hcm
              exact hcm.symm
            · -- `(m : G)` is fixed by all of `Y`.
              intro y hy
              have hfix := hZfix (QuotientGroup.mk' (Subgroup.zpowers a) y) (Subgroup.mem_comap.mp
                  hy)
              rw [QuotientGroup.mk'_apply] at hfix
              have hcompat := quotAction_mk_apply_val φ a y m
              rw [hfix] at hcompat
              exact hcompat.symm

end OddOrder.BG.Ch1.S01
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/BG/Ch1_Preliminary/S01b_Prop116.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