Welcome To Our Shell

Mister Spy & Souheyl Bypass Shell

  
  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.
  
    Example  
    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,  say,  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 χ, ψ of
  G given by
  
  
  [ χ, ψ ] = ( ∑_{g ∈ G} χ(g) ψ(g^{-1}) ) / |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
  χ, ψ, 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 for p-solvable groups
  (using  the  Fong-Swan  Theorem) and in the case that 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.
  
    Example  
    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 (79.18-9) and DeclareProperty (79.18-10).
  
  71.3-5 ConvertToCharacterTable
  
  ConvertToCharacterTable( record )  function
  ConvertToCharacterTableNC( record )  function
  
  Let  record  be  a  record.  ConvertToCharacterTable  converts record into a
  component  object  (see 79.10) 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.
  
    Example  
    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.
  
    Example  
    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.
  
    Example  
    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].
  
    Example  
    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-24))  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.
  
    Example  
    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)).
  
    Example  
    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).
  
    Example  
    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
  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.
  
    Example  
    gap> tables:= [ CharacterTable( CyclicGroup( 3 ) ),
    >               CharacterTable( SymmetricGroup( 4 ) ),
    >               CharacterTable( AlternatingGroup( 5 ) ) ];;
    gap> List( tables, AbelianInvariants );
    [ [ 3 ], [ 2 ], [  ] ]
    gap> List( tables, CommutatorLength );
    [ 1, 1, 1 ]
    gap> List( tables, Exponent );
    [ 3, 12, 30 ]
    gap> List( tables, IsAbelian );
    [ true, false, false ]
    gap> List( tables, IsAlmostSimple );
    [ false, false, true ]
    gap> List( tables, IsCyclic );
    [ true, false, false ]
    gap> List( tables, IsFinite );
    [ true, true, true ]
    gap> List( tables, IsMonomial );
    [ true, true, false ]
    gap> List( tables, IsNilpotent );
    [ true, false, false ]
    gap> List( tables, IsPerfect );
    [ false, false, true ]
    gap> List( tables, IsSimple );
    [ true, false, true ]
    gap> List( tables, IsSolvable );
    [ true, true, false ]
    gap> List( tables, IsSupersolvable );
    [ true, false, false ]
    gap> List( tables, NrConjugacyClasses );
    [ 3, 5, 5 ]
    gap> List( tables, Size );
    [ 3, 24, 60 ]
    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.
  
    Example  
    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.
  
    Example  
    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.
  
    Example  
    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)).
  
    Example  
    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).
  
    Example  
    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).
  
    Example  
    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.
  
    Example  
    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.
  
    Example  
    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)).
  
    Example  
    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}.
  
    Example  
    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.
  
    Example  
    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.
  
    Example  
    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.)
  
    Example  
    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.
  
    Example  
    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.
  
    Example  
    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| ≤ |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.
  
    Example  
    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.
  
    Example  
    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.
  
    Example  
    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.
  
    Example  
    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.
  
    Example  
    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  RadicalGroup  (39.12-9)  for  the  group  of  the  ordinary
  character table ordtbl.
  
    Example  
    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.
  
    Example  
    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.
  
    Example  
    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.
  
    Example  
    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 χ, ψ of a group G are said to lie in the
  same   p-block   if   the  images  of  their  central  characters  ω_χ,  ω_ψ
  (see CentralCharacter  (72.8-17)) under the natural ring epimorphism R → 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 ⊆ 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 χ in the block is defined as the largest exponent
  h for which p^h divides χ(1) / p^{a-d}.
  
    Example  
    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.
  
    Example  
    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.
  
    Example  
    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).
  
    Example  
    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).
  
    Example  
    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-7) 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-24)  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.
  
    Example  
    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,  say,  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.
  
    Example  
    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 ν_n(χ) of an ordinary character χ of the
  group G is given by ν_n(χ) = ( ∑_{g ∈ G} χ(g^n) ) / |G|.
  
  If  tbl  is  a  Brauer  table in characteristic ≠ 2 and 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.
  
    Example  
    gap> tbl:= CharacterTable( "L3(2)" );;
    gap> Indicator( tbl, 2 );
    [ 1, 0, 0, 1, 1, 1 ]
  
  
  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.
  
    Example  
    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 ∈ 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 = ∑_k c_ijk K_k .
  
  Given  the  character table of a finite group G, whose classes are C_1, ...,
  C_r  with  representatives  g_i  ∈ C_i, the class multiplication coefficient
  c_ijk can be computed with the following formula:
  
  
  c_ijk = |C_i| ⋅ |C_j| / |G| ⋅ ∑_{χ ∈ Irr(G)} χ(g_i) χ(g_j) χ(g_k^{-1}) / χ(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, ..., 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, ..., g_n) of elements g_i ∈ C_i with g_1 g_2 ⋯ g_n = 1.
  Note   the   difference  to  the  definition  of  the  class  multiplication
  coefficients in ClassMultiplicationCoefficient (71.12-7).
  
  n(C_1, C_2, ..., C_n) is computed using the formula
  
  
  n(C_1, C_2, ..., C_n) = |C_1| |C_2| ⋯ |C_n| / |G| ⋅ ∑_{χ ∈ Irr(G)} χ(g_1) χ(g_2) ⋯ χ(g_n) / χ(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)).
  
    Example  
    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???) method
  for  character tables that is provided by the GAP package Browse, see 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],
  
  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 this
        case the letter "X" is replaced by "Y"),
  
  classes
        an integer or a list of integers to select a sublist of the classes of
        tbl,
  
  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],
  
  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.
  
    Example  
    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).
  
    Example  
    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 certain
  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.
  
    Example  
    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.
  
    Example  
    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).
  
    Example  
    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 in
  dimension dim, given as MeatAxe modules (see GModuleByMats (69.1-1)).
  
  71.15-2 AbsolutelyIrreducibleModules
  
  AbsolutelyIrreducibleModules( G, F, dim )  operation
  AbsoluteIrreducibleModules( G, F, dim )  operation
  AbsolutIrreducibleModules( 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 absolute irreducible modules of G over the
  field  F  in  dimension  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 65536 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.
  
    Example  
    gap> SetInfoLevel( InfoCharacterTable, 1 );
  
  
  for  printout  of  some  internal results. We now define our group, which is
  isomorphic to PSL_4(3).
  
    Example  
    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.
  
    Example  
    gap> DixonSplit( d );
    #I  Matrix 2,Representative of Order 3,Centralizer: 5832
    #I  Dimensions: [ 1, 2, 1, 4, 12, 1, 1, 2, 1, 2, 1 ]
    #I  Two-dim space split
    #I  Two-dim space split
    #I  Two-dim space split
    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.
  
    Example  
    gap> asp:= AntiSymmetricParts( c, d.irreducibles, 2 );;
    gap> ro:= ReducedCharacters( c, d.irreducibles, asp );;
    gap> Length( ro.irreducibles );
    3
    gap> DxIncludeIrreducibles( d, ro.irreducibles );
  
  
  The tensor products of the nonlinear characters among each other are reduced
  with the irreducible characters. The result is split according to the spaces
  found, which yields characters of smaller norms, but no new irreducibles.
  
    Example  
    gap> nlc:= Filtered( d.irreducibles, i -> i[1] > 1 );;
    gap> t:= Tensored( nlc, nlc );;
    gap> ro:= ReducedCharacters( c, d.irreducibles, t );;  ro.irreducibles;
    [  ]
    gap> List( ro.remainders, i -> ScalarProduct( c, i, i) );
    [ 2, 2, 4, 4, 4, 4, 13, 13, 18, 18, 19, 21, 21, 36, 36, 29, 34, 34, 
      42, 34, 48, 54, 62, 68, 68, 78, 84, 84, 88, 90, 159, 169, 169, 172, 
      172, 266, 271, 271, 268, 274, 274, 280, 328, 373, 373, 456, 532, 
      576, 679, 683, 683, 754, 768, 768, 890, 912, 962, 1453, 1453, 1601, 
      1601, 1728, 1739, 1739, 1802, 2058, 2379, 2414, 2543, 2744, 2744, 
      2920, 3078, 3078, 4275, 4275, 4494, 4760, 5112, 5115, 5115, 5414, 
      6080, 6318, 7100, 7369, 7369, 7798, 8644, 10392, 12373, 12922, 
      14122, 14122, 18948, 21886, 24641, 24641, 25056, 38942, 44950, 
      78778 ]
    gap> t:= SplitCharacters( d, ro.remainders );;
    gap> List( t, i -> ScalarProduct( c, i, i ) );
    [ 2, 2, 4, 2, 2, 4, 4, 3, 6, 5, 5, 9, 9, 4, 12, 13, 18, 18, 20, 18, 
      20, 24, 26, 32, 32, 16, 42, 59, 69, 69, 72, 72, 36, 72, 78, 78, 84, 
      122, 117, 127, 117, 127, 64, 132, 100, 144, 196, 256, 456, 532, 
      576, 679, 683, 683, 754, 768, 768, 890, 912, 962, 1453, 1453, 1601, 
      1601, 1728, 1739, 1739, 1802, 2058, 2379, 2414, 2543, 2744, 2744, 
      2920, 3078, 3078, 4275, 4275, 4494, 4760, 5112, 5115, 5115, 5414, 
      6080, 6318, 7100, 7369, 7369, 7798, 8644, 10392, 12373, 12922, 
      14122, 14122, 18948, 21886, 24641, 24641, 25056, 38942, 44950, 
      78778 ]
  
  
  Finally  we  calculate  the characters induced from all cyclic subgroups and
  obtain the missing irreducibles by applying the LLL-algorithm to them.
  
    Example  
    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.
  
    Example  
    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.
  
    Example  
    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-8)) 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.
  
    Example  
    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.
  
    Example  
    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[, classes][, centre] )  operation
  SourceOfIsoclinicTable( tbl )  attribute
  
  If  tbl  is  the  (ordinary  or modular) character table of a group with the
  structure  2.G.2  with  a  central  subgroup  Z of order 2 or 4 and a normal
  subgroup  N  of index 2 that contains Z then CharacterTableIsoclinic returns
  the  table of the isoclinic group in the sense of the Atlas of Finite Groups
  [CCN+85,  Chapter  6,  Section  7]. If N is not uniquely determined then the
  positions  of the classes forming N must be entered as list classes. If Z is
  not  unique  inside N then the positions of the classes in Z must be entered
  as 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 classes and centre denote class
  numbers w.r.t. the ordinary character table.
  
  For   an   ordinary   character   table   that   has  been  constructed  via
  CharacterTableIsoclinic,  the value of SourceOfIsoclinicTable is the list of
  three arguments in the CharacterTableIsoclinic call.
  
  Note   that   there  is  no  default  method  for  computing  the  value  of
  SourceOfIsoclinicTable.
  
    Example  
    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> iso:= CharacterTableIsoclinic( d8, nsg[3] );;
    gap> Display( iso );
    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> SourceOfIsoclinicTable( iso );
    [ CharacterTable( "Dihedral(8)" ), [ 1, 2, 3 ], [ 3 ], 3 ]
  
  
  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.
  
    Example  
    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.
  
    Example  
    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> IsRecord(
    >        TransformingPermutationsCharacterTables( index2[1], tg ) );
    true
    gap> IsRecord(
    >        TransformingPermutationsCharacterTables( index2[2], tg ) );
    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.
  
    Example  
    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.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
  normalseries = [ k_1, k_2, ..., k_n ] where k_i must be a sublist of k_{i+1}
  for 1 ≤ i ≤ 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 SortCharTable( 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  π 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 π 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.
  
    Example  
    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.
  
    Example  
    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  π 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 ≠ 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 π
  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 π transforms also the
  power maps and the element orders.
  
  If  such  a  permutation  π exists then a record with the components columns
  (π),  rows  (the  permutation  of Irr( tbl1 ) corresponding to π), 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.
  
    Example  
    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.
  
    Example  
    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] );
    Group([ (1,2)(3,4), (1,4)(2,3) ])
    gap> HasNormalSubgroupClassesInfo( tbl );
    true
    gap> NormalSubgroupClassesInfo( tbl );
    rec( nsg := [ Group([ (1,2)(3,4), (1,4)(2,3) ]) ],
      nsgclasses := [ [ 1, 3 ] ], nsgfactors := [  ] )
    gap> ClassPositionsOfNormalSubgroup( tbl, kernel );
    [ 1, 3 ]
    gap> G := FactorGroupNormalSubgroupClasses( tbl, [ 1, 3 ] );;
    gap> NormalSubgroupClassesInfo( tbl ).nsgfactors[1] = G;
    true