# Constructing the Irreducible Characters of O'N with GAP

### THOMAS BREUER
Lehrstuhl D für Mathematik
RWTH, 52056 Aachen, Germany

### September 14th, 2004

We assume that the "table head" of the ordinary character table of the sporadic simple O'Nan group O′N is known. That is, the conjugacy classes and their centralizer orders are known as well as all p-th power maps, for primes p up to the maximal element order in O′N, which is 31. For the sake of simplicity, we take the table head of the character table contained in the GAP Character Table Library [Bre12].

        gap> LoadPackage( "ctbllib" );
        true
        gap> tbl:= CharacterTable( "ON" );
        CharacterTable( "ON" )
        gap> NrConjugacyClasses( tbl );
        30

Besides the table head with the trivial character, we assume that we know a nontrivial irreducible character of smallest degree -which is 10 944- and the nontrivial permutation character of smallest degree; the latter character corresponds to the action on the cosets of a maximal subgroup of type L3(7).2 in O′N.

        gap> irreducibles:= Irr( tbl ){ [ 1, 2 ] };
        [ Character( CharacterTable( "ON" ), [ 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, 1, 1, 1, 1, 1 ] ),
          Character( CharacterTable( "ON" ), [ 10944, 64, 9, 64, 0, -1, 1, 17, 3, 0,
              0, -1, -1, 1, 1, -1, -1, 0, 0, 0, 0, 0, 0, 0, -1, -1, 1, 1, 1, 1 ] ) ]
        gap> max:= CharacterTable( Maxes( tbl )[1] );
        CharacterTable( "L3(7).2" )
        gap> pi:= TrivialCharacter( max ) ^ tbl;
        Character( CharacterTable( "ON" ), [ 122760, 360, 45, 120, 8, 0, 9, 15, 1, 4,
          0, 0, 0, 3, 3, 0, 0, 2, 2, 0, 0, 1, 1, 1, 0, 0, 1, 1, 0, 0 ] )

Now our strategy is to create characters that are in general reducible, and to compute characters and virtual characters of smaller norm from them until eventually the list of irreducibles is complete.
We start with the characters obtained by induction from cyclic subgroups of O′N, and symmetrizations of the known irreducibles. Note that these two computations are possible only because we know the power maps of O′N.

        gap> indcyc:= InducedCyclic( tbl, "all" );;
        gap> sym2:= Symmetrizations( tbl, irreducibles, 2 );;
        gap> sym3:= Symmetrizations( tbl, irreducibles, 3 );;

Before we start to work with characters, we raise the info level for computations of this kind. This will for example cause that a message is printed whenever a new irreducible character has been found.

        gap> SetInfoLevel( InfoCharacterTable, 2 );

First we reduce the characters with the known irreducibles, that is, we project them into the orthogonal space of the vector space that is spanned by the known irreducibles.

        gap> chars:= Concatenation( indcyc, [ pi ], sym2, sym3 );;
        gap> Length( chars );
        91
        gap> chars:= ReducedCharacters( tbl, irreducibles, chars );;
        gap> Length( chars.irreducibles );
        0
        gap> Length( chars.remainders );
        86

In order to find out the dimension of the Z-lattice spanned by the remaining reducible characters, we compute a lattice basis using the LLL algorithm.

        gap> lll:= LLL( tbl, chars.remainders );;
        #I  LLL: 13 irreducibles found

We were lucky, 13 new irreducibles were obtained as elements of the lattice basis; in order to work in their orthogonal space from now on, we reduce `chars.remainders` with them.

        gap> newirr:= lll.irreducibles;;
        gap> chars:= ReducedCharacters( tbl, lll.irreducibles, chars.remainders );;

This yields no new irreducibles. Now let us look at the reducible vectors in the lattice basis computed by `LLL`.

        gap> Length( lll.remainders );
        15
        gap> lll.norms;
        [ 2, 2, 2, 2, 2, 2, 3, 2, 3, 3, 2, 2, 2, 2, 3 ]

Together with the 15 known irreducibles, the basis of length 15 spans the whole 30 dimensional space of irreducibles of O′N. The norms of the virtual characters in `lll.remainders` are listed in `lll.norms`, in our case they are very small. Since `LLL` does not reduce the virtual characters in the `remainders` list with the characters in the `irreducibles` list, we do this reduction now.

        gap> lll:= ReducedClassFunctions( tbl, lll.irreducibles, lll.remainders );;
        gap> Append( irreducibles, newirr );
        gap> Length( irreducibles );
        15

Now 15 irreducible characters are missing, and we know a 15-dimensional lattice L of virtual characters inside the standard lattice spanned by these irreducibles. Let us compute the possible embeddings of L into the standard lattice, and try to deduce irreducible characters if possible. We use the new irreducibles to repeat the process of generating and reducing characters.

        gap> gram:= MatScalarProducts( tbl, lll.remainders, lll.remainders );;
        gap> emb:= OrthogonalEmbeddingsSpecialDimension( tbl, lll.remainders,
        >              gram, Length( gram ) );;
        #I  Decreased : computation of 2nd character failed
        gap> Length( emb.irreducibles );
        11
        gap> Append( irreducibles, emb.irreducibles );
        gap> Length( irreducibles );
        26

This first attempt yields 11 new irreducibles that are uniquely determined by the possible embeddings. Let us see which embeddings are possible for the remaining 4-dimensional lattice.

        gap> chars:= emb.remainders;;
        gap> gram:= MatScalarProducts( tbl, chars, chars );
        [ [ 2, 0, -1, -1 ], [ 0, 2, -1, -1 ], [ -1, -1, 2, 1 ], [ -1, -1, 1, 2 ] ]
        gap> emb:= OrthogonalEmbeddings( gram, 4 );
        rec( vectors := [ [ -1, -1, 1, 1 ], [ -1, 1, 0, 0 ], [ -1, 0, 1, 1 ],
              [ -1, 0, 1, 0 ], [ -1, 0, 0, 1 ], [ 1, 0, 0, 0 ], [ 0, -1, 1, 1 ],
              [ 0, -1, 1, 0 ], [ 0, -1, 0, 1 ], [ 0, 1, 0, 0 ], [ 0, 0, 1, 0 ],
              [ 0, 0, 0, 1 ] ], norms := [ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 ],
          solutions := [ [ 1, 2, 11, 12 ], [ 3, 6, 8, 9 ], [ 4, 5, 7, 10 ] ] )
        gap> dec1:= Decreased( tbl, chars, emb.vectors{ emb.solutions[1] } );
        #I  Decreased : computation of 1st character failed
        fail
        gap> dec2:= Decreased( tbl, chars, emb.vectors{ emb.solutions[2] } );;
        gap> dec3:= Decreased( tbl, chars, emb.vectors{ emb.solutions[3] } );;

We got three embeddings, one of which did not fit to the requirements that the standard basis vectors are characters. The two remaining solutions lead to valid character tables for O′N, which differ only by a permutation of columns of rows.

        gap> TransformingPermutations(
        >        Concatenation( irreducibles, dec2.irreducibles ),
        >        Concatenation( irreducibles, dec3.irreducibles ) );
        rec( columns := (20,21), rows := (27,30)(28,29),
          group := <permutation group with 7 generators> )

In fact, the first of the two solutions corresponds to the character table of O′N that is stored in the GAP Character Table Library.

        gap> IsSubset( Irr( tbl ), irreducibles );
        true
        gap> IsSubset( Irr( tbl ), dec2.irreducibles );
        true

For further computations, we reset the changed `Info` level to zero.

        gap> SetInfoLevel( InfoCharacterTable, 0 );

(The whole computation took less than a second.)

## References

[Bre12]
  T. Breuer, The GAP Character Table Library, Version 1.2, `http://www.math.rwth-aachen.de/` ``~`Thomas.Breuer/` `ctbllib`, Mar 2012, GAP package.

File translated from TEX by TTH, version 3.59.
On 5 May 2012, 09:01.