<?xml version="1.0" encoding="ISO-8859-1"?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en">
<head>
<title>GAP (LAGUNA) - Chapter 2: A sample calculation with LAGUNA</title>
<meta http-equiv="content-type" content="text/html; charset=iso-8859-1" />
<meta name="generator" content="GAPDoc2HTML" />
<link rel="stylesheet" type="text/css" href="manual.css" />
</head>
<body>
<div class="pcenter"><table class="chlink"><tr><td class="chlink1">Goto Chapter: </td><td><a href="chap0.html">Top</a></td><td><a href="chap1.html">1</a></td><td><a href="chap2.html">2</a></td><td><a href="chap3.html">3</a></td><td><a href="chap4.html">4</a></td><td><a href="chapBib.html">Bib</a></td><td><a href="chapInd.html">Ind</a></td></tr></table><br /></div>
<p><a id="s0ss0" name="s0ss0"></a></p>
<h3>2. A sample calculation with <strong class="pkg">LAGUNA</strong></h3>
<p>Before explaining the theory behind the <strong class="pkg">LAGUNA</strong> package we present a sample calculation to show the reader what <strong class="pkg">LAGUNA</strong> is able to compute. We will carry out some calculations in the group algebra of the dihedral group of order 16 over the field of two elements. First we create this modular group algebra.</p>
<table class="example">
<tr><td><pre>
gap> K := GF( 2 );
GF(2)
gap> G := DihedralGroup( 16 );
<pc group of size 16 with 4 generators>
gap> KG := GroupRing( K, G );
<algebra-with-one over GF(2), with 4 generators>
</pre></td></tr></table>
<p>The group algebra <code class="code">KG</code> has some properties and attributes that are direct consequences of its definition. These can be checked very quickly.</p>
<table class="example">
<tr><td><pre>
gap> IsGroupAlgebra( KG );
true
gap> IsPModularGroupAlgebra( KG );
true
gap> IsFModularGroupAlgebra( KG );
true
gap> UnderlyingGroup( KG );
<pc group of size 16 with 4 generators>
gap> LeftActingDomain( KG );
GF(2)
</pre></td></tr></table>
<p>Since <code class="code">KG</code> is naturally a group algebra, the information provided by <code class="code">LeftActingDomain</code> can also be obtained using two other functions as follows.</p>
<table class="example">
<tr><td><pre>
gap> UnderlyingRing( KG );
GF(2)
gap> UnderlyingField( KG );
GF(2)
</pre></td></tr></table>
<p>Let us construct a certain element of the group algebra. For example, we take a minimal generating system of the group <code class="code">G</code> and find the corresponding elements in <code class="code">KG</code>.</p>
<table class="example">
<tr><td><pre>
gap> MinimalGeneratingSet( G );
[ f1, f2 ]
gap> l := List( last, g -> g^Embedding( G, KG ) );
[ (Z(2)^0)*f1, (Z(2)^0)*f2 ]
</pre></td></tr></table>
<p>Now we construct an element <code class="code">x</code> as follows.</p>
<table class="example">
<tr><td><pre>
gap> a :=l[1]; b:=l[2]; # a and b are images of group generators in KG
(Z(2)^0)*f1
(Z(2)^0)*f2
gap> e := One( KG ); # for convenience, we denote the identity by e
(Z(2)^0)*<identity> of ...
gap> x := ( e + a ) * ( e + b );
(Z(2)^0)*<identity> of ...+(Z(2)^0)*f1+(Z(2)^0)*f2+(Z(2)^0)*f1*f2
</pre></td></tr></table>
<p>We may investigate some of the basic properties of our element.</p>
<table class="example">
<tr><td><pre>
gap> Support( x );
[ <identity> of ..., f1, f2, f1*f2 ]
gap> CoefficientsBySupport( x );
[ Z(2)^0, Z(2)^0, Z(2)^0, Z(2)^0 ]
gap> Length( x );
4
gap> TraceOfMagmaRingElement( x );
Z(2)^0
</pre></td></tr></table>
<p>We can also calculate the augmentation of <code class="code">x</code>, which is defined as the sum of its coefficients.</p>
<table class="example">
<tr><td><pre>
gap> Augmentation( x );
0*Z(2)
gap> IsUnit( KG, x );
false
</pre></td></tr></table>
<p>Since the augmentation of <code class="code">x</code> is zero, <code class="code">x</code> is not invertible, but <code class="code">1+x</code> is. This is again very easy to check.</p>
<table class="example">
<tr><td><pre>
gap> y := e + x;
(Z(2)^0)*f1+(Z(2)^0)*f2+(Z(2)^0)*f1*f2
gap> IsUnit( KG, y );
true
</pre></td></tr></table>
<p><strong class="pkg">LAGUNA</strong> can calculate the inverse of <code class="code">1+x</code> very quickly.</p>
<table class="example">
<tr><td><pre>
gap> y^-1;
(Z(2)^0)*f1+(Z(2)^0)*f2+(Z(2)^0)*f3+(Z(2)^0)*f4+(Z(2)^0)*f1*f2+(Z(2)^
0)*f1*f3+(Z(2)^0)*f1*f4+(Z(2)^0)*f2*f4+(Z(2)^0)*f1*f2*f4+(Z(2)^0)*f2*f3*f4+(
Z(2)^0)*f1*f2*f3*f4
gap> y * y^-1;
(Z(2)^0)*<identity> of ...
</pre></td></tr></table>
<p>We may also want to check whether <code class="code">y</code> is symmetric, that is, whether it is invariant under the classical involution; or whether it is unitary, that is, whether the classical involution inverts <code class="code">y</code>. We find that <code class="code">y</code> is neither.</p>
<table class="example">
<tr><td><pre>
gap> Involution( y );
(Z(2)^0)*f1+(Z(2)^0)*f1*f2+(Z(2)^0)*f2*f3*f4
gap> y = Involution( y );
false
gap> IsSymmetric( y );
false
gap> y * Involution( y );
(Z(2)^0)*<identity> of ...+(Z(2)^0)*f2+(Z(2)^0)*f2*f3*f4
gap> IsUnitary( y );
false
</pre></td></tr></table>
<p>Now we calculate some important ideals of <code class="code">KG</code>. First we obtain the augmentation ideal which is the set of elements with augmentation zero. In our case the augmentation ideal of <code class="code">KG</code> coincides with the radical of <code class="code">KG</code>, and this is taken into account in <strong class="pkg">LAGUNA</strong>.</p>
<table class="example">
<tr><td><pre>
gap> AugmentationIdeal( KG );
<two-sided ideal in <algebra-with-one over GF(2), with 4 generators>,
(dimension 15)>
gap> RadicalOfAlgebra( KG ) = AugmentationIdeal( KG );
true
</pre></td></tr></table>
<p>It is well-known that the augmentation ideal of <code class="code">KG</code> is a nilpotent ideal. Using Jennings' theory on dimension subgroups, we can obtain its nilpotency index without immediate calculation of its powers. This is implemented in <strong class="pkg">LAGUNA</strong>.</p>
<table class="example">
<tr><td><pre>
gap> AugmentationIdealNilpotencyIndex( KG );
9
</pre></td></tr></table>
<p>On the other hand, we can also calculate the powers of the augmentation ideal.</p>
<table class="example">
<tr><td><pre>
gap> AugmentationIdealPowerSeries( KG );
[ <algebra of dimension 15 over GF(2)>, <algebra of dimension 13 over GF(2)>,
<algebra of dimension 11 over GF(2)>, <algebra of dimension 9 over GF(2)>,
<algebra of dimension 7 over GF(2)>, <algebra of dimension 5 over GF(2)>,
<algebra of dimension 3 over GF(2)>, <algebra of dimension 1 over GF(2)>,
<algebra over GF(2)> ]
</pre></td></tr></table>
<p>We see that the length of this list is exactly the nilpotency index of the augmentation ideal of <code class="code">KG</code>.</p>
<p>Now let's work with the unit group of <code class="code">KG</code>. First we calculate the normalized unit group, which is the set of elements with augmentation one. The generators of the unit group are obtained as explained in Chapter <a href="chap3.html#s0ss0"><b>3.</b></a>. This can be computed very quickly, but further computation with this group is very inefficient.</p>
<table class="example">
<tr><td><pre>
gap> V := NormalizedUnitGroup( KG );
<group of size 32768 with 15 generators>
</pre></td></tr></table>
<p>In order to make our computation in the normalised unit group efficient, we calculate a power-commutator presentation for this group.</p>
<table class="example">
<tr><td><pre>
gap> W := PcNormalizedUnitGroup( KG );
<pc group of size 32768 with 15 generators>
</pre></td></tr></table>
<p><strong class="pkg">GAP</strong> has many efficient and practical algorithms for groups given by a power-commutator presentation. In order to use these algorithms to carry out computation in the normalised unit group, we need to set up isomorphisms between the outputs of <code class="code">NormalizedUnitGroup</code> and <code class="code">PcNormalizedUnitGroup</code>.</p>
<p>The first isomorphism maps <code class="code">NormalizedUnitGroup(KG)</code> onto the polycyclically presented <code class="code">PcNormalizedUnitGroup(PC)</code>. Let's find the images of the elements of the group <code class="code">G</code> in <code class="code">W</code>.</p>
<table class="example">
<tr><td><pre>
gap> t := NaturalBijectionToPcNormalizedUnitGroup( KG );
MappingByFunction( <group of size 32768 with
15 generators>, <pc group of size 32768 with
15 generators>, function( x ) ... end )
gap> List( AsList( G ), x -> ( x^Embedding( G, KG ) )^t );
[ <identity> of ..., f2, f1, f3, f7, f1*f2*f3, f2*f3, f2*f7, f1*f3, f1*f7,
f3*f7, f1*f2*f7, f1*f2*f3*f7, f2*f3*f7, f1*f3*f7, f1*f2 ]
</pre></td></tr></table>
<p>The second isomorphism is the inverse of the first.</p>
<table class="example">
<tr><td><pre>
gap> f := NaturalBijectionToNormalizedUnitGroup( KG );
[ f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11, f12, f13, f14, f15 ] ->
[ (Z(2)^0)*f2, (Z(2)^0)*f1, (Z(2)^0)*f3,
(Z(2)^0)*f1+(Z(2)^0)*f2+(Z(2)^0)*f1*f2,
(Z(2)^0)*f2+(Z(2)^0)*f3+(Z(2)^0)*f2*f3,
(Z(2)^0)*f1+(Z(2)^0)*f3+(Z(2)^0)*f1*f3, (Z(2)^0)*f4,
(Z(2)^0)*f1+(Z(2)^0)*f2+(Z(2)^0)*f3+(Z(2)^0)*f1*f2+(Z(2)^0)*f1*f3+(Z(2)^
0)*f2*f3+(Z(2)^0)*f1*f2*f3, (Z(2)^0)*f2+(Z(2)^0)*f4+(Z(2)^0)*f2*f4,
(Z(2)^0)*f1+(Z(2)^0)*f4+(Z(2)^0)*f1*f4,
(Z(2)^0)*f3+(Z(2)^0)*f4+(Z(2)^0)*f3*f4,
(Z(2)^0)*f1+(Z(2)^0)*f2+(Z(2)^0)*f4+(Z(2)^0)*f1*f2+(Z(2)^0)*f1*f4+(Z(2)^
0)*f2*f4+(Z(2)^0)*f1*f2*f4, (Z(2)^0)*f2+(Z(2)^0)*f3+(Z(2)^0)*f4+(Z(2)^
0)*f2*f3+(Z(2)^0)*f2*f4+(Z(2)^0)*f3*f4+(Z(2)^0)*f2*f3*f4,
(Z(2)^0)*f1+(Z(2)^0)*f3+(Z(2)^0)*f4+(Z(2)^0)*f1*f3+(Z(2)^0)*f1*f4+(Z(2)^
0)*f3*f4+(Z(2)^0)*f1*f3*f4, (Z(2)^0)*f1+(Z(2)^0)*f2+(Z(2)^0)*f3+(Z(2)^
0)*f4+(Z(2)^0)*f1*f2+(Z(2)^0)*f1*f3+(Z(2)^0)*f1*f4+(Z(2)^0)*f2*f3+(Z(2)^
0)*f2*f4+(Z(2)^0)*f3*f4+(Z(2)^0)*f1*f2*f3+(Z(2)^0)*f1*f2*f4+(Z(2)^
0)*f1*f3*f4+(Z(2)^0)*f2*f3*f4+(Z(2)^0)*f1*f2*f3*f4 ]
</pre></td></tr></table>
<p>For example, we may calculate the conjugacy classes of the group <code class="code">W</code>, and then map their representatives back into the group algebra.</p>
<table class="example">
<tr><td><pre>
gap> cc := ConjugacyClasses( W );;
gap> Length( cc );
848
gap> Representative( cc[ Length( cc ) ] );
f1*f2*f4*f6*f12*f15
gap> last^f;
(Z(2)^0)*<identity> of ...+(Z(2)^0)*f2+(Z(2)^0)*f4+(Z(2)^0)*f1*f2+(Z(2)^
0)*f1*f3+(Z(2)^0)*f1*f4+(Z(2)^0)*f2*f3+(Z(2)^0)*f2*f4+(Z(2)^0)*f3*f4+(Z(2)^
0)*f1*f2*f3+(Z(2)^0)*f1*f3*f4
</pre></td></tr></table>
<p>Having a power-commutator presentation of the normalised unit group, we may use the full power of the <strong class="pkg">GAP</strong> functionality for such groups. For example, the lower central series can be calculated very quickly.</p>
<table class="example">
<tr><td><pre>
gap> LowerCentralSeries( W );
[ <pc group of size 32768 with 15 generators>,
Group([ f3, f5*f8*f10*f12*f13*f14*f15, f6*f8*f12*f14*f15, f7, f9*f12,
f10*f14, f11*f13, f13*f14, f14*f15 ]),
Group([ f7, f9*f12, f10*f15, f11*f15, f13*f15, f14*f15 ]),
Group([ f11*f15, f13*f15, f14*f15 ]), Group([ <identity> of ... ]) ]
</pre></td></tr></table>
<p>Let's now compute, for instance, a minimal system of generators of the centre of the normalised unit group. First we carry out the computation in the group which is determined by the power-commutator presentation, then we map the result into our group algebra.</p>
<table class="example">
<tr><td><pre>
gap> C := Centre( W );
Group([ f3*f5*f13*f15, f7, f15, f13*f15, f14*f15, f11*f13*f14*f15 ])
gap> m := MinimalGeneratingSet( C );
[ f7*f13*f14*f15, f13*f14*f15, f7*f11*f14*f15, f15, f3*f5*f14 ]
gap> List( m, g -> g^f );
[ (Z(2)^0)*<identity> of ...+(Z(2)^0)*f3+(Z(2)^0)*f1*f2+(Z(2)^0)*f3*f4+(Z(2)^
0)*f1*f2*f3+(Z(2)^0)*f1*f2*f4+(Z(2)^0)*f1*f2*f3*f4,
(Z(2)^0)*f3+(Z(2)^0)*f4+(Z(2)^0)*f1*f2+(Z(2)^0)*f3*f4+(Z(2)^0)*f1*f2*f3+(
Z(2)^0)*f1*f2*f4+(Z(2)^0)*f1*f2*f3*f4, (Z(2)^0)*<identity> of ...+(Z(2)^
0)*f2+(Z(2)^0)*f3+(Z(2)^0)*f1*f2+(Z(2)^0)*f2*f3+(Z(2)^0)*f2*f4+(Z(2)^
0)*f3*f4+(Z(2)^0)*f1*f2*f3+(Z(2)^0)*f1*f2*f4+(Z(2)^0)*f2*f3*f4+(Z(2)^
0)*f1*f2*f3*f4, (Z(2)^0)*f1+(Z(2)^0)*f2+(Z(2)^0)*f3+(Z(2)^0)*f4+(Z(2)^
0)*f1*f2+(Z(2)^0)*f1*f3+(Z(2)^0)*f1*f4+(Z(2)^0)*f2*f3+(Z(2)^0)*f2*f4+(
Z(2)^0)*f3*f4+(Z(2)^0)*f1*f2*f3+(Z(2)^0)*f1*f2*f4+(Z(2)^0)*f1*f3*f4+(Z(2)^
0)*f2*f3*f4+(Z(2)^0)*f1*f2*f3*f4, (Z(2)^0)*<identity> of ...+(Z(2)^0)*f1+(
Z(2)^0)*f3+(Z(2)^0)*f1*f3+(Z(2)^0)*f1*f4+(Z(2)^0)*f2*f3+(Z(2)^0)*f2*f4+(
Z(2)^0)*f3*f4+(Z(2)^0)*f1*f3*f4 ]
</pre></td></tr></table>
<p>We finish our example by calculating some properties of the Lie algebra associated with <code class="code">KG</code>. This example needs no further explanation.</p>
<table class="example">
<tr><td><pre>
gap> L := LieAlgebra( KG );
#I LAGUNA package: Constructing Lie algebra ...
<Lie algebra over GF(2)>
gap> D := LieDerivedSubalgebra( L );
#I LAGUNA package: Computing the Lie derived subalgebra ...
<Lie algebra of dimension 9 over GF(2)>
gap> LC := LieCentre( L );
<Lie algebra of dimension 7 over GF(2)>
gap> LieLowerNilpotencyIndex( KG );
5
gap> LieUpperNilpotencyIndex( KG );
5
gap> IsLieAbelian( L );
false
gap> IsLieSolvable( L );
#I LAGUNA package: Checking Lie solvability ...
true
gap> IsLieMetabelian( L );
false
gap> IsLieCentreByMetabelian( L );
true
</pre></td></tr></table>
<div class="pcenter">
<table class="chlink"><tr><td><a href="chap0.html">Top of Book</a></td><td><a href="chap1.html">Previous Chapter</a></td><td><a href="chap3.html">Next Chapter</a></td></tr></table>
<br />
<div class="pcenter"><table class="chlink"><tr><td class="chlink1">Goto Chapter: </td><td><a href="chap0.html">Top</a></td><td><a href="chap1.html">1</a></td><td><a href="chap2.html">2</a></td><td><a href="chap3.html">3</a></td><td><a href="chap4.html">4</a></td><td><a href="chapBib.html">Bib</a></td><td><a href="chapInd.html">Ind</a></td></tr></table><br /></div>
</div>
<hr />
<p class="foot">generated by <a href="http://www.math.rwth-aachen.de/~Frank.Luebeck/GAPDoc">GAPDoc2HTML</a></p>
</body>
</html>
distrib
>
Mandriva
>
2010.0
>
i586
>
media
>
contrib-release
>
by-pkgid
>
91213ddcfbe7f54821d42c2d9e091326
>
files
>
1748
