Groups of order 5^n

Number of groups of small orders

Exponent $n$	Value $5^{n}$	Number of groups of order $5^{n}$	List, information	Comparison with other primes, i.e., groups of order $p^{n}$
1	5	1	only cyclic group:Z5; see equivalence of definitions of group of prime order	See group of prime order
2	25	2	cyclic group:Z25 and elementary abelian group:E25; see also groups of order 25	groups of prime-square order, classification of groups of prime-square order
3	125	5	groups of order 125	groups of prime-cube order, classification of groups of prime-cube order
4	625	15	groups of order 625	groups of prime-fourth order, classification of groups of prime-fourth order for odd prime
5	3125	77	groups of order 3125	groups of prime-fifth order, see also Higman's PORC conjecture
6	15625	684	groups of order 15625	groups of prime-sixth order, see also Higman's PORC conjecture
7	78125	34297	groups of order 78125	groups of prime-seventh order, see also Higman's PORC conjecture

Arithmetic functions

In the tables here, a row value of $n$ means we are looking at the groups of order $5^{n}$. The entry in a cell is the number of isomorphism classes of groups of order $5^{n}$ for which the function takes the value indicated in the column. Note that, for greater visual clarity, all zeros that occur after the last nonzero entry in a row are omitted and the corresponding entry is left blank.

Nilpotency class

$n$	$5^{n}$	total number of groups	class 0	class 1	class 2	class 3	class 4	class 5	class 6
0	1	1	1
1	5	1	0	1
2	25	2	0	2
3	125	5	0	3	2
4	625	15	0	5	6	4
5	3125	77	0	7	30	31	9
6	15625	684	0	11	149	386	99	39
7	78125	34297	0	15	7069	22652	3274	1188	99

Here is the GAP code to generate this information: [SHOW MORE]

We use the function SortArithmeticFunctionSizes, which is not in-built but is easy to code (follow link to get code). We also use the in-built function NilpotencyClassOfGroup. Using these, we get:

gap> SortArithmeticFunctionSizes(5,0,NilpotencyClassOfGroup);
[ [ 0, 1 ] ]
gap> SortArithmeticFunctionSizes(5,1,NilpotencyClassOfGroup);
[ [ 0, 0 ], [ 1, 1 ] ]
gap> SortArithmeticFunctionSizes(5,2,NilpotencyClassOfGroup);
[ [ 0, 0 ], [ 1, 2 ], [ 2, 0 ] ]
gap> SortArithmeticFunctionSizes(5,3,NilpotencyClassOfGroup);
[ [ 0, 0 ], [ 1, 3 ], [ 2, 2 ], [ 3, 0 ] ]
gap> SortArithmeticFunctionSizes(5,4,NilpotencyClassOfGroup);
[ [ 0, 0 ], [ 1, 5 ], [ 2, 6 ], [ 3, 4 ], [ 4, 0 ] ]
gap> SortArithmeticFunctionSizes(5,5,NilpotencyClassOfGroup);
[ [ 0, 0 ], [ 1, 7 ], [ 2, 30 ], [ 3, 31 ], [ 4, 9 ], [ 5, 0 ] ]
gap> SortArithmeticFunctionSizes(5,6,NilpotencyClassOfGroup);
[ [ 0, 0 ], [ 1, 11 ], [ 2, 149 ], [ 3, 386 ], [ 4, 99 ], [ 5, 39 ], [ 6, 0 ]
 ]
gap> SortArithmeticFunctionSizes(5,7,NilpotencyClassOfGroup);
[ [ 0, 0 ], [ 1, 15 ], [ 2, 7069 ], [ 3, 22652 ], [ 4, 3274 ], [ 5, 1188 ], [ 6, 99 ], [ 7, 0 ] ]

Note that for the $5^{7}$ case, the new version of the SmallGroup library (obtain here) is needed, and additional memory may need to be allocated using the command line option `-o' (e.g., gap -o 5G).

Here is the same information, now given in terms of the fraction of groups of a given order that are of a given nilpotency class. For ease of comparison, all fractions are written as decimals, rounded to the fourth decimal place.

$n$	$5^{n}$	total number of groups	class 0	class 1	class 2	class 3	class 4	class 5	class 6
0	1	1	1
1	5	1	0	1
2	25	2	0	1
3	125	5	0	0.6000	0.4000
4	625	15	0	0.3333	0.4000	0.2667
5	3125	77	0	0.0909	0.3896	0.4026	0.1169
6	15625	684	0	0.0161	0.2178	0.5643	0.1447	0.5702
7	78125	34297	0	0.0044	0.2063	0.6605	0.0955	0.0346	0.0289

Derived length

$n$	$5^{n}$	total number of groups	length 0	length 1	length 2	length 3
0	1	1	1
1	5	1	0	1
2	25	2	0	2
3	125	5	0	3	2
4	625	15	0	5	10
5	3125	77	0	7	70
6	15625	684	0	11	657	16
7	78125	34297	0	15	33427	855

Here is the GAP code to generate this information: [SHOW MORE]

We use the function SortArithmeticFunctionSizes, which is not in-built but is easy to code (follow link to get code). We also use the in-built function DerivedLength. Using these, we get:

gap> SortArithmeticFunctionSizes(5,0,NilpotencyClassOfGroup);
[ [ 0, 1 ] ]
gap> SortArithmeticFunctionSizes(5,0,DerivedLength);
[ [ 0, 1 ] ]
gap> SortArithmeticFunctionSizes(5,1,DerivedLength);
[ [ 0, 0 ], [ 1, 1 ] ]
gap> SortArithmeticFunctionSizes(5,2,DerivedLength);
[ [ 0, 0 ], [ 1, 2 ], [ 2, 0 ] ]
gap> SortArithmeticFunctionSizes(5,3,DerivedLength);
[ [ 0, 0 ], [ 1, 3 ], [ 2, 2 ], [ 3, 0 ] ]
gap> SortArithmeticFunctionSizes(5,4,DerivedLength);
[ [ 0, 0 ], [ 1, 5 ], [ 2, 10 ], [ 3, 0 ], [ 4, 0 ] ]
gap> SortArithmeticFunctionSizes(5,5,DerivedLength);
[ [ 0, 0 ], [ 1, 7 ], [ 2, 70 ], [ 3, 0 ], [ 4, 0 ], [ 5, 0 ] ]
gap> SortArithmeticFunctionSizes(5,6,DerivedLength);
[ [ 0, 0 ], [ 1, 11 ], [ 2, 657 ], [ 3, 16 ], [ 4, 0 ], [ 5, 0 ], [ 6, 0 ] ]
gap> SortArithmeticFunctionSizes(5,7,DerivedLength);
[ [ 0, 0 ], [ 1, 15 ], [ 2, 33427 ], [ 3, 855 ], [ 4, 0 ], [ 5, 0 ], [ 6, 0 ], [ 7, 0 ] ]

Note that for the $5^{7}$ case, the new version of the SmallGroup library (obtain here) is needed, and additional memory may need to be allocated using the command line option `-o' (e.g., gap -o 5G).

Here is the same information, now given in terms of the fraction of groups of a given order that are of a given derived length. For ease of comparison, all fractions are written as decimals, rounded to the fourth decimal place.

$n$	$5^{n}$	total number of groups	length 0	length 1	length 2	length 3
0	1	1	1
1	5	1	0	1
2	25	2	0	1
3	125	5	0	0.6000	0.4000
4	625	15	0	0.3333	0.6667
5	3125	77	0	0.0909	0.9091
6	15625	684	0	0.0161	0.9605	0.0234
7	78125	34297	0	0.0044	0.9746	0.0249

Frattini length

$n$	$5^{n}$	total number of groups	length 0	length 1	length 2	length 3	length 4	length 5	length 6
0	1	1	1
1	5	1	0	1
2	25	2	0	1	1
3	125	5	0	1	3	1
4	625	15	0	1	11	2	1
5	3125	77	0	1	62	11	2	1
6	15625	684	0	1	546	122	12	2	1

Here is the GAP code to generate this information: [SHOW MORE]

We use the functions SortArithmeticFunctionSizes and FrattiniLength, which is not in-built but is easy to code (follow link to get code). Using these, we get:

gap> SortArithmeticFunctionSizes(5,0,FrattiniLength);
[ [ 0, 1 ] ]
gap> SortArithmeticFunctionSizes(5,1,FrattiniLength);
[ [ 0, 0 ], [ 1, 1 ] ]
gap> SortArithmeticFunctionSizes(5,2,FrattiniLength);
[ [ 0, 0 ], [ 1, 1 ], [ 2, 1 ] ]
gap> SortArithmeticFunctionSizes(5,3,FrattiniLength);
[ [ 0, 0 ], [ 1, 1 ], [ 2, 3 ], [ 3, 1 ] ]
gap> SortArithmeticFunctionSizes(5,4,FrattiniLength);
[ [ 0, 0 ], [ 1, 1 ], [ 2, 11 ], [ 3, 2 ], [ 4, 1 ] ]
gap> SortArithmeticFunctionSizes(5,5,FrattiniLength);
[ [ 0, 0 ], [ 1, 1 ], [ 2, 62 ], [ 3, 11 ], [ 4, 2 ], [ 5, 1 ] ]
gap> SortArithmeticFunctionSizes(5,6,FrattiniLength);
[ [ 0, 0 ], [ 1, 1 ], [ 2, 546 ], [ 3, 122 ], [ 4, 12 ], [ 5, 2 ], [ 6, 1 ] ]