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 groupsfor Atlas tables (see Section 4.3),
origin: Ostermannfor tables contained in [Ost86],
origin: CAS libraryfor any table of the CAS table library that is contained neither in the Atlas nor in [Ost86], and
origin: Hanrath libraryfor 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_{22}N2\), 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 \in 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 \in 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.
centralizerslist of functions, one for each class type \(t\), with arguments \(q\) and \(p_t\), returning the centralizer order of the class \([t,p_t]\),
charparamlist of functions, one for each character type \(t\), with argument \(q\), returning the list of character parameters of type \(t\),
classparamlist of functions, one for each class type \(t\), with argument \(q\), returning the list of class parameters of type \(t\),
classtextlist 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),
domainfunction of \(q\) returning true if \(q\) is a valid parameter, and false otherwise,
identifieridentifier string of the generic table,
irreducibleslist 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\),
isGenericTablealways true
libinforecord with components firstname (Identifier (Reference: Identifier for character tables) value of the table) and othernames (list of other admissible names)
matrixfunction of \(q\) returning the matrix of irreducibles of \(G_q\),
orderslist 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\),
powermaplist 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]\),
sizefunction of \(q\) returning the order of \(G_q\),
specializednamefunction of \(q\) returning the Identifier (Reference: Identifier for character tables) value of the table of \(G_q\),
textstring 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 = \langle x \rangle\) of order \(q\), there is one type of classes. The class parameters are integers \(k \in \{ 0, \ldots, q-1 \}\), the class with parameter \(k\) consists of the group element \(x^k\). Group order and centralizer orders are the identity function \(q \mapsto 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 \bmod q)]\).
There is one type of characters, with parameters \(l \in \{ 0, \ldots, q-1 \}\); for \(e_q\) a primitive complex \(q\)-th root of unity, the character values are \(\chi_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 - \rho)^2\) for nonzero elements \(\rho \in 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
\[ \{ \{ \rho, \tau \}; \rho, \tau \in F_q, \rho ≠ 0, \tau ≠ 0, \rho ≠ \tau \} \]
for \(t_2\), and with the set \(\{ \{ \epsilon, \epsilon^q \}; \epsilon \in F_{{q^2}} \setminus F_q \}\) for \(t_4\).
The centralizer order functions are \(q \mapsto (q^2-1)(q^2-q)\) for type \(t_1\), \(q \mapsto (q-1)^2\) for type \(t_2\), \(q \mapsto q(q-1)\) for type \(t_3\), and \(q \mapsto q^2-1\) for type \(t_4\).
The representative order function of \(t_1\) maps \((q, \rho)\) to the order of \(\rho\) in \(F_q\), that of \(t_2\) maps \((q, \{ \rho, \tau \})\) to the least common multiple of the orders of \(\rho\) and \(\tau\).
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 \(\chi\) of \(G\) extends to \(G.a\) then the different extensions \(\chi^0, \chi^1, \ldots, \chi^{{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 \leq 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 \(\chi\) by \(\varphi\).
First consider only downward extensions \(m.G\) of a simple group \(G\). If \(m \leq 2\) then only labels of the form \(\chi_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 \geq 3\) are of the form \(\chi_i\), \(\chi_i^*\), or \(\chi_i^{{*k}}\), which means the \(i\)-th character printed in the Atlas, the unique character that is not printed and for which \(\chi_i\) acts as proxy (see [CCN+85, Chapter 7, Sections 8 and 19]), and the image of the printed character \(\chi_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 \(\chi_i\) of \(m.G\) extends to \(m.G.a\) then the \(a^\prime\) extensions are denoted by \(\chi_{{i,0}}, \chi_{{i,1}}, \ldots, \chi_{{i,a^\prime}}\), where \(\chi_{{i,0}}\) is the character whose values are printed in the Atlas.
The label \(\chi_{{i_1 + i_2 + \cdots + i_a}}\) means that \(a\) different characters \(\chi_{{i_1}}, \chi_{{i_2}}, \ldots, \chi_{{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 \(\chi_{{i_1+}}\). Note that \(i_2, i_3, \ldots, i_a\) can be read off from the fusion signs in the Atlas.
Finally, the label \(\chi_{{i_1,j_1 + i_2,j_2 + \cdots + i_{{a^\prime}},j_{{a^\prime}}}}\) means that the characters \(\chi_{{i_1}}, \chi_{{i_2}}, \ldots, \chi_{{i_{{a^\prime}}}}\) of \(m.G\) extend to a group that lies properly between \(m.G\) and \(m.G.a\), and the extensions \(\chi_{{i_1, j_1}}, \chi_{{i_2, j_2}}, \ldots \chi_{{i_{{a^\prime}},j_{{a^\prime}}}}\) 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 \(\chi_{{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 \(\chi_1\). X.3, X.4 extend the proxy character \(\chi_2\). X.5, X.6 extend the not printed character with proxy \(\chi_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 \(\chi_1\), X.4 to X.6 extend \(\chi_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 \(\chi_1, \chi_2\), respectively; X.3, X.5 correspond to the proxies \(\chi_3\), \(\chi_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 \cong D_6\) and \(6.G.2 \cong D_{12}\).
In \(3.G.2\), the characters X.1, X.2 extend \(\chi_1\); \(\chi_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 \(\chi_1\), \(\chi_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 \(\chi_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 \cong A_4\), the characters \(\chi_2\), \(\chi_3\), and \(\chi_4\) fuse, and the classes 2A, 2B and 2C collapse. For getting the table of \(2.G \cong Q_8\), one just has to split the class 2A and adjust the representative orders. Finally, the table of \(2.G.3 \cong SL_2(3)\) is given; the class fusion corresponding to the injection \(2.G \hookrightarrow 2.G.3\) is [ 1, 2, 3, 3, 3 ], and the factor fusion corresponding to the epimorphism \(2.G.3 \rightarrow G.3\) is [ 1, 1, 2, 3, 3, 4, 4 ].
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.
‣ 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
namethe name of the CAS table,
permchars and permclassespermutations 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
textthe 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.
MagmaPathThis 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, and
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.
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).
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.
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.
firstnamesthe list of Identifier (Reference: Identifier for character tables) values of the ordinary tables,
filesthe list of filenames containing the data of ordinary tables,
filenamesa 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,
fusionsourcea 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,
allnamesa list of all admissible names of ordinary library tables,
positiona list that stores at position \(i\) the position in firstnames of the identifier of the table with the \(i\)-th admissible name in allnames,
simpleinfoa 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,
sporadicSimplea list of identifiers of the tables of the \(26\) sporadic simple groups, and
GENERICa record with information about generic tables (see Section 4.2).
‣ LibInfoCharacterTable( tblname ) | ( function ) |
is a record with the components
firstNamethe Identifier (Reference: Identifier for character tables) value of the library table for which tblname is an admissible name, and
fileNamethe 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
namethe identifier of the destination table, or this table itself,
mapthe 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
namethe identifier of the destination table of marks, or this table itself,
mapthe 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 "\(n\)th 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.
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".
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}\).
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)\).
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 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