BGG Category O Dual Modules¶

AUTHORS:

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

class sage.algebras.lie_algebras.bgg_dual_module.BGGDualModule(module)[source]¶

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[source]¶: Bases: IndexedFreeModuleElement

degree_on_basis(m)[source]¶

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()[source]¶

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()[source]¶

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()[source]¶

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()[source]¶

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)[source]¶

Bases: SimpleModule

A finite dimensional simple module.

bgg_resolution()[source]¶

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)[source]¶

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[source]¶: Bases: IndexedFreeModuleElement

ambient()[source]¶

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()[source]¶

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()[source]¶

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()[source]¶

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)[source]¶

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()[source]¶

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()[source]¶

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()[source]¶

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)[source]¶

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)[source]¶

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 ()

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

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()[source]¶

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)[source]¶

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)])
[]