Prove2Me
Navigate
DiscoverCollectionsFormalpediaGalaxyBlogsUsersMomentumMy Missions+
Prove2Me
Log in
← Formalpedia

The virtual character lattice Z[Irr G]\mathbb{Z}[\mathrm{Irr}\,G]Z[IrrG]

Definition
OddOrder_GroupTheory_RepresentationTheory_ZIrr

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

feit-thompsonfinite-groupsgroup-theoryishida-odd-order

Formalizes Peterfalvi's Z[Irr G]\mathbb{Z}[\mathrm{Irr}\,G]Z[IrrG] (Character Theory for the Odd Order Theorem, §2): the Z\mathbb{Z}Z-submodule of complex-valued class functions generated by the irreducible characters, whose elements are the virtual characters of GGG.

Main definitions: IsIrreducibleCharacter (a class function is the character of a finite-dimensional irreducible C\mathbb{C}C-representation), irreducibleCharacters (Irr(G)\mathrm{Irr}(G)Irr(G)), ZIrr (the Z\mathbb{Z}Z-span of the irreducible characters), IsCharacter (genuine characters), repCharacterClassFunction (the class function of a representation), and trivialClassFunction.

The bundle also proves 9 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/ZIrr.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_ClassFunction
import Definitions.Def_OddOrder_GroupTheory_RepresentationTheory_ClassSumAlgebra
import Mathlib.Data.Complex.Basic
import Mathlib.LinearAlgebra.Span.Basic
import Mathlib.RepresentationTheory.Character
import Mathlib.RepresentationTheory.Irreducible

namespace OddOrder.RepresentationTheory

open scoped MonoidAlgebra

variable {G : Type*} [Group G]

/-- The trivial complex character, as a class function: it is constantly `1`. -/
def trivialClassFunction (G : Type*) [Group G] : ClassFunction G ℂ :=
  ⟨fun _ => 1, fun _ _ => rfl⟩

@[simp] theorem trivialClassFunction_apply (g : G) :
    trivialClassFunction G g = 1 :=
  rfl

section RepToClassFunction

variable {V : Type} [AddCommGroup V] [Module ℂ V] [FiniteDimensional ℂ V]

/-- The `ClassFunction G ℂ` attached to a finite-dimensional `ℂ`-representation `ρ` of `G`:
its value at `g` is the trace of `ρ g`. Conjugation invariance follows from
`Representation.char_conj`.

`V` is restricted to `Type 0`; this is sufficient for the irreducible character predicate
because every finite-dimensional `ℂ`-representation has a representative on a vector space
in `Type 0` (e.g. `Fin n → ℂ`). -/
noncomputable def repCharacterClassFunction (ρ : Representation ℂ G V) :
    ClassFunction G ℂ :=
  ⟨ρ.character, fun g h => ρ.char_conj g h⟩

omit [FiniteDimensional ℂ V] in
@[simp] theorem repCharacterClassFunction_apply (ρ : Representation ℂ G V) (g : G) :
    (repCharacterClassFunction ρ : G → ℂ) g = ρ.character g := rfl

end RepToClassFunction

/-- A class function `φ : ClassFunction G ℂ` is an **irreducible character** if there is a
finite-dimensional irreducible `ℂ`-representation `ρ` of `G` (on a vector space in `Type 0`)
whose character is `φ`. -/
def IsIrreducibleCharacter (φ : ClassFunction G ℂ) : Prop :=
  ∃ (V : Type) (_ : AddCommGroup V) (_ : Module ℂ V) (_ : FiniteDimensional ℂ V)
      (ρ : Representation ℂ G V), Representation.IsIrreducible ρ ∧
        (φ : G → ℂ) = ρ.character

/-- The trivial class function is an irreducible character. -/
theorem trivialClassFunction_isIrreducible :
    IsIrreducibleCharacter (trivialClassFunction G) := by
  let ρ : Representation ℂ G ℂ := Representation.trivial ℂ G ℂ
  refine ⟨ℂ, inferInstance, inferInstance, inferInstance, ρ, ?_, ?_⟩
  · change IsSimpleOrder (Subrepresentation ρ)
    refine { toNontrivial := ?_, eq_bot_or_eq_top := ?_ }
    · refine ⟨⟨⊥, ⊤, ?_⟩⟩
      intro h
      have hmem : (1 : ℂ) ∈ (⊥ : Subrepresentation ρ) := by
        rw [h]
        trivial
      have hone : (1 : ℂ) = 0 := by
        change (1 : ℂ) ∈ (⊥ : Submodule ℂ ℂ) at hmem
        simpa only [Submodule.mem_bot] using hmem
      exact one_ne_zero hone
    · intro S
      by_cases hS : S = ⊥
      · exact Or.inl hS
      · right
        apply le_antisymm le_top
        intro z _
        have hnonzero : ∃ y : ℂ, y ∈ S ∧ y ≠ 0 := by
          by_contra h
          apply hS
          apply le_antisymm
          · intro y hy
            have hy0 : y = 0 := by
              by_contra hy0
              exact h ⟨y, hy, hy0⟩
            subst hy0
            change (0 : ℂ) ∈ (⊥ : Submodule ℂ ℂ)
            simp
          · exact bot_le
        obtain ⟨y, hyS, hy0⟩ := hnonzero
        have hz : z = (z / y) • y := by
          calc
            z = (z / y) * y := by field_simp [hy0]
            _ = (z / y) • y := rfl
        rw [hz]
        exact S.toSubmodule.smul_mem (z / y) hyS
  · funext g
    simp [Representation.character]

/-- The set of irreducible characters of `G` (Peterfalvi `Irr(G)`). -/
def irreducibleCharacters (G : Type*) [Group G] : Set (ClassFunction G ℂ) :=
  { φ | IsIrreducibleCharacter φ }

@[simp] theorem mem_irreducibleCharacters {φ : ClassFunction G ℂ} :
    φ ∈ irreducibleCharacters G ↔ IsIrreducibleCharacter φ := Iff.rfl

/-- Peterfalvi's `ℤ[Irr G]`: the `ℤ`-submodule of `ClassFunction G ℂ` spanned by the
irreducible characters. Members are **virtual characters**. -/
def ZIrr (G : Type*) [Group G] : Submodule ℤ (ClassFunction G ℂ) :=
  Submodule.span ℤ (irreducibleCharacters G)

theorem ZIrr_eq_span :
    ZIrr G = Submodule.span ℤ (irreducibleCharacters G) := rfl

/-- Every irreducible character is a virtual character. -/
theorem IsIrreducibleCharacter.mem_ZIrr {φ : ClassFunction G ℂ}
    (hφ : IsIrreducibleCharacter φ) : φ ∈ ZIrr G :=
  Submodule.subset_span hφ

/-- A class function `φ : ClassFunction G ℂ` is a **(genuine) character** if there is a
finite-dimensional `ℂ`-representation `ρ` of `G` (on a vector space in `Type 0`) whose
character is `φ`.  This is the non-irreducible analogue of `IsIrreducibleCharacter`: the
character of an actual module, as opposed to a virtual (`ℤ`-combination) character in
`ZIrr G`.  Genuine characters are exactly those virtual characters whose Fourier
coefficients `⟨φ, ψ⟩` are all non-negative integers (`IsCharacter.exists_natFinsupp_eq_sum`). -/
def IsCharacter (φ : ClassFunction G ℂ) : Prop :=
  ∃ (V : Type) (_ : AddCommGroup V) (_ : Module ℂ V) (_ : FiniteDimensional ℂ V)
      (ρ : Representation ℂ G V), (φ : G → ℂ) = ρ.character

/-- An irreducible character is in particular a genuine character (forget irreducibility). -/
theorem IsIrreducibleCharacter.isCharacter {φ : ClassFunction G ℂ}
    (hφ : IsIrreducibleCharacter φ) : IsCharacter φ := by
  obtain ⟨V, _, _, _, ρ, _, hρ⟩ := hφ
  exact ⟨V, inferInstance, inferInstance, inferInstance, ρ, hρ⟩

/-- The character of a finite-dimensional `ℂ`-representation (on `Type 0`) is a genuine
character. -/
theorem repCharacterClassFunction_isCharacter
    {V : Type} [AddCommGroup V] [Module ℂ V] [FiniteDimensional ℂ V]
    (ρ : Representation ℂ G V) :
    IsCharacter (repCharacterClassFunction ρ) :=
  ⟨V, inferInstance, inferInstance, inferInstance, ρ, rfl⟩

section Degree

open Module (finrank)

/-- **The degree of an irreducible character divides the group order** (Isaacs,
*Character Theory of Finite Groups*, Thm 3.11).  For an irreducible character `φ` of a finite
group `G`, there is a positive natural number `n` (the dimension of any witnessing
representation, i.e. the representation degree) with `φ 1 = n` and `n ∣ |G|`.

This is the `IsIrreducibleCharacter`/`ClassFunction`-level restatement of `finrank_dvd_card`,
making the classical integrality `χ(1) ∣ |G|` consumable through the value `φ 1`.  Since
Peterfalvi's `characterDegree φ` is *definitionally* `φ 1` (`characterDegree_def`), this is
exactly `characterDegree φ ∣ |G|` recast over `ℕ`. -/
theorem IsIrreducibleCharacter.exists_natDegree_charValue_one_dvd_card [Finite G]
    {φ : ClassFunction G ℂ} (hφ : IsIrreducibleCharacter φ) :
    ∃ n : ℕ, 0 < n ∧ φ 1 = (n : ℂ) ∧ n ∣ Nat.card G := by
  obtain ⟨V, _, _, _, ρ, hirr, hchar⟩ := hφ
  have : Representation.IsIrreducible ρ := hirr
  have := nontrivial_of_isIrreducible ρ
  refine ⟨finrank ℂ V, Module.finrank_pos, ?_, finrank_dvd_card ρ⟩
  have hone : (φ : G → ℂ) 1 = ρ.character 1 := by rw [hchar]
  rw [show φ 1 = (φ : G → ℂ) 1 from rfl, hone, ρ.char_one]

/-- **The degree of an irreducible character of a `p`-group is a power of `p`** (Isaacs,
*Character Theory of Finite Groups*, Cor. 3.12 / standard).  If `G` is a finite `p`-group and `φ`
is an irreducible complex character of `G`, then `φ 1` (the representation degree) is a power of
the prime `p`.

This refines `exists_natDegree_charValue_one_dvd_card` (which only records `φ 1 ∣ |G|`) using the
sharper prime-power fact `exists_finrank_eq_prime_pow_of_isPGroup`: the witnessing irreducible
representation has `dim V = p ^ k`, and `φ 1 = dim V` by `char_one`.  It is the degree datum
behind Peterfalvi (6.6) ("for all `j`, `θⱼ(1)` is a power of `p`", mmd L80), where `K` is a
non-abelian `p`-group by (6.5.b). -/
theorem IsIrreducibleCharacter.exists_charValue_one_eq_prime_pow_of_isPGroup [Finite G]
    {p : ℕ} [Fact p.Prime] (hp : IsPGroup p G)
    {φ : ClassFunction G ℂ} (hφ : IsIrreducibleCharacter φ) :
    ∃ k : ℕ, φ 1 = (p ^ k : ℂ) := by
  obtain ⟨V, _, _, _, ρ, hirr, hchar⟩ := hφ
  have : Representation.IsIrreducible ρ := hirr
  have := nontrivial_of_isIrreducible ρ
  obtain ⟨k, hk⟩ := exists_finrank_eq_prime_pow_of_isPGroup hp ρ
  refine ⟨k, ?_⟩
  have hone : (φ : G → ℂ) 1 = ρ.character 1 := by rw [hchar]
  rw [show φ 1 = (φ : G → ℂ) 1 from rfl, hone, ρ.char_one, hk]
  push_cast
  ring

end Degree

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/ZIrr.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