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

Nilpotency class

Up to isomorphism

In the table here, 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.

$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: [SHOW MORE]

$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

Up to isoclinism

We give below information on the number of equivalence classes under the equivalence relation of being isoclinic groups, for each nilpotency class. The equivalence classes under isoclinism are also called Hall-Senior families. For visual clarity, the cells with zero entries are omitted. We know that isoclinic groups have same nilpotency class, with the exception of the trivial group (which has class zero) being isoclinic to nontrivial abelian groups (which have class 1).

$n$	$2^{n}$	total number of equivalence classes under isoclinism	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	1	0	1
3	8	2	0	1	1
4	16	3	0	1	1	1
5	32	8	0	1	3	3	1
6	64	27	0	1	?	?	?	1
7	128	115	0	1	?	?	?	?	1

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