When you start GAP, it already knows several groups. Currently GAP initially knows the following groups:
There is usually no relation between the groups in the different libraries and a group may occur in different libraries in different incarnations.
Note that a system administrator may choose to install all, or only a few, or even none of the libraries. So some of the libraries mentioned below may not be available on your installation.
There are several infinite families of groups which are parametrized by
numbers.
GAP provides various functions to construct these groups.
The functions always permit (but do not require) one to indicate
a filter (see Filters), for example IsPermGroup
, IsMatrixGroup
or
IsPcGroup
, in which the group shall be constructed.
There always is a default filter corresponding to a ``natural'' way
to describe the group in question.
Note that not every group can be constructed in every filter,
there may be theoretical restrictions (IsPcGroup
only works for
solvable groups) or methods may be available only for a few filters.
Certain filters may admit additional hints.
For example, groups constructed in IsMatrixGroup
may be constructed
over a specified field, which can be given as second argument of the
function that constructs the group;
The default field is Rationals
.
CyclicGroup( [
filt, ]
n ) F
constructs the cyclic group of size n in the filter filt.
If filt is not given it defaults to IsPcGroup
.
gap> CyclicGroup(12); <pc group of size 12 with 3 generators> gap> CyclicGroup(IsPermGroup,12); Group( [ ( 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11,12) ] ) gap> matgrp1:= CyclicGroup( IsMatrixGroup, 12 ); <matrix group of size 12 with 1 generators> gap> FieldOfMatrixGroup( matgrp1 ); Rationals gap> matgrp2:= CyclicGroup( IsMatrixGroup, GF(2), 12 ); <matrix group of size 12 with 1 generators> gap> FieldOfMatrixGroup( matgrp2 ); GF(2)
AbelianGroup( [
filt, ]
ints ) F
constructs an abelian group in the filter filt which is of isomorphism
type Cints[1] \* Cints[2] \* ¼\* Cints[n].
ints must be a list of positive integers.
If filt is not given it defaults to IsPcGroup
.
The generators of the group returned are the elements corresponding to
the integers in ints.
gap> AbelianGroup([1,2,3]); <pc group of size 6 with 3 generators>
ElementaryAbelianGroup( [
filt, ]
n ) F
constructs the elementary abelian group of size n in the filter filt.
If filt is not given it defaults to IsPcGroup
.
gap> ElementaryAbelianGroup(8192); <pc group of size 8192 with 13 generators>
DihedralGroup( [
filt, ]
n ) F
constructs the dihedral group of size n in the filter filt.
If filt is not given it defaults to IsPcGroup
.
gap> DihedralGroup(10); <pc group of size 10 with 2 generators>
ExtraspecialGroup( [
filt, ]
order,
exp ) F
Let order be of the form p2n+1, for a prime integer p and a
positive integer n.
ExtraspecialGroup
returns the extraspecial group of order order
that is determined by exp, in the filter filt.
If p is odd then admissible values of exp are the exponent of the
group (either p or p2) or one of '+'
, "+"
, '-'
,
"-"
.
For p = 2, only the above plus or minus signs are admissible.
If filt is not given it defaults to IsPcGroup
.
gap> ExtraspecialGroup( 27, 3 ); <pc group of size 27 with 3 generators> gap> ExtraspecialGroup( 27, '+' ); <pc group of size 27 with 3 generators> gap> ExtraspecialGroup( 8, "-" ); <pc group of size 8 with 3 generators>
AlternatingGroup( [
filt, ]
deg ) F
AlternatingGroup( [
filt, ]
dom ) F
constructs the alternating group of degree deg in the filter filt.
If filt is not given it defaults to IsPermGroup
.
In the second version, the function constructs the alternating group on
the points given in the set dom which must be a set of positive
integers.
gap> AlternatingGroup(5); Alt([1..5])
SymmetricGroup( [
filt, ]
deg ) F
SymmetricGroup( [
filt, ]
dom ) F
constructs the symmetric group of degree deg in the filter filt.
If filt is not given it defaults to IsPermGroup
.
In the second version, the function constructs the symmetric group on
the points given in the set dom which must be a set of positive
integers.
gap> SymmetricGroup(10); Sym([1..10])
Note that permutation groups provide special treatment of symmetric and alternating groups, see Symmetric and Alternating Groups.
GeneralLinearGroup( [
filt, ]
d,
q ) F
GL( [
filt, ]
d,
q ) F
constructs a group isomorphic to the general linear group GL( d, q ) of d ×d matrices over the field with q elements, in the filter filt.
If filt is not given it defaults to IsMatrixGroup
,
and the returned group is the general linear group itself.
gap> GL(4,3); GL(4,3)
SpecialLinearGroup( [
filt, ]
d,
q ) F
SL( [
filt, ]
d,
q ) F
constructs a group isomorphic to the special linear group SL( d, q ) of those d ×d matrices over the field with q elements whose determinant is the identity of the field, in the filter filt.
If filt is not given it defaults to IsMatrixGroup
,
and the returned group is the special linear group itself.
gap> SpecialLinearGroup(2,2); SL(2,2)
Using the OnLines
operation it is possible to obtain the corresponding
projective groups in a permutation action:
gap> g:=GL(4,3);;Size(g); 24261120 gap> pgl:=Action(g,Orbit(g,Z(3)^0*[1,0,0,0],OnLines),OnLines);; gap> Size(pgl); 12130560
ProjectiveGeneralLinearGroup( [
filt, ]
d,
q ) F
PGL( [
filt, ]
d,
q ) F
constructs a group isomorphic to the projective general linear group PGL( d, q ) of those d ×d matrices over the field with q elements, modulo the centre, in the filter filt.
If filt is not given it defaults to IsPermGroup
,
and the returned group is the action on lines of the underlying vector
space.
ProjectiveSpecialLinearGroup( [
filt, ]
d,
q ) F
PSL( [
filt, ]
d,
q ) F
constructs a group isomorphic to the projective special linear group PSL( d, q ) of those d ×d matrices over the field with q elements whose determinant is the identity of the field, modulo the centre, in the filter filt.
If filt is not given it defaults to IsPermGroup
,
and the returned group is the action on lines of the underlying vector
space.
GeneralUnitaryGroup( [
filt, ]
d,
q ) F
GU( [
filt, ]
d,
q ) F
constructs a group isomorphic to the general unitary group GU( d, q ) of those d ×d matrices over the field with q 2 elements that respect a fixed nondegenerate sesquilinear form, in the filter filt.
If filt is not given it defaults to IsMatrixGroup
,
and the returned group is the general unitary group itself.
gap> GeneralUnitaryGroup( 3, 5 ); GU(3,5)
SpecialUnitaryGroup( [
filt, ]
d,
q ) F
SU( [
filt, ]
d,
q ) F
constructs a group isomorphic to the speial unitary group GU( d, q ) of those d ×d matrices over the field with q 2 elements whose determinant is the identity of the field and that respect a fixed nondegenerate sesquilinear form, in the filter filt.
If filt is not given it defaults to IsMatrixGroup
,
and the returned group is the special unitary group itself.
gap> SpecialUnitaryGroup( 3, 5 ); SU(3,5)
SymplecticGroup( [
filt, ]
d,
q ) F
Sp( [
filt, ]
d,
q ) F
SP( [
filt, ]
d,
q ) F
constructs a group isomorphic to the symplectic group Sp( d, q ) of those d ×d matrices over the field with q elements that respect a fixed nondegenerate symplectic form, in the filter filt.
If filt is not given it defaults to IsMatrixGroup
,
and the returned group is the symplectic group itself.
gap> SymplecticGroup( 4, 2 ); Sp(4,2)
MathieuGroup( [
filt, ]
degree ) F
constructs the Mathieu group of degree degree in the filter filt,
where degree must be in { 9, 10, 11, 12, 21, 22, 23, 24 }.
If filt is not given it defaults to IsPermGroup
.
gap> MathieuGroup( 11 ); Group([ ( 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11), ( 3, 7,11, 8)( 4,10, 5, 6) ])
45.2 Constructors for Basic Groups
All functions described in the last section call constructor operations to
do the work.
The names of the constructors are obtained from the names of the functions
by appending Cons
, so for example CyclicGroup
calls the constructor
cat,
n ) O
The first argument cat for each method of this constructor must be
the category for which the method is installed.
For example the method for constructing a cyclic permutation group
is installed as follows (see prg:InstallMethod in ``Programming in GAP''
for the meaning of the arguments of InstallMethod
).
InstallMethod( CyclicGroupCons, "regular perm group", true, [ IsPermGroup and IsRegularProp and IsFinite, IsInt and IsPosRat ], 0, function( filter, n ) ... end );
LibraryGroups( fun 1, val 1, ... )
For each of the following group libraries there is a selection function. This function permits one to select all groups from the library that have a given set of properties.
The name of the selection functions always begins with All
and always
ends with Groups
. In between is a name that hints at the nature of the
group library. For example, the selection function for the library of all
primitive groups (see Primitive permutation groups) is called
AllPrimitiveGroups
.
These functions take an arbitrary number of pairs of arguments. The first argument in such a pair is a function that can be applied to the groups in the library, and the second argument is either a single value that this function must return in order to have this group included in the selection, or a list of such values. For example,
AllPrimitiveGroups( DegreeOperation, [10..15], Size, [1..100], IsAbelian, false );returns a list of all primitive groups with degree between 10 and 15 and size less than 100 that are not abelian.
Thus the AllPrimitiveGroups
behaves as if it was implemented by a
function similar to the one defined below, where PrimitiveGroupsList
is a
list of all primitive groups. (Note that in the definition below we assume
for simplicity that AllPrimitiveGroups
accepts exactly 4 arguments. It is
of course obvious how to change this definition so that the function would
accept a variable number of arguments.)
AllPrimitiveGroups := function( fun1, val1, fun2, val2 ) local groups, g, i; groups := []; for i in [ 1 .. Length( PrimitiveGroupsList ) ] do g := PrimitiveGroupsList[i]; if fun1(g) = val1 or IsList(val1) and fun1(g) in val1 and fun2(g) = val2 or IsList(val2) and fun2(g) in val2 then Add( groups, g ); fi; od; return groups; end;Note that the real selection functions are considerably more difficult, to improve the efficiency. Most important, each recognizes a certain set of properties which are precomputed for the library without having to compute them anew for each group. This will substantially speed up the selection process. In the description of each library we will list the properties that are stored for this library.
LibraryGroup( fun 1, val 1, ... )
This function simply returns the first (in the stored order) group in the
library that has the prescribed properties.
It returns fail
if no such group exists in the library.
45.4 Primitive Permutation Groups
GAP contains a library of primitive permutation groups which includes the following permutation groups up to permutation isomorphism (i.e., up to conjugacy in the corresponding symmetric group)
PrimitiveGroup(
deg,
nr ) F
returns the primitive permutation group of degree deg with number nr from the list.
The library of primitive groups (as given in Theissen97) currently does not store all the groups, but computes them ``on the fly''. Therefore it cannot be guaranteed that the arrangement of the groups will remain the same between different versions of GAP or after making further methods available! Therefore when using or quoting primitive groups in a context that leaves one GAP session it is not sufficient to talk about group number nr of degree deg, but actual generators must be given!
The groups are sorted in the following way: For deg £ 255 first come affine groups. If deg is a prime p it starts with the one-dimensional affine groups over the field Fp, that is Frobenius groups of the form Fp:A for a subgroup A £ Aut(Fp). Then come the other solvable affine groups, in the same order as in the list of M. Short (who did not include the Frobenius groups). Next in the list come the insolvable affine primitive permutation groups.
Then come the non-affine primitive permutation groups of degree deg. They have been classified into cohorts in DixonMortimer88, and GAP represents a cohort as a homomorphism k:N = NSdeg (S)® A whose kernel S is the socle of N and every primitive group in that cohort is the preimage of a subgroup of A (only one from each conjugacy class) under k. For the degrees in question, A is solvable. All primitive groups in the cohort k have the same socle, namely S. The groups of each cohort appear in the list consecutively.
(The functions NrAffinePrimitiveGroups and
``NrSolvablePrimitiveGroups' can
be used to determine where the different parts of the lists start.)
This arrangement differs from the arrangement of primitive groups in the
list of C. Sims, which was used in GAP 3. See PrimitiveGroupSims
(PrimitiveGroupSims).
NrPrimitiveGroups(
deg ) F
returns the number of primitive permutation groups of degree deg in the library.
NrAffinePrimitiveGroups(
deg ) F
returns the number of affine primitive permutation groups of degree deg in the library.
NrSolvableAffinePrimitiveGroups(
deg ) F
returns the number of solvable affine primitive permutation groups of degree deg in the library.
gap> NrPrimitiveGroups(25); 28 gap> NrAffinePrimitiveGroups(25); 22 gap> NrSolvableAffinePrimitiveGroups(25); 19 gap> PrimitiveGroup(25,19); <permutation group of size 2400 with 5 generators> gap> PrimitiveGroup(25,20); 5^2:GL(2,5)_1 gap> PrimitiveGroup(25,22); 5^2:GL(2,5)_3 gap> PrimitiveGroup(25,23); L2,4 on projective points^2.1
AffinePermGroupByMatrixGroup(
M ) F
takes a group M of n ×n matrices over the finite field F and returns an affine permutation group Fn : M , w.r.t. the natural action of M on the vector space Fn.
PrimitiveAffinePermGroupByMatrixGroup(
M ) F
works as AffinePermGroupByMatrixGroup
but assumes that M acts
irreducibly. (This reduces the number of generators.)
gap> g:=SL(3,2);; gap> a:=AffinePermGroupByMatrixGroup(g); 2^3:SL(3,2) gap> b:=PrimitiveAffinePermGroupByMatrixGroup(g);; gap> Length(GeneratorsOfGroup(a));Length(GeneratorsOfGroup(b)); 5 3
The selection functions (see Selection functions) for the primitive
groups library are AllPrimitiveGroups
and OnePrimitiveGroup
.
PrimitiveGroupSims(
deg,
nr ) F
For compatibility with earlier versions of GAP, the original list of
Sims, with the same numbers and the names given by Buekenhout and Leemans
BuekenhoutLeemans96, is also included. It is accessed by the
function PrimitiveGroupSims
.
SimsNo(
G ) A
If G is a primitive group obtained by PrimitiveGroup
(respectively one
of the selection functions) this attribute contains the number of the
isomorphic group in the original list of Sims.
SimsName(
G ) A
If G is a primitive group obtained by PrimitiveGroup
(respectively one
of the selection functions) this attribute contains the name of the
isomorphic group in the original list of Sims.
gap> g:=PrimitiveGroup(25,2); Group( [ ( 2,19)( 3,25)( 4, 7)( 5,13)( 8,20)( 9,12)(10,23)(14,22)(15,18) (17,24), ( 2,20, 7)( 3,22,13)( 4, 8,19)( 5,14,25)( 6,10,23)( 9,11,12) (15,16,18)(17,21,24), ( 1, 6,11,21,16)( 2, 7,12,22,17)( 3, 8,13,23,18) ( 4, 9,14,24,19)( 5,10,15,25,20) ] ) gap> SimsNo(g); 3 gap> SimsName(g); "5^2:S_3" gap> PrimitiveGroupSims(25,2); 5^2:6 gap> PrimitiveGroupSims(25,3); 5^2:S_3
There are also selection functions AllPrimitiveGroupSims
and
OnePrimitiveGroupSims
.
IrreducibleSolvableGroup(
n,
p,
i ) F
returns the i-th irreducible solvable subgroup of GL( n, p ). The irreducible solvable subgroups of GL(n,p) are ordered with respect to the following criteria:
The corresponding selection functions are AllIrreducibleSolvableGroups
and
OneIrreducibleSolvableGroup
. They obtain the following properties from the
database without having to compute them anew:
Dimension
for the linear degree, CharFFE
for the field characteristic,
Size
, IsLinearlyPrimitive
and MinimalBlockDimension
.
45.5 Transitive Permutation Groups
The transitive groups library currently contains representatives for all transitive permutation groups of degree at most 23. Two permutations groups of the same degree are considered to be equivalent, if there is a renumbering of points, which maps one group into the other one. In other words, if they lie in the same conjugacy class under operation of the full symmetric group by conjugation.
TransitiveGroup(
deg,
nr ) F
returns the nr-th transitive group of degree deg. Both deg and
nr must be positive integers. The transitive groups of equal degree
are sorted with respect to their size, so for example
TransitiveGroup(
deg, 1 )
is a transitive group of degree and
size deg, e.g, the cyclic group of size deg, if deg is a
prime.
NrTransitiveGroups(
deg ) F
returns the number of transitive groups of degree deg stored in the
library of transitive groups. The function returns fail
if deg is
beyond the range of the library.
The selection functions (see Selection functions) for the transitive
groups library are AllTransitiveGroups
and OneTransitiveGroup
. They
obtain the following properties from the database without having to compute
them anew:
NrMovedPoints
, Size
, Transitivity
, and IsPrimitive
.
This library was computed by Gregory Butler, John McKay, Gordon Royle and Alexander Hulpke. The list of transitive groups up to degree 11 was published in BM83, the list of degree 12 was published in Roy87, degree 14 and 15 were published in Butler93 and degrees 16--22 in Hulpke96. (Groups of prime degree of course are primitive and were known long before.)
The arrangement and the names of the groups of degree up to 15 is the same
as given in ConwayHulpkeMcKay98. With the exception of the symmetric
and alternating group (which are represented as SymmetricGroup
and
AlternatingGroup
) the generators for these groups also conform to this
paper with the only difference that 0 (which is not permitted in GAP for
permutations to act on) is always replaced by the degree.
gap> TransitiveGroup(10,22); S(5)[x]2 gap> l:=AllTransitiveGroups(NrMovedPoints,12,Size,1440,IsSolvable,false); [ S(6)[x]2, M_10.2(12) = A_6.E_4(12) = [S_6[1/720]{M_10}S_6]2 ] gap> List(l,IsSolvable); [ false, false ]
TransitiveIdentification(
G ) A
Let G be a permutation group, acting transitively on a set of up to 23
points. Then TransitiveIdentification
will return the position of this
group in the transitive groups library. This means, if G acts on
m points and TransitiveIdentification
returns n, then G is
permutation isomorphic to the group TransitiveGroup(m,n)
.
Note: The points moved do not need to be [1..n], the group
á(2,3,4),(2,3)ñ is considered to be transitive on 3
points. If the group has several orbits on the points moved by it the
result of TransitiveIdentification
is undefined.
gap> TransitiveIdentification(Group((1,2),(1,2,3))); 2
This library contains listings of all groups of certain orders up to isomorphism. Currently, the groups of order at most 1000 except 512, the groups whose order is a product of at most 3 primes and the groups of order 2n ·p for n £ 8 and p an odd prime are included in the catalogue.
The nilpotent groups have been computed by E. A. O'Brien, see NO89, while the non-nilpotent groups have been determined by Hans Ulrich Besche and Bettina Eick, see BescheEick98, BescheEick1000 and BescheEick768. For a description of the groups whose order has at most 3 prime factors, see Neu67.
Additionally to the catalogue of groups there exists an identification routine for groups of small order; that is, a function that returns the catalogue number of any given group of suitable order.
Note that the small groups library contains the GAP 3 libraries
TwoGroups
and ThreeGroups
without any changes. Moreover, the
small groups library is a substitute for the GAP 3 library of
solvable groups of order at most 100. However, these catalogues
are sorted differently.
The complete catalogue together with the identification routine needs about 25 MB of space on a hard disk. Thus we have split the library in three layers. The first layer is always installed, since it does not need much space. The second and third layers may be omitted in the installation, if necessary. Moreover, the catalogue and the identification routine can be installed independent of each other.
SmallGroup(
size,
i ) F
SmallGroup( [
size,
i] ) F
returns the i-th group of order size in the catalogue. The group will be given as PcGroup, if it is solvable and as permutation group otherwise. If the groups of order size are not installed, the function returns an error.
NumberSmallGroups(
size ) F
returns the number of groups of order size.
AllGroups( arg ) F
returns all small groups with certain properties. The first selection
function has to be Size
. There are precomputed listings for the
properties IsAbelian
, IsNilpotentGroup
, IsSupersolvableGroup
,
IsSolvableGroup
, RankPGroup
, PClassPGroup
, LGLength
,
FrattinifactorSize
and FrattinifactorId
for the groups of order
at most 1000 except 512 and 768 whose order have more than
three prime factors.
IdsOfAllGroups( arg ) F
similar to AllGroups
but returns id's instead of groups. This may
be useful to avoid workspace overflows, if a large number of groups are
expected in the output.
OneGroup( arg ) F
see AllGroups
.
Gap3CatalogueGroup(
size,
i ) F
returns the i-th group of order size in the GAP 3 catalogue of
solvable groups. This group is isomorphic to the group returned by
SolvableGroup(
size,
i )
in GAP 3.
IdGroup(
G ) A
returns the catalogue number of G; that is, the function returns
a pair [
size,
i]
meaning that G is isomorphic to
SmallGroup(
size,
i )
.
Gap3CatalogueIdGroup(
G ) A
returns the catalogue number of G in the GAP 3 catalogue of solvable
groups; that is, the function returns a pair [
size,
i]
meaning that
G is isomorphic to the group SolvableGroup(
size,
i )
in GAP 3.
UnloadSmallGroupsData( ) F
while GAP loads all necessary data from the small groups library automatically, it does not remove the data from the workspace again. Usually, this will be not necessary, since the data is stored in a compressed format. However, if a large number of small groups have been loaded by a user, then the user might wish to remove the data from the workspace and this can be done by the above function call. Note that this is not dangerous in any case, since the data will be reloaded automatically, if necessary.
gap> G := SmallGroup( 768, 1000000 ); <pc group of size 768 with 9 generators> gap> NumberSmallGroups( 512 ); 10494213 gap> NumberSmallGroups( 768 ); 1090235 gap> NumberSmallGroups( 2^8 * 5 ); 1116461 gap> AllGroups( Size, 120, IsSolvableGroup, false ); [ Group([ ( 1, 2, 4, 8)( 3, 6, 9, 5)( 7,12,13,17)(10,14,11,15)(16,20,21,24) (18,22,19,23), ( 1, 3, 7)( 2, 5,10)( 4, 9,13)( 6,11, 8)(12,16,20) (14,18,22)(15,19,23)(17,21,24) ]), Group([ (1,2,3,4,5), (1,2) ]), Group([ (1,2,3,5,4), (1,3)(2,4)(6,7) ]) ] gap> IdsOfAllGroups( Size, 60, IsSupersolvableGroup, true ); [ [ 60, 1 ], [ 60, 2 ], [ 60, 3 ], [ 60, 4 ], [ 60, 6 ], [ 60, 7 ], [ 60, 8 ], [ 60, 10 ], [ 60, 11 ], [ 60, 12 ], [ 60, 13 ] ] gap> OneGroup( Size, [1..1000], IsSolvableGroup, false ); Group([ (1,2,3,4,5), (1,2,3) ]) gap> List( DerivedSeries( Gap3CatalogueGroup( 24, 15 ) ), Size ); [ 24, 12, 4, 1 ] gap> IdGroup( GL( 2,3 ) ); [ 48, 29 ] gap> Gap3CatalogueIdGroup( GL( 2,3 ) ); [ 48, 49 ] gap> UnloadSmallGroupsData();
Note that for the groups of order 512 NumberSmallGroups
is the
only catalogue function which will return a result. These groups
have been enumerated, but not determined yet.
The GAP library of finite perfect groups provides, up to isomorphism, a list of all perfect groups whose sizes are less than 106 excluding the following sizes:
Except for these eleven sizes, the list of altogether 1096 perfect groups in the library is complete. It relies on results of Derek F. Holt and Wilhelm Plesken which are published in their book it Perfect Groups HP89. Moreover, they have supplied us with files with presentations of 488 of the groups. In terms of these, the remaining 607 nontrivial groups in the library can be described as 276 direct products, 107 central products, and 224 subdirect products. They are computed automatically by suitable GAP functions whenever they are needed.
We are grateful to Derek Holt and Wilhelm Plesken for making their groups available to the GAP community by contributing their files. It should be noted that their book contains a lot of further information for many of the library groups. So we would like to recommend it to any GAP user who is interested in the groups.
The library has been brought into GAP format by Volkmar Felsch.
SizesPerfectGroups( ) F
PerfectGroup( [
filt, ]
size[,
n] ) F
PerfectGroup( [
filt, ]
sizenumberpair ) F
returns a group which is isomorphic to the library group specified
by the size number [
size,
n ]
or by the two separate
arguments size and n, assuming a default value of n = 1.
The optional argument filt defines the filter in which the group is
returned.
Possible filters so far are IsPermGroup
and IsSubgroupFpGroup
.
In the latter case, the generators and relators used coincide with those
given in HP89.
gap> G := PerfectGroup(IsPermGroup,6048,1); U3(3)
As all groups are stored by presentations, a permutation representation is obtained by coset enumeration. Note that some of the library groups do not have a faithful permutation representation of small degree. Computations in these groups may be rather time consuming.
gap> G:=PerfectGroup(IsPermGroup,129024,2); L2(8) N ( 2^6 E 2^1 A ) C 2^1 gap> NrMovedPoints(G); 14336
PerfectIdentification(
G ) A
This attribute is set for all groups obtained from the perfect groups
library and has the value [
size,
nr]
if the group is obtained with
these parameters from the library.
NumberPerfectGroups(
size ) F
returns the number of non-isomorphic perfect groups of size size for
each positive integer size up to 106 except for the eight sizes
listed at the beginning of this section for which the number is not
yet known. For these values as well as for any argument out of range it
returns fail
.
NumberPerfectLibraryGroups(
size ) F
returns the number of perfect groups of size size which are available in the library of finite perfect groups. (The purpose of the function is to provide a simple way to formulate a loop over all library groups of a given size.)
SizeNumbersPerfectGroups(
factor1,
factor2, ... ) F
SizeNumbersPerfectGroups
returns a list of pairs, each entry consisting
of a group order and the number of those groups in the library of perfect
groups that contain the specified factors factor1, factor2, ...
among their composition factors.
Each argument must either be the name of a simple group or an integer which stands for the product of the sizes of one or more cyclic factors. (In fact, the function replaces all integers among the arguments by their product.)
The following text strings are accepted as simple group names.
A
n
or A(
n)
for the alternating groups An,
5 £ n £ 9, for example A5
or A(6)
.
L
n(
q)
or L(
n,
q)
for PSL(n,q), where
n Î {2,3} and q a prime power, ranging
U
n(
q)
or U(
n,
q)
for PSU(n,q), where
n Î {3,4} and q a prime power, ranging
Sp4(4)
or S(4,4)
for the symplectic group S(4,4),
Sz(8)
for the Suzuki group Sz(8),
M
n
or M(
n)
for the Mathieu groups M11,
M12, and M22, and
J
n
or J(
n)
for the Janko groups J1 and
J2.
Note that, for most of the groups, the preceding list offers two
different names in order to be consistent with the notation used in
HP89 as well as with the notation used in the
DisplayCompositionSeries
command of GAP. However, as the names are
compared as text strings, you are restricted to the above choice. Even
expressions like L2(2^5)
are not accepted.
As the use of the term PSU(n,q) is not unique in the literature, we mention that in this library it denotes the factor group of SU(n,q) by its centre, where SU(n,q) is the group of all n ×n unitary matrices with entries in GF(q2) and determinant 1.
The purpose of the function is to provide a simple way to formulate a loop over all library groups which contain certain composition factors.
DisplayInformationPerfectGroups(
size ) F
DisplayInformationPerfectGroups(
size,
n ) F
DisplayInformationPerfectGroups( [
size,
n] ) F
DisplayInformationPerfectGroups
displays some invariants of the n-th
group of order size from the perfect groups library.
If no value of n has been specified, the invariants will be displayed for all groups of size size available in the library. The information provided for G includes the following items:
[
size,
n ]
of G
in the form
size.
n
(the suffix .
n
will be suppressed
if, up to isomorphism, G is the only perfect group of order
size),
gap> DisplayInformationPerfectGroups( 30720, 3 ); #I Perfect group 30720: A5 ( 2^4 E N 2^1 E 2^4 ) A #I size = 2^11*3*5 orbit size = 240 #I Holt-Plesken class 1 (9,3) gap> DisplayInformationPerfectGroups( 30720, 6 ); #I Perfect group 30720: A5 ( 2^4 x 2^4 ) C N 2^1 #I centre = 2 size = 2^11*3*5 orbit size = 384 #I Holt-Plesken class 1 (9,6) gap> DisplayInformationPerfectGroups( Factorial( 8 ) / 2 ); #I Perfect group 20160.1: A5 x L3(2) 2^1 #I centre = 2 size = 2^6*3^2*5*7 orbit sizes = 5 + 16 #I Holt-Plesken class 31 (1,1) (occurs also in class 32) #I Perfect group 20160.2: A5 2^1 x L3(2) #I centre = 2 size = 2^6*3^2*5*7 orbit sizes = 7 + 24 #I Holt-Plesken class 31 (1,2) (occurs also in class 32) #I Perfect group 20160.3: ( A5 x L3(2) ) 2^1 #I centre = 2 size = 2^6*3^2*5*7 orbit size = 192 #I Holt-Plesken class 31 (1,3) #I Perfect group 20160.4: simple group A8 #I size = 2^6*3^2*5*7 orbit size = 8 #I Holt-Plesken class 26 (0,1) #I Perfect group 20160.5: simple group L3(4) #I size = 2^6*3^2*5*7 orbit size = 21 #I Holt-Plesken class 27 (0,1)
For any library group G, the library files do not only provide a
presentation, but, in addition, a list of one or more subgroups S1, ¼, Sr of G such that there is a faithful permutation
representation of G of degree åi = 1r [G:Si] on the set { Si g \mid 1 £ i £ r, g Î G } of the cosets of the Si.
This allows one to construct the groups as permutation groups. The
DisplayInformationPerfectGroups
function displays only the available
degree. The message
orbit size = 8
in the above example means that the available permutation representation is transitive and of degree 8, whereas the message
orbit sizes = 5 + 16means that a nontransitive permutation representation is available which acts on two orbits of size 5 and 16 respectively.
The notation used in the ``description'' of a group is explained in section 5.1.2 of HP89. We quote the respective page from there:
advanceleftskip bymanindent advancerightskip bymanindent Within a class Q # p, an isomorphism type of groups will be denoted by an ordered pair of integers (r,n), where r ³ 0 and n > 0. More precisely, the isomorphism types in Q # p of order pr \mid Q \mid will be denoted by (r,1), (r,2), (r,3), ¼ . Thus Q will always get the size number (0,1).
In addition to the symbol (r,n), the groups in Q # p will also be given a more descriptive name. The purpose of this is to provide a very rough idea of the structure of the group. The names are derived in the following manner. First of all, the isomorphism classes of irreducible FpQ-modules M with \mid Q \mid \mid M \mid £ 106, where Fp is the field of order p, are assigned symbols. These will either be simply px, where x is the dimension of the module, or, if there is more than one isomorphism class of irreducible modules having the same dimension, they will be denoted by px, px¢, etc. The one-dimensional module with trivial Q-action will therefore be denoted by p1. These symbols will be listed under the description of Q. The group name consists essentially of a list of the composition factors working from the top of the group downwards; hence it always starts with the name of Q itself. (This convention is the most convenient in our context, but it is different from that adopted in the ATLAS CCN85, for example, where composition factors are listed in the reverse order. For example, we denote a group isomorphic to SL(2,5) by A5 21 rather than 2 ·A5.)
Some other symbols are used in the name, in order to give some idea of the relationship between these composition factors, and splitting properties. We shall now list these additional symbols.
Brackets have their obvious meaning. Summarizing, we have:
Here are some examples.
We must stress that this notation does not always succeed in being precise or even unambiguous, and the reader is free to ignore it if it does not seem helpful.par
If such a group description has been given in the book for G (and, in
fact, this is the case for most of the library groups), it is displayed
by the DisplayInformationPerfectGroups
function. Otherwise the function
provides a less explicit description of the (in these cases unique)
Holt-Plesken class to which G belongs, together with a serial number if
this is necessary to make it unique.
[Top] [Previous] [Up] [Next] [Index]
GAP 4 manual