Quelle CHAP004.htm Sprache: HTML

products/Sources/formale Sprachen/GAP/pkg/modisom/htm/CHAP004.htm

<html><head><title>[ModIsom] 4 The modular isomorphism problem</title></head>
<body text="#000000" bgcolor="#ffffff">
[<a href = "chapters.htm">Up</a>] [<a href ="CHAP003.htm">Previous</a>] [<a href ="CHAP005.htm">Next</a>] [<a href = "theindex.htm">Index</a>]
<h1>4 The modular isomorphism problem</h1>

<H3>Sections</H3>
<oL>
<li> <A HREF="CHAP004.htm#SECT001">Computing bins and checking bins</a>
<li> <A HREF="CHAP004.htm#SECT002">Kernel size</a>
<li> <A HREF="CHAP004.htm#SECT003">The group theoretical invariants</a>
</ol>

Applications of the methods in this package include the study
of the modular isomorphism problems for the groups of small order
from the SmallGroupLibrary - first for groups of order dividing
28, 36 and 29 <a href="biblio.htm#Eic07"><cite>Eic07</cite></a> <a href="biblio.htm#EKo11"><cite>EKo11</cite></a> and later also 37 and 56
<a href="biblio.htm#MM22"><cite>MM22</cite></a>.
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.


<h2><a name="SECT001">4.1 Computing bins and checking bins</a></h2>

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:

<a name = "SSEC001.1"></a>
<li><code>BinsByGT( p, n, [L], [false] ) F</code>

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
Fp 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 pn 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 pn 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.

<a name = "SSEC001.2"></a>
<li><code>MIPSplitGroupsByGroupTheoreticalInvariants ( L ) F</code>

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

<a name = "SSEC001.3"></a>
<li><code>MIPSplitGroupsByGroupTheoreticalInvariantsNoCohomology(L) F</code>

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.

<a name = "SSEC001.4"></a>
<li><code>BinsByGTAllFields(p, n , [L], [false]) F</code>

<a name = "SSEC001.5"></a>
<li><code>MIPSplitGroupsByGroupTheoreticalInvariantsAllFields(L) F</code>

<a name = "SSEC001.6"></a>
<li><code>MIPSplitGroupsByGroupTheoreticalInvariantsAllFieldsNoCohomology(L) F</code>

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:

<a name = "SSEC001.7"></a>
<li><code>MIPSplitGroupsByAlgebras( [p, n], bin, [f] ) F</code>

If MIPSplitGroupsByAlgebras(p, n, bin, [f]) is called then the algebras
of groups of order pn with group Id's contained in bin are studied.
The underlying field is of order pf 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 pf
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 Gi denote SmallGroup(p^n, i).
In the second case Gi just runs through the groups contained in bin.
Denote by Ai the augmentation ideal of FGi where F is the field
of order pf or simply p, if f is not given.
The function computes and compares the canonical forms of the algebras
Ai / Aij 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 Ai/Aij. 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

<a name = "SSEC001.8"></a>
<li><code>MIPBinSplit(p, n, k, start, step, L, [f])</code>

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 Fp or Fpf, if f is given.
The parameter max is an integer or false that determines the maximal
quotients A/Amax 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/Astart 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:

<pre>
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 ) ]
</pre>

This shows that the Modular Isomorphism Problem has a positive answer for groups
of order 64 for the field F2. The result means e.g. that the smallest quotients
(of Loewy layers)
such that the augmentation ideals A1 and A2 of the groups algebras over F2 of the
groups SmallGroup(64, 156) and SmallGroup(64, 158) are not isomorphic are A1/A18
and A2/A28. These are A1/A15 and A2/A25 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 F4. Note that for the groups
SmallGroup(64, 20) and SmallGroup(64, 22) one has to consider deeper quotients
in this case.

<pre>
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 ) ]

</pre>

The other functions allow to study the problem for groups not coming from the
library. The following groups are studied in <a href="biblio.htm#GLM24"><cite>GLM24</cite></a>.

<pre>
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

</pre>

The program does not finish in a very reasonable time, if we run it over the field F4, 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:

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

</pre>


<h2><a name="SECT002">4.2 Kernel size</a></h2>

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
An/An+m → An ·pl/An ·pl + m. This can
be done in the package using the function

<a name = "SSEC002.1"></a>
<li><code>KernelSizePowerMap(T, n, m, l, [f]) F</code>

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 Fpf.
If f is not given, then it is set to 1.
We can check for instance the first calculation in <a href="biblio.htm#HS06"><cite>HS06</cite></a>(Section 4.1).

<pre>
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
</pre>

This shows that the group algebras over F2 are not isomorphic. This
argument does however not work over F4:

<pre>
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
</pre>


<h2><a name="SECT003">4.3 The group theoretical invariants</a></h2>

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

<a name = "SSEC003.1"></a>
<li><code>GroupInfo(G) F</code>

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 <a href="biblio.htm#San85"><cite>San85</cite></a>(Theorems 6.12, 6.7).
We next list the other functions which are applied, which are all small functions written
for the package:

<a name = "SSEC003.2"></a>
<li><code>CenterDerivedInfo(G) F</code>

calculates the isomorphism types of Z(G) ∩G′ and Z(G)/ Z(G) ∩G′
<a href="biblio.htm#San85"><cite>San85</cite></a>(Theorem 6.11).

<a name = "SSEC003.3"></a>
<li><code>SandlingInfo(G) F</code>

calculates several invariants coming from the small groups algebra which was first
used to study the Modular Isomorphism Problem in <a href="biblio.htm#San89"><cite>San89</cite></a>. Namely, for γi(G)
the i-th term of the lower central series of G it returns the GroupInfo for
G/γ2(G)pγ3(G) <a href="biblio.htm#San89"><cite>San89</cite></a>, the GroupInfo of G/γ2(G)pγ4(G),
if G is 2-generated (mentioned in <a href="biblio.htm#Bag99"><cite>Bag99</cite></a>, proved in <a href="biblio.htm#MM22"><cite>MM22</cite></a>) 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 <a href="biblio.htm#HS06"><cite>HS06</cite></a>(p.16).
This function is not applied in BinsByGTAllFields and its variations.

<a name = "SSEC003.4"></a>
<li><code>JenningsInfo(G) F</code>

Denoting by Di(G) the i-th member of the Jennings series, this function returns
GroupInfo for the different quotients Di(G)/Di+1(G), Di(G)/Di+2(G), Di(G)D2i+1(G)
for meaningful values of i (results <a href="biblio.htm#Jen41"><cite>Jen41</cite></a> <a href="biblio.htm#PS72"><cite>PS72</cite></a> <a href="biblio.htm#RS83"><cite>RS83</cite></a>) and if p is odd also for
G/D4(G) <a href="biblio.htm#Her07"><cite>Her07</cite></a>. For BinsByGTAllFields and its variations only the quotients
Di(G)/Di+1(G) are computed.

<a name = "SSEC003.5"></a>
<li><code>JenningsDerivedInfo(G) F</code>

computes Di(G′)/Di+1(G′) for all i <a href="biblio.htm#San85"><cite>San85</cite></a>(Lemma 6.26).

<a name = "SSEC003.6"></a>
<li><code>BaginskiInfo(G) F</code>

For N = CG(G′/Φ(G′)), where Φ(G) denotes the Frattini subgroup, if G/N is
cyclic, it returns the GroupInfo for N/Φ(G′) and G/Φ(N) <a href="biblio.htm#Bag99"><cite>Bag99</cite></a>.
This function is not applied in BinsByGTAllFields and its variations.

<a name = "SSEC003.7"></a>
<li><code>BaginskiCarantiInfo(G) F</code>

returns the nilpotency class of G/Φ(G′) <a href="biblio.htm#BC88"><cite>BC88</cite></a>(Proposition 2.1).
This function is not applied in BinsByGTAllFields and its variations.

<a name = "SSEC003.8"></a>
<li><code>NilpotencyClassInfo(G) F</code>

returns the nilpotency class of G, when the exponent of G is p or the class equals 2
or the derived subgroup is cyclic <a href="biblio.htm#BK07"><cite>BK07</cite></a>.

<a name = "SSEC003.9"></a>
<li><code>Theorem41MS22(G) F</code>

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)
<a href="biblio.htm#MS22"><cite>MS22</cite></a>(Theorem 4.1). This function is not applied in BinsByGTAllFields and its variations.

<a name = "SSEC003.10"></a>
<li><code>CyclicDerivedInfo(G) F</code>

If p is odd and G′ is cyclic this returns several invariants contained in <a href="biblio.htm#GLdRS22"><cite>GLdRS22</cite></a> <a href="biblio.htm#GLdR23"><cite>GLdR23</cite></a>.
Namely, the quotients Di(CG(G′))/Di+1(CG(G′)) for all i, the exponent of CG(G′), the isomorphism
type of CG(G′)/G′ and the GroupInfo for G/R1(γ3(G)) and G/R3(CG(G′)).
Here Ri(G) denotes the subgroup of G generated by the pi-th powers in G.
If G is additionally 2-generated, it also computes the GroupInfo for CG(G′) and the
type invariants of G (cf. <a href="biblio.htm#GLdRS22"><cite>GLdRS22</cite></a> for the definition).
For BinsByGTAllFields and its variations, the GroupInfo for G/R1(γ3(G))
and G/R3(CG(G′)) is not computed.

<a name = "SSEC003.11"></a>
<li><code>MaximalAbelianDirectFactor(G) F</code>

computes the maximal abelian direct factor of G <a href="biblio.htm#GL24"><cite>GL24</cite></a>. In BinsByGTAllFields and
its variations it computes the maximal elementary abelian direct factor instead <a href="biblio.htm#MSS23"><cite>MSS23</cite></a>.

<a name = "SSEC003.12"></a>
<li><code>NormalSubgroupsInfo(G) F</code>

computes some of the sections of G which are canonical following <a href="biblio.htm#GL24"><cite>GL24</cite></a>(Lemma 3.6). The starting canonical group is the derived subgroup.

<a name = "SSEC003.13"></a>
<li><code>IsCoveredByTheory(G) F</code>

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 <a href="biblio.htm#Bag92"><cite>Bag92</cite></a>,
p is odd, G ≤ pp+1, G has a maximal abelian subgroup and G is of maximal class <a href="biblio.htm#BC88"><cite>BC88</cite></a>,
[G:Z(G)] = p2 <a href="biblio.htm#Dre89"><cite>Dre89</cite></a>, G is a 2-generated 2-group of nilpotency class 2 <a href="biblio.htm#BdR21"><cite>BdR21</cite></a>,
p is odd, G′ is elementary abelian, the nilpotency class of G is 3 and either
CG(G′) is a maximal subgroup of G and abelian <a href="biblio.htm#MS22"><cite>MS22</cite></a>(Theorem 3.3) or a G is
3-generated and a certain condition holds on the commutator map modulo the second center of G
<a href="biblio.htm#MS22"><cite>MS22</cite></a>(Theorem 3.5), G is a 2-group with cyclic center and dihedral central
quotient <a href="biblio.htm#MSS23"><cite>MSS23</cite></a>, G is a 2-group of nilpotency class 2 with cyclic center <a href="biblio.htm#GLM24"><cite>GLM24</cite></a>,
p is odd, G′ is cyclic and R2(G/G′) is cyclic <a href="biblio.htm#GLdR23"><cite>GLdR23</cite></a>(Proposition 3.7).
For BinsByGTAllFields and its variations it only checks, if G is a 2-group of
maximal class, [G:Z(G)] = p2 or G is a 2-group with cyclic center and dihedral central
quotient.

<a name = "SSEC003.14"></a>
<li><code>DimensionTwoCohomology(G) F</code>

computes the dimensions of the second cohomology group H2(FG, F) and of the second
Hochschild cohomology group HH2(FG) = H2(FG, FG).

<a name = "SSEC003.15"></a>
<li><code>ConjugacyClassInfo(G) F</code>

Computes the number of conjugacy classes which are pi-th powers, for all i (Kuelshammer) and
the number of conjugacy classes of pi-th powers which come from conjugacy classes of the same order
(Parmenter-Polcino Milies) <a href="biblio.htm#HS06"><cite>HS06</cite></a>(Section 2.2) and the dimension of the first Hochschild
cohomology group which equals the number ∑gG logp(CG(g)/Φ(CG(g)) where the sum runs over
all the conjugacy classes of G <a href="biblio.htm#HS06"><cite>HS06</cite></a>(Section 2.6).

<a name = "SSEC003.16"></a>
<li><code>SubgroupsInfo(G) F</code>

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 <a href="biblio.htm#HS06"><cite>HS06</cite></a>(Section 2.5).


[<a href = "chapters.htm">Up</a>] [<a href ="CHAP003.htm">Previous</a>] [<a href ="CHAP005.htm">Next</a>] [<a href = "theindex.htm">Index</a>]

<address>ModIsom manual September 2024
</address></body></html>

quality100%

¤ Dauer der Verarbeitung: 0.31 Sekunden (vorverarbeitet) ¤

Wurzel

Suchen

Beweissystem der NASA

Beweissystem Isabelle

NIST Cobol Testsuite

Cephes Mathematical Library

Wiener Entwicklungsmethode

Haftungshinweis

Die Informationen auf dieser Webseite wurden nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit, noch Qualität der bereit gestellten Informationen zugesichert.

Bemerkung:

Die farbliche Syntaxdarstellung ist noch experimentell.