SSL chap1_mj.html

Sprache: HTML

products/Sources/formale Sprachen/GAP/pkg/ctbllib/doc2/chap1_mj.html

<?xml version="1.0" encoding="UTF-8"?>

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
 "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">

<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en">
<head>
<script type="text/javascript"
 src="https://cdn.jsdelivr.net/npm/mathjax@2/MathJax.js?config=TeX-AMS-MML_HTMLorMML">
</script>
<title>GAP (CTblLibXpls) - Chapter 1: Maintenance Issues for the GAP Character Table Library</title>
<meta http-equiv="content-type" content="text/html; charset=UTF-8" />
<meta name="generator" content="GAPDoc2HTML" />
<link rel="stylesheet" type="text/css" href="manual.css" />
<script src="manual.js" type="text/javascript"></script>
<script type="text/javascript">overwriteStyle();</script>
</head>
<body class="chap1" onload="jscontent()">

<div class="chlinktop">Goto Chapter: <a href="chap0_mj.html">Top</a> <a href="chap1_mj.html">1</a> <a href="chap2_mj.html">2</a> <a href="chap3_mj.html">3</a> <a href="chap4_mj.html">4</a> <a href="chap5_mj.html">5</a> <a href="chap6_mj.html">6</a> <a href="chap7_mj.html">7</a> <a href="chap8_mj.html">8</a> <a href="chap9_mj.html">9</a> <a href="chap10_mj.html">10</a> <a href="chap11_mj.html">11</a> <a href="chapBib_mj.html">Bib</a> <a href="chapInd_mj.html">Ind</a> </div>

<div class="chlinkprevnexttop"> <a href="chap0_mj.html">[Top of Book]</a> <a href="chap0_mj.html#contents">[Contents]</a> <a href="chap0_mj.html">[Previous Chapter]</a> <a href="chap2_mj.html">[Next Chapter]</a> </div>

<a href="chap1.html">[MathJax off]</a>
<a id="X8354C98179CDB193" name="X8354C98179CDB193"></a>
<div class="ChapSects"><a href="chap1_mj.html#X8354C98179CDB193">1 Maintenance Issues for the GAP Character Table Library</a>
<div class="ContSect"> <a href="chap1_mj.html#X7ECA800587320C2C">1.1 Disproving Possible Character Tables (November 2006)</a>

<div class="ContSSBlock">
 <a href="chap1_mj.html#X795DCCEA7F4D187A">1.1-1 A Perfect Pseudo Character Table (November 2006)</a>

 <a href="chap1_mj.html#X80F0B4E07B0B2277">1.1-2 An Error in the Character Table of \(E_6(2)\) (March 2016)</a>

 <a href="chap1_mj.html#X7D7982CD87413F76">1.1-3 An Error in a Power Map of the Character Table of \(2.F_4(2).2\) (November 2015)</a>

 <a href="chap1_mj.html#X836E4B6184F32EF5">1.1-4 A Character Table with a Wrong Name (May 2017)</a>

</div></div>
<div class="ContSect"> <a href="chap1_mj.html#X8159D79C7F071B33">1.2 Some finite factor groups of perfect space groups (February 2014)</a>

<div class="ContSSBlock">
 <a href="chap1_mj.html#X8710D4947AEB366F">1.2-1 Constructing the space groups in question</a>

 <a href="chap1_mj.html#X84E7FE70843422B0">1.2-2 Constructing the factor groups in question</a>

 <a href="chap1_mj.html#X79109A20873E76DA">1.2-3 Examples with point group \(A_5\)</a>

 <a href="chap1_mj.html#X83523D1E792F9E01">1.2-4 Examples with point group \(L_3(2)\)</a>

 <a href="chap1_mj.html#X7A01A9BC846BE39A">1.2-5 Example with point group SL\(_2(7)\)</a>

 <a href="chap1_mj.html#X7D3100B58093F37D">1.2-6 Example with point group \(2^3.L_3(2)\)</a>

 <a href="chap1_mj.html#X80800F3B7D6EF06C">1.2-7 Examples with point group \(A_6\)</a>

 <a href="chap1_mj.html#X7D43452C79B0EAE1">1.2-8 Examples with point group \(L_2(8)\)</a>

 <a href="chap1_mj.html#X8575CE147A9819BF">1.2-9 Example with point group \(M_{11}\)</a>

 <a href="chap1_mj.html#X7C0201B77DA1682A">1.2-10 Example with point group \(U_3(3)\)</a>

 <a href="chap1_mj.html#X85D9C329792E58F3">1.2-11 Examples with point group \(U_4(2)\)</a>

 <a href="chap1_mj.html#X8635EE0B78A66120">1.2-12 A remark on one of the example groups</a>

</div></div>
<div class="ContSect"> <a href="chap1_mj.html#X8448022280E82C52">1.3 Generality problems (December 2004/October 2015)</a>

<div class="ContSSBlock">
 <a href="chap1_mj.html#X7D1A66C3844D09B1">1.3-1 Listing possible generality problems</a>

 <a href="chap1_mj.html#X80EB5D827A78975A">1.3-2 A generality problem concerning the group \(J_3\) (April 2015)</a>

 <a href="chap1_mj.html#X82C37532783168AA">1.3-3 A generality problem concerning the group \(HN\) (August 2022)</a>

</div></div>
<div class="ContSect"> <a href="chap1_mj.html#X7D8C6D1883C9CECA">1.4 Brauer Tables that can be derived from Known Tables</a>

<div class="ContSSBlock">
 <a href="chap1_mj.html#X7DF018B77E722CA7">1.4-1 Brauer Tables via Construction Information</a>

 <a href="chap1_mj.html#X795419A287BD228E">1.4-2 Liftable Brauer Characters (May 2017)</a>

</div></div>
<div class="ContSect"> <a href="chap1_mj.html#X864EFF897A854F89">1.5 Information about certain subgroups of the Monster group</a>

<div class="ContSSBlock">
 <a href="chap1_mj.html#X82C7A03684DD7C6E">1.5-1 The Monster group does not contain subgroups of the type \(2.U_4(2)\) (August 2023)</a>

 <a href="chap1_mj.html#X87EC0C48866D1BDE">1.5-2 Perfect central extensions of \(L_3(4)\) (August 2023)</a>

 <a href="chap1_mj.html#X7F605CA28441687F">1.5-3 The character table of \((2 \times O_8^+(3)).S_4 \leq 2.B\) (October 2023)</a>

</div></div>
</div>

<h3>1 Maintenance Issues for the GAP Character Table Library</h3>

This chapter collects examples of computations that arose in the context of maintaining the GAP Character Table Library. The sections have been added when the issues in question arose; the dates of the additions are shown in the section titles.

<a id="X7ECA800587320C2C" name="X7ECA800587320C2C"></a>

<h4>1.1 Disproving Possible Character Tables (November 2006)</h4>

I do not know a necessary and sufficient criterion for checking whether a given matrix together with a list of power maps describes the character table of a finite group. Examples of pseudo character tables (tables which satisfy certain necessary conditions but for which actually no group exists) have been given in <a href="chapBib_mj.html#biBGag86">[Gag86]</a>. Another such example is described in Section <a href="chap2_mj.html#X7E0C603880157C4E">2.4-17</a>. The tables in the GAP Character Table Library satisfy the usual tests. However, there are table candidates for which these tests are not good enough. Another question would be whether a given character table belongs to the group for which it is claimed to belong, see Section <a href="chap1_mj.html#X836E4B6184F32EF5">1.1-4</a> for an example.

<a id="X795DCCEA7F4D187A" name="X795DCCEA7F4D187A"></a>

<h5>1.1-1 A Perfect Pseudo Character Table (November 2006)</h5>

(This example arose from a discussion with Jack Schmidt.)

Up to version 1.1.3 of the GAP Character Table Library, the table with identifier <code class="code">"P41/G1/L1/V4/ext2"</code> was not correct. The problem occurs already in the microfiches that are attached to <a href="chapBib_mj.html#biBHP89">[HP89]</a>.

In the following, we show that this table is not the character table of a finite group, using the GAP library of perfect groups. Currently we do not know how to prove this inconsistency alone from the table.

We start with the construction of the inconsistent table; apart from a little editing, the following input equals the data formerly stored in the file <code class="file">data/ctoholpl.tbl</code> of the GAP Character Table Library.

<div class="example"><pre>
gap> tbl:= rec(
> Identifier:= "P41/G1/L1/V4/ext2",
> InfoText:= Concatenation( [
> "origin: Hanrath library,\n",
> "structure is 2^7.L2(8),\n",
> "characters sorted with permutation (12,14,15,13)(19,20)" ] ),
> UnderlyingCharacteristic:= 0,
> SizesCentralizers:= [64512,1024,1024,64512,64,64,64,64,128,128,64,
> 64,128,128,18,18,14,14,14,14,14,14,18,18,18,18,18,18],
> ComputedPowerMaps:= [,[1,1,1,1,2,3,3,2,3,2,2,1,3,2,16,16,20,20,22,
> 22,18,18,26,26,27,27,23,23],[1,2,3,4,5,6,7,8,9,10,11,12,13,14,4,
> 1,21,22,17,18,19,20,16,15,15,16,16,15],,,,[1,2,3,4,5,6,7,8,9,10,
> 11,12,13,14,15,16,4,1,4,1,4,1,26,25,28,27,23,24]],
> Irr:= 0,
> AutomorphismsOfTable:= Group( [(23,26,27)(24,25,28),(9,13)(10,14),
> (17,19,21)(18,20,22)] ),
> ConstructionInfoCharacterTable:= ["ConstructClifford",[[[1,2,3,4,
> 5,6,7,8,9],[1,7,8,3,9,2],[1,4,5,6,2],[1,2,2,2,2,2,2,2]],
> [["L2(8)"],["Dihedral",18],["Dihedral",14],["2^3"]],[[[1,2,3,4],
> [1,1,1,1],["elab",4,25]],[[1,2,3,4,4,4,4,4,4,4],[2,6,5,2,3,4,5,
> 6,7,8],["elab",10,17]],[[1,2],[3,4],[[1,1],[-1,1]]],[[1,3],[4,
> 2],[[1,1],[-1,1]]],[[1,3],[5,3],[[1,1],[-1,1]]],[[1,3],[6,4],
> [[1,1],[-1,1]]],[[1,2],[7,2],[[1,1],[1,-1]]],[[1,2],[8,3],[[1,
> 1],[-1,1]]],[[1,2],[9,5],[[1,1],[1,-1]]]]]],
> );;
gap> ConstructClifford( tbl, tbl.ConstructionInfoCharacterTable[2] );
gap> ConvertToLibraryCharacterTableNC( tbl );;
</pre></div>

Suppose that there is a group \(G\), say, with this table. Then \(G\) is perfect since the table has only one linear character.

<div class="example"><pre>
gap> Length( LinearCharacters( tbl ) );
1
gap> IsPerfectCharacterTable( tbl );
true
</pre></div>

The table satisfies the orthogonality relations, the structure constants are nonnegative integers, and symmetrizations of the irreducibles decompose into the irreducibles, with nonnegative integral coefficients.

<div class="example"><pre>
gap> IsInternallyConsistent( tbl );
true
gap> irr:= Irr( tbl );;
gap> test:= Concatenation( List( [ 2 .. 7 ],
> n -> Symmetrizations( tbl, irr, n ) ) );;
gap> Append( test, Set( Tensored( irr, irr ) ) );
gap> fail in Decomposition( irr, test, "nonnegative" );
false
gap> if ForAny( Tuples( [ 1 .. NrConjugacyClasses( tbl ) ], 3 ),
> t -> not ClassMultiplicationCoefficient( tbl, t[1], t[2], t[3] )
> in NonnegativeIntegers ) then
> Error( "contradiction" );
> fi;
</pre></div>

The GAP Library of Perfect Groups contains representatives of the four isomorphism types of perfect groups of order \(|G| = 64\,512\).

<div class="example"><pre>
gap> n:= Size( tbl );
64512
gap> NumberPerfectGroups( n );
4
gap> grps:= List( [ 1 .. 4 ], i -> PerfectGroup( IsPermGroup, n, i ) );
[ L2(8) 2^6 E 2^1, L2(8) N 2^6 E 2^1 I, L2(8) N 2^6 E 2^1 II,
 L2(8) N 2^6 E 2^1 III ]
</pre></div>

If we believe that the classification of perfect groups of order \(|G|\) is correct then all we have to do is to show that none of the character tables of these four groups is equivalent to the given table.

<div class="example"><pre>
gap> tbls:= List( grps, CharacterTable );;
gap> List( tbls,
> x -> TransformingPermutationsCharacterTables( x, tbl ) );
[ fail, fail, fail, fail ]
</pre></div>

In fact, already the matrices of irreducible characters of the four groups do not fit to the given table.

<div class="example"><pre>
gap> List( tbls,
> t -> TransformingPermutations( Irr( t ), Irr( tbl ) ) );
[ fail, fail, fail, fail ]
</pre></div>

Let us look closer at the tables in question. Each character table of a perfect group of order \(64\,512\) has exactly one irreducible character of degree \(63\) that takes exactly the values \(-1\), \(0\), \(7\), and \(63\); moreover, the value \(7\) occurs in exactly two classes.

<div class="example"><pre>
gap> testchars:= List( tbls,
> t -> Filtered( Irr( t ),
> x -> x[1] = 63 and Set( x ) = [ -1, 0, 7, 63 ] ) );;
gap> List( testchars, Length );
[ 1, 1, 1, 1 ]
gap> List( testchars, l -> Number( l[1], x -> x = 7 ) );
[ 2, 2, 2, 2 ]
</pre></div>

(Another way to state this is that in each of the four tables \(t\) in question, there are ten preimage classes of the involution class in the simple factor group \(L_2(8)\), there are eight preimage classes of this class in the factor group \(2^6.L_2(8)\), and that the unique class in which an irreducible degree \(63\) character of this factor group takes the value \(7\) splits in \(t\).)

In the erroneous table, however, there is only one class with the value \(7\) in this character.

<div class="example"><pre>
gap> testchars:= List( [ tbl ],
> t -> Filtered( Irr( t ),
> x -> x[1] = 63 and Set( x ) = [ -1, 0, 7, 63 ] ) );;
gap> List( testchars, Length );
[ 1 ]
gap> List( testchars, l -> Number( l[1], x -> x = 7 ) );
[ 1 ]
</pre></div>

This property can be checked easily for the displayed table stored in fiche \(2\), row \(4\), column \(7\) of <a href="chapBib_mj.html#biBHP89">[HP89]</a>, with the name <code class="code">6L1<>Z^7<>L2(8); V4; MOD 2</code>, and it turns out that this table is not correct.

Note that these microfiches contain two tables of order \(64\,512\), and there were three tables of groups of that order in the GAP Character Table Library that contain <code class="code">origin: Hanrath library</code> in their <code class="func">InfoText</code> (<a href="../../../doc/ref/chap12_mj.html#X871562FD7F982C12">Reference: InfoText</a>) value. Besides the incorrect table, these library tables are the character tables of the groups <code class="code">PerfectGroup( 64512, 1 )</code> and <code class="code">PerfectGroup( 64512, 3 )</code>, respectively. (The matrices of irreducible characters of these tables are equivalent.)

<div class="example"><pre>
gap> Filtered( [ 1 .. 4 ], i ->
> TransformingPermutationsCharacterTables( tbls[i],
> CharacterTable( "P41/G1/L1/V1/ext2" ) ) <> fail );
[ 1 ]
gap> Filtered( [ 1 .. 4 ], i ->
> TransformingPermutationsCharacterTables( tbls[i],
> CharacterTable( "P41/G1/L1/V2/ext2" ) ) <> fail );
[ 3 ]
gap> TransformingPermutations( Irr( tbls[1] ), Irr( tbls[3] ) ) <> fail;
true
</pre></div>

Since version 1.2 of the GAP Character Table Library, the character table with the <code class="func">Identifier</code> (<a href="../../../doc/ref/chap70_mj.html#X810E53597B5BB4F8">Reference: Identifier for tables of marks</a>) value <code class="code">"P41/G1/L1/V4/ext2"</code> corresponds to the group <code class="code">PerfectGroup( 64512, 4 )</code>. The choice of this group was somewhat arbitrary since the vector system <code class="code">V4</code> seems to be not defined in <a href="chapBib_mj.html#biBHP89">[HP89]</a>; anyhow, this group and the remaining perfect group, <code class="code">PerfectGroup( 64512, 2 )</code>, have equivalent matrices of irreducibles.

<div class="example"><pre>
gap> Filtered( [ 1 .. 4 ], i ->
> TransformingPermutationsCharacterTables( tbls[i],
> CharacterTable( "P41/G1/L1/V4/ext2" ) ) <> fail );
[ 4 ]
gap> TransformingPermutations( Irr( tbls[2] ), Irr( tbls[4] ) ) <> fail;
true
</pre></div>

<a id="X80F0B4E07B0B2277" name="X80F0B4E07B0B2277"></a>

<h5>1.1-2 An Error in the Character Table of \(E_6(2)\) (March 2016)</h5>

In March 2016, Bill Unger computed the character table of the simple group \(E_6(2)\) with Magma (see <a href="chapBib_mj.html#biBCP96">[CP96]</a>) and compared it with the table that was contained in the GAP Character Table Library since 2000. It turned out that the two tables did not coincide.

The differences concern irrational character values on classes of element order \(91\) and power map values on these classes. (The character values and power maps fit to each other in both tables; thus it may be that the assumption of a wrong power has implied the wrong character values, or vice versa.) Specifically, the \(11\)th power map in the GAP table fixed all elements of order \(91\). Using the smallest matrix representation of \(E_6(2)\) over the field with two elements, one can easily find an element \(g\) of order \(91\), and show that the characteristic polynomials of \(g\) and \(g^{11}\) differ. Hence these two elements cannot be conjugate in \(E_6(2)\). In other words, the GAP table was wrong.

<div class="example"><pre>
gap> g:= AtlasGroup( "E6(2)" );;
gap> repeat x:= PseudoRandom( g ); until Order( x ) = 91;
gap> CharacteristicPolynomial( x ) = CharacteristicPolynomial( x^11 );
false
</pre></div>

The wrong GAP table has been corrected in version 1.3.0 of the GAP Character Table Library.

<div class="example"><pre>
gap> t:= CharacterTable( "E6(2)" );;
gap> ord91:= Positions( OrdersClassRepresentatives( t ), 91 );
[ 163, 164, 165, 166, 167, 168 ]
gap> PowerMap( t, 11 ){ ord91 };
[ 167, 168, 163, 164, 165, 166 ]
</pre></div>

<a id="X7D7982CD87413F76" name="X7D7982CD87413F76"></a>

<h5>1.1-3 An Error in a Power Map of the Character Table of \(2.F_4(2).2\) (November 2015)</h5>

As a part of the computations for <a href="chapBib_mj.html#biBBMO17">[BMO17]</a>, the character table of the group \(2.F_4(2).2\) was computed automatically from a representation of the group, using Magma (see <a href="chapBib_mj.html#biBCP96">[CP96]</a>). It turned out that the \(2\)-nd power map that had been stored on the library character table of \(2.F_4(2).2\) had been wrong.

In fact, this was the one and only case of a power map for an Atlas group which was not determined by the character table, and the <code class="func">InfoText</code> (<a href="../../../doc/ref/chap12_mj.html#X871562FD7F982C12">Reference: InfoText</a>) value of the character table had mentioned the two alternatives.

Note that the ambiguity is not present in the table of the factor group \(F_4(2).2\), and only four faithful irreducible characters of \(2.F_4(2).2\) distinguish the four relevant conjugacy classes.

<div class="example"><pre>
gap> t:= CharacterTable( "2.F4(2).2" );;
gap> f:= CharacterTable( "F4(2).2" );;
gap> map:= PowerMap( t, 2 );
[ 1, 1, 1, 1, 1, 1, 1, 1, 9, 9, 11, 11, 3, 3, 3, 5, 5, 5, 3, 6, 6, 5,
 5, 7, 7, 5, 8, 7, 29, 29, 9, 9, 9, 9, 11, 11, 9, 9, 9, 9, 11, 11,
 43, 43, 20, 20, 20, 14, 14, 13, 13, 20, 21, 24, 28, 28, 57, 57, 29,
 29, 29, 29, 33, 33, 35, 37, 37, 37, 37, 33, 33, 37, 37, 35, 41, 41,
 42, 42, 79, 79, 43, 43, 83, 83, 45, 45, 47, 47, 53, 53, 91, 91, 57,
 57, 61, 61, 61, 98, 98, 70, 70, 63, 63, 81, 81, 83, 83, 1, 6, 7,
 11, 16, 17, 24, 24, 21, 27, 27, 25, 26, 29, 41, 53, 53, 53, 46, 56,
 56, 56, 56, 62, 75, 75, 78, 78, 77, 77, 79, 79, 86, 86, 85, 85, 88,
 88, 88, 88, 95, 95, 96, 96 ]
gap> PositionSublist( map, [ 86, 86, 85, 85 ] );
140
gap> OrdersClassRepresentatives( t ){ [ 140 .. 143 ] };
[ 32, 32, 32, 32 ]
gap> SizesCentralizers( t ){ [ 140 .. 143 ] };
[ 64, 64, 64, 64 ]
gap> GetFusionMap( t, f ){ [ 140 ..143 ] };
[ 86, 86, 87, 87 ]
gap> PowerMap( f, 2 ){ [ 86, 87 ] };
[ 50, 50 ]
gap> pos:= PositionsProperty( Irr( t ),
> x -> x[1] <> x[2] and Length( Set( x{ [ 140 .. 143 ] } ) ) > 1 );
[ 144, 145, 146, 147 ]
gap> List( pos, i -> Irr(t)[i]{ [ 140 .. 143 ] } );
[ [ 2*E(16)-2*E(16)^7, -2*E(16)+2*E(16)^7, 2*E(16)^3-2*E(16)^5,
 -2*E(16)^3+2*E(16)^5 ],
 [ -2*E(16)+2*E(16)^7, 2*E(16)-2*E(16)^7, -2*E(16)^3+2*E(16)^5,
 2*E(16)^3-2*E(16)^5 ],
 [ -2*E(16)^3+2*E(16)^5, 2*E(16)^3-2*E(16)^5, 2*E(16)-2*E(16)^7,
 -2*E(16)+2*E(16)^7 ],
 [ 2*E(16)^3-2*E(16)^5, -2*E(16)^3+2*E(16)^5, -2*E(16)+2*E(16)^7,
 2*E(16)-2*E(16)^7 ] ]
</pre></div>

I had not found a suitable subgroup of \(2.F_4(2).2\) whose character table could be used to decide the question which of the two alternatives is the correct one.

<a id="X836E4B6184F32EF5" name="X836E4B6184F32EF5"></a>

<h5>1.1-4 A Character Table with a Wrong Name (May 2017)</h5>

(This example is much older.)

The character table that is shown in <a href="chapBib_mj.html#biBOst86">[Ost86, p. 126 f.]</a> is claimed to be the table of a Sylow \(2\) subgroup \(P\) of the sporadic simple Lyons group \(Ly\). This table had been contained in the character table library of the CAS system (see <a href="chapBib_mj.html#biBNPP84">[NPP84]</a>), which was one of the predecessors of GAP.

It is easy to see that no subgroup of \(Ly\) can have this character table. Namely, the group of that table contains elements of order eight with centralizer order \(2^6\), and this does not occur in \(Ly\).

<div class="example"><pre>
gap> tbl:= CharacterTable( "Ly" );;
gap> orders:= OrdersClassRepresentatives( tbl );;
gap> order8:= Filtered( [ 1 .. Length( orders ) ], x -> orders[x] = 8 );
[ 12, 13 ]
gap> SizesCentralizers( tbl ){ order8 } / 2^6;
[ 15/2, 3/2 ]
</pre></div>

The table of \(P\) has been computed in <a href="chapBib_mj.html#biBBre91">[Bre91]</a> with character theoretic methods. Nowadays it would be no problem to take a permutation representation of \(Ly\), to compute its Sylow \(2\) subgroup, and use this group to compute its character table. However, the task is even easier if we assume that \(Ly\) has a subgroup of the structure \(3.McL.2\). This subgroup is of odd index, hence it contains a conjugate of \(P\). Clearly the Sylow \(2\) subgroups in the factor group \(McL.2\) are isomorphic with \(P\). Thus we can start with a rather small permutation representation.

<div class="example"><pre>
gap> g:= AtlasGroup( "McL.2" );;
gap> NrMovedPoints( g );
275
gap> syl:= SylowSubgroup( g, 2 );;
gap> pc:= Image( IsomorphismPcGroup( syl ) );;
gap> t:= CharacterTable( pc );;
</pre></div>

The character table coincides with the one which is stored in the Character Table Library.

<div class="example"><pre>
gap> IsRecord( TransformingPermutationsCharacterTables( t,
> CharacterTable( "LyN2" ) ) );
true
</pre></div>

<a id="X8159D79C7F071B33" name="X8159D79C7F071B33"></a>

<h4>1.2 Some finite factor groups of perfect space groups (February 2014)</h4>

If one wants to find a group to which a given character table from the GAP Character Table Library belongs, one can try the function <code class="func">GroupInfoForCharacterTable</code> (<a href="../doc/chap3_mj.html#X78DCD38B7D96D8A4">CTblLib: GroupInfoForCharacterTable</a>). For a long time, this was not successful in the case of \(16\) character tables that had been computed by W. Hanrath (see Section <q>Ordinary and Brauer Tables in the GAP Character Table Library</q> in the CTblLib manual).

Using the information from <a href="chapBib_mj.html#biBHP89">[HP89]</a>, it is straightforward to construct such groups as factor groups of infinite groups. Since version 1.3.0 of the CTblLib package, calling <code class="func">GroupInfoForCharacterTable</code> (<a href="../doc/chap3_mj.html#X78DCD38B7D96D8A4">CTblLib: GroupInfoForCharacterTable</a>) for the \(16\) library tables in question yields nonempty lists and thus allows one to access the results of these constructions, via the function <code class="code">CTblLib.FactorGroupOfPerfectSpaceGroup</code>. This is an undocumented auxiliary function that becomes available automatically when <code class="func">GroupInfoForCharacterTable</code> (<a href="../doc/chap3_mj.html#X78DCD38B7D96D8A4">CTblLib: GroupInfoForCharacterTable</a>) has been called for the first time.

<div class="example"><pre>
gap> GroupInfoForCharacterTable( "A5" );;
gap> IsBound( CTblLib.FactorGroupOfPerfectSpaceGroup );
true
</pre></div>

Below we list the \(16\) group constructions. In each case, an epimorphism from the space group in question is defined by mapping the generators returned by by the function <code class="code">generatorsOfPerfectSpaceGroup</code> defined below to the generators stored in the attribute <code class="func">GeneratorsOfGroup</code> (<a href="../../../doc/ref/chap39_mj.html#X79C44528864044C5">Reference: GeneratorsOfGroup</a>) of the group returned by <code class="code">CTblLib.FactorGroupOfPerfectSpaceGroup</code>.

<a id="X8710D4947AEB366F" name="X8710D4947AEB366F"></a>

<h5>1.2-1 Constructing the space groups in question</h5>

In <a href="chapBib_mj.html#biBHP89">[HP89]</a>, a space group \(S\) is described as a subgroup \(\{ M(g, t); g \in P, t \in T \}\) of GL\((d+1, ℤ)\), where

<div class="pcenter"><table> <tr> <td class="tdright">M(g, t)</td> <td class="tdcenter"> = </td> <td class="tdleft"> <table class="GAPDocTable"> <tr> <td class="tdright">g</td> <td class="tdright">0</td> </tr> <tr> <td class="tdright">V(g)+t</td> <td class="tdright">1</td> </tr> </table> </td> </tr> </table> </div>

the point group \(P\) of \(S\) is a finite subgroup of GL\((d, ℤ)\), the translation lattice \(T\) of \(S\) is a sublattice of \(ℤ^d\), and the vector system \(V\) of \(S\) is a map from \(P\) to \(ℤ^d\). Note that \(V\) maps the identity matrix \(I \in\) GL\((d, ℤ)\) to the zero vector, and \(M(T):= \{ M(I, t); t \in T \}\) is a normal subgroup of \(S\) that is isomorphic with \(T\). More generally, \(M(n T)\) is a normal subgroup of \(S\), for any positive integer \(n\).

Specifically, \(P\) is given by generators \(g_1, g_2, \ldots, g_k\), \(T\) is given by a \(ℤ\)-basis \(B = \{ b_1, b_2, \ldots, b_d \}\) of \(T\), and \(V\) is given by the vectors \(V(g_1), V(g_2), \ldots, V(g_k)\).

In the examples below, the matrix representation of \(P\) is irreducible, so we need just the following \(k+1\) elements to generate \(S\):

<div class="pcenter"> <table> <tr> <td class="tdleft"> <table class="GAPDocTable"> <tr> <td class="tdright">g_1</td> <td class="tdright">0</td> </tr> <tr> <td class="tdright">V(g_1)</td> <td class="tdright">1</td> </tr> </table> <td class="tdleft"> , </td> </td> <td class="tdleft"> <table class="GAPDocTable"> <tr> <td class="tdright">g_2</td> <td class="tdright">0</td> </tr> <tr> <td class="tdright">V(g_2)</td> <td class="tdright">1</td> </tr> </table> </td> <td class="tdleft"> , ..., </td> <td class="tdleft"> <table class="GAPDocTable"> <tr> <td class="tdright">g_k</td> <td class="tdright">0</td> </tr> <tr> <td class="tdright">V(g_k)</td> <td class="tdright">1</td> </tr> </table> </td> <td class="tdleft"> , </td> <td class="tdleft"> <table class="GAPDocTable"> <tr> <td class="tdright">I</td> <td class="tdright">0</td> </tr> <tr> <td class="tdright">b_1</td> <td class="tdright">1</td> </tr> </table> </td> <td class="tdleft"> . </td> </tr> </table> </div>

These generators are returned by the function <code class="code">generatorsOfPerfectSpaceGroup</code>, when the inputs are \([ g_1, g_2, \ldots, g_k ]\), \([ V(g_1), V(g_2), \ldots, V(g_k) ]\), and \(b_1\).

<div class="example"><pre>
gap> generatorsOfPerfectSpaceGroup:= function( Pgens, V, t )
> local d, result, i, m;
> d:= Length( Pgens[1] );
> result:= [];
> for i in [ 1 .. Length( Pgens ) ] do
> m:= IdentityMat( d+1 );
> m{ [ 1 .. d ] }{ [ 1 .. d ] }:= Pgens[i];
> m[ d+1 ]{ [ 1 .. d ] }:= V[i];
> result[i]:= m;
> od;
> m:= IdentityMat( d+1 );
> m[ d+1 ]{ [ 1 .. d ] }:= t;
> Add( result, m );
> return result;
> end;;
</pre></div>

<a id="X84E7FE70843422B0" name="X84E7FE70843422B0"></a>

<h5>1.2-2 Constructing the factor groups in question</h5>

The space group \(S\) acts on \(ℤ^d\), via \(v \cdot M(g, t) = v g + V(g) + t\). A (not necessarily faithful) representation of \(S/M(n T)\) can be obtained from the corresponding action of \(S\) on \(ℤ^d/(n ℤ^d)\), that is, by reducing the vectors modulo \(n\). For the GAP computations, we work instead with vectors of length \(d+1\), extending each vector in \(ℤ^d\) by \(1\) in the last position, and acting on these vectors by right multiplicaton with elements of \(S\). Multiplication followed by reduction modulo \(n\) is implemented by the action function returned by <code class="code">multiplicationModulo</code> when this is called with argument \(n\).

<div class="example"><pre>
gap> multiplicationModulo:= n -> function( v, g )
> return List( v * g, x -> x mod n ); end;;
</pre></div>

In some of the examples, the representation of \(P\) given in <a href="chapBib_mj.html#biBHP89">[HP89]</a> is the action on the factor of a permutation module modulo its trivial submodule. For that, we provide the function <code class="code">deletedPermutationMat</code>, cf. <a href="chapBib_mj.html#biBHP89">[HP89, p. 269]</a>.

<div class="example"><pre>
gap> deletedPermutationMat:= function( pi, n )
> local mat, j, i;
> mat:= PermutationMat( pi, n );
> mat:= mat{ [ 1 .. n-1 ] }{ [ 1 .. n-1 ] };
> j:= n ^ pi;
> if j <> n then
> for i in [ 1 .. n-1 ] do
> mat[i][j]:= -1;
> od;
> fi;
> return mat;
> end;;
</pre></div>

After constructing permutation generators for the example groups, we verify that the groups fit to the character tables from the GAP Character Table Library and to the permutation generators stored for the construction of the group via <code class="code">CTblLib.FactorGroupOfPerfectSpaceGroup</code>.

<div class="example"><pre>
gap> verifyFactorGroup:= function( gens, id )
> local sm, act, stored, hom;
> sm:= SmallerDegreePermutationRepresentation( Group( gens ) );
> gens:= List( gens, x -> x^sm );
> act:= Images( sm );
> if not IsRecord( TransformingPermutationsCharacterTables(
> CharacterTable( act ),
> CharacterTable( id ) ) ) then
> return "wrong character table";
> fi;
> GroupInfoForCharacterTable( id );
> stored:= CTblLib.FactorGroupOfPerfectSpaceGroup( id );
> hom:= GroupHomomorphismByImages( stored, act,
> GeneratorsOfGroup( stored ), gens );
> if hom = fail or not IsBijective( hom ) then
> return "wrong group";
> fi;
> return true;
> end;;
</pre></div>

<a id="X79109A20873E76DA" name="X79109A20873E76DA"></a>

<h5>1.2-3 Examples with point group \(A_5\)</h5>

There are two examples with \(d = 5\). The generators of the point group are as follows (see <a href="chapBib_mj.html#biBHP89">[HP89, p. 272]</a>).

<div class="example"><pre>
gap> a:= deletedPermutationMat( (1,3)(2,4), 6 );;
gap> b:= deletedPermutationMat( (1,2,3)(4,5,6), 6 );;
</pre></div>

In both cases, the vector system is \(V_2\).

<div class="example"><pre>
gap> v:= [ [ 2, 2, 0, 0, 1 ], 0 * b[1] ];;
</pre></div>

In the first example, the translation lattice is the sublattice \(L = 2 L_1\) of the full lattice \(L_1 = ℤ^d\).

<div class="example"><pre>
gap> t:= [ 2, 0, 0, 0, 0 ];;
</pre></div>

The library character table with identifier <code class="code">"P1/G2/L1/V2/ext4"</code> belongs to the factor group of \(S\) modulo the normal subgroup \(M(4 L)\), so we compute the action on an orbit modulo \(8\).

<div class="example"><pre>
gap> sgens:= generatorsOfPerfectSpaceGroup( [ a, b ], v, t );;
gap> g:= Group( sgens );;
gap> fun:= multiplicationModulo( 8 );;
gap> orb:= Orbit( g, [ 1, 0, 0, 0, 0, 1 ], fun );;
gap> permgens:= List( sgens, x -> Permutation( x, orb, fun ) );;
gap> verifyFactorGroup( permgens, "P1/G2/L1/V2/ext4" );
true
</pre></div>

In the second example, the translation lattice is the sublattice \(2 L_2\) of \(ℤ^d\) where \(L_2\) has the following basis.

<div class="example"><pre>
gap> bas:= [ [-1,-1, 1, 1, 1 ],
> [-1, 1,-1, 1, 1 ],
> [ 1, 1, 1,-1,-1 ],
> [ 1, 1,-1,-1, 1 ],
> [-1, 1, 1,-1, 1 ] ];;
</pre></div>

For the sake of simplicity, we rewrite the action of the point group to one on \(L_2\), and we adjust also the vector system.

<div class="example"><pre>
gap> B:= Basis( Rationals^Length( bas ), bas );;
gap> abas:= List( bas, x -> Coefficients( B, x * a ) );;
gap> bbas:= List( bas, x -> Coefficients( B, x * b ) );;
gap> vbas:= List( v, x -> Coefficients( B, x ) );
[ [ 3/2, 1, 2, 3/2, -1 ], [ 0, 0, 0, 0, 0 ] ]
</pre></div>

In order to work with integral matrices (which is necessary because <code class="code">multiplicationModulo</code> uses GAP's <code class="code">mod</code> operator), we double both the vector system and the translation lattice.

<div class="example"><pre>
gap> vbas:= vbas * 2;
[ [ 3, 2, 4, 3, -2 ], [ 0, 0, 0, 0, 0 ] ]
gap> t:= 2 * t;
[ 4, 0, 0, 0, 0 ]
</pre></div>

The library character table with identifier <code class="code">"P1/G2/L2/V2/ext4"</code> belongs to the factor group of \(S\) modulo the normal subgroup \(M(8 L_2)\); since we have doubled the lattice, we compute the action on an orbit modulo \(16\).

<div class="example"><pre>
gap> sgens:= generatorsOfPerfectSpaceGroup( [ abas, bbas ], vbas, t );;
gap> g:= Group( sgens );;
gap> fun:= multiplicationModulo( 16 );;
gap> orb:= Orbit( g, [ 0, 0, 0, 0, 0, 1 ], fun );;
gap> permgens:= List( sgens, x -> Permutation( x, orb, fun ) );;
gap> verifyFactorGroup( permgens, "P1/G2/L2/V2/ext4" );
true
</pre></div>

<a id="X83523D1E792F9E01" name="X83523D1E792F9E01"></a>

<h5>1.2-4 Examples with point group \(L_3(2)\)</h5>

There are three examples with \(d = 6\) and one example with \(d = 8\). The generators of the point group for the first three examples are as follows (see <a href="chapBib_mj.html#biBHP89">[HP89, p. 290]</a>).

<div class="example"><pre>
gap> a:= [ [ 0, 1, 0, 1, 0, 0 ],
> [ 1, 0, 1, 1, 1, 1 ],
> [-1,-1,-1,-1, 0, 0 ],
> [ 0, 0,-1,-1,-1,-1 ],
> [ 1, 1, 1, 1, 0, 1 ],
> [ 0, 0, 1, 0, 1, 0 ] ];;
gap> b:= [ [-1, 0, 0, 0, 0,-1 ],
> [ 0, 0,-1, 0,-1, 0 ],
> [ 1, 1, 1, 1, 1, 1 ],
> [ 0, 0, 1, 0, 0, 0 ],
> [-1,-1,-1, 0, 0, 0 ],
> [ 1, 0, 0, 0, 0, 0 ] ];;
</pre></div>

The first vector system is the trivial vector system \(V_1\) (that is, the space group \(S\) is a split extension of the point group and the translation lattice), and the translation lattice is the full lattice \(L_1 = ℤ^d\).

The library character table with identifier <code class="code">"P11/G1/L1/V1/ext4"</code> belongs to the factor group of \(S\) modulo the normal subgroup \(M(4 L_1)\), so we compute the action on an orbit modulo \(4\).

<div class="example"><pre>
gap> v:= List( [ 1, 2 ], i -> 0 * a[1] );;
gap> t:= [ 1, 0, 0, 0, 0, 0 ];;
gap> sgens:= generatorsOfPerfectSpaceGroup( [ a, b ], v, t );;
gap> g:= Group( sgens );;
gap> fun:= multiplicationModulo( 4 );;
gap> seed:= [ 1, 0, 0, 0, 0, 0, 1 ];;
gap> orb:= Orbit( g, seed, fun );;
gap> permgens:= List( sgens, x -> Permutation( x, orb, fun ) );;
gap> verifyFactorGroup( permgens, "P11/G1/L1/V1/ext4" );
true
</pre></div>

The second vector system is \(V_2\), and the translation lattice is \(2 L_1\).

The library character table with identifier <code class="code">"P11/G1/L1/V2/ext4"</code> belongs to the factor group of \(S\) modulo the normal subgroup \(M(8 L_1)\), so we compute the action on an orbit modulo \(8\).

<div class="example"><pre>
gap> v:= [ [ 1, 0, 1, 0, 0, 0 ], 0 * a[1] ];;
gap> t:= [ 2, 0, 0, 0, 0, 0 ];;
gap> sgens:= generatorsOfPerfectSpaceGroup( [ a, b ], v, t );;
gap> g:= Group( sgens );;
gap> fun:= multiplicationModulo( 8 );;
gap> orb:= Orbit( g, [ 1, 0, 0, 0, 0, 0, 1 ], fun );;
gap> permgens:= List( sgens, x -> Permutation( x, orb, fun ) );;
gap> verifyFactorGroup( permgens, "P11/G1/L1/V2/ext4" );
true
</pre></div>

The third vector system is \(V_3\), and the translation lattice is \(2 L_1\).

The library character table with identifier <code class="code">"P11/G1/L1/V3/ext4"</code> belongs to the factor group of \(S\) modulo the normal subgroup \(M(8 L_1)\), so we compute the action on an orbit modulo \(8\).

<div class="example"><pre>
gap> v:= [ [ 0, 1, 0, 0, 1, 0 ], 0 * a[1] ];;
gap> t:= [ 2, 0, 0, 0, 0, 0 ];;
gap> sgens:= generatorsOfPerfectSpaceGroup( [ a, b ], v, t );;
gap> g:= Group( sgens );;
gap> fun:= multiplicationModulo( 8 );;
gap> orb:= Orbit( g, [ 1, 0, 0, 0, 0, 0, 1 ], fun );;
gap> permgens:= List( sgens, x -> Permutation( x, orb, fun ) );;
gap> verifyFactorGroup( permgens, "P11/G1/L1/V3/ext4" );
true
</pre></div>

The generators of the point group for the fourth example are as follows (see <a href="chapBib_mj.html#biBHP89">[HP89, p. 293]</a>).

<div class="example"><pre>
gap> a:= [ [ 1, 0, 0, 1, 0,-1, 0, 1 ],
> [ 0,-1, 1, 0,-1, 0, 0, 0 ],
> [ 1, 0, 0, 1, 0,-1, 0, 0 ],
> [ 0,-1, 0,-1, 0, 1, 1,-1 ],
> [ 1, 0,-1, 1, 1,-1, 0, 0 ],
> [ 1,-1,-1, 0, 0, 0, 1, 0 ],
> [ 0,-1, 1, 0,-1, 1, 0,-1 ],
> [ 1, 0,-1, 0, 0, 0, 0, 0 ] ];;
gap> b:= [ [ 1, 0,-2, 0, 1,-1, 1, 0 ],
> [ 0,-1, 0, 0, 0, 0, 1,-1 ],
> [ 1, 0,-1, 0, 1,-1, 0, 0 ],
> [-1,-1, 1,-1,-1, 2, 0,-1 ],
> [ 0, 0, 0,-1, 0, 0, 0, 0 ],
> [ 0,-1, 0,-1,-1, 1, 1,-1 ],
> [ 1,-1, 0, 0, 0, 0, 0, 0 ],
> [ 1, 0, 0, 0, 0, 0, 0, 0 ] ];;
</pre></div>

The vector system is the trivial vector system \(V_1\), and the translation lattice is the full lattice \(L_1 = ℤ^d\).

The library character table with identifier <code class="code">"P11/G4/L1/V1/ext3"</code> belongs to the factor group of \(S\) modulo the normal subgroup \(M(3 L_1)\), so we compute the action on an orbit modulo \(3\).

<div class="example"><pre>
gap> v:= List( [ 1, 2 ], i -> 0 * a[1] );;
gap> t:= [ 1, 0, 0, 0, 0, 0, 0, 0 ];;
gap> sgens:= generatorsOfPerfectSpaceGroup( [ a, b ], v, t );;
gap> g:= Group( sgens );;
gap> fun:= multiplicationModulo( 3 );;
gap> seed:= [ 1, 0, 0, 0, 0, 0, 0, 0, 1 ];;
gap> orb:= Orbit( g, seed, fun );;
gap> permgens:= List( sgens, x -> Permutation( x, orb, fun ) );;
gap> verifyFactorGroup( permgens, "P11/G4/L1/V1/ext3" );
true
</pre></div>

<a id="X7A01A9BC846BE39A" name="X7A01A9BC846BE39A"></a>

<h5>1.2-5 Example with point group SL\(_2(7)\)</h5>

There is one example with \(d = 8\). The generators of the point group are as follows (see <a href="chapBib_mj.html#biBHP89">[HP89, p. 295]</a>).

<div class="example"><pre>
gap> a:= KroneckerProduct( IdentityMat( 4 ), [ [ 0, 1 ], [ -1, 0 ] ] );;
gap> b:= [ [ 0,-1, 0, 0, 0, 0, 0, 0 ],
> [ 0, 0, 1, 0, 0, 0, 0, 0 ],
> [-1, 0, 0, 0, 0, 0, 0, 0 ],
> [ 0, 0, 0, 0, 0, 0,-1, 0 ],
> [ 0, 0, 0,-1, 0, 0, 0, 0 ],
> [ 0, 0, 0, 0, 0, 1, 0, 0 ],
> [ 0, 0, 0, 0, 1, 0, 0, 0 ],
> [ 0, 0, 0, 0, 0, 0, 0, 1 ] ];;
</pre></div>

The vector system is the trivial vector system \(V_1\), and the translation lattice is the sublattice \(L_2\) of \(ℤ^d\) that has the following basis, which is called \(B(2,8)\) in <a href="chapBib_mj.html#biBHP89">[HP89, p. 269]</a>.

<div class="example"><pre>
gap> bas:= [ [ 1, 1, 0, 0, 0, 0, 0, 0 ],
> [ 0, 1, 1, 0, 0, 0, 0, 0 ],
> [ 0, 0, 1, 1, 0, 0, 0, 0 ],
> [ 0, 0, 0, 1, 1, 0, 0, 0 ],
> [ 0, 0, 0, 0, 1, 1, 0, 0 ],
> [ 0, 0, 0, 0, 0, 1, 1, 0 ],
> [ 0, 0, 0, 0, 0, 0, 1, 1 ],
> [ 0, 0, 0, 0, 0, 0,-1, 1 ] ];;
</pre></div>

For the sake of simplicity, we rewrite the action to one on \(L_2\).

<div class="example"><pre>
gap> B:= Basis( Rationals^Length( bas ), bas );;
gap> abas:= List( bas, x -> Coefficients( B, x * a ) );;
gap> bbas:= List( bas, x -> Coefficients( B, x * b ) );;
</pre></div>

The library character table with identifier <code class="code">"P12/G1/L2/V1/ext2"</code> belongs to the factor group of \(S\) modulo the normal subgroup \(M(2 L_2)\). The action on an orbit modulo \(2\) is not faithful, its kernel contains the centre of SL\((2,7)\). We can compute a faithful representation by acting on pairs: One entry is the usual vector and the other entry carries the action of the point group.

<div class="example"><pre>
gap> v:= List( [ 1, 2 ], i -> 0 * a[1] );;
gap> t:= [ 1, 0, 0, 0, 0, 0, 0, 0 ];;
gap> sgens:= generatorsOfPerfectSpaceGroup( [ abas, bbas ], v, t );;
gap> g:= Group( sgens );;
gap> fun:= multiplicationModulo( 2 );;
gap> funpairs:= function( pair, g )
> return [ fun( pair[1], g ), pair[2] * g ];
> end;;
gap> seed:= [ [ 1, 0, 0, 0, 0, 0, 0, 0, 1 ],
> [ 1, 0, 0, 0, 0, 0, 0, 0, 0 ] ];;
gap> orb:= Orbit( g, seed, funpairs );;
gap> permgens:= List( sgens, x -> Permutation( x, orb, funpairs ) );;
gap> verifyFactorGroup( permgens, "P12/G1/L2/V1/ext2" );
true
</pre></div>

<a id="X7D3100B58093F37D" name="X7D3100B58093F37D"></a>

<h5>1.2-6 Example with point group \(2^3.L_3(2)\)</h5>

There is one example with \(d = 7\). The generators of the point group are as follows (see <a href="chapBib_mj.html#biBHP89">[HP89, p. 297]</a>).

<div class="example"><pre>
gap> a:= PermutationMat( (2,4)(5,7), 7 );;
gap> b:= PermutationMat( (1,3,2)(4,6,5), 7 );;
gap> c:= DiagonalMat( [ -1, -1, 1, 1, -1, -1, 1 ] );;
</pre></div>

The vector system is the trivial vector system \(V_1\), and the translation lattice is the sublattice \(L_2\) of \(ℤ^d\) that has the following basis, which is called \(B(2,7)\) in <a href="chapBib_mj.html#biBHP89">[HP89, p. 269]</a>.

<div class="example"><pre>
gap> bas:= [ [ 1, 1, 0, 0, 0, 0, 0 ],
> [ 0, 1, 1, 0, 0, 0, 0 ],
> [ 0, 0, 1, 1, 0, 0, 0 ],
> [ 0, 0, 0, 1, 1, 0, 0 ],
> [ 0, 0, 0, 0, 1, 1, 0 ],
> [ 0, 0, 0, 0, 0, 1, 1 ],
> [ 0, 0, 0, 0, 0,-1, 1 ] ];;
</pre></div>

For the sake of simplicity, we rewrite the action to one on \(L_2\).

<div class="example"><pre>
gap> B:= Basis( Rationals^Length( bas ), bas );;
gap> abas:= List( bas, x -> Coefficients( B, x * a ) );;
gap> bbas:= List( bas, x -> Coefficients( B, x * b ) );;
gap> cbas:= List( bas, x -> Coefficients( B, x * c ) );;
</pre></div>

The library character table with identifier <code class="code">"P13/G1/L2/V1/ext2"</code> belongs to the factor group of \(S\) modulo the normal subgroup \(M(2 L_2)\), so we compute the action on an orbit modulo \(2\).

<div class="example"><pre>
gap> v:= List( [ 1 .. 3 ], i -> 0 * a[1] );;
gap> t:= [ 1, 0, 0, 0, 0, 0, 0 ];;
gap> sgens:= generatorsOfPerfectSpaceGroup( [ abas,bbas,cbas ], v, t );;
gap> g:= Group( sgens );;
gap> fun:= multiplicationModulo( 2 );;
gap> orb:= Orbit( g, [ 1, 0, 0, 0, 0, 0, 0, 1 ], fun );;
gap> act:= Action( g, orb, fun );;
gap> permgens:= List( sgens, x -> Permutation( x, orb, fun ) );;
gap> verifyFactorGroup( permgens, "P13/G1/L2/V1/ext2" );
true
</pre></div>

<a id="X80800F3B7D6EF06C" name="X80800F3B7D6EF06C"></a>

<h5>1.2-7 Examples with point group \(A_6\)</h5>

There are two examples with \(d = 10\). In both cases, the generators of the point group are as follows (see <a href="chapBib_mj.html#biBHP89">[HP89, p. 307]</a>).

<div class="example"><pre>
gap> b:= [ [ 0,-1, 0, 0, 0, 0, 0, 0, 0, 0 ], 
> [ 0, 0, 0, 0,-1, 0, 0, 0, 0, 0 ], 
> [ 0, 0, 0, 0, 0, 0, 0, 1, 0, 0 ], 
> [ 0, 0, 0, 0, 0, 0, 0, 0, 1, 0 ], 
> [ 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], 
> [ 0, 0, 1, 0, 0, 0, 0, 0, 0, 0 ], 
> [ 0, 0, 0, 1, 0, 0, 0, 0, 0, 0 ], 
> [ 0, 0, 0, 0, 0, 1, 0, 0, 0, 0 ], 
> [ 0, 0, 0, 0, 0, 0, 1, 0, 0, 0 ], 
> [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 ] ];;
gap> c:= [ [ 0, 0, 0, 0, 0, 0, 0,-1, 0, 0 ], 
> [ 0, 0, 0, 0, 0, 0, 0,-1, 1,-1 ], 
> [ 0, 0, 0, 0,-1, 1, 0,-1, 0, 0 ], 
> [ 0,-1, 1, 0, 0, 0, 0,-1, 0, 0 ], 
> [ 0, 0, 0, 0, 0, 0, 0, 0, 0,-1 ], 
> [ 0, 0, 0, 0, 0, 1, 0, 0, 0, 0 ], 
> [ 0, 0, 1, 0, 0, 0, 0, 0, 0, 0 ], 
> [ 0, 0, 0, 0, 0, 1,-1, 0, 0, 1 ], 
> [ 0, 0, 1,-1, 0, 0, 0, 0, 0, 1 ], 
> [-1, 0, 1, 0, 0,-1, 0, 0, 0, 0 ] ];;
</pre></div>

In both examples, the vector system is the trivial vector system \(V_1\), and the translation lattices are the lattices \(L_2\) and \(L_5\), respectively, which have the following bases.

<div class="example"><pre>
gap> bas2:= [ [ 0, 1,-1, 0, 0, 0, 0, 0, 0, 0 ],
> [ 0, 0, 1,-1, 0, 0, 0, 0, 0, 0 ],
> [ 0, 0, 0, 0, 1,-1, 0, 0, 0, 0 ],
> [ 0, 0, 0, 0, 0, 1,-1, 0, 0, 0 ],
> [ 0, 0, 0, 0, 0, 1, 0,-1, 0, 0 ],
> [ 0, 0, 0, 0, 0, 0, 0, 1,-1, 0 ],
> [ 0, 0, 0, 0, 0, 0, 0, 0, 1,-1 ],
> [ 0, 0, 0, 1, 0, 0, 0, 0, 0,-1 ],
> [ 0, 1, 0, 0, 0, 0, 0, 1, 0, 0 ],
> [ 1, 0, 0, 0, 1, 0, 0, 0, 0, 0 ] ];;
gap> bas5:= [ [ 0,-1, 1, 1,-1, 1, 1,-1,-1, 0 ],
> [ 1, 0,-1,-1,-1, 1, 1,-1,-1, 0 ],
> [ 0, 1, 1,-1, 1, 1,-1, 0, 1, 1 ],
> [ 1, 1, 0,-1, 0,-1, 1,-1, 1,-1 ],
> [-1, 0,-1, 1, 1, 0,-1,-1, 1,-1 ],
> [ 0, 1,-1, 1, 1,-1, 1, 1, 0,-1 ],
> [-1,-1, 1, 1, 0,-1,-1,-1,-1, 0 ],
> [ 1,-1, 0,-1, 1,-1, 1, 1, 0,-1 ],
> [-1, 1,-1, 1,-1, 0,-1, 1, 0,-1 ],
> [ 1,-1,-1, 1, 1, 1, 0, 0,-1,-1 ] ];;
</pre></div>

For the sake of simplicity, we rewrite the action to actions on \(L_2\) and \(L_5\), respectively.

<div class="example"><pre>
gap> B2:= Basis( Rationals^Length( bas2 ), bas2 );;
gap> bbas2:= List( bas2, x -> Coefficients( B2, x * b ) );;
gap> cbas2:= List( bas2, x -> Coefficients( B2, x * c ) );;
gap> B5:= Basis( Rationals^Length( bas5 ), bas5 );;
gap> bbas5:= List( bas5, x -> Coefficients( B5, x * b ) );;
gap> cbas5:= List( bas5, x -> Coefficients( B5, x * c ) );;
</pre></div>

The library character table with identifier <code class="code">"P21/G3/L2/V1/ext2"</code> belongs to the factor group of \(S\) modulo the normal subgroup \(M(2 L_2)\), so we compute the action on an orbit modulo \(2\).

<div class="example"><pre>
gap> v:= List( [ 1, 2 ], i -> 0 * bbas2[1] );;
gap> t:= [ 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 ];;
gap> sgens:= generatorsOfPerfectSpaceGroup( [ bbas2, cbas2 ], v, t );;
gap> g:= Group( sgens );;
gap> fun:= multiplicationModulo( 2 );;
gap> seed:= [ 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 ];;
gap> orb:= Orbit( g, seed, fun );;
gap> permgens:= List( sgens, x -> Permutation( x, orb, fun ) );;
gap> verifyFactorGroup( permgens, "P21/G3/L2/V1/ext2" );
true
</pre></div>

The library character table with identifier <code class="code">"P21/G3/L5/V1/ext2"</code> belongs to the factor group of \(S\) modulo the normal subgroup \(M(2 L_5)\), so we compute the action on an orbit modulo \(2\).

<div class="example"><pre>
gap> sgens:= generatorsOfPerfectSpaceGroup( [ bbas5, cbas5 ], v, t );;
gap> g:= Group( sgens );;
gap> orb:= Orbit( g, seed, fun );;
gap> permgens:= List( sgens, x -> Permutation( x, orb, fun ) );;
gap> verifyFactorGroup( permgens, "P21/G3/L5/V1/ext2" );
true
</pre></div>

<a id="X7D43452C79B0EAE1" name="X7D43452C79B0EAE1"></a>

<h5>1.2-8 Examples with point group \(L_2(8)\)</h5>

There are two examples with \(d = 7\). In both cases, the generators of the point group are as follows (see <a href="chapBib_mj.html#biBHP89">[HP89, p. 327]</a>).

<div class="example"><pre>
gap> a:= [ [ 0,-1, 0, 1, 0,-1, 1],
> [ 0, 0,-1, 0, 1,-1, 0],
> [ 0, 0, 0,-1, 1, 0, 0],
> [ 0, 0, 0,-1, 0, 0, 0],
> [ 0, 0, 1,-1, 0, 0, 0],
> [ 0,-1, 1, 0,-1, 0, 0],
> [ 1,-1, 0, 1, 0,-1, 0] ];;
gap> b:= [ [-1, 0, 1, 0,-1, 1, 0],
> [ 0,-1, 0, 1,-1, 0, 0],
> [ 0, 0,-1, 1, 0, 0, 0],
> [ 0, 0,-1, 0, 0, 0, 0],
> [ 0, 1,-1, 0, 0, 0, 0],
> [-1, 1, 0,-1, 0, 0, 0],
> [-1, 0, 1, 0,-1, 0, 1] ];;
</pre></div>

In both examples, the vector system is \(V_2\). The translation lattice in the first example is the lattice \(L = 3 ℤ^d\).

<div class="example"><pre>
gap> v:= [ [ 2, 1, 0, 0, 0, 1, 4 ],
> [ 2, 0, 0, 0, 0, 0, 0 ] ];;
gap> t:= [ 3, 0, 0, 0, 0, 0, 0 ];;
</pre></div>

The library character table with identifier <code class="code">"P41/G1/L1/V3/ext3"</code> belongs to the factor group of \(S\) modulo the normal subgroup \(M(3 L)\), so we compute the action on an orbit modulo \(9\).

The orbits in this action are quite long. we choose a seed vector from the fixed space of an element of order \(7\).

<div class="example"><pre>
gap> sgens:= generatorsOfPerfectSpaceGroup( [ a, b ], v, t );;
gap> g:= Group( sgens );;
gap> aa:= sgens[1];;
gap> bb:= sgens[2];;
gap> elm:= aa*bb;;
gap> Order( elm );
7
gap> fixed:= NullspaceMat( elm - aa^0 );
[ [ 1, 1, 1, 1, 1, 1, 1, 0 ], [ -4, 1, 1, -5, -5, 2, 0, 1 ] ]
gap> fun:= multiplicationModulo( 9 );;
gap> seed:= fun( fixed[2], aa^0 );
[ 5, 1, 1, 4, 4, 2, 0, 1 ]
gap> orb:= Orbit( g, seed, fun );;
gap> permgens:= List( sgens, x -> Permutation( x, orb, fun ) );;
gap> verifyFactorGroup( permgens, "P41/G1/L1/V3/ext3" );
true
</pre></div>

The translation lattice in the second example is the lattice \(L = 6 ℤ^d\).

<div class="example"><pre>
gap> t:= [ 6, 0, 0, 0, 0, 0, 0 ];;
</pre></div>

The library character table with identifier <code class="code">"P41/G1/L1/V4/ext3"</code> belongs to the factor group of \(S\) modulo the normal subgroup \(M(6 L)\), so we compute the action on an orbit modulo \(18\).

<div class="example"><pre>
gap> fun:= multiplicationModulo( 18 );;
gap> sgens:= generatorsOfPerfectSpaceGroup( [ a, b ], v, t );;
gap> g:= Group( sgens );;
gap> seed:= fun( fixed[2], aa^0 );
[ 14, 1, 1, 13, 13, 2, 0, 1 ]
gap> orb:= Orbit( g, seed, fun );;
gap> permgens:= List( sgens, x -> Permutation( x, orb, fun ) );;
gap> verifyFactorGroup( permgens, "P41/G1/L1/V4/ext3" );
true
</pre></div>

<a id="X8575CE147A9819BF" name="X8575CE147A9819BF"></a>

<h5>1.2-9 Example with point group \(M_{11}\)</h5>

There is one example with \(d = 10\). The generators of the point group are as follows (see <a href="chapBib_mj.html#biBHP89">[HP89, p. 334]</a>).

<div class="example"><pre>
gap> a:= deletedPermutationMat( (1,9)(3,5)(7,11)(8,10), 11 );;
gap> b:= deletedPermutationMat( (1,4,3,2)(5,8,7,6), 11 );;
</pre></div>

The vector system is \(V_2\), and the translation lattice is \(L = 2 ℤ^d\).

<div class="example"><pre>
gap> v:= [ 0 * a[1],
> [ 0, 0, 0, 0, 0, 0, 0, 0, 1, 1 ] ];;
gap> t:= [ 2, 0, 0, 0, 0, 0, 0, 0, 0, 0 ];;
</pre></div>

The library character table with identifier <code class="code">"P48/G1/L1/V2/ext2"</code> belongs to the factor group of \(S\) modulo the normal subgroup \(M(2 L)\), so we compute the action on an orbit modulo \(4\).

<div class="example"><pre>
gap> sgens:= generatorsOfPerfectSpaceGroup( [ a, b ], v, t );;
gap> g:= Group( sgens );;
gap> fun:= multiplicationModulo( 4 );;
gap> orb:= Orbit( g, [ 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 ], fun );;
gap> permgens:= List( sgens, x -> Permutation( x, orb, fun ) );;
gap> verifyFactorGroup( permgens, "P48/G1/L1/V2/ext2" );
true
</pre></div>

<a id="X7C0201B77DA1682A" name="X7C0201B77DA1682A"></a>

<h5>1.2-10 Example with point group \(U_3(3)\)</h5>

There is one example with \(d = 7\). The generators of the point group are as follows (see <a href="chapBib_mj.html#biBHP89">[HP89, p. 335]</a>).

<div class="example"><pre>
gap> a:= [ [ 0, 0,-1, 1, 0,-1, 1 ],
> [ 1, 0,-1, 1, 1,-1, 0 ],
> [ 0, 1,-1, 0, 1, 0,-1 ],
> [ 0, 1, 0,-1, 1, 0,-1 ],
> [-1, 1, 1,-1, 0, 1, 0 ],
> [-1, 0, 1,-1, 0, 0, 1 ],
> [ 0, 0, 0, 0, 0, 0, 1 ] ];;
gap> b:= [ [ 0, 0, 0, 0, 0, 0, 1 ],
> [ 0, 0,-1, 1, 0,-1, 1 ],
> [ 1, 0,-1, 1, 1,-1, 0 ],
> [ 0, 1,-1, 0, 1, 0,-1 ],
> [ 0, 1, 0,-1, 1, 0,-1 ],
> [-1, 1, 1,-1, 0, 1, 0 ],
> [-1, 0, 1,-1, 0, 0, 1 ] ];;
</pre></div>

The vector system is \(V_2\), and the translation lattice is \(L = 3 ℤ^d\).

<div class="example"><pre>
gap> v:= [ [ 2, 1, 0, 0, 2, 1, 0 ],
> 0 * b[1] ];;
gap> t:= [ 3, 0, 0, 0, 0, 0, 0 ];;
</pre></div>

The library character table with identifier <code class="code">"P49/G1/L1/V2/ext3"</code> belongs to the factor group of \(S\) modulo the normal subgroup \(M(3 L)\), so we compute the action on an orbit modulo \(9\).

<div class="example"><pre>
gap> sgens:= generatorsOfPerfectSpaceGroup( [ a, b ], v, t );;
gap> g:= Group( sgens );;
gap> fun:= multiplicationModulo( 9 );;
</pre></div>

The orbits in this action are quite long. we choose a seed vector from the fixed space of an element of order \(12\).

<div class="example"><pre>
gap> aa:= sgens[1];;
gap> bb:= sgens[2];;
gap> elm:= aa*bb^4;;
gap> Order( elm );
12
gap> fixed:= NullspaceMat( elm - aa^0 );
[ [ -1, -1, 1, 1, -1, -1, 1, 0 ], [ 0, -3, 1, 1, -1, -2, 0, 1 ] ]
gap> seed:= fun( fixed[2], aa^0 );
[ 0, 6, 1, 1, 8, 7, 0, 1 ]
gap> orb:= Orbit( g, seed, fun );;
gap> permgens:= List( sgens, x -> Permutation( x, orb, fun ) );;
gap> verifyFactorGroup( permgens, "P49/G1/L1/V2/ext3" );
true
</pre></div>

<a id="X85D9C329792E58F3" name="X85D9C329792E58F3"></a>

<h5>1.2-11 Examples with point group \(U_4(2)\)</h5>

There are two examples with \(d = 6\). In both cases, the generators of the point group are as follows (see <a href="chapBib_mj.html#biBHP89">[HP89, p. 336]</a>).

<div class="example"><pre>
gap> a:= [ [ 0, 1, 0,-1,-1, 1 ],
> [ 1, 0,-1, 0, 1, 0 ],
> [ 0, 0, 0,-1, 0, 1 ],
> [ 0, 0,-1, 0, 0, 1 ],
> [ 0, 0, 0, 0, 1, 0 ],
> [ 0, 0, 0, 0, 0, 1 ] ];;
gap> b:= [ [ 0,-1, 0, 1, 0,-1 ],
> [ 0, 1, 0,-1,-1, 0 ],
> [ 0, 0, 1, 1, 0,-1 ],
> [ 0, 0, 0, 0,-1, 0 ],
> [ 0, 1, 0, 0, 0, 0 ],
> [ 1, 0, 0, 0, 0, 0 ] ];;
</pre></div>

In both examples, the vector system is the trivial vector system \(V_1\), and the translation lattice is the full lattice \(L_1 = ℤ^d\).

<div class="example"><pre>
gap> v:= List( [ 1, 2 ], i -> 0 * a[1] );;
gap> t:= [ 1, 0, 0, 0, 0, 0 ];;
</pre></div>

The library character table with identifier <code class="code">"P50/G1/L1/V1/ext3"</code> belongs to the factor group of \(S\) modulo the normal subgroup \(M(3 L_1)\), so we compute the action on an orbit modulo \(3\).

<div class="example"><pre>
gap> sgens:= generatorsOfPerfectSpaceGroup( [ a, b ], v, t );;
gap> g:= Group( sgens );;
gap> fun:= multiplicationModulo( 3 );;
gap> orb:= Orbit( g, [ 1, 0, 0, 0, 0, 0, 1 ], fun );;
gap> permgens:= List( sgens, x -> Permutation( x, orb, fun ) );;
gap> verifyFactorGroup( permgens, "P50/G1/L1/V1/ext3" );
true
</pre></div>

The library character table with identifier <code class="code">"P50/G1/L1/V1/ext4"</code> belongs to the factor group of \(S\) modulo the normal subgroup \(M(4 L_1)\), so we compute the action on an orbit modulo \(4\).

<div class="example"><pre>
gap> sgens:= generatorsOfPerfectSpaceGroup( [ a, b ], v, t );;
gap> g:= Group( sgens );;
gap> fun:= multiplicationModulo( 4 );;
gap> orb:= Orbit( g, [ 1, 0, 0, 0, 0, 0, 1 ], fun );;
gap> permgens:= List( sgens, x -> Permutation( x, orb, fun ) );;
gap> verifyFactorGroup( permgens, "P50/G1/L1/V1/ext4" );
true
</pre></div>

<a id="X8635EE0B78A66120" name="X8635EE0B78A66120"></a>

<h5>1.2-12 A remark on one of the example groups</h5>

The (perfect) character table with identifier <code class="code">"P1/G2/L2/V2/ext4"</code> has the property that its character degrees are exactly the divisors of \(60\).

<div class="example"><pre>
gap> degrees:= CharacterDegrees( CharacterTable( "P1/G2/L2/V2/ext4" ) );
[ [ 1, 1 ], [ 2, 2 ], [ 3, 2 ], [ 4, 2 ], [ 5, 1 ], [ 6, 5 ],
 [ 10, 4 ], [ 12, 4 ], [ 15, 20 ], [ 20, 2 ], [ 30, 29 ], [ 60, 8 ] ]
gap> List( degrees, x -> x[1] ) = DivisorsInt( 60 );
true
</pre></div>

There are nilpotent groups with the same set of character degrees, for example the direct product of four extraspecial groups of the orders \(2^3\), \(2^3\), \(3^3\), and \(5^3\), respectively. This phenomenon has been described in <a href="chapBib_mj.html#biBNR14">[NR14]</a>.

<a id="X8448022280E82C52" name="X8448022280E82C52"></a>

<h4>1.3 Generality problems (December 2004/October 2015)</h4>

The term <q>generality problem</q> is used for problems concerning consistent choices of conjugacy classes of Brauer tables for the same group, in different characteristics. The definition and some examples are given in <a href="chapBib_mj.html#biBJLPW95">[JLPW95, p. x]</a>.

Section <a href="chap1_mj.html#X7D1A66C3844D09B1">1.3-1</a> shows how to detect generality problems and lists the known generality problems, and Section <a href="chap1_mj.html#X80EB5D827A78975A">1.3-2</a> gives an example that actually arose.

<a id="X7D1A66C3844D09B1" name="X7D1A66C3844D09B1"></a>

<h5>1.3-1 Listing possible generality problems</h5>

We use the following idea for finding character tables which may involve generality problems. (The functions shown in this section are based on GAP 3 code that was originally written by Jürgen Müller.)

If the \(p\)-modular Brauer table \(mtbl\), say, of a group contributes to a generality problem then some choice of conjugacy classes is necessary in order to write down this table, in the sense that some symmetry of the corresponding ordinary table \(tbl\), say, is broken in \(mtbl\). This situation can be detected as follows. We assume that the class fusion from \(mtbl\) to \(tbl\) has been fixed. All possible class fusions are obtained as the orbit of this class fusion under the actions of table automorphisms of \(tbl\), via mapping the images of the class fusion (with the function <code class="func">OnTuples</code> (<a href="../../../doc/ref/chap41_mj.html#X832CC5F87EEA4A7E">Reference: OnTuples</a>)), and of the table automorphisms of \(mtbl\), via permuting the preimages. The case of broken symmetries occurs if and only if this orbit splits into several orbits when only the action of the table automorphisms of \(mtbl\) is considered. Equivalently, symmetries are broken if and only if the orbit under table automorphisms of \(mtbl\) is not closed under the action of table automorphisms of \(tbl\).

<div class="example"><pre>
gap> BrokenSymmetries:= function( ordtbl, modtbl )
> local taut, maut, triv, fus, orb;
> taut:= AutomorphismsOfTable( ordtbl );
> maut:= AutomorphismsOfTable( modtbl );
> triv:= TrivialSubgroup( taut );
> fus:= GetFusionMap( modtbl, ordtbl );
> orb:= MakeImmutable( Set( OrbitFusions( maut, fus, triv ) ) );
> return ForAny( GeneratorsOfGroup( taut ),
> x -> ForAny( orb,
> fus -> not OnTuples( fus, x ) in orb ) );
> end;;
</pre></div>

Remark: (Thanks to Klaus Lux for discussions on this topic.)

<ul>
<li>It may happen that some symmetry \(\sigma_m\) of a Brauer table does not belong to a symmetry \(\sigma_o\) of the corresponding ordinary table, in the sense that permuting the preimage classes of a fusion \(f\) between the two tables with \(\sigma_m\) and permuting the image classes with \(\sigma_o\) yields \(f\).

For example, consider the group \(G = 2.A_6.2_1\), the double cover of the symmetric group \(S_6\) on six points. The \(2\)-modular Brauer table of \(G\), which is essentially equal to that of \(S_6\), has a table automorphism group order two, and the nonidentity element in it swaps the two classes of element order three. The automorphism group of the ordinary character table of \(G\), however, fixes the two classes of element order three; note that exactly one of these classes possesses square roots in the <q>outer half</q> \(G \setminus G'\).

Thus it is not sufficient to compare the orbit of the fixed class fusion under the automorphisms of the ordinary table with the orbit of the same fusion under the automorphisms of the Brauer table.

</li>
</ul>

<div class="example"><pre>
gap> t:= CharacterTable( "2.A6.2_1" );;
gap> m:= t mod 2;;
gap> GetFusionMap( m, t );
[ 1, 4, 6, 9 ]
gap> AutomorphismsOfTable( t );
Group([ (16,17), (14,15), (14,15)(16,17) ])
gap> AutomorphismsOfTable( m );
Group([ (2,3) ])
gap> Display( m );
2.A6.2_1mod2

 2 5 2 2 1
 3 2 2 2 .
 5 1 . . 1

 1a 3a 3b 5a
 2P 1a 3a 3b 5a
 3P 1a 1a 1a 5a
 5P 1a 3a 3b 1a

X.1 1 1 1 1
X.2 4 1 -2 -1
X.3 4 -2 1 -1
X.4 16 -2 -2 1
gap> Display( t );
2.A6.2_1

 2 5 5 4 2 2 2 2 3 1 1 4 4 3 2 2 2 2
 3 2 2 . 2 2 2 2 . . . 1 1 . 1 1 1 1
 5 1 1 . . . . . . 1 1 . . . . . . .

 1a 2a 4a 3a 6a 3b 6b 8a 5a 10a 2b 4b 8b 6c 6d 12a 12b
 2P 1a 1a 2a 3a 3a 3b 3b 4a 5a 5a 1a 2a 4a 3a 3a 6b 6b
 3P 1a 2a 4a 1a 2a 1a 2a 8a 5a 10a 2b 4b 8b 2b 2b 4b 4b
 5P 1a 2a 4a 3a 6a 3b 6b 8a 1a 2a 2b 4b 8b 6d 6c 12b 12a

X.1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
X.2 1 1 1 1 1 1 1 1 1 1 -1 -1 -1 -1 -1 -1 -1
X.3 5 5 1 2 2 -1 -1 -1 . . 3 -1 1 . . -1 -1
X.4 5 5 1 2 2 -1 -1 -1 . . -3 1 -1 . . 1 1
X.5 5 5 1 -1 -1 2 2 -1 . . -1 3 1 -1 -1 . .
X.6 5 5 1 -1 -1 2 2 -1 . . 1 -3 -1 1 1 . .
X.7 16 16 . -2 -2 -2 -2 . 1 1 . . . . . . .
X.8 9 9 1 . . . . 1 -1 -1 3 3 -1 . . . .
X.9 9 9 1 . . . . 1 -1 -1 -3 -3 1 . . . .
X.10 10 10 -2 1 1 1 1 . . . 2 -2 . -1 -1 1 1
X.11 10 10 -2 1 1 1 1 . . . -2 2 . 1 1 -1 -1
X.12 4 -4 . -2 2 1 -1 . -1 1 . . . . . B -B
X.13 4 -4 . -2 2 1 -1 . -1 1 . . . . . -B B
X.14 4 -4 . 1 -1 -2 2 . -1 1 . . . A -A . .
X.15 4 -4 . 1 -1 -2 2 . -1 1 . . . -A A . .
X.16 16 -16 . -2 2 -2 2 . 1 -1 . . . . . . .
X.17 20 -20 . 2 -2 2 -2 . . . . . . . . . .

A = E(3)-E(3)^2
 = Sqrt(-3) = i3
B = -E(12)^7+E(12)^11
 = Sqrt(3) = r3
</pre></div>

When considering several characteristics in parallel, one argues as follows. The possible class fusions from a Brauer table \(mtbl\) to its ordinary table \(tbl\) are given by the orbit of a fixed class fusion under the action of the table automorphisms of \(tbl\). If there are several orbits under the action of the automorphisms of \(mtbl\) then we choose one orbit. Due to this choice, only those table automorphisms of \(tbl\) are admissible for other characteristics that stabilize the chosen orbit. For the second characteristic, we take again the set of all class fusions from the Brauer table to \(tbl\), and split it into orbits under the table automorphisms of the Brauer table. Now there are two possibilities. Either the action of the admissible subgroup of automorphisms of \(tbl\) joins these orbits into one orbit or not. In the former case, we choose again one of the orbits, replace the group of admissible automorphisms of \(tbl\) by the stabilizer of this orbit, and proceed with the next characteristic. In the latter case, we have found a generality problem, since we are not free to choose an arbitrary class fusion from the set of possibilities.

The following function returns the set of primes which may be involved in generality problems for the given ordinary character table. Note that the procedure sketched above does not tell which characteristics are actually involved or which classes are affected by the choices; for example, we could argue that one is always free to choose a fusion for the first characteristics, and that only the other ones cause problems. We return all those primes \(p\) for which broken symmetries between the \(p\)-modular table and the ordinary table have been detected.

<div class="example"><pre>
gap> PrimesOfGeneralityProblems:= function( ordtbl )
> local consider, p, modtbl, taut, triv, admiss, fusion, maut,
> allfusions, orbits, orbit, reps;
> # Find the primes for which symmetries are broken.
> consider:= [];
> for p in Filtered( PrimeDivisors( Size( ordtbl ) ), IsPrimeInt ) do
> modtbl:= ordtbl mod p;
> if modtbl <> fail and BrokenSymmetries( ordtbl, modtbl ) then
> Add( consider, p );
> fi;
> od;
> # Compute the choices and detect generality problems.
> taut:= AutomorphismsOfTable( ordtbl );
> triv:= TrivialSubgroup( taut );
> admiss:= taut;
> for p in consider do
> modtbl:= ordtbl mod p;
> fusion:= GetFusionMap( modtbl, ordtbl );
> maut:= AutomorphismsOfTable( modtbl );
> # - We need not apply the action of 'maut' here,
> # since 'maut' will later be used to get representatives.
> # - We need not apply all elements in 'taut' but only
> # representatives of left cosets of 'admiss' in 'taut',
> # since 'admiss' will later be used to get representatives.
> # allfusions:= OrbitFusions( maut, fusion, taut );
> allfusions:= Set( RightTransversal( taut, admiss ),
> x -> OnTuples( fusion, x^-1 ) );
> # For computing representatives, 'RepresentativesFusions' is not
> # suitable because 'allfusions' is in generally not closed
> # under the actions.
> # reps:= RepresentativesFusions( maut, allfusions, admiss );
> orbits:= [];
> while not IsEmpty( allfusions ) do
> orbit:= OrbitFusions( maut, allfusions[1], admiss );
> Add( orbits, orbit );
> SubtractSet( allfusions, orbit );
> od;
> reps:= List( orbits, x -> x[1] );
> if Length( reps ) = 1 then
> # Reduce the symmetries that are still available.
> admiss:= Stabilizer( admiss,
> Set( OrbitFusions( maut, fusion, triv ) ),
> OnSetsTuples );
> else
> # We have found a generality problem.
> return consider;
> fi;
> od;
> # There is no generality problem for this table.
> return [];
> end;;
</pre></div>

Let us look at a small example, the \(5\)-modular character table of the group \(2.A_5.2\). The irreducible characters of degree \(2\) have the values \(\pm \sqrt{{-2}}\) on the classes <code class="code">8a</code> and <code class="code">8b</code>, and the values \(\pm \sqrt{{-3}}\) on the classes <code class="code">6b</code> and <code class="code">6c</code>. When we define which of the two classes of element order \(8\) is called <code class="code">8a</code>, this will also define which class is called <code class="code">6b</code>. The ordinary character table does not relate the two pairs of classes, there are table automorphisms which interchange each pair independently. This symmetry is thus broken in the \(5\)-modular character table.

<div class="example"><pre>
gap> t:= CharacterTable( "2.A5.2" );;
gap> m:= t mod 5;;
gap> Display( m );
2.A5.2mod5

 2 4 4 3 2 2 2 3 3 2 2
 3 1 1 . 1 1 1 . . 1 1
 5 1 1 . . . . . . . .

 1a 2a 4a 3a 6a 2b 8a 8b 6b 6c
 2P 1a 1a 2a 3a 3a 1a 4a 4a 3a 3a
 3P 1a 2a 4a 1a 2a 2b 8a 8b 2b 2b
 5P 1a 2a 4a 3a 6a 2b 8b 8a 6c 6b

X.1 1 1 1 1 1 1 1 1 1 1
X.2 1 1 1 1 1 -1 -1 -1 -1 -1
X.3 3 3 -1 . . 1 -1 -1 -2 -2
X.4 3 3 -1 . . -1 1 1 2 2
X.5 5 5 1 -1 -1 1 -1 -1 1 1
X.6 5 5 1 -1 -1 -1 1 1 -1 -1
X.7 2 -2 . -1 1 . A -A B -B
X.8 2 -2 . -1 1 . -A A -B B
X.9 4 -4 . 1 -1 . . . B -B
X.10 4 -4 . 1 -1 . . . -B B

A = E(8)+E(8)^3
 = Sqrt(-2) = i2
B = E(3)-E(3)^2
 = Sqrt(-3) = i3
gap> AutomorphismsOfTable( t );
Group([ (11,12), (9,10) ])
gap> AutomorphismsOfTable( m );
Group([ (7,8)(9,10) ])
gap> GetFusionMap( m, t );
[ 1, 2, 3, 4, 5, 8, 9, 10, 11, 12 ]
gap> BrokenSymmetries( t, m );
true
gap> BrokenSymmetries( t, t mod 2 );
false
gap> BrokenSymmetries( t, t mod 3 );
false
gap> PrimesOfGeneralityProblems( t );
[ ]
</pre></div>

Since no symmetry is broken in the \(2\)- and \(3\)-modular character tables of \(G\), there is no generality problem in this case.

For an example of a generality problem, we look at the smallest Janko group \(J_1\). As is mentioned in <a href="chapBib_mj.html#biBJLPW95">[JLPW95, p. x]</a>, the unique irreducible \(11\)-modular Brauer character of degree \(7\) distinguishes the two (algebraically conjugate) classes of element order \(5\). Since also the unique irreducible \(19\)-modular Brauer character of degree \(22\) distinguishes these classes, we have to choose these classes consistently.

<div class="example"><pre>
gap> t:= CharacterTable( "J1" );;
gap> m:= t mod 11;;
gap> Display( m, rec( chars:= Filtered( Irr( m ), x -> x[1] = 7 ) ) );
J1mod11

 2 3 3 1 1 1 1 . 1 1 . . . . .
 3 1 1 1 1 1 1 . . . 1 1 . . .
 5 1 1 1 1 1 . . 1 1 1 1 . . .
 7 1 . . . . . 1 . . . . . . .
 11 1 . . . . . . . . . . . . .
 19 1 . . . . . . . . . . 1 1 1

 1a 2a 3a 5a 5b 6a 7a 10a 10b 15a 15b 19a 19b 19c
 2P 1a 1a 3a 5b 5a 3a 7a 5b 5a 15b 15a 19b 19c 19a
 3P 1a 2a 1a 5b 5a 2a 7a 10b 10a 5b 5a 19b 19c 19a
 5P 1a 2a 3a 1a 1a 6a 7a 2a 2a 3a 3a 19b 19c 19a
 7P 1a 2a 3a 5b 5a 6a 1a 10b 10a 15b 15a 19a 19b 19c
 11P 1a 2a 3a 5a 5b 6a 7a 10a 10b 15a 15b 19a 19b 19c
 19P 1a 2a 3a 5a 5b 6a 7a 10a 10b 15a 15b 1a 1a 1a

Y.1 7 -1 1 A *A -1 . B *B C *C D E F

A = E(5)+E(5)^4
 = (-1+Sqrt(5))/2 = b5
B = -E(5)-2*E(5)^2-2*E(5)^3-E(5)^4
 = (3+Sqrt(5))/2 = 2+b5
C = -2*E(5)-2*E(5)^4
 = 1-Sqrt(5) = 1-r5
D = -E(19)-E(19)^2-E(19)^3-E(19)^5-E(19)^7-E(19)^8-E(19)^11-E(19)^12-E\
(19)^14-E(19)^16-E(19)^17-E(19)^18
E = -E(19)^2-E(19)^3-E(19)^4-E(19)^5-E(19)^6-E(19)^9-E(19)^10-E(19)^13\
-E(19)^14-E(19)^15-E(19)^16-E(19)^17
F = -E(19)-E(19)^4-E(19)^6-E(19)^7-E(19)^8-E(19)^9-E(19)^10-E(19)^11-E\
(19)^12-E(19)^13-E(19)^15-E(19)^18
gap> m:= t mod 19;;
gap> Display( m, rec( chars:= Filtered( Irr( m ), x -> x[1] = 22 ) ) );
J1mod19

 2 3 3 1 1 1 1 . 1 1 . . .
 3 1 1 1 1 1 1 . . . . 1 1
 5 1 1 1 1 1 . . 1 1 . 1 1
 7 1 . . . . . 1 . . . . .
 11 1 . . . . . . . . 1 . .
 19 1 . . . . . . . . . . .

 1a 2a 3a 5a 5b 6a 7a 10a 10b 11a 15a 15b
 2P 1a 1a 3a 5b 5a 3a 7a 5b 5a 11a 15b 15a
 3P 1a 2a 1a 5b 5a 2a 7a 10b 10a 11a 5b 5a
 5P 1a 2a 3a 1a 1a 6a 7a 2a 2a 11a 3a 3a
 7P 1a 2a 3a 5b 5a 6a 1a 10b 10a 11a 15b 15a
 11P 1a 2a 3a 5a 5b 6a 7a 10a 10b 1a 15a 15b
 19P 1a 2a 3a 5a 5b 6a 7a 10a 10b 11a 15a 15b

Y.1 22 -2 1 A *A 1 1 -A -*A . B *B

A = E(5)+E(5)^4
 = (-1+Sqrt(5))/2 = b5
B = -2*E(5)-2*E(5)^4
 = 1-Sqrt(5) = 1-r5
</pre></div>

Note that the degree \(7\) character above also distinguishes the three classes of element order \(19\), and the same holds for the unique irreducible degree \(31\) character from characteristic \(7\). Thus also the prime \(7\) occurs in the list of candidates for generality problems.

<div class="example"><pre>
gap> PrimesOfGeneralityProblems( t );
[ 7, 11, 19 ]
</pre></div>

Finally, we list the candidates for generality problems from GAP's Character Table Library.

<div class="example"><pre>
gap> list:= [];;
gap> isGeneralityProblem:= function( ordtbl )
> local res;
> res:= PrimesOfGeneralityProblems( ordtbl );
> if res = [] then
> return false;
> fi;
> Add( list, [ Identifier( ordtbl ), res ] );
> return true;
> end;;
gap> AllCharacterTableNames( IsDuplicateTable, false,
> isGeneralityProblem, true );;
gap> PrintArray( SortedList( list ) );
[ [ (2.A4x2.G2(4)).2, [ 2, 5, 7, 13 ] ],
 [ (2^2x3).L3(4).2_1, [ 5, 7 ] ],
 [ (2x12).L3(4), [ 2, 3, 7 ] ],
 [ (4^2x3).L3(4), [ 2, 3, 7 ] ],
 [ (7:3xHe):2, [ 5, 7, 17 ] ],
 [ (A5xA12):2, [ 2, 3 ] ],
 [ (D10xHN).2, [ 2, 3, 5, 7, 11, 19 ] ],
 [ (S3x2.Fi22).2, [ 3, 11, 13 ] ],
 [ 12.M22, [ 2, 5, 7, 11 ] ],
 [ 12.M22.2, [ 2, 5, 7, 11 ] ],
 [ 12_1.L3(4).2_1, [ 5, 7 ] ],
 [ 12_2.L3(4), [ 2, 3, 7 ] ],
 [ 12_2.L3(4).2_1, [ 3, 5, 7 ] ],
 [ 12_2.L3(4).2_2, [ 2, 3, 7 ] ],
 [ 12_2.L3(4).2_3, [ 2, 3, 7 ] ],
 [ 2.(A4xG2(4)).2, [ 2, 5, 7, 13 ] ],
 [ 2.2E6(2), [ 13, 19 ] ],
 [ 2.2E6(2).2, [ 13, 19 ] ],
 [ 2.A10, [ 5, 7 ] ],
 [ 2.A11, [ 3, 5, 7 ] ],
 [ 2.A11.2, [ 5, 7, 11 ] ],
 [ 2.A12, [ 2, 3, 5, 7 ] ],
 [ 2.A12.2, [ 5, 7, 11 ] ],
 [ 2.A13, [ 2, 3, 5, 7, 11 ] ],
 [ 2.A13.2, [ 5, 7, 13 ] ],
 [ 2.Alt(14), [ 2, 3, 5, 7 ] ],
 [ 2.Alt(15), [ 2, 5, 7 ] ],
 [ 2.Alt(16), [ 2, 3, 5, 7 ] ],
 [ 2.Alt(17), [ 2, 3, 5, 7 ] ],
 [ 2.Alt(18), [ 2, 3, 5, 7 ] ],
 [ 2.B, [ 17, 23 ] ],
 [ 2.F4(2), [ 2, 7, 13, 17 ] ],
 [ 2.Fi22.2, [ 11, 13 ] ],
 [ 2.G2(4), [ 2, 7 ] ],
 [ 2.G2(4).2, [ 5, 7, 13 ] ],
 [ 2.HS, [ 3, 5, 7, 11 ] ],
 [ 2.HS.2, [ 3, 11 ] ],
 [ 2.L3(4).2_1, [ 5, 7 ] ],
 [ 2.Ru, [ 5, 7, 13, 29 ] ],
 [ 2.Suz, [ 2, 5, 11 ] ],
 [ 2.Suz.2, [ 3, 7, 13 ] ],
 [ 2.Sym(15), [ 3, 5, 7 ] ],
 [ 2.Sym(16), [ 3, 5, 7 ] ],
 [ 2.Sym(17), [ 3, 5, 7 ] ],
 [ 2.Sym(18), [ 5, 7 ] ],
 [ 2.Sz(8), [ 2, 5, 13 ] ],
 [ 2^2.2E6(2), [ 13, 19 ] ],
 [ 2^2.2E6(2).2, [ 13, 19 ] ],
 [ 2^2.Fi22.2, [ 3, 11, 13 ] ],
 [ 2^2.L3(4).2^2, [ 5, 7 ] ],
 [ 2^2.L3(4).2_1, [ 5, 7 ] ],
 [ 2^2.Sz(8), [ 2, 5, 13 ] ],
 [ 2x2.F4(2), [ 2, 7, 13, 17 ] ],
 [ 2x3.Fi22, [ 2, 3, 5 ] ],
 [ 2x6.Fi22, [ 2, 3, 5 ] ],
 [ 2x6.M22, [ 2, 5, 11 ] ],
 [ 2xFi22.2, [ 11, 13 ] ],
 [ 2xFi23, [ 3, 17, 23 ] ],
 [ 3.Fi22, [ 2, 3, 5 ] ],
 [ 3.Fi22.2, [ 2, 5, 11, 13 ] ],
 [ 3.J3, [ 2, 17, 19 ] ],
 [ 3.J3.2, [ 2, 5, 17, 19 ] ],
 [ 3.L3(4).2_3, [ 2, 3, 7 ] ],
 [ 3.L3(4).3.2_3, [ 2, 3, 7 ] ],
 [ 3.L3(7).2, [ 3, 7, 19 ] ],
 [ 3.L3(7).S3, [ 3, 7, 19 ] ],
 [ 3.McL, [ 2, 5, 11 ] ],
 [ 3.McL.2, [ 2, 3, 5, 11 ] ],
 [ 3.ON, [ 3, 7, 11, 19, 31 ] ],
 [ 3.ON.2, [ 3, 5, 7, 11, 19, 31 ] ],
 [ 3.Suz.2, [ 2, 3, 13 ] ],
 [ 3x2.F4(2), [ 2, 7, 13, 17 ] ],
 [ 3x2.Fi22.2, [ 11, 13 ] ],
 [ 3x2.G2(4), [ 2, 7 ] ],
 [ 3xFi23, [ 3, 17, 23 ] ],
 [ 3xJ1, [ 7, 11, 19 ] ],
 [ 3xL3(7).2, [ 3, 7, 19 ] ],
 [ 4.HS.2, [ 5, 7, 11 ] ],
 [ 4.M22, [ 5, 7 ] ],
 [ 4_1.L3(4).2_1, [ 5, 7 ] ],
 [ 4_2.L3(4).2_1, [ 3, 5, 7 ] ],
 [ 6.Fi22, [ 2, 3, 5 ] ],
 [ 6.Fi22.2, [ 2, 5, 11, 13 ] ],
 [ 6.L3(4).2_1, [ 5, 7 ] ],
 [ 6.M22, [ 2, 5, 11 ] ],
 [ 6.O7(3), [ 3, 5, 13 ] ],
 [ 6.O7(3).2, [ 3, 5, 13 ] ],
 [ 6.Suz, [ 2, 5, 11 ] ],
 [ 6.Suz.2, [ 2, 3, 5, 7, 13 ] ],
 [ 6x2.F4(2), [ 2, 7, 13, 17 ] ],
 [ A12, [ 2, 3 ] ],
 [ A14, [ 2, 5, 7 ] ],
 [ A17, [ 2, 7 ] ],
 [ A18, [ 2, 3, 5, 7 ] ],
 [ B, [ 13, 17, 23, 31 ] ],
 [ F3+, [ 17, 23, 29 ] ],
 [ F3+.2, [ 17, 23, 29 ] ],
 [ Fi22.2, [ 11, 13 ] ],
 [ Fi23, [ 3, 17, 23 ] ],
 [ HN, [ 2, 3, 11, 19 ] ],
 [ HN.2, [ 5, 7, 11, 19 ] ],
 [ He, [ 5, 17 ] ],
 [ He.2, [ 5, 7, 17 ] ],
 [ Isoclinic(12.M22.2), [ 2, 5, 7, 11 ] ],
 [ Isoclinic(12_1.L3(4).2_1), [ 5, 7 ] ],
 [ Isoclinic(12_2.L3(4).2_1), [ 3, 5, 7 ] ],
 [ Isoclinic(12_2.L3(4).2_3), [ 2, 3, 7 ] ],
 [ Isoclinic(2.A11.2), [ 5, 7, 11 ] ],
 [ Isoclinic(2.A12.2), [ 5, 7, 11 ] ],
 [ Isoclinic(2.A13.2), [ 5, 7, 13 ] ],
 [ Isoclinic(2.Fi22.2), [ 11, 13 ] ],
 [ Isoclinic(2.G2(4).2), [ 5, 7, 13 ] ],
 [ Isoclinic(2.HS.2), [ 3, 11 ] ],
 [ Isoclinic(2.HSx2), [ 3, 5, 7, 11 ] ],
 [ Isoclinic(2.L3(4).2_1), [ 5, 7 ] ],
 [ Isoclinic(2.Suz.2), [ 3, 7, 13 ] ],
 [ Isoclinic(4_1.L3(4).2_1), [ 5, 7 ] ],
 [ Isoclinic(4_2.L3(4).2_1), [ 3, 5, 7 ] ],
 [ Isoclinic(6.Fi22.2), [ 2, 5, 11, 13 ] ],
 [ Isoclinic(6.L3(4).2_1), [ 5, 7 ] ],
 [ Isoclinic(6.O7(3).2), [ 3, 5, 13 ] ],
 [ Isoclinic(6.Suz.2), [ 2, 3, 5, 7, 13 ] ],
 [ J1, [ 7, 11, 19 ] ],
 [ J1x2, [ 7, 11, 19 ] ],
 [ J3, [ 2, 17, 19 ] ],
 [ J3.2, [ 2, 5, 17, 19 ] ],
 [ L3(4).2_3, [ 3, 7 ] ],
 [ L3(4).3.2_3, [ 2, 3, 7 ] ],
 [ L3(7).2, [ 3, 7, 19 ] ],
 [ L3(7).S3, [ 3, 7, 19 ] ],
 [ L3(9).2_1, [ 3, 7, 13 ] ],
 [ L5(2).2, [ 2, 7, 31 ] ],
 [ Ly, [ 7, 37, 67 ] ],
 [ M23, [ 2, 3, 23 ] ],
 [ ON, [ 3, 7, 11, 19, 31 ] ],
 [ ON.2, [ 3, 5, 7, 11, 19, 31 ] ],
 [ Ru, [ 5, 7, 13, 29 ] ],
 [ S3xFi22.2, [ 11, 13 ] ],
 [ Suz.2, [ 3, 13 ] ] ]
</pre></div>

Note that this list may become longer as new Brauer tables become available. (For example, the prime \(2\) was added to the entries for extensions of \(F_4(2)\) when the \(2\)-modular table of \(F_4(2)\) became available.)

<a id="X80EB5D827A78975A" name="X80EB5D827A78975A"></a>

<h5>1.3-2 A generality problem concerning the group \(J_3\) (April 2015)</h5>

<a name="generality_problem_J3">In March 2015,</a> Klaus Lux reported an inconsistency in the character data of GAP:

The sporadic simple Janko group \(J_3\) has a unique \(19\)-modular irreducible Brauer character of degree \(110\). In the character table that is printed in the Atlas of Brauer characters <a href="chapBib_mj.html#biBJLPW95">[JLPW95, p. 219]</a>, the Brauer character value on the class <code class="code">17A</code> is \(b_{17}\). The Atlas of Group Representations <a href="chapBib_mj.html#biBAGRv3">[WWT+]</a> provides a straight line program for computing class representatives of \(J_3\). If we compute the Brauer character value in question, we do not get \(b_{17}\) but its algebraic conjugate, \(-1-b_{17}\).

<div class="example"><pre>
gap> t:= CharacterTable( "J3" );;
gap> m:= t mod 19;;
gap> cand:= Filtered( Irr( m ), x -> x[1] = 110 );;
gap> Length( cand );
1
gap> slp:= AtlasProgram( "J3", "classes" );;
gap> 17a:= Position( slp.outputs, "17A" );
18
gap> info:= OneAtlasGeneratingSetInfo( "J3", Characteristic, 19,
> Dimension, 110 );;
gap> gens:= AtlasGenerators( info );;
gap> reps:= ResultOfStraightLineProgram( slp.program,
> gens.generators );;
gap> Quadratic( BrauerCharacterValue( reps[ 17a ] ) );
rec( ATLAS := "-1-b17", a := -1, b := -1, d := 2,
 display := "(-1-Sqrt(17))/2", root := 17 )
</pre></div>

How shall we resolve this inconsistency, by replacing the straight line program or by swapping the classes <code class="code">17A</code> and <code class="code">17B</code> in the character table? Before we decide this, we look at related information.

The following table lists the \(p\)-modular irreducible characters of \(J_3\), according to <a href="chapBib_mj.html#biBJLPW95">[JLPW95]</a>, that can be used to define which of the two classes of element order \(17\) shall be called <code class="code">17A</code>; a \(+\) sign in the last column of the table indicates that the representation is available in the Atlas of Group Representations.

<div class="pcenter"><table class="GAPDocTable">
<caption class="GAPDocTable">Table: Representations of \(J_3\) that may define <code class="code">17A</code></caption>
<tr>
<td class="tdright">\(p\)</td>
<td class="tdright">\(\varphi(1)\)</td>
<td class="tdright">\(\varphi(\)<code class="code">17A</code>\()\)</td>
<td class="tdright">\(\varphi(\)<code class="code">17B</code>\()\)</td>
<td class="tdcenter">Atlas?</td>
</tr>
<tr>
<td class="tdright">\(2\)</td>
<td class="tdright">\(78\)</td>
<td class="tdright">\(1-b_{17}\)</td>
<td class="tdright">\(2+b_{17}\)</td>
<td class="tdcenter">\(+\)</td>
</tr>
<tr>
<td class="tdright">\(2\)</td>
<td class="tdright">\(80\)</td>
<td class="tdright">\(3-b_{17}\)</td>
<td class="tdright">\(4+b_{17}\)</td>
<td class="tdcenter">\(+\)</td>
</tr>
<tr>
<td class="tdright">\(2\)</td>
<td class="tdright">\(244\)</td>
<td class="tdright">\(b_{17}-2\)</td>
<td class="tdright">\(-3-b_{17}\)</td>
<td class="tdcenter">\(+\)</td>
</tr>
<tr>
<td class="tdright">\(2\)</td>
<td class="tdright">\(966\)</td>
<td class="tdright">\(r_{17}-3\)</td>
<td class="tdright">\(-3-r_{17}\)</td>
<td class="tdcenter">\(+\)</td>
</tr>
<tr>
<td class="tdright">\(19\)</td>
<td class="tdright">\(110\)</td>
<td class="tdright">\(b_{17}\)</td>
<td class="tdright">\(-1-b_{17}\)</td>
<td class="tdcenter">\(+\)</td>
</tr>
<tr>
<td class="tdright">\(19\)</td>
<td class="tdright">\(214\)</td>
<td class="tdright">\(1-b_{17}\)</td>
<td class="tdright">\(2+b_{17}\)</td>
<td class="tdcenter">\(+\)</td>
</tr>
<tr>
<td class="tdright">\(19\)</td>
<td class="tdright">\(706\)</td>
<td class="tdright">\(-b_{17}\)</td>
<td class="tdright">\(1+b_{17}\)</td>
<td class="tdcenter">\(+\)</td>
</tr>
<tr>
<td class="tdright">\(19\)</td>
<td class="tdright">\(1214\)</td>
<td class="tdright">\(-1+b_{17}\)</td>
<td class="tdright">\(-2-b_{17}\)</td>
<td class="tdcenter">\(-\)</td>
</tr>
</table> 
</div>

Note that the irreducible Brauer characters in characteristic \(3\) and \(5\) that distinguish the two classes <code class="code">17A</code> and <code class="code">17B</code> occur in pairs of Galois conjugate characters.

The following computations show that the given straight line program is compatible with the four characters in characteristic \(2\) but is not compatible with the three available characters in characteristic \(19\).

<div class="example"><pre>
gap> table:= [];;
gap> for pair in [ [ 2, [ 78, 80, 244, 966 ] ],
> [ 19, [ 110, 214, 706 ] ] ] do
> p:= pair[1];
> for d in pair[2] do
> info:= OneAtlasGeneratingSetInfo( "J3", Characteristic, p,
> Dimension, d );
> gens:= AtlasGenerators( info );
> reps:= ResultOfStraightLineProgram( slp.program,
> gens.generators );
> val:= BrauerCharacterValue( reps[ 17a ] );
> Add( table, [ p, d, Quadratic( val ).ATLAS,
> Quadratic( StarCyc( val ) ).ATLAS ] );
> od;
> od;
gap> PrintArray( table );
[ [ 2, 78, 1-b17, 2+b17 ],
 [ 2, 80, 3-b17, 4+b17 ],
 [ 2, 244, -2+b17, -3-b17 ],
 [ 2, 966, -3+r17, -3-r17 ],
 [ 19, 110, -1-b17, b17 ],
 [ 19, 214, 2+b17, 1-b17 ],
 [ 19, 706, 1+b17, -b17 ] ]
</pre></div>

We see that the problem is an inconsistency between the \(2\)-modular and the \(19\)-modular character table of \(J_3\) in <a href="chapBib_mj.html#biBJLPW95">[JLPW95]</a>. In particular, changing the straight line program would not help to resolve the problem.

How shall we proceed in order to fix the problem? We can decide to keep the \(19\)-modular table of \(J_3\), and to swap the two classes of element order \(17\) in the \(2\)-modular table; then also the straight line program has to be changed, and the classes of element orders \(17\) and \(51\) in the \(2\)-modular character table of the triple cover \(3.J_3\) of \(J_3\) have to be adjusted. Alternatively, we can keep the \(2\)-modular table of \(J_3\) and the straight line program, and adjust the conjugacy classes of element orders divisible by \(17\) in the \(19\)-modular character tables of \(J_3\), \(3.J_3\), \(J_3.2\), and \(3.J_3.2\).

We decide to change the \(19\)-modular character tables. Note that these character tables —or equivalently, the corresponding Brauer trees— have been described in <a href="chapBib_mj.html#biBHL89">[HL89]</a>, where explicit choices are mentioned that lead to the shown Brauer trees. Questions about the consistency with Brauer tables in other characteristic had not been an issue in this book. (Only the consistency of the Brauer trees among the \(19\)-blocks of \(3.J_3\) is mentioned.) In fact, the book mentions that the \(19\)-modular Brauer trees for \(J_3\) had been computed already by W. Feit. The inconsistency of Brauer character tables in different characteristic has apparently been overlooked when the data for <a href="chapBib_mj.html#biBJLPW95">[JLPW95]</a> have been put together, and had not been detected until now.

Remarks:

<ul>
<li>Such a change of a Brauer table can in general affect the class fusions from and to this table. Note that Brauer tables may impose conditions on the choice of the fusion among possible fusions that are equivalent w. r. t. the table automorphisms of the ordinary table. In this particular case, in fact no class fusion had to be changed, see the sections <a href="chap9_mj.html#X7ACC7F588213D5D5">9.6-1</a> and Section <a href="chap9_mj.html#X7DED4C437D479226">9.6-3</a>.

</li>
<li>The change of the character tables affects the decomposition matrices. Thus the PDF files containing the \(19\)-modular decomposition matrices had to be updated, see <a href="http://www.math.rwth-aachen.de/~Thomas.Breuer/ctbllib/dec/tex/J3/index.html">http://www.math.rwth-aachen.de/~Thomas.Breuer/ctbllib/dec/tex/J3/index.html</a>.

</li>
<li>Jürgen Müller has checked that the conjugacy classes of all Brauer tables of \(J_3\), \(3.J_3\), \(J_3.2\), \(3.J_3.2\) are consistent after the fix described above.

</li>
</ul>
<a id="X82C37532783168AA" name="X82C37532783168AA"></a>

<h5>1.3-3 A generality problem concerning the group \(HN\) (August 2022)</h5>

The classes <code class="code">20A</code>, <code class="code">20B</code> of the Harada-Norton group \(HN\) in the \(11\)- and \(19\)-modular character tables are determined by unique Brauer characters that have different values on these classes. Once we have defined these classes in one characteristic, the two Brauer characters tell us how to choose them consistently in the other characteristic. Thus the question is whether the two Brauer tables are consistent w.r.t. this property or not.

(Note that this question can be answered independently of all other questions of this kind for \(HN\), because the permutation that swaps exactly the classes <code class="code">20A</code> and <code class="code">20B</code> is a table automorphism of the ordinary character table of \(HN\).)

We start with the ordinary character table of \(HN\). There are exactly two ordinary irreducible characters that take different values on the classes <code class="code">20A</code>, <code class="code">20B</code>, these are \(\chi_{51}\) and \(\chi_{52}\).

<div class="example"><pre>
gap> t:= CharacterTable( "HN" );;
gap> pos20:= Positions( OrdersClassRepresentatives( t ), 20 );
[ 39, 40, 41, 42, 43 ]
gap> diff:= Filtered( Irr( t ), x -> x[39] <> x[40] );;
gap> List( diff, x -> Position( Irr( t ), x ) );
[ 51, 52 ]
</pre></div>

These values are irrational and lie in the field that is generated by the square root of \(5\).

<div class="example"><pre>
gap> List( diff, x -> List( x{ [ 1, 39, 40 ] },
> CTblLib.StringOfAtlasIrrationality ) );
[ [ "5103000", "2r5+1", "-2r5+1" ], [ "5103000", "-2r5+1", "2r5+1" ] ]
</pre></div>

In each of the characteristics \(p \in \{ 11, 19 \}\), the \(p\)-modular reductions of \(\chi_{51}\) and \(\chi_{52}\) decompose differently into irreducibles. Note that the Galois automorphism of the ordinary character table that maps \(\sqrt{5}\) to \(-\sqrt{5}\) does not live in the \(11\)- and \(19\)-modular Brauer tables.

For \(p = 11\), the reduction of \(\chi_{51}\) is \(\varphi_{40} + \varphi_{48}\), with \(\varphi_{40}(1) = 1\,575\,176\) and \(\varphi_{48}(1) = 3\,527\,824\), and the reduction of \(\chi_{52}\) is \(\varphi_{39} + \varphi_{49}\), with \(\varphi_{39}(1) = 1\,361\,919\) and \(\varphi_{49}(1) = 3\,741\,081\).

<div class="example"><pre>
gap> t11:= t mod 11;;
gap> rest11:= RestrictedClassFunctions( diff, t11 );;
gap> dec11:= Decomposition( Irr( t11 ), rest11, "nonnegative" );;
gap> List( dec11, Set );
[ [ 0, 1 ], [ 0, 1 ] ]
gap> List( dec11, x -> Positions( x, 1 ) );
[ [ 40, 48 ], [ 39, 49 ] ]
gap> List( Irr( t11 ){ [ 40, 48 ] }, x -> x[1] );
[ 1575176, 3527824 ]
gap> List( Irr( t11 ){ [ 39, 49 ] }, x -> x[1] );
[ 1361919, 3741081 ]
</pre></div>

For \(p = 19\), the reduction of \(\chi_{51}\) is \(\varphi_{42} + \varphi_{45}\), with \(\varphi_{42}(1) = 2\,125\,925\) and \(\varphi_{45}(1) = 2\,977\,075\), and the reduction of \(\chi_{52}\) is \(\varphi_{33} + \varphi_{48}\), with \(\varphi_{33}(1) = 1\,197\,330\) and \(\varphi_{48}(1) = 3\,905\,670\).

<div class="example"><pre>
gap> t19:= t mod 19;;
gap> rest19:= RestrictedClassFunctions( diff, t19 );;
gap> dec19:= Decomposition( Irr( t19 ), rest19, "nonnegative" );;
gap> List( dec19, Set );
[ [ 0, 1 ], [ 0, 1 ] ]
gap> List( dec19, x -> Positions( x, 1 ) );
[ [ 42, 45 ], [ 33, 48 ] ]
gap> List( Irr( t19 ){ [ 42, 45 ] }, x -> x[1] );
[ 2125925, 2977075 ]
gap> List( Irr( t19 ){ [ 33, 48 ] }, x -> x[1] );
[ 1197330, 3905670 ]
</pre></div>

The Frobenius-Schur indicators of all involved \(p\)-modular constituents are \(+\). This implies that \(\chi_{51}\) reduces orthogonally stably modulo \(11\) but not orthogonally stably modulo \(19\), whereas \(\chi_{52}\) reduces orthogonally stably modulo \(19\) but not orthogonally stably modulo \(11\).

<div class="example"><pre>
gap> Indicator( t11, 2 ){ [ 39, 40, 48, 49 ] };
[ 1, 1, 1, 1 ]
gap> Indicator( t19, 2 ){ [ 33, 42, 45, 48 ] };
[ 1, 1, 1, 1 ]
</pre></div>

In version up to 1.3.4 of the character table library, this condition was not satisfied: The reduction of \(\chi_{51}\) modulo both \(11\) and \(19\) was orthogonally stable, and the reduction of \(\chi_{52}\) modulo both \(11\) and \(19\) was not orthogonally stable. However, this cannot happen, due to theoretical results about orthogonal discriminants of the involved characters. Thus we have found a way to decide the consistency of the classes <code class="code">20A</code> and <code class="code">20B</code> in characteristics \(11\) and \(19\): Either the \(11\)-modular character table or the \(19\)-modular character table of \(HN\) had to be changed for version 1.3.5, by swapping the classes <code class="code">20A</code> and <code class="code">20B</code>.

We decided to change the \(11\)-modular table, because there are no other generality problems for \(HN\) involving the \(19\)-modular table, and hence we are sure that this table will not need to be changed because of new solutions to generality problems.

For \(HN.2\), the situation is similar. There are additionally two classes of element order \(40\) that have to be swapped if <code class="code">20A</code> and <code class="code">20B</code> get swapped. Thus we have to change the \(11\)-modular table of \(HN.2\) accordingly.

Changes of this kind may affect also derived character tables in the library. In this case, the \(11\)-modular table with identifier <code class="code">"(D10xHN).2"</code> was changed as well. Note that this table is not stored explicitly in the data files, it gets constructed from ordinary and modular library tables via <code class="func">ConstructIndexTwoSubdirectProduct</code> (<a href="../doc/chap5_mj.html#X8714D24B802DA949">CTblLib: ConstructIndexTwoSubdirectProduct</a>).

<a id="X7D8C6D1883C9CECA" name="X7D8C6D1883C9CECA"></a>

<h4>1.4 Brauer Tables that can be derived from Known Tables</h4>

In a few situations, one can derive the \(p\)-modular Brauer character table of a group from known character theoretic information.

For quite some time, a method is available in GAP that computes the Brauer characters of \(p\)-solvable groups (see <a href="../../../doc/ref/chap71_mj.html#X8476B25A79D7A7FC">Reference: BrauerTable</a> and <a href="../../../doc/ref/chap71_mj.html#X7A0CBD1884276882">Reference: IsPSolubleCharacterTable</a>).

The following sections list other situations where Brauer tables can be computed by GAP.

<a id="X7DF018B77E722CA7" name="X7DF018B77E722CA7"></a>

<h5>1.4-1 Brauer Tables via Construction Information</h5>

If a given ordinary character table \(t\), say, has been constructed from other ordinary character tables then GAP may be able to create the \(p\)-modular Brauer table of \(t\) from the \(p\)-modular Brauer tables of the <q>ingredients</q>. This happens currently in the following cases.

<ul>
<li>\(t\) has been constructed with <code class="func">CharacterTableDirectProduct</code> (<a href="../../../doc/ref/chap71_mj.html#X7BE1572D7BBC6AC8">Reference: CharacterTableDirectProduct</a>), and GAP can compute the \(p\)-modular Brauer tables of the direct factors.

</li>
<li>\(t\) has been constructed with <code class="func">CharacterTableIsoclinic</code> (<a href="../../../doc/ref/chap71_mj.html#X85BE46F784B83938">Reference: CharacterTableIsoclinic</a>), and GAP can compute the \(p\)-modular Brauer table of the table that is stored in \(t\) as the value of the attribute <code class="func">SourceOfIsoclinicTable</code> (<a href="../../../doc/ref/chap71_mj.html#X85BE46F784B83938">Reference: SourceOfIsoclinicTable</a>).

</li>
<li>\(t\) has the attribute <code class="func">ConstructionInfoCharacterTable</code> (<a href="../doc/chap3_mj.html#X851118377D1D6EC9">CTblLib: ConstructionInfoCharacterTable</a>) set, the first entry of this list \(l\), say, is one of the strings <code class="code">"ConstructGS3"</code> (see <a href="chap2_mj.html#X7CCABDDE864E6300">2.3-2</a>), <code class="code">"ConstructIndexTwoSubdirectProduct"</code> (see <a href="chap2_mj.html#X788591D78451C024">2.3-6</a>), <code class="code">"ConstructMGA"</code> (see <a href="chap2_mj.html#X82E75B6880EC9E6C">2.3-1</a>), <code class="code">"ConstructPermuted"</code>, <code class="code">"ConstructV4G"</code> (see <a href="chap2_mj.html#X81464C4B8178C85A">2.3-4</a>), and GAP can construct the \(p\)-modular Brauer table(s) of the relevant ordinary character table(s), which are library tables whose names occur in \(l\).

</li>
</ul>
<a id="X795419A287BD228E" name="X795419A287BD228E"></a>

<h5>1.4-2 Liftable Brauer Characters (May 2017)</h5>

Let \(B\) be a \(p\)-block of cyclic defect for the finite group \(G\). It can be read off from the set Irr\((B)\) of ordinary irreducible characters of \(B\) whether all irreducible Brauer characters in \(B\) are restrictions of ordinary characters to the \(p\)-regular classes of \(G\), as follows.

If \(B\) has only one irreducible Brauer character then all ordinary characters in \(B\) restrict to this Brauer character. So let us assume that \(B\) contains at least two irreducible Brauer characters, and consider the set \(S\), say, of restrictions of Irr\((B)\) to the \(p\)-regular classes of \(G\).

The block \(B\) contains exactly \(|S| - 1\) irreducible Brauer characters, and the decomposition of the characters in \(S\) into these Brauer characters is described by an \(|S|\) by \(|S| - 1\) matrix \(M\), say, whose entries are zero and one, such that exactly two nonzero entries occur in each column. (See for example <a href="chapBib_mj.html#biBHL89">[HL89, Theorem 2.1.5]</a>, which refers to <a href="chapBib_mj.html#biBDad66">[Dad66]</a>.)

If all irreducible Brauer characters of \(B\) occur in \(S\) then the matrix \(M\) contains \(|S| - 1\) rows that contain exactly one nonzero entry, hence the remaining row consists only of \(1\)s. This means that the element of largest degree in \(S\) is equal to the sum of all other elements in \(S\). Conversely, if the element of largest degree in \(S\) is equal to the sum of all other elements in \(S\) then the matrix \(M\) has the structure as stated above, hence all irreducible Brauer characters of \(B\) occur in \(S\).

Alternatively, one could state that all irreducible Brauer characters of \(B\) are restricted ordinary characters if and only if the Brauer tree of \(B\) is a star (see <a href="chapBib_mj.html#biBHL89">[HL89, p. 2]</a>. If \(B\) contains at least two irreducible Brauer characters then this happens if and only if one of the types \(\times\) or \(\circ\) occurs for exactly one node in the Brauer graph of \(B\), see <a href="chapBib_mj.html#biBHL89">[HL89, Lemma 2.1.13]</a>, and the distribution to types is determined by Irr\((B)\).

The default method for <code class="func">BrauerTableOp</code> (<a href="../../../doc/ref/chap71_mj.html#X8476B25A79D7A7FC">Reference: BrauerTableOp</a>) that is contained in the GAP library has been extended in version 4.11 such that it checks whether the Sylow \(p\)-subgroups of the given group \(G\) are cyclic and, if yes, whether all \(p\)-blocks of \(G\) have the property discussed above. (This feature arose from a discussion with Klaus Lux.)

Examples where this method is successful for all blocks are the \(p\)-modular character tables of the groups PSL\((2, q)\), where \(p\) is odd and does not divide \(q\).

<div class="example"><pre>
gap> t:= CharacterTable( PSL( 2, 11 ) );;
gap> modt:= t mod 5;;
gap> modt <> fail;
true
gap> InfoText( modt );
"computed using that all Brauer characters lift to char. zero"
</pre></div>

Another such example is the \(5\)-modular table of the Mathieu group \(M_{11}\).

<div class="example"><pre>
gap> lib:= CharacterTable( "M11" );;
gap> fromgroup:= CharacterTable( MathieuGroup( 11 ) );;
gap> DecompositionMatrix( lib mod 5 );
[ [ 1, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 1, 0, 0, 0, 0, 0, 0, 0 ],
 [ 0, 0, 1, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 1, 0, 0, 0, 0, 0 ],
 [ 0, 0, 0, 0, 1, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 1, 0, 0, 0 ],
 [ 0, 0, 0, 0, 0, 0, 1, 0, 0 ], [ 1, 0, 0, 0, 1, 1, 1, 0, 0 ],
 [ 0, 0, 0, 0, 0, 0, 0, 1, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 1 ] ]
gap> fromgroup mod 5 <> fail;
true
</pre></div>

There are cases where all Brauer characters of a block lift to characteristic zero but the defect group of the block is not cyclic, thus the method cannot be used. An example is the \(2\)-modular table of the Mathieu group \(M_{11}\).

<div class="example"><pre>
gap> DecompositionMatrix( lib mod 2 );
[ [ 1, 0, 0, 0, 0 ], [ 0, 1, 0, 0, 0 ], [ 0, 1, 0, 0, 0 ],
 [ 0, 1, 0, 0, 0 ], [ 1, 1, 0, 0, 0 ], [ 0, 0, 1, 0, 0 ],
 [ 0, 0, 0, 1, 0 ], [ 0, 0, 0, 0, 1 ], [ 1, 0, 0, 0, 1 ],
 [ 1, 1, 0, 0, 1 ] ]
gap> fromgroup mod 2;
fail
</pre></div>

<a id="X864EFF897A854F89" name="X864EFF897A854F89"></a>

<h4>1.5 Information about certain subgroups of the Monster group</h4>

<a id="X82C7A03684DD7C6E" name="X82C7A03684DD7C6E"></a>

<h5>1.5-1 The Monster group does not contain subgroups of the type \(2.U_4(2)\) (August 2023)</h5>

In the context of a question about decomposition numbers of the sporadic simple Monster group \(��\), Benjamin Sambale was interested in possible embeddings of certain groups \(G\) into \(��\) such that the decomposition matrices of \(G\) are known. For a given \(G\), the first steps were to compute the possible class fusions of \(G\) in \(��\) and then to check whether the corresponding embeddings would be interesting.

Apparently, calling <code class="func">PossibleClassFusions</code> (<a href="../../../doc/ref/chap73_mj.html#X7883271F7F26356E">Reference: PossibleClassFusions</a>) with its default parameters often runs very long and requires a lot of space when \(G\) is a small group such as \(2.U_4(2)\). We can do better by calling the function with the parameter <code class="code">decompose:= false</code>. This has the effect that one criterion is omitted that checks the decomposability of restricted characters of \(��\) as an integral linear combination of characters of the subgroup. As a rule of thumb, if the number of classes of the subgroup is small compared to the number of classes of the group and if the result consists of many candidates then it might be faster to omit the decomposability criterion.

<div class="example"><pre>
gap> s:= CharacterTable( "2.U4(2)" );;
gap> m:= CharacterTable( "M" );;
gap> sfusm:= PossibleClassFusions( s, m, rec( decompose:= false ) );;
gap> Length( sfusm );
2332
</pre></div>

Looking at the (many) candidates, we see that all map the central involution of \(2.U_4(2)\) to the class <code class="code">2B</code> of \(��\), thus any subgroup of the type \(2.U_4(2)\) lies inside the <code class="code">2B</code> normalizer in \(��\). We compute the possible class fusions into this subgroup.

<div class="example"><pre>
gap> Set( List( sfusm, x -> x[2] ) );
[ 3 ]
gap> t:= CharacterTable( "MN2B" );
CharacterTable( "2^1+24.Co1" )
gap> sfust:= PossibleClassFusions( s, t, rec( decompose:= false ) );;
gap> Length( sfust );
0
</pre></div>

Thus we have shown that \(��\) does not contain subgroups of the type \(2.U_4(2)\).

<a id="X87EC0C48866D1BDE" name="X87EC0C48866D1BDE"></a>

<h5>1.5-2 Perfect central extensions of \(L_3(4)\) (August 2023)</h5>

There was <a href="https://mathoverflow.net/questions/450255">the question in MathOverflow</a> which perfect central extensions of the simple group \(G = L_3(4)\) are subgroups of the sporadic simple Monster group \(��\).

First we get the list of perfect central extensions of \(G\) (asuming that their character tables are contained in the character table library).

<div class="example"><pre>
gap> simp:= CharacterTable( "L3(4)" );;
gap> extnames:= AllCharacterTableNames( Identifier,
> x -> EndsWith(x, "L3(4)" ) );;
gap> ext:= List( extnames, CharacterTable );;
gap> ext:= Filtered( ext, x -> Length( ClassPositionsOfCentre( x ) ) =
> Size( x ) / Size( simp ) );;
gap> SortBy( ext, Size );
gap> names:= List( ext, Identifier );
[ "L3(4)", "2.L3(4)", "3.L3(4)", "2^2.L3(4)", "4_1.L3(4)",
 "4_2.L3(4)", "6.L3(4)", "(2x4).L3(4)", "(2^2x3).L3(4)",
 "12_1.L3(4)", "12_2.L3(4)", "4^2.L3(4)", "(2x12).L3(4)",
 "(4^2x3).L3(4)" ]
</pre></div>

The fact that \(G\) is not isomorphic to a subgroup of \(��\) is shown in <a href="chapBib_mj.html#biBHW08">[HW08]</a> (at the end of this paper).

And the following embeddings of central extensions of \(G\) in \(��\) can be established using known subgroups of \(��\).

<ul>
<li>\(2.G < 2.U_4(3) < 2^2.U_6(2) < Fi_{23} < 3.Fi_{24}' < ��\).

</li>
<li>\(2^2.G < He < 3.Fi_{24}' < ��\).

</li>
<li>\(6.G < 2.G_2(4) < 6.Suz < 3^{1+12}_+.2Suz < ��\).

</li>
</ul>
Note that \(G\) is a subgroup of \(U_4(3)\) but not of \(2.U_4(3)\), \(3.G\) is a subgroup of \(G_2(4)\) but not of \(2.G_2(4)\), and \(G_2(4)\) is a subgroup of \(Suz\) but not of \(2.Suz\). The positive statements follow from <a href="chapBib_mj.html#biBCCN85">[CCN+85, pp. 52, 97, 131]</a> and the negative ones from the following computations.

<div class="example"><pre>
gap> Length( PossibleClassFusions( CharacterTable( "L3(4)" ),
> CharacterTable( "2.U4(3)" ) ) );
0
gap> Length( PossibleClassFusions( CharacterTable( "3.L3(4)" ),
> CharacterTable( "2.G2(4)" ) ) );
0
gap> Length( PossibleClassFusions( CharacterTable( "G2(4)" ),
> CharacterTable( "2.Suz" ) ) );
0
</pre></div>

The group \(3.G\) centralizes an element of order three. If \(3.G\) is a subgroup of \(��\) then it is contained in a <code class="code">3A</code> centralizer (of the structure \(3.Fi_{24}'\)), a <code class="code">3B</code> centralizer (of the structure \(3^{1+12}_+.2Suz\)) or a <code class="code">3C</code> centralizer (of the structure \(3 \times Th\)). Clearly the case \(3C\) cannot occur, and <code class="code">3B</code> is excluded by the fact that no class fusion between \(3.G\) and the \(3B\) normalizer \(3^{1+12}_+.2Suz.2\) is possible.

<div class="example"><pre>
gap> t:= CharacterTable( "MN3B" );
CharacterTable( "3^(1+12).2.Suz.2" )
gap> Length( PossibleClassFusions( CharacterTable( "3.L3(4)" ), t ) );
0
</pre></div>

If \(3.G\) is contained in the <code class="code">3A</code> centralizer then this embedding induces one of \(G\) into some maximal subgroup of \(Fi_{24}'\). Using the known character tables of these maximal subgroups in GAP's character table library, one shows that only \(Fi_{23}\) admits a class fusion, but this subgroup lifts to \(3 \times Fi_{23}\) in \(3.Fi_{24}'\) and thus cannot lead to a subgroup of type \(3.G\)..

<div class="example"><pre>
gap> mx:= List( Maxes( CharacterTable( "Fi24'" ) ), CharacterTable );;
gap> s:= CharacterTable( "L3(4)" );;
gap> Filtered( mx, x -> Length( PossibleClassFusions( s, x ) ) > 0 );
[ CharacterTable( "Fi23" ) ]
</pre></div>

The other candidates \(m.G\) contain at least one central involution. If \(m.G\) is a subgroup of \(��\) then it is contained in a <code class="code">2A</code> centralizer (of the structure \(2.B\)) or a <code class="code">2B</code> centralizer (of the structure <code class="code">2^{1+24}_+.Co_1</code>). Again we use <code class="func">PossibleClassFusions</code> (<a href="../../../doc/ref/chap73_mj.html#X7883271F7F26356E">Reference: PossibleClassFusions</a>) to list all candidates for the class fusion, but here we prescribe the central involution of the <code class="code">2A</code> or <code class="code">2B</code> centralizer as an image of one central involution in \(m.G\).

<div class="example"><pre>
gap> done:= [ "L3(4)", "2.L3(4)", "3.L3(4)", "2^2.L3(4)", "6.L3(4)" ];;
gap> names:= Filtered( names, x -> not x in done );
[ "4_1.L3(4)", "4_2.L3(4)", "(2x4).L3(4)", "(2^2x3).L3(4)",
 "12_1.L3(4)", "12_2.L3(4)", "4^2.L3(4)", "(2x12).L3(4)",
 "(4^2x3).L3(4)" ]
gap> invcent:= List( [ "MN2A", "MN2B" ], CharacterTable );
[ CharacterTable( "2.B" ), CharacterTable( "2^1+24.Co1" ) ]
gap> ForAll( invcent, x -> ClassPositionsOfCentre( x ) = [ 1, 2 ] );
true
gap> cand:= [];;
gap> ords:= "dummy";; # Avoid a message about an unbound variable ...
gap> for name in names do
> s:= CharacterTable( name );
> ords:= OrdersClassRepresentatives( s );
> invpos:= Filtered( ClassPositionsOfCentre( s ), i -> ords[i] = 2 );
> for i in invpos do
> for t in invcent do
> init:= InitFusion( s, t );
> if init = fail then
> continue;
> fi;
> init[i]:= 2;
> fus:= PossibleClassFusions( s, t, rec( fusionmap:= init,
> decompose:= false ) );
> if fus <> [] then
> Add( cand, [ s, t, i, fus ] );
> fi;
> od;
> od;
> od;
gap> List( cand, x -> x{ [ 1 .. 3 ] } );
[ [ CharacterTable( "4_1.L3(4)" ), CharacterTable( "2^1+24.Co1" ), 3 ]
 , [ CharacterTable( "(2x4).L3(4)" ), CharacterTable( "2.B" ), 2 ],
 [ CharacterTable( "(2x4).L3(4)" ), CharacterTable( "2.B" ), 3 ] ]
</pre></div>

(Note that we have called <code class="func">PossibleClassFusions</code> (<a href="../../../doc/ref/chap73_mj.html#X7883271F7F26356E">Reference: PossibleClassFusions</a>) with the option <code class="code">decompose:= false</code>, in order to save space and time. See Section <a href="chap1_mj.html#X82C7A03684DD7C6E">1.5-1</a> for more details.)

Concerning the candidate \((2 \times 4).G\), we see that only fusions are possible for which the central involution in question is mapped to a <code class="code">2A</code> element of \(��\). Since we get candidates only for two out of the three central involutions, we see that \((2 \times 4).G\) does not embed into \(��\).

Thus it turns out that exactly one group \(m.G\) cannot be excluded this way. Namely, these character-theoretical criteria leave the possibility that \(4_1.G\) may occur as a subgroup of \(2^{1+24}_+.Co_1\).

Moreover, we see that if this happens then the centre \(C\) of \(4_1.G\) lies inside the normal subgroup \(N = 2^{1+24}_+\). The centralizer of \(C\) in \(N\) has order \(2^{24}\), and the centralizer of \(C\) in \(2^{1+24}_+.Co_1\) has order \(2^{24} \cdot |Co_3|\). We see that \(4_1.G\), if it exists as a subgroup of \(2^{1+24}_+.Co_1\), must lie inside the subgroup \([2^{24}].Co_3\).

<div class="example"><pre>
gap> s:= cand[1][1];
CharacterTable( "4_1.L3(4)" )
gap> t:= cand[1][2];
CharacterTable( "2^1+24.Co1" )
gap> fus:= cand[1][4];
[ [ 1, 5, 2, 5, 9, 8, 23, 27, 24, 27, 49, 49, 50, 50, 70, 74, 71, 74,
 70, 74, 71, 74, 114, 119, 115, 119, 114, 119, 115, 119 ] ]
gap> ClassPositionsOfCentre( s );
[ 1, 2, 3, 4 ]
gap> 5 in ClassPositionsOfPCore( t, 2 );
true
gap> siz:= SizesCentralizers( t )[5] / 2^24;
495766656000
gap> mx:= Filtered( List( Maxes( CharacterTable( "Co1" ) ),
> CharacterTable ),
> x -> Size( x ) mod siz = 0 );
[ CharacterTable( "Co3" ) ]
gap> Size( mx[1] ) = siz;
true
</pre></div>

I do not see a character-theoretic argument that could disprove the existence of such an \(4_1.G\) type subgroup.

<a id="X7F605CA28441687F" name="X7F605CA28441687F"></a>

<h5>1.5-3 The character table of \((2 \times O_8^+(3)).S_4 \leq 2.B\) (October 2023)</h5>

Consider a maximal subgroup \(H\) of type \((3^2:2 \times O_8^+(3)).S_4\) in the sporadic simple Monster group. The character table of \(H\) has been contributed by Tim Burness. We can view \(H\) as \(O_8^+(3).(3^2:2S_4) = O_8^+(3).F\). The character table of \(H\) determines that of \(F\), and this table determines the isomorphism type of \(F\) as <code class="code">SmallGroup( 432, 734 )</code>.

<div class="example"><pre>
gap> tblH:= CharacterTable( "(3^2:2xO8+(3)).S4" );
CharacterTable( "(3^2:2xO8+(3)).S4" )
gap> N:= ClassPositionsOfSolvableResiduum( tblH );;
gap> tblF:= tblH / N;;
gap> Size( tblF );
432
gap> known:= NamesOfEquivalentLibraryCharacterTables( tblF );
[ "3^2.2.S4", "M12M7" ]
gap> Filtered( GroupInfoForCharacterTable( known[1] ),
> x -> x[1] = "SmallGroup" );
[ [ "SmallGroup", [ 432, 734 ] ] ]
</pre></div>

(Note that the precomputed <code class="func">GroupInfoForCharacterTable</code> (<a href="../doc/chap3_mj.html#X78DCD38B7D96D8A4">CTblLib: GroupInfoForCharacterTable</a>) information about GAP library character tables means that exactly one isomorphism type of groups fits to the character table of \(F\).)

We compute that \(O_3(F) \cong 3^2\) has complements in \(F\), thus \(H\) has a subgroup \(V\) of the type \(O_8^+(3).2S_4\), which is a complement of \(O_3(H)\) in \(H\), thus \(V\) is isomorphic with \(H / O_3(H)\).

<div class="example"><pre>
gap> G:= SmallGroup( 432, 734 );;
gap> P:= PCore( G, 3 );;
gap> Length( ComplementClassesRepresentatives( G, P ) );
1
</pre></div>

We can derive the character table of \(V\) from that of \(H\), and compute that the group structure of \(V\) is \((2 \times O_8^+(3)).S_4\). For that, we consider the element orders of the unique normal subgroup of order \(2 |O_8^+(3)|\) in \(V\). If this normal subgroup would not be isomorphic with \(2 \times O_8^+(3)\) then it would have one of the structures \(O_8^+(3).2_1\) or \(O_8^+(3).2_2\), but then it would contain elements of the orders \(24\).

<div class="example"><pre>
gap> tblV:= tblH / ClassPositionsOfPCore( tblH, 3 );;
gap> ord:= 2 * Size( tblH ) / Size( tblF );
9904359628800
gap> classes:= SizesConjugacyClasses( tblV );;
gap> 2N:= Filtered( ClassPositionsOfNormalSubgroups( tblV ),
> l -> Sum( classes{ l } ) = ord );;
gap> Length( 2N );
1
gap> Set( OrdersClassRepresentatives( tblV ){ 2N[1] } );
[ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12, 13, 14, 15, 18, 20, 26, 30 ]
gap> Set( OrdersClassRepresentatives( CharacterTable( "O8+(3)" ) ) );
[ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12, 13, 14, 15, 18, 20 ]
gap> Set( OrdersClassRepresentatives( CharacterTable( "O8+(3).2_1" ) ) );
[ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12, 13, 14, 15, 18, 20, 24, 26, 28,
 30, 36, 40 ]
gap> Set( OrdersClassRepresentatives( CharacterTable( "O8+(3).2_2" ) ) );
[ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12, 13, 14, 15, 18, 20, 24, 26, 28,
 30, 36 ]
</pre></div>

The class fusion of \(V\) into the Monster group shows that \(V\) centralizes a <code class="code">2A</code> element in the Monster, hence \(V\) is a subgroup of a maximal subgroup of the type \(2.B\).

<div class="example"><pre>
gap> tblM:= CharacterTable( "M" );;
gap> VfusM:= PossibleClassFusions( tblV, tblM );;
gap> Length( VfusM );
4
gap> ZV:= ClassPositionsOfCentre( tblV );
[ 1, 2 ]
gap> Set( List( VfusM, l -> l{ ZV } ) );
[ [ 1, 2 ] ]
</pre></div>

From the list of maximal subgroups of \(B\), we see that either \(V\) is contained in the preimage of \(Fi_{23}\) under the natural epimorphism from \(2.B\) to \(B\), or \(V\) is equal to the preimage of \(O_8^+(3).S_4\).

<div class="example"><pre>
gap> tblB:= CharacterTable( "B" );;
gap> mxB:= List( Maxes( tblB ), CharacterTable );;
gap> cand:= Filtered( mxB, s -> Size( s ) mod ( Size( tblV ) / 2 ) = 0 );
[ CharacterTable( "Fi23" ), CharacterTable( "O8+(3).S4" ) ]
</pre></div>

The former possibility is excluded from the fact that the factor of \(V\) by its center does not admit a class fusion into \(Fi_{23}\).

<div class="example"><pre>
gap> Length( PossibleClassFusions( tblV / ZV, CharacterTable( "Fi23" ) ) );
0
</pre></div>

We conclude that \(V\) is a maximal subgroup of \(2.B\).

Thus we have used the character table of \(H\) to construct the character table of a maximal subgroup of \(2.B\), with very little effort.

This table is meanwhile available in the table library, with the identifier <code class="code">"(2xO8+(3)).S4"</code>.

<div class="example"><pre>
gap> lib:= CharacterTable( "(2xO8+(3)).S4" );;
gap> TransformingPermutationsCharacterTables( tblV, lib ) <> fail;
true
gap> Irr( lib ) = Irr( tblV );
true
</pre></div>

In order to add the table to the library, we have to provide also the class fusions from \(V\) to \(2.B\), to the maximal subgroup \((2 \times O_8^+(3)).S_4\) of \(B\), and to the maximal subgroup \((3^2:2 \times O_8^+(3)).S_4\) of \(M\), such that the compositions of fusions from \(V\) to \(B\) via \(O_8^+(3).S_4\) and \(2.B\) are compatible, \(\ldots\)

<div class="example"><pre>
gap> tblU:= CharacterTable( "O8+(3).S4" );;
gap> tbl2B:= CharacterTable( "2.B" );;
gap> CompositionMaps( GetFusionMap( tblU, tblB ),
> GetFusionMap( lib, tblU ) ) =
> CompositionMaps( GetFusionMap( tbl2B, tblB ),
> GetFusionMap( lib, tbl2B ) );
true
</pre></div>

\(\ldots\) and that the compositions of fusions from \(V\) to \(M\) via \((3^2:2 \times O_8^+(3)).S_4\) and \(2.B\) are compatible.

<div class="example"><pre>
gap> tblH:= CharacterTable( "(3^2:2xO8+(3)).S4" );;
gap> CompositionMaps( GetFusionMap( tblH, tblM ),
> GetFusionMap( lib, tblH ) ) =
> CompositionMaps( GetFusionMap( tbl2B, tblM ),
> GetFusionMap( lib, tbl2B ) );
true
</pre></div>

<div class="chlinkprevnextbot"> <a href="chap0_mj.html">[Top of Book]</a> <a href="chap0_mj.html#contents">[Contents]</a> <a href="chap0_mj.html">[Previous Chapter]</a> <a href="chap2_mj.html">[Next Chapter]</a> </div>

<div class="chlinkbot">Goto Chapter: <a href="chap0_mj.html">Top</a> <a href="chap1_mj.html">1</a> <a href="chap2_mj.html">2</a> <a href="chap3_mj.html">3</a> <a href="chap4_mj.html">4</a> <a href="chap5_mj.html">5</a> <a href="chap6_mj.html">6</a> <a href="chap7_mj.html">7</a> <a href="chap8_mj.html">8</a> <a href="chap9_mj.html">9</a> <a href="chap10_mj.html">10</a> <a href="chap11_mj.html">11</a> <a href="chapBib_mj.html">Bib</a> <a href="chapInd_mj.html">Ind</a> </div>

<hr />
generated by <a href="https://www.math.rwth-aachen.de/~Frank.Luebeck/GAPDoc">GAPDoc2HTML</a>
</body>
</html>

Messung V0.5 in Prozent

¤ Dauer der Verarbeitung: 0.65 Sekunden (vorverarbeitet am 2026-05-06) ¤

Wurzel

Suchen

Beweissystem der NASA

Beweissystem Isabelle

NIST Cobol Testsuite

Cephes Mathematical Library

Wiener Entwicklungsmethode

Haftungshinweis

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

Bemerkung:

Die farbliche Syntaxdarstellung und die Messung sind noch experimentell.