GAP (smallgrp) - Chapter 1: The Small Groups Library

Goto Chapter: Top 1 2 Bib Ind
[Top of Book] [Contents] [Previous Chapter] [Next Chapter]

[MathJax off]

1 The Small Groups Library
1.1 Overview
1.2 Related packages
1.3 Function Reference
1.3-1 SmallGroup
1.3-2 SmallGroupsAvailable
1.3-3 AllSmallGroups
1.3-4 OneSmallGroup
1.3-5 NumberSmallGroups
1.3-6 NumberSmallGroupsAvailable
1.3-7 SelectSmallGroups
1.3-8 IdSmallGroup
1.3-9 IdGroupsAvailable
1.3-10 IdsOfAllSmallGroups
1.3-11 IdGap3SolvableGroup
1.3-12 SmallGroupsInformation
1.3-13 SmallGroupsAddLayer
1.3-14 UnloadSmallGroupsData
1.3-15 SMALL_GROUPS_OLD_ORDER

### 1 The Small Groups Library

#### 1.1 Overview

The Small Groups library gives access to all groups of certain small orders. The groups are sorted by their orders and they are listed up to isomorphism; that is, for each of the available orders a complete and irredundant list of isomorphism type representatives of groups is given. Currently, the library contains the following groups:

- those of order at most 2000 except 1024 (\(423\;164\;062\) groups);

- those of cubefree order at most 50 000 (\(395 \; 703\) groups);

- those of order \(p^7\) for the primes \(p = 3,5,7,11\) (\(907 \; 489\) groups);

- those of order \(p^n\) for \(n \leq 6\) and all primes \(p\);

- those of order \(q^n \cdot p\) for \(q^n\) dividing \(2^8\), \(3^6\), \(5^5\) or \(7^4\) and all primes \(p\) with \(p \neq q\);

- those of squarefree order;

- those whose order factorises into at most 3 primes.

The first three items in this list cover an explicit range of orders; the last four provide access to infinite families of groups having orders of certain types.

The library also has an identification function: it returns the library number of a given group. This function determines library numbers using invariants of groups. The function is available for all orders in the library except for the orders 512 and 1536 and except for the orders \(p^5\), \(p^6\) and \(p^7\) above 2000.

The library is organised in 11 layers. Each layer contains the groups of certain orders and their corresponding group identification routines. It is possible to install the first \(n\) layers of the group library and the first \(m\) layers of the group identification for each \(1 \leq m \leq n \leq 11\). This might be useful to save disk space. Which orders belong to which layer is described in Chapter 2, along with detailed information on how the groups were determined, how they are stored, and how they are identified.

The data in this library has been carefully checked and cross-checked. It is believed to be reliable. However, no absolute guarantees are given and users should, as always, make their own checks in critical cases.

This library has been constructed by Hans Ulrich Besche, Bettina Eick and E. A. O'Brien. A survey on this topic and an account of the history of group constructions can be found in [BEO02]. Further detailed information on the construction of this library is available in [New77], [O'B90], [O'B91], [BE99a], [BE99b], [BE01], [BEO01], [EO99a], [EO99b], [NOV04], [Gir03], [DE05], [OV05]. The Small Groups library incorporates the GAP 3 libraries `TwoGroup` and `ThreeGroup`. The data from these libraries was directly included into the Small Groups library, and the ordering there was preserved. The Small Groups library replaces the GAP 3 library of solvable groups of order at most 100. However, both the organisation and the data descriptions of these groups have changed in the Small Groups library.

As of version 1.4 of this library, the arrangement of groups is the same as in Magma, version 2.23. In earlier releases of this library, the arrangement in orders \(p^7\), \(p=3,5,7,11\) disagreed. An attempt to fix this was made in version 1.1 of this library, but a wrong permutation was used. If you would like to refer to index numbers for these orders in older versions of the library, see `SMALL_GROUPS_OLD_ORDER` (1.3-15). The arrangement of all other orders has always agreed and has remained stable.

In version 1.5, the number of groups of order 1024 was corrected. For more information, refer to [Bur21].

#### 1.2 Related packages

Several other GAP packages give access to groups of orders which are not covered by this library, or which are covered only in part. A package can make its groups available through the functions of this chapter by calling `SmallGroupsAddLayer` (1.3-13).

The SglPPow package provides the groups of order \(p^7\) for primes \(p > 11\) and the groups of order \(3^8\). It extends this library: once it is loaded, its groups are available through the usual functions `SmallGroup` (1.3-1), `NumberSmallGroups` (1.3-5) and so on, and `SmallGroupsAvailable` (1.3-2) takes them into account. See https://gap-packages.github.io/sglppow/.

The SOTGrps package constructs and identifies the groups whose order factorises into at most 4 primes, as well as those of order \(p^4 q\) for distinct primes \(p\) and \(q\). It extends this library for those of its orders this one does not cover, and comes with its own functions `SOTGroup`, `AllSOTGroups` and `IdSOTGroup` for all of them. Be aware that where the orders covered by both overlap, the numbering used by SOTGrps in general differs from the one used here. See https://gap-packages.github.io/sotgrps/.

#### 1.3 Function Reference

##### 1.3-1 SmallGroup

`‣ SmallGroup`( order, i ) | ( function )

`‣ SmallGroup`( pair ) | ( function )

returns the i-th group of order order in the catalogue. If the group is solvable, it will be given as a PcGroup; otherwise it will be given as a permutation group. If the groups of order order are not installed, the function reports an error and enters a break loop.

    gap> G := SmallGroup( 60, 4 );
    <pc group of size 60 with 4 generators>
    gap> StructureDescription( G );
    "C60"
    gap> G := SmallGroup( 60, 5 );
    Group([ (1,2,3,4,5), (1,2,3) ])
    gap> StructureDescription( G );
    "A5"
    gap> G := SmallGroup( 768, 1000000 );
    <pc group of size 768 with 9 generators>
    gap> G := SmallGroup( [768, 1000000] );
    <pc group of size 768 with 9 generators>

##### 1.3-2 SmallGroupsAvailable

`‣ SmallGroupsAvailable`( order ) | ( function )

returns `true` if the library of groups of order order is installed, and `false` otherwise.

##### 1.3-3 AllSmallGroups

`‣ AllSmallGroups`( arg ) | ( function )

returns all groups with certain properties as specified by arg. If arg is a number \(n\), then this function returns all groups of order \(n\). However, the function can also take several arguments which then must be organised in pairs `function` and `value`. In this case the first function must be `Size` (Reference: Size) and the first value an order or a range of orders. If a value is a list then it is considered a list of possible function values to include. The function returns those groups of the specified orders having those properties specified by the remaining functions and their values.

Some selection criteria are indexed: their value follows from the position a group has in the library, so a selection using only such criteria constructs no group at all. Any other criterion is checked group by group, at a cost proportional to the number of groups of the given orders.

For the orders whose factorisation has more than three prime factors, `IsNilpotentGroup` (Reference: IsNilpotentGroup), `IsSupersolvableGroup` (Reference: IsSupersolvableGroup) and `IsSolvableGroup` (Reference: IsSolvableGroup) are indexed, except `IsSupersolvableGroup` (Reference: IsSupersolvableGroup) for the cubefree orders above \(2000\) which are not squarefree, and so is `IsAbelian` (Reference: IsAbelian), except for \(p^5\) with \(p \geq 7\). For the prime powers \(p^n\) with \(n \geq 4\), `RankPGroup` (Reference: RankPGroup) is indexed except for \(p^6\) with \(p \geq 11\) and for \(7^7\) and \(11^7\), and `PClassPGroup` (Reference: PClassPGroup) except for those and for \(p^4\) with \(p \geq 11\) and \(p^5\) with \(p \geq 7\). `LGLength` (Reference: LGLength), `FrattinifactorSize` and `FrattinifactorId` are indexed for the orders of at most \(2000\) with more than three prime factors, except \(512\), \(768\), \(1024\), \(1152\), \(1536\), \(1920\) and \(p^n \cdot q > 1000\) with \(n > 2\).

Orders with at most three prime factors are not indexed; no such order below \(50000\) has more than 13 groups.

`SmallGroupsInformation` (1.3-12) reports which criteria are indexed for a given order.

`IdsOfAllSmallGroups` (1.3-10) returns the ids of these groups instead of the groups themselves, and `NumberSmallGroups` (1.3-5) just their number.

    gap> AllSmallGroups( 6 );
    [ <pc group of size 6 with 2 generators>,
      <pc group of size 6 with 2 generators> ]
    gap> AllSmallGroups( 60, IsNilpotentGroup );
    [ <pc group of size 60 with 4 generators>,
      <pc group of size 60 with 4 generators> ]

##### 1.3-4 OneSmallGroup

`‣ OneSmallGroup`( arg ) | ( function )

returns one group with certain properties as specified by arg. The permitted arguments are those supported by `AllSmallGroups` (1.3-3).

    gap> G := OneSmallGroup( 6, IsAbelian );
    <pc group of size 6 with 2 generators>
    gap> StructureDescription( G );
    "C6"
    gap> G := OneSmallGroup( 6, IsAbelian, false );
    <pc group of size 6 with 2 generators>
    gap> StructureDescription( G );
    "S3"
    gap> G := OneSmallGroup( Size, [1..1000], IsSolvableGroup, false );
    Group([ (1,2,3,4,5), (1,2,3) ])

##### 1.3-5 NumberSmallGroups

`‣ NumberSmallGroups`( order[, func1, val1, ...] ) | ( function )

`‣ NrSmallGroups`( order[, func1, val1, ...] ) | ( function )

returns the number of groups of order order.

    gap> NumberSmallGroups( 512 );
    10494213
    gap> NumberSmallGroups( 2^8 * 23 );
    1083472
    gap> NumberSmallGroups( 4096 );
    Error, the library of groups of size 4096 is not available

The function also accepts the arguments of `AllSmallGroups` (1.3-3) and counts the groups that function would return.

    gap> NumberSmallGroups( [ 1 .. 100 ] );
    1048
    gap> NumberSmallGroups( 96, IsAbelian );
    7

Orders alone are answered from the numbers of groups. Otherwise the cost is that of `IdsOfAllSmallGroups` (1.3-10): the indexed criteria are applied first, whatever order the criteria are given in, and only the groups a remaining criterion must be tested on are constructed.

##### 1.3-6 NumberSmallGroupsAvailable

`‣ NumberSmallGroupsAvailable`( order ) | ( function )

returns `true` if the number of groups of order order is known, and `false` otherwise.

    gap> NumberSmallGroupsAvailable( 100 );
    true
    gap> NumberSmallGroups( 100 );
    16
    gap> NumberSmallGroupsAvailable( 4096 );
    false
    gap> NumberSmallGroups( 4096 );
    Error, the library of groups of size 4096 is not available

##### 1.3-7 SelectSmallGroups

`‣ SelectSmallGroups`( argl, all, id ) | ( function )

universal function for `AllSmallGroups`, `OneSmallGroup` and `IdsOfAllSmallGroups`.

##### 1.3-8 IdSmallGroup

`‣ IdSmallGroup`( G ) | ( attribute )

`‣ IdGroup`( G ) | ( attribute )

returns the library number of G; that is, the function returns a pair `[order, i]` where G is isomorphic to `SmallGroup( order, i )`.

    gap> IdSmallGroup( GL( 2,3 ) );
    [ 48, 29 ]
    gap> IdSmallGroup( Group( (1,2,3,4),(4,5) ) );
    [ 120, 34 ]

##### 1.3-9 IdGroupsAvailable

`‣ IdGroupsAvailable`( order ) | ( function )

returns `true` if the identification routines for groups of order order are installed, and `false` otherwise.

##### 1.3-10 IdsOfAllSmallGroups

`‣ IdsOfAllSmallGroups`( arg ) | ( function )

similar to `AllSmallGroups` but returns ids instead of groups. This may prevent workspace overflows if a large number of groups are expected in the output.

    gap> IdsOfAllSmallGroups( 60, IsNilpotentGroup );
    [ [ 60, 4 ], [ 60, 13 ] ]
    gap> IdsOfAllSmallGroups( 60, IsNilpotentGroup, false );
    [ [ 60, 1 ], [ 60, 2 ], [ 60, 3 ], [ 60, 5 ], [ 60, 6 ], [ 60, 7 ],
      [ 60, 8 ], [ 60, 9 ], [ 60, 10 ], [ 60, 11 ], [ 60, 12 ] ]
    gap> IdsOfAllSmallGroups( 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 ] ]

##### 1.3-11 IdGap3SolvableGroup

`‣ IdGap3SolvableGroup`( G ) | ( attribute )

`‣ Gap3CatalogueIdGroup`( G ) | ( attribute )

returns the catalogue number of G in the GAP 3 catalogue of solvable groups; that is, the function returns a pair `[order, i]` meaning that G is isomorphic to the group `SolvableGroup( order, i )` in GAP 3.

##### 1.3-12 SmallGroupsInformation

`‣ SmallGroupsInformation`( order ) | ( function )

prints information on the groups of the specified order.

    gap> SmallGroupsInformation( 32 );

      There are 51 groups of order 32.
      They are sorted by their ranks.
         1 is cyclic.
         2 - 20 have rank 2.
         21 - 44 have rank 3.
         45 - 50 have rank 4.
         51 is elementary abelian.

      The following selection criteria are indexed for this size:
         IsAbelian, IsNilpotentGroup, IsSupersolvableGroup, IsSolvableGroup,
         PClassPGroup, RankPGroup, FrattinifactorSize and FrattinifactorId.

      This size belongs to layer 2 of the SmallGroups library.
      IdSmallGroup is available for this size.

##### 1.3-13 SmallGroupsAddLayer

`‣ SmallGroupsAddLayer`( desc ) | ( function )

adds a further layer to the library, described by the record desc. Its groups then become available through `SmallGroup` (1.3-1), `NumberSmallGroups` (1.3-5), `AllSmallGroups` (1.3-3) and the other functions of this chapter. The components of desc are:

`name`

  a string naming the layer. Must be unique. Can be used by other layers to refer to this one.

`available`

  a function taking an order and either returning `fail`, to indicate this layer does not handle the given order; or else a record which is handed to the functions below as inforec. The component `number` of the returned record, if present, is the number of groups of that order.

`group`

  a function `( order, i, inforec )` returning the i-th group of that order.

`idAvailable`

  optional, a function taking an order and either returning `fail`, to indicate this layer does not handle identification of groups of the given order; or else a record which is handed to the function `id` below as idrec. Defaults to `available`, so it is only needed where the identification covers other orders than the construction, or wants a record of its own. If `idAvailable` is defined then `id` must also be provided.

`id`

  optional, a function `( G, idrec )` returning the index of G among the groups of its order. Without it `IdSmallGroup` (1.3-8) stays unavailable for these orders.

`number`

  optional, a function `( order, inforec )` returning the number of groups of that order. Only needed if `available` does not report this count.

`information`

  optional, a function `( order, inforec, number )` printing what `SmallGroupsInformation` (1.3-12) should say about that order beyond the number of groups.

`properties`

  optional, a function `( order, inforec )` reporting which selection criteria the `select` and `count` functions of this layer can deduce from the position of the groups alone, so that `SelectSmallGroups` (1.3-7) and `NumberSmallGroups` (1.3-5) need not construct the groups to decide these criteria.

`select`, `count`

  optional, how `SelectSmallGroups` (1.3-7) and `NumberSmallGroups` (1.3-5) are to work through this layer. By default the groups of the order are constructed one by one and tested.

`before`, `after`

  optional lists of names of other layers, to be consulted after respectively before this one. A name that is not registered is ignored, so wishing about a package that is not loaded does no harm. The layers of this package are themselves one layer, named `"SmallGrp"`, which without a wish to the contrary comes first.

Where two layers cover an order, the one consulted first wins.

    SmallGroupsAddLayer( rec(
        name := "SOTGrps",
        available := function( order )
            if not IsSOTAvailable( order ) then
                return fail;
            fi;
            return rec( number := NumberOfSOTGroups( order ) );
        end,
        group := { order, i, inforec } -> SOTGroup( order, i ),
        id := { G, inforec } -> IdSOTGroup( G )[2] ) );

##### 1.3-14 UnloadSmallGroupsData

`‣ UnloadSmallGroupsData`( ) | ( function )

GAP loads all necessary data from the library automatically, but it does not delete the data from the workspace again. Usually, this will not be necessary, since the data is stored in a compressed format. However, if a large number of groups from the library have been loaded, then the user might wish to remove the data from the workspace and this can be done by the above function call.

    gap> UnloadSmallGroupsData();

##### 1.3-15 SMALL_GROUPS_OLD_ORDER

`‣ SMALL_GROUPS_OLD_ORDER` | ( global variable )

If set to `true`, then groups of order \(3^7\), \(5^7\), \(7^7\), and \(11^7\) are ordered in the way they were ordered up to version 1.0 of the package. If this variable is set to `false`, which is the default as of version 1.4, then a different ordering, that agrees with the one in Magma version 2.23, is used. The functions `SMALLGP_PERM`\(x\), with \(x=3,5,7,11\), give the old index position corresponding to a new index position. In releases 1.1-1.3 a misunderstood ordering, based on the old ordering and the permutations \((2,30083)(3,30084)(4,30085)(5,30086)\), \((2,104599)(3,104600)(4,104601)(5,104602)\), and \((2,721053)(3,721054)(4,721055)(5,721056)\) respectively, was used.

[Top of Book] [Contents] [Previous Chapter] [Next Chapter]
Goto Chapter: Top 1 2 Bib Ind

generated by GAPDoc2HTML