This chapter informs about the conception of generic character tables (see More about Generic Character Tables), it gives some examples of generic tables (see Examples of Generic Character Tables), and introduces the specialization function (see CharTableSpecialized).

The generic tables that are actually available in the **GAP3** group
collection are listed in CharTable, see also Contents of the Table
Libraries.

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. the cyclic groups, the symmetric groups or the general linear groups
* GL(2,q)*.

Let *{G _{q}|q∈ I}*, where

gap> t:= CharTable( "Symmetric" );; gap> t.irreducibles[1][1]( 5, [ 3, 2 ], [ 2, 2, 1 ] ); 1 # a character value ofSgap> t.orders[1]( 5, [ 2, 1, 1, 1 ] ); 2 # a representative order in_{5}S_{5}

**Generic table** in **GAP3** means that such local evaluation is possible, so
**GAP3** can also deal with tables that are too big to be computed as a
whole. In some cases there are methods to compute the complete table of
small members *G _{q}* faster than local evaluation. If such an algorithm
is part of the generic table, it will be used when the generic table is
used to compute the whole table (see CharTableSpecialized).

While the numbers of conjugacy classes for the series are usually not
bounded, there is a fixed finite number of **types** (equivalence classes)
of conjugacy classes; very often the equivalence relation is isomorphism
of the centralizer 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

There has to be a fixed number of types of irreducibles characters of
*G _{q}*, too. Like the classes, the characters of each type are
parametrised.

In **GAP3**, the parametrisations of classes and characters of the generic
table is given by the record fields `classparam`

and `charparam`

; they
are both lists of functions, each function representing the
parametrisation of a type. In the specialized table, the field
`classparam`

contains the lists of class parameters, the character
parameters are stored in the field `charparam`

of the `irredinfo`

records
(see Character Table Records).

The centralizer orders, representative orders and all powermaps of the
generic character table can be represented by functions in *q*, *t* and
*p _{t}*; in

The values of the irreducible characters of *G _{q}* can be represented by
functions in

Any generic table is a record like an ordinary character table (see Character Table Records). There are some fields which are used for generic tables only:

`isGenericTable`

:

always`true`

`specializedname`

:

function that maps*q*to the name of the table of*G*_{q}

`domain`

:

function that returns`true`

if its argument is a valid*q*for*G*in the series_{q}

`wholetable`

:

function to construct the whole table, more efficient than the local evaluation for this purpose

The table of *G _{q}* can be constructed by specializing

The available generic tables are listed in Contents of the Table Libraries and CharTable.

1. The generic table of the cyclic group:

For the cyclic group *C _{q} = ⟨ x ⟩* of order

The representative order function maps *(q,k)* to *q/*gcd*(q,k)*,
the order of *x ^{k}* in

There is one type of characters with parameters *l∈{0,...,q-1}*;
for *e _{q}* a primitive complex

The library file contains the following generic table:

rec(name:="Cyclic", specializedname:=(q->ConcatenationString("C",String(q))), order:=(n->n), text:="generic character table for cyclic groups", centralizers:=[function(n,k) return n;end], classparam:=[(n->[0..n-1])], charparam:=[(n->[0..n-1])], powermap:=[function(n,k,pow) return [1,k*pow mod n];end], orders:=[function(n,k) return n/Gcd(n,k);end], irreducibles:=[[function(n,k,l) return E(n)^(k*l);end]], domain:=(n->IsInt(n) and n>0), libinfo:=rec(firstname:="Cyclic",othernames:=[]), isGenericTable:=true);

2. The generic table of the general linear group *\rmGL(2,q)*:

We have four types *t _{1}, t_{2}, t_{3}, t_{4}* of classes according to the

- rational canonical form of the elements::

*t*scalar matrices,_{1}

*t*nonscalar diagonal matrices,_{2}

*t*companion matrices of_{3}*(X-ρ)*for elements^{2}*ρ∈ F*and_{q}^{*}

*t*companion matrices of irreducible polynomials of degree 2 over_{4}*F*._{q}

The sets of class parameters of the types are in bijection with

*F _{q}^{*}* for

The centralizer order functions are *q → (q ^{2}-1)(q^{2}-q)* for type

The representative order function of *t _{1}* maps

The file contains something similar to this table:

rec(name:="GL2", specializedname:=(q->ConcatenationString("GL(2,",String(q),")")), order:= ( q -> (q^2-1)*(q^2-q) ), text:= "generic character table of GL(2,q),\ see Robert Steinberg: The Representations of Gl(3,q), Gl(4,q),\ PGL(3,q) and PGL(4,q), Canad. J. Math. 3 (1951)", classparam:= [ ( q -> [0..q-2] ), ( q -> [0..q-2] ), ( q -> Combinations( [0..q-2], 2 ) ), ( q -> Filtered( [1..q^2-2], x -> not (x mod (q+1) = 0) and (x mod (q^2-1)) < (x*q mod (q^2-1)) ))], charparam:= [ ( q -> [0..q-2] ), ( q -> [0..q-2] ), ( q -> Combinations( [0..q-2], 2 ) ), ( q -> Filtered( [1..q^2-2], x -> not (x mod (q+1) = 0) and (x mod (q^2-1)) < (x*q mod (q^2-1)) ))], centralizers := [ function( q, k ) return (q^2-1) * (q^2-q); end, function( q, k ) return q^2-q; end, function( q, k ) return (q-1)^2; end, function( q, k ) return q^2-1; end], orders:= [ function( q, k ) return (q-1)/Gcd( q-1, k ); end, ..., ..., ... ], classtext:= [ ..., ..., ..., ... ], powermap:= [ function( q, k, pow ) return [1, (k*pow) mod (q-1)]; end, ..., ..., ... ], irreducibles := [[ function( q, k, l ) return E(q-1)^(2*k*l); end, function( q, k, l ) return E(q-1)^(2*k*l); end, ..., function( q, k, l ) return E(q-1)^(k*l); end ], [ ..., ..., ..., ... ], [ ..., ..., ..., ... ], [ ..., ..., ..., ... ]], domain := ( q->IsInt(q) and q>1 and Length(Set(FactorsInt(q)))=1 ), isGenericTable := true )

`CharTableSpecialized( `

`generic\_table`, `q` )

returns a character table which is computed by evaluating the generic
character table `generic\_table` at the parameter `q`.

gap> t:= CharTableSpecialized( CharTable( "Cyclic" ), 5 );; gap> PrintCharTable( t ); rec( identifier := "C5", name := "C5", size := 5, order := 5, centralizers := [ 5, 5, 5, 5, 5 ], orders := [ 1, 5, 5, 5, 5 ], powermap := [ ,,,, [ 1, 1, 1, 1, 1 ] ], irreducibles := [ [ 1, 1, 1, 1, 1 ], [ 1, E(5), E(5)^2, E(5)^3, E(5)^4 ], [ 1, E(5)^2, E(5)^4, E(5), E(5)^3 ], [ 1, E(5)^3, E(5), E(5)^4, E(5)^2 ], [ 1, E(5)^4, E(5)^3, E(5)^2, E(5) ] ], classparam := [ [ 1, 0 ], [ 1, 1 ], [ 1, 2 ], [ 1, 3 ], [ 1, 4 ] ], irredinfo := [ rec( charparam := [ 1, 0 ] ), rec( charparam := [ 1, 1 ] ), rec( charparam := [ 1, 2 ] ), rec( charparam := [ 1, 3 ] ), rec( charparam := [ 1, 4 ] ) ], text := "computed using generic character table for cyclic groups"\ , classes := [ 1, 1, 1, 1, 1 ], operations := CharTableOps, fusions := [ ], fusionsource := [ ], projections := [ ], projectionsource := [ ] )

gap3-jm

11 Mar 2019