GAP (CTblLib) - Chapter 4: Contents of the GAP Character Table Library

Goto Chapter: Top 1 2 3 4 5 6 Bib Ind
[Top of Book] [Contents] [Previous Chapter] [Next Chapter]

4 Contents of the GAP Character Table Library
4.1 Ordinary and Brauer Tables in the GAP Character Table Library
4.1-1 Ordinary Character Tables
4.1-2 Brauer Tables
4.2 Generic Character Tables
4.2-1 Available generic character tables
4.2-2 CharacterTableSpecialized
4.2-3 Components of generic character tables
4.2-4 Example: The generic table of cyclic groups
4.2-5 Example: The generic table of the general linear group GL(2,q)
4.3 Atlas Tables
4.3-1 Improvements to the Atlas
4.3-2 Power Maps
4.3-3 Projective Characters and Projections
4.3-4 Tables of Isoclinic Groups
4.3-5 Ordering of Characters and Classes
4.3-6 AtlasLabelsOfIrreducibles
4.3-7 Examples of the Atlas Format for GAP Tables
4.4 CAS Tables
4.4-1 CASInfo
4.5 Customizations of the GAP Character Table Library
4.5-1 Installing the GAP Character Table Library
4.5-2 Unloading Character Table Data
4.6 Technicalities of the Access to Character Tables from the Library
4.6-1 Data Files of the GAP Character Table Library
4.6-2 LIBLIST
4.6-3 LibInfoCharacterTable
4.7 How to Extend the GAP Character Table Library
4.7-1 NotifyNameOfCharacterTable
4.7-2 LibraryFusion
4.7-3 PrintToLib
4.7-4 NotifyCharacterTable
4.8 Sanity Checks for the GAP Character Table Library
4.9 Maintenance of the GAP Character Table Library

### 4 Contents of the GAP Character Table Library

This chapter informs you about

- the currently available character tables (see Section 4.1),

- generic character tables (see Section 4.2),

- the subsets of Atlas tables (see Section 4.3) and CAS tables (see Section 4.4),

- installing the library, and related user preferences (see Section 4.5).

The following rather technical sections are thought for those who want to maintain or extend the Character Table Library.

- the technicalities of the access to library tables (see Section 4.6),

- how to extend the library (see Section 4.7), and

- sanity checks (see Section 4.8).

#### 4.1 Ordinary and Brauer Tables in the GAP Character Table Library

This section gives a brief overview of the contents of the GAP character table library. For the details about, e. g., the structure of data files, see Section 4.6.

The changes in the character table library since the first release of GAP 4 are listed in a file that can be fetched from

http://www.math.rwth-aachen.de/~Thomas.Breuer/ctbllib/htm/ctbldiff.html .

There are three different kinds of character tables in the GAP library, namely ordinary character tables, Brauer tables, and generic character tables. Note that the Brauer table and the corresponding ordinary table of a group determine the decomposition matrix of the group (and the decomposition matrices of its blocks). These decomposition matrices can be computed from the ordinary and modular irreducibles with GAP, see Section Reference: Operations Concerning Blocks for details. A collection of PDF files of the known decomposition matrices of Atlas tables in the GAP Character Table Library can also be found at

http://www.math.rwth-aachen.de/~MOC/decomposition/.

##### 4.1-1 Ordinary Character Tables

Two different aspects are useful to list the ordinary character tables available in GAP, namely the aspect of the source of the tables and that of relations between the tables.

As for the source, there are first of all two big sources, namely the Atlas of Finite Groups (see Section 4.3) and the CAS library of character tables (see [NPP84]). Many Atlas tables are contained in the CAS library, and difficulties may arise because the succession of characters and classes in CAS tables and Atlas tables are in general different, so see Section 4.4 for the relations between these two variants of character tables of the same group. A subset of the CAS tables is the set of tables of Sylow normalizers of sporadic simple groups as published in [Ost86] this may be viewed as another source of character tables. The library also contains the character tables of factor groups of space groups (computed by W. Hanrath, see [Han88]) that are part of [HP89], in the form of two microfiches; these tables are given in CAS format (see Section 4.4) on the microfiches, but they had not been part of the "official" CAS library.

To avoid confusion about the ordering of classes and characters in a given table, authorship and so on, the `InfoText` (Reference: InfoText) value of the table contains the information

`origin: ATLAS of finite groups`

  for Atlas tables (see Section 4.3),

`origin: Ostermann`

  for tables contained in [Ost86],

`origin: CAS library`

  for any table of the CAS table library that is contained neither in the Atlas nor in [Ost86], and

`origin: Hanrath library`

  for tables contained in the microfiches in [HP89].

The `InfoText` (Reference: InfoText) value usually contains more detailed information, for example that the table in question is the character table of a maximal subgroup of an almost simple group. If the table was contained in the CAS library then additional information may be available via the `CASInfo` (4.4-1) value.

If one is interested in the aspect of relations between the tables, i. e., the internal structure of the library of ordinary tables, the contents can be listed up the following way.

We have

- all Atlas tables (see Section 4.3), i. e., the tables of the simple groups which are contained in the Atlas of Finite Groups, and the tables of cyclic and bicyclic extensions of these groups,

- most tables of maximal subgroups of sporadic simple groups (not all for the Monster group),

- many tables of maximal subgroups of other Atlas tables; the `Maxes` (3.7-1) value for the table is set if all tables of maximal subgroups are available,

- the tables of many Sylow p-normalizers of sporadic simple groups; this includes the tables printed in [Ost86] except J_4N2, Co_1N2, Fi_22N2, but also other tables are available; more generally, several tables of normalizers of other radical p-subgroups are available, such as normalizers of defect groups of p-blocks,

- some tables of element centralizers,

- some tables of Sylow p-subgroups,

- and a few other tables, e. g. `W(F4)`

Note that class fusions stored on library tables are not guaranteed to be compatible for any two subgroups of a group and their intersection, and they are not guaranteed to be consistent w. r. t. the composition of maps.

##### 4.1-2 Brauer Tables

The library contains all tables of the Atlas of Brauer Tables ([JLPW95]), and many other Brauer tables of bicyclic extensions of simple groups which are known yet. The Brauer tables in the library contain the information

    origin: modular ATLAS of finite groups

in their `InfoText` (Reference: InfoText) string.

#### 4.2 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 another 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` (Reference: ClassParameters) for an example). GAP does not support the computation of, e. g., generic scalar products.

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` (Reference: ClassParameters) and `CharacterParameters` (Reference: CharacterParameters).

##### 4.2-1 Available generic character tables

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` (Reference: 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( "DoubleCoverAlternating",` n`)`

  the table of the Schur double cover of the alternating group on n letters (see [Noe02]),

`CharacterTable( "DoubleCoverSymmetric",` n`)`

  the table of the standard Schur double cover of the symmetric group on n letters (see [Noe02]),

`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 ]`)` and `CharacterTable( "P:Q",` [ p, q, k ]`)`

  the table of the Frobenius extension of the nontrivial cyclic group of odd order p by the nontrivial cyclic group of order q where q divides p_i-1 for all prime divisors p_i of p; if p is a prime power then q determines the group uniquely and thus the first version can be used, otherwise the action of the residue class of k modulo p is taken for forming orbits of length q each on the nonidentity elements of the group of order p,

`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`)` = ^2B_2(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` (Reference: 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 generalized quaternionic 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` (Reference: CharacterTableWreathSymmetric).

##### 4.2-2 CharacterTableSpecialized

`‣ CharacterTableSpecialized`( gentbl, q ) | ( function )

For a record gentbl representing a generic character table, and a parameter value q, `CharacterTableSpecialized` returns a character table object computed by evaluating gentbl 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.)

    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 the "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

##### 4.2-3 Components of generic character tables

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] (note that this element need not actually lie in the group in question, for example it may be a diagonal matrix but the characteristic polynomial in the group s irreducible),

`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` (Reference: Identifier (for character tables)) 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` (Reference: Identifier (for character tables)) value of the table of G_q,

`text`

  string informing about the generic table

In the specialized table, the `ClassParameters` (Reference: ClassParameters) and `CharacterParameters` (Reference: 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` (4.2-2)).

##### 4.2-4 Example: The generic table of cyclic groups

For the cyclic group C_q = ⟨ x ⟩ of order q, there is one type of classes. The class parameters are integers k ∈ { 0, ..., q-1 }, the class with parameter k consists of the group element x^k. Group order and centralizer orders are the identity function q ↦ q, independent of the parameter k. The representative order function maps the parameter pair [q,k] to q / gcd(q,k), which is the order of x^k in C_q; the p-th power map is the function mapping the triple (q,k,p) to the parameter [1,(kp mod q)].

There is one type of characters, with parameters l ∈ { 0, ..., q-1 }; for e_q a primitive complex q-th root of unity, the character values are χ_l(x^k) = e_q^kl.

    gap> Print( CharacterTable( "Cyclic" ), "\n" );
    rec(
      centralizers := [ function ( n, k )
                return n;
            end ],
      charparam := [ function ( n )
                return [ 0 .. n - 1 ];
            end ],
      classparam := [ function ( n )
                return [ 0 .. n - 1 ];
            end ],
      domain := <Category "<<and-filter>>">,
      identifier := "Cyclic",
      irreducibles := [ [ function ( n, k, l )
                    return E( n ) ^ (k * l);
                end ] ],
      isGenericTable := true,
      libinfo := rec(
          firstname := "Cyclic",
          othernames := [  ] ),
      orders := [ function ( n, k )
                return n / Gcd( n, k );
            end ],
      powermap := [ function ( n, k, pow )
                return [ 1, k * pow mod n ];
            end ],
      size := function ( n )
            return n;
        end,
      specializedname := function ( q )
            return Concatenation( "C", String( q ) );
        end,
      text := "generic character table for cyclic groups" )

##### 4.2-5 Example: The generic table of the general linear group GL(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_1 describes scalar matrices, t_2 nonscalar diagonal matrices, t_3 companion matrices of (X - ρ)^2 for nonzero elements ρ ∈ F_q, and t_4 companion matrices of irreducible polynomials of degree 2 over F_q.

The sets of class parameters of the types are in bijection with nonzero elements in F_q for t_1 and t_3, with the set

{ { ρ, τ }; ρ, τ ∈ F_q, ρ not= 0, τ not= 0, ρ not= τ }

for t_2, and with the set { { ϵ, ϵ^q }; ϵ ∈ F_{q^2} ∖ F_q } for t_4.

The centralizer order functions are q ↦ (q^2-1)(q^2-q) for type t_1, q ↦ (q-1)^2 for type t_2, q ↦ q(q-1) for type t_3, and q ↦ q^2-1 for type t_4.

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

The file contains something similar to the following table.

    rec(
    identifier := "GL2",
    specializedname := ( q -> Concatenation( "GL(2,", String(q), ")" ) ),
    size := ( q -> (q^2-1)*(q^2-q) ),
    text := "generic character table of GL(2,q), see Robert Steinberg: ...",
    centralizers := [ function( q, k ) return (q^2-1) * (q^2-q); end,
                      ..., ..., ... ],
    classparam := [ ( q -> [ 0 .. q-2 ] ), ..., ..., ... ],
    charparam := [ ( q -> [ 0 .. q-2 ] ), ..., ..., ... ],
    powermap := [ function( q, k, pow ) return [ 1, (k*pow) mod (q-1) ]; end,
                  ..., ..., ... ],
    orders:= [ function( q, k ) return (q-1)/Gcd( q-1, k ); end,
               ..., ..., ... ],
    irreducibles := [ [ function( q, k, l ) return E(q-1)^(2*k*l); end,
                        ..., ..., ... ],
                      [ ..., ..., ..., ... ],
                      [ ..., ..., ..., ... ],
                      [ ..., ..., ..., ... ] ],
    classtext := [ ..., ..., ..., ... ],
    domain := IsPrimePowerInt,
    isGenericTable := true )

#### 4.3 Atlas Tables

The GAP character table library contains all character tables of bicyclic extensions of simple groups that are included in the Atlas of Finite Groups ([CCNPW85], from now on called Atlas), and the Brauer tables contained in the Atlas of Brauer Characters ([JLPW95]).

These tables have the information

    origin: ATLAS of finite groups

or

    origin: modular ATLAS of finite groups

in their `InfoText` (Reference: InfoText) value, they are simply called Atlas tables further on.

For displaying Atlas tables with the row labels used in the Atlas, or for displaying decomposition matrices, see `LaTeXStringDecompositionMatrix` (Reference: LaTeXStringDecompositionMatrix) and `AtlasLabelsOfIrreducibles` (4.3-6).

In addition to the information given in Chapters 6 to 8 of the Atlas which tell you how to read the printed tables, there are some rules relating these to the corresponding GAP tables.

##### 4.3-1 Improvements to the Atlas

For the GAP Character Table Library not the printed versions of the Atlas of Finite Groups and the Atlas of Brauer Characters are relevant but the revised versions given by the currently three lists of improvements that are maintained by Simon Norton. The first such list is contained in [BN95], and is printed in the Appendix of [JLPW95]; it contains the improvements that had been known until the "Atlas of Brauer Characters" was published. The second list contains the improvements to the Atlas of Finite Groups that were found since the publication of [JLPW95]. It can be found in the internet, an HTML version at

http://web.mat.bham.ac.uk/atlas/html/atlasmods.html

and a DVI version at

http://web.mat.bham.ac.uk/atlas/html/atlasmods.dvi.

The third list contains the improvements to the Atlas of Brauer Characters, HTML and PDF versions can be found in the internet at

http://www.math.rwth-aachen.de/~MOC/ABCerr.html

and

http://www.math.rwth-aachen.de/~MOC/ABCerr.pdf,

respectively.

Also some tables are regarded as Atlas tables that are not printed in the Atlas but available in Atlas format, according to the lists of improvements mentioned above. Currently these are the tables related to L_2(49), L_2(81), L_6(2), O_8^-(3), O_8^+(3), S_10(2), and ^2E_6(2).3.

##### 4.3-2 Power Maps

For the tables of 3.McL, 3_2.U_4(3) and its covers, and 3_2.U_4(3).2_3 and its covers, the power maps are not uniquely determined by the information from the Atlas but determined only up to matrix automorphisms (see `MatrixAutomorphisms` (Reference: MatrixAutomorphisms)) of the irreducible characters. In these cases, the first possible map according to lexicographical ordering was chosen, and the automorphisms are listed in the `InfoText` (Reference: InfoText) strings of the tables.

##### 4.3-3 Projective Characters and Projections

If G (or G.a) has a nontrivial Schur multiplier then the attribute `ProjectivesInfo` (3.7-2) of the GAP table object of G (or G.a) is set; the `chars` component of the record in question is the list of values lists of those faithful projective irreducibles that are printed in the Atlas (so-called proxy character), and the `map` component lists the positions of columns in the covering for which the column is printed in the Atlas (a so-called proxy class, this preimage is denoted by g_0 in Chapter 7, Section 14 of the Atlas).

##### 4.3-4 Tables of Isoclinic Groups

As described in Chapter 6, Section 7 and in Chapter 7, Section 18 of the Atlas, there exist two (often nonisomorphic) groups of structure 2.G.2 for a simple group G, which are isoclinic. The table in the GAP Character Table Library is the one printed in the Atlas, the table of the isoclinic variant can be constructed using `CharacterTableIsoclinic` (Reference: CharacterTableIsoclinic).

##### 4.3-5 Ordering of Characters and Classes

(Throughout this section, G always means the simple group involved.)

1. For G itself, the ordering of classes and characters in the GAP table coincides with the one in the Atlas.

2. For an automorphic extension G.a, there are three types of characters.

   - If a character χ of G extends to G.a then the different extensions χ^0, χ^1, ..., χ^{a-1} are consecutive in the table of G.a (see [CCNPW85, Chapter 7, Section 16]).

   - If some characters of G fuse to give a single character of G.a then the position of that character in the table of G.a is given by the position of the first involved character of G.

   - If both extension and fusion occur for a character then the resulting characters are consecutive in the table of G.a, and each replaces the first involved character of G.

3. Similarly, there are different types of classes for an automorphic extension G.a, as follows.

   - If some classes collapse then the resulting class replaces the first involved class of G.

   - For a > 2, any proxy class and its algebraic conjugates that are not printed in the Atlas are consecutive in the table of G.a; if more than two classes of G.a have the same proxy class (the only case that actually occurs is for a = 5) then the ordering of non-printed classes is the natural one of corresponding Galois conjugacy operators *k (see [CCNPW85, Chapter 7, Section 19]).

   - For a_1, a_2 dividing a such that a_1 ≤ a_2, the classes of G.a_1 in G.a precede the classes of G.a_2 not contained in G.a_1. This ordering is the same as in the Atlas, with the only exception U_3(8).6.

4. For a central extension M.G, there are two different types of characters, as follows.

   - Each character can be regarded as a faithful character of a factor group m.G, where m divides M. Characters with the same kernel are consecutive as in the Atlas, the ordering of characters with different kernels is given by the order of precedence 1, 2, 4, 3, 6, 12 for the different values of m.

   - If m > 2, a faithful character of m.G that is printed in the Atlas (a so-called proxy character) represents two or more Galois conjugates. In each Atlas table in GAP, a proxy character always precedes the non-printed characters with this proxy. The case m = 12 is the only one that actually occurs where more than one character for a proxy is not printed. In this case, the non-printed characters are ordered according to the corresponding Galois conjugacy operators *5, *7, *11 (in this order).

5. For the classes of a central extension we have the following.

   - The preimages of a G-class in M.G are subsequent, the ordering is the same as that of the lifting order rows in [CCNPW85, Chapter 7, Section 7].

   - The primitive roots of unity chosen to represent the generating central element (i. e., the element in the second class of the GAP table) are `E(3)`, `E(4)`, `E(6)^5` (`= E(2)*E(3)`), and `E(12)^7` (`= E(3)*E(4)`), for m = 3, 4, 6, and 12, respectively.

6. For tables of bicyclic extensions m.G.a, both the rules for automorphic and central extensions hold. Additionally we have the following three rules.

   - Whenever classes of the subgroup m.G collapse in m.G.a then the resulting class replaces the first involved class.

   - Whenever characters of the subgroup m.G collapse fuse in m.G.a then the result character replaces the first involved character.

   - Extensions of a character are subsequent, and the extensions of a proxy character precede the extensions of characters with this proxy that are not printed.

   - Preimages of a class of G.a in m.G.a are subsequent, and the preimages of a proxy class precede the preimages of non-printed classes with this proxy.

##### 4.3-6 AtlasLabelsOfIrreducibles

`‣ AtlasLabelsOfIrreducibles`( tbl[, short] ) | ( function )

Let tbl be the (ordinary or Brauer) character table of a bicyclic extension of a simple group that occurs in the Atlas of Finite Groups [CCNPW85] or the Atlas of Brauer Characters [JLPW95]. `AtlasLabelsOfIrreducibles` returns a list of strings, the i-th entry being a label for the i-th irreducible character of tbl.

The labels have the following form. We state the rules only for ordinary characters, the rules for Brauer characters are obtained by replacing χ by φ.

First consider only downward extensions m.G of a simple group G. If m ≤ 2 then only labels of the form χ_i occur, which denotes the i-th ordinary character shown in the Atlas.

The labels of faithful ordinary characters of groups m.G with m ≥ 3 are of the form χ_i, χ_i^*, or χ_i^{*k}, which means the i-th character printed in the Atlas, the unique character that is not printed and for which χ_i acts as proxy (see [CCNPW85, Chapter 7, Sections 8 and 19]), and the image of the printed character χ_i under the algebraic conjugacy operator *k, respectively.

For groups m.G.a with a > 1, the labels of the irreducible characters are derived from the labels of the irreducible constituents of their restrictions to m.G, as follows.

1. If the ordinary irreducible character χ_i of m.G extends to m.G.a then the a^' extensions are denoted by χ_{i,0}, χ_{i,1}, ..., χ_{i,a^'}, where χ_{i,0} is the character whose values are printed in the Atlas.

2. The label χ_{i_1 + i_2 + ⋯ + i_a} means that a different characters χ_{i_1}, χ_{i_2}, ..., χ_{i_a} of m.G induce to an irreducible character of m.G.a with this label.

   If either `true` or the string `"short"` is entered as the second argument then the label has the short form χ_{i_1+}. Note that i_2, i_3, ..., i_a can be read off from the fusion signs in the Atlas.

3. Finally, the label χ_{i_1,j_1 + i_2,j_2 + ⋯ + i_{a^'},j_{a^'}} means that the characters χ_{i_1}, χ_{i_2}, ..., χ_{i_{a^'}} of m.G extend to a group that lies properly between m.G and m.G.a, and the extensions χ_{i_1, j_1}, χ_{i_2, j_2}, ... χ_{i_{a^'},j_{a^'}} induce to an irreducible character of m.G.a with this label.

   If `true` or the string `"short"` was entered as the second argument then the label has the short form χ_{i,j+}.

    gap> AtlasLabelsOfIrreducibles( CharacterTable( "3.A7.2" ) );
    [ "\\chi_{1,0}", "\\chi_{1,1}", "\\chi_{2,0}", "\\chi_{2,1}",
      "\\chi_{3+4}", "\\chi_{5,0}", "\\chi_{5,1}", "\\chi_{6,0}",
      "\\chi_{6,1}", "\\chi_{7,0}", "\\chi_{7,1}", "\\chi_{8,0}",
      "\\chi_{8,1}", "\\chi_{9,0}", "\\chi_{9,1}", "\\chi_{17+17\\ast 2}",
      "\\chi_{18+18\\ast 2}", "\\chi_{19+19\\ast 2}",
      "\\chi_{20+20\\ast 2}", "\\chi_{21+21\\ast 2}",
      "\\chi_{22+23\\ast 8}", "\\chi_{22\\ast 8+23}" ]
    gap> AtlasLabelsOfIrreducibles( CharacterTable( "3.A7.2" ), "short" );
    [ "\\chi_{1,0}", "\\chi_{1,1}", "\\chi_{2,0}", "\\chi_{2,1}",
      "\\chi_{3+}", "\\chi_{5,0}", "\\chi_{5,1}", "\\chi_{6,0}",
      "\\chi_{6,1}", "\\chi_{7,0}", "\\chi_{7,1}", "\\chi_{8,0}",
      "\\chi_{8,1}", "\\chi_{9,0}", "\\chi_{9,1}", "\\chi_{17+}",
      "\\chi_{18+}", "\\chi_{19+}", "\\chi_{20+}", "\\chi_{21+}",
      "\\chi_{22+}", "\\chi_{23+}" ]

##### 4.3-7 Examples of the Atlas Format for GAP Tables

We give three little examples for the conventions stated in Section 4.3, listing both the Atlas format and the table displayed by GAP.

First, let G be the trivial group. We consider the cyclic group C_6 of order 6. It can be viewed in several ways, namely

- as a downward extension of the factor group C_2 which contains G as a subgroup, or equivalently, as an upward extension of the subgroup C_3 which has a factor group isomorphic to G:

    ┌───────┐ ┌───────┐       ;   @   ;   ;   @      2   1   1   1   1   1   1
    │       │ │       │           1           1      3   1   1   1   1   1   1
    │   G   │ │  G.2  │     p power           A
    │       │ │       │     p' part           A         1a  3a  3b  2a  6a  6b
    └───────┘ └───────┘     ind  1A fus ind  2A     2P  1a  3b  3a  1a  3b  3a
    ┌───────┐ ┌───────┐                             3P  1a  1a  1a  2a  2a  2a
    │       │ │       │  χ_1  +   1   :  ++   1
    │  3.G  │ │ 3.G.2 │                           X.1    1   1   1   1   1   1
    │       │ │       │     ind   1 fus ind   2   X.2    1   1   1  -1  -1  -1
    └───────┘ └───────┘           3           6   X.3    1   A  /A   1   A  /A
                                  3           6   X.4    1   A  /A  -1  -A -/A
                                                  X.5    1  /A   A   1  /A   A
                         χ_2 o2   1   : oo2   1   X.6    1  /A   A  -1 -/A  -A

                                                  A = E(3)
                                                    = (-1+ER(-3))/2 = b3

  `X.1`, `X.2` extend χ_1. `X.3`, `X.4` extend the proxy character χ_2. `X.5`, `X.6` extend the not printed character with proxy χ_2. The classes `1a`, `3a`, `3b` are preimages of `1A`, and `2a`, `6a`, `6b` are preimages of `2A`.

- as a downward extension of the factor group C_3 which contains G as a subgroup, or equivalently, as an upward extension of the subgroup C_2 which has a factor group isomorphic to G:

    ┌───────┐ ┌───────┐       ;   @   ;   ;   @      2   1   1   1   1   1   1
    │       │ │       │           1           1      3   1   1   1   1   1   1
    │   G   │ │  G.3  │     p power           A
    │       │ │       │     p' part           A         1a  2a  3a  6a  3b  6b
    └───────┘ └───────┘     ind  1A fus ind  3A     2P  1a  1a  3b  3b  3a  3a
    ┌───────┐ ┌───────┐                             3P  1a  2a  1a  2a  1a  2a
    │       │ │       │  χ_1  +   1   : +oo   1
    │  2.G  │ │ 2.G.3 │                           X.1    1   1   1   1   1   1
    │       │ │       │     ind   1 fus ind   3   X.2    1   1   A   A  /A  /A
    └───────┘ └───────┘           2           6   X.3    1   1  /A  /A   A   A
                                                  X.4    1  -1   1  -1   1  -1
                         χ_2  +   1   : +oo   1   X.5    1  -1   A  -A  /A -/A
                                                  X.6    1  -1  /A -/A   A  -A

                                                  A = E(3)
                                                    = (-1+ER(-3))/2 = b3

  `X.1` to `X.3` extend χ_1, `X.4` to `X.6` extend χ_2. The classes `1a` and `2a` are preimages of `1A`, `3a` and `6a` are preimages of the proxy class `3A`, and `3b` and `6b` are preimages of the not printed class with proxy `3A`.

- as a downward extension of the factor groups C_3 and C_2 which have G as a factor group:

    ┌───────┐           ;   @        2   1   1   1   1   1   1
    │       │               1        3   1   1   1   1   1   1
    │   G   │         p power
    │       │         p' part           1a  6a  3a  2a  3b  6b
    └───────┘         ind  1A       2P  1a  3a  3b  1a  3a  3b
    ┌───────┐                       3P  1a  2a  1a  2a  1a  2a
    │       │      χ_1  +   1
    │  2.G  │                     X.1    1   1   1   1   1   1
    │       │         ind   1     X.2    1  ─1   1  ─1   1  ─1
    └───────┘               2     X.3    1   A  /A   1   A  /A
    ┌───────┐                     X.4    1  /A   A   1  /A   A
    │       │      χ_2  +   1     X.5    1  ─A  /A  ─1   A ─/A
    │  3.G  │                     X.6    1 ─/A   A  ─1  /A  ─A
    │       │         ind   1
    └───────┘               3     A = E(3)
    ┌───────┐               3       = (─1+ER(─3))/2 = b3
    │       │
    │  6.G  │      χ_3 o2   1
    │       │
    └───────┘         ind   1
                            6
                            3
                            2
                            3
                            6

                   χ_4 o2   1

  `X.1`, `X.2` correspond to χ_1, χ_2, respectively; `X.3`, `X.5` correspond to the proxies χ_3, χ_4, and `X.4`, `X.6` to the not printed characters with these proxies. The factor fusion onto 3.G is given by `[ 1, 2, 3, 1, 2, 3 ]`, that onto G.2 by `[ 1, 2, 1, 2, 1, 2 ]`.

- as an upward extension of the subgroups C_3 or C_2 which both contain a subgroup isomorphic to G:

    ┌───────┐ ┌───────┐ ┌───────┐ ┌───────┐
    │       │ │       │ │       │ │       │
    │   G   │ │  G.2  │ │  G.3  │ │  G.6  │
    │       │ │       │ │       │ │       │
    └───────┘ └───────┘ └───────┘ └───────┘

         ;   @   ;   ;   @   ;   ;   @   ;     ;   @

             1           1           1             1
       p power           A           A            AA
       p' part           A           A            AA
       ind  1A fus ind  2A fus ind  3A fus   ind  6A

    χ_1  +   1   :  ++   1   : +oo   1   :+oo+oo   1

        2   1   1   1   1   1   1
        3   1   1   1   1   1   1

           1a  2a  3a  3b  6a  6b
       2P  1a  1a  3b  3a  3b  3a
       3P  1a  2a  1a  1a  2a  2a
     X.1    1   1   1   1   1   1
     X.2    1  -1   A  /A  -A -/A
     X.3    1   1  /A   A  /A   A
     X.4    1  -1   1   1  -1  -1
     X.5    1   1   A  /A   A  /A
     X.6    1  -1  /A   A -/A  -A

     A = E(3)
       = (-1+ER(-3))/2 = b3

  The classes `1a`, `2a` correspond to 1A, 2A, respectively. `3a`, `6a` correspond to the proxies 3A, 6A, and `3b`, `6b` to the not printed classes with these proxies.

The second example explains the fusion case. Again, G is the trivial group.

    ┌───────┐ ┌───────┐        ;   @   ;   ;  @      3.G.2
    │       │ │       │            1          1
    │   G   │ │  G.2  │      p power          A         2   1   .   1
    │       │ │       │      p' part          A         3   1   1   .
    └───────┘ └───────┘      ind  1A fus ind 2A
    ┌───────┐ ┌───────┐                                    1a 3a 2a
    │       │ │       │   χ_1  +   1   :  ++  1        2P  1a 3a 1a
    │  2.G  │ │ 2.G.2 │                                3P  1a 1a 2a
    │       │ │       │      ind   1 fus ind  2
    └───────┘ └───────┘            2          2      X.1    1  1  1
    ┌───────┐ ┌───────                               X.2    1  1 ─1
    │       │ │           χ_2  +   1   :  ++  1      X.3    2 ─1  .
    │  3.G  │ │ 3.G.2
    │       │ │              ind   1 fus ind  2
    └───────┘                      3                 6.G.2
    ┌───────┐ ┌───────             3
    │       │ │                                         2   2  1  1  2  2  2
    │  6.G  │ │ 6.G.2     χ_3 o2   1   *   +            3   1  1  1  1  .  .
    │       │ │
    └───────┘                ind   1 fus ind  2            1a 6a 3a 2a 2b 2c
                                   6          2        2P  1a 3a 3a 1a 1a 1a
                                   3                   3P  1a 2a 1a 2a 2b 2c
                                   2
                                   3                 Y.1    1  1  1  1  1  1
                                   6                 Y.2    1  1  1  1 -1 -1
                                                     Y.3    1 -1  1 -1  1 -1
                          χ_4 o2   1   *   +         Y.4    1 -1  1 -1 -1  1
                                                     Y.5    2 -1 -1  2  .  .
                                                     Y.6    2  1 -1 -2  .  .

The tables of G, 2.G, 3.G, 6.G and G.2 are known from the first example, that of 2.G.2 will be given in the next one. So here we print only the GAP tables of 3.G.2 ≅ D_6 and 6.G.2 ≅ D_12.

In 3.G.2, the characters `X.1`, `X.2` extend χ_1; χ_3 and its non-printed partner fuse to give `X.3`, and the two preimages of `1A` of order 3 collapse.

In 6.G.2, `Y.1` to `Y.4` are extensions of χ_1, χ_2, so these characters are the inflated characters from 2.G.2 (with respect to the factor fusion `[ 1, 2, 1, 2, 3, 4 ]`). `Y.5` is inflated from 3.G.2 (with respect to the factor fusion `[ 1, 2, 2, 1, 3, 3 ]`), and `Y.6` is the result of the fusion of χ_4 and its non-printed partner.

For the last example, let G be the elementary abelian group 2^2 of order 4. Consider the following tables.

    ┌───────┐ ┌───────┐          ;   @   @   @   @   ;   ;   @
    │       │ │       │              4   4   4   4           1
    │   G   │ │  G.3  │        p power   A   A   A           A
    │       │ │       │        p' part   A   A   A           A
    └───────┘ └───────┘        ind  1A  2A  2B  2C fus ind  3A
    ┌───────┐ ┌───────┐
    │       │ │       │     χ_1  +   1   1   1   1   : +oo   1
    │  2.G  │ │ 2.G.3 │     χ_2  +   1   1  ─1  ─1   .   +   0
    │       │ │       │     χ_3  +   1  ─1   1  ─1   |
    └───────┘ └───────┘     χ_4  +   1  ─1  ─1   1   |

                               ind   1   4   4   4 fus ind   3
                                     2                       6

                            χ_5  -   2   0   0   0   : -oo   1

      G.3

         2   2   2   .   .
         3   1   .   1   1

            1a  2a  3a  3b
        2P  1a  1a  3b  3a
        3P  1a  2a  1a  1a

      X.1    1   1   1   1
      X.2    1   1   A  /A
      X.3    1   1  /A   A         2.G.3
      X.4    3  -1   .   .
                                      2   3   3   2   1   1   1   1
      A = E(3)                        3   1   1   .   1   1   1   1
        = (-1+ER(-3))/2 = b3
                                         1a  2a  4a  3a  6a  3b  6b
      2.G                            2P  1a  1a  2a  3b  3b  3a  3a
                                     3P  1a  2a  4a  1a  2a  1a  2a
         2   3   3   2   2   2
                                   X.1    1   1   1   1   1   1   1
            1a  2a  4a  4b  4c     X.2    1   1   1   A   A  /A  /A
        2P  1a  1a  2a  1a  1a     X.3    1   1   1  /A  /A   A   A
        3P  1a  2a  4a  4b  4c     X.4    3   3  -1   .   .   .   .
                                   X.5    2  -2   .   1   1   1   1
      X.1    1   1   1   1   1     X.6    2  -2   .   A  -A  /A -/A
      X.2    1   1   1  -1  -1     X.7    2  -2   .  /A -/A   A  -A
      X.3    1   1  -1   1  -1
      X.4    1   1  -1  -1   1     A = E(3)
      X.5    2  -2   .   .   .       = (-1+ER(-3))/2 = b3

In the table of G.3 ≅ A_4, the characters χ_2, χ_3, and χ_4 fuse, and the classes `2A`, `2B` and `2C` collapse. For getting the table of 2.G ≅ Q_8, one just has to split the class `2A` and adjust the representative orders. Finally, the table of 2.G.3 ≅ SL_2(3) is given; the class fusion corresponding to the injection 2.G ↪ 2.G.3 is `[ 1, 2, 3, 3, 3 ]`, and the factor fusion corresponding to the epimorphism 2.G.3 → G.3 is `[ 1, 1, 2, 3, 3, 4, 4 ]`.

#### 4.4 CAS Tables

One of the predecessors of GAP was CAS (Character Algorithm System, see [NPP84]), which had also a library of character tables. All these character tables are available in GAP except if stated otherwise in the file `doc/ctbldiff.pdf`. This sublibrary has been completely revised before it was included in GAP, for example, errors have been corrected and power maps have been completed.

Any CAS table is accessible by each of its CAS names (except if stated otherwise in `doc/ctbldiff.pdf`), that is, the table name or the filename used in CAS.

##### 4.4-1 CASInfo

`‣ CASInfo`( tbl ) | ( attribute )

Let tbl be an ordinary character table in the GAP library that was (up to permutations of classes and characters) contained already in the CAS table library. When one fetches tbl from the library, one does in general not get the original CAS table. Namely, in many cases (mostly Atlas tables, see Section 4.3), the identifier of the table (see `Identifier` (Reference: Identifier (for character tables))) as well as the ordering of classes and characters are different for the CAS table and its GAP version.

Note that in several cases, the CAS library contains different tables of the same group, in particular these tables may have different names and orderings of classes and characters.

The `CASInfo` value of tbl, if stored, is a list of records, each describing the relation between tbl and a character table in the CAS library. The records have the components

`name`

  the name of the CAS table,

`permchars` and `permclasses`

  permutations of the `Irr` (Reference: Irr) values and the classes of tbl, respectively, that must be applied in order to get the orderings in the original CAS table, and

`text`

  the text that was stored on the CAS table (which may contain incorrect statements).

    gap> tbl:= CharacterTable( "m10" );
    CharacterTable( "A6.2_3" )
    gap> HasCASInfo( tbl );
    true
    gap> CASInfo( tbl );
    [ rec( name := "m10", permchars := (3,5)(4,8,7,6), permclasses := (),
          text := "names:     m10\norder:     2^4.3^2.5 = 720\nnumber of c\
    lasses: 8\nsource:    cambridge atlas\ncomments:  point stabilizer of \
    mathieu-group m11\ntest:      orth, min, sym[3]\n" ) ]

The class fusions stored on tables from the CAS library have been computed anew with GAP; the `text` component of such a fusion record tells if the fusion map is equal to that in the CAS library, up to the permutation of classes between the table in CAS and its GAP version.

    gap> First( ComputedClassFusions( tbl ), x -> x.name = "M11" );
    rec( map := [ 1, 2, 3, 4, 5, 4, 7, 8 ], name := "M11",
      text := "fusion is unique up to table automorphisms,\nthe representa\
    tive is equal to the fusion map on the CAS table" )

#### 4.5 Customizations of the GAP Character Table Library

##### 4.5-1 Installing the GAP Character Table Library

To install the package unpack the archive file in a directory in the `pkg` directory of your local copy of GAP 4. This might be the `pkg` directory of the GAP 4 home directory, see Section Reference: Installing a GAP Package for details. It is however also possible to keep an additional `pkg` directory in your private directories, see Reference: GAP Root Directories. The latter possibility must be chosen if you do not have write access to the GAP root directory.

The package consists entirely of GAP code, no external binaries need to be compiled.

For checking the installation of the package, you should start GAP and call

    gap> ReadPackage( "ctbllib", "tst/testinst.g" );

If the installation is o. k. then `true` is printed, and the GAP prompt appears again; otherwise the output lines tell you what should be changed.

More testfiles are available in the `tst` directory of the package.

PDF and HTML versions of the package manual are available in the `doc` directory of the package.

##### 4.5-2 Unloading Character Table Data

Data files from the GAP Character Table Library may be read only once during a GAP session –this is efficient but requires memory– or the cached data may be erased as soon as a second data file is to be read –this requires less memory but is usually less efficient.

One can choose between these two possibilities via the user preference `"UnloadCTblLibFiles"`, see `UserPreference` (Reference: UserPreference). The default value of this preference is `true`, that is, the contents of only one data file is kept in memory. Call `SetUserPreference( "CTblLib", "UnloadCTblLibFiles", false );` if you want to change this behaviour.

#### 4.6 Technicalities of the Access to Character Tables from the Library

##### 4.6-1 Data Files of the GAP Character Table Library

The data files of the GAP Character Table Library reside in the `data` directory of the package CTblLib.

The filenames start with `ct` (for "character table"), followed by either `o` (for "ordinary"), `b` (for "Brauer"), or `g` (for "generic"), then a description of the contents (up to 5 characters, e. g., `alter` for the tables of alternating and related groups), and the suffix `.tbl`.

The file `ctb`descr`.tbl` contains the known Brauer tables corresponding to the ordinary tables in the file `cto`descr`.tbl`.

Each data file of the table library is supposed to consist of

1. comment lines, starting with a hash character `#` in the first column,

2. an assignment to a component of `LIBTABLE.LOADSTATUS`, at the end of the file, and

3. function calls of the form

   - `MBT(` name, data`)` ("make Brauer table"),

   - `MOT(` name, data`)` ("make ordinary table"),

   - `ALF(` from, to, map`)`, `ALF(` from, to, map, textlines`)` ("add library fusion"),

   - `ALN(` name, listofnames`)` ("add library name"), and

   - `ARC(` name, component, compdata`)` ("add record component").

   Here name must be the identifier value of the ordinary character table corresponding to the table to which the command refers; data must be a comma separated sequence of GAP objects; from and to must be identifier values of ordinary character tables, map a list of positive integers, textlines and listofnames lists list of strings, component a string, and compdata any GAP object.

   `MOT`, `ALF`, `ALN`, and `ARC` occur only in files containing ordinary character tables, and `MBT` occurs only in files containing Brauer tables.

Besides the above calls, the data in files containing ordinary and Brauer tables may contain only the following GAP functions. (Files containing generic character tables may contain calls to arbitrary GAP library functions.)

`ACM`, `Concatenation` (Reference: concatenation of lists), `E` (Reference: E), `EvalChars`, `GALOIS`, `Length` (Reference: Length), `ShallowCopy` (Reference: ShallowCopy), `TENSOR`, and `TransposedMat` (Reference: TransposedMat).

The function `CTblLib.RecomputeTOC` in the file `gap4/maketbl.g` of the CTblLib package expects the file format described above, and to some extent it checks this format.

The function calls may be continued over several lines of a file. A semicolon is assumed to be the last character in its line if and only if it terminates a function call.

Names of character tables are strings (see Chapter Reference: Strings and Characters), i. e., they are enclosed in double quotes; strings in table library files must not be split over several lines, because otherwise the function `CTblLib.RecomputeTOC` may get confused. Additionally, no character table name is allowed to contain double quotes.

There are three different ways how the table data can be stored in the file.

Full ordinary tables

  are encoded by a call to the function `MOT`, where the arguments correspond to the relevant attribute values; each fusion into another library table is added by a call to `ALF`, values to be stored in components of the table object are added with `ARC`, and admissible names are notified with `ALN`. The argument of `MOT` that encodes the irreducible characters is abbreviated as follows. For each subset of characters that differ just by multiplication with a linear character or by Galois conjugacy, only the first one is given by its values, the others are replaced by `[TENSOR,[i,j]]` (which means that the character is the tensor product of the `i`-th and the `j`-th character in the list) or `[GALOIS,[i,j]]` (which means that the character is obtained from the `i`-th character by applying `GaloisCyc( ., j )` to it).

Brauer tables

  are stored relative to the corresponding ordinary tables; attribute values that can be computed by restricting from the ordinary table to p-regular classes are not stored, and instead of the irreducible characters the files contain (inverses of) decomposition matrices or Brauer trees for the blocks of nonzero defect.

Ordinary construction tables

  have the attribute `ConstructionInfoCharacterTable` (3.7-4) set, with value a list that contains the name of the construction function used and the arguments for a call to this function; the function call is performed by `CharacterTable` (Reference: CharacterTable) when the table is constructed (not when the file containing the table is read). One aim of this mechanism is to store structured character tables such as tables of direct products and tables of central extensions of other tables in a compact way, see Chapter 5.

##### 4.6-2 LIBLIST

`‣ LIBLIST` | ( global variable )

GAP's knowledge about the ordinary character tables in the GAP Character Table Library is given by the file `ctprimar.tbl` (the "primary file" of the character table library). This file can be produced from the data files using the function `CTblLib.RecomputeTOC`.

The information is stored in the global variable `LIBLIST`, which is a record with the following components.

`firstnames`

  the list of `Identifier` (Reference: Identifier (for character tables)) values of the ordinary tables,

`files`

  the list of filenames containing the data of ordinary tables,

`filenames`

  a list of positive integers, value j at position i means that the table whose identifier is the i-th in the `firstnames` list is contained in the j-th file of the `files` component,

`fusionsource`

  a list containing at position i the list of names of tables that store a fusion into the table whose identifier is the i-th in the `firstnames` list,

`allnames`

  a list of all admissible names of ordinary library tables,

`position`

  a list that stores at position i the position in `firstnames` of the identifier of the table with the i-th admissible name in `allnames`,

`projections`

  a list of triples [ name, factname, map ] describing a factor fusion map from the table with identifier name to the table with identifier factname (this is used to construct the table of name using the data of the table of factname),

`simpleinfo`

  a list of triples [ m, name, a ] describing the tables of simple groups in the library; name is the identifier of the table, m`.`name and name`.`a are admissible names for its Schur multiplier and automorphism group, respectively, if these tables are available at all,

`sporadicSimple`

  a list of identifiers of the tables of the 26 sporadic simple groups, and

`GENERIC`

  a record with information about generic tables (see Section 4.2).

##### 4.6-3 LibInfoCharacterTable

`‣ LibInfoCharacterTable`( tblname ) | ( function )

is a record with the components

`firstName`

  the `Identifier` (Reference: Identifier (for character tables)) value of the library table for which tblname is an admissible name, and

`fileName`

  the name of the file in which the table data is stored.

If no such table exists in the GAP library then `fail` is returned.

If tblname contains the substring `"mod"` then it is regarded as the name of a Brauer table. In this case the result is computed from that for the corresponding ordinary table and the characteristic. So if the ordinary table exists then the result is a record although the Brauer table in question need not be contained in the GAP library.

    gap> LibInfoCharacterTable( "S5" );
    rec( fileName := "ctoalter", firstName := "A5.2" )
    gap> LibInfoCharacterTable( "S5mod2" );
    rec( fileName := "ctbalter", firstName := "A5.2mod2" )
    gap> LibInfoCharacterTable( "J5" );
    fail

#### 4.7 How to Extend the GAP Character Table Library

GAP users may want to extend the character table library in different respects.

- Probably the easiest change is to add new admissible names to library tables, in order to use these names in calls of `CharacterTable` (3.1-2). This can be done using `NotifyNameOfCharacterTable` (4.7-1).

- The next kind of changes is the addition of new fusions between library tables. Once a fusion map is known, it can be added to the library file containing the table of the subgroup, using the format produced by `LibraryFusion` (4.7-2).

- The last kind of changes is the addition of new character tables to the GAP character table library. Data files containing tables in library format (i. e., in the form of calls to `MOT` or `MBT`) can be produced using `PrintToLib` (4.7-3).

  If you have an ordinary character table in library format which you want to add to the table library, for example because it shall be accessible via `CharacterTable` (3.1-2), you must notify this table, i. e., tell GAP in which file it can be found, and which names shall be admissible for it. This can be done using `NotifyCharacterTable` (4.7-4).

##### 4.7-1 NotifyNameOfCharacterTable

`‣ NotifyNameOfCharacterTable`( firstname, newnames ) | ( function )

notifies the strings in the list newnames as new admissible names for the library table with `Identifier` (Reference: Identifier (for character tables)) value firstname. If there is already another library table for which some of these names are admissible then an error is signaled.

`NotifyNameOfCharacterTable` modifies the global variable `LIBLIST` (4.6-2).

    gap> CharacterTable( "private" );
    fail
    gap> NotifyNameOfCharacterTable( "A5", [ "private" ] );
    gap> a5:= CharacterTable( "private" );
    CharacterTable( "A5" )

One can notify alternative names for character tables inside data files, using the function `ALN` instead of `NotifyNameOfCharacterTable`. The idea is that the additional names of tables from those files can be ignored which are controlled by `CTblLib.RecomputeTOC`. Therefore, `ALN` is set to `Ignore` before the file is read with `CTblLib.ReadTbl`, otherwise `ALN` is set to `NotifyNameOfCharacterTable`.

##### 4.7-2 LibraryFusion

`‣ LibraryFusion`( name, fus ) | ( function )

For a string name that is an `Identifier` (Reference: Identifier (for character tables)) value of an ordinary character table in the GAP library, and a record fus with the components

`name`

  the identifier of the destination table, or this table itself,

`map`

  the fusion map, a list of image positions,

`text` (optional)

  a string describing properties of the fusion, and

`specification` (optional)

  a string or an integer,

`LibraryFusion` returns a string whose printed value can be used to add the fusion in question to the library file containing the data for the table with identifier name.

If name is a character table then its `Identifier` (Reference: Identifier (for character tables)) value is used as the corresponding string.

    gap> s5:= CharacterTable( "S5" );
    CharacterTable( "A5.2" )
    gap> fus:= PossibleClassFusions( a5, s5 );
    [ [ 1, 2, 3, 4, 4 ] ]
    gap> fusion:= rec( name:= s5, map:= fus[1], text:= "unique" );;
    gap> Print( LibraryFusion( "A5", fusion ) );
    ALF("A5","A5.2",[1,2,3,4,4],[
    "unique"
    ]);

##### 4.7-3 PrintToLib

`‣ PrintToLib`( file, tbl ) | ( function )

prints the (ordinary or Brauer) character table tbl in library format to the file file`.tbl` (or to file if this has already the suffix `.tbl`).

If tbl is an ordinary table then the value of the attribute `NamesOfFusionSources` (Reference: NamesOfFusionSources) is ignored by `PrintToLib`, since for library tables this information is extracted from the source files by the function `CTblLib.RecomputeTOC`.

The names of data files in the GAP Character Table Library begin with `cto` (for ordinary tables) or `ctb` (for corresponding Brauer tables), see Section 4.6. This is supported also for private extensions of the library, that is, if the filenames are chosen this way and the ordinary tables in the `cto` files are notified via `NotifyCharacterTable` (4.7-4) then the Brauer tables will be found in the `ctb` files. Alternatively, if the filenames of the files with the ordinary tables do not start with `cto` then GAP expects the corresponding Brauer tables in the same file as the ordinary tables.

    gap> PrintToLib( "private", a5 );

The above command appends the data of the table `a5` to the file `private.tbl`; the first lines printed to this file are

    MOT("A5",
    [
    "origin: ATLAS of finite groups, tests: 1.o.r., pow[2,3,5]"
    ],
    [60,4,3,5,5],
    [,[1,1,3,5,4],[1,2,1,5,4],,[1,2,3,1,1]],
    [[1,1,1,1,1],[3,-1,0,-E(5)-E(5)^4,-E(5)^2-E(5)^3],
    [GALOIS,[2,2]],[4,0,1,-1,-1],[5,1,-1,0,0]],
    [(4,5)]);
    ARC("A5","projectives",["2.A5",[[2,0,-1,E(5)+E(5)^4,E(5)^2+E(5)^3],
    [GALOIS,[1,2]],[4,0,1,-1,-1],[6,0,0,1,1]],]);
    ARC("A5","extInfo",["2","2"]);

##### 4.7-4 NotifyCharacterTable

`‣ NotifyCharacterTable`( firstname, filename, othernames ) | ( function )

notifies a new ordinary table to the library. This table has `Identifier` (Reference: Identifier (for character tables)) value firstname, it is contained (in library format, see `PrintToLib` (4.7-3)) in the file with name filename (without suffix `.tbl`), and the names contained in the list othernames are admissible for it.

If the initial part of filename is one of `~/`, `/` or `./` then it is interpreted as an absolute path. Otherwise it is interpreted relative to the `data` directory of the CTblLib package.

`NotifyCharacterTable` modifies the global variable `LIBLIST` (4.6-2) for the current GAP session, after having checked that there is no other library table yet with an admissible name equal to firstname or contained in othernames.

For example, let us change the name `A5` to `icos` wherever it occurs in the file `private.tbl` that was produced above, and then notify the "new" table in this file as follows. (The name change is needed because GAP knows already a table with name `A5` and would not accept to add another table with this name.)

    gap> NotifyCharacterTable( "icos", "private", [] );
    gap> icos:= CharacterTable( "icos" );
    CharacterTable( "icos" )
    gap> Display( icos );
    icos

         2  2  2  .  .  .
         3  1  .  1  .  .
         5  1  .  .  1  1

           1a 2a 3a 5a 5b
        2P 1a 1a 3a 5b 5a
        3P 1a 2a 1a 5b 5a
        5P 1a 2a 3a 1a 1a

    X.1     1  1  1  1  1
    X.2     3 -1  .  A *A
    X.3     3 -1  . *A  A
    X.4     4  .  1 -1 -1
    X.5     5  1 -1  .  .

    A = -E(5)-E(5)^4
      = (1-ER(5))/2 = -b5

So the private table is treated as a library table. Note that the table can be accessed only if it has been notified in the current GAP session. For frequently used private tables, it may be reasonable to put the `NotifyCharacterTable` statements into your `gaprc` file (see Reference: The gap.ini and gaprc files), or into a file that is read via the `gaprc` file.

#### 4.8 Sanity Checks for the GAP Character Table Library

The fact that the GAP Character Table Library is designed as an open database (see Chapter 1) makes it especially desirable to have consistency checks available which can be run automatically whenever new data are added.

The file `tst/testall.g` of the package contains `Test` (Reference: Test) statements for executing a collection of such sanity checks; one can run them by calling `ReadPackage( "CTblLib", "tst/testall.g" )`. If no problem occurs then GAP prints only lines starting with one of the following.

    + Input file:
    + GAP4stones:

The examples in the package manual form a part of the tests, they are collected in the file `tst/docxpl.tst` of the package.

The following tests concern only ordinary character tables. In all cases, let tbl be the ordinary character table of a group G, say. The return value is `false` if an error occurred, and `true` otherwise.

`CTblLib.Test.InfoText(` tbl`)`

  checks some properties of the `InfoText` (Reference: InfoText) value of tbl, if available. Currently it is not recommended to use this value programmatically. However, one can rely on the following structure of this value for tables in the GAP Character Table Library.

  - The value is a string that consists of `\n` separated lines.

  - If a line of the form "maximal subgroup of grpname" occurs, where grpname is the name of a character table, then a class fusion from the table in question to that with name grpname is stored.

  - If a line of the form "nth maximal subgroup of grpname" occurs then additionally the name grpname`M`n is admissible for tbl. Furthermore, if the table with name grpname has a `Maxes` (3.7-1) value then tbl is referenced in position n of this list.

`CTblLib.Test.RelativeNames(` tbl`[,` tblname`] )`

  checks some properties of those admissible names for tbl that refer to a related group H, say. Let name be an admissible name for the character table of H. (In particular, name is not an empty string.) Then the following relative names are considered.

  name`M`n

    G is isomorphic with the groups in the n-th class of maximal subgroups of H. An example is `"M12M1"` for the Mathieu group M_11. We consider only cases where name does not contain the letter `x`. For example, `2xM12` denotes the direct product of a cyclic group of order two and the Mathieu group M_12 but not a maximal subgroup of "`2x`". Similarly, `3x2.M22M5` denotes the direct product of a cyclic group of order three and a group in the fifth class of maximal subgroups of 2.M_22 but not a maximal subgroup of "`3x2.M22`".

  name`N`p

    G is isomorphic with the normalizers of the Sylow p-subgroups of H. An example is `"M24N2"` for the (self-normalizing) Sylow 2-subgroup in the Mathieu group M_24.

  name`N`cnam

    G is isomorphic with the normalizers of the cyclic subgroups generated by the elements in the class with the name cnam of H. An example is `"O7(3)N3A"` for the normalizer of an element in the class `3A` of the simple group O_7(3).

  name`C`cnam

    G is isomorphic with the groups in the centralizers of the elements in the class with the name cnam of H. An example is `"M24C2A"` for the centralizer of an element in the class `2A` in the Mathieu group M_24.

  In these cases, `CTblLib.Test.RelativeNames` checks whether a library table with the admissible name name exists and a class fusion to tbl is stored on this table.

  In the case of Sylow p-normalizers, it is also checked whether G contains a normal Sylow p-subgroup of the same order as the Sylow p-subgroups in H. If the normal Sylow p-subgroup of G is cyclic then it is also checked whether G is the full Sylow p-normalizer in H. (In general this information cannot be read off from the character table of H).

  In the case of normalizers (centralizers) of cyclic subgroups, it is also checked whether H really normalizes (centralizes) a subgroup of the given order, and whether the class fusion from tbl to the table of H is compatible with the relative name.

  If the optional argument tblname is given then only this name is tested. If there is only one argument then all admissible names for tbl are tested.

`CTblLib.Test.FindRelativeNames(` tbl`)`

  runs over the class fusions stored on tbl. If tbl is the full centralizer/normalizer of a cyclic subgroup in the table to which the class fusion points then the function proposes to make the corresponding relative name an admissible name for tbl.

`CTblLib.Test.PowerMaps(` tbl`)`

  checks whether all p-th power maps are stored on tbl, for prime divisors p of the order of G, and whether they are correct. (This includes the information about uniqueness of the power maps.)

`CTblLib.Test.TableAutomorphisms(` tbl`)`

  checks whether the table automorphisms are stored on tbl, and whether they are correct. Also all available Brauer tables of tbl are checked.

`CTblLib.Test.CompatibleFactorFusions(` tbl`)`

  checks whether triangles and quadrangles of factor fusions from tbl to other library tables commute (where the entries in the list `CTblLib.IgnoreFactorFusionsCompatibility` are excluded from the tests), and whether the factor fusions commute with the actions of corresponding outer automorphisms.

`CTblLib.Test.FactorsModPCore(` tbl`)`

  checks, for all prime divisors p of the order of G, whether the factor fusion to the character table of G/O_p(G) is stored on tbl.

  Note that if G is not p-solvable and O_p(G) is nontrivial then we can compute the p-modular Brauer table of G if that of the factor group G/O_p(G) is available. The availability of this table is indicated via the availability of the factor fusion from tbl.

`CTblLib.Test.Fusions(` tbl`)`

  checks the class fusions that are stored on the table tbl: No duplicates shall occur, each subgroup fusion or factor fusion is tested using `CTblLib.Test.SubgroupFusion` or `CTblLib.Test.FactorFusion`, respectively, and a fusion to the table of marks for tbl is tested using `CTblLib.Test.FusionToTom`.

`CTblLib.Test.Maxes(` tbl`)`

  checks for those character tables tbl that have the `Maxes` (3.7-1) set whether the character tables with the given names are really available, that they are ordered w.r.t. non-increasing group order, and that the fusions into tbl are stored.

`CTblLib.Test.ClassParameters(` tbl`)`

  checks the compatibility of class parameters of alternating and symmetric groups (partitions describing cycle structures), using the underlying group stored in the corresponding table of marks.

`CTblLib.Test.Constructions(` tbl`)`

  checks the `ConstructionInfoCharacterTable` (3.7-4) status for the table tbl: If this attribute value is set then tests depending on this value are executed; if this attribute is not set then it is checked whether a description of tbl via a construction would be appropriate.

`CTblLib.Test.GroupForGroupInfo(` tbl`)`

  checks that the entries in the list returned by `GroupInfoForCharacterTable` (3.3-1) fit to the character table tbl.

The following tests concern only modular character tables. In all cases, let modtbl be a Brauer character table of a group G, say.

`CTblLib.Test.BlocksInfo(` modtbl`)`

  checks whether the decomposition matrices of all blocks of the Brauer table modtbl are integral, as well as the inverses of their restrictions to basic sets.

`CTblLib.Test.TensorDecomposition(` modtbl`)`

  checks whether the tensor products of irreducible Brauer characters of the Brauer table modtbl decompose into Brauer characters.

`CTblLib.Test.Indicators(` modtbl`)`

  checks the 2-nd indicators of the Brauer table modtbl: The indicator of a Brauer character is zero iff it has at least one nonreal value. In odd characteristic, the indicator of an irreducible Brauer character is equal to the indicator of any ordinary irreducible character that contains it as a constituent, with odd multiplicity. In characteristic two, we test that all nontrivial real irreducible Brauer characters have even degree, and that irreducible Brauer characters with indicator -1 lie in the principal block.

`CTblLib.Test.FactorBlocks(` modtbl`)`

  If the Brauer table modtbl is encoded using references to tables of factor groups then we must make sure that the irreducible characters of the underlying ordinary table and the factors in question are sorted compatibly. (Note that we simply take over the block information about the factors, without applying an explicit mapping.)

#### 4.9 Maintenance of the GAP Character Table Library

It is of course desirable that the information in the GAP Character Table Library is consistent with related data. For example, the ordering of the classes of maximal subgroups stored in the `Maxes` (3.7-1) list of the character table of a group G, say, should correspond to the ordering shown for G in the Atlas of Finite Groups [CCNPW85], to the ordering of maximal subgroups used for G in the AtlasRep, and to the ordering of maximal subgroups in the table of marks of G. The fact that the related data collections are developed independently makes it difficult to achieve this kind of consistency. Sometimes it is unavoidable to "adjust" data of the GAP Character Table Library to external data.

An important issue is the consistency of class fusions. Usually such fusions are determined only up to table automorphisms, and one candidate can be chosen. However, other conditions such as known Brauer tables may restrict the choice. The point is that there are class fusions which predate the availability of Brauer tables in the Character Table Library (in fact many of them have been inherited from the table library of the CAS system), but they are not compatible with the Brauer tables. For example, there are four possible class fusion from M_23 into Co_3, which lie in one orbit under the relevant groups of table automorphisms; two of these maps are not compatible with the 3-modular Brauer tables of M_23 and Co_3, and unfortunately the class fusion that was stored on the CAS tables –and that was available in version 1.0 of the GAP Character Table Library– was one of the not compatible maps. One could argue that the class fusion has older rights, and that the Brauer tables should be adjusted to them, but the Brauer tables are published in the Atlas of Brauer Characters [JLPW95], which is an accepted standard.

[Top of Book] [Contents] [Previous Chapter] [Next Chapter]
Goto Chapter: Top 1 2 3 4 5 6 Bib Ind

generated by GAPDoc2HTML