71.3 Generic Character Tables

Generic character tables provide a means for writing down the character tables of all groups in a (usually infinite) series of similar groups, e.g., cyclic groups, or symmetric groups, or the general linear groups GL(2,q) where q ranges over certain prime powers.

Let { G_q || q Î I } be such a series, where I is an index set. The character table of one fixed member G_q could be computed using a function that takes q as only argument and constructs the table of G_q. It is, however, often desirable to compute not only the whole table but to access just one specific character, or to compute just one character value, without computing the whole character table.

For example, both the conjugacy classes and the irreducible characters of the symmetric group S_n are in bijection with the partitions of n. Thus for given n it makes sense to ask for the character corresponding to a particular partition, or just for its character value at a partition.

A generic character table in GAP allows one such local evaluations. In this sense, GAP can deal also with character tables that are too big to be computed and stored as a whole.

Currently the only operations for generic tables supported by GAP are the specialisation of the parameter q in order to compute the whole character table of G_q, and local evaluation (see ClassParameters for an example). It is not possible to compute, e.g., generic scalar products.

Currently, generic tables of the following groups --in alphabetical order-- are available in GAP. (A list of the names of generic tables known to GAP is LIBTABLE.GENERIC.firstnames.) We list the function calls needed to get a specialized table, the generic table itself can be accessed by calling CharacterTable with the first argument only; for example, CharacterTable( "Cyclic" ) yields the generic table of cyclic groups.

: CharacterTable( "Alternating", n ), the table of the alternating group on n letters,
: CharacterTable( "Cyclic", n ), the table of the cyclic group of order n,
: CharacterTable( "Dihedral", 2n ), the table of the dihedral group of order 2n,
: CharacterTable( "GL", 2, q ), the table of the general linear group GL (2,q), for a prime power q,
: CharacterTable( "GU", 3, q ), the table of the general unitary group GU (3,q), for a prime power q,
: CharacterTable( "P:Q", [ p, q ] ), the table of the Frobenius extension of the cyclic group of prime order p by a cyclic group of order q where q divides p-1,
: CharacterTable( "PSL", 2, q ), the table of the projective special linear group PSL (2,q), for a prime power q,
: CharacterTable( "SL", 2, q ), the table of the special linear group SL (2,q), for a prime power q,
: CharacterTable( "SU", 3, q ), the table of the special unitary group SU (3,q), for a prime power q,
: CharacterTable( "Suzuki", q ), the table of the Suzuki group Sz(q) = ²B₂(q), for q an odd power of 2,
: CharacterTable( "Symmetric", n ), the table of the symmetric group on n letters,
: CharacterTable( "WeylB", n ), the table of the Weyl group of type B_n,
: CharacterTable( "WeylD", n ), the table of the Weyl group of type D_n.

In addition to the above calls that really use generic tables, the following calls to CharacterTable are to some extent ``generic'' constructions. But note that no local evaluation is possible in these cases, as no generic table object exists in GAP that can be asked for local information.

: CharacterTable( "Quaternionic", 4n ), the table of the quaternionic (dicyclic) group of order 4n,
: CharacterTableWreathSymmetric( tbl, n ), the character table of the wreath product of the group whose table is tbl with the symmetric group on n letters (see CharacterTableWreathSymmetric).

CharacterTableSpecialized( generic_table, q ) F

For a record generic_table representing a generic character table, and a parameter value q, CharacterTableSpecialized returns a character table object computed by evaluating generic_table at q.

gap> c5:= CharacterTableSpecialized( CharacterTable( "Cyclic" ), 5 );
CharacterTable( "C5" )
gap> Display( c5 );
C5

     5  1  1  1  1  1

       1a 5a 5b 5c 5d
    5P 1a 1a 1a 1a 1a

X.1     1  1  1  1  1
X.2     1  A  B /B /A
X.3     1  B /A  A /B
X.4     1 /B  A /A  B
X.5     1 /A /B  B  A

A = E(5)
B = E(5)^2

(Also CharacterTable( "Cyclic", 5 ) could have been used to construct the above table.)

While the numbers of conjugacy classes for the members of a series of groups are usually not bounded, there is always a fixed finite number of types (equivalence classes) of conjugacy classes; very often the equivalence relation is isomorphism of the centralizers of the representatives.

For each type t of classes and a fixed q Î I, a parametrisation of the classes in t is a function that assigns to each conjugacy class of G_q in t a parameter by which it is uniquely determined. Thus the classes are indexed by pairs [t,p_t] consisting of a type t and a parameter p_t for that type.

For any generic table, there has to be a fixed number of types of irreducible characters of G_q, too. Like the classes, the characters of each type are parametrised.

In GAP, the parametrisations of classes and characters for tables computed from generic tables is stored using the attributes ClassParameters and CharacterParameters.

ClassParameters( tbl ) A

CharacterParameters( tbl ) A

are lists containing a parameter for each conjugacy class or irreducible character, respectively, of the character table tbl.

It depends on tbl what these parameters are, so there is no default to compute class and character parameters.

For example, the classes of symmetric groups can be parametrized by partitions, corresponding to the cycle structures of permutations. Character tables constructed from generic character tables (see Generic Character Tables) usually have class and character parameters stored.

If tbl is a p-modular Brauer table such that class parameters are stored in the underlying ordinary table (see OrdinaryCharacterTable) of tbl then ClassParameters returns the sublist of class parameters of the ordinary table, for p-regular classes.

gap> HasClassParameters( c5 );  HasCharacterParameters( c5 );
true
true
gap> ClassParameters( c5 );  CharacterParameters( c5 );
[ [ 1, 0 ], [ 1, 1 ], [ 1, 2 ], [ 1, 3 ], [ 1, 4 ] ]
[ [ 1, 0 ], [ 1, 1 ], [ 1, 2 ], [ 1, 3 ], [ 1, 4 ] ]
gap> ClassParameters( CharacterTable( "Symmetric", 3 ) );
[ [ 1, [ 1, 1, 1 ] ], [ 1, [ 2, 1 ] ], [ 1, [ 3 ] ] ]

Here are examples for local evaluation of generic character tables, first a character value of the cyclic group shown above, then a character value and a representative order of a symmetric group.

gap> CharacterTable( "Cyclic" ).irreducibles[1][1]( 5, 2, 3 );
E(5)
gap> tbl:= CharacterTable( "Symmetric" );;
gap> tbl.irreducibles[1][1]( 5, [ 3, 2 ], [ 2, 2, 1 ] );
1
gap> tbl.orders[1]( 5, [ 2, 1, 1, 1 ] );
2

Any generic table in GAP is represented by a record. The following components are supported for generic character table records.

centralizers: list of functions, one for each class type t, with arguments q and p_t, returning the centralizer order of the class [t,p_t],
charparam: list of functions, one for each character type t, with argument q, returning the list of character parameters of type t,
classparam: list of functions, one for each class type t, with argument q, returning the list of class parameters of type t,
classtext: list of functions, one for each class type t, with arguments q and p_t, returning a representative of the class with parameter [t,p_t],
domain: function of q returning true if q is a valid parameter, and false otherwise,
identifier: identifier string of the generic table,
irreducibles: list of list of functions, in row i and column j the function of three arguments, namely q and the parameters p_t and p_s of the class type t and the character type s,
isGenericTable: always true
libinfo: record with components firstname (Identifier value of the table) and othernames (list of other admissible names)
matrix: function of q returning the matrix of irreducibles of G_q,
orders: list of functions, one for each class type t, with arguments q and p_t, returning the representative order of elements of type t and parameter p_t,
powermap: list of functions, one for each class type t, each with three arguments q, p_t, and k, returning the pair [s,p_s] of type and parameter for the k-th power of the class with parameter [t,p_t],
size: function of q returning the order of G_q,
specializedname: function of q returning the Identifier value of the table of G_q,
text: string informing about the generic table

In the specialized table, the ClassParameters and CharacterParameters values are the lists of parameters [t,p_t] of classes and characters, respectively.

If the matrix component is present then its value implements a method to compute the complete table of small members G_q more efficiently than via local evaluation; this method will be called when the generic table is used to compute the whole character table for a given q (see CharacterTableSpecialized).

[Top] [Previous] [Up] [Next] [Index]

GAP 4 manual
February 2000