Applications of the methods in this package include the study of the modular isomorphism problem for the groups of small order from the SmallGroupLibrary - first for groups of order dividing 2^8, 3^6 and 2^9 [Eic08] [EK11] and later also 3^7 and 5^6 [MM22]. This section contains the functions used for this purpose as well as an overview of how the Modular Isomorphism Problem can be studied for any set of groups using on one hand group-theoretical invariants and on the other hand the canonical form of nilpotent algebras.
A set of groups which share all the group-theoretical invariants implemented in the package is called bin. To determine such bins the main function available is:
‣ BinsByGT( p, n[, L][, false] ) | ( function ) |
If the function is called as BinsByGT(p, n), then it returns a partition of the list [1..NumberSmallGroups(p^n)] into sublists so that the groups in the corresponding lists share all the group-theoretical invariants, i.e. the modular group algebras of two groups SmallGroup(p^n, i) and SmallGroup(p^n, j) over the field ℙ_p cannot be isomorphic if i and j are in different lists.
If the function is called as BinsByGT(p, n, L), then L must be a list of groups of order p^n and the function will return a partition of the groups of L which share all the group-theoretical invariants. Alternatively, L can be a list of group IDs of groups of order p^n.
If the function is called as BinsByGT(p, n, L, false) then L must be a list of groups of order p^n and false deactivates the calculation of the dimensions of the second cohomology groups. This can be switched off because for some types of groups GAP cannot apply the needed functions, and because computing the second cohomology groups is arguably the hardest of the invariants to test manually.
Several variations of BinsByGT are available. The first two apply to the case when a list of groups is being studied instead of group IDs.
‣ MIPSplitGroupsByGroupTheoreticalInvariants( L ) | ( function ) |
does the same as BinsByGT(p,n,L) but computes the numbers p and n itself. The input variable must be a list of groups of the same order. Similarly
‣ MIPSplitGroupsByGroupTheoreticalInvariantsNoCohomology( L ) | ( function ) |
computes BinsByGT(p, n, L, false).
Moreover, all the three functions described before have variations where only those group-theoretical invariants are computed that are known to be ℙ-invariants over any field ℙ of characteristic p. The input and output of these functions is exactly as for the three previous functions.
‣ BinsByGTAllFields( p, n[, L][, false] ) | ( function ) |
‣ MIPSplitGroupsByGroupTheoreticalInvariantsAllFields( L ) | ( function ) |
‣ MIPSplitGroupsByGroupTheoreticalInvariantsAllFieldsNoCohomology( L ) | ( function ) |
The group-theoretical invariants used by the function BinsByGT (4.1-1) and its variations are described below. Moreover, GAP prints more or less information on the progress inside these functions, if InfoModIsom is set to 1 or 0, respectively. Examples of the use of the functions are included below.
The main function to apply the algorithm computing the canonical form of nilpotent algebras in the context of the Modular Isomorphism Problem is:
‣ MIPSplitGroupsByAlgebras( [p, n, ]bin[, f] ) | ( function ) |
If MIPSplitGroupsByAlgebras(p, n, bin, [f]) is called then the algebras of groups of order p^n with group IDs contained in bin are studied. The underlying field is of order p^f or, if f is not given, of order p.
If the function is called as MIPSplitGroupsByAlgebras(bin, [f]) then bin must be a list of groups of the same prime power order and the function studies the group algebras of the groups in bin over the field with p^f elements or, if no f is given, of order p.
More precisely, in the first case when bin is a list of integers, for i ∈ bin let G_i denote SmallGroup(p^n, i). In the second case G_i just runs through the groups contained in bin. Denote by A_i the augmentation ideal of ℙ G_i where ℙ is the field of order p^f or simply p, if f is not given. The function computes and compares the canonical forms of the algebras A_i / A_i^j for every i ∈ bin and increasing natural number j.
At each level j it splits the current bins into sub-bins according to the different canonical forms of A_i/A_i^j. Bins of length 1 are then discarded.
The function returns if no further bins are available and provides information at which level the splitting of the bins took place.
For more involved calculations one can use the function
‣ MIPBinSplit( p, n, max, start, step, L[, f] ) | ( function ) |
Given a list L of small group library IDs or a list of groups of order p^n this function checks isomorphism of the associated modular group algebras using canonical forms for the quotients of the augmentation ideals A of ℙ G. Here ℙ is either ℙ_p or ℙ_p^f, if f is given. The parameter max is an integer or false that determines the maximal quotients A/A^max to be checked (if false is given as input, then the quotients are enlarged until non-isomorphic quotients are found or eventually the full augmentation ideal will be checked). The parameter start specifies which quotients A/A^start are precomputed. The parameter step determines in which steps the quotients are enlarged if necessary during the isomorphism check. The output is a record containing three entries: bins contains all the groups, for which the non- isomorphism of the associated modular group algebras could not be determined; splits contains all the groups, for which the associated group algebras were determined to be non-isomorphic (and the first non-isomorphic quotient); time contains the time used for the computation (in milliseconds).
For big algebras all of these functions can use a lot of time and memory. To have a better idea on the progress of the calculations one should set InfoModIsom to 1.
We first show how to study a fixed order:
gap> bins := BinsByGT(2,6); [ [ 156, 158, 160 ], [ 155, 157 ], [ 173, 176 ], [ 179, 180 ], [ 20, 22 ] ] gap> List(bins, bin -> MIPSplitGroupsByAlgebras(2, 6, bin)); [ rec( bins := [ ], splits := [ [ 7, [ 156, 158, 160 ] ] ], time := 2195 ), rec( bins := [ ], splits := [ [ 7, [ 155, 157 ] ] ], time := 1505 ), rec( bins := [ ], splits := [ [ 7, [ 173, 176 ] ] ], time := 3294 ), rec( bins := [ ], splits := [ [ 7, [ 179, 180 ] ] ], time := 3233 ), rec( bins := [ ], splits := [ [ 4, [ 20, 22 ] ] ], time := 160 ) ]
This shows that the Modular Isomorphism Problem has a positive answer for groups of order 64 for the field ℙ_2. The result means e.g. that the smallest quotients (of Loewy layers) such that the augmentation ideals A_1 and A_2 of the group algebras over ℙ_2 of the groups SmallGroup(64, 156) and SmallGroup(64, 158) are not isomorphic are A_1/A_1^8 and A_2/A_2^8. These are A_1/A_1^5 and A_2/A_2^5 for the groups SmallGroup(64, 20) and SmallGroup(64, 22).
The following shows that the problem also has a positive answer for the group algebras of groups of order 64 over the field ℙ_4. Note that for the groups SmallGroup(64, 20) and SmallGroup(64, 22) one has to consider deeper quotients in this case.
gap> bins := BinsByGTAllFields(2,6); [ [ 156, 158, 160 ], [ 155, 157 ], [ 173, 176 ], [ 179, 180 ], [ 104, 105 ], [ 13, 14 ], [ 20, 22 ], [ 18, 19 ] ] gap> List(bins, bin -> MIPSplitGroupsByAlgebras(2, 6, bin, 2)); [ rec( bins := [ ], splits := [ [ 7, [ 156, 158, 160 ] ] ], time := 34833 ), rec( bins := [ ], splits := [ [ 7, [ 155, 157 ] ] ], time := 22479 ), rec( bins := [ ], splits := [ [ 7, [ 173, 176 ] ] ], time := 9806 ), rec( bins := [ ], splits := [ [ 7, [ 179, 180 ] ] ], time := 7819 ), rec( bins := [ ], splits := [ [ 4, [ 104, 105 ] ] ], time := 2226 ), rec( bins := [ ], splits := [ [ 6, [ 13, 14 ] ] ], time := 707 ), rec( bins := [ ], splits := [ [ 6, [ 20, 22 ] ] ], time := 3917 ), rec( bins := [ ], splits := [ [ 6, [ 18, 19 ] ] ], time := 2891 ) ]
The other functions can be used to study the problem for groups not coming from the library. The following groups are studied in [GM24].
R := SmallGroup(64, 19); Q := SmallGroup(64, 18); DR := DirectProduct(R,Q); GDR := GeneratorsOfGroup(DR); z1 := GDR[3]; z2 := GDR[9]; N := Group(z1*z2^(-1)); G := DR/N; DR := DirectProduct(Q,Q); GDR := GeneratorsOfGroup(DR); z1 := GDR[3]; z2 := GDR[9]; N := Group(z1*z2^(-1)); H := DR/N;
gap> MIPSplitGroupsByGroupTheoreticalInvariantsAllFields([G,H]); [ [ Group([ f1, f2, f7, f3, f4, f10, f5, f6, f7, f8, f9, f10 ]), Group([ f1, f2, f7, f3, f4, f10, f5, f6, f7, f8, f9, f10 ]) ] ] # the groups can not be split over all fields by group-theoretical invariants
gap> MIPSplitGroupsByAlgebras([G,H]); rec( bins := [ ], splits := [ [ 4, [ Group([ f1, f2, f7, f3, f4, f10, f5, f6, f7, f8, f9, f10 ]), Group([ f1, f2, f7, f3, f4, f10, f5, f6, f7, f8, f9, f10 ]) ] ] ], time := 44473 ) # over the field of 2 elements it is enough to consider # the 5-th power of the augmentation ideal
The program does not finish in a very reasonable time, if we run it over the field ℙ_4, but we can still check that it is not enough to factor out only the 5th power of the augmentation ideal in this case. One option is to use info level to do this and the other to use MIPBinSplit:
gap> SetInfoLevel(InfoModIsom, 1); gap> MIPSplitGroupsByAlgebras([G,H], 2); #I Refine bin #I Weights yields bins [ [ 1, 2 ] ] #I Layer 1 yields bins [ [ 1, 2 ] ] #I layer 2 of dim 15 aut group has order 2961100800 * 2^0 #I cover is determined #I dim(M) = 16 and dim(U) = 5 #I extended autos #I computed stabilizer #I got quotient #I induced autos #I layer 2 of dim 15 aut group has order 2961100800 * 2^0 #I cover is determined #I dim(M) = 16 and dim(U) = 5 #I extended autos #I computed stabilizer #I got quotient #I induced autos #I Layer 2 yields bins [ [ 1, 2 ] ] #I layer 3 of dim 39 aut group has order 2937600 * 2^88 #I cover is determined #I dim(M) = 29 and dim(U) = 5 #I extended autos #I computed stabilizer #I got quotient #I induced autos #I layer 3 of dim 39 aut group has order 2937600 * 2^88 #I cover is determined #I dim(M) = 29 and dim(U) = 5 #I extended autos #I computed stabilizer #I got quotient #I induced autos #I Layer 3 yields bins [ [ 1, 2 ] ] #I layer 4 of dim 81 aut group has order 2937600 * 2^240 #I cover is determined #I dim(M) = 51 and dim(U) = 9 #I extended autos #I computed stabilizer #I got quotient #I induced autos #I layer 4 of dim 81 aut group has order 2937600 * 2^240 #I cover is determined #I dim(M) = 51 and dim(U) = 9 #I extended autos #I computed stabilizer #I got quotient #I induced autos #I Layer 4 yields bins [ [ 1, 2 ] ] #I layer 5 of dim 145 aut group has order 7200 * 2^496 #I cover is determined #I dim(M) = 73 and dim(U) = 9 #I extended autos #I computed stabilizer #I got quotient #I induced autos #I layer 5 of dim 145 aut group has order 7200 * 2^496 #I cover is determined #I dim(M) = 73 and dim(U) = 9 #I extended autos #I computed stabilizer #I got quotient #I induced autos #I Layer 5 yields bins [ [ 1, 2 ] ] #I layer 6 of dim 231 aut group has order 7200 * 2^800 #I cover is determined #I dim(M) = 95 and dim(U) = 9 #I extended autos #I computed stabilizer #I got quotient ^CError, user interrupt in AddRowVector( u, GetEntryTable( T, i, j ), v[i] * w[j] ); at /home/leo/gap-4.10.1/pkg/modisom-2.5.3/gap/tables/tables.gi:87 called from MultByTable( Q, new[Q.wds[i][1]], new[Q.wds[i][2]] ) at /home/leo/gap-4.10.1/pkg/modisom-2.5.3/gap/autiso/induc.gi:135 called from InduceAutoToQuot( Q, G.agAutos[i] ) at /home/leo/gap-4.10.1/pkg/modisom-2.5.3/gap/autiso/induc.gi:151 called from InduceAutosToQuot( G, Q ); at /home/leo/gap-4.10.1/pkg/modisom-2.5.3/gap/autiso/autiso.gi:57 called from ExtendCanoForm( tabs[i], j ); at /home/leo/gap-4.10.1/pkg/modisom-2.5.3/gap/grpalg/chkbins.gi:117 called from MIPBinSplit( p, n, false, start, step, list, f ) at /home/leo/gap-4.10.1/pkg/modisom-2.5.3/gap/grpalg/chkbins.gi:177 called from ... at *stdin*:39 you can 'return;' brk> quit; # this was not progressing for several hours
gap> Size(G) = Size(H); true gap> Size(G) = 2^10; true
gap> MIPBinSplit(2, 10, 4, 4, 1, [G,H], 2); #I Refine bin #I Weights yields bins [ [ 1, 2 ] ] #I Layer 1 yields bins [ [ 1, 2 ] ] #I layer 2 of dim 15 aut group has order 2961100800 * 2^0 #I cover is determined #I dim(M) = 16 and dim(U) = 5 #I extended autos #I computed stabilizer #I got quotient #I induced autos #I layer 2 of dim 15 aut group has order 2961100800 * 2^0 #I cover is determined #I dim(M) = 16 and dim(U) = 5 #I extended autos #I computed stabilizer #I got quotient #I induced autos #I Layer 2 yields bins [ [ 1, 2 ] ] #I layer 3 of dim 39 aut group has order 2937600 * 2^88 #I cover is determined #I dim(M) = 29 and dim(U) = 5 #I extended autos #I computed stabilizer #I got quotient #I induced autos #I layer 3 of dim 39 aut group has order 2937600 * 2^88 #I cover is determined #I dim(M) = 29 and dim(U) = 5 #I extended autos #I computed stabilizer #I got quotient #I induced autos #I Layer 3 yields bins [ [ 1, 2 ] ] #I layer 4 of dim 81 aut group has order 2937600 * 2^240 #I cover is determined #I dim(M) = 51 and dim(U) = 9 #I extended autos #I computed stabilizer #I got quotient #I induced autos #I layer 4 of dim 81 aut group has order 2937600 * 2^240 #I cover is determined #I dim(M) = 51 and dim(U) = 9 #I extended autos #I computed stabilizer #I got quotient #I induced autos #I Layer 4 yields bins [ [ 1, 2 ] ] rec( bins := [ [ Group([ f1, f2, f7, f3, f4, f10, f5, f6, f7, f8, f9, f10 ]), Group([ f1, f2, f7, f3, f4, f10, f5, f6, f7, f8, f9, f10 ]) ] ], splits := [ ], time := 9469981 )
An idea to study the Modular Isomorphism Problem is to define maps on certain quotients of the augmentation ideal A and count the number of elements which map to 0 under this map. The map most typically used for this is a p-power map A^n/A^n+m → A^n ⋅ p^ℓ/A^n ⋅ p^ℓ + m. This can be done in the package using the function
‣ KernelSizePowerMap( T, n, m, l[, f] ) | ( function ) |
where T is a table as returned by ModIsomTable (2.3-2) and n, m, l are as just described and the calculation is performed over the field ℙ_p^f. If f is not given, then it is set to 1. We can check for instance the first calculation in [HS06](Section 4.1).
gap> G := SmallGroup(64, 20); <pc group of size 64 with 6 generators> gap> H := SmallGroup(64, 22); <pc group of size 64 with 6 generators> gap> TG := ModIsomTable(G, 5);; gap> TH := ModIsomTable(H, 5);; gap> KernelSizePowerMap(TG, 1, 1, 2); 3 gap> KernelSizePowerMap(TH, 1, 1, 2); 1
This shows that the group algebras over ℙ_2 are not isomorphic. This argument does not, however, work over ℙ_4:
gap> TG := ModIsomTable(G, 5, 2);; gap> TH := ModIsomTable(H, 5, 2);; gap> KernelSizePowerMap(TG, 1, 1, 2); 7 gap> KernelSizePowerMap(TH, 1, 1, 2); 7
We document here which group-theoretical invariants are used in BinsByGT (4.1-1) and similar functions.
‣ GroupInfo( G ) | ( function ) |
This is an auxiliary function used in other group-theoretical invariants. If IdGroup is available in GAP for the order of G it returns IdGroup(G). Otherwise it returns [Size(G), AbelianInvariants(G)].
We now describe the invariants in the order they appear in BinsByGT (4.1-1). First the isomorphism types of G/G' and Z(G), the abelianization and the center of G are used. These are very classical invariants [San85](Theorems 6.12, 6.7). We next list the other functions which are applied, which are all small functions written for the package:
‣ CenterDerivedInfo( G ) | ( function ) |
calculates the isomorphism types of Z(G) ∩ G' and Z(G)/ Z(G) ∩ G' [San85](Theorem 6.11).
‣ SandlingInfo( G ) | ( function ) |
calculates several invariants coming from the small groups algebra which was first used to study the Modular Isomorphism Problem in [San89]. Namely, for γ_i(G) the i-th term of the lower central series of G it returns the GroupInfo (4.3-1) for G/γ_2(G)^pγ_3(G) [San89], the GroupInfo (4.3-1) of G/γ_2(G)^pγ_4(G), if G is 2-generated (mentioned in [Bag99], proved in [MM22]), if the derived subgroup of G is elementary abelian and the Jennings series of G has length at most 2p, it returns GroupInfo (4.3-1) for the Frattini subgroup of G [HS06](p.16) and if p is odd and the group satisfies the criteria of [BG24](Theorem B) it returns the GroupInfo (4.3-1) of G/γ_2(G)^pγ_4(G). The output is the GroupInfo (4.3-1) of G, if G is abelian. This function is not applied in BinsByGTAllFields (4.1-4) and its variations.
‣ JenningsInfo( G ) | ( function ) |
Denoting by D_i(G) the i-th member of the Jennings series, this function returns GroupInfo (4.3-1) for the different quotients D_i(G)/D_i+1(G), D_i(G)/D_i+2(G), D_i(G)D_2i+1(G) for meaningful values of i (results [Jen41] [PS72] [RS83]) and if p is odd also for G/D_4(G) [Her07]. For BinsByGTAllFields (4.1-4) and its variations only the quotients D_i(G)/D_i+1(G) are computed (by the function JenningsInfoAllFields).
‣ JenningsDerivedInfo( G ) | ( function ) |
computes D_i(G')/D_i+1(G') for all i [San85](Lemma 6.26).
‣ BaginskiInfo( G ) | ( function ) |
For N = C_G(G'/Φ(G')), where Φ(G) denotes the Frattini subgroup, if G/N is cyclic, it returns the GroupInfo (4.3-1) for N/Φ(G') and G/Φ(N) [Bag99]. This function is not applied in BinsByGTAllFields (4.1-4) and its variations.
‣ BaginskiCarantiInfo( G ) | ( function ) |
returns the nilpotency class of G/Φ(G') [BC88](Proposition 2.1). This function is not applied in BinsByGTAllFields (4.1-4) and its variations.
‣ NilpotencyClassInfo( G ) | ( function ) |
returns the nilpotency class of G, when the exponent of G is p or the class equals 2 or the derived subgroup is cyclic [BK07].
‣ Theorem41MS22( G ) | ( function ) |
If p is odd, G is 2-generated, the nilpotency class of G is 3 and γ_3(G) has exponent p, it returns the isomorphism types of γ_2(G) and γ_3(G) [MS22](Theorem 4.1). This function is not applied in BinsByGTAllFields (4.1-4) and its variations.
‣ CyclicDerivedInfo( G ) | ( function ) |
If G' is cyclic this returns several invariants contained in [GdS23] [Gd24] and [MS25b](Proposition 2.5). Namely, if p is odd, the quotients D_i(C_G(G'))/D_i+1(C_G(G')) for all i, the exponent of C_G(G'), the isomorphism type of C_G(G')/G' and the GroupInfo (4.3-1) for G/R_1(γ_3(G)) and G/R_3(C_G(G')). Here R_i(G) denotes the subgroup of G generated by the p^i-th powers in G. If G is additionally 2-generated, it also computes the GroupInfo (4.3-1) for C_G(G') and the type invariants of G (cf. [GdS23] for the definition). For any p, if G is 2-generated, it returns the GroupInfo (4.3-1) of G/(G')^p. If G is abelian, the return is the GroupInfo (4.3-1) of G. For BinsByGTAllFields (4.1-4) and its variations, the function CyclicDerivedInfoAllFields is used which does not compute the GroupInfo (4.3-1) for G/R_1(γ_3(G)) and G/R_3(C_G(G')).
‣ MaximalAbelianDirectFactor( G ) | ( function ) |
computes the maximal abelian direct factor of G [Gar24]. In BinsByGTAllFields (4.1-4) and its variations the function MaximalElementaryAbelianDirectFactor is used instead, which computes the maximal elementary abelian direct factor [MSS23].
The following three functions serve to compute some of the sections of G which are canonical following Lemma 3.6 in [Gar24]. The starting canonical group is the derived subgroup.
‣ SuccessorsN( G, L, N ) | ( function ) |
Given a finite p-group G, two subgroups N and L of G, with N normal, it returns a list with three entries corresponding to the subgroups obtained by applying the operations preserving the property of being canonical, as described in [Gar24](Lemma 3.6), where t=1 in the notation of the lemma. Namely, Ω(G:N), ℧(L)N and Ω(Z(G))N. Each entry of the output is a list with two elements, the first being a string Omega
, Agemo
or OmegaCenter
and the second the corresponding subgroup of G.
If applying one of the three operations does not change the subgroup N, no entry is added to the list, as there is no successor to N in this way.
‣ CanonicalNormalSubgroups( G ) | ( function ) |
Computes a list of the subgroups of G obtained by iteratively applying the function SuccessorsN (4.3-12), where always L=G and starting from N=G', the derived subgroup of G. An entry of the output is a list with two entries, the first a list of strings and the second a subgroup of G. The strings describe in which order the operations in SuccessorsN (4.3-12) have been applied to G' to obtain the subgroup contained in the second entry. The first entry being the empty list means the derived subgroup of G. The maximum length of a list of strings is 3 log_p exp(G/G').
‣ NormalSubgroupsInfo( G ) | ( function ) |
Returns a list with one entry for each of the subgroups obtained with CanonicalNormalSubgroups(G), and in each entry stores the information, relative to the corresponding subgroup, that is determined by the group ring according to [Gar24](Lemma 3.2). Namely, each entry of the output is a list with four elements, the first being a list of strings which describes the subgroup to which the other entries correspond. The strings are to be read the same way as in the output of CanonicalNormalSubgroups (4.3-13) (the leftmost string is the first applied operation). Denoting by S the corresponding subgroup, the second entry describes the sizes of the subgroups in the Jennings series of S, the third gives the abelian invariants of Z(G) ∩ S and Z(G)S/S, and the fourth entry contains the abelian invariants of G/SG' and SG'/G'.
‣ IsCoveredByTheory( G ) | ( function ) |
determines, whether G belongs to certain classes for which the Modular Isomorphism Problem has been solved positively. It does not check if a group contains a cyclic subgroup of index p^2, cf. [BK07], as this takes some time, but this can be done by the function HasCyclicSubgroupIOfIndexP2. It does also not check if a group belongs to a certain family of 3-subgroups of maximal class (cf. [BK19] and [MS25b]) or certain 2-groups which are 2-generated and are dihedral modulo center [MS25a]. What it does check is, if G is abelian [Des56], G is a 2-group of maximal class [Bag92], p is odd, |G| ≤ p^p+1, G has a maximal abelian subgroup and G is of maximal class [BC88], [G:Z(G)] = p^2 [Dre89], D_3(G) = 1 [PS72] or p is odd and D_4(G) = 1 [Her07], γ_2(G)^pγ_3(G) = 1 [San89] or the more generalisation which is Theorem B in [BG24], p is odd and [G:Z(G)]=p^3 [BG24], G has nilpotency class 2 and is 2-generated [Bd21], G is elementary abelian-by-cyclic [Bag99], p is odd, G' is elementary abelian, the nilpotency class of G is 3 and either C_G(G') is a maximal subgroup of G and abelian [MS22](Theorem 3.3) or G is 3-generated and a certain condition holds on the commutator map modulo the second center of G [MS22](Theorem 3.5), G is a 2-group with cyclic center and dihedral central quotient [MSS23], G is a 2-group of nilpotency class 2 with cyclic center [GM24], p is odd, G' is cyclic and R_2(G/G') is cyclic [Gd24](Proposition 3.7), G is 2-generated and C_G(G'/Φ(G')) is abelian and has index p in G [BZ25](Proposition 8), G is d-generated, the Jennings series of G has length n+1 and the defining relations of G are contained in D_n(F) for F a free pro-p group in d generators [Röh90](Theorem 3.1.2) (using dimensions of subsequent quotients of the Jennings series of free pro-p groups computed in [MRT16](Proposition 3.4)), G is metacyclic [San96].
For BinsByGTAllFields (4.1-4) and its variations the function used is IsCoveredByTheoryAllFields and it only checks, if G is abelian, G is a 2-group of maximal class, [G:Z(G)] = p^2, G is a 2-group with cyclic center and dihedral central quotient, G has nilpotency class 2 and cyclic center and satisfies the additional hypotheses of [GM24](Theorem 1.3), G has nilpotency class at most 2 and is 2-generated [MS25b](Theorem 3.9), G is metacyclic [MS25b](Theorem 3.6).
‣ DimensionTwoCohomology( G ) | ( function ) |
computes the dimensions of the second cohomology group H^2(FG, F) and of the second Hochschild cohomology group HH^2(FG) = H^2(FG, FG).
‣ ConjugacyClassInfo( G ) | ( function ) |
Computes the number of conjugacy classes which are p^i-th powers, for all i (Kuelshammer) and the number of conjugacy classes of p^i-th powers which come from conjugacy classes of the same order (Parmenter-Polcino Milies) [HS06](Section 2.2) and the dimension of the first Hochschild cohomology group which equals the number ∑_g^G log_p(C_G(g)/Φ(C_G(g))) where the sum runs over all the conjugacy classes of G, aka the Roggenkamp parameter [HS06](Section 2.6).
The return contains first the Roggenkamp parameter, then the Kuelshammer invariants (starting from i = 0) and then the invariant of Parmenter-Polcino Milies.
‣ SubgroupsInfo( G ) | ( function ) |
Computes the number of conjugacy classes of maximal elementary abelian subgroups of rank 1,2,... The return is a list of integers which contains this number for all ranks until the maximal possible. This is based on results of Quillen [HS06](Section 2.5).
generated by GAPDoc2HTML