The Database of Groups of Order up to 1000

[Next] [Prev] [_____] [Left] [Up] [Index] [Root]

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 following papers:

Hans Ulrich Besche and Bettina Eick (1998), "Construction of finite groups", J. Symbolic Comput.
Hans Ulrich Besche and Bettina Eick (1998), "The groups of order at most 1000 except 512 and 768", J. Symbolic Comput.

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 following papers, and their references:

E.A. O'Brien (1990), "The p-group generation algorithm", J. Symbolic Comput., 9, 677--698.
E.A. O'Brien (1991), "The Groups of Order 256", J. Algebra, { 143}(1), 219--235.

Subsections

Basic Small Group Functions

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.

NumberOfSmallGroups(o) : RngIntElt -> RngIntElt

Given a positive integer o <= 1000, return the number of groups of order o.

SmallGroup(o, n) : RngIntElt, RngIntElt -> Grp

Given a positive integer o <= 1000 (with o != 512 or 768) and a positive integer n, return the n-th group of order o.

SmallGroup(o: parameters) : RngIntElt -> Grp

    Search: MonStgElt                   Default: "All"

Given a positive integer o <= 1000, return the first group of order o.

SmallGroup(o, f: parameters) : RngIntElt, Program -> Grp

    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.

SmallGroup(S, f: parameters) : [RngIntElt], Program -> Grp

    Search: MonStgElt                   Default: "All"

Given a sequence S of orders and a predicate f (as a function or intrinsic), return the first group with order in S which satisfies f.

SmallGroups(o: parameters) : RngIntElt -> [* Grp *]

    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.

SmallGroups(S: parameters) : [RngIntElt] -> [* Grp *]

    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.

SmallGroups(o, f: parameters) : RngIntElt, Program -> [* Grp *]

    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.

SmallGroups(S, f: parameters) : [RngIntElt], Program -> [* Grp *]

    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.

Processes

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.

SmallGroupProcess(o: parameters) : RngIntElt -> Process

    Search: MonStgElt                   Default: "All"

Return a small group process which will iterate though all groups of order o.

SmallGroupProcess(S: parameters) : [RngIntElt] -> Process

    Search: MonStgElt                   Default: "All"

Return a small group process which will iterate though all groups with order in the sequence S.

SmallGroupProcess(o, f: parameters) : RngIntElt, Program -> Process

    Search: MonStgElt                   Default: "All"

Return a small group process which will iterate though all groups with order o which satisfy the predicate f.

SmallGroupProcess(S, f: parameters) : [RngIntElt], Program -> Process

    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.

IsEmpty(p) : Process -> BoolElt

True if the process p has passed its last group.

Current(p) : Process -> Grp

Return the current group of the process p.

CurrentLabel(p) : Process -> RngIntElt, RngIntElt

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

Advance(~p) : Process ->

Move the process p to its next group.

[Next] [Prev] [_____] [Left] [Up] [Index] [Root]