Goto Chapter: Top 1 2 3 4 5 6 7 8 Bib Ind

1 Maintenance Issues for the GAP Character Table Library

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.

1.1 Disproving Possible Character Tables (November 2006)

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 [GJ86]. Another such example is described in Section 2.4-13. 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.

1.1-1 A Perfect Pseudo Character Table (November 2006)

(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 "P41/G1/L1/V4/ext2" was not correct. The problem occurs already in the microfiches that are attached to [HP89].

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 data/ctoholpl.tbl of the GAP Character Table Library.

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 );;


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

gap> Length( LinearCharacters( tbl ) );
1
gap> IsPerfectCharacterTable( tbl );
true


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.

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
> fi;


The GAP Library of Perfect Groups contains representatives of the four isomorphism types of perfect groups of order |G| = 64512.

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 ]


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.

gap> tbls:= List( grps, CharacterTable );;
gap> List( tbls,
>          x -> TransformingPermutationsCharacterTables( x, tbl ) );
[ fail, fail, fail, fail ]


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

gap> List( tbls,
>          t -> TransformingPermutations( Irr( t ), Irr( tbl ) ) );
[ fail, fail, fail, fail ]


Let us look closer at the tables in question. Each character table of a perfect group of order 64512 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.

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 ]


(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.

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 ]


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

Note that these microfiches contain two tables of order 64512, and there were three tables in the GAP Character Table Library that contain origin: Hanrath library in their InfoText value. Besides the incorrect table, these library tables are the character tables of the groups PerfectGroup( 64512, 1 ) and PerfectGroup( 64512, 3 ), respectively. (The matrices of irreducible characters of these tables are equivalent.)

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


Since version 1.2 of the GAP Character Table Library, the character table with the Identifier value "P41/G1/L1/V4/ext2" corresponds to the group PerfectGroup( 64512, 4 ). The choice of this group was somewhat arbitrary since the vector system V4 seems to be not defined in [HP89]; anyhow, this group and the remaining perfect group, PerfectGroup( 64512, 2 ), have equivalent matrices of irreducibles.

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


1.2 Some finite factor groups of perfect space groups (February 2014)

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 GroupInfoForCharacterTable. For a long time, this was not successful in the case of 16 character tables that had been computed by W. Hanrath (see Section "Ordinary and Brauer Tables in the GAP Character Table Library" in the CTblLib manual).

Using the information from [HP89], it is straightforward to construct such groups as factor groups of infinite groups. Since version 1.2.3 of the CTblLib package, calling GroupInfoForCharacterTable for the 16 library tables in question yields nonempty lists and thus allows one to access the results of these constructions, via the function CTblLib.FactorGroupOfPerfectSpaceGroup.

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 generatorsOfPerfectSpaceGroup defined below to the generators stored in the attribute GeneratorsOfGroup of the group returned by CTblLib.FactorGroupOfPerfectSpaceGroup.

1.2-1 Constructing the space groups in question

In [HP89], a space group S is described as a subgroup { M(g, t); g ∈ P, t ∈ T } of GL(d+1, ℤ), where

M(g, t)  =
 g 0 V(g)+t 1

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 ∈ GL(d, ℤ) to the zero vector, and M(T):= { M(I, t); t ∈ 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, ..., g_k, T is given by a -basis B = { b_1, b_2, ..., b_d } of T, and V is given by the vectors V(g_1), V(g_2), ..., 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:

 g_1 0 V(g_1) 1
 g_2 0 V(g_2) 1
, ...,
 g_k 0 V(g_k) 1
 I 0 b_1 1
.

These generators are returned by the function generatorsOfPerfectSpaceGroup, when the inputs are [ g_1, g_2, ..., g_k ], [ V(g_1), V(g_2), ..., V(g_k) ], and b_1.

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;
>     return result;
> end;;


1.2-2 Constructing the factor groups in question

The space group S acts on ℤ^d, via v ⋅ 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 multiplicationModulo when this is called with argument n.

gap> multiplicationModulo:= n -> function( v, g )
>        return List( v * g, x -> x mod n ); end;;


In some of the examples, the representation of P given in [HP89] is the action on the factor of a permutation module modulo its trivial submodule. For that, we provide the function deletedPermutationMat, cf. [HP89, p. 269].

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;;


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 CTblLib.FactorGroupOfPerfectSpaceGroup.

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;;


1.2-3 Examples with point group A_5

There are two examples with d = 5. The generators of the point group are as follows (see [HP89, p. 272]).

gap> a:= deletedPermutationMat( (1,3)(2,4), 6 );;
gap> b:= deletedPermutationMat( (1,2,3)(4,5,6), 6 );;


In both cases, the vector system is V_2.

gap> v:= [ [ 2, 2, 0, 0, 1 ], 0 * b[1] ];;


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

gap> t:= [ 2, 0, 0, 0, 0 ];;


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

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


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

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 ] ];;


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.

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 ] ]


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

gap> vbas:= vbas * 2;
[ [ 3, 2, 4, 3, -2 ], [ 0, 0, 0, 0, 0 ] ]
gap> t:= 2 * t;
[ 4, 0, 0, 0, 0 ]


The library character table with identifier "P1/G2/L2/V2/ext4" 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.

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


1.2-4 Examples with point group L_3(2)

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 [HP89, p. 290]).

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 ] ];;


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 "P11/G1/L1/V1/ext4" 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.

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


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

The library character table with identifier "P11/G1/L1/V2/ext4" 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.

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


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

The library character table with identifier "P11/G1/L1/V3/ext4" 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.

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


The generators of the point group for the fourth example are as follows (see [HP89, p. 293]).

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 ] ];;


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 "P11/G4/L1/V1/ext3" 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.

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


1.2-5 Example with point group SL_2(7)

There is one example with d = 8. The generators of the point group are as follows (see [HP89, p. 295]).

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 ] ];;


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 [HP89, p. 269].

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 ] ];;


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

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 ) );;


The library character table with identifier "P12/G1/L2/V1/ext2" 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.

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


1.2-6 Example with point group 2^3.L_3(2)

There is one example with d = 7. The generators of the point group are as follows (see [HP89, p. 297]).

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 ] );;


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 [HP89, p. 269].

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 ] ];;


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

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 ) );;


The library character table with identifier "P13/G1/L2/V1/ext2" 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.

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


1.2-7 Examples with point group A_6

There are two examples with d = 10. In both cases, the generators of the point group are as follows (see [HP89, p. 307]).

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 ] ];;


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.

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 ] ];;


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

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 ) );;


The library character table with identifier "P21/G3/L2/V1/ext2" 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.

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


The library character table with identifier "P21/G3/L5/V1/ext2" 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.

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


1.2-8 Examples with point group L_2(8)

There are two examples with d = 7. In both cases, the generators of the point group are as follows (see [HP89, p. 327]).

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] ];;


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

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 ];;


The library character table with identifier "P41/G1/L1/V3/ext3" 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.

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


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

gap> t:= [ 6, 0, 0, 0, 0, 0, 0 ];;


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

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


1.2-9 Example with point group M_11

There is one example with d = 10. The generators of the point group are as follows (see [HP89, p. 334]).

gap> a:= deletedPermutationMat( (1,9)(3,5)(7,11)(8,10), 11 );;
gap> b:= deletedPermutationMat( (1,4,3,2)(5,8,7,6), 11 );;


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

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 ];;


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

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


1.2-10 Example with point group U_3(3)

There is one example with d = 7. The generators of the point group are as follows (see [HP89, p. 335]).

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 ] ];;


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

gap> v:= [ [ 2, 1, 0, 0, 2, 1, 0 ],
>          0 * b[1] ];;
gap> t:= [ 3, 0, 0, 0, 0, 0, 0 ];;


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

gap> sgens:= generatorsOfPerfectSpaceGroup( [ a, b ], v, t );;
gap> g:= Group( sgens );;
gap> fun:= multiplicationModulo( 9 );;


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

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


1.2-11 Examples with point group U_4(2)

There are two examples with d = 6. In both cases, the generators of the point group are as follows (see [HP89, p. 336]).

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 ] ];;


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

gap> v:= List( [ 1, 2 ], i -> 0 * a[1] );;
gap> t:= [ 1, 0, 0, 0, 0, 0 ];;


The library character table with identifier "P50/G1/L1/V1/ext3" 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.

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


The library character table with identifier "P50/G1/L1/V1/ext4" 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.

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


1.2-12 A remark on one of the example groups

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

gap> 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( last, x -> x[1] ) = DivisorsInt( 60 );
true


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 [NR14].

1.3 Generality problems (December 2004/October 2015)

The term "generality problem" 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 [JLPW95, p. x].

Section 1.3-1 shows how to detect generality problems and lists the known generality problems, and Section 1.3-2 gives an example that actually arose.

1.3-1 Listing possible generality problems

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 action of table automorphisms of tbl (via mapping the images of the class fusion). The case of broken symmetries occurs if and only if this orbit splits into several orbits under the table automorphisms of mtbl (via permuting the preimages).

gap> BrokenSymmetries:= function( ordtbl, modtbl )
>     local taut, maut, triv, fus;
>     taut:= AutomorphismsOfTable( ordtbl );
>     maut:= AutomorphismsOfTable( modtbl );
>     triv:= TrivialSubgroup( taut );
>     fus:= GetFusionMap( modtbl, ordtbl );
>     return Length( OrbitFusions( maut, fus, triv ) )
>            < Length( OrbitFusions( triv, fus, taut ) );
> end;;


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.

gap> PrimesOfGeneralityProblems:= function( ordtbl )
>     local consider, p, modtbl, taut, triv, admiss, fusion, maut,
>           allfusions, reps;
>     # Find the primes for which symmetries are broken.
>     consider:= [];
>     for p in Set( Factors( Size( ordtbl ) ) ) do
>       modtbl:= ordtbl mod p;
>       if modtbl <> fail and BrokenSymmetries( ordtbl, modtbl ) then
>       fi;
>     od;
>     # Compute the choices and detect generality problems.
>     taut:= AutomorphismsOfTable( ordtbl );
>     triv:= TrivialSubgroup( taut );
>     for p in consider do
>       modtbl:= ordtbl mod p;
>       fusion:= GetFusionMap( modtbl, ordtbl );
>       maut:= AutomorphismsOfTable( modtbl );
>       allfusions:= OrbitFusions( maut, fusion, taut );
>       reps:= RepresentativesFusions( maut, allfusions, admiss );
>       if Length( reps ) = 1 then
>         # Reduce the symmetries that are still available.
>                              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;;


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 ± sqrt{-2} on the classes 8a and 8b, and the values ± sqrt{-3} on the classes 6b and 6c. When we define which of the two classes of element order 8 is called 8a, this will also define which class is called 6b. 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.

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> Print( AutomorphismsOfTable( t ) );
Group( [ (11,12), ( 9,10) ] )
gap> Print( 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 );
[  ]


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 [JLPW95, p. x], the unique irreducible 11-modular Brauer character of degree 7 distinguished 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.

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)^1\
4-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


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.

gap> PrimesOfGeneralityProblems( t );
[ 7, 11, 19 ]


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



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 ) );
[ [                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.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.B,            [ 17, 23 ] ],
[               2.F4(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 ] ],
[               2.Sz(8),          [ 2, 5, 13 ] ],
[            2^2.2E6(2),            [ 13, 19 ] ],
[         2^2.L3(4).2^2,              [ 5, 7 ] ],
[         2^2.L3(4).2_1,              [ 5, 7 ] ],
[             2^2.Sz(8),          [ 2, 5, 13 ] ],
[                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(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,  [ 5, 7, 11, 19, 31 ] ],
[               3.Suz.2,          [ 2, 3, 13 ] ],
[                 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 ] ],
[                   A12,              [ 2, 3 ] ],
[                   A14,           [ 2, 5, 7 ] ],
[                   A17,              [ 2, 7 ] ],
[                     B,    [ 13, 17, 23, 31 ] ],
[                   F3+,        [ 17, 23, 29 ] ],
[                 F3+.2,        [ 17, 23, 29 ] ],
[                Fi22.2,            [ 11, 13 ] ],
[                  Fi23,            [ 17, 23 ] ],
[                    HN,      [ 2, 3, 11, 19 ] ],
[                  HN.2,      [ 5, 7, 11, 19 ] ],
[                    He,             [ 5, 17 ] ],
[                  He.2,          [ 5, 7, 17 ] ],
[                    J1,         [ 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,  [ 5, 7, 11, 19, 31 ] ],
[                    Ru,      [ 5, 7, 13, 29 ] ],
[                 Suz.2,             [ 3, 13 ] ] ]


Note that this list may become longer as new Brauer tables become available.

1.3-2 A generality problem concerning the group J_3 (April 2015)

In March 2015, 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 [JLPW95, p. 219], the Brauer character value on the class 17A is b_17. The Atlas of Group Representations [ATLASa] 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.

gap> t:= CharacterTable( "J3" );;
gap> m:= t mod 19;;
gap> cand:= Filtered( Irr( m ), x -> x[1] = 110 );;
gap> Length( cand );
1
gap> 17a:= Position( OrdersClassRepresentatives( m ), 17 );
18
gap> Quadratic( cand[1][ 17a ] );
rec( ATLAS := "b17", a := -1, b := 1, d := 2,
display := "(-1+Sqrt(17))/2", root := 17 )
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 )


How shall we resolve this inconsistency, by replacing the straight line program or by swapping the classes 17A and 17B 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 [JLPW95], that can be used to define which of the two classes of element order 17 shall be called 17A; a + sign in the last column of the table indicates that the representation is available in the Atlas of Group Representations.

 p φ(1) φ(17A) φ(17B) Atlas? 2 78 1-b_17 2+b_17 + 2 80 3-b_17 4+b_17 + 2 244 b_17-2 -3-b_17 + 2 966 r_17-3 -3-r_17 + 19 110 b_17 -1-b_17 + 19 214 1-b_17 2+b_17 + 19 706 -b_17 1+b_17 + 19 1214 -1+b_17 -2-b_17 -

Note that the irreducible Brauer characters in characteristic 3 and 5 that distinguish the two classes 17A and 17B 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.

gap> table:= [];
gap> for data 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 ] );
>                            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 ] ]


We see that the problem is an inconsistency between the 2-modular and the 19-modular character table of J_3 in [JLPW95]. 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 equivelently, the corresponding Brauer trees— have been described in [HL89], 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 [JLPW95] have been put together, and had not been detected until now.

Remarks:

• 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 8.6-1 and Section 8.6-3.

• 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 http://www.math.rwth-aachen.de/~Thomas.Breuer/ctbllib/dec/tex/J3/index.html.

• 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.

Goto Chapter: Top 1 2 3 4 5 6 7 8 Bib Ind

generated by GAPDoc2HTML