Documentation

LeanPool.Ado.Algebra.Lie.Submodule.DirectSum

An internal direct sum of Lie submodules is an external one #

A family N : ι → LieSubmodule R L M whose underlying submodules decompose M (DirectSum.IsInternal) presents M as the external direct sum ⨁ i, N i, which carries Mathlib's Lie module structure on a direct sum. This file records the comparison: the sum map ⨁ i, N i → M is a morphism of Lie modules (DirectSum.coeLieModuleHom), and it is an equivalence exactly when the decomposition is internal (DirectSum.lieModuleEquivOfIsInternal).

DirectSum.IsInternal is a statement about the underlying Submodules, so it carries no equivariance on its own; that is what is added here. With the equivalence in hand, a construction applied to M can be computed summand by summand, which is how the multiplicity of an irreducible in M is read off a decomposition of M into irreducibles in TauCeti/Algebra/Lie/Multiplicity.lean.

The file closes with the regrouping theorem DirectSum.nonempty_lieModuleEquiv_sigma_of_isInternal: a decomposition of M whose summands are labelled by a map c : ι → σ, the summand N i being equivalent to a fixed module S (c i), rewrites as M ≃ ⨁_{s} S s ^ m s with m s the number of indices carrying the label s. It is the shape in which a decomposition into irreducibles is packaged once the summands are named: σ is a set of names for the irreducibles, c sends a summand to the name of its isomorphism class, and m is the multiplicity.

Main definitions #

Main results #

Roadmap #

This is infrastructure for the decomposition toolkit of Layer 6 of TauCetiRoadmap/RepresentationTheory/LieHighestWeight/README.md, whose multiplicity target isotypicMultiplicity counts the summands of a decomposition of M into irreducibles; the decompositions it counts are produced by Ado.exists_isInternal_isIrreducible of TauCeti/Algebra/Lie/Submodule/Decomposition.lean, in exactly the DirectSum.IsInternal form consumed here.

noncomputable def DirectSum.coeLieModuleHom {R : Type u} {L : Type v} {M : Type w} {ι : Type w₁} [dec_ι : DecidableEq ι] [CommRing R] [LieRing L] [AddCommGroup M] [Module R M] [LieRingModule L M] (N : ι → LieSubmodule R L M) :
(DirectSum ι fun (i : ι) => ↥(N i)) →ₗ⁅R,L⁆ M

The sum map of a family of Lie submodules, ⨁ i, N i → M, as a morphism of Lie modules. Its underlying linear map is DirectSum.coeLinearMap (DirectSum.coeLieModuleHom_toLinearMap), so DirectSum.IsInternal is exactly the statement that it is bijective.

Equations
Instances For
    @[simp]
    theorem DirectSum.coeLieModuleHom_toLinearMap {R : Type u} {L : Type v} {M : Type w} {ι : Type w₁} [dec_ι : DecidableEq ι] [CommRing R] [LieRing L] [AddCommGroup M] [Module R M] [LieRingModule L M] (N : ι → LieSubmodule R L M) :
    ↑(coeLieModuleHom N) = coeLinearMap fun (i : ι) => ↑(N i)

    The underlying linear map of the sum map of a family of Lie submodules is Mathlib's DirectSum.coeLinearMap of the underlying submodules.

    @[simp]
    theorem DirectSum.coeLieModuleHom_of {R : Type u} {L : Type v} {M : Type w} {ι : Type w₁} [dec_ι : DecidableEq ι] [CommRing R] [LieRing L] [AddCommGroup M] [Module R M] [LieRingModule L M] (N : ι → LieSubmodule R L M) (i : ι) (y : ↥(N i)) :
    (coeLieModuleHom N) ((of (fun (i : ι) => ↥(N i)) i) y) = ↑y
    theorem DirectSum.coeLieModuleHom_bijective_iff {R : Type u} {L : Type v} {M : Type w} {ι : Type w₁} [dec_ι : DecidableEq ι] [CommRing R] [LieRing L] [AddCommGroup M] [Module R M] [LieRingModule L M] (N : ι → LieSubmodule R L M) :
    Function.Bijective ⇑(coeLieModuleHom N) ↔ IsInternal fun (i : ι) => ↑(N i)

    The sum map of a family of Lie submodules is bijective exactly when the family decomposes M internally: by DirectSum.coeLieModuleHom_toLinearMap the two statements are about the same underlying map.

    noncomputable def DirectSum.lieModuleEquivOfIsInternal {R : Type u} {L : Type v} {M : Type w} {ι : Type w₁} [dec_ι : DecidableEq ι] [CommRing R] [LieRing L] [AddCommGroup M] [Module R M] [LieRingModule L M] (N : ι → LieSubmodule R L M) (h : IsInternal fun (i : ι) => ↑(N i)) :
    (DirectSum ι fun (i : ι) => ↥(N i)) ≃ₗ⁅R,L⁆ M

    An internal direct sum of Lie submodules, as an external one. A family of Lie submodules whose underlying submodules decompose M presents M as the direct sum of the family, as Lie modules.

    Equations
    Instances For
      @[simp]
      theorem DirectSum.lieModuleEquivOfIsInternal_apply {R : Type u} {L : Type v} {M : Type w} {ι : Type w₁} [dec_ι : DecidableEq ι] [CommRing R] [LieRing L] [AddCommGroup M] [Module R M] [LieRingModule L M] (N : ι → LieSubmodule R L M) (h : IsInternal fun (i : ι) => ↑(N i)) (m : DirectSum ι fun (i : ι) => ↥(N i)) :
      theorem DirectSum.lieModuleEquivOfIsInternal_toLinearEquiv {R : Type u} {L : Type v} {M : Type w} {ι : Type w₁} [dec_ι : DecidableEq ι] [CommRing R] [LieRing L] [AddCommGroup M] [Module R M] [LieRingModule L M] (N : ι → LieSubmodule R L M) (h : IsInternal fun (i : ι) => ↑(N i)) :

      The underlying linear equivalence of the internal Lie-module decomposition is the canonical equivalence supplied by DirectSum.IsInternal.

      noncomputable def DirectSum.IsInternal.lieModuleProjection {R : Type u} {L : Type v} {M : Type w} {ι : Type w₁} [dec_ι : DecidableEq ι] [CommRing R] [LieRing L] [AddCommGroup M] [Module R M] [LieRingModule L M] {N : ι → LieSubmodule R L M} (h : IsInternal fun (i : ι) => ↑(N i)) (i : ι) :

      The canonical projection onto an internal Lie-module summand. It extracts one component through the internal direct-sum equivalence and includes that component back into the ambient module.

      Equations
      Instances For
        theorem DirectSum.IsInternal.lieModuleProjection_apply {R : Type u} {L : Type v} {M : Type w} {ι : Type w₁} [dec_ι : DecidableEq ι] [CommRing R] [LieRing L] [AddCommGroup M] [Module R M] [LieRingModule L M] {N : ι → LieSubmodule R L M} (h : IsInternal fun (i : ι) => ↑(N i)) (i : ι) (m : M) :
        (h.lieModuleProjection i) m = ↑(((LinearEquiv.ofBijective (coeLinearMap fun (j : ι) => ↑(N j)) h).symm m) i)

        Applying the canonical projection returns the selected internal direct-sum component.

        theorem DirectSum.IsInternal.lieModuleProjection_toLinearMap {R : Type u} {L : Type v} {M : Type w} {ι : Type w₁} [dec_ι : DecidableEq ι] [CommRing R] [LieRing L] [AddCommGroup M] [Module R M] [LieRingModule L M] {N : ι → LieSubmodule R L M} (h : IsInternal fun (i : ι) => ↑(N i)) (i : ι) :

        The underlying linear map of the equivariant summand projection is the canonical projection of the underlying internal direct sum, followed by the summand inclusion.

        theorem DirectSum.IsInternal.sum_lieModuleProjection_apply {R : Type u} {L : Type v} {M : Type w} {ι : Type w₁} [dec_ι : DecidableEq ι] [CommRing R] [LieRing L] [AddCommGroup M] [Module R M] [LieRingModule L M] [Fintype ι] {N : ι → LieSubmodule R L M} (h : IsInternal fun (i : ι) => ↑(N i)) (m : M) :
        ∑ i : ι, (h.lieModuleProjection i) m = m

        Over a finite index type the equivariant projections onto the summands sum to the identity.

        @[simp]
        theorem DirectSum.IsInternal.lieModuleProjection_apply_of_mem {R : Type u} {L : Type v} {M : Type w} {ι : Type w₁} [dec_ι : DecidableEq ι] [CommRing R] [LieRing L] [AddCommGroup M] [Module R M] [LieRingModule L M] {N : ι → LieSubmodule R L M} (h : IsInternal fun (i : ι) => ↑(N i)) (i : ι) {m : M} (hm : m ∈ N i) :

        The canonical projection fixes every element of the selected summand.

        @[simp]
        theorem DirectSum.IsInternal.lieModuleProjection_apply_of_ne {R : Type u} {L : Type v} {M : Type w} {ι : Type w₁} [dec_ι : DecidableEq ι] [CommRing R] [LieRing L] [AddCommGroup M] [Module R M] [LieRingModule L M] {N : ι → LieSubmodule R L M} (h : IsInternal fun (i : ι) => ↑(N i)) {i j : ι} (hji : j ≠ i) (m : ↥(N j)) :
        (h.lieModuleProjection i) ↑m = 0

        The canonical projection vanishes on every other summand.

        @[simp]
        theorem DirectSum.IsInternal.lieModuleProjection_apply_apply {R : Type u} {L : Type v} {M : Type w} {ι : Type w₁} [dec_ι : DecidableEq ι] [CommRing R] [LieRing L] [AddCommGroup M] [Module R M] [LieRingModule L M] {N : ι → LieSubmodule R L M} (h : IsInternal fun (i : ι) => ↑(N i)) (i : ι) (m : M) :

        The canonical projection is idempotent.

        @[simp]
        theorem DirectSum.IsInternal.lieModuleProjection_range {R : Type u} {L : Type v} {M : Type w} {ι : Type w₁} [dec_ι : DecidableEq ι] [CommRing R] [LieRing L] [AddCommGroup M] [Module R M] [LieRingModule L M] {N : ι → LieSubmodule R L M} (h : IsInternal fun (i : ι) => ↑(N i)) (i : ι) :

        The range of the canonical projection is exactly its selected summand.

        theorem DirectSum.nonempty_lieModuleEquiv_sigma_of_isInternal {R : Type u} {L : Type v} {M : Type w} {ι : Type w₁} [dec_ι : DecidableEq ι] [CommRing R] [LieRing L] [AddCommGroup M] [Module R M] [LieRingModule L M] (N : ι → LieSubmodule R L M) [Finite ι] {σ : Type w₃} {S : σ → Type w₄} [(s : σ) → AddCommGroup (S s)] [(s : σ) → Module R (S s)] [(s : σ) → LieRingModule L (S s)] {m : σ → ℕ} (h : IsInternal fun (i : ι) => ↑(N i)) (c : ι → σ) (hc : ∀ (i : ι), Nonempty (↥(N i) ≃ₗ⁅R,L⁆ S (c i))) (hcard : ∀ (s : σ), Nat.card { i : ι // c i = s } = m s) :
        Nonempty (M ≃ₗ⁅R,L⁆ DirectSum ((s : σ) × Fin (m s)) fun (q : (s : σ) × Fin (m s)) => S q.fst)

        An internal decomposition regrouped by the labels of its summands. Suppose the Lie submodules N i decompose M internally, that each N i is equivalent to a member S (c i) of a family of Lie modules indexed by σ, and that m s counts the indices labelled s. Then M is the direct sum, over the pairs of a label s and a counter in Fin (m s), of S s.

        Only Nonempty is asserted: the equivalence depends on the labelling and on the choice of an equivalence N i ≃ S (c i) for each i, so there is no canonical one to name.

        theorem Ado.LieModule.finrank_lieModuleHom_eq_sum_of_isInternal {K : Type u} {L : Type v} {M : Type w} {ι : Type w₁} [DecidableEq ι] [Fintype ι] [Field K] [LieRing L] [LieAlgebra K L] [AddCommGroup M] [Module K M] [LieRingModule L M] [LieModule K L M] (S : Type w₂) [AddCommGroup S] [Module K S] [LieRingModule L S] (N : ι → LieSubmodule K L M) (h : DirectSum.IsInternal fun (i : ι) => ↑(N i)) (hfin : ∀ (i : ι), FiniteDimensional K (S →ₗ⁅K,L⁆ ↥(N i))) :
        Module.finrank K (S →ₗ⁅K,L⁆ M) = ∑ i : ι, Module.finrank K (S →ₗ⁅K,L⁆ ↥(N i))

        Additivity of the morphism space over a decomposition of the target. If the Lie submodules N i decompose M and every component morphism space is finite-dimensional, the finrank of S →ₗ⁅K,L⁆ M is the sum of the finranks of the S →ₗ⁅K,L⁆ N i.