Some steps in the verification of the ordinary character table of the Monster group
THOMAS BREUER, KAY MAGAARD, ROBERT A. WILSON
December 12th, 2024
We show the details of certain computations that are used in [BMW24].
Contents
1 Overview
2 Some restrictions of the natural character of M
3 The permutation character (12.BM)2.B
4 The conjugacy classes of M
4.1 Our strategy to describe the conjugacy classes of M
4.2 Utility functions
4.3 Classes of elements of even order
4.4 Classes of elements of order divisible by 3
4.5 Classes of elements of order divisible by 5
4.6 Classes of elements of order divisible by 11
4.7 Classes of elements of the orders 17, 19, 23, 31, 47
4.8 Classes of elements of order 13
4.9 Classes of elements of order divisible by 29
4.10 Classes of elements of order divisible by 41
4.11 Classes of elements of order divisible by 59
4.12 Classes of elements of order divisible by 71
4.13 Classes of elements of order divisible by 7
5 The power maps of M
6 The degree 196 883 character χ of M
7 The irreducible characters of M
8 Appendix: The character table of 21+24+.Co1
9 Appendix: The character table of 31+12+:6.Suz.2
9.1 Overview
9.2 A permutation representation of H / X
9.3 A permutation representation of H
9.4 Compute the character table of H
10 Appendix: The character table of 51+6+.4.J2.2
1 Overview
The aim of [BMW24] is to verify the ordinary character table
of the Monster group M.
Here we collect,
in the form of an explicit and reproducible
GAP [GAP24] session protocol,
the relevant computations that are needed in that paper.
We proceed as follows.
Section 2 verifies the decomposition of the restrictions of the
ordinary irreducible character of degree 196 883 of M
to the subgroups 2.B and 3.Fi24′ (and 3.Fi24),
as stated in [BMW24,Lemma 1].
Section 3 verifies the decompositions of
the transitive constituents of the permutation character
of the action of CM(a) ≅ 2.B on the conjugacy class aM,
where a is a 2A involution in M.
Sections 4 and 5 construct the
character table head of M, that is,
the lists of conjugacy class lengths, element orders, and power maps.
Section 6 constructs the values of the irreducible
degree 196 883 character of M
and decides the isomorphism type of the 3B normalizer in M.
With this information and with the (already verified) character tables
of the subgroups 2.B, 21+24+.Co1, 3.Fi24, and
31+12+.2.Suz.2 of M,
computing the irreducible characters of M is then easy;
this corresponds to [BMW24,Section 5]
and is done in Section 7.
The final sections 8,
9, 10 document the constructions of three
character tables of subgroups of M.
We will use the GAP Character Table Library
and the interface to the ATLAS of Group Representations [WWT+],
thus we load these GAP packages.
gap> LoadPackage( "ctbllib", false );
true
gap> LoadPackage( "atlasrep", false );
true
The MAGMA system [BCP97] will be needed
for computing some character tables
and for many conjugacy tests.
If the following command returns false
then these steps will not work.
gap> CTblLib.IsMagmaAvailable();
true
We set the line length to 72, like in other standard testfiles.
gap> SizeScreen( [ 72 ] );;
2 Some restrictions of the natural character of M
We assume the existence of an ordinary irreducible character χ
of degree 196 883 of the Monster group M,
and that M has only two conjugacy classes of involutions.
First we compute the restriction of χ to 2.B.
The only faithful degree 196 883 character of 2.B
that has at most two different values on involutions is
1a + 4371a + 96255a + 96256a, as claimed in [BMW24,Lemma 1].
This follows from the following data about 2.B.
gap> table2B:= CharacterTable( "2.B" );;
gap> cand:= Filtered( Irr( table2B ), x -> x[1] <= 196883 );;
gap> List( cand, x -> x[1] );
[ 1, 4371, 96255, 96256 ]
gap> inv:= Positions( OrdersClassRepresentatives( table2B ), 2 );
[ 2, 3, 4, 5, 7 ]
gap> PrintArray( List( cand, x -> x{ Concatenation( [ 1 ], inv ) } ) );
[ [ 1, 1, 1, 1, 1, 1 ],
[ 4371, 4371, -493, 275, 275, 19 ],
[ 96255, 96255, 4863, 2047, 2047, 255 ],
[ 96256, -96256, 0, 2048, -2048, 0 ] ]
Note that 96256a must occur as a constituent
because it is the only faithful candidate,
and it can occur only once because otherwise only 4371a + 2 ·96256a
or 4371 ·1a + 2 ·96256a would be possible decompositions,
which have more than two values on involution classes.
Thus the values of χ2.B on the classes 4 and 5 differ by 4096.
If 96255a would not occur then the values of χ2.B
on the classes 3 and 7 would differ by 512 times the multiplicity of 4371,
but 65659 ·1a + 8 ·4371a + 96256a is not a solution.
Thus 96255a must occur exactly once.
The sum of 96255a and 96256a has four different values
on involutions, hence also 4371a must occur.
We see that the values of χ on the classes of involutions are
4371 and 275, respectively.
gap> Sum( cand ){ inv };
[ 4371, 4371, 4371, 275, 275 ]
The restriction of χ to 3.Fi24′ is computed similarly,
as follows.
Exactly seven irreducible characters of 3.Fi24′ can occur as
constituents of the restriction of χ.
gap> table3Fi24prime:= CharacterTable( "3.Fi24'" );;
gap> cand:= Filtered( Irr( table3Fi24prime ), x -> x[1] <= 196883 );;
gap> inv:= Positions( OrdersClassRepresentatives( table3Fi24prime ), 2 );
[ 4, 7 ]
gap> mat:= List( cand, x -> x{ Concatenation([1], inv)});;
gap> PrintArray( mat );
[ [ 1, 1, 1 ],
[ 8671, 351, -33 ],
[ 57477, 1157, 133 ],
[ 783, 79, 15 ],
[ 783, 79, 15 ],
[ 64584, 1352, 72 ],
[ 64584, 1352, 72 ] ]
Since χ is rational, we need to consider only rationally irreducible
characters, that is, the possible constituents are 1a, 8671a, 57377a,
783ab, and 64584ab.
gap> List( cand, x -> x[2] );
[ 1, 8671, 57477, 783*E(3), 783*E(3)^2, 64584*E(3), 64584*E(3)^2 ]
We see that the value on the first class of involutions must be 4371,
since all values of the possible constituents are positive
and too large for the other possible value 275.
Since the values of all possible constituents on the second class of
involutions are at most equal to the values on the first class,
and equal only for 1a,
we conclude that the value on the second class of involutions is 275.
We see from the ratio of the value on the identity element
and on the first class of involutions
that constituents of degree 57477 or 2 ·64584 exist.
gap> Float( 196883 / 4371 );
45.043
gap> List( mat, v -> Float( v[1] / v[2] ) );
[ 1., 24.7037, 49.6776, 9.91139, 9.91139, 47.7692, 47.7692 ]
gap> Float( ( 196883 - 2 * 64584 ) / ( 4371 - 2 * 1352 ) );
40.6209
gap> Float( ( 196883 - 57477 ) / ( 4371 - 1157 ) );
43.3746
gap> Float( ( 196883 - 2*57477 ) / ( 4371 - 2*1157 ) );
39.8294
gap> Float( ( 196883 - 3*57477 ) / ( 4371 - 3*1157 ) );
27.1689
First suppose that 64584ab is not a constituent.
The above ratios imply that (at least) three constituents of degree 57477
must occur.
However, then the degree admits at most two constituents of degree 8671,
hence the value on the second class of involutions cannot be 275,
a contradiction.
This means that both 64584ab and 57477a occur with multiplicity one.
gap> mat[3] + mat[6] + mat[7];
[ 186645, 3861, 277 ]
The second involution class forces one constituent of degree 8671
(which is the only candidate that can contribute a negative value),
and then a character of degree 1567 remains to be decomposed.
The only solution for the degrees of its constituents is 1 + 1566.
We get the decomposition
1a + 8671a + 57477a + 783ab + 64584ab,
as claimed in [BMW24,Lemma 2].
gap> Sum( mat );
[ 196883, 4371, 275 ]
The characters of the degrees 1, 8671, and 57477 extend two-fold
from 3.Fi24′ to 3.Fi24.
In order to decompose the restriction of χ to 3.Fi24,
we have to determine which extensions from 3.Fi24′ occur.
The following irreducible characters of 3.Fi24 can occur as
constituents of the restriction of χ.
gap> table3Fi24:= CharacterTable( "3.Fi24" );;
gap> cand:= Filtered( Irr( table3Fi24 ), x -> x[1] <= 196883 );;
gap> inv:= Positions( OrdersClassRepresentatives( table3Fi24 ), 2 );
[ 3, 5, 172, 173 ]
gap> mat:= List( cand, x -> x{ Concatenation([1], inv)});;
gap> PrintArray( mat );
[ [ 1, 1, 1, 1, 1 ],
[ 1, 1, 1, -1, -1 ],
[ 8671, 351, -33, 1495, -41 ],
[ 8671, 351, -33, -1495, 41 ],
[ 57477, 1157, 133, 5865, 233 ],
[ 57477, 1157, 133, -5865, -233 ],
[ 1566, 158, 30, 0, 0 ],
[ 129168, 2704, 144, 0, 0 ] ]
We get the decomposition
1a + 8671b + 57477a + 1566a + 129168a claimed in [BMW24,Lemma 2].
gap> Sum( mat{ [ 1, 4, 5, 7, 8 ] } );
[ 196883, 4371, 275, 4371, 275 ]
3 The permutation character (12.BM)2.B
According to [GMS89,Tables VII, IX],
the restriction of the permutation character 12.BM to 2.B
decomposes into nine transitive permutation characters 1U2.B,
with the point stabilizers U listed in Table 1.
Table 1: Suborbit information
| a c ∈ | Ga,c | |cGa| |
| 1A | 2.B | 1 |
| 2A | 22.2E6(2) | 27143910000 |
| 2B | 22+22.Co2 | 11707448673375 |
| 3A | Fi23 | 2031941058560000 |
| 3C | Th | 91569524834304000 |
| 4A | 21+22.McL | 1102935324621312000 |
| 4B | 2.F4(2) | 1254793905192960000 |
| 5A | HN | 30434513446055706624 |
| 6A | 2.Fi22 | 64353605265653760000 |
Here a denotes the central involution in 2.B,
the action is that on the M-conjugacy class of a,
and c ∈ aM is a representative of the orbit in question.
In this section, we compute the nine characters 1U2.B,
where U is one of the above point stabilizers Ga,c.
Note that a ∈ Ga,c holds
(and thus the character is an inflated character of B)
if and only if a and c commute;
this happens exactly for the first three orbits.
All subgroups U except 22+22.Co2 and 21+22.McL
are ATLAS groups whose character tables have been verified.
The subgroup 22+22.Co2 is the preimage of a maximal subgroup
21+22.Co2 of B under the natural epimorphism from 2.B,
and the computation/verification of the character table of 21+22.Co2
has been described in [BMW20].
It will turn out that we do not need the character table of 21+22.McL.
The nine characters will be stored in the variables
pi1, pi2, ..., pi9.
For U = 2.B,
we have 1U2.B = 12.B.
gap> pi1:= TrivialCharacter( table2B );;
For U = 22.2E6(2),
the character 1U2.B is the inflation of 1[U]B
from B to 2.B,
for [U] = U / 〈a 〉 = 2.2E6(2).
(Note that the class fusion from [U] to B is not uniquely
determined by the character tables of the two groups,
but the permutation character is unique.)
gap> tableB:= CharacterTable( "B" );;
gap> tableUbar:= CharacterTable( "2.2E6(2)" );;
gap> fus:= PossibleClassFusions( tableUbar, tableB );;
gap> pi:= Set( fus,
> map -> InducedClassFunctionsByFusionMap( tableUbar, tableB,
> [ TrivialCharacter( tableUbar ) ], map )[1] );;
gap> Length( pi );
1
gap> pi2:= Inflated( tableB, table2B, pi )[1];;
gap> mult:= List( Irr( table2B ),
> chi -> ScalarProduct( table2B, chi, pi2 ) );;
gap> Maximum( mult );
1
gap> Positions( mult, 1 );
[ 1, 2, 3, 5, 7, 13, 15, 17 ]
For U = 22+22.Co2,
the character 1U2.B is the inflation of 1[U]B
from B to 2.B,
for [U] = U / 〈a 〉 = 21+22.Co2,
a maximal subgroup of B.
gap> tableUbar:= CharacterTable( "BN2B" );
CharacterTable( "2^(1+22).Co2" )
gap> fus:= PossibleClassFusions( tableUbar, tableB );;
gap> pi:= Set( fus,
> map -> InducedClassFunctionsByFusionMap( tableUbar, tableB,
> [ TrivialCharacter( tableUbar ) ], map )[1] );;
gap> Length( pi );
1
gap> pi3:= Inflated( tableB, table2B, pi )[1];;
gap> mult:= List( Irr( table2B ),
> chi -> ScalarProduct( table2B, chi, pi3 ) );;
gap> Maximum( mult );
1
gap> Positions( mult, 1 );
[ 1, 3, 5, 8, 13, 15, 28, 30, 37, 40 ]
Next we consider U = Fi23.
gap> tableU:= CharacterTable( "Fi23" );;
gap> fus:= PossibleClassFusions( tableU, table2B );;
gap> pi:= Set( fus,
> map -> InducedClassFunctionsByFusionMap( tableU, table2B,
> [ TrivialCharacter( tableU ) ], map )[1] );;
gap> Length( pi );
1
gap> pi4:= pi[1];;
gap> mult:= List( Irr( table2B ),
> chi -> ScalarProduct( table2B, chi, pi4 ) );;
gap> Maximum( mult );
1
gap> Positions( mult, 1 );
[ 1, 2, 3, 5, 7, 8, 9, 12, 13, 15, 17, 23, 27, 30, 32, 40, 41, 54,
63, 68, 77, 81, 83, 185, 186, 187, 188, 189, 194, 195, 196, 203,
208, 220 ]
Next we consider U = Th.
gap> tableU:= CharacterTable( "Th" );;
gap> fus:= PossibleClassFusions( tableU, table2B );;
gap> pi:= Set( fus,
> map -> InducedClassFunctionsByFusionMap( tableU, table2B,
> [ TrivialCharacter( tableU ) ], map )[1] );;
gap> Length( pi );
1
gap> pi5:= pi[1];;
gap> mult:= List( Irr( table2B ),
> chi -> ScalarProduct( table2B, chi, pi5 ) );;
gap> Maximum( mult );
2
gap> Positions( mult, 1 );
[ 1, 3, 7, 8, 12, 13, 16, 19, 27, 28, 34, 38, 41, 57, 68, 70, 77, 78,
85, 89, 113, 114, 116, 129, 133, 142, 143, 145, 155, 156, 185, 187,
188, 193, 195, 196, 201, 208, 216, 219, 225, 232, 233, 235, 236,
237, 242 ]
gap> Positions( mult, 2 );
[ 62 ]
For U = 21+22.McL, we carry out the computations described in
[Breb,Section "A permutation character of 2.B"].
We know that U is a subgroup of 22+22.Co2,
and that 〈U, a 〉 has the structure 22+22.McL.
As a first step, we induce the trivial character of 〈U, a 〉
to 2.B,
which can be performed by inducing the trivial character of McL to Co2,
then to inflate this character to 21+22.Co2,
then to induce this character to B,
and then to inflate this character to 2.B,
gap> mcl:= CharacterTable( "McL" );;
gap> co2:= CharacterTable( "Co2" );;
gap> fus:= PossibleClassFusions( mcl, co2 );;
gap> Length( fus );
4
gap> ind:= Set( fus, map -> InducedClassFunctionsByFusionMap( mcl, co2,
> [ TrivialCharacter( mcl ) ], map )[1] );;
gap> Length( ind );
1
gap> bm2:= CharacterTable( "BM2" );
CharacterTable( "2^(1+22).Co2" )
gap> infl:= Inflated( co2, bm2, ind );;
gap> ind:= Induced( bm2, tableB, infl );;
gap> infl:= Inflated( tableB, table2B, ind )[1];;
As a second step,
we compute 1U2.B with the GAP function PermChars,
using that we can speed up these computations by prescribing
the permutation character induced from the closure of U with
the normal subgroup 〈a 〉 of 2.B.
(We are lucky:
There is a unique solution, and its computation is quite fast.)
gap> centre:= ClassPositionsOfCentre( table2B );
[ 1, 2 ]
gap> pi:= PermChars( table2B, rec( torso:= [ 2 * infl[1], 0 ],
> normalsubgroup:= centre,
> nonfaithful:= infl ) );;
gap> Length( pi );
1
gap> pi6:= pi[1];;
gap> List( Irr( table2B ), chi -> ScalarProduct( table2B, chi, pi6 ) );
[ 1, 1, 2, 1, 2, 0, 2, 3, 2, 0, 0, 1, 4, 1, 2, 0, 3, 2, 0, 2, 0, 0,
2, 2, 0, 0, 2, 3, 1, 5, 0, 4, 3, 2, 0, 0, 3, 2, 0, 6, 4, 0, 1, 1,
0, 0, 0, 0, 3, 0, 1, 0, 0, 5, 0, 5, 2, 0, 0, 2, 0, 0, 4, 1, 0, 2,
0, 4, 2, 4, 4, 3, 0, 2, 4, 2, 4, 0, 3, 0, 3, 2, 5, 0, 1, 0, 3, 1,
0, 1, 1, 2, 5, 3, 1, 1, 4, 5, 1, 1, 0, 3, 0, 0, 3, 2, 1, 1, 2, 1,
1, 4, 0, 3, 2, 3, 1, 3, 0, 1, 3, 0, 2, 2, 1, 3, 3, 0, 0, 2, 0, 0,
0, 0, 3, 0, 3, 3, 3, 1, 0, 3, 0, 4, 0, 1, 0, 0, 2, 0, 0, 2, 0, 0,
2, 1, 1, 0, 0, 0, 0, 1, 2, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 0, 2, 1,
1, 3, 3, 0, 0, 0, 1, 1, 1, 1, 2, 3, 2, 0, 0, 2, 2, 4, 3, 5, 2, 4,
0, 0, 0, 0, 5, 2, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 7, 0, 0, 1, 7,
7, 0, 0, 0, 1, 6, 4, 5, 0, 0, 3, 0, 0, 0, 0, 0, 4, 1, 1, 3, 8, 3,
2, 2, 5, 0, 1 ]
Next we consider U = 2.F4(2).
We know that U does not contain the central involution of 2.B.
gap> tableU:= CharacterTable( "2.F4(2)" );;
gap> fus:= PossibleClassFusions( tableU, table2B );;
gap> pi:= Set( fus, map -> InducedClassFunctionsByFusionMap( tableU, table2B,
> [ TrivialCharacter( tableU ) ], map )[1] );;
gap> Length( pi );
2
gap> pi:= Filtered( pi, x -> ClassPositionsOfKernel( x ) = [ 1 ] );;
gap> Length( pi );
1
gap> pi7:= pi[1];;
gap> List( Irr( table2B ), chi -> ScalarProduct( table2B, chi, pi7 ) );
[ 1, 1, 2, 0, 2, 0, 2, 2, 1, 0, 0, 2, 4, 1, 3, 0, 2, 1, 0, 0, 0, 0,
2, 1, 0, 0, 2, 2, 1, 4, 0, 2, 1, 2, 0, 0, 3, 2, 0, 4, 4, 0, 0, 0,
0, 0, 1, 0, 0, 0, 1, 0, 0, 2, 1, 3, 3, 0, 0, 3, 0, 1, 4, 0, 0, 3,
0, 6, 0, 3, 2, 0, 0, 1, 4, 1, 4, 2, 6, 1, 4, 0, 4, 0, 1, 1, 2, 0,
0, 3, 2, 1, 3, 2, 0, 0, 4, 5, 3, 1, 0, 3, 0, 0, 1, 1, 2, 0, 0, 2,
0, 2, 0, 3, 3, 3, 0, 4, 1, 0, 4, 1, 1, 1, 1, 1, 2, 1, 1, 2, 3, 0,
0, 2, 2, 0, 5, 5, 3, 0, 1, 5, 1, 4, 0, 1, 0, 1, 1, 0, 0, 3, 1, 0,
2, 3, 1, 0, 2, 0, 0, 2, 1, 0, 1, 0, 0, 1, 0, 0, 0, 1, 0, 0, 1, 2,
1, 4, 4, 0, 0, 0, 3, 1, 1, 1, 2, 2, 2, 0, 0, 1, 2, 3, 3, 3, 1, 2,
0, 0, 1, 1, 4, 2, 0, 0, 0, 3, 2, 0, 0, 0, 0, 0, 0, 4, 0, 0, 1, 5,
5, 0, 1, 1, 2, 2, 4, 4, 0, 0, 3, 1, 1, 1, 0, 0, 4, 1, 1, 5, 7, 3,
2, 5, 5, 0, 1 ]
Next we consider U = HN.
gap> tableU:= CharacterTable( "HN" );;
gap> fus:= PossibleClassFusions( tableU, table2B );;
gap> pi:= Set( fus, map -> InducedClassFunctionsByFusionMap( tableU, table2B,
> [ TrivialCharacter( tableU ) ], map )[1] );;
gap> Length( pi );
1
gap> pi8:= pi[1];;
gap> List( Irr( table2B ), chi -> ScalarProduct( table2B, chi, pi8 ) );
[ 1, 1, 2, 1, 2, 0, 3, 4, 2, 1, 1, 4, 4, 2, 1, 1, 3, 3, 1, 3, 0, 0,
5, 3, 0, 0, 6, 4, 5, 6, 1, 7, 4, 7, 0, 0, 3, 8, 2, 6, 11, 2, 5, 5,
0, 0, 2, 1, 3, 4, 7, 0, 0, 7, 3, 9, 5, 0, 0, 6, 4, 2, 13, 6, 0, 4,
4, 12, 11, 16, 9, 7, 3, 11, 13, 12, 20, 5, 10, 6, 11, 13, 17, 4,
10, 7, 19, 7, 7, 8, 10, 14, 18, 19, 5, 10, 12, 23, 7, 12, 6, 24, 6,
4, 17, 16, 8, 9, 17, 11, 12, 23, 8, 24, 18, 26, 21, 29, 10, 18, 31,
10, 24, 21, 17, 27, 35, 13, 14, 29, 19, 12, 7, 18, 26, 15, 34, 34,
35, 20, 14, 36, 14, 39, 8, 29, 24, 15, 40, 13, 9, 38, 24, 17, 35,
32, 26, 26, 24, 22, 17, 31, 39, 29, 30, 30, 19, 44, 37, 37, 28, 30,
31, 29, 42, 40, 40, 56, 56, 30, 30, 42, 50, 47, 2, 2, 4, 6, 4, 0,
0, 4, 6, 10, 10, 12, 8, 12, 0, 0, 2, 4, 16, 10, 0, 0, 2, 12, 10, 0,
0, 0, 0, 0, 0, 28, 0, 0, 14, 34, 40, 2, 10, 10, 22, 40, 44, 44, 8,
8, 36, 14, 14, 16, 8, 8, 46, 28, 28, 58, 90, 72, 70, 92, 104, 56,
90 ]
Finally, we consider U = 2.Fi22.
There are two candidates for the permutation character (1U)2.B,
according to the possible class fusions.
One of the two characters is zero on the class of the central involution
of 2.B, the other is not.
We know that U does not contain the central involution of 2.B,
hence we can decide which character is correct.
gap> tableU:= CharacterTable( "2.Fi22" );;
gap> fus:= PossibleClassFusions( tableU, table2B );;
gap> pi:= Set( fus, map -> InducedClassFunctionsByFusionMap( tableU, table2B,
> [ TrivialCharacter( tableU ) ], map )[1] );;
gap> Length( pi );
2
gap> pi:= Filtered( pi, x -> ClassPositionsOfKernel( x ) = [ 1 ] );;
gap> Length( pi );
1
gap> pi9:= pi[1];;
gap> List( Irr( table2B ), chi -> ScalarProduct( table2B, chi, pi9 ) );
[ 1, 2, 3, 1, 4, 1, 5, 5, 5, 1, 1, 5, 8, 4, 4, 1, 7, 6, 0, 5, 0, 0,
10, 7, 0, 0, 10, 6, 6, 13, 3, 14, 10, 11, 0, 0, 5, 11, 2, 14, 19,
6, 6, 5, 0, 0, 0, 3, 6, 7, 11, 0, 0, 17, 2, 20, 9, 0, 0, 12, 8, 1,
23, 11, 1, 8, 7, 23, 18, 27, 18, 12, 7, 22, 29, 21, 34, 6, 22, 7,
22, 18, 33, 3, 19, 10, 34, 12, 12, 15, 17, 28, 34, 34, 7, 20, 26,
40, 15, 25, 3, 40, 9, 6, 34, 25, 18, 21, 30, 21, 18, 43, 12, 45,
39, 49, 38, 51, 18, 32, 63, 19, 42, 41, 33, 48, 64, 27, 29, 52, 38,
29, 19, 40, 47, 31, 69, 69, 65, 42, 35, 68, 27, 73, 20, 53, 46, 38,
75, 29, 24, 72, 50, 41, 72, 68, 58, 52, 54, 50, 44, 64, 75, 58, 69,
65, 49, 85, 75, 75, 63, 68, 65, 63, 90, 87, 83, 118, 118, 74, 71,
90, 109, 109, 2, 3, 6, 9, 8, 0, 0, 7, 10, 18, 16, 22, 12, 23, 0, 0,
2, 6, 28, 19, 0, 0, 5, 16, 18, 0, 0, 0, 0, 0, 0, 52, 1, 1, 26, 59,
76, 11, 18, 18, 39, 77, 80, 77, 22, 22, 66, 27, 27, 33, 20, 20, 87,
60, 60, 103, 175, 148, 152, 187, 215, 140, 201 ]
Now we can form the restriction of (12.B)M to 2.B.
gap> constit:= [ pi1, pi2, pi3, pi4, pi5, pi6, pi7, pi8, pi9 ];;
gap> pi:= Sum( constit );;
4 The conjugacy classes of M
4.1 Our strategy to describe the conjugacy classes of M
We know the order of M and its prime divisors.
Let us check whether this fits to our data computed up to now.
gap> sizeM:= pi[1] * Size( table2B );
808017424794512875886459904961710757005754368000000000
gap> StringPP( sizeM );
"2^46*3^20*5^9*7^6*11^2*13^3*17*19*23*29*31*41*47*59*71"
gap> sizeM = Size( CharacterTable( "M" ) );
true
For each prime p dividing |M|,
we classify the conjugacy classes of elements of order p in M
and use the facts that for each such class representative x,
the classes of roots of x in the centralizer/normalizer of x
are in bijection with the corresponding classes in M,
and that this bijection respects centralizer orders.
For each element x ∈ M of order p ∈ { 2, 3, 5 },
we will use the character table of NM(〈x 〉)
to establish M-conjugacy classes of roots of x.
In order not to count the same class several times,
we proceed by increasing p,
and collect only those classes of roots of x for which p is the smallest
prime divisor of the element order.
For elements x ∈ M of prime order p > 5,
it is not necessary to use the character table of NM(〈x 〉);
we will use the permutation character values (12.B)M(x)
and ad hoc arguments.
4.2 Utility functions
During the process of finding the conjugacy classes of M,
we record our knowledge about the character table of M
in a global GAP variable head,
which is a record with the following components.
- Size
-
the group order |M|,
- SizesCentralizers
-
the list of centralizer orders of the conjugacy classes
established up to now,
- OrdersClassRepresentatives
-
the list of corresponding representative orders,
- fusions
-
a list that collects the currently known partial class fusions into M;
each entry is a record with the components
subtable (the character table of the subgroup)
and map (the list of known images;
unknown positions are unbound).
We initialize this variable, using the group order M
and that there is an identity element.
gap> head:= rec( Size:= sizeM,
> SizesCentralizers:= [ sizeM ],
> OrdersClassRepresentatives:= [ 1 ],
> fusions:= [],
> );;
The function ExtendTableHeadByRootClasses takes
the object head,
the character table s of a subgroup H of M,
and an integer pos as its arguments,
where it is assumed that the pos-th class of s
contains an element x of prime order p
such that NM(〈x 〉) = H holds
and such that head contains information only about
those classes of M whose elements have order divisible by a prime
that is smaller than p.
gap> ExtendTableHeadByRootClasses:= function( head, s, pos )
> local fus, orders, p, cents, oldnumber, i, ord;
>
> # Initialize the fusion information.
> fus:= rec( subtable:= s, map:= [ 1 ] );
> Add( head.fusions, fus );
>
> # Compute the positions of root classes of 'pos'.
> orders:= OrdersClassRepresentatives( s );
> p:= orders[ pos ];
> cents:= SizesCentralizers( s );
> oldnumber:= Length( head.OrdersClassRepresentatives );
>
> # Run over the classes of 's'
> # are already contained in head
> for i in [ 1 .. NrConjugacyClasses( s ) ] do
> ord:= orders[i];
> if ord mod p = 0 and
> Minimum( PrimeDivisors( ord ) ) = p and
> PowerMap( s, ord / p, i ) = pos then
> # Class 'i' is a root class of 'pos' and is new in 'head'.
> Add( head.SizesCentralizers, cents[i] );
> Add( head.OrdersClassRepresentatives, orders[i] );
> fus.map[i]:= Length( head.SizesCentralizers );
> fi;
> od;
>
> Print( "#I after ", Identifier( s ), ": found ",
> Length( head.OrdersClassRepresentatives ) - oldnumber,
> " classes, now have ",
> Length( head.OrdersClassRepresentatives ), "\n" );
> end;;
In several cases, we will establish a conjugacy class gM without
knowing the character table of a suitable subgroup of M to which
ExtendTableHeadByRootClasses can be applied, where g is among
the root classes.
That is, we may know just element order s
and centralizer order cent.
We are a bit better off if we know the character table s
of a subgroup of M and the list poss of all those classes
in this table which fuse to the class gM, because then we can
store this information in the partial class fusion from s
that is stored in head.
gap> ExtendTableHeadByCentralizerOrder:= function( head, s, cent, poss )
> local ord, fus, i;
>
> if IsCharacterTable( s ) then
> ord:= Set( OrdersClassRepresentatives( s ){ poss } );
> if Length( ord ) <> 1 then
> Error( "classes cannot fuse" );
> fi;
> ord:= ord[1];
> elif IsInt( s ) then
> ord:= s;
> fi;
> Add( head.SizesCentralizers, cent );
> Add( head.OrdersClassRepresentatives, ord );
>
> Print( "#I after order ", ord, " element" );
> if IsCharacterTable( s ) then
> # extend the stored fusion from s
> fus:= First( head.fusions,
> r -> Identifier( r.subtable ) = Identifier( s ) );
> for i in poss do
> fus.map[i]:= Length( head.SizesCentralizers );
> od;
> Print( " from ", Identifier( s ) );
> fi;
> Print( ": have ",
> Length( head.OrdersClassRepresentatives ), " classes\n" );
> end;;
The permutation character 1HG, where H ≤ G are two groups,
has the property 1HG(g) = |CG(g)| ·|gG ∩H| / |H|.
For g ∈ H,
this implies that |CG(g)| = 1HG(g) ·|H| / |gG ∩H|
can be computed from the character (1HG)H and the class lengths in H,
provided that we know which classes of H fuse into gG.
The function ExtendTableHeadByPermCharValue extends the information
in head by the data for the class gM,
where s is the character table of H,
pi_rest_to_s is (1HG)H,
and poss is the list of positions of those classes in s
that fuse to gM.
gap> ExtendTableHeadByPermCharValue:= function( head, s, pi_rest_to_s, poss )
> local pival, cent;
>
> pival:= Set( pi_rest_to_s{ poss } );
> if Length( pival ) <> 1 then
> Error( "classes cannot fuse" );
> fi;
>
> cent:= pival[1] * Size( s ) / Sum( SizesConjugacyClasses( s ){ poss } );
> ExtendTableHeadByCentralizerOrder( head, s, cent, poss );
> end;;
4.3 Classes of elements of even order
By [BMW24],
we know that M has exactly two conjugacy classes of involutions,
and that the involution centralizers have the structures
2.B (for the class 2A) and
21+24+.Co1 (for the class 2B), respectively.
Moreover, the character tables of these subgroups that are
stored in the GAP Character Table Library are correct.
For 2.B, this follows from the correctness of the character table of B
as shown in [BMW20] and the computations
in [].
For 21+24+.Co1, the recomputation of the character table is described
in Section 8.
Thus we can determine the M-conjugacy classes of elements of even order
as follows.
gap> s:= CharacterTable( "2.B" );;
gap> ClassPositionsOfCentre( s );
[ 1, 2 ]
gap> ExtendTableHeadByRootClasses( head, s, 2 );
#I after 2.B: found 42 classes, now have 43
gap> s:= CharacterTable( "MN2B" );;
gap> ClassPositionsOfCentre( s );
[ 1, 2 ]
gap> ExtendTableHeadByRootClasses( head, s, 2 );
#I after 2^1+24.Co1: found 91 classes, now have 134
4.4 Classes of elements of order divisible by 3
We know that M has exactly three conjugacy classes of elements
of order 3,
and that their normalizers have the structures
3.Fi24 (for the class 3A),
31+12+.2.Suz.2 (for the class 3B),
and S3 ×Th (for the class 3C), respectively.
Moreover,
the GAP character tables of 3.Fi24 and Th are ATLAS tables
and have been verified, see [BMO17].
We determine the M-conjugacy classes of elements of odd order
that are roots of 3A or 3C elements, as follows.
gap> s:= CharacterTable( "3.Fi24" );;
gap> ClassPositionsOfPCore( s, 3 );
[ 1, 2 ]
gap> ExtendTableHeadByRootClasses( head, s, 2 );
#I after 3.F3+.2: found 12 classes, now have 146
gap> s:= CharacterTableDirectProduct( CharacterTable( "Th" ),
> CharacterTable( "Symmetric", 3 ) );;
gap> ClassPositionsOfPCore( s, 3 );
[ 1, 3 ]
gap> ExtendTableHeadByRootClasses( head, s, 3 );
#I after ThxSym(3): found 7 classes, now have 153
The situation with the 3B normalizer is more involved.
Section 9 documents the construction of the character table
of a downward extension of the structure 31+12+:6.Suz.2
of the 3B normalizer, and gives two
candidates for the character table of the 3B normalizer.
It will turn out that each of these candidates leads to "the same"
root classes,
in the sense that the number of these classes, their element orders,
and their centralizer orders are equal.
Note that the 3-core of H = 31+12+:6.Suz.2 has the structure
X ×N,
where X has order 3
and N ≅ 31+12+ such that H / N ≅ 6.Suz.2 holds.
We are interested in the two "diagonal" factors, that is,
the factors of H by the one of the two normal subgroups of order 3 in H
that are not equal to X or Z(N).
(See the picture in Section 9 for the details.)
First we exclude the normal subgroup of order 3 that is contained in the
unique normal subgroup N of order 313.
gap> exts:= CharacterTable( "3^(1+12):6.Suz.2" );;
gap> kernels:= Positions( SizesConjugacyClasses( exts ), 2 );
[ 2, 18, 19, 20 ]
gap> order3_13:= Filtered( ClassPositionsOfNormalSubgroups( exts ),
> l -> Sum( SizesConjugacyClasses( exts ){ l } ) = 3^13 );
[ [ 1 .. 4 ] ]
gap> kernels:= Difference( kernels, order3_13[1] );
[ 18, 19, 20 ]
The classes in the subgroup X can be identified by the fact that
exactly one factor of H by a normal subgroup of order 3 admits a
class fusion from 2.Suz.2, and hence this must be the split extension
of 31+12+ with 2.Suz.2.
gap> facts:= List( kernels, i -> exts / [ 1, i ] );
[ CharacterTable( "3^(1+12):6.Suz.2/[ 1, 18 ]" ),
CharacterTable( "3^(1+12):6.Suz.2/[ 1, 19 ]" ),
CharacterTable( "3^(1+12):6.Suz.2/[ 1, 20 ]" ) ]
gap> f:= CharacterTable( "2.Suz.2" );;
gap> facts:= Filtered( facts,
> x -> Length( PossibleClassFusions( f, x ) ) = 0 );
[ CharacterTable( "3^(1+12):6.Suz.2/[ 1, 19 ]" ),
CharacterTable( "3^(1+12):6.Suz.2/[ 1, 20 ]" ) ]
We compute the root classes for both candidates.
For that,
we first create a copy head2 of the information in head.
gap> kernels:= List( facts,
> f -> Positions( SizesConjugacyClasses( f ), 2 ) );
[ [ 2 ], [ 2 ] ]
gap> head2:= StructuralCopy( head );;
gap> ExtendTableHeadByRootClasses( head, facts[1], 2 );
#I after 3^(1+12):6.Suz.2/[ 1, 19 ]: found 12 classes, now have 165
gap> ExtendTableHeadByRootClasses( head2, facts[2], 2 );
#I after 3^(1+12):6.Suz.2/[ 1, 20 ]: found 12 classes, now have 165
We observe that head and head2 differ only by the
two character tables in the last fusion record.
gap> nams:= RecNames( head );
[ "Size", "OrdersClassRepresentatives", "SizesCentralizers",
"fusions" ]
gap> ForAll( Difference( nams, [ "fusions" ] ),
> nam -> head.( nam ) = head2.( nam ) );
true
gap> Length( head.fusions );
5
gap> ForAll( [ 1 .. 4 ], i -> head.fusions[i] = head2.fusions[i] );
true
gap> head.fusions[5].map = head2.fusions[5].map;
true
We continue with establishing the conjugacy classes of M.
The question which of the two above candidate tables belongs to a subgroup
of M will be answered in Section 6.
4.5 Classes of elements of order divisible by 5
The group 2.B contains two rational conjugacy classes of elements
of order 5,
with different values in the permutation character (12.B)M.
gap> s:= CharacterTable( "2.B" );;
gap> pos:= Positions( OrdersClassRepresentatives( s ), 5 );
[ 23, 25 ]
gap> pi{ pos };
[ 1539000, 7875 ]
This establishes two classes 5A, 5B of conjugacy classes
of elements of order 5 in M,
with centralizer orders 5 |HN| and 57 |2.J2|, respectively.
gap> cents:= List( pos,
> i -> pi[i] * Size( s ) / SizesConjugacyClasses( s )[i] );
[ 1365154560000000, 94500000000 ]
gap> cents = [ 5 * Size( CharacterTable( "HN" ) ),
> 5^7 * Size( CharacterTable( "2.J2" ) ) ];
true
By [BMW24],
we know that M contains exactly two conjugacy classes of elements
of order 5,
5A with centralizer 5 ×HN and normalizer
(D10 ×HN).2,
and 5B with centralizer 51+6+.2.J2 and normalizer
51+6+.4.J2.2.
The two classes are rational
because this is the case already for their intersections with 2.B.
gap> s:= CharacterTable( "MN5A" );
CharacterTable( "(D10xHN).2" )
gap> ClassPositionsOfPCore( s, 5 );
[ 1, 45 ]
gap> ExtendTableHeadByRootClasses( head, s, 45 );
#I after (D10xHN).2: found 5 classes, now have 170
The character table of 51+6+.4.J2.2 has been recomputed
with MAGMA, see Section 10,
thus we are allowed to use the character table from
the GAP character table library.
gap> s:= CharacterTable( "MN5B" );
CharacterTable( "5^(1+6):2.J2.4" )
gap> 5core:= ClassPositionsOfPCore( s, 5 );
[ 1 .. 4 ]
gap> SizesConjugacyClasses( s ){ 5core };
[ 1, 4, 37800, 40320 ]
gap> ExtendTableHeadByRootClasses( head, s, 2 );
#I after 5^(1+6):2.J2.4: found 3 classes, now have 173
4.6 Classes of elements of order divisible by 11
The group 2.B contains a rational class of elements of order 11.
The permutation character (12.BM)2.B yields a class of elements
of order 11 with centralizer order 11 |M12| in M.
gap> s:= CharacterTable( "2.B" );;
gap> pos:= Positions( OrdersClassRepresentatives( s ), 11 );
[ 71 ]
By the arguments in [BMW24],
M has no other classes of element order 11.
gap> ExtendTableHeadByPermCharValue( head, s, pi, pos );
#I after order 11 element from 2.B: have 174 classes
4.7 Classes of elements of the orders 17, 19, 23, 31, 47
The elements of the orders 17, 19, 23, 31, 47 in M lie in cyclic
Sylow subgroups that appear already in 2.B.
The elements of order 17 and 19 are rational in 2.B
and hence also in M.
gap> s:= CharacterTable( "2.B" );;
gap> pos:= Positions( OrdersClassRepresentatives( s ), 17 );
[ 118 ]
gap> ExtendTableHeadByPermCharValue( head, s, pi, pos );
#I after order 17 element from 2.B: have 175 classes
gap> pos:= Positions( OrdersClassRepresentatives( s ), 19 );
[ 128 ]
gap> ExtendTableHeadByPermCharValue( head, s, pi, pos );
#I after order 19 element from 2.B: have 176 classes
For elements g of order p ∈ { 23, 31, 47 },
the group 2.B contains exactly two Galois conjugate classes that contain
the nonidentity powers of g,
which means that [N2.B(〈g 〉):C2.B(g)] = (p−1)/2 holds.
The equation |CM(g)| = |2.B| ·π(g) / |gM ∩2.B|
implies
|
|NM(〈g 〉)| = [NM(〈g 〉):CM(g)] ·|2.B| ·π(g) / |gM| = (p−1)/2 ·|2.B| ·π(g) / |g2.B|. |
|
Note that either the two classes of elements of order p in 2.B
fuse in M or not;
in the former case,
we have [NM(〈g 〉):CM(g)] = p−1 and
|gM ∩2.B| = 2 |g2.B|,
whereas we have
[NM(〈g 〉):CM(g)] = (p−1)/2 and
|gM ∩2.B| = |g2.B| in the latter case.
Thus we can compute |NM(〈g 〉)| in each case,
and we can then find arguments why the two Galois conjugate classes
do not fuse.
First we deal with p = 23.
gap> s:= CharacterTable( "2.B" );
CharacterTable( "2.B" )
gap> ord:= OrdersClassRepresentatives( s );;
gap> classes:= SizesConjugacyClasses( s );;
gap> p:= 23;;
gap> pos:= Positions( ord, p );
[ 147, 149 ]
gap> n:= (p-1)/2 * Size( s ) * pi[ pos[1] ] / classes[ pos[1] ];
6072
gap> Collected( Factors( n ) );
[ [ 2, 3 ], [ 3, 1 ], [ 11, 1 ], [ 23, 1 ] ]
In order to prove that the two classes of elements of order 23 in 2.B
do not fuse in M, it suffices to show that the centralizer order is
divisible by 23.
We see that this is the case already in the 2B centralizer in M.
gap> u:= CharacterTable( "MN2B" );
CharacterTable( "2^1+24.Co1" )
gap> upos:= Positions( OrdersClassRepresentatives( u ), p );
[ 289, 294 ]
gap> SizesCentralizers( u ){ upos } / 2^3;
[ 23, 23 ]
Thus we have established two classes of element order 23 in M.
gap> ExtendTableHeadByPermCharValue( head, s, pi, pos{ [1] } );
#I after order 23 element from 2.B: have 177 classes
gap> ExtendTableHeadByPermCharValue( head, s, pi, pos{ [2] } );
#I after order 23 element from 2.B: have 178 classes
The case p = 31 is done analogously.
Here the necessary 2-part of the centralizer occurs already in 2.B.
gap> p:= 31;;
gap> pos:= Positions( OrdersClassRepresentatives( s ), p );
[ 190, 192 ]
gap> n:= (p-1)/2 * Size( s ) * pi[ pos[1] ] / classes[ pos[1] ];
2790
gap> Collected( Factors( n ) );
[ [ 2, 1 ], [ 3, 2 ], [ 5, 1 ], [ 31, 1 ] ]
gap> SizesCentralizers( s ){ pos };
[ 62, 62 ]
gap> ExtendTableHeadByPermCharValue( head, s, pi, pos{ [1] } );
#I after order 31 element from 2.B: have 179 classes
gap> ExtendTableHeadByPermCharValue( head, s, pi, pos{ [2] } );
#I after order 31 element from 2.B: have 180 classes
Finally, we deal with p = 47.
gap> p:= 47;;
gap> pos:= Positions( OrdersClassRepresentatives( s ), p );
[ 228, 230 ]
gap> n:= (p-1)/2 * Size( s ) * pi[ pos[1] ] / classes[ pos[1] ];
2162
gap> Collected( Factors( n ) );
[ [ 2, 1 ], [ 23, 1 ], [ 47, 1 ] ]
gap> SizesCentralizers( s ){ pos };
[ 94, 94 ]
gap> ExtendTableHeadByPermCharValue( head, s, pi, pos{ [1] } );
#I after order 47 element from 2.B: have 181 classes
gap> ExtendTableHeadByPermCharValue( head, s, pi, pos{ [2] } );
#I after order 47 element from 2.B: have 182 classes
4.8 Classes of elements of order 13
The class 13A of M arises from the rational class of elements
of order 13 in 2.B.
We use the permutation character to enter the information about
the class 13A.
gap> p:= 13;;
gap> pos:= Positions( OrdersClassRepresentatives( s ), p );
[ 97 ]
gap> c:= Size( s ) * pi[ pos[1] ] / classes[ pos[1] ];
73008
gap> Factors( c );
[ 2, 2, 2, 2, 3, 3, 3, 13, 13 ]
gap> ExtendTableHeadByPermCharValue( head, s, pi, pos );
#I after order 13 element from 2.B: have 183 classes
The class 13B intersects the 2B centralizer.
Here we just know the centralizer order 133 ·23 ·3.
gap> c2b:= CharacterTable( "MN2B" );;
gap> pos:= Positions( OrdersClassRepresentatives( c2b ), 13 );
[ 220 ]
gap> ExtendTableHeadByCentralizerOrder( head, c2b, 13^3 * 24, pos );
#I after order 13 element from 2^1+24.Co1: have 184 classes
4.9 Classes of elements of order divisible by 29
The group 3.Fi24 contains a rational class of elements of order 29,
with centralizer order 3 ·29.
gap> u:= CharacterTable( "3.Fi24" );;
gap> pos:= Positions( OrdersClassRepresentatives( u ), 29 );
[ 142 ]
gap> SizesCentralizers( u ){ pos };
[ 87 ]
The list of classes of M collected up to now covers all roots of
elements of the orders 2, 3, 5, 11, 13, 17, 19, 23, 31, 47,
and 29 occurs as a factor of the centralizer order only for the
classes 1A, 3A, 87A, and 87B.
gap> poss:= PositionsProperty( head.SizesCentralizers,
> x -> x mod 29 = 0 );
[ 1, 135, 144, 145 ]
gap> head.OrdersClassRepresentatives{ poss };
[ 1, 3, 87, 87 ]
gap> head.SizesCentralizers{ poss };
[ 808017424794512875886459904961710757005754368000000000,
3765617127571985163878400, 87, 87 ]
Thus the only possible additional prime divisors of the centralizer order
in M of an element x of order 29 are 7, 41, 59, and 71.
gap> candprimes:= Difference( PrimeDivisors( head.Size ),
> [ 2, 3, 5, 11, 13, 17, 19, 23, 29, 31, 47 ] );
[ 7, 41, 59, 71 ]
The centralizer order of x has the form
3 ·29 ·7i ·41j ·59k ·71l,
with 0 ≤ i ≤ 6 and j, k, l ∈ { 0, 1 }.
gap> parts:= Filtered( Collected( Factors( head.Size ) ),
> x -> x[1] in candprimes );
[ [ 7, 6 ], [ 41, 1 ], [ 59, 1 ], [ 71, 1 ] ]
gap> poss:= List( parts, l -> List( [ 0 .. l[2] ], i -> l[1]^i ) );;
gap> cart:= Cartesian( poss );;
gap> possord:= 3 * 29 * List( cart, Product );;
Only 3 ·29 and 3 ·29 ·59 satisfy Sylow's theorem,
that is, |M| / |NM(〈x 〉)| ≡ 1 mod 29.
Note that we have [NM(〈x 〉):CM(x)] = 28.
gap> good:= Filtered( possord,
> x -> ( head.Size / ( 28 * x ) ) mod 29 = 1 );
[ 87, 5133 ]
gap> List( good, Factors );
[ [ 3, 29 ], [ 3, 29, 59 ] ]
Now we can exclude the possible centralizer order 3 ·29 ·59
by the fact that the Sylow 59 subgroup would be normal
and thus would be normalized and hence centralized by an element of
order 3, a contradiction.
gap> Filtered( DivisorsInt( 5133 ), x -> x mod 59 = 1 );
[ 1 ]
Thus we have established a rational class of elements of order 29,
with centralizer of order 3 ·29.
gap> ExtendTableHeadByCentralizerOrder( head, u, 3 * 29, pos );
#I after order 29 element from 3.F3+.2: have 185 classes
4.10 Classes of elements of order divisible by 41
We assume that M contains a subgroup of the structure 38.O8−(3).
The fact that an element x of order 41 in M is normalized
by an element of order 4 can be read off from the factor group
O8−(3).
gap> t:= CharacterTable( "O8-(3)" );
CharacterTable( "O8-(3)" )
gap> Length( Positions( OrdersClassRepresentatives( t ), 41 ) );
10
By the above arguments, the only possible odd prime divisors of
|NM(〈x 〉)|/41 are 5, 7, 59, 71,
where 5 cannot divide the centralizer order.
As in the case of p = 29, we apply Sylow's theorem,
and get
|NM(〈x 〉)| ∈ { 23 ·5 ·41, 23 ·7 ·41 ·71 }.
gap> possord:= 2^2 * 41 * DivisorsInt( 2 * 5 * 7^6 * 59 * 71 );;
gap> good:= Filtered( possord,
> x -> ( head.Size / x ) mod 41 = 1 );
[ 1640, 163016 ]
gap> List( good, Factors );
[ [ 2, 2, 2, 5, 41 ], [ 2, 2, 2, 7, 41, 71 ] ]
Suppose that 71 divides |NM(〈x 〉)|.
Then the 71 Sylow subgroup of NM(〈x 〉) is normal
thus normalized by an element of order 8,
and thus centralized by an involution, a contradiction.
gap> Filtered( DivisorsInt( good[2] ), x -> x mod 71 = 1 );
[ 1 ]
Thus we have established a rational class of self-centralizing elements
of order 41.
gap> ExtendTableHeadByCentralizerOrder( head, 41, 41, fail );
#I after order 41 element: have 186 classes
4.11 Classes of elements of order divisible by 59
By the above arguments,
the normalizer order of an element of order 59 divides
58 ·76 ·59 ·71.
Sylow's theorem admits just the normalizer order 59 ·29.
gap> possord:= 59 * DivisorsInt( 58*7^6*71 );;
gap> good:= Filtered( possord,
> x -> ( head.Size / x ) mod 59 = 1 );
[ 1711 ]
gap> List( good, Factors );
[ [ 29, 59 ] ]
Thus we have established a pair of Galois conjugate classes of
self-centralizing elements of order 59.
gap> ExtendTableHeadByCentralizerOrder( head, 59, 59, fail );
#I after order 59 element: have 187 classes
gap> ExtendTableHeadByCentralizerOrder( head, 59, 59, fail );
#I after order 59 element: have 188 classes
4.12 Classes of elements of order divisible by 71
By the above arguments,
the normalizer order of an element of order 71 divides
70 ·75 ·71.
Sylow's theorem admits just the normalizer order 71 ·35.
gap> possord:= 71 * DivisorsInt( 70*7^5 );;
gap> good:= Filtered( possord,
> x -> ( head.Size / x ) mod 71 = 1 );
[ 2485 ]
gap> List( good, Factors );
[ [ 5, 7, 71 ] ]
Thus we have established a pair of Galois conjugate classes of
self-centralizing elements of order 71.
gap> ExtendTableHeadByCentralizerOrder( head, 71, 71, fail );
#I after order 71 element: have 189 classes
gap> ExtendTableHeadByCentralizerOrder( head, 71, 71, fail );
#I after order 71 element: have 190 classes
4.13 Classes of elements of order divisible by 7
The subgroup 2.B yields a rational class 7A
with centralizer order 7 ·|He|.
gap> s:= CharacterTable( "2.B" );;
gap> pos:= Positions( OrdersClassRepresentatives( s ), 7 );
[ 41 ]
gap> ExtendTableHeadByPermCharValue( head, s, pi, pos );
#I after order 7 element from 2.B: have 191 classes
gap> Last( head.SizesCentralizers ) = 7 * Size( CharacterTable( "He" ) );
true
By additional arguments, we find that the 7A centralizer has the
structure 7 ×He,
and the normalizer has the structure (7:3 ×He).2,
a subdirect product of 7:6 and He.2.
Since He has a pair of Galois conjugate classes of element order 17,
we get also a pair of Galois conjugate classes of element order
7 ·17 = 119.
gap> ExtendTableHeadByCentralizerOrder( head, 119, 119, fail );
#I after order 119 element: have 192 classes
gap> ExtendTableHeadByCentralizerOrder( head, 119, 119, fail );
#I after order 119 element: have 193 classes
The second class of elements of order 7, 7B,
is established by the fact that the subgroup 3.Fi24 contains
two classes of elements of order 7, with different values of the
degreee 196 883 character χ of M.
gap> u:= CharacterTable( "3.Fi24" );;
gap> cand:= Filtered( Irr( u ), x -> x[1] <= 196883 );;
gap> rest:= Sum( cand{ [ 1, 4, 5, 7, 8 ] } );;
gap> pos:= Positions( OrdersClassRepresentatives( u ), 7 );
[ 41, 43 ]
gap> rest{ pos };
[ 50, 1 ]
Note that class 43 fuses to 7B because the restriction of χ
to 2.B has the value 50 on 7A.
gap> ExtendTableHeadByCentralizerOrder( head, u, 7^5 * Factorial(7), [ 43 ] );
#I after order 7 element from 3.F3+.2: have 194 classes
Now the sum of class lengths in head is equal to the order of M.
gap> Sum( head.SizesCentralizers, x -> head.Size / x ) = head.Size;
true
We initialize the character table head of M.
gap> m:= ConvertToCharacterTableNC( rec(
> UnderlyingCharacteristic:= 0,
> Size:= head.Size,
> SizesCentralizers:= head.SizesCentralizers,
> OrdersClassRepresentatives:= head.OrdersClassRepresentatives,
> ) );;
5 The power maps of M
Using the element orders of the class representatives of the table head
of M, and the partial class fusions from the subgroups used in the
previous sections, we compute approximations of the p-th power maps,
for primes p up to the maximal element order in M.
Note that we have not yet determined which of the two possible character
tables of the 3B normalizer belongs to a subgroup of M,
thus we exclude the corresponding partial fusion.
gap> safe_fusions:= Filtered( head.fusions,
> r -> not IsIdenticalObj( r.subtable, facts[1] ) );;
gap> Length( safe_fusions );
6
First we initialize the class fusions, compatible with the definitions of
the classes as given by the partial fusions which we have stored.
gap> for r in safe_fusions do
> fus:= InitFusion( r.subtable, m );
> for i in [ 1 .. Length( r.map ) ] do
> if IsBound( r.map[i] ) then
> if IsInt( fus[i] ) then
> if fus[i] <> r.map[i] then
> Error( "fusion problem" );
> fi;
> elif IsInt( r.map[i] ) then
> if not r.map[i] in fus[i] then
> Error( "fusion problem" );
> fi;
> else
> if not IsSubset( fus[i], r.map[i] ) then
> Error( "fusion problem" );
> fi;
> fi;
> fus[i]:= r.map[i];
> fi;
> od;
> r.fus:= fus;
> od;
Next we initialize approximations of the power maps of the table of M,
and improve them using the compatibility of these maps with the power maps
of the subgroups w. r. t. the current knowledge of the class fusions.
Note that also the knowledge about the class fusions increases this way.
gap> maxorder:= Maximum( head.OrdersClassRepresentatives );
119
gap> powermaps:= [];;
gap> primes:= Filtered( [ 1 .. maxorder ], IsPrimeInt );;
gap> for p in primes do
> powermaps[p]:= InitPowerMap( m, p );
> for r in safe_fusions do
> subpowermap:= PowerMap( r.subtable, p );
> if TransferDiagram( subpowermap, r.fus, powermaps[p] ) = fail then
> Error( "inconsistency" );
> fi;
> od;
> od;
We repeat applying the compatibility conditions until no further
improvements are found.
gap> found:= true;;
gap> res:= "dummy";; # avoid a syntax warning
gap> while found do
> Print( "#I start a round\n" );
> found:= false;
> for p in primes do
> for r in safe_fusions do
> subpowermap:= PowerMap( r.subtable, p );
> res:= TransferDiagram( subpowermap, r.fus, powermaps[p] );
> if res = fail then
> Error( "inconsistency" );
> elif ForAny( RecNames( res ), nam -> res.( nam ) <> [] ) then
> found:= true;
> fi;
> od;
> od;
> od;
#I start a round
#I start a round
#I start a round
#I start a round
Let us see where the power maps are still not determined uniquely,
starting with the 5-th power map.
gap> pos:= PositionsProperty( powermaps[5], IsList );
[ 157, 158, 163, 164, 187, 188, 189, 190, 192, 193 ]
gap> head.OrdersClassRepresentatives{ pos };
[ 15, 15, 39, 39, 59, 59, 71, 71, 119, 119 ]
The ambiguities for the classes of the element orders 59, 71, and 119
are understandable:
For each of these element orders, there is a pair of Galois conjugate
classes, and the subgroups whose class fusions we have used do not contain
these elements.
For each of the primes l ∈ { 59, 71 },
the field of l-th roots of unity contains a unique quadratic subfield,
which is Q(√{−l}),
and the p-th power map, for p coprime to l,
fixes a class of element order l if and only if
the Galois automorphism that raises l-th roots of unity to the p-th power
fixes √{−l}.
In the case of element order l = 119 = 7 ·17,
the field of l-th roots of unity contains the three quadratic subfields,
Q(√{−7}), Q(√{17}), and Q(√{−119}).
In order to decide which of them actually occurs,
we look at a subgroup that contains elements of order 119.
The 7A centralizer in M has the structure 7 ×He,
and the normalizer has the structure (7:3 ×He).2,
a subdirect product of 7:6 and He.2,
see Section 4.13.
The classes of element order 119 in the normalizer correspond to
the classes of this element order in M,
and the character values in the subgroup lie in the field Q(√{−119}).
gap> u:= CharacterTable( "(7:3xHe):2" );;
gap> ConstructionInfoCharacterTable( u );
[ "ConstructIndexTwoSubdirectProduct", "7:3", "7:6", "He", "He.2",
[ 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129,
130, 131, 132, 133, 134, 135, 207, 208, 209, 210, 211, 212,
213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224,
225, 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, 307,
308, 309, 310, 311, 312, 313, 314, 315 ], (), () ]
gap> pos:= Positions( OrdersClassRepresentatives( u ), 119 );
[ 52, 53 ]
gap> f:= Field( Rationals, List( Irr( u ), x -> x[pos[1]] ) );;
gap> Sqrt(-119) in f;
true
We insert the relevant power map values.
gap> for l in [ 59, 71, 119 ] do
> val:= Sqrt( -l );
> poss:= Positions( head.OrdersClassRepresentatives, l );
> for p in primes do
> if Gcd( l, p ) = 1 then
> if GaloisCyc( val, p ) = val then
> powermaps[p]{ poss }:= poss;
> else
> powermaps[p]{ poss }:= Reversed( poss );
> fi;
> fi;
> od;
> od;
Now p-th power maps, for p ≥ 17,
are determined uniquely except for the images of two classes
of element order 39.
These classes had been found as roots of 3B elements.
gap> PositionsProperty( powermaps[17], IsList );
[ 163, 164 ]
gap> head.OrdersClassRepresentatives{ [ 163, 164 ] };
[ 39, 39 ]
gap> List( Filtered( head.fusions,
> r -> IsSubset( r.map, [ 163, 164 ] ) ),
> r -> r.subtable );
[ CharacterTable( "3^(1+12):6.Suz.2/[ 1, 19 ]" ) ]
In order to decide whether the p-th power map fixes or swaps
the two classes, we consider elements of order 78,
which are the square roots of the order 39 elements.
There are three classes of element order 78 in M,
a rational class that powers to 2A
and a pair of Galois conjugate classes that power to 2B.
gap> 78pos:= Positions( head.OrdersClassRepresentatives, 78 );
[ 37, 132, 133 ]
gap> head.fusions[1].subtable;
CharacterTable( "2.B" )
gap> Intersection( 78pos, head.fusions[1].map );
[ 37 ]
gap> s:= head.fusions[2].subtable;
CharacterTable( "2^1+24.Co1" )
gap> Intersection( 78pos, head.fusions[2].map );
[ 132, 133 ]
gap> Positions( head.fusions[2].map, 132 );
[ 342 ]
gap> Positions( head.fusions[2].map, 133 );
[ 344 ]
gap> PowerMap( s, 7 )[342];
344
Since the 3B normalizer in M contains a pair of Galois conjugate
classes of element order 78 which power to the generators of the normal
subgroup of order 3,
these two classes fuse to the non-rational M-classes of elements
of order 78,
and their squares are the classes of element order 39 we are interested in.
gap> poss:= Filtered( head.fusions, r -> IsSubset( r.map, [ 163, 164 ] ) );;
gap> List( poss, r -> r.subtable );
[ CharacterTable( "3^(1+12):6.Suz.2/[ 1, 19 ]" ) ]
gap> Position( poss[1].map, 163 );
173
gap> Position( poss[1].map, 164 );
174
gap> List( facts, s -> Positions( OrdersClassRepresentatives( s ), 39 ) );
[ [ 173, 174 ], [ 173, 174 ] ]
gap> List( facts, s -> PowerMap( s, 7 )[173] );
[ 174, 174 ]
The field of character values on the two classes of M is equal
to the corresponding field of character values in the 3B normalizer,
which is Q(√{−39}).
(Note that we have not yet decided which of the two candidate tables belong
to the 3B normalizer,
but we get the same result for both candidates.)
gap> fields:= List( facts,
> s -> Field( Rationals, List( Irr( s ),
> x -> x[173] ) ) );;
gap> Length( Set( fields ) );
1
gap> Sqrt(-39) in fields[1];
true
Now we can set the power map values on the two classes.
gap> val:= Sqrt( -39 );;
gap> poss:= [ 163, 164 ];;
gap> for p in primes do
> if Gcd( 39, p ) = 1 then
> if GaloisCyc( val, p ) = val then
> powermaps[p]{ poss }:= poss;
> else
> powermaps[p]{ poss }:= Reversed( poss );
> fi;
> fi;
> od;
gap> List( powermaps, Indeterminateness );
[ , 2048, 1536,, 4,, 2,,,, 2,, 9,,,, 1,, 1,,,, 1,,,,,, 1,, 1,,,,,, 1,,
,, 1,, 1,,,, 1,,,,,, 1,,,,,, 1,, 1,,,,,, 1,,,, 1,, 1,,,,,, 1,,,, 1,,
,,,, 1,,,,,,,, 1,,,, 1,, 1,,,, 1,, 1,,,, 1 ]
In the following,
we use the two candidates for the 3B normalizer table
for answering most of the remaining questions about the power maps.
Again, the answers are equal for both candidate tables.
First we initialize the class fusion from the first candidate table ...
gap> r:= First( head.fusions, r -> IsIdenticalObj( r.subtable, facts[1] ) );;
gap> fus:= InitFusion( r.subtable, m );;
gap> for i in [ 1 .. Length( r.map ) ] do
> if IsBound( r.map[i] ) then
> if IsInt( fus[i] ) then
> if fus[i] <> r.map[i] then
> Error( "fusion problem" );
> fi;
> elif IsInt( r.map[i] ) then
> if not r.map[i] in fus[i] then
> Error( "fusion problem" );
> fi;
> else
> if not IsSubset( fus[i], r.map[i] ) then
> Error( "fusion problem" );
> fi;
> fi;
> fus[i]:= r.map[i];
> fi;
> od;
gap> r.fus:= fus;;
... and the class fusion from the second candidate table, ...
gap> r2:= First( head2.fusions, r -> IsIdenticalObj( r.subtable, facts[2] ) );;
gap> fus2:= InitFusion( r2.subtable, m );;
gap> for i in [ 1 .. Length( r2.map ) ] do
> if IsBound( r2.map[i] ) then
> if IsInt( fus2[i] ) then
> if fus2[i] <> r2.map[i] then
> Error( "fusion problem" );
> fi;
> elif IsInt( r2.map[i] ) then
> if not r2.map[i] in fus2[i] then
> Error( "fusion problem" );
> fi;
> else
> if not IsSubset( fus2[i], r2.map[i] ) then
> Error( "fusion problem" );
> fi;
> fi;
> fus2[i]:= r2.map[i];
> fi;
> od;
gap> r2.fus:= fus2;;
... then we create an independent copy of the current approximations
of power maps, and apply the consistency conditions for class fusion and
power maps in the two cases.
gap> powermaps2:= StructuralCopy( powermaps );;
gap> s:= r.subtable;
CharacterTable( "3^(1+12):6.Suz.2/[ 1, 19 ]" )
gap> for p in primes do
> if TransferDiagram( PowerMap( s, p ), fus, powermaps[p] ) = fail then
> Error( "inconsistency" );
> fi;
> od;
gap> s2:= r2.subtable;
CharacterTable( "3^(1+12):6.Suz.2/[ 1, 20 ]" )
gap> for p in primes do
> if TransferDiagram( PowerMap( s2, p ), fus2, powermaps2[p] ) = fail then
> Error( "inconsistency" );
> fi;
> od;
gap> powermaps = powermaps2;
true
gap> List( powermaps, Indeterminateness );
[ , 32, 64,, 1,, 1,,,, 1,, 1,,,, 1,, 1,,,, 1,,,,,, 1,, 1,,,,,, 1,,,,
1,, 1,,,, 1,,,,,, 1,,,,,, 1,, 1,,,,,, 1,,,, 1,, 1,,,,,, 1,,,, 1,,,,,
, 1,,,,,,,, 1,,,, 1,, 1,,,, 1,, 1,,,, 1 ]
One open question is about the squares of the non-rational classes
of element order 78.
gap> powermaps[2]{ [ 132, 133 ] };
[ [ 163, 164 ], [ 163, 164 ] ]
gap> pos78:= List( facts,
> s -> Positions( OrdersClassRepresentatives( s ), 78 ) );
[ [ 235, 236 ], [ 235, 236 ] ]
gap> fus{ [ 235, 236 ] };
[ [ 132, 133 ], [ 132, 133 ] ]
gap> fus2{ [ 235, 236 ] };
[ [ 132, 133 ], [ 132, 133 ] ]
We may identify one class of element order 78 in the 3B normalizer
with the corresponding class of M, and then draw conclusions.
gap> fus[235]:= 132;;
gap> fus2[235]:= 132;;
gap> TransferDiagram( PowerMap( s, 2 ), fus, powermaps[2] ) <> fail;
true
gap> TransferDiagram( PowerMap( s2, 2 ), fus2, powermaps2[2] ) <> fail;
true
gap> powermaps = powermaps2;
true
gap> List( powermaps{ [ 2, 3 ] }, Indeterminateness );
[ 8, 64 ]
Since also the cubes of the concerned classes of element order 39
are still not determined, this question is now decided using that the
2nd and the 3rd power map commute.
gap> powermaps[3]{ [ 163, 164 ] };
[ [ 183, 184 ], [ 183, 184 ] ]
gap> TransferDiagram( powermaps[2], powermaps[3], powermaps[2] ) <> fail;
true
gap> List( powermaps{ [ 2, 3 ] }, Indeterminateness );
[ 8, 16 ]
The next open question is about the cubes of elements of order 93.
The classes of element order 93 -a pair of Galois conjugate classes-
have been found inside subgroups
of the type S3 ×Th, and they do not occur in other subgroups
we have considered.
Thus we may choose which of them cubes to the first class of element order
31.
gap> poss:= Filtered( head.fusions,
> r -> 93 in OrdersClassRepresentatives( r.subtable ) );;
gap> List( poss, r -> r.subtable );
[ CharacterTable( "ThxSym(3)" ) ]
gap> pos93:= Positions( head.OrdersClassRepresentatives, 93 );
[ 152, 153 ]
gap> powermaps[3]{ pos93 };
[ [ 179, 180 ], [ 179, 180 ] ]
gap> powermaps[3][152]:= 179;;
gap> TransferDiagram( PowerMap( poss[1].subtable, 3 ), poss[1].fus,
> powermaps[3] ) <> fail;
true
gap> List( powermaps{ [ 2, 3 ] }, Indeterminateness );
[ 8, 4 ]
The next open question is about the cubes of elements of order 69.
The classes of element order 69 -a pair of Galois conjugate classes-
have been found inside subgroups
of the type 3.Fi24, and they do not occur in other subgroups
we have considered.
Thus we may choose which of them cubes to the first class of element order
23.
gap> poss:= Filtered( head.fusions,
> r -> 69 in OrdersClassRepresentatives( r.subtable ) );;
gap> List( poss, r -> r.subtable );
[ CharacterTable( "3.F3+.2" ) ]
gap> pos69:= Positions( head.OrdersClassRepresentatives, 69 );
[ 142, 143 ]
gap> powermaps[3]{ pos69 };
[ [ 177, 178 ], [ 177, 178 ] ]
gap> powermaps[3]{ [ 142, 143 ] }:= [ 177, 178 ];;
gap> TransferDiagram( PowerMap( poss[1].subtable, 3 ), poss[1].fus,
> powermaps[3] ) <> fail;
true
gap> List( powermaps{ [ 2, 3 ] }, Indeterminateness );
[ 8, 1 ]
The next open question is about the squares of certain elements of order 46.
There are two pairs of Galois conjugate classes of element order 46,
and the 2nd power map is not yet determined for those classes which power
to the class 2B.
gap> pos46:= Positions( head.OrdersClassRepresentatives, 46 );
[ 26, 27, 118, 120 ]
gap> powermaps[2]{ pos46 };
[ 177, 178, [ 177, 178 ], [ 177, 178 ] ]
gap> powermaps[23]{ pos46 };
[ 2, 2, 44, 44 ]
We have defined the two classes of element order 23 as squares of those
two classes of element order 46 that power to 2A,
and we have not yet distinguished the other two classes of element order 46.
Thus we may set the power map values.
gap> powermaps[2]{ [ 118, 120 ] }:= [ 177, 178 ];;
gap> Indeterminateness ( powermaps[2] );
2
Now just one value is left to be determined,
the square of a class of element order 18 and centralizer order 3888.
gap> powermaps[2][78];
[ 155, 156 ]
gap> head.OrdersClassRepresentatives[78];
18
gap> head.SizesCentralizers[78];
3888
There are two classes with this property in M,
both are roots of the generators of the normal subgroup of order 3 in
31+12+.2.Suz.2, and the corresponding two classes in this subgroup
have the same square.
gap> Filtered( [ 1 .. Length( head.OrdersClassRepresentatives ) ],
> i -> head.OrdersClassRepresentatives[i] = 18 and
> head.SizesCentralizers[i] = 3888 );
[ 78, 79 ]
gap> powermaps[3]{ [ 78, 79 ] };
[ 52, 52 ]
gap> powermaps[2][52];
154
gap> First( head.fusions, r -> 154 in r.map ).subtable;
CharacterTable( "3^(1+12):6.Suz.2/[ 1, 19 ]" )
gap> s:= facts[1];
CharacterTable( "3^(1+12):6.Suz.2/[ 1, 19 ]" )
gap> pos18:= Filtered( [ 1 .. NrConjugacyClasses( s ) ],
> i -> OrdersClassRepresentatives( s )[i] = 18 and
> SizesCentralizers( s )[i] = 3888 );
[ 67, 83 ]
gap> PowerMap( s, 2 ){ pos18 };
[ 24, 24 ]
gap> s:= facts[2];
CharacterTable( "3^(1+12):6.Suz.2/[ 1, 20 ]" )
gap> pos18:= Filtered( [ 1 .. NrConjugacyClasses( s ) ],
> i -> OrdersClassRepresentatives( s )[i] = 18 and
> SizesCentralizers( s )[i] = 3888 );
[ 67, 83 ]
gap> PowerMap( s, 2 ){ pos18 };
[ 24, 24 ]
We set the last missing value,
and improve the approximations of the class fusions we have used,
by applying the consistency criteria.
gap> powermaps[2][78]:= powermaps[2][79];;
gap> for r in safe_fusions do
> if not TestConsistencyMaps( ComputedPowerMaps( r.subtable ), r.fus,
> powermaps ) then
> Error( "inconsistent!" );
> fi;
> od;
gap> r:= First( head.fusions, r -> IsIdenticalObj( r.subtable, facts[1] ) );;
gap> TestConsistencyMaps( ComputedPowerMaps( r.subtable ), r.fus,
> powermaps );
true
gap> r2:= First( head2.fusions, r -> IsIdenticalObj( r.subtable, facts[2] ) );;
gap> TestConsistencyMaps( ComputedPowerMaps( r2.subtable ), r2.fus,
> powermaps );
true
gap> SetComputedPowerMaps( m, powermaps );
6 The degree 196 883 character χ of M
We know the values of the irreducible degree 196 883 character χ
of M on the classes of 2.B, by Section 2.
gap> r:= head.fusions[1];;
gap> s:= r.subtable;
CharacterTable( "2.B" )
gap> cand:= Filtered( Irr( s ), x -> x[1] <= 196883 );;
gap> List( cand, x -> x[1] );
[ 1, 4371, 96255, 96256 ]
gap> rest:= Sum( cand );;
gap> rest[1];
196883
Thus we know the values of χ on those classes of M
that are known as images of the class fusion from 2.B.
This yields 111 out of the 194 character values.
gap> chi:= [];;
gap> map:= r.fus;;
gap> for i in [ 1 .. Length( map ) ] do
> if IsInt( map[i] ) then
> chi[ map[i] ]:= rest[i];
> fi;
> od;
gap> Number( chi );
111
Also the restriction of χ to 3.Fi24 is known,
by Section 2.
This yields 29 more character values.
gap> r:= head.fusions[3];;
gap> s:= r.subtable;
CharacterTable( "3.F3+.2" )
gap> cand:= Filtered( Irr( s ), x -> x[1] <= 196883 );;
gap> rest:= Sum( cand{ [ 1, 4, 5, 7, 8 ] } );;
gap> rest[1];
196883
gap> map:= r.fus;;
gap> for i in [ 1 .. Length( map ) ] do
> if IsInt( map[i] ) then
> if IsBound( chi[ map[i] ] ) and chi[ map[i] ] <> rest[i] then
> Error( "inconsistency!" );
> fi;
> chi[ map[i] ]:= rest[i];
> fi;
> od;
gap> Number( chi );
140
Now we compute the restriction of χ to the 2B normalizer.
There are only 13 possible irreducible constituents of this restriction.
We consider the matrix of values of these characters on those classes
for which the class fusion to M is uniquely known and
the value of χ on the image class is known.
This matrix has full rank, thus we can directly compute the decomposition
of the restriction into irreducibles,
and get 41 more character values.
gap> r:= head.fusions[2];;
gap> s:= r.subtable;
CharacterTable( "2^1+24.Co1" )
gap> cand:= Filtered( Irr( s ), x -> x[1] <= chi[1] );;
gap> map:= r.fus;;
gap> knownpos:= Filtered( [ 1 .. Length( map ) ],
> i -> IsInt( map[i] ) and IsBound( chi[ map[i] ] ) );;
gap> rest:= List( knownpos, i -> chi[ map[i] ] );;
gap> mat:= List( cand, x -> x{ knownpos } );;
gap> Length( mat );
13
gap> RankMat( mat );
13
gap> sol:= SolutionMat( mat, rest );
[ 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1 ]
gap> rest:= sol * cand;;
gap> for i in [ 1 .. Length( map ) ] do
> if IsInt( map[i] ) then chi[ map[i] ]:= rest[i]; fi;
> od;
gap> Number( chi );
181
Which values are still missing?
gap> missing:= Filtered( [ 1..194 ], i -> not IsBound( chi[i] ) );
[ 151, 152, 153, 160, 169, 170, 186, 187, 188, 189, 190, 192, 193 ]
gap> head.OrdersClassRepresentatives{ missing };
[ 57, 93, 93, 27, 95, 95, 41, 59, 59, 71, 71, 119, 119 ]
gap> head.SizesCentralizers{ missing };
[ 57, 93, 93, 243, 95, 95, 41, 59, 59, 71, 71, 119, 119 ]
For g ∈ M, we have χ(g) ≡ χ(gp) mod p
and |χ(g)|2 < |CM(g)|.
We apply these conditions.
In all cases except one, the centralizer orders are small enough
for determining the character value uniquely.
gap> for i in missing do
> ord:= head.OrdersClassRepresentatives[i];
> divs:= PrimeDivisors( ord );
> if ForAll( divs, p -> IsBound( chi[ powermaps[p][i] ] ) ) then
> congr:= List( divs, p -> chi[ powermaps[p][i] ] mod p );
> res:= ChineseRem( divs, congr );
> modulus:= Lcm( divs );
> c:= head.SizesCentralizers[i];
> Print( "#I |g| = ", head.OrdersClassRepresentatives[i],
> ", |C_M(g)| = ", c,
> ": value ", res, " modulo ", modulus, "\n" );
> if ( res + 2 * modulus )^2 >= c and ( res - 2 * modulus )^2 >= c then
> cand:= Filtered( res + [ -1 .. 1 ] * modulus, a -> a^2 < c );
> if Length( cand ) = 1 then
> chi[i]:= cand[1];
> fi;
> fi;
> fi;
> od;
#I |g| = 57, |C_M(g)| = 57: value 56 modulo 57
#I |g| = 93, |C_M(g)| = 93: value 92 modulo 93
#I |g| = 93, |C_M(g)| = 93: value 92 modulo 93
#I |g| = 27, |C_M(g)| = 243: value 2 modulo 3
#I |g| = 95, |C_M(g)| = 95: value 0 modulo 95
#I |g| = 95, |C_M(g)| = 95: value 0 modulo 95
#I |g| = 41, |C_M(g)| = 41: value 1 modulo 41
#I |g| = 59, |C_M(g)| = 59: value 0 modulo 59
#I |g| = 59, |C_M(g)| = 59: value 0 modulo 59
#I |g| = 71, |C_M(g)| = 71: value 0 modulo 71
#I |g| = 71, |C_M(g)| = 71: value 0 modulo 71
#I |g| = 119, |C_M(g)| = 119: value 118 modulo 119
#I |g| = 119, |C_M(g)| = 119: value 118 modulo 119
gap> missing:= Filtered( [ 1..194 ], i -> not IsBound( chi[i] ) );
[ 160 ]
The one missing value can be computed from the scalar product
with the trivial character.
gap> diff:= Difference( [ 1 .. NrConjugacyClasses( m ) ], missing );;
gap> classes:= SizesConjugacyClasses( m );;
gap> sum:= Sum( diff, i -> classes[i] * chi[i] );
-6650349175263480459970863415322722279882752000000000
gap> chi[ missing[1] ]:= - sum / classes[ missing[1] ];
2
Now we decide which of the two candidates for the character table of
the 3B normalizer is the correct one.
For the first candidate, the restriction of χ
cannot be decomposed into irreducibles.
gap> r:= First( head.fusions, r -> IsIdenticalObj( r.subtable, facts[1] ) );;
gap> map:= r.fus;;
gap> knownpos:= Filtered( [ 1 .. Length( map ) ], i -> IsInt( map[i] ) );;
gap> rest:= List( knownpos, i -> chi[ map[i] ] );;
gap> cand:= Filtered( Irr( r.subtable ), x -> x[1] <= chi[1] );;
gap> mat:= List( cand, x -> x{ knownpos } );;
gap> Length( mat );
95
gap> RankMat( mat );
88
gap> SolutionMat( mat, rest );
fail
The second candidate admits a decomposition.
gap> r2:= First( head2.fusions, r -> IsIdenticalObj( r.subtable, facts[2] ) );;
gap> map:= r2.fus;;
gap> knownpos:= Filtered( [ 1 .. Length( map ) ], i -> IsInt( map[i] ) );;
gap> rest:= List( knownpos, i -> chi[ map[i] ] );;
gap> cand:= Filtered( Irr( r2.subtable ), x -> x[1] <= chi[1] );;
gap> mat:= List( cand, x -> x{ knownpos } );;
gap> Length( mat );
95
gap> RankMat( mat );
88
gap> SolutionMat( mat, rest );
[ 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 1, 1, 1, 0 ]
gap> Add( safe_fusions, r2 );
The character table of the second candidate is equivalent to
the character table that is stored in the GAP character table library.
gap> TransformingPermutationsCharacterTables( r2.subtable,
> CharacterTable( "MN3B" ) ) <> fail;
true
7 The irreducible characters of M
We will not compute the irreducibles of M from scratch but verify the
irreducibles from the ATLAS character table of M,
in the sense that we use the characters printed in the ATLAS as an
"oracle".
For that,
we compute first a bijection between the columns of our character table head
and those of the ATLAS character table of M.
This is done by using the following invariants:
element orders, centralizer orders,
the values of χ, and the indirection of χ by the 2nd power map.
gap> invs:= TransposedMat( [
> OrdersClassRepresentatives( m ),
> SizesCentralizers( m ),
> chi,
> CompositionMaps( chi, PowerMap( m, 2 ) ) ] );;
gap> invs_set:= Set( invs );;
gap> Length( invs_set );
172
gap> atlas_m:= CharacterTable( "M" );;
gap> invs_atlas:= TransposedMat( [
> OrdersClassRepresentatives( atlas_m ),
> SizesCentralizers( atlas_m ),
> Irr( atlas_m )[2],
> CompositionMaps( Irr( atlas_m )[2], PowerMap( atlas_m, 2 ) ) ] );;
gap> invs_atlas_set:= Set( invs_atlas );;
gap> invs_atlas_set = invs_set;
true
In particular, we see that the sets of invariants are equal for the two
tables.
Note that we cannot get a better choice of invariants,
since there are 22 pairs of Galois conjugate classes in M,
and our current knowledge does not allow us to distinguish
the classes of each pair.
Now we compute a permutation that maps the classes of the ATLAS table
to suitable classes of our table head,
permute the irreducibles of the ATLAS table accordingly,
and create the "oracle" list.
(The explicit permutation (32,33)(179,180) makes sure that the power maps
of the ATLAS table and of our table are compatible.)
gap> pi1:= SortingPerm( invs );;
gap> pi2:= SortingPerm( invs_atlas );;
gap> pi:= pi2 / pi1 * (32,33)(179,180);;
gap> oracle:= List( Irr( atlas_m ), x -> Permuted( x, pi ) );;
In order to prohibit that GAP tries to compute table automorphisms
of our table head of M (which is impossible without knowing the
irreducible characters),
we set a trivial group as value of the attribute
AutomorphismsOfTable;
this will be revised as soon as the irreducibles are known.
gap> SetAutomorphismsOfTable( m, Group( () ) );
First we compute candidates for the class fusion from 2.B,
starting from the approximation we have already computed.
Before we apply GAP's criteria for computing possible class fusions,
we decide about the images of four classes of element orders 40 and 44.
gap> r:= safe_fusions[1];;
gap> s:= r.subtable;
CharacterTable( "2.B" )
gap> pos:= [ 217, 218, 222, 223 ];;
gap> r.fus{ pos };
[ [ 110, 111 ], [ 110, 111 ], [ 88, 89 ], [ 88, 89 ] ]
gap> OrdersClassRepresentatives( s ){ pos };
[ 40, 40, 44, 44 ]
The two classes of element order 40 are a pair of Galois conjugates
in both 2.B and M.
Note that their elements are roots of 2B elements in M,
and the classes 110 and 111 correspond to non-rational elements
of order 40 in the 2B normalizer.
gap> r.fus[ PowerMap( s, 20 )[217] ];
44
gap> r2:= safe_fusions[2];;
gap> s2:= r2.subtable;
CharacterTable( "2^1+24.Co1" )
gap> Position( r2.map, 110 );
273
gap> ForAll( Irr( s2 ), x -> IsInt( x[273] ) );
false
We may freely choose the fusion from the classes 217 and 218 of 2.B
because there is a table automorphism of 2.B that swaps exactly these
two classes.
gap> (217,218) in AutomorphismsOfTable( s );
true
gap> r.fus{ [ 217, 218 ] }:= [ 110, 111 ];;
With the same argument,
also the two classes of element order 44 are a pair of Galois conjugates
both in 2.B and M.
gap> r.fus[ PowerMap( s, 22 )[ 222 ] ];
44
gap> Position( r2.map, 88 );
178
gap> ForAll( Irr( s2 ), x -> IsInt( x[178] ) );
false
There is a table automorphism of 2.B that swaps three pairs of classes,
where the classes of element order 44 form one pair,
and each of the other two pairs is fused in M.
Thus we may again freely choose the fusion from 222 and 223.
gap> (143,144)(222,223)(244,245) in AutomorphismsOfTable( s );
true
gap> r.fus{ [ 143, 144, 244, 245 ] };
[ 15, 15, 34, 34 ]
gap> r.fus{ [ 222, 223 ] }:= [ 88, 89 ];;
Now the remaining open questions about the class fusion from 2.B
can be answered by GAP's function PossibleClassFusions.
gap> knownirr:= [ TrivialCharacter( m ), chi ];;
gap> poss:= PossibleClassFusions( s, m,
> rec( chars:= knownirr, fusionmap:= r.fus ) );;
gap> List( poss, Indeterminateness );
[ 1 ]
Now we can induce the irreducibles of 2.B to M.
gap> induced:= InducedClassFunctionsByFusionMap( s, m, Irr( s ), poss[1] );;
Next we compute candidates for the class fusions from the subgroups
21+24+.Co1, 31+12+.2.Suz.2, and 3.Fi24.
Here we enter also the characters of M obtained by induction from 2.B,
because their restrictions to the subgroups provide additional conditions.
The fusion from 21+24+.Co1 is determined uniquely up to automorphisms
of the subgroup table.
We extend the list of known induced characters.
gap> poss:= PossibleClassFusions( s2, m,
> rec( chars:= Concatenation( knownirr, induced ),
> fusionmap:= r2.fus ) );;
gap> List( poss, Indeterminateness );
[ 1, 1, 1, 1 ]
gap> Length( RepresentativesFusions( AutomorphismsOfTable( s2 ), poss,
> Group( () ) ) );
1
gap> Append( induced,
> InducedClassFunctionsByFusionMap( s2, m, Irr( s2 ), poss[1] ) );
In order to compute the fusion from 31+12+.2.Suz.2,
we have to consider two classes of element order 56 first.
They are a pair of Galois conjugates both in 31+12+.2.Suz.2 and M,
and we may freely choose their fusion because there is a table automorphism
of 31+12+.2.Suz.2 that swaps exactly these two classes.
gap> r:= safe_fusions[7];;
gap> s:= r.subtable;
CharacterTable( "3^(1+12):6.Suz.2/[ 1, 20 ]" )
gap> pos:= Positions( OrdersClassRepresentatives( s ), 56 );
[ 250, 251 ]
gap> r.fus{ pos };
[ [ 125, 126 ], [ 125, 126 ] ]
gap> r.fus[ PowerMap( s, 28 )[ 250 ] ];
44
gap> Position( r2.map, 125 );
319
gap> ForAll( Irr( s2 ), x -> IsInt( x[319] ) );
false
gap> (250, 251) in AutomorphismsOfTable( s );
true
gap> r.fus{ [ 250, 251 ] }:= [ 125, 126 ];;
Now the class fusion to M is determined uniquely up to table automorphisms
of the subgroup,
and we extend the list of induced characters.
gap> poss:= PossibleClassFusions( s, m,
> rec( chars:= Concatenation( knownirr, induced ),
> fusionmap:= r.fus ) );;
gap> List( poss, Indeterminateness );
[ 1, 1 ]
gap> Length( RepresentativesFusions( AutomorphismsOfTable( s ), poss,
> Group( () ) ) );
1
gap> Append( induced,
> InducedClassFunctionsByFusionMap( s, m, Irr( s ), poss[1] ) );
The fusion from 3.Fi24 is determined uniquely up to automorphisms
of the subgroup table.
We extend the list of known induced characters.
gap> r:= safe_fusions[3];;
gap> s:= r.subtable;
CharacterTable( "3.F3+.2" )
gap> poss:= PossibleClassFusions( s, m,
> rec( chars:= Concatenation( knownirr, induced ),
> fusionmap:= r.fus ) );;
gap> List( poss, Indeterminateness );
[ 1 ]
gap> Append( induced,
> InducedClassFunctionsByFusionMap( s, m, Irr( s ), poss[1] ) );
Next we induce the irreducible characters of cyclic subgroups.
gap> Append( induced,
> InducedCyclic( m, [ 2 .. NrConjugacyClasses( m ) ], "all" ) );
Now we reduce the induced characters with the two known irreducibles of M,
and apply the LLL algorithm to the result of the reduction;
this yields four new irreducibles.
gap> red:= Reduced( m, knownirr, induced );;
gap> Length( red.irreducibles );
0
gap> lll:= LLL( m, red.remainders );;
gap> Length( lll.irreducibles );
4
We extend the list of known irreducibles,
reduce the induced characters,
and apply LLL again.
gap> knownirr:= Union( knownirr, lll.irreducibles );;
gap> red:= Reduced( m, knownirr, induced );;
gap> Length( red.irreducibles );
0
gap> lll:= LLL( m, red.remainders );;
gap> Length( lll.irreducibles );
0
Now we use the irreducibles of the ATLAS table of M as an oracle,
as follows.
Whenever a character from the oracle list belongs to the Z-lattice
that is spanned by lll.remainders
then we regard this character as verified,
since we can compute the coefficients of the Z-linear combination,
form the character, and check that it has indeed norm 1.
gap> mat:= MatScalarProducts( m, oracle, lll.remainders );;
gap> norm:= NormalFormIntMat( mat, 4 );;
gap> rowtrans:= norm.rowtrans;;
gap> normal:= norm.normal{ [ 1 .. norm.rank ] };;
gap> one:= IdentityMat( NrConjugacyClasses( m ) );;
gap> for i in [ 2 .. Length( one ) ] do
> extmat:= Concatenation( normal, [ one[i] ] );
> extlen:= Length( extmat );
> extnorm:= NormalFormIntMat( extmat, 4 );
> if extnorm.rank = Length( extnorm.normal ) or
> extnorm.rowtrans[ extlen ][ extlen ] <> 1 then
> coeffs:= fail;
> else
> coeffs:= - extnorm.rowtrans[ extlen ]{ [ 1 .. extnorm.rank ] }
> * rowtrans{ [ 1 .. extnorm.rank ] };
> fi;
> if coeffs <> fail and ForAll( coeffs, IsInt ) then
> # The vector lies in the lattice.
> chi:= coeffs * lll.remainders;
> if not chi in knownirr then
> Add( knownirr, chi );
> fi;
> fi;
> od;
gap> Length( knownirr );
66
gap> Set( knownirr, chi -> ScalarProduct( m, chi, chi ) );
[ 1 ]
We take the generators of the Z-lattice and some symmetrizations
of the known irreducibles,
reuce them with the known irreducibles,
and apply LLL again.
gap> red:= Reduced( m, knownirr, lll.remainders );;
gap> Length( red.irreducibles );
0
gap> sym:= Symmetrizations( m, knownirr, 2 );;
gap> sym:= Reduced( m, knownirr, sym );;
gap> Length( sym.irreducibles );
0
gap> lll:= LLL( m, Concatenation( red.remainders, sym.remainders ) );;
gap> Length( lll.irreducibles );
0
We use the above oracle again, for the new Z-lattice.
gap> mat:= MatScalarProducts( m, oracle, lll.remainders );;
gap> norm:= NormalFormIntMat( mat, 4 );;
gap> rowtrans:= norm.rowtrans;;
gap> normal:= norm.normal{ [ 1 .. norm.rank ] };;
gap> one:= IdentityMat( NrConjugacyClasses( m ) );;
gap> for i in [ 2 .. Length( one ) ] do
> extmat:= Concatenation( normal, [ one[i] ] );
> extlen:= Length( extmat );
> extnorm:= NormalFormIntMat( extmat, 4 );
> if extnorm.rank = Length( extnorm.normal ) or
> extnorm.rowtrans[ extlen ][ extlen ] <> 1 then
> coeffs:= fail;
> else
> coeffs:= - extnorm.rowtrans[ extlen ]{ [ 1 .. extnorm.rank ] }
> * rowtrans{ [ 1 .. extnorm.rank ] };
> fi;
> if coeffs <> fail and ForAll( coeffs, IsInt ) then
> Add( knownirr, coeffs * lll.remainders );
> fi;
> od;
gap> Length( knownirr );
194
Now we are done.
As stated in the beginning of this section,
we unbind the stored trivial value for AutomorphismsOfTable.
gap> SetIrr( m, List( knownirr, x -> ClassFunction( m, x ) ) );
gap> ResetFilterObj( m, HasAutomorphismsOfTable );
gap> TransformingPermutationsCharacterTables( m, atlas_m ) <> fail;
true
8 Appendix: The character table of 21+24+.Co1
The centralizer C of a 2B element in M
has the structure 21+24+.Co1,
which can be constructed as follows.
Consider a subdirect product H of two groups H/X
and H/N,
where X is a cyclic group of order two,
N is an extraspecial group 21+24+,
H/N is the double cover of Co1, and
H/X is an extension of 21+24+ by Co1.
The centre of H is a Klein four group E whose order two subgroups
are X, Y = Z(N), and a third subgroup D.
We have C ≅ H/D.
Figure
Picture Omitted
From the 2-local construction of a matrix representation for M,
we know the following faithful representations,
given by generators that are preimages of standard generators of Co1.
- A monomial permutation representation of H/E ≅ 224.Co1,
of degree 98 280 over the field with three elements,
-
a matrix representation of H/X ≅ 21+24+.Co1,
of dimension 4 096 over the field with three elements,
-
a matrix representation of H/N ≅ 2.Co1,
of dimension 24 over the field with three elements.
We proceed in the following steps.
- First we compute conjugacy class representatives of H/E.
-
A faithful permutation representation of H/Y on
2 ·196 560 = 393 120 points is obtained by
glueing the permutation generators of H/E
(on 2 ·98 280 = 196 560 points)
and H/N
(the smallest permutation representation of 2.Co1,
on 196 560 points) together.
The character table of this permutation group can be computed
directly with MAGMA in about 16 hours of CPU time.
-
Starting from the character table of the factor group H/E,
the 3-modular matrix representation of dimension 4 096 of H/X is used
to compute necessary class splittings from H/E to H/X, as follows.
This representation lifts to characteristic zero because its restriction
to the extraspecial group M/X
is the unique faithful irreducible 3-modular representation of M/X,
and because this representation extends to the full automorphism group
of the extraspecial group.
Thus we can compute the Brauer character values of the representation
on the 3-regular classes of H/X,
and interpret the values as those of an ordinary character ψ, say.
The tensor square ψ2 belongs to the group H/E,
and the known values of ψ suffice to determine the decomposition
of ψ2 into irreducibles of H/E,
and thus to compute also the values of ψ2 on 3-singular classes.
Taking square roots, we get all values of ψ, up to signs.
(We cannot distinguish which of the two values belongs to which of the two
preimage classes, which just means that we are defining these classes
by choosing the positive value for one of them, and the negative value
for the other one.)
-
From now on, we argue character-theoretically.
The missing irreducible characters of H/X are computed as
tensor products of ψ with the irreducible characters of
the factor group H/M ≅ Co1.
Note that this procedure yields enough new irreducible characters
such that the sum of degree squares of all known irreducibles of H/X
equals the order of this group.
This implies that there are not more class splittings w. r. t. the
fusion from H/X to H/E than the splittings forced by the values
of ψ.
-
Using the two class splittings from H/X and H/Y to H/E,
we compute necessary class splittings from H to H/E.
That is, we create a character table head for H together with
class fusions to H/X and H/Y,
assuming that not more columns occur than is forced by H/X and H/Y:
For each class of H/E that splits in both H/X and H/Y,
we get four preimage classes in H.
For each class that splits in exactly one of H/X and H/Y,
we get two preimage classes in H.
For each class that splits in none of H/X and H/Y,
we get one preimage class in H.
Then we take those irreducible characters of H/X and H/Y,
respectively, that do not have E/X or E/Y, respectively,
in their kernel;
we form tensor products of them, which yields characters with kernel D,
and apply the LLL algorithm to them.
This yields all missing irreducibles of H:
The degree squares of all now known irreducibles sum up to the order
of H, which means that no more class splitting occurs.
Finally, we compute the power maps (and thus the element orders)
of the character table of H.
The result is a character table that is permutation equivalent to
the character table that is stored in GAP's table library.
9 Appendix: The character table of 31+12+:6.Suz.2
9.1 Overview
The 3B normalizer in M has the structure 31+12+.2.Suz.2.
Its character table has been computed by Richard Barraclough and
Robert A. Wilson, see [BW07].
In order to describe a reproducible construction of the character table
that does not assume the character table of M,
we recompute this table.
Our approach is similar to that in [BW07]:
The subgroup in question is a factor group of the split extension H of
the extraspecial group N = 31+12+ by 6.Suz.2,
and we compute the character table of this bigger group H.
Figure
Picture Omitted
We have H / N ≅ 6.Suz.2.
Let M be the normal subgroup of H above N such that
H / M ≅ 2.Suz.2 holds.
Then M = X ×N for a normal subgroup X of order 3,
where the extension of M / X by H / M is split.
Let N2 be the normal subgroup of H above N such that
H / N2 ≅ 3.Suz.2 holds.
Then M2 = M N2 has the property H / M2 ≅ Suz.2.
Let Y = Z(N), of order 3.
Then E = X ×Y ≅ 32 is elementary abelian,
with diagonal normal subgroups D1 and D2.
It will turn out that the extensions of M / D1 and M / D2 by H / M
are non-split.
H / Y is a subdirect product of H / N and
H / E ≅ 312.2.Suz.2,
we have H / Y ≅ (3 ×312).2.Suz.2.
The group H is a subdirect product of H / N and H / X.
The 3B normalizer in M is isomorphic to
one of the two factor groups H / D1, H / D2.
(The decision which of the two groups occurs as a subgroup of M
appears in Section 6.)
We use the following approach to compute the character table of H.
- Compute permutation generators gensHmodX of H / X,
of degree 313,
see Section 9.2.
The first two generators are standard generators of 2.Suz.2,
the third generator lies in M / X.
-
Fetch permutation generators gensHmodN of H / N2,
of degree 5 346,
and compute permutation generators gensH of H,
of degree 1 599 669 = 1 594 323 + 5 346,
see Section 9.3.
The first two generators are standard generators of 6.Suz.2,
the third generator lies in N.
-
Let MAGMA compute the character table of H from gensH,
see Section 9.4.
Remark:
In an earlier construction (in September 2020),
we asked MAGMA to compute the character table of H / Y,
and then used individual conjugacy tests for first setting up the class fusion
from H to H / Y and then determining the full character table head of H.
The computation of the missing irreducible characters of H was then
not difficult, using character theoretic methods.
However, trying the same input files in 2024 showed many cases where
some of the required conjugacy tests did not finish in reasonable time.
Luckily, the automatic computation described in Section 9.4
worked.
9.2 A permutation representation of H / X
The ATLAS of Group Representations [WWT+] contains
a faithful representation of H,
as a group of 38 ×38 matrices over the field with three elements.
The generating matrices are called M3max7G0-f3r38B0.m1, ...,
M3max7G0-f3r38B0.m4.
These matrices are block diagonal matrices with blocks of the lengths
24 and 14.
gap> info:= OneAtlasGeneratingSetInfo( "3^(1+12):6.Suz.2", Dimension, 38 );;
gap> gens:= AtlasGenerators( info ).generators;;
gap> Length( gens );
4
gap> ForAll( gens,
> m -> ForAll( [ 25 .. 38 ],
> i -> ForAll( [ 1 .. 24 ],
> j -> IsZero( m[i,j] ) and
> IsZero( m[i,j] ) ) ) );
true
Here we will use just the lower right 14 ×14 blocks,
which generate the factor group H / X ≅ 31+12+:2.Suz.2.
(Note that the 12-dimensional irreducible representation of 2.Suz.2
over the field with 3 elements respects a symplectic form,
and the embedding of 2.Suz.2 into Sp(12,3)
-which is the automorphism group of the extraspecial group 31+12+-
yields a construction of the semidirect product 31+12+:2.Suz.2
as a group of 14 ×14 matrices.)
Later we will construct a faithful permutation representation of H
as a subdirect product of H / X and H / N ≅ 6.Suz.2.
Let G be the group generated by the 14 ×14 matrices.
When one deals with H / X, the fourth generator is redundant,
we will leave it out in the following.
gap> mats:= List( gens, x -> x{ [ 25 .. 38 ] }{ [ 25 .. 38 ] } );;
gap> List( mats, ConvertToMatrixRep );;
gap> Comm( mats[3], mats[3]^mats[2] ) = Inverse( mats[4] );
true
gap> mats:= mats{ [ 1 .. 3 ] };;
We use just the following facts.
The G-action on GF(3)14 has six orbits,
from which we get a faithful permutation representation of H / E ≅ 312.2.Suz.2 on 196 560 points
and a faithful representation homHtoHmodX
of a group of the structure 31+12+.2.Suz.2 on 1 594 323 points.
Since the image contains a subgroup 2.Suz.2,
the image is the split extension H / X of 31+12+ by 2.Suz.2.
gap> G:= GroupWithGenerators( mats );;
gap> orbs:= ShallowCopy( OrbitsDomain( G, GF(3)^14 ) );;
gap> Length( orbs );
6
gap> SortBy( orbs, Length );
gap> List( orbs, Length );
[ 1, 2, 196560, 1397760, 1594323, 1594323 ]
gap> v:= [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2 ] * Z(3)^0;;
gap> orb_large:= First( orbs, x -> v in x );;
gap> Length( orb_large );
1594323
gap> Length( orb_large ) = 3^13;
true
gap> orb_large:= SortedList( orb_large );;
gap> homHtoHmodX:= ActionHomomorphism( G, orb_large );;
gap> represHmodX:= Image( homHtoHmodX );;
gap> Size( represHmodX );
2859230155080499200
gap> Size( represHmodX ) = Size( CharacterTable( "2.Suz.2" ) ) * 3^13;
true
We conclude that the action on 196 560 points represents the group
H / E.
As for the action on 1 594 323 points,
we show that it has a nonabelian normal subgroup of the order 313.
gap> gensHmodX:= List( mats, m -> m^homHtoHmodX );;
gap> n:= NormalClosure( represHmodX,
> Subgroup( represHmodX, [ gensHmodX[3] ] ) );;
gap> Size( n ) = 3^13;
true
gap> IsAbelian( n );
false
Next we show that the first two elements from the generating set
are standard generators of 2.Suz.2.
For that, we first show that these elements are preimages
of standard generators of Suz.2,
by computing that the words in question lie in the centre of 2.Suz.2,
and then show that the elements satisfy the conditions of
standard generators of 2.Suz.2,
that is, the second generator has order 3,
see the page on Suz in the ATLAS of Group Representations [WWT+].
gap> slp:= AtlasProgram( "Suz.2", "check" );;
gap> prog:= StraightLineProgramFromStraightLineDecision( slp.program );;
gap> res:= ResultOfStraightLineProgram( prog, gensHmodX );;
gap> List( res, Order );
[ 2, 1, 2, 1 ]
gap> ForAll( gensHmodX{ [ 1, 2 ] }, x -> ForAll( res, y -> x*y = y*x ) );
true
gap> Order( gensHmodX[2] );
3
9.3 A permutation representation of H
The group H is a subdirect product of H / X and H / N2 ≅ 3.Suz.2,
w.r.t. the common factor group H / M2 ≅ Suz.2.
Since we know that our generators for H / X are compatible with
standard generators of the factor group 2.Suz.2,
it is sufficient to form the diagonal product of our representation of
H / X and a representation of 3.Suz.2 on standard generators.
gap> 3suz2:= OneAtlasGeneratingSet( "3.Suz.2", NrMovedPoints, 5346 );;
gap> 3suz2:= 3suz2.generators;;
gap> omega:= [ 1 .. LargestMovedPoint( 3suz2 ) ];;
gap> shifted:= omega + LargestMovedPoint( gensHmodX );;
gap> pi:= MappingPermListList( omega, shifted );;
gap> shiftedgens:= List( 3suz2, x -> x^pi );;
gap> Append( shiftedgens, [ () ] );
gap> gensH:= List( [ 1 .. 3 ], i -> gensHmodX[i] * shiftedgens[i] );;
gap> NrMovedPoints( gensH );
1599669
The first two of the generators are standard generators of 6.Suz.2.
Note that we know already that they are preimages of standard generators
of Suz.2,
it remains to show that they are elements C, D where D has order 3
and CDCDD has order 7.
gap> Order( gensH[2] );
3
gap> Order( Product( gensH{ [ 1, 2, 1, 2, 2 ] } ) );
7
9.4 Compute the character table of H
Now we let MAGMA do the work.
gap> H:= GroupWithGenerators( gensH );;
gap> if CTblLib.IsMagmaAvailable() then
> mgmt:= CharacterTableComputedByMagma( H, "H_Magma" );
> else
> mgmt:= CharacterTable( "3^(1+12):6.Suz.2" );
> fi;
This computation needed about three weeks of CPU time.
The result verifies the character table of H
that is available in the library.
gap> IsRecord( TransformingPermutationsCharacterTables( mgmt,
> CharacterTable( "3^(1+12):6.Suz.2" ) ) );
true
This character table was used in Section 4.4.
10 Appendix: The character table of 51+6+.4.J2.2
The normalizer of a 5B element in M has the structure
51+6+.4.J2.2,
generators for this group as a permutation group of degree 78 125
are available in the ATLAS of Group Representations [WWT+].
MAGMA [BCP97] can compute the character table from the group
within a few minutes,
the result turns out to be equivalent to the table that is available in
GAP's character table library.
gap> g:= AtlasGroup( "5^(1+6):2.J2.4" );;
gap> if CTblLib.IsMagmaAvailable() then
> mgmt:= CharacterTableComputedByMagma( g, "MN5B_Magma" );
> else
> mgmt:= CharacterTable( "5^(1+6):2.J2.4" );
> fi;
gap> IsRecord( TransformingPermutationsCharacterTables( mgmt,
> CharacterTable( "5^(1+6):2.J2.4" ) ) );
true
This character table was used in Section 4.5.
References
- [BCP97]
-
W. Bosma, J. Cannon, and C. Playoust, The Magma algebra system. I.
The user language, J. Symbolic Comput. 24 (1997),
no. 3-4, 235-265. MR 1484478
- [BGH+17]
-
M. Bhargava, R. Guralnick, G. Hiss, K. Lux, and P. H. Tiep (eds.), Finite
simple groups: thirty years of the Atlas and beyond, Contemporary
Mathematics, vol. 694, Providence, RI, American Mathematical Society, 2017.
MR 3682583
- [BMO17]
-
T. Breuer, G. Malle, and E. A. O'Brien, Reliability and reproducibility
of Atlas information, in Bhargava et al. [BGH+17],
p. 21-31. MR 3682588
- [BMW20]
-
T. Breuer, K. Magaard, and R. A. Wilson, Verification of the ordinary
character table of the Baby Monster, J. Algebra 561 (2020),
111-130. MR 4135540
- [BMW24]
-
, Verification of the conjugacy classes and ordinary character
table of the Monster, submitted, 2024.
- []
- T. Breuer, Constructing the ordinary character tables of some Atlas
groups using character theoretic methods., arXiv:1604.00754.
- [Breb]
-
, Permutation Characters in GAP, https://www.math.rwth-aachen.de/
~Thomas.Breuer/
ctbllib/doc2/
manual.pdf.
- [BW07]
-
R. W. Barraclough and R. A. Wilson, The character table of a maximal
subgroup of the Monster, LMS J. Comput. Math. 10 (2007),
161-175. MR 2308856
- [GAP24]
-
GAP - Groups, Algorithms, and Programming,
Version 4.13.1, https://www.gap-system.org, Mar 2024.
- [GMS89]
-
R. L. Griess Jr., U. Meierfrankenfeld, and Y. Segev, A uniqueness proof
for the Monster, Ann. of Math. (2) 130 (1989), no. 3,
567-602. MR 1025167
- [WWT+]
-
R. A. Wilson, P. Walsh, J. Tripp, I. Suleiman, R. A. Parker, S. P. Norton,
S. Nickerson, S. Linton, J. Bray, and R. Abbott, ATLAS of Finite Group
Representations, http://brauer.maths.qmul.ac.uk/
Atlas/v3.
File translated from
TEX
by
TTH,
version 3.59.
On 22 May 2025, 15:04.