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

Available groups

The orders for which the SmallGroup function can be called are given below. See also AllSmallGroups.

Description	List of orders	Additional comments
$2^{n}, 1 \leq n \leq 9$	$2, 4, 8, 16, 32, 64, 128, 256, 512$	For orders $256 = 2^{8}$ and $512 = 2^{9}$ , the default memory allocation provided by GAP is too small to manipulate the list of groups. A command line option `-o 2G' is is usually enough for most simple manipulations involving the groups of orders 256 and 512. Also, to avoid wasteful printing of long output lists, use a double semicolon for output suppression.
$p^{n}, 1 \leq n \leq 6$ , $p$ prime	(infinite list)	For $n = 5$ and $n = 6$ , the number of groups depends on $p$ . As $p$ gets larger, additional memory allocation is needed.
$p^{7}, p = 3, 5, 7, 11$	$3^{7} = 2187, 5^{7} = 78125, 7^{7} = 823543, 1 1^{7} = 19487171$	This is not available in the version of the library that came with GAP 4.4.12. The new version with these groups can be downloaded from here
cube-free number less than $50000 = 5 \cdot 1 0^{4}$	Too long to list
order $p q^{n}$ , $p, q$ distinct primes, and $q^{n}$ divides one of these: $2^{8}, 3^{6}, 5^{5}, 7^{4}$	(infinite list)
square-free number	(infinite list)
order factorizes into at most 3 primes counting multiplicities	(infinite list)	Note here that "at most 3 primes" counts primes with multiplicity, so $p^{3} q^{2} r^{4}$ does not qualify.

The smallest orders for which the SmallGroups library does not have information are given in the table below:

Number	Prime factorization
1024	$2^{10}$
2016	$2^{5} \cdot 2^{3} \cdot 7$
2024	$2^{3} \cdot 11 \cdot 23$
2025	$3^{4} \cdot 5^{2}$
2040	$2^{3} \cdot 3 \cdot 5 \cdot 17$

Related functions

Aggregative functions

GAP:SmallGroupsInformation: Takes a single input $a$ and prints out verbal summary information on the groups of order $a$ .
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. Note that IdGroup is not available for some of the groups that have group IDs, specifically, groups of order 512, 1536, and those of order $p^{5}, p^{6}, p^{7}$ when the corresponding value is bigger than $2000$ (with the exception of $5^{5} = 3125$ ).

Examples of usage

Single command examples

Here are some examples:

gap> SmallGroup(1,1);
<pc group of size 1 with 0 generators>
gap> IsTrivial(SmallGroup(1,1));
true
gap> SmallGroup(3,1);
<pc group of size 3 with 1 generators>

Below is an explanation:

Command	GAP output/print	Other GAP functions used	Explanation
`SmallGroup(1,1);`	`<pc group of size 1 with 0 generators>`	--	The 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.
`IsTrivial(SmallGroup(1,1));`	`true`	IsTrivial	This checks whether the group constructed as `SmallGroup(1,1)` is the trivial group. It is.
`SmallGroup(3,1);`	`<pc group of size 3 with 1 generators>`	--	This constructs the the cyclic group on three elements. Here, there is $1$ generator.

Error message examples

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
brk> quit;
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

Command	Error message	Explanation
`H := SmallGroup(3,2);`	`Error, there is just 1 group of size 3 ...`	The 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.
`SmallGroup(1024,1);`	`Error, the library of groups of size 1024 is not available ...`	The error message says that the order 1024 is not part of GAP's SmallGroup library.

Typical command sequences using `SmallGroup`

gap> G := SmallGroup(6,2);
<pc group of size 6 with 2 generators>
gap> G = CyclicGroup(6);
false
gap> IsomorphismGroups(G,CyclicGroup(6));
[ f1, f2 ] -> [ f1*f2, f2 ]

Command	GAP output/print	Other GAP functions used	Explanation
`G := SmallGroup(6,2);`	`<pc group of size 6 with 2 generators>`	--	This 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.
`G = CyclicGroup(6);`	`false`	CyclicGroup	This asks whether $G$ is equal, as the group is stored, to the cyclic group of order 6. The answer of false simply indicates that they are not equal in a literal sense, though as the next command shows, they are isomorphic groups.
`IsomorphismGroups(G,CyclicGroup(6));`	`[ f1, f2 ] -> [ f1*f2, f2 ]`	CyclicGroup, IsomorphismGroups	This tests whether the group $G$ is indeed isomorphic to the cyclic group of order six. It is, and the output specifies an isomorphism in terms of the way the groups are stored in GAP.

Here is another example:

gap> L := SmallGroup(60,5);
Group([ (1,2,3,4,5), (1,2,3) ])
gap> IsSimpleGroup(L);
true
gap> IsAlternatingGroup(L);
true

Below is an explanation:

Command	GAP output/print	Other GAP functions used	Explanation
`L := SmallGroup(60,5);`	`Group([ (1,2,3,4,5), (1,2,3) ])`		Constructs the group with GAP ID 5 among the groups of order 60. This is in fact isomorphic to alternating group:A5. Note that the group is stored using a permutation representation because it is not solvable.
`IsSimpleGroup(L);`	`true`	IsSimpleGroup	Asks if the group is a simple group. It is.
`IsAlternatingGroup(L);`	`true`	IsAlternatingGroup	Asks if the group is an alternating group. It is.

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
gap> StructureDescription(M);
"C5 x (C3 : C4)"

Below is an explanation:

Command	GAP output/print	Other GAP functions used	Explanation
`M := SmallGroup(60,1);`	`<pc group of size 60 with 4 generators>`	--	Constructs the group of GAP ID 1 among groups of order 60 and stores it as $M$ . Note that it is stored as a `PcGroup` indicating that it is solvable.
`IsCyclic(M);`	`false`	IsCyclic	Checks whether $M$ is a cyclic group. It is not.
`IsAbelian(M);`	`false`	IsAbelian	Checks whether $M$ is an abelian group. It is not.
`IsSolvable(SmallGroup(60,1));`	`true`	IsSolvable	Checks whether $M$ (not written as $M$ , but using the SmallGroup description) is solvable. It is solvable.
`StructureDescription(M);`	`"C5 x (C3 : C4)"`	StructureDescription	Provides a (partial) description of the structure of $M$ .

Definition

Function type

Behavior

Available groups

Related functions

Aggregative functions

Reverse functions

Examples of usage

Single command examples

Error message examples

Typical command sequences using SmallGroup

References

Typical command sequences using `SmallGroup`