GAP

## A solvable maximal subgroup of Fi23

In this example a solvable maximal subgroup of the sporadic simple group Fi23 is constructed and some of its structure investigated. The permutation character of Fi23 on its cosets is computed.

Most of the original computation was done in the Diploma thesis [Hul93] of Alexander Hulpke. In terms of GAP 3, some part of the example is described in a survey paper by Joachim Neubueser, another part in a talk by Alexander Hulpke.

The following is a GAP 4 version. The input used is available in form of a plain GAP 4 input file.

The Cambridge ATLAS [CCN+85] provides a list of maximal subgroups of Fi23, which for the first class of maximal subgroups contains:

 Order Index Structure Character 129123503308800 31671 2.Fi22 1a+782a+30888a

This tells us that Fi23 has a (faithful) transitive permutation representation of degree 31671, the character of which is the sum of three irreducibles 1a, 782a, and 30888a.

The corresponding line for the subgroup we want to investigate, called S in the sequel, contains

 Order Index Structure 3265173504 1252451200 3+1+8 .2- 1+6 .3+1+2 .2S4 N(3B)

giving us the information that it can be obtained as normalizer of an element of class 3B. However, it does not give us information about the permutation character of Fi23 on the cosets of S.

In addition to this information we use:

We start by reading in this character table and determining the permutation character of degree 31671 as the sum of those three irreducibles, which (as in the ATLAS) have numbers 1, 2, and 6 in the list of characters:
```gap> LoadPackage( "ctbllib" );
true
gap> ct := CharacterTable( "Fi23" );;
gap> permchar := Sum( Irr( ct ){[1,2,6]} );;
gap> permchar;
31671
```
The following commands tell us that Fi23 has four classes of elements of order 3 and that these four classes have numbers 5, 6, 7, and 8 in the character table and that they can be discriminated by the value of the permutation character:
```gap> nccl := NrConjugacyClasses( ct );;
gap> ord3 := Filtered( [ 1 .. nccl ],
>      i -> OrdersClassRepresentatives( ct )[i] = 3 );
[ 5, 6, 7, 8 ]
gap> permchar{ ord3 };
[ 351, 324, 135, 27 ]
```
So elements in class 3B (the second class of elements of order 3) have 324 fixed points.
The table head of the character table of Fi23, either in the ATLAS or from the GAP library of character tables, gives us information about our chances of finding an element from class 3B in a random search. The centralizer of an element of class 3B is of order 1632586752, that is, we have a probability of 1 : 1632586752 that a random element of Fi23 is in class 3B. However from the power map we see that elements of class 3B can be obtained i.a. as powers of elements of classes 36A, 36B, and 27A, which are selfcentralizing, so that we have an almost 10% chance to hit an element of one of these 3 classes. The following GAP routine tells us that altogether we have more than a 16% chance to find an element with a power in class 3B by a random search.
```gap> roots := [ 6 ];;
gap> for i in [ 1 .. nccl ] do
>      if ForAny( Set( Factors( Size( ct ) ) ),
>          p -> PowerMap( ct, p )[i] in roots ) then
>      fi;
>    od;
gap> roots;
[ 6, 15, 17, 19, 21, 33, 34, 35, 36, 43, 45, 46, 47, 52, 66, 67, 68, 69, 70,
71, 72, 83, 87, 93, 94 ]
gap> prop := Sum( roots, i -> 1 / SizesCentralizers( ct )[i] );
257647/1594323
gap> Int( 100 * prop );
16
```
Now we compute an element in 3B and its normalizer N in G. The representation is taken from the ATLAS of Group Representations which we access via the GAP package AtlasRep.
```gap> LoadPackage( "atlasrep" );
true
gap> gens := OneAtlasGeneratingSet( "Fi23", NrMovedPoints, 31671 );;
gap> Fi23 := Group( gens.generators );;
gap> SetSize( Fi23, Size( ct ) );
gap> opdom := MovedPoints( Fi23 );;
gap> found := false;;
gap> repeat
>      g := Random( Fi23 );
>      ord := Order( g );
>      if ord mod 3 = 0 then
>        h := g^( ord / 3 );
>        if Number( opdom, i -> i^h = i ) = 324 then
>          found := true;
>        fi;
>      fi;
>    until found;
gap> N := Normalizer( Fi23, SubgroupNC( Fi23, [ h ] ) );;
gap> Size( N );
3265173504
```
So we now have our maximal subgroup of order 3265173504 as a permutation group N of degree 31671. For computing the character table of N, we switch first to a faithful permutation representation of smaller degree, and then - since N is solvable - to an isomorphic polycyclicly presented group.
```gap> orb := Orbits( N, opdom );;
gap> List( orb, Length );
[ 19683, 11664, 324 ]
gap> P := Action( N, orb );;
gap> Size( P ) = Size( N );
true
gap> A := Image( IsomorphismPcGroup( P ) );;
gap> Size( A ) = Size( N );
true
```
We may now get information such as the derived series in rather short time:
```gap> ds := DerivedSeries( A );;
gap> Length( ds );
11
gap> List( ds, i -> Collected( Factors( Size( i ) ) ) );
[ [ [ 2, 11 ], [ 3, 13 ] ], [ [ 2, 10 ], [ 3, 13 ] ],
[ [ 2, 10 ], [ 3, 12 ] ], [ [ 2, 8 ], [ 3, 12 ] ], [ [ 2, 7 ], [ 3, 12 ] ],
[ [ 2, 7 ], [ 3, 10 ] ], [ [ 2, 7 ], [ 3, 9 ] ], [ [ 2, 1 ], [ 3, 9 ] ],
[ [ 3, 9 ] ], [ [ 3, 1 ] ], [ [ 1, 1 ] ] ]
```
This confirms some of the information about the structure of the group quoted above from the ATLAS. However using methods described e.g. in [CNW90] we can obtain further information about the splitting of extensions, e.g. we can determine representatives of the conjugacy classes of complements of the second last group in the derived series which is an extra special group of order 39.
```gap> compcl := List( [1..8],
>     i-> Complementclasses( ds[i], ds ) );;
gap> List( compcl, Length );
[ 3, 3, 1, 1, 9, 3, 1, 1 ]
```
We can also determine the conjugacy classes of elements using methods from [MN89].
```gap> conjcl := ConjugacyClasses( A );;
gap> Length( conjcl );
181
```
We see that there are 181 classes. Finally we can determine the character table of this group, using A. Hulpke's implementation of the Dixon/Schneider method [Dix67, Sch90]. (This table has in fact been used meanwhile for the determination of the 5-modular character table of Fi23 in a paper [HL94] by Gerhard Hiss and Klaus Lux.)
```gap> sct := CharacterTable( A );;
gap> Irr( sct );;
#I  computing class matrix for class of size >10^6
#I  computing class matrix for class of size >10^6
```
This is indeed the longest computation of the whole run. You may check the time needed on your computer. To be able to complete it, you need to start GAP with at least -o 400M option. Printing a 181 x 181 table is not what we want, but we can use GAP to extract information from the character table. We may for instance ask for the maximal degree of an irreducible character.
```gap> Maximum( List( Irr( sct ), i -> i ) );
18432
```
Or we may ask for the extension of the rationals generated by the character values:
```gap> irrat := Filtered( Union( Irr( sct ) ), i -> not IsRat( i) );
[ -4*E(8)-4*E(8)^3, -2*E(8)-2*E(8)^3, -E(8)-E(8)^3, E(8)+E(8)^3,
2*E(8)+2*E(8)^3, 4*E(8)+4*E(8)^3 ]
gap> alpha := irrat;
E(8)+E(8)^3
gap> MinimalPolynomial( Rationals, alpha );
x_1^2+2
gap> MinimalPolynomial( Rationals, E( 8 ) );
x_1^4+1
```
We may also ask for the kernel of a character and in this particular case identify it with the third last group in the derived series.
```gap> char144 := First( Irr( sct ), i -> i = 144 );;
gap> ker := KernelOfCharacter( char144 );
<pc group with 10 generators>
gap> Size( ker );
39366
gap> ker = ds;
true
```
Finally we compute the permutation character of G that corresponds to the action on the cosets of N. For that, we need the class fusion of N in G, and we compute candidates for this fusion from the character tables.
```gap> fus := PossibleClassFusions( sct, ct );;
gap> Length( fus );
6
gap> Length( RepresentativesFusions( AutomorphismsOfTable( sct ), fus,
>                AutomorphismsOfTable( ct ) ) );
1
```
So the class fusion is uniquely determined up to table automorphisms. All possible fusions induce the same permutation character.
```gap> ind := Set( List( fus,
>       map -> Induced( sct, ct, [ TrivialCharacter( sct ) ], map ) ) );
[ Character( CharacterTable( "Fi23" ), [ 1252451200, 12812800, 98560, 44160,
167440, 35761, 5170, 904, 1120, 112, 320, 80, 0, 3640, 3217, 280, 145,
472, 561, 120, 177, 528, 166, 10, 66, 24, 30, 48, 0, 20, 12, 4, 121,
13, 49, 13, 1, 0, 0, 0, 0, 40, 25, 28, 13, 13, 17, 4, 10, 8, 4, 5, 8,
4, 2, 2, 0, 0, 0, 0, 0, 0, 2, 2, 0, 1, 7, 9, 9, 1, 1, 3, 1, 0, 0, 0, 0,
0, 0, 0, 0, 6, 1, 2, 0, 0, 1, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0 ] ) ]
gap> MatScalarProducts( ct, Irr( ct ), ind );
[ [ 1, 0, 0, 0, 0, 2, 0, 2, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,
0, 1, 1, 0, 0, 0, 0, 3, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 2, 0, 0, 0, 0,
0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2,
0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0 ] ]
gap> PermCharInfo( ct, ind ).ATLAS;
[ "1a+30888aa+106743aa+812889a+5533110a+7468032a+8783424a+12077208aaa+20322225\
a+26838240a+37573536aa+58708650a+73531392a+216154575a+216770400aa+289103904a"
]
```
Alternatively, we could have tried to compute the class fusion explicitly from class representatives of the subgroup N of G, i.e., in the representation on 31671 points; for that, it would be necessary to compute preimages of class representatives of the group `A' in `P' and `N', via suitable homomorphisms. Note that in this case, the irreducible characters of N need not be computed for getting the permutation character.

### Bibliography

CCN+85
J. H. Conway, R. T. Curtis, S. P. Norton, R. A. Parker, and R. A. Wilson.
ATLAS of finite groups.
Oxford University Press, 1985.
CNW90
F. Celler, J. Neubüser, and C. R. B. Wright, Some remarks on the computation of complements and normalizers in soluble groups, Acta Applicandae Mathematicae 21 (1990), 57-76.
Dix67
J. D. Dixon, High speed computation of group characters, Numer. Math. 10 (1967), 446-450.
HL94
Gerhard Hiss and Klaus Lux, The 5-modular characters of the sporadic simple Fischer groups F22 and F23, Comm. Algebra 22(9) (1994), 3563-3590.
Hul93
A. Hulpke.
Zur Berechnung von Charaktertafeln.
Diplomarbeit, Lehrstuhl D für Mathematik, Rheinisch Westfälische Technische Hochschule, 1993.
MN89
M. Mecky and J. Neubüser, Some remarks on the computation of conjugacy classes of soluble groups, Bulletin of the Australian Mathematical Society 40 (1989), 281-292.
Sch90
G. J. A. Schneider, Dixon's character table algorithm revisited, J. Symbolic Computation 9 (1990), no. 5/6, 601-606.