Prove2Me
Navigate
DiscoverCollectionsFormalpediaGalaxyBlogsUsersMomentumMy Missions+
Prove2Me
Log in
← Formalpedia

Peterfalvi (9.11): coherence, setup layer

Definition
OddOrder_Peterfalvi_S11_NineElevenSetup

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

feit-thompsonfinite-groupsgroup-theoryishida-odd-order

The setup layer of the Peterfalvi (9.11) coherence argument, introducing the generic single-factor centralizer CU(Hj)C_U(H_j)CU​(Hj​).

Main declarations: cuSubOf (The generic single-factor centralizer C_U(H_j)); card_cuSubOf_eq_card_ker (|C_U(H_j)| = |ker(aInvariantRestrictAut H_j)| (mirrors card_cuSub_eq_card_ker)); cuInHuPair (The realized two-summand centralizer C_U(H_i) ∩ C_U(H_j) inside HU); cuInHuPair_le_uInHu (C_U(H_i) ∩ C_U(H_j) ≤ U realized inside HU (mirrors cuInHu_le_uInHu)).

The bundle also proves 15 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/Peterfalvi/S11_NineElevenSetup.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_S11_SingleFactorCentralizer

namespace OddOrder.Peterfalvi.S11

open OddOrder.RepresentationTheory

open OddOrder.Isaacs.Ch03.IsAInvariant (quotientMulAutHom)

open scoped Pointwise

variable {G : Type*} [Group G]

section NineElevenTwoInertia

open OddOrder.Isaacs.Ch03 (IsAInvariant isAInvariant_iff_smul_mem)

variable [Finite G] {M : Subgroup G}

/-- **The generic single-factor centralizer `C_U(H_j)`** for an arbitrary Clifford summand
`H_j = caseA.Hpart j`, realized as a subgroup of `G` with `C_U(H_j) ≤ U`.  Mirror of `cuSub`
(which is `C_U(S₀)` for the distinguished generator): the kernel of the restricted `U`-action
`aInvariantRestrictAut (caseA.Hpart_aInvariant j)` on the order-`p` factor `H_j`, pushed into `G`
along `↥(U.subgroupOf (U ⊔ W₁)) ↪ ↥(U ⊔ W₁) ↪ G`.  By orbit symmetry `[U : C_U(H_j)] = a`
(`relIndex_cuSubOf_U_eq_a`), the same index as `C_U(S₀)`. -/
noncomputable def cuSubOf {data : TypesIIIIIIVSetup M} {chief : ChiefFactorData data}
    {chars : Section11CharacterData data chief} (caseA : CliffordCaseAData chars)
    (j : Fin data.q) : Subgroup G :=
  ((aInvariantRestrictAut (caseA.Hpart_aInvariant j)).ker.map
      (data.typeP.U.subgroupOf (data.typeP.U ⊔ data.typeP.W1)).subtype).map
    (data.typeP.U ⊔ data.typeP.W1).subtype

omit [Finite G] in
theorem cuSubOf_le_U {data : TypesIIIIIIVSetup M} {chief : ChiefFactorData data}
    {chars : Section11CharacterData data chief} (caseA : CliffordCaseAData chars)
    (j : Fin data.q) : cuSubOf caseA j ≤ data.U :=
  (Subgroup.map_mono (Subgroup.map_subtype_le _)).trans <| by
    rw [Subgroup.subgroupOf_map_subtype]; exact inf_le_left

omit [Finite G] in
/-- `|C_U(H_j)| = |ker(aInvariantRestrictAut H_j)|` (mirrors `card_cuSub_eq_card_ker`). -/
theorem card_cuSubOf_eq_card_ker {data : TypesIIIIIIVSetup M} {chief : ChiefFactorData data}
    {chars : Section11CharacterData data chief} (caseA : CliffordCaseAData chars)
    (j : Fin data.q) :
    Nat.card ↥(cuSubOf caseA j)
      = Nat.card ↥(aInvariantRestrictAut (caseA.Hpart_aInvariant j)).ker := by
  change Nat.card ↥(((aInvariantRestrictAut (caseA.Hpart_aInvariant j)).ker.map
      (data.typeP.U.subgroupOf (data.typeP.U ⊔ data.typeP.W1)).subtype).map
        (data.typeP.U ⊔ data.typeP.W1).subtype)
      = Nat.card ↥(aInvariantRestrictAut (caseA.Hpart_aInvariant j)).ker
  rw [← Nat.card_congr (Subgroup.equivMapOfInjective _ _ (Subgroup.subtype_injective _)).toEquiv,
    ← Nat.card_congr (Subgroup.equivMapOfInjective _ _ (Subgroup.subtype_injective _)).toEquiv]

/-- **`ker(uActionHom) ≤ ker(aInvariantRestrictAut H_j)`**: an element acting trivially on the
whole chief factor acts trivially on the summand `H_j` (mirrors
`ker_uActionHom_le_ker_aInvariantRestrictAut` for `S₀`, via
`centralizes_all_imp_centralizes_summand`). -/
theorem ker_uActionHom_le_ker_Hpart {data : TypesIIIIIIVSetup M} {chief : ChiefFactorData data}
    {chars : Section11CharacterData data chief} (caseA : CliffordCaseAData chars)
    (j : Fin data.q) :
    (uActionHom data chief).ker ≤ (aInvariantRestrictAut (caseA.Hpart_aInvariant j)).ker := by
  intro g hg
  rw [MonoidHom.mem_ker] at hg ⊢
  exact centralizes_all_imp_centralizes_summand caseA j g hg

/-- **`C = C_U(H̄) ≤ C_U(H_j)`** (`cSub ≤ cuSubOf`, mirrors `cSub_le_cuSub`). -/
theorem cSub_le_cuSubOf {data : TypesIIIIIIVSetup M} {chief : ChiefFactorData data}
    {chars : Section11CharacterData data chief} (caseA : CliffordCaseAData chars)
    (j : Fin data.q) : cSub data chief ≤ cuSubOf caseA j :=
  Subgroup.map_mono (Subgroup.map_mono (ker_uActionHom_le_ker_Hpart caseA j))

/-- **Orbit symmetry of the Clifford index `a`.**  For *any* summand `H_j = caseA.Hpart j` the
order of the `U`-action image on `H_j` equals `caseA.a` (`= |Ū₁|`, the image on the distinguished
generator `S₀`).  Since `H_j = φ(orbitRep j) • S₀` is the automorphic image of `S₀` under
`w = φ(orbitRep j)`, conjugation `σ = conjNormal w⁻¹` (well-defined on the acting group because
`U ◁ U W₁` is the Frobenius kernel, `W1_normalizes_U`) is an automorphism of the acting `U`-group
carrying `ker(restrict on S₀)` to `ker(restrict on H_j)`; equal kernels force equal ranges (first
isomorphism `|U| = |range|·|ker|` on both).  This is the crux behind `[U : C_U(H_j)] = a` for a
general summand (`relIndex_cuSubOf_U_eq_a`). -/
theorem caseA_a_eq_card_Hpart_restrictAut_range {data : TypesIIIIIIVSetup M}
    {chief : ChiefFactorData data} {chars : Section11CharacterData data chief}
    (caseA : CliffordCaseAData chars) (j : Fin data.q) :
    caseA.a = Nat.card ↥(aInvariantRestrictAut (caseA.Hpart_aInvariant j)).range := by
  classical
  set L := data.typeP.U ⊔ data.typeP.W1 with hL
  -- `U ◁ L` (Frobenius kernel), so conjugation by `L`-elements permutes the acting group `U`.
  have hAnorm : (data.typeP.U.subgroupOf L).Normal :=
    (Subgroup.normal_subgroupOf_iff_le_normalizer le_sup_left).mpr
      (sup_le Subgroup.le_normalizer data.typeP.W1_normalizes_U)
  set wt : ↥L := caseA.orbitRep j with hwt
  set w : MulAut (↥data.H ⧸ chief.N) := quotientMulAutHom chief.N_aInvariant wt with hw
  set σ : MulAut ↥(data.typeP.U.subgroupOf L) := MulAut.conjNormal (wt⁻¹) with hσ
  have hHj : caseA.Hpart j = w • caseA.S0 := caseA.Hpart_orbit j
  -- Pointwise-fix characterisation of `restrict … = 1`.
  have hchar : ∀ (S : Subgroup (↥data.H ⧸ chief.N))
      (hS : IsAInvariant (uActionHom data chief) S)
      (a : ↥(data.typeP.U.subgroupOf L)),
      aInvariantRestrictAut hS a = 1 ↔ ∀ y ∈ S, (uActionHom data chief) a y = y := by
    intro S hS a
    constructor
    · intro h y hy
      have hcoe := aInvariantRestrictAut_coe hS a ⟨y, hy⟩
      rw [h] at hcoe
      simpa [MulAut.one_apply] using hcoe.symm
    · intro h
      ext z
      rw [MulAut.one_apply, aInvariantRestrictAut_coe]
      exact h _ z.2
  -- `σ`-conjugation of the action: `φ(σ a) x = w⁻¹ (φ a (w x))`.
  have hσφ : ∀ (a : ↥(data.typeP.U.subgroupOf L)) (x : ↥data.H ⧸ chief.N),
      (uActionHom data chief) (σ a) x = w⁻¹ ((uActionHom data chief) a (w x)) := by
    intro a x
    have hval : ((σ a : ↥(data.typeP.U.subgroupOf L)) : ↥L) = wt⁻¹ * (a : ↥L) * wt := by
      rw [hσ, MulAut.conjNormal_apply, inv_inv]
    have h1 : (uActionHom data chief) (σ a)
        = quotientMulAutHom chief.N_aInvariant
            ((σ a : ↥(data.typeP.U.subgroupOf L)) : ↥L) := rfl
    rw [h1, hval, map_mul, map_mul, map_inv, MulAut.mul_apply, MulAut.mul_apply]
    rfl
  -- Kernel correspondence `ker(H_j) = ker(S₀).comap σ`.
  have hker : (aInvariantRestrictAut (caseA.Hpart_aInvariant j)).ker
      = (aInvariantRestrictAut caseA.S0_aInvariant).ker.comap σ.toMonoidHom := by
    ext a
    rw [MonoidHom.mem_ker, Subgroup.mem_comap, MonoidHom.mem_ker, MulEquiv.coe_toMonoidHom,
      hchar (caseA.Hpart j) (caseA.Hpart_aInvariant j) a,
      hchar caseA.S0 caseA.S0_aInvariant (σ a)]
    constructor
    · intro h x hx
      rw [hσφ a x]
      have hxHj : w x ∈ caseA.Hpart j := by
        rw [hHj, ← MulAut.smul_def]
        exact Subgroup.smul_mem_pointwise_smul_iff.mpr hx
      rw [h (w x) hxHj, ← MulAut.mul_apply, inv_mul_cancel, MulAut.one_apply]
    · intro h y hy
      rw [hHj] at hy
      have hx : w⁻¹ • y ∈ caseA.S0 := Subgroup.mem_pointwise_smul_iff_inv_smul_mem.mp hy
      have hfix := h (w⁻¹ • y) hx
      rw [hσφ a (w⁻¹ • y), MulAut.smul_def] at hfix
      have hww : w (w⁻¹ y) = y := by rw [← MulAut.mul_apply, mul_inv_cancel, MulAut.one_apply]
      rw [hww] at hfix
      exact w⁻¹.injective hfix
  -- Equal kernel cardinalities (conjugation `σ` is a bijection).
  have hkercard : Nat.card ↥(aInvariantRestrictAut (caseA.Hpart_aInvariant j)).ker
      = Nat.card ↥(aInvariantRestrictAut caseA.S0_aInvariant).ker := by
    rw [hker, Subgroup.comap_equiv_eq_map_symm']
    exact (Nat.card_congr (Subgroup.equivMapOfInjective _ σ.symm.toMonoidHom
      σ.symm.injective).toEquiv).symm
  -- Equal range cardinalities via the first isomorphism `|U| = |range|·|ker|`.
  have h0 := Subgroup.card_eq_card_quotient_mul_card_subgroup
    (aInvariantRestrictAut caseA.S0_aInvariant).ker
  have hj := Subgroup.card_eq_card_quotient_mul_card_subgroup
    (aInvariantRestrictAut (caseA.Hpart_aInvariant j)).ker
  rw [Nat.card_congr (QuotientGroup.quotientKerEquivRange
    (aInvariantRestrictAut caseA.S0_aInvariant)).toEquiv] at h0
  rw [Nat.card_congr (QuotientGroup.quotientKerEquivRange
    (aInvariantRestrictAut (caseA.Hpart_aInvariant j))).toEquiv] at hj
  rw [caseA.a_eq_card_restrictAut_range]
  have hcancel := h0.symm.trans hj
  rw [hkercard] at hcancel
  exact Nat.eq_of_mul_eq_mul_right Nat.card_pos hcancel

/-- **`|U| = a · |C_U(H_j)|`** for an arbitrary summand (mirrors `card_U_eq_a_mul_card_cuSub`), via
orbit symmetry `a = |range(aInvariantRestrictAut H_j)|` (`caseA_a_eq_card_Hpart_restrictAut_range`)
and the first isomorphism theorem. -/
theorem card_U_eq_a_mul_card_cuSubOf {data : TypesIIIIIIVSetup M} {chief : ChiefFactorData data}
    {chars : Section11CharacterData data chief} (caseA : CliffordCaseAData chars)
    (j : Fin data.q) :
    Nat.card ↥data.U = caseA.a * Nat.card ↥(cuSubOf caseA j) := by
  rw [caseA_a_eq_card_Hpart_restrictAut_range caseA j]
  have h := Subgroup.card_eq_card_quotient_mul_card_subgroup
    (aInvariantRestrictAut (caseA.Hpart_aInvariant j)).ker
  rw [Nat.card_congr (QuotientGroup.quotientKerEquivRange
      (aInvariantRestrictAut (caseA.Hpart_aInvariant j))).toEquiv,
    ← card_cuSubOf_eq_card_ker caseA j,
    Nat.card_congr (Subgroup.subgroupOfEquivOfLe
      (le_sup_left : data.typeP.U ≤ data.typeP.U ⊔ data.typeP.W1)).toEquiv] at h
  exact h

/-- **`[U : C_U(H_j)] = a`** for an arbitrary Clifford summand `H_j` (mirrors
`relIndex_cuSub_U_eq_a` for `S₀`): Lagrange `[U:C_U(H_j)]·|C_U(H_j)| = |U| = a·|C_U(H_j)|`
(`card_U_eq_a_mul_card_cuSubOf`), cancelling `|C_U(H_j)| > 0`.  The orbit-symmetric per-summand
inertia index behind Peterfalvi (9.11.2). -/
theorem relIndex_cuSubOf_U_eq_a {data : TypesIIIIIIVSetup M} {chief : ChiefFactorData data}
    {chars : Section11CharacterData data chief} (caseA : CliffordCaseAData chars)
    (j : Fin data.q) :
    (cuSubOf caseA j).relIndex data.U = caseA.a := by
  have h1 : (cuSubOf caseA j).relIndex data.U * Nat.card ↥(cuSubOf caseA j)
      = Nat.card ↥data.U := by
    have h := Subgroup.index_mul_card ((cuSubOf caseA j).subgroupOf data.U)
    rwa [Nat.card_congr (Subgroup.subgroupOfEquivOfLe (cuSubOf_le_U caseA j)).toEquiv] at h
  exact Nat.eq_of_mul_eq_mul_right Nat.card_pos
    (h1.trans (card_U_eq_a_mul_card_cuSubOf caseA j))

/-- **The realized two-summand centralizer `C_U(H_i) ∩ C_U(H_j)` inside `HU`**, as a subgroup of
`↥(huSub data)` (mirrors `cuInHu` for the single generator `S₀`, but with the *pair* intersection
`cuSubOf i ⊓ cuSubOf j` of the two single-factor centralizers). -/
noncomputable def cuInHuPair {data : TypesIIIIIIVSetup M} {chief : ChiefFactorData data}
    {chars : Section11CharacterData data chief} (caseA : CliffordCaseAData chars)
    (i j : Fin data.q) : Subgroup ↥(huSub data) :=
  ((cuSubOf caseA i ⊓ cuSubOf caseA j).subgroupOf M).subgroupOf (huSub data)

omit [Finite G] in
/-- `C_U(H_i) ∩ C_U(H_j) ≤ U` realized inside `HU` (mirrors `cuInHu_le_uInHu`). -/
theorem cuInHuPair_le_uInHu {data : TypesIIIIIIVSetup M} {chief : ChiefFactorData data}
    {chars : Section11CharacterData data chief} (caseA : CliffordCaseAData chars)
    (i j : Fin data.q) : cuInHuPair caseA i j ≤ uInHu data :=
  Subgroup.subgroupOf_mono _ (Subgroup.subgroupOf_mono _
    (inf_le_left.trans (cuSubOf_le_U caseA i)))

/-- **Realization bridge**: a `U`-element `a` whose realized `G`-image lies in `cuSubOf caseA k`
acts trivially on the summand `H_k` (`a ∈ ker(aInvariantRestrictAut (Hpart_aInvariant k))`).  The
reverse of the membership-building in `inertia_inf_uInHu_le_cuInHu`: `cuSubOf` is the double
`subtype`-image of the kernel, and the double `subtype` is injective, so the extracted kernel
witness equals `a`. -/
theorem mem_ker_of_realized_mem_cuSubOf {data : TypesIIIIIIVSetup M} {chief : ChiefFactorData data}
    {chars : Section11CharacterData data chief} (caseA : CliffordCaseAData chars) (k : Fin data.q)
    (a : ↥(typeP_quotientCoprimeAction data.typeP data.nontrivial.1 chief.N_aInvariant).U)
    (h : (((typeP_quotientCoprimeAction data.typeP data.nontrivial.1
          chief.N_aInvariant).U.subtype a : ↥(data.typeP.U ⊔ data.typeP.W1)) : G)
        ∈ cuSubOf caseA k) :
    a ∈ (aInvariantRestrictAut (caseA.Hpart_aInvariant k)).ker := by
  simp only [cuSubOf, Subgroup.mem_map] at h
  obtain ⟨w, ⟨b, hb_ker, hb_w⟩, hw⟩ := h
  have hba : b = a := by
    apply Subgroup.subtype_injective (data.typeP.U.subgroupOf (data.typeP.U ⊔ data.typeP.W1))
    apply Subgroup.subtype_injective (data.typeP.U ⊔ data.typeP.W1)
    rw [hb_w]; exact hw
  rwa [hba] at hb_ker

/-- **(9.11.2) `⊆` half at the `HU`-inertia level: `I(θ₀) ⊓ U ≤ C_U(H_i) ∩ C_U(H_j)`.**  For the
inflation `θ₀` of a chief-factor character `θbar` regular on the two Clifford summands `H_i`, `H_j`,
a realized `U`-element `g` in the `HU`-inertia of `θ₀` lies in the realized two-summand centralizer
`cuInHuPair`.  Realizes `g` as an abstract `U`-element `a`, unwraps the `conjBy`-fixing to the
`compHom (typeP_conjAction)` form (`conjBy_compHom_hInHuEquivH` + the injective inflation iso),
feeds it to the two-summand char-inertia core `caseA_hu_char_inertia_two_summands` (giving
`aInvariantRestrictAut … a = 1` on both summands), and builds the intersection membership from the
two kernel witnesses.  Mirrors the single-factor `inertia_inf_uInHu_le_cuInHu`. -/
theorem inertia_inf_uInHu_le_cuInHuPair {data : TypesIIIIIIVSetup M} {chief : ChiefFactorData data}
    {chars : Section11CharacterData data chief} (caseA : CliffordCaseAData chars) {i j : Fin data.q}
    {θbar : IrreducibleCharacter (↥data.H ⧸ chief.N)}
    (hregi : ∃ x ∈ caseA.Hpart i, (θbar : ClassFunction (↥data.H ⧸ chief.N) ℂ) x
      ≠ (θbar : ClassFunction (↥data.H ⧸ chief.N) ℂ) 1)
    (hregj : ∃ x ∈ caseA.Hpart j, (θbar : ClassFunction (↥data.H ⧸ chief.N) ℂ) x
      ≠ (θbar : ClassFunction (↥data.H ⧸ chief.N) ℂ) 1) :
    ClassFunction.inertia (G := ↥(huSub data)) (H := hInHu data)
        (ClassFunction.compHom (hInHuEquivH data).toMonoidHom
          (ClassFunction.compHom (QuotientGroup.mk' chief.N)
            (θbar : ClassFunction (↥data.H ⧸ chief.N) ℂ))) ⊓ uInHu data
      ≤ cuInHuPair caseA i j := by
  rintro g ⟨hgin, hgu⟩
  have hgU : ((g : ↥M) : G) ∈ data.typeP.U := by
    simp only [uInHu] at hgu; exact hgu
  have hgUW1 : ((g : ↥M) : G) ∈ data.typeP.U ⊔ data.typeP.W1 := Subgroup.mem_sup_left hgU
  set a : ↥(typeP_quotientCoprimeAction data.typeP data.nontrivial.1 chief.N_aInvariant).U :=
    ⟨⟨((g : ↥M) : G), hgUW1⟩, Subgroup.mem_subgroupOf.mpr hgU⟩ with ha_def
  have hag : ((g : ↥M) : G)
      = (((typeP_quotientCoprimeAction data.typeP data.nontrivial.1
          chief.N_aInvariant).U.subtype a : ↥(data.typeP.U ⊔ data.typeP.W1)) : G) := rfl
  have hfix := ClassFunction.mem_inertia.mp hgin
  rw [conjBy_compHom_hInHuEquivH data
    ((typeP_quotientCoprimeAction data.typeP data.nontrivial.1 chief.N_aInvariant).U.subtype a)
    g hag] at hfix
  have hfix1 := ClassFunction.compHom_injective_of_surjective (hInHuEquivH data).surjective hfix
  obtain ⟨hi, hj⟩ := caseA_hu_char_inertia_two_summands caseA hregi hregj a hfix1
  have hkeri : a ∈ (aInvariantRestrictAut (caseA.Hpart_aInvariant i)).ker :=
    MonoidHom.mem_ker.mpr hi
  have hkerj : a ∈ (aInvariantRestrictAut (caseA.Hpart_aInvariant j)).ker :=
    MonoidHom.mem_ker.mpr hj
  simp only [cuInHuPair, Subgroup.mem_subgroupOf, Subgroup.mem_inf, cuSubOf, Subgroup.mem_map]
  exact ⟨⟨_, ⟨a, hkeri, rfl⟩, rfl⟩, ⟨_, ⟨a, hkerj, rfl⟩, rfl⟩⟩

/-- **(9.11.2) `⊇` half at the `HU`-inertia level: `C_U(H_i) ∩ C_U(H_j) ≤ I(θ₀)`.**  For the
inflation `θ₀` of `θbar = linearIrreducibleCharacter χ` with `χ` a two-summand-supported
linear character (trivial off `i`, `j`, `hsupp`), the realized two-summand centralizer
`cuInHuPair` fixes `θ₀`.  A `cuInHuPair`-element `c` realizes an abstract `U`-element `a`
centralizing both summands (`aInvariantRestrictAut … a = 1` on `i` and `j`, via
`mem_ker_of_realized_mem_cuSubOf`), so `caseA_centralizes_two_summands_compHom_eq` gives
`compHom (uActionHom a) θbar = θbar`; inflating (`conjBy_compHom_hInHuEquivH` +
`compHom_typeP_conjAction_inflation`) then fixes `θ₀`.  Mirrors `cInHu_le_inertia`, replacing
`quotientMulAutHom w = 1` with the two-summand char-fixing. -/
theorem cuInHuPair_le_inertia {data : TypesIIIIIIVSetup M} {chief : ChiefFactorData data}
    {chars : Section11CharacterData data chief} (caseA : CliffordCaseAData chars) {i j : Fin data.q}
    (χ : (↥data.H ⧸ chief.N) →* ℂˣ)
    (hsupp : ∀ k, k ≠ i → k ≠ j → ∀ x ∈ caseA.Hpart k, χ x = 1) :
    cuInHuPair caseA i j ≤ ClassFunction.inertia (G := ↥(huSub data)) (H := hInHu data)
        (ClassFunction.compHom (hInHuEquivH data).toMonoidHom
          (ClassFunction.compHom (QuotientGroup.mk' chief.N)
            (linearIrreducibleCharacter χ : ClassFunction (↥data.H ⧸ chief.N) ℂ))) := by
  intro c hc
  rw [ClassFunction.mem_inertia]
  have hcinf : ((c : ↥M) : G) ∈ cuSubOf caseA i ⊓ cuSubOf caseA j := by
    simpa only [cuInHuPair, Subgroup.mem_subgroupOf] using hc
  have hgU : ((c : ↥M) : G) ∈ data.typeP.U := cuSubOf_le_U caseA i hcinf.1
  have hgUW1 : ((c : ↥M) : G) ∈ data.typeP.U ⊔ data.typeP.W1 := Subgroup.mem_sup_left hgU
  set a : ↥(typeP_quotientCoprimeAction data.typeP data.nontrivial.1 chief.N_aInvariant).U :=
    ⟨⟨((c : ↥M) : G), hgUW1⟩, Subgroup.mem_subgroupOf.mpr hgU⟩ with ha_def
  have hag : ((c : ↥M) : G)
      = (((typeP_quotientCoprimeAction data.typeP data.nontrivial.1
          chief.N_aInvariant).U.subtype a : ↥(data.typeP.U ⊔ data.typeP.W1)) : G) := rfl
  have hgi : aInvariantRestrictAut (caseA.Hpart_aInvariant i) a = 1 :=
    MonoidHom.mem_ker.mp (mem_ker_of_realized_mem_cuSubOf caseA i a (hag ▸ hcinf.1))
  have hgj : aInvariantRestrictAut (caseA.Hpart_aInvariant j) a = 1 :=
    MonoidHom.mem_ker.mp (mem_ker_of_realized_mem_cuSubOf caseA j a (hag ▸ hcinf.2))
  have hchar : ClassFunction.compHom (quotientMulAutHom chief.N_aInvariant
        ((typeP_quotientCoprimeAction data.typeP data.nontrivial.1
          chief.N_aInvariant).U.subtype a)).toMonoidHom
        (linearIrreducibleCharacter χ : ClassFunction (↥data.H ⧸ chief.N) ℂ)
      = (linearIrreducibleCharacter χ : ClassFunction (↥data.H ⧸ chief.N) ℂ) :=
    caseA_centralizes_two_summands_compHom_eq caseA χ hsupp a hgi hgj
  rw [conjBy_compHom_hInHuEquivH data
      ((typeP_quotientCoprimeAction data.typeP data.nontrivial.1 chief.N_aInvariant).U.subtype a)
      c hag, compHom_typeP_conjAction_inflation, hchar]

/-- **(9.11.2) the `HU`-inertia identity `I(θ₀) = H·(C_U(H_i) ∩ C_U(H_j))`.**  Combining the two
containments (`inertia_inf_uInHu_le_cuInHuPair` for `⊆`, `cuInHuPair_le_inertia` for `⊇`) with
`H ≤ I(θ₀)` (`subgroup_le_inertia`) identifies the `HU`-inertia of the inflated two-summand
character `θ₀` as `hInHu ⊔ cuInHuPair`.  This is the realized `HU`-level lift of Peterfalvi
(9.11.2)'s inertia `I(θ₀) = H·(U₁ ∩ U₁ʷ)`; its index in `HU` is `[U : U₁ ∩ U₁ʷ]` (the
two-summand inertia index).  Mirrors `inertia_eq_hcInHu_of_inf_le` /
`inertia_eq_hcuInHu_of_easy_le`. -/
theorem caseA_inertia_eq_hcuInHuPair {data : TypesIIIIIIVSetup M} {chief : ChiefFactorData data}
    {chars : Section11CharacterData data chief} (caseA : CliffordCaseAData chars) {i j : Fin data.q}
    (χ : (↥data.H ⧸ chief.N) →* ℂˣ)
    (hsupp : ∀ k, k ≠ i → k ≠ j → ∀ x ∈ caseA.Hpart k, χ x = 1)
    (hregi : ∃ x ∈ caseA.Hpart i,
      (linearIrreducibleCharacter χ : ClassFunction (↥data.H ⧸ chief.N) ℂ) x
        ≠ (linearIrreducibleCharacter χ : ClassFunction (↥data.H ⧸ chief.N) ℂ) 1)
    (hregj : ∃ x ∈ caseA.Hpart j,
      (linearIrreducibleCharacter χ : ClassFunction (↥data.H ⧸ chief.N) ℂ) x
        ≠ (linearIrreducibleCharacter χ : ClassFunction (↥data.H ⧸ chief.N) ℂ) 1) :
    ClassFunction.inertia (G := ↥(huSub data)) (H := hInHu data)
        (ClassFunction.compHom (hInHuEquivH data).toMonoidHom
          (ClassFunction.compHom (QuotientGroup.mk' chief.N)
            (linearIrreducibleCharacter χ : ClassFunction (↥data.H ⧸ chief.N) ℂ)))
      = hInHu data ⊔ cuInHuPair caseA i j := by
  set θ₀ := ClassFunction.compHom (hInHuEquivH data).toMonoidHom
    (ClassFunction.compHom (QuotientGroup.mk' chief.N)
      (linearIrreducibleCharacter χ : ClassFunction (↥data.H ⧸ chief.N) ℂ)) with hθ₀
  apply le_antisymm
  · intro g hg
    have hgtop : g ∈ hInHu data ⊔ uInHu data :=
      hInHu_sup_uInHu_eq_top data ▸ Subgroup.mem_top g
    rw [Subgroup.mem_sup_of_normal_left] at hgtop
    obtain ⟨h, hh, u, hu, rfl⟩ := hgtop
    have hh_in : h ∈ ClassFunction.inertia (H := hInHu data) θ₀ :=
      ClassFunction.subgroup_le_inertia θ₀ hh
    have hu_in : u ∈ ClassFunction.inertia (H := hInHu data) θ₀ := by
      have hmem : h⁻¹ * (h * u) ∈ ClassFunction.inertia (H := hInHu data) θ₀ :=
        mul_mem (inv_mem hh_in) hg
      rwa [inv_mul_cancel_left] at hmem
    exact mul_mem (Subgroup.mem_sup_left hh)
      (Subgroup.mem_sup_right (inertia_inf_uInHu_le_cuInHuPair caseA hregi hregj ⟨hu_in, hu⟩))
  · rw [sup_le_iff]
    exact ⟨ClassFunction.subgroup_le_inertia θ₀, cuInHuPair_le_inertia caseA χ hsupp⟩

omit [Finite G] in
open Subgroup in
/-- **`C_U(H_j) ◁ U`** for a general Clifford summand (mirrors `cuSub_subgroupOf_U_normal` for
`S₀`): the realization `cuSubOf j` is the `G`-image of the kernel `ker(aInvariantRestrictAut H_j)`,
so its `subgroupOf U` is normal (kernels are normal, transported by the realization iso
`↥(U.subgroupOf (U ⊔ W₁)) ≃* ↥U`). -/
theorem cuSubOf_subgroupOf_U_normal {data : TypesIIIIIIVSetup M} {chief : ChiefFactorData data}
    {chars : Section11CharacterData data chief} (caseA : CliffordCaseAData chars) (j : Fin data.q) :
    ((cuSubOf caseA j).subgroupOf data.U).Normal := by
  set e := subgroupOfEquivOfLe (le_sup_left : data.typeP.U ≤ data.typeP.U ⊔ data.typeP.W1) with he
  have heq : (cuSubOf caseA j).subgroupOf data.U
      = (aInvariantRestrictAut (caseA.Hpart_aInvariant j)).ker.map e.toMonoidHom := by
    ext x
    simp only [Subgroup.mem_subgroupOf]
    constructor
    · intro hx
      simp only [cuSubOf, Subgroup.mem_map] at hx
      obtain ⟨z, ⟨y, hy, hyz⟩, hzx⟩ := hx
      refine ⟨y, hy, ?_⟩
      apply Subtype.ext
      rw [MulEquiv.coe_toMonoidHom, he, subgroupOfEquivOfLe_apply_coe, ← hzx, ← hyz]
      rfl
    · rintro ⟨y, hy, rfl⟩
      simp only [cuSubOf, Subgroup.mem_map]
      refine ⟨_, ⟨y, hy, rfl⟩, ?_⟩
      rw [MulEquiv.coe_toMonoidHom, he, subgroupOfEquivOfLe_apply_coe]
      rfl
  rw [heq]
  exact (MonoidHom.normal_ker _).map e.toMonoidHom e.surjective

omit [Finite G] in
/-- **`C_U(H_i) ∩ C_U(H_j) ◁ U`** (the two-summand centralizer is normal in `U`): the intersection
of the two single-factor normal centralizers (`cuSubOf_subgroupOf_U_normal`), via `subgroupOf`
distributing over `⊓` (`Subgroup.comap_inf`) and `⊓` of normals being normal. -/
theorem cuSubOf_pair_subgroupOf_U_normal {data : TypesIIIIIIVSetup M} {chief : ChiefFactorData data}
    {chars : Section11CharacterData data chief} (caseA : CliffordCaseAData chars)
    (i j : Fin data.q) :
    ((cuSubOf caseA i ⊓ cuSubOf caseA j).subgroupOf data.U).Normal := by
  have hi := cuSubOf_subgroupOf_U_normal caseA i
  have hj := cuSubOf_subgroupOf_U_normal caseA j
  have hEq : (cuSubOf caseA i ⊓ cuSubOf caseA j).subgroupOf data.U
      = (cuSubOf caseA i).subgroupOf data.U ⊓ (cuSubOf caseA j).subgroupOf data.U := by
    simp only [Subgroup.subgroupOf, Subgroup.comap_inf]
  rw [hEq]
  refine ⟨fun n hn g => Subgroup.mem_inf.mpr ⟨?_, ?_⟩⟩
  · exact hi.conj_mem n (Subgroup.mem_inf.mp hn).1 g
  · exact hj.conj_mem n (Subgroup.mem_inf.mp hn).2 g

omit [Finite G] in
/-- `|C_U(H_i) ∩ C_U(H_j)|` realized inside `HU` equals its `G`-cardinality (mirrors
`card_cuInHu_eq`): the double `subgroupOf` realization is an injective image. -/
theorem card_cuInHuPair_eq {data : TypesIIIIIIVSetup M} {chief : ChiefFactorData data}
    {chars : Section11CharacterData data chief} (caseA : CliffordCaseAData chars)
    (i j : Fin data.q) :
    Nat.card ↥(cuInHuPair caseA i j) = Nat.card ↥(cuSubOf caseA i ⊓ cuSubOf caseA j) := by
  have hKleU : cuSubOf caseA i ⊓ cuSubOf caseA j ≤ data.U := inf_le_left.trans (cuSubOf_le_U caseA
      i)
  have hCsubM : (cuSubOf caseA i ⊓ cuSubOf caseA j).subgroupOf M ≤ huSub data :=
    Subgroup.subgroupOf_mono M (hKleU.trans (le_sup_right : data.U ≤ data.H ⊔ data.U))
  have hCleM : cuSubOf caseA i ⊓ cuSubOf caseA j ≤ M := hKleU.trans (U_le_M data)
  calc Nat.card ↥(cuInHuPair caseA i j)
      = Nat.card ↥((cuSubOf caseA i ⊓ cuSubOf caseA j).subgroupOf M) :=
        Nat.card_congr (Subgroup.subgroupOfEquivOfLe hCsubM).toEquiv
    _ = Nat.card ↥(cuSubOf caseA i ⊓ cuSubOf caseA j) :=
        Nat.card_congr (Subgroup.subgroupOfEquivOfLe hCleM).toEquiv

omit [Finite G] in
open Subgroup in
set_option backward.isDefEq.respectTransparency false in
/-- **`C_U(H_i) ∩ C_U(H_j) ◁ U` realized inside `HU`** (mirrors `cuInHu_normal`):
`cuInHuPair ◁ uInHu`, transported from `(cuSubOf i ⊓ cuSubOf j) ◁ U` along `↥uInHu ≃* ↥U`. -/
theorem cuInHuPair_normal {data : TypesIIIIIIVSetup M} {chief : ChiefFactorData data}
    {chars : Section11CharacterData data chief} (caseA : CliffordCaseAData chars)
    (i j : Fin data.q) :
    ((cuInHuPair caseA i j).subgroupOf (uInHu data)).Normal := by
  have hUsubM : data.U.subgroupOf M ≤ huSub data :=
    Subgroup.subgroupOf_mono M (le_sup_right : data.U ≤ data.H ⊔ data.U)
  set f : ↥(uInHu data) ≃* ↥data.U :=
    (subgroupOfEquivOfLe hUsubM).trans (subgroupOfEquivOfLe (U_le_M data)) with hf
  have hgval : ∀ x : ↥(uInHu data), ((f x : ↥data.U) : G) = (((x : ↥(huSub data)) : ↥M) : G) := by
    intro x
    have h1 : (f x : ↥data.U)
        = subgroupOfEquivOfLe (U_le_M data) (subgroupOfEquivOfLe hUsubM x) := by rw [hf]; rfl
    rw [h1, subgroupOfEquivOfLe_apply_coe, subgroupOfEquivOfLe_apply_coe]
  have hcomap : (cuInHuPair caseA i j).subgroupOf (uInHu data)
      = ((cuSubOf caseA i ⊓ cuSubOf caseA j).subgroupOf data.U).comap f.toMonoidHom := by
    ext x
    simp only [cuInHuPair, Subgroup.mem_subgroupOf]
    rw [Subgroup.mem_comap, Subgroup.mem_subgroupOf, MulEquiv.coe_toMonoidHom, hgval x]
  rw [hcomap]
  exact (cuSubOf_pair_subgroupOf_U_normal caseA i j).comap f.toMonoidHom

omit [Finite G] in
/-- **`H·(C_U(H_i) ∩ C_U(H_j)) ◁ HU`** (mirrors `hcuInHu_normal`): the (9.11.2) inertia subgroup is
normal.  From `H ◁ HU` (`hInHu_normal`), `C_U(H_i) ∩ C_U(H_j) ◁ U` (`cuInHuPair_normal`), and
`H ⊔ U = ⊤` (`hInHu_sup_uInHu_eq_top`) via `sup_normal_of_normal_left_of_normal_subgroupOf`. -/
theorem hcuInHuPair_normal {data : TypesIIIIIIVSetup M} {chief : ChiefFactorData data}
    {chars : Section11CharacterData data chief} (caseA : CliffordCaseAData chars)
    (i j : Fin data.q) :
    (hInHu data ⊔ cuInHuPair caseA i j).Normal :=
  haveI := hInHu_normal data
  haveI := cuInHuPair_normal caseA i j
  OddOrder.GroupTheory.sup_normal_of_normal_left_of_normal_subgroupOf
    (cuInHuPair_le_uInHu caseA i j) (hInHu_sup_uInHu_eq_top data)

/-- **`C = C_U(H̄) ≤ C_U(H_i) ∩ C_U(H_j)`** realized (`cInHu ≤ cuInHuPair`): centralizing the whole
chief factor implies centralizing each summand (`cSub_le_cuSubOf`), realized through the double
`subgroupOf`. -/
theorem cInHu_le_cuInHuPair {data : TypesIIIIIIVSetup M} {chief : ChiefFactorData data}
    {chars : Section11CharacterData data chief} (caseA : CliffordCaseAData chars)
    (i j : Fin data.q) : cInHu data chief ≤ cuInHuPair caseA i j :=
  Subgroup.subgroupOf_mono _ (Subgroup.subgroupOf_mono _
    (le_inf (cSub_le_cuSubOf caseA i) (cSub_le_cuSubOf caseA j)))

/-- **`U ⊓ H·(C_U(H_i) ∩ C_U(H_j)) = C_U(H_i) ∩ C_U(H_j)`** realized (mirrors
`uInHu_inf_hcuInHu_eq_cuInHu`), the second-iso input for `[HU : H·K] = [U : K]`.  The crux
`hInHu ⊓ uInHu ≤ cuInHuPair` factors through `H ⊓ U ≤ C` (`hInHu_inf_uInHu_le_cInHu`) and
`C ≤ K` (`cInHu_le_cuInHuPair`). -/
theorem uInHu_inf_hcuInHuPair_eq_cuInHuPair {data : TypesIIIIIIVSetup M}
    {chief : ChiefFactorData data} {chars : Section11CharacterData data chief}
    (caseA : CliffordCaseAData chars) (i j : Fin data.q) :
    uInHu data ⊓ (hInHu data ⊔ cuInHuPair caseA i j) = cuInHuPair caseA i j := by
  have := hInHu_normal data
  apply le_antisymm
  · rintro x ⟨hxU, hxHC⟩
    obtain ⟨hh, hhmem, cc, ccmem, rfl⟩ := Subgroup.mem_sup_of_normal_left.mp hxHC
    have hcc_u : cc ∈ uInHu data := cuInHuPair_le_uInHu caseA i j ccmem
    have hh_u : hh ∈ uInHu data := by
      have h1 : hh * cc * cc⁻¹ ∈ uInHu data :=
        (uInHu data).mul_mem hxU ((uInHu data).inv_mem hcc_u)
      rwa [mul_inv_cancel_right] at h1
    have hh_c : hh ∈ cuInHuPair caseA i j :=
      cInHu_le_cuInHuPair caseA i j
        (hInHu_inf_uInHu_le_cInHu data chief (Subgroup.mem_inf.mpr ⟨hhmem, hh_u⟩))
    exact (cuInHuPair caseA i j).mul_mem hh_c ccmem
  · exact le_inf (cuInHuPair_le_uInHu caseA i j) le_sup_right

/-- **Second-iso index step: `[HU : H·(C_U(H_i) ∩ C_U(H_j))] = [U : C_U(H_i) ∩ C_U(H_j)]`**
(realized `(hInHu ⊔ cuInHuPair).index = (cuInHuPair.subgroupOf uInHu).index`).  Mirrors
`index_hcuInHu_eq_relindex_cuInHu`: the second isomorphism theorem for `H·K ◁ HU` with
`uInHu ⊔ H·K = ⊤`, and `uInHu ⊓ H·K = K` (`uInHu_inf_hcuInHuPair_eq_cuInHuPair`). -/
theorem index_hcuInHuPair_eq_relindex_cuInHuPair {data : TypesIIIIIIVSetup M}
    {chief : ChiefFactorData data} {chars : Section11CharacterData data chief}
    (caseA : CliffordCaseAData chars) (i j : Fin data.q) :
    (hInHu data ⊔ cuInHuPair caseA i j).index
      = ((cuInHuPair caseA i j).subgroupOf (uInHu data)).index := by
  have : (hInHu data ⊔ cuInHuPair caseA i j).Normal := hcuInHuPair_normal caseA i j
  have htop : uInHu data ⊔ (hInHu data ⊔ cuInHuPair caseA i j) = ⊤ := by
    rw [← sup_assoc, sup_comm (uInHu data) (hInHu data), hInHu_sup_uInHu_eq_top, top_sup_eq]
  have he := Nat.card_congr (QuotientGroup.quotientInfEquivProdNormalQuotient
    (uInHu data) (hInHu data ⊔ cuInHuPair caseA i j)).toEquiv
  have hsub : (hInHu data ⊔ cuInHuPair caseA i j).subgroupOf (uInHu data)
      = (cuInHuPair caseA i j).subgroupOf (uInHu data) := by
    ext x
    simp only [Subgroup.mem_subgroupOf]
    constructor
    · intro hx
      have hxin : (x : ↥(huSub data))
          ∈ uInHu data ⊓ (hInHu data ⊔ cuInHuPair caseA i j) :=
        Subgroup.mem_inf.mpr ⟨x.2, hx⟩
      rw [uInHu_inf_hcuInHuPair_eq_cuInHuPair caseA i j] at hxin
      exact hxin
    · intro hx; exact Subgroup.mem_sup_right hx
  rw [hsub] at he
  have hsplit := Subgroup.card_eq_card_quotient_mul_card_subgroup
    ((hInHu data ⊔ cuInHuPair caseA i j).subgroupOf
      (uInHu data ⊔ (hInHu data ⊔ cuInHuPair caseA i j)))
  rw [Nat.card_congr (Subgroup.subgroupOfEquivOfLe (le_sup_right :
        (hInHu data ⊔ cuInHuPair caseA i j)
          ≤ uInHu data ⊔ (hInHu data ⊔ cuInHuPair caseA i j))).toEquiv,
    ← he, ← Subgroup.index_eq_card] at hsplit
  have htopcard : Nat.card ↥(uInHu data ⊔ (hInHu data ⊔ cuInHuPair caseA i j))
      = Nat.card ↥(huSub data) := by
    rw [htop]; exact Nat.card_congr Subgroup.topEquiv.toEquiv
  rw [htopcard] at hsplit
  have hmul := Subgroup.card_mul_index (hInHu data ⊔ cuInHuPair caseA i j)
  rw [hsplit, mul_comm (((cuInHuPair caseA i j).subgroupOf (uInHu data)).index)] at hmul
  exact Nat.eq_of_mul_eq_mul_left Nat.card_pos hmul

/-- **`[U : C_U(H_i) ∩ C_U(H_j)] = [uInHu : cuInHuPair]`** (realized index equals ambient-`G`
relative index).  Both sides multiply by `|C_U(H_i) ∩ C_U(H_j)|` to `|U|` (Lagrange in the `uInHu`
realization and in `U`), cancelling the positive common factor.  Mirrors the `relIndex_cSub_U_eq_u`
style. -/
theorem index_cuInHuPair_subgroupOf_uInHu_eq_relIndex {data : TypesIIIIIIVSetup M}
    {chief : ChiefFactorData data} {chars : Section11CharacterData data chief}
    (caseA : CliffordCaseAData chars) (i j : Fin data.q) :
    ((cuInHuPair caseA i j).subgroupOf (uInHu data)).index
      = (cuSubOf caseA i ⊓ cuSubOf caseA j).relIndex data.U := by
  have hI : Nat.card ↥(cuSubOf caseA i ⊓ cuSubOf caseA j)
      * ((cuInHuPair caseA i j).subgroupOf (uInHu data)).index = Nat.card ↥data.U := by
    have h := Subgroup.card_mul_index ((cuInHuPair caseA i j).subgroupOf (uInHu data))
    rw [Nat.card_congr (Subgroup.subgroupOfEquivOfLe (cuInHuPair_le_uInHu caseA i j)).toEquiv,
      card_cuInHuPair_eq caseA i j, card_uInHu_eq data] at h
    exact h
  have hII : Nat.card ↥(cuSubOf caseA i ⊓ cuSubOf caseA j)
      * (cuSubOf caseA i ⊓ cuSubOf caseA j).relIndex data.U = Nat.card ↥data.U := by
    have h := Subgroup.card_mul_index ((cuSubOf caseA i ⊓ cuSubOf caseA j).subgroupOf data.U)
    rwa [Nat.card_congr (Subgroup.subgroupOfEquivOfLe
      (inf_le_left.trans (cuSubOf_le_U caseA i))).toEquiv] at h
  exact Nat.eq_of_mul_eq_mul_left Nat.card_pos (hI.trans hII.symm)

end NineElevenTwoInertia

/-- **`[U : K₁ ⊓ K₂] ≤ [U:K₁]·[U:K₂]`** (relative-index form of `Subgroup.index_inf_le`): the
relative index `H.relIndex U = (H.subgroupOf U).index`, and `subgroupOf = comap` distributes over
`⊓` (`Subgroup.comap_inf`), so the ambient `index_inf_le` in `↥U` applies.  The (9.11.2) injectivity
`Ū ↪ (U/U₁)×(U/U₁ʷ)` in relative-index form. -/
theorem relIndex_inf_le {G : Type*} [Group G] {K₁ K₂ U : Subgroup G} :
    (K₁ ⊓ K₂).relIndex U ≤ K₁.relIndex U * K₂.relIndex U := by
  simp only [Subgroup.relIndex, Subgroup.subgroupOf, Subgroup.comap_inf]
  exact Subgroup.index_inf_le

/-- **Peterfalvi (9.11.2), the bound `u ≤ a²`.**  Book (9.11.2): *"The canonical mapping from `Ū` to
`(U/U₁)×(U/U₁ʷ)` is injective, and so `u ≤ a²`."*  Given the inertia identity `C = U₁ ⊓ U₁ʷ` (the
*first* assertion of (9.11.2), the deep character-theoretic input: `U₁ = C_U(H₁)`, `U₁ʷ = C_U(H₂)`,
their intersection is `C = C_U(H̄)`) and the per-summand index `[U:U₁] = [U:U₁ʷ] = a`, the relative
index `u = [U:C]` is bounded by `[U:U₁]·[U:U₁ʷ] = a²` (`relIndex_inf_le`).  Consumed by the (9.11.5)
polynomial bound (`nineElevenFive_refutation`'s `hua2`). -/
theorem nineElevenTwo_u_le_a_sq [Finite G] {M : Subgroup G} {data : TypesIIIIIIVSetup M}
    {chief : ChiefFactorData data} {chars : Section11CharacterData data chief}
    (caseA : CliffordCaseAData chars) {K₁ K₂ : Subgroup G}
    (hK₁ : K₁.relIndex data.U = caseA.a) (hK₂ : K₂.relIndex data.U = caseA.a)
    (hCinf : chars.C = K₁ ⊓ K₂) : chars.u ≤ caseA.a * caseA.a := by
  have hu : (K₁ ⊓ K₂).relIndex data.U = chars.u := by
    rw [← hCinf]; exact relIndex_cSub_U_eq_u chars
  rw [← hu]
  calc (K₁ ⊓ K₂).relIndex data.U ≤ K₁.relIndex data.U * K₂.relIndex data.U := relIndex_inf_le
    _ = caseA.a * caseA.a := by rw [hK₁, hK₂]

end OddOrder.Peterfalvi.S11
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/S11_NineElevenSetup.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