Lie Algebras - Algebras

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

# Lie Algebras

AUTHORS:

- Travis Scrimshaw (2013-05-03): Initial version

class sage.algebras.lie_algebras.lie_algebra.FinitelyGeneratedLieAlgebra(R, names=None, index_set=None, category=None)

  Bases: `LieAlgebraWithGenerators`

  A finitely generated Lie algebra.

class sage.algebras.lie_algebras.lie_algebra.InfinitelyGeneratedLieAlgebra(R, names=None, index_set=None, category=None, prefix='L', **kwds)

  Bases: `LieAlgebraWithGenerators`

  An infinitely generated Lie algebra.

class sage.algebras.lie_algebras.lie_algebra.LieAlgebra(R, names=None, category=None)

  Bases: `Parent`, `UniqueRepresentation`

  A Lie algebra \(L\) over a base ring \(R\).

  A Lie algebra is an \(R\)-module \(L\) with a bilinear operation called Lie bracket \([\cdot, \cdot] : L \times L \to L\) such that \([x, x] = 0\) and the following relation holds:

  \[\bigl[ x, [y, z] \bigr] + \bigl[ y, [z, x] \bigr] + \bigl[ z, [x, y] \bigr] = 0.\]

  This relation is known as the Jacobi identity (or sometimes the Jacobi relation). We note that from \([x, x] = 0\), we have \([x + y, x + y] = 0\). Next from bilinearity, we see that

  \[0 = [x + y, x + y] = [x, x] + [x, y] + [y, x] + [y, y] = [x, y] + [y, x],\]

  thus \([x, y] = -[y, x]\) and the Lie bracket is antisymmetric.

  Lie algebras are closely related to Lie groups. Let \(G\) be a Lie group and fix some \(g \in G\). We can construct the Lie algebra \(L\) of \(G\) by considering the tangent space at \(g\). We can also (partially) recover \(G\) from \(L\) by using what is known as the exponential map.

  Given any associative algebra \(A\), we can construct a Lie algebra \(L\) on the \(R\)-module \(A\) by defining the Lie bracket to be the commutator \([a, b] = ab - ba\). We call an associative algebra \(A\) which contains \(L\) in this fashion an enveloping algebra of \(L\). The embedding \(L \to A\) which sends the Lie bracket to the commutator will be called a Lie embedding. Now if we are given a Lie algebra \(L\), we can construct an enveloping algebra \(U_L\) with Lie embedding \(h : L \to U_L\) which has the following universal property: for any enveloping algebra \(A\) with Lie embedding \(f : L \to A\), there exists a unique unital algebra homomorphism \(g : U_L \to A\) such that \(f = g \circ h\). The algebra \(U_L\) is known as the universal enveloping algebra of \(L\).

  INPUT:

  See examples below for various input options.

  EXAMPLES:

  1. The simplest examples of Lie algebras are abelian Lie algebras. These are Lie algebras whose Lie bracket is (identically) zero. We can create them using the `abelian` keyword:

  Sage

      sage: L.<x,y,z> = LieAlgebra(QQ, abelian=True); L
      Abelian Lie algebra on 3 generators (x, y, z) over Rational Field

  Python

      >>> from sage.all import *
      >>> L = LieAlgebra(QQ, abelian=True, names=('x', 'y', 'z',)); (x, y, z,) = L._first_ngens(3); L
      Abelian Lie algebra on 3 generators (x, y, z) over Rational Field

  2. A Lie algebra can be built from any associative algebra by defining the Lie bracket to be the commutator. For example, we can start with the descent algebra:

  Sage

      sage: D = DescentAlgebra(QQ, 4).D()
      sage: L = LieAlgebra(associative=D); L
      Lie algebra of Descent algebra of 4 over Rational Field
       in the standard basis
      sage: L(D[2]).bracket(L(D[3]))
      D{1, 2} - D{1, 3} + D{2} - D{3}

  [Python]

      >>> from sage.all import *
      >>> D = DescentAlgebra(QQ, Integer(4)).D()
      >>> L = LieAlgebra(associative=D); L
      Lie algebra of Descent algebra of 4 over Rational Field
       in the standard basis
      >>> L(D[Integer(2)]).bracket(L(D[Integer(3)]))
      D{1, 2} - D{1, 3} + D{2} - D{3}

  Next we use a free algebra and do some simple computations:

  Sage

      sage: R.<a,b,c> = FreeAlgebra(QQ, 3)
      sage: L.<x,y,z> = LieAlgebra(associative=R.gens())
      sage: x-y+z
      a - b + c
      sage: L.bracket(x-y, x-z)
      a*b - a*c - b*a + b*c + c*a - c*b
      sage: L.bracket(x-y, L.bracket(x,y))
      a^2*b - 2*a*b*a + a*b^2 + b*a^2 - 2*b*a*b + b^2*a

  Python

      >>> from sage.all import *
      >>> R = FreeAlgebra(QQ, Integer(3), names=('a', 'b', 'c',)); (a, b, c,) = R._first_ngens(3)
      >>> L = LieAlgebra(associative=R.gens(), names=('x', 'y', 'z',)); (x, y, z,) = L._first_ngens(3)
      >>> x-y+z
      a - b + c
      >>> L.bracket(x-y, x-z)
      a*b - a*c - b*a + b*c + c*a - c*b
      >>> L.bracket(x-y, L.bracket(x,y))
      a^2*b - 2*a*b*a + a*b^2 + b*a^2 - 2*b*a*b + b^2*a

  We can also use a subset of the elements as a generating set of the Lie algebra:

  Sage

      sage: R.<a,b,c> = FreeAlgebra(QQ, 3)
      sage: L.<x,y> = LieAlgebra(associative=[a,b+c])
      sage: L.bracket(x, y)
      a*b + a*c - b*a - c*a

  [Python]

      >>> from sage.all import *
      >>> R = FreeAlgebra(QQ, Integer(3), names=('a', 'b', 'c',)); (a, b, c,) = R._first_ngens(3)
      >>> L = LieAlgebra(associative=[a,b+c], names=('x', 'y',)); (x, y,) = L._first_ngens(2)
      >>> L.bracket(x, y)
      a*b + a*c - b*a - c*a

  Now for a more complicated example using the group ring of \(S_3\) as our base algebra:

  Sage

      sage: G = SymmetricGroup(3)
      sage: S = GroupAlgebra(G, QQ)
      sage: L.<x,y> = LieAlgebra(associative=S.gens())
      sage: L.bracket(x, y)
      (2,3) - (1,3)
      sage: L.bracket(x, y-x)
      (2,3) - (1,3)
      sage: L.bracket(L.bracket(x, y), y)
      2*(1,2,3) - 2*(1,3,2)
      sage: L.bracket(x, L.bracket(x, y))
      (2,3) - 2*(1,2) + (1,3)
      sage: L.bracket(x, L.bracket(L.bracket(x, y), y))
      0

  Python

      >>> from sage.all import *
      >>> G = SymmetricGroup(Integer(3))
      >>> S = GroupAlgebra(G, QQ)
      >>> L = LieAlgebra(associative=S.gens(), names=('x', 'y',)); (x, y,) = L._first_ngens(2)
      >>> L.bracket(x, y)
      (2,3) - (1,3)
      >>> L.bracket(x, y-x)
      (2,3) - (1,3)
      >>> L.bracket(L.bracket(x, y), y)
      2*(1,2,3) - 2*(1,3,2)
      >>> L.bracket(x, L.bracket(x, y))
      (2,3) - 2*(1,2) + (1,3)
      >>> L.bracket(x, L.bracket(L.bracket(x, y), y))
      0

  Here is an example using matrices:

  Sage

      sage: MS = MatrixSpace(QQ,2)
      sage: m1 = MS([[0, -1], [1, 0]])
      sage: m2 = MS([[-1, 4], [3, 2]])
      sage: L.<x,y> = LieAlgebra(associative=[m1, m2])
      sage: x
      [ 0 -1]
      [ 1  0]
      sage: y
      [-1  4]
      [ 3  2]
      sage: L.bracket(x,y)
      [-7 -3]
      [-3  7]
      sage: L.bracket(y,y)
      [0 0]
      [0 0]
      sage: L.bracket(y,x)
      [ 7  3]
      [ 3 -7]
      sage: L.bracket(x, L.bracket(y,x))
      [-6 14]
      [14  6]

  [Python]

      >>> from sage.all import *
      >>> MS = MatrixSpace(QQ,Integer(2))
      >>> m1 = MS([[Integer(0), -Integer(1)], [Integer(1), Integer(0)]])
      >>> m2 = MS([[-Integer(1), Integer(4)], [Integer(3), Integer(2)]])
      >>> L = LieAlgebra(associative=[m1, m2], names=('x', 'y',)); (x, y,) = L._first_ngens(2)
      >>> x
      [ 0 -1]
      [ 1  0]
      >>> y
      [-1  4]
      [ 3  2]
      >>> L.bracket(x,y)
      [-7 -3]
      [-3  7]
      >>> L.bracket(y,y)
      [0 0]
      [0 0]
      >>> L.bracket(y,x)
      [ 7  3]
      [ 3 -7]
      >>> L.bracket(x, L.bracket(y,x))
      [-6 14]
      [14  6]

  (See `LieAlgebraFromAssociative` for other examples.)

  3. We can also creating a Lie algebra by inputting a set of structure coefficients. For example, we can create the Lie algebra of \(\QQ^3\) under the Lie bracket \(\times\) (cross-product):

  Sage

      sage: d = {('x','y'): {'z':1}, ('y','z'): {'x':1}, ('z','x'): {'y':1}}
      sage: L.<x,y,z> = LieAlgebra(QQ, d)
      sage: L
      Lie algebra on 3 generators (x, y, z) over Rational Field

  Python

      >>> from sage.all import *
      >>> d = {('x','y'): {'z':Integer(1)}, ('y','z'): {'x':Integer(1)}, ('z','x'): {'y':Integer(1)}}
      >>> L = LieAlgebra(QQ, d, names=('x', 'y', 'z',)); (x, y, z,) = L._first_ngens(3)
      >>> L
      Lie algebra on 3 generators (x, y, z) over Rational Field

  To compute the Lie bracket of two elements, you cannot use the `*` operator. Indeed, this automatically lifts up to the universal enveloping algebra and takes the (associative) product there. To get elements in the Lie algebra, you must use `bracket()`:

  Sage

      sage: L = LieAlgebra(QQ, {('e','h'): {'e':-2}, ('f','h'): {'f':2},
      ....:                     ('e','f'): {'h':1}}, names='e,f,h')
      sage: e,f,h = L.lie_algebra_generators()
      sage: L.bracket(h, e)
      2*e
      sage: elt = h*e; elt
      e*h + 2*e
      sage: P = elt.parent(); P
      Noncommutative Multivariate Polynomial Ring in e, f, h over Rational Field,
       nc-relations: {...}
      sage: R = P.relations()
      sage: for rhs in sorted(R, key=str): print("{} = {}".format(rhs, R[rhs]))
      f*e = e*f - h
      h*e = e*h + 2*e
      h*f = f*h - 2*f

  [Python]

      >>> from sage.all import *
      >>> L = LieAlgebra(QQ, {('e','h'): {'e':-Integer(2)}, ('f','h'): {'f':Integer(2)},
      ...                     ('e','f'): {'h':Integer(1)}}, names='e,f,h')
      >>> e,f,h = L.lie_algebra_generators()
      >>> L.bracket(h, e)
      2*e
      >>> elt = h*e; elt
      e*h + 2*e
      >>> P = elt.parent(); P
      Noncommutative Multivariate Polynomial Ring in e, f, h over Rational Field,
       nc-relations: {...}
      >>> R = P.relations()
      >>> for rhs in sorted(R, key=str): print("{} = {}".format(rhs, R[rhs]))
      f*e = e*f - h
      h*e = e*h + 2*e
      h*f = f*h - 2*f

  For convenience, there are two shorthand notations for computing Lie brackets:

  Sage

      sage: L([h,e])
      2*e
      sage: L([h,[e,f]])
      0
      sage: L([[h,e],[e,f]])
      -4*e
      sage: L[h, e]
      2*e
      sage: L[h, L[e, f]]
      0

  Python

      >>> from sage.all import *
      >>> L([h,e])
      2*e
      >>> L([h,[e,f]])
      0
      >>> L([[h,e],[e,f]])
      -4*e
      >>> L[h, e]
      2*e
      >>> L[h, L[e, f]]
      0

  Warning

  Because this is a modified (abused) version of python syntax, it does NOT work with addition. For example `L([e + [h, f], h])` and `L[e + [h, f], h]` will both raise errors. Instead you must use `L[e + L[h, f], h]`.

  4. We can construct a Lie algebra from a Cartan type by using the `cartan_type` option:

  Sage

      sage: L = LieAlgebra(ZZ, cartan_type=['C', 3])
      sage: L.inject_variables()
      Defining e1, e2, e3, f1, f2, f3, h1, h2, h3
      sage: e1.bracket(e2)
      -E[alpha[1] + alpha[2]]
      sage: L([[e1, e2], e2])
      0
      sage: L([[e2, e3], e3])
      0
      sage: L([e2, [e2, e3]])
      2*E[2*alpha[2] + alpha[3]]

      sage: L = LieAlgebra(ZZ, cartan_type=['E', 6])
      sage: L
      Lie algebra of ['E', 6] in the Chevalley basis

  [Python]

      >>> from sage.all import *
      >>> L = LieAlgebra(ZZ, cartan_type=['C', Integer(3)])
      >>> L.inject_variables()
      Defining e1, e2, e3, f1, f2, f3, h1, h2, h3
      >>> e1.bracket(e2)
      -E[alpha[1] + alpha[2]]
      >>> L([[e1, e2], e2])
      0
      >>> L([[e2, e3], e3])
      0
      >>> L([e2, [e2, e3]])
      2*E[2*alpha[2] + alpha[3]]

      >>> L = LieAlgebra(ZZ, cartan_type=['E', Integer(6)])
      >>> L
      Lie algebra of ['E', 6] in the Chevalley basis

  When the Cartan type is finite type and simply-laced, we can also specify an asymmetry function from [Ka1990] using a Dynkin diagram orientation with the `epsilon` option:

  Sage

      sage: L = LieAlgebra(QQ, cartan_type=['A', 2], epsilon=[(1, 2)])
      sage: e1, e2 = L.e()
      sage: L[e1, e2]
      -E[alpha[1] + alpha[2]]

      sage: L = LieAlgebra(QQ, cartan_type=['A', 2], epsilon=[(2, 1)])
      sage: e1, e2 = L.e()
      sage: L[e1, e2]
      E[alpha[1] + alpha[2]]

  Python

      >>> from sage.all import *
      >>> L = LieAlgebra(QQ, cartan_type=['A', Integer(2)], epsilon=[(Integer(1), Integer(2))])
      >>> e1, e2 = L.e()
      >>> L[e1, e2]
      -E[alpha[1] + alpha[2]]

      >>> L = LieAlgebra(QQ, cartan_type=['A', Integer(2)], epsilon=[(Integer(2), Integer(1))])
      >>> e1, e2 = L.e()
      >>> L[e1, e2]
      E[alpha[1] + alpha[2]]

  We also have matrix versions of the classical Lie algebras:

  Sage

      sage: L = LieAlgebra(ZZ, cartan_type=['A', 2], representation='matrix')
      sage: L.gens()
      (
      [0 1 0]  [0 0 0]  [0 0 0]  [0 0 0]  [ 1  0  0]  [ 0  0  0]
      [0 0 0]  [0 0 1]  [1 0 0]  [0 0 0]  [ 0 -1  0]  [ 0  1  0]
      [0 0 0], [0 0 0], [0 0 0], [0 1 0], [ 0  0  0], [ 0  0 -1]
      )

  [Python]

      >>> from sage.all import *
      >>> L = LieAlgebra(ZZ, cartan_type=['A', Integer(2)], representation='matrix')
      >>> L.gens()
      (
      [0 1 0]  [0 0 0]  [0 0 0]  [0 0 0]  [ 1  0  0]  [ 0  0  0]
      [0 0 0]  [0 0 1]  [1 0 0]  [0 0 0]  [ 0 -1  0]  [ 0  1  0]
      [0 0 0], [0 0 0], [0 0 0], [0 1 0], [ 0  0  0], [ 0  0 -1]
      )

  There is also the compact real form of matrix Lie algebras implemented (the base ring must currently be a field):

  Sage

      sage: L = LieAlgebra(QQ, cartan_type=['A', 2], representation="compact real")
      sage: list(L.basis())
      [
      [ 0  1  0]  [ 0  0  1]  [ 0  0  0]  [ i  0  0]  [0 i 0]  [0 0 i]
      [-1  0  0]  [ 0  0  0]  [ 0  0  1]  [ 0  0  0]  [i 0 0]  [0 0 0]
      [ 0  0  0], [-1  0  0], [ 0 -1  0], [ 0  0 -i], [0 0 0], [i 0 0],

      [ 0  0  0]  [0 0 0]
      [ 0  i  0]  [0 0 i]
      [ 0  0 -i], [0 i 0]
      ]

  Python

      >>> from sage.all import *
      >>> L = LieAlgebra(QQ, cartan_type=['A', Integer(2)], representation="compact real")
      >>> list(L.basis())
      [
      [ 0  1  0]  [ 0  0  1]  [ 0  0  0]  [ i  0  0]  [0 i 0]  [0 0 i]
      [-1  0  0]  [ 0  0  0]  [ 0  0  1]  [ 0  0  0]  [i 0 0]  [0 0 0]
      [ 0  0  0], [-1  0  0], [ 0 -1  0], [ 0  0 -i], [0 0 0], [i 0 0],
      <BLANKLINE>
      [ 0  0  0]  [0 0 0]
      [ 0  i  0]  [0 0 i]
      [ 0  0 -i], [0 i 0]
      ]

  5. We construct a free Lie algebra in a few different ways. There are two primary representations, as brackets and as polynomials:

  Sage

      sage: L = LieAlgebra(QQ, 'x,y,z'); L
      Free Lie algebra generated by (x, y, z) over Rational Field
      sage: P.<a,b,c> = LieAlgebra(QQ, representation='polynomial'); P
      Lie algebra generated by (a, b, c) in
       Free Algebra on 3 generators (a, b, c) over Rational Field

  [Python]

      >>> from sage.all import *
      >>> L = LieAlgebra(QQ, 'x,y,z'); L
      Free Lie algebra generated by (x, y, z) over Rational Field
      >>> P = LieAlgebra(QQ, representation='polynomial', names=('a', 'b', 'c',)); (a, b, c,) = P._first_ngens(3); P
      Lie algebra generated by (a, b, c) in
       Free Algebra on 3 generators (a, b, c) over Rational Field

  This has the basis given by Hall and the one indexed by Lyndon words. We do some computations and convert between the bases:

  Sage

      sage: H = L.Hall()
      sage: H
      Free Lie algebra generated by (x, y, z) over Rational Field in the Hall basis
      sage: Lyn = L.Lyndon()
      sage: Lyn
      Free Lie algebra generated by (x, y, z) over Rational Field in the Lyndon basis
      sage: x,y,z = Lyn.lie_algebra_generators()
      sage: a = Lyn([x, [[z, [x, y]], [y, x]]]); a
      -[x, [[x, y], [x, [y, z]]]] - [x, [[x, y], [[x, z], y]]]
      sage: H(a)
      [[x, y], [z, [x, [x, y]]]] - [[x, y], [[x, y], [x, z]]]
       + [[x, [x, y]], [z, [x, y]]]

  Python

      >>> from sage.all import *
      >>> H = L.Hall()
      >>> H
      Free Lie algebra generated by (x, y, z) over Rational Field in the Hall basis
      >>> Lyn = L.Lyndon()
      >>> Lyn
      Free Lie algebra generated by (x, y, z) over Rational Field in the Lyndon basis
      >>> x,y,z = Lyn.lie_algebra_generators()
      >>> a = Lyn([x, [[z, [x, y]], [y, x]]]); a
      -[x, [[x, y], [x, [y, z]]]] - [x, [[x, y], [[x, z], y]]]
      >>> H(a)
      [[x, y], [z, [x, [x, y]]]] - [[x, y], [[x, y], [x, z]]]
       + [[x, [x, y]], [z, [x, y]]]

  We also have the free Lie algebra given in the polynomial representation, which is the canonical embedding of the free Lie algebra into the free algebra (i.e., the ring of noncommutative polynomials). So the generators of the free Lie algebra are the generators of the free algebra and the Lie bracket is the commutator:

  Sage

      sage: P.<a,b,c> = LieAlgebra(QQ, representation='polynomial'); P
      Lie algebra generated by (a, b, c) in
       Free Algebra on 3 generators (a, b, c) over Rational Field
      sage: P.bracket(a, b) + P.bracket(a - c, b + 3*c)
      2*a*b + 3*a*c - 2*b*a + b*c - 3*c*a - c*b

  [Python]

      >>> from sage.all import *
      >>> P = LieAlgebra(QQ, representation='polynomial', names=('a', 'b', 'c',)); (a, b, c,) = P._first_ngens(3); P
      Lie algebra generated by (a, b, c) in
       Free Algebra on 3 generators (a, b, c) over Rational Field
      >>> P.bracket(a, b) + P.bracket(a - c, b + Integer(3)*c)
      2*a*b + 3*a*c - 2*b*a + b*c - 3*c*a - c*b

  6. Nilpotent Lie algebras are Lie algebras such that there exists an integer \(s\) such that all iterated brackets of length longer than \(s\) are zero. They can be constructed from structural coefficients using the `nilpotent` keyword:

  Sage

      sage: L.<X,Y,Z> = LieAlgebra(QQ, {('X','Y'): {'Z': 1}}, nilpotent=True)
      sage: L
      Nilpotent Lie algebra on 3 generators (X, Y, Z) over Rational Field
      sage: L.category()
      Category of finite dimensional nilpotent Lie algebras with basis over Rational Field

  Python

      >>> from sage.all import *
      >>> L = LieAlgebra(QQ, {('X','Y'): {'Z': Integer(1)}}, nilpotent=True, names=('X', 'Y', 'Z',)); (X, Y, Z,) = L._first_ngens(3)
      >>> L
      Nilpotent Lie algebra on 3 generators (X, Y, Z) over Rational Field
      >>> L.category()
      Category of finite dimensional nilpotent Lie algebras with basis over Rational Field

  A second example defining the Engel Lie algebra:

  Sage

      sage: sc = {('X','Y'): {'Z': 1}, ('X','Z'): {'W': 1}}
      sage: E.<X,Y,Z,W> = LieAlgebra(QQ, sc, nilpotent=True); E
      Nilpotent Lie algebra on 4 generators (X, Y, Z, W) over Rational Field
      sage: E.step()
      3
      sage: E[X, Y + Z]
      Z + W
      sage: E[X, [X, Y + Z]]
      W
      sage: E[X, [X, [X, Y + Z]]]
      0

  [Python]

      >>> from sage.all import *
      >>> sc = {('X','Y'): {'Z': Integer(1)}, ('X','Z'): {'W': Integer(1)}}
      >>> E = LieAlgebra(QQ, sc, nilpotent=True, names=('X', 'Y', 'Z', 'W',)); (X, Y, Z, W,) = E._first_ngens(4); E
      Nilpotent Lie algebra on 4 generators (X, Y, Z, W) over Rational Field
      >>> E.step()
      3
      >>> E[X, Y + Z]
      Z + W
      >>> E[X, [X, Y + Z]]
      W
      >>> E[X, [X, [X, Y + Z]]]
      0

  A nilpotent Lie algebra will also be constructed if given a `category` of a nilpotent Lie algebra:

  Sage

      sage: C = LieAlgebras(QQ).Nilpotent().FiniteDimensional().WithBasis()
      sage: L.<X,Y,Z> = LieAlgebra(QQ, {('X','Y'): {'Z': 1}}, category=C); L
      Nilpotent Lie algebra on 3 generators (X, Y, Z) over Rational Field

  Python

      >>> from sage.all import *
      >>> C = LieAlgebras(QQ).Nilpotent().FiniteDimensional().WithBasis()
      >>> L = LieAlgebra(QQ, {('X','Y'): {'Z': Integer(1)}}, category=C, names=('X', 'Y', 'Z',)); (X, Y, Z,) = L._first_ngens(3); L
      Nilpotent Lie algebra on 3 generators (X, Y, Z) over Rational Field

  7. Free nilpotent Lie algebras are the truncated versions of the free Lie algebras. That is, the only relations other than anticommutativity and the Jacobi identity among the Lie brackets are that brackets of length higher than the nilpotency step vanish. They can be created by using the `step` keyword:

  Sage

      sage: L = LieAlgebra(ZZ, 2, step=3); L
      Free Nilpotent Lie algebra of rank 2 and step 3 over Integer Ring
      sage: L.step()
      3

  [Python]

      >>> from sage.all import *
      >>> L = LieAlgebra(ZZ, Integer(2), step=Integer(3)); L
      Free Nilpotent Lie algebra of rank 2 and step 3 over Integer Ring
      >>> L.step()
      3

  REFERENCES:

  - [deG2000] Willem A. de Graaf. Lie Algebras: Theory and Algorithms.

  - [Ka1990] Victor Kac, Infinite dimensional Lie algebras.

  - Wikipedia article Lie_algebra

  get_order()

    Return an ordering of the basis indices.

    Todo

    Remove this method and in `CombinatorialFreeModule` in favor of a method in the category of (finite dimensional) modules with basis.

    EXAMPLES:

    Sage

        sage: L.<x,y> = LieAlgebra(QQ, {})
        sage: L.get_order()
        ('x', 'y')

    Python

        >>> from sage.all import *
        >>> L = LieAlgebra(QQ, {}, names=('x', 'y',)); (x, y,) = L._first_ngens(2)
        >>> L.get_order()
        ('x', 'y')

  monomial(i)

    Return the monomial indexed by `i`.

    EXAMPLES:

    Sage

        sage: L = lie_algebras.Heisenberg(QQ, oo)
        sage: L.monomial('p1')
        p1

    Python

        >>> from sage.all import *
        >>> L = lie_algebras.Heisenberg(QQ, oo)
        >>> L.monomial('p1')
        p1

  term(i, c=None)

    Return the term indexed by `i` with coefficient `c`.

    EXAMPLES:

    Sage

        sage: L = lie_algebras.Heisenberg(QQ, oo)
        sage: L.term('p1', 4)
        4*p1

    Python

        >>> from sage.all import *
        >>> L = lie_algebras.Heisenberg(QQ, oo)
        >>> L.term('p1', Integer(4))
        4*p1

  zero()

    Return the element \(0\).

    EXAMPLES:

    Sage

        sage: L.<x,y> = LieAlgebra(QQ, representation='polynomial')
        sage: L.zero()
        0

    Python

        >>> from sage.all import *
        >>> L = LieAlgebra(QQ, representation='polynomial', names=('x', 'y',)); (x, y,) = L._first_ngens(2)
        >>> L.zero()
        0

class sage.algebras.lie_algebras.lie_algebra.LieAlgebraFromAssociative(A, gens=None, names=None, index_set=None, category=None)

  Bases: `LieAlgebraWithGenerators`

  A Lie algebra whose elements are from an associative algebra and whose bracket is the commutator.

  Todo

  Split this class into 2 classes, the base class for the Lie algebra corresponding to the full associative algebra and a subclass for the Lie subalgebra (of the full algebra) generated by a generating set?

  Todo

  Return the subalgebra generated by the basis elements of `self` for the universal enveloping algebra.

  EXAMPLES:

  For the first example, we start with a commutative algebra. Note that the bracket of everything will be 0:

  Sage

      sage: R = SymmetricGroupAlgebra(QQ, 2)
      sage: L = LieAlgebra(associative=R)
      sage: x, y = L.basis()
      sage: L.bracket(x, y)
      0

  Python

      >>> from sage.all import *
      >>> R = SymmetricGroupAlgebra(QQ, Integer(2))
      >>> L = LieAlgebra(associative=R)
      >>> x, y = L.basis()
      >>> L.bracket(x, y)
      0

  Next we use a free algebra and do some simple computations:

  Sage

      sage: R.<a,b> = FreeAlgebra(QQ, 2)
      sage: L = LieAlgebra(associative=R)
      sage: x,y = L(a), L(b)
      sage: x-y
      a - b
      sage: L.bracket(x-y, x)
      a*b - b*a
      sage: L.bracket(x-y, L.bracket(x,y))
      a^2*b - 2*a*b*a + a*b^2 + b*a^2 - 2*b*a*b + b^2*a

  [Python]

      >>> from sage.all import *
      >>> R = FreeAlgebra(QQ, Integer(2), names=('a', 'b',)); (a, b,) = R._first_ngens(2)
      >>> L = LieAlgebra(associative=R)
      >>> x,y = L(a), L(b)
      >>> x-y
      a - b
      >>> L.bracket(x-y, x)
      a*b - b*a
      >>> L.bracket(x-y, L.bracket(x,y))
      a^2*b - 2*a*b*a + a*b^2 + b*a^2 - 2*b*a*b + b^2*a

  We can also use a subset of the generators as a generating set of the Lie algebra:

  Sage

      sage: R.<a,b,c> = FreeAlgebra(QQ, 3)
      sage: L.<x,y> = LieAlgebra(associative=[a,b])

  Python

      >>> from sage.all import *
      >>> R = FreeAlgebra(QQ, Integer(3), names=('a', 'b', 'c',)); (a, b, c,) = R._first_ngens(3)
      >>> L = LieAlgebra(associative=[a,b], names=('x', 'y',)); (x, y,) = L._first_ngens(2)

  Now for a more complicated example using the group ring of \(S_3\) as our base algebra:

  Sage

      sage: G = SymmetricGroup(3)
      sage: S = GroupAlgebra(G, QQ)
      sage: L.<x,y> = LieAlgebra(associative=S.gens())
      sage: L.bracket(x, y)
      (2,3) - (1,3)
      sage: L.bracket(x, y-x)
      (2,3) - (1,3)
      sage: L.bracket(L.bracket(x, y), y)
      2*(1,2,3) - 2*(1,3,2)
      sage: L.bracket(x, L.bracket(x, y))
      (2,3) - 2*(1,2) + (1,3)
      sage: L.bracket(x, L.bracket(L.bracket(x, y), y))
      0

  [Python]

      >>> from sage.all import *
      >>> G = SymmetricGroup(Integer(3))
      >>> S = GroupAlgebra(G, QQ)
      >>> L = LieAlgebra(associative=S.gens(), names=('x', 'y',)); (x, y,) = L._first_ngens(2)
      >>> L.bracket(x, y)
      (2,3) - (1,3)
      >>> L.bracket(x, y-x)
      (2,3) - (1,3)
      >>> L.bracket(L.bracket(x, y), y)
      2*(1,2,3) - 2*(1,3,2)
      >>> L.bracket(x, L.bracket(x, y))
      (2,3) - 2*(1,2) + (1,3)
      >>> L.bracket(x, L.bracket(L.bracket(x, y), y))
      0

  Here is an example using matrices:

  Sage

      sage: MS = MatrixSpace(QQ,2)
      sage: m1 = MS([[0, -1], [1, 0]])
      sage: m2 = MS([[-1, 4], [3, 2]])
      sage: L.<x,y> = LieAlgebra(associative=[m1, m2])
      sage: x
      [ 0 -1]
      [ 1  0]
      sage: y
      [-1  4]
      [ 3  2]
      sage: L.bracket(x,y)
      [-7 -3]
      [-3  7]
      sage: L.bracket(y,y)
      [0 0]
      [0 0]
      sage: L.bracket(y,x)
      [ 7  3]
      [ 3 -7]
      sage: L.bracket(x, L.bracket(y,x))
      [-6 14]
      [14  6]

  Python

      >>> from sage.all import *
      >>> MS = MatrixSpace(QQ,Integer(2))
      >>> m1 = MS([[Integer(0), -Integer(1)], [Integer(1), Integer(0)]])
      >>> m2 = MS([[-Integer(1), Integer(4)], [Integer(3), Integer(2)]])
      >>> L = LieAlgebra(associative=[m1, m2], names=('x', 'y',)); (x, y,) = L._first_ngens(2)
      >>> x
      [ 0 -1]
      [ 1  0]
      >>> y
      [-1  4]
      [ 3  2]
      >>> L.bracket(x,y)
      [-7 -3]
      [-3  7]
      >>> L.bracket(y,y)
      [0 0]
      [0 0]
      >>> L.bracket(y,x)
      [ 7  3]
      [ 3 -7]
      >>> L.bracket(x, L.bracket(y,x))
      [-6 14]
      [14  6]

  class Element

    Bases: `LieAlgebraElementWrapper`

    lift_associative()

      Lift `self` to the ambient associative algebra (which might be smaller than the universal enveloping algebra).

      EXAMPLES:

      Sage

          sage: R = FreeAlgebra(QQ, 3, 'x,y,z')
          sage: L.<x,y,z> = LieAlgebra(associative=R.gens())
          sage: x.lift_associative()
          x
          sage: x.lift_associative().parent()
          Free Algebra on 3 generators (x, y, z) over Rational Field

      Python

          >>> from sage.all import *
          >>> R = FreeAlgebra(QQ, Integer(3), 'x,y,z')
          >>> L = LieAlgebra(associative=R.gens(), names=('x', 'y', 'z',)); (x, y, z,) = L._first_ngens(3)
          >>> x.lift_associative()
          x
          >>> x.lift_associative().parent()
          Free Algebra on 3 generators (x, y, z) over Rational Field

    monomial_coefficients(copy=True)

      Return the monomial coefficients of `self` (if this notion makes sense for `self.parent()`).

      EXAMPLES:

      Sage

          sage: R.<x,y,z> = FreeAlgebra(QQ)
          sage: L = LieAlgebra(associative=R)
          sage: elt = L(x) + 2*L(y) - L(z)
          sage: sorted(elt.monomial_coefficients().items())
          [(x, 1), (y, 2), (z, -1)]

          sage: L = LieAlgebra(associative=[x,y])
          sage: elt = L(x) + 2*L(y)
          sage: elt.monomial_coefficients()
          Traceback (most recent call last):
          ...
          NotImplementedError: the basis is not defined

      Python

          >>> from sage.all import *
          >>> R = FreeAlgebra(QQ, names=('x', 'y', 'z',)); (x, y, z,) = R._first_ngens(3)
          >>> L = LieAlgebra(associative=R)
          >>> elt = L(x) + Integer(2)*L(y) - L(z)
          >>> sorted(elt.monomial_coefficients().items())
          [(x, 1), (y, 2), (z, -1)]

          >>> L = LieAlgebra(associative=[x,y])
          >>> elt = L(x) + Integer(2)*L(y)
          >>> elt.monomial_coefficients()
          Traceback (most recent call last):
          ...
          NotImplementedError: the basis is not defined

  associative_algebra()

    Return the associative algebra used to construct `self`.

    EXAMPLES:

    Sage

        sage: G = SymmetricGroup(3)
        sage: S = GroupAlgebra(G, QQ)
        sage: L = LieAlgebra(associative=S)
        sage: L.associative_algebra() is S
        True

    Python

        >>> from sage.all import *
        >>> G = SymmetricGroup(Integer(3))
        >>> S = GroupAlgebra(G, QQ)
        >>> L = LieAlgebra(associative=S)
        >>> L.associative_algebra() is S
        True

  is_abelian()

    Return `True` if `self` is abelian.

    EXAMPLES:

    Sage

        sage: R = FreeAlgebra(QQ, 2, 'x,y')
        sage: L = LieAlgebra(associative=R.gens())
        sage: L.is_abelian()
        False

        sage: R = PolynomialRing(QQ, 'x,y')
        sage: L = LieAlgebra(associative=R.gens())
        sage: L.is_abelian()
        True

    Python

        >>> from sage.all import *
        >>> R = FreeAlgebra(QQ, Integer(2), 'x,y')
        >>> L = LieAlgebra(associative=R.gens())
        >>> L.is_abelian()
        False

        >>> R = PolynomialRing(QQ, 'x,y')
        >>> L = LieAlgebra(associative=R.gens())
        >>> L.is_abelian()
        True

    An example with a Lie algebra from the group algebra:

    Sage

        sage: G = SymmetricGroup(3)
        sage: S = GroupAlgebra(G, QQ)
        sage: L = LieAlgebra(associative=S)
        sage: L.is_abelian()
        False

    [Python]

        >>> from sage.all import *
        >>> G = SymmetricGroup(Integer(3))
        >>> S = GroupAlgebra(G, QQ)
        >>> L = LieAlgebra(associative=S)
        >>> L.is_abelian()
        False

    Now we construct a Lie algebra from commuting elements in the group algebra:

    Sage

        sage: G = SymmetricGroup(5)
        sage: S = GroupAlgebra(G, QQ)
        sage: gens = map(S, [G((1, 2)), G((3, 4))])
        sage: L.<x,y> = LieAlgebra(associative=gens)
        sage: L.is_abelian()
        True

    Python

        >>> from sage.all import *
        >>> G = SymmetricGroup(Integer(5))
        >>> S = GroupAlgebra(G, QQ)
        >>> gens = map(S, [G((Integer(1), Integer(2))), G((Integer(3), Integer(4)))])
        >>> L = LieAlgebra(associative=gens, names=('x', 'y',)); (x, y,) = L._first_ngens(2)
        >>> L.is_abelian()
        True

  lie_algebra_generators()

    Return the Lie algebra generators of `self`.

    EXAMPLES:

    Sage

        sage: G = SymmetricGroup(3)
        sage: S = GroupAlgebra(G, QQ)
        sage: L = LieAlgebra(associative=S)
        sage: L.lie_algebra_generators()
        Finite family {(): (), (1,3,2): (1,3,2), (1,2,3): (1,2,3),
                       (2,3): (2,3), (1,3): (1,3), (1,2): (1,2)}

    Python

        >>> from sage.all import *
        >>> G = SymmetricGroup(Integer(3))
        >>> S = GroupAlgebra(G, QQ)
        >>> L = LieAlgebra(associative=S)
        >>> L.lie_algebra_generators()
        Finite family {(): (), (1,3,2): (1,3,2), (1,2,3): (1,2,3),
                       (2,3): (2,3), (1,3): (1,3), (1,2): (1,2)}

  monomial(i)

    Return the monomial indexed by `i`.

    EXAMPLES:

    Sage

        sage: F.<x,y> = FreeAlgebra(QQ)
        sage: L = LieAlgebra(associative=F)
        sage: L.monomial(x.leading_support())
        x

    Python

        >>> from sage.all import *
        >>> F = FreeAlgebra(QQ, names=('x', 'y',)); (x, y,) = F._first_ngens(2)
        >>> L = LieAlgebra(associative=F)
        >>> L.monomial(x.leading_support())
        x

  term(i, c=None)

    Return the term indexed by `i` with coefficient `c`.

    EXAMPLES:

    Sage

        sage: F.<x,y> = FreeAlgebra(QQ)
        sage: L = LieAlgebra(associative=F)
        sage: L.term(x.leading_support(), 4)
        4*x

    Python

        >>> from sage.all import *
        >>> F = FreeAlgebra(QQ, names=('x', 'y',)); (x, y,) = F._first_ngens(2)
        >>> L = LieAlgebra(associative=F)
        >>> L.term(x.leading_support(), Integer(4))
        4*x

  zero()

    Return the element \(0\) in `self`.

    EXAMPLES:

    Sage

        sage: G = SymmetricGroup(3)
        sage: S = GroupAlgebra(G, QQ)
        sage: L = LieAlgebra(associative=S)
        sage: L.zero()
        0

    Python

        >>> from sage.all import *
        >>> G = SymmetricGroup(Integer(3))
        >>> S = GroupAlgebra(G, QQ)
        >>> L = LieAlgebra(associative=S)
        >>> L.zero()
        0

class sage.algebras.lie_algebras.lie_algebra.LieAlgebraWithGenerators(R, names=None, index_set=None, category=None, prefix='L', **kwds)

  Bases: `LieAlgebra`

  A Lie algebra with distinguished generators.

  gen(i)

    Return the `i`-th generator of `self`.

    EXAMPLES:

    Sage

        sage: L.<x,y> = LieAlgebra(QQ, abelian=True)
        sage: L.gen(0)
        x

    Python

        >>> from sage.all import *
        >>> L = LieAlgebra(QQ, abelian=True, names=('x', 'y',)); (x, y,) = L._first_ngens(2)
        >>> L.gen(Integer(0))
        x

  gens()

    Return a tuple whose entries are the generators for this object, in some order.

    EXAMPLES:

    Sage

        sage: L.<x,y> = LieAlgebra(QQ, abelian=True)
        sage: L.gens()
        (x, y)

    Python

        >>> from sage.all import *
        >>> L = LieAlgebra(QQ, abelian=True, names=('x', 'y',)); (x, y,) = L._first_ngens(2)
        >>> L.gens()
        (x, y)

  indices()

    Return the indices of `self`.

    EXAMPLES:

    Sage

        sage: L.<x,y> = LieAlgebra(QQ, representation='polynomial')
        sage: L.indices()
        {'x', 'y'}

    Python

        >>> from sage.all import *
        >>> L = LieAlgebra(QQ, representation='polynomial', names=('x', 'y',)); (x, y,) = L._first_ngens(2)
        >>> L.indices()
        {'x', 'y'}

  lie_algebra_generators()

    Return the generators of `self` as a Lie algebra.

    EXAMPLES:

    Sage

        sage: L.<x,y> = LieAlgebra(QQ, representation='polynomial')
        sage: L.lie_algebra_generators()
        Finite family {'x': x, 'y': y}

    Python

        >>> from sage.all import *
        >>> L = LieAlgebra(QQ, representation='polynomial', names=('x', 'y',)); (x, y,) = L._first_ngens(2)
        >>> L.lie_algebra_generators()
        Finite family {'x': x, 'y': y}

class sage.algebras.lie_algebras.lie_algebra.LiftMorphismToAssociative(domain, codomain)

  Bases: `LiftMorphism`

  The natural lifting morphism from a Lie algebra constructed from an associative algebra \(A\) to \(A\).

  preimage(x)

    Return the preimage of `x` under `self`.

    EXAMPLES:

    Sage

        sage: R = FreeAlgebra(QQ, 3, 'a,b,c')
        sage: L = LieAlgebra(associative=R)
        sage: x,y,z = R.gens()
        sage: f = R.coerce_map_from(L)
        sage: p = f.preimage(x*y - z); p
        -c + a*b
        sage: p.parent() is L
        True

    Python

        >>> from sage.all import *
        >>> R = FreeAlgebra(QQ, Integer(3), 'a,b,c')
        >>> L = LieAlgebra(associative=R)
        >>> x,y,z = R.gens()
        >>> f = R.coerce_map_from(L)
        >>> p = f.preimage(x*y - z); p
        -c + a*b
        >>> p.parent() is L
        True

  section()

    Return the section map of `self`.

    EXAMPLES:

    Sage

        sage: R = FreeAlgebra(QQ, 3, 'x,y,z')
        sage: L.<x,y,z> = LieAlgebra(associative=R.gens())
        sage: f = R.coerce_map_from(L)
        sage: f.section()
        Generic morphism:
          From: Free Algebra on 3 generators (x, y, z) over Rational Field
          To:   Lie algebra generated by (x, y, z) in Free Algebra on 3 generators (x, y, z) over Rational Field

    Python

        >>> from sage.all import *
        >>> R = FreeAlgebra(QQ, Integer(3), 'x,y,z')
        >>> L = LieAlgebra(associative=R.gens(), names=('x', 'y', 'z',)); (x, y, z,) = L._first_ngens(3)
        >>> f = R.coerce_map_from(L)
        >>> f.section()
        Generic morphism:
          From: Free Algebra on 3 generators (x, y, z) over Rational Field
          To:   Lie algebra generated by (x, y, z) in Free Algebra on 3 generators (x, y, z) over Rational Field

class sage.algebras.lie_algebras.lie_algebra.MatrixLieAlgebraFromAssociative(A, gens=None, names=None, index_set=None, category=None)

  Bases: `LieAlgebraFromAssociative`

  A Lie algebra constructed from a matrix algebra.

  This means a Lie algebra consisting of matrices, with commutator as Lie bracket.

  class Element

    Bases: `LieAlgebraMatrixWrapper`, `Element`

    matrix()

      Return `self` as element of the underlying matrix algebra.

      OUTPUT: an instance of the element class of MatrixSpace

      EXAMPLES:

      Sage

          sage: sl3m = lie_algebras.sl(ZZ, 3, representation='matrix')
          sage: e1,e2, f1, f2, h1, h2 = sl3m.gens()
          sage: h1m = h1.matrix(); h1m
          [ 1  0  0]
          [ 0 -1  0]
          [ 0  0  0]
          sage: h1m.parent()
          Full MatrixSpace of 3 by 3 sparse matrices over Integer Ring
          sage: matrix(h2)
          [ 0  0  0]
          [ 0  1  0]
          [ 0  0 -1]
          sage: L = lie_algebras.so(QQ['z'], 5, representation='matrix')
          sage: matrix(L.an_element())
          [ 1  1  0  0  0]
          [ 1  1  0  0  2]
          [ 0  0 -1 -1  0]
          [ 0  0 -1 -1 -1]
          [ 0  1  0 -2  0]

          sage: gl2 = lie_algebras.gl(QQ, 2)
          sage: matrix(gl2.an_element())
          [1 1]
          [1 1]

      Python

          >>> from sage.all import *
          >>> sl3m = lie_algebras.sl(ZZ, Integer(3), representation='matrix')
          >>> e1,e2, f1, f2, h1, h2 = sl3m.gens()
          >>> h1m = h1.matrix(); h1m
          [ 1  0  0]
          [ 0 -1  0]
          [ 0  0  0]
          >>> h1m.parent()
          Full MatrixSpace of 3 by 3 sparse matrices over Integer Ring
          >>> matrix(h2)
          [ 0  0  0]
          [ 0  1  0]
          [ 0  0 -1]
          >>> L = lie_algebras.so(QQ['z'], Integer(5), representation='matrix')
          >>> matrix(L.an_element())
          [ 1  1  0  0  0]
          [ 1  1  0  0  2]
          [ 0  0 -1 -1  0]
          [ 0  0 -1 -1 -1]
          [ 0  1  0 -2  0]

          >>> gl2 = lie_algebras.gl(QQ, Integer(2))
          >>> matrix(gl2.an_element())
          [1 1]
          [1 1]