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

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

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

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

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

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.

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.

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

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

`‣ 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

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

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 "(IsInt and IsPosRat)">, 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" )

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, ρ ≠ 0, τ ≠ 0, ρ ≠ τ }

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 )

The **GAP** character table library contains all character tables of bicyclic extensions of simple groups that are included in the **Atlas** of Finite Groups ([CCN+85], 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.

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

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

and

https://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.

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.

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**).

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

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

For G itself, the ordering of classes and characters in the

**GAP**table coincides with the one in the**Atlas**.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 [CCN+85, 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.

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 [CCN+85, 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.

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

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 [CCN+85, 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.

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.

`‣ 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 [CCN+85] 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 [CCN+85, 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.

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**.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**.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+}" ]

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

.

One of the predecessors of **GAP** was **CAS** (*C*haracter *A*lgorithm *S*ystem, 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**.

`‣ 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" )

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.

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

of the **CTblLib** package, 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.

The way how the functions `DisplayAtlasContents`

(3.5-6), `DisplayAtlasInfo`

(AtlasRep: DisplayAtlasInfo), `DisplayAtlasMap`

(3.5-8), and `DisplayCTblLibInfo`

(3.5-1) show tabular information can be customized via the user preference `"DisplayFunction"`

of the **AtlasRep** package, see Section AtlasRep: User preference DisplayFunction.

`MagmaPath`

This preference describes the path for calling **MAGMA**. An empty string (the default) means that **MAGMA** is not available.

This preference is used by `CharacterTableComputedByMagma`

(6.5-3).

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

comment lines, starting with a hash character

`#`

in the first column,an assignment to a component of

`LIBTABLE.LOADSTATUS`

, at the end of the file, andfunction 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.

`‣ LIBLIST` | ( global variable ) |

**GAP**'s knowledge about the ordinary character tables in the **GAP** Character Table Library is given by several JSON format files that get evaluated when the file `gap4/ctprimar.g`

(the "primary file" of the character table library) is read. These files can be produced from the data files, see Section 4.6-1.

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`

,`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).

`‣ 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

**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-4).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-5).

`‣ 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`

.

`‣ 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" ]);

`‣ LibraryFusionTblToTom` ( 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 of marks, or this table itself,

`map`

the fusion map, a list of image positions,

`text`

(optional)a string describing properties of the fusion, and

`perm`

(optional)a permutation,

`LibraryFusionTblToTom`

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

The meaning of the component `perm`

is as follows. Let `prim` be the primitive permutation characters obtained by computing the `PermCharsTom`

(Reference: PermCharsTom via fusion map) value of the tables of marks, taking the sublist at the positions in the first component of the `MaximalSubgroupsTom`

(Reference: MaximalSubgroupsTom) value of the tables of marks, and restricting these lists via the `map`

component. Permuting `prim` with the `perm`

component via `Permuted`

(Reference: Permuted) yields the list of permutation characters obtained by inducing the trivial characters of the subgroups given by the `Maxes`

(3.7-1) value of the character table. If the component `perm`

is not present and if the character table has the attribute `Maxes`

(3.7-1) set then the two ways of computing the primitive permutation characters yield the same list.

If `name` is a character table then its `Identifier`

(Reference: Identifier for character tables) value is used as the corresponding string.

gap> tbl:= CharacterTable( "A5" ); CharacterTable( "A5" ) gap> tom:= TableOfMarks( "A5" ); TableOfMarks( "A5" ) gap> fus:= PossibleFusionsCharTableTom( tbl, tom ); [ [ 1, 2, 3, 5, 5 ] ] gap> fusion:= rec( name:= tom, map:= fus[1], text:= "unique" );; gap> Print( LibraryFusionTblToTom( "A5", fusion ) ); ARC("A5","tomfusion",rec(name:="A5",map:=[1,2,3,5,5],text:=[ "unique" ]));

`‣ 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 (see Section 4.6-1).

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

`‣ 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-4)) 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.

`‣ NotifyCharacterTables` ( list ) | ( function ) |

notifies several new ordinary tables to the library. The argument `list` must be a dense list in which each entry is a lists of the form `[ firstname, filename, othernames ]`

, with the same meaning as the arguments of `NotifyCharacterTable`

(4.7-5).

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 get 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`

nG 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`

pG 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`

cnamG 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`

cnamG 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 those prime divisors p of the order of G such that G is not p-solvable, 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.TablesOfSymmetricGroup(`

n`)`

checks that the class parameters and character parameters of the two character tables of the symmetric group of degree n (from the

**Atlas**and from the**SpinSym**package) are consistent. The interesting values of`n`are in`[ 5 .. 13 ]`

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

tbl`)`

checks whether the attribute

`ExtensionInfoCharacterTable`

(3.7-3) is known for all nonabelian simple character tables that are not duplicates.`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.)

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 [CCN+85], 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.

generated by GAPDoc2HTML