Representations of Lie algebras#

AUTHORS:

  • Travis Scrimshaw (2023-08-31): initial version

class sage.algebras.lie_algebras.representation.RepresentationByMorphism(lie_algebra, f, index_set, on_basis, category, **kwargs)#

Bases: CombinatorialFreeModule, Representation_abstract

Representation of a Lie algebra defined by a Lie algebra morphism.

INPUT:

  • lie_algebra – a Lie algebra

  • f – the Lie algebra morphism defining the action of the basis elements of lie_algebra

  • index_set – (optional) the index set of the module basis

  • on_basis – (default: False) the function f defines a map from the basis elements or from a generic element of lie_algebra

If f is encoded as a dict or Family, then the keys must be indices of the basis of lie_algebra and the values being the corresponding matrix defining the action. This sets on_basis=True.

EXAMPLES:

sage: L.<x,y> = LieAlgebra(QQ, {('x','y'): {'y':1}})
sage: f = {x: Matrix([[1,0],[0,0]]), y: Matrix([[0,1],[0,0]])}
sage: L.representation(f)
Representation of Lie algebra on 2 generators (x, y) over Rational Field defined by:
       [1 0]
x |--> [0 0]
       [0 1]
y |--> [0 0]

We construct the direct sum of two copies of the trivial representation for an infinite dimensional Lie algebra:

sage: L = lie_algebras.Affine(QQ, ['E',6,1])
sage: R = L.representation(lambda b: matrix.zero(QQ, 2), index_set=['a','b'])
sage: x = L.an_element()
sage: v = R.an_element(); v
2*R['a'] + 2*R['b']
sage: x * v
0

We construct a finite dimensional representation of the affline Lie algebra of type \(A_2^{(1)}\):

sage: L = lie_algebras.Affine(QQ, ['A',2,1]).derived_subalgebra()
sage: Phi_plus = list(RootSystem(['A',2]).root_lattice().positive_roots())
sage: def aff_action(key):
....:     mat = matrix.zero(QQ, 3)
....:     if key == 'c':  # central element
....:         return mat
....:     b, ell = key
....:     if b in Phi_plus:  # positive root
....:         ind = tuple(sorted(b.to_ambient().support()))
....:         mat[ind] = 1
....:         if ind[0] + 1 != ind[1]:
....:             mat[ind] = -1
....:     elif -b in Phi_plus:  # negative root
....:         ind = tuple(sorted(b.to_ambient().support(), reverse=True))
....:         mat[ind] = 1
....:         if ind[0] - 1 != ind[1]:
....:             mat[ind] = -1
....:     else:  # must be in the Cartan
....:         i = b.leading_support()
....:         mat[i,i] = -1
....:         mat[i-1,i-1] = 1
....:     return mat
sage: F = Family(L.basis(), aff_action, name="lifted natural repr")
sage: R = L.representation(index_set=range(1,4), on_basis=F)
sage: x = L.an_element(); x
(E[alpha[2]] + E[alpha[1]] + h1 + h2 + E[-alpha[2]] + E[-alpha[1]])#t^0
 + (E[-alpha[1] - alpha[2]])#t^1 + (E[alpha[1] + alpha[2]])#t^-1 + c
sage: v = R.an_element(); v
2*R[1] + 2*R[2] + 3*R[3]
sage: x * v
R[1] + 5*R[2] - 3*R[3]
sage: R._test_representation()  # verify that it is a representation
class Element#

Bases: IndexedFreeModuleElement

class sage.algebras.lie_algebras.representation.Representation_abstract(lie_algebra)#

Bases: object

Mixin class for (left) representations of Lie algebras.

INPUT:

  • lie_algebra – a Lie algebra

lie_algebra()#

Return the Lie algebra whose representation self is.

EXAMPLES:

sage: L = lie_algebras.sl(QQ, 4)
sage: R = L.trivial_representation()
sage: R.lie_algebra() is L
True
side()#

Return that self is a left representation.

OUTPUT:

  • the string "left"

EXAMPLES:

sage: L = lie_algebras.sl(QQ, 4)
sage: R = L.trivial_representation()
sage: R.side()
'left'
class sage.algebras.lie_algebras.representation.TrivialRepresentation(lie_algebra, **kwargs)#

Bases: CombinatorialFreeModule, Representation_abstract

The trivial representation of a Lie algebra.

The trivial representation of a Lie algebra \(L\) over a commutative ring \(R\) is the \(1\)-dimensional \(R\)-module on which every element of \(L\) acts by zero.

INPUT:

  • lie_algebra – a Lie algebra

REFERENCES:

class Element#

Bases: IndexedFreeModuleElement