Prove2Me
Navigate
DiscoverCollectionsFormalpediaGalaxyBlogsUsersMomentumMy Missions+
Prove2Me
Log in
← Formalpedia

Galois actions on class functions and irreducible characters

Definition
OddOrder_GroupTheory_RepresentationTheory_GaloisCharacter

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

feit-thompsonfinite-groupsgroup-theoryishida-odd-order

Coefficientwise automorphism infrastructure for class functions: a ring automorphism σ\sigmaσ of C\mathbb{C}C sends a class function φ\varphiφ to g↦σ(φ(g))g\mapsto\sigma(\varphi(g))g↦σ(φ(g)). The main theorem is that Galois conjugates of irreducible characters are irreducible, proved for every ring automorphism of C\mathbb{C}C via the σ\sigmaσ-twisted representation.

Main definitions: mapRingEquiv and mapRingEquivLinear (coefficientwise automorphism of class functions), galoisCoord (the σ\sigmaσ-twisted coordinate bijection), galoisTwist (the σ\sigmaσ-twist of a representation), galoisMap (the resulting irreducible character) and galoisPerm (Galois transport as a permutation of Irr(G)\mathrm{Irr}(G)Irr(G)).

The bundle also proves 33 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/GaloisCharacter.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_IrrIndexing
import Mathlib.Algebra.Module.LinearMap.Defs
import Mathlib.Data.Complex.Basic
import Mathlib.LinearAlgebra.Matrix.ToLin
import Mathlib.LinearAlgebra.Trace
import Mathlib.RepresentationTheory.Character
import Mathlib.RepresentationTheory.Irreducible

namespace OddOrder.RepresentationTheory

namespace ClassFunction

variable {G : Type*} [Group G]

/-- Apply a ring automorphism of `ℂ` coefficientwise to a class function. -/
def mapRingEquiv (σ : ℂ ≃+* ℂ) (φ : ClassFunction G ℂ) : ClassFunction G ℂ :=
  ⟨fun g => σ (φ g), by
    intro g h
    exact congrArg σ (φ.conj_eq g h)
  ⟩

@[simp] theorem mapRingEquiv_apply (σ : ℂ ≃+* ℂ) (φ : ClassFunction G ℂ) (g : G) :
    mapRingEquiv σ φ g = σ (φ g) :=
  rfl

@[simp] theorem mapRingEquiv_zero (σ : ℂ ≃+* ℂ) :
    mapRingEquiv (G := G) σ 0 = 0 := by
  ext g
  simp [mapRingEquiv]

set_option backward.isDefEq.respectTransparency false in
@[simp] theorem mapRingEquiv_add (σ : ℂ ≃+* ℂ) (φ ψ : ClassFunction G ℂ) :
    mapRingEquiv σ (φ + ψ) = mapRingEquiv σ φ + mapRingEquiv σ ψ := by
  ext g
  simp [mapRingEquiv]

set_option backward.isDefEq.respectTransparency false in
@[simp] theorem mapRingEquiv_neg (σ : ℂ ≃+* ℂ) (φ : ClassFunction G ℂ) :
    mapRingEquiv σ (-φ) = -mapRingEquiv σ φ := by
  ext g
  simp [mapRingEquiv]

set_option backward.isDefEq.respectTransparency false in
@[simp] theorem mapRingEquiv_sub (σ : ℂ ≃+* ℂ) (φ ψ : ClassFunction G ℂ) :
    mapRingEquiv σ (φ - ψ) = mapRingEquiv σ φ - mapRingEquiv σ ψ := by
  ext g
  simp [mapRingEquiv]

@[simp] theorem zsmul_apply (n : ℤ) (φ : ClassFunction G ℂ) (g : G) :
    (n • φ) g = n • φ g := rfl

set_option backward.isDefEq.respectTransparency false in
@[simp] theorem mapRingEquiv_zsmul (σ : ℂ ≃+* ℂ) (n : ℤ) (φ : ClassFunction G ℂ) :
    mapRingEquiv σ (n • φ) = n • mapRingEquiv σ φ := by
  ext g
  simp [mapRingEquiv]

/-- Coefficientwise automorphism as a `ℤ`-linear map of class functions. -/
def mapRingEquivLinear (σ : ℂ ≃+* ℂ) : (ClassFunction G ℂ →ₗ[ℤ] ClassFunction G ℂ) :=
  { toFun := mapRingEquiv σ
    map_add' := fun φ ψ => mapRingEquiv_add σ φ ψ
    map_smul' := fun n φ => mapRingEquiv_zsmul σ n φ }

@[simp] theorem mapRingEquivLinear_apply (σ : ℂ ≃+* ℂ) (φ : ClassFunction G ℂ) :
    mapRingEquivLinear (G := G) σ φ = mapRingEquiv σ φ :=
  rfl

@[simp] theorem mapRingEquiv_refl (φ : ClassFunction G ℂ) :
    mapRingEquiv (RingEquiv.refl ℂ) φ = φ := by
  ext g
  simp [mapRingEquiv]

@[simp] theorem mapRingEquiv_symm_mapRingEquiv (σ : ℂ ≃+* ℂ) (φ : ClassFunction G ℂ) :
    mapRingEquiv σ.symm (mapRingEquiv σ φ) = φ := by
  ext g
  simp [mapRingEquiv]

@[simp] theorem mapRingEquiv_mapRingEquiv_symm (σ : ℂ ≃+* ℂ) (φ : ClassFunction G ℂ) :
    mapRingEquiv σ (mapRingEquiv σ.symm φ) = φ := by
  ext g
  simp [mapRingEquiv]

@[simp] theorem mapRingEquiv_eq_zero_iff (σ : ℂ ≃+* ℂ) (φ : ClassFunction G ℂ) :
    mapRingEquiv σ φ = 0 ↔ φ = 0 := by
  constructor
  · intro h
    simpa using congrArg (mapRingEquiv σ.symm) h
  · intro h
    simp [h]

@[simp] theorem mapRingEquiv_ne_zero_iff (σ : ℂ ≃+* ℂ) (φ : ClassFunction G ℂ) :
    mapRingEquiv σ φ ≠ 0 ↔ φ ≠ 0 :=
  not_congr (mapRingEquiv_eq_zero_iff σ φ)

@[simp] theorem mem_support_mapRingEquiv (σ : ℂ ≃+* ℂ) (φ : ClassFunction G ℂ) (g : G) :
    g ∈ (mapRingEquiv σ φ).support ↔ g ∈ φ.support := by
  simp [support, mapRingEquiv]

@[simp] theorem support_mapRingEquiv (σ : ℂ ≃+* ℂ) (φ : ClassFunction G ℂ) :
    (mapRingEquiv σ φ).support = φ.support := by
  ext g
  simp

end ClassFunction

section GaloisTwist

open Module (Basis)

variable {G : Type*} [Group G] {V : Type*} [AddCommGroup V] [Module ℂ V]
  {ι : Type*} [Fintype ι]

/-- The `σ`-twisted coordinate bijection attached to a basis `b` of `V`: send `v` to its
coordinate vector with `σ` applied entrywise.  It is additive and `σ`-semilinear
(`galoisCoord_smul`); we package only the additive bijection and carry the twisted scalar
action as a separate lemma, which is all the lattice transfer below needs. -/
noncomputable def galoisCoord (σ : ℂ ≃+* ℂ) (b : Basis ι ℂ V) : V ≃+ (ι → ℂ) where
  toFun v := fun i => σ (b.repr v i)
  invFun w := b.repr.symm (Finsupp.equivFunOnFinite.symm fun i => σ.symm (w i))
  left_inv v := by
    have h : (fun i => σ.symm (σ (b.repr v i))) = ⇑(b.repr v) := by
      funext i
      rw [RingEquiv.symm_apply_apply]
    change b.repr.symm (Finsupp.equivFunOnFinite.symm fun i => σ.symm (σ (b.repr v i))) = v
    rw [h, Finsupp.equivFunOnFinite_symm_coe]
    exact b.repr.symm_apply_apply v
  right_inv w := by
    funext i
    change σ (b.repr (b.repr.symm (Finsupp.equivFunOnFinite.symm fun i => σ.symm (w i))) i) = w i
    rw [LinearEquiv.apply_symm_apply]
    exact σ.apply_symm_apply (w i)
  map_add' v₁ v₂ := by
    funext i
    change σ (b.repr (v₁ + v₂) i) = σ (b.repr v₁ i) + σ (b.repr v₂ i)
    rw [map_add, Finsupp.add_apply, map_add]

@[simp] theorem galoisCoord_apply (σ : ℂ ≃+* ℂ) (b : Basis ι ℂ V) (v : V) (i : ι) :
    galoisCoord σ b v i = σ (b.repr v i) :=
  rfl

/-- `galoisCoord` is `σ`-semilinear. -/
theorem galoisCoord_smul (σ : ℂ ≃+* ℂ) (b : Basis ι ℂ V) (c : ℂ) (v : V) :
    galoisCoord σ b (c • v) = σ c • galoisCoord σ b v := by
  funext i
  rw [galoisCoord_apply, map_smul, Finsupp.smul_apply, smul_eq_mul, map_mul, Pi.smul_apply,
    smul_eq_mul, galoisCoord_apply]

theorem galoisCoord_symm_smul (σ : ℂ ≃+* ℂ) (b : Basis ι ℂ V) (c : ℂ) (w : ι → ℂ) :
    (galoisCoord σ b).symm (c • w) = σ.symm c • (galoisCoord σ b).symm w := by
  apply (galoisCoord σ b).injective
  rw [AddEquiv.apply_symm_apply, galoisCoord_smul, RingEquiv.apply_symm_apply,
    AddEquiv.apply_symm_apply]

theorem galoisCoord_basis [DecidableEq ι] (σ : ℂ ≃+* ℂ) (b : Basis ι ℂ V) (j : ι) :
    galoisCoord σ b (b j) = Pi.single j 1 := by
  funext i
  rw [galoisCoord_apply, Basis.repr_self]
  rcases eq_or_ne i j with rfl | h
  · rw [Finsupp.single_eq_same, map_one, Pi.single_eq_same]
  · rw [Finsupp.single_eq_of_ne h, map_zero, Pi.single_eq_of_ne h]

theorem galoisCoord_symm_single [DecidableEq ι] (σ : ℂ ≃+* ℂ) (b : Basis ι ℂ V) (j : ι) :
    (galoisCoord σ b).symm (Pi.single j 1) = b j := by
  rw [AddEquiv.symm_apply_eq, galoisCoord_basis]

/-- The `σ`-twist of a representation `ρ : Representation ℂ G V`, realized on the coordinate
space `ι → ℂ` of a basis `b`: conjugate each `ρ g` by `galoisCoord σ b`.  The two coordinate
twists cancel the semilinearity, so each map is genuinely `ℂ`-linear. -/
noncomputable def galoisTwist (σ : ℂ ≃+* ℂ) (ρ : Representation ℂ G V) (b : Basis ι ℂ V) :
    Representation ℂ G (ι → ℂ) where
  toFun g :=
    { toFun := fun w => galoisCoord σ b (ρ g ((galoisCoord σ b).symm w))
      map_add' := fun w₁ w₂ => by rw [map_add, map_add, map_add]
      map_smul' := fun c w => by
        rw [RingHom.id_apply, galoisCoord_symm_smul, map_smul, galoisCoord_smul,
          RingEquiv.apply_symm_apply] }
  map_one' := by
    ext w
    simp
  map_mul' g h := by
    ext w
    simp [Module.End.mul_apply]

@[simp] theorem galoisTwist_apply (σ : ℂ ≃+* ℂ) (ρ : Representation ℂ G V)
    (b : Basis ι ℂ V) (g : G) (w : ι → ℂ) :
    galoisTwist σ ρ b g w = galoisCoord σ b (ρ g ((galoisCoord σ b).symm w)) :=
  rfl

theorem galoisTwist_apply_galoisCoord (σ : ℂ ≃+* ℂ) (ρ : Representation ℂ G V)
    (b : Basis ι ℂ V) (g : G) (v : V) :
    galoisTwist σ ρ b g (galoisCoord σ b v) = galoisCoord σ b (ρ g v) := by
  rw [galoisTwist_apply, AddEquiv.symm_apply_apply]

/-- The character of the `σ`-twist is the `σ`-image of the character: in the standard basis
of `ι → ℂ` the matrix of `galoisTwist σ ρ b g` is the entrywise `σ`-image of the matrix of
`ρ g` in the basis `b`. -/
theorem character_galoisTwist (σ : ℂ ≃+* ℂ) (ρ : Representation ℂ G V) (b : Basis ι ℂ V)
    (g : G) :
    (galoisTwist σ ρ b).character g = σ (ρ.character g) := by
  classical
  have hmat : LinearMap.toMatrix (Pi.basisFun ℂ ι) (Pi.basisFun ℂ ι) (galoisTwist σ ρ b g) =
      (LinearMap.toMatrix b b (ρ g)).map ⇑σ := by
    ext i j
    simp only [LinearMap.toMatrix_apply, Matrix.map_apply, Pi.basisFun_repr, Pi.basisFun_apply,
      galoisTwist_apply, galoisCoord_symm_single, galoisCoord_apply]
  change LinearMap.trace ℂ (ι → ℂ) (galoisTwist σ ρ b g) = σ (LinearMap.trace ℂ V (ρ g))
  rw [LinearMap.trace_eq_matrix_trace ℂ (Pi.basisFun ℂ ι), hmat,
    LinearMap.trace_eq_matrix_trace ℂ b, AddMonoidHom.map_trace]

/-- The `σ`-twist of an irreducible representation is irreducible: pulling a
subrepresentation of the twist back along `galoisCoord σ b` (an additive bijection that
intertwines the two actions and twists scalars by the bijection `σ`) yields a
subrepresentation of `ρ`. -/
theorem isIrreducible_galoisTwist (σ : ℂ ≃+* ℂ) {ρ : Representation ℂ G V}
    (b : Basis ι ℂ V) (hρ : ρ.IsIrreducible) : (galoisTwist σ ρ b).IsIrreducible := by
  have := hρ
  have : Nontrivial V := by
    by_contra hV
    rw [not_nontrivial_iff_subsingleton] at hV
    have hbt : (⊥ : Submodule ℂ V) = ⊤ := by
      ext v
      simp [Subsingleton.elim v 0]
    exact bot_ne_top (α := Subrepresentation ρ)
      (Subrepresentation.toSubmodule_injective hbt)
  refine { toNontrivial := ?_, eq_bot_or_eq_top := fun S' => ?_ }
  · -- `⊥ ≠ ⊤` for subrepresentations of the twist, since `ι → ℂ` is nontrivial
    refine ⟨⊥, ⊤, fun h => ?_⟩
    have hsub : (⊥ : Submodule ℂ (ι → ℂ)) = ⊤ := congrArg Subrepresentation.toSubmodule h
    obtain ⟨v, w, hvw⟩ := exists_pair_ne V
    refine hvw ((galoisCoord σ b).injective ?_)
    have hmem : ∀ u : ι → ℂ, u ∈ (⊥ : Submodule ℂ (ι → ℂ)) := fun u => by
      rw [hsub]; exact Submodule.mem_top
    have h₁ := Submodule.mem_bot ℂ |>.mp (hmem (galoisCoord σ b v))
    have h₂ := Submodule.mem_bot ℂ |>.mp (hmem (galoisCoord σ b w))
    rw [h₁, h₂]
  · -- pull `S'` back along `galoisCoord σ b` to a subrepresentation of `ρ`
    let p : Submodule ℂ V :=
      { carrier := {v : V | galoisCoord σ b v ∈ S'.toSubmodule}
        add_mem' := fun {v₁ v₂} h₁ h₂ => by
          change galoisCoord σ b (v₁ + v₂) ∈ S'.toSubmodule
          rw [map_add]
          exact S'.toSubmodule.add_mem h₁ h₂
        zero_mem' := by
          change galoisCoord σ b 0 ∈ S'.toSubmodule
          rw [map_zero]
          exact S'.toSubmodule.zero_mem
        smul_mem' := fun c v hv => by
          change galoisCoord σ b (c • v) ∈ S'.toSubmodule
          rw [galoisCoord_smul]
          exact S'.toSubmodule.smul_mem (σ c) hv }
    have hp : ∀ (g : G) ⦃v : V⦄, v ∈ p → ρ g v ∈ p := fun g v hv => by
      change galoisCoord σ b (ρ g v) ∈ S'.toSubmodule
      rw [← galoisTwist_apply_galoisCoord σ ρ b g v]
      exact S'.apply_mem_toSubmodule g hv
    rcases hρ.eq_bot_or_eq_top ⟨p, hp⟩ with h | h
    · left
      apply Subrepresentation.toSubmodule_injective
      have hp_bot : p = (⊥ : Submodule ℂ V) := congrArg Subrepresentation.toSubmodule h
      change S'.toSubmodule = (⊥ : Submodule ℂ (ι → ℂ))
      rw [Submodule.eq_bot_iff]
      intro w hw
      have hv : (galoisCoord σ b).symm w ∈ p := by
        change galoisCoord σ b ((galoisCoord σ b).symm w) ∈ S'.toSubmodule
        rw [AddEquiv.apply_symm_apply]
        exact hw
      rw [hp_bot, Submodule.mem_bot] at hv
      rw [← (galoisCoord σ b).apply_symm_apply w, hv, map_zero]
    · right
      apply Subrepresentation.toSubmodule_injective
      have hp_top : p = (⊤ : Submodule ℂ V) := congrArg Subrepresentation.toSubmodule h
      change S'.toSubmodule = (⊤ : Submodule ℂ (ι → ℂ))
      rw [Submodule.eq_top_iff']
      intro w
      have hv : (galoisCoord σ b).symm w ∈ p := by
        rw [hp_top]
        exact Submodule.mem_top
      have hw : galoisCoord σ b ((galoisCoord σ b).symm w) ∈ S'.toSubmodule := hv
      rwa [AddEquiv.apply_symm_apply] at hw

/-- **Galois conjugates of irreducible characters are irreducible.**  For any ring
automorphism `σ : ℂ ≃+* ℂ` and any irreducible character `φ` of `G`, the coefficientwise
transport `g ↦ σ (φ g)` is again an irreducible character: the witnessing representation is
the `σ`-twist `galoisTwist σ ρ b` of a witness `ρ` for `φ`. -/
theorem IsIrreducibleCharacter.mapRingEquiv {φ : ClassFunction G ℂ} (σ : ℂ ≃+* ℂ)
    (hφ : IsIrreducibleCharacter φ) :
    IsIrreducibleCharacter (ClassFunction.mapRingEquiv σ φ) := by
  classical
  obtain ⟨W, _, _, _, ρ, hirr, hchar⟩ := hφ
  let b := Module.Free.chooseBasis ℂ W
  refine ⟨Module.Free.ChooseBasisIndex ℂ W → ℂ, inferInstance, inferInstance, inferInstance,
    galoisTwist σ ρ b, isIrreducible_galoisTwist σ b hirr, ?_⟩
  funext g
  change σ (φ g) = (galoisTwist σ ρ b).character g
  rw [character_galoisTwist]
  exact congrArg σ (congrFun hchar g)

end GaloisTwist

namespace IrreducibleCharacter

variable {G : Type*} [Group G]

/-- The irreducible character obtained by coefficientwise Galois transport. -/
noncomputable def galoisMap (σ : ℂ ≃+* ℂ) (χ : IrreducibleCharacter G) :
    IrreducibleCharacter G :=
  ⟨ClassFunction.mapRingEquiv σ (χ : ClassFunction G ℂ),
    IsIrreducibleCharacter.mapRingEquiv σ χ.2⟩

@[simp] theorem galoisMap_apply_coe (σ : ℂ ≃+* ℂ) (χ : IrreducibleCharacter G) :
    ((galoisMap σ χ : IrreducibleCharacter G) : ClassFunction G ℂ) =
      ClassFunction.mapRingEquiv σ (χ : ClassFunction G ℂ) :=
  rfl

@[simp] theorem galoisMap_apply_apply (σ : ℂ ≃+* ℂ) (χ : IrreducibleCharacter G) (g : G) :
    ((galoisMap σ χ : IrreducibleCharacter G) : ClassFunction G ℂ) g =
      σ ((χ : ClassFunction G ℂ) g) :=
  rfl

@[simp] theorem galoisMap_refl (χ : IrreducibleCharacter G) :
    galoisMap (RingEquiv.refl ℂ) χ = χ := by
  apply IrreducibleCharacter.ext
  simp [galoisMap]

@[simp] theorem galoisMap_symm_galoisMap (σ : ℂ ≃+* ℂ) (χ : IrreducibleCharacter G) :
    galoisMap σ.symm (galoisMap σ χ) = χ := by
  apply IrreducibleCharacter.ext
  simp [galoisMap]

@[simp] theorem galoisMap_galoisMap_symm (σ : ℂ ≃+* ℂ) (χ : IrreducibleCharacter G) :
    galoisMap σ (galoisMap σ.symm χ) = χ := by
  apply IrreducibleCharacter.ext
  simp [galoisMap]

/-- Coefficientwise Galois transport as a permutation of `Irr(G)`. -/
noncomputable def galoisPerm (σ : ℂ ≃+* ℂ) : Equiv.Perm (IrreducibleCharacter G) where
  toFun := galoisMap σ
  invFun := galoisMap σ.symm
  left_inv := galoisMap_symm_galoisMap σ
  right_inv := galoisMap_galoisMap_symm σ

@[simp] theorem galoisPerm_apply (σ : ℂ ≃+* ℂ) (χ : IrreducibleCharacter G) :
    galoisPerm σ χ = galoisMap σ χ :=
  rfl

@[simp] theorem galoisPerm_apply_coe (σ : ℂ ≃+* ℂ) (χ : IrreducibleCharacter G) :
    ((galoisPerm σ χ : IrreducibleCharacter G) : ClassFunction G ℂ) =
      ClassFunction.mapRingEquiv σ (χ : ClassFunction G ℂ) :=
  rfl

@[simp] theorem galoisPerm_apply_apply (σ : ℂ ≃+* ℂ) (χ : IrreducibleCharacter G) (g : G) :
    ((galoisPerm σ χ : IrreducibleCharacter G) : ClassFunction G ℂ) g =
      σ ((χ : ClassFunction G ℂ) g) :=
  rfl

@[simp] theorem galoisPerm_refl :
    galoisPerm (G := G) (RingEquiv.refl ℂ) = Equiv.refl (IrreducibleCharacter G) := by
  ext χ g
  simp [galoisPerm, galoisMap]

end IrreducibleCharacter

namespace ClassFunction

variable {G : Type*} [Group G]

/-- A coefficientwise automorphism sends `Irr(G)` into `Irr(G)`. -/
theorem mapRingEquiv_mem_irreducibleCharacters (σ : ℂ ≃+* ℂ)
    {φ : ClassFunction G ℂ} (hφ : φ ∈ irreducibleCharacters G) :
    mapRingEquiv σ φ ∈ irreducibleCharacters G :=
  IsIrreducibleCharacter.mapRingEquiv σ hφ

/-- A coefficientwise automorphism permutes `Irr(G)`. -/
@[simp] theorem mapRingEquiv_image_irreducibleCharacters (σ : ℂ ≃+* ℂ) :
    mapRingEquiv σ '' irreducibleCharacters G = irreducibleCharacters G := by
  ext φ
  constructor
  · rintro ⟨ψ, hψ, rfl⟩
    exact mapRingEquiv_mem_irreducibleCharacters σ hψ
  · intro hφ
    exact ⟨mapRingEquiv σ.symm φ, mapRingEquiv_mem_irreducibleCharacters σ.symm hφ,
      mapRingEquiv_mapRingEquiv_symm σ φ⟩

/-- A coefficientwise automorphism preserves the virtual character lattice `ℤ[Irr G]`. -/
theorem mapRingEquiv_mem_ZIrr (σ : ℂ ≃+* ℂ)
    {φ : ClassFunction G ℂ} (hφ : φ ∈ ZIrr G) :
    mapRingEquiv σ φ ∈ ZIrr G := by
  induction hφ using Submodule.span_induction with
  | mem x hx =>
      exact IsIrreducibleCharacter.mem_ZIrr
        (mapRingEquiv_mem_irreducibleCharacters σ hx)
  | zero =>
      rw [mapRingEquiv_zero]
      exact Submodule.zero_mem _
  | add x y _ _ hx hy =>
      rw [mapRingEquiv_add]
      exact Submodule.add_mem _ hx hy
  | smul n x _ hx =>
      rw [mapRingEquiv_zsmul]
      exact Submodule.smul_mem _ n hx

end ClassFunction

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