50 Generic Character Tables

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.

Subsections

  1. More about Generic Character Tables
  2. Examples of Generic Character Tables
  3. CharTableSpecialized

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

Let {Gq|q∈ I}, where I is an index set, be such a series. The table of a member Gq could be computed using a program for this series which takes q as parameter, and constructs the table. It is, however, desirable to compute not only the whole table but to get a single character or just one character value without computation the table. E.g. both conjugacy classes and irreducible characters of the symmetric group Sn 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, and its value at a partition:

    gap> t:= CharTable( "Symmetric" );;
    gap> t.irreducibles[1][1]( 5, [ 3, 2 ], [ 2, 2, 1 ] );
    1  # a character value of S5
    gap> t.orders[1]( 5, [ 2, 1, 1, 1 ] );
    2  # a representative order in S5

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 Gq 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 Gq in t a parameter by which it is uniquely determined. Thus the classes are indexed by pairs (t,pt) for a type t and a parameter pt for that type.

There has to be a fixed number of types of irreducibles characters of Gq, 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 pt; in GAP3, however, they are represented by lists of functions in q and a class parameter where each function represents a type of classes. The value of a powermap at a particular class is a pair consisting of type and parameter that specifies the image class.

The values of the irreducible characters of Gq can be represented by functions in q, class type and parameter, character type and parameter; in GAP3, they are represented by lists of lists of functions, each list of functions representing the characters of a type, the function (in q, character parameters and class parameters) representing the classes of a type in these characters.

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 Gq

domain:

function that returns true if its argument is a valid q for Gq in the series

wholetable:

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

The table of Gq can be constructed by specializing q and evaluating the functions in the generic table (see CharTableSpecialized and the examples given in Examples of Generic Character Tables).

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

50.2 Examples of Generic Character Tables

1. The generic table of the cyclic group:

For the cyclic group Cq = ⟨ x ⟩ of order q, there is one type of classes. The class parameters are integers k∈{0,...,q-1}, the class of the parameter k consists of the group element xk. Group order and centralizer orders are the identity function q → q, independent of the parameter k.

The representative order function maps (q,k) to q/gcd(q,k), the order of xk in Cq; the p-th powermap is the function (q,k,p) → [1,(kp mod q)].

There is one type of characters with parameters l∈{0,...,q-1}; for eq a primitive complex q-th root of unity, the character values are χl(xk) = eqkl.

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 t1, t2, t3, t4 of classes according to the

rational canonical form of the elements::

t1 scalar matrices,
t2 nonscalar diagonal matrices,
t3 companion matrices of (X-ρ)2 for elements ρ∈ Fq* and
t4 companion matrices of irreducible polynomials of degree 2 over Fq.

The sets of class parameters of the types are in bijection with
Fq* for t1 and t3, {{ρ,τ}; ρ, τ∈ Fq*, ρ≠τ} for t2 and {{ε,εq}; ε∈ Fq2\ Fq} for t4.

The centralizer order functions are q → (q2-1)(q2-q) for type t1, q → (q-1)2 for type t2, q → q(q-1) for type t3 and q → q2-1 for type t4.

The representative order function of t1 maps (q,ρ) to the order of ρ in Fq, that of t2 maps (q,{ρ,τ}) to the least common multiple of the orders of ρ and τ.

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 )

50.3 CharTableSpecialized

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 := [  ] )

Previous Up Next
Index

gap3-jm
19 Feb 2018