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 algebraf
– the Lie algebra morphism defining the action of the basis elements oflie_algebra
index_set
– (optional) the index set of the module basison_basis
– (default:False
) the functionf
defines a map from the basis elements or from a generic element oflie_algebra
If
f
is encoded as adict
orFamily
, then the keys must be indices of the basis oflie_algebra
and the values being the corresponding matrix defining the action. This setson_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