SSL ctblbm.htm
Sprache: HTML
|
|
| products/Sources/formale Sprachen/GAP/pkg/ctbllib/htm/ctblbm.htm |
 |
< java.lang.StringIndexOutOfBoundsException: Range [13, 12) out of bounds for leng th 79
"http://www.w3.org/TR/html4/loose.dtd">
<html>
<meta name="GENERATOR" content="TtH 3.59">
<style type="text/css"> div.p { margin-top: 7pt;}</style>
<style type="text/css"><!--
td div.comp { margin-top: -0.6ex; margin-bottom: -1ex;}
td div.comb { margin-top: -0.6ex; margin-bottom: -.6ex;}
td div.hrcomp { line-height: 0.9; margin-top<spanclass=" ) );<>
-heightnormal;java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
span.roman {font-family: serif; font-style: normal; font-weight: normal;}
span.overacc2 {position: relative; left: .8em; top: -1.2ex;}
span.overacc1 {position: relative; left: .6em; top: -1.2ex;} --></style>
<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>
<h3 align="center"> T<font size="-2">HOMAS</font> B<font size="-2">REUER</font>, K<font size="-2">AY</font> M<font size="-2">AGAARD</font>, R<font size="-2">OBERT</font> A. W<font size="-2">ILSON</font> </h3>
<div class="p"><!----></div>
<h3 align="center">May 17th, 2019 </h3>
<div class="p"><!----></div>
<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> [1080 128,0,, 0 24 , 135, ,0 , 0 0 27,27 0 0,18,
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].
Atthis point we know that thethree 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 0, 0, 12, 0, 0, 2, 0, 3,3,0,,,0 ,3,2 ,2 , 0,
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 the0 9 ,, ,0 0 0 , 3,0 0,3 ,012,0 0 , , , 0,java.lang.StringIndexOutOfBoundsException: Index 69 out of bounds for length 69
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 < href=#ect:classes>6<a>shows the 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;
is correspondsto  href#"name=CITEBMverify"BMW20/>Sectionnbsp7,
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>
<pre>
62;LoadPackage "ctbllib",false)
true
gap62; LoadPackage( "atlasrep", false );
true
</pre>
<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.
<
<pre>
gap62; 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>
gap62; F:= FreeGroup( List( "java.lang.StringIndexOutOfBoundsException: Range [0, 46) out of bounds for length 0
gap62; gens:= GeneratorsOfGroup( F );;
gap62; rels:= List( gens, x -62; x^2 );;
gap62; ord3pairs:= List( [ 1 .. 7 ], i -62; [ i, i+1 ] );
[ [ 1, 2 ], [ 2, 3 ], [ 3, 4 ], [ 4, 5 ], [ 5, 6 ], [ 6, 7 ], [ 7, 8 ] ]
gap62; Append( ord3pairs, [ [ 5, 9 ], [ 9, 10 ], [ 10, 11 ] ] );
gap62; for pair in ord3pairs do
62; Add( rels, ( gens[ pair[1] ] * gens[ pair[2] ] )^3 );
62; od;
gap62; for i in [ 1 .. 11 ] do
.. 11 ] do
62; if not [ i, j ] in ord3pairs then
62; Add( rels, ( gens[i] * gens[j] )^2 );
62; fi;
62; od;
62; od;
gap62; 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>
<pre>
gap62; gensstrings:= List( gens, String );;
gap62; relsslps:= List( List( rels, String ),
62; x -62; StraightLineProgram( x, gensstrings ) );;
</pre>
<div class="p"><!----></div>
Next we write a straight line program that computes the 11 generators
t<sub>1</sub>, 8230;, 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 <span class"APprompt>><span><span java.lang.StringIndexOutOfBoundsException: Range [52, 50) out of bounds for length 123
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>
<pre>
gap62; slp:= [ [ 1, 1, 2, 1 ], [ 3, 5 ], [ 4, 3 ], [ 5, 1, 2, 1 ] ];;
gap62; resultpos:= [];;
gap2;Add( , [6,19])java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
gap62; resultpos[11]:= Length( slp ) + 2;;
</pre>
<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>
<pre>
gap62; Append( slp, [ [ 1, 1, 7, 1 ], [ 8, 3 ] ] );
gap62; Append( slp, [ [ 6, 3 ], [ 9, 1, 10, 1 ], [ 11, 10 ],
62; [ 6, -1, 12, 1, 6, 1 ] ] );
</pre>
<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>
<pre>
gap62; # 14: e*c, 15: (e*c)^2, 16: (e*c)^3, 17: (e*c)^4, 18: (e*c)^6
gap62; Append( slp, [ [ 13, 1, 9, 1 ], [ 14, 2 ], [ 14, 1, 15, 1 ],
62; [ 15, 2 ], [ 16, 2 ] ] );
gap62; # 19: e*c*e, 20: e*c*e^2*c
gap62; Append( slp[ "A" ]
gap62; # 21: (e*c)^6*c*(e*c)^3, 22: ((e*c)^6*c*(e*c)^3)^2*e*c*e^2*c
gap62; Append( slp, [ [ 18, 1, 9, 1, 16, 1 ], [ 21, 2, 20, 1 ] ] );
gap62; # 23: (((e*c)^6*c*(e*c)^3)^2*e*c*e^2*c)^5
gap62; Append( slp, [ [ 22, 5 ] ] );
gap62; # 24: t1 = f = ((((e*c)^6*c*(e*c)^3)^2*e*c*e^2*c)^5)^((e*c)^4)
gap62; Append( slp, [ [ 17, -1, 23, 1, 17, 1 ] ] );
gap62; resultpos[1]:= Length( slp ) + 2;;
</pre>
<div class""<java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
... 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>
<pre>
gap62; # 25: (e*c)^8*c*(e*c)^3, 26:span class=""g;<span <pan class=GAPinput"PowerMap( t, {ord15 ;<java.lang.StringIndexOutOfBoundsException: Index 95 out of bounds for length 95
gap62; Append( slp, [ [ 15, 1, 21, 1 ], [ 20, 2 ] ] );
gap62; # 27: g = ((e*c)^8*c*(e*c)^3)^((e*c*e^2*c)^2)
gap62; Append( slp, [ [ 26, -1, 25, 1, 26, 1 ] ] );
gap62; # 28: g f, 29: g^-1, 30: t2 = f^{{g f}}
gap62; Append( slp, [ [ 27, 1, 24, 1 ], [ 27, -1 ],
62; [ 28, -1, 7,8, 9, 10 11,12 ]
gap62; resultpos[2]:= Length( slp ) + 2;;
</pre>
<div class="p"><!----></div>
... t<sub>3</sub> = f<sup>g f g</sup>,
t<sub>4</sub> = f<sup>g f g<sup>2</sup></sup>,
t<sub>5</sub> = f<sup>g f g<sup>3</sup></sup>,
t<<span class="GAPprompt">gap></span><spanclass="GAPinput">AtlasClassNames( t ){ [ 7 .. 12 ] };</span>
t<sub>7</sub> = f<sup>g f g<sup>5</sup></sup>,
t<sub>8</sub> = f<sup>g f g<sup>6</sup></sup> (positions 31 to 36), ...
<div class="p"><!----></div>
<pre>
gap62; # 31: t3 = f^( g * f * g )
gap62; Append( slp, [ [ 29, 1, 30, 1, 27, 1 ] ] );
gap62; resultpos[3]:= Length( slp ) + 2;;
gap62; # 32: t4 = f^( g * f * g^2 )
gap62; Append( slp, [ [ 29, 1, 31, 1, 27, 1 ] ] );
gap62; resultpos[4]:= Length( slp ) + 2;;
gap62; # 33: t5 = f^( g * f * g^3 )
gap62; Append( slp, [ [ 29, 1, 32, 1, 27, 1 ] ] );
gap62; resultpos[5]:= Length( slp ) + 2;;
gap62; # "B", "3C, "3D", "3E", "F" "3" ]
gap62; Append( slp, [ [ 29, 1, 33, 1, 27, 1 ] ] );
gap62; resultpos[6]:= Length( slp ) + 2;;
gap62; # 35: t7 = f^( g * f * g^5 )
gap62; Append( slp, [ [ 29, 1, 34, 1, 27, 1 ] ] );
gap62; resultpos[7]:= Length( slp ) + 2;;
gap62; # 36: t8 = f^( g * f * g^6 )
gap62; Append( slp, [ [ 29, 1, 35, 1, 27, 1 ] ] );
gap62; resultpos[8]:= Length( slp ) + 2;;
</pre>
<div class="p"><!----></div>
... p = ((a b)<sup>5</sup> t<sub>11</sub> (a b)<sup>8722;5</sup> t<sub>1</sub> (a b)<sup>5</sup>)<sup>8722;1</sup> (position 38)
and i = d<sup>p</sup> (position 41), ...
<div class="p"><!----></div>
<pre>
gap62; # 37: (a*b)^5*t11*(a*b)^-5*t1*(a*b)^5,
gap62; # 38: p = ((a*b)^5*t11*(a*b)^-5*t1*(a*b)^5)^-1
gap;
gap62; # 39: p^-1, 40: h = c^p, 41: i = d^p
gap62; Append( slp, [ [ 38, -1 ], [ 39, 1, 9, 1, 38, 1 ],
62; [ 39, 1, 6, 1, 38, 1 ] ] );
</pre>
<div class="p"><!----></div>
... j = [t<sub>5</sub><sup>i<sup>2</sup></sup>, t<sub>3</sub> t<sub>4</sub>] (position 45) and
k = [t<sub>5</sub><sup>i<sup>5</sup></sup>, t<sub>3</sub> t<sub>4</sub>] (position 48), ...
<div class="p"><!----></div>
<pre>
gap62; # 42: i^2, 43: t5^(i^2), 44: t3*t4
java.lang.StringIndexOutOfBoundsException: Range [8, 7) out of bounds for length 64
62; [ 31, 1, 32, 1 ] ] );
gap62; # 45: j = Comm( t5^( i^2 ), t3*t4 )
gap62; Append( slp, [ [ 43, -1, 44, -1, 43, 1, 44, 1 ] ] );
gap62; # 46: i^3, 47: t5^(i^5), 48: k = Comm( t5^(i^5), t3*t4 )
gap62; Append( slp, [ [ 41, 1, 42, 1 ], [ 46, -1, 43, 1, 46, 1 ],
#62 47-,44, -,47,1 44,1]])
</pre>
<div class="p"><!----></div>
... l = [t<sub>8</sub><sup>j k</sup>, t<sub>6</sub> t<sub>7</sub>] [t<sub>8</sub><sup>k j</sup>, t<sub>6</sub> t<sub>7</sub>] (position 57),
...
<div class="p"><!----></div>
<pre>
gap62; # 49: t6*t7, 50: (t6*t7)^-1, 51: j*k, 52: k*j, 53: t8^(j*k)
gap#;Append(slp 34 ,35, 1 ,[ ,- ] [ 1, , 1 ]java.lang.StringIndexOutOfBoundsException: Index 75 out of bounds for length 75
62; [ 48, 1, 45, 1 ], [ 51, -1, 36, 1, 51, 1 ] ] );
54 Commt^*) t6*)55 t8(*)
gap62; Append( slp, [ [ 53, -1, 50, 1, 53, 1, 49, 1 ] ] );
gap62; Append( slp, [ [ 52, -1, 36, 1, 52, 1 ] ] );
gap62; # 56: Comm( t8^(k*j), t6*t7 )
gap#;Append(slp, [ , 1 ,1 ,1 49, ]];
gap62; # 57: l = Comm( t8^(j*k), t6*t7 ) * Comm( t8^(k*j), t6*t7 )
gap62; Append( slp, [ [ 54, 1, 56, 1 ] ] );
</pre>
<div class="p"><!----></div>
... l<sub>3</sub> = [t<sub>8</sub><sup>(j k)<sup>4</sup></sup>, t<sub>6</sub> t<sub>7</sub>] (position 61),
l<sub>4</sub> = t<sub>8</sub><sup>(j k)<sup>3</sup> k j</sup> (position 62),
l<sub>5</sub> = (l l<sub>3</sub> l<sub>4</sub>)<sup>3</sup> l<sub>3</sub> l<sub>4</sub> (position 65), ...
<div class="p"><!----></div>
<pre>
gap62; # 58: (j*k)^3, 59: (j* class="APprompt">;/<pan"">until (x )=15mp -NrMovedPoints 5 108</>
gap62; Append( slp, [ [ 51, 3 ], [ 58, -1 ], [ 59, 1, 53, 1, 58, 1 ] ] );
gap62; # 61: l3 = Comm( t8^((j*k)^4), t6*t7 )
gap62; Append( slp, [ [ 60, -1, 50, 1, 60, 1, 49, 1 ] ] );
gap62; # 62: l4 = t8^((j*k)^3*k*j)
gap62; Append( slp, [ [ 52, -1, 59, 1, 36, 1, 58, 1, 52, 1 ] ] );
gap62; # 63: l3*l4, 64: l*l3*l4
gap62; Append( slp, [ [ 61, 1, 62, 1 ], [ 57, 1, 63, 1 ] ] );
gap62; # 65: l5:= ( l * l3 * l4 )^3 * l3 * l4;;
gap62; Append( slp, [ [ 64, 3, 63, 1 ] ] );
</pre>
<div class="p"><!----></div>
... m<sub>2</sub> = l<sub>4</sub><sup>l<sub>5</sub><sup>4</sup></sup> (position 67),
m<sub>3</sub> = m<sub>2</sub><sup>l<sub>5</sub></sup> (position 68),
t<sub>10</sub> = m<sub>3</sub> m<sub>2</sub> l<sub>4</sub> m<sub>2</sub> m<sub>3</sub> (span class="GAPprompt">></span> <span class="GAPinput"> c -> RatioOfNongenerationA ;<java.lang.StringIndexOutOfBoundsException: Index 142 out of bounds for length 142
t<sub>9</sub> = l<sub>4</sub> m<sub>2</sub> t<sub>10</sub> m<sub>2</sub> l<sub>4</sub> (position 70).
<iv class=p><!----></div>
<pre>
gap62; # 66: l5^4, 67: m2 = l4^(l5^4)
gap62; Append( slp, [ [ 65, 4 ], [ 66, -1, 62, 1, 66, 1 ] ] );
gap62; # 68: m3 = m2^l5
gap62; Append( slp, [ [ 65, -1, 67, 1, 65, 1 ] ] );
gap62; # 69: t10 = m3*m2*l4*m2*m3
gap62; Append( slp, [ [ 68, 1, 67, 1, 62, 1, 67, 1, 68, 1 ] ] );
gap62; resultpos[10]:= Length( slp ) + 2;;
gap62; # 70: t9 = l4*m2*t10*m2*l4
gap62; Append( slp, [ [ 62, 1, 67, 1, 69, 1, 67, 1, 62, 1 ] ] );
gap62; resultpos[9]:= Length( slp ) + 2;;
</pre>
<div class="p"><!----></div>
Finally, we specify the list of outputs,
and create the straight line program object.
<div class="p"><!----></div>
<pre>
gap62; Add( slp, List( resultpos, x -62; [ x, 1 ] ) );
gap62; slp:= StraightLineProgram( slp, 2 );
<straight line program62;
<pre>
<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>
<pre>
gap62; b_2:= AtlasGroup( "B", Characteristic, 2, Dimension, 4370 );;
gap62; b_3:= AtlasGroup( "B", Characteristic, 3, Dimension, 4371 );;
;=AtlasGroupB,java.lang.StringIndexOutOfBoundsException: Range [51, 50) out of bounds for length 74
gap62; gens_2:= GeneratorsOfGroup( b_2 );;
gap62; gens_3:= GeneratorsOfGroup( b_3 );;
gap62; gens_5:= GeneratorsOfGroup( b_5 );;
gap62; res_2:= ResultOfStraightLineProgram( slp, gens_2 );;
gap62; ForAll( relsslps
62; prg -62; IsOne( ResultOfStraightLineProgram( prg, res_2 ) ) );
true
gap62; res_3:= ResultOfStraightLineProgram( slp, gens_3 );;
gap62; ForAll( relsslps,
62; prg -62; IsOne( ResultOfStraightLineProgram( prg, res_3 ) ) );
true
gap62; res_5:= ResultOfStraightLineProgram( slp, gens_5 );;
gap62; ForAll( relsslps,
62; prg -62; IsOne( ResultOfStraightLineProgram( prg, res_5 ) ) );
true
</pre>
<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 a8242;, b8242;
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>
gap62; revslp:= [ Concatenation( List( [ 1 .. 8 ], i -'color: green'>62; [ i, 1 ] ) ),
62; Concatenation( List( [ 5, 9, 10, 11 ], i -62; [ i, 1 ] ) ) ];;
</pre>
<div class="p"><!----></div>
... and then a8242; = (r<sup>7</sup> s)<sup>15</sup> (position 15)
and b8242; = (t<sub>1</sub> t<sub>2</sub>)<sup>(sr)<sup>1</sup>0</sup> (position 20).
<div class="p"><!----></div>
<pre>
gap62; Append( revslp, [ [ 12, 7, 13, 1 ], [ 14, 15 ], [ 13, 1, 12, 1 ],
62; [ 16, 10 ], [ 17, -1 ], [ 1, 1, 2, 1 ],
62; [ 18, 1, 19, 1, 17, 1 ] ] );
</pre>
<div class="p"><!----></div>
Again, we specify the outputs and create the java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 26
<div class="p"><!----></div>
<pre>
gap62; Add( revslp, List( [ 15, 20 ], x -62; [ x, 1 ] ) );
gap62; revslp:= StraightLineProgram( revslp, 11 );
<straight line program62;
</pre>
<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 a8242;, b8242; of matrices that is simultaneously conjugate to the
original matrices a, b.
Once this is established, we know that the group 9001;a, b tyle='color: green'>9002;
is equal to the group the 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>
<pre>
gap62; a:= gens_2[1];; b:= gens_2[2];;
gap&62;w:= One a)+ b*a + a*b + b;;
gap62; nsp_2:= NullspaceMat( w );; Length( nsp_2 );
1
gap62; a:= gens_3[1];; b:= gens_3[2];;
gap62; w:= One( a ) + b*a + a*b + b;;
gap62; nsp_3:= NullspaceMat( w );; Length( nsp_3 );
1
gap62; a:= gens_5[1];; b:= gens_5[2];;
gap62; w:= One( a ) + b*a + a*b + b;;
gap62; nsp_5:= NullspaceMat( w );; Length( nsp_5 );
1
</pre>
<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>
gap62; StdBasis:= function( F, mats, seed )
62; local n, b, mb, v, m, new;
62;
62; n:= Length( mats[1] );
62; b:= [ seed ];
62; mb:= MutableBasis( F, b );
62; for v in b do
62; for m in mats do
62; new:= v * m;
62; if not IsContainedInSpan( mb, new ) then
62; Add( b, new );
&62; ifLength(b nthen
62; break;
62; fi;
62; CloseMutableBasis( mb, new );
62; fi;
62; od;
62; if Length( b ) = n then
62; break;
62; fi;
62; od;
&62 b;
62; 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( ) areequal to thematrices a&8242,b&8242 w.&bsp;.nbsp;.
standard basis and a generating vector of the nullspace of w(a8242;, b8242;).
<div class="p"><!----></div>
We verify this in characteristic 2, ...
<div class="p"><!----></div>
<pre>
gap62stdbas_2:=StdBasis(2) nsp_2 )java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
gap62; inv:= stdbas_2^-1;;
gap62; stdgens_2:= List( gens_2, m -62; stdbas_2 * m *, 97 100106112 ]]
gap62; newgens_2:= ResultOfStraightLineProgram( revslp, res_2 );;
gap62; aa:= newgens_2[1];; bb:= newgens_2[2];;
gap#62; := aa) + aa+*bb ;;
gap62; newnsp_2:= NullspaceMat( neww );; Length( newnsp_2 );
1
gap62; newstdbas_2:= StdBasis( GF(2), newgens_2, newnsp_2[1] );;
gap62; inv:= newstdbas_2 ,50 ,57 , ,,, ,97 ,106
gap62; newstdgens_2:= List( newgens_2, m -62; newstdbas_2 * m * inv );;
gap62; stdgens_2 = newstdgens_2;
true
</pre>
<div class="p"><!----></div>
... in characteristic 3, ...
<div class="p"><!----></div>
<pre>
gap62; stdbas_3:= StdBasis( GF(3), gens_3, nsp_3[ =java.lang.StringIndexOutOfBoundsException: Range [23, 22) out of bounds for length 86
gap62; inv:= stdbas_3^-1;;
gap62; stdgens_3:= List( gens_3, m -62; stdbas_3 * m * inv );;
gap62; gap> newgens_3
gap62; aa:= newgens_3[1];; bb:= newgens_3[2];;
gap62; neww:= One( aa ) + bb * aa + aa * bb + bb;;
gap62; newnsp_3:= NullspaceMat( neww );; Length( newnsp_3 );
1
gap62; newstdbas_3:= StdBasis( GF(3), newgens_3, newnsp_3[1] );;
gap62; inv:= newstdbas_3^-1;;
gap62; newstdgens_3:= List( newgens_3, m -62; newstdbas_3 * m * inv );;
# stdgens_3 =;
true
</pre>
<div class="p"><!----></div>
... and in characteristic 5.
iv""<!----></div>
<pre>
gap62; stdbas_5:= StdBasis( GF(5), gens_5, nsp_5[1] );;
gap62; inv:= stdbas_5^-1;;
gap2s:=List(, &62;stdbas_5 * inv;
gap62; newgens_5:= ResultOfStraightLineProgram( revslp, res_5 );;
gap62; aa:= newgens_5[1];; bb:= newgens_5[2];;
gap62; neww:= One( aa ) + bb * aa + aa * bb + bb;;
gap62;
1
gap62; newstdbas_5:= StdBasis( GF(5), newgens_5, newnsp_5[1] );;
gap62; inv:= newstdbas_5^-1;;
gap62; newstdgens_5:= List( newgens_5, m -62; newstdbas_5 * m * inv );;
gap62; stdgens_5 = newstdgens_5;
true
</pre>
<div class="p"><!----></div>
<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
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=">
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],
exceptthatlabels containing<mtwo/m 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</t-
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>
gap62; IdentifyClassName:= function( data2, data3, data5, slp, order )
62; local data, mats, elm, cand, nams, trace, pos, one, rank;
62;
62; data:= [ , data2, data3,, data5 ];
62; mats:= [];
62;
62; elm:= function( p )
62; if not IsBound( mats[p] ) then
62; if slp = fail then
62; mats[p]:= data[p];
62; else
62; mats[p]:= ResultOfStraightLineProgram( slp, data[p] );
#; fi
62; fi;
62; return mats[p];
62; end;
62;
62; if order = fail then
62; order:= Order( elm(2) );
62; fi;
62;
62; # The element order suffices in certain cases.
62; > if
62; # There are two Galois conjugate classes of elements of this order.
62; return Concatenation( String( order ), "AB" );
62; elif order in [ 1, 7, 11, 13, 17, 19, 21, 25, 27, 33, 35, 38, 39,
62; 44, 47, 52java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
62; # There is exactly one conjugacy class of elements of this order.
62; return Concatenation( String( order ), " he nextelements to testedare theclasses class=code"6/code>(entralizer order< class="impleMath">162</span>), in one of <code class="code">9G</code>–<code class="code">9J</code> (centralizer order <span class="SimpleMath">729</span>), in one of <code class="code">9K</code>–<code class="code">9N</code> (centralizer order <span class="SimpleMath">81</span>), in one of <code class="code">12A</code>–<code class="code">12C</code> (centralizer order <span class="SimpleMath">1728</span>), in one of <code class="code">12D</code>–<code class="code">12I</code> (centralizer order <span class="SimpleMath">432</span>)<
62; fi;
62;
62; if order in [ 3, 5, 9, 15 ] then
62; # The trace in the 2-modular representation suffices.
62; cand:= [ [3,1], [3,0], [5,0], [5,1], [9,0], [9,1], [15,0], [15,1] ];
#62; =[","" 5","B, 9" 9","A,15"]
62; trace:= Int( TraceMat( elm(2) ) );
62; return nams[ Position( cand, [ order, trace ] ) ];
62; elif order mod 4 = 2 then
62; # Compute the rank of 1 + x.
62; cand:= [ [ 2, 1860 ], [ 2, 2048 ], [ 2, 2158 ], [ 2, 2168 ],
6, 3534 ],
62; [ 6, 3606 ], [ 6, 3604 ], [ 6, 3596 ], [ 6, 3610 ],
62; [ 6, 3636 ], [ 6, 3638 ], [ 6, 3634 ],
62; [ 10, 3860 ], [ 10, 3896 ], [ 10, 3918 ], [ 10, 3908 ],
62; [ 10, 3920 ], [ 10, 3932 ],
62; [ 14, 3996 ], [ 14, 4008 ], [ 14, 4048 ], [ 14,4034 ],
62; [ 14, 4052 ],
62; [ 18, 4088 ], [ 18, 4090 ], [ 18, 4110 ], [ 18, 4124 ],
62; [ 18, 4128 ], [ 18, 4122 ],
62; [ 22, 4140 ], [ 22, 4158 ],
26, 4198 ] [26,4176 ],
62; [ 30, 4190 ], [ 30, 4212 ], [ 30, 4206 ], [ 30, 4214 ],
62; [ 30, 4224 ], [ 30, 4216 ],
62; [ 34, 4238 ], [ 34, 4220 ],
#; [42, , , ;
62; nams:= [ "2A", "2B", "2C", "2D",
62; "6A", "6B", "6C", "6D", "6E", "6F",
62; "6G", "6H", "6I", "6J", "6K",
62; "10A", "10B", "10C", "10D", < =GAPprompt">></span> =GAPinput" Add elementstotest,s;span
62; "14A", "14B", "14C", "14D", "14E",
62; "18A", "18B", "18C", "18D", "18E", "18F",
62; "22A", "22B",
62; "26A", "26B",
nclass="APprompt>&;/span>< => od;/>
62; "34A", "34BC",
62; "42AB", "42C" ];
62; one:= elm(2)^0;
62; rank:= RankMat( elm(2) + one );
&62 pos= Position , [order rank ;
62; if nams[ pos ] = "30AB" then
62; rank:= RankMat( elm(2)^5 + one );
62; if rank = 3510 then return "30A";
62; elif rank = 3486 then return "30B";
62; else Error( "wrong rank" );
62; fi;
62; elif nams[ pos ] = "42AB" then
&( elm()3+one );
62; if rank = 3996 then return "42A";
62; elif rank = 4008 then return "42B";
62; else Error( "wrong rank" );
62; fi;
62; else
62; return nams[ pos ];
fi;
62; elif order in [ 36, 60 ] then
62; cand:= [ [36,4226],[36,4238],[36,4248],[60,4280],[60,4286],[60,4296] ];
62; nams:= [ "36A", "36B", "36C", "60A", "60B", "60C" ];
62; one:= elm(2)^0;
62; rank:= RankMat( elm(2) + one );
62; return nams[ Position( cand, [ order, rank ] ) ];
62; elif order = 28 then
62; one:= elm(2)^0;
62; rank:= RankMat( elm(2) + one );
#;traceInt(TraceMat^));
62; if rank = 4188 then # 28A or 28C
62; if trace = 0 then return "28A";
62; elif trace = 1 then return "28C";
62; else Error( "wrong trace" );
62; fi;
62; elif rank = 4200 then # 28B or 28D
#; iftrace = 1 then return "28B";
62; elif trace = 0 then return "28D";
62; else Error( "wrong trace" );
62; fi;
62; elif rank = 4210 then return "28E";
62; else Error( "wrong rank" );
&62 fijava.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
62; elif order = 32 then
62; trace:= Int( TraceMat( elm(3)^2 ) );
62; if trace = 2 then return "32AB";
62; elif trace = 0 then return "32CD";
62; else Error( "wrong trace" );
62; fi;
62; elif order = 40 then
62; one:= elm(2)^0;
62; rank:= RankMat( elm(2) + one );
62; if rank = 4242 then # 40A or 40B 0r 40C
62; trace:= Int( TraceMat( elm(3) ) );
62; if trace = 0 then return "40A";
62; elif trace = 1 then return "40B";
62; else return "40C";
62; fi;
62; elif rank = 4250 then return "40D";
62; elif rank = 4258 then return "40E";
62; else Error( "wrong rank" );
62; fi;
62; elif order = 48 then
62; trace:= Int( TraceMat( elm(3) ) );
62; if trace = 0 then return "48A";
62; elif trace = 1 then return "48B";
62; else Error( "wrong <p>The next elements to be tested are classescode=""></><code "6<>(java.lang.StringIndexOutOfBoundsException: Range [131, 130) out of bounds for length 178
62; fi;
62; elif order in [ 4, 8 ] then
62; cand:= [ [4,3114],[4
62; [4,3264],[8,3774],[8,3738],[8,3778],[8,3780],[8,3810],
62; [8,3786],[8,3812],[8,3818] ];
62; nams:= [ "4A-B", "4C-D", "4E", "4F", "4G", "4H-J", "4I",
62; "8A", "8B-C-E", "8D", "8F-H", "8G", "8I-L", "8J", "8K-M-N" ];
62; one:= elm(2)^0;
62; rank:= RankMat( elm(2) + one );
2; = Position , [, rank];
62; if not '-' in nams[ pos ] then
62; return nams[ pos ];
62; elif order = 4 then
62; trace:= Int( TraceMat( elm(3) ) );
62; if trace = 0 then
62; if nams[ pos ] = "4A-B" then return "4B";
2; elif nams[ pos ]="C-"thenreturn "D"java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
62; else return "4H";
62; fi;
62; elif trace = 1 then
62; if nams[ pos ] = "4A-B" then return "4A";
&62; elif nams[pos ]=4C"then return "C;
62; else return "4J";
62; fi;
62; else
62; Error( "wrong trace" );
62; fi;
62; elif order = 8 class="APprompt">></span> <span class="GAPinput"> and cents[ PowerMap( t, 3 )[i] ] = 26127360 ) };</span>
62; if nams[ pos ] = "8B-C-E" then
62; trace:= Int( TraceMat( elm(3) ) );
62; if trace = 1 then return "8B";
62; elif trace = 0 then return "8C";
62; else return "8E";
62; fi;
&62; elif nams[[pos ]= "F-"then
62; rank:= RankMat( ( elm(2) + one )^3 );
62; if rank = 2619 then return "8F";
62; elif rank = 2620 then return "8H";
62; else Error( "wrong rank" );
62; fi;
62; elif nams[ pos ] = "8I-L" then
62; rank:= RankMat( ( elm(2) + one )^2 );
62; if rank = 3202 then return "8I";
62; elif rank = 3204 then "L;
62; else Error( "wrong rank" );
62; fi;
62; else # 8K-M-N
62; rank:= RankMat( ( elm(2) + one )^3 );
62; if rank = 2714 then # 8K-M
62;=Int(elm3))
62; if trace = 1 then return "8K";
62; elif trace = 2 then return "8M";
62; else Error( "wrong trace" );
62; fi;
62; elif rank = 2717 then return "8N";
&;else(" ")
62; fi;
62; fi;
62; fi;
62; elif order in [ 12, 24 ] then
62; cand:=span=""&/><class> java.lang.StringIndexOutOfBoundsException: Range [86, 85) out of bounds for length 116
62; [12,3986],[12,3978],[12,3966],[12,4000],[12,3982],[12,3988],
62; [12,4002],[12,4004],[24,4152],[24,4164],[24,4170],[24,4182],
62; [24,4176],[24,4178],[24,4174],[24,4186] ];
62; nams:= [ "12A-C-D", "12B", "12E", "12F", "12G-H", "12I", "12J",
&;"12K-M,"L" "2N, 12""P "2R-,"Sjava.lang.StringIndexOutOfBoundsException: Index 80 out of bounds for length 80
62; "24A-B-C-D", "24E-G", "24F", "24H", "24I-M", "24J", "24K",
62; "24L-N" ];
62; one:= elm(2)^0;
62; rank:= RankMat( elm(2) + one );
62; pos:= Position( cand, [ order, rank ] );
62; if not '-' in nams[ pos ] then
62; return nams[ pos ];
62; elif order = 12 then
62; if nams[ pos ] = "12A-C-D" then
62; <> betestedare in the code=">X<code>–code class=">A1code (centralizer order <span class=SimpleMath>648<span>)/p>
62; if trace = 3 then return "12A";
62; elif trace = 4 then return "12C";
62; elif trace = 1 then return "12D";
62; else Error( "wrong trace" );
62; fi;
62; else
62; trace:= Int( TraceMat( elm(3) ) );
62; if trace = 0 then
62; if nams[ pos ] = "12G-H" then return "12H";
62; elif nams[ pos ] = "12K-M" then return "12K";
62; else return "12Q"; # 12Q-R-T
62; fi;
62; elif trace = 1 then
62; if nams[ pos ] = "12G-H" then return "12G";
62; elif nams[ pos ] = "12K-M" then return "12M";
62; else return "12R"; # 12Q-R-T
62; fi;
62; elif nams[ pos ] = "12Q-R-T" then
62; return "12T";
62; else
62; Error( "wrong trace" );
62; fi;
62; fi;
62; elif order = 24 then
62; if nams[ pos ] = "24I-M" then
62; rank:= RankMat( elm(2)^2 + one );
62; if rank = 3986 then return "24I";
62; elif rank = 3982 then return "24M";
62; else Error( "wrong rank" );
62; fi;
62; elif nams[ pos ] = "24E-G" then
&62; rank
62; if rank = 3774 then return "24E";
62; elif rank = 3778 then return "24G";
62; else Error( "wrong rank" );
62; fi;
62; elif nams[ pos ] = "24L-N" then
62; trace:= Int( TraceMat( elm(3) ) );
&62; trace = 1 then return "24L";
62; elif trace = 2 then return "24N";
62; else Error( "wrong trace" );
62; fi;
62; else # 24A-B-C-D"
62; trace:= Int( TraceMat( elm(5) ) );
62; if trace = 3 then return "24A";
62; elif trace = 0 then return "24B";
62; elif trace = 2 then return "24C";
62; elif trace = 1 then return "24D";
62; else Error( "wrong trace" );
62; fi;
62; fi;
62; fi;
62; elif order in [ 16, 20 ] then
#62; cand: [[16, 4072 ] [ 16,4074], [ 16 4094 ]java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67
62; [ 20, 4114 ], [ 20, 4128 ], [ 20, 4132 ], [ 20, 4148 ],
62; [ 20, 4144 ], [ 20, 4138 ], [ 20, 4150 ] ];
62; nams:= [ "16A-B", "16C-D-E-F", "16G-H",
62; "20A-B-C-D", "20E", "20F", "20G", "20H", "20I", "20J" ];
62; one:= elm(2)^0;
62; rank:= RankMat( elm(2) + one );
62; pos:= Position( cand, [ order, rank ] );
62; if not '-' in nams[ pos ] then
62; return nams[ pos ];
62; elif order = 20 then
&<pan class"APprompt">gap><span spanclass"APinput>epeat s:= Random( g );</span>
62; if rank = 3908 then return "20B";
62; elif rank <62; 3896 then Error( "wrong rank" );
62; else
62; trace:= Int( TraceMat( elm(3) ) );
62; if trace = 2 then return "20A";
62; elif trace = 0 then return "20C";
62; elif trace = 1 then return "20D";
62; else Error( "wrong trace" );
62; fi;
62; fi;
62; else # order = 16
62; if nams[ pos ] = "16A-B" then
trace:= (TraceMat( elm(3 )
62; if trace = 0 then return "16A";
62; elif trace = 1 then return "16B";
62; else Error( "wrong trace" );
62; fi;
62; elif nams[ pos ] = "16G-H" then
62; trace:= Int( TraceMat( elm(3)^2 ) );
62; if trace = 1 then return "16G";
62; elif trace = 2 then return "6";
62; else Error( "wrong trace" );
62; fi;
62; else # 16C-D-E-F
62; trace:= Int( TraceMat( elm(3) ) );
#; if trace = 0 then # cannot distinguish and 16.
62; return "16DF";
62; elif trace = 2 then # 16C-E
62; one:= elm(2)^0;
62; rank:= RankMat( elm(2)^2 + one );
62; if rank = 3780 then return "16C";
62; &t;/ span"> ,s )<>
62; else Error( "wrong rank" );
62; fi;
62; else
62; Error( "wrong trace" );
62; fi;
62; fi;
62; fi;
62; else Error( "wrong element order" );
62; fi;
62; end;;
</pre>
<div class="p"><!----></div>
Elements of <font size="+0
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>.
< java.lang.StringIndexOutOfBoundsException: Range [11, 10) out of bounds for length 28
<pre>
gap62; cycprg:= AtlasProgram( "B", "cyclic" );;
gap62; cycprg.identifier;
[ "B", "BG1-cycW1", 1 ]
gap62; cycprg.outputs;
[ "12A", "12H", "12I", "12L", "12P", "12S", "12T", "16E", "16F", "16G",
"16H", "18A", "18B", "18D", "18F", "20B", "20C", "20H", "20I", "20J",
"24A", "24B", "24C", "24D", "24E", "24F", "24H", "24I", "24J", "24K",
"24L", "24M", "24N", "25A", "26B", "27A", "28A", "28C", "28D", "28E",
"30A", "30B", "30C", "30E", "30java.lang.StringIndexOutOfBoundsException: Range [0, 38) out of bounds for length 26
"34BC", "36A", "36B", "36C", "38A", "39A", "40A", "40B", "40C", "40D",
"40E", "42A", "42B", "42C", "44A", "46AB", "47AB", "48A", "48B", "52A",
"A",56AB" "60A,"B", "60C, "66A, 70A java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
</pre>
<div class="p"><!----></div>
The remaining representatives are obtained as suitable powers of them.
Thean class="APprompt"gt;<span span="APinput> -&t [i] cents[PowerMap( t 2)i ] 13824 ;<span>
see [<a href="#BMverify" name="CITEBMverify">BMW20</a>,Table 2].
<div class="p"><!----></div>
<pre>
gap62; DefinitionsViaPowerMaps:= [
#62 [ "A"2 "A" ] [ 66" , 33"],["60A" 2, 30"],
62; [ "60C", 2, "30F" ], [ "56AB", 2, "28B" ], [ "52A", 2, "26A" ],
62; [ "48B", 2, "24G" ], [ "46AB", 2, "23AB" ], [ "44A", 2, "22B" ],
62; [ "66A", 3, "22A" ], [ "42C", 2, "21A" ], [ "40E", 2, "20G" ],
62; [ "40D", 2, "20F" ], [ "60B", 3, "20E" ], [ "60A", 3, "20A" ],
62; [ "40C", 2, "20D" ], [ "38A", 2, "19A" ], [ "36C", 2, "18E" ],
62; [ "36B", 2, "18C" ], [ "34A", 2, "17A" ], [ "32CD", 2, "16DF" ],
62; [ "32AB", 2, "16C" ], [ "48B", 3, "16B" ], [ "48A", 3, "16A" ],
62; [ "30F", 2, "15B" ], [ "30A", 2, "15A" ], [ "28E", 2, "14E" ],
62; [ "28A", 2, "14D" ], [ "42A", 3, "14A" ], [ "42B", 3, "14B" ],
62; [ "42C", 3, "14C" ], [ "26A", 2, "13A" ], [ "24N", 2, "12R" ],
62; [ "24M", 2, "12O" ], [ "24L", 2, "12Q" ], [ "24K", 2, "12M" ],
62; [ "24J", 2, "12J" ], [ "24H", 2, "12F" ], [ "24G", 2, "12G" ],
62; [ "24D", 2, "12D" ] n class="gapg;/span>< class">([ ),/
62; [ "36A", 3, "12B" ], [ "60A", 5, "12C" ], [ "60B", 5, "12E" ],
62; [ "22B", 2, "11A" ], [ "20J", 2, "10F" ], [ "20I", 2, "10D" ],
62; [ 20"2"C ,[ 20" , 10"] ["A,3 10"],
62; [ "30E", 3, "10E" ], [ "18F", 2, "9B" ], [ "18E", 2, "9A" ],
62; [ "16H", 2,["B"java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 8
62; [ "16E", 2, "8D" ], [ "24J", 3, "8J" ], [ "24M", 3,span=G"&t;/ java.lang.StringIndexOutOfBoundsException: Range [45, 44) out of bounds for length 92
62; [ "24I", 3, "8G" ], [ "24K", 3, "8F" ], [ "24C", 3, "8E" ],
62 "24"3 8",[A, ,"B ,[24" ,java.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 73
62; [ "24N", 3, "8N" ], [ "40D", 5, "8L" ], [ "14D", 2, "7A" ],
62; [ "12T", 2, "6K" ], [ "12S", 2, "6J" ], [ "12R", 2, "6I" ],
62 [ "P, , 6H"] ["2",2,"G"], [12" 2,"6" ]
62; [ "18A", 3, "6D" ], [ "30B", 5, "6A" ], [ "30A", 5, "6B" ],
62; [ "30E", 5, "6E" ], [ "30C", 5, "6F" ], [ "12C", 3, "4A" ],
62; [ "10F", 2, "5B" ], [ "10B", 2, "5A" ], [ "8N", 2, "4J" ],
62; [ "8M", 2, "4H" ], [ "8L", 2, "4G" ], [ "8J", 2, "4E" ],
62; [ "8I", 2, "4F" ], [ "8H", 2, "4C" ], [ "8E", 2, "4B" ],
62; [ "12E", 3, "4D" ], [ "12T", 3, "4I" ], [ "6K", 2, "3B" ],
62; [ "6A", 2, "3A" ], [ "4J", 2, "2D" ], [ "4I", 2, "2C" ],
62; [ "4A", 2, "2B" ], [ "6A", 3, "2A" ], [ "2B", 2, "1A" ],
62; ];;
</pre>
<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>
gap62; SLPForClassName:= function( nam, cycslp
62; local pos, rule;
62;
62; pos:= Position( outputnames, nam );
62; if pos <62; fail then
62; return RestrictOutputsOfSLP( cycslp.program, pos );
62; fi;
62;
62; rule:= First( DefinitionsViaPowerMaps, x -62; x[3] = nam );
62; if rule = fail then
62; rror( "'nam' is not an admiss. name for a cyclic subgroup of B" );
62; fi;
62;
62; return CompositionOfStraightLinePrograms(
62; StraightLineProgram( [ [ 1, rule[2] ] ], 1 ),
62; SLPForClassName( rule[1], cycslp, outputnames ) );
62; end;;
</pre>
<div class="p"><!----></div>
Let us verify that <tt>IdentifyClassName</tt> computes the claimed labels.
<div class="p"><!----></div>
<pre>
gap62; outputnames:= List( cycprg.outputs,
&&62;x-2 ReplacedString( x, "-, "" ) ;;
gap62; outputnames:= List( outputnames,
62; x -62; ReplacedString( x, "16F", "16DF" ) );;
gap62; labels:= Union( outputnames,
62; List( DefinitionsViaPowerMaps, x -62; x[3] ) );;
gap62; for l in labels do
62; slp:= SLPForClassName( l, cycprg, outputnames );
62; id:= IdentifyClassName( gens_2, gens_3, gens_5, slp, fail );
62; if id <62; l then
62; Print( "#E problem with identification: ", id, " vs. ", l, "\n" );
62; fi;
62; od;
</pre>
<div class="p"><!----></div>
<div class="p"><!----></div>
Asweget outputs,theidentification 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>
gap62; SortParallel( List( labels, x -62; Int( Filtered( x, IsDigitChar ) ) ),
62; labels );
gap62; powerinfo:= [];;
gap62; for l in labels do
62; slp:= SLPForClassName( l, cycprg, outputnames );
62; ord:= Int( Filtered( l, IsDigitChar ) );
62; pow:= [];
62; if not ( IsPrimeInt( ord ) or ord = 1 ) then
62; for p in Set( Factors( ord ) ) do
62; powerslp:= CompositionOfStraightLinePrograms(
62; StraightLineProgram( [ [ 1,p ]],1) slp ;
62; id:= IdentifyClassName( gens_2, gens_3, gens_5, powerslp,
62; ord / p );
62; Add( pow, [ p, id ] );
62; od;
62; fi;
62; Add( powerinfo, [ l, pow ] );
62; 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<pan "GAPprompt"gap;<span<panclassGAPinput"repeat s: g ;/>
We know from [<a href="#Str76b" name="CITEStr76b">Str76</a>] that <font size="+0">B</font> has exactly four classes of involutions,
hose normalizers in <font size="+0">B<font> have thefollowingproperties
<div class="p"><!----></div>
<ul>
<> 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
H8242; by a field automorphism of order two, see [<a href="#Str76b" name="CITEStr76b">Str76</a>,p. 505].
impliesthatH a/> of&8242;
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 <span class""gap>/ <class""nongen gt;194/455;/>
</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.& n class="GAPprompt">></span> <span class="GAPinput"> until Order( s ) = 15 and NrMovedPoints( s ) = 1080 - 3;</span>
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< F<sub>4</sub>(2), F<sub>4</sub>(2).2, 2<supGAPinput"nongen: ( g, 2, s ;<span>
<div class="p"><!----></div>
</li>
<li>
The normalizer of a <tt>2D</tt> involution
has order 11 689 182 <span class""gapgt</pan span=GAPinput"nongen&;194/455;<span>
normalizer in <font size="+0">B</font> of an elementary abelian group of order 2<sup>8</sup>.
The character table of thetrue
a subgroup of <font size="+0">B</font>, see Appendix <a href="#2Dnormalizer">11</a>.
table hasaunique class with centralizerorder 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 8773; 2.<sup>2</sup>E<sub>6</sub>(2).2 be a <tt>2A</tt> centralizer in <font size="+0">B</font>.
java.lang.StringIndexOutOfBoundsException: Index 75 out of bounds for length 41
in the
<div class="p"><!----></div>
<pre>
gap62; h:= CharacterTable( "2.2E6(2).2" );;
gap62; invpos:= Positions( OrdersClassRepresentatives( h ), 2 );
[ 2, 3, 4, 5, 6, 7, 175, 176, 177, 178 ]
gap62; ClassNames( h ){ invpos };
[ "2a", "2b", "2c", "2d", "2e", "2f", "2g", "2h", "2i", "2j" ]
gap62; AtlasClassNames( h ){ invpos };
[ "1A_1", "2A_0", "2A_1", "2B_0", "2B_1", "2C_0", "2D_0", "2D_1", "2E_0",
"2E_1" ]
</pre>
<div <span class"GAPprompt"&/ " = )<>
(The subscripts 0 and 1 that appear above
are denoted by signs + and 8722; in [<a href="#BMverify" name="CITEBMverify">BMW20</a>].)
<div class="p"><!----></div>
<div class="p"><!----></div>
Let us try to compute the necessary <span class="GAPprompt">></span> <span class">iftest lt; java.lang.StringIndexOutOfBoundsException: Range [86, 85) out of bounds for length 97
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 <span class""&<java.lang.StringIndexOutOfBoundsException: Range [35, 34) out of bounds for length 72
H/Z(H).
assumethe of 5then
we can compute the possible degrees of the irreducible constituents
combinatorially, as follows.
<div class="p"><!----></div>
<pre>
gap62; f:= CharacterTable( "2E6(2).2" );;
gap62; index1:= 3968055;;
gap62; constit<p>We get no error message,so statement () is true</p>
gap62; degrees:= Set( constit, x ->62; x[1] );
[ 1, 1938, 48620, 554268, 815100, 1322685, 1828332, 2089164, 2909907, 2956096
]
gap62; lincom:= Filtered( UnorderedTuples( degrees, 5 ),
62; x -62; Sum( x ) = index1 );
[ 1,1938,48620,1828332, 2089164 ]]
</pre>
<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>
gap62; degrees:= lincom[1];
[ 1, 1938, 48620, 1828332, 2089164 ]
gap62; constit:= List( degrees, d -62; Filtered( constit, x -62; x[1] = d ) );;
gap62; cand1:= List( Cartesian( constit ), Sum );;
gap62; cand1:= Filtered( cand1, x -62; ForAll( x, y -62; y 62;= 0 ) );;
gap62; List( ConstituentsOfCharacter( cand1[1] ),
62; x -62; 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).
< java.lang.StringIndexOutOfBoundsException: Range [12, 10) out of bounds for length 28
<pre>
gap62; PermComb( f, rec( degree:= index1 ) ) = cand1;
true
</pre>
<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>
gap62; u:= CharacterTable( "F4(2)" );;
gap62; ufush:= PossibleClassFusions( u, h );;
62; map -62; InducedClassFunctionsByFusionMap( u, h,
62; [ TrivialCharacter( u ) ], map )[1] );;
gap62; Length( ind );
1
gap62; const:= ConstituentsOfCharacter( ind[1] );;
gap62; Sum( const ) = ind[1];
true
gap62; sub:= List( Cartesian( List( const, x -62; [ Zero( x ), x ] ) ), Sum );;
gap#62 cand2:= Filtered sub,
62; x -62; x[1] = ind[1][1] / 4 and Minimum( x ) 62;= 0 );;
gap62; Length( cand2 );
1
gap62; List( ConstituentsOfCharacter( cand2[1] ),
62; x -62; Position( Irr( h ), x ) );
[ 1, 5, 17, 24 ]
</
<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
thederivedsubgroupof H by 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>
<pre>
gap62; s:= CharacterTable( "Fi22.2" );;
gap62; sfush:= PossibleClassFusions( s, h );;
gap62; Length( sfush );
2
gap62; Positions( OrdersClassRepresentatives( s ), 2 );
[ 2, 3, 4, 60, 61, 62 ]
gap62; List( sfush, x -62; x[60] );
[ 175, 176 ]
gap62; cand3:= InducedClassFunctionsByFusionMap( s, h,
62; [ TrivialCharacter( s ) ], sfush[1] );;
gap62; SortedList( List( ConstituentsOfCharacter( cand3[1] ),
62; x -62; Position( Irr( h ), x ) ) );
[ 1, 3, 5, 13, 17, 28, 49, 76, 190, 192, 196, 202, 210, 217 ]
</pre>
<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> 8773; 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 p>Inorder to showthat <pan class="SimpleMath">U_4(2)</span> type subgroup of <span class="SimpleMath">U^'</span>to in span"java.lang.StringIndexOutOfBoundsException: Range [174, 173) out of bounds for length 685
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>
<pre>
gap62; h:= CharacterTable( "2.2E6(2).2" );;
gap62; u:= CharacterTable( "U4(3)" );;
gap62; Positions( OrdersClassRepresentatives( h ), 3 );
[ 8, 10, 12 ]
gap62; ufush:= PossibleClassFusions( u, h );;
gap62; 3pos:= Positions( OrdersClassRepresentatives( u ), 3 );
[ 3, 4, 5, 6 ]
gap62; Set( ufush, x -62; x{ 3pos } );
[ [ 12, 8, 10, 10 ], [ 12, 10, 8, 10 ] ]
gap62; u:= CharacterTable( "2.U4(3)" );;
gap62; ufush:= PossibleClassFusions( u, h );;
gap62; 3pos:= Positions( OrdersClassRepresentatives( u ), 3 );
[ 5, 7, 9, 11 ]
gap62; Set( ufush, x -62; x{ 3pos } );
0 ]
</pre>
<div class="p"><!----></div>
The <tt>3A</tt> elements in U<sub>4</sub>(3) have centralizer order 2<sup>3</sup> 183;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> >183;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 -
the class <tt>3A</tt> is 8722;7.
<div class="p"><!----></div>
<pre>
gap62; u:= CharacterTable( "U4(3)" ) mod 2;;
gap62; phi:= Filtered( Irr<pan class="GAPprompt">gap></span> <span class="GAPinput">GetFusionMap( 2u42, u42 )[4];</span>
gap62; Display( u, rec( chars:= phi, powermap:= false ) );
U4(3)mod2
2 7 3 2 2 . . . . . . . .
3 6 6 5 5 4 . . . 3 3 3 3
5 1 . . . . 1 . . . . . .
7 1 . . . . . 1 1 . . . .
1a 3a 3b 3c 3d 5a 7a 7b 9a 9b 9c 9d
Y.1 20 -7 2 2 2 . -1 -1 -1 -1 -1 -1
</pre>
<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
java.lang.StringIndexOutOfBoundsException: Range [61, 7) out of bounds for length 72
which means that 124;C<sub>H<sub>5</sub></sub>(<tt>3A</tt>)='color: green'>124; = 2<sup>8</sup> 183;3<sup>6</sup>.
<div class="p"><!----></div>
The permutation character of the action of <font size="+0">B</font> on the cosets of <span class="GAPprompt">gap></span> <span class="GAPinput">PositionsProperty( Sizes ), x-&tx= )/>
has the value 1 620 on the class <tt>3C</tt> of H.
<div class="p"><!----></div>
<pre>
gap62; 3pos:= Positions( OrdersClassRepresentatives( f ), 3 );;
gap62; val3C:= 1 + cand1[1][ 3pos[3] ];;
java.lang.StringIndexOutOfBoundsException: Range [8, 7) out of bounds for length 69
gap62; val3C:= val3C + cand2[1][ 3pos[3] ] + cand3[1][ 3pos[3] ];;
gap62; val3C:= val3C + SizesCentralizers( h )[ 3pos[3] ] / ( 2^8 * 3^6 );
1620
</pre>
<div class="p"><!----></div>
Thus we have 124Csubfont ="+"><<sub(tt3<tt)#124 =2<><sup183;<13<sup &pan style='color: green'>1835java.lang.StringIndexOutOfBoundsException: Index 130 out of bounds for length 130
<div class="p"><!----></div>
<pre>
gap62; Collected( Factors( val3C * SizesCentralizers( h )[ 3pos<p last forwhich structure of the preimage has to be shown is <span class="SimpleMath">U = (A_6 × A_6):2^2</span>. We claim that each of the <span class="SimpleMath">A_6</span> type subgroups in the derived subgroup <span class="SimpleMath">U^' = A_6 × A_6</span> lifts to its double cover in <span class="SimpleMath">2.S</span>. Since all elements of order <span class="SimpleMath">20</span> in <span class="SimpleMath">U</span> lie in <span class="SimpleMath">U^'</span>, at least one of the two direct factors must lift to its double cover, in order to give rise to an order <span class="SimpleMath">40</span> element in <span class="SimpleMath">U</span>. In fact both factors lift to the double cover since the two direct factors are
[ [ 2, 13 ], [ 3, 13 ], [ 5, 1 ] ]
</pre>
<div class="p"><!----></div>
<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 paperjava.lang.StringIndexOutOfBoundsException: Range [87, 27) out of bounds for length 93
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>
incharacteristic2 3, 5java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
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 / 9001;z 9002;.
Using this representation,
we construct a straight line program that computes class representatives
of C / 9001;Z 9002; from the images of the given generators=G"gt<>< classGAPinput>x& Sum ({ );<span>
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 "reliminaryfusion´ Cto <size""B/ont.
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 / 9001;Z 9002; that can be
computed by <font face="helvetica">MAGMA<
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>
<pre>
gap62; slp_maxes_2:= AtlasProgram( "B", "maxes", 2 );;
gap62; cgens_3:= ResultOfStraightLineProgram( slp_maxes_2.program,
62; GeneratorsOfGroup( b_3 ) );;
</pre>
<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>
<pre>
gap62; m:= GModuleByMats( cgens_3, GF(3) );;
gap62; cf_3:= MTX.CompositionFactors( m );;
gap&
gap62; List( cf_3, x -62; x.dimension );
[ 23, 2048, 2300 ]
</pre>
<div class="p"><!----></div>
java.lang.StringIndexOutOfBoundsException: Range [10, 2) out of bounds for length 46
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 conjugacy classes<>2A<tt> tt</t respectively
such that the product a b has order 28.
<div class="p"><!----></div>
<div class="p"spanclass=G"gt</pan>< class"APinput" - x = ;<span>
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>8722;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>
<pre>
gap62; slp_co2:= StraightLineProgram( [
62; [ 2,1 1 1] 2 2 ] [4 , 1, 1] [ 4 ]
62; [ 6, 1, 1, 1 ], [ 7, 4 ], [ 3, 2 ], [ 5, 1, 9, 1 ],
62; [ 10, -1 ], [ 6, 3 ], [ 11, 1, 8, 1 ], [ 13, 1, 10, 1 ],
62; [ [ 12, 1 ], [ 14, 1 ] ] ], 2 );;
gap62; f:= FreeGroup( "x", "y" );; x:= f.1;; y:= f.2;;
gap62; words:= ResultOfStraightLineProgram( slp_co2, [ x, y ] );;
gap62; words = [ y^12, ((y^4*x)^4)^(y*(y*x)^3) ];
true
gap62; co2gens:= cf_3[1].generators;;
gap62; co2stdgens:= ResultOfStraightLineProgram( slp_co2, co2gens );;
</pre>
<div class="p"><!----></div>
Nextwe findan orbit of length4600 under the action of C
on the 2300-dimensional module.
This will allow us to represent C/9001;z 9002; 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 isa2<><supU><sub>22subgroup thatfixes
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>
<div class="p"><!----></div>
<pre>
gap62; fgens:= cf_3[3].generators;;
gap62; fstdgens:= ResultOfStraightLineProgram( slp_co2, fgens );;
gap62; slp_co2m1:= AtlasProgramspan java.lang.StringIndexOutOfBoundsException: Range [13, 11) out of bounds for length 101
gap62; ugens:= ResultOfStraightLineProgram( slp_co2m1.program, fstdgens );;
gap62; one:= ugens[1]^0;;
1] 2 ;java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
gap62; Order( comm );
12
gap62; pow:= comm^2;;
gap< class"><span> <pan class="" -java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
gap62; nsp:= List( mats, NullspaceMat );;
gap62; List( nsp, Length );
[ 434, 434 ]
gap62; si:= SumIntersectionMat( nsp[1], nsp[2] );;
gap62; Length( si[2] );
1
gap62; orb:= Orbit( Group( fstdgens ), si[2][1] );;
gap62; Length( orb );
< actions <class=SimpleMath></>onthe spanSimpleMath"O_7()/> subgroups pairwisejava.lang.StringIndexOutOfBoundsException: Range [163, 162) out of bounds for length 575
gap62; orb:= SortedList( orb );;
gap62; stdperms:= List( fstdgens, x -62; Permutation( x, orb ) );;
gap62; List( stdperms, Order );
[ 2, 5 ]
</pre>
<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<div class="example><pre>
<div class="p"><!----></div>
<div class="p"><!----></div>
<br clear="all" /><table border="0" width="100%"><tr><td>
<table align="center" cellspacing="0" cellpadding="2"><tr><td nowrap="nowrap" align="center">
</td><td nowrap="nowrap" align="center">
<table>
<tr><td><tablespan class=GAPprompt">><span> span ""poss: PossiblePermutationCharacters( O7(3) ) java.lang.StringIndexOutOfBoundsException: Range [129, 128) out of bounds for length 139
(b<sup>2</sup> a)<sup>9</sup>, </td></tr></table></td><td><table border="0" cellspacing="0" cellpadding="0"><tr><td nowrap="nowrap" align="center">
(b a b)<sup>9</sup>, </td></tr></table></td><td><table border="0" cellspacing="0" cellpadding="0"><tr><td nowrap="nowrap" align="center">
(a b<sup>2</sup>)<sup>9</sup>, </td></tr></table></td><td><table border="0" cellspacing="0" cellpadding="0"><tr><td nowrap="nowrap" align="center">
(b<sup>2 false,false false, true ]
<tr><td><table border="0" cellspacing="0" cellpadding="0"><tr><td nowrap="nowrap" align="center">
(b a b<sup>2</sup>)<sup>9</sup>, </td></tr></table></td><td><table border="0" cellspacing="0" cellpadding="0"><tr><td nowrap="nowrap" align="center">
((a b)<sup>2</sup> a)<sup>9</sup>, </td></tr></table></td><td><table border="0" cellspacing="0" cellpadding="0"><tr><td nowrap="nowrap" align="center">
(a b (b a)<sup>2</sup>)<sup>9</sup>, </td></tr></table></td><td><table border="0" cellspacing="0" cellpadding="0"><tr><td nowrap="nowrap" align="center">
((a b)<sup>2</sup> b a)<sup>9</sup>, </td></tr></table></td></tr>
<tr><td><table span class="GAPpromptgap></pan<spanclass=GAPinput"ext: PossiblePermutationCharacters(CharacterTable( "O7(3).2" ), t2 );;</span>
(b<sup>3</sup> (b a)<sup>2</sup>)<sup>4</sup>, </td></tr></table></td><td><table border="0" cellspacing="0" cellpadding="0"><tr><td nowrap="nowrap" align="center">
(b (b<sup>2</sup> a)<sup>2</sup>)<sup>4</sup>, </td></tr></table></td><td<table 0 ="0"cellpadding0>tr< nowrap"nowrap"align==center"java.lang.StringIndexOutOfBoundsException: Index 163 out of bounds for length 163
(b<sup>2</sup> a b<sup>3</sup> a)<sup>4</sup>, </td></tr></table></td><td><table border="0" cellspacing="0" cellpadding="0"><tr><td nowrap="nowrap" align="center">
(b a b<sup>4</sup> a)<sup>4</sup>, </td></tr></table></td></tr>
<tr><td><table border="0" cellspacing="0" cellpadding="0"><tr><td nowrap="nowrap" align="center">
(b<sup>2</sup> (b a)<sup>2</sup> b)<sup>4</sup>, </td></tr></table></td><td><table border="0" cellspacing="0" cellpadding="0"><tr><td nowrap="nowrap" align="center">
((b<sup>2</sup> a)<sup>2</sup> b)<sup>4</sup>, </td></tr></table></td><td><table border="0" cellspacing="0" cellpadding="0"><tr><td nowrap="nowrap" align="center">
(b a b<sup>3</sup> a b)<sup>4</sup>, </td></tr></table></td><td><table border="0" cellspacing="0" cellpadding="0"><tr><td nowrap="nowrap" align="center">
(b (b a)<sup>2</sup> b<sup>2</sup>)<sup>4</sup>, </td></tr></table></td></tr>
<tr><td><table border="0" cellspacing="0" cellpadding="0"><tr><td nowrap=
((b a b)<sup>2</sup> b)<sup>4</sup>, </td></tr></table></td><td><table border="0" cellspacing="0" cellpadding="0"><tr><td nowrap="nowrap" align="center">
((b<sup>2</sup>a)<sup>2</up ba)<up>12</up>,/d</r>/table></td><td><table border="0" cellspacing="0" cellpadding="0"><tr><td nowrap="nowrap" align="center">
(b (b a)<sup>2</sup> b<sup>2</sup> a)<sup>12</sup>, </td></tr></table></td><td><table border="0" cellspacing="0" cellpadding="0"><tr><td nowrap="nowrap" align="center">
((b a b)<sup>2</sup> b a)<sup>12</sup>, </td></tr></table></td></tr>
<tr><td><table border="0" cellspacing="0" cellpadding="0"><tr><td nowrap="nowrap" align="center">
((b a b)<sup>2</sup> a b)<sup>12</sup>, </td></tr></table></td><td><table border="0" cellspacing="0" cellpadding="0"><tr><td nowrap="nowrap" align="center">
((b<sup>2</sup> a)<sup>2</sup> b a b a((
</td></tr></table></td><td><table border="0" cellspacing="0" cellpadding="0"><tr><td nowrap="nowrap" align="center">
</td></tr></table></td></tr></table>
</td><td nowrap="nowrap" align="center">
</td></tr></table>
</td></tr></table>
<div class="p"><!----></div>
The following straight line program computes these basis vectors
when it is applied to x and y.
<div class="p"><!----></div>
<pre>
gap62; slp_ker:= StraightLineProgram( [
62; [1 1 2,1], ,1 1 , [ ,2,[4 1 2 ,
62; [ 2, 1, 4, 1 ], [ 3, 1, 2, 1 ], [ 3, 2 ], [ 4, 2 ], [ 6, 2 ],
62; [ 7, 2 ], [ 2, 1, 10, 1 ], [ 2, 1, 6, 1 ], [ 10, 1, 2, 1 ],
62; [ 5, 1, 3, 1 ], [ 4, 1, 5, 1 ], [ 9, 1, 1, 1 ], [ 3, 1, 10, 1 ],
62; [ 9, 1, 4, 1 ], [ 5, 1, 13, 1 ], [ 2, 1, 12, 1 ], [ 14, 1, 7, 1 ],
62; [ 17, 1, 7, 1 ], [ 5, 1, 15, 1 ], [ 12, 1, 2, 1 ], [ 6, 1, 14, 1 ],
62; [ 13, 1, 5, 1 ], [ 11, 1, 2, 1 ], [ 12, 1, 4, 1 ], [ 13, 1, 7, 1 ],
62; [ 11, 1, 4, 1 ], [ 11, 1, 3, 1 ], [ 12, 1, 10, 1 ],
62; [ [ 7, 9 ], [ 6, 9 ], [ 8, 9 ], [ 16, 9 ], [ 17, 9 ], [ 18, 9 ],
62; [ 19, 9 ], [ 20, 9 ], [ 21, 4 ], [ 22, 4 ], [ 23, 4 ], [ 24, 4 ],
62; [ 25, 4 ], [ 26, 4 ], [ 27, 4 ], [ 28, 4 ], [ 29, 4 ], [ 30, 12 ],
62; [ 31, 12 ], [ 32, 12 ], [ 33, 12 ], [ 34, 12 ] ] ], 2 );;
gap62; f:= FreeGroup( "a", "b" );; a:= f.1;; b:= f.2;;
gap62; ResultOfStraightLineProgram( slp_ker, [ a, b ] );
[ (b^2*a)^9, (b
thatfrom the permutationcharacters of <span class="SimpleMath">S.2_1</span> on the cosets of <span class="SimpleMath">L_4(3):2 × 2</span> type subgroups, we see that such subgroups must contain <code class="code">20A</code> elements, i. e., all such subgroups of <span class="SimpleMath">S.2_1</span> lie inside <span class="SimpleMath">O_7(3).2</span> type subgroups. This means that the structure description of these novelties in <a href="chapBib.html#biBCCN85">[CCN+85, p. 140]</a> is not correct. The correct structure is <span class="SimpleMath">L_4(3).2^2</span>.)</p>
(b^2*a*b^3*a)^4, (b*a*b^4*a)^4, (b^2*(b*a)^2*b)^4, ((b^2*a)^2*b)^4,
(b*a*b^3*a*b)^4, (b*(b*a)^2*b^2)^4, ((b*a*b)^2*b)^4, ((b^2*a)^2*b*a)^12,
(b*(b*a)^2*b^2*a)^12, ((b*a*b)^2*b*a)^12, ((b*a*b)^2*a*b)^12,
((b^2*a)^2*b*a*b*a)^12 ]
</pre>
<div [[ 1 ,0 ] ]
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>
<pre>
gap62; slp_co2classreps:= AtlasProgram( "Co2", "classes" );;
</pre>
<div class="p"><!----></div>
Hence we can describe representatives ofHence
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>
<pre>
gap62; classrepsinfo:= [
62; [ "1A", [ ],[ 3,4,22 ],[],[ 8 ] [2] ]],
62; [ "2A", [ [ 1, 6, 8, 9, 11 ], [ 12 ], [ 1, 4, 9, 10, 19 ],
62 span="APprompt">gap></span> <span class="GAPinput">ext:= PermChars( t2, rec( torso:= [ 1120 ] ) );;</span>
62; [ 1, 5, 18 ], [ 3 ] ] ],
62; [ "2B", [ [ 1, 3, 4, 17, 20 ], [ 2, 14, 17 ], [ 2, 10, 22 ],
62; [ 14, 21 ], [ ], [ 9 ], [ 1, 5 ], [ 10, 11 ], [ 6, 12 ],
62; [ 1 ] [2] ]],java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
62; [ "2C", [ [ 4, 11, 13, 20 ], [ 1, 10, 12, 17 ], [ 3, 18, 21 ],
;[ 8,13, 17] 16,22 ,[4,5,15],[8 ]
62; [ 1, 10 ], [ 1, 21 ], [ 3, 9, 18, 21 ], [ 8 ],
62; [ 1, 10, 12 ], [ 4 ], [ 21 ], [ 6 ], [ 1 ], [ ] ] ],
62; [ "3A", [ [ ], [ 21 ], [ 1 ] ] ],
62; [ "3B", [ [ 17, 20 ], [ 17 ], [ 1, 5, 17 ], [ 3, 18 ], [ 1 ], [ 10 ],
62; [ 12 ], [ 3 ], [ ] ] ],
62; [ "4A", [ [ 11 ], [ ], [ 1 ], [ 1,
62; [ "4B", [ [ 2, 7, 19, 20 ], [ 2, 12 ], [ 9, 21 ], [ 5 ], [ ],
[920 , 2 ,[6 ] 1] ] ,
62; [ "4C", [ [ 3, 7, 11 ], [ 18, 22 ], [ 4, 6 ], [ 21 ], [ 2, 17, 18 ],
62; [ 1, 14 ], [ 5, 12, 17 ], [ 14 ], [ 3, 4 ], [ 3 ], [ 10 ],
62; [ 2 ], [ 1 ], [ ] ] ],
62; [ "4D", [ [ 20 ], [ 9, 22 ], [ 8, 16 ], [ 6 ], [ 6, 17 ], [ ],
62; [ 1 ] ] ],
62; [ "4E", [ [ 11, 19 ], [ 3, 7 ], [ 1, 22 ], [ 1, 2, 22 ], [ 1, 10 ],
62; [ 3, 18 ], [ ], [ 5, 20 ], [ 2 ], [ 1, 15 ], [ 1 ], [ 3 ],
62; [ 8 ] ] ],
62; [ "4F", [ [ 3, 4 ], [ 3, 19, 21 ], [ 4, 16 ], [ 4, 13 ], [ 3, 7 ],
62;[4 , , ,7, , java.lang.StringIndexOutOfBoundsException: Index 80 out of bounds for length 80
62; [ 4, 14 ], [ 17 ], [ 19 ], [ 1 ], [ 1, 4 ], [ 18 ],
&62; 11]]]
62; [ "4G", [ [ 10 ], [ 1, 4 ], [ 8 ], [ 20 ], [ ], [ 16 ], [ 1 ],
62; [ 2 ] ] ],
62; [ "5A", [ [ ], [ 1 ] ] ],
62; [ "5B", [ [ ], [ 1 ], [ 2 ], [ 19 ], [ 15, 19 ], [ 4 ], [ 8 ] ] ],
62; [ "6A", [ [ 2 ], [ ], [ 1 ] ] ],
62; [ "6B n class"GAPprompt&t;/span class" -&t; PermChars( 2 rec(torso: )));/>
62; [ "6C", [ [ 8 ], [ 1, 14 ], [ ], [ 9 ], [ 1 ], [ 10 ], [ 2 ],
62; [ 3 ] ] ],
62; [ "6D", [ [ ], [ 19 ], [ 12, 17 ], [ 1, 11 ], [ 7 ], [ 4, 10 ], [ 1 ],
62; [ 2, 3 ], [ 1, 7 ], [ 10 ], [ 3 ] ] ],
62; [ "6E", [ [ 9 ], [ 1, 8 ], [ 2 ], [ 22 ], [ ], [ 2, 3 ], [ 1 ],
62; [ 3, 4 ], [ 3 ], [ 13 ], [ 7 ], [ 6 ] ] ],
62; [ "6F", [ [ 5, 10 ], [ 1, 2, 4 ], [ 4, 13 ], [ 10, 18 ], [ 4, 12 ],
62; [ 4, 9 ], [ 21 ], [ 4 ], [ 8 ], [ 1, 10 ], [ 1, 8, 18 ],
62; [ 10 ], [ 6 ], [ 1 ], [ ], [ 3 ] ] ],
62; [ "7A", [ [ 1, 2 ], [ 2 ], [ ], [ 7 ], [ 1, 10 ], [ 1 ], [ 11 ] ] ],
62; [ "8A", [ [ 2, 18 ], [ ], [ 2 ], [ 9 ], [ 7 ], [ 1 ] ] ],
62; [ "8B", [ [ 8, 17 ], [ 1, 7 ], [ 11, 21 ], [ 2, 8 ], [ ], [ 1 ],
62; [ 2, 12 ], [ 7 ], [ 5 ], [ 2 ] ] ],
62; [ "8C", [ [ 1, 8 ], [ 13 ], [ 9 ], [ ], [ 1 ] ] ],
62; [ "8D", [ [ 1, 2 ], [ 7 ], [ 1 ], [ 6 ], [ ] ] ],
62; [ "8E", [ [ 2, 12 ], [ 3, 22 ], [ 4, 22 ], [ 4, 12 ], [ 1, 11 ],
62; [ 2, 22 ], [ 6, 12 ], [ 9 ], [ 2, 10 ], [ 20 ], [ 1, 9 ],
62; [ 11 ], [ 10 ], [ 1 ], [ ], [ 7 ] ] ],
62; [ "8F", [ [ 1, 10 ], [ 18 ], [ 4 ], [ 9 ], [ 20 ], [ ], [ 6 ],
62; [ 1 ] ] ],
62; [ "9A", [ [ ], [ 4 ], [ 3 ], [ 5 ] ] ],
62; [ "10A", [ [ ], [ 1 ] ] ],
&62; 10,[[2] 12 ] ,[ 1 ] [9] [10 ],[14 ], [3 ]]],
62; [ "10C", [ [ 1, 20 ], [ 5 ], [ 1, 8 ], [ 12 ], [ 2 ], [ ], [ 10 ],
62; [ 3 ], [ 1 ] ] ],
62; [ "11A", [ [ 2 ], [ 1 ], [ 3 ], [ ] ] ],
62; [ "12A", [ [ 10 ], [ ], [ 1 ] ] ],
62; [ "12B", [ [ ], [ 14 ], [ 1 ], [ 3 ], [ 4 ], [ 10 ] ] ],
62; [ "12C", [ [ 19 ], [ ], [ 7 ], [ 1, 7 ], [ 1 ] ] ],
62; [ "12D", [ [ 1 ], [ 11 ], [ 8 ], [ 15 ], [ ], [ 2 ] ] ],
62; [ "12E", [ [ 3 ], [ 5 ], [ ] ] ],
62; [ "12F", [ [ 9 ], [ 1, 15 ], [ 5 ], [ ], [ 2 ], [ 12 ], [ 8 ],
62; [ 1 ] ] ],
62; [ "12G", [ [ ], [ 1 ], [ 3 ] ] ],
62; [ "12H", [ [ 1, 4 ], [ 4, 14 ], [ 4, 9 ], [ 4 ], [ 14 ], [ 9 ], [ 1 ],
62; [ ], [ 11 ], [ 18 ] ] ],
62; [ "14A", [ [ 1, 2 ], [ 1, 7 ], [ 10 ], [ 1 ], [ 19 ], [ ], [ 16 ] ] ],
62; [ "14B", [ [ 7 ], [ ], [ 1 ], [ 11 ] ] ],
62; [ "14C", [ [ 7 ], [ ], [ 1 ], [ 11 ] ] ],
62; [ "15A", [ [ ], [ 2 ], [ 3 ], [ 1 ] ] ],
62; [ "15B", [ [ ] ] ],
62; [ "15C", [ [ ] ] ],
62; [ "16A", [ [ 6 ], [ 11 ], [ ], [ 1 ] ] ],
62; [ "16B", [ [ 3 ], [ ], [ 6 ], [ 1 ] ] ],
62; [ "18A", [ [ 4 ], [ ], [ 5 ], [ 3 ] ] ],
62; [ "20A", [ [ 6 ], [ 1 ], [ ], [ 7 ] ] ],
62; [ "20B", [ [ 3 ], [ 1 ], [ 2 ], [ ] ] ],
62; [ "23A", [ [ ] ] ],
62; [ "23B", [ [ ] ] ],
62; [ "24A", [ [ 18 ], [ 7 ], [ ], [ 1 ] ] ],
62; [ "24B", [ [ 10 ], [ ], [ 1 ], [ 4 ] ] ],
62; [ "28A", [ [ 5 ], [ ], [ 10 ], [ 1 ] ] ],
62; [ "30A", [ [ 2 ], [ ], [ 1 ], [ 3 ] ] ],
62; [ "30B", [ [ ] ] ],
62; [ "30C", [ [ ] pre
</pre>
<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,
henceweshow this program.
<div class="p"><!----></div>
<pre>
gap62; create_classreps_slp:= function( classreps )
62; local words, l, len, lines, kerneloffset, inputoffset, cache, k,
62; found, pair, pos, diff, pos2, first, n, outputs, i, list;
62;
62; # Find words for the products of kernel generators that occur.
62; words:= [];
62; for l in Set( Concatenation( List( classreps, x -='color: green'>62; x[2] ) ) ) do
62; len:= Length( l );
62; if 2 <= len then
62; if not IsBound( words[ len ] ) then
62; words[ len ]:= [];
62; fi;
62; Add( words[ len ], l );
62; fi;
62; od;
62;
62; lines:= [];
62; kerneloffset= 60java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
62; inputoffset:= 82;
62;
62; # We have to form all products of length 2 of kernel generators.
62; cache:= [ [], [] ];
62; for l in words[2] do
62; Add( lines,
2 1 , 1,l]+kerneloffset 1])java.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 74
62; Add( cache[1], java.lang.StringIndexOutOfBoundsException: Range [0, 1) out of bounds for length 0
62; Add( cache[2], Length( lines ) + inputoffset );
62; od;
&62;;
62; # For products of length at least 3, we may use known products
62; # of length 2. Longer matches are not considered.
62; for k in [ 3 .. Length( words ) ] do
62; for l in words[k] do
62; found:= false;
&; pairCombinations(,2 ) do
62; pos:= Position( cache[1], pair );
62; if pos <62; fail then
62; diff:= Difference( l, pair );
62; if Length( diff ) = 1 then
62; Add( lines,
62; [ cache[2][ pos ], 1, diff[1] + kerneloffset, 1 ] );
62; else
62; pos2:= Position( cache[1], diff );
62; if pos2 <62; fail then
62; Add( lines,
62; [ cache[2][ pos ], 1, cache[2][ pos2 ], 1 ] );
62; else
62; first:= cache[2][ pos ];
62; for n in diff do
62; Add( lines, [ first, 1, n + kerneloffset, 1 ] );
62; first:= Length<pan="APprompt"gap&<span"GAPinput">:= List(,x> ApproxP primt2 x ));<span>
62; od;
62; fi;
62; fi;
62; Add( cache[1], l );
62; Add( cache[2], Length( lines ) + inputoffset );
62; found:= true;
62; break;
62; fi;
62; od;
62; if not found then
62; first:= l[1] + kerneloffset;
62; for n in l{ [ 2 .. Length( l ) ] } do
62; Add( lines, [ first, 1, n + kerneloffset, 1 ] );
62; first:= Length( lines ) + inputoffset;
62; od;
62; Add( cache[1], l );
62; Add( cache[2], Length( lines ) + inputoffset );
62; fi;
62; od;
62; od;
62;
62; outputs:= [];
#
62; for i in [ 1 .. Length( classreps ) ] do
62; list:= classreps[i][2];
62; for l in list do
62; if l = [ 0 ] then
62; Add( outputs, [ kerneloffset + 1, 2 ] );
62; elif l = [] then
&62 Add outputs, [ i, 1 ] );
62; elif Length( l ) = 1 then
62; Add( lines, [ i, 1, l[1] + kerneloffset, 1 ] );
62; Add( outputs, [ Length( lines ) + inputoffset, 1 ] );
62; else
62; # The words are already cached.
62; pos:= Position( cache[1], l );
62; Add( lines, [ i, 1, cache[2][ pos ], 1 ] );
62; Add( outputs, [ Length( lines ) + inputoffset, 1 ] );
62; fi;
62; od;
62; od;
62;
62; Add( lines, outputs );
62;
62; return StraightLineProgram( lines, inputoffset );
62; end;;
gap62; slp_classreps:= create_classreps_slp
</pre>
<div class="p"><!----></div>
We compute the class representatives of P.
<div class="p"><!----></div>
<pre>
gap62; kerperms:= ResultOfStraightLineProgram( slp_ker, stdperms );;
&; java.lang.StringIndexOutOfBoundsException: Range [27, 25) out of bounds for length 56
62; slp_co2classreps.program, stdperms );;
gap62; classreps:= ResultOfStraightLineProgram( slp_classreps,
62; Concatenation( co2classreps, kerperms ) );;
</pre>
<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>
gap62; g:= Group( stdperms );;
gap62; SetConjugacyClasses( g,
&; List(classreps, &62 g,x ) )
gap62; libcb2b:= CharacterTable( "BM2" );
CharacterTable( "2^(1+22).Co2" )
gap62; cen:= ClassPositionsOfCentre( libcb2b );;
gap62; if CTblLib.IsMagmaAvailable() then
62; mgmt:= CharacterTableComputedByMagma( g, "2^22.Co2-Magma" );
62; else
62; mgmt:= libcb2b / cen; # this is a hack ...
62; fi;
</pre>
<div class="p"><!----></div>
class"<!----></div>
<div class="p"><!----></div>
Our next goal is to compute the character table of C,
together with the information
conjugacy classes in C and <font size="+0">B</font>.
<div class="p"><!----></div>
In order to write down class representatives of C,
e thewordsfor class representatives of
C / 9001;z 9002; in the generators of the faithful
2048-dimensional module for C, in characteristic 3 and 5.
of 15, the
character value in at least one of the two representations,
and interpret it as the value of the unique faithful irreducible ordinary
character of 2048 .
Whenever this character value is nonzero, we know that the corresponding
class of C / 9001;z 9002; 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
question that is fortheclassrepresentatives &; &9002
and for products of some of them with the central involution of C.
<div class="p"><!----></div>
thejava.lang.StringIndexOutOfBoundsException: Range [37, 36) out of bounds for length 70
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 / 9001;z 9002; 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>
<pre>
gap62; cgens_2:= ResultOfStraightLineProgram( slp_maxes_2.program,
62; GeneratorsOfGroup( b_2 ) );;
gap62; cgens_5:= <span class="GAPprompt">gap><span> <pan classGAPinput">=[;;<span>
62; GeneratorsOfGroup( b_5 ) );;
gap62; cgens_2_std:= ResultOfStraightLineProgram( slp_co2, cgens_2 );;
gap62; cgens_3_std:= ResultOfStraightLineProgram( slp_co2, cgens_3 );;
gap62; cgens_5_std:= ResultOfStraightLineProgram( slp_co2, cgens_5 );;
&62;:=GModuleByMats(cgens_5_std (5
gap62; cf_5:= MTX.CompositionFactors( m );;
gap62; SortParallel( List( cf_5, x -62; x.dimension ), cf_5 );
gap62; List( cf_5, x -62; x.dimension );
[ 23, 2048, 2300 ]
gap62; inputsB:= List( [ cgens_2_std, cgens_3_std, cgens_5_std ],
62; l -62; Concatenation(
62; ResultOfStraightLineProgram( slp_co2classreps.program, l ),
62; ResultOfStraightLineProgram( slp_ker, l ) ) );;
gap62; cf3std:= ResultOfStraightLineProgram( slp_co2, cf_3[2].generators );;
gap inputs2048:= List([ cf3std []generators ]
62; l -62; Concatenation(
62; ResultOfStraightLineProgram( slp_co2classreps.program, l ),
62; ResultOfStraightLineProgram( slp_ker, l ) ) );;
</pre>
<div class="p"><!----></div>
<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 / 9001;z e='color: green'>9002;
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>
gap62; slp:= RestrictOutputsOfSLP( slp_classreps, 1 );;
gap62; centralinv_2048:= List( inputs2048,
62; l - nlyoneclass of < class=SimpleMath"36L_4)/java.lang.StringIndexOutOfBoundsException: Range [79, 78) out of bounds for length 332
gap62; List( centralinv_2048, Order );
[ 2, 2 ]
gap62; centralinv_B:= List( inputsB,
62; l -62; ResultOfStraightLineProgram( slp, l ) );;
</pre>
<div class="p"><!----></div>
Now we run over the class representatives of C / 9001;z e='color: green'>9002;,
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 / 9001;z 9002;,
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>.iv class="example"><pre
<div class="p"><!----></div>
<pre>
gap62; cent_table:= rec( preimages:= [],
62; fusionlabels:= [],
62; projcharacter:= [] );;
gap62; for i in [ 1 .. Length( classreps ) ] do
2; # identify representative
62; slp:= RestrictOutputsOfSLP( slp_classreps, i );
62; id:= IdentifyClassName( inputsB[1], inputsB[2], inputsB[3], slp, fail );
62; order:= Int( Filtered( id, IsDigitChar ) );
&;
62; if order mod 3 = 0 then
62; if order mod 5 = 0 then
62; # We cannot compute</re><div
62; value:= fail;
62; else
62; value:= BrauerCharacterValue(
62; ResultOfStraightLineProgram( slp, inputs2048[2] ) );
62; fi;
&62;else
62; value:= BrauerCharacterValue(
62; ResultOfStraightLineProgram( slp, inputs2048[1] ) );
62; fi;
62;
62; if value = 0 then
62; # Assume no splitting.
62; Add( cent_table.preimages, [ i ] );
62; Add( cent_table.fusionlabels, [ id ] );
62; Add( cent_table.projcharacter, value );
62; else
62; # Identify the class of the other preimage.
62; mats:= List( inputsB,
62; l -62; ResultOfStraightLineProgram( slp, l ) );
&62 ( mats]*[1,
62; mats[2] * centralinv_B[2],
62; mats[3] * centralinv_B[3],
62; fail, fail );
62; if value = fail then
62; # no Brauer character value known
#;Add java.lang.StringIndexOutOfBoundsException: Range [45, 44) out of bounds for length 54
&62;Add cent_table.usionlabels [ id id2 ]
62; Add( cent_table.projcharacter, value );
62; else
62; # two preimage classes, take java.lang.StringIndexOutOfBoundsException: Range [0, 51) out of bounds for length 12
#; .,[ ,] )java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
62; if value 62; 0 then
62; Add( cent_table.fusionlabels, [ id, id2 ] ); e</>
62; Add( cent_table.projcharacter, value );
62; else
62; Add( cent_table.fusionlabels, [ id2, id ] );
62; Add( cent_table.projcharacter, -value );
62; fi;
java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
62; fi;
62; 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<iv class="xample">>
for p 8712; { 3, 5 }.
The value at the p-th power of an element g, say,
determines thecongruence 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 124;C124; / 120,
and a character value of absolute value 7 or larger
on any of these classes would lead to a contribution of at<san class=GAPprompt">/
to the norm of the character.
However, the known character values contribute already more than
1 8722; 7<><sup norm missing values
are uniquely determined by their congruence class modulo 15.
<div class="p"><!----></div>
<pre>
gap62; chi:= cent_table.projcharacter;;
gap62; failpos:= Positions( chi, fail );;
gap62; OrdersClassRepresentatives( mgmt ){ failpos };
[ 15, 30, 30, 30, 15, 15, 30, 30, 30, 30, 30, 30 ]
gap62; SizesCentralizers( mgmt ){ failpos };
[ 120, 120, 120, 120, 30, 30, 120, 120, 120, 120, 30, 30 ]
gap62; used:= 0;;
gap62; for i in[ 1 .. 388 ] do
62; if chi[i] <62; 0 and chi[i] < style='color: green'>62; fail then
62; used:= used + 2 * SizesConjugacyClasses( mgmt )[i] * chi[i]^2;
62; fi;
62; od;
gap62; used / ( 2 * Size( mgmt ) ) 62; 1 - 7^2 / 120;
true
</pre>
<div class="p"><!----></div>
Thus we may complete the character, as follows.
<div class="p"><!----></div>
<pre>
gap62; for i in failpos do
62; v:= ChineseRem( [ 3, 5 ], [ chi[ PowerMap( mgmt, 3, i ) ],
62; chi[ PowerMap( mgmt, 5, i ) ] ] );
62; if v 62; 7 then
62; v:= v - 15;
62; fi;
62; chi[i]:= AbsInt( v );
62; od;
gap62; 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
#;z&9002 that split twoclasses ofC
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>
<pre>
gap62; split:= Filtered( failpos, x -62; chi[x] <62; 0 );
[ 343, 347, 348, 383, 387, 388 ]
gap62; nonsplit:= Difference( failpos, split );
[ 344, 345, 346, 384, 385, 386 ]
gap62; pow:= PowerMap( mgmt, 3 ){ split };
[ 138, 136, 136, 263, 261, 261 ]
gap62; chi{ split };
[ 2, 1, 1, 2, 1, 1 ]
gap#62;chi{ }java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
[ 8, 2, 2, 4, 2, 2 ]
gap62; cent_table.fusionlabels{ split };
[ [ "15A", "30D" ], [ "15B", "30GH" ], [ "15B", "30GH" ], [ "30A", "30E" ],
[ "30GH", "30F" ], [ "30GH", "30F" ] ]
gap62; cent_table.fusionlabels{ pow };
[ [ "5A", "10B" ], [ "10D", "5B" ], [ "10D", "5B" ], [ "10 p>We have found allrelevant characters of span="SimpleMathS>, compute thebounds< class"SimpleMath"σ'S.2__2,s<span.<>
[ "10F", "10D" ], [ "10F", "10D" ] ]
</pre>
<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 positivevalues the character
are not congruent modulo 3.
Similarly, the last two pairs need not be swapped because <tt>30F</tt>
cubes tt>10</>.
<div class="p"><!----></div>
<pre>
gap62; First( powerinfo, l -62; l[1] = "30A" );
[ "30A", [ [ 2, "tpan class=Gjava.lang.StringIndexOutOfBoundsException: Range [23, 22) out of bounds for length 123
gap62; First( powerinfo, l -62; l[1] = "30F" );
[ "30F", [ [ 2, "15B" ], [ 3, "10F" ], [ 5, "6I" ] ] ]
gap62; cent_table.fusionlabels[ split[4] ]:= Permuted(
62; cent_table.fusionlabels[ split[4] ], (1,2) );;
gap62; for i in nonsplit do
&62 Unbind( cent_table.usionlabelsi[2 ;
62; od;
</pre>
<div class="p"><!----></div>
Assuming that not more classes of C / 9001;z 9002; split
under the epimorphism from C,
we create the (preliminary) character table head of C.
<div class="p"><!----></div>
<pre
gap62; for i in split do
62; cent_table.preimages[i]:= [ i, i ];
62; od;
gap62; factorfusion:= Concatenation( cent_table.preimages );;
gap62; cb2b:= rec( UnderlyingCharacteristic:= 0,
62; Size:= 2 * Size( mgmt ),
62; Identifier:= "C_B(2B)",
62; SizesCentralizers:= [] );;
gap62; proj:= InverseMap( factorfusion );;
gap for i in [ 1 .. Length( proj ) ] java.lang.StringIndexOutOfBoundsException: Range [48, 49) out of bounds for length 48
62; if IsInt( proj[i] ) then
62; cb2b.SizesCentralizers[ proj[i] ]:= SizesCentralizers( java.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 0
62; else
62; cb2b.SizesCentralizers{ proj[i] }:=
62; SizesCentralizers( mgmt )[i] * [ 2, 2 ];
62; fi;
62; od;
</pre>
<div class="p"><!----></div>
The element orders are given by the class labels.
<div class="p"><!----></div>
<pre>
gap62; fusionlabels:= Concatenation( cent_table.fusionlabels );;
gap62; cb2b.OrdersClassRepresentatives:= List(
62; Concatenation( cent_table.fusionlabels ),
62; x -62; Int( Filtered( x, IsDigitChar ) ) );;
gap62; ConvertToCharacterTable( cb2b );;
</pre>
<div class="p"><!----></div>
Next we turn the projective character <tt>chi</tt> of C/9001;z style='color: green'>9002;
into a character for C,
and inflate the characters of the factor group to C.
<span class="GAPprompt">gt/><"">( ) }<
<pre>
gap62; chi_c:= [];;
gap62; for i in 80 ]
62; if chi[i] = 0 then
62; chi_c[ proj[i] ]:= 0;
62; else
62; chi_c{ proj[i] }:= [ 1, -1 ] * chi[i];
62; fi;
62; od;
gap62; factirr:= List( Irr( mgmt ), x -62; 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 classes occurs.
<div class="p"><!----></div>
<pre>
gap62; factirr_co2:= Filtered( factirr,
62; x -62; ClassPositionsOfKernel( x ) <62; [ 1, 2 ] );;
gap62; Length( factirr_co2 );
60
gap62; ten:= Tensored( factirr_co2, [ chi_c ] );;
gap62; Set( List( ten, x -62; ScalarProduct( cb2b, x, x ) ) );
[ 1 ]
gap62; irr:= Concatenation( factirr, ten );;
gap62; Size( cb2b ) = Sum( List( irr, x -62; x[1]^2 ) );
true
gap62; SetIrr( cb2b, List( irr, x ->62; 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 / 9001;z 9002;
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>
gap62; powermaps:= ComputedPowerMaps( cb2b );
[ ]
gap62; for p in Set( Factors( Size( cb2b ) ) ) do
#; : CompositionMaps( java.lang.StringIndexOutOfBoundsException: Range [64, 63) out of bounds for length 66
62; CompositionMaps( PowerMap( mgmt, p ), factorfusion ) );
62; poss:= PossiblePowerMaps( cb2b, p, rec( powermap:= init ) );
62; if Length( poss ) <<class=">&t<span>< class>(orbs );<span
62; Error( Ordinal( p ), " power map is not unique" );
62; fi;
62; powermaps[p]:= poss[1];
62; od;
</re
<div class="p"><!----></div>
Finally, we compare the newly computed<>/iv>
with that from <font face="helvetica">GAP</font>'s library.
<div class="p"><!----></div>
<prebeas power of given.p
gap62; libtbl:= CharacterTable( "BM2" );;
gap62; Set( Irr( libtbl ) ) = Set( Irr( cb2b ) );
true
gap62; IsRecord( TransformingPermutationsCharacterTables( libtbl, cb2b ) );
true
</pre>
<div class="p"><!----></div>
<h2><a name="tth_sEc6">
<a>nbsp&bsp;onjugacy 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>(9001;g 9002;)
thatcontain roots of g
and that this bijection respects centralizer orders.
< 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 <span class="GAPprompt">gap></span> <span class="GAPinput">oclass="GAPprompt">ap;<<spanclass"APinput>/>
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>
[
There is exactly one class of element order 7 in <font size="+0">B</font>,
with normalizer of order 2<sup>9</sup> 183;3<sup>3</sup> 'color: green'>183;5 183;7<sup>2</sup>
and contained in maximal subgroups of type n ="APprompt">ap><span<class=GAPinput"SizesCentralizers t2 ) ord20 }<span>
<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> 20 java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 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> 183;17.
<div class="p"><!----></div>
</li>
<li>
There is exactly one class of element order 19 in <font size="+0">B</font>,
with normalizerorder <>2/up&1833<sup><sup&18319.
<div class="p"><!----></div>
</li>
<li>
There are exactly two classes of element span"></> <span class=GAPinput">until Order(20 )=20 Size a BC ) ;/pan>
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 table head for <font size="+0">B</font>.
For that, we collect thejava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
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>
gap62; libB:= CharacterTable( "B" );;
gap62; libBnames:= ClassNames( libB, "ATLAS" );;
gap62; Bclassinfo:= rec();;
gap62; SetCentralizerOrder:= function( classname, value )
62; local pos;
62;
62; pos:= Position( libBnames, classname );
&62; if pos =fail then
62; Print( "no class name '", classname, "'?" );
62; return false;
62; elif SizesCentralizers( libB )[ pos ] <62; value then
62; Error( "wrong centralizer order!" );
#
62; Bclassinfo.( classname ):=
62; [ Int( Filtered( classname, IsDigitChar ) ), value ];
62; return true;
62; 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>
<pre>
gap=GAPprompt&;/><java.lang.StringIndexOutOfBoundsException: Range [42, 41) out of bounds for length 143
gap62; SetCentralizerOrder( "11A", 11 * 120 );;
gap62; SetCentralizerOrder( "13A", 13 * 24 );;
java.lang.StringIndexOutOfBoundsException: Range [8, 7) out of bounds for length 51
gap62; SetCentralizerOrder( "19A", 19 * 2 );;
gap62; SetCentralizerOrder( "23A", 23 * 2 );;
gap62; SetCentralizerOrder( "23B", 23 * 2 );;
gap62; SetCentralizerOrder( "31A", 31 );;
gap62; SetCentralizerOrder( "31B", 31 );;
gap62; SetCentralizerOrder( "47A", 47 );;
gap62; SetCentralizerOrder( "47B", 47 );;
</pre>
<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
<pre>
gap62; RootInfoFromLabels:= function( label )
, root,
62;
62; found:= [ label ];
62; exp:= [ Int( Filtered( label, IsDigitChar ) ) ];
62; res:= rec( total:= [], labels:= [] );
62; res.total[ exp[1] ]:= 1;
62; res.labels[ exp[1] ]:= [ label ];
62; for entry in powerinfo do
62; fordiv "xample"<pre>
62; if not entry[1] in found then
62; pos:= Position( found, root[2] );
62; if pos <62; fail then
62; ord:= exp[ pos ] * root[1];
62; Add( exp, ord );
62; Add( found, entry[1] );
total[ord ])then
62; res.total[ ord ]:= 0;
62; res.labels[ ord ]:= [];
62; fi;
62; res.total[ ord ]:= res.total[ ord ] + 1;
62; Add( res.labels[ ord ], entry[1] );
62; fi;
62; fi;
62; od;
62; od;
62; return res;
62; end;;
</pre>
<div class="p"><!----></div>
Analogously, we will need this roots information for the normalizers
of certain elements, computed from the character tables.
<=p>!-->/>
<pre>
gap62; RootInfoFromTable
62; local orders, posord, res, i, ord;
62;
62; posord:= orders[ pos ];
62; res:= rec( total:= [], classpos:= [] );
62; for i in [ 1 .. NrConjugacyClasses( tbl ) ] do
62; ord:= orders[i];
62; if ord mod posord = 0 and
62; PowerMap( tbl, ord / posord, i ) = pos then
62; if not IsBound( res.total[ ord ] ) then
62; res.totaldivclass=example"<>
62; res.classpos[ ord ]:= [];
62; fi;
62; res.total[ ord ]:= res.total[ ord ] + 1;
62; Add( res.classpos[ ord ], i );
62; fi;
62; od;
62; return res;
62; 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>
<pre>
gap62; norm2A:= CharacterTable( "2.2E6(2).2" );;
gap62; pos2A:= ClassPositionsOfCentre( norm2A );
[ 1, 2 ]
gap62 rootinfo2A_t:=RootInfoFromTable( norm2A, pos2A[2 );
gap62; pos2B:= ClassPositionsOfCentre( cb2b );
[ 1, 2 ]
gap62; rootinfo2B_t:= RootInfoFromTable( cb2b, pos2B[2] );;
gap62; norm2C:= CharacterTableOfIndexTwoSubdirectProduct(
62; CharacterTable( "F4(2)" ), CharacterTable( "F4(2).2" ),
62; CharacterTable( "2^2" ), CharacterTable( "D8" ), "norm2C" );;
gap62; pos2C:= ClassPositionsOfCentre( norm2C.table );
[ 1, 2 ]
gap62; rootinfo2C_t:= RootInfoFromTable( norm2C.table, pos2C[2] );;
gap62; sup_norm2D:= CharacterTable( "BM4" );
CharacterTable("2^(+16.2" )
gap62; pos2D:= Positions( SizesCentralizers( sup_norm2D ), 11689182992793600 );
[ 4 ]
gap62; rootinfo2D_t:= RootInfoFromTable( sup_norm2D, pos2D[1] );;
gap62; rootinfo2A_l:= [ 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64 ,67, 68, 69,
gap62; rootinfo2B_l:= RootInfoFromLabels( "2B" );;
gap62; rootinfo2C_l:= RootInfoFromLabels( "2C" );;
gap62; rootinfo2D_l:= RootInfoFromLabels( "2D" );;
</pre>
<div class="p"><!----></div>
We have to justify that the labels <tt>"2A"</tt>, <tt>"2B"</tt>,
< java.lang.StringIndexOutOfBoundsException: Range [39, 38) out of bounds for length 65
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>
<pre>
gap62; List( [ rootinfo2A_t, rootinfo2B_t, rootinfo2C_t, rootinfo2D_t ],
62; r -62; Filtered( [ 52, 56, 70 ], i -62; IsBound( r.total[i] ) ) );
[ [ 70 ], [ 56 ], [ 52 ], [ ] ]
gap62; List( [ rootinfo2A_l, rootinfo2B_l, rootinfo2C_l, rootinfo2D_l ],
62; r -62; Filtered( [ 52, 56, 70 ], i -62; IsBound( r.total[i] ) ) );
[ [ 70 ], [ 56 ], [ 52 ], [ ] ]
</pre>
<div class="p"><!----></div>
Now we can start to identify the root classes of the normalizers
with the class labels.
<div class="p"><!----></div>
<pre>
gap62; List( [ rootinfo2A_t, rootinfo2B_t, rootinfo2C_t, rootinfo2D_t ],
62; r -62; Sum( Compacted( r.total ) ) );
[ 20, 83, 14, 40 ]
gap62; List( [ rootinfo2A_l, rootinfo2B_l, rootinfo2C_l, rootinfo2D_l ],
62; r -62; Sum( Compacted( r.total ) ) );
[ 19, 77, 14, 40 ]
</pre>
<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>
<pre>
gap62; rootinfo2A_t.total[34];
2
gap62; rootinfo2A_l.total[34];
1
gap62; rootinfo2A_l.labels[34];
[ "34BC" ]
gap62; pos34:= rootinfo2A_t.classpos[34];
[ 133, 135 ]
gap62; PowerMap( norm2A, 3 ){ pos34 };
[ 135, 133 ]
</pre>
<div class="p"><!----></div>
The other six cases where we have to adjust the labels occur for roots of
<tt>2B</tt>.
<div class="p"><!----></div>
<pre>
gap62; rootinfo2B_t.total{ [ 16, 30, 32, 46, 56 ] };
[ 6, 3, 4, 2, 2 ]
gap62; rootinfo2B_l.total{ [ 16, 30, 32, 46, 56 ] };
[ 5, 2, 2, 1, 1 ]
</pre>
<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>
<>
gap62; rootinfo2B_l.labels[30];
[ "30D", "30GH" ]
gap62; pos30:= rootinfo2B_t.classpos[30];
[ 388, 393, 395 ]
gap62; PowerMap( cb2b, 7 ){ pos30 };
[ 388, 395, 393 ]
gap62; List( pos30,
62; i -62; Number( PowerMap( cb2b, 2 ), x -62; x = i ) );
[ 2,, 0, ]
gap62; List( rootinfo2B_l.labels[30],
62; l -62; Length( RootInfoFromLabels( l ).total ) );
[ 60, 30 ]
</pre
<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>
<pre>
gap62; rootinfo2B_l.labels[32];
[ "32AB", "32CD" ]
gap62; pos32:= rootinfo2B_t.classpos[32];
[ 399, 400, 403, 404 ]
gap62; PowerMap( cb2b, 5 ){ pos32 };
[ 400, 399, 404, 403 ]
</pre>
<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>
gap62; 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>
<pre>
gap62; rootinfo2B_l.labels[56];
[ "56AB" ]
gap62; pos56:= rootinfo2B_t.classpos[56];
[ 437, 438 ]
gap62; PowerMap( cb2b, 3 ){ pos56 };
[ 437, 438 ]
gap62; PowerMap( cb2b, 5 ){ pos56 };
[ 438, 437 ]
</pre>
<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>
<pre>
gap62; pos:= rootinfo2B_t.classpos[16];
[ 233, 234, 235, 251, 252, 258 ]
gap62; PowerMap( cb2b, 2 ){ pos };
[ 69, 69, 69, 104, 104, 104 ]
gap62; List( rootinfo2B_t.classpos[16],
62; i -62; Number( PowerMap( cb2b, 2 ), x -62; x = i ) );
[ 0, 0, 0, 2, 0, 2 ]
gap62; rootinfo2B_l.labels[16];
[ "16A",
gap62; Filtered( powerinfo, l -62; l[1] in rootinfo2B_l.labels[16] );
[ [ "16A", [ [ 2, "8D" ] ] ], [ "16B", [ [ 2, "8D" ] ] ],
[ "16E", [ [ 2, "8D" ] ] ], [ "16DF", [ [ 2, "8H" ] ] ],
[ "16C", [ [ 2, "8H" ] ] ] ]
gap#62; rootinfo2B_l.[16]
62; l -62; IsBound( RootInfoFromLabels( l ).total[32] ) );
[ false, false, false, true, true ]
</pre>
<div class="p"><!----></div>
<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>
<pre>
gap62; tosplit:= List( Filtered( powerinfo,
62; x -62; Number( x[1], IsAlphaChar ) 62; 1 ),
62; x -62; x[1] );
[ "16DF", "23AB", "30GH", "31AB", "32AB", "32CD", "34BC", "46AB", "47AB",
56AB ]
gap62; for l in tosplit do
62; ord:= Filtered( l, IsDigitChar );
62; new:= List( Filtered( l, IsAlphaChar ),
62; c -62; Concatenation( ord, [ c ] ) );
62; pos:= PositionProperty( powerinfo, x -62; x[1] = l );
62; Append( powerinfo, List( new, x -62; [ x,
62; StructuralCopy( powerinfo[ pos ][2] ) ] ) );
62; Unbind( powerinfo[ pos ] );
62; od;
gap62; powerinfo:= Compacted( powerinfo );;
gap62; SortParallel(
62; List( powerinfo,
62; x -62; [ Int( Filtered( x[1], IsDigitChar ) ), x[1] ] ),
62; powerinfo );
</pre>
divclass""><!----></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>
<pre>
gap62; Filtered( powerinfo, x -62; ForAny( x[2], p -62; p[2] in tosplit ) );
[ [ "32C", [ [ 2, "16DF" ] ] ], [ "32D", [ [ 2, "16DF" ] ] ],
[ "46A", [ [ 2, "23AB" ], [ 23, "2B" ] ] ],
[ "46B", [ [ 2, "23AB" ], [ 23, "2B" ] ] ] ]
gap62; entry:= First( powerinfo, x -62; x[1] = "32C" );;
gap62; entry[2][1][2]:= "16D";;
gap62; entry:= First( powerinfo, x -62; x[1] = "32D" );;
gap62; entry[2][1][2]:= "16D";;
gap62; entry:= First( powerinfo, x -62; x[1] = "46A" );;
gap62; entry[2][1][2]:= "23A";;
gap62; entry:= First( powerinfo, x -62; x[1] ="46B ;;
gap62; entry[2][1][2]:= "23B";;
</pre>
<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 <spanclass=GAPprompt">></span> <span class="GAPinput"> until Order( x ) mod 13 = 0;</span>
<div class="p"><!----></div>
<pre>
gap62; Length( powerinfo );
184
gap62; Bnames:= List( powerinfo, x -62; x[1] );;
</pre>
<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>"pre</iv
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;
thisthat thenames the labels coincide with the class names.
<div class="p"><!----></div>
<pre>
gap62; n3a:= CharacterTable( "S3xFi22.2" );;
gap62; pos:= ClassPositionsOfPCore( n3a, 3 );
[ 1, 113 ]
gap62; rootinfo3A_t:= RootInfoFromTable( n3a, pos[2] );;
gap62; rootinfo3A_l:= RootInfoFromLabels( "3A" );;
gap62; n3b:= CharacterTable( "3^(1+8).2^(1+6).U4(2).2" );;
gap62; pos:= ClassPositionsOfPCore( n3b, 3 );
[. java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
gap62; Filtered( ClassPositionsOfNormalSubgroups( n3b ),
62; n -62; IsSubset( pos, n ) );
[ [ 1 ], [ 1, 2 ], [ 1 .. 4 ] ]
gap62; rootinfo3B_t:= RootInfoFromTable( n3b, pos[2] );;
gap62; rootinfo3B_l:= RootInfoFromLabels( "3B" );;
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
true
gap&62;IsBound(rootinfo3B_t.total66 ;
false
gap62; rootinfo3A_t.total = rootinfo3A_l.total;
true
gap62; rootinfo3B_t.total = rootinfo3B_l.total;
true
gap62; n5a:= CharacterTable( "5:4xHS.2" );
CharacterTable( "5:4xHS.2" )
gap62; pos:= ClassPositionsOfPCore( n5a, 5 );
[ 1, 40 ]
gap62; rootinfo5A_t:= RootInfoFromTable( n5a, pos[2] );;
gap62; rootinfo5A_l:= RootInfoFromLabels( "5A" );;
gap62; n5b:= CharacterTable( "5^(1+4).2^(1+4).A5.4" );
CharacterTable( "5^(1+4).2^(1+4).A5.4" )
gap62; pos:= ClassPositionsOfPCore( n5b, 5 );
1. ]
gap62; Filtered( ClassPositionsOfNormalSubgroups( n5b ),
62; n -62; IsSubset( pos, n ) );
[ [ 1 ], [ 1, 2 ], [ 1 .. 4 ] ]
gap62; rootinfo5B_t:= RootInfoFromTable( n5b, pos[2] );;
gap62; rootinfo5B_l:= RootInfoFromLabels( "5B" );;
gap62; IsBound( rootinfo5A_t.total[70] );
true
gap62; IsBound( rootinfo5B_t.total[70] );
false
gap62; rootinfo5A_t.total = rootinfo5A_l.total;
true
gap62; rootinfo5B_t.total = rootinfo5B_l.total;
true
</pre>
<divclass=GAPprompt"gapgt;</span><span "APinput">ord65 = ClassOrbit( t, ord65[1] );</span>
It will be useful to provide the <tt>powerinfo</tt
in a record.
<div class="p"><!----></div>
<pre>
gap62; powerinforec:=p span class">5×^-(,java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
gap62; for entry in powerinfo do
62; powerinforec.( entry[1] ): =GAPpromptgapg;/> < classGAPinput java.lang.StringIndexOutOfBoundsException: Range [83, 82) out of bounds for length 99
# od
</pre>
<div class="p"><!----></div>
We recompute the roots information, according to the changed data.
<divp<!----></div>
<pre>
gap62; rootinfo2A_l:= RootInfoFromLabels( false
gap62; rootinfo2B_l:= RootInfoFromLabels( "2B" );;
gap62; rootinfo2C_l:= RootInfoFromLabels( "2C" );;
gap62; rootinfo2D_l:= RootInfoFromLabels( "2D" );;
gap62; rootinfo2A_t.total = rootinfo2A_l.total;
true
gap62; rootinfo2B_t.total = rootinfo2B_l.total;
gap62; rootinfo2C_t.total = rootinfo2C_l.total;
true
gap62; rootinfo2D_t.total = rootinfo2D_l.total;
true
</pre>
<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 span class="GAPprompt">gap></span> <span>cand:= List( reps, y - ,(G [ ] ;;<span
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>
gap62; IdentifyCentralizerOrders:= function( normtbl, rl, rt )
62; local n, identified, found, i, unknown, class, d,java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
62; imgs, im, pos, powerlabel, dd, cent;
62; n:= First( [ 1 .. Length( rl ) ], i -62; IsBound( rl[i] ) );
62; identified:= [ [], [] ];
62; found:= true;
62; while found do
&;found:=false;
62; for i in [ 1 .. Length( rl ) ] do
62; if IsBound( rl[i] ) then
62; unknown:= Difference( rl[i], identified[1] );
62; if Length( unknown ) = 1 then
62; # Identify the class.
#;class: rt[],identified[][]java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
62; Add( identified[1], unknown[1] );
62; Add( identified[2
62; found:= true;
62; # Identify the admissible powers.
62; for d in Difference( DivisorsInt( i / n ), [ 1 ] ) do
62; linfo:= powerinforec.( unknown[1] );
62; for p in Factors( d ) do
62; e:= First( linfo, x -62; x[1] = p );
62; span class="GAPprompt">gap></span> <span class="GAPinput">norms:= List( reps65, y -> Normalizer( G, y ) );;</span>
62; od;
62; if not e[2] in identified[1] then
62; Add( identified[1], e[2] );
62; Add( identified[2], PowerMap( normtbl, d, class ) );
62; found:= true;
62; fi;
62; od;
62; else
&
62; for d in Difference( DivisorsInt( i / n ), [ 1 ] ) do
62; cand:= Difference( rt[i], identified[2] );
62; imgs:= PowerMap( normtbl, d ){ cand };
62; for im in Intersection( imgs, identified[2] ) do
62; pos:= Positions( imgs, im );
62; if Length( pos ) = 1 then
&62 class= [1]java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
62; powerlabel:= identified[1][
62; Position( identified[2], im ) ];
62; # Find the labels of the 'd'-th powers of 'unknown'.
62; linfo:= List( unknown, l -62; powerinforec.( l ) );
62; for p in Factors( d ) do
62; e:= List( linfo, ll -62; First( ll, x -62; x[1] = p ) );
62; linfo:= List( e, ee -62; powerinforec.( ee[2] ) );
62; od;
62; linfo:= List( e, x -62; x[2] );
62; pos:= Position( linfo, powerlabel );
62; Add( identified[1], unknown[ pos ] );
62; Add( identified[2], class );
62; # Identify the admissible powers.
62; for dd in Difference( DivisorsInt( i / n ), [ 1 ] ) do
62; linfo:= powerinforec.( unknown[ pos ] );
62; for p in Factors( dd ) do
62; e:= First( linfo, x -62; x[1] = p );
62; linfo:= powerinforec.( e[2] );
62; od;
62; if not e[2] in identified[1] then
62; Add( identified[1], e[2] );
62; Add( identified[2], PowerMap( normtbl, dd, class ) );
62; =java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
#; ;
62; od;
62; found:= true;
62; break; # since we have to update 'unknown'
62; fi;
62; od;
62; if found then
62; break; # since we have to update 'unknown'
62; fi;
62; od;
62; fi;
62; fi;
#; java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
62; od;
62; # Where java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
62; for i in [ 1 .. Length( rl ) ] do
62; if IsBound( rl[i] ) then
&62; : i] java.lang.StringIndexOutOfBoundsException: Range [53, 52) out of bounds for length 58
62; cent:= Set( SizesCentralizers( normtbl ){ cand } );
62; if Length( cent ) = 1 then
62; Append( identified[1], Difference( rl[i], identified[1] ) );
62; Append( identified[2], cand );
62; fi;
62; fi;
62; od;
62; # Setthe centralizer .
62; for i in [ 1 .. Length( identified[1] ) ] do
62; if not IsBound( Bclassinfo.( identified[1][i] ) ) then
62; Print( "#I identify ", identified[1][i]java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
62; fi;
&62;SetCentralizerOrder [1[]java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
62; SizesCentralizers( normtbl )[ identified[2][i] ] );
62; od;
62;
62; return [ Difference( Concatenation( Compacted( rl ) ), identified[1] ),
62; Difference( Concatenation( Compacted( rt ) ), identified[2] ) ];
#;end;
</pre>
<div class=java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
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>
<pre>
gap62; IdentifyCentralizerOrders( norm2A,
62; rootinfo2A_l.labels, rootinfo2A_t.classpos );
Iidentify2A
#I identify 10A
#I identify 22A
#B
#I identify 38A
#I identify 66A
#I identify 6A
I java.lang.StringIndexOutOfBoundsException: Range [17, 16) out of bounds for length 20
#I identify 14A
#I identify 14B
#I identify 42A
#I identify 6B
#I identify 6D
#I span classGAPprompt"&;<span><pan class=GAPinput"> -g; ( SylowSubgroupM2, ))</>
#I identify 30B
#I identify 30A
#I identify 34B
#I identify 34C
[ [ "18A", "18B" ], [ 74, 76 ] ]
gap62; for i in Union( rootinfo2B_t.classpos <<>
62; if IsBound( powerinforec.( fusionlabels[i] ) ) then
62; SetCentralizerOrder( fusionlabels[i],
62; SizesCentralizers( cb2b )[i] );
62; fi;
62; od;
gap62; IdentifyCentralizerOrders( cb2b,
62; rootinfo2B_l.labels, rootinfo2B_t.classpos );
#I identify 30G
#I identify 30H
#I identify 32A
#I identify 32B
#I identify 32C
# identify 32D
#I identify 46A
#I identify 46B
#I identify 56A
#I identify 56B
[ [ "12A", "12D", "12G", "12I", "12L", "12M", "12O", "16A", "16B", "16C",
"16D", "16E", "16F", "20B", "20C", "20F", "20I", "24A", "24B", "24C",
"24D", "24E", "24F", "24G", "24K", "24M", "40A", "40B", "40C", "40D",
"4F", "4G", "8A", "8B", "8C", "8D", "8E", "8F", "8H", "8I", "8L" ],
[ 28, 42, 47, 48, 49, 61, 63, 68, 69, 103, 104, 116, 145, 151, 158, 163,
169, 187, 199, 215, 217, 218, 219, 220, 233, 234, 235, 251, 252, 258,
292, 308, 309, 310, 311, 320, 332, 333, 344, 357, 420 ] ]
gap62; IdentifyCentralizerOrders( norm2C.table,
62; rootinfo2C_l.labels, rootinfo2C_t.classpos );
# C
#I identify 4I
#I identify 10C
#I identify 12T
#I identify 6K
#I identify14C
#I identify 18F
#I identify 20H
#I identify 26A
#I identify 30C
#I identify 6F
#I identify 34A
#I identify 42C
#I identify 52A
[ [ ], [ ] ]
gap62; IdentifyCentralizerOrders( sup_norm2D,
62; rootinfo2D_l.labels, rootinfo2D_t.classpos );
#I identify 2D
#I identify 14E
#I identify 28E
#I identify 4E
#I identify 36C
#I identify 18E
#I identify 12N
#I identify 6J
#I identify 40E
# identify20java.lang.StringIndexOutOfBoundsException: Range [20, 21) out of bounds for length 20
#I identify 10F
#I identify 8G
#I identify 60C
#I identify 30F
#I identify 12F
#I identify 6I
#I identify 8J
#I identify 10E
#I identify 12S
#I identify 4H
#I identify 18D
#I identify 20J
#I identify 4J
#I identify 24H
#I identify 30E
#I identify 6E
#I identify 6H
#I identify 8N
#I identify 12J
#I identify 12P
#I identify 12Q
#I identify 24L
#I identify 8K
#I identify 8M
#I identify 12R
#I identify 16G
#I identify 24N
#I identify 16H
#I identify 24I
#I identify 24J
[ [ ], [ ] ]
</pre>
<div class="p"><!----></div>
<pre>
gap62; IdentifyCentralizerOrders( n3a,
62; rootinfo3A_l.labels, rootinfo3A_t.classpos );;
#I identify 3A
#I identify 15A
#I identify 21A
#I identify 33A
#I identify 39A
gap62; IdentifyCentralizerOrders( n3b,
62; rootinfo3B_l.labels, rootinfo3B_t.lasspos )
#I identify 3B
#I identify 15B
#I identify 27A
#I identify 9A
#I identify 9B
gap62; IdentifyCentralizerOrders( n5a,
62; rootinfo5A_l.labels, rootinfo5A_t.classpos );;
#I identify 5A
#I identify 35A
#I identify 55A
gap62; IdentifyCentralizerOrders( n5b,
62; rootinfo5B_l.labels, rootinfo5B_t.classpos );;
#I identify 5B
#I identify 25A
</pre>
<div class="p"><!----></div>
Let us see which classes of <font size="+0">B</font> are not identified yet.
<div class="p"><!----></div>
<pre>
gap62; Difference( RecNames( powerinforec ), RecNames( Bclassinfo ) );
[ "16D", "16F", "18A", "18B", "7A" ]
</pre>
<div class="p"><!----></div>
For simplicity, we set the centralizer order for <tt>"7A"</tt> by hand.
<div class="p"><!----></div>
<pre>
;("A, ^ *^ * *7^ );
</pre>
<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> 183;3<sup>4</sup> and 648 = 2<sup>3</sup> le='color: green'>183;3<sup>4</sup>, respectively.
We know a class in <tt>cb2b</tt> that fuses into <tt>18A</tt> and
/pre><div>
Thus <tt>18A</tt> must have centralizer order 1296 in <font size="+0">B</font>.
<div class="p"><!----></div>
<pre>
&62;SetCentralizerOrder 18A,1296 ;java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
gap62; SetCentralizerOrder( "18B", 648 );;
</pre
<div class="p"><!----></div>
The cases <tt>"16D"divclass="example">>
<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>,
lassinvariantsjava.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
epart the information
<div class="p"><!----></div>
<pre>
gap62; diff:= Difference( fusionlabels, RecNames( powerinforec,036,46,, , , , ,0, 108 ,, , 0
[ "16DF", "23AB", "30GH", "32AB", "32CD", "46AB", "56AB" ]
gap62; List( diff, x -62; Positions( fusionlabels, x ) );
[ [ 251, 252, 274, 281, 396 ], [ 421, 423 ], [ 393, 395, 445, 447 ],
[ 399, 400 ], [ 403, 404 ], [ 422, 424 ], [ 437, 438 ] ]
gap62; Length( fusionlabels );
448
gap62; NrConjugacyClasses( cb2b );
448
</pre>
<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>
<java.lang.StringIndexOutOfBoundsException: Range [69, 3) out of bounds for length 69
gap62; fusionlabels[421]:= "23A";;
gap62; fusionlabels[423]:= "23B";;
gap62; fusionlabels[399]:= "32A";;
gap62; fusionlabels[400]:= "32B";;
gap62; fusionlabels[403]:= "32C";;
gap62; fusionlabels[404]:= "32D";;
gap62; fusionlabels[437]:= "56A";;
gap62; fusionlabels[438]:= "56B";;
gap62; pos46:= Positions( OrdersClassRepresentatives( cb2b ), 46 );
[ 422, 424 ]
gap62; PowerMap( cb2b, 2 ){ pos46 };
[ 421, 423 ]
gap62; fusionlabels[422]:= "46A";;
gap62; fusionlabels[424]:= "46B";;
</pre>
<div class="p"><!----></div>
Thus we are left with the question about the fusion to the classes with the
<spanclass=GAPprompt"gap;< < =GAPinput> t )]</>
<div class="p"><!----></div>
For the order3321
Galois conjugate classes, and later try to distinguish the two possibilities
for the other pair, for example via induced characters.
<div class="p"><!----></div>
<pre>
gap62; fusionlabels[393]:= "30G";;
gap62; fusionlabels[395]:= "30H";;
</pre>
<div class="p"><!----></div>
<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>
<pre>
62[:="6;
gap62; fusionlabels[252]:= "16F";;
gap62; SetCentralizerOrder( "16D", SizesCentralizers( cb2b )[251] );;
gap62; SetCentralizerOrder( "16F", SizesCentralizers( cb2b )[252] );;
</pre>
<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>
gap62; cb2bfusb:= List( fusionlabels, l -62; Position( Bnames, l ) );;
gap62; Positions( cb2bfusb, fail );
[ 274, 281, 396, 445, 447 ]
gap62; pos:= Positions( fusionlabels, "16DF" );
[ 274, 281, 396 ]
gap62; for i in pos do
&62 cb2bfusb[]=[ 86,88]java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
62; od;
gap62; pos:= Positions( fusionlabels, "30GH" );
445,447]
gap62; for i in pos do
62; cb2bfusb[i]:= [ 143, 144 ];
62; od;
</pre>
<div class="p"><!----></div>
Before we span class="GAPprompt">></span> <span class="GAPinput">until NrMovedPoints( y ) = 3240 - 1080;</span>
we create the character table head for <font size="+0">B</font>.
<div class="p"><!----></div>
<pre>
gap62; bhead:= rec( UnderlyingCharacteristic:= 0,
62; Identifier:= "Bnew" );;
gap62; bhead.SizesCentralizers:= List( Bnames, x -e='color: green'>62;
gap62; bhead.OrdersClassRepresentatives:= List( Bnames,
62; x -62; Bclassinfo.( x )[1] );;
gap62; bhead.ComputedPowerMaps:= [];;
gap62; galoisinfo:= rec(
62; classes:= [ "23A", "23B", "30G", "30H", "31A", "31B", "32A", "32B",
62; "32C", "32D", "34B", "34C", "46A", "46B", "47A", "47B",
62; "56A", "56B" ],
62; partners:= [ "23B", "23A", "30H", "30G", "31B", "31A", "32B", "32A",
&62 32""C, "C, 34""B,"A, 47" "47",
62; "56B", "56A" ],
62; rootsof:= [ -23, -23, -15, -15, -31, -31, 2, 2,
62; -2, -2, 17, 17, -23, -23, -47, -47,
62; 7, 7 ] );;
gap62; galoisinfo.irrats:= List( galoisinfo.rootsof, Sqrt );;
gap62; for p in Filtered( [ 1 .. Maximum( bhead.OrdersClassRepresentatives ) ],
62; IsPrimeInt ) do
62; map:= [ 1 ];
62; for i in [ 2 .. Length( Bnames ) ] do
62; if bhead.OrdersClassRepresentatives[i] = p then
62; map[i]:= 1;
62; elif bhead.OrdersClassRepresentatives[i] mod p = 0 then
62; # The 'p'-th power has smaller order, we know the image java.lang.StringIndexOutOfBoundsException: Range [0, 80) out of bounds for length 0
62; info:= First( powerinforec.( Bnames[i] ), pair -e='color: green'>62; pair[1] = p );
62; map[i]:= Position( Bnames, info[2] );
62; else
62; # The 'p'-th power is a Galois conjugate.
62; pos:= Position( galoisinfo.classes, Bnames[i] );
62; if pos = fail then
62; # The 'i'-th class is rational.
62; map[i]:= i;
62; else
62; # Determine whether the pair gets swapped.
62; irrat:= galoisinfo.irrats[ pos ];
62; if GaloisCyc( irrat, p ) <62; irrat then
62; map[i]:= Position( Bnames, galoisinfo.partners[ pos ] );
62; else
62; map[i]:= i;
&62 fi;
62; fi;
62; fi;
62; od;
62; bhead.ComputedPowerMaps[p]:= map;
62; od;
gap62; ConvertToCharacterTable( bhead<We show that the group <span class"">=O_10-3) P^-(10,)/ thefollowing./
</pre>
<div class="p"><!----></div>
Check the library table of <font size="+0">B</font> against the character table head.
<div class="p"><!----></div>
<pre>
gap62; b:= CharacterTable( "B" );;
gap62; for p in Filtered( [ 2 ..
62; Maximum( OrdersClassRepresentatives( b ) ) ],
62; IsPrimeInt ) do
62; PowerMap( b, p );
62; od;
gap62; ComputedPowerMaps(<d<>For<spanclass="impleMath"span class=S"(35+1)/=61/, <span="SimpleMath>s</span>consists of one subgroup of the type<class"impleMath"SU53 ≅U_53<span./>
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>
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
gap62; Length( maps );
32
gap62; good:= [];;
gap62; for map in maps do
62; ind:= InducedClassFunctionsByFusionMap( cb2b, b, Irr( cb2b ), map );
&62; (ind x&62; xx ) then
62; Add( good, map );
62; fi;
62; od;
gap62; Length( good );
1
gap62; b2b:= CharacterTable( "BM2" );;
gap62; good[1] = GetFusionMap( b2b, b );
true
</pre>
<divclass"">!---><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 unique6886425600/61
<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
</a>
<div class="p"><!----></div>
We assume the following information about the Baby Monster group <font size="+0">B</font>.
< 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 table head 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>
gap62; b:= CharacterTable( "B" );;
gap62; for p in Filtered( [ 2 ..
62; Maximum( OrdersClassRepresentatives( b ) ) ],
62; IsPrimeInt ) do
62; PowerMap( b, p );
62; 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>
<pre>
gap62; irr_atlas:= Irr( b );;
gap62; ResetFilterObj( b, HasIrr );
</pre>
<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 java.lang.StringIndexOutOfBoundsException: Range [91, 20) out of bounds for length 91
a list of characters of <font size="+0">B</font>, and perhaps a first approximation of the
lassquestion
<div class="p"><!----></div>
<pre>
gap62; tryFusion:= function( s, b, ind, initmap )
62; local i, sfusb, poss, good, test, map, indmap, indgood;
62;
62; for i in [ 1 .. Length( ComputedPowerMaps( b ) ) ] do
62; if IsBound( ComputedPowerMaps( b )[i] ) then
62; PowerMap( s, i );
62; fi;
62; od;
62;
62; if initmap = fail then
62; sfusb:= InitFusion( s, b );;
62; else
62; sfusb:= initmap;
62; fi;
62;
62; if not TestConsistencyMaps( ComputedPowerMaps( s ), sfusb,
62; ComputedPowerMaps( b ) ) then
62; Error( "inconsistency in power maps!" );
62; fi;
62;
62; poss:= FusionsAllowedByRestrictions( s, b, Irr( s ), ind, sfusb,
62; rec( decompose:= true, minamb:= 2, maxamb:= 10^4,
62; quick:= false, maxlen:= 10,
62; contained:= ContainedPossibleCharacters ) );
62; indgood:= [];
62; if ForAll( poss, x -62; ForAll( x, IsInt ) ) then
62; # All candidates in 'poss' are unique.
62; # Consider only representatives under the symmetry group of | |