This article gives both numerical information and links to known facts/conjectures about the distribution of nilpotency class among finite p-groups, i.e., how many p-groups there are of a given derived length.
Related information
Facts known for general primes
Facts known for specific primes
The case 
 |
 |
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.
 |
 |
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:
 |
 |
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
|
The case 
The case 
 |
 |
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

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.
 |
 |
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
|
The case 
 |
 |
total number of groups |
length 0 |
length 1 |
length 2 |
length 3
|
| 0 |
1 |
1 |
1
|
| 1 |
7 |
1 |
0 |
1
|
| 2 |
49 |
2 |
0 |
2
|
| 3 |
343 |
5 |
0 |
3 |
2
|
| 4 |
2401 |
15 |
0 |
5 |
10
|
| 5 |
16807 |
83 |
0 |
7 |
76
|
| 6 |
117649 |
860 |
0 |
11 |
829 |
20
|
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(7,1,DerivedLength);
[ [ 0, 0 ], [ 1, 1 ] ]
gap> SortArithmeticFunctionSizes(7,2,DerivedLength);
[ [ 0, 0 ], [ 1, 2 ], [ 2, 0 ] ]
gap> SortArithmeticFunctionSizes(7,3,DerivedLength);
[ [ 0, 0 ], [ 1, 3 ], [ 2, 2 ], [ 3, 0 ] ]
gap> SortArithmeticFunctionSizes(7,4,DerivedLength);
[ [ 0, 0 ], [ 1, 5 ], [ 2, 10 ], [ 3, 0 ], [ 4, 0 ] ]
gap> SortArithmeticFunctionSizes(7,5,DerivedLength);
[ [ 0, 0 ], [ 1, 7 ], [ 2, 76 ], [ 3, 0 ], [ 4, 0 ], [ 5, 0 ] ]
gap> SortArithmeticFunctionSizes(7,6,DerivedLength);
[ [ 0, 0 ], [ 1, 11 ], [ 2, 829 ], [ 3, 20 ], [ 4, 0 ], [ 5, 0 ], [ 6, 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.
 |
 |
total number of groups |
length 0 |
length 1 |
length 2 |
length 3
|
| 0 |
1 |
1 |
1
|
| 1 |
7 |
1 |
0 |
1
|
| 2 |
49 |
2 |
0 |
1
|
| 3 |
343 |
5 |
0 |
0.6000 |
0.4000
|
| 4 |
2401 |
15 |
0 |
0.3333 |
0.6667
|
| 5 |
16807 |
83 |
0 |
0.0843 |
0.9157
|
| 6 |
117649 |
860 |
0 |
0.0128 |
0.9640 |
0.0233
|