GAP:SmallGroup

This article is about a GAP function.

Definition

Function type

SmallGroup is a GAP function taking in two arguments, both of which are numbers (or, equivalently, a list of two numbers) and outputs a group.

Behavior

GAP has a built-in library of groups of given order, for small orders. All the groups of order $n$ are ordered in a certain way, and each such group has a group ID. The command:

SmallGroup(a,b);

returns the $b^{t h}$ group of order $a$ .

The following caveats should be noted:

For a finite solvable group, the group is stored as a PcGroup: in other words, it is stored in terms of a polycyclic series for the group. Thus, if the group is solvable, the command SmallGroup returns a polycyclic series.
For a finite group that is not solvable, the group is stored as a permutation group.

Error types:

If there are fewer than $b$ isomorphism classes of groups of order $a$ , GAP returns an error, specifying the number of isomorphism classes of groups of order $a$ .
If the groups of order $a$ are not stored in the library, GAP returns an error statin that the library of groups of order $a$ is not available.
If $a$ is not a positive integer, or if only one argument is provided, GAP returns a usage error.

Related functions

Aggregative functions

GAP:AllSmallGroups: Returns, in list format, all the groups of a given order, say $a$ . The $b^{t h}$ member of the list is the same as the $b^{t h}$ group of order $a$ invoked by the command SmallGroup(a,b);.
GAP:OneSmallGroup: This returns just one group of a given order. It returns the first small group. Thus, the commands OneSmallGroup(a) and SmallGroup(a,1) have the same effect.

Reverse functions

GAP:IdGroup: This takes a given group as input and outputs its group ID, i.e., an ordered pair of its order and the position it is in among the groups of that order. This is precisely the two-sided inverse of the SmallGroup function.

Examples of usage

Here are some examples:

gap> SmallGroup(1,1);
<pc group of size 1 with 0 generators>
gap> SmallGroup(3,1);
<pc group of size 3 with 1 generators>
gap> G := SmallGroup(6,2);
<pc group of size 6 with 2 generators>
gap> IsomorphismGroups(G,CyclicGroup(6));
[ f1, f2 ] -> [ f1*f2, f2 ]
gap> H := SmallGroup(3,2);
Error, there is just 1 group of size 3 called from
SMALL_GROUP_FUNCS[inforec.func]( size, i, inforec ) called from
<function>( <arguments> ) called from read-eval-loop
Entering break read-eval-print loop ...
you can 'quit;' to quit to outer loop, or
you can 'return;' to continue

The first command gives the trivial group. The output by GAP for the first command is the output provided for any PcGroup: it gives the size, and the number of generators used for the polycyclic series. In this case, the trivial group has size one and the number of generators is zero.

The second command does something similar for the cyclic group on three elements. Here, there is $1$ generator.

The third command constructs the cyclic group on six elements, and stores this group as $G$ . Note that although this group has a generating set of size one, the polycyclic series has length two; so the number of generators used in this series is two.

The fourth command verifies that this group is indeed isomorphic to the cyclic group of order six, using GAP:IsomorphismGroups.

The fifth command tries to construct the second group of order three. But there is only one group of order three, and GAP returns the relevant error.

Here are some more examples:

gap> L := SmallGroup(60,5);
Group([ (1,2,3,4,5), (1,2,3) ])
gap> IsSimpleGroup(L);
true
gap> M := SmallGroup(60,1);
<pc group of size 60 with 4 generators>
gap> IsCyclic(M);
false
gap> IsAbelian(M);
false
gap> IsSolvable(SmallGroup(60,1));
true

The first command assigns to the variable $L$ the fifth group of order $60$ . Note that this group is returned in the form of a permutation representation; the reason is that this group is not solvable. The next command tests whether this group is simple.

Next, $M$ is assigned as the first group of order $60$ , and subsequent commands test whether $M$ is cyclic, Abelian and solvable. It turns out that $M$ is neither cyclic nor Abelian but is solvable. This matches up with the fact that $M$ is described as a PcGroup.

Here are some further usage examples:

gap> SmallGroup(1024,1);
Error, the library of groups of size 1024 is not available called from
<function>( <arguments> ) called from read-eval-loop
Entering break read-eval-print loop ...
you can 'quit;' to quit to outer loop, or
you can 'return;' to continue
brk> SmallGroup(1025,1);
<pc group of size 1025 with 3 generators>

This example shows that the GAP library often does not contain the collection of groups of a given order but may contain the collection of groups of higher order. This is usually dependent on the number and complexity of groups of particular orders: numbers that are products of primes of very short length usually admit few groups and are likely to be in the GAP library.