Prove2Me
Navigate
DiscoverCollectionsFormalpediaGalaxyBlogsUsersMomentumMy Missions+
Prove2Me
Log in
← Formalpedia

Peterfalvi (1.10): cyclotomic congruences of character values

Definition
OddOrder_GroupTheory_RepresentationTheory_CyclotomicCharacterCongruence

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

feit-thompsonfinite-groupsgroup-theoryishida-odd-order

Formalizes the cyclotomic-integer arithmetic behind Peterfalvi (1.10) (Peterfalvi, Character Theory for the Odd Order Theorem, §1, p. 7), including divisibility properties of 1−ε1-\varepsilon1−ε powers for primitive ppp-th roots of unity.

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/GroupTheory/RepresentationTheory/CyclotomicCharacterCongruence.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_ClassSumAlgebra
import Definitions.Def_OddOrder_GroupTheory_RepresentationTheory_ZIrr
import Definitions.Def_OddOrder_GroupTheory_RepresentationTheory_LinearCharacter
import Definitions.Def_OddOrder_GroupTheory_RepresentationTheory_InducedCharacter
import Mathlib.NumberTheory.Cyclotomic.PrimitiveRoots
import Mathlib.RingTheory.Norm.Transitivity
import Mathlib.RingTheory.RootsOfUnity.Lemmas

namespace OddOrder.RepresentationTheory

open Polynomial Module

/-- For `ε` a primitive `p`-th root of unity (`p` prime) and `0 < k < p`, the cyclotomic factors
`1 - ε^k` and `1 - ε` are **associates**: explicitly `1 - ε = (1 - ε^k)·w` with `w` an algebraic
integer.  Since `gcd(k,p)=1`, `ε^k` is again a primitive `p`-th root, so `ε = (ε^k)^r` for some `r`,
whence `1 - ε = 1 - (ε^k)^r = (1 - ε^k)·∑_{i<r}(ε^k)^i`.  This is the "hard" divisibility direction
(the easy one, `(1-ε) ∣ (1-ε^k)`, is `one_sub_dvd_pow_sub_one`) underlying Peterfalvi (1.10.b). -/
theorem one_sub_pow_dvd_one_sub {p : ℕ} (hp : p.Prime) {ε : ℂ} (hε : IsPrimitiveRoot ε p)
    {k : ℕ} (hk0 : 0 < k) (hkp : k < p) :
    ∃ w : ℂ, IsIntegral ℤ w ∧ (1 - ε) = (1 - ε ^ k) * w := by
  have : NeZero p := ⟨hp.pos.ne'⟩
  have hcop : Nat.Coprime k p :=
    (hp.coprime_iff_not_dvd.mpr (Nat.not_dvd_of_pos_of_lt hk0 hkp)).symm
  have hεk : IsPrimitiveRoot (ε ^ k) p := hε.pow_of_coprime k hcop
  obtain ⟨r, _, hr⟩ := hεk.eq_pow_of_pow_eq_one hε.pow_eq_one
  have hεk_int : IsIntegral ℤ (ε ^ k) :=
    isIntegral_of_pow_eq_one (n := p) hp.pos.ne'
      (by rw [← pow_mul, mul_comm, pow_mul, hε.pow_eq_one, one_pow])
  have hmem : ε ^ k ∈ integralClosure ℤ ℂ := hεk_int
  refine ⟨∑ i ∈ Finset.range r, (ε ^ k) ^ i, ?_, ?_⟩
  · exact Subalgebra.sum_mem _ (fun i _ => Subalgebra.pow_mem _ hmem i)
  · have hgeom : (1 - ε ^ k) * ∑ i ∈ Finset.range r, (ε ^ k) ^ i = 1 - (ε ^ k) ^ r := by
      linear_combination -geom_sum_mul (ε ^ k) r
    rw [hr] at hgeom; exact hgeom.symm

/-- A rational integer `a` with `(a:ℂ) = (b:ℂ)·W` for `b ≠ 0` an integer and `W` an algebraic
integer is divisible by `b` (the rational algebraic integer `W = a/b` is a rational integer). -/
theorem int_dvd_of_intCast_eq_mul_isIntegral {a b : ℤ} (hb : b ≠ 0) {W : ℂ}
    (hW : IsIntegral ℤ W) (h : (a : ℂ) = (b : ℂ) * W) : b ∣ a := by
  have hb' : (b : ℂ) ≠ 0 := Int.cast_ne_zero.mpr hb
  have hbq : (b : ℚ) ≠ 0 := Int.cast_ne_zero.mpr hb
  have hWeq : W = algebraMap ℚ ℂ ((a : ℚ) / (b : ℚ)) := by
    rw [map_div₀, map_intCast, map_intCast, eq_div_iff hb', mul_comm]; exact h.symm
  have hqInt : IsIntegral ℤ ((a : ℚ) / (b : ℚ)) :=
    (isIntegral_algebraMap_iff (algebraMap ℚ ℂ).injective).mp (hWeq ▸ hW)
  obtain ⟨m, hm⟩ := IsIntegrallyClosed.isIntegral_iff.mp hqInt
  refine ⟨m, ?_⟩
  have key : (a : ℚ) = (b : ℚ) * (m : ℚ) := by
    rw [← eq_intCast (algebraMap ℤ ℚ) m, hm]; field_simp
  exact_mod_cast key

/-- **Peterfalvi (1.10.b)** (ℂ-form, global algebraic integers): for `p` prime, `ε` a primitive
`p`-th root of unity, if a rational integer `n` is `(1 - ε)` times an algebraic integer `z`, then
`p ∣ n`.  This is the form actually used in (12.16)/(13.5) — `z` is any algebraic integer of `ℂ`
(matching the Coq/`Z[η]` formulation), no specific cyclotomic field needed.

**Which (1.10.b) to use** (issue 0106): prefer *this* ℂ-form unless you already carry a
`NumberField`/`IsCyclotomicExtension` structure — the abstract form
`int_dvd_of_zeta_sub_one_dvd` says the same thing inside a `p`-th cyclotomic field and pulls
in the number-field machinery with it.

Proof: `∏_{1≤k<p}(1 - ε^k) = p` (`prod_one_sub_pow_eq_order`), and each `(1 - ε^k) ∣ (1 - ε) ∣ n`
(`one_sub_pow_dvd_one_sub`) with integral cofactor, so the product `p` divides `n^{p-1}` with
integral quotient; descending the rational algebraic integer to `ℤ` gives `p ∣ n^{p-1}`, hence
`p ∣ n`. -/
theorem int_dvd_of_one_sub_primRoot_dvd {p : ℕ} (hp : p.Prime) {ε : ℂ}
    (hε : IsPrimitiveRoot ε p) {n : ℤ} {z : ℂ} (hz : IsIntegral ℤ z)
    (h : (n : ℂ) = (1 - ε) * z) : (p : ℤ) ∣ n := by
  obtain ⟨m, rfl⟩ : ∃ m, p = m + 1 := ⟨p - 1, (Nat.succ_pred_eq_of_pos hp.pos).symm⟩
  -- per-factor cofactors: `(n:ℂ) = (1 - ε^(k+1))·c k`, `c k` an algebraic integer.
  have key : ∀ k : ℕ, ∃ c : ℂ, IsIntegral ℤ c ∧ (k < m → (n : ℂ) = (1 - ε ^ (k + 1)) * c) := by
    intro k
    by_cases hk : k < m
    · obtain ⟨w, hw_int, hw_eq⟩ :=
        one_sub_pow_dvd_one_sub (k := k + 1) hp hε (by omega) (by omega)
      exact ⟨w * z, hw_int.mul hz, fun _ => by rw [h, hw_eq]; ring⟩
    · exact ⟨0, isIntegral_zero, fun hc => absurd hc hk⟩
  choose c hc_int hc_eq using key
  -- `n^m = (∏(1-ε^(k+1)))·(∏ c) = (m+1)·(∏ c)`.
  have hprod_fac : (n : ℂ) ^ m = ((m : ℂ) + 1) * ∏ k ∈ Finset.range m, c k := by
    have e1 : (n : ℂ) ^ m = ∏ _k ∈ Finset.range m, (n : ℂ) := by
      rw [Finset.prod_const, Finset.card_range]
    rw [e1, Finset.prod_congr rfl (fun k hk => hc_eq k (Finset.mem_range.mp hk)),
      Finset.prod_mul_distrib, hε.prod_one_sub_pow_eq_order]
  -- descend `(m+1) ∣ n^m` in `ℤ`.
  have hWint : IsIntegral ℤ (∏ k ∈ Finset.range m, c k) := by
    have : (∏ k ∈ Finset.range m, c k) ∈ integralClosure ℤ ℂ :=
      Subalgebra.prod_mem _ (fun k _ => hc_int k)
    exact this
  have hdvd_pow : ((m : ℤ) + 1) ∣ n ^ m :=
    int_dvd_of_intCast_eq_mul_isIntegral (a := n ^ m) (b := (m : ℤ) + 1)
      (by positivity) hWint (by push_cast; exact hprod_fac)
  have hpZ : Prime ((m : ℤ) + 1) := by
    have := Nat.prime_iff_prime_int.mp hp; push_cast at this; exact this
  exact hpZ.dvd_of_dvd_pow hdvd_pow

/-- **Peterfalvi (1.10.a), per-linear-character core**: for a linear character `α : A → ℂˣ` of a
finite group `A`, a `p`-th-power-trivial element `x` (`x^p = 1`) and any `y`, the difference
`α(xy) - α(y)` is `(1 - ε)` times an algebraic integer (`ε` a primitive `p`-th root of unity).

Proof: `α(xy) - α(y) = (α(x) - 1)·α(y)`; `α(x)^p = 1` so `α(x) = ε^k`; `ε^k - 1 = (1-ε)·(-∑ εⁱ)`;
and `α(y)` is a root of unity, hence integral.  This is the linear-character building block of the
restriction-decomposition proof of (1.10.a) (`⟨x,y⟩` abelian ⟹ constituents are linear). -/
theorem exists_integral_linearChar_apply_sub {p : ℕ} (hp : 0 < p) {ε : ℂ}
    (hε : IsPrimitiveRoot ε p) {A : Type*} [Group A] [Finite A] (α : A →* ℂˣ)
    {x y : A} (hx : x ^ p = 1) :
    ∃ z : ℂ, IsIntegral ℤ z ∧ (α (x * y) : ℂ) - (α y : ℂ) = (1 - ε) * z := by
  have : NeZero p := ⟨hp.ne'⟩
  -- `α(x)` is a `p`-th root of unity, hence `= ε^k`
  have hαxp : (α x : ℂ) ^ p = 1 := by
    rw [← Units.val_pow_eq_pow_val, ← map_pow, hx, map_one, Units.val_one]
  obtain ⟨k, _, hk⟩ := hε.eq_pow_of_pow_eq_one hαxp
  -- `α(y)` is a root of unity (order divides `|A|`), hence integral
  have hαy : IsIntegral ℤ (α y : ℂ) := by
    refine isIntegral_of_pow_eq_one (n := Nat.card A) Nat.card_pos.ne' ?_
    rw [← Units.val_pow_eq_pow_val, ← map_pow, pow_card_eq_one', map_one, Units.val_one]
  refine ⟨-(∑ i ∈ Finset.range k, ε ^ i) * (α y : ℂ), ?_, ?_⟩
  · have hε_mem : ε ∈ integralClosure ℤ ℂ := hε.isIntegral hp
    have hsum : IsIntegral ℤ (∑ i ∈ Finset.range k, ε ^ i) :=
      Subalgebra.sum_mem _ (fun i _ => Subalgebra.pow_mem _ hε_mem i)
    exact hsum.neg.mul hαy
  · have hgeom : ε ^ k - 1 = (1 - ε) * (-(∑ i ∈ Finset.range k, ε ^ i)) := by
      rw [← geom_sum_mul ε k]; ring
    rw [map_mul, Units.val_mul, ← hk]
    linear_combination (α y : ℂ) * hgeom

/-- **Peterfalvi (1.10.a)** (full, virtual-character form): for a finite **abelian** group `A`, a
virtual character `χ ∈ ℤ[Irr A]`, a `p`-th-power-trivial element `x` (`x^p = 1`) and any `y`, the
difference `χ(xy) - χ(y)` is `(1 - ε)` times an algebraic integer (`ε` a primitive `p`-th root).

Proof: the set of class functions with this property is a `ℤ`-submodule (closed under `+`, `ℤ`-smul,
contains `0`); it contains every irreducible character of `A` — each is a linear character
(`exists_linearIrreducibleCharacter_eq_of_isMulCommutative`) so the per-linear-character core
`exists_integral_linearChar_apply_sub` applies — hence it contains `ℤ[Irr A] = span ℤ (Irr A)`. -/
theorem exists_integral_zirr_apply_sub {p : ℕ} (hp : 0 < p) {ε : ℂ} (hε : IsPrimitiveRoot ε p)
    {A : Type*} [Group A] [Finite A] [IsMulCommutative A] {χ : ClassFunction A ℂ}
    (hχ : χ ∈ ZIrr A) {x y : A} (hx : x ^ p = 1) :
    ∃ z : ℂ, IsIntegral ℤ z ∧ χ (x * y) - χ y = (1 - ε) * z := by
  -- the property, as a `ℤ`-submodule of `CF(A)`.
  let M : Submodule ℤ (ClassFunction A ℂ) :=
    { carrier := {ψ | ∃ z : ℂ, IsIntegral ℤ z ∧ ψ (x * y) - ψ y = (1 - ε) * z}
      zero_mem' := ⟨0, isIntegral_zero, by simp⟩
      add_mem' := by
        rintro ψ₁ ψ₂ ⟨z₁, hz₁, e₁⟩ ⟨z₂, hz₂, e₂⟩
        exact ⟨z₁ + z₂, hz₁.add hz₂, by
          simp only [ClassFunction.add_apply]; linear_combination e₁ + e₂⟩
      smul_mem' := by
        rintro c ψ ⟨z, hz, e⟩
        have hcz : IsIntegral ℤ ((c : ℂ) * z) :=
          (isIntegral_algebraMap (R := ℤ) (x := c)).mul hz
        refine ⟨(c : ℂ) * z, hcz, ?_⟩
        have happ : ∀ g, (c • ψ) g = (c : ℂ) * ψ g := fun g => by
          change c • ψ g = (c : ℂ) * ψ g
          rw [zsmul_eq_mul]
        rw [happ, happ]; linear_combination (c : ℂ) * e }
  -- every irreducible character of `A` lies in `M`.
  have hsub : irreducibleCharacters A ⊆ (M : Set (ClassFunction A ℂ)) := by
    intro α hα
    obtain ⟨θ, hθ⟩ :=
      (mem_irreducibleCharacters.mp hα).exists_linearIrreducibleCharacter_eq_of_isMulCommutative
    obtain ⟨z, hz, he⟩ := exists_integral_linearChar_apply_sub hp hε θ hx
    refine ⟨z, hz, ?_⟩
    rw [← hθ]; simpa using he
  -- conclude: `χ ∈ ZIrr A = span ℤ (Irr A) ≤ M`.
  rw [ZIrr_eq_span] at hχ
  exact Submodule.span_le.mpr hsub hχ

/-- **Peterfalvi (1.10.a)** (`G`-form, commuting elements): for a virtual character
`ψ ∈ ℤ[Irr G]` of any finite group `G`, an order-dividing-`p` element `x` (`x^p = 1`) and any `y`
**commuting** with
`x`, `ψ(xy) - ψ(y)` is `(1 - ε)` times an algebraic integer.

Reduce to the abelian subgroup `A = ⟨x, y⟩` (commutative since `x, y` commute): `Res_A ψ ∈ ℤ[Irr A]`
(`restrict_mem_ZIrr`), and `exists_integral_zirr_apply_sub` applies, with `(Res_A ψ)(a) = ψ(a)`. -/
theorem exists_integral_apply_sub_of_commute {p : ℕ} (hp : 0 < p) {ε : ℂ}
    (hε : IsPrimitiveRoot ε p) {G : Type*} [Group G] [Finite G]
    {ψ : ClassFunction G ℂ} (hψ : ψ ∈ ZIrr G) {x y : G} (hx : x ^ p = 1) (hxy : Commute x y) :
    ∃ z : ℂ, IsIntegral ℤ z ∧ ψ (x * y) - ψ y = (1 - ε) * z := by
  set A := Subgroup.closure ({x, y} : Set G) with hA
  have : IsMulCommutative ↥A := by
    refine Subgroup.isMulCommutative_closure (fun a ha b hb => ?_)
    simp only [Set.mem_insert_iff, Set.mem_singleton_iff] at ha hb
    rcases ha with rfl | rfl <;> rcases hb with rfl | rfl
    · exact Commute.refl _
    · exact hxy
    · exact hxy.symm
    · exact Commute.refl _
  have hxA : x ∈ A := Subgroup.subset_closure (by simp)
  have hyA : y ∈ A := Subgroup.subset_closure (by simp)
  have hres : ClassFunction.restrict A ψ ∈ ZIrr ↥A := ClassFunction.restrict_mem_ZIrr A hψ
  have hx' : (⟨x, hxA⟩ : ↥A) ^ p = 1 := by
    apply Subtype.ext; push_cast; exact hx
  obtain ⟨z, hz, he⟩ := exists_integral_zirr_apply_sub hp hε hres
    (x := ⟨x, hxA⟩) (y := ⟨y, hyA⟩) hx'
  refine ⟨z, hz, ?_⟩
  rwa [ClassFunction.restrict_apply, ClassFunction.restrict_apply,
    show ((⟨x, hxA⟩ * ⟨y, hyA⟩ : ↥A) : G) = x * y from rfl,
    show ((⟨y, hyA⟩ : ↥A) : G) = y from rfl] at he

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