<title>Some steps in the verification of the ordinary character table of the Baby Monster group</title>
<h1 align="center">Some steps in the verification of the ordinary character table of the Baby Monster group</h1>
<body bgcolor="FFFFFF">
<div class="p"><!----></div>
We show the details of certain computations that are described
in [<a href="#BMverify" name="CITEBMverify">BMW20</a>].
<div class="p"><!----></div>
<div class="p"><!----></div>
<h1>Contents </h1><a href="#tth_sEc1"
>1 Overview</a><br /><a href="#tth_sEc2"
>2 Verification of a presentation for <font size="+0">B</font></a><br /><a href="#tth_sEc3"
>3 Invariants that distinguish conjugacy classes of <font size="+0">B</font></a><br /><a href="#tth_sEc4"
>4 Centralizers of elements of prime order</a><br /><a href="#tth_sEc5"
>5 The character table of 2<sup>1+22</sup>.Co<sub>2</sub></a><br /><a href="#tth_sEc6"
>6 Conjugacy classes of <font size="+0">B</font> and their centralizer orders</a><br /><a href="#tth_sEc7"
>7 The irreducible characters of <font size="+0">B</font></a><br /><a href="#tth_sEc8"
>8 Appendix: Standardizing the generators of Co<sub>2</sub></a><br /><a href="#tth_sEc9"
>9 Appendix: Words for generators of the kernel 2<sup>22</sup></a><br /><a href="#tth_sEc10"
>10 Appendix: Words for class representatives of 2<sup>22</sup>.Co<sub>2</sub></a><br /><a href="#tth_sEc11"
>11 Appendix: About the character table of 2<sup>9+16</sup>.S<sub>8</sub>(2)</a><br />
<div class="p"><!----></div>
<div class="p"><!----></div>
<h2><a name="tth_sEc1">
1</a> Overview</h2>
<div class="p"><!----></div>
The aim of [<a href="#BMverify" name="CITEBMverify">BMW20</a>] is to verify the ordinary character table
of the Baby Monster group <font size="+0">B</font>.
Here we collect,
in the form of an explicit <font face="helvetica">GAP</font> [<a href="#GAP" name="CITEGAP">GAP24</a>] session protocol,
the computations that are needed in that paper.
<div class="p"><!----></div>
We proceed as follows.
<div class="p"><!----></div> Section <a href="#pres_B">2</a>
shows the computations that are described in [<a href="#BMverify" name="CITEBMverify">BMW20</a>,Section 3].
At this point, we know that the three matrix groups that are used
later on are in fact representations of the group <font size="+0">B</font>,
w. r. t. compatible (standard) generators.
<div class="p"><!----></div> Section <a href="#invs_B">3</a> turns the class invariants and the power map
information from [<a href="#BMverify" name="CITEBMverify">BMW20</a>,Section 4] into a <font face="helvetica">GAP</font> function
that identifies the class label of a given word in terms of the
given standard generators.
<div class="p"><!----></div> Section <a href="#centralizers_prime">4</a>
shows part of the computations described in [<a href="#BMverify" name="CITEBMverify">BMW20</a>,Section 5].
<div class="p"><!----></div> Section <a href="#table_c2b">5</a> shows the computation of the character table
of an involution centralizer of type 2<sup>1+22</sup>.Co<sub>2</sub> in <font size="+0">B</font>.
<div class="p"><!----></div> Section <a href="#sect:classes">6</a> shows how the conjugacy classes,
the corresponding centralizer orders, and the power maps of <font size="+0">B</font>
are determined.
<div class="p"><!----></div>
In Section <a href="#sect:classes">6</a>, we put these pieces together and write down
the list of class representatives of <font size="+0">B</font>,
together with their centralizer orders and power maps.
<div class="p"><!----></div>
With this information and with the (already verified) character tables
of some known subgroups of <font size="+0">B</font>,
computing the irreducible characters of <font size="+0">B</font> is then easy;
this corresponds to [<a href="#BMverify" name="CITEBMverify">BMW20</a>,Section 7],
and is done in Section <a href="#sect:irreducibles">7</a>.
<div class="p"><!----></div>
We will use the <font face="helvetica">GAP</font> Character Table Library
and the interface to the A<font size="-2">TLAS</font> of Group Representations [<a href="#AGRv3"name="CITEAGRv3">WWT<sup>+</sup></a>],
thus we load these <font face="helvetica">GAP</font> packages.
<div class="p"><!----></div>
The <font face="helvetica">MAGMA</font> [<a href="#Magma" name="CITEMagma">BCP97</a>] system will be needed
for computing a character table
and for several conjugacy tests.
If the following command returns <tt>false</tt>
then these steps will not work.
<div class="p"><!----></div>
<pre>
gap> CTblLib.IsMagmaAvailable();
true
</pre>
<div class="p"><!----></div>
<h2><a name="tth_sEc2">
2</a> Verification of a presentation for <font size="+0">B</font></h2><a name="pres_B">
</a>
<div class="p"><!----></div>
We show the computations that are described in [<a href="#BMverify" name="CITEBMverify">BMW20</a>,Section 4].
First we create the free generators and relators of the presentation.
<div class="p"><!----></div>
<pre>
gap> F:= FreeGroup( List( "abcdefghijk", x -> [ x ] ) );;
gap> gens:= GeneratorsOfGroup( F );;
gap> rels:= List( gens, x -> x^2 );;
gap> ord3pairs:= List( [ 1 .. 7 ], i -> [ i, i+1 ] );
[ [ 1, 2 ], [ 2, 3 ], [ 3, 4 ], [ 4, 5 ], [ 5, 6 ], [ 6, 7 ], [ 7, 8 ] ]
gap> Append( ord3pairs, [ [ 5, 9 ], [ 9, 10 ], [ 10, 11 ] ] );
gap> for pair in ord3pairs do
> Add( rels, ( gens[ pair[1] ] * gens[ pair[2] ] )^3 );
> od;
gap> for i in [ 1 .. 11 ] do
> for j in [ i+1 .. 11 ] do
> if not [ i, j ] in ord3pairs then
> Add( rels, ( gens[i] * gens[j] )^2 );
> fi;
> od;
> od;
gap> Add( rels, Product( gens{ [ 5, 4, 3, 5, 6, 7, 5, 9, 10 ] } )^10 );
</pre>
<div class="p"><!----></div>
We do not call <tt>FreeGroup( 11 )</tt> because later on we want to
translate the relators into straight line programs,
and we can use <tt>StraightLineProgram</tt> with first argument a string
only if no generator name is a prefix of another generator name.
<div class="p"><!----></div>
Next we write a straight line program that computes the 11 generators
t<sub>1</sub>, …, t<sub>11</sub>,
following the steps shown in [<a href="#BMverify" name="CITEBMverify">BMW20</a>,Table 1].
We start with the two standard generators a and b, say,
in the slots 1 and 2,
and compute expressions for the subsequent slots.
The product a b will be in position 3, its 5th power (a b)<sup>5</sup>
(which will be needed later on) in position 4,
the power (a b)<sup>15</sup> in position 5, and d = (a b)<sup>15</sup> b
in position 6.
The generators t<sub>11</sub> = d<sup>19</sup> gets stored in position 7.
<div class="p"><!----></div>
Next we compute c = (a t<sub>11</sub>)<sup>3</sup> (position 9),
e = ((c d<sup>3</sup>)<sup>10</sup>)<sup>d</sup> (position 13), ...
<div class="p"><!----></div>
... t<sub>1</sub> = f = ((((e c)<sup>6</sup> c (e c)<sup>3</sup> )<sup>2</sup> e c e<sup>2</sup> c)<sup>5</sup>)<sup>(</sup>(e c)<sup>4</sup>)
(position 24), ...
<div class="p"><!----></div>
... g = ((e c)<sup>8</sup> c (e c)<sup>3</sup> )<sup>(e c e<sup>2</sup> c)<sup>2</sup></sup>
(position 27) and t<sub>2</sub> = f<sup>g<sup>f</sup></sup> (position 30), ...
<div class="p"><!----></div>
... p = ((a b)<sup>5</sup> t<sub>11</sub> (a b)<sup>−5</sup> t<sub>1</sub> (a b)<sup>5</sup>)<sup>−1</sup> (position 38)
and i = d<sup>p</sup> (position 41), ...
<div class="p"><!----></div>
And now we compute,
for each of the three pairs of generators we are interested in,
the 11 generators,
and test whether these generators satisfy the presentation.
<div class="p"><!----></div>
In order to prove that the 11 elements that satisfy the relations
generate the same group as the original generators,
we create a straight line program that computes the elements a′, b′
stated in [<a href="#BMverify" name="CITEBMverify">BMW20</a>,Section 4.4],
first the elements r and s (positions 12 and 13), ...
<div class="p"><!----></div>
<pre>
gap> revslp:= [ Concatenation( List( [ 1 .. 8 ], i -> [ i, 1 ] ) ),
> Concatenation( List( [ 5, 9, 10, 11 ], i -> [ i, 1 ] ) ) ];;
</pre>
<div class="p"><!----></div>
... and then a′ = (r<sup>7</sup> s)<sup>15</sup> (position 15)
and b′ = (t<sub>1</sub> t<sub>2</sub>)<sup>(sr)<sup>1</sup>0</sup> (position 20).
<div class="p"><!----></div>
We claim that, for the three representations in question,
evaluating the straight line program <tt>revslp</tt> at the 11
generators
yields a pair a′, b′ of matrices that is simultaneously conjugate to the
original matrices a, b.
Once this is established, we know that the group 〈a, b 〉
is equal to the group generated by the 11 generators,
and that mapping the original generators of any of the three
representations to the original generators of another one
defines a group isomorphism.
<div class="p"><!----></div>
In order to show the conjugacy property,
we use that the nullspace of w(a, b) = a<sup>0</sup> + a b + b a + b
is 1-dimensional, in all three cases.
<div class="p"><!----></div>
The standard basis w. r. t. given generators and a vector v
is defined by starting with the list b = [ v ]
and iteratively adding those images of the vectors in b
under the right multiplication with the generators that increase the
dimension of the vector space generated by b.
(Since such a function is apparently not available in <font face="helvetica">GAP</font>'s MeatAxe,
we provide it here.)
<div class="p"><!----></div>
<pre>
gap> StdBasis:= function( F, mats, seed )
> local n, b, mb, v, m, new;
>
> n:= Length( mats[1] );
> b:= [ seed ];
> mb:= MutableBasis( F, b );
> for v in b do
> for m in mats do
> new:= v * m;
> if not IsContainedInSpan( mb, new ) then
> Add( b, new );
> if Length( b ) = n then
> break;
> fi;
> CloseMutableBasis( mb, new );
> fi;
> od;
> if Length( b ) = n then
> break;
> fi;
> od;
> return b;
> end;;
</pre>
<div class="p"><!----></div>
<div class="p"><!----></div>
All we have to check is that the matrices of the linear mappings a, b
w. r. t. their standard basis and a generating vector of the nullspace
of w(a, b) are equal to the matrices of a′, b′ w. r. t. their
standard basis and a generating vector of the nullspace of w(a′, b′).
<div class="p"><!----></div>
We verify this in characteristic 2, ...
<h2><a name="tth_sEc3">
3</a> Invariants that distinguish conjugacy classes of <font size="+0">B</font></h2><a name="invs_B">
</a>
<div class="p"><!----></div>
The function <tt>IdentifyClassName</tt> shown below
implements the invariants defined in [<a href="#BMverify" name="CITEBMverify">BMW20</a>,Section 5],
that distinguish 183 conjugacy classes of <font size="+0">B</font>.
<div class="p"><!----></div>
Its input can be as follows.
<div class="p"><!----></div>
<ul>
<li> Three matrices <tt>data2</tt>, <tt>data3</tt>, <tt>data5</tt>,
representing an element of <font size="+0">B</font> in the given three matrix representations,
in characteristics 2, 3, and 5, respectively;
in this case, the argument <tt>slp</tt> should be <tt>fail</tt>.
<div class="p"><!----></div>
</li>
<li>
Lists <tt>data2</tt>, <tt>data3</tt>, <tt>data5</tt>
of standard generators of <font size="+0">B</font> in the given three matrix representations
such that <tt>slp</tt> is a straight line program
that takes these generators as inputs,
and computes the element in question.
<div class="p"><!----></div>
</li>
</ul>
<div class="p"><!----></div>
In both cases, the argument <tt>order</tt> can be either <tt>fail</tt>
or the order of the element.
A known order allows us to omit any computation with matrices
in several cases.
<div class="p"><!----></div>
The output is the label for the union of conjugacy classes
as defined in [<a href="#BMverify" name="CITEBMverify">BMW20</a>,Table 2],
except that labels containing <em>two</em> letters are returned
in those cases that will later turn out to describe two Galois conjugate
classes
-these are <tt>"23AB"</tt>, <tt>"30GH"</tt>, <tt>"31AB"</tt>,
<tt>"32AB"</tt>, <tt>"32CD"</tt>, <tt>"34BC"</tt>, <tt>"46AB"</tt>,
<tt>"47AB"</tt>, <tt>"56AB"</tt>-
and in the case of <tt>"16DF"</tt> where we have no invariant that
distinguishes two classes that are not Galois conjugate.
<div class="p"><!----></div>
<pre>
gap> IdentifyClassName:= function( data2, data3, data5, slp, order )
> local data, mats, elm, cand, nams, trace, pos, one, rank;
>
> data:= [ , data2, data3,, data5 ];
> mats:= [];
>
> elm:= function( p )
> if not IsBound( mats[p] ) then
> if slp = fail then
> mats[p]:= data[p];
> else
> mats[p]:= ResultOfStraightLineProgram( slp, data[p] );
> fi;
> fi;
> return mats[p];
> end;
>
> if order = fail then
> order:= Order( elm(2) );
> fi;
>
> # The element order suffices in certain cases.
> if order in [ 23, 31, 46, 47, 56 ] then
> # There are two Galois conjugate classes of elements of this order.
> return Concatenation( String( order ), "AB" );
> elif order in [ 1, 7, 11, 13, 17, 19, 21, 25, 27, 33, 35, 38, 39,
> 44, 47, 52, 55, 66, 70 ] then
> # There is exactly one conjugacy class of elements of this order.
> return Concatenation( String( order ), "A" );
> fi;
>
> if order in [ 3, 5, 9, 15 ] then
> # The trace in the 2-modular representation suffices.
> cand:= [ [3,1], [3,0], [5,0], [5,1], [9,0], [9,1], [15,0], [15,1] ];
> nams:= [ "3A", "3B", "5A", "5B", "9A", "9B", "15A", "15B" ];
> trace:= Int( TraceMat( elm(2) ) );
> return nams[ Position( cand, [ order, trace ] ) ];
> elif order mod 4 = 2 then
> # Compute the rank of 1 + x.
> cand:= [ [ 2, 1860 ], [ 2, 2048 ], [ 2, 2158 ], [ 2, 2168 ],
> [ 6, 3486 ], [ 6, 3510 ], [ 6, 3566 ], [ 6, 3534 ],
> [ 6, 3606 ], [ 6, 3604 ], [ 6, 3596 ], [ 6, 3610 ],
> [ 6, 3636 ], [ 6, 3638 ], [ 6, 3634 ],
> [ 10, 3860 ], [ 10, 3896 ], [ 10, 3918 ], [ 10, 3908 ],
> [ 10, 3920 ], [ 10, 3932 ],
> [ 14, 3996 ], [ 14, 4008 ], [ 14, 4048 ], [ 14,4034 ],
> [ 14, 4052 ],
> [ 18, 4088 ], [ 18, 4090 ], [ 18, 4110 ], [ 18, 4124 ],
> [ 18, 4128 ], [ 18, 4122 ],
> [ 22, 4140 ], [ 22, 4158 ],
> [ 26, 4198 ], [ 26, 4176 ],
> [ 30, 4190 ], [ 30, 4212 ], [ 30, 4206 ], [ 30, 4214 ],
> [ 30, 4224 ], [ 30, 4216 ],
> [ 34, 4238 ], [ 34, 4220 ],
> [ 42, 4242 ], [ 42, 4258 ] ];
> nams:= [ "2A", "2B", "2C", "2D",
> "6A", "6B", "6C", "6D", "6E", "6F",
> "6G", "6H", "6I", "6J", "6K",
> "10A", "10B", "10C", "10D", "10E", "10F",
> "14A", "14B", "14C", "14D", "14E",
> "18A", "18B", "18C", "18D", "18E", "18F",
> "22A", "22B",
> "26A", "26B",
> "30AB", "30C", "30D", "30E", "30F", "30GH",
> "34A", "34BC",
> "42AB", "42C" ];
> one:= elm(2)^0;
> rank:= RankMat( elm(2) + one );
> pos:= Position( cand, [ order, rank ] );
> if nams[ pos ] = "30AB" then
> rank:= RankMat( elm(2)^5 + one );
> if rank = 3510 then return "30A";
> elif rank = 3486 then return "30B";
> else Error( "wrong rank" );
> fi;
> elif nams[ pos ] = "42AB" then
> rank:= RankMat( elm(2)^3 + one );
> if rank = 3996 then return "42A";
> elif rank = 4008 then return "42B";
> else Error( "wrong rank" );
> fi;
> else
> return nams[ pos ];
> fi;
> elif order in [ 36, 60 ] then
> cand:= [ [36,4226],[36,4238],[36,4248],[60,4280],[60,4286],[60,4296] ];
> nams:= [ "36A", "36B", "36C", "60A", "60B", "60C" ];
> one:= elm(2)^0;
> rank:= RankMat( elm(2) + one );
> return nams[ Position( cand, [ order, rank ] ) ];
> elif order = 28 then
> one:= elm(2)^0;
> rank:= RankMat( elm(2) + one );
> trace:= Int( TraceMat( elm(3)^7 ) );
> if rank = 4188 then # 28A or 28C
> if trace = 0 then return "28A";
> elif trace = 1 then return "28C";
> else Error( "wrong trace" );
> fi;
> elif rank = 4200 then # 28B or 28D
> if trace = 1 then return "28B";
> elif trace = 0 then return "28D";
> else Error( "wrong trace" );
> fi;
> elif rank = 4210 then return "28E";
> else Error( "wrong rank" );
> fi;
> elif order = 32 then
> trace:= Int( TraceMat( elm(3)^2 ) );
> if trace = 2 then return "32AB";
> elif trace = 0 then return "32CD";
> else Error( "wrong trace" );
> fi;
> elif order = 40 then
> one:= elm(2)^0;
> rank:= RankMat( elm(2) + one );
> if rank = 4242 then # 40A or 40B 0r 40C
> trace:= Int( TraceMat( elm(3) ) );
> if trace = 0 then return "40A";
> elif trace = 1 then return "40B";
> else return "40C";
> fi;
> elif rank = 4250 then return "40D";
> elif rank = 4258 then return "40E";
> else Error( "wrong rank" );
> fi;
> elif order = 48 then
> trace:= Int( TraceMat( elm(3) ) );
> if trace = 0 then return "48A";
> elif trace = 1 then return "48B";
> else Error( "wrong trace" );
> fi;
> elif order in [ 4, 8 ] then
> cand:= [ [4,3114],[4,3192],[4,3256],[4,3202],[4,3204],[4,3266],
> [4,3264],[8,3774],[8,3738],[8,3778],[8,3780],[8,3810],
> [8,3786],[8,3812],[8,3818] ];
> nams:= [ "4A-B", "4C-D", "4E", "4F", "4G", "4H-J", "4I",
> "8A", "8B-C-E", "8D", "8F-H", "8G", "8I-L", "8J", "8K-M-N" ];
> one:= elm(2)^0;
> rank:= RankMat( elm(2) + one );
> pos:= Position( cand, [ order, rank ] );
> if not '-' in nams[ pos ] then
> return nams[ pos ];
> elif order = 4 then
> trace:= Int( TraceMat( elm(3) ) );
> if trace = 0 then
> if nams[ pos ] = "4A-B" then return "4B";
> elif nams[ pos ] = "4C-D" then return "4D";
> else return "4H";
> fi;
> elif trace = 1 then
> if nams[ pos ] = "4A-B" then return "4A";
> elif nams[ pos ] = "4C-D" then return "4C";
> else return "4J";
> fi;
> else
> Error( "wrong trace" );
> fi;
> elif order = 8 then
> if nams[ pos ] = "8B-C-E" then
> trace:= Int( TraceMat( elm(3) ) );
> if trace = 1 then return "8B";
> elif trace = 0 then return "8C";
> else return "8E";
> fi;
> elif nams[ pos ] = "8F-H" then
> rank:= RankMat( ( elm(2) + one )^3 );
> if rank = 2619 then return "8F";
> elif rank = 2620 then return "8H";
> else Error( "wrong rank" );
> fi;
> elif nams[ pos ] = "8I-L" then
> rank:= RankMat( ( elm(2) + one )^2 );
> if rank = 3202 then return "8I";
> elif rank = 3204 then return "8L";
> else Error( "wrong rank" );
> fi;
> else # 8K-M-N
> rank:= RankMat( ( elm(2) + one )^3 );
> if rank = 2714 then # 8K-M
> trace:= Int( TraceMat( elm(3) ) );
> if trace = 1 then return "8K";
> elif trace = 2 then return "8M";
> else Error( "wrong trace" );
> fi;
> elif rank = 2717 then return "8N";
> else Error( "wrong rank" );
> fi;
> fi;
> fi;
> elif order in [ 12, 24 ] then
> cand:= [ [12,3936],[12,3942],[12,3958],[12,3996],[12,3962],[12,3964],
> [12,3986],[12,3978],[12,3966],[12,4000],[12,3982],[12,3988],
> [12,4002],[12,4004],[24,4152],[24,4164],[24,4170],[24,4182],
> [24,4176],[24,4178],[24,4174],[24,4186] ];
> nams:= [ "12A-C-D", "12B", "12E", "12F", "12G-H", "12I", "12J",
> "12K-M", "12L", "12N", "12O", "12P", "12Q-R-T", "12S",
> "24A-B-C-D", "24E-G", "24F", "24H", "24I-M", "24J", "24K",
> "24L-N" ];
> one:= elm(2)^0;
> rank:= RankMat( elm(2) + one );
> pos:= Position( cand, [ order, rank ] );
> if not '-' in nams[ pos ] then
> return nams[ pos ];
> elif order = 12 then
> if nams[ pos ] = "12A-C-D" then
> trace:= Int( TraceMat( elm(5) ) );
> if trace = 3 then return "12A";
> elif trace = 4 then return "12C";
> elif trace = 1 then return "12D";
> else Error( "wrong trace" );
> fi;
> else
> trace:= Int( TraceMat( elm(3) ) );
> if trace = 0 then
> if nams[ pos ] = "12G-H" then return "12H";
> elif nams[ pos ] = "12K-M" then return "12K";
> else return "12Q"; # 12Q-R-T
> fi;
> elif trace = 1 then
> if nams[ pos ] = "12G-H" then return "12G";
> elif nams[ pos ] = "12K-M" then return "12M";
> else return "12R"; # 12Q-R-T
> fi;
> elif nams[ pos ] = "12Q-R-T" then
> return "12T";
> else
> Error( "wrong trace" );
> fi;
> fi;
> elif order = 24 then
> if nams[ pos ] = "24I-M" then
> rank:= RankMat( elm(2)^2 + one );
> if rank = 3986 then return "24I";
> elif rank = 3982 then return "24M";
> else Error( "wrong rank" );
> fi;
> elif nams[ pos ] = "24E-G" then
> rank:= RankMat( elm(2)^3 + one );
> if rank = 3774 then return "24E";
> elif rank = 3778 then return "24G";
> else Error( "wrong rank" );
> fi;
> elif nams[ pos ] = "24L-N" then
> trace:= Int( TraceMat( elm(3) ) );
> if trace = 1 then return "24L";
> elif trace = 2 then return "24N";
> else Error( "wrong trace" );
> fi;
> else # 24A-B-C-D"
> trace:= Int( TraceMat( elm(5) ) );
> if trace = 3 then return "24A";
> elif trace = 0 then return "24B";
> elif trace = 2 then return "24C";
> elif trace = 1 then return "24D";
> else Error( "wrong trace" );
> fi;
> fi;
> fi;
> elif order in [ 16, 20 ] then
> cand:= [ [ 16, 4072 ], [ 16, 4074 ], [ 16, 4094 ],
> [ 20, 4114 ], [ 20, 4128 ], [ 20, 4132 ], [ 20, 4148 ],
> [ 20, 4144 ], [ 20, 4138 ], [ 20, 4150 ] ];
> nams:= [ "16A-B", "16C-D-E-F", "16G-H",
> "20A-B-C-D", "20E", "20F", "20G", "20H", "20I", "20J" ];
> one:= elm(2)^0;
> rank:= RankMat( elm(2) + one );
> pos:= Position( cand, [ order, rank ] );
> if not '-' in nams[ pos ] then
> return nams[ pos ];
> elif order = 20 then
> rank:= RankMat( elm(2)^2 + one );
> if rank = 3908 then return "20B";
> elif rank <> 3896 then Error( "wrong rank" );
> else
> trace:= Int( TraceMat( elm(3) ) );
> if trace = 2 then return "20A";
> elif trace = 0 then return "20C";
> elif trace = 1 then return "20D";
> else Error( "wrong trace" );
> fi;
> fi;
> else # order = 16
> if nams[ pos ] = "16A-B" then
> trace:= Int( TraceMat( elm(3) ) );
> if trace = 0 then return "16A";
> elif trace = 1 then return "16B";
> else Error( "wrong trace" );
> fi;
> elif nams[ pos ] = "16G-H" then
> trace:= Int( TraceMat( elm(3)^2 ) );
> if trace = 1 then return "16G";
> elif trace = 2 then return "16H";
> else Error( "wrong trace" );
> fi;
> else # 16C-D-E-F
> trace:= Int( TraceMat( elm(3) ) );
> if trace = 0 then # We cannot distinguish 16D and 16F.
> return "16DF";
> elif trace = 2 then # 16C-E
> one:= elm(2)^0;
> rank:= RankMat( elm(2)^2 + one );
> if rank = 3780 then return "16C";
> elif rank = 3778 then return "16E";
> else Error( "wrong rank" );
> fi;
> else
> Error( "wrong trace" );
> fi;
> fi;
> fi;
> else Error( "wrong element order" );
> fi;
> end;;
</pre>
<div class="p"><!----></div>
Elements of <font size="+0">B</font> to which the labels belong can be generated as follows.
The straight line program <tt>"BG1-cycW1"</tt> from [<a href="#AGRv3" name="CITEAGRv3">WWT<sup>+</sup></a>]
computes generators of the maximally cyclic subgroups of <font size="+0">B</font>.
<div class="p"><!----></div>
The remaining representatives are obtained as suitable powers of them.
The following list encodes the definition of these powers,
see [<a href="#BMverify" name="CITEBMverify">BMW20</a>,Table 2].
<div class="p"><!----></div>
The following function takes a label and the straight line program data
shown above, and returns a straight line program for computing an
element for the given label from standard generators of <font size="+0">B</font>.
<div class="p"><!----></div>
<pre>
gap> SLPForClassName:= function( nam, cycslp, outputnames )
> local pos, rule;
>
> pos:= Position( outputnames, nam );
> if pos <> fail then
> return RestrictOutputsOfSLP( cycslp.program, pos );
> fi;
>
> rule:= First( DefinitionsViaPowerMaps, x -> x[3] = nam );
> if rule = fail then
> Error( "'nam' is not an admiss. name for a cyclic subgroup of B" );
> fi;
>
> return CompositionOfStraightLinePrograms(
> StraightLineProgram( [ [ 1, rule[2] ] ], 1 ),
> SLPForClassName( rule[1], cycslp, outputnames ) );
> end;;
</pre>
<div class="p"><!----></div>
Let us verify that <tt>IdentifyClassName</tt> computes the claimed labels.
<div class="p"><!----></div>
<pre>
gap> outputnames:= List( cycprg.outputs,
> x -> ReplacedString( x, "-", "" ) );;
gap> outputnames:= List( outputnames,
> x -> ReplacedString( x, "16F", "16DF" ) );;
gap> labels:= Union( outputnames,
> List( DefinitionsViaPowerMaps, x -> x[3] ) );;
gap> for l in labels do
> slp:= SLPForClassName( l, cycprg, outputnames );
> id:= IdentifyClassName( gens_2, gens_3, gens_5, slp, fail );
> if id <> l then
> Print( "#E problem with identification: ", id, " vs. ", l, "\n" );
> fi;
> od;
</pre>
<div class="p"><!----></div>
<div class="p"><!----></div>
As we get no outputs, the identification is correct.
<div class="p"><!----></div>
For later use, we collect power map information for the labels.
In order to simplify later loops,
we sort the labels w. r. t. increasing element order.
<div class="p"><!----></div>
<pre>
gap> SortParallel( List( labels, x -> Int( Filtered( x, IsDigitChar ) ) ),
> labels );
gap> powerinfo:= [];;
gap> for l in labels do
> slp:= SLPForClassName( l, cycprg, outputnames );
> ord:= Int( Filtered( l, IsDigitChar ) );
> pow:= [];
> if not ( IsPrimeInt( ord ) or ord = 1 ) then
> for p in Set( Factors( ord ) ) do
> powerslp:= CompositionOfStraightLinePrograms(
> StraightLineProgram( [ [ 1, p ] ], 1 ), slp );
> id:= IdentifyClassName( gens_2, gens_3, gens_5, powerslp,
> ord / p );
> Add( pow, [ p, id ] );
> od;
> fi;
> Add( powerinfo, [ l, pow ] );
> od;
</pre>
<div class="p"><!----></div>
<div class="p"><!----></div>
<div class="p"><!----></div>
<h2><a name="tth_sEc4">
4</a> Centralizers of elements of prime order</h2><a name="centralizers_prime">
</a>
<div class="p"><!----></div>
We document part of the computations needed in [<a href="#BMverify" name="CITEBMverify">BMW20</a>,Section 5].
<div class="p"><!----></div>
We know from [<a href="#Str76b" name="CITEStr76b">Str76</a>] that <font size="+0">B</font> has exactly four classes of involutions,
whose normalizers in <font size="+0">B</font> have the following properties.
<div class="p"><!----></div>
<ul>
<li> The normalizer H of a <tt>2A</tt> involution has the structure
2.<sup>2</sup>E<sub>6</sub>(2).2, such that H is an extension of its derived subgroup
H′ by a field automorphism of order two, see [<a href="#Str76b" name="CITEStr76b">Str76</a>,p. 505].
This implies that H is a <em>split</em> extension of H′,
and this means that the character table of H is the one that is shown
in the A<font size="-2">TLAS</font> of Finite Groups and that has the identifier
<tt>"2.2E6(2).2"</tt> in <font face="helvetica">GAP</font>'s library of character tables;
note that the isoclinic variant of H is a <em>non-split</em> extension
of 2.<sup>2</sup>E<sub>6</sub>(2).
<div class="p"><!----></div>
</li>
<li>
The normalizer C of a <tt>2B</tt> involution has the structure
2<sup>1+22</sup>.Co<sub>2</sub>.
Its character table has been constructed in Section <a href="#table_c2b">5</a>.
<div class="p"><!----></div>
</li>
<li>
The normalizer of a <tt>2C</tt> involution is a subdirect product
of F<sub>4</sub>(2).2 and a dihedral group D<sub>8</sub> of order eight,
see [<a href="#Str76b" name="CITEStr76b">Str76</a>,La. 3.1, 5.6].
The character table of this group can easily be constructed
character-theoretically from the known character tables of
F<sub>4</sub>(2), F<sub>4</sub>(2).2, 2<sup>2</sup>, and D<sub>8</sub>.
<div class="p"><!----></div>
</li>
<li>
The normalizer of a <tt>2D</tt> involution
has order 11 689 182 992 793 600 and is contained in the
normalizer in <font size="+0">B</font> of an elementary abelian group of order 2<sup>8</sup>.
The character table of the latter normalizer has been computed from
a subgroup of <font size="+0">B</font>, see Appendix <a href="#2Dnormalizer">11</a>.
This table has a unique class with centralizer order equal to the
order of the normalizer of a <tt>2D</tt> element in <font size="+0">B</font>.
<div class="p"><!----></div>
</li>
</ul>
<div class="p"><!----></div>
Let H ≅ 2.<sup>2</sup>E<sub>6</sub>(2).2 be a <tt>2A</tt> centralizer in <font size="+0">B</font>.
The involution classes in H are as stated
in the table in [<a href="#BMverify" name="CITEBMverify">BMW20</a>,Section 5.1].
<div class="p"><!----></div>
(The subscripts 0 and 1 that appear above
are denoted by signs + and − in [<a href="#BMverify" name="CITEBMverify">BMW20</a>].)
<div class="p"><!----></div>
<div class="p"><!----></div>
Let us try to compute the necessary information about
the permutation action of <font size="+0">B</font> on the cosets of H,
restricted to H.
We calculate the first three transitive constituents
of the permutation character as listed in[<a href="#BMverify" name="CITEBMverify">BMW20</a>,Section 5.2].
<div class="p"><!----></div>
The point stabilizer of the action of H on the first orbit contains
the centre Z(H) of H, thus we may perform the computations with
H/Z(H).
If we assume that the rank of the permutation character is 5 then
we can compute the possible degrees of the irreducible constituents
combinatorially, as follows.
<div class="p"><!----></div>
The degrees are uniquely determined.
Now we compute which sums of irreducibles of these degrees
have nonnegative values.
<div class="p"><!----></div>
<pre>
gap> degrees:= lincom[1];
[ 1, 1938, 48620, 1828332, 2089164 ]
gap> constit:= List( degrees, d -> Filtered( constit, x -> x[1] = d ) );;
gap> cand1:= List( Cartesian( constit ), Sum );;
gap> cand1:= Filtered( cand1, x -> ForAll( x, y -> y >= 0 ) );;
gap> List( ConstituentsOfCharacter( cand1[1] ),
> x -> Position( Irr( f ), x ) );
[ 1, 3, 5, 13, 15 ]
</pre>
<div class="p"><!----></div>
Thus this permutation character is uniquely determined.
Alternatively, we can ask <font face="helvetica">GAP</font> to compute the possible permutation
characters of the given degree, and get the same result
(without a priori knowledge about the rank of the permutation action).
<div class="p"><!----></div>
We compute the permutation character of the action on the second orbit
in two steps.
First we induce the trivial character of F<sub>4</sub>(2) to H and then
we compute the unique subcharacter of this character that has the right
degree and only nonnegative values.
<div class="p"><!----></div>
<pre>
gap> u:= CharacterTable( "F4(2)" );;
gap> ufush:= PossibleClassFusions( u, h );;
gap> ind:= Set( ufush,
> map -> InducedClassFunctionsByFusionMap( u, h,
> [ TrivialCharacter( u ) ], map )[1] );;
gap> Length( ind );
1
gap> const:= ConstituentsOfCharacter( ind[1] );;
gap> Sum( const ) = ind[1];
true
gap> sub:= List( Cartesian( List( const, x -> [ Zero( x ), x ] ) ), Sum );;
gap> cand2:= Filtered( sub,
> x -> x[1] = ind[1][1] / 4 and Minimum( x ) >= 0 );;
gap> Length( cand2 );
1
gap> List( ConstituentsOfCharacter( cand2[1] ),
> x -> Position( Irr( h ), x ) );
[ 1, 5, 17, 24 ]
</pre>
<div class="p"><!----></div>
The character table of the point stabilizer Fi<sub>22</sub>.2
of the action of H on the third orbit is available.
We compute the corresponding permutation character by inducing the
trivial character of Fi<sub>22</sub>.2 to H.
Note that the class fusion from Fi<sub>22</sub>.2 to H is unique up to
the group automorphism of H that multiplies the elements outside
the derived subgroup of H by the central involution in H;
we know that the class <tt>2D</tt> of the point stabilizer lies in a class
of H that fuses into the class <tt>2A</tt> of <font size="+0">B</font>,
thus the first of the two fusions is the right one.
<div class="p"><!----></div>
Next we compute the value of the permutation character of the action
on the fourth orbit listed in[<a href="#BMverify" name="CITEBMverify">BMW20</a>,Section 5.2] on the
class <tt>3C</tt> of H.
The point stabilizer is H<sub>5</sub> ≅ 2<sup>1+20</sup>.U<sub>4</sub>(3).2<sup>2</sup>,
thus the subgroup H<sub>5</sub> Z(H) / Z(H) of H / Z(H) ≅ <sup>2</sup>E<sub>6</sub>(2).2
lies in a maximal subgroup of type (2<sup>1+20</sup>:U<sub>6</sub>(2)).2,
see [<a href="#CCN85" name="CITECCN85">CCN<sup>+</sup>85</a>,p. 191].
<div class="p"><!----></div>
Because the extension of 2<sup>1+20</sup> by U<sub>6</sub>(2) splits,
we know that H<sub>5</sub> Z(H) / Z(H) has U<sub>4</sub>(3) type subgroups,
thus H<sub>5</sub> has subgroups of one of the types U<sub>4</sub>(3), 2.U<sub>4</sub>(3).
Computing possible class fusions from both possibilities to H,
we get that the class of elements of order 3 in U<sub>4</sub>(3) or 2.U<sub>4</sub>(3)
that belongs to the <tt>3A</tt> class of U<sub>4</sub>(3)
lies in the class <tt>3C</tt> of H,
and the other classes of 3-elements lie in the classes <tt>3A</tt> or
<tt>3B</tt> of H, as claimed.
<div class="p"><!----></div>
The <tt>3A</tt> elements in U<sub>4</sub>(3) have centralizer order 2<sup>3</sup> ·3<sup>6</sup>
in this group.
The centralizer order in 2<sup>20</sup>.U<sub>4</sub>(3) is 2<sup>5</sup> ·3<sup>6</sup>,
since the fixed space of a <tt>3A</tt> element on the unique 20 dimensional
irreducible module in characteristic 2 has dimension 2
-this can be read off from the fact that the Brauer character value on
the class <tt>3A</tt> is −7.
<div class="p"><!----></div>
<pre>
gap> u:= CharacterTable( "U4(3)" ) mod 2;;
gap> phi:= Filtered( Irr( u ), x -> x[1] = 20 );;
gap> Display( u, rec( chars:= phi, powermap:= false ) );
U4(3)mod2
<div class="p"><!----></div>
Now the centralizer order gets doubled in the central extension to
2<sup>1+20</sup>.U<sub>4</sub>(3),
and the two upwards extensions cannot fuse the <tt>3A</tt> class with
another class, thus the centralizer order is again doubled in each case,
which means that |C<sub>H<sub>5</sub></sub>(<tt>3A</tt>)| = 2<sup>8</sup> ·3<sup>6</sup>.
<div class="p"><!----></div>
The permutation character of the action of <font size="+0">B</font> on the cosets of H
has the value 1 620 on the class <tt>3C</tt> of H.
<h2><a name="tth_sEc5">
5</a> The character table of 2<sup>1+22</sup>.Co<sub>2</sub></h2><a name="table_c2b">
</a>
<div class="p"><!----></div>
Let z be an involution in <font size="+0">B</font> whose class is called <tt>2B</tt> in the
A<font size="-2">TLAS</font> of Finite Groups.
The centralizer C of z in <font size="+0">B</font> has the structure 2<sup>1+22</sup>.Co<sub>2</sub>,
the construction of its character table is described in [<a href="#Pah07" name="CITEPah07">Pah07</a>],
and this table is available in <font face="helvetica">GAP</font>.
However, that paper assumes the knowledge of the character table of <font size="+0">B</font>,
hence we are not allowed to use the known character table of C
in the verification of the character table of <font size="+0">B</font>.
<div class="p"><!----></div>
In this section, we recompute the character table of C, as follows.
We start with the three certified matrix representations of <font size="+0">B</font>
in characteristic 2, 3, and 5,
and with the straight line program for restricting these representations
to a <tt>2B</tt> centralizer.
<div class="p"><!----></div>
First we standardize the generators of the subgroup such that
the known straight line program for computing class representatives of Co<sub>2</sub>
can be applied.
Next we compute a permutation representation of degree 4600 for the
factor group C / 〈z 〉.
Using this representation,
we construct a straight line program that computes class representatives
of C / 〈Z 〉 from the images of the given generators of C
under the natural epimorphism.
Applying this straight line program to the restrictions of the
given representations of <font size="+0">B</font> and then computing the class labels in <font size="+0">B</font>
yields a "preliminary class fusion´´ from C to <font size="+0">B</font>.
Furthermore,
the given matrix representations of C in characteristic 3 and 5
have a unique faithful constituent,
which lifts to the unique ordinary irreducible character of degree 2048
of C.
Hence the Brauer characters of the two representations yield most of the
values of this ordinary character.
Together with the character table of C / 〈Z 〉 that can be
computed by <font face="helvetica">MAGMA</font> [<a href="#Magma" name="CITEMagma">BCP97</a>] from the permutation representation,
this information suffices to complete the character table of C.
<div class="p"><!----></div>
Using the given degree 4371 matrix representation of <font size="+0">B</font>
over the field with three elements
(verified as described in Section <a href="#pres_B">2</a>)
and the description from [<a href="#AGRv3" name="CITEAGRv3">WWT<sup>+</sup></a>] how to restrict this representation
to (a conjugate of) C,
we compute generators of C.
<div class="p"><!----></div>
The composition factors of the 4371 dimensional module for C have the
dimensions 23, 2300, and 2048, respectively.
The kernels of the actions of C on these factors will turn out to have
the orders 2<sup>23</sup>, 2, and 1, respectively.
<div class="p"><!----></div>
We use the action on the 23-dimensional module
to find words in terms of the generators of C
that act on this module as <em>standard generators</em> of Co<sub>2</sub>,
as defined in [<a href="#Wil96" name="CITEWil96">Wil96</a>].
<div class="p"><!----></div>
For that, we find two elements a, b that generate Co<sub>2</sub> and
lie in the conjugacy classes <tt>2A</tt> and <tt>5A</tt>, respectively,
such that the product a b has order 28.
<div class="p"><!----></div>
<div class="p"><!----></div>
Let us call the generators in the 23-dimensional composition factor
x and y, and set c = y (y x)<sup>3</sup>.
Then the elements y<sup>12</sup>, c<sup>−1</sup> ((y<sup>4</sup> x)<sup>4</sup>) c are standard generators
of Co<sub>2</sub>, see Appendix <a href="#slp_co2">8</a>.
The following straight line program computes these elements
when it is applied to x and y.
<div class="p"><!----></div>
Next we find an orbit of length 4600 under the action of C
on the 2300-dimensional module.
This will allow us to represent C/〈z 〉 as a permutation group
P, say, of degree 4600.
<div class="p"><!----></div>
Note that Co<sub>2</sub> contains a maximal subgroup of the structure U<sub>6</sub>(2).2,
of index 2300,
and that there is a 2<sup>21</sup>.U<sub>6</sub>(2).2 type subgroup of C that fixes
a 1-dimensional subspace in the given 2300-dimensional representation
of C over the field with three elements.
We can compute generators for (a sufficiently large subgroup of)
2<sup>22</sup>.U<sub>6</sub>(2).2 by applying the straight line program for computing
generators of a U<sub>6</sub>(2).2 type subgroup from standard generators of Co<sub>2</sub>.
Then we find a vector in the 1-dimensional subspace
as the common fixed vector of squares of commutators in this subgroup.
<div class="p"><!----></div>
In P, we compute a basis for the elementary abelian
normal subgroup N of order 2<sup>22</sup>,
and the following words for the basis vectors
in terms of the standard generators of Co<sub>2</sub>,
see Appendix <a href="#slp_kernel">9</a>.
<div class="p"><!----></div>
the straight line program that is available in [<a href="#AGRv3" name="CITEAGRv3">WWT<sup>+</sup></a>]
computes class representatives of Co<sub>2</sub> from standard generators.
<div class="p"><!----></div>
Hence we can describe representatives of the 388 classes of P
as products of the class representatives of Co<sub>2</sub>
and suitable elements of N.
The necessary computations are described in Appendix <a href="#slp_classreps">10</a>.
<div class="p"><!----></div>
The list <tt>classrepsinfo</tt> contains 60 entries;
the i-th entry describes the preimage classes of the i-th class
of Co<sub>2</sub>,
by listing the positions of those basis vectors that can be multiplied
with the i-th output of <tt>slp_co2classreps</tt> in order to get
the class representatives in question.
<div class="p"><!----></div>
(The ordering of the representatives fits to the ordering of the classes
in the relevant factor of the library character table of C.
The entry <tt>[ 0 ]</tt> means that the identity matrix is taken instead
of the representative.)
<div class="p"><!----></div>
The <font face="helvetica">GAP</font> code for turning this information into a straight line program
is shorter than the lines of this program,
hence we show this program.
<div class="p"><!----></div>
<pre>
gap> create_classreps_slp:= function( classreps )
> local words, l, len, lines, kerneloffset, inputoffset, cache, k,
> found, pair, pos, diff, pos2, first, n, outputs, i, list;
>
> # Find words for the products of kernel generators that occur.
> words:= [];
> for l in Set( Concatenation( List( classreps, x -> x[2] ) ) ) do
> len:= Length( l );
> if 2 <= len then
> if not IsBound( words[ len ] ) then
> words[ len ]:= [];
> fi;
> Add( words[ len ], l );
> fi;
> od;
>
> lines:= [];
> kerneloffset:= 60;
> inputoffset:= 82;
>
> # We have to form all products of length 2 of kernel generators.
> cache:= [ [], [] ];
> for l in words[2] do
> Add( lines,
> [ l[1] + kerneloffset, 1, l[2] + kerneloffset, 1 ] );
> Add( cache[1], l );
> Add( cache[2], Length( lines ) + inputoffset );
> od;
>
> # For products of length at least 3, we may use known products
> # of length 2. Longer matches are not considered.
> for k in [ 3 .. Length( words ) ] do
> for l in words[k] do
> found:= false;
> for pair in Combinations( l, 2 ) do
> pos:= Position( cache[1], pair );
> if pos <> fail then
> diff:= Difference( l, pair );
> if Length( diff ) = 1 then
> Add( lines,
> [ cache[2][ pos ], 1, diff[1] + kerneloffset, 1 ] );
> else
> pos2:= Position( cache[1], diff );
> if pos2 <> fail then
> Add( lines,
> [ cache[2][ pos ], 1, cache[2][ pos2 ], 1 ] );
> else
> first:= cache[2][ pos ];
> for n in diff do
> Add( lines, [ first, 1, n + kerneloffset, 1 ] );
> first:= Length( lines ) + inputoffset;
> od;
> fi;
> fi;
> Add( cache[1], l );
> Add( cache[2], Length( lines ) + inputoffset );
> found:= true;
> break;
> fi;
> od;
> if not found then
> first:= l[1] + kerneloffset;
> for n in l{ [ 2 .. Length( l ) ] } do
> Add( lines, [ first, 1, n + kerneloffset, 1 ] );
> first:= Length( lines ) + inputoffset;
> od;
> Add( cache[1], l );
> Add( cache[2], Length( lines ) + inputoffset );
> fi;
> od;
> od;
>
> outputs:= [];
>
> for i in [ 1 .. Length( classreps ) ] do
> list:= classreps[i][2];
> for l in list do
> if l = [ 0 ] then
> Add( outputs, [ kerneloffset + 1, 2 ] );
> elif l = [] then
> Add( outputs, [ i, 1 ] );
> elif Length( l ) = 1 then
> Add( lines, [ i, 1, l[1] + kerneloffset, 1 ] );
> Add( outputs, [ Length( lines ) + inputoffset, 1 ] );
> else
> # The words are already cached.
> pos:= Position( cache[1], l );
> Add( lines, [ i, 1, cache[2][ pos ], 1 ] );
> Add( outputs, [ Length( lines ) + inputoffset, 1 ] );
> fi;
> od;
> od;
>
> Add( lines, outputs );
>
> return StraightLineProgram( lines, inputoffset );
> end;;
gap> slp_classreps:= create_classreps_slp( classrepsinfo );;
</pre>
<div class="p"><!----></div>
We compute the class representatives of P.
<div class="p"><!----></div>
Now the <font face="helvetica">MAGMA</font> [<a href="#Magma" name="CITEMagma">BCP97</a>] system is invoked
for computing the irreducible characters of P.
The function <tt>CharacterTableComputedByMagma</tt> guarantees that
the columns are indexed by the class representatives we have chosen.
<div class="p"><!----></div>
<pre>
gap> g:= Group( stdperms );;
gap> SetConjugacyClasses( g,
> List( classreps, x -> ConjugacyClass( g, x ) ) );
gap> libcb2b:= CharacterTable( "BM2" );
CharacterTable( "2^(1+22).Co2" )
gap> cen:= ClassPositionsOfCentre( libcb2b );;
gap> if CTblLib.IsMagmaAvailable() then
> mgmt:= CharacterTableComputedByMagma( g, "2^22.Co2-Magma" );
> else
> mgmt:= libcb2b / cen; # this is a hack ...
> fi;
</pre>
<div class="p"><!----></div>
<div class="p"><!----></div>
<div class="p"><!----></div>
Our next goal is to compute the character table of C,
together with the information about the correspondence of the
conjugacy classes in C and <font size="+0">B</font>.
<div class="p"><!----></div>
In order to write down class representatives of C,
we evaluate the words for class representatives of
C / 〈z 〉 in the generators of the faithful
2048-dimensional module for C, in characteristic 3 and 5.
For elements of order not divisible by 15, we can compute the Brauer
character value in at least one of the two representations,
and interpret it as the value of the unique faithful irreducible ordinary
character of degree 2048 of C.
Whenever this character value is nonzero, we know that the corresponding
class of C / 〈z 〉 splits into two classes of C,
on which the values of this character differ by sign.
For classes where the character value is zero, it will turn out later
that no splitting occurs; for the moment, we leave this question open.
<div class="p"><!----></div>
We get words in terms of the generators a and b of C for the elements
in question, that is, for the class representatives of C / 〈z 〉
and for products of some of them with the central involution of C.
<div class="p"><!----></div>
We evaluate these words in the three 4371-dimensional representations,
and run the identification program in order to assign the label of one of
the preliminary conjugacy classes of <font size="+0">B</font> to them.
<div class="p"><!----></div>
Let us collect the necessary data, that is,
the class representatives of C / 〈z 〉 in the restrictions
of the three representations of <font size="+0">B</font> to C
and in the two 2048-dimensional representations of C,
in characteristics 3 and 5, respectively.
<div class="p"><!----></div>
Next we need the central involution of C in the five representations.
We are lucky, the preimage of the identity of C / 〈z 〉
under the epimorphism from C that is computed by the straight line
program <tt>slp_classreps</tt> has order two.
<div class="p"><!----></div>
<pre>
gap> slp:= RestrictOutputsOfSLP( slp_classreps, 1 );;
gap> centralinv_2048:= List( inputs2048,
> l -> ResultOfStraightLineProgram( slp, l ) );;
gap> List( centralinv_2048, Order );
[ 2, 2 ]
gap> centralinv_B:= List( inputsB,
> l -> ResultOfStraightLineProgram( slp, l ) );;
</pre>
<div class="p"><!----></div>
Now we run over the class representatives of C / 〈z 〉,
and collect the data in a record with the following components.
<div class="p"><!----></div>
<tt>preimages</tt>:
one or two preimage classes, depending on whether the class in question
need not split or must split,
<div class="p"><!----></div>
<tt>fusionlabels</tt>:
for each class of C / 〈z 〉,
one or two labels of class names in <font size="+0">B</font>,
<div class="p"><!----></div>
<tt>projcharacter</tt>:
the Brauer character value of the first preimage of the class
in one of the 2048-dimensional representations, if possible;
otherwise <tt>fail</tt>.
<div class="p"><!----></div>
<pre>
gap> cent_table:= rec( preimages:= [],
> fusionlabels:= [],
> projcharacter:= [] );;
gap> for i in [ 1 .. Length( classreps ) ] do
> # identify the representative
> slp:= RestrictOutputsOfSLP( slp_classreps, i );
> id:= IdentifyClassName( inputsB[1], inputsB[2], inputsB[3], slp, fail );
> order:= Int( Filtered( id, IsDigitChar ) );
>
> if order mod 3 = 0 then
> if order mod 5 = 0 then
> # We cannot compute the Brauer character value.
> value:= fail;
> else
> value:= BrauerCharacterValue(
> ResultOfStraightLineProgram( slp, inputs2048[2] ) );
> fi;
> else
> value:= BrauerCharacterValue(
> ResultOfStraightLineProgram( slp, inputs2048[1] ) );
> fi;
>
> if value = 0 then
> # Assume no splitting.
> Add( cent_table.preimages, [ i ] );
> Add( cent_table.fusionlabels, [ id ] );
> Add( cent_table.projcharacter, value );
> else
> # Identify the class of the other preimage.
> mats:= List( inputsB,
> l -> ResultOfStraightLineProgram( slp, l ) );
> id2:= IdentifyClassName( mats[1] * centralinv_B[1],
> mats[2] * centralinv_B[2],
> mats[3] * centralinv_B[3],
> fail, fail );
> if value = fail then
> # no Brauer character value known
> Add( cent_table.preimages, [ i ] );
> Add( cent_table.fusionlabels, [ id, id2 ] );
> Add( cent_table.projcharacter, value );
> else
> # two preimage classes, take the positive value first
> Add( cent_table.preimages, [ i, i ] );
> if value > 0 then
> Add( cent_table.fusionlabels, [ id, id2 ] );
> Add( cent_table.projcharacter, value );
> else
> Add( cent_table.fusionlabels, [ id2, id ] );
> Add( cent_table.projcharacter, -value );
> fi;
> fi;
> fi;
> od;
</pre>
<div class="p"><!----></div>
Let us compute the missing values for the faithful irreducible character
of C.
We know that these values are integers,
and the character values at the p-th powers are known,
for p ∈ { 3, 5 }.
The value at the p-th power of an element g, say,
determines the congruence class of the value at g modulo p,
thus we know the congruence classes of the missing values modulo 15.
For each of the classes of C where the character value is not known yet,
the class length is at least |C| / 120,
and a character value of absolute value 7 or larger
on any of these classes would lead to a contribution of at least 7<sup>2</sup> / 120
to the norm of the character.
However, the known character values contribute already more than
1 − 7<sup>2</sup> / 120 to the norm, hence the missing character values
are uniquely determined by their congruence class modulo 15.
<div class="p"><!----></div>
Thus we may complete the character, as follows.
<div class="p"><!----></div>
<pre>
gap> for i in failpos do
> v:= ChineseRem( [ 3, 5 ], [ chi[ PowerMap( mgmt, 3, i ) ],
> chi[ PowerMap( mgmt, 5, i ) ] ] );
> if v > 7 then
> v:= v - 15;
> fi;
> chi[i]:= AbsInt( v );
> od;
gap> chi{ failpos };
[ 2, 0, 0, 0, 1, 1, 2, 0, 0, 0, 1, 1 ]
</pre>
<div class="p"><!----></div>
<div class="p"><!----></div>
In order to assign the right labels to the preimages of those classes
of C / 〈z 〉 that split into two classes of C,
we use congruences w. r. t. the third power map.
Note that we have chosen that <em>positive</em>
values of the projective character
belong to the <em>first</em> entry in each pair of class labels.
<div class="p"><!----></div>
We see from the element orders that the first three pairs are already
sorted correctly.
The fourth pair must be swapped because <tt>30A</tt> cubes to <tt>10A</tt>
and the positive values of the projective character
are not congruent modulo 3.
Similarly, the last two pairs need not be swapped because <tt>30F</tt>
cubes to <tt>10F</tt>.
<div class="p"><!----></div>
Assuming that not more classes of C / 〈z 〉 split
under the epimorphism from C,
we create the (preliminary) character tablehead of C.
<div class="p"><!----></div>
<pre>
gap> for i in split do
> cent_table.preimages[i]:= [ i, i ];
> od;
gap> factorfusion:= Concatenation( cent_table.preimages );;
gap> cb2b:= rec( UnderlyingCharacteristic:= 0,
> Size:= 2 * Size( mgmt ),
> Identifier:= "C_B(2B)",
> SizesCentralizers:= [] );;
gap> proj:= InverseMap( factorfusion );;
gap> for i in [ 1 .. Length( proj ) ] do
> if IsInt( proj[i] ) then
> cb2b.SizesCentralizers[ proj[i] ]:= SizesCentralizers( mgmt )[i];
> else
> cb2b.SizesCentralizers{ proj[i] }:=
> SizesCentralizers( mgmt )[i] * [ 2, 2 ];
> fi;
> od;
</pre>
<div class="p"><!----></div>
The element orders are given by the class labels.
<div class="p"><!----></div>
Next we turn the projective character <tt>chi</tt> of C/〈z 〉
into a character for C,
and inflate the characters of the factor group to C.
<div class="p"><!----></div>
<pre>
gap> chi_c:= [];;
gap> for i in [ 1 .. Length( chi ) ] do
> if chi[i] = 0 then
> chi_c[ proj[i] ]:= 0;
> else
> chi_c{ proj[i] }:= [ 1, -1 ] * chi[i];
> fi;
> od;
gap> factirr:= List( Irr( mgmt ), x -> x{ factorfusion } );;
</pre>
<div class="p"><!----></div>
Tensoring the faithful irreducible character with the 60 irreducible
characters of the factor group Co<sub>2</sub> yields 60 irreducible characters
of C, which are in fact all the missing irreducibles.
In particular, no further splitting of classes occurs.
<div class="p"><!----></div>
<pre>
gap> factirr_co2:= Filtered( factirr,
> x -> ClassPositionsOfKernel( x ) <> [ 1, 2 ] );;
gap> Length( factirr_co2 );
60
gap> ten:= Tensored( factirr_co2, [ chi_c ] );;
gap> Set( List( ten, x -> ScalarProduct( cb2b, x, x ) ) );
[ 1 ]
gap> irr:= Concatenation( factirr, ten );;
gap> Size( cb2b ) = Sum( List( irr, x -> x[1]^2 ) );
true
gap> SetIrr( cb2b, List( irr, x -> Character( cb2b, x ) ) );
</pre>
<div class="p"><!----></div>
The only missing information on the character table of C
is that on power maps.
We use the power maps of the table for C / 〈z 〉
as approximations, and let the standard algorithms compute the
candidates for the maps of C;
for all primes, there is only one candidate.
<div class="p"><!----></div>
<div class="p"><!----></div>
<pre>
gap> powermaps:= ComputedPowerMaps( cb2b );
[ ]
gap> for p in Set( Factors( Size( cb2b ) ) ) do
> init:= CompositionMaps( InverseMap( factorfusion ),
> CompositionMaps( PowerMap( mgmt, p ), factorfusion ) );
> poss:= PossiblePowerMaps( cb2b, p, rec( powermap:= init ) );
> if Length( poss ) <> 1 then
> Error( Ordinal( p ), " power map is not unique" );
> fi;
> powermaps[p]:= poss[1];
> od;
</pre>
<div class="p"><!----></div>
Finally, we compare the newly computed character table
with that from <font face="helvetica">GAP</font>'s library.
<h2><a name="tth_sEc6">
6</a> Conjugacy classes of <font size="+0">B</font> and their centralizer orders</h2><a name="sect:classes">
</a>
<div class="p"><!----></div>
In this section, we determine the conjugacy classes of <font size="+0">B</font>
and their centralizer orders, using the fact that for each element g
(of prime order) in a group G, say,
the conjugacy classes of elements in G that contain roots of g
are in bijection with the conjugacy classes in N<sub>G</sub>(〈g 〉)
that contain roots of g,
and that this bijection respects centralizer orders.
<div class="p"><!----></div>
<div class="p"><!----></div>
We have the following information about the elements of odd prime
order in <font size="+0">B</font>, and their normalizers, see [<a href="#BMverify" name="CITEBMverify">BMW20</a>,Section 6].
<div class="p"><!----></div>
<ul>
<li> There are exactly two classes of element order 3 in <font size="+0">B</font>,
<tt>3A</tt> with normalizer S<sub>3</sub> ×Fi<sub>22</sub>.2 and
<tt>3B</tt> with normalizer 3<sup>1+8</sup>.2<sup>1+6</sup>.U<sub>4</sub>(2).2.
Both subgroups have been constructed explicitly in the certified copy
of <font size="+0">B</font>, and the character table of the second subgroup has been
recomputed from a permutation representation -it is equivalent to the
character table in <font face="helvetica">GAP</font>'s library of character tables.
<div class="p"><!----></div>
</li>
<li>
There are exactly two classes of element order 5 in <font size="+0">B</font>,
<tt>5A</tt> with normalizer 5:4 ×HS and
<tt>5B</tt> with normalizer 5<sup>1+4</sup>.2<sup>1+4</sup>.A<sub>5</sub>.4.
According to [<a href="#BMverify" name="CITEBMverify">BMW20</a>,Section 6],
the two subgroups have been constructed explicitly in the certified copy
of <font size="+0">B</font>, and the character table of the second subgroup has been
recomputed from a permutation representation -it is equivalent to the
character table in <font face="helvetica">GAP</font>'s library of character tables.
<div class="p"><!----></div>
</li>
<li>
There is exactly one class of element order 7 in <font size="+0">B</font>,
with normalizer of order 2<sup>9</sup> ·3<sup>3</sup> ·5 ·7<sup>2</sup>
and contained in maximal subgroups of type 2.<sup>2</sup>E<sub>6</sub>(2).2.
<div class="p"><!----></div>
</li>
<li>
There is exactly one class of element order 11 in <font size="+0">B</font>,
with normalizer of type S<sub>5</sub> ×11:10.
<div class="p"><!----></div>
</li>
<li>
There is exactly one class of element order 13 in <font size="+0">B</font>,
with normalizer of type S<sub>4</sub> ×13:12.
<div class="p"><!----></div>
</li>
<li>
There is exactly one class of element order 17 in <font size="+0">B</font>,
with normalizer of order 2<sup>6</sup> ·17.
<div class="p"><!----></div>
</li>
<li>
There is exactly one class of element order 19 in <font size="+0">B</font>,
with normalizer of order 2<sup>2</sup> ·3<sup>2</sup> ·19.
<div class="p"><!----></div>
</li>
<li>
There are exactly two classes of element order 23 in <font size="+0">B</font>,
which are Galois conjugate and have normalizer 2 ×23:11.
<div class="p"><!----></div>
</li>
<li>
There are exactly two classes of element order 31 in <font size="+0">B</font>,
which are Galois conjugate and have normalizer 31:15.
<div class="p"><!----></div>
</li>
<li>
There are exactly two classes of element order 47 in <font size="+0">B</font>,
which are Galois conjugate and have normalizer 47:23.
<div class="p"><!----></div>
</li>
</ul>
<div class="p"><!----></div>
We are going to create the character tablehead for <font size="+0">B</font>.
For that, we collect the information about already identified classes
in a record; its component names are the class names,
the corresponding values are the element order and the centralizer order.
The following auxiliary function sets a value in this record
(and signals an error if the value constradicts the one stored in the
library character tableof <font size="+0">B</font>).
<div class="p"><!----></div>
<pre>
gap> libB:= CharacterTable( "B" );;
gap> libBnames:= ClassNames( libB, "ATLAS" );;
gap> Bclassinfo:= rec();;
gap> SetCentralizerOrder:= function( classname, value )
> local pos;
>
> pos:= Position( libBnames, classname );
> if pos = fail then
> Print( "no class name '", classname, "'?" );
> return false;
> elif SizesCentralizers( libB )[ pos ] <> value then
> Error( "wrong centralizer order!" );
> fi;
> Bclassinfo.( classname ):=
> [ Int( Filtered( classname, IsDigitChar ) ), value ];
> return true;
> end;;
</pre>
<div class="p"><!----></div>
The values mentioned above, for elements of prime order at least 11,
are entered by hand.
<div class="p"><!----></div>
We will need the information about how many root classes a given class
of <font size="+0">B</font> has,
based on the power map information for the labels
(the list <tt>powerinfo</tt>).
<div class="p"><!----></div>
<pre>
gap> RootInfoFromLabels:= function( label )
> local found, exp, res, entry, pos, root, ord;
>
> found:= [ label ];
> exp:= [ Int( Filtered( label, IsDigitChar ) ) ];
> res:= rec( total:= [], labels:= [] );
> res.total[ exp[1] ]:= 1;
> res.labels[ exp[1] ]:= [ label ];
> for entry in powerinfo do
> for root in entry[2] do
> if not entry[1] in found then
> pos:= Position( found, root[2] );
> if pos <> fail then
> ord:= exp[ pos ] * root[1];
> Add( exp, ord );
> Add( found, entry[1] );
> if not IsBound( res.total[ ord ] ) then
> res.total[ ord ]:= 0;
> res.labels[ ord ]:= [];
> fi;
> res.total[ ord ]:= res.total[ ord ] + 1;
> Add( res.labels[ ord ], entry[1] );
> fi;
> fi;
> od;
> od;
> return res;
> end;;
</pre>
<div class="p"><!----></div>
Analogously, we will need this roots information for the normalizers
of certain elements, computed from the character tables.
<div class="p"><!----></div>
<pre>
gap> RootInfoFromTable:= function( tbl, pos )
> local orders, posord, res, i, ord;
>
> orders:= OrdersClassRepresentatives( tbl );
> posord:= orders[ pos ];
> res:= rec( total:= [], classpos:= [] );
> for i in [ 1 .. NrConjugacyClasses( tbl ) ] do
> ord:= orders[i];
> if ord mod posord = 0 and
> PowerMap( tbl, ord / posord, i ) = pos then
> if not IsBound( res.total[ ord ] ) then
> res.total[ ord ]:= 0;
> res.classpos[ ord ]:= [];
> fi;
> res.total[ ord ]:= res.total[ ord ] + 1;
> Add( res.classpos[ ord ], i );
> fi;
> od;
> return res;
> end;;
</pre>
<div class="p"><!----></div>
We compute the roots info for the four involution normalizers,
from the available character tables.
<div class="p"><!----></div>
We have to justify that the labels <tt>"2A"</tt>, <tt>"2B"</tt>,
<tt>"2C"</tt>, <tt>"2D"</tt> for class representatives fit to the
class names <tt>2A</tt>, <tt>2B</tt>, <tt>2C</tt>, <tt>2D</tt>
which are used in [<a href="#Str76b" name="CITEStr76b">Str76</a>].
For that, we check for the availability of roots of certain orders.
<div class="p"><!----></div>
We see that some of the class labels for <font size="+0">B</font> belong to more than one
conjugacy class. Exactly one such case occurs for a root class of
<tt>2A</tt>, the label <tt>"34BC"</tt> belongs to two Galois conjugate
classes <tt>34B</tt>, <tt>34C</tt>.
(This was already clear from the discussion of classes of elements
of order 17.)
<div class="p"><!----></div>
For the classes of element order different from 16,
we have to replace a class label by a pair of labels
which belong to Galois conjugate classes:
<div class="p"><!----></div>
We have to replace the label <tt>"30GH"</tt> (for which there are no square
roots) into two labels, which we call <tt>"30G"</tt> and <tt>"30H"</tt>.
<div class="p"><!----></div>
We replace <tt>"32AB"</tt> by <tt>"32A"</tt> and <tt>"32B"</tt>,
and replace <tt>"32GH"</tt> by <tt>"32G"</tt> and <tt>"32H"</tt>.
<div class="p"><!----></div>
<pre>
gap> rootinfo2B_l.labels[46];
[ "46AB" ]
</pre>
<div class="p"><!----></div>
It was already clear from the presence of two Galois conjugate classes
of element order 23 that there must be two Galois conjugate classes
of element order 46;
we replace <tt>"46AB"</tt> by <tt>"46A"</tt> and <tt>"46B"</tt>.
<div class="p"><!----></div>
We replace <tt>"56AB"</tt> by <tt>"56A"</tt> and <tt>"56B"</tt>.
<div class="p"><!----></div>
Now one case of element order 16 is left.
There are two classes of element order 8 for which we
need three classes of square roots.
We have three square roots for the label <tt>"8D"</tt>
but only two for <tt>"8H"</tt>,
which are <tt>"16C"</tt> and <tt>"16DF"</tt>.
Since both of them have square roots,
we conclude that we have to introduce one new label for a class
of element order 16 that has no square roots.
We call this new label <tt>"16F"</tt>,
and replace <tt>"16DF"</tt> by <tt>"16D"</tt>.
<div class="p"><!----></div>
We record the splittings in the list <tt>powerinfo</tt>.
First we replace the entry for each splitting label by two entries.
<div class="p"><!----></div>
The splitting classes occur as powers only in the follwoing cases:
We may choose <tt>"23A"</tt> as the square of <tt>"46A"</tt>,
and <tt>"23B"</tt> as the square of <tt>"46B"</tt>.
And we have already said that the square of both <tt>"32C"</tt>
and <tt>"32D"</tt> shall be <tt>"16D"</tt>.
We adjust these cases by hand.
<div class="p"><!----></div>
Now the numbers of roots for the four involution labels coincide
with the corresponding numbers of root classes in the normalizers.
We know that <font size="+0">B</font> has 184 conjugacy classes.
<div class="p"><!----></div>
Next we verify that the labels for elements of odd order
describe already the conjugacy classes of elements of odd order.
For that, it is sufficient to check the normalizers of
<tt>"3A"</tt>, <tt>"3B"</tt>, <tt>"5A"</tt>, <tt>"5B"</tt>.
Note that <tt>"3A"</tt> has roots of order 66 and
<tt>"3B"</tt> has no such roots,
and <tt>"5A"</tt> has roots of order 70 and <tt>"5B"</tt> has not;
this means that the names of the labels coincide with the class names.
<div class="p"><!----></div>
We try to identify the classes with labels.
The numbers of classes and labels fit together,
now we compute the bijection.
The following function identifies classes which are determined either
already by the element order or as a power of an identified class
or as a unique root of an identified class.
<div class="p"><!----></div>
<pre>
gap> IdentifyCentralizerOrders:= function( normtbl, rl, rt )
> local n, identified, found, i, unknown, class, d, linfo, p, e, cand,
> imgs, im, pos, powerlabel, dd, cent;
> n:= First( [ 1 .. Length( rl ) ], i -> IsBound( rl[i] ) );
> identified:= [ [], [] ];
> found:= true;
> while found do
> found:= false;
> for i in [ 1 .. Length( rl ) ] do
> if IsBound( rl[i] ) then
> unknown:= Difference( rl[i], identified[1] );
> if Length( unknown ) = 1 then
> # Identify the class.
> class:= Difference( rt[i], identified[2] )[1];
> Add( identified[1], unknown[1] );
> Add( identified[2], class );
> found:= true;
> # Identify the admissible powers.
> for d in Difference( DivisorsInt( i / n ), [ 1 ] ) do
> linfo:= powerinforec.( unknown[1] );
> for p in Factors( d ) do
> e:= First( linfo, x -> x[1] = p );
> linfo:= powerinforec.( e[2] );
> od;
> if not e[2] in identified[1] then
> Add( identified[1], e[2] );
> Add( identified[2], PowerMap( normtbl, d, class ) );
> found:= true;
> fi;
> od;
> else
> # Try to identify roots whose powers are identified.
> for d in Difference( DivisorsInt( i / n ), [ 1 ] ) do
> cand:= Difference( rt[i], identified[2] );
> imgs:= PowerMap( normtbl, d ){ cand };
> for im in Intersection( imgs, identified[2] ) do
> pos:= Positions( imgs, im );
> if Length( pos ) = 1 then
> class:= cand[ pos[1] ];
> powerlabel:= identified[1][
> Position( identified[2], im ) ];
> # Find the labels of the 'd'-th powers of 'unknown'.
> linfo:= List( unknown, l -> powerinforec.( l ) );
> for p in Factors( d ) do
> e:= List( linfo, ll -> First( ll, x -> x[1] = p ) );
> linfo:= List( e, ee -> powerinforec.( ee[2] ) );
> od;
> linfo:= List( e, x -> x[2] );
> pos:= Position( linfo, powerlabel );
> Add( identified[1], unknown[ pos ] );
> Add( identified[2], class );
> # Identify the admissible powers.
> for dd in Difference( DivisorsInt( i / n ), [ 1 ] ) do
> linfo:= powerinforec.( unknown[ pos ] );
> for p in Factors( dd ) do
> e:= First( linfo, x -> x[1] = p );
> linfo:= powerinforec.( e[2] );
> od;
> if not e[2] in identified[1] then
> Add( identified[1], e[2] );
> Add( identified[2], PowerMap( normtbl, dd, class ) );
> found:= true;
> fi;
> od;
> found:= true;
> break; # since we have to update 'unknown'
> fi;
> od;
> if found then
> break; # since we have to update 'unknown'
> fi;
> od;
> fi;
> fi;
> od;
> od;
> # Where the centralizer order is unique, set it.
> for i in [ 1 .. Length( rl ) ] do
> if IsBound( rl[i] ) then
> cand:= Difference( rt[i], identified[2] );
> cent:= Set( SizesCentralizers( normtbl ){ cand } );
> if Length( cent ) = 1 then
> Append( identified[1], Difference( rl[i], identified[1] ) );
> Append( identified[2], cand );
> fi;
> fi;
> od;
> # Set the centralizer orders.
> for i in [ 1 .. Length( identified[1] ) ] do
> if not IsBound( Bclassinfo.( identified[1][i] ) ) then
> Print( "#I identify ", identified[1][i], "\n" );
> fi;
> SetCentralizerOrder( identified[1][i],
> SizesCentralizers( normtbl )[ identified[2][i] ] );
> od;
> # Return the information about unidentified classes.
> return [ Difference( Concatenation( Compacted( rl ) ), identified[1] ),
> Difference( Concatenation( Compacted( rt ) ), identified[2] ) ];
> end;;
</pre>
<div class="p"><!----></div>
We try the function with the four involution normalizers.
In the case of <tt>cb2b</tt>,
we are better off since we know most of the class fusion to <font size="+0">B</font>.
Thus we use also the information about the labels that belong to roots of
<tt>"2B"</tt> elements where this is available.
<div class="p"><!----></div>
The classes <tt>18A</tt> and <tt>"18B"</tt> are roots of <tt>"2A"</tt>.
They have no roots and the same power maps.
The centralizer orders of the two classes in the <tt>"2A"</tt> centralizer
are 1296 = 2<sup>4</sup> ·3<sup>4</sup> and 648 = 2<sup>3</sup> ·3<sup>4</sup>, respectively.
We know a class in <tt>cb2b</tt> that fuses into <tt>18A</tt> and
has centralizer order 144 = 2<sup>4</sup> ·3<sup>2</sup> in <tt>cb2b</tt>.
Thus <tt>18A</tt> must have centralizer order 1296 in <font size="+0">B</font>.
<div class="p"><!----></div>
The cases <tt>"16D"</tt> and <tt>"16F"</tt> will be handled below.
<div class="p"><!----></div>
Later we will need the class fusion from C<sub>B</sub>(<tt>2B</tt>) to <font size="+0">B</font>,
and we know it already as far as the class invariants reach.
We compute part of the missing information.
<div class="p"><!----></div>
We are free to choose the images of the class fusion for the elements of
order 23 (which then determines the classes of element order 46),
32, and 56, since the question is about independent pairs
of Galois conjugate classes.
<div class="p"><!----></div>
Thus we are left with the question about the fusion to the classes with the
labels <tt>"16D"</tt>, <tt>"16F"</tt>, <tt>"30G"</tt>, and <tt>"30H"</tt>.
<div class="p"><!----></div>
For the order 30 elements, we may choose images for <em>one</em> pair of
Galois conjugate classes, and later try to distinguish the two possibilities
for the other pair, for example via induced characters.
<div class="p"><!----></div>
Two classes of order 16 elements with fusion label <tt>"16DF"</tt>
are roots of the central involution of <tt>cb2b</tt>,
and we can distinguish them by the fact that
<tt>"16D"</tt> has square roots whereas <tt>"16F"</tt> has not.
For the other three classes, we are left with two possibilities.
<div class="p"><!----></div>
This means that we have currently 2<sup>5</sup> candidates for the class fusion
from <tt>cb2b</tt> to <font size="+0">B</font>.
<div class="p"><!----></div>
<pre>
gap> cb2bfusb:= List( fusionlabels, l -> Position( Bnames, l ) );;
gap> Positions( cb2bfusb, fail );
[ 274, 281, 396, 445, 447 ]
gap> pos:= Positions( fusionlabels, "16DF" );
[ 274, 281, 396 ]
gap> for i in pos do
> cb2bfusb[i]:= [ 86, 88 ];
> od;
gap> pos:= Positions( fusionlabels, "30GH" );
[ 445, 447 ]
gap> for i in pos do
> cb2bfusb[i]:= [ 143, 144 ];
> od;
</pre>
<div class="p"><!----></div>
Before we compute the irreducible characters of <font size="+0">B</font>,
we create the character tablehead for <font size="+0">B</font>.
<div class="p"><!----></div>
<pre>
gap> bhead:= rec( UnderlyingCharacteristic:= 0,
> Size:= Bclassinfo.( "1A" )[2],
> Identifier:= "Bnew" );;
gap> bhead.SizesCentralizers:= List( Bnames, x -> Bclassinfo.( x )[2] );;
gap> bhead.OrdersClassRepresentatives:= List( Bnames,
> x -> Bclassinfo.( x )[1] );;
gap> bhead.ComputedPowerMaps:= [];;
gap> galoisinfo:= rec(
> classes:= [ "23A", "23B", "30G", "30H", "31A", "31B", "32A", "32B",
> "32C", "32D", "34B", "34C", "46A", "46B", "47A", "47B",
> "56A", "56B" ],
> partners:= [ "23B", "23A", "30H", "30G", "31B", "31A", "32B", "32A",
> "32D", "32C", "34C", "34B", "46B", "46A", "47B", "47A",
> "56B", "56A" ],
> rootsof:= [ -23, -23, -15, -15, -31, -31, 2, 2,
> -2, -2, 17, 17, -23, -23, -47, -47,
> 7, 7 ] );;
gap> galoisinfo.irrats:= List( galoisinfo.rootsof, Sqrt );;
gap> for p in Filtered( [ 1 .. Maximum( bhead.OrdersClassRepresentatives ) ],
> IsPrimeInt ) do
> map:= [ 1 ];
> for i in [ 2 .. Length( Bnames ) ] do
> if bhead.OrdersClassRepresentatives[i] = p then
> map[i]:= 1;
> elif bhead.OrdersClassRepresentatives[i] mod p = 0 then
> # The 'p'-th power has smaller order, we know the image class.
> info:= First( powerinforec.( Bnames[i] ), pair -> pair[1] = p );
> map[i]:= Position( Bnames, info[2] );
> else
> # The 'p'-th power is a Galois conjugate.
> pos:= Position( galoisinfo.classes, Bnames[i] );
> if pos = fail then
> # The 'i'-th class is rational.
> map[i]:= i;
> else
> # Determine whether the pair gets swapped.
> irrat:= galoisinfo.irrats[ pos ];
> if GaloisCyc( irrat, p ) <> irrat then
> map[i]:= Position( Bnames, galoisinfo.partners[ pos ] );
> else
> map[i]:= i;
> fi;
> fi;
> fi;
> od;
> bhead.ComputedPowerMaps[p]:= map;
> od;
gap> ConvertToCharacterTable( bhead );;
</pre>
<div class="p"><!----></div>
Check the library table of <font size="+0">B</font> against the character tablehead.
<div class="p"><!----></div>
<pre>
gap> b:= CharacterTable( "B" );;
gap> for p in Filtered( [ 2 ..
> Maximum( OrdersClassRepresentatives( b ) ) ],
> IsPrimeInt ) do
> PowerMap( b, p );
> od;
gap> ComputedPowerMaps( bhead ) = ComputedPowerMaps( b );
true
</pre>
<div class="p"><!----></div>
Determine the missing pieces of the class fusion
from the <tt>2B</tt> centralizer to <font size="+0">B</font>.
<div class="p"><!----></div>
<pre>
gap> maps:= ContainedMaps( cb2bfusb );;
gap> Length( maps );
32
gap> good:= [];;
gap> for map in maps do
> ind:= InducedClassFunctionsByFusionMap( cb2b, b, Irr( cb2b ), map );
> if ForAll( ind, x -> IsInt( ScalarProduct( b, x, x ) ) ) then
> Add( good, map );
> fi;
> od;
gap> Length( good );
1
gap> b2b:= CharacterTable( "BM2" );;
gap> good[1] = GetFusionMap( b2b, b );
true
</pre>
<div class="p"><!----></div>
In our situation (where the classes of the subgroup have been
identified via the class invariants for <font size="+0">B</font>,
and where we have made appropriate choices for the pairs of
Galois conjugate classes),
the class fusion is unique.
<div class="p"><!----></div>
The newly computed fusion coincides with the one that is stored
on the <font face="helvetica">GAP</font> library table.
<div class="p"><!----></div>
<h2><a name="tth_sEc7">
7</a> The irreducible characters of <font size="+0">B</font></h2><a name="sect:irreducibles">
</a>
<div class="p"><!----></div>
We assume the following information about the Baby Monster group <font size="+0">B</font>.
<div class="p"><!----></div>
<ul>
<li> The conjugacy class lengths, the element orders, and the power maps
(for all primes up to the maximal element order in <font size="+0">B</font>) are known
and coincide with the information that is shown in [<a href="#CCN85" name="CITECCN85">CCN<sup>+</sup>85</a>].
<div class="p"><!----></div>
</li>
<li>
The group <font size="+0">B</font> contains subgroups of the structures
2.<sup>2</sup>E<sub>6</sub>(2).2, Fi<sub>23</sub>, and HN.2.
The ordinary character tables of these groups have been verified
(see [<a href="#BMO17" name="CITEBMO17">BMO17</a>]) and thus may be used in our computations.
<div class="p"><!----></div>
</li>
<li>
The character table of the <tt>2B</tt> centralizer in <font size="+0">B</font> is known.
Also the class fusion from this table to the tablehead of <font size="+0">B</font>
is known by the construction of this character table
in Section <a href="#table_c2b">5</a>.
<div class="p"><!----></div>
</li>
</ul>
<div class="p"><!----></div>
For the sake of simplicity, we start with the A<font size="-2">TLAS</font> table of <font size="+0">B</font>
and store the power maps up to the maximal element order
(needed for inducing from cyclic subgroups).
<div class="p"><!----></div>
<pre>
gap> b:= CharacterTable( "B" );;
gap> for p in Filtered( [ 2 ..
> Maximum( OrdersClassRepresentatives( b ) ) ],
> IsPrimeInt ) do
> PowerMap( b, p );
> od;
</pre>
<div class="p"><!----></div>
In order to make sure that the irreducible characters that are stored
on the table are not silently used inside some computations,
we delete them from the character table.
<div class="p"><!----></div>
Now we compute candidates for the class fusions from the subgroups
which we are allowed to use.
For that, we write a small <font face="helvetica">GAP</font> program.
The input parameters are the character tables of the subgroup and <font size="+0">B</font>,
a list of characters of <font size="+0">B</font>, and perhaps a first approximation of the
class fusion in question.
<div class="p"><!----></div>
<pre>
gap> tryFusion:= function( s, b, ind, initmap )
> local i, sfusb, poss, good, test, map, indmap, indgood;
>
> for i in [ 1 .. Length( ComputedPowerMaps( b ) ) ] do
> if IsBound( ComputedPowerMaps( b )[i] ) then
> PowerMap( s, i );
> fi;
> od;
>
> if initmap = fail then
> sfusb:= InitFusion( s, b );;
> else
> sfusb:= initmap;
> fi;
>
> if not TestConsistencyMaps( ComputedPowerMaps( s ), sfusb,
> ComputedPowerMaps( b ) ) then
> Error( "inconsistency in power maps!" );
> fi;
>
> poss:= FusionsAllowedByRestrictions( s, b, Irr( s ), ind, sfusb,
> rec( decompose:= true, minamb:= 2, maxamb:= 10^4,
> quick:= false, maxlen:= 10,
> contained:= ContainedPossibleCharacters ) );
> indgood:= [];
> if ForAll( poss, x -> ForAll( x, IsInt ) ) then
> # All candidates in 'poss' are unique.
> # Consider only representatives under the symmetry group of 's'.
> poss:= RepresentativesFusions( s, poss, Group( () ) );
>
> # Discard candidates for which the scalar products
> # of induced characters are not integral.
> good:= [];
> test:= ( n -> IsInt( n ) and 0 <= n );
> for map in poss do
> indmap:= InducedClassFunctionsByFusionMap( s, b, Irr( s ), map );
> if ForAll( indmap,
> x -> ForAll( indmap,
> y -> test( ScalarProduct( b, x, y ) ) ) ) then
> Add( good, map );
> fi;
> od;
> poss:= good;
>
> # Compute those induced characters that arise independent of
> # the fusion map.
> indgood:= Intersection( List( good,
> map -> InducedClassFunctionsByFusionMap( s, b, Irr( s ),
> map ) ) );
> fi;
>
> return rec( maps:= poss, induced:= indgood );
> end;;
</pre>
<div class="p"><!----></div>
Our initial characters of <font size="+0">B</font> are the trivial character and the characters
that arise from inducing irreducible characters of cyclic subgroups.
<div class="p"><!----></div>
The class fusion from Fi<sub>23</sub> to <font size="+0">B</font> is determined uniquely
by the available data, and this takes only a few seconds.
<div class="p"><!----></div>
The class fusion from <b>C</b><sub>B</sub>(2B) to <font size="+0">B</font> may be assumed,
see Section <a href="#table_c2b">5</a>.
<div class="p"><!----></div>
Now we want to determine the class fusion from H = 2.<sup>2</sup>E<sub>6</sub>(2).2 to <font size="+0">B</font>.
The approach used above is not feasible in this case.
In order to refine the initial approximation of the class fusion,
we use that H′ contains a subgroup of the type 2.Fi<sub>22</sub>
that is contained also in a Fi<sub>23</sub> type subgroup of <font size="+0">B</font>.
Note that H is the centralizer of an involution z in <font size="+0">B</font> from the class
<tt>2A</tt>, and the class <tt>2A</tt> of Fi<sub>23</sub> lies in this class.
We may choose our Fi<sub>23</sub> subgroup such that it contains z.
The centralizer of z in Fi<sub>23</sub> has then the type 2.Fi<sub>22</sub>.
<div class="p"><!----></div>
<div class="p"><!----></div>
Thus we compute the possible class fusions from 2.Fi<sub>22</sub> to Fi<sub>23</sub>
and to H′.
The compositions of the former maps with the known fusion from Fi<sub>23</sub>
to <font size="+0">B</font> yields the possible class fusions from 2.Fi<sub>22</sub> to <font size="+0">B</font>,
and the compositions of these fusions with the inverses of the latter maps
yield the desired approximations for the fusion from Fi<sub>23</sub> to <font size="+0">B</font>.
<div class="p"><!----></div>
<pre>
gap> 2fi22:= CharacterTable( "2.Fi22" );;
gap> 2fi22fusfi23:= PossibleClassFusions( 2fi22, fi23 );;
gap> 2fi22fusb:= Set( List( 2fi22fusfi23, map -> CompositionMaps(
> fi23fusb.maps[1], map ) ) );;
gap> Length( 2fi22fusb );
2
gap> hh:= CharacterTable( "2.2E6(2)" );;
gap> 2fi22fushh:= PossibleClassFusions( 2fi22, hh );;
gap> approxhhfusb:= [];;
gap> for map1 in 2fi22fushh do
> for map2 in 2fi22fusb do
> AddSet( approxhhfusb, CompositionMaps( map2, InverseMap( map1 ) ) );
> od;
> od;
gap> Length( approxhhfusb );
4
gap> inithhfusb:= InitFusion( hh, b );;
gap> TestConsistencyMaps( ComputedPowerMaps( hh ), inithhfusb,
> ComputedPowerMaps( b ) );
true
gap> for i in [ 1 .. Length( approxhhfusb ) ] do
> if MeetMaps( approxhhfusb[i], inithhfusb ) <> true then
> Unbind( approxhhfusb[i] );
> fi;
> od;
gap> approxhhfusb:= Compacted( approxhhfusb );;
gap> Length( approxhhfusb );
2
</pre>
<div class="p"><!----></div>
We get two initial approximations, and the computation of the
class fusion from H′ to <font size="+0">B</font> is now easy.
<div class="p"><!----></div>
Thus we have determined the class fusion from H′ to <font size="+0">B</font> uniquely.
The next step is to compute the class fusion for the classes in H
that do not lie in H′.
<div class="p"><!----></div>
Now we know many induced characters of <font size="+0">B</font>.
The <font size="+0">Z</font>-lattice that is spanned by these characters contains several
irreducible characters.
Unfortunately, the LLL program in <font face="helvetica">GAP</font> does not find them immediately.
<div class="p"><!----></div>
Therefore, we proceed now in two steps.
First,
we assume that <font size="+0">B</font> has a rational ordinary irreducible character χ,
say, of degree 4371 whose 3- and 5-modular restrictions are
the Brauer characters of the representations
which we have used in Section <a href="#invs_B">3</a>.
From χ together with the known induced characters,
we easily compute a list of vectors of norm 1
such that the input characters are linear combinations of these vectors,
with nonnegative integer coefficients.
In the second step,
we will then <b>not</b> use χ
but we use the vectors found in the first step
as our candidates for the irreducible characters,
which just have to be verified.
<div class="p"><!----></div>
Let us start with the first step, and compute the values of χ.
For each representative of order not divisible by 30,
we compute the Brauer character value from a representation in
characteristic coprime to the element order;
for the remaining classes, we store 'fail' as a preliminary value.
<div class="p"><!----></div>
<pre>
gap> chi:= [];;
gap> for nam in labels do
> slp:= SLPForClassName( nam, cycprg, outputnames );
> ord:= Int( Filtered( nam, IsDigitChar ) );
> if ord mod 2 <> 0 then
> val:= 1 + BrauerCharacterValue(
> ResultOfStraightLineProgram( slp, gens_2 ) );
> elif ord mod 3 <> 0 then
> val:= BrauerCharacterValue(
> ResultOfStraightLineProgram( slp, gens_3 ) );
> elif ord mod 5 <> 0 then
> val:= BrauerCharacterValue(
> ResultOfStraightLineProgram( slp, gens_5 ) );
> else
> val:= fail;
> fi;
> Add( chi, val );
> od;
</pre>
<div class="p"><!----></div>
<div class="p"><!----></div>
<div class="p"><!----></div>
Next we transfer these values to the class positions in the character table.
For that, we compute the mapping from the character tablehead to the labels.
<div class="p"><!----></div>
<pre>
gap> bfuslabels:= [];;
gap> for i in [ 1 .. Length( libBnames ) ] do
> poss:= Filtered( labels, x -> Filtered( libBnames[i], IsDigitChar )
> = Filtered( x, IsDigitChar ) and
> ForAny( Filtered( x, IsAlphaChar ), y -> y in libBnames[i] ) );
> if Length( poss ) <> 1 then
> Print( "problem for ", libBnames[i], "\n" );
> fi;
> bfuslabels[i]:= Position( labels, poss[1] );
> od;
</pre>
<div class="p"><!----></div>
The character values are unknown for eight classes of element order 30
and three classes of element order 60.
<div class="p"><!----></div>
In order to compute the missing values,
we use the same idea as in Section <a href="#table_c2b">5</a>.
We know that these values are integers.
For all classes in question except one,
the class lengths are at least |B| / 360,
thus the absolute value of the character value at these classes
cannot exceed 5.
<div class="p"><!----></div>
Since χ( g<sup>p</sup> ) ≡ χ(g) mod p for p ∈ { 3, 5 }
and since the values χ( g<sup>p</sup> ) are known,
we know the congruence class of χ( g ) modulo 15 for all missing
classes except one.
This determines χ.
<div class="p"><!----></div>
<pre>
gap> for i in failpos do
> v:= ChineseRem( [ 3, 5 ], [ chi[ PowerMap( b, 3, i ) ],
> chi[ PowerMap( b, 5, i ) ] ] );
> if v > 5 then
> v:= v - 15;
> fi;
> chi[i]:= v;
> od;
gap> chi{ failpos };
[ -5, 1, -3, -1, -1, -2, 0, 0, -1, -1, 0 ]
gap> Sum( List( [ 1 .. Length( bclasses ) ],
> i -> bclasses[i] * chi[i]^2 ) ) = Size( b );
true
</pre>
<div class="p"><!----></div>
Now we compute candidates for the irreducibles,
under the assumption that χ is a character.
The following simple function is later used in a loop.
It takes a character table <tt>tbl</tt> and three lists of (virtual)
characters of this table:
<tt>knownirr</tt> contains known irreducibles,
<tt>newirr</tt> contains newly found irreducibles,
and <tt>knownvirt</tt> contains virtual characters.
The idea is as follows.
The list <tt>knownirr</tt> gets extended (in place) by <tt>newirr</tt>,
symmetrizations of the characters in <tt>newirr</tt> and tensor products
of the characters in <tt>knownirr</tt> with those in <tt>newirr</tt> are
created, and the concatenation of <tt>knownvirt</tt> and these characters
gets reduced with <tt>knownirr</tt> and <tt>newirr</tt>;
this process is iterated as long as new irreducible characters are found
in the reduction step, with <tt>newirr</tt> replaced by these characters;
the function returns the list of non-irreducible remainders of
<tt>knownvirt</tt>.
<div class="p"><!----></div>
We start with the trivial character of <font size="+0">B</font> and χ,
and note that the antisymmetric square of χ is irreducible.
We initialize <tt>knownvirt</tt> with the union of the induced characters
which were generated above.
<div class="p"><!----></div>
Reducing the characters with our three irreducible characters
and applying the LLL algorithm to the remainders yields 7
new irreducibles.
<div class="p"><!----></div>
We are lucky,
a short loop of reductions with the new irreducibles and LLL reduction
yields the complete list of irreducible characters.
The ch
<div class="p"><!----></div>
<pre>
gap> n:= NrConjugacyClasses( b );;
gap> while 0 < Length( lll.irreducibles ) and
> Length( lll.irreducibles ) + Length( knownirr ) < n do
> l:= ExtendCandidates( b, knownirr,
> lll.irreducibles, lll.remainders );;
> lll:= LLL( b, l, 99/100 );;
> od;
#I 11 irreducibles known
#I 17 irreducibles known
gap> Append( knownirr, lll.irreducibles );
</pre>
<div class="p"><!----></div>
The irreducible characters found this way coincide with the ones from the
A<font size="-2">TLAS</font> table of <font size="+0">B</font>.
<div class="p"><!----></div>
Now comes step two.
As stated above, all what remains is to verify the candidate vectors,
where we are allowed to use the induced characters but not χ.
<div class="p"><!----></div>
For each candidate vector, we compute whether it occurs
in the <font size="+0">Z</font>-span of the induced characters,
and if yes, we compute the coefficients of a linear combination in terms
of them.
This way, we find/verify the first 30 irreducible characters of <font size="+0">B</font>.
<div class="p"><!----></div>
<div class="p"><!----></div>
<div class="p"><!----></div>
<div class="p"><!----></div>
<pre>
gap> ind:= Concatenation( indfi23, indb2b, indhn2, indh, indcyc );;
gap> mat:= MatScalarProducts( b, knownirr, ind );;
gap> irr:= [ TrivialCharacter( b ) ];;
gap> one:= IdentityMat( NrConjugacyClasses( b ) );;
gap> for i in [ 2 .. Length( one ) ] do
> coeffs:= SolutionIntMat( mat, one[i] );
> if coeffs <> fail and ForAll( coeffs, IsInt ) then
> Add( irr, coeffs * ind );
> fi;
> od;
gap> Length( irr );
30
gap> Set( List( irr, chi -> ScalarProduct( b, chi, chi ) ) );
[ 1 ]
gap> ForAll( irr, chi -> chi[1] > 0 );
true
</pre>
<div class="p"><!----></div>
In order to get the missing irreducible characters of <font size="+0">B</font>,
we add symmetrizations and tensor products of the known irreducibles
to the list of induced characters, and project onto the orthogonal space
of the space that is spanned by the known irreducibles.
No new irreducible characters are found directly this way,
but the <tt>`oracle</tt>' that was used above tells us how to express the missing
irreducibles as integral linear combinations of the known characters.
<div class="p"><!----></div>
It is not surprising that
the irreducible characters found this way coincide with the ones from the
A<font size="-2">TLAS</font> table of <font size="+0">B</font>.
<h2><a name="tth_sEc8">
8</a> Appendix: Standardizing the generators of Co<sub>2</sub></h2><a name="slp_co2">
</a>
<div class="p"><!----></div>
In Section <a href="#table_c2b">5</a>, we have restricted the 3-modular
4371-dimensional representation of <font size="+0">B</font> to a subgroup C of the structure
2<sup>1+22</sup>.Co<sub>2</sub>, and obtained a 23-dimensional composition factor
with a faithful action of the factor group Co<sub>2</sub>,
with generators x and y, say.
Our aim is to find short words in terms of x and y
that yield <em>standard</em> generators for Co<sub>2</sub>,
that is, elements a, b from the classes <tt>2A</tt> and <tt>5A</tt>
of Co<sub>2</sub>, with the properties that the product a b has order 28
and that a and b generate the full group Co<sub>2</sub>.
<div class="p"><!----></div>
The classes <tt>2A</tt> and <tt>5A</tt> of Co<sub>2</sub> are determined by the
Brauer character values −9 and −2, respectively,
in the unique irreducible 23-dimensional 3-modular representation
of Co<sub>2</sub>.
<div class="p"><!----></div>
<pre>
gap> t:= CharacterTable( "Co2" ) mod 3;;
gap> dim23:= Filtered( Irr( t ), chi -> chi[1] = 23 );;
gap> Length( dim23 );
1
gap> pos:= PositionsProperty( OrdersClassRepresentatives( t ),
> x -> x in [ 2, 5 ] );
[ 2, 3, 4, 12, 13 ]
gap> dim23[1]{ pos };
[ -9, 7, -1, -2, 3 ]
</pre>
<div class="p"><!----></div>
The 12-th power of the second generator yields a <tt>2A</tt> element.
<div class="p"><!----></div>
A short word that defines a <tt>5A</tt> element is (y<sup>4</sup> x)<sup>4</sup>.
It can be found as follows.
<div class="p"><!----></div>
<pre>
gap> f:= FreeMonoid( 2 );;
gap> fgens:= GeneratorsOfMonoid( f );
[ m1, m2 ]
gap> for w in Iterator( f ) do
> m:= MappedWord( w, fgens, co2gens );
> ord:= Order( m );
> if ord mod 5 = 0 then
> cand:= m^( ord / 5 );
> if BrauerCharacterValue( cand ) = -2 then
> break;
> fi;
> fi;
> od;
gap> w;
m2^4*m1
gap> ord;
20
</pre>
<div class="p"><!----></div>
Similarly, we find a conjugate of the <tt>5A</tt> element such that
the product has order 28.
<div class="p"><!----></div>
<pre>
gap> for w in Iterator( f ) do
> m:= MappedWord( w, fgens, co2gens );
> b:= cand ^ m;
> if Order( a * b ) = 28 then
> break;
> fi;
> od;
gap> w;
m2*(m2*m1)^3
</pre>
<div class="p"><!----></div>
In order to show that the two elements <tt>a</tt> and <tt>b</tt>
really generate Co<sub>2</sub>,
we use the fact that no proper subgroup of Co<sub>2</sub> contains elements
of the orders 23 and 30.
<div class="p"><!----></div>
<pre>
gap> t:= CharacterTable( "Co2" );;
gap> mx:= List( Maxes( t ), CharacterTable );;
gap> ForAny( List( Maxes( t ), CharacterTable ),
> x -> IsSubset( OrdersClassRepresentatives( x ),
> [ 23, 30 ] ) );
false
</pre>
<div class="p"><!----></div>
It suffices to find products of the generators that have these orders.
We compute random elements until we are successful.
<div class="p"><!----></div>
<pre>
gap> u:= Group( a, b );;
gap> found:= [];;
gap> repeat
> x:= Order( PseudoRandom( u ) );
> if x in [ 23, 30 ] then
> AddSet( found, x );
> fi;
> until Length( found ) = 2;
gap> found;
[ 23, 30 ]
</pre>
<div class="p"><!----></div>
<div class="p"><!----></div>
<h2><a name="tth_sEc9">
9</a> Appendix: Words for generators of the kernel 2<sup>22</sup></h2><a name="slp_kernel">
</a>
<div class="p"><!----></div>
We assume (see Section <a href="#table_c2b">5</a>)
that we have permutation generators <tt>stdperms</tt> on 4060 points
for the group P ≅ 2<sup>22</sup>.Co<sub>2</sub> such that mapping them to
standard generators of Co<sub>2</sub> defines an epimorphism.
Our aim is to find (short) words in terms of <tt>stdperms</tt> for
generators of the elementary abelian normal subgroup of order 2<sup>22</sup>.
<div class="p"><!----></div>
For that, we work in parallel with standard generators <tt>co2permgens</tt>
of Co<sub>2</sub>.
<div class="p"><!----></div>
<pre>
gap> co2permgens:= GeneratorsOfGroup( AtlasGroup( "Co2" ) );;
gap> f:= FreeMonoid( 2 );;
gap> fgens:= GeneratorsOfMonoid( f );;
gap> kernelgens:= [];;
gap> kernelwords:= [];;
gap> kernel:= Group( () );;
gap> for w in Iterator( f ) do
> m1:= MappedWord( w, fgens, stdperms );
> m2:= MappedWord( w, fgens, co2permgens );
> ord1:= Order( m1 );
> ord2:= Order( m2 );
> if ord1 <> ord2 then
> cand:= m1 ^ ord2;
> if not cand in kernel then
> Add( kernelgens, cand );
> Add( kernelwords, [ w, ord2 ] );
> kernel:= ClosureGroup( kernel, cand );
> fi;
> fi;
> if Length( kernelgens ) = 22 then
> break;
> fi;
> od;
</pre>
<div class="p"><!----></div>
The kernel generators obtained with the above procedure are equal to
the results of the straight line program <tt>slp_ker</tt>
from Section <a href="#table_c2b">5</a>.
<h2><a name="tth_sEc10">
10</a> Appendix: Words for class representatives of 2<sup>22</sup>.Co<sub>2</sub></h2><a name="slp_classreps">
</a>
<div class="p"><!----></div>
The group P ≅ 2<sup>22</sup>.Co<sub>2</sub> from Section <a href="#table_c2b">5</a>
has 388 conjugacy classes, as we can compute from the permutation
representation on 4060 points.
Our aim is to find (short) words in terms of the generators <tt>stdperms</tt>
for conjugacy class representatives of P.
<div class="p"><!----></div>
For that, we first compute preimages in P of class representatives
of its factor group Co<sub>2</sub>,
using the straight line program <tt>slp_co2classreps</tt> from [<a href="#AGRv3" name="CITEAGRv3">WWT<sup>+</sup></a>],
and use them to initialize lists of known class representatives and of words
for each class of Co<sub>2</sub>.
In the lists of words, we record the indices of kernel generators with
which we have to multiply the preimage; thus the preimages themselves
are denoted by empty lists.
<div class="p"><!----></div>
<pre>
gap> factccls:= ResultOfStraightLineProgram( slp_co2classreps.program,
> stdperms );;
gap> classreps:= List( factccls, x -> [ x ] );;
gap> classwords:= List( factccls, x -> [ [] ] );;
</pre>
<div class="p"><!----></div>
The preimage of the identity element in Co<sub>2</sub> is not the identity in P.
Since it would be hard to get the identity as a product of this preimage
with a product of kernel generators,
we add the identity element by hand, and denote it by the word <tt>[ 0 ]</tt>.
<div class="p"><!----></div>
Now we multiply the class representatives by words (of increasing length)
in terms of the kernel generators
and add the elements if they yields new classes,
until we have found enough class representatives.
<div class="p"><!----></div>
The conjugacy checks in the following piece of <font face="helvetica">GAP</font> code
cannot be executed with <font face="helvetica">GAP</font> 4.9.3 or earlier versions in reasonable time.
We have done these computations via delegations to <font face="helvetica">MAGMA</font> [<a href="#Magma" name="CITEMagma">BCP97</a>],
using the auxiliary function <tt>IsConjugateViaMagma</tt>.
(We hope that eventually the necessary functionality will become available
also in <font face="helvetica">GAP</font>.)
<div class="p"><!----></div>
<pre>
gap> if CTblLib.IsMagmaAvailable() then
> IsConjugateViaMagma:= function( permgroup, pi, known )
> local path, inputs, str, out, result, pos;
>
> path:= UserPreference( "CTblLib", "MagmaPath" );
> inputs:= [ CTblLib.MagmaStringOfPermGroup( permgroup, "G" ),
> Concatenation( "p:= G!", String( pi ), ";" ),
> "l:= [" ];
> if Length( known ) > 0 then
> Append( inputs,
> List( known, p -> Concatenation( "G!", String( p ), "," ) ) );
> Remove( inputs[ Length( inputs ) ] );
> fi;
> Append( inputs,
> [ "];",
> "conj:= false;",
> "for q in l do",
> " conj:= IsConjugate( G, p, q );",
> " if conj then break; end if;",
> "end for;",
> "if conj then",
> " print true;",
> "else", # Do not call '# Class( G, p );'.
> " print \"#\", # Centralizer( G, p );",
> "end if;" ] );
> str:= "";
> out:= OutputTextString( str, true );
> result:= Process( DirectoryCurrent(), path,
> InputTextString( JoinStringsWithSeparator( inputs, "\n" ) ),
> out, [] );
> CloseStream( out );
> if result <> 0 then
> Error( "Process returned ", result );
> fi;
> pos:= PositionSublist( str, "\n# " );
> if pos <> fail then
> return Int( str{ [ pos + 3 .. Position( str, '\n', pos+1 )-1 ] } );
> elif PositionSublist( str, "true" ) <> fail then
> # 'pi' is conjugate to a perm. in 'known'
> return true;
> else
> Error( "Magma failed" );
> fi;
> end;
> co2tbl:= CharacterTable( "Co2" );;
> g:= Group( stdperms );;
> for i in [ 1 .. Length( factccls ) ] do
> iclasses:= List( classreps[i], x -> ConjugacyClass( g, x ) );
> sum:= 2^22 * SizesConjugacyClasses( co2tbl )[i]
> - Sum( List( iclasses, Size ) );
> len:= 1;
> while sum > 0 do
> for tup in Combinations( [ 1 .. 22 ], len ) do
> cand:= factccls[i] * Product( kernelgens{ tup } );
> # We call Magma anyhow in order to compute the class length.
> conj:= IsConjugateViaMagma( g, cand, classreps[i] );
> if conj <> true then
> Add( classreps[i], cand );
> Add( classwords[i], tup );
> sum:= sum - Size( g ) / conj;
> if sum <= 0 then
> break;
> fi;
> fi;
> od;
> len:= len + 1;;
> od;
> od;
> fi;
</pre>
<div class="p"><!----></div>
Let us check whether the class representatives fit to the ones
used in Section <a href="#table_c2b">5</a> (up to ordering).
<div class="p"><!----></div>
<pre>
gap> if CTblLib.IsMagmaAvailable() then
> Print( ForAll( [ 1 .. Length( factccls ) ],
> i -> Set( classrepsinfo[i][2] ) = Set( classwords[i] ) ), "\n" );
true
> else
> Print( "Magma not available, no check of class representatives\n" );
> fi;
</pre>
<div class="p"><!----></div>
<div class="p"><!----></div>
<h2><a name="tth_sEc11">
11</a> Appendix: About the character table of 2<sup>9+16</sup>.S<sub>8</sub>(2)</h2><a name="2Dnormalizer">
</a>
<div class="p"><!----></div>
As has been stated in Section <a href="#sect:classes">6</a>,
we use the character table of a maximal subgroup of <font size="+0">B</font>
that normalizes an elementary abelian group of order 2<sup>8</sup>
instead of the table of the <tt>2D</tt> normalizer in <font size="+0">B</font>.
The character table of this maximal subgroup,
of the structure 2<sup>9+16</sup>.S<sub>8</sub>(2),
had been computed from a matrix representation of the group.
We verify that this matrix group can indeed be obtained from the
restriction of one of our certified matrix representations of <font size="+0">B</font>.
<div class="p"><!----></div>
First we restrict our representation of <font size="+0">B</font> over the field with
two elements to the fourth maximal subgroup.
<div class="p"><!----></div>
Next we compute a 180 dimensional representation of this group.
(The fact that this representation is faithful follows from the
computations with it; this is beyond the scope of this note.)
<div class="p"><!----></div>
The word used above has a 3 dimensional nullspace
on the 180 dimensional module.
We try each nonzero vector in that space as a seed vector,
and consider the standard bases of the submodules generated by them;
for that, we apply the function <tt>StdBasis</tt> from Section <a href="#pres_B">2</a>.
<div class="p"><!----></div>
We repeat the same process with the matrix generators from which
the character table of the maximal subgroup 2<sup>9+16</sup>.S<sub>8</sub>(2) of <font size="+0">B</font>
has been computed.
<div class="p"><!----></div>
It turns out that the normal forms obtained this way coincide.
<div class="p"><!----></div>
<pre>
gap> List( stdgensnew, x -> Position( stdgensold, x ) );
[ 1, 2, 4, 3 ]
</pre>
<div class="p"><!----></div>
<h2>References</h2>
<dl compact="compact">
<dt><a href="#CITEMagma" name="Magma">[BCP97]</a></dt><dd>
W. Bosma, J. Cannon, and C. Playoust, <em>The Magma algebra system. I.
The user language</em>, J. Symbolic Comput. <b>24</b> (1997),
no. 3-4, 235-265. MR 1484478
<div class="p"><!----></div>
</dd>
<dt><a href="#CITEAtlas2017" name="Atlas2017">[BGH<sup>+</sup>17]</a></dt><dd>
M. Bhargava, R. Guralnick, G. Hiss, K. Lux, and P. H. Tiep (eds.), <em>Finite
simple groups: thirty years of the Atlas and beyond</em>, Contemporary
Mathematics, vol. 694, Providence, RI, American Mathematical Society, 2017.
MR 3682583
<div class="p"><!----></div>
</dd>
<dt><a href="#CITEBMO17" name="BMO17">[BMO17]</a></dt><dd>
T. Breuer, G. Malle, and E. A. O'Brien, <em>Reliability and reproducibility
of Atlas information</em>, in Bhargava et al. [<a href="#Atlas2017" name="CITEAtlas2017">BGH<sup>+</sup>17</a>],
p. 21-31. MR 3682588
<div class="p"><!----></div>
</dd>
<dt><a href="#CITEBMverify" name="BMverify">[BMW20]</a></dt><dd>
T. Breuer, K. Magaard, and R. A. Wilson, <em>Verification of the ordinary
character table of the Baby Monster</em>, J. Algebra <b>561</b> (2020),
111-130. MR 4135540
<div class="p"><!----></div>
</dd>
<dt><a href="#CITECCN85" name="CCN85">[CCN<sup>+</sup>85]</a></dt><dd>
J. H. Conway, R. T. Curtis, S. P. Norton, R. A. Parker, and R. A. Wilson,
<em>Atlas of finite groups</em>, Oxford University Press, Eynsham, 1985,
Maximal subgroups and ordinary characters for simple groups, With
computational assistance from J. G. Thackray. MR 827219 (88g:20025)
<div class="p"><!----></div>
</dd>
<dt><a href="#CITEGAP" name="GAP">[GAP24]</a></dt><dd>
<em><font face="helvetica">GAP</font> - Groups, Algorithms, and Programming,
Version 4.13.1</em>, <a href="https://www.gap-system.org"><tt>https://www.gap<tt>-</tt>system.org</tt></a>, Mar 2024.
<div class="p"><!----></div>
</dd>
<dt><a href="#CITEPah07" name="Pah07">[Pah07]</a></dt><dd>
H. Pahlings, <em>The character table of 2<sup>1+22</sup><sub>+</sub>.<span class="roman">Co</span><sub>2</sub></em>, J.
Algebra <b>315</b> (2007), no. 1, 301-325. MR 2344348
(2008g:20023)
<div class="p"><!----></div>
</dd>
<dt><a href="#CITEStr76b" name="Str76b">[Str76]</a></dt><dd>
G. Stroth, <em>A characterization of Fischer's sporadic simple group of the
order 2<sup>41</sup> ·3<sup>13</sup> ·5<sup>6</sup> ·7<sup>2</sup> ·11 ·13 ·17 ·19 ·23 ·31 ·47</em>, J. Algebra <b>40</b> (1976), no. 2,
499-531. MR 0417277 (54 #5334)
<div class="p"><!----></div>
</dd>
<dt><a href="#CITEWil96" name="Wil96">[Wil96]</a></dt><dd>
R. A. Wilson, <em>Standard generators for sporadic simple groups</em>, J. Algebra
<b>184</b> (1996), no. 2, 505-515. MR 1409225 (98e:20025)
<div class="p"><!----></div>
</dd>
<dt><a href="#CITEAGRv3" name="AGRv3">[WWT<sup>+</sup>]</a></dt><dd>
R. A. Wilson, P. Walsh, J. Tripp, I. Suleiman, R. A. Parker, S. P. Norton,
S. Nickerson, S. Linton, J. Bray, and R. Abbott, <em>ATLAS of Finite Group
Representations</em>, <a href="http://brauer.maths.qmul.ac.uk/Atlas/v3"><tt>http://brauer.maths.qmul.ac.uk/</tt>
<tt>Atlas/v3</tt></a>.</dd>
</dl>
<div class="p"><!----></div>
<div class="p"><!----></div>
<br /><br /><hr /><small>File translated from
T<sub><font size="-1">E</font></sub>X
by <a href="http://hutchinson.belmont.ma.us/tth/">
T<sub><font size="-1">T</font></sub>H</a>,
version 3.59.<br />On 22 May 2025, 15:03.</small>
</html>
Messung V0.5 in Prozent
¤ 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.0.112Bemerkung:
(vorverarbeitet am 2026-04-25)
¤
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 und die Messung sind noch experimentell.
