# Constructing the Irreducible Characters of J4 with GAP

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

### July 13th, 1999

We assume that the "table head" of the ordinary character table of the sporadic simple Janko group J4 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 J4, which is 66. For the sake of simplicity, we take the table head of the character table contained in the GAP Character Table Library [Bre04].

        gap> LoadPackage( "ctbllib" );
        true
        gap> tbl:= CharacterTable( "J4" );
        CharacterTable( "J4" )
        gap> NrConjugacyClasses( tbl );
        62

Besides the table head with the trivial character, we assume that we know a nontrivial irreducible character of smallest degree -which is 1 333- and the nontrivial permutation character of smallest degree; the latter character corresponds to the action on the cosets of a maximal subgroup of type 211.M24 in J4.

        gap> irreducibles:= Irr( tbl ){ [ 1, 2 ] };
        [ Character( CharacterTable( "J4" ), [ 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, 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, 1,
              1 ] ), Character( CharacterTable( "J4" ),
            [ 1333, 53, -11, 10, -11, 5, -3, 3, -10, 2, -2, E(7)+E(7)^2+E(7)^4,
              E(7)^3+E(7)^5+E(7)^6, 1, -3, 1, 3, -1, 2, 2, -2, 2, 0,
              -E(7)-E(7)^2-E(7)^4, -E(7)^3-E(7)^5-E(7)^6, E(7)+E(7)^2+E(7)^4,
              E(7)^3+E(7)^5+E(7)^6, 0, -1, -1, -1, E(7)+E(7)^2+E(7)^4,
              E(7)^3+E(7)^5+E(7)^6, -2, 0, -1, 0, 0, -E(7)-E(7)^2-E(7)^4,
              -E(7)^3-E(7)^5-E(7)^6, -1, 0, 0, 0, 0, -1, -1, E(7)+E(7)^2+E(7)^4,
              E(7)^3+E(7)^5+E(7)^6, 1, 1, 1, 1, 1, -E(7)-E(7)^2-E(7)^4,
              -E(7)^3-E(7)^5-E(7)^6, 0, 0, 0, 0, 1, 1 ] ) ]
        gap> max:= CharacterTable( Maxes( tbl )[1] );;
        gap> pi:= TrivialCharacter( max ) ^ tbl;
        Character( CharacterTable( "J4" ), [ 173067389, 52349, 8317, 737, 957, 253,
          141, 14, 77, 41, 37, 5, 5, 5, 13, 13, 14, 2, 0, 11, 9, 13, 3, 3, 3, 1, 1,
          2, 1, 2, 2, 2, 2, 0, 1, 2, 1, 1, 1, 1, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
          0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ] )

The first new irreducible character is of course the complex conjugate of the degree 1 333 character shown above.

        gap> AddSet( irreducibles, ComplexConjugate( irreducibles[2] ) );

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 J4, and symmetrizations of the known irreducibles. Note that these two computations are possible only because we know the power maps of J4.

        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 );
        220
        gap> chars:= ReducedCharacters( tbl, irreducibles, chars );;
        #I  ReducedCharacters: irreducible character of degree 887778 found
        #I  ReducedCharacters: irreducible character of degree 889111 found
        #I  ReducedCharacters: irreducible character of degree 887778 found
        #I  ReducedCharacters: irreducible character of degree 393877506 found
        #I  ReducedCharacters: irreducible character of degree 789530568 found
        gap> Length( chars.irreducibles );
        5
        gap> Length( chars.remainders );
        206

We found five new irreducibles. For later use, we store those irreducibles for which no symmetrizations were used yet.

        gap> newirr:= chars.irreducibles;;

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: 4 irreducibles found
        gap> List( lll.irreducibles, Degree );
        [ 1981808640, 1981808640, 1981808640, 2267824128 ]

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

        gap> Append( 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 );
        50
        gap> lll.norms;
        [ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 4, 2, 5, 4, 5, 4, 4, 5, 3,
          6, 6, 8, 4, 6, 6, 4, 8, 8, 7, 9, 7, 6, 7, 7, 8, 6, 9, 7, 7, 4, 6, 7, 8, 5 ]

Together with the 13 known irreducibles, the basis of length 49 spans the whole 62 dimensional space of irreducibles of J4. 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 );;

We use the new irreducibles to repeat the process of generating and reducing characters.

        gap> Append( irreducibles, newirr );
        gap> Length( irreducibles );
        12
        gap> sym2:= Symmetrizations( tbl, newirr, 2 );;
        gap> sym3:= Symmetrizations( tbl, newirr, 3 );;
        gap> newchars:= Concatenation( sym2, sym3 );;
        gap> newchars:= ReducedCharacters( tbl, irreducibles, newchars );;
        gap> chars:= Concatenation( chars.remainders, newchars.remainders );;
        gap> lll:= LLL( tbl, chars );;
        #I  LLL: 35 irreducibles found
        gap> lll.norms;
        [ 2, 2, 2, 2, 2, 2, 2, 3, 2, 2, 2, 2, 2, 2, 2 ]
        gap> Append( irreducibles, lll.irreducibles );
        gap> Length( irreducibles );
        47

Most of the virtual characters in `lll.remainders` have norm 2, and GAP has a function that inspects lattices geneated by norm 2 vectors for the occurrence of sublattices of types D4 and D5; in the latter case, the underlying irreducible characters can always be deduced, in the former case this is possible at least in some cases.

        gap> dn:= DnLatticeIterative( tbl, lll );;
        #I  ReducedClassFunctions: irreducible character of degree 786127419 found
        #I  ReducedClassFunctions: irreducible character of degree 786127419 found
        #I  ReducedClassFunctions: irreducible character of degree 1579061136 found
        #I  ReducedClassFunctions: irreducible character of degree 2727495848 found
        #I  ReducedClassFunctions: irreducible character of degree 3403149 found
        #I  ReducedClassFunctions: irreducible character of degree 786127419 found
        #I  ReducedClassFunctions: irreducible character of degree 230279749 found
        #I  ReducedClassFunctions: irreducible character of degree 1842237992 found
        gap> Length( dn.irreducibles );
        9
        gap> Append( irreducibles, dn.irreducibles );
        gap> Length( irreducibles );
        56
        gap> dn.norms;
        [ 2, 2, 2, 2, 2, 2 ]

Now 6 irreducible characters are missing, and we know a 6-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.

        gap> gram:= MatScalarProducts( tbl, dn.remainders, dn.remainders );
        [ [ 2, 0, 0, 0, 0, 0 ], [ 0, 2, 0, 0, -1, 0 ], [ 0, 0, 2, 0, -1, 0 ],
          [ 0, 0, 0, 2, 0, 0 ], [ 0, -1, -1, 0, 2, 1 ], [ 0, 0, 0, 0, 1, 2 ] ]
        gap> emb:= OrthogonalEmbeddingsSpecialDimension( tbl, dn.remainders, gram, 6 );;
        #I  Decreased : computation of 2nd character failed
        gap> Length( emb.irreducibles );
        2
        gap> Append( irreducibles, emb.irreducibles );

A four dimensional lattice is left, and the possible embeddings do not determine uniquely the irreducible characters. So we compute all possible embeddings, and inspect the different cases separately.

        gap> chars:= emb.remainders;;
        gap> gram:= MatScalarProducts( tbl, chars, chars );
        [ [ 2, 0, -1, 0 ], [ 0, 2, -1, 0 ], [ -1, -1, 2, 1 ], [ 0, 0, 1, 2 ] ]
        gap> emb:= OrthogonalEmbeddings( gram, 4 );
        rec( vectors := [ [ -1, -1, 1, 0 ], [ -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, 1 ],
              [ 0, 0, 0, 1 ] ], norms := [ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 ],
          solutions := [ [ 1, 2, 11, 12 ], [ 3, 5, 8, 10 ], [ 4, 6, 7, 9 ] ] )

The `solution` component of the result tells us that there are three solution matrices, each given by a list of positions in the `vectors` component. The irreducible characters can now be extracted using `Decreased`.

        gap> dec1:= Decreased( tbl, chars, emb.vectors{ emb.solutions[1] } );
        #I  Decreased : computation of 1st character failed
        fail

This means that the first solution does not correspond to irreducible characters.

        gap> dec2:= Decreased( tbl, chars, emb.vectors{ emb.solutions[2] } );;
        gap> Length( dec2.irreducibles );
        4
        gap> dec3:= Decreased( tbl, chars, emb.vectors{ emb.solutions[3] } );;
        gap> Length( dec3.irreducibles );
        4
        gap> Intersection( dec2.irreducibles, dec3.irreducibles );
        [  ]

This means that we are left with two possibilities to complete the irreducibles of J4. The computation of orthogonal embeddings was independent of the table head of J4, thus the power maps may provide information to exclude one of the possibilities. For example, we can check whether the symmetrizations of the candidates can be decomposed into irreducibles. This way the vectors in `dec2.irreducibles` can be proved not to be characters.

        gap> sym2:= Symmetrizations( tbl, dec2.irreducibles, 2 );;
        gap> ScalarProduct( dec2.irreducibles[1], sym2[1] );
        7998193/2

Alternatively, one could also try to recompute the second power map from the candidates for irreducibles together with the element orders. For the possibility ruled out, we get a unique power map that is different from the one stored on the table.

        gap> irr:= Concatenation( irreducibles, dec2.irreducibles );;
        gap> pow:= PossiblePowerMaps( tbl, 2, rec( chars:= irr, subchars:= irr ) );
        #I  PossiblePowerMaps: 2nd power map initialized; congruences, kernels and
        #I    maps for smaller primes considered,
        #I    the current indeterminateness is 839808.
        #I  PossiblePowerMaps: no test of decomposability allowed
        #I  PossiblePowerMaps: test scalar products of minus-characters
        #I  PowerMapsAllowedBySymmetrizations: no character with indeterminateness
        #I    between 1 and 100000 significant now
        #I  PossiblePowerMaps: 1 solution(s)
        [ [ 1, 1, 1, 4, 2, 2, 3, 8, 4, 4, 4, 12, 13, 5, 6, 6, 8, 8, 19, 20, 10, 10,
              11, 12, 13, 12, 13, 28, 16, 17, 17, 32, 33, 19, 20, 36, 22, 22, 26, 27,
              41, 28, 43, 44, 45, 46, 47, 48, 49, 51, 52, 50, 30, 31, 32, 33, 57, 58,
              59, 34, 46, 47 ] ]
        gap> pow[1] = PowerMap( tbl, 2 );
        false

Thus we have found the irreducible characters. Finally, let us check whether they coincide with the ones that are stored on the GAP library table.

        gap> irr:= Concatenation( irreducibles, dec3.irreducibles );;
        gap> Set( irr ) = Set( Irr( tbl ) );
        true

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

        gap> SetInfoLevel( InfoCharacterTable, 0 );

(The whole computation took only a few minutes.)

## References

[Bre04]
  Thomas Breuer, Manual for the GAP Character Table Library, Version 1.1, Lehrstuhl D für Mathematik, Rheinisch Westfälische Technische Hochschule, Aachen, Germany, 2004.

File translated from TEX by TTH, version 3.55.
On 31 Mar 2004, 10:53.