Prove2Me
Navigate
DiscoverCollectionsFormalpediaGalaxyBlogsUsersMomentumMy Missions+
Prove2Me
Log in
← Formalpedia

Eigenspace count for a monomial permutation operator (orbit assembly of BG (2.11))

Definition
OddOrder_GroupTheory_RepresentationTheory_CyclicPermEigenCount

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

feit-thompsonfinite-groupsgroup-theoryishida-odd-order

The orbit assembly for the keystone dim⁡E0=dim⁡Em+1\dim E_0=\dim E_m+1dimE0​=dimEm​+1 of (2.11) in Bender–Glauberman, Local Analysis for the Odd Order Theorem. It treats an operator TTT acting monomially with respect to a basis and a permutation σ\sigmaσ with σh=1\sigma^h=1σh=1, Th=1T^h=1Th=1, over a field with a primitive hhh-th root of unity, and counts eigenspace dimensions orbit by orbit, with a distinguished σ\sigmaσ-fixed point.

The main declaration: orbitSetoid.

The bundle also proves 13 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/GroupTheory/RepresentationTheory/CyclicPermEigenCount.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_GroupTheory_RepresentationTheory_CyclicShiftEigenspace

namespace OddOrder.RepresentationTheory

open Finset EigenspaceUnderCyclicAction Module

namespace CyclicPermEigen

variable {κ : Type*}

variable (σ : Equiv.Perm κ) {h : ℕ} [NeZero h]

/-- Composing two `ZMod h`-indexed powers of `σ` adds the indices (mod `h`), since `σ^h = 1`. -/
theorem perm_pow_val_add (hσ : σ ^ h = 1) (a b : ZMod h) (c : κ) :
    (σ ^ a.val) ((σ ^ b.val) c) = (σ ^ (a + b).val) c := by
  rw [← Equiv.Perm.mul_apply, ← pow_add]
  have hmod : a.val + b.val ≡ (a + b).val [MOD h] := by
    rw [ZMod.val_add]; exact (Nat.mod_modEq _ _).symm
  rw [pow_eq_pow_of_modEq hσ hmod]

/-- Two indices are in the same `σ`-orbit (parametrised by `ZMod h`): `c ~ c'` iff
`σ^{k} c = c'` for some `k : ZMod h`.  An equivalence relation once `σ^h = 1`. -/
def orbitSetoid (hσ : σ ^ h = 1) : Setoid κ where
  r c c' := ∃ k : ZMod h, (σ ^ k.val) c = c'
  iseqv := by
    refine ⟨fun c => ⟨0, by simp⟩, ?_, ?_⟩
    · rintro c c' ⟨k, hk⟩
      exact ⟨-k, by rw [← hk, perm_pow_val_add σ hσ (-k) k c]; simp⟩
    · rintro c c' c'' ⟨k, hk⟩ ⟨l, hl⟩
      exact ⟨l + k, by rw [← perm_pow_val_add σ hσ l k c, hk, hl]⟩

variable {F : Type*} [Field F]

/-- `∑_{k : ZMod h} ζ^{k} = 0` for a root of unity `ζ ≠ 1` (`ζ^h = 1`): multiplying the sum
by `ζ` permutes the summands (`Equiv.addRight 1`), so `(ζ − 1)·sum = 0`. -/
theorem sum_pow_val_eq_zero {ζ : F} (hζh : ζ ^ h = 1) (hζ : ζ ≠ 1) :
    ∑ k : ZMod h, ζ ^ k.val = 0 := by
  have hstep : ∀ k : ZMod h, ζ ^ (k.val + 1) = ζ ^ (k + 1).val := by
    intro k
    refine pow_eq_pow_of_modEq hζh ((ZMod.natCast_eq_natCast_iff _ _ _).1 ?_)
    rw [Nat.cast_add, Nat.cast_one, ZMod.natCast_rightInverse k, ZMod.natCast_rightInverse (k + 1)]
  have key : ζ * ∑ k : ZMod h, ζ ^ k.val = ∑ k : ZMod h, ζ ^ k.val := by
    rw [Finset.mul_sum]
    calc ∑ k : ZMod h, ζ * ζ ^ k.val
        = ∑ k : ZMod h, ζ ^ (k.val + 1) := by simp_rw [pow_succ']
      _ = ∑ k : ZMod h, ζ ^ (k + 1).val := Finset.sum_congr rfl fun k _ => hstep k
      _ = ∑ k : ZMod h, ζ ^ k.val :=
        Equiv.sum_comp (Equiv.addRight (1 : ZMod h)) fun k => ζ ^ k.val
  have hsub : (ζ - 1) * ∑ k : ZMod h, ζ ^ k.val = 0 := by rw [sub_mul, key, one_mul, sub_self]
  exact (mul_eq_zero.1 hsub).resolve_left (sub_ne_zero.2 hζ)

/-- `∑_{k : ZMod h} 1 = h`. -/
theorem sum_one_eq_card : ∑ _k : ZMod h, (1 : F) = (h : F) := by
  rw [Finset.sum_const, Finset.card_univ, ZMod.card, nsmul_eq_mul, mul_one]

variable {W : Type*} [AddCommGroup W] [Module F W]

/-- A power of an operator fixes any vector it fixes. -/
theorem pow_apply_fixed (T : Module.End F W) {v : W} (hv : T v = v) (n : ℕ) : (T ^ n) v = v := by
  induction n with
  | zero => simp
  | succ n ih => rw [pow_succ, Module.End.mul_apply, hv, ih]

/-- If `T^h = 1` (`h ≠ 0`) then every power `T^k` is injective: `T^{k(h-1)}` is a left inverse. -/
theorem pow_injective (T : Module.End F W) (hTh : T ^ h = 1) (k : ℕ) :
    Function.Injective (T ^ k) := by
  have hinv : (T ^ (k * (h - 1))) * (T ^ k) = 1 := by
    rw [← pow_add,
      show k * (h - 1) + k = h * k by
        conv_rhs => rw [← Nat.sub_add_cancel (Nat.one_le_iff_ne_zero.2 (NeZero.ne h))]
        ring,
      pow_mul, hTh, one_pow]
  intro x y hxy
  have h2 := congrArg (T ^ (k * (h - 1))) hxy
  rwa [← Module.End.mul_apply, ← Module.End.mul_apply, hinv, Module.End.one_apply,
    Module.End.one_apply] at h2

variable {κ : Type*} (b : Basis κ F W) (T : Module.End F W) (σ : Equiv.Perm κ)

/-- **Off-orbit coordinates vanish.** If `c'` is not in the `σ`-orbit of `c`, the Fourier
projection of `b c` has zero `c'`-coordinate (each summand `T^{k}(b c)` is supported on
`b (σ^k c)`). -/
theorem repr_sum_fourier_orbit_zero
    (hmon : ∀ (k : ℕ) (c : κ), ∃ a : F, (T ^ k) (b c) = a • b ((σ ^ k) c))
    {ε : F} {m : ℕ} {c c' : κ} (hcc' : ∀ k : ZMod h, (σ ^ k.val) c ≠ c') :
    b.repr (∑ k : ZMod h, ((ε ^ m)⁻¹ ^ k.val) • (T ^ k.val) (b c)) c' = 0 := by
  classical
  rw [map_sum]
  simp only [Finsupp.coe_finsetSum, Finset.sum_apply]
  refine Finset.sum_eq_zero fun k _ => ?_
  obtain ⟨a, ha⟩ := hmon k.val c
  rw [ha]
  simp only [map_smul, Finsupp.coe_smul, Pi.smul_apply, Basis.repr_self, Finsupp.single_apply,
    smul_eq_mul]
  rw [if_neg (hcc' k), mul_zero, mul_zero]

/-- **Diagonal coordinate is `1` on a free orbit.** If the `σ`-orbit of `c` is free
(`σ^{k} c = c ⟹ k = 0`), the Fourier projection of `b c` has `c`-coordinate `1` (only the `k = 0`
summand `b c` contributes). -/
theorem repr_sum_fourier_self_free
    (hmon : ∀ (k : ℕ) (c : κ), ∃ a : F, (T ^ k) (b c) = a • b ((σ ^ k) c))
    {ε : F} {m : ℕ} {c : κ} (hfree : ∀ k : ZMod h, (σ ^ k.val) c = c → k = 0) :
    b.repr (∑ k : ZMod h, ((ε ^ m)⁻¹ ^ k.val) • (T ^ k.val) (b c)) c = 1 := by
  classical
  rw [map_sum]
  simp only [Finsupp.coe_finsetSum, Finset.sum_apply]
  rw [Finset.sum_eq_single (0 : ZMod h)]
  · simp only [ZMod.val_zero, pow_zero, one_smul, Module.End.one_apply,
      Basis.repr_self, Finsupp.single_eq_same]
  · intro k _ hk
    obtain ⟨a, ha⟩ := hmon k.val c
    rw [ha]
    simp only [map_smul, Finsupp.coe_smul, Pi.smul_apply, Basis.repr_self, Finsupp.single_apply,
      smul_eq_mul]
    rw [if_neg (fun heq => hk (hfree k heq)), mul_zero, mul_zero]
  · intro hc0; exact absurd (Finset.mem_univ _) hc0

/-- **The Fourier projection of a fixed point is a scalar multiple of it.** If `T (b c₀) = b c₀`
(eigenvalue `1`), then `∑_k (ε^m)⁻¹^{k} • T^{k}(b c₀) = (∑_k (ε^m)⁻¹^{k}) • b c₀`.
-/
theorem sum_fourier_fixed_eq (T : Module.End F W)
    {c₀ : κ} (hc₀ : T (b c₀) = b c₀) {ε : F} (m : ℕ) :
    (∑ k : ZMod h, ((ε ^ m)⁻¹ ^ k.val) • (T ^ k.val) (b c₀))
      = (∑ k : ZMod h, ((ε ^ m)⁻¹ ^ k.val)) • b c₀ := by
  rw [Finset.sum_smul]
  refine Finset.sum_congr rfl fun k _ => ?_
  rw [pow_apply_fixed T hc₀]

/-- **`E_m` is spanned by the Fourier projections of the basis** (`range_sum_pow_eq_eigenspace`
applied to a basis): `T.eigenspace (ε^m) = span {∑_k (ε^m)⁻¹^{k} • T^{k}(b c) : c}`. -/
theorem eigenspace_eq_span_fourier (b : Basis κ F W) (T : Module.End F W)
    {ε : F} (hε : ε ≠ 0) (hεh : ε ^ h = 1) (hTh : T ^ h = 1) (hh : (h : F) ≠ 0) (m : ℕ) :
    Module.End.eigenspace T (ε ^ m)
      = Submodule.span F (Set.range fun c : κ =>
          ∑ k : ZMod h, ((ε ^ m)⁻¹ ^ k.val) • (T ^ k.val) (b c)) := by
  have hop : (fun c : κ => ∑ k : ZMod h, ((ε ^ m)⁻¹ ^ k.val) • (T ^ k.val) (b c))
      = fun c => (∑ k : ZMod h, ((ε ^ m)⁻¹ ^ k.val) • T ^ k.val) (b c) := by
    funext c; simp only [LinearMap.sum_apply, LinearMap.smul_apply]
  rw [hop, ← range_sum_pow_eq_eigenspace T hε hεh hTh hh m, LinearMap.range_eq_map,
    ← b.span_eq, Submodule.map_span, ← Set.range_comp]
  rfl

/-- **Orbit proportionality.** If `c` lies in the `σ`-orbit of `c'`, the Fourier projection of
`b c` is a scalar multiple of that of `b c'` (`sum_pow_smul_pow_comm` + `T^k` invertible).  Hence
the span over all of `κ` collapses onto orbit representatives. -/
theorem fourier_mem_span_rep (b : Basis κ F W) (T : Module.End F W) (σ : Equiv.Perm κ)
    (hmon : ∀ (k : ℕ) (c : κ), ∃ a : F, (T ^ k) (b c) = a • b ((σ ^ k) c))
    (hTh : T ^ h = 1)
    {ε : F} (hε : ε ≠ 0) (hεh : ε ^ h = 1) (m : ℕ) {c c' : κ}
    (hcc' : ∃ k : ZMod h, (σ ^ k.val) c' = c) :
    (∑ l : ZMod h, ((ε ^ m)⁻¹ ^ l.val) • (T ^ l.val) (b c))
      ∈ Submodule.span F {∑ l : ZMod h, ((ε ^ m)⁻¹ ^ l.val) • (T ^ l.val) (b c')} := by
  obtain ⟨k, hk⟩ := hcc'
  obtain ⟨a, ha⟩ := hmon k.val c'
  rw [hk] at ha
  have ha0 : a ≠ 0 := by
    intro h0
    rw [h0, zero_smul] at ha
    exact b.ne_zero c' (pow_injective T hTh k.val (by rw [ha, map_zero]))
  have hbc : b c = a⁻¹ • (T ^ k.val) (b c') := by
    rw [ha, smul_smul, inv_mul_cancel₀ ha0, one_smul]
  have heq : (∑ l : ZMod h, ((ε ^ m)⁻¹ ^ l.val) • (T ^ l.val) (b c))
      = a⁻¹ • ∑ l : ZMod h, ((ε ^ m)⁻¹ ^ l.val) • (T ^ l.val) ((T ^ k.val) (b c')) := by
    rw [hbc]
    simp only [map_smul]
    rw [Finset.smul_sum]
    exact Finset.sum_congr rfl fun l _ => smul_comm _ _ _
  rw [heq, sum_pow_smul_pow_comm T hε hεh hTh (b c') m k.val]
  exact Submodule.smul_mem _ _ (Submodule.smul_mem _ _ (Submodule.mem_span_singleton_self _))

/-- **The Fourier-projected representatives form a basis of `E_m`.** Given an index `I` and
`rep : I → κ` such that the projections span `E_m` (`hspan`), have nonzero diagonal coordinate
(`hdiag`), and vanish off-diagonal (`hoff`), then `finrank E_m = card I`. -/
theorem finrank_eigenspace_eq_card (b : Basis κ F W) (T : Module.End F W) {ε : F} {m : ℕ}
    {I : Type*} [Fintype I] (rep : I → κ)
    (hspan : Module.End.eigenspace T (ε ^ m) = Submodule.span F (Set.range fun i =>
      ∑ l : ZMod h, ((ε ^ m)⁻¹ ^ l.val) • (T ^ l.val) (b (rep i))))
    (hdiag : ∀ i, b.repr (∑ l : ZMod h, ((ε ^ m)⁻¹ ^ l.val) • (T ^ l.val) (b (rep i))) (rep i) ≠ 0)
    (hoff : ∀ i i', i ≠ i' →
      b.repr (∑ l : ZMod h, ((ε ^ m)⁻¹ ^ l.val) • (T ^ l.val) (b (rep i))) (rep i') = 0) :
    Module.finrank F (Module.End.eigenspace T (ε ^ m)) = Fintype.card I := by
  have hli : LinearIndependent F
      (fun i => ∑ l : ZMod h, ((ε ^ m)⁻¹ ^ l.val) • (T ^ l.val) (b (rep i))) :=
    linearIndependent_of_triangular b _ rep hdiag hoff
  rw [hspan, finrank_span_eq_card hli]

/-- **General orbit count** (issue 0106, publicized from the `count` block of
`finrank_eigenspace_fixed_succ`): `dim E_{ε^m} = #(contributing orbits)`.  Given a `Finset S`
of orbit representatives such that

* every index is either in the orbit of some `s ∈ S` or has vanishing Fourier projection
  (`hcover`) — so `S` carries every contributing orbit,
* distinct elements of `S` lie in distinct orbits (`hdisj`), and
* each `s ∈ S` has nonzero diagonal Fourier coordinate (`hdiag` — supplied by
  `repr_sum_fourier_self_free` for free orbits, `repr_sum_fourier_self_partial_of_pow_eq_one`
  for partial-period orbits of a plain permutation),

the `ε^m`-eigenspace of `T` has dimension exactly `S.card`. -/
theorem finrank_eigenspace_eq_card_contributing [Finite κ]
    (b : Basis κ F W) (T : Module.End F W) (σ : Equiv.Perm κ)
    (hmon : ∀ (k : ℕ) (c : κ), ∃ a : F, (T ^ k) (b c) = a • b ((σ ^ k) c))
    (hTh : T ^ h = 1)
    {ε : F} (hε : ε ≠ 0) (hεh : ε ^ h = 1) (hh : (h : F) ≠ 0) (m : ℕ)
    (S : Finset κ)
    (hcover : ∀ c : κ, (∃ s ∈ S, ∃ k : ZMod h, (σ ^ k.val) s = c) ∨
      (∑ l : ZMod h, ((ε ^ m)⁻¹ ^ l.val) • (T ^ l.val) (b c)) = 0)
    (hdisj : ∀ s ∈ S, ∀ s' ∈ S, (∃ k : ZMod h, (σ ^ k.val) s = s') → s = s')
    (hdiag : ∀ s ∈ S,
      b.repr (∑ l : ZMod h, ((ε ^ m)⁻¹ ^ l.val) • (T ^ l.val) (b s)) s ≠ 0) :
    Module.finrank F (Module.End.eigenspace T (ε ^ m)) = S.card := by
  classical
  have : Fintype κ := Fintype.ofFinite κ
  have hspan : Module.End.eigenspace T (ε ^ m) = Submodule.span F (Set.range fun i : ↥S =>
      ∑ l : ZMod h, ((ε ^ m)⁻¹ ^ l.val) • (T ^ l.val) (b (i : κ))) := by
    rw [eigenspace_eq_span_fourier b T hε hεh hTh hh m]
    refine le_antisymm (Submodule.span_le.mpr ?_) (Submodule.span_mono ?_)
    · rintro _ ⟨c, rfl⟩
      rcases hcover c with ⟨s, hsS, hk⟩ | hzero
      · refine Submodule.span_mono ?_ (fourier_mem_span_rep b T σ hmon hTh hε hεh m hk)
        rw [Set.singleton_subset_iff]
        exact ⟨⟨s, hsS⟩, rfl⟩
      · change (∑ l : ZMod h, ((ε ^ m)⁻¹ ^ l.val) • (T ^ l.val) (b c)) ∈ _
        rw [hzero]
        exact Submodule.zero_mem _
    · rintro _ ⟨i, rfl⟩; exact ⟨(i : κ), rfl⟩
  have hoff : ∀ i i' : ↥S, i ≠ i' →
      b.repr (∑ l : ZMod h, ((ε ^ m)⁻¹ ^ l.val) • (T ^ l.val) (b (i : κ))) (i' : κ) = 0 := by
    rintro ⟨s, hsS⟩ ⟨s', hs'S⟩ hne
    refine repr_sum_fourier_orbit_zero b T σ hmon (fun k hk => ?_)
    exact (fun h => hne (Subtype.ext h)) (hdisj s hsS s' hs'S ⟨k, hk⟩)
  have hcard := finrank_eigenspace_eq_card b T (Subtype.val : ↥S → κ) hspan
    (fun i => hdiag (i : κ) i.2) hoff
  rw [hcard, Fintype.card_coe]

/-- **Keystone (BG (2.11)).** For a monomial permutation operator `T` on `b : Basis κ F W`
(`T^k (b c) = a • b (σ^k c)`) with `σ^h = 1`, `T^h = 1`, `ε` a primitive `h`-th root, `char ∤ h`,
a `σ`-fixed `c₀` with `T (b c₀) = b c₀` whose orbit is the *only* non-free one
(every `c ≠ c₀` lies in a free orbit), the `ε`-eigenspaces of the conjugation `T` satisfy
`dim (E_{ε^0}) = dim (E_{ε^m}) + 1` for every `m` with `ε^m ≠ 1`.

`E_{ε^m}` is spanned by the Fourier projections of the orbit representatives
(`eigenspace_eq_span_fourier` + `fourier_mem_span_rep`); these are independent (disjoint orbit
support); so `dim E_{ε^m}` equals the number of *contributing* orbits — every orbit for `ε^0 = 1`,
all but the `c₀`-orbit for `ε^m ≠ 1` (where the fixed point projects to `0`). The orbit count
cancels, leaving the difference `1`. -/
theorem finrank_eigenspace_fixed_succ [Finite κ]
    (b : Basis κ F W) (T : Module.End F W) (σ : Equiv.Perm κ)
    (hmon : ∀ (k : ℕ) (c : κ), ∃ a : F, (T ^ k) (b c) = a • b ((σ ^ k) c))
    (hσ : σ ^ h = 1) (hTh : T ^ h = 1)
    {ε : F} (hprim : IsPrimitiveRoot ε h) (hh : (h : F) ≠ 0)
    {c₀ : κ} (hc₀ : T (b c₀) = b c₀) (hfixσ : σ c₀ = c₀)
    (hfree : ∀ c : κ, c ≠ c₀ → ∀ k : ZMod h, (σ ^ k.val) c = c → k = 0)
    {m : ℕ} (hm : ε ^ m ≠ 1) :
    Module.finrank F (Module.End.eigenspace T (ε ^ 0))
      = Module.finrank F (Module.End.eigenspace T (ε ^ m)) + 1 := by
  classical
  have : Fintype κ := Fintype.ofFinite κ
  let inst : Setoid κ := orbitSetoid σ hσ
  have hε0 : ε ≠ 0 := hprim.ne_zero (NeZero.ne h)
  have hεh : ε ^ h = 1 := hprim.pow_eq_one
  set rep : κ → κ := fun c => (Quotient.mk inst c).out with hrepdef
  have hmk_rep : ∀ c, Quotient.mk inst (rep c) = Quotient.mk inst c := fun c => Quotient.out_eq _
  have hrep_equiv : ∀ c, ∃ k : ZMod h, (σ ^ k.val) (rep c) = c :=
    fun c => Quotient.exact (hmk_rep c)
  have hrep_idem : ∀ c, rep (rep c) = rep c := fun c => by
    change (Quotient.mk inst (rep c)).out = (Quotient.mk inst c).out
    rw [hmk_rep]
  -- `c₀` is fixed by every power of `σ`.
  have hc₀pow : ∀ n : ℕ, (σ ^ n) c₀ = c₀ := by
    intro n; induction n with
    | zero => rfl
    | succ n ih => rw [pow_succ, Equiv.Perm.mul_apply, hfixσ, ih]
  -- `c₀` is its own representative, and the only element mapping to it.
  have hrep_c₀ : rep c₀ = c₀ := by
    obtain ⟨k, hk⟩ := hrep_equiv c₀
    exact (σ ^ k.val).injective (by rw [hk, hc₀pow k.val])
  have honly_c₀ : ∀ c, rep c = c₀ → c = c₀ := by
    intro c hc
    obtain ⟨k, hk⟩ := hrep_equiv c
    rw [hc] at hk
    rw [← hk, hc₀pow k.val]
  -- distinct representatives lie in distinct orbits
  have hdistinct : ∀ c c' : κ, rep c = c → rep c' = c' →
      (∃ k : ZMod h, (σ ^ k.val) c = c') → c = c' := by
    intro c c' hc hc' hcc'
    have : Quotient.mk inst c = Quotient.mk inst c' := Quotient.sound hcc'
    calc c = rep c := hc.symm
      _ = (Quotient.mk inst c).out := rfl
      _ = (Quotient.mk inst c').out := by rw [this]
      _ = rep c' := rfl
      _ = c' := hc'
  -- the fixed point projects to `0` for a nontrivial character
  have hg_c₀_zero : ∀ m', ε ^ m' ≠ 1 →
      (∑ l : ZMod h, ((ε ^ m')⁻¹ ^ l.val) • (T ^ l.val) (b c₀)) = 0 := by
    intro m' hm'
    have hroot : ((ε ^ m')⁻¹) ^ h = 1 := by
      rw [inv_pow, ← pow_mul, mul_comm, pow_mul, hεh, one_pow, inv_one]
    have hne1 : (ε ^ m')⁻¹ ≠ 1 := by rw [ne_eq, inv_eq_one]; exact hm'
    rw [sum_fourier_fixed_eq b T hc₀ m', sum_pow_val_eq_zero hroot hne1, zero_smul]
  -- per-character count: `dim E_{ε^m'} = #{contributing orbit reps}`
  -- (delegated to `finrank_eigenspace_eq_card_contributing`, issue 0106)
  have count : ∀ m' : ℕ, Module.finrank F (Module.End.eigenspace T (ε ^ m'))
      = (Finset.univ.filter (fun c => rep c = c ∧ (ε ^ m' = 1 ∨ c ≠ c₀))).card := by
    intro m'
    set S : Finset κ := Finset.univ.filter (fun c => rep c = c ∧ (ε ^ m' = 1 ∨ c ≠ c₀)) with hSdef
    have hSmem : ∀ c, c ∈ S ↔ rep c = c ∧ (ε ^ m' = 1 ∨ c ≠ c₀) := by
      intro c; rw [hSdef, Finset.mem_filter]; exact and_iff_right (Finset.mem_univ c)
    refine finrank_eigenspace_eq_card_contributing b T σ hmon hTh hε0 hεh hh m' S ?_ ?_ ?_
    · intro c
      by_cases hm1 : ε ^ m' = 1
      · exact Or.inl ⟨rep c, (hSmem _).2 ⟨hrep_idem c, Or.inl hm1⟩, hrep_equiv c⟩
      · by_cases hc0 : rep c = c₀
        · exact Or.inr (by rw [honly_c₀ c hc0]; exact hg_c₀_zero m' hm1)
        · exact Or.inl ⟨rep c, (hSmem _).2 ⟨hrep_idem c, Or.inr hc0⟩, hrep_equiv c⟩
    · intro s hsS s' hs'S hss'
      exact hdistinct s s' ((hSmem s).mp hsS).1 ((hSmem s').mp hs'S).1 hss'
    · intro s hsS
      rw [hSmem] at hsS
      by_cases hc0 : s = c₀
      · subst hc0
        have hm1 : ε ^ m' = 1 := hsS.2.resolve_right (by simp)
        rw [sum_fourier_fixed_eq b T hc₀ m', hm1, inv_one]
        simp only [one_pow]
        rw [sum_one_eq_card]
        simp only [map_smul, Finsupp.smul_apply, Basis.repr_self, Finsupp.single_eq_same,
          smul_eq_mul, mul_one]
        exact hh
      · rw [repr_sum_fourier_self_free b T σ hmon (hfree s hc0)]; exact one_ne_zero
  -- combine the two counts; the total orbit count cancels.
  rw [count 0, count m]
  have hPeq : (Finset.univ.filter (fun c => rep c = c ∧ (ε ^ 0 = 1 ∨ c ≠ c₀)))
      = Finset.univ.filter (fun c => rep c = c) :=
    Finset.filter_congr fun c _ => by simp [pow_zero]
  have hQeq : (Finset.univ.filter (fun c => rep c = c ∧ (ε ^ m = 1 ∨ c ≠ c₀)))
      = Finset.univ.filter (fun c => rep c = c ∧ c ≠ c₀) :=
    Finset.filter_congr fun c _ => by simp only [hm, false_or]
  rw [hPeq, hQeq]
  have hins : Finset.univ.filter (fun c => rep c = c)
      = insert c₀ (Finset.univ.filter (fun c => rep c = c ∧ c ≠ c₀)) := by
    ext c
    simp only [Finset.mem_filter, Finset.mem_univ, true_and, Finset.mem_insert]
    constructor
    · intro hc
      by_cases h : c = c₀
      · exact Or.inl h
      · exact Or.inr ⟨hc, h⟩
    · rintro (rfl | ⟨hc, _⟩)
      · exact hrep_c₀
      · exact hc
  have hnotmem : c₀ ∉ Finset.univ.filter (fun c => rep c = c ∧ c ≠ c₀) := by
    simp only [Finset.mem_filter, Finset.mem_univ, true_and, not_and]
    exact fun _ h => absurd rfl h
  rw [hins, Finset.card_insert_of_notMem hnotmem]

end CyclicPermEigen

end OddOrder.RepresentationTheory
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/GroupTheory/RepresentationTheory/CyclicPermEigenCount.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