This chapter describes the GAP3 accessible functions of the Sisyphos (Version 0.6) share library package for computing with modular group algebras of p-groups, namely a function to convert a p-group into Sisyphos readable format (see PrintSisyphosInputPGroup), several functions that compute automorphism groups of p-groups (see SAutomorphisms), functions that compute normalized automorphism groups as polycyclically presented groups (see AgNormalizedAutomorphisms, AgNormalizedOuterAutomorphisms), functions that test two p-groups for isomorphism (see IsIsomorphic) and compute isomorphisms between p-groups (see Isomorphisms), and a function to compute the element list of an automorphism group that is given by generators (see AutomorphismGroupElements).
The Sisyphos functions for group rings are not yet available, with the only exception of a function that computed the group of normalized units (see NormalizedUnitsGroupRing).
The algorithms require presentations that are compatible with a
characteristic series of the group with elementary abelian factors, e.g.
the p-central series.
If necessary such a presentation is computed secretly using the
p-central series, the
computations are done using this presentation, and then the results are
carried back to the original presentation. The check of compatibility
is done by the function IsCompatiblePCentralSeries (see
IsCompatiblePCentralSeries).
The component isCompatiblePCentralSeries of the group will be either true
or false then.
If you know in advance that your group is compatible with a series of the
kind required, e.g. the Jennings-series,
you can avoid the check by setting this flag to true by hand.
Before using any of the functions described in this chapter you must load the package by calling the statement
gap> RequirePackage( "sisyphos" );
PrintSISYPHOSWord( P, a )
For a polycyclically presented group P and an element a of P,
PrintSISYPHOSWord( P ,a ) prints a string that encodes a in the
input format of the Sisyphos system.
The string "1" means the identity element, the other elements are
products of powers of generators, the i-th generator is given the
name gi.
gap> g := SolvableGroup ( "D8" );;
gap> PrintSISYPHOSWord ( g, g.2*g.1 ); Print( "\n" );
g1*g2*g3
PrintSisyphosInputPGroup( P, name, type )
prints the presentation of the finite p-group P in a format readable by the Sisyphos system. P must be a polycyclically or freely presented group.
In Sisyphos, the group will be named name.
If P is polycyclically presented the i-th generator gets the name
gi.
In the case of a free presentation the names of the generators are not
changed; note that Sisyphos accepts only generators names beginning
with a letter followed by a sequence of letters, digits,underscores
and dots.
type must be either "pcgroup" or the prime dividing the order of
P.
In the former case the Sisyphos object has type pcgroup, P must
be polycyclically presented for that.
In the latter case a Sisyphos object of type group is created.
For avoiding computations in freely presented groups, is neither
checked that the presentation describes a p-group, nor that the
given prime really divides the group order.
See the Sisyphos manual Wur93 for details.
gap> g:= SolvableGroup( "D8" );;
gap> PrintSisyphosInputPGroup( g, "d8", "pcgroup" );
d8 = pcgroup(2,
gens(
g1,
g2,
g3),
rels(
g1^2 = 1,
g2^2 = 1,
g3^2 = 1,
[g2,g1] = g3));
gap> q8 := FreeGroup ( 2 );;
gap> q8.relators := [q8.1^4,q8.2^2/q8.1^2,Comm(q8.2,q8.1)/q8.1^2];;
gap> PrintSisyphosInputPGroup ( q8, "q8", 2 );
#I PQuotient: class 1 : 2
#I PQuotient: Runtime : 0
q8 = group (minimal,
2,
gens(
f.1,
f.2),
rels(
f.1^4,
f.2^2*f.1^-2,
f.2^-1*f.1^-1*f.2*f.1^-1));
71.3 IsCompatiblePCentralSeries
IsCompatiblePCentralSeries( G )
If the component G.isCompatiblePCentralSeries of the polycyclically
presented p-group G is bound, its value is
returned, otherwise the exponent-p-central series of G is computed
and compared to the given presentation. If the generators of each term of
this series form a subset of the generators of G the component
G.isCompatiblePCentralSeries is set to true, otherwise to false.
This value is then returned by the function.
gap> g:= SolvableGroup( "D8" );;
gap> IsCompatiblePCentralSeries ( g );
true
gap> a := AbstractGenerators ( "a", 5 );;
gap> h := AgGroupFpGroup ( rec (
> generators := a,
> relators :=
> [a[1]^2/(a[3]*a[5]),a[2]^2/a[3],a[3]^2/(a[4]*a[5]),a[4]^2,a[5]^2]));;
gap> h.name := "H";;
gap> IsCompatiblePCentralSeries ( h );
false
gap> PCentralSeries ( h, 2 );
[ H, Subgroup( H, [ a3, a4, a5 ] ), Subgroup( H, [ a4*a5 ] ),
Subgroup( H, [ ] ) ]
SAutomorphisms( P )
OuterAutomorphisms( P )
NormalizedAutomorphisms( P )
NormalizedOuterAutomorphisms( P )
all return a record with components
sizeOutG:
sizeInnG:
sizeAutG:
generators:
gap> g:= SolvableGroup( "Q8" );;
gap> SAutomorphisms( g );
rec(
sizeAutG := 24,
sizeInnG := 4,
sizeOutG := 6,
generators :=
[ GroupHomomorphismByImages( Q8, Q8, [ a, b, c ], [ b, a, c ] ),
GroupHomomorphismByImages( Q8, Q8, [ a, b, c ], [ a*b, b, c ] ),
GroupHomomorphismByImages( Q8, Q8, [ a, b, c ], [ a, b*c, c ] ),
GroupHomomorphismByImages( Q8, Q8, [ a, b, c ], [ a*c, b, c ] ) ] )
gap> OuterAutomorphisms( g );
rec(
sizeAutG := 24,
sizeInnG := 4,
sizeOutG := 6,
generators :=
[ GroupHomomorphismByImages( Q8, Q8, [ a, b, c ], [ b, a, c ] ),
GroupHomomorphismByImages( Q8, Q8, [ a, b, c ], [ a*b, b, c ] ) ] )
Note: If the component P.isCompatiblePCentralSeries is not bound
it is computed using IsCompatiblePCentralSeries.
71.5 AgNormalizedAutomorphisms
AgNormalizedAutomorphisms( P )
returns a polycyclically presented group isomorphic to the group of all normalized automorphisms of the polycyclically presented p-group P.
gap> g:= SolvableGroup( "D8" );;
gap> aut:= AgNormalizedAutomorphisms( g );
Group( g0, g1 )
gap> Size( aut );
4
Note: If the component P.isCompatiblePCentralSeries is not bound
it is computed using IsCompatiblePCentralSeries.
71.6 AgNormalizedOuterAutomorphisms
AgNormalizedOuterAutomorphisms( P )
returns a polycyclically presented group isomorphic to the group of normalized outer automorphisms of the polycyclically presented p-group P.
gap> g:= SolvableGroup( "D8" );;
gap> aut:= AgNormalizedOuterAutomorphisms( g );
Group( IdAgWord )
Note: If the component P.isCompatiblePCentralSeries is not bound
it is computed using IsCompatiblePCentralSeries.
IsIsomorphic( P1, P2 )
returns true if the polycyclically or freely presented p-group P1 and
the polycyclically presented p-group P2 are isomorphic,
false otherwise.
gap> g:= SolvableGroup( "D8" );;
gap> nonab:= AllTwoGroups( Size, 8, IsAbelian, false );
[ Group( a1, a2, a3 ), Group( a1, a2, a3 ) ]
gap> List( nonab, x -> IsIsomorphic( g, x ) );
[ true, false ]
(The function Isomorphisms returns isomorphisms in case the groups are
isomorphic.)
Note: If the component P2.isCompatiblePCentralSeries is not bound
it is computed using IsCompatiblePCentralSeries.
Isomorphisms( P1, P2 )
If the polycyclically or freely presented p-groups P1 and the
polycyclically presented p-group P2 are not isomorphic,
Isomorphisms returns false.
Otherwise a record is returned that encodes the isomorphisms from P1 to
P2; its components are
epimorphism:P1.generators that defines an
isomorphism from P1 to P2,
generators:
sizeOutG:
sizeInnG:
sizeOutG:
gap> g:= SolvableGroup( "Q8" );;
gap> nonab:= AllTwoGroups( Size, 8, IsAbelian, false );
[ Group( a1, a2, a3 ), Group( a1, a2, a3 ) ]
gap> nonab[2].name:= "im";;
gap> Isomorphisms( g, nonab[2] );
rec(
sizeAutG := 24,
sizeInnG := 4,
sizeOutG := 6,
epimorphism := [ a1, a2, a3 ],
generators :=
[ GroupHomomorphismByImages( im, im, [ a1, a2, a3 ], [ a2, a1, a3 ] ),
GroupHomomorphismByImages( im, im, [ a1, a2, a3 ], [ a1*a2, a2, a3
] ) ] )
(The function IsIsomorphic tests for isomorphism of p-groups.)
Note: If the component P2.isCompatiblePCentralSeries is not bound
it is computed using IsCompatiblePCentralSeries.
71.9 CorrespondingAutomorphism
CorrespondingAutomorphism( G, w )
If G is a polycyclically presented group of automorphisms of a group P
as returned by AgNormalizedAutomorphisms (see
AgNormalizedAutomorphisms) or
AgNormalizedOuterAutomorphisms (see AgNormalizedOuterAutomorphisms),
and w is an element of G then the automorphism of P corresponding to
w is returned.
gap> g:= TwoGroup( 64, 173 );;
gap> g.name := "G173";;
gap> autg := AgNormalizedAutomorphisms ( g );
Group( g0, g1, g2, g3, g4, g5, g6, g7, g8 )
gap> CorrespondingAutomorphism ( autg, autg.2*autg.1^2 );
GroupHomomorphismByImages( G173, G173, [ a1, a2, a3, a4, a5, a6 ],
[ a1, a2*a4, a3*a6, a4*a6, a5, a6 ] )
71.10 AutomorphismGroupElements
AutomorphismGroupElements( A )
A must be an automorphism record as returned by one of the automorphism routines or a list consisting of automorphisms of a p-group P.
In the first case a list of all elements of Aut(P) or Autn(P) is
returned, if A has been created by SAutomorphisms
or NormalizedAutomorphisms (see SAutomorphisms),
respectively, or a list of coset representatives of Aut(P) or Autn(P)
modulo Inn(P), if A has been created by OuterAutomorphisms
or NormalizedOuterAutomorphisms (see SAutomorphisms), respectively.
In the second case the list of all elements of the subgroup of Aut(P) generated by A is returned.
gap> g:= SolvableGroup( "Q8" );;
gap> outg:= OuterAutomorphisms( g );;
gap> AutomorphismGroupElements( outg );
[ GroupHomomorphismByImages( Q8, Q8, [ a, b, c ], [ a, b, c ] ),
GroupHomomorphismByImages( Q8, Q8, [ a, b, c ], [ b, a, c ] ),
GroupHomomorphismByImages( Q8, Q8, [ a, b, c ], [ a*b, b, c ] ),
GroupHomomorphismByImages( Q8, Q8, [ a, b, c ], [ a*b*c, a, c ] ),
GroupHomomorphismByImages( Q8, Q8, [ a, b, c ], [ b, a*b, c ] ),
GroupHomomorphismByImages( Q8, Q8, [ a, b, c ], [ a, a*b*c, c ] ) ]
gap> l:= [ outg.generators[2] ];
[ GroupHomomorphismByImages( Q8, Q8, [ a, b, c ], [ a*b, b, c ] ) ]
gap> AutomorphismGroupElements( l );
[ GroupHomomorphismByImages( Q8, Q8, [ a, b, c ], [ a, b, c ] ),
GroupHomomorphismByImages( Q8, Q8, [ a, b, c ], [ a*b, b, c ] ),
GroupHomomorphismByImages( Q8, Q8, [ a, b, c ], [ a*c, b, c ] ),
GroupHomomorphismByImages( Q8, Q8, [ a, b, c ], [ a*b*c, b, c ] ) ]
71.11 NormalizedUnitsGroupRing
NormalizedUnitsGroupRing( P )
NormalizedUnitsGroupRing( P, n )
When called with a polycyclicly presented p-group P, the group of normalized units of the group ring FP of P over the field F with p elements is returned.
If a second argument n is given, the group of normalized units of FP / In is returned, where I denotes the augmentation ideal of FP.
The returned group is represented as polycyclicly presented group.
gap> g:= SolvableGroup( "D8" );;
gap> NormalizedUnitsGroupRing( g, 1 );
#D use multiplication table
Group( IdAgWord )
gap> NormalizedUnitsGroupRing( g, 2 );
#D use multiplication table
Group( g1, g2 )
gap> NormalizedUnitsGroupRing( g, 3 );
#D use multiplication table
Group( g1, g2, g3, g4 )
gap> NormalizedUnitsGroupRing( g );
#D use multiplication table
Group( g1, g2, g3, g4, g5, g6, g7 )
gap3-jm