Documentation

LeanPool.RegtsSevenster.RS.Classical.Deligne.RegularSum

The regular-representation dimension bound #

For every SchurPackage and every size n, the central idempotents of the shapes of size n are pairwise orthogonal and sum to the identity of ℂ[S_n]; reading off the coefficient of the identity permutation, the squares of the dimensions sum to n! — the Wedderburn completeness of the blocks. The Cauchy–Schwarz-free consequences n! ≤ (∑ dim)² and √(n!) ≤ ∑ dim are the forms consumed by the Deligne development (Catégories tensorielles, 1.20).

The proof pins the package's characters: centrality makes them class functions, and the Frobenius field determines a class function completely, by linear independence of the completed cycle-type monomials — so they agree with the Jacobi–Trudi characters and the package idempotents are the native projectors. Orthogonality then reduces, through the action table and the faithfulness trick, to injectivity of the Schur specialisation μ ↦ diagramSchur μ, proved by evaluating at genuine variable families and extracting an alternant coefficient. Completeness is a dimension count in the centre of the group algebra against the class sums, which are no more numerous than the shapes.

Polynomial identities from evaluations #

Two multivariate polynomials over ℂ agreeing at every point are equal. (Mathlib's MvPolynomial.funext is not part of the tree's Mathlib footprint, so the finitely-many-variables case is rebuilt here from the one-variable statement.)

theorem RS.mv_eval_zero_fin (m : ℕ) (p : MvPolynomial (Fin m) ℂ) :
(∀ (x : Fin m → ℂ), (MvPolynomial.eval x) p = 0) → p = 0

A multivariate polynomial over ℂ in finitely many variables vanishing at every point is zero.

theorem RS.mv_funext_fin {m : ℕ} {p q : MvPolynomial (Fin m) ℂ} (h : ∀ (x : Fin m → ℂ), (MvPolynomial.eval x) p = (MvPolynomial.eval x) q) :
p = q

Two multivariate polynomials over ℂ in finitely many variables agreeing at every point are equal.

theorem RS.mv_eval_zero_nat (p : MvPolynomial ℕ ℂ) (hp : ∀ (x : ℕ → ℂ), (MvPolynomial.eval x) p = 0) :
p = 0

A multivariate polynomial over ℂ in countably many variables vanishing at every point is zero.

Separation by the Schur specialisation #

The Jacobi–Trudi determinant is stable under padding the row-length vector with zero rows, evaluates at genuine power sums to the polynomial Jacobi–Trudi determinant, and — through the bialternant identity and the strict alternant coefficient — separates diagrams: μ ↦ diagramSchur μ is injective.

theorem RS.det_newtonHZ_pad (t : ℕ → ℂ) (v : ℕ → ℕ) (k : ℕ) {L : ℕ} :
L ≤ k → (∀ (i : ℕ), L ≤ i → v i = 0) → (Matrix.of fun (i j : Fin k) => newtonHZ t (↑(v ↑i) + ↑↑j - ↑↑i)).det = (Matrix.of fun (i j : Fin L) => newtonHZ t (↑(v ↑i) + ↑↑j - ↑↑i)).det

Rows of zero length do not change the Jacobi–Trudi determinant: padding the row-length vector is invisible.

theorem RS.eval_hSub_univ {k : ℕ} (x : Fin k → ℂ) (m : ℕ) :

Evaluating the complete homogeneous polynomial in all variables gives the complete homogeneous value.

theorem RS.eval_hSubZ_univ {k : ℕ} (x : Fin k → ℂ) (z : ℤ) :

Evaluating the ℤ-indexed complete homogeneous polynomial gives the Newton lift of the power sums of the variables.

theorem RS.eval_jtMat_det (lam : YoungDiagram) {k : ℕ} (hk : lam.colLen 0 ≤ k) (x : Fin k → ℂ) :
(MvPolynomial.eval x) (jtMat fun (i : Fin k) => lam.rowLen ↑i).det = diagramSchur lam (pVal x)

The Jacobi–Trudi determinant of a diagram, evaluated at a variable family, is the Schur specialisation at its power sums.

theorem RS.diagramSchur_injective {lam mu : YoungDiagram} (h : ∀ (t : ℕ → ℂ), diagramSchur lam t = diagramSchur mu t) :
lam = mu

Injectivity of the Schur specialisation: diagrams with the same Schur values at every prospective power-sum sequence are equal.

Transport along an equality of sizes #

Shape.e recasts idempotents along symCast at an equality of sizes; on coefficients this is relabelling of permutations along permCast, which preserves products, inverses, and cycle types.

def RS.permCast {m n : ℕ} (h : m = n) :

Relabelling of permutations along an equality of sizes.

Equations
Instances For
    @[simp]

    At rfl, relabelling is the identity.

    theorem RS.permCast_mul {m n : ℕ} (h : m = n) (σ τ : Equiv.Perm (Fin m)) :
    (permCast h) (σ * τ) = (permCast h) σ * (permCast h) τ

    Relabelling preserves products.

    theorem RS.permCast_one {m n : ℕ} (h : m = n) :
    (permCast h) 1 = 1

    Relabelling fixes the identity.

    theorem RS.permCast_inv {m n : ℕ} (h : m = n) (σ : Equiv.Perm (Fin m)) :
    (permCast h) σ⁻¹ = ((permCast h) σ)⁻¹

    Relabelling preserves inverses.

    theorem RS.cycleType_permCast {m n : ℕ} (h : m = n) (σ : Equiv.Perm (Fin m)) :

    Relabelling preserves cycle types.

    theorem RS.symCast_le_refl {n : ℕ} (h : n ≤ n) (x : SymGroupAlgebra n) :
    (symCast h) x = x

    symCast at a reflexive inequality is the identity.

    theorem RS.symCast_apply_of_eq {m n : ℕ} (h : m = n) (x : SymGroupAlgebra m) (g : Equiv.Perm (Fin n)) :
    ((symCast ⋯) x).coeff g = x.coeff ((permCast h).symm g)

    Coefficients of a recast element are coefficients of the original, at the relabelled permutation.

    theorem RS.symCast_classElem_of_eq {m n : ℕ} (h : m = n) (c : Equiv.Perm (Fin m) → ℂ) :
    (symCast ⋯) (classElem c) = classElem fun (g : Equiv.Perm (Fin n)) => c ((permCast h).symm g)

    Recasting a class element relabels its coefficient function.

    Coefficients of the package idempotents #

    The coefficient function of P.e μ, the block-rank computation of the identity coefficient, and the conjugation invariance of the package's characters, forced by centrality.

    theorem RS.charIdempotent_eq_classElem' {n : ℕ} (d : ℕ) (χ : Equiv.Perm (Fin n) → ℂ) :
    charIdempotent d χ = classElem fun (π : Equiv.Perm (Fin n)) => ↑d / ↑n.factorial * χ π

    charIdempotent is the class element of the normalised character — no inversion invariance required.

    theorem RS.SchurPackage.e_coeff (P : SchurPackage) (μ : YoungDiagram) (π : Equiv.Perm (Fin μ.card)) :
    (P.e μ).coeff π = ↑(P.dim μ) / ↑μ.card.factorial * P.char μ π

    The coefficients of the central idempotent of a shape.

    theorem RS.SchurPackage.dim_sq_eq_coeff_one (P : SchurPackage) (μ : YoungDiagram) :
    ↑(P.dim μ) ^ 2 = ↑μ.card.factorial * (P.e μ).coeff 1

    The block rank at the identity coefficient: the square of the dimension is n! times the identity coefficient of the idempotent.

    theorem RS.SchurPackage.char_one (P : SchurPackage) (μ : YoungDiagram) :
    P.char μ 1 = ↑(P.dim μ)

    The package's character at the identity is the dimension.

    The central idempotents are nonzero.

    theorem RS.coeff_conj_of_comm {G : Type u_1} [Group G] (x : MonoidAlgebra ℂ G) (hx : ∀ (y : MonoidAlgebra ℂ G), x * y = y * x) (g c : G) :
    x.coeff (c * g * c⁻¹) = x.coeff g

    Coefficients of an element commuting with the whole group algebra are conjugation-invariant.

    theorem RS.SchurPackage.char_conj (P : SchurPackage) (μ : YoungDiagram) (g c : Equiv.Perm (Fin μ.card)) :
    P.char μ (c * g * c⁻¹) = P.char μ g

    The package's characters are class functions: conjugation invariance is forced by the centrality of the idempotents.

    The Frobenius field determines the characters #

    The completed cycle-type monomials attached to distinct cycle types are distinct monomials, hence linearly independent as functions of the prospective power sums; a class function with vanishing cycle-weighted sums at every t is therefore zero. Comparing the package's Frobenius field with the Jacobi–Trudi one pins P.char = jtChar and P.dim = nDim ∘ jtSimple, identifying the package idempotents with the native projectors.

    noncomputable def RS.cycExp {n : ℕ} (π : Equiv.Perm (Fin n)) :

    The exponent record of the completed cycle-type monomial.

    Equations
    Instances For
      theorem RS.prod_pow_toFinsupp (t : ℕ → ℂ) (m : Multiset ℕ) :
      ((Multiset.toFinsupp m).prod fun (c e : ℕ) => t c ^ e) = (Multiset.map t m).prod

      Products of powers over a multiset's counting record.

      theorem RS.eval_cycExp (t : ℕ → ℂ) {n : ℕ} (π : Equiv.Perm (Fin n)) :

      The completed cycle-type monomial evaluates to the completed cycle-type product.

      theorem RS.cycExp_eq_iff {n : ℕ} (π π' : Equiv.Perm (Fin n)) :

      The exponent record determines, and is determined by, the cycle type.

      theorem RS.classFun_eq_zero_of_cycleProd {n : ℕ} (δ : Equiv.Perm (Fin n) → ℂ) (hconj : ∀ (g c : Equiv.Perm (Fin n)), δ (c * g * c⁻¹) = δ g) (hvan : ∀ (t : ℕ → ℂ), ∑ π : Equiv.Perm (Fin n), δ π * cycleProd t π = 0) (π : Equiv.Perm (Fin n)) :
      δ π = 0

      A class function is determined by its Frobenius pairings: if all its completed cycle-weighted sums vanish, it vanishes.

      theorem RS.SchurPackage.char_eq_jtChar (P : SchurPackage) (μ : YoungDiagram) (π : Equiv.Perm (Fin μ.card)) :
      P.char μ π = jtChar μ π

      The package's characters are the Jacobi–Trudi ones.

      The package's dimensions are the native ones.

      The package idempotents are the native projectors.

      Orthogonality of the blocks #

      Distinct shapes of one size have orthogonal central idempotents: through the native action table, a common simple module would force the two Jacobi–Trudi characters to agree, hence the two Schur specialisations, hence the shapes — by the separation theorem.

      def RS.permCastHom {m n : ℕ} (h : m = n) :

      Relabelling as a homomorphism of permutation groups.

      Equations
      Instances For
        theorem RS.permCast_symm {m n : ℕ} (h : m = n) :

        The inverse of a relabelling is the reverse relabelling.

        Pulling a representation back along a relabelling preserves irreducibility.

        theorem RS.e_mul_e_eq_zero_of_ne (P : SchurPackage) {n : ℕ} (lam mu : YoungDiagram) (hl : lam.card = n) (hm : mu.card = n) (hne : lam ≠ mu) :
        (symCast ⋯) (P.e lam) * (symCast ⋯) (P.e mu) = 0

        Orthogonality of the recast idempotents, unbundled form: distinct diagrams of one size have orthogonal idempotents.

        theorem RS.SchurPackage.shape_e_orthogonal (P : SchurPackage) {n : ℕ} (μ ν : Shape n) (hμν : μ ≠ ν) :
        Shape.e P μ * Shape.e P ν = 0

        Orthogonality of the blocks: distinct shapes of one size have orthogonal recast idempotents.

        Completeness of the blocks #

        The recast idempotents are linearly independent — orthogonal nonzero idempotents — and all lie in the span of the class sums, which is at most p(n)-dimensional; as there are exactly p(n) shapes, they must span, and expanding the identity over them forces every coefficient to be 1.

        noncomputable def RS.fullPartition {n : ℕ} (π : Equiv.Perm (Fin n)) :

        The full cycle type of a permutation of Fin n, completed by its fixed points: a partition of n.

        Equations
        Instances For

          The full cycle type determines the cycle type.

          noncomputable def RS.classSum (n : ℕ) (ρ : n.Partition) :

          The class sum of a full cycle type.

          Equations
          Instances For
            theorem RS.classElem_mem_span_classSum {n : ℕ} (c : Equiv.Perm (Fin n) → ℂ) (hc : ∀ (g k : Equiv.Perm (Fin n)), c (k * g * k⁻¹) = c g) :

            Class elements lie in the span of the class sums: the conjugation-invariant elements are spanned by p(n) vectors.

            theorem RS.one_eq_classElem_ite (n : ℕ) :
            1 = classElem fun (π : Equiv.Perm (Fin n)) => if π = 1 then 1 else 0

            The identity is a class element.

            theorem RS.shape_e_eq_classElem (P : SchurPackage) {n : ℕ} (μ : Shape n) :
            Shape.e P μ = classElem fun (g : Equiv.Perm (Fin n)) => nCoeff (jtSimple ↑μ) ((permCast ⋯).symm g)

            The recast idempotent of a shape is a class element.

            The recast idempotents lie in the span of the class sums.

            theorem RS.shape_e_ne_zero (P : SchurPackage) {n : ℕ} (μ : Shape n) :
            Shape.e P μ ≠ 0

            The recast idempotents are nonzero.

            theorem RS.sum_smul_mul_shape_e (P : SchurPackage) {n : ℕ} (c : Shape n → ℂ) (ν : Shape n) :
            (∑ μ : Shape n, c μ • Shape.e P μ) * Shape.e P ν = c ν • Shape.e P ν

            Multiplying a weighted sum of the recast idempotents by one of them extracts its term.

            The recast idempotents are linearly independent.

            The identity of the group algebra lies in the span of the class sums.

            theorem RS.eq_sum_shape_e_of_mem_span (P : SchurPackage) {n : ℕ} {x : SymGroupAlgebra n} (hx : x ∈ Submodule.span ℂ (Set.range (classSum n))) :
            ∃ (c : Shape n → ℂ), ∑ μ : Shape n, c μ • Shape.e P μ = x

            Every element in the class-sum span has coordinates in the recast central idempotents.

            theorem RS.SchurPackage.sum_shape_e_eq_one (P : SchurPackage) (n : ℕ) :
            ∑ μ : Shape n, Shape.e P μ = 1

            Completeness of the blocks: at every size the recast central idempotents sum to the identity of the group algebra.

            The regular-representation dimension bound #

            Reading the identity coefficient off the completeness identity gives ∑ (dim μ)² = n!; the elementary inequality ∑ aᵢ² ≤ (∑ aᵢ)² for naturals and a square root then give the forms consumed by the Deligne development.

            theorem RS.shape_e_coeff_one (P : SchurPackage) {n : ℕ} (μ : Shape n) :
            (Shape.e P μ).coeff 1 = ↑(P.dim ↑μ) ^ 2 / ↑n.factorial

            The identity coefficient of a recast idempotent.

            theorem RS.SchurPackage.sum_dim_sq_eq (P : SchurPackage) (n : ℕ) :
            ∑ μ : Shape n, P.dim ↑μ ^ 2 = n.factorial

            Wedderburn completeness of the blocks: the squares of the dimensions of the shapes of size n sum to n!.

            theorem RS.SchurPackage.factorial_le_sq_sum_dim (P : SchurPackage) (n : ℕ) :
            ↑n.factorial ≤ ↑(∑ μ : Shape n, P.dim ↑μ) ^ 2

            The factorial is at most the square of the dimension sum.

            theorem RS.SchurPackage.sqrt_factorial_le_sum_dim (P : SchurPackage) (n : ℕ) :
            √↑n.factorial ≤ ↑(∑ μ : Shape n, P.dim ↑μ)

            The regular-representation dimension bound: the dimensions of the shapes of size n sum to at least √(n!).