Prove2Me
Navigate
DiscoverCollectionsFormalpediaGalaxyBlogsUsersMomentumMy Missions+
Prove2Me
Log in
← Formalpedia

Peterfalvi (10.8): coherent-extension norm bounds for maximal types III, IV, V

Definition
OddOrder_Peterfalvi_S12_MaximalBasic

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

feit-thompsonfinite-groupsgroup-theoryishida-odd-order

Formalizes input estimates for Peterfalvi (10.8): norm and sum bounds for the coherent extension ζτ1\zeta^{\tau_1}ζτ1​ under Hypothesis (10.1).

Main declarations: Hypothesis.inner_tau1_zeta_self_eq_one (‖ζ^{τ₁}‖² = 1); Hypothesis.sum_zeta_tau1_normSq_ge_card (The (10.6.b)-summed bound for ζ^{τ₁}); Hypothesis.chiRhoNormSq_zeta_le_line83 (Peterfalvi (10.8), line 83); Hypothesis.mem_restricted_dadeSupport_of_coprime (Coprime-order elements of the full Dade support lie in the A(M)-restricted support).

The bundle also proves 11 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/S12_MaximalBasic.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_Section9Counts
import Definitions.Def_OddOrder_Peterfalvi_S12_TypeIIFrobenius
import Definitions.Def_OddOrder_Peterfalvi_S09_CertificateDischarge

namespace OddOrder.Peterfalvi.S12

open OddOrder.GroupTheory

open OddOrder.RepresentationTheory

open OddOrder.Isaacs

open scoped Pointwise

variable {G : Type*} [Group G]

/-- **Closing arithmetic contradiction of Peterfalvi (10.8)** — the numerical heart of the
non-coherence proof, isolated from the character machinery.

The structural facts derived (under the *coherence* assumption) for the Type-II partner `S` are:
* `w₁ ≥ 3` and the Frobenius bound `|U| ≥ 2w₂+1 ≥ 7` (since `UW₂` is Frobenius and `w₂ ≥ 3`);
* the lower bound `|M'| ≥ (2w₁+1)·w₂`, from `|M'/M''| ≥ 2w₁+1` (the odd Frobenius group
  `(M'/M'')⋊W₁`, Peterfalvi (8.4.d)) and `|M''| ≥ w₂`.

The `(7.5)`/`(7.8.b)`/`(10.6.b)` norm-counting estimate, after the `G₁ ⊆ (H#)^G ∪ V^G` bound,
yields `w₁w₂/|M'| > 1 − 1/w₁ − 1/|U|`.  Its right side exceeds `1 − 1/3 − 1/7 > 1/2`, forcing
`|M'| < 2w₁w₂`; this contradicts `|M'| ≥ (2w₁+1)w₂ = 2w₁w₂ + w₂`.  Pure arithmetic over `ℚ`. -/
theorem typeII_noncoherence_arithmetic
    {w₁ w₂ u Mp : ℕ} (hw1 : 3 ≤ w₁) (hu : 7 ≤ u) (hw2 : 1 ≤ w₂)
    (hMp : (2 * w₁ + 1) * w₂ ≤ Mp)
    (hbound : (1 : ℚ) - 1 / (w₁ : ℚ) - 1 / (u : ℚ) < (w₁ : ℚ) * (w₂ : ℚ) / (Mp : ℚ)) :
    False := by
  have hw1q : (3 : ℚ) ≤ (w₁ : ℚ) := by exact_mod_cast hw1
  have huq : (7 : ℚ) ≤ (u : ℚ) := by exact_mod_cast hu
  have hw2q : (1 : ℚ) ≤ (w₂ : ℚ) := by exact_mod_cast hw2
  have hMppos : 0 < Mp := lt_of_lt_of_le (Nat.mul_pos (by omega) (by omega)) hMp
  have hMpq : (0 : ℚ) < (Mp : ℚ) := by exact_mod_cast hMppos
  -- `1/w₁ ≤ 1/3` and `1/u ≤ 1/7`, so the coherence bound exceeds `1 − 1/3 − 1/7 > 1/2`.
  have h1 : 1 / (w₁ : ℚ) ≤ 1 / 3 := one_div_le_one_div_of_le (by norm_num) hw1q
  have h2 : 1 / (u : ℚ) ≤ 1 / 7 := one_div_le_one_div_of_le (by norm_num) huq
  have hhalf : (1 : ℚ) / 2 < (w₁ : ℚ) * (w₂ : ℚ) / (Mp : ℚ) := by
    have h112 : (1 : ℚ) - 1 / 3 - 1 / 7 > 1 / 2 := by norm_num
    linarith
  -- Clear the denominator: `Mp < 2·w₁w₂`.
  have hhalf' : (1 : ℚ) / 2 * (Mp : ℚ) < (w₁ : ℚ) * (w₂ : ℚ) := (lt_div_iff₀ hMpq).mp hhalf
  -- The lower bound `(2w₁+1)w₂ = 2·w₁w₂ + w₂ ≤ Mp` contradicts it.
  have hMpcast : 2 * ((w₁ : ℚ) * (w₂ : ℚ)) + (w₂ : ℚ) ≤ (Mp : ℚ) := by
    have : ((2 * w₁ + 1) * w₂ : ℚ) ≤ (Mp : ℚ) := by exact_mod_cast hMp
    linarith
  linarith

/-- **Peterfalvi (10.8), structural lower bound** `(2w₁+1)·w₂ ≤ |M'|` (the `hMp` input to the
non-coherence arithmetic `typeII_noncoherence_arithmetic`).

Peterfalvi's "By (8.4.d), `(M'/M'')⋊W₁` is a Frobenius group of odd order; it follows that
`|M':M''| ≥ 2w₁+1`": the cyclic Hall complement `W₁` acts on the abelian section `M'/M''`
fixed-point-freely (its fixed points on `M'` are `C_{M'}(x) = W₂` by `TypePData.centralizer_W1`, and
`W₂ ⊆ M''` by `TypePData.W2_le`), so `w₁ ∣ |M':M''| − 1`
(`S08.caseB_W1_dvd_index_of_centralizer_le`,
the `W₁`-conjugation action on `H = M'.subgroupOf M` with `M'' = ⁅H,H⁆`); with all orders odd and
`M'' < M'`
    (`M'` solvable nontrivial, `Group.IsSolvable.commutator_lt_top_of_nontrivial`) this forces
`|M':M''| ≥ 2w₁+1` (`S08.two_mul_add_one_le_of_odd_dvd`).  Then `|M'| = |M''|·|M':M''| ≥ w₂·(2w₁+1)`
(`Subgroup.index_mul_card`) since `w₂ = |W₂| ≤ |M''|` (`W₂ ⊆ M''`).  Genuine group theory,
**proven**; the one upstream citation is `typePData_W1_hall_coprime`, the shared §10 type-P
coprimality. -/
theorem Hypothesis.card_derived_ge [Finite G]
    (hG : OddOrder.BG.IsMinimalSimpleOdd G) {M : Subgroup G} (hyp : Hypothesis M) :
    (2 * hyp.w1 + 1) * hyp.w2 ≤ Nat.card ↥(derivedInG M) := by
  have := hyp.finiteG
  classical
  have hM'le : derivedInG M ≤ M := Subgroup.map_subtype_le _
  -- `derivedInG K = ⁅K, K⁆` (the commutator of `K` with itself in `G`).
  have hderiv : ∀ K : Subgroup G, derivedInG K = ⁅K, K⁆ := fun K => by
    rw [derivedInG, commutator_def, Subgroup.map_commutator, ← MonoidHom.range_eq_map,
      Subgroup.range_subtype]
  -- `H = M'` realised inside `↥M`; normal, `H.map subtype = M'`, `⁅H,H⁆.map subtype = M''`.
  set H : Subgroup ↥M := (derivedInG M).subgroupOf M with hHdef
  have hKcomm : H = _root_.commutator ↥M := by
    rw [hHdef, derivedInG, Subgroup.subgroupOf,
      Subgroup.comap_map_eq_self_of_injective M.subtype_injective]
  have hHnorm : H.Normal := by rw [hKcomm]; infer_instance
  have hHmap : H.map M.subtype = derivedInG M := by
    rw [hHdef, Subgroup.subgroupOf_map_subtype, inf_eq_left.mpr hM'le]
  have hmapcomm : (⁅H, H⁆ : Subgroup ↥M).map M.subtype = secondDerivedInAmbient M := by
    rw [Subgroup.map_commutator, hHmap, ← hderiv]; rfl
  have hW2leM' : hyp.typeP.W2 ≤ derivedInG M :=
    (hyp.typeP.W2_le.trans inf_le_right).trans (Subgroup.map_subtype_le _)
  -- `↥H` is solvable and nontrivial, so `M'' = ⁅H,H⁆ < H` and the index is `> 1`.
  have : Group.IsSolvable ↥M := hG.isSolvable_of_mem_maximalSubgroups hyp.maximal
  have hHsolv : Group.IsSolvable ↥H :=
    Group.isSolvable_of_isSolvable_injective (f := H.subtype) (Subgroup.subtype_injective H)
  have hHnt : Nontrivial ↥H := by
    have h1 : 1 < Nat.card ↥H := by
      rw [hHdef, Nat.card_congr (Subgroup.subgroupOfEquivOfLe hM'le).toEquiv]
      calc 1 < Nat.card ↥hyp.typeP.W2 :=
            (Subgroup.one_lt_card_iff_ne_bot _).mpr hyp.typeP.W2_nontrivial
        _ ≤ Nat.card ↥(derivedInG M) := Subgroup.card_le_of_le hW2leM'
    exact Finite.one_lt_card_iff_nontrivial.mp h1
  -- the FPF divisibility `w₁ ∣ |H : ⁅H,H⁆| − 1`.
  have hcardW1 : Nat.card ↥(hyp.W1.subgroupOf M) = hyp.w1 :=
    Nat.card_congr (Subgroup.subgroupOfEquivOfLe hyp.typeP.W1_le).toEquiv
  have hcop : Nat.Coprime (Nat.card ↥(hyp.W1.subgroupOf M)) (Nat.card ↥H) := by
    rw [hcardW1, hHdef, Nat.card_congr (Subgroup.subgroupOfEquivOfLe hM'le).toEquiv]
    exact (typePData_W1_hall_coprime hG hyp.maximal (hyp.bgTypeP hG) hyp.typeP).symm
  have hdvd : Nat.card ↥(hyp.W1.subgroupOf M) ∣ (_root_.commutator ↥H).index - 1 := by
    refine OddOrder.Peterfalvi.S08.caseB_W1_dvd_index_of_centralizer_le (hyp.W1.subgroupOf M) hcop
      (_root_.commutator ↥H) ?_
    intro a ha x hcomm
    have haW1 : ((↑(↑a : ↥M) : G)) ∈ hyp.W1 := Subgroup.mem_subgroupOf.mp a.2
    have hane : ((↑(↑a : ↥M) : G)) ≠ 1 := fun h => ha (Subtype.ext (Subtype.ext h))
    have hxM' : ((↑(↑x : ↥M) : G)) ∈ derivedInG M :=
      Subgroup.mem_subgroupOf.mp (hHdef ▸ x.2)
    have hcommG : ((↑(↑x : ↥M) : G)) * ((↑(↑a : ↥M) : G))
        = ((↑(↑a : ↥M) : G)) * ((↑(↑x : ↥M) : G)) := by
      simpa using (congrArg (fun t : ↥M => (↑t : G)) hcomm).symm
    have hxW2 : ((↑(↑x : ↥M) : G)) ∈ hyp.typeP.W2 := by
      rw [← hyp.typeP.centralizer_W1 _ haW1 hane]
      exact Subgroup.mem_inf.mpr ⟨hxM', Subgroup.mem_centralizer_singleton_iff.mpr hcommG⟩
    have key : (↑x : ↥M) ∈ (⁅H, H⁆ : Subgroup ↥M) := by
      refine (Subgroup.mem_map_iff_mem M.subtype_injective).mp ?_
      rw [hmapcomm]
      exact (hyp.typeP.W2_le.trans inf_le_right) hxW2
    exact OddOrder.Peterfalvi.S08.commutator_subgroupOf_self H ▸ Subgroup.mem_subgroupOf.mpr key
  -- `|H : ⁅H,H⁆| ≥ 2w₁ + 1` (odd Frobenius bound).
  have hidxgt : 1 < (_root_.commutator ↥H).index := by
    have hne1 : (_root_.commutator ↥H).index ≠ 1 := by
      rw [Ne, Subgroup.index_eq_one]
      exact (Group.IsSolvable.commutator_lt_top_of_nontrivial ↥H).ne
    have hpos : (_root_.commutator ↥H).index ≠ 0 :=
      Subgroup.index_ne_zero_of_finite
    omega
  have hidxge : 2 * hyp.w1 + 1 ≤ (_root_.commutator ↥H).index := by
    have hw1odd : Odd hyp.w1 := hG.odd.of_dvd_nat (Subgroup.card_subgroup_dvd_card hyp.W1)
    have hidxodd : Odd (_root_.commutator ↥H).index :=
      hG.odd.of_dvd_nat (dvd_trans (Subgroup.index_dvd_card _)
        (dvd_trans (Subgroup.card_subgroup_dvd_card H) (Subgroup.card_subgroup_dvd_card M)))
    exact OddOrder.Peterfalvi.S08.two_mul_add_one_le_of_odd_dvd hw1odd hidxodd
      (hcardW1 ▸ hdvd) hidxgt
  -- `|⁅H,H⁆| = |M''| ≥ w₂`.
  have hcommle : (⁅H, H⁆ : Subgroup ↥M) ≤ H := by
    rw [Subgroup.commutator_le]
    intro p hp q hq
    rw [commutatorElement_def]
    exact H.mul_mem (H.mul_mem (H.mul_mem hp hq) (H.inv_mem hp)) (H.inv_mem hq)
  have hcardge : hyp.w2 ≤ Nat.card ↥(_root_.commutator ↥H) := by
    have eMap := Subgroup.equivMapOfInjective (⁅H, H⁆ : Subgroup ↥M) M.subtype M.subtype_injective
    rw [← OddOrder.Peterfalvi.S08.commutator_subgroupOf_self,
      Nat.card_congr (Subgroup.subgroupOfEquivOfLe hcommle).toEquiv,
      Nat.card_congr eMap.toEquiv, hmapcomm]
    exact Subgroup.card_le_of_le (hyp.typeP.W2_le.trans inf_le_right)
  -- combine: `|M'| = |H| = |⁅H,H⁆|·|H:⁅H,H⁆| ≥ w₂·(2w₁+1)`.
  have hHcard : Nat.card ↥H = Nat.card ↥(derivedInG M) := by
    rw [hHdef]; exact Nat.card_congr (Subgroup.subgroupOfEquivOfLe hM'le).toEquiv
  calc (2 * hyp.w1 + 1) * hyp.w2
      ≤ (_root_.commutator ↥H).index * Nat.card ↥(_root_.commutator ↥H) :=
        Nat.mul_le_mul hidxge hcardge
    _ = Nat.card ↥H := (_root_.commutator ↥H).index_mul_card
    _ = Nat.card ↥(derivedInG M) := hHcard

/-- **Peterfalvi (10.8), line-87 strict bound** `|A(M)|/|M| < 1/w₁`.

Since `A(M) = typePA M = (M')#` (`typePA_eq_sharpSubgroup_derivedInG`), `|A(M)| = |M'| − 1`; and
`|M| = w₁·|M'|` because `[M : M'] = w₁` (`TypePData.card_W1_eq_derived_index`,
`Subgroup.index_mul_card`). Hence `|A(M)|/|M| = (|M'|−1)/(w₁·|M'|) < 1/w₁` (as `|M'| ≥ 1`,
`w₁ ≥ 1`).
This is the strict inequality Peterfalvi (10.8) uses at line 87 to turn `w₁/|M'| ≥ 1 − |G₁|/|G| −
|A(M)|/|M|` into `> 1 − |G₁|/|G| − 1/w₁` (the `hA` consumed by `typeII_coherence_estimate_chain`).
-/
theorem Hypothesis.card_typePA_div_card_lt_inv_w1 [Finite G]
    {M : Subgroup G} (hyp : Hypothesis M) :
    (Nat.card ↥(typePA M hyp.typeP) : ℚ) / (Nat.card ↥M : ℚ) < 1 / (hyp.w1 : ℚ) := by
  have := hyp.finiteG
  have hM'le : derivedInG M ≤ M := Subgroup.map_subtype_le _
  -- `|A(M)| = |M'| − 1` (sharp of the derived subgroup).
  have hcardA : Nat.card ↥(typePA M hyp.typeP) = Nat.card ↥(derivedInG M) - 1 := by
    rw [typePA_eq_sharpSubgroup_derivedInG, Nat.card_coe_set_eq]
    have hc : Nat.card ↥(derivedInG M) = ((derivedInG M : Set G)).ncard := by
      rw [← Nat.card_coe_set_eq]; exact Nat.card_congr (Equiv.refl _)
    rw [sharpSubgroup, Set.ncard_sdiff (Set.singleton_subset_iff.mpr (derivedInG M).one_mem),
      Set.ncard_singleton, hc]
  -- `|M| = w₁·|M'|` since `[M : M'] = w₁`.
  have hcardM : Nat.card ↥M = hyp.w1 * Nat.card ↥(derivedInG M) := by
    have hidx : ((derivedInG M).subgroupOf M).index = hyp.w1 := by
      rw [Hypothesis.w1, Hypothesis.W1]; exact hyp.typeP.card_W1_eq_derived_index.symm
    have hsub : Nat.card ↥((derivedInG M).subgroupOf M) = Nat.card ↥(derivedInG M) :=
      Nat.card_congr (Subgroup.subgroupOfEquivOfLe hM'le).toEquiv
    rw [← Subgroup.index_mul_card ((derivedInG M).subgroupOf M), hidx, hsub]
  -- arithmetic over `ℚ`.
  have hm1 : 1 ≤ Nat.card ↥(derivedInG M) := Nat.card_pos
  have hw1 : 1 ≤ hyp.w1 := Nat.card_pos
  rw [hcardA, hcardM, Nat.cast_sub hm1, Nat.cast_mul]
  have hmq : (0 : ℚ) < (Nat.card ↥(derivedInG M) : ℚ) := by exact_mod_cast hm1
  have hwq : (0 : ℚ) < (hyp.w1 : ℚ) := by exact_mod_cast hw1
  rw [div_lt_div_iff₀ (by positivity) hwq]
  push_cast
  nlinarith [hmq, hwq]

open scoped FiniteInduce in
/-- **`‖ζ^{τ₁}‖² = 1`** (Peterfalvi (10.8) line 81 input): the coherent extension `τ₁` of the Dade
isometry is an isometry on `ℤ[S]` (`coh.coherent.extension_inner_eq`), and `ζ = params.zeta ∈ S` is
irreducible (`params.zeta_irreducible`, `params.zeta_mem_S`), so `‖ζ^{τ₁}‖² = ‖ζ‖² = 1`.

This is the norm-one hypothesis that `S09.family_inequality` (7.5) demands of its character argument
`χ = ζ^{τ₁}`, so it is the bridge that lets the now-self-contained `toFamilyHypothesis71` feed the
(10.8) line-81 inequality. -/
theorem Hypothesis.inner_tau1_zeta_self_eq_one [Finite G] [Fintype G] {M : Subgroup G} [Fintype ↥M]
    [Invertible (Nat.card ↥M : ℂ)] [Invertible (Nat.card G : ℂ)]
    {hyp : Hypothesis M} {params : CharacterParameters hyp} (coh : CoherentHypothesis hyp params) :
    ClassFunction.inner (coh.tau1 params.zeta) (coh.tau1 params.zeta) = 1 := by
  have hspan : params.zeta ∈ OddOrder.Peterfalvi.S07.zSpan (L := ↥M) hyp.Sset :=
    Submodule.subset_span params.zeta_mem_S
  change ClassFunction.inner (coh.coherent.extension params.zeta)
    (coh.coherent.extension params.zeta) = 1
  rw [coh.coherent.extension_inner_eq params.zeta params.zeta hspan hspan]
  simpa using OddOrder.RepresentationTheory.irreducibleCharacter_inner_eq_ite
    (⟨params.zeta, params.zeta_irreducible⟩ : OddOrder.RepresentationTheory.IrreducibleCharacter ↥M)
    (⟨params.zeta, params.zeta_irreducible⟩ : OddOrder.RepresentationTheory.IrreducibleCharacter ↥M)

/-- **The `(10.6.b)`-summed bound** (the analytic core of Peterfalvi (10.8) line 83): if a function
`χ : G → ℂ` takes **odd integer** values on a finite set `S` (in particular `|χ(g)| ≥ 1` there),
then
`|S| ≤ Σ_{g ∈ S} ‖χ(g)‖²`.  General and reusable (no §10 hypotheses): per element, an odd integer
`m ≠ 0` has `‖(m : ℂ)‖² = |m|² ≥ 1`, and `Σ_S 1 = |S|`.  In the (10.8) proof this is applied to
`χ = ζ^{τ₁}` on `G₀ = {g | g ∉ Ã(M), (ord g).Coprime w₁}` via (10.6.b) `zeta_tau1_norm_ge_one`,
dropping the `G₀`-part of the (7.5) sum to reach line 83. -/
theorem card_le_sum_normSq_of_forall_eq_odd_intCast {ι : Type*} (S : Finset ι) {χ : ι → ℂ}
    (h : ∀ g ∈ S, ∃ m : ℤ, χ g = (m : ℂ) ∧ Odd m) :
    (S.card : ℝ) ≤ ∑ g ∈ S, ‖χ g‖ ^ 2 := by
  calc (S.card : ℝ) = ∑ _g ∈ S, (1 : ℝ) := by rw [Finset.sum_const, nsmul_eq_mul, mul_one]
    _ ≤ ∑ g ∈ S, ‖χ g‖ ^ 2 := by
        refine Finset.sum_le_sum (fun g hg => ?_)
        obtain ⟨m, hm, hodd⟩ := h g hg
        have hm0 : m ≠ 0 := by obtain ⟨k, hk⟩ := hodd; omega
        have hnorm : ‖χ g‖ = |(m : ℝ)| := by rw [hm, Complex.norm_intCast]
        have h1 : (1 : ℝ) ≤ |(m : ℝ)| := by
          rw [← Int.cast_abs]; exact_mod_cast Int.one_le_abs hm0
        rw [hnorm]; nlinarith [h1, abs_nonneg ((m : ℝ))]

open scoped Classical FiniteInduce in
/-- **The `(10.6.b)`-summed bound for `ζ^{τ₁}`** — `|G₀| ≤ Σ_{g ∈ G₀} ‖ζ^{τ₁}(g)‖²` over
`G₀ = {g | g ∉ Ã(M), (ord g).Coprime w₁}`.  Composes `card_le_sum_normSq_of_forall_eq_odd_intCast`
(the analytic core) with the per-`g` (10.6.b) bound `tau1_values_and_norm_bound` (`ζ^{τ₁}(g)` is an
odd integer off `Ã(M)` at orders prime to `w₁`).  The 7 parameter conditions are exactly those
supplied by `exists_charParameters_full`.  This is the `G₀`-drop term Peterfalvi (10.8) uses to pass
from the family inequality (7.5) (line 81) to line 83. -/
theorem Hypothesis.sum_zeta_tau1_normSq_ge_card [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) :
    ((Finset.univ.filter
        (fun g : G => g ∉ hyp.dadeData.dade.dadeSupport ∧ (orderOf g).Coprime hyp.w1)).card : ℝ)
      ≤ ∑ g ∈ Finset.univ.filter
          (fun g : G => g ∉ hyp.dadeData.dade.dadeSupport ∧ (orderOf g).Coprime hyp.w1),
          ‖coh.tau1 params.zeta g‖ ^ 2 := by
  classical
  apply card_le_sum_normSq_of_forall_eq_odd_intCast
  intro g hg
  rw [Finset.mem_filter] at hg
  exact (tau1_values_and_norm_bound hG coh hmu hos hzS hz1 hzconj hδpm hδj).2 g hg.2.1 hg.2.2

/-- **Restricting the Dade support shrinks it**: for `A₁ ⊆ A`, the Dade support of the restricted
hypothesis `hyp.restrict` is contained in that of `hyp` (`mem_dadeSupport_iff`: a witness
`a ∈ A₁, h ∈ H(a)` for the restriction is a witness `⟨a, _⟩ ∈ A` for `hyp`, since
`(hyp.restrict ..).H a = hyp.H ⟨a, _⟩`).  In the (10.8) line-83 step this gives `G₀ ⊆ famG₀`: the
`A_0(M)`-support complement `G₀` is inside the `A(M)`-support complement `famG₀` (the family `(7.4)`
support for `A(M) = typePA ⊆ typePA0 = A_0(M)`). -/
theorem dadeSupport_restrict_subset {A A₁ : Set G} {L : Subgroup G} [Fintype G]
    (hyp : OddOrder.Peterfalvi.S04.Hypothesis G A L) (hA₁A : A₁ ⊆ A)
    (hA₁_norm : ∀ (l : L) ⦃a : G⦄, a ∈ A₁ → (l : G) * a * (l : G)⁻¹ ∈ A₁) :
    (hyp.restrict hA₁A hA₁_norm).dadeSupport ⊆ hyp.dadeSupport := by
  intro g hg
  rw [OddOrder.Peterfalvi.S04.Hypothesis.mem_dadeSupport_iff] at hg ⊢
  obtain ⟨a, h, hh, hconj⟩ := hg
  exact ⟨⟨a.1, hA₁A a.2⟩, h, hh, hconj⟩

open scoped Classical FiniteInduce in
/-- **Peterfalvi (10.8), line 83** (the mechanical `(7.5)`+`(10.6.b)` combination): the `ρ`-norm of
`ζ^{τ₁}` for the one-member family `{(M, A(M))}` is bounded by `|A(M)|/|M|` plus the `|G₁|/|G|`-term
`(|famG₀| − |G₀|)/|G|`.

This is Peterfalvi (10.8) 04.12 line 81 → 83: apply the family inequality (7.5)
(`S09.family_inequality` on the now-self-contained `toFamilyHypothesis71`, with the norm-one
`inner_tau1_zeta_self_eq_one`) and drop the `G₀`-part of the sum via the `(10.6.b)` bound
(`sum_zeta_tau1_normSq_ge_card`, using `G₀ ⊆ famG₀` from `dadeSupport_restrict_subset` and
`‖·‖² ≥ 0` on the rest).  Pure real-arithmetic bookkeeping over the family inequality; the genuine
`‖ζ^{τ₁,ρ}‖²` lower bound (7.8.b) and the `|G₁|`-count (TI-counting, §9) are the remaining gates
that
turn this into line 87 and the contradiction.  Here `famG₀ = (toFamilyHypothesis71).G0` is the
`A(M)`-support complement and `G₀ = {g ∉ Ã(M), (ord g).Coprime w₁}` the `A_0(M)`-support coprime
subset (`G₀ ⊆ famG₀`). -/
theorem Hypothesis.chiRhoNormSq_zeta_le_line83 [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.toFamilyHypothesis71).chiRhoNormSq (coh.tau1 params.zeta) 0
      ≤ (Nat.card ↥(typePA M hyp.typeP) : ℝ) / (Nat.card ↥M : ℝ)
        + (Nat.card G : ℝ)⁻¹ * ((Nat.card (hyp.toFamilyHypothesis71).G0 : ℝ)
          - ((Finset.univ.filter (fun g : G => g ∉ hyp.dadeData.dade.dadeSupport
              ∧ (orderOf g).Coprime hyp.w1)).card : ℝ)) := by
  have := hyp.finiteG
  -- `F.A 0 = A(M)`, `F.L 0 = M` (structure projections).
  have hA0 : (hyp.toFamilyHypothesis71).A 0 = typePA M hyp.typeP := rfl
  have hL0 : (hyp.toFamilyHypothesis71).L 0 = M := rfl
  -- (7.5) line 81 (single member, `k = 1`).
  have h81 := OddOrder.Peterfalvi.S09.family_inequality (hyp.toFamilyHypothesis71)
    (coh.tau1 params.zeta) (hyp.inner_tau1_zeta_self_eq_one coh)
  rw [Fin.sum_univ_one, hA0, hL0] at h81
  -- `G₀ ⊆ famG₀`: a `g` off the `A_0(M)`-support is off the restricted `A(M)`-support.
  have hsub : Finset.univ.filter (fun g : G => g ∉ hyp.dadeData.dade.dadeSupport
        ∧ (orderOf g).Coprime hyp.w1)
      ⊆ Finset.univ.filter (fun g : G => g ∈ (hyp.toFamilyHypothesis71).G0) := by
    intro g hg
    rw [Finset.mem_filter] at hg ⊢
    refine ⟨Finset.mem_univ g, fun i => ?_⟩
    have hsupp : ((hyp.toFamilyHypothesis71).hyp71 i).hyp.dadeSupport
        ⊆ hyp.dadeData.dade.dadeSupport :=
      dadeSupport_restrict_subset hyp.dadeData.dade Set.subset_union_left _
    exact fun hmem => hg.2.1 (hsupp hmem)
  -- drop the `G₀`-part: `|G₀| ≤ Σ_{G₀} ‖χ‖² ≤ Σ_{famG₀} ‖χ‖²`.
  have hdrop : ((Finset.univ.filter (fun g : G => g ∉ hyp.dadeData.dade.dadeSupport
        ∧ (orderOf g).Coprime hyp.w1)).card : ℝ)
      ≤ ∑ g ∈ Finset.univ.filter (fun g : G => g ∈ (hyp.toFamilyHypothesis71).G0),
          ‖(coh.tau1 params.zeta : G → ℂ) g‖ ^ 2 := by
    refine le_trans (hyp.sum_zeta_tau1_normSq_ge_card hG coh hmu hos hzS hz1 hzconj hδpm hδj) ?_
    exact Finset.sum_le_sum_of_subset_of_nonneg hsub (fun g _ _ => by positivity)
  -- rearrange the family inequality.
  have hGinv : (0 : ℝ) ≤ (Nat.card G : ℝ)⁻¹ := by positivity
  have hcS := mul_le_mul_of_nonneg_left hdrop hGinv
  rw [mul_sub] at h81 ⊢
  linarith [h81, hcS]

/-- **Peterfalvi (10.8), the analytic chain** (04.12 p.61, lines 87--99) — the pure-`ℚ` assembly
that turns the §7 norm output (line 87) and the §8 TI-counting bound (lines 89--91) into the
coherence bound `1 − 1/w₁ − 1/u < w₁w₂/|M'|`.

Faithful inputs (with `Mp = |M'|`, `cardH = |H| = |S_F|`, `cardS = |S|`, `u = |U|`,
`g1g = |G₁|/|G|`):
* `hA` — the §7 output `w₁/|M'| > 1 − |G₁|/|G| − 1/w₁` (Peterfalvi line 87, from (7.5), (7.8.b),
  (10.6.b), and `|M'| ≥ 2w₁+1`);
* `hB` — the TI-counting bound `|G₁|/|G| ≤ (|H|−1)/|S| + (w₁w₂−w₁−w₂+1)/(w₁w₂)` (from the inclusion
  `G₁ ⊆ (H#)^G ∪ V^G` and the orbit cardinalities, Peterfalvi lines 89--91);
* `hS` — `|S| = |H|·|U|·w₂` (the Type-II partner `S = (H ⋊ U) ⋊ W₂`).

The derivation substitutes `(w₁w₂−w₁−w₂+1)/(w₁w₂) = 1 − 1/w₂ − 1/w₁ + 1/(w₁w₂)` and
`(|H|−1)/|S| ≤ |H|/|S| = 1/(|U|w₂)`, yielding `w₁/|M'| > 1/w₂ − 1/(w₁w₂) − 1/(|U|w₂)`, then
multiplies by `w₂`.  Pure arithmetic over `ℚ`; the genuine character/group inputs are `hA`/`hB`. -/
theorem typeII_coherence_estimate_chain
    {w₁ w₂ u cardH cardS Mp : ℕ} {g1g : ℚ}
    (hw1 : 1 ≤ w₁) (hw2 : 1 ≤ w₂) (hu : 1 ≤ u) (hH : 1 ≤ cardH)
    (hMp : 1 ≤ Mp) (hS : cardS = cardH * u * w₂)
    (hA : 1 - g1g - 1 / (w₁ : ℚ) < (w₁ : ℚ) / (Mp : ℚ))
    (hB : g1g ≤ ((cardH : ℚ) - 1) / (cardS : ℚ)
        + ((w₁ : ℚ) * w₂ - w₁ - w₂ + 1) / ((w₁ : ℚ) * w₂)) :
    (1 : ℚ) - 1 / (w₁ : ℚ) - 1 / (u : ℚ) < (w₁ : ℚ) * w₂ / (Mp : ℚ) := by
  have hw1q : (0 : ℚ) < w₁ := by exact_mod_cast hw1
  have hw2q : (0 : ℚ) < w₂ := by exact_mod_cast hw2
  have huq : (0 : ℚ) < u := by exact_mod_cast hu
  have hHq : (0 : ℚ) < cardH := by exact_mod_cast hH
  have hMpq : (0 : ℚ) < Mp := by exact_mod_cast hMp
  have hw1ne : (w₁ : ℚ) ≠ 0 := ne_of_gt hw1q
  have hw2ne : (w₂ : ℚ) ≠ 0 := ne_of_gt hw2q
  have hune : (u : ℚ) ≠ 0 := ne_of_gt huq
  have hScast : (cardS : ℚ) = (cardH : ℚ) * u * w₂ := by exact_mod_cast hS
  -- `(|H|−1)/|S| ≤ 1/(|U|w₂)` (drop the `−1`, then cancel `|H|`).
  have hHS : ((cardH : ℚ) - 1) / (cardS : ℚ) ≤ 1 / ((u : ℚ) * w₂) := by
    rw [hScast, div_le_div_iff₀ (by positivity) (by positivity)]
    nlinarith [mul_pos huq hw2q]
  -- `(w₁w₂−w₁−w₂+1)/(w₁w₂) = 1 − 1/w₂ − 1/w₁ + 1/(w₁w₂)`.
  have hident : ((w₁ : ℚ) * w₂ - w₁ - w₂ + 1) / ((w₁ : ℚ) * w₂)
      = 1 - 1 / w₂ - 1 / w₁ + 1 / ((w₁ : ℚ) * w₂) := by
    field_simp
  -- `w₁/|M'| > 1/w₂ − 1/(w₁w₂) − 1/(|U|w₂)`.
  have hKey : 1 / (w₂ : ℚ) - 1 / ((w₁ : ℚ) * w₂) - 1 / ((u : ℚ) * w₂) < (w₁ : ℚ) / Mp := by
    rw [hident] at hB
    linarith [hA, hB, hHS]
  -- multiply by `w₂` and simplify the four products.
  have e1 : (w₂ : ℚ) * (1 / w₂) = 1 := by rw [mul_one_div, div_self hw2ne]
  have e2 : (w₂ : ℚ) * (1 / ((w₁ : ℚ) * w₂)) = 1 / w₁ := by
    rw [mul_one_div, mul_comm (w₁ : ℚ) w₂, div_mul_eq_div_div, div_self hw2ne]
  have e3 : (w₂ : ℚ) * (1 / ((u : ℚ) * w₂)) = 1 / u := by
    rw [mul_one_div, mul_comm (u : ℚ) w₂, div_mul_eq_div_div, div_self hw2ne]
  have e4 : (w₂ : ℚ) * ((w₁ : ℚ) / Mp) = (w₁ : ℚ) * w₂ / Mp := by ring
  have hmul := mul_lt_mul_of_pos_left hKey hw2q
  rw [mul_sub, mul_sub, e1, e2, e3, e4] at hmul
  linarith [hmul]

/-- **`V`-elements have order divisible by a `|W₁|`-prime** (the (8.10)/(10.8) support
bookkeeping): `v ∈ V = W ∖ (W₁ ∪ W₂)` factors as `v₁·v₂` with `v₁ ∈ W₁ ∖ {1}`
(`TypePData.exists_mul_eq_of_mem_W`; a trivial `W₁`-part would put `v ∈ W₂`), and any prime of
`orderOf v₁ ∣ |W₁|` divides `orderOf v` — a power killing `v` puts `v₁ ^ n ∈ W₁ ⊓ W₂ = ⊥`. -/
theorem exists_prime_dvd_orderOf_of_mem_typePV [Finite G] {M : Subgroup G}
    (data : TypePData M) {v : G} (hv : v ∈ typePV M data) :
    ∃ p : ℕ, p.Prime ∧ p ∣ orderOf v ∧ p ∣ Nat.card ↥data.W1 := by
  have hW1le : data.W1 ≤ data.W := data.W_eq ▸ le_sup_left
  have hW2le : data.W2 ≤ data.W := data.W_eq ▸ le_sup_right
  obtain ⟨hvW, hvnot⟩ := hv
  rw [Set.mem_union] at hvnot
  push Not at hvnot
  obtain ⟨v₁, hv₁, v₂, hv₂, rfl⟩ :=
    data.exists_mul_eq_of_mem_W (SetLike.mem_coe.mp hvW)
  have hv₁ne : v₁ ≠ 1 := by
    rintro rfl
    exact hvnot.2 (by simpa using hv₂)
  obtain ⟨p, hp, hpd⟩ := Nat.exists_prime_and_dvd
    (fun h => hv₁ne (orderOf_eq_one_iff.mp h))
  have hpW1 : p ∣ Nat.card ↥data.W1 := by
    refine hpd.trans ?_
    have h1 : orderOf v₁ = orderOf (⟨v₁, hv₁⟩ : ↥data.W1) :=
      orderOf_injective data.W1.subtype data.W1.subtype_injective ⟨v₁, hv₁⟩
    rw [h1]
    exact orderOf_dvd_natCard _
  have hcomm : Commute v₁ v₂ := by
    have := data.W_cyclic
    let : CommGroup ↥data.W := IsCyclic.commGroup
    have := mul_comm (⟨v₁, hW1le hv₁⟩ : ↥data.W) ⟨v₂, hW2le hv₂⟩
    exact Subtype.ext_iff.mp this
  refine ⟨p, hp, ?_, hpW1⟩
  have hkill : v₁ ^ orderOf (v₁ * v₂) = 1 := by
    have h1 : (v₁ * v₂) ^ orderOf (v₁ * v₂) = 1 := pow_orderOf_eq_one _
    rw [hcomm.mul_pow] at h1
    have hmem : v₁ ^ orderOf (v₁ * v₂) ∈ data.W1 ⊓ data.W2 := by
      refine ⟨data.W1.pow_mem hv₁ _, ?_⟩
      have heq : v₁ ^ orderOf (v₁ * v₂) = (v₂ ^ orderOf (v₁ * v₂))⁻¹ :=
        eq_inv_of_mul_eq_one_right (((hcomm.pow_pow _ _).symm.eq).trans h1)
      rw [heq]
      exact data.W2.inv_mem (data.W2.pow_mem hv₂ _)
    rwa [disjoint_iff.mp (typePData_disjoint_W1_W2 data), Subgroup.mem_bot] at hmem
  exact hpd.trans (orderOf_dvd_of_pow_eq_one hkill)

open scoped Classical FiniteInduce in
/-- **Coprime-order elements of the full Dade support lie in the `A(M)`-restricted support**
(the (10.8) `G₀`-bookkeeping): the extra support over `A₀(M) ∖ A(M) = V^M` consists of
conjugates of `a·h` with `a` conjugate into `V` — whose order is divisible by a `w₁`-prime
(`exists_prime_dvd_orderOf_of_mem_typePV`, carried through the coprime `H(a)`-part) — so an
element of `w₁`-coprime order must arise from the `A(M)`-part. -/
theorem Hypothesis.mem_restricted_dadeSupport_of_coprime [Finite G] {M : Subgroup G}
    (hyp : Hypothesis M) {g : G} (hg : g ∈ hyp.dadeData.dade.dadeSupport)
    (hcop : (orderOf g).Coprime hyp.w1) :
    g ∈ hyp.toHypothesis71.hyp.dadeSupport := by
  classical
  obtain ⟨a, h, hh, hconj⟩ := hyp.dadeData.dade.mem_dadeSupport_iff.mp hg
  have ha2 : a.1 ∈ typePA M hyp.typeP ∪ conjClassSetIn M (typePV M hyp.typeP) := a.2
  rcases ha2 with haA | haV
  · -- the `A(M)`-part: the same witness lives in the restricted support
    exact hyp.toHypothesis71.hyp.mem_dadeSupport_iff.mpr ⟨⟨a.1, haA⟩, h, hh, hconj⟩
  · -- the `V^M`-part: its orders are divisible by a `w₁`-prime — contradiction
    exfalso
    obtain ⟨t, htV, m, hmM, hma⟩ := haV
    obtain ⟨p, hp, hpv, hpw⟩ := exists_prime_dvd_orderOf_of_mem_typePV hyp.typeP htV
    -- `p ∣ orderOf a` (conjugation-invariance of the order)
    have hoa : orderOf a.1 = orderOf t := by
      rw [← hma]
      have := orderOf_injective (MulAut.conj m).toMonoidHom (MulAut.conj m).injective t
      simpa [MulAut.conj_apply] using this
    have hpa : p ∣ orderOf a.1 := hoa ▸ hpv
    -- `h ∈ H(a)` commutes with `a` and has coprime order ((2.2.b)/(2.2.c))
    have hhc : h ∈ Subgroup.centralizer ({a.1} : Set G) := by
      have hsup : h ∈ hyp.dadeData.dade.H a ⊔ OddOrder.Peterfalvi.S04.centralizerIn M a.1 :=
        (le_sup_left : hyp.dadeData.dade.H a ≤ _) hh
      rwa [← hyp.dadeData.dade.centralizer_eq_sup a] at hsup
    have hcomm : Commute a.1 h :=
      Subgroup.mem_centralizer_iff.mp hhc a.1 rfl
    have hcopah : Nat.Coprime (orderOf a.1) (orderOf h) := by
      have h1 : orderOf h ∣ Nat.card (hyp.dadeData.dade.H a) := by
        have he : orderOf h = orderOf (⟨h, hh⟩ : ↥(hyp.dadeData.dade.H a)) :=
          orderOf_injective (hyp.dadeData.dade.H a).subtype
            (hyp.dadeData.dade.H a).subtype_injective ⟨h, hh⟩
        rw [he]; exact orderOf_dvd_natCard _
      have h2 : orderOf a.1 ∣ Nat.card (OddOrder.Peterfalvi.S04.centralizerIn M a.1) := by
        have haC : a.1 ∈ OddOrder.Peterfalvi.S04.centralizerIn M a.1 :=
          ⟨hyp.dadeData.dade.subset_L a.2, Subgroup.mem_centralizer_iff.mpr
            (fun z hz => by rw [Set.mem_singleton_iff.mp hz])⟩
        have he : orderOf a.1 = orderOf (⟨a.1, haC⟩ : ↥(OddOrder.Peterfalvi.S04.centralizerIn M
            a.1)) :=
          orderOf_injective (OddOrder.Peterfalvi.S04.centralizerIn M a.1).subtype
            (OddOrder.Peterfalvi.S04.centralizerIn M a.1).subtype_injective ⟨a.1, haC⟩
        rw [he]; exact orderOf_dvd_natCard _
      exact ((hyp.dadeData.dade.centralizer_coprime a a).coprime_dvd_left h1).coprime_dvd_right
        h2 |>.symm
    -- `p ∣ orderOf (a·h)`: the killing power lands `a ^ n` in the trivial coprime overlap
    have hpah : p ∣ orderOf (a.1 * h) := by
      have hkill : a.1 ^ orderOf (a.1 * h) = 1 := by
        have h1 : (a.1 * h) ^ orderOf (a.1 * h) = 1 := pow_orderOf_eq_one _
        rw [hcomm.mul_pow] at h1
        have hd1 : orderOf (a.1 ^ orderOf (a.1 * h)) ∣ orderOf a.1 := orderOf_pow_dvd _
        have hd2 : orderOf (a.1 ^ orderOf (a.1 * h)) ∣ orderOf h := by
          have heq : a.1 ^ orderOf (a.1 * h) = (h ^ orderOf (a.1 * h))⁻¹ :=
            eq_inv_of_mul_eq_one_left h1
          rw [heq, orderOf_inv]
          exact orderOf_pow_dvd _
        have hone : orderOf (a.1 ^ orderOf (a.1 * h)) = 1 :=
          Nat.dvd_one.mp (hcopah ▸ Nat.dvd_gcd hd1 hd2)
        exact orderOf_eq_one_iff.mp hone
      exact hpa.trans (orderOf_dvd_of_pow_eq_one hkill)
    -- transport along the conjugacy to `g` and contradict the coprimality
    have hog : orderOf g = orderOf (a.1 * h) := by
      obtain ⟨c, hc⟩ := isConj_iff.mp hconj
      rw [← hc]
      have := orderOf_injective (MulAut.conj c).toMonoidHom (MulAut.conj c).injective (a.1 * h)
      simpa [MulAut.conj_apply] using this
    have hpg : p ∣ orderOf g := hog ▸ hpah
    have hpw1 : p ∣ hyp.w1 := hpw
    exact hp.ne_one (Nat.dvd_one.mp (hcop ▸ Nat.dvd_gcd hpg hpw1))

/-- **The (8.7) type-V trichotomy transfers across `TypePData` choices** (issue 1021): the
alternative field of a `TypeVData` mentions only `H = M_F` (data-independent, `H_eq`) and
`|W₁| = [M : M′]` (data-independent, `card_W1_eq_derived_index`), so it holds verbatim for any
other `TypePData` of the same `M` — in particular for the (10.1) `Hypothesis`'s own datum. -/
theorem TypeVData.alternative_transfer [Finite G] {M : Subgroup G}
    (dV : OddOrder.GroupTheory.TypeVData M) (data : TypePData M) :
    OddOrder.GroupTheory.IsTISubset (sharpSubgroup data.H)
      (Subgroup.normalizer (data.H : Set G)) ∨
    (∃ p : ℕ, p.Prime ∧ p ∈ (Nat.card ↥data.H).primeFactors ∧
      Nat.card ↥data.W1 ∣ p - 1 ∧ IsCyclic ↥(opiCoreInG {p}ᶜ data.H)) ∨
    (∃ p : ℕ, p.Prime ∧ p ∈ (Nat.card ↥data.H).primeFactors ∧
      Nat.card ↥(opiCoreInG {p} data.H) = p ^ 3 ∧ Nat.card ↥data.W1 ∣ p + 1 ∧
      IsCyclic ↥(opiCoreInG {p}ᶜ data.H)) := by
  have hH : dV.typeP.H = data.H := dV.typeP.H_eq.trans data.H_eq.symm
  have hW1 : Nat.card ↥dV.typeP.W1 = Nat.card ↥data.W1 := by
    rw [dV.typeP.card_W1_eq_derived_index, data.card_W1_eq_derived_index]
  rcases dV.alternative with h | h | h
  · exact Or.inl (hH ▸ h)
  · exact Or.inr (Or.inl (hW1 ▸ hH ▸ h))
  · exact Or.inr (Or.inr (hW1 ▸ hH ▸ h))

/-- **The pair κ-Hall dual is `W₂`**: `M_σ ⊓ C_G(W₁) = W₂` for type-`P` data.  This is the
identification `K = W₂(M)` of the `M`-seeded maximal pair (`mp.K_eq` has exactly this LHS with
`mp.Kstar = W₁` literal), the pair-linkage input of the (10.8) partner supply (issue 1020).

`⊇`: `W₂ ≤ H = M_F ≤ M_σ` (`maxNilpotentNormalHall_le_Msigma`) and `W₂` centralises `W₁`
(both sit in the commutative `W`).  `⊆`: `M_σ ≤ M′` (`Msigma_le_derived`), and
`M′ ⊓ C_G(w) = W₂` for a nonidentity `w ∈ W₁` (`centralizer_W1`). -/
theorem typePData_Msigma_inf_centralizer_W1_eq_W2 [Finite G]
    (hG : OddOrder.BG.IsMinimalSimpleOdd G) {M : Subgroup G}
    (hM : M ∈ maximalSubgroups G) (data : TypePData M) :
    OddOrder.BG.Ch3.S10.Msigma M ⊓ Subgroup.centralizer (data.W1 : Set G) = data.W2 := by
  have hW1le : data.W1 ≤ data.W := data.W_eq ▸ le_sup_left
  have hW2le : data.W2 ≤ data.W := data.W_eq ▸ le_sup_right
  apply le_antisymm
  · -- `⊆`: pass through `M′ ⊓ C_G(w) = W₂` at a nonidentity `w ∈ W₁`
    obtain ⟨w, hwW1, hwne⟩ :=
      (data.W1.bot_or_exists_ne_one).resolve_left data.W1_nontrivial
    rintro x ⟨hxσ, hxc⟩
    rw [← data.centralizer_W1 w hwW1 hwne]
    refine ⟨OddOrder.BG.Ch3.S10.Msigma_le_derived hG hM hxσ, ?_⟩
    exact Subgroup.centralizer_le (by simpa using hwW1) hxc
  · -- `⊇`: `W₂ ≤ M_σ` via `H = M_F`, and `W₂` centralises `W₁` inside the commutative `W`
    refine le_inf ?_ ?_
    · refine le_trans ?_ (OddOrder.BG.Ch4.S15.maxNilpotentNormalHall_le_Msigma hG hM)
      exact data.H_eq ▸ (data.W2_le.trans (inf_le_left.trans le_rfl))
    · intro x hx
      rw [Subgroup.mem_centralizer_iff]
      intro w hw
      have := data.W_cyclic
      let : CommGroup ↥data.W := IsCyclic.commGroup
      have := mul_comm (⟨w, hW1le hw⟩ : ↥data.W) ⟨x, hW2le hx⟩
      exact Subtype.ext_iff.mp this

/-- **The `(S_F#)^G` union bound of the (10.8) TI-counting** (p. 60 line 91, `≤`-form): the
conjugacy saturation of the kernel sharp-set of a type-`P` maximal `S` has at most
`(|S_F| − 1)·[G : S]` elements.  `S` stabilises `H# = H ∖ {1}` under conjugation (`H ⊴ S`), so
the union bound `ncard_conjClassSet_le` applies with `L = S`; no TI-property is needed for the
upper bound. -/
theorem ncard_conjClassSet_sharp_H_le [Finite G] {S : Subgroup G} (data : TypePData S) :
    (conjClassSet ((data.H : Set G) \ {1})).ncard ≤ (Nat.card ↥data.H - 1) * S.index := by
  have hHle : data.H ≤ S := data.H_le.trans (Subgroup.map_subtype_le _)
  have hstab : ∀ l ∈ S, ∀ t ∈ (data.H : Set G) \ {1},
      l * t * l⁻¹ ∈ (data.H : Set G) \ {1} := by
    rintro l hl t ⟨htH, htne⟩
    have htH' : t ∈ data.H := htH
    have hnorm := OddOrder.BG.Ch4.S15.maxNilpotentNormalHall_subgroupOf_normal S
    have hconj : l * t * l⁻¹ ∈ maxNilpotentNormalHall S := by
      have hmem := hnorm.conj_mem ⟨t, hHle htH'⟩
        (Subgroup.mem_subgroupOf.mpr (data.H_eq ▸ htH')) ⟨l, hl⟩
      exact Subgroup.mem_subgroupOf.mp hmem
    refine ⟨?_, ?_⟩
    · rw [SetLike.mem_coe, data.H_eq]; exact hconj
    · intro h1
      apply htne
      rw [Set.mem_singleton_iff]
      have := congrArg (fun z => l⁻¹ * z * l) (Set.mem_singleton_iff.mp h1)
      simpa [mul_assoc] using this
  have hle := OddOrder.GroupTheory.ncard_conjClassSet_le (L := S) hstab
  have hA : ((data.H : Set G) \ {1}).ncard = Nat.card ↥data.H - 1 := by
    rw [Set.ncard_sdiff_singleton_of_mem (by exact one_mem data.H),
      ← Nat.card_coe_set_eq]
    rfl
  rwa [hA] at hle

open scoped Classical FiniteInduce in
/-- **The (10.8) `G₁`-count bound, Nat form** (p. 60 lines 89–91): with the type-II partner
data supplied, the restricted-support complement count `|famG₀| = |∁Ã(M)|` is bounded by the
full-support `w₁`-coprime filter plus the two covering counts `(|S_F|−1)·[G:S]` and
`|V|·[G:W]`.

`∁Ã(M)` splits along `w₁`-coprimality; the coprime part equals the full-support coprime filter
(`mem_restricted_dadeSupport_of_coprime` + support monotonicity), and the non-coprime part is
covered by `𝒞((S_F)#) ∪ 𝒞(V_S)` (`mem_conjClassSet_sharpH_or_typePV_of_not_coprime`), counted
by `ncard_conjClassSet_sharp_H_le` and `typePData_conjClassSet_typePV_ncard`. -/
theorem Hypothesis.g1_card_le_of_partner [Finite G] {M S : Subgroup G} (hyp : Hypothesis M)
    (data : TypePData S) (hprime : (Nat.card ↥data.W1).Prime)
    (hcop : Nat.Coprime (Nat.card ↥(derivedInG S)) (Nat.card ↥data.W1))
    (hHall : OddOrder.Isaacs.Ch03.IsHallSubgroup (Nat.card ↥data.H).primeFactors data.H)
    (hcent : ∀ b ∈ data.H, b ≠ 1 → Subgroup.centralizer ({b} : Set G) ≤ S)
    (hfrobcap : ∀ b ∈ data.H, b ≠ 1 → ∀ y ∈ derivedInG S,
      y ∈ Subgroup.centralizer ({b} : Set G) → y ∈ data.H)
    (hW2card : Nat.card ↥data.W2 = hyp.w1) :
    Nat.card (hyp.toFamilyHypothesis71).G0
      ≤ (Finset.univ.filter (fun g : G => g ∉ hyp.dadeData.dade.dadeSupport
          ∧ (orderOf g).Coprime hyp.w1)).card
        + ((Nat.card ↥data.H - 1) * S.index
            + (Nat.card ↥data.W1 * Nat.card ↥data.W2 - Nat.card ↥data.W1
                - Nat.card ↥data.W2 + 1) * data.W.index) := by
  classical
  -- `famG₀` is the complement of the restricted support (the `Fin 1` family collapses)
  have hG0eq : (hyp.toFamilyHypothesis71).G0
      = {g : G | g ∉ hyp.toHypothesis71.hyp.dadeSupport} := by
    ext g
    rw [(hyp.toFamilyHypothesis71).mem_G0_iff]
    exact ⟨fun h => h 0, fun h _ => h⟩
  have hcard0 : Nat.card (hyp.toFamilyHypothesis71).G0
      = (Finset.univ.filter
          (fun g : G => g ∉ hyp.toHypothesis71.hyp.dadeSupport)).card := by
    rw [hG0eq, Nat.card_coe_set_eq, Set.ncard_eq_toFinset_card', Set.toFinset_ofPred]
  -- split the complement along `w₁`-coprimality
  have hsplit : (Finset.univ.filter
        (fun g : G => g ∉ hyp.toHypothesis71.hyp.dadeSupport)).card
      = (Finset.univ.filter (fun g : G => g ∉ hyp.toHypothesis71.hyp.dadeSupport
          ∧ (orderOf g).Coprime hyp.w1)).card
        + (Finset.univ.filter (fun g : G => g ∉ hyp.toHypothesis71.hyp.dadeSupport
            ∧ ¬ (orderOf g).Coprime hyp.w1)).card := by
    rw [← Finset.filter_filter, ← Finset.filter_filter,
      Finset.card_filter_add_card_filter_not]
  -- support monotonicity: the restricted support sits inside the full one
  have hRF : hyp.toHypothesis71.hyp.dadeSupport ⊆ hyp.dadeData.dade.dadeSupport := by
    intro x hx
    obtain ⟨a, h, hh, hconj⟩ := hyp.toHypothesis71.hyp.mem_dadeSupport_iff.mp hx
    exact hyp.dadeData.dade.mem_dadeSupport_iff.mpr
      ⟨⟨a.1, Set.subset_union_left a.2⟩, h, hh, hconj⟩
  -- the coprime part is the full-support coprime filter
  have hcopeq : (Finset.univ.filter (fun g : G => g ∉ hyp.toHypothesis71.hyp.dadeSupport
        ∧ (orderOf g).Coprime hyp.w1)).card
      = (Finset.univ.filter (fun g : G => g ∉ hyp.dadeData.dade.dadeSupport
          ∧ (orderOf g).Coprime hyp.w1)).card := by
    congr 1
    refine Finset.filter_congr fun g _ => ?_
    constructor
    · rintro ⟨hgR, hgcop⟩
      exact ⟨fun hgF => hgR (hyp.mem_restricted_dadeSupport_of_coprime hgF hgcop), hgcop⟩
    · rintro ⟨hgF, hgcop⟩
      exact ⟨fun hgR => hgF (hRF hgR), hgcop⟩
  -- the non-coprime part is covered by `𝒞((S_F)#) ∪ 𝒞(V_S)`
  have hsub : {g : G | g ∉ hyp.toHypothesis71.hyp.dadeSupport
        ∧ ¬ (orderOf g).Coprime hyp.w1}
      ⊆ conjClassSet ((data.H : Set G) \ {1}) ∪ conjClassSet (typePV S data) := by
    rintro g ⟨-, hgnc⟩
    exact mem_conjClassSet_sharpH_or_typePV_of_not_coprime data hprime hcop hHall hcent
      hfrobcap (by rwa [hW2card])
  have hnc_le : (Finset.univ.filter (fun g : G => g ∉ hyp.toHypothesis71.hyp.dadeSupport
        ∧ ¬ (orderOf g).Coprime hyp.w1)).card
      ≤ (Nat.card ↥data.H - 1) * S.index
        + (Nat.card ↥data.W1 * Nat.card ↥data.W2 - Nat.card ↥data.W1
            - Nat.card ↥data.W2 + 1) * data.W.index := by
    calc (Finset.univ.filter (fun g : G => g ∉ hyp.toHypothesis71.hyp.dadeSupport
          ∧ ¬ (orderOf g).Coprime hyp.w1)).card
        = {g : G | g ∉ hyp.toHypothesis71.hyp.dadeSupport
            ∧ ¬ (orderOf g).Coprime hyp.w1}.ncard := by
          rw [Set.ncard_eq_toFinset_card', Set.toFinset_ofPred]
      _ ≤ (conjClassSet ((data.H : Set G) \ {1})
            ∪ conjClassSet (typePV S data)).ncard :=
          Set.ncard_le_ncard hsub (Set.toFinite _)
      _ ≤ (conjClassSet ((data.H : Set G) \ {1})).ncard
            + (conjClassSet (typePV S data)).ncard := Set.ncard_union_le _ _
      _ ≤ _ := by
          rw [typePData_conjClassSet_typePV_ncard]
          exact Nat.add_le_add_right (ncard_conjClassSet_sharp_H_le data) _
  rw [hcard0, hsplit, hcopeq]
  exact Nat.add_le_add_left hnc_le _

open scoped Classical FiniteInduce in
/-- **The (10.8) `hB` bound** (p. 60 lines 89–91, the rational form consumed by
`typeII_coherence_contradiction_estimate_of_partner`): with the type-II partner data supplied,

`(|famG₀| − #{g ∉ Ã₀, (|g|, w₁) = 1}) / |G| ≤ (|S_F| − 1)/|S| + (w₁w₂ − w₁ − w₂ + 1)/(w₁w₂)`.

The rational form of `g1_card_le_of_partner`, divided by `|G| = |S|·[G:S] = |W|·[G:W]`. -/
theorem Hypothesis.g1_div_le_of_partner [Finite G] {M S : Subgroup G} (hyp : Hypothesis M)
    (data : TypePData S) (hprime : (Nat.card ↥data.W1).Prime)
    (hcop : Nat.Coprime (Nat.card ↥(derivedInG S)) (Nat.card ↥data.W1))
    (hHall : OddOrder.Isaacs.Ch03.IsHallSubgroup (Nat.card ↥data.H).primeFactors data.H)
    (hcent : ∀ b ∈ data.H, b ≠ 1 → Subgroup.centralizer ({b} : Set G) ≤ S)
    (hfrobcap : ∀ b ∈ data.H, b ≠ 1 → ∀ y ∈ derivedInG S,
      y ∈ Subgroup.centralizer ({b} : Set G) → y ∈ data.H)
    (hW1card : Nat.card ↥data.W1 = hyp.w2) (hW2card : Nat.card ↥data.W2 = hyp.w1)
    (hWcard : Nat.card ↥data.W = hyp.w1 * hyp.w2) :
    ((Nat.card (hyp.toFamilyHypothesis71).G0 : ℚ)
        - ((Finset.univ.filter (fun g : G => g ∉ hyp.dadeData.dade.dadeSupport
            ∧ (orderOf g).Coprime hyp.w1)).card : ℚ)) / (Nat.card G : ℚ)
      ≤ ((Nat.card ↥data.H : ℚ) - 1) / (Nat.card ↥S : ℚ)
        + ((hyp.w1 : ℚ) * hyp.w2 - hyp.w1 - hyp.w2 + 1) / ((hyp.w1 : ℚ) * hyp.w2) := by
  classical
  have hNat := hyp.g1_card_le_of_partner data hprime hcop hHall hcent hfrobcap hW2card
  -- cardinalities and nonvanishing
  have hcH : 1 ≤ Nat.card ↥data.H := Nat.card_pos
  have hcW1 : 2 ≤ Nat.card ↥data.W1 :=
    (Subgroup.one_lt_card_iff_ne_bot _).mpr data.W1_nontrivial
  have hcW2 : 2 ≤ Nat.card ↥data.W2 :=
    (Subgroup.one_lt_card_iff_ne_bot _).mpr data.W2_nontrivial
  have hsub1 : Nat.card ↥data.W1 ≤ Nat.card ↥data.W1 * Nat.card ↥data.W2 :=
    Nat.le_mul_of_pos_right _ (by omega)
  have hsub2 : Nat.card ↥data.W2
      ≤ Nat.card ↥data.W1 * Nat.card ↥data.W2 - Nat.card ↥data.W1 := by
    have hfac : Nat.card ↥data.W1 * Nat.card ↥data.W2 - Nat.card ↥data.W1
        = Nat.card ↥data.W1 * (Nat.card ↥data.W2 - 1) := by
      rw [Nat.mul_sub, mul_one]
    rw [hfac]
    calc Nat.card ↥data.W2 ≤ 2 * (Nat.card ↥data.W2 - 1) := by omega
      _ ≤ Nat.card ↥data.W1 * (Nat.card ↥data.W2 - 1) :=
          Nat.mul_le_mul_right _ hcW1
  have hSidx0 : (S.index : ℚ) ≠ 0 := by
    exact_mod_cast Subgroup.index_ne_zero_of_finite
  have hWidx0 : (data.W.index : ℚ) ≠ 0 := by
    exact_mod_cast Subgroup.index_ne_zero_of_finite
  have hG0 : (0 : ℚ) < (Nat.card G : ℚ) := by exact_mod_cast Nat.card_pos
  -- `|G| = |S|·[G:S]` and `|G| = |W|·[G:W]`, in `ℚ`
  have hGS : (Nat.card G : ℚ) = (Nat.card ↥S : ℚ) * (S.index : ℚ) := by
    exact_mod_cast (Subgroup.card_mul_index S).symm
  have hGW : (Nat.card G : ℚ) = (Nat.card ↥data.W : ℚ) * (data.W.index : ℚ) := by
    exact_mod_cast (Subgroup.card_mul_index data.W).symm
  -- the numerator bound, cast to `ℚ`
  have hnum : (Nat.card (hyp.toFamilyHypothesis71).G0 : ℚ)
      - ((Finset.univ.filter (fun g : G => g ∉ hyp.dadeData.dade.dadeSupport
          ∧ (orderOf g).Coprime hyp.w1)).card : ℚ)
      ≤ ((Nat.card ↥data.H : ℚ) - 1) * (S.index : ℚ)
        + ((Nat.card ↥data.W1 : ℚ) * (Nat.card ↥data.W2 : ℚ) - (Nat.card ↥data.W1 : ℚ)
            - (Nat.card ↥data.W2 : ℚ) + 1) * (data.W.index : ℚ) := by
    have hc := (Nat.cast_le (α := ℚ)).mpr hNat
    push_cast [Nat.cast_sub hcH, Nat.cast_sub hsub1, Nat.cast_sub hsub2] at hc
    linarith
  -- divide by `|G|` and split into the two orbit terms
  calc ((Nat.card (hyp.toFamilyHypothesis71).G0 : ℚ)
        - ((Finset.univ.filter (fun g : G => g ∉ hyp.dadeData.dade.dadeSupport
            ∧ (orderOf g).Coprime hyp.w1)).card : ℚ)) / (Nat.card G : ℚ)
      ≤ (((Nat.card ↥data.H : ℚ) - 1) * (S.index : ℚ)
          + ((Nat.card ↥data.W1 : ℚ) * (Nat.card ↥data.W2 : ℚ) - (Nat.card ↥data.W1 : ℚ)
              - (Nat.card ↥data.W2 : ℚ) + 1) * (data.W.index : ℚ)) / (Nat.card G : ℚ) := by
        gcongr
    _ = ((Nat.card ↥data.H : ℚ) - 1) / (Nat.card ↥S : ℚ)
          + ((Nat.card ↥data.W1 : ℚ) * (Nat.card ↥data.W2 : ℚ) - (Nat.card ↥data.W1 : ℚ)
              - (Nat.card ↥data.W2 : ℚ) + 1) / (Nat.card ↥data.W : ℚ) := by
        rw [add_div]
        congr 1
        · rw [hGS, mul_div_mul_right _ _ hSidx0]
        · rw [hGW, mul_div_mul_right _ _ hWidx0]
    _ = ((Nat.card ↥data.H : ℚ) - 1) / (Nat.card ↥S : ℚ)
          + ((hyp.w1 : ℚ) * hyp.w2 - hyp.w1 - hyp.w2 + 1) / ((hyp.w1 : ℚ) * hyp.w2) := by
        have e1 : (Nat.card ↥data.W1 : ℚ) = (hyp.w2 : ℚ) := by exact_mod_cast hW1card
        have e2 : (Nat.card ↥data.W2 : ℚ) = (hyp.w1 : ℚ) := by exact_mod_cast hW2card
        have e3 : (Nat.card ↥data.W : ℚ) = (hyp.w1 : ℚ) * (hyp.w2 : ℚ) := by
          exact_mod_cast hWcard
        rw [e1, e2, e3]
        ring

/-- **Type-`P` order factorization** `|M| = |M_F|·|U|·|W₁|`.  The type-`P` decomposition is a double
semidirect product `M = (H ⋊ U) ⋊ W₁`: `W₁` complements the derived subgroup `M' = [M,M]` in `M`
(`M_complement`, `|M| = |M'|·|W₁|`), and `U` complements the Fitting kernel `H = M_F` in `M'`
(`derived_complement`, `|M'| = |H|·|U|`).  For the Type-II partner `S` with `|W₁(S)| = w₂` this is
the `|S| = |S_F|·|U|·w₂` input (`hS`) to Peterfalvi (10.8)'s coherence estimate. -/
theorem typePData_card_eq_H_mul_U_mul_W1 [Finite G] {M : Subgroup G} (data : TypePData M) :
    Nat.card ↥M = Nat.card ↥data.H * Nat.card ↥data.U * Nat.card ↥data.W1 := by
  have hM'le : derivedInG M ≤ M := Subgroup.map_subtype_le _
  -- `|M'|·|W₁| = |M|` (the `M = M' ⋊ W₁` complement).
  have h1 : Nat.card ↥(derivedInG M) * Nat.card ↥data.W1 = Nat.card ↥M := by
    rw [← Nat.card_congr (Subgroup.subgroupOfEquivOfLe hM'le).toEquiv,
      ← Nat.card_congr (Subgroup.subgroupOfEquivOfLe data.W1_le).toEquiv]
    exact data.M_complement.card_mul_card
  -- `|H|·|U| = |M'|` (the `M' = H ⋊ U` complement).
  have h2 : Nat.card ↥data.H * Nat.card ↥data.U = Nat.card ↥(derivedInG M) := by
    rw [← Nat.card_congr (Subgroup.subgroupOfEquivOfLe data.H_le).toEquiv,
      ← Nat.card_congr (Subgroup.subgroupOfEquivOfLe data.U_le).toEquiv]
    exact data.derived_complement.card_mul_card
  calc Nat.card ↥M = Nat.card ↥(derivedInG M) * Nat.card ↥data.W1 := h1.symm
    _ = Nat.card ↥data.H * Nat.card ↥data.U * Nat.card ↥data.W1 := by rw [← h2]

open scoped Classical FiniteInduce in
open OddOrder.Peterfalvi.S09 in
open OddOrder.Peterfalvi.S09.Cert in
/-- **Peterfalvi (10.8), line 87 lower bound — the (7.8.b) ρ-norm bound for `ζ^{τ₁}`**:
`‖ζ^{τ₁,ρ}‖² ≥ 1 − ŵ₁/|M'|`.

This is Peterfalvi (7.8.b) specialised to the coherent extension `τ₁` of `ζ ∈ 𝒮` in the present
type-`P` `Hypothesis M`.  It is the M-side analogue of the §14 pattern
`MHypothesis.rhoNormSq_ge_lower` (`S16_NonExistenceG.lean`), which couples the `ρ`-norm to the
(7.8.b) Dade-integral engine `zetaNuRhoNormSqGeOfDade` (`S09_CertificateDischarge.lean`) via a
`Hypothesis78`-for-`M` certificate (`H = M'`, `ν = coh.tau1`).  Together with the proven line-83
**upper** bound (`chiRhoNormSq_zeta_le_line83`) and the strict `|A(M)|/|M| < 1/w₁`
(`card_typePA_div_card_lt_inv_w1`) this closes the (10.8) estimate's `hA` (line 87).

**Genuine, ungated lane-a gate** (the last §7 char-theoretic input to `hA`): the honest route is the
S16 `chiRhoNormSq_eq_zetaNuRhoNormSq` coupling ported to type-`P` `M`; it does **not** depend on the
(10.7) partner Frobenius structure (that gates only `hB`).  See
`notes/peterfalvi/s10_7_derived_frobenius.md` (2026-07-08 update²).

**Proof (type-`P` port of S16 `exists_M_hypothesis78`)**: assemble a §7 Dade certificate
`S09.Hypothesis78 G (typePA M) M` with `H = M' = derivedInG M`, `K = M'.subgroupOf M`, distinguished
`ζ_0 = Ind_K θ_0 = params.zeta` (placed by `exists_placed_induced_family`), and `ν = coh.tau1`, then
feed the (7.8.b) Dade-integral engine `zetaNuRhoNormSqGeOfDade`.  The `(7.8.a)` agreement `hagree`
bridges the *restricted* Dade map `toHypothesis71.τ` (over `A(M)`) to the *full* map
(`coherence_hagree_dadeMap`, over `A_0(M)`) via `S04.FullDadeIsometryData.restrict_apply`; the
`ζ_0^ν ⊥ 1_G` fact is `coherence_extension_orthogonal_constOne` (using the conjugate member `ζ̄_0`);
`2e+1 ≤ h` is `card_derived_ge`.  The engine bound `1 − e/h ≤ ‖ζ_0^{νρ}‖²` is then rewritten to the
goal via `e = w₁`, `h = |M'|`, and the `chiRhoNormSq = zetaNuRhoNormSq` bridge (mirroring
S16 `chiRhoNormSq_eq_zetaNuRhoNormSq`). -/
theorem Hypothesis.chiRhoNormSq_zeta_ge_line78 [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) :
    (1 : ℝ) - (hyp.w1 : ℝ) / (Nat.card ↥(derivedInG M) : ℝ)
      ≤ (hyp.toFamilyHypothesis71).chiRhoNormSq (coh.tau1 params.zeta) 0 := by
  have := hyp.finiteG
  classical
  -- **Setup**: `H = M' = derivedInG M`, `K = M'.subgroupOf M ⊴ M`.
  have hHL : derivedInG M ≤ M := Subgroup.map_subtype_le _
  have hKnormal0 : ((derivedInG M).subgroupOf M).Normal := by
    rw [derivedInG, Subgroup.subgroupOf,
      Subgroup.comap_map_eq_self_of_injective M.subtype_injective]
    infer_instance
  set K : Subgroup ↥M := (derivedInG M).subgroupOf M with hKdef
  have : K.Normal := hKnormal0
  have hHnorm : ∀ (l : ↥M) ⦃h : G⦄, h ∈ derivedInG M →
      (↑l : G) * h * (↑l : G)⁻¹ ∈ derivedInG M := by
    intro l h hh
    have hhM : h ∈ M := hHL hh
    have hmem : (⟨h, hhM⟩ : ↥M) ∈ K := (Subgroup.mem_subgroupOf).mpr hh
    have hconj := hKnormal0.conj_mem ⟨h, hhM⟩ hmem l
    rw [Subgroup.mem_subgroupOf] at hconj
    simpa using hconj
  have hAH : typePA M hyp.typeP = (derivedInG M : Set G) \ {1} :=
    typePA_eq_sharpSubgroup_derivedInG M hyp.typeP
  -- `M`-stability of `A(M) = typePA` (the input to `toHypothesis71`).
  have hnorm : ∀ (l : ↥M) ⦃a : G⦄, a ∈ typePA M hyp.typeP →
      (↑l : G) * a * (↑l : G)⁻¹ ∈ typePA M hyp.typeP := fun l a ha =>
    ((Subgroup.mem_set_normalizer_iff).mp (hyp.le_normalizer_typePA l.2) a).mp ha
  -- **Placed induced family** with the distinguished `ζ_0 = Ind_K θ_0 = params.zeta`.
  obtain ⟨θz, hθz_ne, hθz_eq⟩ := hzS
  have hχ_range : params.zeta ∈ Set.range
      (fun φ : IrreducibleCharacter ↥K =>
        ClassFunction.induce K (φ : ClassFunction ↥K ℂ)) :=
    ⟨θz, hθz_eq.symm⟩
  have hχ_ne : params.zeta ≠ ClassFunction.induce K
      (trivialIrreducibleCharacter ↥K : ClassFunction ↥K ℂ) := by
    rw [hθz_eq]; exact induce_ne_trivialChar_induce K θz hθz_ne
  obtain ⟨n, θ, ind1H, hind1H, hθ0eq, htriv, hinj, hcover⟩ :=
    exists_placed_induced_family K params.zeta hχ_range hχ_ne
  have hne_triv : ∀ i : Fin (n + 1), i ≠ ind1H →
      θ i ≠ trivialIrreducibleCharacter ↥K := by
    intro i hi hcontra
    apply hi; apply hinj
    change ClassFunction.induce K (θ i : ClassFunction ↥K ℂ)
      = ClassFunction.induce K (θ ind1H : ClassFunction ↥K ℂ)
    rw [hcontra, htriv]
  have hSmem : ∀ i : Fin (n + 1), i ≠ ind1H →
      ClassFunction.induce K (θ i : ClassFunction ↥K ℂ) ∈ hyp.Sset :=
    fun i hi => ⟨θ i, hne_triv i hi, rfl⟩
  -- **Degrees**: `d i = θ_i(1)`, `Ind(θ_0)(1) = [M:K] = w₁`, and `|M| = w₁·|M'|`.
  have hKindex : K.index = hyp.w1 := by
    rw [hKdef, Hypothesis.w1, Hypothesis.W1]; exact hyp.typeP.card_W1_eq_derived_index.symm
  have hcardM : Nat.card ↥M = hyp.w1 * Nat.card ↥(derivedInG M) := by
    have hsub : Nat.card ↥K = Nat.card ↥(derivedInG M) := by
      rw [hKdef]; exact Nat.card_congr (Subgroup.subgroupOfEquivOfLe hHL).toEquiv
    rw [← Subgroup.index_mul_card K, hKindex, hsub]
  let d : Fin (n + 1) → ℂ := fun i => (θ i : ClassFunction ↥K ℂ) (1 : ↥K)
  have hd : ∀ i, d i = (θ i : ClassFunction ↥K ℂ) (1 : ↥K) := fun _ => rfl
  have hz0eq : ClassFunction.induce K (θ 0 : ClassFunction ↥K ℂ) (1 : ↥M)
      = params.zeta 1 := by rw [hθ0eq]
  have hdeg0 : ClassFunction.induce K (θ 0 : ClassFunction ↥K ℂ) (1 : ↥M)
      = (K.index : ℂ) := by
    rw [hz0eq, hz1, hKindex]
  have hdeg : ∀ i, ClassFunction.induce K (θ i : ClassFunction ↥K ℂ) (1 : ↥M)
      = d i * ClassFunction.induce K (θ 0 : ClassFunction ↥K ℂ) (1 : ↥M) := by
    intro i
    rw [ClassFunction.induce_apply_one K (θ i : ClassFunction ↥K ℂ), hdeg0, hd i]; ring
  have hdeg_match : ClassFunction.induce K (θ 0 : ClassFunction ↥K ℂ) (1 : ↥M)
      = ClassFunction.induce K (θ ind1H : ClassFunction ↥K ℂ) (1 : ↥M) := by
    rw [hdeg0, htriv]
    exact (induce_trivialChar_apply_eq_index K (Subgroup.one_mem _)).symm
  -- **Support** of the difference vectors in `A(M) = (M')#` and in `A_0(M)`.
  have psi_support : ∀ i, (ClassFunction.induce K (θ i : ClassFunction ↥K ℂ)
        - d i • ClassFunction.induce K (θ 0 : ClassFunction ↥K ℂ)).support
      ⊆ OddOrder.Peterfalvi.S04.supportInSubgroup (typePA M hyp.typeP) M := by
    intro i
    refine (induce_diff_support (θ i) (θ 0) (d i) (hdeg i)).trans ?_
    intro x hx
    rw [Set.mem_sdiff, SetLike.mem_coe, Set.mem_singleton_iff] at hx
    exact (mem_supportInSubgroup_sharp_subgroupOf_iff (derivedInG M) hAH x).mpr ⟨hx.1, hx.2⟩
  have hsupp_full : ∀ i, (ClassFunction.induce K (θ i : ClassFunction ↥K ℂ)
        - d i • ClassFunction.induce K (θ 0 : ClassFunction ↥K ℂ)).support
      ⊆ OddOrder.Peterfalvi.S04.supportInSubgroup (typePA0 M hyp.typeP) M := by
    intro i
    refine (psi_support i).trans ?_
    intro x hx
    rw [OddOrder.Peterfalvi.S04.mem_supportInSubgroup] at hx ⊢
    exact Set.mem_union_left _ hx
  have hzeta_ind1H : θ ind1H = trivialIrreducibleCharacter ↥K := htriv
  -- The restricted Dade isometry certificate for `H71.τ = toHypothesis71.τ`.
  have hτ : OddOrder.Peterfalvi.S04.IsDadeIsometry (G := G) (k := ℂ) (L := M)
      hyp.toHypothesis71.τ :=
    ((hyp.dadeData.dade.fullDadeIsometryData).restrict Set.subset_union_left
      hnorm).toDadeIsometryData.isDadeIsometry
  -- **`ν`-isometry** on the family (`ν = coh.tau1 = coherent extension`).
  have hnu_isometry : ∀ i j : Fin (n + 1), i ≠ ind1H → j ≠ ind1H →
      ClassFunction.inner (coh.tau1 (ClassFunction.induce K (θ i : ClassFunction ↥K ℂ)))
          (coh.tau1 (ClassFunction.induce K (θ j : ClassFunction ↥K ℂ)))
        = ClassFunction.inner (ClassFunction.induce K (θ i : ClassFunction ↥K ℂ))
          (ClassFunction.induce K (θ j : ClassFunction ↥K ℂ)) :=
    fun i j hi hj => coherence_extension_inner_eq_on_family coh.coherent (hSmem i hi) (hSmem j hj)
  -- **(7.8.a) agreement** — the restricted-vs-full Dade-map bridge.
  have hagree : ∀ i : Fin (n + 1), i ≠ 0 → i ≠ ind1H →
      hyp.toHypothesis71.τ ⟨ClassFunction.induce K (θ i : ClassFunction ↥K ℂ)
          - d i • ClassFunction.induce K (θ 0 : ClassFunction ↥K ℂ), psi_support i⟩
        = coh.tau1 (ClassFunction.induce K (θ i : ClassFunction ↥K ℂ))
          - d i • coh.tau1 (ClassFunction.induce K (θ 0 : ClassFunction ↥K ℂ)) := by
    intro i hi0 hi_ind
    obtain ⟨deg_i, -, hdeg_i_eq⟩ := irreducibleCharacter_apply_one_eq_pos_natCast (θ i)
    have hcohag := coherence_hagree_dadeMap hyp.dadeData.dade coh.coherent
      (hSmem i hi_ind) (hSmem 0 (Ne.symm hind1H)) (m0 := 1) (mi := deg_i) (by norm_num)
      (by rw [hd i, hdeg_i_eq, Nat.cast_one, div_one]) (hsupp_full i)
    have hbridge : hyp.toHypothesis71.τ ⟨ClassFunction.induce K (θ i : ClassFunction ↥K ℂ)
          - d i • ClassFunction.induce K (θ 0 : ClassFunction ↥K ℂ), psi_support i⟩
        = (hyp.dadeData.dade.fullDadeIsometryData).toDadeMap
          ⟨ClassFunction.induce K (θ i : ClassFunction ↥K ℂ)
            - d i • ClassFunction.induce K (θ 0 : ClassFunction ↥K ℂ),
            (ClassFunction.mem_supportedSubmodule).mpr (hsupp_full i)⟩ := by
      change ((hyp.dadeData.dade.fullDadeIsometryData).restrict Set.subset_union_left
          hnorm).toDadeMap ⟨_, psi_support i⟩ = _
      -- `restrict_apply` は `rfl` なので `exact` が直接見通す (v4.33 では `rw` が照合できない)
      exact congrArg _ (Subtype.ext rfl)
    rw [hbridge]; exact hcohag
  -- **Assemble** the (7.8) Dade certificate.
  set H78 := hypothesis78OfDade hyp.toHypothesis71 hτ (derivedInG M) hHL hHnorm hAH θ hinj hcover
    d psi_support hdeg ind1H hind1H hzeta_ind1H hdeg_match coh.tau1 hnu_isometry hagree
    with hH78def
  -- `e = [M:M'] = w₁`, `h = |M'|`.
  have hci : H78.complementIndex = hyp.w1 := by
    have hcieq : H78.complementIndex = Nat.card ↥M / Nat.card ↥(derivedInG M) := rfl
    rw [hcieq, hcardM, Nat.mul_div_cancel _ Nat.card_pos]
  have hko : H78.kernelOrder = Nat.card ↥(derivedInG M) := rfl
  have hsmall : H78.smallIndex := by
    change 2 * H78.complementIndex + 1 ≤ H78.kernelOrder
    rw [hci, hko]
    have hMp := hyp.card_derived_ge hG
    have hw2 : 0 < hyp.w2 := Nat.card_pos
    calc 2 * hyp.w1 + 1 = (2 * hyp.w1 + 1) * 1 := (mul_one _).symm
      _ ≤ (2 * hyp.w1 + 1) * hyp.w2 := Nat.mul_le_mul_left _ hw2
      _ ≤ Nat.card ↥(derivedInG M) := hMp
  -- **(7.8.a) coefficient** `a`.
  obtain ⟨a, ha⟩ := exists_betaDecomp_a H78
    (Submodule.sub_mem _
      (ClassFunction.induce_mem_ZIrr K (θ ind1H).property.mem_ZIrr)
      (ClassFunction.induce_mem_ZIrr K (θ 0).property.mem_ZIrr))
    (coh.coherent.extension_mem_ZIrr _ (Submodule.subset_span (hSmem 0 (Ne.symm hind1H))))
  -- **`ζ_0^ν ⊥ 1_G`** via the conjugate member `ζ̄_0 = Ind_K θ̄_0 ∈ S`.
  obtain ⟨θ0', hθ0'coe⟩ : ∃ t : IrreducibleCharacter ↥K,
      (t : ClassFunction ↥K ℂ) = (θ 0 : ClassFunction ↥K ℂ).conj :=
    ⟨⟨(θ 0 : ClassFunction ↥K ℂ).conj, (θ 0).isIrreducible.conj⟩, rfl⟩
  have hθ0_ne : θ 0 ≠ trivialIrreducibleCharacter ↥K := hne_triv 0 (Ne.symm hind1H)
  have hθ0'_ne : θ0' ≠ trivialIrreducibleCharacter ↥K := by
    intro h
    apply hθ0_ne
    have hcoe : (θ 0 : ClassFunction ↥K ℂ).conj = trivialClassFunction ↥K := by
      rw [← hθ0'coe]
      simpa using congrArg (fun c : IrreducibleCharacter ↥K => (c : ClassFunction ↥K ℂ)) h
    apply Subtype.ext
    change (θ 0 : ClassFunction ↥K ℂ) = trivialClassFunction ↥K
    rw [← ClassFunction.conj_conj (θ 0 : ClassFunction ↥K ℂ), hcoe]
    exact trivialClassFunction_isReal
  have hnorm0 : ClassFunction.inner (ClassFunction.induce K (θ 0 : ClassFunction ↥K ℂ))
      (ClassFunction.induce K (θ 0 : ClassFunction ↥K ℂ)) = 1 := by
    rw [hθ0eq]
    simpa using irreducibleCharacter_inner_eq_ite
      (⟨params.zeta, params.zeta_irreducible⟩ : IrreducibleCharacter ↥M)
      (⟨params.zeta, params.zeta_irreducible⟩ : IrreducibleCharacter ↥M)
  have hnorm0' : ClassFunction.inner (ClassFunction.induce K (θ0' : ClassFunction ↥K ℂ))
      (ClassFunction.induce K (θ0' : ClassFunction ↥K ℂ)) = 1 := by
    rw [hθ0'coe, ← ClassFunction.induce_conj, inner_conj_conj, hnorm0, star_one]
  have hne_zeta : (⟨params.zeta, params.zeta_irreducible⟩ : IrreducibleCharacter ↥M)
      ≠ ⟨params.zeta.conj, params.zeta_irreducible.conj⟩ := by
    intro h
    exact hzconj
      (congrArg (fun c : IrreducibleCharacter ↥M => (c : ClassFunction ↥M ℂ)) h).symm
  have horth : ClassFunction.inner (ClassFunction.induce K (θ 0 : ClassFunction ↥K ℂ))
      (ClassFunction.induce K (θ0' : ClassFunction ↥K ℂ)) = 0 := by
    rw [hθ0'coe, ← ClassFunction.induce_conj, hθ0eq]
    have hite := irreducibleCharacter_inner_eq_ite
      (⟨params.zeta, params.zeta_irreducible⟩ : IrreducibleCharacter ↥M)
      (⟨params.zeta.conj, params.zeta_irreducible.conj⟩ : IrreducibleCharacter ↥M)
    rw [if_neg hne_zeta] at hite
    simpa using hite
  have hdeg' : ClassFunction.induce K (θ0' : ClassFunction ↥K ℂ) (1 : ↥M)
      = 1 * ClassFunction.induce K (θ 0 : ClassFunction ↥K ℂ) (1 : ↥M) := by
    rw [one_mul, ClassFunction.induce_apply_one, ClassFunction.induce_apply_one]
    congr 1
    rw [hθ0'coe, ClassFunction.conj_apply]
    obtain ⟨m, -, hm⟩ := irreducibleCharacter_apply_one_eq_pos_natCast (θ 0)
    rw [hm, star_natCast]
  have hsupp : (ClassFunction.induce K (θ0' : ClassFunction ↥K ℂ)
        - ClassFunction.induce K (θ 0 : ClassFunction ↥K ℂ)).support ⊆ hyp.A0 := by
    have hds := induce_diff_support θ0' (θ 0) 1 hdeg'
    rw [one_smul] at hds
    intro x hx
    have hxd := hds hx
    rw [Set.mem_sdiff, SetLike.mem_coe, Set.mem_singleton_iff] at hxd
    have hmem := (mem_supportInSubgroup_sharp_subgroupOf_iff (derivedInG M) hAH x).mpr
      ⟨hxd.1, hxd.2⟩
    change x ∈ OddOrder.Peterfalvi.S04.supportInSubgroup (typePA0 M hyp.typeP) M
    rw [OddOrder.Peterfalvi.S04.mem_supportInSubgroup] at hmem ⊢
    exact Set.mem_union_left _ hmem
  have hζ0_1 : ClassFunction.inner (ClassFunction.induce K (θ 0 : ClassFunction ↥K ℂ))
      (Hypothesis71.constOne ↥M) = 0 := inner_induce_constOne_eq_zero K (θ 0) hθ0_ne
  have hζ0'_1 : ClassFunction.inner (ClassFunction.induce K (θ0' : ClassFunction ↥K ℂ))
      (Hypothesis71.constOne ↥M) = 0 := inner_induce_constOne_eq_zero K θ0' hθ0'_ne
  have hτ_smul : ∀ (c : ℂ) (x : ClassFunction ↥M ℂ), hyp.tau (c • x) = c • hyp.tau x :=
    dadeIntegralCharacterMap_smul_complex hyp.dadeData.dade
      (hyp.dadeData.dade.fullDadeIsometryData)
  have htau1 : ∀ φ : ClassFunction ↥M ℂ, φ.support ⊆ hyp.A0 →
      ClassFunction.inner (hyp.tau φ) (Hypothesis71.constOne G)
        = ClassFunction.inner φ (Hypothesis71.constOne ↥M) := by
    intro φ hφ
    rw [show hyp.tau φ = hyp.dadeData.dade.dadeMap (k := ℂ)
        ⟨φ, (ClassFunction.mem_supportedSubmodule).mpr hφ⟩ from
      OddOrder.Peterfalvi.S07.dadeIntegralCharacterMap_apply_of_support hyp.dadeData.dade
        (hyp.dadeData.dade.fullDadeIsometryData) hφ]
    exact inner_tau_supported_constOne
      ({ hyp := hyp.dadeData.dade
         τ := hyp.dadeData.dade.dadeMap (k := ℂ)
         isDadeMap := hyp.dadeData.dade.isDadeMap_dadeMap }
        : Hypothesis71 G (typePA0 M hyp.typeP) M)
      ⟨φ, (ClassFunction.mem_supportedSubmodule).mpr hφ⟩
  have hζ0'mem : ClassFunction.induce K (θ0' : ClassFunction ↥K ℂ) ∈ hyp.Sset :=
    ⟨θ0', hθ0'_ne, rfl⟩
  have hzeta0nu : ClassFunction.inner
      (coh.tau1 (ClassFunction.induce K (θ 0 : ClassFunction ↥K ℂ)))
      (Hypothesis71.constOne G) = 0 :=
    coherence_extension_orthogonal_constOne coh.coherent hτ_smul htau1
      (hSmem 0 (Ne.symm hind1H)) hζ0'mem hnorm0 hnorm0' horth hsupp hζ0_1 hζ0'_1
  -- **The (7.8.b) engine bound** `1 − e/h ≤ ‖ζ_0^{νρ}‖²`.
  have hbound : (1 : ℝ) - (H78.complementIndex : ℝ) / (H78.kernelOrder : ℝ)
      ≤ H78.zetaNuRhoNormSq :=
    zetaNuRhoNormSqGeOfDade hyp.toHypothesis71 hτ (derivedInG M) hHL hHnorm hAH θ hinj hcover d
      psi_support hdeg ind1H hind1H hzeta_ind1H hdeg_match coh.tau1 hnu_isometry hagree hzeta0nu
      hnorm0 a ha hsmall
  -- **Norm bridge** `chiRhoNormSq = zetaNuRhoNormSq` (mirrors S16's norm-bridge lemma).
  have hpsi : coh.tau1 params.zeta = H78.nu (H78.hyp76.zeta H78.zetaDistinct) := by
    change coh.tau1 params.zeta = coh.tau1 (ClassFunction.induce K (θ 0 : ClassFunction ↥K ℂ))
    rw [hθ0eq]
  have hnorm_eq : (hyp.toFamilyHypothesis71).chiRhoNormSq (coh.tau1 params.zeta) 0
      = H78.zetaNuRhoNormSq := by
    have hH71 : H78.hyp76.hyp71 = hyp.toHypothesis71 := rfl
    have hcf : ((hyp.toFamilyHypothesis71).hyp71 0).chiRhoCF (coh.tau1 params.zeta)
        = H78.zetaNuRho := by
      change hyp.toHypothesis71.chiRhoCF (coh.tau1 params.zeta) = H78.zetaNuRho
      rw [Hypothesis78.zetaNuRho, hH71, ← hpsi]
    simp only [FamilyHypothesis71.chiRhoNormSq, Hypothesis78.zetaNuRhoNormSq, hcf]
    congr 1
  rw [hnorm_eq, ← hci, ← hko]
  exact hbound

open scoped Classical FiniteInduce in
/-- **The (10.8) coherence-contradiction estimate, partner-supplied form** (issue 1020
Phase 3): the norm-counting estimate with the Type-II partner and its §8/(10.7) supply
facts taken as hypotheses, so that `hB` is discharged by `g1_div_le_of_partner`.  The
unconditional form is assembled downstream (`S12_Noncoherence`), where the pair machinery
provides the supply; see issue 1020.  (The former in-file legacy instantiation — the
bare-sorry `hB` estimate and the legacy `S_not_coherent` — is retired, issue 9087.) -/
theorem typeII_coherence_contradiction_estimate_of_partner [Finite G]
    (hG : OddOrder.BG.IsMinimalSimpleOdd G) {M : Subgroup G}
    {hyp : Hypothesis M} {params : CharacterParameters hyp}
    (coh : CoherentHypothesis hyp params)
    {S : Subgroup G} (data : TypePData S)
    (hSidx : ((derivedInG S).subgroupOf S).index = hyp.w2)
    (hU7 : 7 ≤ Nat.card ↥data.U)
    (hprime : (Nat.card ↥data.W1).Prime)
    (hcop : Nat.Coprime (Nat.card ↥(derivedInG S)) (Nat.card ↥data.W1))
    (hHall : OddOrder.Isaacs.Ch03.IsHallSubgroup
      (Nat.card ↥data.H).primeFactors data.H)
    (hcent : ∀ b ∈ data.H, b ≠ 1 → Subgroup.centralizer ({b} : Set G) ≤ S)
    (hfrobcap : ∀ b ∈ data.H, b ≠ 1 → ∀ y ∈ derivedInG S,
      y ∈ Subgroup.centralizer ({b} : Set G) → y ∈ data.H)
    (hW2card : Nat.card ↥data.W2 = hyp.w1)
    (hWcard : Nat.card ↥data.W = hyp.w1 * hyp.w2) :
    ∃ u : ℕ, 7 ≤ u ∧
      (1 : ℚ) - 1 / (hyp.w1 : ℚ) - 1 / (u : ℚ)
        < (hyp.w1 : ℚ) * (hyp.w2 : ℚ) / (Nat.card ↥(derivedInG M) : ℚ) := by
  classical
  obtain ⟨params', hmu, hos, hzS, hz1, hzconj, hδpm, hδj⟩ := hyp.exists_charParameters_full hG
  let coh' : CoherentHypothesis hyp params' := ⟨coh.coherent⟩
  refine ⟨Nat.card ↥data.U, hU7, ?_⟩
  have hW1card : Nat.card ↥data.W1 = hyp.w2 := by
    rw [data.card_W1_eq_derived_index]; exact hSidx
  have hS_struct : Nat.card ↥S = Nat.card ↥data.H * Nat.card ↥data.U * hyp.w2 := by
    rw [typePData_card_eq_H_mul_U_mul_W1 data, hW1card]
  have h83 := hyp.chiRhoNormSq_zeta_le_line83 hG coh' hmu hos hzS hz1 hzconj hδpm hδj
  have h78 := hyp.chiRhoNormSq_zeta_ge_line78 hG coh' hmu hos hzS hz1 hzconj hδpm hδj
  set g1g : ℚ := ((Nat.card (hyp.toFamilyHypothesis71).G0 : ℚ)
      - ((Finset.univ.filter (fun g : G => g ∉ hyp.dadeData.dade.dadeSupport
          ∧ (orderOf g).Coprime hyp.w1)).card : ℚ)) / (Nat.card G : ℚ) with hg1g_def
  have hA : (1 : ℚ) - g1g - 1 / (hyp.w1 : ℚ)
      < (hyp.w1 : ℚ) / (Nat.card ↥(derivedInG M) : ℚ) := by
    have hpaR : (Nat.card ↥(typePA M hyp.typeP) : ℝ) / (Nat.card ↥M : ℝ)
        < 1 / (hyp.w1 : ℝ) := by
      have h := (Rat.cast_lt (K := ℝ)).mpr hyp.card_typePA_div_card_lt_inv_w1
      push_cast at h; exact h
    have hg1gR : (g1g : ℝ) = (Nat.card G : ℝ)⁻¹
        * ((Nat.card (hyp.toFamilyHypothesis71).G0 : ℝ)
          - ((Finset.univ.filter (fun g : G => g ∉ hyp.dadeData.dade.dadeSupport
              ∧ (orderOf g).Coprime hyp.w1)).card : ℝ)) := by
      rw [hg1g_def]; push_cast; rw [div_eq_inv_mul]
    rw [← Rat.cast_lt (K := ℝ)]
    push_cast
    linarith [h78, h83, hpaR, hg1gR]
  have hB : g1g ≤ ((Nat.card ↥data.H : ℚ) - 1) / (Nat.card ↥S : ℚ)
      + ((hyp.w1 : ℚ) * hyp.w2 - hyp.w1 - hyp.w2 + 1) / ((hyp.w1 : ℚ) * hyp.w2) := by
    rw [hg1g_def]
    exact hyp.g1_div_le_of_partner data hprime hcop hHall hcent hfrobcap
      hW1card hW2card hWcard
  have hw1 : 1 ≤ hyp.w1 := Nat.card_pos
  have hw2 : 1 ≤ hyp.w2 := Nat.card_pos
  have hu : 1 ≤ Nat.card ↥data.U := by omega
  have hH : 1 ≤ Nat.card ↥data.H := Nat.card_pos
  have hMp : 1 ≤ Nat.card ↥(derivedInG M) := Nat.card_pos
  exact typeII_coherence_estimate_chain hw1 hw2 hu hH hMp hS_struct hA hB

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_MaximalBasic.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