Documentation

LeanPool.Ado.Algebra.Lie.DirectSum

External direct sums of Lie modules #

This file supplements Mathlib/Algebra/Lie/DirectSum.lean, which puts a Lie module structure on an external direct sum ⨁ i, Pᵢ and provides the inclusion DirectSum.lieModuleOf and the projection DirectSum.lieModuleComponent as morphisms of Lie modules. Those two come with no application lemmas; the ones saying they are the underlying DirectSum.of and evaluation are recorded here, so that no consumer has to unfold either definition.

They are what makes the morphism space additive over a direct sum in its target: a morphism from a Lie module S into a finite external direct sum is the family of its components, and a finite family of components reassembles to the element it came from. That is Ado.LieModule.lieModuleHomDirectSumEquiv.

The file also refines the two ways an external direct sum is transported to Mathlib's Lie module structure: along a family of morphisms of the summands (DirectSum.lieModuleMap, refining DirectSum.lmap, and DirectSum.lieModuleEquivCongrRight, refining DirectSum.congrLinearEquiv) and along an equivalence of the index type (DirectSum.lieModuleEquivCongrLeft, refining DirectSum.lequivCongrLeft). The bracket acts summand by summand, so in each case the only thing to check is that Mathlib's underlying linear map is equivariant; the _toLinearMap and _toLinearEquiv lemmas record which map that is, so that Mathlib's API for it stays reachable.

Main definitions #

Main results #

Roadmap #

This is infrastructure for the decomposition toolkit of Layer 6 of TauCetiRoadmap/RepresentationTheory/LieHighestWeight/README.md: additivity of the morphism space is the ingredient that TauCeti/Algebra/Lie/Schur.lean names as missing from its dimension form of Schur's lemma, and with which TauCeti/Algebra/Lie/Multiplicity.lean reads a multiplicity off dim_K (S →ₗ⁅K,L⁆ M). The transport definitions are what regroup a decomposition of a module into irreducibles by isomorphism type, in TauCeti/Algebra/Lie/Submodule/DirectSum.lean.

@[simp]
theorem DirectSum.lieModuleOf_apply (R : Type u) (ι : Type w₂) (L : Type v) (P : ι → Type w₁) [CommRing R] [LieRing L] [(i : ι) → AddCommGroup (P i)] [(i : ι) → Module R (P i)] [(i : ι) → LieRingModule L (P i)] [DecidableEq ι] (i : ι) (x : P i) :
(lieModuleOf R ι L P i) x = (of P i) x

The inclusion of a summand into an external direct sum of Lie modules is DirectSum.of.

@[simp]
theorem DirectSum.lieModuleComponent_apply (R : Type u) (ι : Type w₂) (L : Type v) (P : ι → Type w₁) [CommRing R] [LieRing L] [(i : ι) → AddCommGroup (P i)] [(i : ι) → Module R (P i)] [(i : ι) → LieRingModule L (P i)] (i : ι) (x : DirectSum ι fun (i : ι) => P i) :
(lieModuleComponent R ι L P i) x = x i

The projection of an external direct sum of Lie modules onto a summand is evaluation.

def DirectSum.lieModuleMap {R : Type u} {L : Type v} {ι : Type w₂} [CommRing R] [LieRing L] {P : ι → Type w₁} [(i : ι) → AddCommGroup (P i)] [(i : ι) → Module R (P i)] [(i : ι) → LieRingModule L (P i)] {Q : ι → Type w₄} [(i : ι) → AddCommGroup (Q i)] [(i : ι) → Module R (Q i)] [(i : ι) → LieRingModule L (Q i)] (f : (i : ι) → P i →ₗ⁅R,L⁆ Q i) :
(DirectSum ι fun (i : ι) => P i) →ₗ⁅R,L⁆ DirectSum ι fun (i : ι) => Q i

A family of morphisms of the summands, as a morphism of the external direct sums. Its underlying linear map is Mathlib's DirectSum.lmap, so it acts componentwise; the bracket does too, which is all that equivariance needs.

Equations
Instances For
    @[simp]
    theorem DirectSum.lieModuleMap_toLinearMap {R : Type u} {L : Type v} {ι : Type w₂} [CommRing R] [LieRing L] {P : ι → Type w₁} [(i : ι) → AddCommGroup (P i)] [(i : ι) → Module R (P i)] [(i : ι) → LieRingModule L (P i)] {Q : ι → Type w₄} [(i : ι) → AddCommGroup (Q i)] [(i : ι) → Module R (Q i)] [(i : ι) → LieRingModule L (Q i)] (f : (i : ι) → P i →ₗ⁅R,L⁆ Q i) :
    ↑(lieModuleMap f) = lmap fun (i : ι) => ↑(f i)

    The underlying linear map of a family of morphisms of the summands is Mathlib's DirectSum.lmap, which is how its API is reached.

    @[simp]
    theorem DirectSum.lieModuleMap_apply {R : Type u} {L : Type v} {ι : Type w₂} [CommRing R] [LieRing L] {P : ι → Type w₁} [(i : ι) → AddCommGroup (P i)] [(i : ι) → Module R (P i)] [(i : ι) → LieRingModule L (P i)] {Q : ι → Type w₄} [(i : ι) → AddCommGroup (Q i)] [(i : ι) → Module R (Q i)] [(i : ι) → LieRingModule L (Q i)] (f : (i : ι) → P i →ₗ⁅R,L⁆ Q i) (x : DirectSum ι fun (i : ι) => P i) (i : ι) :
    ((lieModuleMap f) x) i = (f i) (x i)
    def DirectSum.lieModuleEquivCongrRight {R : Type u} {L : Type v} {ι : Type w₂} [CommRing R] [LieRing L] {P : ι → Type w₁} [(i : ι) → AddCommGroup (P i)] [(i : ι) → Module R (P i)] [(i : ι) → LieRingModule L (P i)] {Q : ι → Type w₄} [(i : ι) → AddCommGroup (Q i)] [(i : ι) → Module R (Q i)] [(i : ι) → LieRingModule L (Q i)] (e : (i : ι) → P i ≃ₗ⁅R,L⁆ Q i) :
    (DirectSum ι fun (i : ι) => P i) ≃ₗ⁅R,L⁆ DirectSum ι fun (i : ι) => Q i

    A family of equivalences of the summands, as an equivalence of the external direct sums. Its underlying linear equivalence is Mathlib's DirectSum.congrLinearEquiv, whose inverse is already the family of inverses; equivariance is that of the underlying DirectSum.lieModuleMap.

    Equations
    • One or more equations did not get rendered due to their size.
    Instances For
      @[simp]
      theorem DirectSum.lieModuleEquivCongrRight_toLinearEquiv {R : Type u} {L : Type v} {ι : Type w₂} [CommRing R] [LieRing L] {P : ι → Type w₁} [(i : ι) → AddCommGroup (P i)] [(i : ι) → Module R (P i)] [(i : ι) → LieRingModule L (P i)] {Q : ι → Type w₄} [(i : ι) → AddCommGroup (Q i)] [(i : ι) → Module R (Q i)] [(i : ι) → LieRingModule L (Q i)] (e : (i : ι) → P i ≃ₗ⁅R,L⁆ Q i) :

      The underlying linear equivalence of a family of equivalences of the summands is Mathlib's DirectSum.congrLinearEquiv, which is how its API is reached.

      @[simp]
      theorem DirectSum.lieModuleEquivCongrRight_apply {R : Type u} {L : Type v} {ι : Type w₂} [CommRing R] [LieRing L] {P : ι → Type w₁} [(i : ι) → AddCommGroup (P i)] [(i : ι) → Module R (P i)] [(i : ι) → LieRingModule L (P i)] {Q : ι → Type w₄} [(i : ι) → AddCommGroup (Q i)] [(i : ι) → Module R (Q i)] [(i : ι) → LieRingModule L (Q i)] (e : (i : ι) → P i ≃ₗ⁅R,L⁆ Q i) (x : DirectSum ι fun (i : ι) => P i) (i : ι) :
      ((lieModuleEquivCongrRight e) x) i = (e i) (x i)
      @[simp]
      theorem DirectSum.lieModuleEquivCongrRight_symm {R : Type u} {L : Type v} {ι : Type w₂} [CommRing R] [LieRing L] {P : ι → Type w₁} [(i : ι) → AddCommGroup (P i)] [(i : ι) → Module R (P i)] [(i : ι) → LieRingModule L (P i)] {Q : ι → Type w₄} [(i : ι) → AddCommGroup (Q i)] [(i : ι) → Module R (Q i)] [(i : ι) → LieRingModule L (Q i)] (e : (i : ι) → P i ≃ₗ⁅R,L⁆ Q i) :

      The inverse of a family of equivalences of the summands is the family of inverses.

      def DirectSum.lieModuleEquivCongrLeft (R : Type u) (L : Type v) {ι : Type w₂} {κ : Type w₃} [CommRing R] [LieRing L] {P : ι → Type w₁} [(i : ι) → AddCommGroup (P i)] [(i : ι) → Module R (P i)] [(i : ι) → LieRingModule L (P i)] (h : ι ≃ κ) :
      (DirectSum ι fun (i : ι) => P i) ≃ₗ⁅R,L⁆ DirectSum κ fun (k : κ) => P (h.symm k)

      Reindexing an external direct sum of Lie modules along an equivalence of index types. Its underlying linear equivalence is Mathlib's DirectSum.lequivCongrLeft.

      Equations
      Instances For
        @[simp]
        theorem DirectSum.lieModuleEquivCongrLeft_toLinearEquiv (R : Type u) (L : Type v) {ι : Type w₂} {κ : Type w₃} [CommRing R] [LieRing L] {P : ι → Type w₁} [(i : ι) → AddCommGroup (P i)] [(i : ι) → Module R (P i)] [(i : ι) → LieRingModule L (P i)] (h : ι ≃ κ) :

        The underlying linear equivalence of a reindexing is Mathlib's DirectSum.lequivCongrLeft, which is how its API is reached.

        @[simp]
        theorem DirectSum.lieModuleEquivCongrLeft_apply (R : Type u) (L : Type v) {ι : Type w₂} {κ : Type w₃} [CommRing R] [LieRing L] {P : ι → Type w₁} [(i : ι) → AddCommGroup (P i)] [(i : ι) → Module R (P i)] [(i : ι) → LieRingModule L (P i)] (h : ι ≃ κ) (x : DirectSum ι fun (i : ι) => P i) (k : κ) :
        ((lieModuleEquivCongrLeft R L h) x) k = x (h.symm k)
        def Ado.LieModule.lieModuleHomDirectSumEquiv (R : Type u) (L : Type v) {ι : Type w₂} [DecidableEq ι] [Fintype ι] [CommRing R] [LieRing L] [LieAlgebra R L] (S : Type w) [AddCommGroup S] [Module R S] [LieRingModule L S] (P : ι → Type w₁) [(i : ι) → AddCommGroup (P i)] [(i : ι) → Module R (P i)] [(i : ι) → LieRingModule L (P i)] [∀ (i : ι), LieModule R L (P i)] :
        (S →ₗ⁅R,L⁆ DirectSum ι fun (i : ι) => P i) ≃ₗ[R] (i : ι) → S →ₗ⁅R,L⁆ P i

        The morphism space is additive over a direct sum in its target. A morphism from S into a finite external direct sum of Lie modules is the family of its components, and conversely a family of morphisms assembles to one; this is an isomorphism of R-modules.

        Equations
        • One or more equations did not get rendered due to their size.
        Instances For
          @[simp]
          theorem Ado.LieModule.lieModuleHomDirectSumEquiv_apply (R : Type u) (L : Type v) {ι : Type w₂} [DecidableEq ι] [Fintype ι] [CommRing R] [LieRing L] [LieAlgebra R L] (S : Type w) [AddCommGroup S] [Module R S] [LieRingModule L S] (P : ι → Type w₁) [(i : ι) → AddCommGroup (P i)] [(i : ι) → Module R (P i)] [(i : ι) → LieRingModule L (P i)] [∀ (i : ι), LieModule R L (P i)] (f : S →ₗ⁅R,L⁆ DirectSum ι fun (i : ι) => P i) (i : ι) (s : S) :
          ((lieModuleHomDirectSumEquiv R L S P) f i) s = (f s) i
          @[simp]
          theorem Ado.LieModule.lieModuleHomDirectSumEquiv_symm_apply (R : Type u) (L : Type v) {ι : Type w₂} [DecidableEq ι] [Fintype ι] [CommRing R] [LieRing L] [LieAlgebra R L] (S : Type w) [AddCommGroup S] [Module R S] [LieRingModule L S] (P : ι → Type w₁) [(i : ι) → AddCommGroup (P i)] [(i : ι) → Module R (P i)] [(i : ι) → LieRingModule L (P i)] [∀ (i : ι), LieModule R L (P i)] (g : (i : ι) → S →ₗ⁅R,L⁆ P i) (s : S) :
          ((lieModuleHomDirectSumEquiv R L S P).symm g) s = ∑ i : ι, (DirectSum.of P i) ((g i) s)