Kac-Moody Algebras With Triangular Decomposition Basis

AUTHORS:

  • Travis Scrimshaw (07-15-2017): Initial implementation

class sage.categories.triangular_kac_moody_algebras.TriangularKacMoodyAlgebras(base, name=None)[source]

Bases: Category_over_base_ring

Category of Kac-Moody algebras with a distinguished basis that respects the triangular decomposition.

We require that the grading group is the root lattice of the appropriate Cartan type.

class ElementMethods[source]

Bases: object

part()[source]

Return whether the element v is in the lower, zero, or upper part of self.

OUTPUT:

\(-1\) if v is in the lower part, \(0\) if in the zero part, or \(1\) if in the upper part

EXAMPLES:

sage: # needs sage.combinat sage.modules
sage: L = LieAlgebra(QQ, cartan_type='F4')
sage: L.inject_variables()
Defining e1, e2, e3, e4, f1, f2, f3, f4, h1, h2, h3, h4
sage: e1.part()
1
sage: f4.part()
-1
sage: (h2 + h3).part()
0
sage: (f1.bracket(f2) + 4*f4).part()
-1
sage: (e1 + f1).part()
Traceback (most recent call last):
...
ValueError: element is not in one part

>>> from sage.all import *
>>> # needs sage.combinat sage.modules
>>> L = LieAlgebra(QQ, cartan_type='F4')
>>> L.inject_variables()
Defining e1, e2, e3, e4, f1, f2, f3, f4, h1, h2, h3, h4
>>> e1.part()
1
>>> f4.part()
-1
>>> (h2 + h3).part()
0
>>> (f1.bracket(f2) + Integer(4)*f4).part()
-1
>>> (e1 + f1).part()
Traceback (most recent call last):
...
ValueError: element is not in one part
class FiniteDimensional(base_category)[source]

Bases: CategoryWithAxiom_over_base_ring

Category of finite dimensional Kac-Moody algebras (which correspond to semisimple Lie algebras) with a distinguished basis that respects the triangular decomposition.

class ElementMethods[source]

Bases: object

transpose()[source]

Return the transpose of self.

The transpose \(\tau\) is the map that sends the root basis elements \(e_{\alpha} \leftrightarrow e_{-\alpha}\) and fixes the Cartan subalgebra \(h_{\alpha}\). It is an anti-involution in the sense \([\tau(a), \tau(b)] = \tau([b, a])\).

EXAMPLES:

sage: # needs sage.combinat sage.modules
sage: g = LieAlgebra(QQ, cartan_type=['G', 2])
sage: for b in g.basis():
....:     for bp in g.basis():
....:         a = g[b.transpose(), bp.transpose()]
....:         ap = g[bp, b].transpose()
....:         assert a == ap

>>> from sage.all import *
>>> # needs sage.combinat sage.modules
>>> g = LieAlgebra(QQ, cartan_type=['G', Integer(2)])
>>> for b in g.basis():
...     for bp in g.basis():
...         a = g[b.transpose(), bp.transpose()]
...         ap = g[bp, b].transpose()
...         assert a == ap
class ParentMethods[source]

Bases: object

transpose()[source]

The transpose map of self.

EXAMPLES:

sage: # needs sage.combinat sage.modules
sage: g = LieAlgebra(QQ, cartan_type=['B', 2])
sage: g.transpose
Generic endomorphism of Lie algebra of ['B', 2] in the Chevalley basis

>>> from sage.all import *
>>> # needs sage.combinat sage.modules
>>> g = LieAlgebra(QQ, cartan_type=['B', Integer(2)])
>>> g.transpose
Generic endomorphism of Lie algebra of ['B', 2] in the Chevalley basis
class ParentMethods[source]

Bases: object

e(i=None)[source]

Return the generators \(e\) of self.

INPUT:

  • i – (optional) if specified, return just the generator \(e_i\)

EXAMPLES:

sage: L = lie_algebras.so(QQ, 5)                                        # needs sage.combinat sage.modules
sage: L.e()                                                             # needs sage.combinat sage.modules
Finite family {1: E[alpha[1]], 2: E[alpha[2]]}
sage: L.e(1)                                                            # needs sage.combinat sage.modules
E[alpha[1]]

>>> from sage.all import *
>>> L = lie_algebras.so(QQ, Integer(5))                                        # needs sage.combinat sage.modules
>>> L.e()                                                             # needs sage.combinat sage.modules
Finite family {1: E[alpha[1]], 2: E[alpha[2]]}
>>> L.e(Integer(1))                                                            # needs sage.combinat sage.modules
E[alpha[1]]
f(i=None)[source]

Return the generators \(f\) of self.

INPUT:

  • i – (optional) if specified, return just the generator \(f_i\)

EXAMPLES:

sage: L = lie_algebras.so(QQ, 5)                                        # needs sage.combinat sage.modules
sage: L.f()                                                             # needs sage.combinat sage.modules
Finite family {1: E[-alpha[1]], 2: E[-alpha[2]]}
sage: L.f(1)                                                            # needs sage.combinat sage.modules
E[-alpha[1]]

>>> from sage.all import *
>>> L = lie_algebras.so(QQ, Integer(5))                                        # needs sage.combinat sage.modules
>>> L.f()                                                             # needs sage.combinat sage.modules
Finite family {1: E[-alpha[1]], 2: E[-alpha[2]]}
>>> L.f(Integer(1))                                                            # needs sage.combinat sage.modules
E[-alpha[1]]
simple_module(la, basis_key=None, **kwds)[source]

Return the simple module with highest weight la over self.

INPUT:

  • la – the weight

  • basis_key – (optional) a key function for the indexing set of the basis elements of self

OUTPUT:

If la is Verma antidominant, then this returns the VermaModule of highest weight la (which is simple and more efficient). Otherwise this returns a SimpleModule.

EXAMPLES:

sage: # needs sage.combinat sage.modules
sage: g = lie_algebras.sl(QQ, 3)
sage: P = g.cartan_type().root_system().weight_lattice()
sage: La = P.fundamental_weights()
sage: L = g.simple_module(La[1] + La[2])
sage: L
Simple module with highest weight Lambda[1] + Lambda[2]
 of Lie algebra of ['A', 2] in the Chevalley basis
sage: L = g.simple_module(-La[1] - La[2])
sage: L
Verma module with highest weight -Lambda[1] - Lambda[2]
 of Lie algebra of ['A', 2] in the Chevalley basis

>>> from sage.all import *
>>> # needs sage.combinat sage.modules
>>> g = lie_algebras.sl(QQ, Integer(3))
>>> P = g.cartan_type().root_system().weight_lattice()
>>> La = P.fundamental_weights()
>>> L = g.simple_module(La[Integer(1)] + La[Integer(2)])
>>> L
Simple module with highest weight Lambda[1] + Lambda[2]
 of Lie algebra of ['A', 2] in the Chevalley basis
>>> L = g.simple_module(-La[Integer(1)] - La[Integer(2)])
>>> L
Verma module with highest weight -Lambda[1] - Lambda[2]
 of Lie algebra of ['A', 2] in the Chevalley basis
verma_module(la, basis_key=None, **kwds)[source]

Return the Verma module with highest weight la over self.

INPUT:

  • basis_key – (optional) a key function for the indexing set of the basis elements of self

EXAMPLES:

sage: # needs sage.combinat sage.modules
sage: L = lie_algebras.sl(QQ, 3)
sage: P = L.cartan_type().root_system().weight_lattice()
sage: La = P.fundamental_weights()
sage: M = L.verma_module(La[1] + La[2])
sage: M
Verma module with highest weight Lambda[1] + Lambda[2]
 of Lie algebra of ['A', 2] in the Chevalley basis

>>> from sage.all import *
>>> # needs sage.combinat sage.modules
>>> L = lie_algebras.sl(QQ, Integer(3))
>>> P = L.cartan_type().root_system().weight_lattice()
>>> La = P.fundamental_weights()
>>> M = L.verma_module(La[Integer(1)] + La[Integer(2)])
>>> M
Verma module with highest weight Lambda[1] + Lambda[2]
 of Lie algebra of ['A', 2] in the Chevalley basis
super_categories()[source]

EXAMPLES:

sage: from sage.categories.triangular_kac_moody_algebras import TriangularKacMoodyAlgebras
sage: TriangularKacMoodyAlgebras(QQ).super_categories()
[Join of Category of graded Lie algebras with basis over Rational Field
     and Category of kac moody algebras over Rational Field]

>>> from sage.all import *
>>> from sage.categories.triangular_kac_moody_algebras import TriangularKacMoodyAlgebras
>>> TriangularKacMoodyAlgebras(QQ).super_categories()
[Join of Category of graded Lie algebras with basis over Rational Field
     and Category of kac moody algebras over Rational Field]