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

  
  6 Interfaces to Other Data Formats for Character Tables
  
  This chapter describes data formats for character tables that can be read or
  created by GAP. Currently these are the formats used by
  
      the CAS system (see[14 X6.1),
  
      the MOC system (see[14 X6.2),
  
      GAP 3 (see[14 X6.3),
  
      the so-called Cambridge format (see[14 X6.4), and
  
      the MAGMA system (see[14 X6.5).
  
  
  6.1 Interface to the CAS System
  
  The interface to CAS (see [NPP84]) is thought just for printing the CAS data
  to  a  file.  The function CASString (6.1-1) is available mainly in order to
  document the data format. Reading CAS tables is not supported; note that the
  tables  contained  in  the CAS Character Table Library have been migrated to
  GAP using a few sed scripts and C programs.
  
  6.1-1 CASString
  
  CASString( tbl )  function
  
  is  a string that encodes the CAS library format of the character table tbl.
  This  string  can  be  printed to a file which then can be read into the CAS
  system using its get command (see [NPP84]).
  
  The  used  line length is the first entry in the list returned by SizeScreen
  (Reference: SizeScreen).
  
  Only  the known values of the following attributes are used. ClassParameters
  (Reference:  ClassParameters)  (for  partitions  only), ComputedClassFusions
  (Reference:     ComputedClassFusions),     ComputedIndicators    (Reference:
  ComputedIndicators),   ComputedPowerMaps   (Reference:   ComputedPowerMaps),
  ComputedPrimeBlocks     (Reference:     ComputedPrimeBlockss),    Identifier
  (Reference:   Identifier   for   character   tables),  InfoText  (Reference:
  InfoText),  Irr  (Reference:  Irr),  OrdersClassRepresentatives  (Reference:
  OrdersClassRepresentatives),   Size   (Reference:  Size),  SizesCentralizers
  (Reference: SizesCentralisers).
  
    Example  
    gap> Print( CASString( CharacterTable( "Cyclic", 2 ) ), "\n" );
    'C2'
    00/00/00. 00.00.00.
    (2,2,0,2,-1,0)
    text:
    (#computed using generic character table for cyclic groups#),
    order=2,
    centralizers:(
    2,2
    ),
    reps:(
    1,2
    ),
    powermap:2(
    1,1
    ),
    characters:
    (1,1
    ,0:0)
    (1,-1
    ,0:0);
    /// converted from GAP
  
  
  
  6.2 Interface to the MOC System
  
  The  interface  to  MOC  (see [HJLP])  can  be  used  to  print  MOC  input.
  Additionally   it   provides  an  alternative  representation  of  (virtual)
  characters.
  
  The  MOC 3  code of a 5 digit number in MOC 2 code is given by the following
  list. (Note that the code must contain only lower case letters.)
  
  ABCD    for  0ABCD
  a       for  10000
  b       for  10001          k       for  20001
  c       for  10002          l       for  20002
  d       for  10003          m       for  20003
  e       for  10004          n       for  20004
  f       for  10005          o       for  20005
  g       for  10006          p       for  20006
  h       for  10007          q       for  20007
  i       for  10008          r       for  20008
  j       for  10009          s       for  20009
  tAB     for  100AB
  uAB     for  200AB
  vABCD   for  1ABCD
  wABCD   for  2ABCD
  yABC    for  30ABC
  z       for  31000
  
  Note that any long number in MOC 2 format is divided into packages of length
  4,  the  first (!) one filled with leading zeros if necessary. Such a number
  with  decimals d_1, d_2, ..., d_{4n+k} is the sequence 0 d_1 d_2 d_3 d_4 ...
  0 d_{4n-3} d_{4n-2} d_{4n-1} d_4n d_{4n+1} ... d_{4n+k} where 0 ≤ k ≤ 3, the
  first  digit  of  x  is  1  if the number is positive and 2 if the number is
  negative, and then follow (4-k) zeros.
  
  Details  about  the  MOC system are explained in [HJLP], a brief description
  can be found in [LP91].
  
  6.2-1 MAKElb11
  
  MAKElb11( listofns )  function
  
  For  a list listofns of positive integers, MAKElb11 prints field information
  for all number fields with conductor in this list.
  
  The  output  of MAKElb11 is used by the MOC system; Calling MAKElb11( [ 3 ..
  189 ] ) will print something very similar to Richard Parker's file lb11.
  
    Example  
    gap> MAKElb11( [ 3, 4 ] );
       3   2   0   1   0
       4   2   0   1   0
  
  
  6.2-2 MOCTable
  
  MOCTable( gaptbl[, basicset] )  function
  
  MOCTable returns the MOC table record of the GAP character table gaptbl.
  
  The  one  argument  version  can be used only if gaptbl is an ordinary (G.0)
  table.  For  Brauer (G.p) tables, one has to specify a basic set basicset of
  ordinary  irreducibles.  basicset  must  then  be a list of positions of the
  basic  set characters in the Irr (Reference: Irr) list of the ordinary table
  of gaptbl.
  
  The  result  is a record that contains the information of gaptbl in a format
  similar  to  the MOC 3 format. This record can, e. g., easily be printed out
  or be used to print out characters using MOCString (6.2-3).
  
  The components of the result are
  
  identifier
        the  string  MOCTable( name ) where name is the Identifier (Reference:
        Identifier for character tables) value of gaptbl,
  
  GAPtbl
        gaptbl,
  
  prime
        the characteristic of the field (label 30105 in MOC),
  
  centralizers
        centralizer orders for cyclic subgroups (label 30130)
  
  orders
        element orders for cyclic subgroups (label 30140)
  
  fieldbases
        at  position  i  the Parker basis of the number field generated by the
        character values of the i-th cyclic subgroup. The length of fieldbases
        is equal to the value of label 30110 in MOC.
  
  cycsubgps
        cycsubgps[i]  =  j  means that class i of the GAP table belongs to the
        j-th cyclic subgroup of the GAP table,
  
  repcycsub
        repcycsub[j]  =  i  means  that  class  i  of  the  GAP  table  is the
        representative of the j-th cyclic subgroup of the GAP table. Note that
        the representatives of GAP table and MOC table need not agree!
  
  galconjinfo
        a list [ r_1, c_1, r_2, c_2, ..., r_n, c_n ] which means that the i-th
        class  of  the GAP table is the c_i-th conjugate of the representative
        of  the  r_i-th  cyclic  subgroup  on  the MOC table. (This is used to
        translate back to GAP format, stored under label 30160)
  
  30170
        (power  maps)  for  each  cyclic subgroup (except the trivial one) and
        each  prime  divisor  of  the  representative order store four values,
        namely the number of the subgroup, the power, the number of the cyclic
        subgroup   containing   the   image,   and  the  power  to  which  the
        representative  must be raised to yield the image class. (This is used
        only to construct the 30230 power map/embedding information.) In 30170
        only  a  list  of  lists  (one  for each cyclic subgroup) of all these
        values is stored, it will not be used by GAP.
  
  tensinfo
        tensor  product  information,  used to compute the coefficients of the
        Parker  base  for  tensor products of characters (label 30210 in MOC).
        For  a  field with vector space basis (v_1, v_2, ..., v_n), the tensor
        product  information  of a cyclic subgroup in MOC (as computed by fct)
        is either 1 (for rational classes) or a sequence
  
  
  n x_1,1 y_1,1 z_1,1 x_1,2 y_1,2 z_1,2 ... x_1,m_1 y_1,m_1 z_1,m_1 0 x_2,1 y_2,1 z_2,1 x_2,2 y_2,2 z_2,2 ... x_2,m_2 y_2,m_2 z_2,m_2 0 ... z_n,m_n 0
  
        which means that the coefficient of v_k in the product
  
  
  ( ∑_i=1^n a_i v_i ) ( ∑_j=1^n b_j v_j )
  
        is equal to
  
  
  ∑_i=1^m_k x_k,i a_y_k,i} b_z_k,i} .
  
        On a MOC table in GAP, the tensinfo component is a list of lists, each
        containing exactly the sequence mentioned above.
  
  invmap
        inverse  map  to  compute complex conjugate characters, label 30220 in
        MOC.
  
  powerinfo
        field  embeddings  for  p-th  symmetrizations,  p  a prime integer not
        larger than the largest element order, label 30230 in MOC.
  
  30900
        basic  set  of restricted ordinary irreducibles in the case of nonzero
        characteristic, all ordinary irreducibles otherwise.
  
  6.2-3 MOCString
  
  MOCString( moctbl[, chars] )  function
  
  Let moctbl be a MOC table record, as returned by MOCTable (6.2-2). MOCString
  returns a string describing the MOC 3 format of moctbl.
  
  If  a  second  argument  chars is specified, it must be a list of MOC format
  characters  as  returned by MOCChars (6.2-6). In this case, these characters
  are  stored  under  label  30900. If the second argument is missing then the
  basic set of ordinary irreducibles is stored under this label.
  
    Example  
    gap> moca5:= MOCTable( CharacterTable( "A5" ) );
    rec( 30170 := [ [  ], [ 2, 2, 1, 1 ], [ 3, 3, 1, 1 ], [ 4, 5, 1, 1 ] ]
        , 
      30900 := [ [ 1, 1, 1, 1, 0 ], [ 3, -1, 0, 0, -1 ], 
          [ 3, -1, 0, 1, 1 ], [ 4, 0, 1, -1, 0 ], [ 5, 1, -1, 0, 0 ] ], 
      GAPtbl := CharacterTable( "A5" ), centralizers := [ 60, 4, 3, 5 ], 
      cycsubgps := [ 1, 2, 3, 4, 4 ], 
      fieldbases := 
        [ CanonicalBasis( Rationals ), CanonicalBasis( Rationals ), 
          CanonicalBasis( Rationals ), 
          Basis( NF(5,[ 1, 4 ]), [ 1, E(5)+E(5)^4 ] ) ], fields := [  ], 
      galconjinfo := [ 1, 1, 2, 1, 3, 1, 4, 1, 4, 2 ], 
      identifier := "MOCTable(A5)", 
      invmap := [ [ 1, 1, 0 ], [ 1, 2, 0 ], [ 1, 3, 0 ], 
          [ 1, 4, 0, 1, 5, 0 ] ], orders := [ 1, 2, 3, 5 ], 
      powerinfo := 
        [ , 
          [ [ 1, 1, 0 ], [ 1, 1, 0 ], [ 1, 3, 0 ], 
              [ 1, 4, -1, 5, 0, -1, 5, 0 ] ], 
          [ [ 1, 1, 0 ], [ 1, 2, 0 ], [ 1, 1, 0 ], 
              [ 1, 4, -1, 5, 0, -1, 5, 0 ] ],, 
          [ [ 1, 1, 0 ], [ 1, 2, 0 ], [ 1, 3, 0 ], [ 1, 1, 0, 0 ] ] ], 
      prime := 0, repcycsub := [ 1, 2, 3, 4 ], 
      tensinfo := 
        [ [ 1 ], [ 1 ], [ 1 ], 
          [ 2, 1, 1, 1, 1, 2, 2, 0, 1, 1, 2, 1, 2, 1, -1, 2, 2, 0 ] ] )
    gap> str:= MOCString( moca5 );;
    gap> str{[1..68]};
    "y100y105ay110fey130t60edfy140bcdfy150bbbfcabbey160bbcbdbebecy170ccbb"
    gap> moca5mod3:= MOCTable( CharacterTable( "A5" ) mod 3, [ 1 .. 4 ] );;
    gap> MOCString( moca5mod3 ){ [ 1 .. 68 ] };
    "y100y105dy110edy130t60efy140bcfy150bbfcabbey160bbcbdbdcy170ccbbdfbby"
  
  
  6.2-4 ScanMOC
  
  ScanMOC( list )  function
  
  returns  a  record  containing the information encoded in the list list. The
  components  of  the  result are the labels that occur in list. If list is in
  MOC 2  format  (10000-format), the names of components are 30000-numbers; if
  it is in MOC 3 format the names of components have yABC-format.
  
  6.2-5 GAPChars
  
  GAPChars( tbl, mocchars )  function
  
  Let tbl be a character table or a MOC table record, and mocchars be either a
  list of MOC format characters (as returned by MOCChars (6.2-6)) or a list of
  positive  integers  such  as  a  record  component encoding characters, in a
  record produced by ScanMOC (6.2-4).
  
  GAPChars returns translations of mocchars to GAP character values lists.
  
  6.2-6 MOCChars
  
  MOCChars( tbl, gapchars )  function
  
  Let  tbl  be a character table or a MOC table record, and gapchars be a list
  of (GAP format) characters. MOCChars returns translations of gapchars to MOC
  format.
  
    Example  
    gap> scan:= ScanMOC( str );
    rec( y050 := [ 5, 1, 1, 0, 1, 2, 0, 1, 3, 0, 1, 1, 0, 0 ], 
      y105 := [ 0 ], y110 := [ 5, 4 ], y130 := [ 60, 4, 3, 5 ], 
      y140 := [ 1, 2, 3, 5 ], y150 := [ 1, 1, 1, 5, 2, 0, 1, 1, 4 ], 
      y160 := [ 1, 1, 2, 1, 3, 1, 4, 1, 4, 2 ], 
      y170 := [ 2, 2, 1, 1, 3, 3, 1, 1, 4, 5, 1, 1 ], 
      y210 := [ 1, 1, 1, 2, 1, 1, 1, 1, 2, 2, 0, 1, 1, 2, 1, 2, 1, -1, 2, 
          2, 0 ], y220 := [ 1, 1, 0, 1, 2, 0, 1, 3, 0, 1, 4, 0, 1, 5, 0 ],
      y230 := [ 2, 1, 1, 0, 1, 1, 0, 1, 3, 0, 1, 4, -1, 5, 0, -1, 5, 0 ], 
      y900 := [ 1, 1, 1, 1, 0, 3, -1, 0, 0, -1, 3, -1, 0, 1, 1, 4, 0, 1, 
          -1, 0, 5, 1, -1, 0, 0 ] )
    gap> gapchars:= GAPChars( moca5, scan.y900 );
    [ [ 1, 1, 1, 1, 1 ], [ 3, -1, 0, -E(5)-E(5)^4, -E(5)^2-E(5)^3 ], 
      [ 3, -1, 0, -E(5)^2-E(5)^3, -E(5)-E(5)^4 ], [ 4, 0, 1, -1, -1 ], 
      [ 5, 1, -1, 0, 0 ] ]
    gap> mocchars:= MOCChars( moca5, gapchars );
    [ [ 1, 1, 1, 1, 0 ], [ 3, -1, 0, 0, -1 ], [ 3, -1, 0, 1, 1 ], 
      [ 4, 0, 1, -1, 0 ], [ 5, 1, -1, 0, 0 ] ]
    gap> Concatenation( mocchars ) = scan.y900;
    true
  
  
  
  6.3 Interface to GAP 3
  
  The following functions are used to read and write character tables in GAP 3
  format.
  
  6.3-1 GAP3CharacterTableScan
  
  GAP3CharacterTableScan( string )  function
  
  Let  string  be  a  string  that  contains  the output of the GAP 3 function
  PrintCharTable.  In  other  words,  string  describes  a  GAP  record  whose
  components   define   an   ordinary   character   table   object  in  GAP 3.
  GAP3CharacterTableScan  returns  the  corresponding  GAP 4  character  table
  object.
  
  The supported record components are given by the list GAP3CharacterTableData
  (6.3-3).
  
  6.3-2 GAP3CharacterTableString
  
  GAP3CharacterTableString( tbl )  function
  
  For  an  ordinary  character  table  tbl, GAP3CharacterTableString returns a
  string   that   when   read  into  GAP 3  evaluates  to  a  character  table
  corresponding  to  tbl.  A  similar  format is printed by the GAP 3 function
  PrintCharTable.
  
  The supported record components are given by the list GAP3CharacterTableData
  (6.3-3).
  
    Example  
    gap> tbl:= CharacterTable( "Alternating", 5 );;
    gap> str:= GAP3CharacterTableString( tbl );;
    gap> Print( str );
    rec(
    centralizers := [ 60, 4, 3, 5, 5 ],
    fusions := [ rec( map := [ 1, 3, 4, 7, 7 ], name := "Sym(5)" ) ],
    identifier := "Alt(5)",
    irreducibles := [
    [ 1, 1, 1, 1, 1 ],
    [ 4, 0, 1, -1, -1 ],
    [ 5, 1, -1, 0, 0 ],
    [ 3, -1, 0, -E(5)-E(5)^4, -E(5)^2-E(5)^3 ],
    [ 3, -1, 0, -E(5)^2-E(5)^3, -E(5)-E(5)^4 ]
    ],
    orders := [ 1, 2, 3, 5, 5 ],
    powermap := [ , [ 1, 1, 3, 5, 4 ], [ 1, 2, 1, 5, 4 ], , [ 1, 2, 3, 1, \
    1 ] ],
    size := 60,
    text := "computed using generic character table for alternating groups\
    ",
    operations := CharTableOps )
    gap> scan:= GAP3CharacterTableScan( str );
    CharacterTable( "Alt(5)" )
    gap> TransformingPermutationsCharacterTables( tbl, scan );
    rec( columns := (), group := Group([ (4,5) ]), rows := () )
  
  
  6.3-3 GAP3CharacterTableData
  
  GAP3CharacterTableData  global variable
  
  This  is a list of pairs, the first entry being the name of a component in a
  GAP 3 character table and the second entry being the corresponding attribute
  name  in  GAP 4.  The variable is used by GAP3CharacterTableScan (6.3-1) and
  GAP3CharacterTableString (6.3-2).
  
  
  6.4 Interface to the Cambridge Format
  
  The  following  functions deal with the so-called Cambridge format, in which
  the   source   data   of  the  character  tables  in  the  Atlas  of  Finite
  Groups [CCN+85]  and  in the Atlas of Brauer Characters [JLPW95] are stored.
  Each  such  table is stored on a file of its own. The line length is at most
  78,  and  each  item  of  the  table starts in a new line, behind one of the
  following prefixes.
  
  #23
        a description and the name(s) of the simple group
  
  #7
        integers describing the column widths
  
  #9
        the  symbols ; and @, denoting columns between tables and columns that
        belong to conjugacy classes, respectively
  
  #1
        the  symbol  |  in  columns  between  tables,  and  centralizer orders
        otherwise
  
  #2
        the  symbols p (in the first column only), power (in the second column
        only,  which belongs to the class of the identity element), | in other
        columns  between  tables,  and  descriptions  of the powers of classes
        otherwise
  
  #3
        the  symbols p' (in the first column only), part (in the second column
        only,  which belongs to the class of the identity element), | in other
        columns  between  tables,  and  descriptions  of  the p-prime parts of
        classes otherwise
  
  #4
        the  symbols  ind  and  fus in columns between tables, and class names
        otherwise
  
  #5
        either | or strings composed from the symbols +, -, o, and integers in
        columns  where  the lines starting with #4 contain ind; the symbols :,
        .,  ?  in columns where these lines contain fus; character values or |
        otherwise
  
  #6
        the symbols |, ind, and, and fus in columns between tables; the symbol
        |  and  element  orders  of  preimage  classes  in downward extensions
        otherwise
  
  #8
        the last line of the data, may contain the date of the last change
  
  #C
        comments.
  
  6.4-1 CambridgeMaps
  
  CambridgeMaps( tbl )  function
  
  For a character table tbl, CambridgeMaps returns a record with the following
  components.
  
  names
        a list of strings denoting class names,
  
  power
        a  list of strings, the i-th entry encodes the p-th powers of the i-th
        class, for all prime divisors p of the group order,
  
  prime
        a  list  of  strings,  the i-th entry encodes the p-prime parts of the
        i-th class, for all prime divisors p of the group order.
  
  The  meaning  of  the entries of the lists is defined in [CCN+85, Chapter 7,
  Sections 3–5]).
  
  CambridgeMaps  is  used  for  example  by  Display (Reference: Display for a
  character table) in the case that the powermap option has the value "ATLAS".
  
  Note  that  the value of the names component may differ from the class names
  of  the  character  table shown in the Atlas of Finite Groups; an example is
  the character table of the group J_1.
  
    Example  
    gap> CambridgeMaps( CharacterTable( "A5" ) );
    rec( names := [ "1A", "2A", "3A", "5A", "B*" ], 
      power := [ "", "A", "A", "A", "A" ], 
      prime := [ "", "A", "A", "A", "A" ] )
    gap> CambridgeMaps( CharacterTable( "A5" ) mod 2 );
    rec( names := [ "1A", "3A", "5A", "B*" ], 
      power := [ "", "A", "A", "A" ], prime := [ "", "A", "A", "A" ] )
  
  
  6.4-2 StringOfCambridgeFormat
  
  StringOfCambridgeFormat( tblnames[, p] )  function
  
  Let  tblnames be a matrix of identifiers of ordinary character tables, which
  describe  the bicyclic extensions of a simple group from the Atlas of Finite
  Groups. The class fusions between the character tables must be stored on the
  tables.
  
  If  the  required  information  is  available  then  StringOfCambridgeFormat
  returns  a string that encodes an approximation of the Cambridge format file
  for  the simple group in question (whose identifier occurs in the upper left
  corner  of  tblnames).  Otherwise, that is, if some character table or class
  fusion is missing, fail is returned.
  
  If a prime integer p is given as a second argument then the result describes
  p-modular  character  tables,  otherwise  the  ordinary character tables are
  described by the result.
  
  Differences  to  the  original  format  may  occur  for irrational character
  values;  the  descriptions of these values have been chosen deliberately for
  the original files, it is not obvious how to compute these descriptions from
  the character tables in question.
  
    Example  
    gap> str:= StringOfCambridgeFormat( [ [   "A5",   "A5.2" ],
    >                                     [ "2.A5", "2.A5.2" ] ] );;
    gap> Print( str );
    #23 ? A5
    #7 4 4 4 4 4 4 4 4 4 4 4 
    #9 ; @ @ @ @ @ ; ; @ @ @ 
    #1 | 60 4 3 5 5 | | 6 2 3 
    #2 p power A A A A | | A A AB 
    #3 p' part A A A A | | A A AB 
    #4 ind 1A 2A 3A 5A B* fus ind 2B 4A 6A 
    #5 + 1 1 1 1 1 : ++ 1 1 1 
    #5 + 3 -1 0 -b5 * . + 0 0 0 
    #5 + 3 -1 0 * -b5 . | | | | 
    #5 + 4 0 1 -1 -1 : ++ 2 0 -1 
    #5 + 5 1 -1 0 0 : ++ 1 -1 1 
    #6 ind 1 4 3 5 5 fus ind 2 8 6 
    #6 | 2 | 6 10 10 | | | 8 6 
    #5 - 2 0 -1 b5 * . - 0 0 0 
    #5 - 2 0 -1 * b5 . | | | | 
    #5 - 4 0 1 -1 -1 : oo 0 0 i3 
    #5 - 6 0 0 1 1 : oo 0 i2 0 
    #8
    gap> str:= StringOfCambridgeFormat( [ [   "A5",   "A5.2" ],
    >                                     [ "2.A5", "2.A5.2" ] ], 3 );;
    gap> Print( str );
    #23 A5 (Mod 3)
    #7 4 4 4 4 4 4 4 4 4 
    #9 ; @ @ @ @ ; ; @ @ 
    #1 | 60 4 5 5 | | 6 2 
    #2 p power A A A | | A A 
    #3 p' part A A A | | A A 
    #4 ind 1A 2A 5A B* fus ind 2B 4A 
    #5 + 1 1 1 1 : ++ 1 1 
    #5 + 3 -1 -b5 * . + 0 0 
    #5 + 3 -1 * -b5 . | | | 
    #5 + 4 0 -1 -1 : ++ 2 0 
    #6 ind 1 4 5 5 fus ind 2 8 
    #6 | 2 | 10 10 | | | 8 
    #5 - 2 0 b5 * . - 0 0 
    #5 - 2 0 * b5 . | | | 
    #5 - 6 0 1 1 : oo 0 i2 
    #8
    gap> StringOfCambridgeFormat( [ [ "L10(11)" ] ], 0 );
    fail
  
  
  The global option OmitDashedRows can be used to control whether the two-line
  description  of  dashed row portions (concerning tables of, e. g., 2'.Sz(8))
  are  omitted  (value  true)  or  shown (value false). The default is to show
  information about dashed row portions in the case of ordinary tables, and to
  omit this information for Brauer tables.
  
  
  6.5 Interface to the MAGMA System
  
  This  interface  is  intended  to  convert character tables given in MAGMA's
  (see [CP96]) display format into GAP character tables.
  
  The  function  BosmaBase  (6.5-1)  is used for the translation of irrational
  values;  this  function  may be of interest independent of the conversion of
  character tables.
  
  6.5-1 BosmaBase
  
  BosmaBase( n )  function
  
  For  a  positive  integer  n  that is not congruent to 2 modulo 4, BosmaBase
  returns  the  list  of exponents i for which E(n)^i belongs to the canonical
  basis of the n-th cyclotomic field that is defined in [Bos90, Section 5].
  
  As  a  set,  this basis is defined as follows. Let P denote the set of prime
  divisors of n and n = ∏_{p ∈ P} n_p. Let e_l = E(l) for any positive integer
  l,  and  {  e_{m_1}^j  }_{j  ∈  J}  ⊗  { e_{m_2}^k }_{k ∈ K} = { e_{m_1}^j ⋅
  e_{m_2}^k  }_{j  ∈  J,  k  ∈  K}  for  any positive integers m_1, m_2. (This
  notation  is  the  same  as the one used in the description of ZumbroichBase
  (Reference: ZumbroichBase).)
  
  Then the basis is
  
  
  B_n = ⨂_{p ∈ P} B_{n_p}
  
  where
  
  
  B_{n_p} = { e_{n_p}^k; 0 ≤ k ≤ φ(n_p)-1 };
  
  here [122φX denotes Euler's function, see Phi (Reference: Phi).
  
  B_n  consists  of  roots of unity, it is an integral basis (that is, exactly
  the   integral  elements  in  ℚ_n  have  integral  coefficients  w.r.t.[22 XB_n,
  cf.[2 XIsIntegralCyclotomic  (Reference:  IsIntegralCyclotomic)),  and  for any
  divisor m of n that is not congruent to 2 modulo 4, B_m is a subset of B_n.
  
  Note that the list l, say, that is returned by BosmaBase is in general not a
  set.  The  ordering  of  the elements in l fits to the coefficient lists for
  irrational values used by MAGMA's display format.
  
    Example  
    gap> b:= BosmaBase( 8 );
    [ 0, 1, 2, 3 ]
    gap> b:= Basis( CF(8), List( b, i -> E(8)^i ) );
    Basis( CF(8), [ 1, E(8), E(4), E(8)^3 ] )
    gap> Coefficients( b, Sqrt(2) );
    [ 0, 1, 0, -1 ]
    gap> Coefficients( b, Sqrt(-2) );
    [ 0, 1, 0, 1 ]
    gap> b:= BosmaBase( 15 );
    [ 0, 5, 3, 8, 6, 11, 9, 14 ]
    gap> b:= List( b, i -> E(15)^i );
    [ 1, E(3), E(5), E(15)^8, E(5)^2, E(15)^11, E(5)^3, E(15)^14 ]
    gap> Coefficients( Basis( CF(15), b ), EB(15) );
    [ -1, -1, 0, 0, -1, -2, -1, -2 ]
    gap> BosmaBase( 48 );
    [ 0, 3, 6, 9, 12, 15, 18, 21, 16, 19, 22, 25, 28, 31, 34, 37 ]
  
  
  6.5-2 GAPTableOfMagmaFile
  
  GAPTableOfMagmaFile( file, identifier )  function
  GAPTableOfMagmaFile( str, identifier[, "string"] )  function
  
  In  the first form, let file be the name of a file that contains a character
  table   in   MAGMA's   display   format,   and   identifier   be  a  string.
  GAPTableOfMagmaFile  returns  the  corresponding  GAP  character table, with
  Identifier (Reference: Identifier for tables of marks) value identifier.
  
  In  the  second  form, str must be a string that describes the contents of a
  file  as  described  for  the first form, and the third argument must be the
  string "string".
  
    Example  
    gap> tmpdir:= DirectoryTemporary();;
    gap> file:= Filename( tmpdir, "magmatable" );;
    gap> str:= "\
    > Character Table of Group G\n\
    > --------------------------\n\
    > \n\
    > ---------------------------\n\
    > Class |   1  2  3    4    5\n\
    > Size  |   1 15 20   12   12\n\
    > Order |   1  2  3    5    5\n\
    > ---------------------------\n\
    > p  =  2   1  1  3    5    4\n\
    > p  =  3   1  2  1    5    4\n\
    > p  =  5   1  2  3    1    1\n\
    > ---------------------------\n\
    > X.1   +   1  1  1    1    1\n\
    > X.2   +   3 -1  0   Z1 Z1#2\n\
    > X.3   +   3 -1  0 Z1#2   Z1\n\
    > X.4   +   4  0  1   -1   -1\n\
    > X.5   +   5  1 -1    0    0\n\
    > \n\
    > Explanation of Character Value Symbols\n\
    > --------------------------------------\n\
    > \n\
    > # denotes algebraic conjugation, that is,\n\
    > #k indicates replacing the root of unity w by w^k\n\
    > \n\
    > Z1     = (CyclotomicField(5: Sparse := true)) ! [\n\
    > RationalField() | 1, 0, 1, 1 ]\n\
    > ";;
    gap> FileString( file, str );;
    gap> tbl:= GAPTableOfMagmaFile( file, "MagmaA5" );;
    gap> Display( tbl );
    MagmaA5
    
         2  2  2  .  .  .
         3  1  .  1  .  .
         5  1  .  .  1  1
    
           1a 2a 3a 5a 5b
        2P 1a 1a 3a 5b 5a
        3P 1a 2a 1a 5b 5a
        5P 1a 2a 3a 1a 1a
    
    X.1     1  1  1  1  1
    X.2     3 -1  .  A *A
    X.3     3 -1  . *A  A
    X.4     4  .  1 -1 -1
    X.5     5  1 -1  .  .
    
    A = -E(5)-E(5)^4
      = (1-Sqrt(5))/2 = -b5
    gap> tbl2:= GAPTableOfMagmaFile( str, "MagmaA5", "string" );;
    gap> Irr( tbl ) = Irr( tbl2 );
    true
    gap> str:= "\
    > Character Table of Group G\n\
    > --------------------------\n\
    > \n\
    > ------------------------------\n\
    > Class |   1  2   3   4   5   6\n\
    > Size  |   1  1   1   1   1   1\n\
    > Order |   1  2   3   3   6   6\n\
    > ------------------------------\n\
    > p  =  2   1  1   4   3   3   4\n\
    > p  =  3   1  2   1   1   2   2\n\
    > ------------------------------\n\
    > X.1   +   1  1   1   1   1   1\n\
    > X.2   +   1 -1   1   1  -1  -1\n\
    > X.3   0   1  1   J-1-J-1-J   J\n\
    > X.4   0   1 -1   J-1-J 1+J  -J\n\
    > X.5   0   1  1-1-J   J   J-1-J\n\
    > X.6   0   1 -1-1-J   J  -J 1+J\n\
    > \n\
    > \n\
    > Explanation of Character Value Symbols\n\
    > --------------------------------------\n\
    > \n\
    > J = RootOfUnity(3)\n\
    > ";;
    gap> FileString( file, str );;
    gap> tbl:= GAPTableOfMagmaFile( file, "MagmaC6" );;
    gap> Display( tbl );
    MagmaC6
    
         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  3a  3b
        3P 1a 2a 1a 1a  2a  2a
    
    X.1     1  1  1  1   1   1
    X.2     1 -1  1  1  -1  -1
    X.3     1  1  A /A  /A   A
    X.4     1 -1  A /A -/A  -A
    X.5     1  1 /A  A   A  /A
    X.6     1 -1 /A  A  -A -/A
    
    A = E(3)
      = (-1+Sqrt(-3))/2 = b3
  
  
  The  MAGMA  output  for  the above two examples is obtained by the following
  commands.
  
    Example  
    > G1 := Alt(5);
    > CT1 := CharacterTable(G1);
    > CT1;
    > G2:= CyclicGroup(6);
    > CT2:= CharacterTable(G2);
    > CT2;
  
  
  6.5-3 CharacterTableComputedByMagma
  
  CharacterTableComputedByMagma( G, identifier )  function
  
  For     a     permutation    group    G    and    a    string    identifier,
  CharacterTableComputedByMagma  calls  the  MAGMA  system  for  computing the
  character  table  of  G,  and  converts  the  output  into  GAP  format (see
  GAPTableOfMagmaFile   (6.5-2)).   The   returned  character  table  has  the
  Identifier (Reference: Identifier for tables of marks) value identifier.
  
  If the MAGMA system is not available then fail is returned. The availability
  of  MAGMA  is  determined  by  calling MAGMA where the path for this call is
  given  by the user preference MagmaPath of the package CTblLib; if the value
  of  this preference is empty or if MAGMA cannot be called via this path then
  MAGMA is regarded as not available.
  
  If the attribute ConjugacyClasses (Reference: ConjugacyClasses attribute) of
  G  is  set before the call of CharacterTableComputedByMagma then the columns
  of the returned character table fit to the conjugacy classes that are stored
  in G.
  
    Example  
    gap> if CTblLib.IsMagmaAvailable() then
    >      g:= MathieuGroup( 24 );
    >      ccl:= ConjugacyClasses( g );
    >      t:= CharacterTableComputedByMagma( g, "testM24" );
    >      if t = fail then
    >        Print( "#E  Magma did not compute a character table.\n" );
    >      elif ( not HasConjugacyClasses( t ) ) or
    >           ( ConjugacyClasses( t ) <> ccl ) then
    >        Print( "#E  The conjugacy classes do not fit.\n" );
    >      elif TransformingPermutationsCharacterTables( t,
    >               CharacterTable( "M24" ) ) = fail then
    >        Print( "#E  Inconsistency of character tables?\n" );
    >      fi;
    >    fi;
  
  

Generated by dwww version 1.15 on Sun Jun 23 03:46:32 CEST 2024.