47 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 Basic Groups),
·
Classical matrix groups (see Classical Groups),
·
the transitive permutation groups of degree at most 23 (see Transitive permutation groups),
·
a library of groups of small order (see Small Groups),
·
the finite perfect groups of size at most 106 (excluding 11 sizes) (see Finite perfect groups).
·
a library of primitive permutation groups of degree < 1000, complete for degrees < 256 (see Primitive permutation groups),
·
the irreducible solvable subgroups of GL(n,p) for n > 1 and pn < 256 (also in Primitive permutation 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.

Sections

  1. Basic Groups
  2. Classical Groups
  3. Constructors for Basic Groups
  4. Selection Functions
  5. Transitive Permutation Groups
  6. Small Groups
  7. Finite Perfect Groups
  8. Primitive Permutation Groups
  9. Irreducible Maximal Finite Integral Matrix Groups

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

  • TrivialGroup( [filter] ) F

    constructs a trivial group in the category given by the filter filter. If filter is not given it defaults to IsPcGroup.

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

  • CyclicGroup( [filt, ]n ) F

    constructs the cyclic group of size n in the category given by 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 category given by 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 category given by 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 category given by 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 category given by 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 category given by 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 category given by 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.

  • MathieuGroup( [filt, ]degree ) F

    constructs the Mathieu group of degree degree in the category given by 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) ])
    

  • SuzukiGroup( [filt, ]q ) F
  • Sz( [filt, ]q ) F

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

    If filt is not given it defaults to IsMatrixGroup, and the returned group is the Suzuki group itself.

    gap> SuzukiGroup( 32 );
    Sz(32)
    

    47.2 Classical Groups

    The following functions return classical groups. For the linear, symplectic, and unitary groups (the latter in dimension at least 3), the generators are taken from Tay87. The generators of the orthogonal groups are taken from

    H.Ishibashi, A.G.Earnest Two-Element Generation of Orthogonal Groups over Finite Fields.

    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 (see InvariantBilinearForm). Analogously, the invariant sesquilinear form defining the unitary groups is stored as the value of the attribute InvariantSesquilinearForm (see InvariantSesquilinearForm). The defining quadratic form of orthogonal groups is stored as the value of the attribute InvariantQuadraticForm (see InvariantQuadraticForm).

  • GeneralLinearGroup( [filt, ]d, q ) F
  • GL( [filt, ]d, q ) F

    constructs a group isomorphic to the general linear group GL( d, q ) of all d ×d matrices over the field with q elements, in the category given by the filter filt.

    If filt is not given it defaults to IsMatrixGroup, and the returned group is the general linear group as a matrix group in its natural action (see also IsNaturalGL).

    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 all those d ×d matrices over the field with q elements whose determinant is the identity of the field, in the category given by the filter filt.

    If filt is not given it defaults to IsMatrixGroup, and the returned group is the special linear group as a matrix group in its natural action (see also IsNaturalSL).

    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
    

  • 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 category given by 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 category given by 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 category given by 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)
    

  • GeneralOrthogonalGroup( [filt, ][e, ]d, q ) F
  • GO( [filt, ][e, ]d, q ) F

    GeneralOrthogonalGroup returns 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) specified by e, in the category given by the filter filt. The value of e may be one of 0, 1, or -1; e = 0 is possible if and only if d is odd, hence e may be omitted in this case.

    If filt is not given it defaults to IsMatrixGroup, and the returned group is the general orthogonal group itself.

  • SpecialOrthogonalGroup( [filt, ][e, ]d, q ) F
  • SO( [filt, ][e, ]d, q ) F

    SpecialOrthogonalGroup returns 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) 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.)

    If filt is not given it defaults to IsMatrixGroup, and the returned group is the special orthogonal group itself.

    gap> GeneralOrthogonalGroup( 3, 7 );
    GO(0,3,7)
    gap> GeneralOrthogonalGroup( -1, 4, 3 );
    GO(-1,4,3)
    gap> SpecialOrthogonalGroup( 1, 4, 4 );
    GO(+1,4,4)
    

  • 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 category given by 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 category given by 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.

  • ProjectiveGeneralUnitaryGroup( [filt, ]d, q ) F
  • PGU( [filt, ]d, q ) F

    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 IsMatrixGroup, and the returned group is the general unitary group itself.

  • ProjectiveSpecialUnitaryGroup( [filt, ]d, q ) F
  • PSU( [filt, ]d, q ) F

    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 IsMatrixGroup, and the returned group is the general unitary group itself.

  • ProjectiveSymplecticGroup( [filt, ]d, q ) F
  • PSP( [filt, ]d, q ) F
  • PSp( [filt, ]d, q ) F

    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, and the returned group is the action on lines of the underlying vector space.

    47.3 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 calls the constructor


  • CyclicGroupCons( 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 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 );
    

    47.4 Selection Functions


  • AllLibraryGroups( 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 Transitive permutation groups) is called AllTransitiveGroups.

    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,

    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 the AllTransitiveGroups behaves as if it was implemented by a function similar to the one defined below, where TransitiveGroupsList is a list of all primitive 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( 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.

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

    47.6 Small Groups

    This library contains explicit lists of all groups of certain orders up to isomorphism. Currently, the catalogue contains the groups

    ·
    whose order factorises in at most 3 primes.
    ·
    of order at most 2000 except 1024.
    ·
    of order 55 and 74.
    ·
    of order qn ·p where qn divides 28, 36, 55 or 74 and p is an arbitrary prime different to q.

    The groups whose order factorises in at most 3 primes have been classified by O. Hölder in 1893. An explicit description of these groups can be found in Neu67. The remaining p-groups in the catalogue have been constructed by E. A. O'Brien using the p-group generation method, see New77, OBr90 and OBr91. An implementation of this method is part of the ANUPQ share package of GAP. The nilpotent groups are then obtained as direct products of p-groups. The remaining non-nilpotent groups of order at most 2000 have been determined by Hans Ulrich Besche and Bettina Eick using the coprime split extensions method for solvable groups with certain normal Hall subgroups, the Frattini extension method for solvable group in general and the well-known cyclic extension algorithm for non-solvable groups. In BescheEick98 and BescheEick1000 a first version of these methods is described and they are also available within the GrpConst share package of GAP. The groups of order qn ·p have been constructed using a generic variation of our algorithms, see BescheEick768. A survey on group constructions and our algorithms for this purpose can be found in BEO.

    The Small Groups Library incorporates the Gap 3 libraries TwoGroup and ThreeGroup without changes. In particular, the 2- and 3-groups in the Small Groups Library are sorted as the groups in TwoGroup or ThreeGroup. Moreover, the Small Groups Library substitutes the Gap 3 library of solvable groups of order at most 100, but here the sorting of groups has changed in the Small Groups Library.

    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 a given group. This function determines catalogue numbers using invariants of groups. The function is available for all orders in the catalogue except 512 and 1536.

    The catalogue is organised in 8 layers. It is possible to install the first n layers only for each n in the range of 1 to 8. There exists an extensive README file for the Small Groups Library containing detailed information on the layers. The layers contain:

    (1)
    the groups whose size factorises in at most 3 primes.
    (2)
    the remaining groups of size a most 1000 except 512 and 768.
    (3)
    the remaining groups of size 2n * p with n £ 8 and p an odd prime.
    (4)
    the remaining groups of size qn * p where qn divides 36, 55 or 74 and p is a prime different to q. Moreover, this layer contains the groups of order 55 and 74.
    (5)
    the remaining groups of order at most 2000 except 1024, 1152, 1536 and 1920.
    (6)
    the groups of orders 1152 and 1920.
    (7)
    the groups of order 512.
    (8)
    the groups of order 1536.

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

  • AllSmallGroups( arg ) F
  • 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.

  • OneSmallGroup( arg ) F
  • OneGroup( arg ) F

    see AllSmallGroups.

  • SmallGroupsInformation( size ) F

    prints information on the groups of the specified size.

  • NumberSmallGroups( size ) F
  • NrSmallGroups( size ) F

    returns the number of groups of order size.

  • 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 ).

  • IdsOfAllSmallGroups( arg ) F
  • 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.

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

  • 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();
    

    47.7 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 106 excluding the following sizes:

    ·
    For n = 61440, 122880, 172032, 245760, 344064, 491520, 688128, or 983040, the perfect groups of size n have not completely been determined yet. The library neither provides the number of these groups nor the groups themselves.
    ·
    For n = 86016, 368640, or 737280, the library does not yet contain the perfect groups of size n, it only provides their numbers which are 52, 46, and 54, respectively.

    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.

    ·
    An or A(n) for the alternating groups An, 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 S(4,4),
    ·
    Sz(8) for the Suzuki group Sz(8),
    ·
    Mn or M(n) for the Mathieu groups M11, M12, and M22, and
    ·
    Jn 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:

    ·
    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)
    

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

    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.

    ×
    between two factors denotes a direct product of FpQ-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 (f1 × f2) C f3 would mean that the factors f1 and f2 commute modulo f3 and f3 lies in [f1,f2].
    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 FpQ-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 f1 N f2'' means that the normal subgroup f1f2 of the group has no complement but, modulo f2, f1, 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)
    A5 (24 E 21 E 24) A means that the pairs 24 E 21 and 21 E 24 are both elementary abelian of exponent 4.
    (ii)
    A5 (24 E 21 A) C 21 means that O2(G) is of symplectic type 21+5, with Frattini factor group of type 24 E 21. The ``A'' after the 21 indicates that G has a central cyclic subgroup 21 A 21 of order 4.
    (iii)
    L3(2) ((21 E) × (N 23 E 23¢ A) C) 23¢ means that the 23¢ factor at the bottom lies in the commutator subgroup of the pair 23 E 23¢ in the middle, but the lower pair 23¢ A 23¢ is abelian of exponent 4. There is also a submodule 21 E 23¢, and the covering group L3(2) 21 of L3(2) does not split over the 23 factor. (Since G is perfect, it goes without saying that the extension L3(2) 21 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.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.

    47.8 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)

    ·
    the non-affine primitive permutation groups of degree < = 999, described in DixonMortimer88, with generators calculated in Theissen97,
    ·
    all primitive permutation groups of degree < 256, in particular,
       °
    the primitive permutation groups up to degree 50, calculated by C. Sims,
       °
    the solvable (hence affine) primitive permutation groups of degree < 256, calculated by M. Short Sho92,
       °
    the insolvable affine primitive permutation groups of degree < 256, calculated in Theissen97.
    Note that the affine primitive permutation groups of degrees 256--999 are not included.

    For degree up to 50, the names used are as given by Buekenhout and Leemans BuekenhoutLeemans96.

    The names for the groups of higher degree are as chosen by Theissen97 and reflect the cohort structure in DixonMortimer88. They do not conform to the usual naming for extensions. That is l3,4.3 is the third (in some arbitrary ordering) group in a cohort for socle l3,4, but the socle factor is not necessarily of order 3.

    As the work in Theissen97 has not been checked independently for completeness, it is perceivable in theory that for degrees above 50 groups are missing. However when preparing the library it has been ensured that the groups in it are all primitive and not conjugate.

    In detail, we guarantee the following properties for this and further versions (but not versions which came before GAP 4.2) of the library:

    ·
    All groups in the library are primitive permutation groups of the indicated degree.
    ·
    The positions of the groups in the library are stable. That is PrimitiveGroup(n,nr) will always give you a permutation isomorphic group. Note however that we do not guarantee to keep the chosen Sn-representative, the generating set or the name for eternity.
    ·
    Different groups in the library are not conjugate in Sn.
    ·
    If a group in the library has a primitive subgroup with the same socle, this group is in the library as well.

  • PrimitiveGroup( deg, nr ) F

    returns the primitive permutation group of degree deg with number nr from the list.

    The arrangement of the groups differs from the arrangement of primitive groups in the list of C. Sims, which was used in GAP 3. See SimsNo (SimsNo).

  • NrPrimitiveGroups( deg ) F

    returns the number of primitive permutation groups of degree deg in the library.

    gap> NrPrimitiveGroups(25);
    28
    gap> PrimitiveGroup(25,19);
    5^2:((Q_8:3)`4
    gap> PrimitiveGroup(25,20);
    ASL(2,5)
    gap> PrimitiveGroup(25,22);
    AGL(2,5)
    gap> PrimitiveGroup(25,23);
    (A_5xA_5):2
    

    The selection functions (see Selection functions) for the primitive groups library are AllTransitiveGroups and OneTransitiveGroup. They obtain the following properties from the database without having to compute them anew:

    NrMovedPoints, Size, Transitivity, ONanScottType, IsSimpleGroup, IsSolvableGroup, and SocleTypePrimitiveGroup.

    (Note, that for groups of degree up to 999, ONan-Scott types 4a, 4b and 5 cannot occur.)

  • PrimitiveGroupsIterator( attr1, val1, attr2, val2, ... ) F

    returns an iterator through AllPrimitiveGroups(attr1,val1,attr2,val2,...) without creating all these groups at the same time.

  • PrimitiveIdentification( G ) A

    For a primitive permutation group for which an Sn-conjugate exists in the library of primitive permutation groups (see Primitive Permutation Groups), this attribute returns the index position. That is G is conjugate to PrimitiveGroup(NrMovedPoints(G),PrimitiveIdentification(G).

    Methods only exist if the primitive groups library is installed.

    gap> PrimitiveIdentification(Group((1,2),(1,2,3)));
    2
    

  • 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 C. Sims. (this is the arrangement as it was used in GAP 3.

    gap> g:=PrimitiveGroup(25,2);
    5^2:S_3
    gap> SimsNo(g);
    3
    

  • COHORTS_PRIMITIVE_GROUPS V

    In DixonMortimer88 the primitive groups are sorted in ``cohorts'' according to their socle. The variable COHORTS_PRIMITIVE_GROUPS contains for each degree a list of the cohorts for the primitive groups of this degree. Each cohort is represented by a list of length 2, the first entry specifies the socle type (see SocleTypePrimitiveGroup, section SocleTypePrimitiveGroup), the second entry listing the index numbers of the groups in this degree.

    For example in degree 49, we have four cohorts with socles \F72, L2(7)2, A72 and A49 respectively. the group PrimitiveGroup(49,36), which is isomorphic to (A7×A7):22, lies in the third cohort with socle (A7×A7).

    gap> COHORTS_PRIMITIVE_GROUPS[49];
    [ [ rec( series := "Z", width := 2, parameter := 7 ), 
          [ 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 ] ], 
      [ rec( series := "L", width := 2, parameter := [ 2, 7 ] ), [ 34 ] ], 
      [ rec( series := "A", width := 2, parameter := 7 ), [ 35, 36, 37, 38 ] ], 
      [ rec( series := "A", parameter := 49, width := 1 ), [ 39, 40 ] ] ]
    

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

    -
    increasing size;
    -
    increasing guardian number.
    If two groups have the same size and guardian, they are in no particular order. (See the library documentation or Sho92 for the meaning of guardian.)

    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.

    47.9 Irreducible Maximal Finite Integral Matrix Groups

    A library of irreducible maximal finite integral matrix groups is provided with GAP. It contains Q-class representatives for all of these groups of dimension at most 24, and Z-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 Z-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 Z-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 Q-class representatives of the groups of non-prime dimensions between 12 and 24 (see PN95, NP95, Neb95).

    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 GLn(Z) as well as of GLn(Q) and hence lies in some conjugacy class of integral matrix groups under GLn(Z) and also in some conjugacy class of rational matrix groups under GLn(Q). As usual, we call these classes the Z-class and the Q-class of G, respectively. Note that any conjugacy class of subgroups of GLn(Q) contains at least one Z-class of subgroups of GLn(Z) and hence can be considered as the Q-class of some integral matrix group.

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

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

    Secondly, there is the set Q2(n) of the Q-classes of the remaining i.m.f. subgroups of GLn(Z), i.e., of those which are not maximal finite subgroups of GLn(Q). For any such group G, say, there is at least one class C Î Q1(n) such that G is conjugate under Q 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 Q1(n) and Q2(n) by q1(n) and q2(n), respectively.

    As an example, let us consider the case n = 4. There are 6 Z-classes of i.m.f. subgroups of GL4(Z) with representative subgroups G1, ¼, G6 of isomorphsim types G1 @ W(F4), G2 @ D12 \wr C2, G3 @ G4 @ C2 ×S5, G5 @ W(B4), and G6 @ (D12 Y D12) : C2. The corresponding Q-classes, R1, ¼, R6, say, are pairwise different except that R3 coincides with R4. The groups G1, G2, and G3 are i.m.f. subgroups of GL4(Q), but G5 and G6 are not because they are conjugate under GL4(Q) to proper subgroups of G1 and G2, respectively. So we have Q1(4) = { R1, R2, R3 }, Q2(4) = { R5, R6 }, q1(4) = 3, and q2(4) = 2.

    The q1(n) Q-classes of i.m.f. subgroups of GLn(Q) have been determined for each dimension n £ 24. The current GAP library provides integral representative groups for all these classes. Moreover, all Z-classes of i.m.f. subgroups of GLn(Z) are known for n £ 11 and for n Î {13,17,19,23}. For these dimensions, the library offers integral representative groups for all Q-classes in Q1(n) and Q2(n) as well as for all Z-classes of i.m.f. subgroups of GLn(Z).

    Any group G of dimension n given in the library is represented as the automorphism group G = Aut(F,L) = { g Î GLn(Z) \mid Lg = L   and   g F gtr = F } of a positive definite symmetric n ×n matrix F Î Zn ×n on an n-dimensional lattice L @ Z1 ×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 vtr 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 423 different groups, there is no need for a selection or an example function. Instead, there are two functions, ImfInvariants and DisplayImfInvariants, which provide some Z-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.

  • ImfNumberQQClasses( dim ) F
  • ImfNumberQClasses( dim ) F
  • ImfNumberZClasses( dim, q ) F

    ImfNumberQQClasses returns the number q1(dim ) of Q-classes of i.m.f. rational matrix groups of dimension dim. Valid values of dim are all positive integers up to 24.

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

    ImfNumberQClasses returns the number of Q-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 q1(dim ) + q2(dim ) of Q-classes of i.m.f. subgroups of GLdim(Z). Otherwise, it is just the number q1(dim ) of Q-classes of i.m.f. subgroups of GLdim(Q). Valid values of dim are all positive integers up to 24.

    ImfNumberZClasses returns the number of Z-classes in the q th Q-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.

  • DisplayImfInvariants( dim, q ) F
  • DisplayImfInvariants( dim, q, z ) F

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

    -
    its Z-class number in the form dim.q.z, if dim is at most 11 or a prime, or its Q-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 or IsomorphismPermGroupImfGroup below),
    -
    the norm of the associated short vectors,
    -
    only in case that the group is not an i.m.f. group in GLn(Q): an appropriate message, including the Q-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, Q-classes of given dimension, or Z-classes within the given Q-class, respectively. Otherwise, the values of the arguments must be in range. A value z ¹ 1 must not be specified if the Z-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 Z-classes are not known. Then it specifies the only representative group which is available for the q th Q-class. The greatest legal value of dim is 24.

    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 provides the elementary divisors in form of an ordinary GAP list.)

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

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

    Asubd B
    denotes a subdirect product of A by B,

    AY B
    denotes a central product of A by B,

    Awr 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 Cn, dihedral groups Dn, and generalized quaternion groups Qn of order n, denoted by Cn, Dn, and Qn, respectively,
    -
    the alternating groups An and symmetric groups Sn of degree n, denoted by An and Sn, respectively,
    -
    the linear groups GLn(q), PGLn(q), SLn(q), and PSLn(q), denoted by GL(n,q), PGL(n,q), SL(n,q), and PSL(n,q), respectively,
    -
    the unitary groups SUn(q) and PSUn(q), denoted by SU(n,q) and PSU(n,q), respectively,
    -
    the symplectic groups Sp(n,q), denoted by Sp(n,q),
    -
    the orthogonal group O8 +(2), denoted by O+(8,2),
    -
    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 G2(3), denoted by G(2,3),
    -
    the Weyl groups W(An), W(Bn), W(Dn), W(En), and W(F4), denoted by W(An), W(Bn), W(Dn), W(En), and W(F4), respectively,
    -
    the sporadic simple groups Co1, Co2, Co3, HS, J2, M12, M22, M23, M24, and Mc, denoted by Co1, Co2, Co3, HS, J2, M12, M22, M23, M24, and Mc, respectively,
    -
    a point stabilizer of index 11 in M11, 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.

  • ImfInvariants( dim, q ) F
  • ImfInvariants( dim, q, z ) F

    ImfInvariants returns a record which provides some Z-class invariants of the groups in the z th Z-class in the q th Q-class of i.m.f. integral matrix groups of dimension dim. A value z ¹ 1 must not be specified if the Z-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 Z-classes are not known. Then it specifies the only representative group which is available for the q th Q-class. The greatest legal value of dim is 24.

    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, see ElementaryDivisorsMat),

    minimalNorm
    the norm of the associated short vectors,

    sizesOrbitsShortVectors
    the sizes of the orbits of short vectors under F,

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

    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 Z-class invariants, but also Q-class invariants.

    Note further that, though the isomorphism type is a Q-class invariant, you will sometimes get different descriptions for different Z-classes of the same Q-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( size := 2592, isSolvable := true,
      isomorphismType := "C2 x (S3 wr S3)",
      elementaryDivisors := [ 1, 3, 3, 3, 9, 9, 9, 27 ], minimalNorm := 8,
      sizesOrbitsShortVectors := [ 54 ], maximalQClass := 5 )
    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)
    

  • ImfMatrixGroup( dim, q ) F
  • ImfMatrixGroup( dim, q, z ) F

    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 Z-class in the q th Q-class of i.m.f. integral matrix groups of dimension dim. A value z ¹ 1 must not be specified if the Z-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 Z-classes are not known. Then it specifies the only representative group which is available for the q th Q-class. The greatest legal value of dim is 24.

    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 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 described above (see ImfInvariants), 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 below.

    Example:

    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 or IsomorphismPermGroupImfGroup to get an isomorphism to such a permutation group (note that these GAP 4 functions have replaced the GAP 3 functions PermGroup and PermGroupImfGroup).


    IsomorphismPermGroup( G ) M

    IsomorphismPermGroup returns an isomorphism, j say, from the given i.m.f. integral matrix group G to a permutation group P : = j(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 j may be space and time consuming. Fortunately, there are only five Q-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 j-1 from P to G is constructed by determining a Q-base B Ì S of Q1 ×dim in S and, in addition, the associated base change matrix M which transforms B into the standard base of Z1 ×dim. This allows a simple computation of the preimage j-1(p) of any permutation p Î P as follows. If, for 1 £ i £ dim, bi is the position number in S of the ith base vector in B, it suffices to look up the vector whose position number in S is the image of bi under p and to multiply this vector by M to get the ith row of j-1(p).

    You may use the functions Image and PreImage (see Image and PreImage) 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 );
    Group([ ( 1, 2,10, 9)( 3, 8)( 4, 5)( 6, 7),
      ( 1, 6)( 2, 7, 9, 4)( 3, 8)( 5,10), ( 1, 5,10, 6)( 2, 8, 9, 3) ])
    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 );
    <matrix group of size 960 with 3 generators>
    gap> for m in GeneratorsOfGroup( R ) do PrintArray( m ); od;
    [ [  -1,  -1,  -1,  -1,   2 ],
      [   0,  -1,   0,   0,   0 ],
      [   0,   0,   0,   1,   0 ],
      [   0,   0,   1,   0,   0 ],
      [  -1,  -1,   0,   0,   1 ] ]
    [ [   0,   0,  -1,   0,   0 ],
      [   0,  -1,   0,   0,   0 ],
      [   1,   0,   0,   0,   0 ],
      [  -1,  -1,  -1,  -1,   2 ],
      [   0,  -1,  -1,   0,   1 ] ]
    [ [   0,  -1,   0,   0,   0 ],
      [   1,   0,   0,   0,   0 ],
      [   0,   0,   1,   0,   0 ],
      [  -1,  -1,  -1,  -1,   2 ],
      [   0,  -1,   0,  -1,   1 ] ]
    

  • IsomorphismPermGroupImfGroup( G, n ) F

    IsomorphismPermGroupImfGroup returns an isomorphism, j 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 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] [Previous] [Up] [Next] [Index]

    GAP 4 manual
    February 2000