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

    [Top] [Previous] [Up] [Next] [Index]

    GAP 4 manual
    February 2000