Arithmetic functions for groups of order 3^n

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

Distributions for individual arithmetic functions

In the tables here, a row value of $n$ means we are looking at the groups of order $3^{n}$. The entry in a cell is the number of isomorphism classes of groups of order $3^{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$	$3^{n}$	total number of groups	class 0	class 1	class 2	class 3	class 4	class 5	class 6
0	1	1	1
1	3	1	0	1
2	9	2	0	2
3	27	5	0	3	2
4	81	15	0	5	6	4
5	243	67	0	7	28	26	6
6	729	504	0	11	133	282	71	7
7	2187	9310	0	15	1757	6050	1309	173	6

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(3,0,NilpotencyClassOfGroup);
[ [ 0, 1 ] ]
gap> SortArithmeticFunctionSizes(3,1,NilpotencyClassOfGroup);
[ [ 0, 0 ], [ 1, 1 ] ]
gap> SortArithmeticFunctionSizes(3,2,NilpotencyClassOfGroup);
[ [ 0, 0 ], [ 1, 2 ], [ 2, 0 ] ]
gap> SortArithmeticFunctionSizes(3,3,NilpotencyClassOfGroup);
[ [ 0, 0 ], [ 1, 3 ], [ 2, 2 ], [ 3, 0 ] ]
gap> SortArithmeticFunctionSizes(3,4,NilpotencyClassOfGroup);
[ [ 0, 0 ], [ 1, 5 ], [ 2, 6 ], [ 3, 4 ], [ 4, 0 ] ]
gap> SortArithmeticFunctionSizes(3,5,NilpotencyClassOfGroup);
[ [ 0, 0 ], [ 1, 7 ], [ 2, 28 ], [ 3, 26 ], [ 4, 6 ], [ 5, 0 ] ]
gap> SortArithmeticFunctionSizes(3,6,NilpotencyClassOfGroup);
[ [ 0, 0 ], [ 1, 11 ], [ 2, 133 ], [ 3, 282 ], [ 4, 71 ], [ 5, 7 ], [ 6, 0 ] ]
gap> SortArithmeticFunctionSizes(3,7,NilpotencyClassOfGroup);
[ [ 0, 0 ], [ 1, 15 ], [ 2, 1757 ], [ 3, 6050 ], [ 4, 1309 ], [ 5, 173 ], [ 6, 6 ], [ 7, 0 ] ]

Note that for the $3^{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$	$3^{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
0	1	1	0	1
1	3	1	1	0	1
2	9	2	1	0	1
3	27	5	1.4	0	0.6000	0.4000
4	81	15	1.9333	0	0.3333	0.4000	0.2667
5	243	67	2.4627	0	0.1045	0.4179	0.3881	0.1343
6	729	504	2.8611	0	0.0218	0.2639	0.5595	0.1409	0.1389
7	2187	9310	2.9876	0	0.0016	0.1887	0.6498	0.1406	0.0186	0.0006

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

$n$	$3^{n}$	total number of groups	average of values (cohomology tree probability distribution)	class 0	class 1	class 2	class 3	class 4	class 5	class 6
0	1	1	0	1
1	3	3	1	0	1
2	9	2	1	0	1
3	27	5	1.2222	0	0.7778	0.2222
4	81	15	1.4701	0	0.5519	0.4262	0.0219
5	243	67	1.8282	0	0.3778	0.4177	0.2028	0.0016

Derived length

$n$	$3^{n}$	total number of groups	length 0	length 1	length 2	length 3
0	1	1	1
1	3	1	0	1
2	9	2	0	2
3	27	5	0	3	2
4	81	15	0	5	10
5	243	67	0	7	60
6	729	504	0	11	493
7	2187	9310	0	15	9235	60

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). With this function written, the above data can be generated directly:

gap> SortArithmeticFunctionSizes(3,0,DerivedLength);
[ [ 0, 1 ] ]
gap> SortArithmeticFunctionSizes(3,1,DerivedLength);
[ [ 0, 0 ], [ 1, 1 ] ]
gap> SortArithmeticFunctionSizes(3,2,DerivedLength);
[ [ 0, 0 ], [ 1, 2 ], [ 2, 0 ] ]
gap> SortArithmeticFunctionSizes(3,3,DerivedLength);
[ [ 0, 0 ], [ 1, 3 ], [ 2, 2 ], [ 3, 0 ] ]
gap> SortArithmeticFunctionSizes(3,4,DerivedLength);
[ [ 0, 0 ], [ 1, 5 ], [ 2, 10 ], [ 3, 0 ], [ 4, 0 ] ]
gap> SortArithmeticFunctionSizes(3,5,DerivedLength);
[ [ 0, 0 ], [ 1, 7 ], [ 2, 60 ], [ 3, 0 ], [ 4, 0 ], [ 5, 0 ] ]
gap> SortArithmeticFunctionSizes(3,6,DerivedLength);
[ [ 0, 0 ], [ 1, 11 ], [ 2, 493 ], [ 3, 0 ], [ 4, 0 ], [ 5, 0 ], [ 6, 0 ] ]
gap> SortArithmeticFunctionSizes(3,7,DerivedLength);
[ [ 0, 0 ], [ 1, 15 ], [ 2, 9235 ], [ 3, 60 ], [ 4, 0 ], [ 5, 0 ], [ 6, 0 ], [ 7, 0 ] ]

Note that for the $3^{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$	$3^{n}$	total number of groups	length 0	length 1	length 2	length 3
0	1	1	1
1	3	1	0	1
2	9	2	0	1
3	27	5	0	0.6000	0.4000
4	81	15	0	0.3333	0.6667
5	243	67	0	0.1045	0.8955
6	729	504	0	0.0218	0.9782
7	2187	9310	0	0.0016	0.9919	0.6445

Frattini length

$n$	$3^{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	3	1	0	1
2	9	2	0	1	1
3	27	5	0	1	3	1
4	81	15	0	1	11	2	1
5	243	67	0	1	46	17	2	1
6	729	504	0	1	355	133	12	2	1
7	2187	9310	0	1	7192	2018	84	12	2	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(3,1,FrattiniLength);
[ [ 0, 0 ], [ 1, 1 ] ]
gap> SortArithmeticFunctionSizes(3,2,FrattiniLength);
[ [ 0, 0 ], [ 1, 1 ], [ 2, 1 ] ]
gap> SortArithmeticFunctionSizes(3,3,FrattiniLength);
[ [ 0, 0 ], [ 1, 1 ], [ 2, 3 ], [ 3, 1 ] ]
gap> SortArithmeticFunctionSizes(3,4,FrattiniLength);
[ [ 0, 0 ], [ 1, 1 ], [ 2, 11 ], [ 3, 2 ], [ 4, 1 ] ]
gap> SortArithmeticFunctionSizes(3,5,FrattiniLength);
[ [ 0, 0 ], [ 1, 1 ], [ 2, 46 ], [ 3, 17 ], [ 4, 2 ], [ 5, 1 ] ]
gap> SortArithmeticFunctionSizes(3,6,FrattiniLength);
[ [ 0, 0 ], [ 1, 1 ], [ 2, 355 ], [ 3, 133 ], [ 4, 12 ], [ 5, 2 ], [ 6, 1 ] ]
gap> SortArithmeticFunctionSizes(3,7,FrattiniLength);
[ [ 0, 0 ], [ 1, 1 ], [ 2, 7192 ], [ 3, 2018 ], [ 4, 84 ], [ 5, 12 ], [ 6, 2 ], [ 7, 1 ] ]

Note that for the $3^{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).

Interaction of multiple 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$	$3^{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	3	1	0	1
2	9	2	0	2
3	27	5	0	3	2
4	81	15	0	5	6	4
5	243	67	0	7	28	26	6
6	729	504	0	11	133	282	71	0	7
7	2187	9310	0	15	1757	6050	1309	0	113	60	6

Order-cum-power statistics 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$	$3^{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	3	1	0	1
2	9	2	0	2
3	27	5	0	5
4	81	15	0	12	0	3
5	243	67	0	45	0	16	6

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

The code uses two functions: SortArithmeticFunctionSizes and MinimumNilpotencyClassWithSameOrderCumPowerStatistics, neither of which is in-built (follow links to get code). Using these, we can generate the information as follows:

gap> SortArithmeticFunctionSizes(3,0,MinimumNilpotencyClassWithSameOrderCumPowerStatistics);
[ [ 0, 1 ] ]
gap> SortArithmeticFunctionSizes(3,1,MinimumNilpotencyClassWithSameOrderCumPowerStatistics);
[ [ 0, 0 ], [ 1, 1 ] ]
gap> SortArithmeticFunctionSizes(3,2,MinimumNilpotencyClassWithSameOrderCumPowerStatistics);
[ [ 0, 0 ], [ 1, 2 ], [ 2, 0 ] ]
gap> SortArithmeticFunctionSizes(3,3,MinimumNilpotencyClassWithSameOrderCumPowerStatistics);
[ [ 0, 0 ], [ 1, 5 ], [ 2, 0 ], [ 3, 0 ] ]
gap> SortArithmeticFunctionSizes(3,4,MinimumNilpotencyClassWithSameOrderCumPowerStatistics);
[ [ 0, 0 ], [ 1, 12 ], [ 2, 0 ], [ 3, 3 ], [ 4, 0 ] ]
gap> SortArithmeticFunctionSizes(3,5,MinimumNilpotencyClassWithSameOrderCumPowerStatistics);
[ [ 0, 0 ], [ 1, 45 ], [ 2, 0 ], [ 3, 16 ], [ 4, 6 ], [ 5, 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. Note that because of the Baer correspondence, we know that if the class is $2$, then the group is 1-isomorphic to, and hence has the same order-cum-power statistics as, an abelian group. Hence, we remove all the columns with "min-class 2" in them.

$n$	$3^{n}$	total number of groups	class and min-class 0	class and min-class 1	class 2, min-class 1	class 3, min-class 3	class 3, min-class 1	class 4, min-class 4	class 4, min-class 3	class 4, min-class 1	class 5, min-class 5
0	1	1	1
1	3	1	0	1
2	9	2	0	2
3	27	5	0	3	2
4	81	15	0	5	6	3	1
5	243	67	0	7	28	16	10	4