Ziele Untersuchung
mit Columbo Integrität von
Datenbanken Interaktion und
Portierbarkeit Ergonomie der
Schnittstellen

Angebot Produkte Projekt Beratung

Mittel Analytik Modellierung Sprachen Algebra Logik Hardware Denken Kreativität

Zusammenhänge Gesellschaft Wirtschaft Branche Firma


products/sources/formale Sprachen/GAP/pkg/ctbllib/doc2/ (Algebra von RWTH Aachen Version 4.15.1^©) Datei vom 25.4.2025 mit Größe 267 kB

SSL chap8_mj.html Interaktion und
PortierbarkeitHTML

products/sources/formale Sprachen/GAP/pkg/ctbllib/doc2/chap8_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 8: Permutation Characters in GAP</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="chap8" 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="chap7_mj.html">[Previous Chapter]</a> <a href="chap9_mj.html">[Next Chapter]</a> </div>

<a href="chap8.html">[MathJax off]</a>
<a id="X7A7EEBE9858333E1" name="X7A7EEBE9858333E1"></a>
<div class="ChapSects"><a href="chap8_mj.html#X7A7EEBE9858333E1">8 Permutation Characters in GAP</a>
<div class="ContSect"> <a href="chap8_mj.html#X86A1325B82E5AECD">8.1 Some Computations with \(M_{24}\)</a>

</div>
<div class="ContSect"> <a href="chap8_mj.html#X79C9051F805851DB">8.2 All Possible Permutation Characters of \(M_{11}\)</a>

</div>
<div class="ContSect"> <a href="chap8_mj.html#X81A5FC968782CFC3">8.3 The Action of \(U_6(2)\) on the Cosets of \(M_{22}\)</a>

</div>
<div class="ContSect"> <a href="chap8_mj.html#X7EE1811C8496C428">8.4 Degree \(20\,736\) Permutation Characters of \(U_6(2)\)</a>

</div>
<div class="ContSect"> <a href="chap8_mj.html#X7DC6A6E785A347C8">8.5 Degree \(57\,572\,775\) Permutation Characters of \(O_8^+(3)\)</a>

</div>
<div class="ContSect"> <a href="chap8_mj.html#X792D2C2380591D8D">8.6 The Action of \(O_7(3).2\) on the Cosets of \(2^7.S_7\)</a>

</div>
<div class="ContSect"> <a href="chap8_mj.html#X875B361C8512939F">8.7 The Action of \(O_8^+(3).2_1\) on the Cosets of \(2^7.A_8\)</a>

</div>
<div class="ContSect"> <a href="chap8_mj.html#X7B1DFAF98182CFF4">8.8 The Action of \(S_4(4).4\) on the Cosets of \(5^2.[2^5]\)</a>

</div>
<div class="ContSect"> <a href="chap8_mj.html#X7F04F0C684AA8B30">8.9 The Action of \(Co_1\) on the Cosets of Involution Centralizers</a>

</div>
<div class="ContSect"> <a href="chap8_mj.html#X8230719D8538384B">8.10 The Multiplicity Free Permutation Characters of \(G_2(3)\)</a>

</div>
<div class="ContSect"> <a href="chap8_mj.html#X7E3E326C7CB0E2CD">8.11 Degree \(11\,200\) Permutation Characters of \(O_8^+(2)\)</a>

</div>
<div class="ContSect"> <a href="chap8_mj.html#X7D8572E68194CBB9">8.12 A Proof of Nonexistence of a Certain Subgroup</a>

</div>
<div class="ContSect"> <a href="chap8_mj.html#X8068E9DA7CD03BF2">8.13 A Permutation Character of the Lyons group</a>

</div>
<div class="ContSect"> <a href="chap8_mj.html#X87D6C1A67CC7EE0A">8.14 Identifying two subgroups of Aut\((U_3(5))\) (October 2001)</a>

</div>
<div class="ContSect"> <a href="chap8_mj.html#X793669787CF73A55">8.15 A Permutation Character of Aut\((O_8^+(2))\) (October 2001)</a>

</div>
<div class="ContSect"> <a href="chap8_mj.html#X8337F3C682B6BE63">8.16 Four Primitive Permutation Characters of the Monster Group</a>

<div class="ContSSBlock">
 <a href="chap8_mj.html#X78A8A1248336DD26">8.16-1 The Subgroup \(2^2.2^{11}.2^{22}.(S_3 \times M_{24})\)
(June 2009)</a>

 <a href="chap8_mj.html#X79E9247182B20474">8.16-2 The Subgroup \(2^3.2^6.2^{12}.2^{18}.(L_3(2) \times 3.S_6)\)
(September 2009)</a>

 <a href="chap8_mj.html#X7BC36C597E542DEE">8.16-3 The Subgroup \(2^5.2^{10}.2^{20}.(S_3 \times L_5(2))\)
(October 2009)</a>

 <a href="chap8_mj.html#X7F2ABD3E7AFF5F6E">8.16-4 The Subgroup \(2^{{10+16}}.O_{10}^+(2)\) (November 2009)</a>

</div></div>
<div class="ContSect"> <a href="chap8_mj.html#X87D11B097D95D027">8.17 A permutation character of the Baby Monster (June 2012)</a>

</div>
<div class="ContSect"> <a href="chap8_mj.html#X86827FA97D27F3A2">8.18 A permutation character of \(2.B\) (October 2017)</a>

</div>
<div class="ContSect"> <a href="chap8_mj.html#X849F0EA6807C9B19">8.19 Generation of sporadic simple groups by \(\pi\)- and \(\pi'\)-subgroups (December 2021)

<div class="ContSSBlock">
 <a href="chap8_mj.html#X839272078243F4DB">8.19-1 Special Arguments for the Monster Group that are no longer needed</a>

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

<h3>8 Permutation Characters in GAP</h3>

Date: April 17th, 1999

This is a loose collection of examples of computations with permutation characters and possible permutation characters in the GAP system <a href="chapBib_mj.html#biBGAP">[GAP24]</a>. We mainly use the GAP implementation of the algorithms to compute possible permutation characters that are described in <a href="chapBib_mj.html#biBBP98copy">[BP98]</a>, and information from the Atlas of Finite Groups <a href="chapBib_mj.html#biBCCN85">[CCN+85]</a>. A possible permutation character of a finite group \(G\) is a character satisfying the conditions listed in Section <q>Possible Permutation Characters</q> of the GAP Reference Manual.

<ul>
<li>Sections <a href="chap8_mj.html#X87D6C1A67CC7EE0A">8.14</a> and <a href="chap8_mj.html#X793669787CF73A55">8.15</a> were added in October 2001.

</li>
<li>Section <a href="chap8_mj.html#X78A8A1248336DD26">8.16-1</a> was added in June 2009.

</li>
<li>Section <a href="chap8_mj.html#X79E9247182B20474">8.16-2</a> was added in September 2009.

</li>
<li>Section <a href="chap8_mj.html#X7BC36C597E542DEE">8.16-3</a> was added in October 2009.

</li>
<li>Section <a href="chap8_mj.html#X7F2ABD3E7AFF5F6E">8.16-4</a> was added in November 2009.

</li>
<li>Section <a href="chap8_mj.html#X87D11B097D95D027">8.17</a> was added in June 2012.

</li>
<li>Section <a href="chap8_mj.html#X86827FA97D27F3A2">8.18</a> was added in October 2017.

</li>
<li>Section <a href="chap8_mj.html#X849F0EA6807C9B19">8.19</a> was added in December 2021.

</li>
</ul>
In the following, the GAP Character Table Library <a href="chapBib_mj.html#biBCTblLib">[Bre25]</a> will be used frequently.

<div class="example"><pre>
gap> LoadPackage( "ctbllib", "1.2", false );
true
</pre></div>

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

<h4>8.1 Some Computations with \(M_{24}\)</h4>

We start with the sporadic simple Mathieu group \(G = M_{24}\) in its natural action on \(24\) points.

<div class="example"><pre>
gap> g:= MathieuGroup( 24 );;
gap> SetName( g, "m24" );
gap> Size( g ); IsSimple( g ); NrMovedPoints( g );
244823040
true
24
</pre></div>

The conjugacy classes that are computed for a group can be ordered differently in different GAP sessions. In order to make the output shown in the following examples stable, we first sort the conjugacy classes of \(G\) for our purposes.

<div class="example"><pre>
gap> ccl:= AttributeValueNotSet( ConjugacyClasses, g );;
gap> HasConjugacyClasses( g );
false
gap> invariants:= List( ccl, c -> [ Order( Representative( c ) ),
> Size( c ), Size( ConjugacyClass( g, Representative( c )^2 ) ) ] );;
gap> SortParallel( invariants, ccl );
gap> SetConjugacyClasses( g, ccl );
</pre></div>

The permutation character <code class="code">pi</code> of \(G\) corresponding to the action on the moved points is constructed. This action is \(5\)-transitive.

<div class="example"><pre>
gap> NrConjugacyClasses( g );
26
gap> pi:= NaturalCharacter( g );
Character( CharacterTable( m24 ),
[ 24, 8, 0, 6, 0, 0, 4, 0, 4, 2, 0, 3, 3, 2, 0, 2, 0, 0, 1, 1, 1, 1,
 0, 0, 1, 1 ] )
gap> IsTransitive( pi ); Transitivity( pi );
true
5
gap> SetIdentifier( CharacterTable( g ), "M24table" );
gap> Display( pi );
M24table

 2 10 10 9 3 3 7 7 5 2 3 3 1 1 4 2 . 2 2 1
 3 3 1 1 3 2 1 . 1 1 1 1 1 1 . . . 1 1 .
 5 1 . 1 1 . . . . 1 . . . . . 1 . . . .
 7 1 1 . . 1 . . . . . . 1 1 . . . . . 1
 11 1 . . . . . . . . . . . . . . 1 . . .
 23 1 . . . . . . . . . . . . . . . . . .

 1a 2a 2b 3a 3b 4a 4b 4c 5a 6a 6b 7a 7b 8a 10a 11a 12a 12b 14a

Y.1 24 8 . 6 . . 4 . 4 2 . 3 3 2 . 2 . . 1

 2 1 . . . . . .
 3 . 1 1 1 1 . .
 5 . 1 1 . . . .
 7 1 . . 1 1 . .
 11 . . . . . . .
 23 . . . . . 1 1

 14b 15a 15b 21a 21b 23a 23b

Y.1 1 1 1 . . 1 1
</pre></div>

(We have set the <code class="func">Identifier</code> (<a href="../doc/chap3_mj.html#X860F49407882658F">CTblLib: IdentifierOfMainTable</a>) value of the character table because otherwise some default identifier would be chosen, which depends on the GAP session.)

<code class="code">pi</code> determines the permutation characters of the \(G\)-actions on related sets, for example <code class="code">piop</code> on the set of ordered and <code class="code">piup</code> on the set of unordered pairs of points.

<div class="example"><pre>
gap> piop:= pi * pi;
Character( CharacterTable( m24 ),
[ 576, 64, 0, 36, 0, 0, 16, 0, 16, 4, 0, 9, 9, 4, 0, 4, 0, 0, 1, 1,
 1, 1, 0, 0, 1, 1 ] )
gap> IsTransitive( piop );
false
gap> piup:= SymmetricParts( UnderlyingCharacterTable(pi), [ pi ], 2 )[1];
Character( CharacterTable( m24 ),
[ 300, 44, 12, 21, 0, 4, 12, 0, 10, 5, 0, 6, 6, 4, 2, 3, 0, 1, 2, 2,
 1, 1, 0, 0, 1, 1 ] )
gap> IsTransitive( piup );
false
</pre></div>

Clearly the action on unordered pairs is not transitive, since the pairs \([ i, i ]\) form an orbit of their own. There are exactly two \(G\)-orbits on the unordered pairs, hence the \(G\)-action on \(2\)-sets of points is transitive.

<div class="example"><pre>
gap> ScalarProduct( piup, TrivialCharacter( g ) );
2
gap> comb:= Combinations( [ 1 .. 24 ], 2 );;
gap> hom:= ActionHomomorphism( g, comb, OnSets );;
gap> pihom:= NaturalCharacter( hom );
Character( CharacterTable( m24 ),
[ 276, 36, 12, 15, 0, 4, 8, 0, 6, 3, 0, 3, 3, 2, 2, 1, 0, 1, 1, 1,
 0, 0, 0, 0, 0, 0 ] )
gap> Transitivity( pihom );
1
</pre></div>

In terms of characters, the permutation character <code class="code">pihom</code> is the difference of <code class="code">piup</code> and <code class="code">pi</code> . Note that GAP does not know that this difference is in fact a character; in general this question is not easy to decide without knowing the irreducible characters of \(G\), and up to now GAP has not computed the irreducibles.

<div class="example"><pre>
gap> pi2s:= piup - pi;
VirtualCharacter( CharacterTable( m24 ),
[ 276, 36, 12, 15, 0, 4, 8, 0, 6, 3, 0, 3, 3, 2, 2, 1, 0, 1, 1, 1,
 0, 0, 0, 0, 0, 0 ] )
gap> pi2s = pihom;
true
gap> HasIrr( g ); HasIrr( CharacterTable( g ) );
false
false
</pre></div>

The point stabilizer in the action on \(2\)-sets is in fact a maximal subgroup of \(G\), which is isomorphic to the automorphism group \(M_{22}:2\) of the Mathieu group \(M_{22}\). Thus this permutation action is primitive. But we cannot apply <code class="func">IsPrimitive</code> (<a href="../../../doc/ref/chap41_mj.html#X84C19AD68247B760">Reference: IsPrimitive</a>) to the character <code class="code">pihom</code> for getting this answer because primitivity of characters is defined in a different way, cf. <code class="func">IsPrimitiveCharacter</code> (<a href="../../../doc/ref/chap75_mj.html#X7BC72ECE822D4245">Reference: IsPrimitiveCharacter</a>).

<div class="example"><pre>
gap> IsPrimitive( g, comb, OnSets );
true
</pre></div>

We could also have computed the transitive permutation character of degree \(276\) using the GAP Character Table Library instead of the group \(G\), since the character tables of \(G\) and all its maximal subgroups are available, together with the class fusions of the maximal subgroups into \(G\).

<div class="example"><pre>
gap> tbl:= CharacterTable( "M24" );
CharacterTable( "M24" )
gap> maxes:= Maxes( tbl );
[ "M23", "M22.2", "2^4:a8", "M12.2", "2^6:3.s6", "L3(4).3.2_2",
 "2^6:(psl(3,2)xs3)", "L2(23)", "L3(2)" ]
gap> s:= CharacterTable( maxes[2] );
CharacterTable( "M22.2" )
gap> TrivialCharacter( s )^tbl;
Character( CharacterTable( "M24" ),
[ 276, 36, 12, 15, 0, 4, 8, 0, 6, 3, 0, 3, 3, 2, 2, 1, 1, 0, 1, 1,
 0, 0, 0, 0, 0, 0 ] )
</pre></div>

Note that the sequence of conjugacy classes in the library table of \(G\) does in general not agree with the succession computed for the group.

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

<h4>8.2 All Possible Permutation Characters of \(M_{11}\)</h4>

We compute all possible permutation characters of the Mathieu group \(M_{11}\), using the three different strategies available in GAP. First we try the algorithm that enumerates all candidates via solving a system of inequalities, which is described in <a href="chapBib_mj.html#biBBP98copy">[BP98, Section 3.2]</a>.

<div class="example"><pre>
gap> m11:= CharacterTable( "M11" );;
gap> SetName( m11, "m11" );
gap> perms:= PermChars( m11 );
[ Character( m11, [ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 ] ), Character( m11,
 [ 11, 3, 2, 3, 1, 0, 1, 1, 0, 0 ] ), Character( m11,
 [ 12, 4, 3, 0, 2, 1, 0, 0, 1, 1 ] ), Character( m11,
 [ 22, 6, 4, 2, 2, 0, 0, 0, 0, 0 ] ), Character( m11,
 [ 55, 7, 1, 3, 0, 1, 1, 1, 0, 0 ] ), Character( m11,
 [ 66, 10, 3, 2, 1, 1, 0, 0, 0, 0 ] ), Character( m11,
 [ 110, 6, 2, 2, 0, 0, 2, 2, 0, 0 ] ), Character( m11,
 [ 110, 6, 2, 6, 0, 0, 0, 0, 0, 0 ] ), Character( m11,
 [ 110, 14, 2, 2, 0, 2, 0, 0, 0, 0 ] ), Character( m11,
 [ 132, 12, 6, 0, 2, 0, 0, 0, 0, 0 ] ), Character( m11,
 [ 144, 0, 0, 0, 4, 0, 0, 0, 1, 1 ] ), Character( m11,
 [ 165, 13, 3, 1, 0, 1, 1, 1, 0, 0 ] ), Character( m11,
 [ 220, 4, 4, 0, 0, 4, 0, 0, 0, 0 ] ), Character( m11,
 [ 220, 12, 4, 4, 0, 0, 0, 0, 0, 0 ] ), Character( m11,
 [ 220, 20, 4, 0, 0, 2, 0, 0, 0, 0 ] ), Character( m11,
 [ 330, 2, 6, 2, 0, 2, 0, 0, 0, 0 ] ), Character( m11,
 [ 330, 18, 6, 2, 0, 0, 0, 0, 0, 0 ] ), Character( m11,
 [ 396, 12, 0, 4, 1, 0, 0, 0, 0, 0 ] ), Character( m11,
 [ 440, 8, 8, 0, 0, 2, 0, 0, 0, 0 ] ), Character( m11,
 [ 440, 24, 8, 0, 0, 0, 0, 0, 0, 0 ] ), Character( m11,
 [ 495, 15, 0, 3, 0, 0, 1, 1, 0, 0 ] ), Character( m11,
 [ 660, 4, 3, 4, 0, 1, 0, 0, 0, 0 ] ), Character( m11,
 [ 660, 12, 3, 0, 0, 3, 0, 0, 0, 0 ] ), Character( m11,
 [ 660, 12, 12, 0, 0, 0, 0, 0, 0, 0 ] ), Character( m11,
 [ 660, 28, 3, 0, 0, 1, 0, 0, 0, 0 ] ), Character( m11,
 [ 720, 0, 0, 0, 0, 0, 0, 0, 5, 5 ] ), Character( m11,
 [ 792, 24, 0, 0, 2, 0, 0, 0, 0, 0 ] ), Character( m11,
 [ 880, 0, 16, 0, 0, 0, 0, 0, 0, 0 ] ), Character( m11,
 [ 990, 6, 0, 2, 0, 0, 2, 2, 0, 0 ] ), Character( m11,
 [ 990, 6, 0, 6, 0, 0, 0, 0, 0, 0 ] ), Character( m11,
 [ 990, 30, 0, 2, 0, 0, 0, 0, 0, 0 ] ), Character( m11,
 [ 1320, 8, 6, 0, 0, 2, 0, 0, 0, 0 ] ), Character( m11,
 [ 1320, 24, 6, 0, 0, 0, 0, 0, 0, 0 ] ), Character( m11,
 [ 1584, 0, 0, 0, 4, 0, 0, 0, 0, 0 ] ), Character( m11,
 [ 1980, 12, 0, 4, 0, 0, 0, 0, 0, 0 ] ), Character( m11,
 [ 1980, 36, 0, 0, 0, 0, 0, 0, 0, 0 ] ), Character( m11,
 [ 2640, 0, 12, 0, 0, 0, 0, 0, 0, 0 ] ), Character( m11,
 [ 3960, 24, 0, 0, 0, 0, 0, 0, 0, 0 ] ), Character( m11,
 [ 7920, 0, 0, 0, 0, 0, 0, 0, 0, 0 ] ) ]
gap> Length( perms );
39
</pre></div>

Next we try the improved combinatorial approach that is sketched at the end of Section 3.2 in <a href="chapBib_mj.html#biBBP98copy">[BP98]</a>. We get the same characters, except that they may be ordered in a different way; thus we compare the ordered lists.

<div class="example"><pre>
gap> degrees:= DivisorsInt( Size( m11 ) );;
gap> perms2:= [];;
gap> for d in degrees do
> Append( perms2, PermChars( m11, d ) );
> od;
gap> Set( perms ) = Set( perms2 );
true
</pre></div>

Finally, we try the algorithm that is based on Gaussian elimination and that is described in <a href="chapBib_mj.html#biBBP98copy">[BP98, Section 3.3]</a>.

<div class="example"><pre>
gap> perms3:= [];;
gap> for d in degrees do
> Append( perms3, PermChars( m11, rec( torso:= [ d ] ) ) );
> od;
gap> Set( perms ) = Set( perms3 );
true
</pre></div>

GAP provides two more functions to test properties of permutation characters. The first one yields no new information in our case, but the second excludes one possible permutation character; note that <code class="code">TestPerm5</code> needs a \(p\)-modular Brauer table, and the GAP character table library contains all Brauer tables of \(M_{11}\).

<div class="example"><pre>
gap> newperms:= TestPerm4( m11, perms );;
gap> newperms = perms;
true
gap> newperms:= TestPerm5( m11, perms, m11 mod 11 );;
gap> newperms = perms;
false
gap> Difference( perms, newperms );
[ Character( m11, [ 220, 4, 4, 0, 0, 4, 0, 0, 0, 0 ] ) ]
</pre></div>

GAP knows the table of marks of \(M_{11}\), from which the permutation characters can be extracted. It turns out that \(M_{11}\) has \(39\) conjugacy classes of subgroups but only \(36\) different permutation characters, so three candidates computed above are in fact not permutation characters.

<div class="example"><pre>
gap> tom:= TableOfMarks( "M11" );
TableOfMarks( "M11" )
gap> trueperms:= PermCharsTom( m11, tom );;
gap> Length( trueperms ); Length( Set( trueperms ) );
39
36
gap> Difference( perms, trueperms );
[ Character( m11, [ 220, 4, 4, 0, 0, 4, 0, 0, 0, 0 ] ),
 Character( m11, [ 660, 4, 3, 4, 0, 1, 0, 0, 0, 0 ] ),
 Character( m11, [ 660, 12, 3, 0, 0, 3, 0, 0, 0, 0 ] ) ]
</pre></div>

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

<h4>8.3 The Action of \(U_6(2)\) on the Cosets of \(M_{22}\)</h4>

We are interested in the permutation character of \(U_6(2)\) (see <a href="chapBib_mj.html#biBCCN85">[CCN+85, p. 115]</a>) that corresponds to the action on the cosets of a \(M_{22}\) subgroup (see <a href="chapBib_mj.html#biBCCN85">[CCN+85, p. 39]</a>). The character tables of both the group and the point stabilizer are available in the GAP character table library, so we can compute class fusion and permutation character directly; note that if the class fusion is not stored on the table of the subgroup, in general one will not get a unique fusion but only a list of candidates for the fusion.

<div class="example"><pre>
gap> u62:= CharacterTable( "U6(2)" );;
gap> m22:= CharacterTable( "M22" );;
gap> fus:= PossibleClassFusions( m22, u62 );
[ [ 1, 3, 7, 10, 14, 15, 22, 24, 24, 26, 33, 34 ],
 [ 1, 3, 7, 10, 14, 15, 22, 24, 24, 26, 34, 33 ],
 [ 1, 3, 7, 11, 14, 15, 22, 24, 24, 27, 33, 34 ],
 [ 1, 3, 7, 11, 14, 15, 22, 24, 24, 27, 34, 33 ],
 [ 1, 3, 7, 12, 14, 15, 22, 24, 24, 28, 33, 34 ],
 [ 1, 3, 7, 12, 14, 15, 22, 24, 24, 28, 34, 33 ] ]
gap> RepresentativesFusions( m22, fus, u62 );
[ [ 1, 3, 7, 10, 14, 15, 22, 24, 24, 26, 33, 34 ] ]
</pre></div>

We see that there are six possible class fusions that are equivalent under table automorphisms of \(U_6(2)\) and \(M22\).

<div class="example"><pre>
gap> cand:= Set( fus,
> x -> Induced( m22, u62, [ TrivialCharacter( m22 ) ], x )[1] );
[ Character( CharacterTable( "U6(2)" ),
 [ 20736, 0, 384, 0, 0, 0, 54, 0, 0, 0, 0, 48, 0, 16, 6, 0, 0, 0, 0,
 0, 0, 6, 0, 2, 0, 0, 0, 4, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0,
 0, 0, 0, 0, 0, 0 ] ), Character( CharacterTable( "U6(2)" ),
 [ 20736, 0, 384, 0, 0, 0, 54, 0, 0, 0, 48, 0, 0, 16, 6, 0, 0, 0, 0,
 0, 0, 6, 0, 2, 0, 0, 4, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0,
 0, 0, 0, 0, 0, 0 ] ), Character( CharacterTable( "U6(2)" ),
 [ 20736, 0, 384, 0, 0, 0, 54, 0, 0, 48, 0, 0, 0, 16, 6, 0, 0, 0, 0,
 0, 0, 6, 0, 2, 0, 4, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0,
 0, 0, 0, 0, 0, 0 ] ) ]
gap> PermCharInfo( u62, cand ).ATLAS;
[ "1a+22a+252a+616a+1155c+1386a+8064a+9240c",
 "1a+22a+252a+616a+1155b+1386a+8064a+9240b",
 "1a+22a+252a+616a+1155a+1386a+8064a+9240a" ]
gap> aut:= AutomorphismsOfTable( u62 );; Size( aut );
24
gap> elms:= Filtered( Elements( aut ), x -> Order( x ) = 3 );
[ (10,11,12)(26,27,28)(40,41,42), (10,12,11)(26,28,27)(40,42,41) ]
gap> Position( cand, Permuted( cand[1], elms[1] ) );
3
gap> Position( cand, Permuted( cand[3], elms[1] ) );
2
</pre></div>

The six fusions induce three different characters, they are conjugate under the action of the unique subgroup of order \(3\) in the group of table automorphisms of \(U_6(2)\). The table automorphisms of order \(3\) are induced by group automorphisms of \(U_6(2)\) (see <a href="chapBib_mj.html#biBCCN85">[CCN+85, p. 120]</a>). As can be seen from the list of maximal subgroups of \(U_6(2)\) in <a href="chapBib_mj.html#biBCCN85">[CCN+85, p. 115]</a>, the three induced characters are in fact permutation characters which belong to the three classes of maximal subgroups of type \(M_{22}\) in \(U_6(2)\), which are permuted by an outer automorphism of order 3. Now we want to compute the extension of the above permutation character to the group \(U_6(2).2\), which corresponds to the action of this group on the cosets of a \(M_{22}.2\) subgroup.

<div class="example"><pre>
gap> u622:= CharacterTable( "U6(2).2" );;
gap> m222:= CharacterTable( "M22.2" );;
gap> fus:= PossibleClassFusions( m222, u622 );
[ [ 1, 3, 7, 10, 13, 14, 20, 22, 22, 24, 29, 38, 39, 42, 41, 46, 50,
 53, 58, 59, 59 ] ]
gap> cand:= Induced( m222, u622, [ TrivialCharacter( m222 ) ], fus[1] );
[ Character( CharacterTable( "U6(2).2" ),
 [ 20736, 0, 384, 0, 0, 0, 54, 0, 0, 48, 0, 0, 16, 6, 0, 0, 0, 0, 0,
 6, 0, 2, 0, 4, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1080, 72,
 0, 48, 8, 0, 0, 0, 18, 0, 0, 0, 8, 0, 0, 2, 0, 0, 0, 0, 2, 2,
 0, 0, 0, 0, 0, 0 ] ) ]
gap> PermCharInfo( u622, cand ).ATLAS;
[ "1a+22a+252a+616a+1155a+1386a+8064a+9240a" ]
</pre></div>

We see that for the embedding of \(M_{22}.2\) into \(U_6(2).2\), the class fusion is unique, so we get a unique extension of one of the above permutation characters. This implies that exactly one class of maximal subgroups of type \(M_{22}\) extends to \(M_{22}.2\) in a given group \(U_6(2).2\).

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

<h4>8.4 Degree \(20\,736\) Permutation Characters of \(U_6(2)\)</h4>

Now we show an alternative way to compute the characters dealt with in the previous example. This works also if the character table of the point stabilizer is not available. In this situation we can compute all those characters that have certain properties of permutation characters. Of course this may take much longer than the above computations, which needed only a few seconds. (The following calculations may need several hours, depending on the computer used.)

<div class="example"><pre>
gap> cand:= PermChars( u62, rec( torso := [ 20736 ] ) );
[ Character( CharacterTable( "U6(2)" ),
 [ 20736, 0, 384, 0, 0, 0, 54, 0, 0, 0, 0, 48, 0, 16, 6, 0, 0, 0,
 0, 0, 0, 6, 0, 2, 0, 0, 0, 4, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0,
 0, 0, 0, 0, 0, 0, 0 ] ), Character( CharacterTable( "U6(2)" ),
 [ 20736, 0, 384, 0, 0, 0, 54, 0, 0, 0, 48, 0, 0, 16, 6, 0, 0, 0,
 0, 0, 0, 6, 0, 2, 0, 0, 4, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0,
 0, 0, 0, 0, 0, 0, 0 ] ), Character( CharacterTable( "U6(2)" ),
 [ 20736, 0, 384, 0, 0, 0, 54, 0, 0, 48, 0, 0, 0, 16, 6, 0, 0, 0,
 0, 0, 0, 6, 0, 2, 0, 4, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0,
 0, 0, 0, 0, 0, 0, 0 ] ) ]
</pre></div>

For the next step, that is, the computation of the extension of the permutation character to \(U_6(2).2\), we may use the above information, since the values on the inner classes are prescribed. The question which of the three candidates for \(U_6(2)\) extends to \(U_6(2).2\) depends on the choice of the class fusion of \(U_6(2)\) into \(U_6(2).2\). With respect to the class fusion that is stored on the GAP library table, the third candidate extends, as can be seen from the fact that this one is invariant under the permutation of conjugacy classes of \(U_6(2)\) that is induced by the action of the chosen supergroup \(U_6(2).2\).

<div class="example"><pre>
gap> u622:= CharacterTable( "U6(2).2" );;
gap> inv:= InverseMap( GetFusionMap( u62, u622 ) );
[ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, [ 11, 12 ], 13, 14, 15, [ 16, 17 ],
 18, 19, 20, 21, 22, 23, 24, 25, 26, [ 27, 28 ], [ 29, 30 ], 31, 32,
 [ 33, 34 ], [ 35, 36 ], 37, [ 38, 39 ], 40, [ 41, 42 ], 43, 44,
 [ 45, 46 ] ]
gap> ext:= List( cand, x -> CompositionMaps( x, inv ) );
[ [ 20736, 0, 384, 0, 0, 0, 54, 0, 0, 0, [ 0, 48 ], 0, 16, 6, 0, 0,
 0, 0, 0, 6, 0, 2, 0, 0, [ 0, 4 ], 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
 0, 0 ],
 [ 20736, 0, 384, 0, 0, 0, 54, 0, 0, 0, [ 0, 48 ], 0, 16, 6, 0, 0,
 0, 0, 0, 6, 0, 2, 0, 0, [ 0, 4 ], 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
 0, 0 ],
 [ 20736, 0, 384, 0, 0, 0, 54, 0, 0, 48, 0, 0, 16, 6, 0, 0, 0, 0, 0,
 6, 0, 2, 0, 4, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0 ] ]
gap> cand:= PermChars( u622, rec( torso:= ext[3] ) );
[ Character( CharacterTable( "U6(2).2" ),
 [ 20736, 0, 384, 0, 0, 0, 54, 0, 0, 48, 0, 0, 16, 6, 0, 0, 0, 0,
 0, 6, 0, 2, 0, 4, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1080,
 72, 0, 48, 8, 0, 0, 0, 18, 0, 0, 0, 8, 0, 0, 2, 0, 0, 0, 0, 2,
 2, 0, 0, 0, 0, 0, 0 ] ) ]
</pre></div>

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

<h4>8.5 Degree \(57\,572\,775\) Permutation Characters of \(O_8^+(3)\)</h4>

The group \(O_8^+(3)\) (see <a href="chapBib_mj.html#biBCCN85">[CCN+85, p. 140]</a>) contains a subgroup of type \(2^{{3+6}}.L_3(2)\), which extends to a maximal subgroup \(U\) in \(O_8^+(3).3\). For the computation of the permutation character, we cannot use explicit induction since the table of \(U\) is not available in the GAP table library. Since \(U \cap O_8^+(3)\) is contained in a \(O_8^+(2)\) subgroup of \(O_8^+(3)\), we can try to find the permutation character of \(O_8^+(2)\) corresponding to the action on the cosets of \(U \cap O_8^+(3)\), and then induce this character to \(O_8^+(3)\). This kind of computations becomes more difficult with increasing degree, so we try to reduce the problem further. In fact, the \(2^{{3+6}}.L_3(2)\) group is contained in a \(2^6:A_8\) subgroup of \(O_8^+(2)\), in which the index is only \(15\); the unique possible permutation character of this degree can be read off immediately. Induction to \(O_8^+(3)\) through the chain of subgroups is possible provided the class fusions are available. There are \(24\) possible fusions from \(O_8^+(2)\) into \(O_8^+(3)\), which are all equivalent w.r.t. table automorphisms of \(O_8^+(3)\). If we later want to consider the extension of the permutation character in question to \(O_8^+(3).3\) then we have to choose a fusion of an \(O_8^+(2)\) subgroup that does not extend to \(O_8^+(2).3\). But if for example our question is just whether the resulting permutation character is multiplicity-free then this can be decided already from the permutation character of \(O_8^+(3)\).

<div class="example"><pre>
gap> o8p3:= CharacterTable("O8+(3)");;
gap> Size( o8p3 ) / (2^9*168);
57572775
gap> o8p2:= CharacterTable( "O8+(2)" );;
gap> fus:= PossibleClassFusions( o8p2, o8p3 );;
gap> Length( fus );
24
gap> rep:= RepresentativesFusions( o8p2, fus, o8p3 );
[ [ 1, 5, 2, 3, 4, 5, 7, 8, 12, 16, 17, 19, 23, 20, 21, 22, 23, 24,
 25, 26, 37, 38, 42, 31, 32, 36, 49, 52, 51, 50, 43, 44, 45, 53,
 55, 56, 57, 71, 71, 71, 72, 73, 74, 78, 79, 83, 88, 89, 90, 94,
 100, 101, 105 ] ]
gap> fus:= rep[1];;
gap> Size( o8p2 ) / (2^9*168);
2025
gap> sub:= CharacterTable( "2^6:A8" );;
gap> subfus:= GetFusionMap( sub, o8p2 );
[ 1, 3, 2, 2, 4, 5, 6, 13, 3, 6, 12, 13, 14, 7, 21, 24, 11, 30, 29,
 31, 13, 17, 15, 16, 14, 17, 36, 37, 18, 41, 24, 44, 48, 28, 33, 32,
 34, 35, 35, 51, 51 ]
gap> fus:= CompositionMaps( fus, subfus );
[ 1, 2, 5, 5, 3, 4, 5, 23, 2, 5, 19, 23, 20, 7, 37, 31, 17, 50, 51,
 43, 23, 23, 21, 22, 20, 23, 56, 57, 24, 72, 31, 78, 89, 52, 45, 44,
 53, 55, 55, 100, 100 ]
gap> Size( sub ) / (2^9*168);
15
gap> List( Irr( sub ), Degree );
[ 1, 7, 14, 20, 21, 21, 21, 28, 35, 45, 45, 56, 64, 70, 28, 28, 35,
 35, 35, 35, 70, 70, 70, 70, 140, 140, 140, 140, 140, 210, 210, 252,
 252, 280, 280, 315, 315, 315, 315, 420, 448 ]
gap> cand:= PermChars( sub, 15 );
[ Character( CharacterTable( "2^6:A8" ),
 [ 15, 15, 15, 7, 7, 7, 7, 7, 3, 3, 3, 3, 3, 0, 0, 0, 3, 3, 3, 3, 3,
 3, 3, 3, 1, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0 ] ) ]
gap> ind:= Induced( sub, o8p3, cand, fus );
[ Character( CharacterTable( "O8+(3)" ),
 [ 57572775, 59535, 59535, 59535, 3591, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 0, 0, 2187, 0, 27, 135, 135, 135, 243, 0, 0, 0, 0, 0, 0, 0, 0,
 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 27, 27, 27, 0, 0, 0, 0, 27,
 27, 27, 27, 0, 8, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 0, 0 ] ) ]
gap> o8p33:= CharacterTable( "O8+(3).3" );;
gap> inv:= InverseMap( GetFusionMap( o8p3, o8p33 ) );
[ 1, [ 2, 3, 4 ], 5, 6, [ 7, 8, 9 ], [ 10, 11, 12 ], 13,
 [ 14, 15, 16 ], 17, 18, 19, [ 20, 21, 22 ], 23, [ 24, 25, 26 ],
 [ 27, 28, 29 ], 30, [ 31, 32, 33 ], [ 34, 35, 36 ], [ 37, 38, 39 ],
 [ 40, 41, 42 ], [ 43, 44, 45 ], 46, [ 47, 48, 49 ], 50,
 [ 51, 52, 53 ], 54, 55, 56, 57, [ 58, 59, 60 ], [ 61, 62, 63 ], 64,
 [ 65, 66, 67 ], 68, [ 69, 70, 71 ], [ 72, 73, 74 ], [ 75, 76, 77 ],
 [ 78, 79, 80 ], [ 81, 82, 83 ], 84, 85, [ 86, 87, 88 ],
 [ 89, 90, 91 ], [ 92, 93, 94 ], 95, 96, [ 97, 98, 99 ],
 [ 100, 101, 102 ], [ 103, 104, 105 ], [ 106, 107, 108 ],
 [ 109, 110, 111 ], [ 112, 113, 114 ] ]
gap> ext:= CompositionMaps( ind[1], inv );
[ 57572775, 59535, 3591, 0, 0, 0, 0, 0, 2187, 0, 27, 135, 243, 0, 0,
 0, 0, 0, 0, 0, 27, 0, 0, 27, 27, 0, 8, 1, 1, 0, 0, 0, 0, 0, 0, 0,
 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ]
gap> perms:= PermChars( o8p33, rec( torso:= ext ) );
[ Character( CharacterTable( "O8+(3).3" ),
 [ 57572775, 59535, 3591, 0, 0, 0, 0, 0, 2187, 0, 27, 135, 243, 0,
 0, 0, 0, 0, 0, 0, 27, 0, 0, 27, 27, 0, 8, 1, 1, 0, 0, 0, 0, 0,
 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3159,
 3159, 243, 243, 39, 39, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0, 3, 3, 3,
 3, 3, 3, 0, 0, 0, 0, 0, 0, 2, 2, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0,
 0, 0 ] ) ]
gap> PermCharInfo( o8p33, perms ).ATLAS;
[ "1a+780aabb+2457a+2808abc+9450aaabbcc+18200abcdddef+24192a+54600a^{5\
}b+70200aabb+87360ab+139776a^{5}+147420a^{4}b^{4}+163800ab+184275aabc+\
199017aa+218700a+245700a+291200aef+332800a^{4}b^{5}c^{5}+491400aaabcd+\
531441a^{5}b^{4}c^{4}+552825a^{4}+568620aabb+698880a^{4}b^{4}+716800aa\
abbccdddeeff+786240aabb+873600aa+998400aa+1257984a^{6}+1397760aa" ]
</pre></div>

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

<h4>8.6 The Action of \(O_7(3).2\) on the Cosets of \(2^7.S_7\)</h4>

We want to know whether the permutation character of \(O_7(3).2\) (see <a href="chapBib_mj.html#biBCCN85">[CCN+85, p. 108]</a>) on the cosets of its maximal subgroup \(U\) of type \(2^7.S_7\) is multiplicity-free. As in the previous examples, first we try to compute the permutation character of the simple group \(O_7(3)\). It turns out that the direct computation of all candidates from the degree is very time consuming. But we can use for example the additional information provided by the fact that \(U\) contains an \(A_7\) subgroup. We compute the possible class fusions.

<div class="example"><pre>
gap> o73:= CharacterTable( "O7(3)" );;
gap> a7:= CharacterTable( "A7" );;
gap> fus:= PossibleClassFusions( a7, o73 );
[ [ 1, 3, 6, 10, 15, 16, 24, 33, 33 ],
 [ 1, 3, 7, 10, 15, 16, 22, 33, 33 ] ]
</pre></div>

We cannot decide easily which fusion is the right one, but already the fact that no other fusions are possible gives us some information about impossible constituents of the permutation character we want to compute.

<div class="example"><pre>
gap> ind:= List( fus,
> x -> Induced( a7, o73, [ TrivialCharacter( a7 ) ], x )[1] );;
gap> mat:= MatScalarProducts( o73, Irr( o73 ), ind );;
gap> sum:= Sum( mat );
[ 2, 6, 2, 0, 8, 6, 2, 4, 4, 8, 3, 0, 4, 4, 9, 3, 5, 0, 0, 9, 0, 10,
 5, 6, 15, 1, 12, 1, 15, 7, 2, 4, 14, 16, 0, 12, 12, 7, 8, 8, 14,
 12, 12, 14, 6, 6, 20, 16, 12, 12, 12, 10, 10, 12, 12, 8, 12, 6 ]
gap> const:= Filtered( [ 1 .. Length( sum ) ], x -> sum[x] <> 0 );
[ 1, 2, 3, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15, 16, 17, 20, 22, 23, 24,
 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 36, 37, 38, 39, 40, 41, 42,
 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58 ]
gap> Length( const );
52
gap> const:= Irr( o73 ){ const };;
gap> rat:= RationalizedMat( const );;
</pre></div>

But much more can be deduced from the fact that certain zeros of the permutation character can be predicted.

<div class="example"><pre>
gap> names:= ClassNames( o73 );
[ "1a", "2a", "2b", "2c", "3a", "3b", "3c", "3d", "3e", "3f", "3g",
 "4a", "4b", "4c", "4d", "5a", "6a", "6b", "6c", "6d", "6e", "6f",
 "6g", "6h", "6i", "6j", "6k", "6l", "6m", "6n", "6o", "6p", "7a",
 "8a", "8b", "9a", "9b", "9c", "9d", "10a", "10b", "12a", "12b",
 "12c", "12d", "12e", "12f", "12g", "12h", "13a", "13b", "14a",
 "15a", "18a", "18b", "18c", "18d", "20a" ]
gap> List( fus, x -> names{ x } );
[ [ "1a", "2b", "3b", "3f", "4d", "5a", "6h", "7a", "7a" ],
 [ "1a", "2b", "3c", "3f", "4d", "5a", "6f", "7a", "7a" ] ]
gap> torso:= [ 28431 ];;
gap> zeros:= [ 5, 8, 9, 11, 17, 20, 23, 28, 29, 32, 36, 37, 38,
> 43, 46, 47, 48, 53, 54, 55, 56, 57, 58 ];;
gap> names{ zeros };
[ "3a", "3d", "3e", "3g", "6a", "6d", "6g", "6l", "6m", "6p", "9a",
 "9b", "9c", "12b", "12e", "12f", "12g", "15a", "18a", "18b", "18c",
 "18d", "20a" ]
</pre></div>

Every order \(3\) element of \(U\) lies in an \(A_7\) subgroup of \(U\), so among the classes of element order \(3\), at most the classes <code class="code">3B</code>, <code class="code">3C</code>, and <code class="code">3F</code> can have nonzero permutation character values. The excluded classes of element order \(6\) are the square roots of the excluded order \(3\) elements, likewise the given classes of element orders \(9\), \(12\), and \(18\) are excluded. The character value on <code class="code">20A</code> must be zero because \(U\) does not contain elements of this order. So we enter the additional information about these zeros.

<div class="example"><pre>
gap> for i in zeros do
> torso[i]:= 0;
> od;
gap> torso;
[ 28431,,,, 0,,, 0, 0,, 0,,,,,, 0,,, 0,,, 0,,,,, 0, 0,,, 0,,,, 0, 0,
 0,,,,, 0,,, 0, 0, 0,,,,, 0, 0, 0, 0, 0, 0 ]
gap> perms:= PermChars( o73, rec( torso:= torso, chars:= rat ) );
[ Character( CharacterTable( "O7(3)" ),
 [ 28431, 567, 567, 111, 0, 0, 243, 0, 0, 81, 0, 15, 3, 27, 15, 6,
 0, 0, 27, 0, 3, 27, 0, 0, 0, 3, 9, 0, 0, 3, 3, 0, 4, 1, 1, 0,
 0, 0, 0, 2, 2, 3, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 0 ] ) ]
gap> PermCharInfo( o73, perms ).ATLAS;
[ "1a+78a+168a+182a+260ab+1092a+2457a+2730a+4095b+5460a+11648a" ]
</pre></div>

We see that this character is already multiplicity free, so this holds also for its extension to \(O_7(3).2\), and we need not compute this extension. (Of course we could compute it in the same way as in the examples above.)

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

<h4>8.7 The Action of \(O_8^+(3).2_1\) on the Cosets of \(2^7.A_8\)</h4>

We are interested in the permutation character of \(O_8^+(3).2_1\) that corresponds to the action on the cosets of a subgroup of type \(2^7.A_8\). The intersection of the point stabilizer with the simple group \(O_8^+(3)\) is of type \(2^6.A_8\). First we compute the class fusion of these groups, modulo problems with ambiguities due to table automorphisms.

<div class="example"><pre>
gap> o8p3:= CharacterTable( "O8+(3)" );;
gap> o8p2:= CharacterTable( "O8+(2)" );;
gap> fus:= PossibleClassFusions( o8p2, o8p3 );;
gap> NamesOfFusionSources( o8p2 );
[ "A9", "2^8:O8+(2)", "(D10xD10).2^2", "(3x3^3:S3):2",
 "(3x3^(1+2)+:2A4).2", "2^(3+3+3).L3(2)", "NRS(O8+(2),2^(3+3+3)_a)",
 "NRS(O8+(2),2^(3+3+3)_b)", "O8+(2)N2", "O8+(2)M2", "O8+(2)M3",
 "O8+(2)M5", "O8+(2)M6", "O8+(2)M8", "O8+(2)M9", "(3xU4(2)):2",
 "O8+(2)M11", "O8+(2)M12", "2^(1+8)_+:(S3xS3xS3)", "3^4:2^3.S4(a)",
 "(A5xA5):2^2", "O8+(2)M16", "O8+(2)M17", "2^(1+8)+.O8+(2)", "7:6",
 "(A5xD10).2", "(D10xA5).2", "O8+(2)N5C", "2^6:A8", "2.O8+(2)",
 "2^2.O8+(2)", "S6(2)" ]
gap> sub:= CharacterTable( "2^6:A8" );;
gap> subfus:= GetFusionMap( sub, o8p2 );
[ 1, 3, 2, 2, 4, 5, 6, 13, 3, 6, 12, 13, 14, 7, 21, 24, 11, 30, 29,
 31, 13, 17, 15, 16, 14, 17, 36, 37, 18, 41, 24, 44, 48, 28, 33, 32,
 34, 35, 35, 51, 51 ]
gap> fus:= List( fus, x -> CompositionMaps( x, subfus ) );;
gap> fus:= Set( fus );;
gap> Length( fus );
24
</pre></div>

The ambiguities due to Galois automorphisms disappear when we are looking for the permutation characters induced by the fusions.

<div class="example"><pre>
gap> ind:= List( fus, x -> Induced( sub, o8p3,
> [ TrivialCharacter( sub ) ], x )[1] );;
gap> ind:= Set( ind );;
gap> Length( ind );
6
</pre></div>

Now we try to extend the candidates to \(O_8^+(3).2_1\); the choice of the fusion of \(O_8^+(3)\) into \(O_8^+(3).2_1\) determines which of the candidates may extend.

<div class="example"><pre>
gap> o8p32:= CharacterTable( "O8+(3).2_1" );;
gap> fus:= GetFusionMap( o8p3, o8p32 );;
gap> ext:= List( ind, x -> CompositionMaps( x, InverseMap( fus ) ) );;
gap> ext:= Filtered( ext, x -> ForAll( x, IsInt ) );
[ [ 3838185, 17577, 8505, 8505, 873, 0, 0, 0, 0, 6561, 0, 0, 729, 0,
 9, 105, 45, 45, 105, 30, 0, 0, 0, 0, 0, 0, 0, 0, 0, 189, 0, 0,
 0, 9, 9, 27, 27, 0, 0, 27, 9, 0, 8, 1, 1, 0, 0, 0, 0, 0, 0, 0,
 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0,
 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0 ],
 [ 3838185, 17577, 8505, 8505, 873, 0, 6561, 0, 0, 0, 0, 0, 729, 0,
 9, 105, 45, 45, 105, 30, 0, 0, 0, 0, 0, 0, 189, 0, 0, 0, 9, 0,
 0, 0, 9, 27, 27, 0, 0, 9, 27, 0, 8, 1, 1, 0, 0, 0, 0, 0, 0, 0,
 0, 2, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0,
 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ] ]
</pre></div>

We compute the extensions of the first candidate; the other belongs to another class of subgroups, which is the image under an outer automorphism.

<div class="example"><pre>
gap> perms:= PermChars( o8p32, rec( torso:= ext[1] ) );
[ Character( CharacterTable( "O8+(3).2_1" ),
 [ 3838185, 17577, 8505, 8505, 873, 0, 0, 0, 0, 6561, 0, 0, 729, 0,
 9, 105, 45, 45, 105, 30, 0, 0, 0, 0, 0, 0, 0, 0, 0, 189, 0, 0,
 0, 9, 9, 27, 27, 0, 0, 27, 9, 0, 8, 1, 1, 0, 0, 0, 0, 0, 0, 0,
 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0,
 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 3159, 1575, 567, 63, 87,
 15, 0, 0, 45, 0, 81, 9, 27, 0, 0, 3, 3, 3, 3, 5, 5, 0, 0, 0, 4,
 0, 0, 27, 0, 9, 0, 0, 15, 0, 3, 0, 0, 2, 0, 0, 0, 0, 0, 3, 0,
 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ] ) ]
gap> PermCharInfo( o8p32, perms ).ATLAS;
[ "1a+260abc+520ab+819a+2808b+9450aab+18200a+23400ac+29120b+36400aab+4\
6592abce+49140d+66339a+98280ab+163800a+189540d+232960d+332800ab+368550\
a+419328a+531441ab" ]
</pre></div>

Now we repeat the calculations for \(O_8^+(3).2_2\) instead of \(O_8^+(3).2_1\).

<div class="example"><pre>
gap> o8p32:= CharacterTable( "O8+(3).2_2" );;
gap> fus:= GetFusionMap( o8p3, o8p32 );;
gap> ext:= List( ind, x -> CompositionMaps( x, InverseMap( fus ) ) );;
gap> ext:= Filtered( ext, x -> ForAll( x, IsInt ) );;
gap> perms:= PermChars( o8p32, rec( torso:= ext[1] ) );
[ Character( CharacterTable( "O8+(3).2_2" ),
 [ 3838185, 17577, 8505, 873, 0, 0, 0, 6561, 0, 0, 0, 0, 729, 0, 9,
 105, 45, 105, 30, 0, 0, 0, 0, 0, 0, 189, 0, 0, 0, 9, 0, 9, 27,
 0, 0, 0, 27, 27, 9, 0, 8, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 2, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0,
 0, 6, 0, 0, 0, 0, 0, 0, 0, 199017, 2025, 297, 441, 73, 9, 0,
 1215, 0, 0, 0, 0, 0, 81, 0, 0, 0, 0, 27, 27, 0, 1, 9, 12, 0, 0,
 45, 0, 0, 1, 0, 0, 3, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 1, 0,
 0, 0, 0, 0, 0 ] ) ]
gap> PermCharInfo( o8p32, perms ).ATLAS;
[ "1a+260aac+520ab+819a+2808a+9450aaa+18200accee+23400ac+29120a+36400a\
+46592aa+49140c+66339a+93184a+98280ab+163800a+184275ac+189540c+232960c\
+332800aa+419328a+531441aa" ]
</pre></div>

We might be interested in the extension to \(O_8^+(3).(2^2)_{122}\). It is clear that this cannot be multiplicity free because of the multiplicity <code class="code">9450aaa</code> in the character induced from \(O_8^+(3).2_2\). We could put the extensions to the index two subgroups together, but it is simpler (and not expensive) to run the same program as above.

<div class="example"><pre>
gap> o8p322:= CharacterTable( "O8+(3).(2^2)_{122}" );;
gap> fus:= GetFusionMap( o8p32, o8p322 );;
gap> ext:= List( perms, x -> CompositionMaps( x, InverseMap( fus ) ) );;
gap> ext:= Filtered( ext, x -> ForAll( x, IsInt ) );;
gap> perms:= PermChars( o8p322, rec( torso:= ext[1] ) );
[ Character( CharacterTable( "O8+(3).(2^2)_{122}" ),
 [ 3838185, 17577, 8505, 873, 0, 0, 0, 6561, 0, 0, 729, 0, 9, 105,
 45, 105, 30, 0, 0, 0, 0, 0, 0, 189, 0, 0, 9, 9, 27, 0, 0, 27,
 9, 0, 8, 1, 1, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 9, 0, 0,
 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 3159, 1575,
 567, 63, 87, 15, 0, 0, 45, 0, 81, 9, 27, 0, 0, 3, 3, 3, 5, 0,
 0, 4, 0, 0, 27, 0, 9, 0, 0, 15, 0, 3, 0, 0, 2, 0, 0, 0, 3, 0,
 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 199017, 2025, 297, 441, 73, 9, 0,
 1215, 0, 0, 0, 0, 81, 0, 0, 0, 27, 27, 0, 1, 9, 12, 0, 0, 45,
 0, 0, 1, 0, 0, 3, 1, 0, 0, 0, 0, 0, 0, 0, 2, 1, 0, 0, 0, 0, 0,
 0, 28431, 1647, 135, 63, 87, 39, 0, 0, 243, 27, 0, 0, 81, 63,
 0, 0, 0, 9, 0, 3, 3, 6, 2, 0, 0, 0, 9, 0, 0, 3, 3, 3, 0, 4, 0,
 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0 ] ) ]
gap> PermCharInfo( o8p322, perms ).ATLAS;
[ "1a+260ace+819a+1040a+2808c+9450aac+18200a+23400ae+29120c+36400aac+4\
6592ac+49140g+66339a+93184a+163800b+189540g+196560a+232960g+332800ac+3\
68550a+419328a+531441ac" ]
</pre></div>

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

<h4>8.8 The Action of \(S_4(4).4\) on the Cosets of \(5^2.[2^5]\)</h4>

We want to know whether the permutation character corresponding to the action of \(S_4(4).4\) (see <a href="chapBib_mj.html#biBCCN85">[CCN+85, p. 44]</a>) on the cosets of its maximal subgroup of type \(5^2:[2^5]\) is multiplicity free. The library names of subgroups for which the class fusions are stored are listed as value of the attribute <code class="func">NamesOfFusionSources</code> (<a href="../../../doc/ref/chap73_mj.html#X7F6569D5786A9D49">Reference: NamesOfFusionSources</a>), and for groups whose isomorphism type is not determined by the name this is the recommended way to find out whether the table of the subgroup is contained in the GAP library and known to belong to this group. (It might be that a table with such a name is contained in the library but belongs to another group, and it may also be that the table of the group is contained in the library --with any name-- but it is not known that this group is isomorphic to a subgroup of \(S_4(4).4\).)

<div class="example"><pre>
gap> s444:= CharacterTable( "S4(4).4" );;
gap> NamesOfFusionSources( s444 );
[ "(L3(2)xS4(4):2).2", "S4(4)", "S4(4).2" ]
</pre></div>

So we cannot simply fetch the table of the subgroup. As in the previous examples, we compute the possible permutation characters.

<div class="example"><pre>
gap> perms:= PermChars( s444,
> rec( torso:= [ Size( s444 ) / ( 5^2*2^5 ) ] ) );
[ Character( CharacterTable( "S4(4).4" ),
 [ 4896, 384, 96, 0, 16, 32, 36, 16, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0,
 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ] ),
 Character( CharacterTable( "S4(4).4" ),
 [ 4896, 192, 32, 0, 0, 8, 6, 1, 0, 2, 0, 0, 36, 0, 12, 0, 0, 0, 1,
 0, 6, 6, 2, 2, 0, 0, 0, 0, 1, 1 ] ),
 Character( CharacterTable( "S4(4).4" ),
 [ 4896, 240, 64, 0, 8, 8, 36, 16, 0, 0, 0, 0, 0, 12, 8, 0, 4, 4, 0,
 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ] ) ]
</pre></div>

So there are three candidates. None of them is multiplicity free, so we need not decide which of the candidates actually belongs to the group \(5^2:[2^5]\) we have in mind.

<div class="example"><pre>
gap> PermCharInfo( s444, perms ).ATLAS;
[ "1abcd+50abcd+153abcd+170a^{4}b^{4}+680aabb",
 "1a+50ac+153a+170aab+256a+680abb+816a+1020a",
 "1ac+50ac+68a+153abcd+170aabbb+204a+680abb+1020a" ]
</pre></div>

(If we would be interested which candidate is the right one, we could for example look at the intersection with \(S_4(4)\), and hope for a contradiction to the fact that the group must lie in a \((A_5 \times A_5):2\) subgroup.)

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

<h4>8.9 The Action of \(Co_1\) on the Cosets of Involution Centralizers</h4>

We compute the permutation characters of the sporadic simple Conway group \(Co_1\) (see <a href="chapBib_mj.html#biBCCN85">[CCN+85, p. 180]</a>) corresponding to the actions on the cosets of involution centralizers. Equivalently, we are interested in the action of \(Co_1\) on conjugacy classes of involutions. These characters can be computed as follows. First we take the table of \(Co_1\).

<div class="example"><pre>
gap> t:= CharacterTable( "Co1" );
CharacterTable( "Co1" )
</pre></div>

--> --------------------

--> maximum size reached

--> --------------------

quality100%

¤ Dauer der Verarbeitung: 0.29 Sekunden (vorverarbeitet) ¤

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.