Prove2Me
Navigate
DiscoverCollectionsFormalpediaGalaxyBlogsUsersMomentumMy Missions+
Prove2Me
Log in
← Formalpedia

Peterfalvi §10: Dade calculations (continuation)

Definition
OddOrder_Peterfalvi_S12_MaximalIII_IV_V_Core_DadeCalculations

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

feit-thompsonfinite-groupsgroup-theoryishida-odd-order

A continuation of the §10 Dade calculations, centered on the signed σ\sigmaσ-image family of the μ\muμ-columns and the orthonormal character image families built from it.

Main declarations: Hypothesis.columnRImage_inner (Orthonormality of R(μ_j)); Hypothesis.columnRImage_injective (R(μ_j) is injective on Bool × Fin w₁ (distinct orthonormal vectors are distinct)); Hypothesis.columnRImage_sum (The sum of the §10 R(μ_j) family over Bool × Fin w₁ is δ·∑_i (ω_{ij}^σ − ω_{ij'}^σ), the…); Hypothesis.columnImageFamily (§10 column OrthonormalCharacterImageFamily).

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/Peterfalvi/S12_MaximalIII_IV_V_Core/DadeCalculations.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_Peterfalvi_S12_MaximalIII_IV_V_Core_Isometry106

namespace OddOrder.Peterfalvi.S12

open OddOrder.GroupTheory

open OddOrder.RepresentationTheory

open OddOrder.Isaacs

open scoped Pointwise

variable {G : Type*} [Group G]

open scoped FiniteInduce in
/-- **Orthonormality of `R(μ_j)`** at §10: the signed σ-image family `columnRImage` is orthonormal,
`⟨R p, R q⟩ = δ_{p,q}`.  The sign `δ = ±1` gives `δ·δ̄ = 1`, the σ-grid orthonormality
`alignedOmegaSigmaGrid_inner` supplies `⟨ω_{ij}^σ, ω_{i'j'}^σ⟩ = [i=i' ∧ j=j']`, and the two halves
(`j ≠ j'`) are cross-orthogonal. -/
theorem Hypothesis.columnRImage_inner [Finite G] (hG : OddOrder.BG.IsMinimalSimpleOdd G)
    {M : Subgroup G} (hyp : Hypothesis M) (hodd : Odd (Nat.card G)) {δ : ℤ} (hδ : δ = 1 ∨ δ = -1)
    {j j' : Fin hyp.w2} (hjj' : j ≠ j') (p q : Bool × Fin hyp.w1) :
    ClassFunction.inner (hyp.columnRImage hG hodd δ j j' p) (hyp.columnRImage hG hodd δ j j' q)
      = if p = q then (1 : ℂ) else 0 := by
  have hδstar : star ((δ : ℂ)) = (δ : ℂ) := by rcases hδ with h | h <;> rw [h] <;> norm_num
  have hδsq : (δ : ℂ) * (δ : ℂ) = 1 := by rcases hδ with h | h <;> rw [h] <;> norm_num
  obtain ⟨bp, ip⟩ := p
  obtain ⟨bq, iq⟩ := q
  cases bp <;> cases bq <;>
    simp only [Hypothesis.columnRImage, ClassFunction.inner_smul_left,
      OddOrder.RepresentationTheory.inner_smul_right, hyp.alignedOmegaSigmaGrid_inner hG hodd,
      hδstar, star_neg, mul_neg, neg_mul, neg_neg, Prod.mk.injEq, reduceCtorEq, false_and,
      true_and, and_true, ↓reduceIte]
  · -- (false,false): same column `j`, `δ²·[ip=iq] = [ip=iq]`
    rw [← mul_assoc, hδsq, one_mul]
  · -- (false,true): cross column `j ≠ j'`
    rw [if_neg (fun hcon => hjj' hcon.2)]; ring
  · -- (true,false): cross column `j' ≠ j`
    rw [if_neg (fun hcon => hjj' hcon.2.symm)]; ring
  · -- (true,true): same column `j'`, `δ²·[ip=iq] = [ip=iq]`
    rw [← mul_assoc, hδsq, one_mul]

open scoped FiniteInduce in
/-- `R(μ_j)` is injective on `Bool × Fin w₁` (distinct orthonormal vectors are distinct). -/
theorem Hypothesis.columnRImage_injective [Finite G] (hG : OddOrder.BG.IsMinimalSimpleOdd G)
    {M : Subgroup G} (hyp : Hypothesis M) (hodd : Odd (Nat.card G)) {δ : ℤ} (hδ : δ = 1 ∨ δ = -1)
    {j j' : Fin hyp.w2} (hjj' : j ≠ j') :
    Function.Injective (hyp.columnRImage hG hodd δ j j') := by
  intro p q hpq
  by_contra hpqne
  have h0 := hyp.columnRImage_inner hG hodd hδ hjj' p q
  rw [if_neg hpqne, hpq, hyp.columnRImage_inner hG hodd hδ hjj', if_pos rfl] at h0
  exact one_ne_zero h0

open scoped FiniteInduce in
/-- The sum of the §10 `R(μ_j)` family over `Bool × Fin w₁` is `δ·∑_i (ω_{ij}^σ − ω_{ij'}^σ)`, the
image side of the (10.6)(a) summed isometry (`tau_muGrid_columnSum_diff`). -/
theorem Hypothesis.columnRImage_sum [Finite G] (hG : OddOrder.BG.IsMinimalSimpleOdd G)
    {M : Subgroup G} (hyp : Hypothesis M) (hodd : Odd (Nat.card G)) (δ : ℤ) (j j' : Fin hyp.w2) :
    ∑ p : Bool × Fin hyp.w1, hyp.columnRImage hG hodd δ j j' p
      = (δ : ℂ) • ∑ i : Fin hyp.w1, (hyp.alignedOmegaSigmaGrid hG hodd i j
          - hyp.alignedOmegaSigmaGrid hG hodd i j') := by
  rw [Fintype.sum_prod_type, Fintype.sum_bool, Finset.smul_sum]
  simp only [Hypothesis.columnRImage, neg_smul, smul_sub]
  rw [← Finset.sum_add_distrib]
  exact Finset.sum_congr rfl (fun i _ => by abel)

open scoped Classical FiniteInduce in
/-- **§10 column `OrthonormalCharacterImageFamily`** (Peterfalvi (5.2.d) for the reducible column
`μ_j`): the difference-image family `R(μ_j) = {δ·ω_{ij}^σ} ∪ {−δ·ω_{ij'}^σ}` of the column character
`μ_j = ∑_i μ_{ij}` against the §10 Dade isometry `hyp.tau`.  This is the §10 analogue of the §6
`certainTypeR`, built directly on `hyp.tau` (an `IntegralCharacterMap`) instead of the §6 Dade map.

The `image_eq` field `hyp.tau(μ_j − μ̄_j) = ∑ R(μ_j)` combines the conjugate-column identity
`μ̄_j = μ_{j'}` (`hconj`, from `exists_conj_column`), the (10.5) summed isometry
`tau_muGrid_columnSum_diff` (`hyp.tau(μ_j − μ_{j'}) = δ(∑ω_{ij}^σ − ∑ω_{ij'}^σ)`), and
`columnRImage_sum`; `orthonormal`/`mem_ZIrr` come from `columnRImage_inner`/`_injective` and
`alignedOmegaSigmaGrid_mem_ZIrr`.  Feeding `ofProjection` (with `coh.tau1`, ψ = 0), the (5.5)
`eq_sum_of_psi_eq_zero` then computes `μ_j^{τ₁} = ∑_{E ⊆ R(μ_j)} α`. -/
noncomputable def Hypothesis.columnImageFamily [Finite G]
    (hG : OddOrder.BG.IsMinimalSimpleOdd G) {M : Subgroup G} {hyp : Hypothesis M}
    {params : CharacterParameters hyp} (coh : CoherentHypothesis hyp params)
    (hmu : params.mu = hyp.muGrid hG hG.odd)
    (hos : params.omegaSigma = hyp.alignedOmegaSigmaGrid hG hG.odd)
    (hzS : params.zeta ∈ inducedFamily M) (hz1 : params.zeta 1 = (hyp.w1 : ℂ))
    (hzconj : params.zeta.conj ≠ params.zeta)
    (hδpm : params.delta = 1 ∨ params.delta = -1)
    (hδj : ∀ j : Fin hyp.w2, j ≠ 0 → hyp.muColumnSign hG hG.odd j = params.delta)
    {j j' : Fin hyp.w2} (hj0 : j ≠ 0) (hj'0 : j' ≠ 0) (hjj' : j ≠ j')
    (hconj : (∑ i : Fin hyp.w1, hyp.muGrid hG hG.odd i j).conj
      = ∑ i : Fin hyp.w1, hyp.muGrid hG hG.odd i j') :
    OddOrder.Peterfalvi.S07.OrthonormalCharacterImageFamily hyp.tau
      (∑ i : Fin hyp.w1, hyp.muGrid hG hG.odd i j) where
  imageSet := Finset.univ.image (hyp.columnRImage hG hG.odd params.delta j j')
  mem_ZIrr := by
    intro α hα
    rw [Finset.mem_image] at hα
    obtain ⟨⟨b, i⟩, _, rfl⟩ := hα
    cases b
    · simp only [Hypothesis.columnRImage]
      rw [Int.cast_smul_eq_zsmul]
      exact (ZIrr G).smul_mem _ (hyp.alignedOmegaSigmaGrid_mem_ZIrr hG hG.odd i j)
    · simp only [Hypothesis.columnRImage]
      rw [neg_smul, Int.cast_smul_eq_zsmul]
      exact neg_mem ((ZIrr G).smul_mem _ (hyp.alignedOmegaSigmaGrid_mem_ZIrr hG hG.odd i j'))
  orthonormal := by
    intro α hα β hβ
    rw [Finset.mem_image] at hα hβ
    obtain ⟨p, _, rfl⟩ := hα
    obtain ⟨q, _, rfl⟩ := hβ
    rw [hyp.columnRImage_inner hG hG.odd hδpm hjj']
    by_cases hpq : p = q
    · subst hpq; simp
    · rw [if_neg hpq,
        if_neg (fun he => hpq (hyp.columnRImage_injective hG hG.odd hδpm hjj' he))]
  image_eq := by
    rw [hconj, tau_muGrid_columnSum_diff hG coh hmu hos hzS hz1 hzconj hδpm hδj hj0 hj'0,
      Finset.sum_image (fun p _ q _ hpq => hyp.columnRImage_injective hG hG.odd hδpm hjj' hpq),
      hyp.columnRImage_sum, Finset.sum_sub_distrib]

open scoped Classical FiniteInduce in
/-- **§10 column `OrthonormalCharacterImageFamily`, coherence-free** ((5.2.d) for the reducible
column
`μ_j`): the difference-image family `R(μ_j) = {δ·ω_{ij}^σ} ∪ {−δ·ω_{ij'}^σ}` of the column character
`μ_j = ∑_i μ_{ij}` against the §10 Dade isometry `hyp.tau`.  This is the §10 analogue of the §6
`certainTypeR`, built directly on `hyp.tau` (an `IntegralCharacterMap`) instead of the §6 Dade map.

The `image_eq` field `hyp.tau(μ_j − μ̄_j) = ∑ R(μ_j)` combines the conjugate-column identity
`μ̄_j = μ_{j'}` (`hconj`, from `exists_conj_column`), the (10.5) summed isometry
`tau_muGrid_columnSum_diff` (`hyp.tau(μ_j − μ_{j'}) = δ(∑ω_{ij}^σ − ∑ω_{ij'}^σ)`), and
`columnRImage_sum`; `orthonormal`/`mem_ZIrr` come from `columnRImage_inner`/`_injective` and
`alignedOmegaSigmaGrid_mem_ZIrr`.  Feeding `ofProjection` (with `coh.tau1`, ψ = 0), the (5.5)
`eq_sum_of_psi_eq_zero` then computes `μ_j^{τ₁} = ∑_{E ⊆ R(μ_j)} α`. -/
noncomputable def Hypothesis.columnImageFamilyCohFree [Finite G]
    (hG : OddOrder.BG.IsMinimalSimpleOdd G) {M : Subgroup G} {hyp : Hypothesis M}
    {params : CharacterParameters hyp}
    (hmu : params.mu = hyp.muGrid hG hG.odd)
    (hzS : params.zeta ∈ inducedFamily M) (hz1 : params.zeta 1 = (hyp.w1 : ℂ))
    (_hzconj : params.zeta.conj ≠ params.zeta)
    (hδpm : params.delta = 1 ∨ params.delta = -1)
    (hδj : ∀ j : Fin hyp.w2, j ≠ 0 → hyp.muColumnSign hG hG.odd j = params.delta)
    {j j' : Fin hyp.w2} (hj0 : j ≠ 0) (hj'0 : j' ≠ 0) (hjj' : j ≠ j')
    (hconj : (∑ i : Fin hyp.w1, hyp.muGrid hG hG.odd i j).conj
      = ∑ i : Fin hyp.w1, hyp.muGrid hG hG.odd i j') :
    OddOrder.Peterfalvi.S07.OrthonormalCharacterImageFamily hyp.tau
      (∑ i : Fin hyp.w1, hyp.muGrid hG hG.odd i j) where
  imageSet := Finset.univ.image (hyp.columnRImage hG hG.odd params.delta j j')
  mem_ZIrr := by
    intro α hα
    rw [Finset.mem_image] at hα
    obtain ⟨⟨b, i⟩, _, rfl⟩ := hα
    cases b
    · simp only [Hypothesis.columnRImage]
      rw [Int.cast_smul_eq_zsmul]
      exact (ZIrr G).smul_mem _ (hyp.alignedOmegaSigmaGrid_mem_ZIrr hG hG.odd i j)
    · simp only [Hypothesis.columnRImage]
      rw [neg_smul, Int.cast_smul_eq_zsmul]
      exact neg_mem ((ZIrr G).smul_mem _ (hyp.alignedOmegaSigmaGrid_mem_ZIrr hG hG.odd i j'))
  orthonormal := by
    intro α hα β hβ
    rw [Finset.mem_image] at hα hβ
    obtain ⟨p, _, rfl⟩ := hα
    obtain ⟨q, _, rfl⟩ := hβ
    rw [hyp.columnRImage_inner hG hG.odd hδpm hjj']
    by_cases hpq : p = q
    · subst hpq; simp
    · rw [if_neg hpq,
        if_neg (fun he => hpq (hyp.columnRImage_injective hG hG.odd hδpm hjj' he))]
  image_eq := by
    rw [hconj, hyp.tau_muGrid_columnSum_diff_cohFree hG hG.odd hmu hzS hz1 hδpm hδj hj0 hj'0 hjj',
      Finset.sum_image (fun p _ q _ hpq => hyp.columnRImage_injective hG hG.odd hδpm hjj' hpq),
      hyp.columnRImage_sum, Finset.sum_sub_distrib]

open scoped Classical FiniteInduce in
/-- **§10 (5.5) for the column `μ_j`** (Peterfalvi (5.5) applied to the reducible column character):
`μ_j^{τ₁} = ∑_{α ∈ E} α` for some `E ⊆ R(μ_j)` with `|E| = ‖μ_j‖² = w₁`.

Builds the (5.4) `CharacterPsiDecomposition` for `(μ_j, ψ = 0)` against `τ = hyp.tau`,
`τ₁ = coh.tau1` via `ofProjection` — the column `OrthonormalCharacterImageFamily`
(`columnImageFamily`) supplies `R(μ_j)`; the coherence isometry `coh.coherent` supplies the
lattice-relative inner-preservation (`extension_inner_eq`, on `ℤ[S] ⊇ {μ_j − μ̄_j, μ_j}`), the
`τ`-agreement (`extends_on_supported`, `μ_j − μ̄_j` is `A_0`-supported), and the `ZIrr`-membership
(`extension_mem_ZIrr`, `μ_j ∈ S`); the orthogonalities `⟨μ_j, 0⟩ = ⟨μ̄_j, 0⟩ = 0` are trivial and
`⟨μ_j, μ̄_j⟩ = 0` is the cross-column Gram entry (`muGrid_inner_cross_column`, `j ≠ j'`).  Then
`eq_sum_of_psi_eq_zero` extracts the (5.5) sum.  This is the second-to-last step of (10.6)(a); the
final (5.8) full-column endgame then pins `E` to the single full column `{δ·ω_{ij}^σ}`. -/
theorem Hypothesis.exists_muColumn_tau1_eq_sum_R [Finite G]
    (hG : OddOrder.BG.IsMinimalSimpleOdd G) {M : Subgroup G} {hyp : Hypothesis M}
    {params : CharacterParameters hyp} (coh : CoherentHypothesis hyp params)
    (hmu : params.mu = hyp.muGrid hG hG.odd)
    (hos : params.omegaSigma = hyp.alignedOmegaSigmaGrid hG hG.odd)
    (hzS : params.zeta ∈ inducedFamily M) (hz1 : params.zeta 1 = (hyp.w1 : ℂ))
    (hzconj : params.zeta.conj ≠ params.zeta)
    (hδpm : params.delta = 1 ∨ params.delta = -1)
    (hδj : ∀ j : Fin hyp.w2, j ≠ 0 → hyp.muColumnSign hG hG.odd j = params.delta)
    (hd1 : ∀ jj : Fin hyp.w2, jj ≠ 0 → hyp.muGrid hG hG.odd 0 jj 1 ≠ 1)
    {j : Fin hyp.w2} (hj0 : j ≠ 0) :
    ∃ j' : Fin hyp.w2, j' ≠ 0 ∧ j' ≠ j ∧
      ∃ E ⊆ Finset.univ.image (hyp.columnRImage hG hG.odd params.delta j j'),
        coh.tau1 (∑ i : Fin hyp.w1, hyp.muGrid hG hG.odd i j) = ∑ α ∈ E, α ∧
          (E.card : ℂ) = (hyp.w1 : ℂ) := by
  have := hyp.finiteG
  classical
  obtain ⟨j', hj'0, hj'j, hconj⟩ := hyp.exists_conj_column hG hG.odd hj0
  set χ := ∑ i : Fin hyp.w1, hyp.muGrid hG hG.odd i j with hχdef
  have hχS : χ ∈ inducedFamily M := hyp.muGrid_column_sum_mem_inducedFamily hG hG.odd j (hd1 j hj0)
  have hχcS : χ.conj ∈ inducedFamily M := by
    rw [hχdef, hconj]; exact hyp.muGrid_column_sum_mem_inducedFamily hG hG.odd j' (hd1 j' hj'0)
  -- `χ − χ̄ = ∑_i (α_{ij} − α_{ij'})` is `A_0`-supported and lies in `ℤ[S]`.
  have hμdiff : χ - χ.conj
      = ∑ i : Fin hyp.w1, (params.alpha i j - params.alpha i j') := by
    rw [hχdef, hconj, ← Finset.sum_sub_distrib]
    refine Finset.sum_congr rfl fun i _ => ?_
    rw [params.alpha_def, params.alpha_def, hmu]; abel
  have hsumsupp : ∀ s : Finset (Fin hyp.w1),
      (∑ i ∈ s, (params.alpha i j - params.alpha i j')).support ⊆ hyp.A0 := by
    intro s
    induction s using Finset.induction with
    | empty => rw [Finset.sum_empty, ClassFunction.support_zero]; exact Set.empty_subset _
    | insert i s hi ih =>
        rw [Finset.sum_insert hi]
        refine (ClassFunction.support_add_subset _ _).trans (Set.union_subset ?_ ih)
        exact (ClassFunction.support_sub_subset _ _).trans
          (Set.union_subset (params.alpha_support i j hj0) (params.alpha_support i j' hj'0))
  have hsuppmem : (χ - χ.conj) ∈ OddOrder.Peterfalvi.S07.zSupportedSpan hyp.Sset hyp.A0 :=
    ⟨Submodule.sub_mem _ (Submodule.subset_span hχS) (Submodule.subset_span hχcS),
      by rw [hμdiff]; exact hsumsupp Finset.univ⟩
  -- the running coherence isometry preserves inner products on `ℤ[S] ⊇ zSpan {χ − χ̄, χ − 0}`.
  have hspan : OddOrder.Peterfalvi.S07.zSpan (L := ↥M) {χ - χ.conj, χ - 0}
      ≤ OddOrder.Peterfalvi.S07.zSpan hyp.Sset := by
    apply Submodule.span_le.mpr
    intro x hx
    simp only [Set.mem_insert_iff, Set.mem_singleton_iff] at hx
    rcases hx with rfl | rfl
    · exact Submodule.sub_mem _ (Submodule.subset_span hχS) (Submodule.subset_span hχcS)
    · rw [sub_zero]; exact Submodule.subset_span hχS
  -- `⟨μ_j, μ̄_j⟩ = 0` (cross-column Gram entry).
  have hχχbar : ClassFunction.inner χ χ.conj = 0 := by
    rw [hχdef, hconj, OddOrder.RepresentationTheory.inner_sum_left]
    refine Finset.sum_eq_zero fun i _ => ?_
    rw [OddOrder.RepresentationTheory.inner_sum_right]
    exact Finset.sum_eq_zero fun i' _ => hyp.muGrid_inner_cross_column hG hG.odd i i' hj'j.symm
  -- assemble the (5.4) decomposition via `ofProjection` and apply (5.5).
  let R := hyp.columnImageFamily hG coh hmu hos hzS hz1 hzconj hδpm hδj hj0 hj'0
    (Ne.symm hj'j) hconj
  let D : OddOrder.Peterfalvi.S07.CharacterPsiDecomposition hyp.tau χ 0 :=
    OddOrder.Peterfalvi.S07.CharacterPsiDecomposition.ofProjection R coh.tau1
      (fun φ ζ hφ hζ => coh.coherent.extension_inner_eq φ ζ (hspan hφ) (hspan hζ))
      (coh.coherent.extends_on_supported _ hsuppmem)
      (by rw [sub_zero]; exact coh.coherent.extension_mem_ZIrr χ (Submodule.subset_span hχS))
      (by rw [ClassFunction.inner_zero_right])
      (by rw [ClassFunction.inner_zero_right])
      hχχbar
  obtain ⟨_, hτ1, E, hEsub, hEsum, hEcard⟩ := D.eq_sum_of_psi_eq_zero
  refine ⟨j', hj'0, hj'j, E, hEsub, ?_, ?_⟩
  · rw [← hEsum]; exact hτ1
  · rw [hEcard, hχdef, hyp.muGrid_column_sum_inner_self hG hG.odd j]

open scoped Classical FiniteInduce in
/-- **Peterfalvi (10.6)(a) summed isometry**: for every nontrivial column `0 < j < w₂`,
`μ_j^{τ₁} = δ·∑_i ω_{ij}^σ`.

This is the §10 specialisation of Peterfalvi's (5.8) — proved here *without* the general (5.8)
machinery (separability / `σ`-coefficients), using only the (10.6)(a) reduction and a cardinality
count.  By (5.5) (`exists_muColumn_tau1_eq_sum_R`), `μ_j^{τ₁} = ∑_{x ∈ T} R(x)` where
`R = R(μ_j) = {δ·ω_{ij}^σ}∪{−δ·ω_{ij'}^σ}` (`columnRImage`, `j'` the conjugate column) is an
orthonormal family and `|T| = ‖μ_j^{τ₁}‖² = w₁`.  The reduction
`(ω_{ij}^σ − ω_{i0}^σ, μ_j^{τ₁}) = δ` (`omegaSigmaDiff_inner_muColumn_tau1`) computes, against the
`T`-sum, to `δ·[(false, i) ∈ T]` (the cross-column `j'` and the trivial column `0` are orthogonal);
since `δ ≠ 0`, every `(false, i) ∈ T`. So `{false} × univ ⊆ T` with both of cardinality `w₁`,
forcing
`T = {false} × univ` and `μ_j^{τ₁} = ∑_i δ·ω_{ij}^σ = δ·∑_i ω_{ij}^σ`. -/
theorem Hypothesis.muColumn_tau1_pin [Finite G]
    (hG : OddOrder.BG.IsMinimalSimpleOdd G) {M : Subgroup G} {hyp : Hypothesis M}
    {params : CharacterParameters hyp} (coh : CoherentHypothesis hyp params)
    (hmu : params.mu = hyp.muGrid hG hG.odd)
    (hos : params.omegaSigma = hyp.alignedOmegaSigmaGrid hG hG.odd)
    (hzS : params.zeta ∈ inducedFamily M) (hz1 : params.zeta 1 = (hyp.w1 : ℂ))
    (hzconj : params.zeta.conj ≠ params.zeta)
    (hδpm : params.delta = 1 ∨ params.delta = -1)
    (hδj : ∀ j : Fin hyp.w2, j ≠ 0 → hyp.muColumnSign hG hG.odd j = params.delta)
    (hd1 : ∀ jj : Fin hyp.w2, jj ≠ 0 → hyp.muGrid hG hG.odd 0 jj 1 ≠ 1)
    {j : Fin hyp.w2} (hj0 : j ≠ 0) :
    coh.tau1 (∑ i : Fin hyp.w1, hyp.muGrid hG hG.odd i j)
      = (params.delta : ℂ) • ∑ i : Fin hyp.w1, hyp.alignedOmegaSigmaGrid hG hG.odd i j := by
  have := hyp.finiteG
  classical
  -- (5.5): `μ_j^{τ₁} = ∑_{α ∈ E} α` for `E ⊆ R(μ_j)`, `|E| = w₁`.
  obtain ⟨j', hj'0, hj'j, E, hEsub, hEsum, hEcard⟩ :=
    hyp.exists_muColumn_tau1_eq_sum_R hG coh hmu hos hzS hz1 hzconj hδpm hδj hd1 hj0
  set R := hyp.columnRImage hG hG.odd params.delta j j' with hRdef
  have hRinj : Function.Injective R := hyp.columnRImage_injective hG hG.odd hδpm (Ne.symm hj'j)
  -- the preimage `T ⊆ Bool × Fin w₁` of `E` under the injective family `R`.
  set T : Finset (Bool × Fin hyp.w1) := Finset.univ.filter (fun x => R x ∈ E) with hTdef
  have hImT : T.image R = E := by
    apply Finset.ext; intro α
    simp only [Finset.mem_image, hTdef, Finset.mem_filter, Finset.mem_univ, true_and]
    constructor
    · rintro ⟨x, hx, rfl⟩; exact hx
    · intro hα
      obtain ⟨x, -, hx⟩ := Finset.mem_image.mp (hEsub hα)
      exact ⟨x, by rw [hx]; exact hα, hx⟩
  have hSumT : ∑ x ∈ T, R x = ∑ α ∈ E, α := by
    rw [← hImT, Finset.sum_image (fun x _ y _ h => hRinj h)]
  have hCardT : T.card = hyp.w1 := by
    have hc : (T.image R).card = E.card := by rw [hImT]
    rw [Finset.card_image_of_injOn (fun x _ y _ h => hRinj h)] at hc
    rw [hc]; exact_mod_cast hEcard
  -- `μ_j^{τ₁} = ∑_{x ∈ T} R x`.
  have hμT : coh.tau1 (∑ i : Fin hyp.w1, hyp.muGrid hG hG.odd i j) = ∑ x ∈ T, R x := by
    rw [hEsum, hSumT]
  -- inner product of `ω_{ij}^σ − ω_{i0}^σ` against each `R(x)` (only `x = (false, i)` survives).
  have hval : ∀ (i : Fin hyp.w1) (x : Bool × Fin hyp.w1),
      ClassFunction.inner (hyp.alignedOmegaSigmaGrid hG hG.odd i j
        - hyp.alignedOmegaSigmaGrid hG hG.odd i 0) (R x)
      = if x = (false, i) then (params.delta : ℂ) else 0 := by
    intro i x
    have hδstar : star ((params.delta : ℂ)) = (params.delta : ℂ) := by
      rcases hδpm with h | h <;> rw [h] <;> norm_num
    obtain ⟨b, i'⟩ := x
    cases b <;>
      simp only [hRdef, Hypothesis.columnRImage, ClassFunction.inner_sub_left,
        OddOrder.RepresentationTheory.inner_smul_right, hyp.alignedOmegaSigmaGrid_inner hG hG.odd,
        hδstar, star_neg, Prod.mk.injEq, reduceCtorEq, false_and, true_and, and_true,
        ↓reduceIte, neg_mul]
    · -- (false, i'): `δ · [i = i'] − δ · [i = i' ∧ 0 = j] = if i' = i then δ else 0`
      rw [if_neg (show ¬(i = i' ∧ (0 : Fin hyp.w2) = j) from fun hh => hj0 hh.2.symm),
        mul_zero, sub_zero]
      by_cases hii : i = i'
      · rw [if_pos hii, mul_one, if_pos hii.symm]
      · rw [if_neg hii, mul_zero, if_neg (fun h => hii h.symm)]
    · -- (true, i'): both columns orthogonal (`j ≠ j'`, `j' ≠ 0`)
      rw [if_neg (show ¬(i = i' ∧ j = j') from fun hh => hj'j hh.2.symm),
        if_neg (show ¬(i = i' ∧ (0 : Fin hyp.w2) = j') from fun hh => hj'0 hh.2.symm)]
      ring
  -- the (10.6)(a) reduction forces every `(false, i) ∈ T`.
  have hfalseT : ∀ i : Fin hyp.w1, (false, i) ∈ T := by
    intro i
    by_contra hni
    have hRi := hyp.omegaSigmaDiff_inner_muColumn_tau1 hG coh hmu hos hzS hz1 hzconj hδpm hδj hj0 i
    rw [hμT, OddOrder.RepresentationTheory.inner_sum_right] at hRi
    rw [show (∑ x ∈ T, ClassFunction.inner (hyp.alignedOmegaSigmaGrid hG hG.odd i j
          - hyp.alignedOmegaSigmaGrid hG hG.odd i 0) (R x))
        = if (false, i) ∈ T then (params.delta : ℂ) else 0 by
      rw [Finset.sum_congr rfl (fun x _ => hval i x)]; exact Finset.sum_ite_eq' T (false, i) _,
      if_neg hni] at hRi
    rcases hδpm with h | h <;> rw [h] at hRi <;> norm_num at hRi
  -- `{false} × univ ⊆ T` and `|T| = w₁ = |{false} × univ|`, so `T = {false} × univ`.
  have hFsub : Finset.univ.image (fun i : Fin hyp.w1 => (false, i)) ⊆ T := by
    intro x hx
    obtain ⟨i, -, rfl⟩ := Finset.mem_image.mp hx
    exact hfalseT i
  have hFinj : Function.Injective (fun i : Fin hyp.w1 => (false, i)) :=
    fun a b h => congrArg Prod.snd h
  have hFcard : (Finset.univ.image (fun i : Fin hyp.w1 => (false, i))).card = hyp.w1 := by
    rw [Finset.card_image_of_injective _ hFinj, Finset.card_univ, Fintype.card_fin]
  have hTeq : T = Finset.univ.image (fun i : Fin hyp.w1 => (false, i)) :=
    (Finset.eq_of_subset_of_card_le hFsub (by rw [hFcard, hCardT])).symm
  -- conclude: `μ_j^{τ₁} = ∑_i δ·ω_{ij}^σ = δ·∑_i ω_{ij}^σ`.
  rw [hμT, hTeq, Finset.sum_image (fun a _ b _ h => hFinj h)]
  simp only [hRdef, Hypothesis.columnRImage]
  rw [Finset.smul_sum]

open scoped FiniteInduce in
/-- **Peterfalvi (10.6)(a), second identity** — the book's "Also,
`(μ_0 − ζ)^τ = ∑_{0≤i<w₁} ω_{i0}^σ − ζ^{τ₁}`" (p. 59), which is also the `Ã(M)`-independent
half of the (10.6)(b) argument.  Holds under Hypothesis (10.4) alone (no `w₁ < w₂`, no §11
input); the coherence-free (10.9) restatement, where the residual is *not* identified with
`ζ^{τ₁}`, is `exists_residual_of_w1_lt_w2`.

Picks a fixed nontrivial column `k`; the `M`-level identity
`δ(μ_0 − ζ) = (μ_k − dζ) − ∑_i α_{ik}` (from `α_{ik} = μ_{ik} − δμ_{i0} − nζ` and `d = w₁n + δ`)
is mapped through the `ℤ`-linear Dade map `τ`.  Then `τ(μ_k − dζ) = δ∑_i ω_{ik}^σ − dζ^{τ₁}`
(`μ_k − dζ = (μ_k − dζ̄) + d(ζ̄ − ζ)` reduces it to `tau_muColumn_sub_conj_eq_tau1` +
`tau_zeta_sub_conj_eq_tau1`, then `muColumn_tau1_pin` for `μ_k^{τ₁}`) and
`τ(α_{ik}) = δ(ω_{ik}^σ − ω_{i0}^σ) − nζ^{τ₁}` (`alpha_tau_image`); the `δ∑ω_{ik}^σ` cancel and
`(w₁n − d)ζ^{τ₁} = −δζ^{τ₁}`, giving `δ·τ(μ_0 − ζ) = δ∑ω_{i0}^σ − δζ^{τ₁}`; cancel `δ` (`δ² = 1`).

This is `STEP 1` of (10.6)(b) (issue 1009); the remaining `STEP 2` (`τ(μ_0 − ζ)` vanishes off
`Ã(M)`,
the tame support) + `STEP 3` parity then give `|ζ^{τ₁}(g)| ≥ 1`. -/
theorem Hypothesis.tau_muColumnZero_sub_zeta_eq [Finite G]
    (hG : OddOrder.BG.IsMinimalSimpleOdd G) {M : Subgroup G} {hyp : Hypothesis M}
    {params : CharacterParameters hyp} (coh : CoherentHypothesis hyp params)
    (hmu : params.mu = hyp.muGrid hG hG.odd)
    (hos : params.omegaSigma = hyp.alignedOmegaSigmaGrid hG hG.odd)
    (hzS : params.zeta ∈ inducedFamily M) (hz1 : params.zeta 1 = (hyp.w1 : ℂ))
    (hzconj : params.zeta.conj ≠ params.zeta)
    (hδpm : params.delta = 1 ∨ params.delta = -1)
    (hδj : ∀ j : Fin hyp.w2, j ≠ 0 → hyp.muColumnSign hG hG.odd j = params.delta) :
    hyp.tau ((∑ i : Fin hyp.w1, hyp.muGrid hG hG.odd i 0) - params.zeta)
      = (∑ i : Fin hyp.w1, hyp.alignedOmegaSigmaGrid hG hG.odd i 0) - coh.tau1 params.zeta := by
  have := hyp.finiteG
  classical
  have hodd : Odd (Nat.card G) := hG.odd
  -- a fixed nontrivial column `k`.
  have hw2 : 3 ≤ hyp.w2 := (typePData_toTICyclicHypothesis hyp.typeP hodd).three_le_card_W2
  obtain ⟨k, hk0⟩ : ∃ k : Fin hyp.w2, k ≠ 0 :=
    ⟨⟨1, by omega⟩, Fin.ne_of_val_ne (by simp)⟩
  have hcolk : ∀ i, hyp.muGrid hG hodd i k 1 = (params.d : ℂ) := fun i => by
    rw [← hmu]; exact params.degree_independent i k hk0
  have hd1 : params.d ≠ 1 := by have := params.d_gt_one; omega
  have hdk1 : hyp.muGrid hG hodd 0 k 1 ≠ 1 := by rw [hcolk 0]; exact_mod_cast hd1
  have hd1k : ∀ jj : Fin hyp.w2, jj ≠ 0 → hyp.muGrid hG hodd 0 jj 1 ≠ 1 := fun jj hjj => by
    rw [← hmu, params.degree_independent 0 jj hjj]; exact_mod_cast hd1
  -- `d = w₁·n + δ`.
  have hd : (params.d : ℂ) = (hyp.w1 : ℂ) * (params.n : ℂ) + (params.delta : ℂ) := by
    have h : (params.n : ℂ) * (hyp.w1 : ℂ) = (params.d : ℂ) - (params.delta : ℂ) := by
      exact_mod_cast params.n_formula
    linear_combination -h
  -- `τ` commutes with the natural scalar `d`.
  have hsmul_tau : ∀ (x : ClassFunction ↥M ℂ),
      hyp.tau ((params.d : ℂ) • x) = (params.d : ℂ) • hyp.tau x := fun x => by
    rw [Nat.cast_smul_eq_nsmul, map_nsmul, ← Nat.cast_smul_eq_nsmul (R := ℂ)]
  -- `τ(μ_k − dζ) = δ∑ω_{ik}^σ − dζ^{τ₁}` via the conjugate decomposition.
  have htauμk : hyp.tau ((∑ i, hyp.muGrid hG hodd i k) - (params.d : ℂ) • params.zeta)
      = (params.delta : ℂ) • (∑ i, hyp.alignedOmegaSigmaGrid hG hodd i k)
        - (params.d : ℂ) • coh.tau1 params.zeta := by
    have hdecomp : (∑ i, hyp.muGrid hG hodd i k) - (params.d : ℂ) • params.zeta
        = ((∑ i, hyp.muGrid hG hodd i k) - (params.d : ℂ) • params.zeta.conj)
          + (params.d : ℂ) • (params.zeta.conj - params.zeta) := by
      rw [smul_sub]; abel
    have htauzc : hyp.tau (params.zeta.conj - params.zeta)
        = coh.tau1 params.zeta.conj - coh.tau1 params.zeta := by
      rw [show params.zeta.conj - params.zeta = -(params.zeta - params.zeta.conj) by abel, map_neg,
        hyp.tau_zeta_sub_conj_eq_tau1 hG hodd coh hzS params.zeta_irreducible]
      abel
    rw [hdecomp, map_add,
      hyp.tau_muColumn_sub_conj_eq_tau1 hG hodd k coh hzS params.zeta_irreducible hcolk hz1 hdk1,
      hsmul_tau, htauzc,
      muColumn_tau1_pin hG coh hmu hos hzS hz1 hzconj hδpm hδj hd1k hk0]
    module
  -- `τ(α_{ik}) = δ(ω_{ik}^σ − ω_{i0}^σ) − nζ^{τ₁}` (the (10.5) Dade image).
  have htauα : ∀ i, hyp.tau (params.alpha i k)
      = (params.delta : ℂ) • (hyp.alignedOmegaSigmaGrid hG hodd i k
          - hyp.alignedOmegaSigmaGrid hG hodd i 0) - (params.n : ℂ) • coh.tau1 params.zeta := by
    intro i
    have h := alpha_tau_image hG coh hmu hos hzS hz1 hzconj hδpm hδj i k hk0
    rwa [hos] at h
  -- the `M`-level identity `δ(μ_0 − ζ) = (μ_k − dζ) − ∑_i α_{ik}`.
  have hMlevel : (params.delta : ℂ) • ((∑ i, hyp.muGrid hG hodd i 0) - params.zeta)
      = ((∑ i, hyp.muGrid hG hodd i k) - (params.d : ℂ) • params.zeta) - ∑ i, params.alpha i k := by
    have hαe : (∑ i, params.alpha i k)
        = (∑ i, hyp.muGrid hG hodd i k) - (params.delta : ℂ) • (∑ i, hyp.muGrid hG hodd i 0)
          - ((hyp.w1 : ℂ) * (params.n : ℂ)) • params.zeta := by
      rw [Finset.sum_congr rfl (fun i _ => by rw [params.alpha_def, hmu]),
        Finset.sum_sub_distrib, Finset.sum_sub_distrib, ← Finset.smul_sum, Finset.sum_const,
        Finset.card_univ, Fintype.card_fin, ← Nat.cast_smul_eq_nsmul (R := ℂ), smul_smul]
    rw [hαe, hd]; module
  -- `∑_i (δ(ω_{ik}^σ − ω_{i0}^σ) − nζ^{τ₁}) = δ(∑ω_{ik}^σ − ∑ω_{i0}^σ) − (w₁n)ζ^{τ₁}`.
  have hsum_α : (∑ i, ((params.delta : ℂ) • (hyp.alignedOmegaSigmaGrid hG hodd i k
        - hyp.alignedOmegaSigmaGrid hG hodd i 0) - (params.n : ℂ) • coh.tau1 params.zeta))
      = (params.delta : ℂ) • ((∑ i, hyp.alignedOmegaSigmaGrid hG hodd i k)
          - ∑ i, hyp.alignedOmegaSigmaGrid hG hodd i 0)
        - ((hyp.w1 : ℂ) * (params.n : ℂ)) • coh.tau1 params.zeta := by
    rw [Finset.sum_sub_distrib]
    congr 1
    · rw [← Finset.smul_sum, Finset.sum_sub_distrib]
    · rw [Finset.sum_const, Finset.card_univ, Fintype.card_fin, ← Nat.cast_smul_eq_nsmul (R := ℂ),
        smul_smul]
  -- map the `M`-level identity through `τ` and substitute the three images.
  have hscaled : (params.delta : ℂ) • hyp.tau ((∑ i, hyp.muGrid hG hodd i 0) - params.zeta)
      = (params.delta : ℂ) • ((∑ i, hyp.alignedOmegaSigmaGrid hG hodd i 0)
          - coh.tau1 params.zeta) := by
    have hkey := congrArg hyp.tau hMlevel
    rw [Int.cast_smul_eq_zsmul, map_zsmul, ← Int.cast_smul_eq_zsmul (R := ℂ)] at hkey
    rw [hkey, map_sub, htauμk, map_sum, Finset.sum_congr rfl (fun i _ => htauα i), hsum_α, hd]
    module
  -- cancel `δ` (`δ² = 1`).
  have hδsq : (params.delta : ℂ) * (params.delta : ℂ) = 1 := by
    rcases hδpm with h | h <;> rw [h] <;> norm_num
  calc hyp.tau ((∑ i, hyp.muGrid hG hodd i 0) - params.zeta)
      = (params.delta : ℂ) • ((params.delta : ℂ)
          • hyp.tau ((∑ i, hyp.muGrid hG hodd i 0) - params.zeta)) := by
        rw [smul_smul, hδsq, one_smul]
    _ = (params.delta : ℂ) • ((params.delta : ℂ) • ((∑ i, hyp.alignedOmegaSigmaGrid hG hodd i 0)
          - coh.tau1 params.zeta)) := by rw [hscaled]
    _ = (∑ i, hyp.alignedOmegaSigmaGrid hG hodd i 0) - coh.tau1 params.zeta := by
        rw [smul_smul, hδsq, one_smul]

open scoped FiniteInduce in
/-- **§10 (2.7) adjoint at the trivial character**: for an `A_0`-supported class function `φ` on
`M`,
the Dade image `φ^τ = hyp.tau φ` has the same trivial-character multiplicity as `φ`,
`⟨φ^τ, 1_G⟩ = ⟨φ, 1_M⟩`.

The genuine §10 Dade isometry `hyp.tau` agrees on the supported subspace with the §4 Dade map
`hyp.dadeData.dade.dadeMap` (`dadeIntegralCharacterMap_apply_of_support`); the Peterfalvi (2.7)
adjoint
formula `adjoint_formula` with `χ = 1_G` gives `⟨dadeMap ⟨φ,_⟩, 1_G⟩ = ⟨φ, ψ⟩`, where the coset
average `ψ = adjointAverageFun 1_G` is the constant `1` (`|H(a)|⁻¹·∑_{x ∈ H(a)} 1 = 1`), i.e. the
trivial character `1_M`.  This is the `a_{00} = ((μ_0 − ζ)^τ, 1_G) = (μ_0 − ζ, 1_M)` computation
underlying Peterfalvi (10.9). -/
theorem Hypothesis.tau_inner_trivial [Finite G] {M : Subgroup G} (hyp : Hypothesis M)
    {φ : ClassFunction ↥M ℂ} (hφ : φ.support ⊆ hyp.A0) :
    ClassFunction.inner (hyp.tau φ) (trivialClassFunction G)
      = ClassFunction.inner φ (trivialClassFunction (↥M)) := by
  have := hyp.finiteG
  classical
  have hmem : φ ∈ ClassFunction.supportedSubmodule (G := ↥M) (k := ℂ)
      (OddOrder.Peterfalvi.S04.supportInSubgroup (typePA0 M hyp.typeP) M) :=
    (ClassFunction.mem_supportedSubmodule).mpr hφ
  -- `hyp.tau φ = dadeMap ⟨φ, supported⟩` on the supported subspace.
  have he : hyp.tau φ = hyp.dadeData.dade.dadeMap (k := ℂ) ⟨φ, hmem⟩ := by
    change OddOrder.Peterfalvi.S07.dadeIntegralCharacterMap hyp.dadeData.dade
        (hyp.dadeData.dade.fullDadeIsometryData) φ
      = hyp.dadeData.dade.dadeMap (k := ℂ) ⟨φ, hmem⟩
    rw [OddOrder.Peterfalvi.S07.dadeIntegralCharacterMap_apply_of_support hyp.dadeData.dade _ hφ]
  -- the coset average of `1_G` is the constant `1` (= `1_M`).
  have hψ : ∀ a : {a : G // a ∈ typePA0 M hyp.typeP},
      (trivialClassFunction (↥M)) ⟨a.1, hyp.dadeData.dade.subset_L a.2⟩
        = OddOrder.Peterfalvi.S04.adjointAverageFun hyp.dadeData.dade (trivialClassFunction G)
            ⟨a.1, hyp.dadeData.dade.subset_L a.2⟩ := by
    intro a
    rw [OddOrder.Peterfalvi.S04.adjointAverageFun, dif_pos a.2]
    simp only [trivialClassFunction_apply, Finset.sum_const, nsmul_eq_mul, mul_one,
      Finset.card_univ, ← Nat.card_eq_fintype_card]
    rw [inv_mul_cancel₀]
    exact_mod_cast Nat.card_pos.ne'
  rw [he]
  exact OddOrder.Peterfalvi.S04.adjoint_formula hyp.dadeData.dade hyp.dadeData.dade.dadeMap
    (hyp.dadeData.dade.isDadeMap_dadeMap (k := ℂ)) ⟨φ, hmem⟩ (trivialClassFunction G)
    (trivialClassFunction (↥M)) hψ

open scoped FiniteInduce in
/-- **§10 Dade isometry vanishes off the tame support `Ã(M) = dadeSupport`.**  For a class function
`φ` on `M` supported on `A_0(M)`, the Dade image `φ^τ = hyp.tau φ` *vanishes* at any
`g ∉ Ã(M) = hyp.dadeData.dade.dadeSupport`.

The genuine §10 Dade isometry `hyp.tau` is `S07.dadeIntegralCharacterMap hyp.dadeData.dade …`; on
the
supported subspace it agrees with the §4 Dade map `hyp.dadeData.dade.dadeMap`
(`dadeIntegralCharacterMap_apply_of_support`), which vanishes off `dadeSupport`
(`IsDadeMap.map_eq_zero_of_not_mem_dadeSupport`). This is the general "vanishes off `Ã(M)`"
companion
of `dadeIntegralCharacterMap_apply_one_eq_zero` (the `g = 1` special case), and the `Ã(M)`-vanishing
step of (10.6)(b) (issue 1009, STEP 2). -/
theorem Hypothesis.tau_apply_eq_zero_of_not_mem_dadeSupport [Finite G] {M : Subgroup G}
    (hyp : Hypothesis M) {φ : ClassFunction ↥M ℂ} (hφ : φ.support ⊆ hyp.A0)
    {g : G} (hg : g ∉ hyp.dadeData.dade.dadeSupport) :
    hyp.tau φ g = 0 := by
  have := hyp.finiteG
  classical
  change OddOrder.Peterfalvi.S07.dadeIntegralCharacterMap hyp.dadeData.dade
      (hyp.dadeData.dade.fullDadeIsometryData) φ g = 0
  rw [OddOrder.Peterfalvi.S07.dadeIntegralCharacterMap_apply_of_support hyp.dadeData.dade _ hφ]
  exact (hyp.dadeData.dade.isDadeMap_dadeMap (k := ℂ)).map_eq_zero_of_not_mem_dadeSupport
    (⟨φ, (ClassFunction.mem_supportedSubmodule).mpr hφ⟩ :
      OddOrder.Peterfalvi.S04.SupportedClassFunctions (G := G) ℂ (typePA0 M hyp.typeP) M) g hg

open scoped FiniteInduce in
/-- **§10 support of `μ_0 − ζ`** (Peterfalvi (10.6)(b), the `Ã(M)`-vanishing leg): the column-`0`
sum `μ_0 = ∑_i μ_{i0}` (an induced character of degree `w₁`, since each `μ_{i0}(1) = 1`) minus a
degree-`w₁` irreducible `ζ ∈ S` (induced from `M'`) is supported in `A_0(M)`.

Both `μ_0` and `ζ` are induced from the normal `M' = [M,M]`, hence vanish off `M'`
(`muGrid_column_sum_vanishes_off_derived`; induced-from-`M'` for `ζ`); and the degrees cancel,
`(μ_0 − ζ)(1) = w₁ − w₁ = 0` (`muGrid_zero_column_apply_one`), so the support lies in
`M'^# ⊆ A(M) ⊆ A_0(M)`.

This is the companion of `muColumn_sub_conj_support`/`zeta_sub_conj_support`: it makes `μ_0 − ζ`
`A_0`-supported, so the Dade isometry `τ` vanishes on it off `Ã(M)`
(`tau_apply_eq_zero_of_not_mem_dadeSupport`).  Together with the (10.6)(a) identity
`τ(μ_0 − ζ) = ∑_i ω_{i0}^σ − ζ^{τ₁}` (`tau_muColumnZero_sub_zeta_eq`) it yields the pointwise
identity `ζ^{τ₁}(g) = ∑_i ω_{i0}^σ(g)` off `Ã(M)`. -/
theorem Hypothesis.muColumnZero_sub_zeta_support [Finite G]
    (hG : OddOrder.BG.IsMinimalSimpleOdd G) {M : Subgroup G} (hyp : Hypothesis M)
    (hodd : Odd (Nat.card G)) {ζ : ClassFunction ↥M ℂ} (hζS : ζ ∈ inducedFamily M)
    (hζ1 : ζ 1 = (hyp.w1 : ℂ)) :
    ((∑ i : Fin hyp.w1, hyp.muGrid hG hodd i 0) - ζ).support ⊆ hyp.A0 := by
  have := hyp.finiteG
  classical
  obtain ⟨θ, _hθne, hζeq⟩ := hζS
  have hKcomm : (derivedInG M).subgroupOf M = commutator ↥M := by
    rw [derivedInG, Subgroup.subgroupOf,
      Subgroup.comap_map_eq_self_of_injective M.subtype_injective]
  have hKnormal : ((derivedInG M).subgroupOf M).Normal := by rw [hKcomm]; infer_instance
  have hζvanish : ∀ {w : ↥M}, w ∉ (derivedInG M).subgroupOf M → ζ w = 0 := fun {w} hw => by
    rw [hζeq]; exact ClassFunction.induce_eq_zero_of_not_mem_normal _ hw
  have hsumapply : ∀ (w : ↥M), (∑ i : Fin hyp.w1, hyp.muGrid hG hodd i 0) w
      = ∑ i : Fin hyp.w1, hyp.muGrid hG hodd i 0 w := by
    intro w
    refine Finset.univ.induction_on (motive := fun s =>
      (∑ i ∈ s, hyp.muGrid hG hodd i 0) w = ∑ i ∈ s, hyp.muGrid hG hodd i 0 w) ?_ ?_
    · simp
    · intro a s ha ih
      rw [Finset.sum_insert ha, Finset.sum_insert ha, ClassFunction.add_apply, ih]
  intro z hz
  rw [ClassFunction.mem_support] at hz
  -- `z ∈ M'`: else `μ_0 z = ζ z = 0`.
  have hzK : z ∈ (derivedInG M).subgroupOf M := by
    by_contra hzK
    apply hz
    rw [ClassFunction.sub_apply, hyp.muGrid_column_sum_vanishes_off_derived hG hodd 0 hzK,
      hζvanish hzK, sub_zero]
  -- `z ≠ 1`: `(μ_0 − ζ)(1) = w₁ − w₁ = 0`.
  have hz1 : z ≠ 1 := by
    rintro rfl
    apply hz
    rw [ClassFunction.sub_apply, hζ1, hsumapply 1,
      Finset.sum_congr rfl (fun i _ => hyp.muGrid_zero_column_apply_one hG hodd i),
      Finset.sum_const, Finset.card_univ, Fintype.card_fin, nsmul_eq_mul, mul_one, sub_self]
  have hzM' : (z : G) ∈ derivedInG M := Subgroup.mem_subgroupOf.mp hzK
  change (z : G) ∈ typePA0 M hyp.typeP
  unfold typePA0
  rw [Set.mem_union]
  left
  exact ⟨hzM', fun h0 => hz1 (Subtype.ext h0), (z : G),
    ⟨z.2, fun h0 => hz1 (Subtype.ext (Set.mem_singleton_iff.mp h0))⟩,
    Subgroup.mem_centralizer_singleton_iff.mpr rfl⟩

open scoped FiniteInduce in
/-- **Peterfalvi (10.6)(b), STEP 2** (the `Ã(M)`-vanishing reduction): off the tame support
`Ã(M) = dadeSupport`, the coherent image `ζ^{τ₁}` agrees with the column-`0` σ-sum,
`ζ^{τ₁}(g) = ∑_i ω_{i0}^σ(g)` for `g ∉ hyp.dadeData.dade.dadeSupport`.

Combines the (10.6)(a) identity `τ(μ_0 − ζ) = ∑_i ω_{i0}^σ − ζ^{τ₁}`
(`tau_muColumnZero_sub_zeta_eq`, STEP 1) with the vanishing of `τ(μ_0 − ζ)` off `Ã(M)`
(`tau_apply_eq_zero_of_not_mem_dadeSupport`, since `μ_0 − ζ` is `A_0`-supported by
`muColumnZero_sub_zeta_support`).  This is STEP 2 of (10.6)(b) (issue 1009); the remaining STEP 3
(parity of `∑_i ω_{i0}^σ(g)` using `ω_{00}^σ = 1_G` and the conjugate-pairing of the `i > 0`
terms) then gives `|ζ^{τ₁}(g)| ≥ 1`. -/
theorem Hypothesis.zeta_tau1_apply_eq_omegaSigma_sum_of_not_mem_dadeSupport [Finite G]
    (hG : OddOrder.BG.IsMinimalSimpleOdd G) {M : Subgroup G} {hyp : Hypothesis M}
    {params : CharacterParameters hyp} (coh : CoherentHypothesis hyp params)
    (hmu : params.mu = hyp.muGrid hG hG.odd)
    (hos : params.omegaSigma = hyp.alignedOmegaSigmaGrid hG hG.odd)
    (hzS : params.zeta ∈ inducedFamily M) (hz1 : params.zeta 1 = (hyp.w1 : ℂ))
    (hzconj : params.zeta.conj ≠ params.zeta)
    (hδpm : params.delta = 1 ∨ params.delta = -1)
    (hδj : ∀ j : Fin hyp.w2, j ≠ 0 → hyp.muColumnSign hG hG.odd j = params.delta)
    {g : G} (hg : g ∉ hyp.dadeData.dade.dadeSupport) :
    coh.tau1 params.zeta g
      = (∑ i : Fin hyp.w1, hyp.alignedOmegaSigmaGrid hG hG.odd i 0) g := by
  have := hyp.finiteG
  -- STEP 1: `τ(μ_0 − ζ) = ∑_i ω_{i0}^σ − ζ^{τ₁}` as class functions on `G`.
  have hstep1 := hyp.tau_muColumnZero_sub_zeta_eq hG coh hmu hos hzS hz1 hzconj hδpm hδj
  -- `μ_0 − ζ` is `A_0`-supported, so `τ(μ_0 − ζ)` vanishes off `Ã(M)`.
  have hsupp := hyp.muColumnZero_sub_zeta_support hG hG.odd hzS hz1
  have hvanish := hyp.tau_apply_eq_zero_of_not_mem_dadeSupport hsupp hg
  -- Evaluate the STEP 1 identity at `g` (`ClassFunction` is a `CoeFun`, not `DFunLike`).
  have heval : hyp.tau ((∑ i : Fin hyp.w1, hyp.muGrid hG hG.odd i 0) - params.zeta) g
      = ((∑ i : Fin hyp.w1, hyp.alignedOmegaSigmaGrid hG hG.odd i 0)
          - coh.tau1 params.zeta) g :=
    congrArg (fun f : ClassFunction G ℂ => (f : G → ℂ) g) hstep1
  -- Cancel the vanishing left-hand side.
  rw [ClassFunction.sub_apply, hvanish] at heval
  linear_combination heval

open scoped FiniteInduce in
set_option backward.isDefEq.respectTransparency false in
/-- **Peterfalvi (10.6)(b), STEP 3 — integrality of the column-`0` σ-grid value** ((3.9)(c) on the
aligned grid): for `g : G` of order prime to `w₁`, each `ω_{i0}^σ(g)` is a rational integer.

The aligned grid is `ω_{i0}^σ = σ(ω(ξ_i))` for the transported linear character
`ξ_i = (omegaProdChar (w1CharEquiv i) χ₂).comp e` of `tic.W` (column-`0` dual `χ₂ = 1`).  As column
`0` is trivial, `ξ_i` factors through `W₁` (`omegaProdChar_one_right`), so
`orderOf ξ_i ∣ |W₁| = w₁`;
since `(orderOf g)` is coprime to `w₁` it is coprime to `orderOf ξ_i`, and (3.9)(c)
(`exists_intCast_sigma_omega_apply`) gives the integer. -/
theorem Hypothesis.exists_intCast_alignedOmegaSigmaGrid_zero_column [Finite G]
    (hG : OddOrder.BG.IsMinimalSimpleOdd G) {M : Subgroup G} (hyp : Hypothesis M)
    (hodd : Odd (Nat.card G)) (i : Fin hyp.w1) {g : G}
    (hg : (orderOf g).Coprime hyp.w1) :
    ∃ n : ℤ, hyp.alignedOmegaSigmaGrid hG hodd i 0 g = (n : ℂ) := by
  have := hyp.finiteG
  classical
  -- reconstruct the `let`s of `alignedOmegaSigmaGrid`
  let h := (hyp.toCertainTypeHypothesis hG hodd).toHypothesis
  have : NeZero (Nat.card h.W1) := ⟨by have := h.one_lt_card_W1; omega⟩
  have : IsCyclic ↥(h.W1 ⊔ h.W2) := h.isCyclic_sup
  let : CommGroup ↥(h.W1 ⊔ h.W2) := IsCyclic.commGroup
  have hW1le : hyp.typeP.W1 ≤ M := hyp.typeP.W1_le
  have hW2le : hyp.typeP.W2 ≤ M := typePData_W2_le_self hyp.typeP
  have hcardW1 : Nat.card ↥h.W1 = hyp.w1 :=
    Nat.card_congr (Subgroup.subgroupOfEquivOfLe hW1le).toEquiv
  have hcardW2sub : Nat.card ↥(h.W2.subgroupOf (h.W1 ⊔ h.W2)) = hyp.w2 := by
    rw [Nat.card_congr (Subgroup.subgroupOfEquivOfLe (le_sup_right)).toEquiv]
    exact Nat.card_congr (Subgroup.subgroupOfEquivOfLe hW2le).toEquiv
  have : NeZero (Nat.card ↥(h.W2.subgroupOf (h.W1 ⊔ h.W2))) := ⟨Nat.card_pos.ne'⟩
  let χ₂ : (h.W2.subgroupOf (h.W1 ⊔ h.W2)) →* ℂˣ :=
    finCardEquivCharacterGroup _ (finCongr hcardW2sub.symm (0 : Fin hyp.w2))
  let tic := typePData_toTICyclicHypothesis hyp.typeP hodd
  have : NeZero (Nat.card ↥tic.W1) := ⟨Nat.card_pos.ne'⟩
  have : NeZero (Nat.card ↥tic.W2) := ⟨Nat.card_pos.ne'⟩
  let e : ↥tic.W ≃* ↥(h.W1 ⊔ h.W2) :=
    (Subgroup.subgroupOfEquivOfLe (typePData_W_le_self hyp.typeP)).symm.trans
      (MulEquiv.subgroupCongr (typePData_sup_subgroupOf_eq hyp.typeP).symm)
  -- the transported linear character `ξ` of `tic.W`
  let ξ : ↥tic.W →* ℂˣ :=
    (h.sdiffTICyclicHypothesis.omegaProdChar (h.w1CharEquiv (finCongr hcardW1.symm i)) χ₂).comp
      e.toMonoidHom
  -- `alignedOmegaSigmaGrid i 0 = σ(ω ξ)` (mirror the `step1` of the χ-family lemma; `ω = lin`).
  have step1 : hyp.alignedOmegaSigmaGrid hG hodd i 0
      = tic.sigma rfl (hyp.canonicalFullDadeApp hG hodd)
        (tic.omega ξ : ClassFunction ↥tic.W ℂ) := by
    change tic.sigmaIntegral rfl (hyp.canonicalFullDadeApp hG hodd)
        (tic.omega ξ : ClassFunction ↥tic.W ℂ)
      = tic.sigma rfl (hyp.canonicalFullDadeApp hG hodd) (tic.omega ξ : ClassFunction ↥tic.W ℂ)
    rw [OddOrder.Peterfalvi.S05.TICyclicHypothesis.sigmaIntegral_apply]
  -- column `0` dual is trivial, so `ξ = (w1CharEquiv …).comp wFst ∘ e` factors through `W₁`.
  have hχ₂ : χ₂ = 1 := by
    change finCardEquivCharacterGroup _ (finCongr hcardW2sub.symm (0 : Fin hyp.w2)) = 1
    rw [show (finCongr hcardW2sub.symm (0 : Fin hyp.w2)) = 0 from by simp,
      finCardEquivCharacterGroup_zero]
  -- `(w1CharEquiv …) ^ w₁ = 1` from `|Ŵ₁| = |W₁| = w₁` (Pontryagin self-duality).
  have hcardDual : Nat.card ((h.W1.subgroupOf (h.W1 ⊔ h.W2)) →* ℂˣ) = hyp.w1 :=
    (h.sdiffTICyclicHypothesis.card_charGroup_subgroupOf
      h.sdiffTICyclicHypothesis.W1_le_W).trans hcardW1
  have hχ1pow : (h.w1CharEquiv (finCongr hcardW1.symm i)) ^ hyp.w1 = 1 := by
    have := pow_card_eq_one' (x := h.w1CharEquiv (finCongr hcardW1.symm i))
    rwa [hcardDual] at this
  -- column `0` trivial ⟹ `ξ` factors through `W₁` as `(w1CharEquiv …).comp wFst ∘ e`.
  have hξeq : ξ = ((h.w1CharEquiv (finCongr hcardW1.symm i)).comp
      h.sdiffTICyclicHypothesis.wFst).comp e.toMonoidHom := by
    have hpc : (h.sdiffTICyclicHypothesis.omegaProdChar
        (h.w1CharEquiv (finCongr hcardW1.symm i)) χ₂)
        = (h.w1CharEquiv (finCongr hcardW1.symm i)).comp h.sdiffTICyclicHypothesis.wFst := by
      rw [hχ₂]
      exact h.sdiffTICyclicHypothesis.omegaProdChar_one_right _
    exact congrArg (fun f => f.comp e.toMonoidHom) hpc
  -- `ξ ^ w₁ = 1` pointwise.
  have hξpow : ξ ^ hyp.w1 = 1 := by
    refine MonoidHom.ext fun w => Units.val_injective ?_
    rw [MonoidHom.pow_apply, Units.val_pow_eq_pow_val, MonoidHom.one_apply, Units.val_one, hξeq,
      MonoidHom.comp_apply, MonoidHom.comp_apply, ← Units.val_pow_eq_pow_val, ← MonoidHom.pow_apply,
      hχ1pow, MonoidHom.one_apply, Units.val_one]
  have hdvd : orderOf ξ ∣ hyp.w1 := orderOf_dvd_of_pow_eq_one hξpow
  have hcop : (orderOf g).Coprime (orderOf ξ) := hg.coprime_dvd_right hdvd
  obtain ⟨n, hn⟩ :=
    tic.exists_intCast_sigma_omega_apply rfl (hyp.canonicalFullDadeApp hG hodd) ξ hcop
  exact ⟨n, by rw [step1]; exact hn⟩

open scoped FiniteInduce in
set_option backward.isDefEq.respectTransparency false in
/-- **Peterfalvi (10.6)(b), STEP 3 — the principal grid value** ((4.4)/(3.2)(b)): the `(0,0)` entry
of the aligned σ-grid is the trivial character `1_G`, `ω_{00}^σ = 1_G`.

For `i = 0`, column `0`: the source `ξ_{00} = (omegaProdChar (w1CharEquiv 0) χ₂).comp e` is trivial
—
`w1CharEquiv 0 = 1` (`w1CharEquiv_zero`), `χ₂ = 1` (column `0`), so `omegaProdChar 1 1 = 1`
(`omegaProdChar_one_one`) and `(1).comp e = 1`.  Then `tic.omega 1 = 1_{tic.W}` and
`1_{tic.W}^σ = 1_G` (`sigma_trivial`). -/
theorem Hypothesis.alignedOmegaSigmaGrid_zero_zero [Finite G]
    (hG : OddOrder.BG.IsMinimalSimpleOdd G) {M : Subgroup G} (hyp : Hypothesis M)
    (hodd : Odd (Nat.card G)) :
    hyp.alignedOmegaSigmaGrid hG hodd 0 0 = trivialClassFunction G := by
  have := hyp.finiteG
  classical
  -- reconstruct the `let`s of `alignedOmegaSigmaGrid`
  let h := (hyp.toCertainTypeHypothesis hG hodd).toHypothesis
  have : NeZero (Nat.card h.W1) := ⟨by have := h.one_lt_card_W1; omega⟩
  have : IsCyclic ↥(h.W1 ⊔ h.W2) := h.isCyclic_sup
  let : CommGroup ↥(h.W1 ⊔ h.W2) := IsCyclic.commGroup
  have hW1le : hyp.typeP.W1 ≤ M := hyp.typeP.W1_le
  have hW2le : hyp.typeP.W2 ≤ M := typePData_W2_le_self hyp.typeP
  have hcardW1 : Nat.card ↥h.W1 = hyp.w1 :=
    Nat.card_congr (Subgroup.subgroupOfEquivOfLe hW1le).toEquiv
  have hcardW2sub : Nat.card ↥(h.W2.subgroupOf (h.W1 ⊔ h.W2)) = hyp.w2 := by
    rw [Nat.card_congr (Subgroup.subgroupOfEquivOfLe (le_sup_right)).toEquiv]
    exact Nat.card_congr (Subgroup.subgroupOfEquivOfLe hW2le).toEquiv
  have : NeZero (Nat.card ↥(h.W2.subgroupOf (h.W1 ⊔ h.W2))) := ⟨Nat.card_pos.ne'⟩
  let χ₂ : (h.W2.subgroupOf (h.W1 ⊔ h.W2)) →* ℂˣ :=
    finCardEquivCharacterGroup _ (finCongr hcardW2sub.symm (0 : Fin hyp.w2))
  let tic := typePData_toTICyclicHypothesis hyp.typeP hodd
  have : NeZero (Nat.card ↥tic.W1) := ⟨Nat.card_pos.ne'⟩
  have : NeZero (Nat.card ↥tic.W2) := ⟨Nat.card_pos.ne'⟩
  let e : ↥tic.W ≃* ↥(h.W1 ⊔ h.W2) :=
    (Subgroup.subgroupOfEquivOfLe (typePData_W_le_self hyp.typeP)).symm.trans
      (MulEquiv.subgroupCongr (typePData_sup_subgroupOf_eq hyp.typeP).symm)
  let ξ : ↥tic.W →* ℂˣ :=
    (h.sdiffTICyclicHypothesis.omegaProdChar
      (h.w1CharEquiv (finCongr hcardW1.symm (0 : Fin hyp.w1)))
      χ₂).comp e.toMonoidHom
  -- `alignedOmegaSigmaGrid 0 0 = σ(ω ξ)` (mirror the `step1` of the χ-family lemma).
  have step1 : hyp.alignedOmegaSigmaGrid hG hodd 0 0
      = tic.sigma rfl (hyp.canonicalFullDadeApp hG hodd)
        (tic.omega ξ : ClassFunction ↥tic.W ℂ) := by
    change tic.sigmaIntegral rfl (hyp.canonicalFullDadeApp hG hodd)
        (tic.omega ξ : ClassFunction ↥tic.W ℂ)
      = tic.sigma rfl (hyp.canonicalFullDadeApp hG hodd) (tic.omega ξ : ClassFunction ↥tic.W ℂ)
    rw [OddOrder.Peterfalvi.S05.TICyclicHypothesis.sigmaIntegral_apply]
  -- both indices trivial ⟹ `ξ = 1`.
  have hχ₂ : χ₂ = 1 := by
    change finCardEquivCharacterGroup _ (finCongr hcardW2sub.symm (0 : Fin hyp.w2)) = 1
    rw [show (finCongr hcardW2sub.symm (0 : Fin hyp.w2)) = 0 from by simp,
      finCardEquivCharacterGroup_zero]
  have hχ1 : h.w1CharEquiv (finCongr hcardW1.symm (0 : Fin hyp.w1)) = 1 := by
    rw [show (finCongr hcardW1.symm (0 : Fin hyp.w1)) = 0 from by simp, h.w1CharEquiv_zero]
  have hξ1 : ξ = 1 := by
    have hpc : h.sdiffTICyclicHypothesis.omegaProdChar
        (h.w1CharEquiv (finCongr hcardW1.symm (0 : Fin hyp.w1))) χ₂ = 1 := by
      rw [hχ₂, hχ1]; exact h.sdiffTICyclicHypothesis.omegaProdChar_one_one
    change (h.sdiffTICyclicHypothesis.omegaProdChar
      (h.w1CharEquiv (finCongr hcardW1.symm (0 : Fin hyp.w1))) χ₂).comp e.toMonoidHom = 1
    rw [hpc, MonoidHom.one_comp]
  -- `tic.omega 1 = 1_{tic.W}`, and `1_{tic.W}^σ = 1_G`.
  have homega1 : (tic.omega (1 : ↥tic.W →* ℂˣ) : ClassFunction ↥tic.W ℂ)
      = trivialClassFunction ↥tic.W := by ext w; simp
  rw [step1, hξ1, homega1, OddOrder.Peterfalvi.S05.TICyclicHypothesis.sigma_trivial]

open scoped FiniteInduce in
set_option backward.isDefEq.respectTransparency false in
/-- **Peterfalvi (10.6)(b), STEP 3 — the row-conjugation involution** ((3.9)(a)/(4.9)(a) on the
aligned column-`0` grid): complex conjugation of `ω_{i0}^σ` is again a column-`0` grid value
`ω_{i'0}^σ`, where `i' = rowInv i` is the **row-inversion** index (`w1CharEquiv i' =
(w1CharEquiv i)⁻¹`); moreover `i' = i ↔ i = 0` (in the odd-order dual `Ŵ₁`, `χ⁻¹ = χ ⟺ χ = 1`), and
`i ↦ i'` is an involution.

`mapRingEquiv conj (ω_{i0}^σ) = sigma(galoisMap conj (ω(ξ_i))) = sigma(ω(ξ_i⁻¹))`
(`sigma_mapRingEquiv_comm` + `galoisMap_conj_omega`), and `ξ_i⁻¹ = ξ_{i'}` since
`omegaProdChar χ₁ χ₂` inverts coordinatewise (`omegaProdChar_inv`), `w1CharEquiv (rowInv i) =
(w1CharEquiv i)⁻¹` (`w1CharEquiv_rowInv`) and `χ₂⁻¹ = χ₂` (column `0` is trivial).  This is the
(3.9)(a) ingredient that pairs the `i > 0` terms of `∑_i ω_{i0}^σ(g)`. -/
theorem Hypothesis.exists_rowInv_alignedOmegaSigma_conj [Finite G]
    (hG : OddOrder.BG.IsMinimalSimpleOdd G) {M : Subgroup G} (hyp : Hypothesis M)
    (hodd : Odd (Nat.card G)) (i : Fin hyp.w1) :
    ∃ i' : Fin hyp.w1,
      ClassFunction.mapRingEquiv Complex.conjAe.toRingEquiv
          (hyp.alignedOmegaSigmaGrid hG hodd i 0)
        = hyp.alignedOmegaSigmaGrid hG hodd i' 0
      ∧ (i' = i ↔ i = 0)
      ∧ (∀ j' : Fin hyp.w1,
          (ClassFunction.mapRingEquiv Complex.conjAe.toRingEquiv
              (hyp.alignedOmegaSigmaGrid hG hodd i' 0)
            = hyp.alignedOmegaSigmaGrid hG hodd j' 0) → j' = i) := by
  have := hyp.finiteG
  classical
  -- reconstruct the `let`s of `alignedOmegaSigmaGrid`
  let h := (hyp.toCertainTypeHypothesis hG hodd).toHypothesis
  have : NeZero (Nat.card h.W1) := ⟨by have := h.one_lt_card_W1; omega⟩
  have : IsCyclic ↥(h.W1 ⊔ h.W2) := h.isCyclic_sup
  let : CommGroup ↥(h.W1 ⊔ h.W2) := IsCyclic.commGroup
  have hW1le : hyp.typeP.W1 ≤ M := hyp.typeP.W1_le
  have hW2le : hyp.typeP.W2 ≤ M := typePData_W2_le_self hyp.typeP
  have hcardW1 : Nat.card ↥h.W1 = hyp.w1 :=
    Nat.card_congr (Subgroup.subgroupOfEquivOfLe hW1le).toEquiv
  have hcardW2sub : Nat.card ↥(h.W2.subgroupOf (h.W1 ⊔ h.W2)) = hyp.w2 := by
    rw [Nat.card_congr (Subgroup.subgroupOfEquivOfLe (le_sup_right)).toEquiv]
    exact Nat.card_congr (Subgroup.subgroupOfEquivOfLe hW2le).toEquiv
  have : NeZero (Nat.card ↥(h.W2.subgroupOf (h.W1 ⊔ h.W2))) := ⟨Nat.card_pos.ne'⟩
  let χ₂ : (h.W2.subgroupOf (h.W1 ⊔ h.W2)) →* ℂˣ :=
    finCardEquivCharacterGroup _ (finCongr hcardW2sub.symm (0 : Fin hyp.w2))
  let tic := typePData_toTICyclicHypothesis hyp.typeP hodd
  have : NeZero (Nat.card ↥tic.W1) := ⟨Nat.card_pos.ne'⟩
  have : NeZero (Nat.card ↥tic.W2) := ⟨Nat.card_pos.ne'⟩
  let e : ↥tic.W ≃* ↥(h.W1 ⊔ h.W2) :=
    (Subgroup.subgroupOfEquivOfLe (typePData_W_le_self hyp.typeP)).symm.trans
      (MulEquiv.subgroupCongr (typePData_sup_subgroupOf_eq hyp.typeP).symm)
  -- the transported linear character `ξ_a` of `tic.W` for any row `a`
  let ξ : Fin hyp.w1 → (↥tic.W →* ℂˣ) := fun a =>
    (h.sdiffTICyclicHypothesis.omegaProdChar (h.w1CharEquiv (finCongr hcardW1.symm a)) χ₂).comp
      e.toMonoidHom
  -- `alignedOmegaSigmaGrid a 0 = σ(ω ξ_a)` for any row `a`.
  have step1 : ∀ a, hyp.alignedOmegaSigmaGrid hG hodd a 0
      = tic.sigma rfl (hyp.canonicalFullDadeApp hG hodd)
        (tic.omega (ξ a) : ClassFunction ↥tic.W ℂ) := by
    intro a
    change tic.sigmaIntegral rfl (hyp.canonicalFullDadeApp hG hodd)
        (tic.omega (ξ a) : ClassFunction ↥tic.W ℂ)
      = tic.sigma rfl (hyp.canonicalFullDadeApp hG hodd) (tic.omega (ξ a) : ClassFunction ↥tic.W ℂ)
    rw [OddOrder.Peterfalvi.S05.TICyclicHypothesis.sigmaIntegral_apply]
  -- column `0` dual is trivial: `χ₂ = 1` (so `χ₂⁻¹ = χ₂`).
  have hχ₂ : χ₂ = 1 := by
    change finCardEquivCharacterGroup _ (finCongr hcardW2sub.symm (0 : Fin hyp.w2)) = 1
    rw [show (finCongr hcardW2sub.symm (0 : Fin hyp.w2)) = 0 from by simp,
      finCardEquivCharacterGroup_zero]
  -- the row-inversion translated index
  let i' : Fin hyp.w1 :=
    finCongr hcardW1 (OddOrder.Peterfalvi.S06.rowInv h (finCongr hcardW1.symm i))
  -- `finCongr` round-trip: `finCongr hcardW1.symm i' = rowInv (finCongr hcardW1.symm i)`.
  have hround : finCongr hcardW1.symm i'
      = OddOrder.Peterfalvi.S06.rowInv h (finCongr hcardW1.symm i) := by
    change finCongr hcardW1.symm
        (finCongr hcardW1 (OddOrder.Peterfalvi.S06.rowInv h (finCongr hcardW1.symm i)))
      = OddOrder.Peterfalvi.S06.rowInv h (finCongr hcardW1.symm i)
    simp
  -- `χ₂⁻¹ = χ₂` (column `0` is trivial).
  have hχ₂inv : χ₂⁻¹ = χ₂ := by
    rw [hχ₂]
    exact @inv_one ((h.W2.subgroupOf (h.W1 ⊔ h.W2)) →* ℂˣ) _
  -- key: `mapRingEquiv conj (ω_{a0}^σ) = ω_{a'0}^σ` for a row `a` with translated index `a'`.
  have hconj : ∀ a : Fin hyp.w1,
      ClassFunction.mapRingEquiv Complex.conjAe.toRingEquiv (hyp.alignedOmegaSigmaGrid hG hodd a 0)
        = hyp.alignedOmegaSigmaGrid hG hodd
            (finCongr hcardW1 (OddOrder.Peterfalvi.S06.rowInv h (finCongr hcardW1.symm a))) 0 := by
    intro a
    have hroundA : finCongr hcardW1.symm
        (finCongr hcardW1 (OddOrder.Peterfalvi.S06.rowInv h (finCongr hcardW1.symm a)))
      = OddOrder.Peterfalvi.S06.rowInv h (finCongr hcardW1.symm a) := by simp
    -- `ξ_a⁻¹ = ξ_{a'}`.
    have hξinv : (ξ a)⁻¹
        = ξ (finCongr hcardW1 (OddOrder.Peterfalvi.S06.rowInv h (finCongr hcardW1.symm a))) := by
      -- the underlying `omegaProdChar` factors invert; `χ₂⁻¹ = χ₂`, row inverts via `rowInv`.
      have hprod : (h.sdiffTICyclicHypothesis.omegaProdChar
            (h.w1CharEquiv (finCongr hcardW1.symm a)) χ₂)⁻¹
          = h.sdiffTICyclicHypothesis.omegaProdChar
              (h.w1CharEquiv (finCongr hcardW1.symm
                (finCongr hcardW1 (OddOrder.Peterfalvi.S06.rowInv h (finCongr hcardW1.symm a)))))
                χ₂ := by
        rw [hroundA, OddOrder.Peterfalvi.S06.w1CharEquiv_rowInv,
          OddOrder.Peterfalvi.S06.omegaProdChar_inv, hχ₂]
        congr 1
      change ((h.sdiffTICyclicHypothesis.omegaProdChar
          (h.w1CharEquiv (finCongr hcardW1.symm a)) χ₂).comp e.toMonoidHom)⁻¹
        = (h.sdiffTICyclicHypothesis.omegaProdChar
          (h.w1CharEquiv (finCongr hcardW1.symm
            (finCongr hcardW1 (OddOrder.Peterfalvi.S06.rowInv h (finCongr hcardW1.symm a)))))
              χ₂).comp e.toMonoidHom
      refine MonoidHom.ext fun w => Units.val_injective ?_
      rw [MonoidHom.comp_apply, MonoidHom.inv_apply, MonoidHom.comp_apply, ← hprod,
        MonoidHom.inv_apply]
    rw [step1 a,
      step1 (finCongr hcardW1 (OddOrder.Peterfalvi.S06.rowInv h (finCongr hcardW1.symm a))),
      tic.sigma_mapRingEquiv_comm rfl (hyp.canonicalFullDadeApp hG hodd) _ _,
      OddOrder.Peterfalvi.S06.galoisMap_conj_omega, hξinv]
  -- oddness of the dual `Ŵ₁` (from `Odd |G|` via `W₁ ≤ M ≤ G` and Pontryagin).
  have hcardDual : Nat.card ((h.W1.subgroupOf (h.W1 ⊔ h.W2)) →* ℂˣ) = hyp.w1 :=
    (h.sdiffTICyclicHypothesis.card_charGroup_subgroupOf
      h.sdiffTICyclicHypothesis.W1_le_W).trans hcardW1
  have hoddM : Odd (Nat.card ↥M) := Odd.of_dvd_nat hodd (Subgroup.card_subgroup_dvd_card M)
  have hoddW1 : Odd (Nat.card ↥h.W1) :=
    Odd.of_dvd_nat hoddM (Subgroup.card_subgroup_dvd_card h.W1)
  -- in the odd-order dual, `χ⁻¹ = χ ⟹ χ = 1`.
  have hsq_one : ∀ χ : (h.W1.subgroupOf (h.W1 ⊔ h.W2)) →* ℂˣ, χ⁻¹ = χ → χ = 1 := by
    intro χ hχ
    have : Finite ((h.W1.subgroupOf (h.W1 ⊔ h.W2)) →* ℂˣ) := Finite.of_fintype _
    have hx2 : χ ^ 2 = 1 := by rw [pow_two]; nth_rewrite 1 [← hχ]; exact inv_mul_cancel χ
    have h2 : orderOf χ ∣ 2 := orderOf_dvd_of_pow_eq_one hx2
    have hc : orderOf χ ∣ Nat.card ((h.W1.subgroupOf (h.W1 ⊔ h.W2)) →* ℂˣ) := orderOf_dvd_natCard χ
    have hcop : Nat.Coprime 2 (Nat.card ((h.W1.subgroupOf (h.W1 ⊔ h.W2)) →* ℂˣ)) := by
      rw [Nat.coprime_two_left, hcardDual, ← hcardW1]; exact hoddW1
    have hg : orderOf χ ∣ Nat.gcd 2 (Nat.card ((h.W1.subgroupOf (h.W1 ⊔ h.W2)) →* ℂˣ)) :=
      Nat.dvd_gcd h2 hc
    rw [hcop.gcd_eq_one] at hg
    exact orderOf_eq_one_iff.mp (Nat.dvd_one.mp hg)
  refine ⟨i', hconj i, ?_, ?_⟩
  · -- `i' = i ↔ i = 0`.
    constructor
    · intro hii
      have hceq : (h.w1CharEquiv (finCongr hcardW1.symm i))⁻¹
          = h.w1CharEquiv (finCongr hcardW1.symm i) := by
        rw [← OddOrder.Peterfalvi.S06.w1CharEquiv_rowInv, ← hround, hii]
      have hx1 : h.w1CharEquiv (finCongr hcardW1.symm i) = 1 := hsq_one _ hceq
      have hz : finCongr hcardW1.symm i = 0 :=
        h.w1CharEquiv.injective (hx1.trans h.w1CharEquiv_zero.symm)
      have h0 : i = finCongr hcardW1 (0 : Fin (Nat.card h.W1)) := by rw [← hz]; simp
      rw [h0]; simp
    · intro hi0
      have hz : finCongr hcardW1.symm i = 0 := by rw [hi0]; simp
      change finCongr hcardW1 (OddOrder.Peterfalvi.S06.rowInv h (finCongr hcardW1.symm i)) = i
      rw [hz]
      have hrow0 : OddOrder.Peterfalvi.S06.rowInv h (0 : Fin (Nat.card h.W1)) = 0 := by
        have h_inv_one :
            ((1 : (h.W1.subgroupOf (h.W1 ⊔ h.W2)) →* ℂˣ)⁻¹) = 1 :=
          @inv_one ((h.W1.subgroupOf (h.W1 ⊔ h.W2)) →* ℂˣ) _
        rw [OddOrder.Peterfalvi.S06.rowInv, h.w1CharEquiv_zero, h_inv_one]
        exact h.w1CharEquiv.symm_apply_eq.mpr h.w1CharEquiv_zero.symm
      rw [hrow0, hi0]; simp
  · -- involution: applying the construction to `i'` returns `i`.
    intro j' hj'
    have hkey := hconj i'
    rw [hj'] at hkey
    have hii : finCongr hcardW1 (OddOrder.Peterfalvi.S06.rowInv h (finCongr hcardW1.symm i'))
        = i := by
      rw [hround, OddOrder.Peterfalvi.S06.rowInv_rowInv]; simp
    rw [hii] at hkey
    -- `hkey : ω_{j'0}^σ = ω_{i0}^σ`.  Conclude `j' = i` via grid orthonormality.
    by_contra hne
    have hortho := hyp.alignedOmegaSigmaGrid_inner hG hodd j' i 0 0
    rw [hkey, hyp.alignedOmegaSigmaGrid_inner hG hodd i i 0 0, if_pos ⟨rfl, rfl⟩,
      if_neg (fun hc => hne hc.1)] at hortho
    exact one_ne_zero hortho

open scoped FiniteInduce in
/-- **Peterfalvi (10.6)(b), STEP 3 — the parity bound** (the (10.6)(b) target): off the tame support
`Ã(M)`, at a `g` of order prime to `w₁`, the coherent image `ζ^{τ₁}(g)` is an **odd integer**.

By STEP 2 (`zeta_tau1_apply_eq_omegaSigma_sum_of_not_mem_dadeSupport`),
`ζ^{τ₁}(g) = ∑_i ω_{i0}^σ(g)`.  Each `ω_{i0}^σ(g)` is a rational integer `n_i`
(`exists_intCast_alignedOmegaSigmaGrid_zero_column`, (3.9)(c)), so `ζ^{τ₁}(g) = (∑_i n_i : ℤ)`.
The terms pair under the row-conjugation involution `i ↦ i'`
(`exists_rowInv_alignedOmegaSigma_conj`,
(3.9)(a)): `n_{i'} = n_i` (conjugation fixes the real integer), and the unique fixed point `i = 0`
carries the principal value `n_0 = 1` (`alignedOmegaSigmaGrid_zero_zero`, `ω_{00}^σ = 1_G`). Hence
the
off-principal terms sum to an even integer and `∑_i n_i = 1 + even` is odd; in particular
`|ζ^{τ₁}(g)| ≥ 1`.  This closes (10.6)(b) (issue 1009). -/
theorem Hypothesis.zeta_tau1_norm_ge_one [Finite G]
    (hG : OddOrder.BG.IsMinimalSimpleOdd G) {M : Subgroup G} {hyp : Hypothesis M}
    {params : CharacterParameters hyp} (coh : CoherentHypothesis hyp params)
    (hmu : params.mu = hyp.muGrid hG hG.odd)
    (hos : params.omegaSigma = hyp.alignedOmegaSigmaGrid hG hG.odd)
    (hzS : params.zeta ∈ inducedFamily M) (hz1 : params.zeta 1 = (hyp.w1 : ℂ))
    (hzconj : params.zeta.conj ≠ params.zeta)
    (hδpm : params.delta = 1 ∨ params.delta = -1)
    (hδj : ∀ j : Fin hyp.w2, j ≠ 0 → hyp.muColumnSign hG hG.odd j = params.delta)
    {g : G} (hg : g ∉ hyp.dadeData.dade.dadeSupport) (hgord : (orderOf g).Coprime hyp.w1) :
    ∃ m : ℤ, coh.tau1 params.zeta g = (m : ℂ) ∧ Odd m := by
  have := hyp.finiteG
  classical
  -- STEP 2: `ζ^{τ₁}(g) = ∑_i ω_{i0}^σ(g)`.
  have hstep2 := hyp.zeta_tau1_apply_eq_omegaSigma_sum_of_not_mem_dadeSupport
    hG coh hmu hos hzS hz1 hzconj hδpm hδj hg
  -- push the application through the finite sum (CoeFun, not DFunLike).
  have hsumapply : (∑ i : Fin hyp.w1, hyp.alignedOmegaSigmaGrid hG hG.odd i 0) g
      = ∑ i : Fin hyp.w1, (hyp.alignedOmegaSigmaGrid hG hG.odd i 0) g := by
    refine Finset.univ.induction_on (motive := fun s =>
      (∑ i ∈ s, hyp.alignedOmegaSigmaGrid hG hG.odd i 0) g
        = ∑ i ∈ s, (hyp.alignedOmegaSigmaGrid hG hG.odd i 0) g) ?_ ?_
    · simp
    · intro a s ha ih
      rw [Finset.sum_insert ha, Finset.sum_insert ha, ClassFunction.add_apply, ih]
  -- (3.9)(c): each `ω_{i0}^σ(g)` is a rational integer `n i`.
  have hint : ∀ i : Fin hyp.w1,
      ∃ n : ℤ, (hyp.alignedOmegaSigmaGrid hG hG.odd i 0) g = (n : ℂ) := fun i =>
    hyp.exists_intCast_alignedOmegaSigmaGrid_zero_column hG hG.odd i hgord
  let n : Fin hyp.w1 → ℤ := fun i => (hint i).choose
  have hn : ∀ i, (hyp.alignedOmegaSigmaGrid hG hG.odd i 0) g = (n i : ℂ) :=
    fun i => (hint i).choose_spec
  -- `m := ∑ n i`, and `ζ^{τ₁}(g) = (m : ℂ)`.
  have hval : coh.tau1 params.zeta g = ((∑ i : Fin hyp.w1, n i : ℤ) : ℂ) := by
    rw [hstep2, hsumapply]
    push_cast
    exact Finset.sum_congr rfl (fun i _ => hn i)
  refine ⟨∑ i : Fin hyp.w1, n i, hval, ?_⟩
  -- the row-conjugation involution `ρ` ((3.9)(a)).
  have hB : ∀ a : Fin hyp.w1, ∃ i' : Fin hyp.w1,
      ClassFunction.mapRingEquiv Complex.conjAe.toRingEquiv
        (hyp.alignedOmegaSigmaGrid hG hG.odd a 0)
        = hyp.alignedOmegaSigmaGrid hG hG.odd i' 0
      ∧ (i' = a ↔ a = 0)
      ∧ (∀ j' : Fin hyp.w1,
          (ClassFunction.mapRingEquiv Complex.conjAe.toRingEquiv
              (hyp.alignedOmegaSigmaGrid hG hG.odd i' 0)
            = hyp.alignedOmegaSigmaGrid hG hG.odd j' 0) → j' = a) := fun a =>
    hyp.exists_rowInv_alignedOmegaSigma_conj hG hG.odd a
  let ρ : Fin hyp.w1 → Fin hyp.w1 := fun a => (hB a).choose
  have hρconj : ∀ a, ClassFunction.mapRingEquiv Complex.conjAe.toRingEquiv
        (hyp.alignedOmegaSigmaGrid hG hG.odd a 0)
      = hyp.alignedOmegaSigmaGrid hG hG.odd (ρ a) 0 := fun a => (hB a).choose_spec.1
  have hρfix : ∀ a, ρ a = a ↔ a = 0 := fun a => (hB a).choose_spec.2.1
  have hρinv : ∀ a, ρ (ρ a) = a := fun a => (hB a).choose_spec.2.2 (ρ (ρ a)) (hρconj (ρ a))
  -- the involution preserves `n`: `n (ρ a) = n a` (conjugation fixes the real integer).
  have hnρ : ∀ a, n (ρ a) = n a := by
    intro a
    have hc := congrArg (fun f : ClassFunction G ℂ => (f : G → ℂ) g) (hρconj a)
    simp only [ClassFunction.mapRingEquiv_apply] at hc
    rw [hn a, hn (ρ a), map_intCast] at hc
    exact_mod_cast hc.symm
  -- `n 0 = 1` (the principal value `ω_{00}^σ = 1_G`).
  have hn0 : n 0 = 1 := by
    have h00 := hyp.alignedOmegaSigmaGrid_zero_zero hG hG.odd
    have := hn 0
    rw [h00, trivialClassFunction_apply] at this
    exact_mod_cast this.symm
  -- off-principal terms sum to an even integer (fixed-point-free involution on `univ ∖ {0}`).
  have heven : (2 : ℤ) ∣ ∑ i ∈ Finset.univ.erase (0 : Fin hyp.w1), n i := by
    have hz : ((∑ i ∈ Finset.univ.erase (0 : Fin hyp.w1), n i : ℤ) : ZMod 2) = 0 := by
      push_cast
      refine Finset.sum_involution (fun a _ => ρ a) ?_ ?_ ?_ ?_
      · intro a _
        rw [hnρ a]; exact CharTwo.add_self_eq_zero _
      · intro a ha _ hcontra
        exact (Finset.mem_erase.mp ha).1 ((hρfix a).mp hcontra)
      · intro a ha
        rw [Finset.mem_erase] at ha ⊢
        refine ⟨fun hcontra => ha.1 ?_, Finset.mem_univ _⟩
        have hca : ρ a = 0 := hcontra
        calc a = ρ (ρ a) := (hρinv a).symm
          _ = ρ 0 := by rw [hca]
          _ = 0 := (hρfix 0).mpr rfl
      · intro a _; exact hρinv a
    exact_mod_cast (ZMod.intCast_zmod_eq_zero_iff_dvd _ 2).mp hz
  -- `∑ n i = n 0 + (even) = 1 + even` is odd.
  have hsplit : (∑ i : Fin hyp.w1, n i)
      = n 0 + ∑ i ∈ Finset.univ.erase (0 : Fin hyp.w1), n i :=
    (Finset.add_sum_erase Finset.univ n (Finset.mem_univ 0)).symm
  rw [hsplit, hn0]
  rcases heven with ⟨c, hc⟩
  exact ⟨c, by rw [hc]; ring⟩

open scoped FiniteInduce in
/-- **Peterfalvi (10.6)**: the sums of `omega_ij^sigma` describe the `tau1`
images, and outside the tame support the value of `zeta^tau1` has norm at least
one.

Conjunct (a) (the summed isometry) is the genuine `muColumn_tau1_pin` (the §10 specialisation of
(5.8)). Conjunct (b) (the (10.6)(b) parity bound) is now genuine and proven: off
`Ã(M) = dadeSupport`,
at `g` of order prime to `w₁`, `ζ^{τ₁}(g)` is an **odd integer** (`zeta_tau1_norm_ge_one`), hence
`|ζ^{τ₁}(g)| ≥ 1` — replacing the former opaque `zeta_tau1_norm_bound` placeholder field.  The
(10.3)/(10.5) carrier pins (`hmu`/`hos`/`hzS`/`hz1`/`hzconj`/`hδpm`/`hδj`) are discharged by the
constructed `params` (`w2_prime_and_parameter_independence`). -/
theorem tau1_values_and_norm_bound [Finite G]
    (hG : OddOrder.BG.IsMinimalSimpleOdd G) {M : Subgroup G}
    {hyp : Hypothesis M} {params : CharacterParameters hyp}
    (coh : CoherentHypothesis hyp params)
    (hmu : params.mu = hyp.muGrid hG hG.odd)
    (hos : params.omegaSigma = hyp.alignedOmegaSigmaGrid hG hG.odd)
    (hzS : params.zeta ∈ inducedFamily M) (hz1 : params.zeta 1 = (hyp.w1 : ℂ))
    (hzconj : params.zeta.conj ≠ params.zeta)
    (hδpm : params.delta = 1 ∨ params.delta = -1)
    (hδj : ∀ j : Fin hyp.w2, j ≠ 0 → hyp.muColumnSign hG hG.odd j = params.delta) :
    (∀ (j : Fin hyp.w2), j ≠ 0 →
        coh.tau1 (∑ i : Fin hyp.w1, params.mu i j) =
          (params.delta : ℂ) • ∑ i : Fin hyp.w1, params.omegaSigma i j) ∧
      (∀ (g : G), g ∉ hyp.dadeData.dade.dadeSupport → (orderOf g).Coprime hyp.w1 →
          ∃ m : ℤ, coh.tau1 params.zeta g = (m : ℂ) ∧ Odd m) := by
  have hd1 : ∀ jj : Fin hyp.w2, jj ≠ 0 → hyp.muGrid hG hG.odd 0 jj 1 ≠ 1 := by
    intro jj hjj
    rw [← hmu, params.degree_independent 0 jj hjj]
    exact_mod_cast (by have := params.d_gt_one; omega : params.d ≠ 1)
  refine ⟨fun j hj0 => ?_, ?_⟩
  · -- (10.6)(a): the summed isometry `μ_j^{τ₁} = δ·∑_i ω_{ij}^σ`.
    rw [hmu, hos]
    exact hyp.muColumn_tau1_pin hG coh hmu hos hzS hz1 hzconj hδpm hδj hd1 hj0
  · -- (10.6)(b): off `Ã(M)`, at `g` of order prime to `w₁`, `ζ^{τ₁}(g)` is an odd integer
    -- (`zeta_tau1_norm_ge_one`); in particular `|ζ^{τ₁}(g)| ≥ 1`.
    intro g hg hgord
    exact hyp.zeta_tau1_norm_ge_one hG coh hmu hos hzS hz1 hzconj hδpm hδj hg hgord

end OddOrder.Peterfalvi.S12
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/Peterfalvi/S12_MaximalIII_IV_V_Core/DadeCalculations.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