Arithmetic functions for groups of order 2^n

This article gives specific information, namely, arithmetic functions, about a family of groups, namely: groups of order 2^n.
View arithmetic functions for group families | View other specific information about groups of order 2^n

Summary

Below is a summary of the behavior of the average values for important arithmetic functions, where the average is computed by equally weighting all isomorphism classes of groups of that order:

$n$	$2^{n}$	number of groups	nilpotency class	derived length	prime-base logarithm of exponent	Frattini length	minimum size of generating set
0	1	1	0	0	0	0	0
1	2	1	1	1	1	1	1
2	4	2	1	1	1.5	1.5	1.5
3	8	5	1.4	1.4	2	2	2
4	16	14	1.8571	1.6429	2.4286	2.4286	2.3571
5	32	51	2.2745	1.8627	2.6471	2.6471	2.7451
6	64	267	2.5843	1.9588	2.7828	2.7903	3.1124
7	128	2328	2.6937	1.9996	2.7637	2.7668	3.5833
8	256	56092	2.4941	2.0069	?	?	?

Below is a summary of the behavior of the average values where the groups are weighted by the cohomology tree probability distribution:

$n$	$2^{n}$	number of groups	nilpotency class	derived length	prime-base logarithm of exponent	Frattini length	minimum size of generating set
0	1	1	0	0	0	0	0
1	2	1	1	1	1	1	1
2	4	2	1	1	1.5	1.5	1.5
3	8	5	1.25	1.25	2.1875	?	1.8125
4	16	14	1.6172	1.5234	2.6865	?	2.0322
5	32	51	1.9889	1.7728	3.1426	?	2.2039
6	64	267	2.3329	1.8467	3.5342	?	2.3288

In the tables below, a row value of $n$ means we are looking at the groups of order $2^{n}$. The entry in a cell is the number of isomorphism classes of groups of order $2^{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.

Distributions for individual arithmetic functions

Nilpotency class

$n$	$2^{n}$	total number of groups	class 0	class 1	class 2	class 3	class 4	class 5	class 6	class 7
0	1	1	1
1	2	1	0	1
2	4	2	0	2
3	8	5	0	3	2
4	16	14	0	5	6	3
5	32	51	0	7	26	15	3
6	64	267	0	11	117	114	22	3
7	128	2328	0	15	947	1137	197	29	3
8	256	56092	0	22	31742	21325	2642	320	38	3

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 functions, the above data can be generated as follows:

gap> SortArithmeticFunctionSizes(2,0,NilpotencyClassOfGroup);
[ [ 0, 1 ] ]
gap> SortArithmeticFunctionSizes(2,1,NilpotencyClassOfGroup);
[ [ 0, 0 ], [ 1, 1 ] ]
gap> SortArithmeticFunctionSizes(2,2,NilpotencyClassOfGroup);
[ [ 0, 0 ], [ 1, 2 ], [ 2, 0 ] ]
gap> SortArithmeticFunctionSizes(2,3,NilpotencyClassOfGroup);
[ [ 0, 0 ], [ 1, 3 ], [ 2, 2 ], [ 3, 0 ] ]
gap> SortArithmeticFunctionSizes(2,4,NilpotencyClassOfGroup);
[ [ 0, 0 ], [ 1, 5 ], [ 2, 6 ], [ 3, 3 ], [ 4, 0 ] ]
gap> SortArithmeticFunctionSizes(2,5,NilpotencyClassOfGroup);
[ [ 0, 0 ], [ 1, 7 ], [ 2, 26 ], [ 3, 15 ], [ 4, 3 ], [ 5, 0 ] ]
gap> SortArithmeticFunctionSizes(2,6,NilpotencyClassOfGroup);
[ [ 0, 0 ], [ 1, 11 ], [ 2, 117 ], [ 3, 114 ], [ 4, 22 ], [ 5, 3 ], [ 6, 0 ] ]
gap> SortArithmeticFunctionSizes(2,7,NilpotencyClassOfGroup);
[ [ 0, 0 ], [ 1, 15 ], [ 2, 947 ], [ 3, 1137 ], [ 4, 197 ], [ 5, 29 ], [ 6, 3 ], [ 7, 0 ] ]
gap> SortArithmeticFunctionSizes(2,8,NilpotencyClassOfGroup);
[ [ 0, 0 ], [ 1, 22 ], [ 2, 31742 ], [ 3, 21325 ], [ 4, 2642 ], [ 5, 320 ], [ 6, 38 ], [ 7, 3 ], [ 8, 0 ] ]

Although the command can in principle be run for $2^{8}$, it requires a huge memory allocation (this can be controlled setting the "-o" command line option when starting GAP). To obtain the result for $2^{8}$, it is best to split the list of all small groups of order $2^{8}$ into sub-lists and run the function on each.

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$	$2^{n}$	total number of groups	average of values (equal weighting on all groups)	class 0	class 1	class 2	class 3	class 4	class 5	class 6	class 7
0	1	1	0	1
1	2	1	1	0	1
2	4	2	1	0	1
3	8	5	1.4	0	0.6000	0.4000
4	16	14	1.8571	0	0.3571	0.4286	0.2143
5	32	51	2.2745	0	0.1373	0.5098	0.2941	0.0588
6	64	267	2.5843	0	0.0412	0.4382	0.4270	0.0824	0.0112
7	128	2328	2.6937	0	0.0064	0.4068	0.4884	0.0846	0.01245	0.0013
8	256	56092	2.4941	0	0.0004	0.5659	0.3802	0.0471	0.0057	0.0007	0.0001

Below is the information for the probability distribution by nilpotency class using the cohomology tree probability distribution:

$n$	$2^{n}$	total number of groups	weighted average nilpotency class under the distribution	class 0	class 1	class 2	class 3	class 4	class 5	class 6	class 7
0	1	1	0	1
1	2	1	1	0	1
2	4	2	1	0	1
3	8	5	1.25	0	0.7500	0.2500
4	16	14	1.6172	0	0.4766	0.4297	0.0938
5	32	51	1.9889	0	0.2772	0.4684	0.2427	0.0117
6	64	267	2.3329	0	0.1533	0.4231	0.3623	0.0598	0.0015

Derived length

$n$	$2^{n}$	total number of groups	length 0	length 1	length 2	length 3
0	1	1	1
1	2	1	0	1
2	4	2	0	2
3	8	5	0	3	2
4	16	14	0	5	9
5	32	51	0	7	44
6	64	267	0	11	256
7	128	2328	0	15	2299	14
8	256	56092	0	22	55660	410

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 functions, the above data can be generated as follows:

gap> SortArithmeticFunctionSizes(2,0,DerivedLength);
[ [ 0, 1 ] ]
gap> SortArithmeticFunctionSizes(2,1,DerivedLength);
[ [ 0, 0 ], [ 1, 1 ] ]
gap> SortArithmeticFunctionSizes(2,2,DerivedLength);
[ [ 0, 0 ], [ 1, 2 ], [ 2, 0 ] ]
gap> SortArithmeticFunctionSizes(2,3,DerivedLength);
[ [ 0, 0 ], [ 1, 3 ], [ 2, 2 ], [ 3, 0 ] ]
gap> SortArithmeticFunctionSizes(2,4,DerivedLength);
[ [ 0, 0 ], [ 1, 5 ], [ 2, 9 ], [ 3, 0 ], [ 4, 0 ] ]
gap> SortArithmeticFunctionSizes(2,5,DerivedLength);
[ [ 0, 0 ], [ 1, 7 ], [ 2, 44 ], [ 3, 0 ], [ 4, 0 ], [ 5, 0 ] ]
gap> SortArithmeticFunctionSizes(2,6,DerivedLength);
[ [ 0, 0 ], [ 1, 11 ], [ 2, 256 ], [ 3, 0 ], [ 4, 0 ], [ 5, 0 ], [ 6, 0 ] ]
gap> SortArithmeticFunctionSizes(2,7,DerivedLength);
[ [ 0, 0 ], [ 1, 15 ], [ 2, 2299 ], [ 3, 14 ], [ 4, 0 ], [ 5, 0 ], [ 6, 0 ], [ 7, 0 ] ]
gap> SortArithmeticFunctionSizes(2,8,DerivedLength);
[ [ 0, 0 ], [ 1, 22 ], [ 2, 55660 ], [ 3, 410 ], [ 4, 0 ], [ 5, 0 ], [ 6, 0 ], [ 7, 0 ], [ 8, 0 ] ]

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$	$2^{n}$	total number of groups	average of values (equal weighting on all groups)	length 0	length 1	length 2	length 3
0	1	1	0	1
1	2	1	1	0	1
2	4	2	1	0	1
3	8	5	1.4	0	0.6000	0.4000
4	16	14	1.6429	0	0.3571	0.6429
5	32	51	1.8627	0	0.1373	0.8627
6	64	267	1.9588	0	0.0412	0.9588
7	128	2328	1.9996	0	0.0064	0.9875	0.0060
8	256	56092	2.0069	0	0.0004	0.9923	0.0073

Below is information for the probability distribution of derived length under the cohomology tree probability distribution:

$n$	$2^{n}$	total number of groups	average of values (cohomology tree probability distribution)	length 0	length 1	length 2	length 3
0	1	1	0	1
1	2	1	1	0	1
2	4	2	1	0	1
3	8	5	1.25	0	0.7500	0.2500
4	16	14	1.5234	0	0.4766	0.5234
5	32	51	1.7228	0	0.2772	0.7228
6	64	267	1.8467	0	0.1533	0.8467

Prime-base logarithm of exponent

The prime-base logarithm of exponent, in this case, is $\log _{2}E$ where $E$ is the exponent of the group.

$n$	$2^{n}$	number of groups	value 0 (exponent 1)	value 1 (exponent 2)	value 2 (exponent 4)	value 3 (exponent 8)	value 4 (exponent 16)	value 5 (exponent 32)	value 6 (exponent 64)	value 7 (exponent 128)
0	1	1	1
1	2	1	0	1
2	4	2	0	1	1
3	8	5	0	1	3	1
4	16	14	0	1	7	5	1
5	32	51	0	1	23	21	5	1
6	64	267	0	1	96	137	27	5	1
7	128	2328	0	1	823	1269	202	27	5	1

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 functions Exponent and GAP:Log. Using these functions, the above data can be generated as follows:

gap> SortArithmeticFunctionSizes(2,0,G -> Log(Exponent(G),2));
[ [ 0, 1 ] ]
gap> SortArithmeticFunctionSizes(2,1,G -> Log(Exponent(G),2));
[ [ 0, 0 ], [ 1, 1 ] ]
gap> SortArithmeticFunctionSizes(2,2,G -> Log(Exponent(G),2));
[ [ 0, 0 ], [ 1, 1 ], [ 2, 1 ] ]
gap> SortArithmeticFunctionSizes(2,3,G -> Log(Exponent(G),2));
[ [ 0, 0 ], [ 1, 1 ], [ 2, 3 ], [ 3, 1 ] ]
gap> SortArithmeticFunctionSizes(2,4,G -> Log(Exponent(G),2));
[ [ 0, 0 ], [ 1, 1 ], [ 2, 7 ], [ 3, 5 ], [ 4, 1 ] ]
gap> SortArithmeticFunctionSizes(2,5,G -> Log(Exponent(G),2));
[ [ 0, 0 ], [ 1, 1 ], [ 2, 23 ], [ 3, 21 ], [ 4, 5 ], [ 5, 1 ] ]
gap> SortArithmeticFunctionSizes(2,6,G -> Log(Exponent(G),2));
[ [ 0, 0 ], [ 1, 1 ], [ 2, 96 ], [ 3, 137 ], [ 4, 27 ], [ 5, 5 ], [ 6, 1 ] ]
gap> SortArithmeticFunctionSizes(2,7,G -> Log(Exponent(G),2));
[ [ 0, 0 ], [ 1, 1 ], [ 2, 823 ], [ 3, 1269 ], [ 4, 202 ], [ 5, 27 ], [ 6, 5 ], [ 7, 1 ] ]

Here is the same information, now given in terms of the fraction of groups of a given order that have a given prime-base logarithm of exponent. For ease of comparison, all fractions are written as decimals, rounded to the fourth decimal place.

$n$	$2^{n}$	number of groups	average of values (equal weighting on all groups)	value 0	value 1	value 2	value 3	value 4	value 5	value 6	value 7
0	1	1	0	1
1	2	1	1	0	1
2	4	2	1.5	0	0.5000	0.5000
3	8	5	2	0	0.2000	0.6000	0.2000
4	16	14	2.4286	0	0.0714	0.5000	0.3571	0.0714
5	32	51	2.6471	0	0.0196	0.4510	0.4118	0.0980	0.0196
6	64	267	2.7828	0	0.0037	0.3596	0.5131	0.1011	0.0187	0.0037
7	128	2328	2.7637	0	0.0004	0.3535	0.5451	0.0868	0.0116	0.0021	0.0004

Below is information on the probability distribution of prime-base logarithm of exponent under the cohomology tree probability distribution:

$n$	$2^{n}$	number of groups	average of values (cohomology tree probability distribution)	value 0	value 1	value 2	value 3	value 4	value 5	value 6	value 7
0	1	1	0	1
1	2	1	1	0	1
2	4	2	1.5	0	0.5000	0.5000
3	8	5	2.1875	0	0.0625	0.6875	0.0250
4	16	14	2.6865	0	0.0010	0.4365	0.4375	0.1250
5	32	51	3.1426	0	0.0000	0.1738	0.5723	0.1914	0.0625
6	64	267	3.5342	0	0.0000	0.0626	0.4963	0.3166	0.0933	0.0313

Frattini length

$n$	$2^{n}$	total number of groups	length 0	length 1	length 2	length 3	length 4	length 5	length 6	length 7
0	1	1	1
1	2	1	0	1
2	4	2	0	1	1
3	8	5	0	1	3	1
4	16	14	0	1	7	5	1
5	32	51	0	1	23	21	5	1
6	64	267	0	1	94	139	27	5	1
7	128	2328	0	1	816	1276	202	27	5	1

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

We use the functions SortArithmeticFunctionSizes and FrattiniLength, which are not in-built but are easy to code (follow link to get code). With this function written, the above data can be generated directly:

gap> SortArithmeticFunctionSizes(2,0,FrattiniLength);
[ [ 0, 1 ] ]
gap> SortArithmeticFunctionSizes(2,1,FrattiniLength);
[ [ 0, 0 ], [ 1, 1 ] ]
gap> SortArithmeticFunctionSizes(2,2,FrattiniLength);
[ [ 0, 0 ], [ 1, 1 ], [ 2, 1 ] ]
gap> SortArithmeticFunctionSizes(2,3,FrattiniLength);
[ [ 0, 0 ], [ 1, 1 ], [ 2, 3 ], [ 3, 1 ] ]
gap> SortArithmeticFunctionSizes(2,4,FrattiniLength);
[ [ 0, 0 ], [ 1, 1 ], [ 2, 7 ], [ 3, 5 ], [ 4, 1 ] ]
gap> SortArithmeticFunctionSizes(2,5,FrattiniLength);
[ [ 0, 0 ], [ 1, 1 ], [ 2, 23 ], [ 3, 21 ], [ 4, 5 ], [ 5, 1 ] ]
gap> SortArithmeticFunctionSizes(2,6,FrattiniLength);
[ [ 0, 0 ], [ 1, 1 ], [ 2, 94 ], [ 3, 139 ], [ 4, 27 ], [ 5, 5 ], [ 6, 1 ] ]
gap> SortArithmeticFunctionSizes(2,7,FrattiniLength);
[ [ 0, 0 ], [ 1, 1 ], [ 2, 816 ], [ 3, 1276 ], [ 4, 202 ], [ 5, 27 ], [ 6, 5 ], [ 7, 1 ] ]

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

$n$	$2^{n}$	total number of groups	average of values (equal weighting on all groups)	length 0	length 1	length 2	length 3	length 4	length 5	length 6	length 7
0	1	1	0	1
1	2	1	1	0	1
2	4	2	1.5	0	0.5000	0.5000
3	8	5	2	0	0.2000	0.6000	0.2000
4	16	14	2.4286	0	0.0714	0.5000	0.3571	0.0714
5	32	51	2.6471	0	0.0196	0.4510	0.4118	0.0980	0.0196
6	64	267	2.7903	0	0.0037	0.3521	0.5206	0.1011	0.0187	0.0037
7	128	2328	2.7668	0	0.0004	0.3505	0.5481	0.0868	0.0116	0.0021	0.0004

Minimum size of generating set

This is also equal to the prime-base logarithm of the order of the Frattini quotient.

$n$	$2^{n}$	total number of groups	size 0	size 1	size 2	size 3	size 4	size 5	size 6	size 7
0	1	1	1
1	2	1	0	1
2	4	2	0	1	1
3	8	5	0	1	3	1
4	16	14	0	1	8	4	1
5	32	51	0	1	19	24	6	1
6	64	267	0	1	53	137	68	7	1
7	128	2328	0	1	162	833	1153	169	9	1

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

$n$	$2^{n}$	total number of groups	average value of minimum size of generating set	size 0	size 1	size 2	size 3	size 4	size 5	size 6	size 7
0	1	1	0	1
1	2	1	1	0	1
2	4	2	1.5	0	0.5000	0.5000
3	8	5	2	0	0.2000	0.6000	0.2000
4	16	14	2.3571	0	0.0714	0.5714	0.2857	0.0714
5	32	51	2.7451	0	1	19	24	6	1
6	64	267	3.1124	0	1	53	137	68	7	1
7	128	2328	3.5833	0	1	162	833	1153	169	9	1

Below is information on the probability distribution of minimum size of generating set under the cohomology tree probability distribution:

$n$	$2^{n}$	total number of groups	average of values of minimum size of generating set (by cohomology tree probability distribution)	size 0	size 1	size 2	size 3	size 4	size 5	size 6	size 7
0	1	1	0	1
1	2	2	1	0	1
2	4	2	1.5	0	0.5000	0.5000
3	8	5	1.8125	0	0.2500	0.6875	0.0625
4	16	14	2.0322	0	0.1250	0.7188	0.1553	0.0010
5	32	51	2.2039	0	0.0625	0.6753	0.2580	0.0042	0.0000
6	64	267	2.3288	0	0.0313	0.6195	0.3384	0.0011	0.0000	0.0000

Rank of a p-group

$n$	$2^{n}$	total number of groups	rank 0	rank 1	rank 2	rank 3	rank 4	rank 5	rank 6
0	1	1	1
1	2	1	0	1
2	4	2	0	1	1
3	8	5	0	2	2	1
4	16	14	0	2	8	3	1
5	32	51	0	2	21	23	4	1
6	64	267	0	2	54	150	55	5	1

Interaction of multiple arithmetic functions

Nilpotency class-cum-derived length

Note that in considering the possibilities here, we use the fact that derived length is logarithmically bounded by nilpotency class; explicitly, the derived length is at most $[\log _{2}c]+1$ where $[]$ is the greatest integer function and $c$ is the nilpotency class. On the other hand, derived length gives no upper bound on nilpotency class for derived length at least 2.

$n$	$2^{n}$	total number of groups	class and length 0	class and length 1	class 2, length 2	class 3, length 2	class 4, length 2	class 4, length 3	class 5, length 2	class 5, length 3	class 6, length 2	class 6, length 3
0	1	1	1
1	2	1	0	1
2	4	2	0	2
3	8	5	0	3	2
4	16	14	0	5	6	3
5	32	51	0	7	26	15	3
6	64	267	0	11	117	114	22	0	3
7	128	2328	0	15	947	1137	187	10	25	4	3

Element structure and nilpotency class

The arithmetic function we consider here is the smallest nilpotency class among all groups that are order-cum-power statistics-equvalent to it, i.e., have the same order-cum-power statistics.

$n$	$2^{n}$	total number of groups	min-class 0	min-class 1	min-class 2	min-class 3	min-class 4	min-class 5	min-class 6
0	1	1	1
1	2	1	0	1
2	4	2	0	2
3	8	5	0	3	2
4	16	14	0	7	4	3
5	32	51	0	15	18	15	3
6	64	267	0	44	95	103	22	3
7	128	2328	0	?	?	?	?	?	3

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

gap> SortArithmeticFunctionSizes(2,0,MinimumNilpotencyClassWithSameOrderCumPowerStatistics);
[ [ 0, 1 ] ]
gap> SortArithmeticFunctionSizes(2,1,MinimumNilpotencyClassWithSameOrderCumPowerStatistics);
[ [ 0, 0 ], [ 1, 1 ] ]
gap> SortArithmeticFunctionSizes(2,2,MinimumNilpotencyClassWithSameOrderCumPowerStatistics);
[ [ 0, 0 ], [ 1, 2 ], [ 2, 0 ] ]
gap> SortArithmeticFunctionSizes(2,3,MinimumNilpotencyClassWithSameOrderCumPowerStatistics);
[ [ 0, 0 ], [ 1, 3 ], [ 2, 2 ], [ 3, 0 ] ]
gap> SortArithmeticFunctionSizes(2,4,MinimumNilpotencyClassWithSameOrderCumPowerStatistics);
[ [ 0, 0 ], [ 1, 7 ], [ 2, 4 ], [ 3, 3 ], [ 4, 0 ] ]
gap> SortArithmeticFunctionSizes(2,5,MinimumNilpotencyClassWithSameOrderCumPowerStatistics);
[ [ 0, 0 ], [ 1, 15 ], [ 2, 18 ], [ 3, 15 ], [ 4, 3 ], [ 5, 0 ] ]
gap> SortArithmeticFunctionSizes(2,6,MinimumNilpotencyClassWithSameOrderCumPowerStatistics);
[ [ 0, 0 ], [ 1, 44 ], [ 2, 95 ], [ 3, 103 ], [ 4, 22 ], [ 5, 3 ], [ 6, 0 ] ]

In the next table, we give the groups of a given nilpotency class and with the minimum nilpotency class among all groups that are order-cum-power statistics-equivalent to it.

$n$	$2^{n}$	total number of groups	class and min-class 0	class and min-class 1	class 2, min-class 2	class 2, min-class 1	class 3, min-class 3	class 3, min-class 2	class 3, min-class 1	class 4, min-class 4	class 4, min-class 3	class 4, min-class 2	class 4, min-class 1	class 5, min-class 5
0	1	1	1
1	2	1	0	1
2	4	2	0	2
3	8	5	0	3	2
4	16	14	0	5	4	2	3
5	32	51	0	7	18	8	15	0	0	3
6	64	267	0	11	85	32	103	10	1	22	0	0	0	3