| Quellcodebibliothek Statistik Leitseite products/sources/formale Sprachen/GAP/pkg/ctbllib/htm/ (Algebra von RWTH Aachen Version 4.15.1©) Datei vom 22.4.2025 mit Größe 182 kB |
|
Quelle ctblbm.htm Sprache: HTML |
|||||||||||
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
"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: -0.8ex; margin-bottom: -1ex;} td div.norm {line-height:normal;} 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;} --> <title>Some steps in the verification of the ordinary character table of the Baby Monster group</ <h1 align="center">Some steps in the verification of the ordinary character table of the Baby Mo <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">A <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_ >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_ >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_s >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 charac of the Baby Monster group <font size="+0">B</font>. Here we collect, in the form of an explicit <font face="helvetica">GAP</font> [<a href="#GAP" name="CITEGAP">GAP2 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< At this point, we know that the three matrix groups that are used later on are in fact representations of the group <font size="+0">B</font>, w. r. t. compatible (standard) generators. <div class="p"><!----></div> Section <a href="#invs_B">3</a> turns the class invariants and the power map information from [<a href="#BMverify" name="CITEBMverify">BMW20</a>,Section 4] into a <font fa that identifies the class label of a given word in terms of the given standard generators. <div class="p"><!----></div> Section <a href="#centralizers_prime">4</a> shows part of the computations described in [<a href="#BMverify" name="CITEBMverify">BMW20</ <div class="p"><!----></div> Section <a href="#table_c2b">5</a> shows the computation of the character table of an involution centralizer of type 2<sup>1+22</sup>.Co<sub>2</sub> in <font size="+0">B</font>. <div class="p"><!----></div> Section <a href="#sect:classes">6</a> shows how the conjugacy classes, the corresponding centralizer orders, and the power maps of <font size="+0">B</font> are determined. <div class="p"><!----></div> In Section <a href="#sect:classes">6</a>, we put these pieces together and write down the list of class representatives of <font size="+0">B</font>, together with their centralizer orders and power maps. <div class="p"><!----></div> With this information and with the (already verified) character tables of some known subgroups of <font size="+0">B</font>, computing the irreducible characters of <font size="+0">B</font> is then easy; this corresponds to [<a href="#BMverify" name="CITEBMverify">BMW20</a>,Section 7], and is done in Section <a href="#sect:irreducibles">7</a>. <div class="p"><!----></div> We will use the <font face="helvetica">GAP</font> Character Table Library and the interface to the A<font size="-2">TLAS</font> of Group Representations [<a href="#AGRv3" thus we load these <font face="helvetica">GAP</font> packages. <div class="p"><!----></div> <pre> gap> LoadPackage( "ctbllib", false ); true gap> LoadPackage( "atlasrep", false ); true </pre> <div class="p"><!----></div> The <font face="helvetica">MAGMA</font> [<a href="#Magma" name="CITEMagma">BCP97</a>] system wi for computing a character table and for several conjugacy tests. If the following command returns <tt>false</tt> then these steps will not work. <div class="p"><!----></div> <pre> gap> CTblLib.IsMagmaAvailable(); true </pre> <div class="p"><!----></div> <h2><a name="tth_sEc2"> 2</a> Verification of a presentation for <font size="+0">B</font></h2><a name="pres_B"> </a> <div class="p"><!----></div> We show the computations that are described in [<a href="#BMverify" name="CITEBMverify">BMW2 First we create the free generators and relators of the presentation. <div class="p"><!----></div> <pre> gap> F:= FreeGroup( List( "abcdefghijk", x -> [ x ] ) );; gap> gens:= GeneratorsOfGroup( F );; gap> rels:= List( gens, x -> x^2 );; gap> ord3pairs:= List( [ 1 .. 7 ], i -> [ i, i+1 ] ); [ [ 1, 2 ], [ 2, 3 ], [ 3, 4 ], [ 4, 5 ], [ 5, 6 ], [ 6, 7 ], [ 7, 8 ] ] gap> Append( ord3pairs, [ [ 5, 9 ], [ 9, 10 ], [ 10, 11 ] ] ); gap> for pair in ord3pairs do > Add( rels, ( gens[ pair[1] ] * gens[ pair[2] ] )^3 ); > od; gap> for i in [ 1 .. 11 ] do > for j in [ i+1 .. 11 ] do > if not [ i, j ] in ord3pairs then > Add( rels, ( gens[i] * gens[j] )^2 ); > fi; > od; > od; gap> Add( rels, Product( gens{ [ 5, 4, 3, 5, 6, 7, 5, 9, 10 ] } )^10 ); </pre> <div class="p"><!----></div> We do not call <tt>FreeGroup( 11 )</tt> because later on we want to translate the relators into straight line programs, and we can use <tt>StraightLineProgram</tt> with first argument a string only if no generator name is a prefix of another generator name. <div class="p"><!----></div> <pre> gap> gensstrings:= List( gens, String );; gap> relsslps:= List( List( rels, String ), > x -> StraightLineProgram( x, gensstrings ) );; </pre> <div class="p"><!----></div> Next we write a straight line program that computes the 11 generators t<sub>1</sub>, …, t<sub>11</sub>, following the steps shown in [<a href="#BMverify" name="CITEBMverify">BMW20</a>,Table 1]. We start with the two standard generators a and b, say, in the slots 1 and 2, and compute expressions for the subsequent slots. The product a b will be in position 3, its 5th power (a b)<sup>5</sup> (which will be needed later on) in position 4, the power (a b)<sup>15</sup> in position 5, and d = (a b)<sup>15</sup> b in position 6. The generators t<sub>11</sub> = d<sup>19</sup> gets stored in position 7. <div class="p"><!----></div> <pre> gap> slp:= [ [ 1, 1, 2, 1 ], [ 3, 5 ], [ 4, 3 ], [ 5, 1, 2, 1 ] ];; gap> resultpos:= [];; gap> Add( slp, [ 6, 19 ] ); gap> 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> gap> Append( slp, [ [ 1, 1, 7, 1 ], [ 8, 3 ] ] ); gap> Append( slp, [ [ 6, 3 ], [ 9, 1, 10, 1 ], [ 11, 10 ], > [ 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>(</s (position 24), ... <div class="p"><!----></div> <pre> gap> # 14: e*c, 15: (e*c)^2, 16: (e*c)^3, 17: (e*c)^4, 18: (e*c)^6 gap> Append( slp, [ [ 13, 1, 9, 1 ], [ 14, 2 ], [ 14, 1, 15, 1 ], > [ 15, 2 ], [ 16, 2 ] ] ); gap> # 19: e*c*e, 20: e*c*e^2*c gap> Append( slp, [ [ 14, 1, 13, 1 ], [ 19, 1, 14, 1 ] ] ); gap> # 21: (e*c)^6*c*(e*c)^3, 22: ((e*c)^6*c*(e*c)^3)^2*e*c*e^2*c gap> Append( slp, [ [ 18, 1, 9, 1, 16, 1 ], [ 21, 2, 20, 1 ] ] ); gap> # 23: (((e*c)^6*c*(e*c)^3)^2*e*c*e^2*c)^5 gap> Append( slp, [ [ 22, 5 ] ] ); gap> # 24: t1 = f = ((((e*c)^6*c*(e*c)^3)^2*e*c*e^2*c)^5)^((e*c)^4) gap> Append( slp, [ [ 17, -1, 23, 1, 17, 1 ] ] ); gap> resultpos[1]:= Length( slp ) + 2;; </pre> <div class="p"><!----></div> ... g = ((e c)<sup>8</sup> c (e c)<sup>3</sup> )<sup>(e c e<sup>2</sup> c)<sup>2</sup></sup> (position 27) and t<sub>2</sub> = f<sup>g<sup>f</sup></sup> (position 30), ... <div class="p"><!----></div> <pre> gap> # 25: (e*c)^8*c*(e*c)^3, 26: (e*c*e^2*c)^2 gap> Append( slp, [ [ 15, 1, 21, 1 ], [ 20, 2 ] ] ); gap> # 27: g = ((e*c)^8*c*(e*c)^3)^((e*c*e^2*c)^2) gap> Append( slp, [ [ 26, -1, 25, 1, 26, 1 ] ] ); gap> # 28: g f, 29: g^-1, 30: t2 = f^{{g f}} gap> Append( slp, [ [ 27, 1, 24, 1 ], [ 27, -1 ], > [ 28, -1, 24, 1, 28, 1 ] ] ); gap> 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<sub>6</sub> = f<sup>g f g<sup>4</sup></sup>, 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> gap> # 31: t3 = f^( g * f * g ) gap> Append( slp, [ [ 29, 1, 30, 1, 27, 1 ] ] ); gap> resultpos[3]:= Length( slp ) + 2;; gap> # 32: t4 = f^( g * f * g^2 ) gap> Append( slp, [ [ 29, 1, 31, 1, 27, 1 ] ] ); gap> resultpos[4]:= Length( slp ) + 2;; gap> # 33: t5 = f^( g * f * g^3 ) gap> Append( slp, [ [ 29, 1, 32, 1, 27, 1 ] ] ); gap> resultpos[5]:= Length( slp ) + 2;; gap> # 34: t6 = f^( g * f * g^4 ) gap> Append( slp, [ [ 29, 1, 33, 1, 27, 1 ] ] ); gap> resultpos[6]:= Length( slp ) + 2;; gap> # 35: t7 = f^( g * f * g^5 ) gap> Append( slp, [ [ 29, 1, 34, 1, 27, 1 ] ] ); gap> resultpos[7]:= Length( slp ) + 2;; gap> # 36: t8 = f^( g * f * g^6 ) gap> Append( slp, [ [ 29, 1, 35, 1, 27, 1 ] ] ); gap> resultpos[8]:= Length( slp ) + 2;; </pre> <div class="p"><!----></div> ... p = ((a b)<sup>5</sup> t<sub>11</sub> (a b)<sup>−5</sup> t<sub>1</sub> (a b)<sup>5</sup>)<sup>−1</sup> (position 3 and i = d<sup>p</sup> (position 41), ... <div class="p"><!----></div> <pre> gap> # 37: (a*b)^5*t11*(a*b)^-5*t1*(a*b)^5, gap> # 38: p = ((a*b)^5*t11*(a*b)^-5*t1*(a*b)^5)^-1 gap> Append( slp, [ [ 4, 1, 7, 1, 4, -1, 24, 1, 4, 1 ], [ 37, -1 ] ] ); gap> # 39: p^-1, 40: h = c^p, 41: i = d^p gap> Append( slp, [ [ 38, -1 ], [ 39, 1, 9, 1, 38, 1 ], > [ 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> gap> # 42: i^2, 43: t5^(i^2), 44: t3*t4 gap> Append( slp, [ [ 41, 2 ], [ 42, -1, 33, 1, 42, 1 ], > [ 31, 1, 32, 1 ] ] ); gap> # 45: j = Comm( t5^( i^2 ), t3*t4 ) gap> Append( slp, [ [ 43, -1, 44, -1, 43, 1, 44, 1 ] ] ); gap> # 46: i^3, 47: t5^(i^5), 48: k = Comm( t5^(i^5), t3*t4 ) gap> Append( slp, [ [ 41, 1, 42, 1 ], [ 46, -1, 43, 1, 46, 1 ], > [ 47, -1, 44, -1, 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</s ... <div class="p"><!----></div> <pre> gap> # 49: t6*t7, 50: (t6*t7)^-1, 51: j*k, 52: k*j, 53: t8^(j*k) gap> Append( slp, [ [ 34, 1, 35, 1 ], [ 49, -1 ], [ 45, 1, 48, 1 ], > [ 48, 1, 45, 1 ], [ 51, -1, 36, 1, 51, 1 ] ] ); gap> # 54: Comm( t8^(j*k), t6*t7), 55: t8^(k*j) gap> Append( slp, [ [ 53, -1, 50, 1, 53, 1, 49, 1 ] ] ); gap> Append( slp, [ [ 52, -1, 36, 1, 52, 1 ] ] ); gap> # 56: Comm( t8^(k*j), t6*t7 ) gap> Append( slp, [ [ 55, -1, 50, 1, 55, 1, 49, 1 ] ] ); gap> # 57: l = Comm( t8^(j*k), t6*t7 ) * Comm( t8^(k*j), t6*t7 ) gap> 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> gap> # 58: (j*k)^3, 59: (j*k)^-3, 60: t8^((j*k)^4) gap> Append( slp, [ [ 51, 3 ], [ 58, -1 ], [ 59, 1, 53, 1, 58, 1 ] ] ); gap> # 61: l3 = Comm( t8^((j*k)^4), t6*t7 ) gap> Append( slp, [ [ 60, -1, 50, 1, 60, 1, 49, 1 ] ] ); gap> # 62: l4 = t8^((j*k)^3*k*j) gap> Append( slp, [ [ 52, -1, 59, 1, 36, 1, 58, 1, 52, 1 ] ] ); gap> # 63: l3*l4, 64: l*l3*l4 gap> Append( slp, [ [ 61, 1, 62, 1 ], [ 57, 1, 63, 1 ] ] ); gap> # 65: l5:= ( l * l3 * l4 )^3 * l3 * l4;; gap> 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> (position 69), and 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). <div class="p"><!----></div> <pre> gap> # 66: l5^4, 67: m2 = l4^(l5^4) gap> Append( slp, [ [ 65, 4 ], [ 66, -1, 62, 1, 66, 1 ] ] ); gap> # 68: m3 = m2^l5 gap> Append( slp, [ [ 65, -1, 67, 1, 65, 1 ] ] ); gap> # 69: t10 = m3*m2*l4*m2*m3 gap> Append( slp, [ [ 68, 1, 67, 1, 62, 1, 67, 1, 68, 1 ] ] ); gap> resultpos[10]:= Length( slp ) + 2;; gap> # 70: t9 = l4*m2*t10*m2*l4 gap> Append( slp, [ [ 62, 1, 67, 1, 69, 1, 67, 1, 62, 1 ] ] ); gap> 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> gap> Add( slp, List( resultpos, x -> [ x, 1 ] ) ); gap> slp:= StraightLineProgram( slp, 2 ); <straight line program> </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> gap> b_2:= AtlasGroup( "B", Characteristic, 2, Dimension, 4370 );; gap> b_3:= AtlasGroup( "B", Characteristic, 3, Dimension, 4371 );; gap> b_5:= AtlasGroup( "B", Characteristic, 5, Dimension, 4371 );; gap> gens_2:= GeneratorsOfGroup( b_2 );; gap> gens_3:= GeneratorsOfGroup( b_3 );; gap> gens_5:= GeneratorsOfGroup( b_5 );; gap> res_2:= ResultOfStraightLineProgram( slp, gens_2 );; gap> ForAll( relsslps, > prg -> IsOne( ResultOfStraightLineProgram( prg, res_2 ) ) ); true gap> res_3:= ResultOfStraightLineProgram( slp, gens_3 );; gap> ForAll( relsslps, > prg -> IsOne( ResultOfStraightLineProgram( prg, res_3 ) ) ); true gap> res_5:= ResultOfStraightLineProgram( slp, gens_5 );; gap> ForAll( relsslps, > prg -> 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 a′, b′ stated in [<a href="#BMverify" name="CITEBMverify">BMW20</a>,Section 4.4], first the elements r and s (positions 12 and 13), ... <div class="p"><!----></div> <pre> gap> revslp:= [ Concatenation( List( [ 1 .. 8 ], i -> [ i, 1 ] ) ), > Concatenation( List( [ 5, 9, 10, 11 ], i -> [ i, 1 ] ) ) ];; </pre> <div class="p"><!----></div> ... and then a′ = (r<sup>7</sup> s)<sup>15</sup> (position 15) and b′ = (t<sub>1</sub> t<sub>2</sub>)<sup>(sr)<sup>1</sup>0</sup> (position 20). <div class="p"><!----></div> <pre> gap> Append( revslp, [ [ 12, 7, 13, 1 ], [ 14, 15 ], [ 13, 1, 12, 1 ], > [ 16, 10 ], [ 17, -1 ], [ 1, 1, 2, 1 ], > [ 18, 1, 19, 1, 17, 1 ] ] ); </pre> <div class="p"><!----></div> Again, we specify the outputs and create the straight line program object. <div class="p"><!----></div> <pre> gap> Add( revslp, List( [ 15, 20 ], x -> [ x, 1 ] ) ); gap> revslp:= StraightLineProgram( revslp, 11 ); <straight line program> </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 a′, b′ of matrices that is simultaneously conjugate to the original matrices a, b. Once this is established, we know that the group 〈a, b 〉 is equal to the group generated by the 11 generators, and that mapping the original generators of any of the three representations to the original generators of another one defines a group isomorphism. <div class="p"><!----></div> In order to show the conjugacy property, we use that the nullspace of w(a, b) = a<sup>0</sup> + a b + b a + b is 1-dimensional, in all three cases. <div class="p"><!----></div> <pre> gap> a:= gens_2[1];; b:= gens_2[2];; gap> w:= One( a ) + b*a + a*b + b;; gap> nsp_2:= NullspaceMat( w );; Length( nsp_2 ); 1 gap> a:= gens_3[1];; b:= gens_3[2];; gap> w:= One( a ) + b*a + a*b + b;; gap> nsp_3:= NullspaceMat( w );; Length( nsp_3 ); 1 gap> a:= gens_5[1];; b:= gens_5[2];; gap> w:= One( a ) + b*a + a*b + b;; gap> 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 Meat we provide it here.) <div class="p"><!----></div> <pre> gap> StdBasis:= function( F, mats, seed ) > local n, b, mb, v, m, new; > > n:= Length( mats[1] ); > b:= [ seed ]; > mb:= MutableBasis( F, b ); > for v in b do > for m in mats do > new:= v * m; > if not IsContainedInSpan( mb, new ) then > Add( b, new ); > if Length( b ) = n then > break; > fi; > CloseMutableBasis( mb, new ); > fi; > od; > if Length( b ) = n then > break; > fi; > od; > return b; > end;; </pre> <div class="p"><!----></div> <div class="p"><!----></div> All we have to check is that the matrices of the linear mappings a, b w. r. t. their standard basis and a generating vector of the nullspace of w(a, b) are equal to the matrices of a′, b′ w. r. t. their standard basis and a generating vector of the nullspace of w(a′, b′). <div class="p"><!----></div> We verify this in characteristic 2, ... <div class="p"><!----></div> <pre> gap> stdbas_2:= StdBasis( GF(2), gens_2, nsp_2[1] );; gap> inv:= stdbas_2^-1;; gap> stdgens_2:= List( gens_2, m -> stdbas_2 * m * inv );; gap> newgens_2:= ResultOfStraightLineProgram( revslp, res_2 );; gap> aa:= newgens_2[1];; bb:= newgens_2[2];; gap> neww:= One( aa ) + bb * aa + aa * bb + bb;; gap> newnsp_2:= NullspaceMat( neww );; Length( newnsp_2 ); 1 gap> newstdbas_2:= StdBasis( GF(2), newgens_2, newnsp_2[1] );; gap> inv:= newstdbas_2^-1;; gap> newstdgens_2:= List( newgens_2, m -> newstdbas_2 * m * inv );; gap> stdgens_2 = newstdgens_2; true </pre> <div class="p"><!----></div> ... in characteristic 3, ... <div class="p"><!----></div> <pre> gap> stdbas_3:= StdBasis( GF(3), gens_3, nsp_3[1] );; gap> inv:= stdbas_3^-1;; gap> stdgens_3:= List( gens_3, m -> stdbas_3 * m * inv );; gap> newgens_3:= ResultOfStraightLineProgram( revslp, res_3 );; gap> aa:= newgens_3[1];; bb:= newgens_3[2];; gap> neww:= One( aa ) + bb * aa + aa * bb + bb;; gap> newnsp_3:= NullspaceMat( neww );; Length( newnsp_3 ); 1 gap> newstdbas_3:= StdBasis( GF(3), newgens_3, newnsp_3[1] );; gap> inv:= newstdbas_3^-1;; gap> newstdgens_3:= List( newgens_3, m -> newstdbas_3 * m * inv );; gap> stdgens_3 = newstdgens_3; true </pre> <div class="p"><!----></div> ... and in characteristic 5. <div class="p"><!----></div> <pre> gap> stdbas_5:= StdBasis( GF(5), gens_5, nsp_5[1] );; gap> inv:= stdbas_5^-1;; gap> stdgens_5:= List( gens_5, m -> stdbas_5 * m * inv );; gap> newgens_5:= ResultOfStraightLineProgram( revslp, res_5 );; gap> aa:= newgens_5[1];; bb:= newgens_5[2];; gap> neww:= One( aa ) + bb * aa + aa * bb + bb;; gap> newnsp_5:= NullspaceMat( neww );; Length( newnsp_5 ); 1 gap> newstdbas_5:= StdBasis( GF(5), newgens_5, newnsp_5[1] );; gap> inv:= newstdbas_5^-1;; gap> newstdgens_5:= List( newgens_5, m -> newstdbas_5 * m * inv );; gap> 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_ </a> <div class="p"><!----></div> The function <tt>IdentifyClassName</tt> shown below implements the invariants defined in [<a href="#BMverify" name="CITEBMverify">BMW20</a>,Sec that distinguish 183 conjugacy classes of <font size="+0">B</font>. <div class="p"><!----></div> Its input can be as follows. <div class="p"><!----></div> <ul> <li> Three matrices <tt>data2</tt>, <tt>data3</tt>, <tt>data5</tt>, representing an element of <font size="+0">B</font> in the given three matrix representations, in characteristics 2, 3, and 5, respectively; in this case, the argument <tt>slp</tt> should be <tt>fail</tt>. <div class="p"><!----></div> </li> <li> Lists <tt>data2</tt>, <tt>data3</tt>, <tt>data5</tt> of standard generators of <font size="+0">B</font> in the given three matrix representations such that <tt>slp</tt> is a straight line program that takes these generators as inputs, and computes the element in question. <div class="p"><!----></div> </li> </ul> <div class="p"><!----></div> In both cases, the argument <tt>order</tt> can be either <tt>fail</tt> or the order of the element. A known order allows us to omit any computation with matrices in several cases. <div class="p"><!----></div> The output is the label for the union of conjugacy classes as defined in [<a href="#BMverify" name="CITEBMverify">BMW20</a>,Table 2], except that labels containing <em>two</em> letters are returned in those cases that will later turn out to describe two Galois conjugate classes -these are <tt>"23AB"</tt>, <tt>"30GH"</tt>, <tt>"31AB"</tt>, <tt>"32AB"</tt>, <tt>"32CD"</tt>, <tt>"34BC"</tt>, <tt>"46AB"</tt>, <tt>"47AB"</tt>, <tt>"56AB"</tt>- and in the case of <tt>"16DF"</tt> where we have no invariant that distinguishes two classes that are not Galois conjugate. <div class="p"><!----></div> <pre> gap> IdentifyClassName:= function( data2, data3, data5, slp, order ) > local data, mats, elm, cand, nams, trace, pos, one, rank; > > data:= [ , data2, data3,, data5 ]; > mats:= []; > > elm:= function( p ) > if not IsBound( mats[p] ) then > if slp = fail then > mats[p]:= data[p]; > else > mats[p]:= ResultOfStraightLineProgram( slp, data[p] ); > fi; > fi; > return mats[p]; > end; > > if order = fail then > order:= Order( elm(2) ); > fi; > > # The element order suffices in certain cases. > if order in [ 23, 31, 46, 47, 56 ] then > # There are two Galois conjugate classes of elements of this order. > return Concatenation( String( order ), "AB" ); > elif order in [ 1, 7, 11, 13, 17, 19, 21, 25, 27, 33, 35, 38, 39, > 44, 47, 52, 55, 66, 70 ] then > # There is exactly one conjugacy class of elements of this order. > return Concatenation( String( order ), "A" ); > fi; > > if order in [ 3, 5, 9, 15 ] then > # The trace in the 2-modular representation suffices. > cand:= [ [3,1], [3,0], [5,0], [5,1], [9,0], [9,1], [15,0], [15,1] ]; > nams:= [ "3A", "3B", "5A", "5B", "9A", "9B", "15A", "15B" ]; > trace:= Int( TraceMat( elm(2) ) ); > return nams[ Position( cand, [ order, trace ] ) ]; > elif order mod 4 = 2 then > # Compute the rank of 1 + x. > cand:= [ [ 2, 1860 ], [ 2, 2048 ], [ 2, 2158 ], [ 2, 2168 ], > [ 6, 3486 ], [ 6, 3510 ], [ 6, 3566 ], [ 6, 3534 ], > [ 6, 3606 ], [ 6, 3604 ], [ 6, 3596 ], [ 6, 3610 ], > [ 6, 3636 ], [ 6, 3638 ], [ 6, 3634 ], > [ 10, 3860 ], [ 10, 3896 ], [ 10, 3918 ], [ 10, 3908 ], > [ 10, 3920 ], [ 10, 3932 ], > [ 14, 3996 ], [ 14, 4008 ], [ 14, 4048 ], [ 14,4034 ], > [ 14, 4052 ], > [ 18, 4088 ], [ 18, 4090 ], [ 18, 4110 ], [ 18, 4124 ], > [ 18, 4128 ], [ 18, 4122 ], > [ 22, 4140 ], [ 22, 4158 ], > [ 26, 4198 ], [ 26, 4176 ], > [ 30, 4190 ], [ 30, 4212 ], [ 30, 4206 ], [ 30, 4214 ], > [ 30, 4224 ], [ 30, 4216 ], > [ 34, 4238 ], [ 34, 4220 ], > [ 42, 4242 ], [ 42, 4258 ] ]; > nams:= [ "2A", "2B", "2C", "2D", > "6A", "6B", "6C", "6D", "6E", "6F", > "6G", "6H", "6I", "6J", "6K", > "10A", "10B", "10C", "10D", "10E", "10F", > "14A", "14B", "14C", "14D", "14E", > "18A", "18B", "18C", "18D", "18E", "18F", > "22A", "22B", > "26A", "26B", > "30AB", "30C", "30D", "30E", "30F", "30GH", > "34A", "34BC", > "42AB", "42C" ]; > one:= elm(2)^0; > rank:= RankMat( elm(2) + one ); > pos:= Position( cand, [ order, rank ] ); > if nams[ pos ] = "30AB" then > rank:= RankMat( elm(2)^5 + one ); > if rank = 3510 then return "30A"; > elif rank = 3486 then return "30B"; > else Error( "wrong rank" ); > fi; > elif nams[ pos ] = "42AB" then > rank:= RankMat( elm(2)^3 + one ); > if rank = 3996 then return "42A"; > elif rank = 4008 then return "42B"; > else Error( "wrong rank" ); > fi; > else > return nams[ pos ]; > fi; > elif order in [ 36, 60 ] then > cand:= [ [36,4226],[36,4238],[36,4248],[60,4280],[60,4286],[60,4296] ]; > nams:= [ "36A", "36B", "36C", "60A", "60B", "60C" ]; > one:= elm(2)^0; > rank:= RankMat( elm(2) + one ); > return nams[ Position( cand, [ order, rank ] ) ]; > elif order = 28 then > one:= elm(2)^0; > rank:= RankMat( elm(2) + one ); > trace:= Int( TraceMat( elm(3)^7 ) ); > if rank = 4188 then # 28A or 28C > if trace = 0 then return "28A"; > elif trace = 1 then return "28C"; > else Error( "wrong trace" ); > fi; > elif rank = 4200 then # 28B or 28D > if trace = 1 then return "28B"; > elif trace = 0 then return "28D"; > else Error( "wrong trace" ); > fi; > elif rank = 4210 then return "28E"; > else Error( "wrong rank" ); > fi; > elif order = 32 then > trace:= Int( TraceMat( elm(3)^2 ) ); > if trace = 2 then return "32AB"; > elif trace = 0 then return "32CD"; > else Error( "wrong trace" ); > fi; > elif order = 40 then > one:= elm(2)^0; > rank:= RankMat( elm(2) + one ); > if rank = 4242 then # 40A or 40B 0r 40C > trace:= Int( TraceMat( elm(3) ) ); > if trace = 0 then return "40A"; > elif trace = 1 then return "40B"; > else return "40C"; > fi; > elif rank = 4250 then return "40D"; > elif rank = 4258 then return "40E"; > else Error( "wrong rank" ); > fi; > elif order = 48 then > trace:= Int( TraceMat( elm(3) ) ); > if trace = 0 then return "48A"; > elif trace = 1 then return "48B"; > else Error( "wrong trace" ); > fi; > elif order in [ 4, 8 ] then > cand:= [ [4,3114],[4,3192],[4,3256],[4,3202],[4,3204],[4,3266], > [4,3264],[8,3774],[8,3738],[8,3778],[8,3780],[8,3810], > [8,3786],[8,3812],[8,3818] ]; > nams:= [ "4A-B", "4C-D", "4E", "4F", "4G", "4H-J", "4I", > "8A", "8B-C-E", "8D", "8F-H", "8G", "8I-L", "8J", "8K-M-N" ]; > one:= elm(2)^0; > rank:= RankMat( elm(2) + one ); > pos:= Position( cand, [ order, rank ] ); > if not '-' in nams[ pos ] then > return nams[ pos ]; > elif order = 4 then > trace:= Int( TraceMat( elm(3) ) ); > if trace = 0 then > if nams[ pos ] = "4A-B" then return "4B"; > elif nams[ pos ] = "4C-D" then return "4D"; > else return "4H"; > fi; > elif trace = 1 then > if nams[ pos ] = "4A-B" then return "4A"; > elif nams[ pos ] = "4C-D" then return "4C"; > else return "4J"; > fi; > else > Error( "wrong trace" ); > fi; > elif order = 8 then > if nams[ pos ] = "8B-C-E" then > trace:= Int( TraceMat( elm(3) ) ); > if trace = 1 then return "8B"; > elif trace = 0 then return "8C"; > else return "8E"; > fi; > elif nams[ pos ] = "8F-H" then > rank:= RankMat( ( elm(2) + one )^3 ); > if rank = 2619 then return "8F"; > elif rank = 2620 then return "8H"; > else Error( "wrong rank" ); > fi; > elif nams[ pos ] = "8I-L" then > rank:= RankMat( ( elm(2) + one )^2 ); > if rank = 3202 then return "8I"; > elif rank = 3204 then return "8L"; > else Error( "wrong rank" ); > fi; > else # 8K-M-N > rank:= RankMat( ( elm(2) + one )^3 ); > if rank = 2714 then # 8K-M > trace:= Int( TraceMat( elm(3) ) ); > if trace = 1 then return "8K"; > elif trace = 2 then return "8M"; > else Error( "wrong trace" ); > fi; > elif rank = 2717 then return "8N"; > else Error( "wrong rank" ); > fi; > fi; > fi; > elif order in [ 12, 24 ] then > cand:= [ [12,3936],[12,3942],[12,3958],[12,3996],[12,3962],[12,3964], > [12,3986],[12,3978],[12,3966],[12,4000],[12,3982],[12,3988], > [12,4002],[12,4004],[24,4152],[24,4164],[24,4170],[24,4182], > [24,4176],[24,4178],[24,4174],[24,4186] ]; > nams:= [ "12A-C-D", "12B", "12E", "12F", "12G-H", "12I", "12J", > "12K-M", "12L", "12N", "12O", "12P", "12Q-R-T", "12S", > "24A-B-C-D", "24E-G", "24F", "24H", "24I-M", "24J", "24K", > "24L-N" ]; > one:= elm(2)^0; > rank:= RankMat( elm(2) + one ); > pos:= Position( cand, [ order, rank ] ); > if not '-' in nams[ pos ] then > return nams[ pos ]; > elif order = 12 then > if nams[ pos ] = "12A-C-D" then > trace:= Int( TraceMat( elm(5) ) ); > if trace = 3 then return "12A"; > elif trace = 4 then return "12C"; > elif trace = 1 then return "12D"; > else Error( "wrong trace" ); > fi; > else > trace:= Int( TraceMat( elm(3) ) ); > if trace = 0 then > if nams[ pos ] = "12G-H" then return "12H"; > elif nams[ pos ] = "12K-M" then return "12K"; > else return "12Q"; # 12Q-R-T > fi; > elif trace = 1 then > if nams[ pos ] = "12G-H" then return "12G"; > elif nams[ pos ] = "12K-M" then return "12M"; > else return "12R"; # 12Q-R-T > fi; > elif nams[ pos ] = "12Q-R-T" then > return "12T"; > else > Error( "wrong trace" ); > fi; > fi; > elif order = 24 then > if nams[ pos ] = "24I-M" then > rank:= RankMat( elm(2)^2 + one ); > if rank = 3986 then return "24I"; > elif rank = 3982 then return "24M"; > else Error( "wrong rank" ); > fi; > elif nams[ pos ] = "24E-G" then > rank:= RankMat( elm(2)^3 + one ); > if rank = 3774 then return "24E"; > elif rank = 3778 then return "24G"; > else Error( "wrong rank" ); > fi; > elif nams[ pos ] = "24L-N" then > trace:= Int( TraceMat( elm(3) ) ); > if trace = 1 then return "24L"; > elif trace = 2 then return "24N"; > else Error( "wrong trace" ); > fi; > else # 24A-B-C-D" > trace:= Int( TraceMat( elm(5) ) ); > if trace = 3 then return "24A"; > elif trace = 0 then return "24B"; > elif trace = 2 then return "24C"; > elif trace = 1 then return "24D"; > else Error( "wrong trace" ); > fi; > fi; > fi; > elif order in [ 16, 20 ] then > cand:= [ [ 16, 4072 ], [ 16, 4074 ], [ 16, 4094 ], > [ 20, 4114 ], [ 20, 4128 ], [ 20, 4132 ], [ 20, 4148 ], > [ 20, 4144 ], [ 20, 4138 ], [ 20, 4150 ] ]; > nams:= [ "16A-B", "16C-D-E-F", "16G-H", > "20A-B-C-D", "20E", "20F", "20G", "20H", "20I", "20J" ]; > one:= elm(2)^0; > rank:= RankMat( elm(2) + one ); > pos:= Position( cand, [ order, rank ] ); > if not '-' in nams[ pos ] then > return nams[ pos ]; > elif order = 20 then > rank:= RankMat( elm(2)^2 + one ); > if rank = 3908 then return "20B"; > elif rank <> 3896 then Error( "wrong rank" ); > else > trace:= Int( TraceMat( elm(3) ) ); > if trace = 2 then return "20A"; > elif trace = 0 then return "20C"; > elif trace = 1 then return "20D"; > else Error( "wrong trace" ); > fi; > fi; > else # order = 16 > if nams[ pos ] = "16A-B" then > trace:= Int( TraceMat( elm(3) ) ); > if trace = 0 then return "16A"; > elif trace = 1 then return "16B"; > else Error( "wrong trace" ); > fi; > elif nams[ pos ] = "16G-H" then > trace:= Int( TraceMat( elm(3)^2 ) ); > if trace = 1 then return "16G"; > elif trace = 2 then return "16H"; > else Error( "wrong trace" ); > fi; > else # 16C-D-E-F > trace:= Int( TraceMat( elm(3) ) ); > if trace = 0 then # We cannot distinguish 16D and 16F. > return "16DF"; > elif trace = 2 then # 16C-E > one:= elm(2)^0; > rank:= RankMat( elm(2)^2 + one ); > if rank = 3780 then return "16C"; > elif rank = 3778 then return "16E"; > else Error( "wrong rank" ); > fi; > else > Error( "wrong trace" ); > fi; > fi; > fi; > else Error( "wrong element order" ); > fi; > end;; </pre> <div class="p"><!----></div> Elements of <font size="+0">B</font> to which the labels belong can be generated as follows. The straight line program <tt>"BG1-cycW1"</tt> from [<a href="#AGRv3" name="CITEAGRv3">WWT<sup>+< computes generators of the maximally cyclic subgroups of <font size="+0">B</font>. <div class="p"><!----></div> <pre> gap> cycprg:= AtlasProgram( "B", "cyclic" );; gap> cycprg.identifier; [ "B", "BG1-cycW1", 1 ] gap> 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", "30G-H", "31A-B", "32A-B", "32C-D", "34A", "34BC", "36A", "36B", "36C", "38A", "39A", "40A", "40B", "40C", "40D", "40E", "42A", "42B", "42C", "44A", "46AB", "47AB", "48A", "48B", "52A", "55A", "56AB", "60A", "60B", "60C", "66A", "70A" ] </pre> <div class="p"><!----></div> The remaining representatives are obtained as suitable powers of them. The following list encodes the definition of these powers, see [<a href="#BMverify" name="CITEBMverify">BMW20</a>,Table 2]. <div class="p"><!----></div> <pre> gap> DefinitionsViaPowerMaps:= [ > [ "70A", 2, "35A" ], [ "66A", 2, "33A" ], [ "60A", 2, "30D" ], > [ "60C", 2, "30F" ], [ "56AB", 2, "28B" ], [ "52A", 2, "26A" ], > [ "48B", 2, "24G" ], [ "46AB", 2, "23AB" ], [ "44A", 2, "22B" ], > [ "66A", 3, "22A" ], [ "42C", 2, "21A" ], [ "40E", 2, "20G" ], > [ "40D", 2, "20F" ], [ "60B", 3, "20E" ], [ "60A", 3, "20A" ], > [ "40C", 2, "20D" ], [ "38A", 2, "19A" ], [ "36C", 2, "18E" ], > [ "36B", 2, "18C" ], [ "34A", 2, "17A" ], [ "32CD", 2, "16DF" ], > [ "32AB", 2, "16C" ], [ "48B", 3, "16B" ], [ "48A", 3, "16A" ], > [ "30F", 2, "15B" ], [ "30A", 2, "15A" ], [ "28E", 2, "14E" ], > [ "28A", 2, "14D" ], [ "42A", 3, "14A" ], [ "42B", 3, "14B" ], > [ "42C", 3, "14C" ], [ "26A", 2, "13A" ], [ "24N", 2, "12R" ], > [ "24M", 2, "12O" ], [ "24L", 2, "12Q" ], [ "24K", 2, "12M" ], > [ "24J", 2, "12J" ], [ "24H", 2, "12F" ], [ "24G", 2, "12G" ], > [ "24D", 2, "12D" ], [ "36C", 3, "12N" ], [ "36B", 3, "12K" ], > [ "36A", 3, "12B" ], [ "60A", 5, "12C" ], [ "60B", 5, "12E" ], > [ "22B", 2, "11A" ], [ "20J", 2, "10F" ], [ "20I", 2, "10D" ], > [ "20H", 2, "10C" ], [ "20F", 2, "10B" ], [ "30A", 3, "10A" ], > [ "30E", 3, "10E" ], [ "18F", 2, "9B" ], [ "18E", 2, "9A" ], > [ "16H", 2, "8M" ], [ "16G", 2, "8K" ], [ "16DF", 2, "8H" ], > [ "16E", 2, "8D" ], [ "24J", 3, "8J" ], [ "24M", 3, "8I" ], > [ "24I", 3, "8G" ], [ "24K", 3, "8F" ], [ "24C", 3, "8E" ], > [ "24B", 3, "8C" ], [ "24A", 3, "8B" ], [ "24E", 3, "8A" ], > [ "24N", 3, "8N" ], [ "40D", 5, "8L" ], [ "14D", 2, "7A" ], > [ "12T", 2, "6K" ], [ "12S", 2, "6J" ], [ "12R", 2, "6I" ], > [ "12P", 2, "6H" ], [ "12O", 2, "6G" ], [ "12I", 2, "6C" ], > [ "18A", 3, "6D" ], [ "30B", 5, "6A" ], [ "30A", 5, "6B" ], > [ "30E", 5, "6E" ], [ "30C", 5, "6F" ], [ "12C", 3, "4A" ], > [ "10F", 2, "5B" ], [ "10B", 2, "5A" ], [ "8N", 2, "4J" ], > [ "8M", 2, "4H" ], [ "8L", 2, "4G" ], [ "8J", 2, "4E" ], > [ "8I", 2, "4F" ], [ "8H", 2, "4C" ], [ "8E", 2, "4B" ], > [ "12E", 3, "4D" ], [ "12T", 3, "4I" ], [ "6K", 2, "3B" ], > [ "6A", 2, "3A" ], [ "4J", 2, "2D" ], [ "4I", 2, "2C" ], > [ "4A", 2, "2B" ], [ "6A", 3, "2A" ], [ "2B", 2, "1A" ], > ];; </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> gap> SLPForClassName:= function( nam, cycslp, outputnames ) > local pos, rule; > > pos:= Position( outputnames, nam ); > if pos <> fail then > return RestrictOutputsOfSLP( cycslp.program, pos ); > fi; > > rule:= First( DefinitionsViaPowerMaps, x -> x[3] = nam ); > if rule = fail then > Error( "'nam' is not an admiss. name for a cyclic subgroup of B" ); > fi; > > return CompositionOfStraightLinePrograms( > StraightLineProgram( [ [ 1, rule[2] ] ], 1 ), > SLPForClassName( rule[1], cycslp, outputnames ) ); > end;; </pre> <div class="p"><!----></div> Let us verify that <tt>IdentifyClassName</tt> computes the claimed labels. <div class="p"><!----></div> <pre> gap> outputnames:= List( cycprg.outputs, > x -> ReplacedString( x, "-", "" ) );; gap> outputnames:= List( outputnames, > x -> ReplacedString( x, "16F", "16DF" ) );; gap> labels:= Union( outputnames, > List( DefinitionsViaPowerMaps, x -> x[3] ) );; gap> for l in labels do > slp:= SLPForClassName( l, cycprg, outputnames ); > id:= IdentifyClassName( gens_2, gens_3, gens_5, slp, fail ); > if id <> l then > Print( "#E problem with identification: ", id, " vs. ", l, "\n" ); > fi; > od; </pre> <div class="p"><!----></div> <div class="p"><!----></div> As we get no outputs, the identification is correct. <div class="p"><!----></div> For later use, we collect power map information for the labels. In order to simplify later loops, we sort the labels w. r. t. increasing element order. <div class="p"><!----></div> <pre> gap> SortParallel( List( labels, x -> Int( Filtered( x, IsDigitChar ) ) ), > labels ); gap> powerinfo:= [];; gap> for l in labels do > slp:= SLPForClassName( l, cycprg, outputnames ); > ord:= Int( Filtered( l, IsDigitChar ) ); > pow:= []; > if not ( IsPrimeInt( ord ) or ord = 1 ) then > for p in Set( Factors( ord ) ) do > powerslp:= CompositionOfStraightLinePrograms( > StraightLineProgram( [ [ 1, p ] ], 1 ), slp ); > id:= IdentifyClassName( gens_2, gens_3, gens_5, powerslp, > ord / p ); > Add( pow, [ p, id ] ); > od; > fi; > Add( powerinfo, [ l, pow ] ); > od; </pre> <div class="p"><!----></div> <div class="p"><!----></div> <div class="p"><!----></div> <h2><a name="tth_sEc4"> 4</a> Centralizers of elements of prime order</h2><a name="centralizers_prime"> </a> <div class="p"><!----></div> We document part of the computations needed in [<a href="#BMverify" name="CITEBMverify">BMW2 <div class="p"><!----></div> We know from [<a href="#Str76b" name="CITEStr76b">Str76</a>] that <font size="+0">B</font> has exa whose normalizers in <font size="+0">B</font> have the following properties. <div class="p"><!----></div> <ul> <li> The normalizer H of a <tt>2A</tt> involution has the structure 2.<sup>2</sup>E<sub>6</sub>(2).2, such that H is an extension of its derived subgroup H′ by a field automorphism of order two, see [<a href="#Str76b" name="CITEStr76b">Str76</a>,p. 50 This implies that H is a <em>split</em> extension of H′, and this means that the character table of H is the one that is shown in the A<font size="-2">TLAS</font> of Finite Groups and that has the identifier <tt>"2.2E6(2).2"</tt> in <font face="helvetica">GAP</font>'s library of character tables; note that the isoclinic variant of H is a <em>non-split</em> extension of 2.<sup>2</sup>E<sub>6</sub>(2). <div class="p"><!----></div> </li> <li> The normalizer C of a <tt>2B</tt> involution has the structure 2<sup>1+22</sup>.Co<sub>2</sub>. Its character table has been constructed in Section <a href="#table_c2b">5</a>. <div class="p"><!----></div> </li> <li> The normalizer of a <tt>2C</tt> involution is a subdirect product of F<sub>4</sub>(2).2 and a dihedral group D<sub>8</sub> of order eight, see [<a href="#Str76b" name="CITEStr76b">Str76</a>,La. 3.1, 5.6]. The character table of this group can easily be constructed character-theoretically from the known character tables of F<sub>4</sub>(2), F<sub>4</sub>(2).2, 2<sup>2</sup>, and D<sub>8</sub>. <div class="p"><!----></div> </li> <li> The normalizer of a <tt>2D</tt> involution has order 11 689 182 992 793 600 and is contained in the normalizer in <font size="+0">B</font> of an elementary abelian group of order 2<sup>8</sup>. The character table of the latter normalizer has been computed from a subgroup of <font size="+0">B</font>, see Appendix <a href="#2Dnormalizer">11</a>. This table has a unique class with centralizer order equal to the order of the normalizer of a <tt>2D</tt> element in <font size="+0">B</font>. <div class="p"><!----></div> </li> </ul> <div class="p"><!----></div> Let H ≅ 2.<sup>2</sup>E<sub>6</sub>(2).2 be a <tt>2A</tt> centralizer in <font size="+0">B</font>. The involution classes in H are as stated in the table in [<a href="#BMverify" name="CITEBMverify">BMW20</a>,Section 5.1]. <div class="p"><!----></div> <pre> gap> h:= CharacterTable( "2.2E6(2).2" );; gap> invpos:= Positions( OrdersClassRepresentatives( h ), 2 ); [ 2, 3, 4, 5, 6, 7, 175, 176, 177, 178 ] gap> ClassNames( h ){ invpos }; [ "2a", "2b", "2c", "2d", "2e", "2f", "2g", "2h", "2i", "2j" ] gap> 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 class="p"><!----></div> (The subscripts 0 and 1 that appear above are denoted by signs + and − in [<a href="#BMverify" name="CITEBMverify">BMW20</a>].) <div class="p"><!----></div> <div class="p"><!----></div> Let us try to compute the necessary information about the permutation action of <font size="+0">B</font> on the cosets of H, restricted to H. We calculate the first three transitive constituents of the permutation character as listed in[<a href="#BMverify" name="CITEBMverify">BMW20</a>, <div class="p"><!----></div> The point stabilizer of the action of H on the first orbit contains the centre Z(H) of H, thus we may perform the computations with H/Z(H). If we assume that the rank of the permutation character is 5 then we can compute the possible degrees of the irreducible constituents combinatorially, as follows. <div class="p"><!----></div> <pre> gap> f:= CharacterTable( "2E6(2).2" );; gap> index1:= 3968055;; gap> constit:= Filtered( Irr( f ), x -> x[1] <= index1 );; gap> degrees:= Set( constit, x -> x[1] ); [ 1, 1938, 48620, 554268, 815100, 1322685, 1828332, 2089164, 2909907, 2956096 ] gap> lincom:= Filtered( UnorderedTuples( degrees, 5 ), > x -> 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> gap> degrees:= lincom[1]; [ 1, 1938, 48620, 1828332, 2089164 ] gap> constit:= List( degrees, d -> Filtered( constit, x -> x[1] = d ) );; gap> cand1:= List( Cartesian( constit ), Sum );; gap> cand1:= Filtered( cand1, x -> ForAll( x, y -> y >= 0 ) );; gap> List( ConstituentsOfCharacter( cand1[1] ), > x -> Position( Irr( f ), x ) ); [ 1, 3, 5, 13, 15 ] </pre> <div class="p"><!----></div> Thus this permutation character is uniquely determined. Alternatively, we can ask <font face="helvetica">GAP</font> to compute the possible permutatio characters of the given degree, and get the same result (without a priori knowledge about the rank of the permutation action). <div class="p"><!----></div> <pre> gap> 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> gap> u:= CharacterTable( "F4(2)" );; gap> ufush:= PossibleClassFusions( u, h );; gap> ind:= Set( ufush, > map -> InducedClassFunctionsByFusionMap( u, h, > [ TrivialCharacter( u ) ], map )[1] );; gap> Length( ind ); 1 gap> const:= ConstituentsOfCharacter( ind[1] );; gap> Sum( const ) = ind[1]; true gap> sub:= List( Cartesian( List( const, x -> [ Zero( x ), x ] ) ), Sum );; gap> cand2:= Filtered( sub, > x -> x[1] = ind[1][1] / 4 and Minimum( x ) >= 0 );; gap> Length( cand2 ); 1 gap> List( ConstituentsOfCharacter( cand2[1] ), > x -> Position( Irr( h ), x ) ); [ 1, 5, 17, 24 ] </pre> <div class="p"><!----></div> The character table of the point stabilizer Fi<sub>22</sub>.2 of the action of H on the third orbit is available. We compute the corresponding permutation character by inducing the trivial character of Fi<sub>22</sub>.2 to H. Note that the class fusion from Fi<sub>22</sub>.2 to H is unique up to the group automorphism of H that multiplies the elements outside the derived subgroup of H by the central involution in H; we know that the class <tt>2D</tt> of the point stabilizer lies in a class of H that fuses into the class <tt>2A</tt> of <font size="+0">B</font>, thus the first of the two fusions is the right one. <div class="p"><!----></div> <pre> gap> s:= CharacterTable( "Fi22.2" );; gap> sfush:= PossibleClassFusions( s, h );; gap> Length( sfush ); 2 gap> Positions( OrdersClassRepresentatives( s ), 2 ); [ 2, 3, 4, 60, 61, 62 ] gap> List( sfush, x -> x[60] ); [ 175, 176 ] gap> cand3:= InducedClassFunctionsByFusionMap( s, h, > [ TrivialCharacter( s ) ], sfush[1] );; gap> SortedList( List( ConstituentsOfCharacter( cand3[1] ), > x -> 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] class <tt>3C</tt> of H. The point stabilizer is H<sub>5</sub> ≅ 2<sup>1+20</sup>.U<sub>4</sub>(3).2<sup>2</sup>, thus the subgroup H<sub>5</sub> Z(H) / Z(H) of H / Z(H) ≅ <sup>2</sup>E<sub>6</sub>(2).2 lies in a maximal subgroup of type (2<sup>1+20</sup>:U<sub>6</sub>(2)).2, see [<a href="#CCN85" name="CITECCN85">CCN<sup>+</sup>85</a>,p. 191]. <div class="p"><!----></div> Because the extension of 2<sup>1+20</sup> by U<sub>6</sub>(2) splits, we know that H<sub>5</sub> Z(H) / Z(H) has U<sub>4</sub>(3) type subgroups, thus H<sub>5</sub> has subgroups of one of the types U<sub>4</sub>(3), 2.U<sub>4</sub>(3). Computing possible class fusions from both possibilities to H, we get that the class of elements of order 3 in U<sub>4</sub>(3) or 2.U<sub>4</sub>(3) that belongs to the <tt>3A</tt> class of U<sub>4</sub>(3) lies in the class <tt>3C</tt> of H, and the other classes of 3-elements lie in the classes <tt>3A</tt> or <tt>3B</tt> of H, as claimed. <div class="p"><!----></div> <pre> gap> h:= CharacterTable( "2.2E6(2).2" );; gap> u:= CharacterTable( "U4(3)" );; gap> Positions( OrdersClassRepresentatives( h ), 3 ); [ 8, 10, 12 ] gap> ufush:= PossibleClassFusions( u, h );; gap> 3pos:= Positions( OrdersClassRepresentatives( u ), 3 ); [ 3, 4, 5, 6 ] gap> Set( ufush, x -> x{ 3pos } ); [ [ 12, 8, 10, 10 ], [ 12, 10, 8, 10 ] ] gap> u:= CharacterTable( "2.U4(3)" );; gap> ufush:= PossibleClassFusions( u, h );; gap> 3pos:= Positions( OrdersClassRepresentatives( u ), 3 ); [ 5, 7, 9, 11 ] gap> Set( ufush, x -> x{ 3pos } ); [ [ 12, 8, 10, 10 ], [ 12, 10, 8, 10 ] ] </pre> <div class="p"><!----></div> The <tt>3A</tt> elements in U<sub>4</sub>(3) have centralizer order 2<sup>3</sup> ·3<sup>6</sup> in this group. The centralizer order in 2<sup>20</sup>.U<sub>4</sub>(3) is 2<sup>5</sup> ·3<sup>6</sup>, since the fixed space of a <tt>3A</tt> element on the unique 20 dimensional irreducible module in characteristic 2 has dimension 2 -this can be read off from the fact that the Brauer character value on the class <tt>3A</tt> is −7. <div class="p"><!----></div> <pre> gap> u:= CharacterTable( "U4(3)" ) mod 2;; gap> phi:= Filtered( Irr( u ), x -> x[1] = 20 );; gap> Display( u, rec( chars:= phi, powermap:= false ) ); U4(3)mod2 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 another class, thus the centralizer order is again doubled in each case, which means that |C<sub>H<sub>5</sub></sub>(<tt>3A</tt>)| = 2<sup>8</sup> ·3<sup>6</sup>. <div class="p"><!----></div> The permutation character of the action of <font size="+0">B</font> on the cosets of H has the value 1 620 on the class <tt>3C</tt> of H. <div class="p"><!----></div> <pre> gap> 3pos:= Positions( OrdersClassRepresentatives( f ), 3 );; gap> val3C:= 1 + cand1[1][ 3pos[3] ];; gap> 3pos:= Positions( OrdersClassRepresentatives( h ), 3 );; gap> val3C:= val3C + cand2[1][ 3pos[3] ] + cand3[1][ 3pos[3] ];; gap> val3C:= val3C + SizesCentralizers( h )[ 3pos[3] ] / ( 2^8 * 3^6 ); 1620 </pre> <div class="p"><!----></div> Thus we have computed |C<sub><font size="+0">B</font></sub>(<tt>3B</tt>)| = 2<sup>13</sup> ·3<sup>13</sup> ·5. <div class="p"><!----></div> <pre> gap> Collected( Factors( val3C * SizesCentralizers( h )[ 3pos[3] ] ) ); [ [ 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">Pa and this table is available in <font face="helvetica">GAP</font>. However, that paper assumes the knowledge of the character table of <font size="+0">B</font>, hence we are not allowed to use the known character table of C in the verification of the character table of <font size="+0">B</font>. <div class="p"><!----></div> In this section, we recompute the character table of C, as follows. We start with the three certified matrix representations of <font size="+0">B</font> in characteristic 2, 3, and 5, and with the straight line program for restricting these representations to a <tt>2B</tt> centralizer. <div class="p"><!----></div> First we standardize the generators of the subgroup such that the known straight line program for computing class representatives of Co<sub>2</sub> can be applied. Next we compute a permutation representation of degree 4600 for the factor group C / 〈z 〉. Using this representation, we construct a straight line program that computes class representatives of C / 〈Z 〉 from the images of the given generators of C under the natural epimorphism. Applying this straight line program to the restrictions of the given representations of <font size="+0">B</font> and then computing the class labels in <font siz yields a "preliminary class fusion´´ from C to B. Furthermore, the given matrix representations of C in characteristic 3 and 5 have a unique faithful constituent, which lifts to the unique ordinary irreducible character of degree 2048 of C. Hence the Brauer characters of the two representations yield most of the values of this ordinary character. Together with the character table of C / 〈Z 〉 that can be computed by <font face="helvetica">MAGMA</font> [<a href="#Magma" name="CITEMagma">BCP97</a>] f 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 t to (a conjugate of) C, we compute generators of C. <div class="p"><!----></div> <pre> gap> slp_maxes_2:= AtlasProgram( "B", "maxes", 2 );; gap> cgens_3:= ResultOfStraightLineProgram( slp_maxes_2.program, > 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> gap> m:= GModuleByMats( cgens_3, GF(3) );; gap> cf_3:= MTX.CompositionFactors( m );; gap> SortParallel( List( cf_3, x -> x.dimension ), cf_3 ); gap> List( cf_3, x -> x.dimension ); [ 23, 2048, 2300 ] </pre> <div class="p"><!----></div> We use the action on the 23-dimensional module to find words in terms of the generators of C that act on this module as <em>standard generators</em> of Co<sub>2</sub>, as defined in [<a href="#Wil96" name="CITEWil96">Wil96</a>]. <div class="p"><!----></div> For that, we find two elements a, b that generate Co<sub>2</sub> and lie in the conjugacy classes <tt>2A</tt> and <tt>5A</tt>, respectively, such that the product a b has order 28. <div class="p"><!----></div> <div class="p"><!----></div> Let us call the generators in the 23-dimensional composition factor x and y, and set c = y (y x)<sup>3</sup>. Then the elements y<sup>12</sup>, c<sup>−1</sup> ((y<sup>4</sup> x)<sup>4</sup>) c are standard generators of Co<sub>2</sub>, see Appendix <a href="#slp_co2">8</a>. The following straight line program computes these elements when it is applied to x and y. <div class="p"><!----></div> <pre> gap> slp_co2:= StraightLineProgram( [ > [ 2, 1, 1, 1 ], [ 2, 2 ], [ 4, 1, 1, 1 ], [ 4, 2 ], --> -------------------- --> maximum size reached --> -------------------- ¤ Dauer der Verarbeitung: 0.29 Sekunden (vorverarbeitet) ¤*© Formatika GbR, Deutschland |
|
2026-03-28