GAP (ref) - Chapter 71: Character Tables

Goto Chapter: Top 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 Bib Ind
[Top of Book] [Contents] [Previous Chapter] [Next Chapter]

[MathJax off]

71 Character Tables
71.1 Some Remarks about Character Theory in GAP
71.2 History of Character Theory Stuff in GAP
71.3 Creating Character Tables
71.3-1 CharacterTable
71.3-2 BrauerTable
71.3-3 CharacterTableRegular
71.3-4 SupportedCharacterTableInfo
71.3-5 ConvertToCharacterTable
71.4 Character Table Categories
71.4-1 IsNearlyCharacterTable
71.4-2 InfoCharacterTable
71.4-3 NearlyCharacterTablesFamily
71.5 Conventions for Character Tables
71.6 The Interface between Character Tables and Groups
71.6-1 UnderlyingGroup
71.6-2 ConjugacyClasses
71.6-3 IdentificationOfConjugacyClasses
71.6-4 CharacterTableWithStoredGroup
71.6-5 CompatibleConjugacyClasses
71.7 Operators for Character Tables
71.8 Attributes and Properties for Groups and Character Tables
71.8-1 CharacterDegrees
71.8-2 Irr
71.8-3 LinearCharacters
71.8-4 OrdinaryCharacterTable
71.8-5 Group Operations Applicable to Character Tables
71.9 Attributes and Properties only for Character Tables
71.9-1 OrdersClassRepresentatives
71.9-2 SizesCentralizers
71.9-3 SizesConjugacyClasses
71.9-4 AutomorphismsOfTable
71.9-5 UnderlyingCharacteristic
71.9-6 Class Names and Character Names
71.9-7 Class Parameters and Character Parameters
71.9-8 Identifier
71.9-9 InfoText
71.9-10 InverseClasses
71.9-11 RealClasses
71.9-12 ClassOrbit
71.9-13 ClassRoots
71.10 Normal Subgroups Represented by Lists of Class Positions
71.10-1 ClassPositionsOfNormalSubgroups
71.10-2 ClassPositionsOfAgemo
71.10-3 ClassPositionsOfCentre
71.10-4 ClassPositionsOfDirectProductDecompositions
71.10-5 ClassPositionsOfDerivedSubgroup
71.10-6 ClassPositionsOfElementaryAbelianSeries
71.10-7 ClassPositionsOfFittingSubgroup
71.10-8 ClassPositionsOfLowerCentralSeries
71.10-9 ClassPositionsOfUpperCentralSeries
71.10-10 ClassPositionsOfSolvableRadical
71.10-11 ClassPositionsOfSupersolvableResiduum
71.10-12 ClassPositionsOfPCore
71.10-13 ClassPositionsOfNormalClosure
71.11 Operations Concerning Blocks
71.11-1 PrimeBlocks
71.11-2 SameBlock
71.11-3 BlocksInfo
71.11-4 DecompositionMatrix
71.11-5 LaTeXStringDecompositionMatrix
71.12 Other Operations for Character Tables
71.12-1 Index
71.12-2 IsInternallyConsistent
71.12-3 IsPSolvableCharacterTable
71.12-4 IsClassFusionOfNormalSubgroup
71.12-5 Indicator
71.12-6 NrPolyhedralSubgroups
71.12-7 ClassMultiplicationCoefficient
71.12-8 ClassStructureCharTable
71.12-9 MatClassMultCoeffsCharTable
71.13 Printing Character Tables
71.13-1 ViewObj
71.13-2 PrintObj
71.13-3 Display
71.13-4 DisplayOptions
71.13-5 PrintCharacterTable
71.14 Computing the Irreducible Characters of a Group
71.14-1 IrrDixonSchneider
71.14-2 IrrConlon
71.14-3 IrrBaumClausen
71.14-4 IrreducibleRepresentations
71.14-5 IrreducibleRepresentationsDixon
71.15 Representations Given by Modules
71.15-1 IrreducibleModules
71.15-2 AbsolutelyIrreducibleModules
71.15-3 RegularModule
71.16 The Dixon-Schneider Algorithm
71.17 Advanced Methods for Dixon-Schneider Calculations
71.17-1 DixonRecord
71.17-2 DixonInit
71.17-3 DixontinI
71.17-4 DixonSplit
71.17-5 BestSplittingMatrix
71.17-6 DxIncludeIrreducibles
71.17-7 SplitCharacters
71.17-8 IsDxLargeGroup
71.18 Components of a Dixon Record
71.19 An Example of Advanced Dixon-Schneider Calculations
71.20 Constructing Character Tables from Others
71.20-1 CharacterTableDirectProduct
71.20-2 FactorsOfDirectProduct
71.20-3 CharacterTableFactorGroup
71.20-4 CharacterTableIsoclinic
71.20-5 CharacterTableOfNormalSubgroup
71.20-6 CharacterTableWreathSymmetric
71.20-7 CharacterValueWreathSymmetric
71.21 Sorted Character Tables
71.21-1 CharacterTableWithSortedCharacters
71.21-2 SortedCharacters
71.21-3 CharacterTableWithSortedClasses
71.21-4 SortedCharacterTable
71.21-5 ClassPermutation
71.22 Automorphisms and Equivalence of Character Tables
71.22-1 MatrixAutomorphisms
71.22-2 TableAutomorphisms
71.22-3 TransformingPermutations
71.22-4 TransformingPermutationsCharacterTables
71.22-5 FamiliesOfRows
71.23 Storing Normal Subgroup Information
71.23-1 NormalSubgroupClassesInfo
71.23-2 ClassPositionsOfNormalSubgroup
71.23-3 NormalSubgroupClasses
71.23-4 FactorGroupNormalSubgroupClasses

### 71 Character Tables

This chapter describes operations for character tables of finite groups.

Operations for characters (or, more general, class functions) are described in Chapter 72.

For a description of the GAP Library of Character Tables, see the separate manual for the GAP package CTblLib.

Several examples in this chapter require the GAP Character Table Library to be available. If it is not yet loaded then we load it now.

    gap> LoadPackage( "ctbllib" );
    true

#### 71.1 Some Remarks about Character Theory in GAP

It seems to be necessary to state some basic facts –and maybe warnings– at the beginning of the character theory package. This holds for people who are familiar with character theory because there is no global reference on computational character theory, although there are many papers on this topic, such as [NPP84] or [LP91]. It holds, however, also for people who are familiar with GAP because the general concept of domains (see Chapter 12.4) plays no important role here –we will justify this later in this section.

Intuitively, characters (or more generally, class functions) of a finite group \(G\) can be thought of as certain mappings defined on \(G\), with values in the complex number field; the set of all characters of \(G\) forms a semiring, with both addition and multiplication defined pointwise, which is naturally embedded into the ring of generalized (or virtual) characters in the natural way. A \(ℤ\)-basis of this ring, and also a vector space basis of the complex vector space of class functions of \(G\), is given by the irreducible characters of \(G\).

At this stage one could ask where there is a problem, since all these algebraic structures are supported by GAP. But in practice, these structures are of minor importance, compared to individual characters and the character tables themselves (which are not domains in the sense of GAP).

For computations with characters of a finite group \(G\) with \(n\) conjugacy classes, we fix an ordering of the classes, and then identify each class with its position according to this ordering. Each character of \(G\) can be represented by a list of length \(n\) in which the character value for elements of the \(i\)-th class is stored at the \(i\)-th position. Note that we need not know the conjugacy classes of \(G\) physically, even our knowledge of \(G\) may be implicit in the sense that, e.g., we know how many classes of involutions \(G\) has, and which length these classes have, but we never have seen an element of \(G\), or a presentation or representation of \(G\). This allows us to work with the character tables of very large groups, e.g., of the so-called monster, where GAP has (currently) no chance to deal with the group.

As a consequence, also other information involving characters is given implicitly. For example, we can talk about the kernel of a character not as a group but as a list of classes (more exactly: a list of their positions according to the chosen ordering of classes) forming this kernel; we can deduce the group order, the contained cyclic subgroups and so on, but we do not get the group itself.

So typical calculations with characters involve loops over lists of character values. For example, the scalar product of two characters \(\chi\), \(\psi\) of \(G\) given by

\[ [ \chi, \psi ] = \left( \sum_{{g \in G}} \chi(g) \psi(g^{{-1}}) \right) / |G| \]

can be written as

    Sum( [ 1 .. n ], i -> SizesConjugacyClasses( t )[i] * chi[i]
                              * ComplexConjugate( psi[i] ) ) / Size( t );

where `t` is the character table of \(G\), and `chi`, `psi` are the lists of values of \(\chi\), \(\psi\), respectively.

It is one of the advantages of character theory that after one has translated a problem concerning groups into a problem concerning only characters, the necessary calculations are mostly simple. For example, one can often prove that a group is a Galois group over the rationals using calculations with structure constants that can be computed from the character table, and information about (the character tables of) maximal subgroups. When one deals with such questions, the translation back to groups is just an interpretation by the user, it does not take place in GAP.

GAP uses character tables to store information such as class lengths, element orders, the irreducible characters of \(G\) etc. in a consistent way; in the example above, we have seen that `SizesConjugacyClasses` (71.9-3) returns the list of class lengths of its argument. Note that the values of these attributes rely on the chosen ordering of conjugacy classes, a character table is not determined by something similar to generators of groups or rings in GAP where knowledge could in principle be recovered from the generators but is stored mainly for the sake of efficiency.

Note that the character table of a group \(G\) in GAP must not be mixed up with the list of complex irreducible characters of \(G\). The irreducible characters are stored in a character table via the attribute `Irr` (71.8-2).

Two further important instances of information that depends on the ordering of conjugacy classes are power maps and fusion maps. Both are represented as lists of integers in GAP. The \(k\)-th power map maps each class to the class of \(k\)-th powers of its elements, the corresponding list contains at each position the position of the image. A class fusion map between the classes of a subgroup \(H\) of \(G\) and the classes of \(G\) maps each class \(c\) of \(H\) to that class of \(G\) that contains \(c\), the corresponding list contains again the positions of image classes; if we know only the character tables of \(H\) and \(G\) but not the groups themselves, this means with respect to a fixed embedding of \(H\) into \(G\). More about power maps and fusion maps can be found in Chapter 73.

So class functions, power maps, and fusion maps are represented by lists in GAP. If they are plain lists then they are regarded as class functions etc. of an appropriate character table when they are passed to GAP functions that expect class functions etc. For example, a list with all entries equal to 1 is regarded as the trivial character if it is passed to a function that expects a character. Note that this approach requires the character table as an argument for such a function.

One can construct class function objects that store their underlying character table and other attribute values (see Chapter 72). This allows one to omit the character table argument in many functions, and it allows one to use infix operations for tensoring or inducing class functions.

#### 71.2 History of Character Theory Stuff in GAP

GAP provides functions for dealing with group characters since the version GAP 3.1, which was released in March 1992. The reason for adding this branch of mathematics to the topics of GAP was (apart from the usefulness of character theoretic computations in general) the insight that GAP provides an ideal environment for developing the algorithms needed. In particular, it had been decided at Lehrstuhl D für Mathematik that the CAS system (a standalone Fortran program together with a database of character tables, see [NPP84]) should not be developed further and the functionality of CAS should be made available in GAP. The background was that extending CAS (by new Fortran code) had turned out to be much less flexible than writing analogous GAP library code.

For integrating the existing character theory algorithms, GAP's memory management and long integer arithmetic were useful as well as the list handling –it is an important feature of character theoretic methods that questions about groups are translated into manipulations of lists; on the other hand, the datatype of cyclotomics (see Chapter `Cyclotomics` (18.1-2)) was added to the GAP kernel because of the character theory algorithms. For developing further code, also other areas of GAP's library became interesting, such as permutation groups, finite fields, and polynomials.

The development of character theory code for GAP has been supported by several DFG grants, in particular the project Representation Theory of Finite Groups and Finite Dimensional Algebras (until 1991), and the Schwerpunkt Algorithmische Zahlentheorie und Algebra (from 1991 until 1997). Besides that, several Diploma theses at Lehrstuhl D were concerned with the development and/or implementation of algorithms dealing with characters in GAP.

The major contributions can be listed as follows.

- The arithmetic for the cyclotomics data type, following [Zum89], was first implemented by Marco van Meegen; an alternative approach was studied in the diploma thesis of Michael Scherner (see [Sch92]) but was not efficient enough; later Martin Schönert replaced the implementation by a better one.

- The basic routines for characters and character tables were written by Thomas Breuer and Götz Pfeiffer.

- The lattice related functions, such as `LLL` (72.10-4), `OrthogonalEmbeddings` (25.6-1), and `DnLattice` (72.10-8), were implemented by Ansgar Kaup (see [Kau92]).

- Functions for computing possible class fusions, possible power maps, and table automorphisms were written by Thomas Breuer (see [Bre91]).

- Functions for computing possible permutation characters were written by Thomas Breuer (see [Bre91]) and Götz Pfeiffer (see [Pfe91]).

- Functions for computing character tables from groups were written by Alexander Hulpke (Dixon-Schneider algorithm, see [Hul93]) and Hans Ulrich Besche (Baum algorithm and Conlon algorithm, see [Bes92]).

- Functions for dealing with Clifford matrices were written by Ute Schiffer (see [Sch94]).

- Functions for monomiality questions were written by Thomas Breuer and Erzsébet Horváth.

Since then, the code has been maintained and extended further by Alexander Hulpke (code related to his implementation of the Dixon-Schneider algorithm) and Thomas Breuer.

Currently GAP does not provide special functionality for computing Brauer character tables, but there is an interface to the MOC system (see [HJLP]), and the GAP Character Table Library contains many known Brauer character tables.

#### 71.3 Creating Character Tables

There are in general five different ways to get a character table in GAP. You can

1. compute the table from a group,

2. read a file that contains the table data,

3. construct the table using generic formulae,

4. derive it from known character tables, or

5. combine partial information about conjugacy classes, power maps of the group in question, and about (character tables of) some subgroups and supergroups.

In 1., the computation of the irreducible characters is the hardest part; the different algorithms available for this are described in 71.14. Possibility 2. is used for the character tables in the GAP Character Table Library, see the manual of this library. Generic character tables –as addressed by 3.– are described in CTblLib: Generic Character Tables. Several occurrences of 4. are described in 71.20. The last of the above possibilities is currently not supported and will be described in a chapter of its own when it becomes available.

The operation `CharacterTable` (71.3-1) can be used for the cases 1. to 3.

##### 71.3-1 CharacterTable

`‣ CharacterTable`( G[, p] ) | ( operation )

`‣ CharacterTable`( ordtbl, p ) | ( operation )

`‣ CharacterTable`( name[, param] ) | ( operation )

Called with a group G, `CharacterTable` calls the attribute `OrdinaryCharacterTable` (71.8-4). Called with first argument a group G or an ordinary character table ordtbl, and second argument a prime p, `CharacterTable` calls the operation `BrauerTable` (71.3-2).

Called with a string name and perhaps optional parameters param, `CharacterTable` tries to access a character table from the GAP Character Table Library. See the manual of the GAP package CTblLib for an overview of admissible arguments. An error is signalled if this GAP package is not loaded in this case.

Probably the most interesting information about the character table is its list of irreducibles, which can be accessed as the value of the attribute `Irr` (71.8-2). If the argument of `CharacterTable` is a string name then the irreducibles are just read from the library file, therefore the returned table stores them already. However, if `CharacterTable` is called with a group G or with an ordinary character table ordtbl, the irreducible characters are not computed by `CharacterTable`. They are only computed when the `Irr` (71.8-2) value is accessed for the first time, for example when `Display` (6.3-6) is called for the table (see 71.13). This means for example that `CharacterTable` returns its result very quickly, and the first call of `Display` (6.3-6) for this table may take some time because the irreducible characters must be computed at that time before they can be displayed together with other information stored on the character table. The value of the filter `HasIrr` indicates whether the irreducible characters have been computed already.

The reason why `CharacterTable` does not compute the irreducible characters is that there are situations where one only needs the table head, that is, the information about class lengths, power maps etc., but not the irreducibles. For example, if one wants to inspect permutation characters of a group then all one has to do is to induce the trivial characters of subgroups one is interested in; for that, only class lengths and the class fusion are needed. Or if one wants to compute the Molien series (see `MolienSeries` (72.12-1)) for a given complex matrix group, the irreducible characters of this group are in general of no interest.

For details about different algorithms to compute the irreducible characters, see 71.14.

If the group G is given as an argument, `CharacterTable` accesses the conjugacy classes of G and therefore causes that these classes are computed if they were not yet stored (see 71.6).

##### 71.3-2 BrauerTable

`‣ BrauerTable`( ordtbl, p ) | ( operation )

`‣ BrauerTable`( G, p ) | ( operation )

`‣ BrauerTableOp`( ordtbl, p ) | ( operation )

`‣ ComputedBrauerTables`( ordtbl ) | ( attribute )

Called with an ordinary character table ordtbl or a group G, `BrauerTable` returns its p-modular character table if GAP can compute this table, and `fail` otherwise.

The p-modular table can be computed in the following cases.

- The group is p-solvable (see `IsPSolvable` (39.15-26), apply the Fong-Swan Theorem);

- the Sylow p-subgroup of G is cyclic, and all p-modular Brauer characters of G lift to ordinary characters (note that this situation can be detected from the ordinary character table of G);

- the table ordtbl stores information how it was constructed from other tables (as a direct product or as an isoclinic variant, for example), and the Brauer tables of the source tables can be computed;

- ordtbl is a table from the GAP character table library for which also the p-modular table is contained in the table library.

The default method for a group and a prime delegates to `BrauerTable` for the ordinary character table of this group. The default method for ordtbl uses the attribute `ComputedBrauerTables` for storing the computed Brauer table at position p, and calls the operation `BrauerTableOp` for computing values that are not yet known.

So if one wants to install a new method for computing Brauer tables then it is sufficient to install it for `BrauerTableOp`.

The `mod` operator for a character table and a prime (see 71.7) delegates to `BrauerTable`.

##### 71.3-3 CharacterTableRegular

`‣ CharacterTableRegular`( tbl, p ) | ( function )

For an ordinary character table tbl and a prime integer p, `CharacterTableRegular` returns the table head of the p-modular Brauer character table of tbl. This is the restriction of tbl to its p-regular classes, like the return value of `BrauerTable` (71.3-2), but without the irreducible Brauer characters. (In general, these characters are hard to compute, and `BrauerTable` (71.3-2) may return `fail` for the given arguments, for example if tbl is a table from the GAP character table library.)

The returned table head can be used to create p-modular Brauer characters, by restricting ordinary characters, for example when one is interested in approximations of the (unknown) irreducible Brauer characters.

    gap> g:= SymmetricGroup( 4 );
    Sym( [ 1 .. 4 ] )
    gap> tbl:= CharacterTable( g );;  HasIrr( tbl );
    false
    gap> tblmod2:= CharacterTable( tbl, 2 );
    BrauerTable( Sym( [ 1 .. 4 ] ), 2 )
    gap> tblmod2 = CharacterTable( tbl, 2 );
    true
    gap> tblmod2 = BrauerTable( tbl, 2 );
    true
    gap> tblmod2 = BrauerTable( g, 2 );
    true
    gap> libtbl:= CharacterTable( "M" );
    CharacterTable( "M" )
    gap> CharacterTableRegular( libtbl, 2 );
    BrauerTable( "M", 2 )
    gap> BrauerTable( libtbl, 2 );
    fail
    gap> CharacterTable( "Symmetric", 4 );
    CharacterTable( "Sym(4)" )
    gap> ComputedBrauerTables( tbl );
    [ , BrauerTable( Sym( [ 1 .. 4 ] ), 2 ) ]

##### 71.3-4 SupportedCharacterTableInfo

`‣ SupportedCharacterTableInfo` | ( global variable )

`SupportedCharacterTableInfo` is a list that contains at position \(3i-2\) an attribute getter function, at position \(3i-1\) the name of this attribute, and at position \(3i\) a list containing a subset of `[ "character", "class", "mutable" ]`, depending on whether the attribute value relies on the ordering of characters or classes, or whether the attribute value is a mutable list or record.

When (ordinary or Brauer) character table objects are created from records, using `ConvertToCharacterTable` (71.3-5), `SupportedCharacterTableInfo` specifies those record components that shall be used as attribute values; other record components are not be regarded as attribute values in the conversion process.

New attributes and properties can be notified to `SupportedCharacterTableInfo` by creating them with `DeclareAttributeSuppCT` and `DeclarePropertySuppCT` instead of `DeclareAttribute` (13.5-4) and `DeclareProperty` (13.7-5).

##### 71.3-5 ConvertToCharacterTable

`‣ ConvertToCharacterTable`( record ) | ( function )

`‣ ConvertToCharacterTableNC`( record ) | ( function )

Let record be a record. `ConvertToCharacterTable` converts record into a component object (see 79.2) representing a character table. The values of those components of record whose names occur in `SupportedCharacterTableInfo` (71.3-4) correspond to attribute values of the returned character table. All other components of the record simply become components of the character table object.

If inconsistencies in record are detected, `fail` is returned. record must have the component `UnderlyingCharacteristic` bound (cf. `UnderlyingCharacteristic` (71.9-5)), since this decides about whether the returned character table lies in `IsOrdinaryTable` (71.4-1) or in `IsBrauerTable` (71.4-1).

`ConvertToCharacterTableNC` does the same except that all checks of record are omitted.

An example of a conversion from a record to a character table object can be found in Section `PrintCharacterTable` (71.13-5).

#### 71.4 Character Table Categories

##### 71.4-1 IsNearlyCharacterTable

`‣ IsNearlyCharacterTable`( obj ) | ( category )

`‣ IsCharacterTable`( obj ) | ( category )

`‣ IsOrdinaryTable`( obj ) | ( category )

`‣ IsBrauerTable`( obj ) | ( category )

`‣ IsCharacterTableInProgress`( obj ) | ( category )

Every character table like object in GAP lies in the category `IsNearlyCharacterTable`. There are four important subcategories, namely the ordinary tables in `IsOrdinaryTable`, the Brauer tables in `IsBrauerTable`, the union of these two in `IsCharacterTable`, and the incomplete ordinary tables in `IsCharacterTableInProgress`.

We want to distinguish ordinary and Brauer tables because a Brauer table may delegate tasks to the ordinary table of the same group, for example the computation of power maps. A Brauer table is constructed from an ordinary table and stores this table upon construction (see `OrdinaryCharacterTable` (71.8-4)).

Furthermore, `IsOrdinaryTable` and `IsBrauerTable` denote character tables that provide enough information to compute all power maps and irreducible characters (and in the case of Brauer tables to get the ordinary table), for example because the underlying group (see `UnderlyingGroup` (71.6-1)) is known or because the table is a library table (see the manual of the GAP Character Table Library). We want to distinguish these tables from partially known ordinary tables that cannot be asked for all power maps or all irreducible characters.

The character table objects in `IsCharacterTable` are always immutable (see 12.6). This means mainly that the ordering of conjugacy classes used for the various attributes of the character table cannot be changed; see 71.21 for how to compute a character table with a different ordering of classes.

The GAP objects in `IsCharacterTableInProgress` represent incomplete ordinary character tables. This means that not all irreducible characters, not all power maps are known, and perhaps even the number of classes and the centralizer orders are known. Such tables occur when the character table of a group \(G\) is constructed using character tables of related groups and information about \(G\) but for example without explicitly computing the conjugacy classes of \(G\). An object in `IsCharacterTableInProgress` is first of all mutable, so nothing is stored automatically on such a table, since otherwise one has no control of side-effects when a hypothesis is changed. Operations for such tables may return more general values than for other tables, for example class functions may contain unknowns (see Chapter 74) or lists of possible values in certain positions, the same may happen also for power maps and class fusions (see 73.5). Incomplete tables in this sense are currently not supported and will be described in a chapter of their own when they become available. Note that the term incomplete table shall express that GAP cannot compute certain values such as irreducible characters or power maps. A table with access to its group is therefore always complete, also if its irreducible characters are not yet stored.

    gap> g:= SymmetricGroup( 4 );;
    gap> tbl:= CharacterTable( g );  modtbl:= tbl mod 2;
    CharacterTable( Sym( [ 1 .. 4 ] ) )
    BrauerTable( Sym( [ 1 .. 4 ] ), 2 )
    gap> IsCharacterTable( tbl );  IsCharacterTable( modtbl );
    true
    true
    gap> IsBrauerTable( modtbl );  IsBrauerTable( tbl );
    true
    false
    gap> IsOrdinaryTable( tbl );  IsOrdinaryTable( modtbl );
    true
    false
    gap> IsCharacterTable( g );  IsCharacterTable( Irr( g ) );
    false
    false

##### 71.4-2 InfoCharacterTable

`‣ InfoCharacterTable` | ( info class )

is the info class (see 7.4) for computations with character tables.

##### 71.4-3 NearlyCharacterTablesFamily

`‣ NearlyCharacterTablesFamily` | ( family )

Every character table like object lies in this family (see 13.1).

#### 71.5 Conventions for Character Tables

The following few conventions should be noted.

- The class of the identity element is expected to be the first one; thus the degree of a character is the character value at position \(1\).

- The trivial character of a character table need not be the first in the list of irreducibles.

- Most functions that take a character table as an argument and work with characters expect these characters as an argument, too. For some functions, the list of irreducible characters serves as the default, i.e, the value of the attribute `Irr` (71.8-2); in these cases, the `Irr` (71.8-2) value is automatically computed if it was not yet known.

- For a stored class fusion, the image table is denoted by its `Identifier` (71.9-8) value; each library table has a unique identifier by which it can be accessed (see CTblLib: Accessing a Character Table from the Library in the manual for the GAP Character Table Library), tables constructed from groups get an identifier that is unique in the current GAP session.

#### 71.6 The Interface between Character Tables and Groups

For a character table with underlying group (see `UnderlyingGroup` (71.6-1)), the interface between table and group consists of three attribute values, namely the group, the conjugacy classes stored in the table (see `ConjugacyClasses` (71.6-2) below) and the identification of the conjugacy classes of table and group (see `IdentificationOfConjugacyClasses` (71.6-3) below).

Character tables constructed from groups know these values upon construction, and for character tables constructed without groups, these values are usually not known and cannot be computed from the table.

However, given a group \(G\) and a character table of a group isomorphic to \(G\) (for example a character table from the GAP table library), one can tell GAP to compute a new instance of the given table and to use it as the character table of \(G\) (see `CharacterTableWithStoredGroup` (71.6-4)).

Tasks may be delegated from a group to its character table or vice versa only if these three attribute values are stored in the character table.

##### 71.6-1 UnderlyingGroup

`‣ UnderlyingGroup`( ordtbl ) | ( attribute )

For an ordinary character table ordtbl of a finite group, the group can be stored as value of `UnderlyingGroup`.

Brauer tables do not store the underlying group, they access it via the ordinary table (see `OrdinaryCharacterTable` (71.8-4)).

##### 71.6-2 ConjugacyClasses

`‣ ConjugacyClasses`( tbl ) | ( attribute )

For a character table tbl with known underlying group \(G\), the `ConjugacyClasses` value of tbl is a list of conjugacy classes of \(G\). All those lists stored in the table that are related to the ordering of conjugacy classes (such as sizes of centralizers and conjugacy classes, orders of representatives, power maps, and all class functions) refer to the ordering of this list.

This ordering need not coincide with the ordering of conjugacy classes as stored in the underlying group of the table (see 71.21). One reason for this is that otherwise we would not be allowed to use a library table as the character table of a group for which the conjugacy classes are stored already. (Another, less important reason is that we can use the same group as underlying group of character tables that differ only w.r.t. the ordering of classes.)

The class of the identity element must be the first class (see 71.5).

If tbl was constructed from \(G\) then the conjugacy classes have been stored at the same time when \(G\) was stored. If \(G\) and tbl have been connected later than in the construction of tbl, the recommended way to do this is via `CharacterTableWithStoredGroup` (71.6-4). So there is no method for `ConjugacyClasses` that computes the value for tbl if it is not yet stored.

Brauer tables do not store the (\(p\)-regular) conjugacy classes, they access them via the ordinary table (see `OrdinaryCharacterTable` (71.8-4)) if necessary.

##### 71.6-3 IdentificationOfConjugacyClasses

`‣ IdentificationOfConjugacyClasses`( tbl ) | ( attribute )

For an ordinary character table tbl with known underlying group \(G\), `IdentificationOfConjugacyClasses` returns a list of positive integers that contains at position \(i\) the position of the \(i\)-th conjugacy class of tbl in the `ConjugacyClasses` (71.6-2) value of \(G\).

    gap> g:= SymmetricGroup( 4 );;
    gap> repres:= [ (1,2), (1,2,3), (1,2,3,4), (1,2)(3,4), () ];;
    gap> ccl:= List( repres, x -> ConjugacyClass( g, x ) );;
    gap> SetConjugacyClasses( g, ccl );
    gap> tbl:= CharacterTable( g );;   # the table stores already the values
    gap> HasConjugacyClasses( tbl );  HasUnderlyingGroup( tbl );
    true
    true
    gap> UnderlyingGroup( tbl ) = g;
    true
    gap> HasIdentificationOfConjugacyClasses( tbl );
    true
    gap> IdentificationOfConjugacyClasses( tbl );
    [ 5, 1, 2, 3, 4 ]

##### 71.6-4 CharacterTableWithStoredGroup

`‣ CharacterTableWithStoredGroup`( G, tbl[, info] ) | ( function )

Let G be a group and tbl a character table of (a group isomorphic to) G, such that G does not store its `OrdinaryCharacterTable` (71.8-4) value. `CharacterTableWithStoredGroup` calls `CompatibleConjugacyClasses` (71.6-5), trying to identify the classes of G with the columns of tbl.

If this identification is unique up to automorphisms of tbl (see `AutomorphismsOfTable` (71.9-4)) then tbl is stored as `CharacterTable` (71.3-1) value of G, and a new character table is returned that is equivalent to tbl, is sorted in the same way as tbl, and has the values of `UnderlyingGroup` (71.6-1), `ConjugacyClasses` (71.6-2), and `IdentificationOfConjugacyClasses` (71.6-3) set.

Otherwise, i.e., if GAP cannot identify the classes of G up to automorphisms of tbl, `fail` is returned.

If a record is present as the third argument info, its meaning is the same as the optional argument arec for `CompatibleConjugacyClasses` (71.6-5).

If a list is entered as third argument info it is used as value of `IdentificationOfConjugacyClasses` (71.6-3), relative to the `ConjugacyClasses` (71.6-2) value of G, without further checking, and the corresponding character table is returned.

##### 71.6-5 CompatibleConjugacyClasses

`‣ CompatibleConjugacyClasses`( [G, ccl, ]tbl[, arec] ) | ( operation )

If the arguments G and ccl are present then ccl must be a list of the conjugacy classes of the group G, and tbl the ordinary character table of G. Then `CompatibleConjugacyClasses` returns a list \(l\) of positive integers that describes an identification of the columns of tbl with the conjugacy classes ccl in the sense that \(l[i]\) is the position in ccl of the class corresponding to the \(i\)-th column of tbl, if this identification is unique up to automorphisms of tbl (see `AutomorphismsOfTable` (71.9-4)); if GAP cannot identify the classes, `fail` is returned.

If tbl is the first argument then it must be an ordinary character table, and `CompatibleConjugacyClasses` checks whether the columns of tbl can be identified with the conjugacy classes of a group isomorphic to that for which tbl is the character table; the return value is a list of all those sets of class positions for which the columns of tbl cannot be distinguished with the invariants used, up to automorphisms of tbl. So the identification is unique if and only if the returned list is empty.

The usual approach is that one first calls `CompatibleConjugacyClasses` in the second form for checking quickly whether the first form will be successful, and only if this is the case the more time consuming calculations with both group and character table are done.

The following invariants are used.

1. element orders (see `OrdersClassRepresentatives` (71.9-1)),

2. class lengths (see `SizesConjugacyClasses` (71.9-3)),

3. power maps (see `PowerMap` (73.1-1), `ComputedPowerMaps` (73.1-1)),

4. symmetries of the table (see `AutomorphismsOfTable` (71.9-4)).

If the optional argument arec is present then it must be a record whose components describe additional information for the class identification. The following components are supported.

`natchar`

  if \(G\) is a permutation group or matrix group then the value of this component is regarded as the list of values of the natural character (see `NaturalCharacter` (72.7-2)) of G, w.r.t. the ordering of classes in tbl,

`bijection`

  a list describing a partial bijection; the \(i\)-th entry, if bound, is the position of the \(i\)-th conjugacy class of tbl in the list ccl.

    gap> g:= AlternatingGroup( 5 );
    Alt( [ 1 .. 5 ] )
    gap> tbl:= CharacterTable( "A5" );
    CharacterTable( "A5" )
    gap> HasUnderlyingGroup( tbl );  HasOrdinaryCharacterTable( g );
    false
    false
    gap> CompatibleConjugacyClasses( tbl );   # unique identification
    [  ]
    gap> new:= CharacterTableWithStoredGroup( g, tbl );
    CharacterTable( Alt( [ 1 .. 5 ] ) )
    gap> Irr( new ) = Irr( tbl );
    true
    gap> HasConjugacyClasses( new );  HasUnderlyingGroup( new );
    true
    true
    gap> IdentificationOfConjugacyClasses( new );
    [ 1, 2, 3, 4, 5 ]
    gap> # Here is an example where the identification is not unique.
    gap> CompatibleConjugacyClasses( CharacterTable( "J2" ) );
    [ [ 17, 18 ], [ 9, 10 ] ]

#### 71.7 Operators for Character Tables

The following infix operators are defined for character tables.

`tbl1 * tbl2`

  the direct product of two character tables (see `CharacterTableDirectProduct` (71.20-1)),

`tbl / list`

  the table of the factor group modulo the normal subgroup spanned by the classes in the list list (see `CharacterTableFactorGroup` (71.20-3)),

`tbl mod p`

  the p-modular Brauer character table corresponding to the ordinary character table tbl (see `BrauerTable` (71.3-2)),

`tbl.name`

  the position of the class with name name in tbl (see `ClassNames` (71.9-6)).

#### 71.8 Attributes and Properties for Groups and Character Tables

Several attributes for groups are valid also for character tables.

These are first those that have the same meaning for both the group and its character table, and whose values can be read off or computed, respectively, from the character table, such as `Size` (71.8-5), `IsAbelian` (71.8-5), or `IsSolvable` (71.8-5).

Second, there are attributes whose meaning for character tables is different from the meaning for groups, such as `ConjugacyClasses` (71.6-2).

##### 71.8-1 CharacterDegrees

`‣ CharacterDegrees`( G[, p] ) | ( attribute )

`‣ CharacterDegrees`( tbl ) | ( attribute )

In the first form, `CharacterDegrees` returns a collected list of the degrees of the absolutely irreducible characters of the group G; the optional second argument p must be either zero or a prime integer denoting the characteristic, the default value is zero. In the second form, tbl must be an (ordinary or Brauer) character table, and `CharacterDegrees` returns a collected list of the degrees of the absolutely irreducible characters of tbl.

(The default method for the call with only argument a group is to call the operation with second argument `0`.)

For solvable groups, the default method is based on [Con90b].

    gap> CharacterDegrees( SymmetricGroup( 4 ) );
    [ [ 1, 2 ], [ 2, 1 ], [ 3, 2 ] ]
    gap> CharacterDegrees( SymmetricGroup( 4 ), 2 );
    [ [ 1, 1 ], [ 2, 1 ] ]
    gap> CharacterDegrees( CharacterTable( "A5" ) );
    [ [ 1, 1 ], [ 3, 2 ], [ 4, 1 ], [ 5, 1 ] ]
    gap> CharacterDegrees( CharacterTable( "A5" ) mod 2 );
    [ [ 1, 1 ], [ 2, 2 ], [ 4, 1 ] ]

##### 71.8-2 Irr

`‣ Irr`( G[, p] ) | ( attribute )

`‣ Irr`( tbl ) | ( attribute )

Called with a group G, `Irr` returns the irreducible characters of the ordinary character table of G. Called with a group G and a prime integer p, `Irr` returns the irreducible characters of the p-modular Brauer table of G. Called with an (ordinary or Brauer) character table tbl, `Irr` returns the list of all complex absolutely irreducible characters of tbl.

For a character table tbl with underlying group, `Irr` may delegate to the group. For a group G, `Irr` may delegate to its character table only if the irreducibles are already stored there.

(If G is p-solvable (see `IsPSolvable` (39.15-26)) then the p-modular irreducible characters can be computed by the Fong-Swan Theorem; in all other cases, there may be no method.)

Note that the ordering of columns in the `Irr` matrix of the group G refers to the ordering of conjugacy classes in the `CharacterTable` (71.3-1) value of G, which may differ from the ordering of conjugacy classes in G (see 71.6). As an extreme example, for a character table obtained from sorting the classes of the `CharacterTable` (71.3-1) value of G, the ordering of columns in the `Irr` matrix respects the sorting of classes (see 71.21), so the irreducibles of such a table will in general not coincide with the irreducibles stored as the `Irr` value of G although also the sorted table stores the group G.

The ordering of the entries in the attribute `Irr` of a group need not coincide with the ordering of its `IrreducibleRepresentations` (71.14-4) value.

    gap> Irr( SymmetricGroup( 4 ) );
    [ Character( CharacterTable( Sym( [ 1 .. 4 ] ) ), [ 1, -1, 1, 1, -1
         ] ), Character( CharacterTable( Sym( [ 1 .. 4 ] ) ),
        [ 3, -1, -1, 0, 1 ] ),
      Character( CharacterTable( Sym( [ 1 .. 4 ] ) ), [ 2, 0, 2, -1, 0 ] )
        , Character( CharacterTable( Sym( [ 1 .. 4 ] ) ),
        [ 3, 1, -1, 0, -1 ] ),
      Character( CharacterTable( Sym( [ 1 .. 4 ] ) ), [ 1, 1, 1, 1, 1 ] )
     ]
    gap> Irr( SymmetricGroup( 4 ), 2 );
    [ Character( BrauerTable( Sym( [ 1 .. 4 ] ), 2 ), [ 1, 1 ] ),
      Character( BrauerTable( Sym( [ 1 .. 4 ] ), 2 ), [ 2, -1 ] ) ]
    gap> Irr( CharacterTable( "A5" ) );
    [ Character( CharacterTable( "A5" ), [ 1, 1, 1, 1, 1 ] ),
      Character( CharacterTable( "A5" ),
        [ 3, -1, 0, -E(5)-E(5)^4, -E(5)^2-E(5)^3 ] ),
      Character( CharacterTable( "A5" ),
        [ 3, -1, 0, -E(5)^2-E(5)^3, -E(5)-E(5)^4 ] ),
      Character( CharacterTable( "A5" ), [ 4, 0, 1, -1, -1 ] ),
      Character( CharacterTable( "A5" ), [ 5, 1, -1, 0, 0 ] ) ]
    gap> Irr( CharacterTable( "A5" ) mod 2 );
    [ Character( BrauerTable( "A5", 2 ), [ 1, 1, 1, 1 ] ),
      Character( BrauerTable( "A5", 2 ),
        [ 2, -1, E(5)+E(5)^4, E(5)^2+E(5)^3 ] ),
      Character( BrauerTable( "A5", 2 ),
        [ 2, -1, E(5)^2+E(5)^3, E(5)+E(5)^4 ] ),
      Character( BrauerTable( "A5", 2 ), [ 4, 1, -1, -1 ] ) ]

##### 71.8-3 LinearCharacters

`‣ LinearCharacters`( G[, p] ) | ( attribute )

`‣ LinearCharacters`( tbl ) | ( attribute )

`LinearCharacters` returns the linear (i.e., degree \(1\)) characters in the `Irr` (71.8-2) list of the group G or the character table tbl, respectively. In the second form, `LinearCharacters` returns the p-modular linear characters of the group G.

For a character table tbl with underlying group, `LinearCharacters` may delegate to the group. For a group G, `LinearCharacters` may delegate to its character table only if the irreducibles are already stored there.

The ordering of linear characters in tbl need not coincide with the ordering of linear characters in the irreducibles of tbl (see `Irr` (71.8-2)).

    gap> LinearCharacters( SymmetricGroup( 4 ) );
    [ Character( CharacterTable( Sym( [ 1 .. 4 ] ) ), [ 1, 1, 1, 1, 1 ] ),
      Character( CharacterTable( Sym( [ 1 .. 4 ] ) ), [ 1, -1, 1, 1, -1
         ] ) ]

##### 71.8-4 OrdinaryCharacterTable

`‣ OrdinaryCharacterTable`( G ) | ( attribute )

`‣ OrdinaryCharacterTable`( modtbl ) | ( attribute )

`OrdinaryCharacterTable` returns the ordinary character table of the group G or the Brauer character table modtbl, respectively.

Since Brauer character tables are constructed from ordinary tables, the attribute value for modtbl is already stored (cf. 71.4).

    gap> OrdinaryCharacterTable( SymmetricGroup( 4 ) );
    CharacterTable( Sym( [ 1 .. 4 ] ) )
    gap> tbl:= CharacterTable( "A5" );;  modtbl:= tbl mod 2;
    BrauerTable( "A5", 2 )
    gap> OrdinaryCharacterTable( modtbl ) = tbl;
    true

##### 71.8-5 Group Operations Applicable to Character Tables

`‣ AbelianInvariants`( tbl ) | ( attribute )

`‣ CommutatorLength`( tbl ) | ( attribute )

`‣ Exponent`( tbl ) | ( attribute )

`‣ IsAbelian`( tbl ) | ( property )

`‣ IsAlmostSimple`( tbl ) | ( property )

`‣ IsCyclic`( tbl ) | ( property )

`‣ IsElementaryAbelian`( tbl ) | ( property )

`‣ IsFinite`( tbl ) | ( property )

`‣ IsMonomial`( tbl ) | ( property )

`‣ IsNilpotent`( tbl ) | ( property )

`‣ IsPerfect`( tbl ) | ( property )

`‣ IsQuasisimple`( tbl ) | ( property )

`‣ IsSimple`( tbl ) | ( property )

`‣ IsSolvable`( tbl ) | ( property )

`‣ IsSporadicSimple`( tbl ) | ( property )

`‣ IsSupersolvable`( tbl ) | ( property )

`‣ IsomorphismTypeInfoFiniteSimpleGroup`( tbl ) | ( attribute )

`‣ NrConjugacyClasses`( tbl ) | ( attribute )

`‣ Size`( tbl ) | ( attribute )

These operations for groups are applicable to character tables and mean the same for a character table as for its underlying group; see Chapter 39 for the definitions. The operations are mainly useful for selecting character tables with certain properties, also for character tables without access to a group.

    gap> tables:= [ CharacterTable( CyclicGroup( 3 ) ),
    >               CharacterTable( SymmetricGroup( 4 ) ),
    >               CharacterTable( AlternatingGroup( 5 ) ),
    >               CharacterTable( SL( 2, 5 ) ) ];;
    gap> List( tables, AbelianInvariants );
    [ [ 3 ], [ 2 ], [  ], [  ] ]
    gap> List( tables, CommutatorLength );
    [ 1, 1, 1, 1 ]
    gap> List( tables, Exponent );
    [ 3, 12, 30, 60 ]
    gap> List( tables, IsAbelian );
    [ true, false, false, false ]
    gap> List( tables, IsAlmostSimple );
    [ false, false, true, false ]
    gap> List( tables, IsCyclic );
    [ true, false, false, false ]
    gap> List( tables, IsFinite );
    [ true, true, true, true ]
    gap> List( tables, IsMonomial );
    [ true, true, false, false ]
    gap> List( tables, IsNilpotent );
    [ true, false, false, false ]
    gap> List( tables, IsPerfect );
    [ false, false, true, true ]
    gap> List( tables, IsQuasisimple );
    [ false, false, true, true ]
    gap> List( tables, IsSimple );
    [ true, false, true, false ]
    gap> List( tables, IsSolvable );
    [ true, true, false, false ]
    gap> List( tables, IsSupersolvable );
    [ true, false, false, false ]
    gap> List( tables, NrConjugacyClasses );
    [ 3, 5, 5, 9 ]
    gap> List( tables, Size );
    [ 3, 24, 60, 120 ]
    gap> IsomorphismTypeInfoFiniteSimpleGroup( CharacterTable( "C5" ) );
    rec( name := "Z(5)", parameter := 5, series := "Z", shortname := "C5"
     )
    gap> IsomorphismTypeInfoFiniteSimpleGroup( CharacterTable( "S3" ) );
    fail
    gap> IsomorphismTypeInfoFiniteSimpleGroup( CharacterTable( "S6(3)" ) );
    rec( name := "C(3,3) = S(6,3)", parameter := [ 3, 3 ], series := "C",
      shortname := "S6(3)" )
    gap> IsomorphismTypeInfoFiniteSimpleGroup( CharacterTable( "O7(3)" ) );
    rec( name := "B(3,3) = O(7,3)", parameter := [ 3, 3 ], series := "B",
      shortname := "O7(3)" )
    gap> IsomorphismTypeInfoFiniteSimpleGroup( CharacterTable( "A8" ) );
    rec( name := "A(8) ~ A(3,2) = L(4,2) ~ D(3,2) = O+(6,2)",
      parameter := 8, series := "A", shortname := "A8" )
    gap> IsomorphismTypeInfoFiniteSimpleGroup( CharacterTable( "L3(4)" ) );
    rec( name := "A(2,4) = L(3,4)", parameter := [ 3, 4 ], series := "L",
      shortname := "L3(4)" )

#### 71.9 Attributes and Properties only for Character Tables

The following three attributes for character tables –`OrdersClassRepresentatives` (71.9-1), `SizesCentralizers` (71.9-2), and `SizesConjugacyClasses` (71.9-3)– would make sense also for groups but are in fact not used for groups. This is because the values depend on the ordering of conjugacy classes stored as the value of `ConjugacyClasses` (71.6-2), and this value may differ for a group and its character table (see 71.6). Note that for character tables, the consistency of attribute values must be guaranteed, whereas for groups, there is no need to impose such a consistency rule.

The other attributes introduced in this section apply only to character tables, not to groups.

##### 71.9-1 OrdersClassRepresentatives

`‣ OrdersClassRepresentatives`( tbl ) | ( attribute )

is a list of orders of representatives of conjugacy classes of the character table tbl, in the same ordering as the conjugacy classes of tbl.

    gap> tbl:= CharacterTable( "A5" );;
    gap> OrdersClassRepresentatives( tbl );
    [ 1, 2, 3, 5, 5 ]

##### 71.9-2 SizesCentralizers

`‣ SizesCentralizers`( tbl ) | ( attribute )

`‣ SizesCentralisers`( tbl ) | ( attribute )

is a list that stores at position \(i\) the size of the centralizer of any element in the \(i\)-th conjugacy class of the character table tbl.

    gap> tbl:= CharacterTable( "A5" );;
    gap> SizesCentralizers( tbl );
    [ 60, 4, 3, 5, 5 ]

##### 71.9-3 SizesConjugacyClasses

`‣ SizesConjugacyClasses`( tbl ) | ( attribute )

is a list that stores at position \(i\) the size of the \(i\)-th conjugacy class of the character table tbl.

    gap> tbl:= CharacterTable( "A5" );;
    gap> SizesConjugacyClasses( tbl );
    [ 1, 15, 20, 12, 12 ]

##### 71.9-4 AutomorphismsOfTable

`‣ AutomorphismsOfTable`( tbl ) | ( attribute )

is the permutation group of all column permutations of the character table tbl that leave the set of irreducibles and each power map of tbl invariant (see also `TableAutomorphisms` (71.22-2)).

    gap> tbl:= CharacterTable( "Dihedral", 8 );;
    gap> AutomorphismsOfTable( tbl );
    Group([ (4,5) ])
    gap> OrdersClassRepresentatives( tbl );
    [ 1, 4, 2, 2, 2 ]
    gap> SizesConjugacyClasses( tbl );
    [ 1, 2, 1, 2, 2 ]

##### 71.9-5 UnderlyingCharacteristic

`‣ UnderlyingCharacteristic`( tbl ) | ( attribute )

`‣ UnderlyingCharacteristic`( psi ) | ( attribute )

For an ordinary character table tbl, the result is `0`, for a \(p\)-modular Brauer table tbl, it is \(p\). The underlying characteristic of a class function psi is equal to that of its underlying character table.

The underlying characteristic must be stored when the table is constructed, there is no method to compute it.

We cannot use the attribute `Characteristic` (31.10-1) to denote this, since of course each Brauer character is an element of characteristic zero in the sense of GAP (see Chapter 72).

    gap> tbl:= CharacterTable( "A5" );;
    gap> UnderlyingCharacteristic( tbl );
    0
    gap> UnderlyingCharacteristic( tbl mod 17 );
    17

##### 71.9-6 Class Names and Character Names

`‣ ClassNames`( tbl[, "ATLAS"] ) | ( attribute )

`‣ CharacterNames`( tbl ) | ( attribute )

`ClassNames` and `CharacterNames` return lists of strings, one for each conjugacy class or irreducible character, respectively, of the character table tbl. These names are used when tbl is displayed.

The default method for `ClassNames` computes class names consisting of the order of an element in the class and at least one distinguishing letter.

The default method for `CharacterNames` returns the list `[ "X.1", "X.2", ... ]`, whose length is the number of irreducible characters of tbl.

The position of the class with name name in tbl can be accessed as `tbl.name`.

When `ClassNames` is called with two arguments, the second being the string `"ATLAS"`, the class names returned obey the convention used in the Atlas of Finite Groups [CCN+85, Chapter 7, Section 5]. If one is interested in relative class names of almost simple Atlas groups, one can use the function `AtlasClassNames` (AtlasRep: AtlasClassNames).

    gap> tbl:= CharacterTable( "A5" );;
    gap> ClassNames( tbl );
    [ "1a", "2a", "3a", "5a", "5b" ]
    gap> tbl.2a;
    2

##### 71.9-7 Class Parameters and Character Parameters

`‣ ClassParameters`( tbl ) | ( attribute )

`‣ CharacterParameters`( tbl ) | ( attribute )

The values of these attributes are lists containing a parameter for each conjugacy class or irreducible character, respectively, of the character table tbl.

It depends on tbl what these parameters are, so there is no default to compute class and character parameters.

For example, the classes of symmetric groups can be parametrized by partitions, corresponding to the cycle structures of permutations. Character tables constructed from generic character tables (see the manual of the GAP Character Table Library) usually have class and character parameters stored.

If tbl is a \(p\)-modular Brauer table such that class parameters are stored in the underlying ordinary table (see `OrdinaryCharacterTable` (71.8-4)) of tbl then `ClassParameters` returns the sublist of class parameters of the ordinary table, for \(p\)-regular classes.

##### 71.9-8 Identifier

`‣ Identifier`( tbl ) | ( attribute )

is a string that identifies the character table tbl in the current GAP session. It is used mainly for class fusions into tbl that are stored on other character tables. For character tables without group, the identifier is also used to print the table; this is the case for library tables, but also for tables that are constructed as direct products, factors etc. involving tables that may or may not store their groups.

The default method for ordinary tables constructs strings of the form `"CTn"`, where n is a positive integer. `LARGEST_IDENTIFIER_NUMBER` is a list containing the largest integer n used in the current GAP session.

The default method for Brauer tables returns the concatenation of the identifier of the ordinary table, the string `"mod"`, and the (string of the) underlying characteristic.

    gap> Identifier( CharacterTable( "A5" ) );
    "A5"
    gap> tbl:= CharacterTable( Group( () ) );;
    gap> Identifier( tbl );  Identifier( tbl mod 2 );
    "CT8"
    "CT8mod2"

##### 71.9-9 InfoText

`‣ InfoText`( tbl ) | ( method )

is a mutable string with information about the character table tbl. There is no default method to create an info text.

This attribute is used mainly for library tables (see the manual of the GAP Character Table Library). Usual parts of the information are the origin of the table, tests it has passed (`1.o.r.` for the test of orthogonality, `pow[p]` for the construction of the p-th power map, `DEC` for the decomposition of ordinary into Brauer characters, `TENS` for the decomposition of tensor products of irreducibles), and choices made without loss of generality.

    gap> Print( InfoText( CharacterTable( "A5" ) ), "\n" );
    origin: ATLAS of finite groups, tests: 1.o.r., pow[2,3,5]

##### 71.9-10 InverseClasses

`‣ InverseClasses`( tbl ) | ( attribute )

For a character table tbl, `InverseClasses` returns the list mapping each conjugacy class to its inverse class. This list can be regarded as \((-1)\)-st power map of tbl (see `PowerMap` (73.1-1)).

    gap> InverseClasses( CharacterTable( "A5" ) );
    [ 1, 2, 3, 4, 5 ]
    gap> InverseClasses( CharacterTable( "Cyclic", 3 ) );
    [ 1, 3, 2 ]

##### 71.9-11 RealClasses

`‣ RealClasses`( tbl ) | ( attribute )

For a character table tbl, `RealClasses` returns the strictly sorted list of positions of classes in tbl that consist of real elements.

An element \(x\) is real iff it is conjugate to its inverse \(x^{{-1}} = x^{{o(x)-1}}\).

    gap> RealClasses( CharacterTable( "A5" ) );
    [ 1, 2, 3, 4, 5 ]
    gap> RealClasses( CharacterTable( "Cyclic", 3 ) );
    [ 1 ]

##### 71.9-12 ClassOrbit

`‣ ClassOrbit`( tbl, cc ) | ( operation )

is the list of positions of those conjugacy classes of the character table tbl that are Galois conjugate to the cc-th class. That is, exactly the classes at positions given by the list returned by `ClassOrbit` contain generators of the cyclic group generated by an element in the cc-th class.

This information is computed from the power maps of tbl.

    gap> ClassOrbit( CharacterTable( "A5" ), 4 );
    [ 4, 5 ]

##### 71.9-13 ClassRoots

`‣ ClassRoots`( tbl ) | ( attribute )

For a character table tbl, `ClassRoots` returns a list containing at position \(i\) the list of positions of the classes of all nontrivial \(p\)-th roots, where \(p\) runs over the prime divisors of the `Size` (71.8-5) value of tbl.

This information is computed from the power maps of tbl.

    gap> ClassRoots( CharacterTable( "A5" ) );
    [ [ 2, 3, 4, 5 ], [  ], [  ], [  ], [  ] ]
    gap> ClassRoots( CharacterTable( "Cyclic", 6 ) );
    [ [ 3, 4, 5 ], [  ], [ 2 ], [ 2, 6 ], [ 6 ], [  ] ]

#### 71.10 Normal Subgroups Represented by Lists of Class Positions

The following attributes for a character table tbl correspond to attributes for the group \(G\) of tbl. But instead of a normal subgroup (or a list of normal subgroups) of \(G\), they return a strictly sorted list of positive integers (or a list of such lists) which are the positions –relative to the `ConjugacyClasses` (71.6-2) value of tbl– of those classes forming the normal subgroup in question.

##### 71.10-1 ClassPositionsOfNormalSubgroups

`‣ ClassPositionsOfNormalSubgroups`( ordtbl ) | ( attribute )

`‣ ClassPositionsOfMaximalNormalSubgroups`( ordtbl ) | ( attribute )

`‣ ClassPositionsOfMinimalNormalSubgroups`( ordtbl ) | ( attribute )

correspond to `NormalSubgroups` (39.19-9), `MaximalNormalSubgroups` (39.19-10), `MinimalNormalSubgroups` (39.19-11) for the group of the ordinary character table ordtbl.

The entries of the result lists are sorted according to increasing length. (So this total order respects the partial order of normal subgroups given by inclusion.)

    gap> tbls4:= CharacterTable( "Symmetric", 4 );;
    gap> ClassPositionsOfNormalSubgroups( tbls4 );
    [ [ 1 ], [ 1, 3 ], [ 1, 3, 4 ], [ 1 .. 5 ] ]

##### 71.10-2 ClassPositionsOfAgemo

`‣ ClassPositionsOfAgemo`( ordtbl, p ) | ( operation )

corresponds to `Agemo` (39.14-2) for the group of the ordinary character table ordtbl.

    gap> tbls4:= CharacterTable( "Symmetric", 4 );;
    gap> ClassPositionsOfAgemo( tbls4, 2 );
    [ 1, 3, 4 ]

##### 71.10-3 ClassPositionsOfCentre

`‣ ClassPositionsOfCentre`( ordtbl ) | ( attribute )

`‣ ClassPositionsOfCenter`( ordtbl ) | ( attribute )

corresponds to `Centre` (35.4-5) for the group of the ordinary character table ordtbl.

    gap> tbld8:= CharacterTable( "Dihedral", 8 );;
    gap> ClassPositionsOfCentre( tbld8 );
    [ 1, 3 ]

##### 71.10-4 ClassPositionsOfDirectProductDecompositions

`‣ ClassPositionsOfDirectProductDecompositions`( tbl[, nclasses] ) | ( attribute )

Let tbl be the ordinary character table of the group \(G\), say. Called with the only argument tbl, `ClassPositionsOfDirectProductDecompositions` returns the list of all those pairs \([ l_1, l_2 ]\) where \(l_1\) and \(l_2\) are lists of class positions of normal subgroups \(N_1\), \(N_2\) of \(G\) such that \(G\) is their direct product and \(|N_1| \leq |N_2|\) holds. Called with second argument a list nclasses of class positions of a normal subgroup \(N\) of \(G\), `ClassPositionsOfDirectProductDecompositions` returns the list of pairs describing the decomposition of \(N\) as a direct product of two normal subgroups of \(G\).

##### 71.10-5 ClassPositionsOfDerivedSubgroup

`‣ ClassPositionsOfDerivedSubgroup`( ordtbl ) | ( attribute )

corresponds to `DerivedSubgroup` (39.12-3) for the group of the ordinary character table ordtbl.

    gap> tbld8:= CharacterTable( "Dihedral", 8 );;
    gap> ClassPositionsOfDerivedSubgroup( tbld8 );
    [ 1, 3 ]

##### 71.10-6 ClassPositionsOfElementaryAbelianSeries

`‣ ClassPositionsOfElementaryAbelianSeries`( ordtbl ) | ( attribute )

corresponds to `ElementaryAbelianSeries` (39.17-9) for the group of the ordinary character table ordtbl.

    gap> tbls4:= CharacterTable( "Symmetric", 4 );;
    gap> tbla5:= CharacterTable( "A5" );;
    gap> ClassPositionsOfElementaryAbelianSeries( tbls4 );
    [ [ 1 .. 5 ], [ 1, 3, 4 ], [ 1, 3 ], [ 1 ] ]
    gap> ClassPositionsOfElementaryAbelianSeries( tbla5 );
    fail

##### 71.10-7 ClassPositionsOfFittingSubgroup

`‣ ClassPositionsOfFittingSubgroup`( ordtbl ) | ( attribute )

corresponds to `FittingSubgroup` (39.12-5) for the group of the ordinary character table ordtbl.

    gap> tbls4:= CharacterTable( "Symmetric", 4 );;
    gap> ClassPositionsOfFittingSubgroup( tbls4 );
    [ 1, 3 ]

##### 71.10-8 ClassPositionsOfLowerCentralSeries

`‣ ClassPositionsOfLowerCentralSeries`( tbl ) | ( attribute )

corresponds to `LowerCentralSeriesOfGroup` (39.17-11) for the group of the ordinary character table ordtbl.

    gap> tbls4:= CharacterTable( "Symmetric", 4 );;
    gap> tbld8:= CharacterTable( "Dihedral", 8 );;
    gap> ClassPositionsOfLowerCentralSeries( tbls4 );
    [ [ 1 .. 5 ], [ 1, 3, 4 ] ]
    gap> ClassPositionsOfLowerCentralSeries( tbld8 );
    [ [ 1 .. 5 ], [ 1, 3 ], [ 1 ] ]

##### 71.10-9 ClassPositionsOfUpperCentralSeries

`‣ ClassPositionsOfUpperCentralSeries`( ordtbl ) | ( attribute )

corresponds to `UpperCentralSeriesOfGroup` (39.17-12) for the group of the ordinary character table ordtbl.

    gap> tbls4:= CharacterTable( "Symmetric", 4 );;
    gap> tbld8:= CharacterTable( "Dihedral", 8 );;
    gap> ClassPositionsOfUpperCentralSeries( tbls4 );
    [ [ 1 ] ]
    gap> ClassPositionsOfUpperCentralSeries( tbld8 );
    [ [ 1, 3 ], [ 1, 2, 3, 4, 5 ] ]

##### 71.10-10 ClassPositionsOfSolvableRadical

`‣ ClassPositionsOfSolvableRadical`( ordtbl ) | ( attribute )

corresponds to `SolvableRadical` (39.12-9) for the group of the ordinary character table ordtbl.

    gap> ClassPositionsOfSolvableRadical( CharacterTable( "2.A5" ) );
    [ 1, 2 ]

##### 71.10-11 ClassPositionsOfSupersolvableResiduum

`‣ ClassPositionsOfSupersolvableResiduum`( ordtbl ) | ( attribute )

corresponds to `SupersolvableResiduum` (39.12-11) for the group of the ordinary character table ordtbl.

    gap> tbls4:= CharacterTable( "Symmetric", 4 );;
    gap> ClassPositionsOfSupersolvableResiduum( tbls4 );
    [ 1, 3 ]

##### 71.10-12 ClassPositionsOfPCore

`‣ ClassPositionsOfPCore`( ordtbl, p ) | ( operation )

corresponds to `PCore` (39.11-3) for the group of the ordinary character table ordtbl.

    gap> tbls4:= CharacterTable( "Symmetric", 4 );;
    gap> ClassPositionsOfPCore( tbls4, 2 );
    [ 1, 3 ]
    gap> ClassPositionsOfPCore( tbls4, 3 );
    [ 1 ]

##### 71.10-13 ClassPositionsOfNormalClosure

`‣ ClassPositionsOfNormalClosure`( ordtbl, classes ) | ( operation )

is the sorted list of the positions of all conjugacy classes of the ordinary character table ordtbl that form the normal closure (see `NormalClosure` (39.11-4)) of the conjugacy classes at positions in the list classes.

    gap> tbls4:= CharacterTable( "Symmetric", 4 );;
    gap> ClassPositionsOfNormalClosure( tbls4, [ 1, 4 ] );
    [ 1, 3, 4 ]

#### 71.11 Operations Concerning Blocks

##### 71.11-1 PrimeBlocks

`‣ PrimeBlocks`( ordtbl, p ) | ( operation )

`‣ PrimeBlocksOp`( ordtbl, p ) | ( operation )

`‣ ComputedPrimeBlockss`( tbl ) | ( attribute )

For an ordinary character table ordtbl and a prime integer p, `PrimeBlocks` returns a record with the following components.

`block`

  a list, the value \(j\) at position \(i\) means that the \(i\)-th irreducible character of ordtbl lies in the \(j\)-th p-block of ordtbl,

`defect`

  a list containing at position \(i\) the defect of the \(i\)-th block,

`height`

  a list containing at position \(i\) the height of the \(i\)-th irreducible character of ordtbl in its block,

`relevant`

  a list of class positions such that only the restriction to these classes need be checked for deciding whether two characters lie in the same block, and

`centralcharacter`

  a list containing at position \(i\) a list whose values at the positions stored in the component `relevant` are the values of a central character in the \(i\)-th block.

The components `relevant` and `centralcharacters` are used by `SameBlock` (71.11-2).

If `InfoCharacterTable` (71.4-2) has level at least 2, the defects of the blocks and the heights of the characters are printed.

The default method uses the attribute `ComputedPrimeBlockss` for storing the computed value at position p, and calls the operation `PrimeBlocksOp` for computing values that are not yet known.

Two ordinary irreducible characters \(\chi, \psi\) of a group \(G\) are said to lie in the same \(p\)-block if the images of their central characters \(\omega_{\chi}, \omega_{\psi}\) (see `CentralCharacter` (72.8-17)) under the natural ring epimorphism \(R \rightarrow R / M\) are equal, where \(R\) denotes the ring of algebraic integers in the complex number field, and \(M\) is a maximal ideal in \(R\) with \(pR \subseteq M\). (The distribution to \(p\)-blocks is in fact independent of the choice of \(M\), see [Isa76].)

For \(|G| = p^a m\) where \(p\) does not divide \(m\), the defect of a block is the integer \(d\) such that \(p^{{a-d}}\) is the largest power of \(p\) that divides the degrees of all characters in the block.

The height of a character \(\chi\) in the block is defined as the largest exponent \(h\) for which \(p^h\) divides \(\chi(1) / p^{{a-d}}\).

    gap> tbl:= CharacterTable( "L3(2)" );;
    gap> pbl:= PrimeBlocks( tbl, 2 );
    rec( block := [ 1, 1, 1, 1, 1, 2 ],
      centralcharacter := [ [ ,, 56,, 24 ], [ ,, -7,, 3 ] ],
      defect := [ 3, 0 ], height := [ 0, 0, 0, 1, 0, 0 ],
      relevant := [ 3, 5 ] )

##### 71.11-2 SameBlock

`‣ SameBlock`( p, omega1, omega2, relevant ) | ( function )

Let p be a prime integer, omega1 and omega2 be two central characters (or their values lists) of a character table, and relevant be a list of positions as is stored in the component `relevant` of a record returned by `PrimeBlocks` (71.11-1).

`SameBlock` returns `true` if omega1 and omega2 are equal modulo any maximal ideal in the ring of complex algebraic integers containing the ideal spanned by p, and `false` otherwise.

    gap> omega:= List( Irr( tbl ), CentralCharacter );;
    gap> SameBlock( 2, omega[1], omega[2], pbl.relevant );
    true
    gap> SameBlock( 2, omega[1], omega[6], pbl.relevant );
    false

##### 71.11-3 BlocksInfo

`‣ BlocksInfo`( modtbl ) | ( attribute )

For a Brauer character table modtbl, the value of `BlocksInfo` is a list of (mutable) records, the \(i\)-th entry containing information about the \(i\)-th block. Each record has the following components.

`defect`

  the defect of the block,

`ordchars`

  the list of positions of the ordinary characters that belong to the block, relative to `Irr( OrdinaryCharacterTable( modtbl ) )`,

`modchars`

  the list of positions of the Brauer characters that belong to the block, relative to `IBr( modtbl )`.

Optional components are

`basicset`

  a list of positions of ordinary characters in the block whose restriction to modtbl is maximally linearly independent, relative to `Irr( OrdinaryCharacterTable( modtbl ) )`,

`decmat`

  the decomposition matrix of the block, it is stored automatically when `DecompositionMatrix` (71.11-4) is called for the block,

`decinv`

  inverse of the decomposition matrix of the block, restricted to the ordinary characters described by `basicset`,

`brauertree`

  a list that describes the Brauer tree of the block, in the case that the block is of defect \(1\).

    gap> BlocksInfo( CharacterTable( "L3(2)" ) mod 2 );
    [ rec( basicset := [ 1, 2, 3 ],
          decinv := [ [ 1, 0, 0 ], [ 0, 1, 0 ], [ 0, 0, 1 ] ],
          defect := 3, modchars := [ 1, 2, 3 ],
          ordchars := [ 1, 2, 3, 4, 5 ] ),
      rec( basicset := [ 6 ], decinv := [ [ 1 ] ], defect := 0,
          modchars := [ 4 ], ordchars := [ 6 ] ) ]

##### 71.11-4 DecompositionMatrix

`‣ DecompositionMatrix`( modtbl[, blocknr] ) | ( operation )

Let modtbl be a Brauer character table.

Called with one argument, `DecompositionMatrix` returns the decomposition matrix of modtbl, where the rows and columns are indexed by the irreducible characters of the ordinary character table of modtbl and the irreducible characters of modtbl, respectively,

Called with two arguments, `DecompositionMatrix` returns the decomposition matrix of the block of modtbl with number blocknr; the matrix is stored as value of the `decmat` component of the blocknr-th entry of the `BlocksInfo` (71.11-3) list of modtbl.

An ordinary irreducible character is in block \(i\) if and only if all characters before the first character of the same block lie in \(i-1\) different blocks. An irreducible Brauer character is in block \(i\) if it has nonzero scalar product with an ordinary irreducible character in block \(i\).

`DecompositionMatrix` is based on the more general function `Decomposition` (25.4-1).

    gap> modtbl:= CharacterTable( "L3(2)" ) mod 2;
    BrauerTable( "L3(2)", 2 )
    gap> DecompositionMatrix( modtbl );
    [ [ 1, 0, 0, 0 ], [ 0, 1, 0, 0 ], [ 0, 0, 1, 0 ], [ 0, 1, 1, 0 ],
      [ 1, 1, 1, 0 ], [ 0, 0, 0, 1 ] ]
    gap> DecompositionMatrix( modtbl, 1 );
    [ [ 1, 0, 0 ], [ 0, 1, 0 ], [ 0, 0, 1 ], [ 0, 1, 1 ], [ 1, 1, 1 ] ]
    gap> DecompositionMatrix( modtbl, 2 );
    [ [ 1 ] ]

##### 71.11-5 LaTeXStringDecompositionMatrix

`‣ LaTeXStringDecompositionMatrix`( modtbl[, blocknr][, options] ) | ( function )

is a string that contains LaTeX code to print a decomposition matrix (see `DecompositionMatrix` (71.11-4)) nicely.

The optional argument options, if present, must be a record with components `phi`, `chi` (strings used in each label for columns and rows), `collabels`, `rowlabels` (subscripts for the labels). The defaults for `phi` and `chi` are `"{\\tt Y}"` and `"{\\tt X}"`, the defaults for `collabels` and `rowlabels` are the lists of positions of the Brauer characters and ordinary characters in the respective lists of irreducibles in the character tables.

The optional components `nrows` and `ncols` denote the maximal number of rows and columns per array; if they are present then each portion of `nrows` rows and `ncols` columns forms an array of its own which is enclosed in `\[`, `\]`.

If the component `decmat` is bound in options then it must be the decomposition matrix in question, in this case the matrix is not computed from the information in modtbl.

For those character tables from the GAP table library that belong to the Atlas of Finite Groups [CCN+85], `AtlasLabelsOfIrreducibles` (CTblLib: AtlasLabelsOfIrreducibles) constructs character labels that are compatible with those used in the Atlas (see CTblLib: Atlas Tables in the manual of the GAP Character Table Library).

    gap> modtbl:= CharacterTable( "L3(2)" ) mod 2;;
    gap> Print( LaTeXStringDecompositionMatrix( modtbl, 1 ) );
    \[
    \begin{array}{r|rrr} \hline
     & {\tt Y}_{1}
     & {\tt Y}_{2}
     & {\tt Y}_{3}
     \rule[-7pt]{0pt}{20pt} \\ \hline
    {\tt X}_{1} & 1 & . & . \rule[0pt]{0pt}{13pt} \\
    {\tt X}_{2} & . & 1 & . \\
    {\tt X}_{3} & . & . & 1 \\
    {\tt X}_{4} & . & 1 & 1 \\
    {\tt X}_{5} & 1 & 1 & 1 \rule[-7pt]{0pt}{5pt} \\
    \hline
    \end{array}
    \]
    gap> options:= rec( phi:= "\\varphi", chi:= "\\chi" );;
    gap> Print( LaTeXStringDecompositionMatrix( modtbl, 1, options ) );
    \[
    \begin{array}{r|rrr} \hline
     & \varphi_{1}
     & \varphi_{2}
     & \varphi_{3}
     \rule[-7pt]{0pt}{20pt} \\ \hline
    \chi_{1} & 1 & . & . \rule[0pt]{0pt}{13pt} \\
    \chi_{2} & . & 1 & . \\
    \chi_{3} & . & . & 1 \\
    \chi_{4} & . & 1 & 1 \\
    \chi_{5} & 1 & 1 & 1 \rule[-7pt]{0pt}{5pt} \\
    \hline
    \end{array}
    \]

#### 71.12 Other Operations for Character Tables

In the following, we list operations for character tables that are not attributes.

##### 71.12-1 Index

`‣ Index`( tbl, subtbl ) | ( operation )

For two character tables tbl and subtbl, `Index` returns the quotient of the `Size` (71.8-5) values of tbl and subtbl. The containment of the underlying groups of subtbl and tbl is not checked; so the distinction between `Index` (39.3-2) and `IndexNC` (39.3-2) is not made for character tables.

##### 71.12-2 IsInternallyConsistent

`‣ IsInternallyConsistent`( tbl ) | ( method )

For an ordinary character table tbl, `IsInternallyConsistent` (12.8-4) checks the consistency of the following attribute values (if stored).

- `Size` (30.4-6), `SizesCentralizers` (71.9-2), and `SizesConjugacyClasses` (71.9-3).

- `SizesCentralizers` (71.9-2) and `OrdersClassRepresentatives` (71.9-1).

- `ComputedPowerMaps` (73.1-1) and `OrdersClassRepresentatives` (71.9-1).

- `SizesCentralizers` (71.9-2) and `Irr` (71.8-2).

- `Irr` (71.8-2) (first orthogonality relation).

For a Brauer table tbl, `IsInternallyConsistent` checks the consistency of the following attribute values (if stored).

- `Size` (30.4-6), `SizesCentralizers` (71.9-2), and `SizesConjugacyClasses` (71.9-3).

- `SizesCentralizers` (71.9-2) and `OrdersClassRepresentatives` (71.9-1).

- `ComputedPowerMaps` (73.1-1) and `OrdersClassRepresentatives` (71.9-1).

- `Irr` (71.8-2) (closure under complex conjugation and Frobenius map).

If no inconsistency occurs, `true` is returned, otherwise each inconsistency is printed to the screen if the level of `InfoWarning` (7.4-8) is at least \(1\) (see 7.4), and `false` is returned at the end.

##### 71.12-3 IsPSolvableCharacterTable

`‣ IsPSolvableCharacterTable`( tbl, p ) | ( operation )

`‣ IsPSolubleCharacterTable`( tbl, p ) | ( operation )

`‣ IsPSolvableCharacterTableOp`( tbl, p ) | ( operation )

`‣ IsPSolubleCharacterTableOp`( tbl, p ) | ( operation )

`‣ ComputedIsPSolvableCharacterTables`( tbl ) | ( attribute )

`‣ ComputedIsPSolubleCharacterTables`( tbl ) | ( attribute )

`IsPSolvableCharacterTable` for the ordinary character table tbl corresponds to `IsPSolvable` (39.15-26) for the group of tbl, p must be either a prime integer or `0`.

The default method uses the attribute `ComputedIsPSolvableCharacterTables` for storing the computed value at position p, and calls the operation `IsPSolvableCharacterTableOp` for computing values that are not yet known.

    gap> tbl:= CharacterTable( "Sz(8)" );;
    gap> IsPSolvableCharacterTable( tbl, 2 );
    false
    gap> IsPSolvableCharacterTable( tbl, 3 );
    true

##### 71.12-4 IsClassFusionOfNormalSubgroup

`‣ IsClassFusionOfNormalSubgroup`( subtbl, fus, tbl ) | ( function )

For two ordinary character tables tbl and subtbl of a group \(G\) and its subgroup \(U\) and a list fus of positive integers that describes the class fusion of \(U\) into \(G\), `IsClassFusionOfNormalSubgroup` returns `true` if \(U\) is a normal subgroup of \(G\), and `false` otherwise.

    gap> tblc2:= CharacterTable( "Cyclic", 2 );;
    gap> tbld8:= CharacterTable( "Dihedral", 8 );;
    gap> fus:= PossibleClassFusions( tblc2, tbld8 );
    [ [ 1, 3 ], [ 1, 4 ], [ 1, 5 ] ]
    gap> List(fus, map -> IsClassFusionOfNormalSubgroup(tblc2, map, tbld8));
    [ true, false, false ]

##### 71.12-5 Indicator

`‣ Indicator`( tbl[, characters], n ) | ( operation )

`‣ IndicatorOp`( tbl, characters, n ) | ( operation )

`‣ ComputedIndicators`( tbl ) | ( attribute )

If tbl is an ordinary character table then `Indicator` returns the list of n-th Frobenius-Schur indicators of the characters in the list characters; the default of characters is `Irr( tbl )`.

The \(n\)-th Frobenius-Schur indicator \(\nu_n(\chi)\) of an ordinary character \(\chi\) of the group \(G\) is given by \(\nu_n(\chi) = ( \sum_{{g \in G}} \chi(g^n) ) / |G|\).

If tbl is a Brauer table in characteristic \( \neq 2\) and \(\textit{n} = 2\) then `Indicator` returns the second indicator.

The default method uses the attribute `ComputedIndicators` for storing the computed value at position n, and calls the operation `IndicatorOp` for computing values that are not yet known.

    gap> tbl:= CharacterTable( "L3(2)" );;
    gap> Indicator( tbl, 2 );
    [ 1, 0, 0, 1, 1, 1 ]

In nonzero characteristic \(p\), the Frobenius-Schur indicator is defined only for irreducible characters. For odd \(p\), the indicator is computed using the Thompson-Willems Theorem [Tho86, theorem on p. 227]. For \(p = 2\), in general the indicator cannot be computed from the given character tables, here the following necessary conditions are used.

- The trivial character has indicator \(1\).

- The indicator is \(0\) if and only if the character is not real-valued.

- Real characters outside the principal block (the \(2\)-block that contains the trivial character, see `PrimeBlocks` (71.11-1)) have indicator \(1\).

- By [GW95, Lemma 1.2], any real constituent with odd multiplicity in the \(2\)-modular restriction of an ordinary irreducible character with indicator \(1\) has indicator \(1\), provided that the trivial character is not a constituent of the restriction.

For each \(2\)-modular Brauer characters where these conditions are not sufficient to determine the indicator, an unknown value (see `Unknown` (74.1-1)) is returned.

##### 71.12-6 NrPolyhedralSubgroups

`‣ NrPolyhedralSubgroups`( tbl, c1, c2, c3 ) | ( function )

returns the number and isomorphism type of polyhedral subgroups of the group with ordinary character table tbl which are generated by an element \(g\) of class c1 and an element \(h\) of class c2 with the property that the product \(gh\) lies in class c3.

According to [NPP84, p. 233], the number of polyhedral subgroups of isomorphism type \(V_4\), \(D_{2n}\), \(A_4\), \(S_4\), and \(A_5\) can be derived from the class multiplication coefficient (see `ClassMultiplicationCoefficient` (71.12-7)) and the number of Galois conjugates of a class (see `ClassOrbit` (71.9-12)).

The classes c1, c2 and c3 in the parameter list must be ordered according to the order of the elements in these classes. If elements in class c1 and c2 do not generate a polyhedral group then `fail` is returned.

    gap> NrPolyhedralSubgroups( tbl, 2, 2, 4 );
    rec( number := 21, type := "D8" )

##### 71.12-7 ClassMultiplicationCoefficient

`‣ ClassMultiplicationCoefficient`( tbl, i, j, k ) | ( operation )

returns the class multiplication coefficient of the classes i, j, and k of the group \(G\) with ordinary character table tbl.

The class multiplication coefficient \(c_{{i,j,k}}\) of the classes i, j, k equals the number of pairs \((x,y)\) of elements \(x, y \in G\) such that \(x\) lies in class i, \(y\) lies in class j, and their product \(xy\) is a fixed element of class k.

In the center of the group algebra of \(G\), these numbers are found as coefficients of the decomposition of the product of two class sums \(K_i\) and \(K_j\) into class sums:

\[ K_i K_j = \sum_k c_{ijk} K_k . \]

Given the character table of a finite group \(G\), whose classes are \(C_1, \ldots, C_r\) with representatives \(g_i \in C_i\), the class multiplication coefficient \(c_{ijk}\) can be computed with the following formula:

\[ c_{ijk} = |C_i| \cdot |C_j| / |G| \cdot \sum_{{\chi \in Irr(G)}} \chi(g_i) \chi(g_j) \chi(g_k^{{-1}}) / \chi(1). \]

On the other hand the knowledge of the class multiplication coefficients admits the computation of the irreducible characters of \(G\), see `IrrDixonSchneider` (71.14-1).

##### 71.12-8 ClassStructureCharTable

`‣ ClassStructureCharTable`( tbl, classes ) | ( function )

returns the so-called class structure of the classes in the list classes, for the character table tbl of the group \(G\). The length of classes must be at least 2.

Let \(C = (C_1, C_2, \ldots, C_n)\) denote the \(n\)-tuple of conjugacy classes of \(G\) that are indexed by classes. The class structure \(n(C)\) equals the number of \(n\)-tuples \((g_1, g_2, \ldots, g_n)\) of elements \(g_i \in C_i\) with \(g_1 g_2 \cdots g_n = 1\). Note the difference to the definition of the class multiplication coefficients in `ClassMultiplicationCoefficient` (71.12-7).

\(n(C_1, C_2, \ldots, C_n)\) is computed using the formula

\[ n(C_1, C_2, \ldots, C_n) = |C_1| |C_2| \cdots |C_n| / |G| \cdot \sum_{{\chi \in Irr(G)}} \chi(g_1) \chi(g_2) \cdots \chi(g_n) / \chi(1)^{{n-2}} . \]

##### 71.12-9 MatClassMultCoeffsCharTable

`‣ MatClassMultCoeffsCharTable`( tbl, i ) | ( function )

For an ordinary character table tbl and a class position i, `MatClassMultCoeffsCharTable` returns the matrix \([ a_{ijk} ]_{{j,k}}\) of structure constants (see `ClassMultiplicationCoefficient` (71.12-7)).

    gap> tbl:= CharacterTable( "L3(2)" );;
    gap> ClassMultiplicationCoefficient( tbl, 2, 2, 4 );
    4
    gap> ClassStructureCharTable( tbl, [ 2, 2, 4 ] );
    168
    gap> ClassStructureCharTable( tbl, [ 2, 2, 2, 4 ] );
    1848
    gap> MatClassMultCoeffsCharTable( tbl, 2 );
    [ [ 0, 1, 0, 0, 0, 0 ], [ 21, 4, 3, 4, 0, 0 ], [ 0, 8, 6, 8, 7, 7 ],
      [ 0, 8, 6, 1, 7, 7 ], [ 0, 0, 3, 4, 0, 7 ], [ 0, 0, 3, 4, 7, 0 ] ]

#### 71.13 Printing Character Tables

##### 71.13-1 ViewObj

`‣ ViewObj`( tbl ) | ( method )

The default `ViewObj` (6.3-5) method for ordinary character tables prints the string `"CharacterTable"`, followed by the identifier (see `Identifier` (71.9-8)) or, if known, the group of the character table enclosed in brackets. `ViewObj` (6.3-5) for Brauer tables does the same, except that the first string is replaced by `"BrauerTable"`, and that the characteristic is also shown.

##### 71.13-2 PrintObj

`‣ PrintObj`( tbl ) | ( method )

The default `PrintObj` (6.3-5) method for character tables does the same as `ViewObj` (6.3-5), except that `PrintObj` (6.3-5) is used for the group instead of `ViewObj` (6.3-5).

##### 71.13-3 Display

`‣ Display`( tbl ) | ( method )

There are various ways to customize the `Display` (6.3-6) output for character tables. First we describe the default behaviour, alternatives are then described below.

The default `Display` (6.3-6) method prepares the data in tbl for a columnwise output. The number of columns printed at one time depends on the actual line length, which can be accessed and changed by the function `SizeScreen` (6.12-1).

An interesting variant of `Display` (6.3-6) is the function `PageDisplay` (GAPDoc: PageDisplay). Convenient ways to print the `Display` (6.3-6) format to a file are given by the function `PrintTo1` (GAPDoc: PrintTo1) or by using `PageDisplay` (GAPDoc: PageDisplay) and the facilities of the pager used, cf. `Pager` (2.4-1).

An interactive variant of `Display` (6.3-6) is the `Browse` (Browse: Browse) method for character tables that is provided by the GAP package Browse, see `Browse` (Browse: Browse for character tables).

`Display` (6.3-6) shows certain characters (by default all irreducible characters) of tbl, together with the orders of the centralizers in factorized form and the available power maps (see `ComputedPowerMaps` (73.1-1)). The n-th displayed character is given the name `X.n`.

The first lines of the output describe the order of the centralizer of an element of the class factorized into its prime divisors.

The next line gives the name of each class. If no class names are stored on tbl, `ClassNames` (71.9-6) is called.

Preceded by a name `Pn`, the next lines show the nth power maps of tbl in terms of the former shown class names.

Every ambiguous or unknown (see Chapter 74) value of the table is displayed as a question mark `?`.

Irrational character values are not printed explicitly because the lengths of their printed representation might disturb the layout. Instead of that every irrational value is indicated by a name, which is a string of at least one capital letter.

Once a name for an irrational value is found, it is used all over the printed table. Moreover the complex conjugate (see `ComplexConjugate` (18.5-2), `GaloisCyc` (18.5-1)) and the star of an irrationality (see `StarCyc` (18.5-3)) are represented by that very name preceded by a `/` and a `*`, respectively.

The printed character table is then followed by a legend, a list identifying the occurring symbols with their actual values. Occasionally this identification is supplemented by a quadratic representation of the irrationality (see `Quadratic` (18.5-4)) together with the corresponding Atlas notation (see [CCN+85]).

This default style can be changed by prescribing a record arec of options, which can be given

1. as an optional argument in the call to `Display` (6.3-6),

2. as the value of the attribute `DisplayOptions` (71.13-4) if this value is stored in the table,

3. as the value of the global variable `CharacterTableDisplayDefaults.User`, or

4. as the value of the global variable `CharacterTableDisplayDefaults.Global`

(in this order of precedence).

The following components of arec are supported.

`centralizers`

  `false` to suppress the printing of the orders of the centralizers, or the string `"ATLAS"` to force the printing of non-factorized centralizer orders in a style similar to that used in the Atlas of Finite Groups [CCN+85],

`characterField`

  `true` to show the degrees of the character fields over the prime field, in a column with header `d`,

`chars`

  an integer or a list of integers to select a sublist of the irreducible characters of tbl, or a list of characters of tbl (in the latter case, the default letter `"X"` in the character names is replaced by `"Y"`),

`charnames`

  a list of strings of length equal to the number of characters that shall be shown; they are used as labels for the characters,

`classes`

  an integer or a list of integers to select a sublist of the classes of tbl,

`classnames`

  a list of strings of length equal to the number of classes that shall be shown; they are used as labels for the classes,

`indicator`

  `true` enables the printing of the second Frobenius Schur indicator, a list of integers enables the printing of the corresponding indicators (see `Indicator` (71.12-5)),

`letter`

  a single capital letter (e. g. `"P"` for permutation characters) to replace the default `"X"` in character names,

`powermap`

  an integer or a list of integers to select a subset of the available power maps, `false` to suppress the printing of power maps, or the string `"ATLAS"` to force a printing of class names and power maps in a style similar to that used in the Atlas of Finite Groups [CCN+85] (the `"ATLAS"` variant works only if the function `CambridgeMaps` (CTblLib: CambridgeMaps) is available, which belongs to the CTblLib package),

`Display`

  the function that is actually called in order to display the table; the arguments are the table and the optional record, whose components can be used inside the `Display` function,

`StringEntry`

  a function that takes either a character value or a character value and the return value of `StringEntryData` (see below), and returns the string that is actually displayed; it is called for all character values to be displayed, and also for the displayed indicator values (see above),

`StringEntryData`

  a unary function that is called once with argument tbl before the character values are displayed; it returns an object that is used as second argument of the function `StringEntry`,

`Legend`

  a function that takes the result of the `StringEntryData` call as its only argument, after the character table has been displayed; the return value is a string that describes the symbols used in the displayed table in a formatted way, it is printed below the displayed table.

##### 71.13-4 DisplayOptions

`‣ DisplayOptions`( tbl ) | ( attribute )

There is no default method to compute a value, one can set a value with `SetDisplayOptions`.

    gap> tbl:= CharacterTable( "A5" );;
    gap> Display( tbl );
    A5

         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-Sqrt(5))/2 = -b5
    gap> CharacterTableDisplayDefaults.User:= rec(
    >        powermap:= "ATLAS", centralizers:= "ATLAS", chars:= false );;
    gap> Display( CharacterTable( "A5" ) );
    A5

        60  4  3  5  5

     p      A  A  A  A
     p'     A  A  A  A
        1A 2A 3A 5A B*

    gap> options:= rec( chars:= 4, classes:= [ tbl.3a .. tbl.5a ],
    >                   centralizers:= false, indicator:= true,
    >                   powermap:= [ 2 ] );;
    gap> Display( tbl, options );
    A5

              3a 5a
           2P 3a 5b
           2
    X.4    +   1 -1
    gap> SetDisplayOptions( tbl, options );  Display( tbl );
    A5

              3a 5a
           2P 3a 5b
           2
    X.4    +   1 -1
    gap> Unbind( CharacterTableDisplayDefaults.User );

##### 71.13-5 PrintCharacterTable

`‣ PrintCharacterTable`( tbl, varname ) | ( function )

Let tbl be a nearly character table, and varname a string. `PrintCharacterTable` prints those values of the supported attributes (see `SupportedCharacterTableInfo` (71.3-4)) that are known for tbl.

The output of `PrintCharacterTable` is GAP readable; actually reading it into GAP will bind the variable with name varname to a character table that coincides with tbl for all printed components.

This is used mainly for saving character tables to files. A more human readable form is produced by `Display` (6.3-6).

    gap> PrintCharacterTable( CharacterTable( "Cyclic", 2 ), "tbl" );
    tbl:= function()
    local tbl, i;
    tbl:=rec();
    tbl.Irr:=
    [ [ 1, 1 ], [ 1, -1 ] ];
    tbl.IsFinite:=
    true;
    tbl.NrConjugacyClasses:=
    2;
    tbl.Size:=
    2;
    tbl.OrdersClassRepresentatives:=
    [ 1, 2 ];
    tbl.SizesCentralizers:=
    [ 2, 2 ];
    tbl.UnderlyingCharacteristic:=
    0;
    tbl.ClassParameters:=
    [ [ 1, 0 ], [ 1, 1 ] ];
    tbl.CharacterParameters:=
    [ [ 1, 0 ], [ 1, 1 ] ];
    tbl.Identifier:=
    "C2";
    tbl.InfoText:=
    "computed using generic character table for cyclic groups";
    tbl.ComputedPowerMaps:=
    [ , [ 1, 1 ] ];
    ConvertToLibraryCharacterTableNC(tbl);
    return tbl;
    end;
    tbl:= tbl();

#### 71.14 Computing the Irreducible Characters of a Group

Several algorithms are available for computing the irreducible characters of a finite group \(G\). The default method for arbitrary finite groups is to use the Dixon-Schneider algorithm (see `IrrDixonSchneider` (71.14-1)). For supersolvable groups, Conlon's algorithm can be used (see `IrrConlon` (71.14-2)). For abelian-by-supersolvable groups, the Baum-Clausen algorithm for computing the irreducible representations (see `IrreducibleRepresentations` (71.14-4)) can be used to compute the irreducible characters (see `IrrBaumClausen` (71.14-3)).

These functions are installed in methods for `Irr` (71.8-2), but explicitly calling one of them will not set the `Irr` (71.8-2) value of \(G\).

##### 71.14-1 IrrDixonSchneider

`‣ IrrDixonSchneider`( G ) | ( attribute )

computes the irreducible characters of the finite group G, using the Dixon-Schneider method (see 71.16). It calls `DixonInit` (71.17-2) and `DixonSplit` (71.17-4), and finally returns the list returned by `DixontinI` (71.17-3). See also the sections 71.18 and 71.19.

##### 71.14-2 IrrConlon

`‣ IrrConlon`( G ) | ( attribute )

For a finite solvable group G, `IrrConlon` returns a list of monomial irreducible characters of G, among those all irreducibles that have the supersolvable residuum of G in their kernels; so if G is supersolvable, all irreducible characters of G are returned. An error is signalled if G is not solvable.

The characters are computed using Conlon's algorithm (see [Con90a] and [Con90b]). For each irreducible character in the returned list, the monomiality information (see `TestMonomial` (75.4-1)) is stored.

##### 71.14-3 IrrBaumClausen

`‣ IrrBaumClausen`( G ) | ( attribute )

`IrrBaumClausen` returns the absolutely irreducible ordinary characters of the factor group of the finite solvable group G by the derived subgroup of its supersolvable residuum.

The characters are computed using the algorithm by Baum and Clausen (see [BC94]). An error is signalled if G is not solvable.

    gap> g:= SL(2,3);;
    gap> irr1:= IrrDixonSchneider( g );
    [ Character( CharacterTable( SL(2,3) ), [ 1, 1, 1, 1, 1, 1, 1 ] ),
      Character( CharacterTable( SL(2,3) ),
        [ 1, E(3)^2, E(3), 1, E(3), E(3)^2, 1 ] ),
      Character( CharacterTable( SL(2,3) ),
        [ 1, E(3), E(3)^2, 1, E(3)^2, E(3), 1 ] ),
      Character( CharacterTable( SL(2,3) ), [ 2, 1, 1, -2, -1, -1, 0 ] ),
      Character( CharacterTable( SL(2,3) ),
        [ 2, E(3)^2, E(3), -2, -E(3), -E(3)^2, 0 ] ),
      Character( CharacterTable( SL(2,3) ),
        [ 2, E(3), E(3)^2, -2, -E(3)^2, -E(3), 0 ] ),
      Character( CharacterTable( SL(2,3) ), [ 3, 0, 0, 3, 0, 0, -1 ] ) ]
    gap> irr2:= IrrConlon( g );
    [ Character( CharacterTable( SL(2,3) ), [ 1, 1, 1, 1, 1, 1, 1 ] ),
      Character( CharacterTable( SL(2,3) ),
        [ 1, E(3), E(3)^2, 1, E(3)^2, E(3), 1 ] ),
      Character( CharacterTable( SL(2,3) ),
        [ 1, E(3)^2, E(3), 1, E(3), E(3)^2, 1 ] ),
      Character( CharacterTable( SL(2,3) ), [ 3, 0, 0, 3, 0, 0, -1 ] ) ]
    gap> irr3:= IrrBaumClausen( g );
    [ Character( CharacterTable( SL(2,3) ), [ 1, 1, 1, 1, 1, 1, 1 ] ),
      Character( CharacterTable( SL(2,3) ),
        [ 1, E(3), E(3)^2, 1, E(3)^2, E(3), 1 ] ),
      Character( CharacterTable( SL(2,3) ),
        [ 1, E(3)^2, E(3), 1, E(3), E(3)^2, 1 ] ),
      Character( CharacterTable( SL(2,3) ), [ 3, 0, 0, 3, 0, 0, -1 ] ) ]
    gap> chi:= irr2[4];;  HasTestMonomial( chi );
    true

##### 71.14-4 IrreducibleRepresentations

`‣ IrreducibleRepresentations`( G[, F] ) | ( attribute )

Called with a finite group G and a field F, `IrreducibleRepresentations` returns a list of representatives of the irreducible matrix representations of G over F, up to equivalence.

If G is the only argument then `IrreducibleRepresentations` returns a list of representatives of the absolutely irreducible complex representations of G, up to equivalence.

At the moment, methods are available for the following cases: If G is abelian by supersolvable the method of [BC94] is used.

Otherwise, if F and G are both finite, the regular module of G is split by MeatAxe methods which can make this an expensive operation.

Finally, if F is not given (i.e. it defaults to the cyclotomic numbers) and G is a finite group, the method of [Dix93] (see `IrreducibleRepresentationsDixon` (71.14-5)) is used.

For other cases no methods are implemented yet.

The representations obtained are not guaranteed to be nice (for example preserving a unitary form) in any way.

See also `IrreducibleModules` (71.15-1), which provides efficient methods for solvable groups.

    gap> g:= AlternatingGroup( 4 );;
    gap> repr:= IrreducibleRepresentations( g );
    [ Pcgs([ (2,4,3), (1,3)(2,4), (1,2)(3,4) ]) ->
        [ [ [ 1 ] ], [ [ 1 ] ], [ [ 1 ] ] ],
      Pcgs([ (2,4,3), (1,3)(2,4), (1,2)(3,4) ]) ->
        [ [ [ E(3) ] ], [ [ 1 ] ], [ [ 1 ] ] ],
      Pcgs([ (2,4,3), (1,3)(2,4), (1,2)(3,4) ]) ->
        [ [ [ E(3)^2 ] ], [ [ 1 ] ], [ [ 1 ] ] ],
      Pcgs([ (2,4,3), (1,3)(2,4), (1,2)(3,4) ]) ->
        [ [ [ 0, 0, 1 ], [ 1, 0, 0 ], [ 0, 1, 0 ] ],
          [ [ -1, 0, 0 ], [ 0, 1, 0 ], [ 0, 0, -1 ] ],
          [ [ 1, 0, 0 ], [ 0, -1, 0 ], [ 0, 0, -1 ] ] ] ]
    gap> ForAll( repr, IsGroupHomomorphism );
    true
    gap> Length( repr );
    4
    gap> gens:= GeneratorsOfGroup( g );
    [ (1,2,3), (2,3,4) ]
    gap> List( gens, x -> x^repr[1] );
    [ [ [ 1 ] ], [ [ 1 ] ] ]
    gap>  List( gens, x -> x^repr[4] );
    [ [ [ 0, 0, -1 ], [ 1, 0, 0 ], [ 0, -1, 0 ] ],
      [ [ 0, 1, 0 ], [ 0, 0, 1 ], [ 1, 0, 0 ] ] ]

##### 71.14-5 IrreducibleRepresentationsDixon

`‣ IrreducibleRepresentationsDixon`( G[, chi] ) | ( function )

Called with one argument, a group G, `IrreducibleRepresentationsDixon` computes (representatives of) all irreducible complex representations for the finite group G, using the method of [Dix93], which computes the character table and computes the representation as constituent of an induced monomial representation of a subgroup.

This method can be quite expensive for larger groups, for example it might involve calculation of the subgroup lattice of G.

A character chi of G can be given as the second argument, in this case only a representation affording chi is returned.

The second argument can also be a list of characters of G, in this case only representations for characters in this list are computed.

Note that this method might fail if for an irreducible representation there is no subgroup in which its reduction has a linear constituent with multiplicity one.

If the option unitary is given, GAP tries, at extra cost, to find a unitary representation (and will issue an error if it cannot do so).

    gap> a5:= AlternatingGroup( 5 );
    Alt( [ 1 .. 5 ] )
    gap> char:= First( Irr( a5 ), x -> x[1] = 4 );
    Character( CharacterTable( Alt( [ 1 .. 5 ] ) ), [ 4, 0, 1, -1, -1 ] )
    gap> hom:=IrreducibleRepresentationsDixon( a5, char: unitary );;
    gap> Order( a5.1*a5.2 ) = Order( Image( hom, a5.1 )*Image( hom, a5.2 ) );
    true
    gap> reps:= List( ConjugacyClasses( a5 ), Representative );;
    gap> List( reps, g -> TraceMat( Image( hom, g ) ) );
    [ 4, 0, 1, -1, -1 ]

#### 71.15 Representations Given by Modules

This section describes functions that return certain modules of a given group. (Extensions by modules can be formed by the command `Extensions` (46.8-4).)

##### 71.15-1 IrreducibleModules

`‣ IrreducibleModules`( G, F, dim ) | ( operation )

returns a list of length 2. The first entry is a generating system of G. The second entry is a list of all irreducible modules of G over the field F of dimension at most dim, given as MeatAxe modules (see `GModuleByMats` (69.1-1)). Pass `0` for dim to impose no dimension bound.

##### 71.15-2 AbsolutelyIrreducibleModules

`‣ AbsolutelyIrreducibleModules`( G, F, dim ) | ( operation )

`‣ AbsoluteIrreducibleModules`( G, F, dim ) | ( operation )

`‣ AbsolutIrreducibleModules`( G, F, dim ) | ( operation )

`AbsolutelyIrreducibleModules` returns a list of length 2. The first entry is a generating system of the group G. The second entry is a list of all those absolutely irreducible modules of G that can be realized over the finite field F and have dimension at most dim, given as MeatAxe modules (see `GModuleByMats` (69.1-1)).

The other two names are just synonyms.

##### 71.15-3 RegularModule

`‣ RegularModule`( G, F ) | ( operation )

returns a list of length 2. The first entry is a generating system of G. The second entry is the regular module of G over F, given as a MeatAxe module (see `GModuleByMats` (69.1-1)).

#### 71.16 The Dixon-Schneider Algorithm

The GAP library implementation of the Dixon-Schneider algorithm first computes the linear characters, using the commutator factor group. If irreducible characters are missing afterwards, they are computed using the techniques described in [Dix67], [Sch90] and [Hul93].

Called with a group \(G\), the function `CharacterTable` (71.3-1) returns a character table object that stores already information such as class lengths, but not the irreducible characters. The routines that compute the irreducibles may use the information that is already contained in this table object. In particular the ordering of classes in the computed characters coincides with the ordering of classes in the character table of G (see 71.6). Thus it is possible to combine computations using the group with character theoretic computations (see 71.17 for details), for example one can enter known characters. Note that the user is responsible for the correctness of the characters. (There is little use in providing the trivial character to the routine.)

The computation of irreducible characters from the group needs to identify the classes of group elements very often, so it can be helpful to store a class list of all group elements. Since this is obviously limited by the group order, it is controlled by the global function `IsDxLargeGroup` (71.17-8).

The routines compute in a prime field of size \(p\), such that the exponent of the group divides \((p-1)\) and such that \(2 \sqrt{{|G|}} < p\). Currently prime fields of size smaller than \(65\,536\) are handled more efficiently than larger prime fields, so the runtime of the character calculation depends on how large the chosen prime is.

The routine stores a Dixon record (see `DixonRecord` (71.17-1)) in the group that helps routines that identify classes, for example `FusionConjugacyClasses` (73.3-1), to work much faster. Note that interrupting Dixon-Schneider calculations will prevent GAP from cleaning up the Dixon record; when the computation by `IrrDixonSchneider` (71.14-1) is complete, the possibly large record is shrunk to an acceptable size.

#### 71.17 Advanced Methods for Dixon-Schneider Calculations

The computation of irreducible characters of very large groups may take quite some time. On the other hand, for the expert only a few irreducible characters may be needed, since the other ones can be computed using character theoretic methods such as tensoring, induction, and restriction. Thus GAP provides also step-by-step routines for doing the calculations. These routines allow one to compute some characters and to stop before all are calculated. Note that there is no safety net: The routines (being somehow internal) do no error checking, and assume the information given is correct.

When the info level of `InfoCharacterTable` (71.4-2) if positive, information about the progress of splitting is printed. (The default value is zero.)

##### 71.17-1 DixonRecord

`‣ DixonRecord`( G ) | ( attribute )

The `DixonRecord` of a group contains information used by the routines to compute the irreducible characters and related information via the Dixon-Schneider algorithm such as class arrangement and character spaces split obtained so far. Usually this record is passed as argument to all subfunctions to avoid a long argument list. It has a component `conjugacyClasses` which contains the classes of G ordered as the algorithm needs them.

##### 71.17-2 DixonInit

`‣ DixonInit`( G ) | ( function )

This function does all the initializations for the Dixon-Schneider algorithm. This includes calculation of conjugacy classes, power maps, linear characters and character morphisms. It returns a record (see `DixonRecord` (71.17-1) and Section 71.18) that can be used when calculating the irreducible characters of G interactively.

##### 71.17-3 DixontinI

`‣ DixontinI`( D ) | ( function )

This function ends a Dixon-Schneider calculation. It sorts the characters according to the degree and unbinds components in the Dixon record that are not of use any longer. It returns a list of irreducible characters.

##### 71.17-4 DixonSplit

`‣ DixonSplit`( D ) | ( function )

This function performs one splitting step in the Dixon-Schneider algorithm. It selects a class, computes the (partial) class sum matrix, uses it to split character spaces and stores all the irreducible characters obtained that way.

The class to use for splitting is chosen via `BestSplittingMatrix` (71.17-5) and the options described for this function apply here.

`DixonSplit` returns the number of the class that was used for splitting if a split was performed, and `fail` otherwise.

##### 71.17-5 BestSplittingMatrix

`‣ BestSplittingMatrix`( D ) | ( function )

returns the number of the class sum matrix that is assumed to yield the best (cost/earning ration) split. This matrix then will be the next one computed and used.

The global option `maxclasslen` (defaulting to `infinity` (18.2-1)) is recognized by `BestSplittingMatrix`: Only classes whose length is limited by the value of this option will be considered for splitting. If no usable class remains, `fail` is returned.

##### 71.17-6 DxIncludeIrreducibles

`‣ DxIncludeIrreducibles`( D, new[, newmod] ) | ( function )

This function takes a list of irreducible characters new, each given as a list of values (corresponding to the class arrangement in D), and adds these to a partial computed list of irreducibles as maintained by the Dixon record D. This permits one to add characters in interactive use obtained from other sources and to continue the Dixon-Schneider calculation afterwards. If the optional argument newmod is given, it must be a list of reduced characters, corresponding to new. (Otherwise the function has to reduce the characters itself.)

The function closes the new characters under the action of Galois automorphisms and tensor products with linear characters.

##### 71.17-7 SplitCharacters

`‣ SplitCharacters`( D, list ) | ( function )

This routine decomposes the characters given in list according to the character spaces found up to this point. By applying this routine to tensor products etc., it may result in characters with smaller norm, even irreducible ones. Since the recalculation of characters is only possible if the degree is small enough, the splitting process is applied only to characters of sufficiently small degree.

##### 71.17-8 IsDxLargeGroup

`‣ IsDxLargeGroup`( G ) | ( function )

returns `true` if the order of the group G is smaller than the current value of the global variable `DXLARGEGROUPORDER`, and `false` otherwise. In Dixon-Schneider calculations, for small groups in the above sense a class map is stored, whereas for large groups, each occurring element is identified individually.

#### 71.18 Components of a Dixon Record

The Dixon record D returned by `DixonInit` (71.17-2) stores all the information that is used by the Dixon-Schneider routines while computing the irreducible characters of a group. Some entries, however, may be useful to know about when using the algorithm interactively, see 71.19.

`group`

  the group \(G\) of which the character table is to be computed,

`conjugacyClasses`

  classes of \(G\) (all characters stored in the Dixon record correspond to this arrangement of classes),

`irreducibles`

  the already known irreducible characters (given as lists of their values on the conjugacy classes),

`characterTable`

  the `CharacterTable` (71.3-1) value of \(G\) (whose irreducible characters are not yet known),

`ClassElement( D, el )`

  a function that returns the number of the class of \(G\) that contains the element el.

#### 71.19 An Example of Advanced Dixon-Schneider Calculations

First, we set the appropriate info level higher.

    gap> SetInfoLevel( InfoCharacterTable, 1 );

for printout of some internal results. We now define our group, which is isomorphic to PSL\(_4(3)\).

    gap> g:= PrimitiveGroup(40,5);
    PSL(4, 3)
    gap> Size(g);
    6065280
    gap> d:= DixonInit( g );;
    #I  29 classes
    #I  choosing prime 65521
    gap> c:= d.characterTable;;

After the initialisation, one structure matrix is evaluated, yielding smaller spaces and several irreducible characters.

    gap> DixonSplit( d );
    #I  Matrix 2,Representative of Order 3,Centralizer: 5832
    #I  Dimensions: [ [ 1, 6 ], [ 2, 3 ], [ 4, 1 ], [ 12, 1 ] ]
    2

In this case spaces of the listed dimensions are a result of the splitting process. The three two dimensional spaces are split successfully by combinatoric means.

We obtain several irreducible characters by tensor products and notify them to the Dixon record.

    gap> asp:= AntiSymmetricParts( c, d.irreducibles, 2 );;
    gap> ro:= ReducedCharacters( c, d.irreducibles, asp );;
    gap> Length( ro.irreducibles );
    3
    gap> DxIncludeIrreducibles( d, ro.irreducibles );

Finally we calculate the characters induced from all cyclic subgroups and obtain the missing irreducibles by applying the LLL-algorithm to them.

    gap> ic:= InducedCyclic( c, "all" );;
    gap> ro:= ReducedCharacters( c, d.irreducibles, ic );;
    gap> Length( ro.irreducibles );
    0
    gap> l:= LLL( c, ro.remainders );;
    gap> Length( l.irreducibles );
    13

The LLL returns class function objects (see Chapter 72), and the Dixon record works with character values lists. So we convert them to a list of values before feeding them in the machinery of the Dixon-algorithm.

    gap> l.irreducibles[1];
    Character( CharacterTable( PSL(4, 3) ),
     [ 640, -8, -8, -8, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
      0, 0, 0, 0, E(13)^7+E(13)^8+E(13)^11, E(13)^4+E(13)^10+E(13)^12,
      E(13)^2+E(13)^5+E(13)^6, E(13)+E(13)^3+E(13)^9, 0 ] )
    gap> l:=List(l.irreducibles,ValuesOfClassFunction);;
    gap> DxIncludeIrreducibles( d, l );
    gap> Length( d.irreducibles );
    29
    gap> Length( d.classes );
    29

It turns out we have found all irreducible characters. As the last step, we obtain the irreducible characters and tell them to the group. This makes them available also to the character table.

    gap> irrs:= DixontinI( d );;
    #I  Total:1 matrices,[ 2 ]
    gap> SetIrr(g,irrs);
    gap> Length(Irr(c));
    29
    gap> SetInfoLevel( InfoCharacterTable, 0 );

#### 71.20 Constructing Character Tables from Others

The following operations take one or more character table arguments, and return a character table. This holds also for `BrauerTable` (71.3-2). Note that the return value of `BrauerTable` (71.3-2) will in general not know the irreducible Brauer characters, and GAP might be unable to compute these characters.

Note that whenever fusions between input and output tables occur in these operations, they are stored on the concerned tables, and the `NamesOfFusionSources` (73.3-5) values are updated.

(The interactive construction of character tables using character theoretic methods and incomplete tables is not described here.) Currently it is not supported and will be described in a chapter of its own when it becomes available.

##### 71.20-1 CharacterTableDirectProduct

`‣ CharacterTableDirectProduct`( tbl1, tbl2 ) | ( operation )

is the table of the direct product of the character tables tbl1 and tbl2.

The matrix of irreducibles of this table is the Kronecker product (see `KroneckerProduct` (24.5-9)) of the irreducibles of tbl1 and tbl2.

Products of ordinary and Brauer character tables are supported.

In general, the result will not know an underlying group, so missing power maps (for prime divisors of the result) and irreducibles of the input tables may be computed in order to construct the table of the direct product.

The embeddings of the input tables into the direct product are stored, they can be fetched with `GetFusionMap` (73.3-3); if tbl1 is equal to tbl2 then the two embeddings are distinguished by their `specification` components `"1"` and `"2"`, respectively.

Analogously, the projections from the direct product onto the input tables are stored, and can be distinguished by the `specification` components.

The attribute `FactorsOfDirectProduct` (71.20-2) is set to the lists of arguments.

The `*` operator for two character tables (see 71.7) delegates to `CharacterTableDirectProduct`.

    gap> c2:= CharacterTable( "Cyclic", 2 );;
    gap> s3:= CharacterTable( "Symmetric", 3 );;
    gap> Display( CharacterTableDirectProduct( c2, s3 ) );
    C2xSym(3)

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

           1a 2a 3a 2b 2c 6a
        2P 1a 1a 3a 1a 1a 3a
        3P 1a 2a 1a 2b 2c 2b

    X.1     1 -1  1  1 -1  1
    X.2     2  . -1  2  . -1
    X.3     1  1  1  1  1  1
    X.4     1 -1  1 -1  1 -1
    X.5     2  . -1 -2  .  1
    X.6     1  1  1 -1 -1 -1

##### 71.20-2 FactorsOfDirectProduct

`‣ FactorsOfDirectProduct`( tbl ) | ( attribute )

For an ordinary character table that has been constructed via `CharacterTableDirectProduct` (71.20-1), the value of `FactorsOfDirectProduct` is the list of arguments in the `CharacterTableDirectProduct` (71.20-1) call.

Note that there is no default method for computing the value of `FactorsOfDirectProduct`.

##### 71.20-3 CharacterTableFactorGroup

`‣ CharacterTableFactorGroup`( tbl, classes ) | ( operation )

is the character table of the factor group of the ordinary character table tbl by the normal closure of the classes whose positions are contained in the list classes.

The `/` operator for a character table and a list of class positions (see 71.7) delegates to `CharacterTableFactorGroup`.

    gap> s4:= CharacterTable( "Symmetric", 4 );;
    gap> ClassPositionsOfNormalSubgroups( s4 );
    [ [ 1 ], [ 1, 3 ], [ 1, 3, 4 ], [ 1 .. 5 ] ]
    gap> f:= CharacterTableFactorGroup( s4, [ 3 ] );
    CharacterTable( "Sym(4)/[ 1, 3 ]" )
    gap> Display( f );
    Sym(4)/[ 1, 3 ]

         2  1  1  .
         3  1  .  1

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

    X.1     1 -1  1
    X.2     2  . -1
    X.3     1  1  1

##### 71.20-4 CharacterTableIsoclinic

`‣ CharacterTableIsoclinic`( tbl[, arec] ) | ( operation )

`‣ CharacterTableIsoclinic`( tbl[, classes][, centre] ) | ( operation )

`‣ CharacterTableIsoclinic`( modtbl, ordiso ) | ( operation )

`‣ SourceOfIsoclinicTable`( tbl ) | ( attribute )

Let tbl be the (ordinary or modular) character table of a group \(H\) with the structure \(p.G.p\) for some prime \(p\), that is, \(H/Z\) has a normal subgroup \(N\) of index \(p\) and a central subgroup \(Z\) of order \(p\) contained in \(N\).

Then `CharacterTableIsoclinic` returns the table of an isoclinic group in the sense of the Atlas of Finite Groups [CCN+85, Chapter 6, Section 7].

If \(p = 2\) then also the case \(H = 4.G.2\) is supported, that is, \(Z\) has order four and \(N\) has index two in \(H\).

The optional arguments are needed if tbl does not determine the class positions of \(N\) or \(Z\) uniquely, and in the case \(p > 2\) if one wants to specify a variant number for the result.

- In general, the values can be specified via a record arec. If \(N\) is not uniquely determined then the positions of the classes forming \(N\) must be entered as the value of the component `normalSubgroup`. If \(Z\) is not unique inside \(N\) then the class position of a generator of \(Z\) must be entered as the value of the component `centralElement`.

- If \(p = 2\) then one may specify the positions of the classes forming \(N\) via a list classes, and the positions of the classes in \(Z\) as a list centre; if \(Z\) has order \(2\) then centre can be also the position of the involution in \(Z\).

Note that also if tbl is a Brauer table then `normalSubgroup` and `centralElement`, resp. classes and centre, denote class numbers w.r.t. the ordinary character table.

If \(p\) is odd then the Atlas construction describes \(p\) isoclinic variants that arise from \(p.G.p\). (These groups need not be pairwise nonisomorphic.) Entering an integer \(k \in \{ 1, 2, \ldots, p-1 \}\) as the value of the component `k` of arec yields the \(k\)-th of the corresponding character tables; the default for `k` is \(1\).

    gap> d8:= CharacterTable( "Dihedral", 8 );
    CharacterTable( "Dihedral(8)" )
    gap> nsg:= ClassPositionsOfNormalSubgroups( d8 );
    [ [ 1 ], [ 1, 3 ], [ 1 .. 3 ], [ 1, 3, 4 ], [ 1, 3 .. 5 ], [ 1 .. 5 ]
     ]
    gap> isod8:= CharacterTableIsoclinic( d8, nsg[3] );;
    gap> Display( isod8 );
    Isoclinic(Dihedral(8))

         2  3  2  3  2  2

           1a 4a 2a 4b 4c
        2P 1a 2a 1a 2a 2a

    X.1     1  1  1  1  1
    X.2     1  1  1 -1 -1
    X.3     1 -1  1  1 -1
    X.4     1 -1  1 -1  1
    X.5     2  . -2  .  .
    gap> t1:= CharacterTable( SmallGroup( 27, 3 ) );;
    gap> t2:= CharacterTable( SmallGroup( 27, 4 ) );;
    gap> nsg:= ClassPositionsOfNormalSubgroups( t1 );
    [ [ 1 ], [ 1, 4, 8 ], [ 1, 2, 4, 5, 8 ], [ 1, 3, 4, 7, 8 ],
      [ 1, 4, 6, 8, 11 ], [ 1, 4, 8, 9, 10 ], [ 1 .. 11 ] ]
    gap> iso1:= CharacterTableIsoclinic( t1, rec( k:= 1,
    >               normalSubgroup:= nsg[3] ) );;
    gap> iso2:= CharacterTableIsoclinic( t1, rec( k:= 2,
    >               normalSubgroup:= nsg[3] ) );;
    gap> TransformingPermutationsCharacterTables( iso1, t1 ) <> fail;
    false
    gap> TransformingPermutationsCharacterTables( iso1, t2 ) <> fail;
    true
    gap> TransformingPermutationsCharacterTables( iso2, t2 ) <> fail;
    true

For an ordinary character table that has been constructed via `CharacterTableIsoclinic`, the value of `SourceOfIsoclinicTable` encodes this construction, and is defined as follows. If \(p = 2\) then the value is the list with entries tbl, classes, the list of class positions of the nonidentity elements in \(Z\), and the class position of a generator of \(Z\). If \(p\) is an odd prime then the value is a record with the following components.

`table`

  the character table tbl,

`p`

  the prime \(p\),

`k`

  the variant number \(k\),

`outerClasses`

  the list of length \(p-1\) that contains at position \(i\) the sorted list of class positions of the \(i\)-th coset of the normal subgroup \(N\)

`centralElement`

  the class position of a generator of the central subgroup \(Z\).

There is no default method for computing the value of `SourceOfIsoclinicTable`.

    gap> SourceOfIsoclinicTable( isod8 );
    [ CharacterTable( "Dihedral(8)" ), [ 1 .. 3 ], [ 3 ], 3 ]
    gap> SourceOfIsoclinicTable( iso1 );
    rec( centralElement := 4, k := 1,
      outerClasses := [ [ 3, 6, 9 ], [ 7, 10, 11 ] ], p := 3,
      table := CharacterTable( <pc group of size 27 with 3 generators> ) )

If the arguments of `CharacterTableIsoclinic` are a Brauer table modtbl and an ordinary table ordiso then the `SourceOfIsoclinicTable` value of ordiso is assumed to be identical with the `OrdinaryCharacterTable` (71.8-4) value of modtbl, and the specified isoclinic table of modtbl is returned. This variant is useful if one has already constructed ordiso in advance.

    gap> g:= GL(2,3);;
    gap> t:= CharacterTable( g );;
    gap> iso:= CharacterTableIsoclinic( t );;
    gap> t3:= t mod 3;;
    gap> iso3:= CharacterTableIsoclinic( t3, iso );;
    gap> TransformingPermutationsCharacterTables( iso3,
    >        CharacterTableIsoclinic( t3 ) ) <> fail;
    true

Theoretical background: Consider the central product \(K\) of \(H\) with a cyclic group \(C\) of order \(p^2\). That is, \(K = H C\), \(C \leq Z(K)\), and the central subgroup \(Z\) of order \(p\) in \(H\) lies in \(C\). There are \(p+1\) subgroups of \(K\) that contain the normal subgroup \(N\) of index \(p\) in \(H\). One of them is the central product of \(C\) with \(N\), the others are \(H_0 = H\) and its isoclinic variants \(H_1, H_2, \ldots, H_{{p-1}}\). We fix \(g \in H \setminus N\) and a generator \(z\) of \(C\), and get \(H = N \cup N g \cup N g^2 \cup \cdots \cup N g^{{p-1}}\). Then \(H_k\), \(0 \leq k \leq p-1\), is given by \(N \cup N gz^k \cup N (gz^k)^2 \cup \cdots \cup N (gz^k)^{{p-1}}\). The conjugacy classes of all \(H_k\) are in bijection via multiplying the elements with suitable powers of \(z\), and the irreducible characters of all \(H_k\) extend to \(K\) and are in bijection via multiplying the character values with suitable \(p^2\)-th roots of unity.

##### 71.20-5 CharacterTableOfNormalSubgroup

`‣ CharacterTableOfNormalSubgroup`( ordtbl, classes ) | ( function )

Let ordtbl be the ordinary character table of a group \(G\), say, and classes be a list of class positions for this table. If the classes given by classes form a normal subgroup \(N\), say, of \(G\) and if these classes are conjugacy classes of \(N\) then this function returns the character table of \(N\). In all other cases, the function returns `fail`.

    gap> t:= CharacterTable( "Symmetric", 4 );
    CharacterTable( "Sym(4)" )
    gap> nsg:= ClassPositionsOfNormalSubgroups( t );
    [ [ 1 ], [ 1, 3 ], [ 1, 3, 4 ], [ 1 .. 5 ] ]
    gap> rest:= List( nsg, c -> CharacterTableOfNormalSubgroup( t, c ) );
    [ CharacterTable( "Rest(Sym(4),[ 1 ])" ), fail, fail,
      CharacterTable( "Rest(Sym(4),[ 1 .. 5 ])" ) ]

Here is a nontrivial example. We use `CharacterTableOfNormalSubgroup` for computing the two isoclinic variants of \(2.A_5.2\).

    gap> g:= SchurCoverOfSymmetricGroup( 5, 3, 1 );;
    gap> c:= CyclicGroup( 4 );;
    gap> dp:= DirectProduct( g, c );;
    gap> diag:= First( Elements( Centre( dp ) ),
    >                  x -> Order( x ) = 2 and
    >                       not x in Image( Embedding( dp, 1 ) ) and
    >                       not x in Image( Embedding( dp, 2 ) ) );;
    gap> fact:= Image( NaturalHomomorphismByNormalSubgroup( dp,
    >                      Subgroup( dp, [ diag ] ) ));;
    gap> t:= CharacterTable( fact );;
    gap> Size( t );
    480
    gap> nsg:= ClassPositionsOfNormalSubgroups( t );;
    gap> rest:= List( nsg, c -> CharacterTableOfNormalSubgroup( t, c ) );;
    gap> index2:= Filtered( rest, x -> x <> fail and Size( x ) = 240 );;
    gap> Length( index2 );
    2
    gap> tg:= CharacterTable( g );;
    gap> SortedList(List(index2,x->IsRecord(
    >       TransformingPermutationsCharacterTables(x,tg))));
    [ true, false ]

Alternatively, we could construct the character table of the central product with character theoretic methods. Or we could use `CharacterTableIsoclinic` (71.20-4).

##### 71.20-6 CharacterTableWreathSymmetric

`‣ CharacterTableWreathSymmetric`( tbl, n ) | ( function )

returns the character table of the wreath product of a group \(G\) with the full symmetric group on n points, where tbl is the character table of \(G\).

The result has values for `ClassParameters` (71.9-7) and `CharacterParameters` (71.9-7) stored, the entries in these lists are sequences of partitions. Note that this parametrization prevents the principal character from being the first one in the list of irreducibles.

    gap> c3:= CharacterTable( "Cyclic", 3 );;
    gap> wr:= CharacterTableWreathSymmetric( c3, 2 );;
    gap> Display( wr );
    C3wrS2

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

           1a  3a  3b  3c 3d  3e 2a  6a  6b
        2P 1a  3b  3a  3e 3d  3c 1a  3c  3e
        3P 1a  1a  1a  1a 1a  1a 2a  2a  2a

    X.1     1   1   1   1  1   1 -1  -1  -1
    X.2     2   A  /A   B -1  /B  .   .   .
    X.3     2  /A   A  /B -1   B  .   .   .
    X.4     1 -/A  -A  -A  1 -/A -1  /A   A
    X.5     2  -1  -1   2 -1   2  .   .   .
    X.6     1  -A -/A -/A  1  -A -1   A  /A
    X.7     1   1   1   1  1   1  1   1   1
    X.8     1 -/A  -A  -A  1 -/A  1 -/A  -A
    X.9     1  -A -/A -/A  1  -A  1  -A -/A

    A = -E(3)^2
      = (1+Sqrt(-3))/2 = 1+b3
    B = 2*E(3)
      = -1+Sqrt(-3) = 2b3
    gap> CharacterParameters( wr )[1];
    [ [ 1, 1 ], [  ], [  ] ]

##### 71.20-7 CharacterValueWreathSymmetric

`‣ CharacterValueWreathSymmetric`( tbl, n, beta, pi ) | ( function )

Let tbl be the ordinary character table of a group \(G\). The aim of this function is to compute a single character value from the character table of the wreath product of \(G\) with the full symmetric group on n points.

The conjugacy classes and the irreducible characters of this wreath product are parametrized by \(r\)-tuples of partitions which together form a partition of n (see `PartitionTuples` (16.2-31)), where \(r\) is the number of conjugacy classes of \(G\).

We describe the conjugacy class for which we want to compute the value by the \(r\)-tuple pi of partitions in question, and describe the character for which we want to compute the value by the \(r\)-tuple beta of `BetaSet` (16.2-33) values of the \(r\)-tuple of partitions in question.

    gap> n:= 4;;
    gap> classpara:= [ [], [ 2, 1, 1 ] ];;
    gap> charpara:= [ [ 2, 1 ], [ 1 ] ];;
    gap> betas:= List( charpara, BetaSet );;
    gap> c2:= CharacterTable( "Cyclic", 2 );;
    gap> CharacterValueWreathSymmetric( c2, n, betas, classpara );
    0
    gap> wr:= CharacterTableWreathSymmetric( c2, n );;
    gap> classpos:= Position( ClassParameters( wr ), classpara );;
    gap> charpos:= Position( CharacterParameters( wr ), charpara );;
    gap> Irr( wr )[ charpos, classpos ];
    0

This function can be useful if one is interested in only a few character values. If many character values are needed then it is probably faster to compute the whole character table of the wreath product using `CharacterTableWreathSymmetric` (71.20-6), which uses intermediate results of recursive computations and therefore can avoid repetitions.

#### 71.21 Sorted Character Tables

##### 71.21-1 CharacterTableWithSortedCharacters

`‣ CharacterTableWithSortedCharacters`( tbl[, perm] ) | ( operation )

is a character table that differs from tbl only by the succession of its irreducible characters. This affects the values of the attributes `Irr` (71.8-2) and `CharacterParameters` (71.9-7). Namely, these lists are permuted by the permutation perm.

If no second argument is given then a permutation is used that yields irreducible characters of increasing degree for the result. For the succession of characters in the result, see `SortedCharacters` (71.21-2).

The result has all those attributes and properties of tbl that are stored in `SupportedCharacterTableInfo` (71.3-4) and do not depend on the ordering of characters.

##### 71.21-2 SortedCharacters

`‣ SortedCharacters`( tbl, chars[, flag] ) | ( operation )

is a list containing the characters chars, ordered as specified by the other arguments.

There are three possibilities to sort characters: They can be sorted according to ascending norms (flag is the string `"norm"`), to ascending degree (flag is the string `"degree"`), or both (no third argument is given), i.e., characters with same norm are sorted according to ascending degree, and characters with smaller norm precede those with bigger norm.

Rational characters in the result precede other ones with same norm and/or same degree.

The trivial character, if contained in chars, will always be sorted to the first position.

##### 71.21-3 CharacterTableWithSortedClasses

`‣ CharacterTableWithSortedClasses`( tbl[, flag] ) | ( operation )

is a character table obtained by permutation of the classes of tbl. If the second argument flag is the string `"centralizers"` then the classes of the result are sorted according to descending centralizer orders. If the second argument is the string `"representatives"` then the classes of the result are sorted according to ascending representative orders. If no second argument is given then the classes of the result are sorted according to ascending representative orders, and classes with equal representative orders are sorted according to descending centralizer orders.

If the second argument is a permutation then the classes of the result are sorted by application of this permutation.

The result has all those attributes and properties of tbl that are stored in `SupportedCharacterTableInfo` (71.3-4) and do not depend on the ordering of classes.

##### 71.21-4 SortedCharacterTable

`‣ SortedCharacterTable`( tbl, kernel ) | ( function )

`‣ SortedCharacterTable`( tbl, normalseries ) | ( function )

`‣ SortedCharacterTable`( tbl, facttbl, kernel ) | ( function )

is a character table obtained on permutation of the classes and the irreducibles characters of tbl.

The first form sorts the classes at positions contained in the list kernel to the beginning, and sorts all characters in `Irr( tbl )` such that the first characters are those that contain kernel in their kernel.

The second form does the same successively for all kernels \(k_i\) in the list \(\textit{normalseries} = [ k_1, k_2, \ldots, k_n ]\) where \(k_i\) must be a sublist of \(k_{{i+1}}\) for \(1 \leq i \leq n-1\).

The third form computes the table \(F\) of the factor group of tbl modulo the normal subgroup formed by the classes whose positions are contained in the list kernel; \(F\) must be permutation equivalent to the table facttbl, in the sense of `TransformingPermutationsCharacterTables` (71.22-4), otherwise `fail` is returned. The classes of tbl are sorted such that the preimages of a class of \(F\) are consecutive, and that the succession of preimages is that of facttbl. The `Irr` (71.8-2) value of tbl is sorted as with `SortedCharacterTable( tbl, kernel )`.

(Note that the transformation is only unique up to table automorphisms of \(F\), and this need not be unique up to table automorphisms of tbl.)

All rearrangements of classes and characters are stable, i.e., the relative positions of classes and characters that are not distinguished by any relevant property is not changed.

The result has all those attributes and properties of tbl that are stored in `SupportedCharacterTableInfo` (71.3-4) and do not depend on the ordering of classes and characters.

The `ClassPermutation` (71.21-5) value of tbl is changed if necessary, see 71.5.

`SortedCharacterTable` uses `CharacterTableWithSortedClasses` (71.21-3) and `CharacterTableWithSortedCharacters` (71.21-1).

##### 71.21-5 ClassPermutation

`‣ ClassPermutation`( tbl ) | ( attribute )

is a permutation \(\pi\) of classes of the character table tbl. If it is stored then class fusions into tbl that are stored on other tables must be followed by \(\pi\) in order to describe the correct fusion.

This attribute value is bound only if tbl was obtained from another table by permuting the classes, using `CharacterTableWithSortedClasses` (71.21-3) or `SortedCharacterTable` (71.21-4).

It is necessary because the original table and the sorted table have the same identifier (and the same group if known), and hence the same fusions are valid for the two tables.

    gap> tbl:= CharacterTable( "Symmetric", 4 );
    CharacterTable( "Sym(4)" )
    gap> Display( tbl );
    Sym(4)

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

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

    X.1     1 -1  1  1 -1
    X.2     3 -1 -1  .  1
    X.3     2  .  2 -1  .
    X.4     3  1 -1  . -1
    X.5     1  1  1  1  1
    gap> srt1:= CharacterTableWithSortedCharacters( tbl );
    CharacterTable( "Sym(4)" )
    gap> List( Irr( srt1 ), Degree );
    [ 1, 1, 2, 3, 3 ]
    gap> srt2:= CharacterTableWithSortedClasses( tbl );
    CharacterTable( "Sym(4)" )
    gap> SizesCentralizers( tbl );
    [ 24, 4, 8, 3, 4 ]
    gap> SizesCentralizers( srt2 );
    [ 24, 8, 4, 3, 4 ]
    gap> nsg:= ClassPositionsOfNormalSubgroups( tbl );
    [ [ 1 ], [ 1, 3 ], [ 1, 3, 4 ], [ 1 .. 5 ] ]
    gap> srt3:= SortedCharacterTable( tbl, nsg );
    CharacterTable( "Sym(4)" )
    gap> nsg:= ClassPositionsOfNormalSubgroups( srt3 );
    [ [ 1 ], [ 1, 2 ], [ 1 .. 3 ], [ 1 .. 5 ] ]
    gap> Display( srt3 );
    Sym(4)

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

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

    X.1     1  1  1  1  1
    X.2     1  1  1 -1 -1
    X.3     2  2 -1  .  .
    X.4     3 -1  . -1  1
    X.5     3 -1  .  1 -1
    gap> ClassPermutation( srt3 );
    (2,4,3)

#### 71.22 Automorphisms and Equivalence of Character Tables

##### 71.22-1 MatrixAutomorphisms

`‣ MatrixAutomorphisms`( mat[, maps, subgroup] ) | ( operation )

For a matrix mat, `MatrixAutomorphisms` returns the group of those permutations of the columns of mat that leave the set of rows of mat invariant.

If the arguments maps and subgroup are given, only the group of those permutations is constructed that additionally fix each list in the list maps under pointwise action `OnTuples` (41.2-5), and subgroup is a permutation group that is known to be a subgroup of this group of automorphisms.

Each entry in maps must be a list of same length as the rows of mat. For example, if mat is a list of irreducible characters of a group then the list of element orders of the conjugacy classes (see `OrdersClassRepresentatives` (71.9-1)) may be an entry in maps.

##### 71.22-2 TableAutomorphisms

`‣ TableAutomorphisms`( tbl, characters[, info] ) | ( operation )

`TableAutomorphisms` returns the permutation group of those matrix automorphisms (see `MatrixAutomorphisms` (71.22-1)) of the list characters that leave the element orders (see `OrdersClassRepresentatives` (71.9-1)) and all stored power maps (see `ComputedPowerMaps` (73.1-1)) of the character table tbl invariant.

If characters is closed under Galois conjugacy –this is always fulfilled for the list of all irreducible characters of ordinary character tables– the string `"closed"` may be entered as the third argument info. Alternatively, a known subgroup of the table automorphisms can be entered as the third argument info.

The attribute `AutomorphismsOfTable` (71.9-4) can be used to compute and store the table automorphisms for the case that characters equals the `Irr` (71.8-2) value of tbl.

    gap> tbld8:= CharacterTable( "Dihedral", 8 );;
    gap> irrd8:= Irr( tbld8 );
    [ Character( CharacterTable( "Dihedral(8)" ), [ 1, 1, 1, 1, 1 ] ),
      Character( CharacterTable( "Dihedral(8)" ), [ 1, 1, 1, -1, -1 ] ),
      Character( CharacterTable( "Dihedral(8)" ), [ 1, -1, 1, 1, -1 ] ),
      Character( CharacterTable( "Dihedral(8)" ), [ 1, -1, 1, -1, 1 ] ),
      Character( CharacterTable( "Dihedral(8)" ), [ 2, 0, -2, 0, 0 ] ) ]
    gap> orders:= OrdersClassRepresentatives( tbld8 );
    [ 1, 4, 2, 2, 2 ]
    gap> MatrixAutomorphisms( irrd8 );
    Group([ (4,5), (2,4) ])
    gap> MatrixAutomorphisms( irrd8, [ orders ], Group( () ) );
    Group([ (4,5) ])
    gap> TableAutomorphisms( tbld8, irrd8 );
    Group([ (4,5) ])

##### 71.22-3 TransformingPermutations

`‣ TransformingPermutations`( mat1, mat2 ) | ( operation )

Let mat1 and mat2 be matrices. `TransformingPermutations` tries to construct a permutation \(\pi\) that transforms the set of rows of the matrix mat1 to the set of rows of the matrix mat2 by permuting the columns.

If such a permutation exists, a record with the components `columns`, `rows`, and `group` is returned, otherwise `fail`. For `TransformingPermutations( mat1, mat2 ) = r` \(\neq\) `fail`, we have `mat2 = Permuted( List( mat1, x -> Permuted( x, r.columns ) ), r.rows )`.

r`.group` is the group of matrix automorphisms of mat2 (see `MatrixAutomorphisms` (71.22-1)). This group stabilizes the transformation in the sense that applying any of its elements to the columns of mat2 preserves the set of rows of mat2.

##### 71.22-4 TransformingPermutationsCharacterTables

`‣ TransformingPermutationsCharacterTables`( tbl1, tbl2 ) | ( operation )

Let tbl1 and tbl2 be character tables. `TransformingPermutationsCharacterTables` tries to construct a permutation \(\pi\) that transforms the set of rows of the matrix `Irr( tbl1 )` to the set of rows of the matrix `Irr( tbl2 )` by permuting the columns (see `TransformingPermutations` (71.22-3)), such that \(\pi\) transforms also the power maps and the element orders.

If such a permutation \(\pi\) exists then a record with the components `columns` (\(\pi\)), `rows` (the permutation of `Irr( tbl1 )` corresponding to \(\pi\)), and `group` (the permutation group of table automorphisms of tbl2, see `AutomorphismsOfTable` (71.9-4)) is returned. If no such permutation exists, `fail` is returned.

    gap> tblq8:= CharacterTable( "Quaternionic", 8 );;
    gap> irrq8:= Irr( tblq8 );
    [ Character( CharacterTable( "Q8" ), [ 1, 1, 1, 1, 1 ] ),
      Character( CharacterTable( "Q8" ), [ 1, 1, 1, -1, -1 ] ),
      Character( CharacterTable( "Q8" ), [ 1, -1, 1, 1, -1 ] ),
      Character( CharacterTable( "Q8" ), [ 1, -1, 1, -1, 1 ] ),
      Character( CharacterTable( "Q8" ), [ 2, 0, -2, 0, 0 ] ) ]
    gap> OrdersClassRepresentatives( tblq8 );
    [ 1, 4, 2, 4, 4 ]
    gap> TransformingPermutations( irrd8, irrq8 );
    rec( columns := (), group := Group([ (4,5), (2,4) ]), rows := () )
    gap> TransformingPermutationsCharacterTables( tbld8, tblq8 );
    fail
    gap> tbld6:= CharacterTable( "Dihedral", 6 );;
    gap> tbls3:= CharacterTable( "Symmetric", 3 );;
    gap> TransformingPermutationsCharacterTables( tbld6, tbls3 );
    rec( columns := (2,3), group := Group(()), rows := (1,3,2) )

##### 71.22-5 FamiliesOfRows

`‣ FamiliesOfRows`( mat, maps ) | ( function )

distributes the rows of the matrix mat into families, as follows. Two rows of mat belong to the same family if there is a permutation of columns that maps one row to the other row. Each entry in the list maps is regarded to form a family of length 1.

`FamiliesOfRows` returns a record with the components

`famreps`

  the list of representatives for each family,

`permutations`

  the list that contains at position \(i\) a list of permutations that map the members of the family with representative `famreps`\([i]\) to that representative,

`families`

  the list that contains at position \(i\) the list of positions of members of the family of representative `famreps`\([i]\); (for the element maps\([i]\) the only member of the family will get the number `Length( mat ) +` \(i\)).

#### 71.23 Storing Normal Subgroup Information

##### 71.23-1 NormalSubgroupClassesInfo

`‣ NormalSubgroupClassesInfo`( tbl ) | ( attribute )

Let tbl be the ordinary character table of the group \(G\). Many computations for group characters of \(G\) involve computations in normal subgroups or factor groups of \(G\).

In some cases the character table tbl is sufficient; for example questions about a normal subgroup \(N\) of \(G\) can be answered if one knows the conjugacy classes that form \(N\), e.g., the question whether a character of \(G\) restricts irreducibly to \(N\). But other questions require the computation of \(N\) or even more information, like the character table of \(N\).

In order to do these computations only once, one stores in the group a record with components to store normal subgroups, the corresponding lists of conjugacy classes, and (if necessary) the factor groups, namely

`nsg`

  list of normal subgroups of \(G\), may be incomplete,

`nsgclasses`

  at position \(i\), the list of positions of conjugacy classes of tbl forming the \(i\)-th entry of the `nsg` component,

`nsgfactors`

  at position \(i\), if bound, the factor group modulo the \(i\)-th entry of the `nsg` component.

`NormalSubgroupClasses` (71.23-3), `FactorGroupNormalSubgroupClasses` (71.23-4), and `ClassPositionsOfNormalSubgroup` (71.23-2) each use these components, and they are the only functions to do so.

So if you need information about a normal subgroup for that you know the conjugacy classes, you should get it using `NormalSubgroupClasses` (71.23-3). If the normal subgroup was already used it is just returned, with all the knowledge it contains. Otherwise the normal subgroup is added to the lists, and will be available for the next call.

For example, if you are dealing with kernels of characters using the `KernelOfCharacter` (72.8-9) function you make use of this feature because `KernelOfCharacter` (72.8-9) calls `NormalSubgroupClasses` (71.23-3).

##### 71.23-2 ClassPositionsOfNormalSubgroup

`‣ ClassPositionsOfNormalSubgroup`( tbl, N ) | ( function )

is the list of positions of conjugacy classes of the character table tbl that are contained in the normal subgroup N of the underlying group of tbl.

##### 71.23-3 NormalSubgroupClasses

`‣ NormalSubgroupClasses`( tbl, classes ) | ( function )

returns the normal subgroup of the underlying group \(G\) of the ordinary character table tbl that consists of those conjugacy classes of tbl whose positions are in the list classes.

If `NormalSubgroupClassesInfo( tbl ).nsg` does not yet contain the required normal subgroup, and if `NormalSubgroupClassesInfo( tbl ).normalSubgroups` is bound then the result will be identical to the group in `NormalSubgroupClassesInfo( tbl ).normalSubgroups`.

##### 71.23-4 FactorGroupNormalSubgroupClasses

`‣ FactorGroupNormalSubgroupClasses`( tbl, classes ) | ( function )

is the factor group of the underlying group \(G\) of the ordinary character table tbl modulo the normal subgroup of \(G\) that consists of those conjugacy classes of tbl whose positions are in the list classes.

    gap> g:= SymmetricGroup( 4 );
    Sym( [ 1 .. 4 ] )
    gap> SetName( g, "S4" );
    gap> tbl:= CharacterTable( g );
    CharacterTable( S4 )
    gap> irr:= Irr( g );
    [ Character( CharacterTable( S4 ), [ 1, -1, 1, 1, -1 ] ),
      Character( CharacterTable( S4 ), [ 3, -1, -1, 0, 1 ] ),
      Character( CharacterTable( S4 ), [ 2, 0, 2, -1, 0 ] ),
      Character( CharacterTable( S4 ), [ 3, 1, -1, 0, -1 ] ),
      Character( CharacterTable( S4 ), [ 1, 1, 1, 1, 1 ] ) ]
    gap> kernel:= KernelOfCharacter( irr[3] );;
    gap> AsSet(kernel);
    [ (), (1,2)(3,4), (1,3)(2,4), (1,4)(2,3) ]
    gap> SetName(kernel,"V4");
    gap> HasNormalSubgroupClassesInfo( tbl );
    true
    gap> NormalSubgroupClassesInfo( tbl );
    rec( nsg := [ V4 ], nsgclasses := [ [ 1, 3 ] ], nsgfactors := [  ] )
    gap> ClassPositionsOfNormalSubgroup( tbl, kernel );
    [ 1, 3 ]
    gap> G := FactorGroupNormalSubgroupClasses( tbl, [ 1, 3 ] );;
    gap> NormalSubgroupClassesInfo( tbl ).nsgfactors[1] = G;
    true

[Top of Book] [Contents] [Previous Chapter] [Next Chapter]
Goto Chapter: Top 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 Bib Ind

generated by GAPDoc2HTML