|
[Next][Prev] [Right] [Left] [Up] [Index] [Root]
A finitely presented Lie algebra is constructed as the quotient
of a free Lie algebra on a finite number of generators. Denote the set
of generators by X={x1, ..., xn}. Let F denote the base
ring. Then the free Lie algebra generated by the xi over the ring
F is denoted by LF(X). The free magma on X is the set of the
xi together with all bracketed expressions in the xi, e.g.,
((x1, x2), ((x1, x3), x2)). The free Lie algebra LF(X) is
spanned by M(X). However, the elements of this set are not linearly
independent. It is a nontrivial problem to describe a basis of the
free Lie algebra. One of several possibilities is the well-known
Hall basis. Currently Magma does not support calculations
involving bases of the free Lie algebra, as they are of little use
for our main problem: the construction of a basis and multiplication
table for a finitely-presented Lie algebra.
It is convenient to define an ordering on the elements of M(X).
First of all, each generator is assigned a degree. Usually, the degree
of all xi is taken to be one, but it is also possible to assign
different degrees. The degree of a bracket (a, b) is defined to be
the sum of the degrees of a and b. Let m, m' be two elements of
M(X). Then define m<m' if the degree of m is less than the degree
of m'. If their degrees are equal, then define m<m' if m=xi
and m'=(a', b'), for some a', b' in M(X). If both m and m'
are generators of the same degree, so that m=xi, m'=xj, then
define m<m' if i<j. Finally, if both m and m' are bracketed
expressions, that is, m=(a, b) and m'=(a', b'), then define m<m'
if a<a' or a=a' and b<b'.
In the free Lie algebra, the relations (a, b) = - (b, a), and (a, a)=0
hold. In Magma this is used to rewrite an arbitrary element as a
linear combination of elements of the form (a, b) with a<b. If
instead we were to work relative to a basis for LF(X), then
the use of the Jacobi identity when rewriting elements can lead to
rather large expressions. Thus, mathematically speaking, in Magma
rather than work in the free Lie algebra, we actually work in the
free nonassociative anticommutative algebra. However, as our main
interest lies in finitely-presented Lie algebras, this is usually
not a problem.
Subsections
Given a ring F and a positive integer n, this function creates the
free n-generator Lie algebra over the ring F. The generators are
ordered, with the first generator being the biggest in the ordering, and
the last generator the smallest. The angle bracket notation can be used
to assign names to the generators.
The following statement creates the Magma object corresponding to the
free Lie algebra on three generators over the field GF(2).
> L<a,b,c>:= FreeLieAlgebra(Rationals(), 3);
Once a free Lie algebra has been created the user can construct a
bracketed expression (a, b), either by simply typing it literally
as (a,b), or by using the multiplication operator as in
a*b. Recall that Magma rewrites elements so they are in the
form (a, b) with a<b. On some occasions this can lead to the
introduction of a minus sign. Also, if an element contains a
subexpression of the form (a, a), it will be rewritten to 0.
We can multiply and add elements, and multiply them by scalars.
x + y : AlgFPLieElt, AlgFPLieElt -> AlgFPLieElt
x - y : AlgFPLieElt, AlgFPLieElt -> AlgFPLieElt
x * y : AlgFPLieElt, AlgFPLieElt -> AlgFPLieElt
Zero(L) : AlgFPLie -> AlgFPLieElt
The zero element of the free Lie algebra L.
> L<z,y,x> := FreeLieAlgebra(Rationals(), 3);
> x*y;
(x, y)
> (x, y);
(x, y)
> ((x*y)*z);
-(z, (x, y))
> ((x, y), z);
-(z, (x, y))
> ((x, y),(y, x));
0
> 2*((x, y), z) - ((x, z), (y, z)) + 1/2*(x, (x, (y, z)));
-((x, z), (y, z)) + 1/2*(x, (x, (y, z))) - 2*(z, (x, y))
Given an element m of the free Lie algebra magma, return true if m
is a generator and false otherwise. If the result is false then
m = (a, b) for some a and b and so a and b are also returned.
> L<z,y,x>:= FreeLieAlgebra(Rationals(), 3);
> m:=((x, y), z);
> IsLeaf(m);
false z (x, y)
> IsLeaf(x);
true
LieAlgebra(R) : [ AlgFPLieElt ] -> AlgLie, SeqEnum, SeqEnum, UserProgram
LieAlgebra(R) : { AlgFPLieElt } -> AlgLie, SeqEnum, SeqEnum, UserProgram
Given a set or sequence R of elements of a free Lie algebra L, let
I be the ideal of L generated by the elements of R. It is assumed
that the quotient algebra Q = L/I is finite dimensional. This function
returns the structure constant Lie algebra K isomorphic to the quotient
Q. If the quotient Q is infinite dimensional then the program will
not terminate. (The question of determining whether the quotient is
finite dimensional is known to be undecidable.) The function can be
interrupted by pressing Ctrl-C. The elements of R are referred
to as relations.
This function works if the base ring is either a field or equal to the
ring of integers. In these two cases slightly different objects are returned.
If the base ring is a field then four values are returned:
- (a)
- A structure constant algebra K isomorphic to the quotient Q;
- (b)
- A sequence G comprising sequences of integers;
- (c)
- A sequence B of elements of the free Lie algebra L;
- (d)
- A function f.
The sequence B maps to a basis of the quotient algebra, so it is a
basis of a complement of the ideal I in the free Lie algebra L.
The elements of B are in one-to-one correspondence with the basis
elements of K.
If all the relations of R are homogeneous (i.e., if they are linear
combinations of elements of the same degree), then Q is graded.
The sequence G contains information about the grading. It contains
of sequences of length two. The first element of each subsequence is
the degree of a homogeneous subspace H, while the second element
is the dimension of H. The basis elements of K are ordered with
respect to increasing degree. So from G it is straightforward to
read off the degree of each basis element. If the relations are not
homogeneous then the sequence G is empty.
Finally, f is a function that takes two elements from B as arguments,
and returns their product modulo the ideal I.
The algorithm used is described in [dG00], Para 7.4.
Secondly, if the base ring is the ring of integers, also four values are
returned:
- (a)
- A structure constant algebra K isomorphic to the quotient Q;
- (b)
- A sequence G comprising sequences of integers;
- (c)
- A sequence B that is always empty;
- (d)
- A function f.
Here the structure constants algebra is defined over the ring of integers,
so it may have torsion. The sequence G is only nonempty if the input
relations are homogeneous. In that case, it contains the dimensions of
the homogeneous components. In this case the function f is a function
that takes an element u of K and returns an element of the free algebra
that maps to u under the projection map (from the free algebra to the
quotient).
In this example we compute the subalgebra K of E7 spanned by the
positive root spaces.
> L<x7,x6,x5,x4,x3,x2,x1>:= FreeLieAlgebra(RationalField(), 7);
> pp:= { [1,3], [3,4], [2,4], [4,5], [5,6], [6,7] };
> R:= [ ];
> g:= [ L.i : i in [1..7] ];
> for i in [1..7] do
> for j in [i+1..7] do
> if [i,j] in pp then
> a:= (g[i],(g[i],g[j]));
> Append( ~R, a );
> Append( ~R, (g[j],(g[j],g[i])) );
> else
> Append( ~R, (g[i],g[j]) );
> end if;
> end for;
> end for;
>
[
-(x6, x7), -(x7, (x5, x7)), (x5, (x5, x7)), -(x4, x7),
-(x3, x7), -(x2, x7), -(x1, x7), -(x5, x6), -(x6, (x4, x6)),
(x4, (x4, x6)), -(x3, x6), -(x2, x6), -(x1, x6), -(x5, (x4, x5)),
(x4, (x4, x5)), -(x3, x5), -(x2, x5), -(x1, x5), -(x4, (x3, x4)),
(x3, (x3, x4)), -(x2, x4), -(x1, x4), -(x3, (x2, x3)), (x2, (x2, x3)),
-(x1, x3), -(x2, (x1, x2)), (x1, (x1, x2))
]
> time K, G, B, f := LieAlgebra(R);
Time: 0.280
> K;
Lie Algebra of dimension 63 with base ring Rational Field
> #B;
63
> B[63];
(x7, (x5, (x4, (x3, (x2, (x1, (x6, (x4, (x3, (x2, (x5, (x4,
(x3, (x6, (x4, (x5, x7))))))))))))))))
In this example we construct a finitely presented Lie ring (i.e., Lie
algebra over the integers).
> L<y,x>:= FreeLieAlgebra( Integers(), 2 );
> R:= [ x*(x*(x*y))-2*x*y, 2*y*(x*(x*y)), 3*y*(y*(x*y))-x*(x*y),
> x*(y*(x*(y*(x*y)))) ];
> K,g,b,f:= LieAlgebra( R );
> K;
Lie Algebra of dimension 8 with base ring Integer Ring
Column moduli: [2, 2, 2, 8, 8, 8, 0, 0]
> f(K.4);
(y, (x, y))
> LowerCentralSeries( K );
[
Lie Algebra of dimension 8 with base ring Integer Ring
Column moduli: [2, 2, 2, 8, 8, 8, 0, 0],
Lie Algebra of dimension 6 with base ring Integer Ring
Column moduli: [2, 2, 2, 8, 8, 8],
Lie Algebra of dimension 6 with base ring Integer Ring
Column moduli: [2, 2, 2, 4, 8, 8],
Lie Algebra of dimension 6 with base ring Integer Ring
Column moduli: [2, 2, 2, 4, 4, 8],
Lie Algebra of dimension 6 with base ring Integer Ring
Column moduli: [2, 2, 2, 4, 4, 4],
Lie Algebra of dimension 5 with base ring Integer Ring
Column moduli: [2, 2, 2, 4, 4],
Lie Algebra of dimension 4 with base ring Integer Ring
Column moduli: [2, 2, 2, 4],
Lie Algebra of dimension 3 with base ring Integer Ring
Column moduli: [2, 2, 2],
Lie Algebra of dimension 2 with base ring Integer Ring
Column moduli: [2, 2],
Lie Algebra of dimension 1 with base ring Integer Ring
Column moduli: [2],
Lie Algebra of dimension 0 with base ring Integer Ring
]
NilpotentQuotient(R, d) : { AlgFPLieElt, RngIntElt } -> AlgLie, SeqEnum, SeqEnum, UserProgram
Given a set or sequence R of elements of a free Lie algebra L, let
I be the ideal of L generated by the elements of R. Let d be a
positive integer or Infinity().
This function constructs the class d nilpotent
quotient of the Lie algebra L/I, a finite dimensional algebra. The
function returns the same values as LieAlgebra.
This function is similar to the function LieAlgebra except
that the quotient is constructed in the free nilpotent Lie algebra of
class d. All elements of degree strictly larger than d will
be added to the ideal, so the quotient will be finite-dimensional and
nilpotent of class at most d.
In this example, we compute a nilpotent quotient.
> L<y,x> := FreeLieAlgebra(Rationals(), 2);
> R := [(x, (x, (x, y))) - (y, (y, (x, y)))];
> time K, G, B, f := NilpotentQuotient(R, 10);
Time: 0.040
> K;
Lie Algebra of dimension 109 with base ring Rational Field
> #B;
109
> B[100];
(y, (x, (x, (y, (x, (y, (x, (x, (x, y)))))))))
> G;
[
[ 1, 2 ],
[ 2, 1 ],
[ 3, 2 ],
[ 4, 2 ],
[ 5, 4 ],
[ 6, 5 ],
[ 7, 10 ],
[ 8, 15 ],
[ 9, 26 ],
[ 10, 42 ]
]
> f(B[3], B[13]);
-(y, (x, (x, (x, (x, (y, (x, y))))))) + (x, (y, (x, (x, (x, (y, (x, y)))))))
[Next][Prev] [Right] [Left] [Up] [Index] [Root]
|
