BGG Category O Dual Modules - Algebras

Skip to content
Back to top
View this page
Edit this page

# BGG Category O Dual Modules

AUTHORS:

- Travis Scrimshaw (2024-01-07): Initial version

class sage.algebras.lie_algebras.bgg_dual_module.BGGDualModule(module)

  Bases: `CombinatorialFreeModule`

  The dual module \(M^{\vee}\) in the BGG Category \(\mathcal{O}\).

  Let \(\tau\) be the transpose map of a semisimple (finite dimensional) Lie algebra \(\mathfrak{g}\) over a field \(R\). Let \(M \in \mathcal{O}\). The BGG dual module is the \(R\)-module \(M^{\vee} := \bigoplus_{\lambda} M_{\lambda}^*\) which has a \(U(\mathfrak{g})\)-module structure given by

  \[x \cdot \phi(v) := \phi(\tau(x) \cdot v),\]

  which is also a weight module with the same grading as \(M\).

  The basis we chose to work with here is the natural dual basis to the distinguished basis \(B\) of \(M\). That is, we define the dual function to \(b\) as \(\phi_b(c) = \delta_{bc}\).

  EXAMPLES:

  Sage

      sage: g = LieAlgebra(QQ, cartan_type=['A', 1])
      sage: La = g.cartan_type().root_system().weight_lattice().fundamental_weights()
      sage: M = g.verma_module(2*La[1])
      sage: Mc = M.dual()
      sage: B = Mc.basis()
      sage: it = iter(B)
      sage: elts = [next(it) for _ in range(7)]; elts
      [v[2*Lambda[1]]^*,
       f[-alpha[1]]*v[2*Lambda[1]]^*,
       f[-alpha[1]]^2*v[2*Lambda[1]]^*,
       f[-alpha[1]]^3*v[2*Lambda[1]]^*,
       f[-alpha[1]]^4*v[2*Lambda[1]]^*,
       f[-alpha[1]]^5*v[2*Lambda[1]]^*,
       f[-alpha[1]]^6*v[2*Lambda[1]]^*]
      sage: e, h, f = g.pbw_basis().algebra_generators()
      sage: [f * vec for vec in elts]
      [2*f[-alpha[1]]*v[2*Lambda[1]]^*,
       2*f[-alpha[1]]^2*v[2*Lambda[1]]^*,
       0,
       -4*f[-alpha[1]]^4*v[2*Lambda[1]]^*,
       -10*f[-alpha[1]]^5*v[2*Lambda[1]]^*,
       -18*f[-alpha[1]]^6*v[2*Lambda[1]]^*,
       -28*f[-alpha[1]]^7*v[2*Lambda[1]]^*]
      sage: [e * vec for vec in elts]
      [0,
       v[2*Lambda[1]]^*,
       f[-alpha[1]]*v[2*Lambda[1]]^*,
       f[-alpha[1]]^2*v[2*Lambda[1]]^*,
       f[-alpha[1]]^3*v[2*Lambda[1]]^*,
       f[-alpha[1]]^4*v[2*Lambda[1]]^*,
       f[-alpha[1]]^5*v[2*Lambda[1]]^*]
      sage: [h * vec for vec in elts]
      [2*v[2*Lambda[1]]^*,
       0,
       -2*f[-alpha[1]]^2*v[2*Lambda[1]]^*,
       -4*f[-alpha[1]]^3*v[2*Lambda[1]]^*,
       -6*f[-alpha[1]]^4*v[2*Lambda[1]]^*,
       -8*f[-alpha[1]]^5*v[2*Lambda[1]]^*,
       -10*f[-alpha[1]]^6*v[2*Lambda[1]]^*]

  Python

      >>> from sage.all import *
      >>> g = LieAlgebra(QQ, cartan_type=['A', Integer(1)])
      >>> La = g.cartan_type().root_system().weight_lattice().fundamental_weights()
      >>> M = g.verma_module(Integer(2)*La[Integer(1)])
      >>> Mc = M.dual()
      >>> B = Mc.basis()
      >>> it = iter(B)
      >>> elts = [next(it) for _ in range(Integer(7))]; elts
      [v[2*Lambda[1]]^*,
       f[-alpha[1]]*v[2*Lambda[1]]^*,
       f[-alpha[1]]^2*v[2*Lambda[1]]^*,
       f[-alpha[1]]^3*v[2*Lambda[1]]^*,
       f[-alpha[1]]^4*v[2*Lambda[1]]^*,
       f[-alpha[1]]^5*v[2*Lambda[1]]^*,
       f[-alpha[1]]^6*v[2*Lambda[1]]^*]
      >>> e, h, f = g.pbw_basis().algebra_generators()
      >>> [f * vec for vec in elts]
      [2*f[-alpha[1]]*v[2*Lambda[1]]^*,
       2*f[-alpha[1]]^2*v[2*Lambda[1]]^*,
       0,
       -4*f[-alpha[1]]^4*v[2*Lambda[1]]^*,
       -10*f[-alpha[1]]^5*v[2*Lambda[1]]^*,
       -18*f[-alpha[1]]^6*v[2*Lambda[1]]^*,
       -28*f[-alpha[1]]^7*v[2*Lambda[1]]^*]
      >>> [e * vec for vec in elts]
      [0,
       v[2*Lambda[1]]^*,
       f[-alpha[1]]*v[2*Lambda[1]]^*,
       f[-alpha[1]]^2*v[2*Lambda[1]]^*,
       f[-alpha[1]]^3*v[2*Lambda[1]]^*,
       f[-alpha[1]]^4*v[2*Lambda[1]]^*,
       f[-alpha[1]]^5*v[2*Lambda[1]]^*]
      >>> [h * vec for vec in elts]
      [2*v[2*Lambda[1]]^*,
       0,
       -2*f[-alpha[1]]^2*v[2*Lambda[1]]^*,
       -4*f[-alpha[1]]^3*v[2*Lambda[1]]^*,
       -6*f[-alpha[1]]^4*v[2*Lambda[1]]^*,
       -8*f[-alpha[1]]^5*v[2*Lambda[1]]^*,
       -10*f[-alpha[1]]^6*v[2*Lambda[1]]^*]

  REFERENCES:

  - [Humphreys08]

  class Element

    Bases: `IndexedFreeModuleElement`

  degree_on_basis(m)

    Return the degree of the basis element indexed by `m`.

    EXAMPLES:

    Sage

        sage: g = LieAlgebra(QQ, cartan_type=['D', 5])
        sage: La = g.cartan_type().root_system().weight_space().fundamental_weights()
        sage: M = g.verma_module(La[1] + La[4] - 1/3*La[5])
        sage: Mc = M.dual()
        sage: elt = Mc.an_element(); elt
        f[-alpha[5]]^2*f[-alpha[4]]^2*f[-alpha[3]]^3*v[Lambda[1] + Lambda[4] - 1/3*Lambda[5]]^*
         + 2*f[-alpha[5]]*v[Lambda[1] + Lambda[4] - 1/3*Lambda[5]]^*
         + 3*f[-alpha[4]]*v[Lambda[1] + Lambda[4] - 1/3*Lambda[5]]^*
         + v[Lambda[1] + Lambda[4] - 1/3*Lambda[5]]^*
        sage: [M.degree_on_basis(m) for m in elt.support()]
        [Lambda[1] + 3*Lambda[2] - 2*Lambda[3] - 4/3*Lambda[5],
         Lambda[1] + Lambda[4] - 1/3*Lambda[5],
         Lambda[1] + Lambda[3] + Lambda[4] - 7/3*Lambda[5],
         Lambda[1] + Lambda[3] - Lambda[4] - 1/3*Lambda[5]]

    Python

        >>> from sage.all import *
        >>> g = LieAlgebra(QQ, cartan_type=['D', Integer(5)])
        >>> La = g.cartan_type().root_system().weight_space().fundamental_weights()
        >>> M = g.verma_module(La[Integer(1)] + La[Integer(4)] - Integer(1)/Integer(3)*La[Integer(5)])
        >>> Mc = M.dual()
        >>> elt = Mc.an_element(); elt
        f[-alpha[5]]^2*f[-alpha[4]]^2*f[-alpha[3]]^3*v[Lambda[1] + Lambda[4] - 1/3*Lambda[5]]^*
         + 2*f[-alpha[5]]*v[Lambda[1] + Lambda[4] - 1/3*Lambda[5]]^*
         + 3*f[-alpha[4]]*v[Lambda[1] + Lambda[4] - 1/3*Lambda[5]]^*
         + v[Lambda[1] + Lambda[4] - 1/3*Lambda[5]]^*
        >>> [M.degree_on_basis(m) for m in elt.support()]
        [Lambda[1] + 3*Lambda[2] - 2*Lambda[3] - 4/3*Lambda[5],
         Lambda[1] + Lambda[4] - 1/3*Lambda[5],
         Lambda[1] + Lambda[3] + Lambda[4] - 7/3*Lambda[5],
         Lambda[1] + Lambda[3] - Lambda[4] - 1/3*Lambda[5]]

  dual()

    Return the dual module of `self`.

    In Category \(\mathcal{O}\), we have \((M^{\vee})^{\vee} \cong M\), so we return the defining module \(M\) of \(M^{\vee}\).

    EXAMPLES:

    Sage

        sage: g = LieAlgebra(QQ, cartan_type=['F', 4])
        sage: La = g.cartan_type().root_system().weight_space().fundamental_weights()
        sage: M = g.verma_module(La[1] - 5/3*La[2] + 3*La[4])
        sage: Mc = M.dual()
        sage: Mc.dual() is M
        True

    Python

        >>> from sage.all import *
        >>> g = LieAlgebra(QQ, cartan_type=['F', Integer(4)])
        >>> La = g.cartan_type().root_system().weight_space().fundamental_weights()
        >>> M = g.verma_module(La[Integer(1)] - Integer(5)/Integer(3)*La[Integer(2)] + Integer(3)*La[Integer(4)])
        >>> Mc = M.dual()
        >>> Mc.dual() is M
        True

  highest_weight()

    Return the highest weight of `self`.

    EXAMPLES:

    Sage

        sage: g = LieAlgebra(QQ, cartan_type=['E', 7])
        sage: La = g.cartan_type().root_system().weight_space().fundamental_weights()
        sage: M = g.verma_module(2*La[1] + 5/3*La[4] - 3*La[6])
        sage: Mc = M.dual()
        sage: Mc.highest_weight()
        2*Lambda[1] + 5/3*Lambda[4] - 3*Lambda[6]

    Python

        >>> from sage.all import *
        >>> g = LieAlgebra(QQ, cartan_type=['E', Integer(7)])
        >>> La = g.cartan_type().root_system().weight_space().fundamental_weights()
        >>> M = g.verma_module(Integer(2)*La[Integer(1)] + Integer(5)/Integer(3)*La[Integer(4)] - Integer(3)*La[Integer(6)])
        >>> Mc = M.dual()
        >>> Mc.highest_weight()
        2*Lambda[1] + 5/3*Lambda[4] - 3*Lambda[6]

  highest_weight_vector()

    Return the highest weight vector of `self` (assuming the defining module defines such a vector).

    EXAMPLES:

    Sage

        sage: g = LieAlgebra(QQ, cartan_type=['A', 1])
        sage: La = g.cartan_type().root_system().weight_lattice().fundamental_weights()
        sage: M = g.verma_module(2*La[1])
        sage: Mc = M.dual()
        sage: Mc.highest_weight_vector()
        v[2*Lambda[1]]^*

    Python

        >>> from sage.all import *
        >>> g = LieAlgebra(QQ, cartan_type=['A', Integer(1)])
        >>> La = g.cartan_type().root_system().weight_lattice().fundamental_weights()
        >>> M = g.verma_module(Integer(2)*La[Integer(1)])
        >>> Mc = M.dual()
        >>> Mc.highest_weight_vector()
        v[2*Lambda[1]]^*

  lie_algebra()

    Return the underlying Lie algebra of `self`.

    EXAMPLES:

    Sage

        sage: g = LieAlgebra(QQ, cartan_type=['B', 3])
        sage: La = g.cartan_type().root_system().weight_lattice().fundamental_weights()
        sage: M = g.verma_module(2*La[1] + La[3])
        sage: Mc = M.dual()
        sage: Mc.lie_algebra() is g
        True

    Python

        >>> from sage.all import *
        >>> g = LieAlgebra(QQ, cartan_type=['B', Integer(3)])
        >>> La = g.cartan_type().root_system().weight_lattice().fundamental_weights()
        >>> M = g.verma_module(Integer(2)*La[Integer(1)] + La[Integer(3)])
        >>> Mc = M.dual()
        >>> Mc.lie_algebra() is g
        True

class sage.algebras.lie_algebras.bgg_dual_module.FiniteDimensionalSimpleModule(g, weight, prefix='f', basis_key=None, **kwds)

  Bases: `SimpleModule`

  A finite dimensional simple module.

  bgg_resolution()

    Return the BGG resolution of `self`.

    EXAMPLES:

    Sage

        sage: g = LieAlgebra(QQ, cartan_type=['A', 2])
        sage: La = g.cartan_type().root_system().weight_lattice().fundamental_weights()
        sage: L = g.simple_module(La[1] + La[2])
        sage: L.bgg_resolution()
        BGG resolution of Simple module with highest weight Lambda[1] + Lambda[2]
         of Lie algebra of ['A', 2] in the Chevalley basis

    Python

        >>> from sage.all import *
        >>> g = LieAlgebra(QQ, cartan_type=['A', Integer(2)])
        >>> La = g.cartan_type().root_system().weight_lattice().fundamental_weights()
        >>> L = g.simple_module(La[Integer(1)] + La[Integer(2)])
        >>> L.bgg_resolution()
        BGG resolution of Simple module with highest weight Lambda[1] + Lambda[2]
         of Lie algebra of ['A', 2] in the Chevalley basis

class sage.algebras.lie_algebras.bgg_dual_module.SimpleModule(g, weight, prefix='f', basis_key=None, **kwds)

  Bases: `ModulePrinting`, `CombinatorialFreeModule`

  Return the simple module \(L_{\lambda}\) as the image of the natural morphism \(\phi: M_{\lambda} \to M_{\lambda}^{\vee}\).

  class Element

    Bases: `IndexedFreeModuleElement`

  ambient()

    Return the ambient module of `self`.

    EXAMPLES:

    Sage

        sage: g = LieAlgebra(QQ, cartan_type=['G', 2])
        sage: La = g.cartan_type().root_system().weight_lattice().fundamental_weights()
        sage: L = g.simple_module(2*La[1])
        sage: L.ambient()
        BGG Dual of Verma module with highest weight 2*Lambda[1] of
         Lie algebra of ['G', 2] in the Chevalley basis

    Python

        >>> from sage.all import *
        >>> g = LieAlgebra(QQ, cartan_type=['G', Integer(2)])
        >>> La = g.cartan_type().root_system().weight_lattice().fundamental_weights()
        >>> L = g.simple_module(Integer(2)*La[Integer(1)])
        >>> L.ambient()
        BGG Dual of Verma module with highest weight 2*Lambda[1] of
         Lie algebra of ['G', 2] in the Chevalley basis

  dual()

    Return the dual module of `self`, which is `self` since simple modules are self-dual.

    EXAMPLES:

    Sage

        sage: g = LieAlgebra(QQ, cartan_type=['B', 4])
        sage: La = g.cartan_type().root_system().weight_lattice().fundamental_weights()
        sage: L = g.simple_module(2*La[1] + 3*La[4])
        sage: L.dual() is L
        True

    Python

        >>> from sage.all import *
        >>> g = LieAlgebra(QQ, cartan_type=['B', Integer(4)])
        >>> La = g.cartan_type().root_system().weight_lattice().fundamental_weights()
        >>> L = g.simple_module(Integer(2)*La[Integer(1)] + Integer(3)*La[Integer(4)])
        >>> L.dual() is L
        True

  highest_weight()

    Return the highest weight of `self`.

    EXAMPLES:

    Sage

        sage: g = lie_algebras.so(QQ, 7)
        sage: La = g.cartan_type().root_system().weight_lattice().fundamental_weights()
        sage: L = g.simple_module(La[1] + La[2])
        sage: L.highest_weight()
        Lambda[1] + Lambda[2]

    Python

        >>> from sage.all import *
        >>> g = lie_algebras.so(QQ, Integer(7))
        >>> La = g.cartan_type().root_system().weight_lattice().fundamental_weights()
        >>> L = g.simple_module(La[Integer(1)] + La[Integer(2)])
        >>> L.highest_weight()
        Lambda[1] + Lambda[2]

  highest_weight_vector()

    Return the highest weight vector of `self`.

    EXAMPLES:

    Sage

        sage: g = lie_algebras.sp(QQ, 6)
        sage: La = g.cartan_type().root_system().weight_lattice().fundamental_weights()
        sage: L = g.simple_module(La[1] + La[2])
        sage: L.highest_weight_vector()
        u[Lambda[1] + Lambda[2]]

    Python

        >>> from sage.all import *
        >>> g = lie_algebras.sp(QQ, Integer(6))
        >>> La = g.cartan_type().root_system().weight_lattice().fundamental_weights()
        >>> L = g.simple_module(La[Integer(1)] + La[Integer(2)])
        >>> L.highest_weight_vector()
        u[Lambda[1] + Lambda[2]]

  homogeneous_component_basis(mu)

    Return a basis for the `mu` weight space of `self`.

    EXAMPLES:

    Sage

        sage: g = LieAlgebra(QQ, cartan_type=['A', 2])
        sage: P = g.cartan_type().root_system().weight_lattice()
        sage: La = P.fundamental_weights()
        sage: la = La[1] + La[2]
        sage: L = g.simple_module(la)
        sage: from itertools import product
        sage: al = P.simple_roots()
        sage: for wts in product(range(4), repeat=2):
        ....:     mu = la - wts[0] * al[1] - wts[1] * al[2]
        ....:     print(mu)
        ....:     print(L.homogeneous_component_basis(mu))
        Lambda[1] + Lambda[2]
        Family (u[Lambda[1] + Lambda[2]],)
        2*Lambda[1] - Lambda[2]
        Family (f[-alpha[2]]*u[Lambda[1] + Lambda[2]],)
        3*Lambda[1] - 3*Lambda[2]
        Family ()
        4*Lambda[1] - 5*Lambda[2]
        Family ()
        -Lambda[1] + 2*Lambda[2]
        Family (f[-alpha[1]]*u[Lambda[1] + Lambda[2]],)
        0
        Family (f[-alpha[1] - alpha[2]]*u[Lambda[1] + Lambda[2]], f[-alpha[2]]*f[-alpha[1]]*u[Lambda[1] + Lambda[2]])
        Lambda[1] - 2*Lambda[2]
        Family (f[-alpha[2]]*f[-alpha[1] - alpha[2]]*u[Lambda[1] + Lambda[2]],)
        2*Lambda[1] - 4*Lambda[2]
        Family ()
        -3*Lambda[1] + 3*Lambda[2]
        Family ()
        -2*Lambda[1] + Lambda[2]
        Family (f[-alpha[1]]*f[-alpha[1] - alpha[2]]*u[Lambda[1] + Lambda[2]],)
        -Lambda[1] - Lambda[2]
        Family (f[-alpha[1] - alpha[2]]^2*u[Lambda[1] + Lambda[2]],)
        -3*Lambda[2]
        Family ()
        -5*Lambda[1] + 4*Lambda[2]
        Family ()
        -4*Lambda[1] + 2*Lambda[2]
        Family ()
        -3*Lambda[1]
        Family ()
        -2*Lambda[1] - 2*Lambda[2]
        Family ()

    Python

        >>> from sage.all import *
        >>> g = LieAlgebra(QQ, cartan_type=['A', Integer(2)])
        >>> P = g.cartan_type().root_system().weight_lattice()
        >>> La = P.fundamental_weights()
        >>> la = La[Integer(1)] + La[Integer(2)]
        >>> L = g.simple_module(la)
        >>> from itertools import product
        >>> al = P.simple_roots()
        >>> for wts in product(range(Integer(4)), repeat=Integer(2)):
        ...     mu = la - wts[Integer(0)] * al[Integer(1)] - wts[Integer(1)] * al[Integer(2)]
        ...     print(mu)
        ...     print(L.homogeneous_component_basis(mu))
        Lambda[1] + Lambda[2]
        Family (u[Lambda[1] + Lambda[2]],)
        2*Lambda[1] - Lambda[2]
        Family (f[-alpha[2]]*u[Lambda[1] + Lambda[2]],)
        3*Lambda[1] - 3*Lambda[2]
        Family ()
        4*Lambda[1] - 5*Lambda[2]
        Family ()
        -Lambda[1] + 2*Lambda[2]
        Family (f[-alpha[1]]*u[Lambda[1] + Lambda[2]],)
        0
        Family (f[-alpha[1] - alpha[2]]*u[Lambda[1] + Lambda[2]], f[-alpha[2]]*f[-alpha[1]]*u[Lambda[1] + Lambda[2]])
        Lambda[1] - 2*Lambda[2]
        Family (f[-alpha[2]]*f[-alpha[1] - alpha[2]]*u[Lambda[1] + Lambda[2]],)
        2*Lambda[1] - 4*Lambda[2]
        Family ()
        -3*Lambda[1] + 3*Lambda[2]
        Family ()
        -2*Lambda[1] + Lambda[2]
        Family (f[-alpha[1]]*f[-alpha[1] - alpha[2]]*u[Lambda[1] + Lambda[2]],)
        -Lambda[1] - Lambda[2]
        Family (f[-alpha[1] - alpha[2]]^2*u[Lambda[1] + Lambda[2]],)
        -3*Lambda[2]
        Family ()
        -5*Lambda[1] + 4*Lambda[2]
        Family ()
        -4*Lambda[1] + 2*Lambda[2]
        Family ()
        -3*Lambda[1]
        Family ()
        -2*Lambda[1] - 2*Lambda[2]
        Family ()

  lie_algebra()

    Return the underlying Lie algebra of `self`.

    EXAMPLES:

    Sage

        sage: g = lie_algebras.so(QQ, 9)
        sage: La = g.cartan_type().root_system().weight_space().fundamental_weights()
        sage: L = g.simple_module(La[3] - 1/2*La[1])
        sage: L.lie_algebra()
        Lie algebra of ['B', 4] in the Chevalley basis

    Python

        >>> from sage.all import *
        >>> g = lie_algebras.so(QQ, Integer(9))
        >>> La = g.cartan_type().root_system().weight_space().fundamental_weights()
        >>> L = g.simple_module(La[Integer(3)] - Integer(1)/Integer(2)*La[Integer(1)])
        >>> L.lie_algebra()
        Lie algebra of ['B', 4] in the Chevalley basis

  lift()

    Return the lift map of `self` to the ambient dual Verma module.

    EXAMPLES:

    Sage

        sage: g = LieAlgebra(QQ, cartan_type=['G', 2])
        sage: La = g.cartan_type().root_system().weight_lattice().fundamental_weights()
        sage: L = g.simple_module(La[1])
        sage: [L.lift(b) for b in L.basis()]  # long time
        [v[Lambda[1]]^*,
         f[-alpha[1]]*v[Lambda[1]]^*,
         f[-alpha[2]]*f[-alpha[1]]*v[Lambda[1]]^* - f[-alpha[1] - alpha[2]]*v[Lambda[1]]^*,
         f[-alpha[1]]*f[-alpha[1] - alpha[2]]*v[Lambda[1]]^*
          + f[-2*alpha[1] - alpha[2]]*v[Lambda[1]]^*,
         f[-alpha[1]]^2*f[-alpha[1] - alpha[2]]*v[Lambda[1]]^*
          + f[-alpha[1]]*f[-2*alpha[1] - alpha[2]]*v[Lambda[1]]^*
          + 1/2*f[-3*alpha[1] - alpha[2]]*v[Lambda[1]]^*,
         f[-alpha[2]]*f[-alpha[1]]^2*f[-alpha[1] - alpha[2]]*v[Lambda[1]]^*
          + f[-alpha[2]]*f[-alpha[1]]*f[-2*alpha[1] - alpha[2]]*v[Lambda[1]]^*
          + 1/2*f[-alpha[2]]*f[-3*alpha[1] - alpha[2]]*v[Lambda[1]]^*
          - f[-alpha[1] - alpha[2]]*f[-2*alpha[1] - alpha[2]]*v[Lambda[1]]^*
          + 1/2*f[-3*alpha[1] - 2*alpha[2]]*v[Lambda[1]]^*,
         f[-alpha[1]]*f[-alpha[1] - alpha[2]]*f[-2*alpha[1] - alpha[2]]*v[Lambda[1]]^*
          - 1/2*f[-alpha[1]]*f[-3*alpha[1] - 2*alpha[2]]*v[Lambda[1]]^*
          - 1/2*f[-alpha[1] - alpha[2]]*f[-3*alpha[1] - alpha[2]]*v[Lambda[1]]^*
          + f[-2*alpha[1] - alpha[2]]^2*v[Lambda[1]]^*]

    Python

        >>> from sage.all import *
        >>> g = LieAlgebra(QQ, cartan_type=['G', Integer(2)])
        >>> La = g.cartan_type().root_system().weight_lattice().fundamental_weights()
        >>> L = g.simple_module(La[Integer(1)])
        >>> [L.lift(b) for b in L.basis()]  # long time
        [v[Lambda[1]]^*,
         f[-alpha[1]]*v[Lambda[1]]^*,
         f[-alpha[2]]*f[-alpha[1]]*v[Lambda[1]]^* - f[-alpha[1] - alpha[2]]*v[Lambda[1]]^*,
         f[-alpha[1]]*f[-alpha[1] - alpha[2]]*v[Lambda[1]]^*
          + f[-2*alpha[1] - alpha[2]]*v[Lambda[1]]^*,
         f[-alpha[1]]^2*f[-alpha[1] - alpha[2]]*v[Lambda[1]]^*
          + f[-alpha[1]]*f[-2*alpha[1] - alpha[2]]*v[Lambda[1]]^*
          + 1/2*f[-3*alpha[1] - alpha[2]]*v[Lambda[1]]^*,
         f[-alpha[2]]*f[-alpha[1]]^2*f[-alpha[1] - alpha[2]]*v[Lambda[1]]^*
          + f[-alpha[2]]*f[-alpha[1]]*f[-2*alpha[1] - alpha[2]]*v[Lambda[1]]^*
          + 1/2*f[-alpha[2]]*f[-3*alpha[1] - alpha[2]]*v[Lambda[1]]^*
          - f[-alpha[1] - alpha[2]]*f[-2*alpha[1] - alpha[2]]*v[Lambda[1]]^*
          + 1/2*f[-3*alpha[1] - 2*alpha[2]]*v[Lambda[1]]^*,
         f[-alpha[1]]*f[-alpha[1] - alpha[2]]*f[-2*alpha[1] - alpha[2]]*v[Lambda[1]]^*
          - 1/2*f[-alpha[1]]*f[-3*alpha[1] - 2*alpha[2]]*v[Lambda[1]]^*
          - 1/2*f[-alpha[1] - alpha[2]]*f[-3*alpha[1] - alpha[2]]*v[Lambda[1]]^*
          + f[-2*alpha[1] - alpha[2]]^2*v[Lambda[1]]^*]

  pbw_basis()

    Return the PBW basis of the underlying Lie algebra used to define `self`.

    EXAMPLES:

    Sage

        sage: g = lie_algebras.so(QQ, 8)
        sage: La = g.cartan_type().root_system().weight_lattice().fundamental_weights()
        sage: L = g.simple_module(La[2] - 2*La[3])
        sage: L.pbw_basis()
        Universal enveloping algebra of Lie algebra of ['D', 4] in the Chevalley basis
         in the Poincare-Birkhoff-Witt basis

    Python

        >>> from sage.all import *
        >>> g = lie_algebras.so(QQ, Integer(8))
        >>> La = g.cartan_type().root_system().weight_lattice().fundamental_weights()
        >>> L = g.simple_module(La[Integer(2)] - Integer(2)*La[Integer(3)])
        >>> L.pbw_basis()
        Universal enveloping algebra of Lie algebra of ['D', 4] in the Chevalley basis
         in the Poincare-Birkhoff-Witt basis

  retract(x)

    Return the retraction of `x` in `self`.

    EXAMPLES:

    Sage

        sage: g = LieAlgebra(QQ, cartan_type=['A', 2])
        sage: La = g.cartan_type().root_system().weight_lattice().fundamental_weights()
        sage: L = g.simple_module(2*La[1])
        sage: L.retract(L.lift(sum(L.basis())))
        f[-alpha[1]]^2*u[2*Lambda[1]] + f[-alpha[1]]*f[-alpha[1] - alpha[2]]*u[2*Lambda[1]]
         + f[-alpha[1] - alpha[2]]^2*u[2*Lambda[1]] + f[-alpha[1]]*u[2*Lambda[1]]
         + f[-alpha[1] - alpha[2]]*u[2*Lambda[1]] + u[2*Lambda[1]]
        sage: B = list(L.basis())
        sage: L.retract(3/2*L.lift(B[0]) - L.lift(B[2]) - 10/3*L.lift(B[3]))
        -10/3*f[-alpha[1]]^2*u[2*Lambda[1]]
         - f[-alpha[1] - alpha[2]]*u[2*Lambda[1]]
         + 3/2*u[2*Lambda[1]]

    Python

        >>> from sage.all import *
        >>> g = LieAlgebra(QQ, cartan_type=['A', Integer(2)])
        >>> La = g.cartan_type().root_system().weight_lattice().fundamental_weights()
        >>> L = g.simple_module(Integer(2)*La[Integer(1)])
        >>> L.retract(L.lift(sum(L.basis())))
        f[-alpha[1]]^2*u[2*Lambda[1]] + f[-alpha[1]]*f[-alpha[1] - alpha[2]]*u[2*Lambda[1]]
         + f[-alpha[1] - alpha[2]]^2*u[2*Lambda[1]] + f[-alpha[1]]*u[2*Lambda[1]]
         + f[-alpha[1] - alpha[2]]*u[2*Lambda[1]] + u[2*Lambda[1]]
        >>> B = list(L.basis())
        >>> L.retract(Integer(3)/Integer(2)*L.lift(B[Integer(0)]) - L.lift(B[Integer(2)]) - Integer(10)/Integer(3)*L.lift(B[Integer(3)]))
        -10/3*f[-alpha[1]]^2*u[2*Lambda[1]]
         - f[-alpha[1] - alpha[2]]*u[2*Lambda[1]]
         + 3/2*u[2*Lambda[1]]

  weight_space_basis(mu)

    alias of `homogeneous_component_basis()`.

class sage.algebras.lie_algebras.bgg_dual_module.SimpleModuleIndices(simple, prefix, category=None, **kwds)

  Bases: `IndexedFreeAbelianMonoid`

  The indices of the basis for a simple \(U(\mathfrak{g})\)-module.

  Note

  The current implementation assumes the Lie algebra \(\mathfrak{g}\) is finite dimensional.

  cardinality()

    Return the cardinality of `self`.

    EXAMPLES:

    Sage

        sage: g = LieAlgebra(QQ, cartan_type=['E', 6])
        sage: La = g.cartan_type().root_system().weight_lattice().fundamental_weights()
        sage: L = g.simple_module(La[1]+La[4])
        sage: L._indices.cardinality()
        51975

    Python

        >>> from sage.all import *
        >>> g = LieAlgebra(QQ, cartan_type=['E', Integer(6)])
        >>> La = g.cartan_type().root_system().weight_lattice().fundamental_weights()
        >>> L = g.simple_module(La[Integer(1)]+La[Integer(4)])
        >>> L._indices.cardinality()
        51975

  weight_space_basis(mu)

    Return the indices of the `mu` weight space basis elements.

    EXAMPLES:

    Sage

        sage: g = LieAlgebra(QQ, cartan_type=['A', 2])
        sage: P = g.cartan_type().root_system().weight_lattice()
        sage: La = P.fundamental_weights()
        sage: al = P.simple_roots()
        sage: wt = -3*La[1] + 3*La[2]
        sage: I = g.simple_module(wt).indices()
        sage: I.weight_space_basis(wt)
        [1]
        sage: I.weight_space_basis(wt - al[1])
        [f[-alpha[1]]]
        sage: I.weight_space_basis(wt - al[2])
        [f[-alpha[2]]]
        sage: I.weight_space_basis(wt - al[1] - al[2])
        [f[-alpha[1] - alpha[2]], f[-alpha[2]]*f[-alpha[1]]]
        sage: I.weight_space_basis(wt - 4*al[1])
        [f[-alpha[1]]^4]
        sage: I.weight_space_basis(wt - 4*al[2])
        []

    Python

        >>> from sage.all import *
        >>> g = LieAlgebra(QQ, cartan_type=['A', Integer(2)])
        >>> P = g.cartan_type().root_system().weight_lattice()
        >>> La = P.fundamental_weights()
        >>> al = P.simple_roots()
        >>> wt = -Integer(3)*La[Integer(1)] + Integer(3)*La[Integer(2)]
        >>> I = g.simple_module(wt).indices()
        >>> I.weight_space_basis(wt)
        [1]
        >>> I.weight_space_basis(wt - al[Integer(1)])
        [f[-alpha[1]]]
        >>> I.weight_space_basis(wt - al[Integer(2)])
        [f[-alpha[2]]]
        >>> I.weight_space_basis(wt - al[Integer(1)] - al[Integer(2)])
        [f[-alpha[1] - alpha[2]], f[-alpha[2]]*f[-alpha[1]]]
        >>> I.weight_space_basis(wt - Integer(4)*al[Integer(1)])
        [f[-alpha[1]]^4]
        >>> I.weight_space_basis(wt - Integer(4)*al[Integer(2)])
        []