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

  
  3 The User Interface to the GAP Character Table Library
  
  
  3.1 Accessing Data of the CTblLib Package
  
  
  3.1-1 Admissible Names for Character Tables in CTblLib
  
  When you access a character table from the GAP Character Table Library, this
  table is specified by an admissible name.
  
  Admissible names for the ordinary character table tbl of the group G are
  
      an  Atlas  like  name  if tbl is an Atlas table (see Section[14 X4.3), for
        example  "M22" for the table of the Mathieu group M_22, "L2(13).2" for
        L_2(13):2, and "12_1.U4(3).2_1" for 12_1.U_4(3).2_1.
  
        (The  difference  to  the name printed in the Atlas is that subscripts
        and  superscripts  are  omitted  except  if  they  are used to qualify
        integer values, and double dots are replaced by a single dot.)
  
      the  names  that  were admissible for tables of G in the CAS system if
        the CAS table library contained a table of G, for example sl42 for the
        table of the alternating group A_8.
  
        (But  note  that the ordering of rows and columns of the GAP table may
        be different from that in CAS, see Section[14 X4.4.)
  
      some relative names, as follows.
  
            If G is the n-th maximal subgroup (in decreasing group order) of
              a  group  whose  library  table  subtbl  is available in GAP and
              stores  the  Maxes  (3.7-1)  value, and if name is an admissible
              name  for subtbl then nameMn is admissible for tbl. For example,
              the  name  "J3M2"  can  be  used  to  access  the second maximal
              subgroup  of  the  sporadic simple Janko group J_3 which has the
              admissible name "J3".
  
            If  G  is  a  nontrivial Sylow p normalizer in a sporadic simple
              group  with  admissible name name –where nontrivial means that G
              is  not  isomorphic  to a subgroup of p:(p-1)– then nameNp is an
              admissible  name  of  tbl.  For example, the name "J4N11" can be
              used  to  access  the  table  of  the Sylow 11 normalizer in the
              sporadic simple Janko group J_4.
  
            In  a  few  cases,  the  table  of  the Sylow p-subgroup of G is
              accessible  via  the  name  nameSylp where name is an admissible
              name  of the table of G. For example, "A11Syl2" is an admissible
              name  for  the  table of the Sylow 2-subgroup of the alternating
              group A_11.
  
            In  a  few  cases,  the  table of an element centralizer in G is
              accessible via the name nameCcl where name is an admissible name
              of  the  table  of G. For example, "M11C2" is an admissible name
              for  the table of an involution centralizer in the Mathieu group
              M_11.
  
  The  recommended  way  to  access  a  Brauer  table  is via applying the mod
  operator   to  the  ordinary  table  and  the  desired  characteristic  (see
  BrauerTable  (Reference:  BrauerTable) and Section[14 X'Reference: Operators for
  Character  Tables'),  so  it  is not necessary to define admissible names of
  Brauer tables.
  
  A  generic  character table (see Section[14 X4.2) is accessible only by the name
  given by its Identifier (Reference: Identifier for character tables) value.
  
  3.1-2 CharacterTable
  
  CharacterTable( tblname[, para1[, para2]] )  method
  
  If  the  only argument is a string tblname and if this is an admissible name
  (see  3.1-1)  of  a library character table then CharacterTable returns this
  library table, otherwise fail.
  
  If  CharacterTable is called with more than one argument then the first must
  be a string tblname specifying a series of groups which is implemented via a
  generic  character  table, for example "Symmetric" for symmetric groups; the
  remaining  arguments  specialize  the  desired  member  of  the  series (see
  Section[14 X4.2  for  a  list  of available generic tables). If no generic table
  with  name tblname is available or if the parameters are not admissible then
  CharacterTable returns fail.
  
  A call of CharacterTable may cause that some library files are read and that
  some  table  objects are constructed from the data stored in these files, so
  fetching a library table may take more time than one expects.
  
  Case  is  not significant for tblname. For example, both "suzm3" and "SuzM3"
  can  be entered in order to access the character table of the third class of
  maximal subgroups of the sporadic simple Suzuki group.
  
    Example  
    gap> s5:= CharacterTable( "A5.2" );
    CharacterTable( "A5.2" )
    gap> sym5:= CharacterTable( "Symmetric", 5 );
    CharacterTable( "Sym(5)" )
    gap> TransformingPermutationsCharacterTables( s5, sym5 );
    rec( columns := (2,3,4,7,5), group := Group(()), 
      rows := (1,7,3,4,6,5,2) )
  
  
  The  above two tables are tables of the symmetric group on five letters; the
  first  is  in Atlas format (see Section[14 X4.3), the second is constructed from
  the generic table for symmetric groups (see[14 X4.2).
  
    Example  
    gap> CharacterTable( "J5" );
    fail
    gap> CharacterTable( "A5" ) mod 2;
    BrauerTable( "A5", 2 )
  
  
  3.1-3 BrauerTable
  
  BrauerTable( tblname, p )  operation
  
  Called  with a string tblname and a prime integer p, BrauerTable returns the
  p-modular  character  table  of the ordinary character table with admissible
  name  tblname,  if  such  an  ordinary character table exists and if GAP can
  compute its p-modular table. Otherwise fail is returned.
  
  The  default  method  delegates to BrauerTable (Reference: BrauerTable for a
  character  table,  and  a  prime  integer) with arguments the CharacterTable
  (3.1-2) value of tblname and p.
  
    Example  
    gap> BrauerTable( "A5", 2 );
    BrauerTable( "A5", 2 )
    gap> BrauerTable( "J5", 2 );  # no ordinary table with name J5
    fail
    gap> BrauerTable( "M", 2 );   # Brauer table not known
    fail
  
  
  3.1-4 AllCharacterTableNames
  
  AllCharacterTableNames( [func, val, ...[, OfThose, func]]: OrderedBy := func )  function
  
  Similar  to  group libraries (see Chapter[14 X'Reference: Group Libraries'), the
  GAP  Character  Table  Library  can be used to search for ordinary character
  tables with prescribed properties.
  
  A specific library table can be selected by an admissible name, see 3.1-1.
  
  The  selection function (see 'Reference: Selection Functions') for character
  tables  from  the  GAP  Character  Table  Library that have certain abstract
  properties  is AllCharacterTableNames. Contrary to the situation in the case
  of  group  libraries,  the  selection function returns a list not of library
  character  tables  but  of their names; using CharacterTable (3.1-2) one can
  then access the tables themselves.
  
  AllCharacterTableNames  takes  an  arbitrary  even  number of arguments. The
  argument  at  each  odd position must be a function, and the argument at the
  subsequent  even  position  must  be  either a value that this function must
  return when called for the character table in question, in order to have the
  name  of the table included in the selection, or a list of such values, or a
  function  that  returns  true  for  such  a  value, and false otherwise. For
  example,
  
    Example  
    gap> names:= AllCharacterTableNames();;
  
  
  returns  a  list  containing  one admissible name of each ordinary character
  table in the GAP library,
  
    Example  
    gap> simpnames:= AllCharacterTableNames( IsSimple, true,
    >                                        IsAbelian, false );;
  
  
  returns  a  list  containing  an  admissible name of each ordinary character
  table in the GAP library whose groups are nonabelian and simple, and
  
    Example  
    gap> AllCharacterTableNames( IsSimple, true, IsAbelian, false,
    >                            Size, [ 1 .. 100 ] );
    [ "A5", "A6M2", "Alt(5)" ]
  
  
  returns  a  list  containing  an  admissible name of each ordinary character
  table  in  the  GAP  library whose groups are nonabelian and simple and have
  order  at  most 100, respectively. (Note that "A5", "A6M2", and "Alt(5)" are
  identifiers of permutation equivalent character tables. It would be possible
  to exclude duplicates, see Section[14 X3.6).
  
  Similarly,
  
    Example  
    gap> AllCharacterTableNames( Size, IsPrimeInt );
    [ "2.Alt(2)", "Alt(3)", "C2", "C3", "Sym(2)" ]
  
  
  returns the list of all identifiers of library tables whose Size (Reference:
  Size) value is a prime integer, and
  
    Example  
    gap> AllCharacterTableNames( Identifier,
    >        x -> PositionSublist( x, "L8" ) <> fail );
    [ "L8(2)", "P1L82", "P2L82" ]
  
  
  returns the identifiers that contain the string "L8" as a substring.
  
  For  the  sake  of  efficiency,  the  attributes  whose  names are listed in
  CTblLib.SupportedAttributes  are handled in a special way, GAP need not read
  all  files  of the table library in these cases in order to find the desired
  names.
  
    Example  
    gap> CTblLib.SupportedAttributes;
    [ "AbelianInvariants", "Identifier", "IdentifiersOfDuplicateTables", 
      "InfoText", "IsAbelian", "IsAlmostSimple", "IsDuplicateTable", 
      "IsNontrivialDirectProduct", "IsPerfect", "IsQuasisimple", 
      "IsSimple", "IsSporadicSimple", "KnowsDeligneLusztigNames", 
      "KnowsSomeGroupInfo", "Maxes", "NamesOfFusionSources", 
      "NrConjugacyClasses", "Size" ]
  
  
  If    the    Browse    package    (see [BL18])    is    not    loaded   then
  CTblLib.SupportedAttributes      contains     only     "Identifier",     and
  AllCharacterTableNames  will  be very slow when one selects character tables
  according to other attributes from the list shown above.
  
  The  global  option  OrderedBy  can be used to prescribe the ordering of the
  result.  The value of this option, if given, must be a function that takes a
  character  table  as  its  unique  argument;  the result list is then sorted
  according  to the results of this function (w. r. t. the comparison by GAP's
  \< operation).
  
  For  example,  we  may  be interested in the tables of small sporadic simple
  groups,  ordered  alphabetically  or  by  size  (Size (Reference: Size for a
  character  table)) or by the number of conjugacy classes (NrConjugacyClasses
  (Reference: NrConjugacyClasses for a character table)).
  
    Example  
    gap> AllCharacterTableNames( IsSporadicSimple, true,
    >        Size, [ 1 .. 10^6 ],
    >        IsDuplicateTable, false );
    [ "J1", "J2", "M11", "M12", "M22" ]
    gap> AllCharacterTableNames( IsSporadicSimple, true,
    >        Size, [ 1 .. 10^6 ],
    >        IsDuplicateTable, false : OrderedBy:= Size );
    [ "M11", "M12", "J1", "M22", "J2" ]
    gap> AllCharacterTableNames( IsSporadicSimple, true,
    >        Size, [ 1 .. 10^6 ],
    >        IsDuplicateTable, false : OrderedBy:= NrConjugacyClasses );
    [ "M11", "M22", "J1", "M12", "J2" ]
  
  
  (Note  that  the  alphabtical  ordering  could  also be achieved by entering
  OrderedBy:= Identifier.)
  
  If  the  dummy  function  OfThose is an argument at an odd position then the
  following  argument func must be a function that takes a character table and
  returns  a name of a character table or a list of names; this is interpreted
  as  replacement  of  the  names computed up to this position by the union of
  names  returned  by  func.  For  example,  func  may  be  Maxes  (3.7-1)  or
  NamesOfFusionSources (Reference: NamesOfFusionSources)).
  
    Example  
    gap> maxesnames:= AllCharacterTableNames( IsSporadicSimple, true,
    >                                         HasMaxes, true,
    >                                         OfThose, Maxes );;
  
  
  returns  the union of names of ordinary tables of those maximal subgroups of
  sporadic  simple groups that are contained in the table library in the sense
  that the attribute Maxes (3.7-1) is set.
  
  For  the  sake  of  efficiency,  OfThose  followed  by  one of the arguments
  AutomorphismGroup  (Reference:  AutomorphismGroup),  SchurCover  (Reference:
  SchurCover), CompleteGroup is handled in a special way.
  
  3.1-5 OneCharacterTableName
  
  OneCharacterTableName( [func, val, ...[, OfThose, func]]: OrderedBy := func )  function
  
  The  example  function  for  character  tables  from the GAP Character Table
  Library  that  have certain abstract properties is OneCharacterTableName. It
  is  analogous  to the selection function AllCharacterTableNames (3.1-4), the
  difference  is  that  it  returns  one Identifier (Reference: Identifier for
  character tables) value of a character table with the properties in question
  instead  of  the  list  of  all  such  values. If no table with the required
  properties  is  contained  in  the  GAP Character Table Library then fail is
  returned.
  
    Example  
    gap> OneCharacterTableName( IsSimple, true, Size, 60 );
    "A5"
    gap> OneCharacterTableName( IsSimple, true, Size, 20 );
    fail
  
  
  The  global  option  OrderedBy can be used to search for a smallest example,
  according  to  the  value  of  the  option.  If  this function is one of the
  attributes  whose  names  are listed in CTblLib.SupportedAttributes then the
  tables are processed according to increasing values of the option, which may
  speed up the search.
  
  3.1-6 NameOfEquivalentLibraryCharacterTable
  
  NameOfEquivalentLibraryCharacterTable( ordtbl )  function
  NamesOfEquivalentLibraryCharacterTables( ordtbl )  function
  
  Let       ordtbl       be       an       ordinary      character      table.
  NameOfEquivalentLibraryCharacterTable  returns  the  Identifier  (Reference:
  Identifier  for  character  tables)  value  of  a character table in the GAP
  Character  Table  Library  that  is  permutation  equivalent  to ordtbl (see
  TransformingPermutationsCharacterTables                          (Reference:
  TransformingPermutationsCharacterTables))  if such a character table exists,
  and fail otherwise. NamesOfEquivalentLibraryCharacterTables returns the list
  of  all  Identifier  (Reference:  Identifier for character tables) values of
  character  tables  in  the  GAP Character Table Library that are permutation
  equivalent  to  ordtbl;  thus  an  empty list is returned in this case if no
  equivalent library table exists.
  
    Example  
    gap> tbl:= CharacterTable( "Alternating", 5 );;
    gap> NameOfEquivalentLibraryCharacterTable( tbl );
    "A5"
    gap> NamesOfEquivalentLibraryCharacterTables( tbl );
    [ "A5", "A6M2", "Alt(5)" ]
    gap> tbl:= CharacterTable( "Cyclic", 17 );;
    gap> NameOfEquivalentLibraryCharacterTable( tbl );
    fail
    gap> NamesOfEquivalentLibraryCharacterTables( tbl );
    [  ]
  
  
  
  3.2 The Interface to the TomLib Package
  
  The  GAP  Character  Table Library contains ordinary character tables of all
  groups  for  which  the  TomLib package [NMP18] contains the table of marks.
  This  section describes the mapping between these character tables and their
  tables of marks.
  
  If  the  TomLib  package  is not loaded then FusionToTom (3.2-4) is the only
  available function from this section, but of course it is of little interest
  in this situation.
  
  3.2-1 TableOfMarks
  
  TableOfMarks( tbl )  method
  
  Let tbl be an ordinary character table from the GAP Character Table Library,
  for the group G, say. If the TomLib package is loaded and contains the table
  of  marks  of  G  then  there  is a method based on TableOfMarks (Reference:
  TableOfMarks  for a string) that returns this table of marks. If there is no
  such  table  of  marks  but  tbl knows its underlying group then this method
  delegates to the group. Otherwise fail is returned.
  
    Example  
    gap> TableOfMarks( CharacterTable( "A5" ) );
    TableOfMarks( "A5" )
    gap> TableOfMarks( CharacterTable( "M" ) );
    fail
  
  
  3.2-2 CharacterTable
  
  CharacterTable( tom )  method
  
  For  a  table  of  marks  tom,  this  method  for CharacterTable (Reference:
  CharacterTable  for  a  group)  returns the character table corresponding to
  tom.
  
  If tom comes from the TomLib package, the character table comes from the GAP
  Character  Table  Library.  Otherwise,  if  tom  stores  an  UnderlyingGroup
  (Reference:  UnderlyingGroup  for  tables  of  marks) value then the task is
  delegated to a CharacterTable (Reference: CharacterTable for a group) method
  for  this  group,  and  if  no  underlying  group  is available then fail is
  returned.
  
    Example  
    gap> CharacterTable( TableOfMarks( "A5" ) );
    CharacterTable( "A5" )
  
  
  3.2-3 FusionCharTableTom
  
  FusionCharTableTom( tbl, tom )  method
  
  Let  tbl be an ordinary character table from the GAP Character Table Library
  with  the  attribute  FusionToTom (3.2-4), and let tom be the table of marks
  from  the GAP package TomLib that corresponds to tbl. In this case, a method
  for  FusionCharTableTom  (Reference:  FusionCharTableTom)  is available that
  returns  the fusion from tbl to tom that is given by the FusionToTom (3.2-4)
  value of tbl.
  
    Example  
    gap> tbl:= CharacterTable( "A5" );
    CharacterTable( "A5" )
    gap> tom:= TableOfMarks( "A5" );
    TableOfMarks( "A5" )
    gap> FusionCharTableTom( tbl, tom );
    [ 1, 2, 3, 5, 5 ]
  
  
  3.2-4 FusionToTom
  
  FusionToTom( tbl )  attribute
  
  If  this  attribute  is set for an ordinary character table tbl then the GAP
  Library  of Tables of Marks contains the table of marks of the group of tbl,
  and the attribute value is a record with the following components.
  
  name
        the  Identifier  (Reference: Identifier for tables of marks) component
        of the table of marks of tbl,
  
  map
        the fusion map,
  
  text (optional)
        a string describing the status of the fusion, and
  
  perm (optional)
        a  permutation  that  establishes the bijection between the classes of
        maximal  subgroups  in  the  table  of  marks (see MaximalSubgroupsTom
        (Reference:  MaximalSubgroupsTom))  and the Maxes (3.7-1) list of tbl.
        Applying the permutation to the sublist of permutation characters (see
        PermCharsTom   (Reference:   PermCharsTom  via  fusion  map))  at  the
        positions  of  the  maximal subgroups of the table of marks yields the
        list  of  primitive permutation characters computed from the character
        tables  described by the Maxes (3.7-1) list. Usually, there is no perm
        component,  which  means  that  the two lists of primitive permutation
        characters are equal. See Section 2.3-5 for an example.
  
    Example  
    gap> FusionToTom( CharacterTable( "2.A6" ) );
    rec( map := [ 1, 2, 5, 4, 8, 3, 7, 11, 11, 6, 13, 6, 13 ], 
      name := "2.A6", perm := (4,5), 
      text := "fusion map is unique up to table autom." )
  
  
  3.2-5 NameOfLibraryCharacterTable
  
  NameOfLibraryCharacterTable( tomname )  function
  
  This  function  returns  the Identifier (Reference: Identifier for character
  tables)  value  of  the  character table corresponding to the table of marks
  with  Identifier  (Reference: Identifier for tables of marks) value tomname.
  If  no  such character table exists in the GAP Character Table Library or if
  the TomLib package is not loaded then fail is returned.
  
    Example  
    gap> NameOfLibraryCharacterTable( "A5" );
    "A5"
    gap> NameOfLibraryCharacterTable( "S5" );
    "A5.2"
  
  
  
  3.3 The Interface to GAP's Group Libraries
  
  Sometimes  it  is  useful  to  extend a character-theoretic computation with
  computations involving a group that has the character table in question. For
  many  character  tables  in  the  GAP Character Table Library, corresponding
  groups can be found in the various group libraries that are distributed with
  GAP.  This  section  describes  how  one  can access the library groups that
  belong to a given character table.
  
  3.3-1 GroupInfoForCharacterTable
  
  GroupInfoForCharacterTable( tbl )  attribute
  
  Let tbl be an ordinary character table from the GAP Character Table Library.
  GroupInfoForCharacterTable  returns a sorted list of pairs such that calling
  GroupForGroupInfo  (3.3-4)  with  any  of  these  pairs yields a group whose
  ordinary character table is tbl, up to permutations of rows and columns.
  
  Note  that  this group is in general not determined up to isomorphism, since
  nonisomorphic  groups  may  have  the  same character table (including power
  maps).
  
  Contrary  to  the  attribute UnderlyingGroup (Reference: UnderlyingGroup for
  tables of marks), the entries of the GroupInfoForCharacterTable list for tbl
  are not related to the ordering of the conjugacy classes in tbl.
  
  Sources  for  this  attribute  are  the GAP databases of groups described in
  Chapter  'Reference: Group Libraries', and the packages AtlasRep and TomLib,
  see  also GroupForTom (3.3-5) and AtlasStabilizer (3.3-6). If these packages
  are  not  loaded  then part of the information may be missing. If the Browse
  package  (see [BL18])  is not loaded then GroupInfoForCharacterTable returns
  always an empty list.
  
    Example  
    gap> GroupInfoForCharacterTable( CharacterTable( "A5" ) );
    [ [ "AlternatingGroup", [ 5 ] ], [ "AtlasGroup", [ "A5" ] ], 
      [ "AtlasStabilizer", [ "A6", "A6G1-p6aB0" ] ], 
      [ "AtlasStabilizer", [ "A6", "A6G1-p6bB0" ] ], 
      [ "AtlasStabilizer", [ "L2(11)", "L211G1-p11aB0" ] ], 
      [ "AtlasStabilizer", [ "L2(11)", "L211G1-p11bB0" ] ], 
      [ "AtlasStabilizer", [ "L2(19)", "L219G1-p57aB0" ] ], 
      [ "AtlasStabilizer", [ "L2(19)", "L219G1-p57bB0" ] ], 
      [ "AtlasSubgroup", [ "A5.2", 1 ] ], [ "AtlasSubgroup", [ "A6", 1 ] ]
        , [ "AtlasSubgroup", [ "A6", 2 ] ], 
      [ "AtlasSubgroup", [ "J2", 9 ] ], 
      [ "AtlasSubgroup", [ "L2(109)", 4 ] ], 
      [ "AtlasSubgroup", [ "L2(109)", 5 ] ], 
      [ "AtlasSubgroup", [ "L2(11)", 1 ] ], 
      [ "AtlasSubgroup", [ "L2(11)", 2 ] ], 
      [ "AtlasSubgroup", [ "S6(3)", 11 ] ], 
      [ "GroupForTom", [ "2^4:A5", 68 ] ], 
      [ "GroupForTom", [ "2^4:A5`", 56 ] ], [ "GroupForTom", [ "A5" ] ], 
      [ "GroupForTom", [ "A5xA5", 85 ] ], [ "GroupForTom", [ "A6", 21 ] ],
      [ "GroupForTom", [ "J2", 99 ] ], 
      [ "GroupForTom", [ "L2(109)", 25 ] ], 
      [ "GroupForTom", [ "L2(11)", 15 ] ], 
      [ "GroupForTom", [ "L2(125)", 18 ] ], 
      [ "GroupForTom", [ "L2(16)", 18 ] ], 
      [ "GroupForTom", [ "L2(19)", 17 ] ], 
      [ "GroupForTom", [ "L2(29)", 19 ] ], 
      [ "GroupForTom", [ "L2(31)", 25 ] ], 
      [ "GroupForTom", [ "S5", 18 ] ], [ "PSL", [ 2, 4 ] ], 
      [ "PSL", [ 2, 5 ] ], [ "PerfectGroup", [ 60, 1 ] ], 
      [ "PrimitiveGroup", [ 5, 4 ] ], [ "PrimitiveGroup", [ 6, 1 ] ], 
      [ "PrimitiveGroup", [ 10, 1 ] ], [ "SmallGroup", [ 60, 5 ] ], 
      [ "TransitiveGroup", [ 5, 4 ] ], [ "TransitiveGroup", [ 6, 12 ] ], 
      [ "TransitiveGroup", [ 10, 7 ] ], [ "TransitiveGroup", [ 12, 33 ] ],
      [ "TransitiveGroup", [ 15, 5 ] ], [ "TransitiveGroup", [ 20, 15 ] ],
      [ "TransitiveGroup", [ 30, 9 ] ] ]
  
  
  3.3-2 KnowsSomeGroupInfo
  
  KnowsSomeGroupInfo( tbl )  property
  
  For  an ordinary character table tbl, this function returns true if the list
  returned  by  GroupInfoForCharacterTable  (3.3-1)  is  nonempty,  and  false
  otherwise.
  
    Example  
    gap> KnowsSomeGroupInfo( CharacterTable( "A5" ) );
    true
    gap> KnowsSomeGroupInfo( CharacterTable( "M" ) );
    false
  
  
  3.3-3 CharacterTableForGroupInfo
  
  CharacterTableForGroupInfo( info )  attribute
  
  This function is a partial inverse of GroupInfoForCharacterTable (3.3-1). If
  info  has  the  form  [  funcname, args ] and occurs in the list returned by
  GroupInfoForCharacterTable  (3.3-1)  when  called  with a character table t,
  say,  then CharacterTableForGroupInfo returns a character table from the GAP
  Character Table that is equivalent to t. Otherwise fail is returned.
  
    Example  
    gap> CharacterTableForGroupInfo( [ "AlternatingGroup", [ 5 ] ] );
    CharacterTable( "A5" )
  
  
  3.3-4 GroupForGroupInfo
  
  GroupForGroupInfo( info )  attribute
  
  If  info  has the form [ funcname, args ] and occurs in the list returned by
  GroupInfoForCharacterTable  (3.3-1)  when called with a character table tbl,
  say,  then  GroupForGroupInfo  returns a group that is described by info and
  whose  character  table  is  equal  to  tbl,  up to permutations of rows and
  columns. Otherwise fail is returned.
  
  Typically,  funcname  is  a string that is the name of a global GAP function
  fun,  say,  and  args  is  a  list  of arguments for this function such that
  CallFuncList( fun, args ) yields the desired group.
  
    Example  
    gap> GroupForGroupInfo( [ "AlternatingGroup", [ 5 ] ] );
    Alt( [ 1 .. 5 ] )
    gap> GroupForGroupInfo( [ "PrimitiveGroup", [ 5, 4 ] ] );
    A(5)
  
  
  3.3-5 GroupForTom
  
  GroupForTom( tomidentifier[, repnr] )  attribute
  
  Let  tomidentifier  be  a  string  that is an admissible name for a table of
  marks  from the GAP Library of Tables of Marks (the TomLib package [NMP18]).
  Called   with   one   argument,   GroupForTom  returns  the  UnderlyingGroup
  (Reference:  UnderlyingGroup  for  tables  of  marks) value of this table of
  marks.  If  a  positive integer repnr is given as the second argument then a
  representative of the repnr-th class of subgroups of this group is returned,
  see RepresentativeTom (Reference: RepresentativeTom).
  
  The  string"GroupForTom"  may  occur  in the entries of the list returned by
  GroupInfoForCharacterTable   (3.3-1),   and   therefore  may  be  called  by
  GroupForGroupInfo (3.3-4).
  
  If  the  TomLib  package  is not loaded or if it does not contain a table of
  marks with identifier tomidentifier then fail is returned.
  
    Example  
    gap> g:= GroupForTom( "A5" );  u:= GroupForTom( "A5", 2 );
    Group([ (2,4)(3,5), (1,2,5) ])
    Group([ (2,3)(4,5) ])
    gap> IsSubset( g, u );
    true
    gap> GroupForTom( "J4" );
    fail
  
  
  3.3-6 AtlasStabilizer
  
  AtlasStabilizer( gapname, repname )  function
  
  Let  gapname  be  an  admissible name of a group G, say, in the sense of the
  AtlasRep  package  (see  Section[14 X'AtlasRep: Group Names Used in the AtlasRep
  Package'), and repname be a string that occurs as the repname component of a
  record      returned      by      AllAtlasGeneratingSetInfos      (AtlasRep:
  AllAtlasGeneratingSetInfos) when this function is called with first argument
  gapname  and  further  arguments  IsTransitive (Reference: IsTransitive) and
  true.   In   this   case,   repname   describes   a  transitive  permutation
  representation of G.
  
  If  the  AtlasRep  package  is  available  and  if  the permutation group in
  question  can  be  fetched  then AtlasStabilizer returns a point stabilizer.
  Otherwise fail is returned.
  
  The string"AtlasStabilizer" may occur in the entries of the list returned by
  GroupInfoForCharacterTable   (3.3-1),   and   therefore  may  be  called  by
  GroupForGroupInfo (3.3-4).
  
    Example  
    gap> AtlasStabilizer( "A5","A5G1-p5B0");
    Group([ (1,2)(3,4), (2,3,4) ])
  
  
  3.3-7 IsNontrivialDirectProduct
  
  IsNontrivialDirectProduct( tbl )  property
  
  For  an  ordinary  character  table  tbl  of the group G, say, this function
  returns  true  if  G  is  the  direct  product  of smaller groups, and false
  otherwise.
  
    Example  
    gap> mx:= Maxes( CharacterTable( "J1" ) );
    [ "L2(11)", "2^3.7.3", "2xA5", "19:6", "11:10", "D6xD10", "7:6" ]
    gap> List( mx, name -> IsNontrivialDirectProduct(
    >                          CharacterTable( name ) ) );
    [ false, false, true, false, false, true, false ]
  
  
  
  3.4 Unipotent Characters of Finite Groups of Lie Type
  
  Unipotent  characters are defined for finite groups of Lie type. For most of
  these  groups  whose  character table is in the GAP Character Table Library,
  the unipotent characters are known and parametrised by labels. This labeling
  is  due  to  the  work  of  P.  Deligne  and G. Lusztig, thus the label of a
  unipotent character is called its Deligne-Lusztig name (see [CH05]).
  
  3.4-1 UnipotentCharacter
  
  UnipotentCharacter( tbl, label )  function
  
  Let tbl be the ordinary character table of a finite group of Lie type in the
  GAP  Character  Table  Library.  UnipotentCharacter  returns  the  unipotent
  character with Deligne-Lusztig name label.
  
  The  object  label  must  be  either  a  list  of integers which describes a
  partition  (if  the finite group of Lie type is of the type A_l or ^2A_l), a
  list  of  two lists of integers which describes a symbol (if the group is of
  classical  type  other  than  A_l and ^2A_l) or a string (if the group is of
  exceptional type).
  
  A  call of UnipotentCharacter sets the attribute DeligneLusztigNames (3.4-2)
  for tbl.
  
    Example  
    gap> tbl:= CharacterTable( "U4(2).2" );;
    gap> UnipotentCharacter( tbl, [ [ 0, 1 ], [ 2 ] ] );
    Character( CharacterTable( "U4(2).2" ),
     [ 15, 7, 3, -3, 0, 3, -1, 1, 0, 1, -2, 1, 0, 0, -1, 5, 1, 3, -1, 2, 
      -1, 1, -1, 0, 0 ] )
  
  
  3.4-2 DeligneLusztigNames
  
  DeligneLusztigNames( obj )  attribute
  
  For   a   character   table  obj,  DeligneLusztigNames  returns  a  list  of
  Deligne-Lusztig  names  of  the the unipotent characters of obj. If the i-th
  entry is bound then it is the name of the i-th irreducible character of obj,
  and  this  character  is  irreducible.  If  an  irreducible character is not
  unipotent the accordant position is unbound.
  
  DeligneLusztigNames called with a string obj, calls itself with the argument
  CharacterTable( obj ).
  
  When  DeligneLusztigNames  is called with a record obj then this should have
  the  components  isoc,  isot,  l,  and  q,  where  isoc and isot are strings
  defining the isogeny class and isogeny type, and l and q are integers. These
  components define a finite group of Lie type uniquely. Moreover this way one
  can  choose Deligne-Lusztig names for a prescribed type in those cases where
  a  group has more than one interpretation as a finite group of Lie type, see
  the example below. (The first call of DeligneLusztigNames sets the attribute
  value in the character table.)
  
    Example  
    gap> DeligneLusztigNames( "L2(7)" );
    [ [ 2 ],,,, [ 1, 1 ] ]
    gap> tbl:= CharacterTable( "L2(7)" );
    CharacterTable( "L3(2)" )
    gap> HasDeligneLusztigNames( tbl );
    true
    gap> DeligneLusztigNames( rec( isoc:= "A", isot:= "simple",
    >                              l:= 2, q:= 2 ) );
    [ [ 3 ],,, [ 2, 1 ],, [ 1, 1, 1 ] ]
  
  
  3.4-3 DeligneLusztigName
  
  DeligneLusztigName( chi )  function
  
  For    a   unipotent   character   chi,   DeligneLusztigName   returns   the
  Deligne-Lusztig name of chi. For that, DeligneLusztigNames (3.4-2) is called
  with the argument UnderlyingCharacterTable( chi ).
  
    Example  
    gap> tbl:= CharacterTable( "F4(2)" );;
    gap> DeligneLusztigName( Irr( tbl )[9] );
    fail
    gap> HasDeligneLusztigNames( tbl );
    true
    gap> List( [ 1 .. 8 ], i -> DeligneLusztigName( Irr( tbl )[i] ) );
    [ "phi{1,0}", "[ [ 2 ], [  ] ]", "phi{2,4}''", "phi{2,4}'", 
      "F4^II[1]", "phi{4,1}", "F4^I[1]", "phi{9,2}" ]
  
  
  3.4-4 KnowsDeligneLusztigNames
  
  KnowsDeligneLusztigNames( tbl )  property
  
  For  an  ordinary  character  table  tbl,  this  function  returns  true  if
  DeligneLusztigNames (3.4-2) returns the list of Deligne-Lusztig names of the
  unipotent characters of tbl, and false otherwise.
  
    Example  
    gap> KnowsDeligneLusztigNames( CharacterTable( "A5" ) );
    true
    gap> KnowsDeligneLusztigNames( CharacterTable( "M" ) );
    false
  
  
  
  3.5 Browse Applications Provided by CTblLib
  
  The  following  functions  are  available  only  if  the  GAP package Browse
  (see [BL18])  is  loaded.  The  function  DisplayCTblLibInfo  (3.5-1)  shows
  details  about  an ordinary or modular character table in a pager, the other
  functions can be used to show the following information via browse tables.
  
      An  overview  of  the  GAP  Character Table Library, and details pages
        about  ordinary  and  modular  character tables (see BrowseCTblLibInfo
        (3.5-2)),  which  allow  one to navigate to related pages and to pages
        showing      for      example      decomposition     matrices     (cf.
        BrowseDecompositionMatrix (BrowseDecompositionMatrix???)),
  
      an  alternative  display function that shows character tables from the
        Atlas  of  Finite  Groups  [CCN+85] and the Atlas of Brauer Characters
        [JLPW95]  in  a  format  similar  to  the one used in these books (see
        BrowseAtlasTable  (3.5-9),  cf.  Browse (for character tables) (Browse
        (for   character  tables)???)  for  the  default  display  format  for
        character tables),
  
      an  overview  of  the  names  of  simple groups for which the Atlas of
        Finite  Groups  [CCN+85]  and  the Atlas of Brauer Characters [JLPW95]
        show    the    character    tables    and   other   information   (see
        BrowseAtlasContents  (3.5-5), a variant that doe not rely on Browse is
        DisplayAtlasContents (3.5-6)),
  
      a  function  that  shows the Atlas map of the bicyclic extensions of a
        simple  Atlas  group  (see BrowseAtlasMap (3.5-7), a variant that does
        not rely on Browse is DisplayAtlasMap (3.5-8)),
  
      an  overview  of  the  atomic  irrationalities  that  occur  in  Atlas
        character tables (see BrowseCommonIrrationalities (3.5-3)),
  
      an overview of the lists of improvements to the Atlas of Finite Groups
        (see BrowseAtlasImprovements (3.5-10)).
  
      an  overview of the differences between the character table data since
        version  1.1.3  of  the  CTblLib package (see BrowseCTblLibDifferences
        (3.5-4)),
  
  The   functions   BrowseCTblLibInfo   (3.5-2),   BrowseCommonIrrationalities
  (3.5-3),  BrowseCTblLibDifferences (3.5-4), BrowseAtlasContents (3.5-5), and
  BrowseAtlasImprovements  (3.5-10) occur also in the list of choices shown by
  BrowseGapData (BrowseGapData???).
  
  3.5-1 DisplayCTblLibInfo
  
  DisplayCTblLibInfo( tbl )  function
  DisplayCTblLibInfo( name[, p] )  function
  StringCTblLibInfo( tbl )  function
  StringCTblLibInfo( name[, p] )  function
  
  When  DisplayCTblLibInfo  is  called  with  an ordinary or modular character
  table  tbl  then an overview of the information available for this character
  table  is shown via the function that is given by the user preference 4.5-3.
  When  DisplayCTblLibInfo  is called with a string name that is an admissible
  name  for  an  ordinary character table then the overview for this character
  table  is  shown.  If  a prime integer p is entered in addition to name then
  information about the p-modular character table is shown instead.
  
  An interactive variant of DisplayCTblLibInfo is BrowseCTblLibInfo (3.5-2).
  
  The  string  that  is  shown  by  DisplayCTblLibInfo  can  be computed using
  StringCTblLibInfo, with the same arguments.
  
    Example  
    gap> StringCTblLibInfo( CharacterTable( "A5" ) );;
    gap> StringCTblLibInfo( CharacterTable( "A5" ) mod 2 );;
    gap> StringCTblLibInfo( "A5" );;
    gap> StringCTblLibInfo( "A5", 2 );;
  
  
  3.5-2 BrowseCTblLibInfo
  
  BrowseCTblLibInfo( [func, val, ...] )  function
  BrowseCTblLibInfo( tbl )  function
  BrowseCTblLibInfo( name[, p] )  function
  Returns:  nothing.
  
  Called  without  arguments,  BrowseCTblLibInfo shows the contents of the GAP
  Character Table Library in an overview table, see below.
  
  When  arguments  func,  val, ... are given that are admissible arguments for
  AllCharacterTableNames  (3.1-4) –in particular, the first argument must be a
  function–  then  the  overview  is restricted to those character tables that
  match  the  conditions.  The  global  option  "OrderedBy" is supported as in
  AllCharacterTableNames (3.1-4).
  
  When  BrowseCTblLibInfo  is called with a character table tbl then a details
  table is opened that gives an overview of the information available for this
  character table. When BrowseCTblLibInfo is called with a string name that is
  an  admissible  name  for an ordinary character table then the details table
  for  this  character  table  is  opened.  If a prime integer p is entered in
  addition  to  name  then  information about the p-modular character table is
  shown instead.
  
  The overview table has the following columns.
  
  name
        the  Identifier  (Reference: Identifier for character tables) value of
        the table,
  
  size
        the group order,
  
  nccl
        the number of conjugacy classes,
  
  fusions -> G
        the list of identifiers of tables on which a fusion to the given table
        is stored, and
  
  fusions G ->
        the  list  of identifiers of tables to which a fusion is stored on the
        given table.
  
  The  details  table for a given character table has exactly one column. Only
  part   of   the   functionality   of   the   function  NCurses.BrowseGeneric
  (NCurses.BrowseGeneric???)  is available in such a table. On the other hand,
  the  details  tables contain links to other Browse applications, for example
  other details tables.
  
  When  one clicks on a row or an entry in the overview table then the details
  table  for  the character table in question is opened. One can navigate from
  this  details  table  to  a  related  one,  by  first activating a link (via
  repeatedly  hitting  the  Tab  key)  and then following the active link (via
  hitting the Return key). If mouse actions are enabled (by hitting the M key,
  see  NCurses.UseMouse  (NCurses.UseMouse???))  then  one  can  alternatively
  activate a link and click on it via mouse actions.
  
    Example  
    gap> tab:= [ 9 ];;         # hit the TAB key
    gap> n:= [ 14, 14, 14 ];;  # ``do nothing'' input (means timeout)
    gap> BrowseData.SetReplay( Concatenation(
    >         # select the first column, search for the name A5
    >         "sc/A5", [ NCurses.keys.DOWN, NCurses.keys.DOWN,
    >         NCurses.keys.RIGHT, NCurses.keys.ENTER ],
    >         # open the details table for A5
    >         [ NCurses.keys.ENTER ], n, n,
    >         # activate the link to the character table of A5
    >         tab, n, n,
    >         # show the character table of A5
    >         [ NCurses.keys.ENTER ], n, n, "seddrr", n, n,
    >         # close this character table
    >         "Q",
    >         # activate the link to the maximal subgroup D10
    >         tab, tab, n, n,
    >         # jump to the details table for D10
    >         [ NCurses.keys.ENTER ], n, n,
    >         # close this details table
    >         "Q",
    >         # activate the link to a decomposition matrix
    >         tab, tab, tab, tab, tab, n, n,
    >         # show the decomposition matrix
    >         [ NCurses.keys.ENTER ], n, n,
    >         # close this table
    >         "Q",
    >         # activate the link to the AtlasRep overview
    >         tab, tab, tab, tab, tab, tab, tab, n, n,
    >         # show the overview
    >         [ NCurses.keys.ENTER ], n, n,
    >         # close this table
    >         "Q",
    >         # and quit the applications
    >         "QQ" ) );
    gap> BrowseCTblLibInfo();
    gap> BrowseData.SetReplay( false );
  
  
  3.5-3 BrowseCommonIrrationalities
  
  BrowseCommonIrrationalities(  )  function
  Returns:  a  list  of  info  records  for the irrationalities that have been
            clicked in visual mode.
  
  This  function  shows  the  atomic  irrationalities  that occur in character
  tables  in  the  Atlas  of  Finite  Groups [CCN+85]  or  the Atlas of Brauer
  Characters [JLPW95],  together  with descriptions of their reductions to the
  relevant  finite  fields  in  a browse table with the following columns. The
  format is the same as in [JLPW95, Appendix 1].
  
  name
        the  name  of  the  irrationality,  see AtlasIrrationality (Reference:
        AtlasIrrationality),
  
  p
        the characteristic,
  
  value mod C_n
        the  corresponding  reduction  to  a finite field of characteristic p,
        given   by   the  residue  modulo  the  n-th  Conway  polynomial  (see
        ConwayPolynomial (Reference: ConwayPolynomial)),
  
  n
        the   degree   of  the  smallest  extension  of  the  prime  field  of
        characteristic p that contains the reduction.
  
    Example  
    gap> n:= [ 14, 14, 14 ];;  # ``do nothing'' input (means timeout)
    gap> BrowseData.SetReplay( Concatenation(
    >         # categorize the table by the characteristics
    >         "scrsc", n, n,
    >         # expand characteristic 2
    >         "srxq", n, n,
    >         # scroll down
    >         "DDD", n, n,
    >         # and quit the application
    >         "Q" ) );
    gap> BrowseCommonIrrationalities();;
    gap> BrowseData.SetReplay( false );
  
  
  3.5-4 BrowseCTblLibDifferences
  
  BrowseCTblLibDifferences(  )  function
  Returns:  nothing.
  
  BrowseCTblLibDifferences  lists  the differences between the versions of the
  character table data in the CTblLib package, since version 1.1.3.
  
  The  overview table contains one row for each change, where change means the
  addition,  modification,  or  removal  of information, and has the following
  columns.
  
  Identifier
        the  Identifier  (Reference: Identifier for character tables) value of
        the character table,
  
  Type
        one of NEW (for the addition of previously not available information),
        *** (for a bugfix), or C (for a change that does not really fix a bug,
        typically a change motivated by a new consistency criterion),
  
  What
        one  of  class  fusions  (some  class  fusions from or to the table in
        question  were  changed),  maxes  (the  value  of  the attribute Maxes
        (3.7-1) was changed), names (incorrect admissible names were removed),
        table  or  table  mod p (the ordinary or p-modular character table was
        changed),  maxes  (the  value  of  the  attribute  Maxes  (3.7-1)  was
        changed),  tom  fusion (the value of the attribute FusionToTom (3.2-4)
        was changed),
  
  Description
        a description what has been changed,
  
  Flag
        one of Dup (the table is a duplicate, in the sense of IsDuplicateTable
        (3.6-1)),  Der  (the  row belongs to a character table that is derived
        from  other  tables),  Fus  (the  row belongs to the addition of class
        fusions),  Max  (the  row  belongs to a character table that was added
        because  its group is maximal in another group), or None (in all other
        cases  –these  rows  are  to  some  extent  the interesting ones). The
        information  in  this  column  can be used to restrict the overview to
        interesting subsets.
  
  Vers.
        the  package version in which the change described by the row appeared
        first.
  
  The    full    functionality    of    the   function   NCurses.BrowseGeneric
  (NCurses.BrowseGeneric???) is available.
  
  The following examples show the input for
  
      restricting the overview to error rows,
  
      restricting the overview to None rows, and
  
      restricting the overview to rows about a particular table.
  
    Example  
    gap> n:= [ 14, 14, 14, 14, 14, 14 ];;  # ``do nothing''
    gap> enter:= [ NCurses.keys.ENTER ];;
    gap> down:= [ NCurses.keys.DOWN ];;
    gap> right:= [ NCurses.keys.RIGHT ];;
    gap> BrowseData.SetReplay( Concatenation(
    >        "scr",                    # select the 'Type' column,
    >        "f***", enter,            # filter rows containing '***',
    >        n, "Q" ) );               # and quit
    gap> BrowseCTblLibDifferences();
    gap> BrowseData.SetReplay( Concatenation(
    >        "scrrrr",                 # select the 'Flag' column,
    >        "fNone", enter,           # filter rows containing 'None',
    >        n, "Q" ) );               # and quit
    gap> BrowseCTblLibDifferences();
    gap> BrowseData.SetReplay( Concatenation(
    >        "fM",                     # filter rows containing 'M',
    >        down, down, down, right,  # but 'M' as a whole word,
    >        enter,                    #
    >        n, "Q" ) );               # and quit
    gap> BrowseCTblLibDifferences();
    gap> BrowseData.SetReplay( false );
  
  
  3.5-5 BrowseAtlasContents
  
  BrowseAtlasContents(  )  function
  Returns:  nothing.
  
  BrowseAtlasContents  shows  the  list  of  names  of  simple  groups and the
  corresponding  page numbers in the Atlas of Finite Groups [CCN+85], as given
  on  page  v  of  this book, plus a few groups for which [JLPW95, Appendix 2]
  states  that  their  character tables in Atlas format have been obtained; if
  applicable  then  also the corresponding page numbers in the Atlas of Brauer
  Characters [JLPW95] are shown.
  
  Clicking on a page number opens the Atlas map for the group in question, see
  BrowseAtlasMap  (3.5-7). (From the map, one can open the Atlas style display
  using the input "T".)
  
    Example  
    gap> d:= [ NCurses.keys.DOWN ];;  r:= [ NCurses.keys.RIGHT ];;
    gap> c:= [ NCurses.keys.ENTER ];;
    gap> BrowseData.SetReplay( Concatenation(
    >        "/J2",         # Find the string J2,
    >        c,             # start the search,
    >        r,             # select the page for the ordinary table,
    >        c,             # click the entry,
    >        "se",          # select the box of the simple group,
    >        c,             # click the box,
    >        "Q",           # quit the info overview for J2,
    >        d,             # move down to 2.J2,
    >        c,             # click the box,
    >        "Q",           # quit the info overview for 2.J2,
    >        "T",           # show the ATLAS table for (extensions of) J2
    >        "Q",           # quit the ATLAS table,
    >        "Q",           # quit the map,
    >        r,             # select the page for the 2-modular table,
    >        c,             # click the entry,
    >        "T",           # show the 2-modular ATLAS table
    >        "Q",           # quit the ATLAS table,
    >        "Q",           # quit the map,
    >        "Q" ) );       # and quit the application.
    gap> BrowseAtlasContents();
    gap> BrowseData.SetReplay( false );
  
  
  3.5-6 DisplayAtlasContents
  
  DisplayAtlasContents(  )  function
  StringAtlasContents(  )  function
  
  DisplayAtlasContents calls the function that is given by the user preference
  4.5-3,  in  order  to  show  the  list  of  names  of  simple groups and the
  corresponding  page numbers in the Atlas of Finite Groups [CCN+85], as given
  on  page  v  of  this book, plus a few groups for which [JLPW95, Appendix 2]
  states  that  their  character tables in Atlas format have been obtained; if
  applicable  then  also the corresponding page numbers in the Atlas of Brauer
  Characters [JLPW95] are shown.
  
  An   interactive  variant  of  DisplayAtlasContents  is  BrowseAtlasContents
  (3.5-5).
  
  The  string  that  is  shown  by  DisplayAtlasContents can be computed using
  StringAtlasContents.
  
    Example  
    gap> str:= StringAtlasContents();;
    gap> pos:= PositionNthOccurrence( str, '\n', 10 );;
    gap> Print( str{ [ 1 .. pos ] } );
    A5 = L2(4) = L2(5)    2       2:2, 3:2, 5:2
    L3(2) = L2(7)         3       2:3, 3:3, 7:3
    A6 = L2(9) = S4(2)'   4       2:4, 3:4, 5:5
    L2(8) = R(3)'         6       2:6, 3:6, 7:6
    L2(11)                7       2:7, 3:7, 5:8, 11:8
    L2(13)                8       2:9, 3:9, 7:10, 13:10
    L2(17)                9       2:11, 3:11, 17:12
    A7                   10       2:13, 3:13, 5:14, 7:15
    L2(19)               11       2:16, 3:16, 5:17, 19:18
    L2(16)               12       2:19, 3:20, 5:20, 17:21
  
  
  3.5-7 BrowseAtlasMap
  
  BrowseAtlasMap( name[, p] )  function
  Returns:  nothing.
  
  For  a string name that is the identifier of the character table of a simple
  group from the Atlas of Finite Groups [CCN+85], BrowseAtlasMap shows the map
  that  describes  the bicyclic extensions of this group, see [CCN+85, Chapter
  6]. If the optional argument p is not given or if p is zero then the map for
  the ordinary character tables is shown, if p is a prime integer then the map
  for the p-modular Brauer character tables is shown, as in [JLPW95].
  
  Clicking  on  a  square of the map opens the character table information for
  the extension in question, by calling BrowseCTblLibInfo (3.5-2).
  
    Example  
    gap> d:= [ NCurses.keys.DOWN ];;  r:= [ NCurses.keys.RIGHT ];;
    gap> c:= [ NCurses.keys.ENTER ];;
    gap> BrowseData.SetReplay( Concatenation(
    >        "T",           # show the ATLAS table for (extensions of) M12
    >        "Q",           # quit the ATLAS table,
    >        "se",          # select the box of the simple group,
    >        c,             # click the box,
    >        "Q",           # quit the info overview for M12,
    >        r, d,          # select the box for the bicyclic extension,
    >        c,             # click the box,
    >        "Q",           # quit the info overview,
    >        "Q" ) );       # and quit the application.
    gap> BrowseAtlasMap( "M12" );
    gap> BrowseData.SetReplay( false );
  
  
  3.5-8 DisplayAtlasMap
  
  DisplayAtlasMap( name[, p] )  function
  DisplayAtlasMap( arec )  function
  StringsAtlasMap( name[, p] )  function
  StringsAtlasMap( arec )  function
  Returns:  DisplayAtlasMap  returns  nothing,  StringsAtlasMap returns either
            fail or the list of strings that form the rows of the Atlas map of
            the group in question.
  
  Let  name  be  an  admissible name for the character table of a simple Atlas
  group, and p be a prime integer or 0 (which is the default). DisplayAtlasMap
  shows  the map for the group and its extensions, similar to the map shown in
  the Atlas. StringsAtlasMap returns the list of strings that form the rows of
  this map.
  
    Example  
    gap> DisplayAtlasMap( "M12" );
    --------- ---------   
    |       | |       |   
    |   G   | |  G.2  | 15
    |       | |       |   
    --------- ---------   
    --------- ---------   
    |       | |       |   
    |  2.G  | | 2.G.2 | 11
    |       | |       |   
    --------- ---------   
        15        9    
    gap> DisplayAtlasMap( "M12", 2 );
    --------- ---------  
    |       | |       |  
    |   G   | |  G.2  | 6
    |       | |       |  
    --------- ---------  
        6         0    
    gap> StringsAtlasMap( "M11" );
    [ "---------   ", "|       |   ", "|   G   | 10", "|       |   ", 
      "---------   ", "    10   " ]
  
  
  More  generally,  name  can be an admissible name for a character with known
  ExtensionInfoCharacterTable   (3.7-3)   value  and  such  that  the  strings
  describing  multiplier  and  outer automorphism group in this value occur in
  the    lists    CTblLib.AtlasMapMultNames    and   CTblLib.AtlasMapOutNames,
  respectively.  If  not  all  character  tables of bicyclic extensions of the
  simple  group  in  question are available then StringsAtlasMap returns fail,
  and DisplayAtlasMap shows nothing.
  
    Example  
    gap> DisplayAtlasMap( "S10(2)" );
    ---------    
    |       |    
    |   G   | 198
    |       |    
    ---------    
       198   
    gap> DisplayAtlasMap( "L12(27)" );
    gap> StringsAtlasMap( "L12(27)" );
    fail
  
  
  If  the  abovementioned  requirements  are  not  satisfied for the character
  tables  in  question  then  one  can provide the necessary information via a
  record arec.
  
  The  following example shows the Atlas map for the alternating group on four
  points,  viewed  as  an extension of the trivial group by a Klein four group
  and a group of order three.
  
    Example  
    gap> DisplayAtlasMap( rec(
    > labels:= [ [ "G", "G.3" ],
    >            [ "2.G", "" ],
    >            [ "2'.G", "" ],
    >            [ "2''.G", "" ] ],
    > shapes:= [ [ "closed", "closed" ],
    >            [ "closed", "empty" ],
    >            [ "closed", "empty" ],
    >            [ "closed", "empty" ] ],
    > labelscol:= [ "1", "1" ],
    > labelsrow:= [ "1", "1", "1", "1" ],
    > dashedhorz:= [ false, false, true, true ],
    > dashedvert:= [ false, false ],
    > showdashedrows:= true ) );
          --------- ---------  
          |       | |       |  
          |   G   | |  G.3  | 1
          |       | |       |  
          --------- ---------  
          ---------            
          |       |            
          |  2.G  |           1
          |       |            
          ---------            
     2'.G ---------          
          ---------          
    2''.G ---------          
          ---------          
              1         1    
  
  
  The  next  example  shows  the  Atlas  map  for the symmetric group on three
  points, viewed as a bicyclic extension of the trivial group by groups of the
  orders three and two, respectively.
  
    Example  
    gap> DisplayAtlasMap( rec(
    > labels:= [ [ "G", "G.2" ],
    >            [ "3.G", "3.G.2" ] ],
    > shapes:= [ [ "closed", "closed" ],
    >            [ "closed", "open" ] ],
    > labelscol:= [ "1", "1" ],
    > labelsrow:= [ "1", "1" ],
    > dashedhorz:= [ false, false ],
    > dashedvert:= [ false, false ],
    > showdashedrows:= true ) );
    --------- ---------  
    |       | |       |  
    |   G   | |  G.2  | 1
    |       | |       |  
    --------- ---------  
    --------- --------   
    |       | |          
    |  3.G  | | 3.G.2   1
    |       | |          
    ---------            
        1         1    
  
  
  (Depending on the terminal capabilities, the results may look nicer than the
  ASCII only graphics shown above.)
  
  The following components of arec are supported.
  
  name
        a string, the name of the (simple) group;
  
  char
        the characteristic, the default is 0;
  
  identifiers
        an  m by n matrix whose entries are fail or the Identifier (Reference:
        Identifier  for tables of marks) values of the character tables of the
        extensions in question;
  
  labels
        an  m  by n matrix whose entries are fail or the strings that shall be
        used as the labels of the boxes;
  
  shapes
        an  m  by  n  matrix  whose  entries are the strings "closed", "open",
        "broken", and "empty", describing the boxes that occur;
  
  labelscol
        a list of length n that contains the labels to be shown below the last
        row  of  boxes, intended to show the numbers of classes in this column
        of boxes;
  
  labelsrow
        a  list  of length m that contains the labels to be shown on the right
        of  the  last  column  of  boxes,  intended  to  show  the  numbers of
        characters in this row of boxes;
  
  dashedhorz
        a list of length m with entries true (the boxes in this row shall have
        small  height)  or  false  (the  boxes  in  this row shall have normal
        height);
  
  dashedvert
        a  list  of length n with entries true (the boxes in this column shall
        have small width) or false (the boxes in this column shall have normal
        width);
  
  showdashedrows
        true or false, the default is to show rows of dashed boxes in the case
        of  ordinary tables, and to omit them in the case of Brauer tables, as
        happens in the printed Atlases;
  
  onlyasciiboxes
        true (show only ASCII characters when drawing the boxes) or false (use
        line  drawing  characters),  the  default  is  the  value  returned by
        CTblLib.ShowOnlyASCII;
  
  onlyasciilabels
        true  (show  only  ASCII characters in the labels inside the boxes) or
        false  (default,  use  subscripts  if  applicable); the default is the
        value returned by CTblLib.ShowOnlyASCII;
  
  specialshapes
        a  list of length three that describes exceptional cases (intended for
        the  treatment of dashed names and broken boxes, look at the values in
        CTblLib.AtlasMapBoxesSpecial where this component is actually used).
  
  3.5-9 BrowseAtlasTable
  
  BrowseAtlasTable( name[, p] )  function
  Returns:  nothing.
  
  BrowseAtlasTable displays the character tables of bicyclic extensions of the
  simple group with the name name in a window, in the same format as the Atlas
  of  Finite  Groups  [CCN+85] and the Atlas of Brauer Characters [JLPW95] do.
  For  that, it is necessary that these tables are known, as well as the class
  fusions  between  them  and perhaps additional information (e. g., about the
  existence  of  certain  extensions). These requirements are fulfilled if the
  tables are contained in the Atlas, but they may hold also in other cases.
  
  If  a  prime  p  is  given  as the second argument then the p-modular Brauer
  tables are shown, otherwise (or if p is zero) the ordinary tables are shown.
  
    Example  
    gap> d:= [ NCurses.keys.DOWN ];;  r:= [ NCurses.keys.RIGHT ];;
    gap> c:= [ NCurses.keys.ENTER ];;
    gap> BrowseData.SetReplay( Concatenation(
    >        "/y",          # Find the string y,
    >        c,             # start the search,
    >        "nnnn",        # Find more occurrences,
    >        "Q" ) );       # and quit the application.
    gap> BrowseAtlasTable( "A6" );
    gap> BrowseData.SetReplay( false );
  
  
  The  function  uses  NCurses.BrowseGeneric  (NCurses.BrowseGeneric???).  The
  identifier  of the table is used as the static header. The strings X_1, X_2,
  ...  are  used  as  row  labels  for those table rows that contain character
  values,  and  column  labels  are  given  by  centralizer  orders, power map
  information, and class names.
  
  3.5-10 BrowseAtlasImprovements
  
  BrowseAtlasImprovements( [choice] )  function
  Returns:  nothing.
  
  Called     without    argument    or    with    the    string    "ordinary",
  BrowseAtlasImprovements  shows  the  lists  of  improvements to the Atlas of
  Finite Groups [CCN+85] that are contained in [BN95] and [Nor].
  
  Called  with the string "modular", BrowseAtlasImprovements shows the list of
  improvements  to  the Atlas of Brauer Characters [JLPW95] that are contained
  in [ABC].
  
  Called with true, the concatenation of the above lists are shown.
  
  The  overview  table  contains  one  row  for  each improvement, and has the
  following columns.
  
  Section
        the  part  in  the Atlas to which the entry belongs (Introduction, The
        Groups, Additional information, Bibliography, Appendix 1, Appendix 2),
  
  Src
        1 for entries from [BN95], 2 for entries from [Nor], and 3 for entries
        from [ABC],
  
  Typ
        the type of the improvement, one of *** (for mathematical errors), NEW
        (for  new  information),  C  (for  improvements  concerning grammar or
        notational   consistency),   or   M   (for   misprints   or  cases  of
        illegibility),
  
  Page
        the page and perhaps the line in the (ordinary or modular) Atlas,
  
  Group
        the  name  of  the  simple group to which the entry belongs (empty for
        entries not from the section The Groups),
  
  Text
        the description of the entry,
  
  **
        for each entry of the type ***, the subtype of the error to which some
        statements  in  [BMO17]  refer, one of CH (character values), P (power
        maps, element orders, and class names), FI (fusions and indicators), I
        (Introduction,   Bibliography,   the   list   showing  the  orders  of
        multipliers  and  outer  automorphism  group,  and  the list of Conway
        polynomials), MP (maps), MX (descriptions of maximal subgroups), and G
        (other information about the group).
  
  The    full    functionality    of    the   function   NCurses.BrowseGeneric
  (NCurses.BrowseGeneric???) is available.
  
  The  following  example  shows  the  input for first restricting the list to
  errors (type ***), then categorizing the filtered list by the subtype of the
  error, and then expanding the category for the subtype CH.
  
    Example  
    gap> n:= [ 14, 14, 14, 14, 14, 14 ];;  # ``do nothing''
    gap> enter:= [ NCurses.keys.ENTER ];;
    gap> BrowseData.SetReplay( Concatenation(
    >        "scrr",                   # select the 'Typ' column,
    >        "f***", enter,            # filter rows containing '***',
    >        "scrrrrrrsc", enter,      # categorize by the error kind
    >        "sr", enter,              # expand the 'CH' category
    >        n, "Q" ) );               # and quit
    gap> BrowseAtlasImprovements();
    gap> BrowseData.SetReplay( false );
  
  
  
  3.6 Duplicates of Library Character Tables
  
  It  can  be  useful  to  deal with different instances of the same character
  table.  An  example  is  the situation that a group G, say, contains several
  classes  of  isomorphic maximal subgroups that have different class fusions;
  the  attribute  Maxes  (3.7-1)  of  the  character  table of G then contains
  several  entries  that  belong to the same group, but the identifiers of the
  character tables are different.
  
  On  the  other  hand, it can be useful to consider only one of the different
  instances  when  one  searches for character tables with certain properties,
  for example using OneCharacterTableName (3.1-5).
  
  For  that, we introduce the following concept. A character table t_1 is said
  to  be  a  duplicate  of  another  character  table  t_2  if  the  attribute
  IdentifierOfMainTable  (3.6-2) returns the Identifier (Reference: Identifier
  for  character  tables) value of t_2 when it is called with t_1, and we call
  t_2  the  main  table of t_1. In this case, IsDuplicateTable (3.6-1) returns
  true for t_1.
  
  If  the  character  table  t_1 is not a duplicate of any other library table
  then IdentifierOfMainTable (3.6-2) returns fail for t_1 and IsDuplicateTable
  (3.6-1) returns false.
  
  See    AllCharacterTableNames    (3.1-4)   for   examples   how   to   apply
  IsDuplicateTable (3.6-1) in practice.
  
  We do not promise that two library tables for which IsDuplicateTable (3.6-1)
  returns false are necessarily different. (And since nonisomorphic groups may
  have  the  same  character  table,  it  would  not make sense to think about
  restricting  a  search to a subset of library tables that belong to pairwise
  nonisomorphic groups.)
  
  Currently  IdentifierOfMainTable  (3.6-2)  does  not  return fail for t_1 if
  ConstructionInfoCharacterTable (3.7-4) is set in t_1, the first entry of the
  attribute value is "ConstructPermuted", and one of the following holds.
  
      The  second  entry of the ConstructionInfoCharacterTable (3.7-4) value
        is  a  list  of  length  1  that  contains  the Identifier (Reference:
        Identifier for character tables) value of t_2.
  
      The  SpinSym  package is loaded and t_1 is one of the character tables
        provided  by  this  package. These tables are not declared as permuted
        tables of library tables, but we want to regard them as duplicates.
  
  3.6-1 IsDuplicateTable
  
  IsDuplicateTable( tbl )  property
  
  For  an  ordinary  character table tbl from the GAP Character Table Library,
  this  function  returns  true  if  tbl  was constructed from another library
  character   table   by   permuting  rows  and  columns,  via  the  attribute
  ConstructionInfoCharacterTable  (3.7-4).  Otherwise  false  is  returned, in
  particular  if  tbl  is  not  a character table from the GAP Character Table
  Library.
  
  One   application   of   this  function  is  to  restrict  the  search  with
  AllCharacterTableNames  (3.1-4) to only one library character table for each
  class  of permutation equivalent tables. Note that this does property of the
  search  result  cannot  be  guaranteed if private character tables have been
  added to the library, see NotifyCharacterTable (4.7-5).
  
    Example  
    gap> Maxes( CharacterTable( "A6" ) );
    [ "A5", "A6M2", "3^2:4", "s4", "A6M5" ]
    gap> IsDuplicateTable( CharacterTable( "A5" ) );
    false
    gap> IsDuplicateTable( CharacterTable( "A6M2" ) );
    true
  
  
  3.6-2 IdentifierOfMainTable
  
  IdentifierOfMainTable( tbl )  attribute
  
  If  tbl  is  an ordinary character table that is a duplicate in the sense of
  the  introduction  to  Section[14 X3.6 then this function returns the Identifier
  (Reference: Identifier for character tables) value of the main table of tbl.
  Otherwise fail is returned.
  
    Example  
    gap> Maxes( CharacterTable( "A6" ) );
    [ "A5", "A6M2", "3^2:4", "s4", "A6M5" ]
    gap> IdentifierOfMainTable( CharacterTable( "A5" ) );
    fail
    gap> IdentifierOfMainTable( CharacterTable( "A6M2" ) );
    "A5"
  
  
  3.6-3 IdentifiersOfDuplicateTables
  
  IdentifiersOfDuplicateTables( tbl )  attribute
  
  For  an  ordinary  character  table  tbl,  this function returns the list of
  Identifier  (Reference:  Identifier  for  character  tables) values of those
  character tables from the GAP Character Table Library that are duplicates of
  tbl, in the sense of the introduction to Section[14 X3.6.
  
    Example  
    gap> Maxes( CharacterTable( "A6" ) );
    [ "A5", "A6M2", "3^2:4", "s4", "A6M5" ]
    gap> IdentifiersOfDuplicateTables( CharacterTable( "A5" ) );
    [ "A6M2", "Alt(5)" ]
    gap> IdentifiersOfDuplicateTables( CharacterTable( "A6M2" ) );
    [  ]
  
  
  
  3.7 Attributes for Library Character Tables
  
  This  section  describes  certain  attributes which are set only for certain
  (not necessarily all) character tables from the GAP Character Table Library.
  The  attribute  values  are  part  of the database, there are no methods for
  computing them, except for InfoText (3.7-5).
  
  Other  such  attributes  and  properties  are  described  in manual sections
  because  the  context fits better. These attributes are FusionToTom (3.2-4),
  GroupInfoForCharacterTable      (3.3-1),     KnowsSomeGroupInfo     (3.3-2),
  IsNontrivialDirectProduct      (3.3-7),     DeligneLusztigNames     (3.4-2),
  DeligneLusztigName      (3.4-3),      KnowsDeligneLusztigNames      (3.4-4),
  IsDuplicateTable (3.6-1), and CASInfo (4.4-1).
  
  3.7-1 Maxes
  
  Maxes( tbl )  attribute
  
  If  this attribute is set for an ordinary character table tbl then the value
  is  a  list  of  identifiers of the ordinary character tables of all maximal
  subgroups of tbl. There is no default method to compute this value from tbl.
  
  If the Maxes value of tbl is stored then it lists exactly one representative
  for  each  conjugacy class of maximal subgroups of the group of tbl, and the
  character  tables  of  these  maximal  subgroups  are  available  in the GAP
  Character  Table  Library, and compatible class fusions to tbl are stored on
  these tables (see the example in Section 2.3-5).
  
    Example  
    gap> tbl:= CharacterTable( "M11" );;
    gap> HasMaxes( tbl );
    true
    gap> maxes:= Maxes( tbl );
    [ "A6.2_3", "L2(11)", "3^2:Q8.2", "A5.2", "2.S4" ]
    gap> CharacterTable( maxes[1] );
    CharacterTable( "A6.2_3" )
  
  
  3.7-2 ProjectivesInfo
  
  ProjectivesInfo( tbl )  attribute
  
  If  this attribute is set for an ordinary character table tbl then the value
  is a list of records, each with the following components.
  
  name
        the  Identifier  (Reference: Identifier for character tables) value of
        the  character  table  of  the  covering  whose  faithful  irreducible
        characters are described by the record,
  
  chars
        a  list  of values lists of faithful projective irreducibles; only one
        representative  of  each  family  of Galois conjugates is contained in
        this list. and
  
    Example  
    gap> ProjectivesInfo( CharacterTable( "A5" ) );
    [ rec( 
          chars := [ [ 2, 0, -1, E(5)+E(5)^4, E(5)^2+E(5)^3 ], 
              [ 2, 0, -1, E(5)^2+E(5)^3, E(5)+E(5)^4 ], 
              [ 4, 0, 1, -1, -1 ], [ 6, 0, 0, 1, 1 ] ], name := "2.A5" ) ]
  
  
  3.7-3 ExtensionInfoCharacterTable
  
  ExtensionInfoCharacterTable( tbl )  attribute
  
  Let tbl be the ordinary character table of a group G, say. If this attribute
  is set for tbl then the value is a list of length two, the first entry being
  a  string  M  that  describes the Schur multiplier of G and the second entry
  being  a  string A that describes the outer automorphism group of G. Trivial
  multiplier or outer automorphism group are denoted by an empty string.
  
  If  tbl is a table from the GAP Character Table Library and G is (nonabelian
  and)  simple then the value is set. In this case, an admissible name for the
  character  table  of  a  universal  covering  group  of  G (if this table is
  available  and  different from tbl) is given by the concatenation of M, ".",
  and  the  Identifier  (Reference:  Identifier for character tables) value of
  tbl.  Analogously,  an  admissible  name  for  the  character  table  of the
  automorphism  group of G (if this table is available and different from tbl)
  is  given  by the concatenation of the Identifier (Reference: Identifier for
  character tables) value of tbl, ".", and A.
  
    Example  
    gap> ExtensionInfoCharacterTable( CharacterTable( "A5" ) );
    [ "2", "2" ]
  
  
  3.7-4 ConstructionInfoCharacterTable
  
  ConstructionInfoCharacterTable( tbl )  attribute
  
  If  this attribute is set for an ordinary character table tbl then the value
  is  a list that describes how this table was constructed. The first entry is
  a  string  that  is  the  identifier of the function that was applied to the
  pre-table record; the remaining entries are the arguments for that function,
  except that the pre-table record must be prepended to these arguments.
  
  3.7-5 InfoText
  
  InfoText( tbl )  method
  
  This  method  for  library  character  tables  returns an empty string if no
  InfoText value is stored on the table tbl.
  
  Without  this  method,  it  would  be impossible to use InfoText in calls to
  AllCharacterTableNames (3.1-4), as in the following example.
  
    Example  
    gap> AllCharacterTableNames( InfoText,
    >        s -> PositionSublist( s, "tests:" ) <> fail );;
  
  

Generated by dwww version 1.15 on Sun Jun 23 04:25:25 CEST 2024.