4 The modular isomorphism problem

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 F_p can not 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ⁿ 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 Id's of groups of order pⁿ.

If the function is called as BinsByGT(p, n, L, false) then L must be a list of groups of order pⁿ and false disactivates the calculation of the dimensions of the second cohomology groups. This can be switched off as for some type of groups GAP can not apply the needed functions and since 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 Id's.

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

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 F-invariants over any field F of characteristic p. The input and output of these functions is exactly as for the three previous functions.

The group-theoretical invariants used by the function BinsByGT 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:

If MIPSplitGroupsByAlgebras(p, n, bin, [f]) is called then the algebras of groups of order pⁿ with group Id's 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 FG_i where F 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 evolved calculations one can use the function

Given a list L of small group library Id's or a list of groups of order pⁿ this functions checks isomorphism of the associated modular group algebras using canonical forms for the quotients of the augmentation ideals A of FG. Here F is either F_p or F_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 function 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 F₂. The result means e.g. that the smallest quotients (of Loewy layers) such that the augmentation ideals A₁ and A₂ of the groups algebras over F₂ of the groups SmallGroup(64, 156) and SmallGroup(64, 158) are not isomorphic are A₁/A₁⁸ and A₂/A₂⁸. These are A₁/A₁⁵ and A₂/A₂⁵ 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 F₄. 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 allow to study the problem for groups not coming from the library. The following groups are studied in GLM24.

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 F₄, 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 MIPBinsSplit:

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 )

4.2 Kernel size

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ⁿ/A^n+m → A^{n ·pl}/A^{n ·pl + m}. This can be done in the package using the function

where T is a table as returned by ModIsomTable and n, m, l are as just described and the calculation is performed over the field F_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 F₂ are not isomorphic. This argument does however not work over F₄:

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

4.3 The group theoretical invariants

We document here which group-theoretical invariants are used in BinsByGT and similar functions.

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. 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:

calculates the isomorphism types of Z(G) ∩G′ and Z(G)/ Z(G) ∩G′ San85(Theorem 6.11).

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 for G/γ₂(G)^pγ₃(G) San89, the GroupInfo of G/γ₂(G)^pγ₄(G), if G is 2-generated (mentioned in Bag99, proved in MM22) and if the derived subgroup of G is elementary abelian and the Jennings series of G has length at most 2p, it returns GroupInfo for the Frattini subgroup of G HS06(p.16). This function is not applied in BinsByGTAllFields and its variations.

Denoting by D_i(G) the i-th member of the Jennings series, this function returns GroupInfo 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₄(G) Her07. For BinsByGTAllFields and its variations only the quotients D_i(G)/D_i+1(G) are computed.

computes D_i(G′)/D_i+1(G′) for all i San85(Lemma 6.26).

For N = C_G(G′/Φ(G′)), where Φ(G) denotes the Frattini subgroup, if G/N is cyclic, it returns the GroupInfo for N/Φ(G′) and G/Φ(N) Bag99. This function is not applied in BinsByGTAllFields and its variations.

returns the nilpotency class of G/Φ(G′) BC88(Proposition 2.1). This function is not applied in BinsByGTAllFields and its variations.

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.

If p is odd, G is 2-generated, the nilpotency class of G is 3 and γ₃(G) has exponent p, it returns the isomorphism types of γ₂(G) and γ₃(G) MS22(Theorem 4.1). This function is not applied in BinsByGTAllFields and its variations.

If p is odd and G′ is cyclic this returns several invariants contained in GLdRS22 GLdR23. Namely, 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 for G/R₁(γ₃(G)) and G/R₃(C_G(G′)). Here R_i(G) denotes the subgroup of G generated by the pⁱ-th powers in G. If G is additionally 2-generated, it also computes the GroupInfo for C_G(G′) and the type invariants of G (cf. GLdRS22 for the definition). For BinsByGTAllFields and its variations, the GroupInfo for G/R₁(γ₃(G)) and G/R₃(C_G(G′)) is not computed.

computes the maximal abelian direct factor of G GL24. In BinsByGTAllFields and its variations it computes the maximal elementary abelian direct factor instead MSS23.

computes some of the sections of G which are canonical following GL24(Lemma 3.6). The starting canonical group is the derived subgroup.

determines, whether G belongs to certain classes for which the Modular Isomorphism Problem has been solved positively. Namely if 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² Dre89, G is a 2-generated 2-group of nilpotency class 2 BdR21, 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 a 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 GLM24, p is odd, G′ is cyclic and R₂(G/G′) is cyclic GLdR23(Proposition 3.7). For BinsByGTAllFields and its variations it only checks, if G is a 2-group of maximal class, [G:Z(G)] = p² or G is a 2-group with cyclic center and dihedral central quotient.

computes the dimensions of the second cohomology group H²(FG, F) and of the second Hochschild cohomology group HH²(FG) = H²(FG, FG).

Computes the number of conjugacy classes which are pⁱ-th powers, for all i (Kuelshammer) and the number of conjugacy classes of pⁱ-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 HS06(Section 2.6).

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).

[Up] [Previous] [Next] [Index]