Goto Chapter: Top 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 Bib Ind
[Top of Book] [Contents] [Previous Chapter] [Next Chapter]

[MathJax on]

50 Group Libraries
50.1 Basic Groups
50.1-1 TrivialGroup
50.1-2 CyclicGroup
50.1-3 AbelianGroup
50.1-4 ElementaryAbelianGroup
50.1-5 FreeAbelianGroup
50.1-6 DihedralGroup
50.1-7 IsDihedralGroup
50.1-8 DicyclicGroup
50.1-9 IsDicyclicGroup
50.1-10 ExtraspecialGroup
50.1-11 AlternatingGroup
50.1-12 SymmetricGroup
50.1-13 MathieuGroup
50.1-14 SuzukiGroup
50.1-15 ReeGroup
50.1-16 Generator Names
50.2 Classical Groups
50.2-1 GeneralLinearGroup
50.2-2 SpecialLinearGroup
50.2-3 GeneralUnitaryGroup
50.2-4 SpecialUnitaryGroup
50.2-5 SymplecticGroup
50.2-6 GeneralOrthogonalGroup
50.2-7 SpecialOrthogonalGroup
50.2-8 Omega
50.2-9 GeneralSemilinearGroup
50.2-10 SpecialSemilinearGroup
50.2-11 ProjectiveGeneralLinearGroup
50.2-12 ProjectiveSpecialLinearGroup
50.2-13 ProjectiveGeneralUnitaryGroup
50.2-14 ProjectiveSpecialUnitaryGroup
50.2-15 ProjectiveSymplecticGroup
50.2-16 ProjectiveGeneralOrthogonalGroup
50.2-17 ProjectiveSpecialOrthogonalGroup
50.2-18 ProjectiveOmega
50.2-19 ProjectiveGeneralSemilinearGroup
50.2-20 ProjectiveSpecialSemilinearGroup
50.3 Conjugacy Classes in Classical Groups
50.3-1 NrConjugacyClassesGL
50.4 Constructors for Basic Groups
50.5 Selection Functions
50.6 Finite Perfect Groups
50.6-1 SizesPerfectGroups
50.6-2 PerfectGroup
50.6-3 PerfectIdentification
50.6-4 NumberPerfectGroups
50.6-5 SizeNumbersPerfectGroups
50.6-6 DisplayInformationPerfectGroups
50.6-7 More about the Perfect Groups Library
50.7 Irreducible Maximal Finite Integral Matrix Groups
50.7-1 ImfNumberQQClasses
50.7-2 DisplayImfInvariants
50.7-3 ImfInvariants
50.7-4 ImfMatrixGroup
50.7-5 IsomorphismPermGroup
50.7-6 IsomorphismPermGroupImfGroup

### 50 Group Libraries

When you start GAP, it already knows several groups. Currently GAP initially knows the following groups:

- some basic groups, such as cyclic groups or symmetric groups (see 50.1),

- classical matrix groups (see 50.2),

- a library of transitive permutation groups, provided by the TransGrp package (see transgrp: Transitive Permutation Groups),

- a library of groups of small order, provided by the SmallGrp package (see smallgrp: The Small Groups Library),

- a libary of finite perfect groups, (see 50.6),

- a library of primitive permutations groups, provided by the PrimGrp package (see primgrp: Primitive Permutation Groups),

- the irreducible solvable subgroups of GL(n,q) for n>1, q a prime power and q^n < 2^24, provided by the IRREDSOL package (see ???),

- the irreducible maximal finite integral matrix groups of dimension at most 31 (see 50.7),

- the crystallographic groups of dimension at most 4, provided by the CrystCat package (see ???).

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.

GAP might use data libraries that are available to speed up calculations, for example in using a classification to determine that groups must be isomorphic, based on agreement of properties; or to determine maximal subgroups or subgroup maximality. This will be indicated by an info message of level 2 in the info class `InfoPerformance`. If the calculation is to be independent of such data library use, for example if it is used to verify the data library, functions can be called with the option `NoPrecomputedData`, to turn these features off. Doing so might cause significantly longer calculations, or even failure of certain calculations.

#### 50.1 Basic Groups

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 13.2), for example `IsPermGroup` (43.1-1), `IsMatrixGroup` (44.1-1) or `IsPcGroup` (46.3-1), 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` (46.3-1) 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` (44.1-1) 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` (17.1-1).

In the case of matrix groups, also the internal representation of the group elements can be prescribed. For convenience, one can enter one of the filters in the list `ConstructingFiltersForMatrixGroupElements` (26.17-1), which then implies `IsMatrixGroup` (44.1-1).

##### 50.1-1 TrivialGroup

`‣ TrivialGroup`( [filter] ) | ( function )

constructs a trivial group in the category given by the filter filter. If filter is not given it defaults to `IsPcGroup` (46.3-1). For more information on possible values of filt see section (50.1).

    gap> TrivialGroup();
    <pc group of size 1 with 0 generators>
    gap> TrivialGroup( IsPermGroup );
    Group(())

##### 50.1-2 CyclicGroup

`‣ CyclicGroup`( [filt, ]n ) | ( function )

constructs the cyclic group of size n in the category given by the filter filt. If filt is not given it defaults to `IsPcGroup` (46.3-1), unless n equals `infinity` (18.2-1), in which case the default filter is switched to `IsFpGroup` (47.1-2). For more information on possible values of filt see section (50.1).

    gap> CyclicGroup(12);
    <pc group of size 12 with 3 generators>
    gap> CyclicGroup(infinity);
    <free group on the generators [ a ]>
    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 generator>
    gap> FieldOfMatrixGroup( matgrp1 );
    Rationals
    gap> matgrp2:= CyclicGroup( IsMatrixGroup, GF(2), 12 );
    <matrix group of size 12 with 1 generator>
    gap> FieldOfMatrixGroup( matgrp2 );
    GF(2)

##### 50.1-3 AbelianGroup

`‣ AbelianGroup`( [filt, ]ints ) | ( function )

constructs an abelian group in the category given by the filter filt which is of isomorphism type C_{ints[1]} × C_{ints[2]} × ... × C_{ints[n]}, where ints must be a list of non-negative integers or `infinity` (18.2-1); for the latter value or 0, C_{ints[i]} is taken as an infinite cyclic group, otherwise as a cyclic group of order ints[i]. If filt is not given it defaults to `IsPcGroup` (46.3-1), unless any 0 or `infinity` is contained in ints, in which the default filter is switched to `IsFpGroup` (47.1-2). The generators of the group returned are the elements corresponding to the factors C_{ints[i]} and hence the integers in ints. For more information on possible values of filt see section (50.1).

    gap> AbelianGroup([1,2,3]);
    <pc group of size 6 with 3 generators>
    gap> G:=AbelianGroup([0,3]);
    <fp group of size infinity on the generators [ f1, f2 ]>
    gap> AbelianInvariants(G);
    [ 0, 3 ]

##### 50.1-4 ElementaryAbelianGroup

`‣ ElementaryAbelianGroup`( [filt, ]n ) | ( function )

constructs the elementary abelian group of size n in the category given by the filter filt. If filt is not given it defaults to `IsPcGroup` (46.3-1). For more information on possible values of filt see section (50.1).

    gap> ElementaryAbelianGroup(8192);
    <pc group of size 8192 with 13 generators>

##### 50.1-5 FreeAbelianGroup

`‣ FreeAbelianGroup`( [filt, ]rank ) | ( function )

constructs the free abelian group of rank n in the category given by the filter filt. If filt is not given it defaults to `IsFpGroup` (47.1-2). For more information on possible values of filt see section (50.1).

    gap> FreeAbelianGroup(4);
    <fp group of size infinity on the generators [ f1, f2, f3, f4 ]>

##### 50.1-6 DihedralGroup

`‣ DihedralGroup`( [filt, ]n ) | ( function )

constructs the dihedral group of size n in the category given by the filter filt. If filt is not given it defaults to `IsPcGroup` (46.3-1), unless n equals `infinity` (18.2-1), in which case the default filter is switched to `IsFpGroup` (47.1-2). For more information on possible values of filt see section (50.1).

    gap> DihedralGroup(8);
    <pc group of size 8 with 3 generators>
    gap> DihedralGroup( IsPermGroup, 8 );
    Group([ (1,2,3,4), (2,4) ])
    gap> DihedralGroup(infinity);
    <fp group of size infinity on the generators [ r, s ]>

##### 50.1-7 IsDihedralGroup

`‣ IsDihedralGroup`( G ) | ( property )

`‣ DihedralGenerators`( G ) | ( attribute )

`IsDihedralGroup` indicates whether the group G is a dihedral group. If it is, methods may set the attribute `DihedralGenerators` to [t,s], where t and s are two elements such that G = ⟨ t, s | t^2 = s^n = 1, s^t = s^-1 ⟩.

##### 50.1-8 DicyclicGroup

`‣ DicyclicGroup`( [filt, [field, ]]n ) | ( function )

`‣ QuaternionGroup`( [filt, [field, ]]n ) | ( function )

`DicyclicGroup` constructs the dicyclic group of size n in the category given by the filter filt. Here, n must be a multiple of 4. The synonym `QuaternionGroup` for `DicyclicGroup` is provided for backward compatibility, but will print a warning if n is not a power of 2. If filt is not given it defaults to `IsPcGroup` (46.3-1). For more information on possible values of filt see section (50.1). Methods are also available for permutation and matrix groups (of minimal degree and minimal dimension in coprime characteristic).

    gap> DicyclicGroup(24);
    <pc group of size 24 with 4 generators>
    gap> g:=QuaternionGroup(IsMatrixGroup,CF(16),32);
    Group([ [ [ 0, 1 ], [ -1, 0 ] ], [ [ E(16), 0 ], [ 0, -E(16)^7 ] ] ])

##### 50.1-9 IsDicyclicGroup

`‣ IsDicyclicGroup`( G ) | ( property )

`‣ DicyclicGenerators`( G ) | ( attribute )

`‣ IsGeneralisedQuaternionGroup`( G ) | ( property )

`‣ GeneralisedQuaternionGenerators`( G ) | ( attribute )

`‣ IsQuaternionGroup`( G ) | ( property )

`‣ QuaternionGenerators`( G ) | ( attribute )

`IsDicyclicGroup` indicates whether the group G is a dicyclic group of order N = 4n. If it is, methods may set the attribute `DicyclicGenerators` to [ t, s ], where t and s are two elements such that G = ⟨ t, s | s^2n = 1, t^2 = s^n, s^t = s^-1 ⟩ holds.

`IsGeneralisedQuaternionGroup` indicates whether G is a generalized quaternion group, i. e., a dicyclic group of 2-power order. If it is, methods may set the attribute `GeneralisedQuaternionGenerators` to the value of `DicyclicGenerators` for G.

`IsQuaternionGroup` and `QuaternionGenerators` are provided for backwards compatibility with existing code.

##### 50.1-10 ExtraspecialGroup

`‣ ExtraspecialGroup`( [filt, ]order, exp ) | ( function )

Let order be of the form p^{2n+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 category given by the filter filt.

If p is odd then admissible values of exp are the exponent of the group (either p or p^2) or one of `'+'`, `"+"`, `'-'`, `"-"`. For p = 2, only the above plus or minus signs are admissible.

If filt is not given it defaults to `IsPcGroup` (46.3-1). For more information on possible values of filt see section (50.1).

    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>

##### 50.1-11 AlternatingGroup

`‣ AlternatingGroup`( [filt, ]deg ) | ( function )

`‣ AlternatingGroup`( [filt, ]dom ) | ( function )

constructs the alternating group of degree deg in the category given by the filter filt. If filt is not given it defaults to `IsPermGroup` (43.1-1). For more information on possible values of filt see section (50.1). 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 ] )

##### 50.1-12 SymmetricGroup

`‣ SymmetricGroup`( [filt, ]deg ) | ( function )

`‣ SymmetricGroup`( [filt, ]dom ) | ( function )

constructs the symmetric group of degree deg in the category given by the filter filt. If filt is not given it defaults to `IsPermGroup` (43.1-1). For more information on possible values of filt see section (50.1). 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 43.4.

##### 50.1-13 MathieuGroup

`‣ MathieuGroup`( [filt, ]degree ) | ( function )

constructs the Mathieu group of degree degree in the category given by the filter filt, where degree must be in the set { 9, 10, 11, 12, 21, 22, 23, 24 }. If filt is not given it defaults to `IsPermGroup` (43.1-1). For more information on possible values of filt see section (50.1).

    gap> MathieuGroup( 11 );
    Group([ (1,2,3,4,5,6,7,8,9,10,11), (3,7,11,8)(4,10,5,6) ])

##### 50.1-14 SuzukiGroup

`‣ SuzukiGroup`( [filt, ]q ) | ( function )

`‣ Sz`( [filt, ]q ) | ( function )

Constructs a group isomorphic to the Suzuki group Sz( q ) over the field with q elements, where q is a non-square power of 2.

If filt is not given it defaults to `IsMatrixGroup` (44.1-1), and the returned group is the Suzuki group itself. For more information on possible values of filt see section (50.1).

    gap> SuzukiGroup( 32 );
    Sz(32)

##### 50.1-15 ReeGroup

`‣ ReeGroup`( [filt, ]q ) | ( function )

`‣ Ree`( [filt, ]q ) | ( function )

Constructs a group isomorphic to the Ree group ^2G_2(q) where q = 3^{1+2m} for m a non-negative integer.

If filt is not given it defaults to `IsMatrixGroup` (44.1-1) and the generating matrices are based on [KLM01]. (No particular choice of a generating set is guaranteed.) For more information on possible values of filt see section (50.1).

    gap> ReeGroup( 27 );
    Ree(27)

##### 50.1-16 Generator Names

For groups created as finitely presented groups, including polycyclic groups, the generators are labelled, by default, with a letter and a number. It is possible to influence this naming with the option `generatorNames`, see Section 4.12-2. If this option holds a string, then the generators are named with this string and sequential numbers starting with `1`. If this option holds a list of sufficient length consisting of nonempty strings, then the generator names are taken from this list, in order.

    gap> GeneratorsOfGroup(AbelianGroup([5,7]));
    [ f1, f2 ]
    gap> GeneratorsOfGroup(AbelianGroup([5,7]:generatorNames:="a"));
    [ a1, a2 ]
    gap> GeneratorsOfGroup(AbelianGroup([5,7]:generatorNames:=["u","v","w"]));
    [ u, v ]
    gap> AsSSortedList(DihedralGroup(12:generatorNames:="a"));
    [ <identity> of ..., a1, a2, a3, a1*a2, a1*a3, a2*a3, a3^2, a1*a2*a3,
      a1*a3^2, a2*a3^2, a1*a2*a3^2 ]
    gap> AsSSortedList(DihedralGroup(12:generatorNames:=["a","b","c"]));
    [ <identity> of ..., a, b, c, a*b, a*c, b*c, c^2, a*b*c, a*c^2, b*c^2,
      a*b*c^2 ]

#### 50.2 Classical Groups

The following functions return classical groups.

Generators

- For the linear, symplectic, and unitary groups (the latter in dimension at least 3), the generators are taken from [Tay87].

- For the unitary groups in dimension 2, the isomorphism of SU(2,q) and SL(2,q) is used, see for example [Hup67].

- The generators of the general and special orthogonal groups are taken from [IE94] and [KL90], except that the generators of the groups in odd dimension in even characteristic are constructed via the isomorphism to a symplectic group, see for example [Car72].

- The generators of the groups Ω^ϵ(d, q) are taken from [RT98], except that in odd dimension and even characteristic, the generators of SO(d, q) are taken for Ω(d, q). Note that the generators claimed in [RT98, Section 4.5 and 4.6] do not describe orthogonal groups, one would have to transpose these matrices in order to get groups that respect the required forms. The matrices from [RT98] generate groups of the right isomorphism types but not orthogonal groups, except in the case (d,q) = (5,2), where the matrices from [RT98] generate the simple group S_4(2)' and not the group S_4(2).

- The generators for the semilinear groups are constructed from the generators of the corresponding linear groups plus one additional generator that describes the action of the group of field automorphisms; for prime integers p and positive integers f, this yields the matrix groups GammaL(d, p^f) and SigmaL(d, p^f) as groups of d f × df matrices over the field with p elements.

- The generators for the conformal symplectic groups are taken from [Tay21].

Invariant forms

- For symplectic and orthogonal matrix groups returned by the functions described below, the invariant bilinear form is stored as the value of the attribute `InvariantBilinearForm` (44.5-1).

- The invariant sesquilinear form defining the unitary groups is stored as the value of the attribute `InvariantSesquilinearForm` (44.5-5)).

- The defining quadratic form of orthogonal groups is stored as the value of the attribute `InvariantQuadraticForm` (44.5-7).

- The bilinear form that is invariant up to scalars under the conformal symplectic group is stored as the value of the attribute `InvariantBilinearFormUpToScalars` (44.5-3).

Note that due to the different sources for the generators, the invariant forms for the groups Ω(e,d,q) are in general different from the forms for SO(e,d,q) and GO(e,d,q). If version at least 1.2.6 of the Forms package is loaded then compatible groups can be created by specifying the desired form, see the sections below.

##### 50.2-1 GeneralLinearGroup

`‣ GeneralLinearGroup`( [filt, ]d, R ) | ( function )

`‣ GL`( [filt, ]d, R ) | ( function )

`‣ GeneralLinearGroup`( [filt, ]d, q ) | ( function )

`‣ GL`( [filt, ]d, q ) | ( function )

The first two forms construct a group isomorphic to the general linear group GL( d, R ) of all d × d matrices that are invertible over the ring R, in the category given by the filter filt.

The third and the fourth form construct the general linear group over the finite field with q elements.

If filt is not given it defaults to `IsMatrixGroup` (44.1-1), and the returned group is the general linear group as a matrix group in its natural action (see also `IsNaturalGL` (44.4-2), `IsNaturalGLnZ` (44.6-4)).

Currently supported rings R are finite fields, the ring `Integers` (14.1-1), and residue class rings `Integers mod m`, see 14.5.

    gap> GL(4,3);
    GL(4,3)
    gap> GL(2,Integers);
    GL(2,Integers)
    gap> GL(3,Integers mod 12);
    GL(3,Z/12Z)

Using the `OnLines` (41.2-12) 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

If you are interested only in the projective group as a permutation group and not in the correspondence between its moved points and the points in the projective space, you can also use `PGL` (50.2-11).

##### 50.2-2 SpecialLinearGroup

`‣ SpecialLinearGroup`( [filt, ]d, R ) | ( function )

`‣ SL`( [filt, ]d, R ) | ( function )

`‣ SpecialLinearGroup`( [filt, ]d, q ) | ( function )

`‣ SL`( [filt, ]d, q ) | ( function )

The first two forms construct a group isomorphic to the special linear group SL( d, R ) of all those d × d matrices over the ring R whose determinant is the identity of R, in the category given by the filter filt.

The third and the fourth form construct the special linear group over the finite field with q elements.

If filt is not given it defaults to `IsMatrixGroup` (44.1-1), and the returned group is the special linear group as a matrix group in its natural action (see also `IsNaturalSL` (44.4-4), `IsNaturalSLnZ` (44.6-5)).

Currently supported rings R are finite fields, the ring `Integers` (14), and residue class rings `Integers mod m`, see 14.5.

    gap> SpecialLinearGroup(2,2);
    SL(2,2)
    gap> SL(3,Integers);
    SL(3,Integers)
    gap> SL(4,Integers mod 4);
    SL(4,Z/4Z)

##### 50.2-3 GeneralUnitaryGroup

`‣ GeneralUnitaryGroup`( [filt, ]d, q[, form] ) | ( function )

`‣ GeneralUnitaryGroup`( [filt, ]form ) | ( function )

`‣ GU`( [filt, ]d, q[, form] ) | ( function )

`‣ GU`( [filt, ]form ) | ( function )

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 category given by the filter filt.

If filt is not given it defaults to `IsMatrixGroup` (44.1-1), and the returned group is the general unitary group itself.

If version at least 1.2.6 of the Forms package is loaded then the desired sesquilinear form can be specified via form, which can be either a matrix or a form object in `IsHermitianForm` (???) or a group with stored `InvariantSesquilinearForm` (44.5-5) value (and then this form is taken).

A given form determines d, and also q except if form is a matrix that does not store its `BaseDomain` (26.3-1) value. These parameters can be entered, and an error is signalled if they do not fit to the given form.

If form is not given then a default is chosen as described in the introduction to Section 50.2.

    gap> GeneralUnitaryGroup( 3, 5 );
    GU(3,5)
    gap> GeneralUnitaryGroup( IsPermGroup, 3, 5 );
    Perm_GU(3,5)

##### 50.2-4 SpecialUnitaryGroup

`‣ SpecialUnitaryGroup`( [filt, ]d, q[, form] ) | ( function )

`‣ SpecialUnitaryGroup`( [filt, ]form ) | ( function )

`‣ SU`( [filt, ]d, q[, form] ) | ( function )

`‣ SU`( [filt, ]form ) | ( function )

constructs a group isomorphic to the special unitary group SU( 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 category given by the filter filt.

If filt is not given it defaults to `IsMatrixGroup` (44.1-1), and the returned group is the special unitary group itself.

If version at least 1.2.6 of the Forms package is loaded then the desired sesquilinear form can be specified via form, which can be either a matrix or a form object in `IsHermitianForm` (???) or a group with stored `InvariantSesquilinearForm` (44.5-5) value (and then this form is taken).

A given form determines d, and also q except if form is a matrix that does not store its `BaseDomain` (26.3-1) value. These parameters can be entered, and an error is signalled if they do not fit to the given form.

If form is not given then a default is chosen as described in the introduction to Section 50.2.

    gap> SpecialUnitaryGroup( 3, 5 );
    SU(3,5)
    gap> SpecialUnitaryGroup( IsPermGroup, 3, 5 );
    Perm_SU(3,5)

##### 50.2-5 SymplecticGroup

`‣ SymplecticGroup`( [filt, ]d, R[, form] ) | ( function )

`‣ SymplecticGroup`( [filt, ]d, q[, form] ) | ( function )

`‣ SymplecticGroup`( [filt, ]form ) | ( function )

`‣ Sp`( [filt, ]d, R[, form] ) | ( function )

`‣ Sp`( [filt, ]d, q[, form] ) | ( function )

`‣ Sp`( [filt, ]form ) | ( function )

`‣ SP`( [filt, ]d, R[, form] ) | ( function )

`‣ SP`( [filt, ]d, q[, form] ) | ( function )

`‣ SP`( [filt, ]form ) | ( function )

constructs a group isomorphic to the symplectic group Sp( d, R ) of those d × d matrices over the ring R or the field with q elements, respectively, that respect a fixed nondegenerate symplectic form, in the category given by the filter filt.

If filt is not given it defaults to `IsMatrixGroup` (44.1-1), and the returned group is the symplectic group itself. Other supported values for filt are `IsPermGroup` (43.1-1) (in this case, the argument form is not supported) and the entries of `ConstructingFiltersForMatrixGroupElements` (26.17-1).

At the moment finite fields or residue class rings `Integers mod q`, with q an odd prime power, are supported.

If version at least 1.2.6 of the Forms package is loaded and the arguments describe a matrix group over a finite field then the desired bilinear form can be specified via form, which can be either a matrix or a form object in `IsBilinearForm` (???) or a group with stored `InvariantBilinearForm` (44.5-1) value (and then this form is taken).

A given form determines d, and also R except if form is a matrix that does not store its `BaseDomain` (26.3-1) value. These parameters can be entered, and an error is signalled if they do not fit to the given form.

If form is not given then a default is chosen as described in the introduction to Section 50.2.

    gap> SymplecticGroup( 4, 2 );
    Sp(4,2)
    gap> g:=SymplecticGroup(6,Integers mod 9);
    Sp(6,Z/9Z)
    gap> Size(g);
    95928796265538862080
    gap> SymplecticGroup( IsPermGroup, 4, 2 );
    Perm_Sp(4,2)

##### 50.2-6 GeneralOrthogonalGroup

`‣ GeneralOrthogonalGroup`( [filt, ][e, ]d, q[, form] ) | ( function )

`‣ GeneralOrthogonalGroup`( [filt, ]form ) | ( function )

`‣ GO`( [filt, ][e, ]d, q[, form] ) | ( function )

`‣ GO`( [filt, ]form ) | ( function )

constructs a group isomorphic to the general orthogonal group GO( e, d, q ) of those d × d matrices over the field with q elements that respect a non-singular quadratic form (see `InvariantQuadraticForm` (44.5-7)) specified by e, in the category given by the filter filt.

The value of e must be 0 for odd d (and can optionally be omitted in this case), respectively one of 1 or -1 for even d. If filt is not given it defaults to `IsMatrixGroup` (44.1-1), and the returned group is the general orthogonal group itself.

If version at least 1.2.6 of the Forms package is loaded then the desired quadratic form can be specified via form, which can be either a matrix or a form object in `IsQuadraticForm` (???) or a group with stored `InvariantQuadraticForm` (44.5-7) value (and then this form is taken).

A given form determines e and d, and also q except if form is a matrix that does not store its `BaseDomain` (26.3-1) value. These parameters can be entered, and an error is signalled if they do not fit to the given form.

If form is not given then a default is chosen as described in the introduction to Section 50.2.

Note that in [KL90], GO is defined as the stabilizer ∆(V, F, κ) of the quadratic form, up to scalars, whereas our GO is called I(V, F, κ) there.

    gap> GeneralOrthogonalGroup( 5, 3 );
    GO(0,5,3)
    gap> GeneralOrthogonalGroup( -1, 8, 2 );
    GO(-1,8,2)
    gap> GeneralOrthogonalGroup( IsPermGroup, -1, 8, 2 );
    Perm_GO(-1,8,2)

##### 50.2-7 SpecialOrthogonalGroup

`‣ SpecialOrthogonalGroup`( [filt, ][e, ]d, q[, form] ) | ( function )

`‣ SpecialOrthogonalGroup`( [filt, ]form ) | ( function )

`‣ SO`( [filt, ][e, ]d, q[, form] ) | ( function )

`‣ SO`( [filt, ]form ) | ( function )

constructs a group isomorphic to the special orthogonal group SO( e, d, q ), which is the subgroup of all those matrices in the general orthogonal group (see `GeneralOrthogonalGroup` (50.2-6)) that have determinant one, in the category given by the filter filt. (The index of SO( e, d, q ) in GO( e, d, q ) is 2 if q is odd, and 1 if q is even.) Also interesting is the group Omega( e, d, q ), see `Omega` (50.2-8), which is of index 2 in SO( e, d, q ), except in the case d = 1.

If filt is not given it defaults to `IsMatrixGroup` (44.1-1), and the returned group is the special orthogonal group itself.

If version at least 1.2.6 of the Forms package is loaded then the desired quadratic form can be specified via form, which can be either a matrix or a form object in `IsQuadraticForm` (???) or a group with stored `InvariantQuadraticForm` (44.5-7) value (and then this form is taken).

A given form determines e and d, and also q except if form is a matrix that does not store its `BaseDomain` (26.3-1) value. These parameters can be entered, and an error is signalled if they do not fit to the given form.

If form is not given then a default is chosen as described in the introduction to Section 50.2.

    gap> SpecialOrthogonalGroup( 5, 3 );
    SO(0,5,3)
    gap> SpecialOrthogonalGroup( -1, 8, 2 );  # here SO and GO coincide
    GO(-1,8,2)
    gap> SpecialOrthogonalGroup( IsPermGroup, 5, 3 );
    Perm_SO(0,5,3)

##### 50.2-8 Omega

`‣ Omega`( [filt, ][e, ]d, q[, form] ) | ( operation )

`‣ Omega`( [filt, ]form ) | ( operation )

constructs a group isomorphic to the group Ω( e, d, q ) of those d × d matrices over the field with q elements that respect a non-singular quadratic form (see `InvariantQuadraticForm` (44.5-7)) specified by e, and that have square spinor norm in odd characteristic or Dickson invariant 0 in even characteristic, respectively, in the category given by the filter filt.

For odd q and d ≥ 2, this group has always index two in the corresponding special orthogonal group, which will be conjugate in GL(d,q) to the group returned by SO( e, d, q ), see `SpecialOrthogonalGroup` (50.2-7), but may fix a different form (see 50.2).

The value of e must be 0 for odd d (and can optionally be omitted in this case), respectively one of 1 or -1 for even d. If filt is not given it defaults to `IsMatrixGroup` (44.1-1), and the returned group is the group Ω( e, d, q ) itself.

If version at least 1.2.6 of the Forms package is loaded then the desired quadratic form can be specified via form, which can be either a matrix or a form object in `IsQuadraticForm` (???) or a group with stored `InvariantQuadraticForm` (44.5-7) value (and then this form is taken).

A given form determines e and d, and also q except if form is a matrix that does not store its `BaseDomain` (26.3-1) value. These parameters can be entered, and an error is signalled if they do not fit to the given form.

If form is not given then a default is chosen as described in the introduction to Section 50.2.

    gap> g:= Omega( 3, 5 );  StructureDescription( g );
    Omega(0,3,5)
    "A5"
    gap> g:= Omega( 1, 4, 4 );  StructureDescription( g );
    Omega(+1,4,4)
    "A5 x A5"
    gap> g:= Omega( -1, 4, 3 );  StructureDescription( g );
    Omega(-1,4,3)
    "A6"
    gap> g:= Omega( IsPermGroup, 1, 6, 2 );  StructureDescription( g );
    Perm_Omega(+1,6,2)
    "A8"
    gap> IsSubset( GO( 3, 5 ), Omega( 3, 5 ) );  # different forms!
    false

##### 50.2-9 GeneralSemilinearGroup

`‣ GeneralSemilinearGroup`( [filt, ]d, q ) | ( function )

`‣ GammaL`( [filt, ]d, q ) | ( function )

`GeneralSemilinearGroup` returns a group isomorphic to the general semilinear group ΓL( d, q ) of semilinear mappings of the vector space `GF(` q`)^`d.

If filt is not given it defaults to `IsMatrixGroup` (44.1-1), and the returned group consists of matrices of dimension d f over the field with p elements, where q = p^f, for a prime integer p.

##### 50.2-10 SpecialSemilinearGroup

`‣ SpecialSemilinearGroup`( [filt, ]d, q ) | ( function )

`‣ SigmaL`( [filt, ]d, q ) | ( function )

`SpecialSemilinearGroup` returns a group isomorphic to the special semilinear group ΣL( d, q ) of those semilinear mappings of the vector space `GF(` q`)^`d (see `GeneralSemilinearGroup` (50.2-9)) whose linear part has determinant one.

If filt is not given it defaults to `IsMatrixGroup` (44.1-1), and the returned group consists of matrices of dimension d f over the field with p elements, where q = p^f, for a prime integer p.

##### 50.2-11 ProjectiveGeneralLinearGroup

`‣ ProjectiveGeneralLinearGroup`( [filt, ]d, q ) | ( function )

`‣ PGL`( [filt, ]d, q ) | ( function )

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 category given by the filter filt.

If filt is not given it defaults to `IsPermGroup` (43.1-1), and the returned group is the action on lines of the underlying vector space.

##### 50.2-12 ProjectiveSpecialLinearGroup

`‣ ProjectiveSpecialLinearGroup`( [filt, ]d, q ) | ( function )

`‣ PSL`( [filt, ]d, q ) | ( function )

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 category given by the filter filt.

If filt is not given it defaults to `IsPermGroup` (43.1-1), and the returned group is the action on lines of the underlying vector space.

##### 50.2-13 ProjectiveGeneralUnitaryGroup

`‣ ProjectiveGeneralUnitaryGroup`( [filt, ]d, q ) | ( function )

`‣ PGU`( [filt, ]d, q ) | ( function )

constructs a group isomorphic to the projective general unitary group PGU( d, q ) of those d × d matrices over the field with q^2 elements that respect a fixed nondegenerate sesquilinear form, modulo the centre, in the category given by the filter filt.

If filt is not given it defaults to `IsPermGroup` (43.1-1), and the returned group is the action on lines of the underlying vector space.

##### 50.2-14 ProjectiveSpecialUnitaryGroup

`‣ ProjectiveSpecialUnitaryGroup`( [filt, ]d, q ) | ( function )

`‣ PSU`( [filt, ]d, q ) | ( function )

constructs a group isomorphic to the projective special unitary group PSU( d, q ) of those d × d matrices over the field with q^2 elements that respect a fixed nondegenerate sesquilinear form and have determinant 1, modulo the centre, in the category given by the filter filt.

If filt is not given it defaults to `IsPermGroup` (43.1-1), and the returned group is the action on lines of the underlying vector space.

##### 50.2-15 ProjectiveSymplecticGroup

`‣ ProjectiveSymplecticGroup`( [filt, ]d, q ) | ( function )

`‣ PSP`( [filt, ]d, q ) | ( function )

`‣ PSp`( [filt, ]d, q ) | ( function )

constructs a group isomorphic to the projective symplectic group PSp(d,q) of those d × d matrices over the field with q elements that respect a fixed nondegenerate symplectic form, modulo the centre, in the category given by the filter filt.

If filt is not given it defaults to `IsPermGroup` (43.1-1), and the returned group is the action on lines of the underlying vector space.

##### 50.2-16 ProjectiveGeneralOrthogonalGroup

`‣ ProjectiveGeneralOrthogonalGroup`( [filt, ][e, ]d, q ) | ( function )

`‣ PGO`( [filt, ][e, ]d, q ) | ( function )

constructs a group isomorphic to the projective group PGO( e, d, q ) of GO( e, d, q ), modulo the centre (see `GeneralOrthogonalGroup` (50.2-6)), in the category given by the filter filt.

If filt is not given it defaults to `IsPermGroup` (43.1-1), and the returned group is the action on lines of the underlying vector space.

##### 50.2-17 ProjectiveSpecialOrthogonalGroup

`‣ ProjectiveSpecialOrthogonalGroup`( [filt, ][e, ]d, q ) | ( function )

`‣ PSO`( [filt, ][e, ]d, q ) | ( function )

constructs a group isomorphic to the projective group PSO( e, d, q ) of SO( e, d, q ), modulo the centre (see `SpecialOrthogonalGroup` (50.2-7)), in the category given by the filter filt.

If filt is not given it defaults to `IsPermGroup` (43.1-1), and the returned group is the action on lines of the underlying vector space.

##### 50.2-18 ProjectiveOmega

`‣ ProjectiveOmega`( [filt, ][e, ]d, q ) | ( function )

`‣ POmega`( [filt, ][e, ]d, q ) | ( function )

constructs a group isomorphic to the projective group PΩ( e, d, q ) of Ω( e, d, q ), modulo the centre (see `Omega` (50.2-8)), in the category given by the filter filt.

If filt is not given it defaults to `IsPermGroup` (43.1-1), and the returned group is the action on lines of the underlying vector space.

##### 50.2-19 ProjectiveGeneralSemilinearGroup

`‣ ProjectiveGeneralSemilinearGroup`( [filt, ]d, q ) | ( function )

`‣ PGammaL`( [filt, ]d, q ) | ( function )

`ProjectiveGeneralSemilinearGroup` returns a group isomorphic to the factor group of the general semilinear group `GammaL(` d, q `)` modulo the center of its normal subgroup `GL(` d, q `)`.

If filt is not given it defaults to `IsPermGroup` (43.1-1), and the returned group is the action on lines of the underlying vector space `GF(`q`)^`d.

##### 50.2-20 ProjectiveSpecialSemilinearGroup

`‣ ProjectiveSpecialSemilinearGroup`( [filt, ]d, q ) | ( function )

`‣ PSigmaL`( [filt, ]d, q ) | ( function )

`ProjectiveSpecialSemilinearGroup` returns a group isomorphic to the factor group of the special semilinear group `SigmaL(` d, q `)` modulo the center of its normal subgroup `SL(` d, q `)`.

If filt is not given it defaults to `IsPermGroup` (43.1-1), and the returned group is the action on lines of the underlying vector space `GF(`q`)^`d.

#### 50.3 Conjugacy Classes in Classical Groups

For general and special linear groups (see `GeneralLinearGroup` (50.2-1) and `SpecialLinearGroup` (50.2-2)) GAP has an efficient method to generate representatives of the conjugacy classes. This uses results from linear algebra on normal forms of matrices. If you know how to do this for other types of classical groups, please, tell us.

    gap> g := SL(4,9);
    SL(4,9)
    gap> NrConjugacyClasses(g);
    861
    gap> cl := ConjugacyClasses(g);;
    gap> Length(cl);
    861

##### 50.3-1 NrConjugacyClassesGL

`‣ NrConjugacyClassesGL`( n, q ) | ( function )

`‣ NrConjugacyClassesGU`( n, q ) | ( function )

`‣ NrConjugacyClassesSL`( n, q ) | ( function )

`‣ NrConjugacyClassesSU`( n, q ) | ( function )

`‣ NrConjugacyClassesPGL`( n, q ) | ( function )

`‣ NrConjugacyClassesPGU`( n, q ) | ( function )

`‣ NrConjugacyClassesPSL`( n, q ) | ( function )

`‣ NrConjugacyClassesPSU`( n, q ) | ( function )

`‣ NrConjugacyClassesSLIsogeneous`( n, q, f ) | ( function )

`‣ NrConjugacyClassesSUIsogeneous`( n, q, f ) | ( function )

The first of these functions compute for given positive integer n and prime power q the number of conjugacy classes in the classical groups GL( n, q ), GU( n, q ), SL( n, q ), SU( n, q ), PGL( n, q ), PGU( n, q ), PSL( n, q ), PSL( n, q ), respectively. (See also `ConjugacyClasses` (39.10-2) and Section 50.2.)

For each divisor f of n there is a group of Lie type with the same order as SL( n, q ), such that its derived subgroup modulo its center is isomorphic to PSL( n, q ). The various such groups with fixed n and q are called isogeneous. (Depending on congruence conditions on q and n several of these groups may actually be isomorphic.) The function `NrConjugacyClassesSLIsogeneous` computes the number of conjugacy classes in this group. The extreme cases f = 1 and f = n lead to the groups SL( n, q ) and PGL( n, q ), respectively.

The function `NrConjugacyClassesSUIsogeneous` is the analogous one for the corresponding unitary groups.

The formulae for the number of conjugacy classes are taken from [Mac81].

    gap> NrConjugacyClassesGL(24,27);
    22528399544939174406067288580609952
    gap> NrConjugacyClassesPSU(19,17);
    15052300411163848367708
    gap> NrConjugacyClasses(SL(16,16));
    1229782938228219920

#### 50.4 Constructors for Basic Groups

All functions described in the previous sections 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` (50.1-2) calls the constructor

`CyclicGroupCons( cat, n )`

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 `InstallMethod` (78.3-1) for the meaning of the arguments.

    InstallMethod( CyclicGroupCons,
        "regular perm group",
        true,
        [ IsPermGroup and IsRegularProp and IsFinite, IsInt and IsPosRat ], 0,
        function( filter, n )

        ...

        end );

#### 50.5 Selection Functions

`AllLibraryGroups( fun1, val1, ... )`

For a number of the group libraries two selection functions are provided. Each `AllLibraryGroups` selection function permits one to select all groups from the library Library that have a given set of properties. Currently, the library selection functions provided, of this type, are `AllSmallGroups` (smallgrp: AllSmallGroups), `AllIrreducibleSolvableGroups` (primgrp: AllIrreducibleSolvableGroups), `AllTransitiveGroups` (transgrp: AllTransitiveGroups), and `AllPrimitiveGroups` (primgrp: AllPrimitiveGroups). Corresponding to each of these there is a `OneLibraryGroup` function (see below) which returns at most one group.

These functions take an arbitrary number of pairs (but at least one pair) 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 the function `AllSmallGroups` (smallgrp: AllSmallGroups) the first such function must be `Size` (30.4-6), and, unlike the other library selection functions, it supports an alternative syntax where `Size` (30.4-6) is omitted (see `AllSmallGroups` (smallgrp: AllSmallGroups)). Also, see `AllIrreducibleSolvableGroups` (primgrp: AllIrreducibleSolvableGroups), for details pertaining to this function.

For an example, let us consider the selection function for the library of transitive groups (also see transgrp: Transitive Permutation Groups). The command

    gap> AllTransitiveGroups(NrMovedPoints,[10..15],
    >                        Size,         [1..100],
    >                        IsAbelian,    false    );

returns a list of all transitive groups with degree between 10 and 15 and size less than 100 that are not abelian.

Thus `AllTransitiveGroups` behaves as if it was implemented by a function similar to the one defined below, where `TransitiveGroupsList` is a list of all transitive groups. (Note that in the definition below we assume for simplicity that `AllTransitiveGroups` 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.)

    AllTransitiveGroups := function( fun1, val1, fun2, val2 )
    local    groups, g, i;
      groups := [];
      for i  in [ 1 .. Length( TransitiveGroupsList ) ] do
        g := TransitiveGroupsList[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.

`OneLibraryGroup( fun1, val1, ... )`

For each `AllLibraryGroups` function (see above) there is a corresponding function `OneLibraryGroup` on exactly the same arguments, i.e., there are `OneSmallGroup` (smallgrp: OneSmallGroup), `OneIrreducibleSolvableGroup` (primgrp: OneIrreducibleSolvableGroup), `OneTransitiveGroup` (transgrp: OneTransitiveGroup), and `OnePrimitiveGroup` (primgrp: OnePrimitiveGroup). Each function simply returns one group in the library that has the prescribed properties, instead of all such groups. It returns `fail` if no such group exists in the library.

#### 50.6 Finite Perfect Groups

The GAP library of finite perfect groups provides, up to isomorphism, a list of all perfect groups whose sizes are less than 2⋅ 10^6. The groups of orders up to 10^6 have been enumerated by Derek F. Holt and Wilhelm Plesken and published in their book Perfect Groups [HP89]. For orders n = 86016, 368640, or 737280 this work only counted the groups (but did not explicitly list them), the groups of orders n = 61440, 122880, 172032, 245760, 344064, 491520, 688128, or 983040 were omitted.

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 of these has been brought into GAP format by Volkmar Felsch.

Several additional groups omitted from the book Perfect Groups have also been included. Two groups -- one of order 450000 with a factor group of type A_6 and the one of order 962280 -- were found by Jack Schmidt in 2005. Two groups of order 243000 and one each of orders 729000, 871200, 878460 were found in 2020 by Alexander Hulpke.

The perfect groups of size less than 2⋅ 10^6 which had not been classified in the work of Holt and Plesken have been enumerated by Alexander Hulpke. They are stored directly and provide less construction information in their names.

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.

##### 50.6-1 SizesPerfectGroups

`‣ SizesPerfectGroups`( ) | ( function )

This is the ordered list of all numbers up to 2⋅ 10^6 that occur as sizes of perfect groups. One can iterate over part of the perfect groups library with:

    gap> for n in Intersection([100..500],SizesPerfectGroups()) do
    >      for k in [1..NrPerfectGroups(n)] do
    >        pg := PerfectGroup(n,k);
    >      od;
    >    od;

##### 50.6-2 PerfectGroup

`‣ PerfectGroup`( [filt, ]size[, n] ) | ( function )

`‣ PerfectGroup`( [filt, ]sizenumberpair ) | ( function )

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` (43.1-1) and `IsSubgroupFpGroup` (47.1-1). In the latter case, the generators and relators used coincide with those given in [HP89]. The default filter is `IsPermGroup` (43.1-1).

    gap> G := PerfectGroup(IsPermGroup,6048,1);
    U3(3)
    gap> G:=PerfectGroup(IsPermGroup,823080,2);
    A5 2^1 19^2 C 19^1
    gap> NrMovedPoints(G);
    6859
    gap> G:=PerfectGroup(1866240,12);
    PG1866240.12
    gap> NrMovedPoints(G);
    270

##### 50.6-3 PerfectIdentification

`‣ PerfectIdentification`( G ) | ( attribute )

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.

##### 50.6-4 NumberPerfectGroups

`‣ NumberPerfectGroups`( size ) | ( function )

`‣ NrPerfectGroups`( size ) | ( function )

`‣ NumberPerfectLibraryGroups`( size ) | ( function )

`‣ NrPerfectLibraryGroups`( size ) | ( function )

returns the number of non-isomorphic perfect groups of size size for each positive integer size up to 2⋅10^6. Additionally, for odd size an answer is returned (odd order groups are solvable). For any other argument out of range it returns `fail`. NrPerfectGroups is a synonym for `NumberPerfectGroups`. Moreover NumberPerfectLibraryGroups (and its synonym NrPerfectLibraryGroups) exist for historical reasons, and return 0 instead of fail for arguments outside the library scope.

##### 50.6-5 SizeNumbersPerfectGroups

`‣ SizeNumbersPerfectGroups`( factor1, factor2, ... ) | ( function )

`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 nonabelian 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.

- `An` or `A(n)` for the alternating groups A_n, 5 ≤ n ≤ 9, for example `A5` or `A(6)`.

- `Ln(q)` or `L(n,q)` for PSL(n,q), where n ∈ { 2, 3 } and q a prime power, ranging

  - for n = 2 from 4 to 125

  - for n = 3 from 2 to 5

- `Un(q)` or `U(n,q)` for PSU(n,q), where n ∈ { 3, 4 } and q a prime power, ranging

  - for n = 3 from 3 to 5

  - for n = 4 from 2 to 2

- `Sp4(4)` or `S(4,4)` for the symplectic group Sp(4,4),

- `Sz(8)` for the Suzuki group Sz(8),

- `Mn` or `M(n)` for the Mathieu groups M_11, M_12, and M_22, and

- `Jn` or `J(n)` for the Janko groups J_1 and J_2.

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` (39.17-6) 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(q^2) 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.

##### 50.6-6 DisplayInformationPerfectGroups

`‣ DisplayInformationPerfectGroups`( size[, n] ) | ( function )

`‣ DisplayInformationPerfectGroups`( sizenumberpair ) | ( function )

`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.

Alternatively, also a list of length two may be entered as the only argument, with entries size and n.

The information provided for G includes the following items:

- a headline containing the size number `[ 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),

- a message if G is simple or quasisimple, i.e., if the factor group of G by its centre is simple,

- the description of the structure of G as it is given by Holt and Plesken in [HP89] (see below),

- the size of the centre of G (suppressed, if G is simple),

- the prime decomposition of the size of G,

- orbit sizes for a faithful permutation representation of G which is provided by the library (see below),

- a reference to each occurrence of G in the tables of section 5.3 of [HP89]. Each of these references consists of a class number and an internal number (i,j) under which G is listed in that class. For some groups, there is more than one reference because these groups belong to more than one of the classes in the book.

    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)

##### 50.6-7 More about the Perfect Groups Library

For any library group G, the library files do not only provide a presentation, but, in addition, a list of one or more subgroups S_1, ..., S_r of G such that there is a faithful permutation representation of G of degree ∑_{i = 1}^r [G:S_i] on the set { S_i g ∣ 1 ≤ i ≤ r, g ∈ G } of the cosets of the S_i. This allows one to construct the groups as permutation groups. The function `DisplayInformationPerfectGroups` (50.6-6) 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 + 16

means 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:

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 p^r |Q| 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 F_pQ-modules M with |Q|.|M| ≤ 10^6, where F_p is the field of order p, are assigned symbols. These will either be simply p^x, 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 byp^x, p^{x'}, etc. The one-dimensional module with trivial Q-action will therefore be denoted by p^1. 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 [CCN+85], for example, where composition factors are listed in the reverse order. For example, we denote a group isomorphic to SL(2,5) by A_5 2^1 rather than 2.A_5.)

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.

×

  between two factors denotes a direct product of F_pQ-modules or groups.

C

  (for commutator) between two factors means that the second lies in the commutator subgroup of the first. Similarly, a segment of the form (f_1 × f_2) C f_3 would mean that the factors f_1 and f_2 commute modulo f_3 and f_3 lies in [f_1,f_2].

A

  (for abelian) between two factors indicates that the second is in the pth power (but not the commutator subgroup) of the first. A may also follow the factors, if bracketed.

E

  (for elementary abelian) between two factors indicates that together they generate an elementary abelian group (modulo subsequent factors), but that the resulting F_p Q-module extension does not split.

N

  (for nonsplit) before a factor indicates that Q (or possibly its covering group) splits down as far at this factor but not over the factor itself. So Q f_1 N f_2 means that the normal subgroup f_1 f_2 of the group has no complement but, modulo f_2, f_1, does have a complement.

Brackets have their obvious meaning. Summarizing, we have:

×

  = direct product;

C

  = commutator subgroup;

A

  = abelian;

E

  = elementary abelian; and

N

  = nonsplit.

Here are some examples.

(i)

  A_5 (2^4 E 2^1 E 2^4) A means that the pairs 2^4 E 2^1 and 2^1 E 2^4 are both elementary abelian of exponent 4.

(ii)

  A_5 (2^4 E 2^1 A) C 2^1 means that O_2(G) is of symplectic type 2^{1+5}, with Frattini factor group of type 2^4 E 2^1. The A after the 2^1 indicates that G has a central cyclic subgroup 2^1 A 2^1 of order 4.

(iii)

  L_3(2) ((2^1 E) × ( N 2^3 E 2^{3'} A) C) 2^{3'} means that the 2^{3'} factor at the bottom lies in the commutator subgroup of the pair 2^3 E 2^{3'} in the middle, but the lower pair 2^{3'} A 2^{3'} is abelian of exponent 4. There is also a submodule 2^1 E 2^{3'}, and the covering group L_3(2) 2^1 of L_3(2) does not split over the 2^3 factor. (Since G is perfect, it goes without saying that the extension L_3(2) 2^1 cannot split itself.)

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.

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 `DisplayInformationPerfectGroups` (50.6-6). 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.

#### 50.7 Irreducible Maximal Finite Integral Matrix Groups

A library of irreducible maximal finite integral matrix groups is provided with GAP. It contains ℚ-class representatives for all of these groups of dimension at most 31, and ℤ-class representatives for those of dimension at most 11 or of dimension 13, 17, 19, or 23.

The groups provided in this library have been determined by Wilhelm Plesken, partially as joint work with Michael Pohst, or by members of his institute (Lehrstuhl B für Mathematik, RWTH Aachen). In particular, the data for the groups of dimensions 2 to 9 have been taken from the output of computer calculations which they performed in 1979 (see [PP77], [PP80]). The ℤ-class representatives of the groups of dimension 10 have been determined and computed by Bernd Souvignier ([Sou94]), and those of dimensions 11, 13, and 17 have been recomputed for this library from the circulant Gram matrices given in [Ple85], using the stand-alone programs for the computation of short vectors and Bravais groups which have been developed in Plesken's institute. The ℤ-class representatives of the groups of dimensions 19 and 23 had already been determined in [Ple85]. Gabriele Nebe has recomputed them for us. Her main contribution to this library, however, is that she has determined and computed the ℚ-class representatives of the groups of non-prime dimensions between 12 and 24 and the groups of dimensions 25 to 31 (see [PN95], [NP95b], [Neb95], [Neb96]).

The library has been brought into GAP format by Volkmar Felsch. He has applied several GAP routines to check certain consistency of the data. However, the credit and responsibility for the lists remain with the authors. We are grateful to Wilhelm Plesken, Gabriele Nebe, and Bernd Souvignier for supplying their results to GAP.

In the preceding acknowledgement, we used some notations that will also be needed in the sequel. We first define these.

Any integral matrix group G of dimension n is a subgroup of GL_n(ℤ) as well as of GL_n(ℚ) and hence lies in some conjugacy class of integral matrix groups under GL_n(ℤ) and also in some conjugacy class of rational matrix groups under GL_n(ℚ). As usual, we call these classes the ℤ-class and the ℚ-class of G, respectively. Note that any conjugacy class of subgroups of GL_n(ℚ) contains at least one ℤ-class of subgroups of GL_n(ℤ) and hence can be considered as the ℚ-class of some integral matrix group.

In the context of this library we are only concerned with ℤ-classes and ℚ-classes of subgroups of GL_n(ℤ) which are irreducible and maximal finite in GL_n(ℤ) (we will call them i.m.f. subgroups of GL_n(ℤ)). We can distinguish two types of these groups:

First, there are those i.m.f. subgroups of GL_n(ℤ) which are also maximal finite subgroups of GL_n(ℚ). Let us denote the set of their ℚ-classes by Q_1(n). It is clear from the above remark that Q_1(n) just consists of the ℚ-classes of i.m.f. subgroups of GL_n(ℚ).

Secondly, there is the set Q_2(n) of the ℚ-classes of the remaining i.m.f. subgroups of GL_n(ℤ), i.e., of those which are not maximal finite subgroups of GL_n(ℚ). For any such group G, there is at least one class C ∈ Q_1(n) such that G is conjugate under ℚ to a proper subgroup of some group H ∈ C. In fact, the class C is uniquely determined for any group G occurring in the library (though there seems to be no reason to assume that this property should hold in general). Hence we may call C the rational i.m.f. class of G. Finally, we will denote the number of classes in Q_1(n) and Q_2(n) by q_1(n) and q_2(n), respectively.

As an example, let us consider the case n = 4. There are 6 ℤ-classes of i.m.f. subgroups of GL_4(ℤ) with representative subgroups G_1, ..., G_6 of isomorphism types G_1 ≅ W(F_4), G_2 ≅ D_12 ≀ C_2, G_3 ≅ G_4 ≅ C_2 × S_5, G_5 ≅ W(B_4), and G_6 ≅ (D_12 `Y` D_12) : C_2. The corresponding ℚ-classes, which we denote R_1, ..., R_6, are pairwise different except that R_3 coincides with R_4. The groups G_1, G_2, and G_3 are i.m.f. subgroups of GL_4(ℚ), but G_5 and G_6 are not because they are conjugate under GL_4(ℚ) to proper subgroups of G_1 and G_2, respectively. So we have Q_1(4) = { R_1, R_2, R_3 }, Q_2(4) = { R_5, R_6 }, q_1(4) = 3, and q_2(4) = 2.

The q_1(n) ℚ-classes of i.m.f. subgroups of GL_n(ℚ) have been determined for each dimension n ≤ 31. The current GAP library provides integral representative groups for all these classes. Moreover, all ℤ-classes of i.m.f. subgroups of GL_n(ℤ) are known for n ≤ 11 and for n ∈ {13,17,19,23}. For these dimensions, the library offers integral representative groups for all ℚ-classes in Q_1(n) and Q_2(n) as well as for all ℤ-classes of i.m.f. subgroups of GL_n(ℤ).

Any group G of dimension n given in the library is represented as the automorphism group G = Aut(F,L) = { g ∈ GL_n(ℤ) ∣ Lg = L, g F g^tr = F } of a positive definite symmetric n × n matrix F ∈ ℤ^{n × n} on an n-dimensional lattice L ≅ ℤ^{1 × n} (for details see e.g. [PN95]). GAP provides for G a list of matrix generators and the Gram matrix F.

The positive definite quadratic form defined by F defines a norm v F v^tr for each vector v ∈ L, and there is only a finite set of vectors of minimal norm. These vectors are often simply called the short vectors. Their set splits into orbits under G, and G being irreducible acts faithfully on each of these orbits by multiplication from the right. GAP provides for each of these orbits the orbit size and a representative vector.

Like most of the other GAP libraries, the library of i.m.f. integral matrix groups supplies an extraction function, `ImfMatrixGroup`. However, as the library involves only 525 different groups, there is no need for a selection or an example function. Instead, there are two functions, `ImfInvariants` (50.7-3) and `DisplayImfInvariants` (50.7-2), which provide some ℤ-class invariants that can be extracted from the library without actually constructing the representative groups themselves. The difference between these two functions is that the latter one displays the resulting data in some easily readable format, whereas the first one returns them as record components so that you can properly access them.

We shall give an individual description of each of the library functions, but first we would like to insert a short remark concerning their names: Any self-explaining name of a function handling irreducible maximal finite integral matrix groups would have to include this term in full length and hence would grow extremely long. Therefore we have decided to use the abbreviation `Imf` instead in order to restrict the names to some reasonable length.

The first three functions can be used to formulate loops over the classes.

##### 50.7-1 ImfNumberQQClasses

`‣ ImfNumberQQClasses`( dim ) | ( function )

`‣ ImfNumberQClasses`( dim ) | ( function )

`‣ ImfNumberZClasses`( dim, q ) | ( function )

`ImfNumberQQClasses` returns the number q_1(dim) of ℚ-classes of i.m.f. rational matrix groups of dimension dim. Valid values of dim are all positive integers up to 31.

Note: In order to enable you to loop just over the classes belonging to Q_1(dim), we have arranged the list of ℚ-classes of dimension dim for any dimension dim in the library such that, whenever the classes of Q_2(dim) are known, too, i.e., in the cases dim ≤ 11 or dim ∈ {13,17,19,23}, the classes of Q_1(dim) precede those of Q_2(dim) and hence are numbered from 1 to q_1(dim).

`ImfNumberQClasses` returns the number of ℚ-classes of groups of dimension dim which are available in the library. If dim ≤ 11 or dim ∈ {13,17,19,23}, this is the number q_1(dim) + q_2(dim) of ℚ-classes of i.m.f. subgroups of GL_dim(ℤ). Otherwise, it is just the number q_1(dim) of ℚ-classes of i.m.f. subgroups of GL_dim(ℚ). Valid values of dim are all positive integers up to 31.

`ImfNumberZClasses` returns the number of ℤ-classes in the q-th ℚ-class of i.m.f. integral matrix groups of dimension dim. Valid values of dim are all positive integers up to 11 and all primes up to 23.

##### 50.7-2 DisplayImfInvariants

`‣ DisplayImfInvariants`( dim, q[, z] ) | ( function )

`DisplayImfInvariants` displays the following ℤ-class invariants of the groups in the z-th ℤ-class in the q-th ℚ-class of i.m.f. integral matrix groups of dimension dim:

- its ℤ-class number in the form dim.q.z, if dim is at most 11 or a prime at most 23, or its ℚ-class number in the form dim.q, else,

- a message if the group is solvable,

- the size of the group,

- the isomorphism type of the group,

- the elementary divisors of the associated quadratic form,

- the sizes of the orbits of short vectors (these sizes are the degrees of the faithful permutation representations which you may construct using the functions `IsomorphismPermGroup` (50.7-5) or `IsomorphismPermGroupImfGroup` (50.7-6) below),

- the norm of the associated short vectors,

- only in case that the group is not an i.m.f. group in GL_n(ℚ): an appropriate message, including the ℚ-class number of the corresponding rational i.m.f. class.

If you specify the value 0 for any of the parameters dim, q, or z, the command will loop over all available dimensions, ℚ-classes of given dimension, or ℤ-classes within the given ℚ-class, respectively. Otherwise, the values of the arguments must be in range. A value z ≠ 1 must not be specified if the ℤ-classes are not known for the given dimension, i.e., if dim > 11 and dim not ∈ { 13, 17, 19, 23 }. The default value of z is 1. This value of z will be accepted even if the ℤ-classes are not known. Then it specifies the only representative group which is available for the q-th ℚ-class. The greatest legal value of dim is 31.

    gap> DisplayImfInvariants( 3, 1, 0 );
    #I Z-class 3.1.1:  Solvable, size = 2^4*3
    #I   isomorphism type = C2 wr S3 = C2 x S4 = W(B3)
    #I   elementary divisors = 1^3
    #I   orbit size = 6, minimal norm = 1
    #I Z-class 3.1.2:  Solvable, size = 2^4*3
    #I   isomorphism type = C2 wr S3 = C2 x S4 = C2 x W(A3)
    #I   elementary divisors = 1*4^2
    #I   orbit size = 8, minimal norm = 3
    #I Z-class 3.1.3:  Solvable, size = 2^4*3
    #I   isomorphism type = C2 wr S3 = C2 x S4 = C2 x W(A3)
    #I   elementary divisors = 1^2*4
    #I   orbit size = 12, minimal norm = 2
    gap> DisplayImfInvariants( 8, 15, 1 );
    #I Z-class 8.15.1:  Solvable, size = 2^5*3^4
    #I   isomorphism type = C2 x (S3 wr S3)
    #I   elementary divisors = 1*3^3*9^3*27
    #I   orbit size = 54, minimal norm = 8
    #I   not maximal finite in GL(8,Q), rational imf class is 8.5
    gap> DisplayImfInvariants( 20, 23 );
    #I Q-class 20.23:  Size = 2^5*3^2*5*11
    #I   isomorphism type = (PSL(2,11) x D12).C2
    #I   elementary divisors = 1^18*11^2
    #I   orbit size = 3*660 + 2*1980 + 2640 + 3960, minimal norm = 4

Note that the function `DisplayImfInvariants` uses a kind of shorthand to display the elementary divisors. E. g., the expression `1*3^3*9^3*27` in the preceding example stands for the elementary divisors 1,3,3,3,9,9,9,27. (See also the next example which shows that the function `ImfInvariants` (50.7-3) provides the elementary divisors in form of an ordinary GAP list.)

In the description of the isomorphism types the following notations are used:

A `x` B

  denotes a direct product of a group A by a group B,

A `subd` B

  denotes a subdirect product of A by B,

A `Y` B

  denotes a central product of A by B,

A `wr` B

  denotes a wreath product of A by B,

A`:`B

  denotes a split extension of A by B,

A`.`B

  denotes just an extension of A by B (split or nonsplit).

The groups involved are

- the cyclic groups C_n, dihedral groups D_n, and generalized quaternion groups Q_n of order n, denoted by `C` n, `D` n, and `Q` n, respectively,

- the alternating groups A_n and symmetric groups S_n of degree n, denoted by `A` n and `S` n, respectively,

- the linear groups GL_n(q), PGL_n(q), SL_n(q), and PSL_n(q), denoted by `GL`(n,q), `PGL`(n,q), `SL`(n,q), and `PSL`(n,q), respectively,

- the unitary groups SU_n(q) and PSU_n(q), denoted by `SU`(n,q) and `PSU`(n,q), respectively,

- the symplectic groups Sp(n,q) and PSp(n,q), denoted by `Sp`(n,q) and `PSp`(n,q), respectively,

- the orthogonal groups O_8^+(2) and PO_8^+(2), denoted by `O+`(8,2) and `PO+`(8,2), respectively,

- the extraspecial groups 2_+^{1+8}, 3_+^{1+2}, 3_+^{1+4}, and 5_+^{1+2}, denoted by `2+^(1+8)`, `3+^(1+2)`, `3+^(1+4)`, and `5+^(1+2)`, respectively,

- the Chevalley group G_2(3), denoted by `G2(3)`,

- the twisted Chevalley group ^3D_4(2), denoted by `3D4(2)`,

- the Suzuki group Sz(8), denoted by `Sz(8)`,

- the Weyl groups W(A_n), W(B_n), W(D_n), W(E_n), and W(F_4), denoted by `W(An)`, `W(Bn)`, `W(Dn)`, `W(En)`, and `W(F4)`, respectively,

- the sporadic simple groups Co_1, Co_2, Co_3, HS, J_2, M_12, M_22, M_23, M_24, and Mc, denoted by `Co1`, `Co2`, `Co3`, `HS`, `J2`, `M12`, `M22`, `M23`, `M24`, and `Mc`, respectively,

- a point stabilizer of index 11 in M_11, denoted by `M10`.

As mentioned above, the data assembled by the function `DisplayImfInvariants` are cheap data in the sense that they can be provided by the library without loading any of its large matrix files or performing any matrix calculations. The following function allows you to get proper access to these cheap data instead of just displaying them.

##### 50.7-3 ImfInvariants

`‣ ImfInvariants`( dim, q[, z] ) | ( function )

`ImfInvariants` returns a record which provides some ℤ-class invariants of the groups in the z-th ℤ-class in the q-th ℚ-class of i.m.f. integral matrix groups of dimension dim. A value z ≠ 1 must not be specified if the ℤ-classes are not known for the given dimension, i.e., if dim > 11 and dim not ∈ { 13, 17, 19, 23 }. The default value of z is 1. This value of z will be accepted even if the ℤ-classes are not known. Then it specifies the only representative group which is available for the q-th ℚ-class. The greatest legal value of dim is 31.

The resulting record contains six or seven components:

`size`

  the size of any representative group G,

`isSolvable`

  is `true` if G is solvable,

`isomorphismType`

  a text string describing the isomorphism type of G (in the same notation as used by the function `DisplayImfInvariants` above),

`elementaryDivisors`

  the elementary divisors of the associated Gram matrix F (in the same format as the result of the function `ElementaryDivisorsMat` (24.9-1),

`minimalNorm`

  the norm of the associated short vectors,

`sizesOrbitsShortVectors`

  the sizes of the orbits of short vectors under F,

`maximalQClass`

  the ℚ-class number of an i.m.f. group in GL_n(ℚ) that contains G as a subgroup (only in case that not G itself is an i.m.f. subgroup of GL_n(ℚ)).

Note that four of these data, namely the group size, the solvability, the isomorphism type, and the corresponding rational i.m.f. class, are not only ℤ-class invariants, but also ℚ-class invariants.

Note further that, though the isomorphism type is a ℚ-class invariant, you will sometimes get different descriptions for different ℤ-classes of the same ℚ-class (as, e.g., for the classes 3.1.1 and 3.1.2 in the last example above). The purpose of this behaviour is to provide some more information about the underlying lattices.

    gap> ImfInvariants( 8, 15, 1 );
    rec( elementaryDivisors := [ 1, 3, 3, 3, 9, 9, 9, 27 ],
      isSolvable := true, isomorphismType := "C2 x (S3 wr S3)",
      maximalQClass := 5, minimalNorm := 8, size := 2592,
      sizesOrbitsShortVectors := [ 54 ] )
    gap> ImfInvariants( 24, 1 ).size;
    10409396852733332453861621760000
    gap> ImfInvariants( 23, 5, 2 ).sizesOrbitsShortVectors;
    [ 552, 53130 ]
    gap> for i in [ 1 .. ImfNumberQClasses( 22 ) ] do
    >    Print( ImfInvariants( 22, i ).isomorphismType, "\n" ); od;
    C2 wr S22 = W(B22)
    (C2 x PSU(6,2)).S3
    (C2 x S3) wr S11 = (C2 x W(A2)) wr S11
    (C2 x S12) wr C2 = (C2 x W(A11)) wr C2
    C2 x S3 x S12 = C2 x W(A2) x W(A11)
    (C2 x HS).C2
    (C2 x Mc).C2
    C2 x S23 = C2 x W(A22)
    C2 x PSL(2,23)
    C2 x PSL(2,23)
    C2 x PGL(2,23)
    C2 x PGL(2,23)

##### 50.7-4 ImfMatrixGroup

`‣ ImfMatrixGroup`( dim, q[, z] ) | ( function )

`ImfMatrixGroup` is the essential extraction function of this library (note that its name has been changed from `ImfMatGroup` in GAP 3 to `ImfMatrixGroup` in GAP 4). It returns a representative group, G say, of the z-th ℤ-class in the q-th ℚ-class of i.m.f. integral matrix groups of dimension dim. A value z≠ 1 must not be specified if the ℤ-classes are not known for the given dimension, i.e., if dim > 11 and dim not ∈ { 13, 17, 19, 23 }. The default value of z is 1. This value of z will be accepted even if the ℤ-classes are not known. Then it specifies the only representative group which is available for the q-th ℚ-class. The greatest legal value of dim is 31.

    gap> G := ImfMatrixGroup( 5, 1, 3 );
    ImfMatrixGroup(5,1,3)
    gap> for m in GeneratorsOfGroup( G ) do PrintArray( m ); od;
    [ [  -1,   0,   0,   0,   0 ],
      [   0,   1,   0,   0,   0 ],
      [   0,   0,   0,   1,   0 ],
      [  -1,  -1,  -1,  -1,   2 ],
      [  -1,   0,   0,   0,   1 ] ]
    [ [  0,  1,  0,  0,  0 ],
      [  0,  0,  1,  0,  0 ],
      [  0,  0,  0,  1,  0 ],
      [  1,  0,  0,  0,  0 ],
      [  0,  0,  0,  0,  1 ] ]

The attributes `Size` (30.4-6) and `IsSolvable` will be properly set in the resulting matrix group G. In addition, it has two attributes `IsImfMatrixGroup` and `ImfRecord` where the first one is just a logical flag set to `true` and the latter one is a record. Except for the group size and the solvability flag, this record contains the same components as the resulting record of the function `ImfInvariants` (50.7-3) described above, namely the components `isomorphismType`, `elementaryDivisors`, `minimalNorm`, and `sizesOrbitsShortVectors` and, if G is not a rational i.m.f. group, `maximalQClass`. Moreover, it has the two components

`form`

  the associated Gram matrix F, and

`repsOrbitsShortVectors`

  representatives of the orbits of short vectors under F.

The last one of these components will be required by the function `IsomorphismPermGroup` (50.7-5) below.

    gap> Size( G );
    3840
    gap> imf := ImfRecord( G );;
    gap> imf.isomorphismType;
    "C2 wr S5 = C2 x W(D5)"
    gap> PrintArray( imf.form );
    [ [  4,  0,  0,  0,  2 ],
      [  0,  4,  0,  0,  2 ],
      [  0,  0,  4,  0,  2 ],
      [  0,  0,  0,  4,  2 ],
      [  2,  2,  2,  2,  5 ] ]
    gap> imf.elementaryDivisors;
    [ 1, 4, 4, 4, 4 ]
    gap> imf.minimalNorm;
    4

If you want to perform calculations in such a matrix group G you should be aware of the fact that the permutation group routines of GAP are much more efficient than the matrix group routines. Hence we recommend that you do your computations, whenever possible, in the isomorphic permutation group which is induced by the action of G on one of the orbits of the associated short vectors. You may call one of the following functions `IsomorphismPermGroup` (50.7-5) or `IsomorphismPermGroupImfGroup` (50.7-6) to get an isomorphism to such a permutation group (note that these GAP 4 functions have replaced the GAP 3 functions `PermGroup` and `PermGroupImfGroup`).

##### 50.7-5 IsomorphismPermGroup

`‣ IsomorphismPermGroup`( G ) | ( method )

returns an isomorphism, φ say, from the given i.m.f. integral matrix group G to a permutation group P := φ(G) acting on a minimal orbit, S say, of short vectors of G such that each matrix m ∈ G is mapped to the permutation induced by its action on S.

Note that in case of a large orbit the construction of φ may be space and time consuming. Fortunately, there are only six ℚ-classes in the library for which the smallest orbit of short vectors is of size greater than 20000, the worst case being the orbit of size 196560 for the Leech lattice (dim = 24, q = 3).

The inverse isomorphism φ^{-1} from P to G is constructed by determining a ℚ-base B ⊂ S of ℚ^{1 × dim} in S and, in addition, the associated base change matrix M which transforms B into the standard base of ℤ^{1 × dim}. This allows a simple computation of the preimage φ^{-1}(p) of any permutation p ∈ P, as follows. If, for 1 ≤ i ≤ dim, b_i is the position number in S of the i-th base vector in B, it suffices to look up the vector whose position number in S is the image of b_i under p and to multiply this vector by M to get the i-th row of φ^{-1}(p).

You may use the functions `Image` (32.4-6) and `PreImage` (32.5-6) to switch from G to P and back from P to G.

As an example, let us continue the preceding example and compute the solvable residuum of the group G.

    gap> # Perform the computations in an isomorphic permutation group.
    gap> phi := IsomorphismPermGroup( G );;
    gap> P := Image( phi );
    Group([ (1,7,6)(2,9)(4,5,10), (2,3,4,5)(6,9,8,7) ])
    gap> D := DerivedSubgroup( P );;
    gap> Size( D );
    960
    gap> IsPerfectGroup( D );
    true
    gap> # We have found the solvable residuum of P,
    gap> # now move the results back to the matrix group G.
    gap> R := PreImage( phi, D );;
    gap> StructureDescription(R);
    "(C2 x C2 x C2 x C2) : A5"
    gap> IdGroup(D)=IdGroup(R);
    true

##### 50.7-6 IsomorphismPermGroupImfGroup

`‣ IsomorphismPermGroupImfGroup`( G, n ) | ( function )

`IsomorphismPermGroupImfGroup` returns an isomorphism, φ say, from the given i.m.f. integral matrix group G to a permutation group P acting on the n-th orbit, S say, of short vectors of G such that each matrix m ∈ G is mapped to the permutation induced by its action on S.

The only difference to the above function `IsomorphismPermGroup` (50.7-5) is that you can specify the orbit to be used. In fact, as the orbits of short vectors are sorted by increasing sizes, the function `IsomorphismPermGroup( G )` has been implemented such that it is equivalent to `IsomorphismPermGroupImfGroup( G, 1 )`.

    gap> ImfInvariants( 12, 9 ).sizesOrbitsShortVectors;
    [ 120, 300 ]
    gap> G := ImfMatrixGroup( 12, 9 );
    ImfMatrixGroup(12,9)
    gap> phi1 := IsomorphismPermGroupImfGroup( G, 1 );;
    gap> P1 := Image( phi1 );
    <permutation group of size 2400 with 2 generators>
    gap> LargestMovedPoint( P1 );
    120
    gap> phi2 := IsomorphismPermGroupImfGroup( G, 2 );;
    gap> P2 := Image( phi2 );
    <permutation group of size 2400 with 2 generators>
    gap> LargestMovedPoint( P2 );
    300

[Top of Book] [Contents] [Previous Chapter] [Next Chapter]
Goto Chapter: Top 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 Bib Ind

generated by GAPDoc2HTML