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-14). 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].
Several other GAP packages give access to groups of orders which are not covered by this library, or which are covered only in part.
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\). Unlike SglPPow, it does not extend this library: it comes with its own functions SOTGroup, AllSOTGroups and IdSOTGroup. 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/.
‣ 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>
‣ SmallGroupsAvailable( order ) | ( function ) |
returns true if the library of groups of order order is installed, and false otherwise.
‣ 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> ]
‣ 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) ])
‣ 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.
‣ 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
‣ SelectSmallGroups( argl, all, id ) | ( function ) |
universal function for AllSmallGroups, OneSmallGroup and IdsOfAllSmallGroups.
‣ 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 ]
‣ IdGroupsAvailable( order ) | ( function ) |
returns true if the identification routines for groups of order order are installed, and false otherwise.
‣ 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 ] ]
‣ 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.
‣ 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.
‣ 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();
‣ 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.
generated by GAPDoc2HTML