/usr/share/gap/pkg/CtblLib/doc/chap4.txt

  
  4 Contents of the GAP Character Table Library
  
  This chapter informs you about
  
      the currently available character tables (see Section[14 X4.1),
  
      generic character tables (see Section[14 X4.2),
  
      the  subsets  of  Atlas  tables  (see Section[14 X4.3) and CAS tables (see
        Section[14 X4.4),
  
      installing   the   library,   and   related   user   preferences  (see
        Section[14 X4.5).
  
  The  following  rather  technical sections are thought for those who want to
  maintain or extend the Character Table Library.
  
      the technicalities of the access to library tables (see Section[14 X4.6),
  
      how to extend the library (see Section[14 X4.7), and
  
      sanity checks (see Section[14 X4.8).
  
  
  4.1 Ordinary and Brauer Tables in the GAP Character Table Library
  
  This  section  gives  a  brief overview of the contents of the GAP character
  table  library.  For  the details about, e. g., the structure of data files,
  see Section[14 X4.6.
  
  The  changes in the character table library since the first release of GAP 4
  are listed in a file that can be fetched from
  
  https://www.math.rwth-aachen.de/~Thomas.Breuer/ctbllib/htm/ctbldiff.htm.
  
  There  are  three  different  kinds  of character tables in the GAP library,
  namely  ordinary  character  tables,  Brauer  tables,  and generic character
  tables. Note that the Brauer table and the corresponding ordinary table of a
  group determine the decomposition matrix of the group (and the decomposition
  matrices  of  its blocks). These decomposition matrices can be computed from
  the  ordinary  and  modular  irreducibles  with GAP, see Section[14 X'Reference:
  Operations  Concerning Blocks' for details. A collection of PDF files of the
  known  decomposition  matrices  of  Atlas  tables in the GAP Character Table
  Library can also be found at
  
  https://www.math.rwth-aachen.de/~MOC/decomposition/.
  
  
  4.1-1 Ordinary Character Tables
  
  Two  different  aspects  are  useful  to  list the ordinary character tables
  available  in GAP, namely the aspect of the source of the tables and that of
  relations between the tables.
  
  As  for the source, there are first of all two big sources, namely the Atlas
  of  Finite  Groups (see Section[14 X4.3) and the CAS library of character tables
  (see [NPP84]).  Many  Atlas  tables  are  contained  in the CAS library, and
  difficulties  may  arise because the succession of characters and classes in
  CAS tables and Atlas tables are in general different, so see Section[14 X4.4 for
  the  relations  between  these  two variants of character tables of the same
  group.  A subset of the CAS tables is the set of tables of Sylow normalizers
  of  sporadic  simple  groups  as published in [Ost86]  this may be viewed as
  another  source of character tables. The library also contains the character
  tables   of   factor   groups  of  space  groups  (computed  by  W. Hanrath,
  see [Han88])  that are part of [HP89], in the form of two microfiches; these
  tables  are  given  in  CAS format (see Section[14 X4.4) on the microfiches, but
  they had not been part of the official CAS library.
  
  To  avoid  confusion about the ordering of classes and characters in a given
  table, authorship and so on, the InfoText (Reference: InfoText) value of the
  table contains the information
  
  origin: ATLAS of finite groups
        for Atlas tables (see Section[14 X4.3),
  
  origin: Ostermann
        for tables contained in [Ost86],
  
  origin: CAS library
        for  any  table  of the CAS table library that is contained neither in
        the Atlas nor in [Ost86], and
  
  origin: Hanrath library
        for tables contained in the microfiches in [HP89].
  
  The  InfoText  (Reference:  InfoText)  value  usually contains more detailed
  information,  for  example that the table in question is the character table
  of  a maximal subgroup of an almost simple group. If the table was contained
  in  the  CAS  library  then  additional information may be available via the
  CASInfo (4.4-1) value.
  
  If  one  is interested in the aspect of relations between the tables, i. e.,
  the  internal  structure of the library of ordinary tables, the contents can
  be listed up the following way.
  
  We have
  
      all  Atlas  tables  (see Section[14 X4.3), i. e., the tables of the simple
        groups  which  are  contained  in  the Atlas of Finite Groups, and the
        tables of cyclic and bicyclic extensions of these groups,
  
      most  tables  of  maximal subgroups of sporadic simple groups (not all
        for the Monster group),
  
      many  tables  of  maximal  subgroups  of other Atlas tables; the Maxes
        (3.7-1)  value for the table is set if all tables of maximal subgroups
        are available,
  
      the tables of many Sylow p-normalizers of sporadic simple groups; this
        includes  the tables printed in [Ost86] except J_4N2, Co_1N2, Fi_22N2,
        but also other tables are available; more generally, several tables of
        normalizers  of  other  radical  p-subgroups  are  available,  such as
        normalizers of defect groups of p-blocks,
  
      some tables of element centralizers,
  
      some tables of Sylow p-subgroups,
  
      and a few other tables, e. g.[10 XW(F4)
  
  Note  that  class  fusions stored on library tables are not guaranteed to be
  compatible for any two subgroups of a group and their intersection, and they
  are not guaranteed to be consistent w. r. t. the composition of maps.
  
  
  4.1-2 Brauer Tables
  
  The  library  contains  all tables of the Atlas of Brauer Tables ([JLPW95]),
  and  many  other Brauer tables of bicyclic extensions of simple groups which
  are known yet. The Brauer tables in the library contain the information
  
  origin: modular ATLAS of finite groups
  
  in their InfoText (Reference: InfoText) string.
  
  
  4.2 Generic Character Tables
  
  Generic  character  tables  provide  a  means for writing down the character
  tables  of  all  groups  in  a  (usually infinite) series of similar groups,
  e. g.,  cyclic  groups,  or  symmetric  groups, or the general linear groups
  GL(2,q) where q ranges over certain prime powers.
  
  Let { G_q | q ∈ I } be such a series, where I is an index set. The character
  table  of one fixed member G_q could be computed using a function that takes
  q  as  only  argument and constructs the table of G_q. It is, however, often
  desirable  to  compute  not  only  the  whole  table  but to access just one
  specific  character,  or  to  compute  just  one  character  value,  without
  computing the whole character table.
  
  For  example,  both  the conjugacy classes and the irreducible characters of
  the  symmetric group S_n are in bijection with the partitions of n. Thus for
  given  n  it  makes  sense  to  ask  for  the  character  corresponding to a
  particular partition, or just for its character value at another partition.
  
  A  generic character table in GAP allows one such local evaluations. In this
  sense,  GAP  can  deal  also  with  character  tables that are too big to be
  computed and stored as a whole.
  
  Currently  the  only  operations for generic tables supported by GAP are the
  specialisation  of  the  parameter q in order to compute the whole character
  table   of   G_q,  and  local  evaluation  (see[2 XClassParameters  (Reference:
  ClassParameters)  for  an example). GAP does not support the computation of,
  e. g., generic scalar products.
  
  While the numbers of conjugacy classes for the members of a series of groups
  are  usually  not  bounded,  there  is always a fixed finite number of types
  (equivalence  classes)  of  conjugacy  classes;  very  often the equivalence
  relation is isomorphism of the centralizers of the representatives.
  
  For  each  type  t  of  classes  and a fixed q ∈ I, a parametrisation of the
  classes  in t is a function that assigns to each conjugacy class of G_q in t
  a parameter by which it is uniquely determined. Thus the classes are indexed
  by pairs [t,p_t] consisting of a type t and a parameter p_t for that type.
  
  For  any  generic  table,  there  has  to  be  a  fixed  number  of types of
  irreducible characters of G_q, too. Like the classes, the characters of each
  type are parametrised.
  
  In  GAP,  the parametrisations of classes and characters for tables computed
  from   generic   tables  is  stored  using  the  attributes  ClassParameters
  (Reference:    ClassParameters)    and    CharacterParameters    (Reference:
  CharacterParameters).
  
  
  4.2-1 Available generic character tables
  
  Currently,  generic  tables  of the following groups –in alphabetical order–
  are available in GAP. (A list of the names of generic tables known to GAP is
  LIBTABLE.GENERIC.firstnames.)  We  list  the  function calls needed to get a
  specialized  table,  the  generic  table  itself  can be accessed by calling
  CharacterTable (Reference: CharacterTable) with the first argument only; for
  example,  CharacterTable(  "Cyclic"  )  yields  the  generic table of cyclic
  groups.
  
  CharacterTable( "Alternating", n )
        the table of the alternating group on n letters,
  
  CharacterTable( "Cyclic", n )
        the table of the cyclic group of order n,
  
  CharacterTable( "Dihedral", 2n )
        the table of the dihedral group of order 2n,
  
  CharacterTable( "DoubleCoverAlternating", n )
        the  table  of  the  Schur  double cover of the alternating group on n
        letters (see [Noe02]),
  
  CharacterTable( "DoubleCoverSymmetric", n )
        the table of the standard Schur double cover of the symmetric group on
        n letters (see [Noe02]),
  
  CharacterTable( "GL", 2, q )
        the table of the general linear group GL(2,q), for a prime power q,
  
  CharacterTable( "GU", 3, q )
        the table of the general unitary group GU(3,q), for a prime power q,
  
  CharacterTable( "P:Q", [ p, q ] ) and CharacterTable( "P:Q", [ p, q, k ] )
        the table of the Frobenius extension of the nontrivial cyclic group of
        odd  order p by the nontrivial cyclic group of order q where q divides
        p_i-1  for  all  prime divisors p_i of p; if p is a prime power then q
        determines  the group uniquely and thus the first version can be used,
        otherwise  the  action of the residue class of k modulo p is taken for
        forming  orbits  of  length  q each on the nonidentity elements of the
        group of order p,
  
  CharacterTable( "PSL", 2, q )
        the table of the projective special linear group PSL(2,q), for a prime
        power q,
  
  CharacterTable( "SL", 2, q )
        the table of the special linear group SL(2,q), for a prime power q,
  
  CharacterTable( "SU", 3, q )
        the table of the special unitary group SU(3,q), for a prime power q,
  
  CharacterTable( "Suzuki", q )
        the  table of the Suzuki group Sz(q) = ^2B_2(q), for q an odd power of
        2,
  
  CharacterTable( "Symmetric", n )
        the table of the symmetric group on n letters,
  
  CharacterTable( "WeylB", n )
        the table of the Weyl group of type B_n,
  
  CharacterTable( "WeylD", n )
        the table of the Weyl group of type D_n.
  
  In addition to the above calls that really use generic tables, the following
  calls  to  CharacterTable  (Reference:  CharacterTable)  are  to some extent
  generic  constructions.  But  note  that  no local evaluation is possible in
  these  cases, as no generic table object exists in GAP that can be asked for
  local information.
  
  CharacterTable( "Quaternionic", 4n )
        the table of the generalized quaternionic group of order 4n,
  
  CharacterTableWreathSymmetric( tbl, n )
        the  character table of the wreath product of the group whose table is
        tbl     with     the     symmetric     group     on     n     letters,
        see[2 XCharacterTableWreathSymmetric                          (Reference:
        CharacterTableWreathSymmetric).
  
  4.2-2 CharacterTableSpecialized
  
  CharacterTableSpecialized( gentbl, q )  function
  
  For  a record gentbl representing a generic character table, and a parameter
  value q, CharacterTableSpecialized returns a character table object computed
  by evaluating gentbl at q.
  
    Example  
    gap> c5:= CharacterTableSpecialized( CharacterTable( "Cyclic" ), 5 );
    CharacterTable( "C5" )
    gap> Display( c5 );
    C5
    
         5  1  1  1  1  1
    
           1a 5a 5b 5c 5d
        5P 1a 1a 1a 1a 1a
    
    X.1     1  1  1  1  1
    X.2     1  A  B /B /A
    X.3     1  B /A  A /B
    X.4     1 /B  A /A  B
    X.5     1 /A /B  B  A
    
    A = E(5)
    B = E(5)^2
  
  
  (Also  CharacterTable(  "Cyclic",  5 ) could have been used to construct the
  above table.)
  
    Example  
    gap> HasClassParameters( c5 );  HasCharacterParameters( c5 );
    true
    true
    gap> ClassParameters( c5 );  CharacterParameters( c5 );
    [ [ 1, 0 ], [ 1, 1 ], [ 1, 2 ], [ 1, 3 ], [ 1, 4 ] ]
    [ [ 1, 0 ], [ 1, 1 ], [ 1, 2 ], [ 1, 3 ], [ 1, 4 ] ]
    gap> ClassParameters( CharacterTable( "Symmetric", 3 ) );
    [ [ 1, [ 1, 1, 1 ] ], [ 1, [ 2, 1 ] ], [ 1, [ 3 ] ] ]
  
  
  Here  are  examples  for  the  local evaluation of generic character tables,
  first  a  character  value of the cyclic group shown above, then a character
  value and a representative order of a symmetric group.
  
    Example  
    gap> CharacterTable( "Cyclic" ).irreducibles[1][1]( 5, 2, 3 );
    E(5)
    gap> tbl:= CharacterTable( "Symmetric" );;
    gap> tbl.irreducibles[1][1]( 5, [ 3, 2 ], [ 2, 2, 1 ] );
    1
    gap> tbl.orders[1]( 5, [ 2, 1, 1, 1 ] );
    2
  
  
  
  4.2-3 Components of generic character tables
  
  Any  generic  table  in  GAP  is  represented  by  a  record.  The following
  components are supported for generic character table records.
  
  centralizers
        list  of  functions,  one  for each class type t, with arguments q and
        p_t, returning the centralizer order of the class [t,p_t],
  
  charparam
        list  of  functions,  one  for each character type t, with argument q,
        returning the list of character parameters of type t,
  
  classparam
        list  of  functions,  one  for  each  class  type  t, with argument q,
        returning the list of class parameters of type t,
  
  classtext
        list  of  functions,  one  for each class type t, with arguments q and
        p_t,  returning  a  representative of the class with parameter [t,p_t]
        (note  that  this  element  need  not  actually  lie  in  the group in
        question,   for   example   it  may  be  a  diagonal  matrix  but  the
        characteristic polynomial in the group s irreducible),
  
  domain
        function  of  q  returning  true  if q is a valid parameter, and false
        otherwise,
  
  identifier
        identifier string of the generic table,
  
  irreducibles
        list of list of functions, in row i and column j the function of three
        arguments, namely q and the parameters p_t and p_s of the class type t
        and the character type s,
  
  isGenericTable
        always true
  
  libinfo
        record  with  components  firstname (Identifier (Reference: Identifier
        for  character  tables)  value  of  the table) and othernames (list of
        other admissible names)
  
  matrix
        function of q returning the matrix of irreducibles of G_q,
  
  orders
        list  of  functions,  one  for each class type t, with arguments q and
        p_t,  returning  the  representative  order  of elements of type t and
        parameter p_t,
  
  powermap
        list  of  functions,  one  for  each  class  type  t,  each with three
        arguments  q,  p_t,  and  k,  returning  the  pair [s,p_s] of type and
        parameter for the k-th power of the class with parameter [t,p_t],
  
  size
        function of q returning the order of G_q,
  
  specializedname
        function  of  q  returning  the  Identifier (Reference: Identifier for
        character tables) value of the table of G_q,
  
  text
        string informing about the generic table
  
  In  the  specialized table, the ClassParameters (Reference: ClassParameters)
  and  CharacterParameters  (Reference:  CharacterParameters)  values  are the
  lists of parameters [t,p_t] of classes and characters, respectively.
  
  If  the  matrix  component  is present then its value implements a method to
  compute  the  complete  table of small members G_q more efficiently than via
  local  evaluation; this method will be called when the generic table is used
  to    compute    the    whole    character    table    for    a    given   q
  (see[2 XCharacterTableSpecialized (4.2-2)).
  
  
  4.2-4 Example: The generic table of cyclic groups
  
  For  the  cyclic group C_q = ⟨ x [122⟩X of order q, there is one type of classes.
  The  class  parameters  are  integers  k  ∈  { 0, ..., q-1 }, the class with
  parameter  k  consists of the group element x^k. Group order and centralizer
  orders  are the identity function q ↦ q, independent of the parameter k. The
  representative order function maps the parameter pair [q,k] to q / gcd(q,k),
  which is the order of x^k in C_q; the p-th power map is the function mapping
  the triple (q,k,p) to the parameter [1,(kp mod q)].
  
  There  is  one  type of characters, with parameters l ∈ { 0, ..., q-1 }; for
  e_q  a  primitive  complex  q-th  root  of  unity,  the character values are
  χ_l(x^k) = e_q^kl.
  
    Example  
    gap> Print( CharacterTable( "Cyclic" ), "\n" );
    rec(
      centralizers := [ function ( n, k )
                return n;
            end ],
      charparam := [ function ( n )
                return [ 0 .. n - 1 ];
            end ],
      classparam := [ function ( n )
                return [ 0 .. n - 1 ];
            end ],
      domain := <Category "(IsInt and IsPosRat)">,
      identifier := "Cyclic",
      irreducibles := [ [ function ( n, k, l )
                    return E( n ) ^ (k * l);
                end ] ],
      isGenericTable := true,
      libinfo := rec(
          firstname := "Cyclic",
          othernames := [  ] ),
      orders := [ function ( n, k )
                return n / Gcd( n, k );
            end ],
      powermap := [ function ( n, k, pow )
                return [ 1, k * pow mod n ];
            end ],
      size := function ( n )
            return n;
        end,
      specializedname := function ( q )
            return Concatenation( "C", String( q ) );
        end,
      text := "generic character table for cyclic groups" )
  
  
  
  4.2-5 Example: The generic table of the general linear group GL(2,q)
  
  We  have four types t_1, t_2, t_3, t_4 of classes, according to the rational
  canonical form of the elements. t_1 describes scalar matrices, t_2 nonscalar
  diagonal  matrices, t_3 companion matrices of (X - ρ)^2 for nonzero elements
  ρ  ∈  F_q, and t_4 companion matrices of irreducible polynomials of degree 2
  over F_q.
  
  The  sets  of  class  parameters  of the types are in bijection with nonzero
  elements in F_q for t_1 and t_3, with the set
  
  
  { { ρ, τ }; ρ, τ ∈ F_q, ρ ‡ 0, τ ‡ 0, ρ ‡ τ }
  
  for t_2, and with the set { { ϵ, ϵ^q }; ϵ ∈ F_{q^2} ∖ F_q } for t_4.
  
  The  centralizer  order  functions  are q ↦ (q^2-1)(q^2-q) for type t_1, q ↦
  (q-1)^2 for type t_2, q ↦ q(q-1) for type t_3, and q ↦ q^2-1 for type t_4.
  
  The  representative  order  function of t_1 maps (q, ρ) to the order of [122ρX in
  F_q,  that  of  t_2  maps  (q, { ρ, τ }) to the least common multiple of the
  orders of [122ρX and [122τX.
  
  The file contains something similar to the following table.
  
  
    rec(
    identifier := "GL2",
    specializedname := ( q -> Concatenation( "GL(2,", String(q), ")" ) ),
    size := ( q -> (q^2-1)*(q^2-q) ),
    text := "generic character table of GL(2,q), see Robert Steinberg: ...",
    centralizers := [ function( q, k ) return (q^2-1) * (q^2-q); end,
                      ..., ..., ... ],
    classparam := [ ( q -> [ 0 .. q-2 ] ), ..., ..., ... ],
    charparam := [ ( q -> [ 0 .. q-2 ] ), ..., ..., ... ],
    powermap := [ function( q, k, pow ) return [ 1, (k*pow) mod (q-1) ]; end,
                  ..., ..., ... ],
    orders:= [ function( q, k ) return (q-1)/Gcd( q-1, k ); end,
               ..., ..., ... ],
    irreducibles := [ [ function( q, k, l ) return E(q-1)^(2*k*l); end,
                        ..., ..., ... ],
                      [ ..., ..., ..., ... ],
                      [ ..., ..., ..., ... ],
                      [ ..., ..., ..., ... ] ],
    classtext := [ ..., ..., ..., ... ],
    domain := IsPrimePowerInt,
    isGenericTable := true )
  
  
  
  4.3 Atlas Tables
  
  The  GAP  character  table library contains all character tables of bicyclic
  extensions  of simple groups that are included in the Atlas of Finite Groups
  ([CCN+85], from now on called Atlas), and the Brauer tables contained in the
  Atlas of Brauer Characters ([JLPW95]).
  
  These tables have the information
  
  origin: ATLAS of finite groups
  
  or
  
  origin: modular ATLAS of finite groups
  
  in  their InfoText (Reference: InfoText) value, they are simply called Atlas
  tables further on.
  
  For  displaying  Atlas  tables with the row labels used in the Atlas, or for
  displaying    decomposition   matrices,   see[2 XLaTeXStringDecompositionMatrix
  (Reference:   LaTeXStringDecompositionMatrix)  and[2 XAtlasLabelsOfIrreducibles
  (4.3-6).
  
  In  addition  to the information given in Chapters 6 to 8 of the Atlas which
  tell you how to read the printed tables, there are some rules relating these
  to the corresponding GAP tables.
  
  
  4.3-1 Improvements to the Atlas
  
  For the GAP Character Table Library not the printed versions of the Atlas of
  Finite  Groups  and  the  Atlas  of  Brauer  Characters are relevant but the
  revised versions given by the currently three lists of improvements that are
  maintained  by Simon Norton. The first such list is contained in [BN95], and
  is  printed  in  the Appendix of [JLPW95]; it contains the improvements that
  had  been  known  until  the  Atlas  of Brauer Characters was published. The
  second  list  contains  the  improvements to the Atlas of Finite Groups that
  were  found  since  the  publication  of [JLPW95].  It  can  be found in the
  internet, an HTML version at
  
  http://web.mat.bham.ac.uk/atlas/html/atlasmods.html
  
  and a DVI version at
  
  http://web.mat.bham.ac.uk/atlas/html/atlasmods.dvi.
  
  The  third list contains the improvements to the Atlas of Brauer Characters,
  HTML and PDF versions can be found in the internet at
  
  https://www.math.rwth-aachen.de/~MOC/ABCerr.html
  
  and
  
  https://www.math.rwth-aachen.de/~MOC/ABCerr.pdf,
  
  respectively.
  
  Also  some  tables  are regarded as Atlas tables that are not printed in the
  Atlas  but available in Atlas format, according to the lists of improvements
  mentioned above. Currently these are the tables related to L_2(49), L_2(81),
  L_6(2), O_8^-(3), O_8^+(3), S_10(2), and ^2E_6(2).3.
  
  
  4.3-2 Power Maps
  
  For  the  tables of 3.McL, 3_2.U_4(3) and its covers, and 3_2.U_4(3).2_3 and
  its  covers,  the  power maps are not uniquely determined by the information
  from   the   Atlas   but   determined   only   up  to  matrix  automorphisms
  (see[2 XMatrixAutomorphisms    (Reference:    MatrixAutomorphisms))    of   the
  irreducible  characters. In these cases, the first possible map according to
  lexicographical ordering was chosen, and the automorphisms are listed in the
  InfoText (Reference: InfoText) strings of the tables.
  
  
  4.3-3 Projective Characters and Projections
  
  If  G  (or  G.a)  has  a  nontrivial  Schur  multiplier  then  the attribute
  ProjectivesInfo  (3.7-2)  of  the GAP table object of G (or G.a) is set; the
  chars  component  of  the  record in question is the list of values lists of
  those  faithful  projective  irreducibles  that  are  printed  in  the Atlas
  (so-called  proxy  character),  and the map component lists the positions of
  columns  in  the  covering  for  which the column is printed in the Atlas (a
  so-called  proxy  class,  this  preimage  is  denoted  by  g_0 in Chapter 7,
  Section 14 of the Atlas).
  
  
  4.3-4 Tables of Isoclinic Groups
  
  As  described  in  Chapter 6,  Section 7 and in Chapter 7, Section 18 of the
  Atlas, there exist two (often nonisomorphic) groups of structure 2.G.2 for a
  simple  group  G,  which are isoclinic. The table in the GAP Character Table
  Library  is the one printed in the Atlas, the table of the isoclinic variant
  can     be    constructed    using    CharacterTableIsoclinic    (Reference:
  CharacterTableIsoclinic).
  
  
  4.3-5 Ordering of Characters and Classes
  
  (Throughout this section, G always means the simple group involved.)
  
  1   For  G itself, the ordering of classes and characters in the GAP table
        coincides with the one in the Atlas.
  
  2   For an automorphic extension G.a, there are three types of characters.
  
            If  a  character  [122χX  of  G  extends  to  G.a  then the different
              extensions  χ^0,  χ^1, ..., χ^{a-1} are consecutive in the table
              of G.a (see [CCN+85, Chapter 7, Section 16]).
  
            If  some  characters of G fuse to give a single character of G.a
              then the position of that character in the table of G.a is given
              by the position of the first involved character of G.
  
            If  both  extension  and  fusion  occur for a character then the
              resulting  characters  are  consecutive in the table of G.a, and
              each replaces the first involved character of G.
  
  3   Similarly,  there  are  different  types of classes for an automorphic
        extension G.a, as follows.
  
            If  some  classes collapse then the resulting class replaces the
              first involved class of G.
  
            For a > 2, any proxy class and its algebraic conjugates that are
              not printed in the Atlas are consecutive in the table of G.a; if
              more than two classes of G.a have the same proxy class (the only
              case  that  actually  occurs  is for a = 5) then the ordering of
              non-printed  classes  is the natural one of corresponding Galois
              conjugacy operators *k (see [CCN+85, Chapter 7, Section 19]).
  
            For  a_1,  a_2  dividing  a  such that a_1 ≤ a_2, the classes of
              G.a_1  in  G.a  precede  the  classes  of G.a_2 not contained in
              G.a_1.  This ordering is the same as in the Atlas, with the only
              exception U_3(8).6.
  
  4   For  a  central  extension  M.G,  there  are  two  different  types of
        characters, as follows.
  
            Each  character  can  be  regarded  as a faithful character of a
              factor  group  m.G,  where m divides M. Characters with the same
              kernel  are  consecutive  as  in  the  Atlas,  the  ordering  of
              characters  with  different  kernels  is  given  by the order of
              precedence 1, 2, 4, 3, 6, 12 for the different values of m.
  
            If  m  >  2,  a faithful character of m.G that is printed in the
              Atlas  (a  so-called  proxy  character)  represents  two or more
              Galois conjugates. In each Atlas table in GAP, a proxy character
              always  precedes the non-printed characters with this proxy. The
              case m = 12 is the only one that actually occurs where more than
              one  character  for  a  proxy  is not printed. In this case, the
              non-printed    characters   are   ordered   according   to   the
              corresponding  Galois  conjugacy  operators *5, *7, *11 (in this
              order).
  
  5   For the classes of a central extension we have the following.
  
            The  preimages  of a G-class in M.G are subsequent, the ordering
              is  the  same  as  that  of  the  lifting order rows in [CCN+85,
              Chapter 7, Section 7].
  
            The  primitive roots of unity chosen to represent the generating
              central  element  (i. e., the element in the second class of the
              GAP  table) are E(3), E(4), E(6)^5 (= E(2)*E(3)), and E(12)^7 (=
              E(3)*E(4)), for m = 3, 4, 6, and 12, respectively.
  
  6   For   tables   of  bicyclic  extensions  m.G.a,  both  the  rules  for
        automorphic  and  central  extensions  hold.  Additionally we have the
        following three rules.
  
            Whenever  classes of the subgroup m.G collapse in m.G.a then the
              resulting class replaces the first involved class.
  
            Whenever  characters  of the subgroup m.G collapse fuse in m.G.a
              then the result character replaces the first involved character.
  
            Extensions  of a character are subsequent, and the extensions of
              a proxy character precede the extensions of characters with this
              proxy that are not printed.
  
            Preimages  of  a  class  of G.a in m.G.a are subsequent, and the
              preimages  of a proxy class precede the preimages of non-printed
              classes with this proxy.
  
  4.3-6 AtlasLabelsOfIrreducibles
  
  AtlasLabelsOfIrreducibles( tbl[, short] )  function
  
  Let  tbl be the (ordinary or Brauer) character table of a bicyclic extension
  of  a simple group that occurs in the Atlas of Finite Groups [CCN+85] or the
  Atlas  of  Brauer  Characters [JLPW95].  AtlasLabelsOfIrreducibles returns a
  list  of  strings,  the  i-th  entry  being a label for the i-th irreducible
  character of tbl.
  
  The  labels  have  the  following form. We state the rules only for ordinary
  characters,  the  rules for Brauer characters are obtained by replacing [122χX by
  [122φX.
  
  First  consider  only  downward extensions m.G of a simple group G. If m ≤ 2
  then  only  labels  of  the  form χ_i occur, which denotes the i-th ordinary
  character shown in the Atlas.
  
  The  labels  of faithful ordinary characters of groups m.G with m ≥ 3 are of
  the  form χ_i, χ_i^*, or χ_i^{*k}, which means the i-th character printed in
  the  Atlas,  the unique character that is not printed and for which χ_i acts
  as  proxy (see [CCN+85, Chapter 7, Sections 8 and 19]), and the image of the
  printed   character   χ_i   under   the  algebraic  conjugacy  operator  *k,
  respectively.
  
  For  groups  m.G.a  with a > 1, the labels of the irreducible characters are
  derived   from   the   labels  of  the  irreducible  constituents  of  their
  restrictions to m.G, as follows.
  
  1   If the ordinary irreducible character χ_i of m.G extends to m.G.a then
        the  a^'  extensions  are denoted by χ_{i,0}, χ_{i,1}, ..., χ_{i,a^'},
        where χ_{i,0} is the character whose values are printed in the Atlas.
  
  2   The  label  χ_{i_1  + i_2 + ⋯ + i_a} means that a different characters
        χ_{i_1},  χ_{i_2},  ...,  χ_{i_a}  of  m.G  induce  to  an irreducible
        character of m.G.a with this label.
  
        If either true or the string "short" is entered as the second argument
        then  the  label has the short form χ_{i_1+}. Note that i_2, i_3, ...,
        i_a can be read off from the fusion signs in the Atlas.
  
  3   Finally,  the  label χ_{i_1,j_1 + i_2,j_2 + ⋯ + i_{a^'},j_{a^'}} means
        that  the  characters χ_{i_1}, χ_{i_2}, ..., χ_{i_{a^'}} of m.G extend
        to  a  group  that  lies  properly  between  m.G  and  m.G.a,  and the
        extensions  χ_{i_1, j_1}, χ_{i_2, j_2}, ... χ_{i_{a^'},j_{a^'}} induce
        to an irreducible character of m.G.a with this label.
  
        If  true or the string "short" was entered as the second argument then
        the label has the short form χ_{i,j+}.
  
    Example  
    gap> AtlasLabelsOfIrreducibles( CharacterTable( "3.A7.2" ) );
    [ "\\chi_{1,0}", "\\chi_{1,1}", "\\chi_{2,0}", "\\chi_{2,1}", 
      "\\chi_{3+4}", "\\chi_{5,0}", "\\chi_{5,1}", "\\chi_{6,0}", 
      "\\chi_{6,1}", "\\chi_{7,0}", "\\chi_{7,1}", "\\chi_{8,0}", 
      "\\chi_{8,1}", "\\chi_{9,0}", "\\chi_{9,1}", "\\chi_{17+17\\ast 2}",
      "\\chi_{18+18\\ast 2}", "\\chi_{19+19\\ast 2}", 
      "\\chi_{20+20\\ast 2}", "\\chi_{21+21\\ast 2}", 
      "\\chi_{22+23\\ast 8}", "\\chi_{22\\ast 8+23}" ]
    gap> AtlasLabelsOfIrreducibles( CharacterTable( "3.A7.2" ), "short" );
    [ "\\chi_{1,0}", "\\chi_{1,1}", "\\chi_{2,0}", "\\chi_{2,1}", 
      "\\chi_{3+}", "\\chi_{5,0}", "\\chi_{5,1}", "\\chi_{6,0}", 
      "\\chi_{6,1}", "\\chi_{7,0}", "\\chi_{7,1}", "\\chi_{8,0}", 
      "\\chi_{8,1}", "\\chi_{9,0}", "\\chi_{9,1}", "\\chi_{17+}", 
      "\\chi_{18+}", "\\chi_{19+}", "\\chi_{20+}", "\\chi_{21+}", 
      "\\chi_{22+}", "\\chi_{23+}" ]
  
  
  
  4.3-7 Examples of the Atlas Format for GAP Tables
  
  We  give  three  little  examples for the conventions stated in Section[14 X4.3,
  listing both the Atlas format and the table displayed by GAP.
  
  First, let G be the trivial group. We consider the cyclic group C_6 of order
  6. It can be viewed in several ways, namely
  
      as  a downward extension of the factor group C_2 which contains G as a
        subgroup,  or equivalently, as an upward extension of the subgroup C_3
        which has a factor group isomorphic to G:
  
  
    ┌───────┐ ┌───────┐       ;   @   ;   ;   @      2   1   1   1   1   1   1
    │       │ │       │           1           1      3   1   1   1   1   1   1
    │   G   │ │  G.2  │     p power           A
    │       │ │       │     p' part           A         1a  3a  3b  2a  6a  6b
    └───────┘ └───────┘     ind  1A fus ind  2A     2P  1a  3b  3a  1a  3b  3a
    ┌───────┐ ┌───────┐                             3P  1a  1a  1a  2a  2a  2a
    │       │ │       │  χ_1  +   1   :  ++   1
    │  3.G  │ │ 3.G.2 │                           X.1    1   1   1   1   1   1
    │       │ │       │     ind   1 fus ind   2   X.2    1   1   1  -1  -1  -1
    └───────┘ └───────┘           3           6   X.3    1   A  /A   1   A  /A
                                  3           6   X.4    1   A  /A  -1  -A -/A
                                                  X.5    1  /A   A   1  /A   A
                         χ_2 o2   1   : oo2   1   X.6    1  /A   A  -1 -/A  -A
    
                                                  A = E(3)
                                                    = (-1+ER(-3))/2 = b3
  
  
  
        X.1, X.2 extend χ_1. X.3, X.4 extend the proxy character χ_2. X.5, X.6
        extend  the  not printed character with proxy χ_2. The classes 1a, 3a,
        3b are preimages of 1A, and 2a, 6a, 6b are preimages of 2A.
  
      as  a downward extension of the factor group C_3 which contains G as a
        subgroup,  or equivalently, as an upward extension of the subgroup C_2
        which has a factor group isomorphic to G:
  
  
    ┌───────┐ ┌───────┐       ;   @   ;   ;   @      2   1   1   1   1   1   1
    │       │ │       │           1           1      3   1   1   1   1   1   1
    │   G   │ │  G.3  │     p power           A
    │       │ │       │     p' part           A         1a  2a  3a  6a  3b  6b
    └───────┘ └───────┘     ind  1A fus ind  3A     2P  1a  1a  3b  3b  3a  3a
    ┌───────┐ ┌───────┐                             3P  1a  2a  1a  2a  1a  2a
    │       │ │       │  χ_1  +   1   : +oo   1
    │  2.G  │ │ 2.G.3 │                           X.1    1   1   1   1   1   1
    │       │ │       │     ind   1 fus ind   3   X.2    1   1   A   A  /A  /A
    └───────┘ └───────┘           2           6   X.3    1   1  /A  /A   A   A
                                                  X.4    1  -1   1  -1   1  -1
                         χ_2  +   1   : +oo   1   X.5    1  -1   A  -A  /A -/A
                                                  X.6    1  -1  /A -/A   A  -A
    
                                                  A = E(3)
                                                    = (-1+ER(-3))/2 = b3
  
  
  
        X.1  to  X.3  extend χ_1, X.4 to X.6 extend χ_2. The classes 1a and 2a
        are  preimages  of  1A, 3a and 6a are preimages of the proxy class 3A,
        and 3b and 6b are preimages of the not printed class with proxy 3A.
  
      as  a downward extension of the factor groups C_3 and C_2 which have G
        as a factor group:
  
  
    ┌───────┐           ;   @        2   1   1   1   1   1   1
    │       │               1        3   1   1   1   1   1   1
    │   G   │         p power
    │       │         p' part           1a  6a  3a  2a  3b  6b
    └───────┘         ind  1A       2P  1a  3a  3b  1a  3a  3b
    ┌───────┐                       3P  1a  2a  1a  2a  1a  2a
    │       │      χ_1  +   1
    │  2.G  │                     X.1    1   1   1   1   1   1
    │       │         ind   1     X.2    1  ─1   1  ─1   1  ─1
    └───────┘               2     X.3    1   A  /A   1   A  /A
    ┌───────┐                     X.4    1  /A   A   1  /A   A
    │       │      χ_2  +   1     X.5    1  ─A  /A  ─1   A ─/A
    │  3.G  │                     X.6    1 ─/A   A  ─1  /A  ─A
    │       │         ind   1
    └───────┘               3     A = E(3)
    ┌───────┐               3       = (─1+ER(─3))/2 = b3
    │       [104│X
    │  6.G  │      χ_3 o2   1
    │       [104│X
    └───────┘         ind   1
                            6
                            3
                            2
                            3
                            6
    
                   χ_4 o2   1
  
  
  
        X.1,  X.2 correspond to χ_1, χ_2, respectively; X.3, X.5 correspond to
        the  proxies χ_3, χ_4, and X.4, X.6 to the not printed characters with
        these proxies. The factor fusion onto 3.G is given by [ 1, 2, 3, 1, 2,
        3 ], that onto G.2 by [ 1, 2, 1, 2, 1, 2 ].
  
      as  an upward extension of the subgroups C_3 or C_2 which both contain
        a subgroup isomorphic to G:
  
  
    ┌───────┐ ┌───────┐ ┌───────┐ ┌───────[104┐X
    │       │ │       │ │       │ │       [104│X
    │   G   │ │  G.2  │ │  G.3  │ │  G.6  [104│X
    │       │ │       │ │       │ │       [104│X
    └───────┘ └───────┘ └───────┘ └───────[104┘X
    
         ;   @   ;   ;   @   ;   ;   @   ;     ;   @
    
             1           1           1             1
       p power           A           A            AA
       p' part           A           A            AA
       ind  1A fus ind  2A fus ind  3A fus   ind  6A
    
    χ_1  +   1   :  ++   1   : +oo   1   :+oo+oo   1
    
    
        2   1   1   1   1   1   1
        3   1   1   1   1   1   1
    
           1a  2a  3a  3b  6a  6b
       2P  1a  1a  3b  3a  3b  3a
       3P  1a  2a  1a  1a  2a  2a
     X.1    1   1   1   1   1   1
     X.2    1  -1   A  /A  -A -/A
     X.3    1   1  /A   A  /A   A
     X.4    1  -1   1   1  -1  -1
     X.5    1   1   A  /A   A  /A
     X.6    1  -1  /A   A -/A  -A
    
     A = E(3)
       = (-1+ER(-3))/2 = b3
  
  
  
        The  classes  1a,  2a  correspond  to  1A,  2A,  respectively.  3a, 6a
        correspond  to  the  proxies  3A,  6A,  and  3b, 6b to the not printed
        classes with these proxies.
  
  The second example explains the fusion case. Again, G is the trivial group.
  
  
    ┌───────┐ ┌───────┐        ;   @   ;   ;  @      3.G.2
    │       │ │       │            1          1
    │   G   │ │  G.2  │      p power          A         2   1   .   1
    │       │ │       │      p' part          A         3   1   1   .
    └───────┘ └───────┘      ind  1A fus ind 2A
    ┌───────┐ ┌───────┐                                    1a 3a 2a
    │       │ │       │   χ_1  +   1   :  ++  1        2P  1a 3a 1a
    │  2.G  │ │ 2.G.2 │                                3P  1a 1a 2a
    │       │ │       │      ind   1 fus ind  2
    └───────┘ └───────┘            2          2      X.1    1  1  1
    ┌───────┐ ┌───────                               X.2    1  1 ─1
    │       │ │           χ_2  +   1   :  ++  1      X.3    2 ─1  .
    │  3.G  │ │ 3.G.2
    │       │ │              ind   1 fus ind  2
    └───────┘                      3                 6.G.2
    ┌───────┐ ┌───────             3
    │       │ │                                         2   2  1  1  2  2  2
    │  6.G  │ │ 6.G.2     χ_3 o2   1   *   +            3   1  1  1  1  .  .
    │       │ [104│X
    └───────┘                ind   1 fus ind  2            1a 6a 3a 2a 2b 2c
                                   6          2        2P  1a 3a 3a 1a 1a 1a
                                   3                   3P  1a 2a 1a 2a 2b 2c
                                   2
                                   3                 Y.1    1  1  1  1  1  1
                                   6                 Y.2    1  1  1  1 -1 -1
                                                     Y.3    1 -1  1 -1  1 -1
                          χ_4 o2   1   *   +         Y.4    1 -1  1 -1 -1  1
                                                     Y.5    2 -1 -1  2  .  .
                                                     Y.6    2  1 -1 -2  .  .
  
  
  The  tables  of  G,  2.G, 3.G, 6.G and G.2 are known from the first example,
  that  of  2.G.2 will be given in the next one. So here we print only the GAP
  tables of 3.G.2 ≅ D_6 and 6.G.2 ≅ D_12.
  
  In  3.G.2,  the  characters  X.1,  X.2  extend  χ_1; χ_3 and its non-printed
  partner fuse to give X.3, and the two preimages of 1A of order 3 collapse.
  
  In 6.G.2, Y.1 to Y.4 are extensions of χ_1, χ_2, so these characters are the
  inflated characters from 2.G.2 (with respect to the factor fusion [ 1, 2, 1,
  2,  3, 4 ]). Y.5 is inflated from 3.G.2 (with respect to the factor fusion [
  1,  2,  2,  1,  3,  3 ]), and Y.6 is the result of the fusion of χ_4 and its
  non-printed partner.
  
  For  the last example, let G be the elementary abelian group 2^2 of order 4.
  Consider the following tables.
  
  
    ┌───────┐ ┌───────┐          ;   @   @   @   @   ;   ;   @
    │       │ │       │              4   4   4   4           1
    │   G   │ │  G.3  │        p power   A   A   A           A
    │       │ │       │        p' part   A   A   A           A
    └───────┘ └───────┘        ind  1A  2A  2B  2C fus ind  3A
    ┌───────┐ ┌───────[104┐X
    │       │ │       │     χ_1  +   1   1   1   1   : +oo   1
    │  2.G  │ │ 2.G.3 │     χ_2  +   1   1  ─1  ─1   .   +   0
    │       │ │       │     χ_3  +   1  ─1   1  ─1   |
    └───────┘ └───────┘     χ_4  +   1  ─1  ─1   1   |
    
                               ind   1   4   4   4 fus ind   3
                                     2                       6
    
                            χ_5  -   2   0   0   0   : -oo   1
    
      G.3
    
         2   2   2   .   .
         3   1   .   1   1
    
            1a  2a  3a  3b
        2P  1a  1a  3b  3a
        3P  1a  2a  1a  1a
    
      X.1    1   1   1   1
      X.2    1   1   A  /A
      X.3    1   1  /A   A         2.G.3
      X.4    3  -1   .   .
                                      2   3   3   2   1   1   1   1
      A = E(3)                        3   1   1   .   1   1   1   1
        = (-1+ER(-3))/2 = b3
                                         1a  2a  4a  3a  6a  3b  6b
      2.G                            2P  1a  1a  2a  3b  3b  3a  3a
                                     3P  1a  2a  4a  1a  2a  1a  2a
         2   3   3   2   2   2
                                   X.1    1   1   1   1   1   1   1
            1a  2a  4a  4b  4c     X.2    1   1   1   A   A  /A  /A
        2P  1a  1a  2a  1a  1a     X.3    1   1   1  /A  /A   A   A
        3P  1a  2a  4a  4b  4c     X.4    3   3  -1   .   .   .   .
                                   X.5    2  -2   .   1   1   1   1
      X.1    1   1   1   1   1     X.6    2  -2   .   A  -A  /A -/A
      X.2    1   1   1  -1  -1     X.7    2  -2   .  /A -/A   A  -A
      X.3    1   1  -1   1  -1
      X.4    1   1  -1  -1   1     A = E(3)
      X.5    2  -2   .   .   .       = (-1+ER(-3))/2 = b3
  
  
  In  the  table  of G.3 ≅ A_4, the characters χ_2, χ_3, and χ_4 fuse, and the
  classes 2A, 2B and 2C collapse. For getting the table of 2.G ≅ Q_8, one just
  has to split the class 2A and adjust the representative orders. Finally, the
  table  of  2.G.3  ≅  SL_2(3) is given; the class fusion corresponding to the
  injection  2.G  ↪  2.G.3  is  [  1,  2,  3,  3,  3  ], and the factor fusion
  corresponding to the epimorphism 2.G.3 → G.3 is [ 1, 1, 2, 3, 3, 4, 4 ].
  
  
  4.4 CAS Tables
  
  One  of  the  predecessors  of  GAP  was  CAS  (Character  Algorithm System,
  see [NPP84]),  which  had  also  a  library  of  character tables. All these
  character tables are available in GAP except if stated otherwise in the file
  doc/ctbldiff.pdf.  This sublibrary has been completely revised before it was
  included in GAP, for example, errors have been corrected and power maps have
  been completed.
  
  Any  CAS  table  is  accessible  by  each of its CAS names (except if stated
  otherwise in doc/ctbldiff.pdf), that is, the table name or the filename used
  in CAS.
  
  4.4-1 CASInfo
  
  CASInfo( tbl )  attribute
  
  Let  tbl  be  an ordinary character table in the GAP library that was (up to
  permutations  of  classes and characters) contained already in the CAS table
  library.  When one fetches tbl from the library, one does in general not get
  the  original  CAS  table.  Namely,  in many cases (mostly Atlas tables, see
  Section[14 X4.3),  the  identifier  of  the  table  (see[2 XIdentifier  (Reference:
  Identifier  for  character  tables))  as well as the ordering of classes and
  characters are different for the CAS table and its GAP version.
  
  Note that in several cases, the CAS library contains different tables of the
  same  group,  in  particular  these  tables  may  have  different  names and
  orderings of classes and characters.
  
  The  CASInfo  value of tbl, if stored, is a list of records, each describing
  the  relation  between  tbl  and  a  character table in the CAS library. The
  records have the components
  
  name
        the name of the CAS table,
  
  permchars and permclasses
        permutations  of  the  Irr  (Reference: Irr) values and the classes of
        tbl,  respectively, that must be applied in order to get the orderings
        in the original CAS table, and
  
  text
        the text that was stored on the CAS table (which may contain incorrect
        statements).
  
    Example  
    gap> tbl:= CharacterTable( "m10" );
    CharacterTable( "A6.2_3" )
    gap> HasCASInfo( tbl );
    true
    gap> CASInfo( tbl );
    [ rec( name := "m10", permchars := (3,5)(4,8,7,6), permclasses := (), 
          text := "names:     m10\norder:     2^4.3^2.5 = 720\nnumber of c\
    lasses: 8\nsource:    cambridge atlas\ncomments:  point stabilizer of \
    mathieu-group m11\ntest:      orth, min, sym[3]\n" ) ]
  
  
  The  class  fusions stored on tables from the CAS library have been computed
  anew  with  GAP;  the  text  component  of such a fusion record tells if the
  fusion  map  is  equal  to that in the CAS library, up to the permutation of
  classes between the table in CAS and its GAP version.
  
    Example  
    gap> First( ComputedClassFusions( tbl ), x -> x.name = "M11" );
    rec( map := [ 1, 2, 3, 4, 5, 4, 7, 8 ], name := "M11", 
      text := "fusion is unique up to table automorphisms,\nthe representa\
    tive is equal to the fusion map on the CAS table" )
  
  
  
  4.5 Customizations of the GAP Character Table Library
  
  
  4.5-1 Installing the GAP Character Table Library
  
  To  install  the  package  unpack the archive file in a directory in the pkg
  directory  of  your  local copy of GAP 4. This might be the pkg directory of
  the  GAP 4 home directory, see Section[14 X'Reference: Installing a GAP Package'
  for details. It is however also possible to keep an additional pkg directory
  in  your  private  directories,  see[14 X'Reference:  GAP Root Directories'. The
  latter possibility must be chosen if you do not have write access to the GAP
  root directory.
  
  The  package  consists entirely of GAP code, no external binaries need to be
  compiled.
  
  For checking the installation of the package, you should start GAP and call
  
    Example  
    gap> ReadPackage( "ctbllib", "tst/testinst.g" );
  
  
  If  the  installation  is  o. k.  then  true  is printed, and the GAP prompt
  appears again; otherwise the output lines tell you what should be changed.
  
  More testfiles are available in the tst directory of the package.
  
  PDF  and  HTML  versions  of  the  package  manual  are available in the doc
  directory of the package.
  
  
  4.5-2 Unloading Character Table Data
  
  Data files from the GAP Character Table Library may be read only once during
  a GAP session –this is efficient but requires memory– or the cached data may
  be  erased  as  soon as a second data file is to be read –this requires less
  memory but is usually less efficient.
  
  One  can  choose  between  these  two  possibilities via the user preference
  "UnloadCTblLibFiles"  of the CTblLib package, see UserPreference (Reference:
  UserPreference).  The default value of this preference is true, that is, the
  contents  of  only  one data file is kept in memory. Call SetUserPreference(
  "CTblLib",  "UnloadCTblLibFiles",  false  );  if  you  want  to  change this
  behaviour.
  
  
  4.5-3 Changing the display format of several functions
  
  The  way  how  the  functions DisplayAtlasContents (3.5-6), DisplayAtlasInfo
  (AtlasRep:      DisplayAtlasInfo),      DisplayAtlasMap     (3.5-8),     and
  DisplayCTblLibInfo  (3.5-1)  show  tabular information can be customized via
  the  user  preference "DisplayFunction" of the AtlasRep package, see Section
  'AtlasRep: User preference DisplayFunction'.
  
  
  4.5-4 The path for calling MAGMA
  
  This  preference  describes the path for calling MAGMA. An empty string (the
  default) means that Magma is not available.
  
  This preference is used by CharacterTableComputedByMagma (6.5-3).
  
  
  4.6 Technicalities of the Access to Character Tables from the Library
  
  
  4.6-1 Data Files of the GAP Character Table Library
  
  The  data  files  of  the  GAP  Character  Table  Library reside in the data
  directory of the package CTblLib.
  
  The filenames start with ct (for character table), followed by either o (for
  ordinary),  b  (for  Brauer),  or g (for generic), then a description of the
  contents (up to 5 characters, e. g., alter for the tables of alternating and
  related groups), and the suffix .tbl.
  
  The  file ctbdescr.tbl contains the known Brauer tables corresponding to the
  ordinary tables in the file ctodescr.tbl.
  
  Each data file of the table library is supposed to consist of
  
  1   comment lines, starting with a hash character # in the first column,
  
  2   an assignment to a component of LIBTABLE.LOADSTATUS, at the end of the
        file, and
  
  3   function calls of the form
  
            MBT( name, data ) (make Brauer table),
  
            MOT( name, data ) (make ordinary table),
  
            ALF(  from,  to,  map  ),  ALF(  from, to, map, textlines ) (add
              library fusion),
  
            ALN( name, listofnames ) (add library name), and
  
            ARC( name, component, compdata ) (add record component).
  
        Here name must be the identifier value of the ordinary character table
        corresponding to the table to which the command refers; data must be a
        comma  separated  sequence  of  GAP  objects;  from  and  to  must  be
        identifier values of ordinary character tables, map a list of positive
        integers, textlines and listofnames lists list of strings, component a
        string, and compdata any GAP object.
  
        MOT,  ALF,  ALN,  and  ARC  occur  only  in  files containing ordinary
        character  tables,  and  MBT  occurs  only  in files containing Brauer
        tables.
  
  Besides  the  above  calls, the data in files containing ordinary and Brauer
  tables  may  contain  only  the  following  GAP functions. (Files containing
  generic  character  tables  may  contain  calls  to  arbitrary  GAP  library
  functions.)
  
  ACM,  Concatenation  (Reference:  concatenation of lists), E (Reference: E),
  EvalChars,  GALOIS,  Length  (Reference:  Length),  ShallowCopy  (Reference:
  ShallowCopy), TENSOR, and TransposedMat (Reference: TransposedMat).
  
  The  function CTblLib.RecomputeTOC in the file gap4/maketbl.g of the CTblLib
  package  expects  the  file  format  described  above, and to some extent it
  checks this format.
  
  The  function  calls  may  be  continued  over  several  lines  of a file. A
  semicolon  is assumed to be the last character in its line if and only if it
  terminates a function call.
  
  Names  of  character tables are strings (see Chapter[14 X'Reference: Strings and
  Characters'),  i. e.,  they  are enclosed in double quotes; strings in table
  library  files  must  not be split over several lines, because otherwise the
  function  CTblLib.RecomputeTOC  may get confused. Additionally, no character
  table name is allowed to contain double quotes.
  
  There are three different ways how the table data can be stored in the file.
  
  Full ordinary tables
        are  encoded  by  a  call  to  the  function  MOT, where the arguments
        correspond  to the relevant attribute values; each fusion into another
        library  table  is  added  by  a  call  to ALF, values to be stored in
        components  of  the  table  object  are added with ARC, and admissible
        names  are  notified  with  ALN.  The argument of MOT that encodes the
        irreducible  characters  is abbreviated as follows. For each subset of
        characters  that differ just by multiplication with a linear character
        or by Galois conjugacy, only the first one is given by its values, the
        others  are replaced by [TENSOR,[i,j]] (which means that the character
        is  the tensor product of the i-th and the j-th character in the list)
        or [GALOIS,[i,j]] (which means that the character is obtained from the
        i-th character by applying GaloisCyc( ., j ) to it).
  
  Brauer tables
        are  stored  relative  to the corresponding ordinary tables; attribute
        values  that can be computed by restricting from the ordinary table to
        p-regular  classes  are  not  stored,  and  instead of the irreducible
        characters  the  files contain (inverses of) decomposition matrices or
        Brauer trees for the blocks of nonzero defect.
  
  Ordinary construction tables
        have  the  attribute  ConstructionInfoCharacterTable (3.7-4) set, with
        value  a list that contains the name of the construction function used
        and  the  arguments  for a call to this function; the function call is
        performed by CharacterTable (Reference: CharacterTable) when the table
        is  constructed  (not when the file containing the table is read). One
        aim  of this mechanism is to store structured character tables such as
        tables  of  direct  products and tables of central extensions of other
        tables in a compact way, see Chapter 5.
  
  4.6-2 LIBLIST
  
  LIBLIST  global variable
  
  GAP's  knowledge  about  the  ordinary character tables in the GAP Character
  Table  Library is given by several JSON format files that get evaluated when
  the  file  gap4/ctprimar.g (the primary file of the character table library)
  is read. These files can be produced from the data files, see Section 4.6-1.
  
  The  information is stored in the global variable LIBLIST, which is a record
  with the following components.
  
  firstnames
        the  list  of  Identifier (Reference: Identifier for character tables)
        values of the ordinary tables,
  
  files
        the list of filenames containing the data of ordinary tables,
  
  filenames
        a  list  of  positive  integers,  value j at position i means that the
        table whose identifier is the i-th in the firstnames list is contained
        in the j-th file of the files component,
  
  fusionsource
        a list containing at position i the list of names of tables that store
        a fusion into the table whose identifier is the i-th in the firstnames
        list,
  
  allnames
        a list of all admissible names of ordinary library tables,
  
  position
        a  list  that  stores  at position i the position in firstnames of the
        identifier of the table with the i-th admissible name in allnames,
  
  simpleinfo
        a  list  of  triples  [  m,  name, a ] describing the tables of simple
        groups in the library; name is the identifier of the table, m.name and
        name.a  are admissible names for its Schur multiplier and automorphism
        group, respectively, if these tables are available at all,
  
  sporadicSimple
        a  list of identifiers of the tables of the 26 sporadic simple groups,
        and
  
  GENERIC
        a record with information about generic tables (see Section[14 X4.2).
  
  4.6-3 LibInfoCharacterTable
  
  LibInfoCharacterTable( tblname )  function
  
  is a record with the components
  
  firstName
        the  Identifier  (Reference: Identifier for character tables) value of
        the library table for which tblname is an admissible name, and
  
  fileName
        the name of the file in which the table data is stored.
  
  If no such table exists in the GAP library then fail is returned.
  
  If tblname contains the substring "mod" then it is regarded as the name of a
  Brauer  table.  In  this  case  the  result  is  computed  from that for the
  corresponding  ordinary  table  and  the  characteristic. So if the ordinary
  table  exists  then  the  result  is  a  record although the Brauer table in
  question need not be contained in the GAP library.
  
    Example  
    gap> LibInfoCharacterTable( "S5" );
    rec( fileName := "ctoalter", firstName := "A5.2" )
    gap> LibInfoCharacterTable( "S5mod2" );
    rec( fileName := "ctbalter", firstName := "A5.2mod2" )
    gap> LibInfoCharacterTable( "J5" );
    fail
  
  
  
  4.7 How to Extend the GAP Character Table Library
  
  GAP  users  may  want  to  extend  the  character table library in different
  respects.
  
      Probably  the easiest change is to add new admissible names to library
        tables,  in  order  to  use  these  names  in  calls of CharacterTable
        (3.1-2). This can be done using NotifyNameOfCharacterTable (4.7-1).
  
      The  next  kind  of  changes  is  the  addition of new fusions between
        library  tables.  Once  a  fusion map is known, it can be added to the
        library  file  containing  the table of the subgroup, using the format
        produced by LibraryFusion (4.7-2).
  
      The  last  kind  of changes is the addition of new character tables to
        the  GAP  character  table  library.  Data  files containing tables in
        library  format  (i. e.,  in  the  form of calls to MOT or MBT) can be
        produced using PrintToLib (4.7-4).
  
        If  you  have  an ordinary character table in library format which you
        want  to  add  to  the  table library, for example because it shall be
        accessible  via  CharacterTable  (3.1-2),  you must notify this table,
        i. e.,  tell  GAP in which file it can be found, and which names shall
        be  admissible  for  it.  This  can be done using NotifyCharacterTable
        (4.7-5).
  
  4.7-1 NotifyNameOfCharacterTable
  
  NotifyNameOfCharacterTable( firstname, newnames )  function
  
  notifies  the  strings  in the list newnames as new admissible names for the
  library  table  with Identifier (Reference: Identifier for character tables)
  value firstname. If there is already another library table for which some of
  these names are admissible then an error is signaled.
  
  NotifyNameOfCharacterTable modifies the global variable LIBLIST (4.6-2).
  
    Example  
    gap> CharacterTable( "private" );
    fail
    gap> NotifyNameOfCharacterTable( "A5", [ "private" ] );
    gap> a5:= CharacterTable( "private" );
    CharacterTable( "A5" )
  
  
  One  can  notify  alternative  names for character tables inside data files,
  using  the  function  ALN instead of NotifyNameOfCharacterTable. The idea is
  that  the  additional  names of tables from those files can be ignored which
  are  controlled  by  CTblLib.RecomputeTOC.  Therefore,  ALN is set to Ignore
  before  the  file  is  read  with  CTblLib.ReadTbl,  otherwise ALN is set to
  NotifyNameOfCharacterTable.
  
  4.7-2 LibraryFusion
  
  LibraryFusion( name, fus )  function
  
  For a string name that is an Identifier (Reference: Identifier for character
  tables)  value  of  an  ordinary  character  table in the GAP library, and a
  record fus with the components
  
  name
        the identifier of the destination table, or this table itself,
  
  map
        the fusion map, a list of image positions,
  
  text (optional)
        a string describing properties of the fusion, and
  
  specification (optional)
        a string or an integer,
  
  LibraryFusion  returns  a  string whose printed value can be used to add the
  fusion  in  question  to  the library file containing the data for the table
  with identifier name.
  
  If  name is a character table then its Identifier (Reference: Identifier for
  character tables) value is used as the corresponding string.
  
    Example  
    gap> s5:= CharacterTable( "S5" );
    CharacterTable( "A5.2" )
    gap> fus:= PossibleClassFusions( a5, s5 );
    [ [ 1, 2, 3, 4, 4 ] ]
    gap> fusion:= rec( name:= s5, map:= fus[1], text:= "unique" );;
    gap> Print( LibraryFusion( "A5", fusion ) );
    ALF("A5","A5.2",[1,2,3,4,4],[
    "unique"
    ]);
  
  
  4.7-3 LibraryFusionTblToTom
  
  LibraryFusionTblToTom( name, fus )  function
  
  For a string name that is an Identifier (Reference: Identifier for character
  tables)  value  of  an  ordinary  character  table in the GAP library, and a
  record fus with the components
  
  name
        the  identifier  of  the  destination  table  of  marks, or this table
        itself,
  
  map
        the fusion map, a list of image positions,
  
  text (optional)
        a string describing properties of the fusion, and
  
  perm (optional)
        a permutation,
  
  LibraryFusionTblToTom  returns  a  string whose printed value can be used to
  add  the  fusion in question to the library file containing the data for the
  table with identifier name.
  
  The  meaning  of the component perm is as follows. Let prim be the primitive
  permutation  characters  obtained  by computing the PermCharsTom (Reference:
  PermCharsTom  via  fusion  map)  value  of  the  tables of marks, taking the
  sublist  at  the positions in the first component of the MaximalSubgroupsTom
  (Reference:   MaximalSubgroupsTom)   value  of  the  tables  of  marks,  and
  restricting  these lists via the map component. Permuting prim with the perm
  component  via Permuted (Reference: Permuted) yields the list of permutation
  characters  obtained  by  inducing  the  trivial characters of the subgroups
  given  by  the  Maxes (3.7-1) value of the character table. If the component
  perm  is  not  present  and  if  the character table has the attribute Maxes
  (3.7-1)  set  then  the  two  ways  of  computing  the primitive permutation
  characters yield the same list.
  
  If  name is a character table then its Identifier (Reference: Identifier for
  character tables) value is used as the corresponding string.
  
    Example  
    gap> tbl:= CharacterTable( "A5" );     
    CharacterTable( "A5" )
    gap> tom:= TableOfMarks( "A5" );
    TableOfMarks( "A5" )
    gap> fus:= PossibleFusionsCharTableTom( tbl, tom );
    [ [ 1, 2, 3, 5, 5 ] ]
    gap> fusion:= rec( name:= tom, map:= fus[1], text:= "unique" );;
    gap> Print( LibraryFusionTblToTom( "A5", fusion ) );
    ARC("A5","tomfusion",rec(name:="A5",map:=[1,2,3,5,5],text:=[
    "unique"
    ]));
  
  
  4.7-4 PrintToLib
  
  PrintToLib( file, tbl )  function
  
  prints the (ordinary or Brauer) character table tbl in library format to the
  file file.tbl (or to file if this has already the suffix .tbl).
  
  If   tbl   is   an   ordinary   table   then  the  value  of  the  attribute
  NamesOfFusionSources   (Reference:   NamesOfFusionSources)   is  ignored  by
  PrintToLib,  since for library tables this information is extracted from the
  source files (see Section 4.6-1).
  
  The  names  of  data files in the GAP Character Table Library begin with cto
  (for  ordinary  tables)  or  ctb  (for  corresponding  Brauer  tables),  see
  Section[14 X4.6.  This  is supported also for private extensions of the library,
  that is, if the filenames are chosen this way and the ordinary tables in the
  cto  files  are  notified  via  NotifyCharacterTable (4.7-5) then the Brauer
  tables  will  be  found in the ctb files. Alternatively, if the filenames of
  the  files  with  the ordinary tables do not start with cto then GAP expects
  the corresponding Brauer tables in the same file as the ordinary tables.
  
    Example  
    gap> PrintToLib( "private", a5 );
  
  
  The  above command appends the data of the table a5 to the file private.tbl;
  the first lines printed to this file are
  
  
    MOT("A5",
    [
    "origin: ATLAS of finite groups, tests: 1.o.r., pow[2,3,5]"
    ],
    [60,4,3,5,5],
    [,[1,1,3,5,4],[1,2,1,5,4],,[1,2,3,1,1]],
    [[1,1,1,1,1],[3,-1,0,-E(5)-E(5)^4,-E(5)^2-E(5)^3],
    [GALOIS,[2,2]],[4,0,1,-1,-1],[5,1,-1,0,0]],
    [(4,5)]);
    ARC("A5","projectives",["2.A5",[[2,0,-1,E(5)+E(5)^4,E(5)^2+E(5)^3],
    [GALOIS,[1,2]],[4,0,1,-1,-1],[6,0,0,1,1]],]);
    ARC("A5","extInfo",["2","2"]);
  
  
  4.7-5 NotifyCharacterTable
  
  NotifyCharacterTable( firstname, filename, othernames )  function
  
  notifies  a  new  ordinary  table  to the library. This table has Identifier
  (Reference:   Identifier  for  character  tables)  value  firstname,  it  is
  contained  (in library format, see[2 XPrintToLib (4.7-4)) in the file with name
  filename  (without  suffix  .tbl),  and  the  names  contained  in  the list
  othernames are admissible for it.
  
  If the initial part of filename is one of ~/, / or ./ then it is interpreted
  as  an  absolute  path.  Otherwise  it  is  interpreted relative to the data
  directory of the CTblLib package.
  
  NotifyCharacterTable  modifies  the  global variable LIBLIST (4.6-2) for the
  current  GAP  session,  after  having checked that there is no other library
  table  yet  with  an  admissible  name  equal  to  firstname or contained in
  othernames.
  
  For  example,  let  us  change the name A5 to icos wherever it occurs in the
  file  private.tbl  that was produced above, and then notify the new table in
  this file as follows. (The name change is needed because GAP knows already a
  table  with  name  A5  and  would  not accept to add another table with this
  name.)
  
    Example  
    gap> NotifyCharacterTable( "icos", "private", [] );
    gap> icos:= CharacterTable( "icos" );
    CharacterTable( "icos" )
    gap> Display( icos );
    icos
    
         2  2  2  .  .  .
         3  1  .  1  .  .
         5  1  .  .  1  1
    
           1a 2a 3a 5a 5b
        2P 1a 1a 3a 5b 5a
        3P 1a 2a 1a 5b 5a
        5P 1a 2a 3a 1a 1a
    
    X.1     1  1  1  1  1
    X.2     3 -1  .  A *A
    X.3     3 -1  . *A  A
    X.4     4  .  1 -1 -1
    X.5     5  1 -1  .  .
    
    A = -E(5)-E(5)^4
      = (1-ER(5))/2 = -b5
  
  
  So  the private table is treated as a library table. Note that the table can
  be  accessed  only  if  it has been notified in the current GAP session. For
  frequently   used   private   tables,  it  may  be  reasonable  to  put  the
  NotifyCharacterTable  statements  into  your gaprc file (see[14 X'Reference: The
  gap.ini and gaprc files'), or into a file that is read via the gaprc file.
  
  4.7-6 NotifyCharacterTables
  
  NotifyCharacterTables( list )  function
  
  notifies  several new ordinary tables to the library. The argument list must
  be  a  dense  list  in  which each entry is a lists of the form [ firstname,
  filename,   othernames  ],  with  the  same  meaning  as  the  arguments  of
  NotifyCharacterTable (4.7-5).
  
  
  4.8 Sanity Checks for the GAP Character Table Library
  
  The  fact  that  the  GAP  Character  Table  Library  is designed as an open
  database  (see  Chapter[14 X1) makes it especially desirable to have consistency
  checks available which can be run automatically whenever new data get added.
  
  The  file  tst/testall.g  of  the  package  contains  Test (Reference: Test)
  statements  for  executing  a  collection of such sanity checks; one can run
  them  by  calling  ReadPackage(  "CTblLib", "tst/testall.g" ). If no problem
  occurs then GAP prints only lines starting with one of the following.
  
    Example  
    + Input file:
    + GAP4stones:
  
  
  The  examples  in  the  package  manual  form  a part of the tests, they are
  collected in the file tst/docxpl.tst of the package.
  
  The  following  tests  concern only ordinary character tables. In all cases,
  let  tbl be the ordinary character table of a group G, say. The return value
  is false if an error occurred, and true otherwise.
  
  CTblLib.Test.InfoText( tbl )
        checks  some properties of the InfoText (Reference: InfoText) value of
        tbl,  if  available. Currently it is not recommended to use this value
        programmatically.  However, one can rely on the following structure of
        this value for tables in the GAP Character Table Library.
  
            The value is a string that consists of \n separated lines.
  
            If  a line of the form maximal subgroup of grpname occurs, where
              grpname  is  the  name of a character table, then a class fusion
              from the table in question to that with name grpname is stored.
  
            If  a  line  of  the form nth maximal subgroup of grpname occurs
              then  additionally  the  name  grpnameMn  is admissible for tbl.
              Furthermore,  if the table with name grpname has a Maxes (3.7-1)
              value then tbl is referenced in position n of this list.
  
  CTblLib.Test.RelativeNames( tbl[, tblname] )
        checks some properties of those admissible names for tbl that refer to
        a  related  group  H,  say.  Let  name  be  an admissible name for the
        character  table  of  H. (In particular, name is not an empty string.)
        Then the following relative names are considered.
  
        nameMn
              G  is  isomorphic  with  the groups in the n-th class of maximal
              subgroups  of  H.  An  example  is "M12M1" for the Mathieu group
              M_11.  We  consider  only  cases where name does not contain the
              letter  x.  For  example,  2xM12 denotes the direct product of a
              cyclic  group  of order two and the Mathieu group M_12 but not a
              maximal  subgroup of 2x. Similarly, 3x2.M22M5 denotes the direct
              product  of  a  cyclic  group  of order three and a group in the
              fifth  class  of  maximal  subgroups of 2.M_22 but not a maximal
              subgroup of 3x2.M22.
  
        nameNp
              G is isomorphic with the normalizers of the Sylow p-subgroups of
              H.  An  example  is  "M24N2"  for  the  (self-normalizing) Sylow
              2-subgroup in the Mathieu group M_24.
  
        nameNcnam
              G  is  isomorphic  with  the normalizers of the cyclic subgroups
              generated  by the elements in the class with the name cnam of H.
              An example is "O7(3)N3A" for the normalizer of an element in the
              class 3A of the simple group O_7(3).
  
        nameCcnam
              G  is  isomorphic  with  the  groups  in the centralizers of the
              elements  in  the  class  with the name cnam of H. An example is
              "M24C2A"  for  the  centralizer of an element in the class 2A in
              the Mathieu group M_24.
  
        In  these  cases,  CTblLib.Test.RelativeNames checks whether a library
        table  with  the admissible name name exists and a class fusion to tbl
        is stored on this table.
  
        In  the  case  of  Sylow  p-normalizers,  it is also checked whether G
        contains  a  normal  Sylow  p-subgroup  of the same order as the Sylow
        p-subgroups  in  H. If the normal Sylow p-subgroup of G is cyclic then
        it  is also checked whether G is the full Sylow p-normalizer in H. (In
        general  this  information cannot be read off from the character table
        of H).
  
        In  the  case of normalizers (centralizers) of cyclic subgroups, it is
        also  checked  whether H really normalizes (centralizes) a subgroup of
        the given order, and whether the class fusion from tbl to the table of
        H is compatible with the relative name.
  
        If  the  optional  argument  tblname  is  given then only this name is
        tested.  If  there  is only one argument then all admissible names for
        tbl are tested.
  
  CTblLib.Test.FindRelativeNames( tbl )
        runs  over  the  class  fusions  stored  on  tbl.  If  tbl is the full
        centralizer/normalizer  of a cyclic subgroup in the table to which the
        class   fusion   points   then  the  function  proposes  to  make  the
        corresponding relative name an admissible name for tbl.
  
  CTblLib.Test.PowerMaps( tbl )
        checks  whether  all  p-th  power  maps  are  stored on tbl, for prime
        divisors  p  of  the  order  of G, and whether they are correct. (This
        includes the information about uniqueness of the power maps.)
  
  CTblLib.Test.TableAutomorphisms( tbl )
        checks  whether the table automorphisms are stored on tbl, and whether
        they are correct. Also all available Brauer tables of tbl are checked.
  
  CTblLib.Test.CompatibleFactorFusions( tbl )
        checks whether triangles and quadrangles of factor fusions from tbl to
        other   library   tables  commute  (where  the  entries  in  the  list
        CTblLib.IgnoreFactorFusionsCompatibility are excluded from the tests),
        and   whether   the   factor  fusions  commute  with  the  actions  of
        corresponding outer automorphisms.
  
  CTblLib.Test.FactorsModPCore( tbl )
        checks,  for  all those prime divisors p of the order of G such that G
        is not p-solvable, whether the factor fusion to the character table of
        G/O_p(G) is stored on tbl.
  
        Note  that if G is not p-solvable and O_p(G) is nontrivial then we can
        compute  the  p-modular  Brauer table of G if that of the factor group
        G/O_p(G) is available. The availability of this table is indicated via
        the availability of the factor fusion from tbl.
  
  CTblLib.Test.Fusions( tbl )
        checks  the  class  fusions  that  are  stored  on  the  table tbl: No
        duplicates  shall  occur,  each  subgroup  fusion  or factor fusion is
        tested using CTblLib.Test.SubgroupFusion or CTblLib.Test.FactorFusion,
        respectively,  and  a  fusion  to the table of marks for tbl is tested
        using CTblLib.Test.FusionToTom.
  
  CTblLib.Test.Maxes( tbl )
        checks  for those character tables tbl that have the Maxes (3.7-1) set
        whether   the  character  tables  with  the  given  names  are  really
        available,  that  they  are ordered w.r.t. non-increasing group order,
        and that the fusions into tbl are stored.
  
  CTblLib.Test.ClassParameters( tbl )
        checks  the  compatibility  of  class  parameters  of  alternating and
        symmetric  groups  (partitions describing cycle structures), using the
        underlying group stored in the corresponding table of marks.
  
  CTblLib.Test.Constructions( tbl )
        checks the ConstructionInfoCharacterTable (3.7-4) status for the table
        tbl: If this attribute value is set then tests depending on this value
        are  executed; if this attribute is not set then it is checked whether
        a description of tbl via a construction would be appropriate.
  
  CTblLib.Test.ExtensionInfo( tbl )
        checks  whether  the  attribute ExtensionInfoCharacterTable (3.7-3) is
        known  for  all  nonabelian  simple  character  tables  that  are  not
        duplicates.
  
  CTblLib.Test.GroupForGroupInfo( tbl )
        checks    that    the    entries    in    the    list    returned   by
        GroupInfoForCharacterTable (3.3-1) fit to the character table tbl.
  
  The following tests concern only modular character tables. In all cases, let
  modtbl be a Brauer character table of a group G, say.
  
  CTblLib.Test.BlocksInfo( modtbl )
        checks  whether the decomposition matrices of all blocks of the Brauer
        table   modtbl  are  integral,  as  well  as  the  inverses  of  their
        restrictions to basic sets.
  
  CTblLib.Test.TensorDecomposition( modtbl )
        checks whether the tensor products of irreducible Brauer characters of
        the Brauer table modtbl decompose into Brauer characters.
  
  CTblLib.Test.Indicators( modtbl )
        checks  the  2-nd indicators of the Brauer table modtbl: The indicator
        of  a  Brauer character is zero iff it has at least one nonreal value.
        In   odd  characteristic,  the  indicator  of  an  irreducible  Brauer
        character  is  equal  to  the  indicator  of  any ordinary irreducible
        character that contains it as a constituent, with odd multiplicity. In
        characteristic  two,  we  test  that  all  nontrivial real irreducible
        Brauer  characters  have  even  degree,  and  that  irreducible Brauer
        characters with indicator -1 lie in the principal block.
  
  CTblLib.Test.FactorBlocks( modtbl )
        If  the  Brauer  table modtbl is encoded using references to tables of
        factor  groups  then we must make sure that the irreducible characters
        of  the  underlying  ordinary  table  and  the factors in question are
        sorted   compatibly.   (Note  that  we  simply  take  over  the  block
        information about the factors, without applying an explicit mapping.)
  
  
  4.9 Maintenance of the GAP Character Table Library
  
  It  is  of  course desirable that the information in the GAP Character Table
  Library  is  consistent  with related data. For example, the ordering of the
  classes  of  maximal  subgroups  stored  in  the  Maxes  (3.7-1) list of the
  character  table  of a group G, say, should correspond to the ordering shown
  for  G  in  the  Atlas of Finite Groups [CCN+85], to the ordering of maximal
  subgroups  used  for  G  in  the  AtlasRep,  and  to the ordering of maximal
  subgroups  in  the  table  of  marks  of  G.  The fact that the related data
  collections  are  developed independently makes it difficult to achieve this
  kind  of  consistency. Sometimes it is unavoidable to adjust data of the GAP
  Character Table Library to external data.
  
  An important issue is the consistency of class fusions. Usually such fusions
  are  determined  only  up  to  table automorphisms, and one candidate can be
  chosen.  However,  other conditions such as known Brauer tables may restrict
  the  choice.  The  point  is  that there are class fusions which predate the
  availability  of  Brauer tables in the Character Table Library (in fact many
  of  them  have been inherited from the table library of the CAS system), but
  they  are not compatible with the Brauer tables. For example, there are four
  possible  class fusion from M_23 into Co_3, which lie in one orbit under the
  relevant groups of table automorphisms; two of these maps are not compatible
  with  the  3-modular  Brauer  tables of M_23 and Co_3, and unfortunately the
  class  fusion  that  was stored on the CAS tables –and that was available in
  version  1.0  of  the  GAP  Character  Table  Library–  was  one  of the not
  compatible maps. One could argue that the class fusion has older rights, and
  that the Brauer tables should be adjusted to them, but the Brauer tables are
  published  in  the Atlas of Brauer Characters [JLPW95], which is an accepted
  standard.
  

Generated by dwww version 1.15 on Sun Jun 23 03:41:54 CEST 2024.