Magma includes a library of all groups having order at most 1000, excepting orders 512 and 768. This library was prepared by Bettina Eick and Hans Ulrich Besche in 1997 using GAP. The algorithms used to generate the groups and details on their implementations and applications are described in the papers of Besche & Eick [BE99a], [BE99b].
The Small Groups library incorporates *directly* the libraries of 2-groups of order dividing 256 and the 3-groups of order dividing 729, which were prepared and distributed at various intervals by M.F. Newman and E.A. O'Brien and various assistants, the first release dating from 1987. The relative ordering of the p-groups adopted by Newman and O'Brien has been retained.
Details of the algorithms used to generate these libraries are provided in the papers of O'Brien [O'B90], [O'B91], and their references.
Many of the functions in this section have an optional parameter Search. It can be used to limit the small group search to soluble (Search := "Soluble") or insoluble (Search := "Insoluble") groups. The default is Search := "All", which allows all groups to be considered.
When a group is extracted from the database, it is returned as a GrpPC if it is soluble, or as a GrpPerm if it is insoluble.
When using the small groups database for an extended search, it is advisable to open the database using the SmallGroupDatabase function, which returns the database. This can then be passed as first argument to many of the functions described below, and will save that function from opening and closing the database for itself. This will reduce the number of file operations when a lot of use is made of the database. The companion procedure CloseSmallGroupDatabase may be used to close the database when it is of no further use in a session.
Open the small groups database (for extended search) and return a reference to it. This reference may be passed to other functions so that they do fewer file operations.
Close the small groups database which was returned by SmallGroupDatabase, and free the resources associated with its use.
The limiting order of the database of small groups.
Given a positive integer o <= 1000, return the number of groups of order o.
Given a positive integer o <= 1000 (with o != 512 or 768) and a positive integer n, return the n-th group of order o.
Search: MonStgElt Default: "All"
Given a positive integer o <= 1000, return the first group of order o.
Search: MonStgElt Default: "All"
Given a positive integer o <= 1000 and a predicate f (as a function or intrinsic), return the first group of order o which satisfies f.
Return true iff SmallGroup(o, n) is insoluble. This function does not load the group.
Return true iff SmallGroup(o, n) is soluble. This function does not load the group.
Search: MonStgElt Default: "All"
Given a sequence S of orders, or a single order o, and a predicate f (as a function or intrinsic), return the first group with order in S (or equal to o) which satisfies f.
Search: MonStgElt Default: "All"
Warning: BoolElt Default: true
Return a sequence of all groups of order o. Some orders will produce a very large sequence of groups -- in such cases a warning will be printed unless the user specifies Warning := false.
Search: MonStgElt Default: "All"
Warning: BoolElt Default: true
Given a sequence S of orders, return a sequence of all groups with order in S. The resulting sequence may be very long -- in such cases a warning will be printed unless the user specifies Warning := false.
Search: MonStgElt Default: "All"
Given an integer o and a predicate (function or intrinsic) f, return a sequence containing all groups G of order o satisfying f(G) eq true.
Search: MonStgElt Default: "All"
Given a sequence S of orders and a predicate (function or intrinsic) f, return a sequence containing all groups G with order in S satisfying f(G) eq true.
> list := SmallGroups(27, func<x|not IsAbelian(x)> ); > list; [* GrpPC of order 27 = 3^3 PC-Relations: $.2^$.1 = $.2 * $.3, GrpPC of order 27 = 3^3 PC-Relations: $.1^3 = $.3, $.2^$.1 = $.2 * $.3 *]We get the first group in the database with derived length greater than 2.
> G := SmallGroup([1..100], func<x|DerivedLength(x) gt 2>); > G; GrpPC of order 24 = 2^3 * 3 PC-Relations: G.1^3 = Id(G), G.2^2 = G.4, G.3^2 = G.4, G.4^2 = Id(G), G.2^G.1 = G.3, G.3^G.1 = G.2 * G.3, G.3^G.2 = G.3 * G.4Now for a list of the insoluble groups of order 240. The insoluble groups in the database are returned as permutation groups.
> list := SmallGroups(240:Search:="Insoluble"); > #list; 8 > list[7]; Permutation group acting on a set of cardinality 7 (1, 2, 3, 4) (1, 5, 2, 4, 3)(6, 7)
A small group process enables iteration over all groups of specified orders satisfying a given predicate, without having to create and store all such groups together.
A small group process is created via the function SmallGroupProcess (in various forms). The standard process functions IsEmpty, Current, CurrentLabel and Advance can then be applied to the process.
The functions used to create a small group process all have a parameter Search attached to them. It can be used to limit the small group search to soluble (Search := "Soluble") or insoluble (Search := "Insoluble") groups. The default is Search := "All", which allows all groups to be considered.
The Process functions described below do not have a variant with the database as first argument, as each process opens the database for an extended search automatically.
Search: MonStgElt Default: "All"
Return a small group process which will iterate though all groups of order o.
Search: MonStgElt Default: "All"
Return a small group process which will iterate though all groups with order in the sequence S.
Search: MonStgElt Default: "All"
Return a small group process which will iterate though all groups with order o which satisfy the predicate f.
Search: MonStgElt Default: "All"
Return a small group process which will iterate though all groups with order in the sequence S which satisfy the predicate f.
True if the process p has passed its last group.
Return the current group of the process p.
Return the label of the current group of the process p. That is, return o and n such that the current group is SmallGroup(o, n).
Move the process p to its next group.
> P := SmallGroupProcess(128);
> count := {* *};
> repeat
> G := Current(P);
> Include( count, NilpotencyClass(G));
> Advance( P);
> until IsEmpty(P);
> count;
{* 1^^15, 2^^947, 3^^1137, 4^^197, 5^^29, 6^^3 *}
The following functions perform the inverse operation to the small group functions described earlier. Given a group such that a group isomorphic to it is in the database, the identification functions return a pair < o, n > so that SmallGroup(o, n) is isomorphic to the original group.
Locate the pair of integers < o, n > so that SmallGroup(o, n) is isomorphic to G. If there is no such group in the database, then an error will result.
> G := DihedralGroup(10);
> G;
Permutation group G acting on a set of cardinality 10
Order = 20 = 2^2 * 5
(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
(1, 10)(2, 9)(3, 8)(4, 7)(5, 6)
> IdentifyGroup(G);
<20, 4>
> H := SmallGroup(20, 4);
> H;
GrpPC : H of order 20 = 2^2 * 5
PC-Relations:
H.1^2 = Id(H),
H.2^2 = Id(H),
H.3^5 = Id(H),
H.3^H.1 = H.3^4